From 603ca2653eed55e6ed7d25d6e048ccc24e54a8a0 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Wed, 8 Apr 2026 13:58:56 -0400 Subject: [PATCH 1/7] custom bike code --- notebooks/bike_flow_map.widget.js | 48639 +++++++++++++++++++++++++++ notebooks/bike_flow_map_widget.mjs | 726 + 2 files changed, 49365 insertions(+) create mode 100644 notebooks/bike_flow_map.widget.js create mode 100644 notebooks/bike_flow_map_widget.mjs diff --git a/notebooks/bike_flow_map.widget.js b/notebooks/bike_flow_map.widget.js new file mode 100644 index 000000000..c7ed42827 --- /dev/null +++ b/notebooks/bike_flow_map.widget.js @@ -0,0 +1,48639 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod2) => function __require() { + return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports; +}; +var __export = (target, all) => { + for (var name2 in all) + __defProp(target, name2, { get: all[name2], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, + mod2 +)); + +// node_modules/hammerjs/hammer.js +var require_hammer = __commonJS({ + "node_modules/hammerjs/hammer.js"(exports, module) { + (function(window2, document2, exportName, undefined2) { + "use strict"; + var VENDOR_PREFIXES = ["", "webkit", "Moz", "MS", "ms", "o"]; + var TEST_ELEMENT = document2.createElement("div"); + var TYPE_FUNCTION = "function"; + var round12 = Math.round; + var abs = Math.abs; + var now = Date.now; + function setTimeoutContext(fn, timeout, context) { + return setTimeout(bindFn(fn, context), timeout); + } + function invokeArrayArg(arg, fn, context) { + if (Array.isArray(arg)) { + each(arg, context[fn], context); + return true; + } + return false; + } + function each(obj, iterator, context) { + var i; + if (!obj) { + return; + } + if (obj.forEach) { + obj.forEach(iterator, context); + } else if (obj.length !== undefined2) { + i = 0; + while (i < obj.length) { + iterator.call(context, obj[i], i, obj); + i++; + } + } else { + for (i in obj) { + obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj); + } + } + } + function deprecate(method, name2, message2) { + var deprecationMessage = "DEPRECATED METHOD: " + name2 + "\n" + message2 + " AT \n"; + return function() { + var e = new Error("get-stack-trace"); + var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace"; + var log4 = window2.console && (window2.console.warn || window2.console.log); + if (log4) { + log4.call(window2.console, deprecationMessage, stack); + } + return method.apply(this, arguments); + }; + } + var assign; + if (typeof Object.assign !== "function") { + assign = function assign2(target) { + if (target === undefined2 || target === null) { + throw new TypeError("Cannot convert undefined or null to object"); + } + var output = Object(target); + for (var index2 = 1; index2 < arguments.length; index2++) { + var source = arguments[index2]; + if (source !== undefined2 && source !== null) { + for (var nextKey in source) { + if (source.hasOwnProperty(nextKey)) { + output[nextKey] = source[nextKey]; + } + } + } + } + return output; + }; + } else { + assign = Object.assign; + } + var extend = deprecate(function extend2(dest, src, merge2) { + var keys = Object.keys(src); + var i = 0; + while (i < keys.length) { + if (!merge2 || merge2 && dest[keys[i]] === undefined2) { + dest[keys[i]] = src[keys[i]]; + } + i++; + } + return dest; + }, "extend", "Use `assign`."); + var merge = deprecate(function merge2(dest, src) { + return extend(dest, src, true); + }, "merge", "Use `assign`."); + function inherit(child, base, properties) { + var baseP = base.prototype, childP; + childP = child.prototype = Object.create(baseP); + childP.constructor = child; + childP._super = baseP; + if (properties) { + assign(childP, properties); + } + } + function bindFn(fn, context) { + return function boundFn() { + return fn.apply(context, arguments); + }; + } + function boolOrFn(val, args) { + if (typeof val == TYPE_FUNCTION) { + return val.apply(args ? args[0] || undefined2 : undefined2, args); + } + return val; + } + function ifUndefined(val1, val2) { + return val1 === undefined2 ? val2 : val1; + } + function addEventListeners(target, types, handler) { + each(splitStr(types), function(type) { + target.addEventListener(type, handler, false); + }); + } + function removeEventListeners(target, types, handler) { + each(splitStr(types), function(type) { + target.removeEventListener(type, handler, false); + }); + } + function hasParent(node, parent) { + while (node) { + if (node == parent) { + return true; + } + node = node.parentNode; + } + return false; + } + function inStr(str10, find) { + return str10.indexOf(find) > -1; + } + function splitStr(str10) { + return str10.trim().split(/\s+/g); + } + function inArray(src, find, findByKey) { + if (src.indexOf && !findByKey) { + return src.indexOf(find); + } else { + var i = 0; + while (i < src.length) { + if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) { + return i; + } + i++; + } + return -1; + } + } + function toArray(obj) { + return Array.prototype.slice.call(obj, 0); + } + function uniqueArray(src, key, sort) { + var results = []; + var values = []; + var i = 0; + while (i < src.length) { + var val = key ? src[i][key] : src[i]; + if (inArray(values, val) < 0) { + results.push(src[i]); + } + values[i] = val; + i++; + } + if (sort) { + if (!key) { + results = results.sort(); + } else { + results = results.sort(function sortUniqueArray(a, b) { + return a[key] > b[key]; + }); + } + } + return results; + } + function prefixed(obj, property) { + var prefix, prop; + var camelProp = property[0].toUpperCase() + property.slice(1); + var i = 0; + while (i < VENDOR_PREFIXES.length) { + prefix = VENDOR_PREFIXES[i]; + prop = prefix ? prefix + camelProp : property; + if (prop in obj) { + return prop; + } + i++; + } + return undefined2; + } + var _uniqueId = 1; + function uniqueId() { + return _uniqueId++; + } + function getWindowForElement(element) { + var doc = element.ownerDocument || element; + return doc.defaultView || doc.parentWindow || window2; + } + var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i; + var SUPPORT_TOUCH = "ontouchstart" in window2; + var SUPPORT_POINTER_EVENTS = prefixed(window2, "PointerEvent") !== undefined2; + var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent); + var INPUT_TYPE_TOUCH = "touch"; + var INPUT_TYPE_PEN = "pen"; + var INPUT_TYPE_MOUSE = "mouse"; + var INPUT_TYPE_KINECT = "kinect"; + var COMPUTE_INTERVAL = 25; + var INPUT_START2 = 1; + var INPUT_MOVE2 = 2; + var INPUT_END2 = 4; + var INPUT_CANCEL = 8; + var DIRECTION_NONE = 1; + var DIRECTION_LEFT = 2; + var DIRECTION_RIGHT = 4; + var DIRECTION_UP = 8; + var DIRECTION_DOWN = 16; + var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT; + var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN; + var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL; + var PROPS_XY = ["x", "y"]; + var PROPS_CLIENT_XY = ["clientX", "clientY"]; + function Input2(manager, callback) { + var self2 = this; + this.manager = manager; + this.callback = callback; + this.element = manager.element; + this.target = manager.options.inputTarget; + this.domHandler = function(ev) { + if (boolOrFn(manager.options.enable, [manager])) { + self2.handler(ev); + } + }; + this.init(); + } + Input2.prototype = { + /** + * should handle the inputEvent data and trigger the callback + * @virtual + */ + handler: function() { + }, + /** + * bind the events + */ + init: function() { + this.evEl && addEventListeners(this.element, this.evEl, this.domHandler); + this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler); + this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); + }, + /** + * unbind the events + */ + destroy: function() { + this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler); + this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler); + this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); + } + }; + function createInputInstance(manager) { + var Type2; + var inputClass = manager.options.inputClass; + if (inputClass) { + Type2 = inputClass; + } else if (SUPPORT_POINTER_EVENTS) { + Type2 = PointerEventInput2; + } else if (SUPPORT_ONLY_TOUCH) { + Type2 = TouchInput; + } else if (!SUPPORT_TOUCH) { + Type2 = MouseInput2; + } else { + Type2 = TouchMouseInput; + } + return new Type2(manager, inputHandler); + } + function inputHandler(manager, eventType, input) { + var pointersLen = input.pointers.length; + var changedPointersLen = input.changedPointers.length; + var isFirst = eventType & INPUT_START2 && pointersLen - changedPointersLen === 0; + var isFinal = eventType & (INPUT_END2 | INPUT_CANCEL) && pointersLen - changedPointersLen === 0; + input.isFirst = !!isFirst; + input.isFinal = !!isFinal; + if (isFirst) { + manager.session = {}; + } + input.eventType = eventType; + computeInputData(manager, input); + manager.emit("hammer.input", input); + manager.recognize(input); + manager.session.prevInput = input; + } + function computeInputData(manager, input) { + var session = manager.session; + var pointers = input.pointers; + var pointersLength = pointers.length; + if (!session.firstInput) { + session.firstInput = simpleCloneInputData(input); + } + if (pointersLength > 1 && !session.firstMultiple) { + session.firstMultiple = simpleCloneInputData(input); + } else if (pointersLength === 1) { + session.firstMultiple = false; + } + var firstInput = session.firstInput; + var firstMultiple = session.firstMultiple; + var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center; + var center = input.center = getCenter(pointers); + input.timeStamp = now(); + input.deltaTime = input.timeStamp - firstInput.timeStamp; + input.angle = getAngle(offsetCenter, center); + input.distance = getDistance(offsetCenter, center); + computeDeltaXY(session, input); + input.offsetDirection = getDirection(input.deltaX, input.deltaY); + var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY); + input.overallVelocityX = overallVelocity.x; + input.overallVelocityY = overallVelocity.y; + input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y; + input.scale = firstMultiple ? getScale2(firstMultiple.pointers, pointers) : 1; + input.rotation = firstMultiple ? getRotation4(firstMultiple.pointers, pointers) : 0; + input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers; + computeIntervalInputData(session, input); + var target = manager.element; + if (hasParent(input.srcEvent.target, target)) { + target = input.srcEvent.target; + } + input.target = target; + } + function computeDeltaXY(session, input) { + var center = input.center; + var offset = session.offsetDelta || {}; + var prevDelta = session.prevDelta || {}; + var prevInput = session.prevInput || {}; + if (input.eventType === INPUT_START2 || prevInput.eventType === INPUT_END2) { + prevDelta = session.prevDelta = { + x: prevInput.deltaX || 0, + y: prevInput.deltaY || 0 + }; + offset = session.offsetDelta = { + x: center.x, + y: center.y + }; + } + input.deltaX = prevDelta.x + (center.x - offset.x); + input.deltaY = prevDelta.y + (center.y - offset.y); + } + function computeIntervalInputData(session, input) { + var last = session.lastInterval || input, deltaTime = input.timeStamp - last.timeStamp, velocity, velocityX, velocityY, direction; + if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined2)) { + var deltaX = input.deltaX - last.deltaX; + var deltaY = input.deltaY - last.deltaY; + var v = getVelocity(deltaTime, deltaX, deltaY); + velocityX = v.x; + velocityY = v.y; + velocity = abs(v.x) > abs(v.y) ? v.x : v.y; + direction = getDirection(deltaX, deltaY); + session.lastInterval = input; + } else { + velocity = last.velocity; + velocityX = last.velocityX; + velocityY = last.velocityY; + direction = last.direction; + } + input.velocity = velocity; + input.velocityX = velocityX; + input.velocityY = velocityY; + input.direction = direction; + } + function simpleCloneInputData(input) { + var pointers = []; + var i = 0; + while (i < input.pointers.length) { + pointers[i] = { + clientX: round12(input.pointers[i].clientX), + clientY: round12(input.pointers[i].clientY) + }; + i++; + } + return { + timeStamp: now(), + pointers, + center: getCenter(pointers), + deltaX: input.deltaX, + deltaY: input.deltaY + }; + } + function getCenter(pointers) { + var pointersLength = pointers.length; + if (pointersLength === 1) { + return { + x: round12(pointers[0].clientX), + y: round12(pointers[0].clientY) + }; + } + var x = 0, y = 0, i = 0; + while (i < pointersLength) { + x += pointers[i].clientX; + y += pointers[i].clientY; + i++; + } + return { + x: round12(x / pointersLength), + y: round12(y / pointersLength) + }; + } + function getVelocity(deltaTime, x, y) { + return { + x: x / deltaTime || 0, + y: y / deltaTime || 0 + }; + } + function getDirection(x, y) { + if (x === y) { + return DIRECTION_NONE; + } + if (abs(x) >= abs(y)) { + return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT; + } + return y < 0 ? DIRECTION_UP : DIRECTION_DOWN; + } + function getDistance(p1, p2, props) { + if (!props) { + props = PROPS_XY; + } + var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]]; + return Math.sqrt(x * x + y * y); + } + function getAngle(p1, p2, props) { + if (!props) { + props = PROPS_XY; + } + var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]]; + return Math.atan2(y, x) * 180 / Math.PI; + } + function getRotation4(start, end) { + return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY); + } + function getScale2(start, end) { + return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY); + } + var MOUSE_INPUT_MAP2 = { + mousedown: INPUT_START2, + mousemove: INPUT_MOVE2, + mouseup: INPUT_END2 + }; + var MOUSE_ELEMENT_EVENTS = "mousedown"; + var MOUSE_WINDOW_EVENTS = "mousemove mouseup"; + function MouseInput2() { + this.evEl = MOUSE_ELEMENT_EVENTS; + this.evWin = MOUSE_WINDOW_EVENTS; + this.pressed = false; + Input2.apply(this, arguments); + } + inherit(MouseInput2, Input2, { + /** + * handle mouse events + * @param {Object} ev + */ + handler: function MEhandler(ev) { + var eventType = MOUSE_INPUT_MAP2[ev.type]; + if (eventType & INPUT_START2 && ev.button === 0) { + this.pressed = true; + } + if (eventType & INPUT_MOVE2 && ev.which !== 1) { + eventType = INPUT_END2; + } + if (!this.pressed) { + return; + } + if (eventType & INPUT_END2) { + this.pressed = false; + } + this.callback(this.manager, eventType, { + pointers: [ev], + changedPointers: [ev], + pointerType: INPUT_TYPE_MOUSE, + srcEvent: ev + }); + } + }); + var POINTER_INPUT_MAP = { + pointerdown: INPUT_START2, + pointermove: INPUT_MOVE2, + pointerup: INPUT_END2, + pointercancel: INPUT_CANCEL, + pointerout: INPUT_CANCEL + }; + var IE10_POINTER_TYPE_ENUM = { + 2: INPUT_TYPE_TOUCH, + 3: INPUT_TYPE_PEN, + 4: INPUT_TYPE_MOUSE, + 5: INPUT_TYPE_KINECT + // see https://twitter.com/jacobrossi/status/480596438489890816 + }; + var POINTER_ELEMENT_EVENTS = "pointerdown"; + var POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel"; + if (window2.MSPointerEvent && !window2.PointerEvent) { + POINTER_ELEMENT_EVENTS = "MSPointerDown"; + POINTER_WINDOW_EVENTS = "MSPointerMove MSPointerUp MSPointerCancel"; + } + function PointerEventInput2() { + this.evEl = POINTER_ELEMENT_EVENTS; + this.evWin = POINTER_WINDOW_EVENTS; + Input2.apply(this, arguments); + this.store = this.manager.session.pointerEvents = []; + } + inherit(PointerEventInput2, Input2, { + /** + * handle mouse events + * @param {Object} ev + */ + handler: function PEhandler(ev) { + var store = this.store; + var removePointer = false; + var eventTypeNormalized = ev.type.toLowerCase().replace("ms", ""); + var eventType = POINTER_INPUT_MAP[eventTypeNormalized]; + var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType; + var isTouch = pointerType == INPUT_TYPE_TOUCH; + var storeIndex = inArray(store, ev.pointerId, "pointerId"); + if (eventType & INPUT_START2 && (ev.button === 0 || isTouch)) { + if (storeIndex < 0) { + store.push(ev); + storeIndex = store.length - 1; + } + } else if (eventType & (INPUT_END2 | INPUT_CANCEL)) { + removePointer = true; + } + if (storeIndex < 0) { + return; + } + store[storeIndex] = ev; + this.callback(this.manager, eventType, { + pointers: store, + changedPointers: [ev], + pointerType, + srcEvent: ev + }); + if (removePointer) { + store.splice(storeIndex, 1); + } + } + }); + var SINGLE_TOUCH_INPUT_MAP = { + touchstart: INPUT_START2, + touchmove: INPUT_MOVE2, + touchend: INPUT_END2, + touchcancel: INPUT_CANCEL + }; + var SINGLE_TOUCH_TARGET_EVENTS = "touchstart"; + var SINGLE_TOUCH_WINDOW_EVENTS = "touchstart touchmove touchend touchcancel"; + function SingleTouchInput() { + this.evTarget = SINGLE_TOUCH_TARGET_EVENTS; + this.evWin = SINGLE_TOUCH_WINDOW_EVENTS; + this.started = false; + Input2.apply(this, arguments); + } + inherit(SingleTouchInput, Input2, { + handler: function TEhandler(ev) { + var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; + if (type === INPUT_START2) { + this.started = true; + } + if (!this.started) { + return; + } + var touches = normalizeSingleTouches.call(this, ev, type); + if (type & (INPUT_END2 | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) { + this.started = false; + } + this.callback(this.manager, type, { + pointers: touches[0], + changedPointers: touches[1], + pointerType: INPUT_TYPE_TOUCH, + srcEvent: ev + }); + } + }); + function normalizeSingleTouches(ev, type) { + var all = toArray(ev.touches); + var changed = toArray(ev.changedTouches); + if (type & (INPUT_END2 | INPUT_CANCEL)) { + all = uniqueArray(all.concat(changed), "identifier", true); + } + return [all, changed]; + } + var TOUCH_INPUT_MAP = { + touchstart: INPUT_START2, + touchmove: INPUT_MOVE2, + touchend: INPUT_END2, + touchcancel: INPUT_CANCEL + }; + var TOUCH_TARGET_EVENTS = "touchstart touchmove touchend touchcancel"; + function TouchInput() { + this.evTarget = TOUCH_TARGET_EVENTS; + this.targetIds = {}; + Input2.apply(this, arguments); + } + inherit(TouchInput, Input2, { + handler: function MTEhandler(ev) { + var type = TOUCH_INPUT_MAP[ev.type]; + var touches = getTouches.call(this, ev, type); + if (!touches) { + return; + } + this.callback(this.manager, type, { + pointers: touches[0], + changedPointers: touches[1], + pointerType: INPUT_TYPE_TOUCH, + srcEvent: ev + }); + } + }); + function getTouches(ev, type) { + var allTouches = toArray(ev.touches); + var targetIds = this.targetIds; + if (type & (INPUT_START2 | INPUT_MOVE2) && allTouches.length === 1) { + targetIds[allTouches[0].identifier] = true; + return [allTouches, allTouches]; + } + var i, targetTouches, changedTouches = toArray(ev.changedTouches), changedTargetTouches = [], target = this.target; + targetTouches = allTouches.filter(function(touch) { + return hasParent(touch.target, target); + }); + if (type === INPUT_START2) { + i = 0; + while (i < targetTouches.length) { + targetIds[targetTouches[i].identifier] = true; + i++; + } + } + i = 0; + while (i < changedTouches.length) { + if (targetIds[changedTouches[i].identifier]) { + changedTargetTouches.push(changedTouches[i]); + } + if (type & (INPUT_END2 | INPUT_CANCEL)) { + delete targetIds[changedTouches[i].identifier]; + } + i++; + } + if (!changedTargetTouches.length) { + return; + } + return [ + // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel' + uniqueArray(targetTouches.concat(changedTargetTouches), "identifier", true), + changedTargetTouches + ]; + } + var DEDUP_TIMEOUT = 2500; + var DEDUP_DISTANCE = 25; + function TouchMouseInput() { + Input2.apply(this, arguments); + var handler = bindFn(this.handler, this); + this.touch = new TouchInput(this.manager, handler); + this.mouse = new MouseInput2(this.manager, handler); + this.primaryTouch = null; + this.lastTouches = []; + } + inherit(TouchMouseInput, Input2, { + /** + * handle mouse and touch events + * @param {Hammer} manager + * @param {String} inputEvent + * @param {Object} inputData + */ + handler: function TMEhandler(manager, inputEvent, inputData) { + var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH, isMouse = inputData.pointerType == INPUT_TYPE_MOUSE; + if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) { + return; + } + if (isTouch) { + recordTouches.call(this, inputEvent, inputData); + } else if (isMouse && isSyntheticEvent.call(this, inputData)) { + return; + } + this.callback(manager, inputEvent, inputData); + }, + /** + * remove the event listeners + */ + destroy: function destroy() { + this.touch.destroy(); + this.mouse.destroy(); + } + }); + function recordTouches(eventType, eventData) { + if (eventType & INPUT_START2) { + this.primaryTouch = eventData.changedPointers[0].identifier; + setLastTouch.call(this, eventData); + } else if (eventType & (INPUT_END2 | INPUT_CANCEL)) { + setLastTouch.call(this, eventData); + } + } + function setLastTouch(eventData) { + var touch = eventData.changedPointers[0]; + if (touch.identifier === this.primaryTouch) { + var lastTouch = { x: touch.clientX, y: touch.clientY }; + this.lastTouches.push(lastTouch); + var lts = this.lastTouches; + var removeLastTouch = function() { + var i = lts.indexOf(lastTouch); + if (i > -1) { + lts.splice(i, 1); + } + }; + setTimeout(removeLastTouch, DEDUP_TIMEOUT); + } + } + function isSyntheticEvent(eventData) { + var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY; + for (var i = 0; i < this.lastTouches.length; i++) { + var t = this.lastTouches[i]; + var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y); + if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) { + return true; + } + } + return false; + } + var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, "touchAction"); + var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined2; + var TOUCH_ACTION_COMPUTE = "compute"; + var TOUCH_ACTION_AUTO = "auto"; + var TOUCH_ACTION_MANIPULATION = "manipulation"; + var TOUCH_ACTION_NONE = "none"; + var TOUCH_ACTION_PAN_X = "pan-x"; + var TOUCH_ACTION_PAN_Y = "pan-y"; + var TOUCH_ACTION_MAP = getTouchActionProps(); + function TouchAction(manager, value) { + this.manager = manager; + this.set(value); + } + TouchAction.prototype = { + /** + * set the touchAction value on the element or enable the polyfill + * @param {String} value + */ + set: function(value) { + if (value == TOUCH_ACTION_COMPUTE) { + value = this.compute(); + } + if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) { + this.manager.element.style[PREFIXED_TOUCH_ACTION] = value; + } + this.actions = value.toLowerCase().trim(); + }, + /** + * just re-set the touchAction value + */ + update: function() { + this.set(this.manager.options.touchAction); + }, + /** + * compute the value for the touchAction property based on the recognizer's settings + * @returns {String} value + */ + compute: function() { + var actions = []; + each(this.manager.recognizers, function(recognizer) { + if (boolOrFn(recognizer.options.enable, [recognizer])) { + actions = actions.concat(recognizer.getTouchAction()); + } + }); + return cleanTouchActions(actions.join(" ")); + }, + /** + * this method is called on each input cycle and provides the preventing of the browser behavior + * @param {Object} input + */ + preventDefaults: function(input) { + var srcEvent = input.srcEvent; + var direction = input.offsetDirection; + if (this.manager.session.prevented) { + srcEvent.preventDefault(); + return; + } + var actions = this.actions; + var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE]; + var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y]; + var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X]; + if (hasNone) { + var isTapPointer = input.pointers.length === 1; + var isTapMovement = input.distance < 2; + var isTapTouchTime = input.deltaTime < 250; + if (isTapPointer && isTapMovement && isTapTouchTime) { + return; + } + } + if (hasPanX && hasPanY) { + return; + } + if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) { + return this.preventSrc(srcEvent); + } + }, + /** + * call preventDefault to prevent the browser's default behavior (scrolling in most cases) + * @param {Object} srcEvent + */ + preventSrc: function(srcEvent) { + this.manager.session.prevented = true; + srcEvent.preventDefault(); + } + }; + function cleanTouchActions(actions) { + if (inStr(actions, TOUCH_ACTION_NONE)) { + return TOUCH_ACTION_NONE; + } + var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X); + var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); + if (hasPanX && hasPanY) { + return TOUCH_ACTION_NONE; + } + if (hasPanX || hasPanY) { + return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y; + } + if (inStr(actions, TOUCH_ACTION_MANIPULATION)) { + return TOUCH_ACTION_MANIPULATION; + } + return TOUCH_ACTION_AUTO; + } + function getTouchActionProps() { + if (!NATIVE_TOUCH_ACTION) { + return false; + } + var touchMap = {}; + var cssSupports = window2.CSS && window2.CSS.supports; + ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(val) { + touchMap[val] = cssSupports ? window2.CSS.supports("touch-action", val) : true; + }); + return touchMap; + } + var STATE_POSSIBLE = 1; + var STATE_BEGAN = 2; + var STATE_CHANGED = 4; + var STATE_ENDED = 8; + var STATE_RECOGNIZED = STATE_ENDED; + var STATE_CANCELLED = 16; + var STATE_FAILED = 32; + function Recognizer(options) { + this.options = assign({}, this.defaults, options || {}); + this.id = uniqueId(); + this.manager = null; + this.options.enable = ifUndefined(this.options.enable, true); + this.state = STATE_POSSIBLE; + this.simultaneous = {}; + this.requireFail = []; + } + Recognizer.prototype = { + /** + * @virtual + * @type {Object} + */ + defaults: {}, + /** + * set options + * @param {Object} options + * @return {Recognizer} + */ + set: function(options) { + assign(this.options, options); + this.manager && this.manager.touchAction.update(); + return this; + }, + /** + * recognize simultaneous with an other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + recognizeWith: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, "recognizeWith", this)) { + return this; + } + var simultaneous = this.simultaneous; + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + if (!simultaneous[otherRecognizer.id]) { + simultaneous[otherRecognizer.id] = otherRecognizer; + otherRecognizer.recognizeWith(this); + } + return this; + }, + /** + * drop the simultaneous link. it doesnt remove the link on the other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + dropRecognizeWith: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, "dropRecognizeWith", this)) { + return this; + } + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + delete this.simultaneous[otherRecognizer.id]; + return this; + }, + /** + * recognizer can only run when an other is failing + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + requireFailure: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, "requireFailure", this)) { + return this; + } + var requireFail = this.requireFail; + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + if (inArray(requireFail, otherRecognizer) === -1) { + requireFail.push(otherRecognizer); + otherRecognizer.requireFailure(this); + } + return this; + }, + /** + * drop the requireFailure link. it does not remove the link on the other recognizer. + * @param {Recognizer} otherRecognizer + * @returns {Recognizer} this + */ + dropRequireFailure: function(otherRecognizer) { + if (invokeArrayArg(otherRecognizer, "dropRequireFailure", this)) { + return this; + } + otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); + var index2 = inArray(this.requireFail, otherRecognizer); + if (index2 > -1) { + this.requireFail.splice(index2, 1); + } + return this; + }, + /** + * has require failures boolean + * @returns {boolean} + */ + hasRequireFailures: function() { + return this.requireFail.length > 0; + }, + /** + * if the recognizer can recognize simultaneous with an other recognizer + * @param {Recognizer} otherRecognizer + * @returns {Boolean} + */ + canRecognizeWith: function(otherRecognizer) { + return !!this.simultaneous[otherRecognizer.id]; + }, + /** + * You should use `tryEmit` instead of `emit` directly to check + * that all the needed recognizers has failed before emitting. + * @param {Object} input + */ + emit: function(input) { + var self2 = this; + var state = this.state; + function emit(event) { + self2.manager.emit(event, input); + } + if (state < STATE_ENDED) { + emit(self2.options.event + stateStr(state)); + } + emit(self2.options.event); + if (input.additionalEvent) { + emit(input.additionalEvent); + } + if (state >= STATE_ENDED) { + emit(self2.options.event + stateStr(state)); + } + }, + /** + * Check that all the require failure recognizers has failed, + * if true, it emits a gesture event, + * otherwise, setup the state to FAILED. + * @param {Object} input + */ + tryEmit: function(input) { + if (this.canEmit()) { + return this.emit(input); + } + this.state = STATE_FAILED; + }, + /** + * can we emit? + * @returns {boolean} + */ + canEmit: function() { + var i = 0; + while (i < this.requireFail.length) { + if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) { + return false; + } + i++; + } + return true; + }, + /** + * update the recognizer + * @param {Object} inputData + */ + recognize: function(inputData) { + var inputDataClone = assign({}, inputData); + if (!boolOrFn(this.options.enable, [this, inputDataClone])) { + this.reset(); + this.state = STATE_FAILED; + return; + } + if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) { + this.state = STATE_POSSIBLE; + } + this.state = this.process(inputDataClone); + if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) { + this.tryEmit(inputDataClone); + } + }, + /** + * return the state of the recognizer + * the actual recognizing happens in this method + * @virtual + * @param {Object} inputData + * @returns {Const} STATE + */ + process: function(inputData) { + }, + // jshint ignore:line + /** + * return the preferred touch-action + * @virtual + * @returns {Array} + */ + getTouchAction: function() { + }, + /** + * called when the gesture isn't allowed to recognize + * like when another is being recognized or it is disabled + * @virtual + */ + reset: function() { + } + }; + function stateStr(state) { + if (state & STATE_CANCELLED) { + return "cancel"; + } else if (state & STATE_ENDED) { + return "end"; + } else if (state & STATE_CHANGED) { + return "move"; + } else if (state & STATE_BEGAN) { + return "start"; + } + return ""; + } + function directionStr(direction) { + if (direction == DIRECTION_DOWN) { + return "down"; + } else if (direction == DIRECTION_UP) { + return "up"; + } else if (direction == DIRECTION_LEFT) { + return "left"; + } else if (direction == DIRECTION_RIGHT) { + return "right"; + } + return ""; + } + function getRecognizerByNameIfManager(otherRecognizer, recognizer) { + var manager = recognizer.manager; + if (manager) { + return manager.get(otherRecognizer); + } + return otherRecognizer; + } + function AttrRecognizer() { + Recognizer.apply(this, arguments); + } + inherit(AttrRecognizer, Recognizer, { + /** + * @namespace + * @memberof AttrRecognizer + */ + defaults: { + /** + * @type {Number} + * @default 1 + */ + pointers: 1 + }, + /** + * Used to check if it the recognizer receives valid input, like input.distance > 10. + * @memberof AttrRecognizer + * @param {Object} input + * @returns {Boolean} recognized + */ + attrTest: function(input) { + var optionPointers = this.options.pointers; + return optionPointers === 0 || input.pointers.length === optionPointers; + }, + /** + * Process the input and return the state for the recognizer + * @memberof AttrRecognizer + * @param {Object} input + * @returns {*} State + */ + process: function(input) { + var state = this.state; + var eventType = input.eventType; + var isRecognized = state & (STATE_BEGAN | STATE_CHANGED); + var isValid = this.attrTest(input); + if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) { + return state | STATE_CANCELLED; + } else if (isRecognized || isValid) { + if (eventType & INPUT_END2) { + return state | STATE_ENDED; + } else if (!(state & STATE_BEGAN)) { + return STATE_BEGAN; + } + return state | STATE_CHANGED; + } + return STATE_FAILED; + } + }); + function PanRecognizer() { + AttrRecognizer.apply(this, arguments); + this.pX = null; + this.pY = null; + } + inherit(PanRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof PanRecognizer + */ + defaults: { + event: "pan", + threshold: 10, + pointers: 1, + direction: DIRECTION_ALL + }, + getTouchAction: function() { + var direction = this.options.direction; + var actions = []; + if (direction & DIRECTION_HORIZONTAL) { + actions.push(TOUCH_ACTION_PAN_Y); + } + if (direction & DIRECTION_VERTICAL) { + actions.push(TOUCH_ACTION_PAN_X); + } + return actions; + }, + directionTest: function(input) { + var options = this.options; + var hasMoved = true; + var distance8 = input.distance; + var direction = input.direction; + var x = input.deltaX; + var y = input.deltaY; + if (!(direction & options.direction)) { + if (options.direction & DIRECTION_HORIZONTAL) { + direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT; + hasMoved = x != this.pX; + distance8 = Math.abs(input.deltaX); + } else { + direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN; + hasMoved = y != this.pY; + distance8 = Math.abs(input.deltaY); + } + } + input.direction = direction; + return hasMoved && distance8 > options.threshold && direction & options.direction; + }, + attrTest: function(input) { + return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input)); + }, + emit: function(input) { + this.pX = input.deltaX; + this.pY = input.deltaY; + var direction = directionStr(input.direction); + if (direction) { + input.additionalEvent = this.options.event + direction; + } + this._super.emit.call(this, input); + } + }); + function PinchRecognizer() { + AttrRecognizer.apply(this, arguments); + } + inherit(PinchRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof PinchRecognizer + */ + defaults: { + event: "pinch", + threshold: 0, + pointers: 2 + }, + getTouchAction: function() { + return [TOUCH_ACTION_NONE]; + }, + attrTest: function(input) { + return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN); + }, + emit: function(input) { + if (input.scale !== 1) { + var inOut = input.scale < 1 ? "in" : "out"; + input.additionalEvent = this.options.event + inOut; + } + this._super.emit.call(this, input); + } + }); + function PressRecognizer() { + Recognizer.apply(this, arguments); + this._timer = null; + this._input = null; + } + inherit(PressRecognizer, Recognizer, { + /** + * @namespace + * @memberof PressRecognizer + */ + defaults: { + event: "press", + pointers: 1, + time: 251, + // minimal time of the pointer to be pressed + threshold: 9 + // a minimal movement is ok, but keep it low + }, + getTouchAction: function() { + return [TOUCH_ACTION_AUTO]; + }, + process: function(input) { + var options = this.options; + var validPointers = input.pointers.length === options.pointers; + var validMovement = input.distance < options.threshold; + var validTime = input.deltaTime > options.time; + this._input = input; + if (!validMovement || !validPointers || input.eventType & (INPUT_END2 | INPUT_CANCEL) && !validTime) { + this.reset(); + } else if (input.eventType & INPUT_START2) { + this.reset(); + this._timer = setTimeoutContext(function() { + this.state = STATE_RECOGNIZED; + this.tryEmit(); + }, options.time, this); + } else if (input.eventType & INPUT_END2) { + return STATE_RECOGNIZED; + } + return STATE_FAILED; + }, + reset: function() { + clearTimeout(this._timer); + }, + emit: function(input) { + if (this.state !== STATE_RECOGNIZED) { + return; + } + if (input && input.eventType & INPUT_END2) { + this.manager.emit(this.options.event + "up", input); + } else { + this._input.timeStamp = now(); + this.manager.emit(this.options.event, this._input); + } + } + }); + function RotateRecognizer() { + AttrRecognizer.apply(this, arguments); + } + inherit(RotateRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof RotateRecognizer + */ + defaults: { + event: "rotate", + threshold: 0, + pointers: 2 + }, + getTouchAction: function() { + return [TOUCH_ACTION_NONE]; + }, + attrTest: function(input) { + return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN); + } + }); + function SwipeRecognizer() { + AttrRecognizer.apply(this, arguments); + } + inherit(SwipeRecognizer, AttrRecognizer, { + /** + * @namespace + * @memberof SwipeRecognizer + */ + defaults: { + event: "swipe", + threshold: 10, + velocity: 0.3, + direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL, + pointers: 1 + }, + getTouchAction: function() { + return PanRecognizer.prototype.getTouchAction.call(this); + }, + attrTest: function(input) { + var direction = this.options.direction; + var velocity; + if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) { + velocity = input.overallVelocity; + } else if (direction & DIRECTION_HORIZONTAL) { + velocity = input.overallVelocityX; + } else if (direction & DIRECTION_VERTICAL) { + velocity = input.overallVelocityY; + } + return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END2; + }, + emit: function(input) { + var direction = directionStr(input.offsetDirection); + if (direction) { + this.manager.emit(this.options.event + direction, input); + } + this.manager.emit(this.options.event, input); + } + }); + function TapRecognizer() { + Recognizer.apply(this, arguments); + this.pTime = false; + this.pCenter = false; + this._timer = null; + this._input = null; + this.count = 0; + } + inherit(TapRecognizer, Recognizer, { + /** + * @namespace + * @memberof PinchRecognizer + */ + defaults: { + event: "tap", + pointers: 1, + taps: 1, + interval: 300, + // max time between the multi-tap taps + time: 250, + // max time of the pointer to be down (like finger on the screen) + threshold: 9, + // a minimal movement is ok, but keep it low + posThreshold: 10 + // a multi-tap can be a bit off the initial position + }, + getTouchAction: function() { + return [TOUCH_ACTION_MANIPULATION]; + }, + process: function(input) { + var options = this.options; + var validPointers = input.pointers.length === options.pointers; + var validMovement = input.distance < options.threshold; + var validTouchTime = input.deltaTime < options.time; + this.reset(); + if (input.eventType & INPUT_START2 && this.count === 0) { + return this.failTimeout(); + } + if (validMovement && validTouchTime && validPointers) { + if (input.eventType != INPUT_END2) { + return this.failTimeout(); + } + var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true; + var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold; + this.pTime = input.timeStamp; + this.pCenter = input.center; + if (!validMultiTap || !validInterval) { + this.count = 1; + } else { + this.count += 1; + } + this._input = input; + var tapCount = this.count % options.taps; + if (tapCount === 0) { + if (!this.hasRequireFailures()) { + return STATE_RECOGNIZED; + } else { + this._timer = setTimeoutContext(function() { + this.state = STATE_RECOGNIZED; + this.tryEmit(); + }, options.interval, this); + return STATE_BEGAN; + } + } + } + return STATE_FAILED; + }, + failTimeout: function() { + this._timer = setTimeoutContext(function() { + this.state = STATE_FAILED; + }, this.options.interval, this); + return STATE_FAILED; + }, + reset: function() { + clearTimeout(this._timer); + }, + emit: function() { + if (this.state == STATE_RECOGNIZED) { + this._input.tapCount = this.count; + this.manager.emit(this.options.event, this._input); + } + } + }); + function Hammer(element, options) { + options = options || {}; + options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset); + return new Manager3(element, options); + } + Hammer.VERSION = "2.0.7"; + Hammer.defaults = { + /** + * set if DOM events are being triggered. + * But this is slower and unused by simple implementations, so disabled by default. + * @type {Boolean} + * @default false + */ + domEvents: false, + /** + * The value for the touchAction property/fallback. + * When set to `compute` it will magically set the correct value based on the added recognizers. + * @type {String} + * @default compute + */ + touchAction: TOUCH_ACTION_COMPUTE, + /** + * @type {Boolean} + * @default true + */ + enable: true, + /** + * EXPERIMENTAL FEATURE -- can be removed/changed + * Change the parent input target element. + * If Null, then it is being set the to main element. + * @type {Null|EventTarget} + * @default null + */ + inputTarget: null, + /** + * force an input class + * @type {Null|Function} + * @default null + */ + inputClass: null, + /** + * Default recognizer setup when calling `Hammer()` + * When creating a new Manager these will be skipped. + * @type {Array} + */ + preset: [ + // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...] + [RotateRecognizer, { enable: false }], + [PinchRecognizer, { enable: false }, ["rotate"]], + [SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }], + [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ["swipe"]], + [TapRecognizer], + [TapRecognizer, { event: "doubletap", taps: 2 }, ["tap"]], + [PressRecognizer] + ], + /** + * Some CSS properties can be used to improve the working of Hammer. + * Add them to this method and they will be set when creating a new Manager. + * @namespace + */ + cssProps: { + /** + * Disables text selection to improve the dragging gesture. Mainly for desktop browsers. + * @type {String} + * @default 'none' + */ + userSelect: "none", + /** + * Disable the Windows Phone grippers when pressing an element. + * @type {String} + * @default 'none' + */ + touchSelect: "none", + /** + * Disables the default callout shown when you touch and hold a touch target. + * On iOS, when you touch and hold a touch target such as a link, Safari displays + * a callout containing information about the link. This property allows you to disable that callout. + * @type {String} + * @default 'none' + */ + touchCallout: "none", + /** + * Specifies whether zooming is enabled. Used by IE10> + * @type {String} + * @default 'none' + */ + contentZooming: "none", + /** + * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers. + * @type {String} + * @default 'none' + */ + userDrag: "none", + /** + * Overrides the highlight color shown when the user taps a link or a JavaScript + * clickable element in iOS. This property obeys the alpha value, if specified. + * @type {String} + * @default 'rgba(0,0,0,0)' + */ + tapHighlightColor: "rgba(0,0,0,0)" + } + }; + var STOP = 1; + var FORCED_STOP = 2; + function Manager3(element, options) { + this.options = assign({}, Hammer.defaults, options || {}); + this.options.inputTarget = this.options.inputTarget || element; + this.handlers = {}; + this.session = {}; + this.recognizers = []; + this.oldCssProps = {}; + this.element = element; + this.input = createInputInstance(this); + this.touchAction = new TouchAction(this, this.options.touchAction); + toggleCssProps(this, true); + each(this.options.recognizers, function(item) { + var recognizer = this.add(new item[0](item[1])); + item[2] && recognizer.recognizeWith(item[2]); + item[3] && recognizer.requireFailure(item[3]); + }, this); + } + Manager3.prototype = { + /** + * set options + * @param {Object} options + * @returns {Manager} + */ + set: function(options) { + assign(this.options, options); + if (options.touchAction) { + this.touchAction.update(); + } + if (options.inputTarget) { + this.input.destroy(); + this.input.target = options.inputTarget; + this.input.init(); + } + return this; + }, + /** + * stop recognizing for this session. + * This session will be discarded, when a new [input]start event is fired. + * When forced, the recognizer cycle is stopped immediately. + * @param {Boolean} [force] + */ + stop: function(force) { + this.session.stopped = force ? FORCED_STOP : STOP; + }, + /** + * run the recognizers! + * called by the inputHandler function on every movement of the pointers (touches) + * it walks through all the recognizers and tries to detect the gesture that is being made + * @param {Object} inputData + */ + recognize: function(inputData) { + var session = this.session; + if (session.stopped) { + return; + } + this.touchAction.preventDefaults(inputData); + var recognizer; + var recognizers = this.recognizers; + var curRecognizer = session.curRecognizer; + if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) { + curRecognizer = session.curRecognizer = null; + } + var i = 0; + while (i < recognizers.length) { + recognizer = recognizers[i]; + if (session.stopped !== FORCED_STOP && // 1 + (!curRecognizer || recognizer == curRecognizer || // 2 + recognizer.canRecognizeWith(curRecognizer))) { + recognizer.recognize(inputData); + } else { + recognizer.reset(); + } + if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) { + curRecognizer = session.curRecognizer = recognizer; + } + i++; + } + }, + /** + * get a recognizer by its event name. + * @param {Recognizer|String} recognizer + * @returns {Recognizer|Null} + */ + get: function(recognizer) { + if (recognizer instanceof Recognizer) { + return recognizer; + } + var recognizers = this.recognizers; + for (var i = 0; i < recognizers.length; i++) { + if (recognizers[i].options.event == recognizer) { + return recognizers[i]; + } + } + return null; + }, + /** + * add a recognizer to the manager + * existing recognizers with the same event name will be removed + * @param {Recognizer} recognizer + * @returns {Recognizer|Manager} + */ + add: function(recognizer) { + if (invokeArrayArg(recognizer, "add", this)) { + return this; + } + var existing = this.get(recognizer.options.event); + if (existing) { + this.remove(existing); + } + this.recognizers.push(recognizer); + recognizer.manager = this; + this.touchAction.update(); + return recognizer; + }, + /** + * remove a recognizer by name or instance + * @param {Recognizer|String} recognizer + * @returns {Manager} + */ + remove: function(recognizer) { + if (invokeArrayArg(recognizer, "remove", this)) { + return this; + } + recognizer = this.get(recognizer); + if (recognizer) { + var recognizers = this.recognizers; + var index2 = inArray(recognizers, recognizer); + if (index2 !== -1) { + recognizers.splice(index2, 1); + this.touchAction.update(); + } + } + return this; + }, + /** + * bind event + * @param {String} events + * @param {Function} handler + * @returns {EventEmitter} this + */ + on: function(events, handler) { + if (events === undefined2) { + return; + } + if (handler === undefined2) { + return; + } + var handlers = this.handlers; + each(splitStr(events), function(event) { + handlers[event] = handlers[event] || []; + handlers[event].push(handler); + }); + return this; + }, + /** + * unbind event, leave emit blank to remove all handlers + * @param {String} events + * @param {Function} [handler] + * @returns {EventEmitter} this + */ + off: function(events, handler) { + if (events === undefined2) { + return; + } + var handlers = this.handlers; + each(splitStr(events), function(event) { + if (!handler) { + delete handlers[event]; + } else { + handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1); + } + }); + return this; + }, + /** + * emit event to the listeners + * @param {String} event + * @param {Object} data + */ + emit: function(event, data) { + if (this.options.domEvents) { + triggerDomEvent(event, data); + } + var handlers = this.handlers[event] && this.handlers[event].slice(); + if (!handlers || !handlers.length) { + return; + } + data.type = event; + data.preventDefault = function() { + data.srcEvent.preventDefault(); + }; + var i = 0; + while (i < handlers.length) { + handlers[i](data); + i++; + } + }, + /** + * destroy the manager and unbinds all events + * it doesn't unbind dom events, that is the user own responsibility + */ + destroy: function() { + this.element && toggleCssProps(this, false); + this.handlers = {}; + this.session = {}; + this.input.destroy(); + this.element = null; + } + }; + function toggleCssProps(manager, add13) { + var element = manager.element; + if (!element.style) { + return; + } + var prop; + each(manager.options.cssProps, function(value, name2) { + prop = prefixed(element.style, name2); + if (add13) { + manager.oldCssProps[prop] = element.style[prop]; + element.style[prop] = value; + } else { + element.style[prop] = manager.oldCssProps[prop] || ""; + } + }); + if (!add13) { + manager.oldCssProps = {}; + } + } + function triggerDomEvent(event, data) { + var gestureEvent = document2.createEvent("Event"); + gestureEvent.initEvent(event, true, true); + gestureEvent.gesture = data; + data.target.dispatchEvent(gestureEvent); + } + assign(Hammer, { + INPUT_START: INPUT_START2, + INPUT_MOVE: INPUT_MOVE2, + INPUT_END: INPUT_END2, + INPUT_CANCEL, + STATE_POSSIBLE, + STATE_BEGAN, + STATE_CHANGED, + STATE_ENDED, + STATE_RECOGNIZED, + STATE_CANCELLED, + STATE_FAILED, + DIRECTION_NONE, + DIRECTION_LEFT, + DIRECTION_RIGHT, + DIRECTION_UP, + DIRECTION_DOWN, + DIRECTION_HORIZONTAL, + DIRECTION_VERTICAL, + DIRECTION_ALL, + Manager: Manager3, + Input: Input2, + TouchAction, + TouchInput, + MouseInput: MouseInput2, + PointerEventInput: PointerEventInput2, + TouchMouseInput, + SingleTouchInput, + Recognizer, + AttrRecognizer, + Tap: TapRecognizer, + Pan: PanRecognizer, + Swipe: SwipeRecognizer, + Pinch: PinchRecognizer, + Rotate: RotateRecognizer, + Press: PressRecognizer, + on: addEventListeners, + off: removeEventListeners, + each, + merge, + extend, + assign, + inherit, + bindFn, + prefixed + }); + var freeGlobal = typeof window2 !== "undefined" ? window2 : typeof self !== "undefined" ? self : {}; + freeGlobal.Hammer = Hammer; + if (typeof define === "function" && define.amd) { + define(function() { + return Hammer; + }); + } else if (typeof module != "undefined" && module.exports) { + module.exports = Hammer; + } else { + window2[exportName] = Hammer; + } + })(window, document, "Hammer"); + } +}); + +// node_modules/earcut/src/earcut.js +var require_earcut = __commonJS({ + "node_modules/earcut/src/earcut.js"(exports, module) { + "use strict"; + module.exports = earcut3; + module.exports.default = earcut3; + function earcut3(data, holeIndices, dim) { + dim = dim || 2; + var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = []; + if (!outerNode || outerNode.next === outerNode.prev) + return triangles; + var minX, minY, maxX, maxY, x, y, invSize; + if (hasHoles) + outerNode = eliminateHoles(data, holeIndices, outerNode, dim); + if (data.length > 80 * dim) { + minX = maxX = data[0]; + minY = maxY = data[1]; + for (var i = dim; i < outerLen; i += dim) { + x = data[i]; + y = data[i + 1]; + if (x < minX) + minX = x; + if (y < minY) + minY = y; + if (x > maxX) + maxX = x; + if (y > maxY) + maxY = y; + } + invSize = Math.max(maxX - minX, maxY - minY); + invSize = invSize !== 0 ? 32767 / invSize : 0; + } + earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0); + return triangles; + } + function linkedList(data, start, end, dim, clockwise) { + var i, last; + if (clockwise === signedArea(data, start, end, dim) > 0) { + for (i = start; i < end; i += dim) + last = insertNode(i, data[i], data[i + 1], last); + } else { + for (i = end - dim; i >= start; i -= dim) + last = insertNode(i, data[i], data[i + 1], last); + } + if (last && equals12(last, last.next)) { + removeNode(last); + last = last.next; + } + return last; + } + function filterPoints(start, end) { + if (!start) + return start; + if (!end) + end = start; + var p = start, again; + do { + again = false; + if (!p.steiner && (equals12(p, p.next) || area(p.prev, p, p.next) === 0)) { + removeNode(p); + p = end = p.prev; + if (p === p.next) + break; + again = true; + } else { + p = p.next; + } + } while (again || p !== end); + return end; + } + function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) { + if (!ear) + return; + if (!pass && invSize) + indexCurve(ear, minX, minY, invSize); + var stop = ear, prev, next; + while (ear.prev !== ear.next) { + prev = ear.prev; + next = ear.next; + if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) { + triangles.push(prev.i / dim | 0); + triangles.push(ear.i / dim | 0); + triangles.push(next.i / dim | 0); + removeNode(ear); + ear = next.next; + stop = next.next; + continue; + } + ear = next; + if (ear === stop) { + if (!pass) { + earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1); + } else if (pass === 1) { + ear = cureLocalIntersections(filterPoints(ear), triangles, dim); + earcutLinked(ear, triangles, dim, minX, minY, invSize, 2); + } else if (pass === 2) { + splitEarcut(ear, triangles, dim, minX, minY, invSize); + } + break; + } + } + } + function isEar(ear) { + var a = ear.prev, b = ear, c = ear.next; + if (area(a, b, c) >= 0) + return false; + var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; + var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + var p = c.next; + while (p !== a) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) + return false; + p = p.next; + } + return true; + } + function isEarHashed(ear, minX, minY, invSize) { + var a = ear.prev, b = ear, c = ear.next; + if (area(a, b, c) >= 0) + return false; + var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; + var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + var minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize); + var p = ear.prevZ, n = ear.nextZ; + while (p && p.z >= minZ && n && n.z <= maxZ) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) + return false; + p = p.prevZ; + if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) + return false; + n = n.nextZ; + } + while (p && p.z >= minZ) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) + return false; + p = p.prevZ; + } + while (n && n.z <= maxZ) { + if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) + return false; + n = n.nextZ; + } + return true; + } + function cureLocalIntersections(start, triangles, dim) { + var p = start; + do { + var a = p.prev, b = p.next.next; + if (!equals12(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) { + triangles.push(a.i / dim | 0); + triangles.push(p.i / dim | 0); + triangles.push(b.i / dim | 0); + removeNode(p); + removeNode(p.next); + p = start = b; + } + p = p.next; + } while (p !== start); + return filterPoints(p); + } + function splitEarcut(start, triangles, dim, minX, minY, invSize) { + var a = start; + do { + var b = a.next.next; + while (b !== a.prev) { + if (a.i !== b.i && isValidDiagonal(a, b)) { + var c = splitPolygon(a, b); + a = filterPoints(a, a.next); + c = filterPoints(c, c.next); + earcutLinked(a, triangles, dim, minX, minY, invSize, 0); + earcutLinked(c, triangles, dim, minX, minY, invSize, 0); + return; + } + b = b.next; + } + a = a.next; + } while (a !== start); + } + function eliminateHoles(data, holeIndices, outerNode, dim) { + var queue = [], i, len8, start, end, list; + for (i = 0, len8 = holeIndices.length; i < len8; i++) { + start = holeIndices[i] * dim; + end = i < len8 - 1 ? holeIndices[i + 1] * dim : data.length; + list = linkedList(data, start, end, dim, false); + if (list === list.next) + list.steiner = true; + queue.push(getLeftmost(list)); + } + queue.sort(compareX); + for (i = 0; i < queue.length; i++) { + outerNode = eliminateHole(queue[i], outerNode); + } + return outerNode; + } + function compareX(a, b) { + return a.x - b.x; + } + function eliminateHole(hole, outerNode) { + var bridge = findHoleBridge(hole, outerNode); + if (!bridge) { + return outerNode; + } + var bridgeReverse = splitPolygon(bridge, hole); + filterPoints(bridgeReverse, bridgeReverse.next); + return filterPoints(bridge, bridge.next); + } + function findHoleBridge(hole, outerNode) { + var p = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m; + do { + if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) { + var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y); + if (x <= hx && x > qx) { + qx = x; + m = p.x < p.next.x ? p : p.next; + if (x === hx) + return m; + } + } + p = p.next; + } while (p !== outerNode); + if (!m) + return null; + var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan3; + p = m; + do { + if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) { + tan3 = Math.abs(hy - p.y) / (hx - p.x); + if (locallyInside(p, hole) && (tan3 < tanMin || tan3 === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) { + m = p; + tanMin = tan3; + } + } + p = p.next; + } while (p !== stop); + return m; + } + function sectorContainsSector(m, p) { + return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0; + } + function indexCurve(start, minX, minY, invSize) { + var p = start; + do { + if (p.z === 0) + p.z = zOrder(p.x, p.y, minX, minY, invSize); + p.prevZ = p.prev; + p.nextZ = p.next; + p = p.next; + } while (p !== start); + p.prevZ.nextZ = null; + p.prevZ = null; + sortLinked(p); + } + function sortLinked(list) { + var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1; + do { + p = list; + list = null; + tail = null; + numMerges = 0; + while (p) { + numMerges++; + q = p; + pSize = 0; + for (i = 0; i < inSize; i++) { + pSize++; + q = q.nextZ; + if (!q) + break; + } + qSize = inSize; + while (pSize > 0 || qSize > 0 && q) { + if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) { + e = p; + p = p.nextZ; + pSize--; + } else { + e = q; + q = q.nextZ; + qSize--; + } + if (tail) + tail.nextZ = e; + else + list = e; + e.prevZ = tail; + tail = e; + } + p = q; + } + tail.nextZ = null; + inSize *= 2; + } while (numMerges > 1); + return list; + } + function zOrder(x, y, minX, minY, invSize) { + x = (x - minX) * invSize | 0; + y = (y - minY) * invSize | 0; + x = (x | x << 8) & 16711935; + x = (x | x << 4) & 252645135; + x = (x | x << 2) & 858993459; + x = (x | x << 1) & 1431655765; + y = (y | y << 8) & 16711935; + y = (y | y << 4) & 252645135; + y = (y | y << 2) & 858993459; + y = (y | y << 1) & 1431655765; + return x | y << 1; + } + function getLeftmost(start) { + var p = start, leftmost = start; + do { + if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) + leftmost = p; + p = p.next; + } while (p !== start); + return leftmost; + } + function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) { + return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py); + } + function isValidDiagonal(a, b) { + return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges + (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible + (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors + equals12(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); + } + function area(p, q, r) { + return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y); + } + function equals12(p1, p2) { + return p1.x === p2.x && p1.y === p2.y; + } + function intersects(p1, q1, p2, q2) { + var o1 = sign(area(p1, q1, p2)); + var o2 = sign(area(p1, q1, q2)); + var o3 = sign(area(p2, q2, p1)); + var o4 = sign(area(p2, q2, q1)); + if (o1 !== o2 && o3 !== o4) + return true; + if (o1 === 0 && onSegment(p1, p2, q1)) + return true; + if (o2 === 0 && onSegment(p1, q2, q1)) + return true; + if (o3 === 0 && onSegment(p2, p1, q2)) + return true; + if (o4 === 0 && onSegment(p2, q1, q2)) + return true; + return false; + } + function onSegment(p, q, r) { + return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y); + } + function sign(num) { + return num > 0 ? 1 : num < 0 ? -1 : 0; + } + function intersectsPolygon(a, b) { + var p = a; + do { + if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) + return true; + p = p.next; + } while (p !== a); + return false; + } + function locallyInside(a, b) { + return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0; + } + function middleInside(a, b) { + var p = a, inside = false, px = (a.x + b.x) / 2, py = (a.y + b.y) / 2; + do { + if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) + inside = !inside; + p = p.next; + } while (p !== a); + return inside; + } + function splitPolygon(a, b) { + var a2 = new Node2(a.i, a.x, a.y), b2 = new Node2(b.i, b.x, b.y), an = a.next, bp = b.prev; + a.next = b; + b.prev = a; + a2.next = an; + an.prev = a2; + b2.next = a2; + a2.prev = b2; + bp.next = b2; + b2.prev = bp; + return b2; + } + function insertNode(i, x, y, last) { + var p = new Node2(i, x, y); + if (!last) { + p.prev = p; + p.next = p; + } else { + p.next = last.next; + p.prev = last; + last.next.prev = p; + last.next = p; + } + return p; + } + function removeNode(p) { + p.next.prev = p.prev; + p.prev.next = p.next; + if (p.prevZ) + p.prevZ.nextZ = p.nextZ; + if (p.nextZ) + p.nextZ.prevZ = p.prevZ; + } + function Node2(i, x, y) { + this.i = i; + this.x = x; + this.y = y; + this.prev = null; + this.next = null; + this.z = 0; + this.prevZ = null; + this.nextZ = null; + this.steiner = false; + } + earcut3.deviation = function(data, holeIndices, dim, triangles) { + var hasHoles = holeIndices && holeIndices.length; + var outerLen = hasHoles ? holeIndices[0] * dim : data.length; + var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim)); + if (hasHoles) { + for (var i = 0, len8 = holeIndices.length; i < len8; i++) { + var start = holeIndices[i] * dim; + var end = i < len8 - 1 ? holeIndices[i + 1] * dim : data.length; + polygonArea -= Math.abs(signedArea(data, start, end, dim)); + } + } + var trianglesArea = 0; + for (i = 0; i < triangles.length; i += 3) { + var a = triangles[i] * dim; + var b = triangles[i + 1] * dim; + var c = triangles[i + 2] * dim; + trianglesArea += Math.abs( + (data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1]) + ); + } + return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea); + }; + function signedArea(data, start, end, dim) { + var sum = 0; + for (var i = start, j = end - dim; i < end; i += dim) { + sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]); + j = i; + } + return sum; + } + earcut3.flatten = function(data) { + var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0; + for (var i = 0; i < data.length; i++) { + for (var j = 0; j < data[i].length; j++) { + for (var d = 0; d < dim; d++) + result.vertices.push(data[i][j][d]); + } + if (i > 0) { + holeIndex += data[i - 1].length; + result.holes.push(holeIndex); + } + } + return result; + }; + } +}); + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js +function assert(condition, message2) { + if (!condition) { + throw new Error(message2 || "loader assertion failed."); + } +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js +var globals = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document +}; +var self_ = globals.self || globals.window || globals.global || {}; +var window_ = globals.window || globals.self || globals.global || {}; +var global_ = globals.global || globals.self || globals.window || {}; +var document_ = globals.document || {}; +var isBrowser = ( + // @ts-ignore process does not exist on browser + Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser) +); +var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); +var nodeVersion = matches && parseFloat(matches[1]) || 0; + +// node_modules/@probe.gl/env/dist/lib/globals.js +var window_2 = globalThis; +var document_2 = globalThis.document || {}; +var process_ = globalThis.process || {}; +var console_ = globalThis.console; +var navigator_ = globalThis.navigator || {}; + +// node_modules/@probe.gl/env/dist/lib/is-electron.js +function isElectron(mockUserAgent) { + if (typeof window !== "undefined" && window.process?.type === "renderer") { + return true; + } + if (typeof process !== "undefined" && Boolean(process.versions?.["electron"])) { + return true; + } + const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent; + const userAgent2 = mockUserAgent || realUserAgent; + return Boolean(userAgent2 && userAgent2.indexOf("Electron") >= 0); +} + +// node_modules/@probe.gl/env/dist/lib/is-browser.js +function isBrowser2() { + const isNode = ( + // @ts-expect-error + typeof process === "object" && String(process) === "[object process]" && !process?.browser + ); + return !isNode || isElectron(); +} + +// node_modules/@probe.gl/env/dist/lib/get-browser.js +function getBrowser(mockUserAgent) { + if (!mockUserAgent && !isBrowser2()) { + return "Node"; + } + if (isElectron(mockUserAgent)) { + return "Electron"; + } + const userAgent2 = mockUserAgent || navigator_.userAgent || ""; + if (userAgent2.indexOf("Edge") > -1) { + return "Edge"; + } + if (globalThis.chrome) { + return "Chrome"; + } + if (globalThis.safari) { + return "Safari"; + } + if (globalThis.mozInnerScreenX) { + return "Firefox"; + } + return "Unknown"; +} + +// node_modules/@probe.gl/env/dist/index.js +var VERSION = true ? "4.0.7" : "untranspiled source"; + +// node_modules/@probe.gl/log/dist/utils/local-storage.js +function getStorage(type) { + try { + const storage = window[type]; + const x = "__storage_test__"; + storage.setItem(x, x); + storage.removeItem(x); + return storage; + } catch (e) { + return null; + } +} +var LocalStorage = class { + constructor(id, defaultConfig, type = "sessionStorage") { + this.storage = getStorage(type); + this.id = id; + this.config = defaultConfig; + this._loadConfiguration(); + } + getConfiguration() { + return this.config; + } + setConfiguration(configuration) { + Object.assign(this.config, configuration); + if (this.storage) { + const serialized = JSON.stringify(this.config); + this.storage.setItem(this.id, serialized); + } + } + // Get config from persistent store, if available + _loadConfiguration() { + let configuration = {}; + if (this.storage) { + const serializedConfiguration = this.storage.getItem(this.id); + configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; + } + Object.assign(this.config, configuration); + return this; + } +}; + +// node_modules/@probe.gl/log/dist/utils/formatters.js +function formatTime(ms) { + let formatted; + if (ms < 10) { + formatted = `${ms.toFixed(2)}ms`; + } else if (ms < 100) { + formatted = `${ms.toFixed(1)}ms`; + } else if (ms < 1e3) { + formatted = `${ms.toFixed(0)}ms`; + } else { + formatted = `${(ms / 1e3).toFixed(2)}s`; + } + return formatted; +} +function leftPad(string, length10 = 8) { + const padLength = Math.max(length10 - string.length, 0); + return `${" ".repeat(padLength)}${string}`; +} + +// node_modules/@probe.gl/log/dist/utils/color.js +var COLOR; +(function(COLOR2) { + COLOR2[COLOR2["BLACK"] = 30] = "BLACK"; + COLOR2[COLOR2["RED"] = 31] = "RED"; + COLOR2[COLOR2["GREEN"] = 32] = "GREEN"; + COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW"; + COLOR2[COLOR2["BLUE"] = 34] = "BLUE"; + COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA"; + COLOR2[COLOR2["CYAN"] = 36] = "CYAN"; + COLOR2[COLOR2["WHITE"] = 37] = "WHITE"; + COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; + COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED"; + COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; + COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; + COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; + COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; + COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; + COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; +})(COLOR || (COLOR = {})); +var BACKGROUND_INCREMENT = 10; +function getColor(color) { + if (typeof color !== "string") { + return color; + } + color = color.toUpperCase(); + return COLOR[color] || COLOR.WHITE; +} +function addColor(string, color, background) { + if (!isBrowser2 && typeof string === "string") { + if (color) { + const colorCode = getColor(color); + string = `\x1B[${colorCode}m${string}\x1B[39m`; + } + if (background) { + const colorCode = getColor(background); + string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`; + } + } + return string; +} + +// node_modules/@probe.gl/log/dist/utils/autobind.js +function autobind(obj, predefined = ["constructor"]) { + const proto = Object.getPrototypeOf(obj); + const propNames = Object.getOwnPropertyNames(proto); + const object = obj; + for (const key of propNames) { + const value = object[key]; + if (typeof value === "function") { + if (!predefined.find((name2) => key === name2)) { + object[key] = value.bind(obj); + } + } + } +} + +// node_modules/@probe.gl/log/dist/utils/assert.js +function assert2(condition, message2) { + if (!condition) { + throw new Error(message2 || "Assertion failed"); + } +} + +// node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js +function getHiResTimestamp() { + let timestamp; + if (isBrowser2() && window_2.performance) { + timestamp = window_2?.performance?.now?.(); + } else if ("hrtime" in process_) { + const timeParts = process_?.hrtime?.(); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; +} + +// node_modules/@probe.gl/log/dist/log.js +var originalConsole = { + debug: isBrowser2() ? console.debug || console.log : console.log, + log: console.log, + info: console.info, + warn: console.warn, + error: console.error +}; +var DEFAULT_LOG_CONFIGURATION = { + enabled: true, + level: 0 +}; +function noop() { +} +var cache = {}; +var ONCE = { once: true }; +var Log = class { + constructor({ id } = { id: "" }) { + this.VERSION = VERSION; + this._startTs = getHiResTimestamp(); + this._deltaTs = getHiResTimestamp(); + this.userData = {}; + this.LOG_THROTTLE_TIMEOUT = 0; + this.id = id; + this.userData = {}; + this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION); + this.timeStamp(`${this.id} started`); + autobind(this); + Object.seal(this); + } + set level(newLevel) { + this.setLevel(newLevel); + } + get level() { + return this.getLevel(); + } + isEnabled() { + return this._storage.config.enabled; + } + getLevel() { + return this._storage.config.level; + } + /** @return milliseconds, with fractions */ + getTotal() { + return Number((getHiResTimestamp() - this._startTs).toPrecision(10)); + } + /** @return milliseconds, with fractions */ + getDelta() { + return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10)); + } + /** @deprecated use logLevel */ + set priority(newPriority) { + this.level = newPriority; + } + /** @deprecated use logLevel */ + get priority() { + return this.level; + } + /** @deprecated use logLevel */ + getPriority() { + return this.level; + } + // Configure + enable(enabled = true) { + this._storage.setConfiguration({ enabled }); + return this; + } + setLevel(level) { + this._storage.setConfiguration({ level }); + return this; + } + /** return the current status of the setting */ + get(setting) { + return this._storage.config[setting]; + } + // update the status of the setting + set(setting, value) { + this._storage.setConfiguration({ [setting]: value }); + } + /** Logs the current settings as a table */ + settings() { + if (console.table) { + console.table(this._storage.config); + } else { + console.log(this._storage.config); + } + } + // Unconditional logging + assert(condition, message2) { + if (!condition) { + throw new Error(message2 || "Assertion failed"); + } + } + warn(message2) { + return this._getLogFunction(0, message2, originalConsole.warn, arguments, ONCE); + } + error(message2) { + return this._getLogFunction(0, message2, originalConsole.error, arguments); + } + /** Print a deprecation warning */ + deprecated(oldUsage, newUsage) { + return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`); + } + /** Print a removal warning */ + removed(oldUsage, newUsage) { + return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`); + } + probe(logLevel, message2) { + return this._getLogFunction(logLevel, message2, originalConsole.log, arguments, { + time: true, + once: true + }); + } + log(logLevel, message2) { + return this._getLogFunction(logLevel, message2, originalConsole.debug, arguments); + } + info(logLevel, message2) { + return this._getLogFunction(logLevel, message2, console.info, arguments); + } + once(logLevel, message2) { + return this._getLogFunction(logLevel, message2, originalConsole.debug || originalConsole.info, arguments, ONCE); + } + /** Logs an object as a table */ + table(logLevel, table, columns) { + if (table) { + return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], { + tag: getTableHeader(table) + }); + } + return noop; + } + time(logLevel, message2) { + return this._getLogFunction(logLevel, message2, console.time ? console.time : console.info); + } + timeEnd(logLevel, message2) { + return this._getLogFunction(logLevel, message2, console.timeEnd ? console.timeEnd : console.info); + } + timeStamp(logLevel, message2) { + return this._getLogFunction(logLevel, message2, console.timeStamp || noop); + } + group(logLevel, message2, opts = { collapsed: false }) { + const options = normalizeArguments({ logLevel, message: message2, opts }); + const { collapsed } = opts; + options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; + return this._getLogFunction(options); + } + groupCollapsed(logLevel, message2, opts = {}) { + return this.group(logLevel, message2, Object.assign({}, opts, { collapsed: true })); + } + groupEnd(logLevel) { + return this._getLogFunction(logLevel, "", console.groupEnd || noop); + } + // EXPERIMENTAL + withGroup(logLevel, message2, func) { + this.group(logLevel, message2)(); + try { + func(); + } finally { + this.groupEnd(logLevel)(); + } + } + trace() { + if (console.trace) { + console.trace(); + } + } + // PRIVATE METHODS + /** Deduces log level from a variety of arguments */ + _shouldLog(logLevel) { + return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel); + } + _getLogFunction(logLevel, message2, method, args, opts) { + if (this._shouldLog(logLevel)) { + opts = normalizeArguments({ logLevel, message: message2, args, opts }); + method = method || opts.method; + assert2(method); + opts.total = this.getTotal(); + opts.delta = this.getDelta(); + this._deltaTs = getHiResTimestamp(); + const tag = opts.tag || opts.message; + if (opts.once && tag) { + if (!cache[tag]) { + cache[tag] = getHiResTimestamp(); + } else { + return noop; + } + } + message2 = decorateMessage(this.id, opts.message, opts); + return method.bind(console, message2, ...opts.args); + } + return noop; + } +}; +Log.VERSION = VERSION; +function normalizeLogLevel(logLevel) { + if (!logLevel) { + return 0; + } + let resolvedLevel; + switch (typeof logLevel) { + case "number": + resolvedLevel = logLevel; + break; + case "object": + resolvedLevel = logLevel.logLevel || logLevel.priority || 0; + break; + default: + return 0; + } + assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); + return resolvedLevel; +} +function normalizeArguments(opts) { + const { logLevel, message: message2 } = opts; + opts.logLevel = normalizeLogLevel(logLevel); + const args = opts.args ? Array.from(opts.args) : []; + while (args.length && args.shift() !== message2) { + } + switch (typeof logLevel) { + case "string": + case "function": + if (message2 !== void 0) { + args.unshift(message2); + } + opts.message = logLevel; + break; + case "object": + Object.assign(opts, logLevel); + break; + default: + } + if (typeof opts.message === "function") { + opts.message = opts.message(); + } + const messageType = typeof opts.message; + assert2(messageType === "string" || messageType === "object"); + return Object.assign(opts, { args }, opts.opts); +} +function decorateMessage(id, message2, opts) { + if (typeof message2 === "string") { + const time = opts.time ? leftPad(formatTime(opts.total)) : ""; + message2 = opts.time ? `${id}: ${time} ${message2}` : `${id}: ${message2}`; + message2 = addColor(message2, opts.color, opts.background); + } + return message2; +} +function getTableHeader(table) { + for (const key in table) { + for (const title in table[key]) { + return title || "untitled"; + } + } + return "empty"; +} + +// node_modules/@probe.gl/log/dist/init.js +globalThis.probe = {}; + +// node_modules/@probe.gl/log/dist/index.js +var dist_default = new Log({ id: "@probe.gl/log" }); + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/log-utils/log.js +var VERSION2 = true ? "4.3.1" : "latest"; +var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : ""; +function createLog() { + const log4 = new Log({ id: "loaders.gl" }); + globalThis.loaders = globalThis.loaders || {}; + globalThis.loaders.log = log4; + globalThis.loaders.version = version; + globalThis.probe = globalThis.probe || {}; + globalThis.probe.loaders = log4; + return log4; +} +var log = createLog(); + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/option-utils/merge-loader-options.js +function mergeLoaderOptions(baseOptions, newOptions) { + return mergeOptionsRecursively(baseOptions || {}, newOptions); +} +function mergeOptionsRecursively(baseOptions, newOptions, level = 0) { + if (level > 3) { + return newOptions; + } + const options = { ...baseOptions }; + for (const [key, newValue] of Object.entries(newOptions)) { + if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) { + options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key], level + 1); + } else { + options[key] = newOptions[key]; + } + } + return options; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/version.js +var NPM_TAG = "latest"; +function getVersion() { + if (!globalThis._loadersgl_?.version) { + globalThis._loadersgl_ = globalThis._loadersgl_ || {}; + if (false) { + console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."); + globalThis._loadersgl_.version = NPM_TAG; + } else { + globalThis._loadersgl_.version = "4.3.1"; + } + } + return globalThis._loadersgl_.version; +} +var VERSION3 = getVersion(); + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/assert.js +function assert3(condition, message2) { + if (!condition) { + throw new Error(message2 || "loaders.gl assertion failed."); + } +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/globals.js +var globals2 = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document +}; +var self_2 = globals2.self || globals2.window || globals2.global || {}; +var window_3 = globals2.window || globals2.self || globals2.global || {}; +var global_3 = globals2.global || globals2.self || globals2.window || {}; +var document_3 = globals2.document || {}; +var isBrowser3 = ( + // @ts-ignore process.browser + typeof process !== "object" || String(process) !== "[object process]" || process.browser +); +var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined"; +var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); +var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-job.js +var WorkerJob = class { + name; + workerThread; + isRunning = true; + /** Promise that resolves when Job is done */ + result; + _resolve = () => { + }; + _reject = () => { + }; + constructor(jobName, workerThread) { + this.name = jobName; + this.workerThread = workerThread; + this.result = new Promise((resolve2, reject) => { + this._resolve = resolve2; + this._reject = reject; + }); + } + /** + * Send a message to the job's worker thread + * @param data any data structure, ideally consisting mostly of transferrable objects + */ + postMessage(type, payload) { + this.workerThread.postMessage({ + source: "loaders.gl", + // Lets worker ignore unrelated messages + type, + payload + }); + } + /** + * Call to resolve the `result` Promise with the supplied value + */ + done(value) { + assert3(this.isRunning); + this.isRunning = false; + this._resolve(value); + } + /** + * Call to reject the `result` Promise with the supplied error + */ + error(error) { + assert3(this.isRunning); + this.isRunning = false; + this._reject(error); + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/node/worker_threads-browser.js +var NodeWorker = class { + terminate() { + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-utils/get-loadable-worker-url.js +var workerURLCache = /* @__PURE__ */ new Map(); +function getLoadableWorkerURL(props) { + assert3(props.source && !props.url || !props.source && props.url); + let workerURL = workerURLCache.get(props.source || props.url); + if (!workerURL) { + if (props.url) { + workerURL = getLoadableWorkerURLFromURL(props.url); + workerURLCache.set(props.url, workerURL); + } + if (props.source) { + workerURL = getLoadableWorkerURLFromSource(props.source); + workerURLCache.set(props.source, workerURL); + } + } + assert3(workerURL); + return workerURL; +} +function getLoadableWorkerURLFromURL(url) { + if (!url.startsWith("http")) { + return url; + } + const workerSource = buildScriptSource(url); + return getLoadableWorkerURLFromSource(workerSource); +} +function getLoadableWorkerURLFromSource(workerSource) { + const blob = new Blob([workerSource], { type: "application/javascript" }); + return URL.createObjectURL(blob); +} +function buildScriptSource(workerUrl) { + return `try { + importScripts('${workerUrl}'); +} catch (error) { + console.error(error); + throw error; +}`; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-utils/get-transfer-list.js +function getTransferList(object, recursive = true, transfers) { + const transfersSet = transfers || /* @__PURE__ */ new Set(); + if (!object) { + } else if (isTransferable(object)) { + transfersSet.add(object); + } else if (isTransferable(object.buffer)) { + transfersSet.add(object.buffer); + } else if (ArrayBuffer.isView(object)) { + } else if (recursive && typeof object === "object") { + for (const key in object) { + getTransferList(object[key], recursive, transfersSet); + } + } + return transfers === void 0 ? Array.from(transfersSet) : []; +} +function isTransferable(object) { + if (!object) { + return false; + } + if (object instanceof ArrayBuffer) { + return true; + } + if (typeof MessagePort !== "undefined" && object instanceof MessagePort) { + return true; + } + if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) { + return true; + } + if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) { + return true; + } + return false; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-thread.js +var NOOP = () => { +}; +var WorkerThread = class { + name; + source; + url; + terminated = false; + worker; + onMessage; + onError; + _loadableURL = ""; + /** Checks if workers are supported on this platform */ + static isSupported() { + return typeof Worker !== "undefined" && isBrowser3 || typeof NodeWorker !== "undefined" && !isBrowser3; + } + constructor(props) { + const { name: name2, source, url } = props; + assert3(source || url); + this.name = name2; + this.source = source; + this.url = url; + this.onMessage = NOOP; + this.onError = (error) => console.log(error); + this.worker = isBrowser3 ? this._createBrowserWorker() : this._createNodeWorker(); + } + /** + * Terminate this worker thread + * @note Can free up significant memory + */ + destroy() { + this.onMessage = NOOP; + this.onError = NOOP; + this.worker.terminate(); + this.terminated = true; + } + get isRunning() { + return Boolean(this.onMessage); + } + /** + * Send a message to this worker thread + * @param data any data structure, ideally consisting mostly of transferrable objects + * @param transferList If not supplied, calculated automatically by traversing data + */ + postMessage(data, transferList) { + transferList = transferList || getTransferList(data); + this.worker.postMessage(data, transferList); + } + // PRIVATE + /** + * Generate a standard Error from an ErrorEvent + * @param event + */ + _getErrorFromErrorEvent(event) { + let message2 = "Failed to load "; + message2 += `worker ${this.name} from ${this.url}. `; + if (event.message) { + message2 += `${event.message} in `; + } + if (event.lineno) { + message2 += `:${event.lineno}:${event.colno}`; + } + return new Error(message2); + } + /** + * Creates a worker thread on the browser + */ + _createBrowserWorker() { + this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url }); + const worker = new Worker(this._loadableURL, { name: this.name }); + worker.onmessage = (event) => { + if (!event.data) { + this.onError(new Error("No data received")); + } else { + this.onMessage(event.data); + } + }; + worker.onerror = (error) => { + this.onError(this._getErrorFromErrorEvent(error)); + this.terminated = true; + }; + worker.onmessageerror = (event) => console.error(event); + return worker; + } + /** + * Creates a worker thread in node.js + * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool + */ + _createNodeWorker() { + let worker; + if (this.url) { + const absolute = this.url.includes(":/") || this.url.startsWith("/"); + const url = absolute ? this.url : `./${this.url}`; + worker = new NodeWorker(url, { eval: false }); + } else if (this.source) { + worker = new NodeWorker(this.source, { eval: true }); + } else { + throw new Error("no worker"); + } + worker.on("message", (data) => { + this.onMessage(data); + }); + worker.on("error", (error) => { + this.onError(error); + }); + worker.on("exit", (code) => { + }); + return worker; + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-pool.js +var WorkerPool = class { + name = "unnamed"; + source; + // | Function; + url; + maxConcurrency = 1; + maxMobileConcurrency = 1; + onDebug = () => { + }; + reuseWorkers = true; + props = {}; + jobQueue = []; + idleQueue = []; + count = 0; + isDestroyed = false; + /** Checks if workers are supported on this platform */ + static isSupported() { + return WorkerThread.isSupported(); + } + /** + * @param processor - worker function + * @param maxConcurrency - max count of workers + */ + constructor(props) { + this.source = props.source; + this.url = props.url; + this.setProps(props); + } + /** + * Terminates all workers in the pool + * @note Can free up significant memory + */ + destroy() { + this.idleQueue.forEach((worker) => worker.destroy()); + this.isDestroyed = true; + } + setProps(props) { + this.props = { ...this.props, ...props }; + if (props.name !== void 0) { + this.name = props.name; + } + if (props.maxConcurrency !== void 0) { + this.maxConcurrency = props.maxConcurrency; + } + if (props.maxMobileConcurrency !== void 0) { + this.maxMobileConcurrency = props.maxMobileConcurrency; + } + if (props.reuseWorkers !== void 0) { + this.reuseWorkers = props.reuseWorkers; + } + if (props.onDebug !== void 0) { + this.onDebug = props.onDebug; + } + } + async startJob(name2, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) { + const startPromise = new Promise((onStart) => { + this.jobQueue.push({ name: name2, onMessage: onMessage2, onError, onStart }); + return this; + }); + this._startQueuedJob(); + return await startPromise; + } + // PRIVATE + /** + * Starts first queued job if worker is available or can be created + * Called when job is started and whenever a worker returns to the idleQueue + */ + async _startQueuedJob() { + if (!this.jobQueue.length) { + return; + } + const workerThread = this._getAvailableWorker(); + if (!workerThread) { + return; + } + const queuedJob = this.jobQueue.shift(); + if (queuedJob) { + this.onDebug({ + message: "Starting job", + name: queuedJob.name, + workerThread, + backlog: this.jobQueue.length + }); + const job = new WorkerJob(queuedJob.name, workerThread); + workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload); + workerThread.onError = (error) => queuedJob.onError(job, error); + queuedJob.onStart(job); + try { + await job.result; + } catch (error) { + console.error(`Worker exception: ${error}`); + } finally { + this.returnWorkerToQueue(workerThread); + } + } + } + /** + * Returns a worker to the idle queue + * Destroys the worker if + * - pool is destroyed + * - if this pool doesn't reuse workers + * - if maxConcurrency has been lowered + * @param worker + */ + returnWorkerToQueue(worker) { + const shouldDestroyWorker = ( + // Workers on Node.js prevent the process from exiting. + // Until we figure out how to close them before exit, we always destroy them + !isBrowser3 || // If the pool is destroyed, there is no reason to keep the worker around + this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed + !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements + this.count > this._getMaxConcurrency() + ); + if (shouldDestroyWorker) { + worker.destroy(); + this.count--; + } else { + this.idleQueue.push(worker); + } + if (!this.isDestroyed) { + this._startQueuedJob(); + } + } + /** + * Returns idle worker or creates new worker if maxConcurrency has not been reached + */ + _getAvailableWorker() { + if (this.idleQueue.length > 0) { + return this.idleQueue.shift() || null; + } + if (this.count < this._getMaxConcurrency()) { + this.count++; + const name2 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`; + return new WorkerThread({ name: name2, source: this.source, url: this.url }); + } + return null; + } + _getMaxConcurrency() { + return isMobile2 ? this.maxMobileConcurrency : this.maxConcurrency; + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-farm.js +var DEFAULT_PROPS = { + maxConcurrency: 3, + maxMobileConcurrency: 1, + reuseWorkers: true, + onDebug: () => { + } +}; +var WorkerFarm = class _WorkerFarm { + props; + workerPools = /* @__PURE__ */ new Map(); + // singleton + static _workerFarm; + /** Checks if workers are supported on this platform */ + static isSupported() { + return WorkerThread.isSupported(); + } + /** Get the singleton instance of the global worker farm */ + static getWorkerFarm(props = {}) { + _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({}); + _WorkerFarm._workerFarm.setProps(props); + return _WorkerFarm._workerFarm; + } + /** get global instance with WorkerFarm.getWorkerFarm() */ + constructor(props) { + this.props = { ...DEFAULT_PROPS }; + this.setProps(props); + this.workerPools = /* @__PURE__ */ new Map(); + } + /** + * Terminate all workers in the farm + * @note Can free up significant memory + */ + destroy() { + for (const workerPool of this.workerPools.values()) { + workerPool.destroy(); + } + this.workerPools = /* @__PURE__ */ new Map(); + } + /** + * Set props used when initializing worker pools + * @param props + */ + setProps(props) { + this.props = { ...this.props, ...props }; + for (const workerPool of this.workerPools.values()) { + workerPool.setProps(this._getWorkerPoolProps()); + } + } + /** + * Returns a worker pool for the specified worker + * @param options - only used first time for a specific worker name + * @param options.name - the name of the worker - used to identify worker pool + * @param options.url - + * @param options.source - + * @example + * const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...); + */ + getWorkerPool(options) { + const { name: name2, source, url } = options; + let workerPool = this.workerPools.get(name2); + if (!workerPool) { + workerPool = new WorkerPool({ + name: name2, + source, + url + }); + workerPool.setProps(this._getWorkerPoolProps()); + this.workerPools.set(name2, workerPool); + } + return workerPool; + } + _getWorkerPoolProps() { + return { + maxConcurrency: this.props.maxConcurrency, + maxMobileConcurrency: this.props.maxMobileConcurrency, + reuseWorkers: this.props.reuseWorkers, + onDebug: this.props.onDebug + }; + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-api/get-worker-url.js +function getWorkerURL(worker, options = {}) { + const workerOptions = options[worker.id] || {}; + const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`; + let url = workerOptions.workerUrl; + if (!url && worker.id === "compression") { + url = options.workerUrl; + } + if (options._workerType === "test") { + if (isBrowser3) { + url = `modules/${worker.module}/dist/${workerFile}`; + } else { + url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`; + } + } + if (!url) { + let version2 = worker.version; + if (version2 === "latest") { + version2 = NPM_TAG; + } + const versionTag = version2 ? `@${version2}` : ""; + url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`; + } + assert3(url); + return url; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-api/validate-worker-version.js +function validateWorkerVersion(worker, coreVersion = VERSION3) { + assert3(worker, "no worker provided"); + const workerVersion = worker.version; + if (!coreVersion || !workerVersion) { + return false; + } + return true; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/worker-loader-utils/parse-with-worker.js +function canParseWithWorker(loader, options) { + if (!WorkerFarm.isSupported()) { + return false; + } + if (!isBrowser3 && !options?._nodeWorkers) { + return false; + } + return loader.worker && options?.worker; +} +async function parseWithWorker(loader, data, options, context, parseOnMainThread) { + const name2 = loader.id; + const url = getWorkerURL(loader, options); + const workerFarm = WorkerFarm.getWorkerFarm(options); + const workerPool = workerFarm.getWorkerPool({ name: name2, url }); + options = JSON.parse(JSON.stringify(options)); + context = JSON.parse(JSON.stringify(context || {})); + const job = await workerPool.startJob( + "process-on-worker", + // @ts-expect-error + onMessage.bind(null, parseOnMainThread) + // eslint-disable-line @typescript-eslint/no-misused-promises + ); + job.postMessage("process", { + // @ts-ignore + input: data, + options, + context + }); + const result = await job.result; + return await result.result; +} +async function onMessage(parseOnMainThread, job, type, payload) { + switch (type) { + case "done": + job.done(payload); + break; + case "error": + job.error(new Error(payload.error)); + break; + case "process": + const { id, input, options } = payload; + try { + const result = await parseOnMainThread(input, options); + job.postMessage("done", { id, result }); + } catch (error) { + const message2 = error instanceof Error ? error.message : "unknown error"; + job.postMessage("error", { id, error: message2 }); + } + break; + default: + console.warn(`parse-with-worker unknown message ${type}`); + } +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/array-buffer-utils.js +function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) { + byteLength = byteLength || arrayBuffer1.byteLength; + if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) { + return false; + } + const array1 = new Uint8Array(arrayBuffer1); + const array2 = new Uint8Array(arrayBuffer2); + for (let i = 0; i < array1.length; ++i) { + if (array1[i] !== array2[i]) { + return false; + } + } + return true; +} +function concatenateArrayBuffers(...sources) { + return concatenateArrayBuffersFromArray(sources); +} +function concatenateArrayBuffersFromArray(sources) { + const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2); + const byteLength = sourceArrays.reduce((length10, typedArray) => length10 + typedArray.byteLength, 0); + const result = new Uint8Array(byteLength); + let offset = 0; + for (const sourceArray of sourceArrays) { + result.set(sourceArray, offset); + offset += sourceArray.byteLength; + } + return result.buffer; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/iterators/async-iteration.js +async function concatenateArrayBuffersAsync(asyncIterator) { + const arrayBuffers = []; + for await (const chunk of asyncIterator) { + arrayBuffers.push(chunk); + } + return concatenateArrayBuffers(...arrayBuffers); +} + +// node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js +function getHiResTimestamp2() { + let timestamp; + if (typeof window !== "undefined" && window.performance) { + timestamp = window.performance.now(); + } else if (typeof process !== "undefined" && process.hrtime) { + const timeParts = process.hrtime(); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; +} + +// node_modules/@probe.gl/stats/dist/lib/stat.js +var Stat = class { + constructor(name2, type) { + this.sampleSize = 1; + this.time = 0; + this.count = 0; + this.samples = 0; + this.lastTiming = 0; + this.lastSampleTime = 0; + this.lastSampleCount = 0; + this._count = 0; + this._time = 0; + this._samples = 0; + this._startTime = 0; + this._timerPending = false; + this.name = name2; + this.type = type; + this.reset(); + } + reset() { + this.time = 0; + this.count = 0; + this.samples = 0; + this.lastTiming = 0; + this.lastSampleTime = 0; + this.lastSampleCount = 0; + this._count = 0; + this._time = 0; + this._samples = 0; + this._startTime = 0; + this._timerPending = false; + return this; + } + setSampleSize(samples) { + this.sampleSize = samples; + return this; + } + /** Call to increment count (+1) */ + incrementCount() { + this.addCount(1); + return this; + } + /** Call to decrement count (-1) */ + decrementCount() { + this.subtractCount(1); + return this; + } + /** Increase count */ + addCount(value) { + this._count += value; + this._samples++; + this._checkSampling(); + return this; + } + /** Decrease count */ + subtractCount(value) { + this._count -= value; + this._samples++; + this._checkSampling(); + return this; + } + /** Add an arbitrary timing and bump the count */ + addTime(time) { + this._time += time; + this.lastTiming = time; + this._samples++; + this._checkSampling(); + return this; + } + /** Start a timer */ + timeStart() { + this._startTime = getHiResTimestamp2(); + this._timerPending = true; + return this; + } + /** End a timer. Adds to time and bumps the timing count. */ + timeEnd() { + if (!this._timerPending) { + return this; + } + this.addTime(getHiResTimestamp2() - this._startTime); + this._timerPending = false; + this._checkSampling(); + return this; + } + getSampleAverageCount() { + return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0; + } + /** Calculate average time / count for the previous window */ + getSampleAverageTime() { + return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0; + } + /** Calculate counts per second for the previous window */ + getSampleHz() { + return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0; + } + getAverageCount() { + return this.samples > 0 ? this.count / this.samples : 0; + } + /** Calculate average time / count */ + getAverageTime() { + return this.samples > 0 ? this.time / this.samples : 0; + } + /** Calculate counts per second */ + getHz() { + return this.time > 0 ? this.samples / (this.time / 1e3) : 0; + } + _checkSampling() { + if (this._samples === this.sampleSize) { + this.lastSampleTime = this._time; + this.lastSampleCount = this._count; + this.count += this._count; + this.time += this._time; + this.samples += this._samples; + this._time = 0; + this._count = 0; + this._samples = 0; + } + } +}; + +// node_modules/@probe.gl/stats/dist/lib/stats.js +var Stats = class { + constructor(options) { + this.stats = {}; + this.id = options.id; + this.stats = {}; + this._initializeStats(options.stats); + Object.seal(this); + } + /** Acquire a stat. Create if it doesn't exist. */ + get(name2, type = "count") { + return this._getOrCreate({ name: name2, type }); + } + get size() { + return Object.keys(this.stats).length; + } + /** Reset all stats */ + reset() { + for (const stat of Object.values(this.stats)) { + stat.reset(); + } + return this; + } + forEach(fn) { + for (const stat of Object.values(this.stats)) { + fn(stat); + } + } + getTable() { + const table = {}; + this.forEach((stat) => { + table[stat.name] = { + time: stat.time || 0, + count: stat.count || 0, + average: stat.getAverageTime() || 0, + hz: stat.getHz() || 0 + }; + }); + return table; + } + _initializeStats(stats = []) { + stats.forEach((stat) => this._getOrCreate(stat)); + } + _getOrCreate(stat) { + const { name: name2, type } = stat; + let result = this.stats[name2]; + if (!result) { + if (stat instanceof Stat) { + result = stat; + } else { + result = new Stat(name2, type); + } + this.stats[name2] = result; + } + return result; + } +}; + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/file-aliases.js +var pathPrefix = ""; +var fileAliases = {}; +function resolvePath(filename2) { + for (const alias in fileAliases) { + if (filename2.startsWith(alias)) { + const replacement = fileAliases[alias]; + filename2 = filename2.replace(alias, replacement); + } + } + if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) { + filename2 = `${pathPrefix}${filename2}`; + } + return filename2; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/node/buffer.browser.js +function toArrayBuffer(buffer) { + return buffer; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/memory-conversion-utils.js +function isBuffer(value) { + return value && typeof value === "object" && value.isBuffer; +} +function toArrayBuffer2(data) { + if (isBuffer(data)) { + return toArrayBuffer(data); + } + if (data instanceof ArrayBuffer) { + return data; + } + if (ArrayBuffer.isView(data)) { + if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) { + return data.buffer; + } + return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength); + } + if (typeof data === "string") { + const text = data; + const uint8Array = new TextEncoder().encode(text); + return uint8Array.buffer; + } + if (data && typeof data === "object" && data._toArrayBuffer) { + return data._toArrayBuffer(); + } + throw new Error("toArrayBuffer"); +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/path.js +var path_exports = {}; +__export(path_exports, { + dirname: () => dirname, + filename: () => filename, + join: () => join, + resolve: () => resolve +}); + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/get-cwd.js +function getCWD() { + if (typeof process !== "undefined" && typeof process.cwd !== "undefined") { + return process.cwd(); + } + const pathname = window.location?.pathname; + return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || ""; +} + +// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/path.js +function filename(url) { + const slashIndex = url ? url.lastIndexOf("/") : -1; + return slashIndex >= 0 ? url.substr(slashIndex + 1) : ""; +} +function dirname(url) { + const slashIndex = url ? url.lastIndexOf("/") : -1; + return slashIndex >= 0 ? url.substr(0, slashIndex) : ""; +} +function join(...parts) { + const separator = "/"; + parts = parts.map((part, index2) => { + if (index2) { + part = part.replace(new RegExp(`^${separator}`), ""); + } + if (index2 !== parts.length - 1) { + part = part.replace(new RegExp(`${separator}$`), ""); + } + return part; + }); + return parts.join(separator); +} +function resolve(...components) { + const paths = []; + for (let _i = 0; _i < components.length; _i++) { + paths[_i] = components[_i]; + } + let resolvedPath = ""; + let resolvedAbsolute = false; + let cwd; + for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) { + let path; + if (i >= 0) { + path = paths[i]; + } else { + if (cwd === void 0) { + cwd = getCWD(); + } + path = cwd; + } + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === SLASH; + } + resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute) { + return `/${resolvedPath}`; + } else if (resolvedPath.length > 0) { + return resolvedPath; + } + return "."; +} +var SLASH = 47; +var DOT = 46; +function normalizeStringPosix(path, allowAboveRoot) { + let res = ""; + let lastSlash = -1; + let dots = 0; + let code; + let isAboveRoot = false; + for (let i = 0; i <= path.length; ++i) { + if (i < path.length) { + code = path.charCodeAt(i); + } else if (code === SLASH) { + break; + } else { + code = SLASH; + } + if (code === SLASH) { + if (lastSlash === i - 1 || dots === 1) { + } else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) { + if (res.length > 2) { + const start = res.length - 1; + let j = start; + for (; j >= 0; --j) { + if (res.charCodeAt(j) === SLASH) { + break; + } + } + if (j !== start) { + res = j === -1 ? "" : res.slice(0, j); + lastSlash = i; + dots = 0; + isAboveRoot = false; + continue; + } + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSlash = i; + dots = 0; + isAboveRoot = false; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) { + res += "/.."; + } else { + res = ".."; + } + isAboveRoot = true; + } + } else { + const slice = path.slice(lastSlash + 1, i); + if (res.length > 0) { + res += `/${slice}`; + } else { + res = slice; + } + isAboveRoot = false; + } + lastSlash = i; + dots = 0; + } else if (code === DOT && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} + +// node_modules/@loaders.gl/core/dist/javascript-utils/is-type.js +var isBoolean = (x) => typeof x === "boolean"; +var isFunction = (x) => typeof x === "function"; +var isObject = (x) => x !== null && typeof x === "object"; +var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor; +var isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function"; +var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function"; +var isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json; +var isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob; +var isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer; +var isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader); +var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable); +var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x); + +// node_modules/@loaders.gl/core/dist/lib/fetch/fetch-error.js +var FetchError = class extends Error { + constructor(message2, info) { + super(message2); + this.reason = info.reason; + this.url = info.url; + this.response = info.response; + } + /** A best effort reason for why the fetch failed */ + reason; + /** The URL that failed to load. Empty string if not available. */ + url; + /** The Response object, if any. */ + response; +}; + +// node_modules/@loaders.gl/core/dist/lib/utils/mime-type-utils.js +var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/; +var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/; +function compareMIMETypes(mimeType1, mimeType2) { + if (mimeType1.toLowerCase() === mimeType2.toLowerCase()) { + return true; + } + return false; +} +function parseMIMEType(mimeString) { + const matches4 = MIME_TYPE_PATTERN.exec(mimeString); + if (matches4) { + return matches4[1]; + } + return mimeString; +} +function parseMIMETypeFromURL(url) { + const matches4 = DATA_URL_PATTERN.exec(url); + if (matches4) { + return matches4[1]; + } + return ""; +} + +// node_modules/@loaders.gl/core/dist/lib/utils/url-utils.js +var QUERY_STRING_PATTERN = /\?.*/; +function extractQueryString(url) { + const matches4 = url.match(QUERY_STRING_PATTERN); + return matches4 && matches4[0]; +} +function stripQueryString(url) { + return url.replace(QUERY_STRING_PATTERN, ""); +} +function shortenUrlForDisplay(url) { + if (url.length < 50) { + return url; + } + const urlEnd = url.slice(url.length - 15); + const urlStart = url.substr(0, 32); + return `${urlStart}...${urlEnd}`; +} + +// node_modules/@loaders.gl/core/dist/lib/utils/resource-utils.js +function getResourceUrl(resource) { + if (isResponse(resource)) { + const response = resource; + return response.url; + } + if (isBlob(resource)) { + const blob = resource; + return blob.name || ""; + } + if (typeof resource === "string") { + return resource; + } + return ""; +} +function getResourceMIMEType(resource) { + if (isResponse(resource)) { + const response = resource; + const contentTypeHeader = response.headers.get("content-type") || ""; + const noQueryUrl = stripQueryString(response.url); + return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl); + } + if (isBlob(resource)) { + const blob = resource; + return blob.type || ""; + } + if (typeof resource === "string") { + return parseMIMETypeFromURL(resource); + } + return ""; +} +function getResourceContentLength(resource) { + if (isResponse(resource)) { + const response = resource; + return response.headers["content-length"] || -1; + } + if (isBlob(resource)) { + const blob = resource; + return blob.size; + } + if (typeof resource === "string") { + return resource.length; + } + if (resource instanceof ArrayBuffer) { + return resource.byteLength; + } + if (ArrayBuffer.isView(resource)) { + return resource.byteLength; + } + return -1; +} + +// node_modules/@loaders.gl/core/dist/lib/utils/response-utils.js +async function makeResponse(resource) { + if (isResponse(resource)) { + return resource; + } + const headers = {}; + const contentLength = getResourceContentLength(resource); + if (contentLength >= 0) { + headers["content-length"] = String(contentLength); + } + const url = getResourceUrl(resource); + const type = getResourceMIMEType(resource); + if (type) { + headers["content-type"] = type; + } + const initialDataUrl = await getInitialDataUrl(resource); + if (initialDataUrl) { + headers["x-first-bytes"] = initialDataUrl; + } + if (typeof resource === "string") { + resource = new TextEncoder().encode(resource); + } + const response = new Response(resource, { headers }); + Object.defineProperty(response, "url", { value: url }); + return response; +} +async function checkResponse(response) { + if (!response.ok) { + const error = await getResponseError(response); + throw error; + } +} +async function getResponseError(response) { + const shortUrl = shortenUrlForDisplay(response.url); + let message2 = `Failed to fetch resource (${response.status}) ${response.statusText}: ${shortUrl}`; + message2 = message2.length > 100 ? `${message2.slice(0, 100)}...` : message2; + const info = { + reason: response.statusText, + url: response.url, + response + }; + try { + const contentType = response.headers.get("Content-Type"); + info.reason = !response.bodyUsed && contentType?.includes("application/json") ? await response.json() : await response.text(); + } catch (error) { + } + return new FetchError(message2, info); +} +async function getInitialDataUrl(resource) { + const INITIAL_DATA_LENGTH = 5; + if (typeof resource === "string") { + return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`; + } + if (resource instanceof Blob) { + const blobSlice = resource.slice(0, 5); + return await new Promise((resolve2) => { + const reader = new FileReader(); + reader.onload = (event) => resolve2(event?.target?.result); + reader.readAsDataURL(blobSlice); + }); + } + if (resource instanceof ArrayBuffer) { + const slice = resource.slice(0, INITIAL_DATA_LENGTH); + const base64 = arrayBufferToBase64(slice); + return `data:base64,${base64}`; + } + return null; +} +function arrayBufferToBase64(buffer) { + let binary = ""; + const bytes = new Uint8Array(buffer); + for (let i = 0; i < bytes.byteLength; i++) { + binary += String.fromCharCode(bytes[i]); + } + return btoa(binary); +} + +// node_modules/@loaders.gl/core/dist/lib/fetch/fetch-file.js +function isNodePath(url) { + return !isRequestURL(url) && !isDataURL(url); +} +function isRequestURL(url) { + return url.startsWith("http:") || url.startsWith("https:"); +} +function isDataURL(url) { + return url.startsWith("data:"); +} +async function fetchFile(urlOrData, fetchOptions) { + if (typeof urlOrData === "string") { + const url = resolvePath(urlOrData); + if (isNodePath(url)) { + if (globalThis.loaders?.fetchNode) { + return globalThis.loaders?.fetchNode(url, fetchOptions); + } + } + return await fetch(url, fetchOptions); + } + return await makeResponse(urlOrData); +} + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/loggers.js +var probeLog = new Log({ id: "loaders.gl" }); +var NullLog = class { + log() { + return () => { + }; + } + info() { + return () => { + }; + } + warn() { + return () => { + }; + } + error() { + return () => { + }; + } +}; +var ConsoleLog = class { + console; + constructor() { + this.console = console; + } + log(...args) { + return this.console.log.bind(this.console, ...args); + } + info(...args) { + return this.console.info.bind(this.console, ...args); + } + warn(...args) { + return this.console.warn.bind(this.console, ...args); + } + error(...args) { + return this.console.error.bind(this.console, ...args); + } +}; + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/option-defaults.js +var DEFAULT_LOADER_OPTIONS = { + // baseUri + fetch: null, + mimeType: void 0, + nothrow: false, + log: new ConsoleLog(), + // A probe.gl compatible (`log.log()()` syntax) that just logs to console + useLocalLibraries: false, + CDN: "https://unpkg.com/@loaders.gl", + worker: true, + // By default, use worker if provided by loader. + maxConcurrency: 3, + // How many worker instances should be created for each loader. + maxMobileConcurrency: 1, + // How many worker instances should be created for each loader on mobile devices. + reuseWorkers: isBrowser, + // By default reuse workers in browser (Node.js refuses to terminate if browsers are running) + _nodeWorkers: false, + // By default do not support node workers + _workerType: "", + // 'test' to use locally generated workers + limit: 0, + _limitMB: 0, + batchSize: "auto", + batchDebounceMs: 0, + metadata: false, + // TODO - currently only implemented for parseInBatches, adds initial metadata batch, + transforms: [] +}; +var REMOVED_LOADER_OPTIONS = { + throws: "nothrow", + dataType: "(no longer used)", + uri: "baseUri", + // Warn if fetch options are used on top-level + method: "fetch.method", + headers: "fetch.headers", + body: "fetch.body", + mode: "fetch.mode", + credentials: "fetch.credentials", + cache: "fetch.cache", + redirect: "fetch.redirect", + referrer: "fetch.referrer", + referrerPolicy: "fetch.referrerPolicy", + integrity: "fetch.integrity", + keepalive: "fetch.keepalive", + signal: "fetch.signal" +}; + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/option-utils.js +function getGlobalLoaderState() { + globalThis.loaders = globalThis.loaders || {}; + const { loaders } = globalThis; + if (!loaders._state) { + loaders._state = {}; + } + return loaders._state; +} +function getGlobalLoaderOptions() { + const state = getGlobalLoaderState(); + state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS }; + return state.globalOptions; +} +function normalizeOptions(options, loader, loaders, url) { + loaders = loaders || []; + loaders = Array.isArray(loaders) ? loaders : [loaders]; + validateOptions(options, loaders); + return normalizeOptionsInternal(loader, options, url); +} +function validateOptions(options, loaders) { + validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders); + for (const loader of loaders) { + const idOptions = options && options[loader.id] || {}; + const loaderOptions = loader.options && loader.options[loader.id] || {}; + const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {}; + validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders); + } +} +function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) { + const loaderName = id || "Top level"; + const prefix = id ? `${id}.` : ""; + for (const key in options) { + const isSubOptions = !id && isObject(options[key]); + const isBaseUriOption = key === "baseUri" && !id; + const isWorkerUrlOption = key === "workerUrl" && id; + if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) { + if (key in deprecatedOptions) { + probeLog.warn(`${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`)(); + } else if (!isSubOptions) { + const suggestion = findSimilarOption(key, loaders); + probeLog.warn(`${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`)(); + } + } + } +} +function findSimilarOption(optionKey, loaders) { + const lowerCaseOptionKey = optionKey.toLowerCase(); + let bestSuggestion = ""; + for (const loader of loaders) { + for (const key in loader.options) { + if (optionKey === key) { + return `Did you mean '${loader.id}.${key}'?`; + } + const lowerCaseKey = key.toLowerCase(); + const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey); + if (isPartialMatch) { + bestSuggestion = bestSuggestion || `Did you mean '${loader.id}.${key}'?`; + } + } + } + return bestSuggestion; +} +function normalizeOptionsInternal(loader, options, url) { + const loaderDefaultOptions = loader.options || {}; + const mergedOptions = { ...loaderDefaultOptions }; + addUrlOptions(mergedOptions, url); + if (mergedOptions.log === null) { + mergedOptions.log = new NullLog(); + } + mergeNestedFields(mergedOptions, getGlobalLoaderOptions()); + mergeNestedFields(mergedOptions, options); + return mergedOptions; +} +function mergeNestedFields(mergedOptions, options) { + for (const key in options) { + if (key in options) { + const value = options[key]; + if (isPureObject(value) && isPureObject(mergedOptions[key])) { + mergedOptions[key] = { + ...mergedOptions[key], + ...options[key] + }; + } else { + mergedOptions[key] = options[key]; + } + } + } +} +function addUrlOptions(options, url) { + if (url && !("baseUri" in options)) { + options.baseUri = url; + } +} + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/normalize-loader.js +function isLoaderObject(loader) { + if (!loader) { + return false; + } + if (Array.isArray(loader)) { + loader = loader[0]; + } + const hasExtensions = Array.isArray(loader?.extensions); + return hasExtensions; +} +function normalizeLoader(loader) { + assert(loader, "null loader"); + assert(isLoaderObject(loader), "invalid loader"); + let options; + if (Array.isArray(loader)) { + options = loader[1]; + loader = loader[0]; + loader = { + ...loader, + options: { ...loader.options, ...options } + }; + } + if (loader?.parseTextSync || loader?.parseText) { + loader.text = true; + } + if (!loader.text) { + loader.binary = true; + } + return loader; +} + +// node_modules/@loaders.gl/core/dist/lib/api/register-loaders.js +var getGlobalLoaderRegistry = () => { + const state = getGlobalLoaderState(); + state.loaderRegistry = state.loaderRegistry || []; + return state.loaderRegistry; +}; +function registerLoaders(loaders) { + const loaderRegistry = getGlobalLoaderRegistry(); + loaders = Array.isArray(loaders) ? loaders : [loaders]; + for (const loader of loaders) { + const normalizedLoader = normalizeLoader(loader); + if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) { + loaderRegistry.unshift(normalizedLoader); + } + } +} +function getRegisteredLoaders() { + return getGlobalLoaderRegistry(); +} + +// node_modules/@loaders.gl/core/dist/lib/api/select-loader.js +var EXT_PATTERN = /\.([^.]+)$/; +async function selectLoader(data, loaders = [], options, context) { + if (!validHTTPResponse(data)) { + return null; + } + let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context); + if (loader) { + return loader; + } + if (isBlob(data)) { + data = await data.slice(0, 10).arrayBuffer(); + loader = selectLoaderSync(data, loaders, options, context); + } + if (!loader && !options?.nothrow) { + throw new Error(getNoValidLoaderMessage(data)); + } + return loader; +} +function selectLoaderSync(data, loaders = [], options, context) { + if (!validHTTPResponse(data)) { + return null; + } + if (loaders && !Array.isArray(loaders)) { + return normalizeLoader(loaders); + } + let candidateLoaders = []; + if (loaders) { + candidateLoaders = candidateLoaders.concat(loaders); + } + if (!options?.ignoreRegisteredLoaders) { + candidateLoaders.push(...getRegisteredLoaders()); + } + normalizeLoaders(candidateLoaders); + const loader = selectLoaderInternal(data, candidateLoaders, options, context); + if (!loader && !options?.nothrow) { + throw new Error(getNoValidLoaderMessage(data)); + } + return loader; +} +function selectLoaderInternal(data, loaders, options, context) { + const url = getResourceUrl(data); + const type = getResourceMIMEType(data); + const testUrl = stripQueryString(url) || context?.url; + let loader = null; + let reason = ""; + if (options?.mimeType) { + loader = findLoaderByMIMEType(loaders, options?.mimeType); + reason = `match forced by supplied MIME type ${options?.mimeType}`; + } + loader = loader || findLoaderByUrl(loaders, testUrl); + reason = reason || (loader ? `matched url ${testUrl}` : ""); + loader = loader || findLoaderByMIMEType(loaders, type); + reason = reason || (loader ? `matched MIME type ${type}` : ""); + loader = loader || findLoaderByInitialBytes(loaders, data); + reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : ""); + if (options?.fallbackMimeType) { + loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType); + reason = reason || (loader ? `matched fallback MIME type ${type}` : ""); + } + if (reason) { + log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`); + } + return loader; +} +function validHTTPResponse(data) { + if (data instanceof Response) { + if (data.status === 204) { + return false; + } + } + return true; +} +function getNoValidLoaderMessage(data) { + const url = getResourceUrl(data); + const type = getResourceMIMEType(data); + let message2 = "No valid loader found ("; + message2 += url ? `${path_exports.filename(url)}, ` : "no url provided, "; + message2 += `MIME type: ${type ? `"${type}"` : "not provided"}, `; + const firstCharacters = data ? getFirstCharacters(data) : ""; + message2 += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available"; + message2 += ")"; + return message2; +} +function normalizeLoaders(loaders) { + for (const loader of loaders) { + normalizeLoader(loader); + } +} +function findLoaderByUrl(loaders, url) { + const match = url && EXT_PATTERN.exec(url); + const extension = match && match[1]; + return extension ? findLoaderByExtension(loaders, extension) : null; +} +function findLoaderByExtension(loaders, extension) { + extension = extension.toLowerCase(); + for (const loader of loaders) { + for (const loaderExtension of loader.extensions) { + if (loaderExtension.toLowerCase() === extension) { + return loader; + } + } + } + return null; +} +function findLoaderByMIMEType(loaders, mimeType) { + for (const loader of loaders) { + if (loader.mimeTypes?.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) { + return loader; + } + if (compareMIMETypes(mimeType, `application/x.${loader.id}`)) { + return loader; + } + } + return null; +} +function findLoaderByInitialBytes(loaders, data) { + if (!data) { + return null; + } + for (const loader of loaders) { + if (typeof data === "string") { + if (testDataAgainstText(data, loader)) { + return loader; + } + } else if (ArrayBuffer.isView(data)) { + if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) { + return loader; + } + } else if (data instanceof ArrayBuffer) { + const byteOffset = 0; + if (testDataAgainstBinary(data, byteOffset, loader)) { + return loader; + } + } + } + return null; +} +function testDataAgainstText(data, loader) { + if (loader.testText) { + return loader.testText(data); + } + const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; + return tests.some((test) => data.startsWith(test)); +} +function testDataAgainstBinary(data, byteOffset, loader) { + const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; + return tests.some((test) => testBinary(data, byteOffset, loader, test)); +} +function testBinary(data, byteOffset, loader, test) { + if (test instanceof ArrayBuffer) { + return compareArrayBuffers(test, data, test.byteLength); + } + switch (typeof test) { + case "function": + return test(data); + case "string": + const magic = getMagicString(data, byteOffset, test.length); + return test === magic; + default: + return false; + } +} +function getFirstCharacters(data, length10 = 5) { + if (typeof data === "string") { + return data.slice(0, length10); + } else if (ArrayBuffer.isView(data)) { + return getMagicString(data.buffer, data.byteOffset, length10); + } else if (data instanceof ArrayBuffer) { + const byteOffset = 0; + return getMagicString(data, byteOffset, length10); + } + return ""; +} +function getMagicString(arrayBuffer2, byteOffset, length10) { + if (arrayBuffer2.byteLength < byteOffset + length10) { + return ""; + } + const dataView = new DataView(arrayBuffer2); + let magic = ""; + for (let i = 0; i < length10; i++) { + magic += String.fromCharCode(dataView.getUint8(byteOffset + i)); + } + return magic; +} + +// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-string-iterator.js +var DEFAULT_CHUNK_SIZE = 256 * 1024; +function* makeStringIterator(string, options) { + const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE; + let offset = 0; + const textEncoder = new TextEncoder(); + while (offset < string.length) { + const chunkLength = Math.min(string.length - offset, chunkSize); + const chunk = string.slice(offset, offset + chunkLength); + offset += chunkLength; + yield textEncoder.encode(chunk); + } +} + +// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-array-buffer-iterator.js +var DEFAULT_CHUNK_SIZE2 = 256 * 1024; +function* makeArrayBufferIterator(arrayBuffer2, options = {}) { + const { chunkSize = DEFAULT_CHUNK_SIZE2 } = options; + let byteOffset = 0; + while (byteOffset < arrayBuffer2.byteLength) { + const chunkByteLength = Math.min(arrayBuffer2.byteLength - byteOffset, chunkSize); + const chunk = new ArrayBuffer(chunkByteLength); + const sourceArray = new Uint8Array(arrayBuffer2, byteOffset, chunkByteLength); + const chunkArray = new Uint8Array(chunk); + chunkArray.set(sourceArray); + byteOffset += chunkByteLength; + yield chunk; + } +} + +// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-blob-iterator.js +var DEFAULT_CHUNK_SIZE3 = 1024 * 1024; +async function* makeBlobIterator(blob, options) { + const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE3; + let offset = 0; + while (offset < blob.size) { + const end = offset + chunkSize; + const chunk = await blob.slice(offset, end).arrayBuffer(); + offset = end; + yield chunk; + } +} + +// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-stream-iterator.js +function makeStreamIterator(stream, options) { + return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options); +} +async function* makeBrowserStreamIterator(stream, options) { + const reader = stream.getReader(); + let nextBatchPromise; + try { + while (true) { + const currentBatchPromise = nextBatchPromise || reader.read(); + if (options?._streamReadAhead) { + nextBatchPromise = reader.read(); + } + const { done, value } = await currentBatchPromise; + if (done) { + return; + } + yield toArrayBuffer2(value); + } + } catch (error) { + reader.releaseLock(); + } +} +async function* makeNodeStreamIterator(stream, options) { + for await (const chunk of stream) { + yield toArrayBuffer2(chunk); + } +} + +// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-iterator.js +function makeIterator(data, options) { + if (typeof data === "string") { + return makeStringIterator(data, options); + } + if (data instanceof ArrayBuffer) { + return makeArrayBufferIterator(data, options); + } + if (isBlob(data)) { + return makeBlobIterator(data, options); + } + if (isReadableStream(data)) { + return makeStreamIterator(data, options); + } + if (isResponse(data)) { + const response = data; + return makeStreamIterator(response.body, options); + } + throw new Error("makeIterator"); +} + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/get-data.js +var ERR_DATA = "Cannot convert supplied data type"; +function getArrayBufferOrStringFromDataSync(data, loader, options) { + if (loader.text && typeof data === "string") { + return data; + } + if (isBuffer2(data)) { + data = data.buffer; + } + if (data instanceof ArrayBuffer) { + const arrayBuffer2 = data; + if (loader.text && !loader.binary) { + const textDecoder = new TextDecoder("utf8"); + return textDecoder.decode(arrayBuffer2); + } + return arrayBuffer2; + } + if (ArrayBuffer.isView(data)) { + if (loader.text && !loader.binary) { + const textDecoder = new TextDecoder("utf8"); + return textDecoder.decode(data); + } + let arrayBuffer2 = data.buffer; + const byteLength = data.byteLength || data.length; + if (data.byteOffset !== 0 || byteLength !== arrayBuffer2.byteLength) { + arrayBuffer2 = arrayBuffer2.slice(data.byteOffset, data.byteOffset + byteLength); + } + return arrayBuffer2; + } + throw new Error(ERR_DATA); +} +async function getArrayBufferOrStringFromData(data, loader, options) { + const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data); + if (typeof data === "string" || isArrayBuffer) { + return getArrayBufferOrStringFromDataSync(data, loader, options); + } + if (isBlob(data)) { + data = await makeResponse(data); + } + if (isResponse(data)) { + const response = data; + await checkResponse(response); + return loader.binary ? await response.arrayBuffer() : await response.text(); + } + if (isReadableStream(data)) { + data = makeIterator(data, options); + } + if (isIterable(data) || isAsyncIterable(data)) { + return concatenateArrayBuffersAsync(data); + } + throw new Error(ERR_DATA); +} + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/get-fetch-function.js +function getFetchFunction(options, context) { + const globalOptions = getGlobalLoaderOptions(); + const loaderOptions = options || globalOptions; + if (typeof loaderOptions.fetch === "function") { + return loaderOptions.fetch; + } + if (isObject(loaderOptions.fetch)) { + return (url) => fetchFile(url, loaderOptions.fetch); + } + if (context?.fetch) { + return context?.fetch; + } + return fetchFile; +} + +// node_modules/@loaders.gl/core/dist/lib/loader-utils/loader-context.js +function getLoaderContext(context, options, parentContext) { + if (parentContext) { + return parentContext; + } + const newContext = { + fetch: getFetchFunction(options, context), + ...context + }; + if (newContext.url) { + const baseUrl = stripQueryString(newContext.url); + newContext.baseUrl = baseUrl; + newContext.queryString = extractQueryString(newContext.url); + newContext.filename = path_exports.filename(baseUrl); + newContext.baseUrl = path_exports.dirname(baseUrl); + } + if (!Array.isArray(newContext.loaders)) { + newContext.loaders = null; + } + return newContext; +} +function getLoadersFromContext(loaders, context) { + if (loaders && !Array.isArray(loaders)) { + return loaders; + } + let candidateLoaders; + if (loaders) { + candidateLoaders = Array.isArray(loaders) ? loaders : [loaders]; + } + if (context && context.loaders) { + const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders]; + candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders; + } + return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0; +} + +// node_modules/@loaders.gl/core/dist/lib/api/parse.js +async function parse(data, loaders, options, context) { + if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) { + context = void 0; + options = loaders; + loaders = void 0; + } + data = await data; + options = options || {}; + const url = getResourceUrl(data); + const typedLoaders = loaders; + const candidateLoaders = getLoadersFromContext(typedLoaders, context); + const loader = await selectLoader(data, candidateLoaders, options); + if (!loader) { + return null; + } + options = normalizeOptions(options, loader, candidateLoaders, url); + context = getLoaderContext( + // @ts-expect-error + { url, _parse: parse, loaders: candidateLoaders }, + options, + context || null + ); + return await parseWithLoader(loader, data, options, context); +} +async function parseWithLoader(loader, data, options, context) { + validateWorkerVersion(loader); + options = mergeLoaderOptions(loader.options, options); + if (isResponse(data)) { + const response = data; + const { ok, redirected, status, statusText, type, url } = response; + const headers = Object.fromEntries(response.headers.entries()); + context.response = { headers, ok, redirected, status, statusText, type, url }; + } + data = await getArrayBufferOrStringFromData(data, loader, options); + const loaderWithParser = loader; + if (loaderWithParser.parseTextSync && typeof data === "string") { + return loaderWithParser.parseTextSync(data, options, context); + } + if (canParseWithWorker(loader, options)) { + return await parseWithWorker(loader, data, options, context, parse); + } + if (loaderWithParser.parseText && typeof data === "string") { + return await loaderWithParser.parseText(data, options, context); + } + if (loaderWithParser.parse) { + return await loaderWithParser.parse(data, options, context); + } + assert3(!loaderWithParser.parseSync); + throw new Error(`${loader.id} loader - no parser found and worker is disabled`); +} + +// node_modules/@loaders.gl/core/dist/lib/api/load.js +async function load(url, loaders, options, context) { + let resolvedLoaders; + let resolvedOptions; + if (!Array.isArray(loaders) && !isLoaderObject(loaders)) { + resolvedLoaders = []; + resolvedOptions = loaders; + context = void 0; + } else { + resolvedLoaders = loaders; + resolvedOptions = options; + } + const fetch2 = getFetchFunction(resolvedOptions); + let data = url; + if (typeof url === "string") { + data = await fetch2(url); + } + if (isBlob(url)) { + data = await fetch2(url); + } + return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions); +} + +// node_modules/@loaders.gl/images/dist/lib/utils/version.js +var VERSION4 = true ? "4.2.0" : "latest"; + +// node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js +function assert4(condition, message2) { + if (!condition) { + throw new Error(message2 || "loader assertion failed."); + } +} + +// node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js +var globals3 = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document +}; +var self_3 = globals3.self || globals3.window || globals3.global || {}; +var window_4 = globals3.window || globals3.self || globals3.global || {}; +var global_4 = globals3.global || globals3.self || globals3.window || {}; +var document_4 = globals3.document || {}; +var isBrowser4 = ( + // @ts-ignore process does not exist on browser + Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser) +); +var matches3 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); +var nodeVersion3 = matches3 && parseFloat(matches3[1]) || 0; + +// node_modules/@loaders.gl/loader-utils/dist/lib/request-utils/request-scheduler.js +var STAT_QUEUED_REQUESTS = "Queued Requests"; +var STAT_ACTIVE_REQUESTS = "Active Requests"; +var STAT_CANCELLED_REQUESTS = "Cancelled Requests"; +var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever"; +var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever"; +var DEFAULT_PROPS2 = { + id: "request-scheduler", + /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */ + throttleRequests: true, + /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */ + maxRequests: 6, + /** + * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have + * been added to the queue for this amount of time. + */ + debounceTime: 0 +}; +var RequestScheduler = class { + props; + stats; + activeRequestCount = 0; + /** Tracks the number of active requests and prioritizes/cancels queued requests. */ + requestQueue = []; + requestMap = /* @__PURE__ */ new Map(); + updateTimer = null; + constructor(props = {}) { + this.props = { ...DEFAULT_PROPS2, ...props }; + this.stats = new Stats({ id: this.props.id }); + this.stats.get(STAT_QUEUED_REQUESTS); + this.stats.get(STAT_ACTIVE_REQUESTS); + this.stats.get(STAT_CANCELLED_REQUESTS); + this.stats.get(STAT_QUEUED_REQUESTS_EVER); + this.stats.get(STAT_ACTIVE_REQUESTS_EVER); + } + /** + * Called by an application that wants to issue a request, without having it deeply queued by the browser + * + * When the returned promise resolved, it is OK for the application to issue a request. + * The promise resolves to an object that contains a `done` method. + * When the application's request has completed (or failed), the application must call the `done` function + * + * @param handle + * @param getPriority will be called when request "slots" open up, + * allowing the caller to update priority or cancel the request + * Highest priority executes first, priority < 0 cancels the request + * @returns a promise + * - resolves to a object (with a `done` field) when the request can be issued without queueing, + * - resolves to `null` if the request has been cancelled (by the callback return < 0). + * In this case the application should not issue the request + */ + scheduleRequest(handle, getPriority = () => 0) { + if (!this.props.throttleRequests) { + return Promise.resolve({ done: () => { + } }); + } + if (this.requestMap.has(handle)) { + return this.requestMap.get(handle); + } + const request = { handle, priority: 0, getPriority }; + const promise = new Promise((resolve2) => { + request.resolve = resolve2; + return request; + }); + this.requestQueue.push(request); + this.requestMap.set(handle, promise); + this._issueNewRequests(); + return promise; + } + // PRIVATE + _issueRequest(request) { + const { handle, resolve: resolve2 } = request; + let isDone = false; + const done = () => { + if (!isDone) { + isDone = true; + this.requestMap.delete(handle); + this.activeRequestCount--; + this._issueNewRequests(); + } + }; + this.activeRequestCount++; + return resolve2 ? resolve2({ done }) : Promise.resolve({ done }); + } + /** We check requests asynchronously, to prevent multiple updates */ + _issueNewRequests() { + if (this.updateTimer !== null) { + clearTimeout(this.updateTimer); + } + this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime); + } + /** Refresh all requests */ + _issueNewRequestsAsync() { + if (this.updateTimer !== null) { + clearTimeout(this.updateTimer); + } + this.updateTimer = null; + const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0); + if (freeSlots === 0) { + return; + } + this._updateAllRequests(); + for (let i = 0; i < freeSlots; ++i) { + const request = this.requestQueue.shift(); + if (request) { + this._issueRequest(request); + } + } + } + /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */ + _updateAllRequests() { + const requestQueue = this.requestQueue; + for (let i = 0; i < requestQueue.length; ++i) { + const request = requestQueue[i]; + if (!this._updateRequest(request)) { + requestQueue.splice(i, 1); + this.requestMap.delete(request.handle); + i--; + } + } + requestQueue.sort((a, b) => a.priority - b.priority); + } + /** Update a single request by calling the callback */ + _updateRequest(request) { + request.priority = request.getPriority(request.handle); + if (request.priority < 0) { + request.resolve(null); + return false; + } + return true; + } +}; + +// node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js +var parseImageNode = globalThis.loaders?.parseImageNode; +var IMAGE_SUPPORTED = typeof Image !== "undefined"; +var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined"; +var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode); +var DATA_SUPPORTED = isBrowser4 ? true : NODE_IMAGE_SUPPORTED; +function isImageTypeSupported(type) { + switch (type) { + case "auto": + return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED; + case "imagebitmap": + return IMAGE_BITMAP_SUPPORTED; + case "image": + return IMAGE_SUPPORTED; + case "data": + return DATA_SUPPORTED; + default: + throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`); + } +} +function getDefaultImageType() { + if (IMAGE_BITMAP_SUPPORTED) { + return "imagebitmap"; + } + if (IMAGE_SUPPORTED) { + return "image"; + } + if (DATA_SUPPORTED) { + return "data"; + } + throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js"); +} + +// node_modules/@loaders.gl/images/dist/lib/category-api/parsed-image-api.js +function getImageType(image) { + const format = getImageTypeOrNull(image); + if (!format) { + throw new Error("Not an image"); + } + return format; +} +function getImageData(image) { + switch (getImageType(image)) { + case "data": + return image; + case "image": + case "imagebitmap": + const canvas2 = document.createElement("canvas"); + const context = canvas2.getContext("2d"); + if (!context) { + throw new Error("getImageData"); + } + canvas2.width = image.width; + canvas2.height = image.height; + context.drawImage(image, 0, 0); + return context.getImageData(0, 0, image.width, image.height); + default: + throw new Error("getImageData"); + } +} +function getImageTypeOrNull(image) { + if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { + return "imagebitmap"; + } + if (typeof Image !== "undefined" && image instanceof Image) { + return "image"; + } + if (image && typeof image === "object" && image.data && image.width && image.height) { + return "data"; + } + return null; +} + +// node_modules/@loaders.gl/images/dist/lib/parsers/svg-utils.js +var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/; +var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/; +function isSVG(url) { + return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url)); +} +function getBlobOrSVGDataUrl(arrayBuffer2, url) { + if (isSVG(url)) { + const textDecoder = new TextDecoder(); + let xmlText = textDecoder.decode(arrayBuffer2); + try { + if (typeof unescape === "function" && typeof encodeURIComponent === "function") { + xmlText = unescape(encodeURIComponent(xmlText)); + } + } catch (error) { + throw new Error(error.message); + } + const src = `data:image/svg+xml;base64,${btoa(xmlText)}`; + return src; + } + return getBlob(arrayBuffer2, url); +} +function getBlob(arrayBuffer2, url) { + if (isSVG(url)) { + throw new Error("SVG cannot be parsed directly to imagebitmap"); + } + return new Blob([new Uint8Array(arrayBuffer2)]); +} + +// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image.js +async function parseToImage(arrayBuffer2, options, url) { + const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url); + const URL2 = self.URL || self.webkitURL; + const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl); + try { + return await loadToImage(objectUrl || blobOrDataUrl, options); + } finally { + if (objectUrl) { + URL2.revokeObjectURL(objectUrl); + } + } +} +async function loadToImage(url, options) { + const image = new Image(); + image.src = url; + if (options.image && options.image.decode && image.decode) { + await image.decode(); + return image; + } + return await new Promise((resolve2, reject) => { + try { + image.onload = () => resolve2(image); + image.onerror = (error) => { + const message2 = error instanceof Error ? error.message : "error"; + reject(new Error(message2)); + }; + } catch (error) { + reject(error); + } + }); +} + +// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image-bitmap.js +var EMPTY_OBJECT = {}; +var imagebitmapOptionsSupported = true; +async function parseToImageBitmap(arrayBuffer2, options, url) { + let blob; + if (isSVG(url)) { + const image = await parseToImage(arrayBuffer2, options, url); + blob = image; + } else { + blob = getBlob(arrayBuffer2, url); + } + const imagebitmapOptions = options && options.imagebitmap; + return await safeCreateImageBitmap(blob, imagebitmapOptions); +} +async function safeCreateImageBitmap(blob, imagebitmapOptions = null) { + if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) { + imagebitmapOptions = null; + } + if (imagebitmapOptions) { + try { + return await createImageBitmap(blob, imagebitmapOptions); + } catch (error) { + console.warn(error); + imagebitmapOptionsSupported = false; + } + } + return await createImageBitmap(blob); +} +function isEmptyObject(object) { + for (const key in object || EMPTY_OBJECT) { + return false; + } + return true; +} + +// node_modules/@loaders.gl/images/dist/lib/category-api/parse-isobmff-binary.js +function getISOBMFFMediaType(buffer) { + if (!checkString(buffer, "ftyp", 4)) { + return null; + } + if ((buffer[8] & 96) === 0) { + return null; + } + return decodeMajorBrand(buffer); +} +function decodeMajorBrand(buffer) { + const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim(); + switch (brandMajor) { + case "avif": + case "avis": + return { extension: "avif", mimeType: "image/avif" }; + default: + return null; + } +} +function getUTF8String(array, start, end) { + return String.fromCharCode(...array.slice(start, end)); +} +function stringToBytes(string) { + return [...string].map((character) => character.charCodeAt(0)); +} +function checkString(buffer, header, offset = 0) { + const headerBytes = stringToBytes(header); + for (let i = 0; i < headerBytes.length; ++i) { + if (headerBytes[i] !== buffer[i + offset]) { + return false; + } + } + return true; +} + +// node_modules/@loaders.gl/images/dist/lib/category-api/binary-image-api.js +var BIG_ENDIAN = false; +var LITTLE_ENDIAN = true; +function getBinaryImageMetadata(binaryData) { + const dataView = toDataView(binaryData); + return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView); +} +function getISOBMFFMetadata(binaryData) { + const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData); + const mediaType = getISOBMFFMediaType(buffer); + if (!mediaType) { + return null; + } + return { + mimeType: mediaType.mimeType, + // TODO - decode width and height + width: 0, + height: 0 + }; +} +function getPngMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511; + if (!isPng) { + return null; + } + return { + mimeType: "image/png", + width: dataView.getUint32(16, BIG_ENDIAN), + height: dataView.getUint32(20, BIG_ENDIAN) + }; +} +function getGifMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440; + if (!isGif) { + return null; + } + return { + mimeType: "image/gif", + width: dataView.getUint16(6, LITTLE_ENDIAN), + height: dataView.getUint16(8, LITTLE_ENDIAN) + }; +} +function getBmpMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength; + if (!isBmp) { + return null; + } + return { + mimeType: "image/bmp", + width: dataView.getUint32(18, LITTLE_ENDIAN), + height: dataView.getUint32(22, LITTLE_ENDIAN) + }; +} +function getJpegMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255; + if (!isJpeg) { + return null; + } + const { tableMarkers, sofMarkers } = getJpegMarkers(); + let i = 2; + while (i + 9 < dataView.byteLength) { + const marker = dataView.getUint16(i, BIG_ENDIAN); + if (sofMarkers.has(marker)) { + return { + mimeType: "image/jpeg", + height: dataView.getUint16(i + 5, BIG_ENDIAN), + // Number of lines + width: dataView.getUint16(i + 7, BIG_ENDIAN) + // Number of pixels per line + }; + } + if (!tableMarkers.has(marker)) { + return null; + } + i += 2; + i += dataView.getUint16(i, BIG_ENDIAN); + } + return null; +} +function getJpegMarkers() { + const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]); + for (let i = 65504; i < 65520; ++i) { + tableMarkers.add(i); + } + const sofMarkers = /* @__PURE__ */ new Set([ + 65472, + 65473, + 65474, + 65475, + 65477, + 65478, + 65479, + 65481, + 65482, + 65483, + 65485, + 65486, + 65487, + 65502 + ]); + return { tableMarkers, sofMarkers }; +} +function toDataView(data) { + if (data instanceof DataView) { + return data; + } + if (ArrayBuffer.isView(data)) { + return new DataView(data.buffer); + } + if (data instanceof ArrayBuffer) { + return new DataView(data); + } + throw new Error("toDataView"); +} + +// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-node-image.js +async function parseToNodeImage(arrayBuffer2, options) { + const { mimeType } = getBinaryImageMetadata(arrayBuffer2) || {}; + const parseImageNode2 = globalThis.loaders?.parseImageNode; + assert4(parseImageNode2); + return await parseImageNode2(arrayBuffer2, mimeType); +} + +// node_modules/@loaders.gl/images/dist/lib/parsers/parse-image.js +async function parseImage(arrayBuffer2, options, context) { + options = options || {}; + const imageOptions = options.image || {}; + const imageType = imageOptions.type || "auto"; + const { url } = context || {}; + const loadType = getLoadableImageType(imageType); + let image; + switch (loadType) { + case "imagebitmap": + image = await parseToImageBitmap(arrayBuffer2, options, url); + break; + case "image": + image = await parseToImage(arrayBuffer2, options, url); + break; + case "data": + image = await parseToNodeImage(arrayBuffer2, options); + break; + default: + assert4(false); + } + if (imageType === "data") { + image = getImageData(image); + } + return image; +} +function getLoadableImageType(type) { + switch (type) { + case "auto": + case "data": + return getDefaultImageType(); + default: + isImageTypeSupported(type); + return type; + } +} + +// node_modules/@loaders.gl/images/dist/image-loader.js +var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"]; +var MIME_TYPES = [ + "image/png", + "image/jpeg", + "image/gif", + "image/webp", + "image/avif", + "image/bmp", + "image/vnd.microsoft.icon", + "image/svg+xml" +]; +var DEFAULT_IMAGE_LOADER_OPTIONS = { + image: { + type: "auto", + decode: true + // if format is HTML + } + // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor +}; +var ImageLoader = { + dataType: null, + batchType: null, + id: "image", + module: "images", + name: "Images", + version: VERSION4, + mimeTypes: MIME_TYPES, + extensions: EXTENSIONS, + parse: parseImage, + // TODO: byteOffset, byteLength; + tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))], + options: DEFAULT_IMAGE_LOADER_OPTIONS +}; + +// node_modules/@deck.gl/core/dist/utils/log.js +var defaultLogger = new Log({ id: "deck" }); +var log_default = defaultLogger; + +// node_modules/@deck.gl/core/dist/debug/loggers.js +var logState = { + attributeUpdateStart: -1, + attributeManagerUpdateStart: -1, + attributeUpdateMessages: [] +}; +var LOG_LEVEL_MAJOR_UPDATE = 1; +var LOG_LEVEL_MINOR_UPDATE = 2; +var LOG_LEVEL_UPDATE_DETAIL = 3; +var LOG_LEVEL_INFO = 4; +var LOG_LEVEL_DRAW = 2; +var getLoggers = (log4) => ({ + /* Layer events */ + "layer.changeFlag": (layer, key, flags) => { + log4.log(LOG_LEVEL_UPDATE_DETAIL, `${layer.id} ${key}: `, flags[key])(); + }, + "layer.initialize": (layer) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, `Initializing ${layer}`)(); + }, + "layer.update": (layer, needsUpdate) => { + if (needsUpdate) { + const flags = layer.getChangeFlags(); + log4.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layer} because: ${Object.keys(flags).filter((key) => flags[key]).join(", ")}`)(); + } else { + log4.log(LOG_LEVEL_INFO, `${layer} does not need update`)(); + } + }, + "layer.matched": (layer, changed) => { + if (changed) { + log4.log(LOG_LEVEL_INFO, `Matched ${layer}, state transfered`)(); + } + }, + "layer.finalize": (layer) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, `Finalizing ${layer}`)(); + }, + /* CompositeLayer events */ + "compositeLayer.renderLayers": (layer, updated, subLayers) => { + if (updated) { + log4.log(LOG_LEVEL_MINOR_UPDATE, `Composite layer rendered new subLayers ${layer}`, subLayers)(); + } else { + log4.log(LOG_LEVEL_INFO, `Composite layer reused subLayers ${layer}`, subLayers)(); + } + }, + /* LayerManager events */ + "layerManager.setLayers": (layerManager, updated, layers) => { + if (updated) { + log4.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layers.length} deck layers`)(); + } + }, + "layerManager.activateViewport": (layerManager, viewport) => { + log4.log(LOG_LEVEL_UPDATE_DETAIL, "Viewport changed", viewport)(); + }, + /* AttributeManager events */ + "attributeManager.invalidate": (attributeManager, trigger, attributeNames) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, attributeNames ? `invalidated attributes ${attributeNames} (${trigger}) for ${attributeManager.id}` : `invalidated all attributes for ${attributeManager.id}`)(); + }, + "attributeManager.updateStart": (attributeManager) => { + logState.attributeUpdateMessages.length = 0; + logState.attributeManagerUpdateStart = Date.now(); + }, + "attributeManager.updateEnd": (attributeManager, numInstances) => { + const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart); + log4.groupCollapsed(LOG_LEVEL_MINOR_UPDATE, `Updated attributes for ${numInstances} instances in ${attributeManager.id} in ${timeMs}ms`)(); + for (const updateMessage of logState.attributeUpdateMessages) { + log4.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)(); + } + log4.groupEnd(LOG_LEVEL_MINOR_UPDATE)(); + }, + /* Attribute events */ + "attribute.updateStart": (attribute) => { + logState.attributeUpdateStart = Date.now(); + }, + "attribute.allocate": (attribute, numInstances) => { + const message2 = `${attribute.id} allocated ${numInstances}`; + logState.attributeUpdateMessages.push(message2); + }, + "attribute.updateEnd": (attribute, numInstances) => { + const timeMs = Math.round(Date.now() - logState.attributeUpdateStart); + const message2 = `${attribute.id} updated ${numInstances} in ${timeMs}ms`; + logState.attributeUpdateMessages.push(message2); + }, + /* Render events */ + "deckRenderer.renderLayers": (deckRenderer, renderStats, opts) => { + const { pass, redrawReason, stats } = opts; + for (const status of renderStats) { + const { totalCount, visibleCount, compositeCount, pickableCount } = status; + const primitiveCount = totalCount - compositeCount; + const hiddenCount = primitiveCount - visibleCount; + log4.log(LOG_LEVEL_DRAW, `RENDER #${deckRenderer.renderCount} ${visibleCount} (of ${totalCount} layers) to ${pass} because ${redrawReason} (${hiddenCount} hidden, ${compositeCount} composite ${pickableCount} pickable)`)(); + if (stats) { + stats.get("Redraw Layers").add(visibleCount); + } + } + } +}); + +// node_modules/@deck.gl/core/dist/debug/index.js +var loggers = {}; +if (true) { + loggers = getLoggers(log_default); +} +function register(handlers) { + loggers = handlers; +} +function debug(eventType, arg1, arg2, arg3) { + if (log_default.level > 0 && loggers[eventType]) { + loggers[eventType].call(null, arg1, arg2, arg3); + } +} + +// node_modules/@deck.gl/core/dist/utils/json-loader.js +function isJSON(text) { + const firstChar = text[0]; + const lastChar = text[text.length - 1]; + return firstChar === "{" && lastChar === "}" || firstChar === "[" && lastChar === "]"; +} +var json_loader_default = { + dataType: null, + batchType: null, + id: "JSON", + name: "JSON", + module: "", + version: "", + options: {}, + extensions: ["json", "geojson"], + mimeTypes: ["application/json", "application/geo+json"], + testText: isJSON, + parseTextSync: JSON.parse +}; + +// node_modules/@deck.gl/core/dist/lib/init.js +function checkVersion() { + const version2 = true ? "9.0.35" : globalThis.DECK_VERSION || "untranspiled source"; + const existingVersion = globalThis.deck && globalThis.deck.VERSION; + if (existingVersion && existingVersion !== version2) { + throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version2}`); + } + if (!existingVersion) { + log_default.log(1, `deck.gl ${version2}`)(); + globalThis.deck = { + ...globalThis.deck, + VERSION: version2, + version: version2, + log: log_default, + // experimental + _registerLoggers: register + }; + registerLoaders([ + json_loader_default, + // @ts-expect-error non-standard Loader format + [ImageLoader, { imagebitmap: { premultiplyAlpha: "none" } }] + ]); + } + return version2; +} +var VERSION5 = checkVersion(); + +// node_modules/@luma.gl/shadertools/dist/lib/utils/assert.js +function assert5(condition, message2) { + if (!condition) { + throw new Error(message2 || "shadertools: assertion failed."); + } +} + +// node_modules/@luma.gl/shadertools/dist/lib/filters/prop-types.js +var DEFAULT_PROP_VALIDATORS = { + number: { + type: "number", + validate(value, propType) { + return Number.isFinite(value) && typeof propType === "object" && (propType.max === void 0 || value <= propType.max) && (propType.min === void 0 || value >= propType.min); + } + }, + array: { + type: "array", + validate(value, propType) { + return Array.isArray(value) || ArrayBuffer.isView(value); + } + } +}; +function makePropValidators(propTypes) { + const propValidators = {}; + for (const [name2, propType] of Object.entries(propTypes)) { + propValidators[name2] = makePropValidator(propType); + } + return propValidators; +} +function getValidatedProperties(properties, propValidators, errorMessage) { + const validated = {}; + for (const [key, propsValidator] of Object.entries(propValidators)) { + if (properties && key in properties && !propsValidator.private) { + if (propsValidator.validate) { + assert5(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`); + } + validated[key] = properties[key]; + } else { + validated[key] = propsValidator.value; + } + } + return validated; +} +function makePropValidator(propType) { + let type = getTypeOf(propType); + if (type !== "object") { + return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type }; + } + if (typeof propType === "object") { + if (!propType) { + return { type: "object", value: null }; + } + if (propType.type !== void 0) { + return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type }; + } + if (propType.value === void 0) { + return { type: "object", value: propType }; + } + type = getTypeOf(propType.value); + return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type }; + } + throw new Error("props"); +} +function getTypeOf(value) { + if (Array.isArray(value) || ArrayBuffer.isView(value)) { + return "array"; + } + return typeof value; +} + +// node_modules/@luma.gl/shadertools/dist/module-injectors.js +var MODULE_INJECTORS_VS = `#ifdef MODULE_LOGDEPTH +logdepth_adjustPosition(gl_Position); +#endif +`; +var MODULE_INJECTORS_FS = `#ifdef MODULE_MATERIAL +gl_FragColor = material_filterColor(gl_FragColor); +#endif +#ifdef MODULE_LIGHTING +gl_FragColor = lighting_filterColor(gl_FragColor); +#endif +#ifdef MODULE_FOG +gl_FragColor = fog_filterColor(gl_FragColor); +#endif +#ifdef MODULE_PICKING +gl_FragColor = picking_filterHighlightColor(gl_FragColor); +gl_FragColor = picking_filterPickingColor(gl_FragColor); +#endif +#ifdef MODULE_LOGDEPTH +logdepth_setFragDepth(); +#endif +`; + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-injections.js +var MODULE_INJECTORS = { + vertex: MODULE_INJECTORS_VS, + fragment: MODULE_INJECTORS_FS +}; +var REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/; +var REGEX_END_OF_MAIN = /}\n?[^{}]*$/; +var fragments = []; +var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__"; +function normalizeInjections(injections) { + const result = { vertex: {}, fragment: {} }; + for (const hook in injections) { + let injection = injections[hook]; + const stage = getHookStage(hook); + if (typeof injection === "string") { + injection = { + order: 0, + injection + }; + } + result[stage][hook] = injection; + } + return result; +} +function getHookStage(hook) { + const type = hook.slice(0, 2); + switch (type) { + case "vs": + return "vertex"; + case "fs": + return "fragment"; + default: + throw new Error(type); + } +} +function injectShader(source, stage, inject, injectStandardStubs = false) { + const isVertex = stage === "vertex"; + for (const key in inject) { + const fragmentData = inject[key]; + fragmentData.sort((a, b) => a.order - b.order); + fragments.length = fragmentData.length; + for (let i = 0, len8 = fragmentData.length; i < len8; ++i) { + fragments[i] = fragmentData[i].injection; + } + const fragmentString = `${fragments.join("\n")} +`; + switch (key) { + case "vs:#decl": + if (isVertex) { + source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); + } + break; + case "vs:#main-start": + if (isVertex) { + source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); + } + break; + case "vs:#main-end": + if (isVertex) { + source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); + } + break; + case "fs:#decl": + if (!isVertex) { + source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); + } + break; + case "fs:#main-start": + if (!isVertex) { + source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); + } + break; + case "fs:#main-end": + if (!isVertex) { + source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); + } + break; + default: + source = source.replace(key, (match) => match + fragmentString); + } + } + source = source.replace(DECLARATION_INJECT_MARKER, ""); + if (injectStandardStubs) { + source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]); + } + return source; +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-module/shader-module-instance.js +var index = 1; +var ShaderModuleInstance = class _ShaderModuleInstance { + name; + vs; + fs; + getModuleUniforms; + dependencies; + deprecations; + defines; + injections; + uniforms = {}; + uniformTypes = {}; + static instantiateModules(modules) { + return modules.map((module) => { + if (module instanceof _ShaderModuleInstance) { + return module; + } + assert5(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`); + if (!module.name) { + console.warn("shader module has no name"); + module.name = `shader-module-${index++}`; + } + const moduleObject = new _ShaderModuleInstance(module); + moduleObject.dependencies = _ShaderModuleInstance.instantiateModules(module.dependencies || []); + return moduleObject; + }); + } + constructor(props) { + const { name: name2, vs: vs7, fs: fs5, dependencies = [], uniformTypes = {}, uniformPropTypes = {}, getUniforms: getUniforms6, deprecations = [], defines: defines2 = {}, inject = {} } = props; + assert5(typeof name2 === "string"); + this.name = name2; + this.vs = vs7; + this.fs = fs5; + this.getModuleUniforms = getUniforms6; + this.dependencies = _ShaderModuleInstance.instantiateModules(dependencies); + this.deprecations = this._parseDeprecationDefinitions(deprecations); + this.defines = defines2; + this.injections = normalizeInjections(inject); + this.uniformTypes = uniformTypes; + if (uniformPropTypes) { + this.uniforms = makePropValidators(uniformPropTypes); + } + } + // Extracts the source code chunk for the specified shader type from the named shader module + getModuleSource(stage) { + let moduleSource; + switch (stage) { + case "vertex": + moduleSource = this.vs || ""; + break; + case "fragment": + moduleSource = this.fs || ""; + break; + default: + assert5(false); + } + const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_"); + return `// ----- MODULE ${this.name} --------------- + +#define MODULE_${moduleName} +${moduleSource} + +`; + } + getUniforms(userProps, uniforms) { + if (this.getModuleUniforms) { + return this.getModuleUniforms(userProps, uniforms); + } + return getValidatedProperties(userProps, this.uniforms, this.name); + } + getDefines() { + return this.defines; + } + // Warn about deprecated uniforms or functions + checkDeprecations(shaderSource, log4) { + this.deprecations.forEach((def) => { + if (def.regex?.test(shaderSource)) { + if (def.deprecated) { + log4.deprecated(def.old, def.new)(); + } else { + log4.removed(def.old, def.new)(); + } + } + }); + } + _parseDeprecationDefinitions(deprecations) { + deprecations.forEach((def) => { + switch (def.type) { + case "function": + def.regex = new RegExp(`\\b${def.old}\\(`); + break; + default: + def.regex = new RegExp(`${def.type} ${def.old};`); + } + }); + return deprecations; + } + _defaultGetUniforms(opts = {}) { + const uniforms = {}; + const propTypes = this.uniforms; + for (const key in propTypes) { + const propDef = propTypes[key]; + if (key in opts && !propDef.private) { + if (propDef.validate) { + assert5(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`); + } + uniforms[key] = opts[key]; + } else { + uniforms[key] = propDef.value; + } + } + return uniforms; + } +}; + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/select-shaders.js +function selectShaders(props) { + if (props.source && props.platformInfo.type === "webgpu") { + const propsCopy = { ...props, vs: void 0, fs: void 0 }; + return propsCopy; + } + if (!props.vs) { + throw new Error("no vertex shader"); + } + const vs7 = getShaderSource(props.platformInfo, props.vs); + let fs5; + if (props.fs) { + fs5 = getShaderSource(props.platformInfo, props.fs); + } + return { ...props, vs: vs7, fs: fs5 }; +} +function getShaderSource(platformInfo, shader) { + if (typeof shader === "string") { + return shader; + } + switch (platformInfo.type) { + case "webgpu": + if (shader?.wgsl) { + return shader.wgsl; + } + throw new Error("WebGPU does not support GLSL shaders"); + default: + if (shader?.glsl) { + return shader.glsl; + } + throw new Error("WebGL does not support WGSL shaders"); + } +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/resolve-modules.js +function resolveModules(modules) { + const instances = ShaderModuleInstance.instantiateModules(modules); + return getShaderDependencies(instances); +} +function getShaderDependencies(modules) { + const moduleMap = {}; + const moduleDepth = {}; + getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth }); + return Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name2) => moduleMap[name2]); +} +function getDependencyGraph(options) { + const { modules, level, moduleMap, moduleDepth } = options; + if (level >= 5) { + throw new Error("Possible loop in shader dependency graph"); + } + for (const module of modules) { + moduleMap[module.name] = module; + if (moduleDepth[module.name] === void 0 || moduleDepth[module.name] < level) { + moduleDepth[module.name] = level; + } + } + for (const module of modules) { + if (module.dependencies) { + getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth }); + } + } +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/platform-defines.js +function getPlatformShaderDefines(platformInfo) { + switch (platformInfo?.gpu.toLowerCase()) { + case "apple": + return `#define APPLE_GPU +#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 +#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 +#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 +`; + case "nvidia": + return `#define NVIDIA_GPU +#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 +`; + case "intel": + return `#define INTEL_GPU +#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 +#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 +#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 +`; + case "amd": + return `#define AMD_GPU +`; + default: + return `#define DEFAULT_GPU +#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 +#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 +#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 +`; + } +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js +function transpileGLSLShader(source, stage) { + const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100); + if (sourceGLSLVersion !== 300) { + throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources"); + } + switch (stage) { + case "vertex": + source = convertShader(source, ES300_VERTEX_REPLACEMENTS); + return source; + case "fragment": + source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS); + return source; + default: + throw new Error(stage); + } +} +var ES300_REPLACEMENTS = [ + // Fix poorly formatted version directive + [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], + // The individual `texture...()` functions were replaced with `texture()` overloads + [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], + [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("] +]; +var ES300_VERTEX_REPLACEMENTS = [ + ...ES300_REPLACEMENTS, + // `attribute` keyword replaced with `in` + [makeVariableTextRegExp("attribute"), "in $1"], + // `varying` keyword replaced with `out` + [makeVariableTextRegExp("varying"), "out $1"] +]; +var ES300_FRAGMENT_REPLACEMENTS = [ + ...ES300_REPLACEMENTS, + // `varying` keyword replaced with `in` + [makeVariableTextRegExp("varying"), "in $1"] +]; +function convertShader(source, replacements) { + for (const [pattern, replacement] of replacements) { + source = source.replace(pattern, replacement); + } + return source; +} +function makeVariableTextRegExp(qualifier) { + return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g"); +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-hooks.js +function getShaderHooks(hookFunctions, hookInjections) { + let result = ""; + for (const hookName in hookFunctions) { + const hookFunction = hookFunctions[hookName]; + result += `void ${hookFunction.signature} { +`; + if (hookFunction.header) { + result += ` ${hookFunction.header}`; + } + if (hookInjections[hookName]) { + const injections = hookInjections[hookName]; + injections.sort((a, b) => a.order - b.order); + for (const injection of injections) { + result += ` ${injection.injection} +`; + } + } + if (hookFunction.footer) { + result += ` ${hookFunction.footer}`; + } + result += "}\n"; + } + return result; +} +function normalizeShaderHooks(hookFunctions) { + const result = { vertex: {}, fragment: {} }; + for (const hookFunction of hookFunctions) { + let opts; + let hook; + if (typeof hookFunction !== "string") { + opts = hookFunction; + hook = opts.hook; + } else { + opts = {}; + hook = hookFunction; + } + hook = hook.trim(); + const [shaderStage, signature] = hook.split(":"); + const name2 = hook.replace(/\(.+/, ""); + const normalizedHook = Object.assign(opts, { signature }); + switch (shaderStage) { + case "vs": + result.vertex[name2] = normalizedHook; + break; + case "fs": + result.fragment[name2] = normalizedHook; + break; + default: + throw new Error(shaderStage); + } + } + return result; +} + +// node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/get-shader-info.js +function getShaderInfo(source, defaultName) { + return { + name: getShaderName(source, defaultName), + language: "glsl", + version: getShaderVersion(source) + }; +} +function getShaderName(shader, defaultName = "unnamed") { + const SHADER_NAME_REGEXP = /#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/; + const match = SHADER_NAME_REGEXP.exec(shader); + return match ? match[1] : defaultName; +} +function getShaderVersion(source) { + let version2 = 100; + const words = source.match(/[^\s]+/g); + if (words && words.length >= 2 && words[0] === "#version") { + const parsedVersion = parseInt(words[1], 10); + if (Number.isFinite(parsedVersion)) { + version2 = parsedVersion; + } + } + if (version2 !== 100 && version2 !== 300) { + throw new Error(`Invalid GLSL version ${version2}`); + } + return version2; +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders.js +var INJECT_SHADER_DECLARATIONS = ` + +${DECLARATION_INJECT_MARKER} +`; +var FRAGMENT_SHADER_PROLOGUE = `precision highp float; +`; +function assembleShaderWGSL(options) { + const modules = resolveModules(options.modules || []); + return { + source: assembleWGSLShader(options.platformInfo, { + ...options, + source: options.source, + stage: "vertex", + modules + }), + getUniforms: assembleGetUniforms(modules) + }; +} +function assembleShaderPairWGSL(options) { + const modules = resolveModules(options.modules || []); + return { + vs: assembleWGSLShader(options.platformInfo, { + ...options, + source: options.vs, + stage: "vertex", + modules + }), + fs: assembleWGSLShader(options.platformInfo, { + ...options, + source: options.fs, + stage: "fragment", + modules + }), + getUniforms: assembleGetUniforms(modules) + }; +} +function assembleShaderPairGLSL(options) { + const { vs: vs7, fs: fs5 } = options; + const modules = resolveModules(options.modules || []); + return { + vs: assembleGLSLShader(options.platformInfo, { + ...options, + source: vs7, + stage: "vertex", + modules + }), + fs: assembleGLSLShader(options.platformInfo, { + ...options, + source: fs5, + stage: "fragment", + modules + }), + getUniforms: assembleGetUniforms(modules) + }; +} +function assembleWGSLShader(platformInfo, options) { + const { + // id, + source, + stage, + modules, + // defines = {}, + hookFunctions = [], + inject = {}, + log: log4 + } = options; + assert5(typeof source === "string", "shader source must be a string"); + const coreSource = source; + let assembledSource = ""; + const hookFunctionMap = normalizeShaderHooks(hookFunctions); + const hookInjections = {}; + const declInjections = {}; + const mainInjections = {}; + for (const key in inject) { + const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key]; + const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key); + if (match) { + const hash = match[2]; + const name2 = match[3]; + if (hash) { + if (name2 === "decl") { + declInjections[key] = [injection]; + } else { + mainInjections[key] = [injection]; + } + } else { + hookInjections[key] = [injection]; + } + } else { + mainInjections[key] = [injection]; + } + } + const modulesToInject = platformInfo.type !== "webgpu" ? modules : []; + for (const module of modulesToInject) { + if (log4) { + module.checkDeprecations(coreSource, log4); + } + const moduleSource = module.getModuleSource(stage, "wgsl"); + assembledSource += moduleSource; + const injections = module.injections[stage]; + for (const key in injections) { + const match = /^(v|f)s:#([\w-]+)$/.exec(key); + if (match) { + const name2 = match[2]; + const injectionType = name2 === "decl" ? declInjections : mainInjections; + injectionType[key] = injectionType[key] || []; + injectionType[key].push(injections[key]); + } else { + hookInjections[key] = hookInjections[key] || []; + hookInjections[key].push(injections[key]); + } + } + } + assembledSource += INJECT_SHADER_DECLARATIONS; + assembledSource = injectShader(assembledSource, stage, declInjections); + assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections); + assembledSource += coreSource; + assembledSource = injectShader(assembledSource, stage, mainInjections); + return assembledSource; +} +function assembleGLSLShader(platformInfo, options) { + const { id, source, stage, language = "glsl", modules, defines: defines2 = {}, hookFunctions = [], inject = {}, prologue = true, log: log4 } = options; + assert5(typeof source === "string", "shader source must be a string"); + const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1; + const targetVersion = platformInfo.shaderLanguageVersion; + const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es"; + const sourceLines = source.split("\n"); + const coreSource = sourceLines.slice(1).join("\n"); + const allDefines = {}; + modules.forEach((module) => { + Object.assign(allDefines, module.getDefines()); + }); + Object.assign(allDefines, defines2); + let assembledSource = ""; + switch (language) { + case "wgsl": + break; + case "glsl": + assembledSource = prologue ? `${sourceVersionDirective} + +// ----- PROLOGUE ------------------------- +${getShaderNameDefine({ id, source, stage })} +${`#define SHADER_TYPE_${stage.toUpperCase()}`} +${getPlatformShaderDefines(platformInfo)} +${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""} + +// ----- APPLICATION DEFINES ------------------------- + +${getApplicationDefines(allDefines)} + +` : `${sourceVersionDirective} +`; + break; + } + const hookFunctionMap = normalizeShaderHooks(hookFunctions); + const hookInjections = {}; + const declInjections = {}; + const mainInjections = {}; + for (const key in inject) { + const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key]; + const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key); + if (match) { + const hash = match[2]; + const name2 = match[3]; + if (hash) { + if (name2 === "decl") { + declInjections[key] = [injection]; + } else { + mainInjections[key] = [injection]; + } + } else { + hookInjections[key] = [injection]; + } + } else { + mainInjections[key] = [injection]; + } + } + for (const module of modules) { + if (log4) { + module.checkDeprecations(coreSource, log4); + } + const moduleSource = module.getModuleSource(stage); + assembledSource += moduleSource; + const injections = module.injections[stage]; + for (const key in injections) { + const match = /^(v|f)s:#([\w-]+)$/.exec(key); + if (match) { + const name2 = match[2]; + const injectionType = name2 === "decl" ? declInjections : mainInjections; + injectionType[key] = injectionType[key] || []; + injectionType[key].push(injections[key]); + } else { + hookInjections[key] = hookInjections[key] || []; + hookInjections[key].push(injections[key]); + } + } + } + assembledSource += "// ----- MAIN SHADER SOURCE -------------------------"; + assembledSource += INJECT_SHADER_DECLARATIONS; + assembledSource = injectShader(assembledSource, stage, declInjections); + assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections); + assembledSource += coreSource; + assembledSource = injectShader(assembledSource, stage, mainInjections); + if (language === "glsl" && sourceVersion !== targetVersion) { + assembledSource = transpileGLSLShader(assembledSource, stage); + } + return assembledSource.trim(); +} +function assembleGetUniforms(modules) { + return function getUniforms6(opts) { + const uniforms = {}; + for (const module of modules) { + const moduleUniforms = module.getUniforms(opts, uniforms); + Object.assign(uniforms, moduleUniforms); + } + return uniforms; + }; +} +function getShaderNameDefine(options) { + const { id, source, stage } = options; + const injectShaderName = id && source.indexOf("SHADER_NAME") === -1; + return injectShaderName ? ` +#define SHADER_NAME ${id}_${stage} + +` : ""; +} +function getApplicationDefines(defines2 = {}) { + let sourceText = ""; + for (const define2 in defines2) { + const value = defines2[define2]; + if (value || Number.isFinite(value)) { + sourceText += `#define ${define2.toUpperCase()} ${defines2[define2]} +`; + } + } + return sourceText; +} + +// node_modules/@luma.gl/shadertools/dist/lib/shader-assembler.js +var ShaderAssembler = class _ShaderAssembler { + /** Default ShaderAssembler instance */ + static defaultShaderAssembler; + /** Hook functions */ + _hookFunctions = []; + /** Shader modules */ + _defaultModules = []; + /** + * A default shader assembler instance - the natural place to register default modules and hooks + * @returns + */ + static getDefaultShaderAssembler() { + _ShaderAssembler.defaultShaderAssembler = _ShaderAssembler.defaultShaderAssembler || new _ShaderAssembler(); + return _ShaderAssembler.defaultShaderAssembler; + } + /** + * Add a default module that does not have to be provided with every call to assembleShaders() + */ + addDefaultModule(module) { + if (!this._defaultModules.find((m) => m.name === (typeof module === "string" ? module : module.name))) { + this._defaultModules.push(module); + } + } + /** + * Remove a default module + */ + removeDefaultModule(module) { + const moduleName = typeof module === "string" ? module : module.name; + this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName); + } + /** + * Register a shader hook + * @param hook + * @param opts + */ + addShaderHook(hook, opts) { + if (opts) { + hook = Object.assign(opts, { hook }); + } + this._hookFunctions.push(hook); + } + /** + * Assemble a pair of shaders into a single shader program + * @param platformInfo + * @param props + * @returns + */ + assembleShader(props) { + const modules = this._getModuleList(props.modules); + const hookFunctions = this._hookFunctions; + const options = selectShaders(props); + const assembled = assembleShaderWGSL({ + platformInfo: props.platformInfo, + ...options, + modules, + hookFunctions + }); + return { ...assembled, modules }; + } + /** + * Assemble a pair of shaders into a single shader program + * @param platformInfo + * @param props + * @returns + */ + assembleShaderPair(props) { + const options = selectShaders(props); + const modules = this._getModuleList(props.modules); + const hookFunctions = this._hookFunctions; + const { platformInfo } = props; + const isWGSL = props.platformInfo.shaderLanguage === "wgsl"; + const assembled = isWGSL ? assembleShaderPairWGSL({ platformInfo, ...options, modules, hookFunctions }) : assembleShaderPairGLSL({ platformInfo, ...options, modules, hookFunctions }); + return { ...assembled, modules }; + } + /** + * Dedupe and combine with default modules + */ + _getModuleList(appModules = []) { + const modules = new Array(this._defaultModules.length + appModules.length); + const seen = {}; + let count2 = 0; + for (let i = 0, len8 = this._defaultModules.length; i < len8; ++i) { + const module = this._defaultModules[i]; + const name2 = module.name; + modules[count2++] = module; + seen[name2] = true; + } + for (let i = 0, len8 = appModules.length; i < len8; ++i) { + const module = appModules[i]; + const name2 = module.name; + if (!seen[name2]) { + modules[count2++] = module; + seen[name2] = true; + } + } + modules.length = count2; + return ShaderModuleInstance.instantiateModules(modules); + } +}; + +// node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/shader-utils.js +var FS_GLES = `out vec4 transform_output; +void main() { +transform_output = vec4(0); +}`; +var FS300 = `#version 300 es +${FS_GLES}`; +function getPassthroughFS(options) { + const { input, inputChannels, output } = options || {}; + if (!input) { + return FS300; + } + if (!inputChannels) { + throw new Error("inputChannels"); + } + const inputType = channelCountToType(inputChannels); + const outputValue = convertToVec4(input, inputChannels); + return `#version 300 es +in ${inputType} ${input}; +out vec4 ${output}; +void main() { + ${output} = ${outputValue}; +}`; +} +function channelCountToType(channels) { + switch (channels) { + case 1: + return "float"; + case 2: + return "vec2"; + case 3: + return "vec3"; + case 4: + return "vec4"; + default: + throw new Error(`invalid channels: ${channels}`); + } +} +function convertToVec4(variable, channels) { + switch (channels) { + case 1: + return `vec4(${variable}, 0.0, 0.0, 1.0)`; + case 2: + return `vec4(${variable}, 0.0, 1.0)`; + case 3: + return `vec4(${variable}, 1.0)`; + case 4: + return variable; + default: + throw new Error(`invalid channels: ${channels}`); + } +} + +// node_modules/@luma.gl/core/dist/utils/log.js +var log2 = new Log({ id: "luma.gl" }); + +// node_modules/@luma.gl/core/dist/utils/stats-manager.js +var StatsManager = class { + stats = /* @__PURE__ */ new Map(); + getStats(name2) { + return this.get(name2); + } + get(name2) { + if (!this.stats.has(name2)) { + this.stats.set(name2, new Stats({ id: name2 })); + } + return this.stats.get(name2); + } +}; +var lumaStats = new StatsManager(); + +// node_modules/@luma.gl/core/dist/init.js +function initializeLuma() { + const VERSION7 = true ? "9.0.27" : "running from source"; + const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering"; + if (globalThis.luma && globalThis.luma.VERSION !== VERSION7) { + throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION7}`); + } + if (!globalThis.luma) { + if (isBrowser2()) { + log2.log(1, `${VERSION7} - ${STARTUP_MESSAGE}`)(); + } + globalThis.luma = globalThis.luma || { + VERSION: VERSION7, + version: VERSION7, + log: log2, + // A global stats object that various components can add information to + // E.g. see webgl/resource.js + stats: lumaStats + }; + } + return VERSION7; +} +var VERSION6 = initializeLuma(); + +// node_modules/@luma.gl/core/dist/utils/is-array.js +function isTypedArray(value) { + return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null; +} +function isNumberArray(value) { + if (Array.isArray(value)) { + return value.length === 0 || typeof value[0] === "number" ? value : null; + } + return isTypedArray(value); +} + +// node_modules/@luma.gl/core/dist/utils/utils.js +var uidCounters = {}; +function uid(id = "id") { + uidCounters[id] = uidCounters[id] || 1; + const count2 = uidCounters[id]++; + return `${id}-${count2}`; +} +function isObjectEmpty(obj) { + let isEmpty = true; + for (const key in obj) { + isEmpty = false; + break; + } + return isEmpty; +} + +// node_modules/@luma.gl/core/dist/adapter/resources/resource.js +var Resource = class { + /** Default properties for resource */ + static defaultProps = { + id: "undefined", + handle: void 0, + userData: void 0 + }; + /** props.id, for debugging. */ + id; + props; + userData = {}; + _device; + /** Whether this resource has been destroyed */ + destroyed = false; + /** For resources that allocate GPU memory */ + allocatedBytes = 0; + /** Attached resources will be destroyed when this resource is destroyed. Tracks auto-created "sub" resources. */ + _attachedResources = /* @__PURE__ */ new Set(); + /** + * Create a new Resource. Called from Subclass + */ + constructor(device, props, defaultProps14) { + if (!device) { + throw new Error("no device"); + } + this._device = device; + this.props = selectivelyMerge(props, defaultProps14); + const id = this.props.id !== "undefined" ? this.props.id : uid(this[Symbol.toStringTag]); + this.props.id = id; + this.id = id; + this.userData = this.props.userData || {}; + this.addStats(); + } + /** + * destroy can be called on any resource to release it before it is garbage collected. + */ + destroy() { + this.destroyResource(); + } + /** @deprecated Use destroy() */ + delete() { + this.destroy(); + return this; + } + toString() { + return `${this[Symbol.toStringTag] || this.constructor.name}(${this.id})`; + } + /** + * Combines a map of user props and default props, only including props from defaultProps + * @returns returns a map of overridden default props + */ + getProps() { + return this.props; + } + // ATTACHED RESOURCES + /** + * Attaches a resource. Attached resources are auto destroyed when this resource is destroyed + * Called automatically when sub resources are auto created but can be called by application + */ + attachResource(resource) { + this._attachedResources.add(resource); + } + /** + * Detach an attached resource. The resource will no longer be auto-destroyed when this resource is destroyed. + */ + detachResource(resource) { + this._attachedResources.delete(resource); + } + /** + * Destroys a resource (only if owned), and removes from the owned (auto-destroy) list for this resource. + */ + destroyAttachedResource(resource) { + if (this._attachedResources.delete(resource)) { + resource.destroy(); + } + } + /** Destroy all owned resources. Make sure the resources are no longer needed before calling. */ + destroyAttachedResources() { + for (const resource of Object.values(this._attachedResources)) { + resource.destroy(); + } + this._attachedResources = /* @__PURE__ */ new Set(); + } + // PROTECTED METHODS + /** Perform all destroy steps. Can be called by derived resources when overriding destroy() */ + destroyResource() { + this.destroyAttachedResources(); + this.removeStats(); + this.destroyed = true; + } + /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */ + removeStats() { + const stats = this._device.statsManager.getStats("Resource Counts"); + const name2 = this[Symbol.toStringTag]; + stats.get(`${name2}s Active`).decrementCount(); + } + /** Called by subclass to track memory allocations */ + trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) { + const stats = this._device.statsManager.getStats("Resource Counts"); + stats.get("GPU Memory").addCount(bytes); + stats.get(`${name2} Memory`).addCount(bytes); + this.allocatedBytes = bytes; + } + /** Called by subclass to track memory deallocations */ + trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) { + const stats = this._device.statsManager.getStats("Resource Counts"); + stats.get("GPU Memory").subtractCount(this.allocatedBytes); + stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes); + this.allocatedBytes = 0; + } + /** Called by resource constructor to track object creation */ + addStats() { + const stats = this._device.statsManager.getStats("Resource Counts"); + const name2 = this[Symbol.toStringTag]; + stats.get("Resources Created").incrementCount(); + stats.get(`${name2}s Created`).incrementCount(); + stats.get(`${name2}s Active`).incrementCount(); + } +}; +function selectivelyMerge(props, defaultProps14) { + const mergedProps = { ...defaultProps14 }; + for (const key in props) { + if (props[key] !== void 0) { + mergedProps[key] = props[key]; + } + } + return mergedProps; +} + +// node_modules/@luma.gl/core/dist/adapter/resources/buffer.js +var Buffer2 = class _Buffer extends Resource { + static defaultProps = { + ...Resource.defaultProps, + usage: 0, + // Buffer.COPY_DST | Buffer.COPY_SRC + byteLength: 0, + byteOffset: 0, + data: null, + indexType: "uint16", + mappedAtCreation: false + }; + // Usage Flags + static MAP_READ = 1; + static MAP_WRITE = 2; + static COPY_SRC = 4; + static COPY_DST = 8; + /** Index buffer */ + static INDEX = 16; + /** Vertex buffer */ + static VERTEX = 32; + /** Uniform buffer */ + static UNIFORM = 64; + /** Storage buffer */ + static STORAGE = 128; + static INDIRECT = 256; + static QUERY_RESOLVE = 512; + get [Symbol.toStringTag]() { + return "Buffer"; + } + /** The usage with which this buffer was created */ + usage; + /** For index buffers, whether indices are 16 or 32 bit */ + indexType; + /** "Time" of last update */ + updateTimestamp; + constructor(device, props) { + const deducedProps = { ...props }; + if ((props.usage || 0) & _Buffer.INDEX && !props.indexType) { + if (props.data instanceof Uint32Array) { + deducedProps.indexType = "uint32"; + } else if (props.data instanceof Uint16Array) { + deducedProps.indexType = "uint16"; + } + } + super(device, deducedProps, _Buffer.defaultProps); + this.usage = props.usage || 0; + this.indexType = deducedProps.indexType; + this.updateTimestamp = device.incrementTimestamp(); + } + /** Read data synchronously. @note WebGL2 only */ + readSyncWebGL(byteOffset, byteLength) { + throw new Error("not implemented"); + } + // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY) + /** Max amount of debug data saved. Two vec4's */ + static DEBUG_DATA_MAX_LENGTH = 32; + /** A partial CPU-side copy of the data in this buffer, for debugging purposes */ + debugData = new ArrayBuffer(0); + /** This doesn't handle partial non-zero offset updates correctly */ + _setDebugData(data, byteOffset, byteLength) { + const buffer = ArrayBuffer.isView(data) ? data.buffer : data; + const debugDataLength = Math.min(data ? data.byteLength : byteLength, _Buffer.DEBUG_DATA_MAX_LENGTH); + if (data === null) { + this.debugData = new ArrayBuffer(debugDataLength); + } else if (byteOffset === 0 && byteLength === data.byteLength) { + this.debugData = buffer.slice(0, debugDataLength); + } else { + this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength); + } + } +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-data-type.js +function decodeVertexType(type) { + const dataType = TYPE_MAP[type]; + const bytes = getDataTypeBytes(dataType); + const normalized = type.includes("norm"); + const integer = !normalized && !type.startsWith("float"); + const signed = type.startsWith("s"); + return { + dataType: TYPE_MAP[type], + byteLength: bytes, + integer, + signed, + normalized + }; +} +function getDataTypeBytes(type) { + const bytes = TYPE_SIZES[type]; + return bytes; +} +var TYPE_MAP = { + uint8: "uint8", + sint8: "sint8", + unorm8: "uint8", + snorm8: "sint8", + uint16: "uint16", + sint16: "sint16", + unorm16: "uint16", + snorm16: "sint16", + float16: "float16", + float32: "float32", + uint32: "uint32", + sint32: "sint32" +}; +var TYPE_SIZES = { + uint8: 1, + sint8: 1, + uint16: 2, + sint16: 2, + float16: 2, + float32: 4, + uint32: 4, + sint32: 4 +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-texture-format.js +var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [ + "bc1", + "bc2", + "bc3", + "bc4", + "bc5", + "bc6", + "bc7", + "etc1", + "etc2", + "eac", + "atc", + "astc", + "pvrtc" +]; +var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/; +function isTextureFormatCompressed(textureFormat) { + return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some((prefix) => textureFormat.startsWith(prefix)); +} +function decodeTextureFormat(format) { + const matches4 = REGEX.exec(format); + if (matches4) { + const [, format2, length10, type, srgb, suffix] = matches4; + if (format2) { + const dataType = `${type}${length10}`; + const decodedType = decodeVertexType(dataType); + return { + format: format2, + components: format2.length, + // dataType - overwritten by decodedType + srgb: srgb === "-srgb", + unsized: suffix === "-unsized", + webgl: suffix === "-webgl", + ...decodedType + }; + } + } + return decodeNonStandardFormat(format); +} +var EXCEPTIONS = { + // Packed 16 bit formats + "rgba4unorm-webgl": { format: "rgba", bpp: 2 }, + "rgb565unorm-webgl": { format: "rgb", bpp: 2 }, + "rgb5a1unorm-webgl": { format: "rgba", bbp: 2 }, + // Packed 32 bit formats + rgb9e5ufloat: { format: "rgb", bbp: 4 }, + rg11b10ufloat: { format: "rgb", bbp: 4 }, + rgb10a2unorm: { format: "rgba", bbp: 4 }, + "rgb10a2uint-webgl": { format: "rgba", bbp: 4 }, + // Depth/stencil + stencil8: { components: 1, bpp: 1, a: "stencil" }, + depth16unorm: { components: 1, bpp: 2, a: "depth" }, + depth24plus: { components: 1, bpp: 3, a: "depth" }, + depth32float: { components: 1, bpp: 4, a: "depth" }, + "depth24plus-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }, + // "depth24unorm-stencil8" feature + "depth24unorm-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }, + // "depth32float-stencil8" feature + "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" } +}; +function decodeNonStandardFormat(format) { + const data = EXCEPTIONS[format]; + if (!data) { + throw new Error(`Unknown format ${format}`); + } + return { + format: data.format || "", + components: data.components || data.format?.length || 1, + byteLength: data.bpp || 1, + srgb: false, + unsized: false + }; +} + +// node_modules/@luma.gl/core/dist/adapter/device.js +var DeviceLimits = class { +}; +var DeviceFeatures = class { + features; + disabledFeatures; + constructor(features = [], disabledFeatures) { + this.features = new Set(features); + this.disabledFeatures = disabledFeatures || {}; + } + *[Symbol.iterator]() { + yield* this.features; + } + has(feature) { + return !this.disabledFeatures[feature] && this.features.has(feature); + } +}; +var Device = class _Device { + static defaultProps = { + id: null, + canvas: null, + container: null, + manageState: true, + width: 800, + // width are height are only used by headless gl + height: 600, + requestMaxLimits: true, + debug: Boolean(log2.get("debug")), + // Instrument context (at the expense of performance) + spector: Boolean(log2.get("spector") || log2.get("spectorjs")), + // Initialize the SpectorJS WebGL debugger + break: [], + // TODO - Change these after confirming things work as expected + initalizeFeatures: true, + disabledFeatures: { + "compilation-status-async-webgl": true + }, + // alpha: undefined, + // depth: undefined, + // stencil: undefined, + // antialias: undefined, + // premultipliedAlpha: undefined, + // preserveDrawingBuffer: undefined, + // failIfMajorPerformanceCaveat: undefined + gl: null, + // Callbacks + onError: (error) => log2.error(error.message) + }; + get [Symbol.toStringTag]() { + return "Device"; + } + static VERSION = VERSION6; + constructor(props) { + this.props = { ..._Device.defaultProps, ...props }; + this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase()); + } + /** id of this device, primarily for debugging */ + id; + /** A copy of the device props */ + props; + /** Available for the application to store data on the device */ + userData = {}; + /** stats */ + statsManager = lumaStats; + /** Used by other luma.gl modules to store data on the device */ + _lumaData = {}; + /** Check if a specific texture format is GPU compressed */ + isTextureFormatCompressed(format) { + return isTextureFormatCompressed(format); + } + /** + * Trigger device loss. + * @returns `true` if context loss could actually be triggered. + * @note primarily intended for testing how application reacts to device loss + */ + loseDevice() { + return false; + } + /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */ + getCanvasContext() { + if (!this.canvasContext) { + throw new Error("Device has no CanvasContext"); + } + return this.canvasContext; + } + createTexture(props) { + if (props instanceof Promise || typeof props === "string") { + props = { data: props }; + } + return this._createTexture(props); + } + createCommandEncoder(props = {}) { + throw new Error("not implemented"); + } + // WebGL specific HACKS - enables app to remove webgl import + // Use until we have a better way to handle these + /** @deprecated - will be removed - should use command encoder */ + readPixelsToArrayWebGL(source, options) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use command encoder */ + readPixelsToBufferWebGL(source, options) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ + setParametersWebGL(parameters) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ + getParametersWebGL(parameters) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ + withParametersWebGL(parameters, func) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use clear arguments in RenderPass */ + clearWebGL(options) { + throw new Error("not implemented"); + } + /** @deprecated - will be removed - should use for debugging only */ + resetWebGL() { + throw new Error("not implemented"); + } + timestamp = 0; + /** A monotonic counter for tracking buffer and texture updates */ + incrementTimestamp() { + return this.timestamp++; + } + // Error Handling + /** Report unhandled device errors */ + onError(error) { + this.props.onError(error); + } + // IMPLEMENTATION + _getBufferProps(props) { + if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) { + props = { data: props }; + } + const newProps = { ...props }; + if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) { + if (props.data instanceof Uint32Array) { + newProps.indexType = "uint32"; + } else if (props.data instanceof Uint16Array) { + newProps.indexType = "uint16"; + } else { + log2.warn("indices buffer content must be of integer type")(); + } + } + return newProps; + } +}; + +// node_modules/@luma.gl/core/dist/utils/assert.js +function assert6(condition, message2) { + if (!condition) { + throw new Error(message2 || "luma.gl: assertion failed."); + } +} + +// node_modules/@luma.gl/core/dist/lib/luma.js +var deviceMap = /* @__PURE__ */ new Map(); +var luma = class _luma { + static defaultProps = { + ...Device.defaultProps, + type: "best-available", + devices: void 0 + }; + /** Global stats for all devices */ + static stats = lumaStats; + /** Global log */ + static log = log2; + static registerDevices(deviceClasses) { + for (const deviceClass of deviceClasses) { + assert6(deviceClass.type && deviceClass.isSupported && deviceClass.create); + deviceMap.set(deviceClass.type, deviceClass); + } + } + static getAvailableDevices() { + return Array.from(deviceMap).map((Device2) => Device2.type); + } + static getSupportedDevices() { + return Array.from(deviceMap).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type); + } + static setDefaultDeviceProps(props) { + Object.assign(Device.defaultProps, props); + } + /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */ + static async attachDevice(props) { + const devices = getDeviceMap(props.devices) || deviceMap; + if (props.handle instanceof WebGL2RenderingContext) { + const WebGLDevice2 = devices.get("webgl"); + if (WebGLDevice2) { + return await WebGLDevice2.attach(props.handle); + } + } + if (props.handle === null) { + const UnknownDevice = devices.get("unknown"); + if (UnknownDevice) { + return await UnknownDevice.attach(null); + } + } + throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."); + } + /** Creates a device. Asynchronously. */ + static async createDevice(props = {}) { + props = { ..._luma.defaultProps, ...props }; + if (props.gl) { + props.type = "webgl"; + } + const devices = getDeviceMap(props.devices) || deviceMap; + let WebGPUDevice; + let WebGLDevice2; + switch (props.type) { + case "webgpu": + WebGPUDevice = devices.get("webgpu"); + if (WebGPUDevice) { + return await WebGPUDevice.create(props); + } + break; + case "webgl": + WebGLDevice2 = devices.get("webgl"); + if (WebGLDevice2) { + return await WebGLDevice2.create(props); + } + break; + case "unknown": + const UnknownDevice = devices.get("unknown"); + if (UnknownDevice) { + return await UnknownDevice.create(props); + } + break; + case "best-available": + WebGPUDevice = devices.get("webgpu"); + if (WebGPUDevice?.isSupported?.()) { + return await WebGPUDevice.create(props); + } + WebGLDevice2 = devices.get("webgl"); + if (WebGLDevice2?.isSupported?.()) { + return await WebGLDevice2.create(props); + } + break; + } + throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."); + } + static enforceWebGL2(enforce = true) { + const prototype = HTMLCanvasElement.prototype; + if (!enforce && prototype.originalGetContext) { + prototype.getContext = prototype.originalGetContext; + prototype.originalGetContext = void 0; + return; + } + prototype.originalGetContext = prototype.getContext; + prototype.getContext = function(contextId, options) { + if (contextId === "webgl" || contextId === "experimental-webgl") { + return this.originalGetContext("webgl2", options); + } + return this.originalGetContext(contextId, options); + }; + } +}; +function getDeviceMap(deviceClasses) { + if (!deviceClasses || deviceClasses?.length === 0) { + return null; + } + const map3 = /* @__PURE__ */ new Map(); + for (const deviceClass of deviceClasses) { + map3.set(deviceClass.type, deviceClass); + } + return map3; +} + +// node_modules/@luma.gl/core/dist/adapter/canvas-context.js +var isPage = isBrowser2() && typeof document !== "undefined"; +var isPageLoaded = () => isPage && document.readyState === "complete"; +var DEFAULT_CANVAS_CONTEXT_PROPS = { + canvas: null, + width: 800, + // width are height are only used by headless gl + height: 600, + useDevicePixels: true, + autoResize: true, + container: null, + visible: true, + colorSpace: "srgb", + alphaMode: "opaque" +}; +var CanvasContext = class { + id; + props; + canvas; + htmlCanvas; + offscreenCanvas; + type; + width = 1; + height = 1; + resizeObserver; + /** State used by luma.gl classes: TODO - move to canvasContext*/ + _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 }; + /** Check if the DOM is loaded */ + static get isPageLoaded() { + return isPageLoaded(); + } + /** + * Get a 'lazy' promise that resolves when the DOM is loaded. + * @note Since there may be limitations on number of `load` event listeners, + * it is recommended avoid calling this function until actually needed. + * I.e. don't call it until you know that you will be looking up a string in the DOM. + */ + static pageLoaded = getPageLoadPromise(); + constructor(props) { + this.props = { ...DEFAULT_CANVAS_CONTEXT_PROPS, ...props }; + props = this.props; + if (!isBrowser2()) { + this.id = "node-canvas-context"; + this.type = "node"; + this.width = this.props.width; + this.height = this.props.height; + this.canvas = null; + return; + } + if (!props.canvas) { + const canvas2 = createCanvas(props); + const container = getContainer(props?.container || null); + container.insertBefore(canvas2, container.firstChild); + this.canvas = canvas2; + if (!props?.visible) { + this.canvas.style.visibility = "hidden"; + } + } else if (typeof props.canvas === "string") { + this.canvas = getCanvasFromDOM(props.canvas); + } else { + this.canvas = props.canvas; + } + if (this.canvas instanceof HTMLCanvasElement) { + this.id = this.canvas.id; + this.type = "html-canvas"; + this.htmlCanvas = this.canvas; + } else { + this.id = "offscreen-canvas"; + this.type = "offscreen-canvas"; + this.offscreenCanvas = this.canvas; + } + if (this.canvas instanceof HTMLCanvasElement && props.autoResize) { + this.resizeObserver = new ResizeObserver((entries) => { + for (const entry of entries) { + if (entry.target === this.canvas) { + this.update(); + } + } + }); + this.resizeObserver.observe(this.canvas); + } + } + /** + * Returns the current DPR, if props.useDevicePixels is true + * Device refers to physical + */ + getDevicePixelRatio(useDevicePixels) { + if (typeof OffscreenCanvas !== "undefined" && this.canvas instanceof OffscreenCanvas) { + return 1; + } + useDevicePixels = useDevicePixels === void 0 ? this.props.useDevicePixels : useDevicePixels; + if (!useDevicePixels || useDevicePixels <= 0) { + return 1; + } + if (useDevicePixels === true) { + const dpr = typeof window !== "undefined" && window.devicePixelRatio; + return dpr || 1; + } + return useDevicePixels; + } + /** + * Returns the size of drawing buffer in device pixels. + * @note This can be different from the 'CSS' size of a canvas, and also from the + * canvas' internal drawing buffer size (.width, .height). + * This is the size required to cover the canvas, adjusted for DPR + */ + getPixelSize() { + switch (this.type) { + case "node": + return [this.width, this.height]; + case "offscreen-canvas": + return [this.canvas.width, this.canvas.height]; + case "html-canvas": + const dpr = this.getDevicePixelRatio(); + const canvas2 = this.canvas; + return canvas2.parentElement ? [canvas2.clientWidth * dpr, canvas2.clientHeight * dpr] : [this.canvas.width, this.canvas.height]; + default: + throw new Error(this.type); + } + } + getAspect() { + const [width, height] = this.getPixelSize(); + return width / height; + } + /** + * Returns multiplier need to convert CSS size to Device size + */ + cssToDeviceRatio() { + try { + const [drawingBufferWidth] = this.getDrawingBufferSize(); + const { clientWidth } = this._canvasSizeInfo; + return clientWidth ? drawingBufferWidth / clientWidth : 1; + } catch { + return 1; + } + } + /** + * Maps CSS pixel position to device pixel position + */ + cssToDevicePixels(cssPixel, yInvert = true) { + const ratio = this.cssToDeviceRatio(); + const [width, height] = this.getDrawingBufferSize(); + return scalePixels(cssPixel, ratio, width, height, yInvert); + } + /** + * Use devicePixelRatio to set canvas width and height + * @note this is a raw port of luma.gl v8 code. Might be worth a review + */ + setDevicePixelRatio(devicePixelRatio, options = {}) { + if (!this.htmlCanvas) { + return; + } + let clientWidth = "width" in options ? options.width : this.htmlCanvas.clientWidth; + let clientHeight = "height" in options ? options.height : this.htmlCanvas.clientHeight; + if (!clientWidth || !clientHeight) { + log2.log(1, "Canvas clientWidth/clientHeight is 0")(); + devicePixelRatio = 1; + clientWidth = this.htmlCanvas.width || 1; + clientHeight = this.htmlCanvas.height || 1; + } + const cachedSize = this._canvasSizeInfo; + if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) { + let clampedPixelRatio = devicePixelRatio; + const canvasWidth = Math.floor(clientWidth * clampedPixelRatio); + const canvasHeight = Math.floor(clientHeight * clampedPixelRatio); + this.htmlCanvas.width = canvasWidth; + this.htmlCanvas.height = canvasHeight; + const [drawingBufferWidth, drawingBufferHeight] = this.getDrawingBufferSize(); + if (drawingBufferWidth !== canvasWidth || drawingBufferHeight !== canvasHeight) { + clampedPixelRatio = Math.min(drawingBufferWidth / clientWidth, drawingBufferHeight / clientHeight); + this.htmlCanvas.width = Math.floor(clientWidth * clampedPixelRatio); + this.htmlCanvas.height = Math.floor(clientHeight * clampedPixelRatio); + log2.warn("Device pixel ratio clamped")(); + } + this._canvasSizeInfo.clientWidth = clientWidth; + this._canvasSizeInfo.clientHeight = clientHeight; + this._canvasSizeInfo.devicePixelRatio = devicePixelRatio; + } + } + // PRIVATE + /** @todo Major hack done to port the CSS methods above, base canvas context should not depend on WebGL */ + getDrawingBufferSize() { + const gl = this.device.gl; + if (!gl) { + throw new Error("canvas size"); + } + return [gl.drawingBufferWidth, gl.drawingBufferHeight]; + } + /** + * Allows subclass constructor to override the canvas id for auto created canvases. + * This can really help when debugging DOM in apps that create multiple devices + */ + _setAutoCreatedCanvasId(id) { + if (this.htmlCanvas?.id === "lumagl-auto-created-canvas") { + this.htmlCanvas.id = id; + } + } +}; +function getPageLoadPromise() { + if (isPageLoaded() || typeof window === "undefined") { + return Promise.resolve(); + } + return new Promise((resolve2) => { + window.addEventListener("load", () => resolve2()); + }); +} +function getContainer(container) { + if (typeof container === "string") { + const element = document.getElementById(container); + if (!element && !isPageLoaded()) { + throw new Error(`Accessing '${container}' before page was loaded`); + } + if (!element) { + throw new Error(`${container} is not an HTML element`); + } + return element; + } else if (container) { + return container; + } + return document.body; +} +function getCanvasFromDOM(canvasId) { + const canvas2 = document.getElementById(canvasId); + if (!canvas2 && !isPageLoaded()) { + throw new Error(`Accessing '${canvasId}' before page was loaded`); + } + if (!(canvas2 instanceof HTMLCanvasElement)) { + throw new Error("Object is not a canvas element"); + } + return canvas2; +} +function createCanvas(props) { + const { width, height } = props; + const targetCanvas = document.createElement("canvas"); + targetCanvas.id = "lumagl-auto-created-canvas"; + targetCanvas.width = width || 1; + targetCanvas.height = height || 1; + targetCanvas.style.width = Number.isFinite(width) ? `${width}px` : "100%"; + targetCanvas.style.height = Number.isFinite(height) ? `${height}px` : "100%"; + return targetCanvas; +} +function scalePixels(pixel, ratio, width, height, yInvert) { + const point = pixel; + const x = scaleX(point[0], ratio, width); + let y = scaleY(point[1], ratio, height, yInvert); + let t = scaleX(point[0] + 1, ratio, width); + const xHigh = t === width - 1 ? t : t - 1; + t = scaleY(point[1] + 1, ratio, height, yInvert); + let yHigh; + if (yInvert) { + t = t === 0 ? t : t + 1; + yHigh = y; + y = t; + } else { + yHigh = t === height - 1 ? t : t - 1; + } + return { + x, + y, + // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases. + width: Math.max(xHigh - x + 1, 1), + height: Math.max(yHigh - y + 1, 1) + }; +} +function scaleX(x, ratio, width) { + const r = Math.min(Math.round(x * ratio), width - 1); + return r; +} +function scaleY(y, ratio, height, yInvert) { + return yInvert ? Math.max(0, height - 1 - Math.round(y * ratio)) : Math.min(Math.round(y * ratio), height - 1); +} + +// node_modules/@luma.gl/core/dist/adapter/resources/texture.js +var Texture = class _Texture extends Resource { + static defaultProps = { + ...Resource.defaultProps, + data: null, + dimension: "2d", + format: "rgba8unorm", + width: void 0, + height: void 0, + depth: 1, + mipmaps: true, + // type: undefined, + compressed: false, + // mipLevels: 1, + usage: 0, + // usage: GPUTextureUsage.COPY_DST + mipLevels: void 0, + samples: void 0, + type: void 0, + sampler: {}, + view: void 0 + }; + static COPY_SRC = 1; + static COPY_DST = 2; + static TEXTURE_BINDING = 4; + static STORAGE_BINDING = 8; + static RENDER_ATTACHMENT = 16; + get [Symbol.toStringTag]() { + return "Texture"; + } + /** dimension of this texture */ + dimension; + /** format of this texture */ + format; + /** width in pixels of this texture */ + width; + /** height in pixels of this texture */ + height; + /** depth of this texture */ + depth; + /** "Time" of last update. Monotonically increasing timestamp */ + updateTimestamp; + /** Do not use directly. Create with device.createTexture() */ + constructor(device, props, defaultProps14 = _Texture.defaultProps) { + super(device, props, defaultProps14); + this.dimension = this.props.dimension; + this.format = this.props.format; + this.width = this.props.width; + this.height = this.props.height; + this.depth = this.props.depth; + this.updateTimestamp = device.incrementTimestamp(); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/texture-view.js +var TextureView = class _TextureView extends Resource { + static defaultProps = { + ...Resource.defaultProps, + format: void 0, + dimension: void 0, + aspect: "all", + baseMipLevel: 0, + mipLevelCount: void 0, + baseArrayLayer: 0, + arrayLayerCount: void 0 + }; + get [Symbol.toStringTag]() { + return "TextureView"; + } + /** Should not be constructed directly. Use `texture.createView(props)` */ + constructor(device, props) { + super(device, props, _TextureView.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/lib/compiler-log/format-compiler-log.js +function formatCompilerLog(shaderLog, source, options) { + let formattedLog = ""; + const lines = source.split(/\r?\n/); + const log4 = shaderLog.slice().sort((a, b) => a.lineNum - b.lineNum); + switch (options?.showSourceCode || "no") { + case "all": + let currentMessage = 0; + for (let lineNum = 1; lineNum <= lines.length; lineNum++) { + formattedLog += getNumberedLine(lines[lineNum - 1], lineNum, options); + while (log4.length > currentMessage && log4[currentMessage].lineNum === lineNum) { + const message2 = log4[currentMessage++]; + formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, { + ...options, + inlineSource: false + }); + } + } + return formattedLog; + case "issues": + case "no": + for (const message2 of shaderLog) { + formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, { + inlineSource: options?.showSourceCode !== "no" + }); + } + return formattedLog; + } +} +function formatCompilerMessage(message2, lines, lineNum, options) { + if (options?.inlineSource) { + const numberedLines = getNumberedLines(lines, lineNum); + const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^ +` : ""; + return ` +${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message} + +`; + } + return options?.html ? `
${message2.type.toUpperCase()}: ${message2.message}
` : `${message2.type.toUpperCase()}: ${message2.message}`; +} +function getNumberedLines(lines, lineNum, options) { + let numberedLines = ""; + for (let lineIndex = lineNum - 2; lineIndex <= lineNum; lineIndex++) { + const sourceLine = lines[lineIndex - 1]; + if (sourceLine !== void 0) { + numberedLines += getNumberedLine(sourceLine, lineNum, options); + } + } + return numberedLines; +} +function getNumberedLine(line, lineNum, options) { + const escapedLine = options?.html ? escapeHTML(line) : line; + return `${padLeft(String(lineNum), 4)}: ${escapedLine}${options?.html ? "
" : "\n"}`; +} +function padLeft(string, paddedLength) { + let result = ""; + for (let i = string.length; i < paddedLength; ++i) { + result += " "; + } + return result + string; +} +function escapeHTML(unsafe) { + return unsafe.replaceAll("&", "&").replaceAll("<", "<").replaceAll(">", ">").replaceAll('"', """).replaceAll("'", "'"); +} + +// node_modules/@luma.gl/core/dist/lib/compiler-log/get-shader-info.js +function getShaderInfo2(source, defaultName) { + return { + name: getShaderName2(source, defaultName), + language: "glsl", + version: getShaderVersion2(source) + }; +} +function getShaderName2(shader, defaultName = "unnamed") { + const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/; + const match = SHADER_NAME_REGEXP.exec(shader); + return match ? match[1] : defaultName; +} +function getShaderVersion2(source) { + let version2 = 100; + const words = source.match(/[^\s]+/g); + if (words && words.length >= 2 && words[0] === "#version") { + const v = parseInt(words[1], 10); + if (Number.isFinite(v)) { + version2 = v; + } + } + return version2; +} + +// node_modules/@luma.gl/core/dist/adapter/resources/shader.js +var Shader = class _Shader extends Resource { + static defaultProps = { + ...Resource.defaultProps, + language: "auto", + stage: void 0, + source: "", + sourceMap: null, + entryPoint: "main", + debug: "errors" + }; + get [Symbol.toStringTag]() { + return "Shader"; + } + /** The stage of this shader */ + stage; + /** The source code of this shader */ + source; + /** The compilation status of the shader. 'pending' if compilation is asynchronous, and on production */ + compilationStatus = "pending"; + /** Create a new Shader instance */ + constructor(device, props) { + super(device, { id: getShaderIdFromProps(props), ...props }, _Shader.defaultProps); + this.stage = this.props.stage; + this.source = this.props.source; + } + /** Get compiler log synchronously (WebGL only) */ + getCompilationInfoSync() { + return null; + } + /** Get translated shader source in host platform's native language (HLSL, GLSL, and even GLSL ES), if available */ + getTranslatedSource() { + return null; + } + // PORTABLE HELPERS + /** In browser logging of errors */ + async debugShader(trigger = this.props.debug) { + switch (trigger) { + case "never": + return; + case "errors": + if (this.compilationStatus === "success") { + return; + } + break; + case "warnings": + case "always": + break; + } + const messages = await this.getCompilationInfo(); + if (this.props.debug === "warnings" && messages?.length === 0) { + return; + } + this._displayShaderLog(messages); + } + // PRIVATE + /** In-browser UI logging of errors */ + _displayShaderLog(messages) { + if (typeof document === "undefined" || !document?.createElement) { + return; + } + const shaderName = getShaderInfo2(this.source).name; + const shaderTitle = `${this.stage} ${shaderName}`; + let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true }); + const translatedSource = this.getTranslatedSource(); + if (translatedSource) { + htmlLog += `

Translated Source



${translatedSource}
`; + } + const button = document.createElement("Button"); + button.innerHTML = ` +

Shader Compilation Error in ${shaderTitle}



+
+${htmlLog}
+
`; + button.style.top = "10px"; + button.style.left = "10px"; + button.style.position = "absolute"; + button.style.zIndex = "9999"; + button.style.width = "100%"; + button.style.textAlign = "left"; + document.body.appendChild(button); + const errors = document.getElementsByClassName("luma-compiler-log-error"); + if (errors[0]?.scrollIntoView) { + errors[0].scrollIntoView(); + } + button.onclick = () => { + const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`; + navigator.clipboard.writeText(dataURI); + }; + } +}; +function getShaderIdFromProps(props) { + return getShaderInfo2(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`); +} + +// node_modules/@luma.gl/core/dist/adapter/resources/sampler.js +var Sampler = class _Sampler extends Resource { + static defaultProps = { + ...Resource.defaultProps, + type: "color-sampler", + addressModeU: "clamp-to-edge", + addressModeV: "clamp-to-edge", + addressModeW: "clamp-to-edge", + magFilter: "nearest", + minFilter: "nearest", + mipmapFilter: "nearest", + lodMinClamp: 0, + lodMaxClamp: 32, + // Per WebGPU spec + compare: "less-equal", + maxAnisotropy: 1 + }; + get [Symbol.toStringTag]() { + return "Sampler"; + } + constructor(device, props) { + super(device, props, _Sampler.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/framebuffer.js +var Framebuffer = class _Framebuffer extends Resource { + static defaultProps = { + ...Resource.defaultProps, + width: 1, + height: 1, + colorAttachments: [], + // ['rgba8unorm'], + depthStencilAttachment: null + // 'depth24plus-stencil8' + }; + get [Symbol.toStringTag]() { + return "Framebuffer"; + } + /** Width of all attachments in this framebuffer */ + width; + /** Height of all attachments in this framebuffer */ + height; + /** Color attachments */ + colorAttachments = []; + /** Depth-stencil attachment, if provided */ + depthStencilAttachment = null; + constructor(device, props = {}) { + super(device, props, _Framebuffer.defaultProps); + this.width = this.props.width; + this.height = this.props.height; + } + resize(size) { + let updateSize = !size; + if (size) { + const [width, height] = Array.isArray(size) ? size : [size.width, size.height]; + updateSize = updateSize || height !== this.height || width !== this.width; + this.width = width; + this.height = height; + } + if (updateSize) { + log2.log(2, `Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)(); + this.resizeAttachments(this.width, this.height); + } + } + /** Auto creates any textures */ + autoCreateAttachmentTextures() { + if (this.props.colorAttachments.length === 0 && !this.props.depthStencilAttachment) { + throw new Error("Framebuffer has noattachments"); + } + this.colorAttachments = this.props.colorAttachments.map((attachment2) => { + if (typeof attachment2 === "string") { + const texture = this.createColorTexture(attachment2); + this.attachResource(texture); + return texture.view; + } + if (attachment2 instanceof Texture) { + return attachment2.view; + } + return attachment2; + }); + const attachment = this.props.depthStencilAttachment; + if (attachment) { + if (typeof attachment === "string") { + const texture = this.createDepthStencilTexture(attachment); + this.attachResource(texture); + this.depthStencilAttachment = texture.view; + } else if (attachment instanceof Texture) { + this.depthStencilAttachment = attachment.view; + } else { + this.depthStencilAttachment = attachment; + } + } + } + /** Create a color texture */ + createColorTexture(format) { + return this.device.createTexture({ + id: "color-attachment", + usage: Texture.RENDER_ATTACHMENT, + format, + width: this.width, + height: this.height + }); + } + /** Create depth stencil texture */ + createDepthStencilTexture(format) { + return this.device.createTexture({ + id: "depth-stencil-attachment", + usage: Texture.RENDER_ATTACHMENT, + format, + width: this.width, + height: this.height + }); + } + /** + * Default implementation of resize + * Creates new textures with correct size for all attachments. + * and destroys existing textures if owned + */ + resizeAttachments(width, height) { + for (let i = 0; i < this.colorAttachments.length; ++i) { + if (this.colorAttachments[i]) { + const resizedTexture = this.device._createTexture({ + ...this.colorAttachments[i].props, + width, + height + }); + this.destroyAttachedResource(this.colorAttachments[i]); + this.colorAttachments[i] = resizedTexture.view; + this.attachResource(resizedTexture.view); + } + } + if (this.depthStencilAttachment) { + const resizedTexture = this.device._createTexture({ + ...this.depthStencilAttachment.props, + width, + height + }); + this.destroyAttachedResource(this.depthStencilAttachment); + this.depthStencilAttachment = resizedTexture.view; + this.attachResource(resizedTexture); + } + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/render-pipeline.js +var RenderPipeline = class _RenderPipeline extends Resource { + static defaultProps = { + ...Resource.defaultProps, + vs: null, + vertexEntryPoint: "vertexMain", + vsConstants: {}, + fs: null, + fragmentEntryPoint: "fragmentMain", + fsConstants: {}, + shaderLayout: null, + bufferLayout: [], + topology: "triangle-list", + parameters: {}, + // isInstanced: false, + // instanceCount: 0, + // vertexCount: 0, + bindings: {}, + uniforms: {} + }; + get [Symbol.toStringTag]() { + return "RenderPipeline"; + } + /** The merged layout */ + shaderLayout; + /** Buffer map describing buffer interleaving etc */ + bufferLayout; + /** The linking status of the pipeline. 'pending' if linking is asynchronous, and on production */ + linkStatus = "pending"; + /** The hash of the pipeline */ + hash = ""; + constructor(device, props) { + super(device, props, _RenderPipeline.defaultProps); + this.shaderLayout = this.props.shaderLayout; + this.bufferLayout = this.props.bufferLayout || []; + } + // DEPRECATED METHODS + /** + * Uniforms + * @deprecated Use uniforms buffers + * @note textures, samplers and uniform buffers should be set via `setBindings()`, these are not considered uniforms. + * @note In WebGL uniforms have a performance penalty, they are reset before each call to enable pipeline sharing. + */ + setUniformsWebGL(uniforms) { + throw new Error("Use uniform blocks"); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/render-pass.js +var RenderPass = class _RenderPass extends Resource { + /** Default properties for RenderPass */ + static defaultProps = { + ...Resource.defaultProps, + framebuffer: null, + parameters: void 0, + clearColor: [0, 0, 0, 0], + clearDepth: 1, + clearStencil: 0, + depthReadOnly: false, + stencilReadOnly: false, + discard: false, + occlusionQuerySet: void 0, + timestampQuerySet: void 0, + beginTimestampIndex: void 0, + endTimestampIndex: void 0 + }; + get [Symbol.toStringTag]() { + return "RenderPass"; + } + constructor(device, props) { + super(device, props, _RenderPass.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/compute-pipeline.js +var ComputePipeline = class _ComputePipeline extends Resource { + static defaultProps = { + ...Resource.defaultProps, + shader: void 0, + entryPoint: void 0, + constants: {}, + shaderLayout: void 0 + }; + get [Symbol.toStringTag]() { + return "ComputePipeline"; + } + hash = ""; + constructor(device, props) { + super(device, props, _ComputePipeline.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/command-encoder.js +var CommandEncoder = class _CommandEncoder extends Resource { + static defaultProps = { + ...Resource.defaultProps, + measureExecutionTime: void 0 + }; + get [Symbol.toStringTag]() { + return "CommandEncoder"; + } + constructor(device, props) { + super(device, props, _CommandEncoder.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/command-buffer.js +var CommandBuffer = class _CommandBuffer extends Resource { + static defaultProps = { + ...Resource.defaultProps + }; + get [Symbol.toStringTag]() { + return "CommandBuffer"; + } + constructor(device, props) { + super(device, props, _CommandBuffer.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-attribute-type.js +function decodeShaderAttributeType(attributeType) { + const [dataType, components] = TYPE_INFO[attributeType]; + const integer = dataType === "i32" || dataType === "u32"; + const signed = dataType !== "u32"; + const byteLength = TYPE_SIZES2[dataType] * components; + const defaultVertexFormat = getCompatibleVertexFormat(dataType, components); + return { + dataType, + components, + defaultVertexFormat, + byteLength, + integer, + signed + }; +} +function getCompatibleVertexFormat(dataType, components) { + let vertexType; + switch (dataType) { + case "f32": + vertexType = "float32"; + break; + case "i32": + vertexType = "sint32"; + break; + case "u32": + vertexType = "uint32"; + break; + case "f16": + return components <= 2 ? "float16x2" : "float16x4"; + } + if (components === 1) { + return vertexType; + } + return `${vertexType}x${components}`; +} +var TYPE_INFO = { + f32: ["f32", 1], + "vec2": ["f32", 2], + "vec3": ["f32", 3], + "vec4": ["f32", 4], + f16: ["f16", 1], + "vec2": ["f16", 2], + "vec3": ["f16", 3], + "vec4": ["f16", 4], + i32: ["i32", 1], + "vec2": ["i32", 2], + "vec3": ["i32", 3], + "vec4": ["i32", 4], + u32: ["u32", 1], + "vec2": ["u32", 2], + "vec3": ["u32", 3], + "vec4": ["u32", 4] +}; +var TYPE_SIZES2 = { + f32: 4, + f16: 2, + i32: 4, + u32: 4 + // 'bool-webgl': 4, +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-vertex-format.js +function decodeVertexFormat(format) { + let webglOnly; + if (format.endsWith("-webgl")) { + format.replace("-webgl", ""); + webglOnly = true; + } + const [type_, count2] = format.split("x"); + const type = type_; + const components = count2 ? parseInt(count2) : 1; + const decodedType = decodeVertexType(type); + const result = { + type, + components, + byteLength: decodedType.byteLength * components, + integer: decodedType.integer, + signed: decodedType.signed, + normalized: decodedType.normalized + }; + if (webglOnly) { + result.webglOnly = true; + } + return result; +} + +// node_modules/@luma.gl/core/dist/adapter/attribute-utils/get-attribute-from-layouts.js +function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) { + const attributeInfos = {}; + for (const attribute of shaderLayout.attributes) { + attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name); + } + return attributeInfos; +} +function getAttributeInfosByLocation(shaderLayout, bufferLayout, maxVertexAttributes = 16) { + const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout); + const locationInfos = new Array(maxVertexAttributes).fill(null); + for (const attributeInfo of Object.values(attributeInfos)) { + locationInfos[attributeInfo.location] = attributeInfo; + } + return locationInfos; +} +function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) { + const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2); + const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2); + if (!shaderDeclaration) { + return null; + } + const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type); + const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat; + const vertexFormatInfo = decodeVertexFormat(vertexFormat); + return { + attributeName: bufferMapping?.attributeName || shaderDeclaration.name, + bufferName: bufferMapping?.bufferName || shaderDeclaration.name, + location: shaderDeclaration.location, + shaderType: shaderDeclaration.type, + shaderDataType: attributeTypeInfo.dataType, + shaderComponents: attributeTypeInfo.components, + vertexFormat, + bufferDataType: vertexFormatInfo.type, + bufferComponents: vertexFormatInfo.components, + // normalized is a property of the buffer's vertex format + normalized: vertexFormatInfo.normalized, + // integer is a property of the shader declaration + integer: attributeTypeInfo.integer, + stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode, + byteOffset: bufferMapping?.byteOffset || 0, + byteStride: bufferMapping?.byteStride || 0 + }; +} +function getAttributeFromShaderLayout(shaderLayout, name2) { + const attribute = shaderLayout.attributes.find((attr) => attr.name === name2); + if (!attribute) { + log2.warn(`shader layout attribute "${name2}" not present in shader`); + } + return attribute || null; +} +function getAttributeFromBufferLayout(bufferLayouts, name2) { + checkBufferLayouts(bufferLayouts); + let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2); + if (bufferLayoutInfo) { + return bufferLayoutInfo; + } + bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2); + if (bufferLayoutInfo) { + return bufferLayoutInfo; + } + log2.warn(`layout for attribute "${name2}" not present in buffer layout`); + return null; +} +function checkBufferLayouts(bufferLayouts) { + for (const bufferLayout of bufferLayouts) { + if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) { + log2.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`); + } + } +} +function getAttributeFromShortHand(bufferLayouts, name2) { + for (const bufferLayout of bufferLayouts) { + if (bufferLayout.format && bufferLayout.name === name2) { + return { + attributeName: bufferLayout.name, + bufferName: name2, + stepMode: bufferLayout.stepMode, + vertexFormat: bufferLayout.format, + // If offset is needed, use `attributes` field. + byteOffset: 0, + byteStride: bufferLayout.byteStride || 0 + }; + } + } + return null; +} +function getAttributeFromAttributesList(bufferLayouts, name2) { + for (const bufferLayout of bufferLayouts) { + let byteStride = bufferLayout.byteStride; + if (typeof bufferLayout.byteStride !== "number") { + for (const attributeMapping2 of bufferLayout.attributes || []) { + const info = decodeVertexFormat(attributeMapping2.format); + byteStride += info.byteLength; + } + } + const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2); + if (attributeMapping) { + return { + attributeName: attributeMapping.attribute, + bufferName: bufferLayout.name, + stepMode: bufferLayout.stepMode, + vertexFormat: attributeMapping.format, + byteOffset: attributeMapping.byteOffset, + byteStride + }; + } + } + return null; +} +function mergeShaderLayout(baseLayout, overrideLayout) { + const mergedLayout = { + ...baseLayout, + attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })) + }; + for (const attribute of overrideLayout?.attributes || []) { + const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name); + if (!baseAttribute) { + log2.warn(`shader layout attribute ${attribute.name} not present in shader`); + } else { + baseAttribute.type = attribute.type || baseAttribute.type; + baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode; + } + } + return mergedLayout; +} + +// node_modules/@luma.gl/core/dist/adapter/resources/vertex-array.js +var VertexArray = class _VertexArray extends Resource { + static defaultProps = { + ...Resource.defaultProps, + renderPipeline: null + }; + get [Symbol.toStringTag]() { + return "VertexArray"; + } + /** Max number of vertex attributes */ + maxVertexAttributes; + /** Attribute infos indexed by location - TODO only needed by webgl module? */ + attributeInfos; + /** Index buffer */ + indexBuffer = null; + /** Attributes indexed by buffer slot */ + attributes; + constructor(device, props) { + super(device, props, _VertexArray.defaultProps); + this.maxVertexAttributes = device.limits.maxVertexAttributes; + this.attributes = new Array(this.maxVertexAttributes).fill(null); + this.attributeInfos = getAttributeInfosByLocation(props.renderPipeline.shaderLayout, props.renderPipeline.bufferLayout, this.maxVertexAttributes); + } + // DEPRECATED METHODS + /** @deprecated Set constant attributes (WebGL only) */ + setConstantWebGL(location, value) { + throw new Error("constant attributes not supported"); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/transform-feedback.js +var TransformFeedback = class _TransformFeedback extends Resource { + static defaultProps = { + ...Resource.defaultProps, + layout: void 0, + buffers: {} + }; + get [Symbol.toStringTag]() { + return "TransformFeedback"; + } + constructor(device, props) { + super(device, props, _TransformFeedback.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/resources/query-set.js +var QuerySet = class _QuerySet extends Resource { + static defaultProps = { + ...Resource.defaultProps, + type: void 0, + count: void 0 + }; + get [Symbol.toStringTag]() { + return "QuerySet"; + } + constructor(device, props) { + super(device, props, _QuerySet.defaultProps); + } +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-shader-types.js +var UNIFORM_FORMATS = { + f32: { type: "f32", components: 1 }, + i32: { type: "i32", components: 1 }, + u32: { type: "u32", components: 1 }, + // 'bool-webgl': {type: 'bool-webgl', components: 1}, + "vec2": { type: "f32", components: 2 }, + "vec3": { type: "f32", components: 3 }, + "vec4": { type: "f32", components: 4 }, + "vec2": { type: "i32", components: 2 }, + "vec3": { type: "i32", components: 3 }, + "vec4": { type: "i32", components: 4 }, + "vec2": { type: "u32", components: 2 }, + "vec3": { type: "u32", components: 3 }, + "vec4": { type: "u32", components: 4 }, + "mat2x2": { type: "f32", components: 4 }, + "mat2x3": { type: "f32", components: 6 }, + "mat2x4": { type: "f32", components: 8 }, + "mat3x2": { type: "f32", components: 6 }, + "mat3x3": { type: "f32", components: 9 }, + "mat3x4": { type: "f32", components: 12 }, + "mat4x2": { type: "f32", components: 8 }, + "mat4x3": { type: "f32", components: 12 }, + "mat4x4": { type: "f32", components: 16 } +}; +function decodeShaderUniformType(format) { + const decoded = UNIFORM_FORMATS[format]; + assert6(format); + return decoded; +} +function alignTo(size, count2) { + switch (count2) { + case 1: + return size; + case 2: + return size + size % 2; + default: + return size + (4 - size % 4) % 4; + } +} + +// node_modules/@luma.gl/core/dist/utils/array-utils-flat.js +var arrayBuffer; +function getScratchArrayBuffer(byteLength) { + if (!arrayBuffer || arrayBuffer.byteLength < byteLength) { + arrayBuffer = new ArrayBuffer(byteLength); + } + return arrayBuffer; +} +function getScratchArray(Type2, length10) { + const scratchArrayBuffer = getScratchArrayBuffer(Type2.BYTES_PER_ELEMENT * length10); + return new Type2(scratchArrayBuffer, 0, length10); +} +function fillArray(options) { + const { target, source, start = 0, count: count2 = 1 } = options; + const length10 = source.length; + const total = count2 * length10; + let copied = 0; + for (let i = start; copied < length10; copied++) { + target[i++] = source[copied]; + } + while (copied < total) { + if (copied < total - copied) { + target.copyWithin(start + copied, start, start + copied); + copied *= 2; + } else { + target.copyWithin(start + copied, start, start + total - copied); + copied = total; + } + } + return options.target; +} + +// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-buffer-layout.js +var minBufferSize = 1024; +var UniformBufferLayout = class { + layout = {}; + /** number of bytes needed for buffer allocation */ + byteLength; + /** Create a new UniformBufferLayout given a map of attributes. */ + constructor(uniformTypes) { + let size = 0; + for (const [key, uniformType] of Object.entries(uniformTypes)) { + const typeAndComponents = decodeShaderUniformType(uniformType); + const { type, components: count2 } = typeAndComponents; + size = alignTo(size, count2); + const offset = size; + size += count2; + this.layout[key] = { type, size: count2, offset }; + } + size += (4 - size % 4) % 4; + const actualByteLength = size * 4; + this.byteLength = Math.max(actualByteLength, minBufferSize); + } + /** Get the data for the complete buffer */ + getData(uniformValues) { + const bufferSize = Math.max(this.byteLength, minBufferSize); + const arrayBuffer2 = getScratchArrayBuffer(bufferSize); + const typedArrays = { + i32: new Int32Array(arrayBuffer2), + u32: new Uint32Array(arrayBuffer2), + f32: new Float32Array(arrayBuffer2), + // TODO not implemented + f16: new Uint16Array(arrayBuffer2) + }; + for (const [name2, value] of Object.entries(uniformValues)) { + const uniformLayout = this.layout[name2]; + if (!uniformLayout) { + log2.warn(`Supplied uniform value ${name2} not present in uniform block layout`)(); + continue; + } + const { type, size, offset } = uniformLayout; + const typedArray = typedArrays[type]; + if (size === 1) { + if (typeof value !== "number" && typeof value !== "boolean") { + log2.warn(`Supplied value for single component uniform ${name2} is not a number: ${value}`)(); + continue; + } + typedArray[offset] = Number(value); + } else { + const numericArray = isNumberArray(value); + if (!numericArray) { + log2.warn(`Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`)(); + continue; + } + typedArray.set(numericArray, offset); + } + } + return new Uint8Array(arrayBuffer2); + } + /** Does this layout have a field with specified name */ + has(name2) { + return Boolean(this.layout[name2]); + } + /** Get offset and size for a field with specified name */ + get(name2) { + const layout = this.layout[name2]; + return layout; + } +}; + +// node_modules/@luma.gl/core/dist/utils/array-equal.js +function arrayEqual(a, b, limit = 16) { + if (a !== b) { + return false; + } + const arrayA = isNumberArray(a); + if (!arrayA) { + return false; + } + const arrayB = isNumberArray(b); + if (arrayB && arrayA.length === arrayB.length) { + for (let i = 0; i < arrayA.length; ++i) { + if (arrayB[i] !== arrayA[i]) { + return false; + } + } + } + return true; +} +function arrayCopy(a) { + const numberArray = isNumberArray(a); + if (numberArray) { + return numberArray.slice(); + } + return a; +} + +// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-block.js +var UniformBlock = class { + name; + uniforms = {}; + modifiedUniforms = {}; + modified = true; + bindingLayout = {}; + needsRedraw = "initialized"; + constructor(props) { + this.name = props?.name; + if (props?.name && props?.shaderLayout) { + const binding = props?.shaderLayout.bindings?.find((binding2) => binding2.type === "uniform" && binding2.name === props?.name); + if (!binding) { + throw new Error(props?.name); + } + const uniformBlock = binding; + for (const uniform of uniformBlock.uniforms || []) { + this.bindingLayout[uniform.name] = uniform; + } + } + } + /** Set a map of uniforms */ + setUniforms(uniforms) { + for (const [key, value] of Object.entries(uniforms)) { + this._setUniform(key, value); + if (!this.needsRedraw) { + this.setNeedsRedraw(`${this.name}.${key}=${value}`); + } + } + } + setNeedsRedraw(reason) { + this.needsRedraw = this.needsRedraw || reason; + } + /** Returns all uniforms */ + getAllUniforms() { + this.modifiedUniforms = {}; + this.needsRedraw = false; + return this.uniforms || {}; + } + /** Set a single uniform */ + _setUniform(key, value) { + if (arrayEqual(this.uniforms[key], value)) { + return; + } + this.uniforms[key] = arrayCopy(value); + this.modifiedUniforms[key] = true; + this.modified = true; + } +}; + +// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-store.js +var UniformStore = class { + /** Stores the uniform values for each uniform block */ + uniformBlocks = /* @__PURE__ */ new Map(); + /** Can generate data for a uniform buffer for each block from data */ + uniformBufferLayouts = /* @__PURE__ */ new Map(); + /** Actual buffer for the blocks */ + uniformBuffers = /* @__PURE__ */ new Map(); + /** + * Create a new UniformStore instance + * @param blocks + */ + constructor(blocks) { + for (const [bufferName, block] of Object.entries(blocks)) { + const uniformBufferName = bufferName; + const uniformBufferLayout = new UniformBufferLayout(block.uniformTypes || {}); + this.uniformBufferLayouts.set(uniformBufferName, uniformBufferLayout); + const uniformBlock = new UniformBlock({ name: bufferName }); + uniformBlock.setUniforms(block.defaultUniforms || {}); + this.uniformBlocks.set(uniformBufferName, uniformBlock); + } + } + /** Destroy any managed uniform buffers */ + destroy() { + for (const uniformBuffer of this.uniformBuffers.values()) { + uniformBuffer.destroy(); + } + } + /** + * Set uniforms + * Makes all properties partial + */ + setUniforms(uniforms) { + for (const [blockName, uniformValues] of Object.entries(uniforms)) { + this.uniformBlocks.get(blockName).setUniforms(uniformValues); + } + this.updateUniformBuffers(); + } + /** Get the required minimum length of the uniform buffer */ + getUniformBufferByteLength(uniformBufferName) { + return this.uniformBufferLayouts.get(uniformBufferName).byteLength; + } + /** Get formatted binary memory that can be uploaded to a buffer */ + getUniformBufferData(uniformBufferName) { + const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms(); + return this.uniformBufferLayouts.get(uniformBufferName).getData(uniformValues); + } + /** + * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it) + * The new buffer is initialized with current / supplied values + */ + createUniformBuffer(device, uniformBufferName, uniforms) { + if (uniforms) { + this.setUniforms(uniforms); + } + const byteLength = this.getUniformBufferByteLength(uniformBufferName); + const uniformBuffer = device.createBuffer({ + usage: Buffer2.UNIFORM | Buffer2.COPY_DST, + byteLength + }); + const uniformBufferData = this.getUniformBufferData(uniformBufferName); + uniformBuffer.write(uniformBufferData); + return uniformBuffer; + } + /** Get the managed uniform buffer. "managed" resources are destroyed when the uniformStore is destroyed. */ + getManagedUniformBuffer(device, uniformBufferName) { + if (!this.uniformBuffers.get(uniformBufferName)) { + const byteLength = this.getUniformBufferByteLength(uniformBufferName); + const uniformBuffer = device.createBuffer({ + usage: Buffer2.UNIFORM | Buffer2.COPY_DST, + byteLength + }); + this.uniformBuffers.set(uniformBufferName, uniformBuffer); + } + return this.uniformBuffers.get(uniformBufferName); + } + /** Updates all uniform buffers where values have changed */ + updateUniformBuffers() { + let reason = false; + for (const uniformBufferName of this.uniformBlocks.keys()) { + const bufferReason = this.updateUniformBuffer(uniformBufferName); + reason ||= bufferReason; + } + if (reason) { + log2.log(3, `UniformStore.updateUniformBuffers(): ${reason}`)(); + } + return reason; + } + /** Update one uniform buffer. Only updates if values have changed */ + updateUniformBuffer(uniformBufferName) { + const uniformBlock = this.uniformBlocks.get(uniformBufferName); + const uniformBuffer = this.uniformBuffers.get(uniformBufferName); + let reason = false; + if (uniformBuffer && uniformBlock.needsRedraw) { + reason ||= uniformBlock.needsRedraw; + const uniformBufferData = this.getUniformBufferData(uniformBufferName); + const uniformBuffer2 = this.uniformBuffers.get(uniformBufferName); + uniformBuffer2.write(uniformBufferData); + const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms(); + log2.log(4, `Writing to uniform buffer ${String(uniformBufferName)}`, uniformBufferData, uniformValues)(); + } + return reason; + } +}; + +// node_modules/@luma.gl/core/dist/adapter/type-utils/vertex-format-from-attribute.js +function getDataTypeFromTypedArray(arrayOrType) { + const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; + switch (type) { + case Float32Array: + return "float32"; + case Uint16Array: + return "uint16"; + case Uint32Array: + return "uint32"; + case Uint8Array: + case Uint8ClampedArray: + return "uint8"; + case Int8Array: + return "sint8"; + case Int16Array: + return "sint16"; + case Int32Array: + return "sint32"; + default: + throw new Error(type.constructor.name); + } +} +function getTypedArrayFromDataType(dataType) { + switch (dataType) { + case "float32": + return Float32Array; + case "uint32": + return Uint32Array; + case "sint32": + return Int32Array; + case "uint16": + case "unorm16": + return Uint16Array; + case "sint16": + case "snorm16": + return Int16Array; + case "uint8": + case "unorm8": + return Uint8Array; + case "sint8": + case "snorm8": + return Int8Array; + default: + throw new Error(dataType); + } +} +function getVertexFormatFromAttribute(typedArray, size, normalized) { + if (!size || size > 4) { + throw new Error(`size ${size}`); + } + const components = size; + let dataType = getDataTypeFromTypedArray(typedArray); + if (dataType === "uint8" && normalized && components === 1) { + return "unorm8-webgl"; + } + if (dataType === "uint8" && normalized && components === 3) { + return "unorm8x3-webgl"; + } + if (dataType === "uint8" || dataType === "sint8") { + if (components === 1 || components === 3) { + throw new Error(`size: ${size}`); + } + if (normalized) { + dataType = dataType.replace("int", "norm"); + } + return `${dataType}x${components}`; + } + if (dataType === "uint16" || dataType === "sint16") { + if (components === 1 || components === 3) { + throw new Error(`size: ${size}`); + } + if (normalized) { + dataType = dataType.replace("int", "norm"); + } + return `${dataType}x${components}`; + } + if (components === 1) { + return dataType; + } + return `${dataType}x${components}`; +} + +// node_modules/@luma.gl/core/dist/utils/cast.js +function cast(value) { + return value; +} + +// node_modules/@luma.gl/core/dist/lib/uniforms/uniform.js +function isUniformValue(value) { + return isNumberArray(value) !== null || typeof value === "number" || typeof value === "boolean"; +} +function splitUniformsAndBindings(uniforms) { + const result = { bindings: {}, uniforms: {} }; + Object.keys(uniforms).forEach((name2) => { + const uniform = uniforms[name2]; + if (isUniformValue(uniform)) { + result.uniforms[name2] = uniform; + } else { + result.bindings[name2] = uniform; + } + }); + return result; +} + +// node_modules/@luma.gl/core/dist/utils/check-props.js +function checkProps(className, props, propChecks) { + const { removedProps = {}, deprecatedProps = {}, replacedProps = {} } = propChecks; + for (const propName in removedProps) { + if (propName in props) { + const replacementProp = removedProps[propName]; + const replacement = replacementProp ? `${className}.${removedProps[propName]}` : "N/A"; + log2.removed(`${className}.${propName}`, replacement)(); + } + } + for (const propName in deprecatedProps) { + if (propName in props) { + const replacementProp = deprecatedProps[propName]; + log2.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)(); + } + } + let newProps = null; + for (const [propName, replacementProp] of Object.entries(replacedProps)) { + if (propName in props) { + log2.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)(); + newProps = newProps || Object.assign({}, props); + newProps[replacementProp] = props[propName]; + delete newProps[propName]; + } + } + return newProps || props; +} + +// node_modules/@luma.gl/core/dist/utils/load-file.js +var pathPrefix2 = ""; +async function loadImage(url, opts) { + return await new Promise((resolve2, reject) => { + try { + const image = new Image(); + image.onload = () => resolve2(image); + image.onerror = () => reject(new Error(`Could not load image ${url}.`)); + image.crossOrigin = opts?.crossOrigin || "anonymous"; + image.src = url.startsWith("http") ? url : pathPrefix2 + url; + } catch (error) { + reject(error); + } + }); +} +async function loadScript(scriptUrl, scriptId) { + const head = document.getElementsByTagName("head")[0]; + if (!head) { + throw new Error("loadScript"); + } + const script = document.createElement("script"); + script.setAttribute("type", "text/javascript"); + script.setAttribute("src", scriptUrl); + if (scriptId) { + script.id = scriptId; + } + return new Promise((resolve2, reject) => { + script.onload = resolve2; + script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`)); + head.appendChild(script); + }); +} + +// node_modules/@luma.gl/core/dist/utils/deep-equal.js +function deepEqual(a, b, depth) { + if (a === b) { + return true; + } + if (!depth || !a || !b) { + return false; + } + if (Array.isArray(a)) { + if (!Array.isArray(b) || a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (!deepEqual(a[i], b[i], depth - 1)) { + return false; + } + } + return true; + } + if (Array.isArray(b)) { + return false; + } + if (typeof a === "object" && typeof b === "object") { + const aKeys = Object.keys(a); + const bKeys = Object.keys(b); + if (aKeys.length !== bKeys.length) { + return false; + } + for (const key of aKeys) { + if (!b.hasOwnProperty(key)) { + return false; + } + if (!deepEqual(a[key], b[key], depth - 1)) { + return false; + } + } + return true; + } + return false; +} + +// node_modules/@luma.gl/core/dist/utils/request-animation-frame.js +function requestAnimationFrame2(callback) { + return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60); +} +function cancelAnimationFrame2(timerId) { + return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId); +} + +// node_modules/wgsl_reflect/wgsl_reflect.module.js +var ParseContext = class { + constructor() { + this.constants = /* @__PURE__ */ new Map(); + this.aliases = /* @__PURE__ */ new Map(); + this.structs = /* @__PURE__ */ new Map(); + } +}; +var Node = class { + constructor() { + } + get isAstNode() { + return true; + } + get astNodeType() { + return ""; + } + evaluate(context) { + throw new Error("Cannot evaluate node"); + } + evaluateString(context) { + return this.evaluate(context).toString(); + } + search(callback) { + } + searchBlock(block, callback) { + if (block) { + callback(_BlockStart.instance); + for (const node of block) { + if (node instanceof Array) { + this.searchBlock(node, callback); + } else { + node.search(callback); + } + } + callback(_BlockEnd.instance); + } + } +}; +var _BlockStart = class extends Node { +}; +_BlockStart.instance = new _BlockStart(); +var _BlockEnd = class extends Node { +}; +_BlockEnd.instance = new _BlockEnd(); +var Statement = class extends Node { + constructor() { + super(); + } +}; +var Function = class extends Statement { + constructor(name2, args, returnType, body, startLine, endLine) { + super(); + this.calls = /* @__PURE__ */ new Set(); + this.name = name2; + this.args = args; + this.returnType = returnType; + this.body = body; + this.startLine = startLine; + this.endLine = endLine; + } + get astNodeType() { + return "function"; + } + search(callback) { + this.searchBlock(this.body, callback); + } +}; +var StaticAssert = class extends Statement { + constructor(expression) { + super(); + this.expression = expression; + } + get astNodeType() { + return "staticAssert"; + } + search(callback) { + this.expression.search(callback); + } +}; +var While = class extends Statement { + constructor(condition, body) { + super(); + this.condition = condition; + this.body = body; + } + get astNodeType() { + return "while"; + } + search(callback) { + this.condition.search(callback); + this.searchBlock(this.body, callback); + } +}; +var Continuing = class extends Statement { + constructor(body) { + super(); + this.body = body; + } + get astNodeType() { + return "continuing"; + } + search(callback) { + this.searchBlock(this.body, callback); + } +}; +var For = class extends Statement { + constructor(init, condition, increment, body) { + super(); + this.init = init; + this.condition = condition; + this.increment = increment; + this.body = body; + } + get astNodeType() { + return "for"; + } + search(callback) { + var _a2, _b, _c; + (_a2 = this.init) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + (_b = this.condition) === null || _b === void 0 ? void 0 : _b.search(callback); + (_c = this.increment) === null || _c === void 0 ? void 0 : _c.search(callback); + this.searchBlock(this.body, callback); + } +}; +var Var = class extends Statement { + constructor(name2, type, storage, access, value) { + super(); + this.name = name2; + this.type = type; + this.storage = storage; + this.access = access; + this.value = value; + } + get astNodeType() { + return "var"; + } + search(callback) { + var _a2; + callback(this); + (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + } +}; +var Override = class extends Statement { + constructor(name2, type, value) { + super(); + this.name = name2; + this.type = type; + this.value = value; + } + get astNodeType() { + return "override"; + } + search(callback) { + var _a2; + (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + } +}; +var Let = class extends Statement { + constructor(name2, type, storage, access, value) { + super(); + this.name = name2; + this.type = type; + this.storage = storage; + this.access = access; + this.value = value; + } + get astNodeType() { + return "let"; + } + search(callback) { + var _a2; + callback(this); + (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + } +}; +var Const = class extends Statement { + constructor(name2, type, storage, access, value) { + super(); + this.name = name2; + this.type = type; + this.storage = storage; + this.access = access; + this.value = value; + } + get astNodeType() { + return "const"; + } + evaluate(context) { + return this.value.evaluate(context); + } + search(callback) { + var _a2; + callback(this); + (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + } +}; +var IncrementOperator; +(function(IncrementOperator2) { + IncrementOperator2["increment"] = "++"; + IncrementOperator2["decrement"] = "--"; +})(IncrementOperator || (IncrementOperator = {})); +(function(IncrementOperator2) { + function parse2(val) { + const key = val; + if (key == "parse") + throw new Error("Invalid value for IncrementOperator"); + return IncrementOperator2[key]; + } + IncrementOperator2.parse = parse2; +})(IncrementOperator || (IncrementOperator = {})); +var Increment = class extends Statement { + constructor(operator, variable) { + super(); + this.operator = operator; + this.variable = variable; + } + get astNodeType() { + return "increment"; + } + search(callback) { + this.variable.search(callback); + } +}; +var AssignOperator; +(function(AssignOperator2) { + AssignOperator2["assign"] = "="; + AssignOperator2["addAssign"] = "+="; + AssignOperator2["subtractAssin"] = "-="; + AssignOperator2["multiplyAssign"] = "*="; + AssignOperator2["divideAssign"] = "/="; + AssignOperator2["moduloAssign"] = "%="; + AssignOperator2["andAssign"] = "&="; + AssignOperator2["orAssign"] = "|="; + AssignOperator2["xorAssign"] = "^="; + AssignOperator2["shiftLeftAssign"] = "<<="; + AssignOperator2["shiftRightAssign"] = ">>="; +})(AssignOperator || (AssignOperator = {})); +(function(AssignOperator2) { + function parse2(val) { + const key = val; + if (key == "parse") { + throw new Error("Invalid value for AssignOperator"); + } + return key; + } + AssignOperator2.parse = parse2; +})(AssignOperator || (AssignOperator = {})); +var Assign = class extends Statement { + constructor(operator, variable, value) { + super(); + this.operator = operator; + this.variable = variable; + this.value = value; + } + get astNodeType() { + return "assign"; + } + search(callback) { + this.variable.search(callback); + this.value.search(callback); + } +}; +var Call = class extends Statement { + constructor(name2, args) { + super(); + this.name = name2; + this.args = args; + } + get astNodeType() { + return "call"; + } + search(callback) { + for (const node of this.args) { + node.search(callback); + } + callback(this); + } +}; +var Loop = class extends Statement { + constructor(body, continuing) { + super(); + this.body = body; + this.continuing = continuing; + } + get astNodeType() { + return "loop"; + } +}; +var Switch = class extends Statement { + constructor(condition, body) { + super(); + this.condition = condition; + this.body = body; + } + get astNodeType() { + return "body"; + } +}; +var If = class extends Statement { + constructor(condition, body, elseif, _else) { + super(); + this.condition = condition; + this.body = body; + this.elseif = elseif; + this.else = _else; + } + get astNodeType() { + return "if"; + } + search(callback) { + this.condition.search(callback); + this.searchBlock(this.body, callback); + this.searchBlock(this.elseif, callback); + this.searchBlock(this.else, callback); + } +}; +var Return = class extends Statement { + constructor(value) { + super(); + this.value = value; + } + get astNodeType() { + return "return"; + } + search(callback) { + var _a2; + (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); + } +}; +var Enable = class extends Statement { + constructor(name2) { + super(); + this.name = name2; + } + get astNodeType() { + return "enable"; + } +}; +var Requires = class extends Statement { + constructor(extensions) { + super(); + this.extensions = extensions; + } + get astNodeType() { + return "requires"; + } +}; +var Diagnostic = class extends Statement { + constructor(severity, rule) { + super(); + this.severity = severity; + this.rule = rule; + } + get astNodeType() { + return "diagnostic"; + } +}; +var Alias = class extends Statement { + constructor(name2, type) { + super(); + this.name = name2; + this.type = type; + } + get astNodeType() { + return "alias"; + } +}; +var Discard = class extends Statement { + constructor() { + super(); + } + get astNodeType() { + return "discard"; + } +}; +var Break = class extends Statement { + constructor() { + super(); + } + get astNodeType() { + return "break"; + } +}; +var Continue = class extends Statement { + constructor() { + super(); + } + get astNodeType() { + return "continue"; + } +}; +var Type = class extends Statement { + constructor(name2) { + super(); + this.name = name2; + } + get astNodeType() { + return "type"; + } + get isStruct() { + return false; + } + get isArray() { + return false; + } +}; +var Struct = class extends Type { + constructor(name2, members, startLine, endLine) { + super(name2); + this.members = members; + this.startLine = startLine; + this.endLine = endLine; + } + get astNodeType() { + return "struct"; + } + get isStruct() { + return true; + } + /// Return the index of the member with the given name, or -1 if not found. + getMemberIndex(name2) { + for (let i = 0; i < this.members.length; i++) { + if (this.members[i].name == name2) + return i; + } + return -1; + } +}; +var TemplateType = class extends Type { + constructor(name2, format, access) { + super(name2); + this.format = format; + this.access = access; + } + get astNodeType() { + return "template"; + } +}; +var PointerType = class extends Type { + constructor(name2, storage, type, access) { + super(name2); + this.storage = storage; + this.type = type; + this.access = access; + } + get astNodeType() { + return "pointer"; + } +}; +var ArrayType = class extends Type { + constructor(name2, attributes, format, count2) { + super(name2); + this.attributes = attributes; + this.format = format; + this.count = count2; + } + get astNodeType() { + return "array"; + } + get isArray() { + return true; + } +}; +var SamplerType = class extends Type { + constructor(name2, format, access) { + super(name2); + this.format = format; + this.access = access; + } + get astNodeType() { + return "sampler"; + } +}; +var Expression = class extends Node { + constructor() { + super(); + } +}; +var StringExpr = class extends Expression { + constructor(value) { + super(); + this.value = value; + } + get astNodeType() { + return "stringExpr"; + } + toString() { + return this.value; + } + evaluateString() { + return this.value; + } +}; +var CreateExpr = class extends Expression { + constructor(type, args) { + super(); + this.type = type; + this.args = args; + } + get astNodeType() { + return "createExpr"; + } + search(callback) { + callback(this); + if (this.args) { + for (const node of this.args) { + node.search(callback); + } + } + } + evaluate(context) { + return this.args[0].evaluate(context); + } +}; +var CallExpr = class extends Expression { + constructor(name2, args) { + super(); + this.name = name2; + this.args = args; + } + get astNodeType() { + return "callExpr"; + } + evaluate(context) { + switch (this.name) { + case "abs": + return Math.abs(this.args[0].evaluate(context)); + case "acos": + return Math.acos(this.args[0].evaluate(context)); + case "acosh": + return Math.acosh(this.args[0].evaluate(context)); + case "asin": + return Math.asin(this.args[0].evaluate(context)); + case "asinh": + return Math.asinh(this.args[0].evaluate(context)); + case "atan": + return Math.atan(this.args[0].evaluate(context)); + case "atan2": + return Math.atan2(this.args[0].evaluate(context), this.args[1].evaluate(context)); + case "atanh": + return Math.atanh(this.args[0].evaluate(context)); + case "ceil": + return Math.ceil(this.args[0].evaluate(context)); + case "clamp": + return Math.min(Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context)), this.args[2].evaluate(context)); + case "cos": + return Math.cos(this.args[0].evaluate(context)); + case "degrees": + return this.args[0].evaluate(context) * 180 / Math.PI; + case "distance": + return Math.sqrt(Math.pow(this.args[0].evaluate(context) - this.args[1].evaluate(context), 2)); + case "dot": + case "exp": + return Math.exp(this.args[0].evaluate(context)); + case "exp2": + return Math.pow(2, this.args[0].evaluate(context)); + case "floor": + return Math.floor(this.args[0].evaluate(context)); + case "fma": + return this.args[0].evaluate(context) * this.args[1].evaluate(context) + this.args[2].evaluate(context); + case "fract": + return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context)); + case "inverseSqrt": + return 1 / Math.sqrt(this.args[0].evaluate(context)); + case "log": + return Math.log(this.args[0].evaluate(context)); + case "log2": + return Math.log2(this.args[0].evaluate(context)); + case "max": + return Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context)); + case "min": + return Math.min(this.args[0].evaluate(context), this.args[1].evaluate(context)); + case "mix": + return this.args[0].evaluate(context) * (1 - this.args[2].evaluate(context)) + this.args[1].evaluate(context) * this.args[2].evaluate(context); + case "modf": + return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context)); + case "pow": + return Math.pow(this.args[0].evaluate(context), this.args[1].evaluate(context)); + case "radians": + return this.args[0].evaluate(context) * Math.PI / 180; + case "round": + return Math.round(this.args[0].evaluate(context)); + case "sign": + return Math.sign(this.args[0].evaluate(context)); + case "sin": + return Math.sin(this.args[0].evaluate(context)); + case "sinh": + return Math.sinh(this.args[0].evaluate(context)); + case "saturate": + return Math.min(Math.max(this.args[0].evaluate(context), 0), 1); + case "smoothstep": + return this.args[0].evaluate(context) * this.args[0].evaluate(context) * (3 - 2 * this.args[0].evaluate(context)); + case "sqrt": + return Math.sqrt(this.args[0].evaluate(context)); + case "step": + return this.args[0].evaluate(context) < this.args[1].evaluate(context) ? 0 : 1; + case "tan": + return Math.tan(this.args[0].evaluate(context)); + case "tanh": + return Math.tanh(this.args[0].evaluate(context)); + case "trunc": + return Math.trunc(this.args[0].evaluate(context)); + default: + throw new Error("Non const function: " + this.name); + } + } + search(callback) { + for (const node of this.args) { + node.search(callback); + } + callback(this); + } +}; +var VariableExpr = class extends Expression { + constructor(name2) { + super(); + this.name = name2; + } + get astNodeType() { + return "varExpr"; + } + search(callback) { + callback(this); + if (this.postfix) { + this.postfix.search(callback); + } + } + evaluate(context) { + const constant = context.constants.get(this.name); + if (!constant) { + throw new Error("Cannot evaluate node"); + } + return constant.evaluate(context); + } +}; +var ConstExpr = class extends Expression { + constructor(name2, initializer) { + super(); + this.name = name2; + this.initializer = initializer; + } + get astNodeType() { + return "constExpr"; + } + evaluate(context) { + var _a2, _b; + if (this.initializer instanceof CreateExpr) { + const property = (_a2 = this.postfix) === null || _a2 === void 0 ? void 0 : _a2.evaluateString(context); + const type = (_b = this.initializer.type) === null || _b === void 0 ? void 0 : _b.name; + const struct = context.structs.get(type); + const memberIndex = struct === null || struct === void 0 ? void 0 : struct.getMemberIndex(property); + if (memberIndex !== void 0 && memberIndex != -1) { + const value = this.initializer.args[memberIndex].evaluate(context); + return value; + } else { + return this.initializer.evaluate(context); + } + } + return this.initializer.evaluate(context); + } + search(callback) { + this.initializer.search(callback); + } +}; +var LiteralExpr = class extends Expression { + constructor(value) { + super(); + this.value = value; + } + get astNodeType() { + return "literalExpr"; + } + evaluate() { + return this.value; + } +}; +var BitcastExpr = class extends Expression { + constructor(type, value) { + super(); + this.type = type; + this.value = value; + } + get astNodeType() { + return "bitcastExpr"; + } + search(callback) { + this.value.search(callback); + } +}; +var GroupingExpr = class extends Expression { + constructor(contents) { + super(); + this.contents = contents; + } + get astNodeType() { + return "groupExpr"; + } + evaluate(context) { + return this.contents[0].evaluate(context); + } + search(callback) { + this.searchBlock(this.contents, callback); + } +}; +var ArrayIndex = class extends Expression { + constructor(index2) { + super(); + this.index = index2; + } + search(callback) { + this.index.search(callback); + } +}; +var Operator = class extends Expression { + constructor() { + super(); + } +}; +var UnaryOperator = class extends Operator { + constructor(operator, right) { + super(); + this.operator = operator; + this.right = right; + } + get astNodeType() { + return "unaryOp"; + } + evaluate(context) { + switch (this.operator) { + case "+": + return this.right.evaluate(context); + case "-": + return -this.right.evaluate(context); + case "!": + return this.right.evaluate(context) ? 0 : 1; + case "~": + return ~this.right.evaluate(context); + default: + throw new Error("Unknown unary operator: " + this.operator); + } + } + search(callback) { + this.right.search(callback); + } +}; +var BinaryOperator = class extends Operator { + constructor(operator, left, right) { + super(); + this.operator = operator; + this.left = left; + this.right = right; + } + get astNodeType() { + return "binaryOp"; + } + evaluate(context) { + switch (this.operator) { + case "+": + return this.left.evaluate(context) + this.right.evaluate(context); + case "-": + return this.left.evaluate(context) - this.right.evaluate(context); + case "*": + return this.left.evaluate(context) * this.right.evaluate(context); + case "/": + return this.left.evaluate(context) / this.right.evaluate(context); + case "%": + return this.left.evaluate(context) % this.right.evaluate(context); + case "==": + return this.left.evaluate(context) == this.right.evaluate(context) ? 1 : 0; + case "!=": + return this.left.evaluate(context) != this.right.evaluate(context) ? 1 : 0; + case "<": + return this.left.evaluate(context) < this.right.evaluate(context) ? 1 : 0; + case ">": + return this.left.evaluate(context) > this.right.evaluate(context) ? 1 : 0; + case "<=": + return this.left.evaluate(context) <= this.right.evaluate(context) ? 1 : 0; + case ">=": + return this.left.evaluate(context) >= this.right.evaluate(context) ? 1 : 0; + case "&&": + return this.left.evaluate(context) && this.right.evaluate(context) ? 1 : 0; + case "||": + return this.left.evaluate(context) || this.right.evaluate(context) ? 1 : 0; + default: + throw new Error(`Unknown operator ${this.operator}`); + } + } + search(callback) { + this.left.search(callback); + this.right.search(callback); + } +}; +var SwitchCase = class extends Node { + constructor() { + super(); + } +}; +var Case = class extends SwitchCase { + constructor(selector, body) { + super(); + this.selector = selector; + this.body = body; + } + get astNodeType() { + return "case"; + } + search(callback) { + this.searchBlock(this.body, callback); + } +}; +var Default = class extends SwitchCase { + constructor(body) { + super(); + this.body = body; + } + get astNodeType() { + return "default"; + } + search(callback) { + this.searchBlock(this.body, callback); + } +}; +var Argument = class extends Node { + constructor(name2, type, attributes) { + super(); + this.name = name2; + this.type = type; + this.attributes = attributes; + } + get astNodeType() { + return "argument"; + } +}; +var ElseIf = class extends Node { + constructor(condition, body) { + super(); + this.condition = condition; + this.body = body; + } + get astNodeType() { + return "elseif"; + } + search(callback) { + this.condition.search(callback); + this.searchBlock(this.body, callback); + } +}; +var Member = class extends Node { + constructor(name2, type, attributes) { + super(); + this.name = name2; + this.type = type; + this.attributes = attributes; + } + get astNodeType() { + return "member"; + } +}; +var Attribute = class extends Node { + constructor(name2, value) { + super(); + this.name = name2; + this.value = value; + } + get astNodeType() { + return "attribute"; + } +}; +var _a; +var TokenClass; +(function(TokenClass2) { + TokenClass2[TokenClass2["token"] = 0] = "token"; + TokenClass2[TokenClass2["keyword"] = 1] = "keyword"; + TokenClass2[TokenClass2["reserved"] = 2] = "reserved"; +})(TokenClass || (TokenClass = {})); +var TokenType = class { + constructor(name2, type, rule) { + this.name = name2; + this.type = type; + this.rule = rule; + } + toString() { + return this.name; + } +}; +var TokenTypes = class { +}; +_a = TokenTypes; +TokenTypes.none = new TokenType("", TokenClass.reserved, ""); +TokenTypes.eof = new TokenType("EOF", TokenClass.token, ""); +TokenTypes.reserved = { + asm: new TokenType("asm", TokenClass.reserved, "asm"), + bf16: new TokenType("bf16", TokenClass.reserved, "bf16"), + do: new TokenType("do", TokenClass.reserved, "do"), + enum: new TokenType("enum", TokenClass.reserved, "enum"), + f16: new TokenType("f16", TokenClass.reserved, "f16"), + f64: new TokenType("f64", TokenClass.reserved, "f64"), + handle: new TokenType("handle", TokenClass.reserved, "handle"), + i8: new TokenType("i8", TokenClass.reserved, "i8"), + i16: new TokenType("i16", TokenClass.reserved, "i16"), + i64: new TokenType("i64", TokenClass.reserved, "i64"), + mat: new TokenType("mat", TokenClass.reserved, "mat"), + premerge: new TokenType("premerge", TokenClass.reserved, "premerge"), + regardless: new TokenType("regardless", TokenClass.reserved, "regardless"), + typedef: new TokenType("typedef", TokenClass.reserved, "typedef"), + u8: new TokenType("u8", TokenClass.reserved, "u8"), + u16: new TokenType("u16", TokenClass.reserved, "u16"), + u64: new TokenType("u64", TokenClass.reserved, "u64"), + unless: new TokenType("unless", TokenClass.reserved, "unless"), + using: new TokenType("using", TokenClass.reserved, "using"), + vec: new TokenType("vec", TokenClass.reserved, "vec"), + void: new TokenType("void", TokenClass.reserved, "void") +}; +TokenTypes.keywords = { + array: new TokenType("array", TokenClass.keyword, "array"), + atomic: new TokenType("atomic", TokenClass.keyword, "atomic"), + bool: new TokenType("bool", TokenClass.keyword, "bool"), + f32: new TokenType("f32", TokenClass.keyword, "f32"), + i32: new TokenType("i32", TokenClass.keyword, "i32"), + mat2x2: new TokenType("mat2x2", TokenClass.keyword, "mat2x2"), + mat2x3: new TokenType("mat2x3", TokenClass.keyword, "mat2x3"), + mat2x4: new TokenType("mat2x4", TokenClass.keyword, "mat2x4"), + mat3x2: new TokenType("mat3x2", TokenClass.keyword, "mat3x2"), + mat3x3: new TokenType("mat3x3", TokenClass.keyword, "mat3x3"), + mat3x4: new TokenType("mat3x4", TokenClass.keyword, "mat3x4"), + mat4x2: new TokenType("mat4x2", TokenClass.keyword, "mat4x2"), + mat4x3: new TokenType("mat4x3", TokenClass.keyword, "mat4x3"), + mat4x4: new TokenType("mat4x4", TokenClass.keyword, "mat4x4"), + ptr: new TokenType("ptr", TokenClass.keyword, "ptr"), + sampler: new TokenType("sampler", TokenClass.keyword, "sampler"), + sampler_comparison: new TokenType("sampler_comparison", TokenClass.keyword, "sampler_comparison"), + struct: new TokenType("struct", TokenClass.keyword, "struct"), + texture_1d: new TokenType("texture_1d", TokenClass.keyword, "texture_1d"), + texture_2d: new TokenType("texture_2d", TokenClass.keyword, "texture_2d"), + texture_2d_array: new TokenType("texture_2d_array", TokenClass.keyword, "texture_2d_array"), + texture_3d: new TokenType("texture_3d", TokenClass.keyword, "texture_3d"), + texture_cube: new TokenType("texture_cube", TokenClass.keyword, "texture_cube"), + texture_cube_array: new TokenType("texture_cube_array", TokenClass.keyword, "texture_cube_array"), + texture_multisampled_2d: new TokenType("texture_multisampled_2d", TokenClass.keyword, "texture_multisampled_2d"), + texture_storage_1d: new TokenType("texture_storage_1d", TokenClass.keyword, "texture_storage_1d"), + texture_storage_2d: new TokenType("texture_storage_2d", TokenClass.keyword, "texture_storage_2d"), + texture_storage_2d_array: new TokenType("texture_storage_2d_array", TokenClass.keyword, "texture_storage_2d_array"), + texture_storage_3d: new TokenType("texture_storage_3d", TokenClass.keyword, "texture_storage_3d"), + texture_depth_2d: new TokenType("texture_depth_2d", TokenClass.keyword, "texture_depth_2d"), + texture_depth_2d_array: new TokenType("texture_depth_2d_array", TokenClass.keyword, "texture_depth_2d_array"), + texture_depth_cube: new TokenType("texture_depth_cube", TokenClass.keyword, "texture_depth_cube"), + texture_depth_cube_array: new TokenType("texture_depth_cube_array", TokenClass.keyword, "texture_depth_cube_array"), + texture_depth_multisampled_2d: new TokenType("texture_depth_multisampled_2d", TokenClass.keyword, "texture_depth_multisampled_2d"), + texture_external: new TokenType("texture_external", TokenClass.keyword, "texture_external"), + u32: new TokenType("u32", TokenClass.keyword, "u32"), + vec2: new TokenType("vec2", TokenClass.keyword, "vec2"), + vec3: new TokenType("vec3", TokenClass.keyword, "vec3"), + vec4: new TokenType("vec4", TokenClass.keyword, "vec4"), + bitcast: new TokenType("bitcast", TokenClass.keyword, "bitcast"), + block: new TokenType("block", TokenClass.keyword, "block"), + break: new TokenType("break", TokenClass.keyword, "break"), + case: new TokenType("case", TokenClass.keyword, "case"), + continue: new TokenType("continue", TokenClass.keyword, "continue"), + continuing: new TokenType("continuing", TokenClass.keyword, "continuing"), + default: new TokenType("default", TokenClass.keyword, "default"), + diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"), + discard: new TokenType("discard", TokenClass.keyword, "discard"), + else: new TokenType("else", TokenClass.keyword, "else"), + enable: new TokenType("enable", TokenClass.keyword, "enable"), + fallthrough: new TokenType("fallthrough", TokenClass.keyword, "fallthrough"), + false: new TokenType("false", TokenClass.keyword, "false"), + fn: new TokenType("fn", TokenClass.keyword, "fn"), + for: new TokenType("for", TokenClass.keyword, "for"), + function: new TokenType("function", TokenClass.keyword, "function"), + if: new TokenType("if", TokenClass.keyword, "if"), + let: new TokenType("let", TokenClass.keyword, "let"), + const: new TokenType("const", TokenClass.keyword, "const"), + loop: new TokenType("loop", TokenClass.keyword, "loop"), + while: new TokenType("while", TokenClass.keyword, "while"), + private: new TokenType("private", TokenClass.keyword, "private"), + read: new TokenType("read", TokenClass.keyword, "read"), + read_write: new TokenType("read_write", TokenClass.keyword, "read_write"), + return: new TokenType("return", TokenClass.keyword, "return"), + requires: new TokenType("requires", TokenClass.keyword, "requires"), + storage: new TokenType("storage", TokenClass.keyword, "storage"), + switch: new TokenType("switch", TokenClass.keyword, "switch"), + true: new TokenType("true", TokenClass.keyword, "true"), + alias: new TokenType("alias", TokenClass.keyword, "alias"), + type: new TokenType("type", TokenClass.keyword, "type"), + uniform: new TokenType("uniform", TokenClass.keyword, "uniform"), + var: new TokenType("var", TokenClass.keyword, "var"), + override: new TokenType("override", TokenClass.keyword, "override"), + workgroup: new TokenType("workgroup", TokenClass.keyword, "workgroup"), + write: new TokenType("write", TokenClass.keyword, "write"), + r8unorm: new TokenType("r8unorm", TokenClass.keyword, "r8unorm"), + r8snorm: new TokenType("r8snorm", TokenClass.keyword, "r8snorm"), + r8uint: new TokenType("r8uint", TokenClass.keyword, "r8uint"), + r8sint: new TokenType("r8sint", TokenClass.keyword, "r8sint"), + r16uint: new TokenType("r16uint", TokenClass.keyword, "r16uint"), + r16sint: new TokenType("r16sint", TokenClass.keyword, "r16sint"), + r16float: new TokenType("r16float", TokenClass.keyword, "r16float"), + rg8unorm: new TokenType("rg8unorm", TokenClass.keyword, "rg8unorm"), + rg8snorm: new TokenType("rg8snorm", TokenClass.keyword, "rg8snorm"), + rg8uint: new TokenType("rg8uint", TokenClass.keyword, "rg8uint"), + rg8sint: new TokenType("rg8sint", TokenClass.keyword, "rg8sint"), + r32uint: new TokenType("r32uint", TokenClass.keyword, "r32uint"), + r32sint: new TokenType("r32sint", TokenClass.keyword, "r32sint"), + r32float: new TokenType("r32float", TokenClass.keyword, "r32float"), + rg16uint: new TokenType("rg16uint", TokenClass.keyword, "rg16uint"), + rg16sint: new TokenType("rg16sint", TokenClass.keyword, "rg16sint"), + rg16float: new TokenType("rg16float", TokenClass.keyword, "rg16float"), + rgba8unorm: new TokenType("rgba8unorm", TokenClass.keyword, "rgba8unorm"), + rgba8unorm_srgb: new TokenType("rgba8unorm_srgb", TokenClass.keyword, "rgba8unorm_srgb"), + rgba8snorm: new TokenType("rgba8snorm", TokenClass.keyword, "rgba8snorm"), + rgba8uint: new TokenType("rgba8uint", TokenClass.keyword, "rgba8uint"), + rgba8sint: new TokenType("rgba8sint", TokenClass.keyword, "rgba8sint"), + bgra8unorm: new TokenType("bgra8unorm", TokenClass.keyword, "bgra8unorm"), + bgra8unorm_srgb: new TokenType("bgra8unorm_srgb", TokenClass.keyword, "bgra8unorm_srgb"), + rgb10a2unorm: new TokenType("rgb10a2unorm", TokenClass.keyword, "rgb10a2unorm"), + rg11b10float: new TokenType("rg11b10float", TokenClass.keyword, "rg11b10float"), + rg32uint: new TokenType("rg32uint", TokenClass.keyword, "rg32uint"), + rg32sint: new TokenType("rg32sint", TokenClass.keyword, "rg32sint"), + rg32float: new TokenType("rg32float", TokenClass.keyword, "rg32float"), + rgba16uint: new TokenType("rgba16uint", TokenClass.keyword, "rgba16uint"), + rgba16sint: new TokenType("rgba16sint", TokenClass.keyword, "rgba16sint"), + rgba16float: new TokenType("rgba16float", TokenClass.keyword, "rgba16float"), + rgba32uint: new TokenType("rgba32uint", TokenClass.keyword, "rgba32uint"), + rgba32sint: new TokenType("rgba32sint", TokenClass.keyword, "rgba32sint"), + rgba32float: new TokenType("rgba32float", TokenClass.keyword, "rgba32float"), + static_assert: new TokenType("static_assert", TokenClass.keyword, "static_assert") + // WGSL grammar has a few keywords that have different token names than the strings they + // represent. Aliasing them here. + /*int32: new TokenType("i32", TokenClass.keyword, "i32"), + uint32: new TokenType("u32", TokenClass.keyword, "u32"), + float32: new TokenType("f32", TokenClass.keyword, "f32"), + pointer: new TokenType("ptr", TokenClass.keyword, "ptr"),*/ +}; +TokenTypes.tokens = { + decimal_float_literal: new TokenType("decimal_float_literal", TokenClass.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/), + hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/), + int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/), + uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/), + ident: new TokenType("ident", TokenClass.token, /[_a-zA-Z][0-9a-zA-Z_]*/), + and: new TokenType("and", TokenClass.token, "&"), + and_and: new TokenType("and_and", TokenClass.token, "&&"), + arrow: new TokenType("arrow ", TokenClass.token, "->"), + attr: new TokenType("attr", TokenClass.token, "@"), + forward_slash: new TokenType("forward_slash", TokenClass.token, "/"), + bang: new TokenType("bang", TokenClass.token, "!"), + bracket_left: new TokenType("bracket_left", TokenClass.token, "["), + bracket_right: new TokenType("bracket_right", TokenClass.token, "]"), + brace_left: new TokenType("brace_left", TokenClass.token, "{"), + brace_right: new TokenType("brace_right", TokenClass.token, "}"), + colon: new TokenType("colon", TokenClass.token, ":"), + comma: new TokenType("comma", TokenClass.token, ","), + equal: new TokenType("equal", TokenClass.token, "="), + equal_equal: new TokenType("equal_equal", TokenClass.token, "=="), + not_equal: new TokenType("not_equal", TokenClass.token, "!="), + greater_than: new TokenType("greater_than", TokenClass.token, ">"), + greater_than_equal: new TokenType("greater_than_equal", TokenClass.token, ">="), + shift_right: new TokenType("shift_right", TokenClass.token, ">>"), + less_than: new TokenType("less_than", TokenClass.token, "<"), + less_than_equal: new TokenType("less_than_equal", TokenClass.token, "<="), + shift_left: new TokenType("shift_left", TokenClass.token, "<<"), + modulo: new TokenType("modulo", TokenClass.token, "%"), + minus: new TokenType("minus", TokenClass.token, "-"), + minus_minus: new TokenType("minus_minus", TokenClass.token, "--"), + period: new TokenType("period", TokenClass.token, "."), + plus: new TokenType("plus", TokenClass.token, "+"), + plus_plus: new TokenType("plus_plus", TokenClass.token, "++"), + or: new TokenType("or", TokenClass.token, "|"), + or_or: new TokenType("or_or", TokenClass.token, "||"), + paren_left: new TokenType("paren_left", TokenClass.token, "("), + paren_right: new TokenType("paren_right", TokenClass.token, ")"), + semicolon: new TokenType("semicolon", TokenClass.token, ";"), + star: new TokenType("star", TokenClass.token, "*"), + tilde: new TokenType("tilde", TokenClass.token, "~"), + underscore: new TokenType("underscore", TokenClass.token, "_"), + xor: new TokenType("xor", TokenClass.token, "^"), + plus_equal: new TokenType("plus_equal", TokenClass.token, "+="), + minus_equal: new TokenType("minus_equal", TokenClass.token, "-="), + times_equal: new TokenType("times_equal", TokenClass.token, "*="), + division_equal: new TokenType("division_equal", TokenClass.token, "/="), + modulo_equal: new TokenType("modulo_equal", TokenClass.token, "%="), + and_equal: new TokenType("and_equal", TokenClass.token, "&="), + or_equal: new TokenType("or_equal", TokenClass.token, "|="), + xor_equal: new TokenType("xor_equal", TokenClass.token, "^="), + shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="), + shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=") +}; +TokenTypes.simpleTokens = { + "@": _a.tokens.attr, + "{": _a.tokens.brace_left, + "}": _a.tokens.brace_right, + ":": _a.tokens.colon, + ",": _a.tokens.comma, + "(": _a.tokens.paren_left, + ")": _a.tokens.paren_right, + ";": _a.tokens.semicolon +}; +TokenTypes.literalTokens = { + "&": _a.tokens.and, + "&&": _a.tokens.and_and, + "->": _a.tokens.arrow, + "/": _a.tokens.forward_slash, + "!": _a.tokens.bang, + "[": _a.tokens.bracket_left, + "]": _a.tokens.bracket_right, + "=": _a.tokens.equal, + "==": _a.tokens.equal_equal, + "!=": _a.tokens.not_equal, + ">": _a.tokens.greater_than, + ">=": _a.tokens.greater_than_equal, + ">>": _a.tokens.shift_right, + "<": _a.tokens.less_than, + "<=": _a.tokens.less_than_equal, + "<<": _a.tokens.shift_left, + "%": _a.tokens.modulo, + "-": _a.tokens.minus, + "--": _a.tokens.minus_minus, + ".": _a.tokens.period, + "+": _a.tokens.plus, + "++": _a.tokens.plus_plus, + "|": _a.tokens.or, + "||": _a.tokens.or_or, + "*": _a.tokens.star, + "~": _a.tokens.tilde, + "_": _a.tokens.underscore, + "^": _a.tokens.xor, + "+=": _a.tokens.plus_equal, + "-=": _a.tokens.minus_equal, + "*=": _a.tokens.times_equal, + "/=": _a.tokens.division_equal, + "%=": _a.tokens.modulo_equal, + "&=": _a.tokens.and_equal, + "|=": _a.tokens.or_equal, + "^=": _a.tokens.xor_equal, + ">>=": _a.tokens.shift_right_equal, + "<<=": _a.tokens.shift_left_equal +}; +TokenTypes.regexTokens = { + decimal_float_literal: _a.tokens.decimal_float_literal, + hex_float_literal: _a.tokens.hex_float_literal, + int_literal: _a.tokens.int_literal, + uint_literal: _a.tokens.uint_literal, + ident: _a.tokens.ident +}; +TokenTypes.storage_class = [ + _a.keywords.function, + _a.keywords.private, + _a.keywords.workgroup, + _a.keywords.uniform, + _a.keywords.storage +]; +TokenTypes.access_mode = [ + _a.keywords.read, + _a.keywords.write, + _a.keywords.read_write +]; +TokenTypes.sampler_type = [ + _a.keywords.sampler, + _a.keywords.sampler_comparison +]; +TokenTypes.sampled_texture_type = [ + _a.keywords.texture_1d, + _a.keywords.texture_2d, + _a.keywords.texture_2d_array, + _a.keywords.texture_3d, + _a.keywords.texture_cube, + _a.keywords.texture_cube_array +]; +TokenTypes.multisampled_texture_type = [ + _a.keywords.texture_multisampled_2d +]; +TokenTypes.storage_texture_type = [ + _a.keywords.texture_storage_1d, + _a.keywords.texture_storage_2d, + _a.keywords.texture_storage_2d_array, + _a.keywords.texture_storage_3d +]; +TokenTypes.depth_texture_type = [ + _a.keywords.texture_depth_2d, + _a.keywords.texture_depth_2d_array, + _a.keywords.texture_depth_cube, + _a.keywords.texture_depth_cube_array, + _a.keywords.texture_depth_multisampled_2d +]; +TokenTypes.texture_external_type = [_a.keywords.texture_external]; +TokenTypes.any_texture_type = [ + ..._a.sampled_texture_type, + ..._a.multisampled_texture_type, + ..._a.storage_texture_type, + ..._a.depth_texture_type, + ..._a.texture_external_type +]; +TokenTypes.texel_format = [ + _a.keywords.r8unorm, + _a.keywords.r8snorm, + _a.keywords.r8uint, + _a.keywords.r8sint, + _a.keywords.r16uint, + _a.keywords.r16sint, + _a.keywords.r16float, + _a.keywords.rg8unorm, + _a.keywords.rg8snorm, + _a.keywords.rg8uint, + _a.keywords.rg8sint, + _a.keywords.r32uint, + _a.keywords.r32sint, + _a.keywords.r32float, + _a.keywords.rg16uint, + _a.keywords.rg16sint, + _a.keywords.rg16float, + _a.keywords.rgba8unorm, + _a.keywords.rgba8unorm_srgb, + _a.keywords.rgba8snorm, + _a.keywords.rgba8uint, + _a.keywords.rgba8sint, + _a.keywords.bgra8unorm, + _a.keywords.bgra8unorm_srgb, + _a.keywords.rgb10a2unorm, + _a.keywords.rg11b10float, + _a.keywords.rg32uint, + _a.keywords.rg32sint, + _a.keywords.rg32float, + _a.keywords.rgba16uint, + _a.keywords.rgba16sint, + _a.keywords.rgba16float, + _a.keywords.rgba32uint, + _a.keywords.rgba32sint, + _a.keywords.rgba32float +]; +TokenTypes.const_literal = [ + _a.tokens.int_literal, + _a.tokens.uint_literal, + _a.tokens.decimal_float_literal, + _a.tokens.hex_float_literal, + _a.keywords.true, + _a.keywords.false +]; +TokenTypes.literal_or_ident = [ + _a.tokens.ident, + _a.tokens.int_literal, + _a.tokens.uint_literal, + _a.tokens.decimal_float_literal, + _a.tokens.hex_float_literal +]; +TokenTypes.element_count_expression = [ + _a.tokens.int_literal, + _a.tokens.uint_literal, + _a.tokens.ident +]; +TokenTypes.template_types = [ + _a.keywords.vec2, + _a.keywords.vec3, + _a.keywords.vec4, + _a.keywords.mat2x2, + _a.keywords.mat2x3, + _a.keywords.mat2x4, + _a.keywords.mat3x2, + _a.keywords.mat3x3, + _a.keywords.mat3x4, + _a.keywords.mat4x2, + _a.keywords.mat4x3, + _a.keywords.mat4x4, + _a.keywords.atomic, + _a.keywords.bitcast, + ..._a.any_texture_type +]; +TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block, _a.keywords.diagnostic]; +TokenTypes.assignment_operators = [ + _a.tokens.equal, + _a.tokens.plus_equal, + _a.tokens.minus_equal, + _a.tokens.times_equal, + _a.tokens.division_equal, + _a.tokens.modulo_equal, + _a.tokens.and_equal, + _a.tokens.or_equal, + _a.tokens.xor_equal, + _a.tokens.shift_right_equal, + _a.tokens.shift_left_equal +]; +TokenTypes.increment_operators = [ + _a.tokens.plus_plus, + _a.tokens.minus_minus +]; +var Token = class { + constructor(type, lexeme, line) { + this.type = type; + this.lexeme = lexeme; + this.line = line; + } + toString() { + return this.lexeme; + } + isTemplateType() { + return TokenTypes.template_types.indexOf(this.type) != -1; + } + isArrayType() { + return this.type == TokenTypes.keywords.array; + } + isArrayOrTemplateType() { + return this.isArrayType() || this.isTemplateType(); + } +}; +var WgslScanner = class { + constructor(source) { + this._tokens = []; + this._start = 0; + this._current = 0; + this._line = 1; + this._source = source !== null && source !== void 0 ? source : ""; + } + /// Scan all tokens from the source. + scanTokens() { + while (!this._isAtEnd()) { + this._start = this._current; + if (!this.scanToken()) { + throw `Invalid syntax at line ${this._line}`; + } + } + this._tokens.push(new Token(TokenTypes.eof, "", this._line)); + return this._tokens; + } + /// Scan a single token from the source. + scanToken() { + let lexeme = this._advance(); + if (lexeme == "\n") { + this._line++; + return true; + } + if (this._isWhitespace(lexeme)) { + return true; + } + if (lexeme == "/") { + if (this._peekAhead() == "/") { + while (lexeme != "\n") { + if (this._isAtEnd()) { + return true; + } + lexeme = this._advance(); + } + this._line++; + return true; + } else if (this._peekAhead() == "*") { + this._advance(); + let commentLevel = 1; + while (commentLevel > 0) { + if (this._isAtEnd()) { + return true; + } + lexeme = this._advance(); + if (lexeme == "\n") { + this._line++; + } else if (lexeme == "*") { + if (this._peekAhead() == "/") { + this._advance(); + commentLevel--; + if (commentLevel == 0) { + return true; + } + } + } else if (lexeme == "/") { + if (this._peekAhead() == "*") { + this._advance(); + commentLevel++; + } + } + } + return true; + } + } + const simpleToken = TokenTypes.simpleTokens[lexeme]; + if (simpleToken) { + this._addToken(simpleToken); + return true; + } + let matchType = TokenTypes.none; + const isAlpha = this._isAlpha(lexeme); + const isUnderscore = lexeme === "_"; + if (this._isAlphaNumeric(lexeme)) { + let nextChar = this._peekAhead(); + while (this._isAlphaNumeric(nextChar)) { + lexeme += this._advance(); + nextChar = this._peekAhead(); + } + } + if (isAlpha) { + const matchedType = TokenTypes.keywords[lexeme]; + if (matchedType) { + this._addToken(matchedType); + return true; + } + } + if (isAlpha || isUnderscore) { + this._addToken(TokenTypes.tokens.ident); + return true; + } + for (; ; ) { + let matchedType = this._findType(lexeme); + const nextLexeme = this._peekAhead(); + if (lexeme == "-" && this._tokens.length > 0) { + if (nextLexeme == "=") { + this._current++; + lexeme += nextLexeme; + this._addToken(TokenTypes.tokens.minus_equal); + return true; + } + if (nextLexeme == "-") { + this._current++; + lexeme += nextLexeme; + this._addToken(TokenTypes.tokens.minus_minus); + return true; + } + const ti = this._tokens.length - 1; + const isIdentOrLiteral = TokenTypes.literal_or_ident.indexOf(this._tokens[ti].type) != -1; + if ((isIdentOrLiteral || this._tokens[ti].type == TokenTypes.tokens.paren_right) && nextLexeme != ">") { + this._addToken(matchedType); + return true; + } + } + if (lexeme == ">" && (nextLexeme == ">" || nextLexeme == "=")) { + let foundLessThan = false; + let ti = this._tokens.length - 1; + for (let count2 = 0; count2 < 5 && ti >= 0; ++count2, --ti) { + if (TokenTypes.assignment_operators.indexOf(this._tokens[ti].type) !== -1) { + break; + } + if (this._tokens[ti].type === TokenTypes.tokens.less_than) { + if (ti > 0 && this._tokens[ti - 1].isArrayOrTemplateType()) { + foundLessThan = true; + } + break; + } + } + if (foundLessThan) { + this._addToken(matchedType); + return true; + } + } + if (matchedType === TokenTypes.none) { + let lookAheadLexeme = lexeme; + let lookAhead = 0; + const maxLookAhead = 2; + for (let li = 0; li < maxLookAhead; ++li) { + lookAheadLexeme += this._peekAhead(li); + matchedType = this._findType(lookAheadLexeme); + if (matchedType !== TokenTypes.none) { + lookAhead = li; + break; + } + } + if (matchedType === TokenTypes.none) { + if (matchType === TokenTypes.none) { + return false; + } + this._current--; + this._addToken(matchType); + return true; + } + lexeme = lookAheadLexeme; + this._current += lookAhead + 1; + } + matchType = matchedType; + if (this._isAtEnd()) { + break; + } + lexeme += this._advance(); + } + if (matchType === TokenTypes.none) { + return false; + } + this._addToken(matchType); + return true; + } + _findType(lexeme) { + for (const name2 in TokenTypes.regexTokens) { + const type2 = TokenTypes.regexTokens[name2]; + if (this._match(lexeme, type2.rule)) { + return type2; + } + } + const type = TokenTypes.literalTokens[lexeme]; + if (type) { + return type; + } + return TokenTypes.none; + } + _match(lexeme, rule) { + const match = rule.exec(lexeme); + return match && match.index == 0 && match[0] == lexeme; + } + _isAtEnd() { + return this._current >= this._source.length; + } + _isAlpha(c) { + return c >= "a" && c <= "z" || c >= "A" && c <= "Z"; + } + _isAlphaNumeric(c) { + return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c == "_" || c >= "0" && c <= "9"; + } + _isWhitespace(c) { + return c == " " || c == " " || c == "\r"; + } + _advance(amount = 0) { + let c = this._source[this._current]; + amount = amount || 0; + amount++; + this._current += amount; + return c; + } + _peekAhead(offset = 0) { + offset = offset || 0; + if (this._current + offset >= this._source.length) { + return "\0"; + } + return this._source[this._current + offset]; + } + _addToken(type) { + const text = this._source.substring(this._start, this._current); + this._tokens.push(new Token(type, text, this._line)); + } +}; +var WgslParser = class { + constructor() { + this._tokens = []; + this._current = 0; + this._currentLine = 0; + this._context = new ParseContext(); + this._deferArrayCountEval = []; + } + parse(tokensOrCode) { + this._initialize(tokensOrCode); + this._deferArrayCountEval.length = 0; + const statements = []; + while (!this._isAtEnd()) { + const statement = this._global_decl_or_directive(); + if (!statement) { + break; + } + statements.push(statement); + } + if (this._deferArrayCountEval.length > 0) { + for (const arrayDecl of this._deferArrayCountEval) { + const arrayType = arrayDecl["arrayType"]; + const countNode = arrayDecl["countNode"]; + if (countNode instanceof VariableExpr) { + const variable = countNode; + const name2 = variable.name; + const constant = this._context.constants.get(name2); + if (constant) { + try { + const count2 = constant.evaluate(this._context); + arrayType.count = count2; + } catch (e) { + } + } + } + } + this._deferArrayCountEval.length = 0; + } + return statements; + } + _initialize(tokensOrCode) { + if (tokensOrCode) { + if (typeof tokensOrCode == "string") { + const scanner = new WgslScanner(tokensOrCode); + this._tokens = scanner.scanTokens(); + } else { + this._tokens = tokensOrCode; + } + } else { + this._tokens = []; + } + this._current = 0; + } + _error(token, message2) { + return { + token, + message: message2, + toString: function() { + return `${message2}`; + } + }; + } + _isAtEnd() { + return this._current >= this._tokens.length || this._peek().type == TokenTypes.eof; + } + _match(types) { + if (types instanceof TokenType) { + if (this._check(types)) { + this._advance(); + return true; + } + return false; + } + for (let i = 0, l = types.length; i < l; ++i) { + const type = types[i]; + if (this._check(type)) { + this._advance(); + return true; + } + } + return false; + } + _consume(types, message2) { + if (this._check(types)) { + return this._advance(); + } + throw this._error(this._peek(), message2); + } + _check(types) { + if (this._isAtEnd()) { + return false; + } + const tk = this._peek(); + if (types instanceof Array) { + const t = tk.type; + const index2 = types.indexOf(t); + return index2 != -1; + } + return tk.type == types; + } + _advance() { + var _a2, _b; + this._currentLine = (_b = (_a2 = this._peek()) === null || _a2 === void 0 ? void 0 : _a2.line) !== null && _b !== void 0 ? _b : -1; + if (!this._isAtEnd()) { + this._current++; + } + return this._previous(); + } + _peek() { + return this._tokens[this._current]; + } + _previous() { + return this._tokens[this._current - 1]; + } + _global_decl_or_directive() { + while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd()) + ; + if (this._match(TokenTypes.keywords.alias)) { + const type = this._type_alias(); + this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); + return type; + } + if (this._match(TokenTypes.keywords.diagnostic)) { + const directive = this._diagnostic(); + this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); + return directive; + } + if (this._match(TokenTypes.keywords.requires)) { + const requires = this._requires_directive(); + this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); + return requires; + } + if (this._match(TokenTypes.keywords.enable)) { + const enable2 = this._enable_directive(); + this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); + return enable2; + } + const attrs = this._attribute(); + if (this._check(TokenTypes.keywords.var)) { + const _var = this._global_variable_decl(); + if (_var != null) { + _var.attributes = attrs; + } + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + return _var; + } + if (this._check(TokenTypes.keywords.override)) { + const _override = this._override_variable_decl(); + if (_override != null) { + _override.attributes = attrs; + } + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + return _override; + } + if (this._check(TokenTypes.keywords.let)) { + const _let = this._global_let_decl(); + if (_let != null) { + _let.attributes = attrs; + } + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + return _let; + } + if (this._check(TokenTypes.keywords.const)) { + const _const = this._global_const_decl(); + if (_const != null) { + _const.attributes = attrs; + } + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + return _const; + } + if (this._check(TokenTypes.keywords.struct)) { + const _struct = this._struct_decl(); + if (_struct != null) { + _struct.attributes = attrs; + } + return _struct; + } + if (this._check(TokenTypes.keywords.fn)) { + const _fn = this._function_decl(); + if (_fn != null) { + _fn.attributes = attrs; + } + return _fn; + } + return null; + } + _function_decl() { + if (!this._match(TokenTypes.keywords.fn)) { + return null; + } + const startLine = this._currentLine; + const name2 = this._consume(TokenTypes.tokens.ident, "Expected function name.").toString(); + this._consume(TokenTypes.tokens.paren_left, "Expected '(' for function arguments."); + const args = []; + if (!this._check(TokenTypes.tokens.paren_right)) { + do { + if (this._check(TokenTypes.tokens.paren_right)) { + break; + } + const argAttrs = this._attribute(); + const name3 = this._consume(TokenTypes.tokens.ident, "Expected argument name.").toString(); + this._consume(TokenTypes.tokens.colon, "Expected ':' for argument type."); + const typeAttrs = this._attribute(); + const type = this._type_decl(); + if (type != null) { + type.attributes = typeAttrs; + args.push(new Argument(name3, type, argAttrs)); + } + } while (this._match(TokenTypes.tokens.comma)); + } + this._consume(TokenTypes.tokens.paren_right, "Expected ')' after function arguments."); + let _return = null; + if (this._match(TokenTypes.tokens.arrow)) { + const attrs = this._attribute(); + _return = this._type_decl(); + if (_return != null) { + _return.attributes = attrs; + } + } + const body = this._compound_statement(); + const endLine = this._currentLine; + return new Function(name2, args, _return, body, startLine, endLine); + } + _compound_statement() { + const statements = []; + this._consume(TokenTypes.tokens.brace_left, "Expected '{' for block."); + while (!this._check(TokenTypes.tokens.brace_right)) { + const statement = this._statement(); + if (statement !== null) { + statements.push(statement); + } + } + this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block."); + return statements; + } + _statement() { + while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd()) + ; + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + if (this._check(TokenTypes.keywords.if)) { + return this._if_statement(); + } + if (this._check(TokenTypes.keywords.switch)) { + return this._switch_statement(); + } + if (this._check(TokenTypes.keywords.loop)) { + return this._loop_statement(); + } + if (this._check(TokenTypes.keywords.for)) { + return this._for_statement(); + } + if (this._check(TokenTypes.keywords.while)) { + return this._while_statement(); + } + if (this._check(TokenTypes.keywords.continuing)) { + return this._continuing_statement(); + } + if (this._check(TokenTypes.keywords.static_assert)) { + return this._static_assert_statement(); + } + if (this._check(TokenTypes.tokens.brace_left)) { + return this._compound_statement(); + } + let result = null; + if (this._check(TokenTypes.keywords.return)) { + result = this._return_statement(); + } else if (this._check([ + TokenTypes.keywords.var, + TokenTypes.keywords.let, + TokenTypes.keywords.const + ])) { + result = this._variable_statement(); + } else if (this._match(TokenTypes.keywords.discard)) { + result = new Discard(); + } else if (this._match(TokenTypes.keywords.break)) { + result = new Break(); + } else if (this._match(TokenTypes.keywords.continue)) { + result = new Continue(); + } else { + result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement(); + } + if (result != null) { + this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement."); + } + return result; + } + _static_assert_statement() { + if (!this._match(TokenTypes.keywords.static_assert)) { + return null; + } + const expression = this._optional_paren_expression(); + return new StaticAssert(expression); + } + _while_statement() { + if (!this._match(TokenTypes.keywords.while)) { + return null; + } + const condition = this._optional_paren_expression(); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + const block = this._compound_statement(); + return new While(condition, block); + } + _continuing_statement() { + if (!this._match(TokenTypes.keywords.continuing)) { + return null; + } + const block = this._compound_statement(); + return new Continuing(block); + } + _for_statement() { + if (!this._match(TokenTypes.keywords.for)) { + return null; + } + this._consume(TokenTypes.tokens.paren_left, "Expected '('."); + const init = !this._check(TokenTypes.tokens.semicolon) ? this._for_init() : null; + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + const condition = !this._check(TokenTypes.tokens.semicolon) ? this._short_circuit_or_expression() : null; + this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); + const increment = !this._check(TokenTypes.tokens.paren_right) ? this._for_increment() : null; + this._consume(TokenTypes.tokens.paren_right, "Expected ')'."); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + const body = this._compound_statement(); + return new For(init, condition, increment, body); + } + _for_init() { + return this._variable_statement() || this._func_call_statement() || this._assignment_statement(); + } + _for_increment() { + return this._func_call_statement() || this._increment_decrement_statement() || this._assignment_statement(); + } + _variable_statement() { + if (this._check(TokenTypes.keywords.var)) { + const _var = this._variable_decl(); + if (_var === null) { + throw this._error(this._peek(), "Variable declaration expected."); + } + let value = null; + if (this._match(TokenTypes.tokens.equal)) { + value = this._short_circuit_or_expression(); + } + return new Var(_var.name, _var.type, _var.storage, _var.access, value); + } + if (this._match(TokenTypes.keywords.let)) { + const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for let.").toString(); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const typeAttrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = typeAttrs; + } + } + this._consume(TokenTypes.tokens.equal, "Expected '=' for let."); + const value = this._short_circuit_or_expression(); + return new Let(name2, type, null, null, value); + } + if (this._match(TokenTypes.keywords.const)) { + const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for const.").toString(); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const typeAttrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = typeAttrs; + } + } + this._consume(TokenTypes.tokens.equal, "Expected '=' for const."); + const value = this._short_circuit_or_expression(); + return new Const(name2, type, null, null, value); + } + return null; + } + _increment_decrement_statement() { + const savedPos = this._current; + const _var = this._unary_expression(); + if (_var == null) { + return null; + } + if (!this._check(TokenTypes.increment_operators)) { + this._current = savedPos; + return null; + } + const token = this._consume(TokenTypes.increment_operators, "Expected increment operator"); + return new Increment(token.type === TokenTypes.tokens.plus_plus ? IncrementOperator.increment : IncrementOperator.decrement, _var); + } + _assignment_statement() { + let _var = null; + if (this._check(TokenTypes.tokens.brace_right)) { + return null; + } + let isUnderscore = this._match(TokenTypes.tokens.underscore); + if (!isUnderscore) { + _var = this._unary_expression(); + } + if (!isUnderscore && _var == null) { + return null; + } + const type = this._consume(TokenTypes.assignment_operators, "Expected assignment operator."); + const value = this._short_circuit_or_expression(); + return new Assign(AssignOperator.parse(type.lexeme), _var, value); + } + _func_call_statement() { + if (!this._check(TokenTypes.tokens.ident)) { + return null; + } + const savedPos = this._current; + const name2 = this._consume(TokenTypes.tokens.ident, "Expected function name."); + const args = this._argument_expression_list(); + if (args === null) { + this._current = savedPos; + return null; + } + return new Call(name2.lexeme, args); + } + _loop_statement() { + if (!this._match(TokenTypes.keywords.loop)) { + return null; + } + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop."); + const statements = []; + let statement = this._statement(); + while (statement !== null) { + if (Array.isArray(statement)) { + for (let s of statement) { + statements.push(s); + } + } else { + statements.push(statement); + } + statement = this._statement(); + } + let continuing = null; + if (this._match(TokenTypes.keywords.continuing)) { + continuing = this._compound_statement(); + } + this._consume(TokenTypes.tokens.brace_right, "Expected '}' for loop."); + return new Loop(statements, continuing); + } + _switch_statement() { + if (!this._match(TokenTypes.keywords.switch)) { + return null; + } + const condition = this._optional_paren_expression(); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch."); + const body = this._switch_body(); + if (body == null || body.length == 0) { + throw this._error(this._previous(), "Expected 'case' or 'default'."); + } + this._consume(TokenTypes.tokens.brace_right, "Expected '}' for switch."); + return new Switch(condition, body); + } + _switch_body() { + const cases = []; + if (this._match(TokenTypes.keywords.case)) { + const selector = this._case_selectors(); + this._match(TokenTypes.tokens.colon); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch case."); + const body = this._case_body(); + this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch case."); + cases.push(new Case(selector, body)); + } + if (this._match(TokenTypes.keywords.default)) { + this._match(TokenTypes.tokens.colon); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch default."); + const body = this._case_body(); + this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch default."); + cases.push(new Default(body)); + } + if (this._check([TokenTypes.keywords.default, TokenTypes.keywords.case])) { + const _cases = this._switch_body(); + cases.push(_cases[0]); + } + return cases; + } + _case_selectors() { + const selectors = [ + this._shift_expression() + //?.evaluate(this._context).toString() ?? "", + ]; + while (this._match(TokenTypes.tokens.comma)) { + selectors.push(this._shift_expression()); + } + return selectors; + } + _case_body() { + if (this._match(TokenTypes.keywords.fallthrough)) { + this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); + return []; + } + let statement = this._statement(); + if (statement == null) { + return []; + } + if (!(statement instanceof Array)) { + statement = [statement]; + } + const nextStatement = this._case_body(); + if (nextStatement.length == 0) { + return statement; + } + return [...statement, nextStatement[0]]; + } + _if_statement() { + if (!this._match(TokenTypes.keywords.if)) { + return null; + } + const condition = this._optional_paren_expression(); + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + const block = this._compound_statement(); + let elseif = []; + if (this._match_elseif()) { + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + elseif = this._elseif_statement(elseif); + } + let _else = null; + if (this._match(TokenTypes.keywords.else)) { + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + _else = this._compound_statement(); + } + return new If(condition, block, elseif, _else); + } + _match_elseif() { + if (this._tokens[this._current].type === TokenTypes.keywords.else && this._tokens[this._current + 1].type === TokenTypes.keywords.if) { + this._advance(); + this._advance(); + return true; + } + return false; + } + _elseif_statement(elseif = []) { + const condition = this._optional_paren_expression(); + const block = this._compound_statement(); + elseif.push(new ElseIf(condition, block)); + if (this._match_elseif()) { + if (this._check(TokenTypes.tokens.attr)) { + this._attribute(); + } + this._elseif_statement(elseif); + } + return elseif; + } + _return_statement() { + if (!this._match(TokenTypes.keywords.return)) { + return null; + } + const value = this._short_circuit_or_expression(); + return new Return(value); + } + _short_circuit_or_expression() { + let expr = this._short_circuit_and_expr(); + while (this._match(TokenTypes.tokens.or_or)) { + expr = new BinaryOperator(this._previous().toString(), expr, this._short_circuit_and_expr()); + } + return expr; + } + _short_circuit_and_expr() { + let expr = this._inclusive_or_expression(); + while (this._match(TokenTypes.tokens.and_and)) { + expr = new BinaryOperator(this._previous().toString(), expr, this._inclusive_or_expression()); + } + return expr; + } + _inclusive_or_expression() { + let expr = this._exclusive_or_expression(); + while (this._match(TokenTypes.tokens.or)) { + expr = new BinaryOperator(this._previous().toString(), expr, this._exclusive_or_expression()); + } + return expr; + } + _exclusive_or_expression() { + let expr = this._and_expression(); + while (this._match(TokenTypes.tokens.xor)) { + expr = new BinaryOperator(this._previous().toString(), expr, this._and_expression()); + } + return expr; + } + _and_expression() { + let expr = this._equality_expression(); + while (this._match(TokenTypes.tokens.and)) { + expr = new BinaryOperator(this._previous().toString(), expr, this._equality_expression()); + } + return expr; + } + _equality_expression() { + const expr = this._relational_expression(); + if (this._match([TokenTypes.tokens.equal_equal, TokenTypes.tokens.not_equal])) { + return new BinaryOperator(this._previous().toString(), expr, this._relational_expression()); + } + return expr; + } + _relational_expression() { + let expr = this._shift_expression(); + while (this._match([ + TokenTypes.tokens.less_than, + TokenTypes.tokens.greater_than, + TokenTypes.tokens.less_than_equal, + TokenTypes.tokens.greater_than_equal + ])) { + expr = new BinaryOperator(this._previous().toString(), expr, this._shift_expression()); + } + return expr; + } + _shift_expression() { + let expr = this._additive_expression(); + while (this._match([TokenTypes.tokens.shift_left, TokenTypes.tokens.shift_right])) { + expr = new BinaryOperator(this._previous().toString(), expr, this._additive_expression()); + } + return expr; + } + _additive_expression() { + let expr = this._multiplicative_expression(); + while (this._match([TokenTypes.tokens.plus, TokenTypes.tokens.minus])) { + expr = new BinaryOperator(this._previous().toString(), expr, this._multiplicative_expression()); + } + return expr; + } + _multiplicative_expression() { + let expr = this._unary_expression(); + while (this._match([ + TokenTypes.tokens.star, + TokenTypes.tokens.forward_slash, + TokenTypes.tokens.modulo + ])) { + expr = new BinaryOperator(this._previous().toString(), expr, this._unary_expression()); + } + return expr; + } + _unary_expression() { + if (this._match([ + TokenTypes.tokens.minus, + TokenTypes.tokens.bang, + TokenTypes.tokens.tilde, + TokenTypes.tokens.star, + TokenTypes.tokens.and + ])) { + return new UnaryOperator(this._previous().toString(), this._unary_expression()); + } + return this._singular_expression(); + } + _singular_expression() { + const expr = this._primary_expression(); + const p = this._postfix_expression(); + if (p) { + expr.postfix = p; + } + return expr; + } + _postfix_expression() { + if (this._match(TokenTypes.tokens.bracket_left)) { + const expr = this._short_circuit_or_expression(); + this._consume(TokenTypes.tokens.bracket_right, "Expected ']'."); + const arrayIndex = new ArrayIndex(expr); + const p = this._postfix_expression(); + if (p) { + arrayIndex.postfix = p; + } + return arrayIndex; + } + if (this._match(TokenTypes.tokens.period)) { + const name2 = this._consume(TokenTypes.tokens.ident, "Expected member name."); + const p = this._postfix_expression(); + const expr = new StringExpr(name2.lexeme); + if (p) { + expr.postfix = p; + } + return expr; + } + return null; + } + _getStruct(name2) { + if (this._context.aliases.has(name2)) { + const alias = this._context.aliases.get(name2).type; + return alias; + } + if (this._context.structs.has(name2)) { + const struct = this._context.structs.get(name2); + return struct; + } + return null; + } + _primary_expression() { + if (this._match(TokenTypes.tokens.ident)) { + const name2 = this._previous().toString(); + if (this._check(TokenTypes.tokens.paren_left)) { + const args2 = this._argument_expression_list(); + const struct = this._getStruct(name2); + if (struct != null) { + return new CreateExpr(struct, args2); + } + return new CallExpr(name2, args2); + } + if (this._context.constants.has(name2)) { + const c = this._context.constants.get(name2); + return new ConstExpr(name2, c.value); + } + return new VariableExpr(name2); + } + if (this._match(TokenTypes.const_literal)) { + return new LiteralExpr(parseFloat(this._previous().toString())); + } + if (this._check(TokenTypes.tokens.paren_left)) { + return this._paren_expression(); + } + if (this._match(TokenTypes.keywords.bitcast)) { + this._consume(TokenTypes.tokens.less_than, "Expected '<'."); + const type2 = this._type_decl(); + this._consume(TokenTypes.tokens.greater_than, "Expected '>'."); + const value = this._paren_expression(); + return new BitcastExpr(type2, value); + } + const type = this._type_decl(); + const args = this._argument_expression_list(); + return new CreateExpr(type, args); + } + _argument_expression_list() { + if (!this._match(TokenTypes.tokens.paren_left)) { + return null; + } + const args = []; + do { + if (this._check(TokenTypes.tokens.paren_right)) { + break; + } + const arg = this._short_circuit_or_expression(); + args.push(arg); + } while (this._match(TokenTypes.tokens.comma)); + this._consume(TokenTypes.tokens.paren_right, "Expected ')' for agument list"); + return args; + } + _optional_paren_expression() { + this._match(TokenTypes.tokens.paren_left); + const expr = this._short_circuit_or_expression(); + this._match(TokenTypes.tokens.paren_right); + return new GroupingExpr([expr]); + } + _paren_expression() { + this._consume(TokenTypes.tokens.paren_left, "Expected '('."); + const expr = this._short_circuit_or_expression(); + this._consume(TokenTypes.tokens.paren_right, "Expected ')'."); + return new GroupingExpr([expr]); + } + _struct_decl() { + if (!this._match(TokenTypes.keywords.struct)) { + return null; + } + const startLine = this._currentLine; + const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString(); + this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body."); + const members = []; + while (!this._check(TokenTypes.tokens.brace_right)) { + const memberAttrs = this._attribute(); + const memberName = this._consume(TokenTypes.tokens.ident, "Expected variable name.").toString(); + this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type."); + const typeAttrs = this._attribute(); + const memberType = this._type_decl(); + if (memberType != null) { + memberType.attributes = typeAttrs; + } + if (!this._check(TokenTypes.tokens.brace_right)) + this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member."); + else + this._match(TokenTypes.tokens.comma); + members.push(new Member(memberName, memberType, memberAttrs)); + } + this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body."); + const endLine = this._currentLine; + const structNode = new Struct(name2, members, startLine, endLine); + this._context.structs.set(name2, structNode); + return structNode; + } + _global_variable_decl() { + const _var = this._variable_decl(); + if (_var && this._match(TokenTypes.tokens.equal)) { + _var.value = this._const_expression(); + } + return _var; + } + _override_variable_decl() { + const _override = this._override_decl(); + if (_override && this._match(TokenTypes.tokens.equal)) { + _override.value = this._const_expression(); + } + return _override; + } + _global_const_decl() { + if (!this._match(TokenTypes.keywords.const)) { + return null; + } + const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const attrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = attrs; + } + } + let value = null; + if (this._match(TokenTypes.tokens.equal)) { + const valueExpr = this._short_circuit_or_expression(); + if (valueExpr instanceof CreateExpr) { + value = valueExpr; + } else if (valueExpr instanceof ConstExpr && valueExpr.initializer instanceof CreateExpr) { + value = valueExpr.initializer; + } else { + try { + const constValue = valueExpr.evaluate(this._context); + value = new LiteralExpr(constValue); + } catch (_a2) { + value = valueExpr; + } + } + } + const c = new Const(name2.toString(), type, "", "", value); + this._context.constants.set(c.name, c); + return c; + } + _global_let_decl() { + if (!this._match(TokenTypes.keywords.let)) { + return null; + } + const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const attrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = attrs; + } + } + let value = null; + if (this._match(TokenTypes.tokens.equal)) { + value = this._const_expression(); + } + return new Let(name2.toString(), type, "", "", value); + } + _const_expression() { + return this._short_circuit_or_expression(); + } + _variable_decl() { + if (!this._match(TokenTypes.keywords.var)) { + return null; + } + let storage = ""; + let access = ""; + if (this._match(TokenTypes.tokens.less_than)) { + storage = this._consume(TokenTypes.storage_class, "Expected storage_class.").toString(); + if (this._match(TokenTypes.tokens.comma)) + access = this._consume(TokenTypes.access_mode, "Expected access_mode.").toString(); + this._consume(TokenTypes.tokens.greater_than, "Expected '>'."); + } + const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const attrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = attrs; + } + } + return new Var(name2.toString(), type, storage, access, null); + } + _override_decl() { + if (!this._match(TokenTypes.keywords.override)) { + return null; + } + const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); + let type = null; + if (this._match(TokenTypes.tokens.colon)) { + const attrs = this._attribute(); + type = this._type_decl(); + if (type != null) { + type.attributes = attrs; + } + } + return new Override(name2.toString(), type, null); + } + _diagnostic() { + this._consume(TokenTypes.tokens.paren_left, "Expected '('"); + const severity = this._consume(TokenTypes.tokens.ident, "Expected severity control name."); + this._consume(TokenTypes.tokens.comma, "Expected ','"); + const rule = this._consume(TokenTypes.tokens.ident, "Expected diagnostic rule name."); + this._consume(TokenTypes.tokens.paren_right, "Expected ')'"); + return new Diagnostic(severity.toString(), rule.toString()); + } + _enable_directive() { + const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); + return new Enable(name2.toString()); + } + _requires_directive() { + const extensions = [this._consume(TokenTypes.tokens.ident, "identity expected.").toString()]; + while (this._match(TokenTypes.tokens.comma)) { + const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); + extensions.push(name2.toString()); + } + return new Requires(extensions); + } + _type_alias() { + const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); + this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias."); + let aliasType = this._type_decl(); + if (aliasType === null) { + throw this._error(this._peek(), "Expected Type for Alias."); + } + if (this._context.aliases.has(aliasType.name)) { + aliasType = this._context.aliases.get(aliasType.name).type; + } + const aliasNode = new Alias(name2.toString(), aliasType); + this._context.aliases.set(aliasNode.name, aliasNode); + return aliasNode; + } + _type_decl() { + if (this._check([ + TokenTypes.tokens.ident, + ...TokenTypes.texel_format, + TokenTypes.keywords.bool, + TokenTypes.keywords.f32, + TokenTypes.keywords.i32, + TokenTypes.keywords.u32 + ])) { + const type2 = this._advance(); + const typeName = type2.toString(); + if (this._context.structs.has(typeName)) { + return this._context.structs.get(typeName); + } + if (this._context.aliases.has(typeName)) { + return this._context.aliases.get(typeName).type; + } + return new Type(type2.toString()); + } + let type = this._texture_sampler_types(); + if (type) { + return type; + } + if (this._check(TokenTypes.template_types)) { + let type2 = this._advance().toString(); + let format = null; + let access = null; + if (this._match(TokenTypes.tokens.less_than)) { + format = this._type_decl(); + access = null; + if (this._match(TokenTypes.tokens.comma)) { + access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString(); + } + this._consume(TokenTypes.tokens.greater_than, "Expected '>' for type."); + } + return new TemplateType(type2, format, access); + } + if (this._match(TokenTypes.keywords.ptr)) { + let pointer = this._previous().toString(); + this._consume(TokenTypes.tokens.less_than, "Expected '<' for pointer."); + const storage = this._consume(TokenTypes.storage_class, "Expected storage_class for pointer"); + this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer."); + const decl = this._type_decl(); + let access = null; + if (this._match(TokenTypes.tokens.comma)) { + access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString(); + } + this._consume(TokenTypes.tokens.greater_than, "Expected '>' for pointer."); + return new PointerType(pointer, storage.toString(), decl, access); + } + const attrs = this._attribute(); + if (this._match(TokenTypes.keywords.array)) { + let format = null; + let countInt = -1; + const array = this._previous(); + let countNode = null; + if (this._match(TokenTypes.tokens.less_than)) { + format = this._type_decl(); + if (this._context.aliases.has(format.name)) { + format = this._context.aliases.get(format.name).type; + } + let count2 = ""; + if (this._match(TokenTypes.tokens.comma)) { + countNode = this._shift_expression(); + try { + count2 = countNode.evaluate(this._context).toString(); + countNode = null; + } catch (e) { + count2 = "1"; + } + } + this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array."); + countInt = count2 ? parseInt(count2) : 0; + } + const arrayType = new ArrayType(array.toString(), attrs, format, countInt); + if (countNode) { + this._deferArrayCountEval.push({ arrayType, countNode }); + } + return arrayType; + } + return null; + } + _texture_sampler_types() { + if (this._match(TokenTypes.sampler_type)) { + return new SamplerType(this._previous().toString(), null, null); + } + if (this._match(TokenTypes.depth_texture_type)) { + return new SamplerType(this._previous().toString(), null, null); + } + if (this._match(TokenTypes.sampled_texture_type) || this._match(TokenTypes.multisampled_texture_type)) { + const sampler = this._previous(); + this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type."); + const format = this._type_decl(); + this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type."); + return new SamplerType(sampler.toString(), format, null); + } + if (this._match(TokenTypes.storage_texture_type)) { + const sampler = this._previous(); + this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type."); + const format = this._consume(TokenTypes.texel_format, "Invalid texel format.").toString(); + this._consume(TokenTypes.tokens.comma, "Expected ',' after texel format."); + const access = this._consume(TokenTypes.access_mode, "Expected access mode for storage texture type.").toString(); + this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type."); + return new SamplerType(sampler.toString(), format, access); + } + return null; + } + _attribute() { + let attributes = []; + while (this._match(TokenTypes.tokens.attr)) { + const name2 = this._consume(TokenTypes.attribute_name, "Expected attribute name"); + const attr = new Attribute(name2.toString(), null); + if (this._match(TokenTypes.tokens.paren_left)) { + attr.value = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString(); + if (this._check(TokenTypes.tokens.comma)) { + this._advance(); + do { + const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString(); + if (!(attr.value instanceof Array)) { + attr.value = [attr.value]; + } + attr.value.push(v); + } while (this._match(TokenTypes.tokens.comma)); + } + this._consume(TokenTypes.tokens.paren_right, "Expected ')'"); + } + attributes.push(attr); + } + if (attributes.length == 0) { + return null; + } + return attributes; + } +}; +var TypeInfo = class { + constructor(name2, attributes) { + this.name = name2; + this.attributes = attributes; + this.size = 0; + } + get isArray() { + return false; + } + get isStruct() { + return false; + } + get isTemplate() { + return false; + } +}; +var MemberInfo = class { + constructor(name2, type, attributes) { + this.name = name2; + this.type = type; + this.attributes = attributes; + this.offset = 0; + this.size = 0; + } + get isArray() { + return this.type.isArray; + } + get isStruct() { + return this.type.isStruct; + } + get isTemplate() { + return this.type.isTemplate; + } + get align() { + return this.type.isStruct ? this.type.align : 0; + } + get members() { + return this.type.isStruct ? this.type.members : null; + } + get format() { + return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null; + } + get count() { + return this.type.isArray ? this.type.count : 0; + } + get stride() { + return this.type.isArray ? this.type.stride : this.size; + } +}; +var StructInfo = class extends TypeInfo { + constructor(name2, attributes) { + super(name2, attributes); + this.members = []; + this.align = 0; + this.startLine = -1; + this.endLine = -1; + this.inUse = false; + } + get isStruct() { + return true; + } +}; +var ArrayInfo = class extends TypeInfo { + constructor(name2, attributes) { + super(name2, attributes); + this.count = 0; + this.stride = 0; + } + get isArray() { + return true; + } +}; +var TemplateInfo = class extends TypeInfo { + constructor(name2, format, attributes, access) { + super(name2, attributes); + this.format = format; + this.access = access; + } + get isTemplate() { + return true; + } +}; +var ResourceType; +(function(ResourceType2) { + ResourceType2[ResourceType2["Uniform"] = 0] = "Uniform"; + ResourceType2[ResourceType2["Storage"] = 1] = "Storage"; + ResourceType2[ResourceType2["Texture"] = 2] = "Texture"; + ResourceType2[ResourceType2["Sampler"] = 3] = "Sampler"; + ResourceType2[ResourceType2["StorageTexture"] = 4] = "StorageTexture"; +})(ResourceType || (ResourceType = {})); +var VariableInfo = class { + constructor(name2, type, group, binding, attributes, resourceType, access) { + this.name = name2; + this.type = type; + this.group = group; + this.binding = binding; + this.attributes = attributes; + this.resourceType = resourceType; + this.access = access; + } + get isArray() { + return this.type.isArray; + } + get isStruct() { + return this.type.isStruct; + } + get isTemplate() { + return this.type.isTemplate; + } + get size() { + return this.type.size; + } + get align() { + return this.type.isStruct ? this.type.align : 0; + } + get members() { + return this.type.isStruct ? this.type.members : null; + } + get format() { + return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null; + } + get count() { + return this.type.isArray ? this.type.count : 0; + } + get stride() { + return this.type.isArray ? this.type.stride : this.size; + } +}; +var AliasInfo = class { + constructor(name2, type) { + this.name = name2; + this.type = type; + } +}; +var _TypeSize = class { + constructor(align, size) { + this.align = align; + this.size = size; + } +}; +var InputInfo = class { + constructor(name2, type, locationType, location) { + this.name = name2; + this.type = type; + this.locationType = locationType; + this.location = location; + this.interpolation = null; + } +}; +var OutputInfo = class { + constructor(name2, type, locationType, location) { + this.name = name2; + this.type = type; + this.locationType = locationType; + this.location = location; + } +}; +var OverrideInfo = class { + constructor(name2, type, attributes, id) { + this.name = name2; + this.type = type; + this.attributes = attributes; + this.id = id; + } +}; +var ArgumentInfo = class { + constructor(name2, type) { + this.name = name2; + this.type = type; + } +}; +var FunctionInfo = class { + constructor(name2, stage = null) { + this.stage = null; + this.inputs = []; + this.outputs = []; + this.arguments = []; + this.returnType = null; + this.resources = []; + this.overrides = []; + this.startLine = -1; + this.endLine = -1; + this.inUse = false; + this.calls = /* @__PURE__ */ new Set(); + this.name = name2; + this.stage = stage; + } +}; +var EntryFunctions = class { + constructor() { + this.vertex = []; + this.fragment = []; + this.compute = []; + } +}; +var _FunctionResources = class { + constructor(node) { + this.resources = null; + this.inUse = false; + this.info = null; + this.node = node; + } +}; +var WgslReflect = class _WgslReflect { + constructor(code) { + this.uniforms = []; + this.storage = []; + this.textures = []; + this.samplers = []; + this.aliases = []; + this.overrides = []; + this.structs = []; + this.entry = new EntryFunctions(); + this.functions = []; + this._types = /* @__PURE__ */ new Map(); + this._functions = /* @__PURE__ */ new Map(); + if (code) { + this.update(code); + } + } + _isStorageTexture(type) { + return type.name == "texture_storage_1d" || type.name == "texture_storage_2d" || type.name == "texture_storage_2d_array" || type.name == "texture_storage_3d"; + } + update(code) { + const parser = new WgslParser(); + const ast = parser.parse(code); + for (const node of ast) { + if (node instanceof Function) { + this._functions.set(node.name, new _FunctionResources(node)); + } + } + for (const node of ast) { + if (node instanceof Struct) { + const info = this._getTypeInfo(node, null); + if (info instanceof StructInfo) { + this.structs.push(info); + } + } + } + for (const node of ast) { + if (node instanceof Alias) { + this.aliases.push(this._getAliasInfo(node)); + continue; + } + if (node instanceof Override) { + const v = node; + const id = this._getAttributeNum(v.attributes, "id", 0); + const type = v.type != null ? this._getTypeInfo(v.type, v.attributes) : null; + this.overrides.push(new OverrideInfo(v.name, type, v.attributes, id)); + continue; + } + if (this._isUniformVar(node)) { + const v = node; + const g = this._getAttributeNum(v.attributes, "group", 0); + const b = this._getAttributeNum(v.attributes, "binding", 0); + const type = this._getTypeInfo(v.type, v.attributes); + const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Uniform, v.access); + this.uniforms.push(varInfo); + continue; + } + if (this._isStorageVar(node)) { + const v = node; + const g = this._getAttributeNum(v.attributes, "group", 0); + const b = this._getAttributeNum(v.attributes, "binding", 0); + const type = this._getTypeInfo(v.type, v.attributes); + const isStorageTexture = this._isStorageTexture(type); + const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Storage, v.access); + this.storage.push(varInfo); + continue; + } + if (this._isTextureVar(node)) { + const v = node; + const g = this._getAttributeNum(v.attributes, "group", 0); + const b = this._getAttributeNum(v.attributes, "binding", 0); + const type = this._getTypeInfo(v.type, v.attributes); + const isStorageTexture = this._isStorageTexture(type); + const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Texture, v.access); + if (isStorageTexture) { + this.storage.push(varInfo); + } else { + this.textures.push(varInfo); + } + continue; + } + if (this._isSamplerVar(node)) { + const v = node; + const g = this._getAttributeNum(v.attributes, "group", 0); + const b = this._getAttributeNum(v.attributes, "binding", 0); + const type = this._getTypeInfo(v.type, v.attributes); + const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Sampler, v.access); + this.samplers.push(varInfo); + continue; + } + if (node instanceof Function) { + const vertexStage = this._getAttribute(node, "vertex"); + const fragmentStage = this._getAttribute(node, "fragment"); + const computeStage = this._getAttribute(node, "compute"); + const stage = vertexStage || fragmentStage || computeStage; + const fn = new FunctionInfo(node.name, stage === null || stage === void 0 ? void 0 : stage.name); + fn.startLine = node.startLine; + fn.endLine = node.endLine; + this.functions.push(fn); + this._functions.get(node.name).info = fn; + if (stage) { + this._functions.get(node.name).inUse = true; + fn.inUse = true; + fn.resources = this._findResources(node, !!stage); + fn.inputs = this._getInputs(node.args); + fn.outputs = this._getOutputs(node.returnType); + this.entry[stage.name].push(fn); + } else { + fn.arguments = node.args.map((arg) => new ArgumentInfo(arg.name, this._getTypeInfo(arg.type, arg.attributes))); + fn.returnType = node.returnType ? this._getTypeInfo(node.returnType, node.attributes) : null; + } + continue; + } + } + for (const fn of this._functions.values()) { + if (fn.info) { + fn.info.inUse = fn.inUse; + this._addCalls(fn.node, fn.info.calls); + } + } + for (const fn of this._functions.values()) { + fn.node.search((node) => { + var _a2; + if (node.astNodeType === "varExpr") { + const v = node; + for (const override of this.overrides) { + if (v.name == override.name) { + (_a2 = fn.info) === null || _a2 === void 0 ? void 0 : _a2.overrides.push(override); + } + } + } + }); + } + for (const u of this.uniforms) { + this._markStructsInUse(u.type); + } + for (const s of this.storage) { + this._markStructsInUse(s.type); + } + } + _markStructsInUse(type) { + if (!type) { + return; + } + if (type.isStruct) { + type.inUse = true; + if (type.members) { + for (const m of type.members) { + this._markStructsInUse(m.type); + } + } + } else if (type.isArray) { + this._markStructsInUse(type.format); + } else if (type.isTemplate) { + if (type.format) { + this._markStructsInUse(type.format); + } + } else { + const alias = this._getAlias(type.name); + if (alias) { + this._markStructsInUse(alias); + } + } + } + _addCalls(fn, calls) { + var _a2; + for (const call of fn.calls) { + const info = (_a2 = this._functions.get(call.name)) === null || _a2 === void 0 ? void 0 : _a2.info; + if (info) { + calls.add(info); + } + } + } + /// Find a resource by its group and binding. + findResource(group, binding) { + for (const u of this.uniforms) { + if (u.group == group && u.binding == binding) { + return u; + } + } + for (const s of this.storage) { + if (s.group == group && s.binding == binding) { + return s; + } + } + for (const t of this.textures) { + if (t.group == group && t.binding == binding) { + return t; + } + } + for (const s of this.samplers) { + if (s.group == group && s.binding == binding) { + return s; + } + } + return null; + } + _findResource(name2) { + for (const u of this.uniforms) { + if (u.name == name2) { + return u; + } + } + for (const s of this.storage) { + if (s.name == name2) { + return s; + } + } + for (const t of this.textures) { + if (t.name == name2) { + return t; + } + } + for (const s of this.samplers) { + if (s.name == name2) { + return s; + } + } + return null; + } + _markStructsFromAST(type) { + const info = this._getTypeInfo(type, null); + this._markStructsInUse(info); + } + _findResources(fn, isEntry) { + const resources = []; + const self2 = this; + const varStack = []; + fn.search((node) => { + if (node instanceof _BlockStart) { + varStack.push({}); + } else if (node instanceof _BlockEnd) { + varStack.pop(); + } else if (node instanceof Var) { + const v = node; + if (isEntry && v.type !== null) { + this._markStructsFromAST(v.type); + } + if (varStack.length > 0) { + varStack[varStack.length - 1][v.name] = v; + } + } else if (node instanceof CreateExpr) { + const c = node; + if (isEntry && c.type !== null) { + this._markStructsFromAST(c.type); + } + } else if (node instanceof Let) { + const v = node; + if (isEntry && v.type !== null) { + this._markStructsFromAST(v.type); + } + if (varStack.length > 0) { + varStack[varStack.length - 1][v.name] = v; + } + } else if (node instanceof VariableExpr) { + const v = node; + if (varStack.length > 0) { + const varInfo2 = varStack[varStack.length - 1][v.name]; + if (varInfo2) { + return; + } + } + const varInfo = self2._findResource(v.name); + if (varInfo) { + resources.push(varInfo); + } + } else if (node instanceof CallExpr) { + const c = node; + const callFn = self2._functions.get(c.name); + if (callFn) { + if (isEntry) { + callFn.inUse = true; + } + fn.calls.add(callFn.node); + if (callFn.resources === null) { + callFn.resources = self2._findResources(callFn.node, isEntry); + } + resources.push(...callFn.resources); + } + } else if (node instanceof Call) { + const c = node; + const callFn = self2._functions.get(c.name); + if (callFn) { + if (isEntry) { + callFn.inUse = true; + } + fn.calls.add(callFn.node); + if (callFn.resources === null) { + callFn.resources = self2._findResources(callFn.node, isEntry); + } + resources.push(...callFn.resources); + } + } + }); + return [...new Map(resources.map((r) => [r.name, r])).values()]; + } + getBindGroups() { + const groups = []; + function _makeRoom(group, binding) { + if (group >= groups.length) { + groups.length = group + 1; + } + if (groups[group] === void 0) { + groups[group] = []; + } + if (binding >= groups[group].length) { + groups[group].length = binding + 1; + } + } + for (const u of this.uniforms) { + _makeRoom(u.group, u.binding); + const group = groups[u.group]; + group[u.binding] = u; + } + for (const u of this.storage) { + _makeRoom(u.group, u.binding); + const group = groups[u.group]; + group[u.binding] = u; + } + for (const t of this.textures) { + _makeRoom(t.group, t.binding); + const group = groups[t.group]; + group[t.binding] = t; + } + for (const t of this.samplers) { + _makeRoom(t.group, t.binding); + const group = groups[t.group]; + group[t.binding] = t; + } + return groups; + } + _getOutputs(type, outputs = void 0) { + if (outputs === void 0) { + outputs = []; + } + if (type instanceof Struct) { + this._getStructOutputs(type, outputs); + } else { + const output = this._getOutputInfo(type); + if (output !== null) { + outputs.push(output); + } + } + return outputs; + } + _getStructOutputs(struct, outputs) { + for (const m of struct.members) { + if (m.type instanceof Struct) { + this._getStructOutputs(m.type, outputs); + } else { + const location = this._getAttribute(m, "location") || this._getAttribute(m, "builtin"); + if (location !== null) { + const typeInfo = this._getTypeInfo(m.type, m.type.attributes); + const locationValue = this._parseInt(location.value); + const info = new OutputInfo(m.name, typeInfo, location.name, locationValue); + outputs.push(info); + } + } + } + } + _getOutputInfo(type) { + const location = this._getAttribute(type, "location") || this._getAttribute(type, "builtin"); + if (location !== null) { + const typeInfo = this._getTypeInfo(type, type.attributes); + const locationValue = this._parseInt(location.value); + const info = new OutputInfo("", typeInfo, location.name, locationValue); + return info; + } + return null; + } + _getInputs(args, inputs = void 0) { + if (inputs === void 0) { + inputs = []; + } + for (const arg of args) { + if (arg.type instanceof Struct) { + this._getStructInputs(arg.type, inputs); + } else { + const input = this._getInputInfo(arg); + if (input !== null) { + inputs.push(input); + } + } + } + return inputs; + } + _getStructInputs(struct, inputs) { + for (const m of struct.members) { + if (m.type instanceof Struct) { + this._getStructInputs(m.type, inputs); + } else { + const input = this._getInputInfo(m); + if (input !== null) { + inputs.push(input); + } + } + } + } + _getInputInfo(node) { + const location = this._getAttribute(node, "location") || this._getAttribute(node, "builtin"); + if (location !== null) { + const interpolation = this._getAttribute(node, "interpolation"); + const type = this._getTypeInfo(node.type, node.attributes); + const locationValue = this._parseInt(location.value); + const info = new InputInfo(node.name, type, location.name, locationValue); + if (interpolation !== null) { + info.interpolation = this._parseString(interpolation.value); + } + return info; + } + return null; + } + _parseString(s) { + if (s instanceof Array) { + s = s[0]; + } + return s; + } + _parseInt(s) { + if (s instanceof Array) { + s = s[0]; + } + const n = parseInt(s); + return isNaN(n) ? s : n; + } + _getAlias(name2) { + for (const a of this.aliases) { + if (a.name == name2) { + return a.type; + } + } + return null; + } + _getAliasInfo(node) { + return new AliasInfo(node.name, this._getTypeInfo(node.type, null)); + } + _getTypeInfo(type, attributes) { + if (this._types.has(type)) { + return this._types.get(type); + } + if (type instanceof ArrayType) { + const a = type; + const t = a.format ? this._getTypeInfo(a.format, a.attributes) : null; + const info2 = new ArrayInfo(a.name, attributes); + info2.format = t; + info2.count = a.count; + this._types.set(type, info2); + this._updateTypeInfo(info2); + return info2; + } + if (type instanceof Struct) { + const s = type; + const info2 = new StructInfo(s.name, attributes); + info2.startLine = s.startLine; + info2.endLine = s.endLine; + for (const m of s.members) { + const t = this._getTypeInfo(m.type, m.attributes); + info2.members.push(new MemberInfo(m.name, t, m.attributes)); + } + this._types.set(type, info2); + this._updateTypeInfo(info2); + return info2; + } + if (type instanceof SamplerType) { + const s = type; + const formatIsType = s.format instanceof Type; + const format = s.format ? formatIsType ? this._getTypeInfo(s.format, null) : new TypeInfo(s.format, null) : null; + const info2 = new TemplateInfo(s.name, format, attributes, s.access); + this._types.set(type, info2); + this._updateTypeInfo(info2); + return info2; + } + if (type instanceof TemplateType) { + const t = type; + const format = t.format ? this._getTypeInfo(t.format, null) : null; + const info2 = new TemplateInfo(t.name, format, attributes, t.access); + this._types.set(type, info2); + this._updateTypeInfo(info2); + return info2; + } + const info = new TypeInfo(type.name, attributes); + this._types.set(type, info); + this._updateTypeInfo(info); + return info; + } + _updateTypeInfo(type) { + var _a2, _b; + const typeSize = this._getTypeSize(type); + type.size = (_a2 = typeSize === null || typeSize === void 0 ? void 0 : typeSize.size) !== null && _a2 !== void 0 ? _a2 : 0; + if (type instanceof ArrayInfo) { + if (type["format"]) { + const formatInfo = this._getTypeSize(type["format"]); + type.stride = (_b = formatInfo === null || formatInfo === void 0 ? void 0 : formatInfo.size) !== null && _b !== void 0 ? _b : 0; + this._updateTypeInfo(type["format"]); + } + } + if (type instanceof StructInfo) { + this._updateStructInfo(type); + } + } + _updateStructInfo(struct) { + var _a2; + let offset = 0; + let lastSize = 0; + let lastOffset = 0; + let structAlign = 0; + for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) { + const member = struct.members[mi]; + const sizeInfo = this._getTypeSize(member); + if (!sizeInfo) { + continue; + } + (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type; + const align = sizeInfo.align; + const size = sizeInfo.size; + offset = this._roundUp(align, offset + lastSize); + lastSize = size; + lastOffset = offset; + structAlign = Math.max(structAlign, align); + member.offset = offset; + member.size = size; + this._updateTypeInfo(member.type); + } + struct.size = this._roundUp(structAlign, lastOffset + lastSize); + struct.align = structAlign; + } + _getTypeSize(type) { + var _a2, _b; + if (type === null || type === void 0) { + return null; + } + const explicitSize = this._getAttributeNum(type.attributes, "size", 0); + const explicitAlign = this._getAttributeNum(type.attributes, "align", 0); + if (type instanceof MemberInfo) { + type = type.type; + } + if (type instanceof TypeInfo) { + const alias = this._getAlias(type.name); + if (alias !== null) { + type = alias; + } + } + { + const info = _WgslReflect._typeInfo[type.name]; + if (info !== void 0) { + const divisor = ((_a2 = type["format"]) === null || _a2 === void 0 ? void 0 : _a2.name) === "f16" ? 2 : 1; + return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor)); + } + } + { + const info = _WgslReflect._typeInfo[type.name.substring(0, type.name.length - 1)]; + if (info) { + const divisor = type.name[type.name.length - 1] === "h" ? 2 : 1; + return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor)); + } + } + if (type instanceof ArrayInfo) { + let arrayType = type; + let align = 8; + let size = 8; + const E = this._getTypeSize(arrayType.format); + if (E !== null) { + size = E.size; + align = E.align; + } + const N = arrayType.count; + const stride = this._getAttributeNum((_b = type === null || type === void 0 ? void 0 : type.attributes) !== null && _b !== void 0 ? _b : null, "stride", this._roundUp(align, size)); + size = N * stride; + if (explicitSize) { + size = explicitSize; + } + return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size)); + } + if (type instanceof StructInfo) { + let align = 0; + let size = 0; + let offset = 0; + let lastSize = 0; + let lastOffset = 0; + for (const m of type.members) { + const mi = this._getTypeSize(m.type); + if (mi !== null) { + align = Math.max(mi.align, align); + offset = this._roundUp(mi.align, offset + lastSize); + lastSize = mi.size; + lastOffset = offset; + } + } + size = this._roundUp(align, lastOffset + lastSize); + return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size)); + } + return null; + } + _isUniformVar(node) { + return node instanceof Var && node.storage == "uniform"; + } + _isStorageVar(node) { + return node instanceof Var && node.storage == "storage"; + } + _isTextureVar(node) { + return node instanceof Var && node.type !== null && _WgslReflect._textureTypes.indexOf(node.type.name) != -1; + } + _isSamplerVar(node) { + return node instanceof Var && node.type !== null && _WgslReflect._samplerTypes.indexOf(node.type.name) != -1; + } + _getAttribute(node, name2) { + const obj = node; + if (!obj || !obj["attributes"]) { + return null; + } + const attrs = obj["attributes"]; + for (let a of attrs) { + if (a.name == name2) { + return a; + } + } + return null; + } + _getAttributeNum(attributes, name2, defaultValue) { + if (attributes === null) { + return defaultValue; + } + for (let a of attributes) { + if (a.name == name2) { + let v = a !== null && a.value !== null ? a.value : defaultValue; + if (v instanceof Array) { + v = v[0]; + } + if (typeof v === "number") { + return v; + } + if (typeof v === "string") { + return parseInt(v); + } + return defaultValue; + } + } + return defaultValue; + } + _roundUp(k, n) { + return Math.ceil(n / k) * k; + } +}; +WgslReflect._typeInfo = { + f16: { align: 2, size: 2 }, + i32: { align: 4, size: 4 }, + u32: { align: 4, size: 4 }, + f32: { align: 4, size: 4 }, + atomic: { align: 4, size: 4 }, + vec2: { align: 8, size: 8 }, + vec3: { align: 16, size: 12 }, + vec4: { align: 16, size: 16 }, + mat2x2: { align: 8, size: 16 }, + mat3x2: { align: 8, size: 24 }, + mat4x2: { align: 8, size: 32 }, + mat2x3: { align: 16, size: 32 }, + mat3x3: { align: 16, size: 48 }, + mat4x3: { align: 16, size: 64 }, + mat2x4: { align: 16, size: 32 }, + mat3x4: { align: 16, size: 48 }, + mat4x4: { align: 16, size: 64 } +}; +WgslReflect._textureTypes = TokenTypes.any_texture_type.map((t) => { + return t.name; +}); +WgslReflect._samplerTypes = TokenTypes.sampler_type.map((t) => { + return t.name; +}); + +// node_modules/@luma.gl/shadertools/dist/lib/wgsl/get-shader-layout-wgsl.js +function getShaderLayoutFromWGSL(source) { + const shaderLayout = { attributes: [], bindings: [] }; + let parsedWGSL; + try { + parsedWGSL = parseWGSL(source); + } catch (error) { + log2.error(error.message)(); + return shaderLayout; + } + for (const uniform of parsedWGSL.uniforms) { + const members = []; + for (const attribute of uniform.type?.members || []) { + members.push({ + name: attribute.name, + type: getType(attribute.type) + }); + } + shaderLayout.bindings.push({ + type: "uniform", + name: uniform.name, + location: uniform.binding, + // @ts-expect-error + group: uniform.group, + members + }); + } + const vertex = parsedWGSL.entry.vertex[0]; + const attributeCount = vertex?.inputs.length || 0; + for (let i = 0; i < attributeCount; i++) { + const wgslAttribute = vertex.inputs[i]; + if (wgslAttribute.locationType === "location") { + const type = getType(wgslAttribute.type); + shaderLayout.attributes.push({ + name: wgslAttribute.name, + location: Number(wgslAttribute.location), + type + }); + } + } + return shaderLayout; +} +function getType(type) { + return type.format ? `${type.name}<${type.format.name}>` : type.name; +} +function parseWGSL(source) { + try { + return new WgslReflect(source); + } catch (error) { + if (error instanceof Error) { + throw error; + } + let message2 = "WGSL parse error"; + if (typeof error === "object" && error?.message) { + message2 += `: ${error.message} `; + } + if (typeof error === "object" && error?.token) { + message2 += error.token.line || ""; + } + throw new Error(message2, { cause: error }); + } +} + +// node_modules/@luma.gl/shadertools/dist/modules/math/fp32/fp32.js +var fp32shader = `#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND +const float TWO_PI = 6.2831854820251465; +const float PI_2 = 1.5707963705062866; +const float PI_16 = 0.1963495463132858; +const float SIN_TABLE_0 = 0.19509032368659973; +const float SIN_TABLE_1 = 0.3826834261417389; +const float SIN_TABLE_2 = 0.5555702447891235; +const float SIN_TABLE_3 = 0.7071067690849304; +const float COS_TABLE_0 = 0.9807852506637573; +const float COS_TABLE_1 = 0.9238795042037964; +const float COS_TABLE_2 = 0.8314695954322815; +const float COS_TABLE_3 = 0.7071067690849304; +const float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; +const float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; +const float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; +const float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; +float sin_taylor_fp32(float a) { +float r, s, t, x; +if (a == 0.0) { +return 0.0; +} +x = -a * a; +s = a; +r = a; +r = r * x; +t = r * INVERSE_FACTORIAL_3; +s = s + t; +r = r * x; +t = r * INVERSE_FACTORIAL_5; +s = s + t; +r = r * x; +t = r * INVERSE_FACTORIAL_7; +s = s + t; +r = r * x; +t = r * INVERSE_FACTORIAL_9; +s = s + t; +return s; +} +void sincos_taylor_fp32(float a, out float sin_t, out float cos_t) { +if (a == 0.0) { +sin_t = 0.0; +cos_t = 1.0; +} +sin_t = sin_taylor_fp32(a); +cos_t = sqrt(1.0 - sin_t * sin_t); +} +float tan_taylor_fp32(float a) { +float sin_a; +float cos_a; +if (a == 0.0) { +return 0.0; +} +float z = floor(a / TWO_PI); +float r = a - TWO_PI * z; +float t; +float q = floor(r / PI_2 + 0.5); +int j = int(q); +if (j < -2 || j > 2) { +return 1.0 / 0.0; +} +t = r - PI_2 * q; +q = floor(t / PI_16 + 0.5); +int k = int(q); +int abs_k = int(abs(float(k))); +if (abs_k > 4) { +return 1.0 / 0.0; +} else { +t = t - PI_16 * q; +} +float u = 0.0; +float v = 0.0; +float sin_t, cos_t; +float s, c; +sincos_taylor_fp32(t, sin_t, cos_t); +if (k == 0) { +s = sin_t; +c = cos_t; +} else { +if (abs(float(abs_k) - 1.0) < 0.5) { +u = COS_TABLE_0; +v = SIN_TABLE_0; +} else if (abs(float(abs_k) - 2.0) < 0.5) { +u = COS_TABLE_1; +v = SIN_TABLE_1; +} else if (abs(float(abs_k) - 3.0) < 0.5) { +u = COS_TABLE_2; +v = SIN_TABLE_2; +} else if (abs(float(abs_k) - 4.0) < 0.5) { +u = COS_TABLE_3; +v = SIN_TABLE_3; +} +if (k > 0) { +s = u * sin_t + v * cos_t; +c = u * cos_t - v * sin_t; +} else { +s = u * sin_t - v * cos_t; +c = u * cos_t + v * sin_t; +} +} +if (j == 0) { +sin_a = s; +cos_a = c; +} else if (j == 1) { +sin_a = c; +cos_a = -s; +} else if (j == -1) { +sin_a = -c; +cos_a = s; +} else { +sin_a = -s; +cos_a = -c; +} +return sin_a / cos_a; +} +#endif +float tan_fp32(float a) { +#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND +return tan_taylor_fp32(a); +#else +return tan(a); +#endif +} +`; +var fp32 = { + name: "fp32", + vs: fp32shader +}; + +// node_modules/@luma.gl/shadertools/dist/modules/engine/picking/picking.js +var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1]; +var vs = `uniform pickingUniforms { +float isActive; +float isAttribute; +float isHighlightActive; +float useFloatColors; +vec3 highlightedObjectColor; +vec4 highlightColor; +} picking; +out vec4 picking_vRGBcolor_Avalid; +vec3 picking_normalizeColor(vec3 color) { +return picking.useFloatColors > 0.5 ? color : color / 255.0; +} +vec4 picking_normalizeColor(vec4 color) { +return picking.useFloatColors > 0.5 ? color : color / 255.0; +} +bool picking_isColorZero(vec3 color) { +return dot(color, vec3(1.0)) < 0.00001; +} +bool picking_isColorValid(vec3 color) { +return dot(color, vec3(1.0)) > 0.00001; +} +bool isVertexHighlighted(vec3 vertexColor) { +vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor); +return +bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor)); +} +void picking_setPickingColor(vec3 pickingColor) { +pickingColor = picking_normalizeColor(pickingColor); +if (bool(picking.isActive)) { +picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor)); +if (!bool(picking.isAttribute)) { +picking_vRGBcolor_Avalid.rgb = pickingColor; +} +} else { +picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor)); +} +} +void picking_setPickingAttribute(float value) { +if (bool(picking.isAttribute)) { +picking_vRGBcolor_Avalid.r = value; +} +} +void picking_setPickingAttribute(vec2 value) { +if (bool(picking.isAttribute)) { +picking_vRGBcolor_Avalid.rg = value; +} +} +void picking_setPickingAttribute(vec3 value) { +if (bool(picking.isAttribute)) { +picking_vRGBcolor_Avalid.rgb = value; +} +} +`; +var fs = `uniform pickingUniforms { +float isActive; +float isAttribute; +float isHighlightActive; +float useFloatColors; +vec3 highlightedObjectColor; +vec4 highlightColor; +} picking; +in vec4 picking_vRGBcolor_Avalid; +vec4 picking_filterHighlightColor(vec4 color) { +if (picking.isActive > 0.5) { +return color; +} +bool selected = bool(picking_vRGBcolor_Avalid.a); +if (selected) { +float highLightAlpha = picking.highlightColor.a; +float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha); +float highLightRatio = highLightAlpha / blendedAlpha; +vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio); +return vec4(blendedRGB, blendedAlpha); +} else { +return color; +} +} +vec4 picking_filterPickingColor(vec4 color) { +if (bool(picking.isActive)) { +if (picking_vRGBcolor_Avalid.a == 0.0) { +discard; +} +return picking_vRGBcolor_Avalid; +} +return color; +} +vec4 picking_filterColor(vec4 color) { +vec4 highlightColor = picking_filterHighlightColor(color); +return picking_filterPickingColor(highlightColor); +} +`; +var picking = { + name: "picking", + vs, + fs, + uniformTypes: { + isActive: "f32", + isAttribute: "f32", + isHighlightActive: "f32", + useFloatColors: "f32", + highlightedObjectColor: "vec3", + highlightColor: "vec4" + }, + defaultUniforms: { + isActive: false, + isAttribute: false, + isHighlightActive: false, + useFloatColors: true, + highlightedObjectColor: [0, 0, 0], + highlightColor: DEFAULT_HIGHLIGHT_COLOR + }, + getUniforms +}; +function getUniforms(opts = {}, prevUniforms) { + const uniforms = {}; + if (opts.highlightedObjectColor === void 0) { + } else if (opts.highlightedObjectColor === null) { + uniforms.isHighlightActive = false; + } else { + uniforms.isHighlightActive = true; + const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3); + uniforms.highlightedObjectColor = highlightedObjectColor; + } + if (opts.highlightColor) { + const color = Array.from(opts.highlightColor, (x) => x / 255); + if (!Number.isFinite(color[3])) { + color[3] = 1; + } + uniforms.highlightColor = color; + } + if (opts.isActive !== void 0) { + uniforms.isActive = Boolean(opts.isActive); + uniforms.isAttribute = Boolean(opts.isAttribute); + } + if (opts.useFloatColors !== void 0) { + uniforms.useFloatColors = Boolean(opts.useFloatColors); + } + return uniforms; +} + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js +function fp64ify(a, out = [], startIndex = 0) { + const hiPart = Math.fround(a); + const loPart = a - hiPart; + out[startIndex] = hiPart; + out[startIndex + 1] = loPart; + return out; +} +function fp64LowPart(a) { + return a - Math.fround(a); +} +function fp64ifyMatrix4(matrix) { + const matrixFP64 = new Float32Array(32); + for (let i = 0; i < 4; ++i) { + for (let j = 0; j < 4; ++j) { + const index2 = i * 4 + j; + fp64ify(matrix[j * 4 + i], matrixFP64, index2 * 2); + } + } + return matrixFP64; +} + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic-glsl.js +var fp64arithmeticShader = `uniform float ONE; +vec2 split(float a) { +const float SPLIT = 4097.0; +float t = a * SPLIT; +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +float a_hi = t * ONE - (t - a); +float a_lo = a * ONE - a_hi; +#else +float a_hi = t - (t - a); +float a_lo = a - a_hi; +#endif +return vec2(a_hi, a_lo); +} +vec2 split2(vec2 a) { +vec2 b = split(a.x); +b.y += a.y; +return b; +} +vec2 quickTwoSum(float a, float b) { +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +float sum = (a + b) * ONE; +float err = b - (sum - a) * ONE; +#else +float sum = a + b; +float err = b - (sum - a); +#endif +return vec2(sum, err); +} +vec2 twoSum(float a, float b) { +float s = (a + b); +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +float v = (s * ONE - a) * ONE; +float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v); +#else +float v = s - a; +float err = (a - (s - v)) + (b - v); +#endif +return vec2(s, err); +} +vec2 twoSub(float a, float b) { +float s = (a - b); +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +float v = (s * ONE - a) * ONE; +float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v); +#else +float v = s - a; +float err = (a - (s - v)) - (b + v); +#endif +return vec2(s, err); +} +vec2 twoSqr(float a) { +float prod = a * a; +vec2 a_fp64 = split(a); +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x * +a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE; +#else +float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y; +#endif +return vec2(prod, err); +} +vec2 twoProd(float a, float b) { +float prod = a * b; +vec2 a_fp64 = split(a); +vec2 b_fp64 = split(b); +float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y + +a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y; +return vec2(prod, err); +} +vec2 sum_fp64(vec2 a, vec2 b) { +vec2 s, t; +s = twoSum(a.x, b.x); +t = twoSum(a.y, b.y); +s.y += t.x; +s = quickTwoSum(s.x, s.y); +s.y += t.y; +s = quickTwoSum(s.x, s.y); +return s; +} +vec2 sub_fp64(vec2 a, vec2 b) { +vec2 s, t; +s = twoSub(a.x, b.x); +t = twoSub(a.y, b.y); +s.y += t.x; +s = quickTwoSum(s.x, s.y); +s.y += t.y; +s = quickTwoSum(s.x, s.y); +return s; +} +vec2 mul_fp64(vec2 a, vec2 b) { +vec2 prod = twoProd(a.x, b.x); +prod.y += a.x * b.y; +#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) +prod = split2(prod); +#endif +prod = quickTwoSum(prod.x, prod.y); +prod.y += a.y * b.x; +#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) +prod = split2(prod); +#endif +prod = quickTwoSum(prod.x, prod.y); +return prod; +} +vec2 div_fp64(vec2 a, vec2 b) { +float xn = 1.0 / b.x; +#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) +vec2 yn = mul_fp64(a, vec2(xn, 0)); +#else +vec2 yn = a * xn; +#endif +float diff = (sub_fp64(a, mul_fp64(b, yn))).x; +vec2 prod = twoProd(xn, diff); +return sum_fp64(yn, prod); +} +vec2 sqrt_fp64(vec2 a) { +if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0); +if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0); +float x = 1.0 / sqrt(a.x); +float yn = a.x * x; +#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) +vec2 yn_sqr = twoSqr(yn) * ONE; +#else +vec2 yn_sqr = twoSqr(yn); +#endif +float diff = sub_fp64(a, yn_sqr).x; +vec2 prod = twoProd(x * 0.5, diff); +#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) +return sum_fp64(split(yn), prod); +#else +return sum_fp64(vec2(yn, 0.0), prod); +#endif +} +`; + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64.js +var CONST_UNIFORMS = { + // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND + ONE: 1 +}; +function getUniforms2() { + return CONST_UNIFORMS; +} +var fp64arithmetic = { + name: "fp64-arithmetic", + vs: fp64arithmeticShader, + getUniforms: getUniforms2, + fp64ify, + fp64LowPart, + fp64ifyMatrix4 +}; + +// node_modules/@math.gl/core/dist/lib/common.js +var RADIANS_TO_DEGREES = 1 / Math.PI * 180; +var DEGREES_TO_RADIANS = 1 / 180 * Math.PI; +var DEFAULT_CONFIG = { + EPSILON: 1e-12, + debug: false, + precision: 4, + printTypes: false, + printDegrees: false, + printRowMajor: true, + _cartographicRadians: false +}; +globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } }; +var config = globalThis.mathgl.config; +function formatValue(value, { precision = config.precision } = {}) { + value = round(value); + return `${parseFloat(value.toPrecision(precision))}`; +} +function isArray(value) { + return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); +} +function clamp(value, min7, max7) { + return map(value, (value2) => Math.max(min7, Math.min(max7, value2))); +} +function lerp(a, b, t) { + if (isArray(a)) { + return a.map((ai, i) => lerp(ai, b[i], t)); + } + return t * b + (1 - t) * a; +} +function equals(a, b, epsilon) { + const oldEpsilon = config.EPSILON; + if (epsilon) { + config.EPSILON = epsilon; + } + try { + if (a === b) { + return true; + } + if (isArray(a) && isArray(b)) { + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; ++i) { + if (!equals(a[i], b[i])) { + return false; + } + } + return true; + } + if (a && a.equals) { + return a.equals(b); + } + if (b && b.equals) { + return b.equals(a); + } + if (typeof a === "number" && typeof b === "number") { + return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b)); + } + return false; + } finally { + config.EPSILON = oldEpsilon; + } +} +function round(value) { + return Math.round(value / config.EPSILON) * config.EPSILON; +} +function duplicateArray(array) { + return array.clone ? array.clone() : new Array(array.length); +} +function map(value, func, result) { + if (isArray(value)) { + const array = value; + result = result || duplicateArray(array); + for (let i = 0; i < result.length && i < array.length; ++i) { + const val = typeof value === "number" ? value : value[i]; + result[i] = func(val, i, result); + } + return result; + } + return func(value); +} + +// node_modules/@math.gl/core/dist/classes/base/math-array.js +var MathArray = class extends Array { + // Common methods + /** + * Clone the current object + * @returns a new copy of this object + */ + clone() { + return new this.constructor().copy(this); + } + fromArray(array, offset = 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = array[i + offset]; + } + return this.check(); + } + toArray(targetArray = [], offset = 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + targetArray[offset + i] = this[i]; + } + return targetArray; + } + toObject(targetObject) { + return targetObject; + } + from(arrayOrObject) { + return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : ( + // @ts-ignore + this.fromObject(arrayOrObject) + ); + } + to(arrayOrObject) { + if (arrayOrObject === this) { + return this; + } + return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); + } + toTarget(target) { + return target ? this.to(target) : this; + } + /** @deprecated */ + toFloat32Array() { + return new Float32Array(this); + } + toString() { + return this.formatString(config); + } + /** Formats string according to options */ + formatString(opts) { + let string = ""; + for (let i = 0; i < this.ELEMENTS; ++i) { + string += (i > 0 ? ", " : "") + formatValue(this[i], opts); + } + return `${opts.printTypes ? this.constructor.name : ""}[${string}]`; + } + equals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i = 0; i < this.ELEMENTS; ++i) { + if (!equals(this[i], array[i])) { + return false; + } + } + return true; + } + exactEquals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i = 0; i < this.ELEMENTS; ++i) { + if (this[i] !== array[i]) { + return false; + } + } + return true; + } + // Modifiers + /** Negates all values in this object */ + negate() { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = -this[i]; + } + return this.check(); + } + lerp(a, b, t) { + if (t === void 0) { + return this.lerp(this, a, b); + } + for (let i = 0; i < this.ELEMENTS; ++i) { + const ai = a[i]; + const endValue = typeof b === "number" ? b : b[i]; + this[i] = ai + t * (endValue - ai); + } + return this.check(); + } + /** Minimal */ + min(vector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(vector[i], this[i]); + } + return this.check(); + } + /** Maximal */ + max(vector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.max(vector[i], this[i]); + } + return this.check(); + } + clamp(minVector, maxVector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]); + } + return this.check(); + } + add(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] += vector[i]; + } + } + return this.check(); + } + subtract(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] -= vector[i]; + } + } + return this.check(); + } + scale(scale13) { + if (typeof scale13 === "number") { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scale13; + } + } else { + for (let i = 0; i < this.ELEMENTS && i < scale13.length; ++i) { + this[i] *= scale13[i]; + } + } + return this.check(); + } + /** + * Multiplies all elements by `scale` + * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor" + */ + multiplyByScalar(scalar) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scalar; + } + return this.check(); + } + // Debug checks + /** Throws an error if array length is incorrect or contains illegal values */ + check() { + if (config.debug && !this.validate()) { + throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`); + } + return this; + } + /** Returns false if the array length is incorrect or contains illegal values */ + validate() { + let valid = this.length === this.ELEMENTS; + for (let i = 0; i < this.ELEMENTS; ++i) { + valid = valid && Number.isFinite(this[i]); + } + return valid; + } + // three.js compatibility + /** @deprecated */ + sub(a) { + return this.subtract(a); + } + /** @deprecated */ + setScalar(a) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = a; + } + return this.check(); + } + /** @deprecated */ + addScalar(a) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] += a; + } + return this.check(); + } + /** @deprecated */ + subScalar(a) { + return this.addScalar(-a); + } + /** @deprecated */ + multiplyScalar(scalar) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scalar; + } + return this.check(); + } + /** @deprecated */ + divideScalar(a) { + return this.multiplyByScalar(1 / a); + } + /** @deprecated */ + clampScalar(min7, max7) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(Math.max(this[i], min7), max7); + } + return this.check(); + } + /** @deprecated */ + get elements() { + return this; + } +}; + +// node_modules/@math.gl/core/dist/lib/validators.js +function validateVector(v, length10) { + if (v.length !== length10) { + return false; + } + for (let i = 0; i < v.length; ++i) { + if (!Number.isFinite(v[i])) { + return false; + } + } + return true; +} +function checkNumber(value) { + if (!Number.isFinite(value)) { + throw new Error(`Invalid number ${JSON.stringify(value)}`); + } + return value; +} +function checkVector(v, length10, callerName = "") { + if (config.debug && !validateVector(v, length10)) { + throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`); + } + return v; +} + +// node_modules/@math.gl/core/dist/lib/assert.js +function assert7(condition, message2) { + if (!condition) { + throw new Error(`math.gl assertion ${message2}`); + } +} + +// node_modules/@math.gl/core/dist/classes/base/vector.js +var Vector = class extends MathArray { + // ACCESSORS + get x() { + return this[0]; + } + set x(value) { + this[0] = checkNumber(value); + } + get y() { + return this[1]; + } + set y(value) { + this[1] = checkNumber(value); + } + /** + * Returns the length of the vector from the origin to the point described by this vector + * + * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements + * Instead we provide `len` and `magnitude` + */ + len() { + return Math.sqrt(this.lengthSquared()); + } + /** + * Returns the length of the vector from the origin to the point described by this vector + */ + magnitude() { + return this.len(); + } + /** + * Returns the squared length of the vector from the origin to the point described by this vector + */ + lengthSquared() { + let length10 = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + length10 += this[i] * this[i]; + } + return length10; + } + /** + * Returns the squared length of the vector from the origin to the point described by this vector + */ + magnitudeSquared() { + return this.lengthSquared(); + } + distance(mathArray) { + return Math.sqrt(this.distanceSquared(mathArray)); + } + distanceSquared(mathArray) { + let length10 = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + const dist7 = this[i] - mathArray[i]; + length10 += dist7 * dist7; + } + return checkNumber(length10); + } + dot(mathArray) { + let product = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + product += this[i] * mathArray[i]; + } + return checkNumber(product); + } + // MODIFIERS + normalize() { + const length10 = this.magnitude(); + if (length10 !== 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] /= length10; + } + } + return this.check(); + } + multiply(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= vector[i]; + } + } + return this.check(); + } + divide(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] /= vector[i]; + } + } + return this.check(); + } + // THREE.js compatibility + lengthSq() { + return this.lengthSquared(); + } + distanceTo(vector) { + return this.distance(vector); + } + distanceToSquared(vector) { + return this.distanceSquared(vector); + } + getComponent(i) { + assert7(i >= 0 && i < this.ELEMENTS, "index is out of range"); + return checkNumber(this[i]); + } + setComponent(i, value) { + assert7(i >= 0 && i < this.ELEMENTS, "index is out of range"); + this[i] = value; + return this.check(); + } + addVectors(a, b) { + return this.copy(a).add(b); + } + subVectors(a, b) { + return this.copy(a).subtract(b); + } + multiplyVectors(a, b) { + return this.copy(a).multiply(b); + } + addScaledVector(a, b) { + return this.add(new this.constructor(a).multiplyScalar(b)); + } +}; + +// node_modules/@math.gl/core/dist/gl-matrix/vec2.js +var vec2_exports = {}; +__export(vec2_exports, { + add: () => add, + angle: () => angle, + ceil: () => ceil, + clone: () => clone, + copy: () => copy, + create: () => create, + cross: () => cross, + dist: () => dist, + distance: () => distance, + div: () => div, + divide: () => divide, + dot: () => dot, + equals: () => equals2, + exactEquals: () => exactEquals, + floor: () => floor, + forEach: () => forEach2, + fromValues: () => fromValues, + inverse: () => inverse, + len: () => len, + length: () => length, + lerp: () => lerp2, + max: () => max, + min: () => min, + mul: () => mul, + multiply: () => multiply, + negate: () => negate, + normalize: () => normalize, + random: () => random, + rotate: () => rotate, + round: () => round3, + scale: () => scale, + scaleAndAdd: () => scaleAndAdd, + set: () => set, + sqrDist: () => sqrDist, + sqrLen: () => sqrLen, + squaredDistance: () => squaredDistance, + squaredLength: () => squaredLength, + str: () => str, + sub: () => sub, + subtract: () => subtract, + transformMat2: () => transformMat2, + transformMat2d: () => transformMat2d, + transformMat3: () => transformMat3, + transformMat4: () => transformMat4, + zero: () => zero +}); + +// node_modules/@math.gl/core/dist/gl-matrix/common.js +var EPSILON = 1e-6; +var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array; +var RANDOM = Math.random; +function round2(a) { + if (a >= 0) + return Math.round(a); + return a % 0.5 === 0 ? Math.floor(a) : Math.round(a); +} +var degree = Math.PI / 180; + +// node_modules/@math.gl/core/dist/gl-matrix/vec2.js +function create() { + const out = new ARRAY_TYPE(2); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + } + return out; +} +function clone(a) { + const out = new ARRAY_TYPE(2); + out[0] = a[0]; + out[1] = a[1]; + return out; +} +function fromValues(x, y) { + const out = new ARRAY_TYPE(2); + out[0] = x; + out[1] = y; + return out; +} +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + return out; +} +function set(out, x, y) { + out[0] = x; + out[1] = y; + return out; +} +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + return out; +} +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + return out; +} +function multiply(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + return out; +} +function divide(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + return out; +} +function ceil(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + return out; +} +function floor(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + return out; +} +function min(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + return out; +} +function max(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + return out; +} +function round3(out, a) { + out[0] = round2(a[0]); + out[1] = round2(a[1]); + return out; +} +function scale(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + return out; +} +function scaleAndAdd(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + return out; +} +function distance(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + return Math.sqrt(x * x + y * y); +} +function squaredDistance(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + return x * x + y * y; +} +function length(a) { + const x = a[0]; + const y = a[1]; + return Math.sqrt(x * x + y * y); +} +function squaredLength(a) { + const x = a[0]; + const y = a[1]; + return x * x + y * y; +} +function negate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + return out; +} +function inverse(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + return out; +} +function normalize(out, a) { + const x = a[0]; + const y = a[1]; + let len8 = x * x + y * y; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = a[0] * len8; + out[1] = a[1] * len8; + return out; +} +function dot(a, b) { + return a[0] * b[0] + a[1] * b[1]; +} +function cross(out, a, b) { + const z = a[0] * b[1] - a[1] * b[0]; + out[0] = out[1] = 0; + out[2] = z; + return out; +} +function lerp2(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + return out; +} +function random(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + const r = RANDOM() * 2 * Math.PI; + out[0] = Math.cos(r) * scale13; + out[1] = Math.sin(r) * scale13; + return out; +} +function transformMat2(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + return out; +} +function transformMat2d(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y + m[4]; + out[1] = m[1] * x + m[3] * y + m[5]; + return out; +} +function transformMat3(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[3] * y + m[6]; + out[1] = m[1] * x + m[4] * y + m[7]; + return out; +} +function transformMat4(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[4] * y + m[12]; + out[1] = m[1] * x + m[5] * y + m[13]; + return out; +} +function rotate(out, a, b, rad) { + const p0 = a[0] - b[0]; + const p1 = a[1] - b[1]; + const sinC = Math.sin(rad); + const cosC = Math.cos(rad); + out[0] = p0 * cosC - p1 * sinC + b[0]; + out[1] = p0 * sinC + p1 * cosC + b[1]; + return out; +} +function angle(a, b) { + const x1 = a[0]; + const y1 = a[1]; + const x2 = b[0]; + const y2 = b[1]; + const mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)); + const cosine = mag && (x1 * x2 + y1 * y2) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); +} +function zero(out) { + out[0] = 0; + out[1] = 0; + return out; +} +function str(a) { + return `vec2(${a[0]}, ${a[1]})`; +} +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1]; +} +function equals2(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const b0 = b[0]; + const b1 = b[1]; + return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)); +} +var len = length; +var sub = subtract; +var mul = multiply; +var div = divide; +var dist = distance; +var sqrDist = squaredDistance; +var sqrLen = squaredLength; +var forEach2 = function() { + const vec = create(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 2; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + } + return a; + }; +}(); + +// node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js +function vec2_transformMat4AsVector(out, a, m) { + const x = a[0]; + const y = a[1]; + const w = m[3] * x + m[7] * y || 1; + out[0] = (m[0] * x + m[4] * y) / w; + out[1] = (m[1] * x + m[5] * y) / w; + return out; +} +function vec3_transformMat4AsVector(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = m[3] * x + m[7] * y + m[11] * z || 1; + out[0] = (m[0] * x + m[4] * y + m[8] * z) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z) / w; + return out; +} +function vec3_transformMat2(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + out[2] = a[2]; + return out; +} + +// node_modules/@math.gl/core/dist/gl-matrix/vec3.js +var vec3_exports = {}; +__export(vec3_exports, { + add: () => add2, + angle: () => angle2, + bezier: () => bezier, + ceil: () => ceil2, + clone: () => clone2, + copy: () => copy2, + create: () => create2, + cross: () => cross2, + dist: () => dist2, + distance: () => distance2, + div: () => div2, + divide: () => divide2, + dot: () => dot2, + equals: () => equals3, + exactEquals: () => exactEquals2, + floor: () => floor2, + forEach: () => forEach3, + fromValues: () => fromValues2, + hermite: () => hermite, + inverse: () => inverse2, + len: () => len2, + length: () => length2, + lerp: () => lerp3, + max: () => max2, + min: () => min2, + mul: () => mul2, + multiply: () => multiply2, + negate: () => negate2, + normalize: () => normalize2, + random: () => random2, + rotateX: () => rotateX, + rotateY: () => rotateY, + rotateZ: () => rotateZ, + round: () => round4, + scale: () => scale2, + scaleAndAdd: () => scaleAndAdd2, + set: () => set2, + slerp: () => slerp, + sqrDist: () => sqrDist2, + sqrLen: () => sqrLen2, + squaredDistance: () => squaredDistance2, + squaredLength: () => squaredLength2, + str: () => str2, + sub: () => sub2, + subtract: () => subtract2, + transformMat3: () => transformMat32, + transformMat4: () => transformMat42, + transformQuat: () => transformQuat, + zero: () => zero2 +}); +function create2() { + const out = new ARRAY_TYPE(3); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} +function clone2(a) { + const out = new ARRAY_TYPE(3); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} +function length2(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function fromValues2(x, y, z) { + const out = new ARRAY_TYPE(3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function copy2(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} +function set2(out, x, y, z) { + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function add2(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + return out; +} +function subtract2(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + return out; +} +function multiply2(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + return out; +} +function divide2(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + return out; +} +function ceil2(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + return out; +} +function floor2(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + return out; +} +function min2(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + return out; +} +function max2(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + return out; +} +function round4(out, a) { + out[0] = round2(a[0]); + out[1] = round2(a[1]); + out[2] = round2(a[2]); + return out; +} +function scale2(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + return out; +} +function scaleAndAdd2(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + return out; +} +function distance2(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function squaredDistance2(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + return x * x + y * y + z * z; +} +function squaredLength2(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + return x * x + y * y + z * z; +} +function negate2(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + return out; +} +function inverse2(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + out[2] = 1 / a[2]; + return out; +} +function normalize2(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let len8 = x * x + y * y + z * z; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = a[0] * len8; + out[1] = a[1] * len8; + out[2] = a[2] * len8; + return out; +} +function dot2(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +function cross2(out, a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} +function lerp3(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + return out; +} +function slerp(out, a, b, t) { + const angle6 = Math.acos(Math.min(Math.max(dot2(a, b), -1), 1)); + const sinTotal = Math.sin(angle6); + const ratioA = Math.sin((1 - t) * angle6) / sinTotal; + const ratioB = Math.sin(t * angle6) / sinTotal; + out[0] = ratioA * a[0] + ratioB * b[0]; + out[1] = ratioA * a[1] + ratioB * b[1]; + out[2] = ratioA * a[2] + ratioB * b[2]; + return out; +} +function hermite(out, a, b, c, d, t) { + const factorTimes2 = t * t; + const factor1 = factorTimes2 * (2 * t - 3) + 1; + const factor2 = factorTimes2 * (t - 2) + t; + const factor3 = factorTimes2 * (t - 1); + const factor4 = factorTimes2 * (3 - 2 * t); + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + return out; +} +function bezier(out, a, b, c, d, t) { + const inverseFactor = 1 - t; + const inverseFactorTimesTwo = inverseFactor * inverseFactor; + const factorTimes2 = t * t; + const factor1 = inverseFactorTimesTwo * inverseFactor; + const factor2 = 3 * t * inverseFactorTimesTwo; + const factor3 = 3 * factorTimes2 * inverseFactor; + const factor4 = factorTimes2 * t; + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + return out; +} +function random2(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + const r = RANDOM() * 2 * Math.PI; + const z = RANDOM() * 2 - 1; + const zScale = Math.sqrt(1 - z * z) * scale13; + out[0] = Math.cos(r) * zScale; + out[1] = Math.sin(r) * zScale; + out[2] = z * scale13; + return out; +} +function transformMat42(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let w = m[3] * x + m[7] * y + m[11] * z + m[15]; + w = w || 1; + out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; + return out; +} +function transformMat32(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + out[0] = x * m[0] + y * m[3] + z * m[6]; + out[1] = x * m[1] + y * m[4] + z * m[7]; + out[2] = x * m[2] + y * m[5] + z * m[8]; + return out; +} +function transformQuat(out, a, q) { + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const x = a[0]; + const y = a[1]; + const z = a[2]; + let uvx = qy * z - qz * y; + let uvy = qz * x - qx * z; + let uvz = qx * y - qy * x; + let uuvx = qy * uvz - qz * uvy; + let uuvy = qz * uvx - qx * uvz; + let uuvz = qx * uvy - qy * uvx; + const w2 = qw * 2; + uvx *= w2; + uvy *= w2; + uvz *= w2; + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + out[0] = x + uvx + uuvx; + out[1] = y + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; +} +function rotateX(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0]; + r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); + r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateY(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); + r[1] = p[1]; + r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateZ(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); + r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); + r[2] = p[2]; + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function angle2(a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); + const cosine = mag && dot2(a, b) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); +} +function zero2(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + return out; +} +function str2(a) { + return `vec3(${a[0]}, ${a[1]}, ${a[2]})`; +} +function exactEquals2(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]; +} +function equals3(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)); +} +var sub2 = subtract2; +var mul2 = multiply2; +var div2 = divide2; +var dist2 = distance2; +var sqrDist2 = squaredDistance2; +var len2 = length2; +var sqrLen2 = squaredLength2; +var forEach3 = function() { + const vec = create2(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 3; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + } + return a; + }; +}(); + +// node_modules/@math.gl/core/dist/classes/vector3.js +var ORIGIN = [0, 0, 0]; +var ZERO; +var Vector3 = class _Vector3 extends Vector { + static get ZERO() { + if (!ZERO) { + ZERO = new _Vector3(0, 0, 0); + Object.freeze(ZERO); + } + return ZERO; + } + /** + * @class + * @param x + * @param y + * @param z + */ + constructor(x = 0, y = 0, z = 0) { + super(-0, -0, -0); + if (arguments.length === 1 && isArray(x)) { + this.copy(x); + } else { + if (config.debug) { + checkNumber(x); + checkNumber(y); + checkNumber(z); + } + this[0] = x; + this[1] = y; + this[2] = z; + } + } + set(x, y, z) { + this[0] = x; + this[1] = y; + this[2] = z; + return this.check(); + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + return this.check(); + } + fromObject(object) { + if (config.debug) { + checkNumber(object.x); + checkNumber(object.y); + checkNumber(object.z); + } + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + return this.check(); + } + toObject(object) { + object.x = this[0]; + object.y = this[1]; + object.z = this[2]; + return object; + } + // Getters/setters + get ELEMENTS() { + return 3; + } + get z() { + return this[2]; + } + set z(value) { + this[2] = checkNumber(value); + } + // ACCESSORS + angle(vector) { + return angle2(this, vector); + } + // MODIFIERS + cross(vector) { + cross2(this, this, vector); + return this.check(); + } + rotateX({ radians: radians3, origin = ORIGIN }) { + rotateX(this, this, origin, radians3); + return this.check(); + } + rotateY({ radians: radians3, origin = ORIGIN }) { + rotateY(this, this, origin, radians3); + return this.check(); + } + rotateZ({ radians: radians3, origin = ORIGIN }) { + rotateZ(this, this, origin, radians3); + return this.check(); + } + // Transforms + // transforms as point (4th component is implicitly 1) + transform(matrix4) { + return this.transformAsPoint(matrix4); + } + // transforms as point (4th component is implicitly 1) + transformAsPoint(matrix4) { + transformMat42(this, this, matrix4); + return this.check(); + } + // transforms as vector (4th component is implicitly 0, ignores translation. slightly faster) + transformAsVector(matrix4) { + vec3_transformMat4AsVector(this, this, matrix4); + return this.check(); + } + transformByMatrix3(matrix3) { + transformMat32(this, this, matrix3); + return this.check(); + } + transformByMatrix2(matrix2) { + vec3_transformMat2(this, this, matrix2); + return this.check(); + } + transformByQuaternion(quaternion) { + transformQuat(this, this, quaternion); + return this.check(); + } +}; + +// node_modules/@math.gl/core/dist/classes/base/matrix.js +var Matrix = class extends MathArray { + // fromObject(object) { + // const array = object.elements; + // return this.fromRowMajor(array); + // } + // toObject(object) { + // const array = object.elements; + // this.toRowMajor(array); + // return object; + // } + // TODO better override formatString? + toString() { + let string = "["; + if (config.printRowMajor) { + string += "row-major:"; + for (let row = 0; row < this.RANK; ++row) { + for (let col = 0; col < this.RANK; ++col) { + string += ` ${this[col * this.RANK + row]}`; + } + } + } else { + string += "column-major:"; + for (let i = 0; i < this.ELEMENTS; ++i) { + string += ` ${this[i]}`; + } + } + string += "]"; + return string; + } + getElementIndex(row, col) { + return col * this.RANK + row; + } + // By default assumes row major indices + getElement(row, col) { + return this[col * this.RANK + row]; + } + // By default assumes row major indices + setElement(row, col, value) { + this[col * this.RANK + row] = checkNumber(value); + return this; + } + getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { + const firstIndex = columnIndex * this.RANK; + for (let i = 0; i < this.RANK; ++i) { + result[i] = this[firstIndex + i]; + } + return result; + } + setColumn(columnIndex, columnVector) { + const firstIndex = columnIndex * this.RANK; + for (let i = 0; i < this.RANK; ++i) { + this[firstIndex + i] = columnVector[i]; + } + return this; + } +}; + +// node_modules/@math.gl/core/dist/gl-matrix/mat4.js +var mat4_exports = {}; +__export(mat4_exports, { + add: () => add3, + adjoint: () => adjoint, + clone: () => clone3, + copy: () => copy3, + create: () => create3, + decompose: () => decompose, + determinant: () => determinant, + equals: () => equals4, + exactEquals: () => exactEquals3, + frob: () => frob, + fromQuat: () => fromQuat, + fromQuat2: () => fromQuat2, + fromRotation: () => fromRotation, + fromRotationTranslation: () => fromRotationTranslation, + fromRotationTranslationScale: () => fromRotationTranslationScale, + fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin, + fromScaling: () => fromScaling, + fromTranslation: () => fromTranslation, + fromValues: () => fromValues3, + fromXRotation: () => fromXRotation, + fromYRotation: () => fromYRotation, + fromZRotation: () => fromZRotation, + frustum: () => frustum, + getRotation: () => getRotation, + getScaling: () => getScaling, + getTranslation: () => getTranslation, + identity: () => identity, + invert: () => invert, + lookAt: () => lookAt, + mul: () => mul3, + multiply: () => multiply3, + multiplyScalar: () => multiplyScalar, + multiplyScalarAndAdd: () => multiplyScalarAndAdd, + ortho: () => ortho, + orthoNO: () => orthoNO, + orthoZO: () => orthoZO, + perspective: () => perspective, + perspectiveFromFieldOfView: () => perspectiveFromFieldOfView, + perspectiveNO: () => perspectiveNO, + perspectiveZO: () => perspectiveZO, + rotate: () => rotate2, + rotateX: () => rotateX2, + rotateY: () => rotateY2, + rotateZ: () => rotateZ2, + scale: () => scale3, + set: () => set3, + str: () => str3, + sub: () => sub3, + subtract: () => subtract3, + targetTo: () => targetTo, + translate: () => translate, + transpose: () => transpose +}); +function create3() { + const out = new ARRAY_TYPE(16); + if (ARRAY_TYPE != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + } + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out; +} +function clone3(a) { + const out = new ARRAY_TYPE(16); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function copy3(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function fromValues3(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + const out = new ARRAY_TYPE(16); + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function set3(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function transpose(out, a) { + if (out === a) { + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a12 = a[6]; + const a13 = a[7]; + const a23 = a[11]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a01; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a02; + out[9] = a12; + out[11] = a[14]; + out[12] = a03; + out[13] = a13; + out[14] = a23; + } else { + out[0] = a[0]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a[1]; + out[5] = a[5]; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a[2]; + out[9] = a[6]; + out[10] = a[10]; + out[11] = a[14]; + out[12] = a[3]; + out[13] = a[7]; + out[14] = a[11]; + out[15] = a[15]; + } + return out; +} +function invert(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; + } + det = 1 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; +} +function adjoint(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + out[0] = a11 * b11 - a12 * b10 + a13 * b09; + out[1] = a02 * b10 - a01 * b11 - a03 * b09; + out[2] = a31 * b05 - a32 * b04 + a33 * b03; + out[3] = a22 * b04 - a21 * b05 - a23 * b03; + out[4] = a12 * b08 - a10 * b11 - a13 * b07; + out[5] = a00 * b11 - a02 * b08 + a03 * b07; + out[6] = a32 * b02 - a30 * b05 - a33 * b01; + out[7] = a20 * b05 - a22 * b02 + a23 * b01; + out[8] = a10 * b10 - a11 * b08 + a13 * b06; + out[9] = a01 * b08 - a00 * b10 - a03 * b06; + out[10] = a30 * b04 - a31 * b02 + a33 * b00; + out[11] = a21 * b02 - a20 * b04 - a23 * b00; + out[12] = a11 * b07 - a10 * b09 - a12 * b06; + out[13] = a00 * b09 - a01 * b07 + a02 * b06; + out[14] = a31 * b01 - a30 * b03 - a32 * b00; + out[15] = a20 * b03 - a21 * b01 + a22 * b00; + return out; +} +function determinant(a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b0 = a00 * a11 - a01 * a10; + const b1 = a00 * a12 - a02 * a10; + const b2 = a01 * a12 - a02 * a11; + const b3 = a20 * a31 - a21 * a30; + const b4 = a20 * a32 - a22 * a30; + const b5 = a21 * a32 - a22 * a31; + const b6 = a00 * b5 - a01 * b4 + a02 * b3; + const b7 = a10 * b5 - a11 * b4 + a12 * b3; + const b8 = a20 * b2 - a21 * b1 + a22 * b0; + const b9 = a30 * b2 - a31 * b1 + a32 * b0; + return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; +} +function multiply3(out, a, b) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + let b0 = b[0]; + let b1 = b[1]; + let b2 = b[2]; + let b3 = b[3]; + out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[4]; + b1 = b[5]; + b2 = b[6]; + b3 = b[7]; + out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[8]; + b1 = b[9]; + b2 = b[10]; + b3 = b[11]; + out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[12]; + b1 = b[13]; + b2 = b[14]; + b3 = b[15]; + out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + return out; +} +function translate(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + if (a === out) { + out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; + out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; + out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; + out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; + } else { + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a03; + out[4] = a10; + out[5] = a11; + out[6] = a12; + out[7] = a13; + out[8] = a20; + out[9] = a21; + out[10] = a22; + out[11] = a23; + out[12] = a00 * x + a10 * y + a20 * z + a[12]; + out[13] = a01 * x + a11 * y + a21 * z + a[13]; + out[14] = a02 * x + a12 * y + a22 * z + a[14]; + out[15] = a03 * x + a13 * y + a23 * z + a[15]; + } + return out; +} +function scale3(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + out[0] = a[0] * x; + out[1] = a[1] * x; + out[2] = a[2] * x; + out[3] = a[3] * x; + out[4] = a[4] * y; + out[5] = a[5] * y; + out[6] = a[6] * y; + out[7] = a[7] * y; + out[8] = a[8] * z; + out[9] = a[9] * z; + out[10] = a[10] * z; + out[11] = a[11] * z; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function rotate2(out, a, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + let b00; + let b01; + let b02; + let b10; + let b11; + let b12; + let b20; + let b21; + let b22; + if (len8 < EPSILON) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + b00 = x * x * t + c; + b01 = y * x * t + z * s; + b02 = z * x * t - y * s; + b10 = x * y * t - z * s; + b11 = y * y * t + c; + b12 = z * y * t + x * s; + b20 = x * z * t + y * s; + b21 = y * z * t - x * s; + b22 = z * z * t + c; + out[0] = a00 * b00 + a10 * b01 + a20 * b02; + out[1] = a01 * b00 + a11 * b01 + a21 * b02; + out[2] = a02 * b00 + a12 * b01 + a22 * b02; + out[3] = a03 * b00 + a13 * b01 + a23 * b02; + out[4] = a00 * b10 + a10 * b11 + a20 * b12; + out[5] = a01 * b10 + a11 * b11 + a21 * b12; + out[6] = a02 * b10 + a12 * b11 + a22 * b12; + out[7] = a03 * b10 + a13 * b11 + a23 * b12; + out[8] = a00 * b20 + a10 * b21 + a20 * b22; + out[9] = a01 * b20 + a11 * b21 + a21 * b22; + out[10] = a02 * b20 + a12 * b21 + a22 * b22; + out[11] = a03 * b20 + a13 * b21 + a23 * b22; + if (a !== out) { + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + return out; +} +function rotateX2(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[4] = a10 * c + a20 * s; + out[5] = a11 * c + a21 * s; + out[6] = a12 * c + a22 * s; + out[7] = a13 * c + a23 * s; + out[8] = a20 * c - a10 * s; + out[9] = a21 * c - a11 * s; + out[10] = a22 * c - a12 * s; + out[11] = a23 * c - a13 * s; + return out; +} +function rotateY2(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c - a20 * s; + out[1] = a01 * c - a21 * s; + out[2] = a02 * c - a22 * s; + out[3] = a03 * c - a23 * s; + out[8] = a00 * s + a20 * c; + out[9] = a01 * s + a21 * c; + out[10] = a02 * s + a22 * c; + out[11] = a03 * s + a23 * c; + return out; +} +function rotateZ2(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + if (a !== out) { + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c + a10 * s; + out[1] = a01 * c + a11 * s; + out[2] = a02 * c + a12 * s; + out[3] = a03 * c + a13 * s; + out[4] = a10 * c - a00 * s; + out[5] = a11 * c - a01 * s; + out[6] = a12 * c - a02 * s; + out[7] = a13 * c - a03 * s; + return out; +} +function fromTranslation(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromScaling(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = v[1]; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = v[2]; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotation(out, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + if (len8 < EPSILON) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + out[0] = x * x * t + c; + out[1] = y * x * t + z * s; + out[2] = z * x * t - y * s; + out[3] = 0; + out[4] = x * y * t - z * s; + out[5] = y * y * t + c; + out[6] = z * y * t + x * s; + out[7] = 0; + out[8] = x * z * t + y * s; + out[9] = y * z * t - x * s; + out[10] = z * z * t + c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromXRotation(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = c; + out[6] = s; + out[7] = 0; + out[8] = 0; + out[9] = -s; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromYRotation(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = 0; + out[2] = -s; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = s; + out[9] = 0; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromZRotation(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = s; + out[2] = 0; + out[3] = 0; + out[4] = -s; + out[5] = c; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotationTranslation(out, q, v) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromQuat2(out, a) { + const translation = new ARRAY_TYPE(3); + const bx = -a[0]; + const by = -a[1]; + const bz = -a[2]; + const bw = a[3]; + const ax = a[4]; + const ay = a[5]; + const az = a[6]; + const aw = a[7]; + const magnitude = bx * bx + by * by + bz * bz + bw * bw; + if (magnitude > 0) { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; + } else { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; + } + fromRotationTranslation(out, a, translation); + return out; +} +function getTranslation(out, mat) { + out[0] = mat[12]; + out[1] = mat[13]; + out[2] = mat[14]; + return out; +} +function getScaling(out, mat) { + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + return out; +} +function getRotation(out, mat) { + const scaling = new ARRAY_TYPE(3); + getScaling(scaling, mat); + const is1 = 1 / scaling[0]; + const is2 = 1 / scaling[1]; + const is3 = 1 / scaling[2]; + const sm11 = mat[0] * is1; + const sm12 = mat[1] * is2; + const sm13 = mat[2] * is3; + const sm21 = mat[4] * is1; + const sm22 = mat[5] * is2; + const sm23 = mat[6] * is3; + const sm31 = mat[8] * is1; + const sm32 = mat[9] * is2; + const sm33 = mat[10] * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out[3] = 0.25 * S; + out[0] = (sm23 - sm32) / S; + out[1] = (sm31 - sm13) / S; + out[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out[3] = (sm23 - sm32) / S; + out[0] = 0.25 * S; + out[1] = (sm12 + sm21) / S; + out[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out[3] = (sm31 - sm13) / S; + out[0] = (sm12 + sm21) / S; + out[1] = 0.25 * S; + out[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out[3] = (sm12 - sm21) / S; + out[0] = (sm31 + sm13) / S; + out[1] = (sm23 + sm32) / S; + out[2] = 0.25 * S; + } + return out; +} +function decompose(out_r, out_t, out_s, mat) { + out_t[0] = mat[12]; + out_t[1] = mat[13]; + out_t[2] = mat[14]; + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + const is1 = 1 / out_s[0]; + const is2 = 1 / out_s[1]; + const is3 = 1 / out_s[2]; + const sm11 = m11 * is1; + const sm12 = m12 * is2; + const sm13 = m13 * is3; + const sm21 = m21 * is1; + const sm22 = m22 * is2; + const sm23 = m23 * is3; + const sm31 = m31 * is1; + const sm32 = m32 * is2; + const sm33 = m33 * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out_r[3] = 0.25 * S; + out_r[0] = (sm23 - sm32) / S; + out_r[1] = (sm31 - sm13) / S; + out_r[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out_r[3] = (sm23 - sm32) / S; + out_r[0] = 0.25 * S; + out_r[1] = (sm12 + sm21) / S; + out_r[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out_r[3] = (sm31 - sm13) / S; + out_r[0] = (sm12 + sm21) / S; + out_r[1] = 0.25 * S; + out_r[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out_r[3] = (sm12 - sm21) / S; + out_r[0] = (sm31 + sm13) / S; + out_r[1] = (sm23 + sm32) / S; + out_r[2] = 0.25 * S; + } + return out_r; +} +function fromRotationTranslationScale(out, q, v, s) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + out[0] = (1 - (yy + zz)) * sx; + out[1] = (xy + wz) * sx; + out[2] = (xz - wy) * sx; + out[3] = 0; + out[4] = (xy - wz) * sy; + out[5] = (1 - (xx + zz)) * sy; + out[6] = (yz + wx) * sy; + out[7] = 0; + out[8] = (xz + wy) * sz; + out[9] = (yz - wx) * sz; + out[10] = (1 - (xx + yy)) * sz; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromRotationTranslationScaleOrigin(out, q, v, s, o) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + const ox = o[0]; + const oy = o[1]; + const oz = o[2]; + const out0 = (1 - (yy + zz)) * sx; + const out1 = (xy + wz) * sx; + const out2 = (xz - wy) * sx; + const out4 = (xy - wz) * sy; + const out5 = (1 - (xx + zz)) * sy; + const out6 = (yz + wx) * sy; + const out8 = (xz + wy) * sz; + const out9 = (yz - wx) * sz; + const out10 = (1 - (xx + yy)) * sz; + out[0] = out0; + out[1] = out1; + out[2] = out2; + out[3] = 0; + out[4] = out4; + out[5] = out5; + out[6] = out6; + out[7] = 0; + out[8] = out8; + out[9] = out9; + out[10] = out10; + out[11] = 0; + out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); + out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); + out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); + out[15] = 1; + return out; +} +function fromQuat(out, q) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const yx = y * x2; + const yy = y * y2; + const zx = z * x2; + const zy = z * y2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - yy - zz; + out[1] = yx + wz; + out[2] = zx - wy; + out[3] = 0; + out[4] = yx - wz; + out[5] = 1 - xx - zz; + out[6] = zy + wx; + out[7] = 0; + out[8] = zx + wy; + out[9] = zy - wx; + out[10] = 1 - xx - yy; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function frustum(out, left, right, bottom, top, near, far) { + const rl = 1 / (right - left); + const tb = 1 / (top - bottom); + const nf = 1 / (near - far); + out[0] = near * 2 * rl; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = near * 2 * tb; + out[6] = 0; + out[7] = 0; + out[8] = (right + left) * rl; + out[9] = (top + bottom) * tb; + out[10] = (far + near) * nf; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near * 2 * nf; + out[15] = 0; + return out; +} +function perspectiveNO(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = 2 * far * near * nf; + } else { + out[10] = -1; + out[14] = -2 * near; + } + return out; +} +var perspective = perspectiveNO; +function perspectiveZO(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = far * nf; + out[14] = far * near * nf; + } else { + out[10] = -1; + out[14] = -near; + } + return out; +} +function perspectiveFromFieldOfView(out, fov, near, far) { + const upTan = Math.tan(fov.upDegrees * Math.PI / 180); + const downTan = Math.tan(fov.downDegrees * Math.PI / 180); + const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); + const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); + const xScale = 2 / (leftTan + rightTan); + const yScale = 2 / (upTan + downTan); + out[0] = xScale; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = yScale; + out[6] = 0; + out[7] = 0; + out[8] = -((leftTan - rightTan) * xScale * 0.5); + out[9] = (upTan - downTan) * yScale * 0.5; + out[10] = far / (near - far); + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near / (near - far); + out[15] = 0; + return out; +} +function orthoNO(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; +} +var ortho = orthoNO; +function orthoZO(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = near * nf; + out[15] = 1; + return out; +} +function lookAt(out, eye, center, up) { + let len8; + let x0; + let x1; + let x2; + let y0; + let y1; + let y2; + let z0; + let z1; + let z2; + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + const centerx = center[0]; + const centery = center[1]; + const centerz = center[2]; + if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) { + return identity(out); + } + z0 = eyex - centerx; + z1 = eyey - centery; + z2 = eyez - centerz; + len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); + z0 *= len8; + z1 *= len8; + z2 *= len8; + x0 = upy * z2 - upz * z1; + x1 = upz * z0 - upx * z2; + x2 = upx * z1 - upy * z0; + len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); + if (!len8) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len8 = 1 / len8; + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + y0 = z1 * x2 - z2 * x1; + y1 = z2 * x0 - z0 * x2; + y2 = z0 * x1 - z1 * x0; + len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); + if (!len8) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len8 = 1 / len8; + y0 *= len8; + y1 *= len8; + y2 *= len8; + } + out[0] = x0; + out[1] = y0; + out[2] = z0; + out[3] = 0; + out[4] = x1; + out[5] = y1; + out[6] = z1; + out[7] = 0; + out[8] = x2; + out[9] = y2; + out[10] = z2; + out[11] = 0; + out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); + out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); + out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); + out[15] = 1; + return out; +} +function targetTo(out, eye, target, up) { + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + let z0 = eyex - target[0]; + let z1 = eyey - target[1]; + let z2 = eyez - target[2]; + let len8 = z0 * z0 + z1 * z1 + z2 * z2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + z0 *= len8; + z1 *= len8; + z2 *= len8; + } + let x0 = upy * z2 - upz * z1; + let x1 = upz * z0 - upx * z2; + let x2 = upx * z1 - upy * z0; + len8 = x0 * x0 + x1 * x1 + x2 * x2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + out[0] = x0; + out[1] = x1; + out[2] = x2; + out[3] = 0; + out[4] = z1 * x2 - z2 * x1; + out[5] = z2 * x0 - z0 * x2; + out[6] = z0 * x1 - z1 * x0; + out[7] = 0; + out[8] = z0; + out[9] = z1; + out[10] = z2; + out[11] = 0; + out[12] = eyex; + out[13] = eyey; + out[14] = eyez; + out[15] = 1; + return out; +} +function str3(a) { + return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; +} +function frob(a) { + return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); +} +function add3(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + out[8] = a[8] + b[8]; + out[9] = a[9] + b[9]; + out[10] = a[10] + b[10]; + out[11] = a[11] + b[11]; + out[12] = a[12] + b[12]; + out[13] = a[13] + b[13]; + out[14] = a[14] + b[14]; + out[15] = a[15] + b[15]; + return out; +} +function subtract3(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + out[6] = a[6] - b[6]; + out[7] = a[7] - b[7]; + out[8] = a[8] - b[8]; + out[9] = a[9] - b[9]; + out[10] = a[10] - b[10]; + out[11] = a[11] - b[11]; + out[12] = a[12] - b[12]; + out[13] = a[13] - b[13]; + out[14] = a[14] - b[14]; + out[15] = a[15] - b[15]; + return out; +} +function multiplyScalar(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + out[8] = a[8] * b; + out[9] = a[9] * b; + out[10] = a[10] * b; + out[11] = a[11] * b; + out[12] = a[12] * b; + out[13] = a[13] * b; + out[14] = a[14] * b; + out[15] = a[15] * b; + return out; +} +function multiplyScalarAndAdd(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + out[3] = a[3] + b[3] * scale13; + out[4] = a[4] + b[4] * scale13; + out[5] = a[5] + b[5] * scale13; + out[6] = a[6] + b[6] * scale13; + out[7] = a[7] + b[7] * scale13; + out[8] = a[8] + b[8] * scale13; + out[9] = a[9] + b[9] * scale13; + out[10] = a[10] + b[10] * scale13; + out[11] = a[11] + b[11] * scale13; + out[12] = a[12] + b[12] * scale13; + out[13] = a[13] + b[13] * scale13; + out[14] = a[14] + b[14] * scale13; + out[15] = a[15] + b[15] * scale13; + return out; +} +function exactEquals3(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; +} +function equals4(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const a4 = a[4]; + const a5 = a[5]; + const a6 = a[6]; + const a7 = a[7]; + const a8 = a[8]; + const a9 = a[9]; + const a10 = a[10]; + const a11 = a[11]; + const a12 = a[12]; + const a13 = a[13]; + const a14 = a[14]; + const a15 = a[15]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + const b3 = b[3]; + const b4 = b[4]; + const b5 = b[5]; + const b6 = b[6]; + const b7 = b[7]; + const b8 = b[8]; + const b9 = b[9]; + const b10 = b[10]; + const b11 = b[11]; + const b12 = b[12]; + const b13 = b[13]; + const b14 = b[14]; + const b15 = b[15]; + return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1, Math.abs(a15), Math.abs(b15)); +} +var mul3 = multiply3; +var sub3 = subtract3; + +// node_modules/@math.gl/core/dist/gl-matrix/vec4.js +var vec4_exports = {}; +__export(vec4_exports, { + add: () => add4, + ceil: () => ceil3, + clone: () => clone4, + copy: () => copy4, + create: () => create4, + cross: () => cross3, + dist: () => dist3, + distance: () => distance3, + div: () => div3, + divide: () => divide3, + dot: () => dot3, + equals: () => equals5, + exactEquals: () => exactEquals4, + floor: () => floor3, + forEach: () => forEach4, + fromValues: () => fromValues4, + inverse: () => inverse3, + len: () => len3, + length: () => length3, + lerp: () => lerp4, + max: () => max3, + min: () => min3, + mul: () => mul4, + multiply: () => multiply4, + negate: () => negate3, + normalize: () => normalize3, + random: () => random3, + round: () => round5, + scale: () => scale4, + scaleAndAdd: () => scaleAndAdd3, + set: () => set4, + sqrDist: () => sqrDist3, + sqrLen: () => sqrLen3, + squaredDistance: () => squaredDistance3, + squaredLength: () => squaredLength3, + str: () => str4, + sub: () => sub4, + subtract: () => subtract4, + transformMat4: () => transformMat43, + transformQuat: () => transformQuat2, + zero: () => zero3 +}); +function create4() { + const out = new ARRAY_TYPE(4); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} +function clone4(a) { + const out = new ARRAY_TYPE(4); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function fromValues4(x, y, z, w) { + const out = new ARRAY_TYPE(4); + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} +function copy4(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function set4(out, x, y, z, w) { + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} +function add4(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + return out; +} +function subtract4(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + return out; +} +function multiply4(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + out[3] = a[3] * b[3]; + return out; +} +function divide3(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + out[3] = a[3] / b[3]; + return out; +} +function ceil3(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + out[3] = Math.ceil(a[3]); + return out; +} +function floor3(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + out[3] = Math.floor(a[3]); + return out; +} +function min3(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + out[3] = Math.min(a[3], b[3]); + return out; +} +function max3(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + out[3] = Math.max(a[3], b[3]); + return out; +} +function round5(out, a) { + out[0] = round2(a[0]); + out[1] = round2(a[1]); + out[2] = round2(a[2]); + out[3] = round2(a[3]); + return out; +} +function scale4(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + return out; +} +function scaleAndAdd3(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + out[3] = a[3] + b[3] * scale13; + return out; +} +function distance3(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + const w = b[3] - a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} +function squaredDistance3(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + const w = b[3] - a[3]; + return x * x + y * y + z * z + w * w; +} +function length3(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} +function squaredLength3(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return x * x + y * y + z * z + w * w; +} +function negate3(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = -a[3]; + return out; +} +function inverse3(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + out[2] = 1 / a[2]; + out[3] = 1 / a[3]; + return out; +} +function normalize3(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + let len8 = x * x + y * y + z * z + w * w; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = x * len8; + out[1] = y * len8; + out[2] = z * len8; + out[3] = w * len8; + return out; +} +function dot3(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; +} +function cross3(out, u, v, w) { + const A = v[0] * w[1] - v[1] * w[0]; + const B = v[0] * w[2] - v[2] * w[0]; + const C = v[0] * w[3] - v[3] * w[0]; + const D = v[1] * w[2] - v[2] * w[1]; + const E = v[1] * w[3] - v[3] * w[1]; + const F = v[2] * w[3] - v[3] * w[2]; + const G = u[0]; + const H = u[1]; + const I = u[2]; + const J = u[3]; + out[0] = H * F - I * E + J * D; + out[1] = -(G * F) + I * C - J * B; + out[2] = G * E - H * C + J * A; + out[3] = -(G * D) + H * B - I * A; + return out; +} +function lerp4(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + out[3] = aw + t * (b[3] - aw); + return out; +} +function random3(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + let v1; + let v2; + let v3; + let v4; + let s1; + let s2; + do { + v1 = RANDOM() * 2 - 1; + v2 = RANDOM() * 2 - 1; + s1 = v1 * v1 + v2 * v2; + } while (s1 >= 1); + do { + v3 = RANDOM() * 2 - 1; + v4 = RANDOM() * 2 - 1; + s2 = v3 * v3 + v4 * v4; + } while (s2 >= 1); + const d = Math.sqrt((1 - s1) / s2); + out[0] = scale13 * v1; + out[1] = scale13 * v2; + out[2] = scale13 * v3 * d; + out[3] = scale13 * v4 * d; + return out; +} +function transformMat43(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; + out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; + out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; + out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; + return out; +} +function transformQuat2(out, a, q) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const ix = qw * x + qy * z - qz * y; + const iy = qw * y + qz * x - qx * z; + const iz = qw * z + qx * y - qy * x; + const iw = -qx * x - qy * y - qz * z; + out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; + out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; + out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; + out[3] = a[3]; + return out; +} +function zero3(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + return out; +} +function str4(a) { + return `vec4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`; +} +function exactEquals4(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; +} +function equals5(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + const b3 = b[3]; + return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)); +} +var sub4 = subtract4; +var mul4 = multiply4; +var div3 = divide3; +var dist3 = distance3; +var sqrDist3 = squaredDistance3; +var len3 = length3; +var sqrLen3 = squaredLength3; +var forEach4 = function() { + const vec = create4(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 4; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + vec[3] = a[i + 3]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + a[i + 3] = vec[3]; + } + return a; + }; +}(); + +// node_modules/@math.gl/core/dist/classes/matrix4.js +var INDICES; +(function(INDICES3) { + INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; + INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; + INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; + INDICES3[INDICES3["COL0ROW3"] = 3] = "COL0ROW3"; + INDICES3[INDICES3["COL1ROW0"] = 4] = "COL1ROW0"; + INDICES3[INDICES3["COL1ROW1"] = 5] = "COL1ROW1"; + INDICES3[INDICES3["COL1ROW2"] = 6] = "COL1ROW2"; + INDICES3[INDICES3["COL1ROW3"] = 7] = "COL1ROW3"; + INDICES3[INDICES3["COL2ROW0"] = 8] = "COL2ROW0"; + INDICES3[INDICES3["COL2ROW1"] = 9] = "COL2ROW1"; + INDICES3[INDICES3["COL2ROW2"] = 10] = "COL2ROW2"; + INDICES3[INDICES3["COL2ROW3"] = 11] = "COL2ROW3"; + INDICES3[INDICES3["COL3ROW0"] = 12] = "COL3ROW0"; + INDICES3[INDICES3["COL3ROW1"] = 13] = "COL3ROW1"; + INDICES3[INDICES3["COL3ROW2"] = 14] = "COL3ROW2"; + INDICES3[INDICES3["COL3ROW3"] = 15] = "COL3ROW3"; +})(INDICES || (INDICES = {})); +var DEFAULT_FOVY = 45 * Math.PI / 180; +var DEFAULT_ASPECT = 1; +var DEFAULT_NEAR = 0.1; +var DEFAULT_FAR = 500; +var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); +var Matrix4 = class extends Matrix { + static get IDENTITY() { + return getIdentityMatrix(); + } + static get ZERO() { + return getZeroMatrix(); + } + get ELEMENTS() { + return 16; + } + get RANK() { + return 4; + } + get INDICES() { + return INDICES; + } + constructor(array) { + super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0); + if (arguments.length === 1 && Array.isArray(array)) { + this.copy(array); + } else { + this.identity(); + } + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + this[4] = array[4]; + this[5] = array[5]; + this[6] = array[6]; + this[7] = array[7]; + this[8] = array[8]; + this[9] = array[9]; + this[10] = array[10]; + this[11] = array[11]; + this[12] = array[12]; + this[13] = array[13]; + this[14] = array[14]; + this[15] = array[15]; + return this.check(); + } + // eslint-disable-next-line max-params + set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m30; + this[4] = m01; + this[5] = m11; + this[6] = m21; + this[7] = m31; + this[8] = m02; + this[9] = m12; + this[10] = m22; + this[11] = m32; + this[12] = m03; + this[13] = m13; + this[14] = m23; + this[15] = m33; + return this.check(); + } + // accepts row major order, stores as column major + // eslint-disable-next-line max-params + setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m30; + this[4] = m01; + this[5] = m11; + this[6] = m21; + this[7] = m31; + this[8] = m02; + this[9] = m12; + this[10] = m22; + this[11] = m32; + this[12] = m03; + this[13] = m13; + this[14] = m23; + this[15] = m33; + return this.check(); + } + toRowMajor(result) { + result[0] = this[0]; + result[1] = this[4]; + result[2] = this[8]; + result[3] = this[12]; + result[4] = this[1]; + result[5] = this[5]; + result[6] = this[9]; + result[7] = this[13]; + result[8] = this[2]; + result[9] = this[6]; + result[10] = this[10]; + result[11] = this[14]; + result[12] = this[3]; + result[13] = this[7]; + result[14] = this[11]; + result[15] = this[15]; + return result; + } + // Constructors + /** Set to identity matrix */ + identity() { + return this.copy(IDENTITY_MATRIX); + } + /** + * + * @param object + * @returns self + */ + // eslint-disable-next-line @typescript-eslint/no-unused-vars + fromObject(object) { + return this.check(); + } + /** + * Calculates a 4x4 matrix from the given quaternion + * @param quaternion Quaternion to create matrix from + * @returns self + */ + fromQuaternion(quaternion) { + fromQuat(this, quaternion); + return this.check(); + } + /** + * Generates a frustum matrix with the given bounds + * @param view.left - Left bound of the frustum + * @param view.right - Right bound of the frustum + * @param view.bottom - Bottom bound of the frustum + * @param view.top - Top bound of the frustum + * @param view.near - Near bound of the frustum + * @param view.far - Far bound of the frustum. Can be set to Infinity. + * @returns self + */ + frustum(view) { + const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; + if (far === Infinity) { + computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near); + } else { + frustum(this, left, right, bottom, top, near, far); + } + return this.check(); + } + /** + * Generates a look-at matrix with the given eye position, focal point, + * and up axis + * @param view.eye - (vector) Position of the viewer + * @param view.center - (vector) Point the viewer is looking at + * @param view.up - (vector) Up axis + * @returns self + */ + lookAt(view) { + const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view; + lookAt(this, eye, center, up); + return this.check(); + } + /** + * Generates a orthogonal projection matrix with the given bounds + * from "traditional" view space parameters + * @param view.left - Left bound of the frustum + * @param view.right number Right bound of the frustum + * @param view.bottom - Bottom bound of the frustum + * @param view.top number Top bound of the frustum + * @param view.near - Near bound of the frustum + * @param view.far number Far bound of the frustum + * @returns self + */ + ortho(view) { + const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; + ortho(this, left, right, bottom, top, near, far); + return this.check(); + } + /** + * Generates an orthogonal projection matrix with the same parameters + * as a perspective matrix (plus focalDistance) + * @param view.fovy Vertical field of view in radians + * @param view.aspect Aspect ratio. Typically viewport width / viewport height + * @param view.focalDistance Distance in the view frustum used for extent calculations + * @param view.near Near bound of the frustum + * @param view.far Far bound of the frustum + * @returns self + */ + orthographic(view) { + const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; + checkRadians(fovy); + const halfY = fovy / 2; + const top = focalDistance * Math.tan(halfY); + const right = top * aspect; + return this.ortho({ + left: -right, + right, + bottom: -top, + top, + near, + far + }); + } + /** + * Generates a perspective projection matrix with the given bounds + * @param view.fovy Vertical field of view in radians + * @param view.aspect Aspect ratio. typically viewport width/height + * @param view.near Near bound of the frustum + * @param view.far Far bound of the frustum + * @returns self + */ + perspective(view) { + const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view; + checkRadians(fovy); + perspective(this, fovy, aspect, near, far); + return this.check(); + } + // Accessors + determinant() { + return determinant(this); + } + /** + * Extracts the non-uniform scale assuming the matrix is an affine transformation. + * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix. + * @param result + * @returns self + */ + getScale(result = [-0, -0, -0]) { + result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]); + result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]); + result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]); + return result; + } + /** + * Gets the translation portion, assuming the matrix is a affine transformation matrix. + * @param result + * @returns self + */ + getTranslation(result = [-0, -0, -0]) { + result[0] = this[12]; + result[1] = this[13]; + result[2] = this[14]; + return result; + } + /** + * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix + * @param result + * @param scaleResult + * @returns self + */ + getRotation(result, scaleResult) { + result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0]; + scaleResult = scaleResult || [-0, -0, -0]; + const scale13 = this.getScale(scaleResult); + const inverseScale0 = 1 / scale13[0]; + const inverseScale1 = 1 / scale13[1]; + const inverseScale2 = 1 / scale13[2]; + result[0] = this[0] * inverseScale0; + result[1] = this[1] * inverseScale1; + result[2] = this[2] * inverseScale2; + result[3] = 0; + result[4] = this[4] * inverseScale0; + result[5] = this[5] * inverseScale1; + result[6] = this[6] * inverseScale2; + result[7] = 0; + result[8] = this[8] * inverseScale0; + result[9] = this[9] * inverseScale1; + result[10] = this[10] * inverseScale2; + result[11] = 0; + result[12] = 0; + result[13] = 0; + result[14] = 0; + result[15] = 1; + return result; + } + /** + * + * @param result + * @param scaleResult + * @returns self + */ + getRotationMatrix3(result, scaleResult) { + result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0]; + scaleResult = scaleResult || [-0, -0, -0]; + const scale13 = this.getScale(scaleResult); + const inverseScale0 = 1 / scale13[0]; + const inverseScale1 = 1 / scale13[1]; + const inverseScale2 = 1 / scale13[2]; + result[0] = this[0] * inverseScale0; + result[1] = this[1] * inverseScale1; + result[2] = this[2] * inverseScale2; + result[3] = this[4] * inverseScale0; + result[4] = this[5] * inverseScale1; + result[5] = this[6] * inverseScale2; + result[6] = this[8] * inverseScale0; + result[7] = this[9] * inverseScale1; + result[8] = this[10] * inverseScale2; + return result; + } + // Modifiers + transpose() { + transpose(this, this); + return this.check(); + } + invert() { + invert(this, this); + return this.check(); + } + // Operations + multiplyLeft(a) { + multiply3(this, a, this); + return this.check(); + } + multiplyRight(a) { + multiply3(this, this, a); + return this.check(); + } + // Rotates a matrix by the given angle around the X axis + rotateX(radians3) { + rotateX2(this, this, radians3); + return this.check(); + } + // Rotates a matrix by the given angle around the Y axis. + rotateY(radians3) { + rotateY2(this, this, radians3); + return this.check(); + } + /** + * Rotates a matrix by the given angle around the Z axis. + * @param radians + * @returns self + */ + rotateZ(radians3) { + rotateZ2(this, this, radians3); + return this.check(); + } + /** + * + * @param param0 + * @returns self + */ + rotateXYZ(angleXYZ) { + return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]); + } + /** + * + * @param radians + * @param axis + * @returns self + */ + rotateAxis(radians3, axis) { + rotate2(this, this, radians3, axis); + return this.check(); + } + /** + * + * @param factor + * @returns self + */ + scale(factor) { + scale3(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]); + return this.check(); + } + /** + * + * @param vec + * @returns self + */ + translate(vector) { + translate(this, this, vector); + return this.check(); + } + // Transforms + /** + * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points + * @param vector + * @param result + * @returns self + */ + transform(vector, result) { + if (vector.length === 4) { + result = transformMat43(result || [-0, -0, -0, -0], vector, this); + checkVector(result, 4); + return result; + } + return this.transformAsPoint(vector, result); + } + /** + * Transforms any 2 or 3 element array as point (w implicitly 1) + * @param vector + * @param result + * @returns self + */ + transformAsPoint(vector, result) { + const { length: length10 } = vector; + let out; + switch (length10) { + case 2: + out = transformMat4(result || [-0, -0], vector, this); + break; + case 3: + out = transformMat42(result || [-0, -0, -0], vector, this); + break; + default: + throw new Error("Illegal vector"); + } + checkVector(out, vector.length); + return out; + } + /** + * Transforms any 2 or 3 element array as vector (w implicitly 0) + * @param vector + * @param result + * @returns self + */ + transformAsVector(vector, result) { + let out; + switch (vector.length) { + case 2: + out = vec2_transformMat4AsVector(result || [-0, -0], vector, this); + break; + case 3: + out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this); + break; + default: + throw new Error("Illegal vector"); + } + checkVector(out, vector.length); + return out; + } + /** @deprecated */ + transformPoint(vector, result) { + return this.transformAsPoint(vector, result); + } + /** @deprecated */ + transformVector(vector, result) { + return this.transformAsPoint(vector, result); + } + /** @deprecated */ + transformDirection(vector, result) { + return this.transformAsVector(vector, result); + } + // three.js math API compatibility + makeRotationX(radians3) { + return this.identity().rotateX(radians3); + } + makeTranslation(x, y, z) { + return this.identity().translate([x, y, z]); + } +}; +var ZERO2; +var IDENTITY; +function getZeroMatrix() { + if (!ZERO2) { + ZERO2 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + Object.freeze(ZERO2); + } + return ZERO2; +} +function getIdentityMatrix() { + if (!IDENTITY) { + IDENTITY = new Matrix4(); + Object.freeze(IDENTITY); + } + return IDENTITY; +} +function checkRadians(possiblyDegrees) { + if (possiblyDegrees > Math.PI * 2) { + throw Error("expected radians"); + } +} +function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) { + const column0Row0 = 2 * near / (right - left); + const column1Row1 = 2 * near / (top - bottom); + const column2Row0 = (right + left) / (right - left); + const column2Row1 = (top + bottom) / (top - bottom); + const column2Row2 = -1; + const column2Row3 = -1; + const column3Row2 = -2 * near; + result[0] = column0Row0; + result[1] = 0; + result[2] = 0; + result[3] = 0; + result[4] = 0; + result[5] = column1Row1; + result[6] = 0; + result[7] = 0; + result[8] = column2Row0; + result[9] = column2Row1; + result[10] = column2Row2; + result[11] = column2Row3; + result[12] = 0; + result[13] = 0; + result[14] = column3Row2; + result[15] = 0; + return result; +} + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/lights/lights-glsl.js +var lightingShader = `#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX)) +struct AmbientLight { +vec3 color; +}; +struct PointLight { +vec3 color; +vec3 position; +vec3 attenuation; +}; +struct DirectionalLight { +vec3 color; +vec3 direction; +}; +uniform AmbientLight lighting_uAmbientLight; +uniform PointLight lighting_uPointLight[MAX_LIGHTS]; +uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS]; +uniform int lighting_uPointLightCount; +uniform int lighting_uDirectionalLightCount; +uniform bool lighting_uEnabled; +float getPointLightAttenuation(PointLight pointLight, float distance) { +return pointLight.attenuation.x ++ pointLight.attenuation.y * distance ++ pointLight.attenuation.z * distance * distance; +} +#endif +`; + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/lights/lights.js +var INITIAL_MODULE_OPTIONS = { + lightSources: {} +}; +function convertColor(colorDef = {}) { + const { color = [0, 0, 0], intensity = 1 } = colorDef; + return color.map((component) => component * intensity / 255); +} +function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) { + const lightSourceUniforms = {}; + if (ambientLight) { + lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight); + } else { + lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0]; + } + pointLights.forEach((pointLight, index2) => { + lightSourceUniforms[`lighting_uPointLight[${index2}].color`] = convertColor(pointLight); + lightSourceUniforms[`lighting_uPointLight[${index2}].position`] = pointLight.position; + lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [ + 1, + 0, + 0 + ]; + }); + lightSourceUniforms.lighting_uPointLightCount = pointLights.length; + directionalLights.forEach((directionalLight, index2) => { + lightSourceUniforms[`lighting_uDirectionalLight[${index2}].color`] = convertColor(directionalLight); + lightSourceUniforms[`lighting_uDirectionalLight[${index2}].direction`] = directionalLight.direction; + }); + lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length; + return lightSourceUniforms; +} +function getUniforms3(opts = INITIAL_MODULE_OPTIONS) { + if ("lightSources" in opts) { + const { ambientLight, pointLights, directionalLights } = opts.lightSources || {}; + const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0; + if (!hasLights) { + return { lighting_uEnabled: false }; + } + return Object.assign({}, getLightSourceUniforms({ ambientLight, pointLights, directionalLights }), { + lighting_uEnabled: true + }); + } + if ("lights" in opts) { + const lightSources = { pointLights: [], directionalLights: [] }; + for (const light of opts.lights || []) { + switch (light.type) { + case "ambient": + lightSources.ambientLight = light; + break; + case "directional": + lightSources.directionalLights?.push(light); + break; + case "point": + lightSources.pointLights?.push(light); + break; + default: + } + } + return getUniforms3({ lightSources }); + } + return {}; +} +var lights = { + name: "lights", + vs: lightingShader, + fs: lightingShader, + getUniforms: getUniforms3, + defines: { + MAX_LIGHTS: 3 + } +}; + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.js +var lightingShader2 = `uniform float lighting_uAmbient; +uniform float lighting_uDiffuse; +uniform float lighting_uShininess; +uniform vec3 lighting_uSpecularColor; +vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) { +vec3 halfway_direction = normalize(light_direction + view_direction); +float lambertian = dot(light_direction, normal_worldspace); +float specular = 0.0; +if (lambertian > 0.0) { +float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0); +specular = pow(specular_angle, lighting_uShininess); +} +lambertian = max(lambertian, 0.0); +return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color; +} +vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) { +vec3 lightColor = surfaceColor; +if (lighting_uEnabled) { +vec3 view_direction = normalize(cameraPosition - position_worldspace); +lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color; +for (int i = 0; i < MAX_LIGHTS; i++) { +if (i >= lighting_uPointLightCount) { +break; +} +PointLight pointLight = lighting_uPointLight[i]; +vec3 light_position_worldspace = pointLight.position; +vec3 light_direction = normalize(light_position_worldspace - position_worldspace); +lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color); +} +for (int i = 0; i < MAX_LIGHTS; i++) { +if (i >= lighting_uDirectionalLightCount) { +break; +} +DirectionalLight directionalLight = lighting_uDirectionalLight[i]; +lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color); +} +} +return lightColor; +} +vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) { +vec3 lightColor = vec3(0, 0, 0); +vec3 surfaceColor = vec3(0, 0, 0); +if (lighting_uEnabled) { +vec3 view_direction = normalize(cameraPosition - position_worldspace); +for (int i = 0; i < MAX_LIGHTS; i++) { +if (i >= lighting_uPointLightCount) { +break; +} +PointLight pointLight = lighting_uPointLight[i]; +vec3 light_position_worldspace = pointLight.position; +vec3 light_direction = normalize(light_position_worldspace - position_worldspace); +lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color); +} +for (int i = 0; i < MAX_LIGHTS; i++) { +if (i >= lighting_uDirectionalLightCount) { +break; +} +DirectionalLight directionalLight = lighting_uDirectionalLight[i]; +lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color); +} +} +return lightColor; +} +`; + +// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/phong-lighting/phong-lighting.js +var INITIAL_MODULE_OPTIONS2 = {}; +function getMaterialUniforms(material) { + const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material; + return { + lighting_uAmbient: ambient, + lighting_uDiffuse: diffuse, + lighting_uShininess: shininess, + lighting_uSpecularColor: specularColor.map((x) => x / 255) + }; +} +function getUniforms4(opts = INITIAL_MODULE_OPTIONS2) { + if (!("material" in opts)) { + return {}; + } + const { material } = opts; + if (!material) { + return { lighting_uEnabled: false }; + } + return getMaterialUniforms(material); +} +var gouraudLighting = { + name: "gouraud-lighting", + dependencies: [lights], + vs: lightingShader2, + defines: { + LIGHTING_VERTEX: 1 + }, + getUniforms: getUniforms4 +}; + +// node_modules/@deck.gl/core/dist/shaderlib/misc/geometry.js +var defines = "#define SMOOTH_EDGE_RADIUS 0.5"; +var vs2 = ` +${defines} + +struct VertexGeometry { + vec4 position; + vec3 worldPosition; + vec3 worldPositionAlt; + vec3 normal; + vec2 uv; + vec3 pickingColor; +} geometry = VertexGeometry( + vec4(0.0, 0.0, 1.0, 0.0), + vec3(0.0), + vec3(0.0), + vec3(0.0), + vec2(0.0), + vec3(0.0) +); +`; +var fs2 = ` +${defines} + +struct FragmentGeometry { + vec2 uv; +} geometry; + +float smoothedge(float edge, float x) { + return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x); +} +`; +var geometry_default = { name: "geometry", vs: vs2, fs: fs2 }; + +// node_modules/@deck.gl/core/dist/lib/constants.js +var COORDINATE_SYSTEM = { + /** + * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise + */ + DEFAULT: -1, + /** + * Positions are interpreted as [longitude, latitude, elevation] + * longitude/latitude are in degrees, elevation is in meters. + * Dimensions are in meters. + */ + LNGLAT: 1, + /** + * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin. + * Dimensions are in meters. + */ + METER_OFFSETS: 2, + /** + * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin. + * deltaLng/deltaLat are in degrees, elevation is in meters. + * Dimensions are in meters. + */ + LNGLAT_OFFSETS: 3, + /** + * Positions and dimensions are in the common units of the viewport. + */ + CARTESIAN: 0 +}; +Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", { + get: () => { + log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")(); + return 0; + } +}); +var PROJECTION_MODE = { + /** + * Render geospatial data in Web Mercator projection + */ + WEB_MERCATOR: 1, + /** + * Render geospatial data as a 3D globe + */ + GLOBE: 2, + /** + * (Internal use only) Web Mercator projection at high zoom + */ + WEB_MERCATOR_AUTO_OFFSET: 4, + /** + * No transformation + */ + IDENTITY: 0 +}; +var UNIT = { + common: 0, + meters: 1, + pixels: 2 +}; +var EVENTS = { + click: { handler: "onClick" }, + panstart: { handler: "onDragStart" }, + panmove: { handler: "onDrag" }, + panend: { handler: "onDragEnd" } +}; + +// node_modules/@deck.gl/core/dist/shaderlib/project/project.glsl.js +var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`).join(""); +var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join(""); +var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join(""); +var project_glsl_default = `${COORDINATE_SYSTEM_GLSL_CONSTANTS} +${PROJECTION_MODE_GLSL_CONSTANTS} +${UNIT_GLSL_CONSTANTS} +uniform int project_uCoordinateSystem; +uniform int project_uProjectionMode; +uniform float project_uScale; +uniform bool project_uWrapLongitude; +uniform vec3 project_uCommonUnitsPerMeter; +uniform vec3 project_uCommonUnitsPerWorldUnit; +uniform vec3 project_uCommonUnitsPerWorldUnit2; +uniform vec4 project_uCenter; +uniform mat4 project_uModelMatrix; +uniform mat4 project_uViewProjectionMatrix; +uniform vec2 project_uViewportSize; +uniform float project_uDevicePixelRatio; +uniform float project_uFocalDistance; +uniform vec3 project_uCameraPosition; +uniform vec3 project_uCoordinateOrigin; +uniform vec3 project_uCommonOrigin; +uniform bool project_uPseudoMeters; +const float TILE_SIZE = 512.0; +const float PI = 3.1415926536; +const float WORLD_SCALE = TILE_SIZE / (PI * 2.0); +const vec3 ZERO_64_LOW = vec3(0.0); +const float EARTH_RADIUS = 6370972.0; +const float GLOBE_RADIUS = 256.0; +float project_size_at_latitude(float lat) { +float y = clamp(lat, -89.9, 89.9); +return 1.0 / cos(radians(y)); +} +float project_size() { +if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR && +project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT && +project_uPseudoMeters == false) { +if (geometry.position.w == 0.0) { +return project_size_at_latitude(geometry.worldPosition.y); +} +float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0; +float y2 = y * y; +float y4 = y2 * y2; +float y6 = y4 * y2; +return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6; +} +return 1.0; +} +float project_size_at_latitude(float meters, float lat) { +return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude(lat); +} +float project_size(float meters) { +return meters * project_uCommonUnitsPerMeter.z * project_size(); +} +vec2 project_size(vec2 meters) { +return meters * project_uCommonUnitsPerMeter.xy * project_size(); +} +vec3 project_size(vec3 meters) { +return meters * project_uCommonUnitsPerMeter * project_size(); +} +vec4 project_size(vec4 meters) { +return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w); +} +mat3 project_get_orientation_matrix(vec3 up) { +vec3 uz = normalize(up); +vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0)); +vec3 uy = cross(uz, ux); +return mat3(ux, uy, uz); +} +bool project_needs_rotation(vec3 commonPosition, out mat3 transform) { +if (project_uProjectionMode == PROJECTION_MODE_GLOBE) { +transform = project_get_orientation_matrix(commonPosition); +return true; +} +return false; +} +vec3 project_normal(vec3 vector) { +vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0); +vec3 n = normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter); +mat3 rotation; +if (project_needs_rotation(geometry.position.xyz, rotation)) { +n = rotation * n; +} +return n; +} +vec4 project_offset_(vec4 offset) { +float dy = offset.y; +vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy; +return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w); +} +vec2 project_mercator_(vec2 lnglat) { +float x = lnglat.x; +if (project_uWrapLongitude) { +x = mod(x + 180., 360.0) - 180.; +} +float y = clamp(lnglat.y, -89.9, 89.9); +return vec2( +radians(x) + PI, +PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5)) +) * WORLD_SCALE; +} +vec3 project_globe_(vec3 lnglatz) { +float lambda = radians(lnglatz.x); +float phi = radians(lnglatz.y); +float cosPhi = cos(phi); +float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS; +return vec3( +sin(lambda) * cosPhi, +-cos(lambda) * cosPhi, +sin(phi) +) * D; +} +vec4 project_position(vec4 position, vec3 position64Low) { +vec4 position_world = project_uModelMatrix * position; +if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) { +if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { +return vec4( +project_mercator_(position_world.xy), +project_size_at_latitude(position_world.z, position_world.y), +position_world.w +); +} +if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) { +position_world.xyz += project_uCoordinateOrigin; +} +} +if (project_uProjectionMode == PROJECTION_MODE_GLOBE) { +if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { +return vec4( +project_globe_(position_world.xyz), +position_world.w +); +} +} +if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) { +if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { +if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) { +return vec4( +project_mercator_(position_world.xy) - project_uCommonOrigin.xy, +project_size(position_world.z), +position_world.w +); +} +} +} +if (project_uProjectionMode == PROJECTION_MODE_IDENTITY || +(project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET && +(project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT || +project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) { +position_world.xyz -= project_uCoordinateOrigin; +} +return project_offset_(position_world) + project_offset_(project_uModelMatrix * vec4(position64Low, 0.0)); +} +vec4 project_position(vec4 position) { +return project_position(position, ZERO_64_LOW); +} +vec3 project_position(vec3 position, vec3 position64Low) { +vec4 projected_position = project_position(vec4(position, 1.0), position64Low); +return projected_position.xyz; +} +vec3 project_position(vec3 position) { +vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW); +return projected_position.xyz; +} +vec2 project_position(vec2 position) { +vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW); +return projected_position.xy; +} +vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) { +return viewProjectionMatrix * position + center; +} +vec4 project_common_position_to_clipspace(vec4 position) { +return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter); +} +vec2 project_pixel_size_to_clipspace(vec2 pixels) { +vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0; +return offset * project_uFocalDistance; +} +float project_size_to_pixel(float meters) { +return project_size(meters) * project_uScale; +} +float project_size_to_pixel(float size, int unit) { +if (unit == UNIT_METERS) return project_size_to_pixel(size); +if (unit == UNIT_COMMON) return size * project_uScale; +return size; +} +float project_pixel_size(float pixels) { +return pixels / project_uScale; +} +vec2 project_pixel_size(vec2 pixels) { +return pixels / project_uScale; +} +`; + +// node_modules/@deck.gl/core/dist/utils/memoize.js +function isEqual(a, b) { + if (a === b) { + return true; + } + if (Array.isArray(a)) { + const len8 = a.length; + if (!b || b.length !== len8) { + return false; + } + for (let i = 0; i < len8; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + return false; +} +function memoize(compute) { + let cachedArgs = {}; + let cachedResult; + return (args) => { + for (const key in args) { + if (!isEqual(args[key], cachedArgs[key])) { + cachedResult = compute(args); + cachedArgs = args; + break; + } + } + return cachedResult; + }; +} + +// node_modules/@deck.gl/core/dist/shaderlib/project/viewport-uniforms.js +var ZERO_VECTOR = [0, 0, 0, 0]; +var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; +var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; +var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0]; +var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0]; +var getMemoizedViewportUniforms = memoize(calculateViewportUniforms); +function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) { + if (coordinateOrigin.length < 3) { + coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0]; + } + let shaderCoordinateOrigin = coordinateOrigin; + let geospatialOrigin; + let offsetMode = true; + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) { + geospatialOrigin = coordinateOrigin; + } else { + geospatialOrigin = viewport.isGeospatial ? ( + // @ts-expect-error longitude and latitude are not defined on the base Viewport, but is expected on geospatial viewports + [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0] + ) : null; + } + switch (viewport.projectionMode) { + case PROJECTION_MODE.WEB_MERCATOR: + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { + geospatialOrigin = [0, 0, 0]; + offsetMode = false; + } + break; + case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET: + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { + shaderCoordinateOrigin = geospatialOrigin; + } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { + shaderCoordinateOrigin = [ + Math.fround(viewport.center[0]), + Math.fround(viewport.center[1]), + 0 + ]; + geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin); + shaderCoordinateOrigin[0] -= coordinateOrigin[0]; + shaderCoordinateOrigin[1] -= coordinateOrigin[1]; + shaderCoordinateOrigin[2] -= coordinateOrigin[2]; + } + break; + case PROJECTION_MODE.IDENTITY: + shaderCoordinateOrigin = viewport.position.map(Math.fround); + shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0; + break; + case PROJECTION_MODE.GLOBE: + offsetMode = false; + geospatialOrigin = null; + break; + default: + offsetMode = false; + } + return { geospatialOrigin, shaderCoordinateOrigin, offsetMode }; +} +function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) { + const { viewMatrixUncentered, projectionMatrix } = viewport; + let { viewMatrix, viewProjectionMatrix } = viewport; + let projectionCenter = ZERO_VECTOR; + let originCommon = ZERO_VECTOR; + let cameraPosCommon = viewport.cameraPosition; + const { geospatialOrigin, shaderCoordinateOrigin, offsetMode } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin); + if (offsetMode) { + originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); + cameraPosCommon = [ + cameraPosCommon[0] - originCommon[0], + cameraPosCommon[1] - originCommon[1], + cameraPosCommon[2] - originCommon[2] + ]; + originCommon[3] = 1; + projectionCenter = vec4_exports.transformMat4([], originCommon, viewProjectionMatrix); + viewMatrix = viewMatrixUncentered || viewMatrix; + viewProjectionMatrix = mat4_exports.multiply([], projectionMatrix, viewMatrix); + viewProjectionMatrix = mat4_exports.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX); + } + return { + viewMatrix, + viewProjectionMatrix, + projectionCenter, + originCommon, + cameraPosCommon, + shaderCoordinateOrigin, + geospatialOrigin + }; +} +function getUniformsFromViewport({ + viewport, + devicePixelRatio = 1, + modelMatrix = null, + // Match Layer.defaultProps + coordinateSystem = COORDINATE_SYSTEM.DEFAULT, + coordinateOrigin = DEFAULT_COORDINATE_ORIGIN, + autoWrapLongitude = false +}) { + if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; + } + const uniforms = getMemoizedViewportUniforms({ + viewport, + devicePixelRatio, + coordinateSystem, + coordinateOrigin + }); + uniforms.project_uWrapLongitude = autoWrapLongitude; + uniforms.project_uModelMatrix = modelMatrix || IDENTITY_MATRIX2; + return uniforms; +} +function calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSystem, coordinateOrigin }) { + const { projectionCenter, viewProjectionMatrix, originCommon, cameraPosCommon, shaderCoordinateOrigin, geospatialOrigin } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin); + const distanceScales = viewport.getDistanceScales(); + const viewportSize = [ + viewport.width * devicePixelRatio, + viewport.height * devicePixelRatio + ]; + const focalDistance = vec4_exports.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1; + const uniforms = { + // Projection mode values + project_uCoordinateSystem: coordinateSystem, + project_uProjectionMode: viewport.projectionMode, + project_uCoordinateOrigin: shaderCoordinateOrigin, + project_uCommonOrigin: originCommon.slice(0, 3), + project_uCenter: projectionCenter, + // Backward compatibility + // TODO: remove in v9 + // @ts-expect-error _pseudoMeters is only defined on WebMercator viewport + project_uPseudoMeters: Boolean(viewport._pseudoMeters), + // Screen size + project_uViewportSize: viewportSize, + project_uDevicePixelRatio: devicePixelRatio, + project_uFocalDistance: focalDistance, + project_uCommonUnitsPerMeter: distanceScales.unitsPerMeter, + project_uCommonUnitsPerWorldUnit: distanceScales.unitsPerMeter, + project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2, + project_uScale: viewport.scale, + // This is the mercator scale (2 ** zoom) + project_uWrapLongitude: false, + project_uViewProjectionMatrix: viewProjectionMatrix, + project_uModelMatrix: IDENTITY_MATRIX2, + // This is for lighting calculations + project_uCameraPosition: cameraPosCommon + }; + if (geospatialOrigin) { + const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin); + switch (coordinateSystem) { + case COORDINATE_SYSTEM.METER_OFFSETS: + uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter; + uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2; + break; + case COORDINATE_SYSTEM.LNGLAT: + case COORDINATE_SYSTEM.LNGLAT_OFFSETS: + if (!viewport._pseudoMeters) { + uniforms.project_uCommonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter; + } + uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree; + uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2; + break; + case COORDINATE_SYSTEM.CARTESIAN: + uniforms.project_uCommonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]]; + uniforms.project_uCommonUnitsPerWorldUnit2 = [ + 0, + 0, + distanceScalesAtOrigin.unitsPerMeter2[2] + ]; + break; + default: + break; + } + } + return uniforms; +} + +// node_modules/@deck.gl/core/dist/shaderlib/project/project.js +var INITIAL_MODULE_OPTIONS3 = {}; +function getUniforms5(opts = INITIAL_MODULE_OPTIONS3) { + if ("viewport" in opts) { + return getUniformsFromViewport(opts); + } + return {}; +} +var project_default = { + name: "project", + dependencies: [fp32, geometry_default], + vs: project_glsl_default, + getUniforms: getUniforms5 +}; + +// node_modules/@deck.gl/core/dist/shaderlib/project32/project32.js +var vs3 = ` +vec4 project_position_to_clipspace( + vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition +) { + vec3 projectedPosition = project_position(position, position64Low); + mat3 rotation; + if (project_needs_rotation(projectedPosition, rotation)) { + // offset is specified as ENU + // when in globe projection, rotate offset so that the ground alighs with the surface of the globe + offset = rotation * offset; + } + commonPosition = vec4(projectedPosition + offset, 1.0); + return project_common_position_to_clipspace(commonPosition); +} + +vec4 project_position_to_clipspace( + vec3 position, vec3 position64Low, vec3 offset +) { + vec4 commonPosition; + return project_position_to_clipspace(position, position64Low, offset, commonPosition); +} +`; +var project32_default = { + name: "project32", + dependencies: [project_default], + vs: vs3 +}; + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec2.js +var vec2_exports2 = {}; +__export(vec2_exports2, { + add: () => add5, + angle: () => angle3, + ceil: () => ceil4, + clone: () => clone6, + copy: () => copy5, + create: () => create5, + cross: () => cross4, + dist: () => dist4, + distance: () => distance4, + div: () => div4, + divide: () => divide4, + dot: () => dot4, + equals: () => equals6, + exactEquals: () => exactEquals6, + floor: () => floor4, + forEach: () => forEach5, + fromValues: () => fromValues5, + inverse: () => inverse4, + len: () => len4, + length: () => length4, + lerp: () => lerp5, + max: () => max4, + min: () => min4, + mul: () => mul5, + multiply: () => multiply5, + negate: () => negate4, + normalize: () => normalize4, + random: () => random4, + rotate: () => rotate3, + round: () => round7, + scale: () => scale5, + scaleAndAdd: () => scaleAndAdd4, + set: () => set5, + sqrDist: () => sqrDist4, + sqrLen: () => sqrLen4, + squaredDistance: () => squaredDistance4, + squaredLength: () => squaredLength4, + str: () => str5, + sub: () => sub5, + subtract: () => subtract5, + transformMat2: () => transformMat22, + transformMat2d: () => transformMat2d2, + transformMat3: () => transformMat33, + transformMat4: () => transformMat44, + zero: () => zero4 +}); + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/common.js +var EPSILON2 = 1e-6; +var ARRAY_TYPE2 = typeof Float32Array !== "undefined" ? Float32Array : Array; +var RANDOM2 = Math.random; +function round6(a) { + if (a >= 0) + return Math.round(a); + return a % 0.5 === 0 ? Math.floor(a) : Math.round(a); +} +var degree2 = Math.PI / 180; + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec2.js +function create5() { + const out = new ARRAY_TYPE2(2); + if (ARRAY_TYPE2 != Float32Array) { + out[0] = 0; + out[1] = 0; + } + return out; +} +function clone6(a) { + const out = new ARRAY_TYPE2(2); + out[0] = a[0]; + out[1] = a[1]; + return out; +} +function fromValues5(x, y) { + const out = new ARRAY_TYPE2(2); + out[0] = x; + out[1] = y; + return out; +} +function copy5(out, a) { + out[0] = a[0]; + out[1] = a[1]; + return out; +} +function set5(out, x, y) { + out[0] = x; + out[1] = y; + return out; +} +function add5(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + return out; +} +function subtract5(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + return out; +} +function multiply5(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + return out; +} +function divide4(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + return out; +} +function ceil4(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + return out; +} +function floor4(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + return out; +} +function min4(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + return out; +} +function max4(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + return out; +} +function round7(out, a) { + out[0] = round6(a[0]); + out[1] = round6(a[1]); + return out; +} +function scale5(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + return out; +} +function scaleAndAdd4(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + return out; +} +function distance4(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + return Math.sqrt(x * x + y * y); +} +function squaredDistance4(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + return x * x + y * y; +} +function length4(a) { + const x = a[0]; + const y = a[1]; + return Math.sqrt(x * x + y * y); +} +function squaredLength4(a) { + const x = a[0]; + const y = a[1]; + return x * x + y * y; +} +function negate4(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + return out; +} +function inverse4(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + return out; +} +function normalize4(out, a) { + const x = a[0]; + const y = a[1]; + let len8 = x * x + y * y; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = a[0] * len8; + out[1] = a[1] * len8; + return out; +} +function dot4(a, b) { + return a[0] * b[0] + a[1] * b[1]; +} +function cross4(out, a, b) { + const z = a[0] * b[1] - a[1] * b[0]; + out[0] = out[1] = 0; + out[2] = z; + return out; +} +function lerp5(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + return out; +} +function random4(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + const r = RANDOM2() * 2 * Math.PI; + out[0] = Math.cos(r) * scale13; + out[1] = Math.sin(r) * scale13; + return out; +} +function transformMat22(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + return out; +} +function transformMat2d2(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y + m[4]; + out[1] = m[1] * x + m[3] * y + m[5]; + return out; +} +function transformMat33(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[3] * y + m[6]; + out[1] = m[1] * x + m[4] * y + m[7]; + return out; +} +function transformMat44(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[4] * y + m[12]; + out[1] = m[1] * x + m[5] * y + m[13]; + return out; +} +function rotate3(out, a, b, rad) { + const p0 = a[0] - b[0]; + const p1 = a[1] - b[1]; + const sinC = Math.sin(rad); + const cosC = Math.cos(rad); + out[0] = p0 * cosC - p1 * sinC + b[0]; + out[1] = p0 * sinC + p1 * cosC + b[1]; + return out; +} +function angle3(a, b) { + const x1 = a[0]; + const y1 = a[1]; + const x2 = b[0]; + const y2 = b[1]; + const mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)); + const cosine = mag && (x1 * x2 + y1 * y2) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); +} +function zero4(out) { + out[0] = 0; + out[1] = 0; + return out; +} +function str5(a) { + return `vec2(${a[0]}, ${a[1]})`; +} +function exactEquals6(a, b) { + return a[0] === b[0] && a[1] === b[1]; +} +function equals6(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const b0 = b[0]; + const b1 = b[1]; + return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)); +} +var len4 = length4; +var sub5 = subtract5; +var mul5 = multiply5; +var div4 = divide4; +var dist4 = distance4; +var sqrDist4 = squaredDistance4; +var sqrLen4 = squaredLength4; +var forEach5 = function() { + const vec = create5(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 2; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + } + return a; + }; +}(); + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec3.js +var vec3_exports2 = {}; +__export(vec3_exports2, { + add: () => add6, + angle: () => angle4, + bezier: () => bezier2, + ceil: () => ceil5, + clone: () => clone7, + copy: () => copy6, + create: () => create6, + cross: () => cross5, + dist: () => dist5, + distance: () => distance5, + div: () => div5, + divide: () => divide5, + dot: () => dot5, + equals: () => equals7, + exactEquals: () => exactEquals7, + floor: () => floor5, + forEach: () => forEach6, + fromValues: () => fromValues6, + hermite: () => hermite2, + inverse: () => inverse5, + len: () => len5, + length: () => length5, + lerp: () => lerp6, + max: () => max5, + min: () => min5, + mul: () => mul6, + multiply: () => multiply6, + negate: () => negate5, + normalize: () => normalize5, + random: () => random5, + rotateX: () => rotateX3, + rotateY: () => rotateY3, + rotateZ: () => rotateZ3, + round: () => round8, + scale: () => scale6, + scaleAndAdd: () => scaleAndAdd5, + set: () => set6, + slerp: () => slerp2, + sqrDist: () => sqrDist5, + sqrLen: () => sqrLen5, + squaredDistance: () => squaredDistance5, + squaredLength: () => squaredLength5, + str: () => str6, + sub: () => sub6, + subtract: () => subtract6, + transformMat3: () => transformMat34, + transformMat4: () => transformMat45, + transformQuat: () => transformQuat3, + zero: () => zero5 +}); +function create6() { + const out = new ARRAY_TYPE2(3); + if (ARRAY_TYPE2 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} +function clone7(a) { + const out = new ARRAY_TYPE2(3); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} +function length5(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function fromValues6(x, y, z) { + const out = new ARRAY_TYPE2(3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function copy6(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} +function set6(out, x, y, z) { + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function add6(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + return out; +} +function subtract6(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + return out; +} +function multiply6(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + return out; +} +function divide5(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + return out; +} +function ceil5(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + return out; +} +function floor5(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + return out; +} +function min5(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + return out; +} +function max5(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + return out; +} +function round8(out, a) { + out[0] = round6(a[0]); + out[1] = round6(a[1]); + out[2] = round6(a[2]); + return out; +} +function scale6(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + return out; +} +function scaleAndAdd5(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + return out; +} +function distance5(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function squaredDistance5(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + return x * x + y * y + z * z; +} +function squaredLength5(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + return x * x + y * y + z * z; +} +function negate5(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + return out; +} +function inverse5(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + out[2] = 1 / a[2]; + return out; +} +function normalize5(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let len8 = x * x + y * y + z * z; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = a[0] * len8; + out[1] = a[1] * len8; + out[2] = a[2] * len8; + return out; +} +function dot5(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +function cross5(out, a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} +function lerp6(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + return out; +} +function slerp2(out, a, b, t) { + const angle6 = Math.acos(Math.min(Math.max(dot5(a, b), -1), 1)); + const sinTotal = Math.sin(angle6); + const ratioA = Math.sin((1 - t) * angle6) / sinTotal; + const ratioB = Math.sin(t * angle6) / sinTotal; + out[0] = ratioA * a[0] + ratioB * b[0]; + out[1] = ratioA * a[1] + ratioB * b[1]; + out[2] = ratioA * a[2] + ratioB * b[2]; + return out; +} +function hermite2(out, a, b, c, d, t) { + const factorTimes2 = t * t; + const factor1 = factorTimes2 * (2 * t - 3) + 1; + const factor2 = factorTimes2 * (t - 2) + t; + const factor3 = factorTimes2 * (t - 1); + const factor4 = factorTimes2 * (3 - 2 * t); + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + return out; +} +function bezier2(out, a, b, c, d, t) { + const inverseFactor = 1 - t; + const inverseFactorTimesTwo = inverseFactor * inverseFactor; + const factorTimes2 = t * t; + const factor1 = inverseFactorTimesTwo * inverseFactor; + const factor2 = 3 * t * inverseFactorTimesTwo; + const factor3 = 3 * factorTimes2 * inverseFactor; + const factor4 = factorTimes2 * t; + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + return out; +} +function random5(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + const r = RANDOM2() * 2 * Math.PI; + const z = RANDOM2() * 2 - 1; + const zScale = Math.sqrt(1 - z * z) * scale13; + out[0] = Math.cos(r) * zScale; + out[1] = Math.sin(r) * zScale; + out[2] = z * scale13; + return out; +} +function transformMat45(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let w = m[3] * x + m[7] * y + m[11] * z + m[15]; + w = w || 1; + out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; + return out; +} +function transformMat34(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + out[0] = x * m[0] + y * m[3] + z * m[6]; + out[1] = x * m[1] + y * m[4] + z * m[7]; + out[2] = x * m[2] + y * m[5] + z * m[8]; + return out; +} +function transformQuat3(out, a, q) { + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const x = a[0]; + const y = a[1]; + const z = a[2]; + let uvx = qy * z - qz * y; + let uvy = qz * x - qx * z; + let uvz = qx * y - qy * x; + let uuvx = qy * uvz - qz * uvy; + let uuvy = qz * uvx - qx * uvz; + let uuvz = qx * uvy - qy * uvx; + const w2 = qw * 2; + uvx *= w2; + uvy *= w2; + uvz *= w2; + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + out[0] = x + uvx + uuvx; + out[1] = y + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; +} +function rotateX3(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0]; + r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); + r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateY3(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); + r[1] = p[1]; + r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateZ3(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); + r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); + r[2] = p[2]; + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function angle4(a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); + const cosine = mag && dot5(a, b) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); +} +function zero5(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + return out; +} +function str6(a) { + return `vec3(${a[0]}, ${a[1]}, ${a[2]})`; +} +function exactEquals7(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]; +} +function equals7(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)); +} +var sub6 = subtract6; +var mul6 = multiply6; +var div5 = divide5; +var dist5 = distance5; +var sqrDist5 = squaredDistance5; +var len5 = length5; +var sqrLen5 = squaredLength5; +var forEach6 = function() { + const vec = create6(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 3; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + } + return a; + }; +}(); + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/mat4.js +var mat4_exports2 = {}; +__export(mat4_exports2, { + add: () => add7, + adjoint: () => adjoint2, + clone: () => clone8, + copy: () => copy7, + create: () => create7, + decompose: () => decompose2, + determinant: () => determinant2, + equals: () => equals8, + exactEquals: () => exactEquals8, + frob: () => frob2, + fromQuat: () => fromQuat3, + fromQuat2: () => fromQuat22, + fromRotation: () => fromRotation2, + fromRotationTranslation: () => fromRotationTranslation2, + fromRotationTranslationScale: () => fromRotationTranslationScale2, + fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin2, + fromScaling: () => fromScaling2, + fromTranslation: () => fromTranslation2, + fromValues: () => fromValues7, + fromXRotation: () => fromXRotation2, + fromYRotation: () => fromYRotation2, + fromZRotation: () => fromZRotation2, + frustum: () => frustum2, + getRotation: () => getRotation2, + getScaling: () => getScaling2, + getTranslation: () => getTranslation2, + identity: () => identity2, + invert: () => invert2, + lookAt: () => lookAt2, + mul: () => mul7, + multiply: () => multiply7, + multiplyScalar: () => multiplyScalar2, + multiplyScalarAndAdd: () => multiplyScalarAndAdd2, + ortho: () => ortho2, + orthoNO: () => orthoNO2, + orthoZO: () => orthoZO2, + perspective: () => perspective2, + perspectiveFromFieldOfView: () => perspectiveFromFieldOfView2, + perspectiveNO: () => perspectiveNO2, + perspectiveZO: () => perspectiveZO2, + rotate: () => rotate4, + rotateX: () => rotateX4, + rotateY: () => rotateY4, + rotateZ: () => rotateZ4, + scale: () => scale7, + set: () => set7, + str: () => str7, + sub: () => sub7, + subtract: () => subtract7, + targetTo: () => targetTo2, + translate: () => translate2, + transpose: () => transpose2 +}); +function create7() { + const out = new ARRAY_TYPE2(16); + if (ARRAY_TYPE2 != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + } + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out; +} +function clone8(a) { + const out = new ARRAY_TYPE2(16); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function copy7(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function fromValues7(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + const out = new ARRAY_TYPE2(16); + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function set7(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function identity2(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function transpose2(out, a) { + if (out === a) { + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a12 = a[6]; + const a13 = a[7]; + const a23 = a[11]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a01; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a02; + out[9] = a12; + out[11] = a[14]; + out[12] = a03; + out[13] = a13; + out[14] = a23; + } else { + out[0] = a[0]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a[1]; + out[5] = a[5]; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a[2]; + out[9] = a[6]; + out[10] = a[10]; + out[11] = a[14]; + out[12] = a[3]; + out[13] = a[7]; + out[14] = a[11]; + out[15] = a[15]; + } + return out; +} +function invert2(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; + } + det = 1 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; +} +function adjoint2(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + out[0] = a11 * b11 - a12 * b10 + a13 * b09; + out[1] = a02 * b10 - a01 * b11 - a03 * b09; + out[2] = a31 * b05 - a32 * b04 + a33 * b03; + out[3] = a22 * b04 - a21 * b05 - a23 * b03; + out[4] = a12 * b08 - a10 * b11 - a13 * b07; + out[5] = a00 * b11 - a02 * b08 + a03 * b07; + out[6] = a32 * b02 - a30 * b05 - a33 * b01; + out[7] = a20 * b05 - a22 * b02 + a23 * b01; + out[8] = a10 * b10 - a11 * b08 + a13 * b06; + out[9] = a01 * b08 - a00 * b10 - a03 * b06; + out[10] = a30 * b04 - a31 * b02 + a33 * b00; + out[11] = a21 * b02 - a20 * b04 - a23 * b00; + out[12] = a11 * b07 - a10 * b09 - a12 * b06; + out[13] = a00 * b09 - a01 * b07 + a02 * b06; + out[14] = a31 * b01 - a30 * b03 - a32 * b00; + out[15] = a20 * b03 - a21 * b01 + a22 * b00; + return out; +} +function determinant2(a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b0 = a00 * a11 - a01 * a10; + const b1 = a00 * a12 - a02 * a10; + const b2 = a01 * a12 - a02 * a11; + const b3 = a20 * a31 - a21 * a30; + const b4 = a20 * a32 - a22 * a30; + const b5 = a21 * a32 - a22 * a31; + const b6 = a00 * b5 - a01 * b4 + a02 * b3; + const b7 = a10 * b5 - a11 * b4 + a12 * b3; + const b8 = a20 * b2 - a21 * b1 + a22 * b0; + const b9 = a30 * b2 - a31 * b1 + a32 * b0; + return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; +} +function multiply7(out, a, b) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + let b0 = b[0]; + let b1 = b[1]; + let b2 = b[2]; + let b3 = b[3]; + out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[4]; + b1 = b[5]; + b2 = b[6]; + b3 = b[7]; + out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[8]; + b1 = b[9]; + b2 = b[10]; + b3 = b[11]; + out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[12]; + b1 = b[13]; + b2 = b[14]; + b3 = b[15]; + out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + return out; +} +function translate2(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + if (a === out) { + out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; + out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; + out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; + out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; + } else { + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a03; + out[4] = a10; + out[5] = a11; + out[6] = a12; + out[7] = a13; + out[8] = a20; + out[9] = a21; + out[10] = a22; + out[11] = a23; + out[12] = a00 * x + a10 * y + a20 * z + a[12]; + out[13] = a01 * x + a11 * y + a21 * z + a[13]; + out[14] = a02 * x + a12 * y + a22 * z + a[14]; + out[15] = a03 * x + a13 * y + a23 * z + a[15]; + } + return out; +} +function scale7(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + out[0] = a[0] * x; + out[1] = a[1] * x; + out[2] = a[2] * x; + out[3] = a[3] * x; + out[4] = a[4] * y; + out[5] = a[5] * y; + out[6] = a[6] * y; + out[7] = a[7] * y; + out[8] = a[8] * z; + out[9] = a[9] * z; + out[10] = a[10] * z; + out[11] = a[11] * z; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function rotate4(out, a, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + let b00; + let b01; + let b02; + let b10; + let b11; + let b12; + let b20; + let b21; + let b22; + if (len8 < EPSILON2) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + b00 = x * x * t + c; + b01 = y * x * t + z * s; + b02 = z * x * t - y * s; + b10 = x * y * t - z * s; + b11 = y * y * t + c; + b12 = z * y * t + x * s; + b20 = x * z * t + y * s; + b21 = y * z * t - x * s; + b22 = z * z * t + c; + out[0] = a00 * b00 + a10 * b01 + a20 * b02; + out[1] = a01 * b00 + a11 * b01 + a21 * b02; + out[2] = a02 * b00 + a12 * b01 + a22 * b02; + out[3] = a03 * b00 + a13 * b01 + a23 * b02; + out[4] = a00 * b10 + a10 * b11 + a20 * b12; + out[5] = a01 * b10 + a11 * b11 + a21 * b12; + out[6] = a02 * b10 + a12 * b11 + a22 * b12; + out[7] = a03 * b10 + a13 * b11 + a23 * b12; + out[8] = a00 * b20 + a10 * b21 + a20 * b22; + out[9] = a01 * b20 + a11 * b21 + a21 * b22; + out[10] = a02 * b20 + a12 * b21 + a22 * b22; + out[11] = a03 * b20 + a13 * b21 + a23 * b22; + if (a !== out) { + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + return out; +} +function rotateX4(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[4] = a10 * c + a20 * s; + out[5] = a11 * c + a21 * s; + out[6] = a12 * c + a22 * s; + out[7] = a13 * c + a23 * s; + out[8] = a20 * c - a10 * s; + out[9] = a21 * c - a11 * s; + out[10] = a22 * c - a12 * s; + out[11] = a23 * c - a13 * s; + return out; +} +function rotateY4(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c - a20 * s; + out[1] = a01 * c - a21 * s; + out[2] = a02 * c - a22 * s; + out[3] = a03 * c - a23 * s; + out[8] = a00 * s + a20 * c; + out[9] = a01 * s + a21 * c; + out[10] = a02 * s + a22 * c; + out[11] = a03 * s + a23 * c; + return out; +} +function rotateZ4(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + if (a !== out) { + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c + a10 * s; + out[1] = a01 * c + a11 * s; + out[2] = a02 * c + a12 * s; + out[3] = a03 * c + a13 * s; + out[4] = a10 * c - a00 * s; + out[5] = a11 * c - a01 * s; + out[6] = a12 * c - a02 * s; + out[7] = a13 * c - a03 * s; + return out; +} +function fromTranslation2(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromScaling2(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = v[1]; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = v[2]; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotation2(out, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + if (len8 < EPSILON2) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + out[0] = x * x * t + c; + out[1] = y * x * t + z * s; + out[2] = z * x * t - y * s; + out[3] = 0; + out[4] = x * y * t - z * s; + out[5] = y * y * t + c; + out[6] = z * y * t + x * s; + out[7] = 0; + out[8] = x * z * t + y * s; + out[9] = y * z * t - x * s; + out[10] = z * z * t + c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromXRotation2(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = c; + out[6] = s; + out[7] = 0; + out[8] = 0; + out[9] = -s; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromYRotation2(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = 0; + out[2] = -s; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = s; + out[9] = 0; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromZRotation2(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = s; + out[2] = 0; + out[3] = 0; + out[4] = -s; + out[5] = c; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotationTranslation2(out, q, v) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromQuat22(out, a) { + const translation = new ARRAY_TYPE2(3); + const bx = -a[0]; + const by = -a[1]; + const bz = -a[2]; + const bw = a[3]; + const ax = a[4]; + const ay = a[5]; + const az = a[6]; + const aw = a[7]; + const magnitude = bx * bx + by * by + bz * bz + bw * bw; + if (magnitude > 0) { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; + } else { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; + } + fromRotationTranslation2(out, a, translation); + return out; +} +function getTranslation2(out, mat) { + out[0] = mat[12]; + out[1] = mat[13]; + out[2] = mat[14]; + return out; +} +function getScaling2(out, mat) { + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + return out; +} +function getRotation2(out, mat) { + const scaling = new ARRAY_TYPE2(3); + getScaling2(scaling, mat); + const is1 = 1 / scaling[0]; + const is2 = 1 / scaling[1]; + const is3 = 1 / scaling[2]; + const sm11 = mat[0] * is1; + const sm12 = mat[1] * is2; + const sm13 = mat[2] * is3; + const sm21 = mat[4] * is1; + const sm22 = mat[5] * is2; + const sm23 = mat[6] * is3; + const sm31 = mat[8] * is1; + const sm32 = mat[9] * is2; + const sm33 = mat[10] * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out[3] = 0.25 * S; + out[0] = (sm23 - sm32) / S; + out[1] = (sm31 - sm13) / S; + out[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out[3] = (sm23 - sm32) / S; + out[0] = 0.25 * S; + out[1] = (sm12 + sm21) / S; + out[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out[3] = (sm31 - sm13) / S; + out[0] = (sm12 + sm21) / S; + out[1] = 0.25 * S; + out[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out[3] = (sm12 - sm21) / S; + out[0] = (sm31 + sm13) / S; + out[1] = (sm23 + sm32) / S; + out[2] = 0.25 * S; + } + return out; +} +function decompose2(out_r, out_t, out_s, mat) { + out_t[0] = mat[12]; + out_t[1] = mat[13]; + out_t[2] = mat[14]; + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + const is1 = 1 / out_s[0]; + const is2 = 1 / out_s[1]; + const is3 = 1 / out_s[2]; + const sm11 = m11 * is1; + const sm12 = m12 * is2; + const sm13 = m13 * is3; + const sm21 = m21 * is1; + const sm22 = m22 * is2; + const sm23 = m23 * is3; + const sm31 = m31 * is1; + const sm32 = m32 * is2; + const sm33 = m33 * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out_r[3] = 0.25 * S; + out_r[0] = (sm23 - sm32) / S; + out_r[1] = (sm31 - sm13) / S; + out_r[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out_r[3] = (sm23 - sm32) / S; + out_r[0] = 0.25 * S; + out_r[1] = (sm12 + sm21) / S; + out_r[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out_r[3] = (sm31 - sm13) / S; + out_r[0] = (sm12 + sm21) / S; + out_r[1] = 0.25 * S; + out_r[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out_r[3] = (sm12 - sm21) / S; + out_r[0] = (sm31 + sm13) / S; + out_r[1] = (sm23 + sm32) / S; + out_r[2] = 0.25 * S; + } + return out_r; +} +function fromRotationTranslationScale2(out, q, v, s) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + out[0] = (1 - (yy + zz)) * sx; + out[1] = (xy + wz) * sx; + out[2] = (xz - wy) * sx; + out[3] = 0; + out[4] = (xy - wz) * sy; + out[5] = (1 - (xx + zz)) * sy; + out[6] = (yz + wx) * sy; + out[7] = 0; + out[8] = (xz + wy) * sz; + out[9] = (yz - wx) * sz; + out[10] = (1 - (xx + yy)) * sz; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromRotationTranslationScaleOrigin2(out, q, v, s, o) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + const ox = o[0]; + const oy = o[1]; + const oz = o[2]; + const out0 = (1 - (yy + zz)) * sx; + const out1 = (xy + wz) * sx; + const out2 = (xz - wy) * sx; + const out4 = (xy - wz) * sy; + const out5 = (1 - (xx + zz)) * sy; + const out6 = (yz + wx) * sy; + const out8 = (xz + wy) * sz; + const out9 = (yz - wx) * sz; + const out10 = (1 - (xx + yy)) * sz; + out[0] = out0; + out[1] = out1; + out[2] = out2; + out[3] = 0; + out[4] = out4; + out[5] = out5; + out[6] = out6; + out[7] = 0; + out[8] = out8; + out[9] = out9; + out[10] = out10; + out[11] = 0; + out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); + out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); + out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); + out[15] = 1; + return out; +} +function fromQuat3(out, q) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const yx = y * x2; + const yy = y * y2; + const zx = z * x2; + const zy = z * y2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - yy - zz; + out[1] = yx + wz; + out[2] = zx - wy; + out[3] = 0; + out[4] = yx - wz; + out[5] = 1 - xx - zz; + out[6] = zy + wx; + out[7] = 0; + out[8] = zx + wy; + out[9] = zy - wx; + out[10] = 1 - xx - yy; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function frustum2(out, left, right, bottom, top, near, far) { + const rl = 1 / (right - left); + const tb = 1 / (top - bottom); + const nf = 1 / (near - far); + out[0] = near * 2 * rl; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = near * 2 * tb; + out[6] = 0; + out[7] = 0; + out[8] = (right + left) * rl; + out[9] = (top + bottom) * tb; + out[10] = (far + near) * nf; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near * 2 * nf; + out[15] = 0; + return out; +} +function perspectiveNO2(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = 2 * far * near * nf; + } else { + out[10] = -1; + out[14] = -2 * near; + } + return out; +} +var perspective2 = perspectiveNO2; +function perspectiveZO2(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = far * nf; + out[14] = far * near * nf; + } else { + out[10] = -1; + out[14] = -near; + } + return out; +} +function perspectiveFromFieldOfView2(out, fov, near, far) { + const upTan = Math.tan(fov.upDegrees * Math.PI / 180); + const downTan = Math.tan(fov.downDegrees * Math.PI / 180); + const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); + const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); + const xScale = 2 / (leftTan + rightTan); + const yScale = 2 / (upTan + downTan); + out[0] = xScale; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = yScale; + out[6] = 0; + out[7] = 0; + out[8] = -((leftTan - rightTan) * xScale * 0.5); + out[9] = (upTan - downTan) * yScale * 0.5; + out[10] = far / (near - far); + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near / (near - far); + out[15] = 0; + return out; +} +function orthoNO2(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; +} +var ortho2 = orthoNO2; +function orthoZO2(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = near * nf; + out[15] = 1; + return out; +} +function lookAt2(out, eye, center, up) { + let len8; + let x0; + let x1; + let x2; + let y0; + let y1; + let y2; + let z0; + let z1; + let z2; + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + const centerx = center[0]; + const centery = center[1]; + const centerz = center[2]; + if (Math.abs(eyex - centerx) < EPSILON2 && Math.abs(eyey - centery) < EPSILON2 && Math.abs(eyez - centerz) < EPSILON2) { + return identity2(out); + } + z0 = eyex - centerx; + z1 = eyey - centery; + z2 = eyez - centerz; + len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); + z0 *= len8; + z1 *= len8; + z2 *= len8; + x0 = upy * z2 - upz * z1; + x1 = upz * z0 - upx * z2; + x2 = upx * z1 - upy * z0; + len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); + if (!len8) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len8 = 1 / len8; + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + y0 = z1 * x2 - z2 * x1; + y1 = z2 * x0 - z0 * x2; + y2 = z0 * x1 - z1 * x0; + len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); + if (!len8) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len8 = 1 / len8; + y0 *= len8; + y1 *= len8; + y2 *= len8; + } + out[0] = x0; + out[1] = y0; + out[2] = z0; + out[3] = 0; + out[4] = x1; + out[5] = y1; + out[6] = z1; + out[7] = 0; + out[8] = x2; + out[9] = y2; + out[10] = z2; + out[11] = 0; + out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); + out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); + out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); + out[15] = 1; + return out; +} +function targetTo2(out, eye, target, up) { + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + let z0 = eyex - target[0]; + let z1 = eyey - target[1]; + let z2 = eyez - target[2]; + let len8 = z0 * z0 + z1 * z1 + z2 * z2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + z0 *= len8; + z1 *= len8; + z2 *= len8; + } + let x0 = upy * z2 - upz * z1; + let x1 = upz * z0 - upx * z2; + let x2 = upx * z1 - upy * z0; + len8 = x0 * x0 + x1 * x1 + x2 * x2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + out[0] = x0; + out[1] = x1; + out[2] = x2; + out[3] = 0; + out[4] = z1 * x2 - z2 * x1; + out[5] = z2 * x0 - z0 * x2; + out[6] = z0 * x1 - z1 * x0; + out[7] = 0; + out[8] = z0; + out[9] = z1; + out[10] = z2; + out[11] = 0; + out[12] = eyex; + out[13] = eyey; + out[14] = eyez; + out[15] = 1; + return out; +} +function str7(a) { + return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; +} +function frob2(a) { + return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); +} +function add7(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + out[8] = a[8] + b[8]; + out[9] = a[9] + b[9]; + out[10] = a[10] + b[10]; + out[11] = a[11] + b[11]; + out[12] = a[12] + b[12]; + out[13] = a[13] + b[13]; + out[14] = a[14] + b[14]; + out[15] = a[15] + b[15]; + return out; +} +function subtract7(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + out[6] = a[6] - b[6]; + out[7] = a[7] - b[7]; + out[8] = a[8] - b[8]; + out[9] = a[9] - b[9]; + out[10] = a[10] - b[10]; + out[11] = a[11] - b[11]; + out[12] = a[12] - b[12]; + out[13] = a[13] - b[13]; + out[14] = a[14] - b[14]; + out[15] = a[15] - b[15]; + return out; +} +function multiplyScalar2(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + out[8] = a[8] * b; + out[9] = a[9] * b; + out[10] = a[10] * b; + out[11] = a[11] * b; + out[12] = a[12] * b; + out[13] = a[13] * b; + out[14] = a[14] * b; + out[15] = a[15] * b; + return out; +} +function multiplyScalarAndAdd2(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + out[3] = a[3] + b[3] * scale13; + out[4] = a[4] + b[4] * scale13; + out[5] = a[5] + b[5] * scale13; + out[6] = a[6] + b[6] * scale13; + out[7] = a[7] + b[7] * scale13; + out[8] = a[8] + b[8] * scale13; + out[9] = a[9] + b[9] * scale13; + out[10] = a[10] + b[10] * scale13; + out[11] = a[11] + b[11] * scale13; + out[12] = a[12] + b[12] * scale13; + out[13] = a[13] + b[13] * scale13; + out[14] = a[14] + b[14] * scale13; + out[15] = a[15] + b[15] * scale13; + return out; +} +function exactEquals8(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; +} +function equals8(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const a4 = a[4]; + const a5 = a[5]; + const a6 = a[6]; + const a7 = a[7]; + const a8 = a[8]; + const a9 = a[9]; + const a10 = a[10]; + const a11 = a[11]; + const a12 = a[12]; + const a13 = a[13]; + const a14 = a[14]; + const a15 = a[15]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + const b3 = b[3]; + const b4 = b[4]; + const b5 = b[5]; + const b6 = b[6]; + const b7 = b[7]; + const b8 = b[8]; + const b9 = b[9]; + const b10 = b[10]; + const b11 = b[11]; + const b12 = b[12]; + const b13 = b[13]; + const b14 = b[14]; + const b15 = b[15]; + return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON2 * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON2 * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON2 * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON2 * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON2 * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON2 * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON2 * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON2 * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON2 * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON2 * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON2 * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON2 * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON2 * Math.max(1, Math.abs(a15), Math.abs(b15)); +} +var mul7 = multiply7; +var sub7 = subtract7; + +// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec4.js +var vec4_exports2 = {}; +__export(vec4_exports2, { + add: () => add8, + ceil: () => ceil6, + clone: () => clone9, + copy: () => copy8, + create: () => create8, + cross: () => cross6, + dist: () => dist6, + distance: () => distance6, + div: () => div6, + divide: () => divide6, + dot: () => dot6, + equals: () => equals9, + exactEquals: () => exactEquals9, + floor: () => floor6, + forEach: () => forEach7, + fromValues: () => fromValues8, + inverse: () => inverse6, + len: () => len6, + length: () => length6, + lerp: () => lerp7, + max: () => max6, + min: () => min6, + mul: () => mul8, + multiply: () => multiply8, + negate: () => negate6, + normalize: () => normalize6, + random: () => random6, + round: () => round9, + scale: () => scale8, + scaleAndAdd: () => scaleAndAdd6, + set: () => set8, + sqrDist: () => sqrDist6, + sqrLen: () => sqrLen6, + squaredDistance: () => squaredDistance6, + squaredLength: () => squaredLength6, + str: () => str8, + sub: () => sub8, + subtract: () => subtract8, + transformMat4: () => transformMat46, + transformQuat: () => transformQuat4, + zero: () => zero6 +}); +function create8() { + const out = new ARRAY_TYPE2(4); + if (ARRAY_TYPE2 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} +function clone9(a) { + const out = new ARRAY_TYPE2(4); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function fromValues8(x, y, z, w) { + const out = new ARRAY_TYPE2(4); + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} +function copy8(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function set8(out, x, y, z, w) { + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} +function add8(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + return out; +} +function subtract8(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + return out; +} +function multiply8(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + out[3] = a[3] * b[3]; + return out; +} +function divide6(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + out[3] = a[3] / b[3]; + return out; +} +function ceil6(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + out[3] = Math.ceil(a[3]); + return out; +} +function floor6(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + out[3] = Math.floor(a[3]); + return out; +} +function min6(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + out[3] = Math.min(a[3], b[3]); + return out; +} +function max6(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + out[3] = Math.max(a[3], b[3]); + return out; +} +function round9(out, a) { + out[0] = round6(a[0]); + out[1] = round6(a[1]); + out[2] = round6(a[2]); + out[3] = round6(a[3]); + return out; +} +function scale8(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + return out; +} +function scaleAndAdd6(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + out[3] = a[3] + b[3] * scale13; + return out; +} +function distance6(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + const w = b[3] - a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} +function squaredDistance6(a, b) { + const x = b[0] - a[0]; + const y = b[1] - a[1]; + const z = b[2] - a[2]; + const w = b[3] - a[3]; + return x * x + y * y + z * z + w * w; +} +function length6(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} +function squaredLength6(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return x * x + y * y + z * z + w * w; +} +function negate6(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = -a[3]; + return out; +} +function inverse6(out, a) { + out[0] = 1 / a[0]; + out[1] = 1 / a[1]; + out[2] = 1 / a[2]; + out[3] = 1 / a[3]; + return out; +} +function normalize6(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + let len8 = x * x + y * y + z * z + w * w; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = x * len8; + out[1] = y * len8; + out[2] = z * len8; + out[3] = w * len8; + return out; +} +function dot6(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; +} +function cross6(out, u, v, w) { + const A = v[0] * w[1] - v[1] * w[0]; + const B = v[0] * w[2] - v[2] * w[0]; + const C = v[0] * w[3] - v[3] * w[0]; + const D = v[1] * w[2] - v[2] * w[1]; + const E = v[1] * w[3] - v[3] * w[1]; + const F = v[2] * w[3] - v[3] * w[2]; + const G = u[0]; + const H = u[1]; + const I = u[2]; + const J = u[3]; + out[0] = H * F - I * E + J * D; + out[1] = -(G * F) + I * C - J * B; + out[2] = G * E - H * C + J * A; + out[3] = -(G * D) + H * B - I * A; + return out; +} +function lerp7(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + out[3] = aw + t * (b[3] - aw); + return out; +} +function random6(out, scale13) { + scale13 = scale13 === void 0 ? 1 : scale13; + let v1; + let v2; + let v3; + let v4; + let s1; + let s2; + do { + v1 = RANDOM2() * 2 - 1; + v2 = RANDOM2() * 2 - 1; + s1 = v1 * v1 + v2 * v2; + } while (s1 >= 1); + do { + v3 = RANDOM2() * 2 - 1; + v4 = RANDOM2() * 2 - 1; + s2 = v3 * v3 + v4 * v4; + } while (s2 >= 1); + const d = Math.sqrt((1 - s1) / s2); + out[0] = scale13 * v1; + out[1] = scale13 * v2; + out[2] = scale13 * v3 * d; + out[3] = scale13 * v4 * d; + return out; +} +function transformMat46(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; + out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; + out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; + out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; + return out; +} +function transformQuat4(out, a, q) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const ix = qw * x + qy * z - qz * y; + const iy = qw * y + qz * x - qx * z; + const iz = qw * z + qx * y - qy * x; + const iw = -qx * x - qy * y - qz * z; + out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; + out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; + out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; + out[3] = a[3]; + return out; +} +function zero6(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + return out; +} +function str8(a) { + return `vec4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`; +} +function exactEquals9(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; +} +function equals9(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + const b3 = b[3]; + return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON2 * Math.max(1, Math.abs(a3), Math.abs(b3)); +} +var sub8 = subtract8; +var mul8 = multiply8; +var div6 = divide6; +var dist6 = distance6; +var sqrDist6 = squaredDistance6; +var len6 = length6; +var sqrLen6 = squaredLength6; +var forEach7 = function() { + const vec = create8(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 4; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + vec[3] = a[i + 3]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + a[i + 3] = vec[3]; + } + return a; + }; +}(); + +// node_modules/@math.gl/web-mercator/dist/math-utils.js +function createMat4() { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; +} +function transformVector(matrix, vector) { + const result = vec4_exports2.transformMat4([], vector, matrix); + vec4_exports2.scale(result, result, 1 / result[3]); + return result; +} +function mod(value, divisor) { + const modulus = value % divisor; + return modulus < 0 ? divisor + modulus : modulus; +} +function clamp2(x, min7, max7) { + return x < min7 ? min7 : x > max7 ? max7 : x; +} +function ieLog2(x) { + return Math.log(x) * Math.LOG2E; +} +var log22 = Math.log2 || ieLog2; + +// node_modules/@math.gl/web-mercator/dist/assert.js +function assert8(condition, message2) { + if (!condition) { + throw new Error(message2 || "@math.gl/web-mercator: assertion failed."); + } +} + +// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js +var PI = Math.PI; +var PI_4 = PI / 4; +var DEGREES_TO_RADIANS2 = PI / 180; +var RADIANS_TO_DEGREES2 = 180 / PI; +var TILE_SIZE = 512; +var EARTH_CIRCUMFERENCE = 4003e4; +var MAX_LATITUDE = 85.051129; +var DEFAULT_ALTITUDE = 1.5; +function scaleToZoom(scale13) { + return log22(scale13); +} +function lngLatToWorld(lngLat) { + const [lng, lat] = lngLat; + assert8(Number.isFinite(lng)); + assert8(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude"); + const lambda2 = lng * DEGREES_TO_RADIANS2; + const phi2 = lat * DEGREES_TO_RADIANS2; + const x = TILE_SIZE * (lambda2 + PI) / (2 * PI); + const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI); + return [x, y]; +} +function worldToLngLat(xy) { + const [x, y] = xy; + const lambda2 = x / TILE_SIZE * (2 * PI) - PI; + const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4); + return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2]; +} +function getMeterZoom(options) { + const { latitude } = options; + assert8(Number.isFinite(latitude)); + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9; +} +function unitsPerMeter(latitude) { + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + return TILE_SIZE / EARTH_CIRCUMFERENCE / latCosine; +} +function getDistanceScales(options) { + const { latitude, longitude, highPrecision = false } = options; + assert8(Number.isFinite(latitude) && Number.isFinite(longitude)); + const worldSize = TILE_SIZE; + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + const unitsPerDegreeX = worldSize / 360; + const unitsPerDegreeY = unitsPerDegreeX / latCosine; + const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine; + const result = { + unitsPerMeter: [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter], + metersPerUnit: [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter], + unitsPerDegree: [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter], + degreesPerUnit: [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter] + }; + if (highPrecision) { + const latCosine2 = DEGREES_TO_RADIANS2 * Math.tan(latitude * DEGREES_TO_RADIANS2) / latCosine; + const unitsPerDegreeY2 = unitsPerDegreeX * latCosine2 / 2; + const altUnitsPerDegree2 = worldSize / EARTH_CIRCUMFERENCE * latCosine2; + const altUnitsPerMeter2 = altUnitsPerDegree2 / unitsPerDegreeY * altUnitsPerMeter; + result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2]; + result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2]; + } + return result; +} +function addMetersToLngLat(lngLatZ, xyz) { + const [longitude, latitude, z0] = lngLatZ; + const [x, y, z] = xyz; + const { unitsPerMeter: unitsPerMeter2, unitsPerMeter2: unitsPerMeter22 } = getDistanceScales({ + longitude, + latitude, + highPrecision: true + }); + const worldspace = lngLatToWorld(lngLatZ); + worldspace[0] += x * (unitsPerMeter2[0] + unitsPerMeter22[0] * y); + worldspace[1] += y * (unitsPerMeter2[1] + unitsPerMeter22[1] * y); + const newLngLat = worldToLngLat(worldspace); + const newZ = (z0 || 0) + (z || 0); + return Number.isFinite(z0) || Number.isFinite(z) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat; +} +function getViewMatrix(options) { + const { + // Viewport props + height, + pitch, + bearing, + altitude, + // Pre-calculated parameters + scale: scale13, + center + } = options; + const vm = createMat4(); + mat4_exports2.translate(vm, vm, [0, 0, -altitude]); + mat4_exports2.rotateX(vm, vm, -pitch * DEGREES_TO_RADIANS2); + mat4_exports2.rotateZ(vm, vm, bearing * DEGREES_TO_RADIANS2); + const relativeScale = scale13 / height; + mat4_exports2.scale(vm, vm, [relativeScale, relativeScale, relativeScale]); + if (center) { + mat4_exports2.translate(vm, vm, vec3_exports2.negate([], center)); + } + return vm; +} +function getProjectionParameters(options) { + const { width, height, altitude, pitch = 0, offset, center, scale: scale13, nearZMultiplier = 1, farZMultiplier = 1 } = options; + let { fovy = altitudeToFovy(DEFAULT_ALTITUDE) } = options; + if (altitude !== void 0) { + fovy = altitudeToFovy(altitude); + } + const fovRadians = fovy * DEGREES_TO_RADIANS2; + const pitchRadians = pitch * DEGREES_TO_RADIANS2; + const focalDistance = fovyToAltitude(fovy); + let cameraToSeaLevelDistance = focalDistance; + if (center) { + cameraToSeaLevelDistance += center[2] * scale13 / Math.cos(pitchRadians) / height; + } + const fovAboveCenter = fovRadians * (0.5 + (offset ? offset[1] : 0) / height); + const topHalfSurfaceDistance = Math.sin(fovAboveCenter) * cameraToSeaLevelDistance / Math.sin(clamp2(Math.PI / 2 - pitchRadians - fovAboveCenter, 0.01, Math.PI - 0.01)); + const furthestDistance = Math.sin(pitchRadians) * topHalfSurfaceDistance + cameraToSeaLevelDistance; + const horizonDistance = cameraToSeaLevelDistance * 10; + const farZ = Math.min(furthestDistance * farZMultiplier, horizonDistance); + return { + fov: fovRadians, + aspect: width / height, + focalDistance, + near: nearZMultiplier, + far: farZ + }; +} +function altitudeToFovy(altitude) { + return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES2; +} +function fovyToAltitude(fovy) { + return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS2); +} +function worldToPixels(xyz, pixelProjectionMatrix) { + const [x, y, z = 0] = xyz; + assert8(Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)); + return transformVector(pixelProjectionMatrix, [x, y, z, 1]); +} +function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) { + const [x, y, z] = xyz; + assert8(Number.isFinite(x) && Number.isFinite(y), "invalid pixel coordinate"); + if (Number.isFinite(z)) { + const coord = transformVector(pixelUnprojectionMatrix, [x, y, z, 1]); + return coord; + } + const coord0 = transformVector(pixelUnprojectionMatrix, [x, y, 0, 1]); + const coord1 = transformVector(pixelUnprojectionMatrix, [x, y, 1, 1]); + const z0 = coord0[2]; + const z1 = coord1[2]; + const t = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0); + return vec2_exports2.lerp([], coord0, coord1, t); +} + +// node_modules/@math.gl/web-mercator/dist/fit-bounds.js +function fitBounds(options) { + const { + width, + height, + bounds, + minExtent = 0, + // 0.01 would be about 1000 meters (degree is ~110KM) + maxZoom = 24, + // ~x4,000,000 => About 10 meter extents + offset = [0, 0] + } = options; + const [[west, south], [east, north]] = bounds; + const padding = getPaddingObject(options.padding); + const nw = lngLatToWorld([west, clamp2(north, -MAX_LATITUDE, MAX_LATITUDE)]); + const se = lngLatToWorld([east, clamp2(south, -MAX_LATITUDE, MAX_LATITUDE)]); + const size = [ + Math.max(Math.abs(se[0] - nw[0]), minExtent), + Math.max(Math.abs(se[1] - nw[1]), minExtent) + ]; + const targetSize = [ + width - padding.left - padding.right - Math.abs(offset[0]) * 2, + height - padding.top - padding.bottom - Math.abs(offset[1]) * 2 + ]; + assert8(targetSize[0] > 0 && targetSize[1] > 0); + const scaleX2 = targetSize[0] / size[0]; + const scaleY2 = targetSize[1] / size[1]; + const offsetX = (padding.right - padding.left) / 2 / scaleX2; + const offsetY = (padding.top - padding.bottom) / 2 / scaleY2; + const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY]; + const centerLngLat = worldToLngLat(center); + const zoom = Math.min(maxZoom, log22(Math.abs(Math.min(scaleX2, scaleY2)))); + assert8(Number.isFinite(zoom)); + return { + longitude: centerLngLat[0], + latitude: centerLngLat[1], + zoom + }; +} +function getPaddingObject(padding = 0) { + if (typeof padding === "number") { + return { + top: padding, + bottom: padding, + left: padding, + right: padding + }; + } + assert8(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right)); + return padding; +} + +// node_modules/@math.gl/web-mercator/dist/get-bounds.js +var DEGREES_TO_RADIANS3 = Math.PI / 180; +function getBounds(viewport, z = 0) { + const { width, height, unproject } = viewport; + const unprojectOps = { targetZ: z }; + const bottomLeft = unproject([0, height], unprojectOps); + const bottomRight = unproject([width, height], unprojectOps); + let topLeft; + let topRight; + const halfFov = viewport.fovy ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS3 : Math.atan(0.5 / viewport.altitude); + const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS3; + if (halfFov > angleToGround - 0.01) { + topLeft = unprojectOnFarPlane(viewport, 0, z); + topRight = unprojectOnFarPlane(viewport, width, z); + } else { + topLeft = unproject([0, 0], unprojectOps); + topRight = unproject([width, 0], unprojectOps); + } + return [bottomLeft, bottomRight, topRight, topLeft]; +} +function unprojectOnFarPlane(viewport, x, targetZ) { + const { pixelUnprojectionMatrix } = viewport; + const coord0 = transformVector(pixelUnprojectionMatrix, [x, 0, 1, 1]); + const coord1 = transformVector(pixelUnprojectionMatrix, [x, viewport.height, 1, 1]); + const z = targetZ * viewport.distanceScales.unitsPerMeter[2]; + const t = (z - coord0[2]) / (coord1[2] - coord0[2]); + const coord = vec2_exports2.lerp([], coord0, coord1, t); + const result = worldToLngLat(coord); + result.push(targetZ); + return result; +} + +// node_modules/@math.gl/web-mercator/dist/normalize-viewport-props.js +var TILE_SIZE2 = 512; +function normalizeViewportProps(props) { + const { width, height, pitch = 0 } = props; + let { longitude, latitude, zoom, bearing = 0 } = props; + if (longitude < -180 || longitude > 180) { + longitude = mod(longitude + 180, 360) - 180; + } + if (bearing < -180 || bearing > 180) { + bearing = mod(bearing + 180, 360) - 180; + } + const minZoom = log22(height / TILE_SIZE2); + if (zoom <= minZoom) { + zoom = minZoom; + latitude = 0; + } else { + const halfHeightPixels = height / 2 / Math.pow(2, zoom); + const minLatitude = worldToLngLat([0, halfHeightPixels])[1]; + if (latitude < minLatitude) { + latitude = minLatitude; + } else { + const maxLatitude = worldToLngLat([0, TILE_SIZE2 - halfHeightPixels])[1]; + if (latitude > maxLatitude) { + latitude = maxLatitude; + } + } + } + return { width, height, longitude, latitude, zoom, pitch, bearing }; +} + +// node_modules/@deck.gl/core/dist/shaderlib/shadow/shadow.js +var vs4 = ` +const int max_lights = 2; +uniform mat4 shadow_uViewProjectionMatrices[max_lights]; +uniform vec4 shadow_uProjectCenters[max_lights]; +uniform bool shadow_uDrawShadowMap; +uniform bool shadow_uUseShadowMap; +uniform int shadow_uLightId; +uniform float shadow_uLightCount; + +out vec3 shadow_vPosition[max_lights]; + +vec4 shadow_setVertexPosition(vec4 position_commonspace) { + if (shadow_uDrawShadowMap) { + return project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[shadow_uLightId], shadow_uProjectCenters[shadow_uLightId]); + } + if (shadow_uUseShadowMap) { + for (int i = 0; i < max_lights; i++) { + if(i < int(shadow_uLightCount)) { + vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[i], shadow_uProjectCenters[i]); + shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0; + } + } + } + return gl_Position; +} +`; +var fs3 = ` +const int max_lights = 2; +uniform bool shadow_uDrawShadowMap; +uniform bool shadow_uUseShadowMap; +uniform sampler2D shadow_uShadowMap0; +uniform sampler2D shadow_uShadowMap1; +uniform vec4 shadow_uColor; +uniform float shadow_uLightCount; + +in vec3 shadow_vPosition[max_lights]; + +const vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0); +const vec4 bitUnpackShift = 1.0 / bitPackShift; +const vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0); + +float shadow_getShadowWeight(vec3 position, sampler2D shadowMap) { + vec4 rgbaDepth = texture(shadowMap, position.xy); + + float z = dot(rgbaDepth, bitUnpackShift); + return smoothstep(0.001, 0.01, position.z - z); +} + +vec4 shadow_filterShadowColor(vec4 color) { + if (shadow_uDrawShadowMap) { + vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift); + rgbaDepth -= rgbaDepth.gbaa * bitMask; + return rgbaDepth; + } + if (shadow_uUseShadowMap) { + float shadowAlpha = 0.0; + shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0); + if(shadow_uLightCount > 1.0) { + shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1); + } + shadowAlpha *= shadow_uColor.a / shadow_uLightCount; + float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha); + + return vec4( + mix(color.rgb, shadow_uColor.rgb, shadowAlpha / blendedAlpha), + blendedAlpha + ); + } + return color; +} +`; +var getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition); +var getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices); +var DEFAULT_SHADOW_COLOR = [0, 0, 0, 1]; +var VECTOR_TO_POINT_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; +function screenToCommonSpace(xyz, pixelUnprojectionMatrix) { + const [x, y, z] = xyz; + const coord = pixelsToWorld([x, y, z], pixelUnprojectionMatrix); + if (Number.isFinite(z)) { + return coord; + } + return [coord[0], coord[1], 0]; +} +function getViewportCenterPosition({ viewport, center }) { + return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center); +} +function getViewProjectionMatrices({ viewport, shadowMatrices }) { + const projectionMatrices = []; + const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix; + const farZ = viewport.isGeospatial ? void 0 : 1; + const corners = [ + [0, 0, farZ], + // top left ground + [viewport.width, 0, farZ], + // top right ground + [0, viewport.height, farZ], + // bottom left ground + [viewport.width, viewport.height, farZ], + // bottom right ground + [0, 0, -1], + // top left near + [viewport.width, 0, -1], + // top right near + [0, viewport.height, -1], + // bottom left near + [viewport.width, viewport.height, -1] + // bottom right near + ].map((pixel) => ( + // @ts-expect-error z may be undefined + screenToCommonSpace(pixel, pixelUnprojectionMatrix) + )); + for (const shadowMatrix of shadowMatrices) { + const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate()); + const positions = corners.map((corner) => viewMatrix.transform(corner)); + const projectionMatrix = new Matrix4().ortho({ + left: Math.min(...positions.map((position) => position[0])), + right: Math.max(...positions.map((position) => position[0])), + bottom: Math.min(...positions.map((position) => position[1])), + top: Math.max(...positions.map((position) => position[1])), + near: Math.min(...positions.map((position) => -position[2])), + far: Math.max(...positions.map((position) => -position[2])) + }); + projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix)); + } + return projectionMatrices; +} +function createShadowUniforms(opts, context) { + const { shadowEnabled = true } = opts; + if (!shadowEnabled || !opts.shadowMatrices || !opts.shadowMatrices.length) { + return { + shadow_uDrawShadowMap: false, + shadow_uUseShadowMap: false, + shadow_uShadowMap0: opts.dummyShadowMap, + shadow_uShadowMap1: opts.dummyShadowMap + }; + } + const uniforms = { + shadow_uDrawShadowMap: Boolean(opts.drawToShadowMap), + shadow_uUseShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false, + shadow_uColor: opts.shadowColor || DEFAULT_SHADOW_COLOR, + shadow_uLightId: opts.shadowLightId || 0, + shadow_uLightCount: opts.shadowMatrices.length + }; + const center = getMemoizedViewportCenterPosition({ + viewport: opts.viewport, + center: context.project_uCenter + }); + const projectCenters = []; + const viewProjectionMatrices = getMemoizedViewProjectionMatrices({ + shadowMatrices: opts.shadowMatrices, + viewport: opts.viewport + }).slice(); + for (let i = 0; i < opts.shadowMatrices.length; i++) { + const viewProjectionMatrix = viewProjectionMatrices[i]; + const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(opts.viewport.center).negate()); + if (context.project_uCoordinateSystem === COORDINATE_SYSTEM.LNGLAT && context.project_uProjectionMode === PROJECTION_MODE.WEB_MERCATOR) { + viewProjectionMatrices[i] = viewProjectionMatrixCentered; + projectCenters[i] = center; + } else { + viewProjectionMatrices[i] = viewProjectionMatrix.clone().multiplyRight(VECTOR_TO_POINT_MATRIX2); + projectCenters[i] = viewProjectionMatrixCentered.transform(center); + } + } + for (let i = 0; i < viewProjectionMatrices.length; i++) { + uniforms[`shadow_uViewProjectionMatrices[${i}]`] = viewProjectionMatrices[i]; + uniforms[`shadow_uProjectCenters[${i}]`] = projectCenters[i]; + } + for (let i = 0; i < 2; i++) { + uniforms[`shadow_uShadowMap${i}`] = opts.shadowMaps && opts.shadowMaps[i] || opts.dummyShadowMap; + } + return uniforms; +} +var shadow_default = { + name: "shadow", + dependencies: [project_default], + vs: vs4, + fs: fs3, + inject: { + "vs:DECKGL_FILTER_GL_POSITION": ` + position = shadow_setVertexPosition(geometry.position); + `, + "fs:DECKGL_FILTER_COLOR": ` + color = shadow_filterShadowColor(color); + ` + }, + // @ts-expect-error stricter luma gl types + getUniforms: (opts = {}, context = {}) => { + if ("viewport" in opts && (opts.drawToShadowMap || opts.shadowMaps && opts.shadowMaps.length > 0)) { + return createShadowUniforms(opts, context); + } + return {}; + } +}; + +// node_modules/@deck.gl/core/dist/shaderlib/picking/picking.js +var picking_default = { + ...picking, + defaultUniforms: { ...picking.defaultUniforms, useFloatColors: false }, + inject: { + "vs:DECKGL_FILTER_GL_POSITION": ` + // for picking depth values + picking_setPickingAttribute(position.z / position.w); + `, + "vs:DECKGL_FILTER_COLOR": ` + picking_setPickingColor(geometry.pickingColor); + `, + "fs:DECKGL_FILTER_COLOR": { + order: 99, + injection: ` + // use highlight color if this fragment belongs to the selected object. + color = picking_filterHighlightColor(color); + + // use picking color if rendering to picking FBO. + color = picking_filterPickingColor(color); + ` + } + } +}; + +// node_modules/@deck.gl/core/dist/shaderlib/index.js +var DEFAULT_MODULES = [project_default]; +var SHADER_HOOKS = [ + "vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)", + "vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)", + "vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)", + "fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)" +]; +function getShaderAssembler() { + const shaderAssembler = ShaderAssembler.getDefaultShaderAssembler(); + for (const shaderModule of DEFAULT_MODULES) { + shaderAssembler.addDefaultModule(shaderModule); + } + for (const shaderHook of SHADER_HOOKS) { + shaderAssembler.addShaderHook(shaderHook); + } + return shaderAssembler; +} + +// node_modules/@deck.gl/core/dist/effects/lighting/ambient-light.js +var DEFAULT_LIGHT_COLOR = [255, 255, 255]; +var DEFAULT_LIGHT_INTENSITY = 1; +var idCount = 0; +var AmbientLight = class { + constructor(props = {}) { + this.type = "ambient"; + const { color = DEFAULT_LIGHT_COLOR } = props; + const { intensity = DEFAULT_LIGHT_INTENSITY } = props; + this.id = props.id || `ambient-${idCount++}`; + this.color = color; + this.intensity = intensity; + } +}; + +// node_modules/@deck.gl/core/dist/effects/lighting/directional-light.js +var DEFAULT_LIGHT_COLOR2 = [255, 255, 255]; +var DEFAULT_LIGHT_INTENSITY2 = 1; +var DEFAULT_LIGHT_DIRECTION = [0, 0, -1]; +var idCount2 = 0; +var DirectionalLight = class { + constructor(props = {}) { + this.type = "directional"; + const { color = DEFAULT_LIGHT_COLOR2 } = props; + const { intensity = DEFAULT_LIGHT_INTENSITY2 } = props; + const { direction = DEFAULT_LIGHT_DIRECTION } = props; + const { _shadow = false } = props; + this.id = props.id || `directional-${idCount2++}`; + this.color = color; + this.intensity = intensity; + this.type = "directional"; + this.direction = new Vector3(direction).normalize().toArray(); + this.shadow = _shadow; + } + getProjectedLight(opts) { + return this; + } +}; + +// node_modules/@deck.gl/core/dist/passes/pass.js +var Pass = class { + /** Create a new Pass instance */ + constructor(device, props = { id: "pass" }) { + const { id } = props; + this.id = id; + this.device = device; + this.props = { ...props }; + } + setProps(props) { + Object.assign(this.props, props); + } + render(params) { + } + // eslint-disable-line @typescript-eslint/no-empty-function + cleanup() { + } + // eslint-disable-line @typescript-eslint/no-empty-function +}; + +// node_modules/@deck.gl/core/dist/passes/layers-pass.js +var LayersPass = class extends Pass { + constructor() { + super(...arguments); + this._lastRenderIndex = -1; + } + render(options) { + const [width, height] = this.device.canvasContext.getDrawingBufferSize(); + const clearCanvas = options.clearCanvas ?? true; + const clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false); + const clearDepth = clearCanvas ? 1 : false; + const clearStencil = clearCanvas ? 0 : false; + const colorMask = options.colorMask ?? 15; + const parameters = { viewport: [0, 0, width, height] }; + if (options.colorMask) { + parameters.colorMask = colorMask; + } + if (options.scissorRect) { + parameters.scissorRect = options.scissorRect; + } + const renderPass = this.device.beginRenderPass({ + framebuffer: options.target, + parameters, + clearColor, + clearDepth, + clearStencil + }); + try { + return this._drawLayers(renderPass, options); + } finally { + renderPass.end(); + } + } + /** Draw a list of layers in a list of viewports */ + _drawLayers(renderPass, options) { + const { target, moduleParameters, viewports, views, onViewportActive, clearStack = true } = options; + options.pass = options.pass || "unknown"; + if (clearStack) { + this._lastRenderIndex = -1; + } + const renderStats = []; + for (const viewport of viewports) { + const view = views && views[viewport.id]; + onViewportActive?.(viewport); + const drawLayerParams = this._getDrawLayerParams(viewport, options); + const subViewports = viewport.subViewports || [viewport]; + for (const subViewport of subViewports) { + const stats = this._drawLayersInViewport(renderPass, { + target, + moduleParameters, + viewport: subViewport, + view, + pass: options.pass, + layers: options.layers + }, drawLayerParams); + renderStats.push(stats); + } + } + return renderStats; + } + // When a viewport contains multiple subviewports (e.g. repeated web mercator map), + // this is only done once for the parent viewport + /* Resolve the parameters needed to draw each layer */ + _getDrawLayerParams(viewport, { layers, pass, isPicking = false, layerFilter, cullRect, effects, moduleParameters }, evaluateShouldDrawOnly = false) { + const drawLayerParams = []; + const indexResolver = layerIndexResolver(this._lastRenderIndex + 1); + const drawContext = { + layer: layers[0], + viewport, + isPicking, + renderPass: pass, + cullRect + }; + const layerFilterCache = {}; + for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { + const layer = layers[layerIndex]; + const shouldDrawLayer = this._shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache); + const layerParam = { + shouldDrawLayer + }; + if (shouldDrawLayer && !evaluateShouldDrawOnly) { + layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer); + layerParam.moduleParameters = this._getModuleParameters(layer, effects, pass, moduleParameters); + layerParam.layerParameters = { + ...layer.context.deck?.props.parameters, + ...this.getLayerParameters(layer, layerIndex, viewport) + }; + } + drawLayerParams[layerIndex] = layerParam; + } + return drawLayerParams; + } + // Draws a list of layers in one viewport + // TODO - when picking we could completely skip rendering viewports that dont + // intersect with the picking rect + /* eslint-disable max-depth, max-statements */ + _drawLayersInViewport(renderPass, { layers, moduleParameters: globalModuleParameters, pass, target, viewport, view }, drawLayerParams) { + const glViewport = getGLViewport(this.device, { + moduleParameters: globalModuleParameters, + target, + viewport + }); + if (view && view.props.clear) { + const clearOpts = view.props.clear === true ? { color: true, depth: true } : view.props.clear; + this.device.withParametersWebGL({ + scissorTest: true, + scissor: glViewport + }, () => this.device.clearWebGL(clearOpts)); + } + const renderStatus = { + totalCount: layers.length, + visibleCount: 0, + compositeCount: 0, + pickableCount: 0 + }; + renderPass.setParameters({ viewport: glViewport }); + for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { + const layer = layers[layerIndex]; + const { shouldDrawLayer, layerRenderIndex, moduleParameters, layerParameters } = drawLayerParams[layerIndex]; + if (shouldDrawLayer && layer.props.pickable) { + renderStatus.pickableCount++; + } + if (layer.isComposite) { + renderStatus.compositeCount++; + } else if (shouldDrawLayer) { + renderStatus.visibleCount++; + this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex); + moduleParameters.viewport = viewport; + layer.context.renderPass = renderPass; + try { + layer._drawLayer({ + renderPass, + moduleParameters, + uniforms: { layerIndex: layerRenderIndex }, + parameters: layerParameters + }); + } catch (err) { + layer.raiseError(err, `drawing ${layer} to ${pass}`); + } + } + } + return renderStatus; + } + /* eslint-enable max-depth, max-statements */ + /* Methods for subclass overrides */ + shouldDrawLayer(layer) { + return true; + } + getModuleParameters(layer, effects) { + return null; + } + getLayerParameters(layer, layerIndex, viewport) { + return layer.props.parameters; + } + /* Private */ + _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) { + const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer); + if (!shouldDrawLayer) { + return false; + } + drawContext.layer = layer; + let parent = layer.parent; + while (parent) { + if (!parent.props.visible || !parent.filterSubLayer(drawContext)) { + return false; + } + drawContext.layer = parent; + parent = parent.parent; + } + if (layerFilter) { + const rootLayerId = drawContext.layer.id; + if (!(rootLayerId in layerFilterCache)) { + layerFilterCache[rootLayerId] = layerFilter(drawContext); + } + if (!layerFilterCache[rootLayerId]) { + return false; + } + } + layer.activateViewport(drawContext.viewport); + return true; + } + _getModuleParameters(layer, effects, pass, overrides) { + const devicePixelRatio = this.device.canvasContext.cssToDeviceRatio(); + const moduleParameters = Object.assign(Object.create(layer.internalState?.propsInTransition || layer.props), { + autoWrapLongitude: layer.wrapLongitude, + viewport: layer.context.viewport, + mousePosition: layer.context.mousePosition, + picking: { + isActive: 0 + }, + devicePixelRatio + }); + if (effects) { + for (const effect of effects) { + Object.assign(moduleParameters, effect.getModuleParameters?.(layer)); + } + } + return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides); + } +}; +function layerIndexResolver(startIndex = 0, layerIndices = {}) { + const resolvers = {}; + const resolveLayerIndex = (layer, isDrawn) => { + const indexOverride = layer.props._offset; + const layerId = layer.id; + const parentId = layer.parent && layer.parent.id; + let index2; + if (parentId && !(parentId in layerIndices)) { + resolveLayerIndex(layer.parent, false); + } + if (parentId in resolvers) { + const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices); + index2 = resolver(layer, isDrawn); + resolvers[layerId] = resolver; + } else if (Number.isFinite(indexOverride)) { + index2 = indexOverride + (layerIndices[parentId] || 0); + resolvers[layerId] = null; + } else { + index2 = startIndex; + } + if (isDrawn && index2 >= startIndex) { + startIndex = index2 + 1; + } + layerIndices[layerId] = index2; + return index2; + }; + return resolveLayerIndex; +} +function getGLViewport(device, { moduleParameters, target, viewport }) { + const pixelRatio = moduleParameters && moduleParameters.devicePixelRatio || // @ts-expect-error TODO - assuming WebGL context + device.canvasContext.cssToDeviceRatio(); + const [, drawingBufferHeight] = device.canvasContext.getDrawingBufferSize(); + const height = target ? target.height : drawingBufferHeight; + const dimensions = viewport; + return [ + dimensions.x * pixelRatio, + height - (dimensions.y + dimensions.height) * pixelRatio, + dimensions.width * pixelRatio, + dimensions.height * pixelRatio + ]; +} + +// node_modules/@deck.gl/core/dist/passes/shadow-pass.js +var ShadowPass = class extends LayersPass { + constructor(device, props) { + super(device, props); + this.shadowMap = device.createTexture({ + width: 1, + height: 1, + sampler: { + minFilter: "linear", + magFilter: "linear", + addressModeU: "clamp-to-edge", + addressModeV: "clamp-to-edge" + } + }); + this.depthBuffer = device.createTexture({ + format: "depth16unorm", + width: 1, + height: 1, + mipmaps: false, + // TODO fix getWebGLTextureParameters() in luma to avoid passing deprecated parameters + dataFormat: 6402, + // gl.DEPTH_COMPONENT + type: 5125 + // gl.UNSIGNED_INT + }); + this.fbo = device.createFramebuffer({ + id: "shadowmap", + width: 1, + height: 1, + colorAttachments: [this.shadowMap], + // Depth attachment has to be specified for depth test to work + depthStencilAttachment: this.depthBuffer + }); + } + render(params) { + const target = this.fbo; + const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); + const viewport = params.viewports[0]; + const width = viewport.width * pixelRatio; + const height = viewport.height * pixelRatio; + const clearColor = [1, 1, 1, 1]; + if (width !== target.width || height !== target.height) { + target.resize({ width, height }); + } + super.render({ ...params, clearColor, target, pass: "shadow" }); + } + getLayerParameters(layer, layerIndex, viewport) { + return { ...layer.props.parameters, blend: false, depthRange: [0, 1], depthTest: true }; + } + shouldDrawLayer(layer) { + return layer.props.shadowEnabled !== false; + } + getModuleParameters() { + return { + drawToShadowMap: true + }; + } + delete() { + if (this.fbo) { + this.fbo.destroy(); + this.fbo = null; + } + if (this.shadowMap) { + this.shadowMap.destroy(); + this.shadowMap = null; + } + if (this.depthBuffer) { + this.depthBuffer.destroy(); + this.depthBuffer = null; + } + } +}; + +// node_modules/@deck.gl/core/dist/effects/lighting/lighting-effect.js +var DEFAULT_AMBIENT_LIGHT_PROPS = { color: [255, 255, 255], intensity: 1 }; +var DEFAULT_DIRECTIONAL_LIGHT_PROPS = [ + { + color: [255, 255, 255], + intensity: 1, + direction: [-1, 3, -1] + }, + { + color: [255, 255, 255], + intensity: 0.9, + direction: [1, -8, -2.5] + } +]; +var DEFAULT_SHADOW_COLOR2 = [0, 0, 0, 200 / 255]; +var LightingEffect = class { + constructor(props = {}) { + this.id = "lighting-effect"; + this.shadowColor = DEFAULT_SHADOW_COLOR2; + this.shadow = false; + this.ambientLight = null; + this.directionalLights = []; + this.pointLights = []; + this.shadowPasses = []; + this.shadowMaps = []; + this.dummyShadowMap = null; + this.setProps(props); + } + setup(context) { + this.context = context; + const { device, deck } = context; + if (this.shadow && !this.dummyShadowMap) { + this._createShadowPasses(device); + deck._addDefaultShaderModule(shadow_default); + this.dummyShadowMap = device.createTexture({ + width: 1, + height: 1 + }); + } + } + setProps(props) { + this.ambientLight = null; + this.directionalLights = []; + this.pointLights = []; + for (const key in props) { + const lightSource = props[key]; + switch (lightSource.type) { + case "ambient": + this.ambientLight = lightSource; + break; + case "directional": + this.directionalLights.push(lightSource); + break; + case "point": + this.pointLights.push(lightSource); + break; + default: + } + } + this._applyDefaultLights(); + this.shadow = this.directionalLights.some((light) => light.shadow); + if (this.context) { + this.setup(this.context); + } + this.props = props; + } + preRender({ layers, layerFilter, viewports, onViewportActive, views }) { + if (!this.shadow) + return; + this.shadowMatrices = this._calculateMatrices(); + for (let i = 0; i < this.shadowPasses.length; i++) { + const shadowPass = this.shadowPasses[i]; + shadowPass.render({ + layers, + layerFilter, + viewports, + onViewportActive, + views, + moduleParameters: { + shadowLightId: i, + dummyShadowMap: this.dummyShadowMap, + shadowMatrices: this.shadowMatrices + } + }); + } + } + getModuleParameters(layer) { + const parameters = this.shadow ? { + shadowMaps: this.shadowMaps, + dummyShadowMap: this.dummyShadowMap, + shadowColor: this.shadowColor, + shadowMatrices: this.shadowMatrices + } : {}; + parameters.lightSources = { + ambientLight: this.ambientLight, + directionalLights: this.directionalLights.map((directionalLight) => directionalLight.getProjectedLight({ layer })), + pointLights: this.pointLights.map((pointLight) => pointLight.getProjectedLight({ layer })) + }; + return parameters; + } + cleanup(context) { + for (const shadowPass of this.shadowPasses) { + shadowPass.delete(); + } + this.shadowPasses.length = 0; + this.shadowMaps.length = 0; + if (this.dummyShadowMap) { + this.dummyShadowMap.destroy(); + this.dummyShadowMap = null; + context.deck._removeDefaultShaderModule(shadow_default); + } + } + _calculateMatrices() { + const lightMatrices = []; + for (const light of this.directionalLights) { + const viewMatrix = new Matrix4().lookAt({ + eye: new Vector3(light.direction).negate() + }); + lightMatrices.push(viewMatrix); + } + return lightMatrices; + } + _createShadowPasses(device) { + for (let i = 0; i < this.directionalLights.length; i++) { + const shadowPass = new ShadowPass(device); + this.shadowPasses[i] = shadowPass; + this.shadowMaps[i] = shadowPass.shadowMap; + } + } + _applyDefaultLights() { + const { ambientLight, pointLights, directionalLights } = this; + if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) { + this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS); + this.directionalLights.push(new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]), new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1])); + } + } +}; + +// node_modules/@deck.gl/core/dist/utils/typed-array-manager.js +var TypedArrayManager = class { + constructor(options = {}) { + this._pool = []; + this.opts = { overAlloc: 2, poolSize: 100 }; + this.setOptions(options); + } + setOptions(options) { + Object.assign(this.opts, options); + } + allocate(typedArray, count2, { size = 1, type, padding = 0, copy: copy12 = false, initialize = false, maxCount }) { + const Type2 = type || typedArray && typedArray.constructor || Float32Array; + const newSize = count2 * size + padding; + if (ArrayBuffer.isView(typedArray)) { + if (newSize <= typedArray.length) { + return typedArray; + } + if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) { + return new Type2(typedArray.buffer, 0, newSize); + } + } + let maxSize = Infinity; + if (maxCount) { + maxSize = maxCount * size + padding; + } + const newArray = this._allocate(Type2, newSize, initialize, maxSize); + if (typedArray && copy12) { + newArray.set(typedArray); + } else if (!initialize) { + newArray.fill(0, 0, 4); + } + this._release(typedArray); + return newArray; + } + release(typedArray) { + this._release(typedArray); + } + _allocate(Type2, size, initialize, maxSize) { + let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1); + if (sizeToAllocate > maxSize) { + sizeToAllocate = maxSize; + } + const pool = this._pool; + const byteLength = Type2.BYTES_PER_ELEMENT * sizeToAllocate; + const i = pool.findIndex((b) => b.byteLength >= byteLength); + if (i >= 0) { + const array = new Type2(pool.splice(i, 1)[0], 0, sizeToAllocate); + if (initialize) { + array.fill(0); + } + return array; + } + return new Type2(sizeToAllocate); + } + _release(typedArray) { + if (!ArrayBuffer.isView(typedArray)) { + return; + } + const pool = this._pool; + const { buffer } = typedArray; + const { byteLength } = buffer; + const i = pool.findIndex((b) => b.byteLength >= byteLength); + if (i < 0) { + pool.push(buffer); + } else if (i > 0 || pool.length < this.opts.poolSize) { + pool.splice(i, 0, buffer); + } + if (pool.length > this.opts.poolSize) { + pool.shift(); + } + } +}; +var typed_array_manager_default = new TypedArrayManager(); + +// node_modules/@deck.gl/core/dist/utils/math-utils.js +function createMat42() { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; +} +function getCameraPosition(viewMatrixInverse) { + return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]]; +} +function getFrustumPlanes(viewProjectionMatrix) { + return { + left: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[0], viewProjectionMatrix[7] + viewProjectionMatrix[4], viewProjectionMatrix[11] + viewProjectionMatrix[8], viewProjectionMatrix[15] + viewProjectionMatrix[12]), + right: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[0], viewProjectionMatrix[7] - viewProjectionMatrix[4], viewProjectionMatrix[11] - viewProjectionMatrix[8], viewProjectionMatrix[15] - viewProjectionMatrix[12]), + bottom: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[1], viewProjectionMatrix[7] + viewProjectionMatrix[5], viewProjectionMatrix[11] + viewProjectionMatrix[9], viewProjectionMatrix[15] + viewProjectionMatrix[13]), + top: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[1], viewProjectionMatrix[7] - viewProjectionMatrix[5], viewProjectionMatrix[11] - viewProjectionMatrix[9], viewProjectionMatrix[15] - viewProjectionMatrix[13]), + near: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[2], viewProjectionMatrix[7] + viewProjectionMatrix[6], viewProjectionMatrix[11] + viewProjectionMatrix[10], viewProjectionMatrix[15] + viewProjectionMatrix[14]), + far: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[2], viewProjectionMatrix[7] - viewProjectionMatrix[6], viewProjectionMatrix[11] - viewProjectionMatrix[10], viewProjectionMatrix[15] - viewProjectionMatrix[14]) + }; +} +var scratchVector = new Vector3(); +function getFrustumPlane(a, b, c, d) { + scratchVector.set(a, b, c); + const L = scratchVector.len(); + return { distance: d / L, normal: new Vector3(-a / L, -b / L, -c / L) }; +} +function fp64LowPart2(x) { + return x - Math.fround(x); +} +var scratchArray; +function toDoublePrecisionArray(typedArray, options) { + const { size = 1, startIndex = 0 } = options; + const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length; + const count2 = (endIndex - startIndex) / size; + scratchArray = typed_array_manager_default.allocate(scratchArray, count2, { + type: Float32Array, + size: size * 2 + }); + let sourceIndex = startIndex; + let targetIndex = 0; + while (sourceIndex < endIndex) { + for (let j = 0; j < size; j++) { + const value = typedArray[sourceIndex++]; + scratchArray[targetIndex + j] = value; + scratchArray[targetIndex + j + size] = fp64LowPart2(value); + } + targetIndex += size * 2; + } + return scratchArray.subarray(0, count2 * size * 2); +} +function mergeBounds(boundsList) { + let mergedBounds = null; + let isMerged = false; + for (const bounds of boundsList) { + if (!bounds) + continue; + if (!mergedBounds) { + mergedBounds = bounds; + } else { + if (!isMerged) { + mergedBounds = [ + [mergedBounds[0][0], mergedBounds[0][1]], + [mergedBounds[1][0], mergedBounds[1][1]] + ]; + isMerged = true; + } + mergedBounds[0][0] = Math.min(mergedBounds[0][0], bounds[0][0]); + mergedBounds[0][1] = Math.min(mergedBounds[0][1], bounds[0][1]); + mergedBounds[1][0] = Math.max(mergedBounds[1][0], bounds[1][0]); + mergedBounds[1][1] = Math.max(mergedBounds[1][1], bounds[1][1]); + } + } + return mergedBounds; +} + +// node_modules/@deck.gl/core/dist/viewports/viewport.js +var DEGREES_TO_RADIANS4 = Math.PI / 180; +var IDENTITY2 = createMat42(); +var ZERO_VECTOR2 = [0, 0, 0]; +var DEFAULT_DISTANCE_SCALES = { + unitsPerMeter: [1, 1, 1], + metersPerUnit: [1, 1, 1] +}; +function createProjectionMatrix({ width, height, orthographic, fovyRadians, focalDistance, padding, near, far }) { + const aspect = width / height; + const matrix = orthographic ? new Matrix4().orthographic({ fovy: fovyRadians, aspect, focalDistance, near, far }) : new Matrix4().perspective({ fovy: fovyRadians, aspect, near, far }); + if (padding) { + const { left = 0, right = 0, top = 0, bottom = 0 } = padding; + const offsetX = clamp((left + width - right) / 2, 0, width) - width / 2; + const offsetY = clamp((top + height - bottom) / 2, 0, height) - height / 2; + matrix[8] -= offsetX * 2 / width; + matrix[9] += offsetY * 2 / height; + } + return matrix; +} +var Viewport = class _Viewport { + // eslint-disable-next-line complexity + constructor(opts = {}) { + this._frustumPlanes = {}; + this.id = opts.id || this.constructor.displayName || "viewport"; + this.x = opts.x || 0; + this.y = opts.y || 0; + this.width = opts.width || 1; + this.height = opts.height || 1; + this.zoom = opts.zoom || 0; + this.padding = opts.padding; + this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES; + this.focalDistance = opts.focalDistance || 1; + this.position = opts.position || ZERO_VECTOR2; + this.modelMatrix = opts.modelMatrix || null; + const { longitude, latitude } = opts; + this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude); + this._initProps(opts); + this._initMatrices(opts); + this.equals = this.equals.bind(this); + this.project = this.project.bind(this); + this.unproject = this.unproject.bind(this); + this.projectPosition = this.projectPosition.bind(this); + this.unprojectPosition = this.unprojectPosition.bind(this); + this.projectFlat = this.projectFlat.bind(this); + this.unprojectFlat = this.unprojectFlat.bind(this); + } + get subViewports() { + return null; + } + get metersPerPixel() { + return this.distanceScales.metersPerUnit[2] / this.scale; + } + get projectionMode() { + if (this.isGeospatial) { + return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET; + } + return PROJECTION_MODE.IDENTITY; + } + // Two viewports are equal if width and height are identical, and if + // their view and projection matrices are (approximately) equal. + equals(viewport) { + if (!(viewport instanceof _Viewport)) { + return false; + } + if (this === viewport) { + return true; + } + return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix); + } + /** + * Projects xyz (possibly latitude and longitude) to pixel coordinates in window + * using viewport projection parameters + * - [longitude, latitude] to [x, y] + * - [longitude, latitude, Z] => [x, y, z] + * Note: By default, returns top-left coordinates for canvas/SVG type render + * + * @param {Array} lngLatZ - [lng, lat] or [lng, lat, Z] + * @param {Object} opts - options + * @param {Object} opts.topLeft=true - Whether projected coords are top left + * @return {Array} - [x, y] or [x, y, z] in top left coords + */ + project(xyz, { topLeft = true } = {}) { + const worldPosition = this.projectPosition(xyz); + const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix); + const [x, y] = coord; + const y2 = topLeft ? y : this.height - y; + return xyz.length === 2 ? [x, y2] : [x, y2, coord[2]]; + } + /** + * Unproject pixel coordinates on screen onto world coordinates, + * (possibly [lon, lat]) on map. + * - [x, y] => [lng, lat] + * - [x, y, z] => [lng, lat, Z] + * @param {Array} xyz - + * @param {Object} opts - options + * @param {Object} opts.topLeft=true - Whether origin is top left + * @return {Array|null} - [lng, lat, Z] or [X, Y, Z] + */ + unproject(xyz, { topLeft = true, targetZ } = {}) { + const [x, y, z] = xyz; + const y2 = topLeft ? y : this.height - y; + const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2]; + const coord = pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix, targetZWorld); + const [X, Y, Z] = this.unprojectPosition(coord); + if (Number.isFinite(z)) { + return [X, Y, Z]; + } + return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; + } + // NON_LINEAR PROJECTION HOOKS + // Used for web meractor projection + projectPosition(xyz) { + const [X, Y] = this.projectFlat(xyz); + const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2]; + return [X, Y, Z]; + } + unprojectPosition(xyz) { + const [X, Y] = this.unprojectFlat(xyz); + const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2]; + return [X, Y, Z]; + } + /** + * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile. + * Performs the nonlinear part of the web mercator projection. + * Remaining projection is done with 4x4 matrices which also handles + * perspective. + * @param {Array} lngLat - [lng, lat] coordinates + * Specifies a point on the sphere to project onto the map. + * @return {Array} [x,y] coordinates. + */ + projectFlat(xyz) { + if (this.isGeospatial) { + const result = lngLatToWorld(xyz); + result[1] = clamp(result[1], -318, 830); + return result; + } + return xyz; + } + /** + * Unproject world point [x,y] on map onto {lat, lon} on sphere + * @param {object|Vector} xy - object with {x,y} members + * representing point on projected map plane + * @return {GeoCoordinates} - object with {lat,lon} of point on sphere. + * Has toArray method if you need a GeoJSON Array. + * Per cartographic tradition, lat and lon are specified as degrees. + */ + unprojectFlat(xyz) { + if (this.isGeospatial) { + return worldToLngLat(xyz); + } + return xyz; + } + /** + * Get bounds of the current viewport + * @return {Array} - [minX, minY, maxX, maxY] + */ + getBounds(options = {}) { + const unprojectOption = { targetZ: options.z || 0 }; + const topLeft = this.unproject([0, 0], unprojectOption); + const topRight = this.unproject([this.width, 0], unprojectOption); + const bottomLeft = this.unproject([0, this.height], unprojectOption); + const bottomRight = this.unproject([this.width, this.height], unprojectOption); + return [ + Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), + Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), + Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), + Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]) + ]; + } + getDistanceScales(coordinateOrigin) { + if (coordinateOrigin) { + return getDistanceScales({ + longitude: coordinateOrigin[0], + latitude: coordinateOrigin[1], + highPrecision: true + }); + } + return this.distanceScales; + } + containsPixel({ x, y, width = 1, height = 1 }) { + return x < this.x + this.width && this.x < x + width && y < this.y + this.height && this.y < y + height; + } + // Extract frustum planes in common space + getFrustumPlanes() { + if (this._frustumPlanes.near) { + return this._frustumPlanes; + } + Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix)); + return this._frustumPlanes; + } + // EXPERIMENTAL METHODS + /** + * Needed by panning and linear transition + * Pan the viewport to place a given world coordinate at screen point [x, y] + * + * @param {Array} coords - world coordinates + * @param {Array} pixel - [x,y] coordinates on screen + * @return {Object} props of the new viewport + */ + panByPosition(coords, pixel) { + return null; + } + // INTERNAL METHODS + /* eslint-disable complexity, max-statements */ + _initProps(opts) { + const longitude = opts.longitude; + const latitude = opts.latitude; + if (this.isGeospatial) { + if (!Number.isFinite(opts.zoom)) { + this.zoom = getMeterZoom({ latitude }) + Math.log2(this.focalDistance); + } + this.distanceScales = opts.distanceScales || getDistanceScales({ latitude, longitude }); + } + const scale13 = Math.pow(2, this.zoom); + this.scale = scale13; + const { position, modelMatrix } = opts; + let meterOffset = ZERO_VECTOR2; + if (position) { + meterOffset = modelMatrix ? new Matrix4(modelMatrix).transformAsVector(position, []) : position; + } + if (this.isGeospatial) { + const center = this.projectPosition([longitude, latitude, 0]); + this.center = new Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center); + } else { + this.center = this.projectPosition(meterOffset); + } + } + /* eslint-enable complexity, max-statements */ + _initMatrices(opts) { + const { + // View matrix + viewMatrix = IDENTITY2, + // Projection matrix + projectionMatrix = null, + // Projection matrix parameters, used if projectionMatrix not supplied + orthographic = false, + fovyRadians, + fovy = 75, + near = 0.1, + // Distance of near clipping plane + far = 1e3, + // Distance of far clipping plane + padding = null, + // Center offset in pixels + focalDistance = 1 + } = opts; + this.viewMatrixUncentered = viewMatrix; + this.viewMatrix = new Matrix4().multiplyRight(viewMatrix).translate(new Vector3(this.center).negate()); + this.projectionMatrix = projectionMatrix || createProjectionMatrix({ + width: this.width, + height: this.height, + orthographic, + fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS4, + focalDistance, + padding, + near, + far + }); + const vpm = createMat42(); + mat4_exports.multiply(vpm, vpm, this.projectionMatrix); + mat4_exports.multiply(vpm, vpm, this.viewMatrix); + this.viewProjectionMatrix = vpm; + this.viewMatrixInverse = mat4_exports.invert([], this.viewMatrix) || this.viewMatrix; + this.cameraPosition = getCameraPosition(this.viewMatrixInverse); + const viewportMatrix = createMat42(); + const pixelProjectionMatrix = createMat42(); + mat4_exports.scale(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]); + mat4_exports.translate(viewportMatrix, viewportMatrix, [1, -1, 0]); + mat4_exports.multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix); + this.pixelProjectionMatrix = pixelProjectionMatrix; + this.pixelUnprojectionMatrix = mat4_exports.invert(createMat42(), this.pixelProjectionMatrix); + if (!this.pixelUnprojectionMatrix) { + log_default.warn("Pixel project matrix not invertible")(); + } + } +}; +Viewport.displayName = "Viewport"; +var viewport_default = Viewport; + +// node_modules/@deck.gl/core/dist/viewports/web-mercator-viewport.js +var WebMercatorViewport2 = class _WebMercatorViewport extends viewport_default { + /* eslint-disable complexity, max-statements */ + constructor(opts = {}) { + const { + latitude = 0, + longitude = 0, + zoom = 0, + pitch = 0, + bearing = 0, + nearZMultiplier = 0.1, + farZMultiplier = 1.01, + nearZ, + farZ, + orthographic = false, + projectionMatrix, + repeat = false, + worldOffset = 0, + position, + padding, + // backward compatibility + // TODO: remove in v9 + legacyMeterSizes = false + } = opts; + let { width, height, altitude = 1.5 } = opts; + const scale13 = Math.pow(2, zoom); + width = width || 1; + height = height || 1; + let fovy; + let projectionParameters = null; + if (projectionMatrix) { + altitude = projectionMatrix[5] / 2; + fovy = altitudeToFovy(altitude); + } else { + if (opts.fovy) { + fovy = opts.fovy; + altitude = fovyToAltitude(fovy); + } else { + fovy = altitudeToFovy(altitude); + } + let offset; + if (padding) { + const { top = 0, bottom = 0 } = padding; + offset = [0, clamp((top + height - bottom) / 2, 0, height) - height / 2]; + } + projectionParameters = getProjectionParameters({ + width, + height, + scale: scale13, + center: position && [0, 0, position[2] * unitsPerMeter(latitude)], + offset, + pitch, + fovy, + nearZMultiplier, + farZMultiplier + }); + if (Number.isFinite(nearZ)) { + projectionParameters.near = nearZ; + } + if (Number.isFinite(farZ)) { + projectionParameters.far = farZ; + } + } + let viewMatrixUncentered = getViewMatrix({ + height, + pitch, + bearing, + scale: scale13, + altitude + }); + if (worldOffset) { + const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]); + viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered); + } + super({ + ...opts, + // x, y, + width, + height, + // view matrix + viewMatrix: viewMatrixUncentered, + longitude, + latitude, + zoom, + // projection matrix parameters + ...projectionParameters, + fovy, + focalDistance: altitude + }); + this.latitude = latitude; + this.longitude = longitude; + this.zoom = zoom; + this.pitch = pitch; + this.bearing = bearing; + this.altitude = altitude; + this.fovy = fovy; + this.orthographic = orthographic; + this._subViewports = repeat ? [] : null; + this._pseudoMeters = legacyMeterSizes; + Object.freeze(this); + } + /* eslint-enable complexity, max-statements */ + get subViewports() { + if (this._subViewports && !this._subViewports.length) { + const bounds = this.getBounds(); + const minOffset = Math.floor((bounds[0] + 180) / 360); + const maxOffset = Math.ceil((bounds[2] - 180) / 360); + for (let x = minOffset; x <= maxOffset; x++) { + const offsetViewport = x ? new _WebMercatorViewport({ + ...this, + worldOffset: x + }) : this; + this._subViewports.push(offsetViewport); + } + } + return this._subViewports; + } + projectPosition(xyz) { + if (this._pseudoMeters) { + return super.projectPosition(xyz); + } + const [X, Y] = this.projectFlat(xyz); + const Z = (xyz[2] || 0) * unitsPerMeter(xyz[1]); + return [X, Y, Z]; + } + unprojectPosition(xyz) { + if (this._pseudoMeters) { + return super.unprojectPosition(xyz); + } + const [X, Y] = this.unprojectFlat(xyz); + const Z = (xyz[2] || 0) / unitsPerMeter(Y); + return [X, Y, Z]; + } + /** + * Add a meter delta to a base lnglat coordinate, returning a new lnglat array + * + * Note: Uses simple linear approximation around the viewport center + * Error increases with size of offset (roughly 1% per 100km) + * + * @param {[Number,Number]|[Number,Number,Number]) lngLatZ - base coordinate + * @param {[Number,Number]|[Number,Number,Number]) xyz - array of meter deltas + * @return {[Number,Number]|[Number,Number,Number]) array of [lng,lat,z] deltas + */ + addMetersToLngLat(lngLatZ, xyz) { + return addMetersToLngLat(lngLatZ, xyz); + } + panByPosition(coords, pixel) { + const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix); + const toLocation = this.projectFlat(coords); + const translate5 = vec2_exports.add([], toLocation, vec2_exports.negate([], fromLocation)); + const newCenter = vec2_exports.add([], this.center, translate5); + const [longitude, latitude] = this.unprojectFlat(newCenter); + return { longitude, latitude }; + } + getBounds(options = {}) { + const corners = getBounds(this, options.z || 0); + return [ + Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), + Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]), + Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), + Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1]) + ]; + } + /** + * Returns a new viewport that fit around the given rectangle. + * Only supports non-perspective mode. + */ + fitBounds(bounds, options = {}) { + const { width, height } = this; + const { longitude, latitude, zoom } = fitBounds({ width, height, bounds, ...options }); + return new _WebMercatorViewport({ width, height, longitude, latitude, zoom }); + } +}; +WebMercatorViewport2.displayName = "WebMercatorViewport"; +var web_mercator_viewport_default = WebMercatorViewport2; + +// node_modules/@deck.gl/core/dist/shaderlib/project/project-functions.js +var DEFAULT_COORDINATE_ORIGIN2 = [0, 0, 0]; +function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) { + const p = viewport.projectPosition(lngLatZ); + if (offsetMode && viewport instanceof web_mercator_viewport_default) { + const [longitude, latitude, z = 0] = lngLatZ; + const distanceScales = viewport.getDistanceScales([longitude, latitude]); + p[2] = z * distanceScales.unitsPerMeter[2]; + } + return p; +} +function normalizeParameters(opts) { + const { viewport, modelMatrix, coordinateOrigin } = opts; + let { coordinateSystem, fromCoordinateSystem, fromCoordinateOrigin } = opts; + if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; + } + if (fromCoordinateSystem === void 0) { + fromCoordinateSystem = coordinateSystem; + } + if (fromCoordinateOrigin === void 0) { + fromCoordinateOrigin = coordinateOrigin; + } + return { + viewport, + coordinateSystem, + coordinateOrigin, + modelMatrix, + fromCoordinateSystem, + fromCoordinateOrigin + }; +} +function getWorldPosition(position, { viewport, modelMatrix, coordinateSystem, coordinateOrigin, offsetMode }) { + let [x, y, z = 0] = position; + if (modelMatrix) { + [x, y, z] = vec4_exports.transformMat4([], [x, y, z, 1], modelMatrix); + } + switch (coordinateSystem) { + case COORDINATE_SYSTEM.LNGLAT: + return lngLatZToWorldPosition([x, y, z], viewport, offsetMode); + case COORDINATE_SYSTEM.LNGLAT_OFFSETS: + return lngLatZToWorldPosition([x + coordinateOrigin[0], y + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)], viewport, offsetMode); + case COORDINATE_SYSTEM.METER_OFFSETS: + return lngLatZToWorldPosition(addMetersToLngLat(coordinateOrigin, [x, y, z]), viewport, offsetMode); + case COORDINATE_SYSTEM.CARTESIAN: + default: + return viewport.isGeospatial ? [x + coordinateOrigin[0], y + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x, y, z]); + } +} +function projectPosition(position, params) { + const { viewport, coordinateSystem, coordinateOrigin, modelMatrix, fromCoordinateSystem, fromCoordinateOrigin } = normalizeParameters(params); + const { autoOffset = true } = params; + const { geospatialOrigin = DEFAULT_COORDINATE_ORIGIN2, shaderCoordinateOrigin = DEFAULT_COORDINATE_ORIGIN2, offsetMode = false } = autoOffset ? getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin) : {}; + const worldPosition = getWorldPosition(position, { + viewport, + modelMatrix, + coordinateSystem: fromCoordinateSystem, + coordinateOrigin: fromCoordinateOrigin, + offsetMode + }); + if (offsetMode) { + const positionCommonSpace = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); + vec3_exports.sub(worldPosition, worldPosition, positionCommonSpace); + } + return worldPosition; +} + +// node_modules/@luma.gl/engine/dist/animation/timeline.js +var channelHandles = 1; +var animationHandles = 1; +var Timeline = class { + time = 0; + channels = /* @__PURE__ */ new Map(); + animations = /* @__PURE__ */ new Map(); + playing = false; + lastEngineTime = -1; + constructor() { + } + addChannel(props) { + const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props; + const channelId = channelHandles++; + const channel = { + time: 0, + delay, + duration, + rate, + repeat + }; + this._setChannelTime(channel, this.time); + this.channels.set(channelId, channel); + return channelId; + } + removeChannel(channelId) { + this.channels.delete(channelId); + for (const [animationHandle, animation] of this.animations) { + if (animation.channel === channelId) { + this.detachAnimation(animationHandle); + } + } + } + isFinished(channelId) { + const channel = this.channels.get(channelId); + if (channel === void 0) { + return false; + } + return this.time >= channel.delay + channel.duration * channel.repeat; + } + getTime(channelId) { + if (channelId === void 0) { + return this.time; + } + const channel = this.channels.get(channelId); + if (channel === void 0) { + return -1; + } + return channel.time; + } + setTime(time) { + this.time = Math.max(0, time); + const channels = this.channels.values(); + for (const channel of channels) { + this._setChannelTime(channel, this.time); + } + const animations = this.animations.values(); + for (const animationData of animations) { + const { animation, channel } = animationData; + animation.setTime(this.getTime(channel)); + } + } + play() { + this.playing = true; + } + pause() { + this.playing = false; + this.lastEngineTime = -1; + } + reset() { + this.setTime(0); + } + attachAnimation(animation, channelHandle) { + const animationHandle = animationHandles++; + this.animations.set(animationHandle, { + animation, + channel: channelHandle + }); + animation.setTime(this.getTime(channelHandle)); + return animationHandle; + } + detachAnimation(channelId) { + this.animations.delete(channelId); + } + update(engineTime) { + if (this.playing) { + if (this.lastEngineTime === -1) { + this.lastEngineTime = engineTime; + } + this.setTime(this.time + (engineTime - this.lastEngineTime)); + this.lastEngineTime = engineTime; + } + } + _setChannelTime(channel, time) { + const offsetTime = time - channel.delay; + const totalDuration = channel.duration * channel.repeat; + if (offsetTime >= totalDuration) { + channel.time = channel.duration * channel.rate; + } else { + channel.time = Math.max(0, offsetTime) % channel.duration; + channel.time *= channel.rate; + } + } +}; + +// node_modules/@luma.gl/engine/dist/animation-loop/animation-loop.js +var statIdCounter = 0; +var DEFAULT_ANIMATION_LOOP_PROPS = { + device: null, + onAddHTML: () => "", + onInitialize: async () => { + return null; + }, + onRender: () => { + }, + onFinalize: () => { + }, + onError: (error) => console.error(error), + // eslint-disable-line no-console + stats: luma.stats.get(`animation-loop-${statIdCounter++}`), + // view parameters + useDevicePixels: true, + autoResizeViewport: false, + autoResizeDrawingBuffer: false +}; +var AnimationLoop = class { + device = null; + canvas = null; + props; + animationProps = null; + timeline = null; + stats; + cpuTime; + gpuTime; + frameRate; + display; + needsRedraw = "initialized"; + _initialized = false; + _running = false; + _animationFrameId = null; + _nextFramePromise = null; + _resolveNextFrame = null; + _cpuStartTime = 0; + // _gpuTimeQuery: Query | null = null; + /* + * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context + */ + constructor(props) { + this.props = { ...DEFAULT_ANIMATION_LOOP_PROPS, ...props }; + props = this.props; + if (!props.device) { + throw new Error("No device provided"); + } + const { useDevicePixels = true } = this.props; + this.stats = props.stats || new Stats({ id: "animation-loop-stats" }); + this.cpuTime = this.stats.get("CPU Time"); + this.gpuTime = this.stats.get("GPU Time"); + this.frameRate = this.stats.get("Frame Rate"); + this.setProps({ + autoResizeViewport: props.autoResizeViewport, + autoResizeDrawingBuffer: props.autoResizeDrawingBuffer, + useDevicePixels + }); + this.start = this.start.bind(this); + this.stop = this.stop.bind(this); + this._onMousemove = this._onMousemove.bind(this); + this._onMouseleave = this._onMouseleave.bind(this); + } + destroy() { + this.stop(); + this._setDisplay(null); + } + /** @deprecated Use .destroy() */ + delete() { + this.destroy(); + } + /** Flags this animation loop as needing redraw */ + setNeedsRedraw(reason) { + this.needsRedraw = this.needsRedraw || reason; + return this; + } + /** TODO - move these props to CanvasContext? */ + setProps(props) { + if ("autoResizeViewport" in props) { + this.props.autoResizeViewport = props.autoResizeViewport || false; + } + if ("autoResizeDrawingBuffer" in props) { + this.props.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer || false; + } + if ("useDevicePixels" in props) { + this.props.useDevicePixels = props.useDevicePixels || false; + } + return this; + } + /** Starts a render loop if not already running */ + async start() { + if (this._running) { + return this; + } + this._running = true; + try { + let appContext; + if (!this._initialized) { + this._initialized = true; + await this._initDevice(); + this._initialize(); + await this.props.onInitialize(this._getAnimationProps()); + } + if (!this._running) { + return null; + } + if (appContext !== false) { + this._cancelAnimationFrame(); + this._requestAnimationFrame(); + } + return this; + } catch (err) { + const error = err instanceof Error ? err : new Error("Unknown error"); + this.props.onError(error); + throw error; + } + } + /** Stops a render loop if already running, finalizing */ + stop() { + if (this._running) { + if (this.animationProps) { + this.props.onFinalize(this.animationProps); + } + this._cancelAnimationFrame(); + this._nextFramePromise = null; + this._resolveNextFrame = null; + this._running = false; + } + return this; + } + /** Explicitly draw a frame */ + redraw() { + if (this.device?.isLost) { + return this; + } + this._beginFrameTimers(); + this._setupFrame(); + this._updateAnimationProps(); + this._renderFrame(this._getAnimationProps()); + this._clearNeedsRedraw(); + if (this._resolveNextFrame) { + this._resolveNextFrame(this); + this._nextFramePromise = null; + this._resolveNextFrame = null; + } + this._endFrameTimers(); + return this; + } + /** Add a timeline, it will be automatically updated by the animation loop. */ + attachTimeline(timeline) { + this.timeline = timeline; + return this.timeline; + } + /** Remove a timeline */ + detachTimeline() { + this.timeline = null; + } + /** Wait until a render completes */ + waitForRender() { + this.setNeedsRedraw("waitForRender"); + if (!this._nextFramePromise) { + this._nextFramePromise = new Promise((resolve2) => { + this._resolveNextFrame = resolve2; + }); + } + return this._nextFramePromise; + } + /** TODO - should use device.deviceContext */ + async toDataURL() { + this.setNeedsRedraw("toDataURL"); + await this.waitForRender(); + if (this.canvas instanceof HTMLCanvasElement) { + return this.canvas.toDataURL(); + } + throw new Error("OffscreenCanvas"); + } + // PRIVATE METHODS + _initialize() { + this._startEventHandling(); + this._initializeAnimationProps(); + this._updateAnimationProps(); + this._resizeCanvasDrawingBuffer(); + this._resizeViewport(); + } + _setDisplay(display) { + if (this.display) { + this.display.destroy(); + this.display.animationLoop = null; + } + if (display) { + display.animationLoop = this; + } + this.display = display; + } + _requestAnimationFrame() { + if (!this._running) { + return; + } + this._animationFrameId = requestAnimationFrame2(this._animationFrame.bind(this)); + } + _cancelAnimationFrame() { + if (this._animationFrameId === null) { + return; + } + cancelAnimationFrame2(this._animationFrameId); + this._animationFrameId = null; + } + _animationFrame() { + if (!this._running) { + return; + } + this.redraw(); + this._requestAnimationFrame(); + } + // Called on each frame, can be overridden to call onRender multiple times + // to support e.g. stereoscopic rendering + _renderFrame(animationProps) { + if (this.display) { + this.display._renderFrame(animationProps); + return; + } + this.props.onRender(this._getAnimationProps()); + this.device.submit(); + } + _clearNeedsRedraw() { + this.needsRedraw = false; + } + _setupFrame() { + this._resizeCanvasDrawingBuffer(); + this._resizeViewport(); + } + // Initialize the object that will be passed to app callbacks + _initializeAnimationProps() { + if (!this.device) { + throw new Error("loop"); + } + this.animationProps = { + animationLoop: this, + device: this.device, + canvas: this.device?.canvasContext?.canvas, + timeline: this.timeline, + // Initial values + useDevicePixels: this.props.useDevicePixels, + needsRedraw: false, + // Placeholders + width: 1, + height: 1, + aspect: 1, + // Animation props + time: 0, + startTime: Date.now(), + engineTime: 0, + tick: 0, + tock: 0, + // Experimental + _mousePosition: null + // Event props + }; + } + _getAnimationProps() { + if (!this.animationProps) { + throw new Error("animationProps"); + } + return this.animationProps; + } + // Update the context object that will be passed to app callbacks + _updateAnimationProps() { + if (!this.animationProps) { + return; + } + const { width, height, aspect } = this._getSizeAndAspect(); + if (width !== this.animationProps.width || height !== this.animationProps.height) { + this.setNeedsRedraw("drawing buffer resized"); + } + if (aspect !== this.animationProps.aspect) { + this.setNeedsRedraw("drawing buffer aspect changed"); + } + this.animationProps.width = width; + this.animationProps.height = height; + this.animationProps.aspect = aspect; + this.animationProps.needsRedraw = this.needsRedraw; + this.animationProps.engineTime = Date.now() - this.animationProps.startTime; + if (this.timeline) { + this.timeline.update(this.animationProps.engineTime); + } + this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60); + this.animationProps.tock++; + this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime; + } + /** Wait for supplied device */ + async _initDevice() { + this.device = await this.props.device; + if (!this.device) { + throw new Error("No device provided"); + } + this.canvas = this.device.canvasContext?.canvas || null; + } + _createInfoDiv() { + if (this.canvas && this.props.onAddHTML) { + const wrapperDiv = document.createElement("div"); + document.body.appendChild(wrapperDiv); + wrapperDiv.style.position = "relative"; + const div7 = document.createElement("div"); + div7.style.position = "absolute"; + div7.style.left = "10px"; + div7.style.bottom = "10px"; + div7.style.width = "300px"; + div7.style.background = "white"; + if (this.canvas instanceof HTMLCanvasElement) { + wrapperDiv.appendChild(this.canvas); + } + wrapperDiv.appendChild(div7); + const html = this.props.onAddHTML(div7); + if (html) { + div7.innerHTML = html; + } + } + } + _getSizeAndAspect() { + if (!this.device) { + return { width: 1, height: 1, aspect: 1 }; + } + const [width, height] = this.device?.canvasContext?.getPixelSize() || [1, 1]; + let aspect = 1; + const canvas2 = this.device?.canvasContext?.canvas; + if (canvas2 && canvas2.clientHeight) { + aspect = canvas2.clientWidth / canvas2.clientHeight; + } else if (width > 0 && height > 0) { + aspect = width / height; + } + return { width, height, aspect }; + } + /** Default viewport setup */ + _resizeViewport() { + if (this.props.autoResizeViewport && this.device.gl) { + this.device.gl.viewport( + 0, + 0, + // @ts-expect-error Expose canvasContext + this.device.gl.drawingBufferWidth, + // @ts-expect-error Expose canvasContext + this.device.gl.drawingBufferHeight + ); + } + } + /** + * Resize the render buffer of the canvas to match canvas client size + * Optionally multiplying with devicePixel ratio + */ + _resizeCanvasDrawingBuffer() { + if (this.props.autoResizeDrawingBuffer) { + this.device?.canvasContext?.resize({ useDevicePixels: this.props.useDevicePixels }); + } + } + _beginFrameTimers() { + this.frameRate.timeEnd(); + this.frameRate.timeStart(); + this.cpuTime.timeStart(); + } + _endFrameTimers() { + this.cpuTime.timeEnd(); + } + // Event handling + _startEventHandling() { + if (this.canvas) { + this.canvas.addEventListener("mousemove", this._onMousemove.bind(this)); + this.canvas.addEventListener("mouseleave", this._onMouseleave.bind(this)); + } + } + _onMousemove(event) { + if (event instanceof MouseEvent) { + this._getAnimationProps()._mousePosition = [event.offsetX, event.offsetY]; + } + } + _onMouseleave(event) { + this._getAnimationProps()._mousePosition = null; + } +}; + +// node_modules/@luma.gl/engine/dist/geometry/gpu-geometry.js +var GPUGeometry = class { + id; + userData = {}; + /** Determines how vertices are read from the 'vertex' attributes */ + topology; + bufferLayout = []; + vertexCount; + indices; + attributes; + constructor(props) { + this.id = props.id || uid("geometry"); + this.topology = props.topology; + this.indices = props.indices || null; + this.attributes = props.attributes; + this.vertexCount = props.vertexCount; + this.bufferLayout = props.bufferLayout || []; + if (this.indices) { + assert6(this.indices.usage === Buffer2.INDEX); + } + } + destroy() { + this.indices?.destroy(); + for (const attribute of Object.values(this.attributes)) { + attribute.destroy(); + } + } + getVertexCount() { + return this.vertexCount; + } + getAttributes() { + return this.attributes; + } + getIndexes() { + return this.indices; + } + _calculateVertexCount(positions) { + const vertexCount = positions.byteLength / 12; + return vertexCount; + } +}; +function makeGPUGeometry(device, geometry) { + if (geometry instanceof GPUGeometry) { + return geometry; + } + const indices = getIndexBufferFromGeometry(device, geometry); + const { attributes, bufferLayout } = getAttributeBuffersFromGeometry(device, geometry); + return new GPUGeometry({ + topology: geometry.topology || "triangle-list", + bufferLayout, + vertexCount: geometry.vertexCount, + indices, + attributes + }); +} +function getIndexBufferFromGeometry(device, geometry) { + if (!geometry.indices) { + return void 0; + } + const data = geometry.indices.value; + return device.createBuffer({ usage: Buffer2.INDEX, data }); +} +function getAttributeBuffersFromGeometry(device, geometry) { + const bufferLayout = []; + const attributes = {}; + for (const [attributeName, attribute] of Object.entries(geometry.attributes)) { + let name2 = attributeName; + switch (attributeName) { + case "POSITION": + name2 = "positions"; + break; + case "NORMAL": + name2 = "normals"; + break; + case "TEXCOORD_0": + name2 = "texCoords"; + break; + case "COLOR_0": + name2 = "colors"; + break; + } + attributes[name2] = device.createBuffer({ data: attribute.value, id: `${attributeName}-buffer` }); + const { value, size, normalized } = attribute; + bufferLayout.push({ name: name2, format: getVertexFormatFromAttribute(value, size, normalized) }); + } + const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices); + return { attributes, bufferLayout, vertexCount }; +} + +// node_modules/@luma.gl/engine/dist/shader-inputs.js +var ShaderInputs = class { + /** + * The map of modules + * @todo should should this include the resolved dependencies? + */ + modules; + /** Stores the uniform values for each module */ + moduleUniforms; + /** Stores the uniform bindings for each module */ + moduleBindings; + /** Tracks if uniforms have changed */ + moduleUniformsChanged; + /** + * Create a new UniformStore instance + * @param modules + */ + constructor(modules) { + const resolvedModules = resolveModules(Object.values(modules).filter((module) => module.dependencies)); + for (const resolvedModule of resolvedModules) { + modules[resolvedModule.name] = resolvedModule; + } + log2.log(1, "Creating ShaderInputs with modules", Object.keys(modules))(); + this.modules = modules; + this.moduleUniforms = {}; + this.moduleBindings = {}; + for (const [name2, module] of Object.entries(modules)) { + const moduleName = name2; + this.moduleUniforms[moduleName] = module.defaultUniforms || {}; + this.moduleBindings[moduleName] = {}; + } + } + /** Destroy */ + destroy() { + } + /** + * Set module props + */ + setProps(props) { + for (const name2 of Object.keys(props)) { + const moduleName = name2; + const moduleProps = props[moduleName]; + const module = this.modules[moduleName]; + if (!module) { + log2.warn(`Module ${name2} not found`)(); + continue; + } + const oldUniforms = this.moduleUniforms[moduleName]; + const oldBindings = this.moduleBindings[moduleName]; + const uniformsAndBindings = module.getUniforms?.(moduleProps, oldUniforms) || moduleProps; + const { uniforms, bindings } = splitUniformsAndBindings(uniformsAndBindings); + this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms }; + this.moduleBindings[moduleName] = { ...oldBindings, ...bindings }; + } + } + /** Merges all bindings for the shader (from the various modules) */ + // getUniformBlocks(): Record { + // return this.moduleUniforms; + // } + /** + * Return the map of modules + * @todo should should this include the resolved dependencies? + */ + getModules() { + return Object.values(this.modules); + } + /** Get all uniform values for all modules */ + getUniformValues() { + return this.moduleUniforms; + } + /** Merges all bindings for the shader (from the various modules) */ + getBindings() { + const bindings = {}; + for (const moduleBindings of Object.values(this.moduleBindings)) { + Object.assign(bindings, moduleBindings); + } + return bindings; + } + getDebugTable() { + const table = {}; + for (const [moduleName, module] of Object.entries(this.moduleUniforms)) { + for (const [key, value] of Object.entries(module)) { + table[`${moduleName}.${key}`] = { + type: this.modules[moduleName].uniformTypes?.[key], + value: String(value) + }; + } + } + return table; + } +}; + +// node_modules/@luma.gl/engine/dist/lib/pipeline-factory.js +var PipelineFactory = class _PipelineFactory { + static defaultProps = { ...RenderPipeline.defaultProps }; + device; + _hashCounter = 0; + _hashes = {}; + _renderPipelineCache = {}; + _computePipelineCache = {}; + /** Get the singleton default pipeline factory for the specified device */ + static getDefaultPipelineFactory(device) { + device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new _PipelineFactory(device); + return device._lumaData.defaultPipelineFactory; + } + constructor(device) { + this.device = device; + } + /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */ + createRenderPipeline(props) { + const allProps = { ...RenderPipeline.defaultProps, ...props }; + const hash = this._hashRenderPipeline(allProps); + if (!this._renderPipelineCache[hash]) { + const pipeline = this.device.createRenderPipeline({ + ...allProps, + id: allProps.id ? `${allProps.id}-cached` : void 0 + }); + pipeline.hash = hash; + this._renderPipelineCache[hash] = { pipeline, useCount: 0 }; + } + this._renderPipelineCache[hash].useCount++; + return this._renderPipelineCache[hash].pipeline; + } + createComputePipeline(props) { + const allProps = { ...ComputePipeline.defaultProps, ...props }; + const hash = this._hashComputePipeline(allProps); + if (!this._computePipelineCache[hash]) { + const pipeline = this.device.createComputePipeline({ + ...allProps, + id: allProps.id ? `${allProps.id}-cached` : void 0 + }); + pipeline.hash = hash; + this._computePipelineCache[hash] = { pipeline, useCount: 0 }; + } + this._computePipelineCache[hash].useCount++; + return this._computePipelineCache[hash].pipeline; + } + release(pipeline) { + const hash = pipeline.hash; + const cache3 = pipeline instanceof ComputePipeline ? this._computePipelineCache : this._renderPipelineCache; + cache3[hash].useCount--; + if (cache3[hash].useCount === 0) { + cache3[hash].pipeline.destroy(); + delete cache3[hash]; + } + } + // PRIVATE + _hashComputePipeline(props) { + const shaderHash = this._getHash(props.shader.source); + return `${shaderHash}`; + } + /** Calculate a hash based on all the inputs for a render pipeline */ + _hashRenderPipeline(props) { + const vsHash = this._getHash(props.vs.source); + const fsHash = props.fs ? this._getHash(props.fs.source) : 0; + const varyingHash = "-"; + const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout)); + switch (this.device.type) { + case "webgl": + return `${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`; + default: + const parameterHash = this._getHash(JSON.stringify(props.parameters)); + return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}`; + } + } + _getHash(key) { + if (this._hashes[key] === void 0) { + this._hashes[key] = this._hashCounter++; + } + return this._hashes[key]; + } +}; + +// node_modules/@luma.gl/engine/dist/lib/shader-factory.js +var ShaderFactory = class _ShaderFactory { + static defaultProps = { ...Shader.defaultProps }; + device; + _cache = {}; + /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */ + static getDefaultShaderFactory(device) { + device._lumaData.defaultShaderFactory ||= new _ShaderFactory(device); + return device._lumaData.defaultShaderFactory; + } + /** @internal */ + constructor(device) { + this.device = device; + } + /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */ + createShader(props) { + const key = this._hashShader(props); + let cacheEntry = this._cache[key]; + if (!cacheEntry) { + const shader = this.device.createShader({ + ...props, + id: props.id ? `${props.id}-cached` : void 0 + }); + this._cache[key] = cacheEntry = { shader, useCount: 0 }; + } + cacheEntry.useCount++; + return cacheEntry.shader; + } + /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */ + release(shader) { + const key = this._hashShader(shader); + const cacheEntry = this._cache[key]; + if (cacheEntry) { + cacheEntry.useCount--; + if (cacheEntry.useCount === 0) { + delete this._cache[key]; + cacheEntry.shader.destroy(); + } + } + } + // PRIVATE + _hashShader(value) { + return `${value.stage}:${value.source}`; + } +}; + +// node_modules/@luma.gl/engine/dist/debug/debug-shader-layout.js +function getDebugTableForShaderLayout(layout, name2) { + const table = {}; + const header = "Values"; + if (layout.attributes.length === 0 && !layout.varyings?.length) { + return { "No attributes or varyings": { [header]: "N/A" } }; + } + for (const attributeDeclaration of layout.attributes) { + if (attributeDeclaration) { + const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`; + table[`in ${glslDeclaration}`] = { [header]: attributeDeclaration.stepMode || "vertex" }; + } + } + for (const varyingDeclaration of layout.varyings || []) { + const glslDeclaration = `${varyingDeclaration.location} ${varyingDeclaration.name}`; + table[`out ${glslDeclaration}`] = { [header]: JSON.stringify(varyingDeclaration.accessor) }; + } + return table; +} + +// node_modules/@luma.gl/engine/dist/debug/debug-framebuffer.js +var canvas = null; +var ctx = null; +function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgbaScale = 1 }) { + if (!canvas) { + canvas = document.createElement("canvas"); + canvas.id = id; + canvas.title = id; + canvas.style.zIndex = "100"; + canvas.style.position = "absolute"; + canvas.style.top = top; + canvas.style.left = left; + canvas.style.border = "blue 1px solid"; + canvas.style.transform = "scaleY(-1)"; + document.body.appendChild(canvas); + ctx = canvas.getContext("2d"); + } + if (canvas.width !== fbo.width || canvas.height !== fbo.height) { + canvas.width = fbo.width / 2; + canvas.height = fbo.height / 2; + canvas.style.width = "400px"; + canvas.style.height = "400px"; + } + const color = fbo.device.readPixelsToArrayWebGL(fbo); + const imageData = ctx.createImageData(fbo.width, fbo.height); + const offset = 0; + for (let i = 0; i < color.length; i += 4) { + imageData.data[offset + i + 0] = color[i + 0] * rgbaScale; + imageData.data[offset + i + 1] = color[i + 1] * rgbaScale; + imageData.data[offset + i + 2] = color[i + 2] * rgbaScale; + imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale; + } + ctx.putImageData(imageData, 0, 0); +} + +// node_modules/@luma.gl/engine/dist/model/model.js +var LOG_DRAW_PRIORITY = 2; +var LOG_DRAW_TIMEOUT = 1e4; +var Model = class _Model { + static defaultProps = { + ...RenderPipeline.defaultProps, + source: null, + vs: null, + fs: null, + id: "unnamed", + handle: void 0, + userData: {}, + defines: {}, + modules: [], + moduleSettings: void 0, + geometry: null, + indexBuffer: null, + attributes: {}, + constantAttributes: {}, + varyings: [], + isInstanced: void 0, + instanceCount: 0, + vertexCount: 0, + shaderInputs: void 0, + pipelineFactory: void 0, + shaderFactory: void 0, + transformFeedback: void 0, + shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(), + debugShaders: void 0, + disableWarnings: void 0 + }; + device; + id; + source; + vs; + fs; + pipelineFactory; + shaderFactory; + userData = {}; + // Fixed properties (change can trigger pipeline rebuild) + /** The render pipeline GPU parameters, depth testing etc */ + parameters; + /** The primitive topology */ + topology; + /** Buffer layout */ + bufferLayout; + // Dynamic properties + /** Use instanced rendering */ + isInstanced = void 0; + /** instance count. `undefined` means not instanced */ + instanceCount = 0; + /** Vertex count */ + vertexCount; + /** Index buffer */ + indexBuffer = null; + /** Buffer-valued attributes */ + bufferAttributes = {}; + /** Constant-valued attributes */ + constantAttributes = {}; + /** Bindings (textures, samplers, uniform buffers) */ + bindings = {}; + /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/ + uniforms = {}; + /** + * VertexArray + * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt! + * @todo - allow application to define multiple vertex arrays? + * */ + vertexArray; + /** TransformFeedback, WebGL 2 only. */ + transformFeedback = null; + /** The underlying GPU "program". @note May be recreated if parameters change */ + pipeline; + /** ShaderInputs instance */ + shaderInputs; + _uniformStore; + _attributeInfos = {}; + _gpuGeometry = null; + _getModuleUniforms; + props; + _pipelineNeedsUpdate = "newly created"; + _needsRedraw = "initializing"; + _destroyed = false; + /** "Time" of last draw. Monotonically increasing timestamp */ + _lastDrawTimestamp = -1; + constructor(device, props) { + this.props = { ..._Model.defaultProps, ...props }; + props = this.props; + this.id = props.id || uid("model"); + this.device = device; + Object.assign(this.userData, props.userData); + const moduleMap = Object.fromEntries(this.props.modules?.map((module) => [module.name, module]) || []); + this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap)); + const platformInfo = getPlatformInfo(device); + const modules = (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || []; + const isWebGPU = this.device.type === "webgpu"; + if (isWebGPU && this.props.source) { + this.props.shaderLayout ||= getShaderLayoutFromWGSL(this.props.source); + const { source, getUniforms: getUniforms6 } = this.props.shaderAssembler.assembleShader({ + platformInfo, + ...this.props, + modules + }); + this.source = source; + this._getModuleUniforms = getUniforms6; + } else { + const { vs: vs7, fs: fs5, getUniforms: getUniforms6 } = this.props.shaderAssembler.assembleShaderPair({ + platformInfo, + ...this.props, + modules + }); + this.vs = vs7; + this.fs = fs5; + this._getModuleUniforms = getUniforms6; + } + this.vertexCount = this.props.vertexCount; + this.instanceCount = this.props.instanceCount; + this.topology = this.props.topology; + this.bufferLayout = this.props.bufferLayout; + this.parameters = this.props.parameters; + if (props.geometry) { + this.setGeometry(props.geometry); + } + this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device); + this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device); + this.pipeline = this._updatePipeline(); + this.vertexArray = device.createVertexArray({ + renderPipeline: this.pipeline + }); + if (this._gpuGeometry) { + this._setGeometryAttributes(this._gpuGeometry); + } + if ("isInstanced" in props) { + this.isInstanced = props.isInstanced; + } + if (props.instanceCount) { + this.setInstanceCount(props.instanceCount); + } + if (props.vertexCount) { + this.setVertexCount(props.vertexCount); + } + if (props.indexBuffer) { + this.setIndexBuffer(props.indexBuffer); + } + if (props.attributes) { + this.setAttributes(props.attributes); + } + if (props.constantAttributes) { + this.setConstantAttributes(props.constantAttributes); + } + if (props.bindings) { + this.setBindings(props.bindings); + } + if (props.uniforms) { + this.setUniforms(props.uniforms); + } + if (props.moduleSettings) { + this.updateModuleSettings(props.moduleSettings); + } + if (props.transformFeedback) { + this.transformFeedback = props.transformFeedback; + } + Object.seal(this); + } + destroy() { + if (this._destroyed) + return; + this.pipelineFactory.release(this.pipeline); + this.shaderFactory.release(this.pipeline.vs); + if (this.pipeline.fs) { + this.shaderFactory.release(this.pipeline.fs); + } + this._uniformStore.destroy(); + this._gpuGeometry?.destroy(); + this._destroyed = true; + } + // Draw call + /** Query redraw status. Clears the status. */ + needsRedraw() { + if (this._getBindingsUpdateTimestamp() > this._lastDrawTimestamp) { + this.setNeedsRedraw("contents of bound textures or buffers updated"); + } + const needsRedraw = this._needsRedraw; + this._needsRedraw = false; + return needsRedraw; + } + /** Mark the model as needing a redraw */ + setNeedsRedraw(reason) { + this._needsRedraw ||= reason; + } + predraw() { + this.updateShaderInputs(); + this.pipeline = this._updatePipeline(); + } + draw(renderPass) { + this.predraw(); + let drawSuccess; + try { + this._logDrawCallStart(); + this.pipeline = this._updatePipeline(); + this.pipeline.setBindings(this.bindings, { disableWarnings: this.props.disableWarnings }); + if (!isObjectEmpty(this.uniforms)) { + this.pipeline.setUniformsWebGL(this.uniforms); + } + const { indexBuffer } = this.vertexArray; + const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0; + drawSuccess = this.pipeline.draw({ + renderPass, + vertexArray: this.vertexArray, + isInstanced: this.isInstanced, + vertexCount: this.vertexCount, + instanceCount: this.instanceCount, + indexCount, + transformFeedback: this.transformFeedback || void 0, + // WebGL shares underlying cached pipelines even for models that have different parameters and topology, + // so we must provide our unique parameters to each draw + // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call) + parameters: this.parameters, + topology: this.topology + }); + } finally { + this._logDrawCallEnd(); + } + this._logFramebuffer(renderPass); + if (drawSuccess) { + this._lastDrawTimestamp = this.device.timestamp; + this._needsRedraw = false; + } else { + this._needsRedraw = "waiting for resource initialization"; + } + return drawSuccess; + } + // Update fixed fields (can trigger pipeline rebuild) + /** + * Updates the optional geometry + * Geometry, set topology and bufferLayout + * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU + */ + setGeometry(geometry) { + this._gpuGeometry?.destroy(); + const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry); + if (gpuGeometry) { + this.setTopology(gpuGeometry.topology || "triangle-list"); + this.bufferLayout = mergeBufferLayouts(gpuGeometry.bufferLayout, this.bufferLayout); + if (this.vertexArray) { + this._setGeometryAttributes(gpuGeometry); + } + } + this._gpuGeometry = gpuGeometry; + } + /** + * Updates the primitive topology ('triangle-list', 'triangle-strip' etc). + * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU + */ + setTopology(topology) { + if (topology !== this.topology) { + this.topology = topology; + this._setPipelineNeedsUpdate("topology"); + } + } + /** + * Updates the buffer layout. + * @note Triggers a pipeline rebuild / pipeline cache fetch + */ + setBufferLayout(bufferLayout) { + this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout; + this._setPipelineNeedsUpdate("bufferLayout"); + this.pipeline = this._updatePipeline(); + this.vertexArray = this.device.createVertexArray({ + renderPipeline: this.pipeline + }); + if (this._gpuGeometry) { + this._setGeometryAttributes(this._gpuGeometry); + } + } + /** + * Set GPU parameters. + * @note Can trigger a pipeline rebuild / pipeline cache fetch. + * @param parameters + */ + setParameters(parameters) { + if (!deepEqual(parameters, this.parameters, 2)) { + this.parameters = parameters; + this._setPipelineNeedsUpdate("parameters"); + } + } + // Update dynamic fields + /** + * Updates the instance count (used in draw calls) + * @note Any attributes with stepMode=instance need to be at least this big + */ + setInstanceCount(instanceCount) { + this.instanceCount = instanceCount; + if (this.isInstanced === void 0 && instanceCount > 0) { + this.isInstanced = true; + } + this.setNeedsRedraw("instanceCount"); + } + /** + * Updates the vertex count (used in draw calls) + * @note Any attributes with stepMode=vertex need to be at least this big + */ + setVertexCount(vertexCount) { + this.vertexCount = vertexCount; + this.setNeedsRedraw("vertexCount"); + } + /** Set the shader inputs */ + setShaderInputs(shaderInputs) { + this.shaderInputs = shaderInputs; + this._uniformStore = new UniformStore(this.shaderInputs.modules); + for (const moduleName of Object.keys(this.shaderInputs.modules)) { + const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName); + this.bindings[`${moduleName}Uniforms`] = uniformBuffer; + } + this.setNeedsRedraw("shaderInputs"); + } + /** Update uniform buffers from the model's shader inputs */ + updateShaderInputs() { + this._uniformStore.setUniforms(this.shaderInputs.getUniformValues()); + this.setBindings(this.shaderInputs.getBindings()); + this.setNeedsRedraw("shaderInputs"); + } + /** + * Sets bindings (textures, samplers, uniform buffers) + */ + setBindings(bindings) { + Object.assign(this.bindings, bindings); + this.setNeedsRedraw("bindings"); + } + /** + * Updates optional transform feedback. WebGL only. + */ + setTransformFeedback(transformFeedback) { + this.transformFeedback = transformFeedback; + this.setNeedsRedraw("transformFeedback"); + } + /** + * Sets the index buffer + * @todo - how to unset it if we change geometry? + */ + setIndexBuffer(indexBuffer) { + this.vertexArray.setIndexBuffer(indexBuffer); + this.setNeedsRedraw("indexBuffer"); + } + /** + * Sets attributes (buffers) + * @note Overrides any attributes previously set with the same name + */ + setAttributes(buffers, options) { + if (buffers.indices) { + log2.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)(); + } + for (const [bufferName, buffer] of Object.entries(buffers)) { + const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName)); + if (!bufferLayout) { + log2.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)(); + continue; + } + const attributeNames = getAttributeNames(bufferLayout); + let set11 = false; + for (const attributeName of attributeNames) { + const attributeInfo = this._attributeInfos[attributeName]; + if (attributeInfo) { + this.vertexArray.setBuffer(attributeInfo.location, buffer); + set11 = true; + } + } + if (!set11 && !(options?.disableWarnings ?? this.props.disableWarnings)) { + log2.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)(); + } + } + this.setNeedsRedraw("attributes"); + } + /** + * Sets constant attributes + * @note Overrides any attributes previously set with the same name + * Constant attributes are only supported in WebGL, not in WebGPU + * Any attribute that is disabled in the current vertex array object + * is read from the context's global constant value for that attribute location. + * @param constantAttributes + */ + setConstantAttributes(attributes, options) { + for (const [attributeName, value] of Object.entries(attributes)) { + const attributeInfo = this._attributeInfos[attributeName]; + if (attributeInfo) { + this.vertexArray.setConstantWebGL(attributeInfo.location, value); + } else if (!(options?.disableWarnings ?? this.props.disableWarnings)) { + log2.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)(); + } + } + this.setNeedsRedraw("constants"); + } + // DEPRECATED METHODS + /** + * Sets individual uniforms + * @deprecated WebGL only, use uniform buffers for portability + * @param uniforms + */ + setUniforms(uniforms) { + if (!isObjectEmpty(uniforms)) { + this.pipeline.setUniformsWebGL(uniforms); + Object.assign(this.uniforms, uniforms); + } + this.setNeedsRedraw("uniforms"); + } + /** + * @deprecated Updates shader module settings (which results in uniforms being set) + */ + updateModuleSettings(props) { + const { bindings, uniforms } = splitUniformsAndBindings(this._getModuleUniforms(props)); + Object.assign(this.bindings, bindings); + Object.assign(this.uniforms, uniforms); + this.setNeedsRedraw("moduleSettings"); + } + // Internal methods + /** Get the timestamp of the latest updated bound GPU memory resource (buffer/texture). */ + _getBindingsUpdateTimestamp() { + let timestamp = 0; + for (const binding of Object.values(this.bindings)) { + if (binding instanceof TextureView) { + timestamp = Math.max(timestamp, binding.texture.updateTimestamp); + } else if (binding instanceof Buffer2 || binding instanceof Texture) { + timestamp = Math.max(timestamp, binding.updateTimestamp); + } else if (!(binding instanceof Sampler)) { + timestamp = Math.max(timestamp, binding.buffer.updateTimestamp); + } + } + return timestamp; + } + /** + * Updates the optional geometry attributes + * Geometry, sets several attributes, indexBuffer, and also vertex count + * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU + */ + _setGeometryAttributes(gpuGeometry) { + const attributes = { ...gpuGeometry.attributes }; + for (const [attributeName] of Object.entries(attributes)) { + if (!this.pipeline.shaderLayout.attributes.find((layout) => layout.name === attributeName) && attributeName !== "positions") { + delete attributes[attributeName]; + } + } + this.vertexCount = gpuGeometry.vertexCount; + this.setIndexBuffer(gpuGeometry.indices || null); + this.setAttributes(gpuGeometry.attributes, { disableWarnings: true }); + this.setAttributes(attributes, { disableWarnings: this.props.disableWarnings }); + this.setNeedsRedraw("geometry attributes"); + } + /** Mark pipeline as needing update */ + _setPipelineNeedsUpdate(reason) { + this._pipelineNeedsUpdate ||= reason; + this.setNeedsRedraw(reason); + } + /** Update pipeline if needed */ + _updatePipeline() { + if (this._pipelineNeedsUpdate) { + let prevShaderVs = null; + let prevShaderFs = null; + if (this.pipeline) { + log2.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)(); + prevShaderVs = this.pipeline.vs; + prevShaderFs = this.pipeline.fs; + } + this._pipelineNeedsUpdate = false; + const vs7 = this.shaderFactory.createShader({ + id: `${this.id}-vertex`, + stage: "vertex", + source: this.source || this.vs, + debug: this.props.debugShaders + }); + let fs5 = null; + if (this.source) { + fs5 = vs7; + } else if (this.fs) { + fs5 = this.shaderFactory.createShader({ + id: `${this.id}-fragment`, + stage: "fragment", + source: this.source || this.fs, + debug: this.props.debugShaders + }); + } + this.pipeline = this.pipelineFactory.createRenderPipeline({ + ...this.props, + bufferLayout: this.bufferLayout, + topology: this.topology, + parameters: this.parameters, + vs: vs7, + fs: fs5 + }); + this._attributeInfos = getAttributeInfosFromLayouts(this.pipeline.shaderLayout, this.bufferLayout); + if (prevShaderVs) + this.shaderFactory.release(prevShaderVs); + if (prevShaderFs) + this.shaderFactory.release(prevShaderFs); + } + return this.pipeline; + } + /** Throttle draw call logging */ + _lastLogTime = 0; + _logOpen = false; + _logDrawCallStart() { + const logDrawTimeout = log2.level > 3 ? 0 : LOG_DRAW_TIMEOUT; + if (log2.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) { + return; + } + this._lastLogTime = Date.now(); + this._logOpen = true; + log2.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: log2.level <= 2 })(); + } + _logDrawCallEnd() { + if (this._logOpen) { + const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id); + log2.table(LOG_DRAW_PRIORITY, shaderLayoutTable)(); + const uniformTable = this.shaderInputs.getDebugTable(); + for (const [name2, value] of Object.entries(this.uniforms)) { + uniformTable[name2] = { value }; + } + log2.table(LOG_DRAW_PRIORITY, uniformTable)(); + const attributeTable = this._getAttributeDebugTable(); + log2.table(LOG_DRAW_PRIORITY, this._attributeInfos)(); + log2.table(LOG_DRAW_PRIORITY, attributeTable)(); + log2.groupEnd(LOG_DRAW_PRIORITY)(); + this._logOpen = false; + } + } + _drawCount = 0; + _logFramebuffer(renderPass) { + const debugFramebuffers = log2.get("framebuffer"); + this._drawCount++; + if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) { + return; + } + const framebuffer = renderPass.props.framebuffer; + if (framebuffer) { + debugFramebuffer(framebuffer, { id: framebuffer.id, minimap: true }); + } + } + _getAttributeDebugTable() { + const table = {}; + for (const [name2, attributeInfo] of Object.entries(this._attributeInfos)) { + table[attributeInfo.location] = { + name: name2, + type: attributeInfo.shaderType, + values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType) + }; + } + if (this.vertexArray.indexBuffer) { + const { indexBuffer } = this.vertexArray; + const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData); + table.indices = { + name: "indices", + type: indexBuffer.indexType, + values: values.toString() + }; + } + return table; + } + // TODO - fix typing of luma data types + _getBufferOrConstantValues(attribute, dataType) { + const TypedArrayConstructor = getTypedArrayFromDataType(dataType); + const typedArray = attribute instanceof Buffer2 ? new TypedArrayConstructor(attribute.debugData) : attribute; + return typedArray.toString(); + } +}; +function mergeBufferLayouts(layouts1, layouts2) { + const layouts = [...layouts1]; + for (const attribute of layouts2) { + const index2 = layouts.findIndex((attribute2) => attribute2.name === attribute.name); + if (index2 < 0) { + layouts.push(attribute); + } else { + layouts[index2] = attribute; + } + } + return layouts; +} +function getPlatformInfo(device) { + return { + type: device.type, + shaderLanguage: device.info.shadingLanguage, + shaderLanguageVersion: device.info.shadingLanguageVersion, + gpu: device.info.gpu, + // HACK - we pretend that the DeviceFeatures is a Set, it has a similar API + features: device.features + }; +} +function getAttributeNames(bufferLayout) { + return bufferLayout.attributes ? bufferLayout.attributes?.map((layout) => layout.attribute) : [bufferLayout.name]; +} + +// node_modules/@luma.gl/engine/dist/transform/buffer-transform.js +var BufferTransform = class _BufferTransform { + device; + model; + transformFeedback; + /** @deprecated Use device feature test. */ + static isSupported(device) { + return device?.info?.type === "webgl"; + } + constructor(device, props = Model.defaultProps) { + assert6(_BufferTransform.isSupported(device), "BufferTransform not yet implemented on WebGPU"); + this.device = device; + this.model = new Model(this.device, { + id: props.id || "buffer-transform-model", + fs: props.fs || getPassthroughFS(), + topology: props.topology || "point-list", + ...props + }); + this.transformFeedback = this.device.createTransformFeedback({ + layout: this.model.pipeline.shaderLayout, + buffers: props.feedbackBuffers + }); + this.model.setTransformFeedback(this.transformFeedback); + Object.seal(this); + } + /** Destroy owned resources. */ + destroy() { + if (this.model) { + this.model.destroy(); + } + } + /** @deprecated Use {@link destroy}. */ + delete() { + this.destroy(); + } + /** Run one transform loop. */ + run(options) { + const renderPass = this.device.beginRenderPass(options); + this.model.draw(renderPass); + renderPass.end(); + } + /** @deprecated */ + update(...args) { + console.warn("TextureTransform#update() not implemented"); + } + /** Returns the {@link Buffer} or {@link BufferRange} for given varying name. */ + getBuffer(varyingName) { + return this.transformFeedback.getBuffer(varyingName); + } + readAsync(varyingName) { + const result = this.getBuffer(varyingName); + if (result instanceof Buffer2) { + return result.readAsync(); + } + const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result; + return buffer.readAsync(byteOffset, byteLength); + } +}; + +// node_modules/@luma.gl/engine/dist/geometry/geometry.js +var Geometry = class { + id; + /** Determines how vertices are read from the 'vertex' attributes */ + topology; + vertexCount; + indices; + attributes; + userData = {}; + constructor(props) { + const { attributes = {}, indices = null, vertexCount = null } = props; + this.id = props.id || uid("geometry"); + this.topology = props.topology; + if (indices) { + this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices; + } + this.attributes = {}; + for (const [attributeName, attributeValue] of Object.entries(attributes)) { + const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue; + assert6(ArrayBuffer.isView(attribute.value), `${this._print(attributeName)}: must be typed array or object with value as typed array`); + if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) { + attribute.size = 3; + } + if (attributeName === "indices") { + assert6(!this.indices); + this.indices = attribute; + } else { + this.attributes[attributeName] = attribute; + } + } + if (this.indices && this.indices.isIndexed !== void 0) { + this.indices = Object.assign({}, this.indices); + delete this.indices.isIndexed; + } + this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices); + } + getVertexCount() { + return this.vertexCount; + } + /** + * Return an object with all attributes plus indices added as a field. + * TODO Geometry types are a mess + */ + getAttributes() { + return this.indices ? { indices: this.indices, ...this.attributes } : this.attributes; + } + // PRIVATE + _print(attributeName) { + return `Geometry ${this.id} attribute ${attributeName}`; + } + /** + * GeometryAttribute + * value: typed array + * type: indices, vertices, uvs + * size: elements per vertex + * target: WebGL buffer type (string or constant) + * + * @param attributes + * @param indices + * @returns + */ + _setAttributes(attributes, indices) { + return this; + } + _calculateVertexCount(attributes, indices) { + if (indices) { + return indices.value.length; + } + let vertexCount = Infinity; + for (const attribute of Object.values(attributes)) { + const { value, size, constant } = attribute; + if (!constant && value && size >= 1) { + vertexCount = Math.min(vertexCount, value.length / size); + } + } + assert6(Number.isFinite(vertexCount)); + return vertexCount; + } +}; + +// node_modules/@deck.gl/core/dist/passes/pick-layers-pass.js +var PICKING_BLENDING = { + blendColorOperation: "add", + blendColorSrcFactor: "one", + blendColorDstFactor: "zero", + blendAlphaOperation: "add", + blendAlphaSrcFactor: "constant-alpha", + blendAlphaDstFactor: "zero" +}; +var PickLayersPass = class extends LayersPass { + constructor() { + super(...arguments); + this._colorEncoderState = null; + } + render(props) { + if ("pickingFBO" in props) { + return this._drawPickingBuffer(props); + } + return super.render(props); + } + // Private + // Draws list of layers and viewports into the picking buffer + // Note: does not sample the buffer, that has to be done by the caller + _drawPickingBuffer({ layers, layerFilter, views, viewports, onViewportActive, pickingFBO, deviceRect: { x, y, width, height }, cullRect, effects, pass = "picking", pickZ, moduleParameters }) { + this.pickZ = pickZ; + const colorEncoderState = this._resetColorEncoder(pickZ); + const scissorRect = [x, y, width, height]; + const renderStatus = super.render({ + target: pickingFBO, + layers, + layerFilter, + views, + viewports, + onViewportActive, + cullRect, + effects: effects?.filter((e) => e.useInPicking), + pass, + isPicking: true, + moduleParameters, + clearColor: [0, 0, 0, 0], + colorMask: 15, + scissorRect + }); + this._colorEncoderState = null; + const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState); + return { decodePickingColor, stats: renderStatus }; + } + shouldDrawLayer(layer) { + const { pickable, operation } = layer.props; + return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask"); + } + getModuleParameters() { + return { + picking: { + isActive: 1, + isAttribute: this.pickZ + }, + // turn off lighting by adding empty light source object + // lights shader module relies on the `lightSources` to turn on/off lighting + lightSources: {} + }; + } + getLayerParameters(layer, layerIndex, viewport) { + const pickParameters = { + // TODO - When used as a custom layer in older Mapbox versions, context + // state was dirty. Mapbox fixed that; we should test and remove the workaround. + // https://github.com/mapbox/mapbox-gl-js/issues/7801 + depthMask: true, + depthTest: true, + depthRange: [0, 1], + ...layer.props.parameters + }; + const { pickable, operation } = layer.props; + if (!this._colorEncoderState || operation.includes("terrain")) { + pickParameters.blend = false; + } else if (pickable && operation.includes("draw")) { + Object.assign(pickParameters, PICKING_BLENDING); + pickParameters.blend = true; + pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport); + } + return pickParameters; + } + _resetColorEncoder(pickZ) { + this._colorEncoderState = pickZ ? null : { + byLayer: /* @__PURE__ */ new Map(), + byAlpha: [] + }; + return this._colorEncoderState; + } +}; +function encodeColor(encoded, layer, viewport) { + const { byLayer, byAlpha } = encoded; + let a; + let entry = byLayer.get(layer); + if (entry) { + entry.viewports.push(viewport); + a = entry.a; + } else { + a = byLayer.size + 1; + if (a <= 255) { + entry = { a, layer, viewports: [viewport] }; + byLayer.set(layer, entry); + byAlpha[a] = entry; + } else { + log_default.warn("Too many pickable layers, only picking the first 255")(); + a = 0; + } + } + return [0, 0, 0, a / 255]; +} +function decodeColor(encoded, pickedColor) { + const entry = encoded.byAlpha[pickedColor[3]]; + return entry && { + pickedLayer: entry.layer, + pickedViewports: entry.viewports, + pickedObjectIndex: entry.layer.decodePickingColor(pickedColor) + }; +} + +// node_modules/@deck.gl/core/dist/lifecycle/constants.js +var LIFECYCLE = { + NO_STATE: "Awaiting state", + MATCHED: "Matched. State transferred from previous layer", + INITIALIZED: "Initialized", + AWAITING_GC: "Discarded. Awaiting garbage collection", + AWAITING_FINALIZATION: "No longer matched. Awaiting garbage collection", + FINALIZED: "Finalized! Awaiting garbage collection" +}; +var COMPONENT_SYMBOL = Symbol.for("component"); +var PROP_TYPES_SYMBOL = Symbol.for("propTypes"); +var DEPRECATED_PROPS_SYMBOL = Symbol.for("deprecatedProps"); +var ASYNC_DEFAULTS_SYMBOL = Symbol.for("asyncPropDefaults"); +var ASYNC_ORIGINAL_SYMBOL = Symbol.for("asyncPropOriginal"); +var ASYNC_RESOLVED_SYMBOL = Symbol.for("asyncPropResolved"); + +// node_modules/@deck.gl/core/dist/utils/flatten.js +function flatten(array, filter = () => true) { + if (!Array.isArray(array)) { + return filter(array) ? [array] : []; + } + return flattenArray(array, filter, []); +} +function flattenArray(array, filter, result) { + let index2 = -1; + while (++index2 < array.length) { + const value = array[index2]; + if (Array.isArray(value)) { + flattenArray(value, filter, result); + } else if (filter(value)) { + result.push(value); + } + } + return result; +} +function fillArray2({ target, source, start = 0, count: count2 = 1 }) { + const length10 = source.length; + const total = count2 * length10; + let copied = 0; + for (let i = start; copied < length10; copied++) { + target[i++] = source[copied]; + } + while (copied < total) { + if (copied < total - copied) { + target.copyWithin(start + copied, start, start + copied); + copied *= 2; + } else { + target.copyWithin(start + copied, start, start + total - copied); + copied = total; + } + } + return target; +} + +// node_modules/@deck.gl/core/dist/lib/resource/resource.js +var Resource2 = class { + constructor(id, data, context) { + this._loadCount = 0; + this._subscribers = /* @__PURE__ */ new Set(); + this.id = id; + this.context = context; + this.setData(data); + } + // consumer: {onChange: Function} + subscribe(consumer) { + this._subscribers.add(consumer); + } + unsubscribe(consumer) { + this._subscribers.delete(consumer); + } + inUse() { + return this._subscribers.size > 0; + } + delete() { + } + getData() { + return this.isLoaded ? this._error ? Promise.reject(this._error) : this._content : this._loader.then(() => this.getData()); + } + setData(data, forceUpdate) { + if (data === this._data && !forceUpdate) { + return; + } + this._data = data; + const loadCount = ++this._loadCount; + let loader = data; + if (typeof data === "string") { + loader = load(data); + } + if (loader instanceof Promise) { + this.isLoaded = false; + this._loader = loader.then((result) => { + if (this._loadCount === loadCount) { + this.isLoaded = true; + this._error = void 0; + this._content = result; + } + }).catch((error) => { + if (this._loadCount === loadCount) { + this.isLoaded = true; + this._error = error || true; + } + }); + } else { + this.isLoaded = true; + this._error = void 0; + this._content = data; + } + for (const subscriber of this._subscribers) { + subscriber.onChange(this.getData()); + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/resource/resource-manager.js +var ResourceManager = class { + constructor(props) { + this.protocol = props.protocol || "resource://"; + this._context = { + device: props.device, + // @ts-expect-error + gl: props.device?.gl, + resourceManager: this + }; + this._resources = {}; + this._consumers = {}; + this._pruneRequest = null; + } + contains(resourceId) { + if (resourceId.startsWith(this.protocol)) { + return true; + } + return resourceId in this._resources; + } + add({ resourceId, data, forceUpdate = false, persistent = true }) { + let res = this._resources[resourceId]; + if (res) { + res.setData(data, forceUpdate); + } else { + res = new Resource2(resourceId, data, this._context); + this._resources[resourceId] = res; + } + res.persistent = persistent; + } + remove(resourceId) { + const res = this._resources[resourceId]; + if (res) { + res.delete(); + delete this._resources[resourceId]; + } + } + unsubscribe({ consumerId }) { + const consumer = this._consumers[consumerId]; + if (consumer) { + for (const requestId in consumer) { + const request = consumer[requestId]; + const resource = this._resources[request.resourceId]; + if (resource) { + resource.unsubscribe(request); + } + } + delete this._consumers[consumerId]; + this.prune(); + } + } + subscribe({ resourceId, onChange, consumerId, requestId = "default" }) { + const { _resources: resources, protocol } = this; + if (resourceId.startsWith(protocol)) { + resourceId = resourceId.replace(protocol, ""); + if (!resources[resourceId]) { + this.add({ resourceId, data: null, persistent: false }); + } + } + const res = resources[resourceId]; + this._track(consumerId, requestId, res, onChange); + if (res) { + return res.getData(); + } + return void 0; + } + prune() { + if (!this._pruneRequest) { + this._pruneRequest = setTimeout(() => this._prune(), 0); + } + } + finalize() { + for (const key in this._resources) { + this._resources[key].delete(); + } + } + _track(consumerId, requestId, resource, onChange) { + const consumers = this._consumers; + const consumer = consumers[consumerId] = consumers[consumerId] || {}; + let request = consumer[requestId]; + const oldResource = request && request.resourceId && this._resources[request.resourceId]; + if (oldResource) { + oldResource.unsubscribe(request); + this.prune(); + } + if (resource) { + if (request) { + request.onChange = onChange; + request.resourceId = resource.id; + } else { + request = { + onChange, + resourceId: resource.id + }; + } + consumer[requestId] = request; + resource.subscribe(request); + } + } + _prune() { + this._pruneRequest = null; + for (const key of Object.keys(this._resources)) { + const res = this._resources[key]; + if (!res.persistent && !res.inUse()) { + res.delete(); + delete this._resources[key]; + } + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/layer-manager.js +var TRACE_SET_LAYERS = "layerManager.setLayers"; +var TRACE_ACTIVATE_VIEWPORT = "layerManager.activateViewport"; +var LayerManager = class { + /** + * @param device + * @param param1 + */ + // eslint-disable-next-line + constructor(device, props) { + this._lastRenderedLayers = []; + this._needsRedraw = false; + this._needsUpdate = false; + this._nextLayers = null; + this._debug = false; + this._defaultShaderModulesChanged = false; + this.activateViewport = (viewport2) => { + debug(TRACE_ACTIVATE_VIEWPORT, this, viewport2); + if (viewport2) { + this.context.viewport = viewport2; + } + }; + const { deck, stats, viewport, timeline } = props || {}; + this.layers = []; + this.resourceManager = new ResourceManager({ device, protocol: "deck://" }); + this.context = { + mousePosition: null, + userData: {}, + layerManager: this, + device, + // @ts-expect-error + gl: device?.gl, + deck, + shaderAssembler: getShaderAssembler(), + defaultShaderModules: [], + renderPass: void 0, + stats: stats || new Stats({ id: "deck.gl" }), + // Make sure context.viewport is not empty on the first layer initialization + viewport: viewport || new viewport_default({ id: "DEFAULT-INITIAL-VIEWPORT" }), + // Current viewport, exposed to layers for project* function + timeline: timeline || new Timeline(), + resourceManager: this.resourceManager, + onError: void 0 + }; + Object.seal(this); + } + /** Method to call when the layer manager is not needed anymore. */ + finalize() { + this.resourceManager.finalize(); + for (const layer of this.layers) { + this._finalizeLayer(layer); + } + } + /** Check if a redraw is needed */ + needsRedraw(opts = { clearRedrawFlags: false }) { + let redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + for (const layer of this.layers) { + const layerNeedsRedraw = layer.getNeedsRedraw(opts); + redraw = redraw || layerNeedsRedraw; + } + return redraw; + } + /** Check if a deep update of all layers is needed */ + needsUpdate() { + if (this._nextLayers && this._nextLayers !== this._lastRenderedLayers) { + return "layers changed"; + } + if (this._defaultShaderModulesChanged) { + return "shader modules changed"; + } + return this._needsUpdate; + } + /** Layers will be redrawn (in next animation frame) */ + setNeedsRedraw(reason) { + this._needsRedraw = this._needsRedraw || reason; + } + /** Layers will be updated deeply (in next animation frame) + Potentially regenerating attributes and sub layers */ + setNeedsUpdate(reason) { + this._needsUpdate = this._needsUpdate || reason; + } + /** Gets a list of currently rendered layers. Optionally filter by id. */ + getLayers({ layerIds } = {}) { + return layerIds ? this.layers.filter((layer) => layerIds.find((layerId) => layer.id.indexOf(layerId) === 0)) : this.layers; + } + /** Set props needed for layer rendering and picking. */ + setProps(props) { + if ("debug" in props) { + this._debug = props.debug; + } + if ("userData" in props) { + this.context.userData = props.userData; + } + if ("layers" in props) { + this._nextLayers = props.layers; + } + if ("onError" in props) { + this.context.onError = props.onError; + } + } + /** Supply a new layer list, initiating sublayer generation and layer matching */ + setLayers(newLayers, reason) { + debug(TRACE_SET_LAYERS, this, reason, newLayers); + this._lastRenderedLayers = newLayers; + const flatLayers = flatten(newLayers, Boolean); + for (const layer of flatLayers) { + layer.context = this.context; + } + this._updateLayers(this.layers, flatLayers); + } + /** Update layers from last cycle if `setNeedsUpdate()` has been called */ + updateLayers() { + const reason = this.needsUpdate(); + if (reason) { + this.setNeedsRedraw(`updating layers: ${reason}`); + this.setLayers(this._nextLayers || this._lastRenderedLayers, reason); + } + this._nextLayers = null; + } + /** Register a default shader module */ + addDefaultShaderModule(module) { + const { defaultShaderModules } = this.context; + if (!defaultShaderModules.find((m) => m.name === module.name)) { + defaultShaderModules.push(module); + this._defaultShaderModulesChanged = true; + } + } + /** Deregister a default shader module */ + removeDefaultShaderModule(module) { + const { defaultShaderModules } = this.context; + const i = defaultShaderModules.findIndex((m) => m.name === module.name); + if (i >= 0) { + defaultShaderModules.splice(i, 1); + this._defaultShaderModulesChanged = true; + } + } + _handleError(stage, error, layer) { + layer.raiseError(error, `${stage} of ${layer}`); + } + // TODO - mark layers with exceptions as bad and remove from rendering cycle? + /** Match all layers, checking for caught errors + to avoid having an exception in one layer disrupt other layers */ + _updateLayers(oldLayers, newLayers) { + const oldLayerMap = {}; + for (const oldLayer of oldLayers) { + if (oldLayerMap[oldLayer.id]) { + log_default.warn(`Multiple old layers with same id ${oldLayer.id}`)(); + } else { + oldLayerMap[oldLayer.id] = oldLayer; + } + } + if (this._defaultShaderModulesChanged) { + for (const layer of oldLayers) { + layer.setNeedsUpdate(); + layer.setChangeFlags({ extensionsChanged: true }); + } + this._defaultShaderModulesChanged = false; + } + const generatedLayers = []; + this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers); + this._finalizeOldLayers(oldLayerMap); + let needsUpdate = false; + for (const layer of generatedLayers) { + if (layer.hasUniformTransition()) { + needsUpdate = `Uniform transition in ${layer}`; + break; + } + } + this._needsUpdate = needsUpdate; + this.layers = generatedLayers; + } + /* eslint-disable complexity,max-statements */ + // Note: adds generated layers to `generatedLayers` array parameter + _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) { + for (const newLayer of newLayers) { + newLayer.context = this.context; + const oldLayer = oldLayerMap[newLayer.id]; + if (oldLayer === null) { + log_default.warn(`Multiple new layers with same id ${newLayer.id}`)(); + } + oldLayerMap[newLayer.id] = null; + let sublayers = null; + try { + if (this._debug && oldLayer !== newLayer) { + newLayer.validateProps(); + } + if (!oldLayer) { + this._initializeLayer(newLayer); + } else { + this._transferLayerState(oldLayer, newLayer); + this._updateLayer(newLayer); + } + generatedLayers.push(newLayer); + sublayers = newLayer.isComposite ? newLayer.getSubLayers() : null; + } catch (err) { + this._handleError("matching", err, newLayer); + } + if (sublayers) { + this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers); + } + } + } + /* eslint-enable complexity,max-statements */ + // Finalize any old layers that were not matched + _finalizeOldLayers(oldLayerMap) { + for (const layerId in oldLayerMap) { + const layer = oldLayerMap[layerId]; + if (layer) { + this._finalizeLayer(layer); + } + } + } + // / EXCEPTION SAFE LAYER ACCESS + /** Safely initializes a single layer, calling layer methods */ + _initializeLayer(layer) { + try { + layer._initialize(); + layer.lifecycle = LIFECYCLE.INITIALIZED; + } catch (err) { + this._handleError("initialization", err, layer); + } + } + /** Transfer state from one layer to a newer version */ + _transferLayerState(oldLayer, newLayer) { + newLayer._transferState(oldLayer); + newLayer.lifecycle = LIFECYCLE.MATCHED; + if (newLayer !== oldLayer) { + oldLayer.lifecycle = LIFECYCLE.AWAITING_GC; + } + } + /** Safely updates a single layer, cleaning all flags */ + _updateLayer(layer) { + try { + layer._update(); + } catch (err) { + this._handleError("update", err, layer); + } + } + /** Safely finalizes a single layer, removing all resources */ + _finalizeLayer(layer) { + this._needsRedraw = this._needsRedraw || `finalized ${layer}`; + layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION; + try { + layer._finalize(); + layer.lifecycle = LIFECYCLE.FINALIZED; + } catch (err) { + this._handleError("finalization", err, layer); + } + } +}; + +// node_modules/@deck.gl/core/dist/utils/deep-equal.js +function deepEqual2(a, b, depth) { + if (a === b) { + return true; + } + if (!depth || !a || !b) { + return false; + } + if (Array.isArray(a)) { + if (!Array.isArray(b) || a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (!deepEqual2(a[i], b[i], depth - 1)) { + return false; + } + } + return true; + } + if (Array.isArray(b)) { + return false; + } + if (typeof a === "object" && typeof b === "object") { + const aKeys = Object.keys(a); + const bKeys = Object.keys(b); + if (aKeys.length !== bKeys.length) { + return false; + } + for (const key of aKeys) { + if (!b.hasOwnProperty(key)) { + return false; + } + if (!deepEqual2(a[key], b[key], depth - 1)) { + return false; + } + } + return true; + } + return false; +} + +// node_modules/@deck.gl/core/dist/lib/view-manager.js +var ViewManager = class { + constructor(props) { + this.views = []; + this.width = 100; + this.height = 100; + this.viewState = {}; + this.controllers = {}; + this.timeline = props.timeline; + this._viewports = []; + this._viewportMap = {}; + this._isUpdating = false; + this._needsRedraw = "First render"; + this._needsUpdate = "Initialize"; + this._eventManager = props.eventManager; + this._eventCallbacks = { + onViewStateChange: props.onViewStateChange, + onInteractionStateChange: props.onInteractionStateChange + }; + Object.seal(this); + this.setProps(props); + } + /** Remove all resources and event listeners */ + finalize() { + for (const key in this.controllers) { + const controller = this.controllers[key]; + if (controller) { + controller.finalize(); + } + } + this.controllers = {}; + } + /** Check if a redraw is needed */ + needsRedraw(opts = { clearRedrawFlags: false }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + return redraw; + } + /** Mark the manager as dirty. Will rebuild all viewports and update controllers. */ + setNeedsUpdate(reason) { + this._needsUpdate = this._needsUpdate || reason; + this._needsRedraw = this._needsRedraw || reason; + } + /** Checks each viewport for transition updates */ + updateViewStates() { + for (const viewId in this.controllers) { + const controller = this.controllers[viewId]; + if (controller) { + controller.updateTransition(); + } + } + } + /** Get a set of viewports for a given width and height + * TODO - Intention is for deck.gl to autodeduce width and height and drop the need for props + * @param rect (object, optional) - filter the viewports + * + not provided - return all viewports + * + {x, y} - only return viewports that contain this pixel + * + {x, y, width, height} - only return viewports that overlap with this rectangle + */ + getViewports(rect) { + if (rect) { + return this._viewports.filter((viewport) => viewport.containsPixel(rect)); + } + return this._viewports; + } + /** Get a map of all views */ + getViews() { + const viewMap = {}; + this.views.forEach((view) => { + viewMap[view.id] = view; + }); + return viewMap; + } + /** Resolves a viewId string to a View */ + getView(viewId) { + return this.views.find((view) => view.id === viewId); + } + /** Returns the viewState for a specific viewId. Matches the viewState by + 1. view.viewStateId + 2. view.id + 3. root viewState + then applies the view's filter if any */ + getViewState(viewOrViewId) { + const view = typeof viewOrViewId === "string" ? this.getView(viewOrViewId) : viewOrViewId; + const viewState = view && this.viewState[view.getViewStateId()] || this.viewState; + return view ? view.filterViewState(viewState) : viewState; + } + getViewport(viewId) { + return this._viewportMap[viewId]; + } + /** + * Unproject pixel coordinates on screen onto world coordinates, + * (possibly [lon, lat]) on map. + * - [x, y] => [lng, lat] + * - [x, y, z] => [lng, lat, Z] + * @param {Array} xyz - + * @param {Object} opts - options + * @param {Object} opts.topLeft=true - Whether origin is top left + * @return {Array|null} - [lng, lat, Z] or [X, Y, Z] + */ + unproject(xyz, opts) { + const viewports = this.getViewports(); + const pixel = { x: xyz[0], y: xyz[1] }; + for (let i = viewports.length - 1; i >= 0; --i) { + const viewport = viewports[i]; + if (viewport.containsPixel(pixel)) { + const p = xyz.slice(); + p[0] -= viewport.x; + p[1] -= viewport.y; + return viewport.unproject(p, opts); + } + } + return null; + } + /** Update the manager with new Deck props */ + setProps(props) { + if (props.views) { + this._setViews(props.views); + } + if (props.viewState) { + this._setViewState(props.viewState); + } + if ("width" in props || "height" in props) { + this._setSize(props.width, props.height); + } + if (!this._isUpdating) { + this._update(); + } + } + // + // PRIVATE METHODS + // + _update() { + this._isUpdating = true; + if (this._needsUpdate) { + this._needsUpdate = false; + this._rebuildViewports(); + } + if (this._needsUpdate) { + this._needsUpdate = false; + this._rebuildViewports(); + } + this._isUpdating = false; + } + _setSize(width, height) { + if (width !== this.width || height !== this.height) { + this.width = width; + this.height = height; + this.setNeedsUpdate("Size changed"); + } + } + // Update the view descriptor list and set change flag if needed + // Does not actually rebuild the `Viewport`s until `getViewports` is called + _setViews(views) { + views = flatten(views, Boolean); + const viewsChanged = this._diffViews(views, this.views); + if (viewsChanged) { + this.setNeedsUpdate("views changed"); + } + this.views = views; + } + _setViewState(viewState) { + if (viewState) { + const viewStateChanged = !deepEqual2(viewState, this.viewState, 3); + if (viewStateChanged) { + this.setNeedsUpdate("viewState changed"); + } + this.viewState = viewState; + } else { + log_default.warn("missing `viewState` or `initialViewState`")(); + } + } + _createController(view, props) { + const Controller2 = props.type; + const controller = new Controller2({ + timeline: this.timeline, + eventManager: this._eventManager, + // Set an internal callback that calls the prop callback if provided + onViewStateChange: this._eventCallbacks.onViewStateChange, + onStateChange: this._eventCallbacks.onInteractionStateChange, + makeViewport: (viewState) => this.getView(view.id)?.makeViewport({ + viewState, + width: this.width, + height: this.height + }) + }); + return controller; + } + _updateController(view, viewState, viewport, controller) { + const controllerProps = view.controller; + if (controllerProps && viewport) { + const resolvedProps = { + ...viewState, + ...controllerProps, + id: view.id, + x: viewport.x, + y: viewport.y, + width: viewport.width, + height: viewport.height + }; + if (!controller || controller.constructor !== controllerProps.type) { + controller = this._createController(view, resolvedProps); + } + if (controller) { + controller.setProps(resolvedProps); + } + return controller; + } + return null; + } + // Rebuilds viewports from descriptors towards a certain window size + _rebuildViewports() { + const { views } = this; + const oldControllers = this.controllers; + this._viewports = []; + this.controllers = {}; + let invalidateControllers = false; + for (let i = views.length; i--; ) { + const view = views[i]; + const viewState = this.getViewState(view); + const viewport = view.makeViewport({ viewState, width: this.width, height: this.height }); + let oldController = oldControllers[view.id]; + const hasController = Boolean(view.controller); + if (hasController && !oldController) { + invalidateControllers = true; + } + if ((invalidateControllers || !hasController) && oldController) { + oldController.finalize(); + oldController = null; + } + this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController); + if (viewport) { + this._viewports.unshift(viewport); + } + } + for (const id in oldControllers) { + const oldController = oldControllers[id]; + if (oldController && !this.controllers[id]) { + oldController.finalize(); + } + } + this._buildViewportMap(); + } + _buildViewportMap() { + this._viewportMap = {}; + this._viewports.forEach((viewport) => { + if (viewport.id) { + this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport; + } + }); + } + // Check if viewport array has changed, returns true if any change + // Note that descriptors can be the same + _diffViews(newViews, oldViews) { + if (newViews.length !== oldViews.length) { + return true; + } + return newViews.some((_, i) => !newViews[i].equals(oldViews[i])); + } +}; + +// node_modules/@deck.gl/core/dist/utils/positions.js +var PERCENT_OR_PIXELS_REGEX = /([0-9]+\.?[0-9]*)(%|px)/; +function parsePosition(value) { + switch (typeof value) { + case "number": + return { + position: value, + relative: false + }; + case "string": + const match = PERCENT_OR_PIXELS_REGEX.exec(value); + if (match && match.length >= 3) { + const relative = match[2] === "%"; + const position = parseFloat(match[1]); + return { + position: relative ? position / 100 : position, + relative + }; + } + default: + throw new Error(`Could not parse position string ${value}`); + } +} +function getPosition(position, extent) { + return position.relative ? Math.round(position.position * extent) : position.position; +} + +// node_modules/@deck.gl/core/dist/views/view.js +var View = class { + constructor(props) { + const { id, x = 0, y = 0, width = "100%", height = "100%", padding = null } = props; + this.id = id || this.constructor.displayName || "view"; + this.props = { ...props, id: this.id }; + this._x = parsePosition(x); + this._y = parsePosition(y); + this._width = parsePosition(width); + this._height = parsePosition(height); + this._padding = padding && { + left: parsePosition(padding.left || 0), + right: parsePosition(padding.right || 0), + top: parsePosition(padding.top || 0), + bottom: parsePosition(padding.bottom || 0) + }; + this.equals = this.equals.bind(this); + Object.seal(this); + } + equals(view) { + if (this === view) { + return true; + } + return this.ViewportType === view.ViewportType && deepEqual2(this.props, view.props, 2); + } + /** Make viewport from canvas dimensions and view state */ + makeViewport({ width, height, viewState }) { + viewState = this.filterViewState(viewState); + const viewportDimensions = this.getDimensions({ width, height }); + if (!viewportDimensions.height || !viewportDimensions.width) { + return null; + } + return new this.ViewportType({ ...viewState, ...this.props, ...viewportDimensions }); + } + getViewStateId() { + const { viewState } = this.props; + if (typeof viewState === "string") { + return viewState; + } + return viewState?.id || this.id; + } + // Allows view to override (or completely define) viewState + filterViewState(viewState) { + if (this.props.viewState && typeof this.props.viewState === "object") { + if (!this.props.viewState.id) { + return this.props.viewState; + } + const newViewState = { ...viewState }; + for (const key in this.props.viewState) { + if (key !== "id") { + newViewState[key] = this.props.viewState[key]; + } + } + return newViewState; + } + return viewState; + } + /** Resolve the dimensions of the view from overall canvas dimensions */ + getDimensions({ width, height }) { + const dimensions = { + x: getPosition(this._x, width), + y: getPosition(this._y, height), + width: getPosition(this._width, width), + height: getPosition(this._height, height) + }; + if (this._padding) { + dimensions.padding = { + left: getPosition(this._padding.left, width), + top: getPosition(this._padding.top, height), + right: getPosition(this._padding.right, width), + bottom: getPosition(this._padding.bottom, height) + }; + } + return dimensions; + } + // Used by sub classes to resolve controller props + get controller() { + const opts = this.props.controller; + if (!opts) { + return null; + } + if (opts === true) { + return { type: this.ControllerType }; + } + if (typeof opts === "function") { + return { type: opts }; + } + return { type: this.ControllerType, ...opts }; + } +}; + +// node_modules/@deck.gl/core/dist/transitions/transition.js +var Transition = class { + /** + * @params timeline {Timeline} + */ + constructor(timeline) { + this._inProgress = false; + this._handle = null; + this.time = 0; + this.settings = { + duration: 0 + }; + this._timeline = timeline; + } + /* Public API */ + get inProgress() { + return this._inProgress; + } + /** + * (re)start this transition. + * @params props {object} - optional overriding props. see constructor + */ + start(settings) { + this.cancel(); + this.settings = settings; + this._inProgress = true; + this.settings.onStart?.(this); + } + /** + * end this transition if it is in progress. + */ + end() { + if (this._inProgress) { + this._timeline.removeChannel(this._handle); + this._handle = null; + this._inProgress = false; + this.settings.onEnd?.(this); + } + } + /** + * cancel this transition if it is in progress. + */ + cancel() { + if (this._inProgress) { + this.settings.onInterrupt?.(this); + this._timeline.removeChannel(this._handle); + this._handle = null; + this._inProgress = false; + } + } + /** + * update this transition. Returns `true` if updated. + */ + update() { + if (!this._inProgress) { + return false; + } + if (this._handle === null) { + const { _timeline: timeline, settings } = this; + this._handle = timeline.addChannel({ + delay: timeline.getTime(), + duration: settings.duration + }); + } + this.time = this._timeline.getTime(this._handle); + this._onUpdate(); + this.settings.onUpdate?.(this); + if (this._timeline.isFinished(this._handle)) { + this.end(); + } + return true; + } + /* Private API */ + _onUpdate() { + } +}; + +// node_modules/@deck.gl/core/dist/controllers/transition-manager.js +var noop2 = () => { +}; +var TRANSITION_EVENTS = { + BREAK: 1, + SNAP_TO_END: 2, + IGNORE: 3 +}; +var DEFAULT_EASING = (t) => t; +var DEFAULT_INTERRUPTION = TRANSITION_EVENTS.BREAK; +var TransitionManager = class { + constructor(opts) { + this._onTransitionUpdate = (transition) => { + const { time, settings: { interpolator, startProps, endProps, duration, easing } } = transition; + const t = easing(time / duration); + const viewport = interpolator.interpolateProps(startProps, endProps, t); + this.propsInTransition = this.getControllerState({ + ...this.props, + ...viewport + }).getViewportProps(); + this.onViewStateChange({ + viewState: this.propsInTransition, + oldViewState: this.props + }); + }; + this.getControllerState = opts.getControllerState; + this.propsInTransition = null; + this.transition = new Transition(opts.timeline); + this.onViewStateChange = opts.onViewStateChange || noop2; + this.onStateChange = opts.onStateChange || noop2; + } + finalize() { + this.transition.cancel(); + } + // Returns current transitioned viewport. + getViewportInTransition() { + return this.propsInTransition; + } + // Process the vewiport change, either ignore or trigger a new transition. + // Return true if a new transition is triggered, false otherwise. + processViewStateChange(nextProps) { + let transitionTriggered = false; + const currentProps = this.props; + this.props = nextProps; + if (!currentProps || this._shouldIgnoreViewportChange(currentProps, nextProps)) { + return false; + } + if (this._isTransitionEnabled(nextProps)) { + let startProps = currentProps; + if (this.transition.inProgress) { + const { interruption, endProps } = this.transition.settings; + startProps = { + ...currentProps, + ...interruption === TRANSITION_EVENTS.SNAP_TO_END ? endProps : this.propsInTransition || currentProps + }; + } + this._triggerTransition(startProps, nextProps); + transitionTriggered = true; + } else { + this.transition.cancel(); + } + return transitionTriggered; + } + updateTransition() { + this.transition.update(); + } + // Helper methods + _isTransitionEnabled(props) { + const { transitionDuration, transitionInterpolator } = props; + return (transitionDuration > 0 || transitionDuration === "auto") && Boolean(transitionInterpolator); + } + _isUpdateDueToCurrentTransition(props) { + if (this.transition.inProgress && this.propsInTransition) { + return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition); + } + return false; + } + _shouldIgnoreViewportChange(currentProps, nextProps) { + if (this.transition.inProgress) { + const transitionSettings = this.transition.settings; + return transitionSettings.interruption === TRANSITION_EVENTS.IGNORE || // Ignore update if it is due to current active transition. + this._isUpdateDueToCurrentTransition(nextProps); + } + if (this._isTransitionEnabled(nextProps)) { + return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps); + } + return true; + } + _triggerTransition(startProps, endProps) { + const startViewstate = this.getControllerState(startProps); + const endViewStateProps = this.getControllerState(endProps).shortestPathFrom(startViewstate); + const transitionInterpolator = endProps.transitionInterpolator; + const duration = transitionInterpolator.getDuration ? transitionInterpolator.getDuration(startProps, endProps) : endProps.transitionDuration; + if (duration === 0) { + return; + } + const initialProps = transitionInterpolator.initializeProps(startProps, endViewStateProps); + this.propsInTransition = {}; + const transitionSettings = { + duration, + easing: endProps.transitionEasing || DEFAULT_EASING, + interpolator: transitionInterpolator, + interruption: endProps.transitionInterruption || DEFAULT_INTERRUPTION, + startProps: initialProps.start, + endProps: initialProps.end, + onStart: endProps.onTransitionStart, + onUpdate: this._onTransitionUpdate, + onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt), + onEnd: this._onTransitionEnd(endProps.onTransitionEnd) + }; + this.transition.start(transitionSettings); + this.onStateChange({ inTransition: true }); + this.updateTransition(); + } + _onTransitionEnd(callback) { + return (transition) => { + this.propsInTransition = null; + this.onStateChange({ + inTransition: false, + isZooming: false, + isPanning: false, + isRotating: false + }); + callback?.(transition); + }; + } +}; + +// node_modules/@deck.gl/core/dist/utils/assert.js +function assert9(condition, message2) { + if (!condition) { + throw new Error(message2 || "deck.gl: assertion failed."); + } +} + +// node_modules/@deck.gl/core/dist/transitions/transition-interpolator.js +var TransitionInterpolator = class { + /** + * @param opts {array|object} + * @param opts.compare {array} - prop names used in equality check + * @param opts.extract {array} - prop names needed for interpolation + * @param opts.required {array} - prop names that must be supplied + * alternatively, supply one list of prop names as `opts` if all of the above are the same. + */ + constructor(opts) { + const { compare, extract, required } = opts; + this._propsToCompare = compare; + this._propsToExtract = extract || compare; + this._requiredProps = required; + } + /** + * Checks if two sets of props need transition in between + * @param currentProps {object} - a list of viewport props + * @param nextProps {object} - a list of viewport props + * @returns {bool} - true if two props are equivalent + */ + arePropsEqual(currentProps, nextProps) { + for (const key of this._propsToCompare) { + if (!(key in currentProps) || !(key in nextProps) || !equals(currentProps[key], nextProps[key])) { + return false; + } + } + return true; + } + /** + * Called before transition starts to validate/pre-process start and end props + * @param startProps {object} - a list of starting viewport props + * @param endProps {object} - a list of target viewport props + * @returns {Object} {start, end} - start and end props to be passed + * to `interpolateProps` + */ + initializeProps(startProps, endProps) { + const startViewStateProps = {}; + const endViewStateProps = {}; + for (const key of this._propsToExtract) { + if (key in startProps || key in endProps) { + startViewStateProps[key] = startProps[key]; + endViewStateProps[key] = endProps[key]; + } + } + this._checkRequiredProps(startViewStateProps); + this._checkRequiredProps(endViewStateProps); + return { start: startViewStateProps, end: endViewStateProps }; + } + /** + * Returns transition duration + * @param startProps {object} - a list of starting viewport props + * @param endProps {object} - a list of target viewport props + * @returns {Number} - transition duration in milliseconds + */ + getDuration(startProps, endProps) { + return endProps.transitionDuration; + } + _checkRequiredProps(props) { + if (!this._requiredProps) { + return; + } + this._requiredProps.forEach((propName) => { + const value = props[propName]; + assert9(Number.isFinite(value) || Array.isArray(value), `${propName} is required for transition`); + }); + } +}; + +// node_modules/@deck.gl/core/dist/transitions/linear-interpolator.js +var DEFAULT_PROPS3 = ["longitude", "latitude", "zoom", "bearing", "pitch"]; +var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"]; +var LinearInterpolator = class extends TransitionInterpolator { + /** + * @param {Object} opts + * @param {Array} opts.transitionProps - list of props to apply linear transition to. + * @param {Array} opts.around - a screen point to zoom/rotate around. + * @param {Function} opts.makeViewport - construct a viewport instance with given props. + */ + constructor(opts = {}) { + const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps; + const normalizedOpts = Array.isArray(opts) ? {} : opts; + normalizedOpts.transitionProps = Array.isArray(transitionProps) ? { + compare: transitionProps, + required: transitionProps + } : transitionProps || { + compare: DEFAULT_PROPS3, + required: DEFAULT_REQUIRED_PROPS + }; + super(normalizedOpts.transitionProps); + this.opts = normalizedOpts; + } + initializeProps(startProps, endProps) { + const result = super.initializeProps(startProps, endProps); + const { makeViewport, around } = this.opts; + if (makeViewport && around) { + const startViewport = makeViewport(startProps); + const endViewport = makeViewport(endProps); + const aroundPosition = startViewport.unproject(around); + result.start.around = around; + Object.assign(result.end, { + around: endViewport.project(aroundPosition), + aroundPosition, + width: endProps.width, + height: endProps.height + }); + } + return result; + } + interpolateProps(startProps, endProps, t) { + const propsInTransition = {}; + for (const key of this._propsToExtract) { + propsInTransition[key] = lerp(startProps[key] || 0, endProps[key] || 0, t); + } + if (endProps.aroundPosition && this.opts.makeViewport) { + const viewport = this.opts.makeViewport({ ...endProps, ...propsInTransition }); + Object.assign(propsInTransition, viewport.panByPosition( + endProps.aroundPosition, + // anchor point in current screen coordinates + lerp(startProps.around, endProps.around, t) + )); + } + return propsInTransition; + } +}; + +// node_modules/@deck.gl/core/dist/controllers/controller.js +var NO_TRANSITION_PROPS = { + transitionDuration: 0 +}; +var DEFAULT_INERTIA = 300; +var INERTIA_EASING = (t) => 1 - (1 - t) * (1 - t); +var EVENT_TYPES = { + WHEEL: ["wheel"], + PAN: ["panstart", "panmove", "panend"], + PINCH: ["pinchstart", "pinchmove", "pinchend"], + TRIPLE_PAN: ["tripanstart", "tripanmove", "tripanend"], + DOUBLE_TAP: ["doubletap"], + KEYBOARD: ["keydown"] +}; +var pinchEventWorkaround = {}; +var Controller = class { + constructor(opts) { + this.state = {}; + this._events = {}; + this._interactionState = { + isDragging: false + }; + this._customEvents = []; + this._eventStartBlocked = null; + this._panMove = false; + this.invertPan = false; + this.dragMode = "rotate"; + this.inertia = 0; + this.scrollZoom = true; + this.dragPan = true; + this.dragRotate = true; + this.doubleClickZoom = true; + this.touchZoom = true; + this.touchRotate = false; + this.keyboard = true; + this.transitionManager = new TransitionManager({ + ...opts, + getControllerState: (props) => new this.ControllerState(props), + onViewStateChange: this._onTransition.bind(this), + onStateChange: this._setInteractionState.bind(this) + }); + this.handleEvent = this.handleEvent.bind(this); + this.eventManager = opts.eventManager; + this.onViewStateChange = opts.onViewStateChange || (() => { + }); + this.onStateChange = opts.onStateChange || (() => { + }); + this.makeViewport = opts.makeViewport; + } + set events(customEvents) { + this.toggleEvents(this._customEvents, false); + this.toggleEvents(customEvents, true); + this._customEvents = customEvents; + if (this.props) { + this.setProps(this.props); + } + } + finalize() { + for (const eventName in this._events) { + if (this._events[eventName]) { + this.eventManager?.off(eventName, this.handleEvent); + } + } + this.transitionManager.finalize(); + } + /** + * Callback for events + */ + handleEvent(event) { + this._controllerState = void 0; + const eventStartBlocked = this._eventStartBlocked; + switch (event.type) { + case "panstart": + return eventStartBlocked ? false : this._onPanStart(event); + case "panmove": + return this._onPan(event); + case "panend": + return this._onPanEnd(event); + case "pinchstart": + return eventStartBlocked ? false : this._onPinchStart(event); + case "pinchmove": + return this._onPinch(event); + case "pinchend": + return this._onPinchEnd(event); + case "tripanstart": + return eventStartBlocked ? false : this._onTriplePanStart(event); + case "tripanmove": + return this._onTriplePan(event); + case "tripanend": + return this._onTriplePanEnd(event); + case "doubletap": + return this._onDoubleTap(event); + case "wheel": + return this._onWheel(event); + case "keydown": + return this._onKeyDown(event); + default: + return false; + } + } + /* Event utils */ + // Event object: http://hammerjs.github.io/api/#event-object + get controllerState() { + this._controllerState = this._controllerState || new this.ControllerState({ + makeViewport: this.makeViewport, + ...this.props, + ...this.state + }); + return this._controllerState; + } + getCenter(event) { + const { x, y } = this.props; + const { offsetCenter } = event; + return [offsetCenter.x - x, offsetCenter.y - y]; + } + isPointInBounds(pos, event) { + const { width, height } = this.props; + if (event && event.handled) { + return false; + } + const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height; + if (inside && event) { + event.stopPropagation(); + } + return inside; + } + isFunctionKeyPressed(event) { + const { srcEvent } = event; + return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey); + } + isDragging() { + return this._interactionState.isDragging || false; + } + // When a multi-touch event ends, e.g. pinch, not all pointers are lifted at the same time. + // This triggers a brief `pan` event. + // Calling this method will temporarily disable *start events to avoid conflicting transitions. + blockEvents(timeout) { + const timer = setTimeout(() => { + if (this._eventStartBlocked === timer) { + this._eventStartBlocked = null; + } + }, timeout); + this._eventStartBlocked = timer; + } + /** + * Extract interactivity options + */ + setProps(props) { + if (props.dragMode) { + this.dragMode = props.dragMode; + } + this.props = props; + if (!("transitionInterpolator" in props)) { + props.transitionInterpolator = this._getTransitionProps().transitionInterpolator; + } + this.transitionManager.processViewStateChange(props); + const { inertia } = props; + this.inertia = Number.isFinite(inertia) ? inertia : inertia === true ? DEFAULT_INERTIA : 0; + const { scrollZoom = true, dragPan = true, dragRotate = true, doubleClickZoom = true, touchZoom = true, touchRotate = false, keyboard = true } = props; + const isInteractive = Boolean(this.onViewStateChange); + this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom); + this.toggleEvents(EVENT_TYPES.PAN, isInteractive); + this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate)); + this.toggleEvents(EVENT_TYPES.TRIPLE_PAN, isInteractive && touchRotate); + this.toggleEvents(EVENT_TYPES.DOUBLE_TAP, isInteractive && doubleClickZoom); + this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard); + this.scrollZoom = scrollZoom; + this.dragPan = dragPan; + this.dragRotate = dragRotate; + this.doubleClickZoom = doubleClickZoom; + this.touchZoom = touchZoom; + this.touchRotate = touchRotate; + this.keyboard = keyboard; + } + updateTransition() { + this.transitionManager.updateTransition(); + } + toggleEvents(eventNames, enabled) { + if (this.eventManager) { + eventNames.forEach((eventName) => { + if (this._events[eventName] !== enabled) { + this._events[eventName] = enabled; + if (enabled) { + this.eventManager.on(eventName, this.handleEvent); + } else { + this.eventManager.off(eventName, this.handleEvent); + } + } + }); + } + } + // Private Methods + /* Callback util */ + // formats map state and invokes callback function + updateViewport(newControllerState, extraProps = null, interactionState = {}) { + const viewState = { ...newControllerState.getViewportProps(), ...extraProps }; + const changed = this.controllerState !== newControllerState; + this.state = newControllerState.getState(); + this._setInteractionState(interactionState); + if (changed) { + const oldViewState = this.controllerState && this.controllerState.getViewportProps(); + if (this.onViewStateChange) { + this.onViewStateChange({ viewState, interactionState: this._interactionState, oldViewState, viewId: this.props.id }); + } + } + } + _onTransition(params) { + this.onViewStateChange({ ...params, interactionState: this._interactionState, viewId: this.props.id }); + } + _setInteractionState(newStates) { + Object.assign(this._interactionState, newStates); + this.onStateChange(this._interactionState); + } + /* Event handlers */ + // Default handler for the `panstart` event. + _onPanStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton || false; + if (this.invertPan || this.dragMode === "pan") { + alternateMode = !alternateMode; + } + const newControllerState = this.controllerState[alternateMode ? "panStart" : "rotateStart"]({ + pos + }); + this._panMove = alternateMode; + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); + return true; + } + // Default handler for the `panmove` and `panend` event. + _onPan(event) { + if (!this.isDragging()) { + return false; + } + return this._panMove ? this._onPanMove(event) : this._onPanRotate(event); + } + _onPanEnd(event) { + if (!this.isDragging()) { + return false; + } + return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event); + } + // Default handler for panning to move. + // Called by `_onPan` when panning without function key pressed. + _onPanMove(event) { + if (!this.dragPan) { + return false; + } + const pos = this.getCenter(event); + const newControllerState = this.controllerState.pan({ pos }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isPanning: true + }); + return true; + } + _onPanMoveEnd(event) { + const { inertia } = this; + if (this.dragPan && inertia && event.velocity) { + const pos = this.getCenter(event); + const endPos = [ + pos[0] + event.velocityX * inertia / 2, + pos[1] + event.velocityY * inertia / 2 + ]; + const newControllerState = this.controllerState.pan({ pos: endPos }).panEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isPanning: true + }); + } else { + const newControllerState = this.controllerState.panEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isPanning: false + }); + } + return true; + } + // Default handler for panning to rotate. + // Called by `_onPan` when panning with function key pressed. + _onPanRotate(event) { + if (!this.dragRotate) { + return false; + } + const pos = this.getCenter(event); + const newControllerState = this.controllerState.rotate({ pos }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isRotating: true + }); + return true; + } + _onPanRotateEnd(event) { + const { inertia } = this; + if (this.dragRotate && inertia && event.velocity) { + const pos = this.getCenter(event); + const endPos = [ + pos[0] + event.velocityX * inertia / 2, + pos[1] + event.velocityY * inertia / 2 + ]; + const newControllerState = this.controllerState.rotate({ pos: endPos }).rotateEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isRotating: true + }); + } else { + const newControllerState = this.controllerState.rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isRotating: false + }); + } + return true; + } + // Default handler for the `wheel` event. + _onWheel(event) { + if (!this.scrollZoom) { + return false; + } + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + event.srcEvent.preventDefault(); + const { speed = 0.01, smooth = false } = this.scrollZoom === true ? {} : this.scrollZoom; + const { delta } = event; + let scale13 = 2 / (1 + Math.exp(-Math.abs(delta * speed))); + if (delta < 0 && scale13 !== 0) { + scale13 = 1 / scale13; + } + const newControllerState = this.controllerState.zoom({ pos, scale: scale13 }); + this.updateViewport(newControllerState, { ...this._getTransitionProps({ around: pos }), transitionDuration: smooth ? 250 : 1 }, { + isZooming: true, + isPanning: true + }); + return true; + } + _onTriplePanStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const newControllerState = this.controllerState.rotateStart({ pos }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); + return true; + } + _onTriplePan(event) { + if (!this.touchRotate) { + return false; + } + if (!this.isDragging()) { + return false; + } + const pos = this.getCenter(event); + pos[0] -= event.deltaX; + const newControllerState = this.controllerState.rotate({ pos }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isRotating: true + }); + return true; + } + _onTriplePanEnd(event) { + if (!this.isDragging()) { + return false; + } + const { inertia } = this; + if (this.touchRotate && inertia && event.velocityY) { + const pos = this.getCenter(event); + const endPos = [pos[0], pos[1] += event.velocityY * inertia / 2]; + const newControllerState = this.controllerState.rotate({ pos: endPos }); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isRotating: true + }); + this.blockEvents(inertia); + } else { + const newControllerState = this.controllerState.rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isRotating: false + }); + } + return true; + } + // Default handler for the `pinchstart` event. + _onPinchStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const newControllerState = this.controllerState.zoomStart({ pos }).rotateStart({ pos }); + pinchEventWorkaround._startPinchRotation = event.rotation; + pinchEventWorkaround._lastPinchEvent = event; + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); + return true; + } + // Default handler for the `pinchmove` and `pinchend` events. + _onPinch(event) { + if (!this.touchZoom && !this.touchRotate) { + return false; + } + if (!this.isDragging()) { + return false; + } + let newControllerState = this.controllerState; + if (this.touchZoom) { + const { scale: scale13 } = event; + const pos = this.getCenter(event); + newControllerState = newControllerState.zoom({ pos, scale: scale13 }); + } + if (this.touchRotate) { + const { rotation } = event; + newControllerState = newControllerState.rotate({ + deltaAngleX: pinchEventWorkaround._startPinchRotation - rotation + }); + } + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isPanning: this.touchZoom, + isZooming: this.touchZoom, + isRotating: this.touchRotate + }); + pinchEventWorkaround._lastPinchEvent = event; + return true; + } + _onPinchEnd(event) { + if (!this.isDragging()) { + return false; + } + const { inertia } = this; + const { _lastPinchEvent } = pinchEventWorkaround; + if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) { + const pos = this.getCenter(event); + let newControllerState = this.controllerState.rotateEnd(); + const z = Math.log2(event.scale); + const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime); + const endScale = Math.pow(2, z + velocityZ * inertia / 2); + newControllerState = newControllerState.zoom({ pos, scale: endScale }).zoomEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps({ around: pos }), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isPanning: this.touchZoom, + isZooming: this.touchZoom, + isRotating: false + }); + this.blockEvents(inertia); + } else { + const newControllerState = this.controllerState.zoomEnd().rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isPanning: false, + isZooming: false, + isRotating: false + }); + } + pinchEventWorkaround._startPinchRotation = null; + pinchEventWorkaround._lastPinchEvent = null; + return true; + } + // Default handler for the `doubletap` event. + _onDoubleTap(event) { + if (!this.doubleClickZoom) { + return false; + } + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const isZoomOut = this.isFunctionKeyPressed(event); + const newControllerState = this.controllerState.zoom({ pos, scale: isZoomOut ? 0.5 : 2 }); + this.updateViewport(newControllerState, this._getTransitionProps({ around: pos }), { + isZooming: true, + isPanning: true + }); + this.blockEvents(100); + return true; + } + // Default handler for the `keydown` event + _onKeyDown(event) { + if (!this.keyboard) { + return false; + } + const funcKey = this.isFunctionKeyPressed(event); + const { zoomSpeed, moveSpeed, rotateSpeedX, rotateSpeedY } = this.keyboard === true ? {} : this.keyboard; + const { controllerState } = this; + let newControllerState; + const interactionState = {}; + switch (event.srcEvent.code) { + case "Minus": + newControllerState = funcKey ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed) : controllerState.zoomOut(zoomSpeed); + interactionState.isZooming = true; + break; + case "Equal": + newControllerState = funcKey ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed) : controllerState.zoomIn(zoomSpeed); + interactionState.isZooming = true; + break; + case "ArrowLeft": + if (funcKey) { + newControllerState = controllerState.rotateLeft(rotateSpeedX); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveLeft(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowRight": + if (funcKey) { + newControllerState = controllerState.rotateRight(rotateSpeedX); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveRight(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowUp": + if (funcKey) { + newControllerState = controllerState.rotateUp(rotateSpeedY); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveUp(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowDown": + if (funcKey) { + newControllerState = controllerState.rotateDown(rotateSpeedY); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveDown(moveSpeed); + interactionState.isPanning = true; + } + break; + default: + return false; + } + this.updateViewport(newControllerState, this._getTransitionProps(), interactionState); + return true; + } + _getTransitionProps(opts) { + const { transition } = this; + if (!transition || !transition.transitionInterpolator) { + return NO_TRANSITION_PROPS; + } + return opts ? { + ...transition, + transitionInterpolator: new LinearInterpolator({ + ...opts, + ...transition.transitionInterpolator.opts, + makeViewport: this.controllerState.makeViewport + }) + } : transition; + } +}; + +// node_modules/@deck.gl/core/dist/controllers/view-state.js +var ViewState = class { + constructor(props, state) { + this._viewportProps = this.applyConstraints(props); + this._state = state; + } + getViewportProps() { + return this._viewportProps; + } + getState() { + return this._state; + } +}; + +// node_modules/@deck.gl/core/dist/controllers/map-controller.js +var PITCH_MOUSE_THRESHOLD = 5; +var PITCH_ACCEL = 1.2; +var MapState = class extends ViewState { + constructor(options) { + const { + /** Mapbox viewport properties */ + /** The width of the viewport */ + width, + /** The height of the viewport */ + height, + /** The latitude at the center of the viewport */ + latitude, + /** The longitude at the center of the viewport */ + longitude, + /** The tile zoom level of the map. */ + zoom, + /** The bearing of the viewport in degrees */ + bearing = 0, + /** The pitch of the viewport in degrees */ + pitch = 0, + /** + * Specify the altitude of the viewport camera + * Unit: map heights, default 1.5 + * Non-public API, see https://github.com/mapbox/mapbox-gl-js/issues/1137 + */ + altitude = 1.5, + /** Viewport position */ + position = [0, 0, 0], + /** Viewport constraints */ + maxZoom = 20, + minZoom = 0, + maxPitch = 60, + minPitch = 0, + /** Interaction states, required to calculate change during transform */ + /* The point on map being grabbed when the operation first started */ + startPanLngLat, + /* Center of the zoom when the operation first started */ + startZoomLngLat, + /* Pointer position when rotation started */ + startRotatePos, + /** Bearing when current perspective rotate operation started */ + startBearing, + /** Pitch when current perspective rotate operation started */ + startPitch, + /** Zoom when current zoom operation started */ + startZoom, + /** Normalize viewport props to fit map height into viewport */ + normalize: normalize11 = true + } = options; + assert9(Number.isFinite(longitude)); + assert9(Number.isFinite(latitude)); + assert9(Number.isFinite(zoom)); + super({ + width, + height, + latitude, + longitude, + zoom, + bearing, + pitch, + altitude, + maxZoom, + minZoom, + maxPitch, + minPitch, + normalize: normalize11, + position + }, { + startPanLngLat, + startZoomLngLat, + startRotatePos, + startBearing, + startPitch, + startZoom + }); + this.makeViewport = options.makeViewport; + } + /** + * Start panning + * @param {[Number, Number]} pos - position on screen where the pointer grabs + */ + panStart({ pos }) { + return this._getUpdatedState({ + startPanLngLat: this._unproject(pos) + }); + } + /** + * Pan + * @param {[Number, Number]} pos - position on screen where the pointer is + * @param {[Number, Number], optional} startPos - where the pointer grabbed at + * the start of the operation. Must be supplied of `panStart()` was not called + */ + pan({ pos, startPos }) { + const startPanLngLat = this.getState().startPanLngLat || this._unproject(startPos); + if (!startPanLngLat) { + return this; + } + const viewport = this.makeViewport(this.getViewportProps()); + const newProps = viewport.panByPosition(startPanLngLat, pos); + return this._getUpdatedState(newProps); + } + /** + * End panning + * Must call if `panStart()` was called + */ + panEnd() { + return this._getUpdatedState({ + startPanLngLat: null + }); + } + /** + * Start rotating + * @param {[Number, Number]} pos - position on screen where the center is + */ + rotateStart({ pos }) { + return this._getUpdatedState({ + startRotatePos: pos, + startBearing: this.getViewportProps().bearing, + startPitch: this.getViewportProps().pitch + }); + } + /** + * Rotate + * @param {[Number, Number]} pos - position on screen where the center is + */ + rotate({ pos, deltaAngleX = 0, deltaAngleY = 0 }) { + const { startRotatePos, startBearing, startPitch } = this.getState(); + if (!startRotatePos || startBearing === void 0 || startPitch === void 0) { + return this; + } + let newRotation; + if (pos) { + newRotation = this._getNewRotation(pos, startRotatePos, startPitch, startBearing); + } else { + newRotation = { + bearing: startBearing + deltaAngleX, + pitch: startPitch + deltaAngleY + }; + } + return this._getUpdatedState(newRotation); + } + /** + * End rotating + * Must call if `rotateStart()` was called + */ + rotateEnd() { + return this._getUpdatedState({ + startBearing: null, + startPitch: null + }); + } + /** + * Start zooming + * @param {[Number, Number]} pos - position on screen where the center is + */ + zoomStart({ pos }) { + return this._getUpdatedState({ + startZoomLngLat: this._unproject(pos), + startZoom: this.getViewportProps().zoom + }); + } + /** + * Zoom + * @param {[Number, Number]} pos - position on screen where the current center is + * @param {[Number, Number]} startPos - the center position at + * the start of the operation. Must be supplied of `zoomStart()` was not called + * @param {Number} scale - a number between [0, 1] specifying the accumulated + * relative scale. + */ + zoom({ pos, startPos, scale: scale13 }) { + let { startZoom, startZoomLngLat } = this.getState(); + if (!startZoomLngLat) { + startZoom = this.getViewportProps().zoom; + startZoomLngLat = this._unproject(startPos) || this._unproject(pos); + } + if (!startZoomLngLat) { + return this; + } + const { maxZoom, minZoom } = this.getViewportProps(); + let zoom = startZoom + Math.log2(scale13); + zoom = clamp(zoom, minZoom, maxZoom); + const zoomedViewport = this.makeViewport({ ...this.getViewportProps(), zoom }); + return this._getUpdatedState({ + zoom, + ...zoomedViewport.panByPosition(startZoomLngLat, pos) + }); + } + /** + * End zooming + * Must call if `zoomStart()` was called + */ + zoomEnd() { + return this._getUpdatedState({ + startZoomLngLat: null, + startZoom: null + }); + } + zoomIn(speed = 2) { + return this._zoomFromCenter(speed); + } + zoomOut(speed = 2) { + return this._zoomFromCenter(1 / speed); + } + moveLeft(speed = 100) { + return this._panFromCenter([speed, 0]); + } + moveRight(speed = 100) { + return this._panFromCenter([-speed, 0]); + } + moveUp(speed = 100) { + return this._panFromCenter([0, speed]); + } + moveDown(speed = 100) { + return this._panFromCenter([0, -speed]); + } + rotateLeft(speed = 15) { + return this._getUpdatedState({ + bearing: this.getViewportProps().bearing - speed + }); + } + rotateRight(speed = 15) { + return this._getUpdatedState({ + bearing: this.getViewportProps().bearing + speed + }); + } + rotateUp(speed = 10) { + return this._getUpdatedState({ + pitch: this.getViewportProps().pitch + speed + }); + } + rotateDown(speed = 10) { + return this._getUpdatedState({ + pitch: this.getViewportProps().pitch - speed + }); + } + shortestPathFrom(viewState) { + const fromProps = viewState.getViewportProps(); + const props = { ...this.getViewportProps() }; + const { bearing, longitude } = props; + if (Math.abs(bearing - fromProps.bearing) > 180) { + props.bearing = bearing < 0 ? bearing + 360 : bearing - 360; + } + if (Math.abs(longitude - fromProps.longitude) > 180) { + props.longitude = longitude < 0 ? longitude + 360 : longitude - 360; + } + return props; + } + // Apply any constraints (mathematical or defined by _viewportProps) to map state + applyConstraints(props) { + const { maxZoom, minZoom, zoom } = props; + props.zoom = clamp(zoom, minZoom, maxZoom); + const { maxPitch, minPitch, pitch } = props; + props.pitch = clamp(pitch, minPitch, maxPitch); + const { normalize: normalize11 = true } = props; + if (normalize11) { + Object.assign(props, normalizeViewportProps(props)); + } + return props; + } + /* Private methods */ + _zoomFromCenter(scale13) { + const { width, height } = this.getViewportProps(); + return this.zoom({ + pos: [width / 2, height / 2], + scale: scale13 + }); + } + _panFromCenter(offset) { + const { width, height } = this.getViewportProps(); + return this.pan({ + startPos: [width / 2, height / 2], + pos: [width / 2 + offset[0], height / 2 + offset[1]] + }); + } + _getUpdatedState(newProps) { + return new this.constructor({ + makeViewport: this.makeViewport, + ...this.getViewportProps(), + ...this.getState(), + ...newProps + }); + } + _unproject(pos) { + const viewport = this.makeViewport(this.getViewportProps()); + return pos && viewport.unproject(pos); + } + _getNewRotation(pos, startPos, startPitch, startBearing) { + const deltaX = pos[0] - startPos[0]; + const deltaY = pos[1] - startPos[1]; + const centerY = pos[1]; + const startY = startPos[1]; + const { width, height } = this.getViewportProps(); + const deltaScaleX = deltaX / width; + let deltaScaleY = 0; + if (deltaY > 0) { + if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) { + deltaScaleY = deltaY / (startY - height) * PITCH_ACCEL; + } + } else if (deltaY < 0) { + if (startY > PITCH_MOUSE_THRESHOLD) { + deltaScaleY = 1 - centerY / startY; + } + } + deltaScaleY = clamp(deltaScaleY, -1, 1); + const { minPitch, maxPitch } = this.getViewportProps(); + const bearing = startBearing + 180 * deltaScaleX; + let pitch = startPitch; + if (deltaScaleY > 0) { + pitch = startPitch + deltaScaleY * (maxPitch - startPitch); + } else if (deltaScaleY < 0) { + pitch = startPitch - deltaScaleY * (minPitch - startPitch); + } + return { + pitch, + bearing + }; + } +}; +var MapController = class extends Controller { + constructor() { + super(...arguments); + this.ControllerState = MapState; + this.transition = { + transitionDuration: 300, + transitionInterpolator: new LinearInterpolator({ + transitionProps: { + compare: ["longitude", "latitude", "zoom", "bearing", "pitch", "position"], + required: ["longitude", "latitude", "zoom"] + } + }) + }; + this.dragMode = "pan"; + } + setProps(props) { + props.position = props.position || [0, 0, 0]; + const oldProps = this.props; + super.setProps(props); + const dimensionChanged = !oldProps || oldProps.height !== props.height; + if (dimensionChanged) { + this.updateViewport(new this.ControllerState({ + makeViewport: this.makeViewport, + ...props, + ...this.state + })); + } + } +}; + +// node_modules/@deck.gl/core/dist/views/map-view.js +var MapView = class extends View { + constructor(props = {}) { + super(props); + } + get ViewportType() { + return web_mercator_viewport_default; + } + get ControllerType() { + return MapController; + } +}; +MapView.displayName = "MapView"; +var map_view_default = MapView; + +// node_modules/@deck.gl/core/dist/lib/effect-manager.js +var DEFAULT_LIGHTING_EFFECT = new LightingEffect(); +function compareEffects(e1, e2) { + const o1 = e1.order ?? Infinity; + const o2 = e2.order ?? Infinity; + return o1 - o2; +} +var EffectManager = class { + constructor(context) { + this._resolvedEffects = []; + this._defaultEffects = []; + this.effects = []; + this._context = context; + this._needsRedraw = "Initial render"; + this._setEffects([]); + } + /** + * Register a new default effect, i.e. an effect presents regardless of user supplied props.effects + */ + addDefaultEffect(effect) { + const defaultEffects = this._defaultEffects; + if (!defaultEffects.find((e) => e.id === effect.id)) { + const index2 = defaultEffects.findIndex((e) => compareEffects(e, effect) > 0); + if (index2 < 0) { + defaultEffects.push(effect); + } else { + defaultEffects.splice(index2, 0, effect); + } + effect.setup(this._context); + this._setEffects(this.effects); + } + } + setProps(props) { + if ("effects" in props) { + if (!deepEqual2(props.effects, this.effects, 1)) { + this._setEffects(props.effects); + } + } + } + needsRedraw(opts = { clearRedrawFlags: false }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + return redraw; + } + getEffects() { + return this._resolvedEffects; + } + _setEffects(effects) { + const oldEffectsMap = {}; + for (const effect of this.effects) { + oldEffectsMap[effect.id] = effect; + } + const nextEffects = []; + for (const effect of effects) { + const oldEffect = oldEffectsMap[effect.id]; + let effectToAdd = effect; + if (oldEffect && oldEffect !== effect) { + if (oldEffect.setProps) { + oldEffect.setProps(effect.props); + effectToAdd = oldEffect; + } else { + oldEffect.cleanup(this._context); + } + } else if (!oldEffect) { + effect.setup(this._context); + } + nextEffects.push(effectToAdd); + delete oldEffectsMap[effect.id]; + } + for (const removedEffectId in oldEffectsMap) { + oldEffectsMap[removedEffectId].cleanup(this._context); + } + this.effects = nextEffects; + this._resolvedEffects = nextEffects.concat(this._defaultEffects); + if (!effects.some((effect) => effect instanceof LightingEffect)) { + this._resolvedEffects.push(DEFAULT_LIGHTING_EFFECT); + } + this._needsRedraw = "effects changed"; + } + finalize() { + for (const effect of this._resolvedEffects) { + effect.cleanup(this._context); + } + this.effects.length = 0; + this._resolvedEffects.length = 0; + this._defaultEffects.length = 0; + } +}; + +// node_modules/@deck.gl/core/dist/passes/draw-layers-pass.js +var DrawLayersPass = class extends LayersPass { + shouldDrawLayer(layer) { + const { operation } = layer.props; + return operation.includes("draw") || operation.includes("terrain"); + } +}; + +// node_modules/@deck.gl/core/dist/lib/deck-renderer.js +var TRACE_RENDER_LAYERS = "deckRenderer.renderLayers"; +var DeckRenderer = class { + constructor(device) { + this.device = device; + this.layerFilter = null; + this.drawPickingColors = false; + this.drawLayersPass = new DrawLayersPass(device); + this.pickLayersPass = new PickLayersPass(device); + this.renderCount = 0; + this._needsRedraw = "Initial render"; + this.renderBuffers = []; + this.lastPostProcessEffect = null; + } + setProps(props) { + if (this.layerFilter !== props.layerFilter) { + this.layerFilter = props.layerFilter; + this._needsRedraw = "layerFilter changed"; + } + if (this.drawPickingColors !== props.drawPickingColors) { + this.drawPickingColors = props.drawPickingColors; + this._needsRedraw = "drawPickingColors changed"; + } + } + renderLayers(opts) { + if (!opts.viewports.length) { + return; + } + const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass; + const renderOpts = { + layerFilter: this.layerFilter, + isPicking: this.drawPickingColors, + ...opts + }; + if (renderOpts.effects) { + this._preRender(renderOpts.effects, renderOpts); + } + const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target; + if (this.lastPostProcessEffect) { + renderOpts.clearColor = [0, 0, 0, 0]; + renderOpts.clearCanvas = true; + } + const renderStats = layerPass.render({ ...renderOpts, target: outputBuffer }); + if (renderOpts.effects) { + this._postRender(renderOpts.effects, renderOpts); + } + this.renderCount++; + debug(TRACE_RENDER_LAYERS, this, renderStats, opts); + } + needsRedraw(opts = { clearRedrawFlags: false }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + return redraw; + } + finalize() { + const { renderBuffers } = this; + for (const buffer of renderBuffers) { + buffer.delete(); + } + renderBuffers.length = 0; + } + _preRender(effects, opts) { + this.lastPostProcessEffect = null; + opts.preRenderStats = opts.preRenderStats || {}; + for (const effect of effects) { + opts.preRenderStats[effect.id] = effect.preRender(opts); + if (effect.postRender) { + this.lastPostProcessEffect = effect.id; + } + } + if (this.lastPostProcessEffect) { + this._resizeRenderBuffers(); + } + } + _resizeRenderBuffers() { + const { renderBuffers } = this; + const size = this.device.canvasContext.getDrawingBufferSize(); + if (renderBuffers.length === 0) { + [0, 1].map((i) => { + const texture = this.device.createTexture({ + sampler: { minFilter: "linear", magFilter: "linear" } + }); + renderBuffers.push(this.device.createFramebuffer({ + id: `deck-renderbuffer-${i}`, + colorAttachments: [texture] + })); + }); + } + for (const buffer of renderBuffers) { + buffer.resize(size); + } + } + _postRender(effects, opts) { + const { renderBuffers } = this; + const params = { + ...opts, + inputBuffer: renderBuffers[0], + swapBuffer: renderBuffers[1] + }; + for (const effect of effects) { + if (effect.postRender) { + params.target = effect.id === this.lastPostProcessEffect ? opts.target : void 0; + const buffer = effect.postRender(params); + params.inputBuffer = buffer; + params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0]; + } + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/picking/query-object.js +var NO_PICKED_OBJECT = { + pickedColor: null, + pickedObjectIndex: -1 +}; +function getClosestObject({ pickedColors, decodePickingColor, deviceX, deviceY, deviceRadius, deviceRect }) { + const { x, y, width, height } = deviceRect; + let minSquareDistanceToCenter = deviceRadius * deviceRadius; + let closestPixelIndex = -1; + let i = 0; + for (let row = 0; row < height; row++) { + const dy = row + y - deviceY; + const dy2 = dy * dy; + if (dy2 > minSquareDistanceToCenter) { + i += 4 * width; + } else { + for (let col = 0; col < width; col++) { + const pickedLayerIndex = pickedColors[i + 3] - 1; + if (pickedLayerIndex >= 0) { + const dx = col + x - deviceX; + const d2 = dx * dx + dy2; + if (d2 <= minSquareDistanceToCenter) { + minSquareDistanceToCenter = d2; + closestPixelIndex = i; + } + } + i += 4; + } + } + } + if (closestPixelIndex >= 0) { + const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4); + const pickedObject = decodePickingColor(pickedColor); + if (pickedObject) { + const dy = Math.floor(closestPixelIndex / 4 / width); + const dx = closestPixelIndex / 4 - dy * width; + return { + ...pickedObject, + pickedColor, + pickedX: x + dx, + pickedY: y + dy + }; + } + log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); + } + return NO_PICKED_OBJECT; +} +function getUniqueObjects({ pickedColors, decodePickingColor }) { + const uniqueColors = /* @__PURE__ */ new Map(); + if (pickedColors) { + for (let i = 0; i < pickedColors.length; i += 4) { + const pickedLayerIndex = pickedColors[i + 3] - 1; + if (pickedLayerIndex >= 0) { + const pickedColor = pickedColors.slice(i, i + 4); + const colorKey = pickedColor.join(","); + if (!uniqueColors.has(colorKey)) { + const pickedObject = decodePickingColor(pickedColor); + if (pickedObject) { + uniqueColors.set(colorKey, { + ...pickedObject, + color: pickedColor + }); + } else { + log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); + } + } + } + } + } + return Array.from(uniqueColors.values()); +} + +// node_modules/@deck.gl/core/dist/lib/picking/pick-info.js +function getEmptyPickingInfo({ pickInfo, viewports, pixelRatio, x, y, z }) { + let pickedViewport = viewports[0]; + if (viewports.length > 1) { + pickedViewport = getViewportFromCoordinates(pickInfo?.pickedViewports || viewports, { x, y }); + } + let coordinate; + if (pickedViewport) { + const point = [x - pickedViewport.x, y - pickedViewport.y]; + if (z !== void 0) { + point[2] = z; + } + coordinate = pickedViewport.unproject(point); + } + return { + color: null, + layer: null, + viewport: pickedViewport, + index: -1, + picked: false, + x, + y, + pixel: [x, y], + coordinate, + devicePixel: pickInfo && "pickedX" in pickInfo ? [pickInfo.pickedX, pickInfo.pickedY] : void 0, + pixelRatio + }; +} +function processPickInfo(opts) { + const { pickInfo, lastPickedInfo, mode, layers } = opts; + const { pickedColor, pickedLayer, pickedObjectIndex } = pickInfo; + const affectedLayers = pickedLayer ? [pickedLayer] : []; + if (mode === "hover") { + const lastPickedPixelIndex = lastPickedInfo.index; + const lastPickedLayerId = lastPickedInfo.layerId; + const pickedLayerId = pickedLayer ? pickedLayer.props.id : null; + if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedPixelIndex) { + if (pickedLayerId !== lastPickedLayerId) { + const lastPickedLayer = layers.find((layer) => layer.props.id === lastPickedLayerId); + if (lastPickedLayer) { + affectedLayers.unshift(lastPickedLayer); + } + } + lastPickedInfo.layerId = pickedLayerId; + lastPickedInfo.index = pickedObjectIndex; + lastPickedInfo.info = null; + } + } + const baseInfo = getEmptyPickingInfo(opts); + const infos = /* @__PURE__ */ new Map(); + infos.set(null, baseInfo); + affectedLayers.forEach((layer) => { + let info = { ...baseInfo }; + if (layer === pickedLayer) { + info.color = pickedColor; + info.index = pickedObjectIndex; + info.picked = true; + } + info = getLayerPickingInfo({ layer, info, mode }); + const rootLayer = info.layer; + if (layer === pickedLayer && mode === "hover") { + lastPickedInfo.info = info; + } + infos.set(rootLayer.id, info); + if (mode === "hover") { + rootLayer.updateAutoHighlight(info); + } + }); + return infos; +} +function getLayerPickingInfo({ layer, info, mode }) { + while (layer && info) { + const sourceLayer = info.layer || null; + info.sourceLayer = sourceLayer; + info.layer = layer; + info = layer.getPickingInfo({ info, mode, sourceLayer }); + layer = layer.parent; + } + return info; +} +function getViewportFromCoordinates(viewports, pixel) { + for (let i = viewports.length - 1; i >= 0; i--) { + const viewport = viewports[i]; + if (viewport.containsPixel(pixel)) { + return viewport; + } + } + return viewports[0]; +} + +// node_modules/@deck.gl/core/dist/lib/deck-picker.js +var DeckPicker = class { + constructor(device) { + this._pickable = true; + this.device = device; + this.pickLayersPass = new PickLayersPass(device); + this.lastPickedInfo = { + index: -1, + layerId: null, + info: null + }; + } + setProps(props) { + if ("layerFilter" in props) { + this.layerFilter = props.layerFilter; + } + if ("_pickable" in props) { + this._pickable = props._pickable; + } + } + finalize() { + if (this.pickingFBO) { + this.pickingFBO.destroy(); + } + if (this.depthFBO) { + this.depthFBO.destroy(); + } + } + /** Pick the closest info at given coordinate */ + pickObject(opts) { + return this._pickClosestObject(opts); + } + /** Get all unique infos within a bounding box */ + pickObjects(opts) { + return this._pickVisibleObjects(opts); + } + // Returns a new picking info object by assuming the last picked object is still picked + getLastPickedObject({ x, y, layers, viewports }, lastPickedInfo = this.lastPickedInfo.info) { + const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id; + const lastPickedViewportId = lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id; + const layer = lastPickedLayerId ? layers.find((l) => l.id === lastPickedLayerId) : null; + const viewport = lastPickedViewportId && viewports.find((v) => v.id === lastPickedViewportId) || viewports[0]; + const coordinate = viewport && viewport.unproject([x - viewport.x, y - viewport.y]); + const info = { + x, + y, + viewport, + coordinate, + layer + }; + return { ...lastPickedInfo, ...info }; + } + // Private + /** Ensures that picking framebuffer exists and matches the canvas size */ + _resizeBuffer() { + if (!this.pickingFBO) { + this.pickingFBO = this.device.createFramebuffer({ + colorAttachments: ["rgba8unorm"], + depthStencilAttachment: "depth16unorm" + }); + if (this.device.isTextureFormatRenderable("rgba32float")) { + const depthFBO = this.device.createFramebuffer({ + colorAttachments: ["rgba32float"], + depthStencilAttachment: "depth16unorm" + }); + this.depthFBO = depthFBO; + } + } + const { canvas: canvas2 } = this.device.getCanvasContext(); + this.pickingFBO?.resize({ width: canvas2.width, height: canvas2.height }); + this.depthFBO?.resize({ width: canvas2.width, height: canvas2.height }); + } + /** Preliminary filtering of the layers list. Skid picking pass if no layer is pickable. */ + _getPickable(layers) { + if (this._pickable === false) { + return null; + } + const pickableLayers = layers.filter((layer) => this.pickLayersPass.shouldDrawLayer(layer) && !layer.isComposite); + return pickableLayers.length ? pickableLayers : null; + } + /** Pick the closest object at the given coordinate */ + // eslint-disable-next-line max-statements,complexity + _pickClosestObject({ layers, views, viewports, x, y, radius = 0, depth = 1, mode = "query", unproject3D, onViewportActive, effects }) { + const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); + const pickableLayers = this._getPickable(layers); + if (!pickableLayers || viewports.length === 0) { + return { + result: [], + emptyInfo: getEmptyPickingInfo({ viewports, x, y, pixelRatio }) + }; + } + this._resizeBuffer(); + const devicePixelRange = this.device.canvasContext.cssToDevicePixels([x, y], true); + const devicePixel = [ + devicePixelRange.x + Math.floor(devicePixelRange.width / 2), + devicePixelRange.y + Math.floor(devicePixelRange.height / 2) + ]; + const deviceRadius = Math.round(radius * pixelRatio); + const { width, height } = this.pickingFBO; + const deviceRect = this._getPickingRect({ + deviceX: devicePixel[0], + deviceY: devicePixel[1], + deviceRadius, + deviceWidth: width, + deviceHeight: height + }); + const cullRect = { + x: x - radius, + y: y - radius, + width: radius * 2 + 1, + height: radius * 2 + 1 + }; + let infos; + const result = []; + const affectedLayers = /* @__PURE__ */ new Set(); + for (let i = 0; i < depth; i++) { + let pickInfo; + if (deviceRect) { + const pickedResult = this._drawAndSample({ + layers: pickableLayers, + views, + viewports, + onViewportActive, + deviceRect, + cullRect, + effects, + pass: `picking:${mode}` + }); + pickInfo = getClosestObject({ + ...pickedResult, + deviceX: devicePixel[0], + deviceY: devicePixel[1], + deviceRadius, + deviceRect + }); + } else { + pickInfo = { + pickedColor: null, + pickedObjectIndex: -1 + }; + } + let z; + if (pickInfo.pickedLayer && unproject3D && this.depthFBO) { + const { pickedColors: pickedColors2 } = this._drawAndSample({ + layers: [pickInfo.pickedLayer], + views, + viewports, + onViewportActive, + deviceRect: { + x: pickInfo.pickedX, + y: pickInfo.pickedY, + width: 1, + height: 1 + }, + cullRect, + effects, + pass: `picking:${mode}:z` + }, true); + if (pickedColors2[3]) { + z = pickedColors2[0]; + } + } + if (pickInfo.pickedLayer && i + 1 < depth) { + affectedLayers.add(pickInfo.pickedLayer); + pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex); + } + infos = processPickInfo({ + pickInfo, + lastPickedInfo: this.lastPickedInfo, + mode, + layers: pickableLayers, + viewports, + x, + y, + z, + pixelRatio + }); + for (const info of infos.values()) { + if (info.layer) { + result.push(info); + } + } + if (!pickInfo.pickedColor) { + break; + } + } + for (const layer of affectedLayers) { + layer.restorePickingColors(); + } + return { result, emptyInfo: infos.get(null) }; + } + /** Pick all objects within the given bounding box */ + _pickVisibleObjects({ layers, views, viewports, x, y, width = 1, height = 1, mode = "query", maxObjects = null, onViewportActive, effects }) { + const pickableLayers = this._getPickable(layers); + if (!pickableLayers || viewports.length === 0) { + return []; + } + this._resizeBuffer(); + const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); + const leftTop = this.device.canvasContext.cssToDevicePixels([x, y], true); + const deviceLeft = leftTop.x; + const deviceTop = leftTop.y + leftTop.height; + const rightBottom = this.device.canvasContext.cssToDevicePixels([x + width, y + height], true); + const deviceRight = rightBottom.x + rightBottom.width; + const deviceBottom = rightBottom.y; + const deviceRect = { + x: deviceLeft, + y: deviceBottom, + // deviceTop and deviceRight represent the first pixel outside the desired rect + width: deviceRight - deviceLeft, + height: deviceTop - deviceBottom + }; + const pickedResult = this._drawAndSample({ + layers: pickableLayers, + views, + viewports, + onViewportActive, + deviceRect, + cullRect: { x, y, width, height }, + effects, + pass: `picking:${mode}` + }); + const pickInfos = getUniqueObjects(pickedResult); + const uniquePickedObjects = /* @__PURE__ */ new Map(); + const uniqueInfos = []; + const limitMaxObjects = Number.isFinite(maxObjects); + for (let i = 0; i < pickInfos.length; i++) { + if (limitMaxObjects && uniqueInfos.length >= maxObjects) { + break; + } + const pickInfo = pickInfos[i]; + let info = { + color: pickInfo.pickedColor, + layer: null, + index: pickInfo.pickedObjectIndex, + picked: true, + x, + y, + pixelRatio + }; + info = getLayerPickingInfo({ layer: pickInfo.pickedLayer, info, mode }); + const pickedLayerId = info.layer.id; + if (!uniquePickedObjects.has(pickedLayerId)) { + uniquePickedObjects.set(pickedLayerId, /* @__PURE__ */ new Set()); + } + const uniqueObjectsInLayer = uniquePickedObjects.get(pickedLayerId); + const pickedObjectKey = info.object ?? info.index; + if (!uniqueObjectsInLayer.has(pickedObjectKey)) { + uniqueObjectsInLayer.add(pickedObjectKey); + uniqueInfos.push(info); + } + } + return uniqueInfos; + } + _drawAndSample({ layers, views, viewports, onViewportActive, deviceRect, cullRect, effects, pass }, pickZ = false) { + const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO; + const opts = { + layers, + layerFilter: this.layerFilter, + views, + viewports, + onViewportActive, + pickingFBO, + deviceRect, + cullRect, + effects, + pass, + pickZ, + preRenderStats: {} + }; + for (const effect of effects) { + if (effect.useInPicking) { + opts.preRenderStats[effect.id] = effect.preRender(opts); + } + } + const { decodePickingColor } = this.pickLayersPass.render(opts); + const { x, y, width, height } = deviceRect; + const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4); + this.device.readPixelsToArrayWebGL(pickingFBO, { + sourceX: x, + sourceY: y, + sourceWidth: width, + sourceHeight: height, + target: pickedColors + }); + return { pickedColors, decodePickingColor }; + } + // Calculate a picking rect centered on deviceX and deviceY and clipped to device + // Returns null if pixel is outside of device + _getPickingRect({ deviceX, deviceY, deviceRadius, deviceWidth, deviceHeight }) { + const x = Math.max(0, deviceX - deviceRadius); + const y = Math.max(0, deviceY - deviceRadius); + const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x; + const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y; + if (width <= 0 || height <= 0) { + return null; + } + return { x, y, width, height }; + } +}; + +// node_modules/@deck.gl/core/dist/lib/widget-manager.js +var PLACEMENTS = { + "top-left": { top: 0, left: 0 }, + "top-right": { top: 0, right: 0 }, + "bottom-left": { bottom: 0, left: 0 }, + "bottom-right": { bottom: 0, right: 0 }, + fill: { top: 0, left: 0, bottom: 0, right: 0 } +}; +var DEFAULT_PLACEMENT = "top-left"; +var ROOT_CONTAINER_ID = "__root"; +var WidgetManager = class { + constructor({ deck, parentElement }) { + this.defaultWidgets = []; + this.widgets = []; + this.resolvedWidgets = []; + this.containers = {}; + this.lastViewports = {}; + this.deck = deck; + this.parentElement = parentElement; + } + getWidgets() { + return this.resolvedWidgets; + } + /** Declarative API to configure widgets */ + setProps(props) { + if (props.widgets && !deepEqual2(props.widgets, this.widgets, 1)) { + this._setWidgets(props.widgets); + } + } + finalize() { + for (const widget of this.getWidgets()) { + this._remove(widget); + } + this.defaultWidgets.length = 0; + this.resolvedWidgets.length = 0; + for (const id in this.containers) { + this.containers[id].remove(); + } + } + /** Imperative API. Widgets added this way are not affected by the declarative prop. */ + addDefault(widget) { + if (!this.defaultWidgets.find((w) => w.id === widget.id)) { + this._add(widget); + this.defaultWidgets.push(widget); + this._setWidgets(this.widgets); + } + } + /** Resolve widgets from the declarative prop */ + _setWidgets(nextWidgets) { + const oldWidgetMap = {}; + for (const widget of this.resolvedWidgets) { + oldWidgetMap[widget.id] = widget; + } + this.resolvedWidgets.length = 0; + for (const widget of this.defaultWidgets) { + oldWidgetMap[widget.id] = null; + this.resolvedWidgets.push(widget); + } + for (let widget of nextWidgets) { + const oldWidget = oldWidgetMap[widget.id]; + if (!oldWidget) { + this._add(widget); + } else if ( + // Widget placement changed + oldWidget.viewId !== widget.viewId || oldWidget.placement !== widget.placement + ) { + this._remove(oldWidget); + this._add(widget); + } else if (widget !== oldWidget) { + oldWidget.setProps(widget.props); + widget = oldWidget; + } + oldWidgetMap[widget.id] = null; + this.resolvedWidgets.push(widget); + } + for (const id in oldWidgetMap) { + const oldWidget = oldWidgetMap[id]; + if (oldWidget) { + this._remove(oldWidget); + } + } + this.widgets = nextWidgets; + } + _add(widget) { + const { viewId = null, placement = DEFAULT_PLACEMENT } = widget; + const element = widget.onAdd({ deck: this.deck, viewId }); + if (element) { + this._getContainer(viewId, placement).append(element); + } + widget._element = element; + } + _remove(widget) { + widget.onRemove(); + if (widget._element) { + widget._element.remove(); + } + widget._element = void 0; + } + /* global document */ + _getContainer(viewId, placement) { + const containerId = viewId || ROOT_CONTAINER_ID; + let viewContainer = this.containers[containerId]; + if (!viewContainer) { + viewContainer = document.createElement("div"); + viewContainer.style.pointerEvents = "none"; + viewContainer.style.position = "absolute"; + viewContainer.style.overflow = "hidden"; + this.parentElement?.append(viewContainer); + this.containers[containerId] = viewContainer; + } + let container = viewContainer.querySelector(`.${placement}`); + if (!container) { + container = document.createElement("div"); + container.className = placement; + container.style.position = "absolute"; + container.style.zIndex = "2"; + Object.assign(container.style, PLACEMENTS[placement]); + viewContainer.append(container); + } + return container; + } + _updateContainers() { + const canvasWidth = this.deck.width; + const canvasHeight = this.deck.height; + for (const id in this.containers) { + const viewport = this.lastViewports[id] || null; + const visible = id === ROOT_CONTAINER_ID || viewport; + const container = this.containers[id]; + if (visible) { + container.style.display = "block"; + container.style.left = `${viewport ? viewport.x : 0}px`; + container.style.top = `${viewport ? viewport.y : 0}px`; + container.style.width = `${viewport ? viewport.width : canvasWidth}px`; + container.style.height = `${viewport ? viewport.height : canvasHeight}px`; + } else { + container.style.display = "none"; + } + } + } + onRedraw({ viewports, layers }) { + const viewportsById = viewports.reduce((acc, v) => { + acc[v.id] = v; + return acc; + }, {}); + const { lastViewports } = this; + for (const widget of this.getWidgets()) { + const { viewId } = widget; + if (viewId) { + const viewport = viewportsById[viewId]; + if (viewport) { + if (widget.onViewportChange && !viewport.equals(lastViewports[viewId])) { + widget.onViewportChange(viewport); + } + widget.onRedraw?.({ viewports: [viewport], layers }); + } + } else { + if (widget.onViewportChange) { + for (const viewport of viewports) { + if (!viewport.equals(lastViewports[viewport.id])) { + widget.onViewportChange(viewport); + } + } + } + widget.onRedraw?.({ viewports, layers }); + } + } + this.lastViewports = viewportsById; + this._updateContainers(); + } + onHover(info, event) { + for (const widget of this.getWidgets()) { + const { viewId } = widget; + if (!viewId || viewId === info.viewport?.id) { + widget.onHover?.(info, event); + } + } + } + onEvent(info, event) { + const eventOptions = EVENTS[event.type]; + if (!eventOptions) { + return; + } + for (const widget of this.getWidgets()) { + const { viewId } = widget; + if (!viewId || viewId === info.viewport?.id) { + widget[eventOptions.handler]?.(info, event); + } + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/tooltip.js +var defaultStyle = { + zIndex: "1", + position: "absolute", + pointerEvents: "none", + color: "#a0a7b4", + backgroundColor: "#29323c", + padding: "10px", + top: "0", + left: "0", + display: "none" +}; +var Tooltip = class { + constructor() { + this.id = "default-tooltip"; + this.placement = "fill"; + this.props = {}; + this.isVisible = false; + } + onAdd({ deck }) { + const el = document.createElement("div"); + el.className = "deck-tooltip"; + Object.assign(el.style, defaultStyle); + this.deck = deck; + this.element = el; + return el; + } + onRemove() { + this.deck = void 0; + this.element = void 0; + } + setProps() { + } + onViewportChange(viewport) { + if (this.isVisible && viewport.id === this.lastViewport?.id && viewport !== this.lastViewport) { + this.setTooltip(null); + } + } + onHover(info) { + const { deck } = this; + const getTooltip = deck && deck.props.getTooltip; + if (!getTooltip) { + return; + } + const displayInfo = getTooltip(info); + this.lastViewport = info.viewport; + this.setTooltip(displayInfo, info.x, info.y); + } + setTooltip(displayInfo, x, y) { + const el = this.element; + if (!el) { + return; + } + if (typeof displayInfo === "string") { + el.innerText = displayInfo; + } else if (!displayInfo) { + this.isVisible = false; + el.style.display = "none"; + return; + } else { + if (displayInfo.text) { + el.innerText = displayInfo.text; + } + if (displayInfo.html) { + el.innerHTML = displayInfo.html; + } + if (displayInfo.className) { + el.className = displayInfo.className; + } + } + this.isVisible = true; + el.style.display = "block"; + el.style.transform = `translate(${x}px, ${y}px)`; + if (displayInfo && typeof displayInfo === "object" && "style" in displayInfo) { + Object.assign(el.style, displayInfo.style); + } + } +}; + +// node_modules/@luma.gl/constants/dist/webgl-constants.js +var GLEnum; +(function(GLEnum2) { + GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT"; + GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT"; + GLEnum2[GLEnum2["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT"; + GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS"; + GLEnum2[GLEnum2["LINES"] = 1] = "LINES"; + GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP"; + GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP"; + GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES"; + GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP"; + GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN"; + GLEnum2[GLEnum2["ZERO"] = 0] = "ZERO"; + GLEnum2[GLEnum2["ONE"] = 1] = "ONE"; + GLEnum2[GLEnum2["SRC_COLOR"] = 768] = "SRC_COLOR"; + GLEnum2[GLEnum2["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR"; + GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA"; + GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA"; + GLEnum2[GLEnum2["DST_ALPHA"] = 772] = "DST_ALPHA"; + GLEnum2[GLEnum2["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA"; + GLEnum2[GLEnum2["DST_COLOR"] = 774] = "DST_COLOR"; + GLEnum2[GLEnum2["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR"; + GLEnum2[GLEnum2["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE"; + GLEnum2[GLEnum2["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR"; + GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR"; + GLEnum2[GLEnum2["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA"; + GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA"; + GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD"; + GLEnum2[GLEnum2["FUNC_SUBTRACT"] = 32778] = "FUNC_SUBTRACT"; + GLEnum2[GLEnum2["FUNC_REVERSE_SUBTRACT"] = 32779] = "FUNC_REVERSE_SUBTRACT"; + GLEnum2[GLEnum2["BLEND_EQUATION"] = 32777] = "BLEND_EQUATION"; + GLEnum2[GLEnum2["BLEND_EQUATION_RGB"] = 32777] = "BLEND_EQUATION_RGB"; + GLEnum2[GLEnum2["BLEND_EQUATION_ALPHA"] = 34877] = "BLEND_EQUATION_ALPHA"; + GLEnum2[GLEnum2["BLEND_DST_RGB"] = 32968] = "BLEND_DST_RGB"; + GLEnum2[GLEnum2["BLEND_SRC_RGB"] = 32969] = "BLEND_SRC_RGB"; + GLEnum2[GLEnum2["BLEND_DST_ALPHA"] = 32970] = "BLEND_DST_ALPHA"; + GLEnum2[GLEnum2["BLEND_SRC_ALPHA"] = 32971] = "BLEND_SRC_ALPHA"; + GLEnum2[GLEnum2["BLEND_COLOR"] = 32773] = "BLEND_COLOR"; + GLEnum2[GLEnum2["ARRAY_BUFFER_BINDING"] = 34964] = "ARRAY_BUFFER_BINDING"; + GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER_BINDING"] = 34965] = "ELEMENT_ARRAY_BUFFER_BINDING"; + GLEnum2[GLEnum2["LINE_WIDTH"] = 2849] = "LINE_WIDTH"; + GLEnum2[GLEnum2["ALIASED_POINT_SIZE_RANGE"] = 33901] = "ALIASED_POINT_SIZE_RANGE"; + GLEnum2[GLEnum2["ALIASED_LINE_WIDTH_RANGE"] = 33902] = "ALIASED_LINE_WIDTH_RANGE"; + GLEnum2[GLEnum2["CULL_FACE_MODE"] = 2885] = "CULL_FACE_MODE"; + GLEnum2[GLEnum2["FRONT_FACE"] = 2886] = "FRONT_FACE"; + GLEnum2[GLEnum2["DEPTH_RANGE"] = 2928] = "DEPTH_RANGE"; + GLEnum2[GLEnum2["DEPTH_WRITEMASK"] = 2930] = "DEPTH_WRITEMASK"; + GLEnum2[GLEnum2["DEPTH_CLEAR_VALUE"] = 2931] = "DEPTH_CLEAR_VALUE"; + GLEnum2[GLEnum2["DEPTH_FUNC"] = 2932] = "DEPTH_FUNC"; + GLEnum2[GLEnum2["STENCIL_CLEAR_VALUE"] = 2961] = "STENCIL_CLEAR_VALUE"; + GLEnum2[GLEnum2["STENCIL_FUNC"] = 2962] = "STENCIL_FUNC"; + GLEnum2[GLEnum2["STENCIL_FAIL"] = 2964] = "STENCIL_FAIL"; + GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_FAIL"] = 2965] = "STENCIL_PASS_DEPTH_FAIL"; + GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_PASS"] = 2966] = "STENCIL_PASS_DEPTH_PASS"; + GLEnum2[GLEnum2["STENCIL_REF"] = 2967] = "STENCIL_REF"; + GLEnum2[GLEnum2["STENCIL_VALUE_MASK"] = 2963] = "STENCIL_VALUE_MASK"; + GLEnum2[GLEnum2["STENCIL_WRITEMASK"] = 2968] = "STENCIL_WRITEMASK"; + GLEnum2[GLEnum2["STENCIL_BACK_FUNC"] = 34816] = "STENCIL_BACK_FUNC"; + GLEnum2[GLEnum2["STENCIL_BACK_FAIL"] = 34817] = "STENCIL_BACK_FAIL"; + GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_FAIL"] = 34818] = "STENCIL_BACK_PASS_DEPTH_FAIL"; + GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_PASS"] = 34819] = "STENCIL_BACK_PASS_DEPTH_PASS"; + GLEnum2[GLEnum2["STENCIL_BACK_REF"] = 36003] = "STENCIL_BACK_REF"; + GLEnum2[GLEnum2["STENCIL_BACK_VALUE_MASK"] = 36004] = "STENCIL_BACK_VALUE_MASK"; + GLEnum2[GLEnum2["STENCIL_BACK_WRITEMASK"] = 36005] = "STENCIL_BACK_WRITEMASK"; + GLEnum2[GLEnum2["VIEWPORT"] = 2978] = "VIEWPORT"; + GLEnum2[GLEnum2["SCISSOR_BOX"] = 3088] = "SCISSOR_BOX"; + GLEnum2[GLEnum2["COLOR_CLEAR_VALUE"] = 3106] = "COLOR_CLEAR_VALUE"; + GLEnum2[GLEnum2["COLOR_WRITEMASK"] = 3107] = "COLOR_WRITEMASK"; + GLEnum2[GLEnum2["UNPACK_ALIGNMENT"] = 3317] = "UNPACK_ALIGNMENT"; + GLEnum2[GLEnum2["PACK_ALIGNMENT"] = 3333] = "PACK_ALIGNMENT"; + GLEnum2[GLEnum2["MAX_TEXTURE_SIZE"] = 3379] = "MAX_TEXTURE_SIZE"; + GLEnum2[GLEnum2["MAX_VIEWPORT_DIMS"] = 3386] = "MAX_VIEWPORT_DIMS"; + GLEnum2[GLEnum2["SUBPIXEL_BITS"] = 3408] = "SUBPIXEL_BITS"; + GLEnum2[GLEnum2["RED_BITS"] = 3410] = "RED_BITS"; + GLEnum2[GLEnum2["GREEN_BITS"] = 3411] = "GREEN_BITS"; + GLEnum2[GLEnum2["BLUE_BITS"] = 3412] = "BLUE_BITS"; + GLEnum2[GLEnum2["ALPHA_BITS"] = 3413] = "ALPHA_BITS"; + GLEnum2[GLEnum2["DEPTH_BITS"] = 3414] = "DEPTH_BITS"; + GLEnum2[GLEnum2["STENCIL_BITS"] = 3415] = "STENCIL_BITS"; + GLEnum2[GLEnum2["POLYGON_OFFSET_UNITS"] = 10752] = "POLYGON_OFFSET_UNITS"; + GLEnum2[GLEnum2["POLYGON_OFFSET_FACTOR"] = 32824] = "POLYGON_OFFSET_FACTOR"; + GLEnum2[GLEnum2["TEXTURE_BINDING_2D"] = 32873] = "TEXTURE_BINDING_2D"; + GLEnum2[GLEnum2["SAMPLE_BUFFERS"] = 32936] = "SAMPLE_BUFFERS"; + GLEnum2[GLEnum2["SAMPLES"] = 32937] = "SAMPLES"; + GLEnum2[GLEnum2["SAMPLE_COVERAGE_VALUE"] = 32938] = "SAMPLE_COVERAGE_VALUE"; + GLEnum2[GLEnum2["SAMPLE_COVERAGE_INVERT"] = 32939] = "SAMPLE_COVERAGE_INVERT"; + GLEnum2[GLEnum2["COMPRESSED_TEXTURE_FORMATS"] = 34467] = "COMPRESSED_TEXTURE_FORMATS"; + GLEnum2[GLEnum2["VENDOR"] = 7936] = "VENDOR"; + GLEnum2[GLEnum2["RENDERER"] = 7937] = "RENDERER"; + GLEnum2[GLEnum2["VERSION"] = 7938] = "VERSION"; + GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_TYPE"] = 35738] = "IMPLEMENTATION_COLOR_READ_TYPE"; + GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_FORMAT"] = 35739] = "IMPLEMENTATION_COLOR_READ_FORMAT"; + GLEnum2[GLEnum2["BROWSER_DEFAULT_WEBGL"] = 37444] = "BROWSER_DEFAULT_WEBGL"; + GLEnum2[GLEnum2["STATIC_DRAW"] = 35044] = "STATIC_DRAW"; + GLEnum2[GLEnum2["STREAM_DRAW"] = 35040] = "STREAM_DRAW"; + GLEnum2[GLEnum2["DYNAMIC_DRAW"] = 35048] = "DYNAMIC_DRAW"; + GLEnum2[GLEnum2["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER"; + GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER"; + GLEnum2[GLEnum2["BUFFER_SIZE"] = 34660] = "BUFFER_SIZE"; + GLEnum2[GLEnum2["BUFFER_USAGE"] = 34661] = "BUFFER_USAGE"; + GLEnum2[GLEnum2["CURRENT_VERTEX_ATTRIB"] = 34342] = "CURRENT_VERTEX_ATTRIB"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_ENABLED"] = 34338] = "VERTEX_ATTRIB_ARRAY_ENABLED"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_SIZE"] = 34339] = "VERTEX_ATTRIB_ARRAY_SIZE"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_STRIDE"] = 34340] = "VERTEX_ATTRIB_ARRAY_STRIDE"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_TYPE"] = 34341] = "VERTEX_ATTRIB_ARRAY_TYPE"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_NORMALIZED"] = 34922] = "VERTEX_ATTRIB_ARRAY_NORMALIZED"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_POINTER"] = 34373] = "VERTEX_ATTRIB_ARRAY_POINTER"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"] = 34975] = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + GLEnum2[GLEnum2["CULL_FACE"] = 2884] = "CULL_FACE"; + GLEnum2[GLEnum2["FRONT"] = 1028] = "FRONT"; + GLEnum2[GLEnum2["BACK"] = 1029] = "BACK"; + GLEnum2[GLEnum2["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK"; + GLEnum2[GLEnum2["BLEND"] = 3042] = "BLEND"; + GLEnum2[GLEnum2["DEPTH_TEST"] = 2929] = "DEPTH_TEST"; + GLEnum2[GLEnum2["DITHER"] = 3024] = "DITHER"; + GLEnum2[GLEnum2["POLYGON_OFFSET_FILL"] = 32823] = "POLYGON_OFFSET_FILL"; + GLEnum2[GLEnum2["SAMPLE_ALPHA_TO_COVERAGE"] = 32926] = "SAMPLE_ALPHA_TO_COVERAGE"; + GLEnum2[GLEnum2["SAMPLE_COVERAGE"] = 32928] = "SAMPLE_COVERAGE"; + GLEnum2[GLEnum2["SCISSOR_TEST"] = 3089] = "SCISSOR_TEST"; + GLEnum2[GLEnum2["STENCIL_TEST"] = 2960] = "STENCIL_TEST"; + GLEnum2[GLEnum2["NO_ERROR"] = 0] = "NO_ERROR"; + GLEnum2[GLEnum2["INVALID_ENUM"] = 1280] = "INVALID_ENUM"; + GLEnum2[GLEnum2["INVALID_VALUE"] = 1281] = "INVALID_VALUE"; + GLEnum2[GLEnum2["INVALID_OPERATION"] = 1282] = "INVALID_OPERATION"; + GLEnum2[GLEnum2["OUT_OF_MEMORY"] = 1285] = "OUT_OF_MEMORY"; + GLEnum2[GLEnum2["CONTEXT_LOST_WEBGL"] = 37442] = "CONTEXT_LOST_WEBGL"; + GLEnum2[GLEnum2["CW"] = 2304] = "CW"; + GLEnum2[GLEnum2["CCW"] = 2305] = "CCW"; + GLEnum2[GLEnum2["DONT_CARE"] = 4352] = "DONT_CARE"; + GLEnum2[GLEnum2["FASTEST"] = 4353] = "FASTEST"; + GLEnum2[GLEnum2["NICEST"] = 4354] = "NICEST"; + GLEnum2[GLEnum2["GENERATE_MIPMAP_HINT"] = 33170] = "GENERATE_MIPMAP_HINT"; + GLEnum2[GLEnum2["BYTE"] = 5120] = "BYTE"; + GLEnum2[GLEnum2["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE"; + GLEnum2[GLEnum2["SHORT"] = 5122] = "SHORT"; + GLEnum2[GLEnum2["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT"; + GLEnum2[GLEnum2["INT"] = 5124] = "INT"; + GLEnum2[GLEnum2["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT"; + GLEnum2[GLEnum2["FLOAT"] = 5126] = "FLOAT"; + GLEnum2[GLEnum2["DOUBLE"] = 5130] = "DOUBLE"; + GLEnum2[GLEnum2["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT"; + GLEnum2[GLEnum2["ALPHA"] = 6406] = "ALPHA"; + GLEnum2[GLEnum2["RGB"] = 6407] = "RGB"; + GLEnum2[GLEnum2["RGBA"] = 6408] = "RGBA"; + GLEnum2[GLEnum2["LUMINANCE"] = 6409] = "LUMINANCE"; + GLEnum2[GLEnum2["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA"; + GLEnum2[GLEnum2["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4"; + GLEnum2[GLEnum2["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1"; + GLEnum2[GLEnum2["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5"; + GLEnum2[GLEnum2["FRAGMENT_SHADER"] = 35632] = "FRAGMENT_SHADER"; + GLEnum2[GLEnum2["VERTEX_SHADER"] = 35633] = "VERTEX_SHADER"; + GLEnum2[GLEnum2["COMPILE_STATUS"] = 35713] = "COMPILE_STATUS"; + GLEnum2[GLEnum2["DELETE_STATUS"] = 35712] = "DELETE_STATUS"; + GLEnum2[GLEnum2["LINK_STATUS"] = 35714] = "LINK_STATUS"; + GLEnum2[GLEnum2["VALIDATE_STATUS"] = 35715] = "VALIDATE_STATUS"; + GLEnum2[GLEnum2["ATTACHED_SHADERS"] = 35717] = "ATTACHED_SHADERS"; + GLEnum2[GLEnum2["ACTIVE_ATTRIBUTES"] = 35721] = "ACTIVE_ATTRIBUTES"; + GLEnum2[GLEnum2["ACTIVE_UNIFORMS"] = 35718] = "ACTIVE_UNIFORMS"; + GLEnum2[GLEnum2["MAX_VERTEX_ATTRIBS"] = 34921] = "MAX_VERTEX_ATTRIBS"; + GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_VECTORS"] = 36347] = "MAX_VERTEX_UNIFORM_VECTORS"; + GLEnum2[GLEnum2["MAX_VARYING_VECTORS"] = 36348] = "MAX_VARYING_VECTORS"; + GLEnum2[GLEnum2["MAX_COMBINED_TEXTURE_IMAGE_UNITS"] = 35661] = "MAX_COMBINED_TEXTURE_IMAGE_UNITS"; + GLEnum2[GLEnum2["MAX_VERTEX_TEXTURE_IMAGE_UNITS"] = 35660] = "MAX_VERTEX_TEXTURE_IMAGE_UNITS"; + GLEnum2[GLEnum2["MAX_TEXTURE_IMAGE_UNITS"] = 34930] = "MAX_TEXTURE_IMAGE_UNITS"; + GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_VECTORS"] = 36349] = "MAX_FRAGMENT_UNIFORM_VECTORS"; + GLEnum2[GLEnum2["SHADER_TYPE"] = 35663] = "SHADER_TYPE"; + GLEnum2[GLEnum2["SHADING_LANGUAGE_VERSION"] = 35724] = "SHADING_LANGUAGE_VERSION"; + GLEnum2[GLEnum2["CURRENT_PROGRAM"] = 35725] = "CURRENT_PROGRAM"; + GLEnum2[GLEnum2["NEVER"] = 512] = "NEVER"; + GLEnum2[GLEnum2["LESS"] = 513] = "LESS"; + GLEnum2[GLEnum2["EQUAL"] = 514] = "EQUAL"; + GLEnum2[GLEnum2["LEQUAL"] = 515] = "LEQUAL"; + GLEnum2[GLEnum2["GREATER"] = 516] = "GREATER"; + GLEnum2[GLEnum2["NOTEQUAL"] = 517] = "NOTEQUAL"; + GLEnum2[GLEnum2["GEQUAL"] = 518] = "GEQUAL"; + GLEnum2[GLEnum2["ALWAYS"] = 519] = "ALWAYS"; + GLEnum2[GLEnum2["KEEP"] = 7680] = "KEEP"; + GLEnum2[GLEnum2["REPLACE"] = 7681] = "REPLACE"; + GLEnum2[GLEnum2["INCR"] = 7682] = "INCR"; + GLEnum2[GLEnum2["DECR"] = 7683] = "DECR"; + GLEnum2[GLEnum2["INVERT"] = 5386] = "INVERT"; + GLEnum2[GLEnum2["INCR_WRAP"] = 34055] = "INCR_WRAP"; + GLEnum2[GLEnum2["DECR_WRAP"] = 34056] = "DECR_WRAP"; + GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST"; + GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR"; + GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST"; + GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST"; + GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR"; + GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR"; + GLEnum2[GLEnum2["TEXTURE_MAG_FILTER"] = 10240] = "TEXTURE_MAG_FILTER"; + GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER"; + GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S"; + GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T"; + GLEnum2[GLEnum2["TEXTURE_2D"] = 3553] = "TEXTURE_2D"; + GLEnum2[GLEnum2["TEXTURE"] = 5890] = "TEXTURE"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP"; + GLEnum2[GLEnum2["TEXTURE_BINDING_CUBE_MAP"] = 34068] = "TEXTURE_BINDING_CUBE_MAP"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z"; + GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z"; + GLEnum2[GLEnum2["MAX_CUBE_MAP_TEXTURE_SIZE"] = 34076] = "MAX_CUBE_MAP_TEXTURE_SIZE"; + GLEnum2[GLEnum2["TEXTURE0"] = 33984] = "TEXTURE0"; + GLEnum2[GLEnum2["ACTIVE_TEXTURE"] = 34016] = "ACTIVE_TEXTURE"; + GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT"; + GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE"; + GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT"; + GLEnum2[GLEnum2["TEXTURE_WIDTH"] = 4096] = "TEXTURE_WIDTH"; + GLEnum2[GLEnum2["TEXTURE_HEIGHT"] = 4097] = "TEXTURE_HEIGHT"; + GLEnum2[GLEnum2["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2"; + GLEnum2[GLEnum2["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3"; + GLEnum2[GLEnum2["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4"; + GLEnum2[GLEnum2["INT_VEC2"] = 35667] = "INT_VEC2"; + GLEnum2[GLEnum2["INT_VEC3"] = 35668] = "INT_VEC3"; + GLEnum2[GLEnum2["INT_VEC4"] = 35669] = "INT_VEC4"; + GLEnum2[GLEnum2["BOOL"] = 35670] = "BOOL"; + GLEnum2[GLEnum2["BOOL_VEC2"] = 35671] = "BOOL_VEC2"; + GLEnum2[GLEnum2["BOOL_VEC3"] = 35672] = "BOOL_VEC3"; + GLEnum2[GLEnum2["BOOL_VEC4"] = 35673] = "BOOL_VEC4"; + GLEnum2[GLEnum2["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2"; + GLEnum2[GLEnum2["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3"; + GLEnum2[GLEnum2["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4"; + GLEnum2[GLEnum2["SAMPLER_2D"] = 35678] = "SAMPLER_2D"; + GLEnum2[GLEnum2["SAMPLER_CUBE"] = 35680] = "SAMPLER_CUBE"; + GLEnum2[GLEnum2["LOW_FLOAT"] = 36336] = "LOW_FLOAT"; + GLEnum2[GLEnum2["MEDIUM_FLOAT"] = 36337] = "MEDIUM_FLOAT"; + GLEnum2[GLEnum2["HIGH_FLOAT"] = 36338] = "HIGH_FLOAT"; + GLEnum2[GLEnum2["LOW_INT"] = 36339] = "LOW_INT"; + GLEnum2[GLEnum2["MEDIUM_INT"] = 36340] = "MEDIUM_INT"; + GLEnum2[GLEnum2["HIGH_INT"] = 36341] = "HIGH_INT"; + GLEnum2[GLEnum2["FRAMEBUFFER"] = 36160] = "FRAMEBUFFER"; + GLEnum2[GLEnum2["RENDERBUFFER"] = 36161] = "RENDERBUFFER"; + GLEnum2[GLEnum2["RGBA4"] = 32854] = "RGBA4"; + GLEnum2[GLEnum2["RGB5_A1"] = 32855] = "RGB5_A1"; + GLEnum2[GLEnum2["RGB565"] = 36194] = "RGB565"; + GLEnum2[GLEnum2["DEPTH_COMPONENT16"] = 33189] = "DEPTH_COMPONENT16"; + GLEnum2[GLEnum2["STENCIL_INDEX"] = 6401] = "STENCIL_INDEX"; + GLEnum2[GLEnum2["STENCIL_INDEX8"] = 36168] = "STENCIL_INDEX8"; + GLEnum2[GLEnum2["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL"; + GLEnum2[GLEnum2["RENDERBUFFER_WIDTH"] = 36162] = "RENDERBUFFER_WIDTH"; + GLEnum2[GLEnum2["RENDERBUFFER_HEIGHT"] = 36163] = "RENDERBUFFER_HEIGHT"; + GLEnum2[GLEnum2["RENDERBUFFER_INTERNAL_FORMAT"] = 36164] = "RENDERBUFFER_INTERNAL_FORMAT"; + GLEnum2[GLEnum2["RENDERBUFFER_RED_SIZE"] = 36176] = "RENDERBUFFER_RED_SIZE"; + GLEnum2[GLEnum2["RENDERBUFFER_GREEN_SIZE"] = 36177] = "RENDERBUFFER_GREEN_SIZE"; + GLEnum2[GLEnum2["RENDERBUFFER_BLUE_SIZE"] = 36178] = "RENDERBUFFER_BLUE_SIZE"; + GLEnum2[GLEnum2["RENDERBUFFER_ALPHA_SIZE"] = 36179] = "RENDERBUFFER_ALPHA_SIZE"; + GLEnum2[GLEnum2["RENDERBUFFER_DEPTH_SIZE"] = 36180] = "RENDERBUFFER_DEPTH_SIZE"; + GLEnum2[GLEnum2["RENDERBUFFER_STENCIL_SIZE"] = 36181] = "RENDERBUFFER_STENCIL_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"] = 36048] = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"] = 36049] = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"] = 36050] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"] = 36051] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT0"] = 36064] = "COLOR_ATTACHMENT0"; + GLEnum2[GLEnum2["DEPTH_ATTACHMENT"] = 36096] = "DEPTH_ATTACHMENT"; + GLEnum2[GLEnum2["STENCIL_ATTACHMENT"] = 36128] = "STENCIL_ATTACHMENT"; + GLEnum2[GLEnum2["DEPTH_STENCIL_ATTACHMENT"] = 33306] = "DEPTH_STENCIL_ATTACHMENT"; + GLEnum2[GLEnum2["NONE"] = 0] = "NONE"; + GLEnum2[GLEnum2["FRAMEBUFFER_COMPLETE"] = 36053] = "FRAMEBUFFER_COMPLETE"; + GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_ATTACHMENT"] = 36054] = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; + GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"] = 36055] = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; + GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_DIMENSIONS"] = 36057] = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"; + GLEnum2[GLEnum2["FRAMEBUFFER_UNSUPPORTED"] = 36061] = "FRAMEBUFFER_UNSUPPORTED"; + GLEnum2[GLEnum2["FRAMEBUFFER_BINDING"] = 36006] = "FRAMEBUFFER_BINDING"; + GLEnum2[GLEnum2["RENDERBUFFER_BINDING"] = 36007] = "RENDERBUFFER_BINDING"; + GLEnum2[GLEnum2["READ_FRAMEBUFFER"] = 36008] = "READ_FRAMEBUFFER"; + GLEnum2[GLEnum2["DRAW_FRAMEBUFFER"] = 36009] = "DRAW_FRAMEBUFFER"; + GLEnum2[GLEnum2["MAX_RENDERBUFFER_SIZE"] = 34024] = "MAX_RENDERBUFFER_SIZE"; + GLEnum2[GLEnum2["INVALID_FRAMEBUFFER_OPERATION"] = 1286] = "INVALID_FRAMEBUFFER_OPERATION"; + GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL"; + GLEnum2[GLEnum2["UNPACK_PREMULTIPLY_ALPHA_WEBGL"] = 37441] = "UNPACK_PREMULTIPLY_ALPHA_WEBGL"; + GLEnum2[GLEnum2["UNPACK_COLORSPACE_CONVERSION_WEBGL"] = 37443] = "UNPACK_COLORSPACE_CONVERSION_WEBGL"; + GLEnum2[GLEnum2["READ_BUFFER"] = 3074] = "READ_BUFFER"; + GLEnum2[GLEnum2["UNPACK_ROW_LENGTH"] = 3314] = "UNPACK_ROW_LENGTH"; + GLEnum2[GLEnum2["UNPACK_SKIP_ROWS"] = 3315] = "UNPACK_SKIP_ROWS"; + GLEnum2[GLEnum2["UNPACK_SKIP_PIXELS"] = 3316] = "UNPACK_SKIP_PIXELS"; + GLEnum2[GLEnum2["PACK_ROW_LENGTH"] = 3330] = "PACK_ROW_LENGTH"; + GLEnum2[GLEnum2["PACK_SKIP_ROWS"] = 3331] = "PACK_SKIP_ROWS"; + GLEnum2[GLEnum2["PACK_SKIP_PIXELS"] = 3332] = "PACK_SKIP_PIXELS"; + GLEnum2[GLEnum2["TEXTURE_BINDING_3D"] = 32874] = "TEXTURE_BINDING_3D"; + GLEnum2[GLEnum2["UNPACK_SKIP_IMAGES"] = 32877] = "UNPACK_SKIP_IMAGES"; + GLEnum2[GLEnum2["UNPACK_IMAGE_HEIGHT"] = 32878] = "UNPACK_IMAGE_HEIGHT"; + GLEnum2[GLEnum2["MAX_3D_TEXTURE_SIZE"] = 32883] = "MAX_3D_TEXTURE_SIZE"; + GLEnum2[GLEnum2["MAX_ELEMENTS_VERTICES"] = 33e3] = "MAX_ELEMENTS_VERTICES"; + GLEnum2[GLEnum2["MAX_ELEMENTS_INDICES"] = 33001] = "MAX_ELEMENTS_INDICES"; + GLEnum2[GLEnum2["MAX_TEXTURE_LOD_BIAS"] = 34045] = "MAX_TEXTURE_LOD_BIAS"; + GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_COMPONENTS"] = 35657] = "MAX_FRAGMENT_UNIFORM_COMPONENTS"; + GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_COMPONENTS"] = 35658] = "MAX_VERTEX_UNIFORM_COMPONENTS"; + GLEnum2[GLEnum2["MAX_ARRAY_TEXTURE_LAYERS"] = 35071] = "MAX_ARRAY_TEXTURE_LAYERS"; + GLEnum2[GLEnum2["MIN_PROGRAM_TEXEL_OFFSET"] = 35076] = "MIN_PROGRAM_TEXEL_OFFSET"; + GLEnum2[GLEnum2["MAX_PROGRAM_TEXEL_OFFSET"] = 35077] = "MAX_PROGRAM_TEXEL_OFFSET"; + GLEnum2[GLEnum2["MAX_VARYING_COMPONENTS"] = 35659] = "MAX_VARYING_COMPONENTS"; + GLEnum2[GLEnum2["FRAGMENT_SHADER_DERIVATIVE_HINT"] = 35723] = "FRAGMENT_SHADER_DERIVATIVE_HINT"; + GLEnum2[GLEnum2["RASTERIZER_DISCARD"] = 35977] = "RASTERIZER_DISCARD"; + GLEnum2[GLEnum2["VERTEX_ARRAY_BINDING"] = 34229] = "VERTEX_ARRAY_BINDING"; + GLEnum2[GLEnum2["MAX_VERTEX_OUTPUT_COMPONENTS"] = 37154] = "MAX_VERTEX_OUTPUT_COMPONENTS"; + GLEnum2[GLEnum2["MAX_FRAGMENT_INPUT_COMPONENTS"] = 37157] = "MAX_FRAGMENT_INPUT_COMPONENTS"; + GLEnum2[GLEnum2["MAX_SERVER_WAIT_TIMEOUT"] = 37137] = "MAX_SERVER_WAIT_TIMEOUT"; + GLEnum2[GLEnum2["MAX_ELEMENT_INDEX"] = 36203] = "MAX_ELEMENT_INDEX"; + GLEnum2[GLEnum2["RED"] = 6403] = "RED"; + GLEnum2[GLEnum2["RGB8"] = 32849] = "RGB8"; + GLEnum2[GLEnum2["RGBA8"] = 32856] = "RGBA8"; + GLEnum2[GLEnum2["RGB10_A2"] = 32857] = "RGB10_A2"; + GLEnum2[GLEnum2["TEXTURE_3D"] = 32879] = "TEXTURE_3D"; + GLEnum2[GLEnum2["TEXTURE_WRAP_R"] = 32882] = "TEXTURE_WRAP_R"; + GLEnum2[GLEnum2["TEXTURE_MIN_LOD"] = 33082] = "TEXTURE_MIN_LOD"; + GLEnum2[GLEnum2["TEXTURE_MAX_LOD"] = 33083] = "TEXTURE_MAX_LOD"; + GLEnum2[GLEnum2["TEXTURE_BASE_LEVEL"] = 33084] = "TEXTURE_BASE_LEVEL"; + GLEnum2[GLEnum2["TEXTURE_MAX_LEVEL"] = 33085] = "TEXTURE_MAX_LEVEL"; + GLEnum2[GLEnum2["TEXTURE_COMPARE_MODE"] = 34892] = "TEXTURE_COMPARE_MODE"; + GLEnum2[GLEnum2["TEXTURE_COMPARE_FUNC"] = 34893] = "TEXTURE_COMPARE_FUNC"; + GLEnum2[GLEnum2["SRGB"] = 35904] = "SRGB"; + GLEnum2[GLEnum2["SRGB8"] = 35905] = "SRGB8"; + GLEnum2[GLEnum2["SRGB8_ALPHA8"] = 35907] = "SRGB8_ALPHA8"; + GLEnum2[GLEnum2["COMPARE_REF_TO_TEXTURE"] = 34894] = "COMPARE_REF_TO_TEXTURE"; + GLEnum2[GLEnum2["RGBA32F"] = 34836] = "RGBA32F"; + GLEnum2[GLEnum2["RGB32F"] = 34837] = "RGB32F"; + GLEnum2[GLEnum2["RGBA16F"] = 34842] = "RGBA16F"; + GLEnum2[GLEnum2["RGB16F"] = 34843] = "RGB16F"; + GLEnum2[GLEnum2["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY"; + GLEnum2[GLEnum2["TEXTURE_BINDING_2D_ARRAY"] = 35869] = "TEXTURE_BINDING_2D_ARRAY"; + GLEnum2[GLEnum2["R11F_G11F_B10F"] = 35898] = "R11F_G11F_B10F"; + GLEnum2[GLEnum2["RGB9_E5"] = 35901] = "RGB9_E5"; + GLEnum2[GLEnum2["RGBA32UI"] = 36208] = "RGBA32UI"; + GLEnum2[GLEnum2["RGB32UI"] = 36209] = "RGB32UI"; + GLEnum2[GLEnum2["RGBA16UI"] = 36214] = "RGBA16UI"; + GLEnum2[GLEnum2["RGB16UI"] = 36215] = "RGB16UI"; + GLEnum2[GLEnum2["RGBA8UI"] = 36220] = "RGBA8UI"; + GLEnum2[GLEnum2["RGB8UI"] = 36221] = "RGB8UI"; + GLEnum2[GLEnum2["RGBA32I"] = 36226] = "RGBA32I"; + GLEnum2[GLEnum2["RGB32I"] = 36227] = "RGB32I"; + GLEnum2[GLEnum2["RGBA16I"] = 36232] = "RGBA16I"; + GLEnum2[GLEnum2["RGB16I"] = 36233] = "RGB16I"; + GLEnum2[GLEnum2["RGBA8I"] = 36238] = "RGBA8I"; + GLEnum2[GLEnum2["RGB8I"] = 36239] = "RGB8I"; + GLEnum2[GLEnum2["RED_INTEGER"] = 36244] = "RED_INTEGER"; + GLEnum2[GLEnum2["RGB_INTEGER"] = 36248] = "RGB_INTEGER"; + GLEnum2[GLEnum2["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER"; + GLEnum2[GLEnum2["R8"] = 33321] = "R8"; + GLEnum2[GLEnum2["RG8"] = 33323] = "RG8"; + GLEnum2[GLEnum2["R16F"] = 33325] = "R16F"; + GLEnum2[GLEnum2["R32F"] = 33326] = "R32F"; + GLEnum2[GLEnum2["RG16F"] = 33327] = "RG16F"; + GLEnum2[GLEnum2["RG32F"] = 33328] = "RG32F"; + GLEnum2[GLEnum2["R8I"] = 33329] = "R8I"; + GLEnum2[GLEnum2["R8UI"] = 33330] = "R8UI"; + GLEnum2[GLEnum2["R16I"] = 33331] = "R16I"; + GLEnum2[GLEnum2["R16UI"] = 33332] = "R16UI"; + GLEnum2[GLEnum2["R32I"] = 33333] = "R32I"; + GLEnum2[GLEnum2["R32UI"] = 33334] = "R32UI"; + GLEnum2[GLEnum2["RG8I"] = 33335] = "RG8I"; + GLEnum2[GLEnum2["RG8UI"] = 33336] = "RG8UI"; + GLEnum2[GLEnum2["RG16I"] = 33337] = "RG16I"; + GLEnum2[GLEnum2["RG16UI"] = 33338] = "RG16UI"; + GLEnum2[GLEnum2["RG32I"] = 33339] = "RG32I"; + GLEnum2[GLEnum2["RG32UI"] = 33340] = "RG32UI"; + GLEnum2[GLEnum2["R8_SNORM"] = 36756] = "R8_SNORM"; + GLEnum2[GLEnum2["RG8_SNORM"] = 36757] = "RG8_SNORM"; + GLEnum2[GLEnum2["RGB8_SNORM"] = 36758] = "RGB8_SNORM"; + GLEnum2[GLEnum2["RGBA8_SNORM"] = 36759] = "RGBA8_SNORM"; + GLEnum2[GLEnum2["RGB10_A2UI"] = 36975] = "RGB10_A2UI"; + GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_FORMAT"] = 37167] = "TEXTURE_IMMUTABLE_FORMAT"; + GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_LEVELS"] = 33503] = "TEXTURE_IMMUTABLE_LEVELS"; + GLEnum2[GLEnum2["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV"; + GLEnum2[GLEnum2["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV"; + GLEnum2[GLEnum2["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV"; + GLEnum2[GLEnum2["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV"; + GLEnum2[GLEnum2["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8"; + GLEnum2[GLEnum2["HALF_FLOAT"] = 5131] = "HALF_FLOAT"; + GLEnum2[GLEnum2["RG"] = 33319] = "RG"; + GLEnum2[GLEnum2["RG_INTEGER"] = 33320] = "RG_INTEGER"; + GLEnum2[GLEnum2["INT_2_10_10_10_REV"] = 36255] = "INT_2_10_10_10_REV"; + GLEnum2[GLEnum2["CURRENT_QUERY"] = 34917] = "CURRENT_QUERY"; + GLEnum2[GLEnum2["QUERY_RESULT"] = 34918] = "QUERY_RESULT"; + GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE"] = 34919] = "QUERY_RESULT_AVAILABLE"; + GLEnum2[GLEnum2["ANY_SAMPLES_PASSED"] = 35887] = "ANY_SAMPLES_PASSED"; + GLEnum2[GLEnum2["ANY_SAMPLES_PASSED_CONSERVATIVE"] = 36202] = "ANY_SAMPLES_PASSED_CONSERVATIVE"; + GLEnum2[GLEnum2["MAX_DRAW_BUFFERS"] = 34852] = "MAX_DRAW_BUFFERS"; + GLEnum2[GLEnum2["DRAW_BUFFER0"] = 34853] = "DRAW_BUFFER0"; + GLEnum2[GLEnum2["DRAW_BUFFER1"] = 34854] = "DRAW_BUFFER1"; + GLEnum2[GLEnum2["DRAW_BUFFER2"] = 34855] = "DRAW_BUFFER2"; + GLEnum2[GLEnum2["DRAW_BUFFER3"] = 34856] = "DRAW_BUFFER3"; + GLEnum2[GLEnum2["DRAW_BUFFER4"] = 34857] = "DRAW_BUFFER4"; + GLEnum2[GLEnum2["DRAW_BUFFER5"] = 34858] = "DRAW_BUFFER5"; + GLEnum2[GLEnum2["DRAW_BUFFER6"] = 34859] = "DRAW_BUFFER6"; + GLEnum2[GLEnum2["DRAW_BUFFER7"] = 34860] = "DRAW_BUFFER7"; + GLEnum2[GLEnum2["DRAW_BUFFER8"] = 34861] = "DRAW_BUFFER8"; + GLEnum2[GLEnum2["DRAW_BUFFER9"] = 34862] = "DRAW_BUFFER9"; + GLEnum2[GLEnum2["DRAW_BUFFER10"] = 34863] = "DRAW_BUFFER10"; + GLEnum2[GLEnum2["DRAW_BUFFER11"] = 34864] = "DRAW_BUFFER11"; + GLEnum2[GLEnum2["DRAW_BUFFER12"] = 34865] = "DRAW_BUFFER12"; + GLEnum2[GLEnum2["DRAW_BUFFER13"] = 34866] = "DRAW_BUFFER13"; + GLEnum2[GLEnum2["DRAW_BUFFER14"] = 34867] = "DRAW_BUFFER14"; + GLEnum2[GLEnum2["DRAW_BUFFER15"] = 34868] = "DRAW_BUFFER15"; + GLEnum2[GLEnum2["MAX_COLOR_ATTACHMENTS"] = 36063] = "MAX_COLOR_ATTACHMENTS"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT1"] = 36065] = "COLOR_ATTACHMENT1"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT2"] = 36066] = "COLOR_ATTACHMENT2"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT3"] = 36067] = "COLOR_ATTACHMENT3"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT4"] = 36068] = "COLOR_ATTACHMENT4"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT5"] = 36069] = "COLOR_ATTACHMENT5"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT6"] = 36070] = "COLOR_ATTACHMENT6"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT7"] = 36071] = "COLOR_ATTACHMENT7"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT8"] = 36072] = "COLOR_ATTACHMENT8"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT9"] = 36073] = "COLOR_ATTACHMENT9"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT10"] = 36074] = "COLOR_ATTACHMENT10"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT11"] = 36075] = "COLOR_ATTACHMENT11"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT12"] = 36076] = "COLOR_ATTACHMENT12"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT13"] = 36077] = "COLOR_ATTACHMENT13"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT14"] = 36078] = "COLOR_ATTACHMENT14"; + GLEnum2[GLEnum2["COLOR_ATTACHMENT15"] = 36079] = "COLOR_ATTACHMENT15"; + GLEnum2[GLEnum2["SAMPLER_3D"] = 35679] = "SAMPLER_3D"; + GLEnum2[GLEnum2["SAMPLER_2D_SHADOW"] = 35682] = "SAMPLER_2D_SHADOW"; + GLEnum2[GLEnum2["SAMPLER_2D_ARRAY"] = 36289] = "SAMPLER_2D_ARRAY"; + GLEnum2[GLEnum2["SAMPLER_2D_ARRAY_SHADOW"] = 36292] = "SAMPLER_2D_ARRAY_SHADOW"; + GLEnum2[GLEnum2["SAMPLER_CUBE_SHADOW"] = 36293] = "SAMPLER_CUBE_SHADOW"; + GLEnum2[GLEnum2["INT_SAMPLER_2D"] = 36298] = "INT_SAMPLER_2D"; + GLEnum2[GLEnum2["INT_SAMPLER_3D"] = 36299] = "INT_SAMPLER_3D"; + GLEnum2[GLEnum2["INT_SAMPLER_CUBE"] = 36300] = "INT_SAMPLER_CUBE"; + GLEnum2[GLEnum2["INT_SAMPLER_2D_ARRAY"] = 36303] = "INT_SAMPLER_2D_ARRAY"; + GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D"] = 36306] = "UNSIGNED_INT_SAMPLER_2D"; + GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_3D"] = 36307] = "UNSIGNED_INT_SAMPLER_3D"; + GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_CUBE"] = 36308] = "UNSIGNED_INT_SAMPLER_CUBE"; + GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D_ARRAY"] = 36311] = "UNSIGNED_INT_SAMPLER_2D_ARRAY"; + GLEnum2[GLEnum2["MAX_SAMPLES"] = 36183] = "MAX_SAMPLES"; + GLEnum2[GLEnum2["SAMPLER_BINDING"] = 35097] = "SAMPLER_BINDING"; + GLEnum2[GLEnum2["PIXEL_PACK_BUFFER"] = 35051] = "PIXEL_PACK_BUFFER"; + GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER"] = 35052] = "PIXEL_UNPACK_BUFFER"; + GLEnum2[GLEnum2["PIXEL_PACK_BUFFER_BINDING"] = 35053] = "PIXEL_PACK_BUFFER_BINDING"; + GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER_BINDING"] = 35055] = "PIXEL_UNPACK_BUFFER_BINDING"; + GLEnum2[GLEnum2["COPY_READ_BUFFER"] = 36662] = "COPY_READ_BUFFER"; + GLEnum2[GLEnum2["COPY_WRITE_BUFFER"] = 36663] = "COPY_WRITE_BUFFER"; + GLEnum2[GLEnum2["COPY_READ_BUFFER_BINDING"] = 36662] = "COPY_READ_BUFFER_BINDING"; + GLEnum2[GLEnum2["COPY_WRITE_BUFFER_BINDING"] = 36663] = "COPY_WRITE_BUFFER_BINDING"; + GLEnum2[GLEnum2["FLOAT_MAT2x3"] = 35685] = "FLOAT_MAT2x3"; + GLEnum2[GLEnum2["FLOAT_MAT2x4"] = 35686] = "FLOAT_MAT2x4"; + GLEnum2[GLEnum2["FLOAT_MAT3x2"] = 35687] = "FLOAT_MAT3x2"; + GLEnum2[GLEnum2["FLOAT_MAT3x4"] = 35688] = "FLOAT_MAT3x4"; + GLEnum2[GLEnum2["FLOAT_MAT4x2"] = 35689] = "FLOAT_MAT4x2"; + GLEnum2[GLEnum2["FLOAT_MAT4x3"] = 35690] = "FLOAT_MAT4x3"; + GLEnum2[GLEnum2["UNSIGNED_INT_VEC2"] = 36294] = "UNSIGNED_INT_VEC2"; + GLEnum2[GLEnum2["UNSIGNED_INT_VEC3"] = 36295] = "UNSIGNED_INT_VEC3"; + GLEnum2[GLEnum2["UNSIGNED_INT_VEC4"] = 36296] = "UNSIGNED_INT_VEC4"; + GLEnum2[GLEnum2["UNSIGNED_NORMALIZED"] = 35863] = "UNSIGNED_NORMALIZED"; + GLEnum2[GLEnum2["SIGNED_NORMALIZED"] = 36764] = "SIGNED_NORMALIZED"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_INTEGER"] = 35069] = "VERTEX_ATTRIB_ARRAY_INTEGER"; + GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_DIVISOR"] = 35070] = "VERTEX_ATTRIB_ARRAY_DIVISOR"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_MODE"] = 35967] = "TRANSFORM_FEEDBACK_BUFFER_MODE"; + GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"] = 35968] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_VARYINGS"] = 35971] = "TRANSFORM_FEEDBACK_VARYINGS"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_START"] = 35972] = "TRANSFORM_FEEDBACK_BUFFER_START"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_SIZE"] = 35973] = "TRANSFORM_FEEDBACK_BUFFER_SIZE"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"] = 35976] = "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; + GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"] = 35978] = "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"; + GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"] = 35979] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"; + GLEnum2[GLEnum2["INTERLEAVED_ATTRIBS"] = 35980] = "INTERLEAVED_ATTRIBS"; + GLEnum2[GLEnum2["SEPARATE_ATTRIBS"] = 35981] = "SEPARATE_ATTRIBS"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER"] = 35982] = "TRANSFORM_FEEDBACK_BUFFER"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_BINDING"] = 35983] = "TRANSFORM_FEEDBACK_BUFFER_BINDING"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK"] = 36386] = "TRANSFORM_FEEDBACK"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PAUSED"] = 36387] = "TRANSFORM_FEEDBACK_PAUSED"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_ACTIVE"] = 36388] = "TRANSFORM_FEEDBACK_ACTIVE"; + GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BINDING"] = 36389] = "TRANSFORM_FEEDBACK_BINDING"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"] = 33296] = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"] = 33297] = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_RED_SIZE"] = 33298] = "FRAMEBUFFER_ATTACHMENT_RED_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"] = 33299] = "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"] = 33300] = "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"] = 33301] = "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"] = 33302] = "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"] = 33303] = "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; + GLEnum2[GLEnum2["FRAMEBUFFER_DEFAULT"] = 33304] = "FRAMEBUFFER_DEFAULT"; + GLEnum2[GLEnum2["DEPTH24_STENCIL8"] = 35056] = "DEPTH24_STENCIL8"; + GLEnum2[GLEnum2["DRAW_FRAMEBUFFER_BINDING"] = 36006] = "DRAW_FRAMEBUFFER_BINDING"; + GLEnum2[GLEnum2["READ_FRAMEBUFFER_BINDING"] = 36010] = "READ_FRAMEBUFFER_BINDING"; + GLEnum2[GLEnum2["RENDERBUFFER_SAMPLES"] = 36011] = "RENDERBUFFER_SAMPLES"; + GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"] = 36052] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"; + GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"] = 36182] = "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; + GLEnum2[GLEnum2["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER"; + GLEnum2[GLEnum2["UNIFORM_BUFFER_BINDING"] = 35368] = "UNIFORM_BUFFER_BINDING"; + GLEnum2[GLEnum2["UNIFORM_BUFFER_START"] = 35369] = "UNIFORM_BUFFER_START"; + GLEnum2[GLEnum2["UNIFORM_BUFFER_SIZE"] = 35370] = "UNIFORM_BUFFER_SIZE"; + GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_BLOCKS"] = 35371] = "MAX_VERTEX_UNIFORM_BLOCKS"; + GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_BLOCKS"] = 35373] = "MAX_FRAGMENT_UNIFORM_BLOCKS"; + GLEnum2[GLEnum2["MAX_COMBINED_UNIFORM_BLOCKS"] = 35374] = "MAX_COMBINED_UNIFORM_BLOCKS"; + GLEnum2[GLEnum2["MAX_UNIFORM_BUFFER_BINDINGS"] = 35375] = "MAX_UNIFORM_BUFFER_BINDINGS"; + GLEnum2[GLEnum2["MAX_UNIFORM_BLOCK_SIZE"] = 35376] = "MAX_UNIFORM_BLOCK_SIZE"; + GLEnum2[GLEnum2["MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"] = 35377] = "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"; + GLEnum2[GLEnum2["MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"] = 35379] = "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; + GLEnum2[GLEnum2["UNIFORM_BUFFER_OFFSET_ALIGNMENT"] = 35380] = "UNIFORM_BUFFER_OFFSET_ALIGNMENT"; + GLEnum2[GLEnum2["ACTIVE_UNIFORM_BLOCKS"] = 35382] = "ACTIVE_UNIFORM_BLOCKS"; + GLEnum2[GLEnum2["UNIFORM_TYPE"] = 35383] = "UNIFORM_TYPE"; + GLEnum2[GLEnum2["UNIFORM_SIZE"] = 35384] = "UNIFORM_SIZE"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_INDEX"] = 35386] = "UNIFORM_BLOCK_INDEX"; + GLEnum2[GLEnum2["UNIFORM_OFFSET"] = 35387] = "UNIFORM_OFFSET"; + GLEnum2[GLEnum2["UNIFORM_ARRAY_STRIDE"] = 35388] = "UNIFORM_ARRAY_STRIDE"; + GLEnum2[GLEnum2["UNIFORM_MATRIX_STRIDE"] = 35389] = "UNIFORM_MATRIX_STRIDE"; + GLEnum2[GLEnum2["UNIFORM_IS_ROW_MAJOR"] = 35390] = "UNIFORM_IS_ROW_MAJOR"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_BINDING"] = 35391] = "UNIFORM_BLOCK_BINDING"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_DATA_SIZE"] = 35392] = "UNIFORM_BLOCK_DATA_SIZE"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORMS"] = 35394] = "UNIFORM_BLOCK_ACTIVE_UNIFORMS"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"] = 35395] = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"] = 35396] = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"; + GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"] = 35398] = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; + GLEnum2[GLEnum2["OBJECT_TYPE"] = 37138] = "OBJECT_TYPE"; + GLEnum2[GLEnum2["SYNC_CONDITION"] = 37139] = "SYNC_CONDITION"; + GLEnum2[GLEnum2["SYNC_STATUS"] = 37140] = "SYNC_STATUS"; + GLEnum2[GLEnum2["SYNC_FLAGS"] = 37141] = "SYNC_FLAGS"; + GLEnum2[GLEnum2["SYNC_FENCE"] = 37142] = "SYNC_FENCE"; + GLEnum2[GLEnum2["SYNC_GPU_COMMANDS_COMPLETE"] = 37143] = "SYNC_GPU_COMMANDS_COMPLETE"; + GLEnum2[GLEnum2["UNSIGNALED"] = 37144] = "UNSIGNALED"; + GLEnum2[GLEnum2["SIGNALED"] = 37145] = "SIGNALED"; + GLEnum2[GLEnum2["ALREADY_SIGNALED"] = 37146] = "ALREADY_SIGNALED"; + GLEnum2[GLEnum2["TIMEOUT_EXPIRED"] = 37147] = "TIMEOUT_EXPIRED"; + GLEnum2[GLEnum2["CONDITION_SATISFIED"] = 37148] = "CONDITION_SATISFIED"; + GLEnum2[GLEnum2["WAIT_FAILED"] = 37149] = "WAIT_FAILED"; + GLEnum2[GLEnum2["SYNC_FLUSH_COMMANDS_BIT"] = 1] = "SYNC_FLUSH_COMMANDS_BIT"; + GLEnum2[GLEnum2["COLOR"] = 6144] = "COLOR"; + GLEnum2[GLEnum2["DEPTH"] = 6145] = "DEPTH"; + GLEnum2[GLEnum2["STENCIL"] = 6146] = "STENCIL"; + GLEnum2[GLEnum2["MIN"] = 32775] = "MIN"; + GLEnum2[GLEnum2["MAX"] = 32776] = "MAX"; + GLEnum2[GLEnum2["DEPTH_COMPONENT24"] = 33190] = "DEPTH_COMPONENT24"; + GLEnum2[GLEnum2["STREAM_READ"] = 35041] = "STREAM_READ"; + GLEnum2[GLEnum2["STREAM_COPY"] = 35042] = "STREAM_COPY"; + GLEnum2[GLEnum2["STATIC_READ"] = 35045] = "STATIC_READ"; + GLEnum2[GLEnum2["STATIC_COPY"] = 35046] = "STATIC_COPY"; + GLEnum2[GLEnum2["DYNAMIC_READ"] = 35049] = "DYNAMIC_READ"; + GLEnum2[GLEnum2["DYNAMIC_COPY"] = 35050] = "DYNAMIC_COPY"; + GLEnum2[GLEnum2["DEPTH_COMPONENT32F"] = 36012] = "DEPTH_COMPONENT32F"; + GLEnum2[GLEnum2["DEPTH32F_STENCIL8"] = 36013] = "DEPTH32F_STENCIL8"; + GLEnum2[GLEnum2["INVALID_INDEX"] = 4294967295] = "INVALID_INDEX"; + GLEnum2[GLEnum2["TIMEOUT_IGNORED"] = -1] = "TIMEOUT_IGNORED"; + GLEnum2[GLEnum2["MAX_CLIENT_WAIT_TIMEOUT_WEBGL"] = 37447] = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL"; + GLEnum2[GLEnum2["UNMASKED_VENDOR_WEBGL"] = 37445] = "UNMASKED_VENDOR_WEBGL"; + GLEnum2[GLEnum2["UNMASKED_RENDERER_WEBGL"] = 37446] = "UNMASKED_RENDERER_WEBGL"; + GLEnum2[GLEnum2["MAX_TEXTURE_MAX_ANISOTROPY_EXT"] = 34047] = "MAX_TEXTURE_MAX_ANISOTROPY_EXT"; + GLEnum2[GLEnum2["TEXTURE_MAX_ANISOTROPY_EXT"] = 34046] = "TEXTURE_MAX_ANISOTROPY_EXT"; + GLEnum2[GLEnum2["R16_EXT"] = 33322] = "R16_EXT"; + GLEnum2[GLEnum2["RG16_EXT"] = 33324] = "RG16_EXT"; + GLEnum2[GLEnum2["RGB16_EXT"] = 32852] = "RGB16_EXT"; + GLEnum2[GLEnum2["RGBA16_EXT"] = 32859] = "RGBA16_EXT"; + GLEnum2[GLEnum2["R16_SNORM_EXT"] = 36760] = "R16_SNORM_EXT"; + GLEnum2[GLEnum2["RG16_SNORM_EXT"] = 36761] = "RG16_SNORM_EXT"; + GLEnum2[GLEnum2["RGB16_SNORM_EXT"] = 36762] = "RGB16_SNORM_EXT"; + GLEnum2[GLEnum2["RGBA16_SNORM_EXT"] = 36763] = "RGBA16_SNORM_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RED_RGTC1_EXT"] = 36283] = "COMPRESSED_RED_RGTC1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_RGTC1_EXT"] = 36284] = "COMPRESSED_SIGNED_RED_RGTC1_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RED_GREEN_RGTC2_EXT"] = 36285] = "COMPRESSED_RED_GREEN_RGTC2_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"] = 36286] = "COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_BPTC_UNORM_EXT"] = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT"; + GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"] = 36493] = "COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"] = 36494] = "COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"; + GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"] = 36495] = "COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"; + GLEnum2[GLEnum2["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC"; + GLEnum2[GLEnum2["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC"; + GLEnum2[GLEnum2["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC"; + GLEnum2[GLEnum2["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC"; + GLEnum2[GLEnum2["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2"; + GLEnum2[GLEnum2["COMPRESSED_RGBA8_ETC2_EAC"] = 37493] = "COMPRESSED_RGBA8_ETC2_EAC"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ETC2"] = 37494] = "COMPRESSED_SRGB8_ETC2"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37495] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + GLEnum2[GLEnum2["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37496] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37497] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; + GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; + GLEnum2[GLEnum2["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL"; + GLEnum2[GLEnum2["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x4_KHR"] = 37809] = "COMPRESSED_RGBA_ASTC_5x4_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x5_KHR"] = 37810] = "COMPRESSED_RGBA_ASTC_5x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x5_KHR"] = 37811] = "COMPRESSED_RGBA_ASTC_6x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x6_KHR"] = 37812] = "COMPRESSED_RGBA_ASTC_6x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x5_KHR"] = 37813] = "COMPRESSED_RGBA_ASTC_8x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x6_KHR"] = 37814] = "COMPRESSED_RGBA_ASTC_8x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x8_KHR"] = 37815] = "COMPRESSED_RGBA_ASTC_8x8_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x5_KHR"] = 37816] = "COMPRESSED_RGBA_ASTC_10x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x6_KHR"] = 37817] = "COMPRESSED_RGBA_ASTC_10x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x8_KHR"] = 37818] = "COMPRESSED_RGBA_ASTC_10x8_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x10_KHR"] = 37819] = "COMPRESSED_RGBA_ASTC_10x10_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x10_KHR"] = 37820] = "COMPRESSED_RGBA_ASTC_12x10_KHR"; + GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x12_KHR"] = 37821] = "COMPRESSED_RGBA_ASTC_12x12_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"] = 37840] = "COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"] = 37841] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 37851] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; + GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; + GLEnum2[GLEnum2["QUERY_COUNTER_BITS_EXT"] = 34916] = "QUERY_COUNTER_BITS_EXT"; + GLEnum2[GLEnum2["CURRENT_QUERY_EXT"] = 34917] = "CURRENT_QUERY_EXT"; + GLEnum2[GLEnum2["QUERY_RESULT_EXT"] = 34918] = "QUERY_RESULT_EXT"; + GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT"; + GLEnum2[GLEnum2["TIME_ELAPSED_EXT"] = 35007] = "TIME_ELAPSED_EXT"; + GLEnum2[GLEnum2["TIMESTAMP_EXT"] = 36392] = "TIMESTAMP_EXT"; + GLEnum2[GLEnum2["GPU_DISJOINT_EXT"] = 36795] = "GPU_DISJOINT_EXT"; + GLEnum2[GLEnum2["COMPLETION_STATUS_KHR"] = 37297] = "COMPLETION_STATUS_KHR"; + GLEnum2[GLEnum2["DEPTH_CLAMP_EXT"] = 34383] = "DEPTH_CLAMP_EXT"; + GLEnum2[GLEnum2["FIRST_VERTEX_CONVENTION_WEBGL"] = 36429] = "FIRST_VERTEX_CONVENTION_WEBGL"; + GLEnum2[GLEnum2["LAST_VERTEX_CONVENTION_WEBGL"] = 36430] = "LAST_VERTEX_CONVENTION_WEBGL"; + GLEnum2[GLEnum2["PROVOKING_VERTEX_WEBL"] = 36431] = "PROVOKING_VERTEX_WEBL"; + GLEnum2[GLEnum2["POLYGON_MODE_WEBGL"] = 2880] = "POLYGON_MODE_WEBGL"; + GLEnum2[GLEnum2["POLYGON_OFFSET_LINE_WEBGL"] = 10754] = "POLYGON_OFFSET_LINE_WEBGL"; + GLEnum2[GLEnum2["LINE_WEBGL"] = 6913] = "LINE_WEBGL"; + GLEnum2[GLEnum2["FILL_WEBGL"] = 6914] = "FILL_WEBGL"; + GLEnum2[GLEnum2["MAX_CLIP_DISTANCES_WEBGL"] = 3378] = "MAX_CLIP_DISTANCES_WEBGL"; + GLEnum2[GLEnum2["MAX_CULL_DISTANCES_WEBGL"] = 33529] = "MAX_CULL_DISTANCES_WEBGL"; + GLEnum2[GLEnum2["MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"] = 33530] = "MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE0_WEBGL"] = 12288] = "CLIP_DISTANCE0_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE1_WEBGL"] = 12289] = "CLIP_DISTANCE1_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE2_WEBGL"] = 12290] = "CLIP_DISTANCE2_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE3_WEBGL"] = 12291] = "CLIP_DISTANCE3_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE4_WEBGL"] = 12292] = "CLIP_DISTANCE4_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE5_WEBGL"] = 12293] = "CLIP_DISTANCE5_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE6_WEBGL"] = 12294] = "CLIP_DISTANCE6_WEBGL"; + GLEnum2[GLEnum2["CLIP_DISTANCE7_WEBGL"] = 12295] = "CLIP_DISTANCE7_WEBGL"; + GLEnum2[GLEnum2["POLYGON_OFFSET_CLAMP_EXT"] = 36379] = "POLYGON_OFFSET_CLAMP_EXT"; + GLEnum2[GLEnum2["LOWER_LEFT_EXT"] = 36001] = "LOWER_LEFT_EXT"; + GLEnum2[GLEnum2["UPPER_LEFT_EXT"] = 36002] = "UPPER_LEFT_EXT"; + GLEnum2[GLEnum2["NEGATIVE_ONE_TO_ONE_EXT"] = 37726] = "NEGATIVE_ONE_TO_ONE_EXT"; + GLEnum2[GLEnum2["ZERO_TO_ONE_EXT"] = 37727] = "ZERO_TO_ONE_EXT"; + GLEnum2[GLEnum2["CLIP_ORIGIN_EXT"] = 37724] = "CLIP_ORIGIN_EXT"; + GLEnum2[GLEnum2["CLIP_DEPTH_MODE_EXT"] = 37725] = "CLIP_DEPTH_MODE_EXT"; + GLEnum2[GLEnum2["SRC1_COLOR_WEBGL"] = 35065] = "SRC1_COLOR_WEBGL"; + GLEnum2[GLEnum2["SRC1_ALPHA_WEBGL"] = 34185] = "SRC1_ALPHA_WEBGL"; + GLEnum2[GLEnum2["ONE_MINUS_SRC1_COLOR_WEBGL"] = 35066] = "ONE_MINUS_SRC1_COLOR_WEBGL"; + GLEnum2[GLEnum2["ONE_MINUS_SRC1_ALPHA_WEBGL"] = 35067] = "ONE_MINUS_SRC1_ALPHA_WEBGL"; + GLEnum2[GLEnum2["MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"] = 35068] = "MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"; + GLEnum2[GLEnum2["MIRROR_CLAMP_TO_EDGE_EXT"] = 34627] = "MIRROR_CLAMP_TO_EDGE_EXT"; +})(GLEnum || (GLEnum = {})); + +// node_modules/@luma.gl/webgl/dist/context/parameters/webgl-parameter-tables.js +var GL_PARAMETER_DEFAULTS = { + [3042]: false, + [32773]: new Float32Array([0, 0, 0, 0]), + [32777]: 32774, + [34877]: 32774, + [32969]: 1, + [32968]: 0, + [32971]: 1, + [32970]: 0, + [3106]: new Float32Array([0, 0, 0, 0]), + // TBD + [3107]: [true, true, true, true], + [2884]: false, + [2885]: 1029, + [2929]: false, + [2931]: 1, + [2932]: 513, + [2928]: new Float32Array([0, 1]), + // TBD + [2930]: true, + [3024]: true, + [35725]: null, + // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state. + [36006]: null, + [36007]: null, + [34229]: null, + [34964]: null, + [2886]: 2305, + [33170]: 4352, + [2849]: 1, + [32823]: false, + [32824]: 0, + [10752]: 0, + [32926]: false, + [32928]: false, + [32938]: 1, + [32939]: false, + [3089]: false, + // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box + [3088]: new Int32Array([0, 0, 1024, 1024]), + [2960]: false, + [2961]: 0, + [2968]: 4294967295, + [36005]: 4294967295, + [2962]: 519, + [2967]: 0, + [2963]: 4294967295, + [34816]: 519, + [36003]: 0, + [36004]: 4294967295, + [2964]: 7680, + [2965]: 7680, + [2966]: 7680, + [34817]: 7680, + [34818]: 7680, + [34819]: 7680, + // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame. + [2978]: [0, 0, 1024, 1024], + [36389]: null, + [36662]: null, + [36663]: null, + [35053]: null, + [35055]: null, + [35723]: 4352, + [36010]: null, + [35977]: false, + [3333]: 4, + [3317]: 4, + [37440]: false, + [37441]: false, + [37443]: 37444, + [3330]: 0, + [3332]: 0, + [3331]: 0, + [3314]: 0, + [32878]: 0, + [3316]: 0, + [3315]: 0, + [32877]: 0 +}; +var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key); +var hint = (gl, value, key) => gl.hint(key, value); +var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value); +var bindFramebuffer = (gl, value, key) => { + const target = key === 36006 ? 36009 : 36008; + return gl.bindFramebuffer(target, value); +}; +var bindBuffer = (gl, value, key) => { + const bindingMap = { + [34964]: 34962, + [36662]: 36662, + [36663]: 36663, + [35053]: 35051, + [35055]: 35052 + }; + const glTarget = bindingMap[key]; + gl.bindBuffer(glTarget, value); +}; +function isArray2(array) { + return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView); +} +var GL_PARAMETER_SETTERS = { + [3042]: enable, + [32773]: (gl, value) => gl.blendColor(...value), + [32777]: "blendEquation", + [34877]: "blendEquation", + [32969]: "blendFunc", + [32968]: "blendFunc", + [32971]: "blendFunc", + [32970]: "blendFunc", + [3106]: (gl, value) => gl.clearColor(...value), + [3107]: (gl, value) => gl.colorMask(...value), + [2884]: enable, + [2885]: (gl, value) => gl.cullFace(value), + [2929]: enable, + [2931]: (gl, value) => gl.clearDepth(value), + [2932]: (gl, value) => gl.depthFunc(value), + [2928]: (gl, value) => gl.depthRange(...value), + [2930]: (gl, value) => gl.depthMask(value), + [3024]: enable, + [35723]: hint, + [35725]: (gl, value) => gl.useProgram(value), + [36007]: (gl, value) => gl.bindRenderbuffer(36161, value), + [36389]: (gl, value) => gl.bindTransformFeedback?.(36386, value), + [34229]: (gl, value) => gl.bindVertexArray(value), + // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state. + [36006]: bindFramebuffer, + [36010]: bindFramebuffer, + // Buffers + [34964]: bindBuffer, + [36662]: bindBuffer, + [36663]: bindBuffer, + [35053]: bindBuffer, + [35055]: bindBuffer, + [2886]: (gl, value) => gl.frontFace(value), + [33170]: hint, + [2849]: (gl, value) => gl.lineWidth(value), + [32823]: enable, + [32824]: "polygonOffset", + [10752]: "polygonOffset", + [35977]: enable, + [32926]: enable, + [32928]: enable, + [32938]: "sampleCoverage", + [32939]: "sampleCoverage", + [3089]: enable, + [3088]: (gl, value) => gl.scissor(...value), + [2960]: enable, + [2961]: (gl, value) => gl.clearStencil(value), + [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value), + [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value), + [2962]: "stencilFuncFront", + [2967]: "stencilFuncFront", + [2963]: "stencilFuncFront", + [34816]: "stencilFuncBack", + [36003]: "stencilFuncBack", + [36004]: "stencilFuncBack", + [2964]: "stencilOpFront", + [2965]: "stencilOpFront", + [2966]: "stencilOpFront", + [34817]: "stencilOpBack", + [34818]: "stencilOpBack", + [34819]: "stencilOpBack", + [2978]: (gl, value) => gl.viewport(...value), + // WEBGL2 EXTENSIONS + // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/ + [34383]: enable, + // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/ + // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed + // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/ + // POLYGON_MODE_WEBGL TODO - extension function needed + [10754]: enable, + // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/ + [12288]: enable, + [12289]: enable, + [12290]: enable, + [12291]: enable, + [12292]: enable, + [12293]: enable, + [12294]: enable, + [12295]: enable, + // PIXEL PACK/UNPACK MODES + [3333]: pixelStorei, + [3317]: pixelStorei, + [37440]: pixelStorei, + [37441]: pixelStorei, + [37443]: pixelStorei, + [3330]: pixelStorei, + [3332]: pixelStorei, + [3331]: pixelStorei, + [3314]: pixelStorei, + [32878]: pixelStorei, + [3316]: pixelStorei, + [3315]: pixelStorei, + [32877]: pixelStorei, + // Function-style setters + framebuffer: (gl, framebuffer) => { + const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer; + return gl.bindFramebuffer(36160, handle); + }, + blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042), + blendColor: (gl, value) => gl.blendColor(...value), + blendEquation: (gl, args) => { + const separateModes = typeof args === "number" ? [args, args] : args; + gl.blendEquationSeparate(...separateModes); + }, + blendFunc: (gl, args) => { + const separateFuncs = args?.length === 2 ? [...args, ...args] : args; + gl.blendFuncSeparate(...separateFuncs); + }, + clearColor: (gl, value) => gl.clearColor(...value), + clearDepth: (gl, value) => gl.clearDepth(value), + clearStencil: (gl, value) => gl.clearStencil(value), + colorMask: (gl, value) => gl.colorMask(...value), + cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884), + cullFace: (gl, value) => gl.cullFace(value), + depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929), + depthFunc: (gl, value) => gl.depthFunc(value), + depthMask: (gl, value) => gl.depthMask(value), + depthRange: (gl, value) => gl.depthRange(...value), + dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024), + derivativeHint: (gl, value) => { + gl.hint(35723, value); + }, + frontFace: (gl, value) => gl.frontFace(value), + mipmapHint: (gl, value) => gl.hint(33170, value), + lineWidth: (gl, value) => gl.lineWidth(value), + polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823), + polygonOffset: (gl, value) => gl.polygonOffset(...value), + sampleCoverage: (gl, value) => gl.sampleCoverage(...value), + scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089), + scissor: (gl, value) => gl.scissor(...value), + stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960), + stencilMask: (gl, value) => { + value = isArray2(value) ? value : [value, value]; + const [mask, backMask] = value; + gl.stencilMaskSeparate(1028, mask); + gl.stencilMaskSeparate(1029, backMask); + }, + stencilFunc: (gl, args) => { + args = isArray2(args) && args.length === 3 ? [...args, ...args] : args; + const [func, ref, mask, backFunc, backRef, backMask] = args; + gl.stencilFuncSeparate(1028, func, ref, mask); + gl.stencilFuncSeparate(1029, backFunc, backRef, backMask); + }, + stencilOp: (gl, args) => { + args = isArray2(args) && args.length === 3 ? [...args, ...args] : args; + const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args; + gl.stencilOpSeparate(1028, sfail, dpfail, dppass); + gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass); + }, + viewport: (gl, value) => gl.viewport(...value) +}; +function getValue(glEnum, values, cache3) { + return values[glEnum] !== void 0 ? values[glEnum] : cache3[glEnum]; +} +var GL_COMPOSITE_PARAMETER_SETTERS = { + blendEquation: (gl, values, cache3) => gl.blendEquationSeparate(getValue(32777, values, cache3), getValue(34877, values, cache3)), + blendFunc: (gl, values, cache3) => gl.blendFuncSeparate(getValue(32969, values, cache3), getValue(32968, values, cache3), getValue(32971, values, cache3), getValue(32970, values, cache3)), + polygonOffset: (gl, values, cache3) => gl.polygonOffset(getValue(32824, values, cache3), getValue(10752, values, cache3)), + sampleCoverage: (gl, values, cache3) => gl.sampleCoverage(getValue(32938, values, cache3), getValue(32939, values, cache3)), + stencilFuncFront: (gl, values, cache3) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache3), getValue(2967, values, cache3), getValue(2963, values, cache3)), + stencilFuncBack: (gl, values, cache3) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache3), getValue(36003, values, cache3), getValue(36004, values, cache3)), + stencilOpFront: (gl, values, cache3) => gl.stencilOpSeparate(1028, getValue(2964, values, cache3), getValue(2965, values, cache3), getValue(2966, values, cache3)), + stencilOpBack: (gl, values, cache3) => gl.stencilOpSeparate(1029, getValue(34817, values, cache3), getValue(34818, values, cache3), getValue(34819, values, cache3)) +}; +var GL_HOOKED_SETTERS = { + // GENERIC SETTERS + enable: (update, capability) => update({ + [capability]: true + }), + disable: (update, capability) => update({ + [capability]: false + }), + pixelStorei: (update, pname, value) => update({ + [pname]: value + }), + hint: (update, pname, hint2) => update({ + [pname]: hint2 + }), + // SPECIFIC SETTERS + useProgram: (update, value) => update({ + [35725]: value + }), + bindRenderbuffer: (update, target, value) => update({ + [36007]: value + }), + bindTransformFeedback: (update, target, value) => update({ + [36389]: value + }), + bindVertexArray: (update, value) => update({ + [34229]: value + }), + bindFramebuffer: (update, target, framebuffer) => { + switch (target) { + case 36160: + return update({ + [36006]: framebuffer, + [36010]: framebuffer + }); + case 36009: + return update({ [36006]: framebuffer }); + case 36008: + return update({ [36010]: framebuffer }); + default: + return null; + } + }, + bindBuffer: (update, target, buffer) => { + const pname = { + [34962]: [34964], + [36662]: [36662], + [36663]: [36663], + [35051]: [35053], + [35052]: [35055] + }[target]; + if (pname) { + return update({ [pname]: buffer }); + } + return { valueChanged: true }; + }, + blendColor: (update, r, g, b, a) => update({ + [32773]: new Float32Array([r, g, b, a]) + }), + blendEquation: (update, mode) => update({ + [32777]: mode, + [34877]: mode + }), + blendEquationSeparate: (update, modeRGB, modeAlpha) => update({ + [32777]: modeRGB, + [34877]: modeAlpha + }), + blendFunc: (update, src, dst) => update({ + [32969]: src, + [32968]: dst, + [32971]: src, + [32970]: dst + }), + blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({ + [32969]: srcRGB, + [32968]: dstRGB, + [32971]: srcAlpha, + [32970]: dstAlpha + }), + clearColor: (update, r, g, b, a) => update({ + [3106]: new Float32Array([r, g, b, a]) + }), + clearDepth: (update, depth) => update({ + [2931]: depth + }), + clearStencil: (update, s) => update({ + [2961]: s + }), + colorMask: (update, r, g, b, a) => update({ + [3107]: [r, g, b, a] + }), + cullFace: (update, mode) => update({ + [2885]: mode + }), + depthFunc: (update, func) => update({ + [2932]: func + }), + depthRange: (update, zNear, zFar) => update({ + [2928]: new Float32Array([zNear, zFar]) + }), + depthMask: (update, mask) => update({ + [2930]: mask + }), + frontFace: (update, face) => update({ + [2886]: face + }), + lineWidth: (update, width) => update({ + [2849]: width + }), + polygonOffset: (update, factor, units) => update({ + [32824]: factor, + [10752]: units + }), + sampleCoverage: (update, value, invert6) => update({ + [32938]: value, + [32939]: invert6 + }), + scissor: (update, x, y, width, height) => update({ + [3088]: new Int32Array([x, y, width, height]) + }), + stencilMask: (update, mask) => update({ + [2968]: mask, + [36005]: mask + }), + stencilMaskSeparate: (update, face, mask) => update({ + [face === 1028 ? 2968 : 36005]: mask + }), + stencilFunc: (update, func, ref, mask) => update({ + [2962]: func, + [2967]: ref, + [2963]: mask, + [34816]: func, + [36003]: ref, + [36004]: mask + }), + stencilFuncSeparate: (update, face, func, ref, mask) => update({ + [face === 1028 ? 2962 : 34816]: func, + [face === 1028 ? 2967 : 36003]: ref, + [face === 1028 ? 2963 : 36004]: mask + }), + stencilOp: (update, fail, zfail, zpass) => update({ + [2964]: fail, + [2965]: zfail, + [2966]: zpass, + [34817]: fail, + [34818]: zfail, + [34819]: zpass + }), + stencilOpSeparate: (update, face, fail, zfail, zpass) => update({ + [face === 1028 ? 2964 : 34817]: fail, + [face === 1028 ? 2965 : 34818]: zfail, + [face === 1028 ? 2966 : 34819]: zpass + }), + viewport: (update, x, y, width, height) => update({ + [2978]: [x, y, width, height] + }) +}; +var isEnabled = (gl, key) => gl.isEnabled(key); +var GL_PARAMETER_GETTERS = { + [3042]: isEnabled, + [2884]: isEnabled, + [2929]: isEnabled, + [3024]: isEnabled, + [32823]: isEnabled, + [32926]: isEnabled, + [32928]: isEnabled, + [3089]: isEnabled, + [2960]: isEnabled, + [35977]: isEnabled +}; +var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([ + 34016, + 36388, + 36387, + 35983, + 35368, + 34965, + 35739, + 35738, + 3074, + 34853, + 34854, + 34855, + 34856, + 34857, + 34858, + 34859, + 34860, + 34861, + 34862, + 34863, + 34864, + 34865, + 34866, + 34867, + 34868, + 35097, + 32873, + 35869, + 32874, + 34068 +]); + +// node_modules/@luma.gl/webgl/dist/context/parameters/unified-parameter-api.js +function setGLParameters(gl, parameters) { + if (isObjectEmpty2(parameters)) { + return; + } + const compositeSetters = {}; + for (const key in parameters) { + const glConstant = Number(key); + const setter = GL_PARAMETER_SETTERS[key]; + if (setter) { + if (typeof setter === "string") { + compositeSetters[setter] = true; + } else { + setter(gl, parameters[key], glConstant); + } + } + } + const cache3 = gl.state && gl.state.cache; + if (cache3) { + for (const key in compositeSetters) { + const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key]; + compositeSetter(gl, parameters, cache3); + } + } +} +function getGLParameters(gl, parameters = GL_PARAMETER_DEFAULTS) { + if (typeof parameters === "number") { + const key = parameters; + const getter = GL_PARAMETER_GETTERS[key]; + return getter ? getter(gl, key) : gl.getParameter(key); + } + const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters); + const state = {}; + for (const key of parameterKeys) { + const getter = GL_PARAMETER_GETTERS[key]; + state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key)); + } + return state; +} +function resetGLParameters(gl) { + setGLParameters(gl, GL_PARAMETER_DEFAULTS); +} +function isObjectEmpty2(object) { + for (const key in object) { + return false; + } + return true; +} + +// node_modules/@luma.gl/webgl/dist/context/state-tracker/deep-array-equal.js +function deepArrayEqual(x, y) { + if (x === y) { + return true; + } + const isArrayX = Array.isArray(x) || ArrayBuffer.isView(x); + const isArrayY = Array.isArray(y) || ArrayBuffer.isView(y); + if (isArrayX && isArrayY && x.length === y.length) { + for (let i = 0; i < x.length; ++i) { + if (x[i] !== y[i]) { + return false; + } + } + return true; + } + return false; +} + +// node_modules/@luma.gl/webgl/dist/context/state-tracker/track-context-state.js +var GLState = class { + gl; + program = null; + stateStack = []; + enable = true; + cache; + log; + constructor(gl, { + copyState = false, + // Copy cache from params (slow) or initialize from WebGL defaults (fast) + log: log4 = () => { + } + // Logging function, called when gl parameter change calls are actually issued + } = {}) { + this.gl = gl; + this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS); + this.log = log4; + this._updateCache = this._updateCache.bind(this); + Object.seal(this); + } + push(values = {}) { + this.stateStack.push({}); + } + pop() { + assert6(this.stateStack.length > 0); + const oldValues = this.stateStack[this.stateStack.length - 1]; + setGLParameters(this.gl, oldValues); + this.stateStack.pop(); + } + /** + // interceptor for context set functions - update our cache and our stack + // values (Object) - the key values for this setter + * @param values + * @returns + */ + _updateCache(values) { + let valueChanged = false; + let oldValue; + const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null; + for (const key in values) { + assert6(key !== void 0); + const value = values[key]; + const cached = this.cache[key]; + if (!deepArrayEqual(value, cached)) { + valueChanged = true; + oldValue = cached; + if (oldValues && !(key in oldValues)) { + oldValues[key] = cached; + } + this.cache[key] = value; + } + } + return { valueChanged, oldValue }; + } +}; +function getContextState(gl) { + return gl.state; +} +function trackContextState(gl, options) { + const { enable: enable2 = true, copyState } = options; + assert6(copyState !== void 0); + if (!gl.state) { + gl.state = new GLState(gl, { copyState }); + installProgramSpy(gl); + for (const key in GL_HOOKED_SETTERS) { + const setter = GL_HOOKED_SETTERS[key]; + installSetterSpy(gl, key, setter); + } + installGetterOverride(gl, "getParameter"); + installGetterOverride(gl, "isEnabled"); + } + const glState = getContextState(gl); + glState.enable = enable2; + return gl; +} +function pushContextState(gl) { + let glState = getContextState(gl); + if (!glState) { + trackContextState(gl, { copyState: false }); + glState = getContextState(gl); + } + glState.push(); +} +function popContextState(gl) { + const glState = getContextState(gl); + assert6(glState); + glState.pop(); +} +function installGetterOverride(gl, functionName) { + const originalGetterFunc = gl[functionName].bind(gl); + gl[functionName] = function get(pname) { + if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) { + return originalGetterFunc(pname); + } + const glState = getContextState(gl); + if (!(pname in glState.cache)) { + glState.cache[pname] = originalGetterFunc(pname); + } + return glState.enable ? ( + // Call the getter the params so that it can e.g. serve from a cache + glState.cache[pname] + ) : ( + // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext + originalGetterFunc(pname) + ); + }; + Object.defineProperty(gl[functionName], "name", { + value: `${functionName}-from-cache`, + configurable: false + }); +} +function installSetterSpy(gl, functionName, setter) { + if (!gl[functionName]) { + return; + } + const originalSetterFunc = gl[functionName].bind(gl); + gl[functionName] = function set11(...params) { + const glState = getContextState(gl); + const { valueChanged, oldValue } = setter(glState._updateCache, ...params); + if (valueChanged) { + originalSetterFunc(...params); + } + return oldValue; + }; + Object.defineProperty(gl[functionName], "name", { + value: `${functionName}-to-cache`, + configurable: false + }); +} +function installProgramSpy(gl) { + const originalUseProgram = gl.useProgram.bind(gl); + gl.useProgram = function useProgramLuma(handle) { + const glState = getContextState(gl); + if (glState.program !== handle) { + originalUseProgram(handle); + glState.program = handle; + } + }; +} + +// node_modules/@luma.gl/webgl/dist/context/helpers/create-browser-context.js +var DEFAULT_CONTEXT_PROPS = { + powerPreference: "high-performance", + // After all, most apps are using WebGL for performance reasons + // eslint-disable-next-line no-console + onContextLost: () => console.error("WebGL context lost"), + // eslint-disable-next-line no-console + onContextRestored: () => console.info("WebGL context restored") +}; +function createBrowserContext(canvas2, props) { + props = { ...DEFAULT_CONTEXT_PROPS, ...props }; + let errorMessage = null; + const onCreateError = (error) => errorMessage = error.statusMessage || errorMessage; + canvas2.addEventListener("webglcontextcreationerror", onCreateError, false); + let gl = null; + gl ||= canvas2.getContext("webgl2", props); + canvas2.removeEventListener("webglcontextcreationerror", onCreateError, false); + if (!gl) { + throw new Error(`Failed to create WebGL context: ${errorMessage || "Unknown error"}`); + } + if (props.onContextLost) { + const { onContextLost } = props; + canvas2.addEventListener("webglcontextlost", (event) => onContextLost(event), false); + } + if (props.onContextRestored) { + const { onContextRestored } = props; + canvas2.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false); + } + return gl; +} + +// node_modules/@luma.gl/webgl/dist/context/helpers/webgl-extensions.js +function getWebGLExtension(gl, name2, extensions) { + if (extensions[name2] === void 0) { + extensions[name2] = gl.getExtension(name2) || null; + } + return extensions[name2]; +} + +// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-info.js +function getDeviceInfo(gl, extensions) { + const vendorMasked = gl.getParameter(7936); + const rendererMasked = gl.getParameter(7937); + getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions); + const ext = extensions.WEBGL_debug_renderer_info; + const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936); + const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937); + const vendor = vendorUnmasked || vendorMasked; + const renderer = rendererUnmasked || rendererMasked; + const version2 = gl.getParameter(7938); + const gpu = identifyGPUVendor(vendor, renderer); + const gpuBackend = identifyGPUBackend(vendor, renderer); + const gpuType = identifyGPUType(vendor, renderer); + const shadingLanguage = "glsl"; + const shadingLanguageVersion = 300; + return { + type: "webgl", + gpu, + gpuType, + gpuBackend, + vendor, + renderer, + version: version2, + shadingLanguage, + shadingLanguageVersion + }; +} +function identifyGPUVendor(vendor, renderer) { + if (/NVIDIA/i.exec(vendor) || /NVIDIA/i.exec(renderer)) { + return "nvidia"; + } + if (/INTEL/i.exec(vendor) || /INTEL/i.exec(renderer)) { + return "intel"; + } + if (/Apple/i.exec(vendor) || /Apple/i.exec(renderer)) { + return "apple"; + } + if (/AMD/i.exec(vendor) || /AMD/i.exec(renderer) || /ATI/i.exec(vendor) || /ATI/i.exec(renderer)) { + return "amd"; + } + if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) { + return "software"; + } + return "unknown"; +} +function identifyGPUBackend(vendor, renderer) { + if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) { + return "metal"; + } + if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) { + return "opengl"; + } + return "unknown"; +} +function identifyGPUType(vendor, renderer) { + if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) { + return "cpu"; + } + const gpuVendor = identifyGPUVendor(vendor, renderer); + switch (gpuVendor) { + case "intel": + return "integrated"; + case "software": + return "cpu"; + case "unknown": + return "unknown"; + default: + return "discrete"; + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/converters/vertex-formats.js +function getGLFromVertexType(dataType) { + switch (dataType) { + case "uint8": + return 5121; + case "sint8": + return 5120; + case "unorm8": + return 5121; + case "snorm8": + return 5120; + case "uint16": + return 5123; + case "sint16": + return 5122; + case "unorm16": + return 5123; + case "snorm16": + return 5122; + case "uint32": + return 5125; + case "sint32": + return 5124; + case "float16": + return 5131; + case "float32": + return 5126; + } + throw new Error(String(dataType)); +} + +// node_modules/@luma.gl/webgl/dist/adapter/converters/texture-formats.js +var texture_compression_bc = "texture-compression-bc"; +var texture_compression_astc = "texture-compression-astc"; +var texture_compression_etc2 = "texture-compression-etc2"; +var texture_compression_etc1_webgl = "texture-compression-etc1-webgl"; +var texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl"; +var texture_compression_atc_webgl = "texture-compression-atc-webgl"; +var float32_renderable = "float32-renderable-webgl"; +var float16_renderable = "float16-renderable-webgl"; +var rgb9e5ufloat_renderable = "rgb9e5ufloat_renderable-webgl"; +var snorm8_renderable = "snorm8-renderable-webgl"; +var norm16_renderable = "norm16-renderable-webgl"; +var snorm16_renderable = "snorm16-renderable-webgl"; +var float32_filterable = "float32-filterable"; +var float16_filterable = "float16-filterable-webgl"; +var X_S3TC = "WEBGL_compressed_texture_s3tc"; +var X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb"; +var X_RGTC = "EXT_texture_compression_rgtc"; +var X_BPTC = "EXT_texture_compression_bptc"; +var X_ETC2 = "WEBGL_compressed_texture_etc"; +var X_ASTC = "WEBGL_compressed_texture_astc"; +var X_ETC1 = "WEBGL_compressed_texture_etc1"; +var X_PVRTC = "WEBGL_compressed_texture_pvrtc"; +var X_ATC = "WEBGL_compressed_texture_atc"; +var EXT_texture_norm16 = "EXT_texture_norm16"; +var EXT_render_snorm = "EXT_render_snorm"; +var EXT_color_buffer_float = "EXT_color_buffer_float"; +var TEXTURE_FEATURES = { + "float32-renderable-webgl": ["EXT_color_buffer_float"], + "float16-renderable-webgl": ["EXT_color_buffer_half_float"], + "rgb9e5ufloat_renderable-webgl": ["WEBGL_render_shared_exponent"], + "snorm8-renderable-webgl": [EXT_render_snorm], + "norm16-renderable-webgl": [EXT_texture_norm16], + "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm], + "float32-filterable": ["OES_texture_float_linear"], + "float16-filterable-webgl": ["OES_texture_half_float_linear"], + "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"], + "texture-blend-float-webgl": ["EXT_float_blend"], + "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC], + // 'texture-compression-bc3-srgb-webgl': [X_S3TC_SRGB], + // 'texture-compression-bc3-webgl': [X_S3TC], + "texture-compression-bc5-webgl": [X_RGTC], + "texture-compression-bc7-webgl": [X_BPTC], + "texture-compression-etc2": [X_ETC2], + "texture-compression-astc": [X_ASTC], + "texture-compression-etc1-webgl": [X_ETC1], + "texture-compression-pvrtc-webgl": [X_PVRTC], + "texture-compression-atc-webgl": [X_ATC] +}; +function isTextureFeature(feature) { + return feature in TEXTURE_FEATURES; +} +function checkTextureFeature(gl, feature, extensions) { + const textureExtensions = TEXTURE_FEATURES[feature] || []; + return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions)); +} +var TEXTURE_FORMATS = { + // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants + "rgb8unorm-unsized": { + gl: 6407, + b: 4, + c: 2, + bpp: 4, + dataFormat: 6407, + types: [5121, 33635] + }, + "rgba8unorm-unsized": { + gl: 6408, + b: 4, + c: 2, + bpp: 4, + dataFormat: 6408, + types: [5121, 32819, 32820] + }, + // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4}, + // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB}, + // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB}, + // 8-bit formats + "r8unorm": { gl: 33321, b: 1, c: 1, rb: true }, + "r8snorm": { gl: 36756, b: 1, c: 1, render: snorm8_renderable }, + "r8uint": { gl: 33330, b: 1, c: 1, rb: true }, + "r8sint": { gl: 33329, b: 1, c: 1, rb: true }, + // 16-bit formats + "rg8unorm": { gl: 33323, b: 2, c: 2, rb: true }, + "rg8snorm": { gl: 36757, b: 2, c: 2, render: snorm8_renderable }, + "rg8uint": { gl: 33336, b: 2, c: 2, rb: true }, + "rg8sint": { gl: 33335, b: 2, c: 2, rb: true }, + "r16uint": { gl: 33332, b: 2, c: 1, rb: true }, + "r16sint": { gl: 33331, b: 2, c: 1, rb: true }, + "r16float": { gl: 33325, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", rb: true }, + "r16unorm-webgl": { gl: 33322, b: 2, c: 1, f: norm16_renderable, rb: true }, + "r16snorm-webgl": { gl: 36760, b: 2, c: 1, f: snorm16_renderable }, + // Packed 16-bit formats + "rgba4unorm-webgl": { gl: 32854, b: 2, c: 4, wgpu: false, rb: true }, + "rgb565unorm-webgl": { gl: 36194, b: 2, c: 4, wgpu: false, rb: true }, + "rgb5a1unorm-webgl": { gl: 32855, b: 2, c: 4, wgpu: false, rb: true }, + // 24-bit formats + "rgb8unorm-webgl": { gl: 32849, b: 3, c: 3, wgpu: false }, + "rgb8snorm-webgl": { gl: 36758, b: 3, c: 3, wgpu: false }, + // 32-bit formats + "rgba8unorm": { gl: 32856, b: 4, c: 2, bpp: 4 }, + "rgba8unorm-srgb": { gl: 35907, b: 4, c: 4, bpp: 4 }, + "rgba8snorm": { gl: 36759, b: 4, c: 4, render: snorm8_renderable }, + "rgba8uint": { gl: 36220, b: 4, c: 4, bpp: 4 }, + "rgba8sint": { gl: 36238, b: 4, c: 4, bpp: 4 }, + // reverse colors, webgpu only + "bgra8unorm": { b: 4, c: 4 }, + "bgra8unorm-srgb": { b: 4, c: 4 }, + "rg16uint": { gl: 33338, b: 4, c: 1, bpp: 4 }, + "rg16sint": { gl: 33337, b: 4, c: 2, bpp: 4 }, + // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension + "rg16float": { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true }, + "rg16unorm-webgl": { gl: 33324, b: 2, c: 2, render: norm16_renderable }, + "rg16snorm-webgl": { gl: 36761, b: 2, c: 2, render: snorm16_renderable }, + "r32uint": { gl: 33334, b: 4, c: 1, bpp: 4, rb: true }, + "r32sint": { gl: 33333, b: 4, c: 1, bpp: 4, rb: true }, + "r32float": { gl: 33326, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable }, + // Packed 32-bit formats + "rgb9e5ufloat": { gl: 35901, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable }, + // , filter: true}, + "rg11b10ufloat": { gl: 35898, b: 4, c: 3, p: 1, render: float32_renderable, rb: true }, + "rgb10a2unorm": { gl: 32857, b: 4, c: 4, p: 1, rb: true }, + "rgb10a2uint-webgl": { b: 4, c: 4, gl: 36975, p: 1, wgpu: false, bpp: 4, rb: true }, + // 48-bit formats + "rgb16unorm-webgl": { gl: 32852, b: 2, c: 3, f: norm16_renderable }, + // rgb not renderable + "rgb16snorm-webgl": { gl: 36762, b: 2, c: 3, f: norm16_renderable }, + // rgb not renderable + // 64-bit formats + "rg32uint": { gl: 33340, b: 8, c: 2, rb: true }, + "rg32sint": { gl: 33339, b: 8, c: 2, rb: true }, + "rg32float": { gl: 33328, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true }, + "rgba16uint": { gl: 36214, b: 8, c: 4, rb: true }, + "rgba16sint": { gl: 36232, b: 8, c: 4, rb: true }, + "rgba16float": { gl: 34842, b: 8, c: 4, render: float16_renderable, filter: float16_filterable }, + "rgba16unorm-webgl": { gl: 32859, b: 2, c: 4, render: norm16_renderable, rb: true }, + "rgba16snorm-webgl": { gl: 36763, b: 2, c: 4, render: snorm16_renderable }, + // 96-bit formats (deprecated!) + "rgb32float-webgl": { + gl: 34837, + render: float32_renderable, + filter: float32_filterable, + gl2ext: EXT_color_buffer_float, + dataFormat: 6407, + types: [5126] + }, + // 128-bit formats + "rgba32uint": { gl: 36208, b: 16, c: 4, rb: true }, + "rgba32sint": { gl: 36226, b: 16, c: 4, rb: true }, + "rgba32float": { gl: 34836, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, rb: true }, + // Depth and stencil formats + "stencil8": { gl: 36168, b: 1, c: 1, attachment: 36128, rb: true }, + // 8 stencil bits + "depth16unorm": { + gl: 33189, + b: 2, + c: 1, + attachment: 36096, + dataFormat: 6402, + types: [5123], + rb: true + }, + // 16 depth bits + "depth24plus": { + gl: 33190, + b: 3, + c: 1, + attachment: 36096, + dataFormat: 6402, + types: [5125] + }, + "depth32float": { + gl: 36012, + b: 4, + c: 1, + attachment: 36096, + dataFormat: 6402, + types: [5126], + rb: true + }, + // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value. + "depth24plus-stencil8": { + gl: 35056, + b: 4, + c: 2, + p: 1, + attachment: 33306, + rb: true, + depthTexture: true, + dataFormat: 34041, + types: [34042] + }, + // "depth24unorm-stencil8" feature + "depth24unorm-stencil8": { + gl: 35056, + b: 4, + c: 2, + p: 1, + attachment: 33306, + dataFormat: 34041, + types: [34042], + rb: true + }, + // "depth32float-stencil8" feature - TODO below is render buffer only? + "depth32float-stencil8": { + gl: 36013, + b: 5, + c: 2, + p: 1, + attachment: 33306, + dataFormat: 34041, + types: [36269], + rb: true + }, + // BC compressed formats: check device.features.has("texture-compression-bc"); + "bc1-rgb-unorm-webgl": { gl: 33776, x: X_S3TC, f: texture_compression_bc }, + "bc1-rgb-unorm-srgb-webgl": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc }, + "bc1-rgba-unorm": { gl: 33777, x: X_S3TC, f: texture_compression_bc }, + "bc1-rgba-unorm-srgb": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc }, + "bc2-rgba-unorm": { gl: 33778, x: X_S3TC, f: texture_compression_bc }, + "bc2-rgba-unorm-srgb": { gl: 35918, x: X_S3TC_SRGB, f: texture_compression_bc }, + "bc3-rgba-unorm": { gl: 33779, x: X_S3TC, f: texture_compression_bc }, + "bc3-rgba-unorm-srgb": { gl: 35919, x: X_S3TC_SRGB, f: texture_compression_bc }, + "bc4-r-unorm": { gl: 36283, x: X_RGTC, f: texture_compression_bc }, + "bc4-r-snorm": { gl: 36284, x: X_RGTC, f: texture_compression_bc }, + "bc5-rg-unorm": { gl: 36285, x: X_RGTC, f: texture_compression_bc }, + "bc5-rg-snorm": { gl: 36286, x: X_RGTC, f: texture_compression_bc }, + "bc6h-rgb-ufloat": { gl: 36495, x: X_BPTC, f: texture_compression_bc }, + "bc6h-rgb-float": { gl: 36494, x: X_BPTC, f: texture_compression_bc }, + "bc7-rgba-unorm": { gl: 36492, x: X_BPTC, f: texture_compression_bc }, + "bc7-rgba-unorm-srgb": { gl: 36493, x: X_BPTC, f: texture_compression_bc }, + // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2") + // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression + "etc2-rgb8unorm": { gl: 37492, f: texture_compression_etc2 }, + "etc2-rgb8unorm-srgb": { gl: 37494, f: texture_compression_etc2 }, + "etc2-rgb8a1unorm": { gl: 37496, f: texture_compression_etc2 }, + "etc2-rgb8a1unorm-srgb": { gl: 37497, f: texture_compression_etc2 }, + "etc2-rgba8unorm": { gl: 37493, f: texture_compression_etc2 }, + "etc2-rgba8unorm-srgb": { gl: 37495, f: texture_compression_etc2 }, + "eac-r11unorm": { gl: 37488, f: texture_compression_etc2 }, + "eac-r11snorm": { gl: 37489, f: texture_compression_etc2 }, + "eac-rg11unorm": { gl: 37490, f: texture_compression_etc2 }, + "eac-rg11snorm": { gl: 37491, f: texture_compression_etc2 }, + // X_ASTC compressed formats: device.features.has("texture-compression-astc") + "astc-4x4-unorm": { gl: 37808, f: texture_compression_astc }, + "astc-4x4-unorm-srgb": { gl: 37840, f: texture_compression_astc }, + "astc-5x4-unorm": { gl: 37809, f: texture_compression_astc }, + "astc-5x4-unorm-srgb": { gl: 37841, f: texture_compression_astc }, + "astc-5x5-unorm": { gl: 37810, f: texture_compression_astc }, + "astc-5x5-unorm-srgb": { gl: 37842, f: texture_compression_astc }, + "astc-6x5-unorm": { gl: 37811, f: texture_compression_astc }, + "astc-6x5-unorm-srgb": { gl: 37843, f: texture_compression_astc }, + "astc-6x6-unorm": { gl: 37812, f: texture_compression_astc }, + "astc-6x6-unorm-srgb": { gl: 37844, f: texture_compression_astc }, + "astc-8x5-unorm": { gl: 37813, f: texture_compression_astc }, + "astc-8x5-unorm-srgb": { gl: 37845, f: texture_compression_astc }, + "astc-8x6-unorm": { gl: 37814, f: texture_compression_astc }, + "astc-8x6-unorm-srgb": { gl: 37846, f: texture_compression_astc }, + "astc-8x8-unorm": { gl: 37815, f: texture_compression_astc }, + "astc-8x8-unorm-srgb": { gl: 37847, f: texture_compression_astc }, + "astc-10x5-unorm": { gl: 37819, f: texture_compression_astc }, + "astc-10x5-unorm-srgb": { gl: 37851, f: texture_compression_astc }, + "astc-10x6-unorm": { gl: 37817, f: texture_compression_astc }, + "astc-10x6-unorm-srgb": { gl: 37849, f: texture_compression_astc }, + "astc-10x8-unorm": { gl: 37818, f: texture_compression_astc }, + "astc-10x8-unorm-srgb": { gl: 37850, f: texture_compression_astc }, + "astc-10x10-unorm": { gl: 37819, f: texture_compression_astc }, + "astc-10x10-unorm-srgb": { gl: 37851, f: texture_compression_astc }, + "astc-12x10-unorm": { gl: 37820, f: texture_compression_astc }, + "astc-12x10-unorm-srgb": { gl: 37852, f: texture_compression_astc }, + "astc-12x12-unorm": { gl: 37821, f: texture_compression_astc }, + "astc-12x12-unorm-srgb": { gl: 37853, f: texture_compression_astc }, + // WEBGL_compressed_texture_pvrtc + "pvrtc-rgb4unorm-webgl": { gl: 35840, f: texture_compression_pvrtc_webgl }, + "pvrtc-rgba4unorm-webgl": { gl: 35842, f: texture_compression_pvrtc_webgl }, + "pvrtc-rbg2unorm-webgl": { gl: 35841, f: texture_compression_pvrtc_webgl }, + "pvrtc-rgba2unorm-webgl": { gl: 35843, f: texture_compression_pvrtc_webgl }, + // WEBGL_compressed_texture_etc1 + "etc1-rbg-unorm-webgl": { gl: 36196, f: texture_compression_etc1_webgl }, + // WEBGL_compressed_texture_atc + "atc-rgb-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl }, + "atc-rgba-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl }, + "atc-rgbai-unorm-webgl": { gl: 34798, f: texture_compression_atc_webgl } +}; +var DATA_FORMAT_CHANNELS = { + [6403]: 1, + [36244]: 1, + [33319]: 2, + [33320]: 2, + [6407]: 3, + [36248]: 3, + [6408]: 4, + [36249]: 4, + [6402]: 1, + [34041]: 1, + [6406]: 1, + [6409]: 1, + [6410]: 2 +}; +var TYPE_SIZES3 = { + [5126]: 4, + [5125]: 4, + [5124]: 4, + [5123]: 2, + [5122]: 2, + [5131]: 2, + [5120]: 1, + [5121]: 1 +}; +function isTextureFormatSupported(gl, format, extensions) { + const info = TEXTURE_FORMATS[format]; + if (!info) { + return false; + } + if (info.gl === void 0) { + return false; + } + const extension = info.x || info.gl2ext; + if (extension) { + return Boolean(getWebGLExtension(gl, extension, extensions)); + } + return true; +} +function convertTextureFormatToGL(format) { + const formatInfo = TEXTURE_FORMATS[format]; + const webglFormat = formatInfo?.gl; + if (webglFormat === void 0) { + throw new Error(`Unsupported texture format ${format}`); + } + return webglFormat; +} +function isTextureFormatFilterable(gl, format, extensions) { + if (!isTextureFormatSupported(gl, format, extensions)) { + return false; + } + if (format.startsWith("depth") || format.startsWith("stencil")) { + return false; + } + try { + const decoded = decodeTextureFormat(format); + if (decoded.signed) { + return false; + } + } catch { + return false; + } + if (format.endsWith("32float")) { + return Boolean(getWebGLExtension(gl, "OES_texture_float_linear, extensions", extensions)); + } + if (format.endsWith("16float")) { + return Boolean(getWebGLExtension(gl, "OES_texture_half_float_linear, extensions", extensions)); + } + return true; +} +function isTextureFormatRenderable(gl, format, extensions) { + if (!isTextureFormatSupported(gl, format, extensions)) { + return false; + } + if (typeof format === "number") { + return false; + } + return true; +} +function getWebGLTextureParameters(format) { + const formatData = TEXTURE_FORMATS[format]; + const webglFormat = convertTextureFormatToGL(format); + const decoded = decodeTextureFormat(format); + return { + format: webglFormat, + dataFormat: formatData?.dataFormat || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat), + // depth formats don't have a type + type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : formatData?.types?.[0] || 5121, + // @ts-expect-error + compressed: decoded.compressed + }; +} +function getDepthStencilAttachmentWebGL(format) { + const info = TEXTURE_FORMATS[format]; + if (!info?.attachment) { + throw new Error(`${format} is not a depth stencil format`); + } + return info.attachment; +} +function getTextureFormatBytesPerPixel(format) { + const params = getWebGLTextureParameters(format); + const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4; + const channelSize = TYPE_SIZES3[params.type] || 1; + return channels * channelSize; +} +function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) { + if (format === 6408 || format === 6407) { + return format; + } + switch (dataFormat) { + case "r": + return integer && !normalized ? 36244 : 6403; + case "rg": + return integer && !normalized ? 33320 : 33319; + case "rgb": + return integer && !normalized ? 36248 : 6407; + case "rgba": + return integer && !normalized ? 36249 : 6408; + default: + return 6408; + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-features.js +var WEBGL_FEATURES = { + // optional WebGPU features + "depth-clip-control": "EXT_depth_clamp", + // TODO these seem subtly different + // 'timestamp-query' // GPUQueryType "timestamp-query" + // "indirect-first-instance" + // Textures are handled by getTextureFeatures() + // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8' + // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8' + // optional WebGL features + "timer-query-webgl": "EXT_disjoint_timer_query_webgl2", + "compilation-status-async-webgl": "KHR_parallel_shader_compile", + "polygon-mode-webgl": "WEBGL_polygon_mode", + "provoking-vertex-webgl": "WEBGL_provoking_vertex", + "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance", + "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation", + "shader-conservative-depth-webgl": "EXT_conservative_depth" + // Textures are handled by getTextureFeatures() +}; +var WebGLDeviceFeatures = class extends DeviceFeatures { + gl; + extensions; + testedFeatures = /* @__PURE__ */ new Set(); + constructor(gl, extensions, disabledFeatures) { + super([], disabledFeatures); + this.gl = gl; + this.extensions = extensions; + getWebGLExtension(gl, "EXT_color_buffer_float", extensions); + } + *[Symbol.iterator]() { + const features = this.getFeatures(); + for (const feature of features) { + if (this.has(feature)) { + yield feature; + } + } + return []; + } + has(feature) { + if (this.disabledFeatures[feature]) { + return false; + } + if (!this.testedFeatures.has(feature)) { + this.testedFeatures.add(feature); + if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) { + this.features.add(feature); + } + if (this.getWebGLFeature(feature)) { + this.features.add(feature); + } + } + return this.features.has(feature); + } + // FOR DEVICE + initializeFeatures() { + const features = this.getFeatures().filter((feature) => feature !== "polygon-mode-webgl"); + for (const feature of features) { + this.has(feature); + } + } + // IMPLEMENTATION + getFeatures() { + return [...Object.keys(WEBGL_FEATURES), ...Object.keys(TEXTURE_FEATURES)]; + } + /** Extract all WebGL features */ + getWebGLFeature(feature) { + const featureInfo = WEBGL_FEATURES[feature]; + const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo); + return isSupported; + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-limits.js +var WebGLDeviceLimits = class extends DeviceLimits { + get maxTextureDimension1D() { + return 0; + } + // WebGL does not support 1D textures + get maxTextureDimension2D() { + return this.getParameter(3379); + } + get maxTextureDimension3D() { + return this.getParameter(32883); + } + get maxTextureArrayLayers() { + return this.getParameter(35071); + } + get maxBindGroups() { + return 0; + } + get maxDynamicUniformBuffersPerPipelineLayout() { + return 0; + } + // TBD + get maxDynamicStorageBuffersPerPipelineLayout() { + return 0; + } + // TBD + get maxSampledTexturesPerShaderStage() { + return this.getParameter(35660); + } + // ) TBD + get maxSamplersPerShaderStage() { + return this.getParameter(35661); + } + get maxStorageBuffersPerShaderStage() { + return 0; + } + // TBD + get maxStorageTexturesPerShaderStage() { + return 0; + } + // TBD + get maxUniformBuffersPerShaderStage() { + return this.getParameter(35375); + } + get maxUniformBufferBindingSize() { + return this.getParameter(35376); + } + get maxStorageBufferBindingSize() { + return 0; + } + get minUniformBufferOffsetAlignment() { + return this.getParameter(35380); + } + get minStorageBufferOffsetAlignment() { + return 0; + } + get maxVertexBuffers() { + return 16; + } + // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284 + get maxVertexAttributes() { + return this.getParameter(34921); + } + get maxVertexBufferArrayStride() { + return 2048; + } + // TBD, this is just the default value from WebGPU + get maxInterStageShaderComponents() { + return this.getParameter(35659); + } + get maxComputeWorkgroupStorageSize() { + return 0; + } + // WebGL does not support compute shaders + get maxComputeInvocationsPerWorkgroup() { + return 0; + } + // WebGL does not support compute shaders + get maxComputeWorkgroupSizeX() { + return 0; + } + // WebGL does not support compute shaders + get maxComputeWorkgroupSizeY() { + return 0; + } + // WebGL does not support compute shaders + get maxComputeWorkgroupSizeZ() { + return 0; + } + // WebGL does not support compute shaders + get maxComputeWorkgroupsPerDimension() { + return 0; + } + // WebGL does not support compute shaders + // PRIVATE + gl; + limits = {}; + constructor(gl) { + super(); + this.gl = gl; + } + getParameter(parameter) { + if (this.limits[parameter] === void 0) { + this.limits[parameter] = this.gl.getParameter(parameter); + } + return this.limits[parameter]; + } +}; + +// node_modules/@luma.gl/webgl/dist/context/state-tracker/with-parameters.js +function withGLParameters(gl, parameters, func) { + if (isObjectEmpty3(parameters)) { + return func(gl); + } + const { nocatch = true } = parameters; + pushContextState(gl); + setGLParameters(gl, parameters); + let value; + if (nocatch) { + value = func(gl); + popContextState(gl); + } else { + try { + value = func(gl); + } finally { + popContextState(gl); + } + } + return value; +} +function isObjectEmpty3(object) { + for (const key in object) { + return false; + } + return true; +} + +// node_modules/@luma.gl/webgl/dist/adapter/converters/device-parameters.js +function withDeviceAndGLParameters(device, parameters, glParameters, func) { + if (isObjectEmpty(parameters)) { + return func(device); + } + const webglDevice = device; + pushContextState(webglDevice.gl); + try { + setDeviceParameters(device, parameters); + setGLParameters(webglDevice.gl, glParameters); + return func(device); + } finally { + popContextState(webglDevice.gl); + } +} +function setDeviceParameters(device, parameters) { + const webglDevice = device; + const { gl } = webglDevice; + if (parameters.cullMode) { + switch (parameters.cullMode) { + case "none": + gl.disable(2884); + break; + case "front": + gl.enable(2884); + gl.cullFace(1028); + break; + case "back": + gl.enable(2884); + gl.cullFace(1029); + break; + } + } + if (parameters.frontFace) { + gl.frontFace(map2("frontFace", parameters.frontFace, { + ccw: 2305, + cw: 2304 + })); + } + if (parameters.unclippedDepth) { + if (device.features.has("depth-clip-control")) { + gl.enable(34383); + } + } + if (parameters.depthBias !== void 0) { + gl.enable(32823); + gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0); + } + if (parameters.provokingVertex) { + if (device.features.has("provoking-vertex-webgl")) { + const extensions = webglDevice.getExtension("WEBGL_provoking_vertex"); + const ext = extensions.WEBGL_provoking_vertex; + const vertex = map2("provokingVertex", parameters.provokingVertex, { + first: 36429, + last: 36430 + }); + ext?.provokingVertexWEBGL(vertex); + } + } + if (parameters.polygonMode || parameters.polygonOffsetLine) { + if (device.features.has("polygon-mode-webgl")) { + if (parameters.polygonMode) { + const extensions = webglDevice.getExtension("WEBGL_polygon_mode"); + const ext = extensions.WEBGL_polygon_mode; + const mode = map2("polygonMode", parameters.polygonMode, { + fill: 6914, + line: 6913 + }); + ext?.polygonModeWEBGL(1028, mode); + ext?.polygonModeWEBGL(1029, mode); + } + if (parameters.polygonOffsetLine) { + gl.enable(10754); + } + } + } + if (device.features.has("shader-clip-cull-distance-webgl")) { + if (parameters.clipDistance0) { + gl.enable(12288); + } + if (parameters.clipDistance1) { + gl.enable(12289); + } + if (parameters.clipDistance2) { + gl.enable(12290); + } + if (parameters.clipDistance3) { + gl.enable(12291); + } + if (parameters.clipDistance4) { + gl.enable(12292); + } + if (parameters.clipDistance5) { + gl.enable(12293); + } + if (parameters.clipDistance6) { + gl.enable(12294); + } + if (parameters.clipDistance7) { + gl.enable(12295); + } + } + if (parameters.depthWriteEnabled !== void 0) { + gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled)); + } + if (parameters.depthCompare) { + parameters.depthCompare !== "always" ? gl.enable(2929) : gl.disable(2929); + gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare)); + } + if (parameters.stencilWriteMask) { + const mask = parameters.stencilWriteMask; + gl.stencilMaskSeparate(1028, mask); + gl.stencilMaskSeparate(1029, mask); + } + if (parameters.stencilReadMask) { + log2.warn("stencilReadMask not supported under WebGL"); + } + if (parameters.stencilCompare) { + const mask = parameters.stencilReadMask || 4294967295; + const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare); + parameters.stencilCompare !== "always" ? gl.enable(2960) : gl.disable(2960); + gl.stencilFuncSeparate(1028, glValue, 0, mask); + gl.stencilFuncSeparate(1029, glValue, 0, mask); + } + if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) { + const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation); + const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation); + const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation); + gl.stencilOpSeparate(1028, sfail, dpfail, dppass); + gl.stencilOpSeparate(1029, sfail, dpfail, dppass); + } + if (parameters.blendColorOperation || parameters.blendAlphaOperation) { + gl.enable(3042); + const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add"); + const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add"); + gl.blendEquationSeparate(colorEquation, alphaEquation); + const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one"); + const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero"); + const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one"); + const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero"); + gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor); + } +} +function convertCompareFunction(parameter, value) { + return map2(parameter, value, { + never: 512, + less: 513, + equal: 514, + "less-equal": 515, + greater: 516, + "not-equal": 517, + "greater-equal": 518, + always: 519 + }); +} +function convertStencilOperation(parameter, value) { + return map2(parameter, value, { + keep: 7680, + zero: 0, + replace: 7681, + invert: 5386, + "increment-clamp": 7682, + "decrement-clamp": 7683, + "increment-wrap": 34055, + "decrement-wrap": 34056 + }); +} +function convertBlendOperationToEquation(parameter, value) { + return map2(parameter, value, { + add: 32774, + subtract: 32778, + "reverse-subtract": 32779, + min: 32775, + max: 32776 + }); +} +function convertBlendFactorToFunction(parameter, value) { + return map2(parameter, value, { + one: 1, + zero: 0, + "src-color": 768, + "one-minus-src-color": 769, + "dst-color": 774, + "one-minus-dst-color": 775, + "src-alpha": 770, + "one-minus-src-alpha": 771, + "dst-alpha": 772, + "one-minus-dst-alpha": 773, + "src-alpha-saturated": 776, + "constant-color": 32769, + "one-minus-constant-color": 32770, + "constant-alpha": 32771, + "one-minus-constant-alpha": 32772 + }); +} +function message(parameter, value) { + return `Illegal parameter ${value} for ${parameter}`; +} +function map2(parameter, value, valueMap) { + if (!(value in valueMap)) { + throw new Error(message(parameter, value)); + } + return valueMap[value]; +} +function mapBoolean(parameter, value) { + return value; +} + +// node_modules/@luma.gl/webgl/dist/adapter/converters/sampler-parameters.js +function convertSamplerParametersToWebGL(props) { + const params = {}; + if (props.addressModeU) { + params[10242] = convertAddressMode(props.addressModeU); + } + if (props.addressModeV) { + params[10243] = convertAddressMode(props.addressModeV); + } + if (props.addressModeW) { + params[32882] = convertAddressMode(props.addressModeW); + } + if (props.magFilter) { + params[10240] = convertMaxFilterMode(props.magFilter); + } + if (props.minFilter || props.mipmapFilter) { + params[10241] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter); + } + if (props.lodMinClamp !== void 0) { + params[33082] = props.lodMinClamp; + } + if (props.lodMaxClamp !== void 0) { + params[33083] = props.lodMaxClamp; + } + if (props.type === "comparison-sampler") { + params[34892] = 34894; + } + if (props.compare) { + params[34893] = convertCompareFunction("compare", props.compare); + } + if (props.maxAnisotropy) { + params[34046] = props.maxAnisotropy; + } + return params; +} +function convertAddressMode(addressMode) { + switch (addressMode) { + case "clamp-to-edge": + return 33071; + case "repeat": + return 10497; + case "mirror-repeat": + return 33648; + } +} +function convertMaxFilterMode(maxFilter) { + switch (maxFilter) { + case "nearest": + return 9728; + case "linear": + return 9729; + } +} +function convertMinFilterMode(minFilter, mipmapFilter) { + if (!mipmapFilter) { + return convertMaxFilterMode(minFilter); + } + switch (minFilter) { + case "nearest": + return mipmapFilter === "nearest" ? 9984 : 9986; + case "linear": + return mipmapFilter === "nearest" ? 9985 : 9987; + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-buffer.js +var WEBGLBuffer = class extends Buffer2 { + device; + gl; + handle; + /** Target in OpenGL defines the type of buffer */ + glTarget; + /** Usage is a hint on how frequently the buffer will be updates */ + glUsage; + /** Index type is needed when issuing draw calls, so we pre-compute it */ + glIndexType = 5123; + /** Number of bytes allocated on the GPU for this buffer */ + byteLength; + /** Number of bytes used */ + bytesUsed; + constructor(device, props = {}) { + super(device, props); + this.device = device; + this.gl = this.device.gl; + const handle = typeof props === "object" ? props.handle : void 0; + this.handle = handle || this.gl.createBuffer(); + device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data }); + this.glTarget = getWebGLTarget(this.props.usage); + this.glUsage = getWebGLUsage(this.props.usage); + this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123; + if (props.data) { + this._initWithData(props.data, props.byteOffset, props.byteLength); + } else { + this._initWithByteLength(props.byteLength || 0); + } + } + // PRIVATE METHODS + /** Allocate a new buffer and initialize to contents of typed array */ + _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) { + const glTarget = this.glTarget; + this.gl.bindBuffer(glTarget, this.handle); + this.gl.bufferData(glTarget, byteLength, this.glUsage); + this.gl.bufferSubData(glTarget, byteOffset, data); + this.gl.bindBuffer(glTarget, null); + this.bytesUsed = byteLength; + this.byteLength = byteLength; + this._setDebugData(data, byteOffset, byteLength); + this.trackAllocatedMemory(byteLength); + } + // Allocate a GPU buffer of specified size. + _initWithByteLength(byteLength) { + assert6(byteLength >= 0); + let data = byteLength; + if (byteLength === 0) { + data = new Float32Array(0); + } + const glTarget = this.glTarget; + this.gl.bindBuffer(glTarget, this.handle); + this.gl.bufferData(glTarget, data, this.glUsage); + this.gl.bindBuffer(glTarget, null); + this.bytesUsed = byteLength; + this.byteLength = byteLength; + this._setDebugData(null, 0, byteLength); + this.trackAllocatedMemory(byteLength); + return this; + } + destroy() { + if (!this.destroyed && this.handle) { + this.removeStats(); + this.trackDeallocatedMemory(); + this.gl.deleteBuffer(this.handle); + this.destroyed = true; + this.handle = null; + } + } + write(data, byteOffset = 0) { + const srcOffset = 0; + const byteLength = void 0; + const glTarget = 36663; + this.gl.bindBuffer(glTarget, this.handle); + if (srcOffset !== 0 || byteLength !== void 0) { + this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength); + } else { + this.gl.bufferSubData(glTarget, byteOffset, data); + } + this.gl.bindBuffer(glTarget, null); + this._setDebugData(data, byteOffset, data.byteLength); + } + /** Asynchronously read data from the buffer */ + async readAsync(byteOffset = 0, byteLength) { + return this.readSyncWebGL(byteOffset, byteLength); + } + /** Synchronously read data from the buffer. WebGL only. */ + readSyncWebGL(byteOffset = 0, byteLength) { + byteLength = byteLength ?? this.byteLength - byteOffset; + const data = new Uint8Array(byteLength); + const dstOffset = 0; + this.gl.bindBuffer(36662, this.handle); + this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength); + this.gl.bindBuffer(36662, null); + this._setDebugData(data, byteOffset, byteLength); + return data; + } +}; +function getWebGLTarget(usage) { + if (usage & Buffer2.INDEX) { + return 34963; + } + if (usage & Buffer2.VERTEX) { + return 34962; + } + if (usage & Buffer2.UNIFORM) { + return 35345; + } + return 34962; +} +function getWebGLUsage(usage) { + if (usage & Buffer2.INDEX) { + return 35044; + } + if (usage & Buffer2.VERTEX) { + return 35044; + } + if (usage & Buffer2.UNIFORM) { + return 35048; + } + return 35044; +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-sampler.js +var WEBGLSampler = class extends Sampler { + device; + handle; + parameters; + constructor(device, props) { + super(device, props); + this.device = device; + this.parameters = convertSamplerParametersToWebGL(props); + this.handle = this.handle || this.device.gl.createSampler(); + this._setSamplerParameters(this.parameters); + } + destroy() { + if (this.handle) { + this.device.gl.deleteSampler(this.handle); + this.handle = void 0; + } + } + toString() { + return `Sampler(${this.id},${JSON.stringify(this.props)})`; + } + /** Set sampler parameters on the sampler */ + _setSamplerParameters(parameters) { + for (const [pname, value] of Object.entries(parameters)) { + const param = Number(pname); + switch (param) { + case 33082: + case 33083: + this.device.gl.samplerParameterf(this.handle, param, value); + break; + default: + this.device.gl.samplerParameteri(this.handle, param, value); + break; + } + } + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-texture-view.js +var WEBGLTextureView = class extends TextureView { + device; + gl; + handle; + texture; + constructor(device, props) { + super(device, { ...Texture.defaultProps, ...props }); + this.device = device; + this.gl = this.device.gl; + this.handle = null; + this.texture = props.texture; + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-texture.js +var DEFAULT_WEBGL_TEXTURE_PROPS = { + // deprecated + parameters: {}, + pixelStore: {}, + pixels: null, + border: 0, + dataFormat: void 0, + textureUnit: void 0, + target: void 0 +}; +var WEBGLTexture = class _WEBGLTexture extends Texture { + // TODO - remove? + static FACES = [ + 34069, + 34070, + 34071, + 34072, + 34073, + 34074 + ]; + MAX_ATTRIBUTES; + device; + gl; + handle; + // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */ + sampler = void 0; + view = void 0; + // data; + glFormat = void 0; + type = void 0; + dataFormat = void 0; + mipmaps = void 0; + /** + * @note `target` cannot be modified by bind: + * textures are special because when you first bind them to a target, + * they get special information. When you first bind a texture as a + * GL_TEXTURE_2D, you are saying that this texture is a 2D texture. + * And it will always be a 2D texture; this state cannot be changed ever. + * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D; + * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error + * */ + target; + textureUnit = void 0; + /** + * Program.draw() checks the loaded flag of all textures to avoid + * Textures that are still loading from promises + * Set to true as soon as texture has been initialized with valid data + */ + loaded = false; + _video; + constructor(device, props) { + super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props }); + this.device = device; + this.gl = this.device.gl; + this.handle = this.props.handle || this.gl.createTexture(); + this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data }); + this.glFormat = 6408; + this.target = getWebGLTextureTarget(this.props); + this.loaded = false; + if (typeof this.props?.data === "string") { + Object.assign(this.props, { data: loadImage(this.props.data) }); + } + this.initialize(this.props); + Object.seal(this); + } + destroy() { + if (this.handle) { + this.gl.deleteTexture(this.handle); + this.removeStats(); + this.trackDeallocatedMemory("Texture"); + this.destroyed = true; + } + } + toString() { + return `Texture(${this.id},${this.width}x${this.height})`; + } + createView(props) { + return new WEBGLTextureView(this.device, { ...props, texture: this }); + } + // eslint-disable-next-line max-statements + initialize(props = {}) { + if (this.props.dimension === "cube") { + return this.initializeCube(props); + } + let data = props.data; + if (data instanceof Promise) { + data.then((resolvedImageData) => this.initialize(Object.assign({}, props, { + pixels: resolvedImageData, + data: resolvedImageData + }))); + return this; + } + const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement; + if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) { + this._video = null; + data.addEventListener("loadeddata", () => this.initialize(props)); + return this; + } + const { parameters = {} } = props; + const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props; + if (!data) { + data = pixels; + } + let { width, height, dataFormat, type, compressed = false } = props; + const { depth = 0 } = props; + const glFormat = convertTextureFormatToGL(props.format); + ({ width, height, compressed, dataFormat, type } = this._deduceParameters({ + format: props.format, + type, + dataFormat, + compressed, + data, + width, + height + })); + this.width = width; + this.height = height; + this.glFormat = glFormat; + this.type = type; + this.dataFormat = dataFormat; + this.textureUnit = textureUnit; + if (Number.isFinite(this.textureUnit)) { + this.gl.activeTexture(33984 + this.textureUnit); + this.gl.bindTexture(this.target, this.handle); + } + this.mipmaps = mipmaps; + this.setImageData({ + data, + width, + height, + depth, + format: props.format, + type, + dataFormat, + // @ts-expect-error + parameters: pixelStore, + compressed + }); + this.setSampler(props.sampler); + this._setSamplerParameters(parameters); + this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 }); + if (mipmaps && this.device.isTextureFormatFilterable(props.format)) { + this.generateMipmap(); + } + if (isVideo) { + this._video = { + video: data, + parameters, + // @ts-expect-error + lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1 + }; + } + return this; + } + initializeCube(props) { + const { mipmaps = true, parameters = {} } = props; + this.setCubeMapImageData(props).then(() => { + this.loaded = true; + if (mipmaps) { + this.generateMipmap(props); + } + this.setSampler(props.sampler); + this._setSamplerParameters(parameters); + }); + return this; + } + setSampler(sampler = {}) { + let samplerProps; + if (sampler instanceof WEBGLSampler) { + this.sampler = sampler; + samplerProps = sampler.props; + } else { + this.sampler = new WEBGLSampler(this.device, sampler); + samplerProps = sampler; + } + const parameters = convertSamplerParametersToWebGL(samplerProps); + this._setSamplerParameters(parameters); + return this; + } + /** + * If size has changed, reinitializes with current format + * @note note clears image and mipmaps + */ + resize(options) { + const { height, width, mipmaps = false } = options; + if (width !== this.width || height !== this.height) { + return this.initialize({ + width, + height, + format: this.format, + type: this.type, + dataFormat: this.dataFormat, + mipmaps + }); + } + return this; + } + /** Update external texture (video frame) */ + update() { + if (this._video) { + const { video, parameters, lastTime } = this._video; + if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) { + return; + } + this.setSubImageData({ + data: video, + parameters + }); + if (this.mipmaps) { + this.generateMipmap(); + } + this._video.lastTime = video.currentTime; + } + } + // Call to regenerate mipmaps after modifying texture(s) + generateMipmap(params = {}) { + this.mipmaps = true; + this.gl.bindTexture(this.target, this.handle); + withGLParameters(this.gl, params, () => { + this.gl.generateMipmap(this.target); + }); + this.gl.bindTexture(this.target, null); + return this; + } + /* + * Allocates storage + * @param {*} pixels - + * null - create empty texture of specified format + * Typed array - init from image data in typed array + * Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer + * HTMLImageElement|Image - Inits with content of image. Auto width/height + * HTMLCanvasElement - Inits with contents of canvas. Auto width/height + * HTMLVideoElement - Creates video texture. Auto width/height + * + * @param width - + * @param height - + * @param mipMapLevel - + * @param {GLenum} format - format of image data. + * @param {GLenum} type + * - format of array (autodetect from type) or + * - (WEBGL2) format of buffer + * @param {Number} offset - (WEBGL2) offset from start of buffer + * @parameters - temporary settings to be applied, can be used to supply pixel store settings. + */ + // eslint-disable-next-line max-statements, complexity + setImageData(options) { + if (this.props.dimension === "3d" || this.props.dimension === "2d-array") { + return this.setImageData3D(options); + } + this.trackDeallocatedMemory("Texture"); + const { target = this.target, pixels = null, level = 0, glFormat = this.glFormat, offset = 0, parameters = {} } = options; + let { data = null, type = this.type, width = this.width, height = this.height, dataFormat = this.dataFormat, compressed = false } = options; + if (!data) { + data = pixels; + } + ({ type, dataFormat, compressed, width, height } = this._deduceParameters({ + format: this.props.format, + type, + dataFormat, + compressed, + data, + width, + height + })); + const { gl } = this; + gl.bindTexture(this.target, this.handle); + let dataType = null; + ({ data, dataType } = this._getDataType({ data, compressed })); + withGLParameters(this.gl, parameters, () => { + switch (dataType) { + case "null": + gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data); + break; + case "typed-array": + gl.texImage2D( + target, + level, + glFormat, + width, + height, + 0, + // border (must be 0) + dataFormat, + type, + data, + offset + ); + break; + case "buffer": + this.device.gl.bindBuffer(35052, data.handle || data); + this.device.gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset); + this.device.gl.bindBuffer(35052, null); + break; + case "browser-object": + gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data); + break; + case "compressed": + for (const [levelIndex, levelData] of data.entries()) { + gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data); + } + break; + default: + assert6(false, "Unknown image data type"); + } + }); + if (data && data.byteLength) { + this.trackAllocatedMemory(data.byteLength, "Texture"); + } else { + const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format); + this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture"); + } + this.loaded = true; + return this; + } + /** + * Redefines an area of an existing texture + * Note: does not allocate storage + * Redefines an area of an existing texture + */ + setSubImageData({ target = this.target, pixels = null, data = null, x = 0, y = 0, width = this.width, height = this.height, level = 0, glFormat = this.glFormat, type = this.type, dataFormat = this.dataFormat, compressed = false, offset = 0, parameters = {} }) { + ({ type, dataFormat, compressed, width, height } = this._deduceParameters({ + format: this.props.format, + type, + dataFormat, + compressed, + data, + width, + height + })); + assert6(this.depth === 1, "texSubImage not supported for 3D textures"); + if (!data) { + data = pixels; + } + if (data && data.data) { + const ndarray = data; + data = ndarray.data; + width = ndarray.shape[0]; + height = ndarray.shape[1]; + } + if (data instanceof WEBGLBuffer) { + data = data.handle; + } + this.gl.bindTexture(this.target, this.handle); + withGLParameters(this.gl, parameters, () => { + if (compressed) { + this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data); + } else if (data === null) { + this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null); + } else if (ArrayBuffer.isView(data)) { + this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset); + } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) { + this.device.gl.bindBuffer(35052, data); + this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset); + this.device.gl.bindBuffer(35052, null); + } else { + this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data); + } + }); + this.gl.bindTexture(this.target, null); + } + /** + * Defines a two-dimensional texture image or cube-map texture image with + * pixels from the current framebuffer (rather than from client memory). + * (gl.copyTexImage2D wrapper) + * + * Note that binding a texture into a Framebuffer's color buffer and + * rendering can be faster. + */ + copyFramebuffer(opts = {}) { + log2.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(); + return null; + } + getActiveUnit() { + return this.gl.getParameter(34016) - 33984; + } + bind(textureUnit = this.textureUnit) { + const { gl } = this; + if (textureUnit !== void 0) { + this.textureUnit = textureUnit; + gl.activeTexture(33984 + textureUnit); + } + gl.bindTexture(this.target, this.handle); + return textureUnit; + } + unbind(textureUnit = this.textureUnit) { + const { gl } = this; + if (textureUnit !== void 0) { + this.textureUnit = textureUnit; + gl.activeTexture(33984 + textureUnit); + } + gl.bindTexture(this.target, null); + return textureUnit; + } + // PRIVATE METHODS + _getDataType({ data, compressed = false }) { + if (compressed) { + return { data, dataType: "compressed" }; + } + if (data === null) { + return { data, dataType: "null" }; + } + if (ArrayBuffer.isView(data)) { + return { data, dataType: "typed-array" }; + } + if (data instanceof WEBGLBuffer) { + return { data: data.handle, dataType: "buffer" }; + } + if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) { + return { data, dataType: "buffer" }; + } + return { data, dataType: "browser-object" }; + } + // HELPER METHODS + _deduceParameters(opts) { + const { format, data } = opts; + let { width, height, dataFormat, type, compressed } = opts; + const parameters = getWebGLTextureParameters(format); + dataFormat = dataFormat || parameters.dataFormat; + type = type || parameters.type; + compressed = compressed || parameters.compressed; + ({ width, height } = this._deduceImageSize(data, width, height)); + return { dataFormat, type, compressed, width, height, format, data }; + } + // eslint-disable-next-line complexity + _deduceImageSize(data, width, height) { + let size; + if (typeof ImageData !== "undefined" && data instanceof ImageData) { + size = { width: data.width, height: data.height }; + } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) { + size = { width: data.naturalWidth, height: data.naturalHeight }; + } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) { + size = { width: data.width, height: data.height }; + } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) { + size = { width: data.width, height: data.height }; + } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) { + size = { width: data.videoWidth, height: data.videoHeight }; + } else if (!data) { + size = { width: width >= 0 ? width : 1, height: height >= 0 ? height : 1 }; + } else { + size = { width, height }; + } + assert6(size, "Could not deduced texture size"); + assert6(width === void 0 || size.width === width, "Deduced texture width does not match supplied width"); + assert6(height === void 0 || size.height === height, "Deduced texture height does not match supplied height"); + return size; + } + // CUBE MAP METHODS + /* eslint-disable max-statements, max-len */ + async setCubeMapImageData(options) { + const { gl } = this; + const { width, height, pixels, data, format = 6408, type = 5121 } = options; + const imageDataMap = pixels || data; + const resolvedFaces = await Promise.all(_WEBGLTexture.FACES.map((face) => { + const facePixels = imageDataMap[face]; + return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]); + })); + this.bind(); + _WEBGLTexture.FACES.forEach((face, index2) => { + if (resolvedFaces[index2].length > 1 && this.props.mipmaps !== false) { + log2.warn(`${this.id} has mipmap and multiple LODs.`)(); + } + resolvedFaces[index2].forEach((image, lodLevel) => { + if (width && height) { + gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image); + } else { + gl.texImage2D(face, lodLevel, format, format, type, image); + } + }); + }); + this.unbind(); + } + /** @todo update this method to accept LODs */ + setImageDataForFace(options) { + const { + face, + width, + height, + pixels, + data, + format = 6408, + type = 5121 + // generateMipmap = false // TODO + } = options; + const { gl } = this; + const imageData = pixels || data; + this.bind(); + if (imageData instanceof Promise) { + imageData.then((resolvedImageData) => this.setImageDataForFace(Object.assign({}, options, { + face, + data: resolvedImageData, + pixels: resolvedImageData + }))); + } else if (this.width || this.height) { + gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData); + } else { + gl.texImage2D(face, 0, format, format, type, imageData); + } + return this; + } + /** Image 3D copies from Typed Array or WebGLBuffer */ + setImageData3D(options) { + const { + level = 0, + dataFormat, + format, + type, + // = GL.UNSIGNED_BYTE, + width, + height, + depth = 1, + offset = 0, + data, + parameters = {} + } = options; + this.trackDeallocatedMemory("Texture"); + this.gl.bindTexture(this.target, this.handle); + const webglTextureFormat = getWebGLTextureParameters(format); + withGLParameters(this.gl, parameters, () => { + if (ArrayBuffer.isView(data)) { + this.gl.texImage3D( + this.target, + level, + webglTextureFormat.format, + width, + height, + depth, + 0, + webglTextureFormat.dataFormat, + webglTextureFormat.type, + // dataType: getWebGL, + data + ); + } + if (data instanceof WEBGLBuffer) { + this.gl.bindBuffer(35052, data.handle); + this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset); + } + }); + if (data && data.byteLength) { + this.trackAllocatedMemory(data.byteLength, "Texture"); + } else { + const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format); + this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, "Texture"); + } + this.loaded = true; + return this; + } + // RESOURCE METHODS + /** + * Sets sampler parameters on texture + */ + _setSamplerParameters(parameters) { + if (isObjectEmpty(parameters)) { + return; + } + logParameters(parameters); + this.gl.bindTexture(this.target, this.handle); + for (const [pname, pvalue] of Object.entries(parameters)) { + const param = Number(pname); + const value = pvalue; + switch (param) { + case 33082: + case 33083: + this.gl.texParameterf(this.target, param, value); + break; + default: + this.gl.texParameteri(this.target, param, value); + break; + } + } + this.gl.bindTexture(this.target, null); + return; + } +}; +function getWebGLTextureTarget(props) { + switch (props.dimension) { + case "2d": + return 3553; + case "cube": + return 34067; + case "2d-array": + return 35866; + case "3d": + return 32879; + case "1d": + case "cube-array": + default: + throw new Error(props.dimension); + } +} +function logParameters(parameters) { + log2.log(1, "texture sampler parameters", parameters)(); +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-framebuffer.js +var WEBGLFramebuffer = class extends Framebuffer { + device; + gl; + handle; + get texture() { + return this.colorAttachments[0]; + } + constructor(device, props) { + super(device, props); + const isDefaultFramebuffer = props.handle === null; + this.device = device; + this.gl = device.gl; + this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer(); + if (!isDefaultFramebuffer) { + device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props }); + this.autoCreateAttachmentTextures(); + const prevHandle = this.gl.bindFramebuffer(36160, this.handle); + for (let i = 0; i < this.colorAttachments.length; ++i) { + const attachment = this.colorAttachments[i]; + const attachmentPoint = 36064 + i; + if (attachment) { + this._attachOne(attachmentPoint, attachment); + } + } + if (this.depthStencilAttachment) { + this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment); + } + if (props.check !== false) { + const status = this.gl.checkFramebufferStatus(36160); + if (status !== 36053) { + throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`); + } + } + this.gl.bindFramebuffer(36160, prevHandle); + } + } + /** destroys any auto created resources etc. */ + destroy() { + super.destroy(); + if (!this.destroyed && this.handle !== null) { + this.gl.deleteFramebuffer(this.handle); + } + } + // PRIVATE + /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */ + createDepthStencilTexture(format) { + return new WEBGLTexture(this.device, { + id: `${this.id}-depth-stencil`, + format, + width: this.width, + height: this.height, + mipmaps: false + }); + } + /** + * Attachment resize is expected to be a noop if size is same + */ + resizeAttachments(width, height) { + if (this.handle === null) { + this.width = this.gl.drawingBufferWidth; + this.height = this.gl.drawingBufferHeight; + return this; + } + if (width === void 0) { + width = this.gl.drawingBufferWidth; + } + if (height === void 0) { + height = this.gl.drawingBufferHeight; + } + for (const colorAttachment of this.colorAttachments) { + colorAttachment.texture.resize({ width, height }); + } + if (this.depthStencilAttachment) { + this.depthStencilAttachment.texture.resize({ width, height }); + } + return this; + } + /** Attach one attachment */ + _attachOne(attachmentPoint, attachment) { + if (Array.isArray(attachment)) { + const [texture, layer = 0, level = 0] = attachment; + this._attachTexture(attachmentPoint, texture, layer, level); + return texture; + } + if (attachment instanceof WEBGLTexture) { + this._attachTexture(attachmentPoint, attachment, 0, 0); + return attachment; + } + if (attachment instanceof WEBGLTextureView) { + const textureView = attachment; + this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer); + return attachment.texture; + } + throw new Error("attach"); + } + // TODO - we do not seem to need render buffers in WebGL 2 + // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void { + // this.gl.framebufferRenderbuffer( + // GL.FRAMEBUFFER, + // attachment, + // GL.RENDERBUFFER, + // renderbuffer.handle + // ); + // } + /** + * @param attachment + * @param texture + * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap` + * @param level = 0 - mipmapLevel + */ + _attachTexture(attachment, texture, layer, level) { + const { gl } = this.device; + gl.bindTexture(texture.target, texture.handle); + switch (texture.target) { + case 35866: + case 32879: + gl.framebufferTextureLayer(36160, attachment, texture.target, level, layer); + break; + case 34067: + const face = mapIndexToCubeMapFace(layer); + gl.framebufferTexture2D(36160, attachment, face, texture.handle, level); + break; + case 3553: + gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level); + break; + default: + assert6(false, "Illegal texture type"); + } + gl.bindTexture(texture.target, null); + } +}; +function mapIndexToCubeMapFace(layer) { + return layer < 34069 ? layer + 34069 : layer; +} +function _getFrameBufferStatus(status) { + switch (status) { + case 36053: + return "success"; + case 36054: + return "Mismatched attachments"; + case 36055: + return "No attachments"; + case 36057: + return "Height/width mismatch"; + case 36061: + return "Unsupported or split attachments"; + case 36182: + return "Samples mismatch"; + default: + return `${status}`; + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/webgl-canvas-context.js +var WebGLCanvasContext = class extends CanvasContext { + device; + presentationSize; + _framebuffer = null; + constructor(device, props) { + super(props); + this.device = device; + this.presentationSize = [-1, -1]; + this._setAutoCreatedCanvasId(`${this.device.id}-canvas`); + this.update(); + } + getCurrentFramebuffer() { + this.update(); + this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null }); + return this._framebuffer; + } + /** Resizes and updates render targets if necessary */ + update() { + const size = this.getPixelSize(); + const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1]; + if (sizeChanged) { + this.presentationSize = size; + this.resize(); + } + } + /** + * Resize the canvas' drawing buffer. + * + * Can match the canvas CSS size, and optionally also consider devicePixelRatio + * Can be called every frame + * + * Regardless of size, the drawing buffer will always be scaled to the viewport, but + * for best visual results, usually set to either: + * canvas CSS width x canvas CSS height + * canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio + * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html + */ + resize(options) { + if (!this.device.gl) + return; + if (this.canvas) { + const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels); + this.setDevicePixelRatio(devicePixelRatio, options); + return; + } + } + commit() { + } +}; + +// node_modules/@luma.gl/webgl/dist/context/debug/spector.js +var DEFAULT_SPECTOR_PROPS = { + spector: log2.get("spector") || log2.get("spectorjs") +}; +var SPECTOR_CDN_URL = "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js"; +var LOG_LEVEL = 1; +var spector = null; +var initialized = false; +async function loadSpectorJS(props) { + if (!globalThis.SPECTOR) { + try { + await loadScript(SPECTOR_CDN_URL); + } catch (error) { + log2.warn(String(error)); + } + } +} +function initializeSpectorJS(props) { + props = { ...DEFAULT_SPECTOR_PROPS, ...props }; + if (!props?.spector) { + return null; + } + if (!spector && globalThis.SPECTOR) { + log2.probe(LOG_LEVEL, "SPECTOR found and initialized")(); + spector = new globalThis.SPECTOR.Spector(); + if (globalThis.luma) { + globalThis.luma.spector = spector; + } + } + if (!spector) { + return null; + } + if (!initialized) { + initialized = true; + spector.spyCanvases(); + spector?.onCaptureStarted.add((capture) => log2.info("Spector capture started:", capture)()); + spector?.onCapture.add((capture) => { + log2.info("Spector capture complete:", capture)(); + spector?.getResultUI(); + spector?.resultView.display(); + spector?.resultView.addCapture(capture); + }); + } + if (props?.canvas) { + if (typeof props.spector === "string" && props.spector !== props.canvas.id) { + return spector; + } + spector?.startCapture(props?.canvas, 500); + new Promise((resolve2) => setTimeout(resolve2, 2e3)).then((_) => { + log2.info("Spector capture stopped after 2 seconds")(); + spector?.stopCapture(); + }); + } + return spector; +} + +// node_modules/@luma.gl/webgl/dist/context/debug/webgl-developer-tools.js +var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js"; +function getWebGLContextData(gl) { + gl.luma = gl.luma || {}; + return gl.luma; +} +async function loadWebGLDeveloperTools() { + if (isBrowser2() && !globalThis.WebGLDebugUtils) { + globalThis.global = globalThis.global || globalThis; + globalThis.global.module = {}; + await loadScript(WEBGL_DEBUG_CDN_URL); + } +} +function makeDebugContext(gl, props = {}) { + if (!gl) { + return null; + } + return props.debug ? getDebugContext(gl, props) : getRealContext(gl); +} +function getRealContext(gl) { + const data = getWebGLContextData(gl); + return data.realContext ? data.realContext : gl; +} +function getDebugContext(gl, props) { + if (!globalThis.WebGLDebugUtils) { + log2.warn("webgl-debug not loaded")(); + return gl; + } + const data = getWebGLContextData(gl); + if (data.debugContext) { + return data.debugContext; + } + globalThis.WebGLDebugUtils.init({ ...GLEnum, ...gl }); + const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props)); + for (const key in GLEnum) { + if (!(key in glDebug) && typeof GLEnum[key] === "number") { + glDebug[key] = GLEnum[key]; + } + } + class WebGLDebugContext { + } + Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl)); + Object.setPrototypeOf(WebGLDebugContext, glDebug); + const debugContext = Object.create(WebGLDebugContext); + data.realContext = gl; + data.debugContext = debugContext; + debugContext.debug = true; + return debugContext; +} +function getFunctionString(functionName, functionArgs) { + functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg); + let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs); + args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`; + return `gl.${functionName}(${args})`; +} +function onGLError(props, err, functionName, args) { + args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg); + const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err); + const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args); + const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`; + log2.error(message2)(); + debugger; + if (props.throwOnError) { + throw new Error(message2); + } +} +function onValidateGLFunc(props, functionName, functionArgs) { + let functionString = ""; + if (log2.level >= 1) { + functionString = getFunctionString(functionName, functionArgs); + log2.log(1, functionString)(); + } + if (props.break && props.break.length > 0) { + functionString = functionString || getFunctionString(functionName, functionArgs); + const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1); + if (isBreakpoint) { + debugger; + } + } + for (const arg of functionArgs) { + if (arg === void 0) { + functionString = functionString || getFunctionString(functionName, functionArgs); + if (props.throwOnError) { + throw new Error(`Undefined argument: ${functionString}`); + } else { + log2.error(`Undefined argument: ${functionString}`)(); + debugger; + } + } + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/helpers/parse-shader-compiler-log.js +function parseShaderCompilerLog(errLog) { + const lines = errLog.split(/\r?\n/); + const messages = []; + for (const line of lines) { + if (line.length <= 1) { + continue; + } + const segments = line.split(":"); + if (segments.length === 2) { + const [messageType2, message2] = segments; + messages.push({ + message: message2.trim(), + type: getMessageType(messageType2), + lineNum: 0, + linePos: 0 + }); + continue; + } + const [messageType, linePosition, lineNumber, ...rest] = segments; + let lineNum = parseInt(lineNumber, 10); + if (isNaN(lineNum)) { + lineNum = 0; + } + let linePos = parseInt(linePosition, 10); + if (isNaN(linePos)) { + linePos = 0; + } + messages.push({ + message: rest.join(":").trim(), + type: getMessageType(messageType), + lineNum, + linePos + // TODO + }); + } + return messages; +} +function getMessageType(messageType) { + const MESSAGE_TYPES = ["warning", "error", "info"]; + const lowerCaseType = messageType.toLowerCase(); + return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info"; +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shader.js +var WEBGLShader = class extends Shader { + device; + handle; + constructor(device, props) { + super(device, props); + this.device = device; + switch (this.props.stage) { + case "vertex": + this.handle = this.props.handle || this.device.gl.createShader(35633); + break; + case "fragment": + this.handle = this.props.handle || this.device.gl.createShader(35632); + break; + default: + throw new Error(this.props.stage); + } + this._compile(this.source); + } + destroy() { + if (this.handle) { + this.removeStats(); + this.device.gl.deleteShader(this.handle); + this.destroyed = true; + } + } + async getCompilationInfo() { + await this._waitForCompilationComplete(); + return this.getCompilationInfoSync(); + } + getCompilationInfoSync() { + const log4 = this.device.gl.getShaderInfoLog(this.handle); + return parseShaderCompilerLog(log4); + } + getTranslatedSource() { + const extensions = this.device.getExtension("WEBGL_debug_shaders"); + const ext = extensions.WEBGL_debug_shaders; + return ext?.getTranslatedShaderSource(this.handle); + } + // PRIVATE METHODS + /** Compile a shader and get compilation status */ + async _compile(source) { + const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100 +${source2}`; + source = addGLSLVersion(source); + const { gl } = this.device; + gl.shaderSource(this.handle, source); + gl.compileShader(this.handle); + if (log2.level === 0) { + this.compilationStatus = "pending"; + return; + } + if (!this.device.features.has("compilation-status-async-webgl")) { + this._getCompilationStatus(); + this.debugShader(); + if (this.compilationStatus === "error") { + throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`); + } + return; + } + log2.once(1, "Shader compilation is asynchronous")(); + await this._waitForCompilationComplete(); + log2.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)(); + this._getCompilationStatus(); + this.debugShader(); + } + /** Use KHR_parallel_shader_compile extension if available */ + async _waitForCompilationComplete() { + const waitMs = async (ms) => await new Promise((resolve2) => setTimeout(resolve2, ms)); + const DELAY_MS = 10; + if (!this.device.features.has("compilation-status-async-webgl")) { + await waitMs(DELAY_MS); + return; + } + const { gl } = this.device; + for (; ; ) { + const complete = gl.getShaderParameter(this.handle, 37297); + if (complete) { + return; + } + await waitMs(DELAY_MS); + } + } + /** + * Get the shader compilation status + * TODO - Load log even when no error reported, to catch warnings? + * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings + */ + _getCompilationStatus() { + this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 35713) ? "success" : "error"; + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pass.js +var GL_DEPTH_BUFFER_BIT = 256; +var GL_STENCIL_BUFFER_BIT = 1024; +var GL_COLOR_BUFFER_BIT = 16384; +var GL_COLOR = 6144; +var COLOR_CHANNELS = [1, 2, 4, 8]; +var WEBGLRenderPass = class extends RenderPass { + device; + /** Parameters that should be applied before each draw call */ + glParameters; + constructor(device, props) { + super(device, props); + this.device = device; + pushContextState(this.device.gl); + this.setParameters(this.props.parameters); + this.clear(); + } + end() { + popContextState(this.device.gl); + } + pushDebugGroup(groupLabel) { + } + popDebugGroup() { + } + insertDebugMarker(markerLabel) { + } + // beginOcclusionQuery(queryIndex: number): void; + // endOcclusionQuery(): void; + // executeBundles(bundles: Iterable): void; + /** + * Maps RenderPass parameters to GL parameters + */ + setParameters(parameters = {}) { + const glParameters = { ...this.glParameters }; + if (this.props.framebuffer) { + glParameters.framebuffer = this.props.framebuffer; + } + if (this.props.depthReadOnly) { + glParameters.depthMask = !this.props.depthReadOnly; + } + glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1; + glParameters[35977] = this.props.discard; + if (parameters.viewport) { + if (parameters.viewport.length >= 6) { + glParameters.viewport = parameters.viewport.slice(0, 4); + glParameters.depthRange = [parameters.viewport[4], parameters.viewport[5]]; + } else { + glParameters.viewport = parameters.viewport; + } + } + if (parameters.scissorRect) { + glParameters.scissorTest = true; + glParameters.scissor = parameters.scissorRect; + } + if (parameters.blendConstant) { + glParameters.blendColor = parameters.blendConstant; + } + if (parameters.stencilReference) { + console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL"); + parameters[2967] = parameters.stencilReference; + } + if (parameters.colorMask) { + glParameters.colorMask = COLOR_CHANNELS.map((channel) => Boolean(channel & parameters.colorMask)); + } + this.glParameters = glParameters; + setGLParameters(this.device.gl, glParameters); + } + beginOcclusionQuery(queryIndex) { + const webglQuerySet = this.props.occlusionQuerySet; + webglQuerySet?.beginOcclusionQuery(); + } + endOcclusionQuery() { + const webglQuerySet = this.props.occlusionQuerySet; + webglQuerySet?.endOcclusionQuery(); + } + // PRIVATE + /** + * Optionally clears depth, color and stencil buffers based on parameters + */ + clear() { + const glParameters = { ...this.glParameters }; + let clearMask = 0; + if (this.props.clearColor !== false) { + clearMask |= GL_COLOR_BUFFER_BIT; + glParameters.clearColor = this.props.clearColor; + } + if (this.props.clearDepth !== false) { + clearMask |= GL_DEPTH_BUFFER_BIT; + glParameters.clearDepth = this.props.clearDepth; + } + if (this.props.clearStencil !== false) { + clearMask |= GL_STENCIL_BUFFER_BIT; + glParameters.clearStencil = this.props.clearStencil; + } + if (clearMask !== 0) { + withGLParameters(this.device.gl, glParameters, () => { + this.device.gl.clear(clearMask); + }); + } + } + /** + * WebGL2 - clear a specific color buffer + */ + clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) { + withGLParameters(this.device.gl, { framebuffer: this.props.framebuffer }, () => { + switch (value.constructor) { + case Int32Array: + this.device.gl.clearBufferiv(GL_COLOR, drawBuffer, value); + break; + case Uint32Array: + this.device.gl.clearBufferuiv(GL_COLOR, drawBuffer, value); + break; + case Float32Array: + default: + this.device.gl.clearBufferfv(GL_COLOR, drawBuffer, value); + break; + } + }); + } +}; + +// node_modules/@luma.gl/webgl/dist/classic/typed-array-utils.js +var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array"; +function getGLTypeFromTypedArray(arrayOrType) { + const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; + switch (type) { + case Float32Array: + return 5126; + case Uint16Array: + return 5123; + case Uint32Array: + return 5125; + case Uint8Array: + return 5121; + case Uint8ClampedArray: + return 5121; + case Int8Array: + return 5120; + case Int16Array: + return 5122; + case Int32Array: + return 5124; + default: + throw new Error(ERR_TYPE_DEDUCTION); + } +} +function getTypedArrayFromGLType(glType, options) { + const { clamped = true } = options || {}; + switch (glType) { + case 5126: + return Float32Array; + case 5123: + case 33635: + case 32819: + case 32820: + return Uint16Array; + case 5125: + return Uint32Array; + case 5121: + return clamped ? Uint8ClampedArray : Uint8Array; + case 5120: + return Int8Array; + case 5122: + return Int16Array; + case 5124: + return Int32Array; + default: + throw new Error("Failed to deduce typed array type from GL constant"); + } +} + +// node_modules/@luma.gl/webgl/dist/classic/accessor.js +var DEFAULT_ACCESSOR_VALUES = { + offset: 0, + stride: 0, + type: 5126, + size: 1, + divisor: 0, + normalized: false, + integer: false +}; +var PROP_CHECKS = { + deprecatedProps: { + instanced: "divisor", + isInstanced: "divisor" + } +}; +var Accessor = class _Accessor { + offset; + stride; + type; + size; + divisor; + normalized; + integer; + buffer; + index; + static getBytesPerElement(accessor) { + const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126); + return ArrayType2.BYTES_PER_ELEMENT; + } + static getBytesPerVertex(accessor) { + assert6(accessor.size); + const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126); + return ArrayType2.BYTES_PER_ELEMENT * accessor.size; + } + // Combines (merges) a list of accessors. On top of default values + // Usually [programAccessor, bufferAccessor, appAccessor] + // All props will be set in the returned object. + // TODO check for conflicts between values in the supplied accessors + static resolve(...accessors) { + return new _Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); + } + constructor(...accessors) { + accessors.forEach((accessor) => this._assign(accessor)); + Object.freeze(this); + } + toString() { + return JSON.stringify(this); + } + // ACCESSORS + // TODO - remove> + get BYTES_PER_ELEMENT() { + return _Accessor.getBytesPerElement(this); + } + get BYTES_PER_VERTEX() { + return _Accessor.getBytesPerVertex(this); + } + // PRIVATE + // eslint-disable-next-line complexity, max-statements + _assign(props = {}) { + props = checkProps("Accessor", props, PROP_CHECKS); + if (props.type !== void 0) { + this.type = props.type; + if (props.type === 5124 || props.type === 5125) { + this.integer = true; + } + } + if (props.size !== void 0) { + this.size = props.size; + } + if (props.offset !== void 0) { + this.offset = props.offset; + } + if (props.stride !== void 0) { + this.stride = props.stride; + } + if (props.normalize !== void 0) { + this.normalized = props.normalize; + } + if (props.normalized !== void 0) { + this.normalized = props.normalized; + } + if (props.integer !== void 0) { + this.integer = props.integer; + } + if (props.divisor !== void 0) { + this.divisor = props.divisor; + } + if (props.buffer !== void 0) { + this.buffer = props.buffer; + } + if (props.index !== void 0) { + if (typeof props.index === "boolean") { + this.index = props.index ? 1 : 0; + } else { + this.index = props.index; + } + } + if (props.instanced !== void 0) { + this.divisor = props.instanced ? 1 : 0; + } + if (props.isInstanced !== void 0) { + this.divisor = props.isInstanced ? 1 : 0; + } + if (this.offset === void 0) + delete this.offset; + if (this.stride === void 0) + delete this.stride; + if (this.type === void 0) + delete this.type; + if (this.size === void 0) + delete this.size; + if (this.divisor === void 0) + delete this.divisor; + if (this.normalized === void 0) + delete this.normalized; + if (this.integer === void 0) + delete this.integer; + if (this.buffer === void 0) + delete this.buffer; + if (this.index === void 0) + delete this.index; + return this; + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/helpers/decode-webgl-types.js +function isSamplerUniform(type) { + return SAMPLER_TYPES.includes(type); +} +var SAMPLER_TYPES = [ + 35678, + 35680, + 35679, + 35682, + 36289, + 36292, + 36293, + 36298, + 36299, + 36300, + 36303, + 36306, + 36307, + 36308, + 36311 +]; +var COMPOSITE_GL_TYPES = { + [5126]: [5126, 1, "float", "f32", "float32"], + [35664]: [5126, 2, "vec2", "vec2", "float32x2"], + [35665]: [5126, 3, "vec3", "vec3", "float32x3"], + [35666]: [5126, 4, "vec4", "vec4", "float32x4"], + [5124]: [5124, 1, "int", "i32", "sint32"], + [35667]: [5124, 2, "ivec2", "vec2", "sint32x2"], + [35668]: [5124, 3, "ivec3", "vec3", "sint32x3"], + [35669]: [5124, 4, "ivec4", "vec4", "sint32x4"], + [5125]: [5125, 1, "uint", "u32", "uint32"], + [36294]: [5125, 2, "uvec2", "vec2", "uint32x2"], + [36295]: [5125, 3, "uvec3", "vec3", "uint32x3"], + [36296]: [5125, 4, "uvec4", "vec4", "uint32x4"], + [35670]: [5126, 1, "bool", "f32", "float32"], + [35671]: [5126, 2, "bvec2", "vec2", "float32x2"], + [35672]: [5126, 3, "bvec3", "vec3", "float32x3"], + [35673]: [5126, 4, "bvec4", "vec4", "float32x4"], + // TODO - are sizes/components below correct? + [35674]: [5126, 8, "mat2", "mat2x2"], + // 4 + [35685]: [5126, 8, "mat2x3", "mat2x3"], + // 6 + [35686]: [5126, 8, "mat2x4", "mat2x4"], + // 8 + [35687]: [5126, 12, "mat3x2", "mat3x2"], + // 6 + [35675]: [5126, 12, "mat3", "mat3x3"], + // 9 + [35688]: [5126, 12, "mat3x4", "mat3x4"], + // 12 + [35689]: [5126, 16, "mat4x2", "mat4x2"], + // 8 + [35690]: [5126, 16, "mat4x3", "mat4x3"], + // 12 + [35676]: [5126, 16, "mat4", "mat4x4"] + // 16 +}; +function decodeGLUniformType(glUniformType) { + const typeAndSize = COMPOSITE_GL_TYPES[glUniformType]; + if (!typeAndSize) { + throw new Error("uniform"); + } + const [glType, components, , format] = typeAndSize; + return { format, components, glType }; +} +function decodeGLAttributeType(glAttributeType) { + const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType]; + if (!typeAndSize) { + throw new Error("attribute"); + } + const [, components, , shaderType, vertexFormat] = typeAndSize; + const attributeType = shaderType; + return { attributeType, vertexFormat, components }; +} + +// node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout.js +function getShaderLayout(gl, program) { + const shaderLayout = { + attributes: [], + bindings: [] + }; + shaderLayout.attributes = readAttributeDeclarations(gl, program); + const uniformBlocks = readUniformBlocks(gl, program); + for (const uniformBlock of uniformBlocks) { + const uniforms2 = uniformBlock.uniforms.map((uniform) => ({ + name: uniform.name, + format: uniform.format, + byteOffset: uniform.byteOffset, + byteStride: uniform.byteStride, + arrayLength: uniform.arrayLength + })); + shaderLayout.bindings.push({ + type: "uniform", + name: uniformBlock.name, + location: uniformBlock.location, + visibility: (uniformBlock.vertex ? 1 : 0) & (uniformBlock.fragment ? 2 : 0), + minBindingSize: uniformBlock.byteLength, + uniforms: uniforms2 + }); + } + const uniforms = readUniformBindings(gl, program); + let textureUnit = 0; + for (const uniform of uniforms) { + if (isSamplerUniform(uniform.type)) { + const { viewDimension, sampleType } = getSamplerInfo(uniform.type); + shaderLayout.bindings.push({ + type: "texture", + name: uniform.name, + location: textureUnit, + viewDimension, + sampleType + }); + uniform.textureUnit = textureUnit; + textureUnit += 1; + } + } + if (uniforms.length) { + shaderLayout.uniforms = uniforms; + } + const varyings = readVaryings(gl, program); + if (varyings?.length) { + shaderLayout.varyings = varyings; + } + return shaderLayout; +} +function readAttributeDeclarations(gl, program) { + const attributes = []; + const count2 = gl.getProgramParameter(program, 35721); + for (let index2 = 0; index2 < count2; index2++) { + const activeInfo = gl.getActiveAttrib(program, index2); + if (!activeInfo) { + throw new Error("activeInfo"); + } + const { + name: name2, + type: compositeType + /* , size*/ + } = activeInfo; + const location = gl.getAttribLocation(program, name2); + if (location >= 0) { + const { attributeType } = decodeGLAttributeType(compositeType); + const stepMode = /instance/i.test(name2) ? "instance" : "vertex"; + attributes.push({ + name: name2, + location, + stepMode, + type: attributeType + // size - for arrays, size is the number of elements in the array + }); + } + } + attributes.sort((a, b) => a.location - b.location); + return attributes; +} +function readVaryings(gl, program) { + const varyings = []; + const count2 = gl.getProgramParameter(program, 35971); + for (let location = 0; location < count2; location++) { + const activeInfo = gl.getTransformFeedbackVarying(program, location); + if (!activeInfo) { + throw new Error("activeInfo"); + } + const { name: name2, type: compositeType, size } = activeInfo; + const { glType, components } = decodeGLUniformType(compositeType); + const accessor = new Accessor({ type: glType, size: size * components }); + const varying = { location, name: name2, accessor }; + varyings.push(varying); + } + varyings.sort((a, b) => a.location - b.location); + return varyings; +} +function readUniformBindings(gl, program) { + const uniforms = []; + const uniformCount = gl.getProgramParameter(program, 35718); + for (let i = 0; i < uniformCount; i++) { + const activeInfo = gl.getActiveUniform(program, i); + if (!activeInfo) { + throw new Error("activeInfo"); + } + const { name: rawName, size, type } = activeInfo; + const { name: name2, isArray: isArray5 } = parseUniformName(rawName); + let webglLocation = gl.getUniformLocation(program, name2); + const uniformInfo = { + // WebGL locations are uniquely typed but just numbers + location: webglLocation, + name: name2, + size, + type, + isArray: isArray5 + }; + uniforms.push(uniformInfo); + if (uniformInfo.size > 1) { + for (let j = 0; j < uniformInfo.size; j++) { + const elementName = `${name2}[${j}]`; + webglLocation = gl.getUniformLocation(program, elementName); + const arrayElementUniformInfo = { + ...uniformInfo, + name: elementName, + location: webglLocation + }; + uniforms.push(arrayElementUniformInfo); + } + } + } + return uniforms; +} +function readUniformBlocks(gl, program) { + const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname); + const uniformBlocks = []; + const blockCount = gl.getProgramParameter(program, 35382); + for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) { + const blockInfo = { + name: gl.getActiveUniformBlockName(program, blockIndex) || "", + location: getBlockParameter(blockIndex, 35391), + byteLength: getBlockParameter(blockIndex, 35392), + vertex: getBlockParameter(blockIndex, 35396), + fragment: getBlockParameter(blockIndex, 35398), + uniformCount: getBlockParameter(blockIndex, 35394), + uniforms: [] + }; + const uniformIndices = getBlockParameter(blockIndex, 35395) || []; + const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383); + const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384); + const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387); + const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388); + for (let i = 0; i < blockInfo.uniformCount; ++i) { + const activeInfo = gl.getActiveUniform(program, uniformIndices[i]); + if (!activeInfo) { + throw new Error("activeInfo"); + } + blockInfo.uniforms.push({ + name: activeInfo.name, + format: decodeGLUniformType(uniformType[i]).format, + type: uniformType[i], + arrayLength: uniformArrayLength[i], + byteOffset: uniformOffset[i], + byteStride: uniformStride[i] + // matrixStride: uniformStride[i], + // rowMajor: uniformRowMajor[i] + }); + } + uniformBlocks.push(blockInfo); + } + uniformBlocks.sort((a, b) => a.location - b.location); + return uniformBlocks; +} +var SAMPLER_UNIFORMS_GL_TO_GPU = { + [35678]: ["2d", "float"], + [35680]: ["cube", "float"], + [35679]: ["3d", "float"], + [35682]: ["3d", "depth"], + [36289]: ["2d-array", "float"], + [36292]: ["2d-array", "depth"], + [36293]: ["cube", "float"], + [36298]: ["2d", "sint"], + [36299]: ["3d", "sint"], + [36300]: ["cube", "sint"], + [36303]: ["2d-array", "uint"], + [36306]: ["2d", "uint"], + [36307]: ["3d", "uint"], + [36308]: ["cube", "uint"], + [36311]: ["2d-array", "uint"] +}; +function getSamplerInfo(type) { + const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type]; + if (!sampler) { + throw new Error("sampler"); + } + const [viewDimension, sampleType] = sampler; + return { viewDimension, sampleType }; +} +function parseUniformName(name2) { + if (name2[name2.length - 1] !== "]") { + return { + name: name2, + length: 1, + isArray: false + }; + } + const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/; + const matches4 = UNIFORM_NAME_REGEXP.exec(name2); + if (!matches4 || matches4.length < 2) { + throw new Error(`Failed to parse GLSL uniform name ${name2}`); + } + return { + name: matches4[1], + length: matches4[2] ? 1 : 0, + isArray: Boolean(matches4[2]) + }; +} + +// node_modules/@luma.gl/webgl/dist/adapter/helpers/set-uniform.js +function setUniform(gl, location, type, value) { + const gl2 = gl; + let uniformValue = value; + if (uniformValue === true) { + uniformValue = 1; + } + if (uniformValue === false) { + uniformValue = 0; + } + const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue; + switch (type) { + case 35678: + case 35680: + case 35679: + case 35682: + case 36289: + case 36292: + case 36293: + case 36298: + case 36299: + case 36300: + case 36303: + case 36306: + case 36307: + case 36308: + case 36311: + if (typeof value !== "number") { + throw new Error("samplers must be set to integers"); + } + return gl.uniform1i(location, value); + case 5126: + return gl.uniform1fv(location, arrayValue); + case 35664: + return gl.uniform2fv(location, arrayValue); + case 35665: + return gl.uniform3fv(location, arrayValue); + case 35666: + return gl.uniform4fv(location, arrayValue); + case 5124: + return gl.uniform1iv(location, arrayValue); + case 35667: + return gl.uniform2iv(location, arrayValue); + case 35668: + return gl.uniform3iv(location, arrayValue); + case 35669: + return gl.uniform4iv(location, arrayValue); + case 35670: + return gl.uniform1iv(location, arrayValue); + case 35671: + return gl.uniform2iv(location, arrayValue); + case 35672: + return gl.uniform3iv(location, arrayValue); + case 35673: + return gl.uniform4iv(location, arrayValue); + case 5125: + return gl2.uniform1uiv(location, arrayValue, 1); + case 36294: + return gl2.uniform2uiv(location, arrayValue, 2); + case 36295: + return gl2.uniform3uiv(location, arrayValue, 3); + case 36296: + return gl2.uniform4uiv(location, arrayValue, 4); + case 35674: + return gl.uniformMatrix2fv(location, false, arrayValue); + case 35675: + return gl.uniformMatrix3fv(location, false, arrayValue); + case 35676: + return gl.uniformMatrix4fv(location, false, arrayValue); + case 35685: + return gl2.uniformMatrix2x3fv(location, false, arrayValue); + case 35686: + return gl2.uniformMatrix2x4fv(location, false, arrayValue); + case 35687: + return gl2.uniformMatrix3x2fv(location, false, arrayValue); + case 35688: + return gl2.uniformMatrix3x4fv(location, false, arrayValue); + case 35689: + return gl2.uniformMatrix4x2fv(location, false, arrayValue); + case 35690: + return gl2.uniformMatrix4x3fv(location, false, arrayValue); + } + throw new Error("Illegal uniform"); +} + +// node_modules/@luma.gl/webgl/dist/adapter/helpers/webgl-topology-utils.js +function getGLDrawMode(topology) { + switch (topology) { + case "point-list": + return 0; + case "line-list": + return 1; + case "line-strip": + return 3; + case "line-loop-webgl": + return 2; + case "triangle-list": + return 4; + case "triangle-strip": + return 5; + case "triangle-fan-webgl": + return 6; + default: + throw new Error(topology); + } +} +function getGLPrimitive(topology) { + switch (topology) { + case "point-list": + return 0; + case "line-list": + return 1; + case "line-strip": + return 1; + case "line-loop-webgl": + return 1; + case "triangle-list": + return 4; + case "triangle-strip": + return 4; + case "triangle-fan-webgl": + return 4; + default: + throw new Error(topology); + } +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js +var LOG_PROGRAM_PERF_PRIORITY = 4; +var WEBGLRenderPipeline = class extends RenderPipeline { + /** The WebGL device that created this render pipeline */ + device; + /** Handle to underlying WebGL program */ + handle; + /** vertex shader */ + vs; + /** fragment shader */ + fs; + /** The layout extracted from shader by WebGL introspection APIs */ + introspectedLayout; + /** Uniforms set on this model */ + uniforms = {}; + /** Bindings set on this model */ + bindings = {}; + /** WebGL varyings */ + varyings = null; + _uniformCount = 0; + _uniformSetters = {}; + // TODO are these used? + constructor(device, props) { + super(device, props); + this.device = device; + this.handle = this.props.handle || this.device.gl.createProgram(); + this.device.setSpectorMetadata(this.handle, { id: this.props.id }); + this.vs = cast(props.vs); + this.fs = cast(props.fs); + const { varyings, bufferMode = 35981 } = props; + if (varyings && varyings.length > 0) { + this.varyings = varyings; + this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode); + } + this._linkShaders(); + log2.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)(); + this.introspectedLayout = getShaderLayout(this.device.gl, this.handle); + log2.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)(); + this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout); + switch (this.props.topology) { + case "triangle-fan-webgl": + case "line-loop-webgl": + log2.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`); + break; + default: + } + } + destroy() { + if (this.handle) { + this.device.gl.deleteProgram(this.handle); + this.destroyed = true; + } + } + /** + * Bindings include: textures, samplers and uniform buffers + * @todo needed for portable model + */ + setBindings(bindings, options) { + for (const [name2, value] of Object.entries(bindings)) { + const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name2) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name2}Uniforms`); + if (!binding) { + const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", "); + if (!options?.disableWarnings) { + log2.warn(`Unknown binding "${name2}" in render pipeline "${this.id}", expected one of ${validBindings}`)(); + } + continue; + } + if (!value) { + log2.warn(`Unsetting binding "${name2}" in render pipeline "${this.id}"`)(); + } + switch (binding.type) { + case "uniform": + if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) { + throw new Error("buffer value"); + } + break; + case "texture": + if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) { + throw new Error("texture value"); + } + break; + case "sampler": + log2.warn(`Ignoring sampler ${name2}`)(); + break; + default: + throw new Error(binding.type); + } + this.bindings[name2] = value; + } + } + /** @todo needed for portable model + * @note The WebGL API is offers many ways to draw things + * This function unifies those ways into a single call using common parameters with sane defaults + */ + draw(options) { + const { + renderPass, + parameters = this.props.parameters, + topology = this.props.topology, + vertexArray, + vertexCount, + // indexCount, + instanceCount, + isInstanced = false, + firstVertex = 0, + // firstIndex, + // firstInstance, + // baseVertex, + transformFeedback + } = options; + const glDrawMode = getGLDrawMode(topology); + const isIndexed = Boolean(vertexArray.indexBuffer); + const glIndexType = vertexArray.indexBuffer?.glIndexType; + if (this.linkStatus !== "success") { + log2.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)(); + return false; + } + if (!this._areTexturesRenderable() || vertexCount === 0) { + log2.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)(); + return false; + } + if (vertexCount === 0) { + log2.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)(); + return true; + } + this.device.gl.useProgram(this.handle); + vertexArray.bindBeforeRender(renderPass); + if (transformFeedback) { + transformFeedback.begin(this.props.topology); + } + this._applyBindings(); + this._applyUniforms(); + const webglRenderPass = renderPass; + withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => { + if (isIndexed && isInstanced) { + this.device.gl.drawElementsInstanced( + glDrawMode, + vertexCount || 0, + // indexCount? + glIndexType, + firstVertex, + instanceCount || 0 + ); + } else if (isIndexed) { + this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex); + } else if (isInstanced) { + this.device.gl.drawArraysInstanced(glDrawMode, firstVertex, vertexCount || 0, instanceCount || 0); + } else { + this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0); + } + if (transformFeedback) { + transformFeedback.end(); + } + }); + vertexArray.unbindAfterRender(renderPass); + return true; + } + // DEPRECATED METHODS + setUniformsWebGL(uniforms) { + const { bindings } = splitUniformsAndBindings(uniforms); + Object.keys(bindings).forEach((name2) => { + log2.warn(`Unsupported value "${JSON.stringify(bindings[name2])}" used in setUniforms() for key ${name2}. Use setBindings() instead?`)(); + }); + Object.assign(this.uniforms, uniforms); + } + // PRIVATE METHODS + // setAttributes(attributes: Record): void {} + // setBindings(bindings: Record): void {} + async _linkShaders() { + const { gl } = this.device; + gl.attachShader(this.handle, this.vs.handle); + gl.attachShader(this.handle, this.fs.handle); + log2.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)(); + gl.linkProgram(this.handle); + log2.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)(); + if (log2.level === 0) { + } + if (!this.device.features.has("compilation-status-async-webgl")) { + const status2 = this._getLinkStatus(); + this._reportLinkStatus(status2); + return; + } + log2.once(1, "RenderPipeline linking is asynchronous")(); + await this._waitForLinkComplete(); + log2.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)(); + const status = this._getLinkStatus(); + this._reportLinkStatus(status); + } + /** Report link status. First, check for shader compilation failures if linking fails */ + _reportLinkStatus(status) { + switch (status) { + case "success": + return; + default: + if (this.vs.compilationStatus === "error") { + this.vs.debugShader(); + throw new Error(`Error during compilation of shader ${this.vs.id}`); + } + if (this.fs?.compilationStatus === "error") { + this.fs.debugShader(); + throw new Error(`Error during compilation of shader ${this.fs.id}`); + } + throw new Error(`Error during ${status}: ${this.device.gl.getProgramInfoLog(this.handle)}`); + } + } + /** + * Get the shader compilation status + * TODO - Load log even when no error reported, to catch warnings? + * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings + */ + _getLinkStatus() { + const { gl } = this.device; + const linked = gl.getProgramParameter(this.handle, 35714); + if (!linked) { + this.linkStatus = "error"; + return "linking"; + } + gl.validateProgram(this.handle); + const validated = gl.getProgramParameter(this.handle, 35715); + if (!validated) { + this.linkStatus = "error"; + return "validation"; + } + this.linkStatus = "success"; + return "success"; + } + /** Use KHR_parallel_shader_compile extension if available */ + async _waitForLinkComplete() { + const waitMs = async (ms) => await new Promise((resolve2) => setTimeout(resolve2, ms)); + const DELAY_MS = 10; + if (!this.device.features.has("compilation-status-async-webgl")) { + await waitMs(DELAY_MS); + return; + } + const { gl } = this.device; + for (; ; ) { + const complete = gl.getProgramParameter(this.handle, 37297); + if (complete) { + return; + } + await waitMs(DELAY_MS); + } + } + /** + * Checks if all texture-values uniforms are renderable (i.e. loaded) + * Update a texture if needed (e.g. from video) + * Note: This is currently done before every draw call + */ + _areTexturesRenderable() { + let texturesRenderable = true; + for (const [, texture] of Object.entries(this.bindings)) { + if (texture instanceof WEBGLTexture) { + texture.update(); + texturesRenderable = texturesRenderable && texture.loaded; + } + } + return texturesRenderable; + } + /** Apply any bindings (before each draw call) */ + _applyBindings() { + if (this.linkStatus !== "success") { + return; + } + const { gl } = this.device; + gl.useProgram(this.handle); + let textureUnit = 0; + let uniformBufferIndex = 0; + for (const binding of this.shaderLayout.bindings) { + const value = this.bindings[binding.name] || this.bindings[binding.name.replace(/Uniforms$/, "")]; + if (!value) { + throw new Error(`No value for binding ${binding.name} in ${this.id}`); + } + switch (binding.type) { + case "uniform": + const { name: name2 } = binding; + const location = gl.getUniformBlockIndex(this.handle, name2); + if (location === 4294967295) { + throw new Error(`Invalid uniform block name ${name2}`); + } + gl.uniformBlockBinding(this.handle, uniformBufferIndex, location); + if (value instanceof WEBGLBuffer) { + gl.bindBufferBase(35345, uniformBufferIndex, value.handle); + } else { + gl.bindBufferRange( + 35345, + uniformBufferIndex, + // @ts-expect-error + value.buffer.handle, + // @ts-expect-error + value.offset || 0, + // @ts-expect-error + value.size || value.buffer.byteLength - value.offset + ); + } + uniformBufferIndex += 1; + break; + case "texture": + if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) { + throw new Error("texture"); + } + let texture; + if (value instanceof WEBGLTextureView) { + texture = value.texture; + } else if (value instanceof WEBGLTexture) { + texture = value; + } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) { + log2.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")(); + texture = value.colorAttachments[0].texture; + } else { + throw new Error("No texture"); + } + gl.activeTexture(33984 + textureUnit); + gl.bindTexture(texture.target, texture.handle); + textureUnit += 1; + break; + case "sampler": + break; + case "storage": + case "read-only-storage": + throw new Error(`binding type '${binding.type}' not supported in WebGL`); + } + } + } + /** + * Due to program sharing, uniforms need to be reset before every draw call + * (though caching will avoid redundant WebGL calls) + */ + _applyUniforms() { + for (const uniformLayout of this.shaderLayout.uniforms || []) { + const { name: name2, location, type, textureUnit } = uniformLayout; + const value = this.uniforms[name2] ?? textureUnit; + if (value !== void 0) { + setUniform(this.device.gl, location, type, value); + } + } + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-buffer.js +function cast2(value) { + return value; +} +var WEBGLCommandBuffer = class extends CommandBuffer { + device; + commands = []; + constructor(device) { + super(device, {}); + this.device = device; + } + submitCommands(commands = this.commands) { + for (const command of commands) { + switch (command.name) { + case "copy-buffer-to-buffer": + _copyBufferToBuffer(this.device, command.options); + break; + case "copy-buffer-to-texture": + _copyBufferToTexture(this.device, command.options); + break; + case "copy-texture-to-buffer": + _copyTextureToBuffer(this.device, command.options); + break; + case "copy-texture-to-texture": + _copyTextureToTexture(this.device, command.options); + break; + } + } + } +}; +function _copyBufferToBuffer(device, options) { + const source = cast2(options.source); + const destination = cast2(options.destination); + device.gl.bindBuffer(36662, source.handle); + device.gl.bindBuffer(36663, destination.handle); + device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size); + device.gl.bindBuffer(36662, null); + device.gl.bindBuffer(36663, null); +} +function _copyBufferToTexture(device, options) { + throw new Error("Not implemented"); +} +function _copyTextureToBuffer(device, options) { + const { + /** Texture to copy to/from. */ + source, + /** Mip-map level of the texture to copy to/from. (Default 0) */ + mipLevel = 0, + /** Defines which aspects of the texture to copy to/from. */ + aspect = "all", + /** Width to copy */ + width = options.source.width, + /** Height to copy */ + height = options.source.height, + depthOrArrayLayers = 0, + /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */ + origin = [0, 0], + /** Destination buffer */ + destination, + /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */ + byteOffset = 0, + /** + * The stride, in bytes, between the beginning of each block row and the subsequent block row. + * Required if there are multiple block rows (i.e. the copy height or depth is more than one block). + */ + bytesPerRow, + /** + * Number of block rows per single image of the texture. + * rowsPerImage × bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image. + * Required if there are multiple images (i.e. the copy depth is more than one). + */ + rowsPerImage + } = options; + if (aspect !== "all") { + throw new Error("not supported"); + } + if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) { + throw new Error("not implemented"); + } + const { framebuffer, destroyFramebuffer } = getFramebuffer(source); + let prevHandle; + try { + const webglBuffer = destination; + const sourceWidth = width || framebuffer.width; + const sourceHeight = height || framebuffer.height; + const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format); + const sourceFormat = sourceParams.dataFormat; + const sourceType = sourceParams.type; + device.gl.bindBuffer(35051, webglBuffer.handle); + prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle); + device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset); + } finally { + device.gl.bindBuffer(35051, null); + if (prevHandle !== void 0) { + device.gl.bindFramebuffer(36160, prevHandle); + } + if (destroyFramebuffer) { + framebuffer.destroy(); + } + } +} +function _copyTextureToTexture(device, options) { + const { + /** Texture to copy to/from. */ + source, + /** Mip-map level of the texture to copy to (Default 0) */ + destinationMipLevel = 0, + /** Defines which aspects of the texture to copy to/from. */ + // aspect = 'all', + /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy from. */ + origin = [0, 0], + /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to. */ + destinationOrigin = [0, 0], + /** Texture to copy to/from. */ + destination + /** Mip-map level of the texture to copy to/from. (Default 0) */ + // destinationMipLevel = options.mipLevel, + /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */ + // destinationOrigin = [0, 0], + /** Defines which aspects of the texture to copy to/from. */ + // destinationAspect = options.aspect, + } = options; + let { + width = options.destination.width, + height = options.destination.height + // depthOrArrayLayers = 0 + } = options; + const { framebuffer, destroyFramebuffer } = getFramebuffer(source); + const [sourceX, sourceY] = origin; + const [destinationX, destinationY, destinationZ] = destinationOrigin; + const prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle); + let texture = null; + let textureTarget; + if (destination instanceof WEBGLTexture) { + texture = destination; + width = Number.isFinite(width) ? width : texture.width; + height = Number.isFinite(height) ? height : texture.height; + texture.bind(0); + textureTarget = texture.target; + } else { + throw new Error("invalid destination"); + } + switch (textureTarget) { + case 3553: + case 34067: + device.gl.copyTexSubImage2D(textureTarget, destinationMipLevel, destinationX, destinationY, sourceX, sourceY, width, height); + break; + case 35866: + case 32879: + device.gl.copyTexSubImage3D(textureTarget, destinationMipLevel, destinationX, destinationY, destinationZ, sourceX, sourceY, width, height); + break; + default: + } + if (texture) { + texture.unbind(); + } + device.gl.bindFramebuffer(36160, prevHandle); + if (destroyFramebuffer) { + framebuffer.destroy(); + } +} +function getFramebuffer(source) { + if (source instanceof Texture) { + const { width, height, id } = source; + const framebuffer = source.device.createFramebuffer({ + id: `framebuffer-for-${id}`, + width, + height, + colorAttachments: [source] + }); + return { framebuffer, destroyFramebuffer: true }; + } + return { framebuffer: source, destroyFramebuffer: false }; +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-encoder.js +var WEBGLCommandEncoder = class extends CommandEncoder { + device; + commandBuffer; + constructor(device, props) { + super(device, props); + this.device = device; + this.commandBuffer = new WEBGLCommandBuffer(device); + } + destroy() { + } + finish() { + this.commandBuffer.submitCommands(); + } + // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder; + // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder; + // finish(options?: {id?: string}): GPUCommandBuffer; + copyBufferToBuffer(options) { + this.commandBuffer.commands.push({ name: "copy-buffer-to-buffer", options }); + } + copyBufferToTexture(options) { + this.commandBuffer.commands.push({ name: "copy-buffer-to-texture", options }); + } + copyTextureToBuffer(options) { + this.commandBuffer.commands.push({ name: "copy-texture-to-buffer", options }); + } + copyTextureToTexture(options) { + this.commandBuffer.commands.push({ name: "copy-texture-to-texture", options }); + } + pushDebugGroup(groupLabel) { + } + popDebugGroup() { + } + insertDebugMarker(markerLabel) { + } + resolveQuerySet(querySet, destination, options) { + } +}; + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-vertex-array.js +var WEBGLVertexArray = class _WEBGLVertexArray extends VertexArray { + get [Symbol.toStringTag]() { + return "VertexArray"; + } + device; + handle; + /** Attribute 0 buffer constant */ + buffer = null; + bufferValue = null; + /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */ + static isConstantAttributeZeroSupported(device) { + return getBrowser() === "Chrome"; + } + // Create a VertexArray + constructor(device, props) { + super(device, props); + this.device = device; + this.handle = this.device.gl.createVertexArray(); + } + destroy() { + super.destroy(); + if (this.buffer) { + this.buffer?.destroy(); + } + if (this.handle) { + this.device.gl.deleteVertexArray(this.handle); + this.handle = void 0; + } + } + /** + // Set (bind/unbind) an elements buffer, for indexed rendering. + // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported + * + * @param elementBuffer + */ + setIndexBuffer(indexBuffer) { + const buffer = indexBuffer; + if (buffer && buffer.glTarget !== 34963) { + throw new Error("Use .setBuffer()"); + } + this.device.gl.bindVertexArray(this.handle); + this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null); + this.indexBuffer = buffer; + this.device.gl.bindVertexArray(null); + } + /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */ + setBuffer(location, attributeBuffer) { + const buffer = attributeBuffer; + if (buffer.glTarget === 34963) { + throw new Error("Use .setIndexBuffer()"); + } + const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location); + this.device.gl.bindVertexArray(this.handle); + this.device.gl.bindBuffer(34962, buffer.handle); + if (integer) { + this.device.gl.vertexAttribIPointer(location, size, type, stride, offset); + } else { + this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset); + } + this.device.gl.bindBuffer(34962, null); + this.device.gl.enableVertexAttribArray(location); + this.device.gl.vertexAttribDivisor(location, divisor || 0); + this.attributes[location] = buffer; + this.device.gl.bindVertexArray(null); + } + /** Set a location in vertex attributes array to a constant value, disables the location */ + setConstantWebGL(location, value) { + this._enable(location, false); + this.attributes[location] = value; + } + bindBeforeRender() { + this.device.gl.bindVertexArray(this.handle); + this._applyConstantAttributes(); + } + unbindAfterRender() { + this.device.gl.bindVertexArray(null); + } + // Internal methods + /** + * Constant attributes need to be reset before every draw call + * Any attribute that is disabled in the current vertex array object + * is read from the context's global constant value for that attribute location. + * @note Constant attributes are only supported in WebGL, not in WebGPU + */ + _applyConstantAttributes() { + for (let location = 0; location < this.maxVertexAttributes; ++location) { + const constant = this.attributes[location]; + if (ArrayBuffer.isView(constant)) { + this.device.setConstantAttributeWebGL(location, constant); + } + } + } + /** + * Set a location in vertex attributes array to a buffer, enables the location, sets divisor + * @note requires vertex array to be bound + */ + // protected _setAttributeLayout(location: number): void { + // const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location); + // // WebGL2 supports *integer* data formats, i.e. GPU will see integer values + // if (integer) { + // this.device.gl.vertexAttribIPointer(location, size, type, stride, offset); + // } else { + // // Attaches ARRAY_BUFFER with specified buffer format to location + // this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset); + // } + // this.device.gl.vertexAttribDivisor(location, divisor || 0); + // } + /** Get an accessor from the */ + _getAccessor(location) { + const attributeInfo = this.attributeInfos[location]; + if (!attributeInfo) { + throw new Error(`Unknown attribute location ${location}`); + } + const glType = getGLFromVertexType(attributeInfo.bufferDataType); + return { + size: attributeInfo.bufferComponents, + type: glType, + stride: attributeInfo.byteStride, + offset: attributeInfo.byteOffset, + normalized: attributeInfo.normalized, + // it is the shader attribute declaration, not the vertex memory format, + // that determines if the data in the buffer will be treated as integers. + // + // Also note that WebGL supports assigning non-normalized integer data to floating point attributes, + // but as far as we can tell, WebGPU does not. + integer: attributeInfo.integer, + divisor: attributeInfo.stepMode === "instance" ? 1 : 0 + }; + } + /** + * Enabling an attribute location makes it reference the currently bound buffer + * Disabling an attribute location makes it reference the global constant value + * TODO - handle single values for size 1 attributes? + * TODO - convert classic arrays based on known type? + */ + _enable(location, enable2 = true) { + const canDisableAttributeZero = _WEBGLVertexArray.isConstantAttributeZeroSupported(this.device); + const canDisableAttribute = canDisableAttributeZero || location !== 0; + if (enable2 || canDisableAttribute) { + location = Number(location); + this.device.gl.bindVertexArray(this.handle); + if (enable2) { + this.device.gl.enableVertexAttribArray(location); + } else { + this.device.gl.disableVertexAttribArray(location); + } + this.device.gl.bindVertexArray(null); + } + } + /** + * Provide a means to create a buffer that is equivalent to a constant. + * NOTE: Desktop OpenGL cannot disable attribute 0. + * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled- + * this-has-significant-performance-penalty + */ + getConstantBuffer(elementCount, value) { + const constantValue = normalizeConstantArrayValue(value); + const byteLength = constantValue.byteLength * elementCount; + const length10 = constantValue.length * elementCount; + if (this.buffer && byteLength !== this.buffer.byteLength) { + throw new Error(`Buffer size is immutable, byte length ${byteLength} !== ${this.buffer.byteLength}.`); + } + let updateNeeded = !this.buffer; + this.buffer = this.buffer || this.device.createBuffer({ byteLength }); + updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue); + if (updateNeeded) { + const typedArray = getScratchArray(value.constructor, length10); + fillArray({ target: typedArray, source: constantValue, start: 0, count: length10 }); + this.buffer.write(typedArray); + this.bufferValue = value; + } + return this.buffer; + } +}; +function normalizeConstantArrayValue(arrayValue) { + if (Array.isArray(arrayValue)) { + return new Float32Array(arrayValue); + } + return arrayValue; +} +function compareConstantArrayValues(v1, v2) { + if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { + return false; + } + for (let i = 0; i < v1.length; ++i) { + if (v1[i] !== v2[i]) { + return false; + } + } + return true; +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-transform-feedback.js +var WEBGLTransformFeedback = class extends TransformFeedback { + device; + gl; + handle; + /** + * NOTE: The Model already has this information while drawing, but + * TransformFeedback currently needs it internally, to look up + * varying information outside of a draw() call. + */ + layout; + buffers = {}; + unusedBuffers = {}; + /** + * Allows us to avoid a Chrome bug where a buffer that is already bound to a + * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target. + * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346 + */ + bindOnUse = true; + _bound = false; + constructor(device, props) { + super(device, props); + this.device = device; + this.gl = device.gl; + this.handle = this.props.handle || this.gl.createTransformFeedback(); + this.layout = this.props.layout; + if (props.buffers) { + this.setBuffers(props.buffers); + } + Object.seal(this); + } + destroy() { + this.gl.deleteTransformFeedback(this.handle); + super.destroy(); + } + begin(topology = "point-list") { + this.gl.bindTransformFeedback(36386, this.handle); + if (this.bindOnUse) { + this._bindBuffers(); + } + this.gl.beginTransformFeedback(getGLPrimitive(topology)); + } + end() { + this.gl.endTransformFeedback(); + if (this.bindOnUse) { + this._unbindBuffers(); + } + this.gl.bindTransformFeedback(36386, null); + } + // SUBCLASS + setBuffers(buffers) { + this.buffers = {}; + this.unusedBuffers = {}; + this.bind(() => { + for (const bufferName in buffers) { + this.setBuffer(bufferName, buffers[bufferName]); + } + }); + } + setBuffer(locationOrName, bufferOrRange) { + const location = this._getVaryingIndex(locationOrName); + const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange); + if (location < 0) { + this.unusedBuffers[locationOrName] = buffer; + log2.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)(); + return; + } + this.buffers[location] = { buffer, byteLength, byteOffset }; + if (!this.bindOnUse) { + this._bindBuffer(location, buffer, byteOffset, byteLength); + } + } + getBuffer(locationOrName) { + if (isIndex(locationOrName)) { + return this.buffers[locationOrName] || null; + } + const location = this._getVaryingIndex(locationOrName); + return location >= 0 ? this.buffers[location] : null; + } + bind(funcOrHandle = this.handle) { + if (typeof funcOrHandle !== "function") { + this.gl.bindTransformFeedback(36386, funcOrHandle); + return this; + } + let value; + if (!this._bound) { + this.gl.bindTransformFeedback(36386, this.handle); + this._bound = true; + value = funcOrHandle(); + this._bound = false; + this.gl.bindTransformFeedback(36386, null); + } else { + value = funcOrHandle(); + } + return value; + } + unbind() { + this.bind(null); + } + // PRIVATE METHODS + /** Extract offsets for bindBufferRange */ + _getBufferRange(bufferOrRange) { + if (bufferOrRange instanceof WEBGLBuffer) { + return { buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength }; + } + const { buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength } = bufferOrRange; + return { buffer, byteOffset, byteLength }; + } + _getVaryingIndex(locationOrName) { + if (isIndex(locationOrName)) { + return Number(locationOrName); + } + for (const varying of this.layout.varyings) { + if (locationOrName === varying.name) { + return varying.location; + } + } + return -1; + } + /** + * Need to avoid chrome bug where buffer that is already bound to a different target + * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target. + */ + _bindBuffers() { + for (const bufferIndex in this.buffers) { + const { buffer, byteLength, byteOffset } = this._getBufferRange(this.buffers[bufferIndex]); + this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength); + } + } + _unbindBuffers() { + for (const bufferIndex in this.buffers) { + this.gl.bindBufferBase(35982, Number(bufferIndex), null); + } + } + _bindBuffer(index2, buffer, byteOffset = 0, byteLength) { + const handle = buffer && buffer.handle; + if (!handle || byteLength === void 0) { + this.gl.bindBufferBase(35982, index2, handle); + } else { + this.gl.bindBufferRange(35982, index2, handle, byteOffset, byteLength); + } + } +}; +function isIndex(value) { + if (typeof value === "number") { + return Number.isInteger(value); + } + return /^\d+$/.test(value); +} + +// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-query-set.js +var WEBGLQuerySet = class extends QuerySet { + device; + handle; + target = null; + _queryPending = false; + _pollingPromise = null; + get [Symbol.toStringTag]() { + return "Query"; + } + // Create a query class + constructor(device, props) { + super(device, props); + this.device = device; + if (props.count > 1) { + throw new Error("WebGL QuerySet can only have one value"); + } + this.handle = this.device.gl.createQuery(); + Object.seal(this); + } + destroy() { + this.device.gl.deleteQuery(this.handle); + } + // FOR RENDER PASS AND COMMAND ENCODER + /** + * Shortcut for timer query (dependent on extension in both WebGL1 and 2) + * Measures GPU time delta between this call and a matching `end` call in the + * GPU instruction stream. + */ + beginTimestampQuery() { + return this._begin(35007); + } + endTimestampQuery() { + this._end(); + } + // Shortcut for occlusion queries + beginOcclusionQuery(options) { + return this._begin(options?.conservative ? 36202 : 35887); + } + endOcclusionQuery() { + this._end(); + } + // Shortcut for transformFeedbackQuery + beginTransformFeedbackQuery() { + return this._begin(35976); + } + endTransformFeedbackQuery() { + this._end(); + } + async resolveQuery() { + const value = await this.pollQuery(); + return [value]; + } + // PRIVATE METHODS + /** + * Due to OpenGL API limitations, after calling `begin()` on one Query + * instance, `end()` must be called on that same instance before + * calling `begin()` on another query. While there can be multiple + * outstanding queries representing disjoint `begin()`/`end()` intervals. + * It is not possible to interleave or overlap `begin` and `end` calls. + */ + _begin(target) { + if (this._queryPending) { + return; + } + this.target = target; + this.device.gl.beginQuery(this.target, this.handle); + return; + } + // ends the current query + _end() { + if (this._queryPending) { + return; + } + if (this.target) { + this.device.gl.endQuery(this.target); + this.target = null; + this._queryPending = true; + } + return; + } + // Returns true if the query result is available + isResultAvailable() { + if (!this._queryPending) { + return false; + } + const resultAvailable = this.device.gl.getQueryParameter(this.handle, 34919); + if (resultAvailable) { + this._queryPending = false; + } + return resultAvailable; + } + // Timing query is disjoint, i.e. results are invalid + isTimerDisjoint() { + return this.device.gl.getParameter(36795); + } + // Returns query result. + getResult() { + return this.device.gl.getQueryParameter(this.handle, 34918); + } + // Returns the query result, converted to milliseconds to match JavaScript conventions. + getTimerMilliseconds() { + return this.getResult() / 1e6; + } + // Polls the query + pollQuery(limit = Number.POSITIVE_INFINITY) { + if (this._pollingPromise) { + return this._pollingPromise; + } + let counter2 = 0; + this._pollingPromise = new Promise((resolve2, reject) => { + const poll = () => { + if (this.isResultAvailable()) { + resolve2(this.getResult()); + this._pollingPromise = null; + } else if (counter2++ > limit) { + reject("Timed out"); + this._pollingPromise = null; + } else { + requestAnimationFrame(poll); + } + }; + requestAnimationFrame(poll); + }); + return this._pollingPromise; + } +}; + +// node_modules/@luma.gl/webgl/dist/classic/format-utils.js +function glFormatToComponents(format) { + switch (format) { + case 6406: + case 33326: + case 6403: + return 1; + case 33328: + case 33319: + return 2; + case 6407: + case 34837: + return 3; + case 6408: + case 34836: + return 4; + default: + assert6(false); + return 0; + } +} +function glTypeToBytes(type) { + switch (type) { + case 5121: + return 1; + case 33635: + case 32819: + case 32820: + return 2; + case 5126: + return 4; + default: + assert6(false); + return 0; + } +} + +// node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js +function readPixelsToArray(source, options) { + const { + sourceX = 0, + sourceY = 0, + sourceFormat = 6408, + sourceAttachment = 36064 + // TODO - support gl.readBuffer + } = options || {}; + let { + target = null, + // following parameters are auto deduced if not provided + sourceWidth, + sourceHeight, + sourceType + } = options || {}; + const { framebuffer, deleteFramebuffer } = getFramebuffer2(source); + assert6(framebuffer); + const { gl, handle } = framebuffer; + sourceWidth = sourceWidth || framebuffer.width; + sourceHeight = sourceHeight || framebuffer.height; + const attachment = sourceAttachment - 36064; + sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.type || 5121; + target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight); + sourceType = sourceType || getGLTypeFromTypedArray(target); + const prevHandle = gl.bindFramebuffer(36160, handle); + gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target); + gl.bindFramebuffer(36160, prevHandle || null); + if (deleteFramebuffer) { + framebuffer.destroy(); + } + return target; +} +function readPixelsToBuffer(source, options) { + const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {}; + let { sourceWidth, sourceHeight, sourceType } = options || {}; + const { framebuffer, deleteFramebuffer } = getFramebuffer2(source); + assert6(framebuffer); + sourceWidth = sourceWidth || framebuffer.width; + sourceHeight = sourceHeight || framebuffer.height; + const webglFramebuffer = framebuffer; + sourceType = sourceType || 5121; + let webglBufferTarget = target; + if (!webglBufferTarget) { + const components = glFormatToComponents(sourceFormat); + const byteCount = glTypeToBytes(sourceType); + const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount; + webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength }); + } + const commandEncoder = source.device.createCommandEncoder(); + commandEncoder.copyTextureToBuffer({ + source, + width: sourceWidth, + height: sourceHeight, + origin: [sourceX, sourceY], + destination: webglBufferTarget, + byteOffset: targetByteOffset + }); + commandEncoder.destroy(); + if (deleteFramebuffer) { + framebuffer.destroy(); + } + return webglBufferTarget; +} +function getFramebuffer2(source) { + if (!(source instanceof Framebuffer)) { + return { framebuffer: toFramebuffer(source), deleteFramebuffer: true }; + } + return { framebuffer: source, deleteFramebuffer: false }; +} +function toFramebuffer(texture, props) { + const { device, width, height, id } = texture; + const framebuffer = device.createFramebuffer({ + ...props, + id: `framebuffer-for-${id}`, + width, + height, + colorAttachments: [texture] + }); + return framebuffer; +} +function getPixelArray(pixelArray, type, format, width, height) { + if (pixelArray) { + return pixelArray; + } + type = type || 5121; + const ArrayType2 = getTypedArrayFromGLType(type, { clamped: false }); + const components = glFormatToComponents(format); + return new ArrayType2(width * height * components); +} + +// node_modules/@luma.gl/webgl/dist/classic/clear.js +var GL_DEPTH_BUFFER_BIT2 = 256; +var GL_STENCIL_BUFFER_BIT2 = 1024; +var GL_COLOR_BUFFER_BIT2 = 16384; +var ERR_ARGUMENTS = "clear: bad arguments"; +function clear(device, options) { + const { framebuffer = null, color = null, depth = null, stencil = null } = options || {}; + const parameters = {}; + if (framebuffer) { + parameters.framebuffer = framebuffer; + } + let clearFlags = 0; + if (color) { + clearFlags |= GL_COLOR_BUFFER_BIT2; + if (color !== true) { + parameters.clearColor = color; + } + } + if (depth) { + clearFlags |= GL_DEPTH_BUFFER_BIT2; + if (depth !== true) { + parameters.clearDepth = depth; + } + } + if (stencil) { + clearFlags |= GL_STENCIL_BUFFER_BIT2; + if (depth !== true) { + parameters.clearStencil = depth; + } + } + assert6(clearFlags !== 0, ERR_ARGUMENTS); + const gl = device.gl; + withGLParameters(gl, parameters, () => { + gl.clear(clearFlags); + }); +} + +// node_modules/@luma.gl/webgl/dist/adapter/webgl-device.js +var LOG_LEVEL2 = 1; +var WebGLDevice = class _WebGLDevice extends Device { + // + // Public `Device` API + // + /** type of this device */ + static type = "webgl"; + /** type of this device */ + type = "webgl"; + /** The underlying WebGL context */ + handle; + features; + limits; + info; + canvasContext; + lost; + _resolveContextLost; + // + // Static methods, expected to be present by `luma.createDevice()` + // + /** Check if WebGL 2 is available */ + static isSupported() { + return typeof WebGL2RenderingContext !== "undefined"; + } + /** + * Get a device instance from a GL context + * Creates and instruments the device if not already created + * @param gl + * @returns + */ + static attach(gl) { + if (gl instanceof _WebGLDevice) { + return gl; + } + if (gl?.device instanceof Device) { + return gl.device; + } + if (!isWebGL(gl)) { + throw new Error("Invalid WebGL2RenderingContext"); + } + return new _WebGLDevice({ gl }); + } + static async create(props = {}) { + log2.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")(); + const promises = []; + if (props.debug) { + promises.push(loadWebGLDeveloperTools()); + } + if (props.spector) { + promises.push(loadSpectorJS()); + } + if (typeof props.canvas === "string") { + promises.push(CanvasContext.pageLoaded); + } + const results = await Promise.allSettled(promises); + for (const result of results) { + if (result.status === "rejected") { + log2.error(`Failed to initialize debug libraries ${result.reason}`)(); + } + } + log2.probe(LOG_LEVEL2 + 1, "DOM is loaded")(); + if (props.gl?.device) { + log2.warn("reattaching existing device")(); + return _WebGLDevice.attach(props.gl); + } + const device = new _WebGLDevice(props); + const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`; + log2.probe(LOG_LEVEL2, message2)(); + log2.table(LOG_LEVEL2, device.info)(); + log2.groupEnd(LOG_LEVEL2)(); + return device; + } + // + // Public API + // + constructor(props) { + super({ ...props, id: props.id || uid("webgl-device") }); + const device = props.gl?.device; + if (device) { + throw new Error(`WebGL context already attached to device ${device.id}`); + } + const canvas2 = props.gl?.canvas || props.canvas; + this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas: canvas2 }); + this.lost = new Promise((resolve2) => { + this._resolveContextLost = resolve2; + }); + let gl = props.gl || null; + gl ||= createBrowserContext(this.canvasContext.canvas, { + ...props, + onContextLost: (event) => this._resolveContextLost?.({ + reason: "destroyed", + message: "Entered sleep mode, or too many apps or browser tabs are using the GPU." + }) + }); + if (!gl) { + throw new Error("WebGL context creation failed"); + } + this.handle = gl; + this.gl = gl; + this.gl.device = this; + this.gl._version = 2; + if (props.spector) { + this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas }); + } + this.info = getDeviceInfo(this.gl, this._extensions); + this.limits = new WebGLDeviceLimits(this.gl); + this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures); + if (this.props.initalizeFeatures) { + this.features.initializeFeatures(); + } + this.canvasContext.resize(); + const { enable: enable2 = true, copyState = false } = props; + trackContextState(this.gl, { + enable: enable2, + copyState, + log: (...args) => log2.log(1, ...args)() + }); + if (props.debug) { + this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true }); + this.debug = true; + log2.level = Math.max(log2.level, 1); + log2.warn("WebGL debug mode activated. Performance reduced.")(); + } + } + /** + * Destroys the context + * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts + */ + destroy() { + } + get isLost() { + return this.gl.isContextLost(); + } + getSize() { + return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight]; + } + isTextureFormatSupported(format) { + return isTextureFormatSupported(this.gl, format, this._extensions); + } + isTextureFormatFilterable(format) { + return isTextureFormatFilterable(this.gl, format, this._extensions); + } + isTextureFormatRenderable(format) { + return isTextureFormatRenderable(this.gl, format, this._extensions); + } + // IMPLEMENTATION OF ABSTRACT DEVICE + createCanvasContext(props) { + throw new Error("WebGL only supports a single canvas"); + } + createBuffer(props) { + const newProps = this._getBufferProps(props); + return new WEBGLBuffer(this, newProps); + } + _createTexture(props) { + return new WEBGLTexture(this, props); + } + createExternalTexture(props) { + throw new Error("createExternalTexture() not implemented"); + } + createSampler(props) { + return new WEBGLSampler(this, props); + } + createShader(props) { + return new WEBGLShader(this, props); + } + createFramebuffer(props) { + return new WEBGLFramebuffer(this, props); + } + createVertexArray(props) { + return new WEBGLVertexArray(this, props); + } + createTransformFeedback(props) { + return new WEBGLTransformFeedback(this, props); + } + createQuerySet(props) { + return new WEBGLQuerySet(this, props); + } + createRenderPipeline(props) { + return new WEBGLRenderPipeline(this, props); + } + beginRenderPass(props) { + return new WEBGLRenderPass(this, props); + } + createComputePipeline(props) { + throw new Error("ComputePipeline not supported in WebGL"); + } + beginComputePass(props) { + throw new Error("ComputePass not supported in WebGL"); + } + renderPass = null; + createCommandEncoder(props) { + return new WEBGLCommandEncoder(this, props); + } + /** + * Offscreen Canvas Support: Commit the frame + * https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/commit + * Chrome's offscreen canvas does not require gl.commit + */ + submit() { + this.renderPass?.end(); + this.renderPass = null; + } + // + // TEMPORARY HACKS - will be removed in v9.1 + // + /** @deprecated - should use command encoder */ + readPixelsToArrayWebGL(source, options) { + return readPixelsToArray(source, options); + } + /** @deprecated - should use command encoder */ + readPixelsToBufferWebGL(source, options) { + return readPixelsToBuffer(source, options); + } + setParametersWebGL(parameters) { + setGLParameters(this.gl, parameters); + } + getParametersWebGL(parameters) { + return getGLParameters(this.gl, parameters); + } + withParametersWebGL(parameters, func) { + return withGLParameters(this.gl, parameters, func); + } + clearWebGL(options) { + clear(this, options); + } + resetWebGL() { + log2.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")(); + resetGLParameters(this.gl); + } + // + // WebGL-only API (not part of `Device` API) + // + /** WebGL2 context. */ + gl; + debug = false; + /** State used by luma.gl classes: TODO - move to canvasContext*/ + _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 }; + /** State used by luma.gl classes - TODO - not used? */ + _extensions = {}; + _polyfilled = false; + /** Instance of Spector.js (if initialized) */ + spectorJS; + /** + * Triggers device (or WebGL context) loss. + * @note primarily intended for testing how application reacts to device loss + */ + loseDevice() { + let deviceLossTriggered = false; + const extensions = this.getExtension("WEBGL_lose_context"); + const ext = extensions.WEBGL_lose_context; + if (ext) { + deviceLossTriggered = true; + ext.loseContext(); + } + this._resolveContextLost?.({ + reason: "destroyed", + message: "Application triggered context loss" + }); + return deviceLossTriggered; + } + /** Save current WebGL context state onto an internal stack */ + pushState() { + pushContextState(this.gl); + } + /** Restores previously saved context state */ + popState() { + popContextState(this.gl); + } + /** + * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension + * luma.gl ids and props can be inspected + */ + setSpectorMetadata(handle, props) { + handle.__SPECTOR_Metadata = props; + } + /** + * Returns the GL. constant that corresponds to a numeric value of a GL constant + * Be aware that there are some duplicates especially for constants that are 0, + * so this isn't guaranteed to return the right key in all cases. + */ + getGLKey(value, gl) { + gl = gl || this.gl2 || this.gl; + const number = Number(value); + for (const key in gl) { + if (gl[key] === number) { + return `GL.${key}`; + } + } + return String(value); + } + /** Store constants */ + _constants; + /** + * Set a constant value for a location. Disabled attributes at that location will read from this value + * @note WebGL constants are stored globally on the WebGL context, not the VertexArray + * so they need to be updated before every render + * @todo - remember/cache values to avoid setting them unnecessarily? + */ + setConstantAttributeWebGL(location, constant) { + const maxVertexAttributes = this.limits.maxVertexAttributes; + this._constants = this._constants || new Array(maxVertexAttributes).fill(null); + const currentConstant = this._constants[location]; + if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) { + log2.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)(); + } + this._constants[location] = constant; + switch (constant.constructor) { + case Float32Array: + setConstantFloatArray(this, location, constant); + break; + case Int32Array: + setConstantIntArray(this, location, constant); + break; + case Uint32Array: + setConstantUintArray(this, location, constant); + break; + default: + assert6(false); + } + } + /** Ensure extensions are only requested once */ + getExtension(name2) { + getWebGLExtension(this.gl, name2, this._extensions); + return this._extensions; + } +}; +function isWebGL(gl) { + if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { + return true; + } + return Boolean(gl && Number.isFinite(gl._version)); +} +function setConstantFloatArray(device, location, array) { + switch (array.length) { + case 1: + device.gl.vertexAttrib1fv(location, array); + break; + case 2: + device.gl.vertexAttrib2fv(location, array); + break; + case 3: + device.gl.vertexAttrib3fv(location, array); + break; + case 4: + device.gl.vertexAttrib4fv(location, array); + break; + default: + assert6(false); + } +} +function setConstantIntArray(device, location, array) { + device.gl.vertexAttribI4iv(location, array); +} +function setConstantUintArray(device, location, array) { + device.gl.vertexAttribI4uiv(location, array); +} +function compareConstantArrayValues2(v1, v2) { + if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { + return false; + } + for (let i = 0; i < v1.length; ++i) { + if (v1[i] !== v2[i]) { + return false; + } + } + return true; +} + +// node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js +var hammerjs = __toESM(require_hammer()); + +// node_modules/mjolnir.js/dist/esm/utils/hammer-overrides.js +var INPUT_START = 1; +var INPUT_MOVE = 2; +var INPUT_END = 4; +var MOUSE_INPUT_MAP = { + mousedown: INPUT_START, + mousemove: INPUT_MOVE, + mouseup: INPUT_END +}; +function some(array, predict) { + for (let i = 0; i < array.length; i++) { + if (predict(array[i])) { + return true; + } + } + return false; +} +function enhancePointerEventInput(PointerEventInput2) { + const oldHandler = PointerEventInput2.prototype.handler; + PointerEventInput2.prototype.handler = function handler(ev) { + const store = this.store; + if (ev.button > 0 && ev.type === "pointerdown") { + if (!some(store, (e) => e.pointerId === ev.pointerId)) { + store.push(ev); + } + } + oldHandler.call(this, ev); + }; +} +function enhanceMouseInput(MouseInput2) { + MouseInput2.prototype.handler = function handler(ev) { + let eventType = MOUSE_INPUT_MAP[ev.type]; + if (eventType & INPUT_START && ev.button >= 0) { + this.pressed = true; + } + if (eventType & INPUT_MOVE && ev.which === 0) { + eventType = INPUT_END; + } + if (!this.pressed) { + return; + } + if (eventType & INPUT_END) { + this.pressed = false; + } + this.callback(this.manager, eventType, { + pointers: [ev], + changedPointers: [ev], + pointerType: "mouse", + srcEvent: ev + }); + }; +} + +// node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js +enhancePointerEventInput(hammerjs.PointerEventInput); +enhanceMouseInput(hammerjs.MouseInput); +var Manager2 = hammerjs.Manager; +var hammer_browser_default = hammerjs; + +// node_modules/mjolnir.js/dist/esm/inputs/input.js +var Input = class { + constructor(element, callback, options) { + this.element = element; + this.callback = callback; + this.options = { enable: true, ...options }; + } +}; + +// node_modules/mjolnir.js/dist/esm/constants.js +var RECOGNIZERS = hammer_browser_default ? [ + [hammer_browser_default.Pan, { event: "tripan", pointers: 3, threshold: 0, enable: false }], + [hammer_browser_default.Rotate, { enable: false }], + [hammer_browser_default.Pinch, { enable: false }], + [hammer_browser_default.Swipe, { enable: false }], + [hammer_browser_default.Pan, { threshold: 0, enable: false }], + [hammer_browser_default.Press, { enable: false }], + [hammer_browser_default.Tap, { event: "doubletap", taps: 2, enable: false }], + // TODO - rename to 'tap' and 'singletap' in the next major release + [hammer_browser_default.Tap, { event: "anytap", enable: false }], + [hammer_browser_default.Tap, { enable: false }] +] : null; +var RECOGNIZER_COMPATIBLE_MAP = { + tripan: ["rotate", "pinch", "pan"], + rotate: ["pinch"], + pinch: ["pan"], + pan: ["press", "doubletap", "anytap", "tap"], + doubletap: ["anytap"], + anytap: ["tap"] +}; +var RECOGNIZER_FALLBACK_MAP = { + doubletap: ["tap"] +}; +var BASIC_EVENT_ALIASES = { + pointerdown: "pointerdown", + pointermove: "pointermove", + pointerup: "pointerup", + touchstart: "pointerdown", + touchmove: "pointermove", + touchend: "pointerup", + mousedown: "pointerdown", + mousemove: "pointermove", + mouseup: "pointerup" +}; +var INPUT_EVENT_TYPES = { + KEY_EVENTS: ["keydown", "keyup"], + MOUSE_EVENTS: ["mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "mouseleave"], + WHEEL_EVENTS: [ + // Chrome, Safari + "wheel", + // IE + "mousewheel" + ] +}; +var EVENT_RECOGNIZER_MAP = { + tap: "tap", + anytap: "anytap", + doubletap: "doubletap", + press: "press", + pinch: "pinch", + pinchin: "pinch", + pinchout: "pinch", + pinchstart: "pinch", + pinchmove: "pinch", + pinchend: "pinch", + pinchcancel: "pinch", + rotate: "rotate", + rotatestart: "rotate", + rotatemove: "rotate", + rotateend: "rotate", + rotatecancel: "rotate", + tripan: "tripan", + tripanstart: "tripan", + tripanmove: "tripan", + tripanup: "tripan", + tripandown: "tripan", + tripanleft: "tripan", + tripanright: "tripan", + tripanend: "tripan", + tripancancel: "tripan", + pan: "pan", + panstart: "pan", + panmove: "pan", + panup: "pan", + pandown: "pan", + panleft: "pan", + panright: "pan", + panend: "pan", + pancancel: "pan", + swipe: "swipe", + swipeleft: "swipe", + swiperight: "swipe", + swipeup: "swipe", + swipedown: "swipe" +}; +var GESTURE_EVENT_ALIASES = { + click: "tap", + anyclick: "anytap", + dblclick: "doubletap", + mousedown: "pointerdown", + mousemove: "pointermove", + mouseup: "pointerup", + mouseover: "pointerover", + mouseout: "pointerout", + mouseleave: "pointerleave" +}; + +// node_modules/mjolnir.js/dist/esm/utils/globals.js +var userAgent = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : ""; +var window_5 = typeof window !== "undefined" ? window : global; +var passiveSupported = false; +try { + const options = { + // This function will be called when the browser + // attempts to access the passive property. + get passive() { + passiveSupported = true; + return true; + } + }; + window_5.addEventListener("test", null, options); + window_5.removeEventListener("test", null); +} catch (err) { + passiveSupported = false; +} + +// node_modules/mjolnir.js/dist/esm/inputs/wheel-input.js +var firefox = userAgent.indexOf("firefox") !== -1; +var { WHEEL_EVENTS } = INPUT_EVENT_TYPES; +var EVENT_TYPE = "wheel"; +var WHEEL_DELTA_MAGIC_SCALER = 4.000244140625; +var WHEEL_DELTA_PER_LINE = 40; +var SHIFT_MULTIPLIER = 0.25; +var WheelInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + if (!this.options.enable) { + return; + } + let value = event.deltaY; + if (window_5.WheelEvent) { + if (firefox && event.deltaMode === window_5.WheelEvent.DOM_DELTA_PIXEL) { + value /= window_5.devicePixelRatio; + } + if (event.deltaMode === window_5.WheelEvent.DOM_DELTA_LINE) { + value *= WHEEL_DELTA_PER_LINE; + } + } + if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) { + value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER); + } + if (event.shiftKey && value) { + value = value * SHIFT_MULTIPLIER; + } + this.callback({ + type: EVENT_TYPE, + center: { + x: event.clientX, + y: event.clientY + }, + delta: -value, + srcEvent: event, + pointerType: "mouse", + target: event.target + }); + }; + this.events = (this.options.events || []).concat(WHEEL_EVENTS); + this.events.forEach((event) => element.addEventListener(event, this.handleEvent, passiveSupported ? { passive: false } : false)); + } + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === EVENT_TYPE) { + this.options.enable = enabled; + } + } +}; + +// node_modules/mjolnir.js/dist/esm/inputs/move-input.js +var { MOUSE_EVENTS } = INPUT_EVENT_TYPES; +var MOVE_EVENT_TYPE = "pointermove"; +var OVER_EVENT_TYPE = "pointerover"; +var OUT_EVENT_TYPE = "pointerout"; +var ENTER_EVENT_TYPE = "pointerenter"; +var LEAVE_EVENT_TYPE = "pointerleave"; +var MoveInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + this.handleOverEvent(event); + this.handleOutEvent(event); + this.handleEnterEvent(event); + this.handleLeaveEvent(event); + this.handleMoveEvent(event); + }; + this.pressed = false; + const { enable: enable2 } = this.options; + this.enableMoveEvent = enable2; + this.enableLeaveEvent = enable2; + this.enableEnterEvent = enable2; + this.enableOutEvent = enable2; + this.enableOverEvent = enable2; + this.events = (this.options.events || []).concat(MOUSE_EVENTS); + this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); + } + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === MOVE_EVENT_TYPE) { + this.enableMoveEvent = enabled; + } + if (eventType === OVER_EVENT_TYPE) { + this.enableOverEvent = enabled; + } + if (eventType === OUT_EVENT_TYPE) { + this.enableOutEvent = enabled; + } + if (eventType === ENTER_EVENT_TYPE) { + this.enableEnterEvent = enabled; + } + if (eventType === LEAVE_EVENT_TYPE) { + this.enableLeaveEvent = enabled; + } + } + handleOverEvent(event) { + if (this.enableOverEvent) { + if (event.type === "mouseover") { + this._emit(OVER_EVENT_TYPE, event); + } + } + } + handleOutEvent(event) { + if (this.enableOutEvent) { + if (event.type === "mouseout") { + this._emit(OUT_EVENT_TYPE, event); + } + } + } + handleEnterEvent(event) { + if (this.enableEnterEvent) { + if (event.type === "mouseenter") { + this._emit(ENTER_EVENT_TYPE, event); + } + } + } + handleLeaveEvent(event) { + if (this.enableLeaveEvent) { + if (event.type === "mouseleave") { + this._emit(LEAVE_EVENT_TYPE, event); + } + } + } + handleMoveEvent(event) { + if (this.enableMoveEvent) { + switch (event.type) { + case "mousedown": + if (event.button >= 0) { + this.pressed = true; + } + break; + case "mousemove": + if (event.which === 0) { + this.pressed = false; + } + if (!this.pressed) { + this._emit(MOVE_EVENT_TYPE, event); + } + break; + case "mouseup": + this.pressed = false; + break; + default: + } + } + } + _emit(type, event) { + this.callback({ + type, + center: { + x: event.clientX, + y: event.clientY + }, + srcEvent: event, + pointerType: "mouse", + target: event.target + }); + } +}; + +// node_modules/mjolnir.js/dist/esm/inputs/key-input.js +var { KEY_EVENTS } = INPUT_EVENT_TYPES; +var DOWN_EVENT_TYPE = "keydown"; +var UP_EVENT_TYPE = "keyup"; +var KeyInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + const targetElement = event.target || event.srcElement; + if (targetElement.tagName === "INPUT" && targetElement.type === "text" || targetElement.tagName === "TEXTAREA") { + return; + } + if (this.enableDownEvent && event.type === "keydown") { + this.callback({ + type: DOWN_EVENT_TYPE, + srcEvent: event, + key: event.key, + target: event.target + }); + } + if (this.enableUpEvent && event.type === "keyup") { + this.callback({ + type: UP_EVENT_TYPE, + srcEvent: event, + key: event.key, + target: event.target + }); + } + }; + this.enableDownEvent = this.options.enable; + this.enableUpEvent = this.options.enable; + this.events = (this.options.events || []).concat(KEY_EVENTS); + element.tabIndex = this.options.tabIndex || 0; + element.style.outline = "none"; + this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); + } + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === DOWN_EVENT_TYPE) { + this.enableDownEvent = enabled; + } + if (eventType === UP_EVENT_TYPE) { + this.enableUpEvent = enabled; + } + } +}; + +// node_modules/mjolnir.js/dist/esm/inputs/contextmenu-input.js +var EVENT_TYPE2 = "contextmenu"; +var ContextmenuInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + if (!this.options.enable) { + return; + } + this.callback({ + type: EVENT_TYPE2, + center: { + x: event.clientX, + y: event.clientY + }, + srcEvent: event, + pointerType: "mouse", + target: event.target + }); + }; + element.addEventListener("contextmenu", this.handleEvent); + } + destroy() { + this.element.removeEventListener("contextmenu", this.handleEvent); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === EVENT_TYPE2) { + this.options.enable = enabled; + } + } +}; + +// node_modules/mjolnir.js/dist/esm/utils/event-utils.js +var DOWN_EVENT = 1; +var MOVE_EVENT = 2; +var UP_EVENT = 4; +var MOUSE_EVENTS2 = { + pointerdown: DOWN_EVENT, + pointermove: MOVE_EVENT, + pointerup: UP_EVENT, + mousedown: DOWN_EVENT, + mousemove: MOVE_EVENT, + mouseup: UP_EVENT +}; +var MOUSE_EVENT_WHICH_LEFT = 1; +var MOUSE_EVENT_WHICH_MIDDLE = 2; +var MOUSE_EVENT_WHICH_RIGHT = 3; +var MOUSE_EVENT_BUTTON_LEFT = 0; +var MOUSE_EVENT_BUTTON_MIDDLE = 1; +var MOUSE_EVENT_BUTTON_RIGHT = 2; +var MOUSE_EVENT_BUTTONS_LEFT_MASK = 1; +var MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2; +var MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4; +function whichButtons(event) { + const eventType = MOUSE_EVENTS2[event.srcEvent.type]; + if (!eventType) { + return null; + } + const { buttons, button, which } = event.srcEvent; + let leftButton = false; + let middleButton = false; + let rightButton = false; + if ( + // button is up, need to find out which one was pressed before + eventType === UP_EVENT || // moving but does not support `buttons` API + eventType === MOVE_EVENT && !Number.isFinite(buttons) + ) { + leftButton = which === MOUSE_EVENT_WHICH_LEFT; + middleButton = which === MOUSE_EVENT_WHICH_MIDDLE; + rightButton = which === MOUSE_EVENT_WHICH_RIGHT; + } else if (eventType === MOVE_EVENT) { + leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK); + middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK); + rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK); + } else if (eventType === DOWN_EVENT) { + leftButton = button === MOUSE_EVENT_BUTTON_LEFT; + middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE; + rightButton = button === MOUSE_EVENT_BUTTON_RIGHT; + } + return { leftButton, middleButton, rightButton }; +} +function getOffsetPosition(event, rootElement) { + const center = event.center; + if (!center) { + return null; + } + const rect = rootElement.getBoundingClientRect(); + const scaleX2 = rect.width / rootElement.offsetWidth || 1; + const scaleY2 = rect.height / rootElement.offsetHeight || 1; + const offsetCenter = { + x: (center.x - rect.left - rootElement.clientLeft) / scaleX2, + y: (center.y - rect.top - rootElement.clientTop) / scaleY2 + }; + return { center, offsetCenter }; +} + +// node_modules/mjolnir.js/dist/esm/utils/event-registrar.js +var DEFAULT_OPTIONS = { + srcElement: "root", + priority: 0 +}; +var EventRegistrar = class { + constructor(eventManager) { + this.handleEvent = (event) => { + if (this.isEmpty()) { + return; + } + const mjolnirEvent = this._normalizeEvent(event); + let target = event.srcEvent.target; + while (target && target !== mjolnirEvent.rootElement) { + this._emit(mjolnirEvent, target); + if (mjolnirEvent.handled) { + return; + } + target = target.parentNode; + } + this._emit(mjolnirEvent, "root"); + }; + this.eventManager = eventManager; + this.handlers = []; + this.handlersByElement = /* @__PURE__ */ new Map(); + this._active = false; + } + // Returns true if there are no non-passive handlers + isEmpty() { + return !this._active; + } + add(type, handler, options, once = false, passive = false) { + const { handlers, handlersByElement } = this; + let opts = DEFAULT_OPTIONS; + if (typeof options === "string" || options && options.addEventListener) { + opts = { ...DEFAULT_OPTIONS, srcElement: options }; + } else if (options) { + opts = { ...DEFAULT_OPTIONS, ...options }; + } + let entries = handlersByElement.get(opts.srcElement); + if (!entries) { + entries = []; + handlersByElement.set(opts.srcElement, entries); + } + const entry = { + type, + handler, + srcElement: opts.srcElement, + priority: opts.priority + }; + if (once) { + entry.once = true; + } + if (passive) { + entry.passive = true; + } + handlers.push(entry); + this._active = this._active || !entry.passive; + let insertPosition = entries.length - 1; + while (insertPosition >= 0) { + if (entries[insertPosition].priority >= entry.priority) { + break; + } + insertPosition--; + } + entries.splice(insertPosition + 1, 0, entry); + } + remove(type, handler) { + const { handlers, handlersByElement } = this; + for (let i = handlers.length - 1; i >= 0; i--) { + const entry = handlers[i]; + if (entry.type === type && entry.handler === handler) { + handlers.splice(i, 1); + const entries = handlersByElement.get(entry.srcElement); + entries.splice(entries.indexOf(entry), 1); + if (entries.length === 0) { + handlersByElement.delete(entry.srcElement); + } + } + } + this._active = handlers.some((entry) => !entry.passive); + } + /** + * Invoke handlers on a particular element + */ + _emit(event, srcElement) { + const entries = this.handlersByElement.get(srcElement); + if (entries) { + let immediatePropagationStopped = false; + const stopPropagation = () => { + event.handled = true; + }; + const stopImmediatePropagation = () => { + event.handled = true; + immediatePropagationStopped = true; + }; + const entriesToRemove = []; + for (let i = 0; i < entries.length; i++) { + const { type, handler, once } = entries[i]; + handler({ + ...event, + // @ts-ignore + type, + stopPropagation, + stopImmediatePropagation + }); + if (once) { + entriesToRemove.push(entries[i]); + } + if (immediatePropagationStopped) { + break; + } + } + for (let i = 0; i < entriesToRemove.length; i++) { + const { type, handler } = entriesToRemove[i]; + this.remove(type, handler); + } + } + } + /** + * Normalizes hammerjs and custom events to have predictable fields. + */ + _normalizeEvent(event) { + const rootElement = this.eventManager.getElement(); + return { + ...event, + ...whichButtons(event), + ...getOffsetPosition(event, rootElement), + preventDefault: () => { + event.srcEvent.preventDefault(); + }, + stopImmediatePropagation: null, + stopPropagation: null, + handled: false, + rootElement + }; + } +}; + +// node_modules/mjolnir.js/dist/esm/event-manager.js +var DEFAULT_OPTIONS2 = { + // event handlers + events: null, + // custom recognizers + recognizers: null, + recognizerOptions: {}, + // Manager class + Manager: Manager2, + // allow browser default touch action + // https://github.com/uber/react-map-gl/issues/506 + touchAction: "none", + tabIndex: 0 +}; +var EventManager = class { + constructor(element = null, options) { + this._onBasicInput = (event) => { + const { srcEvent } = event; + const alias = BASIC_EVENT_ALIASES[srcEvent.type]; + if (alias) { + this.manager.emit(alias, event); + } + }; + this._onOtherEvent = (event) => { + this.manager.emit(event.type, event); + }; + this.options = { ...DEFAULT_OPTIONS2, ...options }; + this.events = /* @__PURE__ */ new Map(); + this.setElement(element); + const { events } = this.options; + if (events) { + this.on(events); + } + } + getElement() { + return this.element; + } + setElement(element) { + if (this.element) { + this.destroy(); + } + this.element = element; + if (!element) { + return; + } + const { options } = this; + const ManagerClass = options.Manager; + this.manager = new ManagerClass(element, { + touchAction: options.touchAction, + recognizers: options.recognizers || RECOGNIZERS + }).on("hammer.input", this._onBasicInput); + if (!options.recognizers) { + Object.keys(RECOGNIZER_COMPATIBLE_MAP).forEach((name2) => { + const recognizer = this.manager.get(name2); + if (recognizer) { + RECOGNIZER_COMPATIBLE_MAP[name2].forEach((otherName) => { + recognizer.recognizeWith(otherName); + }); + } + }); + } + for (const recognizerName in options.recognizerOptions) { + const recognizer = this.manager.get(recognizerName); + if (recognizer) { + const recognizerOption = options.recognizerOptions[recognizerName]; + delete recognizerOption.enable; + recognizer.set(recognizerOption); + } + } + this.wheelInput = new WheelInput(element, this._onOtherEvent, { + enable: false + }); + this.moveInput = new MoveInput(element, this._onOtherEvent, { + enable: false + }); + this.keyInput = new KeyInput(element, this._onOtherEvent, { + enable: false, + tabIndex: options.tabIndex + }); + this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, { + enable: false + }); + for (const [eventAlias, eventRegistrar] of this.events) { + if (!eventRegistrar.isEmpty()) { + this._toggleRecognizer(eventRegistrar.recognizerName, true); + this.manager.on(eventAlias, eventRegistrar.handleEvent); + } + } + } + // Tear down internal event management implementations. + destroy() { + if (this.element) { + this.wheelInput.destroy(); + this.moveInput.destroy(); + this.keyInput.destroy(); + this.contextmenuInput.destroy(); + this.manager.destroy(); + this.wheelInput = null; + this.moveInput = null; + this.keyInput = null; + this.contextmenuInput = null; + this.manager = null; + this.element = null; + } + } + /** Register an event handler function to be called on `event` */ + on(event, handler, opts) { + this._addEventHandler(event, handler, opts, false); + } + once(event, handler, opts) { + this._addEventHandler(event, handler, opts, true); + } + watch(event, handler, opts) { + this._addEventHandler(event, handler, opts, false, true); + } + off(event, handler) { + this._removeEventHandler(event, handler); + } + /* + * Enable/disable recognizer for the given event + */ + _toggleRecognizer(name2, enabled) { + const { manager } = this; + if (!manager) { + return; + } + const recognizer = manager.get(name2); + if (recognizer && recognizer.options.enable !== enabled) { + recognizer.set({ enable: enabled }); + const fallbackRecognizers = RECOGNIZER_FALLBACK_MAP[name2]; + if (fallbackRecognizers && !this.options.recognizers) { + fallbackRecognizers.forEach((otherName) => { + const otherRecognizer = manager.get(otherName); + if (enabled) { + otherRecognizer.requireFailure(name2); + recognizer.dropRequireFailure(otherName); + } else { + otherRecognizer.dropRequireFailure(name2); + } + }); + } + } + this.wheelInput.enableEventType(name2, enabled); + this.moveInput.enableEventType(name2, enabled); + this.keyInput.enableEventType(name2, enabled); + this.contextmenuInput.enableEventType(name2, enabled); + } + /** + * Process the event registration for a single event + handler. + */ + _addEventHandler(event, handler, opts, once, passive) { + if (typeof event !== "string") { + opts = handler; + for (const eventName in event) { + this._addEventHandler(eventName, event[eventName], opts, once, passive); + } + return; + } + const { manager, events } = this; + const eventAlias = GESTURE_EVENT_ALIASES[event] || event; + let eventRegistrar = events.get(eventAlias); + if (!eventRegistrar) { + eventRegistrar = new EventRegistrar(this); + events.set(eventAlias, eventRegistrar); + eventRegistrar.recognizerName = EVENT_RECOGNIZER_MAP[eventAlias] || eventAlias; + if (manager) { + manager.on(eventAlias, eventRegistrar.handleEvent); + } + } + eventRegistrar.add(event, handler, opts, once, passive); + if (!eventRegistrar.isEmpty()) { + this._toggleRecognizer(eventRegistrar.recognizerName, true); + } + } + /** + * Process the event deregistration for a single event + handler. + */ + _removeEventHandler(event, handler) { + if (typeof event !== "string") { + for (const eventName in event) { + this._removeEventHandler(eventName, event[eventName]); + } + return; + } + const { events } = this; + const eventAlias = GESTURE_EVENT_ALIASES[event] || event; + const eventRegistrar = events.get(eventAlias); + if (!eventRegistrar) { + return; + } + eventRegistrar.remove(event, handler); + if (eventRegistrar.isEmpty()) { + const { recognizerName } = eventRegistrar; + let isRecognizerUsed = false; + for (const eh of events.values()) { + if (eh.recognizerName === recognizerName && !eh.isEmpty()) { + isRecognizerUsed = true; + break; + } + } + if (!isRecognizerUsed) { + this._toggleRecognizer(recognizerName, false); + } + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/deck.js +function noop3() { +} +var getCursor = ({ isDragging }) => isDragging ? "grabbing" : "grab"; +var defaultProps = { + id: "", + width: "100%", + height: "100%", + style: null, + viewState: null, + initialViewState: null, + pickingRadius: 0, + layerFilter: null, + parameters: {}, + parent: null, + device: null, + deviceProps: { type: "webgl" }, + gl: null, + glOptions: {}, + canvas: null, + layers: [], + effects: [], + views: null, + controller: null, + // Rely on external controller, e.g. react-map-gl + useDevicePixels: true, + touchAction: "none", + eventRecognizerOptions: {}, + _framebuffer: null, + _animate: false, + _pickable: true, + _typedArrayManagerProps: {}, + _customRender: null, + widgets: [], + onDeviceInitialized: noop3, + onWebGLInitialized: noop3, + onResize: noop3, + onViewStateChange: noop3, + onInteractionStateChange: noop3, + onBeforeRender: noop3, + onAfterRender: noop3, + onLoad: noop3, + onError: (error) => log_default.error(error.message, error.cause)(), + onHover: null, + onClick: null, + onDragStart: null, + onDrag: null, + onDragEnd: null, + _onMetrics: null, + getCursor, + getTooltip: null, + debug: false, + drawPickingColors: false +}; +var Deck = class { + constructor(props) { + this.width = 0; + this.height = 0; + this.userData = {}; + this.device = null; + this.canvas = null; + this.viewManager = null; + this.layerManager = null; + this.effectManager = null; + this.deckRenderer = null; + this.deckPicker = null; + this.eventManager = null; + this.widgetManager = null; + this.tooltip = null; + this.animationLoop = null; + this.cursorState = { + isHovering: false, + isDragging: false + }; + this.stats = new Stats({ id: "deck.gl" }); + this.metrics = { + fps: 0, + setPropsTime: 0, + updateAttributesTime: 0, + framesRedrawn: 0, + pickTime: 0, + pickCount: 0, + gpuTime: 0, + gpuTimePerFrame: 0, + cpuTime: 0, + cpuTimePerFrame: 0, + bufferMemory: 0, + textureMemory: 0, + renderbufferMemory: 0, + gpuMemory: 0 + }; + this._metricsCounter = 0; + this._needsRedraw = "Initial render"; + this._pickRequest = { + mode: "hover", + x: -1, + y: -1, + radius: 0, + event: null + }; + this._lastPointerDownInfo = null; + this._onPointerMove = (event) => { + const { _pickRequest } = this; + if (event.type === "pointerleave") { + _pickRequest.x = -1; + _pickRequest.y = -1; + _pickRequest.radius = 0; + } else if (event.leftButton || event.rightButton) { + return; + } else { + const pos = event.offsetCenter; + if (!pos) { + return; + } + _pickRequest.x = pos.x; + _pickRequest.y = pos.y; + _pickRequest.radius = this.props.pickingRadius; + } + if (this.layerManager) { + this.layerManager.context.mousePosition = { x: _pickRequest.x, y: _pickRequest.y }; + } + _pickRequest.event = event; + }; + this._onEvent = (event) => { + const eventOptions = EVENTS[event.type]; + const pos = event.offsetCenter; + if (!eventOptions || !pos || !this.layerManager) { + return; + } + const layers = this.layerManager.getLayers(); + const info = this.deckPicker.getLastPickedObject({ + x: pos.x, + y: pos.y, + layers, + viewports: this.getViewports(pos) + }, this._lastPointerDownInfo); + const { layer } = info; + const layerHandler = layer && (layer[eventOptions.handler] || layer.props[eventOptions.handler]); + const rootHandler = this.props[eventOptions.handler]; + let handled = false; + if (layerHandler) { + handled = layerHandler.call(layer, info, event); + } + if (!handled) { + rootHandler?.(info, event); + this.widgetManager.onEvent(info, event); + } + }; + this._onPointerDown = (event) => { + const pos = event.offsetCenter; + const pickedInfo = this._pick("pickObject", "pickObject Time", { + x: pos.x, + y: pos.y, + radius: this.props.pickingRadius + }); + this._lastPointerDownInfo = pickedInfo.result[0] || pickedInfo.emptyInfo; + }; + this.props = { ...defaultProps, ...props }; + props = this.props; + if (props.viewState && props.initialViewState) { + log_default.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(); + } + this.viewState = this.props.initialViewState; + if (props.device) { + this.device = props.device; + } else if (props.gl) { + if (props.gl instanceof WebGLRenderingContext) { + log_default.error("WebGL1 context not supported.")(); + } + this.device = WebGLDevice.attach(props.gl); + } + let deviceOrPromise = this.device; + if (!deviceOrPromise) { + luma.registerDevices([WebGLDevice]); + deviceOrPromise = luma.createDevice({ + ...props.deviceProps, + canvas: this._createCanvas(props) + }); + } + this.animationLoop = this._createAnimationLoop(deviceOrPromise, props); + this.setProps(props); + if (props._typedArrayManagerProps) { + typed_array_manager_default.setOptions(props._typedArrayManagerProps); + } + this.animationLoop.start(); + } + /** Stop rendering and dispose all resources */ + finalize() { + this.animationLoop?.stop(); + this.animationLoop?.destroy(); + this.animationLoop = null; + this._lastPointerDownInfo = null; + this.layerManager?.finalize(); + this.layerManager = null; + this.viewManager?.finalize(); + this.viewManager = null; + this.effectManager?.finalize(); + this.effectManager = null; + this.deckRenderer?.finalize(); + this.deckRenderer = null; + this.deckPicker?.finalize(); + this.deckPicker = null; + this.eventManager?.destroy(); + this.eventManager = null; + this.widgetManager?.finalize(); + this.widgetManager = null; + if (!this.props.canvas && !this.props.device && !this.props.gl && this.canvas) { + this.canvas.parentElement?.removeChild(this.canvas); + this.canvas = null; + } + } + /** Partially update props */ + setProps(props) { + this.stats.get("setProps Time").timeStart(); + if ("onLayerHover" in props) { + log_default.removed("onLayerHover", "onHover")(); + } + if ("onLayerClick" in props) { + log_default.removed("onLayerClick", "onClick")(); + } + if (props.initialViewState && // depth = 3 when comparing viewStates: viewId.position.0 + !deepEqual2(this.props.initialViewState, props.initialViewState, 3)) { + this.viewState = props.initialViewState; + } + Object.assign(this.props, props); + this._setCanvasSize(this.props); + const resolvedProps = Object.create(this.props); + Object.assign(resolvedProps, { + views: this._getViews(), + width: this.width, + height: this.height, + viewState: this._getViewState() + }); + this.animationLoop?.setProps(resolvedProps); + if (this.layerManager) { + this.viewManager.setProps(resolvedProps); + this.layerManager.activateViewport(this.getViewports()[0]); + this.layerManager.setProps(resolvedProps); + this.effectManager.setProps(resolvedProps); + this.deckRenderer.setProps(resolvedProps); + this.deckPicker.setProps(resolvedProps); + this.widgetManager.setProps(resolvedProps); + } + this.stats.get("setProps Time").timeEnd(); + } + // Public API + /** + * Check if a redraw is needed + * @returns `false` or a string summarizing the redraw reason + */ + needsRedraw(opts = { clearRedrawFlags: false }) { + if (!this.layerManager) { + return false; + } + if (this.props._animate) { + return "Deck._animate"; + } + let redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts); + const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts); + const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts); + const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts); + redraw = redraw || viewManagerNeedsRedraw || layerManagerNeedsRedraw || effectManagerNeedsRedraw || deckRendererNeedsRedraw; + return redraw; + } + /** + * Redraw the GL context + * @param reason If not provided, only redraw if deemed necessary. Otherwise redraw regardless of internal states. + * @returns + */ + redraw(reason) { + if (!this.layerManager) { + return; + } + let redrawReason = this.needsRedraw({ clearRedrawFlags: true }); + redrawReason = reason || redrawReason; + if (!redrawReason) { + return; + } + this.stats.get("Redraw Count").incrementCount(); + if (this.props._customRender) { + this.props._customRender(redrawReason); + } else { + this._drawLayers(redrawReason); + } + } + /** Flag indicating that the Deck instance has initialized its resources and it's safe to call public methods. */ + get isInitialized() { + return this.viewManager !== null; + } + /** Get a list of views that are currently rendered */ + getViews() { + assert9(this.viewManager); + return this.viewManager.views; + } + /** Get a list of viewports that are currently rendered. + * @param rect If provided, only returns viewports within the given bounding box. + */ + getViewports(rect) { + assert9(this.viewManager); + return this.viewManager.getViewports(rect); + } + /** Get the current canvas element. */ + getCanvas() { + return this.canvas; + } + /** Query the object rendered on top at a given point */ + pickObject(opts) { + const infos = this._pick("pickObject", "pickObject Time", opts).result; + return infos.length ? infos[0] : null; + } + /* Query all rendered objects at a given point */ + pickMultipleObjects(opts) { + opts.depth = opts.depth || 10; + return this._pick("pickObject", "pickMultipleObjects Time", opts).result; + } + /* Query all objects rendered on top within a bounding box */ + pickObjects(opts) { + return this._pick("pickObjects", "pickObjects Time", opts); + } + /** Experimental + * Add a global resource for sharing among layers + */ + _addResources(resources, forceUpdate = false) { + for (const id in resources) { + this.layerManager.resourceManager.add({ resourceId: id, data: resources[id], forceUpdate }); + } + } + /** Experimental + * Remove a global resource + */ + _removeResources(resourceIds) { + for (const id of resourceIds) { + this.layerManager.resourceManager.remove(id); + } + } + /** Experimental + * Register a default effect. Effects will be sorted by order, those with a low order will be rendered first + */ + _addDefaultEffect(effect) { + this.effectManager.addDefaultEffect(effect); + } + _addDefaultShaderModule(module) { + this.layerManager.addDefaultShaderModule(module); + } + _removeDefaultShaderModule(module) { + this.layerManager?.removeDefaultShaderModule(module); + } + _pick(method, statKey, opts) { + assert9(this.deckPicker); + const { stats } = this; + stats.get("Pick Count").incrementCount(); + stats.get(statKey).timeStart(); + const infos = this.deckPicker[method]({ + // layerManager, viewManager and effectManager are always defined if deckPicker is + layers: this.layerManager.getLayers(opts), + views: this.viewManager.getViews(), + viewports: this.getViewports(opts), + onViewportActive: this.layerManager.activateViewport, + effects: this.effectManager.getEffects(), + ...opts + }); + stats.get(statKey).timeEnd(); + return infos; + } + /** Resolve props.canvas to element */ + _createCanvas(props) { + let canvas2 = props.canvas; + if (typeof canvas2 === "string") { + canvas2 = document.getElementById(canvas2); + assert9(canvas2); + } + if (!canvas2) { + canvas2 = document.createElement("canvas"); + canvas2.id = props.id || "deckgl-overlay"; + const parent = props.parent || document.body; + parent.appendChild(canvas2); + } + Object.assign(canvas2.style, props.style); + return canvas2; + } + /** Updates canvas width and/or height, if provided as props */ + _setCanvasSize(props) { + if (!this.canvas) { + return; + } + const { width, height } = props; + if (width || width === 0) { + const cssWidth = Number.isFinite(width) ? `${width}px` : width; + this.canvas.style.width = cssWidth; + } + if (height || height === 0) { + const cssHeight = Number.isFinite(height) ? `${height}px` : height; + this.canvas.style.position = props.style?.position || "absolute"; + this.canvas.style.height = cssHeight; + } + } + /** If canvas size has changed, reads out the new size and update */ + _updateCanvasSize() { + const { canvas: canvas2 } = this; + if (!canvas2) { + return; + } + const newWidth = canvas2.clientWidth ?? canvas2.width; + const newHeight = canvas2.clientHeight ?? canvas2.height; + if (newWidth !== this.width || newHeight !== this.height) { + this.width = newWidth; + this.height = newHeight; + this.viewManager?.setProps({ width: newWidth, height: newHeight }); + this.layerManager?.activateViewport(this.getViewports()[0]); + this.props.onResize({ width: newWidth, height: newHeight }); + } + } + _createAnimationLoop(deviceOrPromise, props) { + const { + // width, + // height, + gl, + // deviceProps, + // glOptions, + // debug, + onError, + // onBeforeRender, + // onAfterRender, + useDevicePixels + } = props; + return new AnimationLoop({ + device: deviceOrPromise, + useDevicePixels, + // TODO v9 + autoResizeDrawingBuffer: !gl, + // do not auto resize external context + autoResizeViewport: false, + // @ts-expect-error luma.gl needs to accept Promise return value + onInitialize: (context) => this._setDevice(context.device), + onRender: this._onRenderFrame.bind(this), + // @ts-expect-error typing mismatch: AnimationLoop does not accept onError:null + onError + // onBeforeRender, + // onAfterRender, + }); + } + // Get the most relevant view state: props.viewState, if supplied, shadows internal viewState + // TODO: For backwards compatibility ensure numeric width and height is added to the viewState + _getViewState() { + return this.props.viewState || this.viewState; + } + // Get the view descriptor list + _getViews() { + const { views } = this.props; + const normalizedViews = Array.isArray(views) ? views : ( + // If null, default to a full screen map view port + views ? [views] : [new map_view_default({ id: "default-view" })] + ); + if (normalizedViews.length && this.props.controller) { + normalizedViews[0].props.controller = this.props.controller; + } + return normalizedViews; + } + _onContextLost() { + const { onError } = this.props; + if (this.animationLoop && onError) { + onError(new Error("WebGL context is lost")); + } + } + /** Actually run picking */ + _pickAndCallback() { + const { _pickRequest } = this; + if (_pickRequest.event) { + const { result, emptyInfo } = this._pick("pickObject", "pickObject Time", _pickRequest); + this.cursorState.isHovering = result.length > 0; + let pickedInfo = emptyInfo; + let handled = false; + for (const info of result) { + pickedInfo = info; + handled = info.layer?.onHover(info, _pickRequest.event) || handled; + } + if (!handled) { + this.props.onHover?.(pickedInfo, _pickRequest.event); + this.widgetManager.onHover(pickedInfo, _pickRequest.event); + } + _pickRequest.event = null; + } + } + _updateCursor() { + const container = this.props.parent || this.canvas; + if (container) { + container.style.cursor = this.props.getCursor(this.cursorState); + } + } + _setDevice(device) { + this.device = device; + if (!this.animationLoop) { + return; + } + if (!this.canvas) { + this.canvas = this.device.canvasContext?.canvas; + } + this.device.setParametersWebGL({ + blend: true, + blendFunc: [770, 771, 1, 771], + polygonOffsetFill: true, + depthTest: true, + depthFunc: 515 + }); + this.props.onDeviceInitialized(this.device); + if (this.device instanceof WebGLDevice) { + this.props.onWebGLInitialized(this.device.gl); + } + const timeline = new Timeline(); + timeline.play(); + this.animationLoop.attachTimeline(timeline); + this.eventManager = new EventManager(this.props.parent || this.canvas, { + touchAction: this.props.touchAction, + recognizerOptions: this.props.eventRecognizerOptions, + events: { + pointerdown: this._onPointerDown, + pointermove: this._onPointerMove, + pointerleave: this._onPointerMove + } + }); + for (const eventType in EVENTS) { + this.eventManager.on(eventType, this._onEvent); + } + this.viewManager = new ViewManager({ + timeline, + eventManager: this.eventManager, + onViewStateChange: this._onViewStateChange.bind(this), + onInteractionStateChange: this._onInteractionStateChange.bind(this), + views: this._getViews(), + viewState: this._getViewState(), + width: this.width, + height: this.height + }); + const viewport = this.viewManager.getViewports()[0]; + this.layerManager = new LayerManager(this.device, { + deck: this, + stats: this.stats, + viewport, + timeline + }); + this.effectManager = new EffectManager({ + deck: this, + device: this.device + }); + this.deckRenderer = new DeckRenderer(this.device); + this.deckPicker = new DeckPicker(this.device); + this.widgetManager = new WidgetManager({ + deck: this, + parentElement: this.canvas?.parentElement + }); + this.widgetManager.addDefault(new Tooltip()); + this.setProps(this.props); + this._updateCanvasSize(); + this.props.onLoad(); + } + /** Internal only: default render function (redraw all layers and views) */ + _drawLayers(redrawReason, renderOptions) { + const { device, gl } = this.layerManager.context; + this.props.onBeforeRender({ device, gl }); + const opts = { + target: this.props._framebuffer, + layers: this.layerManager.getLayers(), + viewports: this.viewManager.getViewports(), + onViewportActive: this.layerManager.activateViewport, + views: this.viewManager.getViews(), + pass: "screen", + effects: this.effectManager.getEffects(), + ...renderOptions + }; + this.deckRenderer?.renderLayers(opts); + if (opts.pass === "screen") { + this.widgetManager.onRedraw({ + viewports: opts.viewports, + layers: opts.layers + }); + } + this.props.onAfterRender({ device, gl }); + } + // Callbacks + _onRenderFrame() { + this._getFrameStats(); + if (this._metricsCounter++ % 60 === 0) { + this._getMetrics(); + this.stats.reset(); + log_default.table(4, this.metrics)(); + if (this.props._onMetrics) { + this.props._onMetrics(this.metrics); + } + } + this._updateCanvasSize(); + this._updateCursor(); + this.layerManager.updateLayers(); + this._pickAndCallback(); + this.redraw(); + if (this.viewManager) { + this.viewManager.updateViewStates(); + } + } + // Callbacks + _onViewStateChange(params) { + const viewState = this.props.onViewStateChange(params) || params.viewState; + if (this.viewState) { + this.viewState = { ...this.viewState, [params.viewId]: viewState }; + if (!this.props.viewState) { + if (this.viewManager) { + this.viewManager.setProps({ viewState: this.viewState }); + } + } + } + } + _onInteractionStateChange(interactionState) { + this.cursorState.isDragging = interactionState.isDragging || false; + this.props.onInteractionStateChange(interactionState); + } + _getFrameStats() { + const { stats } = this; + stats.get("frameRate").timeEnd(); + stats.get("frameRate").timeStart(); + const animationLoopStats = this.animationLoop.stats; + stats.get("GPU Time").addTime(animationLoopStats.get("GPU Time").lastTiming); + stats.get("CPU Time").addTime(animationLoopStats.get("CPU Time").lastTiming); + } + _getMetrics() { + const { metrics, stats } = this; + metrics.fps = stats.get("frameRate").getHz(); + metrics.setPropsTime = stats.get("setProps Time").time; + metrics.updateAttributesTime = stats.get("Update Attributes").time; + metrics.framesRedrawn = stats.get("Redraw Count").count; + metrics.pickTime = stats.get("pickObject Time").time + stats.get("pickMultipleObjects Time").time + stats.get("pickObjects Time").time; + metrics.pickCount = stats.get("Pick Count").count; + metrics.gpuTime = stats.get("GPU Time").time; + metrics.cpuTime = stats.get("CPU Time").time; + metrics.gpuTimePerFrame = stats.get("GPU Time").getAverageTime(); + metrics.cpuTimePerFrame = stats.get("CPU Time").getAverageTime(); + const memoryStats = luma.stats.get("Memory Usage"); + metrics.bufferMemory = memoryStats.get("Buffer Memory").count; + metrics.textureMemory = memoryStats.get("Texture Memory").count; + metrics.renderbufferMemory = memoryStats.get("Renderbuffer Memory").count; + metrics.gpuMemory = memoryStats.get("GPU Memory").count; + } +}; +Deck.defaultProps = defaultProps; +Deck.VERSION = VERSION5; +var deck_default = Deck; + +// node_modules/@deck.gl/core/dist/lib/attribute/gl-utils.js +function typedArrayFromDataType(type) { + switch (type) { + case "float64": + return Float64Array; + case "uint8": + case "unorm8": + return Uint8ClampedArray; + default: + return getTypedArrayFromDataType(type); + } +} +var dataTypeFromTypedArray = getDataTypeFromTypedArray; +function getBufferAttributeLayout(name2, accessor) { + return { + attribute: name2, + // @ts-expect-error Not all combinations are valid vertex formats; it's up to DataColumn to ensure + format: accessor.size > 1 ? `${accessor.type}x${accessor.size}` : accessor.type, + byteOffset: accessor.offset || 0 + // Note stride is set on the top level + }; +} +function getStride(accessor) { + return accessor.stride || accessor.size * accessor.bytesPerElement; +} +function bufferLayoutEqual(accessor1, accessor2) { + return accessor1.type === accessor2.type && accessor1.size === accessor2.size && getStride(accessor1) === getStride(accessor2) && (accessor1.offset || 0) === (accessor2.offset || 0); +} + +// node_modules/@deck.gl/core/dist/lib/attribute/data-column.js +function resolveShaderAttribute(baseAccessor, shaderAttributeOptions) { + if (shaderAttributeOptions.offset) { + log_default.removed("shaderAttribute.offset", "vertexOffset, elementOffset")(); + } + const stride = getStride(baseAccessor); + const vertexOffset = shaderAttributeOptions.vertexOffset !== void 0 ? shaderAttributeOptions.vertexOffset : baseAccessor.vertexOffset || 0; + const elementOffset = shaderAttributeOptions.elementOffset || 0; + const offset = ( + // offsets defined by the attribute + vertexOffset * stride + elementOffset * baseAccessor.bytesPerElement + // offsets defined by external buffers if any + (baseAccessor.offset || 0) + ); + return { + ...shaderAttributeOptions, + offset, + stride + }; +} +function resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) { + const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions); + return { + high: resolvedOptions, + low: { + ...resolvedOptions, + offset: resolvedOptions.offset + baseAccessor.size * 4 + } + }; +} +var DataColumn = class { + /* eslint-disable max-statements */ + constructor(device, opts, state) { + this._buffer = null; + this.device = device; + this.id = opts.id || ""; + this.size = opts.size || 1; + const logicalType = opts.logicalType || opts.type; + const doublePrecision = logicalType === "float64"; + let { defaultValue } = opts; + defaultValue = Number.isFinite(defaultValue) ? [defaultValue] : defaultValue || new Array(this.size).fill(0); + let bufferType; + if (doublePrecision) { + bufferType = "float32"; + } else if (!logicalType && opts.isIndexed) { + bufferType = "uint32"; + } else { + bufferType = logicalType || "float32"; + } + let defaultType = typedArrayFromDataType(logicalType || bufferType); + this.doublePrecision = doublePrecision; + if (doublePrecision && opts.fp64 === false) { + defaultType = Float32Array; + } + this.value = null; + this.settings = { + ...opts, + defaultType, + defaultValue, + logicalType, + type: bufferType, + normalized: bufferType.includes("norm"), + size: this.size, + bytesPerElement: defaultType.BYTES_PER_ELEMENT + }; + this.state = { + ...state, + externalBuffer: null, + bufferAccessor: this.settings, + allocatedValue: null, + numInstances: 0, + bounds: null, + constant: false + }; + } + /* eslint-enable max-statements */ + get isConstant() { + return this.state.constant; + } + get buffer() { + return this._buffer; + } + get byteOffset() { + const accessor = this.getAccessor(); + if (accessor.vertexOffset) { + return accessor.vertexOffset * getStride(accessor); + } + return 0; + } + get numInstances() { + return this.state.numInstances; + } + set numInstances(n) { + this.state.numInstances = n; + } + delete() { + if (this._buffer) { + this._buffer.delete(); + this._buffer = null; + } + typed_array_manager_default.release(this.state.allocatedValue); + } + getBuffer() { + if (this.state.constant) { + return null; + } + return this.state.externalBuffer || this._buffer; + } + getValue(attributeName = this.id, options = null) { + const result = {}; + if (this.state.constant) { + const value = this.value; + if (options) { + const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options); + const offset = shaderAttributeDef.offset / value.BYTES_PER_ELEMENT; + const size = shaderAttributeDef.size || this.size; + result[attributeName] = value.subarray(offset, offset + size); + } else { + result[attributeName] = value; + } + } else { + result[attributeName] = this.getBuffer(); + } + if (this.doublePrecision) { + if (this.value instanceof Float64Array) { + result[`${attributeName}64Low`] = result[attributeName]; + } else { + result[`${attributeName}64Low`] = new Float32Array(this.size); + } + } + return result; + } + _getBufferLayout(attributeName = this.id, options = null) { + const accessor = this.getAccessor(); + const attributes = []; + const result = { + name: this.id, + byteStride: getStride(accessor), + attributes + }; + if (this.doublePrecision) { + const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(accessor, options || {}); + attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...doubleShaderAttributeDefs.high }), getBufferAttributeLayout(`${attributeName}64Low`, { + ...accessor, + ...doubleShaderAttributeDefs.low + })); + } else if (options) { + const shaderAttributeDef = resolveShaderAttribute(accessor, options); + attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...shaderAttributeDef })); + } else { + attributes.push(getBufferAttributeLayout(attributeName, accessor)); + } + return result; + } + setAccessor(accessor) { + this.state.bufferAccessor = accessor; + } + getAccessor() { + return this.state.bufferAccessor; + } + // Returns [min: Array(size), max: Array(size)] + /* eslint-disable max-depth */ + getBounds() { + if (this.state.bounds) { + return this.state.bounds; + } + let result = null; + if (this.state.constant && this.value) { + const min7 = Array.from(this.value); + result = [min7, min7]; + } else { + const { value, numInstances, size } = this; + const len8 = numInstances * size; + if (value && len8 && value.length >= len8) { + const min7 = new Array(size).fill(Infinity); + const max7 = new Array(size).fill(-Infinity); + for (let i = 0; i < len8; ) { + for (let j = 0; j < size; j++) { + const v = value[i++]; + if (v < min7[j]) + min7[j] = v; + if (v > max7[j]) + max7[j] = v; + } + } + result = [min7, max7]; + } + } + this.state.bounds = result; + return result; + } + // returns true if success + // eslint-disable-next-line max-statements + setData(data) { + const { state } = this; + let opts; + if (ArrayBuffer.isView(data)) { + opts = { value: data }; + } else if (data instanceof Buffer2) { + opts = { buffer: data }; + } else { + opts = data; + } + const accessor = { ...this.settings, ...opts }; + if (ArrayBuffer.isView(opts.value)) { + if (!opts.type) { + const is64Bit = this.doublePrecision && opts.value instanceof Float64Array; + if (is64Bit) { + accessor.type = "float32"; + } else { + const type = dataTypeFromTypedArray(opts.value); + accessor.type = accessor.normalized ? type.replace("int", "norm") : type; + } + } + accessor.bytesPerElement = opts.value.BYTES_PER_ELEMENT; + accessor.stride = getStride(accessor); + } + state.bounds = null; + if (opts.constant) { + let value = opts.value; + value = this._normalizeValue(value, [], 0); + if (this.settings.normalized) { + value = this.normalizeConstant(value); + } + const hasChanged = !state.constant || !this._areValuesEqual(value, this.value); + if (!hasChanged) { + return false; + } + state.externalBuffer = null; + state.constant = true; + this.value = ArrayBuffer.isView(value) ? value : new Float32Array(value); + } else if (opts.buffer) { + const buffer = opts.buffer; + state.externalBuffer = buffer; + state.constant = false; + this.value = opts.value || null; + } else if (opts.value) { + this._checkExternalBuffer(opts); + let value = opts.value; + state.externalBuffer = null; + state.constant = false; + this.value = value; + let { buffer } = this; + const stride = getStride(accessor); + const byteOffset = (accessor.vertexOffset || 0) * stride; + if (this.doublePrecision && value instanceof Float64Array) { + value = toDoublePrecisionArray(value, accessor); + } + if (this.settings.isIndexed) { + const ArrayType2 = this.settings.defaultType; + if (value.constructor !== ArrayType2) { + value = new ArrayType2(value); + } + } + const requiredBufferSize = value.byteLength + byteOffset + stride * 2; + if (!buffer || buffer.byteLength < requiredBufferSize) { + buffer = this._createBuffer(requiredBufferSize); + } + buffer.write(value, byteOffset); + } + this.setAccessor(accessor); + return true; + } + updateSubBuffer(opts = {}) { + this.state.bounds = null; + const value = this.value; + const { startOffset = 0, endOffset } = opts; + this.buffer.write(this.doublePrecision && value instanceof Float64Array ? toDoublePrecisionArray(value, { + size: this.size, + startIndex: startOffset, + endIndex: endOffset + }) : value.subarray(startOffset, endOffset), startOffset * value.BYTES_PER_ELEMENT + this.byteOffset); + } + allocate(numInstances, copy12 = false) { + const { state } = this; + const oldValue = state.allocatedValue; + const value = typed_array_manager_default.allocate(oldValue, numInstances + 1, { + size: this.size, + type: this.settings.defaultType, + copy: copy12 + }); + this.value = value; + const { byteOffset } = this; + let { buffer } = this; + if (!buffer || buffer.byteLength < value.byteLength + byteOffset) { + buffer = this._createBuffer(value.byteLength + byteOffset); + if (copy12 && oldValue) { + buffer.write(oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue, byteOffset); + } + } + state.allocatedValue = value; + state.constant = false; + state.externalBuffer = null; + this.setAccessor(this.settings); + return true; + } + // PRIVATE HELPER METHODS + _checkExternalBuffer(opts) { + const { value } = opts; + if (!ArrayBuffer.isView(value)) { + throw new Error(`Attribute ${this.id} value is not TypedArray`); + } + const ArrayType2 = this.settings.defaultType; + let illegalArrayType = false; + if (this.doublePrecision) { + illegalArrayType = value.BYTES_PER_ELEMENT < 4; + } + if (illegalArrayType) { + throw new Error(`Attribute ${this.id} does not support ${value.constructor.name}`); + } + if (!(value instanceof ArrayType2) && this.settings.normalized && !("normalized" in opts)) { + log_default.warn(`Attribute ${this.id} is normalized`)(); + } + } + // https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer + normalizeConstant(value) { + switch (this.settings.type) { + case "snorm8": + return new Float32Array(value).map((x) => (x + 128) / 255 * 2 - 1); + case "snorm16": + return new Float32Array(value).map((x) => (x + 32768) / 65535 * 2 - 1); + case "unorm8": + return new Float32Array(value).map((x) => x / 255); + case "unorm16": + return new Float32Array(value).map((x) => x / 65535); + default: + return value; + } + } + /* check user supplied values and apply fallback */ + _normalizeValue(value, out, start) { + const { defaultValue, size } = this.settings; + if (Number.isFinite(value)) { + out[start] = value; + return out; + } + if (!value) { + let i = size; + while (--i >= 0) { + out[start + i] = defaultValue[i]; + } + return out; + } + switch (size) { + case 4: + out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3]; + case 3: + out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2]; + case 2: + out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1]; + case 1: + out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0]; + break; + default: + let i = size; + while (--i >= 0) { + out[start + i] = Number.isFinite(value[i]) ? value[i] : defaultValue[i]; + } + } + return out; + } + _areValuesEqual(value1, value2) { + if (!value1 || !value2) { + return false; + } + const { size } = this; + for (let i = 0; i < size; i++) { + if (value1[i] !== value2[i]) { + return false; + } + } + return true; + } + _createBuffer(byteLength) { + if (this._buffer) { + this._buffer.destroy(); + } + const { isIndexed, type } = this.settings; + this._buffer = this.device.createBuffer({ + ...this._buffer?.props, + id: this.id, + usage: isIndexed ? Buffer2.INDEX : Buffer2.VERTEX, + indexType: isIndexed ? type : void 0, + byteLength + }); + return this._buffer; + } +}; + +// node_modules/@deck.gl/core/dist/utils/iterable-utils.js +var EMPTY_ARRAY = []; +var placeholderArray = []; +function createIterable(data, startRow = 0, endRow = Infinity) { + let iterable = EMPTY_ARRAY; + const objectInfo = { + index: -1, + data, + // visitor can optionally utilize this to avoid constructing a new array for every object + target: [] + }; + if (!data) { + iterable = EMPTY_ARRAY; + } else if (typeof data[Symbol.iterator] === "function") { + iterable = data; + } else if (data.length > 0) { + placeholderArray.length = data.length; + iterable = placeholderArray; + } + if (startRow > 0 || Number.isFinite(endRow)) { + iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow); + objectInfo.index = startRow - 1; + } + return { iterable, objectInfo }; +} +function isAsyncIterable2(data) { + return data && data[Symbol.asyncIterator]; +} +function getAccessorFromBuffer(typedArray, options) { + const { size, stride, offset, startIndices, nested } = options; + const bytesPerElement = typedArray.BYTES_PER_ELEMENT; + const elementStride = stride ? stride / bytesPerElement : size; + const elementOffset = offset ? offset / bytesPerElement : 0; + const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride); + return (_, { index: index2, target }) => { + if (!startIndices) { + const sourceIndex = index2 * elementStride + elementOffset; + for (let j = 0; j < size; j++) { + target[j] = typedArray[sourceIndex + j]; + } + return target; + } + const startIndex = startIndices[index2]; + const endIndex = startIndices[index2 + 1] || vertexCount; + let result; + if (nested) { + result = new Array(endIndex - startIndex); + for (let i = startIndex; i < endIndex; i++) { + const sourceIndex = i * elementStride + elementOffset; + target = new Array(size); + for (let j = 0; j < size; j++) { + target[j] = typedArray[sourceIndex + j]; + } + result[i - startIndex] = target; + } + } else if (elementStride === size) { + result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset); + } else { + result = new typedArray.constructor((endIndex - startIndex) * size); + let targetIndex = 0; + for (let i = startIndex; i < endIndex; i++) { + const sourceIndex = i * elementStride + elementOffset; + for (let j = 0; j < size; j++) { + result[targetIndex++] = typedArray[sourceIndex + j]; + } + } + } + return result; + }; +} + +// node_modules/@deck.gl/core/dist/utils/range.js +var EMPTY = []; +var FULL = [[0, Infinity]]; +function add9(rangeList, range) { + if (rangeList === FULL) { + return rangeList; + } + if (range[0] < 0) { + range[0] = 0; + } + if (range[0] >= range[1]) { + return rangeList; + } + const newRangeList = []; + const len8 = rangeList.length; + let insertPosition = 0; + for (let i = 0; i < len8; i++) { + const range0 = rangeList[i]; + if (range0[1] < range[0]) { + newRangeList.push(range0); + insertPosition = i + 1; + } else if (range0[0] > range[1]) { + newRangeList.push(range0); + } else { + range = [Math.min(range0[0], range[0]), Math.max(range0[1], range[1])]; + } + } + newRangeList.splice(insertPosition, 0, range); + return newRangeList; +} + +// node_modules/@deck.gl/core/dist/lib/attribute/transition-settings.js +var DEFAULT_TRANSITION_SETTINGS = { + interpolation: { + duration: 0, + easing: (t) => t + }, + spring: { + stiffness: 0.05, + damping: 0.5 + } +}; +function normalizeTransitionSettings(userSettings, layerSettings) { + if (!userSettings) { + return null; + } + if (Number.isFinite(userSettings)) { + userSettings = { type: "interpolation", duration: userSettings }; + } + const type = userSettings.type || "interpolation"; + return { + ...DEFAULT_TRANSITION_SETTINGS[type], + ...layerSettings, + ...userSettings, + type + }; +} + +// node_modules/@deck.gl/core/dist/lib/attribute/attribute.js +var Attribute2 = class extends DataColumn { + constructor(device, opts) { + super(device, opts, { + startIndices: null, + lastExternalBuffer: null, + binaryValue: null, + binaryAccessor: null, + needsUpdate: true, + needsRedraw: false, + layoutChanged: false, + updateRanges: FULL + }); + this.constant = false; + this.settings.update = opts.update || (opts.accessor ? this._autoUpdater : void 0); + Object.seal(this.settings); + Object.seal(this.state); + this._validateAttributeUpdaters(); + } + get startIndices() { + return this.state.startIndices; + } + set startIndices(layout) { + this.state.startIndices = layout; + } + needsUpdate() { + return this.state.needsUpdate; + } + needsRedraw({ clearChangedFlags = false } = {}) { + const needsRedraw = this.state.needsRedraw; + this.state.needsRedraw = needsRedraw && !clearChangedFlags; + return needsRedraw; + } + layoutChanged() { + return this.state.layoutChanged; + } + setAccessor(accessor) { + var _a2; + (_a2 = this.state).layoutChanged || (_a2.layoutChanged = !bufferLayoutEqual(accessor, this.getAccessor())); + super.setAccessor(accessor); + } + getUpdateTriggers() { + const { accessor } = this.settings; + return [this.id].concat(typeof accessor !== "function" && accessor || []); + } + supportsTransition() { + return Boolean(this.settings.transition); + } + // Resolve transition settings object if transition is enabled, otherwise `null` + getTransitionSetting(opts) { + if (!opts || !this.supportsTransition()) { + return null; + } + const { accessor } = this.settings; + const layerSettings = this.settings.transition; + const userSettings = Array.isArray(accessor) ? ( + // @ts-ignore + opts[accessor.find((a) => opts[a])] + ) : ( + // @ts-ignore + opts[accessor] + ); + return normalizeTransitionSettings(userSettings, layerSettings); + } + setNeedsUpdate(reason = this.id, dataRange) { + this.state.needsUpdate = this.state.needsUpdate || reason; + this.setNeedsRedraw(reason); + if (dataRange) { + const { startRow = 0, endRow = Infinity } = dataRange; + this.state.updateRanges = add9(this.state.updateRanges, [startRow, endRow]); + } else { + this.state.updateRanges = FULL; + } + } + clearNeedsUpdate() { + this.state.needsUpdate = false; + this.state.updateRanges = EMPTY; + } + setNeedsRedraw(reason = this.id) { + this.state.needsRedraw = this.state.needsRedraw || reason; + } + allocate(numInstances) { + const { state, settings } = this; + if (settings.noAlloc) { + return false; + } + if (settings.update) { + super.allocate(numInstances, state.updateRanges !== FULL); + return true; + } + return false; + } + updateBuffer({ numInstances, data, props, context }) { + if (!this.needsUpdate()) { + return false; + } + const { state: { updateRanges }, settings: { update, noAlloc } } = this; + let updated = true; + if (update) { + for (const [startRow, endRow] of updateRanges) { + update.call(context, this, { data, startRow, endRow, props, numInstances }); + } + if (!this.value) { + } else if (this.constant || !this.buffer || this.buffer.byteLength < this.value.byteLength + this.byteOffset) { + this.setData({ + value: this.value, + constant: this.constant + }); + this.constant = false; + } else { + for (const [startRow, endRow] of updateRanges) { + const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0; + const endOffset = Number.isFinite(endRow) ? this.getVertexOffset(endRow) : noAlloc || !Number.isFinite(numInstances) ? this.value.length : numInstances * this.size; + super.updateSubBuffer({ startOffset, endOffset }); + } + } + this._checkAttributeArray(); + } else { + updated = false; + } + this.clearNeedsUpdate(); + this.setNeedsRedraw(); + return updated; + } + // Use generic value + // Returns true if successful + setConstantValue(value) { + if (value === void 0 || typeof value === "function") { + return false; + } + const hasChanged = this.setData({ constant: true, value }); + if (hasChanged) { + this.setNeedsRedraw(); + } + this.clearNeedsUpdate(); + return true; + } + // Use external buffer + // Returns true if successful + // eslint-disable-next-line max-statements + setExternalBuffer(buffer) { + const { state } = this; + if (!buffer) { + state.lastExternalBuffer = null; + return false; + } + this.clearNeedsUpdate(); + if (state.lastExternalBuffer === buffer) { + return true; + } + state.lastExternalBuffer = buffer; + this.setNeedsRedraw(); + this.setData(buffer); + return true; + } + // Binary value is a typed array packed from mapping the source data with the accessor + // If the returned value from the accessor is the same as the attribute value, set it directly + // Otherwise use the auto updater for transform/normalization + setBinaryValue(buffer, startIndices = null) { + const { state, settings } = this; + if (!buffer) { + state.binaryValue = null; + state.binaryAccessor = null; + return false; + } + if (settings.noAlloc) { + return false; + } + if (state.binaryValue === buffer) { + this.clearNeedsUpdate(); + return true; + } + state.binaryValue = buffer; + this.setNeedsRedraw(); + const needsUpdate = settings.transform || startIndices !== this.startIndices; + if (needsUpdate) { + if (ArrayBuffer.isView(buffer)) { + buffer = { value: buffer }; + } + const binaryValue = buffer; + assert9(ArrayBuffer.isView(binaryValue.value), `invalid ${settings.accessor}`); + const needsNormalize = Boolean(binaryValue.size) && binaryValue.size !== this.size; + state.binaryAccessor = getAccessorFromBuffer(binaryValue.value, { + size: binaryValue.size || this.size, + stride: binaryValue.stride, + offset: binaryValue.offset, + startIndices, + nested: needsNormalize + }); + return false; + } + this.clearNeedsUpdate(); + this.setData(buffer); + return true; + } + getVertexOffset(row) { + const { startIndices } = this; + const vertexIndex = startIndices ? row < startIndices.length ? startIndices[row] : this.numInstances : row; + return vertexIndex * this.size; + } + getValue() { + const shaderAttributeDefs = this.settings.shaderAttributes; + const result = super.getValue(); + if (!shaderAttributeDefs) { + return result; + } + for (const shaderAttributeName in shaderAttributeDefs) { + Object.assign(result, super.getValue(shaderAttributeName, shaderAttributeDefs[shaderAttributeName])); + } + return result; + } + /** Generate WebGPU-style buffer layout descriptor from this attribute */ + getBufferLayout(modelInfo) { + this.state.layoutChanged = false; + const shaderAttributeDefs = this.settings.shaderAttributes; + const result = super._getBufferLayout(); + const { stepMode } = this.settings; + if (stepMode === "dynamic") { + result.stepMode = modelInfo ? modelInfo.isInstanced ? "instance" : "vertex" : "instance"; + } else { + result.stepMode = stepMode ?? "vertex"; + } + if (!shaderAttributeDefs) { + return result; + } + for (const shaderAttributeName in shaderAttributeDefs) { + const map3 = super._getBufferLayout(shaderAttributeName, shaderAttributeDefs[shaderAttributeName]); + result.attributes.push(...map3.attributes); + } + return result; + } + /* eslint-disable max-depth, max-statements */ + _autoUpdater(attribute, { data, startRow, endRow, props, numInstances }) { + if (attribute.constant) { + return; + } + const { settings, state, value, size, startIndices } = attribute; + const { accessor, transform } = settings; + const accessorFunc = state.binaryAccessor || // @ts-ignore + (typeof accessor === "function" ? accessor : props[accessor]); + assert9(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`); + let i = attribute.getVertexOffset(startRow); + const { iterable, objectInfo } = createIterable(data, startRow, endRow); + for (const object of iterable) { + objectInfo.index++; + let objectValue = accessorFunc(object, objectInfo); + if (transform) { + objectValue = transform.call(this, objectValue); + } + if (startIndices) { + const numVertices = (objectInfo.index < startIndices.length - 1 ? startIndices[objectInfo.index + 1] : numInstances) - startIndices[objectInfo.index]; + if (objectValue && Array.isArray(objectValue[0])) { + let startIndex = i; + for (const item of objectValue) { + attribute._normalizeValue(item, value, startIndex); + startIndex += size; + } + } else if (objectValue && objectValue.length > size) { + value.set(objectValue, i); + } else { + attribute._normalizeValue(objectValue, objectInfo.target, 0); + fillArray2({ + target: value, + source: objectInfo.target, + start: i, + count: numVertices + }); + } + i += numVertices * size; + } else { + attribute._normalizeValue(objectValue, value, i); + i += size; + } + } + } + /* eslint-enable max-depth, max-statements */ + // Validate deck.gl level fields + _validateAttributeUpdaters() { + const { settings } = this; + const hasUpdater = settings.noAlloc || typeof settings.update === "function"; + if (!hasUpdater) { + throw new Error(`Attribute ${this.id} missing update or accessor`); + } + } + // check that the first few elements of the attribute are reasonable + /* eslint-disable no-fallthrough */ + _checkAttributeArray() { + const { value } = this; + const limit = Math.min(4, this.size); + if (value && value.length >= limit) { + let valid = true; + switch (limit) { + case 4: + valid = valid && Number.isFinite(value[3]); + case 3: + valid = valid && Number.isFinite(value[2]); + case 2: + valid = valid && Number.isFinite(value[1]); + case 1: + valid = valid && Number.isFinite(value[0]); + break; + default: + valid = false; + } + if (!valid) { + throw new Error(`Illegal attribute generated for ${this.id}`); + } + } + } +}; + +// node_modules/@deck.gl/core/dist/utils/array-utils.js +function padArrayChunk(options) { + const { source, target, start = 0, size, getData } = options; + const end = options.end || target.length; + const sourceLength = source.length; + const targetLength = end - start; + if (sourceLength > targetLength) { + target.set(source.subarray(0, targetLength), start); + return; + } + target.set(source, start); + if (!getData) { + return; + } + let i = sourceLength; + while (i < targetLength) { + const datum = getData(i, source); + for (let j = 0; j < size; j++) { + target[start + i] = datum[j] || 0; + i++; + } + } +} +function padArray({ source, target, size, getData, sourceStartIndices, targetStartIndices }) { + if (!sourceStartIndices || !targetStartIndices) { + padArrayChunk({ + source, + target, + size, + getData + }); + return target; + } + let sourceIndex = 0; + let targetIndex = 0; + const getChunkData = getData && ((i, chunk) => getData(i + targetIndex, chunk)); + const n = Math.min(sourceStartIndices.length, targetStartIndices.length); + for (let i = 1; i < n; i++) { + const nextSourceIndex = sourceStartIndices[i] * size; + const nextTargetIndex = targetStartIndices[i] * size; + padArrayChunk({ + source: source.subarray(sourceIndex, nextSourceIndex), + target, + start: targetIndex, + end: nextTargetIndex, + size, + getData: getChunkData + }); + sourceIndex = nextSourceIndex; + targetIndex = nextTargetIndex; + } + if (targetIndex < target.length) { + padArrayChunk({ + // @ts-ignore + source: [], + target, + start: targetIndex, + size, + getData: getChunkData + }); + } + return target; +} + +// node_modules/@deck.gl/core/dist/transitions/gpu-transition-utils.js +function cloneAttribute(attribute) { + const { device, settings, value } = attribute; + const newAttribute = new Attribute2(device, settings); + newAttribute.setData({ + value: value instanceof Float64Array ? new Float64Array(0) : new Float32Array(0), + normalized: settings.normalized + }); + return newAttribute; +} +function getAttributeTypeFromSize(size) { + switch (size) { + case 1: + return "float"; + case 2: + return "vec2"; + case 3: + return "vec3"; + case 4: + return "vec4"; + default: + throw new Error(`No defined attribute type for size "${size}"`); + } +} +function getFloat32VertexFormat(size) { + switch (size) { + case 1: + return "float32"; + case 2: + return "float32x2"; + case 3: + return "float32x3"; + case 4: + return "float32x4"; + default: + throw new Error("invalid type size"); + } +} +function cycleBuffers(buffers) { + buffers.push(buffers.shift()); +} +function getAttributeBufferLength(attribute, numInstances) { + const { doublePrecision, settings, value, size } = attribute; + const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1; + let maxVertexOffset = 0; + const { shaderAttributes } = attribute.settings; + if (shaderAttributes) { + for (const shaderAttribute of Object.values(shaderAttributes)) { + maxVertexOffset = Math.max(maxVertexOffset, shaderAttribute.vertexOffset ?? 0); + } + } + return (settings.noAlloc ? value.length : (numInstances + maxVertexOffset) * size) * multiplier; +} +function matchBuffer({ device, source, target }) { + if (!target || target.byteLength < source.byteLength) { + target?.destroy(); + target = device.createBuffer({ + byteLength: source.byteLength, + usage: source.usage + }); + } + return target; +} +function padBuffer({ device, buffer, attribute, fromLength, toLength, fromStartIndices, getData = (x) => x }) { + const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1; + const size = attribute.size * precisionMultiplier; + const byteOffset = attribute.byteOffset; + const targetByteOffset = attribute.settings.bytesPerElement < 4 ? byteOffset / attribute.settings.bytesPerElement * 4 : byteOffset; + const toStartIndices = attribute.startIndices; + const hasStartIndices = fromStartIndices && toStartIndices; + const isConstant = attribute.isConstant; + if (!hasStartIndices && buffer && fromLength >= toLength) { + return buffer; + } + const ArrayType2 = attribute.value instanceof Float64Array ? Float32Array : attribute.value.constructor; + const toData = isConstant ? attribute.value : ( + // TODO(v9.1): Avoid non-portable synchronous reads. + new ArrayType2(attribute.getBuffer().readSyncWebGL(byteOffset, toLength * ArrayType2.BYTES_PER_ELEMENT).buffer) + ); + if (attribute.settings.normalized && !isConstant) { + const getter = getData; + getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk)); + } + const getMissingData = isConstant ? (i, chunk) => getData(toData, chunk) : (i, chunk) => getData(toData.subarray(i + byteOffset, i + byteOffset + size), chunk); + const source = buffer ? new Float32Array(buffer.readSyncWebGL(targetByteOffset, fromLength * 4).buffer) : new Float32Array(0); + const target = new Float32Array(toLength); + padArray({ + source, + target, + sourceStartIndices: fromStartIndices, + targetStartIndices: toStartIndices, + size, + getData: getMissingData + }); + if (!buffer || buffer.byteLength < target.byteLength + targetByteOffset) { + buffer?.destroy(); + buffer = device.createBuffer({ + byteLength: target.byteLength + targetByteOffset, + usage: 35050 + }); + } + buffer.write(target, targetByteOffset); + return buffer; +} + +// node_modules/@deck.gl/core/dist/transitions/gpu-transition.js +var GPUTransitionBase = class { + constructor({ device, attribute, timeline }) { + this.buffers = []; + this.currentLength = 0; + this.device = device; + this.transition = new Transition(timeline); + this.attribute = attribute; + this.attributeInTransition = cloneAttribute(attribute); + this.currentStartIndices = attribute.startIndices; + } + get inProgress() { + return this.transition.inProgress; + } + start(transitionSettings, numInstances, duration = Infinity) { + this.settings = transitionSettings; + this.currentStartIndices = this.attribute.startIndices; + this.currentLength = getAttributeBufferLength(this.attribute, numInstances); + this.transition.start({ ...transitionSettings, duration }); + } + update() { + const updated = this.transition.update(); + if (updated) { + this.onUpdate(); + } + return updated; + } + setBuffer(buffer) { + this.attributeInTransition.setData({ + buffer, + normalized: this.attribute.settings.normalized, + // Retain placeholder value to generate correct shader layout + value: this.attributeInTransition.value + }); + } + cancel() { + this.transition.cancel(); + } + delete() { + this.cancel(); + for (const buffer of this.buffers) { + buffer.destroy(); + } + this.buffers.length = 0; + } +}; + +// node_modules/@deck.gl/core/dist/transitions/gpu-interpolation-transition.js +var GPUInterpolationTransition = class extends GPUTransitionBase { + constructor({ device, attribute, timeline }) { + super({ device, attribute, timeline }); + this.type = "interpolation"; + this.transform = getTransform(device, attribute); + } + start(transitionSettings, numInstances) { + const prevLength = this.currentLength; + const prevStartIndices = this.currentStartIndices; + super.start(transitionSettings, numInstances, transitionSettings.duration); + if (transitionSettings.duration <= 0) { + this.transition.cancel(); + return; + } + const { buffers, attribute } = this; + cycleBuffers(buffers); + buffers[0] = padBuffer({ + device: this.device, + buffer: buffers[0], + attribute, + fromLength: prevLength, + toLength: this.currentLength, + fromStartIndices: prevStartIndices, + getData: transitionSettings.enter + }); + buffers[1] = matchBuffer({ + device: this.device, + source: buffers[0], + target: buffers[1] + }); + this.setBuffer(buffers[1]); + const { transform } = this; + const model = transform.model; + let vertexCount = Math.floor(this.currentLength / attribute.size); + if (useFp64(attribute)) { + vertexCount /= 2; + } + model.setVertexCount(vertexCount); + if (attribute.isConstant) { + model.setAttributes({ aFrom: buffers[0] }); + model.setConstantAttributes({ aTo: attribute.value }); + } else { + model.setAttributes({ + aFrom: buffers[0], + aTo: attribute.getBuffer() + }); + } + transform.transformFeedback.setBuffers({ vCurrent: buffers[1] }); + } + onUpdate() { + const { duration, easing } = this.settings; + const { time } = this.transition; + let t = time / duration; + if (easing) { + t = easing(t); + } + const { model } = this.transform; + model.setUniforms({ time: t }); + this.transform.run({ discard: true }); + } + delete() { + super.delete(); + this.transform.destroy(); + } +}; +var vs5 = `#version 300 es +#define SHADER_NAME interpolation-transition-vertex-shader + +uniform float time; +in ATTRIBUTE_TYPE aFrom; +in ATTRIBUTE_TYPE aTo; +out ATTRIBUTE_TYPE vCurrent; + +void main(void) { + vCurrent = mix(aFrom, aTo, time); + gl_Position = vec4(0.0); +} +`; +var vs64 = `#version 300 es +#define SHADER_NAME interpolation-transition-vertex-shader + +uniform float time; +in ATTRIBUTE_TYPE aFrom; +in ATTRIBUTE_TYPE aFrom64Low; +in ATTRIBUTE_TYPE aTo; +in ATTRIBUTE_TYPE aTo64Low; +out ATTRIBUTE_TYPE vCurrent; +out ATTRIBUTE_TYPE vCurrent64Low; + +vec2 mix_fp64(vec2 a, vec2 b, float x) { + vec2 range = sub_fp64(b, a); + return sum_fp64(a, mul_fp64(range, vec2(x, 0.0))); +} + +void main(void) { + for (int i=0; i 0; + if (!isTransitioning) { + transition.end(); + } + } + delete() { + super.delete(); + this.transform.destroy(); + this.texture.destroy(); + this.framebuffer.destroy(); + } +}; +var vs6 = `#version 300 es +#define SHADER_NAME spring-transition-vertex-shader + +#define EPSILON 0.00001 + +uniform float stiffness; +uniform float damping; +in ATTRIBUTE_TYPE aPrev; +in ATTRIBUTE_TYPE aCur; +in ATTRIBUTE_TYPE aTo; +out ATTRIBUTE_TYPE vNext; +out float vIsTransitioningFlag; + +ATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) { + ATTRIBUTE_TYPE velocity = cur - prev; + ATTRIBUTE_TYPE delta = dest - cur; + ATTRIBUTE_TYPE spring = delta * stiffness; + ATTRIBUTE_TYPE damper = velocity * -1.0 * damping; + return spring + damper + velocity + cur; +} + +void main(void) { + bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON; + vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0; + + vNext = getNextValue(aCur, aPrev, aTo); + gl_Position = vec4(0, 0, 0, 1); + gl_PointSize = 100.0; +} +`; +var fs4 = `#version 300 es +#define SHADER_NAME spring-transition-is-transitioning-fragment-shader + +in float vIsTransitioningFlag; + +out vec4 fragColor; + +void main(void) { + if (vIsTransitioningFlag == 0.0) { + discard; + } + fragColor = vec4(1.0); +}`; +function getTransform2(device, attribute) { + const attributeType = getAttributeTypeFromSize(attribute.size); + const format = getFloat32VertexFormat(attribute.size); + return new BufferTransform(device, { + vs: vs6, + fs: fs4, + bufferLayout: [ + { name: "aPrev", format }, + { name: "aCur", format }, + { name: "aTo", format: attribute.getBufferLayout().attributes[0].format } + ], + varyings: ["vNext"], + defines: { ATTRIBUTE_TYPE: attributeType }, + parameters: { + depthCompare: "always", + blendColorOperation: "max", + blendColorSrcFactor: "one", + blendColorDstFactor: "one", + blendAlphaOperation: "max", + blendAlphaSrcFactor: "one", + blendAlphaDstFactor: "one" + } + }); +} +function getTexture(device) { + return device.createTexture({ + data: new Uint8Array(4), + format: "rgba8unorm", + mipmaps: false, + // dataFormat: GL.RGBA, + width: 1, + height: 1 + }); +} +function getFramebuffer3(device, texture) { + return device.createFramebuffer({ + id: "spring-transition-is-transitioning-framebuffer", + width: 1, + height: 1, + colorAttachments: [texture] + }); +} + +// node_modules/@deck.gl/core/dist/lib/attribute/attribute-transition-manager.js +var TRANSITION_TYPES = { + interpolation: GPUInterpolationTransition, + spring: GPUSpringTransition +}; +var AttributeTransitionManager = class { + constructor(device, { id, timeline }) { + if (!device) + throw new Error("AttributeTransitionManager is constructed without device"); + this.id = id; + this.device = device; + this.timeline = timeline; + this.transitions = {}; + this.needsRedraw = false; + this.numInstances = 1; + } + finalize() { + for (const attributeName in this.transitions) { + this._removeTransition(attributeName); + } + } + /* Public methods */ + // Called when attribute manager updates + // Check the latest attributes for updates. + update({ attributes, transitions, numInstances }) { + this.numInstances = numInstances || 1; + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + const settings = attribute.getTransitionSetting(transitions); + if (!settings) + continue; + this._updateAttribute(attributeName, attribute, settings); + } + for (const attributeName in this.transitions) { + const attribute = attributes[attributeName]; + if (!attribute || !attribute.getTransitionSetting(transitions)) { + this._removeTransition(attributeName); + } + } + } + // Returns `true` if attribute is transition-enabled + hasAttribute(attributeName) { + const transition = this.transitions[attributeName]; + return transition && transition.inProgress; + } + // Get all the animated attributes + getAttributes() { + const animatedAttributes = {}; + for (const attributeName in this.transitions) { + const transition = this.transitions[attributeName]; + if (transition.inProgress) { + animatedAttributes[attributeName] = transition.attributeInTransition; + } + } + return animatedAttributes; + } + /* eslint-disable max-statements */ + // Called every render cycle, run transform feedback + // Returns `true` if anything changes + run() { + if (this.numInstances === 0) { + return false; + } + for (const attributeName in this.transitions) { + const updated = this.transitions[attributeName].update(); + if (updated) { + this.needsRedraw = true; + } + } + const needsRedraw = this.needsRedraw; + this.needsRedraw = false; + return needsRedraw; + } + /* eslint-enable max-statements */ + /* Private methods */ + _removeTransition(attributeName) { + this.transitions[attributeName].delete(); + delete this.transitions[attributeName]; + } + // Check an attributes for updates + // Returns a transition object if a new transition is triggered. + _updateAttribute(attributeName, attribute, settings) { + const transition = this.transitions[attributeName]; + let isNew = !transition || transition.type !== settings.type; + if (isNew) { + if (transition) { + this._removeTransition(attributeName); + } + const TransitionType = TRANSITION_TYPES[settings.type]; + if (TransitionType) { + this.transitions[attributeName] = new TransitionType({ + attribute, + timeline: this.timeline, + device: this.device + }); + } else { + log_default.error(`unsupported transition type '${settings.type}'`)(); + isNew = false; + } + } + if (isNew || attribute.needsRedraw()) { + this.needsRedraw = true; + this.transitions[attributeName].start(settings, this.numInstances); + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/attribute/attribute-manager.js +var TRACE_INVALIDATE = "attributeManager.invalidate"; +var TRACE_UPDATE_START = "attributeManager.updateStart"; +var TRACE_UPDATE_END = "attributeManager.updateEnd"; +var TRACE_ATTRIBUTE_UPDATE_START = "attribute.updateStart"; +var TRACE_ATTRIBUTE_ALLOCATE = "attribute.allocate"; +var TRACE_ATTRIBUTE_UPDATE_END = "attribute.updateEnd"; +var AttributeManager = class { + constructor(device, { id = "attribute-manager", stats, timeline } = {}) { + this.mergeBoundsMemoized = memoize(mergeBounds); + this.id = id; + this.device = device; + this.attributes = {}; + this.updateTriggers = {}; + this.needsRedraw = true; + this.userData = {}; + this.stats = stats; + this.attributeTransitionManager = new AttributeTransitionManager(device, { + id: `${id}-transitions`, + timeline + }); + Object.seal(this); + } + finalize() { + for (const attributeName in this.attributes) { + this.attributes[attributeName].delete(); + } + this.attributeTransitionManager.finalize(); + } + // Returns the redraw flag, optionally clearing it. + // Redraw flag will be set if any attributes attributes changed since + // flag was last cleared. + // + // @param {String} [clearRedrawFlags=false] - whether to clear the flag + // @return {false|String} - reason a redraw is needed. + getNeedsRedraw(opts = { clearRedrawFlags: false }) { + const redraw = this.needsRedraw; + this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags; + return redraw && this.id; + } + // Sets the redraw flag. + // @param {Boolean} redraw=true + setNeedsRedraw() { + this.needsRedraw = true; + } + // Adds attributes + add(attributes) { + this._add(attributes); + } + // Adds attributes + addInstanced(attributes) { + this._add(attributes, { stepMode: "instance" }); + } + /** + * Removes attributes + * Takes an array of attribute names and delete them from + * the attribute map if they exists + * + * @example + * attributeManager.remove(['position']); + * + * @param {Object} attributeNameArray - attribute name array (see above) + */ + remove(attributeNameArray) { + for (const name2 of attributeNameArray) { + if (this.attributes[name2] !== void 0) { + this.attributes[name2].delete(); + delete this.attributes[name2]; + } + } + } + // Marks an attribute for update + invalidate(triggerName, dataRange) { + const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange); + debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes); + } + invalidateAll(dataRange) { + for (const attributeName in this.attributes) { + this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange); + } + debug(TRACE_INVALIDATE, this, "all"); + } + // Ensure all attribute buffers are updated from props or data. + // eslint-disable-next-line complexity + update({ data, numInstances, startIndices = null, transitions, props = {}, buffers = {}, context = {} }) { + let updated = false; + debug(TRACE_UPDATE_START, this); + if (this.stats) { + this.stats.get("Update Attributes").timeStart(); + } + for (const attributeName in this.attributes) { + const attribute = this.attributes[attributeName]; + const accessorName = attribute.settings.accessor; + attribute.startIndices = startIndices; + attribute.numInstances = numInstances; + if (props[attributeName]) { + log_default.removed(`props.${attributeName}`, `data.attributes.${attributeName}`)(); + } + if (attribute.setExternalBuffer(buffers[attributeName])) { + } else if (attribute.setBinaryValue(typeof accessorName === "string" ? buffers[accessorName] : void 0, data.startIndices)) { + } else if (typeof accessorName === "string" && !buffers[accessorName] && attribute.setConstantValue(props[accessorName])) { + } else if (attribute.needsUpdate()) { + updated = true; + this._updateAttribute({ + attribute, + numInstances, + data, + props, + context + }); + } + this.needsRedraw = this.needsRedraw || attribute.needsRedraw(); + } + if (updated) { + debug(TRACE_UPDATE_END, this, numInstances); + } + if (this.stats) { + this.stats.get("Update Attributes").timeEnd(); + } + this.attributeTransitionManager.update({ + attributes: this.attributes, + numInstances, + transitions + }); + } + // Update attribute transition to the current timestamp + // Returns `true` if any transition is in progress + updateTransition() { + const { attributeTransitionManager } = this; + const transitionUpdated = attributeTransitionManager.run(); + this.needsRedraw = this.needsRedraw || transitionUpdated; + return transitionUpdated; + } + /** + * Returns all attribute descriptors + * Note: Format matches luma.gl Model/Program.setAttributes() + * @return {Object} attributes - descriptors + */ + getAttributes() { + return { ...this.attributes, ...this.attributeTransitionManager.getAttributes() }; + } + /** + * Computes the spatial bounds of a given set of attributes + */ + getBounds(attributeNames) { + const bounds = attributeNames.map((attributeName) => this.attributes[attributeName]?.getBounds()); + return this.mergeBoundsMemoized(bounds); + } + /** + * Returns changed attribute descriptors + * This indicates which WebGLBuffers need to be updated + * @return {Object} attributes - descriptors + */ + getChangedAttributes(opts = { clearChangedFlags: false }) { + const { attributes, attributeTransitionManager } = this; + const changedAttributes = { ...attributeTransitionManager.getAttributes() }; + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) { + changedAttributes[attributeName] = attribute; + } + } + return changedAttributes; + } + /** Generate WebGPU-style buffer layout descriptors from all attributes */ + getBufferLayouts(modelInfo) { + return Object.values(this.getAttributes()).map((attribute) => attribute.getBufferLayout(modelInfo)); + } + // PRIVATE METHODS + /** Register new attributes */ + _add(attributes, overrideOptions) { + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + const props = { + ...attribute, + id: attributeName, + size: attribute.isIndexed && 1 || attribute.size || 1, + ...overrideOptions + }; + this.attributes[attributeName] = new Attribute2(this.device, props); + } + this._mapUpdateTriggersToAttributes(); + } + // build updateTrigger name to attribute name mapping + _mapUpdateTriggersToAttributes() { + const triggers = {}; + for (const attributeName in this.attributes) { + const attribute = this.attributes[attributeName]; + attribute.getUpdateTriggers().forEach((triggerName) => { + if (!triggers[triggerName]) { + triggers[triggerName] = []; + } + triggers[triggerName].push(attributeName); + }); + } + this.updateTriggers = triggers; + } + _invalidateTrigger(triggerName, dataRange) { + const { attributes, updateTriggers } = this; + const invalidatedAttributes = updateTriggers[triggerName]; + if (invalidatedAttributes) { + invalidatedAttributes.forEach((name2) => { + const attribute = attributes[name2]; + if (attribute) { + attribute.setNeedsUpdate(attribute.id, dataRange); + } + }); + } + return invalidatedAttributes; + } + _updateAttribute(opts) { + const { attribute, numInstances } = opts; + debug(TRACE_ATTRIBUTE_UPDATE_START, attribute); + if (attribute.constant) { + attribute.setConstantValue(attribute.value); + return; + } + if (attribute.allocate(numInstances)) { + debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances); + } + const updated = attribute.updateBuffer(opts); + if (updated) { + this.needsRedraw = true; + debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances); + } + } +}; + +// node_modules/@deck.gl/core/dist/transitions/cpu-interpolation-transition.js +var CPUInterpolationTransition = class extends Transition { + get value() { + return this._value; + } + _onUpdate() { + const { time, settings: { fromValue, toValue, duration, easing } } = this; + const t = easing(time / duration); + this._value = lerp(fromValue, toValue, t); + } +}; + +// node_modules/@deck.gl/core/dist/transitions/cpu-spring-transition.js +var EPSILON3 = 1e-5; +function updateSpringElement(prev, cur, dest, damping, stiffness) { + const velocity = cur - prev; + const delta = dest - cur; + const spring = delta * stiffness; + const damper = -velocity * damping; + return spring + damper + velocity + cur; +} +function updateSpring(prev, cur, dest, damping, stiffness) { + if (Array.isArray(dest)) { + const next = []; + for (let i = 0; i < dest.length; i++) { + next[i] = updateSpringElement(prev[i], cur[i], dest[i], damping, stiffness); + } + return next; + } + return updateSpringElement(prev, cur, dest, damping, stiffness); +} +function distance7(value1, value2) { + if (Array.isArray(value1)) { + let distanceSquare = 0; + for (let i = 0; i < value1.length; i++) { + const d = value1[i] - value2[i]; + distanceSquare += d * d; + } + return Math.sqrt(distanceSquare); + } + return Math.abs(value1 - value2); +} +var CPUSpringTransition = class extends Transition { + get value() { + return this._currValue; + } + _onUpdate() { + const { fromValue, toValue, damping, stiffness } = this.settings; + const { _prevValue = fromValue, _currValue = fromValue } = this; + let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness); + const delta = distance7(nextValue, toValue); + const velocity = distance7(nextValue, _currValue); + if (delta < EPSILON3 && velocity < EPSILON3) { + nextValue = toValue; + this.end(); + } + this._prevValue = _currValue; + this._currValue = nextValue; + } +}; + +// node_modules/@deck.gl/core/dist/lib/uniform-transition-manager.js +var TRANSITION_TYPES2 = { + interpolation: CPUInterpolationTransition, + spring: CPUSpringTransition +}; +var UniformTransitionManager = class { + constructor(timeline) { + this.transitions = /* @__PURE__ */ new Map(); + this.timeline = timeline; + } + get active() { + return this.transitions.size > 0; + } + add(key, fromValue, toValue, settings) { + const { transitions } = this; + if (transitions.has(key)) { + const transition2 = transitions.get(key); + const { value = transition2.settings.fromValue } = transition2; + fromValue = value; + this.remove(key); + } + settings = normalizeTransitionSettings(settings); + if (!settings) { + return; + } + const TransitionType = TRANSITION_TYPES2[settings.type]; + if (!TransitionType) { + log_default.error(`unsupported transition type '${settings.type}'`)(); + return; + } + const transition = new TransitionType(this.timeline); + transition.start({ + ...settings, + fromValue, + toValue + }); + transitions.set(key, transition); + } + remove(key) { + const { transitions } = this; + if (transitions.has(key)) { + transitions.get(key).cancel(); + transitions.delete(key); + } + } + update() { + const propsInTransition = {}; + for (const [key, transition] of this.transitions) { + transition.update(); + propsInTransition[key] = transition.value; + if (!transition.inProgress) { + this.remove(key); + } + } + return propsInTransition; + } + clear() { + for (const key of this.transitions.keys()) { + this.remove(key); + } + } +}; + +// node_modules/@deck.gl/core/dist/lifecycle/props.js +function validateProps(props) { + const propTypes = props[PROP_TYPES_SYMBOL]; + for (const propName in propTypes) { + const propType = propTypes[propName]; + const { validate: validate2 } = propType; + if (validate2 && !validate2(props[propName], propType)) { + throw new Error(`Invalid prop ${propName}: ${props[propName]}`); + } + } +} +function diffProps(props, oldProps) { + const propsChangedReason = compareProps({ + newProps: props, + oldProps, + propTypes: props[PROP_TYPES_SYMBOL], + ignoreProps: { data: null, updateTriggers: null, extensions: null, transitions: null } + }); + const dataChangedReason = diffDataProps(props, oldProps); + let updateTriggersChangedReason = false; + if (!dataChangedReason) { + updateTriggersChangedReason = diffUpdateTriggers(props, oldProps); + } + return { + dataChanged: dataChangedReason, + propsChanged: propsChangedReason, + updateTriggersChanged: updateTriggersChangedReason, + extensionsChanged: diffExtensions(props, oldProps), + transitionsChanged: diffTransitions(props, oldProps) + }; +} +function diffTransitions(props, oldProps) { + if (!props.transitions) { + return false; + } + const result = {}; + const propTypes = props[PROP_TYPES_SYMBOL]; + let changed = false; + for (const key in props.transitions) { + const propType = propTypes[key]; + const type = propType && propType.type; + const isTransitionable = type === "number" || type === "color" || type === "array"; + if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) { + result[key] = true; + changed = true; + } + } + return changed ? result : false; +} +function compareProps({ newProps, oldProps, ignoreProps = {}, propTypes = {}, triggerName = "props" }) { + if (oldProps === newProps) { + return false; + } + if (typeof newProps !== "object" || newProps === null) { + return `${triggerName} changed shallowly`; + } + if (typeof oldProps !== "object" || oldProps === null) { + return `${triggerName} changed shallowly`; + } + for (const key of Object.keys(newProps)) { + if (!(key in ignoreProps)) { + if (!(key in oldProps)) { + return `${triggerName}.${key} added`; + } + const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); + if (changed) { + return `${triggerName}.${key} ${changed}`; + } + } + } + for (const key of Object.keys(oldProps)) { + if (!(key in ignoreProps)) { + if (!(key in newProps)) { + return `${triggerName}.${key} dropped`; + } + if (!Object.hasOwnProperty.call(newProps, key)) { + const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); + if (changed) { + return `${triggerName}.${key} ${changed}`; + } + } + } + } + return false; +} +function comparePropValues(newProp, oldProp, propType) { + let equal = propType && propType.equal; + if (equal && !equal(newProp, oldProp, propType)) { + return "changed deeply"; + } + if (!equal) { + equal = newProp && oldProp && newProp.equals; + if (equal && !equal.call(newProp, oldProp)) { + return "changed deeply"; + } + } + if (!equal && oldProp !== newProp) { + return "changed shallowly"; + } + return null; +} +function diffDataProps(props, oldProps) { + if (oldProps === null) { + return "oldProps is null, initial diff"; + } + let dataChanged = false; + const { dataComparator, _dataDiff } = props; + if (dataComparator) { + if (!dataComparator(props.data, oldProps.data)) { + dataChanged = "Data comparator detected a change"; + } + } else if (props.data !== oldProps.data) { + dataChanged = "A new data container was supplied"; + } + if (dataChanged && _dataDiff) { + dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged; + } + return dataChanged; +} +function diffUpdateTriggers(props, oldProps) { + if (oldProps === null) { + return { all: true }; + } + if ("all" in props.updateTriggers) { + const diffReason = diffUpdateTrigger(props, oldProps, "all"); + if (diffReason) { + return { all: true }; + } + } + const reason = {}; + let changed = false; + for (const triggerName in props.updateTriggers) { + if (triggerName !== "all") { + const diffReason = diffUpdateTrigger(props, oldProps, triggerName); + if (diffReason) { + reason[triggerName] = true; + changed = true; + } + } + } + return changed ? reason : false; +} +function diffExtensions(props, oldProps) { + if (oldProps === null) { + return true; + } + const oldExtensions = oldProps.extensions; + const { extensions } = props; + if (extensions === oldExtensions) { + return false; + } + if (!oldExtensions || !extensions) { + return true; + } + if (extensions.length !== oldExtensions.length) { + return true; + } + for (let i = 0; i < extensions.length; i++) { + if (!extensions[i].equals(oldExtensions[i])) { + return true; + } + } + return false; +} +function diffUpdateTrigger(props, oldProps, triggerName) { + let newTriggers = props.updateTriggers[triggerName]; + newTriggers = newTriggers === void 0 || newTriggers === null ? {} : newTriggers; + let oldTriggers = oldProps.updateTriggers[triggerName]; + oldTriggers = oldTriggers === void 0 || oldTriggers === null ? {} : oldTriggers; + const diffReason = compareProps({ + oldProps: oldTriggers, + newProps: newTriggers, + triggerName + }); + return diffReason; +} + +// node_modules/@deck.gl/core/dist/utils/count.js +var ERR_NOT_OBJECT = "count(): argument not an object"; +var ERR_NOT_CONTAINER = "count(): argument not a container"; +function count(container) { + if (!isObject2(container)) { + throw new Error(ERR_NOT_OBJECT); + } + if (typeof container.count === "function") { + return container.count(); + } + if (Number.isFinite(container.size)) { + return container.size; + } + if (Number.isFinite(container.length)) { + return container.length; + } + if (isPlainObject(container)) { + return Object.keys(container).length; + } + throw new Error(ERR_NOT_CONTAINER); +} +function isPlainObject(value) { + return value !== null && typeof value === "object" && value.constructor === Object; +} +function isObject2(value) { + return value !== null && typeof value === "object"; +} + +// node_modules/@deck.gl/core/dist/utils/shader.js +function mergeShaders(target, source) { + if (!source) { + return target; + } + const result = { ...target, ...source }; + if ("defines" in source) { + result.defines = { ...target.defines, ...source.defines }; + } + if ("modules" in source) { + result.modules = (target.modules || []).concat(source.modules); + if (source.modules.some((module) => module.name === "project64")) { + const index2 = result.modules.findIndex((module) => module.name === "project32"); + if (index2 >= 0) { + result.modules.splice(index2, 1); + } + } + } + if ("inject" in source) { + if (!target.inject) { + result.inject = source.inject; + } else { + const mergedInjection = { ...target.inject }; + for (const key in source.inject) { + mergedInjection[key] = (mergedInjection[key] || "") + source.inject[key]; + } + result.inject = mergedInjection; + } + } + return result; +} + +// node_modules/@deck.gl/core/dist/utils/texture.js +var DEFAULT_TEXTURE_PARAMETERS = { + minFilter: "linear", + mipmapFilter: "linear", + magFilter: "linear", + addressModeU: "clamp-to-edge", + addressModeV: "clamp-to-edge" +}; +var internalTextures = {}; +function createTexture(owner, device, image, sampler) { + if (image instanceof Texture) { + return image; + } else if (image.constructor && image.constructor.name !== "Object") { + image = { data: image }; + } + let samplerParameters = null; + if (image.compressed) { + samplerParameters = { + minFilter: "linear", + mipmapFilter: image.data.length > 1 ? "nearest" : "linear" + }; + } + const texture = device.createTexture({ + ...image, + sampler: { + ...DEFAULT_TEXTURE_PARAMETERS, + ...samplerParameters, + ...sampler + } + }); + internalTextures[texture.id] = owner; + return texture; +} +function destroyTexture(owner, texture) { + if (!texture || !(texture instanceof Texture)) { + return; + } + if (internalTextures[texture.id] === owner) { + texture.delete(); + delete internalTextures[texture.id]; + } +} + +// node_modules/@deck.gl/core/dist/lifecycle/prop-types.js +var TYPE_DEFINITIONS = { + boolean: { + validate(value, propType) { + return true; + }, + equal(value1, value2, propType) { + return Boolean(value1) === Boolean(value2); + } + }, + number: { + validate(value, propType) { + return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); + } + }, + color: { + validate(value, propType) { + return propType.optional && !value || isArray3(value) && (value.length === 3 || value.length === 4); + }, + equal(value1, value2, propType) { + return deepEqual2(value1, value2, 1); + } + }, + accessor: { + validate(value, propType) { + const valueType = getTypeOf2(value); + return valueType === "function" || valueType === getTypeOf2(propType.value); + }, + equal(value1, value2, propType) { + if (typeof value2 === "function") { + return true; + } + return deepEqual2(value1, value2, 1); + } + }, + array: { + validate(value, propType) { + return propType.optional && !value || isArray3(value); + }, + equal(value1, value2, propType) { + const { compare } = propType; + const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; + return compare ? deepEqual2(value1, value2, depth) : value1 === value2; + } + }, + object: { + equal(value1, value2, propType) { + if (propType.ignore) { + return true; + } + const { compare } = propType; + const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; + return compare ? deepEqual2(value1, value2, depth) : value1 === value2; + } + }, + function: { + validate(value, propType) { + return propType.optional && !value || typeof value === "function"; + }, + equal(value1, value2, propType) { + const shouldIgnore = !propType.compare && propType.ignore !== false; + return shouldIgnore || value1 === value2; + } + }, + data: { + transform: (value, propType, component) => { + if (!value) { + return value; + } + const { dataTransform } = component.props; + if (dataTransform) { + return dataTransform(value); + } + if (typeof value.shape === "string" && value.shape.endsWith("-table") && Array.isArray(value.data)) { + return value.data; + } + return value; + } + }, + image: { + transform: (value, propType, component) => { + const context = component.context; + if (!context || !context.device) { + return null; + } + return createTexture(component.id, context.device, value, { + ...propType.parameters, + ...component.props.textureParameters + }); + }, + release: (value, propType, component) => { + destroyTexture(component.id, value); + } + } +}; +function parsePropTypes(propDefs) { + const propTypes = {}; + const defaultProps14 = {}; + const deprecatedProps = {}; + for (const [propName, propDef] of Object.entries(propDefs)) { + const deprecated = propDef?.deprecatedFor; + if (deprecated) { + deprecatedProps[propName] = Array.isArray(deprecated) ? deprecated : [deprecated]; + } else { + const propType = parsePropType(propName, propDef); + propTypes[propName] = propType; + defaultProps14[propName] = propType.value; + } + } + return { propTypes, defaultProps: defaultProps14, deprecatedProps }; +} +function parsePropType(name2, propDef) { + switch (getTypeOf2(propDef)) { + case "object": + return normalizePropDefinition(name2, propDef); + case "array": + return normalizePropDefinition(name2, { type: "array", value: propDef, compare: false }); + case "boolean": + return normalizePropDefinition(name2, { type: "boolean", value: propDef }); + case "number": + return normalizePropDefinition(name2, { type: "number", value: propDef }); + case "function": + return normalizePropDefinition(name2, { type: "function", value: propDef, compare: true }); + default: + return { name: name2, type: "unknown", value: propDef }; + } +} +function normalizePropDefinition(name2, propDef) { + if (!("type" in propDef)) { + if (!("value" in propDef)) { + return { name: name2, type: "object", value: propDef }; + } + return { name: name2, type: getTypeOf2(propDef.value), ...propDef }; + } + return { name: name2, ...TYPE_DEFINITIONS[propDef.type], ...propDef }; +} +function isArray3(value) { + return Array.isArray(value) || ArrayBuffer.isView(value); +} +function getTypeOf2(value) { + if (isArray3(value)) { + return "array"; + } + if (value === null) { + return "null"; + } + return typeof value; +} + +// node_modules/@deck.gl/core/dist/lifecycle/create-props.js +function createProps(component, propObjects) { + let extensions; + for (let i = propObjects.length - 1; i >= 0; i--) { + const props = propObjects[i]; + if ("extensions" in props) { + extensions = props.extensions; + } + } + const propsPrototype = getPropsPrototype(component.constructor, extensions); + const propsInstance = Object.create(propsPrototype); + propsInstance[COMPONENT_SYMBOL] = component; + propsInstance[ASYNC_ORIGINAL_SYMBOL] = {}; + propsInstance[ASYNC_RESOLVED_SYMBOL] = {}; + for (let i = 0; i < propObjects.length; ++i) { + const props = propObjects[i]; + for (const key in props) { + propsInstance[key] = props[key]; + } + } + Object.freeze(propsInstance); + return propsInstance; +} +var MergedDefaultPropsCacheKey = "_mergedDefaultProps"; +function getPropsPrototype(componentClass, extensions) { + if (!(componentClass instanceof component_default.constructor)) + return {}; + let cacheKey = MergedDefaultPropsCacheKey; + if (extensions) { + for (const extension of extensions) { + const ExtensionClass = extension.constructor; + if (ExtensionClass) { + cacheKey += `:${ExtensionClass.extensionName || ExtensionClass.name}`; + } + } + } + const defaultProps14 = getOwnProperty(componentClass, cacheKey); + if (!defaultProps14) { + return componentClass[cacheKey] = createPropsPrototypeAndTypes(componentClass, extensions || []); + } + return defaultProps14; +} +function createPropsPrototypeAndTypes(componentClass, extensions) { + const parent = componentClass.prototype; + if (!parent) { + return null; + } + const parentClass = Object.getPrototypeOf(componentClass); + const parentDefaultProps = getPropsPrototype(parentClass); + const componentDefaultProps = getOwnProperty(componentClass, "defaultProps") || {}; + const componentPropDefs = parsePropTypes(componentDefaultProps); + const defaultProps14 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps, componentPropDefs.defaultProps); + const propTypes = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps?.[PROP_TYPES_SYMBOL], componentPropDefs.propTypes); + const deprecatedProps = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps?.[DEPRECATED_PROPS_SYMBOL], componentPropDefs.deprecatedProps); + for (const extension of extensions) { + const extensionDefaultProps = getPropsPrototype(extension.constructor); + if (extensionDefaultProps) { + Object.assign(defaultProps14, extensionDefaultProps); + Object.assign(propTypes, extensionDefaultProps[PROP_TYPES_SYMBOL]); + Object.assign(deprecatedProps, extensionDefaultProps[DEPRECATED_PROPS_SYMBOL]); + } + } + createPropsPrototype(defaultProps14, componentClass); + addAsyncPropsToPropPrototype(defaultProps14, propTypes); + addDeprecatedPropsToPropPrototype(defaultProps14, deprecatedProps); + defaultProps14[PROP_TYPES_SYMBOL] = propTypes; + defaultProps14[DEPRECATED_PROPS_SYMBOL] = deprecatedProps; + if (extensions.length === 0 && !hasOwnProperty(componentClass, "_propTypes")) { + componentClass._propTypes = propTypes; + } + return defaultProps14; +} +function createPropsPrototype(defaultProps14, componentClass) { + const id = getComponentName(componentClass); + Object.defineProperties(defaultProps14, { + // `id` is treated specially because layer might need to override it + id: { + writable: true, + value: id + } + }); +} +function addDeprecatedPropsToPropPrototype(defaultProps14, deprecatedProps) { + for (const propName in deprecatedProps) { + Object.defineProperty(defaultProps14, propName, { + enumerable: false, + set(newValue) { + const nameStr = `${this.id}: ${propName}`; + for (const newPropName of deprecatedProps[propName]) { + if (!hasOwnProperty(this, newPropName)) { + this[newPropName] = newValue; + } + } + log_default.deprecated(nameStr, deprecatedProps[propName].join("/"))(); + } + }); + } +} +function addAsyncPropsToPropPrototype(defaultProps14, propTypes) { + const defaultValues = {}; + const descriptors = {}; + for (const propName in propTypes) { + const propType = propTypes[propName]; + const { name: name2, value } = propType; + if (propType.async) { + defaultValues[name2] = value; + descriptors[name2] = getDescriptorForAsyncProp(name2); + } + } + defaultProps14[ASYNC_DEFAULTS_SYMBOL] = defaultValues; + defaultProps14[ASYNC_ORIGINAL_SYMBOL] = {}; + Object.defineProperties(defaultProps14, descriptors); +} +function getDescriptorForAsyncProp(name2) { + return { + enumerable: true, + // Save the provided value for async props in a special map + set(newValue) { + if (typeof newValue === "string" || newValue instanceof Promise || isAsyncIterable2(newValue)) { + this[ASYNC_ORIGINAL_SYMBOL][name2] = newValue; + } else { + this[ASYNC_RESOLVED_SYMBOL][name2] = newValue; + } + }, + // Only the component's state knows the true value of async prop + get() { + if (this[ASYNC_RESOLVED_SYMBOL]) { + if (name2 in this[ASYNC_RESOLVED_SYMBOL]) { + const value = this[ASYNC_RESOLVED_SYMBOL][name2]; + return value || this[ASYNC_DEFAULTS_SYMBOL][name2]; + } + if (name2 in this[ASYNC_ORIGINAL_SYMBOL]) { + const state = this[COMPONENT_SYMBOL] && this[COMPONENT_SYMBOL].internalState; + if (state && state.hasAsyncProp(name2)) { + return state.getAsyncProp(name2) || this[ASYNC_DEFAULTS_SYMBOL][name2]; + } + } + } + return this[ASYNC_DEFAULTS_SYMBOL][name2]; + } + }; +} +function hasOwnProperty(object, prop) { + return Object.prototype.hasOwnProperty.call(object, prop); +} +function getOwnProperty(object, prop) { + return hasOwnProperty(object, prop) && object[prop]; +} +function getComponentName(componentClass) { + const componentName = componentClass.componentName; + if (!componentName) { + log_default.warn(`${componentClass.name}.componentName not specified`)(); + } + return componentName || componentClass.name; +} + +// node_modules/@deck.gl/core/dist/lifecycle/component.js +var counter = 0; +var Component = class { + constructor(...propObjects) { + this.props = createProps(this, propObjects); + this.id = this.props.id; + this.count = counter++; + } + // clone this layer with modified props + clone(newProps) { + const { props } = this; + const asyncProps = {}; + for (const key in props[ASYNC_DEFAULTS_SYMBOL]) { + if (key in props[ASYNC_RESOLVED_SYMBOL]) { + asyncProps[key] = props[ASYNC_RESOLVED_SYMBOL][key]; + } else if (key in props[ASYNC_ORIGINAL_SYMBOL]) { + asyncProps[key] = props[ASYNC_ORIGINAL_SYMBOL][key]; + } + } + return new this.constructor({ ...props, ...asyncProps, ...newProps }); + } +}; +Component.componentName = "Component"; +Component.defaultProps = {}; +var component_default = Component; + +// node_modules/@deck.gl/core/dist/lifecycle/component-state.js +var EMPTY_PROPS = Object.freeze({}); +var ComponentState = class { + constructor(component) { + this.component = component; + this.asyncProps = {}; + this.onAsyncPropUpdated = () => { + }; + this.oldProps = null; + this.oldAsyncProps = null; + } + finalize() { + for (const propName in this.asyncProps) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp && asyncProp.type && asyncProp.type.release) { + asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component); + } + } + this.asyncProps = {}; + this.component = null; + this.resetOldProps(); + } + /* Layer-facing props API */ + getOldProps() { + return this.oldAsyncProps || this.oldProps || EMPTY_PROPS; + } + resetOldProps() { + this.oldAsyncProps = null; + this.oldProps = this.component ? this.component.props : null; + } + // Checks if a prop is overridden + hasAsyncProp(propName) { + return propName in this.asyncProps; + } + // Returns value of an overriden prop + getAsyncProp(propName) { + const asyncProp = this.asyncProps[propName]; + return asyncProp && asyncProp.resolvedValue; + } + isAsyncPropLoading(propName) { + if (propName) { + const asyncProp = this.asyncProps[propName]; + return Boolean(asyncProp && asyncProp.pendingLoadCount > 0 && asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount); + } + for (const key in this.asyncProps) { + if (this.isAsyncPropLoading(key)) { + return true; + } + } + return false; + } + // Without changing the original prop value, swap out the data resolution under the hood + reloadAsyncProp(propName, value) { + this._watchPromise(propName, Promise.resolve(value)); + } + // Updates all async/overridden props (when new props come in) + // Checks if urls have changed, starts loading, or removes override + setAsyncProps(props) { + this.component = props[COMPONENT_SYMBOL] || this.component; + const resolvedValues = props[ASYNC_RESOLVED_SYMBOL] || {}; + const originalValues = props[ASYNC_ORIGINAL_SYMBOL] || props; + const defaultValues = props[ASYNC_DEFAULTS_SYMBOL] || {}; + for (const propName in resolvedValues) { + const value = resolvedValues[propName]; + this._createAsyncPropData(propName, defaultValues[propName]); + this._updateAsyncProp(propName, value); + resolvedValues[propName] = this.getAsyncProp(propName); + } + for (const propName in originalValues) { + const value = originalValues[propName]; + this._createAsyncPropData(propName, defaultValues[propName]); + this._updateAsyncProp(propName, value); + } + } + /* Placeholder methods for subclassing */ + _fetch(propName, url) { + return null; + } + _onResolve(propName, value) { + } + // eslint-disable-line @typescript-eslint/no-empty-function + _onError(propName, error) { + } + // eslint-disable-line @typescript-eslint/no-empty-function + // Intercept strings (URLs) and Promises and activates loading and prop rewriting + _updateAsyncProp(propName, value) { + if (!this._didAsyncInputValueChange(propName, value)) { + return; + } + if (typeof value === "string") { + value = this._fetch(propName, value); + } + if (value instanceof Promise) { + this._watchPromise(propName, value); + return; + } + if (isAsyncIterable2(value)) { + this._resolveAsyncIterable(propName, value); + return; + } + this._setPropValue(propName, value); + } + // Whenever async props are changing, we need to make a copy of oldProps + // otherwise the prop rewriting will affect the value both in props and oldProps. + // While the copy is relatively expensive, this only happens on load completion. + _freezeAsyncOldProps() { + if (!this.oldAsyncProps && this.oldProps) { + this.oldAsyncProps = Object.create(this.oldProps); + for (const propName in this.asyncProps) { + Object.defineProperty(this.oldAsyncProps, propName, { + enumerable: true, + value: this.oldProps[propName] + }); + } + } + } + // Checks if an input value actually changed (to avoid reloading/rewatching promises/urls) + _didAsyncInputValueChange(propName, value) { + const asyncProp = this.asyncProps[propName]; + if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) { + return false; + } + asyncProp.lastValue = value; + return true; + } + // Set normal, non-async value + _setPropValue(propName, value) { + this._freezeAsyncOldProps(); + const asyncProp = this.asyncProps[propName]; + if (asyncProp) { + value = this._postProcessValue(asyncProp, value); + asyncProp.resolvedValue = value; + asyncProp.pendingLoadCount++; + asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount; + } + } + // Set a just resolved async value, calling onAsyncPropUpdates if value changes asynchronously + _setAsyncPropValue(propName, value, loadCount) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== void 0) { + this._freezeAsyncOldProps(); + asyncProp.resolvedValue = value; + asyncProp.resolvedLoadCount = loadCount; + this.onAsyncPropUpdated(propName, value); + } + } + // Tracks a promise, sets the prop when loaded, handles load count + _watchPromise(propName, promise) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp) { + asyncProp.pendingLoadCount++; + const loadCount = asyncProp.pendingLoadCount; + promise.then((data) => { + if (!this.component) { + return; + } + data = this._postProcessValue(asyncProp, data); + this._setAsyncPropValue(propName, data, loadCount); + this._onResolve(propName, data); + }).catch((error) => { + this._onError(propName, error); + }); + } + } + async _resolveAsyncIterable(propName, iterable) { + if (propName !== "data") { + this._setPropValue(propName, iterable); + return; + } + const asyncProp = this.asyncProps[propName]; + if (!asyncProp) { + return; + } + asyncProp.pendingLoadCount++; + const loadCount = asyncProp.pendingLoadCount; + let data = []; + let count2 = 0; + for await (const chunk of iterable) { + if (!this.component) { + return; + } + const { dataTransform } = this.component.props; + if (dataTransform) { + data = dataTransform(chunk, data); + } else { + data = data.concat(chunk); + } + Object.defineProperty(data, "__diff", { + enumerable: false, + value: [{ startRow: count2, endRow: data.length }] + }); + count2 = data.length; + this._setAsyncPropValue(propName, data, loadCount); + } + this._onResolve(propName, data); + } + // Give the app a chance to post process the loaded data + _postProcessValue(asyncProp, value) { + const propType = asyncProp.type; + if (propType && this.component) { + if (propType.release) { + propType.release(asyncProp.resolvedValue, propType, this.component); + } + if (propType.transform) { + return propType.transform(value, propType, this.component); + } + } + return value; + } + // Creating an asyncProp record if needed + _createAsyncPropData(propName, defaultValue) { + const asyncProp = this.asyncProps[propName]; + if (!asyncProp) { + const propTypes = this.component && this.component.props[PROP_TYPES_SYMBOL]; + this.asyncProps[propName] = { + type: propTypes && propTypes[propName], + lastValue: null, + resolvedValue: defaultValue, + pendingLoadCount: 0, + resolvedLoadCount: 0 + }; + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/layer-state.js +var LayerState = class extends ComponentState { + constructor({ attributeManager, layer }) { + super(layer); + this.attributeManager = attributeManager; + this.needsRedraw = true; + this.needsUpdate = true; + this.subLayers = null; + this.usesPickingColorCache = false; + } + get layer() { + return this.component; + } + /* Override base Component methods with Layer-specific handling */ + _fetch(propName, url) { + const layer = this.layer; + const fetch2 = layer?.props.fetch; + if (fetch2) { + return fetch2(url, { propName, layer }); + } + return super._fetch(propName, url); + } + _onResolve(propName, value) { + const layer = this.layer; + if (layer) { + const onDataLoad = layer.props.onDataLoad; + if (propName === "data" && onDataLoad) { + onDataLoad(value, { propName, layer }); + } + } + } + _onError(propName, error) { + const layer = this.layer; + if (layer) { + layer.raiseError(error, `loading ${propName} of ${this.layer}`); + } + } +}; + +// node_modules/@deck.gl/core/dist/lib/layer.js +var TRACE_CHANGE_FLAG = "layer.changeFlag"; +var TRACE_INITIALIZE = "layer.initialize"; +var TRACE_UPDATE = "layer.update"; +var TRACE_FINALIZE = "layer.finalize"; +var TRACE_MATCHED = "layer.matched"; +var MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1; +var EMPTY_ARRAY2 = Object.freeze([]); +var areViewportsEqual = memoize(({ oldViewport, viewport }) => { + return oldViewport.equals(viewport); +}); +var pickingColorCache = new Uint8ClampedArray(0); +var defaultProps2 = { + // data: Special handling for null, see below + data: { type: "data", value: EMPTY_ARRAY2, async: true }, + dataComparator: { type: "function", value: null, optional: true }, + _dataDiff: { + type: "function", + // @ts-ignore __diff is not defined on data + value: (data) => data && data.__diff, + optional: true + }, + dataTransform: { type: "function", value: null, optional: true }, + onDataLoad: { type: "function", value: null, optional: true }, + onError: { type: "function", value: null, optional: true }, + fetch: { + type: "function", + value: (url, { propName, layer, loaders, loadOptions, signal }) => { + const { resourceManager } = layer.context; + loadOptions = loadOptions || layer.getLoadOptions(); + loaders = loaders || layer.props.loaders; + if (signal) { + loadOptions = { + ...loadOptions, + fetch: { + ...loadOptions?.fetch, + signal + } + }; + } + let inResourceManager = resourceManager.contains(url); + if (!inResourceManager && !loadOptions) { + resourceManager.add({ resourceId: url, data: load(url, loaders), persistent: false }); + inResourceManager = true; + } + if (inResourceManager) { + return resourceManager.subscribe({ + resourceId: url, + onChange: (data) => layer.internalState?.reloadAsyncProp(propName, data), + consumerId: layer.id, + requestId: propName + }); + } + return load(url, loaders, loadOptions); + } + }, + updateTriggers: {}, + // Update triggers: a core change detection mechanism in deck.gl + visible: true, + pickable: false, + opacity: { type: "number", min: 0, max: 1, value: 1 }, + operation: "draw", + onHover: { type: "function", value: null, optional: true }, + onClick: { type: "function", value: null, optional: true }, + onDragStart: { type: "function", value: null, optional: true }, + onDrag: { type: "function", value: null, optional: true }, + onDragEnd: { type: "function", value: null, optional: true }, + coordinateSystem: COORDINATE_SYSTEM.DEFAULT, + coordinateOrigin: { type: "array", value: [0, 0, 0], compare: true }, + modelMatrix: { type: "array", value: null, compare: true, optional: true }, + wrapLongitude: false, + positionFormat: "XYZ", + colorFormat: "RGBA", + parameters: { type: "object", value: {}, optional: true, compare: 2 }, + loadOptions: { type: "object", value: null, optional: true, ignore: true }, + transitions: null, + extensions: [], + loaders: { type: "array", value: [], optional: true, ignore: true }, + // Offset depth based on layer index to avoid z-fighting. + // Negative values pull layer towards the camera + // https://www.opengl.org/archives/resources/faq/technical/polygonoffset.htm + getPolygonOffset: { + type: "function", + value: ({ layerIndex }) => [0, -layerIndex * 100] + }, + // Selection/Highlighting + highlightedObjectIndex: null, + autoHighlight: false, + highlightColor: { type: "accessor", value: [0, 0, 128, 128] } +}; +var Layer = class extends component_default { + constructor() { + super(...arguments); + this.internalState = null; + this.lifecycle = LIFECYCLE.NO_STATE; + this.parent = null; + } + static get componentName() { + return Object.prototype.hasOwnProperty.call(this, "layerName") ? this.layerName : ""; + } + get root() { + let layer = this; + while (layer.parent) { + layer = layer.parent; + } + return layer; + } + toString() { + const className = this.constructor.layerName || this.constructor.name; + return `${className}({id: '${this.props.id}'})`; + } + // Public API for users + /** Projects a point with current view state from the current layer's coordinate system to screen */ + project(xyz) { + assert9(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + const worldPosition = getWorldPosition(xyz, { + viewport, + modelMatrix: this.props.modelMatrix, + coordinateOrigin: this.props.coordinateOrigin, + coordinateSystem: this.props.coordinateSystem + }); + const [x, y, z] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix); + return xyz.length === 2 ? [x, y] : [x, y, z]; + } + /** Unprojects a screen pixel to the current view's default coordinate system + Note: this does not reverse `project`. */ + unproject(xy) { + assert9(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + return viewport.unproject(xy); + } + /** Projects a point with current view state from the current layer's coordinate system to the world space */ + projectPosition(xyz, params) { + assert9(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + return projectPosition(xyz, { + viewport, + modelMatrix: this.props.modelMatrix, + coordinateOrigin: this.props.coordinateOrigin, + coordinateSystem: this.props.coordinateSystem, + ...params + }); + } + // Public API for custom layer implementation + /** `true` if this layer renders other layers */ + get isComposite() { + return false; + } + /** Updates selected state members and marks the layer for redraw */ + setState(partialState) { + this.setChangeFlags({ stateChanged: true }); + Object.assign(this.state, partialState); + this.setNeedsRedraw(); + } + /** Sets the redraw flag for this layer, will trigger a redraw next animation frame */ + setNeedsRedraw() { + if (this.internalState) { + this.internalState.needsRedraw = true; + } + } + /** Mark this layer as needs a deep update */ + setNeedsUpdate() { + if (this.internalState) { + this.context.layerManager.setNeedsUpdate(String(this)); + this.internalState.needsUpdate = true; + } + } + /** Returns true if all async resources are loaded */ + get isLoaded() { + return this.internalState ? !this.internalState.isAsyncPropLoading() : false; + } + /** Returns true if using shader-based WGS84 longitude wrapping */ + get wrapLongitude() { + return this.props.wrapLongitude; + } + /** @deprecated Returns true if the layer is visible in the picking pass */ + isPickable() { + return this.props.pickable && this.props.visible; + } + /** Returns an array of models used by this layer, can be overriden by layer subclass */ + getModels() { + const state = this.state; + return state && (state.models || state.model && [state.model]) || []; + } + // TODO deprecate in favour of setShaderModuleProps + /** Update shader module parameters */ + setModuleParameters(moduleParameters) { + for (const model of this.getModels()) { + model.updateModuleSettings(moduleParameters); + } + } + /** Update shader input parameters */ + setShaderModuleProps(...props) { + for (const model of this.getModels()) { + model.shaderInputs.setProps(...props); + } + } + /** Returns the attribute manager of this layer */ + getAttributeManager() { + return this.internalState && this.internalState.attributeManager; + } + /** Returns the most recent layer that matched to this state + (When reacting to an async event, this layer may no longer be the latest) */ + getCurrentLayer() { + return this.internalState && this.internalState.layer; + } + /** Returns the default parse options for async props */ + getLoadOptions() { + return this.props.loadOptions; + } + use64bitPositions() { + const { coordinateSystem } = this.props; + return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN; + } + // Event handling + onHover(info, pickingEvent) { + if (this.props.onHover) { + return this.props.onHover(info, pickingEvent) || false; + } + return false; + } + onClick(info, pickingEvent) { + if (this.props.onClick) { + return this.props.onClick(info, pickingEvent) || false; + } + return false; + } + // Returns the picking color that doesn't match any subfeature + // Use if some graphics do not belong to any pickable subfeature + // @return {Array} - a black color + nullPickingColor() { + return [0, 0, 0]; + } + // Returns the picking color that doesn't match any subfeature + // Use if some graphics do not belong to any pickable subfeature + encodePickingColor(i, target = []) { + target[0] = i + 1 & 255; + target[1] = i + 1 >> 8 & 255; + target[2] = i + 1 >> 8 >> 8 & 255; + return target; + } + // Returns the index corresponding to a picking color that doesn't match any subfeature + // @param {Uint8Array} color - color array to be decoded + // @return {Array} - the decoded picking color + decodePickingColor(color) { + assert9(color instanceof Uint8Array); + const [i1, i2, i3] = color; + const index2 = i1 + i2 * 256 + i3 * 65536 - 1; + return index2; + } + /** Deduces number of instances. Intention is to support: + - Explicit setting of numInstances + - Auto-deduction for ES6 containers that define a size member + - Auto-deduction for Classic Arrays via the built-in length attribute + - Auto-deduction via arrays */ + getNumInstances() { + if (Number.isFinite(this.props.numInstances)) { + return this.props.numInstances; + } + if (this.state && this.state.numInstances !== void 0) { + return this.state.numInstances; + } + return count(this.props.data); + } + /** Buffer layout describes how many attribute values are packed for each data object + The default (null) is one value each object. + Some data formats (e.g. paths, polygons) have various length. Their buffer layout + is in the form of [L0, L1, L2, ...] */ + getStartIndices() { + if (this.props.startIndices) { + return this.props.startIndices; + } + if (this.state && this.state.startIndices) { + return this.state.startIndices; + } + return null; + } + // Default implementation + getBounds() { + return this.getAttributeManager()?.getBounds(["positions", "instancePositions"]); + } + getShaders(shaders) { + shaders = mergeShaders(shaders, { + disableWarnings: true, + modules: this.context.defaultShaderModules + }); + for (const extension of this.props.extensions) { + shaders = mergeShaders(shaders, extension.getShaders.call(this, extension)); + } + return shaders; + } + /** Controls if updateState should be called. By default returns true if any prop has changed */ + shouldUpdateState(params) { + return params.changeFlags.propsOrDataChanged; + } + /** Default implementation, all attributes will be invalidated and updated when data changes */ + // eslint-disable-next-line complexity + updateState(params) { + const attributeManager = this.getAttributeManager(); + const { dataChanged } = params.changeFlags; + if (dataChanged && attributeManager) { + if (Array.isArray(dataChanged)) { + for (const dataRange of dataChanged) { + attributeManager.invalidateAll(dataRange); + } + } else { + attributeManager.invalidateAll(); + } + } + if (attributeManager) { + const { props } = params; + const hasPickingBuffer = this.internalState.hasPickingBuffer; + const needsPickingBuffer = Number.isInteger(props.highlightedObjectIndex) || props.pickable || props.extensions.some((extension) => extension.getNeedsPickingBuffer.call(this, extension)); + if (hasPickingBuffer !== needsPickingBuffer) { + this.internalState.hasPickingBuffer = needsPickingBuffer; + const { pickingColors, instancePickingColors } = attributeManager.attributes; + const pickingColorsAttribute = pickingColors || instancePickingColors; + if (pickingColorsAttribute) { + if (needsPickingBuffer && pickingColorsAttribute.constant) { + pickingColorsAttribute.constant = false; + attributeManager.invalidate(pickingColorsAttribute.id); + } + if (!pickingColorsAttribute.value && !needsPickingBuffer) { + pickingColorsAttribute.constant = true; + pickingColorsAttribute.value = [0, 0, 0]; + } + } + } + } + } + /** Called once when layer is no longer matched and state will be discarded. Layers can destroy WebGL resources here. */ + finalizeState(context) { + for (const model of this.getModels()) { + model.destroy(); + } + const attributeManager = this.getAttributeManager(); + if (attributeManager) { + attributeManager.finalize(); + } + if (this.context) { + this.context.resourceManager.unsubscribe({ consumerId: this.id }); + } + if (this.internalState) { + this.internalState.uniformTransitions.clear(); + this.internalState.finalize(); + } + } + // If state has a model, draw it with supplied uniforms + draw(opts) { + for (const model of this.getModels()) { + model.draw(opts); + } + } + // called to populate the info object that is passed to the event handler + // @return null to cancel event + getPickingInfo({ info, mode, sourceLayer }) { + const { index: index2 } = info; + if (index2 >= 0) { + if (Array.isArray(this.props.data)) { + info.object = this.props.data[index2]; + } + } + return info; + } + // END LIFECYCLE METHODS + // / INTERNAL METHODS - called by LayerManager, DeckRenderer and DeckPicker + /** (Internal) Propagate an error event through the system */ + raiseError(error, message2) { + if (message2) { + error = new Error(`${message2}: ${error.message}`, { cause: error }); + } + if (!this.props.onError?.(error)) { + this.context?.onError?.(error, this); + } + } + /** (Internal) Checks if this layer needs redraw */ + getNeedsRedraw(opts = { clearRedrawFlags: false }) { + return this._getNeedsRedraw(opts); + } + /** (Internal) Checks if this layer needs a deep update */ + needsUpdate() { + if (!this.internalState) { + return false; + } + return this.internalState.needsUpdate || this.hasUniformTransition() || this.shouldUpdateState(this._getUpdateParams()); + } + /** Checks if this layer has ongoing uniform transition */ + hasUniformTransition() { + return this.internalState?.uniformTransitions.active || false; + } + /** Called when this layer is rendered into the given viewport */ + activateViewport(viewport) { + if (!this.internalState) { + return; + } + const oldViewport = this.internalState.viewport; + this.internalState.viewport = viewport; + if (!oldViewport || !areViewportsEqual({ oldViewport, viewport })) { + this.setChangeFlags({ viewportChanged: true }); + if (this.isComposite) { + if (this.needsUpdate()) { + this.setNeedsUpdate(); + } + } else { + this._update(); + } + } + } + /** Default implementation of attribute invalidation, can be redefined */ + invalidateAttribute(name2 = "all") { + const attributeManager = this.getAttributeManager(); + if (!attributeManager) { + return; + } + if (name2 === "all") { + attributeManager.invalidateAll(); + } else { + attributeManager.invalidate(name2); + } + } + /** Send updated attributes to the WebGL model */ + updateAttributes(changedAttributes) { + let bufferLayoutChanged = false; + for (const id in changedAttributes) { + if (changedAttributes[id].layoutChanged()) { + bufferLayoutChanged = true; + } + } + for (const model of this.getModels()) { + this._setModelAttributes(model, changedAttributes, bufferLayoutChanged); + } + } + /** Recalculate any attributes if needed */ + _updateAttributes() { + const attributeManager = this.getAttributeManager(); + if (!attributeManager) { + return; + } + const props = this.props; + const numInstances = this.getNumInstances(); + const startIndices = this.getStartIndices(); + attributeManager.update({ + data: props.data, + numInstances, + startIndices, + props, + transitions: props.transitions, + // @ts-ignore (TS2339) property attribute is not present on some acceptable data types + buffers: props.data.attributes, + context: this + }); + const changedAttributes = attributeManager.getChangedAttributes({ clearChangedFlags: true }); + this.updateAttributes(changedAttributes); + } + /** Update attribute transitions. This is called in drawLayer, no model updates required. */ + _updateAttributeTransition() { + const attributeManager = this.getAttributeManager(); + if (attributeManager) { + attributeManager.updateTransition(); + } + } + /** Update uniform (prop) transitions. This is called in updateState, may result in model updates. */ + _updateUniformTransition() { + const { uniformTransitions } = this.internalState; + if (uniformTransitions.active) { + const propsInTransition = uniformTransitions.update(); + const props = Object.create(this.props); + for (const key in propsInTransition) { + Object.defineProperty(props, key, { value: propsInTransition[key] }); + } + return props; + } + return this.props; + } + /** Updater for the automatically populated instancePickingColors attribute */ + calculateInstancePickingColors(attribute, { numInstances }) { + if (attribute.constant) { + return; + } + const cacheSize = Math.floor(pickingColorCache.length / 4); + this.internalState.usesPickingColorCache = true; + if (cacheSize < numInstances) { + if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) { + log_default.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(); + } + pickingColorCache = typed_array_manager_default.allocate(pickingColorCache, numInstances, { + size: 4, + copy: true, + maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE) + }); + const newCacheSize = Math.floor(pickingColorCache.length / 4); + const pickingColor = []; + for (let i = cacheSize; i < newCacheSize; i++) { + this.encodePickingColor(i, pickingColor); + pickingColorCache[i * 4 + 0] = pickingColor[0]; + pickingColorCache[i * 4 + 1] = pickingColor[1]; + pickingColorCache[i * 4 + 2] = pickingColor[2]; + } + } + attribute.value = pickingColorCache.subarray(0, numInstances * 4); + } + /** Apply changed attributes to model */ + _setModelAttributes(model, changedAttributes, bufferLayoutChanged = false) { + if (!Object.keys(changedAttributes).length) { + return; + } + if (bufferLayoutChanged) { + const attributeManager = this.getAttributeManager(); + model.setBufferLayout(attributeManager.getBufferLayouts(model)); + changedAttributes = attributeManager.getAttributes(); + } + const excludeAttributes = model.userData?.excludeAttributes || {}; + const attributeBuffers = {}; + const constantAttributes = {}; + for (const name2 in changedAttributes) { + if (excludeAttributes[name2]) { + continue; + } + const values = changedAttributes[name2].getValue(); + for (const attributeName in values) { + const value = values[attributeName]; + if (value instanceof Buffer2) { + if (changedAttributes[name2].settings.isIndexed) { + model.setIndexBuffer(value); + } else { + attributeBuffers[attributeName] = value; + } + } else if (value) { + constantAttributes[attributeName] = value; + } + } + } + model.setAttributes(attributeBuffers); + model.setConstantAttributes(constantAttributes); + } + /** (Internal) Sets the picking color at the specified index to null picking color. Used for multi-depth picking. + This method may be overriden by layer implementations */ + disablePickingIndex(objectIndex) { + const data = this.props.data; + if (!("attributes" in data)) { + this._disablePickingIndex(objectIndex); + return; + } + const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + const externalColorAttribute = colors && data.attributes && data.attributes[colors.id]; + if (externalColorAttribute && externalColorAttribute.value) { + const values = externalColorAttribute.value; + const objectColor = this.encodePickingColor(objectIndex); + for (let index2 = 0; index2 < data.length; index2++) { + const i = colors.getVertexOffset(index2); + if (values[i] === objectColor[0] && values[i + 1] === objectColor[1] && values[i + 2] === objectColor[2]) { + this._disablePickingIndex(index2); + } + } + } else { + this._disablePickingIndex(objectIndex); + } + } + // TODO - simplify subclassing interface + _disablePickingIndex(objectIndex) { + const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + if (!colors) { + return; + } + const start = colors.getVertexOffset(objectIndex); + const end = colors.getVertexOffset(objectIndex + 1); + colors.buffer.write(new Uint8Array(end - start), start); + } + /** (Internal) Re-enable all picking indices after multi-depth picking */ + restorePickingColors() { + const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + if (!colors) { + return; + } + if ( + // @ts-ignore (TS2531) this method is only called internally with internalState defined + this.internalState.usesPickingColorCache && colors.value.buffer !== pickingColorCache.buffer + ) { + colors.value = pickingColorCache.subarray(0, colors.value.length); + } + colors.updateSubBuffer({ startOffset: 0 }); + } + /* eslint-disable max-statements */ + /* (Internal) Called by layer manager when a new layer is found */ + _initialize() { + assert9(!this.internalState); + assert9(Number.isFinite(this.props.coordinateSystem)); + debug(TRACE_INITIALIZE, this); + const attributeManager = this._getAttributeManager(); + if (attributeManager) { + attributeManager.addInstanced({ + instancePickingColors: { + type: "uint8", + size: 4, + noAlloc: true, + // Updaters are always called with `this` pointing to the layer + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculateInstancePickingColors + } + }); + } + this.internalState = new LayerState({ + attributeManager, + layer: this + }); + this._clearChangeFlags(); + this.state = {}; + Object.defineProperty(this.state, "attributeManager", { + get: () => { + log_default.deprecated("layer.state.attributeManager", "layer.getAttributeManager()")(); + return attributeManager; + } + }); + this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline); + this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this); + this.internalState.setAsyncProps(this.props); + this.initializeState(this.context); + for (const extension of this.props.extensions) { + extension.initializeState.call(this, this.context, extension); + } + this.setChangeFlags({ + dataChanged: "init", + propsChanged: "init", + viewportChanged: true, + extensionsChanged: true + }); + this._update(); + } + /** (Internal) Called by layer manager to transfer state from an old layer */ + _transferState(oldLayer) { + debug(TRACE_MATCHED, this, this === oldLayer); + const { state, internalState } = oldLayer; + if (this === oldLayer) { + return; + } + this.internalState = internalState; + this.state = state; + this.internalState.setAsyncProps(this.props); + this._diffProps(this.props, this.internalState.getOldProps()); + } + /** (Internal) Called by layer manager when a new layer is added or an existing layer is matched with a new instance */ + _update() { + const stateNeedsUpdate = this.needsUpdate(); + debug(TRACE_UPDATE, this, stateNeedsUpdate); + if (!stateNeedsUpdate) { + return; + } + const currentProps = this.props; + const context = this.context; + const internalState = this.internalState; + const currentViewport = context.viewport; + const propsInTransition = this._updateUniformTransition(); + internalState.propsInTransition = propsInTransition; + context.viewport = internalState.viewport || currentViewport; + this.props = propsInTransition; + try { + const updateParams = this._getUpdateParams(); + const oldModels = this.getModels(); + if (context.device) { + this.updateState(updateParams); + } else { + try { + this.updateState(updateParams); + } catch (error) { + } + } + for (const extension of this.props.extensions) { + extension.updateState.call(this, updateParams, extension); + } + const modelChanged = this.getModels()[0] !== oldModels[0]; + this._postUpdate(updateParams, modelChanged); + } finally { + context.viewport = currentViewport; + this.props = currentProps; + this._clearChangeFlags(); + internalState.needsUpdate = false; + internalState.resetOldProps(); + } + } + /* eslint-enable max-statements */ + /** (Internal) Called by manager when layer is about to be disposed + Note: not guaranteed to be called on application shutdown */ + _finalize() { + debug(TRACE_FINALIZE, this); + this.finalizeState(this.context); + for (const extension of this.props.extensions) { + extension.finalizeState.call(this, this.context, extension); + } + } + // Calculates uniforms + _drawLayer({ renderPass, moduleParameters = null, uniforms = {}, parameters = {} }) { + this._updateAttributeTransition(); + const currentProps = this.props; + const context = this.context; + this.props = this.internalState.propsInTransition || currentProps; + const opacity = this.props.opacity; + uniforms.opacity = Math.pow(opacity, 1 / 2.2); + try { + if (moduleParameters) { + const { isActive, isAttribute } = moduleParameters.picking; + this.setModuleParameters(moduleParameters); + this.setShaderModuleProps({ picking: { isActive, isAttribute } }); + } + const { getPolygonOffset } = this.props; + const offsets = getPolygonOffset && getPolygonOffset(uniforms) || [0, 0]; + context.device.setParametersWebGL({ polygonOffset: offsets }); + for (const model of this.getModels()) { + model.setParameters(parameters); + } + context.device.withParametersWebGL(parameters, () => { + const opts = { renderPass, moduleParameters, uniforms, parameters, context }; + for (const extension of this.props.extensions) { + extension.draw.call(this, opts, extension); + } + this.draw(opts); + }); + } finally { + this.props = currentProps; + } + } + // Helper methods + /** Returns the current change flags */ + getChangeFlags() { + return this.internalState?.changeFlags; + } + /* eslint-disable complexity */ + /** Dirty some change flags, will be handled by updateLayer */ + setChangeFlags(flags) { + if (!this.internalState) { + return; + } + const { changeFlags } = this.internalState; + for (const key in flags) { + if (flags[key]) { + let flagChanged = false; + switch (key) { + case "dataChanged": + const dataChangedReason = flags[key]; + const prevDataChangedReason = changeFlags[key]; + if (dataChangedReason && Array.isArray(prevDataChangedReason)) { + changeFlags.dataChanged = Array.isArray(dataChangedReason) ? prevDataChangedReason.concat(dataChangedReason) : dataChangedReason; + flagChanged = true; + } + default: + if (!changeFlags[key]) { + changeFlags[key] = flags[key]; + flagChanged = true; + } + } + if (flagChanged) { + debug(TRACE_CHANGE_FLAG, this, key, flags); + } + } + } + const propsOrDataChanged = Boolean(changeFlags.dataChanged || changeFlags.updateTriggersChanged || changeFlags.propsChanged || changeFlags.extensionsChanged); + changeFlags.propsOrDataChanged = propsOrDataChanged; + changeFlags.somethingChanged = propsOrDataChanged || changeFlags.viewportChanged || changeFlags.stateChanged; + } + /* eslint-enable complexity */ + /** Clear all changeFlags, typically after an update */ + _clearChangeFlags() { + this.internalState.changeFlags = { + dataChanged: false, + propsChanged: false, + updateTriggersChanged: false, + viewportChanged: false, + stateChanged: false, + extensionsChanged: false, + propsOrDataChanged: false, + somethingChanged: false + }; + } + /** Compares the layers props with old props from a matched older layer + and extracts change flags that describe what has change so that state + can be update correctly with minimal effort */ + _diffProps(newProps, oldProps) { + const changeFlags = diffProps(newProps, oldProps); + if (changeFlags.updateTriggersChanged) { + for (const key in changeFlags.updateTriggersChanged) { + if (changeFlags.updateTriggersChanged[key]) { + this.invalidateAttribute(key); + } + } + } + if (changeFlags.transitionsChanged) { + for (const key in changeFlags.transitionsChanged) { + this.internalState.uniformTransitions.add(key, oldProps[key], newProps[key], newProps.transitions?.[key]); + } + } + return this.setChangeFlags(changeFlags); + } + /** (Internal) called by layer manager to perform extra props validation (in development only) */ + validateProps() { + validateProps(this.props); + } + /** (Internal) Called by deck picker when the hovered object changes to update the auto highlight */ + updateAutoHighlight(info) { + if (this.props.autoHighlight && !Number.isInteger(this.props.highlightedObjectIndex)) { + this._updateAutoHighlight(info); + } + } + // May be overriden by subclasses + // TODO - simplify subclassing interface + /** Update picking module parameters to highlight the hovered object */ + _updateAutoHighlight(info) { + const picking2 = { + // @ts-expect-error stricter luma gl types + highlightedObjectColor: info.picked ? info.color : null + }; + const { highlightColor } = this.props; + if (info.picked && typeof highlightColor === "function") { + picking2.highlightColor = highlightColor(info); + } + this.setShaderModuleProps({ picking: picking2 }); + this.setNeedsRedraw(); + } + /** Create new attribute manager */ + _getAttributeManager() { + const context = this.context; + return new AttributeManager(context.device, { + id: this.props.id, + stats: context.stats, + timeline: context.timeline + }); + } + // Private methods + /** Called after updateState to perform common tasks */ + _postUpdate(updateParams, forceUpdate) { + const { props, oldProps } = updateParams; + this.setNeedsRedraw(); + this._updateAttributes(); + const model = this.state.model; + if (model?.isInstanced) { + model.setInstanceCount(this.getNumInstances()); + } + const { autoHighlight, highlightedObjectIndex, highlightColor } = props; + if (forceUpdate || oldProps.autoHighlight !== autoHighlight || oldProps.highlightedObjectIndex !== highlightedObjectIndex || oldProps.highlightColor !== highlightColor) { + const picking2 = {}; + if (Array.isArray(highlightColor)) { + picking2.highlightColor = highlightColor; + } + if (forceUpdate || oldProps.autoHighlight !== autoHighlight || highlightedObjectIndex !== oldProps.highlightedObjectIndex) { + picking2.highlightedObjectColor = Number.isFinite(highlightedObjectIndex) && highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null; + } + this.setShaderModuleProps({ picking: picking2 }); + } + } + _getUpdateParams() { + return { + props: this.props, + // @ts-ignore TS2531 this method can only be called internally with internalState assigned + oldProps: this.internalState.getOldProps(), + context: this.context, + // @ts-ignore TS2531 this method can only be called internally with internalState assigned + changeFlags: this.internalState.changeFlags + }; + } + /** Checks state of attributes and model */ + _getNeedsRedraw(opts) { + if (!this.internalState) { + return false; + } + let redraw = false; + redraw = redraw || this.internalState.needsRedraw && this.id; + const attributeManager = this.getAttributeManager(); + const attributeManagerNeedsRedraw = attributeManager ? attributeManager.getNeedsRedraw(opts) : false; + redraw = redraw || attributeManagerNeedsRedraw; + if (redraw) { + for (const extension of this.props.extensions) { + extension.onNeedsRedraw.call(this, extension); + } + } + this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags; + return redraw; + } + /** Callback when asyn prop is loaded */ + _onAsyncPropUpdated() { + this._diffProps(this.props, this.internalState.getOldProps()); + this.setNeedsUpdate(); + } +}; +Layer.defaultProps = defaultProps2; +Layer.layerName = "Layer"; +var layer_default = Layer; + +// node_modules/@deck.gl/core/dist/lib/composite-layer.js +var TRACE_RENDER_LAYERS2 = "compositeLayer.renderLayers"; +var CompositeLayer = class extends layer_default { + /** `true` if this layer renders other layers */ + get isComposite() { + return true; + } + /** Returns true if all async resources are loaded */ + get isLoaded() { + return super.isLoaded && this.getSubLayers().every((layer) => layer.isLoaded); + } + /** Return last rendered sub layers */ + getSubLayers() { + return this.internalState && this.internalState.subLayers || []; + } + // initializeState is usually not needed for composite layers + // Provide empty definition to disable check for missing definition + // eslint-disable-next-line @typescript-eslint/no-empty-function + initializeState(context) { + } + /** Updates selected state members and marks the composite layer to need rerender */ + setState(updateObject) { + super.setState(updateObject); + this.setNeedsUpdate(); + } + /** called to augment the info object that is bubbled up from a sublayer + override Layer.getPickingInfo() because decoding / setting uniform do + not apply to a composite layer. */ + getPickingInfo({ info }) { + const { object } = info; + const isDataWrapped = object && object.__source && object.__source.parent && object.__source.parent.id === this.id; + if (!isDataWrapped) { + return info; + } + info.object = object.__source.object; + info.index = object.__source.index; + return info; + } + /** + * Filters sub layers at draw time. Return true if the sub layer should be drawn. + */ + filterSubLayer(context) { + return true; + } + /** Returns true if sub layer needs to be rendered */ + shouldRenderSubLayer(subLayerId, data) { + return data && data.length; + } + /** Returns sub layer class for a specific sublayer */ + getSubLayerClass(subLayerId, DefaultLayerClass) { + const { _subLayerProps: overridingProps } = this.props; + return overridingProps && overridingProps[subLayerId] && overridingProps[subLayerId].type || DefaultLayerClass; + } + /** When casting user data into another format to pass to sublayers, + add reference to the original object and object index */ + getSubLayerRow(row, sourceObject, sourceObjectIndex) { + row.__source = { + parent: this, + object: sourceObject, + index: sourceObjectIndex + }; + return row; + } + /** Some composite layers cast user data into another format before passing to sublayers + We need to unwrap them before calling the accessor so that they see the original data + objects */ + getSubLayerAccessor(accessor) { + if (typeof accessor === "function") { + const objectInfo = { + index: -1, + // @ts-ignore accessing resolved data + data: this.props.data, + target: [] + }; + return (x, i) => { + if (x && x.__source) { + objectInfo.index = x.__source.index; + return accessor(x.__source.object, objectInfo); + } + return accessor(x, i); + }; + } + return accessor; + } + /** Returns sub layer props for a specific sublayer */ + // eslint-disable-next-line complexity + getSubLayerProps(sublayerProps = {}) { + const { opacity, pickable, visible, parameters, getPolygonOffset, highlightedObjectIndex, autoHighlight, highlightColor, coordinateSystem, coordinateOrigin, wrapLongitude, positionFormat, modelMatrix, extensions, fetch: fetch2, operation, _subLayerProps: overridingProps } = this.props; + const newProps = { + id: "", + updateTriggers: {}, + opacity, + pickable, + visible, + parameters, + getPolygonOffset, + highlightedObjectIndex, + autoHighlight, + highlightColor, + coordinateSystem, + coordinateOrigin, + wrapLongitude, + positionFormat, + modelMatrix, + extensions, + fetch: fetch2, + operation + }; + const overridingSublayerProps = overridingProps && sublayerProps.id && overridingProps[sublayerProps.id]; + const overridingSublayerTriggers = overridingSublayerProps && overridingSublayerProps.updateTriggers; + const sublayerId = sublayerProps.id || "sublayer"; + if (overridingSublayerProps) { + const propTypes = this.props[PROP_TYPES_SYMBOL]; + const subLayerPropTypes = sublayerProps.type ? sublayerProps.type._propTypes : {}; + for (const key in overridingSublayerProps) { + const propType = subLayerPropTypes[key] || propTypes[key]; + if (propType && propType.type === "accessor") { + overridingSublayerProps[key] = this.getSubLayerAccessor(overridingSublayerProps[key]); + } + } + } + Object.assign( + newProps, + sublayerProps, + // experimental feature that allows users to override sublayer props via parent layer prop + overridingSublayerProps + ); + newProps.id = `${this.props.id}-${sublayerId}`; + newProps.updateTriggers = { + all: this.props.updateTriggers?.all, + ...sublayerProps.updateTriggers, + ...overridingSublayerTriggers + }; + for (const extension of extensions) { + const passThroughProps = extension.getSubLayerProps.call(this, extension); + if (passThroughProps) { + Object.assign(newProps, passThroughProps, { + updateTriggers: Object.assign(newProps.updateTriggers, passThroughProps.updateTriggers) + }); + } + } + return newProps; + } + /** Update sub layers to highlight the hovered object */ + _updateAutoHighlight(info) { + for (const layer of this.getSubLayers()) { + layer.updateAutoHighlight(info); + } + } + /** Override base Layer method */ + _getAttributeManager() { + return null; + } + /** (Internal) Called after an update to rerender sub layers */ + _postUpdate(updateParams, forceUpdate) { + let subLayers = this.internalState.subLayers; + const shouldUpdate = !subLayers || this.needsUpdate(); + if (shouldUpdate) { + const subLayersList = this.renderLayers(); + subLayers = flatten(subLayersList, Boolean); + this.internalState.subLayers = subLayers; + } + debug(TRACE_RENDER_LAYERS2, this, shouldUpdate, subLayers); + for (const layer of subLayers) { + layer.parent = this; + } + } +}; +CompositeLayer.layerName = "CompositeLayer"; +var composite_layer_default = CompositeLayer; + +// node_modules/@deck.gl/core/dist/viewports/globe-viewport.js +var DEGREES_TO_RADIANS5 = Math.PI / 180; +var RADIANS_TO_DEGREES3 = 180 / Math.PI; +var EARTH_RADIUS = 6370972; +var GLOBE_RADIUS = 256; +function getDistanceScales2() { + const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS; + const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS; + return { + unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2], + unitsPerMeter2: [0, 0, 0], + metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2], + unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2], + unitsPerDegree2: [0, 0, 0], + degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2] + }; +} +var GlobeViewport = class extends viewport_default { + constructor(opts = {}) { + const { latitude = 0, longitude = 0, zoom = 0, nearZMultiplier = 0.1, farZMultiplier = 2, resolution = 10 } = opts; + let { height, altitude = 1.5 } = opts; + height = height || 1; + altitude = Math.max(0.75, altitude); + const viewMatrix = new Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }); + const scale13 = Math.pow(2, zoom); + viewMatrix.rotateX(latitude * DEGREES_TO_RADIANS5); + viewMatrix.rotateZ(-longitude * DEGREES_TO_RADIANS5); + viewMatrix.scale(scale13 / height); + const halfFov = Math.atan(0.5 / altitude); + const relativeScale = GLOBE_RADIUS * 2 * scale13 / height; + super({ + ...opts, + // x, y, width, + height, + // view matrix + viewMatrix, + longitude, + latitude, + zoom, + // projection matrix parameters + distanceScales: getDistanceScales2(), + fovyRadians: halfFov * 2, + focalDistance: altitude, + near: nearZMultiplier, + far: Math.min(2, 1 / relativeScale + 1) * altitude * farZMultiplier + }); + this.latitude = latitude; + this.longitude = longitude; + this.resolution = resolution; + } + get projectionMode() { + return PROJECTION_MODE.GLOBE; + } + getDistanceScales() { + return this.distanceScales; + } + getBounds(options = {}) { + const unprojectOption = { targetZ: options.z || 0 }; + const left = this.unproject([0, this.height / 2], unprojectOption); + const top = this.unproject([this.width / 2, 0], unprojectOption); + const right = this.unproject([this.width, this.height / 2], unprojectOption); + const bottom = this.unproject([this.width / 2, this.height], unprojectOption); + if (right[0] < this.longitude) + right[0] += 360; + if (left[0] > this.longitude) + left[0] -= 360; + return [ + Math.min(left[0], right[0], top[0], bottom[0]), + Math.min(left[1], right[1], top[1], bottom[1]), + Math.max(left[0], right[0], top[0], bottom[0]), + Math.max(left[1], right[1], top[1], bottom[1]) + ]; + } + unproject(xyz, { topLeft = true, targetZ } = {}) { + const [x, y, z] = xyz; + const y2 = topLeft ? y : this.height - y; + const { pixelUnprojectionMatrix } = this; + let coord; + if (Number.isFinite(z)) { + coord = transformVector2(pixelUnprojectionMatrix, [x, y2, z, 1]); + } else { + const coord0 = transformVector2(pixelUnprojectionMatrix, [x, y2, -1, 1]); + const coord1 = transformVector2(pixelUnprojectionMatrix, [x, y2, 1, 1]); + const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS; + const lSqr = vec3_exports.sqrLen(vec3_exports.sub([], coord0, coord1)); + const l0Sqr = vec3_exports.sqrLen(coord0); + const l1Sqr = vec3_exports.sqrLen(coord1); + const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16; + const dSqr = 4 * sSqr / lSqr; + const r0 = Math.sqrt(l0Sqr - dSqr); + const dr = Math.sqrt(Math.max(0, lt * lt - dSqr)); + const t = (r0 - dr) / Math.sqrt(lSqr); + coord = vec3_exports.lerp([], coord0, coord1, t); + } + const [X, Y, Z] = this.unprojectPosition(coord); + if (Number.isFinite(z)) { + return [X, Y, Z]; + } + return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; + } + projectPosition(xyz) { + const [lng, lat, Z = 0] = xyz; + const lambda = lng * DEGREES_TO_RADIANS5; + const phi = lat * DEGREES_TO_RADIANS5; + const cosPhi = Math.cos(phi); + const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS; + return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D]; + } + unprojectPosition(xyz) { + const [x, y, z] = xyz; + const D = vec3_exports.len(xyz); + const phi = Math.asin(z / D); + const lambda = Math.atan2(x, -y); + const lng = lambda * RADIANS_TO_DEGREES3; + const lat = phi * RADIANS_TO_DEGREES3; + const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS; + return [lng, lat, Z]; + } + projectFlat(xyz) { + return xyz; + } + unprojectFlat(xyz) { + return xyz; + } + panByPosition(coords, pixel) { + const fromPosition = this.unproject(pixel); + return { + longitude: coords[0] - fromPosition[0] + this.longitude, + latitude: coords[1] - fromPosition[1] + this.latitude + }; + } +}; +function transformVector2(matrix, vector) { + const result = vec4_exports.transformMat4([], vector, matrix); + vec4_exports.scale(result, result, 1 / result[3]); + return result; +} + +// node_modules/@deck.gl/core/dist/utils/tesselator.js +var Tesselator = class { + constructor(opts) { + this.indexStarts = [0]; + this.vertexStarts = [0]; + this.vertexCount = 0; + this.instanceCount = 0; + const { attributes = {} } = opts; + this.typedArrayManager = typed_array_manager_default; + this.attributes = {}; + this._attributeDefs = attributes; + this.opts = opts; + this.updateGeometry(opts); + } + /* Public methods */ + updateGeometry(opts) { + Object.assign(this.opts, opts); + const { data, buffers = {}, getGeometry, geometryBuffer, positionFormat, dataChanged, normalize: normalize11 = true } = this.opts; + this.data = data; + this.getGeometry = getGeometry; + this.positionSize = // @ts-ignore (2339) when geometryBuffer is a luma Buffer, size falls back to positionFormat + geometryBuffer && geometryBuffer.size || (positionFormat === "XY" ? 2 : 3); + this.buffers = buffers; + this.normalize = normalize11; + if (geometryBuffer) { + assert9(data.startIndices); + this.getGeometry = this.getGeometryFromBuffer(geometryBuffer); + if (!normalize11) { + buffers.vertexPositions = geometryBuffer; + } + } + this.geometryBuffer = buffers.vertexPositions; + if (Array.isArray(dataChanged)) { + for (const dataRange of dataChanged) { + this._rebuildGeometry(dataRange); + } + } else { + this._rebuildGeometry(); + } + } + updatePartialGeometry({ startRow, endRow }) { + this._rebuildGeometry({ startRow, endRow }); + } + getGeometryFromBuffer(geometryBuffer) { + const value = geometryBuffer.value || geometryBuffer; + if (!ArrayBuffer.isView(value)) { + return null; + } + return getAccessorFromBuffer(value, { + size: this.positionSize, + offset: geometryBuffer.offset, + stride: geometryBuffer.stride, + startIndices: this.data.startIndices + }); + } + /* Private utility methods */ + _allocate(instanceCount, copy12) { + const { attributes, buffers, _attributeDefs, typedArrayManager } = this; + for (const name2 in _attributeDefs) { + if (name2 in buffers) { + typedArrayManager.release(attributes[name2]); + attributes[name2] = null; + } else { + const def = _attributeDefs[name2]; + def.copy = copy12; + attributes[name2] = typedArrayManager.allocate(attributes[name2], instanceCount, def); + } + } + } + /** + * Visit all objects + * `data` is expected to be an iterable consistent with the base Layer expectation + */ + _forEachGeometry(visitor, startRow, endRow) { + const { data, getGeometry } = this; + const { iterable, objectInfo } = createIterable(data, startRow, endRow); + for (const object of iterable) { + objectInfo.index++; + const geometry = getGeometry ? getGeometry(object, objectInfo) : null; + visitor(geometry, objectInfo.index); + } + } + /* eslint-disable complexity,max-statements */ + _rebuildGeometry(dataRange) { + if (!this.data) { + return; + } + let { indexStarts, vertexStarts, instanceCount } = this; + const { data, geometryBuffer } = this; + const { startRow = 0, endRow = Infinity } = dataRange || {}; + const normalizedData = {}; + if (!dataRange) { + indexStarts = [0]; + vertexStarts = [0]; + } + if (this.normalize || !geometryBuffer) { + this._forEachGeometry((geometry, dataIndex) => { + const normalizedGeometry = geometry && this.normalizeGeometry(geometry); + normalizedData[dataIndex] = normalizedGeometry; + vertexStarts[dataIndex + 1] = vertexStarts[dataIndex] + (normalizedGeometry ? this.getGeometrySize(normalizedGeometry) : 0); + }, startRow, endRow); + instanceCount = vertexStarts[vertexStarts.length - 1]; + } else { + vertexStarts = data.startIndices; + instanceCount = vertexStarts[data.length] || 0; + if (ArrayBuffer.isView(geometryBuffer)) { + instanceCount = instanceCount || geometryBuffer.length / this.positionSize; + } else if (geometryBuffer instanceof Buffer2) { + const byteStride = this.positionSize * 4; + instanceCount = instanceCount || geometryBuffer.byteLength / byteStride; + } else if (geometryBuffer.buffer) { + const byteStride = geometryBuffer.stride || this.positionSize * 4; + instanceCount = instanceCount || geometryBuffer.buffer.byteLength / byteStride; + } else if (geometryBuffer.value) { + const bufferValue = geometryBuffer.value; + const elementStride = ( + // @ts-ignore (2339) if stride is not specified, will fall through to positionSize + geometryBuffer.stride / bufferValue.BYTES_PER_ELEMENT || this.positionSize + ); + instanceCount = instanceCount || bufferValue.length / elementStride; + } + } + this._allocate(instanceCount, Boolean(dataRange)); + this.indexStarts = indexStarts; + this.vertexStarts = vertexStarts; + this.instanceCount = instanceCount; + const context = {}; + this._forEachGeometry((geometry, dataIndex) => { + const normalizedGeometry = normalizedData[dataIndex] || geometry; + context.vertexStart = vertexStarts[dataIndex]; + context.indexStart = indexStarts[dataIndex]; + const vertexEnd = dataIndex < vertexStarts.length - 1 ? vertexStarts[dataIndex + 1] : instanceCount; + context.geometrySize = vertexEnd - vertexStarts[dataIndex]; + context.geometryIndex = dataIndex; + this.updateGeometryAttributes(normalizedGeometry, context); + }, startRow, endRow); + this.vertexCount = indexStarts[indexStarts.length - 1]; + } +}; + +// node_modules/@deck.gl/layers/dist/bitmap-layer/create-mesh.js +var DEFAULT_INDICES = new Uint32Array([0, 2, 1, 0, 3, 2]); +var DEFAULT_TEX_COORDS = new Float32Array([0, 1, 0, 0, 1, 0, 1, 1]); +function createMesh(bounds, resolution) { + if (!resolution) { + return createQuad(bounds); + } + const maxXSpan = Math.max(Math.abs(bounds[0][0] - bounds[3][0]), Math.abs(bounds[1][0] - bounds[2][0])); + const maxYSpan = Math.max(Math.abs(bounds[1][1] - bounds[0][1]), Math.abs(bounds[2][1] - bounds[3][1])); + const uCount = Math.ceil(maxXSpan / resolution) + 1; + const vCount = Math.ceil(maxYSpan / resolution) + 1; + const vertexCount = (uCount - 1) * (vCount - 1) * 6; + const indices = new Uint32Array(vertexCount); + const texCoords = new Float32Array(uCount * vCount * 2); + const positions = new Float64Array(uCount * vCount * 3); + let vertex = 0; + let index2 = 0; + for (let u = 0; u < uCount; u++) { + const ut = u / (uCount - 1); + for (let v = 0; v < vCount; v++) { + const vt = v / (vCount - 1); + const p = interpolateQuad(bounds, ut, vt); + positions[vertex * 3 + 0] = p[0]; + positions[vertex * 3 + 1] = p[1]; + positions[vertex * 3 + 2] = p[2] || 0; + texCoords[vertex * 2 + 0] = ut; + texCoords[vertex * 2 + 1] = 1 - vt; + if (u > 0 && v > 0) { + indices[index2++] = vertex - vCount; + indices[index2++] = vertex - vCount - 1; + indices[index2++] = vertex - 1; + indices[index2++] = vertex - vCount; + indices[index2++] = vertex - 1; + indices[index2++] = vertex; + } + vertex++; + } + } + return { + vertexCount, + positions, + indices, + texCoords + }; +} +function createQuad(bounds) { + const positions = new Float64Array(12); + for (let i = 0; i < bounds.length; i++) { + positions[i * 3 + 0] = bounds[i][0]; + positions[i * 3 + 1] = bounds[i][1]; + positions[i * 3 + 2] = bounds[i][2] || 0; + } + return { + vertexCount: 6, + positions, + indices: DEFAULT_INDICES, + texCoords: DEFAULT_TEX_COORDS + }; +} +function interpolateQuad(quad, ut, vt) { + return lerp(lerp(quad[0], quad[1], vt), lerp(quad[3], quad[2], vt), ut); +} + +// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer-vertex.js +var bitmap_layer_vertex_default = `#version 300 es +#define SHADER_NAME bitmap-layer-vertex-shader + +in vec2 texCoords; +in vec3 positions; +in vec3 positions64Low; + +out vec2 vTexCoord; +out vec2 vTexPos; + +uniform float coordinateConversion; + +const vec3 pickingColor = vec3(1.0, 0.0, 0.0); + +void main(void) { + geometry.worldPosition = positions; + geometry.uv = texCoords; + geometry.pickingColor = pickingColor; + + gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position); + DECKGL_FILTER_GL_POSITION(gl_Position, geometry); + + vTexCoord = texCoords; + + if (coordinateConversion < -0.5) { + vTexPos = geometry.position.xy + project_uCommonOrigin.xy; + } else if (coordinateConversion > 0.5) { + vTexPos = geometry.worldPosition.xy; + } + + vec4 color = vec4(0.0); + DECKGL_FILTER_COLOR(color, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer-fragment.js +var packUVsIntoRGB = ` +vec3 packUVsIntoRGB(vec2 uv) { + // Extract the top 8 bits. We want values to be truncated down so we can add a fraction + vec2 uv8bit = floor(uv * 256.); + + // Calculate the normalized remainders of u and v parts that do not fit into 8 bits + // Scale and clamp to 0-1 range + vec2 uvFraction = fract(uv * 256.); + vec2 uvFraction4bit = floor(uvFraction * 16.); + + // Remainder can be encoded in blue channel, encode as 4 bits for pixel coordinates + float fractions = uvFraction4bit.x + uvFraction4bit.y * 16.; + + return vec3(uv8bit, fractions) / 255.; +} +`; +var bitmap_layer_fragment_default = `#version 300 es +#define SHADER_NAME bitmap-layer-fragment-shader + +#ifdef GL_ES +precision highp float; +#endif + +uniform sampler2D bitmapTexture; + +in vec2 vTexCoord; +in vec2 vTexPos; + +out vec4 fragColor; + +uniform float desaturate; +uniform vec4 transparentColor; +uniform vec3 tintColor; +uniform float opacity; + +uniform float coordinateConversion; +uniform vec4 bounds; + +/* projection utils */ +const float TILE_SIZE = 512.0; +const float PI = 3.1415926536; +const float WORLD_SCALE = TILE_SIZE / PI / 2.0; + +// from degrees to Web Mercator +vec2 lnglat_to_mercator(vec2 lnglat) { + float x = lnglat.x; + float y = clamp(lnglat.y, -89.9, 89.9); + return vec2( + radians(x) + PI, + PI + log(tan(PI * 0.25 + radians(y) * 0.5)) + ) * WORLD_SCALE; +} + +// from Web Mercator to degrees +vec2 mercator_to_lnglat(vec2 xy) { + xy /= WORLD_SCALE; + return degrees(vec2( + xy.x - PI, + atan(exp(xy.y - PI)) * 2.0 - PI * 0.5 + )); +} +/* End projection utils */ + +// apply desaturation +vec3 color_desaturate(vec3 color) { + float luminance = (color.r + color.g + color.b) * 0.333333333; + return mix(color, vec3(luminance), desaturate); +} + +// apply tint +vec3 color_tint(vec3 color) { + return color * tintColor; +} + +// blend with background color +vec4 apply_opacity(vec3 color, float alpha) { + if (transparentColor.a == 0.0) { + return vec4(color, alpha); + } + float blendedAlpha = alpha + transparentColor.a * (1.0 - alpha); + float highLightRatio = alpha / blendedAlpha; + vec3 blendedRGB = mix(transparentColor.rgb, color, highLightRatio); + return vec4(blendedRGB, blendedAlpha); +} + +vec2 getUV(vec2 pos) { + return vec2( + (pos.x - bounds[0]) / (bounds[2] - bounds[0]), + (pos.y - bounds[3]) / (bounds[1] - bounds[3]) + ); +} + +${packUVsIntoRGB} + +void main(void) { + vec2 uv = vTexCoord; + if (coordinateConversion < -0.5) { + vec2 lnglat = mercator_to_lnglat(vTexPos); + uv = getUV(lnglat); + } else if (coordinateConversion > 0.5) { + vec2 commonPos = lnglat_to_mercator(vTexPos); + uv = getUV(commonPos); + } + vec4 bitmapColor = texture(bitmapTexture, uv); + + fragColor = apply_opacity(color_tint(color_desaturate(bitmapColor.rgb)), bitmapColor.a * opacity); + + geometry.uv = uv; + DECKGL_FILTER_COLOR(fragColor, geometry); + + if (bool(picking.isActive) && !bool(picking.isAttribute)) { + // Since instance information is not used, we can use picking color for pixel index + fragColor.rgb = packUVsIntoRGB(uv); + } +} +`; + +// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer.js +var defaultProps3 = { + image: { type: "image", value: null, async: true }, + bounds: { type: "array", value: [1, 0, 0, 1], compare: true }, + _imageCoordinateSystem: COORDINATE_SYSTEM.DEFAULT, + desaturate: { type: "number", min: 0, max: 1, value: 0 }, + // More context: because of the blending mode we're using for ground imagery, + // alpha is not effective when blending the bitmap layers with the base map. + // Instead we need to manually dim/blend rgb values with a background color. + transparentColor: { type: "color", value: [0, 0, 0, 0] }, + tintColor: { type: "color", value: [255, 255, 255] }, + textureParameters: { type: "object", ignore: true, value: null } +}; +var BitmapLayer = class extends layer_default { + getShaders() { + return super.getShaders({ vs: bitmap_layer_vertex_default, fs: bitmap_layer_fragment_default, modules: [project32_default, picking_default] }); + } + initializeState() { + const attributeManager = this.getAttributeManager(); + attributeManager.remove(["instancePickingColors"]); + const noAlloc = true; + attributeManager.add({ + indices: { + size: 1, + isIndexed: true, + update: (attribute) => attribute.value = this.state.mesh.indices, + noAlloc + }, + positions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + update: (attribute) => attribute.value = this.state.mesh.positions, + noAlloc + }, + texCoords: { + size: 2, + update: (attribute) => attribute.value = this.state.mesh.texCoords, + noAlloc + } + }); + } + updateState({ props, oldProps, changeFlags }) { + const attributeManager = this.getAttributeManager(); + if (changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + attributeManager.invalidateAll(); + } + if (props.bounds !== oldProps.bounds) { + const oldMesh = this.state.mesh; + const mesh = this._createMesh(); + this.state.model.setVertexCount(mesh.vertexCount); + for (const key in mesh) { + if (oldMesh && oldMesh[key] !== mesh[key]) { + attributeManager.invalidate(key); + } + } + this.setState({ mesh, ...this._getCoordinateUniforms() }); + } else if (props._imageCoordinateSystem !== oldProps._imageCoordinateSystem) { + this.setState(this._getCoordinateUniforms()); + } + } + getPickingInfo(params) { + const { image } = this.props; + const info = params.info; + if (!info.color || !image) { + info.bitmap = null; + return info; + } + const { width, height } = image; + info.index = 0; + const uv = unpackUVsFromRGB(info.color); + info.bitmap = { + size: { width, height }, + uv, + pixel: [Math.floor(uv[0] * width), Math.floor(uv[1] * height)] + }; + return info; + } + // Override base Layer multi-depth picking logic + disablePickingIndex() { + this.setState({ disablePicking: true }); + } + restorePickingColors() { + this.setState({ disablePicking: false }); + } + _updateAutoHighlight(info) { + super._updateAutoHighlight({ + ...info, + color: this.encodePickingColor(0) + }); + } + _createMesh() { + const { bounds } = this.props; + let normalizedBounds = bounds; + if (isRectangularBounds(bounds)) { + normalizedBounds = [ + [bounds[0], bounds[1]], + [bounds[0], bounds[3]], + [bounds[2], bounds[3]], + [bounds[2], bounds[1]] + ]; + } + return createMesh(normalizedBounds, this.context.viewport.resolution); + } + _getModel() { + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + topology: "triangle-list", + isInstanced: false + }); + } + draw(opts) { + const { uniforms, moduleParameters } = opts; + const { model, coordinateConversion, bounds, disablePicking } = this.state; + const { image, desaturate, transparentColor, tintColor } = this.props; + if (moduleParameters.picking.isActive && disablePicking) { + return; + } + if (image && model) { + model.setUniforms(uniforms); + model.setBindings({ bitmapTexture: image }); + model.setUniforms({ + desaturate, + transparentColor: transparentColor.map((x) => x / 255), + // @ts-expect-error stricter luma gl types + tintColor: tintColor.slice(0, 3).map((x) => x / 255), + coordinateConversion, + bounds + }); + model.draw(this.context.renderPass); + } + } + _getCoordinateUniforms() { + const { LNGLAT, CARTESIAN, DEFAULT } = COORDINATE_SYSTEM; + let { _imageCoordinateSystem: imageCoordinateSystem } = this.props; + if (imageCoordinateSystem !== DEFAULT) { + const { bounds } = this.props; + if (!isRectangularBounds(bounds)) { + throw new Error("_imageCoordinateSystem only supports rectangular bounds"); + } + const defaultImageCoordinateSystem = this.context.viewport.resolution ? LNGLAT : CARTESIAN; + imageCoordinateSystem = imageCoordinateSystem === LNGLAT ? LNGLAT : CARTESIAN; + if (imageCoordinateSystem === LNGLAT && defaultImageCoordinateSystem === CARTESIAN) { + return { coordinateConversion: -1, bounds }; + } + if (imageCoordinateSystem === CARTESIAN && defaultImageCoordinateSystem === LNGLAT) { + const bottomLeft = lngLatToWorld([bounds[0], bounds[1]]); + const topRight = lngLatToWorld([bounds[2], bounds[3]]); + return { + coordinateConversion: 1, + bounds: [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]] + }; + } + } + return { + coordinateConversion: 0, + bounds: [0, 0, 0, 0] + }; + } +}; +BitmapLayer.layerName = "BitmapLayer"; +BitmapLayer.defaultProps = defaultProps3; +var bitmap_layer_default = BitmapLayer; +function unpackUVsFromRGB(color) { + const [u, v, fracUV] = color; + const vFrac = (fracUV & 240) / 256; + const uFrac = (fracUV & 15) / 16; + return [(u + uFrac) / 256, (v + vFrac) / 256]; +} +function isRectangularBounds(bounds) { + return Number.isFinite(bounds[0]); +} + +// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer-vertex.glsl.js +var icon_layer_vertex_glsl_default = `#version 300 es +#define SHADER_NAME icon-layer-vertex-shader +in vec2 positions; +in vec3 instancePositions; +in vec3 instancePositions64Low; +in float instanceSizes; +in float instanceAngles; +in vec4 instanceColors; +in vec3 instancePickingColors; +in vec4 instanceIconFrames; +in float instanceColorModes; +in vec2 instanceOffsets; +in vec2 instancePixelOffset; +uniform float sizeScale; +uniform vec2 iconsTextureDim; +uniform float sizeMinPixels; +uniform float sizeMaxPixels; +uniform bool billboard; +uniform int sizeUnits; +out float vColorMode; +out vec4 vColor; +out vec2 vTextureCoords; +out vec2 uv; +vec2 rotate_by_angle(vec2 vertex, float angle) { +float angle_radian = angle * PI / 180.0; +float cos_angle = cos(angle_radian); +float sin_angle = sin(angle_radian); +mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle); +return rotationMatrix * vertex; +} +void main(void) { +geometry.worldPosition = instancePositions; +geometry.uv = positions; +geometry.pickingColor = instancePickingColors; +uv = positions; +vec2 iconSize = instanceIconFrames.zw; +float sizePixels = clamp( +project_size_to_pixel(instanceSizes * sizeScale, sizeUnits), +sizeMinPixels, sizeMaxPixels +); +float instanceScale = iconSize.y == 0.0 ? 0.0 : sizePixels / iconSize.y; +vec2 pixelOffset = positions / 2.0 * iconSize + instanceOffsets; +pixelOffset = rotate_by_angle(pixelOffset, instanceAngles) * instanceScale; +pixelOffset += instancePixelOffset; +pixelOffset.y *= -1.0; +if (billboard) { +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +vec3 offset = vec3(pixelOffset, 0.0); +DECKGL_FILTER_SIZE(offset, geometry); +gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); +} else { +vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0); +DECKGL_FILTER_SIZE(offset_common, geometry); +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +} +vTextureCoords = mix( +instanceIconFrames.xy, +instanceIconFrames.xy + iconSize, +(positions.xy + 1.0) / 2.0 +) / iconsTextureDim; +vColor = instanceColors; +DECKGL_FILTER_COLOR(vColor, geometry); +vColorMode = instanceColorModes; +} +`; + +// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer-fragment.glsl.js +var icon_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME icon-layer-fragment-shader +precision highp float; +uniform float opacity; +uniform sampler2D iconsTexture; +uniform float alphaCutoff; +in float vColorMode; +in vec4 vColor; +in vec2 vTextureCoords; +in vec2 uv; +out vec4 fragColor; +void main(void) { +geometry.uv = uv; +vec4 texColor = texture(iconsTexture, vTextureCoords); +vec3 color = mix(texColor.rgb, vColor.rgb, vColorMode); +float a = texColor.a * opacity * vColor.a; +if (a < alphaCutoff) { +discard; +} +fragColor = vec4(color, a); +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/icon-layer/icon-manager.js +var DEFAULT_CANVAS_WIDTH = 1024; +var DEFAULT_BUFFER = 4; +var noop4 = () => { +}; +var DEFAULT_SAMPLER_PARAMETERS = { + minFilter: "linear", + mipmapFilter: "linear", + // LINEAR is the default value but explicitly set it here + magFilter: "linear", + // minimize texture boundary artifacts + addressModeU: "clamp-to-edge", + addressModeV: "clamp-to-edge" +}; +var MISSING_ICON = { + x: 0, + y: 0, + width: 0, + height: 0 +}; +function nextPowOfTwo(number) { + return Math.pow(2, Math.ceil(Math.log2(number))); +} +function resizeImage(ctx2, imageData, maxWidth, maxHeight) { + const resizeRatio = Math.min(maxWidth / imageData.width, maxHeight / imageData.height); + const width = Math.floor(imageData.width * resizeRatio); + const height = Math.floor(imageData.height * resizeRatio); + if (resizeRatio === 1) { + return { data: imageData, width, height }; + } + ctx2.canvas.height = height; + ctx2.canvas.width = width; + ctx2.clearRect(0, 0, width, height); + ctx2.drawImage(imageData, 0, 0, imageData.width, imageData.height, 0, 0, width, height); + return { data: ctx2.canvas, width, height }; +} +function getIconId(icon) { + return icon && (icon.id || icon.url); +} +function resizeTexture(texture, width, height, sampler) { + const { width: oldWidth, height: oldHeight, device } = texture; + const newTexture = device.createTexture({ format: "rgba8unorm", width, height, sampler }); + const commandEncoder = device.createCommandEncoder(); + commandEncoder.copyTextureToTexture({ + source: texture, + destination: newTexture, + width: oldWidth, + height: oldHeight + }); + commandEncoder.finish(); + texture.destroy(); + return newTexture; +} +function buildRowMapping(mapping, columns, yOffset) { + for (let i = 0; i < columns.length; i++) { + const { icon, xOffset } = columns[i]; + const id = getIconId(icon); + mapping[id] = { + ...icon, + x: xOffset, + y: yOffset + }; + } +} +function buildMapping({ icons, buffer, mapping = {}, xOffset = 0, yOffset = 0, rowHeight = 0, canvasWidth }) { + let columns = []; + for (let i = 0; i < icons.length; i++) { + const icon = icons[i]; + const id = getIconId(icon); + if (!mapping[id]) { + const { height, width } = icon; + if (xOffset + width + buffer > canvasWidth) { + buildRowMapping(mapping, columns, yOffset); + xOffset = 0; + yOffset = rowHeight + yOffset + buffer; + rowHeight = 0; + columns = []; + } + columns.push({ + icon, + xOffset + }); + xOffset = xOffset + width + buffer; + rowHeight = Math.max(rowHeight, height); + } + } + if (columns.length > 0) { + buildRowMapping(mapping, columns, yOffset); + } + return { + mapping, + rowHeight, + xOffset, + yOffset, + canvasWidth, + canvasHeight: nextPowOfTwo(rowHeight + yOffset + buffer) + }; +} +function getDiffIcons(data, getIcon, cachedIcons) { + if (!data || !getIcon) { + return null; + } + cachedIcons = cachedIcons || {}; + const icons = {}; + const { iterable, objectInfo } = createIterable(data); + for (const object of iterable) { + objectInfo.index++; + const icon = getIcon(object, objectInfo); + const id = getIconId(icon); + if (!icon) { + throw new Error("Icon is missing."); + } + if (!icon.url) { + throw new Error("Icon url is missing."); + } + if (!icons[id] && (!cachedIcons[id] || icon.url !== cachedIcons[id].url)) { + icons[id] = { ...icon, source: object, sourceIndex: objectInfo.index }; + } + } + return icons; +} +var IconManager = class { + constructor(device, { onUpdate = noop4, onError = noop4 }) { + this._loadOptions = null; + this._texture = null; + this._externalTexture = null; + this._mapping = {}; + this._textureParameters = null; + this._pendingCount = 0; + this._autoPacking = false; + this._xOffset = 0; + this._yOffset = 0; + this._rowHeight = 0; + this._buffer = DEFAULT_BUFFER; + this._canvasWidth = DEFAULT_CANVAS_WIDTH; + this._canvasHeight = 0; + this._canvas = null; + this.device = device; + this.onUpdate = onUpdate; + this.onError = onError; + } + finalize() { + this._texture?.delete(); + } + getTexture() { + return this._texture || this._externalTexture; + } + getIconMapping(icon) { + const id = this._autoPacking ? getIconId(icon) : icon; + return this._mapping[id] || MISSING_ICON; + } + setProps({ loadOptions, autoPacking, iconAtlas, iconMapping, textureParameters }) { + if (loadOptions) { + this._loadOptions = loadOptions; + } + if (autoPacking !== void 0) { + this._autoPacking = autoPacking; + } + if (iconMapping) { + this._mapping = iconMapping; + } + if (iconAtlas) { + this._texture?.delete(); + this._texture = null; + this._externalTexture = iconAtlas; + } + if (textureParameters) { + this._textureParameters = textureParameters; + } + } + get isLoaded() { + return this._pendingCount === 0; + } + packIcons(data, getIcon) { + if (!this._autoPacking || typeof document === "undefined") { + return; + } + const icons = Object.values(getDiffIcons(data, getIcon, this._mapping) || {}); + if (icons.length > 0) { + const { mapping, xOffset, yOffset, rowHeight, canvasHeight } = buildMapping({ + icons, + buffer: this._buffer, + canvasWidth: this._canvasWidth, + mapping: this._mapping, + rowHeight: this._rowHeight, + xOffset: this._xOffset, + yOffset: this._yOffset + }); + this._rowHeight = rowHeight; + this._mapping = mapping; + this._xOffset = xOffset; + this._yOffset = yOffset; + this._canvasHeight = canvasHeight; + if (!this._texture) { + this._texture = this.device.createTexture({ + format: "rgba8unorm", + width: this._canvasWidth, + height: this._canvasHeight, + sampler: this._textureParameters || DEFAULT_SAMPLER_PARAMETERS + }); + } + if (this._texture.height !== this._canvasHeight) { + this._texture = resizeTexture(this._texture, this._canvasWidth, this._canvasHeight, this._textureParameters || DEFAULT_SAMPLER_PARAMETERS); + } + this.onUpdate(); + this._canvas = this._canvas || document.createElement("canvas"); + this._loadIcons(icons); + } + } + _loadIcons(icons) { + const ctx2 = this._canvas.getContext("2d", { + willReadFrequently: true + }); + for (const icon of icons) { + this._pendingCount++; + load(icon.url, this._loadOptions).then((imageData) => { + const id = getIconId(icon); + const iconDef = this._mapping[id]; + const { x, y, width: maxWidth, height: maxHeight } = iconDef; + const { data, width, height } = resizeImage(ctx2, imageData, maxWidth, maxHeight); + this._texture.setSubImageData({ + data, + x: x + (maxWidth - width) / 2, + y: y + (maxHeight - height) / 2, + width, + height + }); + iconDef.width = width; + iconDef.height = height; + this._texture.generateMipmap(); + this.onUpdate(); + }).catch((error) => { + this.onError({ + url: icon.url, + source: icon.source, + sourceIndex: icon.sourceIndex, + loadOptions: this._loadOptions, + error + }); + }).finally(() => { + this._pendingCount--; + }); + } + } +}; + +// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer.js +var DEFAULT_COLOR = [0, 0, 0, 255]; +var defaultProps4 = { + iconAtlas: { type: "image", value: null, async: true }, + iconMapping: { type: "object", value: {}, async: true }, + sizeScale: { type: "number", value: 1, min: 0 }, + billboard: true, + sizeUnits: "pixels", + sizeMinPixels: { type: "number", min: 0, value: 0 }, + // min point radius in pixels + sizeMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, + // max point radius in pixels + alphaCutoff: { type: "number", value: 0.05, min: 0, max: 1 }, + getPosition: { type: "accessor", value: (x) => x.position }, + getIcon: { type: "accessor", value: (x) => x.icon }, + getColor: { type: "accessor", value: DEFAULT_COLOR }, + getSize: { type: "accessor", value: 1 }, + getAngle: { type: "accessor", value: 0 }, + getPixelOffset: { type: "accessor", value: [0, 0] }, + onIconError: { type: "function", value: null, optional: true }, + textureParameters: { type: "object", ignore: true, value: null } +}; +var IconLayer = class extends layer_default { + getShaders() { + return super.getShaders({ vs: icon_layer_vertex_glsl_default, fs: icon_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); + } + initializeState() { + this.state = { + iconManager: new IconManager(this.context.device, { + onUpdate: this._onUpdate.bind(this), + onError: this._onError.bind(this) + }) + }; + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instancePositions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceSizes: { + size: 1, + transition: true, + accessor: "getSize", + defaultValue: 1 + }, + instanceOffsets: { + size: 2, + accessor: "getIcon", + // eslint-disable-next-line @typescript-eslint/unbound-method + transform: this.getInstanceOffset + }, + instanceIconFrames: { + size: 4, + accessor: "getIcon", + // eslint-disable-next-line @typescript-eslint/unbound-method + transform: this.getInstanceIconFrame + }, + instanceColorModes: { + size: 1, + type: "uint8", + accessor: "getIcon", + // eslint-disable-next-line @typescript-eslint/unbound-method + transform: this.getInstanceColorMode + }, + instanceColors: { + size: this.props.colorFormat.length, + type: "unorm8", + transition: true, + accessor: "getColor", + defaultValue: DEFAULT_COLOR + }, + instanceAngles: { + size: 1, + transition: true, + accessor: "getAngle" + }, + instancePixelOffset: { + size: 2, + transition: true, + accessor: "getPixelOffset" + } + }); + } + /* eslint-disable max-statements, complexity */ + updateState(params) { + super.updateState(params); + const { props, oldProps, changeFlags } = params; + const attributeManager = this.getAttributeManager(); + const { iconAtlas, iconMapping, data, getIcon, textureParameters } = props; + const { iconManager } = this.state; + if (typeof iconAtlas === "string") { + return; + } + const prePacked = iconAtlas || this.internalState.isAsyncPropLoading("iconAtlas"); + iconManager.setProps({ + loadOptions: props.loadOptions, + autoPacking: !prePacked, + iconAtlas, + iconMapping: prePacked ? iconMapping : null, + textureParameters + }); + if (prePacked) { + if (oldProps.iconMapping !== props.iconMapping) { + attributeManager.invalidate("getIcon"); + } + } else if (changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getIcon)) { + iconManager.packIcons(data, getIcon); + } + if (changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + attributeManager.invalidateAll(); + } + } + /* eslint-enable max-statements, complexity */ + get isLoaded() { + return super.isLoaded && this.state.iconManager.isLoaded; + } + finalizeState(context) { + super.finalizeState(context); + this.state.iconManager.finalize(); + } + draw({ uniforms }) { + const { sizeScale, sizeMinPixels, sizeMaxPixels, sizeUnits, billboard, alphaCutoff } = this.props; + const { iconManager } = this.state; + const iconsTexture = iconManager.getTexture(); + if (iconsTexture) { + const model = this.state.model; + model.setBindings({ iconsTexture }); + model.setUniforms(uniforms); + model.setUniforms({ + iconsTextureDim: [iconsTexture.width, iconsTexture.height], + sizeUnits: UNIT[sizeUnits], + sizeScale, + sizeMinPixels, + sizeMaxPixels, + billboard, + alphaCutoff + }); + model.draw(this.context.renderPass); + } + } + _getModel() { + const positions = [-1, -1, 1, -1, -1, 1, 1, 1]; + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + geometry: new Geometry({ + topology: "triangle-strip", + attributes: { + // The size must be explicitly passed here otherwise luma.gl + // will default to assuming that positions are 3D (x,y,z) + positions: { + size: 2, + value: new Float32Array(positions) + } + } + }), + isInstanced: true + }); + } + _onUpdate() { + this.setNeedsRedraw(); + } + _onError(evt) { + const onIconError = this.getCurrentLayer()?.props.onIconError; + if (onIconError) { + onIconError(evt); + } else { + log_default.error(evt.error.message)(); + } + } + getInstanceOffset(icon) { + const { width, height, anchorX = width / 2, anchorY = height / 2 } = this.state.iconManager.getIconMapping(icon); + return [width / 2 - anchorX, height / 2 - anchorY]; + } + getInstanceColorMode(icon) { + const mapping = this.state.iconManager.getIconMapping(icon); + return mapping.mask ? 1 : 0; + } + getInstanceIconFrame(icon) { + const { x, y, width, height } = this.state.iconManager.getIconMapping(icon); + return [x, y, width, height]; + } +}; +IconLayer.defaultProps = defaultProps4; +IconLayer.layerName = "IconLayer"; +var icon_layer_default = IconLayer; + +// node_modules/@deck.gl/layers/dist/line-layer/line-layer-vertex.glsl.js +var line_layer_vertex_glsl_default = `#version 300 es +#define SHADER_NAME line-layer-vertex-shader +in vec3 positions; +in vec3 instanceSourcePositions; +in vec3 instanceTargetPositions; +in vec3 instanceSourcePositions64Low; +in vec3 instanceTargetPositions64Low; +in vec4 instanceColors; +in vec3 instancePickingColors; +in float instanceWidths; +uniform float opacity; +uniform float widthScale; +uniform float widthMinPixels; +uniform float widthMaxPixels; +uniform float useShortestPath; +uniform int widthUnits; +out vec4 vColor; +out vec2 uv; +vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) { +vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize); +dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x); +return dir_screenspace * offset_direction * width / 2.0; +} +vec3 splitLine(vec3 a, vec3 b, float x) { +float t = (x - a.x) / (b.x - a.x); +return vec3(x, mix(a.yz, b.yz, t)); +} +void main(void) { +geometry.worldPosition = instanceSourcePositions; +geometry.worldPositionAlt = instanceTargetPositions; +vec3 source_world = instanceSourcePositions; +vec3 target_world = instanceTargetPositions; +vec3 source_world_64low = instanceSourcePositions64Low; +vec3 target_world_64low = instanceTargetPositions64Low; +if (useShortestPath > 0.5 || useShortestPath < -0.5) { +source_world.x = mod(source_world.x + 180., 360.0) - 180.; +target_world.x = mod(target_world.x + 180., 360.0) - 180.; +float deltaLng = target_world.x - source_world.x; +if (deltaLng * useShortestPath > 180.) { +source_world.x += 360. * useShortestPath; +source_world = splitLine(source_world, target_world, 180. * useShortestPath); +source_world_64low = vec3(0.0); +} else if (deltaLng * useShortestPath < -180.) { +target_world.x += 360. * useShortestPath; +target_world = splitLine(source_world, target_world, 180. * useShortestPath); +target_world_64low = vec3(0.0); +} else if (useShortestPath < 0.) { +gl_Position = vec4(0.); +return; +} +} +vec4 source_commonspace; +vec4 target_commonspace; +vec4 source = project_position_to_clipspace(source_world, source_world_64low, vec3(0.), source_commonspace); +vec4 target = project_position_to_clipspace(target_world, target_world_64low, vec3(0.), target_commonspace); +float segmentIndex = positions.x; +vec4 p = mix(source, target, segmentIndex); +geometry.position = mix(source_commonspace, target_commonspace, segmentIndex); +uv = positions.xy; +geometry.uv = uv; +geometry.pickingColor = instancePickingColors; +float widthPixels = clamp( +project_size_to_pixel(instanceWidths * widthScale, widthUnits), +widthMinPixels, widthMaxPixels +); +vec3 offset = vec3( +getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels), +0.0); +DECKGL_FILTER_SIZE(offset, geometry); +DECKGL_FILTER_GL_POSITION(p, geometry); +gl_Position = p + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0); +vColor = vec4(instanceColors.rgb, instanceColors.a * opacity); +DECKGL_FILTER_COLOR(vColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/line-layer/line-layer-fragment.glsl.js +var line_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME line-layer-fragment-shader +precision highp float; +in vec4 vColor; +in vec2 uv; +out vec4 fragColor; +void main(void) { +geometry.uv = uv; +fragColor = vColor; +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/line-layer/line-layer.js +var DEFAULT_COLOR2 = [0, 0, 0, 255]; +var defaultProps5 = { + getSourcePosition: { type: "accessor", value: (x) => x.sourcePosition }, + getTargetPosition: { type: "accessor", value: (x) => x.targetPosition }, + getColor: { type: "accessor", value: DEFAULT_COLOR2 }, + getWidth: { type: "accessor", value: 1 }, + widthUnits: "pixels", + widthScale: { type: "number", value: 1, min: 0 }, + widthMinPixels: { type: "number", value: 0, min: 0 }, + widthMaxPixels: { type: "number", value: Number.MAX_SAFE_INTEGER, min: 0 } +}; +var LineLayer = class extends layer_default { + getBounds() { + return this.getAttributeManager()?.getBounds([ + "instanceSourcePositions", + "instanceTargetPositions" + ]); + } + getShaders() { + return super.getShaders({ vs: line_layer_vertex_glsl_default, fs: line_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); + } + // This layer has its own wrapLongitude logic + get wrapLongitude() { + return false; + } + initializeState() { + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instanceSourcePositions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + transition: true, + accessor: "getSourcePosition" + }, + instanceTargetPositions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + transition: true, + accessor: "getTargetPosition" + }, + instanceColors: { + size: this.props.colorFormat.length, + type: "unorm8", + transition: true, + accessor: "getColor", + defaultValue: [0, 0, 0, 255] + }, + instanceWidths: { + size: 1, + transition: true, + accessor: "getWidth", + defaultValue: 1 + } + }); + } + updateState(params) { + super.updateState(params); + if (params.changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + this.getAttributeManager().invalidateAll(); + } + } + draw({ uniforms }) { + const { widthUnits, widthScale, widthMinPixels, widthMaxPixels, wrapLongitude } = this.props; + const model = this.state.model; + model.setUniforms(uniforms); + model.setUniforms({ + widthUnits: UNIT[widthUnits], + widthScale, + widthMinPixels, + widthMaxPixels, + useShortestPath: wrapLongitude ? 1 : 0 + }); + model.draw(this.context.renderPass); + if (wrapLongitude) { + model.setUniforms({ + useShortestPath: -1 + }); + model.draw(this.context.renderPass); + } + } + _getModel() { + const positions = [0, -1, 0, 0, 1, 0, 1, -1, 0, 1, 1, 0]; + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + geometry: new Geometry({ + topology: "triangle-strip", + attributes: { + positions: { size: 3, value: new Float32Array(positions) } + } + }), + isInstanced: true + }); + } +}; +LineLayer.layerName = "LineLayer"; +LineLayer.defaultProps = defaultProps5; +var line_layer_default = LineLayer; + +// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer-vertex.glsl.js +var scatterplot_layer_vertex_glsl_default = `#version 300 es +#define SHADER_NAME scatterplot-layer-vertex-shader +in vec3 positions; +in vec3 instancePositions; +in vec3 instancePositions64Low; +in float instanceRadius; +in float instanceLineWidths; +in vec4 instanceFillColors; +in vec4 instanceLineColors; +in vec3 instancePickingColors; +uniform float opacity; +uniform float radiusScale; +uniform float radiusMinPixels; +uniform float radiusMaxPixels; +uniform float lineWidthScale; +uniform float lineWidthMinPixels; +uniform float lineWidthMaxPixels; +uniform float stroked; +uniform bool filled; +uniform bool antialiasing; +uniform bool billboard; +uniform int radiusUnits; +uniform int lineWidthUnits; +out vec4 vFillColor; +out vec4 vLineColor; +out vec2 unitPosition; +out float innerUnitRadius; +out float outerRadiusPixels; +void main(void) { +geometry.worldPosition = instancePositions; +outerRadiusPixels = clamp( +project_size_to_pixel(radiusScale * instanceRadius, radiusUnits), +radiusMinPixels, radiusMaxPixels +); +float lineWidthPixels = clamp( +project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits), +lineWidthMinPixels, lineWidthMaxPixels +); +outerRadiusPixels += stroked * lineWidthPixels / 2.0; +float edgePadding = antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0; +unitPosition = edgePadding * positions.xy; +geometry.uv = unitPosition; +geometry.pickingColor = instancePickingColors; +innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels; +if (billboard) { +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +vec3 offset = edgePadding * positions * outerRadiusPixels; +DECKGL_FILTER_SIZE(offset, geometry); +gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); +} else { +vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels); +DECKGL_FILTER_SIZE(offset, geometry); +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +} +vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity); +DECKGL_FILTER_COLOR(vFillColor, geometry); +vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); +DECKGL_FILTER_COLOR(vLineColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer-fragment.glsl.js +var scatterplot_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME scatterplot-layer-fragment-shader +precision highp float; +uniform bool filled; +uniform float stroked; +uniform bool antialiasing; +in vec4 vFillColor; +in vec4 vLineColor; +in vec2 unitPosition; +in float innerUnitRadius; +in float outerRadiusPixels; +out vec4 fragColor; +void main(void) { +geometry.uv = unitPosition; +float distToCenter = length(unitPosition) * outerRadiusPixels; +float inCircle = antialiasing ? +smoothedge(distToCenter, outerRadiusPixels) : +step(distToCenter, outerRadiusPixels); +if (inCircle == 0.0) { +discard; +} +if (stroked > 0.5) { +float isLine = antialiasing ? +smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) : +step(innerUnitRadius * outerRadiusPixels, distToCenter); +if (filled) { +fragColor = mix(vFillColor, vLineColor, isLine); +} else { +if (isLine == 0.0) { +discard; +} +fragColor = vec4(vLineColor.rgb, vLineColor.a * isLine); +} +} else if (!filled) { +discard; +} else { +fragColor = vFillColor; +} +fragColor.a *= inCircle; +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer.js +var DEFAULT_COLOR3 = [0, 0, 0, 255]; +var defaultProps6 = { + radiusUnits: "meters", + radiusScale: { type: "number", min: 0, value: 1 }, + radiusMinPixels: { type: "number", min: 0, value: 0 }, + // min point radius in pixels + radiusMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, + // max point radius in pixels + lineWidthUnits: "meters", + lineWidthScale: { type: "number", min: 0, value: 1 }, + lineWidthMinPixels: { type: "number", min: 0, value: 0 }, + lineWidthMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, + stroked: false, + filled: true, + billboard: false, + antialiasing: true, + getPosition: { type: "accessor", value: (x) => x.position }, + getRadius: { type: "accessor", value: 1 }, + getFillColor: { type: "accessor", value: DEFAULT_COLOR3 }, + getLineColor: { type: "accessor", value: DEFAULT_COLOR3 }, + getLineWidth: { type: "accessor", value: 1 }, + // deprecated + strokeWidth: { deprecatedFor: "getLineWidth" }, + outline: { deprecatedFor: "stroked" }, + getColor: { deprecatedFor: ["getFillColor", "getLineColor"] } +}; +var ScatterplotLayer = class extends layer_default { + getShaders() { + return super.getShaders({ vs: scatterplot_layer_vertex_glsl_default, fs: scatterplot_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); + } + initializeState() { + this.getAttributeManager().addInstanced({ + instancePositions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceRadius: { + size: 1, + transition: true, + accessor: "getRadius", + defaultValue: 1 + }, + instanceFillColors: { + size: this.props.colorFormat.length, + transition: true, + type: "unorm8", + accessor: "getFillColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineColors: { + size: this.props.colorFormat.length, + transition: true, + type: "unorm8", + accessor: "getLineColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineWidths: { + size: 1, + transition: true, + accessor: "getLineWidth", + defaultValue: 1 + } + }); + } + updateState(params) { + super.updateState(params); + if (params.changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + this.getAttributeManager().invalidateAll(); + } + } + draw({ uniforms }) { + const { radiusUnits, radiusScale, radiusMinPixels, radiusMaxPixels, stroked, filled, billboard, antialiasing, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels } = this.props; + const model = this.state.model; + model.setUniforms(uniforms); + model.setUniforms({ + stroked: stroked ? 1 : 0, + filled, + billboard, + antialiasing, + radiusUnits: UNIT[radiusUnits], + radiusScale, + radiusMinPixels, + radiusMaxPixels, + lineWidthUnits: UNIT[lineWidthUnits], + lineWidthScale, + lineWidthMinPixels, + lineWidthMaxPixels + }); + model.draw(this.context.renderPass); + } + _getModel() { + const positions = [-1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0]; + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + geometry: new Geometry({ + topology: "triangle-strip", + attributes: { + positions: { size: 3, value: new Float32Array(positions) } + } + }), + isInstanced: true + }); + } +}; +ScatterplotLayer.defaultProps = defaultProps6; +ScatterplotLayer.layerName = "ScatterplotLayer"; +var scatterplot_layer_default = ScatterplotLayer; + +// node_modules/@math.gl/polygon/dist/polygon-utils.js +var WINDING = { + CLOCKWISE: 1, + COUNTER_CLOCKWISE: -1 +}; +function modifyPolygonWindingDirection(points, direction, options = {}) { + const windingDirection = getPolygonWindingDirection(points, options); + if (windingDirection !== direction) { + reversePolygon(points, options); + return true; + } + return false; +} +function getPolygonWindingDirection(points, options = {}) { + return Math.sign(getPolygonSignedArea(points, options)); +} +var DimIndex = { + x: 0, + y: 1, + z: 2 +}; +function getPolygonSignedArea(points, options = {}) { + const { start = 0, end = points.length, plane = "xy" } = options; + const dim = options.size || 2; + let area = 0; + const i0 = DimIndex[plane[0]]; + const i1 = DimIndex[plane[1]]; + for (let i = start, j = end - dim; i < end; i += dim) { + area += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]); + j = i; + } + return area / 2; +} +function reversePolygon(points, options) { + const { start = 0, end = points.length, size = 2 } = options; + const numPoints = (end - start) / size; + const numSwaps = Math.floor(numPoints / 2); + for (let i = 0; i < numSwaps; ++i) { + const b1 = start + i * size; + const b2 = start + (numPoints - 1 - i) * size; + for (let j = 0; j < size; ++j) { + const tmp = points[b1 + j]; + points[b1 + j] = points[b2 + j]; + points[b2 + j] = tmp; + } + } +} + +// node_modules/@math.gl/polygon/dist/utils.js +function push(target, source) { + const size = source.length; + const startIndex = target.length; + if (startIndex > 0) { + let isDuplicate = true; + for (let i = 0; i < size; i++) { + if (target[startIndex - size + i] !== source[i]) { + isDuplicate = false; + break; + } + } + if (isDuplicate) { + return false; + } + } + for (let i = 0; i < size; i++) { + target[startIndex + i] = source[i]; + } + return true; +} +function copy9(target, source) { + const size = source.length; + for (let i = 0; i < size; i++) { + target[i] = source[i]; + } +} +function getPointAtIndex(positions, index2, size, offset, out = []) { + const startI = offset + index2 * size; + for (let i = 0; i < size; i++) { + out[i] = positions[startI + i]; + } + return out; +} + +// node_modules/@math.gl/polygon/dist/lineclip.js +function intersect(a, b, edge, bbox, out = []) { + let t; + let snap; + if (edge & 8) { + t = (bbox[3] - a[1]) / (b[1] - a[1]); + snap = 3; + } else if (edge & 4) { + t = (bbox[1] - a[1]) / (b[1] - a[1]); + snap = 1; + } else if (edge & 2) { + t = (bbox[2] - a[0]) / (b[0] - a[0]); + snap = 2; + } else if (edge & 1) { + t = (bbox[0] - a[0]) / (b[0] - a[0]); + snap = 0; + } else { + return null; + } + for (let i = 0; i < a.length; i++) { + out[i] = (snap & 1) === i ? bbox[snap] : t * (b[i] - a[i]) + a[i]; + } + return out; +} +function bitCode(p, bbox) { + let code = 0; + if (p[0] < bbox[0]) + code |= 1; + else if (p[0] > bbox[2]) + code |= 2; + if (p[1] < bbox[1]) + code |= 4; + else if (p[1] > bbox[3]) + code |= 8; + return code; +} + +// node_modules/@math.gl/polygon/dist/cut-by-grid.js +function cutPolylineByGrid(positions, options) { + const { size = 2, broken = false, gridResolution = 10, gridOffset = [0, 0], startIndex = 0, endIndex = positions.length } = options || {}; + const numPoints = (endIndex - startIndex) / size; + let part = []; + const result = [part]; + const a = getPointAtIndex(positions, 0, size, startIndex); + let b; + let codeB; + const cell = getGridCell(a, gridResolution, gridOffset, []); + const scratchPoint = []; + push(part, a); + for (let i = 1; i < numPoints; i++) { + b = getPointAtIndex(positions, i, size, startIndex, b); + codeB = bitCode(b, cell); + while (codeB) { + intersect(a, b, codeB, cell, scratchPoint); + const codeAlt = bitCode(scratchPoint, cell); + if (codeAlt) { + intersect(a, scratchPoint, codeAlt, cell, scratchPoint); + codeB = codeAlt; + } + push(part, scratchPoint); + copy9(a, scratchPoint); + moveToNeighborCell(cell, gridResolution, codeB); + if (broken && part.length > size) { + part = []; + result.push(part); + push(part, a); + } + codeB = bitCode(b, cell); + } + push(part, b); + copy9(a, b); + } + return broken ? result : result[0]; +} +var TYPE_INSIDE = 0; +var TYPE_BORDER = 1; +function cutPolygonByGrid(positions, holeIndices = null, options) { + if (!positions.length) { + return []; + } + const { size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false } = options || {}; + const result = []; + const queue = [ + { + pos: positions, + types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null, + holes: holeIndices || [] + } + ]; + const bbox = [[], []]; + let cell = []; + while (queue.length) { + const { pos, types, holes } = queue.shift(); + getBoundingBox(pos, size, holes[0] || pos.length, bbox); + cell = getGridCell(bbox[0], gridResolution, gridOffset, cell); + const code = bitCode(bbox[1], cell); + if (code) { + let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code); + const polygonLow = { pos: parts[0].pos, types: parts[0].types, holes: [] }; + const polygonHigh = { pos: parts[1].pos, types: parts[1].types, holes: [] }; + queue.push(polygonLow, polygonHigh); + for (let i = 0; i < holes.length; i++) { + parts = bisectPolygon(pos, types, size, holes[i], holes[i + 1] || pos.length, cell, code); + if (parts[0]) { + polygonLow.holes.push(polygonLow.pos.length); + polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos); + if (edgeTypes) { + polygonLow.types = concatInPlace(polygonLow.types, parts[0].types); + } + } + if (parts[1]) { + polygonHigh.holes.push(polygonHigh.pos.length); + polygonHigh.pos = concatInPlace(polygonHigh.pos, parts[1].pos); + if (edgeTypes) { + polygonHigh.types = concatInPlace(polygonHigh.types, parts[1].types); + } + } + } + } else { + const polygon = { positions: pos }; + if (edgeTypes) { + polygon.edgeTypes = types; + } + if (holes.length) { + polygon.holeIndices = holes; + } + result.push(polygon); + } + } + return result; +} +function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, edge) { + const numPoints = (endIndex - startIndex) / size; + const resultLow = []; + const resultHigh = []; + const typesLow = []; + const typesHigh = []; + const scratchPoint = []; + let p; + let side; + let type; + const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex); + let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]); + let prevType = edgeTypes && edgeTypes[numPoints - 1]; + let lowPointCount = 0; + let highPointCount = 0; + for (let i = 0; i < numPoints; i++) { + p = getPointAtIndex(positions, i, size, startIndex, p); + side = Math.sign(edge & 8 ? p[1] - bbox[3] : p[0] - bbox[2]); + type = edgeTypes && edgeTypes[startIndex / size + i]; + if (side && prevSide && prevSide !== side) { + intersect(prev, p, edge, bbox, scratchPoint); + push(resultLow, scratchPoint) && typesLow.push(prevType); + push(resultHigh, scratchPoint) && typesHigh.push(prevType); + } + if (side <= 0) { + push(resultLow, p) && typesLow.push(type); + lowPointCount -= side; + } else if (typesLow.length) { + typesLow[typesLow.length - 1] = TYPE_INSIDE; + } + if (side >= 0) { + push(resultHigh, p) && typesHigh.push(type); + highPointCount += side; + } else if (typesHigh.length) { + typesHigh[typesHigh.length - 1] = TYPE_INSIDE; + } + copy9(prev, p); + prevSide = side; + prevType = type; + } + return [ + lowPointCount ? { pos: resultLow, types: edgeTypes && typesLow } : null, + highPointCount ? { pos: resultHigh, types: edgeTypes && typesHigh } : null + ]; +} +function getGridCell(p, gridResolution, gridOffset, out) { + const left = Math.floor((p[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0]; + const bottom = Math.floor((p[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1]; + out[0] = left; + out[1] = bottom; + out[2] = left + gridResolution; + out[3] = bottom + gridResolution; + return out; +} +function moveToNeighborCell(cell, gridResolution, edge) { + if (edge & 8) { + cell[1] += gridResolution; + cell[3] += gridResolution; + } else if (edge & 4) { + cell[1] -= gridResolution; + cell[3] -= gridResolution; + } else if (edge & 2) { + cell[0] += gridResolution; + cell[2] += gridResolution; + } else if (edge & 1) { + cell[0] -= gridResolution; + cell[2] -= gridResolution; + } +} +function getBoundingBox(positions, size, endIndex, out) { + let minX = Infinity; + let maxX = -Infinity; + let minY = Infinity; + let maxY = -Infinity; + for (let i = 0; i < endIndex; i += size) { + const x = positions[i]; + const y = positions[i + 1]; + minX = x < minX ? x : minX; + maxX = x > maxX ? x : maxX; + minY = y < minY ? y : minY; + maxY = y > maxY ? y : maxY; + } + out[0][0] = minX; + out[0][1] = minY; + out[1][0] = maxX; + out[1][1] = maxY; + return out; +} +function concatInPlace(arr1, arr2) { + for (let i = 0; i < arr2.length; i++) { + arr1.push(arr2[i]); + } + return arr1; +} + +// node_modules/@math.gl/polygon/dist/cut-by-mercator-bounds.js +var DEFAULT_MAX_LATITUDE = 85.051129; +function cutPolylineByMercatorBounds(positions, options) { + const { size = 2, startIndex = 0, endIndex = positions.length, normalize: normalize11 = true } = options || {}; + const newPositions = positions.slice(startIndex, endIndex); + wrapLongitudesForShortestPath(newPositions, size, 0, endIndex - startIndex); + const parts = cutPolylineByGrid(newPositions, { + size, + broken: true, + gridResolution: 360, + gridOffset: [-180, -180] + }); + if (normalize11) { + for (const part of parts) { + shiftLongitudesIntoRange(part, size); + } + } + return parts; +} +function cutPolygonByMercatorBounds(positions, holeIndices = null, options) { + const { size = 2, normalize: normalize11 = true, edgeTypes = false } = options || {}; + holeIndices = holeIndices || []; + const newPositions = []; + const newHoleIndices = []; + let srcStartIndex = 0; + let targetIndex = 0; + for (let ringIndex = 0; ringIndex <= holeIndices.length; ringIndex++) { + const srcEndIndex = holeIndices[ringIndex] || positions.length; + const targetStartIndex = targetIndex; + const splitIndex = findSplitIndex(positions, size, srcStartIndex, srcEndIndex); + for (let i = splitIndex; i < srcEndIndex; i++) { + newPositions[targetIndex++] = positions[i]; + } + for (let i = srcStartIndex; i < splitIndex; i++) { + newPositions[targetIndex++] = positions[i]; + } + wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex); + insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options?.maxLatitude); + srcStartIndex = srcEndIndex; + newHoleIndices[ringIndex] = targetIndex; + } + newHoleIndices.pop(); + const parts = cutPolygonByGrid(newPositions, newHoleIndices, { + size, + gridResolution: 360, + gridOffset: [-180, -180], + edgeTypes + }); + if (normalize11) { + for (const part of parts) { + shiftLongitudesIntoRange(part.positions, size); + } + } + return parts; +} +function findSplitIndex(positions, size, startIndex, endIndex) { + let maxLat = -1; + let pointIndex = -1; + for (let i = startIndex + 1; i < endIndex; i += size) { + const lat = Math.abs(positions[i]); + if (lat > maxLat) { + maxLat = lat; + pointIndex = i - 1; + } + } + return pointIndex; +} +function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) { + const firstLng = positions[startIndex]; + const lastLng = positions[endIndex - size]; + if (Math.abs(firstLng - lastLng) > 180) { + const p = getPointAtIndex(positions, 0, size, startIndex); + p[0] += Math.round((lastLng - firstLng) / 360) * 360; + push(positions, p); + p[1] = Math.sign(p[1]) * maxLatitude; + push(positions, p); + p[0] = firstLng; + push(positions, p); + } +} +function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) { + let prevLng = positions[0]; + let lng; + for (let i = startIndex; i < endIndex; i += size) { + lng = positions[i]; + const delta = lng - prevLng; + if (delta > 180 || delta < -180) { + lng -= Math.round(delta / 360) * 360; + } + positions[i] = prevLng = lng; + } +} +function shiftLongitudesIntoRange(positions, size) { + let refLng; + const pointCount = positions.length / size; + for (let i = 0; i < pointCount; i++) { + refLng = positions[i * size]; + if ((refLng + 180) % 360 !== 0) { + break; + } + } + const delta = -Math.round(refLng / 360) * 360; + if (delta === 0) { + return; + } + for (let i = 0; i < pointCount; i++) { + positions[i * size] += delta; + } +} + +// node_modules/@deck.gl/layers/dist/path-layer/path.js +function normalizePath(path, size, gridResolution, wrapLongitude) { + let flatPath; + if (Array.isArray(path[0])) { + const length10 = path.length * size; + flatPath = new Array(length10); + for (let i = 0; i < path.length; i++) { + for (let j = 0; j < size; j++) { + flatPath[i * size + j] = path[i][j] || 0; + } + } + } else { + flatPath = path; + } + if (gridResolution) { + return cutPolylineByGrid(flatPath, { size, gridResolution }); + } + if (wrapLongitude) { + return cutPolylineByMercatorBounds(flatPath, { size }); + } + return flatPath; +} + +// node_modules/@deck.gl/layers/dist/path-layer/path-tesselator.js +var START_CAP = 1; +var END_CAP = 2; +var INVALID = 4; +var PathTesselator = class extends Tesselator { + constructor(opts) { + super({ + ...opts, + attributes: { + // Padding covers shaderAttributes for last segment in largest case fp64 + // additional vertex + hi & low parts, 3 * 6 + positions: { + size: 3, + padding: 18, + initialize: true, + type: opts.fp64 ? Float64Array : Float32Array + }, + segmentTypes: { size: 1, type: Uint8ClampedArray } + } + }); + } + /** Get packed attribute by name */ + get(attributeName) { + return this.attributes[attributeName]; + } + /* Implement base Tesselator interface */ + getGeometryFromBuffer(buffer) { + if (this.normalize) { + return super.getGeometryFromBuffer(buffer); + } + return null; + } + /* Implement base Tesselator interface */ + normalizeGeometry(path) { + if (this.normalize) { + return normalizePath(path, this.positionSize, this.opts.resolution, this.opts.wrapLongitude); + } + return path; + } + /* Implement base Tesselator interface */ + getGeometrySize(path) { + if (isCut(path)) { + let size = 0; + for (const subPath of path) { + size += this.getGeometrySize(subPath); + } + return size; + } + const numPoints = this.getPathLength(path); + if (numPoints < 2) { + return 0; + } + if (this.isClosed(path)) { + return numPoints < 3 ? 0 : numPoints + 2; + } + return numPoints; + } + /* Implement base Tesselator interface */ + updateGeometryAttributes(path, context) { + if (context.geometrySize === 0) { + return; + } + if (path && isCut(path)) { + for (const subPath of path) { + const geometrySize = this.getGeometrySize(subPath); + context.geometrySize = geometrySize; + this.updateGeometryAttributes(subPath, context); + context.vertexStart += geometrySize; + } + } else { + this._updateSegmentTypes(path, context); + this._updatePositions(path, context); + } + } + _updateSegmentTypes(path, context) { + const segmentTypes = this.attributes.segmentTypes; + const isPathClosed = path ? this.isClosed(path) : false; + const { vertexStart, geometrySize } = context; + segmentTypes.fill(0, vertexStart, vertexStart + geometrySize); + if (isPathClosed) { + segmentTypes[vertexStart] = INVALID; + segmentTypes[vertexStart + geometrySize - 2] = INVALID; + } else { + segmentTypes[vertexStart] += START_CAP; + segmentTypes[vertexStart + geometrySize - 2] += END_CAP; + } + segmentTypes[vertexStart + geometrySize - 1] = INVALID; + } + _updatePositions(path, context) { + const { positions } = this.attributes; + if (!positions || !path) { + return; + } + const { vertexStart, geometrySize } = context; + const p = new Array(3); + for (let i = vertexStart, ptIndex = 0; ptIndex < geometrySize; i++, ptIndex++) { + this.getPointOnPath(path, ptIndex, p); + positions[i * 3] = p[0]; + positions[i * 3 + 1] = p[1]; + positions[i * 3 + 2] = p[2]; + } + } + // Utilities + /** Returns the number of points in the path */ + getPathLength(path) { + return path.length / this.positionSize; + } + /** Returns a point on the path at the specified index */ + getPointOnPath(path, index2, target = []) { + const { positionSize } = this; + if (index2 * positionSize >= path.length) { + index2 += 1 - path.length / positionSize; + } + const i = index2 * positionSize; + target[0] = path[i]; + target[1] = path[i + 1]; + target[2] = positionSize === 3 && path[i + 2] || 0; + return target; + } + // Returns true if the first and last points are identical + isClosed(path) { + if (!this.normalize) { + return Boolean(this.opts.loop); + } + const { positionSize } = this; + const lastPointIndex = path.length - positionSize; + return path[0] === path[lastPointIndex] && path[1] === path[lastPointIndex + 1] && (positionSize === 2 || path[2] === path[lastPointIndex + 2]); + } +}; +function isCut(path) { + return Array.isArray(path[0]); +} + +// node_modules/@deck.gl/layers/dist/path-layer/path-layer-vertex.glsl.js +var path_layer_vertex_glsl_default = `#version 300 es +#define SHADER_NAME path-layer-vertex-shader +in vec2 positions; +in float instanceTypes; +in vec3 instanceStartPositions; +in vec3 instanceEndPositions; +in vec3 instanceLeftPositions; +in vec3 instanceRightPositions; +in vec3 instanceLeftPositions64Low; +in vec3 instanceStartPositions64Low; +in vec3 instanceEndPositions64Low; +in vec3 instanceRightPositions64Low; +in float instanceStrokeWidths; +in vec4 instanceColors; +in vec3 instancePickingColors; +uniform float widthScale; +uniform float widthMinPixels; +uniform float widthMaxPixels; +uniform float jointType; +uniform float capType; +uniform float miterLimit; +uniform bool billboard; +uniform int widthUnits; +uniform float opacity; +out vec4 vColor; +out vec2 vCornerOffset; +out float vMiterLength; +out vec2 vPathPosition; +out float vPathLength; +out float vJointType; +const float EPSILON = 0.001; +const vec3 ZERO_OFFSET = vec3(0.0); +float flipIfTrue(bool flag) { +return -(float(flag) * 2. - 1.); +} +vec3 getLineJoinOffset( +vec3 prevPoint, vec3 currPoint, vec3 nextPoint, +vec2 width +) { +bool isEnd = positions.x > 0.0; +float sideOfPath = positions.y; +float isJoint = float(sideOfPath == 0.0); +vec3 deltaA3 = (currPoint - prevPoint); +vec3 deltaB3 = (nextPoint - currPoint); +mat3 rotationMatrix; +bool needsRotation = !billboard && project_needs_rotation(currPoint, rotationMatrix); +if (needsRotation) { +deltaA3 = deltaA3 * rotationMatrix; +deltaB3 = deltaB3 * rotationMatrix; +} +vec2 deltaA = deltaA3.xy / width; +vec2 deltaB = deltaB3.xy / width; +float lenA = length(deltaA); +float lenB = length(deltaB); +vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0); +vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0); +vec2 perpA = vec2(-dirA.y, dirA.x); +vec2 perpB = vec2(-dirB.y, dirB.x); +vec2 tangent = dirA + dirB; +tangent = length(tangent) > 0. ? normalize(tangent) : perpA; +vec2 miterVec = vec2(-tangent.y, tangent.x); +vec2 dir = isEnd ? dirA : dirB; +vec2 perp = isEnd ? perpA : perpB; +float L = isEnd ? lenA : lenB; +float sinHalfA = abs(dot(miterVec, perp)); +float cosHalfA = abs(dot(dirA, miterVec)); +float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x); +float cornerPosition = sideOfPath * turnDirection; +float miterSize = 1.0 / max(sinHalfA, EPSILON); +miterSize = mix( +min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)), +miterSize, +step(0.0, cornerPosition) +); +vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition)) +* (sideOfPath + isJoint * turnDirection); +bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0)); +bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0)); +bool isCap = isStartCap || isEndCap; +if (isCap) { +offsetVec = mix(perp * sideOfPath, dir * capType * 4.0 * flipIfTrue(isStartCap), isJoint); +vJointType = capType; +} else { +vJointType = jointType; +} +vPathLength = L; +vCornerOffset = offsetVec; +vMiterLength = dot(vCornerOffset, miterVec * turnDirection); +vMiterLength = isCap ? isJoint : vMiterLength; +vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd); +vPathPosition = vec2( +dot(offsetFromStartOfPath, perp), +dot(offsetFromStartOfPath, dir) +); +geometry.uv = vPathPosition; +float isValid = step(instanceTypes, 3.5); +vec3 offset = vec3(offsetVec * width * isValid, 0.0); +if (needsRotation) { +offset = rotationMatrix * offset; +} +return offset; +} +void clipLine(inout vec4 position, vec4 refPosition) { +if (position.w < EPSILON) { +float r = (EPSILON - refPosition.w) / (position.w - refPosition.w); +position = refPosition + (position - refPosition) * r; +} +} +void main() { +geometry.pickingColor = instancePickingColors; +vColor = vec4(instanceColors.rgb, instanceColors.a * opacity); +float isEnd = positions.x; +vec3 prevPosition = mix(instanceLeftPositions, instanceStartPositions, isEnd); +vec3 prevPosition64Low = mix(instanceLeftPositions64Low, instanceStartPositions64Low, isEnd); +vec3 currPosition = mix(instanceStartPositions, instanceEndPositions, isEnd); +vec3 currPosition64Low = mix(instanceStartPositions64Low, instanceEndPositions64Low, isEnd); +vec3 nextPosition = mix(instanceEndPositions, instanceRightPositions, isEnd); +vec3 nextPosition64Low = mix(instanceEndPositions64Low, instanceRightPositions64Low, isEnd); +geometry.worldPosition = currPosition; +vec2 widthPixels = vec2(clamp( +project_size_to_pixel(instanceStrokeWidths * widthScale, widthUnits), +widthMinPixels, widthMaxPixels) / 2.0); +vec3 width; +if (billboard) { +vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET); +vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position); +vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET); +clipLine(prevPositionScreen, currPositionScreen); +clipLine(nextPositionScreen, currPositionScreen); +clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd)); +width = vec3(widthPixels, 0.0); +DECKGL_FILTER_SIZE(width, geometry); +vec3 offset = getLineJoinOffset( +prevPositionScreen.xyz / prevPositionScreen.w, +currPositionScreen.xyz / currPositionScreen.w, +nextPositionScreen.xyz / nextPositionScreen.w, +project_pixel_size_to_clipspace(width.xy) +); +DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry); +gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w); +} else { +prevPosition = project_position(prevPosition, prevPosition64Low); +currPosition = project_position(currPosition, currPosition64Low); +nextPosition = project_position(nextPosition, nextPosition64Low); +width = vec3(project_pixel_size(widthPixels), 0.0); +DECKGL_FILTER_SIZE(width, geometry); +vec3 offset = getLineJoinOffset(prevPosition, currPosition, nextPosition, width.xy); +geometry.position = vec4(currPosition + offset, 1.0); +gl_Position = project_common_position_to_clipspace(geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +} +DECKGL_FILTER_COLOR(vColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/path-layer/path-layer-fragment.glsl.js +var path_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME path-layer-fragment-shader +precision highp float; +uniform float miterLimit; +in vec4 vColor; +in vec2 vCornerOffset; +in float vMiterLength; +in vec2 vPathPosition; +in float vPathLength; +in float vJointType; +out vec4 fragColor; +void main(void) { +geometry.uv = vPathPosition; +if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) { +if (vJointType > 0.5 && length(vCornerOffset) > 1.0) { +discard; +} +if (vJointType < 0.5 && vMiterLength > miterLimit + 1.0) { +discard; +} +} +fragColor = vColor; +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/path-layer/path-layer.js +var DEFAULT_COLOR4 = [0, 0, 0, 255]; +var defaultProps7 = { + widthUnits: "meters", + widthScale: { type: "number", min: 0, value: 1 }, + widthMinPixels: { type: "number", min: 0, value: 0 }, + widthMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, + jointRounded: false, + capRounded: false, + miterLimit: { type: "number", min: 0, value: 4 }, + billboard: false, + _pathType: null, + getPath: { type: "accessor", value: (object) => object.path }, + getColor: { type: "accessor", value: DEFAULT_COLOR4 }, + getWidth: { type: "accessor", value: 1 }, + // deprecated props + rounded: { deprecatedFor: ["jointRounded", "capRounded"] } +}; +var ATTRIBUTE_TRANSITION = { + enter: (value, chunk) => { + return chunk.length ? chunk.subarray(chunk.length - value.length) : value; + } +}; +var PathLayer = class extends layer_default { + getShaders() { + return super.getShaders({ vs: path_layer_vertex_glsl_default, fs: path_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); + } + get wrapLongitude() { + return false; + } + getBounds() { + return this.getAttributeManager()?.getBounds(["vertexPositions"]); + } + initializeState() { + const noAlloc = true; + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + vertexPositions: { + size: 3, + // Start filling buffer from 1 vertex in + vertexOffset: 1, + type: "float64", + fp64: this.use64bitPositions(), + transition: ATTRIBUTE_TRANSITION, + accessor: "getPath", + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculatePositions, + noAlloc, + shaderAttributes: { + instanceLeftPositions: { + vertexOffset: 0 + }, + instanceStartPositions: { + vertexOffset: 1 + }, + instanceEndPositions: { + vertexOffset: 2 + }, + instanceRightPositions: { + vertexOffset: 3 + } + } + }, + instanceTypes: { + size: 1, + type: "uint8", + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculateSegmentTypes, + noAlloc + }, + instanceStrokeWidths: { + size: 1, + accessor: "getWidth", + transition: ATTRIBUTE_TRANSITION, + defaultValue: 1 + }, + instanceColors: { + size: this.props.colorFormat.length, + type: "unorm8", + accessor: "getColor", + transition: ATTRIBUTE_TRANSITION, + defaultValue: DEFAULT_COLOR4 + }, + instancePickingColors: { + size: 4, + type: "uint8", + accessor: (object, { index: index2, target: value }) => this.encodePickingColor(object && object.__source ? object.__source.index : index2, value) + } + }); + this.setState({ + pathTesselator: new PathTesselator({ + fp64: this.use64bitPositions() + }) + }); + } + updateState(params) { + super.updateState(params); + const { props, changeFlags } = params; + const attributeManager = this.getAttributeManager(); + const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath); + if (geometryChanged) { + const { pathTesselator } = this.state; + const buffers = props.data.attributes || {}; + pathTesselator.updateGeometry({ + data: props.data, + geometryBuffer: buffers.getPath, + buffers, + normalize: !props._pathType, + loop: props._pathType === "loop", + getGeometry: props.getPath, + positionFormat: props.positionFormat, + wrapLongitude: props.wrapLongitude, + // TODO - move the flag out of the viewport + resolution: this.context.viewport.resolution, + dataChanged: changeFlags.dataChanged + }); + this.setState({ + numInstances: pathTesselator.instanceCount, + startIndices: pathTesselator.vertexStarts + }); + if (!changeFlags.dataChanged) { + attributeManager.invalidateAll(); + } + } + if (changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + attributeManager.invalidateAll(); + } + } + getPickingInfo(params) { + const info = super.getPickingInfo(params); + const { index: index2 } = info; + const data = this.props.data; + if (data[0] && data[0].__source) { + info.object = data.find((d) => d.__source.index === index2); + } + return info; + } + /** Override base Layer method */ + disablePickingIndex(objectIndex) { + const data = this.props.data; + if (data[0] && data[0].__source) { + for (let i = 0; i < data.length; i++) { + if (data[i].__source.index === objectIndex) { + this._disablePickingIndex(i); + } + } + } else { + super.disablePickingIndex(objectIndex); + } + } + draw({ uniforms }) { + const { jointRounded, capRounded, billboard, miterLimit, widthUnits, widthScale, widthMinPixels, widthMaxPixels } = this.props; + const model = this.state.model; + model.setUniforms(uniforms); + model.setUniforms({ + jointType: Number(jointRounded), + capType: Number(capRounded), + billboard, + widthUnits: UNIT[widthUnits], + widthScale, + miterLimit, + widthMinPixels, + widthMaxPixels + }); + model.draw(this.context.renderPass); + } + _getModel() { + const SEGMENT_INDICES = [ + // start corner + 0, + 1, + 2, + // body + 1, + 4, + 2, + 1, + 3, + 4, + // end corner + 3, + 5, + 4 + ]; + const SEGMENT_POSITIONS = [ + // bevel start corner + 0, + 0, + // start inner corner + 0, + -1, + // start outer corner + 0, + 1, + // end inner corner + 1, + -1, + // end outer corner + 1, + 1, + // bevel end corner + 1, + 0 + ]; + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + geometry: new Geometry({ + topology: "triangle-list", + attributes: { + indices: new Uint16Array(SEGMENT_INDICES), + positions: { value: new Float32Array(SEGMENT_POSITIONS), size: 2 } + } + }), + isInstanced: true + }); + } + calculatePositions(attribute) { + const { pathTesselator } = this.state; + attribute.startIndices = pathTesselator.vertexStarts; + attribute.value = pathTesselator.get("positions"); + } + calculateSegmentTypes(attribute) { + const { pathTesselator } = this.state; + attribute.startIndices = pathTesselator.vertexStarts; + attribute.value = pathTesselator.get("segmentTypes"); + } +}; +PathLayer.defaultProps = defaultProps7; +PathLayer.layerName = "PathLayer"; +var path_layer_default = PathLayer; + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/polygon.js +var import_earcut2 = __toESM(require_earcut(), 1); +var OUTER_POLYGON_WINDING = WINDING.CLOCKWISE; +var HOLE_POLYGON_WINDING = WINDING.COUNTER_CLOCKWISE; +var windingOptions = { + isClosed: true +}; +function validate(polygon) { + polygon = polygon && polygon.positions || polygon; + if (!Array.isArray(polygon) && !ArrayBuffer.isView(polygon)) { + throw new Error("invalid polygon"); + } +} +function getPositions(polygon) { + return "positions" in polygon ? polygon.positions : polygon; +} +function getHoleIndices(polygon) { + return "holeIndices" in polygon ? polygon.holeIndices : null; +} +function isNested(polygon) { + return Array.isArray(polygon[0]); +} +function isSimple(polygon) { + return polygon.length >= 1 && polygon[0].length >= 2 && Number.isFinite(polygon[0][0]); +} +function isNestedRingClosed(simplePolygon) { + const p0 = simplePolygon[0]; + const p1 = simplePolygon[simplePolygon.length - 1]; + return p0[0] === p1[0] && p0[1] === p1[1] && p0[2] === p1[2]; +} +function isFlatRingClosed(positions, size, startIndex, endIndex) { + for (let i = 0; i < size; i++) { + if (positions[startIndex + i] !== positions[endIndex - size + i]) { + return false; + } + } + return true; +} +function copyNestedRing(target, targetStartIndex, simplePolygon, size, windingDirection) { + let targetIndex = targetStartIndex; + const len8 = simplePolygon.length; + for (let i = 0; i < len8; i++) { + for (let j = 0; j < size; j++) { + target[targetIndex++] = simplePolygon[i][j] || 0; + } + } + if (!isNestedRingClosed(simplePolygon)) { + for (let j = 0; j < size; j++) { + target[targetIndex++] = simplePolygon[0][j] || 0; + } + } + windingOptions.start = targetStartIndex; + windingOptions.end = targetIndex; + windingOptions.size = size; + modifyPolygonWindingDirection(target, windingDirection, windingOptions); + return targetIndex; +} +function copyFlatRing(target, targetStartIndex, positions, size, srcStartIndex = 0, srcEndIndex, windingDirection) { + srcEndIndex = srcEndIndex || positions.length; + const srcLength = srcEndIndex - srcStartIndex; + if (srcLength <= 0) { + return targetStartIndex; + } + let targetIndex = targetStartIndex; + for (let i = 0; i < srcLength; i++) { + target[targetIndex++] = positions[srcStartIndex + i]; + } + if (!isFlatRingClosed(positions, size, srcStartIndex, srcEndIndex)) { + for (let i = 0; i < size; i++) { + target[targetIndex++] = positions[srcStartIndex + i]; + } + } + windingOptions.start = targetStartIndex; + windingOptions.end = targetIndex; + windingOptions.size = size; + modifyPolygonWindingDirection(target, windingDirection, windingOptions); + return targetIndex; +} +function normalize7(polygon, positionSize) { + validate(polygon); + const positions = []; + const holeIndices = []; + if ("positions" in polygon) { + const { positions: srcPositions, holeIndices: srcHoleIndices } = polygon; + if (srcHoleIndices) { + let targetIndex = 0; + for (let i = 0; i <= srcHoleIndices.length; i++) { + targetIndex = copyFlatRing(positions, targetIndex, srcPositions, positionSize, srcHoleIndices[i - 1], srcHoleIndices[i], i === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); + holeIndices.push(targetIndex); + } + holeIndices.pop(); + return { positions, holeIndices }; + } + polygon = srcPositions; + } + if (!isNested(polygon)) { + copyFlatRing(positions, 0, polygon, positionSize, 0, positions.length, OUTER_POLYGON_WINDING); + return positions; + } + if (!isSimple(polygon)) { + let targetIndex = 0; + for (const [polygonIndex, simplePolygon] of polygon.entries()) { + targetIndex = copyNestedRing(positions, targetIndex, simplePolygon, positionSize, polygonIndex === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); + holeIndices.push(targetIndex); + } + holeIndices.pop(); + return { positions, holeIndices }; + } + copyNestedRing(positions, 0, polygon, positionSize, OUTER_POLYGON_WINDING); + return positions; +} +function getPlaneArea(positions, xIndex, yIndex) { + const numVerts = positions.length / 3; + let area = 0; + for (let i = 0; i < numVerts; i++) { + const j = (i + 1) % numVerts; + area += positions[i * 3 + xIndex] * positions[j * 3 + yIndex]; + area -= positions[j * 3 + xIndex] * positions[i * 3 + yIndex]; + } + return Math.abs(area / 2); +} +function permutePositions(positions, xIndex, yIndex, zIndex) { + const numVerts = positions.length / 3; + for (let i = 0; i < numVerts; i++) { + const o = i * 3; + const x = positions[o + 0]; + const y = positions[o + 1]; + const z = positions[o + 2]; + positions[o + xIndex] = x; + positions[o + yIndex] = y; + positions[o + zIndex] = z; + } +} +function getSurfaceIndices(polygon, positionSize, preproject, full3d) { + let holeIndices = getHoleIndices(polygon); + if (holeIndices) { + holeIndices = holeIndices.map((positionIndex) => positionIndex / positionSize); + } + let positions = getPositions(polygon); + const is3d = full3d && positionSize === 3; + if (preproject) { + const n = positions.length; + positions = positions.slice(); + const p = []; + for (let i = 0; i < n; i += positionSize) { + p[0] = positions[i]; + p[1] = positions[i + 1]; + if (is3d) { + p[2] = positions[i + 2]; + } + const xy = preproject(p); + positions[i] = xy[0]; + positions[i + 1] = xy[1]; + if (is3d) { + positions[i + 2] = xy[2]; + } + } + } + if (is3d) { + const xyArea = getPlaneArea(positions, 0, 1); + const xzArea = getPlaneArea(positions, 0, 2); + const yzArea = getPlaneArea(positions, 1, 2); + if (!xyArea && !xzArea && !yzArea) { + return []; + } + if (xyArea > xzArea && xyArea > yzArea) { + } else if (xzArea > yzArea) { + if (!preproject) { + positions = positions.slice(); + } + permutePositions(positions, 0, 2, 1); + } else { + if (!preproject) { + positions = positions.slice(); + } + permutePositions(positions, 2, 0, 1); + } + } + return (0, import_earcut2.default)(positions, holeIndices, positionSize); +} + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/polygon-tesselator.js +var PolygonTesselator = class extends Tesselator { + constructor(opts) { + const { fp64: fp642, IndexType = Uint32Array } = opts; + super({ + ...opts, + attributes: { + positions: { size: 3, type: fp642 ? Float64Array : Float32Array }, + vertexValid: { type: Uint16Array, size: 1 }, + indices: { type: IndexType, size: 1 } + } + }); + } + /** Get attribute by name */ + get(attributeName) { + const { attributes } = this; + if (attributeName === "indices") { + return attributes.indices && attributes.indices.subarray(0, this.vertexCount); + } + return attributes[attributeName]; + } + /** Override base Tesselator method */ + updateGeometry(opts) { + super.updateGeometry(opts); + const externalIndices = this.buffers.indices; + if (externalIndices) { + this.vertexCount = (externalIndices.value || externalIndices).length; + } else if (this.data && !this.getGeometry) { + throw new Error("missing indices buffer"); + } + } + /** Implement base Tesselator interface */ + normalizeGeometry(polygon) { + if (this.normalize) { + const normalizedPolygon = normalize7(polygon, this.positionSize); + if (this.opts.resolution) { + return cutPolygonByGrid(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { + size: this.positionSize, + gridResolution: this.opts.resolution, + edgeTypes: true + }); + } + if (this.opts.wrapLongitude) { + return cutPolygonByMercatorBounds(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { + size: this.positionSize, + maxLatitude: 86, + edgeTypes: true + }); + } + return normalizedPolygon; + } + return polygon; + } + /** Implement base Tesselator interface */ + getGeometrySize(polygon) { + if (isCut2(polygon)) { + let size = 0; + for (const subPolygon of polygon) { + size += this.getGeometrySize(subPolygon); + } + return size; + } + return getPositions(polygon).length / this.positionSize; + } + /** Override base Tesselator method */ + getGeometryFromBuffer(buffer) { + if (this.normalize || !this.buffers.indices) { + return super.getGeometryFromBuffer(buffer); + } + return null; + } + /** Implement base Tesselator interface */ + updateGeometryAttributes(polygon, context) { + if (polygon && isCut2(polygon)) { + for (const subPolygon of polygon) { + const geometrySize = this.getGeometrySize(subPolygon); + context.geometrySize = geometrySize; + this.updateGeometryAttributes(subPolygon, context); + context.vertexStart += geometrySize; + context.indexStart = this.indexStarts[context.geometryIndex + 1]; + } + } else { + const normalizedPolygon = polygon; + this._updateIndices(normalizedPolygon, context); + this._updatePositions(normalizedPolygon, context); + this._updateVertexValid(normalizedPolygon, context); + } + } + // Flatten the indices array + _updateIndices(polygon, { geometryIndex, vertexStart: offset, indexStart }) { + const { attributes, indexStarts, typedArrayManager } = this; + let target = attributes.indices; + if (!target || !polygon) { + return; + } + let i = indexStart; + const indices = getSurfaceIndices(polygon, this.positionSize, this.opts.preproject, this.opts.full3d); + target = typedArrayManager.allocate(target, indexStart + indices.length, { + copy: true + }); + for (let j = 0; j < indices.length; j++) { + target[i++] = indices[j] + offset; + } + indexStarts[geometryIndex + 1] = indexStart + indices.length; + attributes.indices = target; + } + // Flatten out all the vertices of all the sub subPolygons + _updatePositions(polygon, { vertexStart, geometrySize }) { + const { attributes: { positions }, positionSize } = this; + if (!positions || !polygon) { + return; + } + const polygonPositions = getPositions(polygon); + for (let i = vertexStart, j = 0; j < geometrySize; i++, j++) { + const x = polygonPositions[j * positionSize]; + const y = polygonPositions[j * positionSize + 1]; + const z = positionSize > 2 ? polygonPositions[j * positionSize + 2] : 0; + positions[i * 3] = x; + positions[i * 3 + 1] = y; + positions[i * 3 + 2] = z; + } + } + _updateVertexValid(polygon, { vertexStart, geometrySize }) { + const { positionSize } = this; + const vertexValid = this.attributes.vertexValid; + const holeIndices = polygon && getHoleIndices(polygon); + if (polygon && polygon.edgeTypes) { + vertexValid.set(polygon.edgeTypes, vertexStart); + } else { + vertexValid.fill(1, vertexStart, vertexStart + geometrySize); + } + if (holeIndices) { + for (let j = 0; j < holeIndices.length; j++) { + vertexValid[vertexStart + holeIndices[j] / positionSize - 1] = 0; + } + } + vertexValid[vertexStart + geometrySize - 1] = 0; + } +}; +function isCut2(polygon) { + return Array.isArray(polygon) && polygon.length > 0 && !Number.isFinite(polygon[0]); +} + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-main.glsl.js +var solid_polygon_layer_vertex_main_glsl_default = `uniform bool extruded; +uniform bool isWireframe; +uniform float elevationScale; +uniform float opacity; +in vec4 fillColors; +in vec4 lineColors; +in vec3 pickingColors; +out vec4 vColor; +struct PolygonProps { +vec3 positions; +vec3 positions64Low; +vec3 normal; +float elevations; +}; +vec3 project_offset_normal(vec3 vector) { +if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT || +project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSETS) { +return normalize(vector * project_uCommonUnitsPerWorldUnit); +} +return project_normal(vector); +} +void calculatePosition(PolygonProps props) { +vec3 pos = props.positions; +vec3 pos64Low = props.positions64Low; +vec3 normal = props.normal; +vec4 colors = isWireframe ? lineColors : fillColors; +geometry.worldPosition = props.positions; +geometry.pickingColor = pickingColors; +if (extruded) { +pos.z += props.elevations * elevationScale; +} +gl_Position = project_position_to_clipspace(pos, pos64Low, vec3(0.), geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +if (extruded) { +#ifdef IS_SIDE_VERTEX +normal = project_offset_normal(normal); +#else +normal = project_normal(normal); +#endif +geometry.normal = normal; +vec3 lightColor = lighting_getLightColor(colors.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal); +vColor = vec4(lightColor, colors.a * opacity); +} else { +vColor = vec4(colors.rgb, colors.a * opacity); +} +DECKGL_FILTER_COLOR(vColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-top.glsl.js +var solid_polygon_layer_vertex_top_glsl_default = `#version 300 es +#define SHADER_NAME solid-polygon-layer-vertex-shader +in vec3 vertexPositions; +in vec3 vertexPositions64Low; +in float elevations; +${solid_polygon_layer_vertex_main_glsl_default} +void main(void) { +PolygonProps props; +props.positions = vertexPositions; +props.positions64Low = vertexPositions64Low; +props.elevations = elevations; +props.normal = vec3(0.0, 0.0, 1.0); +calculatePosition(props); +} +`; + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-side.glsl.js +var solid_polygon_layer_vertex_side_glsl_default = `#version 300 es +#define SHADER_NAME solid-polygon-layer-vertex-shader-side +#define IS_SIDE_VERTEX +in vec2 positions; +in vec3 vertexPositions; +in vec3 nextVertexPositions; +in vec3 vertexPositions64Low; +in vec3 nextVertexPositions64Low; +in float elevations; +in float instanceVertexValid; +${solid_polygon_layer_vertex_main_glsl_default} +void main(void) { +if(instanceVertexValid < 0.5){ +gl_Position = vec4(0.); +return; +} +PolygonProps props; +vec3 pos; +vec3 pos64Low; +vec3 nextPos; +vec3 nextPos64Low; +#if RING_WINDING_ORDER_CW == 1 +pos = vertexPositions; +pos64Low = vertexPositions64Low; +nextPos = nextVertexPositions; +nextPos64Low = nextVertexPositions64Low; +#else +pos = nextVertexPositions; +pos64Low = nextVertexPositions64Low; +nextPos = vertexPositions; +nextPos64Low = vertexPositions64Low; +#endif +props.positions = mix(pos, nextPos, positions.x); +props.positions64Low = mix(pos64Low, nextPos64Low, positions.x); +props.normal = vec3( +pos.y - nextPos.y + (pos64Low.y - nextPos64Low.y), +nextPos.x - pos.x + (nextPos64Low.x - pos64Low.x), +0.0); +props.elevations = elevations * positions.y; +calculatePosition(props); +} +`; + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-fragment.glsl.js +var solid_polygon_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME solid-polygon-layer-fragment-shader +precision highp float; +in vec4 vColor; +out vec4 fragColor; +void main(void) { +fragColor = vColor; +geometry.uv = vec2(0.); +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer.js +var DEFAULT_COLOR5 = [0, 0, 0, 255]; +var defaultProps8 = { + filled: true, + extruded: false, + wireframe: false, + _normalize: true, + _windingOrder: "CW", + _full3d: false, + elevationScale: { type: "number", min: 0, value: 1 }, + getPolygon: { type: "accessor", value: (f) => f.polygon }, + getElevation: { type: "accessor", value: 1e3 }, + getFillColor: { type: "accessor", value: DEFAULT_COLOR5 }, + getLineColor: { type: "accessor", value: DEFAULT_COLOR5 }, + material: true +}; +var ATTRIBUTE_TRANSITION2 = { + enter: (value, chunk) => { + return chunk.length ? chunk.subarray(chunk.length - value.length) : value; + } +}; +var SolidPolygonLayer = class extends layer_default { + getShaders(type) { + return super.getShaders({ + vs: type === "top" ? solid_polygon_layer_vertex_top_glsl_default : solid_polygon_layer_vertex_side_glsl_default, + fs: solid_polygon_layer_fragment_glsl_default, + defines: { + RING_WINDING_ORDER_CW: !this.props._normalize && this.props._windingOrder === "CCW" ? 0 : 1 + }, + modules: [project32_default, gouraudLighting, picking_default] + }); + } + get wrapLongitude() { + return false; + } + getBounds() { + return this.getAttributeManager()?.getBounds(["vertexPositions"]); + } + initializeState() { + const { viewport } = this.context; + let { coordinateSystem } = this.props; + const { _full3d } = this.props; + if (viewport.isGeospatial && coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = COORDINATE_SYSTEM.LNGLAT; + } + let preproject; + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { + if (_full3d) { + preproject = viewport.projectPosition.bind(viewport); + } else { + preproject = viewport.projectFlat.bind(viewport); + } + } + this.setState({ + numInstances: 0, + polygonTesselator: new PolygonTesselator({ + // Lnglat coordinates are usually projected non-linearly, which affects tesselation results + // Provide a preproject function if the coordinates are in lnglat + preproject, + fp64: this.use64bitPositions(), + IndexType: Uint32Array + }) + }); + const attributeManager = this.getAttributeManager(); + const noAlloc = true; + attributeManager.remove(["instancePickingColors"]); + attributeManager.add({ + indices: { + size: 1, + isIndexed: true, + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculateIndices, + noAlloc + }, + vertexPositions: { + size: 3, + type: "float64", + stepMode: "dynamic", + fp64: this.use64bitPositions(), + transition: ATTRIBUTE_TRANSITION2, + accessor: "getPolygon", + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculatePositions, + noAlloc, + shaderAttributes: { + nextVertexPositions: { + vertexOffset: 1 + } + } + }, + instanceVertexValid: { + size: 1, + type: "uint16", + stepMode: "instance", + // eslint-disable-next-line @typescript-eslint/unbound-method + update: this.calculateVertexValid, + noAlloc + }, + elevations: { + size: 1, + stepMode: "dynamic", + transition: ATTRIBUTE_TRANSITION2, + accessor: "getElevation" + }, + fillColors: { + size: this.props.colorFormat.length, + type: "unorm8", + stepMode: "dynamic", + transition: ATTRIBUTE_TRANSITION2, + accessor: "getFillColor", + defaultValue: DEFAULT_COLOR5 + }, + lineColors: { + size: this.props.colorFormat.length, + type: "unorm8", + stepMode: "dynamic", + transition: ATTRIBUTE_TRANSITION2, + accessor: "getLineColor", + defaultValue: DEFAULT_COLOR5 + }, + pickingColors: { + size: 4, + type: "uint8", + stepMode: "dynamic", + accessor: (object, { index: index2, target: value }) => this.encodePickingColor(object && object.__source ? object.__source.index : index2, value) + } + }); + } + getPickingInfo(params) { + const info = super.getPickingInfo(params); + const { index: index2 } = info; + const data = this.props.data; + if (data[0] && data[0].__source) { + info.object = data.find((d) => d.__source.index === index2); + } + return info; + } + disablePickingIndex(objectIndex) { + const data = this.props.data; + if (data[0] && data[0].__source) { + for (let i = 0; i < data.length; i++) { + if (data[i].__source.index === objectIndex) { + this._disablePickingIndex(i); + } + } + } else { + super.disablePickingIndex(objectIndex); + } + } + draw({ uniforms }) { + const { extruded, filled, wireframe, elevationScale } = this.props; + const { topModel, sideModel, wireframeModel, polygonTesselator } = this.state; + const renderUniforms = { + ...uniforms, + extruded: Boolean(extruded), + elevationScale + }; + if (wireframeModel && wireframe) { + wireframeModel.setInstanceCount(polygonTesselator.instanceCount - 1); + wireframeModel.setUniforms(renderUniforms); + wireframeModel.draw(this.context.renderPass); + } + if (sideModel && filled) { + sideModel.setInstanceCount(polygonTesselator.instanceCount - 1); + sideModel.setUniforms(renderUniforms); + sideModel.draw(this.context.renderPass); + } + if (topModel && filled) { + topModel.setVertexCount(polygonTesselator.vertexCount); + topModel.setUniforms(renderUniforms); + topModel.draw(this.context.renderPass); + } + } + updateState(updateParams) { + super.updateState(updateParams); + this.updateGeometry(updateParams); + const { props, oldProps, changeFlags } = updateParams; + const attributeManager = this.getAttributeManager(); + const regenerateModels = changeFlags.extensionsChanged || props.filled !== oldProps.filled || props.extruded !== oldProps.extruded; + if (regenerateModels) { + this.state.models?.forEach((model) => model.destroy()); + this.setState(this._getModels()); + attributeManager.invalidateAll(); + } + } + updateGeometry({ props, oldProps, changeFlags }) { + const geometryConfigChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPolygon); + if (geometryConfigChanged) { + const { polygonTesselator } = this.state; + const buffers = props.data.attributes || {}; + polygonTesselator.updateGeometry({ + data: props.data, + normalize: props._normalize, + geometryBuffer: buffers.getPolygon, + buffers, + getGeometry: props.getPolygon, + positionFormat: props.positionFormat, + wrapLongitude: props.wrapLongitude, + // TODO - move the flag out of the viewport + resolution: this.context.viewport.resolution, + fp64: this.use64bitPositions(), + dataChanged: changeFlags.dataChanged, + full3d: props._full3d + }); + this.setState({ + numInstances: polygonTesselator.instanceCount, + startIndices: polygonTesselator.vertexStarts + }); + if (!changeFlags.dataChanged) { + this.getAttributeManager().invalidateAll(); + } + } + } + _getModels() { + const { id, filled, extruded } = this.props; + let topModel; + let sideModel; + let wireframeModel; + if (filled) { + const shaders = this.getShaders("top"); + shaders.defines.NON_INSTANCED_MODEL = 1; + const bufferLayout = this.getAttributeManager().getBufferLayouts({ isInstanced: false }); + topModel = new Model(this.context.device, { + ...shaders, + id: `${id}-top`, + topology: "triangle-list", + uniforms: { + isWireframe: false + }, + bufferLayout, + isIndexed: true, + userData: { + excludeAttributes: { instanceVertexValid: true } + } + }); + } + if (extruded) { + const bufferLayout = this.getAttributeManager().getBufferLayouts({ isInstanced: true }); + sideModel = new Model(this.context.device, { + ...this.getShaders("side"), + id: `${id}-side`, + bufferLayout, + uniforms: { + isWireframe: false + }, + geometry: new Geometry({ + topology: "triangle-strip", + attributes: { + // top right - top left - bottom right - bottom left + positions: { + size: 2, + value: new Float32Array([1, 0, 0, 0, 1, 1, 0, 1]) + } + } + }), + isInstanced: true, + userData: { + excludeAttributes: { indices: true } + } + }); + wireframeModel = new Model(this.context.device, { + ...this.getShaders("side"), + id: `${id}-wireframe`, + bufferLayout, + uniforms: { + isWireframe: true + }, + geometry: new Geometry({ + topology: "line-strip", + attributes: { + // top right - top left - bottom left - bottom right + positions: { + size: 2, + value: new Float32Array([1, 0, 0, 0, 0, 1, 1, 1]) + } + } + }), + isInstanced: true, + userData: { + excludeAttributes: { indices: true } + } + }); + } + return { + models: [sideModel, wireframeModel, topModel].filter(Boolean), + topModel, + sideModel, + wireframeModel + }; + } + calculateIndices(attribute) { + const { polygonTesselator } = this.state; + attribute.startIndices = polygonTesselator.indexStarts; + attribute.value = polygonTesselator.get("indices"); + } + calculatePositions(attribute) { + const { polygonTesselator } = this.state; + attribute.startIndices = polygonTesselator.vertexStarts; + attribute.value = polygonTesselator.get("positions"); + } + calculateVertexValid(attribute) { + attribute.value = this.state.polygonTesselator.get("vertexValid"); + } +}; +SolidPolygonLayer.defaultProps = defaultProps8; +SolidPolygonLayer.layerName = "SolidPolygonLayer"; +var solid_polygon_layer_default = SolidPolygonLayer; + +// node_modules/@deck.gl/layers/dist/utils.js +function replaceInRange({ data, getIndex, dataRange, replace }) { + const { startRow = 0, endRow = Infinity } = dataRange; + const count2 = data.length; + let replaceStart = count2; + let replaceEnd = count2; + for (let i = 0; i < count2; i++) { + const row = getIndex(data[i]); + if (replaceStart > i && row >= startRow) { + replaceStart = i; + } + if (row >= endRow) { + replaceEnd = i; + break; + } + } + let index2 = replaceStart; + const dataLengthChanged = replaceEnd - replaceStart !== replace.length; + const endChunk = dataLengthChanged ? data.slice(replaceEnd) : void 0; + for (let i = 0; i < replace.length; i++) { + data[index2++] = replace[i]; + } + if (endChunk) { + for (let i = 0; i < endChunk.length; i++) { + data[index2++] = endChunk[i]; + } + data.length = index2; + } + return { + startRow: replaceStart, + endRow: replaceStart + replace.length + }; +} + +// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-binary.js +function binaryToFeatureForAccesor(data, index2) { + if (!data) { + return null; + } + const featureIndex = "startIndices" in data ? data.startIndices[index2] : index2; + const geometryIndex = data.featureIds.value[featureIndex]; + if (featureIndex !== -1) { + return getPropertiesForIndex(data, geometryIndex, featureIndex); + } + return null; +} +function getPropertiesForIndex(data, propertiesIndex, numericPropsIndex) { + const feature = { + properties: { ...data.properties[propertiesIndex] } + }; + for (const prop in data.numericProps) { + feature.properties[prop] = data.numericProps[prop].value[numericPropsIndex]; + } + return feature; +} +function calculatePickingColors(geojsonBinary, encodePickingColor) { + const pickingColors = { + points: null, + lines: null, + polygons: null + }; + for (const key in pickingColors) { + const featureIds = geojsonBinary[key].globalFeatureIds.value; + pickingColors[key] = new Uint8ClampedArray(featureIds.length * 3); + const pickingColor = []; + for (let i = 0; i < featureIds.length; i++) { + encodePickingColor(featureIds[i], pickingColor); + pickingColors[key][i * 3 + 0] = pickingColor[0]; + pickingColors[key][i * 3 + 1] = pickingColor[1]; + pickingColors[key][i * 3 + 2] = pickingColor[2]; + } + } + return pickingColors; +} + +// node_modules/@deck.gl/layers/dist/text-layer/multi-icon-layer/multi-icon-layer-fragment.glsl.js +var multi_icon_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME multi-icon-layer-fragment-shader +precision highp float; +uniform float opacity; +uniform sampler2D iconsTexture; +uniform float gamma; +uniform bool sdf; +uniform float alphaCutoff; +uniform float sdfBuffer; +uniform float outlineBuffer; +uniform vec4 outlineColor; +in vec4 vColor; +in vec2 vTextureCoords; +in vec2 uv; +out vec4 fragColor; +void main(void) { +geometry.uv = uv; +if (!bool(picking.isActive)) { +float alpha = texture(iconsTexture, vTextureCoords).a; +vec4 color = vColor; +if (sdf) { +float distance = alpha; +alpha = smoothstep(sdfBuffer - gamma, sdfBuffer + gamma, distance); +if (outlineBuffer > 0.0) { +float inFill = alpha; +float inBorder = smoothstep(outlineBuffer - gamma, outlineBuffer + gamma, distance); +color = mix(outlineColor, vColor, inFill); +alpha = inBorder; +} +} +float a = alpha * color.a; +if (a < alphaCutoff) { +discard; +} +fragColor = vec4(color.rgb, a * opacity); +} +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/text-layer/multi-icon-layer/multi-icon-layer.js +var DEFAULT_BUFFER2 = 192 / 256; +var EMPTY_ARRAY3 = []; +var defaultProps9 = { + getIconOffsets: { type: "accessor", value: (x) => x.offsets }, + alphaCutoff: 1e-3, + smoothing: 0.1, + outlineWidth: 0, + outlineColor: { type: "color", value: [0, 0, 0, 255] } +}; +var MultiIconLayer = class extends icon_layer_default { + getShaders() { + return { ...super.getShaders(), fs: multi_icon_layer_fragment_glsl_default }; + } + initializeState() { + super.initializeState(); + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instanceOffsets: { + size: 2, + accessor: "getIconOffsets" + }, + instancePickingColors: { + type: "uint8", + size: 3, + accessor: (object, { index: index2, target: value }) => this.encodePickingColor(index2, value) + } + }); + } + updateState(params) { + super.updateState(params); + const { props, oldProps } = params; + let { outlineColor } = props; + if (outlineColor !== oldProps.outlineColor) { + outlineColor = outlineColor.map((x) => x / 255); + outlineColor[3] = Number.isFinite(outlineColor[3]) ? outlineColor[3] : 1; + this.setState({ + outlineColor + }); + } + if (!props.sdf && props.outlineWidth) { + log_default.warn(`${this.id}: fontSettings.sdf is required to render outline`)(); + } + } + draw(params) { + const { sdf, smoothing, outlineWidth } = this.props; + const { outlineColor } = this.state; + const outlineBuffer = outlineWidth ? Math.max(smoothing, DEFAULT_BUFFER2 * (1 - outlineWidth)) : -1; + params.uniforms = { + ...params.uniforms, + // Refer the following doc about gamma and buffer + // https://blog.mapbox.com/drawing-text-with-signed-distance-fields-in-mapbox-gl-b0933af6f817 + sdfBuffer: DEFAULT_BUFFER2, + outlineBuffer, + gamma: smoothing, + sdf: Boolean(sdf), + outlineColor + }; + super.draw(params); + if (sdf && outlineWidth) { + const { iconManager } = this.state; + const iconsTexture = iconManager.getTexture(); + const model = this.state.model; + if (iconsTexture) { + model.setUniforms({ outlineBuffer: DEFAULT_BUFFER2 }); + model.draw(this.context.renderPass); + } + } + } + getInstanceOffset(icons) { + return icons ? Array.from(icons).flatMap((icon) => super.getInstanceOffset(icon)) : EMPTY_ARRAY3; + } + getInstanceColorMode(icons) { + return 1; + } + getInstanceIconFrame(icons) { + return icons ? Array.from(icons).flatMap((icon) => super.getInstanceIconFrame(icon)) : EMPTY_ARRAY3; + } +}; +MultiIconLayer.defaultProps = defaultProps9; +MultiIconLayer.layerName = "MultiIconLayer"; +var multi_icon_layer_default = MultiIconLayer; + +// node_modules/@mapbox/tiny-sdf/index.js +var INF = 1e20; +var TinySDF = class { + constructor({ + fontSize = 24, + buffer = 3, + radius = 8, + cutoff = 0.25, + fontFamily = "sans-serif", + fontWeight = "normal", + fontStyle = "normal" + } = {}) { + this.buffer = buffer; + this.cutoff = cutoff; + this.radius = radius; + const size = this.size = fontSize + buffer * 4; + const canvas2 = this._createCanvas(size); + const ctx2 = this.ctx = canvas2.getContext("2d", { willReadFrequently: true }); + ctx2.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`; + ctx2.textBaseline = "alphabetic"; + ctx2.textAlign = "left"; + ctx2.fillStyle = "black"; + this.gridOuter = new Float64Array(size * size); + this.gridInner = new Float64Array(size * size); + this.f = new Float64Array(size); + this.z = new Float64Array(size + 1); + this.v = new Uint16Array(size); + } + _createCanvas(size) { + const canvas2 = document.createElement("canvas"); + canvas2.width = canvas2.height = size; + return canvas2; + } + draw(char) { + const { + width: glyphAdvance, + actualBoundingBoxAscent, + actualBoundingBoxDescent, + actualBoundingBoxLeft, + actualBoundingBoxRight + } = this.ctx.measureText(char); + const glyphTop = Math.ceil(actualBoundingBoxAscent); + const glyphLeft = 0; + const glyphWidth = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(actualBoundingBoxRight - actualBoundingBoxLeft))); + const glyphHeight = Math.min(this.size - this.buffer, glyphTop + Math.ceil(actualBoundingBoxDescent)); + const width = glyphWidth + 2 * this.buffer; + const height = glyphHeight + 2 * this.buffer; + const len8 = Math.max(width * height, 0); + const data = new Uint8ClampedArray(len8); + const glyph = { data, width, height, glyphWidth, glyphHeight, glyphTop, glyphLeft, glyphAdvance }; + if (glyphWidth === 0 || glyphHeight === 0) + return glyph; + const { ctx: ctx2, buffer, gridInner, gridOuter } = this; + ctx2.clearRect(buffer, buffer, glyphWidth, glyphHeight); + ctx2.fillText(char, buffer, buffer + glyphTop); + const imgData = ctx2.getImageData(buffer, buffer, glyphWidth, glyphHeight); + gridOuter.fill(INF, 0, len8); + gridInner.fill(0, 0, len8); + for (let y = 0; y < glyphHeight; y++) { + for (let x = 0; x < glyphWidth; x++) { + const a = imgData.data[4 * (y * glyphWidth + x) + 3] / 255; + if (a === 0) + continue; + const j = (y + buffer) * width + x + buffer; + if (a === 1) { + gridOuter[j] = 0; + gridInner[j] = INF; + } else { + const d = 0.5 - a; + gridOuter[j] = d > 0 ? d * d : 0; + gridInner[j] = d < 0 ? d * d : 0; + } + } + } + edt(gridOuter, 0, 0, width, height, width, this.f, this.v, this.z); + edt(gridInner, buffer, buffer, glyphWidth, glyphHeight, width, this.f, this.v, this.z); + for (let i = 0; i < len8; i++) { + const d = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]); + data[i] = Math.round(255 - 255 * (d / this.radius + this.cutoff)); + } + return glyph; + } +}; +function edt(data, x0, y0, width, height, gridSize, f, v, z) { + for (let x = x0; x < x0 + width; x++) + edt1d(data, y0 * gridSize + x, gridSize, height, f, v, z); + for (let y = y0; y < y0 + height; y++) + edt1d(data, y * gridSize + x0, 1, width, f, v, z); +} +function edt1d(grid, offset, stride, length10, f, v, z) { + v[0] = 0; + z[0] = -INF; + z[1] = INF; + f[0] = grid[offset]; + for (let q = 1, k = 0, s = 0; q < length10; q++) { + f[q] = grid[offset + q * stride]; + const q2 = q * q; + do { + const r = v[k]; + s = (f[q] - f[r] + q2 - r * r) / (q - r) / 2; + } while (s <= z[k] && --k > -1); + k++; + v[k] = q; + z[k] = s; + z[k + 1] = INF; + } + for (let q = 0, k = 0; q < length10; q++) { + while (z[k + 1] < q) + k++; + const r = v[k]; + const qr = q - r; + grid[offset + q * stride] = f[r] + qr * qr; + } +} + +// node_modules/@deck.gl/layers/dist/text-layer/utils.js +var MISSING_CHAR_WIDTH = 32; +var SINGLE_LINE = []; +function nextPowOfTwo2(number) { + return Math.pow(2, Math.ceil(Math.log2(number))); +} +function buildMapping2({ characterSet, getFontWidth, fontHeight, buffer, maxCanvasWidth, mapping = {}, xOffset = 0, yOffset = 0 }) { + let row = 0; + let x = xOffset; + const rowHeight = fontHeight + buffer * 2; + for (const char of characterSet) { + if (!mapping[char]) { + const width = getFontWidth(char); + if (x + width + buffer * 2 > maxCanvasWidth) { + x = 0; + row++; + } + mapping[char] = { + x: x + buffer, + y: yOffset + row * rowHeight + buffer, + width, + height: rowHeight, + layoutWidth: width, + layoutHeight: fontHeight + }; + x += width + buffer * 2; + } + } + return { + mapping, + xOffset: x, + yOffset: yOffset + row * rowHeight, + canvasHeight: nextPowOfTwo2(yOffset + (row + 1) * rowHeight) + }; +} +function getTextWidth(text, startIndex, endIndex, mapping) { + let width = 0; + for (let i = startIndex; i < endIndex; i++) { + const character = text[i]; + width += mapping[character]?.layoutWidth || 0; + } + return width; +} +function breakAll(text, startIndex, endIndex, maxWidth, iconMapping, target) { + let rowStartCharIndex = startIndex; + let rowOffsetLeft = 0; + for (let i = startIndex; i < endIndex; i++) { + const textWidth = getTextWidth(text, i, i + 1, iconMapping); + if (rowOffsetLeft + textWidth > maxWidth) { + if (rowStartCharIndex < i) { + target.push(i); + } + rowStartCharIndex = i; + rowOffsetLeft = 0; + } + rowOffsetLeft += textWidth; + } + return rowOffsetLeft; +} +function breakWord(text, startIndex, endIndex, maxWidth, iconMapping, target) { + let rowStartCharIndex = startIndex; + let groupStartCharIndex = startIndex; + let groupEndCharIndex = startIndex; + let rowOffsetLeft = 0; + for (let i = startIndex; i < endIndex; i++) { + if (text[i] === " ") { + groupEndCharIndex = i + 1; + } else if (text[i + 1] === " " || i + 1 === endIndex) { + groupEndCharIndex = i + 1; + } + if (groupEndCharIndex > groupStartCharIndex) { + let groupWidth = getTextWidth(text, groupStartCharIndex, groupEndCharIndex, iconMapping); + if (rowOffsetLeft + groupWidth > maxWidth) { + if (rowStartCharIndex < groupStartCharIndex) { + target.push(groupStartCharIndex); + rowStartCharIndex = groupStartCharIndex; + rowOffsetLeft = 0; + } + if (groupWidth > maxWidth) { + groupWidth = breakAll(text, groupStartCharIndex, groupEndCharIndex, maxWidth, iconMapping, target); + rowStartCharIndex = target[target.length - 1]; + } + } + groupStartCharIndex = groupEndCharIndex; + rowOffsetLeft += groupWidth; + } + } + return rowOffsetLeft; +} +function autoWrapping(text, wordBreak, maxWidth, iconMapping, startIndex = 0, endIndex) { + if (endIndex === void 0) { + endIndex = text.length; + } + const result = []; + if (wordBreak === "break-all") { + breakAll(text, startIndex, endIndex, maxWidth, iconMapping, result); + } else { + breakWord(text, startIndex, endIndex, maxWidth, iconMapping, result); + } + return result; +} +function transformRow(line, startIndex, endIndex, iconMapping, leftOffsets, rowSize) { + let x = 0; + let rowHeight = 0; + for (let i = startIndex; i < endIndex; i++) { + const character = line[i]; + const frame = iconMapping[character]; + if (frame) { + if (!rowHeight) { + rowHeight = frame.layoutHeight; + } + leftOffsets[i] = x + frame.layoutWidth / 2; + x += frame.layoutWidth; + } else { + log_default.warn(`Missing character: ${character} (${character.codePointAt(0)})`)(); + leftOffsets[i] = x; + x += MISSING_CHAR_WIDTH; + } + } + rowSize[0] = x; + rowSize[1] = rowHeight; +} +function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth, iconMapping) { + const characters = Array.from(paragraph); + const numCharacters = characters.length; + const x = new Array(numCharacters); + const y = new Array(numCharacters); + const rowWidth = new Array(numCharacters); + const autoWrappingEnabled = (wordBreak === "break-word" || wordBreak === "break-all") && isFinite(maxWidth) && maxWidth > 0; + const size = [0, 0]; + const rowSize = [0, 0]; + let rowOffsetTop = 0; + let lineStartIndex = 0; + let lineEndIndex = 0; + for (let i = 0; i <= numCharacters; i++) { + const char = characters[i]; + if (char === "\n" || i === numCharacters) { + lineEndIndex = i; + } + if (lineEndIndex > lineStartIndex) { + const rows = autoWrappingEnabled ? autoWrapping(characters, wordBreak, maxWidth, iconMapping, lineStartIndex, lineEndIndex) : SINGLE_LINE; + for (let rowIndex = 0; rowIndex <= rows.length; rowIndex++) { + const rowStart = rowIndex === 0 ? lineStartIndex : rows[rowIndex - 1]; + const rowEnd = rowIndex < rows.length ? rows[rowIndex] : lineEndIndex; + transformRow(characters, rowStart, rowEnd, iconMapping, x, rowSize); + for (let j = rowStart; j < rowEnd; j++) { + const char2 = characters[j]; + const layoutOffsetY = iconMapping[char2]?.layoutOffsetY || 0; + y[j] = rowOffsetTop + rowSize[1] / 2 + layoutOffsetY; + rowWidth[j] = rowSize[0]; + } + rowOffsetTop = rowOffsetTop + rowSize[1] * lineHeight; + size[0] = Math.max(size[0], rowSize[0]); + } + lineStartIndex = lineEndIndex; + } + if (char === "\n") { + x[lineStartIndex] = 0; + y[lineStartIndex] = 0; + rowWidth[lineStartIndex] = 0; + lineStartIndex++; + } + } + size[1] = rowOffsetTop; + return { x, y, rowWidth, size }; +} +function getTextFromBuffer({ value, length: length10, stride, offset, startIndices, characterSet }) { + const bytesPerElement = value.BYTES_PER_ELEMENT; + const elementStride = stride ? stride / bytesPerElement : 1; + const elementOffset = offset ? offset / bytesPerElement : 0; + const characterCount = startIndices[length10] || Math.ceil((value.length - elementOffset) / elementStride); + const autoCharacterSet = characterSet && /* @__PURE__ */ new Set(); + const texts = new Array(length10); + let codes = value; + if (elementStride > 1 || elementOffset > 0) { + const ArrayType2 = value.constructor; + codes = new ArrayType2(characterCount); + for (let i = 0; i < characterCount; i++) { + codes[i] = value[i * elementStride + elementOffset]; + } + } + for (let index2 = 0; index2 < length10; index2++) { + const startIndex = startIndices[index2]; + const endIndex = startIndices[index2 + 1] || characterCount; + const codesAtIndex = codes.subarray(startIndex, endIndex); + texts[index2] = String.fromCodePoint.apply(null, codesAtIndex); + if (autoCharacterSet) { + codesAtIndex.forEach(autoCharacterSet.add, autoCharacterSet); + } + } + if (autoCharacterSet) { + for (const charCode of autoCharacterSet) { + characterSet.add(String.fromCodePoint(charCode)); + } + } + return { texts, characterCount }; +} + +// node_modules/@deck.gl/layers/dist/text-layer/lru-cache.js +var LRUCache = class { + constructor(limit = 5) { + this._cache = {}; + this._order = []; + this.limit = limit; + } + get(key) { + const value = this._cache[key]; + if (value) { + this._deleteOrder(key); + this._appendOrder(key); + } + return value; + } + set(key, value) { + if (!this._cache[key]) { + if (Object.keys(this._cache).length === this.limit) { + this.delete(this._order[0]); + } + this._cache[key] = value; + this._appendOrder(key); + } else { + this.delete(key); + this._cache[key] = value; + this._appendOrder(key); + } + } + delete(key) { + const value = this._cache[key]; + if (value) { + delete this._cache[key]; + this._deleteOrder(key); + } + } + _deleteOrder(key) { + const index2 = this._order.indexOf(key); + if (index2 >= 0) { + this._order.splice(index2, 1); + } + } + _appendOrder(key) { + this._order.push(key); + } +}; + +// node_modules/@deck.gl/layers/dist/text-layer/font-atlas-manager.js +function getDefaultCharacterSet() { + const charSet = []; + for (let i = 32; i < 128; i++) { + charSet.push(String.fromCharCode(i)); + } + return charSet; +} +var DEFAULT_FONT_SETTINGS = { + fontFamily: "Monaco, monospace", + fontWeight: "normal", + characterSet: getDefaultCharacterSet(), + fontSize: 64, + buffer: 4, + sdf: false, + cutoff: 0.25, + radius: 12, + smoothing: 0.1 +}; +var MAX_CANVAS_WIDTH = 1024; +var BASELINE_SCALE = 0.9; +var HEIGHT_SCALE = 1.2; +var CACHE_LIMIT = 3; +var cache2 = new LRUCache(CACHE_LIMIT); +function getNewChars(cacheKey, characterSet) { + let newCharSet; + if (typeof characterSet === "string") { + newCharSet = new Set(Array.from(characterSet)); + } else { + newCharSet = new Set(characterSet); + } + const cachedFontAtlas = cache2.get(cacheKey); + if (!cachedFontAtlas) { + return newCharSet; + } + for (const char in cachedFontAtlas.mapping) { + if (newCharSet.has(char)) { + newCharSet.delete(char); + } + } + return newCharSet; +} +function populateAlphaChannel(alphaChannel, imageData) { + for (let i = 0; i < alphaChannel.length; i++) { + imageData.data[4 * i + 3] = alphaChannel[i]; + } +} +function setTextStyle(ctx2, fontFamily, fontSize, fontWeight) { + ctx2.font = `${fontWeight} ${fontSize}px ${fontFamily}`; + ctx2.fillStyle = "#000"; + ctx2.textBaseline = "alphabetic"; + ctx2.textAlign = "left"; +} +function setFontAtlasCacheLimit(limit) { + log_default.assert(Number.isFinite(limit) && limit >= CACHE_LIMIT, "Invalid cache limit"); + cache2 = new LRUCache(limit); +} +var FontAtlasManager = class { + constructor() { + this.props = { ...DEFAULT_FONT_SETTINGS }; + } + get atlas() { + return this._atlas; + } + // TODO - cut during v9 porting as types reveal this is not correct + // get texture(): Texture | undefined { + // return this._atlas; + // } + get mapping() { + return this._atlas && this._atlas.mapping; + } + get scale() { + const { fontSize, buffer } = this.props; + return (fontSize * HEIGHT_SCALE + buffer * 2) / fontSize; + } + setProps(props = {}) { + Object.assign(this.props, props); + this._key = this._getKey(); + const charSet = getNewChars(this._key, this.props.characterSet); + const cachedFontAtlas = cache2.get(this._key); + if (cachedFontAtlas && charSet.size === 0) { + if (this._atlas !== cachedFontAtlas) { + this._atlas = cachedFontAtlas; + } + return; + } + const fontAtlas = this._generateFontAtlas(charSet, cachedFontAtlas); + this._atlas = fontAtlas; + cache2.set(this._key, fontAtlas); + } + // eslint-disable-next-line max-statements + _generateFontAtlas(characterSet, cachedFontAtlas) { + const { fontFamily, fontWeight, fontSize, buffer, sdf, radius, cutoff } = this.props; + let canvas2 = cachedFontAtlas && cachedFontAtlas.data; + if (!canvas2) { + canvas2 = document.createElement("canvas"); + canvas2.width = MAX_CANVAS_WIDTH; + } + const ctx2 = canvas2.getContext("2d", { willReadFrequently: true }); + setTextStyle(ctx2, fontFamily, fontSize, fontWeight); + const { mapping, canvasHeight, xOffset, yOffset } = buildMapping2({ + getFontWidth: (char) => ctx2.measureText(char).width, + fontHeight: fontSize * HEIGHT_SCALE, + buffer, + characterSet, + maxCanvasWidth: MAX_CANVAS_WIDTH, + ...cachedFontAtlas && { + mapping: cachedFontAtlas.mapping, + xOffset: cachedFontAtlas.xOffset, + yOffset: cachedFontAtlas.yOffset + } + }); + if (canvas2.height !== canvasHeight) { + const imageData = ctx2.getImageData(0, 0, canvas2.width, canvas2.height); + canvas2.height = canvasHeight; + ctx2.putImageData(imageData, 0, 0); + } + setTextStyle(ctx2, fontFamily, fontSize, fontWeight); + if (sdf) { + const tinySDF = new TinySDF({ + fontSize, + buffer, + radius, + cutoff, + fontFamily, + fontWeight: `${fontWeight}` + }); + for (const char of characterSet) { + const { data, width, height, glyphTop } = tinySDF.draw(char); + mapping[char].width = width; + mapping[char].layoutOffsetY = fontSize * BASELINE_SCALE - glyphTop; + const imageData = ctx2.createImageData(width, height); + populateAlphaChannel(data, imageData); + ctx2.putImageData(imageData, mapping[char].x, mapping[char].y); + } + } else { + for (const char of characterSet) { + ctx2.fillText(char, mapping[char].x, mapping[char].y + buffer + fontSize * BASELINE_SCALE); + } + } + return { + xOffset, + yOffset, + mapping, + data: canvas2, + width: canvas2.width, + height: canvas2.height + }; + } + _getKey() { + const { fontFamily, fontWeight, fontSize, buffer, sdf, radius, cutoff } = this.props; + if (sdf) { + return `${fontFamily} ${fontWeight} ${fontSize} ${buffer} ${radius} ${cutoff}`; + } + return `${fontFamily} ${fontWeight} ${fontSize} ${buffer}`; + } +}; + +// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer-vertex.glsl.js +var text_background_layer_vertex_glsl_default = `#version 300 es +#define SHADER_NAME text-background-layer-vertex-shader +in vec2 positions; +in vec3 instancePositions; +in vec3 instancePositions64Low; +in vec4 instanceRects; +in float instanceSizes; +in float instanceAngles; +in vec2 instancePixelOffsets; +in float instanceLineWidths; +in vec4 instanceFillColors; +in vec4 instanceLineColors; +in vec3 instancePickingColors; +uniform bool billboard; +uniform float opacity; +uniform float sizeScale; +uniform float sizeMinPixels; +uniform float sizeMaxPixels; +uniform vec4 padding; +uniform int sizeUnits; +out vec4 vFillColor; +out vec4 vLineColor; +out float vLineWidth; +out vec2 uv; +out vec2 dimensions; +vec2 rotate_by_angle(vec2 vertex, float angle) { +float angle_radian = radians(angle); +float cos_angle = cos(angle_radian); +float sin_angle = sin(angle_radian); +mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle); +return rotationMatrix * vertex; +} +void main(void) { +geometry.worldPosition = instancePositions; +geometry.uv = positions; +geometry.pickingColor = instancePickingColors; +uv = positions; +vLineWidth = instanceLineWidths; +float sizePixels = clamp( +project_size_to_pixel(instanceSizes * sizeScale, sizeUnits), +sizeMinPixels, sizeMaxPixels +); +dimensions = instanceRects.zw * sizePixels + padding.xy + padding.zw; +vec2 pixelOffset = (positions * instanceRects.zw + instanceRects.xy) * sizePixels + mix(-padding.xy, padding.zw, positions); +pixelOffset = rotate_by_angle(pixelOffset, instanceAngles); +pixelOffset += instancePixelOffsets; +pixelOffset.y *= -1.0; +if (billboard) { +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +vec3 offset = vec3(pixelOffset, 0.0); +DECKGL_FILTER_SIZE(offset, geometry); +gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); +} else { +vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0); +DECKGL_FILTER_SIZE(offset_common, geometry); +gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position); +DECKGL_FILTER_GL_POSITION(gl_Position, geometry); +} +vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity); +DECKGL_FILTER_COLOR(vFillColor, geometry); +vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); +DECKGL_FILTER_COLOR(vLineColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer-fragment.glsl.js +var text_background_layer_fragment_glsl_default = `#version 300 es +#define SHADER_NAME text-background-layer-fragment-shader +precision highp float; +uniform bool stroked; +in vec4 vFillColor; +in vec4 vLineColor; +in float vLineWidth; +in vec2 uv; +in vec2 dimensions; +out vec4 fragColor; +void main(void) { +geometry.uv = uv; +vec2 pixelPosition = uv * dimensions; +if (stroked) { +float distToEdge = min( +min(pixelPosition.x, dimensions.x - pixelPosition.x), +min(pixelPosition.y, dimensions.y - pixelPosition.y) +); +float isBorder = smoothedge(distToEdge, vLineWidth); +fragColor = mix(vFillColor, vLineColor, isBorder); +} else { +fragColor = vFillColor; +} +DECKGL_FILTER_COLOR(fragColor, geometry); +} +`; + +// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer.js +var defaultProps10 = { + billboard: true, + sizeScale: 1, + sizeUnits: "pixels", + sizeMinPixels: 0, + sizeMaxPixels: Number.MAX_SAFE_INTEGER, + padding: { type: "array", value: [0, 0, 0, 0] }, + getPosition: { type: "accessor", value: (x) => x.position }, + getSize: { type: "accessor", value: 1 }, + getAngle: { type: "accessor", value: 0 }, + getPixelOffset: { type: "accessor", value: [0, 0] }, + getBoundingRect: { type: "accessor", value: [0, 0, 0, 0] }, + getFillColor: { type: "accessor", value: [0, 0, 0, 255] }, + getLineColor: { type: "accessor", value: [0, 0, 0, 255] }, + getLineWidth: { type: "accessor", value: 1 } +}; +var TextBackgroundLayer = class extends layer_default { + getShaders() { + return super.getShaders({ vs: text_background_layer_vertex_glsl_default, fs: text_background_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); + } + initializeState() { + this.getAttributeManager().addInstanced({ + instancePositions: { + size: 3, + type: "float64", + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceSizes: { + size: 1, + transition: true, + accessor: "getSize", + defaultValue: 1 + }, + instanceAngles: { + size: 1, + transition: true, + accessor: "getAngle" + }, + instanceRects: { + size: 4, + accessor: "getBoundingRect" + }, + instancePixelOffsets: { + size: 2, + transition: true, + accessor: "getPixelOffset" + }, + instanceFillColors: { + size: 4, + transition: true, + type: "unorm8", + accessor: "getFillColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineColors: { + size: 4, + transition: true, + type: "unorm8", + accessor: "getLineColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineWidths: { + size: 1, + transition: true, + accessor: "getLineWidth", + defaultValue: 1 + } + }); + } + updateState(params) { + super.updateState(params); + const { changeFlags } = params; + if (changeFlags.extensionsChanged) { + this.state.model?.destroy(); + this.state.model = this._getModel(); + this.getAttributeManager().invalidateAll(); + } + } + draw({ uniforms }) { + const { billboard, sizeScale, sizeUnits, sizeMinPixels, sizeMaxPixels, getLineWidth } = this.props; + let { padding } = this.props; + if (padding.length < 4) { + padding = [padding[0], padding[1], padding[0], padding[1]]; + } + const model = this.state.model; + model.setUniforms(uniforms); + model.setUniforms({ + billboard, + stroked: Boolean(getLineWidth), + padding, + sizeUnits: UNIT[sizeUnits], + sizeScale, + sizeMinPixels, + sizeMaxPixels + }); + model.draw(this.context.renderPass); + } + _getModel() { + const positions = [0, 0, 1, 0, 1, 1, 0, 1]; + return new Model(this.context.device, { + ...this.getShaders(), + id: this.props.id, + bufferLayout: this.getAttributeManager().getBufferLayouts(), + geometry: new Geometry({ + topology: "triangle-fan-webgl", + vertexCount: 4, + attributes: { + positions: { size: 2, value: new Float32Array(positions) } + } + }), + isInstanced: true + }); + } +}; +TextBackgroundLayer.defaultProps = defaultProps10; +TextBackgroundLayer.layerName = "TextBackgroundLayer"; +var text_background_layer_default = TextBackgroundLayer; + +// node_modules/@deck.gl/layers/dist/text-layer/text-layer.js +var TEXT_ANCHOR = { + start: 1, + middle: 0, + end: -1 +}; +var ALIGNMENT_BASELINE = { + top: 1, + center: 0, + bottom: -1 +}; +var DEFAULT_COLOR6 = [0, 0, 0, 255]; +var DEFAULT_LINE_HEIGHT = 1; +var defaultProps11 = { + billboard: true, + sizeScale: 1, + sizeUnits: "pixels", + sizeMinPixels: 0, + sizeMaxPixels: Number.MAX_SAFE_INTEGER, + background: false, + getBackgroundColor: { type: "accessor", value: [255, 255, 255, 255] }, + getBorderColor: { type: "accessor", value: DEFAULT_COLOR6 }, + getBorderWidth: { type: "accessor", value: 0 }, + backgroundPadding: { type: "array", value: [0, 0, 0, 0] }, + characterSet: { type: "object", value: DEFAULT_FONT_SETTINGS.characterSet }, + fontFamily: DEFAULT_FONT_SETTINGS.fontFamily, + fontWeight: DEFAULT_FONT_SETTINGS.fontWeight, + lineHeight: DEFAULT_LINE_HEIGHT, + outlineWidth: { type: "number", value: 0, min: 0 }, + outlineColor: { type: "color", value: DEFAULT_COLOR6 }, + fontSettings: { type: "object", value: {}, compare: 1 }, + // auto wrapping options + wordBreak: "break-word", + maxWidth: { type: "number", value: -1 }, + getText: { type: "accessor", value: (x) => x.text }, + getPosition: { type: "accessor", value: (x) => x.position }, + getColor: { type: "accessor", value: DEFAULT_COLOR6 }, + getSize: { type: "accessor", value: 32 }, + getAngle: { type: "accessor", value: 0 }, + getTextAnchor: { type: "accessor", value: "middle" }, + getAlignmentBaseline: { type: "accessor", value: "center" }, + getPixelOffset: { type: "accessor", value: [0, 0] }, + // deprecated + backgroundColor: { deprecatedFor: ["background", "getBackgroundColor"] } +}; +var TextLayer = class extends composite_layer_default { + constructor() { + super(...arguments); + this.getBoundingRect = (object, objectInfo) => { + let { size: [width, height] } = this.transformParagraph(object, objectInfo); + const { fontSize } = this.state.fontAtlasManager.props; + width /= fontSize; + height /= fontSize; + const { getTextAnchor, getAlignmentBaseline } = this.props; + const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; + const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; + return [(anchorX - 1) * width / 2, (anchorY - 1) * height / 2, width, height]; + }; + this.getIconOffsets = (object, objectInfo) => { + const { getTextAnchor, getAlignmentBaseline } = this.props; + const { x, y, rowWidth, size: [width, height] } = this.transformParagraph(object, objectInfo); + const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; + const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; + const numCharacters = x.length; + const offsets = new Array(numCharacters * 2); + let index2 = 0; + for (let i = 0; i < numCharacters; i++) { + const rowOffset = (1 - anchorX) * (width - rowWidth[i]) / 2; + offsets[index2++] = (anchorX - 1) * width / 2 + rowOffset + x[i]; + offsets[index2++] = (anchorY - 1) * height / 2 + y[i]; + } + return offsets; + }; + } + initializeState() { + this.state = { + styleVersion: 0, + fontAtlasManager: new FontAtlasManager() + }; + if (this.props.maxWidth > 0) { + log_default.warn("v8.9 breaking change: TextLayer maxWidth is now relative to text size")(); + } + } + // eslint-disable-next-line complexity + updateState(params) { + const { props, oldProps, changeFlags } = params; + const textChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getText); + if (textChanged) { + this._updateText(); + } + const fontChanged = this._updateFontAtlas(); + const styleChanged = fontChanged || props.lineHeight !== oldProps.lineHeight || props.wordBreak !== oldProps.wordBreak || props.maxWidth !== oldProps.maxWidth; + if (styleChanged) { + this.setState({ + styleVersion: this.state.styleVersion + 1 + }); + } + } + getPickingInfo({ info }) { + info.object = info.index >= 0 ? this.props.data[info.index] : null; + return info; + } + /** Returns true if font has changed */ + _updateFontAtlas() { + const { fontSettings, fontFamily, fontWeight } = this.props; + const { fontAtlasManager, characterSet } = this.state; + const fontProps = { + ...fontSettings, + characterSet, + fontFamily, + fontWeight + }; + if (!fontAtlasManager.mapping) { + fontAtlasManager.setProps(fontProps); + return true; + } + for (const key in fontProps) { + if (fontProps[key] !== fontAtlasManager.props[key]) { + fontAtlasManager.setProps(fontProps); + return true; + } + } + return false; + } + // Text strings are variable width objects + // Count characters and start offsets + _updateText() { + const { data, characterSet } = this.props; + const textBuffer = data.attributes?.getText; + let { getText } = this.props; + let startIndices = data.startIndices; + let numInstances; + const autoCharacterSet = characterSet === "auto" && /* @__PURE__ */ new Set(); + if (textBuffer && startIndices) { + const { texts, characterCount } = getTextFromBuffer({ + ...ArrayBuffer.isView(textBuffer) ? { value: textBuffer } : textBuffer, + // @ts-ignore if data.attribute is defined then length is expected + length: data.length, + startIndices, + characterSet: autoCharacterSet + }); + numInstances = characterCount; + getText = (_, { index: index2 }) => texts[index2]; + } else { + const { iterable, objectInfo } = createIterable(data); + startIndices = [0]; + numInstances = 0; + for (const object of iterable) { + objectInfo.index++; + const text = Array.from(getText(object, objectInfo) || ""); + if (autoCharacterSet) { + text.forEach(autoCharacterSet.add, autoCharacterSet); + } + numInstances += text.length; + startIndices.push(numInstances); + } + } + this.setState({ + getText, + startIndices, + numInstances, + characterSet: autoCharacterSet || characterSet + }); + } + /** There are two size systems in this layer: + + + Pixel size: user-specified text size, via getSize, sizeScale, sizeUnits etc. + The layer roughly matches the output of the layer to CSS pixels, e.g. getSize: 12, sizeScale: 2 + in layer props is roughly equivalent to font-size: 24px in CSS. + + Texture size: internally, character positions in a text blob are calculated using the sizes of iconMapping, + which depends on how large each character is drawn into the font atlas. This is controlled by + fontSettings.fontSize (default 64) and most users do not set it manually. + These numbers are intended to be used in the vertex shader and never to be exposed to the end user. + + All surfaces exposed to the user should either use the pixel size or a multiplier relative to the pixel size. */ + /** Calculate the size and position of each character in a text string. + * Values are in texture size */ + transformParagraph(object, objectInfo) { + const { fontAtlasManager } = this.state; + const iconMapping = fontAtlasManager.mapping; + const getText = this.state.getText; + const { wordBreak, lineHeight, maxWidth } = this.props; + const paragraph = getText(object, objectInfo) || ""; + return transformParagraph(paragraph, lineHeight, wordBreak, maxWidth * fontAtlasManager.props.fontSize, iconMapping); + } + renderLayers() { + const { startIndices, numInstances, getText, fontAtlasManager: { scale: scale13, atlas, mapping }, styleVersion } = this.state; + const { data, _dataDiff, getPosition: getPosition2, getColor: getColor2, getSize, getAngle, getPixelOffset, getBackgroundColor, getBorderColor, getBorderWidth, backgroundPadding, background, billboard, fontSettings, outlineWidth, outlineColor, sizeScale, sizeUnits, sizeMinPixels, sizeMaxPixels, transitions, updateTriggers } = this.props; + const CharactersLayerClass = this.getSubLayerClass("characters", multi_icon_layer_default); + const BackgroundLayerClass = this.getSubLayerClass("background", text_background_layer_default); + return [ + background && new BackgroundLayerClass({ + // background props + getFillColor: getBackgroundColor, + getLineColor: getBorderColor, + getLineWidth: getBorderWidth, + padding: backgroundPadding, + // props shared with characters layer + getPosition: getPosition2, + getSize, + getAngle, + getPixelOffset, + billboard, + sizeScale, + sizeUnits, + sizeMinPixels, + sizeMaxPixels, + transitions: transitions && { + getPosition: transitions.getPosition, + getAngle: transitions.getAngle, + getSize: transitions.getSize, + getFillColor: transitions.getBackgroundColor, + getLineColor: transitions.getBorderColor, + getLineWidth: transitions.getBorderWidth, + getPixelOffset: transitions.getPixelOffset + } + }, this.getSubLayerProps({ + id: "background", + updateTriggers: { + getPosition: updateTriggers.getPosition, + getAngle: updateTriggers.getAngle, + getSize: updateTriggers.getSize, + getFillColor: updateTriggers.getBackgroundColor, + getLineColor: updateTriggers.getBorderColor, + getLineWidth: updateTriggers.getBorderWidth, + getPixelOffset: updateTriggers.getPixelOffset, + getBoundingRect: { + getText: updateTriggers.getText, + getTextAnchor: updateTriggers.getTextAnchor, + getAlignmentBaseline: updateTriggers.getAlignmentBaseline, + styleVersion + } + } + }), { + data: ( + // @ts-ignore (2339) attribute is not defined on all data types + data.attributes && data.attributes.background ? ( + // @ts-ignore (2339) attribute is not defined on all data types + { length: data.length, attributes: data.attributes.background } + ) : data + ), + _dataDiff, + // Maintain the same background behavior as <=8.3. Remove in v9? + autoHighlight: false, + getBoundingRect: this.getBoundingRect + }), + new CharactersLayerClass({ + sdf: fontSettings.sdf, + smoothing: Number.isFinite(fontSettings.smoothing) ? fontSettings.smoothing : DEFAULT_FONT_SETTINGS.smoothing, + outlineWidth: outlineWidth / (fontSettings.radius || DEFAULT_FONT_SETTINGS.radius), + outlineColor, + iconAtlas: atlas, + iconMapping: mapping, + getPosition: getPosition2, + getColor: getColor2, + getSize, + getAngle, + getPixelOffset, + billboard, + sizeScale: sizeScale * scale13, + sizeUnits, + sizeMinPixels: sizeMinPixels * scale13, + sizeMaxPixels: sizeMaxPixels * scale13, + transitions: transitions && { + getPosition: transitions.getPosition, + getAngle: transitions.getAngle, + getColor: transitions.getColor, + getSize: transitions.getSize, + getPixelOffset: transitions.getPixelOffset + } + }, this.getSubLayerProps({ + id: "characters", + updateTriggers: { + all: updateTriggers.getText, + getPosition: updateTriggers.getPosition, + getAngle: updateTriggers.getAngle, + getColor: updateTriggers.getColor, + getSize: updateTriggers.getSize, + getPixelOffset: updateTriggers.getPixelOffset, + getIconOffsets: { + getTextAnchor: updateTriggers.getTextAnchor, + getAlignmentBaseline: updateTriggers.getAlignmentBaseline, + styleVersion + } + } + }), { + data, + _dataDiff, + startIndices, + numInstances, + getIconOffsets: this.getIconOffsets, + getIcon: getText + }) + ]; + } + static set fontAtlasCacheLimit(limit) { + setFontAtlasCacheLimit(limit); + } +}; +TextLayer.defaultProps = defaultProps11; +TextLayer.layerName = "TextLayer"; +var text_layer_default = TextLayer; + +// node_modules/@deck.gl/layers/dist/geojson-layer/sub-layer-map.js +var POINT_LAYER = { + circle: { + type: scatterplot_layer_default, + props: { + filled: "filled", + stroked: "stroked", + lineWidthMaxPixels: "lineWidthMaxPixels", + lineWidthMinPixels: "lineWidthMinPixels", + lineWidthScale: "lineWidthScale", + lineWidthUnits: "lineWidthUnits", + pointRadiusMaxPixels: "radiusMaxPixels", + pointRadiusMinPixels: "radiusMinPixels", + pointRadiusScale: "radiusScale", + pointRadiusUnits: "radiusUnits", + pointAntialiasing: "antialiasing", + pointBillboard: "billboard", + getFillColor: "getFillColor", + getLineColor: "getLineColor", + getLineWidth: "getLineWidth", + getPointRadius: "getRadius" + } + }, + icon: { + type: icon_layer_default, + props: { + iconAtlas: "iconAtlas", + iconMapping: "iconMapping", + iconSizeMaxPixels: "sizeMaxPixels", + iconSizeMinPixels: "sizeMinPixels", + iconSizeScale: "sizeScale", + iconSizeUnits: "sizeUnits", + iconAlphaCutoff: "alphaCutoff", + iconBillboard: "billboard", + getIcon: "getIcon", + getIconAngle: "getAngle", + getIconColor: "getColor", + getIconPixelOffset: "getPixelOffset", + getIconSize: "getSize" + } + }, + text: { + type: text_layer_default, + props: { + textSizeMaxPixels: "sizeMaxPixels", + textSizeMinPixels: "sizeMinPixels", + textSizeScale: "sizeScale", + textSizeUnits: "sizeUnits", + textBackground: "background", + textBackgroundPadding: "backgroundPadding", + textFontFamily: "fontFamily", + textFontWeight: "fontWeight", + textLineHeight: "lineHeight", + textMaxWidth: "maxWidth", + textOutlineColor: "outlineColor", + textOutlineWidth: "outlineWidth", + textWordBreak: "wordBreak", + textCharacterSet: "characterSet", + textBillboard: "billboard", + textFontSettings: "fontSettings", + getText: "getText", + getTextAngle: "getAngle", + getTextColor: "getColor", + getTextPixelOffset: "getPixelOffset", + getTextSize: "getSize", + getTextAnchor: "getTextAnchor", + getTextAlignmentBaseline: "getAlignmentBaseline", + getTextBackgroundColor: "getBackgroundColor", + getTextBorderColor: "getBorderColor", + getTextBorderWidth: "getBorderWidth" + } + } +}; +var LINE_LAYER = { + type: path_layer_default, + props: { + lineWidthUnits: "widthUnits", + lineWidthScale: "widthScale", + lineWidthMinPixels: "widthMinPixels", + lineWidthMaxPixels: "widthMaxPixels", + lineJointRounded: "jointRounded", + lineCapRounded: "capRounded", + lineMiterLimit: "miterLimit", + lineBillboard: "billboard", + getLineColor: "getColor", + getLineWidth: "getWidth" + } +}; +var POLYGON_LAYER = { + type: solid_polygon_layer_default, + props: { + extruded: "extruded", + filled: "filled", + wireframe: "wireframe", + elevationScale: "elevationScale", + material: "material", + _full3d: "_full3d", + getElevation: "getElevation", + getFillColor: "getFillColor", + getLineColor: "getLineColor" + } +}; +function getDefaultProps({ type, props }) { + const result = {}; + for (const key in props) { + result[key] = type.defaultProps[props[key]]; + } + return result; +} +function forwardProps(layer, mapping) { + const { transitions, updateTriggers } = layer.props; + const result = { + updateTriggers: {}, + transitions: transitions && { + getPosition: transitions.geometry + } + }; + for (const sourceKey in mapping) { + const targetKey = mapping[sourceKey]; + let value = layer.props[sourceKey]; + if (sourceKey.startsWith("get")) { + value = layer.getSubLayerAccessor(value); + result.updateTriggers[targetKey] = updateTriggers[sourceKey]; + if (transitions) { + result.transitions[targetKey] = transitions[sourceKey]; + } + } + result[targetKey] = value; + } + return result; +} + +// node_modules/@deck.gl/layers/dist/geojson-layer/geojson.js +function getGeojsonFeatures(geojson) { + if (Array.isArray(geojson)) { + return geojson; + } + log_default.assert(geojson.type, "GeoJSON does not have type"); + switch (geojson.type) { + case "Feature": + return [geojson]; + case "FeatureCollection": + log_default.assert(Array.isArray(geojson.features), "GeoJSON does not have features array"); + return geojson.features; + default: + return [{ geometry: geojson }]; + } +} +function separateGeojsonFeatures(features, wrapFeature, dataRange = {}) { + const separated = { + pointFeatures: [], + lineFeatures: [], + polygonFeatures: [], + polygonOutlineFeatures: [] + }; + const { startRow = 0, endRow = features.length } = dataRange; + for (let featureIndex = startRow; featureIndex < endRow; featureIndex++) { + const feature = features[featureIndex]; + const { geometry } = feature; + if (!geometry) { + continue; + } + if (geometry.type === "GeometryCollection") { + log_default.assert(Array.isArray(geometry.geometries), "GeoJSON does not have geometries array"); + const { geometries } = geometry; + for (let i = 0; i < geometries.length; i++) { + const subGeometry = geometries[i]; + separateGeometry(subGeometry, separated, wrapFeature, feature, featureIndex); + } + } else { + separateGeometry(geometry, separated, wrapFeature, feature, featureIndex); + } + } + return separated; +} +function separateGeometry(geometry, separated, wrapFeature, sourceFeature, sourceFeatureIndex) { + const { type, coordinates } = geometry; + const { pointFeatures, lineFeatures, polygonFeatures, polygonOutlineFeatures } = separated; + if (!validateGeometry(type, coordinates)) { + log_default.warn(`${type} coordinates are malformed`)(); + return; + } + switch (type) { + case "Point": + pointFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + break; + case "MultiPoint": + coordinates.forEach((point) => { + pointFeatures.push(wrapFeature({ + geometry: { type: "Point", coordinates: point } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "LineString": + lineFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + break; + case "MultiLineString": + coordinates.forEach((path) => { + lineFeatures.push(wrapFeature({ + geometry: { type: "LineString", coordinates: path } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "Polygon": + polygonFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + coordinates.forEach((path) => { + polygonOutlineFeatures.push(wrapFeature({ + geometry: { type: "LineString", coordinates: path } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "MultiPolygon": + coordinates.forEach((polygon) => { + polygonFeatures.push(wrapFeature({ + geometry: { type: "Polygon", coordinates: polygon } + }, sourceFeature, sourceFeatureIndex)); + polygon.forEach((path) => { + polygonOutlineFeatures.push(wrapFeature({ + geometry: { type: "LineString", coordinates: path } + }, sourceFeature, sourceFeatureIndex)); + }); + }); + break; + default: + } +} +var COORDINATE_NEST_LEVEL = { + Point: 1, + MultiPoint: 2, + LineString: 2, + MultiLineString: 3, + Polygon: 3, + MultiPolygon: 4 +}; +function validateGeometry(type, coordinates) { + let nestLevel = COORDINATE_NEST_LEVEL[type]; + log_default.assert(nestLevel, `Unknown GeoJSON type ${type}`); + while (coordinates && --nestLevel > 0) { + coordinates = coordinates[0]; + } + return coordinates && Number.isFinite(coordinates[0]); +} + +// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-layer-props.js +function createEmptyLayerProps() { + return { + points: {}, + lines: {}, + polygons: {}, + polygonsOutline: {} + }; +} +function getCoordinates(f) { + return f.geometry.coordinates; +} +function createLayerPropsFromFeatures(features, featuresDiff) { + const layerProps = createEmptyLayerProps(); + const { pointFeatures, lineFeatures, polygonFeatures, polygonOutlineFeatures } = features; + layerProps.points.data = pointFeatures; + layerProps.points._dataDiff = featuresDiff.pointFeatures && (() => featuresDiff.pointFeatures); + layerProps.points.getPosition = getCoordinates; + layerProps.lines.data = lineFeatures; + layerProps.lines._dataDiff = featuresDiff.lineFeatures && (() => featuresDiff.lineFeatures); + layerProps.lines.getPath = getCoordinates; + layerProps.polygons.data = polygonFeatures; + layerProps.polygons._dataDiff = featuresDiff.polygonFeatures && (() => featuresDiff.polygonFeatures); + layerProps.polygons.getPolygon = getCoordinates; + layerProps.polygonsOutline.data = polygonOutlineFeatures; + layerProps.polygonsOutline._dataDiff = featuresDiff.polygonOutlineFeatures && (() => featuresDiff.polygonOutlineFeatures); + layerProps.polygonsOutline.getPath = getCoordinates; + return layerProps; +} +function createLayerPropsFromBinary(geojsonBinary, encodePickingColor) { + const layerProps = createEmptyLayerProps(); + const { points, lines, polygons } = geojsonBinary; + const customPickingColors = calculatePickingColors(geojsonBinary, encodePickingColor); + layerProps.points.data = { + length: points.positions.value.length / points.positions.size, + attributes: { + ...points.attributes, + getPosition: points.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.points + } + }, + properties: points.properties, + numericProps: points.numericProps, + featureIds: points.featureIds + }; + layerProps.lines.data = { + length: lines.pathIndices.value.length - 1, + startIndices: lines.pathIndices.value, + attributes: { + ...lines.attributes, + getPath: lines.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.lines + } + }, + properties: lines.properties, + numericProps: lines.numericProps, + featureIds: lines.featureIds + }; + layerProps.lines._pathType = "open"; + layerProps.polygons.data = { + length: polygons.polygonIndices.value.length - 1, + startIndices: polygons.polygonIndices.value, + attributes: { + ...polygons.attributes, + getPolygon: polygons.positions, + pickingColors: { + size: 3, + value: customPickingColors.polygons + } + }, + properties: polygons.properties, + numericProps: polygons.numericProps, + featureIds: polygons.featureIds + }; + layerProps.polygons._normalize = false; + if (polygons.triangles) { + layerProps.polygons.data.attributes.indices = polygons.triangles.value; + } + layerProps.polygonsOutline.data = { + length: polygons.primitivePolygonIndices.value.length - 1, + startIndices: polygons.primitivePolygonIndices.value, + attributes: { + ...polygons.attributes, + getPath: polygons.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.polygons + } + }, + properties: polygons.properties, + numericProps: polygons.numericProps, + featureIds: polygons.featureIds + }; + layerProps.polygonsOutline._pathType = "open"; + return layerProps; +} + +// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-layer.js +var FEATURE_TYPES = ["points", "linestrings", "polygons"]; +var defaultProps12 = { + ...getDefaultProps(POINT_LAYER.circle), + ...getDefaultProps(POINT_LAYER.icon), + ...getDefaultProps(POINT_LAYER.text), + ...getDefaultProps(LINE_LAYER), + ...getDefaultProps(POLYGON_LAYER), + // Overwrite sub layer defaults + stroked: true, + filled: true, + extruded: false, + wireframe: false, + _full3d: false, + iconAtlas: { type: "object", value: null }, + iconMapping: { type: "object", value: {} }, + getIcon: { type: "accessor", value: (f) => f.properties.icon }, + getText: { type: "accessor", value: (f) => f.properties.text }, + // Self props + pointType: "circle", + // TODO: deprecated, remove in v9 + getRadius: { deprecatedFor: "getPointRadius" } +}; +var GeoJsonLayer = class extends composite_layer_default { + initializeState() { + this.state = { + layerProps: {}, + features: {}, + featuresDiff: {} + }; + } + updateState({ props, changeFlags }) { + if (!changeFlags.dataChanged) { + return; + } + const { data } = this.props; + const binary = data && "points" in data && "polygons" in data && "lines" in data; + this.setState({ binary }); + if (binary) { + this._updateStateBinary({ props, changeFlags }); + } else { + this._updateStateJSON({ props, changeFlags }); + } + } + _updateStateBinary({ props, changeFlags }) { + const layerProps = createLayerPropsFromBinary(props.data, this.encodePickingColor); + this.setState({ layerProps }); + } + _updateStateJSON({ props, changeFlags }) { + const features = getGeojsonFeatures(props.data); + const wrapFeature = this.getSubLayerRow.bind(this); + let newFeatures = {}; + const featuresDiff = {}; + if (Array.isArray(changeFlags.dataChanged)) { + const oldFeatures = this.state.features; + for (const key in oldFeatures) { + newFeatures[key] = oldFeatures[key].slice(); + featuresDiff[key] = []; + } + for (const dataRange of changeFlags.dataChanged) { + const partialFeatures = separateGeojsonFeatures(features, wrapFeature, dataRange); + for (const key in oldFeatures) { + featuresDiff[key].push(replaceInRange({ + data: newFeatures[key], + getIndex: (f) => f.__source.index, + dataRange, + replace: partialFeatures[key] + })); + } + } + } else { + newFeatures = separateGeojsonFeatures(features, wrapFeature); + } + const layerProps = createLayerPropsFromFeatures(newFeatures, featuresDiff); + this.setState({ + features: newFeatures, + featuresDiff, + layerProps + }); + } + getPickingInfo(params) { + const info = super.getPickingInfo(params); + const { index: index2, sourceLayer } = info; + info.featureType = FEATURE_TYPES.find((ft) => sourceLayer.id.startsWith(`${this.id}-${ft}-`)); + if (index2 >= 0 && sourceLayer.id.startsWith(`${this.id}-points-text`) && this.state.binary) { + info.index = this.props.data.points.globalFeatureIds.value[index2]; + } + return info; + } + _updateAutoHighlight(info) { + const pointLayerIdPrefix = `${this.id}-points-`; + const sourceIsPoints = info.featureType === "points"; + for (const layer of this.getSubLayers()) { + if (layer.id.startsWith(pointLayerIdPrefix) === sourceIsPoints) { + layer.updateAutoHighlight(info); + } + } + } + _renderPolygonLayer() { + const { extruded, wireframe } = this.props; + const { layerProps } = this.state; + const id = "polygons-fill"; + const PolygonFillLayer = this.shouldRenderSubLayer(id, layerProps.polygons?.data) && this.getSubLayerClass(id, POLYGON_LAYER.type); + if (PolygonFillLayer) { + const forwardedProps = forwardProps(this, POLYGON_LAYER.props); + const useLineColor = extruded && wireframe; + if (!useLineColor) { + delete forwardedProps.getLineColor; + } + forwardedProps.updateTriggers.lineColors = useLineColor; + return new PolygonFillLayer(forwardedProps, this.getSubLayerProps({ + id, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.polygons); + } + return null; + } + _renderLineLayers() { + const { extruded, stroked } = this.props; + const { layerProps } = this.state; + const polygonStrokeLayerId = "polygons-stroke"; + const lineStringsLayerId = "linestrings"; + const PolygonStrokeLayer = !extruded && stroked && this.shouldRenderSubLayer(polygonStrokeLayerId, layerProps.polygonsOutline?.data) && this.getSubLayerClass(polygonStrokeLayerId, LINE_LAYER.type); + const LineStringsLayer = this.shouldRenderSubLayer(lineStringsLayerId, layerProps.lines?.data) && this.getSubLayerClass(lineStringsLayerId, LINE_LAYER.type); + if (PolygonStrokeLayer || LineStringsLayer) { + const forwardedProps = forwardProps(this, LINE_LAYER.props); + return [ + PolygonStrokeLayer && new PolygonStrokeLayer(forwardedProps, this.getSubLayerProps({ + id: polygonStrokeLayerId, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.polygonsOutline), + LineStringsLayer && new LineStringsLayer(forwardedProps, this.getSubLayerProps({ + id: lineStringsLayerId, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.lines) + ]; + } + return null; + } + _renderPointLayers() { + const { pointType } = this.props; + const { layerProps, binary } = this.state; + let { highlightedObjectIndex } = this.props; + if (!binary && Number.isFinite(highlightedObjectIndex)) { + highlightedObjectIndex = layerProps.points.data.findIndex((d) => d.__source.index === highlightedObjectIndex); + } + const types = new Set(pointType.split("+")); + const pointLayers = []; + for (const type of types) { + const id = `points-${type}`; + const PointLayerMapping = POINT_LAYER[type]; + const PointsLayer = PointLayerMapping && this.shouldRenderSubLayer(id, layerProps.points?.data) && this.getSubLayerClass(id, PointLayerMapping.type); + if (PointsLayer) { + const forwardedProps = forwardProps(this, PointLayerMapping.props); + let pointsLayerProps = layerProps.points; + if (type === "text" && binary) { + const { instancePickingColors, ...rest } = pointsLayerProps.data.attributes; + pointsLayerProps = { + ...pointsLayerProps, + // @ts-expect-error TODO - type binary data + data: { ...pointsLayerProps.data, attributes: rest } + }; + } + pointLayers.push(new PointsLayer(forwardedProps, this.getSubLayerProps({ + id, + updateTriggers: forwardedProps.updateTriggers, + highlightedObjectIndex + }), pointsLayerProps)); + } + } + return pointLayers; + } + renderLayers() { + const { extruded } = this.props; + const polygonFillLayer = this._renderPolygonLayer(); + const lineLayers = this._renderLineLayers(); + const pointLayers = this._renderPointLayers(); + return [ + // If not extruded: flat fill layer is drawn below outlines + !extruded && polygonFillLayer, + lineLayers, + pointLayers, + // If extruded: draw fill layer last for correct blending behavior + extruded && polygonFillLayer + ]; + } + getSubLayerAccessor(accessor) { + const { binary } = this.state; + if (!binary || typeof accessor !== "function") { + return super.getSubLayerAccessor(accessor); + } + return (object, info) => { + const { data, index: index2 } = info; + const feature = binaryToFeatureForAccesor(data, index2); + return accessor(feature, info); + }; + } +}; +GeoJsonLayer.layerName = "GeoJsonLayer"; +GeoJsonLayer.defaultProps = defaultProps12; +var geojson_layer_default = GeoJsonLayer; + +// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tile-2d-header.js +var Tile2DHeader = class { + constructor(index2) { + this.index = index2; + this.isVisible = false; + this.isSelected = false; + this.parent = null; + this.children = []; + this.content = null; + this._loader = void 0; + this._abortController = null; + this._loaderId = 0; + this._isLoaded = false; + this._isCancelled = false; + this._needsReload = false; + } + /** @deprecated use `boundingBox` instead */ + get bbox() { + return this._bbox; + } + // TODO - remove in v9 + set bbox(value) { + if (this._bbox) + return; + this._bbox = value; + if ("west" in value) { + this.boundingBox = [ + [value.west, value.south], + [value.east, value.north] + ]; + } else { + this.boundingBox = [ + [value.left, value.top], + [value.right, value.bottom] + ]; + } + } + get data() { + return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content; + } + get isLoaded() { + return this._isLoaded && !this._needsReload; + } + get isLoading() { + return Boolean(this._loader) && !this._isCancelled; + } + get needsReload() { + return this._needsReload || this._isCancelled; + } + get byteLength() { + const result = this.content ? this.content.byteLength : 0; + if (!Number.isFinite(result)) { + console.error("byteLength not defined in tile data"); + } + return result; + } + /* eslint-disable max-statements */ + async _loadData({ getData, requestScheduler, onLoad, onError }) { + const { index: index2, id, bbox, userData, zoom } = this; + const loaderId = this._loaderId; + this._abortController = new AbortController(); + const { signal } = this._abortController; + const requestToken = await requestScheduler.scheduleRequest(this, (tile) => { + return tile.isSelected ? 1 : -1; + }); + if (!requestToken) { + this._isCancelled = true; + return; + } + if (this._isCancelled) { + requestToken.done(); + return; + } + let tileData = null; + let error; + try { + tileData = await getData({ index: index2, id, bbox, userData, zoom, signal }); + } catch (err) { + error = err || true; + } finally { + requestToken.done(); + } + if (loaderId !== this._loaderId) { + return; + } + this._loader = void 0; + this.content = tileData; + if (this._isCancelled && !tileData) { + this._isLoaded = false; + return; + } + this._isLoaded = true; + this._isCancelled = false; + if (error) { + onError(error, this); + } else { + onLoad(this); + } + } + loadData(opts) { + this._isLoaded = false; + this._isCancelled = false; + this._needsReload = false; + this._loaderId++; + this._loader = this._loadData(opts); + return this._loader; + } + setNeedsReload() { + if (this.isLoading) { + this.abort(); + this._loader = void 0; + } + this._needsReload = true; + } + abort() { + if (this.isLoaded) { + return; + } + this._isCancelled = true; + this._abortController?.abort(); + } +}; + +// node_modules/@math.gl/culling/dist/constants.js +var INTERSECTION = { + OUTSIDE: -1, + // Represents that an object is not contained within the frustum. + INTERSECTING: 0, + // Represents that an object intersects one of the frustum's planes. + INSIDE: 1 + // Represents that an object is fully within the frustum. +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/common.js +var RADIANS_TO_DEGREES4 = 1 / Math.PI * 180; +var DEGREES_TO_RADIANS6 = 1 / 180 * Math.PI; +var DEFAULT_CONFIG2 = { + EPSILON: 1e-12, + debug: false, + precision: 4, + printTypes: false, + printDegrees: false, + printRowMajor: true, + _cartographicRadians: false +}; +globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG2 } }; +var config2 = globalThis.mathgl.config; +function formatValue2(value, { precision = config2.precision } = {}) { + value = round10(value); + return `${parseFloat(value.toPrecision(precision))}`; +} +function isArray4(value) { + return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); +} +function equals10(a, b, epsilon) { + const oldEpsilon = config2.EPSILON; + if (epsilon) { + config2.EPSILON = epsilon; + } + try { + if (a === b) { + return true; + } + if (isArray4(a) && isArray4(b)) { + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; ++i) { + if (!equals10(a[i], b[i])) { + return false; + } + } + return true; + } + if (a && a.equals) { + return a.equals(b); + } + if (b && b.equals) { + return b.equals(a); + } + if (typeof a === "number" && typeof b === "number") { + return Math.abs(a - b) <= config2.EPSILON * Math.max(1, Math.abs(a), Math.abs(b)); + } + return false; + } finally { + config2.EPSILON = oldEpsilon; + } +} +function round10(value) { + return Math.round(value / config2.EPSILON) * config2.EPSILON; +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/math-array.js +var MathArray2 = class extends Array { + // Common methods + /** + * Clone the current object + * @returns a new copy of this object + */ + clone() { + return new this.constructor().copy(this); + } + fromArray(array, offset = 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = array[i + offset]; + } + return this.check(); + } + toArray(targetArray = [], offset = 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + targetArray[offset + i] = this[i]; + } + return targetArray; + } + toObject(targetObject) { + return targetObject; + } + from(arrayOrObject) { + return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : ( + // @ts-ignore + this.fromObject(arrayOrObject) + ); + } + to(arrayOrObject) { + if (arrayOrObject === this) { + return this; + } + return isArray4(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); + } + toTarget(target) { + return target ? this.to(target) : this; + } + /** @deprecated */ + toFloat32Array() { + return new Float32Array(this); + } + toString() { + return this.formatString(config2); + } + /** Formats string according to options */ + formatString(opts) { + let string = ""; + for (let i = 0; i < this.ELEMENTS; ++i) { + string += (i > 0 ? ", " : "") + formatValue2(this[i], opts); + } + return `${opts.printTypes ? this.constructor.name : ""}[${string}]`; + } + equals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i = 0; i < this.ELEMENTS; ++i) { + if (!equals10(this[i], array[i])) { + return false; + } + } + return true; + } + exactEquals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i = 0; i < this.ELEMENTS; ++i) { + if (this[i] !== array[i]) { + return false; + } + } + return true; + } + // Modifiers + /** Negates all values in this object */ + negate() { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = -this[i]; + } + return this.check(); + } + lerp(a, b, t) { + if (t === void 0) { + return this.lerp(this, a, b); + } + for (let i = 0; i < this.ELEMENTS; ++i) { + const ai = a[i]; + const endValue = typeof b === "number" ? b : b[i]; + this[i] = ai + t * (endValue - ai); + } + return this.check(); + } + /** Minimal */ + min(vector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(vector[i], this[i]); + } + return this.check(); + } + /** Maximal */ + max(vector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.max(vector[i], this[i]); + } + return this.check(); + } + clamp(minVector, maxVector) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]); + } + return this.check(); + } + add(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] += vector[i]; + } + } + return this.check(); + } + subtract(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] -= vector[i]; + } + } + return this.check(); + } + scale(scale13) { + if (typeof scale13 === "number") { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scale13; + } + } else { + for (let i = 0; i < this.ELEMENTS && i < scale13.length; ++i) { + this[i] *= scale13[i]; + } + } + return this.check(); + } + /** + * Multiplies all elements by `scale` + * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor" + */ + multiplyByScalar(scalar) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scalar; + } + return this.check(); + } + // Debug checks + /** Throws an error if array length is incorrect or contains illegal values */ + check() { + if (config2.debug && !this.validate()) { + throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`); + } + return this; + } + /** Returns false if the array length is incorrect or contains illegal values */ + validate() { + let valid = this.length === this.ELEMENTS; + for (let i = 0; i < this.ELEMENTS; ++i) { + valid = valid && Number.isFinite(this[i]); + } + return valid; + } + // three.js compatibility + /** @deprecated */ + sub(a) { + return this.subtract(a); + } + /** @deprecated */ + setScalar(a) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = a; + } + return this.check(); + } + /** @deprecated */ + addScalar(a) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] += a; + } + return this.check(); + } + /** @deprecated */ + subScalar(a) { + return this.addScalar(-a); + } + /** @deprecated */ + multiplyScalar(scalar) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= scalar; + } + return this.check(); + } + /** @deprecated */ + divideScalar(a) { + return this.multiplyByScalar(1 / a); + } + /** @deprecated */ + clampScalar(min7, max7) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] = Math.min(Math.max(this[i], min7), max7); + } + return this.check(); + } + /** @deprecated */ + get elements() { + return this; + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/validators.js +function validateVector2(v, length10) { + if (v.length !== length10) { + return false; + } + for (let i = 0; i < v.length; ++i) { + if (!Number.isFinite(v[i])) { + return false; + } + } + return true; +} +function checkNumber2(value) { + if (!Number.isFinite(value)) { + throw new Error(`Invalid number ${JSON.stringify(value)}`); + } + return value; +} +function checkVector2(v, length10, callerName = "") { + if (config2.debug && !validateVector2(v, length10)) { + throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`); + } + return v; +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/assert.js +function assert10(condition, message2) { + if (!condition) { + throw new Error(`math.gl assertion ${message2}`); + } +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/vector.js +var Vector2 = class extends MathArray2 { + // ACCESSORS + get x() { + return this[0]; + } + set x(value) { + this[0] = checkNumber2(value); + } + get y() { + return this[1]; + } + set y(value) { + this[1] = checkNumber2(value); + } + /** + * Returns the length of the vector from the origin to the point described by this vector + * + * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements + * Instead we provide `len` and `magnitude` + */ + len() { + return Math.sqrt(this.lengthSquared()); + } + /** + * Returns the length of the vector from the origin to the point described by this vector + */ + magnitude() { + return this.len(); + } + /** + * Returns the squared length of the vector from the origin to the point described by this vector + */ + lengthSquared() { + let length10 = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + length10 += this[i] * this[i]; + } + return length10; + } + /** + * Returns the squared length of the vector from the origin to the point described by this vector + */ + magnitudeSquared() { + return this.lengthSquared(); + } + distance(mathArray) { + return Math.sqrt(this.distanceSquared(mathArray)); + } + distanceSquared(mathArray) { + let length10 = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + const dist7 = this[i] - mathArray[i]; + length10 += dist7 * dist7; + } + return checkNumber2(length10); + } + dot(mathArray) { + let product = 0; + for (let i = 0; i < this.ELEMENTS; ++i) { + product += this[i] * mathArray[i]; + } + return checkNumber2(product); + } + // MODIFIERS + normalize() { + const length10 = this.magnitude(); + if (length10 !== 0) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] /= length10; + } + } + return this.check(); + } + multiply(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] *= vector[i]; + } + } + return this.check(); + } + divide(...vectors) { + for (const vector of vectors) { + for (let i = 0; i < this.ELEMENTS; ++i) { + this[i] /= vector[i]; + } + } + return this.check(); + } + // THREE.js compatibility + lengthSq() { + return this.lengthSquared(); + } + distanceTo(vector) { + return this.distance(vector); + } + distanceToSquared(vector) { + return this.distanceSquared(vector); + } + getComponent(i) { + assert10(i >= 0 && i < this.ELEMENTS, "index is out of range"); + return checkNumber2(this[i]); + } + setComponent(i, value) { + assert10(i >= 0 && i < this.ELEMENTS, "index is out of range"); + this[i] = value; + return this.check(); + } + addVectors(a, b) { + return this.copy(a).add(b); + } + subVectors(a, b) { + return this.copy(a).subtract(b); + } + multiplyVectors(a, b) { + return this.copy(a).multiply(b); + } + addScaledVector(a, b) { + return this.add(new this.constructor(a).multiplyScalar(b)); + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/common.js +var EPSILON4 = 1e-6; +var ARRAY_TYPE3 = typeof Float32Array !== "undefined" ? Float32Array : Array; +var degree3 = Math.PI / 180; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec2.js +function create9() { + const out = new ARRAY_TYPE3(2); + if (ARRAY_TYPE3 != Float32Array) { + out[0] = 0; + out[1] = 0; + } + return out; +} +function transformMat35(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[3] * y + m[6]; + out[1] = m[1] * x + m[4] * y + m[7]; + return out; +} +var forEach8 = function() { + const vec = create9(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 2; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + } + return a; + }; +}(); + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js +function vec3_transformMat4AsVector2(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = m[3] * x + m[7] * y + m[11] * z || 1; + out[0] = (m[0] * x + m[4] * y + m[8] * z) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z) / w; + return out; +} +function vec3_transformMat22(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + out[2] = a[2]; + return out; +} +function vec4_transformMat2(out, a, m) { + const x = a[0]; + const y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function vec4_transformMat3(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + out[0] = m[0] * x + m[3] * y + m[6] * z; + out[1] = m[1] * x + m[4] * y + m[7] * z; + out[2] = m[2] * x + m[5] * y + m[8] * z; + out[3] = a[3]; + return out; +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec3.js +function create10() { + const out = new ARRAY_TYPE3(3); + if (ARRAY_TYPE3 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} +function length7(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function fromValues9(x, y, z) { + const out = new ARRAY_TYPE3(3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function normalize8(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let len8 = x * x + y * y + z * z; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = a[0] * len8; + out[1] = a[1] * len8; + out[2] = a[2] * len8; + return out; +} +function dot7(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +function cross7(out, a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} +function transformMat47(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + let w = m[3] * x + m[7] * y + m[11] * z + m[15]; + w = w || 1; + out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; + return out; +} +function transformMat36(out, a, m) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + out[0] = x * m[0] + y * m[3] + z * m[6]; + out[1] = x * m[1] + y * m[4] + z * m[7]; + out[2] = x * m[2] + y * m[5] + z * m[8]; + return out; +} +function transformQuat5(out, a, q) { + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const x = a[0]; + const y = a[1]; + const z = a[2]; + let uvx = qy * z - qz * y; + let uvy = qz * x - qx * z; + let uvz = qx * y - qy * x; + let uuvx = qy * uvz - qz * uvy; + let uuvy = qz * uvx - qx * uvz; + let uuvz = qx * uvy - qy * uvx; + const w2 = qw * 2; + uvx *= w2; + uvy *= w2; + uvz *= w2; + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + out[0] = x + uvx + uuvx; + out[1] = y + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; +} +function rotateX5(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0]; + r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); + r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateY5(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); + r[1] = p[1]; + r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function rotateZ5(out, a, b, rad) { + const p = []; + const r = []; + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); + r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); + r[2] = p[2]; + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + return out; +} +function angle5(a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); + const cosine = mag && dot7(a, b) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); +} +var len7 = length7; +var forEach9 = function() { + const vec = create10(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 3; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + } + return a; + }; +}(); + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/vector3.js +var ORIGIN2 = [0, 0, 0]; +var ZERO3; +var Vector32 = class _Vector3 extends Vector2 { + static get ZERO() { + if (!ZERO3) { + ZERO3 = new _Vector3(0, 0, 0); + Object.freeze(ZERO3); + } + return ZERO3; + } + /** + * @class + * @param x + * @param y + * @param z + */ + constructor(x = 0, y = 0, z = 0) { + super(-0, -0, -0); + if (arguments.length === 1 && isArray4(x)) { + this.copy(x); + } else { + if (config2.debug) { + checkNumber2(x); + checkNumber2(y); + checkNumber2(z); + } + this[0] = x; + this[1] = y; + this[2] = z; + } + } + set(x, y, z) { + this[0] = x; + this[1] = y; + this[2] = z; + return this.check(); + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + return this.check(); + } + fromObject(object) { + if (config2.debug) { + checkNumber2(object.x); + checkNumber2(object.y); + checkNumber2(object.z); + } + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + return this.check(); + } + toObject(object) { + object.x = this[0]; + object.y = this[1]; + object.z = this[2]; + return object; + } + // Getters/setters + get ELEMENTS() { + return 3; + } + get z() { + return this[2]; + } + set z(value) { + this[2] = checkNumber2(value); + } + // ACCESSORS + angle(vector) { + return angle5(this, vector); + } + // MODIFIERS + cross(vector) { + cross7(this, this, vector); + return this.check(); + } + rotateX({ radians: radians3, origin = ORIGIN2 }) { + rotateX5(this, this, origin, radians3); + return this.check(); + } + rotateY({ radians: radians3, origin = ORIGIN2 }) { + rotateY5(this, this, origin, radians3); + return this.check(); + } + rotateZ({ radians: radians3, origin = ORIGIN2 }) { + rotateZ5(this, this, origin, radians3); + return this.check(); + } + // Transforms + // transforms as point (4th component is implicitly 1) + transform(matrix4) { + return this.transformAsPoint(matrix4); + } + // transforms as point (4th component is implicitly 1) + transformAsPoint(matrix4) { + transformMat47(this, this, matrix4); + return this.check(); + } + // transforms as vector (4th component is implicitly 0, ignores translation. slightly faster) + transformAsVector(matrix4) { + vec3_transformMat4AsVector2(this, this, matrix4); + return this.check(); + } + transformByMatrix3(matrix3) { + transformMat36(this, this, matrix3); + return this.check(); + } + transformByMatrix2(matrix2) { + vec3_transformMat22(this, this, matrix2); + return this.check(); + } + transformByQuaternion(quaternion) { + transformQuat5(this, this, quaternion); + return this.check(); + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/vector4.js +var ZERO4; +var Vector4 = class _Vector4 extends Vector2 { + static get ZERO() { + if (!ZERO4) { + ZERO4 = new _Vector4(0, 0, 0, 0); + Object.freeze(ZERO4); + } + return ZERO4; + } + constructor(x = 0, y = 0, z = 0, w = 0) { + super(-0, -0, -0, -0); + if (isArray4(x) && arguments.length === 1) { + this.copy(x); + } else { + if (config2.debug) { + checkNumber2(x); + checkNumber2(y); + checkNumber2(z); + checkNumber2(w); + } + this[0] = x; + this[1] = y; + this[2] = z; + this[3] = w; + } + } + set(x, y, z, w) { + this[0] = x; + this[1] = y; + this[2] = z; + this[3] = w; + return this.check(); + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + return this.check(); + } + fromObject(object) { + if (config2.debug) { + checkNumber2(object.x); + checkNumber2(object.y); + checkNumber2(object.z); + checkNumber2(object.w); + } + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + this[3] = object.w; + return this; + } + toObject(object) { + object.x = this[0]; + object.y = this[1]; + object.z = this[2]; + object.w = this[3]; + return object; + } + // Getters/setters + /* eslint-disable no-multi-spaces, brace-style, no-return-assign */ + get ELEMENTS() { + return 4; + } + get z() { + return this[2]; + } + set z(value) { + this[2] = checkNumber2(value); + } + get w() { + return this[3]; + } + set w(value) { + this[3] = checkNumber2(value); + } + transform(matrix4) { + transformMat47(this, this, matrix4); + return this.check(); + } + transformByMatrix3(matrix3) { + vec4_transformMat3(this, this, matrix3); + return this.check(); + } + transformByMatrix2(matrix2) { + vec4_transformMat2(this, this, matrix2); + return this.check(); + } + transformByQuaternion(quaternion) { + transformQuat5(this, this, quaternion); + return this.check(); + } + // three.js compatibility + applyMatrix4(m) { + m.transform(this, this); + return this; + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/matrix.js +var Matrix2 = class extends MathArray2 { + // fromObject(object) { + // const array = object.elements; + // return this.fromRowMajor(array); + // } + // toObject(object) { + // const array = object.elements; + // this.toRowMajor(array); + // return object; + // } + // TODO better override formatString? + toString() { + let string = "["; + if (config2.printRowMajor) { + string += "row-major:"; + for (let row = 0; row < this.RANK; ++row) { + for (let col = 0; col < this.RANK; ++col) { + string += ` ${this[col * this.RANK + row]}`; + } + } + } else { + string += "column-major:"; + for (let i = 0; i < this.ELEMENTS; ++i) { + string += ` ${this[i]}`; + } + } + string += "]"; + return string; + } + getElementIndex(row, col) { + return col * this.RANK + row; + } + // By default assumes row major indices + getElement(row, col) { + return this[col * this.RANK + row]; + } + // By default assumes row major indices + setElement(row, col, value) { + this[col * this.RANK + row] = checkNumber2(value); + return this; + } + getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { + const firstIndex = columnIndex * this.RANK; + for (let i = 0; i < this.RANK; ++i) { + result[i] = this[firstIndex + i]; + } + return result; + } + setColumn(columnIndex, columnVector) { + const firstIndex = columnIndex * this.RANK; + for (let i = 0; i < this.RANK; ++i) { + this[firstIndex + i] = columnVector[i]; + } + return this; + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/mat3.js +function create11() { + const out = new ARRAY_TYPE3(9); + if (ARRAY_TYPE3 != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + } + out[0] = 1; + out[4] = 1; + out[8] = 1; + return out; +} +function transpose3(out, a) { + if (out === a) { + const a01 = a[1]; + const a02 = a[2]; + const a12 = a[5]; + out[1] = a[3]; + out[2] = a[6]; + out[3] = a01; + out[5] = a[7]; + out[6] = a02; + out[7] = a12; + } else { + out[0] = a[0]; + out[1] = a[3]; + out[2] = a[6]; + out[3] = a[1]; + out[4] = a[4]; + out[5] = a[7]; + out[6] = a[2]; + out[7] = a[5]; + out[8] = a[8]; + } + return out; +} +function invert3(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[3]; + const a11 = a[4]; + const a12 = a[5]; + const a20 = a[6]; + const a21 = a[7]; + const a22 = a[8]; + const b01 = a22 * a11 - a12 * a21; + const b11 = -a22 * a10 + a12 * a20; + const b21 = a21 * a10 - a11 * a20; + let det = a00 * b01 + a01 * b11 + a02 * b21; + if (!det) { + return null; + } + det = 1 / det; + out[0] = b01 * det; + out[1] = (-a22 * a01 + a02 * a21) * det; + out[2] = (a12 * a01 - a02 * a11) * det; + out[3] = b11 * det; + out[4] = (a22 * a00 - a02 * a20) * det; + out[5] = (-a12 * a00 + a02 * a10) * det; + out[6] = b21 * det; + out[7] = (-a21 * a00 + a01 * a20) * det; + out[8] = (a11 * a00 - a01 * a10) * det; + return out; +} +function determinant3(a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[3]; + const a11 = a[4]; + const a12 = a[5]; + const a20 = a[6]; + const a21 = a[7]; + const a22 = a[8]; + return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20); +} +function multiply9(out, a, b) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[3]; + const a11 = a[4]; + const a12 = a[5]; + const a20 = a[6]; + const a21 = a[7]; + const a22 = a[8]; + const b00 = b[0]; + const b01 = b[1]; + const b02 = b[2]; + const b10 = b[3]; + const b11 = b[4]; + const b12 = b[5]; + const b20 = b[6]; + const b21 = b[7]; + const b22 = b[8]; + out[0] = b00 * a00 + b01 * a10 + b02 * a20; + out[1] = b00 * a01 + b01 * a11 + b02 * a21; + out[2] = b00 * a02 + b01 * a12 + b02 * a22; + out[3] = b10 * a00 + b11 * a10 + b12 * a20; + out[4] = b10 * a01 + b11 * a11 + b12 * a21; + out[5] = b10 * a02 + b11 * a12 + b12 * a22; + out[6] = b20 * a00 + b21 * a10 + b22 * a20; + out[7] = b20 * a01 + b21 * a11 + b22 * a21; + out[8] = b20 * a02 + b21 * a12 + b22 * a22; + return out; +} +function translate3(out, a, v) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[3]; + const a11 = a[4]; + const a12 = a[5]; + const a20 = a[6]; + const a21 = a[7]; + const a22 = a[8]; + const x = v[0]; + const y = v[1]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a10; + out[4] = a11; + out[5] = a12; + out[6] = x * a00 + y * a10 + a20; + out[7] = x * a01 + y * a11 + a21; + out[8] = x * a02 + y * a12 + a22; + return out; +} +function rotate5(out, a, rad) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[3]; + const a11 = a[4]; + const a12 = a[5]; + const a20 = a[6]; + const a21 = a[7]; + const a22 = a[8]; + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c * a00 + s * a10; + out[1] = c * a01 + s * a11; + out[2] = c * a02 + s * a12; + out[3] = c * a10 - s * a00; + out[4] = c * a11 - s * a01; + out[5] = c * a12 - s * a02; + out[6] = a20; + out[7] = a21; + out[8] = a22; + return out; +} +function scale9(out, a, v) { + const x = v[0]; + const y = v[1]; + out[0] = x * a[0]; + out[1] = x * a[1]; + out[2] = x * a[2]; + out[3] = y * a[3]; + out[4] = y * a[4]; + out[5] = y * a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + return out; +} +function fromQuat4(out, q) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const yx = y * x2; + const yy = y * y2; + const zx = z * x2; + const zy = z * y2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - yy - zz; + out[3] = yx - wz; + out[6] = zx + wy; + out[1] = yx + wz; + out[4] = 1 - xx - zz; + out[7] = zy - wx; + out[2] = zx - wy; + out[5] = zy + wx; + out[8] = 1 - xx - yy; + return out; +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/matrix3.js +var INDICES2; +(function(INDICES3) { + INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; + INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; + INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; + INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0"; + INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1"; + INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2"; + INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0"; + INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1"; + INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2"; +})(INDICES2 || (INDICES2 = {})); +var IDENTITY_MATRIX3 = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]); +var Matrix3 = class extends Matrix2 { + static get IDENTITY() { + return getIdentityMatrix2(); + } + static get ZERO() { + return getZeroMatrix2(); + } + get ELEMENTS() { + return 9; + } + get RANK() { + return 3; + } + get INDICES() { + return INDICES2; + } + constructor(array, ...args) { + super(-0, -0, -0, -0, -0, -0, -0, -0, -0); + if (arguments.length === 1 && Array.isArray(array)) { + this.copy(array); + } else if (args.length > 0) { + this.copy([array, ...args]); + } else { + this.identity(); + } + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + this[4] = array[4]; + this[5] = array[5]; + this[6] = array[6]; + this[7] = array[7]; + this[8] = array[8]; + return this.check(); + } + // Constructors + identity() { + return this.copy(IDENTITY_MATRIX3); + } + /** + * + * @param object + * @returns self + */ + // eslint-disable-next-line @typescript-eslint/no-unused-vars + fromObject(object) { + return this.check(); + } + /** Calculates a 3x3 matrix from the given quaternion + * q quat Quaternion to create matrix from + */ + fromQuaternion(q) { + fromQuat4(this, q); + return this.check(); + } + /** + * accepts column major order, stores in column major order + */ + // eslint-disable-next-line max-params + set(m00, m10, m20, m01, m11, m21, m02, m12, m22) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m01; + this[4] = m11; + this[5] = m21; + this[6] = m02; + this[7] = m12; + this[8] = m22; + return this.check(); + } + /** + * accepts row major order, stores as column major + */ + // eslint-disable-next-line max-params + setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m01; + this[4] = m11; + this[5] = m21; + this[6] = m02; + this[7] = m12; + this[8] = m22; + return this.check(); + } + // Accessors + determinant() { + return determinant3(this); + } + // Modifiers + transpose() { + transpose3(this, this); + return this.check(); + } + /** Invert a matrix. Note that this can fail if the matrix is not invertible */ + invert() { + invert3(this, this); + return this.check(); + } + // Operations + multiplyLeft(a) { + multiply9(this, a, this); + return this.check(); + } + multiplyRight(a) { + multiply9(this, this, a); + return this.check(); + } + rotate(radians3) { + rotate5(this, this, radians3); + return this.check(); + } + scale(factor) { + if (Array.isArray(factor)) { + scale9(this, this, factor); + } else { + scale9(this, this, [factor, factor]); + } + return this.check(); + } + translate(vec) { + translate3(this, this, vec); + return this.check(); + } + // Transforms + transform(vector, result) { + let out; + switch (vector.length) { + case 2: + out = transformMat35(result || [-0, -0], vector, this); + break; + case 3: + out = transformMat36(result || [-0, -0, -0], vector, this); + break; + case 4: + out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this); + break; + default: + throw new Error("Illegal vector"); + } + checkVector2(out, vector.length); + return out; + } + /** @deprecated */ + transformVector(vector, result) { + return this.transform(vector, result); + } + /** @deprecated */ + transformVector2(vector, result) { + return this.transform(vector, result); + } + /** @deprecated */ + transformVector3(vector, result) { + return this.transform(vector, result); + } +}; +var ZERO_MATRIX3; +var IDENTITY_MATRIX32 = null; +function getZeroMatrix2() { + if (!ZERO_MATRIX3) { + ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); + Object.freeze(ZERO_MATRIX3); + } + return ZERO_MATRIX3; +} +function getIdentityMatrix2() { + if (!IDENTITY_MATRIX32) { + IDENTITY_MATRIX32 = new Matrix3(); + Object.freeze(IDENTITY_MATRIX32); + } + return IDENTITY_MATRIX32; +} + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/mat4.js +var mat4_exports3 = {}; +__export(mat4_exports3, { + add: () => add10, + adjoint: () => adjoint3, + clone: () => clone10, + copy: () => copy10, + create: () => create12, + decompose: () => decompose3, + determinant: () => determinant4, + equals: () => equals11, + exactEquals: () => exactEquals10, + frob: () => frob3, + fromQuat: () => fromQuat5, + fromQuat2: () => fromQuat23, + fromRotation: () => fromRotation3, + fromRotationTranslation: () => fromRotationTranslation3, + fromRotationTranslationScale: () => fromRotationTranslationScale3, + fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin3, + fromScaling: () => fromScaling3, + fromTranslation: () => fromTranslation3, + fromValues: () => fromValues10, + fromXRotation: () => fromXRotation3, + fromYRotation: () => fromYRotation3, + fromZRotation: () => fromZRotation3, + frustum: () => frustum3, + getRotation: () => getRotation3, + getScaling: () => getScaling3, + getTranslation: () => getTranslation3, + identity: () => identity3, + invert: () => invert4, + lookAt: () => lookAt3, + mul: () => mul9, + multiply: () => multiply10, + multiplyScalar: () => multiplyScalar3, + multiplyScalarAndAdd: () => multiplyScalarAndAdd3, + ortho: () => ortho3, + orthoNO: () => orthoNO3, + orthoZO: () => orthoZO3, + perspective: () => perspective3, + perspectiveFromFieldOfView: () => perspectiveFromFieldOfView3, + perspectiveNO: () => perspectiveNO3, + perspectiveZO: () => perspectiveZO3, + rotate: () => rotate6, + rotateX: () => rotateX6, + rotateY: () => rotateY6, + rotateZ: () => rotateZ6, + scale: () => scale10, + set: () => set9, + str: () => str9, + sub: () => sub9, + subtract: () => subtract9, + targetTo: () => targetTo3, + translate: () => translate4, + transpose: () => transpose4 +}); +function create12() { + const out = new ARRAY_TYPE3(16); + if (ARRAY_TYPE3 != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + } + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out; +} +function clone10(a) { + const out = new ARRAY_TYPE3(16); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function copy10(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function fromValues10(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + const out = new ARRAY_TYPE3(16); + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function set9(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} +function identity3(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function transpose4(out, a) { + if (out === a) { + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a12 = a[6]; + const a13 = a[7]; + const a23 = a[11]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a01; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a02; + out[9] = a12; + out[11] = a[14]; + out[12] = a03; + out[13] = a13; + out[14] = a23; + } else { + out[0] = a[0]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a[1]; + out[5] = a[5]; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a[2]; + out[9] = a[6]; + out[10] = a[10]; + out[11] = a[14]; + out[12] = a[3]; + out[13] = a[7]; + out[14] = a[11]; + out[15] = a[15]; + } + return out; +} +function invert4(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; + } + det = 1 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; +} +function adjoint3(out, a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + out[0] = a11 * b11 - a12 * b10 + a13 * b09; + out[1] = a02 * b10 - a01 * b11 - a03 * b09; + out[2] = a31 * b05 - a32 * b04 + a33 * b03; + out[3] = a22 * b04 - a21 * b05 - a23 * b03; + out[4] = a12 * b08 - a10 * b11 - a13 * b07; + out[5] = a00 * b11 - a02 * b08 + a03 * b07; + out[6] = a32 * b02 - a30 * b05 - a33 * b01; + out[7] = a20 * b05 - a22 * b02 + a23 * b01; + out[8] = a10 * b10 - a11 * b08 + a13 * b06; + out[9] = a01 * b08 - a00 * b10 - a03 * b06; + out[10] = a30 * b04 - a31 * b02 + a33 * b00; + out[11] = a21 * b02 - a20 * b04 - a23 * b00; + out[12] = a11 * b07 - a10 * b09 - a12 * b06; + out[13] = a00 * b09 - a01 * b07 + a02 * b06; + out[14] = a31 * b01 - a30 * b03 - a32 * b00; + out[15] = a20 * b03 - a21 * b01 + a22 * b00; + return out; +} +function determinant4(a) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + const b0 = a00 * a11 - a01 * a10; + const b1 = a00 * a12 - a02 * a10; + const b2 = a01 * a12 - a02 * a11; + const b3 = a20 * a31 - a21 * a30; + const b4 = a20 * a32 - a22 * a30; + const b5 = a21 * a32 - a22 * a31; + const b6 = a00 * b5 - a01 * b4 + a02 * b3; + const b7 = a10 * b5 - a11 * b4 + a12 * b3; + const b8 = a20 * b2 - a21 * b1 + a22 * b0; + const b9 = a30 * b2 - a31 * b1 + a32 * b0; + return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; +} +function multiply10(out, a, b) { + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + let b0 = b[0]; + let b1 = b[1]; + let b2 = b[2]; + let b3 = b[3]; + out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[4]; + b1 = b[5]; + b2 = b[6]; + b3 = b[7]; + out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[8]; + b1 = b[9]; + b2 = b[10]; + b3 = b[11]; + out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + b0 = b[12]; + b1 = b[13]; + b2 = b[14]; + b3 = b[15]; + out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + return out; +} +function translate4(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + if (a === out) { + out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; + out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; + out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; + out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; + } else { + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a03; + out[4] = a10; + out[5] = a11; + out[6] = a12; + out[7] = a13; + out[8] = a20; + out[9] = a21; + out[10] = a22; + out[11] = a23; + out[12] = a00 * x + a10 * y + a20 * z + a[12]; + out[13] = a01 * x + a11 * y + a21 * z + a[13]; + out[14] = a02 * x + a12 * y + a22 * z + a[14]; + out[15] = a03 * x + a13 * y + a23 * z + a[15]; + } + return out; +} +function scale10(out, a, v) { + const x = v[0]; + const y = v[1]; + const z = v[2]; + out[0] = a[0] * x; + out[1] = a[1] * x; + out[2] = a[2] * x; + out[3] = a[3] * x; + out[4] = a[4] * y; + out[5] = a[5] * y; + out[6] = a[6] * y; + out[7] = a[7] * y; + out[8] = a[8] * z; + out[9] = a[9] * z; + out[10] = a[10] * z; + out[11] = a[11] * z; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} +function rotate6(out, a, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + let a00; + let a01; + let a02; + let a03; + let a10; + let a11; + let a12; + let a13; + let a20; + let a21; + let a22; + let a23; + let b00; + let b01; + let b02; + let b10; + let b11; + let b12; + let b20; + let b21; + let b22; + if (len8 < EPSILON4) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + a00 = a[0]; + a01 = a[1]; + a02 = a[2]; + a03 = a[3]; + a10 = a[4]; + a11 = a[5]; + a12 = a[6]; + a13 = a[7]; + a20 = a[8]; + a21 = a[9]; + a22 = a[10]; + a23 = a[11]; + b00 = x * x * t + c; + b01 = y * x * t + z * s; + b02 = z * x * t - y * s; + b10 = x * y * t - z * s; + b11 = y * y * t + c; + b12 = z * y * t + x * s; + b20 = x * z * t + y * s; + b21 = y * z * t - x * s; + b22 = z * z * t + c; + out[0] = a00 * b00 + a10 * b01 + a20 * b02; + out[1] = a01 * b00 + a11 * b01 + a21 * b02; + out[2] = a02 * b00 + a12 * b01 + a22 * b02; + out[3] = a03 * b00 + a13 * b01 + a23 * b02; + out[4] = a00 * b10 + a10 * b11 + a20 * b12; + out[5] = a01 * b10 + a11 * b11 + a21 * b12; + out[6] = a02 * b10 + a12 * b11 + a22 * b12; + out[7] = a03 * b10 + a13 * b11 + a23 * b12; + out[8] = a00 * b20 + a10 * b21 + a20 * b22; + out[9] = a01 * b20 + a11 * b21 + a21 * b22; + out[10] = a02 * b20 + a12 * b21 + a22 * b22; + out[11] = a03 * b20 + a13 * b21 + a23 * b22; + if (a !== out) { + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + return out; +} +function rotateX6(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[4] = a10 * c + a20 * s; + out[5] = a11 * c + a21 * s; + out[6] = a12 * c + a22 * s; + out[7] = a13 * c + a23 * s; + out[8] = a20 * c - a10 * s; + out[9] = a21 * c - a11 * s; + out[10] = a22 * c - a12 * s; + out[11] = a23 * c - a13 * s; + return out; +} +function rotateY6(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + if (a !== out) { + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c - a20 * s; + out[1] = a01 * c - a21 * s; + out[2] = a02 * c - a22 * s; + out[3] = a03 * c - a23 * s; + out[8] = a00 * s + a20 * c; + out[9] = a01 * s + a21 * c; + out[10] = a02 * s + a22 * c; + out[11] = a03 * s + a23 * c; + return out; +} +function rotateZ6(out, a, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + if (a !== out) { + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + out[0] = a00 * c + a10 * s; + out[1] = a01 * c + a11 * s; + out[2] = a02 * c + a12 * s; + out[3] = a03 * c + a13 * s; + out[4] = a10 * c - a00 * s; + out[5] = a11 * c - a01 * s; + out[6] = a12 * c - a02 * s; + out[7] = a13 * c - a03 * s; + return out; +} +function fromTranslation3(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromScaling3(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = v[1]; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = v[2]; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotation3(out, rad, axis) { + let x = axis[0]; + let y = axis[1]; + let z = axis[2]; + let len8 = Math.sqrt(x * x + y * y + z * z); + let c; + let s; + let t; + if (len8 < EPSILON4) { + return null; + } + len8 = 1 / len8; + x *= len8; + y *= len8; + z *= len8; + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + out[0] = x * x * t + c; + out[1] = y * x * t + z * s; + out[2] = z * x * t - y * s; + out[3] = 0; + out[4] = x * y * t - z * s; + out[5] = y * y * t + c; + out[6] = z * y * t + x * s; + out[7] = 0; + out[8] = x * z * t + y * s; + out[9] = y * z * t - x * s; + out[10] = z * z * t + c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromXRotation3(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = c; + out[6] = s; + out[7] = 0; + out[8] = 0; + out[9] = -s; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromYRotation3(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = 0; + out[2] = -s; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = s; + out[9] = 0; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromZRotation3(out, rad) { + const s = Math.sin(rad); + const c = Math.cos(rad); + out[0] = c; + out[1] = s; + out[2] = 0; + out[3] = 0; + out[4] = -s; + out[5] = c; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function fromRotationTranslation3(out, q, v) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromQuat23(out, a) { + const translation = new ARRAY_TYPE3(3); + const bx = -a[0]; + const by = -a[1]; + const bz = -a[2]; + const bw = a[3]; + const ax = a[4]; + const ay = a[5]; + const az = a[6]; + const aw = a[7]; + const magnitude = bx * bx + by * by + bz * bz + bw * bw; + if (magnitude > 0) { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; + } else { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; + } + fromRotationTranslation3(out, a, translation); + return out; +} +function getTranslation3(out, mat) { + out[0] = mat[12]; + out[1] = mat[13]; + out[2] = mat[14]; + return out; +} +function getScaling3(out, mat) { + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + return out; +} +function getRotation3(out, mat) { + const scaling = new ARRAY_TYPE3(3); + getScaling3(scaling, mat); + const is1 = 1 / scaling[0]; + const is2 = 1 / scaling[1]; + const is3 = 1 / scaling[2]; + const sm11 = mat[0] * is1; + const sm12 = mat[1] * is2; + const sm13 = mat[2] * is3; + const sm21 = mat[4] * is1; + const sm22 = mat[5] * is2; + const sm23 = mat[6] * is3; + const sm31 = mat[8] * is1; + const sm32 = mat[9] * is2; + const sm33 = mat[10] * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out[3] = 0.25 * S; + out[0] = (sm23 - sm32) / S; + out[1] = (sm31 - sm13) / S; + out[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out[3] = (sm23 - sm32) / S; + out[0] = 0.25 * S; + out[1] = (sm12 + sm21) / S; + out[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out[3] = (sm31 - sm13) / S; + out[0] = (sm12 + sm21) / S; + out[1] = 0.25 * S; + out[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out[3] = (sm12 - sm21) / S; + out[0] = (sm31 + sm13) / S; + out[1] = (sm23 + sm32) / S; + out[2] = 0.25 * S; + } + return out; +} +function decompose3(out_r, out_t, out_s, mat) { + out_t[0] = mat[12]; + out_t[1] = mat[13]; + out_t[2] = mat[14]; + const m11 = mat[0]; + const m12 = mat[1]; + const m13 = mat[2]; + const m21 = mat[4]; + const m22 = mat[5]; + const m23 = mat[6]; + const m31 = mat[8]; + const m32 = mat[9]; + const m33 = mat[10]; + out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + const is1 = 1 / out_s[0]; + const is2 = 1 / out_s[1]; + const is3 = 1 / out_s[2]; + const sm11 = m11 * is1; + const sm12 = m12 * is2; + const sm13 = m13 * is3; + const sm21 = m21 * is1; + const sm22 = m22 * is2; + const sm23 = m23 * is3; + const sm31 = m31 * is1; + const sm32 = m32 * is2; + const sm33 = m33 * is3; + const trace = sm11 + sm22 + sm33; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1) * 2; + out_r[3] = 0.25 * S; + out_r[0] = (sm23 - sm32) / S; + out_r[1] = (sm31 - sm13) / S; + out_r[2] = (sm12 - sm21) / S; + } else if (sm11 > sm22 && sm11 > sm33) { + S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; + out_r[3] = (sm23 - sm32) / S; + out_r[0] = 0.25 * S; + out_r[1] = (sm12 + sm21) / S; + out_r[2] = (sm31 + sm13) / S; + } else if (sm22 > sm33) { + S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; + out_r[3] = (sm31 - sm13) / S; + out_r[0] = (sm12 + sm21) / S; + out_r[1] = 0.25 * S; + out_r[2] = (sm23 + sm32) / S; + } else { + S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; + out_r[3] = (sm12 - sm21) / S; + out_r[0] = (sm31 + sm13) / S; + out_r[1] = (sm23 + sm32) / S; + out_r[2] = 0.25 * S; + } + return out_r; +} +function fromRotationTranslationScale3(out, q, v, s) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + out[0] = (1 - (yy + zz)) * sx; + out[1] = (xy + wz) * sx; + out[2] = (xz - wy) * sx; + out[3] = 0; + out[4] = (xy - wz) * sy; + out[5] = (1 - (xx + zz)) * sy; + out[6] = (yz + wx) * sy; + out[7] = 0; + out[8] = (xz + wy) * sz; + out[9] = (yz - wx) * sz; + out[10] = (1 - (xx + yy)) * sz; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} +function fromRotationTranslationScaleOrigin3(out, q, v, s, o) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const xy = x * y2; + const xz = x * z2; + const yy = y * y2; + const yz = y * z2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + const sx = s[0]; + const sy = s[1]; + const sz = s[2]; + const ox = o[0]; + const oy = o[1]; + const oz = o[2]; + const out0 = (1 - (yy + zz)) * sx; + const out1 = (xy + wz) * sx; + const out2 = (xz - wy) * sx; + const out4 = (xy - wz) * sy; + const out5 = (1 - (xx + zz)) * sy; + const out6 = (yz + wx) * sy; + const out8 = (xz + wy) * sz; + const out9 = (yz - wx) * sz; + const out10 = (1 - (xx + yy)) * sz; + out[0] = out0; + out[1] = out1; + out[2] = out2; + out[3] = 0; + out[4] = out4; + out[5] = out5; + out[6] = out6; + out[7] = 0; + out[8] = out8; + out[9] = out9; + out[10] = out10; + out[11] = 0; + out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); + out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); + out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); + out[15] = 1; + return out; +} +function fromQuat5(out, q) { + const x = q[0]; + const y = q[1]; + const z = q[2]; + const w = q[3]; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const xx = x * x2; + const yx = y * x2; + const yy = y * y2; + const zx = z * x2; + const zy = z * y2; + const zz = z * z2; + const wx = w * x2; + const wy = w * y2; + const wz = w * z2; + out[0] = 1 - yy - zz; + out[1] = yx + wz; + out[2] = zx - wy; + out[3] = 0; + out[4] = yx - wz; + out[5] = 1 - xx - zz; + out[6] = zy + wx; + out[7] = 0; + out[8] = zx + wy; + out[9] = zy - wx; + out[10] = 1 - xx - yy; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} +function frustum3(out, left, right, bottom, top, near, far) { + const rl = 1 / (right - left); + const tb = 1 / (top - bottom); + const nf = 1 / (near - far); + out[0] = near * 2 * rl; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = near * 2 * tb; + out[6] = 0; + out[7] = 0; + out[8] = (right + left) * rl; + out[9] = (top + bottom) * tb; + out[10] = (far + near) * nf; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near * 2 * nf; + out[15] = 0; + return out; +} +function perspectiveNO3(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = 2 * far * near * nf; + } else { + out[10] = -1; + out[14] = -2 * near; + } + return out; +} +var perspective3 = perspectiveNO3; +function perspectiveZO3(out, fovy, aspect, near, far) { + const f = 1 / Math.tan(fovy / 2); + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + const nf = 1 / (near - far); + out[10] = far * nf; + out[14] = far * near * nf; + } else { + out[10] = -1; + out[14] = -near; + } + return out; +} +function perspectiveFromFieldOfView3(out, fov, near, far) { + const upTan = Math.tan(fov.upDegrees * Math.PI / 180); + const downTan = Math.tan(fov.downDegrees * Math.PI / 180); + const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); + const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); + const xScale = 2 / (leftTan + rightTan); + const yScale = 2 / (upTan + downTan); + out[0] = xScale; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = yScale; + out[6] = 0; + out[7] = 0; + out[8] = -((leftTan - rightTan) * xScale * 0.5); + out[9] = (upTan - downTan) * yScale * 0.5; + out[10] = far / (near - far); + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near / (near - far); + out[15] = 0; + return out; +} +function orthoNO3(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; +} +var ortho3 = orthoNO3; +function orthoZO3(out, left, right, bottom, top, near, far) { + const lr = 1 / (left - right); + const bt = 1 / (bottom - top); + const nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = near * nf; + out[15] = 1; + return out; +} +function lookAt3(out, eye, center, up) { + let len8; + let x0; + let x1; + let x2; + let y0; + let y1; + let y2; + let z0; + let z1; + let z2; + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + const centerx = center[0]; + const centery = center[1]; + const centerz = center[2]; + if (Math.abs(eyex - centerx) < EPSILON4 && Math.abs(eyey - centery) < EPSILON4 && Math.abs(eyez - centerz) < EPSILON4) { + return identity3(out); + } + z0 = eyex - centerx; + z1 = eyey - centery; + z2 = eyez - centerz; + len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); + z0 *= len8; + z1 *= len8; + z2 *= len8; + x0 = upy * z2 - upz * z1; + x1 = upz * z0 - upx * z2; + x2 = upx * z1 - upy * z0; + len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); + if (!len8) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len8 = 1 / len8; + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + y0 = z1 * x2 - z2 * x1; + y1 = z2 * x0 - z0 * x2; + y2 = z0 * x1 - z1 * x0; + len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); + if (!len8) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len8 = 1 / len8; + y0 *= len8; + y1 *= len8; + y2 *= len8; + } + out[0] = x0; + out[1] = y0; + out[2] = z0; + out[3] = 0; + out[4] = x1; + out[5] = y1; + out[6] = z1; + out[7] = 0; + out[8] = x2; + out[9] = y2; + out[10] = z2; + out[11] = 0; + out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); + out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); + out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); + out[15] = 1; + return out; +} +function targetTo3(out, eye, target, up) { + const eyex = eye[0]; + const eyey = eye[1]; + const eyez = eye[2]; + const upx = up[0]; + const upy = up[1]; + const upz = up[2]; + let z0 = eyex - target[0]; + let z1 = eyey - target[1]; + let z2 = eyez - target[2]; + let len8 = z0 * z0 + z1 * z1 + z2 * z2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + z0 *= len8; + z1 *= len8; + z2 *= len8; + } + let x0 = upy * z2 - upz * z1; + let x1 = upz * z0 - upx * z2; + let x2 = upx * z1 - upy * z0; + len8 = x0 * x0 + x1 * x1 + x2 * x2; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + x0 *= len8; + x1 *= len8; + x2 *= len8; + } + out[0] = x0; + out[1] = x1; + out[2] = x2; + out[3] = 0; + out[4] = z1 * x2 - z2 * x1; + out[5] = z2 * x0 - z0 * x2; + out[6] = z0 * x1 - z1 * x0; + out[7] = 0; + out[8] = z0; + out[9] = z1; + out[10] = z2; + out[11] = 0; + out[12] = eyex; + out[13] = eyey; + out[14] = eyez; + out[15] = 1; + return out; +} +function str9(a) { + return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; +} +function frob3(a) { + return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); +} +function add10(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + out[8] = a[8] + b[8]; + out[9] = a[9] + b[9]; + out[10] = a[10] + b[10]; + out[11] = a[11] + b[11]; + out[12] = a[12] + b[12]; + out[13] = a[13] + b[13]; + out[14] = a[14] + b[14]; + out[15] = a[15] + b[15]; + return out; +} +function subtract9(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + out[6] = a[6] - b[6]; + out[7] = a[7] - b[7]; + out[8] = a[8] - b[8]; + out[9] = a[9] - b[9]; + out[10] = a[10] - b[10]; + out[11] = a[11] - b[11]; + out[12] = a[12] - b[12]; + out[13] = a[13] - b[13]; + out[14] = a[14] - b[14]; + out[15] = a[15] - b[15]; + return out; +} +function multiplyScalar3(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + out[8] = a[8] * b; + out[9] = a[9] * b; + out[10] = a[10] * b; + out[11] = a[11] * b; + out[12] = a[12] * b; + out[13] = a[13] * b; + out[14] = a[14] * b; + out[15] = a[15] * b; + return out; +} +function multiplyScalarAndAdd3(out, a, b, scale13) { + out[0] = a[0] + b[0] * scale13; + out[1] = a[1] + b[1] * scale13; + out[2] = a[2] + b[2] * scale13; + out[3] = a[3] + b[3] * scale13; + out[4] = a[4] + b[4] * scale13; + out[5] = a[5] + b[5] * scale13; + out[6] = a[6] + b[6] * scale13; + out[7] = a[7] + b[7] * scale13; + out[8] = a[8] + b[8] * scale13; + out[9] = a[9] + b[9] * scale13; + out[10] = a[10] + b[10] * scale13; + out[11] = a[11] + b[11] * scale13; + out[12] = a[12] + b[12] * scale13; + out[13] = a[13] + b[13] * scale13; + out[14] = a[14] + b[14] * scale13; + out[15] = a[15] + b[15] * scale13; + return out; +} +function exactEquals10(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; +} +function equals11(a, b) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const a4 = a[4]; + const a5 = a[5]; + const a6 = a[6]; + const a7 = a[7]; + const a8 = a[8]; + const a9 = a[9]; + const a10 = a[10]; + const a11 = a[11]; + const a12 = a[12]; + const a13 = a[13]; + const a14 = a[14]; + const a15 = a[15]; + const b0 = b[0]; + const b1 = b[1]; + const b2 = b[2]; + const b3 = b[3]; + const b4 = b[4]; + const b5 = b[5]; + const b6 = b[6]; + const b7 = b[7]; + const b8 = b[8]; + const b9 = b[9]; + const b10 = b[10]; + const b11 = b[11]; + const b12 = b[12]; + const b13 = b[13]; + const b14 = b[14]; + const b15 = b[15]; + return Math.abs(a0 - b0) <= EPSILON4 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON4 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON4 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON4 * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON4 * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON4 * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON4 * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON4 * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON4 * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON4 * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON4 * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON4 * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON4 * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON4 * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON4 * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON4 * Math.max(1, Math.abs(a15), Math.abs(b15)); +} +var mul9 = multiply10; +var sub9 = subtract9; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec4.js +function create13() { + const out = new ARRAY_TYPE3(4); + if (ARRAY_TYPE3 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} +function add11(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + return out; +} +function scale11(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + return out; +} +function length8(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} +function squaredLength7(a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + return x * x + y * y + z * z + w * w; +} +function normalize9(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const w = a[3]; + let len8 = x * x + y * y + z * z + w * w; + if (len8 > 0) { + len8 = 1 / Math.sqrt(len8); + } + out[0] = x * len8; + out[1] = y * len8; + out[2] = z * len8; + out[3] = w * len8; + return out; +} +function dot8(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; +} +function lerp9(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + out[3] = aw + t * (b[3] - aw); + return out; +} +function transformQuat6(out, a, q) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + const qx = q[0]; + const qy = q[1]; + const qz = q[2]; + const qw = q[3]; + const ix = qw * x + qy * z - qz * y; + const iy = qw * y + qz * x - qx * z; + const iz = qw * z + qx * y - qy * x; + const iw = -qx * x - qy * y - qz * z; + out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; + out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; + out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; + out[3] = a[3]; + return out; +} +var forEach10 = function() { + const vec = create13(); + return function(a, stride, offset, count2, fn, arg) { + let i; + let l; + if (!stride) { + stride = 4; + } + if (!offset) { + offset = 0; + } + if (count2) { + l = Math.min(count2 * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i]; + vec[1] = a[i + 1]; + vec[2] = a[i + 2]; + vec[3] = a[i + 3]; + fn(vec, vec, arg); + a[i] = vec[0]; + a[i + 1] = vec[1]; + a[i + 2] = vec[2]; + a[i + 3] = vec[3]; + } + return a; + }; +}(); + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/quat.js +function create14() { + const out = new ARRAY_TYPE3(4); + if (ARRAY_TYPE3 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + out[3] = 1; + return out; +} +function identity4(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; +} +function setAxisAngle(out, axis, rad) { + rad = rad * 0.5; + const s = Math.sin(rad); + out[0] = s * axis[0]; + out[1] = s * axis[1]; + out[2] = s * axis[2]; + out[3] = Math.cos(rad); + return out; +} +function multiply11(out, a, b) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + const bx = b[0]; + const by = b[1]; + const bz = b[2]; + const bw = b[3]; + out[0] = ax * bw + aw * bx + ay * bz - az * by; + out[1] = ay * bw + aw * by + az * bx - ax * bz; + out[2] = az * bw + aw * bz + ax * by - ay * bx; + out[3] = aw * bw - ax * bx - ay * by - az * bz; + return out; +} +function rotateX7(out, a, rad) { + rad *= 0.5; + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + const bx = Math.sin(rad); + const bw = Math.cos(rad); + out[0] = ax * bw + aw * bx; + out[1] = ay * bw + az * bx; + out[2] = az * bw - ay * bx; + out[3] = aw * bw - ax * bx; + return out; +} +function rotateY7(out, a, rad) { + rad *= 0.5; + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + const by = Math.sin(rad); + const bw = Math.cos(rad); + out[0] = ax * bw - az * by; + out[1] = ay * bw + aw * by; + out[2] = az * bw + ax * by; + out[3] = aw * bw - ay * by; + return out; +} +function rotateZ7(out, a, rad) { + rad *= 0.5; + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + const bz = Math.sin(rad); + const bw = Math.cos(rad); + out[0] = ax * bw + ay * bz; + out[1] = ay * bw - ax * bz; + out[2] = az * bw + aw * bz; + out[3] = aw * bw - az * bz; + return out; +} +function calculateW(out, a) { + const x = a[0]; + const y = a[1]; + const z = a[2]; + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = Math.sqrt(Math.abs(1 - x * x - y * y - z * z)); + return out; +} +function slerp3(out, a, b, t) { + const ax = a[0]; + const ay = a[1]; + const az = a[2]; + const aw = a[3]; + let bx = b[0]; + let by = b[1]; + let bz = b[2]; + let bw = b[3]; + let cosom; + let omega; + let scale0; + let scale1; + let sinom; + cosom = ax * bx + ay * by + az * bz + aw * bw; + if (cosom < 0) { + cosom = -cosom; + bx = -bx; + by = -by; + bz = -bz; + bw = -bw; + } + if (1 - cosom > EPSILON4) { + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1 - t) * omega) / sinom; + scale1 = Math.sin(t * omega) / sinom; + } else { + scale0 = 1 - t; + scale1 = t; + } + out[0] = scale0 * ax + scale1 * bx; + out[1] = scale0 * ay + scale1 * by; + out[2] = scale0 * az + scale1 * bz; + out[3] = scale0 * aw + scale1 * bw; + return out; +} +function invert5(out, a) { + const a0 = a[0]; + const a1 = a[1]; + const a2 = a[2]; + const a3 = a[3]; + const dot10 = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3; + const invDot = dot10 ? 1 / dot10 : 0; + out[0] = -a0 * invDot; + out[1] = -a1 * invDot; + out[2] = -a2 * invDot; + out[3] = a3 * invDot; + return out; +} +function conjugate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = a[3]; + return out; +} +function fromMat3(out, m) { + const fTrace = m[0] + m[4] + m[8]; + let fRoot; + if (fTrace > 0) { + fRoot = Math.sqrt(fTrace + 1); + out[3] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[0] = (m[5] - m[7]) * fRoot; + out[1] = (m[6] - m[2]) * fRoot; + out[2] = (m[1] - m[3]) * fRoot; + } else { + let i = 0; + if (m[4] > m[0]) + i = 1; + if (m[8] > m[i * 3 + i]) + i = 2; + const j = (i + 1) % 3; + const k = (i + 2) % 3; + fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1); + out[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot; + out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot; + out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot; + } + return out; +} +var add12 = add11; +var scale12 = scale11; +var dot9 = dot8; +var lerp10 = lerp9; +var length9 = length8; +var squaredLength8 = squaredLength7; +var normalize10 = normalize9; +var rotationTo = function() { + const tmpvec3 = create10(); + const xUnitVec3 = fromValues9(1, 0, 0); + const yUnitVec3 = fromValues9(0, 1, 0); + return function(out, a, b) { + const dot10 = dot7(a, b); + if (dot10 < -0.999999) { + cross7(tmpvec3, xUnitVec3, a); + if (len7(tmpvec3) < 1e-6) + cross7(tmpvec3, yUnitVec3, a); + normalize8(tmpvec3, tmpvec3); + setAxisAngle(out, tmpvec3, Math.PI); + return out; + } else if (dot10 > 0.999999) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; + } + cross7(tmpvec3, a, b); + out[0] = tmpvec3[0]; + out[1] = tmpvec3[1]; + out[2] = tmpvec3[2]; + out[3] = 1 + dot10; + return normalize10(out, out); + }; +}(); +var sqlerp = function() { + const temp1 = create14(); + const temp2 = create14(); + return function(out, a, b, c, d, t) { + slerp3(temp1, a, d, t); + slerp3(temp2, b, c, t); + slerp3(out, temp1, temp2, 2 * t * (1 - t)); + return out; + }; +}(); +var setAxes = function() { + const matr = create11(); + return function(out, view, right, up) { + matr[0] = right[0]; + matr[3] = right[1]; + matr[6] = right[2]; + matr[1] = up[0]; + matr[4] = up[1]; + matr[7] = up[2]; + matr[2] = -view[0]; + matr[5] = -view[1]; + matr[8] = -view[2]; + return normalize10(out, fromMat3(out, matr)); + }; +}(); + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/quaternion.js +var IDENTITY_QUATERNION = [0, 0, 0, 1]; +var Quaternion = class extends MathArray2 { + constructor(x = 0, y = 0, z = 0, w = 1) { + super(-0, -0, -0, -0); + if (Array.isArray(x) && arguments.length === 1) { + this.copy(x); + } else { + this.set(x, y, z, w); + } + } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + return this.check(); + } + set(x, y, z, w) { + this[0] = x; + this[1] = y; + this[2] = z; + this[3] = w; + return this.check(); + } + fromObject(object) { + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + this[3] = object.w; + return this.check(); + } + /** + * Creates a quaternion from the given 3x3 rotation matrix. + * NOTE: The resultant quaternion is not normalized, so you should + * be sure to renormalize the quaternion yourself where necessary. + * @param m + * @returns + */ + fromMatrix3(m) { + fromMat3(this, m); + return this.check(); + } + fromAxisRotation(axis, rad) { + setAxisAngle(this, axis, rad); + return this.check(); + } + /** Set a quat to the identity quaternion */ + identity() { + identity4(this); + return this.check(); + } + // Set the components of a quat to the given values + // set(i, j, k, l) { + // quat_set(this, i, j, k, l); + // return this.check(); + // } + // Sets a quat from the given angle and rotation axis, then returns it. + setAxisAngle(axis, rad) { + return this.fromAxisRotation(axis, rad); + } + // Getters/setters + get ELEMENTS() { + return 4; + } + get x() { + return this[0]; + } + set x(value) { + this[0] = checkNumber2(value); + } + get y() { + return this[1]; + } + set y(value) { + this[1] = checkNumber2(value); + } + get z() { + return this[2]; + } + set z(value) { + this[2] = checkNumber2(value); + } + get w() { + return this[3]; + } + set w(value) { + this[3] = checkNumber2(value); + } + // Calculates the length of a quat + len() { + return length9(this); + } + // Calculates the squared length of a quat + lengthSquared() { + return squaredLength8(this); + } + // Calculates the dot product of two quat's + // @return {Number} + dot(a) { + return dot9(this, a); + } + // Gets the rotation axis and angle for a given quaternion. + // If a quaternion is created with setAxisAngle, this method will + // return the same values as providied in the original parameter + // list OR functionally equivalent values. + // Example: The quaternion formed by axis [0, 0, 1] and angle -90 + // is the same as the quaternion formed by [0, 0, 1] and 270. + // This method favors the latter. + // @return {{[x,y,z], Number}} + // getAxisAngle() { + // const axis = []; + // // const angle = quat_getAxisAngle(axis, this); + // return {axis, angle}; + // } + // MODIFIERS + // Sets a quaternion to represent the shortest rotation from one vector + // to another. Both vectors are assumed to be unit length. + rotationTo(vectorA, vectorB) { + rotationTo(this, vectorA, vectorB); + return this.check(); + } + // Sets the specified quaternion with values corresponding to the given axes. + // Each axis is a vec3 and is expected to be unit length and perpendicular + // to all other specified axes. + // setAxes() { + // Number + // } + // Performs a spherical linear interpolation with two control points + // sqlerp() { + // Number; + // } + // Adds two quat's + add(a) { + add12(this, this, a); + return this.check(); + } + // Calculates the W component of a quat from the X, Y, and Z components. + // Any existing W component will be ignored. + calculateW() { + calculateW(this, this); + return this.check(); + } + // Calculates the conjugate of a quat If the quaternion is normalized, + // this function is faster than quat_invert and produces the same result. + conjugate() { + conjugate(this, this); + return this.check(); + } + // Calculates the inverse of a quat + invert() { + invert5(this, this); + return this.check(); + } + // Performs a linear interpolation between two quat's + lerp(a, b, t) { + if (t === void 0) { + return this.lerp(this, a, b); + } + lerp10(this, a, b, t); + return this.check(); + } + // Multiplies two quat's + multiplyRight(a) { + multiply11(this, this, a); + return this.check(); + } + multiplyLeft(a) { + multiply11(this, a, this); + return this.check(); + } + // Normalize a quat + normalize() { + const length10 = this.len(); + const l = length10 > 0 ? 1 / length10 : 0; + this[0] = this[0] * l; + this[1] = this[1] * l; + this[2] = this[2] * l; + this[3] = this[3] * l; + if (length10 === 0) { + this[3] = 1; + } + return this.check(); + } + // Rotates a quaternion by the given angle about the X axis + rotateX(rad) { + rotateX7(this, this, rad); + return this.check(); + } + // Rotates a quaternion by the given angle about the Y axis + rotateY(rad) { + rotateY7(this, this, rad); + return this.check(); + } + // Rotates a quaternion by the given angle about the Z axis + rotateZ(rad) { + rotateZ7(this, this, rad); + return this.check(); + } + // Scales a quat by a scalar number + scale(b) { + scale12(this, this, b); + return this.check(); + } + // Performs a spherical linear interpolation between two quat + slerp(arg0, arg1, arg2) { + let start; + let target; + let ratio; + switch (arguments.length) { + case 1: + ({ + start = IDENTITY_QUATERNION, + target, + ratio + } = arg0); + break; + case 2: + start = this; + target = arg0; + ratio = arg1; + break; + default: + start = arg0; + target = arg1; + ratio = arg2; + } + slerp3(this, start, target, ratio); + return this.check(); + } + transformVector4(vector, result = new Vector4()) { + transformQuat6(result, vector, this); + return checkVector2(result, 4); + } + // THREE.js Math API compatibility + lengthSq() { + return this.lengthSquared(); + } + setFromAxisAngle(axis, rad) { + return this.setAxisAngle(axis, rad); + } + premultiply(a) { + return this.multiplyLeft(a); + } + multiply(a) { + return this.multiplyRight(a); + } +}; + +// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/math-utils.js +var math_utils_exports3 = {}; +__export(math_utils_exports3, { + EPSILON1: () => EPSILON1, + EPSILON10: () => EPSILON10, + EPSILON11: () => EPSILON11, + EPSILON12: () => EPSILON12, + EPSILON13: () => EPSILON13, + EPSILON14: () => EPSILON14, + EPSILON15: () => EPSILON15, + EPSILON16: () => EPSILON16, + EPSILON17: () => EPSILON17, + EPSILON18: () => EPSILON18, + EPSILON19: () => EPSILON19, + EPSILON2: () => EPSILON22, + EPSILON20: () => EPSILON20, + EPSILON3: () => EPSILON32, + EPSILON4: () => EPSILON42, + EPSILON5: () => EPSILON5, + EPSILON6: () => EPSILON6, + EPSILON7: () => EPSILON7, + EPSILON8: () => EPSILON8, + EPSILON9: () => EPSILON9, + PI_OVER_FOUR: () => PI_OVER_FOUR, + PI_OVER_SIX: () => PI_OVER_SIX, + PI_OVER_TWO: () => PI_OVER_TWO, + TWO_PI: () => TWO_PI +}); +var EPSILON1 = 0.1; +var EPSILON22 = 0.01; +var EPSILON32 = 1e-3; +var EPSILON42 = 1e-4; +var EPSILON5 = 1e-5; +var EPSILON6 = 1e-6; +var EPSILON7 = 1e-7; +var EPSILON8 = 1e-8; +var EPSILON9 = 1e-9; +var EPSILON10 = 1e-10; +var EPSILON11 = 1e-11; +var EPSILON12 = 1e-12; +var EPSILON13 = 1e-13; +var EPSILON14 = 1e-14; +var EPSILON15 = 1e-15; +var EPSILON16 = 1e-16; +var EPSILON17 = 1e-17; +var EPSILON18 = 1e-18; +var EPSILON19 = 1e-19; +var EPSILON20 = 1e-20; +var PI_OVER_TWO = Math.PI / 2; +var PI_OVER_FOUR = Math.PI / 4; +var PI_OVER_SIX = Math.PI / 6; +var TWO_PI = Math.PI * 2; + +// node_modules/@math.gl/culling/dist/lib/bounding-volumes/axis-aligned-bounding-box.js +var scratchVector2 = new Vector32(); +var scratchNormal = new Vector32(); +var AxisAlignedBoundingBox = class _AxisAlignedBoundingBox { + /** + * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes. + * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes. + * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes. + * @param center The center of the box; automatically computed if not supplied. + */ + constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) { + center = center || scratchVector2.copy(minimum).add(maximum).scale(0.5); + this.center = new Vector32(center); + this.halfDiagonal = new Vector32(maximum).subtract(this.center); + this.minimum = new Vector32(minimum); + this.maximum = new Vector32(maximum); + } + /** + * Duplicates a AxisAlignedBoundingBox instance. + * + * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance. + */ + clone() { + return new _AxisAlignedBoundingBox(this.minimum, this.maximum, this.center); + } + /** + * Compares the provided AxisAlignedBoundingBox componentwise and returns + * true if they are equal, false otherwise. + * + * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with. + * @returns {Boolean} true if left and right are equal, false otherwise. + */ + equals(right) { + return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum); + } + /** + * Applies a 4x4 affine transformation matrix to a bounding sphere. + * @param transform The transformation matrix to apply to the bounding sphere. + * @returns itself, i.e. the modified BoundingVolume. + */ + transform(transform) { + this.center.transformAsPoint(transform); + this.halfDiagonal.transform(transform); + this.minimum.transform(transform); + this.maximum.transform(transform); + return this; + } + /** + * Determines which side of a plane a box is located. + */ + intersectPlane(plane) { + const { halfDiagonal } = this; + const normal = scratchNormal.from(plane.normal); + const e = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z); + const s = this.center.dot(normal) + plane.distance; + if (s - e > 0) { + return INTERSECTION.INSIDE; + } + if (s + e < 0) { + return INTERSECTION.OUTSIDE; + } + return INTERSECTION.INTERSECTING; + } + /** Computes the estimated distance from the closest point on a bounding box to a point. */ + distanceTo(point) { + return Math.sqrt(this.distanceSquaredTo(point)); + } + /** Computes the estimated distance squared from the closest point on a bounding box to a point. */ + distanceSquaredTo(point) { + const offset = scratchVector2.from(point).subtract(this.center); + const { halfDiagonal } = this; + let distanceSquared = 0; + let d; + d = Math.abs(offset.x) - halfDiagonal.x; + if (d > 0) { + distanceSquared += d * d; + } + d = Math.abs(offset.y) - halfDiagonal.y; + if (d > 0) { + distanceSquared += d * d; + } + d = Math.abs(offset.z) - halfDiagonal.z; + if (d > 0) { + distanceSquared += d * d; + } + return distanceSquared; + } +}; + +// node_modules/@math.gl/culling/dist/lib/bounding-volumes/bounding-sphere.js +var scratchVector3 = new Vector32(); +var scratchVector22 = new Vector32(); +var BoundingSphere = class _BoundingSphere { + /** Creates a bounding sphere */ + constructor(center = [0, 0, 0], radius = 0) { + this.radius = -0; + this.center = new Vector32(); + this.fromCenterRadius(center, radius); + } + /** Sets the bounding sphere from `center` and `radius`. */ + fromCenterRadius(center, radius) { + this.center.from(center); + this.radius = radius; + return this; + } + /** + * Computes a bounding sphere from the corner points of an axis-aligned bounding box. The sphere + * tightly and fully encompasses the box. + */ + fromCornerPoints(corner, oppositeCorner) { + oppositeCorner = scratchVector3.from(oppositeCorner); + this.center = new Vector32().from(corner).add(oppositeCorner).scale(0.5); + this.radius = this.center.distance(oppositeCorner); + return this; + } + /** Compares the provided BoundingSphere component wise */ + equals(right) { + return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius; + } + /** Duplicates a BoundingSphere instance. */ + clone() { + return new _BoundingSphere(this.center, this.radius); + } + /** Computes a bounding sphere that contains both the left and right bounding spheres. */ + union(boundingSphere) { + const leftCenter = this.center; + const leftRadius = this.radius; + const rightCenter = boundingSphere.center; + const rightRadius = boundingSphere.radius; + const toRightCenter = scratchVector3.copy(rightCenter).subtract(leftCenter); + const centerSeparation = toRightCenter.magnitude(); + if (leftRadius >= centerSeparation + rightRadius) { + return this.clone(); + } + if (rightRadius >= centerSeparation + leftRadius) { + return boundingSphere.clone(); + } + const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5; + scratchVector22.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter); + this.center.copy(scratchVector22); + this.radius = halfDistanceBetweenTangentPoints; + return this; + } + /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */ + expand(point) { + const scratchPoint = scratchVector3.from(point); + const radius = scratchPoint.subtract(this.center).magnitude(); + if (radius > this.radius) { + this.radius = radius; + } + return this; + } + // BoundingVolume interface + /** + * Applies a 4x4 affine transformation matrix to a bounding sphere. + * @param sphere The bounding sphere to apply the transformation to. + * @param transform The transformation matrix to apply to the bounding sphere. + * @returns self. + */ + transform(transform) { + this.center.transform(transform); + const scale13 = mat4_exports3.getScaling(scratchVector3, transform); + this.radius = Math.max(scale13[0], Math.max(scale13[1], scale13[2])) * this.radius; + return this; + } + /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */ + distanceSquaredTo(point) { + const d = this.distanceTo(point); + return d * d; + } + /** Computes the estimated distance from the closest point on a bounding sphere to a point. */ + distanceTo(point) { + const scratchPoint = scratchVector3.from(point); + const delta = scratchPoint.subtract(this.center); + return Math.max(0, delta.len() - this.radius); + } + /** Determines which side of a plane a sphere is located. */ + intersectPlane(plane) { + const center = this.center; + const radius = this.radius; + const normal = plane.normal; + const distanceToPlane = normal.dot(center) + plane.distance; + if (distanceToPlane < -radius) { + return INTERSECTION.OUTSIDE; + } + if (distanceToPlane < radius) { + return INTERSECTION.INTERSECTING; + } + return INTERSECTION.INSIDE; + } +}; + +// node_modules/@math.gl/culling/dist/lib/bounding-volumes/oriented-bounding-box.js +var scratchVector32 = new Vector32(); +var scratchOffset = new Vector32(); +var scratchVectorU = new Vector32(); +var scratchVectorV = new Vector32(); +var scratchVectorW = new Vector32(); +var scratchCorner = new Vector32(); +var scratchToCenter = new Vector32(); +var MATRIX3 = { + COLUMN0ROW0: 0, + COLUMN0ROW1: 1, + COLUMN0ROW2: 2, + COLUMN1ROW0: 3, + COLUMN1ROW1: 4, + COLUMN1ROW2: 5, + COLUMN2ROW0: 6, + COLUMN2ROW1: 7, + COLUMN2ROW2: 8 +}; +var OrientedBoundingBox = class _OrientedBoundingBox { + constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) { + this.center = new Vector32().from(center); + this.halfAxes = new Matrix3(halfAxes); + } + /** Returns an array with three halfSizes for the bounding box */ + get halfSize() { + const xAxis = this.halfAxes.getColumn(0); + const yAxis = this.halfAxes.getColumn(1); + const zAxis = this.halfAxes.getColumn(2); + return [new Vector32(xAxis).len(), new Vector32(yAxis).len(), new Vector32(zAxis).len()]; + } + /** Returns a quaternion describing the orientation of the bounding box */ + get quaternion() { + const xAxis = this.halfAxes.getColumn(0); + const yAxis = this.halfAxes.getColumn(1); + const zAxis = this.halfAxes.getColumn(2); + const normXAxis = new Vector32(xAxis).normalize(); + const normYAxis = new Vector32(yAxis).normalize(); + const normZAxis = new Vector32(zAxis).normalize(); + return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis])); + } + /** + * Create OrientedBoundingBox from quaternion based OBB, + */ + fromCenterHalfSizeQuaternion(center, halfSize, quaternion) { + const quaternionObject = new Quaternion(quaternion); + const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject); + directionsMatrix[0] = directionsMatrix[0] * halfSize[0]; + directionsMatrix[1] = directionsMatrix[1] * halfSize[0]; + directionsMatrix[2] = directionsMatrix[2] * halfSize[0]; + directionsMatrix[3] = directionsMatrix[3] * halfSize[1]; + directionsMatrix[4] = directionsMatrix[4] * halfSize[1]; + directionsMatrix[5] = directionsMatrix[5] * halfSize[1]; + directionsMatrix[6] = directionsMatrix[6] * halfSize[2]; + directionsMatrix[7] = directionsMatrix[7] * halfSize[2]; + directionsMatrix[8] = directionsMatrix[8] * halfSize[2]; + this.center = new Vector32().from(center); + this.halfAxes = directionsMatrix; + return this; + } + /** Duplicates a OrientedBoundingBox instance. */ + clone() { + return new _OrientedBoundingBox(this.center, this.halfAxes); + } + /** Compares the provided OrientedBoundingBox component wise and returns */ + equals(right) { + return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes); + } + /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */ + getBoundingSphere(result = new BoundingSphere()) { + const halfAxes = this.halfAxes; + const u = halfAxes.getColumn(0, scratchVectorU); + const v = halfAxes.getColumn(1, scratchVectorV); + const w = halfAxes.getColumn(2, scratchVectorW); + const cornerVector = scratchVector32.copy(u).add(v).add(w); + result.center.copy(this.center); + result.radius = cornerVector.magnitude(); + return result; + } + /** Determines which side of a plane the oriented bounding box is located. */ + intersectPlane(plane) { + const center = this.center; + const normal = plane.normal; + const halfAxes = this.halfAxes; + const normalX = normal.x; + const normalY = normal.y; + const normalZ = normal.z; + const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]); + const distanceToPlane = normal.dot(center) + plane.distance; + if (distanceToPlane <= -radEffective) { + return INTERSECTION.OUTSIDE; + } else if (distanceToPlane >= radEffective) { + return INTERSECTION.INSIDE; + } + return INTERSECTION.INTERSECTING; + } + /** Computes the estimated distance from the closest point on a bounding box to a point. */ + distanceTo(point) { + return Math.sqrt(this.distanceSquaredTo(point)); + } + /** + * Computes the estimated distance squared from the closest point + * on a bounding box to a point. + * See Geometric Tools for Computer Graphics 10.4.2 + */ + distanceSquaredTo(point) { + const offset = scratchOffset.from(point).subtract(this.center); + const halfAxes = this.halfAxes; + const u = halfAxes.getColumn(0, scratchVectorU); + const v = halfAxes.getColumn(1, scratchVectorV); + const w = halfAxes.getColumn(2, scratchVectorW); + const uHalf = u.magnitude(); + const vHalf = v.magnitude(); + const wHalf = w.magnitude(); + u.normalize(); + v.normalize(); + w.normalize(); + let distanceSquared = 0; + let d; + d = Math.abs(offset.dot(u)) - uHalf; + if (d > 0) { + distanceSquared += d * d; + } + d = Math.abs(offset.dot(v)) - vHalf; + if (d > 0) { + distanceSquared += d * d; + } + d = Math.abs(offset.dot(w)) - wHalf; + if (d > 0) { + distanceSquared += d * d; + } + return distanceSquared; + } + /** + * The distances calculated by the vector from the center of the bounding box + * to position projected onto direction. + * + * - If you imagine the infinite number of planes with normal direction, + * this computes the smallest distance to the closest and farthest planes + * from `position` that intersect the bounding box. + * + * @param position The position to calculate the distance from. + * @param direction The direction from position. + * @param result An Interval (array of length 2) to store the nearest and farthest distances. + * @returns Interval (array of length 2) with nearest and farthest distances + * on the bounding box from position in direction. + */ + // eslint-disable-next-line max-statements + computePlaneDistances(position, direction, result = [-0, -0]) { + let minDist = Number.POSITIVE_INFINITY; + let maxDist = Number.NEGATIVE_INFINITY; + const center = this.center; + const halfAxes = this.halfAxes; + const u = halfAxes.getColumn(0, scratchVectorU); + const v = halfAxes.getColumn(1, scratchVectorV); + const w = halfAxes.getColumn(2, scratchVectorW); + const corner = scratchCorner.copy(u).add(v).add(w).add(center); + const toCenter = scratchToCenter.copy(corner).subtract(position); + let mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u).add(v).subtract(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u).subtract(v).add(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u).subtract(v).subtract(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u).add(v).add(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u).add(v).subtract(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u).subtract(v).add(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u).subtract(v).subtract(w); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + result[0] = minDist; + result[1] = maxDist; + return result; + } + /** + * Applies a 4x4 affine transformation matrix to a bounding sphere. + * @param transform The transformation matrix to apply to the bounding sphere. + * @returns itself, i.e. the modified BoundingVolume. + */ + transform(transformation) { + this.center.transformAsPoint(transformation); + const xAxis = this.halfAxes.getColumn(0, scratchVectorU); + xAxis.transformAsPoint(transformation); + const yAxis = this.halfAxes.getColumn(1, scratchVectorV); + yAxis.transformAsPoint(transformation); + const zAxis = this.halfAxes.getColumn(2, scratchVectorW); + zAxis.transformAsPoint(transformation); + this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]); + return this; + } + getTransform() { + throw new Error("not implemented"); + } +}; + +// node_modules/@math.gl/culling/dist/lib/plane.js +var scratchPosition = new Vector32(); +var scratchNormal2 = new Vector32(); +var Plane = class _Plane { + constructor(normal = [0, 0, 1], distance8 = 0) { + this.normal = new Vector32(); + this.distance = -0; + this.fromNormalDistance(normal, distance8); + } + /** Creates a plane from a normal and a distance from the origin. */ + fromNormalDistance(normal, distance8) { + assert10(Number.isFinite(distance8)); + this.normal.from(normal).normalize(); + this.distance = distance8; + return this; + } + /** Creates a plane from a normal and a point on the plane. */ + fromPointNormal(point, normal) { + point = scratchPosition.from(point); + this.normal.from(normal).normalize(); + const distance8 = -this.normal.dot(point); + this.distance = distance8; + return this; + } + /** Creates a plane from the general equation */ + fromCoefficients(a, b, c, d) { + this.normal.set(a, b, c); + assert10(equals10(this.normal.len(), 1)); + this.distance = d; + return this; + } + /** Duplicates a Plane instance. */ + clone() { + return new _Plane(this.normal, this.distance); + } + /** Compares the provided Planes by normal and distance */ + equals(right) { + return equals10(this.distance, right.distance) && equals10(this.normal, right.normal); + } + /** Computes the signed shortest distance of a point to a plane. + * The sign of the distance determines which side of the plane the point is on. + */ + getPointDistance(point) { + return this.normal.dot(point) + this.distance; + } + /** Transforms the plane by the given transformation matrix. */ + transform(matrix4) { + const normal = scratchNormal2.copy(this.normal).transformAsVector(matrix4).normalize(); + const point = this.normal.scale(-this.distance).transform(matrix4); + return this.fromPointNormal(point, normal); + } + projectPointOntoPlane(point, result = [0, 0, 0]) { + const scratchPoint = scratchPosition.from(point); + const pointDistance = this.getPointDistance(scratchPoint); + const scaledNormal = scratchNormal2.copy(this.normal).scale(pointDistance); + return scratchPoint.subtract(scaledNormal).to(result); + } +}; + +// node_modules/@math.gl/culling/dist/lib/culling-volume.js +var faces = [new Vector32([1, 0, 0]), new Vector32([0, 1, 0]), new Vector32([0, 0, 1])]; +var scratchPlaneCenter = new Vector32(); +var scratchPlaneNormal = new Vector32(); +var CullingVolume = class _CullingVolume { + /** + * Create a new `CullingVolume` bounded by an array of clipping planed + * @param planes Array of clipping planes. + * */ + constructor(planes = []) { + this.planes = planes; + } + /** + * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere. + * The planes are aligned to the x, y, and z axes in world coordinates. + */ + fromBoundingSphere(boundingSphere) { + this.planes.length = 2 * faces.length; + const center = boundingSphere.center; + const radius = boundingSphere.radius; + let planeIndex = 0; + for (const faceNormal of faces) { + let plane0 = this.planes[planeIndex]; + let plane1 = this.planes[planeIndex + 1]; + if (!plane0) { + plane0 = this.planes[planeIndex] = new Plane(); + } + if (!plane1) { + plane1 = this.planes[planeIndex + 1] = new Plane(); + } + const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center); + plane0.fromPointNormal(plane0Center, faceNormal); + const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center); + const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate(); + plane1.fromPointNormal(plane1Center, negatedFaceNormal); + planeIndex += 2; + } + return this; + } + /** Determines whether a bounding volume intersects the culling volume. */ + computeVisibility(boundingVolume) { + let intersect2 = INTERSECTION.INSIDE; + for (const plane of this.planes) { + const result = boundingVolume.intersectPlane(plane); + switch (result) { + case INTERSECTION.OUTSIDE: + return INTERSECTION.OUTSIDE; + case INTERSECTION.INTERSECTING: + intersect2 = INTERSECTION.INTERSECTING; + break; + default: + } + } + return intersect2; + } + /** + * Determines whether a bounding volume intersects the culling volume. + * + * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling + * volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then + * the parent (and therefore this) volume is completely inside plane[planeIndex] + * and that plane check can be skipped. + */ + computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) { + assert10(Number.isFinite(parentPlaneMask), "parentPlaneMask is required."); + if (parentPlaneMask === _CullingVolume.MASK_OUTSIDE || parentPlaneMask === _CullingVolume.MASK_INSIDE) { + return parentPlaneMask; + } + let mask = _CullingVolume.MASK_INSIDE; + const planes = this.planes; + for (let k = 0; k < this.planes.length; ++k) { + const flag = k < 31 ? 1 << k : 0; + if (k < 31 && (parentPlaneMask & flag) === 0) { + continue; + } + const plane = planes[k]; + const result = boundingVolume.intersectPlane(plane); + if (result === INTERSECTION.OUTSIDE) { + return _CullingVolume.MASK_OUTSIDE; + } else if (result === INTERSECTION.INTERSECTING) { + mask |= flag; + } + } + return mask; + } +}; +CullingVolume.MASK_OUTSIDE = 4294967295; +CullingVolume.MASK_INSIDE = 0; +CullingVolume.MASK_INDETERMINATE = 2147483647; + +// node_modules/@math.gl/culling/dist/lib/perspective-off-center-frustum.js +var scratchPlaneUpVector = new Vector32(); +var scratchPlaneRightVector = new Vector32(); +var scratchPlaneNearCenter = new Vector32(); +var scratchPlaneFarCenter = new Vector32(); +var scratchPlaneNormal2 = new Vector32(); + +// node_modules/@math.gl/culling/dist/lib/algorithms/bounding-sphere-from-points.js +var fromPointsXMin = new Vector32(); +var fromPointsYMin = new Vector32(); +var fromPointsZMin = new Vector32(); +var fromPointsXMax = new Vector32(); +var fromPointsYMax = new Vector32(); +var fromPointsZMax = new Vector32(); +var fromPointsCurrentPos = new Vector32(); +var fromPointsScratch = new Vector32(); +var fromPointsRitterCenter = new Vector32(); +var fromPointsMinBoxPt = new Vector32(); +var fromPointsMaxBoxPt = new Vector32(); +var fromPointsNaiveCenterScratch = new Vector32(); + +// node_modules/@math.gl/culling/dist/lib/algorithms/compute-eigen-decomposition.js +var scratchMatrix = new Matrix3(); +var scratchUnitary = new Matrix3(); +var scratchDiagonal = new Matrix3(); +var jMatrix = new Matrix3(); +var jMatrixTranspose = new Matrix3(); +function computeEigenDecomposition(matrix, result = {}) { + const EIGEN_TOLERANCE = math_utils_exports3.EPSILON20; + const EIGEN_MAX_SWEEPS = 10; + let count2 = 0; + let sweep = 0; + const unitaryMatrix = scratchUnitary; + const diagonalMatrix = scratchDiagonal; + unitaryMatrix.identity(); + diagonalMatrix.copy(matrix); + const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix); + while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) { + shurDecomposition(diagonalMatrix, jMatrix); + jMatrixTranspose.copy(jMatrix).transpose(); + diagonalMatrix.multiplyRight(jMatrix); + diagonalMatrix.multiplyLeft(jMatrixTranspose); + unitaryMatrix.multiplyRight(jMatrix); + if (++count2 > 2) { + ++sweep; + count2 = 0; + } + } + result.unitary = unitaryMatrix.toTarget(result.unitary); + result.diagonal = diagonalMatrix.toTarget(result.diagonal); + return result; +} +function computeFrobeniusNorm(matrix) { + let norm = 0; + for (let i = 0; i < 9; ++i) { + const temp = matrix[i]; + norm += temp * temp; + } + return Math.sqrt(norm); +} +var rowVal = [1, 0, 0]; +var colVal = [2, 2, 1]; +function offDiagonalFrobeniusNorm(matrix) { + let norm = 0; + for (let i = 0; i < 3; ++i) { + const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]; + norm += 2 * temp * temp; + } + return Math.sqrt(norm); +} +function shurDecomposition(matrix, result) { + const tolerance = math_utils_exports3.EPSILON15; + let maxDiagonal = 0; + let rotAxis = 1; + for (let i = 0; i < 3; ++i) { + const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]); + if (temp > maxDiagonal) { + rotAxis = i; + maxDiagonal = temp; + } + } + const p = rowVal[rotAxis]; + const q = colVal[rotAxis]; + let c = 1; + let s = 0; + if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) { + const qq = matrix[scratchMatrix.getElementIndex(q, q)]; + const pp = matrix[scratchMatrix.getElementIndex(p, p)]; + const qp = matrix[scratchMatrix.getElementIndex(q, p)]; + const tau = (qq - pp) / 2 / qp; + let t; + if (tau < 0) { + t = -1 / (-tau + Math.sqrt(1 + tau * tau)); + } else { + t = 1 / (tau + Math.sqrt(1 + tau * tau)); + } + c = 1 / Math.sqrt(1 + t * t); + s = t * c; + } + Matrix3.IDENTITY.to(result); + result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c; + result[scratchMatrix.getElementIndex(q, p)] = s; + result[scratchMatrix.getElementIndex(p, q)] = -s; + return result; +} + +// node_modules/@math.gl/culling/dist/lib/algorithms/bounding-box-from-points.js +var scratchVector23 = new Vector32(); +var scratchVector33 = new Vector32(); +var scratchVector4 = new Vector32(); +var scratchVector5 = new Vector32(); +var scratchVector6 = new Vector32(); +var scratchCovarianceResult = new Matrix3(); +var scratchEigenResult = { + diagonal: new Matrix3(), + unitary: new Matrix3() +}; +function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) { + if (!positions || positions.length === 0) { + result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); + result.center = new Vector32(); + return result; + } + const length10 = positions.length; + const meanPoint = new Vector32(0, 0, 0); + for (const position of positions) { + meanPoint.add(position); + } + const invLength = 1 / length10; + meanPoint.multiplyByScalar(invLength); + let exx = 0; + let exy = 0; + let exz = 0; + let eyy = 0; + let eyz = 0; + let ezz = 0; + for (const position of positions) { + const p = scratchVector23.copy(position).subtract(meanPoint); + exx += p.x * p.x; + exy += p.x * p.y; + exz += p.x * p.z; + eyy += p.y * p.y; + eyz += p.y * p.z; + ezz += p.z * p.z; + } + exx *= invLength; + exy *= invLength; + exz *= invLength; + eyy *= invLength; + eyz *= invLength; + ezz *= invLength; + const covarianceMatrix = scratchCovarianceResult; + covarianceMatrix[0] = exx; + covarianceMatrix[1] = exy; + covarianceMatrix[2] = exz; + covarianceMatrix[3] = exy; + covarianceMatrix[4] = eyy; + covarianceMatrix[5] = eyz; + covarianceMatrix[6] = exz; + covarianceMatrix[7] = eyz; + covarianceMatrix[8] = ezz; + const { unitary } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult); + const rotation = result.halfAxes.copy(unitary); + let v1 = rotation.getColumn(0, scratchVector4); + let v2 = rotation.getColumn(1, scratchVector5); + let v3 = rotation.getColumn(2, scratchVector6); + let u1 = -Number.MAX_VALUE; + let u2 = -Number.MAX_VALUE; + let u3 = -Number.MAX_VALUE; + let l1 = Number.MAX_VALUE; + let l2 = Number.MAX_VALUE; + let l3 = Number.MAX_VALUE; + for (const position of positions) { + scratchVector23.copy(position); + u1 = Math.max(scratchVector23.dot(v1), u1); + u2 = Math.max(scratchVector23.dot(v2), u2); + u3 = Math.max(scratchVector23.dot(v3), u3); + l1 = Math.min(scratchVector23.dot(v1), l1); + l2 = Math.min(scratchVector23.dot(v2), l2); + l3 = Math.min(scratchVector23.dot(v3), l3); + } + v1 = v1.multiplyByScalar(0.5 * (l1 + u1)); + v2 = v2.multiplyByScalar(0.5 * (l2 + u2)); + v3 = v3.multiplyByScalar(0.5 * (l3 + u3)); + result.center.copy(v1).add(v2).add(v3); + const scale13 = scratchVector33.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5); + const scaleMatrix = new Matrix3([scale13[0], 0, 0, 0, scale13[1], 0, 0, 0, scale13[2]]); + result.halfAxes.multiplyRight(scaleMatrix); + return result; +} + +// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tile-2d-traversal.js +var TILE_SIZE3 = 512; +var MAX_MAPS = 3; +var REF_POINTS_5 = [ + [0.5, 0.5], + [0, 0], + [0, 1], + [1, 0], + [1, 1] +]; +var REF_POINTS_9 = REF_POINTS_5.concat([ + [0, 0.5], + [0.5, 0], + [1, 0.5], + [0.5, 1] +]); +var REF_POINTS_11 = REF_POINTS_9.concat([ + [0.25, 0.5], + [0.75, 0.5] +]); +var OSMNode = class _OSMNode { + constructor(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + } + get children() { + if (!this._children) { + const x = this.x * 2; + const y = this.y * 2; + const z = this.z + 1; + this._children = [ + new _OSMNode(x, y, z), + new _OSMNode(x, y + 1, z), + new _OSMNode(x + 1, y, z), + new _OSMNode(x + 1, y + 1, z) + ]; + } + return this._children; + } + // eslint-disable-next-line complexity + update(params) { + const { viewport, cullingVolume, elevationBounds, minZ, maxZ, bounds, offset, project } = params; + const boundingVolume = this.getBoundingVolume(elevationBounds, offset, project); + if (bounds && !this.insideBounds(bounds)) { + return false; + } + const isInside = cullingVolume.computeVisibility(boundingVolume); + if (isInside < 0) { + return false; + } + if (!this.childVisible) { + let { z } = this; + if (z < maxZ && z >= minZ) { + const distance8 = boundingVolume.distanceTo(viewport.cameraPosition) * viewport.scale / viewport.height; + z += Math.floor(Math.log2(distance8)); + } + if (z >= maxZ) { + this.selected = true; + return true; + } + } + this.selected = false; + this.childVisible = true; + for (const child of this.children) { + child.update(params); + } + return true; + } + getSelected(result = []) { + if (this.selected) { + result.push(this); + } + if (this._children) { + for (const node of this._children) { + node.getSelected(result); + } + } + return result; + } + insideBounds([minX, minY, maxX, maxY]) { + const scale13 = Math.pow(2, this.z); + const extent = TILE_SIZE3 / scale13; + return this.x * extent < maxX && this.y * extent < maxY && (this.x + 1) * extent > minX && (this.y + 1) * extent > minY; + } + getBoundingVolume(zRange, worldOffset, project) { + if (project) { + const refPoints = this.z < 1 ? REF_POINTS_11 : this.z < 2 ? REF_POINTS_9 : REF_POINTS_5; + const refPointPositions = []; + for (const p of refPoints) { + const lngLat = osmTile2lngLat(this.x + p[0], this.y + p[1], this.z); + lngLat[2] = zRange[0]; + refPointPositions.push(project(lngLat)); + if (zRange[0] !== zRange[1]) { + lngLat[2] = zRange[1]; + refPointPositions.push(project(lngLat)); + } + } + return makeOrientedBoundingBoxFromPoints(refPointPositions); + } + const scale13 = Math.pow(2, this.z); + const extent = TILE_SIZE3 / scale13; + const originX = this.x * extent + worldOffset * TILE_SIZE3; + const originY = TILE_SIZE3 - (this.y + 1) * extent; + return new AxisAlignedBoundingBox([originX, originY, zRange[0]], [originX + extent, originY + extent, zRange[1]]); + } +}; +function getOSMTileIndices(viewport, maxZ, zRange, bounds) { + const project = viewport instanceof GlobeViewport && viewport.resolution ? ( + // eslint-disable-next-line @typescript-eslint/unbound-method + viewport.projectPosition + ) : null; + const planes = Object.values(viewport.getFrustumPlanes()).map(({ normal, distance: distance8 }) => new Plane(normal.clone().negate(), distance8)); + const cullingVolume = new CullingVolume(planes); + const unitsPerMeter2 = viewport.distanceScales.unitsPerMeter[2]; + const elevationMin = zRange && zRange[0] * unitsPerMeter2 || 0; + const elevationMax = zRange && zRange[1] * unitsPerMeter2 || 0; + const minZ = viewport instanceof web_mercator_viewport_default && viewport.pitch <= 60 ? maxZ : 0; + if (bounds) { + const [minLng, minLat, maxLng, maxLat] = bounds; + const topLeft = lngLatToWorld([minLng, maxLat]); + const bottomRight = lngLatToWorld([maxLng, minLat]); + bounds = [topLeft[0], TILE_SIZE3 - topLeft[1], bottomRight[0], TILE_SIZE3 - bottomRight[1]]; + } + const root = new OSMNode(0, 0, 0); + const traversalParams = { + viewport, + project, + cullingVolume, + elevationBounds: [elevationMin, elevationMax], + minZ, + maxZ, + bounds, + // num. of worlds from the center. For repeated maps + offset: 0 + }; + root.update(traversalParams); + if (viewport instanceof web_mercator_viewport_default && viewport.subViewports && viewport.subViewports.length > 1) { + traversalParams.offset = -1; + while (root.update(traversalParams)) { + if (--traversalParams.offset < -MAX_MAPS) { + break; + } + } + traversalParams.offset = 1; + while (root.update(traversalParams)) { + if (++traversalParams.offset > MAX_MAPS) { + break; + } + } + } + return root.getSelected(); +} + +// node_modules/@deck.gl/geo-layers/dist/tileset-2d/utils.js +var TILE_SIZE4 = 512; +var DEFAULT_EXTENT = [-Infinity, -Infinity, Infinity, Infinity]; +var urlType = { + type: "object", + value: null, + validate: (value, propType) => propType.optional && value === null || typeof value === "string" || Array.isArray(value) && value.every((url) => typeof url === "string"), + equal: (value1, value2) => { + if (value1 === value2) { + return true; + } + if (!Array.isArray(value1) || !Array.isArray(value2)) { + return false; + } + const len8 = value1.length; + if (len8 !== value2.length) { + return false; + } + for (let i = 0; i < len8; i++) { + if (value1[i] !== value2[i]) { + return false; + } + } + return true; + } +}; +function transformBox(bbox, modelMatrix) { + const transformedCoords = [ + // top-left + modelMatrix.transformAsPoint([bbox[0], bbox[1]]), + // top-right + modelMatrix.transformAsPoint([bbox[2], bbox[1]]), + // bottom-left + modelMatrix.transformAsPoint([bbox[0], bbox[3]]), + // bottom-right + modelMatrix.transformAsPoint([bbox[2], bbox[3]]) + ]; + const transformedBox = [ + // Minimum x coord + Math.min(...transformedCoords.map((i) => i[0])), + // Minimum y coord + Math.min(...transformedCoords.map((i) => i[1])), + // Max x coord + Math.max(...transformedCoords.map((i) => i[0])), + // Max y coord + Math.max(...transformedCoords.map((i) => i[1])) + ]; + return transformedBox; +} +function stringHash(s) { + return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0)); +} +function getURLFromTemplate(template, tile) { + if (!template || !template.length) { + return null; + } + const { index: index2, id } = tile; + if (Array.isArray(template)) { + const i = stringHash(id) % template.length; + template = template[i]; + } + let url = template; + for (const key of Object.keys(index2)) { + const regex = new RegExp(`{${key}}`, "g"); + url = url.replace(regex, String(index2[key])); + } + if (Number.isInteger(index2.y) && Number.isInteger(index2.z)) { + url = url.replace(/\{-y\}/g, String(Math.pow(2, index2.z) - index2.y - 1)); + } + return url; +} +function getBoundingBox2(viewport, zRange, extent) { + let bounds; + if (zRange && zRange.length === 2) { + const [minZ, maxZ] = zRange; + const bounds0 = viewport.getBounds({ z: minZ }); + const bounds1 = viewport.getBounds({ z: maxZ }); + bounds = [ + Math.min(bounds0[0], bounds1[0]), + Math.min(bounds0[1], bounds1[1]), + Math.max(bounds0[2], bounds1[2]), + Math.max(bounds0[3], bounds1[3]) + ]; + } else { + bounds = viewport.getBounds(); + } + if (!viewport.isGeospatial) { + return [ + // Top corner should not be more then bottom corner in either direction + Math.max(Math.min(bounds[0], extent[2]), extent[0]), + Math.max(Math.min(bounds[1], extent[3]), extent[1]), + // Bottom corner should not be less then top corner in either direction + Math.min(Math.max(bounds[2], extent[0]), extent[2]), + Math.min(Math.max(bounds[3], extent[1]), extent[3]) + ]; + } + return [ + Math.max(bounds[0], extent[0]), + Math.max(bounds[1], extent[1]), + Math.min(bounds[2], extent[2]), + Math.min(bounds[3], extent[3]) + ]; +} +function getCullBounds({ viewport, z, cullRect }) { + const subViewports = viewport.subViewports || [viewport]; + return subViewports.map((v) => getCullBoundsInViewport(v, z || 0, cullRect)); +} +function getCullBoundsInViewport(viewport, z, cullRect) { + if (!Array.isArray(z)) { + const x = cullRect.x - viewport.x; + const y = cullRect.y - viewport.y; + const { width, height } = cullRect; + const unprojectOption = { targetZ: z }; + const topLeft = viewport.unproject([x, y], unprojectOption); + const topRight = viewport.unproject([x + width, y], unprojectOption); + const bottomLeft = viewport.unproject([x, y + height], unprojectOption); + const bottomRight = viewport.unproject([x + width, y + height], unprojectOption); + return [ + Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), + Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), + Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), + Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]) + ]; + } + const bounds0 = getCullBoundsInViewport(viewport, z[0], cullRect); + const bounds1 = getCullBoundsInViewport(viewport, z[1], cullRect); + return [ + Math.min(bounds0[0], bounds1[0]), + Math.min(bounds0[1], bounds1[1]), + Math.max(bounds0[2], bounds1[2]), + Math.max(bounds0[3], bounds1[3]) + ]; +} +function getIndexingCoords(bbox, scale13, modelMatrixInverse) { + if (modelMatrixInverse) { + const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map((i) => i * scale13 / TILE_SIZE4); + return transformedTileIndex; + } + return bbox.map((i) => i * scale13 / TILE_SIZE4); +} +function getScale(z, tileSize) { + return Math.pow(2, z) * TILE_SIZE4 / tileSize; +} +function osmTile2lngLat(x, y, z) { + const scale13 = getScale(z, TILE_SIZE4); + const lng = x / scale13 * 360 - 180; + const n = Math.PI - 2 * Math.PI * y / scale13; + const lat = 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))); + return [lng, lat]; +} +function tile2XY(x, y, z, tileSize) { + const scale13 = getScale(z, tileSize); + return [x / scale13 * TILE_SIZE4, y / scale13 * TILE_SIZE4]; +} +function tileToBoundingBox(viewport, x, y, z, tileSize = TILE_SIZE4) { + if (viewport.isGeospatial) { + const [west, north] = osmTile2lngLat(x, y, z); + const [east, south] = osmTile2lngLat(x + 1, y + 1, z); + return { west, north, east, south }; + } + const [left, top] = tile2XY(x, y, z, tileSize); + const [right, bottom] = tile2XY(x + 1, y + 1, z, tileSize); + return { left, top, right, bottom }; +} +function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInverse) { + const bbox = getBoundingBox2(viewport, null, extent); + const scale13 = getScale(z, tileSize); + const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale13, modelMatrixInverse); + const indices = []; + for (let x = Math.floor(minX); x < maxX; x++) { + for (let y = Math.floor(minY); y < maxY; y++) { + indices.push({ x, y, z }); + } + } + return indices; +} +function getTileIndices({ viewport, maxZoom, minZoom, zRange, extent, tileSize = TILE_SIZE4, modelMatrix, modelMatrixInverse, zoomOffset = 0 }) { + let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset; + if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) { + if (!extent) { + return []; + } + z = minZoom; + } + if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) { + z = maxZoom; + } + let transformedExtent = extent; + if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) { + transformedExtent = transformBox(extent, modelMatrix); + } + return viewport.isGeospatial ? getOSMTileIndices(viewport, z, zRange, extent) : getIdentityTileIndices(viewport, z, tileSize, transformedExtent || DEFAULT_EXTENT, modelMatrixInverse); +} + +// node_modules/@deck.gl/geo-layers/dist/tileset-2d/memoize.js +function memoize2(compute) { + let cachedArgs = {}; + let cachedResult; + return (args) => { + for (const key in args) { + if (!isEqual2(args[key], cachedArgs[key])) { + cachedResult = compute(args); + cachedArgs = args; + break; + } + } + return cachedResult; + }; +} +function isEqual2(a, b) { + if (a === b) { + return true; + } + if (Array.isArray(a)) { + const len8 = a.length; + if (!b || b.length !== len8) { + return false; + } + for (let i = 0; i < len8; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + return false; +} + +// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tileset-2d.js +var TILE_STATE_VISITED = 1; +var TILE_STATE_VISIBLE = 2; +var STRATEGY_NEVER = "never"; +var STRATEGY_REPLACE = "no-overlap"; +var STRATEGY_DEFAULT = "best-available"; +var DEFAULT_CACHE_SCALE = 5; +var STRATEGIES = { + [STRATEGY_DEFAULT]: updateTileStateDefault, + [STRATEGY_REPLACE]: updateTileStateReplace, + [STRATEGY_NEVER]: () => { + } +}; +var DEFAULT_TILESET2D_PROPS = { + extent: null, + tileSize: 512, + maxZoom: null, + minZoom: null, + maxCacheSize: null, + maxCacheByteSize: null, + refinementStrategy: "best-available", + zRange: null, + maxRequests: 6, + debounceTime: 0, + zoomOffset: 0, + // onTileLoad: (tile: Tile2DHeader) => void, // onTileUnload: (tile: Tile2DHeader) => void, // onTileError: (error: any, tile: Tile2DHeader) => void, /** Called when all tiles in the current viewport are loaded. */ + // onViewportLoad: ((tiles: Tile2DHeader[]) => void) | null, + onTileLoad: () => { + }, + onTileUnload: () => { + }, + onTileError: () => { + } +}; +var Tileset2D = class { + /** + * Takes in a function that returns tile data, a cache size, and a max and a min zoom level. + * Cache size defaults to 5 * number of tiles in the current viewport + */ + constructor(opts) { + this._getCullBounds = memoize2(getCullBounds); + this.opts = { ...DEFAULT_TILESET2D_PROPS, ...opts }; + this.setOptions(this.opts); + this.onTileLoad = (tile) => { + this.opts.onTileLoad?.(tile); + if (this.opts.maxCacheByteSize != null) { + this._cacheByteSize += tile.byteLength; + this._resizeCache(); + } + }; + this._requestScheduler = new RequestScheduler({ + throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0, + maxRequests: this.opts.maxRequests, + debounceTime: this.opts.debounceTime + }); + this._cache = /* @__PURE__ */ new Map(); + this._tiles = []; + this._dirty = false; + this._cacheByteSize = 0; + this._viewport = null; + this._zRange = null; + this._selectedTiles = null; + this._frameNumber = 0; + this._modelMatrix = new Matrix4(); + this._modelMatrixInverse = new Matrix4(); + } + /* Public API */ + get tiles() { + return this._tiles; + } + get selectedTiles() { + return this._selectedTiles; + } + get isLoaded() { + return this._selectedTiles !== null && this._selectedTiles.every((tile) => tile.isLoaded); + } + get needsReload() { + return this._selectedTiles !== null && this._selectedTiles.some((tile) => tile.needsReload); + } + setOptions(opts) { + Object.assign(this.opts, opts); + if (Number.isFinite(opts.maxZoom)) { + this._maxZoom = Math.floor(opts.maxZoom); + } + if (Number.isFinite(opts.minZoom)) { + this._minZoom = Math.ceil(opts.minZoom); + } + } + // Clean up any outstanding tile requests. + finalize() { + for (const tile of this._cache.values()) { + if (tile.isLoading) { + tile.abort(); + } + } + this._cache.clear(); + this._tiles = []; + this._selectedTiles = null; + } + reloadAll() { + for (const id of this._cache.keys()) { + const tile = this._cache.get(id); + if (!this._selectedTiles || !this._selectedTiles.includes(tile)) { + this._cache.delete(id); + } else { + tile.setNeedsReload(); + } + } + } + /** + * Update the cache with the given viewport and model matrix and triggers callback onUpdate. + */ + update(viewport, { zRange, modelMatrix } = { + zRange: null, + modelMatrix: null + }) { + const modelMatrixAsMatrix4 = modelMatrix ? new Matrix4(modelMatrix) : new Matrix4(); + const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix); + if (!this._viewport || !viewport.equals(this._viewport) || !equals(this._zRange, zRange) || isModelMatrixNew) { + if (isModelMatrixNew) { + this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert(); + this._modelMatrix = modelMatrixAsMatrix4; + } + this._viewport = viewport; + this._zRange = zRange; + const tileIndices = this.getTileIndices({ + viewport, + maxZoom: this._maxZoom, + minZoom: this._minZoom, + zRange, + modelMatrix: this._modelMatrix, + modelMatrixInverse: this._modelMatrixInverse + }); + this._selectedTiles = tileIndices.map((index2) => this._getTile(index2, true)); + if (this._dirty) { + this._rebuildTree(); + } + } else if (this.needsReload) { + this._selectedTiles = this._selectedTiles.map((tile) => this._getTile(tile.index, true)); + } + const changed = this.updateTileStates(); + this._pruneRequests(); + if (this._dirty) { + this._resizeCache(); + } + if (changed) { + this._frameNumber++; + } + return this._frameNumber; + } + // eslint-disable-next-line complexity + isTileVisible(tile, cullRect) { + if (!tile.isVisible) { + return false; + } + if (cullRect && this._viewport) { + const boundsArr = this._getCullBounds({ + viewport: this._viewport, + z: this._zRange, + cullRect + }); + const { bbox } = tile; + for (const [minX, minY, maxX, maxY] of boundsArr) { + let overlaps; + if ("west" in bbox) { + overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY; + } else { + const y0 = Math.min(bbox.top, bbox.bottom); + const y1 = Math.max(bbox.top, bbox.bottom); + overlaps = bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY; + } + if (overlaps) { + return true; + } + } + return false; + } + return true; + } + /* Public interface for subclassing */ + /** Returns array of tile indices in the current viewport */ + getTileIndices({ viewport, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) { + const { tileSize, extent, zoomOffset } = this.opts; + return getTileIndices({ + viewport, + maxZoom, + minZoom, + zRange, + tileSize, + extent, + modelMatrix, + modelMatrixInverse, + zoomOffset + }); + } + /** Returns unique string key for a tile index */ + getTileId(index2) { + return `${index2.x}-${index2.y}-${index2.z}`; + } + /** Returns a zoom level for a tile index */ + getTileZoom(index2) { + return index2.z; + } + /** Returns additional metadata to add to tile, bbox by default */ + getTileMetadata(index2) { + const { tileSize } = this.opts; + return { bbox: tileToBoundingBox(this._viewport, index2.x, index2.y, index2.z, tileSize) }; + } + /** Returns index of the parent tile */ + getParentIndex(index2) { + const x = Math.floor(index2.x / 2); + const y = Math.floor(index2.y / 2); + const z = index2.z - 1; + return { x, y, z }; + } + // Returns true if any tile's visibility changed + updateTileStates() { + const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT; + const visibilities = new Array(this._cache.size); + let i = 0; + for (const tile of this._cache.values()) { + visibilities[i++] = tile.isVisible; + tile.isSelected = false; + tile.isVisible = false; + } + for (const tile of this._selectedTiles) { + tile.isSelected = true; + tile.isVisible = true; + } + (typeof refinementStrategy === "function" ? refinementStrategy : STRATEGIES[refinementStrategy])(Array.from(this._cache.values())); + i = 0; + for (const tile of this._cache.values()) { + if (visibilities[i++] !== tile.isVisible) { + return true; + } + } + return false; + } + _pruneRequests() { + const { maxRequests = 0 } = this.opts; + const abortCandidates = []; + let ongoingRequestCount = 0; + for (const tile of this._cache.values()) { + if (tile.isLoading) { + ongoingRequestCount++; + if (!tile.isSelected && !tile.isVisible) { + abortCandidates.push(tile); + } + } + } + while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) { + const tile = abortCandidates.shift(); + tile.abort(); + ongoingRequestCount--; + } + } + // This needs to be called every time some tiles have been added/removed from cache + _rebuildTree() { + const { _cache } = this; + for (const tile of _cache.values()) { + tile.parent = null; + if (tile.children) { + tile.children.length = 0; + } + } + for (const tile of _cache.values()) { + const parent = this._getNearestAncestor(tile); + tile.parent = parent; + if (parent?.children) { + parent.children.push(tile); + } + } + } + /** + * Clear tiles that are not visible when the cache is full + */ + /* eslint-disable complexity */ + _resizeCache() { + const { _cache, opts } = this; + const maxCacheSize = opts.maxCacheSize ?? // @ts-expect-error called only when selectedTiles is initialized + (opts.maxCacheByteSize != null ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length); + const maxCacheByteSize = opts.maxCacheByteSize ?? Infinity; + const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize; + if (overflown) { + for (const [id, tile] of _cache) { + if (!tile.isVisible && !tile.isSelected) { + this._cacheByteSize -= opts.maxCacheByteSize != null ? tile.byteLength : 0; + _cache.delete(id); + this.opts.onTileUnload?.(tile); + } + if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) { + break; + } + } + this._rebuildTree(); + this._dirty = true; + } + if (this._dirty) { + this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom); + this._dirty = false; + } + } + _getTile(index2, create15) { + const id = this.getTileId(index2); + let tile = this._cache.get(id); + let needsReload = false; + if (!tile && create15) { + tile = new Tile2DHeader(index2); + Object.assign(tile, this.getTileMetadata(tile.index)); + Object.assign(tile, { id, zoom: this.getTileZoom(tile.index) }); + needsReload = true; + this._cache.set(id, tile); + this._dirty = true; + } else if (tile && tile.needsReload) { + needsReload = true; + } + if (tile && needsReload) { + tile.loadData({ + getData: this.opts.getTileData, + requestScheduler: this._requestScheduler, + onLoad: this.onTileLoad, + onError: this.opts.onTileError + }); + } + return tile; + } + _getNearestAncestor(tile) { + const { _minZoom = 0 } = this; + let index2 = tile.index; + while (this.getTileZoom(index2) > _minZoom) { + index2 = this.getParentIndex(index2); + const parent = this._getTile(index2); + if (parent) { + return parent; + } + } + return null; + } +}; +function updateTileStateDefault(allTiles) { + for (const tile of allTiles) { + tile.state = 0; + } + for (const tile of allTiles) { + if (tile.isSelected && !getPlaceholderInAncestors(tile)) { + getPlaceholderInChildren(tile); + } + } + for (const tile of allTiles) { + tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); + } +} +function updateTileStateReplace(allTiles) { + for (const tile of allTiles) { + tile.state = 0; + } + for (const tile of allTiles) { + if (tile.isSelected) { + getPlaceholderInAncestors(tile); + } + } + const sortedTiles = Array.from(allTiles).sort((t1, t2) => t1.zoom - t2.zoom); + for (const tile of sortedTiles) { + tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); + if (tile.children && (tile.isVisible || tile.state & TILE_STATE_VISITED)) { + for (const child of tile.children) { + child.state = TILE_STATE_VISITED; + } + } else if (tile.isSelected) { + getPlaceholderInChildren(tile); + } + } +} +function getPlaceholderInAncestors(startTile) { + let tile = startTile; + while (tile) { + if (tile.isLoaded || tile.content) { + tile.state |= TILE_STATE_VISIBLE; + return true; + } + tile = tile.parent; + } + return false; +} +function getPlaceholderInChildren(tile) { + for (const child of tile.children) { + if (child.isLoaded || child.content) { + child.state |= TILE_STATE_VISIBLE; + } else { + getPlaceholderInChildren(child); + } + } +} + +// node_modules/@deck.gl/geo-layers/dist/tile-layer/tile-layer.js +var defaultProps13 = { + TilesetClass: Tileset2D, + data: { type: "data", value: [] }, + dataComparator: urlType.equal, + renderSubLayers: { type: "function", value: (props) => new geojson_layer_default(props) }, + getTileData: { type: "function", optional: true, value: null }, + // TODO - change to onViewportLoad to align with Tile3DLayer + onViewportLoad: { type: "function", optional: true, value: null }, + onTileLoad: { type: "function", value: (tile) => { + } }, + onTileUnload: { type: "function", value: (tile) => { + } }, + // eslint-disable-next-line + onTileError: { type: "function", value: (err) => console.error(err) }, + extent: { type: "array", optional: true, value: null, compare: true }, + tileSize: 512, + maxZoom: null, + minZoom: 0, + maxCacheSize: null, + maxCacheByteSize: null, + refinementStrategy: STRATEGY_DEFAULT, + zRange: null, + maxRequests: 6, + debounceTime: 0, + zoomOffset: 0 +}; +var TileLayer = class extends composite_layer_default { + initializeState() { + this.state = { + tileset: null, + isLoaded: false + }; + } + finalizeState() { + this.state?.tileset?.finalize(); + } + get isLoaded() { + return Boolean(this.state?.tileset?.selectedTiles?.every((tile) => tile.isLoaded && tile.layers && tile.layers.every((layer) => layer.isLoaded))); + } + shouldUpdateState({ changeFlags }) { + return changeFlags.somethingChanged; + } + updateState({ changeFlags }) { + let { tileset } = this.state; + const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged; + const dataChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData); + if (!tileset) { + tileset = new this.props.TilesetClass(this._getTilesetOptions()); + this.setState({ tileset }); + } else if (propsChanged) { + tileset.setOptions(this._getTilesetOptions()); + if (dataChanged) { + tileset.reloadAll(); + } else { + tileset.tiles.forEach((tile) => { + tile.layers = null; + }); + } + } + this._updateTileset(); + } + _getTilesetOptions() { + const { tileSize, maxCacheSize, maxCacheByteSize, refinementStrategy, extent, maxZoom, minZoom, maxRequests, debounceTime, zoomOffset } = this.props; + return { + maxCacheSize, + maxCacheByteSize, + maxZoom, + minZoom, + tileSize, + refinementStrategy, + extent, + maxRequests, + debounceTime, + zoomOffset, + getTileData: this.getTileData.bind(this), + onTileLoad: this._onTileLoad.bind(this), + onTileError: this._onTileError.bind(this), + onTileUnload: this._onTileUnload.bind(this) + }; + } + _updateTileset() { + const tileset = this.state.tileset; + const { zRange, modelMatrix } = this.props; + const frameNumber = tileset.update(this.context.viewport, { zRange, modelMatrix }); + const { isLoaded } = tileset; + const loadingStateChanged = this.state.isLoaded !== isLoaded; + const tilesetChanged = this.state.frameNumber !== frameNumber; + if (isLoaded && (loadingStateChanged || tilesetChanged)) { + this._onViewportLoad(); + } + if (tilesetChanged) { + this.setState({ frameNumber }); + } + this.state.isLoaded = isLoaded; + } + _onViewportLoad() { + const { tileset } = this.state; + const { onViewportLoad } = this.props; + if (onViewportLoad) { + onViewportLoad(tileset.selectedTiles); + } + } + _onTileLoad(tile) { + this.props.onTileLoad(tile); + tile.layers = null; + this.setNeedsUpdate(); + } + _onTileError(error, tile) { + this.props.onTileError(error); + tile.layers = null; + this.setNeedsUpdate(); + } + _onTileUnload(tile) { + this.props.onTileUnload(tile); + } + // Methods for subclass to override + getTileData(tile) { + const { data, getTileData, fetch: fetch2 } = this.props; + const { signal } = tile; + tile.url = typeof data === "string" || Array.isArray(data) ? getURLFromTemplate(data, tile) : null; + if (getTileData) { + return getTileData(tile); + } + if (fetch2 && tile.url) { + return fetch2(tile.url, { propName: "data", layer: this, signal }); + } + return null; + } + renderSubLayers(props) { + return this.props.renderSubLayers(props); + } + getSubLayerPropsByTile(tile) { + return null; + } + getPickingInfo(params) { + const sourceLayer = params.sourceLayer; + const sourceTile = sourceLayer.props.tile; + const info = params.info; + if (info.picked) { + info.tile = sourceTile; + } + info.sourceTile = sourceTile; + info.sourceTileSubLayer = sourceLayer; + return info; + } + _updateAutoHighlight(info) { + info.sourceTileSubLayer.updateAutoHighlight(info); + } + renderLayers() { + return this.state.tileset.tiles.map((tile) => { + const subLayerProps = this.getSubLayerPropsByTile(tile); + if (!tile.isLoaded && !tile.content) { + } else if (!tile.layers) { + const layers = this.renderSubLayers({ + ...this.props, + ...this.getSubLayerProps({ + id: tile.id, + updateTriggers: this.props.updateTriggers + }), + data: tile.content, + _offset: 0, + tile + }); + tile.layers = flatten(layers, Boolean).map((layer) => layer.clone({ + tile, + ...subLayerProps + })); + } else if (subLayerProps && tile.layers[0] && Object.keys(subLayerProps).some((propName) => tile.layers[0].props[propName] !== subLayerProps[propName])) { + tile.layers = tile.layers.map((layer) => layer.clone(subLayerProps)); + } + return tile.layers; + }); + } + filterSubLayer({ layer, cullRect }) { + const { tile } = layer.props; + return this.state.tileset.isTileVisible(tile, cullRect); + } +}; +TileLayer.defaultProps = defaultProps13; +TileLayer.layerName = "TileLayer"; +var tile_layer_default = TileLayer; + +// notebooks/bike_flow_map_widget.mjs +var Observable = (initialValue) => { + let value = initialValue; + const subscribers = /* @__PURE__ */ new Set(); + return { + get: () => value, + set: (newValue) => { + if (value === newValue) + return; + value = newValue; + subscribers.forEach((fn) => fn(value)); + }, + subscribe: (fn, options = { immediate: true }) => { + subscribers.add(fn); + if (options.immediate) + fn(value); + return () => subscribers.delete(fn); + } + }; +}; +var createStore = () => ({ + stations: Observable([]), + edge_index: Observable({}), + click_info: Observable({}), + selected_rows: Observable([]), + selected_cols: Observable([]), + width: Observable(560), + height: Observable(800), + debug: Observable(false), + focus: Observable(""), + highlights: Observable([]), + edges: Observable([]), + deck_check: Observable({ inputs: true, computed: true, layers: true }), + deck_ready: Observable(false), + palette_rgb: Observable([]) +}); +var log3 = (store, ...args) => { + if (store.debug.get()) + console.log("[bike-map]", ...args); +}; +var sameList = (a, b) => { + if (!Array.isArray(a) || !Array.isArray(b)) + return false; + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; i += 1) + if (a[i] !== b[i]) + return false; + return true; +}; +var setDerivedState = (store, { focus, highlights, edges }) => { + const curFocus = store.focus.get() || ""; + const curHighlights = store.highlights.get() || []; + const curEdges = store.edges.get() || []; + const nextFocus = focus || ""; + const nextHighlights = highlights || []; + const nextEdges = edges || []; + let changed = false; + if (curFocus !== nextFocus) { + store.focus.set(nextFocus); + changed = true; + } + if (!sameList(curHighlights, nextHighlights)) { + store.highlights.set(nextHighlights); + changed = true; + } + const curStr = JSON.stringify(curEdges); + const nextStr = JSON.stringify(nextEdges); + if (curStr !== nextStr) { + store.edges.set(nextEdges); + changed = true; + } + return changed; +}; +function basemapLayer() { + return new tile_layer_default({ + id: "bike-basemap", + data: "https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png", + minZoom: 0, + maxZoom: 19, + tileSize: 256, + renderSubLayers: (props) => { + if (!props.data || !props.tile) + return null; + let west; + let south; + let east; + let north; + const bb = props.tile.boundingBox; + if (bb && bb.length === 2) { + [[west, south], [east, north]] = bb; + } else if (props.tile.bbox && "west" in props.tile.bbox) { + ({ west, south, east, north } = props.tile.bbox); + } else { + return null; + } + return new bitmap_layer_default(props, { + id: `${props.id}-bitmap`, + data: [0], + image: props.data, + bounds: [west, south, east, north] + }); + } + }); +} +var STATION_PALETTE_HEX = [ + "#E69F00", + "#56B4E9", + "#009E73", + "#F0E442", + "#0072B2", + "#D55E00", + "#CC79A7", + "#393b79", + "#aec7e8", + "#ff7f0e", + "#ffbb78", + "#98df8a", + "#bcbd22", + "#404040", + "#ff9896", + "#c5b0d5", + "#8c5648", + "#1f77b4", + "#5254a3", + "#FFDB58", + "#c49c94", + "#e377c2", + "#7f7f7f", + "#2ca02c", + "#9467bd", + "#dbdb8d", + "#17becf", + "#637939", + "#6b6ecf", + "#9c9ede", + "#d62728", + "#8ca252", + "#8c6d31", + "#bd9e39", + "#e7cb94", + "#843c39", + "#ad494a", + "#d6616b", + "#7b4173", + "#a55194", + "#ce6dbd", + "#de9ed6" +]; +function hexToRgb(hex) { + const h = String(hex).replace("#", ""); + if (h.length !== 6) + return [145, 150, 170]; + return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)]; +} +var DEFAULT_PALETTE_RGB = STATION_PALETTE_HEX.map(hexToRgb); +function resolvePaletteRgb(store) { + const raw = store.palette_rgb.get(); + if (Array.isArray(raw) && raw.length > 0) { + return raw.map((row) => { + if (Array.isArray(row) && row.length >= 3) { + return [Number(row[0]), Number(row[1]), Number(row[2])]; + } + return [145, 150, 170]; + }); + } + return DEFAULT_PALETTE_RGB; +} +var CLUSTER_UNKNOWN_RGB = [176, 180, 190]; +var TRAFFIC_UNCONNECTED_RGBA = [168, 172, 180, 118]; +function clusterRgbFromId(clusterId, paletteRgb) { + const id = Number(clusterId); + if (!Number.isFinite(id) || id <= 0) + return CLUSTER_UNKNOWN_RGB; + const pal = paletteRgb.length ? paletteRgb : DEFAULT_PALETTE_RGB; + const c = pal[(id - 1) % pal.length]; + return [c[0], c[1], c[2]]; +} +function clusterFillWithAlpha(clusterId, alpha, paletteRgb) { + const [r, g, b] = clusterRgbFromId(clusterId, paletteRgb); + return [r, g, b, alpha]; +} +function clusterFillColor(clusterId, paletteRgb) { + return clusterFillWithAlpha(clusterId, 228, paletteRgb); +} +var FLOW_OUT_RGB = [255, 70, 70]; +var FLOW_IN_RGB = [70, 150, 255]; +function flowBlendRgb(outW, inW) { + const o = Math.max(0, Number(outW) || 0); + const i = Math.max(0, Number(inW) || 0); + const sum = o + i; + if (sum <= 0) + return [145, 150, 170]; + const t = o / sum; + const lerp12 = (a, b, x) => Math.round(a + (b - a) * x); + return [ + lerp12(FLOW_IN_RGB[0], FLOW_OUT_RGB[0], t), + lerp12(FLOW_IN_RGB[1], FLOW_OUT_RGB[1], t), + lerp12(FLOW_IN_RGB[2], FLOW_OUT_RGB[2], t) + ]; +} +function flowBlendWithAlpha(outW, inW, alpha) { + const [r, g, b] = flowBlendRgb(outW, inW); + return [r, g, b, alpha]; +} +function fitViewState(stations) { + if (!stations.length) + return { longitude: -73.98, latitude: 40.75, zoom: 10.5, pitch: 0, bearing: 0 }; + let minLat = Infinity; + let maxLat = -Infinity; + let minLng = Infinity; + let maxLng = -Infinity; + for (const s of stations) { + const lat = Number(s.lat); + const lng = Number(s.lng); + if (!Number.isFinite(lat) || !Number.isFinite(lng)) + continue; + minLat = Math.min(minLat, lat); + maxLat = Math.max(maxLat, lat); + minLng = Math.min(minLng, lng); + maxLng = Math.max(maxLng, lng); + } + const latitude = (minLat + maxLat) / 2; + const longitude = (minLng + maxLng) / 2; + const span = Math.max(maxLat - minLat, maxLng - minLng, 0.02); + const zoom = Math.min(14, Math.max(9, 12 - Math.log2(span * 80))); + return { latitude, longitude, zoom, pitch: 0, bearing: 0 }; +} +function render({ model, el }) { + const store = createStore(); + const root = document.createElement("div"); + root.style.background = "#e2e4e8"; + root.style.borderRadius = "4px"; + root.style.overflow = "hidden"; + el.appendChild(root); + let deck = null; + let raf = 0; + let renderVersion = 0; + let lastSig = ""; + let lastActionKey = null; + let lastActionSeq = -1; + let linkInteractionSeq = 0; + let linkSnap = { ci: "", rows: "", cols: "" }; + const getLinkedWeights = () => { + const focus = store.focus.get(); + const idx = store.edge_index.get() || {}; + const out = /* @__PURE__ */ new Map(); + const inn = /* @__PURE__ */ new Map(); + if (!focus || !idx[focus]) + return { out, inn }; + for (const e of idx[focus].out || []) + out.set(e.name, Number(e.w) || 0); + for (const e of idx[focus].in || []) + inn.set(e.name, Number(e.w) || 0); + return { out, inn }; + }; + const computeStateFromInputs = () => { + const info = store.click_info.get() || {}; + const t = String(info.type || "").replace("-", "_"); + const v = info.value || {}; + const idx = store.edge_index.get() || {}; + const seq = linkInteractionSeq; + const sig = JSON.stringify({ + t, + v, + rows: store.selected_rows.get() || [], + cols: store.selected_cols.get() || [] + }); + if (sig === lastSig) { + log3(store, "compute skip (same signature)", t); + return; + } + lastSig = sig; + log3(store, "compute start", t, "rows", (store.selected_rows.get() || []).length, "cols", (store.selected_cols.get() || []).length); + const setState = (focus, highlights, edges) => setDerivedState(store, { focus, highlights, edges }); + const stationFrom = (raw) => { + const txt = String(raw || "").trim(); + if (idx[txt]) + return txt; + if (txt.includes("|")) { + const rhs = txt.split("|", 2)[1].trim(); + if (idx[rhs]) + return rhs; + } + return txt; + }; + if (t === "row_label" || t === "col_label") { + const name2 = stationFrom(v.name); + const actionKey = `${t}:${name2}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState("", [], []); + lastActionKey = null; + lastActionSeq = seq; + log3(store, "label toggle off", t, name2); + return; + } + const bucket = idx[name2] || { out: [], in: [] }; + const edges = [ + ...(bucket.out || []).map((e) => ({ + source_name: name2, + target_name: e.name, + direction: "out", + opacity: e.opacity, + weight: e.w, + geom_share: e.geom_share, + trips: e.trips, + source: e.source, + target: e.target + })), + ...(bucket.in || []).map((e) => ({ + source_name: e.name, + target_name: name2, + direction: "in", + opacity: e.opacity, + weight: e.w, + geom_share: e.geom_share, + trips: e.trips, + source: e.source, + target: e.target + })) + ]; + setState(name2, name2 ? [name2] : [], edges); + lastActionKey = actionKey; + lastActionSeq = seq; + log3(store, "label", t, name2, "edges", edges.length); + return; + } + if (t === "mat_value") { + const row = stationFrom((v.row || {}).name); + const col = stationFrom((v.col || {}).name); + const actionKey = `mat:${col}->${row}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState("", [], []); + lastActionKey = null; + lastActionSeq = seq; + log3(store, "mat toggle off", col, row); + return; + } + const p = Number(v.value || 0); + const src = idx[col]?.coord; + const dst = idx[row]?.coord; + const outEdge = (idx[col]?.out || []).find((e) => e.name === row); + const g = outEdge != null ? Number(outEdge.geom_share) : NaN; + const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); + const edge = src && dst ? [{ + source_name: col, + target_name: row, + direction: "direct", + opacity: Math.max(0.2, Math.min(0.98, p * 3)), + weight: p, + geom_share: geom, + trips: outEdge?.trips, + source: src, + target: dst + }] : []; + setState("", [col, row].filter(Boolean), edge); + lastActionKey = actionKey; + lastActionSeq = seq; + log3(store, "mat", col, "->", row, p); + return; + } + if (t === "row_dendro" || t === "col_dendro") { + const fromClick = (v.selected_names || []).map(stationFrom).filter((n) => idx[n]); + const rows = (store.selected_rows.get() || []).map(stationFrom).filter((n) => idx[n]); + const cols = (store.selected_cols.get() || []).map(stationFrom).filter((n) => idx[n]); + if (v.is_unselecting || Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0) { + setState("", [], []); + lastActionKey = null; + lastActionSeq = seq; + log3(store, "dendro clear", t); + return; + } + const names = t === "col_dendro" ? cols.length ? cols : fromClick.length ? fromClick : rows : rows.length ? rows : fromClick.length ? fromClick : cols; + const actionKey = `${t}:${names.slice().sort().join("|")}`; + setState("", names, []); + lastActionKey = actionKey; + lastActionSeq = seq; + log3(store, "dendro", t, "names", names.length, "rows", rows.length, "cols", cols.length); + return; + } + if (t === "cat_value") { + const axis = v.axis; + const attrIndex = v.attr_index; + const catVal = v.value; + const rawNames = Array.isArray(v.node_names) ? v.node_names : []; + const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n]))]; + const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState("", [], []); + lastActionKey = null; + lastActionSeq = seq; + log3(store, "cat toggle off", axis, catVal); + return; + } + setState("", names, []); + lastActionKey = actionKey; + lastActionSeq = seq; + log3(store, "cat", axis, "value", catVal, "stations", names.length); + return; + } + }; + const buildLayers = () => { + const stations = store.stations.get() || []; + const focus = store.focus.get(); + const highlightArr = store.highlights.get() || []; + const highlights = new Set(highlightArr); + const edges = store.edges.get() || []; + const stationNameSet = new Set(stations.map((d) => d.name)); + const overlap = highlightArr.filter((n) => stationNameSet.has(n)); + log3(store, "buildLayers", { + focus, + highlightCount: highlightArr.length, + overlap: overlap.length, + sample: overlap.slice(0, 5), + stations: stations.length, + edges: edges.length, + version: renderVersion + }); + const hasSel = Boolean(focus) || highlights.size > 0; + const { out, inn } = getLinkedWeights(); + const highlightKey = Array.from(highlights).sort().join("|"); + const outKey = Array.from(out.entries()).map(([k, v]) => `${k}:${v}`).sort().join("|"); + const inKey = Array.from(inn.entries()).map(([k, v]) => `${k}:${v}`).sort().join("|"); + const styleKey = `${focus}__${highlightKey}__${outKey}__${inKey}__${hasSel}`; + let peakLinkWeight = 0; + for (const v of out.values()) + peakLinkWeight = Math.max(peakLinkWeight, v); + for (const v of inn.values()) + peakLinkWeight = Math.max(peakLinkWeight, v); + let hubSumOut = 0; + let hubSumIn = 0; + for (const v of out.values()) + hubSumOut += Number(v) || 0; + for (const v of inn.values()) + hubSumIn += Number(v) || 0; + const linkedRadius = (n) => { + const wo = out.has(n) ? Math.min(1, Math.max(0, out.get(n) || 0)) : 0; + const wi = inn.has(n) ? Math.min(1, Math.max(0, inn.get(n) || 0)) : 0; + const w = Math.max(wo, wi); + return 100 + 125 * Math.sqrt(w); + }; + const focusHubRadius = () => 178 + 48 * Math.sqrt(Math.min(1, peakLinkWeight)); + const palRgb = resolvePaletteRgb(store); + const pointData = stations.map((d) => d); + const points = new scatterplot_layer_default({ + id: "bike-stations", + data: pointData, + pickable: true, + radiusUnits: "meters", + radiusMinPixels: 3, + radiusMaxPixels: 56, + getPosition: (d) => [Number(d.lng), Number(d.lat)], + getRadius: (d) => { + const n = d.name; + if (focus && n === focus) + return focusHubRadius(); + if (focus && (out.has(n) || inn.has(n))) + return linkedRadius(n); + if (highlights.has(n)) + return 90; + return hasSel ? 70 : 90; + }, + getFillColor: (d) => { + const n = d.name; + if (focus) { + if (n === focus) { + return flowBlendWithAlpha(hubSumOut, hubSumIn, 248); + } + if (out.has(n) || inn.has(n)) { + const wo = out.has(n) ? Math.max(0, out.get(n) || 0) : 0; + const wi = inn.has(n) ? Math.max(0, inn.get(n) || 0) : 0; + const w = Math.max(wo, wi); + const a = Math.round(148 + 102 * Math.sqrt(Math.min(1, w))); + return flowBlendWithAlpha(wo, wi, a); + } + return TRAFFIC_UNCONNECTED_RGBA; + } + if (highlights.size > 0) { + const c = clusterFillColor(d.cluster_id, palRgb); + if (highlights.has(n)) + return [c[0], c[1], c[2], 242]; + return [c[0], c[1], c[2], 36]; + } + return clusterFillColor(d.cluster_id, palRgb); + }, + updateTriggers: { + getRadius: [styleKey, renderVersion], + getFillColor: [styleKey, renderVersion] + }, + onClick: (info) => { + if (!info.object) + return; + const n = info.object.name; + if (store.focus.get() === n) { + setDerivedState(store, { focus: "", highlights: [], edges: [] }); + lastActionKey = null; + scheduleRender(); + log3(store, "map toggle off", n); + return; + } + const idx = store.edge_index.get() || {}; + const bucket = idx[n] || { out: [], in: [] }; + const e = [ + ...(bucket.out || []).map((x) => ({ + source_name: n, + target_name: x.name, + direction: "out", + opacity: x.opacity, + weight: x.w, + geom_share: x.geom_share, + trips: x.trips, + source: x.source, + target: x.target + })), + ...(bucket.in || []).map((x) => ({ + source_name: x.name, + target_name: n, + direction: "in", + opacity: x.opacity, + weight: x.w, + geom_share: x.geom_share, + trips: x.trips, + source: x.source, + target: x.target + })) + ]; + setDerivedState(store, { focus: n, highlights: [n], edges: e }); + lastActionKey = null; + scheduleRender(); + log3(store, "map click", n, "edges", e.length); + } + }); + const lineWidthFor = (d) => { + if (d.direction === "direct") { + const g2 = Number(d.geom_share); + const x = Number.isFinite(g2) ? Math.min(1, Math.max(0, g2)) : 0; + return 4 + 14 * x; + } + const g = Number(d.geom_share); + if (Number.isFinite(g) && g > 0) { + const x = Math.min(1, g); + return 4 + 22 * x ** 0.92; + } + return 2.5; + }; + const lines = new line_layer_default({ + id: "bike-flow-lines", + data: edges, + widthUnits: "pixels", + getSourcePosition: (d) => d.source, + getTargetPosition: (d) => d.target, + getWidth: lineWidthFor, + updateTriggers: { + getWidth: [styleKey, renderVersion] + }, + getColor: (d) => { + const a = Math.round(Math.max(0, Math.min(1, Number(d.opacity) || 0)) * 255); + if (d.direction === "in") + return [70, 150, 255, a]; + if (d.direction === "out") + return [255, 70, 70, a]; + return [255, 240, 120, a]; + } + }); + return [basemapLayer(), lines, points]; + }; + let pendingProps = null; + const prepareDeckProps = () => { + const stations = store.stations.get() || []; + const w = Number(store.width.get() || 560); + const h = Number(store.height.get() || 800); + root.style.width = `${w}px`; + root.style.height = `${h}px`; + const props = { + parent: root, + width: w, + height: h, + controller: true, + layers: buildLayers(), + getTooltip: ({ object, layer }) => { + if (!object || layer.id !== "bike-stations") + return null; + const sid = object.station_id != null ? String(object.station_id) : ""; + const nm = object.name != null ? String(object.name) : ""; + const html = sid ? `
id ${sid}
name ${nm}
` : `
${nm}
`; + return { + html, + style: { + backgroundColor: "rgba(255,255,255,0.94)", + color: "#1a1d24", + padding: "6px 10px", + borderRadius: "4px", + boxShadow: "0 1px 4px rgba(0,0,0,0.18)" + } + }; + } + }; + if (!deck) { + deck = new deck_default({ ...props, initialViewState: fitViewState(stations) }); + log3(store, "deck init", "stations", stations.length); + pendingProps = null; + return; + } + pendingProps = props; + }; + const applyDeckProps = () => { + if (deck && pendingProps) { + deck.setProps(pendingProps); + if (typeof deck.redraw === "function") + deck.redraw(true); + log3(store, "deck setProps", { + layers: pendingProps.layers.length, + highlights: (store.highlights.get() || []).length, + edges: (store.edges.get() || []).length, + version: renderVersion + }); + pendingProps = null; + } + }; + store.deck_check.subscribe( + (check) => { + const ready = Object.values(check).every((v) => v === true); + if (store.deck_ready.get() !== ready) + store.deck_ready.set(ready); + }, + { immediate: true } + ); + store.deck_ready.subscribe( + (ready) => { + if (!ready) + return; + log3(store, "deck_ready -> apply"); + applyDeckProps(); + }, + { immediate: false } + ); + const scheduleRender = () => { + if (raf) + return; + raf = requestAnimationFrame(() => { + raf = 0; + renderVersion += 1; + log3(store, "flush start", { version: renderVersion }); + store.deck_check.set({ inputs: false, computed: false, layers: false }); + store.deck_check.set({ ...store.deck_check.get(), inputs: true }); + computeStateFromInputs(); + store.deck_check.set({ ...store.deck_check.get(), computed: true }); + prepareDeckProps(); + store.deck_check.set({ ...store.deck_check.get(), layers: true }); + log3(store, "flush end", store.deck_check.get()); + }); + }; + [ + store.stations, + store.edge_index, + store.click_info, + store.selected_rows, + store.selected_cols, + store.width, + store.height, + store.palette_rgb + ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); + const syncFromModel = () => { + const ci = JSON.stringify(model.get("click_info") || {}); + const rows = JSON.stringify(model.get("selected_rows") || []); + const cols = JSON.stringify(model.get("selected_cols") || []); + if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols) { + linkSnap = { ci, rows, cols }; + linkInteractionSeq += 1; + } + log3(store, "syncFromModel start"); + store.stations.set(model.get("stations") || []); + store.palette_rgb.set(model.get("palette_rgb") || []); + store.edge_index.set(model.get("edge_index") || {}); + store.click_info.set(model.get("click_info") || {}); + store.selected_rows.set(model.get("selected_rows") || []); + store.selected_cols.set(model.get("selected_cols") || []); + store.width.set(model.get("width") || 560); + store.height.set(model.get("height") || 800); + store.debug.set(Boolean(model.get("debug"))); + log3(store, "syncFromModel done", { + linkSeq: linkInteractionSeq, + rows: (store.selected_rows.get() || []).length, + cols: (store.selected_cols.get() || []).length, + clickType: (store.click_info.get() || {}).type || null + }); + scheduleRender(); + }; + [ + "stations", + "edge_index", + "click_info", + "selected_rows", + "selected_cols", + "width", + "height", + "debug", + "palette_rgb" + ].forEach((name2) => model.on(`change:${name2}`, syncFromModel)); + syncFromModel(); + return () => { + if (raf) + cancelAnimationFrame(raf); + if (deck) + deck.finalize(); + }; +} +var bike_flow_map_widget_default = { render }; +export { + bike_flow_map_widget_default as default +}; diff --git a/notebooks/bike_flow_map_widget.mjs b/notebooks/bike_flow_map_widget.mjs new file mode 100644 index 000000000..d38f72a73 --- /dev/null +++ b/notebooks/bike_flow_map_widget.mjs @@ -0,0 +1,726 @@ +import { BitmapLayer, Deck, LineLayer, ScatterplotLayer, TileLayer } from 'deck.gl'; + +const Observable = (initialValue) => { + let value = initialValue; + const subscribers = new Set(); + return { + get: () => value, + set: (newValue) => { + if (value === newValue) return; + value = newValue; + subscribers.forEach((fn) => fn(value)); + }, + subscribe: (fn, options = { immediate: true }) => { + subscribers.add(fn); + if (options.immediate) fn(value); + return () => subscribers.delete(fn); + }, + }; +}; + +const createStore = () => ({ + stations: Observable([]), + edge_index: Observable({}), + click_info: Observable({}), + selected_rows: Observable([]), + selected_cols: Observable([]), + width: Observable(560), + height: Observable(800), + debug: Observable(false), + focus: Observable(''), + highlights: Observable([]), + edges: Observable([]), + deck_check: Observable({ inputs: true, computed: true, layers: true }), + deck_ready: Observable(false), + palette_rgb: Observable([]), +}); + +const log = (store, ...args) => { + if (store.debug.get()) console.log('[bike-map]', ...args); +}; + +const sameList = (a, b) => { + if (!Array.isArray(a) || !Array.isArray(b)) return false; + if (a.length !== b.length) return false; + for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false; + return true; +}; + +const setDerivedState = (store, { focus, highlights, edges }) => { + const curFocus = store.focus.get() || ''; + const curHighlights = store.highlights.get() || []; + const curEdges = store.edges.get() || []; + + const nextFocus = focus || ''; + const nextHighlights = highlights || []; + const nextEdges = edges || []; + + let changed = false; + if (curFocus !== nextFocus) { + store.focus.set(nextFocus); + changed = true; + } + if (!sameList(curHighlights, nextHighlights)) { + store.highlights.set(nextHighlights); + changed = true; + } + const curStr = JSON.stringify(curEdges); + const nextStr = JSON.stringify(nextEdges); + if (curStr !== nextStr) { + store.edges.set(nextEdges); + changed = true; + } + return changed; +}; + +function basemapLayer() { + return new TileLayer({ + id: 'bike-basemap', + data: 'https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png', + minZoom: 0, + maxZoom: 19, + tileSize: 256, + renderSubLayers: (props) => { + if (!props.data || !props.tile) return null; + let west; + let south; + let east; + let north; + const bb = props.tile.boundingBox; + if (bb && bb.length === 2) { + [[west, south], [east, north]] = bb; + } else if (props.tile.bbox && 'west' in props.tile.bbox) { + ({ west, south, east, north } = props.tile.bbox); + } else { + return null; + } + return new BitmapLayer(props, { + id: `${props.id}-bitmap`, + data: [0], + image: props.data, + bounds: [west, south, east, north], + }); + }, + }); +} + +/** Okabe–Ito (colorblind-safe) first, then Celldega `clust.constants._COLOR_PALETTE` — keep in sync with notebook `STATION_PALETTE_HEX`. */ +const STATION_PALETTE_HEX = [ + '#E69F00', '#56B4E9', '#009E73', '#F0E442', '#0072B2', '#D55E00', '#CC79A7', + '#393b79', '#aec7e8', '#ff7f0e', '#ffbb78', '#98df8a', '#bcbd22', '#404040', + '#ff9896', '#c5b0d5', '#8c5648', '#1f77b4', '#5254a3', '#FFDB58', '#c49c94', + '#e377c2', '#7f7f7f', '#2ca02c', '#9467bd', '#dbdb8d', '#17becf', '#637939', + '#6b6ecf', '#9c9ede', '#d62728', '#8ca252', '#8c6d31', '#bd9e39', '#e7cb94', + '#843c39', '#ad494a', '#d6616b', '#7b4173', '#a55194', '#ce6dbd', '#de9ed6', +]; + +function hexToRgb(hex) { + const h = String(hex).replace('#', ''); + if (h.length !== 6) return [145, 150, 170]; + return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)]; +} + +const DEFAULT_PALETTE_RGB = STATION_PALETTE_HEX.map(hexToRgb); + +function resolvePaletteRgb(store) { + const raw = store.palette_rgb.get(); + if (Array.isArray(raw) && raw.length > 0) { + return raw.map((row) => { + if (Array.isArray(row) && row.length >= 3) { + return [Number(row[0]), Number(row[1]), Number(row[2])]; + } + return [145, 150, 170]; + }); + } + return DEFAULT_PALETTE_RGB; +} + +/** cluster_id 0 = unclustered / unknown (matches Clustergram label "0"). */ +const CLUSTER_UNKNOWN_RGB = [176, 180, 190]; + +/** Traffic view: stations with no edge to the focused hub. */ +const TRAFFIC_UNCONNECTED_RGBA = [168, 172, 180, 118]; + +function clusterRgbFromId(clusterId, paletteRgb) { + const id = Number(clusterId); + if (!Number.isFinite(id) || id <= 0) return CLUSTER_UNKNOWN_RGB; + const pal = paletteRgb.length ? paletteRgb : DEFAULT_PALETTE_RGB; + const c = pal[(id - 1) % pal.length]; + return [c[0], c[1], c[2]]; +} + +function clusterFillWithAlpha(clusterId, alpha, paletteRgb) { + const [r, g, b] = clusterRgbFromId(clusterId, paletteRgb); + return [r, g, b, alpha]; +} + +function clusterFillColor(clusterId, paletteRgb) { + return clusterFillWithAlpha(clusterId, 228, paletteRgb); +} + +/** Same endpoints as LineLayer getColor: out red, in blue. */ +const FLOW_OUT_RGB = [255, 70, 70]; +const FLOW_IN_RGB = [70, 150, 255]; + +function flowBlendRgb(outW, inW) { + const o = Math.max(0, Number(outW) || 0); + const i = Math.max(0, Number(inW) || 0); + const sum = o + i; + if (sum <= 0) return [145, 150, 170]; + const t = o / sum; + const lerp = (a, b, x) => Math.round(a + (b - a) * x); + return [ + lerp(FLOW_IN_RGB[0], FLOW_OUT_RGB[0], t), + lerp(FLOW_IN_RGB[1], FLOW_OUT_RGB[1], t), + lerp(FLOW_IN_RGB[2], FLOW_OUT_RGB[2], t), + ]; +} + +function flowBlendWithAlpha(outW, inW, alpha) { + const [r, g, b] = flowBlendRgb(outW, inW); + return [r, g, b, alpha]; +} + +function fitViewState(stations) { + if (!stations.length) return { longitude: -73.98, latitude: 40.75, zoom: 10.5, pitch: 0, bearing: 0 }; + let minLat = Infinity; let maxLat = -Infinity; let minLng = Infinity; let maxLng = -Infinity; + for (const s of stations) { + const lat = Number(s.lat); const lng = Number(s.lng); + if (!Number.isFinite(lat) || !Number.isFinite(lng)) continue; + minLat = Math.min(minLat, lat); maxLat = Math.max(maxLat, lat); + minLng = Math.min(minLng, lng); maxLng = Math.max(maxLng, lng); + } + const latitude = (minLat + maxLat) / 2; + const longitude = (minLng + maxLng) / 2; + const span = Math.max(maxLat - minLat, maxLng - minLng, 0.02); + const zoom = Math.min(14, Math.max(9, 12 - Math.log2(span * 80))); + return { latitude, longitude, zoom, pitch: 0, bearing: 0 }; +} + +function render({ model, el }) { + const store = createStore(); + const root = document.createElement('div'); + root.style.background = '#e2e4e8'; + root.style.borderRadius = '4px'; + root.style.overflow = 'hidden'; + el.appendChild(root); + + let deck = null; + let raf = 0; + let renderVersion = 0; + let lastSig = ""; + let lastActionKey = null; + let lastActionSeq = -1; + /** Increments when linked Clustergram traits change (jslink / static HTML); drives label+mat toggle. */ + let linkInteractionSeq = 0; + let linkSnap = { ci: '', rows: '', cols: '' }; + + const getLinkedWeights = () => { + const focus = store.focus.get(); + const idx = store.edge_index.get() || {}; + const out = new Map(); + const inn = new Map(); + if (!focus || !idx[focus]) return { out, inn }; + for (const e of idx[focus].out || []) out.set(e.name, Number(e.w) || 0); + for (const e of idx[focus].in || []) inn.set(e.name, Number(e.w) || 0); + return { out, inn }; + }; + + const computeStateFromInputs = () => { + const info = store.click_info.get() || {}; + const t = String(info.type || '').replace('-', '_'); + const v = info.value || {}; + const idx = store.edge_index.get() || {}; + const seq = linkInteractionSeq; + const sig = JSON.stringify({ + t, + v, + rows: store.selected_rows.get() || [], + cols: store.selected_cols.get() || [], + }); + if (sig === lastSig) { + log(store, 'compute skip (same signature)', t); + return; + } + lastSig = sig; + log(store, 'compute start', t, 'rows', (store.selected_rows.get()||[]).length, 'cols', (store.selected_cols.get()||[]).length); + + const setState = (focus, highlights, edges) => + setDerivedState(store, { focus, highlights, edges }); + + const stationFrom = (raw) => { + const txt = String(raw || '').trim(); + if (idx[txt]) return txt; + if (txt.includes('|')) { + const rhs = txt.split('|', 2)[1].trim(); + if (idx[rhs]) return rhs; + } + return txt; + }; + + if (t === 'row_label' || t === 'col_label') { + const name = stationFrom(v.name); + const actionKey = `${t}:${name}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState('', [], []); + lastActionKey = null; + lastActionSeq = seq; + log(store, 'label toggle off', t, name); + return; + } + const bucket = idx[name] || { out: [], in: [] }; + const edges = [ + ...(bucket.out || []).map((e) => ({ + source_name: name, + target_name: e.name, + direction: 'out', + opacity: e.opacity, + weight: e.w, + geom_share: e.geom_share, + trips: e.trips, + source: e.source, + target: e.target, + })), + ...(bucket.in || []).map((e) => ({ + source_name: e.name, + target_name: name, + direction: 'in', + opacity: e.opacity, + weight: e.w, + geom_share: e.geom_share, + trips: e.trips, + source: e.source, + target: e.target, + })), + ]; + setState(name, name ? [name] : [], edges); + lastActionKey = actionKey; + lastActionSeq = seq; + log(store, 'label', t, name, 'edges', edges.length); + return; + } + + if (t === 'mat_value') { + const row = stationFrom((v.row || {}).name); + const col = stationFrom((v.col || {}).name); + const actionKey = `mat:${col}->${row}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState('', [], []); + lastActionKey = null; + lastActionSeq = seq; + log(store, 'mat toggle off', col, row); + return; + } + const p = Number(v.value || 0); + const src = idx[col]?.coord; + const dst = idx[row]?.coord; + const outEdge = (idx[col]?.out || []).find((e) => e.name === row); + const g = outEdge != null ? Number(outEdge.geom_share) : NaN; + const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); + const edge = src && dst + ? [{ + source_name: col, + target_name: row, + direction: 'direct', + opacity: Math.max(0.2, Math.min(0.98, p * 3)), + weight: p, + geom_share: geom, + trips: outEdge?.trips, + source: src, + target: dst, + }] + : []; + setState('', [col, row].filter(Boolean), edge); + lastActionKey = actionKey; + lastActionSeq = seq; + log(store, 'mat', col, '->', row, p); + return; + } + + if (t === 'row_dendro' || t === 'col_dendro') { + const fromClick = (v.selected_names || []).map(stationFrom).filter((n) => idx[n]); + const rows = (store.selected_rows.get() || []).map(stationFrom).filter((n) => idx[n]); + const cols = (store.selected_cols.get() || []).map(stationFrom).filter((n) => idx[n]); + + if (v.is_unselecting || (Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0)) { + setState('', [], []); + lastActionKey = null; + lastActionSeq = seq; + log(store, 'dendro clear', t); + return; + } + + // Prefer axis traitlets (they represent full live dendrogram selection); + // click_info.selected_names can be a smaller interim payload. + const names = t === 'col_dendro' + ? (cols.length ? cols : (fromClick.length ? fromClick : rows)) + : (rows.length ? rows : (fromClick.length ? fromClick : cols)); + + // No actionKey "toggle off" vs linkInteractionSeq here: dendrogram updates can + // re-send the same selection across frames; toggling off would flicker. + const actionKey = `${t}:${names.slice().sort().join('|')}`; + setState('', names, []); + lastActionKey = actionKey; + lastActionSeq = seq; + log(store, 'dendro', t, 'names', names.length, 'rows', rows.length, 'cols', cols.length); + return; + } + + if (t === 'cat_value') { + const axis = v.axis; + const attrIndex = v.attr_index; + const catVal = v.value; + const rawNames = Array.isArray(v.node_names) ? v.node_names : []; + const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n]))]; + const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; + if (actionKey === lastActionKey && seq !== lastActionSeq) { + setState('', [], []); + lastActionKey = null; + lastActionSeq = seq; + log(store, 'cat toggle off', axis, catVal); + return; + } + setState('', names, []); + lastActionKey = actionKey; + lastActionSeq = seq; + log(store, 'cat', axis, 'value', catVal, 'stations', names.length); + return; + } + }; + + const buildLayers = () => { + const stations = store.stations.get() || []; + const focus = store.focus.get(); + const highlightArr = store.highlights.get() || []; + const highlights = new Set(highlightArr); + const edges = store.edges.get() || []; + const stationNameSet = new Set(stations.map((d) => d.name)); + const overlap = highlightArr.filter((n) => stationNameSet.has(n)); + log(store, 'buildLayers', { + focus, + highlightCount: highlightArr.length, + overlap: overlap.length, + sample: overlap.slice(0, 5), + stations: stations.length, + edges: edges.length, + version: renderVersion, + }); + const hasSel = Boolean(focus) || highlights.size > 0; + const { out, inn } = getLinkedWeights(); + const highlightKey = Array.from(highlights).sort().join('|'); + const outKey = Array.from(out.entries()) + .map(([k, v]) => `${k}:${v}`) + .sort() + .join('|'); + const inKey = Array.from(inn.entries()) + .map(([k, v]) => `${k}:${v}`) + .sort() + .join('|'); + const styleKey = `${focus}__${highlightKey}__${outKey}__${inKey}__${hasSel}`; + + let peakLinkWeight = 0; + for (const v of out.values()) peakLinkWeight = Math.max(peakLinkWeight, v); + for (const v of inn.values()) peakLinkWeight = Math.max(peakLinkWeight, v); + + let hubSumOut = 0; + let hubSumIn = 0; + for (const v of out.values()) hubSumOut += Number(v) || 0; + for (const v of inn.values()) hubSumIn += Number(v) || 0; + + const linkedRadius = (n) => { + const wo = out.has(n) ? Math.min(1, Math.max(0, out.get(n) || 0)) : 0; + const wi = inn.has(n) ? Math.min(1, Math.max(0, inn.get(n) || 0)) : 0; + const w = Math.max(wo, wi); + return 100 + 125 * Math.sqrt(w); + }; + + const focusHubRadius = () => + 178 + 48 * Math.sqrt(Math.min(1, peakLinkWeight)); + + const palRgb = resolvePaletteRgb(store); + + // Force a new data container each render so style-only updates always propagate + const pointData = stations.map((d) => d); + + const points = new ScatterplotLayer({ + id: 'bike-stations', + data: pointData, + pickable: true, + radiusUnits: 'meters', + radiusMinPixels: 3, + radiusMaxPixels: 56, + getPosition: (d) => [Number(d.lng), Number(d.lat)], + getRadius: (d) => { + const n = d.name; + if (focus && n === focus) return focusHubRadius(); + if (focus && (out.has(n) || inn.has(n))) return linkedRadius(n); + if (highlights.has(n)) return 90; + return hasSel ? 70 : 90; + }, + getFillColor: (d) => { + const n = d.name; + // Focus / traffic: hub + neighbors use red↔blue blend from out vs in weight (lines still encode direction/width). + if (focus) { + if (n === focus) { + return flowBlendWithAlpha(hubSumOut, hubSumIn, 248); + } + if (out.has(n) || inn.has(n)) { + const wo = out.has(n) ? Math.max(0, out.get(n) || 0) : 0; + const wi = inn.has(n) ? Math.max(0, inn.get(n) || 0) : 0; + const w = Math.max(wo, wi); + const a = Math.round(148 + 102 * Math.sqrt(Math.min(1, w))); + return flowBlendWithAlpha(wo, wi, a); + } + return TRAFFIC_UNCONNECTED_RGBA; + } + // Dendrogram / matrix highlights (no focus): keep dendrogram cluster colors + if (highlights.size > 0) { + const c = clusterFillColor(d.cluster_id, palRgb); + if (highlights.has(n)) return [c[0], c[1], c[2], 242]; + return [c[0], c[1], c[2], 36]; + } + return clusterFillColor(d.cluster_id, palRgb); + }, + updateTriggers: { + getRadius: [styleKey, renderVersion], + getFillColor: [styleKey, renderVersion], + }, + onClick: (info) => { + if (!info.object) return; + const n = info.object.name; + if (store.focus.get() === n) { + setDerivedState(store, { focus: '', highlights: [], edges: [] }); + lastActionKey = null; + scheduleRender(); + log(store, 'map toggle off', n); + return; + } + const idx = store.edge_index.get() || {}; + const bucket = idx[n] || { out: [], in: [] }; + const e = [ + ...(bucket.out || []).map((x) => ({ + source_name: n, + target_name: x.name, + direction: 'out', + opacity: x.opacity, + weight: x.w, + geom_share: x.geom_share, + trips: x.trips, + source: x.source, + target: x.target, + })), + ...(bucket.in || []).map((x) => ({ + source_name: x.name, + target_name: n, + direction: 'in', + opacity: x.opacity, + weight: x.w, + geom_share: x.geom_share, + trips: x.trips, + source: x.source, + target: x.target, + })), + ]; + setDerivedState(store, { focus: n, highlights: [n], edges: e }); + lastActionKey = null; + scheduleRender(); + log(store, 'map click', n, 'edges', e.length); + }, + }); + + // geom_share in [0,1]; scale like matrix emphasis (stronger than before, pixel units). + const lineWidthFor = (d) => { + if (d.direction === 'direct') { + const g = Number(d.geom_share); + const x = Number.isFinite(g) ? Math.min(1, Math.max(0, g)) : 0; + return 4 + 14 * x; + } + const g = Number(d.geom_share); + if (Number.isFinite(g) && g > 0) { + const x = Math.min(1, g); + return 4 + 22 * x ** 0.92; + } + return 2.5; + }; + + const lines = new LineLayer({ + id: 'bike-flow-lines', + data: edges, + widthUnits: 'pixels', + getSourcePosition: (d) => d.source, + getTargetPosition: (d) => d.target, + getWidth: lineWidthFor, + updateTriggers: { + getWidth: [styleKey, renderVersion], + }, + getColor: (d) => { + const a = Math.round(Math.max(0, Math.min(1, Number(d.opacity) || 0)) * 255); + if (d.direction === 'in') return [70, 150, 255, a]; + if (d.direction === 'out') return [255, 70, 70, a]; + return [255, 240, 120, a]; + }, + }); + + return [basemapLayer(), lines, points]; + }; + + let pendingProps = null; + + const prepareDeckProps = () => { + const stations = store.stations.get() || []; + const w = Number(store.width.get() || 560); + const h = Number(store.height.get() || 800); + root.style.width = `${w}px`; + root.style.height = `${h}px`; + + + const props = { + parent: root, + width: w, + height: h, + controller: true, + layers: buildLayers(), + getTooltip: ({ object, layer }) => { + if (!object || layer.id !== 'bike-stations') return null; + const sid = object.station_id != null ? String(object.station_id) : ''; + const nm = object.name != null ? String(object.name) : ''; + const html = sid + ? `
id ${sid}
name ${nm}
` + : `
${nm}
`; + return { + html, + style: { + backgroundColor: 'rgba(255,255,255,0.94)', + color: '#1a1d24', + padding: '6px 10px', + borderRadius: '4px', + boxShadow: '0 1px 4px rgba(0,0,0,0.18)', + }, + }; + }, + }; + + if (!deck) { + deck = new Deck({ ...props, initialViewState: fitViewState(stations) }); + log(store, 'deck init', 'stations', stations.length); + pendingProps = null; + return; + } + + pendingProps = props; + }; + + const applyDeckProps = () => { + if (deck && pendingProps) { + deck.setProps(pendingProps); + if (typeof deck.redraw === 'function') deck.redraw(true); + log(store, 'deck setProps', { + layers: pendingProps.layers.length, + highlights: (store.highlights.get() || []).length, + edges: (store.edges.get() || []).length, + version: renderVersion, + }); + pendingProps = null; + } + }; + + store.deck_check.subscribe( + (check) => { + const ready = Object.values(check).every((v) => v === true); + if (store.deck_ready.get() !== ready) store.deck_ready.set(ready); + }, + { immediate: true } + ); + + store.deck_ready.subscribe( + (ready) => { + if (!ready) return; + log(store, 'deck_ready -> apply'); + applyDeckProps(); + }, + { immediate: false } + ); + + const scheduleRender = () => { + if (raf) return; + raf = requestAnimationFrame(() => { + raf = 0; + renderVersion += 1; + log(store, 'flush start', { version: renderVersion }); + store.deck_check.set({ inputs: false, computed: false, layers: false }); + + // 1) inputs considered synced for this frame + store.deck_check.set({ ...store.deck_check.get(), inputs: true }); + + // 2) derive interaction state + computeStateFromInputs(); + store.deck_check.set({ ...store.deck_check.get(), computed: true }); + + // 3) prepare deck props (or init deck) + prepareDeckProps(); + store.deck_check.set({ ...store.deck_check.get(), layers: true }); + + log(store, 'flush end', store.deck_check.get()); + }); + }; + + // subscriptions: any change schedules one render pass + [ + store.stations, + store.edge_index, + store.click_info, + store.selected_rows, + store.selected_cols, + store.width, + store.height, + store.palette_rgb, + ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); + + const syncFromModel = () => { + const ci = JSON.stringify(model.get('click_info') || {}); + const rows = JSON.stringify(model.get('selected_rows') || []); + const cols = JSON.stringify(model.get('selected_cols') || []); + if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols) { + linkSnap = { ci, rows, cols }; + linkInteractionSeq += 1; + } + log(store, 'syncFromModel start'); + store.stations.set(model.get('stations') || []); + store.palette_rgb.set(model.get('palette_rgb') || []); + store.edge_index.set(model.get('edge_index') || {}); + store.click_info.set(model.get('click_info') || {}); + store.selected_rows.set(model.get('selected_rows') || []); + store.selected_cols.set(model.get('selected_cols') || []); + store.width.set(model.get('width') || 560); + store.height.set(model.get('height') || 800); + store.debug.set(Boolean(model.get('debug'))); + log(store, 'syncFromModel done', { + linkSeq: linkInteractionSeq, + rows: (store.selected_rows.get() || []).length, + cols: (store.selected_cols.get() || []).length, + clickType: (store.click_info.get() || {}).type || null, + }); + scheduleRender(); + }; + + [ + 'stations', + 'edge_index', + 'click_info', + 'selected_rows', + 'selected_cols', + 'width', + 'height', + 'debug', + 'palette_rgb', + ].forEach((name) => model.on(`change:${name}`, syncFromModel)); + + syncFromModel(); + + return () => { + if (raf) cancelAnimationFrame(raf); + if (deck) deck.finalize(); + }; +} + +export default { render }; From 84a6a10ba31a8498ae9f440254c09f0ee5cf0348 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Thu, 9 Apr 2026 15:34:55 -0400 Subject: [PATCH 2/7] celldega clustergram improvements --- docs/assets/js/celldega.js | 186 ++++++++++---------- js/celldega.js | 10 ++ js/deck-gl/matrix/label_layers.js | 20 ++- js/deck-gl/matrix/mat_layer.js | 12 +- js/matrix/matrix_axis_slice.js | 178 ++++++++++++++++++++ js/viz/matrix_viz.js | 58 +++++++ notebooks/bike_flow_map.widget.js | 254 +++++++++++++++++++++------- notebooks/bike_flow_map_widget.mjs | 261 ++++++++++++++++++++++------- src/celldega/clust/matrix.py | 7 +- src/celldega/viz/widget.py | 109 ++++++++++++ 10 files changed, 869 insertions(+), 226 deletions(-) create mode 100644 js/matrix/matrix_axis_slice.js diff --git a/docs/assets/js/celldega.js b/docs/assets/js/celldega.js index fcef319fd..c341d776e 100644 --- a/docs/assets/js/celldega.js +++ b/docs/assets/js/celldega.js @@ -1,32 +1,32 @@ -var l9=Object.create;var hg=Object.defineProperty;var c9=Object.getOwnPropertyDescriptor;var u9=Object.getOwnPropertyNames;var B9=Object.getPrototypeOf,f9=Object.prototype.hasOwnProperty;var h9=(t,A,j)=>A in t?hg(t,A,{enumerable:!0,configurable:!0,writable:!0,value:j}):t[A]=j;var C6=(t,A)=>()=>(A||t((A={exports:{}}).exports,A),A.exports),fr=(t,A)=>{for(var j in A)hg(t,j,{get:A[j],enumerable:!0})},d9=(t,A,j,e)=>{if(A&&typeof A=="object"||typeof A=="function")for(let r of u9(A))!f9.call(t,r)&&r!==j&&hg(t,r,{get:()=>A[r],enumerable:!(e=c9(A,r))||e.enumerable});return t};var Qs=(t,A,j)=>(j=t!=null?l9(B9(t)):{},d9(A||!t||!t.__esModule?hg(j,"default",{value:t,enumerable:!0}):j,t));var I=(t,A,j)=>(h9(t,typeof A!="symbol"?A+"":A,j),j);var m8=(()=>{for(var t=new Uint8Array(128),A=0;A<64;A++)t[A<26?A+65:A<52?A+71:A<62?A-4:A*4-205]=A;return j=>{for(var e=j.length,r=new Uint8Array((e-(j[e-1]=="=")-(j[e-2]=="="))*3/4|0),n=0,i=0;n>4,r[i++]=l<<4|c>>2,r[i++]=c<<6|B}return r}})();var GL=C6((U2A,Q$)=>{(function(t,A,j,e){"use strict";var r=["","webkit","Moz","MS","ms","o"],n=A.createElement("div"),i="function",o=Math.round,l=Math.abs,c=Date.now;function B(R,N,H){return setTimeout(b(R,H),N)}function h(R,N,H){return Array.isArray(R)?(d(R,H[N],H),!0):!1}function d(R,N,H){var aA;if(R)if(R.forEach)R.forEach(N,H);else if(R.length!==e)for(aA=0;aA\s*\(/gm,"{anonymous}()@"):"Unknown Stack Trace",Ft=t.console&&(t.console.warn||t.console.log);return Ft&&Ft.call(t.console,aA,GA),R.apply(this,arguments)}}var g;typeof Object.assign!="function"?g=function(N){if(N===e||N===null)throw new TypeError("Cannot convert undefined or null to object");for(var H=Object(N),aA=1;aA-1}function D(R){return R.trim().split(/\s+/g)}function L(R,N,H){if(R.indexOf&&!H)return R.indexOf(N);for(var aA=0;aArt[N]}):aA=aA.sort()),aA}function W(R,N){for(var H,aA,gA=N[0].toUpperCase()+N.slice(1),GA=0;GA1&&!H.firstMultiple?H.firstMultiple=we(N):gA===1&&(H.firstMultiple=!1);var GA=H.firstInput,Ft=H.firstMultiple,Xt=Ft?Ft.center:GA.center,ut=N.center=Ee(aA);N.timeStamp=c(),N.deltaTime=N.timeStamp-GA.timeStamp,N.angle=J(Xt,ut),N.distance=bt(Xt,ut),Gt(H,N),N.offsetDirection=Ij(N.deltaX,N.deltaY);var rt=MA(N.deltaTime,N.deltaX,N.deltaY);N.overallVelocityX=rt.x,N.overallVelocityY=rt.y,N.overallVelocity=l(rt.x)>l(rt.y)?rt.x:rt.y,N.scale=Ft?O(Ft.pointers,aA):1,N.rotation=Ft?P(Ft.pointers,aA):0,N.maxPointers=H.prevInput?N.pointers.length>H.prevInput.maxPointers?N.pointers.length:H.prevInput.maxPointers:N.pointers.length,EA(H,N);var Yt=R.element;S(N.srcEvent.target,Yt)&&(Yt=N.srcEvent.target),N.target=Yt}function Gt(R,N){var H=N.center,aA=R.offsetDelta||{},gA=R.prevDelta||{},GA=R.prevInput||{};(N.eventType===wA||GA.eventType===qA)&&(gA=R.prevDelta={x:GA.deltaX||0,y:GA.deltaY||0},aA=R.offsetDelta={x:H.x,y:H.y}),N.deltaX=gA.x+(H.x-aA.x),N.deltaY=gA.y+(H.y-aA.y)}function EA(R,N){var H=R.lastInterval||N,aA=N.timeStamp-H.timeStamp,gA,GA,Ft,Xt;if(N.eventType!=Ht&&(aA>ft||H.velocity===e)){var ut=N.deltaX-H.deltaX,rt=N.deltaY-H.deltaY,Yt=MA(aA,ut,rt);GA=Yt.x,Ft=Yt.y,gA=l(Yt.x)>l(Yt.y)?Yt.x:Yt.y,Xt=Ij(ut,rt),R.lastInterval=N}else gA=H.velocity,GA=H.velocityX,Ft=H.velocityY,Xt=H.direction;N.velocity=gA,N.velocityX=GA,N.velocityY=Ft,N.direction=Xt}function we(R){for(var N=[],H=0;H=l(N)?R<0?l6:Tt:N<0?me:FA}function bt(R,N,H){H||(H=Uj);var aA=N[H[0]]-R[H[0]],gA=N[H[1]]-R[H[1]];return Math.sqrt(aA*aA+gA*gA)}function J(R,N,H){H||(H=Uj);var aA=N[H[0]]-R[H[0]],gA=N[H[1]]-R[H[1]];return Math.atan2(gA,aA)*180/Math.PI}function P(R,N){return J(N[1],N[0],KA)+J(R[1],R[0],KA)}function O(R,N){return bt(N[0],N[1],KA)/bt(R[0],R[1],KA)}var K={mousedown:wA,mousemove:_t,mouseup:qA},V="mousedown",U="mousemove mouseup";function lA(){this.evEl=V,this.evWin=U,this.pressed=!1,xA.apply(this,arguments)}y(lA,xA,{handler:function(N){var H=K[N.type];H&wA&&N.button===0&&(this.pressed=!0),H&_t&&N.which!==1&&(H=qA),this.pressed&&(H&qA&&(this.pressed=!1),this.callback(this.manager,H,{pointers:[N],changedPointers:[N],pointerType:Ct,srcEvent:N}))}});var rA={pointerdown:wA,pointermove:_t,pointerup:qA,pointercancel:Ht,pointerout:Ht},hA={2:QA,3:mt,4:Ct,5:SA},uA="pointerdown",nA="pointermove pointerup pointercancel";t.MSPointerEvent&&!t.PointerEvent&&(uA="MSPointerDown",nA="MSPointerMove MSPointerUp MSPointerCancel");function sA(){this.evEl=uA,this.evWin=nA,xA.apply(this,arguments),this.store=this.manager.session.pointerEvents=[]}y(sA,xA,{handler:function(N){var H=this.store,aA=!1,gA=N.type.toLowerCase().replace("ms",""),GA=rA[gA],Ft=hA[N.pointerType]||N.pointerType,Xt=Ft==QA,ut=L(H,N.pointerId,"pointerId");GA&wA&&(N.button===0||Xt)?ut<0&&(H.push(N),ut=H.length-1):GA&(qA|Ht)&&(aA=!0),!(ut<0)&&(H[ut]=N,this.callback(this.manager,GA,{pointers:H,changedPointers:[N],pointerType:Ft,srcEvent:N}),aA&&H.splice(ut,1))}});var kA={touchstart:wA,touchmove:_t,touchend:qA,touchcancel:Ht},BA="touchstart",tt="touchstart touchmove touchend touchcancel";function UA(){this.evTarget=BA,this.evWin=tt,this.started=!1,xA.apply(this,arguments)}y(UA,xA,{handler:function(N){var H=kA[N.type];if(H===wA&&(this.started=!0),!!this.started){var aA=wt.call(this,N,H);H&(qA|Ht)&&aA[0].length-aA[1].length===0&&(this.started=!1),this.callback(this.manager,H,{pointers:aA[0],changedPointers:aA[1],pointerType:QA,srcEvent:N})}}});function wt(R,N){var H=z(R.touches),aA=z(R.changedTouches);return N&(qA|Ht)&&(H=T(H.concat(aA),"identifier",!0)),[H,aA]}var at={touchstart:wA,touchmove:_t,touchend:qA,touchcancel:Ht},kj="touchstart touchmove touchend touchcancel";function Lj(){this.evTarget=kj,this.targetIds={},xA.apply(this,arguments)}y(Lj,xA,{handler:function(N){var H=at[N.type],aA=Vj.call(this,N,H);aA&&this.callback(this.manager,H,{pointers:aA[0],changedPointers:aA[1],pointerType:QA,srcEvent:N})}});function Vj(R,N){var H=z(R.touches),aA=this.targetIds;if(N&(wA|_t)&&H.length===1)return aA[H[0].identifier]=!0,[H,H];var gA,GA,Ft=z(R.changedTouches),Xt=[],ut=this.target;if(GA=H.filter(function(rt){return S(rt.target,ut)}),N===wA)for(gA=0;gA-1&&aA.splice(GA,1)};setTimeout(gA,dj)}}function _j(R){for(var N=R.srcEvent.clientX,H=R.srcEvent.clientY,aA=0;aA-1&&this.requireFail.splice(N,1),this},hasRequireFailures:function(){return this.requireFail.length>0},canRecognizeWith:function(R){return!!this.simultaneous[R.id]},emit:function(R){var N=this,H=this.state;function aA(gA){N.manager.emit(gA,R)}H=Pe&&aA(N.options.event+t7(H))},tryEmit:function(R){if(this.canEmit())return this.emit(R);this.state=gn},canEmit:function(){for(var R=0;RN.threshold&&gA&N.direction},attrTest:function(R){return B6.prototype.attrTest.call(this,R)&&(this.state&Wt||!(this.state&Wt)&&this.directionTest(R))},emit:function(R){this.pX=R.deltaX,this.pY=R.deltaY;var N=j7(R.direction);N&&(R.additionalEvent=this.options.event+N),this._super.emit.call(this,R)}});function yl(){B6.apply(this,arguments)}y(yl,B6,{defaults:{event:"pinch",threshold:0,pointers:2},getTouchAction:function(){return[c6]},attrTest:function(R){return this._super.attrTest.call(this,R)&&(Math.abs(R.scale-1)>this.options.threshold||this.state&Wt)},emit:function(R){if(R.scale!==1){var N=R.scale<1?"in":"out";R.additionalEvent=this.options.event+N}this._super.emit.call(this,R)}});function lu(){mn.apply(this,arguments),this._timer=null,this._input=null}y(lu,mn,{defaults:{event:"press",pointers:1,time:251,threshold:9},getTouchAction:function(){return[Gr]},process:function(R){var N=this.options,H=R.pointers.length===N.pointers,aA=R.distanceN.time;if(this._input=R,!aA||!H||R.eventType&(qA|Ht)&&!gA)this.reset();else if(R.eventType&wA)this.reset(),this._timer=B(function(){this.state=xe,this.tryEmit()},N.time,this);else if(R.eventType&qA)return xe;return gn},reset:function(){clearTimeout(this._timer)},emit:function(R){this.state===xe&&(R&&R.eventType&qA?this.manager.emit(this.options.event+"up",R):(this._input.timeStamp=c(),this.manager.emit(this.options.event,this._input)))}});function Pt(){B6.apply(this,arguments)}y(Pt,B6,{defaults:{event:"rotate",threshold:0,pointers:2},getTouchAction:function(){return[c6]},attrTest:function(R){return this._super.attrTest.call(this,R)&&(Math.abs(R.rotation)>this.options.threshold||this.state&Wt)}});function vl(){B6.apply(this,arguments)}y(vl,B6,{defaults:{event:"swipe",threshold:10,velocity:.3,direction:yj|cj,pointers:1},getTouchAction:function(){return Yr.prototype.getTouchAction.call(this)},attrTest:function(R){var N=this.options.direction,H;return N&(yj|cj)?H=R.overallVelocity:N&yj?H=R.overallVelocityX:N&cj&&(H=R.overallVelocityY),this._super.attrTest.call(this,R)&&N&R.offsetDirection&&R.distance>this.options.threshold&&R.maxPointers==this.options.pointers&&l(H)>this.options.velocity&&R.eventType&qA},emit:function(R){var N=j7(R.offsetDirection);N&&this.manager.emit(this.options.event+N,R),this.manager.emit(this.options.event,R)}});function br(){mn.apply(this,arguments),this.pTime=!1,this.pCenter=!1,this._timer=null,this._input=null,this.count=0}y(br,mn,{defaults:{event:"tap",pointers:1,taps:1,interval:300,time:250,threshold:9,posThreshold:10},getTouchAction:function(){return[Fe]},process:function(R){var N=this.options,H=R.pointers.length===N.pointers,aA=R.distance{"use strict";wF.exports=mx;wF.exports.default=mx;function mx(t,A,j){j=j||2;var e=A&&A.length,r=e?A[0]*j:t.length,n=Y2(t,0,r,j,!0),i=[];if(!n||n.next===n.prev)return i;var o,l,c,B,h,d,k;if(e&&(n=rsA(t,A,n,j)),t.length>80*j){o=c=t[0],l=B=t[1];for(var g=j;gc&&(c=h),d>B&&(B=d);k=Math.max(c-o,B-l),k=k!==0?32767/k:0}return gk(n,i,j,o,l,k,0),i}function Y2(t,A,j,e,r){var n,i;if(r===bF(t,A,j,e)>0)for(n=A;n=A;n-=e)i=W2(n,t[n],t[n+1],i);return i&&Ex(i,i.next)&&(Ek(i),i=i.next),i}function Oc(t,A){if(!t)return t;A||(A=t);var j=t,e;do if(e=!1,!j.steiner&&(Ex(j,j.next)||ne(j.prev,j,j.next)===0)){if(Ek(j),j=A=j.prev,j===j.next)break;e=!0}else j=j.next;while(e||j!==A);return A}function gk(t,A,j,e,r,n,i){if(t){!i&&n&&asA(t,e,r,n);for(var o=t,l,c;t.prev!==t.next;){if(l=t.prev,c=t.next,n?tsA(t,e,r,n):AsA(t)){A.push(l.i/j|0),A.push(t.i/j|0),A.push(c.i/j|0),Ek(t),t=c.next,o=c.next;continue}if(t=c,t===o){i?i===1?(t=jsA(Oc(t),A,j),gk(t,A,j,e,r,n,2)):i===2&&esA(t,A,j,e,r,n):gk(Oc(t),A,j,e,r,n,1);break}}}}function AsA(t){var A=t.prev,j=t,e=t.next;if(ne(A,j,e)>=0)return!1;for(var r=A.x,n=j.x,i=e.x,o=A.y,l=j.y,c=e.y,B=rn?r>i?r:i:n>i?n:i,k=o>l?o>c?o:c:l>c?l:c,g=e.next;g!==A;){if(g.x>=B&&g.x<=d&&g.y>=h&&g.y<=k&&UB(r,o,n,l,i,c,g.x,g.y)&&ne(g.prev,g,g.next)>=0)return!1;g=g.next}return!0}function tsA(t,A,j,e){var r=t.prev,n=t,i=t.next;if(ne(r,n,i)>=0)return!1;for(var o=r.x,l=n.x,c=i.x,B=r.y,h=n.y,d=i.y,k=ol?o>c?o:c:l>c?l:c,m=B>h?B>d?B:d:h>d?h:d,y=qF(k,g,A,j,e),b=qF(E,m,A,j,e),v=t.prevZ,_=t.nextZ;v&&v.z>=y&&_&&_.z<=b;){if(v.x>=k&&v.x<=E&&v.y>=g&&v.y<=m&&v!==r&&v!==i&&UB(o,B,l,h,c,d,v.x,v.y)&&ne(v.prev,v,v.next)>=0||(v=v.prevZ,_.x>=k&&_.x<=E&&_.y>=g&&_.y<=m&&_!==r&&_!==i&&UB(o,B,l,h,c,d,_.x,_.y)&&ne(_.prev,_,_.next)>=0))return!1;_=_.nextZ}for(;v&&v.z>=y;){if(v.x>=k&&v.x<=E&&v.y>=g&&v.y<=m&&v!==r&&v!==i&&UB(o,B,l,h,c,d,v.x,v.y)&&ne(v.prev,v,v.next)>=0)return!1;v=v.prevZ}for(;_&&_.z<=b;){if(_.x>=k&&_.x<=E&&_.y>=g&&_.y<=m&&_!==r&&_!==i&&UB(o,B,l,h,c,d,_.x,_.y)&&ne(_.prev,_,_.next)>=0)return!1;_=_.nextZ}return!0}function jsA(t,A,j){var e=t;do{var r=e.prev,n=e.next.next;!Ex(r,n)&&J2(r,e,e.next,n)&&mk(r,n)&&mk(n,r)&&(A.push(r.i/j|0),A.push(e.i/j|0),A.push(n.i/j|0),Ek(e),Ek(e.next),e=t=n),e=e.next}while(e!==t);return Oc(e)}function esA(t,A,j,e,r,n){var i=t;do{for(var o=i.next.next;o!==i.prev;){if(i.i!==o.i&&usA(i,o)){var l=Z2(i,o);i=Oc(i,i.next),l=Oc(l,l.next),gk(i,A,j,e,r,n,0),gk(l,A,j,e,r,n,0);return}o=o.next}i=i.next}while(i!==t)}function rsA(t,A,j,e){var r=[],n,i,o,l,c;for(n=0,i=A.length;n=j.next.y&&j.next.y!==j.y){var o=j.x+(r-j.y)*(j.next.x-j.x)/(j.next.y-j.y);if(o<=e&&o>n&&(n=o,i=j.x=j.x&&j.x>=c&&e!==j.x&&UB(ri.x||j.x===i.x&&ssA(i,j)))&&(i=j,h=d)),j=j.next;while(j!==l);return i}function ssA(t,A){return ne(t.prev,t,A.prev)<0&&ne(A.next,t,t.next)<0}function asA(t,A,j,e){var r=t;do r.z===0&&(r.z=qF(r.x,r.y,A,j,e)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==t);r.prevZ.nextZ=null,r.prevZ=null,lsA(r)}function lsA(t){var A,j,e,r,n,i,o,l,c=1;do{for(j=t,t=null,n=null,i=0;j;){for(i++,e=j,o=0,A=0;A0||l>0&&e;)o!==0&&(l===0||!e||j.z<=e.z)?(r=j,j=j.nextZ,o--):(r=e,e=e.nextZ,l--),n?n.nextZ=r:t=r,r.prevZ=n,n=r;j=e}n.nextZ=null,c*=2}while(i>1);return t}function qF(t,A,j,e,r){return t=(t-j)*r|0,A=(A-e)*r|0,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,A=(A|A<<8)&16711935,A=(A|A<<4)&252645135,A=(A|A<<2)&858993459,A=(A|A<<1)&1431655765,t|A<<1}function csA(t){var A=t,j=t;do(A.x=(t-i)*(n-o)&&(t-i)*(e-o)>=(j-i)*(A-o)&&(j-i)*(n-o)>=(r-i)*(e-o)}function usA(t,A){return t.next.i!==A.i&&t.prev.i!==A.i&&!BsA(t,A)&&(mk(t,A)&&mk(A,t)&&fsA(t,A)&&(ne(t.prev,t,A.prev)||ne(t,A.prev,A))||Ex(t,A)&&ne(t.prev,t,t.next)>0&&ne(A.prev,A,A.next)>0)}function ne(t,A,j){return(A.y-t.y)*(j.x-A.x)-(A.x-t.x)*(j.y-A.y)}function Ex(t,A){return t.x===A.x&&t.y===A.y}function J2(t,A,j,e){var r=gx(ne(t,A,j)),n=gx(ne(t,A,e)),i=gx(ne(j,e,t)),o=gx(ne(j,e,A));return!!(r!==n&&i!==o||r===0&&kx(t,j,A)||n===0&&kx(t,e,A)||i===0&&kx(j,t,e)||o===0&&kx(j,A,e))}function kx(t,A,j){return A.x<=Math.max(t.x,j.x)&&A.x>=Math.min(t.x,j.x)&&A.y<=Math.max(t.y,j.y)&&A.y>=Math.min(t.y,j.y)}function gx(t){return t>0?1:t<0?-1:0}function BsA(t,A){var j=t;do{if(j.i!==t.i&&j.next.i!==t.i&&j.i!==A.i&&j.next.i!==A.i&&J2(j,j.next,t,A))return!0;j=j.next}while(j!==t);return!1}function mk(t,A){return ne(t.prev,t,t.next)<0?ne(t,A,t.next)>=0&&ne(t,t.prev,A)>=0:ne(t,A,t.prev)<0||ne(t,t.next,A)<0}function fsA(t,A){var j=t,e=!1,r=(t.x+A.x)/2,n=(t.y+A.y)/2;do j.y>n!=j.next.y>n&&j.next.y!==j.y&&r<(j.next.x-j.x)*(n-j.y)/(j.next.y-j.y)+j.x&&(e=!e),j=j.next;while(j!==t);return e}function Z2(t,A){var j=new GF(t.i,t.x,t.y),e=new GF(A.i,A.x,A.y),r=t.next,n=A.prev;return t.next=A,A.prev=t,j.next=r,r.prev=j,e.next=j,j.prev=e,n.next=e,e.prev=n,e}function W2(t,A,j,e){var r=new GF(t,A,j);return e?(r.next=e.next,r.prev=e,e.next.prev=r,e.next=r):(r.prev=r,r.next=r),r}function Ek(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function GF(t,A,j){this.i=t,this.x=A,this.y=j,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}mx.deviation=function(t,A,j,e){var r=A&&A.length,n=r?A[0]*j:t.length,i=Math.abs(bF(t,0,n,j));if(r)for(var o=0,l=A.length;o0&&(e+=t[r-1].length,j.holes.push(e))}return j}});var bD=C6((iy,GD)=>{(function(t,A){A(typeof iy=="object"&&typeof GD<"u"?iy:t.jsts={})})(iy,function(t){"use strict";function A(){}function j(s){this.message=s||""}function e(s){this.message=s||""}function r(s){this.message=s||""}function n(){}function i(s){return s===null?dj:s.color}function o(s){return s===null?null:s.parent}function l(s,a){s!==null&&(s.color=a)}function c(s){return s===null?null:s.left}function B(s){return s===null?null:s.right}function h(){this.root_=null,this.size_=0}function d(){}function k(){this.array_=[],arguments[0]instanceof rA&&this.addAll(arguments[0])}function g(){}function E(s){this.message=s||""}function m(){this.array_=[]}"fill"in Array.prototype||Object.defineProperty(Array.prototype,"fill",{configurable:!0,value:function(s){if(this===void 0||this===null)throw new TypeError(this+" is not an object");var a=Object(this),u=Math.max(Math.min(a.length,9007199254740991),0)||0,f=1 in arguments&&parseInt(Number(arguments[1]),10)||0;f=f<0?Math.max(u+f,0):Math.min(f,u);var p=2 in arguments&&arguments[2]!==void 0?parseInt(Number(arguments[2]),10)||0:u;for(p=p<0?Math.max(u+arguments[2],0):Math.min(p,u);fa.x?1:this.ya.y?1:0},F.prototype.clone=function(){},F.prototype.copy=function(){return new F(this)},F.prototype.toString=function(){return"("+this.x+", "+this.y+", "+this.z+")"},F.prototype.distance3D=function(s){var a=this.x-s.x,u=this.y-s.y,f=this.z-s.z;return Math.sqrt(a*a+u*u+f*f)},F.prototype.distance=function(s){var a=this.x-s.x,u=this.y-s.y;return Math.sqrt(a*a+u*u)},F.prototype.hashCode=function(){var s=17;return s=37*s+F.hashCode(this.x),s=37*s+F.hashCode(this.y)},F.prototype.setCoordinate=function(s){this.x=s.x,this.y=s.y,this.z=s.z},F.prototype.interfaces_=function(){return[w,x,A]},F.prototype.getClass=function(){return F},F.hashCode=function(){if(arguments.length===1){var s=arguments[0],a=v.doubleToLongBits(s);return Math.trunc((a^a)>>>32)}},D.DimensionalComparator.get=function(){return L},D.serialVersionUID.get=function(){return 6683108902428367e3},D.NULL_ORDINATE.get=function(){return v.NaN},D.X.get=function(){return 0},D.Y.get=function(){return 1},D.Z.get=function(){return 2},Object.defineProperties(F,D);var L=function(s){if(this._dimensionsToTest=2,arguments.length!==0){if(arguments.length===1){var a=arguments[0];if(a!==2&&a!==3)throw new b("only 2 or 3 dimensions may be specified");this._dimensionsToTest=a}}};L.prototype.compare=function(s,a){var u=s,f=a,p=L.compare(u.x,f.x);if(p!==0)return p;var $=L.compare(u.y,f.y);return $!==0?$:this._dimensionsToTest<=2?0:L.compare(u.z,f.z)},L.prototype.interfaces_=function(){return[S]},L.prototype.getClass=function(){return L},L.compare=function(s,a){return sa?1:v.isNaN(s)?v.isNaN(a)?0:-1:v.isNaN(a)?1:0};var z=function(){};z.prototype.create=function(){},z.prototype.interfaces_=function(){return[]},z.prototype.getClass=function(){return z};var T=function(){},W={INTERIOR:{configurable:!0},BOUNDARY:{configurable:!0},EXTERIOR:{configurable:!0},NONE:{configurable:!0}};T.prototype.interfaces_=function(){return[]},T.prototype.getClass=function(){return T},T.toLocationSymbol=function(s){switch(s){case T.EXTERIOR:return"e";case T.BOUNDARY:return"b";case T.INTERIOR:return"i";case T.NONE:return"-"}throw new b("Unknown location value: "+s)},W.INTERIOR.get=function(){return 0},W.BOUNDARY.get=function(){return 1},W.EXTERIOR.get=function(){return 2},W.NONE.get=function(){return-1},Object.defineProperties(T,W);var G=function(s,a){return s.interfaces_&&s.interfaces_().indexOf(a)>-1},jA=function(){},pA={LOG_10:{configurable:!0}};jA.prototype.interfaces_=function(){return[]},jA.prototype.getClass=function(){return jA},jA.log10=function(s){var a=Math.log(s);return v.isInfinite(a)||v.isNaN(a)?a:a/jA.LOG_10},jA.min=function(s,a,u,f){var p=s;return au?u:s}if(Number.isInteger(arguments[2])&&Number.isInteger(arguments[0])&&Number.isInteger(arguments[1])){var f=arguments[0],p=arguments[1],$=arguments[2];return f$?$:f}},jA.wrap=function(s,a){return s<0?a- -s%a:s%a},jA.max=function(){if(arguments.length===3){var s=arguments[0],a=arguments[1],u=arguments[2],f=s;return a>f&&(f=a),u>f&&(f=u),f}if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3],C=p;return $>C&&(C=$),q>C&&(C=q),M>C&&(C=M),C}},jA.average=function(s,a){return(s+a)/2},pA.LOG_10.get=function(){return Math.log(10)},Object.defineProperties(jA,pA);var dA=function(s){this.str=s};dA.prototype.append=function(s){this.str+=s},dA.prototype.setCharAt=function(s,a){this.str=this.str.substr(0,s)+a+this.str.substr(s+1)},dA.prototype.toString=function(s){return this.str};var $A=function(s){this.value=s};$A.prototype.intValue=function(){return this.value},$A.prototype.compareTo=function(s){return this.values?1:0},$A.isNaN=function(s){return Number.isNaN(s)};var _A=function(){};_A.isWhitespace=function(s){return s<=32&&s>=0||s===127},_A.toUpperCase=function(s){return s.toUpperCase()};var Y=function s(){if(this._hi=0,this._lo=0,arguments.length===0)this.init(0);else if(arguments.length===1){if(typeof arguments[0]=="number"){var a=arguments[0];this.init(a)}else if(arguments[0]instanceof s){var u=arguments[0];this.init(u)}else if(typeof arguments[0]=="string"){var f=arguments[0];s.call(this,s.parse(f))}}else if(arguments.length===2){var p=arguments[0],$=arguments[1];this.init(p,$)}},QA={PI:{configurable:!0},TWO_PI:{configurable:!0},PI_2:{configurable:!0},E:{configurable:!0},NaN:{configurable:!0},EPS:{configurable:!0},SPLIT:{configurable:!0},MAX_PRINT_DIGITS:{configurable:!0},TEN:{configurable:!0},ONE:{configurable:!0},SCI_NOT_EXPONENT_CHAR:{configurable:!0},SCI_NOT_ZERO:{configurable:!0}};Y.prototype.le=function(s){return(this._hi9?(oA=!0,cA="9"):cA="0"+Q,q.append(cA),u=u.subtract(Y.valueOf(Q)).multiply(Y.TEN),oA&&u.selfAdd(Y.TEN);var yA=!0,vA=Y.magnitude(u._hi);if(vA<0&&Math.abs(vA)>=M-C&&(yA=!1),!yA)break}return a[0]=f,q.toString()},Y.prototype.sqr=function(){return this.multiply(this)},Y.prototype.doubleValue=function(){return this._hi+this._lo},Y.prototype.subtract=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.add(s.negate())}if(typeof arguments[0]=="number"){var a=arguments[0];return this.add(-a)}},Y.prototype.equals=function(){if(arguments.length===1){var s=arguments[0];return this._hi===s._hi&&this._lo===s._lo}},Y.prototype.isZero=function(){return this._hi===0&&this._lo===0},Y.prototype.selfSubtract=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.isNaN()?this:this.selfAdd(-s._hi,-s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.isNaN()?this:this.selfAdd(-a,0)}},Y.prototype.getSpecialNumberString=function(){return this.isZero()?"0.0":this.isNaN()?"NaN ":null},Y.prototype.min=function(s){return this.le(s)?this:s},Y.prototype.selfDivide=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfDivide(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.selfDivide(a,0)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1],p=null,$=null,q=null,M=null,C=null,Q=null,oA=null,cA=null;return C=this._hi/u,Q=Y.SPLIT*C,p=Q-C,cA=Y.SPLIT*u,p=Q-p,$=C-p,q=cA-u,oA=C*u,q=cA-q,M=u-q,cA=p*q-oA+p*M+$*q+$*M,Q=(this._hi-oA-cA+this._lo-C*f)/u,cA=C+Q,this._hi=cA,this._lo=C-cA+Q,this}},Y.prototype.dump=function(){return"DD<"+this._hi+", "+this._lo+">"},Y.prototype.divide=function(){if(arguments[0]instanceof Y){var s=arguments[0],a=null,u=null,f=null,p=null,$=null,q=null,M=null,C=null;return u=($=this._hi/s._hi)-(a=(q=Y.SPLIT*$)-(a=q-$)),C=a*(f=(C=Y.SPLIT*s._hi)-(f=C-s._hi))-(M=$*s._hi)+a*(p=s._hi-f)+u*f+u*p,q=(this._hi-M-C+this._lo-$*s._lo)/s._hi,new Y(C=$+q,$-C+q)}if(typeof arguments[0]=="number"){var Q=arguments[0];return v.isNaN(Q)?Y.createNaN():Y.copy(this).selfDivide(Q,0)}},Y.prototype.ge=function(s){return(this._hi>s._hi||this._hi===s._hi)&&this._lo>=s._lo},Y.prototype.pow=function(s){if(s===0)return Y.valueOf(1);var a=new Y(this),u=Y.valueOf(1),f=Math.abs(s);if(f>1)for(;f>0;)f%2==1&&u.selfMultiply(a),(f/=2)>0&&(a=a.sqr());else u=a;return s<0?u.reciprocal():u},Y.prototype.ceil=function(){if(this.isNaN())return Y.NaN;var s=Math.ceil(this._hi),a=0;return s===this._hi&&(a=Math.ceil(this._lo)),new Y(s,a)},Y.prototype.compareTo=function(s){var a=s;return this._hia._hi?1:this._loa._lo?1:0},Y.prototype.rint=function(){return this.isNaN()?this:this.add(.5).floor()},Y.prototype.setValue=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.init(s),this}if(typeof arguments[0]=="number"){var a=arguments[0];return this.init(a),this}},Y.prototype.max=function(s){return this.ge(s)?this:s},Y.prototype.sqrt=function(){if(this.isZero())return Y.valueOf(0);if(this.isNegative())return Y.NaN;var s=1/Math.sqrt(this._hi),a=this._hi*s,u=Y.valueOf(a),f=this.subtract(u.sqr())._hi*(.5*s);return u.add(f)},Y.prototype.selfAdd=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfAdd(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0],u=null,f=null,p=null,$=null,q=null,M=null;return p=this._hi+a,q=p-this._hi,$=p-q,$=a-q+(this._hi-$),M=$+this._lo,u=p+M,f=M+(p-u),this._hi=u+f,this._lo=f+(u-this._hi),this}}else if(arguments.length===2){var C=arguments[0],Q=arguments[1],oA=null,cA=null,yA=null,vA=null,IA=null,DA=null,Jt=null;vA=this._hi+C,cA=this._lo+Q,IA=vA-(DA=vA-this._hi),yA=cA-(Jt=cA-this._lo);var Yj=(oA=vA+(DA=(IA=C-DA+(this._hi-IA))+cA))+(DA=(yA=Q-Jt+(this._lo-yA))+(DA+(vA-oA))),Br=DA+(oA-Yj);return this._hi=Yj,this._lo=Br,this}},Y.prototype.selfMultiply=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfMultiply(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.selfMultiply(a,0)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1],p=null,$=null,q=null,M=null,C=null,Q=null;p=(C=Y.SPLIT*this._hi)-this._hi,Q=Y.SPLIT*u,p=C-p,$=this._hi-p,q=Q-u;var oA=(C=this._hi*u)+(Q=p*(q=Q-q)-C+p*(M=u-q)+$*q+$*M+(this._hi*f+this._lo*u)),cA=Q+(p=C-oA);return this._hi=oA,this._lo=cA,this}},Y.prototype.selfSqr=function(){return this.selfMultiply(this)},Y.prototype.floor=function(){if(this.isNaN())return Y.NaN;var s=Math.floor(this._hi),a=0;return s===this._hi&&(a=Math.floor(this._lo)),new Y(s,a)},Y.prototype.negate=function(){return this.isNaN()?this:new Y(-this._hi,-this._lo)},Y.prototype.clone=function(){},Y.prototype.multiply=function(){if(arguments[0]instanceof Y){var s=arguments[0];return s.isNaN()?Y.createNaN():Y.copy(this).selfMultiply(s)}if(typeof arguments[0]=="number"){var a=arguments[0];return v.isNaN(a)?Y.createNaN():Y.copy(this).selfMultiply(a,0)}},Y.prototype.isNaN=function(){return v.isNaN(this._hi)},Y.prototype.intValue=function(){return Math.trunc(this._hi)},Y.prototype.toString=function(){var s=Y.magnitude(this._hi);return s>=-3&&s<=20?this.toStandardNotation():this.toSciNotation()},Y.prototype.toStandardNotation=function(){var s=this.getSpecialNumberString();if(s!==null)return s;var a=new Array(1).fill(null),u=this.extractSignificantDigits(!0,a),f=a[0]+1,p=u;if(u.charAt(0)===".")p="0"+u;else if(f<0)p="0."+Y.stringOfChar("0",-f)+u;else if(u.indexOf(".")===-1){var $=f-u.length;p=u+Y.stringOfChar("0",$)+".0"}return this.isNegative()?"-"+p:p},Y.prototype.reciprocal=function(){var s=null,a=null,u=null,f=null,p=null,$=null,q=null,M=null;a=(p=1/this._hi)-(s=($=Y.SPLIT*p)-(s=$-p)),u=(M=Y.SPLIT*this._hi)-this._hi;var C=p+($=(1-(q=p*this._hi)-(M=s*(u=M-u)-q+s*(f=this._hi-u)+a*u+a*f)-p*this._lo)/this._hi);return new Y(C,p-C+$)},Y.prototype.toSciNotation=function(){if(this.isZero())return Y.SCI_NOT_ZERO;var s=this.getSpecialNumberString();if(s!==null)return s;var a=new Array(1).fill(null),u=this.extractSignificantDigits(!1,a),f=Y.SCI_NOT_EXPONENT_CHAR+a[0];if(u.charAt(0)==="0")throw new Error("Found leading zero: "+u);var p="";u.length>1&&(p=u.substring(1));var $=u.charAt(0)+"."+p;return this.isNegative()?"-"+$+f:$+f},Y.prototype.abs=function(){return this.isNaN()?Y.NaN:this.isNegative()?this.negate():new Y(this)},Y.prototype.isPositive=function(){return(this._hi>0||this._hi===0)&&this._lo>0},Y.prototype.lt=function(s){return(this._his._hi||this._hi===s._hi)&&this._lo>s._lo},Y.prototype.isNegative=function(){return(this._hi<0||this._hi===0)&&this._lo<0},Y.prototype.trunc=function(){return this.isNaN()?Y.NaN:this.isPositive()?this.floor():this.ceil()},Y.prototype.signum=function(){return this._hi>0?1:this._hi<0?-1:this._lo>0?1:this._lo<0?-1:0},Y.prototype.interfaces_=function(){return[A,w,x]},Y.prototype.getClass=function(){return Y},Y.sqr=function(s){return Y.valueOf(s).selfMultiply(s)},Y.valueOf=function(){if(typeof arguments[0]=="string"){var s=arguments[0];return Y.parse(s)}if(typeof arguments[0]=="number"){var a=arguments[0];return new Y(a)}},Y.sqrt=function(s){return Y.valueOf(s).sqrt()},Y.parse=function(s){for(var a=0,u=s.length;_A.isWhitespace(s.charAt(a));)a++;var f=!1;if(a=u);){var Q=s.charAt(a);if(a++,_A.isDigit(Q)){var oA=Q-"0";$.selfMultiply(Y.TEN),$.selfAdd(oA),q++}else{if(Q!=="."){if(Q==="e"||Q==="E"){var cA=s.substring(a);try{C=$A.parseInt(cA)}catch(Jt){throw Jt instanceof Error?new Error("Invalid exponent "+cA+" in string "+s):Jt}break}throw new Error("Unexpected character '"+Q+"' at position "+a+" in string "+s)}M=q}}var yA=$,vA=q-M-C;if(vA===0)yA=$;else if(vA>0){var IA=Y.TEN.pow(vA);yA=$.divide(IA)}else if(vA<0){var DA=Y.TEN.pow(-vA);yA=$.multiply(DA)}return f?yA.negate():yA},Y.createNaN=function(){return new Y(v.NaN,v.NaN)},Y.copy=function(s){return new Y(s)},Y.magnitude=function(s){var a=Math.abs(s),u=Math.log(a)/Math.log(10),f=Math.trunc(Math.floor(u));return 10*Math.pow(10,f)<=a&&(f+=1),f},Y.stringOfChar=function(s,a){for(var u=new dA,f=0;f0){if($<=0)return mt.signum(q);f=p+$}else{if(!(p<0)||$>=0)return mt.signum(q);f=-p-$}var M=mt.DP_SAFE_EPSILON*f;return q>=M||-q>=M?mt.signum(q):2},mt.signum=function(s){return s>0?1:s<0?-1:0},Ct.DP_SAFE_EPSILON.get=function(){return 1e-15},Object.defineProperties(mt,Ct);var SA=function(){},ft={X:{configurable:!0},Y:{configurable:!0},Z:{configurable:!0},M:{configurable:!0}};ft.X.get=function(){return 0},ft.Y.get=function(){return 1},ft.Z.get=function(){return 2},ft.M.get=function(){return 3},SA.prototype.setOrdinate=function(s,a,u){},SA.prototype.size=function(){},SA.prototype.getOrdinate=function(s,a){},SA.prototype.getCoordinate=function(){},SA.prototype.getCoordinateCopy=function(s){},SA.prototype.getDimension=function(){},SA.prototype.getX=function(s){},SA.prototype.clone=function(){},SA.prototype.expandEnvelope=function(s){},SA.prototype.copy=function(){},SA.prototype.getY=function(s){},SA.prototype.toCoordinateArray=function(){},SA.prototype.interfaces_=function(){return[x]},SA.prototype.getClass=function(){return SA},Object.defineProperties(SA,ft);var wA=function(){},_t=function(s){function a(){s.call(this,"Projective point not representable on the Cartesian plane.")}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(wA),qA=function(){};qA.arraycopy=function(s,a,u,f,p){for(var $=0,q=a;qs._minx?this._minx:s._minx,u=this._miny>s._miny?this._miny:s._miny,f=this._maxx=this._minx&&a.getMaxX()<=this._maxx&&a.getMinY()>=this._miny&&a.getMaxY()<=this._maxy}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];return!this.isNull()&&u>=this._minx&&u<=this._maxx&&f>=this._miny&&f<=this._maxy}},bA.prototype.intersects=function(){if(arguments.length===1){if(arguments[0]instanceof bA){var s=arguments[0];return!this.isNull()&&!s.isNull()&&!(s._minx>this._maxx||s._maxxthis._maxy||s._maxythis._maxx||uthis._maxy||fthis._maxx&&(this._maxx=a._maxx),a._minythis._maxy&&(this._maxy=a._maxy))}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.isNull()?(this._minx=u,this._maxx=u,this._miny=f,this._maxy=f):(uthis._maxx&&(this._maxx=u),fthis._maxy&&(this._maxy=f))}},bA.prototype.minExtent=function(){if(this.isNull())return 0;var s=this.getWidth(),a=this.getHeight();return sa._minx?1:this._minya._miny?1:this._maxxa._maxx?1:this._maxya._maxy?1:0},bA.prototype.translate=function(s,a){if(this.isNull())return null;this.init(this.getMinX()+s,this.getMaxX()+s,this.getMinY()+a,this.getMaxY()+a)},bA.prototype.toString=function(){return"Env["+this._minx+" : "+this._maxx+", "+this._miny+" : "+this._maxy+"]"},bA.prototype.setToNull=function(){this._minx=0,this._maxx=-1,this._miny=0,this._maxy=-1},bA.prototype.getHeight=function(){return this.isNull()?0:this._maxy-this._miny},bA.prototype.maxExtent=function(){if(this.isNull())return 0;var s=this.getWidth(),a=this.getHeight();return s>a?s:a},bA.prototype.expandBy=function(){if(arguments.length===1){var s=arguments[0];this.expandBy(s,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1];if(this.isNull())return null;this._minx-=a,this._maxx+=a,this._miny-=u,this._maxy+=u,(this._minx>this._maxx||this._miny>this._maxy)&&this.setToNull()}},bA.prototype.contains=function(){if(arguments.length===1){if(arguments[0]instanceof bA){var s=arguments[0];return this.covers(s)}if(arguments[0]instanceof F){var a=arguments[0];return this.covers(a)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];return this.covers(u,f)}},bA.prototype.centre=function(){return this.isNull()?null:new F((this.getMinX()+this.getMaxX())/2,(this.getMinY()+this.getMaxY())/2)},bA.prototype.init=function(){if(arguments.length===0)this.setToNull();else if(arguments.length===1){if(arguments[0]instanceof F){var s=arguments[0];this.init(s.x,s.x,s.y,s.y)}else if(arguments[0]instanceof bA){var a=arguments[0];this._minx=a._minx,this._maxx=a._maxx,this._miny=a._miny,this._maxy=a._maxy}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.init(u.x,f.x,u.y,f.y)}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];p<$?(this._minx=p,this._maxx=$):(this._minx=$,this._maxx=p),qs._maxx&&(a=this._minx-s._maxx);var u=0;return this._maxys._maxy&&(u=this._miny-s._maxy),a===0?u:u===0?a:Math.sqrt(a*a+u*u)},bA.prototype.hashCode=function(){var s=17;return s=37*s+F.hashCode(this._minx),s=37*s+F.hashCode(this._maxx),s=37*s+F.hashCode(this._miny),s=37*s+F.hashCode(this._maxy)},bA.prototype.interfaces_=function(){return[w,A]},bA.prototype.getClass=function(){return bA},bA.intersects=function(){if(arguments.length===3){var s=arguments[0],a=arguments[1],u=arguments[2];return u.x>=(s.xa.x?s.x:a.x)&&u.y>=(s.ya.y?s.y:a.y)}if(arguments.length===4){var f=arguments[0],p=arguments[1],$=arguments[2],q=arguments[3],M=Math.min($.x,q.x),C=Math.max($.x,q.x),Q=Math.min(f.x,p.x),oA=Math.max(f.x,p.x);return!(Q>C)&&!(oAC)&&!(oAthis.getEdgeDistance(s,1)?(this._intLineIndex[s][0]=0,this._intLineIndex[s][1]=1):(this._intLineIndex[s][0]=1,this._intLineIndex[s][1]=0)}},xA.prototype.isProper=function(){return this.hasIntersection()&&this._isProper},xA.prototype.setPrecisionModel=function(s){this._precisionModel=s},xA.prototype.isInteriorIntersection=function(){if(arguments.length===0)return!!this.isInteriorIntersection(0)||!!this.isInteriorIntersection(1);if(arguments.length===1){for(var s=arguments[0],a=0;ap?f:p;else{var q=Math.abs(s.x-a.x),M=Math.abs(s.y-a.y);($=f>p?q:M)!==0||s.equals(a)||($=Math.max(q,M))}return KA.isTrue(!($===0&&!s.equals(a)),"Bad distance calculation"),$},xA.nonRobustComputeEdgeDistance=function(s,a,u){var f=s.x-a.x,p=s.y-a.y,$=Math.sqrt(f*f+p*p);return KA.isTrue(!($===0&&!s.equals(a)),"Invalid distance calculation"),$},fA.DONT_INTERSECT.get=function(){return 0},fA.DO_INTERSECT.get=function(){return 1},fA.COLLINEAR.get=function(){return 2},fA.NO_INTERSECTION.get=function(){return 0},fA.POINT_INTERSECTION.get=function(){return 1},fA.COLLINEAR_INTERSECTION.get=function(){return 2},Object.defineProperties(xA,fA);var PA=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isInSegmentEnvelopes=function(u){var f=new bA(this._inputLines[0][0],this._inputLines[0][1]),p=new bA(this._inputLines[1][0],this._inputLines[1][1]);return f.contains(u)&&p.contains(u)},a.prototype.computeIntersection=function(){if(arguments.length!==3)return s.prototype.computeIntersection.apply(this,arguments);var u=arguments[0],f=arguments[1],p=arguments[2];if(this._isProper=!1,bA.intersects(f,p,u)&&EA.orientationIndex(f,p,u)===0&&EA.orientationIndex(p,f,u)===0)return this._isProper=!0,(u.equals(f)||u.equals(p))&&(this._isProper=!1),this._result=s.POINT_INTERSECTION,null;this._result=s.NO_INTERSECTION},a.prototype.normalizeToMinimum=function(u,f,p,$,q){q.x=this.smallestInAbsValue(u.x,f.x,p.x,$.x),q.y=this.smallestInAbsValue(u.y,f.y,p.y,$.y),u.x-=q.x,u.y-=q.y,f.x-=q.x,f.y-=q.y,p.x-=q.x,p.y-=q.y,$.x-=q.x,$.y-=q.y},a.prototype.safeHCoordinateIntersection=function(u,f,p,$){var q=null;try{q=Ht.intersection(u,f,p,$)}catch(M){if(!(M instanceof _t))throw M;q=a.nearestEndpoint(u,f,p,$)}return q},a.prototype.intersection=function(u,f,p,$){var q=this.intersectionWithNormalization(u,f,p,$);return this.isInSegmentEnvelopes(q)||(q=new F(a.nearestEndpoint(u,f,p,$))),this._precisionModel!==null&&this._precisionModel.makePrecise(q),q},a.prototype.smallestInAbsValue=function(u,f,p,$){var q=u,M=Math.abs(q);return Math.abs(f)1e-4&&qA.out.println("Distance = "+q.distance(M))},a.prototype.intersectionWithNormalization=function(u,f,p,$){var q=new F(u),M=new F(f),C=new F(p),Q=new F($),oA=new F;this.normalizeToEnvCentre(q,M,C,Q,oA);var cA=this.safeHCoordinateIntersection(q,M,C,Q);return cA.x+=oA.x,cA.y+=oA.y,cA},a.prototype.computeCollinearIntersection=function(u,f,p,$){var q=bA.intersects(u,f,p),M=bA.intersects(u,f,$),C=bA.intersects(p,$,u),Q=bA.intersects(p,$,f);return q&&M?(this._intPt[0]=p,this._intPt[1]=$,s.COLLINEAR_INTERSECTION):C&&Q?(this._intPt[0]=u,this._intPt[1]=f,s.COLLINEAR_INTERSECTION):q&&C?(this._intPt[0]=p,this._intPt[1]=u,!p.equals(u)||M||Q?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):q&&Q?(this._intPt[0]=p,this._intPt[1]=f,!p.equals(f)||M||C?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):M&&C?(this._intPt[0]=$,this._intPt[1]=u,!$.equals(u)||q||Q?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):M&&Q?(this._intPt[0]=$,this._intPt[1]=f,!$.equals(f)||q||C?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):s.NO_INTERSECTION},a.prototype.normalizeToEnvCentre=function(u,f,p,$,q){var M=u.xf.x?u.x:f.x,oA=u.y>f.y?u.y:f.y,cA=p.x<$.x?p.x:$.x,yA=p.y<$.y?p.y:$.y,vA=p.x>$.x?p.x:$.x,IA=p.y>$.y?p.y:$.y,DA=((M>cA?M:cA)+(QyA?C:yA)+(oA0&&M>0||q<0&&M<0)return s.NO_INTERSECTION;var C=EA.orientationIndex(p,$,u),Q=EA.orientationIndex(p,$,f);return C>0&&Q>0||C<0&&Q<0?s.NO_INTERSECTION:q===0&&M===0&&C===0&&Q===0?this.computeCollinearIntersection(u,f,p,$):(q===0||M===0||C===0||Q===0?(this._isProper=!1,u.equals2D(p)||u.equals2D($)?this._intPt[0]=u:f.equals2D(p)||f.equals2D($)?this._intPt[0]=f:q===0?this._intPt[0]=new F(p):M===0?this._intPt[0]=new F($):C===0?this._intPt[0]=new F(u):Q===0&&(this._intPt[0]=new F(f))):(this._isProper=!0,this._intPt[0]=this.intersection(u,f,p,$)),s.POINT_INTERSECTION)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.nearestEndpoint=function(u,f,p,$){var q=u,M=EA.distancePointLine(u,p,$),C=EA.distancePointLine(f,p,$);return C0?u>0?-p:p:u>0?p:-p;if(a===0||u===0)return f>0?s>0?p:-p:s>0?-p:p;if(a>0?f>0?a<=f||(p=-p,$=s,s=u,u=$,$=a,a=f,f=$):a<=-f?(p=-p,u=-u,f=-f):($=s,s=-u,u=$,$=a,a=-f,f=$):f>0?-a<=f?(p=-p,s=-s,a=-a):($=-s,s=u,u=$,$=-a,a=f,f=$):a>=f?(s=-s,a=-a,u=-u,f=-f):(p=-p,$=-s,s=-u,u=$,$=-a,a=-f,f=$),s>0){if(!(u>0)||!(s<=u))return p}else{if(u>0||!(s>=u))return-p;p=-p,s=-s,u=-u}for(;;){if(q=Math.floor(u/s),u-=q*s,(f-=q*a)<0)return-p;if(f>a)return p;if(s>u+u){if(af+f)return-p;u=s-u,f=a-f,p=-p}if(f===0)return u===0?0:-p;if(u===0||(q=Math.floor(s/u),s-=q*u,(a-=q*f)<0))return p;if(a>f)return-p;if(u>s+s){if(fa+a)return p;s=u-s,a=f-a,p=-p}if(a===0)return s===0?0:p;if(s===0)return-p}};var Gt=function(){this._p=null,this._crossingCount=0,this._isPointOnSegment=!1;var s=arguments[0];this._p=s};Gt.prototype.countSegment=function(s,a){if(s.xf&&(u=a.x,f=s.x),this._p.x>=u&&this._p.x<=f&&(this._isPointOnSegment=!0),null}if(s.y>this._p.y&&a.y<=this._p.y||a.y>this._p.y&&s.y<=this._p.y){var p=s.x-this._p.x,$=s.y-this._p.y,q=a.x-this._p.x,M=a.y-this._p.y,C=RA.signOfDet2x2(p,$,q,M);if(C===0)return this._isPointOnSegment=!0,null;M<$&&(C=-C),C>0&&this._crossingCount++}},Gt.prototype.isPointInPolygon=function(){return this.getLocation()!==T.EXTERIOR},Gt.prototype.getLocation=function(){return this._isPointOnSegment?T.BOUNDARY:this._crossingCount%2==1?T.INTERIOR:T.EXTERIOR},Gt.prototype.isOnSegment=function(){return this._isPointOnSegment},Gt.prototype.interfaces_=function(){return[]},Gt.prototype.getClass=function(){return Gt},Gt.locatePointInRing=function(){if(arguments[0]instanceof F&&G(arguments[1],SA)){for(var s=arguments[0],a=arguments[1],u=new Gt(s),f=new F,p=new F,$=1;$1||M<0||M>1)&&(p=!0)}}else p=!0;return p?jA.min(EA.distancePointLine(s,u,f),EA.distancePointLine(a,u,f),EA.distancePointLine(u,s,a),EA.distancePointLine(f,s,a)):0},EA.isPointInRing=function(s,a){return EA.locatePointInRing(s,a)!==T.EXTERIOR},EA.computeLength=function(s){var a=s.size();if(a<=1)return 0;var u=0,f=new F;s.getCoordinate(0,f);for(var p=f.x,$=f.y,q=1;qu.y&&(u=$,f=p)}var q=f;do(q-=1)<0&&(q=a);while(s[q].equals2D(u)&&q!==f);var M=f;do M=(M+1)%a;while(s[M].equals2D(u)&&M!==f);var C=s[q],Q=s[M];if(C.equals2D(u)||Q.equals2D(u)||C.equals2D(Q))return!1;var oA=EA.computeOrientation(C,u,Q),cA=!1;return cA=oA===0?C.x>Q.x:oA>0,cA},EA.locatePointInRing=function(s,a){return Gt.locatePointInRing(s,a)},EA.distancePointLinePerpendicular=function(s,a,u){var f=(u.x-a.x)*(u.x-a.x)+(u.y-a.y)*(u.y-a.y),p=((a.y-s.y)*(u.x-a.x)-(a.x-s.x)*(u.y-a.y))/f;return Math.abs(p)*Math.sqrt(f)},EA.computeOrientation=function(s,a,u){return EA.orientationIndex(s,a,u)},EA.distancePointLine=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];if(a.length===0)throw new b("Line array must contain at least one vertex");for(var u=s.distance(a[0]),f=0;f=1)return $.distance(M);var oA=((q.y-$.y)*(M.x-q.x)-(q.x-$.x)*(M.y-q.y))/C;return Math.abs(oA)*Math.sqrt(C)}},EA.isOnLine=function(s,a){for(var u=new PA,f=1;f0},V.prototype.interfaces_=function(){return[P]},V.prototype.getClass=function(){return V};var U=function(){};U.prototype.isInBoundary=function(s){return s>1},U.prototype.interfaces_=function(){return[P]},U.prototype.getClass=function(){return U};var lA=function(){};lA.prototype.isInBoundary=function(s){return s===1},lA.prototype.interfaces_=function(){return[P]},lA.prototype.getClass=function(){return lA};var rA=function(){};rA.prototype.add=function(){},rA.prototype.addAll=function(){},rA.prototype.isEmpty=function(){},rA.prototype.iterator=function(){},rA.prototype.size=function(){},rA.prototype.toArray=function(){},rA.prototype.remove=function(){},(j.prototype=new Error).name="IndexOutOfBoundsException";var hA=function(){};hA.prototype.hasNext=function(){},hA.prototype.next=function(){},hA.prototype.remove=function(){};var uA=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.get=function(){},a.prototype.set=function(){},a.prototype.isEmpty=function(){},a}(rA);(e.prototype=new Error).name="NoSuchElementException";var nA=function(s){function a(){s.call(this),this.array_=[],arguments[0]instanceof rA&&this.addAll(arguments[0])}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.ensureCapacity=function(){},a.prototype.interfaces_=function(){return[s,rA]},a.prototype.add=function(u){return arguments.length===1?this.array_.push(u):this.array_.splice(arguments[0],arguments[1]),!0},a.prototype.clear=function(){this.array_=[]},a.prototype.addAll=function(u){for(var f=u.iterator();f.hasNext();)this.add(f.next());return!0},a.prototype.set=function(u,f){var p=this.array_[u];return this.array_[u]=f,p},a.prototype.iterator=function(){return new sA(this)},a.prototype.get=function(u){if(u<0||u>=this.size())throw new j;return this.array_[u]},a.prototype.isEmpty=function(){return this.array_.length===0},a.prototype.size=function(){return this.array_.length},a.prototype.toArray=function(){for(var u=[],f=0,p=this.array_.length;f=1&&this.get(this.size()-1).equals2D(q))return null;s.prototype.add.call(this,q)}else if(arguments[0]instanceof Object&&typeof arguments[1]=="boolean"){var M=arguments[0],C=arguments[1];return this.add(M,C),!0}}else if(arguments.length===3){if(typeof arguments[2]=="boolean"&&arguments[0]instanceof Array&&typeof arguments[1]=="boolean"){var Q=arguments[0],oA=arguments[1];if(arguments[2])for(var cA=0;cA=0;yA--)this.add(Q[yA],oA);return!0}if(typeof arguments[2]=="boolean"&&Number.isInteger(arguments[0])&&arguments[1]instanceof F){var vA=arguments[0],IA=arguments[1];if(!arguments[2]){var DA=this.size();if(DA>0&&(vA>0&&this.get(vA-1).equals2D(IA)||vANi&&(Vs=-1);for(var D_=Br;D_!==Ni;D_+=Vs)this.add(Jt[D_],Yj);return!0}},a.prototype.closeRing=function(){this.size()>0&&this.add(new F(this.get(0)),!1)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},Object.defineProperties(a,u),a}(nA),BA=function(){},tt={ForwardComparator:{configurable:!0},BidirectionalComparator:{configurable:!0},coordArrayType:{configurable:!0}};tt.ForwardComparator.get=function(){return UA},tt.BidirectionalComparator.get=function(){return wt},tt.coordArrayType.get=function(){return new Array(0).fill(null)},BA.prototype.interfaces_=function(){return[]},BA.prototype.getClass=function(){return BA},BA.isRing=function(s){return!(s.length<4)&&!!s[0].equals2D(s[s.length-1])},BA.ptNotInList=function(s,a){for(var u=0;u=s?a:[]},BA.indexOf=function(s,a){for(var u=0;u0)&&(a=s[u]);return a},BA.extract=function(s,a,u){a=jA.clamp(a,0,s.length);var f=(u=jA.clamp(u,-1,s.length))-a+1;u<0&&(f=0),a>=s.length&&(f=0),uf.length)return 1;if(u.length===0)return 0;var p=BA.compare(u,f);return BA.isEqualReversed(u,f)?0:p},wt.prototype.OLDcompare=function(s,a){var u=s,f=a;if(u.lengthf.length)return 1;if(u.length===0)return 0;for(var p=BA.increasingDirection(u),$=BA.increasingDirection(f),q=p>0?0:u.length-1,M=$>0?0:u.length-1,C=0;C0))return a.value;a=a.right}}return null},h.prototype.put=function(s,a){if(this.root_===null)return this.root_={key:s,value:a,left:null,right:null,parent:null,color:dj,getValue:function(){return this.value},getKey:function(){return this.key}},this.size_=1,null;var u,f,p=this.root_;do if(u=p,(f=s.compareTo(p.key))<0)p=p.left;else{if(!(f>0)){var $=p.value;return p.value=a,$}p=p.right}while(p!==null);var q={key:s,left:null,right:null,value:a,parent:u,color:dj,getValue:function(){return this.value},getKey:function(){return this.key}};return f<0?u.left=q:u.right=q,this.fixAfterInsertion(q),this.size_++,null},h.prototype.fixAfterInsertion=function(s){for(s.color=1;s!=null&&s!==this.root_&&s.parent.color===1;)if(o(s)===c(o(o(s)))){var a=B(o(o(s)));i(a)===1?(l(o(s),dj),l(a,dj),l(o(o(s)),1),s=o(o(s))):(s===B(o(s))&&(s=o(s),this.rotateLeft(s)),l(o(s),dj),l(o(o(s)),1),this.rotateRight(o(o(s))))}else{var u=c(o(o(s)));i(u)===1?(l(o(s),dj),l(u,dj),l(o(o(s)),1),s=o(o(s))):(s===c(o(s))&&(s=o(s),this.rotateRight(s)),l(o(s),dj),l(o(o(s)),1),this.rotateLeft(o(o(s))))}this.root_.color=dj},h.prototype.values=function(){var s=new nA,a=this.getFirstEntry();if(a!==null)for(s.add(a.value);(a=h.successor(a))!==null;)s.add(a.value);return s},h.prototype.entrySet=function(){var s=new Lj,a=this.getFirstEntry();if(a!==null)for(s.add(a);(a=h.successor(a))!==null;)s.add(a);return s},h.prototype.rotateLeft=function(s){if(s!=null){var a=s.right;s.right=a.left,a.left!=null&&(a.left.parent=s),a.parent=s.parent,s.parent===null?this.root_=a:s.parent.left===s?s.parent.left=a:s.parent.right=a,a.left=s,s.parent=a}},h.prototype.rotateRight=function(s){if(s!=null){var a=s.left;s.left=a.right,a.right!=null&&(a.right.parent=s),a.parent=s.parent,s.parent===null?this.root_=a:s.parent.right===s?s.parent.right=a:s.parent.left=a,a.right=s,s.parent=a}},h.prototype.getFirstEntry=function(){var s=this.root_;if(s!=null)for(;s.left!=null;)s=s.left;return s},h.successor=function(s){if(s===null)return null;if(s.right!==null){for(var a=s.right;a.left!==null;)a=a.left;return a}for(var u=s.parent,f=s;u!==null&&f===u.right;)f=u,u=u.parent;return u},h.prototype.size=function(){return this.size_};var Cj=function(){};Cj.prototype.interfaces_=function(){return[]},Cj.prototype.getClass=function(){return Cj},d.prototype=new n,(k.prototype=new d).contains=function(s){for(var a=0,u=this.array_.length;a=0;){var q=p.substring(0,$);f.add(q),$=(p=p.substring($+u)).indexOf(a)}p.length>0&&f.add(p);for(var M=new Array(f.size()).fill(null),C=0;C0)for(var $=p;$0&&f.append(" ");for(var $=0;$0&&f.append(","),f.append(ue.toString(s.getOrdinate(p,$)))}return f.append(")"),f.toString()}},uj.ensureValidRing=function(s,a){var u=a.size();return u===0?a:u<=3?uj.createClosedRing(s,a,4):a.getOrdinate(0,SA.X)===a.getOrdinate(u-1,SA.X)&&a.getOrdinate(0,SA.Y)===a.getOrdinate(u-1,SA.Y)?a:uj.createClosedRing(s,a,u+1)},uj.createClosedRing=function(s,a,u){var f=s.create(u,a.getDimension()),p=a.size();uj.copy(a,0,f,0,p);for(var $=p;$0&&uj.reverse(this._points),null}},a.prototype.getCoordinate=function(){return this.isEmpty()?null:this._points.getCoordinate(0)},a.prototype.getBoundaryDimension=function(){return this.isClosed()?jt.FALSE:0},a.prototype.isClosed=function(){return!this.isEmpty()&&this.getCoordinateN(0).equals2D(this.getCoordinateN(this.getNumPoints()-1))},a.prototype.getEndPoint=function(){return this.isEmpty()?null:this.getPointN(this.getNumPoints()-1)},a.prototype.getDimension=function(){return 1},a.prototype.getLength=function(){return EA.computeLength(this._points)},a.prototype.getNumPoints=function(){return this._points.size()},a.prototype.reverse=function(){var f=this._points.copy();return uj.reverse(f),this.getFactory().createLineString(f)},a.prototype.compareToSameClass=function(){if(arguments.length===1){for(var f=arguments[0],p=0,$=0;p= 2)");this._points=f},a.prototype.isCoordinate=function(f){for(var p=0;p=1&&this.getCoordinateSequence().size()= 4)")},a.prototype.getGeometryType=function(){return"LinearRing"},a.prototype.copy=function(){return new a(this._points.copy(),this._factory)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},u.MINIMUM_VALID_SIZE.get=function(){return 4},u.serialVersionUID.get=function(){return-0x3b229e262367a600},Object.defineProperties(a,u),a}(Bj),xe=function(s){function a(){s.apply(this,arguments)}s&&(a.__proto__=s),(a.prototype=Object.create(s&&s.prototype)).constructor=a;var u={serialVersionUID:{configurable:!0}};return a.prototype.getSortIndex=function(){return MA.SORTINDEX_MULTIPOLYGON},a.prototype.equalsExact=function(){if(arguments.length===2){var f=arguments[0],p=arguments[1];return!!this.isEquivalentClass(f)&&s.prototype.equalsExact.call(this,f,p)}return s.prototype.equalsExact.apply(this,arguments)},a.prototype.getBoundaryDimension=function(){return 1},a.prototype.getDimension=function(){return 2},a.prototype.reverse=function(){for(var f=this._geometries.length,p=new Array(f).fill(null),$=0;$0?a.createPoint(u[0]):a.createPoint():s},t7.prototype.interfaces_=function(){return[Ie.GeometryEditorOperation]},t7.prototype.getClass=function(){return t7};var j7=function(){};j7.prototype.edit=function(s,a){return s instanceof Pe?a.createLinearRing(this.edit(s.getCoordinateSequence(),s)):s instanceof Bj?a.createLineString(this.edit(s.getCoordinateSequence(),s)):s instanceof ir?a.createPoint(this.edit(s.getCoordinateSequence(),s)):s},j7.prototype.interfaces_=function(){return[Ie.GeometryEditorOperation]},j7.prototype.getClass=function(){return j7};var fj=function(){if(this._dimension=3,this._coordinates=null,arguments.length===1){if(arguments[0]instanceof Array)this._coordinates=arguments[0],this._dimension=3;else if(Number.isInteger(arguments[0])){var s=arguments[0];this._coordinates=new Array(s).fill(null);for(var a=0;a0){var s=new dA(17*this._coordinates.length);s.append("("),s.append(this._coordinates[0]);for(var a=1;a3&&(f=3),f<2?new fj(u):new fj(u,f)}},Yr.prototype.interfaces_=function(){return[z,A]},Yr.prototype.getClass=function(){return Yr},Yr.instance=function(){return Yr.instanceObject},yl.serialVersionUID.get=function(){return-0x38e49fa6cf6f2e00},yl.instanceObject.get=function(){return new Yr},Object.defineProperties(Yr,yl);var lu=function(s){function a(){s.call(this),this.map_=new Map}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.get=function(u){return this.map_.get(u)||null},a.prototype.put=function(u,f){return this.map_.set(u,f),f},a.prototype.values=function(){for(var u=new nA,f=this.map_.values(),p=f.next();!p.done;)u.add(p.value),p=f.next();return u},a.prototype.entrySet=function(){var u=new Lj;return this.map_.entries().forEach(function(f){return u.add(f)}),u},a.prototype.size=function(){return this.map_.size()},a}(at),Pt=function s(){if(this._modelType=null,this._scale=null,arguments.length===0)this._modelType=s.FLOATING;else if(arguments.length===1){if(arguments[0]instanceof br){var a=arguments[0];this._modelType=a,a===s.FIXED&&this.setScale(1)}else if(typeof arguments[0]=="number"){var u=arguments[0];this._modelType=s.FIXED,this.setScale(u)}else if(arguments[0]instanceof s){var f=arguments[0];this._modelType=f._modelType,this._scale=f._scale}}},vl={serialVersionUID:{configurable:!0},maximumPreciseValue:{configurable:!0}};Pt.prototype.equals=function(s){if(!(s instanceof Pt))return!1;var a=s;return this._modelType===a._modelType&&this._scale===a._scale},Pt.prototype.compareTo=function(s){var a=s,u=this.getMaximumSignificantDigits(),f=a.getMaximumSignificantDigits();return new $A(u).compareTo(new $A(f))},Pt.prototype.getScale=function(){return this._scale},Pt.prototype.isFloating=function(){return this._modelType===Pt.FLOATING||this._modelType===Pt.FLOATING_SINGLE},Pt.prototype.getType=function(){return this._modelType},Pt.prototype.toString=function(){var s="UNKNOWN";return this._modelType===Pt.FLOATING?s="Floating":this._modelType===Pt.FLOATING_SINGLE?s="Floating-Single":this._modelType===Pt.FIXED&&(s="Fixed (Scale="+this.getScale()+")"),s},Pt.prototype.makePrecise=function(){if(typeof arguments[0]=="number"){var s=arguments[0];return v.isNaN(s)||this._modelType===Pt.FLOATING_SINGLE?s:this._modelType===Pt.FIXED?Math.round(s*this._scale)/this._scale:s}if(arguments[0]instanceof F){var a=arguments[0];if(this._modelType===Pt.FLOATING)return null;a.x=this.makePrecise(a.x),a.y=this.makePrecise(a.y)}},Pt.prototype.getMaximumSignificantDigits=function(){var s=16;return this._modelType===Pt.FLOATING?s=16:this._modelType===Pt.FLOATING_SINGLE?s=6:this._modelType===Pt.FIXED&&(s=1+Math.trunc(Math.ceil(Math.log(this.getScale())/Math.log(10)))),s},Pt.prototype.setScale=function(s){this._scale=Math.abs(s)},Pt.prototype.interfaces_=function(){return[A,w]},Pt.prototype.getClass=function(){return Pt},Pt.mostPrecise=function(s,a){return s.compareTo(a)>=0?s:a},vl.serialVersionUID.get=function(){return 7777263578777804e3},vl.maximumPreciseValue.get=function(){return 9007199254740992},Object.defineProperties(Pt,vl);var br=function s(a){this._name=a||null,s.nameToTypeMap.put(a,this)},ri={serialVersionUID:{configurable:!0},nameToTypeMap:{configurable:!0}};br.prototype.readResolve=function(){return br.nameToTypeMap.get(this._name)},br.prototype.toString=function(){return this._name},br.prototype.interfaces_=function(){return[A]},br.prototype.getClass=function(){return br},ri.serialVersionUID.get=function(){return-552860263173159e4},ri.nameToTypeMap.get=function(){return new lu},Object.defineProperties(br,ri),Pt.Type=br,Pt.FIXED=new br("FIXED"),Pt.FLOATING=new br("FLOATING"),Pt.FLOATING_SINGLE=new br("FLOATING SINGLE");var Et=function s(){this._precisionModel=new Pt,this._SRID=0,this._coordinateSequenceFactory=s.getDefaultCoordinateSequenceFactory(),arguments.length===0||(arguments.length===1?G(arguments[0],z)?this._coordinateSequenceFactory=arguments[0]:arguments[0]instanceof Pt&&(this._precisionModel=arguments[0]):arguments.length===2?(this._precisionModel=arguments[0],this._SRID=arguments[1]):arguments.length===3&&(this._precisionModel=arguments[0],this._SRID=arguments[1],this._coordinateSequenceFactory=arguments[2]))},nh={serialVersionUID:{configurable:!0}};Et.prototype.toGeometry=function(s){return s.isNull()?this.createPoint(null):s.getMinX()===s.getMaxX()&&s.getMinY()===s.getMaxY()?this.createPoint(new F(s.getMinX(),s.getMinY())):s.getMinX()===s.getMaxX()||s.getMinY()===s.getMaxY()?this.createLineString([new F(s.getMinX(),s.getMinY()),new F(s.getMaxX(),s.getMaxY())]):this.createPolygon(this.createLinearRing([new F(s.getMinX(),s.getMinY()),new F(s.getMinX(),s.getMaxY()),new F(s.getMaxX(),s.getMaxY()),new F(s.getMaxX(),s.getMinY()),new F(s.getMinX(),s.getMinY())]),null)},Et.prototype.createLineString=function(s){return s?s instanceof Array?new Bj(this.getCoordinateSequenceFactory().create(s),this):G(s,SA)?new Bj(s,this):void 0:new Bj(this.getCoordinateSequenceFactory().create([]),this)},Et.prototype.createMultiLineString=function(){if(arguments.length===0)return new Gr(null,this);if(arguments.length===1){var s=arguments[0];return new Gr(s,this)}},Et.prototype.buildGeometry=function(s){for(var a=null,u=!1,f=!1,p=s.iterator();p.hasNext();){var $=p.next(),q=$.getClass();a===null&&(a=q),q!==a&&(u=!0),$.isGeometryCollectionOrDerived()&&(f=!0)}if(a===null)return this.createGeometryCollection();if(u||f)return this.createGeometryCollection(Et.toGeometryArray(s));var M=s.iterator().next();if(s.size()>1){if(M instanceof Wt)return this.createMultiPolygon(Et.toPolygonArray(s));if(M instanceof Bj)return this.createMultiLineString(Et.toLineStringArray(s));if(M instanceof ir)return this.createMultiPoint(Et.toPointArray(s));KA.shouldNeverReachHere("Unhandled class: "+M.getClass().getName())}return M},Et.prototype.createMultiPointFromCoords=function(s){return this.createMultiPoint(s!==null?this.getCoordinateSequenceFactory().create(s):null)},Et.prototype.createPoint=function(){if(arguments.length===0)return this.createPoint(this.getCoordinateSequenceFactory().create([]));if(arguments.length===1){if(arguments[0]instanceof F){var s=arguments[0];return this.createPoint(s!==null?this.getCoordinateSequenceFactory().create([s]):null)}if(G(arguments[0],SA)){var a=arguments[0];return new ir(a,this)}}},Et.prototype.getCoordinateSequenceFactory=function(){return this._coordinateSequenceFactory},Et.prototype.createPolygon=function(){if(arguments.length===0)return new Wt(null,null,this);if(arguments.length===1){if(G(arguments[0],SA)){var s=arguments[0];return this.createPolygon(this.createLinearRing(s))}if(arguments[0]instanceof Array){var a=arguments[0];return this.createPolygon(this.createLinearRing(a))}if(arguments[0]instanceof Pe){var u=arguments[0];return this.createPolygon(u,null)}}else if(arguments.length===2){var f=arguments[0],p=arguments[1];return new Wt(f,p,this)}},Et.prototype.getSRID=function(){return this._SRID},Et.prototype.createGeometryCollection=function(){if(arguments.length===0)return new oj(null,this);if(arguments.length===1){var s=arguments[0];return new oj(s,this)}},Et.prototype.createGeometry=function(s){return new Ie(this).edit(s,{edit:function(){if(arguments.length===2){var a=arguments[0];return this._coordinateSequenceFactory.create(a)}}})},Et.prototype.getPrecisionModel=function(){return this._precisionModel},Et.prototype.createLinearRing=function(){if(arguments.length===0)return this.createLinearRing(this.getCoordinateSequenceFactory().create([]));if(arguments.length===1){if(arguments[0]instanceof Array){var s=arguments[0];return this.createLinearRing(s!==null?this.getCoordinateSequenceFactory().create(s):null)}if(G(arguments[0],SA)){var a=arguments[0];return new Pe(a,this)}}},Et.prototype.createMultiPolygon=function(){if(arguments.length===0)return new xe(null,this);if(arguments.length===1){var s=arguments[0];return new xe(s,this)}},Et.prototype.createMultiPoint=function(){if(arguments.length===0)return new M6(null,this);if(arguments.length===1){if(arguments[0]instanceof Array){var s=arguments[0];return new M6(s,this)}if(arguments[0]instanceof Array){var a=arguments[0];return this.createMultiPoint(a!==null?this.getCoordinateSequenceFactory().create(a):null)}if(G(arguments[0],SA)){var u=arguments[0];if(u===null)return this.createMultiPoint(new Array(0).fill(null));for(var f=new Array(u.size()).fill(null),p=0;p=this.size())throw new Error;return this.array_[s]},m.prototype.push=function(s){return this.array_.push(s),s},m.prototype.pop=function(s){if(this.array_.length===0)throw new E;return this.array_.pop()},m.prototype.peek=function(){if(this.array_.length===0)throw new E;return this.array_[this.array_.length-1]},m.prototype.empty=function(){return this.array_.length===0},m.prototype.isEmpty=function(){return this.empty()},m.prototype.search=function(s){return this.array_.indexOf(s)},m.prototype.size=function(){return this.array_.length},m.prototype.toArray=function(){for(var s=[],a=0,u=this.array_.length;a0&&this._minIndexthis._minCoord.y&&u.y>this._minCoord.y&&f===EA.CLOCKWISE)&&(p=!0),p&&(this._minIndex=this._minIndex-1)},gA.prototype.getRightmostSideOfSegment=function(s,a){var u=s.getEdge().getCoordinates();if(a<0||a+1>=u.length||u[a].y===u[a+1].y)return-1;var f=H.LEFT;return u[a].ythis._minCoord.x)&&(this._minDe=s,this._minIndex=u,this._minCoord=a[u])},gA.prototype.findRightmostEdgeAtNode=function(){var s=this._minDe.getNode().getEdges();this._minDe=s.getRightmostEdge(),this._minDe.isForward()||(this._minDe=this._minDe.getSym(),this._minIndex=this._minDe.getEdge().getCoordinates().length-1)},gA.prototype.findEdge=function(s){for(var a=s.iterator();a.hasNext();){var u=a.next();u.isForward()&&this.checkForRightmostCoordinate(u)}KA.isTrue(this._minIndex!==0||this._minCoord.equals(this._minDe.getCoordinate()),"inconsistency in rightmost processing"),this._minIndex===0?this.findRightmostEdgeAtNode():this.findRightmostEdgeAtVertex(),this._orientedDe=this._minDe,this.getRightmostSide(this._minDe,this._minIndex)===H.LEFT&&(this._orientedDe=this._minDe.getSym())},gA.prototype.interfaces_=function(){return[]},gA.prototype.getClass=function(){return gA};var GA=function(s){function a(u,f){s.call(this,a.msgWithCoord(u,f)),this.pt=f?new F(f):null,this.name="TopologyException"}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.getCoordinate=function(){return this.pt},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.msgWithCoord=function(u,f){return f?u:u+" [ "+f+" ]"},a}(ce),Ft=function(){this.array_=[]};Ft.prototype.addLast=function(s){this.array_.push(s)},Ft.prototype.removeFirst=function(){return this.array_.shift()},Ft.prototype.isEmpty=function(){return this.array_.length===0};var Xt=function(){this._finder=null,this._dirEdgeList=new nA,this._nodes=new nA,this._rightMostCoord=null,this._env=null,this._finder=new gA};Xt.prototype.clearVisitedEdges=function(){for(var s=this._dirEdgeList.iterator();s.hasNext();)s.next().setVisited(!1)},Xt.prototype.getRightmostCoordinate=function(){return this._rightMostCoord},Xt.prototype.computeNodeDepth=function(s){for(var a=null,u=s.getEdges().iterator();u.hasNext();){var f=u.next();if(f.isVisited()||f.getSym().isVisited()){a=f;break}}if(a===null)throw new GA("unable to find edge to compute depths at "+s.getCoordinate());s.getEdges().computeDepths(a);for(var p=s.getEdges().iterator();p.hasNext();){var $=p.next();$.setVisited(!0),this.copySymDepths($)}},Xt.prototype.computeDepth=function(s){this.clearVisitedEdges();var a=this._finder.getEdge();a.setEdgeDepths(H.RIGHT,s),this.copySymDepths(a),this.computeDepths(a)},Xt.prototype.create=function(s){this.addReachable(s),this._finder.findEdge(this._dirEdgeList),this._rightMostCoord=this._finder.getCoordinate()},Xt.prototype.findResultEdges=function(){for(var s=this._dirEdgeList.iterator();s.hasNext();){var a=s.next();a.getDepth(H.RIGHT)>=1&&a.getDepth(H.LEFT)<=0&&!a.isInteriorAreaEdge()&&a.setInResult(!0)}},Xt.prototype.computeDepths=function(s){var a=new Lj,u=new Ft,f=s.getNode();for(u.addLast(f),a.add(f),s.setVisited(!0);!u.isEmpty();){var p=u.removeFirst();a.add(p),this.computeNodeDepth(p);for(var $=p.getEdges().iterator();$.hasNext();){var q=$.next().getSym();if(!q.isVisited()){var M=q.getNode();a.contains(M)||(u.addLast(M),a.add(M))}}}},Xt.prototype.compareTo=function(s){var a=s;return this._rightMostCoord.xa._rightMostCoord.x?1:0},Xt.prototype.getEnvelope=function(){if(this._env===null){for(var s=new bA,a=this._dirEdgeList.iterator();a.hasNext();)for(var u=a.next().getEdge().getCoordinates(),f=0;fthis.location.length){var a=new Array(3).fill(null);a[H.ON]=this.location[H.ON],a[H.LEFT]=T.NONE,a[H.RIGHT]=T.NONE,this.location=a}for(var u=0;u1&&s.append(T.toLocationSymbol(this.location[H.LEFT])),s.append(T.toLocationSymbol(this.location[H.ON])),this.location.length>1&&s.append(T.toLocationSymbol(this.location[H.RIGHT])),s.toString()},ut.prototype.setLocations=function(s,a,u){this.location[H.ON]=s,this.location[H.LEFT]=a,this.location[H.RIGHT]=u},ut.prototype.get=function(s){return s1},ut.prototype.isAnyNull=function(){for(var s=0;sthis._maxNodeDegree&&(this._maxNodeDegree=a),s=this.getNext(s)}while(s!==this._startDe);this._maxNodeDegree*=2},Yt.prototype.addPoints=function(s,a,u){var f=s.getCoordinates();if(a){var p=1;u&&(p=0);for(var $=p;$=0;M--)this._pts.add(f[M])}},Yt.prototype.isHole=function(){return this._isHole},Yt.prototype.setInResult=function(){var s=this._startDe;do s.getEdge().setInResult(!0),s=s.getNext();while(s!==this._startDe)},Yt.prototype.containsPoint=function(s){var a=this.getLinearRing();if(!a.getEnvelopeInternal().contains(s)||!EA.isPointInRing(s,a.getCoordinates()))return!1;for(var u=this._holes.iterator();u.hasNext();)if(u.next().containsPoint(s))return!1;return!0},Yt.prototype.addHole=function(s){this._holes.add(s)},Yt.prototype.isShell=function(){return this._shell===null},Yt.prototype.getLabel=function(){return this._label},Yt.prototype.getEdges=function(){return this._edges},Yt.prototype.getMaxNodeDegree=function(){return this._maxNodeDegree<0&&this.computeMaxNodeDegree(),this._maxNodeDegree},Yt.prototype.getShell=function(){return this._shell},Yt.prototype.mergeLabel=function(){if(arguments.length===1){var s=arguments[0];this.mergeLabel(s,0),this.mergeLabel(s,1)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=a.getLocation(u,H.RIGHT);if(f===T.NONE)return null;if(this._label.getLocation(u)===T.NONE)return this._label.setLocation(u,f),null}},Yt.prototype.setShell=function(s){this._shell=s,s!==null&&s.addHole(this)},Yt.prototype.toPolygon=function(s){for(var a=new Array(this._holes.size()).fill(null),u=0;u=2,"found partial label"),this.computeIM(s)},En.prototype.isInResult=function(){return this._isInResult},En.prototype.isVisited=function(){return this._isVisited},En.prototype.interfaces_=function(){return[]},En.prototype.getClass=function(){return En};var cg=function(s){function a(){s.call(this),this._coord=null,this._edges=null;var u=arguments[0],f=arguments[1];this._coord=u,this._edges=f,this._label=new rt(0,T.NONE)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isIncidentEdgeInResult=function(){for(var u=this.getEdges().getEdges().iterator();u.hasNext();)if(u.next().getEdge().isInResult())return!0;return!1},a.prototype.isIsolated=function(){return this._label.getGeometryCount()===1},a.prototype.getCoordinate=function(){return this._coord},a.prototype.print=function(u){u.println("node "+this._coord+" lbl: "+this._label)},a.prototype.computeIM=function(u){},a.prototype.computeMergedLocation=function(u,f){var p=T.NONE;if(p=this._label.getLocation(f),!u.isNull(f)){var $=u.getLocation(f);p!==T.BOUNDARY&&(p=$)}return p},a.prototype.setLabel=function(){if(arguments.length!==2)return s.prototype.setLabel.apply(this,arguments);var u=arguments[0],f=arguments[1];this._label===null?this._label=new rt(u,f):this._label.setLocation(u,f)},a.prototype.getEdges=function(){return this._edges},a.prototype.mergeLabel=function(){if(arguments[0]instanceof a){var u=arguments[0];this.mergeLabel(u._label)}else if(arguments[0]instanceof rt)for(var f=arguments[0],p=0;p<2;p++){var $=this.computeMergedLocation(f,p);this._label.getLocation(p)===T.NONE&&this._label.setLocation(p,$)}},a.prototype.add=function(u){this._edges.insert(u),u.setNode(this)},a.prototype.setLabelBoundary=function(u){if(this._label===null)return null;var f=T.NONE;this._label!==null&&(f=this._label.getLocation(u));var p=null;switch(f){case T.BOUNDARY:p=T.INTERIOR;break;case T.INTERIOR:default:p=T.BOUNDARY}this._label.setLocation(u,p)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(En),ii=function(){this.nodeMap=new h,this.nodeFact=null;var s=arguments[0];this.nodeFact=s};ii.prototype.find=function(s){return this.nodeMap.get(s)},ii.prototype.addNode=function(){if(arguments[0]instanceof F){var s=arguments[0],a=this.nodeMap.get(s);return a===null&&(a=this.nodeFact.createNode(s),this.nodeMap.put(s,a)),a}if(arguments[0]instanceof cg){var u=arguments[0],f=this.nodeMap.get(u.getCoordinate());return f===null?(this.nodeMap.put(u.getCoordinate(),u),u):(f.mergeLabel(u),f)}},ii.prototype.print=function(s){for(var a=this.iterator();a.hasNext();)a.next().print(s)},ii.prototype.iterator=function(){return this.nodeMap.values().iterator()},ii.prototype.values=function(){return this.nodeMap.values()},ii.prototype.getBoundaryNodes=function(s){for(var a=new nA,u=this.iterator();u.hasNext();){var f=u.next();f.getLabel().getLocation(s)===T.BOUNDARY&&a.add(f)}return a},ii.prototype.add=function(s){var a=s.getCoordinate();this.addNode(a).add(s)},ii.prototype.interfaces_=function(){return[]},ii.prototype.getClass=function(){return ii};var tj=function(){},oh={NE:{configurable:!0},NW:{configurable:!0},SW:{configurable:!0},SE:{configurable:!0}};tj.prototype.interfaces_=function(){return[]},tj.prototype.getClass=function(){return tj},tj.isNorthern=function(s){return s===tj.NE||s===tj.NW},tj.isOpposite=function(s,a){return s===a?!1:(s-a+4)%4===2},tj.commonHalfPlane=function(s,a){if(s===a)return s;if((s-a+4)%4===2)return-1;var u=sa?s:a)===3?3:u},tj.isInHalfPlane=function(s,a){return a===tj.SE?s===tj.SE||s===tj.SW:s===a||s===a+1},tj.quadrant=function(){if(typeof arguments[0]=="number"&&typeof arguments[1]=="number"){var s=arguments[0],a=arguments[1];if(s===0&&a===0)throw new b("Cannot compute the quadrant for point ( "+s+", "+a+" )");return s>=0?a>=0?tj.NE:tj.SE:a>=0?tj.NW:tj.SW}if(arguments[0]instanceof F&&arguments[1]instanceof F){var u=arguments[0],f=arguments[1];if(f.x===u.x&&f.y===u.y)throw new b("Cannot compute the quadrant for two identical points "+u);return f.x>=u.x?f.y>=u.y?tj.NE:tj.SE:f.y>=u.y?tj.NW:tj.SW}},oh.NE.get=function(){return 0},oh.NW.get=function(){return 1},oh.SW.get=function(){return 2},oh.SE.get=function(){return 3},Object.defineProperties(tj,oh);var Ve=function(){if(this._edge=null,this._label=null,this._node=null,this._p0=null,this._p1=null,this._dx=null,this._dy=null,this._quadrant=null,arguments.length===1){var s=arguments[0];this._edge=s}else if(arguments.length===3){var a=arguments[0],u=arguments[1],f=arguments[2];this._edge=a,this.init(u,f),this._label=null}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];this._edge=p,this.init($,q),this._label=M}};Ve.prototype.compareDirection=function(s){return this._dx===s._dx&&this._dy===s._dy?0:this._quadrant>s._quadrant?1:this._quadrant2){$.linkDirectedEdgesForMinimalEdgeRings();var q=$.buildMinimalRings(),M=this.findShell(q);M!==null?(this.placePolygonHoles(M,q),a.add(M)):u.addAll(q)}else f.add($)}return f},Jr.prototype.containsPoint=function(s){for(var a=this._shellList.iterator();a.hasNext();)if(a.next().containsPoint(s))return!0;return!1},Jr.prototype.buildMaximalEdgeRings=function(s){for(var a=new nA,u=s.iterator();u.hasNext();){var f=u.next();if(f.isInResult()&&f.getLabel().isArea()&&f.getEdgeRing()===null){var p=new r9(f,this._geometryFactory);a.add(p),p.setInResult()}}return a},Jr.prototype.placePolygonHoles=function(s,a){for(var u=a.iterator();u.hasNext();){var f=u.next();f.isHole()&&f.setShell(s)}},Jr.prototype.getPolygons=function(){return this.computePolygons(this._shellList)},Jr.prototype.findEdgeRingContaining=function(s,a){for(var u=s.getLinearRing(),f=u.getEnvelopeInternal(),p=u.getCoordinateN(0),$=null,q=null,M=a.iterator();M.hasNext();){var C=M.next(),Q=C.getLinearRing(),oA=Q.getEnvelopeInternal();$!==null&&(q=$.getLinearRing().getEnvelopeInternal());var cA=!1;oA.contains(f)&&EA.isPointInRing(p,Q.getCoordinates())&&(cA=!0),cA&&($===null||q.contains(oA))&&($=C)}return $},Jr.prototype.findShell=function(s){for(var a=0,u=null,f=s.iterator();f.hasNext();){var p=f.next();p.isHole()||(u=p,a++)}return KA.isTrue(a<=1,"found two shells in MinimalEdgeRing list"),u},Jr.prototype.add=function(){if(arguments.length===1){var s=arguments[0];this.add(s.getEdgeEnds(),s.getNodes())}else if(arguments.length===2){var a=arguments[0],u=arguments[1];Gj.linkResultDirectedEdges(u);var f=this.buildMaximalEdgeRings(a),p=new nA,$=this.buildMinimalEdgeRings(f,this._shellList,p);this.sortShellsAndHoles($,this._shellList,p),this.placeFreeHoles(this._shellList,p)}},Jr.prototype.interfaces_=function(){return[]},Jr.prototype.getClass=function(){return Jr};var uu=function(){};uu.prototype.getBounds=function(){},uu.prototype.interfaces_=function(){return[]},uu.prototype.getClass=function(){return uu};var O6=function(){this._bounds=null,this._item=null;var s=arguments[0],a=arguments[1];this._bounds=s,this._item=a};O6.prototype.getItem=function(){return this._item},O6.prototype.getBounds=function(){return this._bounds},O6.prototype.interfaces_=function(){return[uu,A]},O6.prototype.getClass=function(){return O6};var To=function(){this._size=null,this._items=null,this._size=0,this._items=new nA,this._items.add(null)};To.prototype.poll=function(){if(this.isEmpty())return null;var s=this._items.get(1);return this._items.set(1,this._items.get(this._size)),this._size-=1,this.reorder(1),s},To.prototype.size=function(){return this._size},To.prototype.reorder=function(s){for(var a=null,u=this._items.get(s);2*s<=this._size&&((a=2*s)!==this._size&&this._items.get(a+1).compareTo(this._items.get(a))<0&&a++,this._items.get(a).compareTo(u)<0);s=a)this._items.set(s,this._items.get(a));this._items.set(s,u)},To.prototype.clear=function(){this._size=0,this._items.clear()},To.prototype.isEmpty=function(){return this._size===0},To.prototype.add=function(s){this._items.add(null),this._size+=1;var a=this._size;for(this._items.set(0,s);s.compareTo(this._items.get(Math.trunc(a/2)))<0;a/=2)this._items.set(a,this._items.get(Math.trunc(a/2)));this._items.set(a,s)},To.prototype.interfaces_=function(){return[]},To.prototype.getClass=function(){return To};var Rs=function(){};Rs.prototype.visitItem=function(s){},Rs.prototype.interfaces_=function(){return[]},Rs.prototype.getClass=function(){return Rs};var ql=function(){};ql.prototype.insert=function(s,a){},ql.prototype.remove=function(s,a){},ql.prototype.query=function(){},ql.prototype.interfaces_=function(){return[]},ql.prototype.getClass=function(){return ql};var je=function(){if(this._childBoundables=new nA,this._bounds=null,this._level=null,arguments.length!==0){if(arguments.length===1){var s=arguments[0];this._level=s}}},t8={serialVersionUID:{configurable:!0}};je.prototype.getLevel=function(){return this._level},je.prototype.size=function(){return this._childBoundables.size()},je.prototype.getChildBoundables=function(){return this._childBoundables},je.prototype.addChildBoundable=function(s){KA.isTrue(this._bounds===null),this._childBoundables.add(s)},je.prototype.isEmpty=function(){return this._childBoundables.isEmpty()},je.prototype.getBounds=function(){return this._bounds===null&&(this._bounds=this.computeBounds()),this._bounds},je.prototype.interfaces_=function(){return[uu,A]},je.prototype.getClass=function(){return je},t8.serialVersionUID.get=function(){return 6493722185909574e3},Object.defineProperties(je,t8);var T6=function(){};T6.reverseOrder=function(){return{compare:function(s,a){return a.compareTo(s)}}},T6.min=function(s){return T6.sort(s),s.get(0)},T6.sort=function(s,a){var u=s.toArray();a?vj.sort(u,a):vj.sort(u);for(var f=s.iterator(),p=0,$=u.length;p<$;p++)f.next(),f.set(u[p])},T6.singletonList=function(s){var a=new nA;return a.add(s),a};var Qj=function(){this._boundable1=null,this._boundable2=null,this._distance=null,this._itemDistance=null;var s=arguments[0],a=arguments[1],u=arguments[2];this._boundable1=s,this._boundable2=a,this._itemDistance=u,this._distance=this.distance()};Qj.prototype.expandToQueue=function(s,a){var u=Qj.isComposite(this._boundable1),f=Qj.isComposite(this._boundable2);if(u&&f)return Qj.area(this._boundable1)>Qj.area(this._boundable2)?(this.expand(this._boundable1,this._boundable2,s,a),null):(this.expand(this._boundable2,this._boundable1,s,a),null);if(u)return this.expand(this._boundable1,this._boundable2,s,a),null;if(f)return this.expand(this._boundable2,this._boundable1,s,a),null;throw new b("neither boundable is composite")},Qj.prototype.isLeaves=function(){return!(Qj.isComposite(this._boundable1)||Qj.isComposite(this._boundable2))},Qj.prototype.compareTo=function(s){var a=s;return this._distancea._distance?1:0},Qj.prototype.expand=function(s,a,u,f){for(var p=s.getChildBoundables().iterator();p.hasNext();){var $=p.next(),q=new Qj($,a,this._itemDistance);q.getDistance()1,"Node capacity must be greater than 1"),this._nodeCapacity=u}},ug={IntersectsOp:{configurable:!0},serialVersionUID:{configurable:!0},DEFAULT_NODE_CAPACITY:{configurable:!0}};ye.prototype.getNodeCapacity=function(){return this._nodeCapacity},ye.prototype.lastNode=function(s){return s.get(s.size()-1)},ye.prototype.size=function(){if(arguments.length===0)return this.isEmpty()?0:(this.build(),this.size(this._root));if(arguments.length===1){for(var s=0,a=arguments[0].getChildBoundables().iterator();a.hasNext();){var u=a.next();u instanceof je?s+=this.size(u):u instanceof O6&&(s+=1)}return s}},ye.prototype.removeItem=function(s,a){for(var u=null,f=s.getChildBoundables().iterator();f.hasNext();){var p=f.next();p instanceof O6&&p.getItem()===a&&(u=p)}return u!==null&&(s.getChildBoundables().remove(u),!0)},ye.prototype.itemsTree=function(){if(arguments.length===0){this.build();var s=this.itemsTree(this._root);return s===null?new nA:s}if(arguments.length===1){for(var a=arguments[0],u=new nA,f=a.getChildBoundables().iterator();f.hasNext();){var p=f.next();if(p instanceof je){var $=this.itemsTree(p);$!==null&&u.add($)}else p instanceof O6?u.add(p.getItem()):KA.shouldNeverReachHere()}return u.size()<=0?null:u}},ye.prototype.insert=function(s,a){KA.isTrue(!this._built,"Cannot insert items into an STR packed R-tree after it has been built."),this._itemBoundables.add(new O6(s,a))},ye.prototype.boundablesAtLevel=function(){if(arguments.length===1){var s=arguments[0],a=new nA;return this.boundablesAtLevel(s,this._root,a),a}if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2];if(KA.isTrue(u>-2),f.getLevel()===u)return p.add(f),null;for(var $=f.getChildBoundables().iterator();$.hasNext();){var q=$.next();q instanceof je?this.boundablesAtLevel(u,q,p):(KA.isTrue(q instanceof O6),u===-1&&p.add(q))}return null}},ye.prototype.query=function(){if(arguments.length===1){var s=arguments[0];this.build();var a=new nA;return this.isEmpty()||this.getIntersectsOp().intersects(this._root.getBounds(),s)&&this.query(s,this._root,a),a}if(arguments.length===2){var u=arguments[0],f=arguments[1];if(this.build(),this.isEmpty())return null;this.getIntersectsOp().intersects(this._root.getBounds(),u)&&this.query(u,this._root,f)}else if(arguments.length===3){if(G(arguments[2],Rs)&&arguments[0]instanceof Object&&arguments[1]instanceof je)for(var p=arguments[0],$=arguments[1],q=arguments[2],M=$.getChildBoundables(),C=0;Cs&&(s=f)}}return s+1}},ye.prototype.createParentBoundables=function(s,a){KA.isTrue(!s.isEmpty());var u=new nA;u.add(this.createNode(a));var f=new nA(s);T6.sort(f,this.getComparator());for(var p=f.iterator();p.hasNext();){var $=p.next();this.lastNode(u).getChildBoundables().size()===this.getNodeCapacity()&&u.add(this.createNode(a)),this.lastNode(u).addChildBoundable($)}return u},ye.prototype.isEmpty=function(){return this._built?this._root.isEmpty():this._itemBoundables.isEmpty()},ye.prototype.interfaces_=function(){return[A]},ye.prototype.getClass=function(){return ye},ye.compareDoubles=function(s,a){return s>a?1:s0);for(var $=new nA,q=0;q0;){var vA=yA.poll(),IA=vA.getDistance();if(IA>=oA)break;vA.isLeaves()?(oA=IA,cA=vA):vA.expandToQueue(yA,oA)}return[cA.getBoundable(0).getItem(),cA.getBoundable(1).getItem()]}}else if(arguments.length===3){var DA=arguments[0],Jt=arguments[1],Yj=arguments[2],Br=new O6(DA,Jt),Ni=new Qj(this.getRoot(),Br,Yj);return this.nearestNeighbour(Ni)[0]}},a.prototype.interfaces_=function(){return[ql,A]},a.prototype.getClass=function(){return a},a.centreX=function(f){return a.avg(f.getMinX(),f.getMaxX())},a.avg=function(f,p){return(f+p)/2},a.centreY=function(f){return a.avg(f.getMinY(),f.getMaxY())},u.STRtreeNode.get=function(){return e8},u.serialVersionUID.get=function(){return 0x39920f7d5f261e0},u.xComparator.get=function(){return{interfaces_:function(){return[S]},compare:function(f,p){return s.compareDoubles(a.centreX(f.getBounds()),a.centreX(p.getBounds()))}}},u.yComparator.get=function(){return{interfaces_:function(){return[S]},compare:function(f,p){return s.compareDoubles(a.centreY(f.getBounds()),a.centreY(p.getBounds()))}}},u.intersectsOp.get=function(){return{interfaces_:function(){return[s.IntersectsOp]},intersects:function(f,p){return f.intersects(p)}}},u.DEFAULT_NODE_CAPACITY.get=function(){return 10},Object.defineProperties(a,u),a}(ye),e8=function(s){function a(){var u=arguments[0];s.call(this,u)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.computeBounds=function(){for(var u=null,f=this.getChildBoundables().iterator();f.hasNext();){var p=f.next();u===null?u=new bA(p.getBounds()):u.expandToInclude(p.getBounds())}return u},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(je),wr=function(){};wr.prototype.interfaces_=function(){return[]},wr.prototype.getClass=function(){return wr},wr.relativeSign=function(s,a){return sa?1:0},wr.compare=function(s,a,u){if(a.equals2D(u))return 0;var f=wr.relativeSign(a.x,u.x),p=wr.relativeSign(a.y,u.y);switch(s){case 0:return wr.compareValue(f,p);case 1:return wr.compareValue(p,f);case 2:return wr.compareValue(p,-f);case 3:return wr.compareValue(-f,p);case 4:return wr.compareValue(-f,-p);case 5:return wr.compareValue(-p,-f);case 6:return wr.compareValue(-p,f);case 7:return wr.compareValue(f,-p)}return KA.shouldNeverReachHere("invalid octant value"),0},wr.compareValue=function(s,a){return s<0?-1:s>0?1:a<0?-1:a>0?1:0};var Ls=function(){this._segString=null,this.coord=null,this.segmentIndex=null,this._segmentOctant=null,this._isInterior=null;var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];this._segString=s,this.coord=new F(a),this.segmentIndex=u,this._segmentOctant=f,this._isInterior=!a.equals2D(s.getCoordinate(u))};Ls.prototype.getCoordinate=function(){return this.coord},Ls.prototype.print=function(s){s.print(this.coord),s.print(" seg # = "+this.segmentIndex)},Ls.prototype.compareTo=function(s){var a=s;return this.segmentIndexa.segmentIndex?1:this.coord.equals2D(a.coord)?0:wr.compare(this._segmentOctant,this.coord,a.coord)},Ls.prototype.isEndPoint=function(s){return this.segmentIndex===0&&!this._isInterior||this.segmentIndex===s},Ls.prototype.isInterior=function(){return this._isInterior},Ls.prototype.interfaces_=function(){return[w]},Ls.prototype.getClass=function(){return Ls};var or=function(){this._nodeMap=new h,this._edge=null;var s=arguments[0];this._edge=s};or.prototype.getSplitCoordinates=function(){var s=new kA;this.addEndpoints();for(var a=this.iterator(),u=a.next();a.hasNext();){var f=a.next();this.addEdgeCoordinates(u,f,s),u=f}return s.toCoordinateArray()},or.prototype.addCollapsedNodes=function(){var s=new nA;this.findCollapsesFromInsertedNodes(s),this.findCollapsesFromExistingVertices(s);for(var a=s.iterator();a.hasNext();){var u=a.next().intValue();this.add(this._edge.getCoordinate(u),u)}},or.prototype.print=function(s){s.println("Intersections:");for(var a=this.iterator();a.hasNext();)a.next().print(s)},or.prototype.findCollapsesFromExistingVertices=function(s){for(var a=0;a=0?a>=0?u>=f?0:1:u>=f?7:6:a>=0?u>=f?3:2:u>=f?4:5}if(arguments[0]instanceof F&&arguments[1]instanceof F){var p=arguments[0],$=arguments[1],q=$.x-p.x,M=$.y-p.y;if(q===0&&M===0)throw new b("Cannot compute the octant for two identical points "+p);return Gl.octant(q,M)}};var Oi=function(){};Oi.prototype.getCoordinates=function(){},Oi.prototype.size=function(){},Oi.prototype.getCoordinate=function(s){},Oi.prototype.isClosed=function(){},Oi.prototype.setData=function(s){},Oi.prototype.getData=function(){},Oi.prototype.interfaces_=function(){return[]},Oi.prototype.getClass=function(){return Oi};var sh=function(){};sh.prototype.addIntersection=function(s,a){},sh.prototype.interfaces_=function(){return[Oi]},sh.prototype.getClass=function(){return sh};var Hj=function(){this._nodeList=new or(this),this._pts=null,this._data=null;var s=arguments[0],a=arguments[1];this._pts=s,this._data=a};Hj.prototype.getCoordinates=function(){return this._pts},Hj.prototype.size=function(){return this._pts.length},Hj.prototype.getCoordinate=function(s){return this._pts[s]},Hj.prototype.isClosed=function(){return this._pts[0].equals(this._pts[this._pts.length-1])},Hj.prototype.getSegmentOctant=function(s){return s===this._pts.length-1?-1:this.safeOctant(this.getCoordinate(s),this.getCoordinate(s+1))},Hj.prototype.setData=function(s){this._data=s},Hj.prototype.safeOctant=function(s,a){return s.equals2D(a)?0:Gl.octant(s,a)},Hj.prototype.getData=function(){return this._data},Hj.prototype.addIntersection=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];this.addIntersectionNode(s,a)}else if(arguments.length===4){var u=arguments[0],f=arguments[1],p=arguments[3],$=new F(u.getIntersection(p));this.addIntersection($,f)}},Hj.prototype.toString=function(){return cj.toLineString(new fj(this._pts))},Hj.prototype.getNodeList=function(){return this._nodeList},Hj.prototype.addIntersectionNode=function(s,a){var u=a,f=u+1;if(f=0&&u>=0||a<=0&&u<=0?Math.max(a,u):0}if(arguments[0]instanceof F){var f=arguments[0];return EA.orientationIndex(this.p0,this.p1,f)}},CA.prototype.toGeometry=function(s){return s.createLineString([this.p0,this.p1])},CA.prototype.isVertical=function(){return this.p0.x===this.p1.x},CA.prototype.equals=function(s){if(!(s instanceof CA))return!1;var a=s;return this.p0.equals(a.p0)&&this.p1.equals(a.p1)},CA.prototype.intersection=function(s){var a=new PA;return a.computeIntersection(this.p0,this.p1,s.p0,s.p1),a.hasIntersection()?a.getIntersection(0):null},CA.prototype.project=function(){if(arguments[0]instanceof F){var s=arguments[0];if(s.equals(this.p0)||s.equals(this.p1))return new F(s);var a=this.projectionFactor(s),u=new F;return u.x=this.p0.x+a*(this.p1.x-this.p0.x),u.y=this.p0.y+a*(this.p1.y-this.p0.y),u}if(arguments[0]instanceof CA){var f=arguments[0],p=this.projectionFactor(f.p0),$=this.projectionFactor(f.p1);if(p>=1&&$>=1||p<=0&&$<=0)return null;var q=this.project(f.p0);p<0&&(q=this.p0),p>1&&(q=this.p1);var M=this.project(f.p1);return $<0&&(M=this.p0),$>1&&(M=this.p1),new CA(q,M)}},CA.prototype.normalize=function(){this.p1.compareTo(this.p0)<0&&this.reverse()},CA.prototype.angle=function(){return Math.atan2(this.p1.y-this.p0.y,this.p1.x-this.p0.x)},CA.prototype.getCoordinate=function(s){return s===0?this.p0:this.p1},CA.prototype.distancePerpendicular=function(s){return EA.distancePointLinePerpendicular(s,this.p0,this.p1)},CA.prototype.minY=function(){return Math.min(this.p0.y,this.p1.y)},CA.prototype.midPoint=function(){return CA.midPoint(this.p0,this.p1)},CA.prototype.projectionFactor=function(s){if(s.equals(this.p0))return 0;if(s.equals(this.p1))return 1;var a=this.p1.x-this.p0.x,u=this.p1.y-this.p0.y,f=a*a+u*u;return f<=0?v.NaN:((s.x-this.p0.x)*a+(s.y-this.p0.y)*u)/f},CA.prototype.closestPoints=function(s){var a=this.intersection(s);if(a!==null)return[a,a];var u=new Array(2).fill(null),f=v.MAX_VALUE,p=null,$=this.closestPoint(s.p0);f=$.distance(s.p0),u[0]=$,u[1]=s.p0;var q=this.closestPoint(s.p1);(p=q.distance(s.p1))0&&a<1?this.project(s):this.p0.distance(s)1||v.isNaN(a))&&(a=1),a},CA.prototype.toString=function(){return"LINESTRING( "+this.p0.x+" "+this.p0.y+", "+this.p1.x+" "+this.p1.y+")"},CA.prototype.isHorizontal=function(){return this.p0.y===this.p1.y},CA.prototype.distance=function(){if(arguments[0]instanceof CA){var s=arguments[0];return EA.distanceLineLine(this.p0,this.p1,s.p0,s.p1)}if(arguments[0]instanceof F){var a=arguments[0];return EA.distancePointLine(a,this.p0,this.p1)}},CA.prototype.pointAlong=function(s){var a=new F;return a.x=this.p0.x+s*(this.p1.x-this.p0.x),a.y=this.p0.y+s*(this.p1.y-this.p0.y),a},CA.prototype.hashCode=function(){var s=v.doubleToLongBits(this.p0.x);s^=31*v.doubleToLongBits(this.p0.y);var a=Math.trunc(s)^Math.trunc(s>>32),u=v.doubleToLongBits(this.p1.x);return u^=31*v.doubleToLongBits(this.p1.y),a^(Math.trunc(u)^Math.trunc(u>>32))},CA.prototype.interfaces_=function(){return[w,A]},CA.prototype.getClass=function(){return CA},CA.midPoint=function(s,a){return new F((s.x+a.x)/2,(s.y+a.y)/2)},r8.serialVersionUID.get=function(){return 0x2d2172135f411c00},Object.defineProperties(CA,r8);var ah=function(){this.tempEnv1=new bA,this.tempEnv2=new bA,this._overlapSeg1=new CA,this._overlapSeg2=new CA};ah.prototype.overlap=function(){if(arguments.length!==2){if(arguments.length===4){var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];s.getLineSegment(a,this._overlapSeg1),u.getLineSegment(f,this._overlapSeg2),this.overlap(this._overlapSeg1,this._overlapSeg2)}}},ah.prototype.interfaces_=function(){return[]},ah.prototype.getClass=function(){return ah};var Zr=function(){this._pts=null,this._start=null,this._end=null,this._env=null,this._context=null,this._id=null;var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];this._pts=s,this._start=a,this._end=u,this._context=f};Zr.prototype.getLineSegment=function(s,a){a.p0=this._pts[s],a.p1=this._pts[s+1]},Zr.prototype.computeSelect=function(s,a,u,f){var p=this._pts[a],$=this._pts[u];if(f.tempEnv1.init(p,$),u-a==1)return f.select(this,a),null;if(!s.intersects(f.tempEnv1))return null;var q=Math.trunc((a+u)/2);a=s.length-1)return s.length-1;for(var f=tj.quadrant(s[u],s[u+1]),p=a+1;p$.getId()&&($.computeOverlaps(M,f),this._nOverlaps++),this._segInt.isDone())return null}},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},u.SegmentOverlapAction.get=function(){return n8},Object.defineProperties(a,u),a}(lh),n8=function(s){function a(){s.call(this),this._si=null;var u=arguments[0];this._si=u}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.overlap=function(){if(arguments.length!==4)return s.prototype.overlap.apply(this,arguments);var u=arguments[0],f=arguments[1],p=arguments[2],$=arguments[3],q=u.getContext(),M=p.getContext();this._si.processIntersections(q,f,M,$)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(ah),zt=function s(){if(this._quadrantSegments=s.DEFAULT_QUADRANT_SEGMENTS,this._endCapStyle=s.CAP_ROUND,this._joinStyle=s.JOIN_ROUND,this._mitreLimit=s.DEFAULT_MITRE_LIMIT,this._isSingleSided=!1,this._simplifyFactor=s.DEFAULT_SIMPLIFY_FACTOR,arguments.length!==0){if(arguments.length===1){var a=arguments[0];this.setQuadrantSegments(a)}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.setQuadrantSegments(u),this.setEndCapStyle(f)}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];this.setQuadrantSegments(p),this.setEndCapStyle($),this.setJoinStyle(q),this.setMitreLimit(M)}}},So={CAP_ROUND:{configurable:!0},CAP_FLAT:{configurable:!0},CAP_SQUARE:{configurable:!0},JOIN_ROUND:{configurable:!0},JOIN_MITRE:{configurable:!0},JOIN_BEVEL:{configurable:!0},DEFAULT_QUADRANT_SEGMENTS:{configurable:!0},DEFAULT_MITRE_LIMIT:{configurable:!0},DEFAULT_SIMPLIFY_FACTOR:{configurable:!0}};zt.prototype.getEndCapStyle=function(){return this._endCapStyle},zt.prototype.isSingleSided=function(){return this._isSingleSided},zt.prototype.setQuadrantSegments=function(s){this._quadrantSegments=s,this._quadrantSegments===0&&(this._joinStyle=zt.JOIN_BEVEL),this._quadrantSegments<0&&(this._joinStyle=zt.JOIN_MITRE,this._mitreLimit=Math.abs(this._quadrantSegments)),s<=0&&(this._quadrantSegments=1),this._joinStyle!==zt.JOIN_ROUND&&(this._quadrantSegments=zt.DEFAULT_QUADRANT_SEGMENTS)},zt.prototype.getJoinStyle=function(){return this._joinStyle},zt.prototype.setJoinStyle=function(s){this._joinStyle=s},zt.prototype.setSimplifyFactor=function(s){this._simplifyFactor=s<0?0:s},zt.prototype.getSimplifyFactor=function(){return this._simplifyFactor},zt.prototype.getQuadrantSegments=function(){return this._quadrantSegments},zt.prototype.setEndCapStyle=function(s){this._endCapStyle=s},zt.prototype.getMitreLimit=function(){return this._mitreLimit},zt.prototype.setMitreLimit=function(s){this._mitreLimit=s},zt.prototype.setSingleSided=function(s){this._isSingleSided=s},zt.prototype.interfaces_=function(){return[]},zt.prototype.getClass=function(){return zt},zt.bufferDistanceError=function(s){var a=Math.PI/2/s;return 1-Math.cos(a/2)},So.CAP_ROUND.get=function(){return 1},So.CAP_FLAT.get=function(){return 2},So.CAP_SQUARE.get=function(){return 3},So.JOIN_ROUND.get=function(){return 1},So.JOIN_MITRE.get=function(){return 2},So.JOIN_BEVEL.get=function(){return 3},So.DEFAULT_QUADRANT_SEGMENTS.get=function(){return 8},So.DEFAULT_MITRE_LIMIT.get=function(){return 5},So.DEFAULT_SIMPLIFY_FACTOR.get=function(){return .01},Object.defineProperties(zt,So);var Mj=function(s){this._distanceTol=null,this._isDeleted=null,this._angleOrientation=EA.COUNTERCLOCKWISE,this._inputLine=s||null},ch={INIT:{configurable:!0},DELETE:{configurable:!0},KEEP:{configurable:!0},NUM_PTS_TO_CHECK:{configurable:!0}};Mj.prototype.isDeletable=function(s,a,u,f){var p=this._inputLine[s],$=this._inputLine[a],q=this._inputLine[u];return!!this.isConcave(p,$,q)&&!!this.isShallow(p,$,q,f)&&this.isShallowSampled(p,$,s,u,f)},Mj.prototype.deleteShallowConcavities=function(){for(var s=1,a=this.findNextNonDeletedIndex(s),u=this.findNextNonDeletedIndex(a),f=!1;u=0;f--)this.addPt(s[f])},$n.prototype.isRedundant=function(s){if(this._ptList.size()<1)return!1;var a=this._ptList.get(this._ptList.size()-1);return s.distance(a)Math.PI;)s-=It.PI_TIMES_2;for(;s<=-Math.PI;)s+=It.PI_TIMES_2;return s},It.angle=function(){if(arguments.length===1){var s=arguments[0];return Math.atan2(s.y,s.x)}if(arguments.length===2){var a=arguments[0],u=arguments[1],f=u.x-a.x,p=u.y-a.y;return Math.atan2(p,f)}},It.isAcute=function(s,a,u){var f=s.x-a.x,p=s.y-a.y;return f*(u.x-a.x)+p*(u.y-a.y)>0},It.isObtuse=function(s,a,u){var f=s.x-a.x,p=s.y-a.y;return f*(u.x-a.x)+p*(u.y-a.y)<0},It.interiorAngle=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u);return Math.abs(p-f)},It.normalizePositive=function(s){if(s<0){for(;s<0;)s+=It.PI_TIMES_2;s>=It.PI_TIMES_2&&(s=0)}else{for(;s>=It.PI_TIMES_2;)s-=It.PI_TIMES_2;s<0&&(s=0)}return s},It.angleBetween=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u);return It.diff(f,p)},It.diff=function(s,a){var u=null;return(u=sMath.PI&&(u=2*Math.PI-u),u},It.toRadians=function(s){return s*Math.PI/180},It.getTurn=function(s,a){var u=Math.sin(a-s);return u>0?It.COUNTERCLOCKWISE:u<0?It.CLOCKWISE:It.NONE},It.angleBetweenOriented=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u)-f;return p<=-Math.PI?p+It.PI_TIMES_2:p>Math.PI?p-It.PI_TIMES_2:p},bl.PI_TIMES_2.get=function(){return 2*Math.PI},bl.PI_OVER_2.get=function(){return Math.PI/2},bl.PI_OVER_4.get=function(){return Math.PI/4},bl.COUNTERCLOCKWISE.get=function(){return EA.COUNTERCLOCKWISE},bl.CLOCKWISE.get=function(){return EA.CLOCKWISE},bl.NONE.get=function(){return EA.COLLINEAR},Object.defineProperties(It,bl);var pj=function s(){this._maxCurveSegmentError=0,this._filletAngleQuantum=null,this._closingSegLengthFactor=1,this._segList=null,this._distance=0,this._precisionModel=null,this._bufParams=null,this._li=null,this._s0=null,this._s1=null,this._s2=null,this._seg0=new CA,this._seg1=new CA,this._offset0=new CA,this._offset1=new CA,this._side=0,this._hasNarrowConcaveAngle=!1;var a=arguments[0],u=arguments[1],f=arguments[2];this._precisionModel=a,this._bufParams=u,this._li=new PA,this._filletAngleQuantum=Math.PI/2/u.getQuadrantSegments(),u.getQuadrantSegments()>=8&&u.getJoinStyle()===zt.JOIN_ROUND&&(this._closingSegLengthFactor=s.MAX_CLOSING_SEG_LEN_FACTOR),this.init(f)},uh={OFFSET_SEGMENT_SEPARATION_FACTOR:{configurable:!0},INSIDE_TURN_VERTEX_SNAP_DISTANCE_FACTOR:{configurable:!0},CURVE_VERTEX_SNAP_DISTANCE_FACTOR:{configurable:!0},MAX_CLOSING_SEG_LEN_FACTOR:{configurable:!0}};pj.prototype.addNextSegment=function(s,a){if(this._s0=this._s1,this._s1=this._s2,this._s2=s,this._seg0.setCoordinates(this._s0,this._s1),this.computeOffsetSegment(this._seg0,this._side,this._distance,this._offset0),this._seg1.setCoordinates(this._s1,this._s2),this.computeOffsetSegment(this._seg1,this._side,this._distance,this._offset1),this._s1.equals(this._s2))return null;var u=EA.computeOrientation(this._s0,this._s1,this._s2),f=u===EA.CLOCKWISE&&this._side===H.LEFT||u===EA.COUNTERCLOCKWISE&&this._side===H.RIGHT;u===0?this.addCollinear(a):f?this.addOutsideTurn(u,a):this.addInsideTurn(u,a)},pj.prototype.addLineEndCap=function(s,a){var u=new CA(s,a),f=new CA;this.computeOffsetSegment(u,H.LEFT,this._distance,f);var p=new CA;this.computeOffsetSegment(u,H.RIGHT,this._distance,p);var $=a.x-s.x,q=a.y-s.y,M=Math.atan2(q,$);switch(this._bufParams.getEndCapStyle()){case zt.CAP_ROUND:this._segList.addPt(f.p1),this.addFilletArc(a,M+Math.PI/2,M-Math.PI/2,EA.CLOCKWISE,this._distance),this._segList.addPt(p.p1);break;case zt.CAP_FLAT:this._segList.addPt(f.p1),this._segList.addPt(p.p1);break;case zt.CAP_SQUARE:var C=new F;C.x=Math.abs(this._distance)*Math.cos(M),C.y=Math.abs(this._distance)*Math.sin(M);var Q=new F(f.p1.x+C.x,f.p1.y+C.y),oA=new F(p.p1.x+C.x,p.p1.y+C.y);this._segList.addPt(Q),this._segList.addPt(oA)}},pj.prototype.getCoordinates=function(){return this._segList.getCoordinates()},pj.prototype.addMitreJoin=function(s,a,u,f){var p=!0,$=null;try{$=Ht.intersection(a.p0,a.p1,u.p0,u.p1),(f<=0?1:$.distance(s)/Math.abs(f))>this._bufParams.getMitreLimit()&&(p=!1)}catch(q){if(!(q instanceof _t))throw q;$=new F(0,0),p=!1}p?this._segList.addPt($):this.addLimitedMitreJoin(a,u,f,this._bufParams.getMitreLimit())},pj.prototype.addFilletCorner=function(s,a,u,f,p){var $=a.x-s.x,q=a.y-s.y,M=Math.atan2(q,$),C=u.x-s.x,Q=u.y-s.y,oA=Math.atan2(Q,C);f===EA.CLOCKWISE?M<=oA&&(M+=2*Math.PI):M>=oA&&(M-=2*Math.PI),this._segList.addPt(a),this.addFilletArc(s,M,oA,f,p),this._segList.addPt(u)},pj.prototype.addOutsideTurn=function(s,a){if(this._offset0.p1.distance(this._offset1.p0)0){var u=new F((this._closingSegLengthFactor*this._offset0.p1.x+this._s1.x)/(this._closingSegLengthFactor+1),(this._closingSegLengthFactor*this._offset0.p1.y+this._s1.y)/(this._closingSegLengthFactor+1));this._segList.addPt(u);var f=new F((this._closingSegLengthFactor*this._offset1.p0.x+this._s1.x)/(this._closingSegLengthFactor+1),(this._closingSegLengthFactor*this._offset1.p0.y+this._s1.y)/(this._closingSegLengthFactor+1));this._segList.addPt(f)}else this._segList.addPt(this._s1);this._segList.addPt(this._offset1.p0)}},pj.prototype.createCircle=function(s){var a=new F(s.x+this._distance,s.y);this._segList.addPt(a),this.addFilletArc(s,0,2*Math.PI,-1,this._distance),this._segList.closeRing()},pj.prototype.addBevelJoin=function(s,a){this._segList.addPt(s.p1),this._segList.addPt(a.p0)},pj.prototype.init=function(s){this._distance=s,this._maxCurveSegmentError=s*(1-Math.cos(this._filletAngleQuantum/2)),this._segList=new $n,this._segList.setPrecisionModel(this._precisionModel),this._segList.setMinimumVertexDistance(s*pj.CURVE_VERTEX_SNAP_DISTANCE_FACTOR)},pj.prototype.addCollinear=function(s){this._li.computeIntersection(this._s0,this._s1,this._s1,this._s2),this._li.getIntersectionNum()>=2&&(this._bufParams.getJoinStyle()===zt.JOIN_BEVEL||this._bufParams.getJoinStyle()===zt.JOIN_MITRE?(s&&this._segList.addPt(this._offset0.p1),this._segList.addPt(this._offset1.p0)):this.addFilletCorner(this._s1,this._offset0.p1,this._offset1.p0,EA.CLOCKWISE,this._distance))},pj.prototype.closeRing=function(){this._segList.closeRing()},pj.prototype.hasNarrowConcaveAngle=function(){return this._hasNarrowConcaveAngle},pj.prototype.interfaces_=function(){return[]},pj.prototype.getClass=function(){return pj},uh.OFFSET_SEGMENT_SEPARATION_FACTOR.get=function(){return .001},uh.INSIDE_TURN_VERTEX_SNAP_DISTANCE_FACTOR.get=function(){return .001},uh.CURVE_VERTEX_SNAP_DISTANCE_FACTOR.get=function(){return 1e-6},uh.MAX_CLOSING_SEG_LEN_FACTOR.get=function(){return 80},Object.defineProperties(pj,uh);var Fr=function(){this._distance=0,this._precisionModel=null,this._bufParams=null;var s=arguments[0],a=arguments[1];this._precisionModel=s,this._bufParams=a};Fr.prototype.getOffsetCurve=function(s,a){if(this._distance=a,a===0)return null;var u=a<0,f=Math.abs(a),p=this.getSegGen(f);s.length<=1?this.computePointCurve(s[0],p):this.computeOffsetCurve(s,u,p);var $=p.getCoordinates();return u&&BA.reverse($),$},Fr.prototype.computeSingleSidedBufferCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);if(a){u.addSegments(s,!0);var p=Mj.simplify(s,-f),$=p.length-1;u.initSideSegments(p[$],p[$-1],H.LEFT),u.addFirstSegment();for(var q=$-2;q>=0;q--)u.addNextSegment(p[q],!0)}else{u.addSegments(s,!1);var M=Mj.simplify(s,f),C=M.length-1;u.initSideSegments(M[0],M[1],H.LEFT),u.addFirstSegment();for(var Q=2;Q<=C;Q++)u.addNextSegment(M[Q],!0)}u.addLastSegment(),u.closeRing()},Fr.prototype.computeRingBufferCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);a===H.RIGHT&&(f=-f);var p=Mj.simplify(s,f),$=p.length-1;u.initSideSegments(p[$-1],p[0],a);for(var q=1;q<=$;q++){var M=q!==1;u.addNextSegment(p[q],M)}u.closeRing()},Fr.prototype.computeLineBufferCurve=function(s,a){var u=this.simplifyTolerance(this._distance),f=Mj.simplify(s,u),p=f.length-1;a.initSideSegments(f[0],f[1],H.LEFT);for(var $=2;$<=p;$++)a.addNextSegment(f[$],!0);a.addLastSegment(),a.addLineEndCap(f[p-1],f[p]);var q=Mj.simplify(s,-u),M=q.length-1;a.initSideSegments(q[M],q[M-1],H.LEFT);for(var C=M-2;C>=0;C--)a.addNextSegment(q[C],!0);a.addLastSegment(),a.addLineEndCap(q[1],q[0]),a.closeRing()},Fr.prototype.computePointCurve=function(s,a){switch(this._bufParams.getEndCapStyle()){case zt.CAP_ROUND:a.createCircle(s);break;case zt.CAP_SQUARE:a.createSquare(s)}},Fr.prototype.getLineCurve=function(s,a){if(this._distance=a,a<0&&!this._bufParams.isSingleSided()||a===0)return null;var u=Math.abs(a),f=this.getSegGen(u);if(s.length<=1)this.computePointCurve(s[0],f);else if(this._bufParams.isSingleSided()){var p=a<0;this.computeSingleSidedBufferCurve(s,p,f)}else this.computeLineBufferCurve(s,f);return f.getCoordinates()},Fr.prototype.getBufferParameters=function(){return this._bufParams},Fr.prototype.simplifyTolerance=function(s){return s*this._bufParams.getSimplifyFactor()},Fr.prototype.getRingCurve=function(s,a,u){if(this._distance=u,s.length<=2)return this.getLineCurve(s,u);if(u===0)return Fr.copyCoordinates(s);var f=this.getSegGen(u);return this.computeRingBufferCurve(s,a,f),f.getCoordinates()},Fr.prototype.computeOffsetCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);if(a){var p=Mj.simplify(s,-f),$=p.length-1;u.initSideSegments(p[$],p[$-1],H.LEFT),u.addFirstSegment();for(var q=$-2;q>=0;q--)u.addNextSegment(p[q],!0)}else{var M=Mj.simplify(s,f),C=M.length-1;u.initSideSegments(M[0],M[1],H.LEFT),u.addFirstSegment();for(var Q=2;Q<=C;Q++)u.addNextSegment(M[Q],!0)}u.addLastSegment()},Fr.prototype.getSegGen=function(s){return new pj(this._precisionModel,this._bufParams,s)},Fr.prototype.interfaces_=function(){return[]},Fr.prototype.getClass=function(){return Fr},Fr.copyCoordinates=function(s){for(var a=new Array(s.length).fill(null),u=0;up.getMaxY()||this.findStabbedSegments(s,f.getDirectedEdges(),a)}return a}if(arguments.length===3){if(G(arguments[2],uA)&&arguments[0]instanceof F&&arguments[1]instanceof I_){for(var $=arguments[0],q=arguments[1],M=arguments[2],C=q.getEdge().getCoordinates(),Q=0;Qthis._seg.p1.y&&this._seg.reverse(),!(Math.max(this._seg.p0.x,this._seg.p1.x)<$.x)&&!(this._seg.isHorizontal()||$.ythis._seg.p1.y||EA.computeOrientation(this._seg.p0,this._seg.p1,$)===EA.RIGHT)){var oA=q.getDepth(H.LEFT);this._seg.p0.equals(C[Q])||(oA=q.getDepth(H.RIGHT));var cA=new r7(this._seg,oA);M.add(cA)}}else if(G(arguments[2],uA)&&arguments[0]instanceof F&&G(arguments[1],uA))for(var yA=arguments[0],vA=arguments[1],IA=arguments[2],DA=vA.iterator();DA.hasNext();){var Jt=DA.next();Jt.isForward()&&this.findStabbedSegments(yA,Jt,IA)}}},wl.prototype.getDepth=function(s){var a=this.findStabbedSegments(s);return a.size()===0?0:T6.min(a)._leftDepth},wl.prototype.interfaces_=function(){return[]},wl.prototype.getClass=function(){return wl},o8.DepthSegment.get=function(){return r7},Object.defineProperties(wl,o8);var r7=function(){this._upwardSeg=null,this._leftDepth=null;var s=arguments[0],a=arguments[1];this._upwardSeg=new CA(s),this._leftDepth=a};r7.prototype.compareTo=function(s){var a=s;if(this._upwardSeg.minX()>=a._upwardSeg.maxX())return 1;if(this._upwardSeg.maxX()<=a._upwardSeg.minX())return-1;var u=this._upwardSeg.orientationIndex(a._upwardSeg);return u!==0||(u=-1*a._upwardSeg.orientationIndex(this._upwardSeg))!=0?u:this._upwardSeg.compareTo(a._upwardSeg)},r7.prototype.compareX=function(s,a){var u=s.p0.compareTo(a.p0);return u!==0?u:s.p1.compareTo(a.p1)},r7.prototype.toString=function(){return this._upwardSeg.toString()},r7.prototype.interfaces_=function(){return[w]},r7.prototype.getClass=function(){return r7};var Ut=function(s,a,u){this.p0=s||null,this.p1=a||null,this.p2=u||null};Ut.prototype.area=function(){return Ut.area(this.p0,this.p1,this.p2)},Ut.prototype.signedArea=function(){return Ut.signedArea(this.p0,this.p1,this.p2)},Ut.prototype.interpolateZ=function(s){if(s===null)throw new b("Supplied point is null.");return Ut.interpolateZ(s,this.p0,this.p1,this.p2)},Ut.prototype.longestSideLength=function(){return Ut.longestSideLength(this.p0,this.p1,this.p2)},Ut.prototype.isAcute=function(){return Ut.isAcute(this.p0,this.p1,this.p2)},Ut.prototype.circumcentre=function(){return Ut.circumcentre(this.p0,this.p1,this.p2)},Ut.prototype.area3D=function(){return Ut.area3D(this.p0,this.p1,this.p2)},Ut.prototype.centroid=function(){return Ut.centroid(this.p0,this.p1,this.p2)},Ut.prototype.inCentre=function(){return Ut.inCentre(this.p0,this.p1,this.p2)},Ut.prototype.interfaces_=function(){return[]},Ut.prototype.getClass=function(){return Ut},Ut.area=function(s,a,u){return Math.abs(((u.x-s.x)*(a.y-s.y)-(a.x-s.x)*(u.y-s.y))/2)},Ut.signedArea=function(s,a,u){return((u.x-s.x)*(a.y-s.y)-(a.x-s.x)*(u.y-s.y))/2},Ut.det=function(s,a,u,f){return s*f-a*u},Ut.interpolateZ=function(s,a,u,f){var p=a.x,$=a.y,q=u.x-p,M=f.x-p,C=u.y-$,Q=f.y-$,oA=q*Q-M*C,cA=s.x-p,yA=s.y-$,vA=(Q*cA-M*yA)/oA,IA=(-C*cA+q*yA)/oA;return a.z+vA*(u.z-a.z)+IA*(f.z-a.z)},Ut.longestSideLength=function(s,a,u){var f=s.distance(a),p=a.distance(u),$=u.distance(s),q=f;return p>q&&(q=p),$>q&&(q=$),q},Ut.isAcute=function(s,a,u){return!!It.isAcute(s,a,u)&&!!It.isAcute(a,u,s)&&!!It.isAcute(u,s,a)},Ut.circumcentre=function(s,a,u){var f=u.x,p=u.y,$=s.x-f,q=s.y-p,M=a.x-f,C=a.y-p,Q=2*Ut.det($,q,M,C),oA=Ut.det(q,$*$+q*q,C,M*M+C*C),cA=Ut.det($,$*$+q*q,M,M*M+C*C);return new F(f-oA/Q,p+cA/Q)},Ut.perpendicularBisector=function(s,a){var u=a.x-s.x,f=a.y-s.y,p=new Ht(s.x+u/2,s.y+f/2,1),$=new Ht(s.x-f+u/2,s.y+u+f/2,1);return new Ht(p,$)},Ut.angleBisector=function(s,a,u){var f=a.distance(s),p=f/(f+a.distance(u)),$=u.x-s.x,q=u.y-s.y;return new F(s.x+p*$,s.y+p*q)},Ut.area3D=function(s,a,u){var f=a.x-s.x,p=a.y-s.y,$=a.z-s.z,q=u.x-s.x,M=u.y-s.y,C=u.z-s.z,Q=p*C-$*M,oA=$*q-f*C,cA=f*M-p*q,yA=Q*Q+oA*oA+cA*cA,vA=Math.sqrt(yA)/2;return vA},Ut.centroid=function(s,a,u){var f=(s.x+a.x+u.x)/3,p=(s.y+a.y+u.y)/3;return new F(f,p)},Ut.inCentre=function(s,a,u){var f=a.distance(u),p=s.distance(u),$=s.distance(a),q=f+p+$,M=(f*s.x+p*a.x+$*u.x)/q,C=(f*s.y+p*a.y+$*u.y)/q;return new F(M,C)};var h6=function(){this._inputGeom=null,this._distance=null,this._curveBuilder=null,this._curveList=new nA;var s=arguments[0],a=arguments[1],u=arguments[2];this._inputGeom=s,this._distance=a,this._curveBuilder=u};h6.prototype.addPoint=function(s){if(this._distance<=0)return null;var a=s.getCoordinates(),u=this._curveBuilder.getLineCurve(a,this._distance);this.addCurve(u,T.EXTERIOR,T.INTERIOR)},h6.prototype.addPolygon=function(s){var a=this._distance,u=H.LEFT;this._distance<0&&(a=-this._distance,u=H.RIGHT);var f=s.getExteriorRing(),p=BA.removeRepeatedPoints(f.getCoordinates());if(this._distance<0&&this.isErodedCompletely(f,this._distance)||this._distance<=0&&p.length<3)return null;this.addPolygonRing(p,a,u,T.EXTERIOR,T.INTERIOR);for(var $=0;$0&&this.isErodedCompletely(q,-this._distance)||this.addPolygonRing(M,a,H.opposite(u),T.INTERIOR,T.EXTERIOR)}},h6.prototype.isTriangleErodedCompletely=function(s,a){var u=new Ut(s[0],s[1],s[2]),f=u.inCentre();return EA.distancePointLine(f,u.p0,u.p1)=Pe.MINIMUM_VALID_SIZE&&EA.isCCW(s)&&($=p,q=f,u=H.opposite(u));var M=this._curveBuilder.getRingCurve(s,u,a);this.addCurve(M,$,q)},h6.prototype.add=function(s){if(s.isEmpty())return null;s instanceof Wt?this.addPolygon(s):s instanceof Bj?this.addLineString(s):s instanceof ir?this.addPoint(s):s instanceof M6?this.addCollection(s):s instanceof Gr?this.addCollection(s):s instanceof xe?this.addCollection(s):s instanceof oj&&this.addCollection(s)},h6.prototype.isErodedCompletely=function(s,a){var u=s.getCoordinates();if(u.length<4)return a<0;if(u.length===4)return this.isTriangleErodedCompletely(u,a);var f=s.getEnvelopeInternal(),p=Math.min(f.getHeight(),f.getWidth());return a<0&&2*Math.abs(a)>p},h6.prototype.addCollection=function(s){for(var a=0;a=this._max)throw new e;var s=this._parent.getGeometryN(this._index++);return s instanceof oj?(this._subcollectionIterator=new Ti(s),this._subcollectionIterator.next()):s},Ti.prototype.remove=function(){throw new Error(this.getClass().getName())},Ti.prototype.hasNext=function(){if(this._atStart)return!0;if(this._subcollectionIterator!==null){if(this._subcollectionIterator.hasNext())return!0;this._subcollectionIterator=null}return!(this._index>=this._max)},Ti.prototype.interfaces_=function(){return[hA]},Ti.prototype.getClass=function(){return Ti},Ti.isAtomic=function(s){return!(s instanceof oj)};var xn=function(){this._geom=null;var s=arguments[0];this._geom=s};xn.prototype.locate=function(s){return xn.locate(s,this._geom)},xn.prototype.interfaces_=function(){return[fu]},xn.prototype.getClass=function(){return xn},xn.isPointInRing=function(s,a){return!!a.getEnvelopeInternal().intersects(s)&&EA.isPointInRing(s,a.getCoordinates())},xn.containsPointInPolygon=function(s,a){if(a.isEmpty())return!1;var u=a.getExteriorRing();if(!xn.isPointInRing(s,u))return!1;for(var f=0;fA in t?kg(t,A,{enumerable:!0,configurable:!0,writable:!0,value:j}):t[A]=j;var C6=(t,A)=>()=>(A||t((A={exports:{}}).exports,A),A.exports),fr=(t,A)=>{for(var j in A)kg(t,j,{get:A[j],enumerable:!0})},$9=(t,A,j,e)=>{if(A&&typeof A=="object"||typeof A=="function")for(let r of k9(A))!m9.call(t,r)&&r!==j&&kg(t,r,{get:()=>A[r],enumerable:!(e=p9(A,r))||e.enumerable});return t};var Qs=(t,A,j)=>(j=t!=null?d9(g9(t)):{},$9(A||!t||!t.__esModule?kg(j,"default",{value:t,enumerable:!0}):j,t));var I=(t,A,j)=>(E9(t,typeof A!="symbol"?A+"":A,j),j);var v8=(()=>{for(var t=new Uint8Array(128),A=0;A<64;A++)t[A<26?A+65:A<52?A+71:A<62?A-4:A*4-205]=A;return j=>{for(var e=j.length,r=new Uint8Array((e-(j[e-1]=="=")-(j[e-2]=="="))*3/4|0),n=0,i=0;n>4,r[i++]=l<<4|c>>2,r[i++]=c<<6|B}return r}})();var ML=C6((ACA,Ax)=>{(function(t,A,j,e){"use strict";var r=["","webkit","Moz","MS","ms","o"],n=A.createElement("div"),i="function",o=Math.round,l=Math.abs,c=Date.now;function B(L,N,D){return setTimeout(G(L,D),N)}function h(L,N,D){return Array.isArray(L)?(d(L,D[N],D),!0):!1}function d(L,N,D){var aA;if(L)if(L.forEach)L.forEach(N,D);else if(L.length!==e)for(aA=0;aA\s*\(/gm,"{anonymous}()@"):"Unknown Stack Trace",Ft=t.console&&(t.console.warn||t.console.log);return Ft&&Ft.call(t.console,aA,bA),L.apply(this,arguments)}}var g;typeof Object.assign!="function"?g=function(N){if(N===e||N===null)throw new TypeError("Cannot convert undefined or null to object");for(var D=Object(N),aA=1;aA-1}function C(L){return L.trim().split(/\s+/g)}function R(L,N,D){if(L.indexOf&&!D)return L.indexOf(N);for(var aA=0;aArt[N]}):aA=aA.sort()),aA}function Q(L,N){for(var D,aA,gA=N[0].toUpperCase()+N.slice(1),bA=0;bA1&&!D.firstMultiple?D.firstMultiple=we(N):gA===1&&(D.firstMultiple=!1);var bA=D.firstInput,Ft=D.firstMultiple,Xt=Ft?Ft.center:bA.center,ut=N.center=Ee(aA);N.timeStamp=c(),N.deltaTime=N.timeStamp-bA.timeStamp,N.angle=J(Xt,ut),N.distance=Gt(Xt,ut),bt(D,N),N.offsetDirection=Ij(N.deltaX,N.deltaY);var rt=MA(N.deltaTime,N.deltaX,N.deltaY);N.overallVelocityX=rt.x,N.overallVelocityY=rt.y,N.overallVelocity=l(rt.x)>l(rt.y)?rt.x:rt.y,N.scale=Ft?S(Ft.pointers,aA):1,N.rotation=Ft?P(Ft.pointers,aA):0,N.maxPointers=D.prevInput?N.pointers.length>D.prevInput.maxPointers?N.pointers.length:D.prevInput.maxPointers:N.pointers.length,EA(D,N);var Yt=L.element;O(N.srcEvent.target,Yt)&&(Yt=N.srcEvent.target),N.target=Yt}function bt(L,N){var D=N.center,aA=L.offsetDelta||{},gA=L.prevDelta||{},bA=L.prevInput||{};(N.eventType===wA||bA.eventType===qA)&&(gA=L.prevDelta={x:bA.deltaX||0,y:bA.deltaY||0},aA=L.offsetDelta={x:D.x,y:D.y}),N.deltaX=gA.x+(D.x-aA.x),N.deltaY=gA.y+(D.y-aA.y)}function EA(L,N){var D=L.lastInterval||N,aA=N.timeStamp-D.timeStamp,gA,bA,Ft,Xt;if(N.eventType!=Ht&&(aA>ft||D.velocity===e)){var ut=N.deltaX-D.deltaX,rt=N.deltaY-D.deltaY,Yt=MA(aA,ut,rt);bA=Yt.x,Ft=Yt.y,gA=l(Yt.x)>l(Yt.y)?Yt.x:Yt.y,Xt=Ij(ut,rt),L.lastInterval=N}else gA=D.velocity,bA=D.velocityX,Ft=D.velocityY,Xt=D.direction;N.velocity=gA,N.velocityX=bA,N.velocityY=Ft,N.direction=Xt}function we(L){for(var N=[],D=0;D=l(N)?L<0?l6:Tt:N<0?me:FA}function Gt(L,N,D){D||(D=Uj);var aA=N[D[0]]-L[D[0]],gA=N[D[1]]-L[D[1]];return Math.sqrt(aA*aA+gA*gA)}function J(L,N,D){D||(D=Uj);var aA=N[D[0]]-L[D[0]],gA=N[D[1]]-L[D[1]];return Math.atan2(gA,aA)*180/Math.PI}function P(L,N){return J(N[1],N[0],KA)+J(L[1],L[0],KA)}function S(L,N){return Gt(N[0],N[1],KA)/Gt(L[0],L[1],KA)}var K={mousedown:wA,mousemove:_t,mouseup:qA},V="mousedown",U="mousemove mouseup";function lA(){this.evEl=V,this.evWin=U,this.pressed=!1,xA.apply(this,arguments)}y(lA,xA,{handler:function(N){var D=K[N.type];D&wA&&N.button===0&&(this.pressed=!0),D&_t&&N.which!==1&&(D=qA),this.pressed&&(D&qA&&(this.pressed=!1),this.callback(this.manager,D,{pointers:[N],changedPointers:[N],pointerType:Ct,srcEvent:N}))}});var rA={pointerdown:wA,pointermove:_t,pointerup:qA,pointercancel:Ht,pointerout:Ht},hA={2:QA,3:mt,4:Ct,5:SA},uA="pointerdown",nA="pointermove pointerup pointercancel";t.MSPointerEvent&&!t.PointerEvent&&(uA="MSPointerDown",nA="MSPointerMove MSPointerUp MSPointerCancel");function sA(){this.evEl=uA,this.evWin=nA,xA.apply(this,arguments),this.store=this.manager.session.pointerEvents=[]}y(sA,xA,{handler:function(N){var D=this.store,aA=!1,gA=N.type.toLowerCase().replace("ms",""),bA=rA[gA],Ft=hA[N.pointerType]||N.pointerType,Xt=Ft==QA,ut=R(D,N.pointerId,"pointerId");bA&wA&&(N.button===0||Xt)?ut<0&&(D.push(N),ut=D.length-1):bA&(qA|Ht)&&(aA=!0),!(ut<0)&&(D[ut]=N,this.callback(this.manager,bA,{pointers:D,changedPointers:[N],pointerType:Ft,srcEvent:N}),aA&&D.splice(ut,1))}});var kA={touchstart:wA,touchmove:_t,touchend:qA,touchcancel:Ht},BA="touchstart",tt="touchstart touchmove touchend touchcancel";function UA(){this.evTarget=BA,this.evWin=tt,this.started=!1,xA.apply(this,arguments)}y(UA,xA,{handler:function(N){var D=kA[N.type];if(D===wA&&(this.started=!0),!!this.started){var aA=wt.call(this,N,D);D&(qA|Ht)&&aA[0].length-aA[1].length===0&&(this.started=!1),this.callback(this.manager,D,{pointers:aA[0],changedPointers:aA[1],pointerType:QA,srcEvent:N})}}});function wt(L,N){var D=X(L.touches),aA=X(L.changedTouches);return N&(qA|Ht)&&(D=T(D.concat(aA),"identifier",!0)),[D,aA]}var at={touchstart:wA,touchmove:_t,touchend:qA,touchcancel:Ht},kj="touchstart touchmove touchend touchcancel";function Lj(){this.evTarget=kj,this.targetIds={},xA.apply(this,arguments)}y(Lj,xA,{handler:function(N){var D=at[N.type],aA=Vj.call(this,N,D);aA&&this.callback(this.manager,D,{pointers:aA[0],changedPointers:aA[1],pointerType:QA,srcEvent:N})}});function Vj(L,N){var D=X(L.touches),aA=this.targetIds;if(N&(wA|_t)&&D.length===1)return aA[D[0].identifier]=!0,[D,D];var gA,bA,Ft=X(L.changedTouches),Xt=[],ut=this.target;if(bA=D.filter(function(rt){return O(rt.target,ut)}),N===wA)for(gA=0;gA-1&&aA.splice(bA,1)};setTimeout(gA,dj)}}function _j(L){for(var N=L.srcEvent.clientX,D=L.srcEvent.clientY,aA=0;aA-1&&this.requireFail.splice(N,1),this},hasRequireFailures:function(){return this.requireFail.length>0},canRecognizeWith:function(L){return!!this.simultaneous[L.id]},emit:function(L){var N=this,D=this.state;function aA(gA){N.manager.emit(gA,L)}D=Pe&&aA(N.options.event+t7(D))},tryEmit:function(L){if(this.canEmit())return this.emit(L);this.state=gn},canEmit:function(){for(var L=0;LN.threshold&&gA&N.direction},attrTest:function(L){return B6.prototype.attrTest.call(this,L)&&(this.state&Qt||!(this.state&Qt)&&this.directionTest(L))},emit:function(L){this.pX=L.deltaX,this.pY=L.deltaY;var N=j7(L.direction);N&&(L.additionalEvent=this.options.event+N),this._super.emit.call(this,L)}});function yl(){B6.apply(this,arguments)}y(yl,B6,{defaults:{event:"pinch",threshold:0,pointers:2},getTouchAction:function(){return[c6]},attrTest:function(L){return this._super.attrTest.call(this,L)&&(Math.abs(L.scale-1)>this.options.threshold||this.state&Qt)},emit:function(L){if(L.scale!==1){var N=L.scale<1?"in":"out";L.additionalEvent=this.options.event+N}this._super.emit.call(this,L)}});function lu(){mn.apply(this,arguments),this._timer=null,this._input=null}y(lu,mn,{defaults:{event:"press",pointers:1,time:251,threshold:9},getTouchAction:function(){return[br]},process:function(L){var N=this.options,D=L.pointers.length===N.pointers,aA=L.distanceN.time;if(this._input=L,!aA||!D||L.eventType&(qA|Ht)&&!gA)this.reset();else if(L.eventType&wA)this.reset(),this._timer=B(function(){this.state=xe,this.tryEmit()},N.time,this);else if(L.eventType&qA)return xe;return gn},reset:function(){clearTimeout(this._timer)},emit:function(L){this.state===xe&&(L&&L.eventType&qA?this.manager.emit(this.options.event+"up",L):(this._input.timeStamp=c(),this.manager.emit(this.options.event,this._input)))}});function Pt(){B6.apply(this,arguments)}y(Pt,B6,{defaults:{event:"rotate",threshold:0,pointers:2},getTouchAction:function(){return[c6]},attrTest:function(L){return this._super.attrTest.call(this,L)&&(Math.abs(L.rotation)>this.options.threshold||this.state&Qt)}});function vl(){B6.apply(this,arguments)}y(vl,B6,{defaults:{event:"swipe",threshold:10,velocity:.3,direction:yj|cj,pointers:1},getTouchAction:function(){return Yr.prototype.getTouchAction.call(this)},attrTest:function(L){var N=this.options.direction,D;return N&(yj|cj)?D=L.overallVelocity:N&yj?D=L.overallVelocityX:N&cj&&(D=L.overallVelocityY),this._super.attrTest.call(this,L)&&N&L.offsetDirection&&L.distance>this.options.threshold&&L.maxPointers==this.options.pointers&&l(D)>this.options.velocity&&L.eventType&qA},emit:function(L){var N=j7(L.offsetDirection);N&&this.manager.emit(this.options.event+N,L),this.manager.emit(this.options.event,L)}});function Gr(){mn.apply(this,arguments),this.pTime=!1,this.pCenter=!1,this._timer=null,this._input=null,this.count=0}y(Gr,mn,{defaults:{event:"tap",pointers:1,taps:1,interval:300,time:250,threshold:9,posThreshold:10},getTouchAction:function(){return[Fe]},process:function(L){var N=this.options,D=L.pointers.length===N.pointers,aA=L.distance{"use strict";OF.exports=vx;OF.exports.default=vx;function vx(t,A,j){j=j||2;var e=A&&A.length,r=e?A[0]*j:t.length,n=eC(t,0,r,j,!0),i=[];if(!n||n.next===n.prev)return i;var o,l,c,B,h,d,k;if(e&&(n=lsA(t,A,n,j)),t.length>80*j){o=c=t[0],l=B=t[1];for(var g=j;gc&&(c=h),d>B&&(B=d);k=Math.max(c-o,B-l),k=k!==0?32767/k:0}return Ek(n,i,j,o,l,k,0),i}function eC(t,A,j,e,r){var n,i;if(r===MF(t,A,j,e)>0)for(n=A;n=A;n-=e)i=jC(n,t[n],t[n+1],i);return i&&_x(i,i.next)&&(xk(i),i=i.next),i}function Tc(t,A){if(!t)return t;A||(A=t);var j=t,e;do if(e=!1,!j.steiner&&(_x(j,j.next)||ne(j.prev,j,j.next)===0)){if(xk(j),j=A=j.prev,j===j.next)break;e=!0}else j=j.next;while(e||j!==A);return A}function Ek(t,A,j,e,r,n,i){if(t){!i&&n&&hsA(t,e,r,n);for(var o=t,l,c;t.prev!==t.next;){if(l=t.prev,c=t.next,n?osA(t,e,r,n):isA(t)){A.push(l.i/j|0),A.push(t.i/j|0),A.push(c.i/j|0),xk(t),t=c.next,o=c.next;continue}if(t=c,t===o){i?i===1?(t=ssA(Tc(t),A,j),Ek(t,A,j,e,r,n,2)):i===2&&asA(t,A,j,e,r,n):Ek(Tc(t),A,j,e,r,n,1);break}}}}function isA(t){var A=t.prev,j=t,e=t.next;if(ne(A,j,e)>=0)return!1;for(var r=A.x,n=j.x,i=e.x,o=A.y,l=j.y,c=e.y,B=rn?r>i?r:i:n>i?n:i,k=o>l?o>c?o:c:l>c?l:c,g=e.next;g!==A;){if(g.x>=B&&g.x<=d&&g.y>=h&&g.y<=k&&UB(r,o,n,l,i,c,g.x,g.y)&&ne(g.prev,g,g.next)>=0)return!1;g=g.next}return!0}function osA(t,A,j,e){var r=t.prev,n=t,i=t.next;if(ne(r,n,i)>=0)return!1;for(var o=r.x,l=n.x,c=i.x,B=r.y,h=n.y,d=i.y,k=ol?o>c?o:c:l>c?l:c,m=B>h?B>d?B:d:h>d?h:d,y=PF(k,g,A,j,e),G=PF(E,m,A,j,e),v=t.prevZ,_=t.nextZ;v&&v.z>=y&&_&&_.z<=G;){if(v.x>=k&&v.x<=E&&v.y>=g&&v.y<=m&&v!==r&&v!==i&&UB(o,B,l,h,c,d,v.x,v.y)&&ne(v.prev,v,v.next)>=0||(v=v.prevZ,_.x>=k&&_.x<=E&&_.y>=g&&_.y<=m&&_!==r&&_!==i&&UB(o,B,l,h,c,d,_.x,_.y)&&ne(_.prev,_,_.next)>=0))return!1;_=_.nextZ}for(;v&&v.z>=y;){if(v.x>=k&&v.x<=E&&v.y>=g&&v.y<=m&&v!==r&&v!==i&&UB(o,B,l,h,c,d,v.x,v.y)&&ne(v.prev,v,v.next)>=0)return!1;v=v.prevZ}for(;_&&_.z<=G;){if(_.x>=k&&_.x<=E&&_.y>=g&&_.y<=m&&_!==r&&_!==i&&UB(o,B,l,h,c,d,_.x,_.y)&&ne(_.prev,_,_.next)>=0)return!1;_=_.nextZ}return!0}function ssA(t,A,j){var e=t;do{var r=e.prev,n=e.next.next;!_x(r,n)&&rC(r,e,e.next,n)&&$k(r,n)&&$k(n,r)&&(A.push(r.i/j|0),A.push(e.i/j|0),A.push(n.i/j|0),xk(e),xk(e.next),e=t=n),e=e.next}while(e!==t);return Tc(e)}function asA(t,A,j,e,r,n){var i=t;do{for(var o=i.next.next;o!==i.prev;){if(i.i!==o.i&&ksA(i,o)){var l=nC(i,o);i=Tc(i,i.next),l=Tc(l,l.next),Ek(i,A,j,e,r,n,0),Ek(l,A,j,e,r,n,0);return}o=o.next}i=i.next}while(i!==t)}function lsA(t,A,j,e){var r=[],n,i,o,l,c;for(n=0,i=A.length;n=j.next.y&&j.next.y!==j.y){var o=j.x+(r-j.y)*(j.next.x-j.x)/(j.next.y-j.y);if(o<=e&&o>n&&(n=o,i=j.x=j.x&&j.x>=c&&e!==j.x&&UB(ri.x||j.x===i.x&&fsA(i,j)))&&(i=j,h=d)),j=j.next;while(j!==l);return i}function fsA(t,A){return ne(t.prev,t,A.prev)<0&&ne(A.next,t,t.next)<0}function hsA(t,A,j,e){var r=t;do r.z===0&&(r.z=PF(r.x,r.y,A,j,e)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==t);r.prevZ.nextZ=null,r.prevZ=null,dsA(r)}function dsA(t){var A,j,e,r,n,i,o,l,c=1;do{for(j=t,t=null,n=null,i=0;j;){for(i++,e=j,o=0,A=0;A0||l>0&&e;)o!==0&&(l===0||!e||j.z<=e.z)?(r=j,j=j.nextZ,o--):(r=e,e=e.nextZ,l--),n?n.nextZ=r:t=r,r.prevZ=n,n=r;j=e}n.nextZ=null,c*=2}while(i>1);return t}function PF(t,A,j,e,r){return t=(t-j)*r|0,A=(A-e)*r|0,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,A=(A|A<<8)&16711935,A=(A|A<<4)&252645135,A=(A|A<<2)&858993459,A=(A|A<<1)&1431655765,t|A<<1}function psA(t){var A=t,j=t;do(A.x=(t-i)*(n-o)&&(t-i)*(e-o)>=(j-i)*(A-o)&&(j-i)*(n-o)>=(r-i)*(e-o)}function ksA(t,A){return t.next.i!==A.i&&t.prev.i!==A.i&&!gsA(t,A)&&($k(t,A)&&$k(A,t)&&msA(t,A)&&(ne(t.prev,t,A.prev)||ne(t,A.prev,A))||_x(t,A)&&ne(t.prev,t,t.next)>0&&ne(A.prev,A,A.next)>0)}function ne(t,A,j){return(A.y-t.y)*(j.x-A.x)-(A.x-t.x)*(j.y-A.y)}function _x(t,A){return t.x===A.x&&t.y===A.y}function rC(t,A,j,e){var r=yx(ne(t,A,j)),n=yx(ne(t,A,e)),i=yx(ne(j,e,t)),o=yx(ne(j,e,A));return!!(r!==n&&i!==o||r===0&&xx(t,j,A)||n===0&&xx(t,e,A)||i===0&&xx(j,t,e)||o===0&&xx(j,A,e))}function xx(t,A,j){return A.x<=Math.max(t.x,j.x)&&A.x>=Math.min(t.x,j.x)&&A.y<=Math.max(t.y,j.y)&&A.y>=Math.min(t.y,j.y)}function yx(t){return t>0?1:t<0?-1:0}function gsA(t,A){var j=t;do{if(j.i!==t.i&&j.next.i!==t.i&&j.i!==A.i&&j.next.i!==A.i&&rC(j,j.next,t,A))return!0;j=j.next}while(j!==t);return!1}function $k(t,A){return ne(t.prev,t,t.next)<0?ne(t,A,t.next)>=0&&ne(t,t.prev,A)>=0:ne(t,A,t.prev)<0||ne(t,t.next,A)<0}function msA(t,A){var j=t,e=!1,r=(t.x+A.x)/2,n=(t.y+A.y)/2;do j.y>n!=j.next.y>n&&j.next.y!==j.y&&r<(j.next.x-j.x)*(n-j.y)/(j.next.y-j.y)+j.x&&(e=!e),j=j.next;while(j!==t);return e}function nC(t,A){var j=new IF(t.i,t.x,t.y),e=new IF(A.i,A.x,A.y),r=t.next,n=A.prev;return t.next=A,A.prev=t,j.next=r,r.prev=j,e.next=j,j.prev=e,n.next=e,e.prev=n,e}function jC(t,A,j,e){var r=new IF(t,A,j);return e?(r.next=e.next,r.prev=e,e.next.prev=r,e.next=r):(r.prev=r,r.next=r),r}function xk(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function IF(t,A,j){this.i=t,this.x=A,this.y=j,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}vx.deviation=function(t,A,j,e){var r=A&&A.length,n=r?A[0]*j:t.length,i=Math.abs(MF(t,0,n,j));if(r)for(var o=0,l=A.length;o0&&(e+=t[r-1].length,j.holes.push(e))}return j}});var OD=C6((cy,MD)=>{(function(t,A){A(typeof cy=="object"&&typeof MD<"u"?cy:t.jsts={})})(cy,function(t){"use strict";function A(){}function j(s){this.message=s||""}function e(s){this.message=s||""}function r(s){this.message=s||""}function n(){}function i(s){return s===null?dj:s.color}function o(s){return s===null?null:s.parent}function l(s,a){s!==null&&(s.color=a)}function c(s){return s===null?null:s.left}function B(s){return s===null?null:s.right}function h(){this.root_=null,this.size_=0}function d(){}function k(){this.array_=[],arguments[0]instanceof rA&&this.addAll(arguments[0])}function g(){}function E(s){this.message=s||""}function m(){this.array_=[]}"fill"in Array.prototype||Object.defineProperty(Array.prototype,"fill",{configurable:!0,value:function(s){if(this===void 0||this===null)throw new TypeError(this+" is not an object");var a=Object(this),u=Math.max(Math.min(a.length,9007199254740991),0)||0,f=1 in arguments&&parseInt(Number(arguments[1]),10)||0;f=f<0?Math.max(u+f,0):Math.min(f,u);var p=2 in arguments&&arguments[2]!==void 0?parseInt(Number(arguments[2]),10)||0:u;for(p=p<0?Math.max(u+arguments[2],0):Math.min(p,u);fa.x?1:this.ya.y?1:0},F.prototype.clone=function(){},F.prototype.copy=function(){return new F(this)},F.prototype.toString=function(){return"("+this.x+", "+this.y+", "+this.z+")"},F.prototype.distance3D=function(s){var a=this.x-s.x,u=this.y-s.y,f=this.z-s.z;return Math.sqrt(a*a+u*u+f*f)},F.prototype.distance=function(s){var a=this.x-s.x,u=this.y-s.y;return Math.sqrt(a*a+u*u)},F.prototype.hashCode=function(){var s=17;return s=37*s+F.hashCode(this.x),s=37*s+F.hashCode(this.y)},F.prototype.setCoordinate=function(s){this.x=s.x,this.y=s.y,this.z=s.z},F.prototype.interfaces_=function(){return[w,x,A]},F.prototype.getClass=function(){return F},F.hashCode=function(){if(arguments.length===1){var s=arguments[0],a=v.doubleToLongBits(s);return Math.trunc((a^a)>>>32)}},C.DimensionalComparator.get=function(){return R},C.serialVersionUID.get=function(){return 6683108902428367e3},C.NULL_ORDINATE.get=function(){return v.NaN},C.X.get=function(){return 0},C.Y.get=function(){return 1},C.Z.get=function(){return 2},Object.defineProperties(F,C);var R=function(s){if(this._dimensionsToTest=2,arguments.length!==0){if(arguments.length===1){var a=arguments[0];if(a!==2&&a!==3)throw new G("only 2 or 3 dimensions may be specified");this._dimensionsToTest=a}}};R.prototype.compare=function(s,a){var u=s,f=a,p=R.compare(u.x,f.x);if(p!==0)return p;var $=R.compare(u.y,f.y);return $!==0?$:this._dimensionsToTest<=2?0:R.compare(u.z,f.z)},R.prototype.interfaces_=function(){return[O]},R.prototype.getClass=function(){return R},R.compare=function(s,a){return sa?1:v.isNaN(s)?v.isNaN(a)?0:-1:v.isNaN(a)?1:0};var X=function(){};X.prototype.create=function(){},X.prototype.interfaces_=function(){return[]},X.prototype.getClass=function(){return X};var T=function(){},Q={INTERIOR:{configurable:!0},BOUNDARY:{configurable:!0},EXTERIOR:{configurable:!0},NONE:{configurable:!0}};T.prototype.interfaces_=function(){return[]},T.prototype.getClass=function(){return T},T.toLocationSymbol=function(s){switch(s){case T.EXTERIOR:return"e";case T.BOUNDARY:return"b";case T.INTERIOR:return"i";case T.NONE:return"-"}throw new G("Unknown location value: "+s)},Q.INTERIOR.get=function(){return 0},Q.BOUNDARY.get=function(){return 1},Q.EXTERIOR.get=function(){return 2},Q.NONE.get=function(){return-1},Object.defineProperties(T,Q);var b=function(s,a){return s.interfaces_&&s.interfaces_().indexOf(a)>-1},jA=function(){},pA={LOG_10:{configurable:!0}};jA.prototype.interfaces_=function(){return[]},jA.prototype.getClass=function(){return jA},jA.log10=function(s){var a=Math.log(s);return v.isInfinite(a)||v.isNaN(a)?a:a/jA.LOG_10},jA.min=function(s,a,u,f){var p=s;return au?u:s}if(Number.isInteger(arguments[2])&&Number.isInteger(arguments[0])&&Number.isInteger(arguments[1])){var f=arguments[0],p=arguments[1],$=arguments[2];return f$?$:f}},jA.wrap=function(s,a){return s<0?a- -s%a:s%a},jA.max=function(){if(arguments.length===3){var s=arguments[0],a=arguments[1],u=arguments[2],f=s;return a>f&&(f=a),u>f&&(f=u),f}if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3],H=p;return $>H&&(H=$),q>H&&(H=q),M>H&&(H=M),H}},jA.average=function(s,a){return(s+a)/2},pA.LOG_10.get=function(){return Math.log(10)},Object.defineProperties(jA,pA);var dA=function(s){this.str=s};dA.prototype.append=function(s){this.str+=s},dA.prototype.setCharAt=function(s,a){this.str=this.str.substr(0,s)+a+this.str.substr(s+1)},dA.prototype.toString=function(s){return this.str};var $A=function(s){this.value=s};$A.prototype.intValue=function(){return this.value},$A.prototype.compareTo=function(s){return this.values?1:0},$A.isNaN=function(s){return Number.isNaN(s)};var _A=function(){};_A.isWhitespace=function(s){return s<=32&&s>=0||s===127},_A.toUpperCase=function(s){return s.toUpperCase()};var Y=function s(){if(this._hi=0,this._lo=0,arguments.length===0)this.init(0);else if(arguments.length===1){if(typeof arguments[0]=="number"){var a=arguments[0];this.init(a)}else if(arguments[0]instanceof s){var u=arguments[0];this.init(u)}else if(typeof arguments[0]=="string"){var f=arguments[0];s.call(this,s.parse(f))}}else if(arguments.length===2){var p=arguments[0],$=arguments[1];this.init(p,$)}},QA={PI:{configurable:!0},TWO_PI:{configurable:!0},PI_2:{configurable:!0},E:{configurable:!0},NaN:{configurable:!0},EPS:{configurable:!0},SPLIT:{configurable:!0},MAX_PRINT_DIGITS:{configurable:!0},TEN:{configurable:!0},ONE:{configurable:!0},SCI_NOT_EXPONENT_CHAR:{configurable:!0},SCI_NOT_ZERO:{configurable:!0}};Y.prototype.le=function(s){return(this._hi9?(oA=!0,cA="9"):cA="0"+W,q.append(cA),u=u.subtract(Y.valueOf(W)).multiply(Y.TEN),oA&&u.selfAdd(Y.TEN);var yA=!0,vA=Y.magnitude(u._hi);if(vA<0&&Math.abs(vA)>=M-H&&(yA=!1),!yA)break}return a[0]=f,q.toString()},Y.prototype.sqr=function(){return this.multiply(this)},Y.prototype.doubleValue=function(){return this._hi+this._lo},Y.prototype.subtract=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.add(s.negate())}if(typeof arguments[0]=="number"){var a=arguments[0];return this.add(-a)}},Y.prototype.equals=function(){if(arguments.length===1){var s=arguments[0];return this._hi===s._hi&&this._lo===s._lo}},Y.prototype.isZero=function(){return this._hi===0&&this._lo===0},Y.prototype.selfSubtract=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.isNaN()?this:this.selfAdd(-s._hi,-s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.isNaN()?this:this.selfAdd(-a,0)}},Y.prototype.getSpecialNumberString=function(){return this.isZero()?"0.0":this.isNaN()?"NaN ":null},Y.prototype.min=function(s){return this.le(s)?this:s},Y.prototype.selfDivide=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfDivide(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.selfDivide(a,0)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1],p=null,$=null,q=null,M=null,H=null,W=null,oA=null,cA=null;return H=this._hi/u,W=Y.SPLIT*H,p=W-H,cA=Y.SPLIT*u,p=W-p,$=H-p,q=cA-u,oA=H*u,q=cA-q,M=u-q,cA=p*q-oA+p*M+$*q+$*M,W=(this._hi-oA-cA+this._lo-H*f)/u,cA=H+W,this._hi=cA,this._lo=H-cA+W,this}},Y.prototype.dump=function(){return"DD<"+this._hi+", "+this._lo+">"},Y.prototype.divide=function(){if(arguments[0]instanceof Y){var s=arguments[0],a=null,u=null,f=null,p=null,$=null,q=null,M=null,H=null;return u=($=this._hi/s._hi)-(a=(q=Y.SPLIT*$)-(a=q-$)),H=a*(f=(H=Y.SPLIT*s._hi)-(f=H-s._hi))-(M=$*s._hi)+a*(p=s._hi-f)+u*f+u*p,q=(this._hi-M-H+this._lo-$*s._lo)/s._hi,new Y(H=$+q,$-H+q)}if(typeof arguments[0]=="number"){var W=arguments[0];return v.isNaN(W)?Y.createNaN():Y.copy(this).selfDivide(W,0)}},Y.prototype.ge=function(s){return(this._hi>s._hi||this._hi===s._hi)&&this._lo>=s._lo},Y.prototype.pow=function(s){if(s===0)return Y.valueOf(1);var a=new Y(this),u=Y.valueOf(1),f=Math.abs(s);if(f>1)for(;f>0;)f%2==1&&u.selfMultiply(a),(f/=2)>0&&(a=a.sqr());else u=a;return s<0?u.reciprocal():u},Y.prototype.ceil=function(){if(this.isNaN())return Y.NaN;var s=Math.ceil(this._hi),a=0;return s===this._hi&&(a=Math.ceil(this._lo)),new Y(s,a)},Y.prototype.compareTo=function(s){var a=s;return this._hia._hi?1:this._loa._lo?1:0},Y.prototype.rint=function(){return this.isNaN()?this:this.add(.5).floor()},Y.prototype.setValue=function(){if(arguments[0]instanceof Y){var s=arguments[0];return this.init(s),this}if(typeof arguments[0]=="number"){var a=arguments[0];return this.init(a),this}},Y.prototype.max=function(s){return this.ge(s)?this:s},Y.prototype.sqrt=function(){if(this.isZero())return Y.valueOf(0);if(this.isNegative())return Y.NaN;var s=1/Math.sqrt(this._hi),a=this._hi*s,u=Y.valueOf(a),f=this.subtract(u.sqr())._hi*(.5*s);return u.add(f)},Y.prototype.selfAdd=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfAdd(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0],u=null,f=null,p=null,$=null,q=null,M=null;return p=this._hi+a,q=p-this._hi,$=p-q,$=a-q+(this._hi-$),M=$+this._lo,u=p+M,f=M+(p-u),this._hi=u+f,this._lo=f+(u-this._hi),this}}else if(arguments.length===2){var H=arguments[0],W=arguments[1],oA=null,cA=null,yA=null,vA=null,IA=null,DA=null,Jt=null;vA=this._hi+H,cA=this._lo+W,IA=vA-(DA=vA-this._hi),yA=cA-(Jt=cA-this._lo);var Yj=(oA=vA+(DA=(IA=H-DA+(this._hi-IA))+cA))+(DA=(yA=W-Jt+(this._lo-yA))+(DA+(vA-oA))),Br=DA+(oA-Yj);return this._hi=Yj,this._lo=Br,this}},Y.prototype.selfMultiply=function(){if(arguments.length===1){if(arguments[0]instanceof Y){var s=arguments[0];return this.selfMultiply(s._hi,s._lo)}if(typeof arguments[0]=="number"){var a=arguments[0];return this.selfMultiply(a,0)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1],p=null,$=null,q=null,M=null,H=null,W=null;p=(H=Y.SPLIT*this._hi)-this._hi,W=Y.SPLIT*u,p=H-p,$=this._hi-p,q=W-u;var oA=(H=this._hi*u)+(W=p*(q=W-q)-H+p*(M=u-q)+$*q+$*M+(this._hi*f+this._lo*u)),cA=W+(p=H-oA);return this._hi=oA,this._lo=cA,this}},Y.prototype.selfSqr=function(){return this.selfMultiply(this)},Y.prototype.floor=function(){if(this.isNaN())return Y.NaN;var s=Math.floor(this._hi),a=0;return s===this._hi&&(a=Math.floor(this._lo)),new Y(s,a)},Y.prototype.negate=function(){return this.isNaN()?this:new Y(-this._hi,-this._lo)},Y.prototype.clone=function(){},Y.prototype.multiply=function(){if(arguments[0]instanceof Y){var s=arguments[0];return s.isNaN()?Y.createNaN():Y.copy(this).selfMultiply(s)}if(typeof arguments[0]=="number"){var a=arguments[0];return v.isNaN(a)?Y.createNaN():Y.copy(this).selfMultiply(a,0)}},Y.prototype.isNaN=function(){return v.isNaN(this._hi)},Y.prototype.intValue=function(){return Math.trunc(this._hi)},Y.prototype.toString=function(){var s=Y.magnitude(this._hi);return s>=-3&&s<=20?this.toStandardNotation():this.toSciNotation()},Y.prototype.toStandardNotation=function(){var s=this.getSpecialNumberString();if(s!==null)return s;var a=new Array(1).fill(null),u=this.extractSignificantDigits(!0,a),f=a[0]+1,p=u;if(u.charAt(0)===".")p="0"+u;else if(f<0)p="0."+Y.stringOfChar("0",-f)+u;else if(u.indexOf(".")===-1){var $=f-u.length;p=u+Y.stringOfChar("0",$)+".0"}return this.isNegative()?"-"+p:p},Y.prototype.reciprocal=function(){var s=null,a=null,u=null,f=null,p=null,$=null,q=null,M=null;a=(p=1/this._hi)-(s=($=Y.SPLIT*p)-(s=$-p)),u=(M=Y.SPLIT*this._hi)-this._hi;var H=p+($=(1-(q=p*this._hi)-(M=s*(u=M-u)-q+s*(f=this._hi-u)+a*u+a*f)-p*this._lo)/this._hi);return new Y(H,p-H+$)},Y.prototype.toSciNotation=function(){if(this.isZero())return Y.SCI_NOT_ZERO;var s=this.getSpecialNumberString();if(s!==null)return s;var a=new Array(1).fill(null),u=this.extractSignificantDigits(!1,a),f=Y.SCI_NOT_EXPONENT_CHAR+a[0];if(u.charAt(0)==="0")throw new Error("Found leading zero: "+u);var p="";u.length>1&&(p=u.substring(1));var $=u.charAt(0)+"."+p;return this.isNegative()?"-"+$+f:$+f},Y.prototype.abs=function(){return this.isNaN()?Y.NaN:this.isNegative()?this.negate():new Y(this)},Y.prototype.isPositive=function(){return(this._hi>0||this._hi===0)&&this._lo>0},Y.prototype.lt=function(s){return(this._his._hi||this._hi===s._hi)&&this._lo>s._lo},Y.prototype.isNegative=function(){return(this._hi<0||this._hi===0)&&this._lo<0},Y.prototype.trunc=function(){return this.isNaN()?Y.NaN:this.isPositive()?this.floor():this.ceil()},Y.prototype.signum=function(){return this._hi>0?1:this._hi<0?-1:this._lo>0?1:this._lo<0?-1:0},Y.prototype.interfaces_=function(){return[A,w,x]},Y.prototype.getClass=function(){return Y},Y.sqr=function(s){return Y.valueOf(s).selfMultiply(s)},Y.valueOf=function(){if(typeof arguments[0]=="string"){var s=arguments[0];return Y.parse(s)}if(typeof arguments[0]=="number"){var a=arguments[0];return new Y(a)}},Y.sqrt=function(s){return Y.valueOf(s).sqrt()},Y.parse=function(s){for(var a=0,u=s.length;_A.isWhitespace(s.charAt(a));)a++;var f=!1;if(a=u);){var W=s.charAt(a);if(a++,_A.isDigit(W)){var oA=W-"0";$.selfMultiply(Y.TEN),$.selfAdd(oA),q++}else{if(W!=="."){if(W==="e"||W==="E"){var cA=s.substring(a);try{H=$A.parseInt(cA)}catch(Jt){throw Jt instanceof Error?new Error("Invalid exponent "+cA+" in string "+s):Jt}break}throw new Error("Unexpected character '"+W+"' at position "+a+" in string "+s)}M=q}}var yA=$,vA=q-M-H;if(vA===0)yA=$;else if(vA>0){var IA=Y.TEN.pow(vA);yA=$.divide(IA)}else if(vA<0){var DA=Y.TEN.pow(-vA);yA=$.multiply(DA)}return f?yA.negate():yA},Y.createNaN=function(){return new Y(v.NaN,v.NaN)},Y.copy=function(s){return new Y(s)},Y.magnitude=function(s){var a=Math.abs(s),u=Math.log(a)/Math.log(10),f=Math.trunc(Math.floor(u));return 10*Math.pow(10,f)<=a&&(f+=1),f},Y.stringOfChar=function(s,a){for(var u=new dA,f=0;f0){if($<=0)return mt.signum(q);f=p+$}else{if(!(p<0)||$>=0)return mt.signum(q);f=-p-$}var M=mt.DP_SAFE_EPSILON*f;return q>=M||-q>=M?mt.signum(q):2},mt.signum=function(s){return s>0?1:s<0?-1:0},Ct.DP_SAFE_EPSILON.get=function(){return 1e-15},Object.defineProperties(mt,Ct);var SA=function(){},ft={X:{configurable:!0},Y:{configurable:!0},Z:{configurable:!0},M:{configurable:!0}};ft.X.get=function(){return 0},ft.Y.get=function(){return 1},ft.Z.get=function(){return 2},ft.M.get=function(){return 3},SA.prototype.setOrdinate=function(s,a,u){},SA.prototype.size=function(){},SA.prototype.getOrdinate=function(s,a){},SA.prototype.getCoordinate=function(){},SA.prototype.getCoordinateCopy=function(s){},SA.prototype.getDimension=function(){},SA.prototype.getX=function(s){},SA.prototype.clone=function(){},SA.prototype.expandEnvelope=function(s){},SA.prototype.copy=function(){},SA.prototype.getY=function(s){},SA.prototype.toCoordinateArray=function(){},SA.prototype.interfaces_=function(){return[x]},SA.prototype.getClass=function(){return SA},Object.defineProperties(SA,ft);var wA=function(){},_t=function(s){function a(){s.call(this,"Projective point not representable on the Cartesian plane.")}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(wA),qA=function(){};qA.arraycopy=function(s,a,u,f,p){for(var $=0,q=a;qs._minx?this._minx:s._minx,u=this._miny>s._miny?this._miny:s._miny,f=this._maxx=this._minx&&a.getMaxX()<=this._maxx&&a.getMinY()>=this._miny&&a.getMaxY()<=this._maxy}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];return!this.isNull()&&u>=this._minx&&u<=this._maxx&&f>=this._miny&&f<=this._maxy}},GA.prototype.intersects=function(){if(arguments.length===1){if(arguments[0]instanceof GA){var s=arguments[0];return!this.isNull()&&!s.isNull()&&!(s._minx>this._maxx||s._maxxthis._maxy||s._maxythis._maxx||uthis._maxy||fthis._maxx&&(this._maxx=a._maxx),a._minythis._maxy&&(this._maxy=a._maxy))}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.isNull()?(this._minx=u,this._maxx=u,this._miny=f,this._maxy=f):(uthis._maxx&&(this._maxx=u),fthis._maxy&&(this._maxy=f))}},GA.prototype.minExtent=function(){if(this.isNull())return 0;var s=this.getWidth(),a=this.getHeight();return sa._minx?1:this._minya._miny?1:this._maxxa._maxx?1:this._maxya._maxy?1:0},GA.prototype.translate=function(s,a){if(this.isNull())return null;this.init(this.getMinX()+s,this.getMaxX()+s,this.getMinY()+a,this.getMaxY()+a)},GA.prototype.toString=function(){return"Env["+this._minx+" : "+this._maxx+", "+this._miny+" : "+this._maxy+"]"},GA.prototype.setToNull=function(){this._minx=0,this._maxx=-1,this._miny=0,this._maxy=-1},GA.prototype.getHeight=function(){return this.isNull()?0:this._maxy-this._miny},GA.prototype.maxExtent=function(){if(this.isNull())return 0;var s=this.getWidth(),a=this.getHeight();return s>a?s:a},GA.prototype.expandBy=function(){if(arguments.length===1){var s=arguments[0];this.expandBy(s,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1];if(this.isNull())return null;this._minx-=a,this._maxx+=a,this._miny-=u,this._maxy+=u,(this._minx>this._maxx||this._miny>this._maxy)&&this.setToNull()}},GA.prototype.contains=function(){if(arguments.length===1){if(arguments[0]instanceof GA){var s=arguments[0];return this.covers(s)}if(arguments[0]instanceof F){var a=arguments[0];return this.covers(a)}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];return this.covers(u,f)}},GA.prototype.centre=function(){return this.isNull()?null:new F((this.getMinX()+this.getMaxX())/2,(this.getMinY()+this.getMaxY())/2)},GA.prototype.init=function(){if(arguments.length===0)this.setToNull();else if(arguments.length===1){if(arguments[0]instanceof F){var s=arguments[0];this.init(s.x,s.x,s.y,s.y)}else if(arguments[0]instanceof GA){var a=arguments[0];this._minx=a._minx,this._maxx=a._maxx,this._miny=a._miny,this._maxy=a._maxy}}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.init(u.x,f.x,u.y,f.y)}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];p<$?(this._minx=p,this._maxx=$):(this._minx=$,this._maxx=p),qs._maxx&&(a=this._minx-s._maxx);var u=0;return this._maxys._maxy&&(u=this._miny-s._maxy),a===0?u:u===0?a:Math.sqrt(a*a+u*u)},GA.prototype.hashCode=function(){var s=17;return s=37*s+F.hashCode(this._minx),s=37*s+F.hashCode(this._maxx),s=37*s+F.hashCode(this._miny),s=37*s+F.hashCode(this._maxy)},GA.prototype.interfaces_=function(){return[w,A]},GA.prototype.getClass=function(){return GA},GA.intersects=function(){if(arguments.length===3){var s=arguments[0],a=arguments[1],u=arguments[2];return u.x>=(s.xa.x?s.x:a.x)&&u.y>=(s.ya.y?s.y:a.y)}if(arguments.length===4){var f=arguments[0],p=arguments[1],$=arguments[2],q=arguments[3],M=Math.min($.x,q.x),H=Math.max($.x,q.x),W=Math.min(f.x,p.x),oA=Math.max(f.x,p.x);return!(W>H)&&!(oAH)&&!(oAthis.getEdgeDistance(s,1)?(this._intLineIndex[s][0]=0,this._intLineIndex[s][1]=1):(this._intLineIndex[s][0]=1,this._intLineIndex[s][1]=0)}},xA.prototype.isProper=function(){return this.hasIntersection()&&this._isProper},xA.prototype.setPrecisionModel=function(s){this._precisionModel=s},xA.prototype.isInteriorIntersection=function(){if(arguments.length===0)return!!this.isInteriorIntersection(0)||!!this.isInteriorIntersection(1);if(arguments.length===1){for(var s=arguments[0],a=0;ap?f:p;else{var q=Math.abs(s.x-a.x),M=Math.abs(s.y-a.y);($=f>p?q:M)!==0||s.equals(a)||($=Math.max(q,M))}return KA.isTrue(!($===0&&!s.equals(a)),"Bad distance calculation"),$},xA.nonRobustComputeEdgeDistance=function(s,a,u){var f=s.x-a.x,p=s.y-a.y,$=Math.sqrt(f*f+p*p);return KA.isTrue(!($===0&&!s.equals(a)),"Invalid distance calculation"),$},fA.DONT_INTERSECT.get=function(){return 0},fA.DO_INTERSECT.get=function(){return 1},fA.COLLINEAR.get=function(){return 2},fA.NO_INTERSECTION.get=function(){return 0},fA.POINT_INTERSECTION.get=function(){return 1},fA.COLLINEAR_INTERSECTION.get=function(){return 2},Object.defineProperties(xA,fA);var PA=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isInSegmentEnvelopes=function(u){var f=new GA(this._inputLines[0][0],this._inputLines[0][1]),p=new GA(this._inputLines[1][0],this._inputLines[1][1]);return f.contains(u)&&p.contains(u)},a.prototype.computeIntersection=function(){if(arguments.length!==3)return s.prototype.computeIntersection.apply(this,arguments);var u=arguments[0],f=arguments[1],p=arguments[2];if(this._isProper=!1,GA.intersects(f,p,u)&&EA.orientationIndex(f,p,u)===0&&EA.orientationIndex(p,f,u)===0)return this._isProper=!0,(u.equals(f)||u.equals(p))&&(this._isProper=!1),this._result=s.POINT_INTERSECTION,null;this._result=s.NO_INTERSECTION},a.prototype.normalizeToMinimum=function(u,f,p,$,q){q.x=this.smallestInAbsValue(u.x,f.x,p.x,$.x),q.y=this.smallestInAbsValue(u.y,f.y,p.y,$.y),u.x-=q.x,u.y-=q.y,f.x-=q.x,f.y-=q.y,p.x-=q.x,p.y-=q.y,$.x-=q.x,$.y-=q.y},a.prototype.safeHCoordinateIntersection=function(u,f,p,$){var q=null;try{q=Ht.intersection(u,f,p,$)}catch(M){if(!(M instanceof _t))throw M;q=a.nearestEndpoint(u,f,p,$)}return q},a.prototype.intersection=function(u,f,p,$){var q=this.intersectionWithNormalization(u,f,p,$);return this.isInSegmentEnvelopes(q)||(q=new F(a.nearestEndpoint(u,f,p,$))),this._precisionModel!==null&&this._precisionModel.makePrecise(q),q},a.prototype.smallestInAbsValue=function(u,f,p,$){var q=u,M=Math.abs(q);return Math.abs(f)1e-4&&qA.out.println("Distance = "+q.distance(M))},a.prototype.intersectionWithNormalization=function(u,f,p,$){var q=new F(u),M=new F(f),H=new F(p),W=new F($),oA=new F;this.normalizeToEnvCentre(q,M,H,W,oA);var cA=this.safeHCoordinateIntersection(q,M,H,W);return cA.x+=oA.x,cA.y+=oA.y,cA},a.prototype.computeCollinearIntersection=function(u,f,p,$){var q=GA.intersects(u,f,p),M=GA.intersects(u,f,$),H=GA.intersects(p,$,u),W=GA.intersects(p,$,f);return q&&M?(this._intPt[0]=p,this._intPt[1]=$,s.COLLINEAR_INTERSECTION):H&&W?(this._intPt[0]=u,this._intPt[1]=f,s.COLLINEAR_INTERSECTION):q&&H?(this._intPt[0]=p,this._intPt[1]=u,!p.equals(u)||M||W?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):q&&W?(this._intPt[0]=p,this._intPt[1]=f,!p.equals(f)||M||H?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):M&&H?(this._intPt[0]=$,this._intPt[1]=u,!$.equals(u)||q||W?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):M&&W?(this._intPt[0]=$,this._intPt[1]=f,!$.equals(f)||q||H?s.COLLINEAR_INTERSECTION:s.POINT_INTERSECTION):s.NO_INTERSECTION},a.prototype.normalizeToEnvCentre=function(u,f,p,$,q){var M=u.xf.x?u.x:f.x,oA=u.y>f.y?u.y:f.y,cA=p.x<$.x?p.x:$.x,yA=p.y<$.y?p.y:$.y,vA=p.x>$.x?p.x:$.x,IA=p.y>$.y?p.y:$.y,DA=((M>cA?M:cA)+(WyA?H:yA)+(oA0&&M>0||q<0&&M<0)return s.NO_INTERSECTION;var H=EA.orientationIndex(p,$,u),W=EA.orientationIndex(p,$,f);return H>0&&W>0||H<0&&W<0?s.NO_INTERSECTION:q===0&&M===0&&H===0&&W===0?this.computeCollinearIntersection(u,f,p,$):(q===0||M===0||H===0||W===0?(this._isProper=!1,u.equals2D(p)||u.equals2D($)?this._intPt[0]=u:f.equals2D(p)||f.equals2D($)?this._intPt[0]=f:q===0?this._intPt[0]=new F(p):M===0?this._intPt[0]=new F($):H===0?this._intPt[0]=new F(u):W===0&&(this._intPt[0]=new F(f))):(this._isProper=!0,this._intPt[0]=this.intersection(u,f,p,$)),s.POINT_INTERSECTION)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.nearestEndpoint=function(u,f,p,$){var q=u,M=EA.distancePointLine(u,p,$),H=EA.distancePointLine(f,p,$);return H0?u>0?-p:p:u>0?p:-p;if(a===0||u===0)return f>0?s>0?p:-p:s>0?-p:p;if(a>0?f>0?a<=f||(p=-p,$=s,s=u,u=$,$=a,a=f,f=$):a<=-f?(p=-p,u=-u,f=-f):($=s,s=-u,u=$,$=a,a=-f,f=$):f>0?-a<=f?(p=-p,s=-s,a=-a):($=-s,s=u,u=$,$=-a,a=f,f=$):a>=f?(s=-s,a=-a,u=-u,f=-f):(p=-p,$=-s,s=-u,u=$,$=-a,a=-f,f=$),s>0){if(!(u>0)||!(s<=u))return p}else{if(u>0||!(s>=u))return-p;p=-p,s=-s,u=-u}for(;;){if(q=Math.floor(u/s),u-=q*s,(f-=q*a)<0)return-p;if(f>a)return p;if(s>u+u){if(af+f)return-p;u=s-u,f=a-f,p=-p}if(f===0)return u===0?0:-p;if(u===0||(q=Math.floor(s/u),s-=q*u,(a-=q*f)<0))return p;if(a>f)return-p;if(u>s+s){if(fa+a)return p;s=u-s,a=f-a,p=-p}if(a===0)return s===0?0:p;if(s===0)return-p}};var bt=function(){this._p=null,this._crossingCount=0,this._isPointOnSegment=!1;var s=arguments[0];this._p=s};bt.prototype.countSegment=function(s,a){if(s.xf&&(u=a.x,f=s.x),this._p.x>=u&&this._p.x<=f&&(this._isPointOnSegment=!0),null}if(s.y>this._p.y&&a.y<=this._p.y||a.y>this._p.y&&s.y<=this._p.y){var p=s.x-this._p.x,$=s.y-this._p.y,q=a.x-this._p.x,M=a.y-this._p.y,H=RA.signOfDet2x2(p,$,q,M);if(H===0)return this._isPointOnSegment=!0,null;M<$&&(H=-H),H>0&&this._crossingCount++}},bt.prototype.isPointInPolygon=function(){return this.getLocation()!==T.EXTERIOR},bt.prototype.getLocation=function(){return this._isPointOnSegment?T.BOUNDARY:this._crossingCount%2==1?T.INTERIOR:T.EXTERIOR},bt.prototype.isOnSegment=function(){return this._isPointOnSegment},bt.prototype.interfaces_=function(){return[]},bt.prototype.getClass=function(){return bt},bt.locatePointInRing=function(){if(arguments[0]instanceof F&&b(arguments[1],SA)){for(var s=arguments[0],a=arguments[1],u=new bt(s),f=new F,p=new F,$=1;$1||M<0||M>1)&&(p=!0)}}else p=!0;return p?jA.min(EA.distancePointLine(s,u,f),EA.distancePointLine(a,u,f),EA.distancePointLine(u,s,a),EA.distancePointLine(f,s,a)):0},EA.isPointInRing=function(s,a){return EA.locatePointInRing(s,a)!==T.EXTERIOR},EA.computeLength=function(s){var a=s.size();if(a<=1)return 0;var u=0,f=new F;s.getCoordinate(0,f);for(var p=f.x,$=f.y,q=1;qu.y&&(u=$,f=p)}var q=f;do(q-=1)<0&&(q=a);while(s[q].equals2D(u)&&q!==f);var M=f;do M=(M+1)%a;while(s[M].equals2D(u)&&M!==f);var H=s[q],W=s[M];if(H.equals2D(u)||W.equals2D(u)||H.equals2D(W))return!1;var oA=EA.computeOrientation(H,u,W),cA=!1;return cA=oA===0?H.x>W.x:oA>0,cA},EA.locatePointInRing=function(s,a){return bt.locatePointInRing(s,a)},EA.distancePointLinePerpendicular=function(s,a,u){var f=(u.x-a.x)*(u.x-a.x)+(u.y-a.y)*(u.y-a.y),p=((a.y-s.y)*(u.x-a.x)-(a.x-s.x)*(u.y-a.y))/f;return Math.abs(p)*Math.sqrt(f)},EA.computeOrientation=function(s,a,u){return EA.orientationIndex(s,a,u)},EA.distancePointLine=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];if(a.length===0)throw new G("Line array must contain at least one vertex");for(var u=s.distance(a[0]),f=0;f=1)return $.distance(M);var oA=((q.y-$.y)*(M.x-q.x)-(q.x-$.x)*(M.y-q.y))/H;return Math.abs(oA)*Math.sqrt(H)}},EA.isOnLine=function(s,a){for(var u=new PA,f=1;f0},V.prototype.interfaces_=function(){return[P]},V.prototype.getClass=function(){return V};var U=function(){};U.prototype.isInBoundary=function(s){return s>1},U.prototype.interfaces_=function(){return[P]},U.prototype.getClass=function(){return U};var lA=function(){};lA.prototype.isInBoundary=function(s){return s===1},lA.prototype.interfaces_=function(){return[P]},lA.prototype.getClass=function(){return lA};var rA=function(){};rA.prototype.add=function(){},rA.prototype.addAll=function(){},rA.prototype.isEmpty=function(){},rA.prototype.iterator=function(){},rA.prototype.size=function(){},rA.prototype.toArray=function(){},rA.prototype.remove=function(){},(j.prototype=new Error).name="IndexOutOfBoundsException";var hA=function(){};hA.prototype.hasNext=function(){},hA.prototype.next=function(){},hA.prototype.remove=function(){};var uA=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.get=function(){},a.prototype.set=function(){},a.prototype.isEmpty=function(){},a}(rA);(e.prototype=new Error).name="NoSuchElementException";var nA=function(s){function a(){s.call(this),this.array_=[],arguments[0]instanceof rA&&this.addAll(arguments[0])}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.ensureCapacity=function(){},a.prototype.interfaces_=function(){return[s,rA]},a.prototype.add=function(u){return arguments.length===1?this.array_.push(u):this.array_.splice(arguments[0],arguments[1]),!0},a.prototype.clear=function(){this.array_=[]},a.prototype.addAll=function(u){for(var f=u.iterator();f.hasNext();)this.add(f.next());return!0},a.prototype.set=function(u,f){var p=this.array_[u];return this.array_[u]=f,p},a.prototype.iterator=function(){return new sA(this)},a.prototype.get=function(u){if(u<0||u>=this.size())throw new j;return this.array_[u]},a.prototype.isEmpty=function(){return this.array_.length===0},a.prototype.size=function(){return this.array_.length},a.prototype.toArray=function(){for(var u=[],f=0,p=this.array_.length;f=1&&this.get(this.size()-1).equals2D(q))return null;s.prototype.add.call(this,q)}else if(arguments[0]instanceof Object&&typeof arguments[1]=="boolean"){var M=arguments[0],H=arguments[1];return this.add(M,H),!0}}else if(arguments.length===3){if(typeof arguments[2]=="boolean"&&arguments[0]instanceof Array&&typeof arguments[1]=="boolean"){var W=arguments[0],oA=arguments[1];if(arguments[2])for(var cA=0;cA=0;yA--)this.add(W[yA],oA);return!0}if(typeof arguments[2]=="boolean"&&Number.isInteger(arguments[0])&&arguments[1]instanceof F){var vA=arguments[0],IA=arguments[1];if(!arguments[2]){var DA=this.size();if(DA>0&&(vA>0&&this.get(vA-1).equals2D(IA)||vANi&&(Vs=-1);for(var U_=Br;U_!==Ni;U_+=Vs)this.add(Jt[U_],Yj);return!0}},a.prototype.closeRing=function(){this.size()>0&&this.add(new F(this.get(0)),!1)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},Object.defineProperties(a,u),a}(nA),BA=function(){},tt={ForwardComparator:{configurable:!0},BidirectionalComparator:{configurable:!0},coordArrayType:{configurable:!0}};tt.ForwardComparator.get=function(){return UA},tt.BidirectionalComparator.get=function(){return wt},tt.coordArrayType.get=function(){return new Array(0).fill(null)},BA.prototype.interfaces_=function(){return[]},BA.prototype.getClass=function(){return BA},BA.isRing=function(s){return!(s.length<4)&&!!s[0].equals2D(s[s.length-1])},BA.ptNotInList=function(s,a){for(var u=0;u=s?a:[]},BA.indexOf=function(s,a){for(var u=0;u0)&&(a=s[u]);return a},BA.extract=function(s,a,u){a=jA.clamp(a,0,s.length);var f=(u=jA.clamp(u,-1,s.length))-a+1;u<0&&(f=0),a>=s.length&&(f=0),uf.length)return 1;if(u.length===0)return 0;var p=BA.compare(u,f);return BA.isEqualReversed(u,f)?0:p},wt.prototype.OLDcompare=function(s,a){var u=s,f=a;if(u.lengthf.length)return 1;if(u.length===0)return 0;for(var p=BA.increasingDirection(u),$=BA.increasingDirection(f),q=p>0?0:u.length-1,M=$>0?0:u.length-1,H=0;H0))return a.value;a=a.right}}return null},h.prototype.put=function(s,a){if(this.root_===null)return this.root_={key:s,value:a,left:null,right:null,parent:null,color:dj,getValue:function(){return this.value},getKey:function(){return this.key}},this.size_=1,null;var u,f,p=this.root_;do if(u=p,(f=s.compareTo(p.key))<0)p=p.left;else{if(!(f>0)){var $=p.value;return p.value=a,$}p=p.right}while(p!==null);var q={key:s,left:null,right:null,value:a,parent:u,color:dj,getValue:function(){return this.value},getKey:function(){return this.key}};return f<0?u.left=q:u.right=q,this.fixAfterInsertion(q),this.size_++,null},h.prototype.fixAfterInsertion=function(s){for(s.color=1;s!=null&&s!==this.root_&&s.parent.color===1;)if(o(s)===c(o(o(s)))){var a=B(o(o(s)));i(a)===1?(l(o(s),dj),l(a,dj),l(o(o(s)),1),s=o(o(s))):(s===B(o(s))&&(s=o(s),this.rotateLeft(s)),l(o(s),dj),l(o(o(s)),1),this.rotateRight(o(o(s))))}else{var u=c(o(o(s)));i(u)===1?(l(o(s),dj),l(u,dj),l(o(o(s)),1),s=o(o(s))):(s===c(o(s))&&(s=o(s),this.rotateRight(s)),l(o(s),dj),l(o(o(s)),1),this.rotateLeft(o(o(s))))}this.root_.color=dj},h.prototype.values=function(){var s=new nA,a=this.getFirstEntry();if(a!==null)for(s.add(a.value);(a=h.successor(a))!==null;)s.add(a.value);return s},h.prototype.entrySet=function(){var s=new Lj,a=this.getFirstEntry();if(a!==null)for(s.add(a);(a=h.successor(a))!==null;)s.add(a);return s},h.prototype.rotateLeft=function(s){if(s!=null){var a=s.right;s.right=a.left,a.left!=null&&(a.left.parent=s),a.parent=s.parent,s.parent===null?this.root_=a:s.parent.left===s?s.parent.left=a:s.parent.right=a,a.left=s,s.parent=a}},h.prototype.rotateRight=function(s){if(s!=null){var a=s.left;s.left=a.right,a.right!=null&&(a.right.parent=s),a.parent=s.parent,s.parent===null?this.root_=a:s.parent.right===s?s.parent.right=a:s.parent.left=a,a.right=s,s.parent=a}},h.prototype.getFirstEntry=function(){var s=this.root_;if(s!=null)for(;s.left!=null;)s=s.left;return s},h.successor=function(s){if(s===null)return null;if(s.right!==null){for(var a=s.right;a.left!==null;)a=a.left;return a}for(var u=s.parent,f=s;u!==null&&f===u.right;)f=u,u=u.parent;return u},h.prototype.size=function(){return this.size_};var Cj=function(){};Cj.prototype.interfaces_=function(){return[]},Cj.prototype.getClass=function(){return Cj},d.prototype=new n,(k.prototype=new d).contains=function(s){for(var a=0,u=this.array_.length;a=0;){var q=p.substring(0,$);f.add(q),$=(p=p.substring($+u)).indexOf(a)}p.length>0&&f.add(p);for(var M=new Array(f.size()).fill(null),H=0;H0)for(var $=p;$0&&f.append(" ");for(var $=0;$0&&f.append(","),f.append(ue.toString(s.getOrdinate(p,$)))}return f.append(")"),f.toString()}},uj.ensureValidRing=function(s,a){var u=a.size();return u===0?a:u<=3?uj.createClosedRing(s,a,4):a.getOrdinate(0,SA.X)===a.getOrdinate(u-1,SA.X)&&a.getOrdinate(0,SA.Y)===a.getOrdinate(u-1,SA.Y)?a:uj.createClosedRing(s,a,u+1)},uj.createClosedRing=function(s,a,u){var f=s.create(u,a.getDimension()),p=a.size();uj.copy(a,0,f,0,p);for(var $=p;$0&&uj.reverse(this._points),null}},a.prototype.getCoordinate=function(){return this.isEmpty()?null:this._points.getCoordinate(0)},a.prototype.getBoundaryDimension=function(){return this.isClosed()?jt.FALSE:0},a.prototype.isClosed=function(){return!this.isEmpty()&&this.getCoordinateN(0).equals2D(this.getCoordinateN(this.getNumPoints()-1))},a.prototype.getEndPoint=function(){return this.isEmpty()?null:this.getPointN(this.getNumPoints()-1)},a.prototype.getDimension=function(){return 1},a.prototype.getLength=function(){return EA.computeLength(this._points)},a.prototype.getNumPoints=function(){return this._points.size()},a.prototype.reverse=function(){var f=this._points.copy();return uj.reverse(f),this.getFactory().createLineString(f)},a.prototype.compareToSameClass=function(){if(arguments.length===1){for(var f=arguments[0],p=0,$=0;p= 2)");this._points=f},a.prototype.isCoordinate=function(f){for(var p=0;p=1&&this.getCoordinateSequence().size()= 4)")},a.prototype.getGeometryType=function(){return"LinearRing"},a.prototype.copy=function(){return new a(this._points.copy(),this._factory)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},u.MINIMUM_VALID_SIZE.get=function(){return 4},u.serialVersionUID.get=function(){return-0x3b229e262367a600},Object.defineProperties(a,u),a}(Bj),xe=function(s){function a(){s.apply(this,arguments)}s&&(a.__proto__=s),(a.prototype=Object.create(s&&s.prototype)).constructor=a;var u={serialVersionUID:{configurable:!0}};return a.prototype.getSortIndex=function(){return MA.SORTINDEX_MULTIPOLYGON},a.prototype.equalsExact=function(){if(arguments.length===2){var f=arguments[0],p=arguments[1];return!!this.isEquivalentClass(f)&&s.prototype.equalsExact.call(this,f,p)}return s.prototype.equalsExact.apply(this,arguments)},a.prototype.getBoundaryDimension=function(){return 1},a.prototype.getDimension=function(){return 2},a.prototype.reverse=function(){for(var f=this._geometries.length,p=new Array(f).fill(null),$=0;$0?a.createPoint(u[0]):a.createPoint():s},t7.prototype.interfaces_=function(){return[Ie.GeometryEditorOperation]},t7.prototype.getClass=function(){return t7};var j7=function(){};j7.prototype.edit=function(s,a){return s instanceof Pe?a.createLinearRing(this.edit(s.getCoordinateSequence(),s)):s instanceof Bj?a.createLineString(this.edit(s.getCoordinateSequence(),s)):s instanceof ir?a.createPoint(this.edit(s.getCoordinateSequence(),s)):s},j7.prototype.interfaces_=function(){return[Ie.GeometryEditorOperation]},j7.prototype.getClass=function(){return j7};var fj=function(){if(this._dimension=3,this._coordinates=null,arguments.length===1){if(arguments[0]instanceof Array)this._coordinates=arguments[0],this._dimension=3;else if(Number.isInteger(arguments[0])){var s=arguments[0];this._coordinates=new Array(s).fill(null);for(var a=0;a0){var s=new dA(17*this._coordinates.length);s.append("("),s.append(this._coordinates[0]);for(var a=1;a3&&(f=3),f<2?new fj(u):new fj(u,f)}},Yr.prototype.interfaces_=function(){return[X,A]},Yr.prototype.getClass=function(){return Yr},Yr.instance=function(){return Yr.instanceObject},yl.serialVersionUID.get=function(){return-0x38e49fa6cf6f2e00},yl.instanceObject.get=function(){return new Yr},Object.defineProperties(Yr,yl);var lu=function(s){function a(){s.call(this),this.map_=new Map}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.get=function(u){return this.map_.get(u)||null},a.prototype.put=function(u,f){return this.map_.set(u,f),f},a.prototype.values=function(){for(var u=new nA,f=this.map_.values(),p=f.next();!p.done;)u.add(p.value),p=f.next();return u},a.prototype.entrySet=function(){var u=new Lj;return this.map_.entries().forEach(function(f){return u.add(f)}),u},a.prototype.size=function(){return this.map_.size()},a}(at),Pt=function s(){if(this._modelType=null,this._scale=null,arguments.length===0)this._modelType=s.FLOATING;else if(arguments.length===1){if(arguments[0]instanceof Gr){var a=arguments[0];this._modelType=a,a===s.FIXED&&this.setScale(1)}else if(typeof arguments[0]=="number"){var u=arguments[0];this._modelType=s.FIXED,this.setScale(u)}else if(arguments[0]instanceof s){var f=arguments[0];this._modelType=f._modelType,this._scale=f._scale}}},vl={serialVersionUID:{configurable:!0},maximumPreciseValue:{configurable:!0}};Pt.prototype.equals=function(s){if(!(s instanceof Pt))return!1;var a=s;return this._modelType===a._modelType&&this._scale===a._scale},Pt.prototype.compareTo=function(s){var a=s,u=this.getMaximumSignificantDigits(),f=a.getMaximumSignificantDigits();return new $A(u).compareTo(new $A(f))},Pt.prototype.getScale=function(){return this._scale},Pt.prototype.isFloating=function(){return this._modelType===Pt.FLOATING||this._modelType===Pt.FLOATING_SINGLE},Pt.prototype.getType=function(){return this._modelType},Pt.prototype.toString=function(){var s="UNKNOWN";return this._modelType===Pt.FLOATING?s="Floating":this._modelType===Pt.FLOATING_SINGLE?s="Floating-Single":this._modelType===Pt.FIXED&&(s="Fixed (Scale="+this.getScale()+")"),s},Pt.prototype.makePrecise=function(){if(typeof arguments[0]=="number"){var s=arguments[0];return v.isNaN(s)||this._modelType===Pt.FLOATING_SINGLE?s:this._modelType===Pt.FIXED?Math.round(s*this._scale)/this._scale:s}if(arguments[0]instanceof F){var a=arguments[0];if(this._modelType===Pt.FLOATING)return null;a.x=this.makePrecise(a.x),a.y=this.makePrecise(a.y)}},Pt.prototype.getMaximumSignificantDigits=function(){var s=16;return this._modelType===Pt.FLOATING?s=16:this._modelType===Pt.FLOATING_SINGLE?s=6:this._modelType===Pt.FIXED&&(s=1+Math.trunc(Math.ceil(Math.log(this.getScale())/Math.log(10)))),s},Pt.prototype.setScale=function(s){this._scale=Math.abs(s)},Pt.prototype.interfaces_=function(){return[A,w]},Pt.prototype.getClass=function(){return Pt},Pt.mostPrecise=function(s,a){return s.compareTo(a)>=0?s:a},vl.serialVersionUID.get=function(){return 7777263578777804e3},vl.maximumPreciseValue.get=function(){return 9007199254740992},Object.defineProperties(Pt,vl);var Gr=function s(a){this._name=a||null,s.nameToTypeMap.put(a,this)},ri={serialVersionUID:{configurable:!0},nameToTypeMap:{configurable:!0}};Gr.prototype.readResolve=function(){return Gr.nameToTypeMap.get(this._name)},Gr.prototype.toString=function(){return this._name},Gr.prototype.interfaces_=function(){return[A]},Gr.prototype.getClass=function(){return Gr},ri.serialVersionUID.get=function(){return-552860263173159e4},ri.nameToTypeMap.get=function(){return new lu},Object.defineProperties(Gr,ri),Pt.Type=Gr,Pt.FIXED=new Gr("FIXED"),Pt.FLOATING=new Gr("FLOATING"),Pt.FLOATING_SINGLE=new Gr("FLOATING SINGLE");var Et=function s(){this._precisionModel=new Pt,this._SRID=0,this._coordinateSequenceFactory=s.getDefaultCoordinateSequenceFactory(),arguments.length===0||(arguments.length===1?b(arguments[0],X)?this._coordinateSequenceFactory=arguments[0]:arguments[0]instanceof Pt&&(this._precisionModel=arguments[0]):arguments.length===2?(this._precisionModel=arguments[0],this._SRID=arguments[1]):arguments.length===3&&(this._precisionModel=arguments[0],this._SRID=arguments[1],this._coordinateSequenceFactory=arguments[2]))},nh={serialVersionUID:{configurable:!0}};Et.prototype.toGeometry=function(s){return s.isNull()?this.createPoint(null):s.getMinX()===s.getMaxX()&&s.getMinY()===s.getMaxY()?this.createPoint(new F(s.getMinX(),s.getMinY())):s.getMinX()===s.getMaxX()||s.getMinY()===s.getMaxY()?this.createLineString([new F(s.getMinX(),s.getMinY()),new F(s.getMaxX(),s.getMaxY())]):this.createPolygon(this.createLinearRing([new F(s.getMinX(),s.getMinY()),new F(s.getMinX(),s.getMaxY()),new F(s.getMaxX(),s.getMaxY()),new F(s.getMaxX(),s.getMinY()),new F(s.getMinX(),s.getMinY())]),null)},Et.prototype.createLineString=function(s){return s?s instanceof Array?new Bj(this.getCoordinateSequenceFactory().create(s),this):b(s,SA)?new Bj(s,this):void 0:new Bj(this.getCoordinateSequenceFactory().create([]),this)},Et.prototype.createMultiLineString=function(){if(arguments.length===0)return new br(null,this);if(arguments.length===1){var s=arguments[0];return new br(s,this)}},Et.prototype.buildGeometry=function(s){for(var a=null,u=!1,f=!1,p=s.iterator();p.hasNext();){var $=p.next(),q=$.getClass();a===null&&(a=q),q!==a&&(u=!0),$.isGeometryCollectionOrDerived()&&(f=!0)}if(a===null)return this.createGeometryCollection();if(u||f)return this.createGeometryCollection(Et.toGeometryArray(s));var M=s.iterator().next();if(s.size()>1){if(M instanceof Qt)return this.createMultiPolygon(Et.toPolygonArray(s));if(M instanceof Bj)return this.createMultiLineString(Et.toLineStringArray(s));if(M instanceof ir)return this.createMultiPoint(Et.toPointArray(s));KA.shouldNeverReachHere("Unhandled class: "+M.getClass().getName())}return M},Et.prototype.createMultiPointFromCoords=function(s){return this.createMultiPoint(s!==null?this.getCoordinateSequenceFactory().create(s):null)},Et.prototype.createPoint=function(){if(arguments.length===0)return this.createPoint(this.getCoordinateSequenceFactory().create([]));if(arguments.length===1){if(arguments[0]instanceof F){var s=arguments[0];return this.createPoint(s!==null?this.getCoordinateSequenceFactory().create([s]):null)}if(b(arguments[0],SA)){var a=arguments[0];return new ir(a,this)}}},Et.prototype.getCoordinateSequenceFactory=function(){return this._coordinateSequenceFactory},Et.prototype.createPolygon=function(){if(arguments.length===0)return new Qt(null,null,this);if(arguments.length===1){if(b(arguments[0],SA)){var s=arguments[0];return this.createPolygon(this.createLinearRing(s))}if(arguments[0]instanceof Array){var a=arguments[0];return this.createPolygon(this.createLinearRing(a))}if(arguments[0]instanceof Pe){var u=arguments[0];return this.createPolygon(u,null)}}else if(arguments.length===2){var f=arguments[0],p=arguments[1];return new Qt(f,p,this)}},Et.prototype.getSRID=function(){return this._SRID},Et.prototype.createGeometryCollection=function(){if(arguments.length===0)return new oj(null,this);if(arguments.length===1){var s=arguments[0];return new oj(s,this)}},Et.prototype.createGeometry=function(s){return new Ie(this).edit(s,{edit:function(){if(arguments.length===2){var a=arguments[0];return this._coordinateSequenceFactory.create(a)}}})},Et.prototype.getPrecisionModel=function(){return this._precisionModel},Et.prototype.createLinearRing=function(){if(arguments.length===0)return this.createLinearRing(this.getCoordinateSequenceFactory().create([]));if(arguments.length===1){if(arguments[0]instanceof Array){var s=arguments[0];return this.createLinearRing(s!==null?this.getCoordinateSequenceFactory().create(s):null)}if(b(arguments[0],SA)){var a=arguments[0];return new Pe(a,this)}}},Et.prototype.createMultiPolygon=function(){if(arguments.length===0)return new xe(null,this);if(arguments.length===1){var s=arguments[0];return new xe(s,this)}},Et.prototype.createMultiPoint=function(){if(arguments.length===0)return new M6(null,this);if(arguments.length===1){if(arguments[0]instanceof Array){var s=arguments[0];return new M6(s,this)}if(arguments[0]instanceof Array){var a=arguments[0];return this.createMultiPoint(a!==null?this.getCoordinateSequenceFactory().create(a):null)}if(b(arguments[0],SA)){var u=arguments[0];if(u===null)return this.createMultiPoint(new Array(0).fill(null));for(var f=new Array(u.size()).fill(null),p=0;p=this.size())throw new Error;return this.array_[s]},m.prototype.push=function(s){return this.array_.push(s),s},m.prototype.pop=function(s){if(this.array_.length===0)throw new E;return this.array_.pop()},m.prototype.peek=function(){if(this.array_.length===0)throw new E;return this.array_[this.array_.length-1]},m.prototype.empty=function(){return this.array_.length===0},m.prototype.isEmpty=function(){return this.empty()},m.prototype.search=function(s){return this.array_.indexOf(s)},m.prototype.size=function(){return this.array_.length},m.prototype.toArray=function(){for(var s=[],a=0,u=this.array_.length;a0&&this._minIndexthis._minCoord.y&&u.y>this._minCoord.y&&f===EA.CLOCKWISE)&&(p=!0),p&&(this._minIndex=this._minIndex-1)},gA.prototype.getRightmostSideOfSegment=function(s,a){var u=s.getEdge().getCoordinates();if(a<0||a+1>=u.length||u[a].y===u[a+1].y)return-1;var f=D.LEFT;return u[a].ythis._minCoord.x)&&(this._minDe=s,this._minIndex=u,this._minCoord=a[u])},gA.prototype.findRightmostEdgeAtNode=function(){var s=this._minDe.getNode().getEdges();this._minDe=s.getRightmostEdge(),this._minDe.isForward()||(this._minDe=this._minDe.getSym(),this._minIndex=this._minDe.getEdge().getCoordinates().length-1)},gA.prototype.findEdge=function(s){for(var a=s.iterator();a.hasNext();){var u=a.next();u.isForward()&&this.checkForRightmostCoordinate(u)}KA.isTrue(this._minIndex!==0||this._minCoord.equals(this._minDe.getCoordinate()),"inconsistency in rightmost processing"),this._minIndex===0?this.findRightmostEdgeAtNode():this.findRightmostEdgeAtVertex(),this._orientedDe=this._minDe,this.getRightmostSide(this._minDe,this._minIndex)===D.LEFT&&(this._orientedDe=this._minDe.getSym())},gA.prototype.interfaces_=function(){return[]},gA.prototype.getClass=function(){return gA};var bA=function(s){function a(u,f){s.call(this,a.msgWithCoord(u,f)),this.pt=f?new F(f):null,this.name="TopologyException"}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.getCoordinate=function(){return this.pt},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.msgWithCoord=function(u,f){return f?u:u+" [ "+f+" ]"},a}(ce),Ft=function(){this.array_=[]};Ft.prototype.addLast=function(s){this.array_.push(s)},Ft.prototype.removeFirst=function(){return this.array_.shift()},Ft.prototype.isEmpty=function(){return this.array_.length===0};var Xt=function(){this._finder=null,this._dirEdgeList=new nA,this._nodes=new nA,this._rightMostCoord=null,this._env=null,this._finder=new gA};Xt.prototype.clearVisitedEdges=function(){for(var s=this._dirEdgeList.iterator();s.hasNext();)s.next().setVisited(!1)},Xt.prototype.getRightmostCoordinate=function(){return this._rightMostCoord},Xt.prototype.computeNodeDepth=function(s){for(var a=null,u=s.getEdges().iterator();u.hasNext();){var f=u.next();if(f.isVisited()||f.getSym().isVisited()){a=f;break}}if(a===null)throw new bA("unable to find edge to compute depths at "+s.getCoordinate());s.getEdges().computeDepths(a);for(var p=s.getEdges().iterator();p.hasNext();){var $=p.next();$.setVisited(!0),this.copySymDepths($)}},Xt.prototype.computeDepth=function(s){this.clearVisitedEdges();var a=this._finder.getEdge();a.setEdgeDepths(D.RIGHT,s),this.copySymDepths(a),this.computeDepths(a)},Xt.prototype.create=function(s){this.addReachable(s),this._finder.findEdge(this._dirEdgeList),this._rightMostCoord=this._finder.getCoordinate()},Xt.prototype.findResultEdges=function(){for(var s=this._dirEdgeList.iterator();s.hasNext();){var a=s.next();a.getDepth(D.RIGHT)>=1&&a.getDepth(D.LEFT)<=0&&!a.isInteriorAreaEdge()&&a.setInResult(!0)}},Xt.prototype.computeDepths=function(s){var a=new Lj,u=new Ft,f=s.getNode();for(u.addLast(f),a.add(f),s.setVisited(!0);!u.isEmpty();){var p=u.removeFirst();a.add(p),this.computeNodeDepth(p);for(var $=p.getEdges().iterator();$.hasNext();){var q=$.next().getSym();if(!q.isVisited()){var M=q.getNode();a.contains(M)||(u.addLast(M),a.add(M))}}}},Xt.prototype.compareTo=function(s){var a=s;return this._rightMostCoord.xa._rightMostCoord.x?1:0},Xt.prototype.getEnvelope=function(){if(this._env===null){for(var s=new GA,a=this._dirEdgeList.iterator();a.hasNext();)for(var u=a.next().getEdge().getCoordinates(),f=0;fthis.location.length){var a=new Array(3).fill(null);a[D.ON]=this.location[D.ON],a[D.LEFT]=T.NONE,a[D.RIGHT]=T.NONE,this.location=a}for(var u=0;u1&&s.append(T.toLocationSymbol(this.location[D.LEFT])),s.append(T.toLocationSymbol(this.location[D.ON])),this.location.length>1&&s.append(T.toLocationSymbol(this.location[D.RIGHT])),s.toString()},ut.prototype.setLocations=function(s,a,u){this.location[D.ON]=s,this.location[D.LEFT]=a,this.location[D.RIGHT]=u},ut.prototype.get=function(s){return s1},ut.prototype.isAnyNull=function(){for(var s=0;sthis._maxNodeDegree&&(this._maxNodeDegree=a),s=this.getNext(s)}while(s!==this._startDe);this._maxNodeDegree*=2},Yt.prototype.addPoints=function(s,a,u){var f=s.getCoordinates();if(a){var p=1;u&&(p=0);for(var $=p;$=0;M--)this._pts.add(f[M])}},Yt.prototype.isHole=function(){return this._isHole},Yt.prototype.setInResult=function(){var s=this._startDe;do s.getEdge().setInResult(!0),s=s.getNext();while(s!==this._startDe)},Yt.prototype.containsPoint=function(s){var a=this.getLinearRing();if(!a.getEnvelopeInternal().contains(s)||!EA.isPointInRing(s,a.getCoordinates()))return!1;for(var u=this._holes.iterator();u.hasNext();)if(u.next().containsPoint(s))return!1;return!0},Yt.prototype.addHole=function(s){this._holes.add(s)},Yt.prototype.isShell=function(){return this._shell===null},Yt.prototype.getLabel=function(){return this._label},Yt.prototype.getEdges=function(){return this._edges},Yt.prototype.getMaxNodeDegree=function(){return this._maxNodeDegree<0&&this.computeMaxNodeDegree(),this._maxNodeDegree},Yt.prototype.getShell=function(){return this._shell},Yt.prototype.mergeLabel=function(){if(arguments.length===1){var s=arguments[0];this.mergeLabel(s,0),this.mergeLabel(s,1)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=a.getLocation(u,D.RIGHT);if(f===T.NONE)return null;if(this._label.getLocation(u)===T.NONE)return this._label.setLocation(u,f),null}},Yt.prototype.setShell=function(s){this._shell=s,s!==null&&s.addHole(this)},Yt.prototype.toPolygon=function(s){for(var a=new Array(this._holes.size()).fill(null),u=0;u=2,"found partial label"),this.computeIM(s)},En.prototype.isInResult=function(){return this._isInResult},En.prototype.isVisited=function(){return this._isVisited},En.prototype.interfaces_=function(){return[]},En.prototype.getClass=function(){return En};var fg=function(s){function a(){s.call(this),this._coord=null,this._edges=null;var u=arguments[0],f=arguments[1];this._coord=u,this._edges=f,this._label=new rt(0,T.NONE)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isIncidentEdgeInResult=function(){for(var u=this.getEdges().getEdges().iterator();u.hasNext();)if(u.next().getEdge().isInResult())return!0;return!1},a.prototype.isIsolated=function(){return this._label.getGeometryCount()===1},a.prototype.getCoordinate=function(){return this._coord},a.prototype.print=function(u){u.println("node "+this._coord+" lbl: "+this._label)},a.prototype.computeIM=function(u){},a.prototype.computeMergedLocation=function(u,f){var p=T.NONE;if(p=this._label.getLocation(f),!u.isNull(f)){var $=u.getLocation(f);p!==T.BOUNDARY&&(p=$)}return p},a.prototype.setLabel=function(){if(arguments.length!==2)return s.prototype.setLabel.apply(this,arguments);var u=arguments[0],f=arguments[1];this._label===null?this._label=new rt(u,f):this._label.setLocation(u,f)},a.prototype.getEdges=function(){return this._edges},a.prototype.mergeLabel=function(){if(arguments[0]instanceof a){var u=arguments[0];this.mergeLabel(u._label)}else if(arguments[0]instanceof rt)for(var f=arguments[0],p=0;p<2;p++){var $=this.computeMergedLocation(f,p);this._label.getLocation(p)===T.NONE&&this._label.setLocation(p,$)}},a.prototype.add=function(u){this._edges.insert(u),u.setNode(this)},a.prototype.setLabelBoundary=function(u){if(this._label===null)return null;var f=T.NONE;this._label!==null&&(f=this._label.getLocation(u));var p=null;switch(f){case T.BOUNDARY:p=T.INTERIOR;break;case T.INTERIOR:default:p=T.BOUNDARY}this._label.setLocation(u,p)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(En),ii=function(){this.nodeMap=new h,this.nodeFact=null;var s=arguments[0];this.nodeFact=s};ii.prototype.find=function(s){return this.nodeMap.get(s)},ii.prototype.addNode=function(){if(arguments[0]instanceof F){var s=arguments[0],a=this.nodeMap.get(s);return a===null&&(a=this.nodeFact.createNode(s),this.nodeMap.put(s,a)),a}if(arguments[0]instanceof fg){var u=arguments[0],f=this.nodeMap.get(u.getCoordinate());return f===null?(this.nodeMap.put(u.getCoordinate(),u),u):(f.mergeLabel(u),f)}},ii.prototype.print=function(s){for(var a=this.iterator();a.hasNext();)a.next().print(s)},ii.prototype.iterator=function(){return this.nodeMap.values().iterator()},ii.prototype.values=function(){return this.nodeMap.values()},ii.prototype.getBoundaryNodes=function(s){for(var a=new nA,u=this.iterator();u.hasNext();){var f=u.next();f.getLabel().getLocation(s)===T.BOUNDARY&&a.add(f)}return a},ii.prototype.add=function(s){var a=s.getCoordinate();this.addNode(a).add(s)},ii.prototype.interfaces_=function(){return[]},ii.prototype.getClass=function(){return ii};var tj=function(){},oh={NE:{configurable:!0},NW:{configurable:!0},SW:{configurable:!0},SE:{configurable:!0}};tj.prototype.interfaces_=function(){return[]},tj.prototype.getClass=function(){return tj},tj.isNorthern=function(s){return s===tj.NE||s===tj.NW},tj.isOpposite=function(s,a){return s===a?!1:(s-a+4)%4===2},tj.commonHalfPlane=function(s,a){if(s===a)return s;if((s-a+4)%4===2)return-1;var u=sa?s:a)===3?3:u},tj.isInHalfPlane=function(s,a){return a===tj.SE?s===tj.SE||s===tj.SW:s===a||s===a+1},tj.quadrant=function(){if(typeof arguments[0]=="number"&&typeof arguments[1]=="number"){var s=arguments[0],a=arguments[1];if(s===0&&a===0)throw new G("Cannot compute the quadrant for point ( "+s+", "+a+" )");return s>=0?a>=0?tj.NE:tj.SE:a>=0?tj.NW:tj.SW}if(arguments[0]instanceof F&&arguments[1]instanceof F){var u=arguments[0],f=arguments[1];if(f.x===u.x&&f.y===u.y)throw new G("Cannot compute the quadrant for two identical points "+u);return f.x>=u.x?f.y>=u.y?tj.NE:tj.SE:f.y>=u.y?tj.NW:tj.SW}},oh.NE.get=function(){return 0},oh.NW.get=function(){return 1},oh.SW.get=function(){return 2},oh.SE.get=function(){return 3},Object.defineProperties(tj,oh);var Ve=function(){if(this._edge=null,this._label=null,this._node=null,this._p0=null,this._p1=null,this._dx=null,this._dy=null,this._quadrant=null,arguments.length===1){var s=arguments[0];this._edge=s}else if(arguments.length===3){var a=arguments[0],u=arguments[1],f=arguments[2];this._edge=a,this.init(u,f),this._label=null}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];this._edge=p,this.init($,q),this._label=M}};Ve.prototype.compareDirection=function(s){return this._dx===s._dx&&this._dy===s._dy?0:this._quadrant>s._quadrant?1:this._quadrant2){$.linkDirectedEdgesForMinimalEdgeRings();var q=$.buildMinimalRings(),M=this.findShell(q);M!==null?(this.placePolygonHoles(M,q),a.add(M)):u.addAll(q)}else f.add($)}return f},Jr.prototype.containsPoint=function(s){for(var a=this._shellList.iterator();a.hasNext();)if(a.next().containsPoint(s))return!0;return!1},Jr.prototype.buildMaximalEdgeRings=function(s){for(var a=new nA,u=s.iterator();u.hasNext();){var f=u.next();if(f.isInResult()&&f.getLabel().isArea()&&f.getEdgeRing()===null){var p=new l9(f,this._geometryFactory);a.add(p),p.setInResult()}}return a},Jr.prototype.placePolygonHoles=function(s,a){for(var u=a.iterator();u.hasNext();){var f=u.next();f.isHole()&&f.setShell(s)}},Jr.prototype.getPolygons=function(){return this.computePolygons(this._shellList)},Jr.prototype.findEdgeRingContaining=function(s,a){for(var u=s.getLinearRing(),f=u.getEnvelopeInternal(),p=u.getCoordinateN(0),$=null,q=null,M=a.iterator();M.hasNext();){var H=M.next(),W=H.getLinearRing(),oA=W.getEnvelopeInternal();$!==null&&(q=$.getLinearRing().getEnvelopeInternal());var cA=!1;oA.contains(f)&&EA.isPointInRing(p,W.getCoordinates())&&(cA=!0),cA&&($===null||q.contains(oA))&&($=H)}return $},Jr.prototype.findShell=function(s){for(var a=0,u=null,f=s.iterator();f.hasNext();){var p=f.next();p.isHole()||(u=p,a++)}return KA.isTrue(a<=1,"found two shells in MinimalEdgeRing list"),u},Jr.prototype.add=function(){if(arguments.length===1){var s=arguments[0];this.add(s.getEdgeEnds(),s.getNodes())}else if(arguments.length===2){var a=arguments[0],u=arguments[1];bj.linkResultDirectedEdges(u);var f=this.buildMaximalEdgeRings(a),p=new nA,$=this.buildMinimalEdgeRings(f,this._shellList,p);this.sortShellsAndHoles($,this._shellList,p),this.placeFreeHoles(this._shellList,p)}},Jr.prototype.interfaces_=function(){return[]},Jr.prototype.getClass=function(){return Jr};var uu=function(){};uu.prototype.getBounds=function(){},uu.prototype.interfaces_=function(){return[]},uu.prototype.getClass=function(){return uu};var O6=function(){this._bounds=null,this._item=null;var s=arguments[0],a=arguments[1];this._bounds=s,this._item=a};O6.prototype.getItem=function(){return this._item},O6.prototype.getBounds=function(){return this._bounds},O6.prototype.interfaces_=function(){return[uu,A]},O6.prototype.getClass=function(){return O6};var To=function(){this._size=null,this._items=null,this._size=0,this._items=new nA,this._items.add(null)};To.prototype.poll=function(){if(this.isEmpty())return null;var s=this._items.get(1);return this._items.set(1,this._items.get(this._size)),this._size-=1,this.reorder(1),s},To.prototype.size=function(){return this._size},To.prototype.reorder=function(s){for(var a=null,u=this._items.get(s);2*s<=this._size&&((a=2*s)!==this._size&&this._items.get(a+1).compareTo(this._items.get(a))<0&&a++,this._items.get(a).compareTo(u)<0);s=a)this._items.set(s,this._items.get(a));this._items.set(s,u)},To.prototype.clear=function(){this._size=0,this._items.clear()},To.prototype.isEmpty=function(){return this._size===0},To.prototype.add=function(s){this._items.add(null),this._size+=1;var a=this._size;for(this._items.set(0,s);s.compareTo(this._items.get(Math.trunc(a/2)))<0;a/=2)this._items.set(a,this._items.get(Math.trunc(a/2)));this._items.set(a,s)},To.prototype.interfaces_=function(){return[]},To.prototype.getClass=function(){return To};var Rs=function(){};Rs.prototype.visitItem=function(s){},Rs.prototype.interfaces_=function(){return[]},Rs.prototype.getClass=function(){return Rs};var ql=function(){};ql.prototype.insert=function(s,a){},ql.prototype.remove=function(s,a){},ql.prototype.query=function(){},ql.prototype.interfaces_=function(){return[]},ql.prototype.getClass=function(){return ql};var je=function(){if(this._childBoundables=new nA,this._bounds=null,this._level=null,arguments.length!==0){if(arguments.length===1){var s=arguments[0];this._level=s}}},i8={serialVersionUID:{configurable:!0}};je.prototype.getLevel=function(){return this._level},je.prototype.size=function(){return this._childBoundables.size()},je.prototype.getChildBoundables=function(){return this._childBoundables},je.prototype.addChildBoundable=function(s){KA.isTrue(this._bounds===null),this._childBoundables.add(s)},je.prototype.isEmpty=function(){return this._childBoundables.isEmpty()},je.prototype.getBounds=function(){return this._bounds===null&&(this._bounds=this.computeBounds()),this._bounds},je.prototype.interfaces_=function(){return[uu,A]},je.prototype.getClass=function(){return je},i8.serialVersionUID.get=function(){return 6493722185909574e3},Object.defineProperties(je,i8);var T6=function(){};T6.reverseOrder=function(){return{compare:function(s,a){return a.compareTo(s)}}},T6.min=function(s){return T6.sort(s),s.get(0)},T6.sort=function(s,a){var u=s.toArray();a?vj.sort(u,a):vj.sort(u);for(var f=s.iterator(),p=0,$=u.length;p<$;p++)f.next(),f.set(u[p])},T6.singletonList=function(s){var a=new nA;return a.add(s),a};var Qj=function(){this._boundable1=null,this._boundable2=null,this._distance=null,this._itemDistance=null;var s=arguments[0],a=arguments[1],u=arguments[2];this._boundable1=s,this._boundable2=a,this._itemDistance=u,this._distance=this.distance()};Qj.prototype.expandToQueue=function(s,a){var u=Qj.isComposite(this._boundable1),f=Qj.isComposite(this._boundable2);if(u&&f)return Qj.area(this._boundable1)>Qj.area(this._boundable2)?(this.expand(this._boundable1,this._boundable2,s,a),null):(this.expand(this._boundable2,this._boundable1,s,a),null);if(u)return this.expand(this._boundable1,this._boundable2,s,a),null;if(f)return this.expand(this._boundable2,this._boundable1,s,a),null;throw new G("neither boundable is composite")},Qj.prototype.isLeaves=function(){return!(Qj.isComposite(this._boundable1)||Qj.isComposite(this._boundable2))},Qj.prototype.compareTo=function(s){var a=s;return this._distancea._distance?1:0},Qj.prototype.expand=function(s,a,u,f){for(var p=s.getChildBoundables().iterator();p.hasNext();){var $=p.next(),q=new Qj($,a,this._itemDistance);q.getDistance()1,"Node capacity must be greater than 1"),this._nodeCapacity=u}},hg={IntersectsOp:{configurable:!0},serialVersionUID:{configurable:!0},DEFAULT_NODE_CAPACITY:{configurable:!0}};ye.prototype.getNodeCapacity=function(){return this._nodeCapacity},ye.prototype.lastNode=function(s){return s.get(s.size()-1)},ye.prototype.size=function(){if(arguments.length===0)return this.isEmpty()?0:(this.build(),this.size(this._root));if(arguments.length===1){for(var s=0,a=arguments[0].getChildBoundables().iterator();a.hasNext();){var u=a.next();u instanceof je?s+=this.size(u):u instanceof O6&&(s+=1)}return s}},ye.prototype.removeItem=function(s,a){for(var u=null,f=s.getChildBoundables().iterator();f.hasNext();){var p=f.next();p instanceof O6&&p.getItem()===a&&(u=p)}return u!==null&&(s.getChildBoundables().remove(u),!0)},ye.prototype.itemsTree=function(){if(arguments.length===0){this.build();var s=this.itemsTree(this._root);return s===null?new nA:s}if(arguments.length===1){for(var a=arguments[0],u=new nA,f=a.getChildBoundables().iterator();f.hasNext();){var p=f.next();if(p instanceof je){var $=this.itemsTree(p);$!==null&&u.add($)}else p instanceof O6?u.add(p.getItem()):KA.shouldNeverReachHere()}return u.size()<=0?null:u}},ye.prototype.insert=function(s,a){KA.isTrue(!this._built,"Cannot insert items into an STR packed R-tree after it has been built."),this._itemBoundables.add(new O6(s,a))},ye.prototype.boundablesAtLevel=function(){if(arguments.length===1){var s=arguments[0],a=new nA;return this.boundablesAtLevel(s,this._root,a),a}if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2];if(KA.isTrue(u>-2),f.getLevel()===u)return p.add(f),null;for(var $=f.getChildBoundables().iterator();$.hasNext();){var q=$.next();q instanceof je?this.boundablesAtLevel(u,q,p):(KA.isTrue(q instanceof O6),u===-1&&p.add(q))}return null}},ye.prototype.query=function(){if(arguments.length===1){var s=arguments[0];this.build();var a=new nA;return this.isEmpty()||this.getIntersectsOp().intersects(this._root.getBounds(),s)&&this.query(s,this._root,a),a}if(arguments.length===2){var u=arguments[0],f=arguments[1];if(this.build(),this.isEmpty())return null;this.getIntersectsOp().intersects(this._root.getBounds(),u)&&this.query(u,this._root,f)}else if(arguments.length===3){if(b(arguments[2],Rs)&&arguments[0]instanceof Object&&arguments[1]instanceof je)for(var p=arguments[0],$=arguments[1],q=arguments[2],M=$.getChildBoundables(),H=0;Hs&&(s=f)}}return s+1}},ye.prototype.createParentBoundables=function(s,a){KA.isTrue(!s.isEmpty());var u=new nA;u.add(this.createNode(a));var f=new nA(s);T6.sort(f,this.getComparator());for(var p=f.iterator();p.hasNext();){var $=p.next();this.lastNode(u).getChildBoundables().size()===this.getNodeCapacity()&&u.add(this.createNode(a)),this.lastNode(u).addChildBoundable($)}return u},ye.prototype.isEmpty=function(){return this._built?this._root.isEmpty():this._itemBoundables.isEmpty()},ye.prototype.interfaces_=function(){return[A]},ye.prototype.getClass=function(){return ye},ye.compareDoubles=function(s,a){return s>a?1:s0);for(var $=new nA,q=0;q0;){var vA=yA.poll(),IA=vA.getDistance();if(IA>=oA)break;vA.isLeaves()?(oA=IA,cA=vA):vA.expandToQueue(yA,oA)}return[cA.getBoundable(0).getItem(),cA.getBoundable(1).getItem()]}}else if(arguments.length===3){var DA=arguments[0],Jt=arguments[1],Yj=arguments[2],Br=new O6(DA,Jt),Ni=new Qj(this.getRoot(),Br,Yj);return this.nearestNeighbour(Ni)[0]}},a.prototype.interfaces_=function(){return[ql,A]},a.prototype.getClass=function(){return a},a.centreX=function(f){return a.avg(f.getMinX(),f.getMaxX())},a.avg=function(f,p){return(f+p)/2},a.centreY=function(f){return a.avg(f.getMinY(),f.getMaxY())},u.STRtreeNode.get=function(){return s8},u.serialVersionUID.get=function(){return 0x39920f7d5f261e0},u.xComparator.get=function(){return{interfaces_:function(){return[O]},compare:function(f,p){return s.compareDoubles(a.centreX(f.getBounds()),a.centreX(p.getBounds()))}}},u.yComparator.get=function(){return{interfaces_:function(){return[O]},compare:function(f,p){return s.compareDoubles(a.centreY(f.getBounds()),a.centreY(p.getBounds()))}}},u.intersectsOp.get=function(){return{interfaces_:function(){return[s.IntersectsOp]},intersects:function(f,p){return f.intersects(p)}}},u.DEFAULT_NODE_CAPACITY.get=function(){return 10},Object.defineProperties(a,u),a}(ye),s8=function(s){function a(){var u=arguments[0];s.call(this,u)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.computeBounds=function(){for(var u=null,f=this.getChildBoundables().iterator();f.hasNext();){var p=f.next();u===null?u=new GA(p.getBounds()):u.expandToInclude(p.getBounds())}return u},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(je),wr=function(){};wr.prototype.interfaces_=function(){return[]},wr.prototype.getClass=function(){return wr},wr.relativeSign=function(s,a){return sa?1:0},wr.compare=function(s,a,u){if(a.equals2D(u))return 0;var f=wr.relativeSign(a.x,u.x),p=wr.relativeSign(a.y,u.y);switch(s){case 0:return wr.compareValue(f,p);case 1:return wr.compareValue(p,f);case 2:return wr.compareValue(p,-f);case 3:return wr.compareValue(-f,p);case 4:return wr.compareValue(-f,-p);case 5:return wr.compareValue(-p,-f);case 6:return wr.compareValue(-p,f);case 7:return wr.compareValue(f,-p)}return KA.shouldNeverReachHere("invalid octant value"),0},wr.compareValue=function(s,a){return s<0?-1:s>0?1:a<0?-1:a>0?1:0};var Ls=function(){this._segString=null,this.coord=null,this.segmentIndex=null,this._segmentOctant=null,this._isInterior=null;var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];this._segString=s,this.coord=new F(a),this.segmentIndex=u,this._segmentOctant=f,this._isInterior=!a.equals2D(s.getCoordinate(u))};Ls.prototype.getCoordinate=function(){return this.coord},Ls.prototype.print=function(s){s.print(this.coord),s.print(" seg # = "+this.segmentIndex)},Ls.prototype.compareTo=function(s){var a=s;return this.segmentIndexa.segmentIndex?1:this.coord.equals2D(a.coord)?0:wr.compare(this._segmentOctant,this.coord,a.coord)},Ls.prototype.isEndPoint=function(s){return this.segmentIndex===0&&!this._isInterior||this.segmentIndex===s},Ls.prototype.isInterior=function(){return this._isInterior},Ls.prototype.interfaces_=function(){return[w]},Ls.prototype.getClass=function(){return Ls};var or=function(){this._nodeMap=new h,this._edge=null;var s=arguments[0];this._edge=s};or.prototype.getSplitCoordinates=function(){var s=new kA;this.addEndpoints();for(var a=this.iterator(),u=a.next();a.hasNext();){var f=a.next();this.addEdgeCoordinates(u,f,s),u=f}return s.toCoordinateArray()},or.prototype.addCollapsedNodes=function(){var s=new nA;this.findCollapsesFromInsertedNodes(s),this.findCollapsesFromExistingVertices(s);for(var a=s.iterator();a.hasNext();){var u=a.next().intValue();this.add(this._edge.getCoordinate(u),u)}},or.prototype.print=function(s){s.println("Intersections:");for(var a=this.iterator();a.hasNext();)a.next().print(s)},or.prototype.findCollapsesFromExistingVertices=function(s){for(var a=0;a=0?a>=0?u>=f?0:1:u>=f?7:6:a>=0?u>=f?3:2:u>=f?4:5}if(arguments[0]instanceof F&&arguments[1]instanceof F){var p=arguments[0],$=arguments[1],q=$.x-p.x,M=$.y-p.y;if(q===0&&M===0)throw new G("Cannot compute the octant for two identical points "+p);return bl.octant(q,M)}};var Oi=function(){};Oi.prototype.getCoordinates=function(){},Oi.prototype.size=function(){},Oi.prototype.getCoordinate=function(s){},Oi.prototype.isClosed=function(){},Oi.prototype.setData=function(s){},Oi.prototype.getData=function(){},Oi.prototype.interfaces_=function(){return[]},Oi.prototype.getClass=function(){return Oi};var sh=function(){};sh.prototype.addIntersection=function(s,a){},sh.prototype.interfaces_=function(){return[Oi]},sh.prototype.getClass=function(){return sh};var Hj=function(){this._nodeList=new or(this),this._pts=null,this._data=null;var s=arguments[0],a=arguments[1];this._pts=s,this._data=a};Hj.prototype.getCoordinates=function(){return this._pts},Hj.prototype.size=function(){return this._pts.length},Hj.prototype.getCoordinate=function(s){return this._pts[s]},Hj.prototype.isClosed=function(){return this._pts[0].equals(this._pts[this._pts.length-1])},Hj.prototype.getSegmentOctant=function(s){return s===this._pts.length-1?-1:this.safeOctant(this.getCoordinate(s),this.getCoordinate(s+1))},Hj.prototype.setData=function(s){this._data=s},Hj.prototype.safeOctant=function(s,a){return s.equals2D(a)?0:bl.octant(s,a)},Hj.prototype.getData=function(){return this._data},Hj.prototype.addIntersection=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];this.addIntersectionNode(s,a)}else if(arguments.length===4){var u=arguments[0],f=arguments[1],p=arguments[3],$=new F(u.getIntersection(p));this.addIntersection($,f)}},Hj.prototype.toString=function(){return cj.toLineString(new fj(this._pts))},Hj.prototype.getNodeList=function(){return this._nodeList},Hj.prototype.addIntersectionNode=function(s,a){var u=a,f=u+1;if(f=0&&u>=0||a<=0&&u<=0?Math.max(a,u):0}if(arguments[0]instanceof F){var f=arguments[0];return EA.orientationIndex(this.p0,this.p1,f)}},CA.prototype.toGeometry=function(s){return s.createLineString([this.p0,this.p1])},CA.prototype.isVertical=function(){return this.p0.x===this.p1.x},CA.prototype.equals=function(s){if(!(s instanceof CA))return!1;var a=s;return this.p0.equals(a.p0)&&this.p1.equals(a.p1)},CA.prototype.intersection=function(s){var a=new PA;return a.computeIntersection(this.p0,this.p1,s.p0,s.p1),a.hasIntersection()?a.getIntersection(0):null},CA.prototype.project=function(){if(arguments[0]instanceof F){var s=arguments[0];if(s.equals(this.p0)||s.equals(this.p1))return new F(s);var a=this.projectionFactor(s),u=new F;return u.x=this.p0.x+a*(this.p1.x-this.p0.x),u.y=this.p0.y+a*(this.p1.y-this.p0.y),u}if(arguments[0]instanceof CA){var f=arguments[0],p=this.projectionFactor(f.p0),$=this.projectionFactor(f.p1);if(p>=1&&$>=1||p<=0&&$<=0)return null;var q=this.project(f.p0);p<0&&(q=this.p0),p>1&&(q=this.p1);var M=this.project(f.p1);return $<0&&(M=this.p0),$>1&&(M=this.p1),new CA(q,M)}},CA.prototype.normalize=function(){this.p1.compareTo(this.p0)<0&&this.reverse()},CA.prototype.angle=function(){return Math.atan2(this.p1.y-this.p0.y,this.p1.x-this.p0.x)},CA.prototype.getCoordinate=function(s){return s===0?this.p0:this.p1},CA.prototype.distancePerpendicular=function(s){return EA.distancePointLinePerpendicular(s,this.p0,this.p1)},CA.prototype.minY=function(){return Math.min(this.p0.y,this.p1.y)},CA.prototype.midPoint=function(){return CA.midPoint(this.p0,this.p1)},CA.prototype.projectionFactor=function(s){if(s.equals(this.p0))return 0;if(s.equals(this.p1))return 1;var a=this.p1.x-this.p0.x,u=this.p1.y-this.p0.y,f=a*a+u*u;return f<=0?v.NaN:((s.x-this.p0.x)*a+(s.y-this.p0.y)*u)/f},CA.prototype.closestPoints=function(s){var a=this.intersection(s);if(a!==null)return[a,a];var u=new Array(2).fill(null),f=v.MAX_VALUE,p=null,$=this.closestPoint(s.p0);f=$.distance(s.p0),u[0]=$,u[1]=s.p0;var q=this.closestPoint(s.p1);(p=q.distance(s.p1))0&&a<1?this.project(s):this.p0.distance(s)1||v.isNaN(a))&&(a=1),a},CA.prototype.toString=function(){return"LINESTRING( "+this.p0.x+" "+this.p0.y+", "+this.p1.x+" "+this.p1.y+")"},CA.prototype.isHorizontal=function(){return this.p0.y===this.p1.y},CA.prototype.distance=function(){if(arguments[0]instanceof CA){var s=arguments[0];return EA.distanceLineLine(this.p0,this.p1,s.p0,s.p1)}if(arguments[0]instanceof F){var a=arguments[0];return EA.distancePointLine(a,this.p0,this.p1)}},CA.prototype.pointAlong=function(s){var a=new F;return a.x=this.p0.x+s*(this.p1.x-this.p0.x),a.y=this.p0.y+s*(this.p1.y-this.p0.y),a},CA.prototype.hashCode=function(){var s=v.doubleToLongBits(this.p0.x);s^=31*v.doubleToLongBits(this.p0.y);var a=Math.trunc(s)^Math.trunc(s>>32),u=v.doubleToLongBits(this.p1.x);return u^=31*v.doubleToLongBits(this.p1.y),a^(Math.trunc(u)^Math.trunc(u>>32))},CA.prototype.interfaces_=function(){return[w,A]},CA.prototype.getClass=function(){return CA},CA.midPoint=function(s,a){return new F((s.x+a.x)/2,(s.y+a.y)/2)},a8.serialVersionUID.get=function(){return 0x2d2172135f411c00},Object.defineProperties(CA,a8);var ah=function(){this.tempEnv1=new GA,this.tempEnv2=new GA,this._overlapSeg1=new CA,this._overlapSeg2=new CA};ah.prototype.overlap=function(){if(arguments.length!==2){if(arguments.length===4){var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];s.getLineSegment(a,this._overlapSeg1),u.getLineSegment(f,this._overlapSeg2),this.overlap(this._overlapSeg1,this._overlapSeg2)}}},ah.prototype.interfaces_=function(){return[]},ah.prototype.getClass=function(){return ah};var Zr=function(){this._pts=null,this._start=null,this._end=null,this._env=null,this._context=null,this._id=null;var s=arguments[0],a=arguments[1],u=arguments[2],f=arguments[3];this._pts=s,this._start=a,this._end=u,this._context=f};Zr.prototype.getLineSegment=function(s,a){a.p0=this._pts[s],a.p1=this._pts[s+1]},Zr.prototype.computeSelect=function(s,a,u,f){var p=this._pts[a],$=this._pts[u];if(f.tempEnv1.init(p,$),u-a==1)return f.select(this,a),null;if(!s.intersects(f.tempEnv1))return null;var q=Math.trunc((a+u)/2);a=s.length-1)return s.length-1;for(var f=tj.quadrant(s[u],s[u+1]),p=a+1;p$.getId()&&($.computeOverlaps(M,f),this._nOverlaps++),this._segInt.isDone())return null}},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},u.SegmentOverlapAction.get=function(){return l8},Object.defineProperties(a,u),a}(lh),l8=function(s){function a(){s.call(this),this._si=null;var u=arguments[0];this._si=u}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.overlap=function(){if(arguments.length!==4)return s.prototype.overlap.apply(this,arguments);var u=arguments[0],f=arguments[1],p=arguments[2],$=arguments[3],q=u.getContext(),M=p.getContext();this._si.processIntersections(q,f,M,$)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(ah),zt=function s(){if(this._quadrantSegments=s.DEFAULT_QUADRANT_SEGMENTS,this._endCapStyle=s.CAP_ROUND,this._joinStyle=s.JOIN_ROUND,this._mitreLimit=s.DEFAULT_MITRE_LIMIT,this._isSingleSided=!1,this._simplifyFactor=s.DEFAULT_SIMPLIFY_FACTOR,arguments.length!==0){if(arguments.length===1){var a=arguments[0];this.setQuadrantSegments(a)}else if(arguments.length===2){var u=arguments[0],f=arguments[1];this.setQuadrantSegments(u),this.setEndCapStyle(f)}else if(arguments.length===4){var p=arguments[0],$=arguments[1],q=arguments[2],M=arguments[3];this.setQuadrantSegments(p),this.setEndCapStyle($),this.setJoinStyle(q),this.setMitreLimit(M)}}},So={CAP_ROUND:{configurable:!0},CAP_FLAT:{configurable:!0},CAP_SQUARE:{configurable:!0},JOIN_ROUND:{configurable:!0},JOIN_MITRE:{configurable:!0},JOIN_BEVEL:{configurable:!0},DEFAULT_QUADRANT_SEGMENTS:{configurable:!0},DEFAULT_MITRE_LIMIT:{configurable:!0},DEFAULT_SIMPLIFY_FACTOR:{configurable:!0}};zt.prototype.getEndCapStyle=function(){return this._endCapStyle},zt.prototype.isSingleSided=function(){return this._isSingleSided},zt.prototype.setQuadrantSegments=function(s){this._quadrantSegments=s,this._quadrantSegments===0&&(this._joinStyle=zt.JOIN_BEVEL),this._quadrantSegments<0&&(this._joinStyle=zt.JOIN_MITRE,this._mitreLimit=Math.abs(this._quadrantSegments)),s<=0&&(this._quadrantSegments=1),this._joinStyle!==zt.JOIN_ROUND&&(this._quadrantSegments=zt.DEFAULT_QUADRANT_SEGMENTS)},zt.prototype.getJoinStyle=function(){return this._joinStyle},zt.prototype.setJoinStyle=function(s){this._joinStyle=s},zt.prototype.setSimplifyFactor=function(s){this._simplifyFactor=s<0?0:s},zt.prototype.getSimplifyFactor=function(){return this._simplifyFactor},zt.prototype.getQuadrantSegments=function(){return this._quadrantSegments},zt.prototype.setEndCapStyle=function(s){this._endCapStyle=s},zt.prototype.getMitreLimit=function(){return this._mitreLimit},zt.prototype.setMitreLimit=function(s){this._mitreLimit=s},zt.prototype.setSingleSided=function(s){this._isSingleSided=s},zt.prototype.interfaces_=function(){return[]},zt.prototype.getClass=function(){return zt},zt.bufferDistanceError=function(s){var a=Math.PI/2/s;return 1-Math.cos(a/2)},So.CAP_ROUND.get=function(){return 1},So.CAP_FLAT.get=function(){return 2},So.CAP_SQUARE.get=function(){return 3},So.JOIN_ROUND.get=function(){return 1},So.JOIN_MITRE.get=function(){return 2},So.JOIN_BEVEL.get=function(){return 3},So.DEFAULT_QUADRANT_SEGMENTS.get=function(){return 8},So.DEFAULT_MITRE_LIMIT.get=function(){return 5},So.DEFAULT_SIMPLIFY_FACTOR.get=function(){return .01},Object.defineProperties(zt,So);var Mj=function(s){this._distanceTol=null,this._isDeleted=null,this._angleOrientation=EA.COUNTERCLOCKWISE,this._inputLine=s||null},ch={INIT:{configurable:!0},DELETE:{configurable:!0},KEEP:{configurable:!0},NUM_PTS_TO_CHECK:{configurable:!0}};Mj.prototype.isDeletable=function(s,a,u,f){var p=this._inputLine[s],$=this._inputLine[a],q=this._inputLine[u];return!!this.isConcave(p,$,q)&&!!this.isShallow(p,$,q,f)&&this.isShallowSampled(p,$,s,u,f)},Mj.prototype.deleteShallowConcavities=function(){for(var s=1,a=this.findNextNonDeletedIndex(s),u=this.findNextNonDeletedIndex(a),f=!1;u=0;f--)this.addPt(s[f])},$n.prototype.isRedundant=function(s){if(this._ptList.size()<1)return!1;var a=this._ptList.get(this._ptList.size()-1);return s.distance(a)Math.PI;)s-=It.PI_TIMES_2;for(;s<=-Math.PI;)s+=It.PI_TIMES_2;return s},It.angle=function(){if(arguments.length===1){var s=arguments[0];return Math.atan2(s.y,s.x)}if(arguments.length===2){var a=arguments[0],u=arguments[1],f=u.x-a.x,p=u.y-a.y;return Math.atan2(p,f)}},It.isAcute=function(s,a,u){var f=s.x-a.x,p=s.y-a.y;return f*(u.x-a.x)+p*(u.y-a.y)>0},It.isObtuse=function(s,a,u){var f=s.x-a.x,p=s.y-a.y;return f*(u.x-a.x)+p*(u.y-a.y)<0},It.interiorAngle=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u);return Math.abs(p-f)},It.normalizePositive=function(s){if(s<0){for(;s<0;)s+=It.PI_TIMES_2;s>=It.PI_TIMES_2&&(s=0)}else{for(;s>=It.PI_TIMES_2;)s-=It.PI_TIMES_2;s<0&&(s=0)}return s},It.angleBetween=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u);return It.diff(f,p)},It.diff=function(s,a){var u=null;return(u=sMath.PI&&(u=2*Math.PI-u),u},It.toRadians=function(s){return s*Math.PI/180},It.getTurn=function(s,a){var u=Math.sin(a-s);return u>0?It.COUNTERCLOCKWISE:u<0?It.CLOCKWISE:It.NONE},It.angleBetweenOriented=function(s,a,u){var f=It.angle(a,s),p=It.angle(a,u)-f;return p<=-Math.PI?p+It.PI_TIMES_2:p>Math.PI?p-It.PI_TIMES_2:p},Gl.PI_TIMES_2.get=function(){return 2*Math.PI},Gl.PI_OVER_2.get=function(){return Math.PI/2},Gl.PI_OVER_4.get=function(){return Math.PI/4},Gl.COUNTERCLOCKWISE.get=function(){return EA.COUNTERCLOCKWISE},Gl.CLOCKWISE.get=function(){return EA.CLOCKWISE},Gl.NONE.get=function(){return EA.COLLINEAR},Object.defineProperties(It,Gl);var pj=function s(){this._maxCurveSegmentError=0,this._filletAngleQuantum=null,this._closingSegLengthFactor=1,this._segList=null,this._distance=0,this._precisionModel=null,this._bufParams=null,this._li=null,this._s0=null,this._s1=null,this._s2=null,this._seg0=new CA,this._seg1=new CA,this._offset0=new CA,this._offset1=new CA,this._side=0,this._hasNarrowConcaveAngle=!1;var a=arguments[0],u=arguments[1],f=arguments[2];this._precisionModel=a,this._bufParams=u,this._li=new PA,this._filletAngleQuantum=Math.PI/2/u.getQuadrantSegments(),u.getQuadrantSegments()>=8&&u.getJoinStyle()===zt.JOIN_ROUND&&(this._closingSegLengthFactor=s.MAX_CLOSING_SEG_LEN_FACTOR),this.init(f)},uh={OFFSET_SEGMENT_SEPARATION_FACTOR:{configurable:!0},INSIDE_TURN_VERTEX_SNAP_DISTANCE_FACTOR:{configurable:!0},CURVE_VERTEX_SNAP_DISTANCE_FACTOR:{configurable:!0},MAX_CLOSING_SEG_LEN_FACTOR:{configurable:!0}};pj.prototype.addNextSegment=function(s,a){if(this._s0=this._s1,this._s1=this._s2,this._s2=s,this._seg0.setCoordinates(this._s0,this._s1),this.computeOffsetSegment(this._seg0,this._side,this._distance,this._offset0),this._seg1.setCoordinates(this._s1,this._s2),this.computeOffsetSegment(this._seg1,this._side,this._distance,this._offset1),this._s1.equals(this._s2))return null;var u=EA.computeOrientation(this._s0,this._s1,this._s2),f=u===EA.CLOCKWISE&&this._side===D.LEFT||u===EA.COUNTERCLOCKWISE&&this._side===D.RIGHT;u===0?this.addCollinear(a):f?this.addOutsideTurn(u,a):this.addInsideTurn(u,a)},pj.prototype.addLineEndCap=function(s,a){var u=new CA(s,a),f=new CA;this.computeOffsetSegment(u,D.LEFT,this._distance,f);var p=new CA;this.computeOffsetSegment(u,D.RIGHT,this._distance,p);var $=a.x-s.x,q=a.y-s.y,M=Math.atan2(q,$);switch(this._bufParams.getEndCapStyle()){case zt.CAP_ROUND:this._segList.addPt(f.p1),this.addFilletArc(a,M+Math.PI/2,M-Math.PI/2,EA.CLOCKWISE,this._distance),this._segList.addPt(p.p1);break;case zt.CAP_FLAT:this._segList.addPt(f.p1),this._segList.addPt(p.p1);break;case zt.CAP_SQUARE:var H=new F;H.x=Math.abs(this._distance)*Math.cos(M),H.y=Math.abs(this._distance)*Math.sin(M);var W=new F(f.p1.x+H.x,f.p1.y+H.y),oA=new F(p.p1.x+H.x,p.p1.y+H.y);this._segList.addPt(W),this._segList.addPt(oA)}},pj.prototype.getCoordinates=function(){return this._segList.getCoordinates()},pj.prototype.addMitreJoin=function(s,a,u,f){var p=!0,$=null;try{$=Ht.intersection(a.p0,a.p1,u.p0,u.p1),(f<=0?1:$.distance(s)/Math.abs(f))>this._bufParams.getMitreLimit()&&(p=!1)}catch(q){if(!(q instanceof _t))throw q;$=new F(0,0),p=!1}p?this._segList.addPt($):this.addLimitedMitreJoin(a,u,f,this._bufParams.getMitreLimit())},pj.prototype.addFilletCorner=function(s,a,u,f,p){var $=a.x-s.x,q=a.y-s.y,M=Math.atan2(q,$),H=u.x-s.x,W=u.y-s.y,oA=Math.atan2(W,H);f===EA.CLOCKWISE?M<=oA&&(M+=2*Math.PI):M>=oA&&(M-=2*Math.PI),this._segList.addPt(a),this.addFilletArc(s,M,oA,f,p),this._segList.addPt(u)},pj.prototype.addOutsideTurn=function(s,a){if(this._offset0.p1.distance(this._offset1.p0)0){var u=new F((this._closingSegLengthFactor*this._offset0.p1.x+this._s1.x)/(this._closingSegLengthFactor+1),(this._closingSegLengthFactor*this._offset0.p1.y+this._s1.y)/(this._closingSegLengthFactor+1));this._segList.addPt(u);var f=new F((this._closingSegLengthFactor*this._offset1.p0.x+this._s1.x)/(this._closingSegLengthFactor+1),(this._closingSegLengthFactor*this._offset1.p0.y+this._s1.y)/(this._closingSegLengthFactor+1));this._segList.addPt(f)}else this._segList.addPt(this._s1);this._segList.addPt(this._offset1.p0)}},pj.prototype.createCircle=function(s){var a=new F(s.x+this._distance,s.y);this._segList.addPt(a),this.addFilletArc(s,0,2*Math.PI,-1,this._distance),this._segList.closeRing()},pj.prototype.addBevelJoin=function(s,a){this._segList.addPt(s.p1),this._segList.addPt(a.p0)},pj.prototype.init=function(s){this._distance=s,this._maxCurveSegmentError=s*(1-Math.cos(this._filletAngleQuantum/2)),this._segList=new $n,this._segList.setPrecisionModel(this._precisionModel),this._segList.setMinimumVertexDistance(s*pj.CURVE_VERTEX_SNAP_DISTANCE_FACTOR)},pj.prototype.addCollinear=function(s){this._li.computeIntersection(this._s0,this._s1,this._s1,this._s2),this._li.getIntersectionNum()>=2&&(this._bufParams.getJoinStyle()===zt.JOIN_BEVEL||this._bufParams.getJoinStyle()===zt.JOIN_MITRE?(s&&this._segList.addPt(this._offset0.p1),this._segList.addPt(this._offset1.p0)):this.addFilletCorner(this._s1,this._offset0.p1,this._offset1.p0,EA.CLOCKWISE,this._distance))},pj.prototype.closeRing=function(){this._segList.closeRing()},pj.prototype.hasNarrowConcaveAngle=function(){return this._hasNarrowConcaveAngle},pj.prototype.interfaces_=function(){return[]},pj.prototype.getClass=function(){return pj},uh.OFFSET_SEGMENT_SEPARATION_FACTOR.get=function(){return .001},uh.INSIDE_TURN_VERTEX_SNAP_DISTANCE_FACTOR.get=function(){return .001},uh.CURVE_VERTEX_SNAP_DISTANCE_FACTOR.get=function(){return 1e-6},uh.MAX_CLOSING_SEG_LEN_FACTOR.get=function(){return 80},Object.defineProperties(pj,uh);var Fr=function(){this._distance=0,this._precisionModel=null,this._bufParams=null;var s=arguments[0],a=arguments[1];this._precisionModel=s,this._bufParams=a};Fr.prototype.getOffsetCurve=function(s,a){if(this._distance=a,a===0)return null;var u=a<0,f=Math.abs(a),p=this.getSegGen(f);s.length<=1?this.computePointCurve(s[0],p):this.computeOffsetCurve(s,u,p);var $=p.getCoordinates();return u&&BA.reverse($),$},Fr.prototype.computeSingleSidedBufferCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);if(a){u.addSegments(s,!0);var p=Mj.simplify(s,-f),$=p.length-1;u.initSideSegments(p[$],p[$-1],D.LEFT),u.addFirstSegment();for(var q=$-2;q>=0;q--)u.addNextSegment(p[q],!0)}else{u.addSegments(s,!1);var M=Mj.simplify(s,f),H=M.length-1;u.initSideSegments(M[0],M[1],D.LEFT),u.addFirstSegment();for(var W=2;W<=H;W++)u.addNextSegment(M[W],!0)}u.addLastSegment(),u.closeRing()},Fr.prototype.computeRingBufferCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);a===D.RIGHT&&(f=-f);var p=Mj.simplify(s,f),$=p.length-1;u.initSideSegments(p[$-1],p[0],a);for(var q=1;q<=$;q++){var M=q!==1;u.addNextSegment(p[q],M)}u.closeRing()},Fr.prototype.computeLineBufferCurve=function(s,a){var u=this.simplifyTolerance(this._distance),f=Mj.simplify(s,u),p=f.length-1;a.initSideSegments(f[0],f[1],D.LEFT);for(var $=2;$<=p;$++)a.addNextSegment(f[$],!0);a.addLastSegment(),a.addLineEndCap(f[p-1],f[p]);var q=Mj.simplify(s,-u),M=q.length-1;a.initSideSegments(q[M],q[M-1],D.LEFT);for(var H=M-2;H>=0;H--)a.addNextSegment(q[H],!0);a.addLastSegment(),a.addLineEndCap(q[1],q[0]),a.closeRing()},Fr.prototype.computePointCurve=function(s,a){switch(this._bufParams.getEndCapStyle()){case zt.CAP_ROUND:a.createCircle(s);break;case zt.CAP_SQUARE:a.createSquare(s)}},Fr.prototype.getLineCurve=function(s,a){if(this._distance=a,a<0&&!this._bufParams.isSingleSided()||a===0)return null;var u=Math.abs(a),f=this.getSegGen(u);if(s.length<=1)this.computePointCurve(s[0],f);else if(this._bufParams.isSingleSided()){var p=a<0;this.computeSingleSidedBufferCurve(s,p,f)}else this.computeLineBufferCurve(s,f);return f.getCoordinates()},Fr.prototype.getBufferParameters=function(){return this._bufParams},Fr.prototype.simplifyTolerance=function(s){return s*this._bufParams.getSimplifyFactor()},Fr.prototype.getRingCurve=function(s,a,u){if(this._distance=u,s.length<=2)return this.getLineCurve(s,u);if(u===0)return Fr.copyCoordinates(s);var f=this.getSegGen(u);return this.computeRingBufferCurve(s,a,f),f.getCoordinates()},Fr.prototype.computeOffsetCurve=function(s,a,u){var f=this.simplifyTolerance(this._distance);if(a){var p=Mj.simplify(s,-f),$=p.length-1;u.initSideSegments(p[$],p[$-1],D.LEFT),u.addFirstSegment();for(var q=$-2;q>=0;q--)u.addNextSegment(p[q],!0)}else{var M=Mj.simplify(s,f),H=M.length-1;u.initSideSegments(M[0],M[1],D.LEFT),u.addFirstSegment();for(var W=2;W<=H;W++)u.addNextSegment(M[W],!0)}u.addLastSegment()},Fr.prototype.getSegGen=function(s){return new pj(this._precisionModel,this._bufParams,s)},Fr.prototype.interfaces_=function(){return[]},Fr.prototype.getClass=function(){return Fr},Fr.copyCoordinates=function(s){for(var a=new Array(s.length).fill(null),u=0;up.getMaxY()||this.findStabbedSegments(s,f.getDirectedEdges(),a)}return a}if(arguments.length===3){if(b(arguments[2],uA)&&arguments[0]instanceof F&&arguments[1]instanceof R_){for(var $=arguments[0],q=arguments[1],M=arguments[2],H=q.getEdge().getCoordinates(),W=0;Wthis._seg.p1.y&&this._seg.reverse(),!(Math.max(this._seg.p0.x,this._seg.p1.x)<$.x)&&!(this._seg.isHorizontal()||$.ythis._seg.p1.y||EA.computeOrientation(this._seg.p0,this._seg.p1,$)===EA.RIGHT)){var oA=q.getDepth(D.LEFT);this._seg.p0.equals(H[W])||(oA=q.getDepth(D.RIGHT));var cA=new r7(this._seg,oA);M.add(cA)}}else if(b(arguments[2],uA)&&arguments[0]instanceof F&&b(arguments[1],uA))for(var yA=arguments[0],vA=arguments[1],IA=arguments[2],DA=vA.iterator();DA.hasNext();){var Jt=DA.next();Jt.isForward()&&this.findStabbedSegments(yA,Jt,IA)}}},wl.prototype.getDepth=function(s){var a=this.findStabbedSegments(s);return a.size()===0?0:T6.min(a)._leftDepth},wl.prototype.interfaces_=function(){return[]},wl.prototype.getClass=function(){return wl},u8.DepthSegment.get=function(){return r7},Object.defineProperties(wl,u8);var r7=function(){this._upwardSeg=null,this._leftDepth=null;var s=arguments[0],a=arguments[1];this._upwardSeg=new CA(s),this._leftDepth=a};r7.prototype.compareTo=function(s){var a=s;if(this._upwardSeg.minX()>=a._upwardSeg.maxX())return 1;if(this._upwardSeg.maxX()<=a._upwardSeg.minX())return-1;var u=this._upwardSeg.orientationIndex(a._upwardSeg);return u!==0||(u=-1*a._upwardSeg.orientationIndex(this._upwardSeg))!=0?u:this._upwardSeg.compareTo(a._upwardSeg)},r7.prototype.compareX=function(s,a){var u=s.p0.compareTo(a.p0);return u!==0?u:s.p1.compareTo(a.p1)},r7.prototype.toString=function(){return this._upwardSeg.toString()},r7.prototype.interfaces_=function(){return[w]},r7.prototype.getClass=function(){return r7};var Ut=function(s,a,u){this.p0=s||null,this.p1=a||null,this.p2=u||null};Ut.prototype.area=function(){return Ut.area(this.p0,this.p1,this.p2)},Ut.prototype.signedArea=function(){return Ut.signedArea(this.p0,this.p1,this.p2)},Ut.prototype.interpolateZ=function(s){if(s===null)throw new G("Supplied point is null.");return Ut.interpolateZ(s,this.p0,this.p1,this.p2)},Ut.prototype.longestSideLength=function(){return Ut.longestSideLength(this.p0,this.p1,this.p2)},Ut.prototype.isAcute=function(){return Ut.isAcute(this.p0,this.p1,this.p2)},Ut.prototype.circumcentre=function(){return Ut.circumcentre(this.p0,this.p1,this.p2)},Ut.prototype.area3D=function(){return Ut.area3D(this.p0,this.p1,this.p2)},Ut.prototype.centroid=function(){return Ut.centroid(this.p0,this.p1,this.p2)},Ut.prototype.inCentre=function(){return Ut.inCentre(this.p0,this.p1,this.p2)},Ut.prototype.interfaces_=function(){return[]},Ut.prototype.getClass=function(){return Ut},Ut.area=function(s,a,u){return Math.abs(((u.x-s.x)*(a.y-s.y)-(a.x-s.x)*(u.y-s.y))/2)},Ut.signedArea=function(s,a,u){return((u.x-s.x)*(a.y-s.y)-(a.x-s.x)*(u.y-s.y))/2},Ut.det=function(s,a,u,f){return s*f-a*u},Ut.interpolateZ=function(s,a,u,f){var p=a.x,$=a.y,q=u.x-p,M=f.x-p,H=u.y-$,W=f.y-$,oA=q*W-M*H,cA=s.x-p,yA=s.y-$,vA=(W*cA-M*yA)/oA,IA=(-H*cA+q*yA)/oA;return a.z+vA*(u.z-a.z)+IA*(f.z-a.z)},Ut.longestSideLength=function(s,a,u){var f=s.distance(a),p=a.distance(u),$=u.distance(s),q=f;return p>q&&(q=p),$>q&&(q=$),q},Ut.isAcute=function(s,a,u){return!!It.isAcute(s,a,u)&&!!It.isAcute(a,u,s)&&!!It.isAcute(u,s,a)},Ut.circumcentre=function(s,a,u){var f=u.x,p=u.y,$=s.x-f,q=s.y-p,M=a.x-f,H=a.y-p,W=2*Ut.det($,q,M,H),oA=Ut.det(q,$*$+q*q,H,M*M+H*H),cA=Ut.det($,$*$+q*q,M,M*M+H*H);return new F(f-oA/W,p+cA/W)},Ut.perpendicularBisector=function(s,a){var u=a.x-s.x,f=a.y-s.y,p=new Ht(s.x+u/2,s.y+f/2,1),$=new Ht(s.x-f+u/2,s.y+u+f/2,1);return new Ht(p,$)},Ut.angleBisector=function(s,a,u){var f=a.distance(s),p=f/(f+a.distance(u)),$=u.x-s.x,q=u.y-s.y;return new F(s.x+p*$,s.y+p*q)},Ut.area3D=function(s,a,u){var f=a.x-s.x,p=a.y-s.y,$=a.z-s.z,q=u.x-s.x,M=u.y-s.y,H=u.z-s.z,W=p*H-$*M,oA=$*q-f*H,cA=f*M-p*q,yA=W*W+oA*oA+cA*cA,vA=Math.sqrt(yA)/2;return vA},Ut.centroid=function(s,a,u){var f=(s.x+a.x+u.x)/3,p=(s.y+a.y+u.y)/3;return new F(f,p)},Ut.inCentre=function(s,a,u){var f=a.distance(u),p=s.distance(u),$=s.distance(a),q=f+p+$,M=(f*s.x+p*a.x+$*u.x)/q,H=(f*s.y+p*a.y+$*u.y)/q;return new F(M,H)};var h6=function(){this._inputGeom=null,this._distance=null,this._curveBuilder=null,this._curveList=new nA;var s=arguments[0],a=arguments[1],u=arguments[2];this._inputGeom=s,this._distance=a,this._curveBuilder=u};h6.prototype.addPoint=function(s){if(this._distance<=0)return null;var a=s.getCoordinates(),u=this._curveBuilder.getLineCurve(a,this._distance);this.addCurve(u,T.EXTERIOR,T.INTERIOR)},h6.prototype.addPolygon=function(s){var a=this._distance,u=D.LEFT;this._distance<0&&(a=-this._distance,u=D.RIGHT);var f=s.getExteriorRing(),p=BA.removeRepeatedPoints(f.getCoordinates());if(this._distance<0&&this.isErodedCompletely(f,this._distance)||this._distance<=0&&p.length<3)return null;this.addPolygonRing(p,a,u,T.EXTERIOR,T.INTERIOR);for(var $=0;$0&&this.isErodedCompletely(q,-this._distance)||this.addPolygonRing(M,a,D.opposite(u),T.INTERIOR,T.EXTERIOR)}},h6.prototype.isTriangleErodedCompletely=function(s,a){var u=new Ut(s[0],s[1],s[2]),f=u.inCentre();return EA.distancePointLine(f,u.p0,u.p1)=Pe.MINIMUM_VALID_SIZE&&EA.isCCW(s)&&($=p,q=f,u=D.opposite(u));var M=this._curveBuilder.getRingCurve(s,u,a);this.addCurve(M,$,q)},h6.prototype.add=function(s){if(s.isEmpty())return null;s instanceof Qt?this.addPolygon(s):s instanceof Bj?this.addLineString(s):s instanceof ir?this.addPoint(s):s instanceof M6?this.addCollection(s):s instanceof br?this.addCollection(s):s instanceof xe?this.addCollection(s):s instanceof oj&&this.addCollection(s)},h6.prototype.isErodedCompletely=function(s,a){var u=s.getCoordinates();if(u.length<4)return a<0;if(u.length===4)return this.isTriangleErodedCompletely(u,a);var f=s.getEnvelopeInternal(),p=Math.min(f.getHeight(),f.getWidth());return a<0&&2*Math.abs(a)>p},h6.prototype.addCollection=function(s){for(var a=0;a=this._max)throw new e;var s=this._parent.getGeometryN(this._index++);return s instanceof oj?(this._subcollectionIterator=new Ti(s),this._subcollectionIterator.next()):s},Ti.prototype.remove=function(){throw new Error(this.getClass().getName())},Ti.prototype.hasNext=function(){if(this._atStart)return!0;if(this._subcollectionIterator!==null){if(this._subcollectionIterator.hasNext())return!0;this._subcollectionIterator=null}return!(this._index>=this._max)},Ti.prototype.interfaces_=function(){return[hA]},Ti.prototype.getClass=function(){return Ti},Ti.isAtomic=function(s){return!(s instanceof oj)};var xn=function(){this._geom=null;var s=arguments[0];this._geom=s};xn.prototype.locate=function(s){return xn.locate(s,this._geom)},xn.prototype.interfaces_=function(){return[fu]},xn.prototype.getClass=function(){return xn},xn.isPointInRing=function(s,a){return!!a.getEnvelopeInternal().intersects(s)&&EA.isPointInRing(s,a.getCoordinates())},xn.containsPointInPolygon=function(s,a){if(a.isEmpty())return!1;var u=a.getExteriorRing();if(!xn.isPointInRing(s,u))return!1;for(var f=0;f=0;p--){var $=this._edgeList.get(p),q=$.getSym();f===null&&(f=q),u!==null&&q.setNext(u),u=$}f.setNext(u)},a.prototype.computeDepths=function(){if(arguments.length===1){var u=arguments[0],f=this.findIndex(u),p=u.getDepth(H.LEFT),$=u.getDepth(H.RIGHT),q=this.computeDepths(f+1,this._edgeList.size(),p);if(this.computeDepths(0,f,q)!==$)throw new GA("depth mismatch at "+u.getCoordinate())}else if(arguments.length===3){for(var M=arguments[0],C=arguments[1],Q=arguments[2],oA=M;oA=0;q--){var M=this._resultAreaEdgeList.get(q),C=M.getSym();switch(f===null&&M.getEdgeRing()===u&&(f=M),$){case this._SCANNING_FOR_INCOMING:if(C.getEdgeRing()!==u)continue;p=C,$=this._LINKING_TO_OUTGOING;break;case this._LINKING_TO_OUTGOING:if(M.getEdgeRing()!==u)continue;p.setNextMin(M),$=this._SCANNING_FOR_INCOMING}}$===this._LINKING_TO_OUTGOING&&(KA.isTrue(f!==null,"found null for first outgoing dirEdge"),KA.isTrue(f.getEdgeRing()===u,"unable to link last incoming dirEdge"),p.setNextMin(f))},a.prototype.getOutgoingDegree=function(){if(arguments.length===0){for(var u=0,f=this.iterator();f.hasNext();)f.next().isInResult()&&u++;return u}if(arguments.length===1){for(var p=arguments[0],$=0,q=this.iterator();q.hasNext();)q.next().getEdgeRing()===p&&$++;return $}},a.prototype.getLabel=function(){return this._label},a.prototype.findCoveredLineEdges=function(){for(var u=T.NONE,f=this.iterator();f.hasNext();){var p=f.next(),$=p.getSym();if(!p.isLineEdge()){if(p.isInResult()){u=T.INTERIOR;break}if($.isInResult()){u=T.EXTERIOR;break}}}if(u===T.NONE)return null;for(var q=u,M=this.iterator();M.hasNext();){var C=M.next(),Q=C.getSym();C.isLineEdge()?C.getEdge().setCovered(q===T.INTERIOR):(C.isInResult()&&(q=T.EXTERIOR),Q.isInResult()&&(q=T.INTERIOR))}},a.prototype.computeLabelling=function(u){s.prototype.computeLabelling.call(this,u),this._label=new rt(T.NONE);for(var f=this.iterator();f.hasNext();)for(var p=f.next().getEdge().getLabel(),$=0;$<2;$++){var q=p.getLocation($);q!==T.INTERIOR&&q!==T.BOUNDARY||this._label.setLocation($,T.INTERIOR)}},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Qe),s8=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.createNode=function(u){return new cg(u,new i9)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(cu),Cs=function s(){this._pts=null,this._orientation=null;var a=arguments[0];this._pts=a,this._orientation=s.orientation(a)};Cs.prototype.compareTo=function(s){var a=s;return Cs.compareOriented(this._pts,this._orientation,a._pts,a._orientation)},Cs.prototype.interfaces_=function(){return[w]},Cs.prototype.getClass=function(){return Cs},Cs.orientation=function(s){return BA.increasingDirection(s)===1},Cs.compareOriented=function(s,a,u,f){for(var p=a?1:-1,$=f?1:-1,q=a?s.length:-1,M=f?u.length:-1,C=a?0:s.length-1,Q=f?0:u.length-1;;){var oA=s[C].compareTo(u[Q]);if(oA!==0)return oA;var cA=(C+=p)===q,yA=(Q+=$)===M;if(cA&&!yA)return-1;if(!cA&&yA)return 1;if(cA&&yA)return 0}};var S6=function(){this._edges=new nA,this._ocaMap=new h};S6.prototype.print=function(s){s.print("MULTILINESTRING ( ");for(var a=0;a0&&s.print(","),s.print("(");for(var f=u.getCoordinates(),p=0;p0&&s.print(","),s.print(f[p].x+" "+f[p].y);s.println(")")}s.print(") ")},S6.prototype.addAll=function(s){for(var a=s.iterator();a.hasNext();)this.add(a.next())},S6.prototype.findEdgeIndex=function(s){for(var a=0;a0||!a.coord.equals2D(f);p||u--;var $=new Array(u).fill(null),q=0;$[q++]=new F(s.coord);for(var M=s.segmentIndex+1;M<=a.segmentIndex;M++)$[q++]=this.edge.pts[M];return p&&($[q]=a.coord),new Bg($,new rt(this.edge._label))},Si.prototype.add=function(s,a,u){var f=new si(s,a,u),p=this._nodeMap.get(f);return p!==null?p:(this._nodeMap.put(f,f),f)},Si.prototype.isIntersection=function(s){for(var a=this.iterator();a.hasNext();)if(a.next().coord.equals(s))return!0;return!1},Si.prototype.interfaces_=function(){return[]},Si.prototype.getClass=function(){return Si};var i7=function(){};i7.prototype.getChainStartIndices=function(s){var a=0,u=new nA;u.add(new $A(a));do{var f=this.findChainEnd(s,a);u.add(new $A(f)),a=f}while(au?a:u},Ro.prototype.getMinX=function(s){var a=this.pts[this.startIndex[s]].x,u=this.pts[this.startIndex[s+1]].x;return aa&&(f=1),this._depth[s][u]=f}}},Me.prototype.getDelta=function(s){return this._depth[s][H.RIGHT]-this._depth[s][H.LEFT]},Me.prototype.getLocation=function(s,a){return this._depth[s][a]<=0?T.EXTERIOR:T.INTERIOR},Me.prototype.toString=function(){return"A: "+this._depth[0][1]+","+this._depth[0][2]+" B: "+this._depth[1][1]+","+this._depth[1][2]},Me.prototype.add=function(){if(arguments.length===1)for(var s=arguments[0],a=0;a<2;a++)for(var u=1;u<3;u++){var f=s.getLocation(a,u);f!==T.EXTERIOR&&f!==T.INTERIOR||(this.isNull(a,u)?this._depth[a][u]=Me.depthAtLocation(f):this._depth[a][u]+=Me.depthAtLocation(f))}else if(arguments.length===3){var p=arguments[0],$=arguments[1];arguments[2]===T.INTERIOR&&this._depth[p][$]++}},Me.prototype.interfaces_=function(){return[]},Me.prototype.getClass=function(){return Me},Me.depthAtLocation=function(s){return s===T.EXTERIOR?0:s===T.INTERIOR?1:Me.NULL_VALUE},a8.NULL_VALUE.get=function(){return-1},Object.defineProperties(Me,a8);var Bg=function(s){function a(){if(s.call(this),this.pts=null,this._env=null,this.eiList=new Si(this),this._name=null,this._mce=null,this._isIsolated=!0,this._depth=new Me,this._depthDelta=0,arguments.length===1){var u=arguments[0];a.call(this,u,null)}else if(arguments.length===2){var f=arguments[0],p=arguments[1];this.pts=f,this._label=p}}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.getDepth=function(){return this._depth},a.prototype.getCollapsedEdge=function(){var u=new Array(2).fill(null);return u[0]=this.pts[0],u[1]=this.pts[1],new a(u,rt.toLineLabel(this._label))},a.prototype.isIsolated=function(){return this._isIsolated},a.prototype.getCoordinates=function(){return this.pts},a.prototype.setIsolated=function(u){this._isIsolated=u},a.prototype.setName=function(u){this._name=u},a.prototype.equals=function(u){if(!(u instanceof a))return!1;var f=u;if(this.pts.length!==f.pts.length)return!1;for(var p=!0,$=!0,q=this.pts.length,M=0;M0?this.pts[0]:null;if(arguments.length===1){var u=arguments[0];return this.pts[u]}},a.prototype.print=function(u){u.print("edge "+this._name+": "),u.print("LINESTRING (");for(var f=0;f0&&u.print(","),u.print(this.pts[f].x+" "+this.pts[f].y);u.print(") "+this._label+" "+this._depthDelta)},a.prototype.computeIM=function(u){a.updateIM(this._label,u)},a.prototype.isCollapsed=function(){return!!this._label.isArea()&&this.pts.length===3&&!!this.pts[0].equals(this.pts[2])},a.prototype.isClosed=function(){return this.pts[0].equals(this.pts[this.pts.length-1])},a.prototype.getMaximumSegmentIndex=function(){return this.pts.length-1},a.prototype.getDepthDelta=function(){return this._depthDelta},a.prototype.getNumPoints=function(){return this.pts.length},a.prototype.printReverse=function(u){u.print("edge "+this._name+": ");for(var f=this.pts.length-1;f>=0;f--)u.print(this.pts[f]+" ");u.println("")},a.prototype.getMonotoneChainEdge=function(){return this._mce===null&&(this._mce=new Ro(this)),this._mce},a.prototype.getEnvelope=function(){if(this._env===null){this._env=new bA;for(var u=0;u0&&u.append(","),u.append(this.pts[f].x+" "+this.pts[f].y);return u.append(") "+this._label+" "+this._depthDelta),u.toString()},a.prototype.isPointwiseEqual=function(u){if(this.pts.length!==u.pts.length)return!1;for(var f=0;ff||this._maxy$;if(q)return!1;var M=this.intersectsToleranceSquare(s,a);return KA.isTrue(!(q&&M),"Found bad envelope test"),M},Pr.prototype.initCorners=function(s){this._minx=s.x-.5,this._maxx=s.x+.5,this._miny=s.y-.5,this._maxy=s.y+.5,this._corner[0]=new F(this._maxx,this._maxy),this._corner[1]=new F(this._minx,this._maxy),this._corner[2]=new F(this._minx,this._miny),this._corner[3]=new F(this._maxx,this._miny)},Pr.prototype.intersects=function(s,a){return this._scaleFactor===1?this.intersectsScaled(s,a):(this.copyScaled(s,this._p0Scaled),this.copyScaled(a,this._p1Scaled),this.intersectsScaled(this._p0Scaled,this._p1Scaled))},Pr.prototype.scale=function(s){return Math.round(s*this._scaleFactor)},Pr.prototype.getCoordinate=function(){return this._originalPt},Pr.prototype.copyScaled=function(s,a){a.x=this.scale(s.x),a.y=this.scale(s.y)},Pr.prototype.getSafeEnvelope=function(){if(this._safeEnv===null){var s=Pr.SAFE_ENV_EXPANSION_FACTOR/this._scaleFactor;this._safeEnv=new bA(this._originalPt.x-s,this._originalPt.x+s,this._originalPt.y-s,this._originalPt.y+s)}return this._safeEnv},Pr.prototype.intersectsPixelClosure=function(s,a){return this._li.computeIntersection(s,a,this._corner[0],this._corner[1]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[1],this._corner[2]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[2],this._corner[3]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[3],this._corner[0]),!!this._li.hasIntersection())))},Pr.prototype.intersectsToleranceSquare=function(s,a){var u=!1,f=!1;return this._li.computeIntersection(s,a,this._corner[0],this._corner[1]),!!this._li.isProper()||(this._li.computeIntersection(s,a,this._corner[1],this._corner[2]),!!this._li.isProper()||(this._li.hasIntersection()&&(u=!0),this._li.computeIntersection(s,a,this._corner[2],this._corner[3]),!!this._li.isProper()||(this._li.hasIntersection()&&(f=!0),this._li.computeIntersection(s,a,this._corner[3],this._corner[0]),!!this._li.isProper()||!(!u||!f)||!!s.equals(this._pt)||!!a.equals(this._pt))))},Pr.prototype.addSnappedNode=function(s,a){var u=s.getCoordinate(a),f=s.getCoordinate(a+1);return!!this.intersects(u,f)&&(s.addIntersection(this.getCoordinate(),a),!0)},Pr.prototype.interfaces_=function(){return[]},Pr.prototype.getClass=function(){return Pr},c8.SAFE_ENV_EXPANSION_FACTOR.get=function(){return .75},Object.defineProperties(Pr,c8);var Bh=function(){this.tempEnv1=new bA,this.selectedSegment=new CA};Bh.prototype.select=function(){if(arguments.length!==1){if(arguments.length===2){var s=arguments[0],a=arguments[1];s.getLineSegment(a,this.selectedSegment),this.select(this.selectedSegment)}}},Bh.prototype.interfaces_=function(){return[]},Bh.prototype.getClass=function(){return Bh};var hu=function(){this._index=null;var s=arguments[0];this._index=s},u8={HotPixelSnapAction:{configurable:!0}};hu.prototype.snap=function(){if(arguments.length===1){var s=arguments[0];return this.snap(s,null,-1)}if(arguments.length===3){var a=arguments[0],u=arguments[1],f=arguments[2],p=a.getSafeEnvelope(),$=new B8(a,u,f);return this._index.query(p,{interfaces_:function(){return[Rs]},visitItem:function(q){q.select(p,$)}}),$.isNodeAdded()}},hu.prototype.interfaces_=function(){return[]},hu.prototype.getClass=function(){return hu},u8.HotPixelSnapAction.get=function(){return B8},Object.defineProperties(hu,u8);var B8=function(s){function a(){s.call(this),this._hotPixel=null,this._parentEdge=null,this._hotPixelVertexIndex=null,this._isNodeAdded=!1;var u=arguments[0],f=arguments[1],p=arguments[2];this._hotPixel=u,this._parentEdge=f,this._hotPixelVertexIndex=p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isNodeAdded=function(){return this._isNodeAdded},a.prototype.select=function(){if(arguments.length!==2)return s.prototype.select.apply(this,arguments);var u=arguments[0],f=arguments[1],p=u.getContext();if(this._parentEdge!==null&&p===this._parentEdge&&f===this._hotPixelVertexIndex)return null;this._isNodeAdded=this._hotPixel.addSnappedNode(p,f)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Bh),Fl=function(){this._li=null,this._interiorIntersections=null;var s=arguments[0];this._li=s,this._interiorIntersections=new nA};Fl.prototype.processIntersections=function(s,a,u,f){if(s===u&&a===f)return null;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];if(this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&this._li.isInteriorIntersection()){for(var C=0;C=0;a--){try{s.bufferReducedPrecision(a)}catch($){if(!($ instanceof GA))throw $;s._saveException=$}if(s._resultGeometry!==null)return null}throw this._saveException}if(arguments.length===1){var u=arguments[0],f=Oe.precisionScaleFactor(this._argGeom,this._distance,u),p=new Pt(f);this.bufferFixedPrecision(p)}},Oe.prototype.computeGeometry=function(){if(this.bufferOriginalPrecision(),this._resultGeometry!==null)return null;var s=this._argGeom.getFactory().getPrecisionModel();s.getType()===Pt.FIXED?this.bufferFixedPrecision(s):this.bufferReducedPrecision()},Oe.prototype.setQuadrantSegments=function(s){this._bufParams.setQuadrantSegments(s)},Oe.prototype.bufferOriginalPrecision=function(){try{var s=new sr(this._bufParams);this._resultGeometry=s.buffer(this._argGeom,this._distance)}catch(a){if(!(a instanceof ce))throw a;this._saveException=a}},Oe.prototype.getResultGeometry=function(s){return this._distance=s,this.computeGeometry(),this._resultGeometry},Oe.prototype.setEndCapStyle=function(s){this._bufParams.setEndCapStyle(s)},Oe.prototype.interfaces_=function(){return[]},Oe.prototype.getClass=function(){return Oe},Oe.bufferOp=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];return new Oe(s).getResultGeometry(a)}if(arguments.length===3){if(Number.isInteger(arguments[2])&&arguments[0]instanceof MA&&typeof arguments[1]=="number"){var u=arguments[0],f=arguments[1],p=arguments[2],$=new Oe(u);return $.setQuadrantSegments(p),$.getResultGeometry(f)}if(arguments[2]instanceof zt&&arguments[0]instanceof MA&&typeof arguments[1]=="number"){var q=arguments[0],M=arguments[1],C=arguments[2];return new Oe(q,C).getResultGeometry(M)}}else if(arguments.length===4){var Q=arguments[0],oA=arguments[1],cA=arguments[2],yA=arguments[3],vA=new Oe(Q);return vA.setQuadrantSegments(cA),vA.setEndCapStyle(yA),vA.getResultGeometry(oA)}},Oe.precisionScaleFactor=function(s,a,u){var f=s.getEnvelopeInternal(),p=jA.max(Math.abs(f.getMaxX()),Math.abs(f.getMaxY()),Math.abs(f.getMinX()),Math.abs(f.getMinY()))+2*(a>0?a:0),$=u-Math.trunc(Math.log(p)/Math.log(10)+1);return Math.pow(10,$)},du.CAP_ROUND.get=function(){return zt.CAP_ROUND},du.CAP_BUTT.get=function(){return zt.CAP_FLAT},du.CAP_FLAT.get=function(){return zt.CAP_FLAT},du.CAP_SQUARE.get=function(){return zt.CAP_SQUARE},du.MAX_PRECISION_DIGITS.get=function(){return 12},Object.defineProperties(Oe,du);var ar=function(){this._pt=[new F,new F],this._distance=v.NaN,this._isNull=!0};ar.prototype.getCoordinates=function(){return this._pt},ar.prototype.getCoordinate=function(s){return this._pt[s]},ar.prototype.setMinimum=function(){if(arguments.length===1){var s=arguments[0];this.setMinimum(s._pt[0],s._pt[1])}else if(arguments.length===2){var a=arguments[0],u=arguments[1];if(this._isNull)return this.initialize(a,u),null;var f=a.distance(u);fthis._distance&&this.initialize(a,u,f)}},ar.prototype.interfaces_=function(){return[]},ar.prototype.getClass=function(){return ar};var Li=function(){};Li.prototype.interfaces_=function(){return[]},Li.prototype.getClass=function(){return Li},Li.computeDistance=function(){if(arguments[2]instanceof ar&&arguments[0]instanceof Bj&&arguments[1]instanceof F)for(var s=arguments[0],a=arguments[1],u=arguments[2],f=s.getCoordinates(),p=new CA,$=0;$0||this._isIn?T.INTERIOR:T.EXTERIOR)},R6.prototype.interfaces_=function(){return[]},R6.prototype.getClass=function(){return R6};var lr=function s(){if(this._component=null,this._segIndex=null,this._pt=null,arguments.length===2){var a=arguments[0],u=arguments[1];s.call(this,a,s.INSIDE_AREA,u)}else if(arguments.length===3){var f=arguments[0],p=arguments[1],$=arguments[2];this._component=f,this._segIndex=p,this._pt=$}},f8={INSIDE_AREA:{configurable:!0}};lr.prototype.isInsideArea=function(){return this._segIndex===lr.INSIDE_AREA},lr.prototype.getCoordinate=function(){return this._pt},lr.prototype.getGeometryComponent=function(){return this._component},lr.prototype.getSegmentIndex=function(){return this._segIndex},lr.prototype.interfaces_=function(){return[]},lr.prototype.getClass=function(){return lr},f8.INSIDE_AREA.get=function(){return-1},Object.defineProperties(lr,f8);var Ns=function(s){this._pts=s||null};Ns.prototype.filter=function(s){s instanceof ir&&this._pts.add(s)},Ns.prototype.interfaces_=function(){return[qj]},Ns.prototype.getClass=function(){return Ns},Ns.getPoints=function(){if(arguments.length===1){var s=arguments[0];return s instanceof ir?T6.singletonList(s):Ns.getPoints(s,new nA)}if(arguments.length===2){var a=arguments[0],u=arguments[1];return a instanceof ir?u.add(a):a instanceof oj&&a.apply(new Ns(u)),u}};var Il=function(){this._locations=null;var s=arguments[0];this._locations=s};Il.prototype.filter=function(s){(s instanceof ir||s instanceof Bj||s instanceof Wt)&&this._locations.add(new lr(s,0,s.getCoordinate()))},Il.prototype.interfaces_=function(){return[qj]},Il.prototype.getClass=function(){return Il},Il.getLocations=function(s){var a=new nA;return s.apply(new Il(a)),a};var Se=function(){if(this._geom=null,this._terminateDistance=0,this._ptLocator=new R6,this._minDistanceLocation=null,this._minDistance=v.MAX_VALUE,arguments.length===2){var s=arguments[0],a=arguments[1];this._geom=[s,a],this._terminateDistance=0}else if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2];this._geom=new Array(2).fill(null),this._geom[0]=u,this._geom[1]=f,this._terminateDistance=p}};Se.prototype.computeContainmentDistance=function(){if(arguments.length===0){var s=new Array(2).fill(null);if(this.computeContainmentDistance(0,s),this._minDistance<=this._terminateDistance)return null;this.computeContainmentDistance(1,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=1-a,p=Lo.getPolygons(this._geom[a]);if(p.size()>0){var $=Il.getLocations(this._geom[f]);if(this.computeContainmentDistance($,p,u),this._minDistance<=this._terminateDistance)return this._minDistanceLocation[f]=u[0],this._minDistanceLocation[a]=u[1],null}}else if(arguments.length===3){if(arguments[2]instanceof Array&&G(arguments[0],uA)&&G(arguments[1],uA)){for(var q=arguments[0],M=arguments[1],C=arguments[2],Q=0;Qthis._minDistance)return null;for(var f=s.getCoordinates(),p=a.getCoordinate(),$=0;$this._minDistance)return null;for(var cA=C.getCoordinates(),yA=Q.getCoordinates(),vA=0;vAthis._distance&&this.initialize(a,u,f)}},We.prototype.interfaces_=function(){return[]},We.prototype.getClass=function(){return We};var li=function(){};li.prototype.interfaces_=function(){return[]},li.prototype.getClass=function(){return li},li.computeDistance=function(){if(arguments[2]instanceof We&&arguments[0]instanceof Bj&&arguments[1]instanceof F)for(var s=arguments[0],a=arguments[1],u=arguments[2],f=new CA,p=s.getCoordinates(),$=0;$1||s<=0)throw new b("Fraction is not in range (0.0 - 1.0]");this._densifyFrac=s},d6.prototype.compute=function(s,a){this.computeOrientedDistance(s,a,this._ptDist),this.computeOrientedDistance(a,s,this._ptDist)},d6.prototype.distance=function(){return this.compute(this._g0,this._g1),this._ptDist.getDistance()},d6.prototype.computeOrientedDistance=function(s,a,u){var f=new Ml(a);if(s.apply(f),u.setMaximum(f.getMaxPointDistance()),this._densifyFrac>0){var p=new Ks(a,this._densifyFrac);s.apply(p),u.setMaximum(p.getMaxPointDistance())}},d6.prototype.orientedDistance=function(){return this.computeOrientedDistance(this._g0,this._g1,this._ptDist),this._ptDist.getDistance()},d6.prototype.interfaces_=function(){return[]},d6.prototype.getClass=function(){return d6},d6.distance=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];return new d6(s,a).distance()}if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2],$=new d6(u,f);return $.setDensifyFraction(p),$.distance()}},T_.MaxPointDistanceFilter.get=function(){return Ml},T_.MaxDensifiedByFractionDistanceFilter.get=function(){return Ks},Object.defineProperties(d6,T_);var Ml=function(){this._maxPtDist=new We,this._minPtDist=new We,this._euclideanDist=new li,this._geom=null;var s=arguments[0];this._geom=s};Ml.prototype.filter=function(s){this._minPtDist.initialize(),li.computeDistance(this._geom,s,this._minPtDist),this._maxPtDist.setMaximum(this._minPtDist)},Ml.prototype.getMaxPointDistance=function(){return this._maxPtDist},Ml.prototype.interfaces_=function(){return[J]},Ml.prototype.getClass=function(){return Ml};var Ks=function(){this._maxPtDist=new We,this._minPtDist=new We,this._geom=null,this._numSubSegs=0;var s=arguments[0],a=arguments[1];this._geom=s,this._numSubSegs=Math.trunc(Math.round(1/a))};Ks.prototype.filter=function(s,a){if(a===0)return null;for(var u=s.getCoordinate(a-1),f=s.getCoordinate(a),p=(f.x-u.x)/this._numSubSegs,$=(f.y-u.y)/this._numSubSegs,q=0;qu){this._isValid=!1;var p=f.getCoordinates();this._errorLocation=p[1],this._errorIndicator=s.getFactory().createLineString(p),this._errMsg="Distance between buffer curve and input is too large ("+this._maxDistanceFound+" at "+cj.toLineString(p[0],p[1])+")"}},An.prototype.isValid=function(){var s=Math.abs(this._bufDistance),a=An.MAX_DISTANCE_DIFF_FRAC*s;return this._minValidDistance=s-a,this._maxValidDistance=s+a,!(!this._input.isEmpty()&&!this._result.isEmpty())||(this._bufDistance>0?this.checkPositiveValid():this.checkNegativeValid(),An.VERBOSE&&qA.out.println("Min Dist= "+this._minDistanceFound+" err= "+(1-this._minDistanceFound/this._bufDistance)+" Max Dist= "+this._maxDistanceFound+" err= "+(this._maxDistanceFound/this._bufDistance-1)),this._isValid)},An.prototype.checkNegativeValid=function(){if(!(this._input instanceof Wt||this._input instanceof xe||this._input instanceof oj))return null;var s=this.getPolygonLines(this._input);if(this.checkMinimumDistance(s,this._result,this._minValidDistance),!this._isValid)return null;this.checkMaximumDistance(s,this._result,this._maxValidDistance)},An.prototype.getErrorIndicator=function(){return this._errorIndicator},An.prototype.checkMinimumDistance=function(s,a,u){var f=new Se(s,a,u);if(this._minDistanceFound=f.distance(),this._minDistanceFound0&&s>a&&(this._isValid=!1,this._errorMsg="Area of positive buffer is smaller than input",this._errorIndicator=this._result),this._distance<0&&s=2||this._distance>0?null:(this._result.isEmpty()||(this._isValid=!1,this._errorMsg="Result is non-empty",this._errorIndicator=this._result),void this.report("ExpectedEmpty"))},Re.prototype.report=function(s){if(!Re.VERBOSE)return null;qA.out.println("Check "+s+": "+(this._isValid?"passed":"FAILED"))},Re.prototype.getErrorMessage=function(){return this._errorMsg},Re.prototype.interfaces_=function(){return[]},Re.prototype.getClass=function(){return Re},Re.isValidMsg=function(s,a,u){var f=new Re(s,a,u);return f.isValid()?null:f.getErrorMessage()},Re.isValid=function(s,a,u){return!!new Re(s,a,u).isValid()},R_.VERBOSE.get=function(){return!1},R_.MAX_ENV_DIFF_FRAC.get=function(){return .012},Object.defineProperties(Re,R_);var ci=function(){this._pts=null,this._data=null;var s=arguments[0],a=arguments[1];this._pts=s,this._data=a};ci.prototype.getCoordinates=function(){return this._pts},ci.prototype.size=function(){return this._pts.length},ci.prototype.getCoordinate=function(s){return this._pts[s]},ci.prototype.isClosed=function(){return this._pts[0].equals(this._pts[this._pts.length-1])},ci.prototype.getSegmentOctant=function(s){return s===this._pts.length-1?-1:Gl.octant(this.getCoordinate(s),this.getCoordinate(s+1))},ci.prototype.setData=function(s){this._data=s},ci.prototype.getData=function(){return this._data},ci.prototype.toString=function(){return cj.toLineString(new fj(this._pts))},ci.prototype.interfaces_=function(){return[Oi]},ci.prototype.getClass=function(){return ci};var ve=function(){this._findAllIntersections=!1,this._isCheckEndSegmentsOnly=!1,this._li=null,this._interiorIntersection=null,this._intSegments=null,this._intersections=new nA,this._intersectionCount=0,this._keepIntersections=!0;var s=arguments[0];this._li=s,this._interiorIntersection=null};ve.prototype.getInteriorIntersection=function(){return this._interiorIntersection},ve.prototype.setCheckEndSegmentsOnly=function(s){this._isCheckEndSegmentsOnly=s},ve.prototype.getIntersectionSegments=function(){return this._intSegments},ve.prototype.count=function(){return this._intersectionCount},ve.prototype.getIntersections=function(){return this._intersections},ve.prototype.setFindAllIntersections=function(s){this._findAllIntersections=s},ve.prototype.setKeepIntersections=function(s){this._keepIntersections=s},ve.prototype.processIntersections=function(s,a,u,f){if(!this._findAllIntersections&&this.hasIntersection()||s===u&&a===f||this._isCheckEndSegmentsOnly&&!(this.isEndSegment(s,a)||this.isEndSegment(u,f)))return null;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&this._li.isInteriorIntersection()&&(this._intSegments=new Array(4).fill(null),this._intSegments[0]=p,this._intSegments[1]=$,this._intSegments[2]=q,this._intSegments[3]=M,this._interiorIntersection=this._li.getIntersection(0),this._keepIntersections&&this._intersections.add(this._interiorIntersection),this._intersectionCount++)},ve.prototype.isEndSegment=function(s,a){return a===0||a>=s.size()-2},ve.prototype.hasIntersection=function(){return this._interiorIntersection!==null},ve.prototype.isDone=function(){return!this._findAllIntersections&&this._interiorIntersection!==null},ve.prototype.interfaces_=function(){return[n7]},ve.prototype.getClass=function(){return ve},ve.createAllIntersectionsFinder=function(s){var a=new ve(s);return a.setFindAllIntersections(!0),a},ve.createAnyIntersectionFinder=function(s){return new ve(s)},ve.createIntersectionCounter=function(s){var a=new ve(s);return a.setFindAllIntersections(!0),a.setKeepIntersections(!1),a};var L6=function(){this._li=new PA,this._segStrings=null,this._findAllIntersections=!1,this._segInt=null,this._isValid=!0;var s=arguments[0];this._segStrings=s};L6.prototype.execute=function(){if(this._segInt!==null)return null;this.checkInteriorIntersections()},L6.prototype.getIntersections=function(){return this._segInt.getIntersections()},L6.prototype.isValid=function(){return this.execute(),this._isValid},L6.prototype.setFindAllIntersections=function(s){this._findAllIntersections=s},L6.prototype.checkInteriorIntersections=function(){this._isValid=!0,this._segInt=new ve(this._li),this._segInt.setFindAllIntersections(this._findAllIntersections);var s=new M_;if(s.setSegmentIntersector(this._segInt),s.computeNodes(this._segStrings),this._segInt.hasIntersection())return this._isValid=!1,null},L6.prototype.checkValid=function(){if(this.execute(),!this._isValid)throw new GA(this.getErrorMessage(),this._segInt.getInteriorIntersection())},L6.prototype.getErrorMessage=function(){if(this._isValid)return"no intersections found";var s=this._segInt.getIntersectionSegments();return"found non-noded intersection between "+cj.toLineString(s[0],s[1])+" and "+cj.toLineString(s[2],s[3])},L6.prototype.interfaces_=function(){return[]},L6.prototype.getClass=function(){return L6},L6.computeIntersections=function(s){var a=new L6(s);return a.setFindAllIntersections(!0),a.isValid(),a.getIntersections()};var s7=function s(){this._nv=null;var a=arguments[0];this._nv=new L6(s.toSegmentStrings(a))};s7.prototype.checkValid=function(){this._nv.checkValid()},s7.prototype.interfaces_=function(){return[]},s7.prototype.getClass=function(){return s7},s7.toSegmentStrings=function(s){for(var a=new nA,u=s.iterator();u.hasNext();){var f=u.next();a.add(new ci(f.getCoordinates(),f))}return a},s7.checkValid=function(s){new s7(s).checkValid()};var Ol=function(s){this._mapOp=s};Ol.prototype.map=function(s){for(var a=new nA,u=0;u0&&f<4&&!this._preserveType?this._factory.createLineString(u):this._factory.createLinearRing(u)},Ir.prototype.interfaces_=function(){return[]},Ir.prototype.getClass=function(){return Ir};var Ci=function s(){if(this._snapTolerance=0,this._srcPts=null,this._seg=new CA,this._allowSnappingToSourceVertices=!1,this._isClosed=!1,arguments[0]instanceof Bj&&typeof arguments[1]=="number"){var a=arguments[0],u=arguments[1];s.call(this,a.getCoordinates(),u)}else if(arguments[0]instanceof Array&&typeof arguments[1]=="number"){var f=arguments[0],p=arguments[1];this._srcPts=f,this._isClosed=s.isClosed(f),this._snapTolerance=p}};Ci.prototype.snapVertices=function(s,a){for(var u=this._isClosed?s.size()-1:s.size(),f=0;f=0&&s.add($+1,new F(p),!1)}},Ci.prototype.findSegmentIndexToSnap=function(s,a){for(var u=v.MAX_VALUE,f=-1,p=0;pa&&(a=f)}return a}if(arguments.length===2){var p=arguments[0],$=arguments[1];return Math.min(Dj.computeOverlaySnapTolerance(p),Dj.computeOverlaySnapTolerance($))}},Dj.computeSizeBasedSnapTolerance=function(s){var a=s.getEnvelopeInternal();return Math.min(a.getHeight(),a.getWidth())*Dj.SNAP_PRECISION_FACTOR},Dj.snapToSelf=function(s,a,u){return new Dj(s).snapToSelf(a,u)},h8.SNAP_PRECISION_FACTOR.get=function(){return 1e-9},Object.defineProperties(Dj,h8);var d8=function(s){function a(u,f,p){s.call(this),this._snapTolerance=u||null,this._snapPts=f||null,this._isSelfSnap=p!==void 0&&p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.snapLine=function(u,f){var p=new Ci(u,this._snapTolerance);return p.setAllowSnappingToSourceVertices(this._isSelfSnap),p.snapTo(f)},a.prototype.transformCoordinates=function(u,f){var p=u.toCoordinateArray(),$=this.snapLine(p,this._snapPts);return this._factory.getCoordinateSequenceFactory().create($)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Ir),cr=function(){this._isFirst=!0,this._commonMantissaBitsCount=53,this._commonBits=0,this._commonSignExp=null};cr.prototype.getCommon=function(){return v.longBitsToDouble(this._commonBits)},cr.prototype.add=function(s){var a=v.doubleToLongBits(s);if(this._isFirst)return this._commonBits=a,this._commonSignExp=cr.signExpBits(this._commonBits),this._isFirst=!1,null;if(cr.signExpBits(a)!==this._commonSignExp)return this._commonBits=0,null;this._commonMantissaBitsCount=cr.numCommonMostSigMantissaBits(this._commonBits,a),this._commonBits=cr.zeroLowerBits(this._commonBits,64-(12+this._commonMantissaBitsCount))},cr.prototype.toString=function(){if(arguments.length===1){var s=arguments[0],a=v.longBitsToDouble(s),u="0000000000000000000000000000000000000000000000000000000000000000"+v.toBinaryString(s),f=u.substring(u.length-64);return f.substring(0,1)+" "+f.substring(1,12)+"(exp) "+f.substring(12)+" [ "+a+" ]"}},cr.prototype.interfaces_=function(){return[]},cr.prototype.getClass=function(){return cr},cr.getBit=function(s,a){return s&1<>52},cr.zeroLowerBits=function(s,a){return s&~((1<=0;f--){if(cr.getBit(s,f)!==cr.getBit(a,f))return u;u++}return 52};var Xs=function(){this._commonCoord=null,this._ccFilter=new Sl},L_={CommonCoordinateFilter:{configurable:!0},Translater:{configurable:!0}};Xs.prototype.addCommonBits=function(s){var a=new zs(this._commonCoord);s.apply(a),s.geometryChanged()},Xs.prototype.removeCommonBits=function(s){if(this._commonCoord.x===0&&this._commonCoord.y===0)return s;var a=new F(this._commonCoord);a.x=-a.x,a.y=-a.y;var u=new zs(a);return s.apply(u),s.geometryChanged(),s},Xs.prototype.getCommonCoordinate=function(){return this._commonCoord},Xs.prototype.add=function(s){s.apply(this._ccFilter),this._commonCoord=this._ccFilter.getCommonCoordinate()},Xs.prototype.interfaces_=function(){return[]},Xs.prototype.getClass=function(){return Xs},L_.CommonCoordinateFilter.get=function(){return Sl},L_.Translater.get=function(){return zs},Object.defineProperties(Xs,L_);var Sl=function(){this._commonBitsX=new cr,this._commonBitsY=new cr};Sl.prototype.filter=function(s){this._commonBitsX.add(s.x),this._commonBitsY.add(s.y)},Sl.prototype.getCommonCoordinate=function(){return new F(this._commonBitsX.getCommon(),this._commonBitsY.getCommon())},Sl.prototype.interfaces_=function(){return[J]},Sl.prototype.getClass=function(){return Sl};var zs=function(){this.trans=null;var s=arguments[0];this.trans=s};zs.prototype.filter=function(s,a){var u=s.getOrdinate(a,0)+this.trans.x,f=s.getOrdinate(a,1)+this.trans.y;s.setOrdinate(a,0,u),s.setOrdinate(a,1,f)},zs.prototype.isDone=function(){return!1},zs.prototype.isGeometryChanged=function(){return!0},zs.prototype.interfaces_=function(){return[gj]},zs.prototype.getClass=function(){return zs};var _e=function(s,a){this._geom=new Array(2).fill(null),this._snapTolerance=null,this._cbr=null,this._geom[0]=s,this._geom[1]=a,this.computeSnapTolerance()};_e.prototype.selfSnap=function(s){return new Dj(s).snapTo(s,this._snapTolerance)},_e.prototype.removeCommonBits=function(s){this._cbr=new Xs,this._cbr.add(s[0]),this._cbr.add(s[1]);var a=new Array(2).fill(null);return a[0]=this._cbr.removeCommonBits(s[0].copy()),a[1]=this._cbr.removeCommonBits(s[1].copy()),a},_e.prototype.prepareResult=function(s){return this._cbr.addCommonBits(s),s},_e.prototype.getResultGeometry=function(s){var a=this.snap(this._geom),u=nt.overlayOp(a[0],a[1],s);return this.prepareResult(u)},_e.prototype.checkValid=function(s){s.isValid()||qA.out.println("Snapped geometry is invalid")},_e.prototype.computeSnapTolerance=function(){this._snapTolerance=Dj.computeOverlaySnapTolerance(this._geom[0],this._geom[1])},_e.prototype.snap=function(s){var a=this.removeCommonBits(s);return Dj.snap(a[0],a[1],this._snapTolerance)},_e.prototype.interfaces_=function(){return[]},_e.prototype.getClass=function(){return _e},_e.overlayOp=function(s,a,u){return new _e(s,a).getResultGeometry(u)},_e.union=function(s,a){return _e.overlayOp(s,a,nt.UNION)},_e.intersection=function(s,a){return _e.overlayOp(s,a,nt.INTERSECTION)},_e.symDifference=function(s,a){return _e.overlayOp(s,a,nt.SYMDIFFERENCE)},_e.difference=function(s,a){return _e.overlayOp(s,a,nt.DIFFERENCE)};var ur=function(s,a){this._geom=new Array(2).fill(null),this._geom[0]=s,this._geom[1]=a};ur.prototype.getResultGeometry=function(s){var a=null,u=!1,f=null;try{a=nt.overlayOp(this._geom[0],this._geom[1],s),u=!0}catch(p){if(!(p instanceof ce))throw p;f=p}if(!u)try{a=_e.overlayOp(this._geom[0],this._geom[1],s)}catch(p){throw p instanceof ce?f:p}return a},ur.prototype.interfaces_=function(){return[]},ur.prototype.getClass=function(){return ur},ur.overlayOp=function(s,a,u){return new ur(s,a).getResultGeometry(u)},ur.union=function(s,a){return ur.overlayOp(s,a,nt.UNION)},ur.intersection=function(s,a){return ur.overlayOp(s,a,nt.INTERSECTION)},ur.symDifference=function(s,a){return ur.overlayOp(s,a,nt.SYMDIFFERENCE)},ur.difference=function(s,a){return ur.overlayOp(s,a,nt.DIFFERENCE)};var fh=function(){this.mce=null,this.chainIndex=null;var s=arguments[0],a=arguments[1];this.mce=s,this.chainIndex=a};fh.prototype.computeIntersections=function(s,a){this.mce.computeIntersectsForChain(this.chainIndex,s.mce,s.chainIndex,a)},fh.prototype.interfaces_=function(){return[]},fh.prototype.getClass=function(){return fh};var tn=function s(){if(this._label=null,this._xValue=null,this._eventType=null,this._insertEvent=null,this._deleteEventIndex=null,this._obj=null,arguments.length===2){var a=arguments[0],u=arguments[1];this._eventType=s.DELETE,this._xValue=a,this._insertEvent=u}else if(arguments.length===3){var f=arguments[0],p=arguments[1],$=arguments[2];this._eventType=s.INSERT,this._label=f,this._xValue=p,this._obj=$}},C_={INSERT:{configurable:!0},DELETE:{configurable:!0}};tn.prototype.isDelete=function(){return this._eventType===tn.DELETE},tn.prototype.setDeleteEventIndex=function(s){this._deleteEventIndex=s},tn.prototype.getObject=function(){return this._obj},tn.prototype.compareTo=function(s){var a=s;return this._xValuea._xValue?1:this._eventTypea._eventType?1:0},tn.prototype.getInsertEvent=function(){return this._insertEvent},tn.prototype.isInsert=function(){return this._eventType===tn.INSERT},tn.prototype.isSameLabel=function(s){return this._label!==null&&this._label===s._label},tn.prototype.getDeleteEventIndex=function(){return this._deleteEventIndex},tn.prototype.interfaces_=function(){return[w]},tn.prototype.getClass=function(){return tn},C_.INSERT.get=function(){return 1},C_.DELETE.get=function(){return 2},Object.defineProperties(tn,C_);var fg=function(){};fg.prototype.interfaces_=function(){return[]},fg.prototype.getClass=function(){return fg};var Le=function(){this._hasIntersection=!1,this._hasProper=!1,this._hasProperInterior=!1,this._properIntersectionPoint=null,this._li=null,this._includeProper=null,this._recordIsolated=null,this._isSelfIntersection=null,this._numIntersections=0,this.numTests=0,this._bdyNodes=null,this._isDone=!1,this._isDoneWhenProperInt=!1;var s=arguments[0],a=arguments[1],u=arguments[2];this._li=s,this._includeProper=a,this._recordIsolated=u};Le.prototype.isTrivialIntersection=function(s,a,u,f){if(s===u&&this._li.getIntersectionNum()===1){if(Le.isAdjacentSegments(a,f))return!0;if(s.isClosed()){var p=s.getNumPoints()-1;if(a===0&&f===p||f===0&&a===p)return!0}}return!1},Le.prototype.getProperIntersectionPoint=function(){return this._properIntersectionPoint},Le.prototype.setIsDoneIfProperInt=function(s){this._isDoneWhenProperInt=s},Le.prototype.hasProperInteriorIntersection=function(){return this._hasProperInterior},Le.prototype.isBoundaryPointInternal=function(s,a){for(var u=a.iterator();u.hasNext();){var f=u.next().getCoordinate();if(s.isIntersection(f))return!0}return!1},Le.prototype.hasProperIntersection=function(){return this._hasProper},Le.prototype.hasIntersection=function(){return this._hasIntersection},Le.prototype.isDone=function(){return this._isDone},Le.prototype.isBoundaryPoint=function(s,a){return a!==null&&(!!this.isBoundaryPointInternal(s,a[0])||!!this.isBoundaryPointInternal(s,a[1]))},Le.prototype.setBoundaryNodes=function(s,a){this._bdyNodes=new Array(2).fill(null),this._bdyNodes[0]=s,this._bdyNodes[1]=a},Le.prototype.addIntersections=function(s,a,u,f){if(s===u&&a===f)return null;this.numTests++;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&(this._recordIsolated&&(s.setIsolated(!1),u.setIsolated(!1)),this._numIntersections++,this.isTrivialIntersection(s,a,u,f)||(this._hasIntersection=!0,!this._includeProper&&this._li.isProper()||(s.addIntersections(this._li,a,0),u.addIntersections(this._li,f,1)),this._li.isProper()&&(this._properIntersectionPoint=this._li.getIntersection(0).copy(),this._hasProper=!0,this._isDoneWhenProperInt&&(this._isDone=!0),this.isBoundaryPoint(this._li,this._bdyNodes)||(this._hasProperInterior=!0))))},Le.prototype.interfaces_=function(){return[]},Le.prototype.getClass=function(){return Le},Le.isAdjacentSegments=function(s,a){return Math.abs(s-a)===1};var o9=function(s){function a(){s.call(this),this.events=new nA,this.nOverlaps=null}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.prepareEvents=function(){T6.sort(this.events);for(var u=0;ua||this._max$?1:0},hh.prototype.interfaces_=function(){return[S]},hh.prototype.getClass=function(){return hh};var s9=function(s){function a(){s.call(this),this._item=null;var u=arguments[0],f=arguments[1],p=arguments[2];this._min=u,this._max=f,this._item=p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.query=function(u,f,p){if(!this.intersects(u,f))return null;p.visitItem(this._item)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Hi),a9=function(s){function a(){s.call(this),this._node1=null,this._node2=null;var u=arguments[0],f=arguments[1];this._node1=u,this._node2=f,this.buildExtent(this._node1,this._node2)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.buildExtent=function(u,f){this._min=Math.min(u._min,f._min),this._max=Math.max(u._max,f._max)},a.prototype.query=function(u,f,p){if(!this.intersects(u,f))return null;this._node1!==null&&this._node1.query(u,f,p),this._node2!==null&&this._node2.query(u,f,p)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Hi),Di=function(){this._leaves=new nA,this._root=null,this._level=0};Di.prototype.buildTree=function(){T6.sort(this._leaves,new Hi.NodeComparator);for(var s=this._leaves,a=null,u=new nA;;){if(this.buildLevel(s,u),u.size()===1)return u.get(0);a=s,s=u,u=a}},Di.prototype.insert=function(s,a,u){if(this._root!==null)throw new Error("Index cannot be added to once it has been queried");this._leaves.add(new s9(s,a,u))},Di.prototype.query=function(s,a,u){this.init(),this._root.query(s,a,u)},Di.prototype.buildRoot=function(){if(this._root!==null)return null;this._root=this.buildTree()},Di.prototype.printNode=function(s){qA.out.println(cj.toLineString(new F(s._min,this._level),new F(s._max,this._level)))},Di.prototype.init=function(){if(this._root!==null)return null;this.buildRoot()},Di.prototype.buildLevel=function(s,a){this._level++,a.clear();for(var u=0;u=2,"found LineString with single point"),this.insertBoundaryPoint(this._argIndex,f[0]),this.insertBoundaryPoint(this._argIndex,f[f.length-1])},a.prototype.getInvalidPoint=function(){return this._invalidPoint},a.prototype.getBoundaryPoints=function(){for(var u=this.getBoundaryNodes(),f=new Array(u.size()).fill(null),p=0,$=u.iterator();$.hasNext();){var q=$.next();f[p++]=q.getCoordinate().copy()}return f},a.prototype.getBoundaryNodes=function(){return this._boundaryNodes===null&&(this._boundaryNodes=this._nodes.getBoundaryNodes(this._argIndex)),this._boundaryNodes},a.prototype.addSelfIntersectionNode=function(u,f,p){if(this.isBoundaryNode(u,f))return null;p===T.BOUNDARY&&this._useBoundaryDeterminationRule?this.insertBoundaryPoint(u,f):this.insertPoint(u,f,p)},a.prototype.addPolygonRing=function(u,f,p){if(u.isEmpty())return null;var $=BA.removeRepeatedPoints(u.getCoordinates());if($.length<4)return this._hasTooFewPoints=!0,this._invalidPoint=$[0],null;var q=f,M=p;EA.isCCW($)&&(q=p,M=f);var C=new Bg($,new rt(this._argIndex,T.BOUNDARY,q,M));this._lineEdgeMap.put(u,C),this.insertEdge(C),this.insertPoint(this._argIndex,$[0],T.BOUNDARY)},a.prototype.insertPoint=function(u,f,p){var $=this._nodes.addNode(f),q=$.getLabel();q===null?$._label=new rt(u,p):q.setLocation(u,p)},a.prototype.createEdgeSetIntersector=function(){return new o9},a.prototype.addSelfIntersectionNodes=function(u){for(var f=this._edges.iterator();f.hasNext();)for(var p=f.next(),$=p.getLabel().getLocation(u),q=p.eiList.iterator();q.hasNext();){var M=q.next();this.addSelfIntersectionNode(u,M.coord,$)}},a.prototype.add=function(){if(arguments.length!==1)return s.prototype.add.apply(this,arguments);var u=arguments[0];if(u.isEmpty())return null;if(u instanceof xe&&(this._useBoundaryDeterminationRule=!1),u instanceof Wt)this.addPolygon(u);else if(u instanceof Bj)this.addLineString(u);else if(u instanceof ir)this.addPoint(u);else if(u instanceof M6)this.addCollection(u);else if(u instanceof Gr)this.addCollection(u);else if(u instanceof xe)this.addCollection(u);else{if(!(u instanceof oj))throw new Error(u.getClass().getName());this.addCollection(u)}},a.prototype.addCollection=function(u){for(var f=0;f50?(this._areaPtLocator===null&&(this._areaPtLocator=new ku(this._parentGeom)),this._areaPtLocator.locate(u)):this._ptLocator.locate(u,this._parentGeom)},a.prototype.findEdge=function(){if(arguments.length===1){var u=arguments[0];return this._lineEdgeMap.get(u)}return s.prototype.findEdge.apply(this,arguments)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.determineBoundary=function(u,f){return u.isInBoundary(f)?T.BOUNDARY:T.INTERIOR},a}(Gj),mu=function(){if(this._li=new PA,this._resultPrecisionModel=null,this._arg=null,arguments.length===1){var s=arguments[0];this.setComputationPrecision(s.getPrecisionModel()),this._arg=new Array(1).fill(null),this._arg[0]=new dh(0,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=P.OGC_SFS_BOUNDARY_RULE;a.getPrecisionModel().compareTo(u.getPrecisionModel())>=0?this.setComputationPrecision(a.getPrecisionModel()):this.setComputationPrecision(u.getPrecisionModel()),this._arg=new Array(2).fill(null),this._arg[0]=new dh(0,a,f),this._arg[1]=new dh(1,u,f)}else if(arguments.length===3){var p=arguments[0],$=arguments[1],q=arguments[2];p.getPrecisionModel().compareTo($.getPrecisionModel())>=0?this.setComputationPrecision(p.getPrecisionModel()):this.setComputationPrecision($.getPrecisionModel()),this._arg=new Array(2).fill(null),this._arg[0]=new dh(0,p,q),this._arg[1]=new dh(1,$,q)}};mu.prototype.getArgGeometry=function(s){return this._arg[s].getGeometry()},mu.prototype.setComputationPrecision=function(s){this._resultPrecisionModel=s,this._li.setPrecisionModel(this._resultPrecisionModel)},mu.prototype.interfaces_=function(){return[]},mu.prototype.getClass=function(){return mu};var l7=function(){};l7.prototype.interfaces_=function(){return[]},l7.prototype.getClass=function(){return l7},l7.map=function(){if(arguments[0]instanceof MA&&G(arguments[1],l7.MapOp)){for(var s=arguments[0],a=arguments[1],u=new nA,f=0;f=s.size()?null:s.get(a)},Wj.union=function(s){return new Wj(s).union()},g8.STRTREE_NODE_CAPACITY.get=function(){return 4},Object.defineProperties(Wj,g8);var ph=function(){};ph.prototype.interfaces_=function(){return[]},ph.prototype.getClass=function(){return ph},ph.union=function(s,a){if(s.isEmpty()||a.isEmpty()){if(s.isEmpty()&&a.isEmpty())return nt.createEmptyResult(nt.UNION,s,a,s.getFactory());if(s.isEmpty())return a.copy();if(a.isEmpty())return s.copy()}return s.checkNotGeometryCollection(s),s.checkNotGeometryCollection(a),ur.overlayOp(s,a,nt.UNION)},t.GeoJSONReader=R,t.GeoJSONWriter=N,t.OverlayOp=nt,t.UnionOp=ph,t.BufferOp=Oe,Object.defineProperty(t,"__esModule",{value:!0})})});var wy=C6((P1,I1)=>{(function(t,A){typeof P1=="object"&&typeof I1<"u"?I1.exports=A():(t=typeof globalThis<"u"?globalThis:t||self,t.polygonClipping=A())})(P1,function(){"use strict";function t(J,P){var O={label:0,sent:function(){if(U[0]&1)throw U[1];return U[1]},trys:[],ops:[]},K,V,U,lA;return lA={next:rA(0),throw:rA(1),return:rA(2)},typeof Symbol=="function"&&(lA[Symbol.iterator]=function(){return this}),lA;function rA(uA){return function(nA){return hA([uA,nA])}}function hA(uA){if(K)throw new TypeError("Generator is already executing.");for(;O;)try{if(K=1,V&&(U=uA[0]&2?V.return:uA[0]?V.throw||((U=V.return)&&U.call(V),0):V.next)&&!(U=U.call(V,uA[1])).done)return U;switch(V=0,U&&(uA=[uA[0]&2,U.value]),uA[0]){case 0:case 1:U=uA;break;case 4:return O.label++,{value:uA[1],done:!1};case 5:O.label++,V=uA[1],uA=[0];continue;case 7:uA=O.ops.pop(),O.trys.pop();continue;default:if(U=O.trys,!(U=U.length>0&&U[U.length-1])&&(uA[0]===6||uA[0]===2)){O=0;continue}if(uA[0]===3&&(!U||uA[1]>U[0]&&uA[1]P?1:J0){if(P.right===null)break;if(O(J,P.right.key)>0){var rA=P.right;if(P.right=rA.left,rA.left=P,P=rA,P.right===null)break}V.right=P,V=P,P=P.right}else break}return V.right=P.left,U.left=P.right,P.left=K.right,P.right=K.left,P}function r(J,P,O,K){var V=new A(J,P);if(O===null)return V.left=V.right=null,V;O=e(J,O,K);var U=K(J,O.key);return U<0?(V.left=O.left,V.right=O,O.left=null):U>=0&&(V.right=O.right,V.left=O,O.right=null),V}function n(J,P,O){var K=null,V=null;if(P){P=e(J,P,O);var U=O(P.key,J);U===0?(K=P.left,V=P.right):U<0?(V=P.right,P.right=null,K=P):(K=P.left,P.left=null,V=P)}return{left:K,right:V}}function i(J,P,O){return P===null?J:(J===null||(P=e(J.key,P,O),P.left=J),P)}function o(J,P,O,K,V){if(J){K(""+P+(O?"\u2514\u2500\u2500 ":"\u251C\u2500\u2500 ")+V(J)+` -`);var U=P+(O?" ":"\u2502 ");J.left&&o(J.left,U,!1,K,V),J.right&&o(J.right,U,!0,K,V)}}var l=function(){function J(P){P===void 0&&(P=j),this._root=null,this._size=0,this._comparator=P}return J.prototype.insert=function(P,O){return this._size++,this._root=r(P,O,this._root,this._comparator)},J.prototype.add=function(P,O){var K=new A(P,O);this._root===null&&(K.left=K.right=null,this._size++,this._root=K);var V=this._comparator,U=e(P,this._root,V),lA=V(P,U.key);return lA===0?this._root=U:(lA<0?(K.left=U.left,K.right=U,U.left=null):lA>0&&(K.right=U.right,K.left=U,U.right=null),this._size++,this._root=K),this._root},J.prototype.remove=function(P){this._root=this._remove(P,this._root,this._comparator)},J.prototype._remove=function(P,O,K){var V;if(O===null)return null;O=e(P,O,K);var U=K(P,O.key);return U===0?(O.left===null?V=O.right:(V=e(P,O.left,K),V.right=O.right),this._size--,V):O},J.prototype.pop=function(){var P=this._root;if(P){for(;P.left;)P=P.left;return this._root=e(P.key,this._root,this._comparator),this._root=this._remove(P.key,this._root,this._comparator),{key:P.key,data:P.data}}return null},J.prototype.findStatic=function(P){for(var O=this._root,K=this._comparator;O;){var V=K(P,O.key);if(V===0)return O;V<0?O=O.left:O=O.right}return null},J.prototype.find=function(P){return this._root&&(this._root=e(P,this._root,this._comparator),this._comparator(P,this._root.key)!==0)?null:this._root},J.prototype.contains=function(P){for(var O=this._root,K=this._comparator;O;){var V=K(P,O.key);if(V===0)return!0;V<0?O=O.left:O=O.right}return!1},J.prototype.forEach=function(P,O){for(var K=this._root,V=[],U=!1;!U;)K!==null?(V.push(K),K=K.left):V.length!==0?(K=V.pop(),P.call(O,K),K=K.right):U=!0;return this},J.prototype.range=function(P,O,K,V){for(var U=[],lA=this._comparator,rA=this._root,hA;U.length!==0||rA;)if(rA)U.push(rA),rA=rA.left;else{if(rA=U.pop(),hA=lA(rA.key,O),hA>0)break;if(lA(rA.key,P)>=0&&K.call(V,rA))return this;rA=rA.right}return this},J.prototype.keys=function(){var P=[];return this.forEach(function(O){var K=O.key;return P.push(K)}),P},J.prototype.values=function(){var P=[];return this.forEach(function(O){var K=O.data;return P.push(K)}),P},J.prototype.min=function(){return this._root?this.minNode(this._root).key:null},J.prototype.max=function(){return this._root?this.maxNode(this._root).key:null},J.prototype.minNode=function(P){if(P===void 0&&(P=this._root),P)for(;P.left;)P=P.left;return P},J.prototype.maxNode=function(P){if(P===void 0&&(P=this._root),P)for(;P.right;)P=P.right;return P},J.prototype.at=function(P){for(var O=this._root,K=!1,V=0,U=[];!K;)if(O)U.push(O),O=O.left;else if(U.length>0){if(O=U.pop(),V===P)return O;V++,O=O.right}else K=!0;return null},J.prototype.next=function(P){var O=this._root,K=null;if(P.right){for(K=P.right;K.left;)K=K.left;return K}for(var V=this._comparator;O;){var U=V(P.key,O.key);if(U===0)break;U<0?(K=O,O=O.left):O=O.right}return K},J.prototype.prev=function(P){var O=this._root,K=null;if(P.left!==null){for(K=P.left;K.right;)K=K.right;return K}for(var V=this._comparator;O;){var U=V(P.key,O.key);if(U===0)break;U<0?O=O.left:(K=O,O=O.right)}return K},J.prototype.clear=function(){return this._root=null,this._size=0,this},J.prototype.toList=function(){return h(this._root)},J.prototype.load=function(P,O,K){O===void 0&&(O=[]),K===void 0&&(K=!1);var V=P.length,U=this._comparator;if(K&&g(P,O,0,V-1,U),this._root===null)this._root=c(P,O,0,V),this._size=V;else{var lA=k(this.toList(),B(P,O),U);V=this._size+V,this._root=d({head:lA},0,V)}return this},J.prototype.isEmpty=function(){return this._root===null},Object.defineProperty(J.prototype,"size",{get:function(){return this._size},enumerable:!0,configurable:!0}),Object.defineProperty(J.prototype,"root",{get:function(){return this._root},enumerable:!0,configurable:!0}),J.prototype.toString=function(P){P===void 0&&(P=function(K){return String(K.key)});var O=[];return o(this._root,"",!0,function(K){return O.push(K)},P),O.join("")},J.prototype.update=function(P,O,K){var V=this._comparator,U=n(P,this._root,V),lA=U.left,rA=U.right;V(P,O)<0?rA=r(O,K,rA,V):lA=r(O,K,lA,V),this._root=i(lA,rA,V)},J.prototype.split=function(P){return n(P,this._root,this._comparator)},J.prototype[Symbol.iterator]=function(){var P,O,K;return t(this,function(V){switch(V.label){case 0:P=this._root,O=[],K=!1,V.label=1;case 1:return K?[3,6]:P===null?[3,2]:(O.push(P),P=P.left,[3,5]);case 2:return O.length===0?[3,4]:(P=O.pop(),[4,P]);case 3:return V.sent(),P=P.right,[3,5];case 4:K=!0,V.label=5;case 5:return[3,1];case 6:return[2]}})},J}();function c(J,P,O,K){var V=K-O;if(V>0){var U=O+Math.floor(V/2),lA=J[U],rA=P[U],hA=new A(lA,rA);return hA.left=c(J,P,O,U),hA.right=c(J,P,U+1,K),hA}return null}function B(J,P){for(var O=new A(null,null),K=O,V=0;V0?(P=U=U.next=O.pop(),P=P.right):K=!0;return U.next=null,V.next}function d(J,P,O){var K=O-P;if(K>0){var V=P+Math.floor(K/2),U=d(J,P,V),lA=J.head;return lA.left=U,J.head=J.head.next,lA.right=d(J,V+1,O),lA}return null}function k(J,P,O){for(var K=new A(null,null),V=K,U=J,lA=P;U!==null&&lA!==null;)O(U.key,lA.key)<0?(V.next=U,U=U.next):(V.next=lA,lA=lA.next),V=V.next;return U!==null?V.next=U:lA!==null&&(V.next=lA),K.next}function g(J,P,O,K,V){if(!(O>=K)){for(var U=J[O+K>>1],lA=O-1,rA=K+1;;){do lA++;while(V(J[lA],U)<0);do rA--;while(V(J[rA],U)>0);if(lA>=rA)break;var hA=J[lA];J[lA]=J[rA],J[rA]=hA,hA=P[lA],P[lA]=P[rA],P[rA]=hA}g(J,P,O,rA,V),g(J,P,rA+1,K,V)}}let E=(J,P)=>J.ll.x<=P.x&&P.x<=J.ur.x&&J.ll.y<=P.y&&P.y<=J.ur.y,m=(J,P)=>{if(P.ur.x{if(-yuA==nA>-uA?(U=uA,uA=P[++sA]):(U=nA,nA=K[++kA]);let BA=0;if(sAuA==nA>-uA?(lA=uA+U,rA=U-(lA-uA),uA=P[++sA]):(lA=nA+U,rA=U-(lA-nA),nA=K[++kA]),U=lA,rA!==0&&(V[BA++]=rA);sAuA==nA>-uA?(lA=U+uA,hA=lA-U,rA=U-(lA-hA)+(uA-hA),uA=P[++sA]):(lA=U+nA,hA=lA-U,rA=U-(lA-hA)+(nA-hA),nA=K[++kA]),U=lA,rA!==0&&(V[BA++]=rA);for(;sA=Gr||-oj>=Gr||(sA=J-jt,rA=J-(jt+sA)+(sA-V),sA=O-_j,uA=O-(_j+sA)+(sA-V),sA=P-qj,hA=P-(qj+sA)+(sA-U),sA=K-gj,nA=K-(gj+sA)+(sA-U),rA===0&&hA===0&&uA===0&&nA===0)||(Gr=jA*lA+D*Math.abs(oj),oj+=jt*nA+gj*rA-(qj*uA+_j*hA),oj>=Gr||-oj>=Gr))return oj;Vj=rA*gj,kA=F*rA,BA=kA-(kA-rA),tt=rA-BA,kA=F*gj,UA=kA-(kA-gj),wt=gj-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=hA*_j,kA=F*hA,BA=kA-(kA-hA),tt=hA-BA,kA=F*_j,UA=kA-(kA-_j),wt=_j-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let Fe=L(4,pA,4,Y,dA);Vj=jt*nA,kA=F*jt,BA=kA-(kA-jt),tt=jt-BA,kA=F*nA,UA=kA-(kA-nA),wt=nA-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=qj*uA,kA=F*qj,BA=kA-(kA-qj),tt=qj-BA,kA=F*uA,UA=kA-(kA-uA),wt=uA-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let c6=L(Fe,dA,4,Y,$A);Vj=rA*nA,kA=F*rA,BA=kA-(kA-rA),tt=rA-BA,kA=F*nA,UA=kA-(kA-nA),wt=nA-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=hA*uA,kA=F*hA,BA=kA-(kA-hA),tt=hA-BA,kA=F*uA,UA=kA-(kA-uA),wt=uA-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let ue=L(c6,$A,4,Y,_A);return _A[ue-1]}function mt(J,P,O,K,V,U){let lA=(P-U)*(O-V),rA=(J-V)*(K-U),hA=lA-rA,uA=Math.abs(lA+rA);return Math.abs(hA)>=W*uA?hA:-QA(J,P,O,K,V,U,uA)}let Ct=(J,P)=>J.x*P.y-J.y*P.x,SA=(J,P)=>J.x*P.x+J.y*P.y,ft=(J,P,O)=>{let K=mt(J.x,J.y,P.x,P.y,O.x,O.y);return K>0?-1:K<0?1:0},wA=J=>Math.sqrt(SA(J,J)),_t=(J,P,O)=>{let K={x:P.x-J.x,y:P.y-J.y},V={x:O.x-J.x,y:O.y-J.y};return Ct(V,K)/wA(V)/wA(K)},qA=(J,P,O)=>{let K={x:P.x-J.x,y:P.y-J.y},V={x:O.x-J.x,y:O.y-J.y};return SA(V,K)/wA(V)/wA(K)},Ht=(J,P,O)=>P.y===0?null:{x:J.x+P.x/P.y*(O-J.y),y:O},bA=(J,P,O)=>P.x===0?null:{x:O,y:J.y+P.y/P.x*(O-J.x)},l6=(J,P,O,K)=>{if(P.x===0)return bA(O,K,J.x);if(K.x===0)return bA(J,P,O.x);if(P.y===0)return Ht(O,K,J.y);if(K.y===0)return Ht(J,P,O.y);let V=Ct(P,K);if(V==0)return null;let U={x:O.x-J.x,y:O.y-J.y},lA=Ct(U,P)/V,rA=Ct(U,K)/V,hA=J.x+rA*P.x,uA=O.x+lA*K.x,nA=J.y+rA*P.y,sA=O.y+lA*K.y,kA=(hA+uA)/2,BA=(nA+sA)/2;return{x:kA,y:BA}};class Tt{static compare(P,O){let K=Tt.comparePoints(P.point,O.point);return K!==0?K:(P.point!==O.point&&P.link(O),P.isLeft!==O.isLeft?P.isLeft?1:-1:FA.compare(P.segment,O.segment))}static comparePoints(P,O){return P.xO.x?1:P.yO.y?1:0}constructor(P,O){P.events===void 0?P.events=[this]:P.events.push(this),this.point=P,this.isLeft=O}link(P){if(P.point===this.point)throw new Error("Tried to link already linked events");let O=P.point.events;for(let K=0,V=O.length;K{let U=V.otherSE;O.set(V,{sine:_t(this.point,P.point,U.point),cosine:qA(this.point,P.point,U.point)})};return(V,U)=>{O.has(V)||K(V),O.has(U)||K(U);let{sine:lA,cosine:rA}=O.get(V),{sine:hA,cosine:uA}=O.get(U);return lA>=0&&hA>=0?rAuA?-1:0:lA<0&&hA<0?rAuA?1:0:hAlA?1:0}}}let me=0;class FA{static compare(P,O){let K=P.leftSE.point.x,V=O.leftSE.point.x,U=P.rightSE.point.x,lA=O.rightSE.point.x;if(lArA&&hA>uA)return-1;let sA=P.comparePoint(O.leftSE.point);if(sA<0)return 1;if(sA>0)return-1;let kA=O.comparePoint(P.rightSE.point);return kA!==0?kA:-1}if(K>V){if(rAhA&&rA>nA)return 1;let sA=O.comparePoint(P.leftSE.point);if(sA!==0)return sA;let kA=P.comparePoint(O.rightSE.point);return kA<0?1:kA>0?-1:1}if(rAhA)return 1;if(UlA){let sA=P.comparePoint(O.rightSE.point);if(sA<0)return 1;if(sA>0)return-1}if(U!==lA){let sA=uA-rA,kA=U-K,BA=nA-hA,tt=lA-V;if(sA>kA&&BAtt)return-1}return U>lA?1:UnA?1:P.idO.id?1:0}constructor(P,O,K,V){this.id=++me,this.leftSE=P,P.segment=this,P.otherSE=O,this.rightSE=O,O.segment=this,O.otherSE=P,this.rings=K,this.windings=V}static fromRing(P,O,K){let V,U,lA,rA=Tt.comparePoints(P,O);if(rA<0)V=P,U=O,lA=1;else if(rA>0)V=O,U=P,lA=-1;else throw new Error(`Tried to create degenerate segment at [${P.x}, ${P.y}]`);let hA=new Tt(V,!0),uA=new Tt(U,!1);return new FA(hA,uA,[K],[lA])}replaceRightSE(P){this.rightSE=P,this.rightSE.segment=this,this.rightSE.otherSE=this.leftSE,this.leftSE.otherSE=this.rightSE}bbox(){let P=this.leftSE.point.y,O=this.rightSE.point.y;return{ll:{x:this.leftSE.point.x,y:PO?P:O}}}vector(){return{x:this.rightSE.point.x-this.leftSE.point.x,y:this.rightSE.point.y-this.leftSE.point.y}}isAnEndpoint(P){return P.x===this.leftSE.point.x&&P.y===this.leftSE.point.y||P.x===this.rightSE.point.x&&P.y===this.rightSE.point.y}comparePoint(P){if(this.isAnEndpoint(P))return 0;let O=this.leftSE.point,K=this.rightSE.point,V=this.vector();if(O.x===K.x)return P.x===O.x?0:P.x0&&rA.swapEvents(),Tt.comparePoints(this.leftSE.point,this.rightSE.point)>0&&this.swapEvents(),K&&(V.checkForConsuming(),U.checkForConsuming()),O}swapEvents(){let P=this.rightSE;this.rightSE=this.leftSE,this.leftSE=P,this.leftSE.isLeft=!0,this.rightSE.isLeft=!1;for(let O=0,K=this.windings.length;O0){let U=O;O=K,K=U}if(O.prev===K){let U=O;O=K,K=U}for(let U=0,lA=K.rings.length;UV.length===1&&V[0].isSubject;this._isInResult=K(P)!==K(O);break}default:throw new Error(`Unrecognized operation type found ${EA.type}`)}return this._isInResult}}class yj{constructor(P,O,K){if(!Array.isArray(P)||P.length===0)throw new Error("Input geometry is not a valid Polygon or MultiPolygon");if(this.poly=O,this.isExterior=K,this.segments=[],typeof P[0][0]!="number"||typeof P[0][1]!="number")throw new Error("Input geometry is not a valid Polygon or MultiPolygon");let V=x.round(P[0][0],P[0][1]);this.bbox={ll:{x:V.x,y:V.y},ur:{x:V.x,y:V.y}};let U=V;for(let lA=1,rA=P.length;lAthis.bbox.ur.x&&(this.bbox.ur.x=hA.x),hA.y>this.bbox.ur.y&&(this.bbox.ur.y=hA.y),U=hA)}(V.x!==U.x||V.y!==U.y)&&this.segments.push(FA.fromRing(U,V,this))}getSweepEvents(){let P=[];for(let O=0,K=this.segments.length;Othis.bbox.ur.x&&(this.bbox.ur.x=U.bbox.ur.x),U.bbox.ur.y>this.bbox.ur.y&&(this.bbox.ur.y=U.bbox.ur.y),this.interiorRings.push(U)}this.multiPoly=O}getSweepEvents(){let P=this.exteriorRing.getSweepEvents();for(let O=0,K=this.interiorRings.length;Othis.bbox.ur.x&&(this.bbox.ur.x=U.bbox.ur.x),U.bbox.ur.y>this.bbox.ur.y&&(this.bbox.ur.y=U.bbox.ur.y),this.polys.push(U)}this.isSubject=O}getSweepEvents(){let P=[];for(let O=0,K=this.polys.length;O0&&(P=lA)}let O=P.segment.prevInResult(),K=O?O.prevInResult():null;for(;;){if(!O)return null;if(!K)return O.ringOut;if(K.ringOut!==O.ringOut)return K.ringOut.enclosingRing()!==O.ringOut?O.ringOut:O.ringOut.enclosingRing();O=K.prevInResult(),K=O?O.prevInResult():null}}}class KA{constructor(P){this.exteriorRing=P,P.poly=this,this.interiorRings=[]}addInterior(P){this.interiorRings.push(P),P.poly=this}getGeom(){let P=[this.exteriorRing.getGeom()];if(P[0]===null)return null;for(let O=0,K=this.interiorRings.length;O1&&arguments[1]!==void 0?arguments[1]:FA.compare;this.queue=P,this.tree=new l(O),this.segments=[]}process(P){let O=P.segment,K=[];if(P.consumedBy)return P.isLeft?this.queue.remove(P.otherSE):this.tree.remove(O),K;let V=P.isLeft?this.tree.add(O):this.tree.find(O);if(!V)throw new Error(`Unable to find segment #${O.id} [${O.leftSE.point.x}, ${O.leftSE.point.y}] -> [${O.rightSE.point.x}, ${O.rightSE.point.y}] in SweepLine tree.`);let U=V,lA=V,rA,hA;for(;rA===void 0;)U=this.tree.prev(U),U===null?rA=null:U.key.consumedBy===void 0&&(rA=U.key);for(;hA===void 0;)lA=this.tree.next(lA),lA===null?hA=null:lA.key.consumedBy===void 0&&(hA=lA.key);if(P.isLeft){let uA=null;if(rA){let sA=rA.getIntersection(O);if(sA!==null&&(O.isAnEndpoint(sA)||(uA=sA),!rA.isAnEndpoint(sA))){let kA=this._splitSafely(rA,sA);for(let BA=0,tt=kA.length;BA0?(this.tree.remove(O),K.push(P)):(this.segments.push(O),O.prev=rA)}else{if(rA&&hA){let uA=rA.getIntersection(hA);if(uA!==null){if(!rA.isAnEndpoint(uA)){let nA=this._splitSafely(rA,uA);for(let sA=0,kA=nA.length;sAPA)throw new Error("Infinite loop when putting segment endpoints in a priority queue (queue size too big).")}let lA=new fA(U),rA=U.size,hA=U.pop();for(;hA;){let sA=hA.key;if(U.size===rA){let BA=sA.segment;throw new Error(`Unable to pop() ${sA.isLeft?"left":"right"} SweepEvent [${sA.point.x}, ${sA.point.y}] from segment #${BA.id} [${BA.leftSE.point.x}, ${BA.leftSE.point.y}] -> [${BA.rightSE.point.x}, ${BA.rightSE.point.y}] from queue.`)}if(U.size>PA)throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big).");if(lA.segments.length>RA)throw new Error("Infinite loop when passing sweep line over endpoints (too many sweep line segments).");let kA=lA.process(sA);for(let BA=0,tt=kA.length;BA1?P-1:0),K=1;K1?P-1:0),K=1;K1?P-1:0),K=1;K1?P-1:0),K=1;K{"use strict";var ClA=Object.prototype.hasOwnProperty,Nn="~";function A0(){}Object.create&&(A0.prototype=Object.create(null),new A0().__proto__||(Nn=!1));function HlA(t,A,j){this.fn=t,this.context=A,this.once=j||!1}function fN(t,A,j,e,r){if(typeof j!="function")throw new TypeError("The listener must be a function");var n=new HlA(j,e||t,r),i=Nn?Nn+A:A;return t._events[i]?t._events[i].fn?t._events[i]=[t._events[i],n]:t._events[i].push(n):(t._events[i]=n,t._eventsCount++),t}function Fy(t,A){--t._eventsCount===0?t._events=new A0:delete t._events[A]}function fn(){this._events=new A0,this._eventsCount=0}fn.prototype.eventNames=function(){var A=[],j,e;if(this._eventsCount===0)return A;for(e in j=this._events)ClA.call(j,e)&&A.push(Nn?e.slice(1):e);return Object.getOwnPropertySymbols?A.concat(Object.getOwnPropertySymbols(j)):A};fn.prototype.listeners=function(A){var j=Nn?Nn+A:A,e=this._events[j];if(!e)return[];if(e.fn)return[e.fn];for(var r=0,n=e.length,i=new Array(n);r{(function(t,A){typeof qP=="object"&&typeof GP<"u"?GP.exports=A():(t=t||self).RBush=A()})(qP,function(){"use strict";function t(m,y,b,v,_){(function w(x,S,F,D,L){for(;D>F;){if(D-F>600){var z=D-F+1,T=S-F+1,W=Math.log(z),G=.5*Math.exp(2*W/3),jA=.5*Math.sqrt(W*G*(z-G)/z)*(T-z/2<0?-1:1),pA=Math.max(F,Math.floor(S-T*G/z+jA)),dA=Math.min(D,Math.floor(S+(z-T)*G/z+jA));w(x,S,pA,dA,L)}var $A=x[S],_A=F,Y=D;for(A(x,F,S),L(x[D],$A)>0&&A(x,F,D);_A0;)Y--}L(x[F],$A)===0?A(x,F,Y):A(x,++Y,D),Y<=S&&(F=Y+1),S<=Y&&(D=Y-1)}})(m,y,b||0,v||m.length-1,_||j)}function A(m,y,b){var v=m[y];m[y]=m[b],m[b]=v}function j(m,y){return my?1:0}var e=function(m){m===void 0&&(m=9),this._maxEntries=Math.max(4,m),this._minEntries=Math.max(2,Math.ceil(.4*this._maxEntries)),this.clear()};function r(m,y,b){if(!b)return y.indexOf(m);for(var v=0;v=m.minX&&y.maxY>=m.minY}function g(m){return{children:m,height:1,leaf:!0,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0}}function E(m,y,b,v,_){for(var w=[y,b];w.length;)if(!((b=w.pop())-(y=w.pop())<=v)){var x=y+Math.ceil((b-y)/v/2)*v;t(m,x,y,b,_),w.push(y,x,x,b)}}return e.prototype.all=function(){return this._all(this.data,[])},e.prototype.search=function(m){var y=this.data,b=[];if(!k(m,y))return b;for(var v=this.toBBox,_=[];y;){for(var w=0;w=0&&_[y].children.length>this._maxEntries;)this._split(_,y),y--;this._adjustParentBBoxes(v,_,y)},e.prototype._split=function(m,y){var b=m[y],v=b.children.length,_=this._minEntries;this._chooseSplitAxis(b,_,v);var w=this._chooseSplitIndex(b,_,v),x=g(b.children.splice(w,b.children.length-w));x.height=b.height,x.leaf=b.leaf,n(b,this.toBBox),n(x,this.toBBox),y?m[y-1].children.push(x):this._splitRoot(b,x)},e.prototype._splitRoot=function(m,y){this.data=g([m,y]),this.data.height=m.height+1,this.data.leaf=!1,n(this.data,this.toBBox)},e.prototype._chooseSplitIndex=function(m,y,b){for(var v,_,w,x,S,F,D,L=1/0,z=1/0,T=y;T<=b-y;T++){var W=i(m,0,T,this.toBBox),G=i(m,T,b,this.toBBox),jA=(_=W,w=G,x=void 0,S=void 0,F=void 0,D=void 0,x=Math.max(_.minX,w.minX),S=Math.max(_.minY,w.minY),F=Math.min(_.maxX,w.maxX),D=Math.min(_.maxY,w.maxY),Math.max(0,F-x)*Math.max(0,D-S)),pA=B(W)+B(G);jA=y;L--){var z=m.children[L];o(x,m.leaf?_(z):z),S+=h(x)}return S},e.prototype._adjustParentBBoxes=function(m,y,b){for(var v=b;v>=0;v--)o(y[v],m)},e.prototype._condense=function(m){for(var y=m.length-1,b=void 0;y>=0;y--)m[y].children.length===0?y>0?(b=m[y-1].children).splice(b.indexOf(m[y]),1):this.clear():n(m[y],this.toBBox)},e})});var IP=C6(ot=>{"use strict";Object.defineProperty(ot,"__esModule",{value:!0});ot.earthRadius=63710088e-1;ot.factors={centimeters:ot.earthRadius*100,centimetres:ot.earthRadius*100,degrees:ot.earthRadius/111325,feet:ot.earthRadius*3.28084,inches:ot.earthRadius*39.37,kilometers:ot.earthRadius/1e3,kilometres:ot.earthRadius/1e3,meters:ot.earthRadius,metres:ot.earthRadius,miles:ot.earthRadius/1609.344,millimeters:ot.earthRadius*1e3,millimetres:ot.earthRadius*1e3,nauticalmiles:ot.earthRadius/1852,radians:1,yards:ot.earthRadius*1.0936};ot.unitsFactors={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/ot.earthRadius,yards:1.0936133};ot.areaFactors={acres:247105e-9,centimeters:1e4,centimetres:1e4,feet:10.763910417,hectares:1e-4,inches:1550.003100006,kilometers:1e-6,kilometres:1e-6,meters:1,metres:1,miles:386e-9,millimeters:1e6,millimetres:1e6,yards:1.195990046};function sl(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}ot.feature=sl;function NcA(t,A,j){switch(j===void 0&&(j={}),t){case"Point":return bP(A).geometry;case"LineString":return FP(A).geometry;case"Polygon":return wP(A).geometry;case"MultiPoint":return K3(A).geometry;case"MultiLineString":return N3(A).geometry;case"MultiPolygon":return X3(A).geometry;default:throw new Error(t+" is invalid")}}ot.geometry=NcA;function bP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!Yy(t[0])||!Yy(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return sl(e,A,j)}ot.point=bP;function KcA(t,A,j){return j===void 0&&(j={}),Jy(t.map(function(e){return bP(e,A)}),j)}ot.points=KcA;function wP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=0))throw new Error("precision must be a positive number");var j=Math.pow(10,A||0);return Math.round(t*j)/j}ot.round=VcA;function z3(t,A){A===void 0&&(A="kilometers");var j=ot.factors[A];if(!j)throw new Error(A+" units is invalid");return t*j}ot.radiansToLength=z3;function PP(t,A){A===void 0&&(A="kilometers");var j=ot.factors[A];if(!j)throw new Error(A+" units is invalid");return t/j}ot.lengthToRadians=PP;function QcA(t,A){return U3(PP(t,A))}ot.lengthToDegrees=QcA;function WcA(t){var A=t%360;return A<0&&(A+=360),A}ot.bearingToAzimuth=WcA;function U3(t){var A=t%(2*Math.PI);return A*180/Math.PI}ot.radiansToDegrees=U3;function YcA(t){var A=t%360;return A*Math.PI/180}ot.degreesToRadians=YcA;function JcA(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return z3(PP(t,A),j)}ot.convertLength=JcA;function ZcA(t,A,j){if(A===void 0&&(A="meters"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("area must be a positive number");var e=ot.areaFactors[A];if(!e)throw new Error("invalid original units");var r=ot.areaFactors[j];if(!r)throw new Error("invalid final units");return t/e*r}ot.convertArea=ZcA;function Yy(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}ot.isNumber=Yy;function AuA(t){return!!t&&t.constructor===Object}ot.isObject=AuA;function tuA(t){if(!t)throw new Error("bbox is required");if(!Array.isArray(t))throw new Error("bbox must be an Array");if(t.length!==4&&t.length!==6)throw new Error("bbox must be an Array of 4 or 6 numbers");t.forEach(function(A){if(!Yy(A))throw new Error("bbox must only contain numbers")})}ot.validateBBox=tuA;function juA(t){if(!t)throw new Error("id is required");if(["string","number"].indexOf(typeof t)===-1)throw new Error("id must be a number or a string")}ot.validateId=juA});var J3=C6(jr=>{"use strict";Object.defineProperty(jr,"__esModule",{value:!0});var hn=IP();function u0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=hn.lineString([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}function auA(t,A,j){var e=j,r=!1;return W3(t,function(n,i,o,l,c){r===!1&&j===void 0?e=n:e=A(e,n,i,o,l,c),r=!0}),e}function Y3(t,A){if(!t)throw new Error("geojson is required");Zy(t,function(j,e,r){if(j.geometry!==null){var n=j.geometry.type,i=j.geometry.coordinates;switch(n){case"LineString":if(A(j,e,r,0,0)===!1)return!1;break;case"Polygon":for(var o=0;o{"use strict";Object.defineProperty(st,"__esModule",{value:!0});st.earthRadius=63710088e-1;st.factors={centimeters:st.earthRadius*100,centimetres:st.earthRadius*100,degrees:st.earthRadius/111325,feet:st.earthRadius*3.28084,inches:st.earthRadius*39.37,kilometers:st.earthRadius/1e3,kilometres:st.earthRadius/1e3,meters:st.earthRadius,metres:st.earthRadius,miles:st.earthRadius/1609.344,millimeters:st.earthRadius*1e3,millimetres:st.earthRadius*1e3,nauticalmiles:st.earthRadius/1852,radians:1,yards:st.earthRadius*1.0936};st.unitsFactors={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/st.earthRadius,yards:1.0936133};st.areaFactors={acres:247105e-9,centimeters:1e4,centimetres:1e4,feet:10.763910417,hectares:1e-4,inches:1550.003100006,kilometers:1e-6,kilometres:1e-6,meters:1,metres:1,miles:386e-9,millimeters:1e6,millimetres:1e6,yards:1.195990046};function al(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}st.feature=al;function BuA(t,A,j){switch(j===void 0&&(j={}),t){case"Point":return OP(A).geometry;case"LineString":return SP(A).geometry;case"Polygon":return TP(A).geometry;case"MultiPoint":return AK(A).geometry;case"MultiLineString":return Z3(A).geometry;case"MultiPolygon":return tK(A).geometry;default:throw new Error(t+" is invalid")}}st.geometry=BuA;function OP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!Av(t[0])||!Av(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return al(e,A,j)}st.point=OP;function fuA(t,A,j){return j===void 0&&(j={}),tv(t.map(function(e){return OP(e,A)}),j)}st.points=fuA;function TP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=0))throw new Error("precision must be a positive number");var j=Math.pow(10,A||0);return Math.round(t*j)/j}st.round=kuA;function jK(t,A){A===void 0&&(A="kilometers");var j=st.factors[A];if(!j)throw new Error(A+" units is invalid");return t*j}st.radiansToLength=jK;function RP(t,A){A===void 0&&(A="kilometers");var j=st.factors[A];if(!j)throw new Error(A+" units is invalid");return t/j}st.lengthToRadians=RP;function guA(t,A){return eK(RP(t,A))}st.lengthToDegrees=guA;function muA(t){var A=t%360;return A<0&&(A+=360),A}st.bearingToAzimuth=muA;function eK(t){var A=t%(2*Math.PI);return A*180/Math.PI}st.radiansToDegrees=eK;function EuA(t){var A=t%360;return A*Math.PI/180}st.degreesToRadians=EuA;function $uA(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return jK(RP(t,A),j)}st.convertLength=$uA;function xuA(t,A,j){if(A===void 0&&(A="meters"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("area must be a positive number");var e=st.areaFactors[A];if(!e)throw new Error("invalid original units");var r=st.areaFactors[j];if(!r)throw new Error("invalid final units");return t/e*r}st.convertArea=xuA;function Av(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}st.isNumber=Av;function yuA(t){return!!t&&t.constructor===Object}st.isObject=yuA;function vuA(t){if(!t)throw new Error("bbox is required");if(!Array.isArray(t))throw new Error("bbox must be an Array");if(t.length!==4&&t.length!==6)throw new Error("bbox must be an Array of 4 or 6 numbers");t.forEach(function(A){if(!Av(A))throw new Error("bbox must only contain numbers")})}st.validateBBox=vuA;function _uA(t){if(!t)throw new Error("id is required");if(["string","number"].indexOf(typeof t)===-1)throw new Error("id must be a number or a string")}st.validateId=_uA});var aK=C6(er=>{"use strict";Object.defineProperty(er,"__esModule",{value:!0});var dn=rK();function B0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=dn.lineString([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}function IuA(t,A,j){var e=j,r=!1;return oK(t,function(n,i,o,l,c){r===!1&&j===void 0?e=n:e=A(e,n,i,o,l,c),r=!0}),e}function sK(t,A){if(!t)throw new Error("geojson is required");jv(t,function(j,e,r){if(j.geometry!==null){var n=j.geometry.type,i=j.geometry.coordinates;switch(n){case"LineString":if(A(j,e,r,0,0)===!1)return!1;break;case"Polygon":for(var o=0;o{"use strict";Object.defineProperty(HP,"__esModule",{value:!0});var SuA=aK();function CP(t){var A=[1/0,1/0,-1/0,-1/0];return SuA.coordEach(t,function(j){A[0]>j[0]&&(A[0]=j[0]),A[1]>j[1]&&(A[1]=j[1]),A[2]{var Fs=D3(),uK=IP(),BK=J3(),Ef=lK().default,RuA=BK.featureEach,Qot=BK.coordEach,Wot=uK.polygon,cK=uK.featureCollection;function fK(t){var A=new Fs(t);return A.insert=function(j){if(j.type!=="Feature")throw new Error("invalid feature");return j.bbox=j.bbox?j.bbox:Ef(j),Fs.prototype.insert.call(this,j)},A.load=function(j){var e=[];return Array.isArray(j)?j.forEach(function(r){if(r.type!=="Feature")throw new Error("invalid features");r.bbox=r.bbox?r.bbox:Ef(r),e.push(r)}):RuA(j,function(r){if(r.type!=="Feature")throw new Error("invalid features");r.bbox=r.bbox?r.bbox:Ef(r),e.push(r)}),Fs.prototype.load.call(this,e)},A.remove=function(j,e){if(j.type!=="Feature")throw new Error("invalid feature");return j.bbox=j.bbox?j.bbox:Ef(j),Fs.prototype.remove.call(this,j,e)},A.clear=function(){return Fs.prototype.clear.call(this)},A.search=function(j){var e=Fs.prototype.search.call(this,this.toBBox(j));return cK(e)},A.collides=function(j){return Fs.prototype.collides.call(this,this.toBBox(j))},A.all=function(){var j=Fs.prototype.all.call(this);return cK(j)},A.toJSON=function(){return Fs.prototype.toJSON.call(this)},A.fromJSON=function(j){return Fs.prototype.fromJSON.call(this,j)},A.toBBox=function(j){var e;if(j.bbox)e=j.bbox;else if(Array.isArray(j)&&j.length===4)e=j;else if(Array.isArray(j)&&j.length===6)e=[j[0],j[1],j[3],j[4]];else if(j.type==="Feature")e=Ef(j);else if(j.type==="FeatureCollection")e=Ef(j);else throw new Error("invalid geojson");return{minX:e[0],minY:e[1],maxX:e[2],maxY:e[3]}},A}DP.exports=fK;DP.exports.default=fK});var PK=C6((L7t,FK)=>{var wK="Expected a function",GK=NaN,WuA="[object Symbol]",YuA=/^\s+|\s+$/g,JuA=/^[-+]0x[0-9a-f]+$/i,ZuA=/^0b[01]+$/i,ABA=/^0o[0-7]+$/i,tBA=parseInt,jBA=typeof global=="object"&&global&&global.Object===Object&&global,eBA=typeof self=="object"&&self&&self.Object===Object&&self,rBA=jBA||eBA||Function("return this")(),nBA=Object.prototype,iBA=nBA.toString,oBA=Math.max,sBA=Math.min,VP=function(){return rBA.Date.now()};function aBA(t,A,j){var e,r,n,i,o,l,c=0,B=!1,h=!1,d=!0;if(typeof t!="function")throw new TypeError(wK);A=bK(A)||0,sv(j)&&(B=!!j.leading,h="maxWait"in j,n=h?oBA(bK(j.maxWait)||0,A):n,d="trailing"in j?!!j.trailing:d);function k(x){var S=e,F=r;return e=r=void 0,c=x,i=t.apply(F,S),i}function g(x){return c=x,o=setTimeout(y,A),B?k(x):i}function E(x){var S=x-l,F=x-c,D=A-S;return h?sBA(D,n-F):D}function m(x){var S=x-l,F=x-c;return l===void 0||S>=A||S<0||h&&F>=n}function y(){var x=VP();if(m(x))return b(x);o=setTimeout(y,E(x))}function b(x){return o=void 0,d&&e?k(x):(e=r=void 0,i)}function v(){o!==void 0&&clearTimeout(o),c=0,e=l=r=o=void 0}function _(){return o===void 0?i:b(VP())}function w(){var x=VP(),S=m(x);if(e=arguments,r=this,l=x,S){if(o===void 0)return g(l);if(h)return o=setTimeout(y,A),k(l)}return o===void 0&&(o=setTimeout(y,A)),i}return w.cancel=v,w.flush=_,w}function lBA(t,A,j){var e=!0,r=!0;if(typeof t!="function")throw new TypeError(wK);return sv(j)&&(e="leading"in j?!!j.leading:e,r="trailing"in j?!!j.trailing:r),aBA(t,A,{leading:e,maxWait:A,trailing:r})}function sv(t){var A=typeof t;return!!t&&(A=="object"||A=="function")}function cBA(t){return!!t&&typeof t=="object"}function uBA(t){return typeof t=="symbol"||cBA(t)&&iBA.call(t)==WuA}function bK(t){if(typeof t=="number")return t;if(uBA(t))return GK;if(sv(t)){var A=typeof t.valueOf=="function"?t.valueOf():t;t=sv(A)?A+"":A}if(typeof t!="string")return t===0?t:+t;t=t.replace(YuA,"");var j=ZuA.test(t);return j||ABA.test(t)?tBA(t.slice(2),j?2:8):JuA.test(t)?GK:+t}FK.exports=lBA});function $8(t,A){var j={};for(var e in t)Object.prototype.hasOwnProperty.call(t,e)&&A.indexOf(e)<0&&(j[e]=t[e]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var r=0,e=Object.getOwnPropertySymbols(t);r=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}};throw new TypeError(A?"Object is not iterable.":"Symbol.iterator is not defined.")}function vt(t){return this instanceof vt?(this.v=t,this):new vt(t)}function H6(t,A,j){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=j.apply(t,A||[]),r,n=[];return r={},i("next"),i("throw"),i("return"),r[Symbol.asyncIterator]=function(){return this},r;function i(d){e[d]&&(r[d]=function(k){return new Promise(function(g,E){n.push([d,k,g,E])>1||o(d,k)})})}function o(d,k){try{l(e[d](k))}catch(g){h(n[0][3],g)}}function l(d){d.value instanceof vt?Promise.resolve(d.value.v).then(c,B):h(n[0][2],d)}function c(d){o("next",d)}function B(d){o("throw",d)}function h(d,k){d(k),n.shift(),n.length&&o(n[0][0],n[0][1])}}function $u(t){var A,j;return A={},e("next"),e("throw",function(r){throw r}),e("return"),A[Symbol.iterator]=function(){return this},A;function e(r,n){A[r]=t[r]?function(i){return(j=!j)?{value:vt(t[r](i)),done:!1}:n?n(i):i}:n}}function Ki(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var A=t[Symbol.asyncIterator],j;return A?A.call(t):(t=typeof E8=="function"?E8(t):t[Symbol.iterator](),j={},e("next"),e("throw"),e("return"),j[Symbol.asyncIterator]=function(){return this},j);function e(n){j[n]=t[n]&&function(i){return new Promise(function(o,l){i=t[n](i),r(o,l,i.done,i.value)})}}function r(n,i,o,l){Promise.resolve(l).then(function(c){n({value:c,done:o})},i)}}var V_={};fr(V_,{compareArrayLike:()=>U_,joinUint8Arrays:()=>N6,memcpy:()=>mh,rebaseValueOffsets:()=>xg,toArrayBufferView:()=>Mt,toArrayBufferViewAsyncIterator:()=>zi,toArrayBufferViewIterator:()=>Ho,toBigInt64Array:()=>$g,toBigUint64Array:()=>v9,toFloat32Array:()=>_9,toFloat32ArrayAsyncIterator:()=>D9,toFloat32ArrayIterator:()=>M9,toFloat64Array:()=>q9,toFloat64ArrayAsyncIterator:()=>N9,toFloat64ArrayIterator:()=>O9,toInt16Array:()=>$9,toInt16ArrayAsyncIterator:()=>R9,toInt16ArrayIterator:()=>w9,toInt32Array:()=>Rl,toInt32ArrayAsyncIterator:()=>L9,toInt32ArrayIterator:()=>F9,toInt8Array:()=>E9,toInt8ArrayAsyncIterator:()=>S9,toInt8ArrayIterator:()=>b9,toUint16Array:()=>x9,toUint16ArrayAsyncIterator:()=>C9,toUint16ArrayIterator:()=>P9,toUint32Array:()=>y9,toUint32ArrayAsyncIterator:()=>H9,toUint32ArrayIterator:()=>I9,toUint8Array:()=>it,toUint8ArrayAsyncIterator:()=>z_,toUint8ArrayIterator:()=>X_,toUint8ClampedArray:()=>G9,toUint8ClampedArrayAsyncIterator:()=>K9,toUint8ClampedArrayIterator:()=>T9});var p9=new TextDecoder("utf-8"),kh=t=>p9.decode(t),k9=new TextEncoder,Co=t=>k9.encode(t);var g9=t=>typeof t=="number",x8=t=>typeof t=="boolean",Ye=t=>typeof t=="function",qn=t=>t!=null&&Object(t)===t,D6=t=>qn(t)&&Ye(t.then);var Xi=t=>qn(t)&&Ye(t[Symbol.iterator]),Bi=t=>qn(t)&&Ye(t[Symbol.asyncIterator]),dg=t=>qn(t)&&qn(t.schema);var pg=t=>qn(t)&&"done"in t&&"value"in t;var kg=t=>qn(t)&&Ye(t.stat)&&g9(t.fd);var gg=t=>qn(t)&&gh(t.body),mg=t=>"_getDOMStream"in t&&"_getNodeStream"in t,y8=t=>qn(t)&&Ye(t.abort)&&Ye(t.getWriter)&&!mg(t),gh=t=>qn(t)&&Ye(t.cancel)&&Ye(t.getReader)&&!mg(t),v8=t=>qn(t)&&Ye(t.end)&&Ye(t.write)&&x8(t.writable)&&!mg(t),Eg=t=>qn(t)&&Ye(t.read)&&Ye(t.pipe)&&x8(t.readable)&&!mg(t),_8=t=>qn(t)&&Ye(t.clear)&&Ye(t.bytes)&&Ye(t.position)&&Ye(t.setPosition)&&Ye(t.capacity)&&Ye(t.getBufferIdentifier)&&Ye(t.createLong);var K_=typeof SharedArrayBuffer<"u"?SharedArrayBuffer:ArrayBuffer;function m9(t){let A=t[0]?[t[0]]:[],j,e,r,n;for(let i,o,l=0,c=0,B=t.length;++lB+h.byteLength,0),r,n,i,o=0,l=-1,c=Math.min(A||Number.POSITIVE_INFINITY,e);for(let B=j.length;++lMt(Int8Array,t),$9=t=>Mt(Int16Array,t),Rl=t=>Mt(Int32Array,t),$g=t=>Mt(BigInt64Array,t),it=t=>Mt(Uint8Array,t),x9=t=>Mt(Uint16Array,t),y9=t=>Mt(Uint32Array,t),v9=t=>Mt(BigUint64Array,t),_9=t=>Mt(Float32Array,t),q9=t=>Mt(Float64Array,t),G9=t=>Mt(Uint8ClampedArray,t),N_=t=>(t.next(),t);function*Ho(t,A){let j=function*(r){yield r},e=typeof A=="string"||ArrayBuffer.isView(A)||A instanceof ArrayBuffer||A instanceof K_?j(A):Xi(A)?A:j(A);return yield*N_(function*(r){let n=null;do n=r.next(yield Mt(t,n));while(!n.done)}(e[Symbol.iterator]())),new t}var b9=t=>Ho(Int8Array,t),w9=t=>Ho(Int16Array,t),F9=t=>Ho(Int32Array,t),X_=t=>Ho(Uint8Array,t),P9=t=>Ho(Uint16Array,t),I9=t=>Ho(Uint32Array,t),M9=t=>Ho(Float32Array,t),O9=t=>Ho(Float64Array,t),T9=t=>Ho(Uint8ClampedArray,t);function zi(t,A){return H6(this,arguments,function*(){if(D6(A))return yield vt(yield vt(yield*$u(Ki(zi(t,yield vt(A))))));let e=function(i){return H6(this,arguments,function*(){yield yield vt(yield vt(i))})},r=function(i){return H6(this,arguments,function*(){yield vt(yield*$u(Ki(N_(function*(o){let l=null;do l=o.next(yield l?.value);while(!l.done)}(i[Symbol.iterator]())))))})},n=typeof A=="string"||ArrayBuffer.isView(A)||A instanceof ArrayBuffer||A instanceof K_?e(A):Xi(A)?r(A):Bi(A)?A:e(A);return yield vt(yield*$u(Ki(N_(function(i){return H6(this,arguments,function*(){let o=null;do o=yield vt(i.next(yield yield vt(Mt(t,o))));while(!o.done)})}(n[Symbol.asyncIterator]()))))),yield vt(new t)})}var S9=t=>zi(Int8Array,t),R9=t=>zi(Int16Array,t),L9=t=>zi(Int32Array,t),z_=t=>zi(Uint8Array,t),C9=t=>zi(Uint16Array,t),H9=t=>zi(Uint32Array,t),D9=t=>zi(Float32Array,t),N9=t=>zi(Float64Array,t),K9=t=>zi(Uint8ClampedArray,t);function xg(t,A,j){if(t!==0){j=j.slice(0,A);for(let e=-1,r=j.length;++e0)do if(t[j]!==A[j])return!1;while(++j(t.next(),t);function*X9(t){let A,j=!1,e=[],r,n,i,o=0;function l(){return n==="peek"?N6(e,i)[0]:([r,e,o]=N6(e,i),r)}({cmd:n,size:i}=(yield null)||{cmd:"read",size:0});let c=X_(t)[Symbol.iterator]();try{do if({done:A,value:r}=Number.isNaN(i-o)?c.next():c.next(i-o),!A&&r.byteLength>0&&(e.push(r),o+=r.byteLength),A||i<=o)do({cmd:n,size:i}=yield l());while(i0&&(r.push(n),l+=n.byteLength),j||o<=l)do({cmd:i,size:o}=yield yield vt(c()));while(o0&&(r.push(it(n)),l+=n.byteLength),j||o<=l)do({cmd:i,size:o}=yield yield vt(c()));while(o{})}get closed(){return this.reader?this.reader.closed.catch(()=>{}):Promise.resolve()}releaseLock(){this.reader&&this.reader.releaseLock(),this.reader=null}cancel(A){return OA(this,void 0,void 0,function*(){let{reader:j,source:e}=this;j&&(yield j.cancel(A).catch(()=>{})),e&&e.locked&&this.releaseLock()})}read(A){return OA(this,void 0,void 0,function*(){if(A===0)return{done:this.reader==null,value:new Uint8Array(0)};let j=yield this.reader.read();return!j.done&&(j.value=it(j)),j})}},Q_=(t,A)=>{let j=r=>e([A,r]),e;return[A,j,new Promise(r=>(e=r)&&t.once(A,j))]};function V9(t){return H6(this,arguments,function*(){let j=[],e="error",r=!1,n=null,i,o,l=0,c=[],B;function h(){return i==="peek"?N6(c,o)[0]:([B,c,l]=N6(c,o),B)}if({cmd:i,size:o}=(yield yield vt(null))||{cmd:"read",size:0},t.isTTY)return yield yield vt(new Uint8Array(0)),yield vt(null);try{j[0]=Q_(t,"end"),j[1]=Q_(t,"error");do{if(j[2]=Q_(t,"readable"),[e,n]=yield vt(Promise.race(j.map(k=>k[2]))),e==="error")break;if((r=e==="end")||(Number.isFinite(o-l)?(B=it(t.read(o-l)),B.byteLength0&&(c.push(B),l+=B.byteLength)),r||o<=l)do({cmd:i,size:o}=yield yield vt(h()));while(o{for(let[y,b]of k)t.off(y,b);try{let y=t.destroy;y&&y.call(t,g),g=void 0}catch(y){g=y||g}finally{g!=null?m(g):E()}})}})}var hj;(function(t){t[t.V1=0]="V1",t[t.V2=1]="V2",t[t.V3=2]="V3",t[t.V4=3]="V4",t[t.V5=4]="V5"})(hj||(hj={}));var bj;(function(t){t[t.Sparse=0]="Sparse",t[t.Dense=1]="Dense"})(bj||(bj={}));var mj;(function(t){t[t.HALF=0]="HALF",t[t.SINGLE=1]="SINGLE",t[t.DOUBLE=2]="DOUBLE"})(mj||(mj={}));var Ce;(function(t){t[t.DAY=0]="DAY",t[t.MILLISECOND=1]="MILLISECOND"})(Ce||(Ce={}));var XA;(function(t){t[t.SECOND=0]="SECOND",t[t.MILLISECOND=1]="MILLISECOND",t[t.MICROSECOND=2]="MICROSECOND",t[t.NANOSECOND=3]="NANOSECOND"})(XA||(XA={}));var hr;(function(t){t[t.YEAR_MONTH=0]="YEAR_MONTH",t[t.DAY_TIME=1]="DAY_TIME",t[t.MONTH_DAY_NANO=2]="MONTH_DAY_NANO"})(hr||(hr={}));var Do=new Int32Array(2),vg=new Float32Array(Do.buffer),_g=new Float64Array(Do.buffer),xu=new Uint16Array(new Uint8Array([1,0]).buffer)[0]===1;var Eh;(function(t){t[t.UTF8_BYTES=1]="UTF8_BYTES",t[t.UTF16_STRING=2]="UTF16_STRING"})(Eh||(Eh={}));var K6=class t{constructor(A){this.bytes_=A,this.position_=0,this.text_decoder_=new TextDecoder}static allocate(A){return new t(new Uint8Array(A))}clear(){this.position_=0}bytes(){return this.bytes_}position(){return this.position_}setPosition(A){this.position_=A}capacity(){return this.bytes_.length}readInt8(A){return this.readUint8(A)<<24>>24}readUint8(A){return this.bytes_[A]}readInt16(A){return this.readUint16(A)<<16>>16}readUint16(A){return this.bytes_[A]|this.bytes_[A+1]<<8}readInt32(A){return this.bytes_[A]|this.bytes_[A+1]<<8|this.bytes_[A+2]<<16|this.bytes_[A+3]<<24}readUint32(A){return this.readInt32(A)>>>0}readInt64(A){return BigInt.asIntN(64,BigInt(this.readUint32(A))+(BigInt(this.readUint32(A+4))<>8}writeUint16(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8}writeInt32(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8,this.bytes_[A+2]=j>>16,this.bytes_[A+3]=j>>24}writeUint32(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8,this.bytes_[A+2]=j>>16,this.bytes_[A+3]=j>>24}writeInt64(A,j){this.writeInt32(A,Number(BigInt.asIntN(32,j))),this.writeInt32(A+4,Number(BigInt.asIntN(32,j>>BigInt(32))))}writeUint64(A,j){this.writeUint32(A,Number(BigInt.asUintN(32,j))),this.writeUint32(A+4,Number(BigInt.asUintN(32,j>>BigInt(32))))}writeFloat32(A,j){vg[0]=j,this.writeInt32(A,Do[0])}writeFloat64(A,j){_g[0]=j,this.writeInt32(A,Do[xu?0:1]),this.writeInt32(A+4,Do[xu?1:0])}getBufferIdentifier(){if(this.bytes_.lengththis.minalign&&(this.minalign=A);let e=~(this.bb.capacity()-this.space+j)+1&A-1;for(;this.space=0&&this.vtable[j]==0;j--);let e=j+1;for(;j>=0;j--)this.addInt16(this.vtable[j]!=0?A-this.vtable[j]:0);let r=2;this.addInt16(A-this.object_start);let n=(e+r)*2;this.addInt16(n);let i=0,o=this.space;A:for(j=0;j=0;i--)this.writeInt8(n.charCodeAt(i))}this.prep(this.minalign,4+r),this.addOffset(A),r&&this.addInt32(this.bb.capacity()-this.space),this.bb.setPosition(this.space)}finishSizePrefixed(A,j){this.finish(A,j,!0)}requiredField(A,j){let e=this.bb.capacity()-A,r=e-this.bb.readInt32(e);if(!(j=0;e--)A.addInt32(j[e]);return A.endVector()}static startTypeIdsVector(A,j){A.startVector(4,j,4)}static endUnion(A){return A.endObject()}static createUnion(A,j,e){return t.startUnion(A),t.addMode(A,j),t.addTypeIds(A,e),t.endUnion(A)}};var Ph=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsUtf8(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsUtf8(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static startUtf8(A){A.startObject(0)}static endUtf8(A){return A.endObject()}static createUtf8(A){return t.startUtf8(A),t.endUtf8(A)}};var Ej;(function(t){t[t.NONE=0]="NONE",t[t.Null=1]="Null",t[t.Int=2]="Int",t[t.FloatingPoint=3]="FloatingPoint",t[t.Binary=4]="Binary",t[t.Utf8=5]="Utf8",t[t.Bool=6]="Bool",t[t.Decimal=7]="Decimal",t[t.Date=8]="Date",t[t.Time=9]="Time",t[t.Timestamp=10]="Timestamp",t[t.Interval=11]="Interval",t[t.List=12]="List",t[t.Struct_=13]="Struct_",t[t.Union=14]="Union",t[t.FixedSizeBinary=15]="FixedSizeBinary",t[t.FixedSizeList=16]="FixedSizeList",t[t.Map=17]="Map",t[t.Duration=18]="Duration",t[t.LargeBinary=19]="LargeBinary",t[t.LargeUtf8=20]="LargeUtf8",t[t.LargeList=21]="LargeList",t[t.RunEndEncoded=22]="RunEndEncoded"})(Ej||(Ej={}));var jn=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsField(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsField(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}name(A){let j=this.bb.__offset(this.bb_pos,4);return j?this.bb.__string(this.bb_pos+j,A):null}nullable(){let A=this.bb.__offset(this.bb_pos,6);return A?!!this.bb.readInt8(this.bb_pos+A):!1}typeType(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.readUint8(this.bb_pos+A):Ej.NONE}type(A){let j=this.bb.__offset(this.bb_pos,10);return j?this.bb.__union(A,this.bb_pos+j):null}dictionary(A){let j=this.bb.__offset(this.bb_pos,12);return j?(A||new No).__init(this.bb.__indirect(this.bb_pos+j),this.bb):null}children(A,j){let e=this.bb.__offset(this.bb_pos,14);return e?(j||new t).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}childrenLength(){let A=this.bb.__offset(this.bb_pos,14);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,16);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,16);return A?this.bb.__vector_len(this.bb_pos+A):0}static startField(A){A.startObject(7)}static addName(A,j){A.addFieldOffset(0,j,0)}static addNullable(A,j){A.addFieldInt8(1,+j,0)}static addTypeType(A,j){A.addFieldInt8(2,j,Ej.NONE)}static addType(A,j){A.addFieldOffset(3,j,0)}static addDictionary(A,j){A.addFieldOffset(4,j,0)}static addChildren(A,j){A.addFieldOffset(5,j,0)}static createChildrenVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startChildrenVector(A,j){A.startVector(4,j,4)}static addCustomMetadata(A,j){A.addFieldOffset(6,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endField(A){return A.endObject()}};var p6=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsSchema(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsSchema(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}endianness(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):u7.Little}fields(A,j){let e=this.bb.__offset(this.bb_pos,6);return e?(j||new jn).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}fieldsLength(){let A=this.bb.__offset(this.bb_pos,6);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,8);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.__vector_len(this.bb_pos+A):0}features(A){let j=this.bb.__offset(this.bb_pos,10);return j?this.bb.readInt64(this.bb.__vector(this.bb_pos+j)+A*8):BigInt(0)}featuresLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.__vector_len(this.bb_pos+A):0}static startSchema(A){A.startObject(4)}static addEndianness(A,j){A.addFieldInt16(0,j,u7.Little)}static addFields(A,j){A.addFieldOffset(1,j,0)}static createFieldsVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startFieldsVector(A,j){A.startVector(4,j,4)}static addCustomMetadata(A,j){A.addFieldOffset(2,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static addFeatures(A,j){A.addFieldOffset(3,j,0)}static createFeaturesVector(A,j){A.startVector(8,j.length,8);for(let e=j.length-1;e>=0;e--)A.addInt64(j[e]);return A.endVector()}static startFeaturesVector(A,j){A.startVector(8,j,8)}static endSchema(A){return A.endObject()}static finishSchemaBuffer(A,j){A.finish(j)}static finishSizePrefixedSchemaBuffer(A,j){A.finish(j,void 0,!0)}static createSchema(A,j,e,r,n){return t.startSchema(A),t.addEndianness(A,j),t.addFields(A,e),t.addCustomMetadata(A,r),t.addFeatures(A,n),t.endSchema(A)}};var Lt;(function(t){t[t.NONE=0]="NONE",t[t.Schema=1]="Schema",t[t.DictionaryBatch=2]="DictionaryBatch",t[t.RecordBatch=3]="RecordBatch",t[t.Tensor=4]="Tensor",t[t.SparseTensor=5]="SparseTensor"})(Lt||(Lt={}));var Z;(function(t){t[t.NONE=0]="NONE",t[t.Null=1]="Null",t[t.Int=2]="Int",t[t.Float=3]="Float",t[t.Binary=4]="Binary",t[t.Utf8=5]="Utf8",t[t.Bool=6]="Bool",t[t.Decimal=7]="Decimal",t[t.Date=8]="Date",t[t.Time=9]="Time",t[t.Timestamp=10]="Timestamp",t[t.Interval=11]="Interval",t[t.List=12]="List",t[t.Struct=13]="Struct",t[t.Union=14]="Union",t[t.FixedSizeBinary=15]="FixedSizeBinary",t[t.FixedSizeList=16]="FixedSizeList",t[t.Map=17]="Map",t[t.Duration=18]="Duration",t[t.LargeBinary=19]="LargeBinary",t[t.LargeUtf8=20]="LargeUtf8",t[t.Dictionary=-1]="Dictionary",t[t.Int8=-2]="Int8",t[t.Int16=-3]="Int16",t[t.Int32=-4]="Int32",t[t.Int64=-5]="Int64",t[t.Uint8=-6]="Uint8",t[t.Uint16=-7]="Uint16",t[t.Uint32=-8]="Uint32",t[t.Uint64=-9]="Uint64",t[t.Float16=-10]="Float16",t[t.Float32=-11]="Float32",t[t.Float64=-12]="Float64",t[t.DateDay=-13]="DateDay",t[t.DateMillisecond=-14]="DateMillisecond",t[t.TimestampSecond=-15]="TimestampSecond",t[t.TimestampMillisecond=-16]="TimestampMillisecond",t[t.TimestampMicrosecond=-17]="TimestampMicrosecond",t[t.TimestampNanosecond=-18]="TimestampNanosecond",t[t.TimeSecond=-19]="TimeSecond",t[t.TimeMillisecond=-20]="TimeMillisecond",t[t.TimeMicrosecond=-21]="TimeMicrosecond",t[t.TimeNanosecond=-22]="TimeNanosecond",t[t.DenseUnion=-23]="DenseUnion",t[t.SparseUnion=-24]="SparseUnion",t[t.IntervalDayTime=-25]="IntervalDayTime",t[t.IntervalYearMonth=-26]="IntervalYearMonth",t[t.DurationSecond=-27]="DurationSecond",t[t.DurationMillisecond=-28]="DurationMillisecond",t[t.DurationMicrosecond=-29]="DurationMicrosecond",t[t.DurationNanosecond=-30]="DurationNanosecond"})(Z||(Z={}));var Wi;(function(t){t[t.OFFSET=0]="OFFSET",t[t.DATA=1]="DATA",t[t.VALIDITY=2]="VALIDITY",t[t.TYPE=3]="TYPE"})(Wi||(Wi={}));var hq={};fr(hq,{clampIndex:()=>OV,clampRange:()=>Th,createElementComparator:()=>$7});var Y_={};fr(Y_,{valueToString:()=>Yi});function Yi(t){if(t===null)return"null";if(t===void 0)return"undefined";switch(typeof t){case"number":return`${t}`;case"bigint":return`${t}`;case"string":return`"${t}"`}return typeof t[Symbol.toPrimitive]=="function"?t[Symbol.toPrimitive]("string"):ArrayBuffer.isView(t)?t instanceof BigInt64Array||t instanceof BigUint64Array?`[${[...t].map(A=>Yi(A))}]`:`[${t}]`:ArrayBuffer.isView(t)?`[${t}]`:JSON.stringify(t,(A,j)=>typeof j=="bigint"?`${j}`:j)}var Z_={};fr(Z_,{BN:()=>Mh,bigNumToBigInt:()=>b8,bigNumToString:()=>Gu,isArrowBigNumSymbol:()=>q8});var q8=Symbol.for("isArrowBigNum");function Ji(t,...A){return A.length===0?Object.setPrototypeOf(Mt(this.TypedArray,t),this.constructor.prototype):Object.setPrototypeOf(new this.TypedArray(t,...A),this.constructor.prototype)}Ji.prototype[q8]=!0;Ji.prototype.toJSON=function(){return`"${Gu(this)}"`};Ji.prototype.valueOf=function(){return G8(this)};Ji.prototype.toString=function(){return Gu(this)};Ji.prototype[Symbol.toPrimitive]=function(t="default"){switch(t){case"number":return G8(this);case"string":return Gu(this);case"default":return b8(this)}return Gu(this)};function _u(...t){return Ji.apply(this,t)}function qu(...t){return Ji.apply(this,t)}function Ih(...t){return Ji.apply(this,t)}Object.setPrototypeOf(_u.prototype,Object.create(Int32Array.prototype));Object.setPrototypeOf(qu.prototype,Object.create(Uint32Array.prototype));Object.setPrototypeOf(Ih.prototype,Object.create(Uint32Array.prototype));Object.assign(_u.prototype,Ji.prototype,{constructor:_u,signed:!0,TypedArray:Int32Array,BigIntArray:BigInt64Array});Object.assign(qu.prototype,Ji.prototype,{constructor:qu,signed:!1,TypedArray:Uint32Array,BigIntArray:BigUint64Array});Object.assign(Ih.prototype,Ji.prototype,{constructor:Ih,signed:!0,TypedArray:Uint32Array,BigIntArray:BigUint64Array});function G8(t){let{buffer:A,byteOffset:j,length:e,signed:r}=t,n=new BigUint64Array(A,j,e),i=r&&n.at(-1)&BigInt(1)<{if(t.byteLength===8)return`${new t.BigIntArray(t.buffer,t.byteOffset,1)[0]}`;if(!t.signed)return J_(t);let A=new Uint16Array(t.buffer,t.byteOffset,t.byteLength/2);if(new Int16Array([A.at(-1)])[0]>=0)return J_(t);A=A.slice();let e=1;for(let n=0;nt.byteLength===8?new t.BigIntArray(t.buffer,t.byteOffset,1)[0]:Gu(t);function J_(t){let A="",j=new Uint32Array(2),e=new Uint16Array(t.buffer,t.byteOffset,t.byteLength/2),r=new Uint32Array((e=new Uint16Array(e).reverse()).buffer),n=-1,i=e.length-1;do{for(j[0]=e[n=0];nNumber.MAX_SAFE_INTEGER))throw new TypeError(`${t} is not safe to convert to a number.`);return Number(t)}var w8,F8,P8,I8,M8,O8,T8,S8,R8,L8,C8,H8,D8,N8,K8,X8,z8,U8,V8,Q8,W8,Y8,HA=class t{static isNull(A){return A?.typeId===Z.Null}static isInt(A){return A?.typeId===Z.Int}static isFloat(A){return A?.typeId===Z.Float}static isBinary(A){return A?.typeId===Z.Binary}static isLargeBinary(A){return A?.typeId===Z.LargeBinary}static isUtf8(A){return A?.typeId===Z.Utf8}static isLargeUtf8(A){return A?.typeId===Z.LargeUtf8}static isBool(A){return A?.typeId===Z.Bool}static isDecimal(A){return A?.typeId===Z.Decimal}static isDate(A){return A?.typeId===Z.Date}static isTime(A){return A?.typeId===Z.Time}static isTimestamp(A){return A?.typeId===Z.Timestamp}static isInterval(A){return A?.typeId===Z.Interval}static isDuration(A){return A?.typeId===Z.Duration}static isList(A){return A?.typeId===Z.List}static isStruct(A){return A?.typeId===Z.Struct}static isUnion(A){return A?.typeId===Z.Union}static isFixedSizeBinary(A){return A?.typeId===Z.FixedSizeBinary}static isFixedSizeList(A){return A?.typeId===Z.FixedSizeList}static isMap(A){return A?.typeId===Z.Map}static isDictionary(A){return A?.typeId===Z.Dictionary}static isDenseUnion(A){return t.isUnion(A)&&A.mode===bj.Dense}static isSparseUnion(A){return t.isUnion(A)&&A.mode===bj.Sparse}constructor(A){this.typeId=A}};w8=Symbol.toStringTag;HA[w8]=(t=>(t.children=null,t.ArrayType=Array,t.OffsetArrayType=Int32Array,t[Symbol.toStringTag]="DataType"))(HA.prototype);var Gn=class extends HA{constructor(){super(Z.Null)}toString(){return"Null"}};F8=Symbol.toStringTag;Gn[F8]=(t=>t[Symbol.toStringTag]="Null")(Gn.prototype);var qe=class extends HA{constructor(A,j){super(Z.Int),this.isSigned=A,this.bitWidth=j}get ArrayType(){switch(this.bitWidth){case 8:return this.isSigned?Int8Array:Uint8Array;case 16:return this.isSigned?Int16Array:Uint16Array;case 32:return this.isSigned?Int32Array:Uint32Array;case 64:return this.isSigned?BigInt64Array:BigUint64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}toString(){return`${this.isSigned?"I":"Ui"}nt${this.bitWidth}`}};P8=Symbol.toStringTag;qe[P8]=(t=>(t.isSigned=null,t.bitWidth=null,t[Symbol.toStringTag]="Int"))(qe.prototype);var bg=class extends qe{constructor(){super(!0,8)}get ArrayType(){return Int8Array}},wg=class extends qe{constructor(){super(!0,16)}get ArrayType(){return Int16Array}},Xo=class extends qe{constructor(){super(!0,32)}get ArrayType(){return Int32Array}},Fg=class extends qe{constructor(){super(!0,64)}get ArrayType(){return BigInt64Array}},Pg=class extends qe{constructor(){super(!1,8)}get ArrayType(){return Uint8Array}},Ig=class extends qe{constructor(){super(!1,16)}get ArrayType(){return Uint16Array}},Mg=class extends qe{constructor(){super(!1,32)}get ArrayType(){return Uint32Array}},Og=class extends qe{constructor(){super(!1,64)}get ArrayType(){return BigUint64Array}};Object.defineProperty(bg.prototype,"ArrayType",{value:Int8Array});Object.defineProperty(wg.prototype,"ArrayType",{value:Int16Array});Object.defineProperty(Xo.prototype,"ArrayType",{value:Int32Array});Object.defineProperty(Fg.prototype,"ArrayType",{value:BigInt64Array});Object.defineProperty(Pg.prototype,"ArrayType",{value:Uint8Array});Object.defineProperty(Ig.prototype,"ArrayType",{value:Uint16Array});Object.defineProperty(Mg.prototype,"ArrayType",{value:Uint32Array});Object.defineProperty(Og.prototype,"ArrayType",{value:BigUint64Array});var k6=class extends HA{constructor(A){super(Z.Float),this.precision=A}get ArrayType(){switch(this.precision){case mj.HALF:return Uint16Array;case mj.SINGLE:return Float32Array;case mj.DOUBLE:return Float64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}toString(){return`Float${this.precision<<5||16}`}};I8=Symbol.toStringTag;k6[I8]=(t=>(t.precision=null,t[Symbol.toStringTag]="Float"))(k6.prototype);var Tg=class extends k6{constructor(){super(mj.HALF)}},Sg=class extends k6{constructor(){super(mj.SINGLE)}},Rg=class extends k6{constructor(){super(mj.DOUBLE)}};Object.defineProperty(Tg.prototype,"ArrayType",{value:Uint16Array});Object.defineProperty(Sg.prototype,"ArrayType",{value:Float32Array});Object.defineProperty(Rg.prototype,"ArrayType",{value:Float64Array});var Zs=class extends HA{constructor(){super(Z.Binary)}toString(){return"Binary"}};M8=Symbol.toStringTag;Zs[M8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Binary"))(Zs.prototype);var Aa=class extends HA{constructor(){super(Z.LargeBinary)}toString(){return"LargeBinary"}};O8=Symbol.toStringTag;Aa[O8]=(t=>(t.ArrayType=Uint8Array,t.OffsetArrayType=BigInt64Array,t[Symbol.toStringTag]="LargeBinary"))(Aa.prototype);var ta=class extends HA{constructor(){super(Z.Utf8)}toString(){return"Utf8"}};T8=Symbol.toStringTag;ta[T8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Utf8"))(ta.prototype);var ja=class extends HA{constructor(){super(Z.LargeUtf8)}toString(){return"LargeUtf8"}};S8=Symbol.toStringTag;ja[S8]=(t=>(t.ArrayType=Uint8Array,t.OffsetArrayType=BigInt64Array,t[Symbol.toStringTag]="LargeUtf8"))(ja.prototype);var ea=class extends HA{constructor(){super(Z.Bool)}toString(){return"Bool"}};R8=Symbol.toStringTag;ea[R8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Bool"))(ea.prototype);var ra=class extends HA{constructor(A,j,e=128){super(Z.Decimal),this.scale=A,this.precision=j,this.bitWidth=e}toString(){return`Decimal[${this.precision}e${this.scale>0?"+":""}${this.scale}]`}};L8=Symbol.toStringTag;ra[L8]=(t=>(t.scale=null,t.precision=null,t.ArrayType=Uint32Array,t[Symbol.toStringTag]="Decimal"))(ra.prototype);var na=class extends HA{constructor(A){super(Z.Date),this.unit=A}toString(){return`Date${(this.unit+1)*32}<${Ce[this.unit]}>`}};C8=Symbol.toStringTag;na[C8]=(t=>(t.unit=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Date"))(na.prototype);var Zi=class extends HA{constructor(A,j){super(Z.Time),this.unit=A,this.bitWidth=j}toString(){return`Time${this.bitWidth}<${XA[this.unit]}>`}get ArrayType(){switch(this.bitWidth){case 32:return Int32Array;case 64:return BigInt64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}};H8=Symbol.toStringTag;Zi[H8]=(t=>(t.unit=null,t.bitWidth=null,t[Symbol.toStringTag]="Time"))(Zi.prototype);var ia=class extends HA{constructor(A,j){super(Z.Timestamp),this.unit=A,this.timezone=j}toString(){return`Timestamp<${XA[this.unit]}${this.timezone?`, ${this.timezone}`:""}>`}};D8=Symbol.toStringTag;ia[D8]=(t=>(t.unit=null,t.timezone=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Timestamp"))(ia.prototype);var oa=class extends HA{constructor(A){super(Z.Interval),this.unit=A}toString(){return`Interval<${hr[this.unit]}>`}};N8=Symbol.toStringTag;oa[N8]=(t=>(t.unit=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Interval"))(oa.prototype);var sa=class extends HA{constructor(A){super(Z.Duration),this.unit=A}toString(){return`Duration<${XA[this.unit]}>`}};K8=Symbol.toStringTag;sa[K8]=(t=>(t.unit=null,t.ArrayType=BigInt64Array,t[Symbol.toStringTag]="Duration"))(sa.prototype);var Ao=class extends HA{constructor(A){super(Z.List),this.children=[A]}toString(){return`List<${this.valueType}>`}get valueType(){return this.children[0].type}get valueField(){return this.children[0]}get ArrayType(){return this.valueType.ArrayType}};X8=Symbol.toStringTag;Ao[X8]=(t=>(t.children=null,t[Symbol.toStringTag]="List"))(Ao.prototype);var Oj=class extends HA{constructor(A){super(Z.Struct),this.children=A}toString(){return`Struct<{${this.children.map(A=>`${A.name}:${A.type}`).join(", ")}}>`}};z8=Symbol.toStringTag;Oj[z8]=(t=>(t.children=null,t[Symbol.toStringTag]="Struct"))(Oj.prototype);var to=class extends HA{constructor(A,j,e){super(Z.Union),this.mode=A,this.children=e,this.typeIds=j=Int32Array.from(j),this.typeIdToChildIndex=j.reduce((r,n,i)=>(r[n]=i)&&r||r,Object.create(null))}toString(){return`${this[Symbol.toStringTag]}<${this.children.map(A=>`${A.type}`).join(" | ")}>`}};U8=Symbol.toStringTag;to[U8]=(t=>(t.mode=null,t.typeIds=null,t.children=null,t.typeIdToChildIndex=null,t.ArrayType=Int8Array,t[Symbol.toStringTag]="Union"))(to.prototype);var aa=class extends HA{constructor(A){super(Z.FixedSizeBinary),this.byteWidth=A}toString(){return`FixedSizeBinary[${this.byteWidth}]`}};V8=Symbol.toStringTag;aa[V8]=(t=>(t.byteWidth=null,t.ArrayType=Uint8Array,t[Symbol.toStringTag]="FixedSizeBinary"))(aa.prototype);var jo=class extends HA{constructor(A,j){super(Z.FixedSizeList),this.listSize=A,this.children=[j]}get valueType(){return this.children[0].type}get valueField(){return this.children[0]}get ArrayType(){return this.valueType.ArrayType}toString(){return`FixedSizeList[${this.listSize}]<${this.valueType}>`}};Q8=Symbol.toStringTag;jo[Q8]=(t=>(t.children=null,t.listSize=null,t[Symbol.toStringTag]="FixedSizeList"))(jo.prototype);var eo=class extends HA{constructor(A,j=!1){var e,r,n;if(super(Z.Map),this.children=[A],this.keysSorted=j,A&&(A.name="entries",!((e=A?.type)===null||e===void 0)&&e.children)){let i=(r=A?.type)===null||r===void 0?void 0:r.children[0];i&&(i.name="key");let o=(n=A?.type)===null||n===void 0?void 0:n.children[1];o&&(o.name="value")}}get keyType(){return this.children[0].type.children[0].type}get valueType(){return this.children[0].type.children[1].type}get childType(){return this.children[0].type}toString(){return`Map<{${this.children[0].type.children.map(A=>`${A.name}:${A.type}`).join(", ")}}>`}};W8=Symbol.toStringTag;eo[W8]=(t=>(t.children=null,t.keysSorted=null,t[Symbol.toStringTag]="Map_"))(eo.prototype);var Q9=(t=>()=>++t)(-1),z6=class extends HA{constructor(A,j,e,r){super(Z.Dictionary),this.indices=j,this.dictionary=A,this.isOrdered=r||!1,this.id=e==null?Q9():ee(e)}get children(){return this.dictionary.children}get valueType(){return this.dictionary}get ArrayType(){return this.dictionary.ArrayType}toString(){return`Dictionary<${this.indices}, ${this.dictionary}>`}};Y8=Symbol.toStringTag;z6[Y8]=(t=>(t.id=null,t.indices=null,t.isOrdered=null,t.dictionary=null,t[Symbol.toStringTag]="Dictionary"))(z6.prototype);function U6(t){let A=t;switch(t.typeId){case Z.Decimal:return t.bitWidth/32;case Z.Timestamp:return 2;case Z.Date:return 1+A.unit;case Z.Interval:return 1+A.unit;case Z.FixedSizeList:return A.listSize;case Z.FixedSizeBinary:return A.byteWidth;default:return 1}}var WA=class{visitMany(A,...j){return A.map((e,r)=>this.visit(e,...j.map(n=>n[r])))}visit(...A){return this.getVisitFn(A[0],!1).apply(this,A)}getVisitFn(A,j=!0){return W9(this,A,j)}getVisitFnByTypeId(A,j=!0){return bu(this,A,j)}visitNull(A,...j){return null}visitBool(A,...j){return null}visitInt(A,...j){return null}visitFloat(A,...j){return null}visitUtf8(A,...j){return null}visitLargeUtf8(A,...j){return null}visitBinary(A,...j){return null}visitLargeBinary(A,...j){return null}visitFixedSizeBinary(A,...j){return null}visitDate(A,...j){return null}visitTimestamp(A,...j){return null}visitTime(A,...j){return null}visitDecimal(A,...j){return null}visitList(A,...j){return null}visitStruct(A,...j){return null}visitUnion(A,...j){return null}visitDictionary(A,...j){return null}visitInterval(A,...j){return null}visitDuration(A,...j){return null}visitFixedSizeList(A,...j){return null}visitMap(A,...j){return null}};function W9(t,A,j=!0){return typeof A=="number"?bu(t,A,j):typeof A=="string"&&A in Z?bu(t,Z[A],j):A&&A instanceof HA?bu(t,J8(A),j):A?.type&&A.type instanceof HA?bu(t,J8(A.type),j):bu(t,Z.NONE,j)}function bu(t,A,j=!0){let e=null;switch(A){case Z.Null:e=t.visitNull;break;case Z.Bool:e=t.visitBool;break;case Z.Int:e=t.visitInt;break;case Z.Int8:e=t.visitInt8||t.visitInt;break;case Z.Int16:e=t.visitInt16||t.visitInt;break;case Z.Int32:e=t.visitInt32||t.visitInt;break;case Z.Int64:e=t.visitInt64||t.visitInt;break;case Z.Uint8:e=t.visitUint8||t.visitInt;break;case Z.Uint16:e=t.visitUint16||t.visitInt;break;case Z.Uint32:e=t.visitUint32||t.visitInt;break;case Z.Uint64:e=t.visitUint64||t.visitInt;break;case Z.Float:e=t.visitFloat;break;case Z.Float16:e=t.visitFloat16||t.visitFloat;break;case Z.Float32:e=t.visitFloat32||t.visitFloat;break;case Z.Float64:e=t.visitFloat64||t.visitFloat;break;case Z.Utf8:e=t.visitUtf8;break;case Z.LargeUtf8:e=t.visitLargeUtf8;break;case Z.Binary:e=t.visitBinary;break;case Z.LargeBinary:e=t.visitLargeBinary;break;case Z.FixedSizeBinary:e=t.visitFixedSizeBinary;break;case Z.Date:e=t.visitDate;break;case Z.DateDay:e=t.visitDateDay||t.visitDate;break;case Z.DateMillisecond:e=t.visitDateMillisecond||t.visitDate;break;case Z.Timestamp:e=t.visitTimestamp;break;case Z.TimestampSecond:e=t.visitTimestampSecond||t.visitTimestamp;break;case Z.TimestampMillisecond:e=t.visitTimestampMillisecond||t.visitTimestamp;break;case Z.TimestampMicrosecond:e=t.visitTimestampMicrosecond||t.visitTimestamp;break;case Z.TimestampNanosecond:e=t.visitTimestampNanosecond||t.visitTimestamp;break;case Z.Time:e=t.visitTime;break;case Z.TimeSecond:e=t.visitTimeSecond||t.visitTime;break;case Z.TimeMillisecond:e=t.visitTimeMillisecond||t.visitTime;break;case Z.TimeMicrosecond:e=t.visitTimeMicrosecond||t.visitTime;break;case Z.TimeNanosecond:e=t.visitTimeNanosecond||t.visitTime;break;case Z.Decimal:e=t.visitDecimal;break;case Z.List:e=t.visitList;break;case Z.Struct:e=t.visitStruct;break;case Z.Union:e=t.visitUnion;break;case Z.DenseUnion:e=t.visitDenseUnion||t.visitUnion;break;case Z.SparseUnion:e=t.visitSparseUnion||t.visitUnion;break;case Z.Dictionary:e=t.visitDictionary;break;case Z.Interval:e=t.visitInterval;break;case Z.IntervalDayTime:e=t.visitIntervalDayTime||t.visitInterval;break;case Z.IntervalYearMonth:e=t.visitIntervalYearMonth||t.visitInterval;break;case Z.Duration:e=t.visitDuration;break;case Z.DurationSecond:e=t.visitDurationSecond||t.visitDuration;break;case Z.DurationMillisecond:e=t.visitDurationMillisecond||t.visitDuration;break;case Z.DurationMicrosecond:e=t.visitDurationMicrosecond||t.visitDuration;break;case Z.DurationNanosecond:e=t.visitDurationNanosecond||t.visitDuration;break;case Z.FixedSizeList:e=t.visitFixedSizeList;break;case Z.Map:e=t.visitMap;break}if(typeof e=="function")return e;if(!j)return()=>null;throw new Error(`Unrecognized type '${Z[A]}'`)}function J8(t){switch(t.typeId){case Z.Null:return Z.Null;case Z.Int:{let{bitWidth:A,isSigned:j}=t;switch(A){case 8:return j?Z.Int8:Z.Uint8;case 16:return j?Z.Int16:Z.Uint16;case 32:return j?Z.Int32:Z.Uint32;case 64:return j?Z.Int64:Z.Uint64}return Z.Int}case Z.Float:switch(t.precision){case mj.HALF:return Z.Float16;case mj.SINGLE:return Z.Float32;case mj.DOUBLE:return Z.Float64}return Z.Float;case Z.Binary:return Z.Binary;case Z.LargeBinary:return Z.LargeBinary;case Z.Utf8:return Z.Utf8;case Z.LargeUtf8:return Z.LargeUtf8;case Z.Bool:return Z.Bool;case Z.Decimal:return Z.Decimal;case Z.Time:switch(t.unit){case XA.SECOND:return Z.TimeSecond;case XA.MILLISECOND:return Z.TimeMillisecond;case XA.MICROSECOND:return Z.TimeMicrosecond;case XA.NANOSECOND:return Z.TimeNanosecond}return Z.Time;case Z.Timestamp:switch(t.unit){case XA.SECOND:return Z.TimestampSecond;case XA.MILLISECOND:return Z.TimestampMillisecond;case XA.MICROSECOND:return Z.TimestampMicrosecond;case XA.NANOSECOND:return Z.TimestampNanosecond}return Z.Timestamp;case Z.Date:switch(t.unit){case Ce.DAY:return Z.DateDay;case Ce.MILLISECOND:return Z.DateMillisecond}return Z.Date;case Z.Interval:switch(t.unit){case hr.DAY_TIME:return Z.IntervalDayTime;case hr.YEAR_MONTH:return Z.IntervalYearMonth}return Z.Interval;case Z.Duration:switch(t.unit){case XA.SECOND:return Z.DurationSecond;case XA.MILLISECOND:return Z.DurationMillisecond;case XA.MICROSECOND:return Z.DurationMicrosecond;case XA.NANOSECOND:return Z.DurationNanosecond}return Z.Duration;case Z.Map:return Z.Map;case Z.List:return Z.List;case Z.Struct:return Z.Struct;case Z.Union:switch(t.mode){case bj.Dense:return Z.DenseUnion;case bj.Sparse:return Z.SparseUnion}return Z.Union;case Z.FixedSizeBinary:return Z.FixedSizeBinary;case Z.FixedSizeList:return Z.FixedSizeList;case Z.Dictionary:return Z.Dictionary}throw new Error(`Unrecognized type '${Z[t.typeId]}'`)}WA.prototype.visitInt8=null;WA.prototype.visitInt16=null;WA.prototype.visitInt32=null;WA.prototype.visitInt64=null;WA.prototype.visitUint8=null;WA.prototype.visitUint16=null;WA.prototype.visitUint32=null;WA.prototype.visitUint64=null;WA.prototype.visitFloat16=null;WA.prototype.visitFloat32=null;WA.prototype.visitFloat64=null;WA.prototype.visitDateDay=null;WA.prototype.visitDateMillisecond=null;WA.prototype.visitTimestampSecond=null;WA.prototype.visitTimestampMillisecond=null;WA.prototype.visitTimestampMicrosecond=null;WA.prototype.visitTimestampNanosecond=null;WA.prototype.visitTimeSecond=null;WA.prototype.visitTimeMillisecond=null;WA.prototype.visitTimeMicrosecond=null;WA.prototype.visitTimeNanosecond=null;WA.prototype.visitDenseUnion=null;WA.prototype.visitSparseUnion=null;WA.prototype.visitIntervalDayTime=null;WA.prototype.visitIntervalYearMonth=null;WA.prototype.visitDuration=null;WA.prototype.visitDurationSecond=null;WA.prototype.visitDurationMillisecond=null;WA.prototype.visitDurationMicrosecond=null;WA.prototype.visitDurationNanosecond=null;var Aq={};fr(Aq,{float64ToUint16:()=>Oh,uint16ToFloat64:()=>Lg});var Z8=new Float64Array(1),wu=new Uint32Array(Z8.buffer);function Lg(t){let A=(t&31744)>>10,j=(t&1023)/1024,e=Math.pow(-1,(t&32768)>>15);switch(A){case 31:return e*(j?Number.NaN:1/0);case 0:return e*(j?6103515625e-14*j:0)}return e*Math.pow(2,A-15)*(1+j)}function Oh(t){if(t!==t)return 32256;Z8[0]=t;let A=(wu[1]&2147483648)>>16&65535,j=wu[1]&2146435072,e=0;return j>=1089470464?wu[0]>0?j=31744:(j=(j&2080374784)>>16,e=(wu[1]&1048575)>>10):j<=1056964608?(e=1048576+(wu[1]&1048575),e=1048576+(e<<(j>>20)-998)>>21,j=0):(j=j-1056964608>>10,e=(wu[1]&1048575)+512>>10),A|j|e&65535}var et=class extends WA{};function Bt(t){return(A,j,e)=>{if(A.setValid(j,e!=null))return t(A,j,e)}}var Y9=(t,A,j)=>{t[A]=Math.trunc(j/864e5)},tq=(t,A,j)=>{t[A]=Math.trunc(j%4294967296),t[A+1]=Math.trunc(j/4294967296)},J9=(t,A,j)=>{t[A]=Math.trunc(j*1e3%4294967296),t[A+1]=Math.trunc(j*1e3/4294967296)},Z9=(t,A,j)=>{t[A]=Math.trunc(j*1e6%4294967296),t[A+1]=Math.trunc(j*1e6/4294967296)},AM=(t,A,j,e)=>{if(j+1{let r=t+j;e?A[r>>3]|=1<>3]&=~(1<{t[A]=j},jq=({values:t},A,j)=>{t[A]=j},tM=({values:t},A,j)=>{t[A]=Oh(j)},tV=(t,A,j)=>{switch(t.type.precision){case mj.HALF:return tM(t,A,j);case mj.SINGLE:case mj.DOUBLE:return jq(t,A,j)}},Cg=({values:t},A,j)=>{Y9(t,A,j.valueOf())},Hg=({values:t},A,j)=>{tq(t,A*2,j.valueOf())},eq=({stride:t,values:A},j,e)=>{A.set(e.subarray(0,t),t*j)},jM=({values:t,valueOffsets:A},j,e)=>AM(t,A,j,e),eM=({values:t,valueOffsets:A},j,e)=>AM(t,A,j,Co(e)),rq=(t,A,j)=>{t.type.unit===Ce.DAY?Cg(t,A,j):Hg(t,A,j)},Dg=({values:t},A,j)=>tq(t,A*2,j/1e3),Ng=({values:t},A,j)=>tq(t,A*2,j),Kg=({values:t},A,j)=>J9(t,A*2,j),Xg=({values:t},A,j)=>Z9(t,A*2,j),nq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return Dg(t,A,j);case XA.MILLISECOND:return Ng(t,A,j);case XA.MICROSECOND:return Kg(t,A,j);case XA.NANOSECOND:return Xg(t,A,j)}},zg=({values:t},A,j)=>{t[A]=j},Ug=({values:t},A,j)=>{t[A]=j},Vg=({values:t},A,j)=>{t[A]=j},Qg=({values:t},A,j)=>{t[A]=j},iq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return zg(t,A,j);case XA.MILLISECOND:return Ug(t,A,j);case XA.MICROSECOND:return Vg(t,A,j);case XA.NANOSECOND:return Qg(t,A,j)}},oq=({values:t,stride:A},j,e)=>{t.set(e.subarray(0,A),A*j)},jV=(t,A,j)=>{let e=t.children[0],r=t.valueOffsets,n=Or.getVisitFn(e);if(Array.isArray(j))for(let i=-1,o=r[A],l=r[A+1];o{let e=t.children[0],{valueOffsets:r}=t,n=Or.getVisitFn(e),{[A]:i,[A+1]:o}=r,l=j instanceof Map?j.entries():Object.entries(j);for(let c of l)if(n(e,i,c),++i>=o)break},rV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A[n]),nV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A.get(n)),iV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A.get(r.name)),oV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A[r.name]),sV=(t,A,j)=>{let e=t.type.children.map(n=>Or.getVisitFn(n.type)),r=j instanceof Map?iV(A,j):j instanceof Dt?nV(A,j):Array.isArray(j)?rV(A,j):oV(A,j);t.type.children.forEach((n,i)=>r(e[i],t.children[i],n,i))},aV=(t,A,j)=>{t.type.mode===bj.Dense?rM(t,A,j):nM(t,A,j)},rM=(t,A,j)=>{let e=t.type.typeIdToChildIndex[t.typeIds[A]],r=t.children[e];Or.visit(r,t.valueOffsets[A],j)},nM=(t,A,j)=>{let e=t.type.typeIdToChildIndex[t.typeIds[A]],r=t.children[e];Or.visit(r,A,j)},lV=(t,A,j)=>{var e;(e=t.dictionary)===null||e===void 0||e.set(t.values[A],j)},sq=(t,A,j)=>{t.type.unit===hr.DAY_TIME?Wg(t,A,j):Yg(t,A,j)},Wg=({values:t},A,j)=>{t.set(j.subarray(0,2),2*A)},Yg=({values:t},A,j)=>{t[A]=j[0]*12+j[1]%12},Jg=({values:t},A,j)=>{t[A]=j},Zg=({values:t},A,j)=>{t[A]=j},Am=({values:t},A,j)=>{t[A]=j},tm=({values:t},A,j)=>{t[A]=j},aq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return Jg(t,A,j);case XA.MILLISECOND:return Zg(t,A,j);case XA.MICROSECOND:return Am(t,A,j);case XA.NANOSECOND:return tm(t,A,j)}},cV=(t,A,j)=>{let{stride:e}=t,r=t.children[0],n=Or.getVisitFn(r);if(Array.isArray(j))for(let i=-1,o=A*e;++i`${Yi(A)}: ${Yi(j)}`).join(", ")}}`}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}[Symbol.iterator](){return new lq(this[ro],this[Fu])}},lq=class{constructor(A,j){this.childIndex=0,this.children=A.children,this.rowIndex=j,this.childFields=A.type.children,this.numChildren=this.childFields.length}[Symbol.iterator](){return this}next(){let A=this.childIndex;return Aj.name)}has(A,j){return A[ro].type.children.findIndex(e=>e.name===j)!==-1}getOwnPropertyDescriptor(A,j){if(A[ro].type.children.findIndex(e=>e.name===j)!==-1)return{writable:!0,enumerable:!0,configurable:!0}}get(A,j){if(Reflect.has(A,j))return A[j];let e=A[ro].type.children.findIndex(r=>r.name===j);if(e!==-1){let r=He.visit(A[ro].children[e],A[Fu]);return Reflect.set(A,j,r),r}}set(A,j,e){let r=A[ro].type.children.findIndex(n=>n.name===j);return r!==-1?(Or.visit(A[ro].children[r],A[Fu],e),Reflect.set(A,j,e)):Reflect.has(A,j)||typeof j=="symbol"?Reflect.set(A,j,e):!1}};var YA=class extends WA{};function lt(t){return(A,j)=>A.getValid(j)?t(A,j):null}var uV=(t,A)=>864e5*t[A],uq=(t,A)=>4294967296*t[A+1]+(t[A]>>>0),BV=(t,A)=>4294967296*(t[A+1]/1e3)+(t[A]>>>0)/1e3,fV=(t,A)=>4294967296*(t[A+1]/1e6)+(t[A]>>>0)/1e6,iM=t=>new Date(t),hV=(t,A)=>iM(uV(t,A)),dV=(t,A)=>iM(uq(t,A)),pV=(t,A)=>null,oM=(t,A,j)=>{if(j+1>=A.length)return null;let e=ee(A[j]),r=ee(A[j+1]);return t.subarray(e,r)},kV=({offset:t,values:A},j)=>{let e=t+j;return(A[e>>3]&1<hV(t,A),aM=({values:t},A)=>dV(t,A*2),E7=({stride:t,values:A},j)=>A[t*j],gV=({stride:t,values:A},j)=>Lg(A[t*j]),lM=({values:t},A)=>t[A],mV=({stride:t,values:A},j)=>A.subarray(t*j,t*(j+1)),cM=({values:t,valueOffsets:A},j)=>oM(t,A,j),uM=({values:t,valueOffsets:A},j)=>{let e=oM(t,A,j);return e!==null?kh(e):null},EV=({values:t},A)=>t[A],$V=({type:t,values:A},j)=>t.precision!==mj.HALF?A[j]:Lg(A[j]),xV=(t,A)=>t.type.unit===Ce.DAY?sM(t,A):aM(t,A),BM=({values:t},A)=>1e3*uq(t,A*2),fM=({values:t},A)=>uq(t,A*2),hM=({values:t},A)=>BV(t,A*2),dM=({values:t},A)=>fV(t,A*2),yV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return BM(t,A);case XA.MILLISECOND:return fM(t,A);case XA.MICROSECOND:return hM(t,A);case XA.NANOSECOND:return dM(t,A)}},pM=({values:t},A)=>t[A],kM=({values:t},A)=>t[A],gM=({values:t},A)=>t[A],mM=({values:t},A)=>t[A],vV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return pM(t,A);case XA.MILLISECOND:return kM(t,A);case XA.MICROSECOND:return gM(t,A);case XA.NANOSECOND:return mM(t,A)}},_V=({values:t,stride:A},j)=>Mh.decimal(t.subarray(A*j,A*(j+1))),qV=(t,A)=>{let{valueOffsets:j,stride:e,children:r}=t,{[A*e]:n,[A*e+1]:i}=j,l=r[0].slice(n,i-n);return new Dt([l])},GV=(t,A)=>{let{valueOffsets:j,children:e}=t,{[A]:r,[A+1]:n}=j,i=e[0];return new zo(i.slice(r,n-r))},bV=(t,A)=>new m7(t,A),wV=(t,A)=>t.type.mode===bj.Dense?EM(t,A):$M(t,A),EM=(t,A)=>{let j=t.type.typeIdToChildIndex[t.typeIds[A]],e=t.children[j];return He.visit(e,t.valueOffsets[A])},$M=(t,A)=>{let j=t.type.typeIdToChildIndex[t.typeIds[A]],e=t.children[j];return He.visit(e,A)},FV=(t,A)=>{var j;return(j=t.dictionary)===null||j===void 0?void 0:j.get(t.values[A])},PV=(t,A)=>t.type.unit===hr.DAY_TIME?xM(t,A):yM(t,A),xM=({values:t},A)=>t.subarray(2*A,2*(A+1)),yM=({values:t},A)=>{let j=t[A],e=new Int32Array(2);return e[0]=Math.trunc(j/12),e[1]=Math.trunc(j%12),e},vM=({values:t},A)=>t[A],_M=({values:t},A)=>t[A],qM=({values:t},A)=>t[A],GM=({values:t},A)=>t[A],IV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return vM(t,A);case XA.MILLISECOND:return _M(t,A);case XA.MICROSECOND:return qM(t,A);case XA.NANOSECOND:return GM(t,A)}},MV=(t,A)=>{let{stride:j,children:e}=t,n=e[0].slice(A*j,j);return new Dt([n])};YA.prototype.visitNull=lt(pV);YA.prototype.visitBool=lt(kV);YA.prototype.visitInt=lt(EV);YA.prototype.visitInt8=lt(E7);YA.prototype.visitInt16=lt(E7);YA.prototype.visitInt32=lt(E7);YA.prototype.visitInt64=lt(lM);YA.prototype.visitUint8=lt(E7);YA.prototype.visitUint16=lt(E7);YA.prototype.visitUint32=lt(E7);YA.prototype.visitUint64=lt(lM);YA.prototype.visitFloat=lt($V);YA.prototype.visitFloat16=lt(gV);YA.prototype.visitFloat32=lt(E7);YA.prototype.visitFloat64=lt(E7);YA.prototype.visitUtf8=lt(uM);YA.prototype.visitLargeUtf8=lt(uM);YA.prototype.visitBinary=lt(cM);YA.prototype.visitLargeBinary=lt(cM);YA.prototype.visitFixedSizeBinary=lt(mV);YA.prototype.visitDate=lt(xV);YA.prototype.visitDateDay=lt(sM);YA.prototype.visitDateMillisecond=lt(aM);YA.prototype.visitTimestamp=lt(yV);YA.prototype.visitTimestampSecond=lt(BM);YA.prototype.visitTimestampMillisecond=lt(fM);YA.prototype.visitTimestampMicrosecond=lt(hM);YA.prototype.visitTimestampNanosecond=lt(dM);YA.prototype.visitTime=lt(vV);YA.prototype.visitTimeSecond=lt(pM);YA.prototype.visitTimeMillisecond=lt(kM);YA.prototype.visitTimeMicrosecond=lt(gM);YA.prototype.visitTimeNanosecond=lt(mM);YA.prototype.visitDecimal=lt(_V);YA.prototype.visitList=lt(qV);YA.prototype.visitStruct=lt(bV);YA.prototype.visitUnion=lt(wV);YA.prototype.visitDenseUnion=lt(EM);YA.prototype.visitSparseUnion=lt($M);YA.prototype.visitDictionary=lt(FV);YA.prototype.visitInterval=lt(PV);YA.prototype.visitIntervalDayTime=lt(xM);YA.prototype.visitIntervalYearMonth=lt(yM);YA.prototype.visitDuration=lt(IV);YA.prototype.visitDurationSecond=lt(vM);YA.prototype.visitDurationMillisecond=lt(_M);YA.prototype.visitDurationMicrosecond=lt(qM);YA.prototype.visitDurationNanosecond=lt(GM);YA.prototype.visitFixedSizeList=lt(MV);YA.prototype.visitMap=lt(GV);var He=new YA;var hi=Symbol.for("keys"),Pu=Symbol.for("vals"),zo=class{constructor(A){return this[hi]=new Dt([A.children[0]]).memoize(),this[Pu]=A.children[1],new Proxy(this,new fq)}[Symbol.iterator](){return new Bq(this[hi],this[Pu])}get size(){return this[hi].length}toArray(){return Object.values(this.toJSON())}toJSON(){let A=this[hi],j=this[Pu],e={};for(let r=-1,n=A.length;++r`${Yi(A)}: ${Yi(j)}`).join(", ")}}`}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}},Bq=class{constructor(A,j){this.keys=A,this.vals=j,this.keyIndex=0,this.numKeys=A.length}[Symbol.iterator](){return this}next(){let A=this.keyIndex;return A===this.numKeys?{done:!0,value:null}:(this.keyIndex++,{done:!1,value:[this.keys.get(A),He.visit(this.vals,A)]})}},fq=class{isExtensible(){return!1}deleteProperty(){return!1}preventExtensions(){return!0}ownKeys(A){return A[hi].toArray().map(String)}has(A,j){return A[hi].includes(j)}getOwnPropertyDescriptor(A,j){if(A[hi].indexOf(j)!==-1)return{writable:!0,enumerable:!0,configurable:!0}}get(A,j){if(Reflect.has(A,j))return A[j];let e=A[hi].indexOf(j);if(e!==-1){let r=He.visit(Reflect.get(A,Pu),e);return Reflect.set(A,j,r),r}}set(A,j,e){let r=A[hi].indexOf(j);return r!==-1?(Or.visit(Reflect.get(A,Pu),r,e),Reflect.set(A,j,e)):Reflect.has(A,j)?Reflect.set(A,j,e):!1}};Object.defineProperties(zo.prototype,{[Symbol.toStringTag]:{enumerable:!1,configurable:!1,value:"Row"},[hi]:{writable:!0,enumerable:!1,configurable:!1,value:null},[Pu]:{writable:!0,enumerable:!1,configurable:!1,value:null}});function OV(t,A,j){let e=t.length,r=A>-1?A:e+A%e;return j?j(t,r):r}var bM;function Th(t,A,j,e){let{length:r=0}=t,n=typeof A!="number"?0:A,i=typeof j!="number"?r:j;return n<0&&(n=(n%r+r)%r),i<0&&(i=(i%r+r)%r),ir&&(i=r),e?e(t,n,i):[n,i]}var wM=t=>t!==t;function $7(t){if(typeof t!=="object"||t===null)return wM(t)?wM:j=>j===t;if(t instanceof Date){let j=t.valueOf();return e=>e instanceof Date?e.valueOf()===j:!1}return ArrayBuffer.isView(t)?j=>j?U_(t,j):!1:t instanceof Map?SV(t):Array.isArray(t)?TV(t):t instanceof Dt?RV(t):LV(t,!0)}function TV(t){let A=[];for(let j=-1,e=t.length;++j!1;let e=[];for(let r=-1,n=j.length;++r{if(!j||typeof j!="object")return!1;switch(j.constructor){case Array:return CV(t,j);case Map:return FM(t,j,j.keys());case zo:case m7:case Object:case void 0:return FM(t,j,A||Object.keys(j))}return j instanceof Dt?HV(t,j):!1}}function CV(t,A){let j=t.length;if(A.length!==j)return!1;for(let e=-1;++eCl,getBit:()=>PM,getBool:()=>rm,packBools:()=>Dl,popcnt_array:()=>IM,popcnt_bit_range:()=>Sh,popcnt_uint32:()=>em,setBool:()=>DV,truncateBitmap:()=>Hl});function rm(t,A,j,e){return(j&1<>e}function DV(t,A,j){return j?!!(t[A>>3]|=1<>3]&=~(1<0||j.byteLength>3):Dl(new Cl(j,t,A,null,rm)).subarray(0,e)),r}return j}function Dl(t){let A=[],j=0,e=0,r=0;for(let i of t)i&&(r|=1<0)&&(A[j++]=r);let n=new Uint8Array(A.length+7&-8);return n.set(A),n}var Cl=class{constructor(A,j,e,r,n){this.bytes=A,this.length=e,this.context=r,this.get=n,this.bit=j%8,this.byteIndex=j>>3,this.byte=A[this.byteIndex++],this.index=0}next(){return this.index>3<<3,r=A+(A%8===0?0:8-A%8);return Sh(t,A,r)+Sh(t,e,j)+IM(t,r>>3,e-r>>3)}function IM(t,A,j){let e=0,r=Math.trunc(A),n=new DataView(t.buffer,t.byteOffset,t.byteLength),i=j===void 0?t.byteLength:r+j;for(;i-r>=4;)e+=em(n.getUint32(r)),r+=4;for(;i-r>=2;)e+=em(n.getUint16(r)),r+=2;for(;i-r>=1;)e+=em(n.getUint8(r)),r+=1;return e}function em(t){let A=Math.trunc(t);return A=A-(A>>>1&1431655765),A=(A&858993459)+(A>>>2&858993459),(A+(A>>>4)&252645135)*16843009>>>24}var NV=-1,rj=class t{get typeId(){return this.type.typeId}get ArrayType(){return this.type.ArrayType}get buffers(){return[this.valueOffsets,this.values,this.nullBitmap,this.typeIds]}get nullable(){if(this._nullCount!==0){let{type:A}=this;return HA.isSparseUnion(A)?this.children.some(j=>j.nullable):HA.isDenseUnion(A)?this.children.some(j=>j.nullable):this.nullBitmap&&this.nullBitmap.byteLength>0}return!0}get byteLength(){let A=0,{valueOffsets:j,values:e,nullBitmap:r,typeIds:n}=this;return j&&(A+=j.byteLength),e&&(A+=e.byteLength),r&&(A+=r.byteLength),n&&(A+=n.byteLength),this.children.reduce((i,o)=>i+o.byteLength,A)}get nullCount(){if(HA.isUnion(this.type))return this.children.reduce((e,r)=>e+r.nullCount,0);let A=this._nullCount,j;return A<=NV&&(j=this.nullBitmap)&&(this._nullCount=A=this.length-Sh(j,this.offset,this.offset+this.length)),A}constructor(A,j,e,r,n,i=[],o){this.type=A,this.children=i,this.dictionary=o,this.offset=Math.floor(Math.max(j||0,0)),this.length=Math.floor(Math.max(e||0,0)),this._nullCount=Math.floor(Math.max(r||0,-1));let l;n instanceof t?(this.stride=n.stride,this.values=n.values,this.typeIds=n.typeIds,this.nullBitmap=n.nullBitmap,this.valueOffsets=n.valueOffsets):(this.stride=U6(A),n&&((l=n[0])&&(this.valueOffsets=l),(l=n[1])&&(this.values=l),(l=n[2])&&(this.nullBitmap=l),(l=n[3])&&(this.typeIds=l)))}getValid(A){let{type:j}=this;if(HA.isUnion(j)){let e=j,r=this.children[e.typeIdToChildIndex[this.typeIds[A]]],n=e.mode===bj.Dense?this.valueOffsets[A]:A;return r.getValid(n)}if(this.nullable&&this.nullCount>0){let e=this.offset+A;return(this.nullBitmap[e>>3]&1<>3;(!n||n.byteLength<=B)&&(n=new Uint8Array((i+o+63&-64)>>3).fill(255),this.nullCount>0&&n.set(Hl(i,o,this.nullBitmap),0),Object.assign(this,{nullBitmap:n,_nullCount:-1}));let h=n[B];e=(h&c)!==0,j?n[B]=h|c:n[B]=h&~c}return e!==!!j&&(this._nullCount=this.nullCount+(j?-1:1)),j}clone(A=this.type,j=this.offset,e=this.length,r=this._nullCount,n=this,i=this.children){return new t(A,j,e,r,n,i,this.dictionary)}slice(A,j){let{stride:e,typeId:r,children:n}=this,i=+(this._nullCount===0)-1,o=r===16?e:1,l=this._sliceBuffers(A,j,e,r);return this.clone(this.type,this.offset+A,j,i,l,n.length===0||this.valueOffsets?n:this._sliceChildren(n,o*A,o*j))}_changeLengthAndBackfillNullBitmap(A){if(this.typeId===Z.Null)return this.clone(this.type,0,A,0);let{length:j,nullCount:e}=this,r=new Uint8Array((A+63&-64)>>3).fill(255,0,j>>3);r[j>>3]=(1<0&&r.set(Hl(this.offset,j,this.nullBitmap),0);let n=this.buffers;return n[Wi.VALIDITY]=r,this.clone(this.type,0,A,e+(A-j),n)}_sliceBuffers(A,j,e,r){let n,{buffers:i}=this;return(n=i[Wi.TYPE])&&(i[Wi.TYPE]=n.subarray(A,A+j)),(n=i[Wi.OFFSET])&&(i[Wi.OFFSET]=n.subarray(A,A+j+1))||(n=i[Wi.DATA])&&(i[Wi.DATA]=r===6?n:n.subarray(e*A,e*(A+j))),i}_sliceChildren(A,j,e){return A.map(r=>r.slice(j,e))}};rj.prototype.children=Object.freeze([]);var pq=class t extends WA{visit(A){return this.getVisitFn(A.type).call(this,A)}visitNull(A){let{["type"]:j,["offset"]:e=0,["length"]:r=0}=A;return new rj(j,e,r,r)}visitBool(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length>>3,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitInt(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitFloat(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitUtf8(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=Rl(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitLargeUtf8(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=$g(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=Rl(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitLargeBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=$g(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitFixedSizeBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDate(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitTimestamp(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitTime(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDecimal(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitList(A){let{["type"]:j,["offset"]:e=0,["child"]:r}=A,n=it(A.nullBitmap),i=Rl(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,void 0,n],[r])}visitStruct(A){let{["type"]:j,["offset"]:e=0,["children"]:r=[]}=A,n=it(A.nullBitmap),{length:i=r.reduce((l,{length:c})=>Math.max(l,c),0),nullCount:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,void 0,n],r)}visitUnion(A){let{["type"]:j,["offset"]:e=0,["children"]:r=[]}=A,n=Mt(j.ArrayType,A.typeIds),{["length"]:i=n.length,["nullCount"]:o=-1}=A;if(HA.isSparseUnion(j))return new rj(j,e,i,o,[void 0,void 0,void 0,n],r);let l=Rl(A.valueOffsets);return new rj(j,e,i,o,[l,void 0,void 0,n],r)}visitDictionary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.indices.ArrayType,A.data),{["dictionary"]:i=new Dt([new t().visit({type:j.dictionary})])}=A,{["length"]:o=n.length,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[void 0,n,r],[],i)}visitInterval(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDuration(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitFixedSizeList(A){let{["type"]:j,["offset"]:e=0,["child"]:r=new t().visit({type:j.valueType})}=A,n=it(A.nullBitmap),{["length"]:i=r.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,void 0,n],[r])}visitMap(A){let{["type"]:j,["offset"]:e=0,["child"]:r=new t().visit({type:j.childType})}=A,n=it(A.nullBitmap),i=Rl(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,void 0,n],[r])}},KV=new pq;function ht(t){return KV.visit(t)}var Rh=class{constructor(A=0,j){this.numChunks=A,this.getChunkIterator=j,this.chunkIndex=0,this.chunkIterator=this.getChunkIterator(0)}next(){for(;this.chunkIndexA.nullable)}function nm(t){return t.reduce((A,j)=>A+j.nullCount,0)}function im(t){return t.reduce((A,j,e)=>(A[e+1]=A[e]+j.length,A),new Uint32Array(t.length+1))}function om(t,A,j,e){let r=[];for(let n=-1,i=t.length;++n=e)break;if(j>=l+c)continue;if(l>=j&&l+c<=e){r.push(o);continue}let B=Math.max(0,j-l),h=Math.min(e-l,c);r.push(o.slice(B,h-B))}return r.length===0&&r.push(t[0].slice(0,0)),r}function kq(t,A,j,e){let r=0,n=0,i=A.length-1;do{if(r>=i-1)return j0?0:-1}function zV(t,A){let{nullBitmap:j}=t;if(!j||t.nullCount<=0)return-1;let e=0;for(let r of new Cl(j,t.offset+(A||0),t.length,j,rm)){if(!r)return e;++e}return-1}function dt(t,A,j){if(A===void 0)return-1;if(A===null)switch(t.typeId){case Z.Union:break;case Z.Dictionary:break;default:return zV(t,j)}let e=He.getVisitFn(t),r=$7(A);for(let n=(j||0)-1,i=t.length;++n{let r=t.data[e];return r.values.subarray(0,r.length)[Symbol.iterator]()});let j=0;return new Rh(t.data.length,e=>{let n=t.data[e].length,i=t.slice(j,j+n);return j+=n,new gq(i)})}var gq=class{constructor(A){this.vector=A,this.index=0}next(){return this.indexo.data):A;if(n.length===0||n.some(o=>!(o instanceof rj)))throw new TypeError("Vector constructor expects an Array of Data instances.");let i=(j=n[0])===null||j===void 0?void 0:j.type;switch(n.length){case 0:this._offsets=[0];break;case 1:{let{get:o,set:l,indexOf:c}=SM[i.typeId],B=n[0];this.isValid=h=>Lh(B,h),this.get=h=>o(B,h),this.set=(h,d)=>l(B,h,d),this.indexOf=h=>c(B,h),this._offsets=[0,B.length];break}default:Object.setPrototypeOf(this,RM[i.typeId]),this._offsets=im(n);break}this.data=n,this.type=i,this.stride=U6(i),this.numChildren=(r=(e=i.children)===null||e===void 0?void 0:e.length)!==null&&r!==void 0?r:0,this.length=this._offsets.at(-1)}get byteLength(){return this.data.reduce((A,j)=>A+j.byteLength,0)}get nullable(){return MM(this.data)}get nullCount(){return nm(this.data)}get ArrayType(){return this.type.ArrayType}get[Symbol.toStringTag](){return`${this.VectorName}<${this.type[Symbol.toStringTag]}>`}get VectorName(){return`${Z[this.type.typeId]}Vector`}isValid(A){return!1}get(A){return null}set(A,j){}indexOf(A,j){return-1}includes(A,j){return this.indexOf(A,j)>-1}[Symbol.iterator](){return Mu.visit(this)}concat(...A){return new t(this.data.concat(A.flatMap(j=>j.data).flat(Number.POSITIVE_INFINITY)))}slice(A,j){return new t(Th(this,A,j,({data:e,_offsets:r},n,i)=>om(e,r,n,i)))}toJSON(){return[...this]}toArray(){let{type:A,data:j,length:e,stride:r,ArrayType:n}=this;switch(A.typeId){case Z.Int:case Z.Float:case Z.Decimal:case Z.Time:case Z.Timestamp:switch(j.length){case 0:return new n;case 1:return j[0].values.subarray(0,e*r);default:return j.reduce((i,{values:o,length:l})=>(i.array.set(o.subarray(0,l*r),i.offset),i.offset+=l*r,i),{array:new n(e*r),offset:0}).array}}return[...this]}toString(){return`[${[...this].join(",")}]`}getChild(A){var j;return this.getChildAt((j=this.type.children)===null||j===void 0?void 0:j.findIndex(e=>e.name===A))}getChildAt(A){return A>-1&&Aj[A])):null}get isMemoized(){return HA.isDictionary(this.type)?this.data[0].dictionary.isMemoized:!1}memoize(){if(HA.isDictionary(this.type)){let A=new lm(this.data[0].dictionary),j=this.data.map(e=>{let r=e.clone();return r.dictionary=A,r});return new t(j)}return new lm(this)}unmemoize(){if(HA.isDictionary(this.type)&&this.isMemoized){let A=this.data[0].dictionary.unmemoize(),j=this.data.map(e=>{let r=e.clone();return r.dictionary=A,r});return new t(j)}return this}};TM=Symbol.toStringTag;Dt[TM]=(t=>{t.type=HA.prototype,t.data=[],t.length=0,t.stride=1,t.numChildren=0,t._offsets=new Uint32Array([0]),t[Symbol.isConcatSpreadable]=!0;let A=Object.keys(Z).map(j=>Z[j]).filter(j=>typeof j=="number"&&j!==Z.NONE);for(let j of A){let e=He.getVisitFnByTypeId(j),r=Or.getVisitFnByTypeId(j),n=Nl.getVisitFnByTypeId(j);SM[j]={get:e,set:r,indexOf:n},RM[j]=Object.create(t,{isValid:{value:Iu(Lh)},get:{value:Iu(He.getVisitFnByTypeId(j))},set:{value:sm(Or.getVisitFnByTypeId(j))},indexOf:{value:am(Nl.getVisitFnByTypeId(j))}})}return"Vector"})(Dt.prototype);var lm=class t extends Dt{constructor(A){super(A.data);let j=this.get,e=this.set,r=this.slice,n=new Array(this.length);Object.defineProperty(this,"get",{value(i){let o=n[i];if(o!==void 0)return o;let l=j.call(this,i);return n[i]=l,l}}),Object.defineProperty(this,"set",{value(i,o){e.call(this,i,o),n[i]=o}}),Object.defineProperty(this,"slice",{value:(i,o)=>new t(r.call(this,i,o))}),Object.defineProperty(this,"isMemoized",{value:!0}),Object.defineProperty(this,"unmemoize",{value:()=>new Dt(this.data)}),Object.defineProperty(this,"memoize",{value:()=>this})}};function LM(t){if(!t||t.length<=0)return function(r){return!0};let A="",j=t.filter(e=>e===e);return j.length>0&&(A=` +`)}return s.toString()},Qe.prototype.computeEdgeEndLabels=function(s){for(var a=this.iterator();a.hasNext();)a.next().computeLabel(s)},Qe.prototype.computeLabelling=function(s){this.computeEdgeEndLabels(s[0].getBoundaryNodeRule()),this.propagateSideLabels(0),this.propagateSideLabels(1);for(var a=[!1,!1],u=this.iterator();u.hasNext();)for(var f=u.next().getLabel(),p=0;p<2;p++)f.isLine(p)&&f.getLocation(p)===T.BOUNDARY&&(a[p]=!0);for(var $=this.iterator();$.hasNext();)for(var q=$.next(),M=q.getLabel(),H=0;H<2;H++)if(M.isAnyNull(H)){var W=T.NONE;if(a[H])W=T.EXTERIOR;else{var oA=q.getCoordinate();W=this.getLocation(H,oA,s)}M.setAllLocationsIfNull(H,W)}},Qe.prototype.getDegree=function(){return this._edgeMap.size()},Qe.prototype.insertEdgeEnd=function(s,a){this._edgeMap.put(s,a),this._edgeList=null},Qe.prototype.interfaces_=function(){return[]},Qe.prototype.getClass=function(){return Qe};var u9=function(s){function a(){s.call(this),this._resultAreaEdgeList=null,this._label=null,this._SCANNING_FOR_INCOMING=1,this._LINKING_TO_OUTGOING=2}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.linkResultDirectedEdges=function(){this.getResultAreaEdges();for(var u=null,f=null,p=this._SCANNING_FOR_INCOMING,$=0;$=0;p--){var $=this._edgeList.get(p),q=$.getSym();f===null&&(f=q),u!==null&&q.setNext(u),u=$}f.setNext(u)},a.prototype.computeDepths=function(){if(arguments.length===1){var u=arguments[0],f=this.findIndex(u),p=u.getDepth(D.LEFT),$=u.getDepth(D.RIGHT),q=this.computeDepths(f+1,this._edgeList.size(),p);if(this.computeDepths(0,f,q)!==$)throw new bA("depth mismatch at "+u.getCoordinate())}else if(arguments.length===3){for(var M=arguments[0],H=arguments[1],W=arguments[2],oA=M;oA=0;q--){var M=this._resultAreaEdgeList.get(q),H=M.getSym();switch(f===null&&M.getEdgeRing()===u&&(f=M),$){case this._SCANNING_FOR_INCOMING:if(H.getEdgeRing()!==u)continue;p=H,$=this._LINKING_TO_OUTGOING;break;case this._LINKING_TO_OUTGOING:if(M.getEdgeRing()!==u)continue;p.setNextMin(M),$=this._SCANNING_FOR_INCOMING}}$===this._LINKING_TO_OUTGOING&&(KA.isTrue(f!==null,"found null for first outgoing dirEdge"),KA.isTrue(f.getEdgeRing()===u,"unable to link last incoming dirEdge"),p.setNextMin(f))},a.prototype.getOutgoingDegree=function(){if(arguments.length===0){for(var u=0,f=this.iterator();f.hasNext();)f.next().isInResult()&&u++;return u}if(arguments.length===1){for(var p=arguments[0],$=0,q=this.iterator();q.hasNext();)q.next().getEdgeRing()===p&&$++;return $}},a.prototype.getLabel=function(){return this._label},a.prototype.findCoveredLineEdges=function(){for(var u=T.NONE,f=this.iterator();f.hasNext();){var p=f.next(),$=p.getSym();if(!p.isLineEdge()){if(p.isInResult()){u=T.INTERIOR;break}if($.isInResult()){u=T.EXTERIOR;break}}}if(u===T.NONE)return null;for(var q=u,M=this.iterator();M.hasNext();){var H=M.next(),W=H.getSym();H.isLineEdge()?H.getEdge().setCovered(q===T.INTERIOR):(H.isInResult()&&(q=T.EXTERIOR),W.isInResult()&&(q=T.INTERIOR))}},a.prototype.computeLabelling=function(u){s.prototype.computeLabelling.call(this,u),this._label=new rt(T.NONE);for(var f=this.iterator();f.hasNext();)for(var p=f.next().getEdge().getLabel(),$=0;$<2;$++){var q=p.getLocation($);q!==T.INTERIOR&&q!==T.BOUNDARY||this._label.setLocation($,T.INTERIOR)}},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Qe),B8=function(s){function a(){s.apply(this,arguments)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.createNode=function(u){return new fg(u,new u9)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(cu),Cs=function s(){this._pts=null,this._orientation=null;var a=arguments[0];this._pts=a,this._orientation=s.orientation(a)};Cs.prototype.compareTo=function(s){var a=s;return Cs.compareOriented(this._pts,this._orientation,a._pts,a._orientation)},Cs.prototype.interfaces_=function(){return[w]},Cs.prototype.getClass=function(){return Cs},Cs.orientation=function(s){return BA.increasingDirection(s)===1},Cs.compareOriented=function(s,a,u,f){for(var p=a?1:-1,$=f?1:-1,q=a?s.length:-1,M=f?u.length:-1,H=a?0:s.length-1,W=f?0:u.length-1;;){var oA=s[H].compareTo(u[W]);if(oA!==0)return oA;var cA=(H+=p)===q,yA=(W+=$)===M;if(cA&&!yA)return-1;if(!cA&&yA)return 1;if(cA&&yA)return 0}};var S6=function(){this._edges=new nA,this._ocaMap=new h};S6.prototype.print=function(s){s.print("MULTILINESTRING ( ");for(var a=0;a0&&s.print(","),s.print("(");for(var f=u.getCoordinates(),p=0;p0&&s.print(","),s.print(f[p].x+" "+f[p].y);s.println(")")}s.print(") ")},S6.prototype.addAll=function(s){for(var a=s.iterator();a.hasNext();)this.add(a.next())},S6.prototype.findEdgeIndex=function(s){for(var a=0;a0||!a.coord.equals2D(f);p||u--;var $=new Array(u).fill(null),q=0;$[q++]=new F(s.coord);for(var M=s.segmentIndex+1;M<=a.segmentIndex;M++)$[q++]=this.edge.pts[M];return p&&($[q]=a.coord),new dg($,new rt(this.edge._label))},Si.prototype.add=function(s,a,u){var f=new si(s,a,u),p=this._nodeMap.get(f);return p!==null?p:(this._nodeMap.put(f,f),f)},Si.prototype.isIntersection=function(s){for(var a=this.iterator();a.hasNext();)if(a.next().coord.equals(s))return!0;return!1},Si.prototype.interfaces_=function(){return[]},Si.prototype.getClass=function(){return Si};var i7=function(){};i7.prototype.getChainStartIndices=function(s){var a=0,u=new nA;u.add(new $A(a));do{var f=this.findChainEnd(s,a);u.add(new $A(f)),a=f}while(au?a:u},Ro.prototype.getMinX=function(s){var a=this.pts[this.startIndex[s]].x,u=this.pts[this.startIndex[s+1]].x;return aa&&(f=1),this._depth[s][u]=f}}},Me.prototype.getDelta=function(s){return this._depth[s][D.RIGHT]-this._depth[s][D.LEFT]},Me.prototype.getLocation=function(s,a){return this._depth[s][a]<=0?T.EXTERIOR:T.INTERIOR},Me.prototype.toString=function(){return"A: "+this._depth[0][1]+","+this._depth[0][2]+" B: "+this._depth[1][1]+","+this._depth[1][2]},Me.prototype.add=function(){if(arguments.length===1)for(var s=arguments[0],a=0;a<2;a++)for(var u=1;u<3;u++){var f=s.getLocation(a,u);f!==T.EXTERIOR&&f!==T.INTERIOR||(this.isNull(a,u)?this._depth[a][u]=Me.depthAtLocation(f):this._depth[a][u]+=Me.depthAtLocation(f))}else if(arguments.length===3){var p=arguments[0],$=arguments[1];arguments[2]===T.INTERIOR&&this._depth[p][$]++}},Me.prototype.interfaces_=function(){return[]},Me.prototype.getClass=function(){return Me},Me.depthAtLocation=function(s){return s===T.EXTERIOR?0:s===T.INTERIOR?1:Me.NULL_VALUE},f8.NULL_VALUE.get=function(){return-1},Object.defineProperties(Me,f8);var dg=function(s){function a(){if(s.call(this),this.pts=null,this._env=null,this.eiList=new Si(this),this._name=null,this._mce=null,this._isIsolated=!0,this._depth=new Me,this._depthDelta=0,arguments.length===1){var u=arguments[0];a.call(this,u,null)}else if(arguments.length===2){var f=arguments[0],p=arguments[1];this.pts=f,this._label=p}}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.getDepth=function(){return this._depth},a.prototype.getCollapsedEdge=function(){var u=new Array(2).fill(null);return u[0]=this.pts[0],u[1]=this.pts[1],new a(u,rt.toLineLabel(this._label))},a.prototype.isIsolated=function(){return this._isIsolated},a.prototype.getCoordinates=function(){return this.pts},a.prototype.setIsolated=function(u){this._isIsolated=u},a.prototype.setName=function(u){this._name=u},a.prototype.equals=function(u){if(!(u instanceof a))return!1;var f=u;if(this.pts.length!==f.pts.length)return!1;for(var p=!0,$=!0,q=this.pts.length,M=0;M0?this.pts[0]:null;if(arguments.length===1){var u=arguments[0];return this.pts[u]}},a.prototype.print=function(u){u.print("edge "+this._name+": "),u.print("LINESTRING (");for(var f=0;f0&&u.print(","),u.print(this.pts[f].x+" "+this.pts[f].y);u.print(") "+this._label+" "+this._depthDelta)},a.prototype.computeIM=function(u){a.updateIM(this._label,u)},a.prototype.isCollapsed=function(){return!!this._label.isArea()&&this.pts.length===3&&!!this.pts[0].equals(this.pts[2])},a.prototype.isClosed=function(){return this.pts[0].equals(this.pts[this.pts.length-1])},a.prototype.getMaximumSegmentIndex=function(){return this.pts.length-1},a.prototype.getDepthDelta=function(){return this._depthDelta},a.prototype.getNumPoints=function(){return this.pts.length},a.prototype.printReverse=function(u){u.print("edge "+this._name+": ");for(var f=this.pts.length-1;f>=0;f--)u.print(this.pts[f]+" ");u.println("")},a.prototype.getMonotoneChainEdge=function(){return this._mce===null&&(this._mce=new Ro(this)),this._mce},a.prototype.getEnvelope=function(){if(this._env===null){this._env=new GA;for(var u=0;u0&&u.append(","),u.append(this.pts[f].x+" "+this.pts[f].y);return u.append(") "+this._label+" "+this._depthDelta),u.toString()},a.prototype.isPointwiseEqual=function(u){if(this.pts.length!==u.pts.length)return!1;for(var f=0;ff||this._maxy$;if(q)return!1;var M=this.intersectsToleranceSquare(s,a);return KA.isTrue(!(q&&M),"Found bad envelope test"),M},Pr.prototype.initCorners=function(s){this._minx=s.x-.5,this._maxx=s.x+.5,this._miny=s.y-.5,this._maxy=s.y+.5,this._corner[0]=new F(this._maxx,this._maxy),this._corner[1]=new F(this._minx,this._maxy),this._corner[2]=new F(this._minx,this._miny),this._corner[3]=new F(this._maxx,this._miny)},Pr.prototype.intersects=function(s,a){return this._scaleFactor===1?this.intersectsScaled(s,a):(this.copyScaled(s,this._p0Scaled),this.copyScaled(a,this._p1Scaled),this.intersectsScaled(this._p0Scaled,this._p1Scaled))},Pr.prototype.scale=function(s){return Math.round(s*this._scaleFactor)},Pr.prototype.getCoordinate=function(){return this._originalPt},Pr.prototype.copyScaled=function(s,a){a.x=this.scale(s.x),a.y=this.scale(s.y)},Pr.prototype.getSafeEnvelope=function(){if(this._safeEnv===null){var s=Pr.SAFE_ENV_EXPANSION_FACTOR/this._scaleFactor;this._safeEnv=new GA(this._originalPt.x-s,this._originalPt.x+s,this._originalPt.y-s,this._originalPt.y+s)}return this._safeEnv},Pr.prototype.intersectsPixelClosure=function(s,a){return this._li.computeIntersection(s,a,this._corner[0],this._corner[1]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[1],this._corner[2]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[2],this._corner[3]),!!this._li.hasIntersection()||(this._li.computeIntersection(s,a,this._corner[3],this._corner[0]),!!this._li.hasIntersection())))},Pr.prototype.intersectsToleranceSquare=function(s,a){var u=!1,f=!1;return this._li.computeIntersection(s,a,this._corner[0],this._corner[1]),!!this._li.isProper()||(this._li.computeIntersection(s,a,this._corner[1],this._corner[2]),!!this._li.isProper()||(this._li.hasIntersection()&&(u=!0),this._li.computeIntersection(s,a,this._corner[2],this._corner[3]),!!this._li.isProper()||(this._li.hasIntersection()&&(f=!0),this._li.computeIntersection(s,a,this._corner[3],this._corner[0]),!!this._li.isProper()||!(!u||!f)||!!s.equals(this._pt)||!!a.equals(this._pt))))},Pr.prototype.addSnappedNode=function(s,a){var u=s.getCoordinate(a),f=s.getCoordinate(a+1);return!!this.intersects(u,f)&&(s.addIntersection(this.getCoordinate(),a),!0)},Pr.prototype.interfaces_=function(){return[]},Pr.prototype.getClass=function(){return Pr},d8.SAFE_ENV_EXPANSION_FACTOR.get=function(){return .75},Object.defineProperties(Pr,d8);var Bh=function(){this.tempEnv1=new GA,this.selectedSegment=new CA};Bh.prototype.select=function(){if(arguments.length!==1){if(arguments.length===2){var s=arguments[0],a=arguments[1];s.getLineSegment(a,this.selectedSegment),this.select(this.selectedSegment)}}},Bh.prototype.interfaces_=function(){return[]},Bh.prototype.getClass=function(){return Bh};var hu=function(){this._index=null;var s=arguments[0];this._index=s},p8={HotPixelSnapAction:{configurable:!0}};hu.prototype.snap=function(){if(arguments.length===1){var s=arguments[0];return this.snap(s,null,-1)}if(arguments.length===3){var a=arguments[0],u=arguments[1],f=arguments[2],p=a.getSafeEnvelope(),$=new k8(a,u,f);return this._index.query(p,{interfaces_:function(){return[Rs]},visitItem:function(q){q.select(p,$)}}),$.isNodeAdded()}},hu.prototype.interfaces_=function(){return[]},hu.prototype.getClass=function(){return hu},p8.HotPixelSnapAction.get=function(){return k8},Object.defineProperties(hu,p8);var k8=function(s){function a(){s.call(this),this._hotPixel=null,this._parentEdge=null,this._hotPixelVertexIndex=null,this._isNodeAdded=!1;var u=arguments[0],f=arguments[1],p=arguments[2];this._hotPixel=u,this._parentEdge=f,this._hotPixelVertexIndex=p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.isNodeAdded=function(){return this._isNodeAdded},a.prototype.select=function(){if(arguments.length!==2)return s.prototype.select.apply(this,arguments);var u=arguments[0],f=arguments[1],p=u.getContext();if(this._parentEdge!==null&&p===this._parentEdge&&f===this._hotPixelVertexIndex)return null;this._isNodeAdded=this._hotPixel.addSnappedNode(p,f)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Bh),Fl=function(){this._li=null,this._interiorIntersections=null;var s=arguments[0];this._li=s,this._interiorIntersections=new nA};Fl.prototype.processIntersections=function(s,a,u,f){if(s===u&&a===f)return null;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];if(this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&this._li.isInteriorIntersection()){for(var H=0;H=0;a--){try{s.bufferReducedPrecision(a)}catch($){if(!($ instanceof bA))throw $;s._saveException=$}if(s._resultGeometry!==null)return null}throw this._saveException}if(arguments.length===1){var u=arguments[0],f=Oe.precisionScaleFactor(this._argGeom,this._distance,u),p=new Pt(f);this.bufferFixedPrecision(p)}},Oe.prototype.computeGeometry=function(){if(this.bufferOriginalPrecision(),this._resultGeometry!==null)return null;var s=this._argGeom.getFactory().getPrecisionModel();s.getType()===Pt.FIXED?this.bufferFixedPrecision(s):this.bufferReducedPrecision()},Oe.prototype.setQuadrantSegments=function(s){this._bufParams.setQuadrantSegments(s)},Oe.prototype.bufferOriginalPrecision=function(){try{var s=new sr(this._bufParams);this._resultGeometry=s.buffer(this._argGeom,this._distance)}catch(a){if(!(a instanceof ce))throw a;this._saveException=a}},Oe.prototype.getResultGeometry=function(s){return this._distance=s,this.computeGeometry(),this._resultGeometry},Oe.prototype.setEndCapStyle=function(s){this._bufParams.setEndCapStyle(s)},Oe.prototype.interfaces_=function(){return[]},Oe.prototype.getClass=function(){return Oe},Oe.bufferOp=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];return new Oe(s).getResultGeometry(a)}if(arguments.length===3){if(Number.isInteger(arguments[2])&&arguments[0]instanceof MA&&typeof arguments[1]=="number"){var u=arguments[0],f=arguments[1],p=arguments[2],$=new Oe(u);return $.setQuadrantSegments(p),$.getResultGeometry(f)}if(arguments[2]instanceof zt&&arguments[0]instanceof MA&&typeof arguments[1]=="number"){var q=arguments[0],M=arguments[1],H=arguments[2];return new Oe(q,H).getResultGeometry(M)}}else if(arguments.length===4){var W=arguments[0],oA=arguments[1],cA=arguments[2],yA=arguments[3],vA=new Oe(W);return vA.setQuadrantSegments(cA),vA.setEndCapStyle(yA),vA.getResultGeometry(oA)}},Oe.precisionScaleFactor=function(s,a,u){var f=s.getEnvelopeInternal(),p=jA.max(Math.abs(f.getMaxX()),Math.abs(f.getMaxY()),Math.abs(f.getMinX()),Math.abs(f.getMinY()))+2*(a>0?a:0),$=u-Math.trunc(Math.log(p)/Math.log(10)+1);return Math.pow(10,$)},du.CAP_ROUND.get=function(){return zt.CAP_ROUND},du.CAP_BUTT.get=function(){return zt.CAP_FLAT},du.CAP_FLAT.get=function(){return zt.CAP_FLAT},du.CAP_SQUARE.get=function(){return zt.CAP_SQUARE},du.MAX_PRECISION_DIGITS.get=function(){return 12},Object.defineProperties(Oe,du);var ar=function(){this._pt=[new F,new F],this._distance=v.NaN,this._isNull=!0};ar.prototype.getCoordinates=function(){return this._pt},ar.prototype.getCoordinate=function(s){return this._pt[s]},ar.prototype.setMinimum=function(){if(arguments.length===1){var s=arguments[0];this.setMinimum(s._pt[0],s._pt[1])}else if(arguments.length===2){var a=arguments[0],u=arguments[1];if(this._isNull)return this.initialize(a,u),null;var f=a.distance(u);fthis._distance&&this.initialize(a,u,f)}},ar.prototype.interfaces_=function(){return[]},ar.prototype.getClass=function(){return ar};var Li=function(){};Li.prototype.interfaces_=function(){return[]},Li.prototype.getClass=function(){return Li},Li.computeDistance=function(){if(arguments[2]instanceof ar&&arguments[0]instanceof Bj&&arguments[1]instanceof F)for(var s=arguments[0],a=arguments[1],u=arguments[2],f=s.getCoordinates(),p=new CA,$=0;$0||this._isIn?T.INTERIOR:T.EXTERIOR)},R6.prototype.interfaces_=function(){return[]},R6.prototype.getClass=function(){return R6};var lr=function s(){if(this._component=null,this._segIndex=null,this._pt=null,arguments.length===2){var a=arguments[0],u=arguments[1];s.call(this,a,s.INSIDE_AREA,u)}else if(arguments.length===3){var f=arguments[0],p=arguments[1],$=arguments[2];this._component=f,this._segIndex=p,this._pt=$}},g8={INSIDE_AREA:{configurable:!0}};lr.prototype.isInsideArea=function(){return this._segIndex===lr.INSIDE_AREA},lr.prototype.getCoordinate=function(){return this._pt},lr.prototype.getGeometryComponent=function(){return this._component},lr.prototype.getSegmentIndex=function(){return this._segIndex},lr.prototype.interfaces_=function(){return[]},lr.prototype.getClass=function(){return lr},g8.INSIDE_AREA.get=function(){return-1},Object.defineProperties(lr,g8);var Ns=function(s){this._pts=s||null};Ns.prototype.filter=function(s){s instanceof ir&&this._pts.add(s)},Ns.prototype.interfaces_=function(){return[qj]},Ns.prototype.getClass=function(){return Ns},Ns.getPoints=function(){if(arguments.length===1){var s=arguments[0];return s instanceof ir?T6.singletonList(s):Ns.getPoints(s,new nA)}if(arguments.length===2){var a=arguments[0],u=arguments[1];return a instanceof ir?u.add(a):a instanceof oj&&a.apply(new Ns(u)),u}};var Il=function(){this._locations=null;var s=arguments[0];this._locations=s};Il.prototype.filter=function(s){(s instanceof ir||s instanceof Bj||s instanceof Qt)&&this._locations.add(new lr(s,0,s.getCoordinate()))},Il.prototype.interfaces_=function(){return[qj]},Il.prototype.getClass=function(){return Il},Il.getLocations=function(s){var a=new nA;return s.apply(new Il(a)),a};var Se=function(){if(this._geom=null,this._terminateDistance=0,this._ptLocator=new R6,this._minDistanceLocation=null,this._minDistance=v.MAX_VALUE,arguments.length===2){var s=arguments[0],a=arguments[1];this._geom=[s,a],this._terminateDistance=0}else if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2];this._geom=new Array(2).fill(null),this._geom[0]=u,this._geom[1]=f,this._terminateDistance=p}};Se.prototype.computeContainmentDistance=function(){if(arguments.length===0){var s=new Array(2).fill(null);if(this.computeContainmentDistance(0,s),this._minDistance<=this._terminateDistance)return null;this.computeContainmentDistance(1,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=1-a,p=Lo.getPolygons(this._geom[a]);if(p.size()>0){var $=Il.getLocations(this._geom[f]);if(this.computeContainmentDistance($,p,u),this._minDistance<=this._terminateDistance)return this._minDistanceLocation[f]=u[0],this._minDistanceLocation[a]=u[1],null}}else if(arguments.length===3){if(arguments[2]instanceof Array&&b(arguments[0],uA)&&b(arguments[1],uA)){for(var q=arguments[0],M=arguments[1],H=arguments[2],W=0;Wthis._minDistance)return null;for(var f=s.getCoordinates(),p=a.getCoordinate(),$=0;$this._minDistance)return null;for(var cA=H.getCoordinates(),yA=W.getCoordinates(),vA=0;vAthis._distance&&this.initialize(a,u,f)}},We.prototype.interfaces_=function(){return[]},We.prototype.getClass=function(){return We};var li=function(){};li.prototype.interfaces_=function(){return[]},li.prototype.getClass=function(){return li},li.computeDistance=function(){if(arguments[2]instanceof We&&arguments[0]instanceof Bj&&arguments[1]instanceof F)for(var s=arguments[0],a=arguments[1],u=arguments[2],f=new CA,p=s.getCoordinates(),$=0;$1||s<=0)throw new G("Fraction is not in range (0.0 - 1.0]");this._densifyFrac=s},d6.prototype.compute=function(s,a){this.computeOrientedDistance(s,a,this._ptDist),this.computeOrientedDistance(a,s,this._ptDist)},d6.prototype.distance=function(){return this.compute(this._g0,this._g1),this._ptDist.getDistance()},d6.prototype.computeOrientedDistance=function(s,a,u){var f=new Ml(a);if(s.apply(f),u.setMaximum(f.getMaxPointDistance()),this._densifyFrac>0){var p=new Ks(a,this._densifyFrac);s.apply(p),u.setMaximum(p.getMaxPointDistance())}},d6.prototype.orientedDistance=function(){return this.computeOrientedDistance(this._g0,this._g1,this._ptDist),this._ptDist.getDistance()},d6.prototype.interfaces_=function(){return[]},d6.prototype.getClass=function(){return d6},d6.distance=function(){if(arguments.length===2){var s=arguments[0],a=arguments[1];return new d6(s,a).distance()}if(arguments.length===3){var u=arguments[0],f=arguments[1],p=arguments[2],$=new d6(u,f);return $.setDensifyFraction(p),$.distance()}},H_.MaxPointDistanceFilter.get=function(){return Ml},H_.MaxDensifiedByFractionDistanceFilter.get=function(){return Ks},Object.defineProperties(d6,H_);var Ml=function(){this._maxPtDist=new We,this._minPtDist=new We,this._euclideanDist=new li,this._geom=null;var s=arguments[0];this._geom=s};Ml.prototype.filter=function(s){this._minPtDist.initialize(),li.computeDistance(this._geom,s,this._minPtDist),this._maxPtDist.setMaximum(this._minPtDist)},Ml.prototype.getMaxPointDistance=function(){return this._maxPtDist},Ml.prototype.interfaces_=function(){return[J]},Ml.prototype.getClass=function(){return Ml};var Ks=function(){this._maxPtDist=new We,this._minPtDist=new We,this._geom=null,this._numSubSegs=0;var s=arguments[0],a=arguments[1];this._geom=s,this._numSubSegs=Math.trunc(Math.round(1/a))};Ks.prototype.filter=function(s,a){if(a===0)return null;for(var u=s.getCoordinate(a-1),f=s.getCoordinate(a),p=(f.x-u.x)/this._numSubSegs,$=(f.y-u.y)/this._numSubSegs,q=0;qu){this._isValid=!1;var p=f.getCoordinates();this._errorLocation=p[1],this._errorIndicator=s.getFactory().createLineString(p),this._errMsg="Distance between buffer curve and input is too large ("+this._maxDistanceFound+" at "+cj.toLineString(p[0],p[1])+")"}},An.prototype.isValid=function(){var s=Math.abs(this._bufDistance),a=An.MAX_DISTANCE_DIFF_FRAC*s;return this._minValidDistance=s-a,this._maxValidDistance=s+a,!(!this._input.isEmpty()&&!this._result.isEmpty())||(this._bufDistance>0?this.checkPositiveValid():this.checkNegativeValid(),An.VERBOSE&&qA.out.println("Min Dist= "+this._minDistanceFound+" err= "+(1-this._minDistanceFound/this._bufDistance)+" Max Dist= "+this._maxDistanceFound+" err= "+(this._maxDistanceFound/this._bufDistance-1)),this._isValid)},An.prototype.checkNegativeValid=function(){if(!(this._input instanceof Qt||this._input instanceof xe||this._input instanceof oj))return null;var s=this.getPolygonLines(this._input);if(this.checkMinimumDistance(s,this._result,this._minValidDistance),!this._isValid)return null;this.checkMaximumDistance(s,this._result,this._maxValidDistance)},An.prototype.getErrorIndicator=function(){return this._errorIndicator},An.prototype.checkMinimumDistance=function(s,a,u){var f=new Se(s,a,u);if(this._minDistanceFound=f.distance(),this._minDistanceFound0&&s>a&&(this._isValid=!1,this._errorMsg="Area of positive buffer is smaller than input",this._errorIndicator=this._result),this._distance<0&&s=2||this._distance>0?null:(this._result.isEmpty()||(this._isValid=!1,this._errorMsg="Result is non-empty",this._errorIndicator=this._result),void this.report("ExpectedEmpty"))},Re.prototype.report=function(s){if(!Re.VERBOSE)return null;qA.out.println("Check "+s+": "+(this._isValid?"passed":"FAILED"))},Re.prototype.getErrorMessage=function(){return this._errorMsg},Re.prototype.interfaces_=function(){return[]},Re.prototype.getClass=function(){return Re},Re.isValidMsg=function(s,a,u){var f=new Re(s,a,u);return f.isValid()?null:f.getErrorMessage()},Re.isValid=function(s,a,u){return!!new Re(s,a,u).isValid()},N_.VERBOSE.get=function(){return!1},N_.MAX_ENV_DIFF_FRAC.get=function(){return .012},Object.defineProperties(Re,N_);var ci=function(){this._pts=null,this._data=null;var s=arguments[0],a=arguments[1];this._pts=s,this._data=a};ci.prototype.getCoordinates=function(){return this._pts},ci.prototype.size=function(){return this._pts.length},ci.prototype.getCoordinate=function(s){return this._pts[s]},ci.prototype.isClosed=function(){return this._pts[0].equals(this._pts[this._pts.length-1])},ci.prototype.getSegmentOctant=function(s){return s===this._pts.length-1?-1:bl.octant(this.getCoordinate(s),this.getCoordinate(s+1))},ci.prototype.setData=function(s){this._data=s},ci.prototype.getData=function(){return this._data},ci.prototype.toString=function(){return cj.toLineString(new fj(this._pts))},ci.prototype.interfaces_=function(){return[Oi]},ci.prototype.getClass=function(){return ci};var ve=function(){this._findAllIntersections=!1,this._isCheckEndSegmentsOnly=!1,this._li=null,this._interiorIntersection=null,this._intSegments=null,this._intersections=new nA,this._intersectionCount=0,this._keepIntersections=!0;var s=arguments[0];this._li=s,this._interiorIntersection=null};ve.prototype.getInteriorIntersection=function(){return this._interiorIntersection},ve.prototype.setCheckEndSegmentsOnly=function(s){this._isCheckEndSegmentsOnly=s},ve.prototype.getIntersectionSegments=function(){return this._intSegments},ve.prototype.count=function(){return this._intersectionCount},ve.prototype.getIntersections=function(){return this._intersections},ve.prototype.setFindAllIntersections=function(s){this._findAllIntersections=s},ve.prototype.setKeepIntersections=function(s){this._keepIntersections=s},ve.prototype.processIntersections=function(s,a,u,f){if(!this._findAllIntersections&&this.hasIntersection()||s===u&&a===f||this._isCheckEndSegmentsOnly&&!(this.isEndSegment(s,a)||this.isEndSegment(u,f)))return null;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&this._li.isInteriorIntersection()&&(this._intSegments=new Array(4).fill(null),this._intSegments[0]=p,this._intSegments[1]=$,this._intSegments[2]=q,this._intSegments[3]=M,this._interiorIntersection=this._li.getIntersection(0),this._keepIntersections&&this._intersections.add(this._interiorIntersection),this._intersectionCount++)},ve.prototype.isEndSegment=function(s,a){return a===0||a>=s.size()-2},ve.prototype.hasIntersection=function(){return this._interiorIntersection!==null},ve.prototype.isDone=function(){return!this._findAllIntersections&&this._interiorIntersection!==null},ve.prototype.interfaces_=function(){return[n7]},ve.prototype.getClass=function(){return ve},ve.createAllIntersectionsFinder=function(s){var a=new ve(s);return a.setFindAllIntersections(!0),a},ve.createAnyIntersectionFinder=function(s){return new ve(s)},ve.createIntersectionCounter=function(s){var a=new ve(s);return a.setFindAllIntersections(!0),a.setKeepIntersections(!1),a};var L6=function(){this._li=new PA,this._segStrings=null,this._findAllIntersections=!1,this._segInt=null,this._isValid=!0;var s=arguments[0];this._segStrings=s};L6.prototype.execute=function(){if(this._segInt!==null)return null;this.checkInteriorIntersections()},L6.prototype.getIntersections=function(){return this._segInt.getIntersections()},L6.prototype.isValid=function(){return this.execute(),this._isValid},L6.prototype.setFindAllIntersections=function(s){this._findAllIntersections=s},L6.prototype.checkInteriorIntersections=function(){this._isValid=!0,this._segInt=new ve(this._li),this._segInt.setFindAllIntersections(this._findAllIntersections);var s=new L_;if(s.setSegmentIntersector(this._segInt),s.computeNodes(this._segStrings),this._segInt.hasIntersection())return this._isValid=!1,null},L6.prototype.checkValid=function(){if(this.execute(),!this._isValid)throw new bA(this.getErrorMessage(),this._segInt.getInteriorIntersection())},L6.prototype.getErrorMessage=function(){if(this._isValid)return"no intersections found";var s=this._segInt.getIntersectionSegments();return"found non-noded intersection between "+cj.toLineString(s[0],s[1])+" and "+cj.toLineString(s[2],s[3])},L6.prototype.interfaces_=function(){return[]},L6.prototype.getClass=function(){return L6},L6.computeIntersections=function(s){var a=new L6(s);return a.setFindAllIntersections(!0),a.isValid(),a.getIntersections()};var s7=function s(){this._nv=null;var a=arguments[0];this._nv=new L6(s.toSegmentStrings(a))};s7.prototype.checkValid=function(){this._nv.checkValid()},s7.prototype.interfaces_=function(){return[]},s7.prototype.getClass=function(){return s7},s7.toSegmentStrings=function(s){for(var a=new nA,u=s.iterator();u.hasNext();){var f=u.next();a.add(new ci(f.getCoordinates(),f))}return a},s7.checkValid=function(s){new s7(s).checkValid()};var Ol=function(s){this._mapOp=s};Ol.prototype.map=function(s){for(var a=new nA,u=0;u0&&f<4&&!this._preserveType?this._factory.createLineString(u):this._factory.createLinearRing(u)},Ir.prototype.interfaces_=function(){return[]},Ir.prototype.getClass=function(){return Ir};var Ci=function s(){if(this._snapTolerance=0,this._srcPts=null,this._seg=new CA,this._allowSnappingToSourceVertices=!1,this._isClosed=!1,arguments[0]instanceof Bj&&typeof arguments[1]=="number"){var a=arguments[0],u=arguments[1];s.call(this,a.getCoordinates(),u)}else if(arguments[0]instanceof Array&&typeof arguments[1]=="number"){var f=arguments[0],p=arguments[1];this._srcPts=f,this._isClosed=s.isClosed(f),this._snapTolerance=p}};Ci.prototype.snapVertices=function(s,a){for(var u=this._isClosed?s.size()-1:s.size(),f=0;f=0&&s.add($+1,new F(p),!1)}},Ci.prototype.findSegmentIndexToSnap=function(s,a){for(var u=v.MAX_VALUE,f=-1,p=0;pa&&(a=f)}return a}if(arguments.length===2){var p=arguments[0],$=arguments[1];return Math.min(Dj.computeOverlaySnapTolerance(p),Dj.computeOverlaySnapTolerance($))}},Dj.computeSizeBasedSnapTolerance=function(s){var a=s.getEnvelopeInternal();return Math.min(a.getHeight(),a.getWidth())*Dj.SNAP_PRECISION_FACTOR},Dj.snapToSelf=function(s,a,u){return new Dj(s).snapToSelf(a,u)},m8.SNAP_PRECISION_FACTOR.get=function(){return 1e-9},Object.defineProperties(Dj,m8);var E8=function(s){function a(u,f,p){s.call(this),this._snapTolerance=u||null,this._snapPts=f||null,this._isSelfSnap=p!==void 0&&p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.snapLine=function(u,f){var p=new Ci(u,this._snapTolerance);return p.setAllowSnappingToSourceVertices(this._isSelfSnap),p.snapTo(f)},a.prototype.transformCoordinates=function(u,f){var p=u.toCoordinateArray(),$=this.snapLine(p,this._snapPts);return this._factory.getCoordinateSequenceFactory().create($)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Ir),cr=function(){this._isFirst=!0,this._commonMantissaBitsCount=53,this._commonBits=0,this._commonSignExp=null};cr.prototype.getCommon=function(){return v.longBitsToDouble(this._commonBits)},cr.prototype.add=function(s){var a=v.doubleToLongBits(s);if(this._isFirst)return this._commonBits=a,this._commonSignExp=cr.signExpBits(this._commonBits),this._isFirst=!1,null;if(cr.signExpBits(a)!==this._commonSignExp)return this._commonBits=0,null;this._commonMantissaBitsCount=cr.numCommonMostSigMantissaBits(this._commonBits,a),this._commonBits=cr.zeroLowerBits(this._commonBits,64-(12+this._commonMantissaBitsCount))},cr.prototype.toString=function(){if(arguments.length===1){var s=arguments[0],a=v.longBitsToDouble(s),u="0000000000000000000000000000000000000000000000000000000000000000"+v.toBinaryString(s),f=u.substring(u.length-64);return f.substring(0,1)+" "+f.substring(1,12)+"(exp) "+f.substring(12)+" [ "+a+" ]"}},cr.prototype.interfaces_=function(){return[]},cr.prototype.getClass=function(){return cr},cr.getBit=function(s,a){return s&1<>52},cr.zeroLowerBits=function(s,a){return s&~((1<=0;f--){if(cr.getBit(s,f)!==cr.getBit(a,f))return u;u++}return 52};var Xs=function(){this._commonCoord=null,this._ccFilter=new Sl},K_={CommonCoordinateFilter:{configurable:!0},Translater:{configurable:!0}};Xs.prototype.addCommonBits=function(s){var a=new zs(this._commonCoord);s.apply(a),s.geometryChanged()},Xs.prototype.removeCommonBits=function(s){if(this._commonCoord.x===0&&this._commonCoord.y===0)return s;var a=new F(this._commonCoord);a.x=-a.x,a.y=-a.y;var u=new zs(a);return s.apply(u),s.geometryChanged(),s},Xs.prototype.getCommonCoordinate=function(){return this._commonCoord},Xs.prototype.add=function(s){s.apply(this._ccFilter),this._commonCoord=this._ccFilter.getCommonCoordinate()},Xs.prototype.interfaces_=function(){return[]},Xs.prototype.getClass=function(){return Xs},K_.CommonCoordinateFilter.get=function(){return Sl},K_.Translater.get=function(){return zs},Object.defineProperties(Xs,K_);var Sl=function(){this._commonBitsX=new cr,this._commonBitsY=new cr};Sl.prototype.filter=function(s){this._commonBitsX.add(s.x),this._commonBitsY.add(s.y)},Sl.prototype.getCommonCoordinate=function(){return new F(this._commonBitsX.getCommon(),this._commonBitsY.getCommon())},Sl.prototype.interfaces_=function(){return[J]},Sl.prototype.getClass=function(){return Sl};var zs=function(){this.trans=null;var s=arguments[0];this.trans=s};zs.prototype.filter=function(s,a){var u=s.getOrdinate(a,0)+this.trans.x,f=s.getOrdinate(a,1)+this.trans.y;s.setOrdinate(a,0,u),s.setOrdinate(a,1,f)},zs.prototype.isDone=function(){return!1},zs.prototype.isGeometryChanged=function(){return!0},zs.prototype.interfaces_=function(){return[gj]},zs.prototype.getClass=function(){return zs};var _e=function(s,a){this._geom=new Array(2).fill(null),this._snapTolerance=null,this._cbr=null,this._geom[0]=s,this._geom[1]=a,this.computeSnapTolerance()};_e.prototype.selfSnap=function(s){return new Dj(s).snapTo(s,this._snapTolerance)},_e.prototype.removeCommonBits=function(s){this._cbr=new Xs,this._cbr.add(s[0]),this._cbr.add(s[1]);var a=new Array(2).fill(null);return a[0]=this._cbr.removeCommonBits(s[0].copy()),a[1]=this._cbr.removeCommonBits(s[1].copy()),a},_e.prototype.prepareResult=function(s){return this._cbr.addCommonBits(s),s},_e.prototype.getResultGeometry=function(s){var a=this.snap(this._geom),u=nt.overlayOp(a[0],a[1],s);return this.prepareResult(u)},_e.prototype.checkValid=function(s){s.isValid()||qA.out.println("Snapped geometry is invalid")},_e.prototype.computeSnapTolerance=function(){this._snapTolerance=Dj.computeOverlaySnapTolerance(this._geom[0],this._geom[1])},_e.prototype.snap=function(s){var a=this.removeCommonBits(s);return Dj.snap(a[0],a[1],this._snapTolerance)},_e.prototype.interfaces_=function(){return[]},_e.prototype.getClass=function(){return _e},_e.overlayOp=function(s,a,u){return new _e(s,a).getResultGeometry(u)},_e.union=function(s,a){return _e.overlayOp(s,a,nt.UNION)},_e.intersection=function(s,a){return _e.overlayOp(s,a,nt.INTERSECTION)},_e.symDifference=function(s,a){return _e.overlayOp(s,a,nt.SYMDIFFERENCE)},_e.difference=function(s,a){return _e.overlayOp(s,a,nt.DIFFERENCE)};var ur=function(s,a){this._geom=new Array(2).fill(null),this._geom[0]=s,this._geom[1]=a};ur.prototype.getResultGeometry=function(s){var a=null,u=!1,f=null;try{a=nt.overlayOp(this._geom[0],this._geom[1],s),u=!0}catch(p){if(!(p instanceof ce))throw p;f=p}if(!u)try{a=_e.overlayOp(this._geom[0],this._geom[1],s)}catch(p){throw p instanceof ce?f:p}return a},ur.prototype.interfaces_=function(){return[]},ur.prototype.getClass=function(){return ur},ur.overlayOp=function(s,a,u){return new ur(s,a).getResultGeometry(u)},ur.union=function(s,a){return ur.overlayOp(s,a,nt.UNION)},ur.intersection=function(s,a){return ur.overlayOp(s,a,nt.INTERSECTION)},ur.symDifference=function(s,a){return ur.overlayOp(s,a,nt.SYMDIFFERENCE)},ur.difference=function(s,a){return ur.overlayOp(s,a,nt.DIFFERENCE)};var fh=function(){this.mce=null,this.chainIndex=null;var s=arguments[0],a=arguments[1];this.mce=s,this.chainIndex=a};fh.prototype.computeIntersections=function(s,a){this.mce.computeIntersectsForChain(this.chainIndex,s.mce,s.chainIndex,a)},fh.prototype.interfaces_=function(){return[]},fh.prototype.getClass=function(){return fh};var tn=function s(){if(this._label=null,this._xValue=null,this._eventType=null,this._insertEvent=null,this._deleteEventIndex=null,this._obj=null,arguments.length===2){var a=arguments[0],u=arguments[1];this._eventType=s.DELETE,this._xValue=a,this._insertEvent=u}else if(arguments.length===3){var f=arguments[0],p=arguments[1],$=arguments[2];this._eventType=s.INSERT,this._label=f,this._xValue=p,this._obj=$}},X_={INSERT:{configurable:!0},DELETE:{configurable:!0}};tn.prototype.isDelete=function(){return this._eventType===tn.DELETE},tn.prototype.setDeleteEventIndex=function(s){this._deleteEventIndex=s},tn.prototype.getObject=function(){return this._obj},tn.prototype.compareTo=function(s){var a=s;return this._xValuea._xValue?1:this._eventTypea._eventType?1:0},tn.prototype.getInsertEvent=function(){return this._insertEvent},tn.prototype.isInsert=function(){return this._eventType===tn.INSERT},tn.prototype.isSameLabel=function(s){return this._label!==null&&this._label===s._label},tn.prototype.getDeleteEventIndex=function(){return this._deleteEventIndex},tn.prototype.interfaces_=function(){return[w]},tn.prototype.getClass=function(){return tn},X_.INSERT.get=function(){return 1},X_.DELETE.get=function(){return 2},Object.defineProperties(tn,X_);var pg=function(){};pg.prototype.interfaces_=function(){return[]},pg.prototype.getClass=function(){return pg};var Le=function(){this._hasIntersection=!1,this._hasProper=!1,this._hasProperInterior=!1,this._properIntersectionPoint=null,this._li=null,this._includeProper=null,this._recordIsolated=null,this._isSelfIntersection=null,this._numIntersections=0,this.numTests=0,this._bdyNodes=null,this._isDone=!1,this._isDoneWhenProperInt=!1;var s=arguments[0],a=arguments[1],u=arguments[2];this._li=s,this._includeProper=a,this._recordIsolated=u};Le.prototype.isTrivialIntersection=function(s,a,u,f){if(s===u&&this._li.getIntersectionNum()===1){if(Le.isAdjacentSegments(a,f))return!0;if(s.isClosed()){var p=s.getNumPoints()-1;if(a===0&&f===p||f===0&&a===p)return!0}}return!1},Le.prototype.getProperIntersectionPoint=function(){return this._properIntersectionPoint},Le.prototype.setIsDoneIfProperInt=function(s){this._isDoneWhenProperInt=s},Le.prototype.hasProperInteriorIntersection=function(){return this._hasProperInterior},Le.prototype.isBoundaryPointInternal=function(s,a){for(var u=a.iterator();u.hasNext();){var f=u.next().getCoordinate();if(s.isIntersection(f))return!0}return!1},Le.prototype.hasProperIntersection=function(){return this._hasProper},Le.prototype.hasIntersection=function(){return this._hasIntersection},Le.prototype.isDone=function(){return this._isDone},Le.prototype.isBoundaryPoint=function(s,a){return a!==null&&(!!this.isBoundaryPointInternal(s,a[0])||!!this.isBoundaryPointInternal(s,a[1]))},Le.prototype.setBoundaryNodes=function(s,a){this._bdyNodes=new Array(2).fill(null),this._bdyNodes[0]=s,this._bdyNodes[1]=a},Le.prototype.addIntersections=function(s,a,u,f){if(s===u&&a===f)return null;this.numTests++;var p=s.getCoordinates()[a],$=s.getCoordinates()[a+1],q=u.getCoordinates()[f],M=u.getCoordinates()[f+1];this._li.computeIntersection(p,$,q,M),this._li.hasIntersection()&&(this._recordIsolated&&(s.setIsolated(!1),u.setIsolated(!1)),this._numIntersections++,this.isTrivialIntersection(s,a,u,f)||(this._hasIntersection=!0,!this._includeProper&&this._li.isProper()||(s.addIntersections(this._li,a,0),u.addIntersections(this._li,f,1)),this._li.isProper()&&(this._properIntersectionPoint=this._li.getIntersection(0).copy(),this._hasProper=!0,this._isDoneWhenProperInt&&(this._isDone=!0),this.isBoundaryPoint(this._li,this._bdyNodes)||(this._hasProperInterior=!0))))},Le.prototype.interfaces_=function(){return[]},Le.prototype.getClass=function(){return Le},Le.isAdjacentSegments=function(s,a){return Math.abs(s-a)===1};var B9=function(s){function a(){s.call(this),this.events=new nA,this.nOverlaps=null}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.prepareEvents=function(){T6.sort(this.events);for(var u=0;ua||this._max$?1:0},hh.prototype.interfaces_=function(){return[O]},hh.prototype.getClass=function(){return hh};var f9=function(s){function a(){s.call(this),this._item=null;var u=arguments[0],f=arguments[1],p=arguments[2];this._min=u,this._max=f,this._item=p}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.query=function(u,f,p){if(!this.intersects(u,f))return null;p.visitItem(this._item)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Hi),h9=function(s){function a(){s.call(this),this._node1=null,this._node2=null;var u=arguments[0],f=arguments[1];this._node1=u,this._node2=f,this.buildExtent(this._node1,this._node2)}return s&&(a.__proto__=s),a.prototype=Object.create(s&&s.prototype),a.prototype.constructor=a,a.prototype.buildExtent=function(u,f){this._min=Math.min(u._min,f._min),this._max=Math.max(u._max,f._max)},a.prototype.query=function(u,f,p){if(!this.intersects(u,f))return null;this._node1!==null&&this._node1.query(u,f,p),this._node2!==null&&this._node2.query(u,f,p)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a}(Hi),Di=function(){this._leaves=new nA,this._root=null,this._level=0};Di.prototype.buildTree=function(){T6.sort(this._leaves,new Hi.NodeComparator);for(var s=this._leaves,a=null,u=new nA;;){if(this.buildLevel(s,u),u.size()===1)return u.get(0);a=s,s=u,u=a}},Di.prototype.insert=function(s,a,u){if(this._root!==null)throw new Error("Index cannot be added to once it has been queried");this._leaves.add(new f9(s,a,u))},Di.prototype.query=function(s,a,u){this.init(),this._root.query(s,a,u)},Di.prototype.buildRoot=function(){if(this._root!==null)return null;this._root=this.buildTree()},Di.prototype.printNode=function(s){qA.out.println(cj.toLineString(new F(s._min,this._level),new F(s._max,this._level)))},Di.prototype.init=function(){if(this._root!==null)return null;this.buildRoot()},Di.prototype.buildLevel=function(s,a){this._level++,a.clear();for(var u=0;u=2,"found LineString with single point"),this.insertBoundaryPoint(this._argIndex,f[0]),this.insertBoundaryPoint(this._argIndex,f[f.length-1])},a.prototype.getInvalidPoint=function(){return this._invalidPoint},a.prototype.getBoundaryPoints=function(){for(var u=this.getBoundaryNodes(),f=new Array(u.size()).fill(null),p=0,$=u.iterator();$.hasNext();){var q=$.next();f[p++]=q.getCoordinate().copy()}return f},a.prototype.getBoundaryNodes=function(){return this._boundaryNodes===null&&(this._boundaryNodes=this._nodes.getBoundaryNodes(this._argIndex)),this._boundaryNodes},a.prototype.addSelfIntersectionNode=function(u,f,p){if(this.isBoundaryNode(u,f))return null;p===T.BOUNDARY&&this._useBoundaryDeterminationRule?this.insertBoundaryPoint(u,f):this.insertPoint(u,f,p)},a.prototype.addPolygonRing=function(u,f,p){if(u.isEmpty())return null;var $=BA.removeRepeatedPoints(u.getCoordinates());if($.length<4)return this._hasTooFewPoints=!0,this._invalidPoint=$[0],null;var q=f,M=p;EA.isCCW($)&&(q=p,M=f);var H=new dg($,new rt(this._argIndex,T.BOUNDARY,q,M));this._lineEdgeMap.put(u,H),this.insertEdge(H),this.insertPoint(this._argIndex,$[0],T.BOUNDARY)},a.prototype.insertPoint=function(u,f,p){var $=this._nodes.addNode(f),q=$.getLabel();q===null?$._label=new rt(u,p):q.setLocation(u,p)},a.prototype.createEdgeSetIntersector=function(){return new B9},a.prototype.addSelfIntersectionNodes=function(u){for(var f=this._edges.iterator();f.hasNext();)for(var p=f.next(),$=p.getLabel().getLocation(u),q=p.eiList.iterator();q.hasNext();){var M=q.next();this.addSelfIntersectionNode(u,M.coord,$)}},a.prototype.add=function(){if(arguments.length!==1)return s.prototype.add.apply(this,arguments);var u=arguments[0];if(u.isEmpty())return null;if(u instanceof xe&&(this._useBoundaryDeterminationRule=!1),u instanceof Qt)this.addPolygon(u);else if(u instanceof Bj)this.addLineString(u);else if(u instanceof ir)this.addPoint(u);else if(u instanceof M6)this.addCollection(u);else if(u instanceof br)this.addCollection(u);else if(u instanceof xe)this.addCollection(u);else{if(!(u instanceof oj))throw new Error(u.getClass().getName());this.addCollection(u)}},a.prototype.addCollection=function(u){for(var f=0;f50?(this._areaPtLocator===null&&(this._areaPtLocator=new ku(this._parentGeom)),this._areaPtLocator.locate(u)):this._ptLocator.locate(u,this._parentGeom)},a.prototype.findEdge=function(){if(arguments.length===1){var u=arguments[0];return this._lineEdgeMap.get(u)}return s.prototype.findEdge.apply(this,arguments)},a.prototype.interfaces_=function(){return[]},a.prototype.getClass=function(){return a},a.determineBoundary=function(u,f){return u.isInBoundary(f)?T.BOUNDARY:T.INTERIOR},a}(bj),mu=function(){if(this._li=new PA,this._resultPrecisionModel=null,this._arg=null,arguments.length===1){var s=arguments[0];this.setComputationPrecision(s.getPrecisionModel()),this._arg=new Array(1).fill(null),this._arg[0]=new dh(0,s)}else if(arguments.length===2){var a=arguments[0],u=arguments[1],f=P.OGC_SFS_BOUNDARY_RULE;a.getPrecisionModel().compareTo(u.getPrecisionModel())>=0?this.setComputationPrecision(a.getPrecisionModel()):this.setComputationPrecision(u.getPrecisionModel()),this._arg=new Array(2).fill(null),this._arg[0]=new dh(0,a,f),this._arg[1]=new dh(1,u,f)}else if(arguments.length===3){var p=arguments[0],$=arguments[1],q=arguments[2];p.getPrecisionModel().compareTo($.getPrecisionModel())>=0?this.setComputationPrecision(p.getPrecisionModel()):this.setComputationPrecision($.getPrecisionModel()),this._arg=new Array(2).fill(null),this._arg[0]=new dh(0,p,q),this._arg[1]=new dh(1,$,q)}};mu.prototype.getArgGeometry=function(s){return this._arg[s].getGeometry()},mu.prototype.setComputationPrecision=function(s){this._resultPrecisionModel=s,this._li.setPrecisionModel(this._resultPrecisionModel)},mu.prototype.interfaces_=function(){return[]},mu.prototype.getClass=function(){return mu};var l7=function(){};l7.prototype.interfaces_=function(){return[]},l7.prototype.getClass=function(){return l7},l7.map=function(){if(arguments[0]instanceof MA&&b(arguments[1],l7.MapOp)){for(var s=arguments[0],a=arguments[1],u=new nA,f=0;f=s.size()?null:s.get(a)},Wj.union=function(s){return new Wj(s).union()},y8.STRTREE_NODE_CAPACITY.get=function(){return 4},Object.defineProperties(Wj,y8);var ph=function(){};ph.prototype.interfaces_=function(){return[]},ph.prototype.getClass=function(){return ph},ph.union=function(s,a){if(s.isEmpty()||a.isEmpty()){if(s.isEmpty()&&a.isEmpty())return nt.createEmptyResult(nt.UNION,s,a,s.getFactory());if(s.isEmpty())return a.copy();if(a.isEmpty())return s.copy()}return s.checkNotGeometryCollection(s),s.checkNotGeometryCollection(a),ur.overlayOp(s,a,nt.UNION)},t.GeoJSONReader=L,t.GeoJSONWriter=N,t.OverlayOp=nt,t.UnionOp=ph,t.BufferOp=Oe,Object.defineProperty(t,"__esModule",{value:!0})})});var Oy=C6((S1,R1)=>{(function(t,A){typeof S1=="object"&&typeof R1<"u"?R1.exports=A():(t=typeof globalThis<"u"?globalThis:t||self,t.polygonClipping=A())})(S1,function(){"use strict";function t(J,P){var S={label:0,sent:function(){if(U[0]&1)throw U[1];return U[1]},trys:[],ops:[]},K,V,U,lA;return lA={next:rA(0),throw:rA(1),return:rA(2)},typeof Symbol=="function"&&(lA[Symbol.iterator]=function(){return this}),lA;function rA(uA){return function(nA){return hA([uA,nA])}}function hA(uA){if(K)throw new TypeError("Generator is already executing.");for(;S;)try{if(K=1,V&&(U=uA[0]&2?V.return:uA[0]?V.throw||((U=V.return)&&U.call(V),0):V.next)&&!(U=U.call(V,uA[1])).done)return U;switch(V=0,U&&(uA=[uA[0]&2,U.value]),uA[0]){case 0:case 1:U=uA;break;case 4:return S.label++,{value:uA[1],done:!1};case 5:S.label++,V=uA[1],uA=[0];continue;case 7:uA=S.ops.pop(),S.trys.pop();continue;default:if(U=S.trys,!(U=U.length>0&&U[U.length-1])&&(uA[0]===6||uA[0]===2)){S=0;continue}if(uA[0]===3&&(!U||uA[1]>U[0]&&uA[1]P?1:J0){if(P.right===null)break;if(S(J,P.right.key)>0){var rA=P.right;if(P.right=rA.left,rA.left=P,P=rA,P.right===null)break}V.right=P,V=P,P=P.right}else break}return V.right=P.left,U.left=P.right,P.left=K.right,P.right=K.left,P}function r(J,P,S,K){var V=new A(J,P);if(S===null)return V.left=V.right=null,V;S=e(J,S,K);var U=K(J,S.key);return U<0?(V.left=S.left,V.right=S,S.left=null):U>=0&&(V.right=S.right,V.left=S,S.right=null),V}function n(J,P,S){var K=null,V=null;if(P){P=e(J,P,S);var U=S(P.key,J);U===0?(K=P.left,V=P.right):U<0?(V=P.right,P.right=null,K=P):(K=P.left,P.left=null,V=P)}return{left:K,right:V}}function i(J,P,S){return P===null?J:(J===null||(P=e(J.key,P,S),P.left=J),P)}function o(J,P,S,K,V){if(J){K(""+P+(S?"\u2514\u2500\u2500 ":"\u251C\u2500\u2500 ")+V(J)+` +`);var U=P+(S?" ":"\u2502 ");J.left&&o(J.left,U,!1,K,V),J.right&&o(J.right,U,!0,K,V)}}var l=function(){function J(P){P===void 0&&(P=j),this._root=null,this._size=0,this._comparator=P}return J.prototype.insert=function(P,S){return this._size++,this._root=r(P,S,this._root,this._comparator)},J.prototype.add=function(P,S){var K=new A(P,S);this._root===null&&(K.left=K.right=null,this._size++,this._root=K);var V=this._comparator,U=e(P,this._root,V),lA=V(P,U.key);return lA===0?this._root=U:(lA<0?(K.left=U.left,K.right=U,U.left=null):lA>0&&(K.right=U.right,K.left=U,U.right=null),this._size++,this._root=K),this._root},J.prototype.remove=function(P){this._root=this._remove(P,this._root,this._comparator)},J.prototype._remove=function(P,S,K){var V;if(S===null)return null;S=e(P,S,K);var U=K(P,S.key);return U===0?(S.left===null?V=S.right:(V=e(P,S.left,K),V.right=S.right),this._size--,V):S},J.prototype.pop=function(){var P=this._root;if(P){for(;P.left;)P=P.left;return this._root=e(P.key,this._root,this._comparator),this._root=this._remove(P.key,this._root,this._comparator),{key:P.key,data:P.data}}return null},J.prototype.findStatic=function(P){for(var S=this._root,K=this._comparator;S;){var V=K(P,S.key);if(V===0)return S;V<0?S=S.left:S=S.right}return null},J.prototype.find=function(P){return this._root&&(this._root=e(P,this._root,this._comparator),this._comparator(P,this._root.key)!==0)?null:this._root},J.prototype.contains=function(P){for(var S=this._root,K=this._comparator;S;){var V=K(P,S.key);if(V===0)return!0;V<0?S=S.left:S=S.right}return!1},J.prototype.forEach=function(P,S){for(var K=this._root,V=[],U=!1;!U;)K!==null?(V.push(K),K=K.left):V.length!==0?(K=V.pop(),P.call(S,K),K=K.right):U=!0;return this},J.prototype.range=function(P,S,K,V){for(var U=[],lA=this._comparator,rA=this._root,hA;U.length!==0||rA;)if(rA)U.push(rA),rA=rA.left;else{if(rA=U.pop(),hA=lA(rA.key,S),hA>0)break;if(lA(rA.key,P)>=0&&K.call(V,rA))return this;rA=rA.right}return this},J.prototype.keys=function(){var P=[];return this.forEach(function(S){var K=S.key;return P.push(K)}),P},J.prototype.values=function(){var P=[];return this.forEach(function(S){var K=S.data;return P.push(K)}),P},J.prototype.min=function(){return this._root?this.minNode(this._root).key:null},J.prototype.max=function(){return this._root?this.maxNode(this._root).key:null},J.prototype.minNode=function(P){if(P===void 0&&(P=this._root),P)for(;P.left;)P=P.left;return P},J.prototype.maxNode=function(P){if(P===void 0&&(P=this._root),P)for(;P.right;)P=P.right;return P},J.prototype.at=function(P){for(var S=this._root,K=!1,V=0,U=[];!K;)if(S)U.push(S),S=S.left;else if(U.length>0){if(S=U.pop(),V===P)return S;V++,S=S.right}else K=!0;return null},J.prototype.next=function(P){var S=this._root,K=null;if(P.right){for(K=P.right;K.left;)K=K.left;return K}for(var V=this._comparator;S;){var U=V(P.key,S.key);if(U===0)break;U<0?(K=S,S=S.left):S=S.right}return K},J.prototype.prev=function(P){var S=this._root,K=null;if(P.left!==null){for(K=P.left;K.right;)K=K.right;return K}for(var V=this._comparator;S;){var U=V(P.key,S.key);if(U===0)break;U<0?S=S.left:(K=S,S=S.right)}return K},J.prototype.clear=function(){return this._root=null,this._size=0,this},J.prototype.toList=function(){return h(this._root)},J.prototype.load=function(P,S,K){S===void 0&&(S=[]),K===void 0&&(K=!1);var V=P.length,U=this._comparator;if(K&&g(P,S,0,V-1,U),this._root===null)this._root=c(P,S,0,V),this._size=V;else{var lA=k(this.toList(),B(P,S),U);V=this._size+V,this._root=d({head:lA},0,V)}return this},J.prototype.isEmpty=function(){return this._root===null},Object.defineProperty(J.prototype,"size",{get:function(){return this._size},enumerable:!0,configurable:!0}),Object.defineProperty(J.prototype,"root",{get:function(){return this._root},enumerable:!0,configurable:!0}),J.prototype.toString=function(P){P===void 0&&(P=function(K){return String(K.key)});var S=[];return o(this._root,"",!0,function(K){return S.push(K)},P),S.join("")},J.prototype.update=function(P,S,K){var V=this._comparator,U=n(P,this._root,V),lA=U.left,rA=U.right;V(P,S)<0?rA=r(S,K,rA,V):lA=r(S,K,lA,V),this._root=i(lA,rA,V)},J.prototype.split=function(P){return n(P,this._root,this._comparator)},J.prototype[Symbol.iterator]=function(){var P,S,K;return t(this,function(V){switch(V.label){case 0:P=this._root,S=[],K=!1,V.label=1;case 1:return K?[3,6]:P===null?[3,2]:(S.push(P),P=P.left,[3,5]);case 2:return S.length===0?[3,4]:(P=S.pop(),[4,P]);case 3:return V.sent(),P=P.right,[3,5];case 4:K=!0,V.label=5;case 5:return[3,1];case 6:return[2]}})},J}();function c(J,P,S,K){var V=K-S;if(V>0){var U=S+Math.floor(V/2),lA=J[U],rA=P[U],hA=new A(lA,rA);return hA.left=c(J,P,S,U),hA.right=c(J,P,U+1,K),hA}return null}function B(J,P){for(var S=new A(null,null),K=S,V=0;V0?(P=U=U.next=S.pop(),P=P.right):K=!0;return U.next=null,V.next}function d(J,P,S){var K=S-P;if(K>0){var V=P+Math.floor(K/2),U=d(J,P,V),lA=J.head;return lA.left=U,J.head=J.head.next,lA.right=d(J,V+1,S),lA}return null}function k(J,P,S){for(var K=new A(null,null),V=K,U=J,lA=P;U!==null&&lA!==null;)S(U.key,lA.key)<0?(V.next=U,U=U.next):(V.next=lA,lA=lA.next),V=V.next;return U!==null?V.next=U:lA!==null&&(V.next=lA),K.next}function g(J,P,S,K,V){if(!(S>=K)){for(var U=J[S+K>>1],lA=S-1,rA=K+1;;){do lA++;while(V(J[lA],U)<0);do rA--;while(V(J[rA],U)>0);if(lA>=rA)break;var hA=J[lA];J[lA]=J[rA],J[rA]=hA,hA=P[lA],P[lA]=P[rA],P[rA]=hA}g(J,P,S,rA,V),g(J,P,rA+1,K,V)}}let E=(J,P)=>J.ll.x<=P.x&&P.x<=J.ur.x&&J.ll.y<=P.y&&P.y<=J.ur.y,m=(J,P)=>{if(P.ur.x{if(-yuA==nA>-uA?(U=uA,uA=P[++sA]):(U=nA,nA=K[++kA]);let BA=0;if(sAuA==nA>-uA?(lA=uA+U,rA=U-(lA-uA),uA=P[++sA]):(lA=nA+U,rA=U-(lA-nA),nA=K[++kA]),U=lA,rA!==0&&(V[BA++]=rA);sAuA==nA>-uA?(lA=U+uA,hA=lA-U,rA=U-(lA-hA)+(uA-hA),uA=P[++sA]):(lA=U+nA,hA=lA-U,rA=U-(lA-hA)+(nA-hA),nA=K[++kA]),U=lA,rA!==0&&(V[BA++]=rA);for(;sA=br||-oj>=br||(sA=J-jt,rA=J-(jt+sA)+(sA-V),sA=S-_j,uA=S-(_j+sA)+(sA-V),sA=P-qj,hA=P-(qj+sA)+(sA-U),sA=K-gj,nA=K-(gj+sA)+(sA-U),rA===0&&hA===0&&uA===0&&nA===0)||(br=jA*lA+C*Math.abs(oj),oj+=jt*nA+gj*rA-(qj*uA+_j*hA),oj>=br||-oj>=br))return oj;Vj=rA*gj,kA=F*rA,BA=kA-(kA-rA),tt=rA-BA,kA=F*gj,UA=kA-(kA-gj),wt=gj-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=hA*_j,kA=F*hA,BA=kA-(kA-hA),tt=hA-BA,kA=F*_j,UA=kA-(kA-_j),wt=_j-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let Fe=R(4,pA,4,Y,dA);Vj=jt*nA,kA=F*jt,BA=kA-(kA-jt),tt=jt-BA,kA=F*nA,UA=kA-(kA-nA),wt=nA-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=qj*uA,kA=F*qj,BA=kA-(kA-qj),tt=qj-BA,kA=F*uA,UA=kA-(kA-uA),wt=uA-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let c6=R(Fe,dA,4,Y,$A);Vj=rA*nA,kA=F*rA,BA=kA-(kA-rA),tt=rA-BA,kA=F*nA,UA=kA-(kA-nA),wt=nA-UA,dj=tt*wt-(Vj-BA*UA-tt*UA-BA*wt),Cj=hA*uA,kA=F*hA,BA=kA-(kA-hA),tt=hA-BA,kA=F*uA,UA=kA-(kA-uA),wt=uA-UA,$e=tt*wt-(Cj-BA*UA-tt*UA-BA*wt),at=dj-$e,sA=dj-at,Y[0]=dj-(at+sA)+(sA-$e),kj=Vj+at,sA=kj-Vj,Lj=Vj-(kj-sA)+(at-sA),at=Lj-Cj,sA=Lj-at,Y[1]=Lj-(at+sA)+(sA-Cj),vj=kj+at,sA=vj-kj,Y[2]=kj-(vj-sA)+(at-sA),Y[3]=vj;let ue=R(c6,$A,4,Y,_A);return _A[ue-1]}function mt(J,P,S,K,V,U){let lA=(P-U)*(S-V),rA=(J-V)*(K-U),hA=lA-rA,uA=Math.abs(lA+rA);return Math.abs(hA)>=Q*uA?hA:-QA(J,P,S,K,V,U,uA)}let Ct=(J,P)=>J.x*P.y-J.y*P.x,SA=(J,P)=>J.x*P.x+J.y*P.y,ft=(J,P,S)=>{let K=mt(J.x,J.y,P.x,P.y,S.x,S.y);return K>0?-1:K<0?1:0},wA=J=>Math.sqrt(SA(J,J)),_t=(J,P,S)=>{let K={x:P.x-J.x,y:P.y-J.y},V={x:S.x-J.x,y:S.y-J.y};return Ct(V,K)/wA(V)/wA(K)},qA=(J,P,S)=>{let K={x:P.x-J.x,y:P.y-J.y},V={x:S.x-J.x,y:S.y-J.y};return SA(V,K)/wA(V)/wA(K)},Ht=(J,P,S)=>P.y===0?null:{x:J.x+P.x/P.y*(S-J.y),y:S},GA=(J,P,S)=>P.x===0?null:{x:S,y:J.y+P.y/P.x*(S-J.x)},l6=(J,P,S,K)=>{if(P.x===0)return GA(S,K,J.x);if(K.x===0)return GA(J,P,S.x);if(P.y===0)return Ht(S,K,J.y);if(K.y===0)return Ht(J,P,S.y);let V=Ct(P,K);if(V==0)return null;let U={x:S.x-J.x,y:S.y-J.y},lA=Ct(U,P)/V,rA=Ct(U,K)/V,hA=J.x+rA*P.x,uA=S.x+lA*K.x,nA=J.y+rA*P.y,sA=S.y+lA*K.y,kA=(hA+uA)/2,BA=(nA+sA)/2;return{x:kA,y:BA}};class Tt{static compare(P,S){let K=Tt.comparePoints(P.point,S.point);return K!==0?K:(P.point!==S.point&&P.link(S),P.isLeft!==S.isLeft?P.isLeft?1:-1:FA.compare(P.segment,S.segment))}static comparePoints(P,S){return P.xS.x?1:P.yS.y?1:0}constructor(P,S){P.events===void 0?P.events=[this]:P.events.push(this),this.point=P,this.isLeft=S}link(P){if(P.point===this.point)throw new Error("Tried to link already linked events");let S=P.point.events;for(let K=0,V=S.length;K{let U=V.otherSE;S.set(V,{sine:_t(this.point,P.point,U.point),cosine:qA(this.point,P.point,U.point)})};return(V,U)=>{S.has(V)||K(V),S.has(U)||K(U);let{sine:lA,cosine:rA}=S.get(V),{sine:hA,cosine:uA}=S.get(U);return lA>=0&&hA>=0?rAuA?-1:0:lA<0&&hA<0?rAuA?1:0:hAlA?1:0}}}let me=0;class FA{static compare(P,S){let K=P.leftSE.point.x,V=S.leftSE.point.x,U=P.rightSE.point.x,lA=S.rightSE.point.x;if(lArA&&hA>uA)return-1;let sA=P.comparePoint(S.leftSE.point);if(sA<0)return 1;if(sA>0)return-1;let kA=S.comparePoint(P.rightSE.point);return kA!==0?kA:-1}if(K>V){if(rAhA&&rA>nA)return 1;let sA=S.comparePoint(P.leftSE.point);if(sA!==0)return sA;let kA=P.comparePoint(S.rightSE.point);return kA<0?1:kA>0?-1:1}if(rAhA)return 1;if(UlA){let sA=P.comparePoint(S.rightSE.point);if(sA<0)return 1;if(sA>0)return-1}if(U!==lA){let sA=uA-rA,kA=U-K,BA=nA-hA,tt=lA-V;if(sA>kA&&BAtt)return-1}return U>lA?1:UnA?1:P.idS.id?1:0}constructor(P,S,K,V){this.id=++me,this.leftSE=P,P.segment=this,P.otherSE=S,this.rightSE=S,S.segment=this,S.otherSE=P,this.rings=K,this.windings=V}static fromRing(P,S,K){let V,U,lA,rA=Tt.comparePoints(P,S);if(rA<0)V=P,U=S,lA=1;else if(rA>0)V=S,U=P,lA=-1;else throw new Error(`Tried to create degenerate segment at [${P.x}, ${P.y}]`);let hA=new Tt(V,!0),uA=new Tt(U,!1);return new FA(hA,uA,[K],[lA])}replaceRightSE(P){this.rightSE=P,this.rightSE.segment=this,this.rightSE.otherSE=this.leftSE,this.leftSE.otherSE=this.rightSE}bbox(){let P=this.leftSE.point.y,S=this.rightSE.point.y;return{ll:{x:this.leftSE.point.x,y:PS?P:S}}}vector(){return{x:this.rightSE.point.x-this.leftSE.point.x,y:this.rightSE.point.y-this.leftSE.point.y}}isAnEndpoint(P){return P.x===this.leftSE.point.x&&P.y===this.leftSE.point.y||P.x===this.rightSE.point.x&&P.y===this.rightSE.point.y}comparePoint(P){if(this.isAnEndpoint(P))return 0;let S=this.leftSE.point,K=this.rightSE.point,V=this.vector();if(S.x===K.x)return P.x===S.x?0:P.x0&&rA.swapEvents(),Tt.comparePoints(this.leftSE.point,this.rightSE.point)>0&&this.swapEvents(),K&&(V.checkForConsuming(),U.checkForConsuming()),S}swapEvents(){let P=this.rightSE;this.rightSE=this.leftSE,this.leftSE=P,this.leftSE.isLeft=!0,this.rightSE.isLeft=!1;for(let S=0,K=this.windings.length;S0){let U=S;S=K,K=U}if(S.prev===K){let U=S;S=K,K=U}for(let U=0,lA=K.rings.length;UV.length===1&&V[0].isSubject;this._isInResult=K(P)!==K(S);break}default:throw new Error(`Unrecognized operation type found ${EA.type}`)}return this._isInResult}}class yj{constructor(P,S,K){if(!Array.isArray(P)||P.length===0)throw new Error("Input geometry is not a valid Polygon or MultiPolygon");if(this.poly=S,this.isExterior=K,this.segments=[],typeof P[0][0]!="number"||typeof P[0][1]!="number")throw new Error("Input geometry is not a valid Polygon or MultiPolygon");let V=x.round(P[0][0],P[0][1]);this.bbox={ll:{x:V.x,y:V.y},ur:{x:V.x,y:V.y}};let U=V;for(let lA=1,rA=P.length;lAthis.bbox.ur.x&&(this.bbox.ur.x=hA.x),hA.y>this.bbox.ur.y&&(this.bbox.ur.y=hA.y),U=hA)}(V.x!==U.x||V.y!==U.y)&&this.segments.push(FA.fromRing(U,V,this))}getSweepEvents(){let P=[];for(let S=0,K=this.segments.length;Sthis.bbox.ur.x&&(this.bbox.ur.x=U.bbox.ur.x),U.bbox.ur.y>this.bbox.ur.y&&(this.bbox.ur.y=U.bbox.ur.y),this.interiorRings.push(U)}this.multiPoly=S}getSweepEvents(){let P=this.exteriorRing.getSweepEvents();for(let S=0,K=this.interiorRings.length;Sthis.bbox.ur.x&&(this.bbox.ur.x=U.bbox.ur.x),U.bbox.ur.y>this.bbox.ur.y&&(this.bbox.ur.y=U.bbox.ur.y),this.polys.push(U)}this.isSubject=S}getSweepEvents(){let P=[];for(let S=0,K=this.polys.length;S0&&(P=lA)}let S=P.segment.prevInResult(),K=S?S.prevInResult():null;for(;;){if(!S)return null;if(!K)return S.ringOut;if(K.ringOut!==S.ringOut)return K.ringOut.enclosingRing()!==S.ringOut?S.ringOut:S.ringOut.enclosingRing();S=K.prevInResult(),K=S?S.prevInResult():null}}}class KA{constructor(P){this.exteriorRing=P,P.poly=this,this.interiorRings=[]}addInterior(P){this.interiorRings.push(P),P.poly=this}getGeom(){let P=[this.exteriorRing.getGeom()];if(P[0]===null)return null;for(let S=0,K=this.interiorRings.length;S1&&arguments[1]!==void 0?arguments[1]:FA.compare;this.queue=P,this.tree=new l(S),this.segments=[]}process(P){let S=P.segment,K=[];if(P.consumedBy)return P.isLeft?this.queue.remove(P.otherSE):this.tree.remove(S),K;let V=P.isLeft?this.tree.add(S):this.tree.find(S);if(!V)throw new Error(`Unable to find segment #${S.id} [${S.leftSE.point.x}, ${S.leftSE.point.y}] -> [${S.rightSE.point.x}, ${S.rightSE.point.y}] in SweepLine tree.`);let U=V,lA=V,rA,hA;for(;rA===void 0;)U=this.tree.prev(U),U===null?rA=null:U.key.consumedBy===void 0&&(rA=U.key);for(;hA===void 0;)lA=this.tree.next(lA),lA===null?hA=null:lA.key.consumedBy===void 0&&(hA=lA.key);if(P.isLeft){let uA=null;if(rA){let sA=rA.getIntersection(S);if(sA!==null&&(S.isAnEndpoint(sA)||(uA=sA),!rA.isAnEndpoint(sA))){let kA=this._splitSafely(rA,sA);for(let BA=0,tt=kA.length;BA0?(this.tree.remove(S),K.push(P)):(this.segments.push(S),S.prev=rA)}else{if(rA&&hA){let uA=rA.getIntersection(hA);if(uA!==null){if(!rA.isAnEndpoint(uA)){let nA=this._splitSafely(rA,uA);for(let sA=0,kA=nA.length;sAPA)throw new Error("Infinite loop when putting segment endpoints in a priority queue (queue size too big).")}let lA=new fA(U),rA=U.size,hA=U.pop();for(;hA;){let sA=hA.key;if(U.size===rA){let BA=sA.segment;throw new Error(`Unable to pop() ${sA.isLeft?"left":"right"} SweepEvent [${sA.point.x}, ${sA.point.y}] from segment #${BA.id} [${BA.leftSE.point.x}, ${BA.leftSE.point.y}] -> [${BA.rightSE.point.x}, ${BA.rightSE.point.y}] from queue.`)}if(U.size>PA)throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big).");if(lA.segments.length>RA)throw new Error("Infinite loop when passing sweep line over endpoints (too many sweep line segments).");let kA=lA.process(sA);for(let BA=0,tt=kA.length;BA1?P-1:0),K=1;K1?P-1:0),K=1;K1?P-1:0),K=1;K1?P-1:0),K=1;K{"use strict";var zlA=Object.prototype.hasOwnProperty,Nn="~";function j0(){}Object.create&&(j0.prototype=Object.create(null),new j0().__proto__||(Nn=!1));function UlA(t,A,j){this.fn=t,this.context=A,this.once=j||!1}function mN(t,A,j,e,r){if(typeof j!="function")throw new TypeError("The listener must be a function");var n=new UlA(j,e||t,r),i=Nn?Nn+A:A;return t._events[i]?t._events[i].fn?t._events[i]=[t._events[i],n]:t._events[i].push(n):(t._events[i]=n,t._eventsCount++),t}function Ty(t,A){--t._eventsCount===0?t._events=new j0:delete t._events[A]}function fn(){this._events=new j0,this._eventsCount=0}fn.prototype.eventNames=function(){var A=[],j,e;if(this._eventsCount===0)return A;for(e in j=this._events)zlA.call(j,e)&&A.push(Nn?e.slice(1):e);return Object.getOwnPropertySymbols?A.concat(Object.getOwnPropertySymbols(j)):A};fn.prototype.listeners=function(A){var j=Nn?Nn+A:A,e=this._events[j];if(!e)return[];if(e.fn)return[e.fn];for(var r=0,n=e.length,i=new Array(n);r{(function(t,A){typeof PP=="object"&&typeof IP<"u"?IP.exports=A():(t=t||self).RBush=A()})(PP,function(){"use strict";function t(m,y,G,v,_){(function w(x,O,F,C,R){for(;C>F;){if(C-F>600){var X=C-F+1,T=O-F+1,Q=Math.log(X),b=.5*Math.exp(2*Q/3),jA=.5*Math.sqrt(Q*b*(X-b)/X)*(T-X/2<0?-1:1),pA=Math.max(F,Math.floor(O-T*b/X+jA)),dA=Math.min(C,Math.floor(O+(X-T)*b/X+jA));w(x,O,pA,dA,R)}var $A=x[O],_A=F,Y=C;for(A(x,F,O),R(x[C],$A)>0&&A(x,F,C);_A0;)Y--}R(x[F],$A)===0?A(x,F,Y):A(x,++Y,C),Y<=O&&(F=Y+1),O<=Y&&(C=Y-1)}})(m,y,G||0,v||m.length-1,_||j)}function A(m,y,G){var v=m[y];m[y]=m[G],m[G]=v}function j(m,y){return my?1:0}var e=function(m){m===void 0&&(m=9),this._maxEntries=Math.max(4,m),this._minEntries=Math.max(2,Math.ceil(.4*this._maxEntries)),this.clear()};function r(m,y,G){if(!G)return y.indexOf(m);for(var v=0;v=m.minX&&y.maxY>=m.minY}function g(m){return{children:m,height:1,leaf:!0,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0}}function E(m,y,G,v,_){for(var w=[y,G];w.length;)if(!((G=w.pop())-(y=w.pop())<=v)){var x=y+Math.ceil((G-y)/v/2)*v;t(m,x,y,G,_),w.push(y,x,x,G)}}return e.prototype.all=function(){return this._all(this.data,[])},e.prototype.search=function(m){var y=this.data,G=[];if(!k(m,y))return G;for(var v=this.toBBox,_=[];y;){for(var w=0;w=0&&_[y].children.length>this._maxEntries;)this._split(_,y),y--;this._adjustParentBBoxes(v,_,y)},e.prototype._split=function(m,y){var G=m[y],v=G.children.length,_=this._minEntries;this._chooseSplitAxis(G,_,v);var w=this._chooseSplitIndex(G,_,v),x=g(G.children.splice(w,G.children.length-w));x.height=G.height,x.leaf=G.leaf,n(G,this.toBBox),n(x,this.toBBox),y?m[y-1].children.push(x):this._splitRoot(G,x)},e.prototype._splitRoot=function(m,y){this.data=g([m,y]),this.data.height=m.height+1,this.data.leaf=!1,n(this.data,this.toBBox)},e.prototype._chooseSplitIndex=function(m,y,G){for(var v,_,w,x,O,F,C,R=1/0,X=1/0,T=y;T<=G-y;T++){var Q=i(m,0,T,this.toBBox),b=i(m,T,G,this.toBBox),jA=(_=Q,w=b,x=void 0,O=void 0,F=void 0,C=void 0,x=Math.max(_.minX,w.minX),O=Math.max(_.minY,w.minY),F=Math.min(_.maxX,w.maxX),C=Math.min(_.maxY,w.maxY),Math.max(0,F-x)*Math.max(0,C-O)),pA=B(Q)+B(b);jA=y;R--){var X=m.children[R];o(x,m.leaf?_(X):X),O+=h(x)}return O},e.prototype._adjustParentBBoxes=function(m,y,G){for(var v=G;v>=0;v--)o(y[v],m)},e.prototype._condense=function(m){for(var y=m.length-1,G=void 0;y>=0;y--)m[y].children.length===0?y>0?(G=m[y-1].children).splice(G.indexOf(m[y]),1):this.clear():n(m[y],this.toBBox)},e})});var RP=C6(ot=>{"use strict";Object.defineProperty(ot,"__esModule",{value:!0});ot.earthRadius=63710088e-1;ot.factors={centimeters:ot.earthRadius*100,centimetres:ot.earthRadius*100,degrees:ot.earthRadius/111325,feet:ot.earthRadius*3.28084,inches:ot.earthRadius*39.37,kilometers:ot.earthRadius/1e3,kilometres:ot.earthRadius/1e3,meters:ot.earthRadius,metres:ot.earthRadius,miles:ot.earthRadius/1609.344,millimeters:ot.earthRadius*1e3,millimetres:ot.earthRadius*1e3,nauticalmiles:ot.earthRadius/1852,radians:1,yards:ot.earthRadius*1.0936};ot.unitsFactors={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/ot.earthRadius,yards:1.0936133};ot.areaFactors={acres:247105e-9,centimeters:1e4,centimetres:1e4,feet:10.763910417,hectares:1e-4,inches:1550.003100006,kilometers:1e-6,kilometres:1e-6,meters:1,metres:1,miles:386e-9,millimeters:1e6,millimetres:1e6,yards:1.195990046};function sl(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}ot.feature=sl;function QcA(t,A,j){switch(j===void 0&&(j={}),t){case"Point":return MP(A).geometry;case"LineString":return TP(A).geometry;case"Polygon":return OP(A).geometry;case"MultiPoint":return W3(A).geometry;case"MultiLineString":return Q3(A).geometry;case"MultiPolygon":return Y3(A).geometry;default:throw new Error(t+" is invalid")}}ot.geometry=QcA;function MP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!jv(t[0])||!jv(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return sl(e,A,j)}ot.point=MP;function WcA(t,A,j){return j===void 0&&(j={}),ev(t.map(function(e){return MP(e,A)}),j)}ot.points=WcA;function OP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=0))throw new Error("precision must be a positive number");var j=Math.pow(10,A||0);return Math.round(t*j)/j}ot.round=AuA;function J3(t,A){A===void 0&&(A="kilometers");var j=ot.factors[A];if(!j)throw new Error(A+" units is invalid");return t*j}ot.radiansToLength=J3;function SP(t,A){A===void 0&&(A="kilometers");var j=ot.factors[A];if(!j)throw new Error(A+" units is invalid");return t/j}ot.lengthToRadians=SP;function tuA(t,A){return Z3(SP(t,A))}ot.lengthToDegrees=tuA;function juA(t){var A=t%360;return A<0&&(A+=360),A}ot.bearingToAzimuth=juA;function Z3(t){var A=t%(2*Math.PI);return A*180/Math.PI}ot.radiansToDegrees=Z3;function euA(t){var A=t%360;return A*Math.PI/180}ot.degreesToRadians=euA;function ruA(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return J3(SP(t,A),j)}ot.convertLength=ruA;function nuA(t,A,j){if(A===void 0&&(A="meters"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("area must be a positive number");var e=ot.areaFactors[A];if(!e)throw new Error("invalid original units");var r=ot.areaFactors[j];if(!r)throw new Error("invalid final units");return t/e*r}ot.convertArea=nuA;function jv(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}ot.isNumber=jv;function iuA(t){return!!t&&t.constructor===Object}ot.isObject=iuA;function ouA(t){if(!t)throw new Error("bbox is required");if(!Array.isArray(t))throw new Error("bbox must be an Array");if(t.length!==4&&t.length!==6)throw new Error("bbox must be an Array of 4 or 6 numbers");t.forEach(function(A){if(!jv(A))throw new Error("bbox must only contain numbers")})}ot.validateBBox=ouA;function suA(t){if(!t)throw new Error("id is required");if(["string","number"].indexOf(typeof t)===-1)throw new Error("id must be a number or a string")}ot.validateId=suA});var rK=C6(jr=>{"use strict";Object.defineProperty(jr,"__esModule",{value:!0});var hn=RP();function f0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=hn.lineString([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}function huA(t,A,j){var e=j,r=!1;return jK(t,function(n,i,o,l,c){r===!1&&j===void 0?e=n:e=A(e,n,i,o,l,c),r=!0}),e}function eK(t,A){if(!t)throw new Error("geojson is required");rv(t,function(j,e,r){if(j.geometry!==null){var n=j.geometry.type,i=j.geometry.coordinates;switch(n){case"LineString":if(A(j,e,r,0,0)===!1)return!1;break;case"Polygon":for(var o=0;o{"use strict";Object.defineProperty(st,"__esModule",{value:!0});st.earthRadius=63710088e-1;st.factors={centimeters:st.earthRadius*100,centimetres:st.earthRadius*100,degrees:st.earthRadius/111325,feet:st.earthRadius*3.28084,inches:st.earthRadius*39.37,kilometers:st.earthRadius/1e3,kilometres:st.earthRadius/1e3,meters:st.earthRadius,metres:st.earthRadius,miles:st.earthRadius/1609.344,millimeters:st.earthRadius*1e3,millimetres:st.earthRadius*1e3,nauticalmiles:st.earthRadius/1852,radians:1,yards:st.earthRadius*1.0936};st.unitsFactors={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/st.earthRadius,yards:1.0936133};st.areaFactors={acres:247105e-9,centimeters:1e4,centimetres:1e4,feet:10.763910417,hectares:1e-4,inches:1550.003100006,kilometers:1e-6,kilometres:1e-6,meters:1,metres:1,miles:386e-9,millimeters:1e6,millimetres:1e6,yards:1.195990046};function al(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}st.feature=al;function guA(t,A,j){switch(j===void 0&&(j={}),t){case"Point":return CP(A).geometry;case"LineString":return DP(A).geometry;case"Polygon":return HP(A).geometry;case"MultiPoint":return iK(A).geometry;case"MultiLineString":return nK(A).geometry;case"MultiPolygon":return oK(A).geometry;default:throw new Error(t+" is invalid")}}st.geometry=guA;function CP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!nv(t[0])||!nv(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return al(e,A,j)}st.point=CP;function muA(t,A,j){return j===void 0&&(j={}),iv(t.map(function(e){return CP(e,A)}),j)}st.points=muA;function HP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=0))throw new Error("precision must be a positive number");var j=Math.pow(10,A||0);return Math.round(t*j)/j}st.round=yuA;function sK(t,A){A===void 0&&(A="kilometers");var j=st.factors[A];if(!j)throw new Error(A+" units is invalid");return t*j}st.radiansToLength=sK;function NP(t,A){A===void 0&&(A="kilometers");var j=st.factors[A];if(!j)throw new Error(A+" units is invalid");return t/j}st.lengthToRadians=NP;function vuA(t,A){return aK(NP(t,A))}st.lengthToDegrees=vuA;function _uA(t){var A=t%360;return A<0&&(A+=360),A}st.bearingToAzimuth=_uA;function aK(t){var A=t%(2*Math.PI);return A*180/Math.PI}st.radiansToDegrees=aK;function quA(t){var A=t%360;return A*Math.PI/180}st.degreesToRadians=quA;function buA(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return sK(NP(t,A),j)}st.convertLength=buA;function GuA(t,A,j){if(A===void 0&&(A="meters"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("area must be a positive number");var e=st.areaFactors[A];if(!e)throw new Error("invalid original units");var r=st.areaFactors[j];if(!r)throw new Error("invalid final units");return t/e*r}st.convertArea=GuA;function nv(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}st.isNumber=nv;function wuA(t){return!!t&&t.constructor===Object}st.isObject=wuA;function FuA(t){if(!t)throw new Error("bbox is required");if(!Array.isArray(t))throw new Error("bbox must be an Array");if(t.length!==4&&t.length!==6)throw new Error("bbox must be an Array of 4 or 6 numbers");t.forEach(function(A){if(!nv(A))throw new Error("bbox must only contain numbers")})}st.validateBBox=FuA;function PuA(t){if(!t)throw new Error("id is required");if(["string","number"].indexOf(typeof t)===-1)throw new Error("id must be a number or a string")}st.validateId=PuA});var hK=C6(er=>{"use strict";Object.defineProperty(er,"__esModule",{value:!0});var dn=lK();function h0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=dn.lineString([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}function LuA(t,A,j){var e=j,r=!1;return BK(t,function(n,i,o,l,c){r===!1&&j===void 0?e=n:e=A(e,n,i,o,l,c),r=!0}),e}function fK(t,A){if(!t)throw new Error("geojson is required");ov(t,function(j,e,r){if(j.geometry!==null){var n=j.geometry.type,i=j.geometry.coordinates;switch(n){case"LineString":if(A(j,e,r,0,0)===!1)return!1;break;case"Polygon":for(var o=0;o{"use strict";Object.defineProperty(zP,"__esModule",{value:!0});var NuA=hK();function XP(t){var A=[1/0,1/0,-1/0,-1/0];return NuA.coordEach(t,function(j){A[0]>j[0]&&(A[0]=j[0]),A[1]>j[1]&&(A[1]=j[1]),A[2]{var Fs=V3(),kK=RP(),gK=rK(),Ef=dK().default,KuA=gK.featureEach,jst=gK.coordEach,est=kK.polygon,pK=kK.featureCollection;function mK(t){var A=new Fs(t);return A.insert=function(j){if(j.type!=="Feature")throw new Error("invalid feature");return j.bbox=j.bbox?j.bbox:Ef(j),Fs.prototype.insert.call(this,j)},A.load=function(j){var e=[];return Array.isArray(j)?j.forEach(function(r){if(r.type!=="Feature")throw new Error("invalid features");r.bbox=r.bbox?r.bbox:Ef(r),e.push(r)}):KuA(j,function(r){if(r.type!=="Feature")throw new Error("invalid features");r.bbox=r.bbox?r.bbox:Ef(r),e.push(r)}),Fs.prototype.load.call(this,e)},A.remove=function(j,e){if(j.type!=="Feature")throw new Error("invalid feature");return j.bbox=j.bbox?j.bbox:Ef(j),Fs.prototype.remove.call(this,j,e)},A.clear=function(){return Fs.prototype.clear.call(this)},A.search=function(j){var e=Fs.prototype.search.call(this,this.toBBox(j));return pK(e)},A.collides=function(j){return Fs.prototype.collides.call(this,this.toBBox(j))},A.all=function(){var j=Fs.prototype.all.call(this);return pK(j)},A.toJSON=function(){return Fs.prototype.toJSON.call(this)},A.fromJSON=function(j){return Fs.prototype.fromJSON.call(this,j)},A.toBBox=function(j){var e;if(j.bbox)e=j.bbox;else if(Array.isArray(j)&&j.length===4)e=j;else if(Array.isArray(j)&&j.length===6)e=[j[0],j[1],j[3],j[4]];else if(j.type==="Feature")e=Ef(j);else if(j.type==="FeatureCollection")e=Ef(j);else throw new Error("invalid geojson");return{minX:e[0],minY:e[1],maxX:e[2],maxY:e[3]}},A}UP.exports=mK;UP.exports.default=mK});var RK=C6((z7t,SK)=>{var TK="Expected a function",MK=NaN,jBA="[object Symbol]",eBA=/^\s+|\s+$/g,rBA=/^[-+]0x[0-9a-f]+$/i,nBA=/^0b[01]+$/i,iBA=/^0o[0-7]+$/i,oBA=parseInt,sBA=typeof global=="object"&&global&&global.Object===Object&&global,aBA=typeof self=="object"&&self&&self.Object===Object&&self,lBA=sBA||aBA||Function("return this")(),cBA=Object.prototype,uBA=cBA.toString,BBA=Math.max,fBA=Math.min,ZP=function(){return lBA.Date.now()};function hBA(t,A,j){var e,r,n,i,o,l,c=0,B=!1,h=!1,d=!0;if(typeof t!="function")throw new TypeError(TK);A=OK(A)||0,Bv(j)&&(B=!!j.leading,h="maxWait"in j,n=h?BBA(OK(j.maxWait)||0,A):n,d="trailing"in j?!!j.trailing:d);function k(x){var O=e,F=r;return e=r=void 0,c=x,i=t.apply(F,O),i}function g(x){return c=x,o=setTimeout(y,A),B?k(x):i}function E(x){var O=x-l,F=x-c,C=A-O;return h?fBA(C,n-F):C}function m(x){var O=x-l,F=x-c;return l===void 0||O>=A||O<0||h&&F>=n}function y(){var x=ZP();if(m(x))return G(x);o=setTimeout(y,E(x))}function G(x){return o=void 0,d&&e?k(x):(e=r=void 0,i)}function v(){o!==void 0&&clearTimeout(o),c=0,e=l=r=o=void 0}function _(){return o===void 0?i:G(ZP())}function w(){var x=ZP(),O=m(x);if(e=arguments,r=this,l=x,O){if(o===void 0)return g(l);if(h)return o=setTimeout(y,A),k(l)}return o===void 0&&(o=setTimeout(y,A)),i}return w.cancel=v,w.flush=_,w}function dBA(t,A,j){var e=!0,r=!0;if(typeof t!="function")throw new TypeError(TK);return Bv(j)&&(e="leading"in j?!!j.leading:e,r="trailing"in j?!!j.trailing:r),hBA(t,A,{leading:e,maxWait:A,trailing:r})}function Bv(t){var A=typeof t;return!!t&&(A=="object"||A=="function")}function pBA(t){return!!t&&typeof t=="object"}function kBA(t){return typeof t=="symbol"||pBA(t)&&uBA.call(t)==jBA}function OK(t){if(typeof t=="number")return t;if(kBA(t))return MK;if(Bv(t)){var A=typeof t.valueOf=="function"?t.valueOf():t;t=Bv(A)?A+"":A}if(typeof t!="string")return t===0?t:+t;t=t.replace(eBA,"");var j=nBA.test(t);return j||iBA.test(t)?oBA(t.slice(2),j?2:8):rBA.test(t)?MK:+t}SK.exports=dBA});var gg="net_mat[row][col] is the matrix entry at row index (row entity) and column index (col entity)";function Rl(t,A,j){if(!t?.set)return;let e=typeof crypto<"u"&&crypto.randomUUID?crypto.randomUUID():`r${Date.now()}-${Math.random().toString(16).slice(2)}`;return t.set("matrix_slice_request",{}),t.set("matrix_slice_request",{req_id:e,op:A,...j}),t.save_changes(),e}function kh(t,A,j){let e=t?.mat?.net_mat,r=t?.row_nodes,n=t?.col_nodes;if(!Array.isArray(e)||!Array.isArray(r)||!Array.isArray(n)||A==null||Number.isNaN(Number(A)))return null;let i=Number(A);if(i<0||i>=e.length)return null;let o=e[i];if(!Array.isArray(o))return null;let l=[];for(let h=0;hd.value-h.value);let c=j==null?2e3:j<0?Math.min(l.length,5e5):Math.min(l.length,j,5e5),B=r[i];return{slice_kind:"row_axis",matrix_convention:gg,primary_index:i,primary_name:B?B.name:null,entries:l.slice(0,c)}}function gh(t,A,j){let e=t?.mat?.net_mat,r=t?.row_nodes,n=t?.col_nodes;if(!Array.isArray(e)||!Array.isArray(r)||!Array.isArray(n)||A==null||Number.isNaN(Number(A)))return null;let i=Number(A);if(i<0||i>=n.length)return null;let o=[];for(let B=0;B=h.length)continue;let d=Number(h[i]);if(!Number.isFinite(d)||d===0)continue;let k=r[B];k&&o.push({row:B,col:i,counterpart_name:k.name,value:d})}o.sort((B,h)=>h.value-B.value);let l=j==null?2e3:j<0?Math.min(o.length,5e5):Math.min(o.length,j,5e5),c=n[i];return{slice_kind:"col_axis",matrix_convention:gg,primary_index:i,primary_name:c?c.name:null,entries:o.slice(0,l)}}function mg(t,A,j){return{slice_kind:"cell",matrix_convention:gg,row_index:t,col_index:A,value:j}}function _8(t,A,j,e){let r=kh(t,A,e),n=gh(t,j,e);return!r&&!n?null:{slice_kind:"row_col",matrix_convention:gg,row_axis:r,col_axis:n}}function b8(t,A){var j={};for(var e in t)Object.prototype.hasOwnProperty.call(t,e)&&A.indexOf(e)<0&&(j[e]=t[e]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var r=0,e=Object.getOwnPropertySymbols(t);r=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}};throw new TypeError(A?"Object is not iterable.":"Symbol.iterator is not defined.")}function vt(t){return this instanceof vt?(this.v=t,this):new vt(t)}function H6(t,A,j){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=j.apply(t,A||[]),r,n=[];return r={},i("next"),i("throw"),i("return"),r[Symbol.asyncIterator]=function(){return this},r;function i(d){e[d]&&(r[d]=function(k){return new Promise(function(g,E){n.push([d,k,g,E])>1||o(d,k)})})}function o(d,k){try{l(e[d](k))}catch(g){h(n[0][3],g)}}function l(d){d.value instanceof vt?Promise.resolve(d.value.v).then(c,B):h(n[0][2],d)}function c(d){o("next",d)}function B(d){o("throw",d)}function h(d,k){d(k),n.shift(),n.length&&o(n[0][0],n[0][1])}}function $u(t){var A,j;return A={},e("next"),e("throw",function(r){throw r}),e("return"),A[Symbol.iterator]=function(){return this},A;function e(r,n){A[r]=t[r]?function(i){return(j=!j)?{value:vt(t[r](i)),done:!1}:n?n(i):i}:n}}function Ki(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var A=t[Symbol.asyncIterator],j;return A?A.call(t):(t=typeof q8=="function"?q8(t):t[Symbol.iterator](),j={},e("next"),e("throw"),e("return"),j[Symbol.asyncIterator]=function(){return this},j);function e(n){j[n]=t[n]&&function(i){return new Promise(function(o,l){i=t[n](i),r(o,l,i.done,i.value)})}}function r(n,i,o,l){Promise.resolve(l).then(function(c){n({value:c,done:o})},i)}}var Z_={};fr(Z_,{compareArrayLike:()=>J_,joinUint8Arrays:()=>N6,memcpy:()=>$h,rebaseValueOffsets:()=>bg,toArrayBufferView:()=>Mt,toArrayBufferViewAsyncIterator:()=>zi,toArrayBufferViewIterator:()=>Ho,toBigInt64Array:()=>qg,toBigUint64Array:()=>F9,toFloat32Array:()=>P9,toFloat32ArrayAsyncIterator:()=>V9,toFloat32ArrayIterator:()=>C9,toFloat64Array:()=>I9,toFloat64ArrayAsyncIterator:()=>Q9,toFloat64ArrayIterator:()=>H9,toInt16Array:()=>b9,toInt16ArrayAsyncIterator:()=>K9,toInt16ArrayIterator:()=>T9,toInt32Array:()=>Ll,toInt32ArrayAsyncIterator:()=>X9,toInt32ArrayIterator:()=>S9,toInt8Array:()=>q9,toInt8ArrayAsyncIterator:()=>N9,toInt8ArrayIterator:()=>O9,toUint16Array:()=>G9,toUint16ArrayAsyncIterator:()=>z9,toUint16ArrayIterator:()=>R9,toUint32Array:()=>w9,toUint32ArrayAsyncIterator:()=>U9,toUint32ArrayIterator:()=>L9,toUint8Array:()=>it,toUint8ArrayAsyncIterator:()=>Y_,toUint8ArrayIterator:()=>W_,toUint8ClampedArray:()=>M9,toUint8ClampedArrayAsyncIterator:()=>W9,toUint8ClampedArrayIterator:()=>D9});var x9=new TextDecoder("utf-8"),mh=t=>x9.decode(t),y9=new TextEncoder,Co=t=>y9.encode(t);var v9=t=>typeof t=="number",G8=t=>typeof t=="boolean",Ye=t=>typeof t=="function",qn=t=>t!=null&&Object(t)===t,D6=t=>qn(t)&&Ye(t.then);var Xi=t=>qn(t)&&Ye(t[Symbol.iterator]),Bi=t=>qn(t)&&Ye(t[Symbol.asyncIterator]),Eg=t=>qn(t)&&qn(t.schema);var $g=t=>qn(t)&&"done"in t&&"value"in t;var xg=t=>qn(t)&&Ye(t.stat)&&v9(t.fd);var yg=t=>qn(t)&&Eh(t.body),vg=t=>"_getDOMStream"in t&&"_getNodeStream"in t,w8=t=>qn(t)&&Ye(t.abort)&&Ye(t.getWriter)&&!vg(t),Eh=t=>qn(t)&&Ye(t.cancel)&&Ye(t.getReader)&&!vg(t),F8=t=>qn(t)&&Ye(t.end)&&Ye(t.write)&&G8(t.writable)&&!vg(t),_g=t=>qn(t)&&Ye(t.read)&&Ye(t.pipe)&&G8(t.readable)&&!vg(t),P8=t=>qn(t)&&Ye(t.clear)&&Ye(t.bytes)&&Ye(t.position)&&Ye(t.setPosition)&&Ye(t.capacity)&&Ye(t.getBufferIdentifier)&&Ye(t.createLong);var Q_=typeof SharedArrayBuffer<"u"?SharedArrayBuffer:ArrayBuffer;function _9(t){let A=t[0]?[t[0]]:[],j,e,r,n;for(let i,o,l=0,c=0,B=t.length;++lB+h.byteLength,0),r,n,i,o=0,l=-1,c=Math.min(A||Number.POSITIVE_INFINITY,e);for(let B=j.length;++lMt(Int8Array,t),b9=t=>Mt(Int16Array,t),Ll=t=>Mt(Int32Array,t),qg=t=>Mt(BigInt64Array,t),it=t=>Mt(Uint8Array,t),G9=t=>Mt(Uint16Array,t),w9=t=>Mt(Uint32Array,t),F9=t=>Mt(BigUint64Array,t),P9=t=>Mt(Float32Array,t),I9=t=>Mt(Float64Array,t),M9=t=>Mt(Uint8ClampedArray,t),V_=t=>(t.next(),t);function*Ho(t,A){let j=function*(r){yield r},e=typeof A=="string"||ArrayBuffer.isView(A)||A instanceof ArrayBuffer||A instanceof Q_?j(A):Xi(A)?A:j(A);return yield*V_(function*(r){let n=null;do n=r.next(yield Mt(t,n));while(!n.done)}(e[Symbol.iterator]())),new t}var O9=t=>Ho(Int8Array,t),T9=t=>Ho(Int16Array,t),S9=t=>Ho(Int32Array,t),W_=t=>Ho(Uint8Array,t),R9=t=>Ho(Uint16Array,t),L9=t=>Ho(Uint32Array,t),C9=t=>Ho(Float32Array,t),H9=t=>Ho(Float64Array,t),D9=t=>Ho(Uint8ClampedArray,t);function zi(t,A){return H6(this,arguments,function*(){if(D6(A))return yield vt(yield vt(yield*$u(Ki(zi(t,yield vt(A))))));let e=function(i){return H6(this,arguments,function*(){yield yield vt(yield vt(i))})},r=function(i){return H6(this,arguments,function*(){yield vt(yield*$u(Ki(V_(function*(o){let l=null;do l=o.next(yield l?.value);while(!l.done)}(i[Symbol.iterator]())))))})},n=typeof A=="string"||ArrayBuffer.isView(A)||A instanceof ArrayBuffer||A instanceof Q_?e(A):Xi(A)?r(A):Bi(A)?A:e(A);return yield vt(yield*$u(Ki(V_(function(i){return H6(this,arguments,function*(){let o=null;do o=yield vt(i.next(yield yield vt(Mt(t,o))));while(!o.done)})}(n[Symbol.asyncIterator]()))))),yield vt(new t)})}var N9=t=>zi(Int8Array,t),K9=t=>zi(Int16Array,t),X9=t=>zi(Int32Array,t),Y_=t=>zi(Uint8Array,t),z9=t=>zi(Uint16Array,t),U9=t=>zi(Uint32Array,t),V9=t=>zi(Float32Array,t),Q9=t=>zi(Float64Array,t),W9=t=>zi(Uint8ClampedArray,t);function bg(t,A,j){if(t!==0){j=j.slice(0,A);for(let e=-1,r=j.length;++e0)do if(t[j]!==A[j])return!1;while(++j(t.next(),t);function*Y9(t){let A,j=!1,e=[],r,n,i,o=0;function l(){return n==="peek"?N6(e,i)[0]:([r,e,o]=N6(e,i),r)}({cmd:n,size:i}=(yield null)||{cmd:"read",size:0});let c=W_(t)[Symbol.iterator]();try{do if({done:A,value:r}=Number.isNaN(i-o)?c.next():c.next(i-o),!A&&r.byteLength>0&&(e.push(r),o+=r.byteLength),A||i<=o)do({cmd:n,size:i}=yield l());while(i0&&(r.push(n),l+=n.byteLength),j||o<=l)do({cmd:i,size:o}=yield yield vt(c()));while(o0&&(r.push(it(n)),l+=n.byteLength),j||o<=l)do({cmd:i,size:o}=yield yield vt(c()));while(o{})}get closed(){return this.reader?this.reader.closed.catch(()=>{}):Promise.resolve()}releaseLock(){this.reader&&this.reader.releaseLock(),this.reader=null}cancel(A){return OA(this,void 0,void 0,function*(){let{reader:j,source:e}=this;j&&(yield j.cancel(A).catch(()=>{})),e&&e.locked&&this.releaseLock()})}read(A){return OA(this,void 0,void 0,function*(){if(A===0)return{done:this.reader==null,value:new Uint8Array(0)};let j=yield this.reader.read();return!j.done&&(j.value=it(j)),j})}},Aq=(t,A)=>{let j=r=>e([A,r]),e;return[A,j,new Promise(r=>(e=r)&&t.once(A,j))]};function AV(t){return H6(this,arguments,function*(){let j=[],e="error",r=!1,n=null,i,o,l=0,c=[],B;function h(){return i==="peek"?N6(c,o)[0]:([B,c,l]=N6(c,o),B)}if({cmd:i,size:o}=(yield yield vt(null))||{cmd:"read",size:0},t.isTTY)return yield yield vt(new Uint8Array(0)),yield vt(null);try{j[0]=Aq(t,"end"),j[1]=Aq(t,"error");do{if(j[2]=Aq(t,"readable"),[e,n]=yield vt(Promise.race(j.map(k=>k[2]))),e==="error")break;if((r=e==="end")||(Number.isFinite(o-l)?(B=it(t.read(o-l)),B.byteLength0&&(c.push(B),l+=B.byteLength)),r||o<=l)do({cmd:i,size:o}=yield yield vt(h()));while(o{for(let[y,G]of k)t.off(y,G);try{let y=t.destroy;y&&y.call(t,g),g=void 0}catch(y){g=y||g}finally{g!=null?m(g):E()}})}})}var hj;(function(t){t[t.V1=0]="V1",t[t.V2=1]="V2",t[t.V3=2]="V3",t[t.V4=3]="V4",t[t.V5=4]="V5"})(hj||(hj={}));var Gj;(function(t){t[t.Sparse=0]="Sparse",t[t.Dense=1]="Dense"})(Gj||(Gj={}));var mj;(function(t){t[t.HALF=0]="HALF",t[t.SINGLE=1]="SINGLE",t[t.DOUBLE=2]="DOUBLE"})(mj||(mj={}));var Ce;(function(t){t[t.DAY=0]="DAY",t[t.MILLISECOND=1]="MILLISECOND"})(Ce||(Ce={}));var XA;(function(t){t[t.SECOND=0]="SECOND",t[t.MILLISECOND=1]="MILLISECOND",t[t.MICROSECOND=2]="MICROSECOND",t[t.NANOSECOND=3]="NANOSECOND"})(XA||(XA={}));var hr;(function(t){t[t.YEAR_MONTH=0]="YEAR_MONTH",t[t.DAY_TIME=1]="DAY_TIME",t[t.MONTH_DAY_NANO=2]="MONTH_DAY_NANO"})(hr||(hr={}));var Do=new Int32Array(2),wg=new Float32Array(Do.buffer),Fg=new Float64Array(Do.buffer),xu=new Uint16Array(new Uint8Array([1,0]).buffer)[0]===1;var xh;(function(t){t[t.UTF8_BYTES=1]="UTF8_BYTES",t[t.UTF16_STRING=2]="UTF16_STRING"})(xh||(xh={}));var K6=class t{constructor(A){this.bytes_=A,this.position_=0,this.text_decoder_=new TextDecoder}static allocate(A){return new t(new Uint8Array(A))}clear(){this.position_=0}bytes(){return this.bytes_}position(){return this.position_}setPosition(A){this.position_=A}capacity(){return this.bytes_.length}readInt8(A){return this.readUint8(A)<<24>>24}readUint8(A){return this.bytes_[A]}readInt16(A){return this.readUint16(A)<<16>>16}readUint16(A){return this.bytes_[A]|this.bytes_[A+1]<<8}readInt32(A){return this.bytes_[A]|this.bytes_[A+1]<<8|this.bytes_[A+2]<<16|this.bytes_[A+3]<<24}readUint32(A){return this.readInt32(A)>>>0}readInt64(A){return BigInt.asIntN(64,BigInt(this.readUint32(A))+(BigInt(this.readUint32(A+4))<>8}writeUint16(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8}writeInt32(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8,this.bytes_[A+2]=j>>16,this.bytes_[A+3]=j>>24}writeUint32(A,j){this.bytes_[A]=j,this.bytes_[A+1]=j>>8,this.bytes_[A+2]=j>>16,this.bytes_[A+3]=j>>24}writeInt64(A,j){this.writeInt32(A,Number(BigInt.asIntN(32,j))),this.writeInt32(A+4,Number(BigInt.asIntN(32,j>>BigInt(32))))}writeUint64(A,j){this.writeUint32(A,Number(BigInt.asUintN(32,j))),this.writeUint32(A+4,Number(BigInt.asUintN(32,j>>BigInt(32))))}writeFloat32(A,j){wg[0]=j,this.writeInt32(A,Do[0])}writeFloat64(A,j){Fg[0]=j,this.writeInt32(A,Do[xu?0:1]),this.writeInt32(A+4,Do[xu?1:0])}getBufferIdentifier(){if(this.bytes_.lengththis.minalign&&(this.minalign=A);let e=~(this.bb.capacity()-this.space+j)+1&A-1;for(;this.space=0&&this.vtable[j]==0;j--);let e=j+1;for(;j>=0;j--)this.addInt16(this.vtable[j]!=0?A-this.vtable[j]:0);let r=2;this.addInt16(A-this.object_start);let n=(e+r)*2;this.addInt16(n);let i=0,o=this.space;A:for(j=0;j=0;i--)this.writeInt8(n.charCodeAt(i))}this.prep(this.minalign,4+r),this.addOffset(A),r&&this.addInt32(this.bb.capacity()-this.space),this.bb.setPosition(this.space)}finishSizePrefixed(A,j){this.finish(A,j,!0)}requiredField(A,j){let e=this.bb.capacity()-A,r=e-this.bb.readInt32(e);if(!(j=0;e--)A.addInt32(j[e]);return A.endVector()}static startTypeIdsVector(A,j){A.startVector(4,j,4)}static endUnion(A){return A.endObject()}static createUnion(A,j,e){return t.startUnion(A),t.addMode(A,j),t.addTypeIds(A,e),t.endUnion(A)}};var Mh=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsUtf8(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsUtf8(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static startUtf8(A){A.startObject(0)}static endUtf8(A){return A.endObject()}static createUtf8(A){return t.startUtf8(A),t.endUtf8(A)}};var Ej;(function(t){t[t.NONE=0]="NONE",t[t.Null=1]="Null",t[t.Int=2]="Int",t[t.FloatingPoint=3]="FloatingPoint",t[t.Binary=4]="Binary",t[t.Utf8=5]="Utf8",t[t.Bool=6]="Bool",t[t.Decimal=7]="Decimal",t[t.Date=8]="Date",t[t.Time=9]="Time",t[t.Timestamp=10]="Timestamp",t[t.Interval=11]="Interval",t[t.List=12]="List",t[t.Struct_=13]="Struct_",t[t.Union=14]="Union",t[t.FixedSizeBinary=15]="FixedSizeBinary",t[t.FixedSizeList=16]="FixedSizeList",t[t.Map=17]="Map",t[t.Duration=18]="Duration",t[t.LargeBinary=19]="LargeBinary",t[t.LargeUtf8=20]="LargeUtf8",t[t.LargeList=21]="LargeList",t[t.RunEndEncoded=22]="RunEndEncoded"})(Ej||(Ej={}));var jn=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsField(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsField(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}name(A){let j=this.bb.__offset(this.bb_pos,4);return j?this.bb.__string(this.bb_pos+j,A):null}nullable(){let A=this.bb.__offset(this.bb_pos,6);return A?!!this.bb.readInt8(this.bb_pos+A):!1}typeType(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.readUint8(this.bb_pos+A):Ej.NONE}type(A){let j=this.bb.__offset(this.bb_pos,10);return j?this.bb.__union(A,this.bb_pos+j):null}dictionary(A){let j=this.bb.__offset(this.bb_pos,12);return j?(A||new No).__init(this.bb.__indirect(this.bb_pos+j),this.bb):null}children(A,j){let e=this.bb.__offset(this.bb_pos,14);return e?(j||new t).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}childrenLength(){let A=this.bb.__offset(this.bb_pos,14);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,16);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,16);return A?this.bb.__vector_len(this.bb_pos+A):0}static startField(A){A.startObject(7)}static addName(A,j){A.addFieldOffset(0,j,0)}static addNullable(A,j){A.addFieldInt8(1,+j,0)}static addTypeType(A,j){A.addFieldInt8(2,j,Ej.NONE)}static addType(A,j){A.addFieldOffset(3,j,0)}static addDictionary(A,j){A.addFieldOffset(4,j,0)}static addChildren(A,j){A.addFieldOffset(5,j,0)}static createChildrenVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startChildrenVector(A,j){A.startVector(4,j,4)}static addCustomMetadata(A,j){A.addFieldOffset(6,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endField(A){return A.endObject()}};var p6=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsSchema(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsSchema(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}endianness(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):u7.Little}fields(A,j){let e=this.bb.__offset(this.bb_pos,6);return e?(j||new jn).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}fieldsLength(){let A=this.bb.__offset(this.bb_pos,6);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,8);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.__vector_len(this.bb_pos+A):0}features(A){let j=this.bb.__offset(this.bb_pos,10);return j?this.bb.readInt64(this.bb.__vector(this.bb_pos+j)+A*8):BigInt(0)}featuresLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.__vector_len(this.bb_pos+A):0}static startSchema(A){A.startObject(4)}static addEndianness(A,j){A.addFieldInt16(0,j,u7.Little)}static addFields(A,j){A.addFieldOffset(1,j,0)}static createFieldsVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startFieldsVector(A,j){A.startVector(4,j,4)}static addCustomMetadata(A,j){A.addFieldOffset(2,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static addFeatures(A,j){A.addFieldOffset(3,j,0)}static createFeaturesVector(A,j){A.startVector(8,j.length,8);for(let e=j.length-1;e>=0;e--)A.addInt64(j[e]);return A.endVector()}static startFeaturesVector(A,j){A.startVector(8,j,8)}static endSchema(A){return A.endObject()}static finishSchemaBuffer(A,j){A.finish(j)}static finishSizePrefixedSchemaBuffer(A,j){A.finish(j,void 0,!0)}static createSchema(A,j,e,r,n){return t.startSchema(A),t.addEndianness(A,j),t.addFields(A,e),t.addCustomMetadata(A,r),t.addFeatures(A,n),t.endSchema(A)}};var Lt;(function(t){t[t.NONE=0]="NONE",t[t.Schema=1]="Schema",t[t.DictionaryBatch=2]="DictionaryBatch",t[t.RecordBatch=3]="RecordBatch",t[t.Tensor=4]="Tensor",t[t.SparseTensor=5]="SparseTensor"})(Lt||(Lt={}));var Z;(function(t){t[t.NONE=0]="NONE",t[t.Null=1]="Null",t[t.Int=2]="Int",t[t.Float=3]="Float",t[t.Binary=4]="Binary",t[t.Utf8=5]="Utf8",t[t.Bool=6]="Bool",t[t.Decimal=7]="Decimal",t[t.Date=8]="Date",t[t.Time=9]="Time",t[t.Timestamp=10]="Timestamp",t[t.Interval=11]="Interval",t[t.List=12]="List",t[t.Struct=13]="Struct",t[t.Union=14]="Union",t[t.FixedSizeBinary=15]="FixedSizeBinary",t[t.FixedSizeList=16]="FixedSizeList",t[t.Map=17]="Map",t[t.Duration=18]="Duration",t[t.LargeBinary=19]="LargeBinary",t[t.LargeUtf8=20]="LargeUtf8",t[t.Dictionary=-1]="Dictionary",t[t.Int8=-2]="Int8",t[t.Int16=-3]="Int16",t[t.Int32=-4]="Int32",t[t.Int64=-5]="Int64",t[t.Uint8=-6]="Uint8",t[t.Uint16=-7]="Uint16",t[t.Uint32=-8]="Uint32",t[t.Uint64=-9]="Uint64",t[t.Float16=-10]="Float16",t[t.Float32=-11]="Float32",t[t.Float64=-12]="Float64",t[t.DateDay=-13]="DateDay",t[t.DateMillisecond=-14]="DateMillisecond",t[t.TimestampSecond=-15]="TimestampSecond",t[t.TimestampMillisecond=-16]="TimestampMillisecond",t[t.TimestampMicrosecond=-17]="TimestampMicrosecond",t[t.TimestampNanosecond=-18]="TimestampNanosecond",t[t.TimeSecond=-19]="TimeSecond",t[t.TimeMillisecond=-20]="TimeMillisecond",t[t.TimeMicrosecond=-21]="TimeMicrosecond",t[t.TimeNanosecond=-22]="TimeNanosecond",t[t.DenseUnion=-23]="DenseUnion",t[t.SparseUnion=-24]="SparseUnion",t[t.IntervalDayTime=-25]="IntervalDayTime",t[t.IntervalYearMonth=-26]="IntervalYearMonth",t[t.DurationSecond=-27]="DurationSecond",t[t.DurationMillisecond=-28]="DurationMillisecond",t[t.DurationMicrosecond=-29]="DurationMicrosecond",t[t.DurationNanosecond=-30]="DurationNanosecond"})(Z||(Z={}));var Wi;(function(t){t[t.OFFSET=0]="OFFSET",t[t.DATA=1]="DATA",t[t.VALIDITY=2]="VALIDITY",t[t.TYPE=3]="TYPE"})(Wi||(Wi={}));var mq={};fr(mq,{clampIndex:()=>HV,clampRange:()=>Rh,createElementComparator:()=>$7});var jq={};fr(jq,{valueToString:()=>Yi});function Yi(t){if(t===null)return"null";if(t===void 0)return"undefined";switch(typeof t){case"number":return`${t}`;case"bigint":return`${t}`;case"string":return`"${t}"`}return typeof t[Symbol.toPrimitive]=="function"?t[Symbol.toPrimitive]("string"):ArrayBuffer.isView(t)?t instanceof BigInt64Array||t instanceof BigUint64Array?`[${[...t].map(A=>Yi(A))}]`:`[${t}]`:ArrayBuffer.isView(t)?`[${t}]`:JSON.stringify(t,(A,j)=>typeof j=="bigint"?`${j}`:j)}var rq={};fr(rq,{BN:()=>Th,bigNumToBigInt:()=>O8,bigNumToString:()=>bu,isArrowBigNumSymbol:()=>I8});var I8=Symbol.for("isArrowBigNum");function Ji(t,...A){return A.length===0?Object.setPrototypeOf(Mt(this.TypedArray,t),this.constructor.prototype):Object.setPrototypeOf(new this.TypedArray(t,...A),this.constructor.prototype)}Ji.prototype[I8]=!0;Ji.prototype.toJSON=function(){return`"${bu(this)}"`};Ji.prototype.valueOf=function(){return M8(this)};Ji.prototype.toString=function(){return bu(this)};Ji.prototype[Symbol.toPrimitive]=function(t="default"){switch(t){case"number":return M8(this);case"string":return bu(this);case"default":return O8(this)}return bu(this)};function _u(...t){return Ji.apply(this,t)}function qu(...t){return Ji.apply(this,t)}function Oh(...t){return Ji.apply(this,t)}Object.setPrototypeOf(_u.prototype,Object.create(Int32Array.prototype));Object.setPrototypeOf(qu.prototype,Object.create(Uint32Array.prototype));Object.setPrototypeOf(Oh.prototype,Object.create(Uint32Array.prototype));Object.assign(_u.prototype,Ji.prototype,{constructor:_u,signed:!0,TypedArray:Int32Array,BigIntArray:BigInt64Array});Object.assign(qu.prototype,Ji.prototype,{constructor:qu,signed:!1,TypedArray:Uint32Array,BigIntArray:BigUint64Array});Object.assign(Oh.prototype,Ji.prototype,{constructor:Oh,signed:!0,TypedArray:Uint32Array,BigIntArray:BigUint64Array});function M8(t){let{buffer:A,byteOffset:j,length:e,signed:r}=t,n=new BigUint64Array(A,j,e),i=r&&n.at(-1)&BigInt(1)<{if(t.byteLength===8)return`${new t.BigIntArray(t.buffer,t.byteOffset,1)[0]}`;if(!t.signed)return eq(t);let A=new Uint16Array(t.buffer,t.byteOffset,t.byteLength/2);if(new Int16Array([A.at(-1)])[0]>=0)return eq(t);A=A.slice();let e=1;for(let n=0;nt.byteLength===8?new t.BigIntArray(t.buffer,t.byteOffset,1)[0]:bu(t);function eq(t){let A="",j=new Uint32Array(2),e=new Uint16Array(t.buffer,t.byteOffset,t.byteLength/2),r=new Uint32Array((e=new Uint16Array(e).reverse()).buffer),n=-1,i=e.length-1;do{for(j[0]=e[n=0];nNumber.MAX_SAFE_INTEGER))throw new TypeError(`${t} is not safe to convert to a number.`);return Number(t)}var T8,S8,R8,L8,C8,H8,D8,N8,K8,X8,z8,U8,V8,Q8,W8,Y8,J8,Z8,AM,tM,jM,eM,HA=class t{static isNull(A){return A?.typeId===Z.Null}static isInt(A){return A?.typeId===Z.Int}static isFloat(A){return A?.typeId===Z.Float}static isBinary(A){return A?.typeId===Z.Binary}static isLargeBinary(A){return A?.typeId===Z.LargeBinary}static isUtf8(A){return A?.typeId===Z.Utf8}static isLargeUtf8(A){return A?.typeId===Z.LargeUtf8}static isBool(A){return A?.typeId===Z.Bool}static isDecimal(A){return A?.typeId===Z.Decimal}static isDate(A){return A?.typeId===Z.Date}static isTime(A){return A?.typeId===Z.Time}static isTimestamp(A){return A?.typeId===Z.Timestamp}static isInterval(A){return A?.typeId===Z.Interval}static isDuration(A){return A?.typeId===Z.Duration}static isList(A){return A?.typeId===Z.List}static isStruct(A){return A?.typeId===Z.Struct}static isUnion(A){return A?.typeId===Z.Union}static isFixedSizeBinary(A){return A?.typeId===Z.FixedSizeBinary}static isFixedSizeList(A){return A?.typeId===Z.FixedSizeList}static isMap(A){return A?.typeId===Z.Map}static isDictionary(A){return A?.typeId===Z.Dictionary}static isDenseUnion(A){return t.isUnion(A)&&A.mode===Gj.Dense}static isSparseUnion(A){return t.isUnion(A)&&A.mode===Gj.Sparse}constructor(A){this.typeId=A}};T8=Symbol.toStringTag;HA[T8]=(t=>(t.children=null,t.ArrayType=Array,t.OffsetArrayType=Int32Array,t[Symbol.toStringTag]="DataType"))(HA.prototype);var bn=class extends HA{constructor(){super(Z.Null)}toString(){return"Null"}};S8=Symbol.toStringTag;bn[S8]=(t=>t[Symbol.toStringTag]="Null")(bn.prototype);var qe=class extends HA{constructor(A,j){super(Z.Int),this.isSigned=A,this.bitWidth=j}get ArrayType(){switch(this.bitWidth){case 8:return this.isSigned?Int8Array:Uint8Array;case 16:return this.isSigned?Int16Array:Uint16Array;case 32:return this.isSigned?Int32Array:Uint32Array;case 64:return this.isSigned?BigInt64Array:BigUint64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}toString(){return`${this.isSigned?"I":"Ui"}nt${this.bitWidth}`}};R8=Symbol.toStringTag;qe[R8]=(t=>(t.isSigned=null,t.bitWidth=null,t[Symbol.toStringTag]="Int"))(qe.prototype);var Mg=class extends qe{constructor(){super(!0,8)}get ArrayType(){return Int8Array}},Og=class extends qe{constructor(){super(!0,16)}get ArrayType(){return Int16Array}},Xo=class extends qe{constructor(){super(!0,32)}get ArrayType(){return Int32Array}},Tg=class extends qe{constructor(){super(!0,64)}get ArrayType(){return BigInt64Array}},Sg=class extends qe{constructor(){super(!1,8)}get ArrayType(){return Uint8Array}},Rg=class extends qe{constructor(){super(!1,16)}get ArrayType(){return Uint16Array}},Lg=class extends qe{constructor(){super(!1,32)}get ArrayType(){return Uint32Array}},Cg=class extends qe{constructor(){super(!1,64)}get ArrayType(){return BigUint64Array}};Object.defineProperty(Mg.prototype,"ArrayType",{value:Int8Array});Object.defineProperty(Og.prototype,"ArrayType",{value:Int16Array});Object.defineProperty(Xo.prototype,"ArrayType",{value:Int32Array});Object.defineProperty(Tg.prototype,"ArrayType",{value:BigInt64Array});Object.defineProperty(Sg.prototype,"ArrayType",{value:Uint8Array});Object.defineProperty(Rg.prototype,"ArrayType",{value:Uint16Array});Object.defineProperty(Lg.prototype,"ArrayType",{value:Uint32Array});Object.defineProperty(Cg.prototype,"ArrayType",{value:BigUint64Array});var k6=class extends HA{constructor(A){super(Z.Float),this.precision=A}get ArrayType(){switch(this.precision){case mj.HALF:return Uint16Array;case mj.SINGLE:return Float32Array;case mj.DOUBLE:return Float64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}toString(){return`Float${this.precision<<5||16}`}};L8=Symbol.toStringTag;k6[L8]=(t=>(t.precision=null,t[Symbol.toStringTag]="Float"))(k6.prototype);var Hg=class extends k6{constructor(){super(mj.HALF)}},Dg=class extends k6{constructor(){super(mj.SINGLE)}},Ng=class extends k6{constructor(){super(mj.DOUBLE)}};Object.defineProperty(Hg.prototype,"ArrayType",{value:Uint16Array});Object.defineProperty(Dg.prototype,"ArrayType",{value:Float32Array});Object.defineProperty(Ng.prototype,"ArrayType",{value:Float64Array});var Zs=class extends HA{constructor(){super(Z.Binary)}toString(){return"Binary"}};C8=Symbol.toStringTag;Zs[C8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Binary"))(Zs.prototype);var Aa=class extends HA{constructor(){super(Z.LargeBinary)}toString(){return"LargeBinary"}};H8=Symbol.toStringTag;Aa[H8]=(t=>(t.ArrayType=Uint8Array,t.OffsetArrayType=BigInt64Array,t[Symbol.toStringTag]="LargeBinary"))(Aa.prototype);var ta=class extends HA{constructor(){super(Z.Utf8)}toString(){return"Utf8"}};D8=Symbol.toStringTag;ta[D8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Utf8"))(ta.prototype);var ja=class extends HA{constructor(){super(Z.LargeUtf8)}toString(){return"LargeUtf8"}};N8=Symbol.toStringTag;ja[N8]=(t=>(t.ArrayType=Uint8Array,t.OffsetArrayType=BigInt64Array,t[Symbol.toStringTag]="LargeUtf8"))(ja.prototype);var ea=class extends HA{constructor(){super(Z.Bool)}toString(){return"Bool"}};K8=Symbol.toStringTag;ea[K8]=(t=>(t.ArrayType=Uint8Array,t[Symbol.toStringTag]="Bool"))(ea.prototype);var ra=class extends HA{constructor(A,j,e=128){super(Z.Decimal),this.scale=A,this.precision=j,this.bitWidth=e}toString(){return`Decimal[${this.precision}e${this.scale>0?"+":""}${this.scale}]`}};X8=Symbol.toStringTag;ra[X8]=(t=>(t.scale=null,t.precision=null,t.ArrayType=Uint32Array,t[Symbol.toStringTag]="Decimal"))(ra.prototype);var na=class extends HA{constructor(A){super(Z.Date),this.unit=A}toString(){return`Date${(this.unit+1)*32}<${Ce[this.unit]}>`}};z8=Symbol.toStringTag;na[z8]=(t=>(t.unit=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Date"))(na.prototype);var Zi=class extends HA{constructor(A,j){super(Z.Time),this.unit=A,this.bitWidth=j}toString(){return`Time${this.bitWidth}<${XA[this.unit]}>`}get ArrayType(){switch(this.bitWidth){case 32:return Int32Array;case 64:return BigInt64Array}throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`)}};U8=Symbol.toStringTag;Zi[U8]=(t=>(t.unit=null,t.bitWidth=null,t[Symbol.toStringTag]="Time"))(Zi.prototype);var ia=class extends HA{constructor(A,j){super(Z.Timestamp),this.unit=A,this.timezone=j}toString(){return`Timestamp<${XA[this.unit]}${this.timezone?`, ${this.timezone}`:""}>`}};V8=Symbol.toStringTag;ia[V8]=(t=>(t.unit=null,t.timezone=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Timestamp"))(ia.prototype);var oa=class extends HA{constructor(A){super(Z.Interval),this.unit=A}toString(){return`Interval<${hr[this.unit]}>`}};Q8=Symbol.toStringTag;oa[Q8]=(t=>(t.unit=null,t.ArrayType=Int32Array,t[Symbol.toStringTag]="Interval"))(oa.prototype);var sa=class extends HA{constructor(A){super(Z.Duration),this.unit=A}toString(){return`Duration<${XA[this.unit]}>`}};W8=Symbol.toStringTag;sa[W8]=(t=>(t.unit=null,t.ArrayType=BigInt64Array,t[Symbol.toStringTag]="Duration"))(sa.prototype);var Ao=class extends HA{constructor(A){super(Z.List),this.children=[A]}toString(){return`List<${this.valueType}>`}get valueType(){return this.children[0].type}get valueField(){return this.children[0]}get ArrayType(){return this.valueType.ArrayType}};Y8=Symbol.toStringTag;Ao[Y8]=(t=>(t.children=null,t[Symbol.toStringTag]="List"))(Ao.prototype);var Oj=class extends HA{constructor(A){super(Z.Struct),this.children=A}toString(){return`Struct<{${this.children.map(A=>`${A.name}:${A.type}`).join(", ")}}>`}};J8=Symbol.toStringTag;Oj[J8]=(t=>(t.children=null,t[Symbol.toStringTag]="Struct"))(Oj.prototype);var to=class extends HA{constructor(A,j,e){super(Z.Union),this.mode=A,this.children=e,this.typeIds=j=Int32Array.from(j),this.typeIdToChildIndex=j.reduce((r,n,i)=>(r[n]=i)&&r||r,Object.create(null))}toString(){return`${this[Symbol.toStringTag]}<${this.children.map(A=>`${A.type}`).join(" | ")}>`}};Z8=Symbol.toStringTag;to[Z8]=(t=>(t.mode=null,t.typeIds=null,t.children=null,t.typeIdToChildIndex=null,t.ArrayType=Int8Array,t[Symbol.toStringTag]="Union"))(to.prototype);var aa=class extends HA{constructor(A){super(Z.FixedSizeBinary),this.byteWidth=A}toString(){return`FixedSizeBinary[${this.byteWidth}]`}};AM=Symbol.toStringTag;aa[AM]=(t=>(t.byteWidth=null,t.ArrayType=Uint8Array,t[Symbol.toStringTag]="FixedSizeBinary"))(aa.prototype);var jo=class extends HA{constructor(A,j){super(Z.FixedSizeList),this.listSize=A,this.children=[j]}get valueType(){return this.children[0].type}get valueField(){return this.children[0]}get ArrayType(){return this.valueType.ArrayType}toString(){return`FixedSizeList[${this.listSize}]<${this.valueType}>`}};tM=Symbol.toStringTag;jo[tM]=(t=>(t.children=null,t.listSize=null,t[Symbol.toStringTag]="FixedSizeList"))(jo.prototype);var eo=class extends HA{constructor(A,j=!1){var e,r,n;if(super(Z.Map),this.children=[A],this.keysSorted=j,A&&(A.name="entries",!((e=A?.type)===null||e===void 0)&&e.children)){let i=(r=A?.type)===null||r===void 0?void 0:r.children[0];i&&(i.name="key");let o=(n=A?.type)===null||n===void 0?void 0:n.children[1];o&&(o.name="value")}}get keyType(){return this.children[0].type.children[0].type}get valueType(){return this.children[0].type.children[1].type}get childType(){return this.children[0].type}toString(){return`Map<{${this.children[0].type.children.map(A=>`${A.name}:${A.type}`).join(", ")}}>`}};jM=Symbol.toStringTag;eo[jM]=(t=>(t.children=null,t.keysSorted=null,t[Symbol.toStringTag]="Map_"))(eo.prototype);var tV=(t=>()=>++t)(-1),z6=class extends HA{constructor(A,j,e,r){super(Z.Dictionary),this.indices=j,this.dictionary=A,this.isOrdered=r||!1,this.id=e==null?tV():ee(e)}get children(){return this.dictionary.children}get valueType(){return this.dictionary}get ArrayType(){return this.dictionary.ArrayType}toString(){return`Dictionary<${this.indices}, ${this.dictionary}>`}};eM=Symbol.toStringTag;z6[eM]=(t=>(t.id=null,t.indices=null,t.isOrdered=null,t.dictionary=null,t[Symbol.toStringTag]="Dictionary"))(z6.prototype);function U6(t){let A=t;switch(t.typeId){case Z.Decimal:return t.bitWidth/32;case Z.Timestamp:return 2;case Z.Date:return 1+A.unit;case Z.Interval:return 1+A.unit;case Z.FixedSizeList:return A.listSize;case Z.FixedSizeBinary:return A.byteWidth;default:return 1}}var WA=class{visitMany(A,...j){return A.map((e,r)=>this.visit(e,...j.map(n=>n[r])))}visit(...A){return this.getVisitFn(A[0],!1).apply(this,A)}getVisitFn(A,j=!0){return jV(this,A,j)}getVisitFnByTypeId(A,j=!0){return Gu(this,A,j)}visitNull(A,...j){return null}visitBool(A,...j){return null}visitInt(A,...j){return null}visitFloat(A,...j){return null}visitUtf8(A,...j){return null}visitLargeUtf8(A,...j){return null}visitBinary(A,...j){return null}visitLargeBinary(A,...j){return null}visitFixedSizeBinary(A,...j){return null}visitDate(A,...j){return null}visitTimestamp(A,...j){return null}visitTime(A,...j){return null}visitDecimal(A,...j){return null}visitList(A,...j){return null}visitStruct(A,...j){return null}visitUnion(A,...j){return null}visitDictionary(A,...j){return null}visitInterval(A,...j){return null}visitDuration(A,...j){return null}visitFixedSizeList(A,...j){return null}visitMap(A,...j){return null}};function jV(t,A,j=!0){return typeof A=="number"?Gu(t,A,j):typeof A=="string"&&A in Z?Gu(t,Z[A],j):A&&A instanceof HA?Gu(t,rM(A),j):A?.type&&A.type instanceof HA?Gu(t,rM(A.type),j):Gu(t,Z.NONE,j)}function Gu(t,A,j=!0){let e=null;switch(A){case Z.Null:e=t.visitNull;break;case Z.Bool:e=t.visitBool;break;case Z.Int:e=t.visitInt;break;case Z.Int8:e=t.visitInt8||t.visitInt;break;case Z.Int16:e=t.visitInt16||t.visitInt;break;case Z.Int32:e=t.visitInt32||t.visitInt;break;case Z.Int64:e=t.visitInt64||t.visitInt;break;case Z.Uint8:e=t.visitUint8||t.visitInt;break;case Z.Uint16:e=t.visitUint16||t.visitInt;break;case Z.Uint32:e=t.visitUint32||t.visitInt;break;case Z.Uint64:e=t.visitUint64||t.visitInt;break;case Z.Float:e=t.visitFloat;break;case Z.Float16:e=t.visitFloat16||t.visitFloat;break;case Z.Float32:e=t.visitFloat32||t.visitFloat;break;case Z.Float64:e=t.visitFloat64||t.visitFloat;break;case Z.Utf8:e=t.visitUtf8;break;case Z.LargeUtf8:e=t.visitLargeUtf8;break;case Z.Binary:e=t.visitBinary;break;case Z.LargeBinary:e=t.visitLargeBinary;break;case Z.FixedSizeBinary:e=t.visitFixedSizeBinary;break;case Z.Date:e=t.visitDate;break;case Z.DateDay:e=t.visitDateDay||t.visitDate;break;case Z.DateMillisecond:e=t.visitDateMillisecond||t.visitDate;break;case Z.Timestamp:e=t.visitTimestamp;break;case Z.TimestampSecond:e=t.visitTimestampSecond||t.visitTimestamp;break;case Z.TimestampMillisecond:e=t.visitTimestampMillisecond||t.visitTimestamp;break;case Z.TimestampMicrosecond:e=t.visitTimestampMicrosecond||t.visitTimestamp;break;case Z.TimestampNanosecond:e=t.visitTimestampNanosecond||t.visitTimestamp;break;case Z.Time:e=t.visitTime;break;case Z.TimeSecond:e=t.visitTimeSecond||t.visitTime;break;case Z.TimeMillisecond:e=t.visitTimeMillisecond||t.visitTime;break;case Z.TimeMicrosecond:e=t.visitTimeMicrosecond||t.visitTime;break;case Z.TimeNanosecond:e=t.visitTimeNanosecond||t.visitTime;break;case Z.Decimal:e=t.visitDecimal;break;case Z.List:e=t.visitList;break;case Z.Struct:e=t.visitStruct;break;case Z.Union:e=t.visitUnion;break;case Z.DenseUnion:e=t.visitDenseUnion||t.visitUnion;break;case Z.SparseUnion:e=t.visitSparseUnion||t.visitUnion;break;case Z.Dictionary:e=t.visitDictionary;break;case Z.Interval:e=t.visitInterval;break;case Z.IntervalDayTime:e=t.visitIntervalDayTime||t.visitInterval;break;case Z.IntervalYearMonth:e=t.visitIntervalYearMonth||t.visitInterval;break;case Z.Duration:e=t.visitDuration;break;case Z.DurationSecond:e=t.visitDurationSecond||t.visitDuration;break;case Z.DurationMillisecond:e=t.visitDurationMillisecond||t.visitDuration;break;case Z.DurationMicrosecond:e=t.visitDurationMicrosecond||t.visitDuration;break;case Z.DurationNanosecond:e=t.visitDurationNanosecond||t.visitDuration;break;case Z.FixedSizeList:e=t.visitFixedSizeList;break;case Z.Map:e=t.visitMap;break}if(typeof e=="function")return e;if(!j)return()=>null;throw new Error(`Unrecognized type '${Z[A]}'`)}function rM(t){switch(t.typeId){case Z.Null:return Z.Null;case Z.Int:{let{bitWidth:A,isSigned:j}=t;switch(A){case 8:return j?Z.Int8:Z.Uint8;case 16:return j?Z.Int16:Z.Uint16;case 32:return j?Z.Int32:Z.Uint32;case 64:return j?Z.Int64:Z.Uint64}return Z.Int}case Z.Float:switch(t.precision){case mj.HALF:return Z.Float16;case mj.SINGLE:return Z.Float32;case mj.DOUBLE:return Z.Float64}return Z.Float;case Z.Binary:return Z.Binary;case Z.LargeBinary:return Z.LargeBinary;case Z.Utf8:return Z.Utf8;case Z.LargeUtf8:return Z.LargeUtf8;case Z.Bool:return Z.Bool;case Z.Decimal:return Z.Decimal;case Z.Time:switch(t.unit){case XA.SECOND:return Z.TimeSecond;case XA.MILLISECOND:return Z.TimeMillisecond;case XA.MICROSECOND:return Z.TimeMicrosecond;case XA.NANOSECOND:return Z.TimeNanosecond}return Z.Time;case Z.Timestamp:switch(t.unit){case XA.SECOND:return Z.TimestampSecond;case XA.MILLISECOND:return Z.TimestampMillisecond;case XA.MICROSECOND:return Z.TimestampMicrosecond;case XA.NANOSECOND:return Z.TimestampNanosecond}return Z.Timestamp;case Z.Date:switch(t.unit){case Ce.DAY:return Z.DateDay;case Ce.MILLISECOND:return Z.DateMillisecond}return Z.Date;case Z.Interval:switch(t.unit){case hr.DAY_TIME:return Z.IntervalDayTime;case hr.YEAR_MONTH:return Z.IntervalYearMonth}return Z.Interval;case Z.Duration:switch(t.unit){case XA.SECOND:return Z.DurationSecond;case XA.MILLISECOND:return Z.DurationMillisecond;case XA.MICROSECOND:return Z.DurationMicrosecond;case XA.NANOSECOND:return Z.DurationNanosecond}return Z.Duration;case Z.Map:return Z.Map;case Z.List:return Z.List;case Z.Struct:return Z.Struct;case Z.Union:switch(t.mode){case Gj.Dense:return Z.DenseUnion;case Gj.Sparse:return Z.SparseUnion}return Z.Union;case Z.FixedSizeBinary:return Z.FixedSizeBinary;case Z.FixedSizeList:return Z.FixedSizeList;case Z.Dictionary:return Z.Dictionary}throw new Error(`Unrecognized type '${Z[t.typeId]}'`)}WA.prototype.visitInt8=null;WA.prototype.visitInt16=null;WA.prototype.visitInt32=null;WA.prototype.visitInt64=null;WA.prototype.visitUint8=null;WA.prototype.visitUint16=null;WA.prototype.visitUint32=null;WA.prototype.visitUint64=null;WA.prototype.visitFloat16=null;WA.prototype.visitFloat32=null;WA.prototype.visitFloat64=null;WA.prototype.visitDateDay=null;WA.prototype.visitDateMillisecond=null;WA.prototype.visitTimestampSecond=null;WA.prototype.visitTimestampMillisecond=null;WA.prototype.visitTimestampMicrosecond=null;WA.prototype.visitTimestampNanosecond=null;WA.prototype.visitTimeSecond=null;WA.prototype.visitTimeMillisecond=null;WA.prototype.visitTimeMicrosecond=null;WA.prototype.visitTimeNanosecond=null;WA.prototype.visitDenseUnion=null;WA.prototype.visitSparseUnion=null;WA.prototype.visitIntervalDayTime=null;WA.prototype.visitIntervalYearMonth=null;WA.prototype.visitDuration=null;WA.prototype.visitDurationSecond=null;WA.prototype.visitDurationMillisecond=null;WA.prototype.visitDurationMicrosecond=null;WA.prototype.visitDurationNanosecond=null;var nq={};fr(nq,{float64ToUint16:()=>Sh,uint16ToFloat64:()=>Kg});var nM=new Float64Array(1),wu=new Uint32Array(nM.buffer);function Kg(t){let A=(t&31744)>>10,j=(t&1023)/1024,e=Math.pow(-1,(t&32768)>>15);switch(A){case 31:return e*(j?Number.NaN:1/0);case 0:return e*(j?6103515625e-14*j:0)}return e*Math.pow(2,A-15)*(1+j)}function Sh(t){if(t!==t)return 32256;nM[0]=t;let A=(wu[1]&2147483648)>>16&65535,j=wu[1]&2146435072,e=0;return j>=1089470464?wu[0]>0?j=31744:(j=(j&2080374784)>>16,e=(wu[1]&1048575)>>10):j<=1056964608?(e=1048576+(wu[1]&1048575),e=1048576+(e<<(j>>20)-998)>>21,j=0):(j=j-1056964608>>10,e=(wu[1]&1048575)+512>>10),A|j|e&65535}var et=class extends WA{};function Bt(t){return(A,j,e)=>{if(A.setValid(j,e!=null))return t(A,j,e)}}var eV=(t,A,j)=>{t[A]=Math.trunc(j/864e5)},iq=(t,A,j)=>{t[A]=Math.trunc(j%4294967296),t[A+1]=Math.trunc(j/4294967296)},rV=(t,A,j)=>{t[A]=Math.trunc(j*1e3%4294967296),t[A+1]=Math.trunc(j*1e3/4294967296)},nV=(t,A,j)=>{t[A]=Math.trunc(j*1e6%4294967296),t[A+1]=Math.trunc(j*1e6/4294967296)},iM=(t,A,j,e)=>{if(j+1{let r=t+j;e?A[r>>3]|=1<>3]&=~(1<{t[A]=j},oq=({values:t},A,j)=>{t[A]=j},oM=({values:t},A,j)=>{t[A]=Sh(j)},oV=(t,A,j)=>{switch(t.type.precision){case mj.HALF:return oM(t,A,j);case mj.SINGLE:case mj.DOUBLE:return oq(t,A,j)}},Xg=({values:t},A,j)=>{eV(t,A,j.valueOf())},zg=({values:t},A,j)=>{iq(t,A*2,j.valueOf())},sq=({stride:t,values:A},j,e)=>{A.set(e.subarray(0,t),t*j)},sM=({values:t,valueOffsets:A},j,e)=>iM(t,A,j,e),aM=({values:t,valueOffsets:A},j,e)=>iM(t,A,j,Co(e)),aq=(t,A,j)=>{t.type.unit===Ce.DAY?Xg(t,A,j):zg(t,A,j)},Ug=({values:t},A,j)=>iq(t,A*2,j/1e3),Vg=({values:t},A,j)=>iq(t,A*2,j),Qg=({values:t},A,j)=>rV(t,A*2,j),Wg=({values:t},A,j)=>nV(t,A*2,j),lq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return Ug(t,A,j);case XA.MILLISECOND:return Vg(t,A,j);case XA.MICROSECOND:return Qg(t,A,j);case XA.NANOSECOND:return Wg(t,A,j)}},Yg=({values:t},A,j)=>{t[A]=j},Jg=({values:t},A,j)=>{t[A]=j},Zg=({values:t},A,j)=>{t[A]=j},Am=({values:t},A,j)=>{t[A]=j},cq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return Yg(t,A,j);case XA.MILLISECOND:return Jg(t,A,j);case XA.MICROSECOND:return Zg(t,A,j);case XA.NANOSECOND:return Am(t,A,j)}},uq=({values:t,stride:A},j,e)=>{t.set(e.subarray(0,A),A*j)},sV=(t,A,j)=>{let e=t.children[0],r=t.valueOffsets,n=Or.getVisitFn(e);if(Array.isArray(j))for(let i=-1,o=r[A],l=r[A+1];o{let e=t.children[0],{valueOffsets:r}=t,n=Or.getVisitFn(e),{[A]:i,[A+1]:o}=r,l=j instanceof Map?j.entries():Object.entries(j);for(let c of l)if(n(e,i,c),++i>=o)break},lV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A[n]),cV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A.get(n)),uV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A.get(r.name)),BV=(t,A)=>(j,e,r,n)=>e&&j(e,t,A[r.name]),fV=(t,A,j)=>{let e=t.type.children.map(n=>Or.getVisitFn(n.type)),r=j instanceof Map?uV(A,j):j instanceof Dt?cV(A,j):Array.isArray(j)?lV(A,j):BV(A,j);t.type.children.forEach((n,i)=>r(e[i],t.children[i],n,i))},hV=(t,A,j)=>{t.type.mode===Gj.Dense?lM(t,A,j):cM(t,A,j)},lM=(t,A,j)=>{let e=t.type.typeIdToChildIndex[t.typeIds[A]],r=t.children[e];Or.visit(r,t.valueOffsets[A],j)},cM=(t,A,j)=>{let e=t.type.typeIdToChildIndex[t.typeIds[A]],r=t.children[e];Or.visit(r,A,j)},dV=(t,A,j)=>{var e;(e=t.dictionary)===null||e===void 0||e.set(t.values[A],j)},Bq=(t,A,j)=>{t.type.unit===hr.DAY_TIME?tm(t,A,j):jm(t,A,j)},tm=({values:t},A,j)=>{t.set(j.subarray(0,2),2*A)},jm=({values:t},A,j)=>{t[A]=j[0]*12+j[1]%12},em=({values:t},A,j)=>{t[A]=j},rm=({values:t},A,j)=>{t[A]=j},nm=({values:t},A,j)=>{t[A]=j},im=({values:t},A,j)=>{t[A]=j},fq=(t,A,j)=>{switch(t.type.unit){case XA.SECOND:return em(t,A,j);case XA.MILLISECOND:return rm(t,A,j);case XA.MICROSECOND:return nm(t,A,j);case XA.NANOSECOND:return im(t,A,j)}},pV=(t,A,j)=>{let{stride:e}=t,r=t.children[0],n=Or.getVisitFn(r);if(Array.isArray(j))for(let i=-1,o=A*e;++i`${Yi(A)}: ${Yi(j)}`).join(", ")}}`}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}[Symbol.iterator](){return new hq(this[ro],this[Fu])}},hq=class{constructor(A,j){this.childIndex=0,this.children=A.children,this.rowIndex=j,this.childFields=A.type.children,this.numChildren=this.childFields.length}[Symbol.iterator](){return this}next(){let A=this.childIndex;return Aj.name)}has(A,j){return A[ro].type.children.findIndex(e=>e.name===j)!==-1}getOwnPropertyDescriptor(A,j){if(A[ro].type.children.findIndex(e=>e.name===j)!==-1)return{writable:!0,enumerable:!0,configurable:!0}}get(A,j){if(Reflect.has(A,j))return A[j];let e=A[ro].type.children.findIndex(r=>r.name===j);if(e!==-1){let r=He.visit(A[ro].children[e],A[Fu]);return Reflect.set(A,j,r),r}}set(A,j,e){let r=A[ro].type.children.findIndex(n=>n.name===j);return r!==-1?(Or.visit(A[ro].children[r],A[Fu],e),Reflect.set(A,j,e)):Reflect.has(A,j)||typeof j=="symbol"?Reflect.set(A,j,e):!1}};var YA=class extends WA{};function lt(t){return(A,j)=>A.getValid(j)?t(A,j):null}var kV=(t,A)=>864e5*t[A],pq=(t,A)=>4294967296*t[A+1]+(t[A]>>>0),gV=(t,A)=>4294967296*(t[A+1]/1e3)+(t[A]>>>0)/1e3,mV=(t,A)=>4294967296*(t[A+1]/1e6)+(t[A]>>>0)/1e6,uM=t=>new Date(t),EV=(t,A)=>uM(kV(t,A)),$V=(t,A)=>uM(pq(t,A)),xV=(t,A)=>null,BM=(t,A,j)=>{if(j+1>=A.length)return null;let e=ee(A[j]),r=ee(A[j+1]);return t.subarray(e,r)},yV=({offset:t,values:A},j)=>{let e=t+j;return(A[e>>3]&1<EV(t,A),hM=({values:t},A)=>$V(t,A*2),E7=({stride:t,values:A},j)=>A[t*j],vV=({stride:t,values:A},j)=>Kg(A[t*j]),dM=({values:t},A)=>t[A],_V=({stride:t,values:A},j)=>A.subarray(t*j,t*(j+1)),pM=({values:t,valueOffsets:A},j)=>BM(t,A,j),kM=({values:t,valueOffsets:A},j)=>{let e=BM(t,A,j);return e!==null?mh(e):null},qV=({values:t},A)=>t[A],bV=({type:t,values:A},j)=>t.precision!==mj.HALF?A[j]:Kg(A[j]),GV=(t,A)=>t.type.unit===Ce.DAY?fM(t,A):hM(t,A),gM=({values:t},A)=>1e3*pq(t,A*2),mM=({values:t},A)=>pq(t,A*2),EM=({values:t},A)=>gV(t,A*2),$M=({values:t},A)=>mV(t,A*2),wV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return gM(t,A);case XA.MILLISECOND:return mM(t,A);case XA.MICROSECOND:return EM(t,A);case XA.NANOSECOND:return $M(t,A)}},xM=({values:t},A)=>t[A],yM=({values:t},A)=>t[A],vM=({values:t},A)=>t[A],_M=({values:t},A)=>t[A],FV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return xM(t,A);case XA.MILLISECOND:return yM(t,A);case XA.MICROSECOND:return vM(t,A);case XA.NANOSECOND:return _M(t,A)}},PV=({values:t,stride:A},j)=>Th.decimal(t.subarray(A*j,A*(j+1))),IV=(t,A)=>{let{valueOffsets:j,stride:e,children:r}=t,{[A*e]:n,[A*e+1]:i}=j,l=r[0].slice(n,i-n);return new Dt([l])},MV=(t,A)=>{let{valueOffsets:j,children:e}=t,{[A]:r,[A+1]:n}=j,i=e[0];return new zo(i.slice(r,n-r))},OV=(t,A)=>new m7(t,A),TV=(t,A)=>t.type.mode===Gj.Dense?qM(t,A):bM(t,A),qM=(t,A)=>{let j=t.type.typeIdToChildIndex[t.typeIds[A]],e=t.children[j];return He.visit(e,t.valueOffsets[A])},bM=(t,A)=>{let j=t.type.typeIdToChildIndex[t.typeIds[A]],e=t.children[j];return He.visit(e,A)},SV=(t,A)=>{var j;return(j=t.dictionary)===null||j===void 0?void 0:j.get(t.values[A])},RV=(t,A)=>t.type.unit===hr.DAY_TIME?GM(t,A):wM(t,A),GM=({values:t},A)=>t.subarray(2*A,2*(A+1)),wM=({values:t},A)=>{let j=t[A],e=new Int32Array(2);return e[0]=Math.trunc(j/12),e[1]=Math.trunc(j%12),e},FM=({values:t},A)=>t[A],PM=({values:t},A)=>t[A],IM=({values:t},A)=>t[A],MM=({values:t},A)=>t[A],LV=(t,A)=>{switch(t.type.unit){case XA.SECOND:return FM(t,A);case XA.MILLISECOND:return PM(t,A);case XA.MICROSECOND:return IM(t,A);case XA.NANOSECOND:return MM(t,A)}},CV=(t,A)=>{let{stride:j,children:e}=t,n=e[0].slice(A*j,j);return new Dt([n])};YA.prototype.visitNull=lt(xV);YA.prototype.visitBool=lt(yV);YA.prototype.visitInt=lt(qV);YA.prototype.visitInt8=lt(E7);YA.prototype.visitInt16=lt(E7);YA.prototype.visitInt32=lt(E7);YA.prototype.visitInt64=lt(dM);YA.prototype.visitUint8=lt(E7);YA.prototype.visitUint16=lt(E7);YA.prototype.visitUint32=lt(E7);YA.prototype.visitUint64=lt(dM);YA.prototype.visitFloat=lt(bV);YA.prototype.visitFloat16=lt(vV);YA.prototype.visitFloat32=lt(E7);YA.prototype.visitFloat64=lt(E7);YA.prototype.visitUtf8=lt(kM);YA.prototype.visitLargeUtf8=lt(kM);YA.prototype.visitBinary=lt(pM);YA.prototype.visitLargeBinary=lt(pM);YA.prototype.visitFixedSizeBinary=lt(_V);YA.prototype.visitDate=lt(GV);YA.prototype.visitDateDay=lt(fM);YA.prototype.visitDateMillisecond=lt(hM);YA.prototype.visitTimestamp=lt(wV);YA.prototype.visitTimestampSecond=lt(gM);YA.prototype.visitTimestampMillisecond=lt(mM);YA.prototype.visitTimestampMicrosecond=lt(EM);YA.prototype.visitTimestampNanosecond=lt($M);YA.prototype.visitTime=lt(FV);YA.prototype.visitTimeSecond=lt(xM);YA.prototype.visitTimeMillisecond=lt(yM);YA.prototype.visitTimeMicrosecond=lt(vM);YA.prototype.visitTimeNanosecond=lt(_M);YA.prototype.visitDecimal=lt(PV);YA.prototype.visitList=lt(IV);YA.prototype.visitStruct=lt(OV);YA.prototype.visitUnion=lt(TV);YA.prototype.visitDenseUnion=lt(qM);YA.prototype.visitSparseUnion=lt(bM);YA.prototype.visitDictionary=lt(SV);YA.prototype.visitInterval=lt(RV);YA.prototype.visitIntervalDayTime=lt(GM);YA.prototype.visitIntervalYearMonth=lt(wM);YA.prototype.visitDuration=lt(LV);YA.prototype.visitDurationSecond=lt(FM);YA.prototype.visitDurationMillisecond=lt(PM);YA.prototype.visitDurationMicrosecond=lt(IM);YA.prototype.visitDurationNanosecond=lt(MM);YA.prototype.visitFixedSizeList=lt(CV);YA.prototype.visitMap=lt(MV);var He=new YA;var hi=Symbol.for("keys"),Pu=Symbol.for("vals"),zo=class{constructor(A){return this[hi]=new Dt([A.children[0]]).memoize(),this[Pu]=A.children[1],new Proxy(this,new gq)}[Symbol.iterator](){return new kq(this[hi],this[Pu])}get size(){return this[hi].length}toArray(){return Object.values(this.toJSON())}toJSON(){let A=this[hi],j=this[Pu],e={};for(let r=-1,n=A.length;++r`${Yi(A)}: ${Yi(j)}`).join(", ")}}`}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}},kq=class{constructor(A,j){this.keys=A,this.vals=j,this.keyIndex=0,this.numKeys=A.length}[Symbol.iterator](){return this}next(){let A=this.keyIndex;return A===this.numKeys?{done:!0,value:null}:(this.keyIndex++,{done:!1,value:[this.keys.get(A),He.visit(this.vals,A)]})}},gq=class{isExtensible(){return!1}deleteProperty(){return!1}preventExtensions(){return!0}ownKeys(A){return A[hi].toArray().map(String)}has(A,j){return A[hi].includes(j)}getOwnPropertyDescriptor(A,j){if(A[hi].indexOf(j)!==-1)return{writable:!0,enumerable:!0,configurable:!0}}get(A,j){if(Reflect.has(A,j))return A[j];let e=A[hi].indexOf(j);if(e!==-1){let r=He.visit(Reflect.get(A,Pu),e);return Reflect.set(A,j,r),r}}set(A,j,e){let r=A[hi].indexOf(j);return r!==-1?(Or.visit(Reflect.get(A,Pu),r,e),Reflect.set(A,j,e)):Reflect.has(A,j)?Reflect.set(A,j,e):!1}};Object.defineProperties(zo.prototype,{[Symbol.toStringTag]:{enumerable:!1,configurable:!1,value:"Row"},[hi]:{writable:!0,enumerable:!1,configurable:!1,value:null},[Pu]:{writable:!0,enumerable:!1,configurable:!1,value:null}});function HV(t,A,j){let e=t.length,r=A>-1?A:e+A%e;return j?j(t,r):r}var OM;function Rh(t,A,j,e){let{length:r=0}=t,n=typeof A!="number"?0:A,i=typeof j!="number"?r:j;return n<0&&(n=(n%r+r)%r),i<0&&(i=(i%r+r)%r),ir&&(i=r),e?e(t,n,i):[n,i]}var TM=t=>t!==t;function $7(t){if(typeof t!=="object"||t===null)return TM(t)?TM:j=>j===t;if(t instanceof Date){let j=t.valueOf();return e=>e instanceof Date?e.valueOf()===j:!1}return ArrayBuffer.isView(t)?j=>j?J_(t,j):!1:t instanceof Map?NV(t):Array.isArray(t)?DV(t):t instanceof Dt?KV(t):XV(t,!0)}function DV(t){let A=[];for(let j=-1,e=t.length;++j!1;let e=[];for(let r=-1,n=j.length;++r{if(!j||typeof j!="object")return!1;switch(j.constructor){case Array:return zV(t,j);case Map:return SM(t,j,j.keys());case zo:case m7:case Object:case void 0:return SM(t,j,A||Object.keys(j))}return j instanceof Dt?UV(t,j):!1}}function zV(t,A){let j=t.length;if(A.length!==j)return!1;for(let e=-1;++eHl,getBit:()=>RM,getBool:()=>am,packBools:()=>Nl,popcnt_array:()=>LM,popcnt_bit_range:()=>Lh,popcnt_uint32:()=>sm,setBool:()=>VV,truncateBitmap:()=>Dl});function am(t,A,j,e){return(j&1<>e}function VV(t,A,j){return j?!!(t[A>>3]|=1<>3]&=~(1<0||j.byteLength>3):Nl(new Hl(j,t,A,null,am)).subarray(0,e)),r}return j}function Nl(t){let A=[],j=0,e=0,r=0;for(let i of t)i&&(r|=1<0)&&(A[j++]=r);let n=new Uint8Array(A.length+7&-8);return n.set(A),n}var Hl=class{constructor(A,j,e,r,n){this.bytes=A,this.length=e,this.context=r,this.get=n,this.bit=j%8,this.byteIndex=j>>3,this.byte=A[this.byteIndex++],this.index=0}next(){return this.index>3<<3,r=A+(A%8===0?0:8-A%8);return Lh(t,A,r)+Lh(t,e,j)+LM(t,r>>3,e-r>>3)}function LM(t,A,j){let e=0,r=Math.trunc(A),n=new DataView(t.buffer,t.byteOffset,t.byteLength),i=j===void 0?t.byteLength:r+j;for(;i-r>=4;)e+=sm(n.getUint32(r)),r+=4;for(;i-r>=2;)e+=sm(n.getUint16(r)),r+=2;for(;i-r>=1;)e+=sm(n.getUint8(r)),r+=1;return e}function sm(t){let A=Math.trunc(t);return A=A-(A>>>1&1431655765),A=(A&858993459)+(A>>>2&858993459),(A+(A>>>4)&252645135)*16843009>>>24}var QV=-1,rj=class t{get typeId(){return this.type.typeId}get ArrayType(){return this.type.ArrayType}get buffers(){return[this.valueOffsets,this.values,this.nullBitmap,this.typeIds]}get nullable(){if(this._nullCount!==0){let{type:A}=this;return HA.isSparseUnion(A)?this.children.some(j=>j.nullable):HA.isDenseUnion(A)?this.children.some(j=>j.nullable):this.nullBitmap&&this.nullBitmap.byteLength>0}return!0}get byteLength(){let A=0,{valueOffsets:j,values:e,nullBitmap:r,typeIds:n}=this;return j&&(A+=j.byteLength),e&&(A+=e.byteLength),r&&(A+=r.byteLength),n&&(A+=n.byteLength),this.children.reduce((i,o)=>i+o.byteLength,A)}get nullCount(){if(HA.isUnion(this.type))return this.children.reduce((e,r)=>e+r.nullCount,0);let A=this._nullCount,j;return A<=QV&&(j=this.nullBitmap)&&(this._nullCount=A=this.length-Lh(j,this.offset,this.offset+this.length)),A}constructor(A,j,e,r,n,i=[],o){this.type=A,this.children=i,this.dictionary=o,this.offset=Math.floor(Math.max(j||0,0)),this.length=Math.floor(Math.max(e||0,0)),this._nullCount=Math.floor(Math.max(r||0,-1));let l;n instanceof t?(this.stride=n.stride,this.values=n.values,this.typeIds=n.typeIds,this.nullBitmap=n.nullBitmap,this.valueOffsets=n.valueOffsets):(this.stride=U6(A),n&&((l=n[0])&&(this.valueOffsets=l),(l=n[1])&&(this.values=l),(l=n[2])&&(this.nullBitmap=l),(l=n[3])&&(this.typeIds=l)))}getValid(A){let{type:j}=this;if(HA.isUnion(j)){let e=j,r=this.children[e.typeIdToChildIndex[this.typeIds[A]]],n=e.mode===Gj.Dense?this.valueOffsets[A]:A;return r.getValid(n)}if(this.nullable&&this.nullCount>0){let e=this.offset+A;return(this.nullBitmap[e>>3]&1<>3;(!n||n.byteLength<=B)&&(n=new Uint8Array((i+o+63&-64)>>3).fill(255),this.nullCount>0&&n.set(Dl(i,o,this.nullBitmap),0),Object.assign(this,{nullBitmap:n,_nullCount:-1}));let h=n[B];e=(h&c)!==0,j?n[B]=h|c:n[B]=h&~c}return e!==!!j&&(this._nullCount=this.nullCount+(j?-1:1)),j}clone(A=this.type,j=this.offset,e=this.length,r=this._nullCount,n=this,i=this.children){return new t(A,j,e,r,n,i,this.dictionary)}slice(A,j){let{stride:e,typeId:r,children:n}=this,i=+(this._nullCount===0)-1,o=r===16?e:1,l=this._sliceBuffers(A,j,e,r);return this.clone(this.type,this.offset+A,j,i,l,n.length===0||this.valueOffsets?n:this._sliceChildren(n,o*A,o*j))}_changeLengthAndBackfillNullBitmap(A){if(this.typeId===Z.Null)return this.clone(this.type,0,A,0);let{length:j,nullCount:e}=this,r=new Uint8Array((A+63&-64)>>3).fill(255,0,j>>3);r[j>>3]=(1<0&&r.set(Dl(this.offset,j,this.nullBitmap),0);let n=this.buffers;return n[Wi.VALIDITY]=r,this.clone(this.type,0,A,e+(A-j),n)}_sliceBuffers(A,j,e,r){let n,{buffers:i}=this;return(n=i[Wi.TYPE])&&(i[Wi.TYPE]=n.subarray(A,A+j)),(n=i[Wi.OFFSET])&&(i[Wi.OFFSET]=n.subarray(A,A+j+1))||(n=i[Wi.DATA])&&(i[Wi.DATA]=r===6?n:n.subarray(e*A,e*(A+j))),i}_sliceChildren(A,j,e){return A.map(r=>r.slice(j,e))}};rj.prototype.children=Object.freeze([]);var $q=class t extends WA{visit(A){return this.getVisitFn(A.type).call(this,A)}visitNull(A){let{["type"]:j,["offset"]:e=0,["length"]:r=0}=A;return new rj(j,e,r,r)}visitBool(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length>>3,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitInt(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitFloat(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitUtf8(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=Ll(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitLargeUtf8(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=qg(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=Ll(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitLargeBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.data),n=it(A.nullBitmap),i=qg(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,r,n])}visitFixedSizeBinary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDate(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitTimestamp(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitTime(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDecimal(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitList(A){let{["type"]:j,["offset"]:e=0,["child"]:r}=A,n=it(A.nullBitmap),i=Ll(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,void 0,n],[r])}visitStruct(A){let{["type"]:j,["offset"]:e=0,["children"]:r=[]}=A,n=it(A.nullBitmap),{length:i=r.reduce((l,{length:c})=>Math.max(l,c),0),nullCount:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,void 0,n],r)}visitUnion(A){let{["type"]:j,["offset"]:e=0,["children"]:r=[]}=A,n=Mt(j.ArrayType,A.typeIds),{["length"]:i=n.length,["nullCount"]:o=-1}=A;if(HA.isSparseUnion(j))return new rj(j,e,i,o,[void 0,void 0,void 0,n],r);let l=Ll(A.valueOffsets);return new rj(j,e,i,o,[l,void 0,void 0,n],r)}visitDictionary(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.indices.ArrayType,A.data),{["dictionary"]:i=new Dt([new t().visit({type:j.dictionary})])}=A,{["length"]:o=n.length,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[void 0,n,r],[],i)}visitInterval(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitDuration(A){let{["type"]:j,["offset"]:e=0}=A,r=it(A.nullBitmap),n=Mt(j.ArrayType,A.data),{["length"]:i=n.length,["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,n,r])}visitFixedSizeList(A){let{["type"]:j,["offset"]:e=0,["child"]:r=new t().visit({type:j.valueType})}=A,n=it(A.nullBitmap),{["length"]:i=r.length/U6(j),["nullCount"]:o=A.nullBitmap?-1:0}=A;return new rj(j,e,i,o,[void 0,void 0,n],[r])}visitMap(A){let{["type"]:j,["offset"]:e=0,["child"]:r=new t().visit({type:j.childType})}=A,n=it(A.nullBitmap),i=Ll(A.valueOffsets),{["length"]:o=i.length-1,["nullCount"]:l=A.nullBitmap?-1:0}=A;return new rj(j,e,o,l,[i,void 0,n],[r])}},WV=new $q;function ht(t){return WV.visit(t)}var Ch=class{constructor(A=0,j){this.numChunks=A,this.getChunkIterator=j,this.chunkIndex=0,this.chunkIterator=this.getChunkIterator(0)}next(){for(;this.chunkIndexA.nullable)}function lm(t){return t.reduce((A,j)=>A+j.nullCount,0)}function cm(t){return t.reduce((A,j,e)=>(A[e+1]=A[e]+j.length,A),new Uint32Array(t.length+1))}function um(t,A,j,e){let r=[];for(let n=-1,i=t.length;++n=e)break;if(j>=l+c)continue;if(l>=j&&l+c<=e){r.push(o);continue}let B=Math.max(0,j-l),h=Math.min(e-l,c);r.push(o.slice(B,h-B))}return r.length===0&&r.push(t[0].slice(0,0)),r}function xq(t,A,j,e){let r=0,n=0,i=A.length-1;do{if(r>=i-1)return j0?0:-1}function JV(t,A){let{nullBitmap:j}=t;if(!j||t.nullCount<=0)return-1;let e=0;for(let r of new Hl(j,t.offset+(A||0),t.length,j,am)){if(!r)return e;++e}return-1}function dt(t,A,j){if(A===void 0)return-1;if(A===null)switch(t.typeId){case Z.Union:break;case Z.Dictionary:break;default:return JV(t,j)}let e=He.getVisitFn(t),r=$7(A);for(let n=(j||0)-1,i=t.length;++n{let r=t.data[e];return r.values.subarray(0,r.length)[Symbol.iterator]()});let j=0;return new Ch(t.data.length,e=>{let n=t.data[e].length,i=t.slice(j,j+n);return j+=n,new yq(i)})}var yq=class{constructor(A){this.vector=A,this.index=0}next(){return this.indexo.data):A;if(n.length===0||n.some(o=>!(o instanceof rj)))throw new TypeError("Vector constructor expects an Array of Data instances.");let i=(j=n[0])===null||j===void 0?void 0:j.type;switch(n.length){case 0:this._offsets=[0];break;case 1:{let{get:o,set:l,indexOf:c}=NM[i.typeId],B=n[0];this.isValid=h=>Hh(B,h),this.get=h=>o(B,h),this.set=(h,d)=>l(B,h,d),this.indexOf=h=>c(B,h),this._offsets=[0,B.length];break}default:Object.setPrototypeOf(this,KM[i.typeId]),this._offsets=cm(n);break}this.data=n,this.type=i,this.stride=U6(i),this.numChildren=(r=(e=i.children)===null||e===void 0?void 0:e.length)!==null&&r!==void 0?r:0,this.length=this._offsets.at(-1)}get byteLength(){return this.data.reduce((A,j)=>A+j.byteLength,0)}get nullable(){return CM(this.data)}get nullCount(){return lm(this.data)}get ArrayType(){return this.type.ArrayType}get[Symbol.toStringTag](){return`${this.VectorName}<${this.type[Symbol.toStringTag]}>`}get VectorName(){return`${Z[this.type.typeId]}Vector`}isValid(A){return!1}get(A){return null}set(A,j){}indexOf(A,j){return-1}includes(A,j){return this.indexOf(A,j)>-1}[Symbol.iterator](){return Mu.visit(this)}concat(...A){return new t(this.data.concat(A.flatMap(j=>j.data).flat(Number.POSITIVE_INFINITY)))}slice(A,j){return new t(Rh(this,A,j,({data:e,_offsets:r},n,i)=>um(e,r,n,i)))}toJSON(){return[...this]}toArray(){let{type:A,data:j,length:e,stride:r,ArrayType:n}=this;switch(A.typeId){case Z.Int:case Z.Float:case Z.Decimal:case Z.Time:case Z.Timestamp:switch(j.length){case 0:return new n;case 1:return j[0].values.subarray(0,e*r);default:return j.reduce((i,{values:o,length:l})=>(i.array.set(o.subarray(0,l*r),i.offset),i.offset+=l*r,i),{array:new n(e*r),offset:0}).array}}return[...this]}toString(){return`[${[...this].join(",")}]`}getChild(A){var j;return this.getChildAt((j=this.type.children)===null||j===void 0?void 0:j.findIndex(e=>e.name===A))}getChildAt(A){return A>-1&&Aj[A])):null}get isMemoized(){return HA.isDictionary(this.type)?this.data[0].dictionary.isMemoized:!1}memoize(){if(HA.isDictionary(this.type)){let A=new hm(this.data[0].dictionary),j=this.data.map(e=>{let r=e.clone();return r.dictionary=A,r});return new t(j)}return new hm(this)}unmemoize(){if(HA.isDictionary(this.type)&&this.isMemoized){let A=this.data[0].dictionary.unmemoize(),j=this.data.map(e=>{let r=e.clone();return r.dictionary=A,r});return new t(j)}return this}};DM=Symbol.toStringTag;Dt[DM]=(t=>{t.type=HA.prototype,t.data=[],t.length=0,t.stride=1,t.numChildren=0,t._offsets=new Uint32Array([0]),t[Symbol.isConcatSpreadable]=!0;let A=Object.keys(Z).map(j=>Z[j]).filter(j=>typeof j=="number"&&j!==Z.NONE);for(let j of A){let e=He.getVisitFnByTypeId(j),r=Or.getVisitFnByTypeId(j),n=Kl.getVisitFnByTypeId(j);NM[j]={get:e,set:r,indexOf:n},KM[j]=Object.create(t,{isValid:{value:Iu(Hh)},get:{value:Iu(He.getVisitFnByTypeId(j))},set:{value:Bm(Or.getVisitFnByTypeId(j))},indexOf:{value:fm(Kl.getVisitFnByTypeId(j))}})}return"Vector"})(Dt.prototype);var hm=class t extends Dt{constructor(A){super(A.data);let j=this.get,e=this.set,r=this.slice,n=new Array(this.length);Object.defineProperty(this,"get",{value(i){let o=n[i];if(o!==void 0)return o;let l=j.call(this,i);return n[i]=l,l}}),Object.defineProperty(this,"set",{value(i,o){e.call(this,i,o),n[i]=o}}),Object.defineProperty(this,"slice",{value:(i,o)=>new t(r.call(this,i,o))}),Object.defineProperty(this,"isMemoized",{value:!0}),Object.defineProperty(this,"unmemoize",{value:()=>new Dt(this.data)}),Object.defineProperty(this,"memoize",{value:()=>this})}};function XM(t){if(!t||t.length<=0)return function(r){return!0};let A="",j=t.filter(e=>e===e);return j.length>0&&(A=` switch (x) {${j.map(e=>` - case ${UV(e)}:`).join("")} + case ${ZV(e)}:`).join("")} return false; }`),t.length!==j.length&&(A=`if (x !== x) return false; ${A}`),new Function("x",`${A} -return true;`)}function UV(t){return typeof t!="bigint"?Yi(t):`${Yi(t)}n`}function mq(t,A){let j=Math.ceil(t)*A-1;return(j-j%64+64||64)/A}function CM(t,A=0){return t.length>=A?t.subarray(0,A):mh(new t.constructor(A),t,0)}var no=class{constructor(A,j=0,e=1){this.length=Math.ceil(j/e),this.buffer=new A(this.length),this.stride=e,this.BYTES_PER_ELEMENT=A.BYTES_PER_ELEMENT,this.ArrayType=A}get byteLength(){return Math.ceil(this.length*this.stride)*this.BYTES_PER_ELEMENT}get reservedLength(){return this.buffer.length/this.stride}get reservedByteLength(){return this.buffer.byteLength}set(A,j){return this}append(A){return this.set(this.length,A)}reserve(A){if(A>0){this.length+=A;let j=this.stride,e=this.length*j,r=this.buffer.length;e>=r&&this._resize(r===0?mq(e*1,this.BYTES_PER_ELEMENT):mq(e*2,this.BYTES_PER_ELEMENT))}return this}flush(A=this.length){A=mq(A*this.stride,this.BYTES_PER_ELEMENT);let j=CM(this.buffer,A);return this.clear(),j}clear(){return this.length=0,this.buffer=new this.ArrayType,this}_resize(A){return this.buffer=CM(this.buffer,A)}},ca=class extends no{last(){return this.get(this.length-1)}get(A){return this.buffer[A]}set(A,j){return this.reserve(A-this.length+1),this.buffer[A*this.stride]=j,this}},Ou=class extends ca{constructor(){super(Uint8Array,0,1/8),this.numValid=0}get numInvalid(){return this.length-this.numValid}get(A){return this.buffer[A>>3]>>A%8&1}set(A,j){let{buffer:e}=this.reserve(A-this.length+1),r=A>>3,n=A%8,i=e[r]>>n&1;return j?i===0&&(e[r]|=1<=0&&r.fill(r[e],e,A),r[A]=r[A-1]+j,this}flush(A=this.length-1){return A>this.length&&this.set(A-1,this.BYTES_PER_ELEMENT>4?BigInt(0):0),super.flush(A+1)}};var Nj=class{static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A){throw new Error('"throughDOM" not available in this environment')}constructor({type:A,nullValues:j}){this.length=0,this.finished=!1,this.type=A,this.children=[],this.nullValues=j,this.stride=U6(A),this._nulls=new Ou,j&&j.length>0&&(this._isValid=LM(j))}toVector(){return new Dt([this.flush()])}get ArrayType(){return this.type.ArrayType}get nullCount(){return this._nulls.numInvalid}get numChildren(){return this.children.length}get byteLength(){let A=0,{_offsets:j,_values:e,_nulls:r,_typeIds:n,children:i}=this;return j&&(A+=j.byteLength),e&&(A+=e.byteLength),r&&(A+=r.byteLength),n&&(A+=n.byteLength),i.reduce((o,l)=>o+l.byteLength,A)}get reservedLength(){return this._nulls.reservedLength}get reservedByteLength(){let A=0;return this._offsets&&(A+=this._offsets.reservedByteLength),this._values&&(A+=this._values.reservedByteLength),this._nulls&&(A+=this._nulls.reservedByteLength),this._typeIds&&(A+=this._typeIds.reservedByteLength),this.children.reduce((j,e)=>j+e.reservedByteLength,A)}get valueOffsets(){return this._offsets?this._offsets.buffer:null}get values(){return this._values?this._values.buffer:null}get nullBitmap(){return this._nulls?this._nulls.buffer:null}get typeIds(){return this._typeIds?this._typeIds.buffer:null}append(A){return this.set(this.length,A)}isValid(A){return this._isValid(A)}set(A,j){return this.setValid(A,this.isValid(j))&&this.setValue(A,j),this}setValue(A,j){this._setValue(this,A,j)}setValid(A,j){return this.length=this._nulls.set(A,+j).length,j}addChild(A,j=`${this.numChildren}`){throw new Error(`Cannot append children to non-nested type "${this.type}"`)}getChildAt(A){return this.children[A]||null}flush(){let A,j,e,r,{type:n,length:i,nullCount:o,_typeIds:l,_offsets:c,_values:B,_nulls:h}=this;(j=l?.flush(i))?r=c?.flush(i):(r=c?.flush(i))?A=B?.flush(c.last()):A=B?.flush(i),o>0&&(e=h?.flush(i));let d=this.children.map(k=>k.flush());return this.clear(),ht({type:n,length:i,nullCount:o,children:d,child:d[0],data:A,typeIds:j,nullBitmap:e,valueOffsets:r})}finish(){this.finished=!0;for(let A of this.children)A.finish();return this}clear(){var A,j,e,r;this.length=0,(A=this._nulls)===null||A===void 0||A.clear(),(j=this._values)===null||j===void 0||j.clear(),(e=this._offsets)===null||e===void 0||e.clear(),(r=this._typeIds)===null||r===void 0||r.clear();for(let n of this.children)n.clear();return this}};Nj.prototype.length=1;Nj.prototype.stride=1;Nj.prototype.children=null;Nj.prototype.finished=!1;Nj.prototype.nullValues=null;Nj.prototype._isValid=()=>!0;var De=class extends Nj{constructor(A){super(A),this._values=new ca(this.ArrayType,0,this.stride)}setValue(A,j){let e=this._values;return e.reserve(A-e.length+1),super.setValue(A,j)}},g6=class extends Nj{constructor(A){super(A),this._pendingLength=0,this._offsets=new Tu(A.type)}setValue(A,j){let e=this._pending||(this._pending=new Map),r=e.get(A);r&&(this._pendingLength-=r.length),this._pendingLength+=j instanceof zo?j[hi].length:j.length,e.set(A,j)}setValid(A,j){return super.setValid(A,j)?!0:((this._pending||(this._pending=new Map)).set(A,void 0),!1)}clear(){return this._pendingLength=0,this._pending=void 0,super.clear()}flush(){return this._flush(),super.flush()}finish(){return this._flush(),super.finish()}_flush(){let A=this._pending,j=this._pendingLength;return this._pendingLength=0,this._pending=void 0,A&&A.size>0&&this._flushPending(A,j),this}};var Kl=class{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}offset(){return this.bb.readInt64(this.bb_pos)}metaDataLength(){return this.bb.readInt32(this.bb_pos+8)}bodyLength(){return this.bb.readInt64(this.bb_pos+16)}static sizeOf(){return 24}static createBlock(A,j,e,r){return A.prep(8,24),A.writeInt64(BigInt(r??0)),A.pad(4),A.writeInt32(e),A.writeInt64(BigInt(j??0)),A.offset()}};var V6=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsFooter(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsFooter(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}version(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):hj.V1}schema(A){let j=this.bb.__offset(this.bb_pos,6);return j?(A||new p6).__init(this.bb.__indirect(this.bb_pos+j),this.bb):null}dictionaries(A,j){let e=this.bb.__offset(this.bb_pos,8);return e?(j||new Kl).__init(this.bb.__vector(this.bb_pos+e)+A*24,this.bb):null}dictionariesLength(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.__vector_len(this.bb_pos+A):0}recordBatches(A,j){let e=this.bb.__offset(this.bb_pos,10);return e?(j||new Kl).__init(this.bb.__vector(this.bb_pos+e)+A*24,this.bb):null}recordBatchesLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,12);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,12);return A?this.bb.__vector_len(this.bb_pos+A):0}static startFooter(A){A.startObject(5)}static addVersion(A,j){A.addFieldInt16(0,j,hj.V1)}static addSchema(A,j){A.addFieldOffset(1,j,0)}static addDictionaries(A,j){A.addFieldOffset(2,j,0)}static startDictionariesVector(A,j){A.startVector(24,j,8)}static addRecordBatches(A,j){A.addFieldOffset(3,j,0)}static startRecordBatchesVector(A,j){A.startVector(24,j,8)}static addCustomMetadata(A,j){A.addFieldOffset(4,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endFooter(A){return A.endObject()}static finishFooterBuffer(A,j){A.finish(j)}static finishSizePrefixedFooterBuffer(A,j){A.finish(j,void 0,!0)}};var aj=class t{constructor(A=[],j,e,r=hj.V5){this.fields=A||[],this.metadata=j||new Map,e||(e=Eq(A)),this.dictionaries=e,this.metadataVersion=r}get[Symbol.toStringTag](){return"Schema"}get names(){return this.fields.map(A=>A.name)}toString(){return`Schema<{ ${this.fields.map((A,j)=>`${j}: ${A}`).join(", ")} }>`}select(A){let j=new Set(A),e=this.fields.filter(r=>j.has(r.name));return new t(e,this.metadata)}selectAt(A){let j=A.map(e=>this.fields[e]).filter(Boolean);return new t(j,this.metadata)}assign(...A){let j=A[0]instanceof t?A[0]:Array.isArray(A[0])?new t(A[0]):new t(A),e=[...this.fields],r=cm(cm(new Map,this.metadata),j.metadata),n=j.fields.filter(o=>{let l=e.findIndex(c=>c.name===o.name);return~l?(e[l]=o.clone({metadata:cm(cm(new Map,e[l].metadata),o.metadata)}))&&!1:!0}),i=Eq(n,new Map);return new t([...e,...n],r,new Map([...this.dictionaries,...i]))}};aj.prototype.fields=null;aj.prototype.metadata=null;aj.prototype.dictionaries=null;var St=class t{static new(...A){let[j,e,r,n]=A;return A[0]&&typeof A[0]=="object"&&({name:j}=A[0],e===void 0&&(e=A[0].type),r===void 0&&(r=A[0].nullable),n===void 0&&(n=A[0].metadata)),new t(`${j}`,e,r,n)}constructor(A,j,e=!1,r){this.name=A,this.type=j,this.nullable=e,this.metadata=r||new Map}get typeId(){return this.type.typeId}get[Symbol.toStringTag](){return"Field"}toString(){return`${this.name}: ${this.type}`}clone(...A){let[j,e,r,n]=A;return!A[0]||typeof A[0]!="object"?[j=this.name,e=this.type,r=this.nullable,n=this.metadata]=A:{name:j=this.name,type:e=this.type,nullable:r=this.nullable,metadata:n=this.metadata}=A[0],t.new(j,e,r,n)}};St.prototype.type=null;St.prototype.name=null;St.prototype.nullable=null;St.prototype.metadata=null;function cm(t,A){return new Map([...t||new Map,...A||new Map])}function Eq(t,A=new Map){for(let j=-1,e=t.length;++j0&&Eq(n.children,A)}return A}var VV=Ll,QV=K6,ua=class{static decode(A){A=new QV(it(A));let j=V6.getRootAsFooter(A),e=aj.decode(j.schema(),new Map,j.version());return new $q(e,j)}static encode(A){let j=new VV,e=aj.encode(j,A.schema);V6.startRecordBatchesVector(j,A.numRecordBatches);for(let i of[...A.recordBatches()].slice().reverse())Ba.encode(j,i);let r=j.endVector();V6.startDictionariesVector(j,A.numDictionaries);for(let i of[...A.dictionaryBatches()].slice().reverse())Ba.encode(j,i);let n=j.endVector();return V6.startFooter(j),V6.addSchema(j,e),V6.addVersion(j,hj.V5),V6.addRecordBatches(j,r),V6.addDictionaries(j,n),V6.finishFooterBuffer(j,V6.endFooter(j)),j.asUint8Array()}get numRecordBatches(){return this._recordBatches.length}get numDictionaries(){return this._dictionaryBatches.length}constructor(A,j=hj.V5,e,r){this.schema=A,this.version=j,e&&(this._recordBatches=e),r&&(this._dictionaryBatches=r)}*recordBatches(){for(let A,j=-1,e=this.numRecordBatches;++j=0&&A=0&&A=0&&A=0&&Athis._closedPromiseResolve=A)}get closed(){return this._closedPromise}cancel(A){return OA(this,void 0,void 0,function*(){yield this.return(A)})}write(A){this._ensureOpen()&&(this.resolvers.length<=0?this._values.push(A):this.resolvers.shift().resolve({done:!1,value:A}))}abort(A){this._closedPromiseResolve&&(this.resolvers.length<=0?this._error={error:A}:this.resolvers.shift().reject({done:!0,value:A}))}close(){if(this._closedPromiseResolve){let{resolvers:A}=this;for(;A.length>0;)A.shift().resolve(Tj);this._closedPromiseResolve(),this._closedPromiseResolve=void 0}}[Symbol.asyncIterator](){return this}toDOMStream(A){return Mr.toDOMStream(this._closedPromiseResolve||this._error?this:this._values,A)}toNodeStream(A){return Mr.toNodeStream(this._closedPromiseResolve||this._error?this:this._values,A)}throw(A){return OA(this,void 0,void 0,function*(){return yield this.abort(A),Tj})}return(A){return OA(this,void 0,void 0,function*(){return yield this.close(),Tj})}read(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"read")).value})}peek(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"peek")).value})}next(...A){return this._values.length>0?Promise.resolve({done:!1,value:this._values.shift()}):this._error?Promise.reject({done:!0,value:this._error.error}):this._closedPromiseResolve?new Promise((j,e)=>{this.resolvers.push({resolve:j,reject:e})}):Promise.resolve(Tj)}_ensureOpen(){if(this._closedPromiseResolve)return!0;throw new Error("AsyncQueue is closed")}};var Uo=class extends um{write(A){if((A=it(A)).byteLength>0)return super.write(A)}toString(A=!1){return A?kh(this.toUint8Array(!0)):this.toUint8Array(!1).then(kh)}toUint8Array(A=!1){return A?N6(this._values)[0]:OA(this,void 0,void 0,function*(){var j,e,r,n;let i=[],o=0;try{for(var l=!0,c=Ki(this),B;B=yield c.next(),j=B.done,!j;l=!0){n=B.value,l=!1;let h=n;i.push(h),o+=h.byteLength}}catch(h){e={error:h}}finally{try{!l&&!j&&(r=c.return)&&(yield r.call(c))}finally{if(e)throw e.error}}return N6(i,o)[0]})}},Vo=class{constructor(A){A&&(this.source=new xq(Mr.fromIterable(A)))}[Symbol.iterator](){return this}next(A){return this.source.next(A)}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}peek(A){return this.source.peek(A)}read(A){return this.source.read(A)}},di=class t{constructor(A){A instanceof t?this.source=A.source:A instanceof Uo?this.source=new fa(Mr.fromAsyncIterable(A)):Eg(A)?this.source=new fa(Mr.fromNodeStream(A)):gh(A)?this.source=new fa(Mr.fromDOMStream(A)):gg(A)?this.source=new fa(Mr.fromDOMStream(A.body)):Xi(A)?this.source=new fa(Mr.fromIterable(A)):D6(A)?this.source=new fa(Mr.fromAsyncIterable(A)):Bi(A)&&(this.source=new fa(Mr.fromAsyncIterable(A)))}[Symbol.asyncIterator](){return this}next(A){return this.source.next(A)}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}get closed(){return this.source.closed}cancel(A){return this.source.cancel(A)}peek(A){return this.source.peek(A)}read(A){return this.source.read(A)}},xq=class{constructor(A){this.source=A}cancel(A){this.return(A)}peek(A){return this.next(A,"peek").value}read(A){return this.next(A,"read").value}next(A,j="read"){return this.source.next({cmd:j,size:A})}throw(A){return Object.create(this.source.throw&&this.source.throw(A)||Tj)}return(A){return Object.create(this.source.return&&this.source.return(A)||Tj)}},fa=class{constructor(A){this.source=A,this._closedPromise=new Promise(j=>this._closedPromiseResolve=j)}cancel(A){return OA(this,void 0,void 0,function*(){yield this.return(A)})}get closed(){return this._closedPromise}read(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"read")).value})}peek(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"peek")).value})}next(A,j="read"){return OA(this,void 0,void 0,function*(){return yield this.source.next({cmd:j,size:A})})}throw(A){return OA(this,void 0,void 0,function*(){let j=this.source.throw&&(yield this.source.throw(A))||Tj;return this._closedPromiseResolve&&this._closedPromiseResolve(),this._closedPromiseResolve=void 0,Object.create(j)})}return(A){return OA(this,void 0,void 0,function*(){let j=this.source.return&&(yield this.source.return(A))||Tj;return this._closedPromiseResolve&&this._closedPromiseResolve(),this._closedPromiseResolve=void 0,Object.create(j)})}};var Hh=class extends Vo{constructor(A,j){super(),this.position=0,this.buffer=it(A),this.size=j===void 0?this.buffer.byteLength:j}readInt32(A){let{buffer:j,byteOffset:e}=this.readAt(A,4);return new DataView(j,e).getInt32(0,!0)}seek(A){return this.position=Math.min(A,this.size),ADh,Int128:()=>Nh,Int64:()=>ha,Uint64:()=>re});function Su(t){return t<0&&(t=4294967295+t+1),`0x${t.toString(16)}`}var Ru=8,yq=[1,10,100,1e3,1e4,1e5,1e6,1e7,1e8],Dh=class{constructor(A){this.buffer=A}high(){return this.buffer[1]}low(){return this.buffer[0]}_times(A){let j=new Uint32Array([this.buffer[1]>>>16,this.buffer[1]&65535,this.buffer[0]>>>16,this.buffer[0]&65535]),e=new Uint32Array([A.buffer[1]>>>16,A.buffer[1]&65535,A.buffer[0]>>>16,A.buffer[0]&65535]),r=j[3]*e[3];this.buffer[0]=r&65535;let n=r>>>16;return r=j[2]*e[3],n+=r,r=j[3]*e[2]>>>0,n+=r,this.buffer[0]+=n<<16,this.buffer[1]=n>>>0>>16,this.buffer[1]+=j[1]*e[3]+j[2]*e[2]+j[3]*e[1],this.buffer[1]+=j[0]*e[3]+j[1]*e[2]+j[2]*e[1]+j[3]*e[0]<<16,this}_plus(A){let j=this.buffer[0]+A.buffer[0]>>>0;this.buffer[1]+=A.buffer[1],j>>0&&++this.buffer[1],this.buffer[0]=j}lessThan(A){return this.buffer[1]>>0,j[2]=this.buffer[2]+A.buffer[2]>>>0,j[1]=this.buffer[1]+A.buffer[1]>>>0,j[0]=this.buffer[0]+A.buffer[0]>>>0,j[0]>>0&&++j[1],j[1]>>0&&++j[2],j[2]>>0&&++j[3],this.buffer[3]=j[3],this.buffer[2]=j[2],this.buffer[1]=j[1],this.buffer[0]=j[0],this}hex(){return`${Su(this.buffer[3])} ${Su(this.buffer[2])} ${Su(this.buffer[1])} ${Su(this.buffer[0])}`}static multiply(A,j){return new t(new Uint32Array(A.buffer)).times(j)}static add(A,j){return new t(new Uint32Array(A.buffer)).plus(j)}static from(A,j=new Uint32Array(4)){return t.fromString(typeof A=="string"?A:A.toString(),j)}static fromNumber(A,j=new Uint32Array(4)){return t.fromString(A.toString(),j)}static fromString(A,j=new Uint32Array(4)){let e=A.startsWith("-"),r=A.length,n=new t(j);for(let i=e?1:0;i0&&this.readData(A,e)||new Uint8Array(0)}readOffsets(A,j){return this.readData(A,j)}readTypeIds(A,j){return this.readData(A,j)}readData(A,{length:j,offset:e}=this.nextBufferRange()){return this.bytes.subarray(e,e+j)}readDictionary(A){return this.dictionaries.get(A.id)}},Bm=class extends Kh{constructor(A,j,e,r,n){super(new Uint8Array(0),j,e,r,n),this.sources=A}readNullBitmap(A,j,{offset:e}=this.nextBufferRange()){return j<=0?new Uint8Array(0):Dl(this.sources[e])}readOffsets(A,{offset:j}=this.nextBufferRange()){return Mt(Uint8Array,Mt(A.OffsetArrayType,this.sources[j]))}readTypeIds(A,{offset:j}=this.nextBufferRange()){return Mt(Uint8Array,Mt(A.ArrayType,this.sources[j]))}readData(A,{offset:j}=this.nextBufferRange()){let{sources:e}=this;return HA.isTimestamp(A)?Mt(Uint8Array,ha.convertArray(e[j])):(HA.isInt(A)||HA.isTime(A))&&A.bitWidth===64||HA.isDuration(A)?Mt(Uint8Array,ha.convertArray(e[j])):HA.isDate(A)&&A.unit===Ce.MILLISECOND?Mt(Uint8Array,ha.convertArray(e[j])):HA.isDecimal(A)?Mt(Uint8Array,Nh.convertArray(e[j])):HA.isBinary(A)||HA.isLargeBinary(A)||HA.isFixedSizeBinary(A)?WV(e[j]):HA.isBool(A)?Dl(e[j]):HA.isUtf8(A)||HA.isLargeUtf8(A)?Co(e[j].join("")):Mt(Uint8Array,Mt(A.ArrayType,e[j].map(r=>+r)))}};function WV(t){let A=t.join(""),j=new Uint8Array(A.length/2);for(let e=0;e>1]=Number.parseInt(A.slice(e,e+2),16);return j}var Lu=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,it(j))}_flushPending(A,j){let e=this._offsets,r=this._values.reserve(j).buffer,n=0;for(let[i,o]of A)if(o===void 0)e.set(i,0);else{let l=o.length;r.set(o,n),e.set(i,l),n+=l}}};var Cu=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,it(j))}_flushPending(A,j){let e=this._offsets,r=this._values.reserve(j).buffer,n=0;for(let[i,o]of A)if(o===void 0)e.set(i,BigInt(0));else{let l=o.length;r.set(o,n),e.set(i,BigInt(l)),n+=l}}};var fm=class extends Nj{constructor(A){super(A),this._values=new Ou}setValue(A,j){this._values.set(A,+j)}};var zl=class extends De{};zl.prototype._setValue=rq;var Xh=class extends zl{};Xh.prototype._setValue=Cg;var zh=class extends zl{};zh.prototype._setValue=Hg;var Uh=class extends De{};Uh.prototype._setValue=oq;var hm=class extends Nj{constructor({type:A,nullValues:j,dictionaryHashFunction:e}){super({type:new z6(A.dictionary,A.indices,A.id,A.isOrdered)}),this._nulls=null,this._dictionaryOffset=0,this._keysToIndices=Object.create(null),this.indices=Ul({type:this.type.indices,nullValues:j}),this.dictionary=Ul({type:this.type.dictionary,nullValues:null}),typeof e=="function"&&(this.valueToKey=e)}get values(){return this.indices.values}get nullCount(){return this.indices.nullCount}get nullBitmap(){return this.indices.nullBitmap}get byteLength(){return this.indices.byteLength+this.dictionary.byteLength}get reservedLength(){return this.indices.reservedLength+this.dictionary.reservedLength}get reservedByteLength(){return this.indices.reservedByteLength+this.dictionary.reservedByteLength}isValid(A){return this.indices.isValid(A)}setValid(A,j){let e=this.indices;return j=e.setValid(A,j),this.length=e.length,j}setValue(A,j){let e=this._keysToIndices,r=this.valueToKey(j),n=e[r];return n===void 0&&(e[r]=n=this._dictionaryOffset+this.dictionary.append(j).length-1),this.indices.setValue(A,n)}flush(){let A=this.type,j=this._dictionary,e=this.dictionary.toVector(),r=this.indices.flush().clone(A);return r.dictionary=j?j.concat(e):e,this.finished||(this._dictionaryOffset+=e.length),this._dictionary=r.dictionary,this.clear(),r}finish(){return this.indices.finish(),this.dictionary.finish(),this._dictionaryOffset=0,this._keysToIndices=Object.create(null),super.finish()}clear(){return this.indices.clear(),this.dictionary.clear(),super.clear()}valueToKey(A){return typeof A=="string"?A:`${A}`}};var Vh=class extends De{};Vh.prototype._setValue=eq;var dm=class extends Nj{setValue(A,j){let[e]=this.children,r=A*this.stride;for(let n=-1,i=j.length;++n0)throw new Error("FixedSizeListBuilder can only have one child.");let e=this.children.push(A);return this.type=new jo(this.type.listSize,new St(j,A.type,!0)),e}};var Vl=class extends De{setValue(A,j){this._values.set(A,j)}},pm=class extends Vl{setValue(A,j){super.setValue(A,Oh(j))}},km=class extends Vl{},gm=class extends Vl{};var Ql=class extends De{};Ql.prototype._setValue=sq;var Qh=class extends Ql{};Qh.prototype._setValue=Wg;var Wh=class extends Ql{};Wh.prototype._setValue=Yg;var da=class extends De{};da.prototype._setValue=aq;var Yh=class extends da{};Yh.prototype._setValue=Jg;var Jh=class extends da{};Jh.prototype._setValue=Zg;var Zh=class extends da{};Zh.prototype._setValue=Am;var Ad=class extends da{};Ad.prototype._setValue=tm;var pi=class extends De{setValue(A,j){this._values.set(A,j)}},mm=class extends pi{},Em=class extends pi{},$m=class extends pi{},xm=class extends pi{},ym=class extends pi{},vm=class extends pi{},_m=class extends pi{},qm=class extends pi{};var Gm=class extends g6{constructor(A){super(A),this._offsets=new Tu(A.type)}addChild(A,j="0"){if(this.numChildren>0)throw new Error("ListBuilder can only have one child.");return this.children[this.numChildren]=A,this.type=new Ao(new St(j,A.type,!0)),this.numChildren-1}_flushPending(A){let j=this._offsets,[e]=this.children;for(let[r,n]of A)if(typeof n>"u")j.set(r,0);else{let i=n,o=i.length,l=j.set(r,o).buffer[r];for(let c=-1;++c0)throw new Error("ListBuilder can only have one child.");return this.children[this.numChildren]=A,this.type=new eo(new St(j,A.type,!0),this.type.keysSorted),this.numChildren-1}_flushPending(A){let j=this._offsets,[e]=this.children;for(let[r,n]of A)if(n===void 0)j.set(r,0);else{let{[r]:i,[r+1]:o}=j.set(r,n.size).buffer;for(let l of n.entries())if(e.set(i,l),++i>=o)break}}};var wm=class extends Nj{setValue(A,j){}setValid(A,j){return this.length=Math.max(A+1,this.length),j}};var Fm=class extends Nj{setValue(A,j){let{children:e,type:r}=this;switch(Array.isArray(j)||j.constructor){case!0:return r.children.forEach((n,i)=>e[i].set(A,j[i]));case Map:return r.children.forEach((n,i)=>e[i].set(A,j.get(n.name)));default:return r.children.forEach((n,i)=>e[i].set(A,j[n.name]))}}setValid(A,j){return super.setValid(A,j)||this.children.forEach(e=>e.setValid(A,j)),j}addChild(A,j=`${this.numChildren}`){let e=this.children.push(A);return this.type=new Oj([...this.type.children,new St(j,A.type,!0)]),e}};var pa=class extends De{};pa.prototype._setValue=nq;var td=class extends pa{};td.prototype._setValue=Dg;var jd=class extends pa{};jd.prototype._setValue=Ng;var ed=class extends pa{};ed.prototype._setValue=Kg;var rd=class extends pa{};rd.prototype._setValue=Xg;var ka=class extends De{};ka.prototype._setValue=iq;var nd=class extends ka{};nd.prototype._setValue=zg;var id=class extends ka{};id.prototype._setValue=Ug;var od=class extends ka{};od.prototype._setValue=Vg;var sd=class extends ka{};sd.prototype._setValue=Qg;var Hu=class extends Nj{constructor(A){super(A),this._typeIds=new ca(Int8Array,0,1),typeof A.valueToChildTypeId=="function"&&(this._valueToChildTypeId=A.valueToChildTypeId)}get typeIdToChildIndex(){return this.type.typeIdToChildIndex}append(A,j){return this.set(this.length,A,j)}set(A,j,e){return e===void 0&&(e=this._valueToChildTypeId(this,j,A)),this.setValue(A,j,e),this}setValue(A,j,e){this._typeIds.set(A,e);let r=this.type.typeIdToChildIndex[e],n=this.children[r];n?.set(A,j)}addChild(A,j=`${this.children.length}`){let e=this.children.push(A),{type:{children:r,mode:n,typeIds:i}}=this,o=[...r,new St(j,A.type)];return this.type=new to(n,[...i,e],o),e}_valueToChildTypeId(A,j,e){throw new Error("Cannot map UnionBuilder value to child typeId. Pass the `childTypeId` as the second argument to unionBuilder.append(), or supply a `valueToChildTypeId` function as part of the UnionBuilder constructor options.")}},Pm=class extends Hu{},Im=class extends Hu{constructor(A){super(A),this._offsets=new ca(Int32Array)}setValue(A,j,e){let r=this._typeIds.set(A,e).buffer[A],n=this.getChildAt(this.type.typeIdToChildIndex[r]),i=this._offsets.set(A,n.length).buffer[A];n?.set(i,j)}};var ad=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,Co(j))}_flushPending(A,j){}};ad.prototype._flushPending=Lu.prototype._flushPending;var ld=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,Co(j))}_flushPending(A,j){}};ld.prototype._flushPending=Cu.prototype._flushPending;var _q=class extends WA{visitNull(){return wm}visitBool(){return fm}visitInt(){return pi}visitInt8(){return mm}visitInt16(){return Em}visitInt32(){return $m}visitInt64(){return xm}visitUint8(){return ym}visitUint16(){return vm}visitUint32(){return _m}visitUint64(){return qm}visitFloat(){return Vl}visitFloat16(){return pm}visitFloat32(){return km}visitFloat64(){return gm}visitUtf8(){return ad}visitLargeUtf8(){return ld}visitBinary(){return Lu}visitLargeBinary(){return Cu}visitFixedSizeBinary(){return Vh}visitDate(){return zl}visitDateDay(){return Xh}visitDateMillisecond(){return zh}visitTimestamp(){return pa}visitTimestampSecond(){return td}visitTimestampMillisecond(){return jd}visitTimestampMicrosecond(){return ed}visitTimestampNanosecond(){return rd}visitTime(){return ka}visitTimeSecond(){return nd}visitTimeMillisecond(){return id}visitTimeMicrosecond(){return od}visitTimeNanosecond(){return sd}visitDecimal(){return Uh}visitList(){return Gm}visitStruct(){return Fm}visitUnion(){return Hu}visitDenseUnion(){return Im}visitSparseUnion(){return Pm}visitDictionary(){return hm}visitInterval(){return Ql}visitIntervalDayTime(){return Qh}visitIntervalYearMonth(){return Wh}visitDuration(){return da}visitDurationSecond(){return Yh}visitDurationMillisecond(){return Jh}visitDurationMicrosecond(){return Zh}visitDurationNanosecond(){return Ad}visitFixedSizeList(){return dm}visitMap(){return bm}},HM=new _q;var At=class extends WA{compareSchemas(A,j){return A===j||j instanceof A.constructor&&this.compareManyFields(A.fields,j.fields)}compareManyFields(A,j){return A===j||Array.isArray(A)&&Array.isArray(j)&&A.length===j.length&&A.every((e,r)=>this.compareFields(e,j[r]))}compareFields(A,j){return A===j||j instanceof A.constructor&&A.name===j.name&&A.nullable===j.nullable&&this.visit(A.type,j.type)}};function bn(t,A){return A instanceof t.constructor}function Wl(t,A){return t===A||bn(t,A)}function ga(t,A){return t===A||bn(t,A)&&t.bitWidth===A.bitWidth&&t.isSigned===A.isSigned}function Mm(t,A){return t===A||bn(t,A)&&t.precision===A.precision}function YV(t,A){return t===A||bn(t,A)&&t.byteWidth===A.byteWidth}function qq(t,A){return t===A||bn(t,A)&&t.unit===A.unit}function cd(t,A){return t===A||bn(t,A)&&t.unit===A.unit&&t.timezone===A.timezone}function ud(t,A){return t===A||bn(t,A)&&t.unit===A.unit&&t.bitWidth===A.bitWidth}function JV(t,A){return t===A||bn(t,A)&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function ZV(t,A){return t===A||bn(t,A)&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function Gq(t,A){return t===A||bn(t,A)&&t.mode===A.mode&&t.typeIds.every((j,e)=>j===A.typeIds[e])&&Qo.compareManyFields(t.children,A.children)}function AQ(t,A){return t===A||bn(t,A)&&t.id===A.id&&t.isOrdered===A.isOrdered&&Qo.visit(t.indices,A.indices)&&Qo.visit(t.dictionary,A.dictionary)}function bq(t,A){return t===A||bn(t,A)&&t.unit===A.unit}function Bd(t,A){return t===A||bn(t,A)&&t.unit===A.unit}function tQ(t,A){return t===A||bn(t,A)&&t.listSize===A.listSize&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function jQ(t,A){return t===A||bn(t,A)&&t.keysSorted===A.keysSorted&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}At.prototype.visitNull=Wl;At.prototype.visitBool=Wl;At.prototype.visitInt=ga;At.prototype.visitInt8=ga;At.prototype.visitInt16=ga;At.prototype.visitInt32=ga;At.prototype.visitInt64=ga;At.prototype.visitUint8=ga;At.prototype.visitUint16=ga;At.prototype.visitUint32=ga;At.prototype.visitUint64=ga;At.prototype.visitFloat=Mm;At.prototype.visitFloat16=Mm;At.prototype.visitFloat32=Mm;At.prototype.visitFloat64=Mm;At.prototype.visitUtf8=Wl;At.prototype.visitLargeUtf8=Wl;At.prototype.visitBinary=Wl;At.prototype.visitLargeBinary=Wl;At.prototype.visitFixedSizeBinary=YV;At.prototype.visitDate=qq;At.prototype.visitDateDay=qq;At.prototype.visitDateMillisecond=qq;At.prototype.visitTimestamp=cd;At.prototype.visitTimestampSecond=cd;At.prototype.visitTimestampMillisecond=cd;At.prototype.visitTimestampMicrosecond=cd;At.prototype.visitTimestampNanosecond=cd;At.prototype.visitTime=ud;At.prototype.visitTimeSecond=ud;At.prototype.visitTimeMillisecond=ud;At.prototype.visitTimeMicrosecond=ud;At.prototype.visitTimeNanosecond=ud;At.prototype.visitDecimal=Wl;At.prototype.visitList=JV;At.prototype.visitStruct=ZV;At.prototype.visitUnion=Gq;At.prototype.visitDenseUnion=Gq;At.prototype.visitSparseUnion=Gq;At.prototype.visitDictionary=AQ;At.prototype.visitInterval=bq;At.prototype.visitIntervalDayTime=bq;At.prototype.visitIntervalYearMonth=bq;At.prototype.visitDuration=Bd;At.prototype.visitDurationSecond=Bd;At.prototype.visitDurationMillisecond=Bd;At.prototype.visitDurationMicrosecond=Bd;At.prototype.visitDurationNanosecond=Bd;At.prototype.visitFixedSizeList=tQ;At.prototype.visitMap=jQ;var Qo=new At;function Yl(t,A){return Qo.compareSchemas(t,A)}function DM(t,A){return Qo.compareFields(t,A)}function NM(t,A){return Qo.visit(t,A)}function Ul(t){let A=t.type,j=new(HM.getVisitFn(A)())(t);if(A.children&&A.children.length>0){let e=t.children||[],r={nullValues:t.nullValues},n=Array.isArray(e)?(i,o)=>e[o]||r:({name:i})=>e[i]||r;for(let[i,o]of A.children.entries()){let{type:l}=o,c=n(o,i);j.children.push(Ul(Object.assign(Object.assign({},c),{type:l})))}}return j}function Om(t,A){return eQ(t,A.map(j=>j.data.concat()))}function eQ(t,A){let j=[...t.fields],e=[],r={numBatches:A.reduce((h,d)=>Math.max(h,d.length),0)},n=0,i=0,o=-1,l=A.length,c,B=[];for(;r.numBatches-- >0;){for(i=Number.POSITIVE_INFINITY,o=-1;++o0&&(e[n++]=ht({type:new Oj(j),length:i,nullCount:0,children:B.slice()})))}return[t=t.assign(j),e.map(h=>new Be(t,h))]}function rQ(t,A,j,e,r){var n;let i=(A+63&-64)>>3;for(let o=-1,l=e.length;++o=A)B===A?j[o]=c:(j[o]=c.slice(0,A),r.numBatches=Math.max(r.numBatches,e[o].unshift(c.slice(A,B-A))));else{let h=t[o];t[o]=h.clone({nullable:!0}),j[o]=(n=c?._changeLengthAndBackfillNullBitmap(A))!==null&&n!==void 0?n:ht({type:h.type,length:A,nullCount:A,nullBitmap:new Uint8Array(i)})}}return j}var KM,m6=class t{constructor(...A){var j,e;if(A.length===0)return this.batches=[],this.schema=new aj([]),this._offsets=[0],this;let r,n;A[0]instanceof aj&&(r=A.shift()),A.at(-1)instanceof Uint32Array&&(n=A.pop());let i=l=>{if(l){if(l instanceof Be)return[l];if(l instanceof t)return l.batches;if(l instanceof rj){if(l.type instanceof Oj)return[new Be(new aj(l.type.children),l)]}else{if(Array.isArray(l))return l.flatMap(c=>i(c));if(typeof l[Symbol.iterator]=="function")return[...l].flatMap(c=>i(c));if(typeof l=="object"){let c=Object.keys(l),B=c.map(k=>new Dt([l[k]])),h=r??new aj(c.map((k,g)=>new St(String(k),B[g].type,B[g].nullable))),[,d]=Om(h,B);return d.length===0?[new Be(l)]:d}}}return[]},o=A.flatMap(l=>i(l));if(r=(e=r??((j=o[0])===null||j===void 0?void 0:j.schema))!==null&&e!==void 0?e:new aj([]),!(r instanceof aj))throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");for(let l of o){if(!(l instanceof Be))throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");if(!Yl(r,l.schema))throw new TypeError("Table and inner RecordBatch schemas must be equivalent.")}this.schema=r,this.batches=o,this._offsets=n??im(this.data)}get data(){return this.batches.map(({data:A})=>A)}get numCols(){return this.schema.fields.length}get numRows(){return this.data.reduce((A,j)=>A+j.length,0)}get nullCount(){return this._nullCount===-1&&(this._nullCount=nm(this.data)),this._nullCount}isValid(A){return!1}get(A){return null}set(A,j){}indexOf(A,j){return-1}[Symbol.iterator](){return this.batches.length>0?Mu.visit(new Dt(this.data)):new Array(0)[Symbol.iterator]()}toArray(){return[...this]}toString(){return`[ +return true;`)}function ZV(t){return typeof t!="bigint"?Yi(t):`${Yi(t)}n`}function vq(t,A){let j=Math.ceil(t)*A-1;return(j-j%64+64||64)/A}function zM(t,A=0){return t.length>=A?t.subarray(0,A):$h(new t.constructor(A),t,0)}var no=class{constructor(A,j=0,e=1){this.length=Math.ceil(j/e),this.buffer=new A(this.length),this.stride=e,this.BYTES_PER_ELEMENT=A.BYTES_PER_ELEMENT,this.ArrayType=A}get byteLength(){return Math.ceil(this.length*this.stride)*this.BYTES_PER_ELEMENT}get reservedLength(){return this.buffer.length/this.stride}get reservedByteLength(){return this.buffer.byteLength}set(A,j){return this}append(A){return this.set(this.length,A)}reserve(A){if(A>0){this.length+=A;let j=this.stride,e=this.length*j,r=this.buffer.length;e>=r&&this._resize(r===0?vq(e*1,this.BYTES_PER_ELEMENT):vq(e*2,this.BYTES_PER_ELEMENT))}return this}flush(A=this.length){A=vq(A*this.stride,this.BYTES_PER_ELEMENT);let j=zM(this.buffer,A);return this.clear(),j}clear(){return this.length=0,this.buffer=new this.ArrayType,this}_resize(A){return this.buffer=zM(this.buffer,A)}},ca=class extends no{last(){return this.get(this.length-1)}get(A){return this.buffer[A]}set(A,j){return this.reserve(A-this.length+1),this.buffer[A*this.stride]=j,this}},Ou=class extends ca{constructor(){super(Uint8Array,0,1/8),this.numValid=0}get numInvalid(){return this.length-this.numValid}get(A){return this.buffer[A>>3]>>A%8&1}set(A,j){let{buffer:e}=this.reserve(A-this.length+1),r=A>>3,n=A%8,i=e[r]>>n&1;return j?i===0&&(e[r]|=1<=0&&r.fill(r[e],e,A),r[A]=r[A-1]+j,this}flush(A=this.length-1){return A>this.length&&this.set(A-1,this.BYTES_PER_ELEMENT>4?BigInt(0):0),super.flush(A+1)}};var Nj=class{static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A){throw new Error('"throughDOM" not available in this environment')}constructor({type:A,nullValues:j}){this.length=0,this.finished=!1,this.type=A,this.children=[],this.nullValues=j,this.stride=U6(A),this._nulls=new Ou,j&&j.length>0&&(this._isValid=XM(j))}toVector(){return new Dt([this.flush()])}get ArrayType(){return this.type.ArrayType}get nullCount(){return this._nulls.numInvalid}get numChildren(){return this.children.length}get byteLength(){let A=0,{_offsets:j,_values:e,_nulls:r,_typeIds:n,children:i}=this;return j&&(A+=j.byteLength),e&&(A+=e.byteLength),r&&(A+=r.byteLength),n&&(A+=n.byteLength),i.reduce((o,l)=>o+l.byteLength,A)}get reservedLength(){return this._nulls.reservedLength}get reservedByteLength(){let A=0;return this._offsets&&(A+=this._offsets.reservedByteLength),this._values&&(A+=this._values.reservedByteLength),this._nulls&&(A+=this._nulls.reservedByteLength),this._typeIds&&(A+=this._typeIds.reservedByteLength),this.children.reduce((j,e)=>j+e.reservedByteLength,A)}get valueOffsets(){return this._offsets?this._offsets.buffer:null}get values(){return this._values?this._values.buffer:null}get nullBitmap(){return this._nulls?this._nulls.buffer:null}get typeIds(){return this._typeIds?this._typeIds.buffer:null}append(A){return this.set(this.length,A)}isValid(A){return this._isValid(A)}set(A,j){return this.setValid(A,this.isValid(j))&&this.setValue(A,j),this}setValue(A,j){this._setValue(this,A,j)}setValid(A,j){return this.length=this._nulls.set(A,+j).length,j}addChild(A,j=`${this.numChildren}`){throw new Error(`Cannot append children to non-nested type "${this.type}"`)}getChildAt(A){return this.children[A]||null}flush(){let A,j,e,r,{type:n,length:i,nullCount:o,_typeIds:l,_offsets:c,_values:B,_nulls:h}=this;(j=l?.flush(i))?r=c?.flush(i):(r=c?.flush(i))?A=B?.flush(c.last()):A=B?.flush(i),o>0&&(e=h?.flush(i));let d=this.children.map(k=>k.flush());return this.clear(),ht({type:n,length:i,nullCount:o,children:d,child:d[0],data:A,typeIds:j,nullBitmap:e,valueOffsets:r})}finish(){this.finished=!0;for(let A of this.children)A.finish();return this}clear(){var A,j,e,r;this.length=0,(A=this._nulls)===null||A===void 0||A.clear(),(j=this._values)===null||j===void 0||j.clear(),(e=this._offsets)===null||e===void 0||e.clear(),(r=this._typeIds)===null||r===void 0||r.clear();for(let n of this.children)n.clear();return this}};Nj.prototype.length=1;Nj.prototype.stride=1;Nj.prototype.children=null;Nj.prototype.finished=!1;Nj.prototype.nullValues=null;Nj.prototype._isValid=()=>!0;var De=class extends Nj{constructor(A){super(A),this._values=new ca(this.ArrayType,0,this.stride)}setValue(A,j){let e=this._values;return e.reserve(A-e.length+1),super.setValue(A,j)}},g6=class extends Nj{constructor(A){super(A),this._pendingLength=0,this._offsets=new Tu(A.type)}setValue(A,j){let e=this._pending||(this._pending=new Map),r=e.get(A);r&&(this._pendingLength-=r.length),this._pendingLength+=j instanceof zo?j[hi].length:j.length,e.set(A,j)}setValid(A,j){return super.setValid(A,j)?!0:((this._pending||(this._pending=new Map)).set(A,void 0),!1)}clear(){return this._pendingLength=0,this._pending=void 0,super.clear()}flush(){return this._flush(),super.flush()}finish(){return this._flush(),super.finish()}_flush(){let A=this._pending,j=this._pendingLength;return this._pendingLength=0,this._pending=void 0,A&&A.size>0&&this._flushPending(A,j),this}};var Xl=class{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}offset(){return this.bb.readInt64(this.bb_pos)}metaDataLength(){return this.bb.readInt32(this.bb_pos+8)}bodyLength(){return this.bb.readInt64(this.bb_pos+16)}static sizeOf(){return 24}static createBlock(A,j,e,r){return A.prep(8,24),A.writeInt64(BigInt(r??0)),A.pad(4),A.writeInt32(e),A.writeInt64(BigInt(j??0)),A.offset()}};var V6=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsFooter(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsFooter(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}version(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):hj.V1}schema(A){let j=this.bb.__offset(this.bb_pos,6);return j?(A||new p6).__init(this.bb.__indirect(this.bb_pos+j),this.bb):null}dictionaries(A,j){let e=this.bb.__offset(this.bb_pos,8);return e?(j||new Xl).__init(this.bb.__vector(this.bb_pos+e)+A*24,this.bb):null}dictionariesLength(){let A=this.bb.__offset(this.bb_pos,8);return A?this.bb.__vector_len(this.bb_pos+A):0}recordBatches(A,j){let e=this.bb.__offset(this.bb_pos,10);return e?(j||new Xl).__init(this.bb.__vector(this.bb_pos+e)+A*24,this.bb):null}recordBatchesLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.__vector_len(this.bb_pos+A):0}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,12);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,12);return A?this.bb.__vector_len(this.bb_pos+A):0}static startFooter(A){A.startObject(5)}static addVersion(A,j){A.addFieldInt16(0,j,hj.V1)}static addSchema(A,j){A.addFieldOffset(1,j,0)}static addDictionaries(A,j){A.addFieldOffset(2,j,0)}static startDictionariesVector(A,j){A.startVector(24,j,8)}static addRecordBatches(A,j){A.addFieldOffset(3,j,0)}static startRecordBatchesVector(A,j){A.startVector(24,j,8)}static addCustomMetadata(A,j){A.addFieldOffset(4,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endFooter(A){return A.endObject()}static finishFooterBuffer(A,j){A.finish(j)}static finishSizePrefixedFooterBuffer(A,j){A.finish(j,void 0,!0)}};var aj=class t{constructor(A=[],j,e,r=hj.V5){this.fields=A||[],this.metadata=j||new Map,e||(e=_q(A)),this.dictionaries=e,this.metadataVersion=r}get[Symbol.toStringTag](){return"Schema"}get names(){return this.fields.map(A=>A.name)}toString(){return`Schema<{ ${this.fields.map((A,j)=>`${j}: ${A}`).join(", ")} }>`}select(A){let j=new Set(A),e=this.fields.filter(r=>j.has(r.name));return new t(e,this.metadata)}selectAt(A){let j=A.map(e=>this.fields[e]).filter(Boolean);return new t(j,this.metadata)}assign(...A){let j=A[0]instanceof t?A[0]:Array.isArray(A[0])?new t(A[0]):new t(A),e=[...this.fields],r=dm(dm(new Map,this.metadata),j.metadata),n=j.fields.filter(o=>{let l=e.findIndex(c=>c.name===o.name);return~l?(e[l]=o.clone({metadata:dm(dm(new Map,e[l].metadata),o.metadata)}))&&!1:!0}),i=_q(n,new Map);return new t([...e,...n],r,new Map([...this.dictionaries,...i]))}};aj.prototype.fields=null;aj.prototype.metadata=null;aj.prototype.dictionaries=null;var St=class t{static new(...A){let[j,e,r,n]=A;return A[0]&&typeof A[0]=="object"&&({name:j}=A[0],e===void 0&&(e=A[0].type),r===void 0&&(r=A[0].nullable),n===void 0&&(n=A[0].metadata)),new t(`${j}`,e,r,n)}constructor(A,j,e=!1,r){this.name=A,this.type=j,this.nullable=e,this.metadata=r||new Map}get typeId(){return this.type.typeId}get[Symbol.toStringTag](){return"Field"}toString(){return`${this.name}: ${this.type}`}clone(...A){let[j,e,r,n]=A;return!A[0]||typeof A[0]!="object"?[j=this.name,e=this.type,r=this.nullable,n=this.metadata]=A:{name:j=this.name,type:e=this.type,nullable:r=this.nullable,metadata:n=this.metadata}=A[0],t.new(j,e,r,n)}};St.prototype.type=null;St.prototype.name=null;St.prototype.nullable=null;St.prototype.metadata=null;function dm(t,A){return new Map([...t||new Map,...A||new Map])}function _q(t,A=new Map){for(let j=-1,e=t.length;++j0&&_q(n.children,A)}return A}var AQ=Cl,tQ=K6,ua=class{static decode(A){A=new tQ(it(A));let j=V6.getRootAsFooter(A),e=aj.decode(j.schema(),new Map,j.version());return new qq(e,j)}static encode(A){let j=new AQ,e=aj.encode(j,A.schema);V6.startRecordBatchesVector(j,A.numRecordBatches);for(let i of[...A.recordBatches()].slice().reverse())Ba.encode(j,i);let r=j.endVector();V6.startDictionariesVector(j,A.numDictionaries);for(let i of[...A.dictionaryBatches()].slice().reverse())Ba.encode(j,i);let n=j.endVector();return V6.startFooter(j),V6.addSchema(j,e),V6.addVersion(j,hj.V5),V6.addRecordBatches(j,r),V6.addDictionaries(j,n),V6.finishFooterBuffer(j,V6.endFooter(j)),j.asUint8Array()}get numRecordBatches(){return this._recordBatches.length}get numDictionaries(){return this._dictionaryBatches.length}constructor(A,j=hj.V5,e,r){this.schema=A,this.version=j,e&&(this._recordBatches=e),r&&(this._dictionaryBatches=r)}*recordBatches(){for(let A,j=-1,e=this.numRecordBatches;++j=0&&A=0&&A=0&&A=0&&Athis._closedPromiseResolve=A)}get closed(){return this._closedPromise}cancel(A){return OA(this,void 0,void 0,function*(){yield this.return(A)})}write(A){this._ensureOpen()&&(this.resolvers.length<=0?this._values.push(A):this.resolvers.shift().resolve({done:!1,value:A}))}abort(A){this._closedPromiseResolve&&(this.resolvers.length<=0?this._error={error:A}:this.resolvers.shift().reject({done:!0,value:A}))}close(){if(this._closedPromiseResolve){let{resolvers:A}=this;for(;A.length>0;)A.shift().resolve(Tj);this._closedPromiseResolve(),this._closedPromiseResolve=void 0}}[Symbol.asyncIterator](){return this}toDOMStream(A){return Mr.toDOMStream(this._closedPromiseResolve||this._error?this:this._values,A)}toNodeStream(A){return Mr.toNodeStream(this._closedPromiseResolve||this._error?this:this._values,A)}throw(A){return OA(this,void 0,void 0,function*(){return yield this.abort(A),Tj})}return(A){return OA(this,void 0,void 0,function*(){return yield this.close(),Tj})}read(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"read")).value})}peek(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"peek")).value})}next(...A){return this._values.length>0?Promise.resolve({done:!1,value:this._values.shift()}):this._error?Promise.reject({done:!0,value:this._error.error}):this._closedPromiseResolve?new Promise((j,e)=>{this.resolvers.push({resolve:j,reject:e})}):Promise.resolve(Tj)}_ensureOpen(){if(this._closedPromiseResolve)return!0;throw new Error("AsyncQueue is closed")}};var Uo=class extends pm{write(A){if((A=it(A)).byteLength>0)return super.write(A)}toString(A=!1){return A?mh(this.toUint8Array(!0)):this.toUint8Array(!1).then(mh)}toUint8Array(A=!1){return A?N6(this._values)[0]:OA(this,void 0,void 0,function*(){var j,e,r,n;let i=[],o=0;try{for(var l=!0,c=Ki(this),B;B=yield c.next(),j=B.done,!j;l=!0){n=B.value,l=!1;let h=n;i.push(h),o+=h.byteLength}}catch(h){e={error:h}}finally{try{!l&&!j&&(r=c.return)&&(yield r.call(c))}finally{if(e)throw e.error}}return N6(i,o)[0]})}},Vo=class{constructor(A){A&&(this.source=new bq(Mr.fromIterable(A)))}[Symbol.iterator](){return this}next(A){return this.source.next(A)}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}peek(A){return this.source.peek(A)}read(A){return this.source.read(A)}},di=class t{constructor(A){A instanceof t?this.source=A.source:A instanceof Uo?this.source=new fa(Mr.fromAsyncIterable(A)):_g(A)?this.source=new fa(Mr.fromNodeStream(A)):Eh(A)?this.source=new fa(Mr.fromDOMStream(A)):yg(A)?this.source=new fa(Mr.fromDOMStream(A.body)):Xi(A)?this.source=new fa(Mr.fromIterable(A)):D6(A)?this.source=new fa(Mr.fromAsyncIterable(A)):Bi(A)&&(this.source=new fa(Mr.fromAsyncIterable(A)))}[Symbol.asyncIterator](){return this}next(A){return this.source.next(A)}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}get closed(){return this.source.closed}cancel(A){return this.source.cancel(A)}peek(A){return this.source.peek(A)}read(A){return this.source.read(A)}},bq=class{constructor(A){this.source=A}cancel(A){this.return(A)}peek(A){return this.next(A,"peek").value}read(A){return this.next(A,"read").value}next(A,j="read"){return this.source.next({cmd:j,size:A})}throw(A){return Object.create(this.source.throw&&this.source.throw(A)||Tj)}return(A){return Object.create(this.source.return&&this.source.return(A)||Tj)}},fa=class{constructor(A){this.source=A,this._closedPromise=new Promise(j=>this._closedPromiseResolve=j)}cancel(A){return OA(this,void 0,void 0,function*(){yield this.return(A)})}get closed(){return this._closedPromise}read(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"read")).value})}peek(A){return OA(this,void 0,void 0,function*(){return(yield this.next(A,"peek")).value})}next(A,j="read"){return OA(this,void 0,void 0,function*(){return yield this.source.next({cmd:j,size:A})})}throw(A){return OA(this,void 0,void 0,function*(){let j=this.source.throw&&(yield this.source.throw(A))||Tj;return this._closedPromiseResolve&&this._closedPromiseResolve(),this._closedPromiseResolve=void 0,Object.create(j)})}return(A){return OA(this,void 0,void 0,function*(){let j=this.source.return&&(yield this.source.return(A))||Tj;return this._closedPromiseResolve&&this._closedPromiseResolve(),this._closedPromiseResolve=void 0,Object.create(j)})}};var Nh=class extends Vo{constructor(A,j){super(),this.position=0,this.buffer=it(A),this.size=j===void 0?this.buffer.byteLength:j}readInt32(A){let{buffer:j,byteOffset:e}=this.readAt(A,4);return new DataView(j,e).getInt32(0,!0)}seek(A){return this.position=Math.min(A,this.size),AKh,Int128:()=>Xh,Int64:()=>ha,Uint64:()=>re});function Su(t){return t<0&&(t=4294967295+t+1),`0x${t.toString(16)}`}var Ru=8,Gq=[1,10,100,1e3,1e4,1e5,1e6,1e7,1e8],Kh=class{constructor(A){this.buffer=A}high(){return this.buffer[1]}low(){return this.buffer[0]}_times(A){let j=new Uint32Array([this.buffer[1]>>>16,this.buffer[1]&65535,this.buffer[0]>>>16,this.buffer[0]&65535]),e=new Uint32Array([A.buffer[1]>>>16,A.buffer[1]&65535,A.buffer[0]>>>16,A.buffer[0]&65535]),r=j[3]*e[3];this.buffer[0]=r&65535;let n=r>>>16;return r=j[2]*e[3],n+=r,r=j[3]*e[2]>>>0,n+=r,this.buffer[0]+=n<<16,this.buffer[1]=n>>>0>>16,this.buffer[1]+=j[1]*e[3]+j[2]*e[2]+j[3]*e[1],this.buffer[1]+=j[0]*e[3]+j[1]*e[2]+j[2]*e[1]+j[3]*e[0]<<16,this}_plus(A){let j=this.buffer[0]+A.buffer[0]>>>0;this.buffer[1]+=A.buffer[1],j>>0&&++this.buffer[1],this.buffer[0]=j}lessThan(A){return this.buffer[1]>>0,j[2]=this.buffer[2]+A.buffer[2]>>>0,j[1]=this.buffer[1]+A.buffer[1]>>>0,j[0]=this.buffer[0]+A.buffer[0]>>>0,j[0]>>0&&++j[1],j[1]>>0&&++j[2],j[2]>>0&&++j[3],this.buffer[3]=j[3],this.buffer[2]=j[2],this.buffer[1]=j[1],this.buffer[0]=j[0],this}hex(){return`${Su(this.buffer[3])} ${Su(this.buffer[2])} ${Su(this.buffer[1])} ${Su(this.buffer[0])}`}static multiply(A,j){return new t(new Uint32Array(A.buffer)).times(j)}static add(A,j){return new t(new Uint32Array(A.buffer)).plus(j)}static from(A,j=new Uint32Array(4)){return t.fromString(typeof A=="string"?A:A.toString(),j)}static fromNumber(A,j=new Uint32Array(4)){return t.fromString(A.toString(),j)}static fromString(A,j=new Uint32Array(4)){let e=A.startsWith("-"),r=A.length,n=new t(j);for(let i=e?1:0;i0&&this.readData(A,e)||new Uint8Array(0)}readOffsets(A,j){return this.readData(A,j)}readTypeIds(A,j){return this.readData(A,j)}readData(A,{length:j,offset:e}=this.nextBufferRange()){return this.bytes.subarray(e,e+j)}readDictionary(A){return this.dictionaries.get(A.id)}},km=class extends zh{constructor(A,j,e,r,n){super(new Uint8Array(0),j,e,r,n),this.sources=A}readNullBitmap(A,j,{offset:e}=this.nextBufferRange()){return j<=0?new Uint8Array(0):Nl(this.sources[e])}readOffsets(A,{offset:j}=this.nextBufferRange()){return Mt(Uint8Array,Mt(A.OffsetArrayType,this.sources[j]))}readTypeIds(A,{offset:j}=this.nextBufferRange()){return Mt(Uint8Array,Mt(A.ArrayType,this.sources[j]))}readData(A,{offset:j}=this.nextBufferRange()){let{sources:e}=this;return HA.isTimestamp(A)?Mt(Uint8Array,ha.convertArray(e[j])):(HA.isInt(A)||HA.isTime(A))&&A.bitWidth===64||HA.isDuration(A)?Mt(Uint8Array,ha.convertArray(e[j])):HA.isDate(A)&&A.unit===Ce.MILLISECOND?Mt(Uint8Array,ha.convertArray(e[j])):HA.isDecimal(A)?Mt(Uint8Array,Xh.convertArray(e[j])):HA.isBinary(A)||HA.isLargeBinary(A)||HA.isFixedSizeBinary(A)?jQ(e[j]):HA.isBool(A)?Nl(e[j]):HA.isUtf8(A)||HA.isLargeUtf8(A)?Co(e[j].join("")):Mt(Uint8Array,Mt(A.ArrayType,e[j].map(r=>+r)))}};function jQ(t){let A=t.join(""),j=new Uint8Array(A.length/2);for(let e=0;e>1]=Number.parseInt(A.slice(e,e+2),16);return j}var Lu=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,it(j))}_flushPending(A,j){let e=this._offsets,r=this._values.reserve(j).buffer,n=0;for(let[i,o]of A)if(o===void 0)e.set(i,0);else{let l=o.length;r.set(o,n),e.set(i,l),n+=l}}};var Cu=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,it(j))}_flushPending(A,j){let e=this._offsets,r=this._values.reserve(j).buffer,n=0;for(let[i,o]of A)if(o===void 0)e.set(i,BigInt(0));else{let l=o.length;r.set(o,n),e.set(i,BigInt(l)),n+=l}}};var gm=class extends Nj{constructor(A){super(A),this._values=new Ou}setValue(A,j){this._values.set(A,+j)}};var Ul=class extends De{};Ul.prototype._setValue=aq;var Uh=class extends Ul{};Uh.prototype._setValue=Xg;var Vh=class extends Ul{};Vh.prototype._setValue=zg;var Qh=class extends De{};Qh.prototype._setValue=uq;var mm=class extends Nj{constructor({type:A,nullValues:j,dictionaryHashFunction:e}){super({type:new z6(A.dictionary,A.indices,A.id,A.isOrdered)}),this._nulls=null,this._dictionaryOffset=0,this._keysToIndices=Object.create(null),this.indices=Vl({type:this.type.indices,nullValues:j}),this.dictionary=Vl({type:this.type.dictionary,nullValues:null}),typeof e=="function"&&(this.valueToKey=e)}get values(){return this.indices.values}get nullCount(){return this.indices.nullCount}get nullBitmap(){return this.indices.nullBitmap}get byteLength(){return this.indices.byteLength+this.dictionary.byteLength}get reservedLength(){return this.indices.reservedLength+this.dictionary.reservedLength}get reservedByteLength(){return this.indices.reservedByteLength+this.dictionary.reservedByteLength}isValid(A){return this.indices.isValid(A)}setValid(A,j){let e=this.indices;return j=e.setValid(A,j),this.length=e.length,j}setValue(A,j){let e=this._keysToIndices,r=this.valueToKey(j),n=e[r];return n===void 0&&(e[r]=n=this._dictionaryOffset+this.dictionary.append(j).length-1),this.indices.setValue(A,n)}flush(){let A=this.type,j=this._dictionary,e=this.dictionary.toVector(),r=this.indices.flush().clone(A);return r.dictionary=j?j.concat(e):e,this.finished||(this._dictionaryOffset+=e.length),this._dictionary=r.dictionary,this.clear(),r}finish(){return this.indices.finish(),this.dictionary.finish(),this._dictionaryOffset=0,this._keysToIndices=Object.create(null),super.finish()}clear(){return this.indices.clear(),this.dictionary.clear(),super.clear()}valueToKey(A){return typeof A=="string"?A:`${A}`}};var Wh=class extends De{};Wh.prototype._setValue=sq;var Em=class extends Nj{setValue(A,j){let[e]=this.children,r=A*this.stride;for(let n=-1,i=j.length;++n0)throw new Error("FixedSizeListBuilder can only have one child.");let e=this.children.push(A);return this.type=new jo(this.type.listSize,new St(j,A.type,!0)),e}};var Ql=class extends De{setValue(A,j){this._values.set(A,j)}},$m=class extends Ql{setValue(A,j){super.setValue(A,Sh(j))}},xm=class extends Ql{},ym=class extends Ql{};var Wl=class extends De{};Wl.prototype._setValue=Bq;var Yh=class extends Wl{};Yh.prototype._setValue=tm;var Jh=class extends Wl{};Jh.prototype._setValue=jm;var da=class extends De{};da.prototype._setValue=fq;var Zh=class extends da{};Zh.prototype._setValue=em;var Ad=class extends da{};Ad.prototype._setValue=rm;var td=class extends da{};td.prototype._setValue=nm;var jd=class extends da{};jd.prototype._setValue=im;var pi=class extends De{setValue(A,j){this._values.set(A,j)}},vm=class extends pi{},_m=class extends pi{},qm=class extends pi{},bm=class extends pi{},Gm=class extends pi{},wm=class extends pi{},Fm=class extends pi{},Pm=class extends pi{};var Im=class extends g6{constructor(A){super(A),this._offsets=new Tu(A.type)}addChild(A,j="0"){if(this.numChildren>0)throw new Error("ListBuilder can only have one child.");return this.children[this.numChildren]=A,this.type=new Ao(new St(j,A.type,!0)),this.numChildren-1}_flushPending(A){let j=this._offsets,[e]=this.children;for(let[r,n]of A)if(typeof n>"u")j.set(r,0);else{let i=n,o=i.length,l=j.set(r,o).buffer[r];for(let c=-1;++c0)throw new Error("ListBuilder can only have one child.");return this.children[this.numChildren]=A,this.type=new eo(new St(j,A.type,!0),this.type.keysSorted),this.numChildren-1}_flushPending(A){let j=this._offsets,[e]=this.children;for(let[r,n]of A)if(n===void 0)j.set(r,0);else{let{[r]:i,[r+1]:o}=j.set(r,n.size).buffer;for(let l of n.entries())if(e.set(i,l),++i>=o)break}}};var Om=class extends Nj{setValue(A,j){}setValid(A,j){return this.length=Math.max(A+1,this.length),j}};var Tm=class extends Nj{setValue(A,j){let{children:e,type:r}=this;switch(Array.isArray(j)||j.constructor){case!0:return r.children.forEach((n,i)=>e[i].set(A,j[i]));case Map:return r.children.forEach((n,i)=>e[i].set(A,j.get(n.name)));default:return r.children.forEach((n,i)=>e[i].set(A,j[n.name]))}}setValid(A,j){return super.setValid(A,j)||this.children.forEach(e=>e.setValid(A,j)),j}addChild(A,j=`${this.numChildren}`){let e=this.children.push(A);return this.type=new Oj([...this.type.children,new St(j,A.type,!0)]),e}};var pa=class extends De{};pa.prototype._setValue=lq;var ed=class extends pa{};ed.prototype._setValue=Ug;var rd=class extends pa{};rd.prototype._setValue=Vg;var nd=class extends pa{};nd.prototype._setValue=Qg;var id=class extends pa{};id.prototype._setValue=Wg;var ka=class extends De{};ka.prototype._setValue=cq;var od=class extends ka{};od.prototype._setValue=Yg;var sd=class extends ka{};sd.prototype._setValue=Jg;var ad=class extends ka{};ad.prototype._setValue=Zg;var ld=class extends ka{};ld.prototype._setValue=Am;var Hu=class extends Nj{constructor(A){super(A),this._typeIds=new ca(Int8Array,0,1),typeof A.valueToChildTypeId=="function"&&(this._valueToChildTypeId=A.valueToChildTypeId)}get typeIdToChildIndex(){return this.type.typeIdToChildIndex}append(A,j){return this.set(this.length,A,j)}set(A,j,e){return e===void 0&&(e=this._valueToChildTypeId(this,j,A)),this.setValue(A,j,e),this}setValue(A,j,e){this._typeIds.set(A,e);let r=this.type.typeIdToChildIndex[e],n=this.children[r];n?.set(A,j)}addChild(A,j=`${this.children.length}`){let e=this.children.push(A),{type:{children:r,mode:n,typeIds:i}}=this,o=[...r,new St(j,A.type)];return this.type=new to(n,[...i,e],o),e}_valueToChildTypeId(A,j,e){throw new Error("Cannot map UnionBuilder value to child typeId. Pass the `childTypeId` as the second argument to unionBuilder.append(), or supply a `valueToChildTypeId` function as part of the UnionBuilder constructor options.")}},Sm=class extends Hu{},Rm=class extends Hu{constructor(A){super(A),this._offsets=new ca(Int32Array)}setValue(A,j,e){let r=this._typeIds.set(A,e).buffer[A],n=this.getChildAt(this.type.typeIdToChildIndex[r]),i=this._offsets.set(A,n.length).buffer[A];n?.set(i,j)}};var cd=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,Co(j))}_flushPending(A,j){}};cd.prototype._flushPending=Lu.prototype._flushPending;var ud=class extends g6{constructor(A){super(A),this._values=new no(Uint8Array)}get byteLength(){let A=this._pendingLength+this.length*4;return this._offsets&&(A+=this._offsets.byteLength),this._values&&(A+=this._values.byteLength),this._nulls&&(A+=this._nulls.byteLength),A}setValue(A,j){return super.setValue(A,Co(j))}_flushPending(A,j){}};ud.prototype._flushPending=Cu.prototype._flushPending;var Fq=class extends WA{visitNull(){return Om}visitBool(){return gm}visitInt(){return pi}visitInt8(){return vm}visitInt16(){return _m}visitInt32(){return qm}visitInt64(){return bm}visitUint8(){return Gm}visitUint16(){return wm}visitUint32(){return Fm}visitUint64(){return Pm}visitFloat(){return Ql}visitFloat16(){return $m}visitFloat32(){return xm}visitFloat64(){return ym}visitUtf8(){return cd}visitLargeUtf8(){return ud}visitBinary(){return Lu}visitLargeBinary(){return Cu}visitFixedSizeBinary(){return Wh}visitDate(){return Ul}visitDateDay(){return Uh}visitDateMillisecond(){return Vh}visitTimestamp(){return pa}visitTimestampSecond(){return ed}visitTimestampMillisecond(){return rd}visitTimestampMicrosecond(){return nd}visitTimestampNanosecond(){return id}visitTime(){return ka}visitTimeSecond(){return od}visitTimeMillisecond(){return sd}visitTimeMicrosecond(){return ad}visitTimeNanosecond(){return ld}visitDecimal(){return Qh}visitList(){return Im}visitStruct(){return Tm}visitUnion(){return Hu}visitDenseUnion(){return Rm}visitSparseUnion(){return Sm}visitDictionary(){return mm}visitInterval(){return Wl}visitIntervalDayTime(){return Yh}visitIntervalYearMonth(){return Jh}visitDuration(){return da}visitDurationSecond(){return Zh}visitDurationMillisecond(){return Ad}visitDurationMicrosecond(){return td}visitDurationNanosecond(){return jd}visitFixedSizeList(){return Em}visitMap(){return Mm}},UM=new Fq;var At=class extends WA{compareSchemas(A,j){return A===j||j instanceof A.constructor&&this.compareManyFields(A.fields,j.fields)}compareManyFields(A,j){return A===j||Array.isArray(A)&&Array.isArray(j)&&A.length===j.length&&A.every((e,r)=>this.compareFields(e,j[r]))}compareFields(A,j){return A===j||j instanceof A.constructor&&A.name===j.name&&A.nullable===j.nullable&&this.visit(A.type,j.type)}};function Gn(t,A){return A instanceof t.constructor}function Yl(t,A){return t===A||Gn(t,A)}function ga(t,A){return t===A||Gn(t,A)&&t.bitWidth===A.bitWidth&&t.isSigned===A.isSigned}function Lm(t,A){return t===A||Gn(t,A)&&t.precision===A.precision}function eQ(t,A){return t===A||Gn(t,A)&&t.byteWidth===A.byteWidth}function Pq(t,A){return t===A||Gn(t,A)&&t.unit===A.unit}function Bd(t,A){return t===A||Gn(t,A)&&t.unit===A.unit&&t.timezone===A.timezone}function fd(t,A){return t===A||Gn(t,A)&&t.unit===A.unit&&t.bitWidth===A.bitWidth}function rQ(t,A){return t===A||Gn(t,A)&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function nQ(t,A){return t===A||Gn(t,A)&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function Iq(t,A){return t===A||Gn(t,A)&&t.mode===A.mode&&t.typeIds.every((j,e)=>j===A.typeIds[e])&&Qo.compareManyFields(t.children,A.children)}function iQ(t,A){return t===A||Gn(t,A)&&t.id===A.id&&t.isOrdered===A.isOrdered&&Qo.visit(t.indices,A.indices)&&Qo.visit(t.dictionary,A.dictionary)}function Mq(t,A){return t===A||Gn(t,A)&&t.unit===A.unit}function hd(t,A){return t===A||Gn(t,A)&&t.unit===A.unit}function oQ(t,A){return t===A||Gn(t,A)&&t.listSize===A.listSize&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}function sQ(t,A){return t===A||Gn(t,A)&&t.keysSorted===A.keysSorted&&t.children.length===A.children.length&&Qo.compareManyFields(t.children,A.children)}At.prototype.visitNull=Yl;At.prototype.visitBool=Yl;At.prototype.visitInt=ga;At.prototype.visitInt8=ga;At.prototype.visitInt16=ga;At.prototype.visitInt32=ga;At.prototype.visitInt64=ga;At.prototype.visitUint8=ga;At.prototype.visitUint16=ga;At.prototype.visitUint32=ga;At.prototype.visitUint64=ga;At.prototype.visitFloat=Lm;At.prototype.visitFloat16=Lm;At.prototype.visitFloat32=Lm;At.prototype.visitFloat64=Lm;At.prototype.visitUtf8=Yl;At.prototype.visitLargeUtf8=Yl;At.prototype.visitBinary=Yl;At.prototype.visitLargeBinary=Yl;At.prototype.visitFixedSizeBinary=eQ;At.prototype.visitDate=Pq;At.prototype.visitDateDay=Pq;At.prototype.visitDateMillisecond=Pq;At.prototype.visitTimestamp=Bd;At.prototype.visitTimestampSecond=Bd;At.prototype.visitTimestampMillisecond=Bd;At.prototype.visitTimestampMicrosecond=Bd;At.prototype.visitTimestampNanosecond=Bd;At.prototype.visitTime=fd;At.prototype.visitTimeSecond=fd;At.prototype.visitTimeMillisecond=fd;At.prototype.visitTimeMicrosecond=fd;At.prototype.visitTimeNanosecond=fd;At.prototype.visitDecimal=Yl;At.prototype.visitList=rQ;At.prototype.visitStruct=nQ;At.prototype.visitUnion=Iq;At.prototype.visitDenseUnion=Iq;At.prototype.visitSparseUnion=Iq;At.prototype.visitDictionary=iQ;At.prototype.visitInterval=Mq;At.prototype.visitIntervalDayTime=Mq;At.prototype.visitIntervalYearMonth=Mq;At.prototype.visitDuration=hd;At.prototype.visitDurationSecond=hd;At.prototype.visitDurationMillisecond=hd;At.prototype.visitDurationMicrosecond=hd;At.prototype.visitDurationNanosecond=hd;At.prototype.visitFixedSizeList=oQ;At.prototype.visitMap=sQ;var Qo=new At;function Jl(t,A){return Qo.compareSchemas(t,A)}function VM(t,A){return Qo.compareFields(t,A)}function QM(t,A){return Qo.visit(t,A)}function Vl(t){let A=t.type,j=new(UM.getVisitFn(A)())(t);if(A.children&&A.children.length>0){let e=t.children||[],r={nullValues:t.nullValues},n=Array.isArray(e)?(i,o)=>e[o]||r:({name:i})=>e[i]||r;for(let[i,o]of A.children.entries()){let{type:l}=o,c=n(o,i);j.children.push(Vl(Object.assign(Object.assign({},c),{type:l})))}}return j}function Cm(t,A){return aQ(t,A.map(j=>j.data.concat()))}function aQ(t,A){let j=[...t.fields],e=[],r={numBatches:A.reduce((h,d)=>Math.max(h,d.length),0)},n=0,i=0,o=-1,l=A.length,c,B=[];for(;r.numBatches-- >0;){for(i=Number.POSITIVE_INFINITY,o=-1;++o0&&(e[n++]=ht({type:new Oj(j),length:i,nullCount:0,children:B.slice()})))}return[t=t.assign(j),e.map(h=>new Be(t,h))]}function lQ(t,A,j,e,r){var n;let i=(A+63&-64)>>3;for(let o=-1,l=e.length;++o=A)B===A?j[o]=c:(j[o]=c.slice(0,A),r.numBatches=Math.max(r.numBatches,e[o].unshift(c.slice(A,B-A))));else{let h=t[o];t[o]=h.clone({nullable:!0}),j[o]=(n=c?._changeLengthAndBackfillNullBitmap(A))!==null&&n!==void 0?n:ht({type:h.type,length:A,nullCount:A,nullBitmap:new Uint8Array(i)})}}return j}var WM,m6=class t{constructor(...A){var j,e;if(A.length===0)return this.batches=[],this.schema=new aj([]),this._offsets=[0],this;let r,n;A[0]instanceof aj&&(r=A.shift()),A.at(-1)instanceof Uint32Array&&(n=A.pop());let i=l=>{if(l){if(l instanceof Be)return[l];if(l instanceof t)return l.batches;if(l instanceof rj){if(l.type instanceof Oj)return[new Be(new aj(l.type.children),l)]}else{if(Array.isArray(l))return l.flatMap(c=>i(c));if(typeof l[Symbol.iterator]=="function")return[...l].flatMap(c=>i(c));if(typeof l=="object"){let c=Object.keys(l),B=c.map(k=>new Dt([l[k]])),h=r??new aj(c.map((k,g)=>new St(String(k),B[g].type,B[g].nullable))),[,d]=Cm(h,B);return d.length===0?[new Be(l)]:d}}}return[]},o=A.flatMap(l=>i(l));if(r=(e=r??((j=o[0])===null||j===void 0?void 0:j.schema))!==null&&e!==void 0?e:new aj([]),!(r instanceof aj))throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");for(let l of o){if(!(l instanceof Be))throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");if(!Jl(r,l.schema))throw new TypeError("Table and inner RecordBatch schemas must be equivalent.")}this.schema=r,this.batches=o,this._offsets=n??cm(this.data)}get data(){return this.batches.map(({data:A})=>A)}get numCols(){return this.schema.fields.length}get numRows(){return this.data.reduce((A,j)=>A+j.length,0)}get nullCount(){return this._nullCount===-1&&(this._nullCount=lm(this.data)),this._nullCount}isValid(A){return!1}get(A){return null}set(A,j){}indexOf(A,j){return-1}[Symbol.iterator](){return this.batches.length>0?Mu.visit(new Dt(this.data)):new Array(0)[Symbol.iterator]()}toArray(){return[...this]}toString(){return`[ ${this.toArray().join(`, `)} -]`}concat(...A){let j=this.schema,e=this.data.concat(A.flatMap(({data:r})=>r));return new t(j,e.map(r=>new Be(j,r)))}slice(A,j){let e=this.schema;[A,j]=Th({length:this.numRows},A,j);let r=om(this.data,this._offsets,A,j);return new t(e,r.map(n=>new Be(e,n)))}getChild(A){return this.getChildAt(this.schema.fields.findIndex(j=>j.name===A))}getChildAt(A){if(A>-1&&Ae.children[A]);if(j.length===0){let{type:e}=this.schema.fields[A],r=ht({type:e,length:0,nullCount:0});j.push(r._changeLengthAndBackfillNullBitmap(this.numRows))}return new Dt(j)}return null}setChild(A,j){var e;return this.setChildAt((e=this.schema.fields)===null||e===void 0?void 0:e.findIndex(r=>r.name===A),j)}setChildAt(A,j){let e=this.schema,r=[...this.batches];if(A>-1&&Athis.getChildAt(c));[n[A],o[A]]=[i,j],[e,r]=Om(e,o)}return new t(e,r)}select(A){let j=this.schema.fields.reduce((e,r,n)=>e.set(r.name,n),new Map);return this.selectAt(A.map(e=>j.get(e)).filter(e=>e>-1))}selectAt(A){let j=this.schema.selectAt(A),e=this.batches.map(r=>r.selectAt(A));return new t(j,e)}assign(A){let j=this.schema.fields,[e,r]=A.schema.fields.reduce((o,l,c)=>{let[B,h]=o,d=j.findIndex(k=>k.name===l.name);return~d?h[d]=c:B.push(c),o},[[],[]]),n=this.schema.assign(A.schema),i=[...j.map((o,l)=>[l,r[l]]).map(([o,l])=>l===void 0?this.getChildAt(o):A.getChildAt(l)),...e.map(o=>A.getChildAt(o))].filter(Boolean);return new t(...Om(n,i))}};KM=Symbol.toStringTag;m6[KM]=(t=>(t.schema=null,t.batches=[],t._offsets=new Uint32Array([0]),t._nullCount=-1,t[Symbol.isConcatSpreadable]=!0,t.isValid=Iu(Lh),t.get=Iu(He.getVisitFn(Z.Struct)),t.set=sm(Or.getVisitFn(Z.Struct)),t.indexOf=am(Nl.getVisitFn(Z.Struct)),"Table"))(m6.prototype);var zM,Be=class t{constructor(...A){switch(A.length){case 2:{if([this.schema]=A,!(this.schema instanceof aj))throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");if([,this.data=ht({nullCount:0,type:new Oj(this.schema.fields),children:this.schema.fields.map(j=>ht({type:j.type,nullCount:0}))})]=A,!(this.data instanceof rj))throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");[this.schema,this.data]=XM(this.schema,this.data.children);break}case 1:{let[j]=A,{fields:e,children:r,length:n}=Object.keys(j).reduce((l,c,B)=>(l.children[B]=j[c],l.length=Math.max(l.length,j[c].length),l.fields[B]=St.new({name:c,type:j[c].type,nullable:!0}),l),{length:0,fields:new Array,children:new Array}),i=new aj(e),o=ht({type:new Oj(e),length:n,children:r,nullCount:0});[this.schema,this.data]=XM(i,o.children,n);break}default:throw new TypeError("RecordBatch constructor expects an Object mapping names to child Data, or a [Schema, Data] pair.")}}get dictionaries(){return this._dictionaries||(this._dictionaries=UM(this.schema.fields,this.data.children))}get numCols(){return this.schema.fields.length}get numRows(){return this.data.length}get nullCount(){return this.data.nullCount}isValid(A){return this.data.getValid(A)}get(A){return He.visit(this.data,A)}set(A,j){return Or.visit(this.data,A,j)}indexOf(A,j){return Nl.visit(this.data,A,j)}[Symbol.iterator](){return Mu.visit(new Dt([this.data]))}toArray(){return[...this]}concat(...A){return new m6(this.schema,[this,...A])}slice(A,j){let[e]=new Dt([this.data]).slice(A,j).data;return new t(this.schema,e)}getChild(A){var j;return this.getChildAt((j=this.schema.fields)===null||j===void 0?void 0:j.findIndex(e=>e.name===A))}getChildAt(A){return A>-1&&Ar.name===A),j)}setChildAt(A,j){let e=this.schema,r=this.data;if(A>-1&&Ao.name===n);~i&&(r[i]=this.data.children[i])}return new t(j,ht({type:e,length:this.numRows,children:r}))}selectAt(A){let j=this.schema.selectAt(A),e=A.map(n=>this.data.children[n]).filter(Boolean),r=ht({type:new Oj(j.fields),length:this.numRows,children:e});return new t(j,r)}};zM=Symbol.toStringTag;Be[zM]=(t=>(t._nullCount=-1,t[Symbol.isConcatSpreadable]=!0,"RecordBatch"))(Be.prototype);function XM(t,A,j=A.reduce((e,r)=>Math.max(e,r.length),0)){var e;let r=[...t.fields],n=[...A],i=(j+63&-64)>>3;for(let[o,l]of t.fields.entries()){let c=A[o];(!c||c.length!==j)&&(r[o]=l.clone({nullable:!0}),n[o]=(e=c?._changeLengthAndBackfillNullBitmap(j))!==null&&e!==void 0?e:ht({type:l.type,length:j,nullCount:j,nullBitmap:new Uint8Array(i)}))}return[t.assign(r),ht({type:new Oj(r),length:j,children:n})]}function UM(t,A,j=new Map){var e,r;if(((e=t?.length)!==null&&e!==void 0?e:0)>0&&t?.length===A?.length)for(let n=-1,i=t.length;++nht({type:r.type})),e=ht({type:new Oj(A.fields),nullCount:0,children:j});super(A,e)}};var io=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsMessage(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsMessage(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}version(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):hj.V1}headerType(){let A=this.bb.__offset(this.bb_pos,6);return A?this.bb.readUint8(this.bb_pos+A):Lt.NONE}header(A){let j=this.bb.__offset(this.bb_pos,8);return j?this.bb.__union(A,this.bb_pos+j):null}bodyLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.readInt64(this.bb_pos+A):BigInt("0")}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,12);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,12);return A?this.bb.__vector_len(this.bb_pos+A):0}static startMessage(A){A.startObject(5)}static addVersion(A,j){A.addFieldInt16(0,j,hj.V1)}static addHeaderType(A,j){A.addFieldInt8(1,j,Lt.NONE)}static addHeader(A,j){A.addFieldOffset(2,j,0)}static addBodyLength(A,j){A.addFieldInt64(3,j,BigInt("0"))}static addCustomMetadata(A,j){A.addFieldOffset(4,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endMessage(A){return A.endObject()}static finishMessageBuffer(A,j){A.finish(j)}static finishSizePrefixedMessageBuffer(A,j){A.finish(j,void 0,!0)}static createMessage(A,j,e,r,n,i){return t.startMessage(A),t.addVersion(A,j),t.addHeaderType(A,e),t.addHeader(A,r),t.addBodyLength(A,n),t.addCustomMetadata(A,i),t.endMessage(A)}};var wq=class extends WA{visit(A,j){return A==null||j==null?void 0:super.visit(A,j)}visitNull(A,j){return wh.startNull(j),wh.endNull(j)}visitInt(A,j){return Vi.startInt(j),Vi.addBitWidth(j,A.bitWidth),Vi.addIsSigned(j,A.isSigned),Vi.endInt(j)}visitFloat(A,j){return p7.startFloatingPoint(j),p7.addPrecision(j,A.precision),p7.endFloatingPoint(j)}visitBinary(A,j){return vh.startBinary(j),vh.endBinary(j)}visitLargeBinary(A,j){return qh.startLargeBinary(j),qh.endLargeBinary(j)}visitBool(A,j){return _h.startBool(j),_h.endBool(j)}visitUtf8(A,j){return Ph.startUtf8(j),Ph.endUtf8(j)}visitLargeUtf8(A,j){return Gh.startLargeUtf8(j),Gh.endLargeUtf8(j)}visitDecimal(A,j){return Ko.startDecimal(j),Ko.addScale(j,A.scale),Ko.addPrecision(j,A.precision),Ko.addBitWidth(j,A.bitWidth),Ko.endDecimal(j)}visitDate(A,j){return B7.startDate(j),B7.addUnit(j,A.unit),B7.endDate(j)}visitTime(A,j){return Ys.startTime(j),Ys.addUnit(j,A.unit),Ys.addBitWidth(j,A.bitWidth),Ys.endTime(j)}visitTimestamp(A,j){let e=A.timezone&&j.createString(A.timezone)||void 0;return Js.startTimestamp(j),Js.addUnit(j,A.unit),e!==void 0&&Js.addTimezone(j,e),Js.endTimestamp(j)}visitInterval(A,j){return k7.startInterval(j),k7.addUnit(j,A.unit),k7.endInterval(j)}visitDuration(A,j){return f7.startDuration(j),f7.addUnit(j,A.unit),f7.endDuration(j)}visitList(A,j){return bh.startList(j),bh.endList(j)}visitStruct(A,j){return Fh.startStruct_(j),Fh.endStruct_(j)}visitUnion(A,j){Qi.startTypeIdsVector(j,A.typeIds.length);let e=Qi.createTypeIdsVector(j,A.typeIds);return Qi.startUnion(j),Qi.addMode(j,A.mode),Qi.addTypeIds(j,e),Qi.endUnion(j)}visitDictionary(A,j){let e=this.visit(A.indices,j);return No.startDictionaryEncoding(j),No.addId(j,BigInt(A.id)),No.addIsOrdered(j,A.isOrdered),e!==void 0&&No.addIndexType(j,e),No.endDictionaryEncoding(j)}visitFixedSizeBinary(A,j){return h7.startFixedSizeBinary(j),h7.addByteWidth(j,A.byteWidth),h7.endFixedSizeBinary(j)}visitFixedSizeList(A,j){return d7.startFixedSizeList(j),d7.addListSize(j,A.listSize),d7.endFixedSizeList(j)}visitMap(A,j){return g7.startMap(j),g7.addKeysSorted(j,A.keysSorted),g7.endMap(j)}},Tm=new wq;function YM(t,A=new Map){return new aj(iQ(t,A),Sm(t.metadata),A)}function Fq(t){return new Tr(t.count,ZM(t.columns),A4(t.columns))}function JM(t){return new $6(Fq(t.data),t.id,t.isDelta)}function iQ(t,A){return(t.fields||[]).filter(Boolean).map(j=>St.fromJSON(j,A))}function VM(t,A){return(t.children||[]).filter(Boolean).map(j=>St.fromJSON(j,A))}function ZM(t){return(t||[]).reduce((A,j)=>[...A,new ki(j.count,oQ(j.VALIDITY)),...ZM(j.children)],[])}function A4(t,A=[]){for(let j=-1,e=(t||[]).length;++jA+ +(j===0),0)}function t4(t,A){let j,e,r,n,i,o;return!A||!(n=t.dictionary)?(i=WM(t,VM(t,A)),r=new St(t.name,i,t.nullable,Sm(t.metadata))):A.has(j=n.id)?(e=(e=n.indexType)?QM(e):new Xo,o=new z6(A.get(j),e,j,n.isOrdered),r=new St(t.name,o,t.nullable,Sm(t.metadata))):(e=(e=n.indexType)?QM(e):new Xo,A.set(j,i=WM(t,VM(t,A))),o=new z6(i,e,j,n.isOrdered),r=new St(t.name,o,t.nullable,Sm(t.metadata))),r||null}function Sm(t=[]){return new Map(t.map(({key:A,value:j})=>[A,j]))}function QM(t){return new qe(t.isSigned,t.bitWidth)}function WM(t,A){let j=t.type.name;switch(j){case"NONE":return new Gn;case"null":return new Gn;case"binary":return new Zs;case"largebinary":return new Aa;case"utf8":return new ta;case"largeutf8":return new ja;case"bool":return new ea;case"list":return new Ao((A||[])[0]);case"struct":return new Oj(A||[]);case"struct_":return new Oj(A||[])}switch(j){case"int":{let e=t.type;return new qe(e.isSigned,e.bitWidth)}case"floatingpoint":{let e=t.type;return new k6(mj[e.precision])}case"decimal":{let e=t.type;return new ra(e.scale,e.precision,e.bitWidth)}case"date":{let e=t.type;return new na(Ce[e.unit])}case"time":{let e=t.type;return new Zi(XA[e.unit],e.bitWidth)}case"timestamp":{let e=t.type;return new ia(XA[e.unit],e.timezone)}case"interval":{let e=t.type;return new oa(hr[e.unit])}case"duration":{let e=t.type;return new sa(XA[e.unit])}case"union":{let e=t.type,[r,...n]=(e.mode+"").toLowerCase(),i=r.toUpperCase()+n.join("");return new to(bj[i],e.typeIds||[],A||[])}case"fixedsizebinary":{let e=t.type;return new aa(e.byteWidth)}case"fixedsizelist":{let e=t.type;return new jo(e.listSize,(A||[])[0])}case"map":{let e=t.type;return new eo((A||[])[0],e.keysSorted)}}throw new Error(`Unrecognized type: "${j}"`)}var sQ=Ll,aQ=K6,x6=class t{static fromJSON(A,j){let e=new t(0,hj.V5,j);return e._createHeader=lQ(A,j),e}static decode(A){A=new aQ(it(A));let j=io.getRootAsMessage(A),e=j.bodyLength(),r=j.version(),n=j.headerType(),i=new t(e,r,n);return i._createHeader=cQ(j,n),i}static encode(A){let j=new sQ,e=-1;return A.isSchema()?e=aj.encode(j,A.header()):A.isRecordBatch()?e=Tr.encode(j,A.header()):A.isDictionaryBatch()&&(e=$6.encode(j,A.header())),io.startMessage(j),io.addVersion(j,hj.V5),io.addHeader(j,e),io.addHeaderType(j,A.headerType),io.addBodyLength(j,BigInt(A.bodyLength)),io.finishMessageBuffer(j,io.endMessage(j)),j.asUint8Array()}static from(A,j=0){if(A instanceof aj)return new t(0,hj.V5,Lt.Schema,A);if(A instanceof Tr)return new t(j,hj.V5,Lt.RecordBatch,A);if(A instanceof $6)return new t(j,hj.V5,Lt.DictionaryBatch,A);throw new Error(`Unrecognized Message header: ${A}`)}get type(){return this.headerType}get version(){return this._version}get headerType(){return this._headerType}get bodyLength(){return this._bodyLength}header(){return this._createHeader()}isSchema(){return this.headerType===Lt.Schema}isRecordBatch(){return this.headerType===Lt.RecordBatch}isDictionaryBatch(){return this.headerType===Lt.DictionaryBatch}constructor(A,j,e,r){this._version=j,this._headerType=e,this.body=new Uint8Array(0),r&&(this._createHeader=()=>r),this._bodyLength=ee(A)}},Tr=class{get nodes(){return this._nodes}get length(){return this._length}get buffers(){return this._buffers}constructor(A,j,e){this._nodes=j,this._buffers=e,this._length=ee(A)}},$6=class{get id(){return this._id}get data(){return this._data}get isDelta(){return this._isDelta}get length(){return this.data.length}get nodes(){return this.data.nodes}get buffers(){return this.data.buffers}constructor(A,j,e=!1){this._data=A,this._isDelta=e,this._id=ee(j)}},E6=class{constructor(A,j){this.offset=ee(A),this.length=ee(j)}},ki=class{constructor(A,j){this.length=ee(A),this.nullCount=ee(j)}};function lQ(t,A){return()=>{switch(A){case Lt.Schema:return aj.fromJSON(t);case Lt.RecordBatch:return Tr.fromJSON(t);case Lt.DictionaryBatch:return $6.fromJSON(t)}throw new Error(`Unrecognized Message type: { name: ${Lt[A]}, type: ${A} }`)}}function cQ(t,A){return()=>{switch(A){case Lt.Schema:return aj.decode(t.header(new p6),new Map,t.version());case Lt.RecordBatch:return Tr.decode(t.header(new X6),t.version());case Lt.DictionaryBatch:return $6.decode(t.header(new Ws),t.version())}throw new Error(`Unrecognized Message type: { name: ${Lt[A]}, type: ${A} }`)}}St.encode=$Q;St.decode=mQ;St.fromJSON=t4;aj.encode=EQ;aj.decode=uQ;aj.fromJSON=YM;Tr.encode=xQ;Tr.decode=BQ;Tr.fromJSON=Fq;$6.encode=yQ;$6.decode=fQ;$6.fromJSON=JM;ki.encode=vQ;ki.decode=dQ;E6.encode=_Q;E6.decode=hQ;function uQ(t,A=new Map,j=hj.V5){let e=gQ(t,A);return new aj(e,Rm(t),A,j)}function BQ(t,A=hj.V5){if(t.compression()!==null)throw new Error("Record batch compression not implemented");return new Tr(t.length(),pQ(t),kQ(t,A))}function fQ(t,A=hj.V5){return new $6(Tr.decode(t.data(),A),t.id(),t.isDelta())}function hQ(t){return new E6(t.offset(),t.length())}function dQ(t){return new ki(t.length(),t.nullCount())}function pQ(t){let A=[];for(let j,e=-1,r=-1,n=t.nodesLength();++eSt.encode(t,n));p6.startFieldsVector(t,j.length);let e=p6.createFieldsVector(t,j),r=A.metadata&&A.metadata.size>0?p6.createCustomMetadataVector(t,[...A.metadata].map(([n,i])=>{let o=t.createString(`${n}`),l=t.createString(`${i}`);return Je.startKeyValue(t),Je.addKey(t,o),Je.addValue(t,l),Je.endKeyValue(t)})):-1;return p6.startSchema(t),p6.addFields(t,e),p6.addEndianness(t,qQ?u7.Little:u7.Big),r!==-1&&p6.addCustomMetadata(t,r),p6.endSchema(t)}function $Q(t,A){let j=-1,e=-1,r=-1,n=A.type,i=A.typeId;HA.isDictionary(n)?(i=n.dictionary.typeId,r=Tm.visit(n,t),e=Tm.visit(n.dictionary,t)):e=Tm.visit(n,t);let o=(n.children||[]).map(B=>St.encode(t,B)),l=jn.createChildrenVector(t,o),c=A.metadata&&A.metadata.size>0?jn.createCustomMetadataVector(t,[...A.metadata].map(([B,h])=>{let d=t.createString(`${B}`),k=t.createString(`${h}`);return Je.startKeyValue(t),Je.addKey(t,d),Je.addValue(t,k),Je.endKeyValue(t)})):-1;return A.name&&(j=t.createString(A.name)),jn.startField(t),jn.addType(t,e),jn.addTypeType(t,i),jn.addChildren(t,l),jn.addNullable(t,!!A.nullable),j!==-1&&jn.addName(t,j),r!==-1&&jn.addDictionary(t,r),c!==-1&&jn.addCustomMetadata(t,c),jn.endField(t)}function xQ(t,A){let j=A.nodes||[],e=A.buffers||[];X6.startNodesVector(t,j.length);for(let i of j.slice().reverse())ki.encode(t,i);let r=t.endVector();X6.startBuffersVector(t,e.length);for(let i of e.slice().reverse())E6.encode(t,i);let n=t.endVector();return X6.startRecordBatch(t),X6.addLength(t,BigInt(A.length)),X6.addNodes(t,r),X6.addBuffers(t,n),X6.endRecordBatch(t)}function yQ(t,A){let j=Tr.encode(t,A.data);return Ws.startDictionaryBatch(t),Ws.addId(t,BigInt(A.id)),Ws.addIsDelta(t,A.isDelta),Ws.addData(t,j),Ws.endDictionaryBatch(t)}function vQ(t,A){return vu.createFieldNode(t,BigInt(A.length),BigInt(A.nullCount))}function _Q(t,A){return yu.createBuffer(t,BigInt(A.offset),BigInt(A.length))}var qQ=(()=>{let t=new ArrayBuffer(2);return new DataView(t).setInt16(0,256,!0),new Int16Array(t)[0]===256})();var Iq=t=>`Expected ${Lt[t]} Message in stream, but was null or length 0.`,Mq=t=>`Header pointer of flatbuffer-encoded ${Lt[t]} Message is null or length 0.`,n4=(t,A)=>`Expected to read ${t} metadata bytes, but only read ${A}.`,i4=(t,A)=>`Expected to read ${t} bytes for message body, but only read ${A}.`,Du=class{constructor(A){this.source=A instanceof Vo?A:new Vo(A)}[Symbol.iterator](){return this}next(){let A;return(A=this.readMetadataLength()).done?Tj:A.value===-1&&(A=this.readMetadataLength()).done?Tj:(A=this.readMetadata(A.value)).done?Tj:A}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}readMessage(A){let j;if((j=this.next()).done)return null;if(A!=null&&j.value.headerType!==A)throw new Error(Iq(A));return j.value}readMessageBody(A){if(A<=0)return new Uint8Array(0);let j=it(this.source.read(A));if(j.byteLength[...r,...n.VALIDITY&&[n.VALIDITY]||[],...n.TYPE_ID&&[n.TYPE_ID]||[],...n.OFFSET&&[n.OFFSET]||[],...n.DATA&&[n.DATA]||[],...j(n.children)],[])}}readMessage(A){let j;if((j=this.next()).done)return null;if(A!=null&&j.value.headerType!==A)throw new Error(Iq(A));return j.value}readSchema(){let A=Lt.Schema,j=this.readMessage(A),e=j?.header();if(!j||!e)throw new Error(Mq(A));return e}},Lm=4,Pq="ARROW1",Nu=new Uint8Array(Pq.length);for(let t=0;tthis):this}readRecordBatch(A){return this._impl.isFile()?this._impl.readRecordBatch(A):null}[Symbol.iterator](){return this._impl[Symbol.iterator]()}[Symbol.asyncIterator](){return this._impl[Symbol.asyncIterator]()}toDOMStream(){return Mr.toDOMStream(this.isSync()?{[Symbol.iterator]:()=>this}:{[Symbol.asyncIterator]:()=>this})}toNodeStream(){return Mr.toNodeStream(this.isSync()?{[Symbol.iterator]:()=>this}:{[Symbol.asyncIterator]:()=>this},{objectMode:!0})}static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A,j){throw new Error('"throughDOM" not available in this environment')}static from(A){return A instanceof t?A:dg(A)?bQ(A):kg(A)?PQ(A):D6(A)?OA(this,void 0,void 0,function*(){return yield t.from(yield A)}):gg(A)||gh(A)||Eg(A)||Bi(A)?FQ(new di(A)):wQ(new Vo(A))}static readAll(A){return A instanceof t?A.isSync()?s4(A):a4(A):dg(A)||ArrayBuffer.isView(A)||Xi(A)||pg(A)?s4(A):a4(A)}},ma=class extends Q6{constructor(A){super(A),this._impl=A}readAll(){return[...this]}[Symbol.iterator](){return this._impl[Symbol.iterator]()}[Symbol.asyncIterator](){return H6(this,arguments,function*(){yield vt(yield*$u(Ki(this[Symbol.iterator]())))})}},Zl=class extends Q6{constructor(A){super(A),this._impl=A}readAll(){var A,j,e,r;return OA(this,void 0,void 0,function*(){let n=new Array;try{for(var i=!0,o=Ki(this),l;l=yield o.next(),A=l.done,!A;i=!0){r=l.value,i=!1;let c=r;n.push(c)}}catch(c){j={error:c}}finally{try{!i&&!A&&(e=o.return)&&(yield e.call(o))}finally{if(j)throw j.error}}return n})}[Symbol.iterator](){throw new Error("AsyncRecordBatchStreamReader is not Iterable")}[Symbol.asyncIterator](){return this._impl[Symbol.asyncIterator]()}},Ac=class extends ma{constructor(A){super(A),this._impl=A}},Hm=class extends Zl{constructor(A){super(A),this._impl=A}},Dm=class{get numDictionaries(){return this._dictionaryIndex}get numRecordBatches(){return this._recordBatchIndex}constructor(A=new Map){this.closed=!1,this.autoDestroy=!0,this._dictionaryIndex=0,this._recordBatchIndex=0,this.dictionaries=A}isSync(){return!1}isAsync(){return!1}isFile(){return!1}isStream(){return!1}reset(A){return this._dictionaryIndex=0,this._recordBatchIndex=0,this.schema=A,this.dictionaries=new Map,this}_loadRecordBatch(A,j){let e=this._loadVectors(A,j,this.schema.fields),r=ht({type:new Oj(this.schema.fields),length:A.length,children:e});return new Be(this.schema,r)}_loadDictionaryBatch(A,j){let{id:e,isDelta:r}=A,{dictionaries:n,schema:i}=this,o=n.get(e);if(r||!o){let l=i.dictionaries.get(e),c=this._loadVectors(A.data,j,[l]);return(o&&r?o.concat(new Dt(c)):new Dt(c)).memoize()}return o.memoize()}_loadVectors(A,j,e){return new Kh(j,A.nodes,A.buffers,this.dictionaries,this.schema.metadataVersion).visitMany(e)}},Xu=class extends Dm{constructor(A,j){super(j),this._reader=dg(A)?new hd(this._handle=A):new Du(this._handle=A)}isSync(){return!0}isStream(){return!0}[Symbol.iterator](){return this}cancel(){!this.closed&&(this.closed=!0)&&(this.reset()._reader.return(),this._reader=null,this.dictionaries=null)}open(A){return this.closed||(this.autoDestroy=l4(this,A),this.schema||(this.schema=this._reader.readSchema())||this.cancel()),this}throw(A){return!this.closed&&this.autoDestroy&&(this.closed=!0)?this.reset()._reader.throw(A):Tj}return(A){return!this.closed&&this.autoDestroy&&(this.closed=!0)?this.reset()._reader.return(A):Tj}next(){if(this.closed)return Tj;let A,{_reader:j}=this;for(;A=this._readNextMessageAndValidate();)if(A.isSchema())this.reset(A.header());else if(A.isRecordBatch()){this._recordBatchIndex++;let e=A.header(),r=j.readMessageBody(A.bodyLength);return{done:!1,value:this._loadRecordBatch(e,r)}}else if(A.isDictionaryBatch()){this._dictionaryIndex++;let e=A.header(),r=j.readMessageBody(A.bodyLength),n=this._loadDictionaryBatch(e,r);this.dictionaries.set(e.id,n)}return this.schema&&this._recordBatchIndex===0?(this._recordBatchIndex++,{done:!1,value:new Jl(this.schema)}):this.return()}_readNextMessageAndValidate(A){return this._reader.readMessage(A)}},zu=class extends Dm{constructor(A,j){super(j),this._reader=new fd(this._handle=A)}isAsync(){return!0}isStream(){return!0}[Symbol.asyncIterator](){return this}cancel(){return OA(this,void 0,void 0,function*(){!this.closed&&(this.closed=!0)&&(yield this.reset()._reader.return(),this._reader=null,this.dictionaries=null)})}open(A){return OA(this,void 0,void 0,function*(){return this.closed||(this.autoDestroy=l4(this,A),this.schema||(this.schema=yield this._reader.readSchema())||(yield this.cancel())),this})}throw(A){return OA(this,void 0,void 0,function*(){return!this.closed&&this.autoDestroy&&(this.closed=!0)?yield this.reset()._reader.throw(A):Tj})}return(A){return OA(this,void 0,void 0,function*(){return!this.closed&&this.autoDestroy&&(this.closed=!0)?yield this.reset()._reader.return(A):Tj})}next(){return OA(this,void 0,void 0,function*(){if(this.closed)return Tj;let A,{_reader:j}=this;for(;A=yield this._readNextMessageAndValidate();)if(A.isSchema())yield this.reset(A.header());else if(A.isRecordBatch()){this._recordBatchIndex++;let e=A.header(),r=yield j.readMessageBody(A.bodyLength);return{done:!1,value:this._loadRecordBatch(e,r)}}else if(A.isDictionaryBatch()){this._dictionaryIndex++;let e=A.header(),r=yield j.readMessageBody(A.bodyLength),n=this._loadDictionaryBatch(e,r);this.dictionaries.set(e.id,n)}return this.schema&&this._recordBatchIndex===0?(this._recordBatchIndex++,{done:!1,value:new Jl(this.schema)}):yield this.return()})}_readNextMessageAndValidate(A){return OA(this,void 0,void 0,function*(){return yield this._reader.readMessage(A)})}},Nm=class extends Xu{get footer(){return this._footer}get numDictionaries(){return this._footer?this._footer.numDictionaries:0}get numRecordBatches(){return this._footer?this._footer.numRecordBatches:0}constructor(A,j){super(A instanceof Hh?A:new Hh(A),j)}isSync(){return!0}isFile(){return!0}open(A){if(!this.closed&&!this._footer){this.schema=(this._footer=this._readFooter()).schema;for(let j of this._footer.dictionaryBatches())j&&this._readDictionaryBatch(this._dictionaryIndex++)}return super.open(A)}readRecordBatch(A){var j;if(this.closed)return null;this._footer||this.open();let e=(j=this._footer)===null||j===void 0?void 0:j.getRecordBatch(A);if(e&&this._handle.seek(e.offset)){let r=this._reader.readMessage(Lt.RecordBatch);if(r?.isRecordBatch()){let n=r.header(),i=this._reader.readMessageBody(r.bodyLength);return this._loadRecordBatch(n,i)}}return null}_readDictionaryBatch(A){var j;let e=(j=this._footer)===null||j===void 0?void 0:j.getDictionaryBatch(A);if(e&&this._handle.seek(e.offset)){let r=this._reader.readMessage(Lt.DictionaryBatch);if(r?.isDictionaryBatch()){let n=r.header(),i=this._reader.readMessageBody(r.bodyLength),o=this._loadDictionaryBatch(n,i);this.dictionaries.set(n.id,o)}}}_readFooter(){let{_handle:A}=this,j=A.size-Oq,e=A.readInt32(j),r=A.readAt(j-e,e);return ua.decode(r)}_readNextMessageAndValidate(A){var j;if(this._footer||this.open(),this._footer&&this._recordBatchIndexsuper.open}});return OA(this,void 0,void 0,function*(){if(!this.closed&&!this._footer){this.schema=(this._footer=yield this._readFooter()).schema;for(let e of this._footer.dictionaryBatches())e&&(yield this._readDictionaryBatch(this._dictionaryIndex++))}return yield j.open.call(this,A)})}readRecordBatch(A){var j;return OA(this,void 0,void 0,function*(){if(this.closed)return null;this._footer||(yield this.open());let e=(j=this._footer)===null||j===void 0?void 0:j.getRecordBatch(A);if(e&&(yield this._handle.seek(e.offset))){let r=yield this._reader.readMessage(Lt.RecordBatch);if(r?.isRecordBatch()){let n=r.header(),i=yield this._reader.readMessageBody(r.bodyLength);return this._loadRecordBatch(n,i)}}return null})}_readDictionaryBatch(A){var j;return OA(this,void 0,void 0,function*(){let e=(j=this._footer)===null||j===void 0?void 0:j.getDictionaryBatch(A);if(e&&(yield this._handle.seek(e.offset))){let r=yield this._reader.readMessage(Lt.DictionaryBatch);if(r?.isDictionaryBatch()){let n=r.header(),i=yield this._reader.readMessageBody(r.bodyLength),o=this._loadDictionaryBatch(n,i);this.dictionaries.set(n.id,o)}}})}_readFooter(){return OA(this,void 0,void 0,function*(){let{_handle:A}=this;A._pending&&(yield A._pending);let j=A.size-Oq,e=yield A.readInt32(j),r=yield A.readAt(j-e,e);return ua.decode(r)})}_readNextMessageAndValidate(A){return OA(this,void 0,void 0,function*(){if(this._footer||(yield this.open()),this._footer&&this._recordBatchIndex=4?Cm(A)?new Ac(new Nm(t.read())):new ma(new Xu(t)):new ma(new Xu(function*(){}()))}function FQ(t){return OA(this,void 0,void 0,function*(){let A=yield t.peek(Ku+7&-8);return A&&A.byteLength>=4?Cm(A)?new Ac(new Nm(yield t.read())):new Zl(new zu(t)):new Zl(new zu(function(){return H6(this,arguments,function*(){})}()))})}function PQ(t){return OA(this,void 0,void 0,function*(){let{size:A}=yield t.stat(),j=new x7(t,A);return A>=o4&&Cm(yield j.readAt(0,Ku+7&-8))?new Hm(new Tq(j)):new Zl(new zu(j))})}var Jj=class t extends WA{static assemble(...A){let j=r=>r.flatMap(n=>Array.isArray(n)?j(n):n instanceof Be?n.data.children:n.data),e=new t;return e.visitMany(j(A)),e}constructor(){super(),this._byteLength=0,this._nodes=[],this._buffers=[],this._bufferRegions=[]}visit(A){if(A instanceof Dt)return this.visitMany(A.data),this;let{type:j}=A;if(!HA.isDictionary(j)){let{length:e}=A;if(e>2147483647)throw new RangeError("Cannot write arrays larger than 2^31 - 1 in length");if(HA.isUnion(j))this.nodes.push(new ki(e,0));else{let{nullCount:r}=A;HA.isNull(j)||oo.call(this,r<=0?new Uint8Array(0):Hl(A.offset,e,A.nullBitmap)),this.nodes.push(new ki(e,r))}}return super.visit(A)}visitNull(A){return this}visitDictionary(A){return this.visit(A.clone(A.type.indices))}get nodes(){return this._nodes}get buffers(){return this._buffers}get byteLength(){return this._byteLength}get bufferRegions(){return this._bufferRegions}};function oo(t){let A=t.byteLength+7&-8;return this.buffers.push(t),this.bufferRegions.push(new E6(this._byteLength,A)),this._byteLength+=A,this}function IQ(t){var A;let{type:j,length:e,typeIds:r,valueOffsets:n}=t;if(oo.call(this,r),j.mode===bj.Sparse)return Rq.call(this,t);if(j.mode===bj.Dense){if(t.offset<=0)return oo.call(this,n),Rq.call(this,t);{let i=new Int32Array(e),o=Object.create(null),l=Object.create(null);for(let c,B,h=-1;++h{let h=j.typeIds[B],d=o[h],k=l[h];return c.slice(d,Math.min(e,k))}))}}return this}function MQ(t){let A;return t.nullCount>=t.length?oo.call(this,new Uint8Array(0)):(A=t.values)instanceof Uint8Array?oo.call(this,Hl(t.offset,t.length,A)):oo.call(this,Dl(t.values))}function Ea(t){return oo.call(this,t.values.subarray(0,t.length*t.stride))}function Km(t){let{length:A,values:j,valueOffsets:e}=t,r=ee(e[0]),n=ee(e[A]),i=Math.min(n-r,j.byteLength-r);return oo.call(this,xg(-r,A+1,e)),oo.call(this,j.subarray(r,r+i)),this}function Lq(t){let{length:A,valueOffsets:j}=t;if(j){let{[0]:e,[A]:r}=j;return oo.call(this,xg(-e,A+1,j)),this.visit(t.children[0].slice(e,r-e))}return this.visit(t.children[0])}function Rq(t){return this.visitMany(t.type.children.map((A,j)=>t.children[j]).filter(Boolean))[0]}Jj.prototype.visitBool=MQ;Jj.prototype.visitInt=Ea;Jj.prototype.visitFloat=Ea;Jj.prototype.visitUtf8=Km;Jj.prototype.visitLargeUtf8=Km;Jj.prototype.visitBinary=Km;Jj.prototype.visitLargeBinary=Km;Jj.prototype.visitFixedSizeBinary=Ea;Jj.prototype.visitDate=Ea;Jj.prototype.visitTimestamp=Ea;Jj.prototype.visitTime=Ea;Jj.prototype.visitDecimal=Ea;Jj.prototype.visitList=Lq;Jj.prototype.visitStruct=Rq;Jj.prototype.visitUnion=IQ;Jj.prototype.visitInterval=Ea;Jj.prototype.visitDuration=Ea;Jj.prototype.visitFixedSizeList=Lq;Jj.prototype.visitMap=Lq;var tc=class extends Xl{static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A,j){throw new Error('"throughDOM" not available in this environment')}constructor(A){super(),this._position=0,this._started=!1,this._sink=new Uo,this._schema=null,this._dictionaryBlocks=[],this._recordBatchBlocks=[],this._dictionaryDeltaOffsets=new Map,qn(A)||(A={autoDestroy:!0,writeLegacyIpcFormat:!1}),this._autoDestroy=typeof A.autoDestroy=="boolean"?A.autoDestroy:!0,this._writeLegacyIpcFormat=typeof A.writeLegacyIpcFormat=="boolean"?A.writeLegacyIpcFormat:!1}toString(A=!1){return this._sink.toString(A)}toUint8Array(A=!1){return this._sink.toUint8Array(A)}writeAll(A){return D6(A)?A.then(j=>this.writeAll(j)):Bi(A)?Hq(this,A):Cq(this,A)}get closed(){return this._sink.closed}[Symbol.asyncIterator](){return this._sink[Symbol.asyncIterator]()}toDOMStream(A){return this._sink.toDOMStream(A)}toNodeStream(A){return this._sink.toNodeStream(A)}close(){return this.reset()._sink.close()}abort(A){return this.reset()._sink.abort(A)}finish(){return this._autoDestroy?this.close():this.reset(this._sink,this._schema),this}reset(A=this._sink,j=null){return A===this._sink||A instanceof Uo?this._sink=A:(this._sink=new Uo,A&&y8(A)?this.toDOMStream({type:"bytes"}).pipeTo(A):A&&v8(A)&&this.toNodeStream({objectMode:!1}).pipe(A)),this._started&&this._schema&&this._writeFooter(this._schema),this._started=!1,this._dictionaryBlocks=[],this._recordBatchBlocks=[],this._dictionaryDeltaOffsets=new Map,(!j||!Yl(j,this._schema))&&(j==null?(this._position=0,this._schema=null):(this._started=!0,this._schema=j,this._writeSchema(j))),this}write(A){let j=null;if(this._sink){if(A==null)return this.finish()&&void 0;if(A instanceof m6&&!(j=A.schema))return this.finish()&&void 0;if(A instanceof Be&&!(j=A.schema))return this.finish()&&void 0}else throw new Error("RecordBatchWriter is closed");if(j&&!Yl(j,this._schema)){if(this._started&&this._autoDestroy)return this.close();this.reset(this._sink,j)}A instanceof Be?A instanceof Jl||this._writeRecordBatch(A):A instanceof m6?this.writeAll(A.batches):Xi(A)&&this.writeAll(A)}_writeMessage(A,j=8){let e=j-1,r=x6.encode(A),n=r.byteLength,i=this._writeLegacyIpcFormat?4:8,o=n+i+e&~e,l=o-n-i;return A.headerType===Lt.RecordBatch?this._recordBatchBlocks.push(new Ba(o,A.bodyLength,this._position)):A.headerType===Lt.DictionaryBatch&&this._dictionaryBlocks.push(new Ba(o,A.bodyLength,this._position)),this._writeLegacyIpcFormat||this._write(Int32Array.of(-1)),this._write(Int32Array.of(o-i)),n>0&&this._write(r),this._writePadding(l)}_write(A){if(this._started){let j=it(A);j&&j.byteLength>0&&(this._sink.write(j),this._position+=j.byteLength)}return this}_writeSchema(A){return this._writeMessage(x6.from(A))}_writeFooter(A){return this._writeLegacyIpcFormat?this._write(Int32Array.of(0)):this._write(Int32Array.of(-1,0))}_writeMagic(){return this._write(Nu)}_writePadding(A){return A>0?this._write(new Uint8Array(A)):this}_writeRecordBatch(A){let{byteLength:j,nodes:e,bufferRegions:r,buffers:n}=Jj.assemble(A),i=new Tr(A.numRows,e,r),o=x6.from(i,j);return this._writeDictionaries(A)._writeMessage(o)._writeBodyBuffers(n)}_writeDictionaryBatch(A,j,e=!1){this._dictionaryDeltaOffsets.set(j,A.length+(this._dictionaryDeltaOffsets.get(j)||0));let{byteLength:r,nodes:n,bufferRegions:i,buffers:o}=Jj.assemble(new Dt([A])),l=new Tr(A.length,n,i),c=new $6(l,j,e),B=x6.from(c,r);return this._writeMessage(B)._writeBodyBuffers(o)}_writeBodyBuffers(A){let j,e,r;for(let n=-1,i=A.length;++n0&&(this._write(j),(r=(e+7&-8)-e)>0&&this._writePadding(r));return this}_writeDictionaries(A){for(let[j,e]of A.dictionaries){let r=this._dictionaryDeltaOffsets.get(j)||0;if(r===0||(e=e?.slice(r)).length>0)for(let n of e.data)this._writeDictionaryBatch(n,j,r>0),r+=n.length}return this}},dd=class t extends tc{static writeAll(A,j){let e=new t(j);return D6(A)?A.then(r=>e.writeAll(r)):Bi(A)?Hq(e,A):Cq(e,A)}},pd=class t extends tc{static writeAll(A){let j=new t;return D6(A)?A.then(e=>j.writeAll(e)):Bi(A)?Hq(j,A):Cq(j,A)}constructor(){super(),this._autoDestroy=!0}_writeSchema(A){return this._writeMagic()._writePadding(2)}_writeFooter(A){let j=ua.encode(new ua(A,hj.V5,this._recordBatchBlocks,this._dictionaryBlocks));return super._writeFooter(A)._write(j)._write(Int32Array.of(j.byteLength))._writeMagic()}};function Cq(t,A){let j=A;A instanceof m6&&(j=A.batches,t.reset(void 0,A.schema));for(let e of j)t.write(e);return t.finish()}function Hq(t,A){var j,e,r,n,i,o,l;return OA(this,void 0,void 0,function*(){try{for(j=!0,e=Ki(A);r=yield e.next(),n=r.done,!n;j=!0){l=r.value,j=!1;let c=l;t.write(c)}}catch(c){i={error:c}}finally{try{!j&&!n&&(o=e.return)&&(yield o.call(e))}finally{if(i)throw i.error}}return t.finish()})}function c4(t,A){if(Bi(t))return TQ(t,A);if(Xi(t))return OQ(t,A);throw new Error("toDOMStream() must be called with an Iterable or AsyncIterable")}function OQ(t,A){let j=null,e=A?.type==="bytes"||!1,r=A?.highWaterMark||Math.pow(2,24);return new ReadableStream(Object.assign(Object.assign({},A),{start(i){n(i,j||(j=t[Symbol.iterator]()))},pull(i){j?n(i,j):i.close()},cancel(){(j?.return&&j.return()||!0)&&(j=null)}}),Object.assign({highWaterMark:e?r:void 0},A));function n(i,o){let l,c=null,B=i.desiredSize||null;for(;!(c=o.next(e?B:null)).done;)if(ArrayBuffer.isView(c.value)&&(l=it(c.value))&&(B!=null&&e&&(B=B-l.byteLength+1),c.value=l),i.enqueue(c.value),B!=null&&--B<=0)return;i.close()}}function TQ(t,A){let j=null,e=A?.type==="bytes"||!1,r=A?.highWaterMark||Math.pow(2,24);return new ReadableStream(Object.assign(Object.assign({},A),{start(i){return OA(this,void 0,void 0,function*(){yield n(i,j||(j=t[Symbol.asyncIterator]()))})},pull(i){return OA(this,void 0,void 0,function*(){j?yield n(i,j):i.close()})},cancel(){return OA(this,void 0,void 0,function*(){(j?.return&&(yield j.return())||!0)&&(j=null)})}}),Object.assign({highWaterMark:e?r:void 0},A));function n(i,o){return OA(this,void 0,void 0,function*(){let l,c=null,B=i.desiredSize||null;for(;!(c=yield o.next(e?B:null)).done;)if(ArrayBuffer.isView(c.value)&&(l=it(c.value))&&(B!=null&&e&&(B=B-l.byteLength+1),c.value=l),i.enqueue(c.value),B!=null&&--B<=0)return;i.close()})}}function f4(t){return new Dq(t)}var Dq=class{constructor(A){this._numChunks=0,this._finished=!1,this._bufferedSize=0;let{["readableStrategy"]:j,["writableStrategy"]:e,["queueingStrategy"]:r="count"}=A,n=$8(A,["readableStrategy","writableStrategy","queueingStrategy"]);this._controller=null,this._builder=Ul(n),this._getSize=r!=="bytes"?u4:B4;let{["highWaterMark"]:i=r==="bytes"?Math.pow(2,14):1e3}=Object.assign({},j),{["highWaterMark"]:o=r==="bytes"?Math.pow(2,14):1e3}=Object.assign({},e);this.readable=new ReadableStream({cancel:()=>{this._builder.clear()},pull:l=>{this._maybeFlush(this._builder,this._controller=l)},start:l=>{this._maybeFlush(this._builder,this._controller=l)}},{highWaterMark:i,size:r!=="bytes"?u4:B4}),this.writable=new WritableStream({abort:()=>{this._builder.clear()},write:()=>{this._maybeFlush(this._builder,this._controller)},close:()=>{this._maybeFlush(this._builder.finish(),this._controller)}},{highWaterMark:o,size:l=>this._writeValueAndReturnChunkSize(l)})}_writeValueAndReturnChunkSize(A){let j=this._bufferedSize;return this._bufferedSize=this._getSize(this._builder.append(A)),this._bufferedSize-j}_maybeFlush(A,j){j!=null&&(this._bufferedSize>=j.desiredSize&&++this._numChunks&&this._enqueue(j,A.toVector()),A.finished&&((A.length>0||this._numChunks===0)&&++this._numChunks&&this._enqueue(j,A.toVector()),!this._finished&&(this._finished=!0)&&this._enqueue(j,null)))}_enqueue(A,j){this._bufferedSize=0,this._controller=null,j==null?A.close():A.enqueue(j)}},u4=t=>{var A;return(A=t?.length)!==null&&A!==void 0?A:0},B4=t=>{var A;return(A=t?.byteLength)!==null&&A!==void 0?A:0};function Xm(t,A){let j=new Uo,e=null,r=new ReadableStream({cancel(){return OA(this,void 0,void 0,function*(){yield j.close()})},start(o){return OA(this,void 0,void 0,function*(){yield i(o,e||(e=yield n()))})},pull(o){return OA(this,void 0,void 0,function*(){e?yield i(o,e):o.close()})}});return{writable:new WritableStream(j,Object.assign({highWaterMark:Math.pow(2,14)},t)),readable:r};function n(){return OA(this,void 0,void 0,function*(){return yield(yield Q6.from(j)).open(A)})}function i(o,l){return OA(this,void 0,void 0,function*(){let c=o.desiredSize,B=null;for(;!(B=yield l.next()).done;)if(o.enqueue(B.value),c!=null&&--c<=0)return;o.close()})}}function zm(t,A){let j=new this(t),e=new di(j),r=new ReadableStream({cancel(){return OA(this,void 0,void 0,function*(){yield e.cancel()})},pull(i){return OA(this,void 0,void 0,function*(){yield n(i)})},start(i){return OA(this,void 0,void 0,function*(){yield n(i)})}},Object.assign({highWaterMark:Math.pow(2,14)},A));return{writable:new WritableStream(j,t),readable:r};function n(i){return OA(this,void 0,void 0,function*(){let o=null,l=i.desiredSize;for(;o=yield e.read(l||null);)if(i.enqueue(o),l!=null&&(l-=o.byteLength)<=0)return;i.close()})}}function wn(t){let A=Q6.from(t);return D6(A)?A.then(j=>wn(j)):A.isAsync()?A.readAll().then(j=>new m6(j)):new m6(A.readAll())}var RQ=Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({},Z_),vq),dq),Aq),V_),hq),Y_),{compareSchemas:Yl,compareFields:DM,compareTypes:NM});Mr.toDOMStream=c4;Nj.throughDOM=f4;Q6.throughDOM=Xm;Ac.throughDOM=Xm;ma.throughDOM=Xm;tc.throughDOM=zm;pd.throughDOM=zm;dd.throughDOM=zm;var Zj=(t,A={})=>{let{coordinates:j,url:e,messages:r={},throwOnAuth:n=!0,logUnexpected:i=!0}=A,l={...{network:"Network error occurred",notFound:"Resource not found",unauthorized:"Unauthorized access",forbidden:"Access forbidden",unexpected:"Unexpected error occurred"},...r};if(t.name==="NetworkError"||t.code==="NETWORK_ERROR")return{error:"network",message:l.network,retryable:!0};if(t.status===404)return{error:"not_found",message:l.notFound,retryable:!1};if(t.status===401){let c=j?`${l.unauthorized} for resource at ${j}`:l.unauthorized;if(n)throw new Error(c);return{error:"unauthorized",message:c,retryable:!1}}if(t.status===403){let c=j?`${l.forbidden} for resource at ${j}`:l.forbidden;if(n)throw new Error(c);return{error:"forbidden",message:c,retryable:!1}}if(i){let c={...j&&{coordinates:j},...e&&{url:e},error:t.message,stack:t.stack};console.error(l.unexpected,c)}return{error:"unexpected",message:l.unexpected,retryable:!1}},Uu=(t,A={})=>{let{logLevel:j="warn",shouldLog:e=!0}=A;e&&A.forceLog&&console[j](t,A.data||"")};var eA,kd=null;function Vu(){return(kd===null||kd.byteLength===0)&&(kd=new Uint8Array(eA.memory.buffer)),kd}var Vm=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});Vm.decode();var LQ=2146435072,Nq=0;function CQ(t,A){return Nq+=A,Nq>=LQ&&(Vm=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),Vm.decode(),Nq=A),Vm.decode(Vu().subarray(t,t+A))}function so(t,A){return t=t>>>0,CQ(t,A)}var Sr=0,md=new TextEncoder;"encodeInto"in md||(md.encodeInto=function(t,A){let j=md.encode(t);return A.set(j),{read:t.length,written:j.length}});function ao(t,A,j){if(j===void 0){let o=md.encode(t),l=A(o.length,1)>>>0;return Vu().subarray(l,l+o.length).set(o),Sr=o.length,l}let e=t.length,r=A(e,1)>>>0,n=Vu(),i=0;for(;i127)break;n[r+i]=o}if(i!==e){i!==0&&(t=t.slice(i)),r=j(r,e,e=i+t.length*3,1)>>>0;let o=Vu().subarray(r+i,r+e),l=md.encodeInto(t,o);i+=l.written,r=j(r,e,i,1)>>>0}return Sr=i,r}var jc=null;function W6(){return(jc===null||jc.buffer.detached===!0||jc.buffer.detached===void 0&&jc.buffer!==eA.memory.buffer)&&(jc=new DataView(eA.memory.buffer)),jc}function Wo(t){let A=eA.__externref_table_alloc();return eA.__wbindgen_export_4.set(A,t),A}function Ze(t,A){try{return t.apply(this,A)}catch(j){let e=Wo(j);eA.__wbindgen_exn_store(e)}}function en(t){return t==null}function Qu(t,A){return t=t>>>0,Vu().subarray(t/1,t/1+A)}function Xq(t){let A=typeof t;if(A=="number"||A=="boolean"||t==null)return`${t}`;if(A=="string")return`"${t}"`;if(A=="symbol"){let r=t.description;return r==null?"Symbol":`Symbol(${r})`}if(A=="function"){let r=t.name;return typeof r=="string"&&r.length>0?`Function(${r})`:"Function"}if(Array.isArray(t)){let r=t.length,n="[";r>0&&(n+=Xq(t[0]));for(let i=1;i1)e=j[1];else return toString.call(t);if(e=="Object")try{return"Object("+JSON.stringify(t)+")"}catch{return"Object"}return t instanceof Error?`${t.name}: ${t.message} -${t.stack}`:e}var h4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>{eA.__wbindgen_export_5.get(t.dtor)(t.a,t.b)});function d4(t,A,j,e){let r={a:t,b:A,cnt:1,dtor:j},n=(...i)=>{r.cnt++;let o=r.a;r.a=0;try{return e(o,r.b,...i)}finally{--r.cnt===0?(eA.__wbindgen_export_5.get(r.dtor)(o,r.b),h4.unregister(r)):r.a=o}};return n.original=r,h4.register(n,r,r),n}function fe(t){let A=eA.__wbindgen_export_4.get(t);return eA.__externref_table_dealloc(t),A}function Ed(t,A){t=t>>>0;let j=W6(),e=[];for(let r=t;r>>0;return Vu().set(t,j/1),Sr=t.length,j}function Uq(t,A){let j=zq(t,eA.__wbindgen_malloc),e=Sr,r=eA.readParquet(j,e,en(A)?0:Wo(A));if(r[2])throw fe(r[1]);return tB.__wrap(r[0])}function Vq(t){let A=zq(t,eA.__wbindgen_malloc),j=Sr,e=eA.readSchema(A,j);if(e[2])throw fe(e[1]);return $a.__wrap(e[0])}function HQ(t,A){if(!(t instanceof A))throw new Error(`expected instance of ${A.name}`)}var gd=null;function DQ(){return(gd===null||gd.byteLength===0)&&(gd=new Uint32Array(eA.memory.buffer)),gd}function NQ(t,A){return t=t>>>0,DQ().subarray(t/4,t/4+A)}function KQ(t,A){eA.wasm_bindgen__convert__closures_____invoke__hfec9c6c02f6046ed(t,A)}function XQ(t,A,j){eA.closure3789_externref_shim(t,A,j)}function zQ(t,A,j,e){eA.closure3803_externref_shim(t,A,j,e)}var E_A=Object.freeze({UNCOMPRESSED:0,0:"UNCOMPRESSED",SNAPPY:1,1:"SNAPPY",GZIP:2,2:"GZIP",BROTLI:3,3:"BROTLI",LZ4:4,4:"LZ4",ZSTD:5,5:"ZSTD",LZ4_RAW:6,6:"LZ4_RAW",LZO:7,7:"LZO"}),$_A=Object.freeze({None:0,0:"None",Chunk:1,1:"Chunk",Page:2,2:"Page"}),x_A=Object.freeze({PLAIN:0,0:"PLAIN",PLAIN_DICTIONARY:1,1:"PLAIN_DICTIONARY",RLE:2,2:"RLE",BIT_PACKED:3,3:"BIT_PACKED",DELTA_BINARY_PACKED:4,4:"DELTA_BINARY_PACKED",DELTA_LENGTH_BYTE_ARRAY:5,5:"DELTA_LENGTH_BYTE_ARRAY",DELTA_BYTE_ARRAY:6,6:"DELTA_BYTE_ARRAY",RLE_DICTIONARY:7,7:"RLE_DICTIONARY",BYTE_STREAM_SPLIT:8,8:"BYTE_STREAM_SPLIT"}),y_A=Object.freeze({V1:0,0:"V1",V2:1,1:"V2"}),UQ=["bytes"],VQ=["default","no-store","reload","no-cache","force-cache","only-if-cached"],QQ=["omit","same-origin","include"],WQ=["same-origin","no-cors","cors","navigate"],p4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_columnchunkmetadata_free(t>>>0,1)),Wu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,p4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,p4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_columnchunkmetadata_free(A,0)}filePath(){let A=eA.columnchunkmetadata_filePath(this.__wbg_ptr),j;return A[0]!==0&&(j=so(A[0],A[1]).slice(),eA.__wbindgen_free(A[0],A[1]*1,1)),j}fileOffset(){return eA.columnchunkmetadata_fileOffset(this.__wbg_ptr)}columnPath(){let A=eA.columnchunkmetadata_columnPath(this.__wbg_ptr);var j=Ed(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}encodings(){let A=eA.columnchunkmetadata_encodings(this.__wbg_ptr);var j=Ed(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}numValues(){return eA.columnchunkmetadata_numValues(this.__wbg_ptr)}compression(){return eA.columnchunkmetadata_compression(this.__wbg_ptr)}compressedSize(){return eA.columnchunkmetadata_compressedSize(this.__wbg_ptr)}uncompressedSize(){return eA.columnchunkmetadata_uncompressedSize(this.__wbg_ptr)}};Symbol.dispose&&(Wu.prototype[Symbol.dispose]=Wu.prototype.free);var k4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffidata_free(t>>>0,1)),Yu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,k4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,k4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffidata_free(A,0)}arrayAddr(){return eA.ffidata_arrayAddr(this.__wbg_ptr)>>>0}schemaAddr(){return eA.ffidata_schemaAddr(this.__wbg_ptr)>>>0}};Symbol.dispose&&(Yu.prototype[Symbol.dispose]=Yu.prototype.free);var g4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffischema_free(t>>>0,1)),Ju=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,g4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,g4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffischema_free(A,0)}addr(){return eA.ffischema_addr(this.__wbg_ptr)>>>0}};Symbol.dispose&&(Ju.prototype[Symbol.dispose]=Ju.prototype.free);var m4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffistream_free(t>>>0,1)),Zu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,m4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,m4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffistream_free(A,0)}numArrays(){return eA.ffistream_numArrays(this.__wbg_ptr)>>>0}schemaAddr(){return eA.ffistream_schemaAddr(this.__wbg_ptr)>>>0}arrayAddr(A){return eA.ffistream_arrayAddr(this.__wbg_ptr,A)>>>0}arrayAddrs(){let A=eA.ffistream_arrayAddrs(this.__wbg_ptr);var j=NQ(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}drop(){let A=this.__destroy_into_raw();eA.ffistream_drop(A)}};Symbol.dispose&&(Zu.prototype[Symbol.dispose]=Zu.prototype.free);var E4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_filemetadata_free(t>>>0,1)),$d=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,E4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,E4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_filemetadata_free(A,0)}version(){return eA.filemetadata_version(this.__wbg_ptr)}numRows(){return eA.filemetadata_numRows(this.__wbg_ptr)}createdBy(){let A=eA.filemetadata_createdBy(this.__wbg_ptr),j;return A[0]!==0&&(j=so(A[0],A[1]).slice(),eA.__wbindgen_free(A[0],A[1]*1,1)),j}keyValueMetadata(){let A=eA.filemetadata_keyValueMetadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return fe(A[0])}};Symbol.dispose&&($d.prototype[Symbol.dispose]=$d.prototype.free);var YQ=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingbytesource_free(t>>>0,1)),Qm=class{__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,YQ.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingbytesource_free(A,0)}get type(){let A=eA.intounderlyingbytesource_type(this.__wbg_ptr);return UQ[A]}get autoAllocateChunkSize(){return eA.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr)>>>0}start(A){eA.intounderlyingbytesource_start(this.__wbg_ptr,A)}pull(A){return eA.intounderlyingbytesource_pull(this.__wbg_ptr,A)}cancel(){let A=this.__destroy_into_raw();eA.intounderlyingbytesource_cancel(A)}};Symbol.dispose&&(Qm.prototype[Symbol.dispose]=Qm.prototype.free);var JQ=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingsink_free(t>>>0,1)),Wm=class{__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,JQ.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingsink_free(A,0)}write(A){return eA.intounderlyingsink_write(this.__wbg_ptr,A)}close(){let A=this.__destroy_into_raw();return eA.intounderlyingsink_close(A)}abort(A){let j=this.__destroy_into_raw();return eA.intounderlyingsink_abort(j,A)}};Symbol.dispose&&(Wm.prototype[Symbol.dispose]=Wm.prototype.free);var $4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingsource_free(t>>>0,1)),xd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,$4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,$4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingsource_free(A,0)}pull(A){return eA.intounderlyingsource_pull(this.__wbg_ptr,A)}cancel(){let A=this.__destroy_into_raw();eA.intounderlyingsource_cancel(A)}};Symbol.dispose&&(xd.prototype[Symbol.dispose]=xd.prototype.free);var x4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_parquetfile_free(t>>>0,1)),y7=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,x4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,x4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_parquetfile_free(A,0)}static fromUrl(A){let j=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),e=Sr;return eA.parquetfile_fromUrl(j,e)}static fromFile(A){return eA.parquetfile_fromFile(A)}metadata(){let A=eA.parquetfile_metadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return yd.__wrap(A[0])}schema(){let A=eA.parquetfile_schema(this.__wbg_ptr);if(A[2])throw fe(A[1]);return $a.__wrap(A[0])}read(A){return eA.parquetfile_read(this.__wbg_ptr,en(A)?0:Wo(A))}stream(A){return eA.parquetfile_stream(this.__wbg_ptr,en(A)?0:Wo(A))}};Symbol.dispose&&(y7.prototype[Symbol.dispose]=y7.prototype.free);var y4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_parquetmetadata_free(t>>>0,1)),yd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,y4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,y4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_parquetmetadata_free(A,0)}fileMetadata(){let A=eA.parquetmetadata_fileMetadata(this.__wbg_ptr);return $d.__wrap(A)}numRowGroups(){return eA.parquetmetadata_numRowGroups(this.__wbg_ptr)>>>0}rowGroup(A){let j=eA.parquetmetadata_rowGroup(this.__wbg_ptr,A);return AB.__wrap(j)}rowGroups(){let A=eA.parquetmetadata_rowGroups(this.__wbg_ptr);var j=Ed(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}};Symbol.dispose&&(yd.prototype[Symbol.dispose]=yd.prototype.free);var v4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_recordbatch_free(t>>>0,1)),ec=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,v4.register(j,j.__wbg_ptr,j),j}static __unwrap(A){return A instanceof t?A.__destroy_into_raw():0}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,v4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_recordbatch_free(A,0)}get numRows(){return eA.recordbatch_numRows(this.__wbg_ptr)>>>0}get numColumns(){return eA.recordbatch_numColumns(this.__wbg_ptr)>>>0}get schema(){let A=eA.recordbatch_schema(this.__wbg_ptr);return $a.__wrap(A)}toFFI(){let A=eA.recordbatch_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Yu.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.recordbatch_intoFFI(A);if(j[2])throw fe(j[1]);return Yu.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.recordbatch_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}withSchema(A){HQ(A,$a);var j=A.__destroy_into_raw();let e=eA.recordbatch_withSchema(this.__wbg_ptr,j);if(e[2])throw fe(e[1]);return t.__wrap(e[0])}slice(A,j){let e=eA.recordbatch_slice(this.__wbg_ptr,A,j);return t.__wrap(e)}getArrayMemorySize(){return eA.recordbatch_getArrayMemorySize(this.__wbg_ptr)>>>0}};Symbol.dispose&&(ec.prototype[Symbol.dispose]=ec.prototype.free);var _4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_rowgroupmetadata_free(t>>>0,1)),AB=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,_4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,_4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_rowgroupmetadata_free(A,0)}numColumns(){return eA.rowgroupmetadata_numColumns(this.__wbg_ptr)>>>0}column(A){let j=eA.rowgroupmetadata_column(this.__wbg_ptr,A);return Wu.__wrap(j)}columns(){let A=eA.rowgroupmetadata_columns(this.__wbg_ptr);var j=Ed(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}numRows(){return eA.rowgroupmetadata_numRows(this.__wbg_ptr)}totalByteSize(){return eA.rowgroupmetadata_totalByteSize(this.__wbg_ptr)}compressedSize(){return eA.rowgroupmetadata_compressedSize(this.__wbg_ptr)}};Symbol.dispose&&(AB.prototype[Symbol.dispose]=AB.prototype.free);var q4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_schema_free(t>>>0,1)),$a=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,q4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,q4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_schema_free(A,0)}toFFI(){let A=eA.schema_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Ju.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.schema_intoFFI(A);if(j[2])throw fe(j[1]);return Ju.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.schema_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}withMetadata(A){let j=eA.schema_withMetadata(this.__wbg_ptr,A);if(j[2])throw fe(j[1]);return t.__wrap(j[0])}indexOf(A){let j=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),e=Sr,r=eA.schema_indexOf(this.__wbg_ptr,j,e);if(r[2])throw fe(r[1]);return r[0]>>>0}metadata(){let A=eA.schema_metadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return fe(A[0])}};Symbol.dispose&&($a.prototype[Symbol.dispose]=$a.prototype.free);var G4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_table_free(t>>>0,1)),tB=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,G4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,G4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_table_free(A,0)}get schema(){let A=eA.table_schema(this.__wbg_ptr);return $a.__wrap(A)}recordBatch(A){let j=eA.table_recordBatch(this.__wbg_ptr,A);return j===0?void 0:ec.__wrap(j)}recordBatches(){let A=eA.table_recordBatches(this.__wbg_ptr);var j=Ed(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}get numBatches(){return eA.table_numBatches(this.__wbg_ptr)>>>0}toFFI(){let A=eA.table_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Zu.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.table_intoFFI(A);if(j[2])throw fe(j[1]);return Zu.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.table_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}static fromIPCStream(A){let j=zq(A,eA.__wbindgen_malloc),e=Sr,r=eA.table_fromIPCStream(j,e);if(r[2])throw fe(r[1]);return t.__wrap(r[0])}getArrayMemorySize(){return eA.table_getArrayMemorySize(this.__wbg_ptr)>>>0}};Symbol.dispose&&(tB.prototype[Symbol.dispose]=tB.prototype.free);var b4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_writerproperties_free(t>>>0,1)),vd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,b4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,b4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_writerproperties_free(A,0)}};Symbol.dispose&&(vd.prototype[Symbol.dispose]=vd.prototype.free);var Kq=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_writerpropertiesbuilder_free(t>>>0,1)),Ym=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,Kq.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,Kq.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_writerpropertiesbuilder_free(A,0)}constructor(){let A=eA.writerpropertiesbuilder_new();return this.__wbg_ptr=A>>>0,Kq.register(this,this.__wbg_ptr,this),this}build(){let A=this.__destroy_into_raw(),j=eA.writerpropertiesbuilder_build(A);return vd.__wrap(j)}setWriterVersion(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setWriterVersion(j,A);return t.__wrap(e)}setDataPageSizeLimit(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDataPageSizeLimit(j,A);return t.__wrap(e)}setDictionaryPageSizeLimit(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDictionaryPageSizeLimit(j,A);return t.__wrap(e)}setWriteBatchSize(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setWriteBatchSize(j,A);return t.__wrap(e)}setMaxRowGroupSize(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setMaxRowGroupSize(j,A);return t.__wrap(e)}setCreatedBy(A){let j=this.__destroy_into_raw(),e=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),r=Sr,n=eA.writerpropertiesbuilder_setCreatedBy(j,e,r);return t.__wrap(n)}setKeyValueMetadata(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setKeyValueMetadata(j,A);if(e[2])throw fe(e[1]);return t.__wrap(e[0])}setEncoding(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setEncoding(j,A);return t.__wrap(e)}setCompression(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setCompression(j,A);return t.__wrap(e)}setDictionaryEnabled(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDictionaryEnabled(j,A);return t.__wrap(e)}setStatisticsEnabled(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setStatisticsEnabled(j,A);return t.__wrap(e)}setColumnEncoding(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnEncoding(e,r,n,j);return t.__wrap(i)}setColumnCompression(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnCompression(e,r,n,j);return t.__wrap(i)}setColumnDictionaryEnabled(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnDictionaryEnabled(e,r,n,j);return t.__wrap(i)}setColumnStatisticsEnabled(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnStatisticsEnabled(e,r,n,j);return t.__wrap(i)}};Symbol.dispose&&(Ym.prototype[Symbol.dispose]=Ym.prototype.free);var ZQ=new Set(["basic","cors","default"]);async function AW(t,A){if(typeof Response=="function"&&t instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(t,A)}catch(e){if(t.ok&&ZQ.has(t.type)&&t.headers.get("Content-Type")!=="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",e);else throw e}let j=await t.arrayBuffer();return await WebAssembly.instantiate(j,A)}else{let j=await WebAssembly.instantiate(t,A);return j instanceof WebAssembly.Instance?{instance:j,module:t}:j}}function w4(){let t={};return t.wbg={},t.wbg.__wbg_Error_e17e777aac105295=function(A,j){return Error(so(A,j))},t.wbg.__wbg_Number_998bea33bd87c3e0=function(A){return Number(A)},t.wbg.__wbg_String_8f0eb39a4a4c2f66=function(A,j){let e=String(j),r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_abort_67e1b49bf6614565=function(A){A.abort()},t.wbg.__wbg_abort_d830bf2e9aa6ec5b=function(A,j){A.abort(j)},t.wbg.__wbg_append_72a3c0addd2bce38=function(){return Ze(function(A,j,e,r,n){A.append(so(j,e),so(r,n))},arguments)},t.wbg.__wbg_arrayBuffer_2c907ed8e8ef4e35=function(A){return A.arrayBuffer()},t.wbg.__wbg_arrayBuffer_9c99b8e2809e8cbb=function(){return Ze(function(A){return A.arrayBuffer()},arguments)},t.wbg.__wbg_buffer_8d40b1d762fb3c66=function(A){return A.buffer},t.wbg.__wbg_byobRequest_2c036bceca1e6037=function(A){let j=A.byobRequest;return en(j)?0:Wo(j)},t.wbg.__wbg_byteLength_331a6b5545834024=function(A){return A.byteLength},t.wbg.__wbg_byteOffset_49a5b5608000358b=function(A){return A.byteOffset},t.wbg.__wbg_call_13410aac570ffff7=function(){return Ze(function(A,j){return A.call(j)},arguments)},t.wbg.__wbg_call_a5400b25a865cfd8=function(){return Ze(function(A,j,e){return A.call(j,e)},arguments)},t.wbg.__wbg_cancel_8bb5b8f4906b658a=function(A){return A.cancel()},t.wbg.__wbg_catch_c80ecae90cb8ed4e=function(A,j){return A.catch(j)},t.wbg.__wbg_clearTimeout_6222fede17abcb1a=function(A){return clearTimeout(A)},t.wbg.__wbg_close_a1918cff3cac355b=function(A){return A.close()},t.wbg.__wbg_close_cccada6053ee3a65=function(){return Ze(function(A){A.close()},arguments)},t.wbg.__wbg_close_d71a78219dc23e91=function(){return Ze(function(A){A.close()},arguments)},t.wbg.__wbg_columnchunkmetadata_new=function(A){return Wu.__wrap(A)},t.wbg.__wbg_done_75ed0ee6dd243d9d=function(A){return A.done},t.wbg.__wbg_enqueue_452bc2343d1c2ff9=function(){return Ze(function(A,j){A.enqueue(j)},arguments)},t.wbg.__wbg_entries_2be2f15bd5554996=function(A){return Object.entries(A)},t.wbg.__wbg_fetch_87aed7f306ec6d63=function(A,j){return A.fetch(j)},t.wbg.__wbg_fetch_f156d10be9a5c88a=function(A){return fetch(A)},t.wbg.__wbg_getReader_48e00749fe3f6089=function(){return Ze(function(A){return A.getReader()},arguments)},t.wbg.__wbg_getWriter_03d7689e275ac6a4=function(){return Ze(function(A){return A.getWriter()},arguments)},t.wbg.__wbg_get_0da715ceaecea5c8=function(A,j){return A[j>>>0]},t.wbg.__wbg_get_458e874b43b18b25=function(){return Ze(function(A,j){return Reflect.get(A,j)},arguments)},t.wbg.__wbg_getdone_f026246f6bbe58d3=function(A){let j=A.done;return en(j)?16777215:j?1:0},t.wbg.__wbg_getvalue_31e5a08f61e5aa42=function(A){return A.value},t.wbg.__wbg_getwithrefkey_1dc361bd10053bfe=function(A,j){return A[j]},t.wbg.__wbg_has_b89e451f638123e3=function(){return Ze(function(A,j){return Reflect.has(A,j)},arguments)},t.wbg.__wbg_headers_29fec3c72865cd75=function(A){return A.headers},t.wbg.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd=function(A){let j;try{j=A instanceof ArrayBuffer}catch{j=!1}return j},t.wbg.__wbg_instanceof_Response_50fde2cd696850bf=function(A){let j;try{j=A instanceof Response}catch{j=!1}return j},t.wbg.__wbg_instanceof_Uint8Array_9a8378d955933db7=function(A){let j;try{j=A instanceof Uint8Array}catch{j=!1}return j},t.wbg.__wbg_isArray_030cce220591fb41=function(A){return Array.isArray(A)},t.wbg.__wbg_isSafeInteger_1c0d1af5542e102a=function(A){return Number.isSafeInteger(A)},t.wbg.__wbg_iterator_f370b34483c71a1c=function(){return Symbol.iterator},t.wbg.__wbg_length_186546c51cd61acd=function(A){return A.length},t.wbg.__wbg_length_6bb7e81f9d7713e4=function(A){return A.length},t.wbg.__wbg_new_19c25a3f2fa63a02=function(){return new Object},t.wbg.__wbg_new_2e3c58a15f39f5f9=function(A,j){try{var e={a:A,b:j},r=(i,o)=>{let l=e.a;e.a=0;try{return zQ(l,e.b,i,o)}finally{e.a=l}};return new Promise(r)}finally{e.a=e.b=0}},t.wbg.__wbg_new_2ff1f68f3676ea53=function(){return new Map},t.wbg.__wbg_new_638ebfaedbf32a5e=function(A){return new Uint8Array(A)},t.wbg.__wbg_new_66b9434b4e59b63e=function(){return Ze(function(){return new AbortController},arguments)},t.wbg.__wbg_new_99a6a948d5b3f607=function(){return Ze(function(){return new TransformStream},arguments)},t.wbg.__wbg_new_da9dc54c5db29dfa=function(A,j){return new Error(so(A,j))},t.wbg.__wbg_new_f6e53210afea8e45=function(){return Ze(function(){return new Headers},arguments)},t.wbg.__wbg_newfromslice_074c56947bd43469=function(A,j){return new Uint8Array(Qu(A,j))},t.wbg.__wbg_newnoargs_254190557c45b4ec=function(A,j){return new Function(so(A,j))},t.wbg.__wbg_newwithbyteoffset_6bd4b2a4ca518883=function(A,j){return new Uint8Array(A,j>>>0)},t.wbg.__wbg_newwithbyteoffsetandlength_e8f53910b4d42b45=function(A,j,e){return new Uint8Array(A,j>>>0,e>>>0)},t.wbg.__wbg_newwithintounderlyingsource_b47f6a6a596a7f24=function(A,j){return new ReadableStream(xd.__wrap(A),j)},t.wbg.__wbg_newwithstrandinit_b5d168a29a3fd85f=function(){return Ze(function(A,j,e){return new Request(so(A,j),e)},arguments)},t.wbg.__wbg_next_5b3530e612fde77d=function(A){return A.next},t.wbg.__wbg_next_692e82279131b03c=function(){return Ze(function(A){return A.next()},arguments)},t.wbg.__wbg_parquetfile_new=function(A){return y7.__wrap(A)},t.wbg.__wbg_prototypesetcall_3d4a26c1ed734349=function(A,j,e){Uint8Array.prototype.set.call(Qu(A,j),e)},t.wbg.__wbg_queueMicrotask_25d0739ac89e8c88=function(A){queueMicrotask(A)},t.wbg.__wbg_queueMicrotask_4488407636f5bf24=function(A){return A.queueMicrotask},t.wbg.__wbg_read_bc925c758aa4d897=function(A){return A.read()},t.wbg.__wbg_readable_e82cff27b968ed1c=function(A){return A.readable},t.wbg.__wbg_ready_4186da3cb500ae7d=function(A){return A.ready},t.wbg.__wbg_recordbatch_new=function(A){return ec.__wrap(A)},t.wbg.__wbg_recordbatch_unwrap=function(A){return ec.__unwrap(A)},t.wbg.__wbg_releaseLock_62151472ae632176=function(A){A.releaseLock()},t.wbg.__wbg_releaseLock_ff29b586502a8221=function(A){A.releaseLock()},t.wbg.__wbg_resolve_4055c623acdd6a1b=function(A){return Promise.resolve(A)},t.wbg.__wbg_respond_6c2c4e20ef85138e=function(){return Ze(function(A,j){A.respond(j>>>0)},arguments)},t.wbg.__wbg_rowgroupmetadata_new=function(A){return AB.__wrap(A)},t.wbg.__wbg_setTimeout_2b339866a2aa3789=function(A,j){return setTimeout(A,j)},t.wbg.__wbg_set_1353b2a5e96bc48c=function(A,j,e){A.set(Qu(j,e))},t.wbg.__wbg_set_3f1d0b984ed272ed=function(A,j,e){A[j]=e},t.wbg.__wbg_set_b7f1cf4fae26fe2a=function(A,j,e){return A.set(j,e)},t.wbg.__wbg_setbody_c8460bdf44147df8=function(A,j){A.body=j},t.wbg.__wbg_setcache_90ca4ad8a8ad40d3=function(A,j){A.cache=VQ[j]},t.wbg.__wbg_setcredentials_9cd60d632c9d5dfc=function(A,j){A.credentials=QQ[j]},t.wbg.__wbg_setheaders_0052283e2f3503d1=function(A,j){A.headers=j},t.wbg.__wbg_sethighwatermark_3d5961f834647d41=function(A,j){A.highWaterMark=j},t.wbg.__wbg_setmethod_9b504d5b855b329c=function(A,j,e){A.method=so(j,e)},t.wbg.__wbg_setmode_a23e1a2ad8b512f8=function(A,j){A.mode=WQ[j]},t.wbg.__wbg_setsignal_8c45ad1247a74809=function(A,j){A.signal=j},t.wbg.__wbg_signal_da4d466ce86118b5=function(A){return A.signal},t.wbg.__wbg_size_8f84e7768fba0589=function(A){return A.size},t.wbg.__wbg_slice_224856d46230c13c=function(){return Ze(function(A,j,e){return A.slice(j,e)},arguments)},t.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12=function(){let A=typeof global>"u"?null:global;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184=function(){let A=typeof globalThis>"u"?null:globalThis;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_SELF_995b214ae681ff99=function(){let A=typeof self>"u"?null:self;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea=function(){let A=typeof window>"u"?null:window;return en(A)?0:Wo(A)},t.wbg.__wbg_status_3fea3036088621d6=function(A){return A.status},t.wbg.__wbg_stringify_b98c93d0a190446a=function(){return Ze(function(A){return JSON.stringify(A)},arguments)},t.wbg.__wbg_table_new=function(A){return tB.__wrap(A)},t.wbg.__wbg_then_b33a773d723afa3e=function(A,j,e){return A.then(j,e)},t.wbg.__wbg_then_e22500defe16819f=function(A,j){return A.then(j)},t.wbg.__wbg_toString_78df35411a4fd40c=function(A){return A.toString()},t.wbg.__wbg_url_e5720dfacf77b05e=function(A,j){let e=j.url,r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_value_dd9372230531eade=function(A){return A.value},t.wbg.__wbg_view_91cc97d57ab30530=function(A){let j=A.view;return en(j)?0:Wo(j)},t.wbg.__wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1=function(A,j){let e=j,r=typeof e=="bigint"?e:void 0;W6().setBigInt64(A+8*1,en(r)?BigInt(0):r,!0),W6().setInt32(A+4*0,!en(r),!0)},t.wbg.__wbg_wbindgenbooleanget_3fe6f642c7d97746=function(A){let j=A,e=typeof j=="boolean"?j:void 0;return en(e)?16777215:e?1:0},t.wbg.__wbg_wbindgencbdrop_eb10308566512b88=function(A){let j=A.original;return j.cnt--==1?(j.a=0,!0):!1},t.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d=function(A,j){let e=Xq(j),r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_wbindgenfunctiontable_aa1084b2969a9cbe=function(){return eA.__wbindgen_export_5},t.wbg.__wbg_wbindgenin_d7a1ee10933d2d55=function(A,j){return A in j},t.wbg.__wbg_wbindgenisbigint_ecb90cc08a5a9154=function(A){return typeof A=="bigint"},t.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74=function(A){return typeof A=="function"},t.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8=function(A){let j=A;return typeof j=="object"&&j!==null},t.wbg.__wbg_wbindgenisstring_d4fa939789f003b0=function(A){return typeof A=="string"},t.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5=function(A){return A===void 0},t.wbg.__wbg_wbindgenjsvaleq_e6f2ad59ccae1b58=function(A,j){return A===j},t.wbg.__wbg_wbindgenjsvallooseeq_9bec8c9be826bed1=function(A,j){return A==j},t.wbg.__wbg_wbindgenmemory_d84da70f7c42d172=function(){return eA.memory},t.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb=function(A,j){let e=j,r=typeof e=="number"?e:void 0;W6().setFloat64(A+8*1,en(r)?0:r,!0),W6().setInt32(A+4*0,!en(r),!0)},t.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f=function(A,j){let e=j,r=typeof e=="string"?e:void 0;var n=en(r)?0:ao(r,eA.__wbindgen_malloc,eA.__wbindgen_realloc),i=Sr;W6().setInt32(A+4*1,i,!0),W6().setInt32(A+4*0,n,!0)},t.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6=function(A,j){throw new Error(so(A,j))},t.wbg.__wbg_writable_e5202c9fd57615db=function(A){return A.writable},t.wbg.__wbg_write_2e39e04a4c8c9e9d=function(A,j){return A.write(j)},t.wbg.__wbindgen_cast_2241b6af4c4b2941=function(A,j){return so(A,j)},t.wbg.__wbindgen_cast_4625c577ab2ec9ee=function(A){return BigInt.asUintN(64,A)},t.wbg.__wbindgen_cast_d6cd19b81560fd6e=function(A){return A},t.wbg.__wbindgen_cast_e9d4edd5d697755b=function(A,j){return d4(A,j,317,KQ)},t.wbg.__wbindgen_cast_eb8544ce08914b2c=function(A,j){return d4(A,j,3778,XQ)},t.wbg.__wbindgen_init_externref_table=function(){let A=eA.__wbindgen_export_4,j=A.grow(4);A.set(0,void 0),A.set(j+0,void 0),A.set(j+1,null),A.set(j+2,!0),A.set(j+3,!1)},t}function F4(t,A){return eA=t.exports,tW.__wbindgen_wasm_module=A,jc=null,gd=null,kd=null,eA.__wbindgen_start(),eA}function P4(t){if(eA!==void 0)return eA;typeof t<"u"&&(Object.getPrototypeOf(t)===Object.prototype?{module:t}=t:console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));let A=w4();t instanceof WebAssembly.Module||(t=new WebAssembly.Module(t));let j=new WebAssembly.Instance(t,A);return F4(j,t)}async function tW(t){if(eA!==void 0)return eA;typeof t<"u"&&(Object.getPrototypeOf(t)===Object.prototype?{module_or_path:t}=t:console.warn("using deprecated parameters for the initialization function; pass a single object instead")),typeof t>"u"&&(t=new URL("parquet_wasm_bg.wasm",import.meta.url));let A=w4();(typeof t=="string"||typeof Request=="function"&&t instanceof Request||typeof URL=="function"&&t instanceof URL)&&(t=fetch(t));let{instance:j,module:e}=await AW(await t,A);return F4(j,e)}var I4=m8("AGFzbQEAAAAB5AiJAWACf38AYAN/f38AYAJ/fwF/YAF/AGABfwF/YAR/f39/AGADf39/AX9gBX9/f39/AGAGf39/f39/AGAFf39/f38Bf2AEf39/fwF/YAd/f39/f39/AGAAA39/f2ADf39/AX5gAW8Bb2AAAX9gBn9/f39/fwF/YAFvAX9gCH9/f39/f39/AX9gCH9/f39/f39/AGACf38BfmAAAn9/YAd/f39/f39/AX9gAn9/AW9gC39/f39/f39/f39/AX9gAn9+AGAAAW9gAX8Df39/YAx/f39/f39/f39/f38Bf2ADf39+AGAAAGAJf39/fn5+fn9/AGADf35/AGABfwJ/f2AABH9/f39gAn9vAGACb28Bb2AEf39+fwBgA39+fgBgAX8BfGABfwFvYAFvAGAKf39/f39/f39/fwF/YAp/f39/f39/f39/AGAEf35/fwBgAX8BfmACf28Bb2ACb28AYA5/f39/f39/f39/f39/fwF/YAR/f39+AGAFf35+fn4AYAl/f39/f39/f38Bf2AFf39+f38AYAJvfwFvYAJvfwBgAm9vAX9gDX9/f39/f39/f39/f38AYAZ/fn5+fn8AYAl/f39/f39/f38AYAF/AX1gBn9/fn5+fgBgA29vbwFvYAx/f39/f39/f39/f38AYAV/fn9/fwBgAn98AGAFf39/fn8AYAR/fn5/AGADf398AGABfwR/f39/YAJ/fwN/f39gAW8BfGADb39/AW9gA29/fwBgA39/bwBgC39/f39/f39/f39/AGADfn5/AX9gBX9/fn9/AX9gCX9+fn5+fn5+fgBgBH98f38Bf2AEf31/fwF/YAZ/f35/f38AYA5/f39/f39/f39/f39/fwBgAXwBfGADfn9/AX9gAX0BfWADf35/AX9gD39/f39/f39/f39/f39/fwF/YAF+AX9gA39/fwN/f39gAn9vA39/f2ADb29vAGADf39vAW9gAm98AGAFb39/f38AYAF8AW9gAX4Bb2AKf39/f39+f39/fwBgEX9/f39/f39/f39/f39/f39/AX9gBH9/fn4AYA9/f39/f39/f39/f39/f38AYAd/f35+fn5/AGAEf39/fQBgBX9/fn5/AGAEf398fwBgBH9/fX8AYBJ/f39/f39/f39/f39/f39/f38AYAl/f39/f39+fn4AYAV/f39+fwF/YAN/fnwAYAZ+f39/f38BfmAIf39/f39+f38AYAJ/fwF8YAN+f38BfmAFf39/f34AYBZ/f39/f39/f39/f39/f39/f39/f39/AX9gAn5/AGAHf39/f39+fwBgAn5+AXxgAn9/AX1gBH9/f38BfmAFfn5+fn8Bf2ACfH8BfGAEfn9/fwBgBH9/f34Bf2ADf39+AX9gBn9/f39/fgF/YAJ+fwF/YAJ+fgF+YAR/fn5+AGACf38Ef39/f2AFf399f38AYAR/fX9/AGAFf398f38AYAR/fH9/AGAEf39vbwBgA39/fAFvYAABfgLRJn4Dd2JnFV9fd2JnX3BhcnF1ZXRmaWxlX25ldwAoA3diZxpfX3diZ19yb3dncm91cG1ldGFkYXRhX25ldwAoA3diZx1fX3diZ19jb2x1bW5jaHVua21ldGFkYXRhX25ldwAoA3diZzJfX3diZ19uZXd3aXRoaW50b3VuZGVybHlpbmdzb3VyY2VfYjQ3ZjZhNmE1OTZhN2YyNAAuA3diZyBfX3diZ19nZXRSZWFkZXJfNDhlMDA3NDlmZTNmNjA4OQAOA3diZxxfX3diZ19mZXRjaF9mMTU2ZDEwYmU5YTVjODhhAA4Dd2JnIV9fd2JnX3NldFRpbWVvdXRfMmIzMzk4NjZhMmFhMzc4OQA1A3diZyNfX3diZ19jbGVhclRpbWVvdXRfNjIyMmZlZGUxN2FiY2IxYQAOA3diZxhfX3diZ19yZWNvcmRiYXRjaF91bndyYXAAEQN3YmcVX193YmdfcmVjb3JkYmF0Y2hfbmV3ACgDd2JnD19fd2JnX3RhYmxlX25ldwAoA3diZx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0YTRjMmY2NgAjA3diZyRfX3diZ19nZXR3aXRocmVma2V5XzFkYzM2MWJkMTAwNTNiZmUAJAN3YmcaX193Ymdfc2V0XzNmMWQwYjk4NGVkMjcyZWQAWgN3YmclX193YmdfcXVldWVNaWNyb3Rhc2tfMjVkMDczOWFjODllOGM4OAApA3diZyVfX3diZ19xdWV1ZU1pY3JvdGFza180NDg4NDA3NjM2ZjViZjI0AA4Dd2JnHF9fd2JnX2ZldGNoXzg3YWVkN2YzMDZlYzZkNjMAJAN3YmcdX193Ymdfc2lnbmFsX2RhNGQ0NjZjZTg2MTE4YjUADgN3YmcaX193YmdfbmV3XzY2Yjk0MzRiNGU1OWI2M2UAGgN3YmccX193YmdfYWJvcnRfNjdlMWI0OWJmNjYxNDU2NQApA3diZxxfX3diZ19hYm9ydF9kODMwYmYyZTlhYTZlYzViAC8Dd2JnG19fd2JnX3ZpZXdfOTFjYzk3ZDU3YWIzMDUzMAARA3diZx5fX3diZ19yZXNwb25kXzZjMmM0ZTIwZWY4NTEzOGUANgN3YmcoX193YmdfbmV3d2l0aHN0cmFuZGluaXRfYjVkMTY4YTI5YTNmZDg1ZgBbA3diZypfX3diZ19pbnN0YW5jZW9mX1Jlc3BvbnNlXzUwZmRlMmNkNjk2ODUwYmYAEQN3YmcaX193YmdfdXJsX2U1NzIwZGZhY2Y3N2IwNWUAIwN3YmcdX193Ymdfc3RhdHVzXzNmZWEzMDM2MDg4NjIxZDYAEQN3YmceX193YmdfaGVhZGVyc18yOWZlYzNjNzI4NjVjZDc1AA4Dd2JnIl9fd2JnX2FycmF5QnVmZmVyXzljOTliOGUyODA5ZThjYmIADgN3YmcnX193Ymdfc2V0aGlnaHdhdGVybWFya18zZDU5NjFmODM0NjQ3ZDQxAFwDd2JnG19fd2JnX3NpemVfOGY4NGU3NzY4ZmJhMDU4OQBGA3diZyJfX3diZ19hcnJheUJ1ZmZlcl8yYzkwN2VkOGU4ZWY0ZTM1AA4Dd2JnHF9fd2JnX3NsaWNlXzIyNDg1NmQ0NjIzMGMxM2MARwN3YmcgX193YmdfZ2V0V3JpdGVyXzAzZDc2ODllMjc1YWM2YTQADgN3YmcaX193YmdfbmV3X2Y2ZTUzMjEwYWZlYThlNDUAGgN3YmcdX193YmdfYXBwZW5kXzcyYTNjMGFkZGQyYmNlMzgAXQN3YmcbX193YmdfcmVhZF9iYzkyNWM3NThhYTRkODk3AA4Dd2JnIl9fd2JnX3JlbGVhc2VMb2NrX2ZmMjliNTg2NTAyYTgyMjEAKQN3YmcdX193YmdfY2FuY2VsXzhiYjViOGY0OTA2YjY1OGEADgN3YmcfX193YmdfcmVhZGFibGVfZTgyY2ZmMjdiOTY4ZWQxYwAOA3diZx9fX3diZ193cml0YWJsZV9lNTIwMmM5ZmQ1NzYxNWRiAA4Dd2JnGl9fd2JnX25ld185OWE2YTk0OGQ1YjNmNjA3ABoDd2JnHF9fd2JnX3JlYWR5XzQxODZkYTNjYjUwMGFlN2QADgN3YmccX193YmdfY2xvc2VfYTE5MThjZmYzY2FjMzU1YgAOA3diZyJfX3diZ19yZWxlYXNlTG9ja182MjE1MTQ3MmFlNjMyMTc2ACkDd2JnHF9fd2JnX3dyaXRlXzJlMzllMDRhNGM4YzllOWQAJAN3YmceX193Ymdfc2V0Ym9keV9jODQ2MGJkZjQ0MTQ3ZGY4AC8Dd2JnH19fd2JnX3NldGNhY2hlXzkwY2E0YWQ4YThhZDQwZDMANgN3YmclX193Ymdfc2V0Y3JlZGVudGlhbHNfOWNkNjBkNjMyYzlkNWRmYwA2A3diZyFfX3diZ19zZXRoZWFkZXJzXzAwNTIyODNlMmYzNTAzZDEALwN3YmcgX193Ymdfc2V0bWV0aG9kXzliNTA0ZDViODU1YjMyOWMASAN3YmceX193Ymdfc2V0bW9kZV9hMjNlMWEyYWQ4YjUxMmY4ADYDd2JnIF9fd2JnX3NldHNpZ25hbF84YzQ1YWQxMjQ3YTc0ODA5AC8Dd2JnHl9fd2JnX2dldGRvbmVfZjAyNjI0NmY2YmJlNThkMwARA3diZx9fX3diZ19nZXR2YWx1ZV8zMWU1YTA4ZjYxZTVhYTQyAA4Dd2JnIl9fd2JnX2J5b2JSZXF1ZXN0XzJjMDM2YmNlY2ExZTYwMzcAEQN3YmccX193YmdfY2xvc2VfY2NjYWRhNjA1M2VlM2E2NQApA3diZxxfX3diZ19jbG9zZV9kNzFhNzgyMTlkYzIzZTkxACkDd2JnHl9fd2JnX2VucXVldWVfNDUyYmMyMzQzZDFjMmZmOQAvA3diZxpfX3diZ19nZXRfMGRhNzE1Y2VhZWNlYTVjOAA1A3diZx1fX3diZ19sZW5ndGhfMTg2NTQ2YzUxY2Q2MWFjZAARA3diZyBfX3diZ19uZXdub2FyZ3NfMjU0MTkwNTU3YzQ1YjRlYwAXA3diZxpfX3diZ19uZXdfMmZmMWY2OGYzNjc2ZWE1MwAaA3diZxtfX3diZ19uZXh0XzViMzUzMGU2MTJmZGU3N2QADgN3YmcbX193YmdfZG9uZV83NWVkMGVlNmRkMjQzZDlkABEDd2JnHF9fd2JnX3ZhbHVlX2RkOTM3MjIzMDUzMWVhZGUADgN3YmcfX193YmdfaXRlcmF0b3JfZjM3MGIzNDQ4M2M3MWExYwAaA3diZxpfX3diZ19uZXdfMTljMjVhM2YyZmE2M2EwMgAaA3diZx5fX3diZ19pc0FycmF5XzAzMGNjZTIyMDU5MWZiNDEAEQN3YmctX193YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl82N2YzMDEyNTI5ZjZhMmRkABEDd2JnGl9fd2JnX25ld19kYTlkYzU0YzVkYjI5ZGZhABcDd2JnG19fd2JnX2NhbGxfMTM0MTBhYWM1NzBmZmZmNwAkA3diZxtfX3diZ19jYWxsX2E1NDAwYjI1YTg2NWNmZDgAPQN3YmcaX193Ymdfc2V0X2I3ZjFjZjRmYWUyNmZlMmEAPQN3YmcbX193YmdfbmV4dF82OTJlODIyNzkxMzFiMDNjAA4Dd2JnJF9fd2JnX2lzU2FmZUludGVnZXJfMWMwZDFhZjU1NDJlMTAyYQARA3diZx5fX3diZ19lbnRyaWVzXzJiZTJmMTViZDU1NTQ5OTYADgN3YmcfX193YmdfdG9TdHJpbmdfNzhkZjM1NDExYTRmZDQwYwAOA3diZxpfX3diZ19uZXdfMmUzYzU4YTE1ZjM5ZjVmOQAXA3diZx5fX3diZ19yZXNvbHZlXzQwNTVjNjIzYWNkZDZhMWIADgN3YmccX193YmdfY2F0Y2hfYzgwZWNhZTkwY2I4ZWQ0ZQAkA3diZxtfX3diZ190aGVuX2UyMjUwMGRlZmUxNjgxOWYAJAN3YmcbX193YmdfdGhlbl9iMzNhNzczZDcyM2FmYTNlAD0Dd2JnMl9fd2JnX3N0YXRpY19hY2Nlc3Nvcl9HTE9CQUxfVEhJU19mMGE0NDA5MTA1ODk4MTg0AA8Dd2JnK19fd2JnX3N0YXRpY19hY2Nlc3Nvcl9TRUxGXzk5NWIyMTRhZTY4MWZmOTkADwN3YmctX193Ymdfc3RhdGljX2FjY2Vzc29yX1dJTkRPV19jZGUzODkwNDc5YzY3NWVhAA8Dd2JnLV9fd2JnX3N0YXRpY19hY2Nlc3Nvcl9HTE9CQUxfODkyMWY4MjBjMmNlM2YxMgAPA3diZx1fX3diZ19sZW5ndGhfNmJiN2U4MWY5ZDc3MTNlNAARA3diZydfX3diZ19wcm90b3R5cGVzZXRjYWxsXzNkNGEyNmMxZWQ3MzQzNDkASQN3YmcaX193Ymdfc2V0XzEzNTNiMmE1ZTk2YmM0OGMASAN3YmcaX193YmdfbmV3XzYzOGViZmFlZGJmMzJhNWUADgN3YmcsX193YmdfaW5zdGFuY2VvZl9VaW50OEFycmF5XzlhODM3OGQ5NTU5MzNkYjcAEQN3YmcjX193YmdfbmV3ZnJvbXNsaWNlXzA3NGM1Njk0N2JkNDM0NjkAFwN3YmcoX193YmdfbmV3d2l0aGJ5dGVvZmZzZXRfNmJkNGIyYTRjYTUxODg4MwA1A3diZzFfX3diZ19uZXd3aXRoYnl0ZW9mZnNldGFuZGxlbmd0aF9lOGY1MzkxMGI0ZDQyYjQ1AEcDd2JnHV9fd2JnX2J1ZmZlcl84ZDQwYjFkNzYyZmIzYzY2AA4Dd2JnIV9fd2JnX2J5dGVMZW5ndGhfMzMxYTZiNTU0NTgzNDAyNAARA3diZyFfX3diZ19ieXRlT2Zmc2V0XzQ5YTViNTYwODAwMDM1OGIAEQN3YmcaX193YmdfZ2V0XzQ1OGU4NzRiNDNiMThiMjUAJAN3YmcaX193YmdfaGFzX2I4OWU0NTFmNjM4MTIzZTMANwN3YmcgX193Ymdfc3RyaW5naWZ5X2I5OGM5M2QwYTE5MDQ0NmEADgN3YmcqX193Ymdfd2JpbmRnZW5kZWJ1Z3N0cmluZ185OWVmMjU3YTNkZGRhMzRkACMDd2JnJV9fd2JnX3diaW5kZ2VubWVtb3J5X2Q4NGRhNzBmN2M0MmQxNzIAGgN3YmcsX193Ymdfd2JpbmRnZW5mdW5jdGlvbnRhYmxlX2FhMTA4NGIyOTY5YTljYmUAGgN3YmccX193YmdfRXJyb3JfZTE3ZTc3N2FhYzEwNTI5NQAXA3diZx1fX3diZ19OdW1iZXJfOTk4YmVhMzNiZDg3YzNlMABGA3diZypfX3diZ193YmluZGdlbmlzdW5kZWZpbmVkX2M0YjcxZDA3M2I5MmYzYzUAEQN3YmcnX193Ymdfd2JpbmRnZW5pc29iamVjdF8zMDdhNTNjNmJkOTdmYmY4ABEDd2JnKV9fd2JnX3diaW5kZ2VuaXNmdW5jdGlvbl84Y2VlN2RjZTM3MjVhZTc0ABEDd2JnJ19fd2JnX3diaW5kZ2VuaXNzdHJpbmdfZDRmYTkzOTc4OWYwMDNiMAARA3diZydfX3diZ193YmluZGdlbmlzYmlnaW50X2VjYjkwY2MwOGE1YTkxNTQAEQN3YmchX193Ymdfd2JpbmRnZW5pbl9kN2ExZWUxMDkzM2QyZDU1ADcDd2JnKF9fd2JnX3diaW5kZ2VubnVtYmVyZ2V0X2Y3NGI0Yzc1MjVhYzA1Y2IAIwN3YmcpX193Ymdfd2JpbmRnZW5ib29sZWFuZ2V0XzNmZTZmNjQyYzdkOTc3NDYAEQN3YmcoX193Ymdfd2JpbmRnZW5zdHJpbmdnZXRfMGYxNmE2ZGRkZGVmMzc2ZgAjA3diZy1fX3diZ193YmluZGdlbmJpZ2ludGdldGFzaTY0X2FjNzQzZWNlNmFiOWJiYTEAIwN3YmckX193Ymdfd2JpbmRnZW50aHJvd180NTFlYzFhODQ2OWQ3ZWI2AAADd2JnJV9fd2JnX3diaW5kZ2VuY2Jkcm9wX2ViMTAzMDg1NjY1MTJiODgAEQN3YmcmX193Ymdfd2JpbmRnZW5qc3ZhbGVxX2U2ZjJhZDU5Y2NhZTFiNTgANwN3YmcrX193Ymdfd2JpbmRnZW5qc3ZhbGxvb3NlZXFfOWJlYzhjOWJlODI2YmVkMQA3A3diZx9fX3diaW5kZ2VuX2luaXRfZXh0ZXJucmVmX3RhYmxlAB4Dd2JnIF9fd2JpbmRnZW5fY2FzdF9lOWQ0ZWRkNWQ2OTc3NTViABcDd2JnIF9fd2JpbmRnZW5fY2FzdF8yMjQxYjZhZjRjNGIyOTQxABcDd2JnIF9fd2JpbmRnZW5fY2FzdF9kNmNkMTliODE1NjBmZDZlAF4Dd2JnIF9fd2JpbmRnZW5fY2FzdF80NjI1YzU3N2FiMmVjOWVlAF8Dd2JnIF9fd2JpbmRnZW5fY2FzdF9lYjg1NDRjZTA4OTE0YjJjABcD2D3PPQcHBwcHBwcHBwUFBQUIAQUFAAAAAAcBAQIHYAAHAgIBBQUAAgUFAT4BBQEBCgMEOAcBFgABAgEHBwEHAAEBCAIKCwABBQUICAUFCAgAAAAICAgIAQUAAAgFBwAABQUAADk5AAABAQAAAAAAAAACYQEfHx8HBx8JHwcfEAcHBwcHBwcHBwcHBwcHBwcHBx8fAQEBAQIHAAgBBwcHAQcHAQEBAQcHB0oHBwcHBxABBg0SAwcCBwcFBQcABwEBAQUqBwcHBwcHBwcCCAcHBQA6EA0CAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQEFEAEBAAAAAAAAAAAAAAgFBUsACwIAAQAABT8AAAABBQUFBQUFBQUFAAYBAQUBAAIAAAUFBQUFBQUBBQEFBRABBwUFFgEFBQAABQoKCgoAAgAAAAAAAAAAAAAAAAUAAAAACwAAAAAIBQAAAAAAAAAAAAEAAAAAAAAAAAAAAAgICAAAAAAAAAEABwUAAAUBAQUFBQEFAQUFAQEKCgUJBQUFBQUFBQAFBQoICgAAAAUBAAAABQUFAQIABQUFAQEBBQkFAQUFBQUFBQAFBQUBAQABBQIcAAAJCQkABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUWAAAFBQABAAAAAAAAAAEAAQAAAQAAAAAAAAAAAAAAAAAFBQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQBHAABAABMAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAFHAAAAAAAAAAAAAAAAAAABQAAAAUAAAACCgIwMDAFBQUKCgEKBQUFBQpNAAAxBQUFQAEAAjIFBQocHAgBAQkBABYBAQISAAoBCwEKBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFBQUIBwEBBQUBAQEBCAgKCgoKCgoKEAkCAgECAgICGAAABwcBGAAKCgoKCgAAAAAAAAZiAAEFBQUFBQUFBQUFBQU7OzsBAQEBBQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQoKAAAAEAAFAAgIAAUFOGMBBgYCCAIAEAkGBgkAARMIAQgIBU4GTwgICAgIHAcABQAAAAAAAAAAAAAJBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB00AAAAAAAAAAAAAAAoBAQEBAQEHBwgQAAAAABwBAAICAgICAgEBAQICAgICAgICAgICAgIAAQcrKysLAgUBHAA6BggBAQcBAAIBAQELAQEFBRMBASoqFkA4AQEQATMBAQEFAE4ABQUQAQEWCAgICAgICAgICAFPBQUAAgULCwsLCwtMAQAAAAIQARYHAQEHBQcFECoBBwcHBwcHBwcBBQIBATwHHAIFABYCAQUBBQgIBAQEBAUYAAEBAAcABgEICAgICAgICDEFBQUGBAQKBQUIAQU8AQsDBQUFAQEBAQgICAgICAgICAgCKwUAFBMBAgICCAgAAgICAgICAgJkAmULAQAFBgE8PAoFAQEBAQEBCDMAAQcTBQEBAQECAgEFBQIDAAAAAAAGAwcBAAsBAQUBBgYBAgEBAQULZgUFCQkABQUFAQsLBQcHBwcHBwcHBwcHBwoAAAcCASs+BQEBAQcAAAkCBQUABQUFZyUFBQUFBSVoAAABAAAAAAAAAAAAAAAACgUKAAUKBQUBNCUCBQAAAAAAAAACCQsHBgAICAAACAUFBQUJJgoKBgEBCwUAAQAFAQEBAAAGJg0LAgIABQkmAAABAQELBwMCAAAAFAACUAEBABQFAQECAQsSAAYUCwAAAAAAAAAAAAAAAAAAAAEBAAAAAAMFAwMDAwMICAgICAgDAwMDAQkDAwADAwMDAwMUFBQUFBQBAwMDAwMDAwMCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw0DAwMCAgICEwEAAAsLAANRAQEBAgMAAEEBFBQBAQAFFgsLCwA5AQUAAAAAAAUACAIACwMLEgEABgMAAAAFAQEBBQgeSgsLCwcICAgICAgqAQEBAQEBBQUFBQEFBQUFBWkGAQEFBQUFBQUFBwMLCwEBAQEFBQUFAQEABGoIAQEAAAACQQsLCwsLCwsLCwsBBQUFBQAAAQUFBQUFBQADBwcFAAUFAAEBAABQAQACBwUAAAABBQcBAQEBAQUYFAAAAgUTAQEAAAABAAUHAAAAAAELawIAAAEAAAEBAQFCAAEKAQAAADgHBwcHAgEAAAUHBwIAAQAFAQICAwUdAQEBATkBAAACAAIAAAAAAAABAAAAAAEADwcAAAAAAAAAAAAAAAAAAAAAAAQDCwAEAQEAAAAAARYBABMAAQYGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAQDBQcBAAAAAAAAAAUFBQUFBQUFAQECAgYAAAAAAAcAAAEBAQEBAAAFBQUFBQUFBQUFBQUFBQUFBgYGBwtSAAABAAAIExMTExMTHQUFBQUFBQUFBwEFBQUFBQUFBRABBQcWByAIBwcTEwAAAAAABwUEPgUAAggFAQUYAQEBAQcAAAAAAAIBAQEBBQUFExMLAwQBCAUDAgUCBRQAAAABBRMTAQEFAAEAAAUCBQYAABgAABABAQAAAAAAAAADAAAABwcHAFMBASAAAAEBAwABBQUFBQUACQA0BQEAAAcEAAMQAQUAAAAAAAAAAAAAAAAAAAAAAAAFBQMAAgcCAAcHCQICAAIDAQAAAAAAAQEACAUAAgMBAQEBAAEKCgoKAgUCCQICASAIBQICbAcAAAAAAAAAAAAAAAAAAAAAAQAFAgAEAAAAAAAAACwsLCwAAAEBAQICAgICAQICAgICCDBtCQMJAAAAAwAAAQAACgEQAAEAAAICBQsAAwsDAAAAMQEAABkCOgkBAUEIAwMtbgUFAAUAAQEBBQEAAgIBMwUFAAsBAQACBQELAAAABQUBAAIDAgICAgAADwEFBQUGPwAAAAJUCgAABAUDAAEBAAEACwEKVQBvAQEBAQEBAAUBAAAABwABCwcHAwAAAQEBAQEDAQADAAcACRAFBQUFCQkJCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDAAYFBgEJAQUCAgMHAwNVBQFWBnA/AQEBAQEBAQACAQUAAAUJAAUFAAMBAQAALAUHAwAAAAAGAQAAAAAAAAAAAwAAAAAAAQAFBwFxBwcAAAQHBgcBBwIABQAAAQEFAQUFBQUBAQEBBwAAAAAEBAABAQIFAQEHAAcHAwIKAgAxAQMLCAAAAAAAAAAAAAAAAAAAAAACAQMAAAICBgMAARISAQEAAAAAAQEBAQcFAQAFBQUFAAEABAAZBQAABgMDAwMDAwMDAAQDAwAFAwMDAwoBAAAAAAAAGQQZAAADAwMAAAUAAAEABQAAAgUBAQEBAQEBAAAAAAEBAAADAQIBBQcGAAgAAQABCwUABQUAGXIDAxIYKgoBBAAAAAAAAwUAAQIIBQYDBgsDAQUCAAQDNAoEAQEAGQABAQgIAQEBBwAAAQEAAAACAgcBKwsDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEDczAABgUABzMFdAUFBQUFBQUFBQUFBQUFBQUFBQUFBQECdQMDAAAAAQEHBwAJBwUBAQEBAQEBAQACQAEFAAEtCAABAQQFBAAEAwV2AwMDAwEBBFEKAgMAAAdWAAAEBAABBgcBAAABAwN3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAQIABwEDAwAAAQUAABkAAAQAAAABAAUFBQUBAgEFGAMABAAABQk0OgIBAgEBAwEBBwAAAAEABQABAAAAAAEBAQEAAAAAAAAAAAAAAAcAAAcFAgMtAQYAAQYJCQkJCQEAAwMDAwEBAAAABQUDAwEBAwcCAwABAAEAAAAAAAAAAAAAAAAAAAgWAAEDAwMCBAEAAQECMgAxAwMAAAAFAQEBAAAAAgADAwcHBwcHCgoABAUFBQUFBQUBAQIAAAEFAQEHCwMHAQEPAAEBCQEFCQUAAAAAAQAAAQIGAgMFAwIAAAABAQQEBAUCJgECAAAAAAECAAAAAAAABwAABQMCAgEBAQEBAQEBAQEBAQEBAQEBAQcAAgEBAgIBAwEBAQEABR0FAAEELQQAAgELAAUJCQkDAQcJAQMBBQYFBQEAAiYAAgUEAwMBAQEBAQEBAQEFAAUAAAMAAAAAAAAAAAEBAAUCAhQDAwAAAAMDAwACBwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAgEBBQUBAQEBHR0BAQEdBQMFCwYCAQEAAAABAQEFBQEBAAAAAAABAAMDAwAAAwMAAhYBARkFAgAEAgAAAQQDAAAAAAAFBQUFBAQEBAUDCAAGAw0AAAIBBAIAAwIAAAEBAQECAAEDAQAEAAQBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAggDCAICAgICAgADBAQEAQABBwMAAwETAAMCBwIAAQIDBgICAwMCCgMAAwIBAgQAAQAdAAoBCgYHAQEBAQEBBQUDAwMDAwMDAwMDAwUFBQUFBQUCAAMDBwMAAgICAgAABQUFBQUFBQYAAAAAAAAAAAACAAYAAAEBAQEBAQEBAQEBAQEBAQEBAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAXgCAgICAgIAAAAAAQAAAgMKAwMDAAAdAQUFBQMBAgoCAgICAgQEBAQEBAQEBAQEBAQEBAMDAwMDAwMDAwMDAwMICAIAAAAAAgMDAAAyAwMlCgMAAAMDAgMDBQICAAAAAQEDAQEBAQcDAwMHBwMDAwMDAwMDAwMAAAMHAAMDAwMDBAAAAwEABQUAAAUAAgAHAAICAgAAAAAAAAAAAAAAAQMBAwADAwMDAAADAwEACAEAAgICAAAAAAMDAwMAAAMDAwEBBQMCAgECCgoKCgoKCgoBAAAACgUDAwIlAwMDAAEDAwEDCQMBAQEBAQEBAQEBAQEBAQEBBAAGAgMCAiYDAwMEAgMDAwMAAAAEBAQEBAQBBAkDBAkAAwEAAAMDAwMDAwMEAQABAQADCgMDAAEDAgIHAQUCAgMDBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDAwMgAwMIBgkCAQAAAAMDAwMFBQAAAAMDAAAFAgIAAAIGAgQEBAQHBwcHBwcHBwIABAYAeQMGAAMAAAMDAwADAAAACgYUAAAAAAUFBQUFBQUFBQUFSwUFBQUFBQUFBQUFBQUFBQABAAACBAABAAEBAAUBAQEBAQEBAQ0DAQEACAEFBQMAAAMCAgICAgICAgMAAAAAAAEFAAEBBAMDAwMEAAAEAwMDAwADAwAAAAECAwIWAgAAAAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcBAAADAwMDAgAAAwADBgUNAwYDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwMBAgEDAAAAAwMDAwACAAMDAwMDAwYEBAAABgZ6BgcHBwcFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQMFAQAKMgMFAwMGQkIDAwAAAwQBAwEDAwEEAjIEBQMAAgAAAwEAAgICAgZ7AgcFAAEEBAQEBAQEBAQEBAADAwEAAAAAAgUFAQEIAAMDAwMAAAAEAgICAAUBAAACAgEABAAABQEAAFIABAUFBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwQCAAAAAAECA0NDBAADAwICBQEEAwMDBAQEBAQEAwMDA3wBAQAAAQAAAAAAAAAAAAADAwMDAwMAAAMDAwMDAwMDAwICAAAAAAAAAAACAgICAgICAwMCAgEAAgMDAwADAAAAAwABBAAAAEMAAAANAgAKAAAAAAAAAAQEBAQEBAQEBAQEBAQFBSAgICAHBwEDAwICBAIAAAADBAQCEAEBCgACAAACAwUEAgQAAQICAwMFAwADAwMDAwQCAwMDAQEGAwAAAAAAAAMBAgECBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcDAAMDAQMDAwUFBQUABAEBAQABAQYDAwMBAQEAAwAFBQMGDQMABQMBAwMIAQ0NAwQFAgMDAAADAgIDAw8DAgIDAwMDAQMCAAAAAwMDAAMJCgADAwMDAwMDAwMDAwMDAwMHBgAAAgIDAQACBgMGAwMDAwQEAgMDAw0NGQICAAJXBAcHBwcHBwcHBwcHBwcHBwcHBwcAAAMDAAMDAwUAAwMDAwMDAwMDBQMBAwICAQADBB4CAgQAAx4GAwMAAwMFAQIDAAAAAAAADQMHBwEQAgIAAwMDAAAAAAAAAAAABAEHAAIAAgAAAwAAAAEAAgMEAAAAAAAAAAAAAAIDfQIGEwYCAAAABAADAAQCBwABAwgAAwMDAwMDBAgDBwEDBQMDAQEJBQEHAQMEBAQDAgMCBAEHAAcBAQcGAgMABAQCBQACAgAAAgIGAAMCAQEBAAMBBgICAwMBBgMDAwMDAwADAQAAAwMBAwMDAwAEAQMDAwEBAQEAAQMDAwMDAAMDAAEAAAMAAAAAAgACAQAAAAEBBgAAAAAAAAAAAAJ+AgUFBQMDAAAAAAQEBAMDBAQDCgMDAAQDAAQDAwMDAwQEBAQEAwQEAAAAAAAAAAAEBAQBBQAEAAAAAwMDAwQEBAMHAgQEBAQEBAQEAwMDBAMBAQMDAgICBwICAAAAAAEBAQEBAQEBAAECAgIEAAICBQACBAMDAwMDAwMBAgEDBAMDA38FBAQDBAMEBAMEBAQEAAQABAQEBAQEBAQECYABAwMDAwMDAwMDAycnJycnJycFAgMDAAEDAwMDAwMAAwAEAwUFAQEDAwQBAQMAAgMDBAQEBAQEBAQDAwMDAwEEBQEAAAAFAwMAAgUFBwMDAgQtDwIAAgIBAgQDBQADBQAAAgICAgAEBlcEAwkCAgMCAgIDAwMEBAEAAAEDAQEKAwIeBAMDAwMCAgAAAAMCAwQAAgICAgICAgICAwICAgMDAQMBAgYPAgIDAQQEAQIEAwIKAgQDAwMCAwEDAwMBAwQDAwcHBwAEgQEDAwMDAwMDAwACAgIBAzsDAwAEAAQFAwIDAAIFWEREWEQDDwMEAQMDAwAHAAAAAAAAAAAAAAAAAAAAAgAAAAAACQMBAABZRUVZRQMDAwMDAwMDAAMAAAEDAwMAAAACAgMADQoAAgICAAADAAUAGxsbGxsbGxsbGwMDAwMAAQEBBAQFBAABAQMDAwMDAwMDAwMDAwAAAAADAgAAAgIDAQABAwAAAwIDAwMDAwMDAAADBAMEAwkJCQkJUwAAAwMDAAAAAAAAAAEEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAgABISEhISEhISEDAwMDAgMEAwMDAgICAgIGBgQCAAAAAAAAAwECAgAAACYZAAAEAxADAwMDAwICAgoAAAAAAAAAAQMEAwICJQMNDQMDAwICAQICAQEEAgICAg0CDQACAgICAgOCAYQBBwk0AwIACgMDAwMDAwACAwMDAwMDAwMDBBgYAwMAAAAAAAADAwIAAAEFAAIChgEDAwMDAQEAAgACAg8PDw8FBQQDBQUFBQUNDQMDAwMDAwEDDQENDQ0NDQICAgIAAAQPDxkDBQAGAgMDAgQEAwMDAwIAAAYSEhISEhISEhISEhIBAwMDAwAEAAMAAAICAgMGAVQENS4uLi4DAwMAAAMDAwADAwADAwAAAAMDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABB0AAAAAAAAAAAAAAAAAAAADAwMAAAAAAAAABwMDAC0AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAMAAAAAAAAAAAAAAAAAAAAAAAACAAICAgAAAAMDAwMAAAACAg4DBAMEBAQEBAYGCQkJCQkJCQkJCQkJCQkJCQkJCQkUBgAFBQAEAAQAAAQEAAAEBAAEDwIDAwICAgIBAwEBAAICBgMDCgIGBQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAQEDAAMDAAkCAAkJCQkJCQkQEAECAgYCBgMBAwMEAgYDAgMDBgIDBAQBBgEDBgYCBIcBSQAAAgIABAQDCQkJCQkJBAUIBAQEBAQAAwQEBAQEBAQGAAECBw8XFxcjAAMAAgICAAABAgIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAIAAwIAAAAAAAAAAAAAAAAAAAAAAAAJAAAAAgMCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAABAQEAAQEAgICAgIABAAEAAAAAAAEBAAABAAAAAcHBwcHBwcHAgcAAwQFBQADAAEEAwACAgIEKAICAQICBAIEBAAEBgEEBAQDAwIBAQICBQMCBAICAgICAgICAQUFAgoKCgQEAAQAAw8CBAQEBAQKBAEBAQMBAhoaAwICAgICAwMDAgICAgICAgICAgICAgICAgIEAgICAwIAAgICAgADAwIDAgIAAgABAQMDAwMDAwMDAwMDAwMDBAICAgIEBAQEBAQCAgIABAAEAgICAgMCAwMCAgICAgICAgICAgICAwICAgICBAICAgICAgICAwACAgICAgIAAgICAgACAgIEBAQEBAQEBAQEBAIEBAQEBAQCAgQEBAQEBAQEBAQEBAIEAgIEAgMDAwMEBAQEBAQEAgACAgICAwMCAgICAgICAgICAgICAgICAAICAgQBAgIFBAQEAAIEAgQAHh4CAgICAgICAgIAAgICAgIGAgAAAgICAgQEAgAABAQEAAAAAAAABAQAAAQCAAAEBAQEBAQAAAACAgQUBAAAAAAAAAAAAAQEAAAAAAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEAgQBAQMDAgICAgICBAQDBAQEAwQDAwMEBAQEBAMEBAQEBA8eBAQEBAQEBAQEBA8EBAQEBIgBBAQCAgQEAQMFAAcECwJwAa4erh5vAIABBQMBACMGCQF/AUGAgMAACwfkHYQBBm1lbW9yeQIAFl9fd2JnX3BhcnF1ZXRmaWxlX2ZyZWUA/hUTcGFycXVldGZpbGVfZnJvbVVybAClNhRwYXJxdWV0ZmlsZV9mcm9tRmlsZQDTNBRwYXJxdWV0ZmlsZV9tZXRhZGF0YQCYLRJwYXJxdWV0ZmlsZV9zY2hlbWEAmS0QcGFycXVldGZpbGVfcmVhZACmNhJwYXJxdWV0ZmlsZV9zdHJlYW0ApzYaX193YmdfcGFycXVldG1ldGFkYXRhX2ZyZWUAiiQccGFycXVldG1ldGFkYXRhX2ZpbGVNZXRhZGF0YQD8JRxwYXJxdWV0bWV0YWRhdGFfbnVtUm93R3JvdXBzAIMqGHBhcnF1ZXRtZXRhZGF0YV9yb3dHcm91cADVJRlwYXJxdWV0bWV0YWRhdGFfcm93R3JvdXBzAIouF19fd2JnX2ZpbGVtZXRhZGF0YV9mcmVlAJEhFGZpbGVtZXRhZGF0YV92ZXJzaW9uALMrFGZpbGVtZXRhZGF0YV9udW1Sb3dzAO4qFmZpbGVtZXRhZGF0YV9jcmVhdGVkQnkAiy4dZmlsZW1ldGFkYXRhX2tleVZhbHVlTWV0YWRhdGEAmi0bX193Ymdfcm93Z3JvdXBtZXRhZGF0YV9mcmVlAIskG3Jvd2dyb3VwbWV0YWRhdGFfbnVtQ29sdW1ucwCEKhdyb3dncm91cG1ldGFkYXRhX2NvbHVtbgDWJRhyb3dncm91cG1ldGFkYXRhX2NvbHVtbnMAjC4Ycm93Z3JvdXBtZXRhZGF0YV9udW1Sb3dzAO8qHnJvd2dyb3VwbWV0YWRhdGFfdG90YWxCeXRlU2l6ZQDwKh9yb3dncm91cG1ldGFkYXRhX2NvbXByZXNzZWRTaXplAPEqHl9fd2JnX2NvbHVtbmNodW5rbWV0YWRhdGFfZnJlZQCMJBxjb2x1bW5jaHVua21ldGFkYXRhX2ZpbGVQYXRoAI0uHmNvbHVtbmNodW5rbWV0YWRhdGFfZmlsZU9mZnNldAC0Kx5jb2x1bW5jaHVua21ldGFkYXRhX2NvbHVtblBhdGgAji4dY29sdW1uY2h1bmttZXRhZGF0YV9lbmNvZGluZ3MAjy4dY29sdW1uY2h1bmttZXRhZGF0YV9udW1WYWx1ZXMA8iofY29sdW1uY2h1bmttZXRhZGF0YV9jb21wcmVzc2lvbgDCKCJjb2x1bW5jaHVua21ldGFkYXRhX2NvbXByZXNzZWRTaXplAPMqJGNvbHVtbmNodW5rbWV0YWRhdGFfdW5jb21wcmVzc2VkU2l6ZQD0KhtfX3diZ193cml0ZXJwcm9wZXJ0aWVzX2ZyZWUAkiEbd3JpdGVycHJvcGVydGllc2J1aWxkZXJfbmV3ALUrHXdyaXRlcnByb3BlcnRpZXNidWlsZGVyX2J1aWxkAIYRKHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldFdyaXRlclZlcnNpb24A1hwsd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0RGF0YVBhZ2VTaXplTGltaXQAtB8yd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0RGljdGlvbmFyeVBhZ2VTaXplTGltaXQA5CYpd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0V3JpdGVCYXRjaFNpemUAkyEqd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0TWF4Um93R3JvdXBTaXplAOUmJHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENyZWF0ZWRCeQDgICt3cml0ZXJwcm9wZXJ0aWVzYnVpbGRlcl9zZXRLZXlWYWx1ZU1ldGFkYXRhAPAsI3dyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldEVuY29kaW5nANYfJndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbXByZXNzaW9uAP4bLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldERpY3Rpb25hcnlFbmFibGVkAP0lLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldFN0YXRpc3RpY3NFbmFibGVkANcfKXdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkVuY29kaW5nAJsZLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkNvbXByZXNzaW9uAOwdMndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkRpY3Rpb25hcnlFbmFibGVkANccMndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtblN0YXRpc3RpY3NFbmFibGVkAJwZIl9fd2JnX3dyaXRlcnByb3BlcnRpZXNidWlsZGVyX2ZyZWUAkiELcmVhZFBhcnF1ZXQAxywKcmVhZFNjaGVtYQDxLAx3cml0ZVBhcnF1ZXQAqiwRcmVhZFBhcnF1ZXRTdHJlYW0A/jUWdHJhbnNmb3JtUGFycXVldFN0cmVhbQCAMB1fX3diZ19pbnRvdW5kZXJseWluZ3NpbmtfZnJlZQDeHhhpbnRvdW5kZXJseWluZ3Npbmtfd3JpdGUAgTAYaW50b3VuZGVybHlpbmdzaW5rX2Nsb3NlAPU6GGludG91bmRlcmx5aW5nc2lua19hYm9ydACCMCNfX3diZ19pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfZnJlZQCVIR1pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfdHlwZQDyKy5pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfYXV0b0FsbG9jYXRlQ2h1bmtTaXplAIUqHmludG91bmRlcmx5aW5nYnl0ZXNvdXJjZV9zdGFydACoNh1pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfcHVsbACDMB9pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfY2FuY2VsAM4sH19fd2JnX2ludG91bmRlcmx5aW5nc291cmNlX2ZyZWUAwCAZaW50b3VuZGVybHlpbmdzb3VyY2VfcHVsbACEMBtpbnRvdW5kZXJseWluZ3NvdXJjZV9jYW5jZWwAmSwWX193YmdfcmVjb3JkYmF0Y2hfZnJlZQCaIRNyZWNvcmRiYXRjaF9udW1Sb3dzAIkqFnJlY29yZGJhdGNoX251bUNvbHVtbnMAiioScmVjb3JkYmF0Y2hfc2NoZW1hAOcoEXJlY29yZGJhdGNoX3RvRkZJAJstE3JlY29yZGJhdGNoX2ludG9GRkkAnC0ZcmVjb3JkYmF0Y2hfaW50b0lQQ1N0cmVhbQDILBZyZWNvcmRiYXRjaF93aXRoU2NoZW1hAPIsEXJlY29yZGJhdGNoX3NsaWNlAIMmHnJlY29yZGJhdGNoX2dldEFycmF5TWVtb3J5U2l6ZQCLKhRfX3diZ19mZmlzdHJlYW1fZnJlZQCMGhNmZmlzdHJlYW1fbnVtQXJyYXlzAIwqFGZmaXN0cmVhbV9zY2hlbWFBZGRyAI0qE2ZmaXN0cmVhbV9hcnJheUFkZHIAkCQUZmZpc3RyZWFtX2FycmF5QWRkcnMAkC4OZmZpc3RyZWFtX2Ryb3AAly4UX193YmdfZmZpc2NoZW1hX2ZyZWUAyyEOZmZpc2NoZW1hX2FkZHIAjyMSX193YmdfZmZpZGF0YV9mcmVlAPAdEWZmaWRhdGFfYXJyYXlBZGRyAI4qEmZmaWRhdGFfc2NoZW1hQWRkcgCPKhFfX3diZ19zY2hlbWFfZnJlZQDxHQxzY2hlbWFfdG9GRkkAnS0Oc2NoZW1hX2ludG9GRkkAni0Uc2NoZW1hX2ludG9JUENTdHJlYW0AySwTc2NoZW1hX3dpdGhNZXRhZGF0YQDzLA5zY2hlbWFfaW5kZXhPZgDKLA9zY2hlbWFfbWV0YWRhdGEAny0Kd2FzbU1lbW9yeQC1Ow5fZnVuY3Rpb25UYWJsZQC2OxBfX3diZ190YWJsZV9mcmVlAJEkDHRhYmxlX3NjaGVtYQCjJBF0YWJsZV9yZWNvcmRCYXRjaADaGhN0YWJsZV9yZWNvcmRCYXRjaGVzAJEuEHRhYmxlX251bUJhdGNoZXMAkCoLdGFibGVfdG9GRkkAoC0NdGFibGVfaW50b0ZGSQChLRN0YWJsZV9pbnRvSVBDU3RyZWFtAMssE3RhYmxlX2Zyb21JUENTdHJlYW0A9CwYdGFibGVfZ2V0QXJyYXlNZW1vcnlTaXplAP0fGXJ1c3RfenN0ZF93YXNtX3NoaW1fcXNvcnQAuQoacnVzdF96c3RkX3dhc21fc2hpbV9tYWxsb2MAhi8acnVzdF96c3RkX3dhc21fc2hpbV9tZW1jbXAA4C8acnVzdF96c3RkX3dhc21fc2hpbV9jYWxsb2MAny4YcnVzdF96c3RkX3dhc21fc2hpbV9mcmVlANI1GnJ1c3RfenN0ZF93YXNtX3NoaW1fbWVtY3B5ANw0G3J1c3RfenN0ZF93YXNtX3NoaW1fbWVtbW92ZQDcNBpydXN0X3pzdGRfd2FzbV9zaGltX21lbXNldADdNBFfX3diaW5kZ2VuX21hbGxvYwC3KhJfX3diaW5kZ2VuX3JlYWxsb2MA4SsUX193YmluZGdlbl9leG5fc3RvcmUA+TUXX19leHRlcm5yZWZfdGFibGVfYWxsb2MA3xITX193YmluZGdlbl9leHBvcnRfNAEBE19fd2JpbmRnZW5fZXhwb3J0XzUBABlfX2V4dGVybnJlZl90YWJsZV9kZWFsbG9jAPIfFl9fZXh0ZXJucmVmX2Ryb3Bfc2xpY2UAqCwPX193YmluZGdlbl9mcmVlAPg1PXdhc21fYmluZGdlbl9fY29udmVydF9fY2xvc3VyZXNfX19fX2ludm9rZV9faGZlYzljNmMwMmY2MDQ2ZWQAoi8aY2xvc3VyZTM3ODlfZXh0ZXJucmVmX3NoaW0A/zUaY2xvc3VyZTM4MDNfZXh0ZXJucmVmX3NoaW0Amy8QX193YmluZGdlbl9zdGFydAB4CeI8AgBBAQurHvoloQGDI5gD6x3rAfsTvQHaHooG2R7hBdgeuAOEI6YGtxq3GrYathq0GrQahhqGGrUatRqzGrMatzuUNdcSmj24O7k7sivJI/sRoSnbHOor7zasNqs9iTDcO6s9yD7iNZoqhjX4O5k8uQnGLogwqTbGLsg+/CjjKJMu1wmMMIMOlTWpAZQutwmaJ8MSizCkAYowpBDXGpsB1hrVC8Im1Qy3O5Q11xK6O+sr1C/CLKEp1DSaGMkj/BG7O7c7iDerPY0wyD6yK/YuxAmWNagB9RfjAYIq0gn3LsUL9hfiAbc7lDXXErw7qjadPqMJ7Cu9O/gswSjuK787+SzAKO0rvjv6LL8ojSbrNfc61A70KP4llgG3O5Q11xLBO8I7oSm3O6s9kDDIPqsetR+VLvcMySP+EeAM6RWyK9Qt/Bi2K8EqxTvGO/Y6wDvJPswR1i32FNganAHCJtYM1hrWC7c7lDXXEsc79yvUL6Ep1DTJO/ArtzuHPdQ79iqrPZUwqzarPcg+zzvIO5Mwqz2rPZQwyD6yK4I2wwmzNr8Q2yOGI8s11C22K98K3grJC609yjvEO8M7sz3TG5Q8gCb3FKw9rz2hL48Y2RysPa49oC/dAZ0GyQfPG/8ewCqsPasP6hasPYgRiQq3O6w2kjyjJdAkgBamLfMrtzurPZkwyD6MI8cOiyPIDooj1QiII/ILiSOUCYoaihqLGosauhq6GsAVwBW7GrsatzuUNdkSyzv8LtQkySeaMK82+SrIPo0jnhD9LJswrzb9LMg+3Ry+Lqs9nTCrPdA7zjurPZwwrzarPcg+zTuzNpg1tzurPZ4wyD6rGrI2vCqCNsw7tyuiL3n6LuAfrR70K589siuWLrM2nBKCNtk7+SurPaQwsDbIPtg7+CuiML8u+iurPZ8wsDarPcg+sD37K6Ew0jv1K6Uwqz3TO/YroDCrPdY7ozCrPbgr1STaO4Q2hDa0HLc7mTXaEts7iCrqJpgo6yayK987ox+IEYoKtzusNrc7rDbhO7c7lDXZEuI71y+CKacw6Qu0NvAWtT23PYYhnT62Pdsnsj6cNoA1lCWTO806zTqBNdoq+yn/HdcMzCTXL7Ir8SWGMKw2zyvoKNkbuSt82C/QL44gjj2yPsg+rhDjI/YG0BbhI9kksDCsMLIwsTCzMKgwrjDZJKsw0CG+Nr89mzWwA541wi7DLs8hvzacNbEDnTWvMK0wpRy2NqouvT2xPqwjvjzDPJEvsj6SNvc0hyWLO646rjr4NL0sxzyvHLg2pi67PagjvTzFPM4hwDafNZsIoDWqMMEgwTbAPaE16QGiNcQuxS6pMKYcujalLr49oCPBPMY8rBy7NqkuuT20I788wjyhHLw2qC66PbAjwDzEPJUctzapLrk9myOdHLk2qC66PZ8j4R29NokUvD2xPo0hnj64PZEvkjb3NJsllzuuOq46+DS9LOw8iTWkPfc84iOgJ/0Nsh7aJNowyDC5MM0wyzC+MMMwzDC/MNUwvDDAMNgw0TDKMLYwyTC7MNcviRKLCuQ7uyueKogq4TWcPLIrmiriNbc7rDa9MIQpwTDNJtkwuS6XPsok3TDaG8kkyD7/LroEggqrPd4w1TarPcg+0y2EF6s92zDVNqs9nwSdJdwwgyvXNrU9tz2dPrY9sj7ZLcItuSbDLdQ28y3LJfQt9S35I/Yt9y3ELcUtxi34Lfkt+i37LfwtgjyBPIM8hhXgNsA9pzWIDLY1xC7FLocV4zajNf8LvjWIFd02sjWDDLM1iRXaNqU1gAy7NYoV3jaxNYQMtzWLFec2pjX8C7g1jBXZNrA1ggy1NY0V5DarNYEMtDWGFeI2rjWGDLw1hxXlNqk1hwy5NYgV4TakNf4LvTWJFd82qjX9C7o1ihXcNq81+wu1NYsV6DasNYUMtDWMFds2qDWCDLU1jRXmNq01gQy0NdAwxTDTMNQwzjDHMNIwtTC6MMIwxjDPMNYwtzDXMMQwnz7qNrE+wiqQEtAsuDDVI9Y24zvjO7M+7xugPsM9yT6yPskvxD7FPrI+7Ty3PrAq2DafFcI9tD6FIa0+iz71L64+mzb/NJUllDvLOss6gjW/LOE8pxzPNqkuuT2xPqojmhzSNqkuuT2rI8Q2uT2oHMg2qC66PZ4jlBzLNqguuj2hI8k2uj2qHM42qC66PbYjqRzMNqguuj2cI6Qc0DaoLro9uCOfHMc2qC66PacjnBzRNqkuuT2xI5YcwjaoLro9tSOTHMY2py7BPbcjqj6JPqMcyjalLr49qSOZHNM2py7BPbIjoBzNNqUuvj2mI8M2vT3FNrs9/CvJI4AS3zDrNsg+siucKp4l8BuBEv4rsivKLusVsj6qLf467BahPv4Mtj6EK+AwjhXcL8EruD6rLZguwiv9K9MSuT6aKN8pwyu3O7MvtT6oPqA+4h+rL74rvyudLOYRtz7LLq0vjA3BK9MSsS/aJawvvivBK9MSsi/ZJbsZviugEP8MqQn2C68v4x/YIqwZqQm3O+0TqD6gPswV6SiwL+QfzxGNDc0upC7BGNcvoj6mGMgovg2ePrI+5juaLusWlB2hDqQ+uj69H7UegxDcDfEUmy6SHdgNhBDdDfIUmy6QHdcN1gr0DOc7zC6RHfMMhhDWDfAUmS6THdkNhRDaDfMUmS6VHdsNoz7AEJYdsgulPrY+8x2CLbkE6AnVDac+tz6zCtQv6ifMJt4MgDu1ProrhC3yBekJ3g2mPrQKyybdDN4M3QzOLv0osiudLpwuni73O9ghtzvrKPAbgxL/K7I+yD63O6wouSvEPaEdxCvFK8crxiuALIs8+TvEPfk87zbWGdgMgD2uLuMk7zDXL/o78BuEErIr7CWGMOwouSueGukw0S7RLqUnpSekIaQhtS+1L6QnpCekJ6Qn9Cf0J7QvtC/PJs8mpSelJ9Iu0i6rIPE26TbrAv4CnhSrPfEw9TaxPqchxRDONa8psCnuNvQ2sT6mIdwBzTWtKa4p8zbYAe428jaxPqYh4QHNNa0primUFfc2yD3BNZkDxzXHLsgulRX2Nr81iBPANfw2kQGWFfo2wjWQAco1pRX5NsM1jwHGNZUV+zbFNfMCyDWWFfg2xDXyAsk18jD9Nrc97hC2Au8QqyWsJecw4jDiHe02/BTGPbE+jiGePrg9ki+yPps2/zSaJZg7yzrLOoI12iiJKOUw5DDrMK4q8DbkDcU9xz2EIcM61zyrLpo2+zSTJZE7xDrEOv402SvZKuow7jDtMOww5jDjMOgw8DCtLtY0jTyxKZ8q7yilKIk32y28Bs092S3UNr0e9jD1MIo8hC+GN4Uv7DaIPLIrhyn0MJ4e/zbkLM49sT6DIcA61TzBLbI+mTb8NJIlkjvBOsE6/TTcJu0lyhz+NuMszz2CIb861jyBN7U9tz2dPrY94RjoHqs9+DCAN8g+lTyJPKs99zCAN8g+5CO0Krc7qz35MKs9yD7dL+0V3xysPdE9vC/TAfwFhAfSG9E1yCvQPfgnjDyTFPcStha4EIUO+Q7TEbsGkBDIEuELvw2HNtoh1i65K8w1rDaoJ9cupyfYJd47qz36MMg+8CiyK98liCrcFt4t4TTgNN803jSINok2lRjiLeAt1zXYNdk12jWMNo024S3fLeU05DTjNOI0ijaLNug05zTmNOs06jTpNNs13DXdNe407TTsNPE08DTvNIgvhy/hL+Iv4y/kL+Uv5i/nL+gv6S/qL+sv7C+UPJE8vCqCNrku/TDnI9YOqz3+MIM3yD6yK5oqkzz5HZI8miq7K54qljybKpwq+BuRK6s9gjGFN8g+3juBMZc8mDybKukkqyiaPJo8mjyaPJo8mzz9As4CsAKzAZECiSzvNrc7hDHIPrIr5SXBEOI1hjCqJ94u6CW3O+M1uhGePLc74zW6EZ883y7gLuEu3jurPYUxyD7tHvwd7B6aL/sd/R3+HYos1y/XL6A82S3UNqE83CKGMY0phzGYCoo31RXVPbc9vCOrPoo+lRmyPrI+lwPEPsU+sj7uG9sgtCjcJ4s3tT23PZ0+tj3ZLdQ25DWyK4YwxRW2K9ArmBi+L74v4i7iLtcv7h6iPMQr0CvEK7kr/yPSK48g0yviFNQrkCC2K7srsivQK7ALpwvvNrMl6RKQLZAO4wukPP089iSSMZwxlTGLMZAxijGWMZcxmDGPMZExkzGTK4gxiTGbMZQxmjGdMYwxmTHdIo0xjjGLIKM34izZPbc9gSHSPNM8lBmyPpM2+TSRJY87tzq3Ovo07x/UPIogojfhLNo9gCGTN749sT7ZLdQ2syGcN9gs2z2xPvsgqz6KPug1sj6TNu4KiCWMO7c65gmVKaIs2Cu0IZs31izXPfcgyzzOPOg1vQrLCdUooizYK7UhnTfZLNY99CDJPMw86DW+CswJ0yiiLNgruCGaN9cs2D31IMo8zTzoNcAKzQnUKKIs2CuxIaE32CzbPfYg6DXvCuUJoizYK7choDfWLNc9+CDoNb8KygmiLNgrsiGeN9ks1j36IOg1oizYK7YhnzfXLNg9+SDoNaIs2CuUN7k9mTfBPY43uj2SN7k9kDe6PZY3wT2YN749kTe6PY83vT2VN7s9lze5PbIruSuyNtMr0ivDHsAxpzGhMbUx9yS8McMxvTGvMaIxxTG3MaMxrDHGMbYxuTG/MaAxnjGfMbgxszG6MbsxqzGtMaYxrjGlMaQxwjG0MbIxsDHBMfgkvjH3JLEx3iKoMaoxpTyOKcQxzSapMa83uj2xPrI+rTe9Pbo3uz28N7k9mxzEN6ouvT2kI5gctDeoLro9pSOeHLE3qC66PaMjlxypN6guuj2dI5IcqDeoLro9ryOwN7k9rje6Pb43uT2RHMM3qS65PbMjqxzCN6guuj26I60cxjepLrk9riOuHLI3qC66PaIjohy5N6guuj25I7ActzepLrk9rSO/N7o9qje6Paw3uj3BN7o92S3UNsc3xj2xPp4+uD3LN7U9tz2dPrY9yjfZPbc9yTfaPd0dpjfpLNw9sT6JIdM6xDzHLZM2+TSWJZU7tzq3Ovo0sSrnPOAdpDfnLN09iiHUOsM8sze+PcA3uT21N749qze6Pbs3wT3FN8E9vTe+Pbg3uT22N7o9zDfCPbw+yDe8PbE+nj64Pd4dpTfoLNw9hyHfHac35izdPYghxB7PMdox+STfMdUxyzHcMdIx2zHIMcoxxzHJMd0x2DHeMdMxzjHUMc0xzDHhMdkx1zHWMeAx3yLQMaY8zSbRMc033D2xPrI+uiz2N6AUqTzON909uyyoPOY32j23Pbc75TXcEu481De6PbE+2Te5Pd83uT3bN8E93De+Pdc3uj3QN7o92je6Pdg3uT3iN7k94Te6PdY3vj3lN7k95DfBPdM3uT3SN7o93je6PeA3uj3PN7o90Te6PeM3vT3dN7k91Te6Pec3wj29PrIr0iu5K9Mr7zaBDfok6THvMesx5DHnMeMx4jHsMe0x7jHmMegx5THqMac86Te9PbE+sj7wN7s98je5Pes3uj3tN7498ze+Peo3uj3vN7k96De6Pew3uT31N8E98TfBPe43uj30N7k9+QaRLeMu0yuSJ/o86C3MGcI05y3yNZMv5jX3BtArnDzZLdQ21y+qPLssuiyPJrkr0yv/PK8qsiWyJdom2ibZJtkm2SbZJsEvwS/CL8Ivwy/DL8QvxC/BL8Ev2ibaJsMvwy/CL8Iv5C7kLtML0wvAL8Avwi/CL8AvwC/DL8MvwC/AL/sk8THFHvAx8jGrPPk3zz2xPrI++DfOPfc3xj2xPp4+uD3ZLdQ2rzzfPOMU7za3O+U13BKuPIgRjwqsNqMa8zHZLdQ2/TfFPcc9sj78N5Imuye+J7MnoSapPpEmxh6UJpcmtyemJp8mmCOvJ8cemSa6J7AnoiaeJpojuSeYJpAmrie4J78nqSakJrUnqyaoJtEqnSa9J6w8lyOjJsQksSeZI60nmiaVJvs3rCaXJpwmshmgJrwnmyaWJqUmqia0J7InmianJpMmtifIHvcxiTL1MaUy/iSCMqIy/DH4MZYyizKRMqMymzKrMooy/jGFMvkxgDL/MacyjDL2MZgynTKTMpQy9DGIMpcylTKkMpAyqjKNMoQy/ySaMpwrpjKpMqEyjzL6MY4ymTKcMv4koDLyIv0xrDLJHpIyhjKwPM8jqDLzIoEykCmHMs0mnzKtJp4ygzL7MZ44wT2xPrI+kTi+PZQ4uT2IOLo9kjjBPZc4vj2LOLk9mzi6PZU4vj2gOLk9nTi6PYw4uj2cOLo9mTi6PZA4uj2fOLk9gji6PY04vT2TOLk9jzi6PYY4vT2KOLs9szjCPb4+hDi6PY44uj2FOLo9gzi6PZg4uT2HOLo9iTi5PZo4uT2WOLo9oTi6Pf833D2xPqs4vD2xPp4+uD2BON09rDjZPbc9gDjcPf433T2tONo9rzjOPaI4xj2xPp4+uD2uOM89sji1Pbc9nT62PbE41T23PbI+2S3UNqg42z2xPqY41z2pONY9pzjYPaQ42z2qONc9pTjWPaM42D2wOMU9xz2MH7Y42izgPbE+/CCdPrY96TWsPrMIxD7FPrI+6xuNLI4soiuNH7Q42yzhPf4gsgjtG44ftTjcLOI9/SCxCOwbniqaKoAlrTKxPNkt1Da3OLk9sT6yPpw7yh6xMsIyrzLcMoEluzLZMrYysjLPMsQyyjLaMtMy4TLDMrgyvjKzMroyuTLeMsUysDLRMtUyzDLNMq4ywTLQMs4y2zLJMuAyxjK9Mp0r3TLfMtgyyDK0Mscy0jLUMvQitzLiMsseyzK/MtcvtzvlNdwSsjyzPJEpwDLNJtcyrybWMrwytTLkONk9tz2yPuU42j3jONc9sT7cONg94TjbPd042z3iONY93jjWPd841z3gONg95jjPPbE+5zjOPcA4vT2xPtE4vj3VOLo9wji6PdQ4uT3KOLo9zDjBPdo4uT3JOLo91ji6Pc84vj29OLo92Ti5PcM4uT3HOL09xTi5PdA4uj3BOLo9zji5Pb84uj3TOLo9xDi7Pb44uj3GOLo92zi6PdI4uT28OLo9zTi5Pdg4wT3XOLo9yDi6Pcs4vj3pOMI9vz65ONw9sT66ONw9uzjdPbg43T3oOLU9tz2dPrY96jjhPbE+sj7rOOI97DjgPdkt1DbMHuYy9zLkMpEzgiXxMo4z6zLnMoMz+TL/Mo8zhzOWM/gy7TL0Mugy7zLuMpMz+jLlMoUziTOAM4Ez4zL2MoQzgjOQM/4ylTP7MvMyniuSM5QzjTP9Muky/DKGM4gzgiWMM/Ui7DKXM7U89iLwMpIp9TLNJoszsCaKM/Iy6jKNOcE9sT6yPoA5vj2DObk99zi6PYE5wT2GOb49+ji5PYo5uj2EOb49jzm5PYw5uj37OLo9izm6PYg5uj3/OLo9jjm5PfE4uj38OL09gjm5Pf44uj31OL09+Ti7PZ45wj3APvM4uj39OLo99Di6PfI4uj2HObk99ji6Pfg4uT2JObk9hTm6PZA5uj3uONw9sT6ZObw9sT6ePrg98DjdPZo52T23Pe843D3tON09mznaPZ05tT23PZ0+tj2cOdU9tz2yPpY52z2xPpQ51z2XOdY9lTnYPZI52z2YOdc9kznWPZE52D2hOeA9sT6fOeE9oDniPeUs1iq0PLQ87T35Kek97D3JPus96j25PLo8uzzkPeY95T3oPec92S3UNrUltjzDEcURwhHEEc0emzOpM5kzwDODJaQzvTOfM5wztTOrM7EzvjO5M8UzqjOhM6YznTOjM6IzwjOsM5oztzO7M7IzszOYM6gztjO0M78zsDPEM60zpTOfK8EzwzO8M68znjOuM7gzujP3IqAzxjOTKacz2S3UNqk5uj2xPrI+uDm5Pac5uj28Obk9uzm+PbU5vj26Obo9rTm5PbI5uj2zObo9sDm6PbY5wT3BObo9qDm6Pb45uT23Obk9uTm+Paw5uj2uObs9wDm6PcM5uT2/Obo9wjnBPb05uj3FObo9rzm5PcQ5uT2rObo9sTm9PbQ5uj2mObo9qjm9PaM53D2xPqI53T2kOdw9pTndPc051z2xPso52D3LOds9xjnYPcc52z3MOdY9yTnXPcg51j3POdo9tz3OOdk90Dm1Pbc9nT62Pbc8uDy8PIgRkAq3O6w2nyqbKsU07za5K80m2TPOHuAz1jPfM8kzoCv9M4I07jPrM9cz/zPoM/szhCX8Ofk9sT6yPv459z36Ofk9+DnxPeU59z2BOvA9+znxPe458D2EJYA0hSXzM88e2zPjM9Ej/jP2M80z6TP0M9ozzjPcM9Ez/DP5M+YzzzPIM+8z2DP3M8wz4jPwM+Ez9TPHM+oz8TPKM9Az5TP4M+wz5DPtM+cz3TPSKIE0sCHTM7Im3jPSM/oz+CLyM8szyRnUM9Uz5DnjO8M+oD7DPck+sj7SOfw9wj70Ofk98DnxPek58D2AOvA99TnwPew58D32OfA9hDrxPfE58D2COvE97znxPfI58D2DOvA96jnwPe058D3mOfA9/znwPes58T33OfA9+Tn+PdU57j2xPt857z2xPp4+uD3WOfQ9izr/Pbc91DnuPdM59D2KOoM+4jmEPqMejTqDEYc+sT6MIeg86jyjLJ02gzWXJZY71zrXOoQ1miTUI+A5gj6xPp4+uD3hOfI9zByMOoQRgD6LIek86zyFOvg9tz2dPrY9hjqIPrc91zmFPrE+3TnzPds59T3YOfs93jmFPtw58z3ZOfU92jn7Pec58T3oOfA9/Tn+PfM5hj7jOfY9xz2JOoE+sT6IOv09hzr6PYYlhzSWNJ00jTSINI40izSiNKE0lDSJNIQ0mjSMNJ80hjSRNJs0kDSeNIM0lzScNIU0ijSTNKA0mDSSNJk0lTSPNJA68T2xPrI+njrwPag68D2XOvA9kTrwPZ06+T2qOvA9mzrwPZM68D2iOv49jzrwPaM6+T2fOvA9nDqGPqU6+T2hOvE9pDrxPaY6/j2YOvE9rTrxPZY68D2gOvA9mTrxPac69z2rOvE9lDrxPZI68D2pOvA9jjr3PZU68D2sOvA9mjrwPcg8yRyoNKo0pjSlNKM0qTSkNKc0szr1PbE+sDr7PbY6hT61OvM9tDrzPbI6+z2xOvU9rzqFPsc6xTrIOpQ2lTbJOs88tCasNKs0rTS6OoE+sT6yPrg6+j25Ov091B+3O+U13BLQPNML0wv5IrE0sDS7OoM+tz2yPrw6/z2IEZEKtzusNtAesjSzNL068j2xPrI+vjqEPtIjtDTCOvY9xz3GOuA8iBGSCrc7rDbNJrU0yjr8PcY+2Ci2NMw6+D23PZ0+tj2yPtco3TziPNcvuSG3NM46iD63PbI+iBGTCrc7rDbRHr00uzS8NLg00DruPbE+sj7POvQ90TruPdI69D3LGbk0ujTVOoA+sT7WOoc+iBGUCrc7rDaZJcA02DrvPbE+nj64PZglvjTZOoI+sT6ePrg9vzTaOuM7xz6gPsM9yT6yPuo1wRLeO+w1xhH6Bus1kCyIEZUKtzusNuYu6C3nLe010CuUPMs+6B2+I7shuiG8IYsWhB2MFr0hnCSyKtsr3Cu+IawK3RTxPIgRlgq3O6w2siubO/UUyj7KPpo7xRLbOq0PmTuZO/AlkSfeJpkZmRmYGZgZmRmZGZYZlhmXGZcZmhmaGZgZmBnmGeYZ3TrqENw66RDdOuoQ3zqFEd466xDcOukQ3jrrEN86hRHlFbIriBeIF7wYvBilLI0TpiyOE+E6wA7gOr8O8zzQJdElzD7MPrYotijIFcgV4jrDCqcs1wHwPPY88jzuNe825y7oLect7zXQK4Ua6C7oLect8DXQK947rDbPDPsGxD3TK6ARgT3+PO823juzKrIr4TWUPN478TXIEYI9+DzjOsQ0+zyKNfw86S7oLect8zXQK947rDbSDPwGxD3TK+ou6C3nLeYM0CuLNcY03jvxNcgRgz3gJsc0yD6CGYQ9tzuIN4U91C+IPYk9jD22HLIrjT2yPsg+2CP0JekZti7fK50kyCeaGuArxynoOuk6oDuPPsgpwBj0FqE7kD63K8stnySAI6Ak/yLrLo4o7xOvFn2WL8QswSO5KJkpvCr2NeQOyjTLNMw0zTR70i+XL+4u7y7wLu4u7y7uLu0u7C6EJLgueu828RfeO/o1yhHoFqYa0y+bPZUs7zazNsEhnDzDI8EmpBGcPfwv+i+ePfsvlyfLEZ09uSvyLqw2sjb5L880zjTxOp4p8DrXO/Eu6h3WEvIXqz2ZL/YlmC/7L+Qn+hGgPaE9oj3TEMUspj2lPYI28jrzOuMroxvTHPw1tDuqPcwKjyinPeIowhKoPQBBrB4LAv81my8MApwqCom5zALPPcD5AgQffwd+AX0BfCMAQZAEayIFJAAgBSADNgKsAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAABBAmsOJQECAwQFBgcICQoLDA0ODxAAABYRFwAYGQAAAAAAAAAAABITFBUACyAFQQE2ArQBIAVBnLH/ADYCsAEgBUIBNwK8ASAFQa8DNgLUAiAFIAVB0AJqNgK4ASAFIAVBrAFqNgLQAiAFQcADaiAFQbABahCZDiAAQYKAgIB4NgIAIAAgBSkCwAM3AgQgAEEMaiAFQcgDaigCADYCAAwxCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgR4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNLyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NNyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCjKAsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAUgBUGwAWogCCACEIcLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTwgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0zIAVBiANqELsjDDMLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwtCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgx4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNKyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NNyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTsgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0yIAVBiANqELsjDDILIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwrCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQih4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNKSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NNyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBGGogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTkgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0wIAVBiANqELsjDDALIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwnCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNJSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCCACEIYLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTggBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0vIAVBiANqELsjDC8LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwlCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNIyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NMyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBMGogBUGwAWogCCACEIoLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0tIAVBiANqELsjDC0LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwhCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNHyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMCAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCCACEIILDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTUgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0sIAVBiANqELsjDCwLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwfCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiD0UNHSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NMCAFIAooAhAgA0ECdGoqAgAiKzgC0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCrDCEkIAUoArABIgRBCGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAHICR6p0EDdiACaiAIcSIMQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogKzgCACAFIAFBAWo2AowCIAVByABqIAVBsAFqICsgAhCMCwwBCyAEQQAgDGtBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY7AQQgAEGQgICAeDYCACAOELItIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPMeIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCABE8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNMyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSogBUGIA2oQuyMMKgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDBsLIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCULIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN4JDCQLIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCMLIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN4JDCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCELIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgYgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMIQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwVCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPMeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNEyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAVBwANqIQ0gBSgCWCETIAUoAlwhDyMAQTBrIgQkAAJAIA8gBUGwAWoiAigCMEYEQCMAQUBqIgYkACAGIA82AgQgBiATNgIAIAIgEyAPEM0CISQgBiACQTBqIgE2AjwgBiACQegAaiIYNgI4IAYgBjYCNCAGIAE2AhAgBiAYNgIMIAYgAjYCCCAGQRhqIQwgBkE0aiEQIAZBCGoiHyEBQQAhC0EAIRFBACEUQQAhGUEAIRojAEEgayIOJAAgAkEgaiIKKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAKKAIMIghBAWoiCSAITwRAAkAgCigCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAJSQRAAkACQCAIQQFqIgsgCSAJIAtJGyILQQ9PBEAgC0H/////AUsNAUF/IAtBA3RBB25BAWtndkEBaiELDAILQQRBCEEQIAtBCEkbIAtBBEkbIQsMAQsQ3ScgASgCHCELIAEoAhgiCUGBgICAeEcNBAsgAUHQAGogCkEQaiIHQQQgCxD7FCABKAJYIQsgASgCVCEJIAEoAlAiCEUNAyABIAEoAlw2AkwgASALNgJIIAEgCTYCRCABIAg2AkAgAUEQaiABQUBrEME0IAEoAhQiCwRAIAEoAhBB/wEgC/wLAAsgASgCSCELIAEoAkQhCSABKAJAIghFDQMgASABKAJMNgI8IAEgCzYCOCABIAk2AjQgASAINgIwIAFChICAgIABNwIoIAEgBzYCJCABQTBqISAgASAKKAIMIhwEfyAIQQhqISEgCigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgEUEIaiERIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIHKAIAIRUgAUEIaiAHKAIEIAcoAggoAgAgCigCACAleqdBA3YgEWpBAnQiImtBBGsoAgAQyiUgCCAJIBUgASgCCCABKAIMEM0CpyIjcSIHaikAAEKAgYKEiJCgwIB/gyImUARAQQghFQNAIAcgFWohByAVQQhqIRUgCCAHIAlxIgdqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCCAmeqdBA3YgB2ogCXEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiAjQRl2IhU6AAAgISAHQQhrIAlxaiAVOgAAIAggB0ECdGtBBGsgCigCACAia0EEaygAADYAACAcQQFrIhwNAAsgCigCDAVBAAsiCTYCPCABIAsgCWs2AjggCiAgQQQQ+iogAUEkahD1JwwBCyAKIAFBIGpB0OCAARDuCQtBgYCAgHghCQwBCxDdJyABKAIEIQsgASgCACEJCyAbIAs2AgQgGyAJNgIAIAFB4ABqJAALIAooAgQiCyAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEHIBAoAgQhESAQKAIAIQggCigCACEJA0ACQCABIAlqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIAwCfgJAA0AgJVANASAOIBEgBygCACAKKAIAICV6p0EDdiABaiALcSIVQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCCgCACAIKAIEIA4oAgAgDigCBBCfO0UNAAsgDCAkNwMIIAwgCigCAEEAIBVrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIAtxIRQLQQEgJSAmQgGGg1ANAhogDCAJIBRqLAAAQQBOBH8gCSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAUCzYCECAMICQ3AwhCAQs3AwAgDCAKNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiALcSEBDAELCyAGIA82AjwgBiATNgI4IAYgGDYCNCAfIAwgEBCLEyAGKAIQQQRrKAIAIQEgBkGQgICAeDYCGCAEQQRqIgogAUH//wNNBH8gDBCIEUGTgICAeAVBkICAgHgLNgIAIAogATsBBCAGQUBrJAAgBC8BCCEGIAQoAgQiAUGTgICAeEcEQCANIAQpAQo3AQYgDUEMaiAEQRBqKQEANwEAIA0gBjsBBCANIAE2AgAMAgsCQCACKAJABEAgAigCUCILQQFqIglBA3YgCUEHcUEAR2oiASACKAJMIgpLBEAgASAKayEOIAIoAkQiCCABSQRAIAJBQGsgCEEBdCIKIAFBwP///wNxQUBrIAEgAUE/cRsiCCAIIApJGxDoGSACKAJMIQoLIA4EQCACKAJIIApqQQAgDvwLAAsgAiABNgJMCyACIAk2AlAgAigCSCALQQN2aiIBIAEtAABBASALQQdxdHI6AAAMAQsgAiACKAJUQQFqNgJUCyACKAI8IgEgAigCNEYEQCACQTRqQci1gAEQrSgLIAIoAjggAUEBdGogBjsBACANIAY7AQQgDUGTgICAeDYCACACIAFBAWo2AjwMAQsgBCAPNgIcIARBAjYCCCAEQaC3gAE2AgQgBEICNwIQIARBOzYCLCAEQZwDNgIkIAQgAkEwajYCICAEIARBIGo2AgwgBCAEQRxqNgIoIA1BBGogBEEEahCZDiANQY2AgIB4NgIACyAEQTBqJAAgBSgCwAMiAUGTgICAeEYNASAAIAUpAcYDNwEGIABBDGogBUHMA2opAQA3AQAgACAFLwHEAzsBBCAAIAE2AgAgBUHQAWoQjjsgFxCyLSAFQZgCahCKLwwXCyAWEOY6IAUoAvABRQ0qIAUoAoACQQFqIgJBA3YgAkEHcUEAR2oiASAFKAL8ASIESwRAIAEgBGshBiAFKAL0ASIKIAFJBEAgFiAKQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIKIAQgCksbEOgZIAUoAvwBIQQLIAYEQCAFKAL4ASAEakEAIAb8CwALIAUgATYC/AELIAUgAjYCgAIgBSgC7AEiASAFKALkAUYEQCAXQYCd/wAQrSgLIAUoAugBIAFBAXRqQQA7AQAgBSABQQFqNgLsAQsgHiADQQFqIgNHDQALDBMLIAMtAAIhEiADLQABIRMgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDBILIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIgeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPMeIAFBxABqIAMQnx4gAUH4AGpBpLWAARClKyABKQOAASEmIAEpA3ghJwJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISVBACEDDAILIAEpAoABISUgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCElIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJjcDGCACICc3AxAgAiAlNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhBFDRAgBUHcAWohCSAFQdABaiEOIAVBkAJqIREgBUGEAmohDSAFQcABaiEUQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDSggBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBQgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiFSAESQRAIBEgFUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFSABIBVLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQfAAaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCABE8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf//A3EhAkGQgICAeCEBIANBAUcNFSAFQYgDahC7IwwVCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgEEcNAAsMEAsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMDwsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjR4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxChHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiE0UNDSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NKCAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgESAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBgAFqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0rIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBDzHiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0qIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0QtS0gBUGwAWpBIEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0PIAVBiANqELsjDA8LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwKCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwJCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCAHiIKQQxqIgsQ3DwhBCALENw8IQMjAEGQAWsiASQAIAFBEGogBBDzHiABQcQAaiADEKIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEwQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDcPCITRQ0HIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDcPCADTQ0MIAooAhAgA0EFdGoiASkDACEkIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICQ3A8ADAkACQAJAIAUoArwBRQ0AIBEgBUHAA2oQrQwhJSAFKAKwASIEQTBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEBA0AgAiAEaikAACIpICqFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVBwANqQSAgByAleqdBA3YgAmogCHFBUGwiDGpBIBCfOw0EICVCAX0gJYMiJVBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiBCAFKAKEAkYEQCANELIoCyAFKAKIAiAEQQV0aiIBICg3AxggASAnNwMQIAEgJjcDCCABICQ3AwAgBSAEQQFqNgKMAiAFQaABaiAFQbABaiAkICYgJyAoIAIQlwoMAQsgBCAMakEQaygCACECCyAFQZCAgIB4NgLQAiACQYCABE8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCyLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf//A3EhAkGQgICAeCEBIANBAUcNDCAFQYgDahC7IwwMCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMBwsgASACKAIcEQQAQdSw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZSo0KABNgIAIANClKjQoMGChYoUNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIEKQnrPu2bSNkukAhSADKQMoQoj0q4HgscXkwgCFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhASADKAIgQQFGDSYgAygCKCICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQSBqIAIQ0zoQ8ykgAhDTOiIOBEAgA0HcAGohCiADQdAAaiELQQAhBANAAkAgAiAEEJYlRQRAIANBCGogAiAEEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQ1w8gAygCuAEiBkGTgICAeEYNASAAIAMpAb4BNwEGIABBDGogA0HEAWopAQA3AQAgACADLwG8ATsBBCAAIAY2AgAgARCOOyALELItIANBhAFqELosDAQLIAoQ5jogAygCXEUNKSADKAJsQQFqIglBA3YgCUEHcUEAR2oiASADKAJoIgZLBEAgASAGayENIAMoAmAiCCABSQRAIAogCEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiCCAGIAhLGxDoGSADKAJoIQYLIA0EQCADKAJkIAZqQQAgDfwLAAsgAyABNgJoCyADIAk2AmwgAygCWCIBIAMoAlBGBEAgC0GAnf8AEK0oCyADKAJUIAFBAXRqQQA7AQAgAyABQQFqNgJYCyAOIARBAWoiBEcNAAsLIANBuAFqIgIgA0EgaiIEEOIRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCyLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCcLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMHAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEPMpIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0nIAMoAsgBIgJBvrX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NLCADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIAMoAsABIAEQrB8gA0GsAWogA0EQaiADKAIAIAMoAgQQ1w8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJyADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEOIRQdAAQQQQrTYiAUUNJSABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuiwgA0GQAmokAAwbCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlqzYsAE2AgAgA0KWrNiw4cKFixY3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQsKM9/bqy9zRhH+FIAMpAyhC5ZP0mPmv+Oiof4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJSADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDUOhDwKSACENQ6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ8hYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDbDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuywMBAsgChDmOiADKAJcRQ0oIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ2xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJgsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwbCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSYgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0rIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDbDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0mIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ2xFB0ABBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC7LCADQZACaiQADBoLIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGYsODAATYCACADQpiw4MCBg4aMGDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCx9n0597Etpx3hSADKQMoQo2yzpSMypLmp3+FhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhASADKAIgQQFGDSQgAygCKCICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQSBqIAIQ0zoQ8ykgAhDTOiIOBEAgA0HcAGohCiADQdAAaiELQQAhBANAAkAgAiAEEJYlRQRAIANBCGogAiAEEP8WIANBuAFqIANBIGoiASADKAIIIAMoAgwQ3g8gAygCuAEiBkGTgICAeEYNASAAIAMpAb4BNwEGIABBDGogA0HEAWopAQA3AQAgACADLwG8ATsBBCAAIAY2AgAgARCOOyALELItIANBhAFqELosDAQLIAoQ5jogAygCXEUNJyADKAJsQQFqIglBA3YgCUEHcUEAR2oiASADKAJoIgZLBEAgASAGayENIAMoAmAiCCABSQRAIAogCEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiCCAGIAhLGxDoGSADKAJoIQYLIA0EQCADKAJkIAZqQQAgDfwLAAsgAyABNgJoCyADIAk2AmwgAygCWCIBIAMoAlBGBEAgC0GAnf8AEK0oCyADKAJUIAFBAXRqQQA7AQAgAyABQQFqNgJYCyAOIARBAWoiBEcNAAsLIANBuAFqIgIgA0EgaiIEENQRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCyLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCULIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGgsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEPMpIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCq5iR8ZX61fyAf4UgAykDyAFClpT4q/Cx6bPhAIWEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJSADKALIASICQZC1/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSogAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADQcABaiABEK0qIANBrAFqIANBEGogAygCACADKAIEEN4PIAMoAqwBIgFBk4CAgHhGDQEgACADKQGyATcBBiAAQQxqIANBuAFqKQEANwEAIAAgAy8BsAE7AQQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSUgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCtKAsgAygCRCABQQF0akEAOwEAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDUEUHQAEEEEK02IgFFDSMgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELItIANB9ABqELosIANBkAJqJAAMGQsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZmy5MgBNgIAIANCmbLkyJGjxowZNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELT2NP4/eb2kkiFIAMpAyhCotieiOGg6unMAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNIyADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDUOhDwKSACENQ6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDaDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuywMBAsgChDmOiADKAJcRQ0mIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ3BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwZCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0kIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKSADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2g8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJCADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENwRQdAAQQQQrTYiAUUNIiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuywgA0GQAmokAAwYCyABIAUoArgBQdCg/wAQ/S8ACyAFIAoQ/zs2AqADDBsLIAUgChCAPDYCoAMMGgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2hQgAUE0aiIJIAJBIGoQzxQCQEEMQQQQrTYiAwRAIANCh46cuPDgwYMHNwIAIANBCGpBh46cODYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDSIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNIyACIApBMPwKAAAgBCACEIY+IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ8IIAFBkANqJAAMAQsMIQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQti0gC0EwQRAQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfim/wA2AswCIAUgATYCyAIgBUGYAWogBUHIAmoQlCsQ3yECQAJAIAUoApgBIgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUH0tP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAKcARCAFSAFQbABaiACIBIgDxCjEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFyAFQcgCahC7IwwXCyAFQc8DaiIEIAVBwAFqIgYpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIKIAVB0AFqKQIANwMAIAVBmANqIgsgBUHYAWopAgA3AwAgBUGoA2oiCSACKQMANwMAIAVBrwNqIg0gBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRwgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogCSkDADcAACABQRhqIA0pAAA3AAAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACAFQbABaiAEIAFB1LL/ABDzCSAFLQD0ASIDQQJGBEAgBUHQA2ogBigCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFyAFQcgCahC7IwwXCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0WIAVByAJqELsjDBYLDB4LDB0LIAAgJDcCDCAAIAM2AgggACACNgIEIAAgATYCAAwTCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDTFCABQTRqIgkgAkEgahDPFAJAQQxBBBCtNiIDBEAgA0KHjpy48ODBgwc3AgAgA0EIakGHjpw4NgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNICAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPk9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0hIAIgCkEw/AoAACAEIAIQ/j0gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQnwggAUGQA2okAAwBCwwfCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCyLSAFQYQCahC1LSALQSBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB+Kb/ADYCzAIgBSABNgLIAiAFQYgBaiAFQcgCahCUKxDdIQJAAkAgBSgCiAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQYi1/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAowBEIAVIAVBsAFqIAIgEiAPEKETIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0VIAVByAJqELsjDBULIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUH8sf8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0VIAVByAJqELsjDBULIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRQgBUHIAmoQuyMMFAsMHAsMGwsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBELIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENIUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0eIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDR8gAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDB0LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELQtIAtBEEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUH4pv8ANgLMAiAFIAE2AsgCIAVB+ABqIAVByAJqEJQrEOIhAkACQCAFKAJ4IgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUHgtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJ8EIAVIAVBsAFqIAIgEiAPEKITIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUGksf8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADA8LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENcUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0cIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDR0gAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBsLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELMtIAtBCEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUH4pv8ANgLMAiAFIAE2AsgCIAVB6ABqIAVByAJqEJQrEN4hAkACQCAFKAJoIgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUGQtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJsEIAVIAVBsAFqIAIgEyASEKATIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUGss/8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsMGAsMFwsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADA0LIAVBwANqIQQjAEGQA2siASQAIAVBsAFqIgJBIGoQlzYgAUEIaiIKIAJB6ABqEMcUIAFBQGsiBiACQTRqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAigCMCELQQxBBBCtNiICRQ0aIAIgCzYCBCACQRU6AAAgASACNgJ4IAEgAzYCdCABQSI6AHAgAUHYAWoiAyAGEPk9IAFBtAJqIgIgAxChGyADIAIgAUHwAGoQjBhBxABBBBCtNiIGRQ0bIAYgChDvPSABQQE2ArwCIAEgBjYCuAIgAUEBNgK0AiABQfwAaiIGIAMgAhD8IiACIAYQzRwgBCACEJ8IIAFBkANqJAAMAQsMGQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCOOyAFQeQBahCyLSAFQZgCahCKLyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQ0gBUHQAmoQuyMMDQsMFQsgBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVB0AJqELsjDAsLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENgUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0YIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRkgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBcLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVBiANqELsjDAsLDBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM0UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0XIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRggAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENUUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0WIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRcgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBULQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0JIAVBiANqELsjDAkLDBELIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENkUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0VIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRYgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBQLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAVBiANqELsjDAgLDBALIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENQUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0UIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRUgAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM8UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0TIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRQgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBILQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAVBiANqELsjDAYLDA4LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENEUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0SIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRMgAiAKQTD8CgAAIAQgAhD3PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBELQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAVBiANqELsjDAULDA0LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENsUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0RIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRIgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENAUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0QIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDREgAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA8LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0DIAVBiANqELsjDAMLDAsLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM4UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0PIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRAgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA4LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAVBiANqELsjDAILDAoLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENYUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0OIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDQ8gAiAKQTD8CgAAIAQgAhD3PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELItIAVBhAJqELEtIAtBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgChCjPDYCoAMMAwsgBSAKEP47NgKgAwwCCyAFIAoQ/Ds2AqADDAELIAUgChD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgASADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAEgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQALwPkCBB9/B34BfQF8IwBBkARrIgUkACAFIAM2AqwBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADDELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwxCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCBHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0vIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw03IAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKMoCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBSAFQbABaiAIIAIQhwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTQgBUGIA2oQuyMMNAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwwCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCOHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0tIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ03IAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEIaiAFQbABaiAIIAIQgwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTIgBUGIA2oQuyMMMgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCsLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwuCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCKHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPgeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0pIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ03IAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUEYaiAFQbABaiAkIAIQiwsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTEgBUGIA2oQuyMMMQsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCkLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwtCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCLHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0nIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw0zIAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKkZCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBUEgaiAFQbABaiAIIAIQiQsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS8gBUGIA2oQuyMMLwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCULIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwrCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCMHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0jIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0zIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEwaiAFQbABaiAIIAIQigsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS4gBUGIA2oQuyMMLgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCMLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCHHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0hIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0zIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUE4aiAFQbABaiAkIAIQhQsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSwgBUGIA2oQuyMMLAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDB8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwoCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCEHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIPRQ0dIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0wIAUgCigCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKsMISQgBSgCsAEiBEEIayEHIAUoArQBIgggJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAcgJHqnQQN2IAJqIAhxIgxBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiArOAIAIAUgAUEBajYCjAIgBUHIAGogBUGwAWogKyACEIwLDAELIARBACAMa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0rIAVBiANqELsjDCsLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwdCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgh4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ9R4gAUHEAGogAxD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNGyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMCAFIAooAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCEkIAUoArABIgRBEGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAHICR6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogLDkDACAFIAFBAWo2AowCIAVB0ABqIAVBsAFqICwgAhCECwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgIACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY7AQQgAEGQgICAeDYCACAOELItIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ9R4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakHw34ABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf//AU0EfyAMEIgRQZOAgIB4BUGQgICAeAs2AgAgCiABOwEEIAZBQGskACAELwEIIQYgBCgCBCIBQZOAgIB4RwRAIA0gBCkBCjcBBiANQQxqIARBEGopAQA3AQAgDSAGOwEEIA0gATYCAAwCCwJAIAIoAkAEQCACKAJQIgtBAWoiCUEDdiAJQQdxQQBHaiIBIAIoAkwiCksEQCABIAprIQ4gAigCRCIIIAFJBEAgAkFAayAIQQF0IgogAUHA////A3FBQGsgASABQT9xGyIIIAggCkkbEOgZIAIoAkwhCgsgDgRAIAIoAkggCmpBACAO/AsACyACIAE2AkwLIAIgCTYCUCACKAJIIAtBA3ZqIgEgAS0AAEEBIAtBB3F0cjoAAAwBCyACIAIoAlRBAWo2AlQLIAIoAjwiASACKAI0RgRAIAJBNGpByLWAARCtKAsgAigCOCABQQF0aiAGOwEAIA0gBjsBBCANQZOAgIB4NgIAIAIgAUEBajYCPAwBCyAEIA82AhwgBEECNgIIIARBoLeAATYCBCAEQgI3AhAgBEE7NgIsIARBnAM2AiQgBCACQTBqNgIgIAQgBEEgajYCDCAEIARBHGo2AiggDUEEaiAEQQRqEJkOIA1BjYCAgHg2AgALIARBMGokACAFKALAAyIBQZOAgIB4Rg0BIAAgBSkBxgM3AQYgAEEMaiAFQcwDaikBADcBACAAIAUvAcQDOwEEIAAgATYCACAFQdABahCOOyAXELItIAVBmAJqEIovDBcLIBYQ5jogBSgC8AFFDSogBSgCgAJBAWoiAkEDdiACQQdxQQBHaiIBIAUoAvwBIgRLBEAgASAEayEGIAUoAvQBIgogAUkEQCAWIApBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgogBCAKSxsQ6BkgBSgC/AEhBAsgBgRAIAUoAvgBIARqQQAgBvwLAAsgBSABNgL8AQsgBSACNgKAAiAFKALsASIBIAUoAuQBRgRAIBdBgJ3/ABCtKAsgBSgC6AEgAUEBdGpBADsBACAFIAFBAWo2AuwBCyAeIANBAWoiA0cNAAsMEwsgAy0AAiESIAMtAAEhEyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMEgsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ9R4gAUHEAGogAxCfHiABQfgAakGktYABEKUrIAEpA4ABISYgASkDeCEnAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJUEAIQMMAgsgASkCgAEhJSAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISUgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAmNwMYIAIgJzcDECACICU3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEEUNECAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohESAFQYQCaiENIAVBwAFqIRRBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NKCAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgFCAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIVIARJBEAgESAVQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIVIAEgFUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVB8ABqIAVBsAFqIAggAhCICwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgIACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0sIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSsgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH//wNxIQJBkICAgHghASADQQFHDRIgBUGIA2oQuyMMEgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBNHDQALDA0LIAMtAAIhDyADLQABIRIgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDAwLIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIYeIgpBDGoiCxDaPCEEIAsQ2jwhAyMAQZABayIBJAAgAUEQaiAEEPUeIAFBxABqIAMQoB4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQSBBEAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENo8IhNFDQogBUHcAWohCSAFQdABaiEOIAVBkAJqIRAgBUGEAmohDSAFQcABaiERQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENo8IANNDQwgCigCECADQQR0aiIBKQMAISQgBSABKQMIIiY3A9gCIAUgJDcD0AICQAJAAkAgBSgCvAFFDQAgESAFQdACahCwDCElIAUoArABIgRBIGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hKEEAIQEDQCACIARqKQAAIicgKIUiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBECAHICV6p0EDdiACaiAIcSIMQQV0a0EQEJ87DQQgJUIBfSAlgyIlUEUNAAsLICcgJ0IBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCxKAsgBSgCiAIgAUEEdGoiBCAmNwMIIAQgJDcDACAFIAFBAWo2AowCIAVBkAFqIAVBsAFqICQgJiACENQKDAELIARBACAMa0EFdGpBEGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4Qsi0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH//wNxIQJBkICAgHghASADQQFHDQ8gBUGIA2oQuyMMDwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBNHDQALDAoLIAMtAAIhDyADLQABIRIgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDAkLIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIAeIgpBDGoiCxDcPCEEIAsQ3DwhAyMAQZABayIBJAAgAUEQaiAEEPUeIAFBxABqIAMQoh4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQTBBEAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENw8IhNFDQcgBUHcAWohCSAFQdABaiEOIAVBkAJqIRAgBUGEAmohDSAFQcABaiERQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENw8IANNDQwgCigCECADQQV0aiIBKQMAISQgASkDCCEmIAEpAxAhJyAFIAEpAxgiKDcD2AMgBSAnNwPQAyAFICY3A8gDIAUgJDcDwAMCQAJAAkAgBSgCvAFFDQAgESAFQcADahCtDCElIAUoArABIgRBMGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hKkEAIQEDQCACIARqKQAAIikgKoUiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHAA2pBICAHICV6p0EDdiACaiAIcUFQbCIMakEgEJ87DQQgJUIBfSAlgyIlUEUNAAsLICkgKUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIEIAUoAoQCRgRAIA0QsigLIAUoAogCIARBBXRqIgEgKDcDGCABICc3AxAgASAmNwMIIAEgJDcDACAFIARBAWo2AowCIAVBoAFqIAVBsAFqICQgJiAnICggAhCXCgwBCyAEIAxqQRBrKAIAIQILIAVBkICAgHg2AtACIAJBgIACTw0BIAVB0AJqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0pIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0Qti0gBUGwAWpBMEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCJJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBDWDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmhFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiSUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDWDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmhFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EJAlIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMENIPIAMoArgBIgZBk4CAgHhGDQEgACADKQG+ATcBBiAAQQxqIANBxAFqKQEANwEAIAAgAy8BvAE7AQQgACAGNgIAIAEQjjsgCxCyLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCtKAsgAygCVCABQQF0akEAOwEAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCZEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsi0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCQJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEENIPIAMoAqwBIgFBk4CAgHhGDQEgACADKQGyATcBBiAAQQxqIANBuAFqKQEANwEAIAAgAy8BsAE7AQQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCtKAsgAygCRCABQQF0akEAOwEAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCZEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELItIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCJJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDYDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQlRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiSUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2A8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJURQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EJAlIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMENUPIAMoArgBIgZBk4CAgHhGDQEgACADKQG+ATcBBiAAQQxqIANBxAFqKQEANwEAIAAgAy8BvAE7AQQgACAGNgIAIAEQjjsgCxCyLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCtKAsgAygCVCABQQF0akEAOwEAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCXEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsi0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCQJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBDVDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQlxFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDOFAJAQQxBBBCtNiIDBEAgA0KDhoyYsODAgQM3AgAgA0EIakGDhowYNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPk9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQpAggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCyLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBmKT/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCbKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEOIJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqEM4UAkBBDEEEEK02IgMEQCADQoOGjJiw4MCBAzcCACADQQhqQYOGjBg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCkCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGYpP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJsrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQZik/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmysQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQZik/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmysQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ+T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQpAggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELItIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAv8+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTQgBUGIA2oQuyMMNAsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwwCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCOHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0tIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ03IAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEIaiAFQbABaiAIIAIQgwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTwgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0zIAVBiANqELsjDDMLIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwtCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgx4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNKyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NNyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTEgBUGIA2oQuyMMMQsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCkLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwtCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCLHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0nIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw0zIAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKkZCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBUEgaiAFQbABaiAIIAIQiQsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTkgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0wIAVBiANqELsjDDALIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwnCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNJSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCCACEIYLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS4gBUGIA2oQuyMMLgsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCMLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCHHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0hIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0zIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUE4aiAFQbABaiAkIAIQhQsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0tIAVBiANqELsjDC0LIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwhCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNHyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMCAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCCACEIILDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTQgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0rIAVBiANqELsjDCsLIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwdCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgh4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNGyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMCAFIAooAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCEkIAUoArABIgRBEGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAHICR6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogLDkDACAFIAFBAWo2AowCIAVB0ABqIAVBsAFqICwgAhCECwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNMyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSogBUGIA2oQuyMMKgsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDBsLIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCULIAVBBDoAsAEgACABIAIgBUGwAWogAyAEENwJDCQLIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCMLIAVBBDoAsAEgACABIAIgBUGwAWogAyAEENwJDCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCELIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgYgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMIQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwVCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPkeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNEyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAVBwANqIQ0gBSgCWCETIAUoAlwhDyMAQTBrIgQkAAJAIA8gBUGwAWoiAigCMEYEQCMAQUBqIgYkACAGIA82AgQgBiATNgIAIAIgEyAPEM0CISQgBiACQTBqIgE2AjwgBiACQegAaiIYNgI4IAYgBjYCNCAGIAE2AhAgBiAYNgIMIAYgAjYCCCAGQRhqIQwgBkE0aiEQIAZBCGoiHyEBQQAhC0EAIRFBACEUQQAhGUEAIRojAEEgayIOJAAgAkEgaiIKKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAKKAIMIghBAWoiCSAITwRAAkAgCigCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAJSQRAAkACQCAIQQFqIgsgCSAJIAtJGyILQQ9PBEAgC0H/////AUsNAUF/IAtBA3RBB25BAWtndkEBaiELDAILQQRBCEEQIAtBCEkbIAtBBEkbIQsMAQsQ3ScgASgCHCELIAEoAhgiCUGBgICAeEcNBAsgAUHQAGogCkEQaiIHQQQgCxD7FCABKAJYIQsgASgCVCEJIAEoAlAiCEUNAyABIAEoAlw2AkwgASALNgJIIAEgCTYCRCABIAg2AkAgAUEQaiABQUBrEME0IAEoAhQiCwRAIAEoAhBB/wEgC/wLAAsgASgCSCELIAEoAkQhCSABKAJAIghFDQMgASABKAJMNgI8IAEgCzYCOCABIAk2AjQgASAINgIwIAFChICAgIABNwIoIAEgBzYCJCABQTBqISAgASAKKAIMIhwEfyAIQQhqISEgCigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgEUEIaiERIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIHKAIAIRUgAUEIaiAHKAIEIAcoAggoAgAgCigCACAleqdBA3YgEWpBAnQiImtBBGsoAgAQyiUgCCAJIBUgASgCCCABKAIMEM0CpyIjcSIHaikAAEKAgYKEiJCgwIB/gyImUARAQQghFQNAIAcgFWohByAVQQhqIRUgCCAHIAlxIgdqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCCAmeqdBA3YgB2ogCXEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiAjQRl2IhU6AAAgISAHQQhrIAlxaiAVOgAAIAggB0ECdGtBBGsgCigCACAia0EEaygAADYAACAcQQFrIhwNAAsgCigCDAVBAAsiCTYCPCABIAsgCWs2AjggCiAgQQQQ+iogAUEkahD1JwwBCyAKIAFBIGpB0NeAARDuCQtBgYCAgHghCQwBCxDdJyABKAIEIQsgASgCACEJCyAbIAs2AgQgGyAJNgIAIAFB4ABqJAALIAooAgQiCyAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEHIBAoAgQhESAQKAIAIQggCigCACEJA0ACQCABIAlqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIAwCfgJAA0AgJVANASAOIBEgBygCACAKKAIAICV6p0EDdiABaiALcSIVQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCCgCACAIKAIEIA4oAgAgDigCBBCfO0UNAAsgDCAkNwMIIAwgCigCAEEAIBVrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIAtxIRQLQQEgJSAmQgGGg1ANAhogDCAJIBRqLAAAQQBOBH8gCSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAUCzYCECAMICQ3AwhCAQs3AwAgDCAKNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiALcSEBDAELCyAGIA82AjwgBiATNgI4IAYgGDYCNCAfIAwgEBCLEyAGKAIQQQRrKAIAIQEgBkGQgICAeDYCGCAEQQRqIgogAUEATgR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE2AgQgBkFAayQAIAQoAgghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQIMNwIIIA1BEGogBEEUaigCADYCACANIAY2AgQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEJ0oCyACKAI4IAFBAnRqIAY2AgAgDSAGNgIEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQLIAzcCCCAAQRBqIAVB0ANqKAIANgIAIAAgBSgCxAM2AgQgACABNgIAIAVB0AFqEI47IBcQsy0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiIEQQN2IARBB3FBAEdqIgIgBSgC/AEiAUsEQCACIAFrIQYgBSgC9AEiCiACSQRAIBYgCkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCiABIApLGxDoGSAFKAL8ASEBCyAGBEAgBSgC+AEgAWpBACAG/AsACyAFIAI2AvwBCyAFIAQ2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEJ0oCyAFKALoASABQQJ0akEANgIAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBiALENs8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBkEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBmopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEPIAUoApQCIhUgBkkEQCARIBVBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAGNgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIAZBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0sIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0VIAVBiANqELsjDBULIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBiALENg8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBkEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBmopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEMIAUoApQCIhQgBkkEQCAQIBRBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAGNgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIAZBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0rIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0SIAVBiANqELsjDBILIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBiALENo8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIGQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAGaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgYgBSgCnAIiAUsEQCAGIAFrIQwgBSgClAIiFCAGSQRAIBAgFEEBdCIBIAZBwP///wNxQUBrIAYgBkE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAY2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgYgJjcDCCAGICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAGQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBkEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAUsEQCAEIAFrIQcgBSgC4AEiDCAESQRAIAkgDEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiDCABIAxLGxDoGSAFKALoASEBCyAHBEAgBSgC5AEgAWpBACAH/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAZBA3ZqIgEgAS0AAEEBIAZBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQQMBAsgCRDmOiAFKALcAUUNKiAFKALsAUEBaiIGQQN2IAZBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAY2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCzLSANELUtIAVBsAFqQSBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCAEGQgICAeCECIANBAUcNDyAFQYgDahC7IwwPCyACIQRBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhBCAFKAKwASICQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAQ2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQYgCxDcPCEDIwBBkAFrIgEkACABQRBqIAYQ+R4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEGDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAGQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEGCyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAGNgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBkEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBmopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEMIAUoApQCIhQgBkkEQCAQIBRBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAGNgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgYgBSgChAJGBEAgDRCyKAsgBSgCiAIgBkEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBkEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAYgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkEASA0BIAVB0AJqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0pIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0Qti0gBUGwAWpBMEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0MIAVBiANqELsjDAwLIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCOJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBDUDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgBjYCACABEI47IAsQsy0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmBFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQjiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDUDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmBFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI0lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEN0PIAMoArgBIgZBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACAGNgIAIAEQjjsgCxCzLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCSEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCNJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEN0PIAMoAqwBIgFBk4CAgHhGDQEgACADKQK0ATcCCCAAQRBqIANBvAFqKAIANgIAIAAgAygCsAE2AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCdKAsgAygCRCABQQJ0akEANgIAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCSEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELMtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCOJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDZDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgBjYCACABEI47IAsQsy0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQnRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQjiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2Q8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJ0RQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI0lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEN8PIAMoArgBIgZBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACAGNgIAIAEQjjsgCxCzLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCQEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCNJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBDfDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkBFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDQFAJAQQxBBBCtNiIDBEAgA0KEiJCgwICBggQ3AgAgA0EIakGEiJAgNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPE9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQogggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB8KT/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCXKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEOMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAQ2AgQgACACNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENAUAkBBDEEEEK02IgMEQCADQoSIkKDAgIGCBDcCACADQQhqQYSIkCA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ8T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCiCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELMtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHwpP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJcrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfCk/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQlysQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfCk/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlysQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ8T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQogggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELMtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvh+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ9x4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakGQ3IABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf8BTQR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE6AAQgBkFAayQAIAQtAAghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQAJNwAFIA1BDGogBEEQaikAADcAACANIAY6AAQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEKkZCyACKAI4IAFqIAY6AAAgDSAGOgAEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQDFAzcABSAAQQxqIAVBzANqKQAANwAAIAAgBS0AxAM6AAQgACABNgIAIAVB0AFqEI47IBcQsS0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiICQQN2IAJBB3FBAEdqIgEgBSgC/AEiBEsEQCABIARrIQYgBSgC9AEiCiABSQRAIBYgCkEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCiAEIApLGxDoGSAFKAL8ASEECyAGBEAgBSgC+AEgBGpBACAG/AsACyAFIAE2AvwBCyAFIAI2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEKkZCyAFKALoASABakEAOgAAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhUgBEkEQCARIBVBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4QsS0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH/AXEhAkGQgICAeCEBIANBAUcNDyAFQYgDahC7IwwPCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQQgCxDcPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBEEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgQgBSgChAJGBEAgDRCyKAsgBSgCiAIgBEEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBEEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAQgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkGAAk8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhDvKSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBD2DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQqRkLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ4xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ7ykgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBD2DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQqRkLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ4xFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EPEpIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPUPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCpGQsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBDhEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDxKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEPUPIAMoAqwBIgFBk4CAgHhGDQEgACADKQCxATcABSAAQQxqIANBuAFqKQAANwAAIAAgAy0AsAE6AAQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCpGQsgAygCRCABakEAOgAAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDhEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELEtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhDvKSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBD8DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQqRkLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ4BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ7ykgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ/A8gAygCrAEiAUGTgICAeEYNASAAIAMpALEBNwAFIABBDGogA0G4AWopAAA3AAAgACADLQCwAToABCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEKkZCyADKAJEIAFqQQA6AAAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEOARQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsS0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EPEpIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPkPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCpGQsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBDXEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDxKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBD5DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQqRkLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1xFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDRFAJAQQxBBBCtNiIDBEAgA0KGjJiw4MCBgwY3AgAgA0EIakGGjJgwNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPc9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQnQggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCxLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBoKb/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCaKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEJ0KIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENEUAkBBDEEEEK02IgMEQCADQoaMmLDgwIGDBjcCACADQQhqQYaMmDA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ9z0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCdCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELEtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGgpv8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJorEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQaCm/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmisQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQaCm/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmisQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ9z0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQnQggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELEtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsS0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvh+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ8B4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakGg14ABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf8ATQR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE6AAQgBkFAayQAIAQtAAghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQAJNwAFIA1BDGogBEEQaikAADcAACANIAY6AAQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEKMoCyACKAI4IAFqIAY6AAAgDSAGOgAEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQDFAzcABSAAQQxqIAVBzANqKQAANwAAIAAgBS0AxAM6AAQgACABNgIAIAVB0AFqEI47IBcQsS0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiICQQN2IAJBB3FBAEdqIgEgBSgC/AEiBEsEQCABIARrIQYgBSgC9AEiCiABSQRAIBYgCkEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCiAEIApLGxDoGSAFKAL8ASEECyAGBEAgBSgC+AEgBGpBACAG/AsACyAFIAE2AvwBCyAFIAI2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEKMoCyAFKALoASABakEAOgAAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhUgBEkEQCARIBVBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4QsS0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH/AXEhAkGQgICAeCEBIANBAUcNDyAFQYgDahC7IwwPCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQQgCxDcPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBEEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgQgBSgChAJGBEAgDRCyKAsgBSgCiAIgBEEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBEEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAQgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkGAAU8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCKJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBD4DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQoygLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmxFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBD4DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQoygLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmxFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI8lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPcPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCjKAsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCPEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCPJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEPcPIAMoAqwBIgFBk4CAgHhGDQEgACADKQCxATcABSAAQQxqIANBuAFqKQAANwAAIAAgAy0AsAE6AAQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCjKAsgAygCRCABakEAOgAAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCPEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELEtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCKJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBD6DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQoygLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQnBFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ+g8gAygCrAEiAUGTgICAeEYNASAAIAMpALEBNwAFIABBDGogA0G4AWopAAA3AAAgACADLQCwAToABCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEKMoCyADKAJEIAFqQQA6AAAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJwRQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsS0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI8lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPsPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCjKAsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCTEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCPJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBD7DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQoygLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkxFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDWFAJAQQxBBBCtNiIDBEAgA0KChIiQoMCAgQI3AgAgA0EIakGChIgQNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPc9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQngggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCxLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBwKP/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCZKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEIQKIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENYUAkBBDEEEEK02IgMEQCADQoKEiJCgwICBAjcCACADQQhqQYKEiBA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ9z0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCeCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELEtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHAo/8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJkrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcCj/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmSsQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcCj/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmSsQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ9z0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQngggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELEtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsS0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvS6wIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADC0LIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgR4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEUUNLCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiADIAooAghPDTEgBSAHKAIQIANqLQAAIgk6ANACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgBGogCHEiDUEDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQoygLIAUoAogCIAFqIAk6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAkgBBCHCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ03IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCwLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCOHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0qIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NMSAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCSAEEIMLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMKgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwrCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIMeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ+R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8IhFFDSggBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0xIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAJIAQQiAsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwoCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCoLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQih4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNJiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDTEgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICUgBBCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASIPIAJJBEAgBiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDCYLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCLHiIHQQxqIgooAgghAyAKKAIIIQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgCigCCCIRRQ0kIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAMgCigCCE8NLSAFIAcoAhAgA2otAAAiCToA0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCvDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiAEaiAIcSINQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCpGQsgBSgCiAIgAWogCToAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCSAEEIkLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTMgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMJAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwoCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIkeIgdBDGoiChDZPCEDIAoQ2TwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ8x4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENk8IhFFDSIgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0tIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK4MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IARqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEK0oCyAFKAKIAiABQQF0aiAJOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAJIAQQhgsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNMiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwiCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEUUNICAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDS0gBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQqwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgBGogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqIAk2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAkgBBCKCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0xIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCALIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJgsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCHHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCINRQ0eIAVB3AFqIQYgBUHQAWohCyAFQZACaiERIAVBhAJqIQ4gBUHAAWohEkEAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NLSAFIAcoAhAgA0EDdGopAwAiJTcD0AICQAJAAkAgBSgCvAFFDQAgEiAFQdACahCsDCEkIAUoArABIgRBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAJcSECDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDCAFKAKUAiIPIAJJBEAgESAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgAjYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJTcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJSAEEIULDAELIARBACAMa0EEdGpBCGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTAgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMHgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwlCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIUeIgdBDGoiChDZPCEDIAoQ2TwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ9B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENk8IhFFDRwgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0qIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK4MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IARqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEK0oCyAFKAKIAiABQQF0aiAJOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAJIAQQggsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwcCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCQLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiDUUNGiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSogBSAHKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgCCAkeqdBA3YgAmogCXEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAQQjAsMAQsgBEEAIAxrQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwaCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCMLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgh4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNGCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSogBSAHKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAQQhAsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwYCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDCELIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN0JDCALIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDB8LIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN0JDB4LIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDB0LIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgcgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAcQpgwMHQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwRCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPgeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNDyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAUoAlghDyAFKAJcIREjAEEwayIHJAAgBUHAA2oiDAJ/IBEgBUGwAWoiBCgCMEYEQCMAQUBqIgIkACACIBE2AgQgAiAPNgIAIAQgDyAREM0CISQgAiAEQTBqIgE2AjwgAiAEQegAaiIYNgI4IAIgAjYCNCACIAE2AhAgAiAYNgIMIAIgBDYCCCACQRhqIQ0gAkE0aiEQIAJBCGoiHyEBQQAhCkEAIRNBACEVQQAhGUEAIRojAEEgayIOJAAgBEEgaiIGKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAGKAIMIglBAWoiCyAJTwRAAkAgBigCBCIJIAlBAWpBA3ZBB2wgCUEISRsiCUEBdiALSQRAAkACQCAJQQFqIgogCyAKIAtLGyIKQQ9PBEAgCkH/////AUsNAUF/IApBA3RBB25BAWtndkEBaiEKDAILQQRBCEEQIApBCEkbIApBBEkbIQoMAQsQ3ScgASgCHCEKIAEoAhgiC0GBgICAeEcNBAsgAUHQAGogBkEQaiIIQQQgChD7FCABKAJYIQogASgCVCELIAEoAlAiCUUNAyABIAEoAlw2AkwgASAKNgJIIAEgCzYCRCABIAk2AkAgAUEQaiABQUBrEME0IAEoAhQiCgRAIAEoAhBB/wEgCvwLAAsgASgCSCEKIAEoAkQhCyABKAJAIglFDQMgASABKAJMNgI8IAEgCjYCOCABIAs2AjQgASAJNgIwIAFChICAgIABNwIoIAEgCDYCJCABQTBqISAgASAGKAIMIhwEfyAJQQhqISEgBigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgE0EIaiETIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIIKAIAIRQgAUEIaiAIKAIEIAgoAggoAgAgBigCACAleqdBA3YgE2pBAnQiImtBBGsoAgAQyiUgCSALIBQgASgCCCABKAIMEM0CpyIjcSIIaikAAEKAgYKEiJCgwIB/gyImUARAQQghFANAIAggFGohCCAUQQhqIRQgCSAIIAtxIghqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCSAmeqdBA3YgCGogC3EiCGosAABBAE4EQCAJKQMAQoCBgoSIkKDAgH+DeqdBA3YhCAsgCCAJaiAjQRl2IhQ6AAAgISAIQQhrIAtxaiAUOgAAIAkgCEECdGtBBGsgBigCACAia0EEaygAADYAACAcQQFrIhwNAAsgBigCDAVBAAsiCzYCPCABIAogC2s2AjggBiAgQQQQ+iogAUEkahD1JwwBCyAGIAFBIGpBsNiAARDuCQtBgYCAgHghCwwBCxDdJyABKAIEIQogASgCACELCyAbIAo2AgQgGyALNgIAIAFB4ABqJAALIAYoAgQiCiAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEIIBAoAgQhEyAQKAIAIQkgBigCACELA0ACQCABIAtqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIA0CfgJAA0AgJVANASAOIBMgCCgCACAGKAIAICV6p0EDdiABaiAKcSIUQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCSgCACAJKAIEIA4oAgAgDigCBBCfO0UNAAsgDSAkNwMIIA0gBigCAEEAIBRrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIApxIRULQQEgJSAmQgGGg1ANAhogDSALIBVqLAAAQQBOBH8gCykDAEKAgYKEiJCgwIB/g3qnQQN2BSAVCzYCECANICQ3AwhCAQs3AwAgDSAGNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiAKcSEBDAELCyACIBE2AjwgAiAPNgI4IAIgGDYCNCAfIA0gEBCLEyACKAIQQQRrNQIAISQgAkGQgICAeDYCGCANEIgRIAdBGGoiAUEANgIAIAEgJDcDCCACQUBrJAAgBygCGARAIAcoAhwhASAHKQMgISQgDCAHKQMoNwMQIAwgJDcDCCAMIAE2AgRBAQwCCyAHKQMgISQCQCAEKAJABEAgBCgCUCIGQQFqIgpBA3YgCkEHcUEAR2oiASAEKAJMIgJLBEAgASACayELIAQoAkQiDiABSQRAIARBQGsgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSAEKAJMIQILIAsEQCAEKAJIIAJqQQAgC/wLAAsgBCABNgJMCyAEIAo2AlAgBCgCSCAGQQN2aiIBIAEtAABBASAGQQdxdHI6AAAMAQsgBCAEKAJUQQFqNgJUCyAEKAI8IgEgBCgCNEYEQCAEQTRqQci1gAEQsygLIAQoAjggAUEDdGogJDcDACAMICQ3AwggBCABQQFqNgI8QQAMAQsgByARNgIEIAdBAjYCHCAHQaC3gAE2AhggB0ICNwIkIAdBOzYCFCAHQZwDNgIMIAcgBEEwajYCCCAHIAdBCGo2AiAgByAHQQRqNgIQIAxBCGogB0EYahCZDiAMQY2AgIB4NgIEQQELNgIAIAdBMGokACAFKALAA0UNASAFKALEAyEBIAUpA8gDISQgACAFKQPQAzcCDCAAICQ3AgQgACABNgIAIAVB0AFqEI47IBcQtC0gBUGYAmoQii8MEwsgFhDmOiAFKALwAUUNJiAFKAKAAkEBaiIEQQN2IARBB3FBAEdqIgIgBSgC/AEiAUsEQCACIAFrIQcgBSgC9AEiBiACSQRAIBYgBkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiBiABIAZLGxDoGSAFKAL8ASEBCyAHBEAgBSgC+AEgAWpBACAH/AsACyAFIAI2AvwBCyAFIAQ2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AELMoCyAFKALoASABQQN0akIANwMAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwPCyADLQACIREgAy0AASESIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQiB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhCfHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiD0UNDiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohECAFQYQCaiEOIAVBwAFqIRNBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSIgBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgBGogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiFSACSQRAIBAgFUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiFSABIBVLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqIAk2AgAgBSABQQFqNgKMAiAFQfAAaiAFQbABaiAJIAQQiAsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNJiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyAPRw0ACwwOCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBsLIAMtAAIhDSADLQABIREgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCNHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCISRQ0MIAVB3AFqIQYgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NIiAFIAcoAhAgA0EDdGopAwAiJTcD0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCsDCEkIAUoArABIgRBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAJcSECDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDCAFKAKUAiITIAJJBEAgDyATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgAjYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJTcDACAFIAFBAWo2AowCIAVBgAFqIAVBsAFqICUgBBCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASITIAJJBEAgBiATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0lIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBJHDQALDAwLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGgsgAy0AAiENIAMtAAEhESAFQbABaiIHIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIYeIgZBDGoiChDaPCEDIAoQ2jwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQoB4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQSBBEAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgB0EgaiABQRBqQTT8CgAAIAdB1ABqIAFBxABqQTT8CgAAIAcgJTcDGCAHICY3AxAgByAkNwMIIAcgAjYCBCAHIAM2AgAgAUGQAWokACAKENo8IhJFDQogBUHcAWohByAFQdABaiELIAVBkAJqIQ8gBUGEAmohDiAFQcABaiEQQQAhAwNAAkAgBiADEIclRQRAIAUgAzYCyAIgChDaPCADTQ0KIAYoAhAgA0EEdGoiASkDACElIAUgASkDCCImNwPYAiAFICU3A9ACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQsAwhJCAFKAKwASIEQSBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQRAgCCAkeqdBA3YgAmogCXEiDEEFdGtBEBCfOw0EICRCAX0gJIMiJFBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsSgLIAUoAogCIAFBBHRqIgIgJjcDCCACICU3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAlICYgBBDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASITIAJJBEAgByATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAHEOY6IAUoAtwBRQ0kIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgByAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBJHDQALDAoLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGQsgAy0AAiENIAMtAAEhESAFQbABaiIHIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIAeIgZBDGoiChDcPCEDIAoQ3DwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQoh4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQTBBEAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgB0EgaiABQRBqQTT8CgAAIAdB1ABqIAFBxABqQTT8CgAAIAcgJTcDGCAHICY3AxAgByAkNwMIIAcgAjYCBCAHIAM2AgAgAUGQAWokACAKENw8IhJFDQggBUHcAWohByAFQdABaiELIAVBkAJqIQ8gBUGEAmohDiAFQcABaiEQQQAhAwNAAkAgBiADEIclRQRAIAUgAzYCyAIgChDcPCADTQ0KIAYoAhAgA0EFdGoiASkDACElIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICU3A8ADAkACQAJAIAUoArwBRQ0AIBAgBUHAA2oQrQwhJCAFKAKwASIEQTBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEBA0AgAiAEaikAACIpICqFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVBwANqQSAgCCAkeqdBA3YgAmogCXFBUGwiDGpBIBCfOw0EICRCAX0gJIMiJFBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAOELIoCyAFKAKIAiACQQV0aiIBICg3AxggASAnNwMQIAEgJjcDCCABICU3AwAgBSACQQFqNgKMAiAFQaABaiAFQbABaiAlICYgJyAoIAQQlwoMAQsgBCAMakEQaygCACEECyAFQZCAgIB4NgLQAiAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAcgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBxDmOiAFKALcAUUNIyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAcgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwICyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGUqNCgATYCACADQpSo0KDBgoWKFDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCkJ6z7tm0jZLpAIUgAykDKEKI9KuB4LHF5MIAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0iIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EIslIAQQ0zoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQvQ8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuiwMBAsgBhDmOiADKAJcRQ0lIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQjhFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwYCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiyUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSMgAygCyAEiAUG+tf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0oIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgAygCwAEgAhCsHyADQagBaiADQRBqIAMoAgAgAygCBBC9DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSMgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCOEUHQAEEEEK02IgFFDSEgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELosIANBkAJqJAAMFwsgASACKAIcEQQAQdSw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZas2LABNgIAIANClqzYsOHChYsWNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELCjPf26svc0YR/hSADKQMoQuWT9Jj5r/joqH+FhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDSEgAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQjCUgBBDUOiIJBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8hYgA0G4AWogA0EgaiIBIAMoAgggAygCDBC8DyADKAK4AUUNASADKAK8ASECIAMpA8ABISQgACADKQPIATcCDCAAICQ3AgQgACACNgIAIAEQjjsgChC0LSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSQgAygCbEEBaiILQQN2IAtBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshDiADKAJgIgggAUkEQCAGIAhBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgggAiAISxsQ6BkgAygCaCECCyAOBEAgAygCZCACakEAIA78CwALIAMgATYCaAsgAyALNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCzKAsgAygCVCABQQN0akIANwMAIAMgAUEBajYCWAsgCSAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBCWEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQtC0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwiCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBcLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCMJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNIiADKALIASIBQb61/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohCwNAAkACQCADKALEAQRAIAIgAygC1AFPDScgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADKALAASACEKwfIANBqAFqIANBEGogAygCACADKAIEELwPIAMoAqgBRQ0BIAMoAqwBIQEgAykDsAEhJCAAIAMpA7gBNwIMIAAgJDcCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCxD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNIiADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiDiABSQRAIAQgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AELMoCyADKAJEIAFBA3RqQgA3AwAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJYRQdAAQQQQrTYiAUUNICABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQtC0gA0H0AGoQuywgA0GQAmokAAwWCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmLDgwAE2AgAgA0KYsODAgYOGjBg3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQsfZ9OfexLacd4UgAykDKEKNss6UjMqS5qd/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0gIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EIslIAQQ0zoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEP8WIANBuAFqIANBIGoiASADKAIIIAMoAgwQtg8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuiwMBAsgBhDmOiADKAJcRQ0jIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQkRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwWCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiyUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0hIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJiADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GoAWogA0EQaiADKAIAIAMoAgQQtg8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0hIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkRFB0ABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC6LCADQZACaiQADBULIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGZsuTIATYCACADQpmy5MiRo8aMGTcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBC09jT+P3m9pJIhSADKQMoQqLYnojhoOrpzACFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDR8gAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQjCUgBBDUOiIJBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBC5DyADKAK4AUUNASADKAK8ASECIAMpA8ABISQgACADKQPIATcCDCAAICQ3AgQgACACNgIAIAEQjjsgChC0LSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSIgAygCbEEBaiILQQN2IAtBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshDiADKAJgIgggAUkEQCAGIAhBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgggAiAISxsQ6BkgAygCaCECCyAOBEAgAygCZCACakEAIA78CwALIAMgATYCaAsgAyALNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCzKAsgAygCVCABQQN0akIANwMAIAMgAUEBajYCWAsgCSAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBCUEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQtC0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwgCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBULIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCMJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSAgAygCyAEiAUGQtf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0lIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgA0HAAWogAhCtKiADQagBaiADQRBqIAMoAgAgAygCBBC5DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSAgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCUEUHQAEEEEK02IgFFDR4gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELssIANBkAJqJAAMFAsgASAFKAK4AUHQoP8AEP0vAAsgBSAGEP87NgKgAwwXCyAFIAYQgDw2AqADDBYLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0fIAMgCkEw/AoAACAHIAMQhj4gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwdCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahC0LSAFQYQCahC2LSACQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVByKX/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCVKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgESANEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiILIAIpAwA3AwAgBUGvA2oiDiAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiALKQMANwAAIAFBGGogDikAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUHUsv8AEOEJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0dIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR4gAyAKQTD8CgAAIAcgAxD+PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBwLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELUtIAJBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHIpf8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJUrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiARIA0QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0XIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQfyx/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCwwZCwwYCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRwgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHSADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcil/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQlSsQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiARIA0QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQaSx/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRsgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMGgsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcil/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlSsQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiASIBEQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0VIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQayz/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNDyAFQcgCahC7IwwPCwwXCwwWCyAFQcADaiEEIwBBkANrIgEkACAFQbABaiICQSBqEJc2IAFBCGoiBiACQegAahDHFCABQUBrIgcgAkE0ahDbFAJAQQxBBBCtNiIDBEAgA0KFipSo0KDBggU3AgAgA0EIakGFipQoNgIAIAIoAjAhCkEMQQQQrTYiAkUNGiACIAo2AgQgAkEVOgAAIAEgAjYCeCABIAM2AnQgAUEiOgBwIAFB2AFqIgMgBxDwPSABQbQCaiICIAMQoRsgAyACIAFB8ABqEIwYQcQAQQQQrTYiB0UNGyAHIAYQ7z0gAUEBNgK8AiABIAc2ArgCIAFBATYCtAIgAUH8AGoiByADIAIQ/CIgAiAHEM0cIAQgAhCgCCABQZADaiQADAELDBkLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQjjsgBUHkAWoQtC0gBUGYAmoQii8gBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0NIAVB0AJqELsjDA0LDBULIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQdACahC7IwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRggByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNGSADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM0UIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0XIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRggAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDVFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0XIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwVC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCSAFQYgDahC7IwwJCwwRCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRUgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFiADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENQUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0UIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRUgAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDPFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0UIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwSC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBiAFQYgDahC7IwwGCwwOCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRIgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNEyADIApBMPwKAAAgByADEPc9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCxLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENsUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0RIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRIgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDQFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNECAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0RIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwPC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELMtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAyAFQYgDahC7IwwDCwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDQ8gByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNECADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENYUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0OIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDQ8gAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgBxCjPDYCoAMMAwsgBSAHEP47NgKgAwwCCyAFIAcQ/Ds2AqADDAELIAUgBxD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgAiADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAIgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQAL4usCBB9/B34BfQF8IwBBkARrIgUkACAFIAM2AqwBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAABBAmsOJQECAwQFBgcICQoLDA0ODxAAABYRFwAYGQAAAAAAAAAAABITFBUACyAFQQE2ArQBIAVBnLH/ADYCsAEgBUIBNwK8ASAFQa8DNgLUAiAFIAVB0AJqNgK4ASAFIAVBrAFqNgLQAiAFQcADaiAFQbABahCZDiAAQYKAgIB4NgIAIAAgBSkCwAM3AgQgAEEMaiAFQcgDaigCADYCAAwtCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIEeIgdBDGoiCigCCCEDIAooAgghAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKKAIIIhFFDSwgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0xIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK8MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IARqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEKMoCyAFKAKIAiABaiAJOgAAIAUgAUEBajYCjAIgBSAFQbABaiAJIAQQhwsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwsCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCwLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjh4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEUUNKiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENk8IANNDTEgBSAHKAIQIANBAXRqLwEAIgk7AdACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrgwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQIgDCAkeqdBA3YgBGogCHEiDUEDdGtBAhCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQrSgLIAUoAogCIAFBAXRqIAk7AQAgBSABQQFqNgKMAiAFQQhqIAVBsAFqIAkgBBCDCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ02IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCoLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKwsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCDHiIHQQxqIgoQ2zwhAyAKENs8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDbPCIRRQ0oIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2zwgA00NMSAFIAcoAhAgA0ECdGooAgAiCTYC0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCrDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiAEaiAIcSINQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCdKAsgBSgCiAIgAUECdGogCTYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCSAEEIgLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTUgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMKAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIoeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDSYgBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0xIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiBEEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgxBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELMoCyAFKAKIAiABQQN0aiAlNwMAIAUgAUEBajYCjAIgBUEYaiAFQbABaiAlIAQQiwsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNCAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwmCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCkLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQix4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEUUNJCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiADIAooAghPDS0gBSAHKAIQIANqLQAAIgk6ANACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgBGogCHEiDUEDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQqRkLIAUoAogCIAFqIAk6AAAgBSABQQFqNgKMAiAFQSBqIAVBsAFqIAkgBBCJCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCQLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKAsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCJHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0iIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NLSAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCSAEEIYLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTIgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMIgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwnCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIweIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8IhFFDSAgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0tIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUEwaiAFQbABaiAJIAQQigsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNMSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwgCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCYLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhx4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNHiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDS0gBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQThqIAVBsAFqICUgBBCFCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASIPIAJJBEAgBiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0wIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDB4LIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJQsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCFHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0cIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NKiAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCSAEEIILDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS8gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMHAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwkCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIQeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8Ig1FDRogBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0qIAUgBygCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKsMISQgBSgCsAEiBEEIayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAggJHqnQQN2IAJqIAlxIgxBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiArOAIAIAUgAUEBajYCjAIgBUHIAGogBUGwAWogKyAEEIwLDAELIARBACAMa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS4gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwjCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIIeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDRggBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0qIAUgBygCECADQQN0aisDACIsOQPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiBEEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgxBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELMoCyAFKAKIAiABQQN0aiAsOQMAIAUgAUEBajYCjAIgBUHQAGogBUGwAWogLCAEEIQLDAELIARBACAMa0EEdGpBCGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS0gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwiCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwhCyAFQQQ6ALABIAAgASACIAVBsAFqIAMgBBDaCQwgCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwfCyAFQQQ6ALABIAAgASACIAVBsAFqIAMgBBDaCQweCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwdCyADKAIEIQMgBUEVOgDAAyAFIAM2AsQDIAVBsAFqIAEgAiAFQcADaiIHIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgRBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgBDYCACAHEKYMDB0LIAUgATYC1AIgBSACNgLQAiAFQcADahCmDCAFQeAAaiAFQdACahC5JiAFQbABaiAFKAJgIhIgBSgCZCgCDBEAAAJAIBIEQCAFKQOwAULA47Xe0v6llSyFIAUpA7gBQvXOqKjR/trMpH+FhFANAQsgBUGwAWpBL0EAQQFBARCgGCAFKAK0ASEBIAUoArABQQFGDQkgBSgCuAEiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMEQsgBUGwAWoiAUHYuIABQfi4gAEQhTUiAigCACACKAIEKAIMEQQAENoBIAFBIGoQrzQgAUE0akGACBDvHiABQegAakGACCADEI8XIAEgAzYCMCASKAIwIh5FDQ8gBUHwAWohFiAFQeQBaiEXQQAhAwNAAkAgEiADEJslRQRAIAVB2ABqIBIgAxCgGyAFKAJYIQ8gBSgCXCERIwBBMGsiByQAIAVBwANqIgwCfyARIAVBsAFqIgQoAjBGBEAjAEFAaiICJAAgAiARNgIEIAIgDzYCACAEIA8gERDNAiEkIAIgBEEwaiIBNgI8IAIgBEHoAGoiGDYCOCACIAI2AjQgAiABNgIQIAIgGDYCDCACIAQ2AgggAkEYaiENIAJBNGohECACQQhqIh8hAUEAIQpBACETQQAhFUEAIRlBACEaIwBBIGsiDiQAIARBIGoiBigCCEUEQCAOQRhqIAFBCGooAgA2AgAgDiABKQIANwMQIA5BCGohGyMAQeAAayIBJAAgASAOQRBqNgIgAkAgBigCDCIJQQFqIgsgCU8EQAJAIAYoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgC0kEQAJAAkAgCUEBaiIKIAsgCiALSxsiCkEPTwRAIApB/////wFLDQFBfyAKQQN0QQduQQFrZ3ZBAWohCgwCC0EEQQhBECAKQQhJGyAKQQRJGyEKDAELEN0nIAEoAhwhCiABKAIYIgtBgYCAgHhHDQQLIAFB0ABqIAZBEGoiCEEEIAoQ+xQgASgCWCEKIAEoAlQhCyABKAJQIglFDQMgASABKAJcNgJMIAEgCjYCSCABIAs2AkQgASAJNgJAIAFBEGogAUFAaxDBNCABKAIUIgoEQCABKAIQQf8BIAr8CwALIAEoAkghCiABKAJEIQsgASgCQCIJRQ0DIAEgASgCTDYCPCABIAo2AjggASALNgI0IAEgCTYCMCABQoSAgICAATcCKCABIAg2AiQgAUEwaiEgIAEgBigCDCIcBH8gCUEIaiEhIAYoAgAiHSkDAEJ/hUKAgYKEiJCgwIB/gyElA0AgJVAEQANAIBNBCGohEyAdQQhqIh0pAwBCgIGChIiQoMCAf4MiJUKAgYKEiJCgwIB/UQ0ACyAlQoCBgoSIkKDAgH+FISULIAEoAiAiCCgCACEUIAFBCGogCCgCBCAIKAIIKAIAIAYoAgAgJXqnQQN2IBNqQQJ0IiJrQQRrKAIAEMolIAkgCyAUIAEoAgggASgCDBDNAqciI3EiCGopAABCgIGChIiQoMCAf4MiJlAEQEEIIRQDQCAIIBRqIQggFEEIaiEUIAkgCCALcSIIaikAAEKAgYKEiJCgwIB/gyImUA0ACwsgJUIBfSAlgyElIAkgJnqnQQN2IAhqIAtxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogI0EZdiIUOgAAICEgCEEIayALcWogFDoAACAJIAhBAnRrQQRrIAYoAgAgImtBBGsoAAA2AAAgHEEBayIcDQALIAYoAgwFQQALIgs2AjwgASAKIAtrNgI4IAYgIEEEEPoqIAFBJGoQ9ScMAQsgBiABQSBqQaDdgAEQ7gkLQYGAgIB4IQsMAQsQ3ScgASgCBCEKIAEoAgAhCwsgGyAKNgIEIBsgCzYCACABQeAAaiQACyAGKAIEIgogJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEnIBAoAgghCCAQKAIEIRMgECgCACEJIAYoAgAhCwNAAkAgASALaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyElAn8CQCANAn4CQANAICVQDQEgDiATIAgoAgAgBigCACAleqdBA3YgAWogCnEiFEECdGtBBGsoAgAQyiUgJUIBfSAlgyElIAkoAgAgCSgCBCAOKAIAIA4oAgQQnztFDQALIA0gJDcDCCANIAYoAgBBACAUa0ECdGo2AhBCAAwBCyAmQoCBgoSIkKDAgH+DISUgGUUEQCAlUA0CICV6p0EDdiABaiAKcSEVC0EBICUgJkIBhoNQDQIaIA0gCyAVaiwAAEEATgR/IAspAwBCgIGChIiQoMCAf4N6p0EDdgUgFQs2AhAgDSAkNwMIQgELNwMAIA0gBjYCFCAOQSBqJAAMAgtBAAshGSABIBpBCGoiGmogCnEhAQwBCwsgAiARNgI8IAIgDzYCOCACIBg2AjQgHyANIBAQixMgAigCEEEEazUCACEkIAJBkICAgHg2AhggDRCIESAHQRhqIgFBADYCACABICQ3AwggAkFAayQAIAcoAhgEQCAHKAIcIQEgBykDICEkIAwgBykDKDcDECAMICQ3AwggDCABNgIEQQEMAgsgBykDICEkAkAgBCgCQARAIAQoAlAiBkEBaiIKQQN2IApBB3FBAEdqIgEgBCgCTCICSwRAIAEgAmshCyAEKAJEIg4gAUkEQCAEQUBrIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgBCgCTCECCyALBEAgBCgCSCACakEAIAv8CwALIAQgATYCTAsgBCAKNgJQIAQoAkggBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAQgBCgCVEEBajYCVAsgBCgCPCIBIAQoAjRGBEAgBEE0akHItYABELMoCyAEKAI4IAFBA3RqICQ3AwAgDCAkNwMIIAQgAUEBajYCPEEADAELIAcgETYCBCAHQQI2AhwgB0Ggt4ABNgIYIAdCAjcCJCAHQTs2AhQgB0GcAzYCDCAHIARBMGo2AgggByAHQQhqNgIgIAcgB0EEajYCECAMQQhqIAdBGGoQmQ4gDEGNgICAeDYCBEEBCzYCACAHQTBqJAAgBSgCwANFDQEgBSgCxAMhASAFKQPIAyEkIAAgBSkD0AM3AgwgACAkNwIEIAAgATYCACAFQdABahCOOyAXELQtIAVBmAJqEIovDBMLIBYQ5jogBSgC8AFFDSYgBSgCgAJBAWoiBEEDdiAEQQdxQQBHaiICIAUoAvwBIgFLBEAgAiABayEHIAUoAvQBIgYgAkkEQCAWIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBSgC/AEhAQsgBwRAIAUoAvgBIAFqQQAgB/wLAAsgBSACNgL8AQsgBSAENgKAAiAFKALsASIBIAUoAuQBRgRAIBdBgJ3/ABCzKAsgBSgC6AEgAUEDdGpCADcDACAFIAFBAWo2AuwBCyAeIANBAWoiA0cNAAsMDwsgAy0AAiERIAMtAAEhEiAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIgeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQnx4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8Ig9FDQ4gBUHcAWohBiAFQdABaiELIAVBkAJqIRAgBUGEAmohDiAFQcABaiETQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0iIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhUgAkkEQCAQIBVBAXQiASACQcD///8DcUFAayACIAJBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCSAEEIgLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDSYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgD0cNAAsMDgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwbCyADLQACIQ0gAy0AASERIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjR4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhChHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiEkUNDCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohDyAFQYQCaiEOIAVBwAFqIRBBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSIgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQYABaiAFQbABaiAlIAQQiwsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAYgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNJSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwMCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBoLIAMtAAIhDSADLQABIREgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCGHiIGQQxqIgoQ2jwhAyAKENo8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEgQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDaPCISRQ0KIAVB3AFqIQcgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAYgAxCHJUUEQCAFIAM2AsgCIAoQ2jwgA00NCiAGKAIQIANBBHRqIgEpAwAhJSAFIAEpAwgiJjcD2AIgBSAlNwPQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqELAMISQgBSgCsAEiBEEgayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEoQQAhAQNAIAIgBGopAAAiJyAohSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEQIAggJHqnQQN2IAJqIAlxIgxBBXRrQRAQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJyAnQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIhMgAkkEQCAPIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELEoCyAFKAKIAiABQQR0aiICICY3AwggAiAlNwMAIAUgAUEBajYCjAIgBUGQAWogBUGwAWogJSAmIAQQ1AoMAQsgBEEAIAxrQQV0akEQaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAcgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBxDmOiAFKALcAUUNJCAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAcgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwKCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBkLIAMtAAIhDSADLQABIREgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCAHiIGQQxqIgoQ3DwhAyAKENw8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEKIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEwQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDcPCISRQ0IIAVB3AFqIQcgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAYgAxCHJUUEQCAFIAM2AsgCIAoQ3DwgA00NCiAGKAIQIANBBXRqIgEpAwAhJSABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAlNwPAAwJAAkACQCAFKAK8AUUNACAQIAVBwANqEK0MISQgBSgCsAEiBEEwayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQcADakEgIAggJHqnQQN2IAJqIAlxQVBsIgxqQSAQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIhMgAkkEQCAPIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDhCyKAsgBSgCiAIgAkEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAlNwMAIAUgAkEBajYCjAIgBUGgAWogBUGwAWogJSAmICcgKCAEEJcKDAELIAQgDGpBEGsoAgAhBAsgBUGQgICAeDYC0AIgBUHQAmoQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIhMgAkkEQCAHIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAcQ5jogBSgC3AFFDSMgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAHIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEkcNAAsMCAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwYCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNIiADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDtKSAEENM6IgkEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxCAFyADQbgBaiADQSBqIgEgAygCCCADKAIMELgPIAMoArgBRQ0BIAMoArwBIQIgAykDwAEhJCAAIAMpA8gBNwIMIAAgJDcCBCAAIAI2AgAgARCOOyAKELQtIANBhAFqELosDAQLIAYQ5jogAygCXEUNJSADKAJsQQFqIgtBA3YgC0EHcUEAR2oiASADKAJoIgJLBEAgASACayEOIAMoAmAiCCABSQRAIAYgCEEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCCACIAhLGxDoGSADKAJoIQILIA4EQCADKAJkIAJqQQAgDvwLAAsgAyABNgJoCyADIAs2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AELMoCyADKAJUIAFBA3RqQgA3AwAgAyABQQFqNgJYCyAJIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEENURQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahC0LSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCMLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO0pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0jIAMoAsgBIgFBvrX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NKCADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIAMoAsABIAIQrB8gA0GoAWogA0EQaiADKAIAIAMoAgQQuA8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0jIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1RFB0ABBBBCtNiIBRQ0hIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC6LCADQZACaiQADBcLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0hIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENQ6EPIpIAQQ1DoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEPIWIANBuAFqIANBIGoiASADKAIIIAMoAgwQuw8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0kIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ2RFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIgsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwXCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8ikgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSIgAygCyAEiAUG+tf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0nIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgAygCwAEgAhCsHyADQagBaiADQRBqIAMoAgAgAygCBBC7DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSIgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDZEUHQAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELssIANBkAJqJAAMFgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNICADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDtKSAEENM6IgkEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxD/FiADQbgBaiADQSBqIgEgAygCCCADKAIMELoPIAMoArgBRQ0BIAMoArwBIQIgAykDwAEhJCAAIAMpA8gBNwIMIAAgJDcCBCAAIAI2AgAgARCOOyAKELQtIANBhAFqELosDAQLIAYQ5jogAygCXEUNIyADKAJsQQFqIgtBA3YgC0EHcUEAR2oiASADKAJoIgJLBEAgASACayEOIAMoAmAiCCABSQRAIAYgCEEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCCACIAhLGxDoGSADKAJoIQILIA4EQCADKAJkIAJqQQAgDvwLAAsgAyABNgJoCyADIAs2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AELMoCyADKAJUIAFBA3RqQgA3AwAgAyABQQFqNgJYCyAJIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEEN4RQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahC0LSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCELIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMFgsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO0pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCq5iR8ZX61fyAf4UgAykDyAFClpT4q/Cx6bPhAIWEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNISADKALIASIBQZC1/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohCwNAAkACQCADKALEAQRAIAIgAygC1AFPDSYgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADQcABaiACEK0qIANBqAFqIANBEGogAygCACADKAIEELoPIAMoAqgBRQ0BIAMoAqwBIQEgAykDsAEhJCAAIAMpA7gBNwIMIAAgJDcCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCxD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNISADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiDiABSQRAIAQgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AELMoCyADKAJEIAFBA3RqQgA3AwAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEN4RQdAAQQQQrTYiAUUNHyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQtC0gA0H0AGoQuiwgA0GQAmokAAwVCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0fIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENQ6EPIpIAQQ1DoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEPEWIANBuAFqIANBIGoiASADKAIIIAMoAgwQtw8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0iIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ3xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwVCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8ikgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0gIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJSADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GoAWogA0EQaiADKAIAIAMoAgQQtw8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0gIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ3xFB0ABBBBCtNiIBRQ0eIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC7LCADQZACaiQADBQLIAEgBSgCuAFB0KD/ABD9LwALIAUgBhD/OzYCoAMMFwsgBSAGEIA8NgKgAwwWCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2hQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0eIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR8gAyAKQTD8CgAAIAcgAxCGPiABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDB0LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELYtIAJBMEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVBmAFqIAVByAJqEJgrEN8hAkACQCAFKAKYASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVB9LT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCnAEQgBUgBUGwAWogAiARIA0QoxMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQdSy/wAQ8QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0xQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0dIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR4gAyAKQTD8CgAAIAcgAxD+PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBwLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELUtIAJBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJgrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiARIA0QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0XIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQfyx/wAQ8QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCwwZCwwYCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0cIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR0gAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBsLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVB+ABqIAVByAJqEJgrEOIhAkACQCAFKAJ4IgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUHgtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJ8EIAVIAVBsAFqIAIgESANEKITIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiILIAIpAwA3AwAgBUGvA2oiDiAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiALKQMANwAAIAFBGGogDikAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUGksf8AEPEJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsMGAsMFwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENcUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNGyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0cIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwaCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBqKj/ADYCzAIgBSABNgLIAiAFQegAaiAFQcgCahCYKxDeIQJAAkAgBSgCaCIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBkLT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCbBCAFSAFQbABaiACIBIgERCgEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCyAFQc8DaiIEIAVBwAFqIgcpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIGIAVB0AFqKQIANwMAIAVBmANqIgogBUHYAWopAgA3AwAgBUGoA2oiCyACKQMANwMAIAVBrwNqIg4gBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRUgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogCykDADcAACABQRhqIA4pAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCikDADcCACAFQbABaiAEIAFBrLP/ABDxCSAFLQD0ASIDQQJGBEAgBUHQA2ogBygCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0PIAVByAJqELsjDA8LDBcLDBYLIAVBwANqIQQjAEGQA2siASQAIAVBsAFqIgJBIGoQlzYgAUEIaiIGIAJB6ABqEMcUIAFBQGsiByACQTRqENkUAkBBDEEEEK02IgMEQCADQomSpMiQocKECTcCACADQQhqQYmSpMgANgIAIAIoAjAhCkEMQQQQrTYiAkUNGiACIAo2AgQgAkEVOgAAIAEgAjYCeCABIAM2AnQgAUEiOgBwIAFB2AFqIgMgBxDwPSABQbQCaiICIAMQoRsgAyACIAFB8ABqEIwYQcQAQQQQrTYiB0UNGyAHIAYQ7z0gAUEBNgK8AiABIAc2ArgCIAFBATYCtAIgAUH8AGoiByADIAIQ/CIgAiAHEM0cIAQgAhChCCABQZADaiQADAELDBkLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQjjsgBUHkAWoQtC0gBUGYAmoQii8gBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0NIAVB0AJqELsjDA0LDBULIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQdACahC7IwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0YIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRkgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBcLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVBiANqELsjDAsLDBMLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDNFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRcgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNGCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENUUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0XIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwVC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCSAFQYgDahC7IwwJCwwRCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0VIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRYgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBQLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAVBiANqELsjDAgLDBALIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDUFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRQgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFSADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM8UIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0UIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwSC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBiAFQYgDahC7IwwGCwwOCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0SIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRMgAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBELQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsS0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAVBiANqELsjDAULDA0LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDbFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDREgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNEiADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENAUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNECAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0RIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwPC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELMtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAyAFQYgDahC7IwwDCwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0PIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRAgAyAKQTD8CgAAIAcgAxD5PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDA4LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsi0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAVBiANqELsjDAILDAoLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDWFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDQ4gByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNDyADIApBMPwKAAAgByADEPc9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsS0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAHEKM8NgKgAwwDCyAFIAcQ/js2AqADDAILIAUgBxD8OzYCoAMMAQsgBSAHEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyACIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgAiADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvw6wIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADC0LIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgR4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEEUNLCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0yIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK8MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEKMoCyAFKAKIAiACaiAJOgAAIAUgAkEBajYCjAIgBSAFQbABaiAJIAEQhwsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTggBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwsCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCwLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjh4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNKiAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0yIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUEIaiAFQbABaiAJIAEQgwsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwqCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgx4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEEUNKCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0yIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEKsMISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiAJNgIAIAUgAkEBajYCjAIgBUEQaiAFQbABaiAJIAEQiAsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwoCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCoLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQih4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNJiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0yIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiAUEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhBANAIAEgAmopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgtBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AELMoCyAFKAKIAiACQQN0aiAlNwMAIAUgAkEBajYCjAIgBUEYaiAFQbABaiAlIAEQiwsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDiAESQRAIAYgDkEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDiACIA5LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTUgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwmCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCkLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQix4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEEUNJCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0uIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK8MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEKkZCyAFKAKIAiACaiAJOgAAIAUgAkEBajYCjAIgBUEgaiAFQbABaiAJIAEQiQsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwkCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQiR4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNIiAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0uIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUEoaiAFQbABaiAJIAEQhgsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTMgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwiCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEEUNICAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0uIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEKsMISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiAJNgIAIAUgAkEBajYCjAIgBUEwaiAFQbABaiAJIAEQigsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTIgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwgCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCYLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhx4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNHiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0uIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiAUEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhBANAIAEgAmopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgtBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AELMoCyAFKAKIAiACQQN0aiAlNwMAIAUgAkEBajYCjAIgBUE4aiAFQbABaiAlIAEQhQsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDiAESQRAIAYgDkEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDiACIA5LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTEgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwweCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCULIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhR4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNHCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0rIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUFAayAFQbABaiAJIAEQggsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTAgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwcCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCQLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiDUUNGiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0rIAUgBygCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKsMISQgBSgCsAEiAUEIayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhBANAIAEgAmopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAggJHqnQQN2IAJqIAlxIgtBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiArOAIAIAUgAkEBajYCjAIgBUHIAGogBUGwAWogKyABEIwLDAELIAFBACALa0EDdGpBBGsoAgAhAQsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAugBIgJLBEAgBCACayELIAUoAuABIg4gBEkEQCAGIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgC6AEhAgsgCwRAIAUoAuQBIAJqQQAgC/wLAAsgBSAENgLoAQsgBSAINgLsASAFKALkASAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFHDQJBkJ3/AAwBCyAGEOY6IAUoAtwBRQ0vIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCSAFKALgASIIIAFJBEAgBiAIQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIIIAQgCEsbEOgZIAUoAugBIQQLIAkEQCAFKALkASAEakEAIAn8CwALIAUgATYC6AELIAUgAjYC7AFBACEBIAUoAtgBIgIgBSgC0AFHDQFBgJ3/AAsQnSgLIAUoAtQBIAJBAnRqIAE2AgAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwjCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIIeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEPIeIAFBxABqIAIQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDRggBUHcAWohBiAFQdABaiEQIAVBkAJqIREgBUGEAmohDCAFQcABaiESQQAhAwNAAkAgEAJ/IAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NKyAFIAcoAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEiAFQdACahCsDCEkIAUoArABIgFBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQQDQCABIAJqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSILQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgBEEIaiIEaiAJcSECDAALAAsgDCgCCCEBAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKAKcAiICSwRAIAQgAmshCyAFKAKUAiIOIARJBEAgESAOQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyIOIAIgDksbEOgZIAUoApwCIQILIAsEQCAFKAKYAiACakEAIAv8CwALIAUgBDYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiICIAUoAoQCRgRAIAxBkJ3/ABCzKAsgBSgCiAIgAkEDdGogLDkDACAFIAJBAWo2AowCIAVB0ABqIAVBsAFqICwgARCECwwBCyABQQAgC2tBBHRqQQhrKAIAIQELIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASICSwRAIAQgAmshCyAFKALgASIOIARJBEAgBiAOQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyIOIAIgDksbEOgZIAUoAugBIQILIAsEQCAFKALkASACakEAIAv8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRw0CQZCd/wAMAQsgBhDmOiAFKALcAUUNLiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQkgBSgC4AEiCCABSQRAIAYgCEEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCCAEIAhLGxDoGSAFKALoASEECyAJBEAgBSgC5AEgBGpBACAJ/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhASAFKALYASICIAUoAtABRw0BQYCd/wALEJ0oCyAFKALUASACQQJ0aiABNgIAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDBgLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMIQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMIAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiByAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBxCmDAwdCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBELIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ8h4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0PIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohCSAFKAJYIQ4gBSgCXCERIwBBMGsiByQAAkAgESAFQbABaiIEKAIwRgRAIwBBQGoiAiQAIAIgETYCBCACIA42AgAgBCAOIBEQzQIhJCACIARBMGoiATYCPCACIARB6ABqIhg2AjggAiACNgI0IAIgATYCECACIBg2AgwgAiAENgIIIAJBGGohECACQTRqIQ8gAkEIaiIfIQFBACEKQQAhE0EAIRVBACEZQQAhGiMAQSBrIggkACAEQSBqIgYoAghFBEAgCEEYaiABQQhqKAIANgIAIAggASkCADcDECAIQQhqIRsjAEHgAGsiASQAIAEgCEEQajYCIAJAIAYoAgwiC0EBaiIMIAtPBEACQCAGKAIEIgsgC0EBakEDdkEHbCALQQhJGyILQQF2IAxJBEACQAJAIAtBAWoiCiAMIAogDEsbIgpBD08EQCAKQf////8BSw0BQX8gCkEDdEEHbkEBa2d2QQFqIQoMAgtBBEEIQRAgCkEISRsgCkEESRshCgwBCxDdJyABKAIcIQogASgCGCIMQYGAgIB4Rw0ECyABQdAAaiAGQRBqIg1BBCAKEPsUIAEoAlghCiABKAJUIQwgASgCUCILRQ0DIAEgASgCXDYCTCABIAo2AkggASAMNgJEIAEgCzYCQCABQRBqIAFBQGsQwTQgASgCFCIKBEAgASgCEEH/ASAK/AsACyABKAJIIQogASgCRCEMIAEoAkAiC0UNAyABIAEoAkw2AjwgASAKNgI4IAEgDDYCNCABIAs2AjAgAUKEgICAgAE3AiggASANNgIkIAFBMGohICABIAYoAgwiHAR/IAtBCGohISAGKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCATQQhqIRMgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIg0oAgAhFCABQQhqIA0oAgQgDSgCCCgCACAGKAIAICV6p0EDdiATakECdCIia0EEaygCABDKJSALIAwgFCABKAIIIAEoAgwQzQKnIiNxIg1qKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEUA0AgDSAUaiENIBRBCGohFCALIAwgDXEiDWopAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSALICZ6p0EDdiANaiAMcSINaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiENCyALIA1qICNBGXYiFDoAACAhIA1BCGsgDHFqIBQ6AAAgCyANQQJ0a0EEayAGKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAGKAIMBUEACyIMNgI8IAEgCiAMazYCOCAGICBBBBD6KiABQSRqEPUnDAELIAYgAUEgakHA3IABEO4JC0GBgICAeCEMDAELEN0nIAEoAgQhCiABKAIAIQwLIBsgCjYCBCAbIAw2AgAgAUHgAGokAAsgBigCBCIKICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAPKAIIIQ0gDygCBCETIA8oAgAhCyAGKAIAIQwDQAJAIAEgDGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgEAJ+AkADQCAlUA0BIAggEyANKAIAIAYoAgAgJXqnQQN2IAFqIApxIhRBAnRrQQRrKAIAEMolICVCAX0gJYMhJSALKAIAIAsoAgQgCCgCACAIKAIEEJ87RQ0ACyAQICQ3AwggECAGKAIAQQAgFGtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogCnEhFQtBASAlICZCAYaDUA0CGiAQIAwgFWosAABBAE4EfyAMKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBULNgIQIBAgJDcDCEIBCzcDACAQIAY2AhQgCEEgaiQADAILQQALIRkgASAaQQhqIhpqIApxIQEMAQsLIAIgETYCPCACIA42AjggAiAYNgI0IB8gECAPEIsTIAIoAhBBBGsoAgAhASACQZCAgIB4NgIYIBAQiBEgB0EEaiIGQZOAgIB4NgIAIAYgATYCBCACQUBrJAAgBygCCCEGIAcoAgQiAUGTgICAeEcEQCAJIAcpAgw3AgggCUEQaiAHQRRqKAIANgIAIAkgBjYCBCAJIAE2AgAMAgsCQCAEKAJABEAgBCgCUCIKQQFqIgxBA3YgDEEHcUEAR2oiASAEKAJMIgJLBEAgASACayEIIAQoAkQiCyABSQRAIARBQGsgC0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCyACIAtLGxDoGSAEKAJMIQILIAgEQCAEKAJIIAJqQQAgCPwLAAsgBCABNgJMCyAEIAw2AlAgBCgCSCAKQQN2aiIBIAEtAABBASAKQQdxdHI6AAAMAQsgBCAEKAJUQQFqNgJUCyAEKAI8IgEgBCgCNEYEQCAEQTRqQci1gAEQnSgLIAQoAjggAUECdGogBjYCACAJIAY2AgQgCUGTgICAeDYCACAEIAFBAWo2AjwMAQsgByARNgIcIAdBAjYCCCAHQaC3gAE2AgQgB0ICNwIQIAdBOzYCLCAHQZwDNgIkIAcgBEEwajYCICAHIAdBIGo2AgwgByAHQRxqNgIoIAlBBGogB0EEahCZDiAJQY2AgIB4NgIACyAHQTBqJAAgBSgCwAMiAUGTgICAeEYNASAAIAUpAsgDNwIIIABBEGogBUHQA2ooAgA2AgAgACAFKALEAzYCBCAAIAE2AgAgBUHQAWoQjjsgFxCzLSAFQZgCahCKLwwTCyAWEOY6IAUoAvABRQ0mIAUoAoACQQFqIgJBA3YgAkEHcUEAR2oiASAFKAL8ASIESwRAIAEgBGshByAFKAL0ASIGIAFJBEAgFiAGQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIGIAQgBksbEOgZIAUoAvwBIQQLIAcEQCAFKAL4ASAEakEAIAf8CwALIAUgATYC/AELIAUgAjYCgAIgBSgC7AEiASAFKALkAUYEQCAXQYCd/wAQnSgLIAUoAugBIAFBAnRqQQA2AgAgBSABQQFqNgLsAQsgHiADQQFqIgNHDQALDA8LIAMtAAIhECADLQABIREgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCIHiIHQQxqIgoQ2zwhAyAKENs8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDbPCISRQ0OIAVB3AFqIQYgBUHQAWohDiAFQZACaiEPIAVBhAJqIQwgBUHAAWohE0EAIQMDQAJAIA4CfyAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSMgBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQsgBSgCtAEiCCAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACECA0AgASAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgCyAkeqdBA3YgAWogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASABIAJBCGoiAmogCHEhAQwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCEEBaiILQQN2IAtBB3FBAEdqIgIgBSgCnAIiBEsEQCACIARrIQ0gBSgClAIiFSACSQRAIA8gFUEBdCIEIAJBwP///wNxQUBrIAIgAkE/cRsiFSAEIBVLGxDoGSAFKAKcAiEECyANBEAgBSgCmAIgBGpBACAN/AsACyAFIAI2ApwCCyAFIAs2AqACIAUoApgCIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAMQZCd/wAQnSgLIAUoAogCIAJBAnRqIAk2AgAgBSACQQFqNgKMAiAFQfAAaiAFQbABaiAJIAEQiAsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDScgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwOCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBsLIAMtAAIhDSADLQABIRAgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCNHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCIRRQ0MIAVB3AFqIQYgBUHQAWohEiAFQZACaiEOIAVBhAJqIQwgBUHAAWohD0EAIQMDQAJAIBICfyAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSMgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrAwhJCAFKAKwASIBQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEEA0AgASACaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiC0EEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIARBCGoiBGogCXEhAgwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgCnAIiAksEQCAEIAJrIQsgBSgClAIiEyAESQRAIA4gE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKAKcAiECCyALBEAgBSgCmAIgAmpBACAL/AsACyAFIAQ2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAMQZCd/wAQsygLIAUoAogCIAJBA3RqICU3AwAgBSACQQFqNgKMAiAFQYABaiAFQbABaiAlIAEQiwsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiEyAESQRAIAYgE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDSYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwMCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBoLIAMtAAIhDSADLQABIRAgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCGHiIGQQxqIgoQ2jwhAyAKENo8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEgQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDaPCIRRQ0KIAVB3AFqIQcgBUHQAWohEiAFQZACaiEOIAVBhAJqIQwgBUHAAWohD0EAIQMDQAJAIBICfyAGIAMQhyVFBEAgBSADNgLIAiAKENo8IANNDQsgBigCECADQQR0aiIBKQMAISUgBSABKQMIIiY3A9gCIAUgJTcD0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCwDCEkIAUoArABIgFBIGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hKEEAIQQDQCABIAJqKQAAIicgKIUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBECAIICR6p0EDdiACaiAJcSILQQV0a0EQEJ87DQQgJEIBfSAkgyIkUEUNAAsLICcgJ0IBhoNCgIGChIiQoMCAf4NQRQ0BIAIgBEEIaiIEaiAJcSECDAALAAsgDCgCCCEBAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKAKcAiICSwRAIAQgAmshCyAFKAKUAiITIARJBEAgDiATQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyITIAIgE0sbEOgZIAUoApwCIQILIAsEQCAFKAKYAiACakEAIAv8CwALIAUgBDYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiICIAUoAoQCRgRAIAxBkJ3/ABCxKAsgBSgCiAIgAkEEdGoiBCAmNwMIIAQgJTcDACAFIAJBAWo2AowCIAVBkAFqIAVBsAFqICUgJiABENQKDAELIAFBACALa0EFdGpBEGsoAgAhAQsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAugBIgJLBEAgBCACayELIAUoAuABIhMgBEkEQCAHIBNBAXQiAiAEQcD///8DcUFAayAEIARBP3EbIhMgAiATSxsQ6BkgBSgC6AEhAgsgCwRAIAUoAuQBIAJqQQAgC/wLAAsgBSAENgLoAQsgBSAINgLsASAFKALkASAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFHDQJBkJ3/AAwBCyAHEOY6IAUoAtwBRQ0lIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCSAFKALgASIIIAFJBEAgByAIQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIIIAQgCEsbEOgZIAUoAugBIQQLIAkEQCAFKALkASAEakEAIAn8CwALIAUgATYC6AELIAUgAjYC7AFBACEBIAUoAtgBIgIgBSgC0AFHDQFBgJ3/AAsQnSgLIAUoAtQBIAJBAnRqIAE2AgAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMCgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwZCyADLQACIQ0gAy0AASEQIAVBsAFqIgcgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgB4iBkEMaiIKENw8IQMgChDcPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAHQSBqIAFBEGpBNPwKAAAgB0HUAGogAUHEAGpBNPwKAAAgByAlNwMYIAcgJjcDECAHICQ3AwggByACNgIEIAcgAzYCACABQZABaiQAIAoQ3DwiEUUNCCAFQdwBaiEHIAVB0AFqIRIgBUGQAmohDiAFQYQCaiEMIAVBwAFqIQ9BACEDA0ACQCASAn8gBiADEIclRQRAIAUgAzYCyAIgChDcPCADTQ0LIAYoAhAgA0EFdGoiASkDACElIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICU3A8ADAkACQAJAIAUoArwBRQ0AIA8gBUHAA2oQrQwhJCAFKAKwASIBQTBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEEA0AgASACaikAACIpICqFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVBwANqQSAgCCAkeqdBA3YgAmogCXFBUGwiC2pBIBCfOw0EICRCAX0gJIMiJFBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIARBCGoiBGogCXEhAgwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgCnAIiAksEQCAEIAJrIQsgBSgClAIiEyAESQRAIA4gE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKAKcAiECCyALBEAgBSgCmAIgAmpBACAL/AsACyAFIAQ2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiBCAFKAKEAkYEQCAMELIoCyAFKAKIAiAEQQV0aiICICg3AxggAiAnNwMQIAIgJjcDCCACICU3AwAgBSAEQQFqNgKMAiAFQaABaiAFQbABaiAlICYgJyAoIAEQlwoMAQsgASALakEQaygCACEBCyAFQZCAgIB4NgLQAiAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiEyAESQRAIAcgE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAcQ5jogBSgC3AFFDSQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAHIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwICyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGUqNCgATYCACADQpSo0KDBgoWKFDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCkJ6z7tm0jZLpAIUgAykDKEKI9KuB4LHF5MIAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0iIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EO4pIAQQ0zoiCARAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQ4Q8gAygCuAEiAkGTgICAeEYNASAAIAMpAsABNwIIIABBEGogA0HIAWooAgA2AgAgACADKAK8ATYCBCAAIAI2AgAgARCOOyAKELMtIANBhAFqELosDAQLIAYQ5jogAygCXEUNJSADKAJsQQFqIgxBA3YgDEEHcUEAR2oiASADKAJoIgJLBEAgASACayEJIAMoAmAiCyABSQRAIAYgC0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCyACIAtLGxDoGSADKAJoIQILIAkEQCADKAJkIAJqQQAgCfwLAAsgAyABNgJoCyADIAw2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AEJ0oCyADKAJUIAFBAnRqQQA2AgAgAyABQQFqNgJYCyAIIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEENoRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCzLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCMLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO4pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0jIAMoAsgBIgFBvrX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiEMA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NKCADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIAMoAsABIAIQrB8gA0GsAWogA0EQaiADKAIAIAMoAgQQ4Q8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgDBD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNIyADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiCSABSQRAIAQgCUEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCSACIAlLGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENoRQdAAQQQQrTYiAUUNISABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuiwgA0GQAmokAAwXCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlqzYsAE2AgAgA0KWrNiw4cKFixY3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQsKM9/bqy9zRhH+FIAMpAyhC5ZP0mPmv+Oiof4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNISADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDUOhD0KSAEENQ6IggEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMENwPIAMoArgBIgJBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACACNgIAIAEQjjsgChCzLSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSQgAygCbEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshCSADKAJgIgsgAUkEQCAGIAtBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgsgAiALSxsQ6BkgAygCaCECCyAJBEAgAygCZCACakEAIAn8CwALIAMgATYCaAsgAyAMNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgCCAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBDdEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwiCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBcLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABD0KSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNIiADKALIASIBQb61/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohDANAAkACQCADKALEAQRAIAIgAygC1AFPDScgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADKALAASACEKwfIANBrAFqIANBEGogAygCACADKAIEENwPIAMoAqwBIgFBk4CAgHhGDQEgACADKQK0ATcCCCAAQRBqIANBvAFqKAIANgIAIAAgAygCsAE2AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAwQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSIgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIgkgAUkEQCAEIAlBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgkgAiAJSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCdKAsgAygCRCABQQJ0akEANgIAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDdEUHQAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELMtIANB9ABqELssIANBkAJqJAAMFgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNICADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDuKSAEENM6IggEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxD/FiADQbgBaiADQSBqIgEgAygCCCADKAIMEOAPIAMoArgBIgJBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACACNgIAIAEQjjsgChCzLSADQYQBahC6LAwECyAGEOY6IAMoAlxFDSMgAygCbEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshCSADKAJgIgsgAUkEQCAGIAtBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgsgAiALSxsQ6BkgAygCaCECCyAJBEAgAygCZCACakEAIAn8CwALIAMgATYCaAsgAyAMNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgCCAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBDWEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuiwgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwhCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBYLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDuKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSEgAygCyAEiAUGQtf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQwDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0mIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgA0HAAWogAhCtKiADQawBaiADQRBqIAMoAgAgAygCBBDgDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAMEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0hIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIJIAFJBEAgBCAJQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIJIAIgCUsbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1hFB0ABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC6LCADQZACaiQADBULIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGZsuTIATYCACADQpmy5MiRo8aMGTcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBC09jT+P3m9pJIhSADKQMoQqLYnojhoOrpzACFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDR8gAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQ9CkgBBDUOiIIBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDTDyADKAK4ASICQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgAjYCACABEI47IAoQsy0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0iIAMoAmxBAWoiDEEDdiAMQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQkgAygCYCILIAFJBEAgBiALQQF0IgIgAUHA////A3FBQGsgASABQT9xGyILIAIgC0sbEOgZIAMoAmghAgsgCQRAIAMoAmQgAmpBACAJ/AsACyADIAE2AmgLIAMgDDYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIAggB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ2BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwVCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ9CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0gIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiEMA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJSADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ0w8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgDBD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNICADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiCSABSQRAIAQgCUEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCSACIAlLGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENgRQdAAQQQQrTYiAUUNHiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuywgA0GQAmokAAwUCyABIAUoArgBQdCg/wAQ/S8ACyAFIAYQ/zs2AqADDBcLIAUgBhCAPDYCoAMMFgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENoUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0fIAMgCkEw/AoAACAHIAMQhj4gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwdCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC2LSACQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCWKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgECANEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiIMIAIpAwA3AwAgBUGvA2oiCSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAMKQMANwAAIAFBGGogCSkAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUHUsv8AEPIJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHSAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0eIAMgCkEw/AoAACAHIAMQ/j0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwcCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC1LSACQSBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQYgBaiAFQcgCahCWKxDdIQJAAkAgBSgCiAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQYi1/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAowBEIAVIAVBsAFqIAIgECANEKETIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0SIAVByAJqELsjDBILIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiIMIAIpAwA3AwAgBUGvA2oiCSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFyABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAMKQMANwAAIAFBGGogCSkAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUH8sf8AEPIJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0SIAVByAJqELsjDBILIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsMGQsMGAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENIUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHCAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0dIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwbCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQfgAaiAFQcgCahCWKxDiIQJAAkAgBSgCeCIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVB4LT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCfBCAFSAFQbABaiACIBAgDRCiEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCyAFQc8DaiIEIAVBwAFqIgcpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIGIAVB0AFqKQIANwMAIAVBmANqIgogBUHYAWopAgA3AwAgBUGoA2oiDCACKQMANwMAIAVBrwNqIgkgBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRYgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogDCkDADcAACABQRhqIAkpAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCikDADcCACAFQbABaiAEIAFBpLH/ABDyCSAFLQD0ASIDQQJGBEAgBUHQA2ogBygCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0QIAVByAJqELsjDBALDBgLDBcLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDXFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRsgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMGgsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQdCn/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlisQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiARIBAQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgwgAikDADcDACAFQa8DaiIJIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0VIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAwpAwA3AAAgAUEYaiAJKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQayz/wAQ8gkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNDyAFQcgCahC7IwwPCwwXCwwWCyAFQcADaiEEIwBBkANrIgEkACAFQbABaiICQSBqEJc2IAFBCGoiBiACQegAahDHFCABQUBrIgcgAkE0ahDUFAJAQQxBBBCtNiIDBEAgA0KIkKDAgIGChAg3AgAgA0EIakGIkKDAADYCACACKAIwIQpBDEEEEK02IgJFDRogAiAKNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAcQ8T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgdFDRsgByAGEO89IAFBATYCvAIgASAHNgK4AiABQQE2ArQCIAFB/ABqIgcgAyACEPwiIAIgBxDNHCAEIAIQowggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELMtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENgUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNGCAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0ZIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwXC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQYgDahC7IwwLCwwTCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0XIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRggAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDVFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRYgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFyADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENkUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFSAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0WIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwUC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCCAFQYgDahC7IwwICwwQCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0UIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRUgAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDPFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRMgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFCADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENEUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0TIAMgCkEw/AoAACAHIAMQ9z0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwRC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBSAFQYgDahC7IwwFCwwNCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0RIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRIgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDQFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRAgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNESADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM4UIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNDyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0QIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwOC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAiAFQYgDahC7IwwCCwwKCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0OIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDQ8gAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgBxCjPDYCoAMMAwsgBSAHEP47NgKgAwwCCyAFIAcQ/Ds2AqADDAELIAUgBxD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgAiADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAIgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQALhcUYAhZ/B34jAEGQCmsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwRBAAiCiADELsIBEAgCiEJIAEhBSACIQYMAQsgA0EEaiEHIAMoAgQhCyADLQAAIg1BAWshDiANQRtGIQ8gDUEbayEQIAohCSACIQYgASEFA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAktAAAiDARAIAxBIkYNASAQDggNDA4PDAwMEAwLIA4OJwEBAQEBAQEBAQsBAQEBAQEBAQEBAQEBAQEBAQsBAQsBCwELCwsLAQsLIAggAzYCSCAIIAk2AkwgCSgCBC0AAEECaw4IAgMEBQYHCAkBCyAIQUBrIAMgBSAGKAIkEQQAEKErIAAgCCkDQDcCBCAAQZOAgIB4NgIADLcDCyAIQQM2AlQgCEHs2/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLYDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhCIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQdiq/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIQiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMsDCyABQQhqIAUgBhCEIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMoDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANCxsy654zqoIW8f4UgASkDuANCutKR74r29PjMAIWEUA0DCyABQbADakHKAEEAQQFBARCgGCABKAK0AyECIAEoArADQQFHDQMMyQMLIAEoArgDIgNB9q//AEHGAPwKAAAgAELGADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMCgsgAigCECEHIAFBsANqIgUgA0EYahCoPhDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNAyABIAQ2ArAEIAEgAikCHDcCtAQgBSABQbAEaiICENkgGiACIANBDGoQvS0gASgCzAQiAiABKALQBEYNByABQegDaiEJIAFBjARqIQQgAUG0BGohCgNAAkACQAJAAkAgASgCtAQEQCACIAEoAsQETw3JAyABKAK4BCABKALABCACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLMBCABKAKwBCgCECACaiwAACICQQBODQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMzQMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNyAMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNCyACIAIoAgAiAkEBazYCACACQQFHDQsgChD7HgwLCyABQbADakEAIAcgAkECdGoiAigCACIDIAJBBGooAgAgA2sQiRALIAEoAswEIgIgASgC0ARHDQALDAcLIAFBsANqIgYgAkEMahCnLiABQcgBaiIJIAYQthMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUHYqv8ANgIgIAEgBTYCHCAGIAFBHGpB6KL/ACAHKAIAIgkgBBCGASABKAKwAyIFQZOAgIB4RwRAIAEpArQDIRsgACABKQK8AzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCtAM3AtQEIAFBsANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCuAMhBCABKAK0AyECIAEoArADIgVBk4CAgHhHBEAgACABKQK8AzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AuQCIAEgAjYC4AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFB1ARqEPgtIAFBHGoQ+C1NBEAgAUEoaiIGIAEoAtQEIAEoAtgEENMjIAFBsANqIgUgBhChGyABQbAEaiIGIAMQxwYgAUHIAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCuAQgASAHNgK0BCABQQE2ArAEIAFB7ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUHUBGoQ+C0gAUEcaiIDEPgtazYCJCABIAMQ8y02ArAEIAFBAzYCzAEgAUHoqf8ANgLIASABQgM3AtQBIAFBlww2AsQDIAFBrwM2ArwDIAFBOzYCtAMgASABQbADajYC0AEgASABQRhqNgLAAyABIAFBsARqNgK4AyABIAFBJGo2ArADIABBBGogAUHIAWoQqhggAEGGgICAeDYCACACIAIoAgAiAEEBazYCACAAQQFHDQsgAUHgAmoQuyMMCwsgAUGwA2oiAiABQcgBahCeCCACEOspIQJBwKP/AAwHCyABQbADaiICIAFByAFqEKQIIAIQ6ykhAkGYpP8ADAYLIAFBsANqIgIgAUHIAWoQogggAhDrKSECQfCk/wAMBQsgAUGwA2oiAiABQcgBahCgCCACEOspIQJByKX/AAwECyABQbADaiICIAFByAFqEJ0IIAIQ6ykhAkGgpv8ADAMLIAFBsANqIgIgAUHIAWoQnwggAhDrKSECQfim/wAMAgsgAUGwA2oiAiABQcgBahCjCCACEOspIQJB0Kf/AAwBCyABQbADaiICIAFByAFqEKEIIAIQ6ykhAkGoqP8ACzYCCCAAIAI2AgQgAEGTgICAeDYCACABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNDCABQRxqELsjDAwLIAFBAjYCtAMgAUGoqf8ANgKwAyABQgE3ArwDIAFBlww2ArQEIAEgAUGwBGo2ArgDIAEgAUEYajYCsAQgAEEEaiABQbADahCqGCAAQYKAgIB4NgIAIAFByAFqEP8mDAILDMYDCyABKALUBCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHUBGoQuyMLIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgASgCuAMiA0Horv8AQcoA/AoAACAAQcoANgIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwHCyACKAIQIQcgAUGwA2oiBSADQRhqEKg+EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC9LSABKALMBCICIAEoAtAERg0BIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcYDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJqLAAAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzKAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3FAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0FIAIgAigCACICQQFrNgIAIAJBAUcNBSAKEPseDAULIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMAQsACwJAIAEoArQEIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBtARqEPseCyABQcgBaiABQbADahDbDAsgAUGwA2oQ6SUgAUHoAmoiAiABQdQBaikCADcDACABQfACaiIDIAFB3AFqKAIANgIAIAEgASkCzAE3A+ACIAEoAsgBIgRBgICAgHhGBEAgACABKQPgAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAQLIAFBpAJqIgMgAUHgAWpBJPwKAAAgAUHQAmoiBSABQegCaikDADcDACABQdgCaiIGIAFB8AJqKAIANgIAIAEgASkD4AI3A8gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDyAI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAQLDMADCyABKAK4AyIDQbKv/wBBxAD8CgAAIABCxAA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAILAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENwMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUH0AmoiAyABQeABakEk/AoAACABQaADaiIFIAFB6AJqKQMANwMAIAFBqANqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDmAMQsD5BxABBBBCtNiICRQ29AyACIAQ2AgggAkKBgICAEDcCACACIAEpA5gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwy1AwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAiAkEXaw4EAgEBAwALIAJBIkYNAwsgAUGwA2ogBSAGEIMiIgVBPGpB6KL/ACADIAQQhgEgASgCuAMhAyABKAK0AyECIAEoArADIgRBk4CAgHhHBEAgACABKQK8AzcCDCAAIAM2AgggACACNgIEIAAgBDYCAAwPCyABIAM2AswBIAEgAjYCyAEgACACIAMoAghBAWtBeHFqQQhqIAMgBUEMakGQrv8AEJMBIAIgAigCACIAQQFrNgIAIABBAUcNDiABQcgBahC7IwwOCyABIAUgBhCDIiIDQTxqELkmIAFBsANqIAEoAgAiAiABKAIEKAIMEQAAIAIEQCABKQOwA0KQnrPu2bSNkukAhSABKQO4A0KI9KuB4LHF5MIAhYRQDQQLIAFBsANqQcYAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAgzKAwsgAUEIaiAFIAYQgyIiA0E8ahC5JiABQbADaiABKAIIIgIgASgCDCgCDBEAACACBEAgASkDsANCx9n0597Etpx3hSABKQO4A0KNss6UjMqS5qd/hYRQDQYLIAFBsANqQcQAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNCQzJAwsgASADQQRqIgc2AhggAUEQaiAFIAYoAhARAAAgAUGwA2ogASgCECICIAEoAhQoAgwRAAAgAgRAIAEpA7ADQpOT7vXoqIKWZ4UgASkDuANCmJLh6biI4pZphYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzIAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENk8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC/LSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcgDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBAXRqLgEAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzMAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3HAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMBwsgAUGwA2oiBiACQQxqEKUuIAFByAFqIgkgBhC9ExCwPgJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGogCUEw/AoAACABQZCu/wA2AiAgASAFNgIcIAYgAUEcakHoov8AIAcoAgAiCSAEEIYBIAEoArADIgVBk4CAgHhHBEAgASkCtAMhGyAAIAEpArwDNwIMIAAgGzcCBCAAIAU2AgAMAwsgASABKQK0AzcC1AQgAUGwA2ogAkE8akHoov8AIAMoAgggBBCGASABKAK4AyEEIAEoArQDIQIgASgCsAMiBUGTgICAeEcEQCAAIAEpArwDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC5AIgASACNgLgAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUHUBGoQ+C0gAUEcahD4LU0EQCABQShqIgYgASgC1AQgASgC2AQQ0yMgAUGwA2oiBSAGEKEbIAFBsARqIgYgAxDHBiABQcgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgK4BCABIAc2ArQEIAFBATYCsAQgAUHsAGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQdQEahD4LSABQRxqIgMQ+C1rNgIkIAEgAxDzLTYCsAQgAUEDNgLMASABQeip/wA2AsgBIAFCAzcC1AEgAUGXDDYCxAMgAUGvAzYCvAMgAUE7NgK0AyABIAFBsANqNgLQASABIAFBGGo2AsADIAEgAUGwBGo2ArgDIAEgAUEkajYCsAMgAEEEaiABQcgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQeACahC7IwwLCyABQbADaiICIAFByAFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBsANqIgIgAUHIAWoQpAggAhDrKSECQZik/wAMBgsgAUGwA2oiAiABQcgBahCiCCACEOspIQJB8KT/AAwFCyABQbADaiICIAFByAFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBsANqIgIgAUHIAWoQnQggAhDrKSECQaCm/wAMAwsgAUGwA2oiAiABQcgBahCfCCACEOspIQJB+Kb/AAwCCyABQbADaiICIAFByAFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBsANqIgIgAUHIAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0MIAFBHGoQuyMMDAsgAUECNgK0AyABQaip/wA2ArADIAFCATcCvAMgAUGXDDYCtAQgASABQbAEajYCuAMgASABQRhqNgKwBCAAQQRqIAFBsANqEKoYIABBgoCAgHg2AgAgAUHIAWoQ/yYMAgsMxQMLIAEoAtQEIgAgACgCACIAQQFrNgIAIABBAUcNACABQdQEahC7IwsgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQggAUEcahC7IwwICyABKAK4AyIDQeiu/wBBygD8CgAAIABBygA2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAcLIAIoAhAhByABQbADaiIFIANBGGoQ2TwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEL8tIAEoAswEIgIgASgC0ARGDQEgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NxQMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkEBdGouAQAiAkEATg0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMkDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcQDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIAJBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMvwMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbwDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDLQDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhyIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQYis/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIciIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMkDCyABQQhqIAUgBhCHIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMgDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANC2s6AyavF6v3HAIUgASkDuANCm/Tdt5mL044/hYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzHAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENs8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahDALSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDccDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBAnRqKAIAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzLAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3GAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMBwsgAUGwA2oiBiACQQxqEKkuIAFByAFqIgkgBhCtExCwPgJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGogCUEw/AoAACABQYis/wA2AiAgASAFNgIcIAYgAUEcakHoov8AIAcoAgAiCSAEEIYBIAEoArADIgVBk4CAgHhHBEAgASkCtAMhGyAAIAEpArwDNwIMIAAgGzcCBCAAIAU2AgAMAwsgASABKQK0AzcC1AQgAUGwA2ogAkE8akHoov8AIAMoAgggBBCGASABKAK4AyEEIAEoArQDIQIgASgCsAMiBUGTgICAeEcEQCAAIAEpArwDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC5AIgASACNgLgAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUHUBGoQ+C0gAUEcahD4LU0EQCABQShqIgYgASgC1AQgASgC2AQQ0yMgAUGwA2oiBSAGEKEbIAFBsARqIgYgAxDHBiABQcgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgK4BCABIAc2ArQEIAFBATYCsAQgAUHsAGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQdQEahD4LSABQRxqIgMQ+C1rNgIkIAEgAxDzLTYCsAQgAUEDNgLMASABQeip/wA2AsgBIAFCAzcC1AEgAUGXDDYCxAMgAUGvAzYCvAMgAUE7NgK0AyABIAFBsANqNgLQASABIAFBGGo2AsADIAEgAUGwBGo2ArgDIAEgAUEkajYCsAMgAEEEaiABQcgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQeACahC7IwwLCyABQbADaiICIAFByAFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBsANqIgIgAUHIAWoQpAggAhDrKSECQZik/wAMBgsgAUGwA2oiAiABQcgBahCiCCACEOspIQJB8KT/AAwFCyABQbADaiICIAFByAFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBsANqIgIgAUHIAWoQnQggAhDrKSECQaCm/wAMAwsgAUGwA2oiAiABQcgBahCfCCACEOspIQJB+Kb/AAwCCyABQbADaiICIAFByAFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBsANqIgIgAUHIAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0MIAFBHGoQuyMMDAsgAUECNgK0AyABQaip/wA2ArADIAFCATcCvAMgAUGXDDYCtAQgASABQbAEajYCuAMgASABQRhqNgKwBCAAQQRqIAFBsANqEKoYIABBgoCAgHg2AgAgAUHIAWoQ/yYMAgsMxAMLIAEoAtQEIgAgACgCACIAQQFrNgIAIABBAUcNACABQdQEahC7IwsgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQggAUEcahC7IwwICyABKAK4AyIDQeiu/wBBygD8CgAAIABBygA2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAcLIAIoAhAhByABQbADaiIFIANBGGoQ2zwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEMAtIAEoAswEIgIgASgC0ARGDQEgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NxAMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkECdGooAgAiAkEATg0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMgDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcMDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIAJBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMvgMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbsDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDLMDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhSIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQeCs/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIUiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMgDCyABQQhqIAUgBhCFIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMcDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANC/Ou54rzv+NByhSABKQO4A0La45+NzI/hgal/hYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzGAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENg8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC+LSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcYDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBA3RqKQMAIhtCgICAgBBUDQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMygMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNxQMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNCyACIAIoAgAiAkEBazYCACACQQFHDQsgChD7HgwLCyABQbADakEAIAcgG6dBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwHCyABQbADaiIGIAJBDGoQqC4gAUHIAWoiCSAGELETELA+AkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiAJQTD8CgAAIAFB4Kz/ADYCICABIAU2AhwgBiABQRxqQeii/wAgBygCACIJIAQQhgEgASgCsAMiBUGTgICAeEcEQCABKQK0AyEbIAAgASkCvAM3AgwgACAbNwIEIAAgBTYCAAwDCyABIAEpArQDNwLUBCABQbADaiACQTxqQeii/wAgAygCCCAEEIYBIAEoArgDIQQgASgCtAMhAiABKAKwAyIFQZOAgIB4RwRAIAAgASkCvAM3AgwgACAENgIIIAAgAjYCBCAAIAU2AgAMAgsgASAENgLkAiABIAI2AuACAkAgAAJ/AkACQAJAAkACQAJAAkACQCABQdQEahD4LSABQRxqEPgtTQRAIAFBKGoiBiABKALUBCABKALYBBDTIyABQbADaiIFIAYQoRsgAUGwBGoiBiADEMcGIAFByAFqIgMgBSAGEIwYEKgvIQcgBSACIAQQ0yMgByAFQcQA/AoAACABQQE2ArgEIAEgBzYCtAQgAUEBNgKwBCABQewAaiICIAMgBhD8IiADIAIQzRwgCS0AAEECaw4IAQIDBAUGBwgKCyABIAFB1ARqEPgtIAFBHGoiAxD4LWs2AiQgASADEPMtNgKwBCABQQM2AswBIAFB6Kn/ADYCyAEgAUIDNwLUASABQZcMNgLEAyABQa8DNgK8AyABQTs2ArQDIAEgAUGwA2o2AtABIAEgAUEYajYCwAMgASABQbAEajYCuAMgASABQSRqNgKwAyAAQQRqIAFByAFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB4AJqELsjDAsLIAFBsANqIgIgAUHIAWoQngggAhDrKSECQcCj/wAMBwsgAUGwA2oiAiABQcgBahCkCCACEOspIQJBmKT/AAwGCyABQbADaiICIAFByAFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBsANqIgIgAUHIAWoQoAggAhDrKSECQcil/wAMBAsgAUGwA2oiAiABQcgBahCdCCACEOspIQJBoKb/AAwDCyABQbADaiICIAFByAFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBsANqIgIgAUHIAWoQowggAhDrKSECQdCn/wAMAQsgAUGwA2oiAiABQcgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQwgAUEcahC7IwwMCyABQQI2ArQDIAFBqKn/ADYCsAMgAUIBNwK8AyABQZcMNgK0BCABIAFBsARqNgK4AyABIAFBGGo2ArAEIABBBGogAUGwA2oQqhggAEGCgICAeDYCACABQcgBahD/JgwCCwzDAwsgASgC1AQiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFB1ARqELsjCyABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNCCABQRxqELsjDAgLIAEoArgDIgNB6K7/AEHKAPwKAAAgAEHKADYCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMBwsgAigCECEHIAFBsANqIgUgA0EYahDYPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNACABIAQ2ArAEIAEgAikCHDcCtAQgBSABQbAEaiICENkgGiACIANBDGoQvi0gASgCzAQiAiABKALQBEYNASABQegDaiEJIAFBjARqIQQgAUG0BGohCgNAAkACQAJAAkAgASgCtAQEQCACIAEoAsQETw3DAyABKAK4BCABKALABCACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLMBCABKAKwBCgCECACQQN0aikDACIbQoCAgIAQVA0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMcDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcIDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIBunQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMAQsACwJAIAEoArQEIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBtARqEPseCyABQcgBaiABQbADahDbDAsgAUGwA2oQ6SUgAUHoAmoiAiABQdQBaikCADcDACABQfACaiIDIAFB3AFqKAIANgIAIAEgASkCzAE3A+ACIAEoAsgBIgRBgICAgHhGBEAgACABKQPgAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAQLIAFBpAJqIgMgAUHgAWpBJPwKAAAgAUHQAmoiBSABQegCaikDADcDACABQdgCaiIGIAFB8AJqKAIANgIAIAEgASkD4AI3A8gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDyAI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAQLDL0DCyABKAK4AyIDQbKv/wBBxAD8CgAAIABCxAA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAILAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENwMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUH0AmoiAyABQeABakEk/AoAACABQaADaiIFIAFB6AJqKQMANwMAIAFBqANqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDmAMQsD5BxABBBBCtNiICRQ26AyACIAQ2AgggAkKBgICAEDcCACACIAEpA5gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwyyAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQcADaiAFIAYQiSIiBUE8akHoov8AIAMgBBCGASABKALIAyEDIAEoAsQDIQIgASgCwAMiBEGTgICAeEcEQCAAIAEpAswDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA0LIAEgAzYC3AEgASACNgLYASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQbit/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0MIAFB2AFqELsjDAwLIAFBCGogBSAGEIkiIgNBPGoQuSYgAUHAA2ogASgCCCICIAEoAgwoAgwRAAAgAgRAIAEpA8ADQpCes+7ZtI2S6QCFIAEpA8gDQoj0q4HgscXkwgCFhFANBAsgAUHAA2pBxgBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0CDMcDCyABQRBqIAUgBhCJIiIDQTxqELkmIAFBwANqIAEoAhAiAiABKAIUKAIMEQAAIAIEQCABKQPAA0LH2fTn3sS2nHeFIAEpA8gDQo2yzpSMypLmp3+FhFANBgsgAUHAA2pBxABBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0IDMYDCyABIANBBGoiBzYCICABQRhqIAUgBigCEBEAACABQcADaiABKAIYIgIgASgCHCgCDBEAACACBEAgASkDwANC/Pb4rvGI1KEVhSABKQPIA0LvytP9o9G+0fAAhYRQDQMLIAFBwANqQcoAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAwzFAwsgASgCyAMiAkH2r/8AQcYA/AoAACAAQsYANwIMIAAgAjYCCCAAIAM2AgQgAEGGgICAeDYCAAwICyACKAIQIQogAUHAA2oiBSADQRhqEKg+EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCvAQgASACKQIcNwLABCAFIAFBvARqIgIQ2SAaIAIgA0EMahC9LSABKALYBCICIAEoAtwEIgtGBEAgASgCwAQhBAwHCyABQfgDaiEMIAFBnARqIQYgASgCwAQhBANAAkACQCAERQ0AIAIgASgC0ARPDcADIAEoAsQEIAIgASgCzARqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcUUNACABIAJBAWo2AtgEIAYQ5jogASgCnARFDcEDIAEoAqwEQQFqIgdBA3YgB0EHcUEAR2oiBSABKAKoBCIDSwRAIAUgA2shCSABKAKgBCINIAVJBEAgBiANQQF0IgMgBUHA////A3FBQGsgBSAFQT9xGyINIAMgDUsbEOgZIAEoAqgEIQMLIAkEQCABKAKkBCADakEAIAn8CwALIAEgBTYCqAQLIAEgBzYCrAQgASgCgAQiAyABKAL4A0YEQCAMQaCd/wAQsSgLIAEoAvwDIANBBHRqIgVCADcDCCAFQgA3AwAgASADQQFqNgKABAwBCyABIAJBAWo2AtgEIAFBwANqQQAgCiABKAK8BCgCECACai0AAEECdGoiAygCACIFIANBBGooAgAgBWsQiRAMAAsgAkEBaiICIAtHDQALDAYLIAFBwANqIgYgAkEMahCnLiABQdgBaiIJIAYQuBMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUG4rf8ANgIoIAEgBTYCJCAGIAFBJGpB6KL/ACAHKAIAIgkgBBCGASABKALAAyIFQZOAgIB4RwRAIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCxAM3AiwgAUHAA2ogAkE8akHoov8AIAMoAgggBBCGASABKALIAyEEIAEoAsQDIQIgASgCwAMiBUGTgICAeEcEQCAAIAEpAswDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC9AIgASACNgLwAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUEsahD4LSABQSRqEPgtTQRAIAFBOGoiBiABKAIsIAEoAjAQ0yMgAUHAA2oiBSAGEKEbIAFBvARqIgYgAxDHBiABQdgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgLEBCABIAc2AsAEIAFBATYCvAQgAUH8AGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQSxqEPgtIAFBJGoiAxD4LWs2AjQgASADEPMtNgK8BCABQQM2AtwBIAFB6Kn/ADYC2AEgAUIDNwLkASABQZcMNgLUAyABQa8DNgLMAyABQTs2AsQDIAEgAUHAA2o2AuABIAEgAUEgajYC0AMgASABQbwEajYCyAMgASABQTRqNgLAAyAAQQRqIAFB2AFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB8AJqELsjDAsLIAFBwANqIgIgAUHYAWoQngggAhDrKSECQcCj/wAMBwsgAUHAA2oiAiABQdgBahCkCCACEOspIQJBmKT/AAwGCyABQcADaiICIAFB2AFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBwANqIgIgAUHYAWoQoAggAhDrKSECQcil/wAMBAsgAUHAA2oiAiABQdgBahCdCCACEOspIQJBoKb/AAwDCyABQcADaiICIAFB2AFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBwANqIgIgAUHYAWoQowggAhDrKSECQdCn/wAMAQsgAUHAA2oiAiABQdgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQogAUEkahC7IwwKCyABQQI2AsQDIAFBqKn/ADYCwAMgAUIBNwLMAyABQZcMNgLABCABIAFBvARqNgLIAyABIAFBIGo2ArwEIABBBGogAUHAA2oQqhggAEGCgICAeDYCACABQdgBahD/JgwCCwzAAwsgASgCLCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEsahC7IwsgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAUEkahC7IwwGCyABKALIAyICQeiu/wBBygD8CgAAIABBygA2AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAULIAIoAhAhCiABQcADaiIFIANBGGoQqD4QxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgK8BCABIAIpAhw3AsAEIAUgAUG8BGoiAhDZIBogAiADQQxqEL0tIAEoAtgEIgIgASgC3AQiC0YEQCABKALABCEEDAILIAFB+ANqIQwgAUGcBGohBiABKALABCEEA0ACQAJAIARFDQAgAiABKALQBE8NvQMgASgCxAQgAiABKALMBGoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYC2AQgBhDmOiABKAKcBEUNvgMgASgCrARBAWoiB0EDdiAHQQdxQQBHaiIFIAEoAqgEIgNLBEAgBSADayEJIAEoAqAEIg0gBUkEQCAGIA1BAXQiAyAFQcD///8DcUFAayAFIAVBP3EbIg0gAyANSxsQ6BkgASgCqAQhAwsgCQRAIAEoAqQEIANqQQAgCfwLAAsgASAFNgKoBAsgASAHNgKsBCABKAKABCIDIAEoAvgDRgRAIAxBoJ3/ABCxKAsgASgC/AMgA0EEdGoiBUIANwMIIAVCADcDACABIANBAWo2AoAEDAELIAEgAkEBajYC2AQgAUHAA2pBACAKIAEoArwEKAIQIAJqLQAAQQJ0aiIDKAIAIgUgA0EEaigCACAFaxCJEAwACyACQQFqIgIgC0cNAAsMAQsACwJAIARFDQAgBCAEKAIAIgJBAWs2AgAgAkEBRw0AIAFBwARqEPseCyABQdgBaiABQcADaiICENsMIAIQ6SUgAUH4AmoiAiABQeQBaikCADcDACABQYADaiIDIAFB7AFqKAIANgIAIAEgASkC3AE3A/ACIAEoAtgBIgRBgICAgHhGBEAgACABKQPwAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAMLIAFBtAJqIgMgAUHwAWpBJPwKAAAgAUHgAmoiBSABQfgCaikDADcDACABQegCaiIGIAFBgANqKAIANgIAIAEgASkD8AI3A9gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkD2AI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAMLDLsDCyABKALIAyICQbKv/wBBxAD8CgAAIABCxAA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAELAkAgBEUNACAEIAQoAgAiAkEBazYCACACQQFHDQAgAUHABGoQ+x4LIAFB2AFqIAFBwANqIgIQ3AwgAhDpJSABQfgCaiICIAFB5AFqKQIANwMAIAFBgANqIgMgAUHsAWooAgA2AgAgASABKQLcATcD8AIgASgC2AEiBEGAgICAeEYEQCAAIAEpA/ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUGEA2oiAyABQfABakEk/AoAACABQbADaiIFIAFB+AJqKQMANwMAIAFBuANqIgYgAUGAA2ooAgA2AgAgASABKQPwAjcDqAMQsD5BxABBBBCtNiICRQ25AyACIAQ2AgggAkKBgICAEDcCACACIAEpA6gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwyxAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQcADaiAFIAYQiCIiBUE8akHoov8AIAMgBBCGASABKALIAyEDIAEoAsQDIQIgASgCwAMiBEGTgICAeEcEQCAAIAEpAswDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA0LIAEgAzYC3AEgASACNgLYASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQZCi/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0MIAFB2AFqELsjDAwLIAFBCGogBSAGEIgiIgNBPGoQuSYgAUHAA2ogASgCCCICIAEoAgwoAgwRAAAgAgRAIAEpA8ADQpCes+7ZtI2S6QCFIAEpA8gDQoj0q4HgscXkwgCFhFANBAsgAUHAA2pBxgBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0CDMYDCyABQRBqIAUgBhCIIiIDQTxqELkmIAFBwANqIAEoAhAiAiABKAIUKAIMEQAAIAIEQCABKQPAA0LH2fTn3sS2nHeFIAEpA8gDQo2yzpSMypLmp3+FhFANBgsgAUHAA2pBxABBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0IDMUDCyABIANBBGoiBzYCICABQRhqIAUgBigCEBEAACABQcADaiABKAIYIgIgASgCHCgCDBEAACACBEAgASkDwANChrKY2Z2pt6ZuhSABKQPIA0Ldr7vZ27bP1maFhFANAwsgAUHAA2pBygBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0DDMQDCyABKALIAyICQfav/wBBxgD8CgAAIABCxgA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAgLIAIoAhAhCyABQcADaiIFIANBGGoQ2TwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQMgASAENgK8BCABIAIpAhw3AsAEIAUgAUG8BGoiAhDZIBogAiADQQxqEL8tIAEoAtgEIgIgASgC3AQiDEYEQCABKALABCEDDAcLIAJBAXQhBCABQfgDaiENIAFBnARqIQcgASgCwAQhAwNAAkACQCADRQ0AIAIgASgC0ARPDb8DIAEoAsQEIAIgASgCzARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2AtgEIAcQ5jogASgCnARFDcADIAEoAqwEQQFqIglBA3YgCUEHcUEAR2oiBiABKAKoBCIFSwRAIAYgBWshCiABKAKgBCIOIAZJBEAgByAOQQF0IgUgBkHA////A3FBQGsgBiAGQT9xGyIOIAUgDksbEOgZIAEoAqgEIQULIAoEQCABKAKkBCAFakEAIAr8CwALIAEgBjYCqAQLIAEgCTYCrAQgASgCgAQiBSABKAL4A0YEQCANQaCd/wAQsSgLIAEoAvwDIAVBBHRqIgZCADcDCCAGQgA3AwAgASAFQQFqNgKABAwBCyABIAJBAWo2AtgEIAFBwANqQQAgCyABKAK8BCgCECAEai8BAEECdGoiBSgCACIGIAVBBGooAgAgBmsQiRAMAAsgBEECaiEEIAJBAWoiAiAMRw0ACwwGCyABQcADaiIGIAJBDGoQpS4gAUHYAWoiCSAGEKoTELA+AkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiAJQTD8CgAAIAFBkKL/ADYCKCABIAU2AiQgBiABQSRqQeii/wAgBygCACIJIAQQhgEgASgCwAMiBUGTgICAeEcEQCABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIAAgBTYCAAwDCyABIAEpAsQDNwIsIAFBwANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCyAMhBCABKALEAyECIAEoAsADIgVBk4CAgHhHBEAgACABKQLMAzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AvQCIAEgAjYC8AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFBLGoQ+C0gAUEkahD4LU0EQCABQThqIgYgASgCLCABKAIwENMjIAFBwANqIgUgBhChGyABQbwEaiIGIAMQxwYgAUHYAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCxAQgASAHNgLABCABQQE2ArwEIAFB/ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUEsahD4LSABQSRqIgMQ+C1rNgI0IAEgAxDzLTYCvAQgAUEDNgLcASABQeip/wA2AtgBIAFCAzcC5AEgAUGXDDYC1AMgAUGvAzYCzAMgAUE7NgLEAyABIAFBwANqNgLgASABIAFBIGo2AtADIAEgAUG8BGo2AsgDIAEgAUE0ajYCwAMgAEEEaiABQdgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQfACahC7IwwLCyABQcADaiICIAFB2AFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBwANqIgIgAUHYAWoQpAggAhDrKSECQZik/wAMBgsgAUHAA2oiAiABQdgBahCiCCACEOspIQJB8KT/AAwFCyABQcADaiICIAFB2AFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBwANqIgIgAUHYAWoQnQggAhDrKSECQaCm/wAMAwsgAUHAA2oiAiABQdgBahCfCCACEOspIQJB+Kb/AAwCCyABQcADaiICIAFB2AFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBwANqIgIgAUHYAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAFBJGoQuyMMCgsgAUECNgLEAyABQaip/wA2AsADIAFCATcCzAMgAUGXDDYCwAQgASABQbwEajYCyAMgASABQSBqNgK8BCAAQQRqIAFBwANqEKoYIABBgoCAgHg2AgAgAUHYAWoQ/yYMAgsMvwMLIAEoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBLGoQuyMLIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAFBJGoQuyMMBgsgASgCyAMiAkHorv8AQcoA/AoAACAAQcoANgIMIAAgAjYCCCAAIAM2AgQgAEGGgICAeDYCAAwFCyACKAIQIQsgAUHAA2oiBSADQRhqENk8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCvAQgASACKQIcNwLABCAFIAFBvARqIgIQ2SAaIAIgA0EMahC/LSABKALYBCICIAEoAtwEIgxGBEAgASgCwAQhAwwCCyACQQF0IQQgAUH4A2ohDSABQZwEaiEHIAEoAsAEIQMDQAJAAkAgA0UNACACIAEoAtAETw28AyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASACQQFqNgLYBCAHEOY6IAEoApwERQ29AyABKAKsBEEBaiIJQQN2IAlBB3FBAEdqIgYgASgCqAQiBUsEQCAGIAVrIQogASgCoAQiDiAGSQRAIAcgDkEBdCIFIAZBwP///wNxQUBrIAYgBkE/cRsiDiAFIA5LGxDoGSABKAKoBCEFCyAKBEAgASgCpAQgBWpBACAK/AsACyABIAY2AqgECyABIAk2AqwEIAEoAoAEIgUgASgC+ANGBEAgDUGgnf8AELEoCyABKAL8AyAFQQR0aiIGQgA3AwggBkIANwMAIAEgBUEBajYCgAQMAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGovAQBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAALIARBAmohBCACQQFqIgIgDEcNAAsMAQsACwJAIANFDQAgAyADKAIAIgJBAWs2AgAgAkEBRw0AIAFBwARqEPseCyABQdgBaiABQcADaiICENsMIAIQ6SUgAUH4AmoiAiABQeQBaikCADcDACABQYADaiIDIAFB7AFqKAIANgIAIAEgASkC3AE3A/ACIAEoAtgBIgRBgICAgHhGBEAgACABKQPwAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAMLIAFBtAJqIgMgAUHwAWpBJPwKAAAgAUHgAmoiBSABQfgCaikDADcDACABQegCaiIGIAFBgANqKAIANgIAIAEgASkD8AI3A9gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkD2AI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAMLDLoDCyABKALIAyICQbKv/wBBxAD8CgAAIABCxAA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAELAkAgA0UNACADIAMoAgAiAkEBazYCACACQQFHDQAgAUHABGoQ+x4LIAFB2AFqIAFBwANqIgIQ3AwgAhDpJSABQfgCaiICIAFB5AFqKQIANwMAIAFBgANqIgMgAUHsAWooAgA2AgAgASABKQLcATcD8AIgASgC2AEiBEGAgICAeEYEQCAAIAEpA/ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUGEA2oiAyABQfABakEk/AoAACABQbADaiIFIAFB+AJqKQMANwMAIAFBuANqIgYgAUGAA2ooAgA2AgAgASABKQPwAjcDqAMQsD5BxABBBBCtNiICRQ24AyACIAQ2AgggAkKBgICAEDcCACACIAEpA6gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwywAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAiAkEXaw4EAgEBAwALIAJBIkYNAwsgAUHAA2ogBSAGEIoiIgVBPGpB6KL/ACADIAQQhgEgASgCyAMhAyABKALEAyECIAEoAsADIgRBk4CAgHhHBEAgACABKQLMAzcCDCAAIAM2AgggACACNgIEIAAgBDYCAAwPCyABIAM2AtwBIAEgAjYC2AEgACACIAMoAghBAWtBeHFqQQhqIAMgBUEMakGAqv8AEJMBIAIgAigCACIAQQFrNgIAIABBAUcNDiABQdgBahC7IwwOCyABQQhqIAUgBhCKIiIDQTxqELkmIAFBwANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQPAA0KQnrPu2bSNkukAhSABKQPIA0KI9KuB4LHF5MIAhYRQDQQLIAFBwANqQcYAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAgzHAwsgAUEQaiAFIAYQiiIiA0E8ahC5JiABQcADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDwANCx9n0597Etpx3hSABKQPIA0KNss6UjMqS5qd/hYRQDQULIAFBwANqQcQAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAwzGAwsgASADQQRqIgc2AiAgAUEYaiAFIAYoAhARAAAgAUHAA2ogASgCGCICIAEoAhwoAgwRAAAgAgRAIAEpA8ADQvLI+sP06YyY8wCFIAEpA8gDQvC4kO3DhNv9ToWEUA0GCyABQcADakHKAEEAQQFBARCgGCABKALEAyEDIAEoAsADQQFHDQQMxQMLIAEoAsgDIgJB9q//AEHGAPwKAAAgAELGADcCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMCgsgAigCECELIAFBwANqIgUgA0EYahDbPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNBCABIAQ2ArwEIAEgAikCHDcCwAQgBSABQbwEaiICENkgGiACIANBDGoQwC0gASgC2AQiAiABKALcBCIMRgRAIAEoAsAEIQMMCQsgAkECdCEEIAFB+ANqIQ0gAUGcBGohByABKALABCEDA0ACQAJAIAMEQCACIAEoAtAETw3BAyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGooAgBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAELIAEgAkEBajYC2AQgBxDmOiABKAKcBEUNwAMgASgCrARBAWoiCUEDdiAJQQdxQQBHaiIGIAEoAqgEIgVLBEAgBiAFayEKIAEoAqAEIg4gBkkEQCAHIA5BAXQiBSAGQcD///8DcUFAayAGIAZBP3EbIg4gBSAOSxsQ6BkgASgCqAQhBQsgCgRAIAEoAqQEIAVqQQAgCvwLAAsgASAGNgKoBAsgASAJNgKsBCABKAKABCIFIAEoAvgDRgRAIA1BoJ3/ABCxKAsgASgC/AMgBUEEdGoiBkIANwMIIAZCADcDACABIAVBAWo2AoAECyAEQQRqIQQgAkEBaiICIAxHDQALDAgLIAEoAsgDIgJBsq//AEHEAPwKAAAgAELEADcCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMCAsgAigCECELIAFBwANqIgUgA0EYahDbPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNAiABIAQ2ArwEIAEgAikCHDcCwAQgBSABQbwEaiICENkgGiACIANBDGoQwC0gASgC2AQiAiABKALcBCIMRgRAIAEoAsAEIQMMBgsgAkECdCEEIAFB+ANqIQ0gAUGcBGohByABKALABCEDA0ACQAJAIAMEQCACIAEoAtAETw2/AyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGooAgBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAELIAEgAkEBajYC2AQgBxDmOiABKAKcBEUNvgMgASgCrARBAWoiCUEDdiAJQQdxQQBHaiIGIAEoAqgEIgVLBEAgBiAFayEKIAEoAqAEIg4gBkkEQCAHIA5BAXQiBSAGQcD///8DcUFAayAGIAZBP3EbIg4gBSAOSxsQ6BkgASgCqAQhBQsgCgRAIAEoAqQEIAVqQQAgCvwLAAsgASAGNgKoBAsgASAJNgKsBCABKAKABCIFIAEoAvgDRgRAIA1BoJ3/ABCxKAsgASgC/AMgBUEEdGoiBkIANwMIIAZCADcDACABIAVBAWo2AoAECyAEQQRqIQQgAkEBaiICIAxHDQALDAULIAEoAsgDIgJB6K7/AEHKAPwKAAAgAEHKADYCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMBgsgAUHAA2oiBiACQQxqEKkuIAFB2AFqIgkgBhC5ExCwPkE4QQQQrTYiBUUNuwMgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUGAqv8ANgIoIAEgBTYCJCAGIAFBJGpB6KL/ACAHKAIAIgkgBBCGASABKALAAyIFQZOAgIB4RwRAIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCxAM3AiwgAUHAA2ogAkE8akHoov8AIAMoAgggBBCGASABKALIAyEEIAEoAsQDIQIgASgCwAMiBUGTgICAeEcEQCAAIAEpAswDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC9AIgASACNgLwAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUEsahD4LSABQSRqEPgtTQRAIAFBOGoiBiABKAIsIAEoAjAQ0yMgAUHAA2oiBSAGEKEbIAFBvARqIgYgAxDHBiABQdgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgLEBCABIAc2AsAEIAFBATYCvAQgAUH8AGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQSxqEPgtIAFBJGoiAxD4LWs2AjQgASADEPMtNgK8BCABQQM2AtwBIAFB6Kn/ADYC2AEgAUIDNwLkASABQZcMNgLUAyABQa8DNgLMAyABQTs2AsQDIAEgAUHAA2o2AuABIAEgAUEgajYC0AMgASABQbwEajYCyAMgASABQTRqNgLAAyAAQQRqIAFB2AFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB8AJqELsjDAsLIAFBwANqIgIgAUHYAWoQngggAhDrKSECQcCj/wAMBwsgAUHAA2oiAiABQdgBahCkCCACEOspIQJBmKT/AAwGCyABQcADaiICIAFB2AFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBwANqIgIgAUHYAWoQoAggAhDrKSECQcil/wAMBAsgAUHAA2oiAiABQdgBahCdCCACEOspIQJBoKb/AAwDCyABQcADaiICIAFB2AFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBwANqIgIgAUHYAWoQowggAhDrKSECQdCn/wAMAQsgAUHAA2oiAiABQdgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAUEkahC7IwwGCyABQQI2AsQDIAFBqKn/ADYCwAMgAUIBNwLMAyABQZcMNgLABCABIAFBvARqNgLIAyABIAFBIGo2ArwEIABBBGogAUHAA2oQqhggAEGCgICAeDYCACABQdgBahD/JgwCCwALIAEoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBLGoQuyMLIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBJGoQuyMMAgsCQCADRQ0AIAMgAygCACICQQFrNgIAIAJBAUcNACABQcAEahD7HgsgAUHYAWogAUHAA2oiAhDbDCACEOklIAFB+AJqIgIgAUHkAWopAgA3AwAgAUGAA2oiAyABQewBaigCADYCACABIAEpAtwBNwPwAiABKALYASIEQYCAgIB4RgRAIAAgASkD8AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwCCyABQbQCaiIDIAFB8AFqQST8CgAAIAFB4AJqIgUgAUH4AmopAwA3AwAgAUHoAmoiBiABQYADaigCADYCACABIAEpA/ACNwPYAhCwPkHEAEEEEK02IgIEQCACIAQ2AgggAkKBgICAEDcCACACIAEpA9gCNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABBuKH/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwCCwy4AwsCQCADRQ0AIAMgAygCACICQQFrNgIAIAJBAUcNACABQcAEahD7HgsgAUHYAWogAUHAA2oiAhDcDCACEOklIAFB+AJqIgIgAUHkAWopAgA3AwAgAUGAA2oiAyABQewBaigCADYCACABIAEpAtwBNwPwAiABKALYASIEQYCAgIB4RgRAIAAgASkD8AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQYQDaiIDIAFB8AFqQST8CgAAIAFBsANqIgUgAUH4AmopAwA3AwAgAUG4A2oiBiABQYADaigCADYCACABIAEpA/ACNwOoAxCwPkHEAEEEEK02IgJFDbcDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDqAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDK8DCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhiIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQbCr/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIYiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMQDCyABQQhqIAUgBhCGIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMMDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANCpJvx8abpgqoQhSABKQO4A0LNu9rE68fEghiFhFANAwsgAUGwA2pBygBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0DDMIDCyABKAK4AyIDQfav/wBBxgD8CgAAIABCxgA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAoLIAIoAhAhByABQbADaiIFIANBGGoQ2DwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQMgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEL4tIAEoAswEIgIgASgC0ARGDQcgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NwgMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkEDdGopAwAiG0KAgICAEFQNAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzGAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3BAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByAbp0ECdGoiAigCACIDIAJBBGooAgAgA2sQiRALIAEoAswEIgIgASgC0ARHDQALDAcLIAFBsANqIgYgAkEMahCoLiABQcgBaiIJIAYQrhMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUGwq/8ANgIgIAEgBTYCHCAGIAFBHGpB6KL/ACAHKAIAIgkgBBCGASABKAKwAyIFQZOAgIB4RwRAIAEpArQDIRsgACABKQK8AzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCtAM3AtQEIAFBsANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCuAMhBCABKAK0AyECIAEoArADIgVBk4CAgHhHBEAgACABKQK8AzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AuQCIAEgAjYC4AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFB1ARqEPgtIAFBHGoQ+C1NBEAgAUEoaiIGIAEoAtQEIAEoAtgEENMjIAFBsANqIgUgBhChGyABQbAEaiIGIAMQxwYgAUHIAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCuAQgASAHNgK0BCABQQE2ArAEIAFB7ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUHUBGoQ+C0gAUEcaiIDEPgtazYCJCABIAMQ8y02ArAEIAFBAzYCzAEgAUHoqf8ANgLIASABQgM3AtQBIAFBlww2AsQDIAFBrwM2ArwDIAFBOzYCtAMgASABQbADajYC0AEgASABQRhqNgLAAyABIAFBsARqNgK4AyABIAFBJGo2ArADIABBBGogAUHIAWoQqhggAEGGgICAeDYCACACIAIoAgAiAEEBazYCACAAQQFHDQsgAUHgAmoQuyMMCwsgAUGwA2oiAiABQcgBahCeCCACEOspIQJBwKP/AAwHCyABQbADaiICIAFByAFqEKQIIAIQ6ykhAkGYpP8ADAYLIAFBsANqIgIgAUHIAWoQogggAhDrKSECQfCk/wAMBQsgAUGwA2oiAiABQcgBahCgCCACEOspIQJByKX/AAwECyABQbADaiICIAFByAFqEJ0IIAIQ6ykhAkGgpv8ADAMLIAFBsANqIgIgAUHIAWoQnwggAhDrKSECQfim/wAMAgsgAUGwA2oiAiABQcgBahCjCCACEOspIQJB0Kf/AAwBCyABQbADaiICIAFByAFqEKEIIAIQ6ykhAkGoqP8ACzYCCCAAIAI2AgQgAEGTgICAeDYCACABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNDCABQRxqELsjDAwLIAFBAjYCtAMgAUGoqf8ANgKwAyABQgE3ArwDIAFBlww2ArQEIAEgAUGwBGo2ArgDIAEgAUEYajYCsAQgAEEEaiABQbADahCqGCAAQYKAgIB4NgIAIAFByAFqEP8mDAILDL8DCyABKALUBCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHUBGoQuyMLIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgASgCuAMiA0Horv8AQcoA/AoAACAAQcoANgIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwHCyACKAIQIQcgAUGwA2oiBSADQRhqENg8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC+LSABKALMBCICIAEoAtAERg0BIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDb8DIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBA3RqKQMAIhtCgICAgBBUDQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMwwMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNvgMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNBSACIAIoAgAiAkEBazYCACACQQFHDQUgChD7HgwFCyABQbADakEAIAcgG6dBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMuQMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbYDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDK4DCyAMQRtrDgQVExYVEwsgCCAKNgJMIAggAzYCSCAMQRtrDgQDExYEEwsgDEEbaw4EBBsWBRsLIAggCjYCTCAIIAM2AkggDEEbaw4EBRwWBhwLIAggCjYCTCAIIAM2AkggCy0AAEECaw4IBwgJCgsMDQ4GCyMAQeAAayIDJAAgA0EEaiABIAIQkCIiAUEMakHs54ABIAcoAgAiAkEwaiAEEIYBIAMoAgwhBCADKAIIIQUCQAJAAkAgAygCBCIGQZOAgIB4RwRAIAAgAykCEDcCDCAAIAQ2AgggACAFNgIEIAAgBjYCAAwBCyACIAIoAgAiBkEBajYCACAGQQBIDQEgASgCFCIGIAYoAgAiB0EBajYCACAHQQBIDQEgAyAGNgI8IAMgASkCGDcCQCADQcgAaiIGIAEQmTYQ7iUgA0EEaiIHIAIgA0E8aiAFIAQgBhCcHhCwPkHAAEEEEK02IgFFDbUDIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HgAGokAAwBCwALDKgDCyMAQYABayIDJAAgAyABIAIQkSIiARCZNhDuJQJAAkACQAJAAkACQCABQQxqIgIQ9C1BAEgEQCADQTBqQSNBAEEBQQEQoBggAygCNCEBIAMoAjBBAUYNBCADKAI4IgJBqOmAAUEj/AoAACAAQSM2AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBMGogAkHs54ABIAcoAgAiAkEwaiAEEIYBIAMoAjghBCADKAI0IQUgAygCMCIGQZOAgIB4Rg0BIAAgAykCPDcCDCAAIAQ2AgggACAFNgIEIAAgBjYCAAsgAygCACIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASADEPseDAELIANBGGoiBiABKAIYIgcgByABKAIcQXhxahC4GyADQSRqIgEgBhDoGCACIAIoAgAiBkEBajYCACAGQQBIDQIgA0H4AGogA0EQaikCADcDACADQfAAaiADQQhqKQIANwMAIAMgAykCADcDaCADQTBqIgYgAiABIAUgBCADQegAahCcHhCwPkHAAEEEEK02IgFFDbUDIAFCgYCAgBA3AgAgAUEIaiAGQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAWokAAwCCyABIAMoAjhB1OWAARD9LwsACwynAwsgBSAGEJAiIQkgA0EIaiEOQQAhB0EAIQwjAEGwBWsiBiQAIAYgCzYCHCAJEMA6IQMCQAJAAkACfwJAIAQtADQiD0EBRg0AIAkQwToNACAGQQA2AiBBAAwBC0HAACEBIAkQwDoiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDbcDIAIEQBCwPiACQcAAEK02IgFFDbcDCyAGQgA3AqQDIAYgATYCoAMgBiACNgKcAyAGQcAANgKYAwJAIAkQmTYiAQRAIAZBmANqIAEQlS8MAQsgBkGYA2ogCRDAOhCrEQsgBkEwaiAGQagDaigCADYCACAGQShqIAZBoANqKQIANwMAIAYgBikCmAM3AyBBAQshAiAGQTRqIgUgCUEMaiIQEMMtELA+AkBBBEEEEK02IgEEQCAGQQE2AqADIAYgATYCnAMgBkEBNgKYAyABIAU2AgAgBkH4AGogBkGYA2ogAiADIAtsIgoQwCxBACECAkACQCAJKAIcIgFBCE8EQCABQQJ2IQ0gCSgCGCIBKAIEIAEoAgByRSEMA0AgBiAHNgLEAiAGIAFBBGoiAygCACIFIAEoAgAiAWsiFDYCyAICQCALIBRGDQACQAJAAkAgD0UEQCAJIAcQkiVFDQELIAEgAkcEQCAGQfgAakEAIAIgARDYGwsgBkH4AGogCxCHFyAGKAIgRQ0BIAZBEGogBkEgahCGPSAHQQN2IgEgBigCFCICTw0CIAYoAhAgAWoiASABLQAAQX4gB0EHcXdxOgAAIAUhAgwDCyAGQQM2AtgCIAZBgOmAATYC1AIgBkIDNwLgAiAGQTs2AqwDIAZBOzYCpAMgBkGcAzYCnAMgBiAGQZgDajYC3AIgBiAGQcgCajYCqAMgBiAGQcQCajYCoAMgBiAGQRxqNgKYAyAAQQRqIAZB1AJqEJkOIABBgoCAgHg2AgAMBQtBmOmAARCyOwALIAEgAkGQ44ABEMMhAAsgB0EBaiEHIAMhASANQQFrIg1BAk8NAAsLIAYCfyAMIAJBAEdyIgMEQCAKIAYoAtABIgFHBEAgBkH4AGpBACACIAIgCmogAWsQ2BsLIAZBmANqIgEgBkH4AGpBzAH8CgAAIAZB1AJqIgIgARDqLCAGIAIQoAEgBigCBCEHIAYoAgAMAQsgBkEIaiAQQQAgChDLJSAGKAIMIQcgBigCCAsiATYCzAIgBiAHNgLQAiAGQZgDaiABIAcoAghBAWtBeHFqQQhqIAcgDigCACIBQTBqIAQQhgEgBigCoAMhAiAGKAKcAyEEIAYoApgDIgVBk4CAgHhHBEAgACAGKQKkAzcCDCAAIAI2AgggACAENgIEIAAgBTYCACAGKALMAiIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkHMAmoQuyMLIANFDQEMBgsCQCAGKAIgIgUEQCAGQeACaiAGQSxqKQIANwIAIAYgBTYC1AIgBiAGKQIkNwLYAiAGQZgDaiIFIAZB1AJqIgcQgxQgBkHkBGogBRDhJyAHEM8vDAELIAZBADYC5AQLIAEgASgCACIFQQFqNgIAIAVBAEgNAyAGQfwEaiIFIAEgBigCHCAEIAIgBkHkBGoQsxwQsD5BPEEEEK02IgFFDbgDIAFCgYCAgBA3AgAgAUEIaiAFQTT8CgAAIABBlOeAATYCCCAAIAE2AgQgAEGTgICAeDYCACAGKALMAiIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkHMAmoQuyMLIANFDQEMBAsgBkH4AGoQ7hcMBAsgBkH4AGoQ7hcMAgtBBEEEEKM9CwALIAZBNGoQgScMAQsgBkE0ahCBJyAGKAIgRQ0AIAZBIGoQzy8LIAZBsAVqJAAMpgMLIAUgBhCRIiEJIANBCGohDkEAIQdBACEMIwBBsAVrIgYkACAGIAs2AhwgCRC/OiEDAkACQAJAAn8CQCAELQA0Ig9BAUYNACAJEME6DQAgBkEANgIgQQAMAQtBwAAhASAJEL86IgJBA3YgAkEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ22AyACBEAQsD4gAkHAABCtNiIBRQ22AwsgBkIANwKkAyAGIAE2AqADIAYgAjYCnAMgBkHAADYCmAMCQCAJEJk2IgEEQCAGQZgDaiABEJUvDAELIAZBmANqIAkQvzoQqxELIAZBMGogBkGoA2ooAgA2AgAgBkEoaiAGQaADaikCADcDACAGIAYpApgDNwMgQQELIQIgBkE0aiIFIAlBDGoiEBDDLRCwPgJAQQRBBBCtNiIBBEAgBkEBNgKgAyAGIAE2ApwDIAZBATYCmAMgASAFNgIAIAZB+ABqIAZBmANqIAIgAyALbCIKEMAsQQAhAgJAAkAgCSgCHCIBQRBPBEAgAUEDdiENIAkoAhgiASkDCCABKQMAhKdFIQwDQCAGIAc2AsQCIAYgAUEIaiIDKAIAIgUgASgCACIBayIUNgLIAgJAIAsgFEYNAAJAAkACQCAPRQRAIAkgBxCSJUUNAQsgASACRwRAIAZB+ABqQQAgAiABENgbCyAGQfgAaiALEIcXIAYoAiBFDQEgBkEQaiAGQSBqEIY9IAdBA3YiASAGKAIUIgJPDQIgBigCECABaiIBIAEtAABBfiAHQQdxd3E6AAAgBSECDAMLIAZBAzYC2AIgBkGA6YABNgLUAiAGQgM3AuACIAZBOzYCrAMgBkE7NgKkAyAGQZwDNgKcAyAGIAZBmANqNgLcAiAGIAZByAJqNgKoAyAGIAZBxAJqNgKgAyAGIAZBHGo2ApgDIABBBGogBkHUAmoQmQ4gAEGCgICAeDYCAAwFC0GY6YABELI7AAsgASACQZDjgAEQwyEACyAHQQFqIQcgAyEBIA1BAWsiDUECTw0ACwsgBgJ/IAwgAkEAR3IiAwRAIAogBigC0AEiAUcEQCAGQfgAakEAIAIgAiAKaiABaxDYGwsgBkGYA2oiASAGQfgAakHMAfwKAAAgBkHUAmoiAiABEOosIAYgAhCgASAGKAIEIQcgBigCAAwBCyAGQQhqIBBBACAKEMslIAYoAgwhByAGKAIICyIBNgLMAiAGIAc2AtACIAZBmANqIAEgBygCCEEBa0F4cWpBCGogByAOKAIAIgFBMGogBBCGASAGKAKgAyECIAYoApwDIQQgBigCmAMiBUGTgICAeEcEQCAAIAYpAqQDNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIAIAYoAswCIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQcwCahC7IwsgA0UNAQwGCwJAIAYoAiAiBQRAIAZB4AJqIAZBLGopAgA3AgAgBiAFNgLUAiAGIAYpAiQ3AtgCIAZBmANqIgUgBkHUAmoiBxCDFCAGQeQEaiAFEOEnIAcQzy8MAQsgBkEANgLkBAsgASABKAIAIgVBAWo2AgAgBUEASA0DIAZB/ARqIgUgASAGKAIcIAQgAiAGQeQEahCzHBCwPkE8QQQQrTYiAUUNtwMgAUKBgICAEDcCACABQQhqIAVBNPwKAAAgAEGU54ABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAYoAswCIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQcwCahC7IwsgA0UNAQwECyAGQfgAahDuFwwECyAGQfgAahDuFwwCC0EEQQQQoz0LAAsgBkE0ahCBJwwBCyAGQTRqEIEnIAYoAiBFDQAgBkEgahDPLwsgBkGwBWokAAylAwsjAEGAAWsiAyQAIAMgASACEJAiIgEQmTYQ7iUgA0EwaiABQQxqQezngAEgBygCACICQTBqIAQQhgEgAygCOCEEIAMoAjQhBQJAAkACQCADKAIwIgZBk4CAgHhHBEAgACADKQI8NwIMIAAgBDYCCCAAIAU2AgQgACAGNgIAIAMoAgAiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAxD7HgwBCyADQRhqIgYgASgCGCIHIAcgASgCHEF8cWoQuRsgA0EkaiIBIAYQvRggAiACKAIAIgZBAWo2AgAgBkEASA0BIANB+ABqIANBEGopAgA3AwAgA0HwAGogA0EIaikCADcDACADIAMpAgA3A2ggA0EwaiIGIAIgASAFIAQgA0HoAGoQnR4QsD5BwABBBBCtNiIBRQ2xAyABQoGAgIAQNwIAIAFBCGogBkE4/AoAACAAQeTlgAE2AgggACABNgIEIABBk4CAgHg2AgALIANBgAFqJAAMAQsACwykAwsjAEHgAGsiAyQAIANBBGogASACEJEiIgFBDGpB7OeAASAHKAIAIgJBMGogBBCGASADKAIMIQQgAygCCCEFAkACQAJAIAMoAgQiBkGTgICAeEcEQCAAIAMpAhA3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgAiACKAIAIgZBAWo2AgAgBkEASA0BIAEoAhQiBiAGKAIAIgdBAWo2AgAgB0EASA0BIAMgBjYCPCADIAEpAhg3AkAgA0HIAGoiBiABEJk2EO4lIANBBGoiByACIANBPGogBSAEIAYQnR4QsD5BwABBBBCtNiIBRQ2wAyABQoGAgIAQNwIAIAFBCGogB0E4/AoAACAAQeTlgAE2AgggACABNgIEIABBk4CAgHg2AgALIANB4ABqJAAMAQsACwyjAwsgCEEDNgJUIAhBrNz/ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAyiAwsgACABIAIgAygCCCAEEIIBDKEDCyAAIAEgAiADKAIIIAQQfwygAwsgACABIAIgAygCCCAEEIABDJ8DCyAAIAEgAiADKAIIIAQQgwEMngMLIAAgASACIAMoAgggBBCBAQydAwsgACABIAIgAygCCCAEEH4MnAMLIAAgASACIAMoAgggBBCFAQybAwsgACABIAIgAygCCCAEEIQBDJoDCyAPRQ0KIAYhAiAFIQELIwBB8ABrIgMkACADQdgAaiABIAIgBygCACIBQTBqIAQQhgEgAygCYCECIAMoAlwhBAJAAkACQCADKAJYIgVBk4CAgHhHBEAgACADKQJkNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIADAELIAMgAjYCECADIAQ2AgwgA0EUaiIFIANBDGoQ9C1BARCCESABIAEoAgAiBkEBajYCACAGQQBIDQEgA0EANgJYIANBIGoiBiABIAUgBCACIANB2ABqEJweELA+QcAAQQQQrTYiAUUNpQMgAUKBgICAEDcCACABQQhqIAZBOPwKAAAgAEG85oABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQfAAaiQADAELAAsMmAMLIAggCTYCTCAIIAM2AkggDUEYaw4CBQYECyANQRtHDQogCCAJNgJMIAggAzYCSCAJIQogBiECIAUhAQsgC0EwaiAKKAIIQTBqELsIBEAgACABIAIQ9BAMlgMLIAsgCygCACIDQQFqNgIAIANBAEgNlgMgCEEdOgCQAiAIKAJMKAIEIQMgCCALNgKYAiAIIAM2ApQCIAhB0ABqIAEgAiAIQZACaiIDIAQQhgEgCCgCWCECIAgoAlQhASAIKAJQIgRBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAMQpwwMlgMLIAggAjYCxAMgCCABNgLAAyAAIAEgAigCCEEBa0F4cWpBCGogAhD0ECABIAEoAgAiAEEBazYCACAAQQFGBEAgCEHAA2oQuyMLIAhBkAJqEKcMDJUDCyAIIAM2AkggCCAJNgJMIAkoAgQgC0YNkwMgCEHQAGohAiMAQRBrIgEkACABQQRqQcIAQQBBAUEBEKAYIAEoAgghAwJAIAEoAgRBAUcEQCABKAIMIgRBhN7/AEHCAPwKAAAgAkHCADYCCCACIAQ2AgQgAiADNgIAIAFBEGokAAwBCwyjAwsgAEGCgICAeDYCACAAIAgpAlA3AgQgAEEMaiAIQdgAaigCADYCAAyUAwsgC0EwaiAKKAIIQTBqELsIDZEDIAsgCygCACIDQQFqNgIAIANBAEgNlAMgCEEdOgCQAiAIKAJMKAIEIQMgCCALNgKYAiAIIAM2ApQCIAhB0ABqIAEgAiAIQZACaiIDIAQQhgEgCCgCWCECIAgoAlQhASAIKAJQIgRBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAMQpwwMlAMLIAggAjYCxAMgCCABNgLAAyAAIAEgAigCCEEBa0F4cWpBCGogAhDzECABIAEoAgAiAEEBazYCACAAQQFGBEAgCEHAA2oQuyMLIAhBkAJqEKcMDJMDCyAIQdAAaiECIwBBEGsiASQAIAFBBGpBJ0EAQQFBARCgGCABKAIIIQMCQCABKAIEQQFHBEAgASgCDCIEQcbe/wBBJ/wKAAAgAkEnNgIIIAIgBDYCBCACIAM2AgAgAUEQaiQADAELDKEDCyAAQYKAgIB4NgIAIAAgCCkCUDcCBCAAQQxqIAhB2ABqKAIANgIADJIDCyAAIAUgBiAEEJEJDJEDCyAAIAUgBiAEEJIJDJADCyALQQFGDQILIAxBHUYNAiAMQSNrDgUEBQYHCAMLIwBB8ABrIgMkACADQdgAaiABIAIgBygCACIBQTBqIAQQhgEgAygCYCECIAMoAlwhBAJAAkACQCADKAJYIgVBk4CAgHhHBEAgACADKQJkNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIADAELIAMgAjYCECADIAQ2AgwgA0EUaiIFIANBDGoQ9C1BARCKESABIAEoAgAiBkEBajYCACAGQQBIDQEgA0EANgJYIANBIGoiBiABIAUgBCACIANB2ABqEJ0eELA+QcAAQQQQrTYiAUUNmgMgAUKBgICAEDcCACABQQhqIAZBOPwKAAAgAEHk5YABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQfAAaiQADAELAAsMjQMLIwBB0ABrIgEkACABQThqIAUgBiADQQhqKAIAIgJBMGogBBCGASABKAJAIQMgASgCPCEEAkACQAJAIAEoAjgiBUGTgICAeEcEQCAAIAEpAkQ3AgwgACADNgIIIAAgBDYCBCAAIAU2AgAMAQsgAiACKAIAIgVBAWo2AgAgBUEASA0BIAFBADYCOCABQQRqIgUgAkEBIAQgAyABQThqELMcELA+QTxBBBCtNiICRQ2aAyACQoGAgIAQNwIAIAJBCGogBUE0/AoAACAAQZTngAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB0ABqJAAMAQsACwyMAwsgCSgCBEEBRg0GCyAIIAk2AkwgCCADNgJIDB0LIAggCTYCTCAIIAM2AkggDUEjaw4EBwgJCgsLIAggCTYCTCAIIAM2AkggDUEjaw4ECwwNDg8LIAggCTYCTCAIIAM2AkggDUEjaw4EDxAREhMLIAggCTYCTCAIIAM2AkggDUEjaw4EExQVFhcLIAggCTYCTCAIIAM2AkhBACEBQSchAiANQQFrDicl/AL8AvwC/AL8AvwC/AL8AvwC/AL8AvAC/AL8AvwC/ALwAvAC8ALwAvAC8ALnAukC6wLwAvAC8ALwAvACJPAC8AIZGx0fF/ACCyAFIAYQxi9B7OeAASEGQQxqIgUQ8y0iCSADELsIRQ0ACwsgCCAJNgJMIAggAzYCSCAIQdAAaiIBIAUgBigCFBEAACAIIAEQoAEgACAIKQMANwIEIABBk4CAgHg2AgAMggMLIAUgBhDkISEKIAktAAEhCyAJLQACIQkgAy0AASEGIAMtAAIhByMAQcACayIBJAACQAJAAkACQAJ/AkACQAJ/AkACQAJAIAcgCUYgBiALT3FFBEACQAJAIAnAIAfASgRAIAEgBjoApQEgASAGOgCmASABIAc6AKcBIAEgCSAHayIJwCICNgLwAUEKIQMgAUEKNgKwAUEBIQUDQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNBCACQQFGDQELIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNAyACQQF2IQIMAQsLIAEgBTYCqAEgASAFQQJtIgI2AqwBIAFBACACazYCvAEgASABQbwBajYCuAEgASABQawBajYCtAEgASABQagBajYCsAEgCyAJa8AgBsBOBEAgBC0ANA0FIAEgAUGlAWo2ArgCIAEgAUGmAWo2ArQCIAEgAUGwAWo2ArACIAFBgAJqIAogAUGwAmoQqgQgAS0AgAIiBUEpRgRAIAFB6ABqIAFBlAJqKAIANgIAIAEgASkCjAI3A2AgASgCiAIhAyABKAKEAiECDA4LIAFB4AFqIAFBoAJqKQIANwIAIAFB6AFqIAFBqAJqKQIANwIAIAFB1AFqIAFBlAJqKAIANgIAIAEgAS0AgwI6AMMBIAEgAS8AgQI7AMEBIAEgASkCmAI3AtgBIAEgASkCjAI3AswBIAEoAogCIQMgASgChAIMCwsgAUGAAmogBiAHEM4OIAEoAoACIgJBk4CAgHhHBEAgAUHoAGogAUGQAmooAgA2AgAgASABKQKIAjcDYCABKAKEAiEDDA0LIAFBwAFqIAogAUGwAWoQzB8MCQsgASAGOgBsIAEgBjoAqAEgASAHOgCpASABIAcgCWsiDMAiAjYC8AFBCiEDIAFBCjYCOEEBIQUCQCAHIAlGDQADQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQQgAkEBRg0CCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQMgAkEBdiECDAALAAsgASAFNgK8ASABIAFBvAFqNgI4IAsgDGrAIAbASgRAIAQtADQNBSABIAFB7ABqNgK4AiABIAFBqAFqNgK0AiABIAFBOGo2ArACIAFBgAJqIAogAUGwAmoQvAcgAS0AgAIiBUEpRgRAIAFBuAFqIAFBlAJqKAIANgIAIAEgASkCjAI3A7ABIAEoAogCIQMgASgChAIhAgwJCyABQeABaiABQaACaikCADcCACABQegBaiABQagCaikCADcCACABQdQBaiABQZQCaigCADYCACABIAEtAIMCOgDDASABIAEvAIECOwDBASABIAEpApgCNwLYASABIAEpAowCNwLMASABKAKIAiEDIAEoAoQCDAcLIAFBgAJqIAYgBxDODiABKAKAAiICQZOAgIB4RwRAIAFBuAFqIAFBkAJqKAIANgIAIAEgASkCiAI3A7ABIAEoAoQCIQMMCAsgAUHAAWogCiABQbwBahDJHwwFCyABQQI2AoQCIAFBiJiAATYCgAIgAUICNwKMAiABQfoPNgK8AiABQfwPNgK0AiABIAFBsAJqNgKIAiABIAFB8AFqNgK4AiABIAFBsAFqNgKwAiABQcQBaiABQYACahCZDiABQegAaiABQdABaigCADYCACABIAEpAsgBNwNgIAEoAsQBIQNBiICAgHghAgwKCyABQQI2AoQCIAFBiJiAATYCgAIgAUICNwKMAiABQfoPNgK8AiABQfwPNgK0AiABIAFBsAJqNgKIAiABIAFB8AFqNgK4AiABIAFBOGo2ArACIAFBxAFqIAFBgAJqEJkOIAFBuAFqIAFB0AFqKAIANgIAIAEgASkCyAE3A7ABIAEoAsQBIQNBiICAgHghAgwFCyABQQhqIAoQgBUMBwsgAUHAAWogCiABQbABaiABQaUBahDvBAwECyABQcABaiAKIAFBOGogAUHsAGoQ0wQLIAEoAsgBIQMgAS0AwAEhBSABKALEAQshAiABQa4BaiIEIAEtAMMBOgAAIAFBuAFqIgkgAUHUAWooAgA2AgAgAUHQAGoiCiABQeABaikCADcDACABQdgAaiILIAFB6AFqKQIANwMAIAEgAS8AwQE7AawBIAEgASkCzAE3A7ABIAEgASkC2AE3A0ggBUH/AXFBKUYNACABQegAaiAJKAIAIgk2AgAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACABQRxqIAk2AgAgASABLwGsATsACSABIAEpA7ABIhs3A2AgASABKQNINwIgIAEgBC0AADoACyABIBs3AhQgASADNgIQIAEgAjYCDCABIAU6AAgMAwsgAUHoAGogAUG4AWooAgAiBDYCACABIAEpA7ABIhs3A2AgAEEQaiAENgAAIAAgGzcACCAAIAM2AgQgACACNgIADAULIAEoAsgBIQMgAS0AwAEhBSABKALEAQshAiABQe4AaiIEIAEtAMMBOgAAIAFB6ABqIgkgAUHUAWooAgA2AgAgAUHQAGoiCiABQeABaikCADcDACABQdgAaiILIAFB6AFqKQIANwMAIAEgAS8AwQE7AWwgASABKQLMATcDYCABIAEpAtgBNwNIIAVB/wFxQSlGDQEgAUFAayAJKAIAIgk2AgAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACABQRxqIAk2AgAgASABLwFsOwAJIAEgASkDYCIbNwM4IAEgASkDSDcCICABIAQtAAA6AAsgASAbNwIUIAEgAzYCECABIAI2AgwgASAFOgAICyABQYACaiABQQhqIAYgBxCgEyABLQCAAiIDQSlHDQEgAUGDAWogAUGUAmooAgAiAjYAACABQfsAaiABQYwCaikCACIbNwAAIAEgASkChAIiHDcAcyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQUBrIAFB6ABqKAIAIgQ2AgAgASABKQNgIhs3AzggAEEQaiAENgAAIAAgGzcACCAAIAM2AgQgACACNgIADAELIAFB/wBqIgQgAUGQAmopAAA3AAAgAUH4AGoiBSABQYkCaikAADcDACABQZABaiIGIAFBoAJqKQIANwMAIAFBmAFqIgcgAUGoAmopAgA3AwAgASABKQCBAjcDcCABIAEpApgCNwOIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDcDcACSACIAEpA4gBNwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAQsMhwMLIAFBwAJqJAAMgQMLIAUgBhDkISEKIAksAAEhCyAJLQACIQUgAy0AASEGIAMtAAIhByMAQZACayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFwCAHwEwEQCABIAY6AJYBIAEgBjoAPCABIAc6AD0gASAHIAVrIgPAIgI2ApwBQgohGyABQgo3A6ABQgEhHAJAIAUgB0YNAANAIAJBAXEEQCABQRBqIBwgHEI/hyAbIBtCP4cQqB4gASkDGCABKQMQIhxCP4dSDQQgAkEBRg0CCyABIBsgG0I/hyIdIBsgHRCoHiABKQMIIAEpAwAiG0I/h1INAyACQQF2IQIMAAsACyABIBw3A4gBIAEgAUGIAWo2AqABIAMgC2rAIAbASgRAIAQtADQNBiABIAFBlgFqNgIoIAEgAUE8ajYCJCABIAFBoAFqNgIgIAFB4AFqIAogAUEgahC3ByABLQDgASIEQSlHDQMgASkC8AEhGyABKQLoASEcIAEoAuQBIQIMDAsgAUHgAWogBiAHEM0OIAEoAuABIgJBk4CAgHhHBEAgASkC7AEhGyABKQLkASEcDAwLIAFBsAFqIAogAUGIAWoQzR8MCgsgASAGOgCVASABIAY6AJYBIAEgBzoAlwEgASAFIAdrIgnAIgI2AqABQQohBSABQQo2AogBQQEhAwNAAkAgAkEBcQRAIAOsIAWsfiIbQiCIpyAbpyIDQR91Rw0FIAJBAUYNAQsgBawiGyAbfiIbQiCIpyAbpyIFQR91Rw0EIAJBAXYhAgwBCwsgASADNgKYASABIANBAm0iAjYCnAEgAUEAIAJrNgKIASABIAFBiAFqNgKoASABIAFBnAFqNgKkASABIAFBmAFqNgKgASALIAlrwCAGwE4EQCAELQA0DQYgASABQZUBajYCKCABIAFBlgFqNgIkIAEgAUGgAWo2AiAgAUHgAWogCiABQSBqELYEIAEtAOABIgRBKUcNBCABKQLwASEbIAEoAuwBIQUgASgC6AEhAyABKALkASECDAgLIAFB4AFqIAYgBxDNDiABKALgASICQZOAgIB4RwRAIAEpAuwBIRsgASgC6AEhBSABKALkASEDDAgLIAFBsAFqIAogAUGgAWoQxh8MBgsgAUECNgLkASABQYiYgAE2AuABIAFCAjcC7AEgAUH6DzYCLCABQf0PNgIkIAEgAUEgajYC6AEgASABQZwBajYCKCABIAFBoAFqNgIgIAFBtAFqIAFB4AFqEJkOIAEpArQBIRwgASkCvAEhG0GIgICAeCECDAkLIAFBmgFqIAEtAOMBIgI6AAAgAUHQAGogAUGIAmopAgA3AwAgAUHIAGogAUGAAmopAgA3AwAgASACOgCzASABIAEvAOEBIgI7ALEBIAEgASkC+AEiGzcCyAEgASACOwGYASABIBs3A0AgASgC5AEhAiABKQLoASEcIAEpAvABIRsMCgsgAUECNgLkASABQYiYgAE2AuABIAFCAjcC7AEgAUH6DzYCLCABQfwPNgIkIAEgAUEgajYC6AEgASABQaABajYCKCABIAFBiAFqNgIgIAFBtAFqIAFB4AFqEJkOIAEoArQBIQMgASgCuAEhBSABKQK8ASEbQYiAgIB4IQIMBAsgAUHQAWogAUGAAmopAgAiHDcCACABQdgBaiABQYgCaikCACIdNwIAIAFBPmogAS0A4wEiAjoAACABIAI6ALMBIAEgAS8A4QEiAjsAsQEgASABKQL4ASIeNwLIASABIAI7ATwgASgC5AEhAiABKALoASEDIAEoAuwBIQUgASkC8AEhGyABQdAAaiAdNwMAIAFByABqIBw3AwAgASAeNwNADAQLIAFBsAFqIAogAUGgAWogAUGWAWoQ2wQMBAsgAUGwAWogCiABQaABaiABQZUBahCEBQsgAUE+aiABLQCzAToAACABQcgAaiABQdABaikCADcDACABQdAAaiABQdgBaikCADcDACABIAEvALEBOwE8IAEgASkCyAE3A0AgASkCwAEhGyABKAK8ASEFIAEoArgBIQMgASgCtAEhAiABLQCwASIEQSlHDQELIAAgBTYCCCAAIAM2AgQMAwsgAUGiAWogAUE+ai0AADoAACABQShqIAFByABqKQMANwMAIAFBMGogAUHQAGopAwA3AwAgASABLwE8OwGgASABIAEpA0A3AyAMBAsgAUGaAWogAS0AswE6AAAgAUHIAGogAUHQAWopAgA3AwAgAUHQAGogAUHYAWopAgA3AwAgASABLwCxATsBmAEgASABKQLIATcDQCABKQLAASEbIAEpArgBIRwgASgCtAEhAiABLQCwASIEQSlHDQILIAAgHDcCBAsgACACNgIAIAAgGzcCDAwCCyABQaIBaiABQZoBai0AADoAACABQShqIAFByABqKQMANwMAIAFBMGogAUHQAGopAwA3AwAgASABLwGYATsBoAEgASABKQNANwMgIBxCIIinIQUgHKchAwsgAUGAAmogAUEoaikDADcCACABQYgCaiABQTBqKQMANwIAIAEgBDoA4AEgASABLwGgATsA4QEgASAbNwLwASABIAU2AuwBIAEgAzYC6AEgASACNgLkASABIAEpAyA3AvgBIAEgAUGiAWotAAA6AOMBIAFBsAFqIAFB4AFqIAYgBxCiEyABLQCwASIDQSlGBEAgAUHrAGogAUHEAWooAgAiAjYAACABQeMAaiABQbwBaikCACIbNwAAIAEgASkCtAEiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQecAaiIEIAFBwAFqKQAANwAAIAFB4ABqIgUgAUG5AWopAAA3AwAgAUH4AGoiBiABQdABaikCADcDACABQYABaiIHIAFB2AFqKQIANwMAIAEgASkAsQE3A1ggASABKQLIATcDcBCwPkE4QQQQrTYiAkUNhwMgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNYNwAJIAIgASkDcDcCICAAQbyagAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQZACaiQADAALDIADCyAFIAYQ5CEhCiAJLAABIQsgCS0AAiEFIAMtAAEhBiADLQACIQcjAEGwAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBcAgB8BMBEAgASAGOgDGASABIAY6AFQgASAHOgBVIAEgByAFayIDwCICNgLMASABQgA3A7gBQgohGyABQgo3A7ABQgEhHgJAIAUgB0YNAANAIAJBAXEEQCABQQA2AjQgAUEgaiAeIB0gGyAcIAFBNGoQ9gwgASgCNA0EIAEpAyghHSABKQMgIR4gAkEBRg0CCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0DIAEpAwghHCABKQMAIRsgAkEBdiECDAALAAsgASAeNwOgASABIB03A6gBIAEgAUGgAWo2ArABIAMgC2rAIAbASgRAIAQtADQNBiABIAFBxgFqNgJAIAEgAUHUAGo2AjwgASABQbABajYCOCABQYACaiAKIAFBOGoQwQcgAS0AgAIiBEEpRw0DIAEpApACIRsgASkCiAIhHCABKAKEAiECDAwLIAFBgAJqIAYgBxDMDiABKAKAAiICQZOAgIB4RwRAIAEpAowCIRsgASkChAIhHAwMCyABQdABaiAKIAFBoAFqEMEfDAoLIAEgBjoAxQEgASAGOgDGASABIAc6AMcBIAEgBSAHayIJwCICNgKwAUEKIQUgAUEKNgKgAUEBIQMDQAJAIAJBAXEEQCADrCAFrH4iG0IgiKcgG6ciA0EfdUcNBSACQQFGDQELIAWsIhsgG34iG0IgiKcgG6ciBUEfdUcNBCACQQF2IQIMAQsLIAEgAzYCyAEgASADQQJtIgI2AswBIAFBACACazYCoAEgASABQaABajYCuAEgASABQcwBajYCtAEgASABQcgBajYCsAEgCyAJa8AgBsBOBEAgBC0ANA0GIAEgAUHFAWo2AkAgASABQcYBajYCPCABIAFBsAFqNgI4IAFBgAJqIAogAUE4ahCkBCABLQCAAiIEQSlHDQQgASkCkAIhGyABKAKMAiEFIAEoAogCIQMgASgChAIhAgwICyABQYACaiAGIAcQzA4gASgCgAIiAkGTgICAeEcEQCABKQKMAiEbIAEoAogCIQUgASgChAIhAwwICyABQdABaiAKIAFBsAFqEMQfDAYLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AkQgAUH7DzYCPCABIAFBOGo2AogCIAEgAUHMAWo2AkAgASABQbABajYCOCABQdQBaiABQYACahCZDiABKQLUASEcIAEpAtwBIRtBiICAgHghAgwJCyABQcoBaiABLQCDAiICOgAAIAFB6ABqIAFBqAJqKQIANwMAIAFB4ABqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsByAEgASAbNwNYIAEoAoQCIQIgASkCiAIhHCABKQKQAiEbDAoLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AkQgAUH8DzYCPCABIAFBOGo2AogCIAEgAUGwAWo2AkAgASABQaABajYCOCABQdQBaiABQYACahCZDiABKALUASEDIAEoAtgBIQUgASkC3AEhG0GIgICAeCECDAQLIAFB8AFqIAFBoAJqKQIAIhw3AgAgAUH4AWogAUGoAmopAgAiHTcCACABQdYAaiABLQCDAiICOgAAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIh43AugBIAEgAjsBVCABKAKEAiECIAEoAogCIQMgASgCjAIhBSABKQKQAiEbIAFB6ABqIB03AwAgAUHgAGogHDcDACABIB43A1gMBAsgAUHQAWogCiABQbABaiABQcYBahDQBAwECyABQdABaiAKIAFBsAFqIAFBxQFqEIIFCyABQdYAaiABLQDTAToAACABQeAAaiABQfABaikCADcDACABQegAaiABQfgBaikCADcDACABIAEvANEBOwFUIAEgASkC6AE3A1ggASkC4AEhGyABKALcASEFIAEoAtgBIQMgASgC1AEhAiABLQDQASIEQSlHDQELIAAgBTYCCCAAIAM2AgQMAwsgAUGyAWogAUHWAGotAAA6AAAgAUFAayABQeAAaikDADcDACABQcgAaiABQegAaikDADcDACABIAEvAVQ7AbABIAEgASkDWDcDOAwECyABQcoBaiABLQDTAToAACABQeAAaiABQfABaikCADcDACABQegAaiABQfgBaikCADcDACABIAEvANEBOwHIASABIAEpAugBNwNYIAEpAuABIRsgASkC2AEhHCABKALUASECIAEtANABIgRBKUcNAgsgACAcNwIECyAAIAI2AgAgACAbNwIMDAILIAFBsgFqIAFBygFqLQAAOgAAIAFBQGsgAUHgAGopAwA3AwAgAUHIAGogAUHoAGopAwA3AwAgASABLwHIATsBsAEgASABKQNYNwM4IBxCIIinIQUgHKchAwsgAUGgAmogAUFAaykDADcCACABQagCaiABQcgAaikDADcCACABIAQ6AIACIAEgAS8BsAE7AIECIAEgGzcCkAIgASAFNgKMAiABIAM2AogCIAEgAjYChAIgASABKQM4NwKYAiABIAFBsgFqLQAAOgCDAiABQdABaiABQYACaiAGIAcQoRMgAS0A0AEiA0EpRgRAIAFBgwFqIAFB5AFqKAIAIgI2AAAgAUH7AGogAUHcAWopAgAiGzcAACABIAEpAtQBIhw3AHMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUH/AGoiBCABQeABaikAADcAACABQfgAaiIFIAFB2QFqKQAANwMAIAFBkAFqIgYgAUHwAWopAgA3AwAgAUGYAWoiByABQfgBaikCADcDACABIAEpANEBNwNwIAEgASkC6AE3A4gBELA+QThBBBCtNiICRQ2GAyACIAM6AAggAkKBgICAEDcCACACIAEpA3A3AAkgAiABKQOIATcCICAAQbSYgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQbACaiQADAALDP8CCyAFIAYQ5CEhCiAJLAABIQsgCS0AAiECIAMtAAEhBiADLQACIQcjAEGQAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIALAIAfATARAIAEgBjoAJCABIAY6AJgBIAEgBzoAmQEgAUGgAWpCCkIAELIuIAFB0AFqIAEpA6ABIAEpA6gBIAEpA7ABIAEpA7gBIAcgAmsiAsAQ3wEgASgC0AFBAUYEQCABKQPgASEbIAEpA9gBIRwgASgC1AEhAgwLCyABIAEpA/gBNwOIASABIAEpA/ABNwOAASABIAEpA+gBNwN4IAEgASkD4AE3A3AgASABQfAAajYCjAIgAiALasAgBsBKBEAgBC0ANA0FIAEgAUEkajYCECABIAFBmAFqNgIMIAEgAUGMAmo2AgggAUHQAWogCiABQQhqELIHIAEtANABIgRBKUcNAiABKQLgASEbIAEpAtgBIRwgASgC1AEhAgwLCyABQdABaiAGIAcQzw4gASgC0AEiAkGTgICAeEcEQCABKQLcASEbIAEpAtQBIRwMCwsgAUGgAWogCiABQfAAahDDHwwJCyABIAY6AJUBIAEgBjoAlgEgASAHOgCXASABIAIgB2siCcAiAjYCCEEKIQUgAUEKNgKMAkEBIQMDQAJAIAJBAXEEQCADrCAFrH4iG0IgiKcgG6ciA0EfdUcNBCACQQFGDQELIAWsIhsgG34iG0IgiKcgG6ciBUEfdUcNAyACQQF2IQIMAQsLIAEgAzYCmAEgASADQQJtIgI2ApwBIAFBACACazYCjAIgASABQYwCajYCECABIAFBnAFqNgIMIAEgAUGYAWo2AgggCyAJa8AgBsBOBEAgBC0ANA0FIAEgAUGVAWo2AjAgASABQZYBajYCLCABIAFBCGo2AiggAUHQAWogCiABQShqEIAEIAEtANABIgRBKUcNAyABKQLgASEbIAEoAtwBIQUgASgC2AEhAyABKALUASECDAcLIAFB0AFqIAYgBxDPDiABKALQASICQZOAgIB4RwRAIAEpAtwBIRsgASgC2AEhBSABKALUASEDDAcLIAFBoAFqIAogAUEIahDPHwwFCyABQZ4BaiABLQDTASICOgAAIAFBOGogAUH4AWopAgA3AwAgAUEwaiABQfABaikCADcDACABIAI6AKMBIAEgAS8A0QEiAjsAoQEgASABKQLoASIbNwK4ASABIAI7AZwBIAEgGzcDKCABKALUASECIAEpAtgBIRwgASkC4AEhGwwKCyABQQI2AtQBIAFBiJiAATYC0AEgAUICNwLcASABQfoPNgI0IAFB/A82AiwgASABQShqNgLYASABIAFBCGo2AjAgASABQYwCajYCKCABQaQBaiABQdABahCZDiABKAKkASEDIAEoAqgBIQUgASkCrAEhG0GIgICAeCECDAQLIAFBwAFqIAFB8AFqKQIAIhw3AgAgAUHIAWogAUH4AWopAgAiHTcCACABQSZqIAEtANMBIgI6AAAgASACOgCjASABIAEvANEBIgI7AKEBIAEgASkC6AEiHjcCuAEgASACOwEkIAEoAtQBIQIgASgC2AEhAyABKALcASEFIAEpAuABIRsgAUGAAWogHTcDACABQfgAaiAcNwMAIAEgHjcDcAwECyABQaABaiAKIAFBjAJqIAFBJGoQ3QQMBAsgAUGgAWogCiABQQhqIAFBlQFqENYECyABQSZqIAEtAKMBOgAAIAFB+ABqIAFBwAFqKQIANwMAIAFBgAFqIAFByAFqKQIANwMAIAEgAS8AoQE7ASQgASABKQK4ATcDcCABKQKwASEbIAEoAqwBIQUgASgCqAEhAyABKAKkASECIAEtAKABIgRBKUcNAQsgACAFNgIIIAAgAzYCBAwDCyABQY4CaiABQSZqLQAAOgAAIAFBEGogAUH4AGopAwA3AwAgAUEYaiABQYABaikDADcDACABIAEvASQ7AYwCIAEgASkDcDcDCAwECyABQZ4BaiABLQCjAToAACABQTBqIAFBwAFqKQIANwMAIAFBOGogAUHIAWopAgA3AwAgASABLwChATsBnAEgASABKQK4ATcDKCABKQKwASEbIAEpAqgBIRwgASgCpAEhAiABLQCgASIEQSlHDQILIAAgHDcCBAsgACACNgIAIAAgGzcCDAwCCyABQY4CaiABQZ4Bai0AADoAACABQRBqIAFBMGopAwA3AwAgAUEYaiABQThqKQMANwMAIAEgAS8BnAE7AYwCIAEgASkDKDcDCCAcQiCIpyEFIBynIQMLIAFB8AFqIAFBEGopAwA3AgAgAUH4AWogAUEYaikDADcCACABIAQ6ANABIAEgAS8BjAI7ANEBIAEgGzcC4AEgASAFNgLcASABIAM2AtgBIAEgAjYC1AEgASABKQMINwLoASABIAFBjgJqLQAAOgDTASABQaABaiABQdABaiAGIAcQoxMgAS0AoAEiA0EpRgRAIAFB0wBqIAFBtAFqKAIAIgI2AAAgAUHLAGogAUGsAWopAgAiGzcAACABIAEpAqQBIhw3AEMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUHPAGoiBCABQbABaikAADcAACABQcgAaiIFIAFBqQFqKQAANwMAIAFB4ABqIgYgAUHAAWopAgA3AwAgAUHoAGoiByABQcgBaikCADcDACABIAEpAKEBNwNAIAEgASkCuAE3A1gQsD5BOEEEEK02IgJFDYUDIAIgAzoACCACQoGAgIAQNwIAIAIgASkDQDcACSACIAEpA1g3AiAgAEGMmYABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUGQAmokAAwACwz+AgsgDUENa0H/AXFBB0kNECAJQQJqIQIjAEFAaiIBJAAgASADNgIQIAEgCTYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIAItAAAgBBCbAgwMCyAAIAUgBiACLQAAIAQQlgIMCwsgACAFIAYgAi0AACAEELECDAoLIAAgBSAGIAItAAAgBBCyAgwJCyAAIAUgBiACLQAAIAQQoAIMCAsgACAFIAYgAi0AACAEEJoCDAcLIAAgBSAGIAItAAAgBBCYAgwGCyAAIAUgBiACLQAAIAQQlwIMBQsgACAFIAYgAUE/aiACENMgDAQLIAAgBSAGIAFBP2ogAhDXIAwDCyAAIAUgBiAEEJEJDAILIAAgBSAGIAQQkgkMAQsgACAFIAYgBBCnAQsgAUFAayQADP0CCyAFIAYQ6CEhCiAJLAABIQsgCS0AAiEJIAMtAAEhBSADLQACIQYjAEGgAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCcAgBsBMBEAgASAFOgCWASABIAU6AEQgASAGOgBFIAEgBiAJayIMwCICNgKwAUEKIQcgAUEKNgKoAUEBIQMCQCAGIAlGDQADQCACQQFxBEAgA6wgB6x+IhtCIIinIBunIgNBH3VHDQQgAkEBRg0CCyAHrCIbIBt+IhtCIIinIBunIgdBH3VHDQMgAkEBdiECDAALAAsgASADNgKgASABIAFBoAFqNgKwASALIAxqwCAFwEoEQCAELQA0DQYgASABQZYBajYCMCABIAFBxABqNgIsIAEgAUGwAWo2AiggAUHwAWogCiABQShqEL0HIAEtAPABIgdBKUcNAyABKQKAAiEbIAEoAvwBIQMgASgC+AEhBCABKAL0ASECDAwLIAFB8AFqIAUgBhDODiABKALwASICQZOAgIB4RwRAIAEpAvwBIRsgASgC+AEhAyABKAL0ASEEDAwLIAFBwAFqIAogAUGgAWoQwh8MCgsgASAFOgCVASABIAU6AJYBIAEgBjoAlwEgASAJIAZrIgPAIgI2AqgBQgohGyABQgo3A7ABQgEhHANAAkAgAkEBcQRAIAFBEGogHCAcQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHEI/h1INBSACQQFGDQELIAEgGyAbQj+HIh0gGyAdEKgeIAEpAwggASkDACIbQj+HUg0EIAJBAXYhAgwBCwsgASAcNwOYASABIBxCAn8iGzcDoAEgAUIAIBt9NwOoASABIAFBqAFqNgK4ASABIAFBoAFqNgK0ASABIAFBmAFqNgKwASALIANrwCAFwE4EQCAELQA0DQYgASABQZUBajYCMCABIAFBlgFqNgIsIAEgAUGwAWo2AiggAUHwAWogCiABQShqELUHIAEtAPABIgdBKUcNBCABKQKAAiEbIAEpAvgBIRwgASgC9AEhAgwICyABQfABaiAFIAYQzg4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEbIAEpAvQBIRwMCAsgAUHAAWogCiABQbABahDFHwwGCyABQQI2AvQBIAFBiJiAATYC8AEgAUICNwL8ASABQfoPNgI0IAFB/A82AiwgASABQShqNgL4ASABIAFBsAFqNgIwIAEgAUGoAWo2AiggAUHEAWogAUHwAWoQmQ4gASgCxAEhBCABKALIASEDIAEpAswBIRtBiICAgHghAgwJCyABQeABaiABQZACaikCACIcNwIAIAFB6AFqIAFBmAJqKQIAIh03AgAgAUGaAWogAS0A8wEiAjoAACABIAI6AMMBIAEgAS8A8QEiAjsAwQEgASABKQKIAiIeNwLYASABIAI7AZgBIAEoAvQBIQIgASgC+AEhBCABKAL8ASEDIAEpAoACIRsgAUHYAGogHTcDACABQdAAaiAcNwMAIAEgHjcDSAwKCyABQQI2AvQBIAFBiJiAATYC8AEgAUICNwL8ASABQfoPNgI0IAFB/Q82AiwgASABQShqNgL4ASABIAFBqAFqNgIwIAEgAUGwAWo2AiggAUHEAWogAUHwAWoQmQ4gASkCxAEhHCABKQLMASEbQYiAgIB4IQIMBAsgAUHGAGogAS0A8wEiAjoAACABQdgAaiABQZgCaikCADcDACABQdAAaiABQZACaikCADcDACABIAI6AMMBIAEgAS8A8QEiAjsAwQEgASABKQKIAiIbNwLYASABIAI7AUQgASAbNwNIIAEoAvQBIQIgASkC+AEhHCABKQKAAiEbDAQLIAFBwAFqIAogAUGwAWogAUGWAWoQ1QQMBAsgAUHAAWogCiABQbABaiABQZUBahD2BAsgAUHGAGogAS0AwwE6AAAgAUHQAGogAUHgAWopAgA3AwAgAUHYAGogAUHoAWopAgA3AwAgASABLwDBATsBRCABIAEpAtgBNwNIIAEpAtABIRsgASkCyAEhHCABKALEASECIAEtAMABIgdBKUcNAQsgACAcNwIEDAMLIAFBsgFqIAFBxgBqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAUQ7AbABIAEgASkDSDcDKAwECyABQZoBaiABLQDDAToAACABQdAAaiABQeABaikCADcDACABQdgAaiABQegBaikCADcDACABIAEvAMEBOwGYASABIAEpAtgBNwNIIAEpAtABIRsgASgCzAEhAyABKALIASEEIAEoAsQBIQIgAS0AwAEiB0EpRw0CCyAAIAM2AgggACAENgIECyAAIAI2AgAgACAbNwIMDAILIAFBsgFqIAFBmgFqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAZgBOwGwASABIAEpA0g3AyggBK0gA61CIIaEIRwLIAFBkAJqIAFBMGopAwA3AgAgAUGYAmogAUE4aikDADcCACABIAc6APABIAEgAS8BsAE7APEBIAEgGzcCgAIgASAcNwL4ASABIAI2AvQBIAEgASkDKDcCiAIgASABQbIBai0AADoA8wEgAUHAAWogAUHwAWogBSAGEKATIAEtAMABIgNBKUYEQCABQfMAaiABQdQBaigCACICNgAAIAFB6wBqIAFBzAFqKQIAIhs3AAAgASABKQLEASIcNwBjIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB7wBqIgQgAUHQAWopAAA3AAAgAUHoAGoiBSABQckBaikAADcDACABQYABaiIGIAFB4AFqKQIANwMAIAFBiAFqIgcgAUHoAWopAgA3AwAgASABKQDBATcDYCABIAEpAtgBNwN4ELA+QThBBBCtNiICRQ2DAyACIAM6AAggAkKBgICAEDcCACACIAEpA2A3AAkgAiABKQN4NwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFBoAJqJAAMAAsM/AILIAUgBhDoISEGIAktAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQeACayIBJAACQAJAAkACQAJAAkACQAJAAkACQCADIAdGIAUgCk9xRQRAAkACQAJAAkAgB8AgA8BKBEAgASAFOgDFASABIAU6AMYBIAEgAzoAxwEgASAHIANrIgfAIgI2AugBQgohGyABQgo3A9gBQgEhHANAAkAgAkEBcQRAIAFBEGogHCAcQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHEI/h1INBCACQQFGDQELIAEgGyAbQj+HIh0gGyAdEKgeIAEpAwggASkDACIbQj+HUg0DIAJBAXYhAgwBCwsgASAcNwPIASABIBxCAn8iGzcD0AEgAUIAIBt9NwPoASABIAFB6AFqNgLgASABIAFB0AFqNgLcASABIAFByAFqNgLYASAKIAdrwCAFwE4EQCAELQA0DQcgASABQcUBajYC2AIgASABQcYBajYC1AIgASABQdgBajYC0AIgAUGgAmogBiABQdACahC1BCABLQCgAiIEQSlHDQMgASkCsAIhGyABKQKoAiEcIAEoAqQCIQIMDQsgAUGgAmogBSADEM0OIAEoAqACIgJBk4CAgHhHBEAgASkCrAIhGyABKQKkAiEcDA0LIAFB8AFqIAYgAUHYAWoQyh8MCwsgASAFOgDGASABIAU6AIwBIAEgAzoAjQEgASADIAdrIgnAIgI2AtABQgohGyABQgo3A9gBQgEhHAJAIAMgB0YNAANAIAJBAXEEQCABQTBqIBwgHEI/hyAbIBtCP4cQqB4gASkDOCABKQMwIhxCP4dSDQUgAkEBRg0CCyABQSBqIBsgG0I/hyIdIBsgHRCoHiABKQMoIAEpAyAiG0I/h1INBCACQQF2IQIMAAsACyABIBw3A+gBIAEgAUHoAWo2AtgBIAkgCmrAIAXASgRAIAQtADQNByABIAFBxgFqNgLYAiABIAFBjAFqNgLUAiABIAFB2AFqNgLQAiABQaACaiAGIAFB0AJqELkHIAEtAKACIgRBKUcNBCABKQKwAiEbIAEpAqgCIRwgASgCpAIhAgwJCyABQaACaiAFIAMQzQ4gASgCoAIiAkGTgICAeEcEQCABKQKsAiEbIAEpAqQCIRwMCQsgAUHwAWogBiABQegBahDIHwwHCyABQQI2AqQCIAFBiJiAATYCoAIgAUICNwKsAiABQfoPNgLcAiABQf0PNgLUAiABIAFB0AJqNgKoAiABIAFB6AFqNgLYAiABIAFB2AFqNgLQAiABQfQBaiABQaACahCZDiABKQL0ASEcIAEpAvwBIRtBiICAgHghAgwKCyABQY4BaiABLQCjAiICOgAAIAFBgAFqIAFByAJqKQIANwMAIAFB+ABqIAFBwAJqKQIANwMAIAEgAjoA8wEgASABLwChAiICOwDxASABIAEpArgCIhs3AogCIAEgAjsBjAEgASAbNwNwIAEoAqQCIQIgASkCqAIhHCABKQKwAiEbDAoLIAFBAjYCpAIgAUGImIABNgKgAiABQgI3AqwCIAFB+g82AtwCIAFB/Q82AtQCIAEgAUHQAmo2AqgCIAEgAUHQAWo2AtgCIAEgAUHYAWo2AtACIAFB9AFqIAFBoAJqEJkOIAEpAvQBIRwgASkC/AEhG0GIgICAeCECDAULIAFBygFqIAEtAKMCIgI6AAAgAUGAAWogAUHIAmopAgA3AwAgAUH4AGogAUHAAmopAgA3AwAgASACOgDzASABIAEvAKECIgI7APEBIAEgASkCuAIiGzcCiAIgASACOwHIASABIBs3A3AgASgCpAIhAiABKQKoAiEcIAEpArACIRsMBQsgAUFAayAGEIAVDAgLIAFB8AFqIAYgAUHYAWogAUHFAWoQ+wQMBAsgAUHwAWogBiABQdgBaiABQcYBahDEBAsgAUHKAWogAS0A8wE6AAAgAUH4AGogAUGQAmopAgA3AwAgAUGAAWogAUGYAmopAgA3AwAgASABLwDxATsByAEgASABKQKIAjcDcCABKQKAAiEbIAEpAvgBIRwgASgC9AEhAiABLQDwASIEQSlHDQELIAAgGzcCDCAAIBw3AgQgACACNgIADAULIAFB4ABqIAFB+ABqKQMANwIAIAFB6ABqIAFBgAFqKQMANwIAIAEgAS8ByAE7AEEgASABKQNwNwJYIAEgAUHKAWotAAA6AEMgASAbNwJQIAEgHDcCSCABIAI2AkQgASAEOgBADAMLIAFBjgFqIAEtAPMBOgAAIAFB+ABqIAFBkAJqKQIANwMAIAFBgAFqIAFBmAJqKQIANwMAIAEgAS8A8QE7AYwBIAEgASkCiAI3A3AgASkCgAIhGyABKQL4ASEcIAEoAvQBIQIgAS0A8AEiBEEpRw0BCyAAIBs3AgwgACAcNwIEIAAgAjYCAAwCCyABQeAAaiABQfgAaikDADcCACABQegAaiABQYABaikDADcCACABIAEvAYwBOwBBIAEgASkDcDcCWCABIAFBjgFqLQAAOgBDIAEgGzcCUCABIBw3AkggASACNgJEIAEgBDoAQAsgAUGgAmogAUFAayAFIAMQohMgAS0AoAIiA0EpRgRAIAFBowFqIAFBtAJqKAIAIgI2AAAgAUGbAWogAUGsAmopAgAiGzcAACABIAEpAqQCIhw3AJMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBnwFqIgQgAUGwAmopAAA3AAAgAUGYAWoiBSABQakCaikAADcDACABQbABaiIGIAFBwAJqKQIANwMAIAFBuAFqIgcgAUHIAmopAgA3AwAgASABKQChAjcDkAEgASABKQK4AjcDqAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA5ABNwAJIAIgASkDqAE3AiAgAEG8moABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwBCwyBAwsgAUHgAmokAAz7AgsgBSAGEOghIQYgCSwAASEKIAktAAIhByADLQABIQUgAy0AAiEDIwBB4AJrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAfAIAPATARAIAEgBToA7gEgASAFOgB0IAEgAzoAdSABIAMgB2siCcAiAjYC+AEgAUIANwPYAUIKIRsgAUIKNwPQAUIBIR4CQCADIAdGDQADQCACQQFxBEAgAUEANgJUIAFBQGsgHiAdIBsgHCABQdQAahD2DCABKAJUDQQgASkDSCEdIAEpA0AhHiACQQFGDQILIAFBADYCPCABQSBqIBsgHCAbIBwgAUE8ahD2DCABKAI8DQMgASkDKCEcIAEpAyAhGyACQQF2IQIMAAsACyABIB43A8ABIAEgHTcDyAEgASABQcABajYC0AEgCSAKasAgBcBKBEAgBC0ANA0GIAEgAUHuAWo2AmAgASABQfQAajYCXCABIAFB0AFqNgJYIAFBsAJqIAYgAUHYAGoQtAcgAS0AsAIiBEEpRw0DDA4LIAFBsAJqIAUgAxDMDiABKAKwAiICQZOAgIB4Rw0MIAFBgAJqIAYgAUHAAWoQzh8MCQsgASAFOgDtASABIAU6AO4BIAEgAzoA7wEgASAHIANrIgfAIgI2AsABQgohGyABQgo3A9ABQgEhHQNAAkAgAkEBcQRAIAFBEGogHSAdQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHUI/h1INBSACQQFGDQELIAEgGyAbQj+HIhwgGyAcEKgeIAEpAwggASkDACIbQj+HUg0EIAJBAXYhAgwBCwsgASAdNwPwASABIB1CAn8iGzcD+AEgAUIAIBt9NwPAASABIAFBwAFqNgLYASABIAFB+AFqNgLUASABIAFB8AFqNgLQASAKIAdrwCAFwE4EQCAELQA0DQYgASABQe0BajYCYCABIAFB7gFqNgJcIAEgAUHQAWo2AlggAUGwAmogBiABQdgAahCeBCABLQCwAiIEQSlGDQ0gAUH2AGogAS0AswIiAjoAACABQYgBaiABQdgCaikCADcDACABQYABaiABQdACaikCADcDACABIAI6AIMCIAEgAS8AsQIiAjsAgQIgASABKQLIAiIbNwKYAiABIAI7AXQgASAbNwN4IAEoArQCIQIgASkCuAIhHCABKQLAAiEbDAgLIAFBsAJqIAUgAxDMDiABKAKwAiICQZOAgIB4Rw0LIAFBgAJqIAYgAUHQAWoQxx8MBgsgAUECNgK0AiABQYiYgAE2ArACIAFCAjcCvAIgAUH6DzYCZCABQfsPNgJcIAEgAUHYAGo2ArgCIAEgAUH4AWo2AmAMAgsgAUHyAWogAS0AswIiAjoAACABQYgBaiABQdgCaikCADcDACABQYABaiABQdACaikCADcDACABIAI6AIMCIAEgAS8AsQIiAjsAgQIgASABKQLIAiIbNwKYAiABIAI7AfABIAEgGzcDeCABKAK0AiECIAEpArgCIRwgASkCwAIhGwwHCyABQQI2ArQCIAFBiJiAATYCsAIgAUICNwK8AiABQfoPNgJkIAFB/Q82AlwgASABQdgAajYCuAIgASABQcABajYCYAsgASABQdABajYCWCABQYQCaiABQbACahCZDiABKQKEAiEcQYiAgIB4IQIgASkCjAIMCQsgAUGAAmogBiABQdABaiABQe4BahDrBAwDCyABQYACaiAGIAFB0AFqIAFB7QFqEOMECyABQfYAaiABLQCDAjoAACABQYABaiABQaACaikCADcDACABQYgBaiABQagCaikCADcDACABIAEvAIECOwF0IAEgASkCmAI3A3ggASkCiAIhHCABKAKEAiECIAEpApACIhsgAS0AgAIiBEEpRg0GGgsgAUHSAWogAUH2AGotAAA6AAAgAUHgAGogAUGAAWopAwA3AwAgAUHoAGogAUGIAWopAwA3AwAgASABLwF0OwHQAQwCCyABQfIBaiABLQCDAjoAACABQYABaiABQaACaikCADcDACABQYgBaiABQagCaikCADcDACABIAEvAIECOwHwASABIAEpApgCNwN4IAEpAogCIRwgASgChAIhAiABKQKQAiIbIAEtAIACIgRBKUYNBBoLIAFB0gFqIAFB8gFqLQAAOgAAIAFB4ABqIAFBgAFqKQMANwMAIAFB6ABqIAFBiAFqKQMANwMAIAEgAS8B8AE7AdABCyABIAEpA3g3A1ggAUHQAmogAUHgAGopAwA3AgAgAUHYAmogAUHoAGopAwA3AgAgASAEOgCwAiABIAEvAdABOwCxAiABIBs3AsACIAEgHDcCuAIgASACNgK0AiABIAEpA1g3AsgCIAEgAUHSAWotAAA6ALMCIAFBgAJqIAFBsAJqIAUgAxChEyABLQCAAiIDQSlGBEAgAUGjAWogAUGUAmooAgAiAjYAACABQZsBaiABQYwCaikCACIbNwAAIAEgASkChAIiHDcAkwEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUGfAWoiBCABQZACaikAADcAACABQZgBaiIFIAFBiQJqKQAANwMAIAFBsAFqIgYgAUGgAmopAgA3AwAgAUG4AWoiByABQagCaikCADcDACABIAEpAIECNwOQASABIAEpApgCNwOoARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDkAE3AAkgAiABKQOoATcCICAAQbSYgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAQLDIMDCyABKQK0AiEcIAEpArwCDAELIAEpArgCIRwgASgCtAIhAiABKQLAAgs3AgwgACAcNwIEIAAgAjYCAAsgAUHgAmokAAz6AgsgBSAGEOghIQYgCSwAASEHIAktAAIhAiADLQABIQUgAy0AAiEDIwBBsAJrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAsAgA8BMBEAgASAFOgBEIAEgBToAuAEgASADOgC5ASABQdABakIKQgAQsi4gAUGAAmogASkD0AEgASkD2AEgASkD4AEgASkD6AEgAyACayICwBDfASABKAKAAkEBRgRAIAEpA4gCIRsgASgChAIhAiABKQOQAgwNCyABIAEpA6gCNwOoASABIAEpA6ACNwOgASABIAEpA5gCNwOYASABIAEpA5ACNwOQASABIAFBkAFqNgLIASACIAdqwCAFwEoEQCAELQA0DQQgASABQcQAajYCMCABIAFBuAFqNgIsIAEgAUHIAWo2AiggAUGAAmogBiABQShqEMIHIAEtAIACIgRBKUcNAgwMCyABQYACaiAFIAMQzw4gASgCgAIiAkGTgICAeEcNCiABQdABaiAGIAFBkAFqEMsfDAcLIAEgBToAtQEgASAFOgC2ASABIAM6ALcBIAEgAiADayIJwCICNgLIAUIKIRwgAUIKNwMoQgEhGwNAAkAgAkEBcQRAIAFBEGogGyAbQj+HIBwgHEI/hxCoHiABKQMYIAEpAxAiG0I/h1INBCACQQFGDQELIAEgHCAcQj+HIh0gHCAdEKgeIAEpAwggASkDACIcQj+HUg0DIAJBAXYhAgwBCwsgASAbNwO4ASABIBtCAn8iGzcDwAEgAUIAIBt9NwPIASABIAFByAFqNgIwIAEgAUHAAWo2AiwgASABQbgBajYCKCAHIAlrwCAFwE4EQCAELQA0DQQgASABQbUBajYCUCABIAFBtgFqNgJMIAEgAUEoajYCSCABQYACaiAGIAFByABqEP0DIAEtAIACIgRBKUYNCyABQcYAaiABLQCDAiICOgAAIAFBoAFqIAFBqAJqKQIANwMAIAFBmAFqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsBRCABIBs3A5ABIAEoAoQCIQIgASkCiAIhGyABKQKQAiEcDAYLIAFBgAJqIAUgAxDPDiABKAKAAiICQZOAgIB4Rw0JIAFB0AFqIAYgAUEoahDQHwwECyABQcIBaiABLQCDAiICOgAAIAFB2ABqIAFBqAJqKQIANwMAIAFB0ABqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsBwAEgASAbNwNIIAEoAoQCIQIgASkCiAIhGyABKQKQAiEcDAYLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AlQgAUH9DzYCTCABIAFByABqNgKIAiABIAFByAFqNgJQIAEgAUEoajYCSCABQdQBaiABQYACahCZDiABKQLUASEbQYiAgIB4IQIgASkC3AEMCQsgAUHQAWogBiABQcgBaiABQcQAahD0BAwDCyABQdABaiAGIAFBKGogAUG1AWoQ/QQLIAFBxgBqIAEtANMBOgAAIAFBmAFqIAFB8AFqKQIANwMAIAFBoAFqIAFB+AFqKQIANwMAIAEgAS8A0QE7AUQgASABKQLoATcDkAEgASkC2AEhGyABKALUASECIAEpAuABIhwgAS0A0AEiBEEpRg0GGgsgAUHKAWogAUHGAGotAAA6AAAgAUEwaiABQZgBaikDADcDACABQThqIAFBoAFqKQMANwMAIAEgAS8BRDsByAEgASABKQOQATcDKAwCCyABQcIBaiABLQDTAToAACABQdAAaiABQfABaikCADcDACABQdgAaiABQfgBaikCADcDACABIAEvANEBOwHAASABIAEpAugBNwNIIAEpAtgBIRsgASgC1AEhAiABKQLgASIcIAEtANABIgRBKUYNBBoLIAFBygFqIAFBwgFqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAcABOwHIASABIAEpA0g3AygLIAFBoAJqIAFBMGopAwA3AgAgAUGoAmogAUE4aikDADcCACABIAQ6AIACIAEgAS8ByAE7AIECIAEgHDcCkAIgASAbNwKIAiABIAI2AoQCIAEgASkDKDcCmAIgASABQcoBai0AADoAgwIgAUHQAWogAUGAAmogBSADEKMTIAEtANABIgNBKUYEQCABQfMAaiABQeQBaigCACICNgAAIAFB6wBqIAFB3AFqKQIAIhs3AAAgASABKQLUASIcNwBjIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLIAFB7wBqIgQgAUHgAWopAAA3AAAgAUHoAGoiBSABQdkBaikAADcDACABQYABaiIGIAFB8AFqKQIANwMAIAFBiAFqIgcgAUH4AWopAgA3AwAgASABKQDRATcDYCABIAEpAugBNwN4ELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNgNwAJIAIgASkDeDcCICAAQYyZgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAQLDIIDCyABKQKEAiEbIAEpAowCDAELIAEpAogCIRsgASgChAIhAiABKQKQAgs3AgwgACAbNwIEIAAgAjYCAAsgAUGwAmokAAz5AgsgDUENa0H/AXFBB0kNCyAJQQJqIQIjAEFAaiIBJAAgASADNgIQIAEgCTYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIAItAAAgBBCmAgwMCyAAIAUgBiACLQAAIAQQoQIMCwsgACAFIAYgAi0AACAEEKICDAoLIAAgBSAGIAItAAAgBBC/AgwJCyAAIAUgBiACLQAAIAQQpwIMCAsgACAFIAYgAi0AACAEEKQCDAcLIAAgBSAGIAItAAAgBBClAgwGCyAAIAUgBiACLQAAIAQQqAIMBQsgACAFIAYgAUE/aiACENUgDAQLIAAgBSAGIAFBP2ogAhDSIAwDCyAAIAUgBiAEEJEJDAILIAAgBSAGIAQQkgkMAQsgACAFIAYgBBCnAQsgAUFAayQADPgCCyAFIAYQ/CEhCiAJLAABIQsgCS0AAiEJIAMtAAEhBSADLQACIQYjAEHgAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCcAgBsBMBEAgASAFOgC+ASABIAU6AGwgASAGOgBtIAEgBiAJayIMwCICNgLQAkEKIQcgAUEKNgLAAUEBIQMCQCAGIAlGDQADQCACQQFxBEAgA6wgB6x+IhtCIIinIBunIgNBH3VHDQQgAkEBRg0CCyAHrCIbIBt+IhtCIIinIBunIgdBH3VHDQMgAkEBdiECDAALAAsgASADNgLEAiABIAFBxAJqNgLQAiALIAxqwCAFwEoEQCAELQA0DQYgASABQb4BajYCWCABIAFB7ABqNgJUIAEgAUHQAmo2AlAgAUGUAmogCiABQdAAahC7ByABLQCUAiIHQSlHDQMgASkCpAIhGyABKAKgAiEDIAEoApwCIQQgASgCmAIhAgwMCyABQZQCaiAFIAYQzg4gASgClAIiAkGTgICAeEcEQCABKQKgAiEbIAEoApwCIQMgASgCmAIhBAwMCyABQeQBaiAKIAFBxAJqEKsdDAoLIAEgBToAvQEgASAFOgC+ASABIAY6AL8BIAEgCSAGayIDwCICNgLEAiABQgA3A9gCQgohGyABQgo3A9ACQgEhHgNAAkAgAkEBcQRAIAFBADYCTCABQTBqIB4gHSAbIBwgAUHMAGoQ9gwgASgCTA0FIAEpAzghHSABKQMwIR4gAkEBRg0BCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0EIAEpAwghHCABKQMAIRsgAkEBdiECDAELCyABIB43A8ABIAEgHTcDyAEgAUEgaiAeIB1CAkIAEIMZIAEgASkDICIbNwPQAiABIAEpAygiHDcD2AIgAUIAIBt9NwNQIAFCACAcIBtCAFKtfH03A1ggASABQdAAajYC4AEgASABQdACajYC3AEgASABQcABajYC2AEgCyADa8AgBcBOBEAgBC0ANA0GIAEgAUG9AWo2AswCIAEgAUG+AWo2AsgCIAEgAUHYAWo2AsQCIAFBlAJqIAogAUHEAmoQugcgAS0AlAIiB0EpRw0EIAEpAqQCIRsgASkCnAIhHCABKAKYAiECDAgLIAFBlAJqIAUgBhDODiABKAKUAiICQZOAgIB4RwRAIAEpAqACIRsgASkCmAIhHAwICyABQeQBaiAKIAFB2AFqEKodDAYLIAFBAjYCmAIgAUGImIABNgKUAiABQgI3AqACIAFB+g82AlwgAUH8DzYCVCABIAFB0ABqNgKcAiABIAFB0AJqNgJYIAEgAUHAAWo2AlAgAUHoAWogAUGUAmoQmQ4gASgC6AEhBCABKALsASEDIAEpAvABIRtBiICAgHghAgwJCyABQYQCaiABQbQCaikCACIcNwIAIAFBjAJqIAFBvAJqKQIAIh03AgAgAUHaAWogAS0AlwIiAjoAACABIAI6AOcBIAEgAS8AlQIiAjsA5QEgASABKQKsAiIeNwL8ASABIAI7AdgBIAEoApgCIQIgASgCnAIhBCABKAKgAiEDIAEpAqQCIRsgAUGAAWogHTcDACABQfgAaiAcNwMAIAEgHjcDcAwKCyABQQI2ApgCIAFBiJiAATYClAIgAUICNwKgAiABQfoPNgJcIAFB+w82AlQgASABQdAAajYCnAIgASABQcQCajYCWCABIAFB0AJqNgJQIAFB6AFqIAFBlAJqEJkOIAEpAugBIRwgASkC8AEhG0GIgICAeCECDAQLIAFB7gBqIAEtAJcCIgI6AAAgAUGAAWogAUG8AmopAgA3AwAgAUH4AGogAUG0AmopAgA3AwAgASACOgDnASABIAEvAJUCIgI7AOUBIAEgASkCrAIiGzcC/AEgASACOwFsIAEgGzcDcCABKAKYAiECIAEpApwCIRwgASkCpAIhGwwECyABQeQBaiAKIAFB0AJqIAFBvgFqEM4EDAQLIAFB5AFqIAogAUHYAWogAUG9AWoQ5gQLIAFB7gBqIAEtAOcBOgAAIAFB+ABqIAFBhAJqKQIANwMAIAFBgAFqIAFBjAJqKQIANwMAIAEgAS8A5QE7AWwgASABKQL8ATcDcCABKQL0ASEbIAEpAuwBIRwgASgC6AEhAiABLQDkASIHQSlHDQELIAAgHDcCBAwDCyABQdICaiABQe4Aai0AADoAACABQdgAaiABQfgAaikDADcDACABQeAAaiABQYABaikDADcDACABIAEvAWw7AdACIAEgASkDcDcDUAwECyABQdoBaiABLQDnAToAACABQfgAaiABQYQCaikCADcDACABQYABaiABQYwCaikCADcDACABIAEvAOUBOwHYASABIAEpAvwBNwNwIAEpAvQBIRsgASgC8AEhAyABKALsASEEIAEoAugBIQIgAS0A5AEiB0EpRw0CCyAAIAM2AgggACAENgIECyAAIAI2AgAgACAbNwIMDAILIAFB0gJqIAFB2gFqLQAAOgAAIAFB2ABqIAFB+ABqKQMANwMAIAFB4ABqIAFBgAFqKQMANwMAIAEgAS8B2AE7AdACIAEgASkDcDcDUCAErSADrUIghoQhHAsgAUG0AmogAUHYAGopAwA3AgAgAUG8AmogAUHgAGopAwA3AgAgASAHOgCUAiABIAEvAdACOwCVAiABIBs3AqQCIAEgHDcCnAIgASACNgKYAiABIAEpA1A3AqwCIAEgAUHSAmotAAA6AJcCIAFB5AFqIAFBlAJqIAUgBhCgEyABLQDkASIDQSlGBEAgAUGbAWogAUH4AWooAgAiAjYAACABQZMBaiABQfABaikCACIbNwAAIAEgASkC6AEiHDcAiwEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUGXAWoiBCABQfQBaikAADcAACABQZABaiIFIAFB7QFqKQAANwMAIAFBqAFqIgYgAUGEAmopAgA3AwAgAUGwAWoiByABQYwCaikCADcDACABIAEpAOUBNwOIASABIAEpAvwBNwOgARCwPkE4QQQQrTYiAkUN/gIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQOIATcACSACIAEpA6ABNwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4AJqJAAMAAsM9wILIAUgBhD8ISEGIAksAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQYADayIBJAACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHwCADwEwEQCABIAU6AN4BIAEgBToAjAEgASADOgCNASABIAMgB2siCcAiAjYC5AJCCiEbIAFCCjcD8AJCASEdAkAgAyAHRg0AA0AgAkEBcQRAIAFB4ABqIB0gHUI/hyAbIBtCP4cQqB4gASkDaCABKQNgIh1CP4dSDQQgAkEBRg0CCyABQdAAaiAbIBtCP4ciHCAbIBwQqB4gASkDWCABKQNQIhtCP4dSDQMgAkEBdiECDAALAAsgASAdNwPgASABIAFB4AFqNgLwAiAJIApqwCAFwEoEQCAELQA0DQYgASABQd4BajYCeCABIAFBjAFqNgJ0IAEgAUHwAmo2AnAgAUG0AmogBiABQfAAahCvByABLQC0AiIEQSlHDQMMDgsgAUG0AmogBSADEM0OIAEoArQCIgJBk4CAgHhHDQwgAUGEAmogBiABQeABahCnHQwJCyABIAU6AN0BIAEgBToA3gEgASADOgDfASABIAcgA2siB8AiAjYC5AIgAUIANwP4AkIKIRsgAUIKNwPwAkIBIR4DQAJAIAJBAXEEQCABQQA2AkwgAUEwaiAeIB0gGyAcIAFBzABqEPYMIAEoAkwNBSABKQM4IR0gASkDMCEeIAJBAUYNAQsgAUEANgIcIAEgGyAcIBsgHCABQRxqEPYMIAEoAhwNBCABKQMIIRwgASkDACEbIAJBAXYhAgwBCwsgASAeNwPgASABIB03A+gBIAFBIGogHiAdQgJCABCDGSABIAEpAyAiGzcD8AIgASABKQMoIhw3A/gCIAFCACAbfTcDcCABQgAgHCAbQgBSrXx9NwN4IAEgAUHwAGo2AoACIAEgAUHwAmo2AvwBIAEgAUHgAWo2AvgBIAogB2vAIAXATgRAIAQtADQNBiABIAFB3QFqNgLsAiABIAFB3gFqNgLoAiABIAFB+AFqNgLkAiABQbQCaiAGIAFB5AJqELAHIAEtALQCIgRBKUYNDSABQY4BaiABLQC3AiICOgAAIAFBoAFqIAFB3AJqKQIANwMAIAFBmAFqIAFB1AJqKQIANwMAIAEgAjoAhwIgASABLwC1AiICOwCFAiABIAEpAswCIhs3ApwCIAEgAjsBjAEgASAbNwOQASABKAK4AiECIAEpArwCIRwgASkCxAIhGwwICyABQbQCaiAFIAMQzQ4gASgCtAIiAkGTgICAeEcNCyABQYQCaiAGIAFB+AFqEKYdDAYLIAFBAjYCuAIgAUGImIABNgK0AiABQgI3AsACIAFB+g82AnwgAUH9DzYCdAwCCyABQfoBaiABLQC3AiICOgAAIAFBoAFqIAFB3AJqKQIANwMAIAFBmAFqIAFB1AJqKQIANwMAIAEgAjoAhwIgASABLwC1AiICOwCFAiABIAEpAswCIhs3ApwCIAEgAjsB+AEgASAbNwOQASABKAK4AiECIAEpArwCIRwgASkCxAIhGwwHCyABQQI2ArgCIAFBiJiAATYCtAIgAUICNwLAAiABQfoPNgJ8IAFB+w82AnQLIAEgAUHwAGo2ArwCIAEgAUHkAmo2AnggASABQfACajYCcCABQYgCaiABQbQCahCZDiABKQKIAiEcQYiAgIB4IQIgASkCkAIMCQsgAUGEAmogBiABQfACaiABQd4BahDHBAwDCyABQYQCaiAGIAFB+AFqIAFB3QFqEPgECyABQY4BaiABLQCHAjoAACABQZgBaiABQaQCaikCADcDACABQaABaiABQawCaikCADcDACABIAEvAIUCOwGMASABIAEpApwCNwOQASABKQKMAiEcIAEoAogCIQIgASkClAIiGyABLQCEAiIEQSlGDQYaCyABQfICaiABQY4Bai0AADoAACABQfgAaiABQZgBaikDADcDACABQYABaiABQaABaikDADcDACABIAEvAYwBOwHwAgwCCyABQfoBaiABLQCHAjoAACABQZgBaiABQaQCaikCADcDACABQaABaiABQawCaikCADcDACABIAEvAIUCOwH4ASABIAEpApwCNwOQASABKQKMAiEcIAEoAogCIQIgASkClAIiGyABLQCEAiIEQSlGDQQaCyABQfICaiABQfoBai0AADoAACABQfgAaiABQZgBaikDADcDACABQYABaiABQaABaikDADcDACABIAEvAfgBOwHwAgsgASABKQOQATcDcCABQdQCaiABQfgAaikDADcCACABQdwCaiABQYABaikDADcCACABIAQ6ALQCIAEgAS8B8AI7ALUCIAEgGzcCxAIgASAcNwK8AiABIAI2ArgCIAEgASkDcDcCzAIgASABQfICai0AADoAtwIgAUGEAmogAUG0AmogBSADEKITIAEtAIQCIgNBKUYEQCABQbsBaiABQZgCaigCACICNgAAIAFBswFqIAFBkAJqKQIAIhs3AAAgASABKQKIAiIcNwCrASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECyABQbcBaiIEIAFBlAJqKQAANwAAIAFBsAFqIgUgAUGNAmopAAA3AwAgAUHIAWoiBiABQaQCaikCADcDACABQdABaiIHIAFBrAJqKQIANwMAIAEgASkAhQI3A6gBIAEgASkCnAI3A8ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQOoATcACSACIAEpA8ABNwIgIABBvJqAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBAsM/wILIAEpArgCIRwgASkCwAIMAQsgASkCvAIhHCABKAK4AiECIAEpAsQCCzcCDCAAIBw3AgQgACACNgIACyABQYADaiQADPYCCyAFIAYQ/CEhBiAJLQABIQogCS0AAiEHIAMtAAEhBSADLQACIQMjAEHAA2siASQAAkACQAJAAkACQAJAAkACQAJAAkAgAyAHRiAFIApPcUUEQAJAAkACQAJAIAfAIAPASgRAIAEgBToAlQIgASAFOgCWAiABIAM6AJcCIAEgByADayIHwCICNgKkAiABQgA3A6gDQgohGyABQgo3A6ADQgEhHQNAAkAgAkEBcQRAIAFBADYCTCABQTBqIB0gHiAbIBwgAUHMAGoQ9gwgASgCTA0EIAEpAzghHiABKQMwIR0gAkEBRg0BCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0DIAEpAwghHCABKQMAIRsgAkEBdiECDAELCyABIB03A7ACIAEgHjcDuAIgAUEgaiAdIB5CAkIAEIMZIAEgASkDICIbNwOgAyABIAEpAygiHDcDqAMgAUIAIBt9NwOwAyABQgAgHCAbQgBSrXx9NwO4AyABIAFBsANqNgKgAiABIAFBoANqNgKcAiABIAFBsAJqNgKYAiAKIAdrwCAFwE4EQCAELQA0DQcgASABQZUCajYCrAIgASABQZYCajYCqAIgASABQZgCajYCpAIgAUHwAmogBiABQaQCahCHAyABLQDwAiIEQSlHDQMgASkCgAMhGyABKQL4AiEcIAEoAvQCIQIMDQsgAUHwAmogBSADEMwOIAEoAvACIgJBk4CAgHhHBEAgASkC/AIhGyABKQL0AiEcDA0LIAFBwAJqIAYgAUGYAmoQqB0MCwsgASAFOgCWAiABIAU6ANwBIAEgAzoA3QEgASADIAdrIgnAIgI2AqQCIAFCADcDqANCCiEbIAFCCjcDoANCASEdAkAgAyAHRg0AA0AgAkEBcQRAIAFBADYCjAEgAUHwAGogHSAeIBsgHCABQYwBahD2DCABKAKMAQ0FIAEpA3ghHiABKQNwIR0gAkEBRg0CCyABQQA2AmwgAUHQAGogGyAcIBsgHCABQewAahD2DCABKAJsDQQgASkDWCEcIAEpA1AhGyACQQF2IQIMAAsACyABIB03A7ACIAEgHjcDuAIgASABQbACajYCoAMgCSAKasAgBcBKBEAgBC0ANA0HIAEgAUGWAmo2ArgDIAEgAUHcAWo2ArQDIAEgAUGgA2o2ArADIAFB8AJqIAYgAUGwA2oQvgcgAS0A8AIiBEEpRw0EIAEpAoADIRsgASkC+AIhHCABKAL0AiECDAkLIAFB8AJqIAUgAxDMDiABKALwAiICQZOAgIB4RwRAIAEpAvwCIRsgASkC9AIhHAwJCyABQcACaiAGIAFBsAJqELEdDAcLIAFBAjYC9AIgAUGImIABNgLwAiABQgI3AvwCIAFB+g82ArwDIAFB+w82ArQDIAEgAUGwA2o2AvgCIAEgAUGkAmo2ArgDIAEgAUGgA2o2ArADIAFBxAJqIAFB8AJqEJkOIAEpAsQCIRwgASkCzAIhG0GIgICAeCECDAoLIAFB3gFqIAEtAPMCIgI6AAAgAUHQAWogAUGYA2opAgA3AwAgAUHIAWogAUGQA2opAgA3AwAgASACOgDDAiABIAEvAPECIgI7AMECIAEgASkCiAMiGzcC2AIgASACOwHcASABIBs3A8ABIAEoAvQCIQIgASkC+AIhHCABKQKAAyEbDAoLIAFBAjYC9AIgAUGImIABNgLwAiABQgI3AvwCIAFB+g82ArwDIAFB+w82ArQDIAEgAUGwA2o2AvgCIAEgAUGkAmo2ArgDIAEgAUGgA2o2ArADIAFBxAJqIAFB8AJqEJkOIAEpAsQCIRwgASkCzAIhG0GIgICAeCECDAULIAFBmgJqIAEtAPMCIgI6AAAgAUHQAWogAUGYA2opAgA3AwAgAUHIAWogAUGQA2opAgA3AwAgASACOgDDAiABIAEvAPECIgI7AMECIAEgASkCiAMiGzcC2AIgASACOwGYAiABIBs3A8ABIAEoAvQCIQIgASkC+AIhHCABKQKAAyEbDAULIAFBkAFqIAYQgBUMCAsgAUHAAmogBiABQZgCaiABQZUCahDCBAwECyABQcACaiAGIAFBoANqIAFBlgJqEOQECyABQZoCaiABLQDDAjoAACABQcgBaiABQeACaikCADcDACABQdABaiABQegCaikCADcDACABIAEvAMECOwGYAiABIAEpAtgCNwPAASABKQLQAiEbIAEpAsgCIRwgASgCxAIhAiABLQDAAiIEQSlHDQELIAAgGzcCDCAAIBw3AgQgACACNgIADAULIAFBsAFqIAFByAFqKQMANwIAIAFBuAFqIAFB0AFqKQMANwIAIAEgAS8BmAI7AJEBIAEgASkDwAE3AqgBIAEgAUGaAmotAAA6AJMBIAEgGzcCoAEgASAcNwKYASABIAI2ApQBIAEgBDoAkAEMAwsgAUHeAWogAS0AwwI6AAAgAUHIAWogAUHgAmopAgA3AwAgAUHQAWogAUHoAmopAgA3AwAgASABLwDBAjsB3AEgASABKQLYAjcDwAEgASkC0AIhGyABKQLIAiEcIAEoAsQCIQIgAS0AwAIiBEEpRw0BCyAAIBs3AgwgACAcNwIEIAAgAjYCAAwCCyABQbABaiABQcgBaikDADcCACABQbgBaiABQdABaikDADcCACABIAEvAdwBOwCRASABIAEpA8ABNwKoASABIAFB3gFqLQAAOgCTASABIBs3AqABIAEgHDcCmAEgASACNgKUASABIAQ6AJABCyABQfACaiABQZABaiAFIAMQoRMgAS0A8AIiA0EpRgRAIAFB8wFqIAFBhANqKAIAIgI2AAAgAUHrAWogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB7wFqIgQgAUGAA2opAAA3AAAgAUHoAWoiBSABQfkCaikAADcDACABQYACaiIGIAFBkANqKQIANwMAIAFBiAJqIgcgAUGYA2opAgA3AwAgASABKQDxAjcD4AEgASABKQKIAzcD+AEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA+ABNwAJIAIgASkD+AE3AiAgAEG0mIABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwBCwz7AgsgAUHAA2okAAz1AgsgBSAGEPwhIQYgCSwAASEHIAktAAIhAiADLQABIQUgAy0AAiEDIwBBgANrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAsAgA8BMBEAgASAFOgBsIAEgBToAhAIgASADOgCFAiABQZACakIKQgAQsi4gAUHAAmogASkDkAIgASkDmAIgASkDoAIgASkDqAIgAyACayICwBDfASABKALAAkEBRgRAIAEpA8gCIRsgASgCxAIhAiABKQPQAgwNCyABIAEpA+gCNwPYASABIAEpA+ACNwPQASABIAEpA9gCNwPIASABIAEpA9ACNwPAASABIAFBwAFqNgLwASACIAdqwCAFwEoEQCAELQA0DQQgASABQewAajYCWCABIAFBhAJqNgJUIAEgAUHwAWo2AlAgAUHAAmogBiABQdAAahC2ByABLQDAAiIEQSlHDQIMDAsgAUHAAmogBSADEM8OIAEoAsACIgJBk4CAgHhHDQogAUGQAmogBiABQcABahCsHQwHCyABIAU6AO0BIAEgBToA7gEgASADOgDvASABIAIgA2siCcAiAjYC9AIgAUIANwNYQgohHCABQgo3A1BCASEeA0ACQCACQQFxBEAgAUEANgJMIAFBMGogHiAdIBwgGyABQcwAahD2DCABKAJMDQQgASkDOCEdIAEpAzAhHiACQQFGDQELIAFBADYCHCABIBwgGyAcIBsgAUEcahD2DCABKAIcDQMgASkDCCEbIAEpAwAhHCACQQF2IQIMAQsLIAEgHjcD8AEgASAdNwP4ASABQSBqIB4gHUICQgAQgxkgASABKQMgIhs3A1AgASABKQMoIhw3A1ggAUIAIBt9NwNwIAFCACAcIBtCAFKtfH03A3ggASABQfAAajYCjAIgASABQdAAajYCiAIgASABQfABajYChAIgByAJa8AgBcBOBEAgBC0ANA0EIAEgAUHtAWo2AvwCIAEgAUHuAWo2AvgCIAEgAUGEAmo2AvQCIAFBwAJqIAYgAUH0AmoQ7AIgAS0AwAIiBEEpRg0LIAFB7gBqIAEtAMMCIgI6AAAgAUHQAWogAUHoAmopAgA3AwAgAUHIAWogAUHgAmopAgA3AwAgASACOgCTAiABIAEvAMECIgI7AJECIAEgASkC2AIiGzcCqAIgASACOwFsIAEgGzcDwAEgASgCxAIhAiABKQLIAiEbIAEpAtACIRwMBgsgAUHAAmogBSADEM8OIAEoAsACIgJBk4CAgHhHDQkgAUGQAmogBiABQYQCahC2HQwECyABQfYCaiABLQDDAiICOgAAIAFBgAFqIAFB6AJqKQIANwMAIAFB+ABqIAFB4AJqKQIANwMAIAEgAjoAkwIgASABLwDBAiICOwCRAiABIAEpAtgCIhs3AqgCIAEgAjsB9AIgASAbNwNwIAEoAsQCIQIgASkCyAIhGyABKQLQAiEcDAYLIAFBAjYCxAIgAUGImIABNgLAAiABQgI3AswCIAFB+g82AnwgAUH7DzYCdCABIAFB8ABqNgLIAiABIAFB9AJqNgJ4IAEgAUHQAGo2AnAgAUGUAmogAUHAAmoQmQ4gASkClAIhG0GIgICAeCECIAEpApwCDAkLIAFBkAJqIAYgAUHwAWogAUHsAGoQ4AQMAwsgAUGQAmogBiABQYQCaiABQe0BahD3BAsgAUHuAGogAS0AkwI6AAAgAUHIAWogAUGwAmopAgA3AwAgAUHQAWogAUG4AmopAgA3AwAgASABLwCRAjsBbCABIAEpAqgCNwPAASABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQYaCyABQfIBaiABQe4Aai0AADoAACABQdgAaiABQcgBaikDADcDACABQeAAaiABQdABaikDADcDACABIAEvAWw7AfABIAEgASkDwAE3A1AMAgsgAUH2AmogAS0AkwI6AAAgAUH4AGogAUGwAmopAgA3AwAgAUGAAWogAUG4AmopAgA3AwAgASABLwCRAjsB9AIgASABKQKoAjcDcCABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQQaCyABQfIBaiABQfYCai0AADoAACABQdgAaiABQfgAaikDADcDACABQeAAaiABQYABaikDADcDACABIAEvAfQCOwHwASABIAEpA3A3A1ALIAFB4AJqIAFB2ABqKQMANwIAIAFB6AJqIAFB4ABqKQMANwIAIAEgBDoAwAIgASABLwHwATsAwQIgASAcNwLQAiABIBs3AsgCIAEgAjYCxAIgASABKQNQNwLYAiABIAFB8gFqLQAAOgDDAiABQZACaiABQcACaiAFIAMQoxMgAS0AkAIiA0EpRgRAIAFBowFqIAFBpAJqKAIAIgI2AAAgAUGbAWogAUGcAmopAgAiGzcAACABIAEpApQCIhw3AJMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLIAFBnwFqIgQgAUGgAmopAAA3AAAgAUGYAWoiBSABQZkCaikAADcDACABQbABaiIGIAFBsAJqKQIANwMAIAFBuAFqIgcgAUG4AmopAgA3AwAgASABKQCRAjcDkAEgASABKQKoAjcDqAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA5ABNwAJIAIgASkDqAE3AiAgAEGMmYABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwz9AgsgASkCxAIhGyABKQLMAgwBCyABKQLIAiEbIAEoAsQCIQIgASkC0AILNwIMIAAgGzcCBCAAIAI2AgALIAFBgANqJAAM9AILIA1BDWtB/wFxQQdJDQYgCUECaiECIwBBQGoiASQAIAEgAzYCECABIAk2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAADhsBAAIDBAUGBwgJAAoLAAAAAAAAAAAAAAAMDQ4ACyABQQM2AhggAUHY3/8ANgIUIAFCAjcCICABQa8DNgI4IAFBrwM2AjAgASABQSxqNgIcIAEgAUEQajYCNCABIAFBDGo2AiwgAEEEaiABQRRqEJkOIABBgoCAgHg2AgAMDgsgASADIAUgBigCJBEEABChKyAAIAEpAwA3AgQgAEGTgICAeDYCAAwNCyAAIAUgBiACLQAAIAQQ9gEMDAsgACAFIAYgAi0AACAEEPIBDAsLIAAgBSAGIAItAAAgBBDxAQwKCyAAIAUgBiACLQAAIAQQ/AEMCQsgACAFIAYgAi0AACAEEPsBDAgLIAAgBSAGIAItAAAgBBD6AQwHCyAAIAUgBiACLQAAIAQQ+QEMBgsgACAFIAYgAi0AACAEEJICDAULIAAgBSAGIAFBP2ogAhDUIAwECyAAIAUgBiABQT9qIAIQ2CAMAwsgACAFIAYgBBCRCQwCCyAAIAUgBiAEEJIJDAELIAAgBSAGIAQQpwELIAFBQGskAAzzAgsgBSAGEOMhIQogCSwAASELIAktAAIhCSADLQABIQYgAy0AAiEHIwBB4AJrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJwCAHwEwEQCABIAY6AF4gASAGOgAkIAEgBzoAJSABIAcgCWsiDMAiAjYCYEEKIQMgAUEKNgIIQQEhBQJAIAcgCUYNAANAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNBCACQQFGDQILIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNAyACQQF2IQIMAAsACyABIAU2AoQCIAEgAUGEAmo2AmAgCyAMasAgBsBKBEAgBC0ANA0FIAEgAUHeAGo2AogBIAEgAUEkajYChAEgASABQeAAajYCgAEgAUGQAmogCiABQYABahCzByABLQCQAiIEQSlHDQMgASkCoAIhGyABKAKcAiEDIAEoApgCIQUgASgClAIhAgwLCyABQZACaiAGIAcQzg4gASgCkAIiAkGTgICAeEcEQCABKQKcAiEbIAEoApgCIQMgASgClAIhBQwLCyABQdABaiAKIAFBhAJqEK8dDAkLIAEgBjoAXSABIAY6AF4gASAHOgBfIAFB0AFqQgpCABCyLiABQZACaiABKQPQASABKQPYASABKQPgASABKQPoASAJIAdrIgLAEN8BIAEoApACQQFGBEAgASkDoAIhGyABKQOYAiEcIAEoApQCIQIMBwsgASABKQO4AiIbNwN4IAEgASkDsAIiHDcDcCABIAEpA6gCIh03A2ggASABKQOgAiIeNwNgIAFBkAJqIgMQ7CwgASgCkAJBAXFFDZADIAMgHiAdIBwgGyABKQOgAiABKQOoAiABKQOwAiABKQO4AhCaCCABAn4gAS0AkAJBAUYEQCABLQCRAgRAQoCAgICAgICAgH8hHEIAIRtCACEdQgAMAgsgAUEANgLgASABQQE2AtQBIAFBjJSAATYC0AEgAUIENwLYASABQdABakGUlIABEO8sAAsgASkDuAIhHCABKQOwAiEdIAEpA6gCIRsgASkDoAILIh43A4ABIAEgGzcDiAEgASAdNwOQASABIBw3A5gBIAFCACAbIB5CAFKtfH0iGzcDqAEgAUIAIB59Ih43A6ABIAEgHkIAUiAbQgBSIBtQG0F/c61CAYMiGyAdQn+FfCIdNwOwASABIBsgHVatIBxCf4V8NwO4ASABIAFBoAFqNgLMASABIAFBgAFqNgLIASABIAFB4ABqNgLEASALIAJrwCAGwE4EQCAELQA0DQUgASABQd0AajYCjAIgASABQd4AajYCiAIgASABQcQBajYChAIgAUGQAmogCiABQYQCahCkAyABLQCQAiIEQSlHDQMgASkCoAIhGyABKQKYAiEcIAEoApQCIQIMBwsgAUGQAmogBiAHEM4OIAEoApACIgJBk4CAgHhHBEAgASkCnAIhGyABKQKUAiEcDAcLIAFB0AFqIAogAUHEAWoQqR0MBQsgAUECNgKUAiABQYiYgAE2ApACIAFCAjcCnAIgAUH6DzYCjAEgAUH8DzYChAEgASABQYABajYCmAIgASABQeAAajYCiAEgASABQQhqNgKAASABQdQBaiABQZACahCZDiABKALUASEFIAEoAtgBIQMgASkC3AEhG0GIgICAeCECDAgLIAFB8AFqIAFBsAJqKQIAIhw3AgAgAUH4AWogAUG4AmopAgAiHTcCACABQcYBaiABLQCTAiICOgAAIAEgAjoA0wEgASABLwCRAiICOwDRASABIAEpAqgCIh43AugBIAEgAjsBxAEgASgClAIhAiABKAKYAiEFIAEoApwCIQMgASkCoAIhGyABQbABaiAdNwMAIAFBqAFqIBw3AwAgASAeNwOgAQwJCyABQSZqIAEtAJMCIgI6AAAgAUEYaiABQbgCaikCADcDACABQRBqIAFBsAJqKQIANwMAIAEgAjoA0wEgASABLwCRAiICOwDRASABIAEpAqgCIhs3AugBIAEgAjsBJCABIBs3AwggASgClAIhAiABKQKYAiEcIAEpAqACIRsMBAsgAUHQAWogCiABQeAAaiABQd4AahD+BAwECyABQdABaiAKIAFBxAFqIAFB3QBqEJ8DCyABQSZqIAEtANMBOgAAIAFBEGogAUHwAWopAgA3AwAgAUEYaiABQfgBaikCADcDACABIAEvANEBOwEkIAEgASkC6AE3AwggASkC4AEhGyABKQLYASEcIAEoAtQBIQIgAS0A0AEiBEEpRw0BCyAAIBw3AgQMAwsgAUHiAGogAUEmai0AADoAACABQYgBaiABQRBqKQMANwMAIAFBkAFqIAFBGGopAwA3AwAgASABLwEkOwFgIAEgASkDCDcDgAEMBAsgAUHGAWogAS0A0wE6AAAgAUGoAWogAUHwAWopAgA3AwAgAUGwAWogAUH4AWopAgA3AwAgASABLwDRATsBxAEgASABKQLoATcDoAEgASkC4AEhGyABKALcASEDIAEoAtgBIQUgASgC1AEhAiABLQDQASIEQSlHDQILIAAgAzYCCCAAIAU2AgQLIAAgAjYCACAAIBs3AgwMAgsgAUHiAGogAUHGAWotAAA6AAAgAUGIAWogAUGoAWopAwA3AwAgAUGQAWogAUGwAWopAwA3AwAgASABLwHEATsBYCABIAEpA6ABNwOAASAFrSADrUIghoQhHAsgAUGwAmogAUGIAWopAwA3AgAgAUG4AmogAUGQAWopAwA3AgAgASAEOgCQAiABIAEvAWA7AJECIAEgGzcCoAIgASAcNwKYAiABIAI2ApQCIAEgASkDgAE3AqgCIAEgAUHiAGotAAA6AJMCIAFB0AFqIAFBkAJqIAYgBxCgEyABLQDQASIDQSlGBEAgAUE7aiABQeQBaigCACICNgAAIAFBM2ogAUHcAWopAgAiGzcAACABIAEpAtQBIhw3ACsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUE3aiIEIAFB4AFqKQAANwAAIAFBMGoiBSABQdkBaikAADcDACABQcgAaiIGIAFB8AFqKQIANwMAIAFB0ABqIgcgAUH4AWopAgA3AwAgASABKQDRATcDKCABIAEpAugBNwNAELA+QThBBBCtNiICRQ35AiACIAM6AAggAkKBgICAEDcCACACIAEpAyg3AAkgAiABKQNANwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4AJqJAAMAAsM8gILIAUgBhDjISEGIAksAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQYADayIBJAACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAIAfAIAPATARAIAEgBToAfiABIAU6AEQgASADOgBFIAEgAyAHayIJwCICNgKkAkIKIRwgAUIKNwOAAUIBIR0CQCADIAdGDQADQCACQQFxBEAgAUEQaiAdIB1CP4cgHCAcQj+HEKgeIAEpAxggASkDECIdQj+HUg0EIAJBAUYNAgsgASAcIBxCP4ciGyAcIBsQqB4gASkDCCABKQMAIhxCP4dSDQMgAkEBdiECDAALAAsgASAdNwMoIAEgAUEoajYCgAEgCSAKasAgBcBKBEAgBC0ANA0EIAEgAUH+AGo2AqgBIAEgAUHEAGo2AqQBIAEgAUGAAWo2AqABIAFBsAJqIAYgAUGgAWoQuAcgAS0AsAIiBEEpRw0DDAwLIAFBsAJqIAUgAxDNDiABKAKwAiICQZOAgIB4Rw0KIAFB8AFqIAYgAUEoahC1HQwHCyABIAU6AH0gASAFOgB+IAEgAzoAfyABQfABakIKQgAQsi4gAUGwAmogASkD8AEgASkD+AEgASkDgAIgASkDiAIgByADayICwBDfASABKAKwAkEBRgRAIAEpA7gCIRsgASgCtAIhAiABKQPAAgwMCyABIAEpA9gCIhs3A5gBIAEgASkD0AIiHDcDkAEgASABKQPIAiIdNwOIASABIAEpA8ACIh43A4ABIAFBsAJqIgcQ7CwgASgCsAJBAXFFDY0DIAcgHiAdIBwgGyABKQPAAiABKQPIAiABKQPQAiABKQPYAhCaCCABAn4gAS0AsAJBAUYEQCABLQCxAgRAQoCAgICAgICAgH8hG0IAIR1CACEcQgAMAgsgAUEANgKAAiABQQE2AvQBIAFBjJSAATYC8AEgAUIENwL4ASABQfABakGUlIABEO8sAAsgASkD2AIhGyABKQPQAiEcIAEpA8gCIR0gASkDwAILIh43A6ABIAEgHTcDqAEgASAcNwOwASABIBs3A7gBIAFCACAdIB5CAFKtfH0iHTcDyAEgAUIAIB59Ih43A8ABIAEgHkIAUiAdQgBSIB1QG0F/c61CAYMiHSAcQn+FfCIcNwPQASABIBwgHVStIBtCf4V8NwPYASABIAFBwAFqNgLsASABIAFBoAFqNgLoASABIAFBgAFqNgLkASAKIAJrwCAFwE4EQCAELQA0DQQgASABQf0AajYCrAIgASABQf4AajYCqAIgASABQeQBajYCpAIgAUGwAmogBiABQaQCahD7AyABLQCwAiIEQSlGDQsgAUHGAGogAS0AswIiAjoAACABQThqIAFB2AJqKQIANwMAIAFBMGogAUHQAmopAgA3AwAgASACOgDzASABIAEvALECIgI7APEBIAEgASkCyAIiGzcCiAIgASACOwFEIAEgGzcDKCABKAK0AiECIAEpArgCIRsgASkCwAIhHAwGCyABQbACaiAFIAMQzQ4gASgCsAIiAkGTgICAeEcNCSABQfABaiAGIAFB5AFqELAdDAQLIAFBAjYCtAIgAUGImIABNgKwAiABQgI3ArwCIAFB+g82AqwBIAFB/Q82AqQBIAEgAUGgAWo2ArgCIAEgAUGkAmo2AqgBIAEgAUGAAWo2AqABIAFB9AFqIAFBsAJqEJkOIAEpAvQBIRtBiICAgHghAiABKQL8AQwKCyABQeYBaiABLQCzAiICOgAAIAFB0AFqIAFB2AJqKQIANwMAIAFByAFqIAFB0AJqKQIANwMAIAEgAjoA8wEgASABLwCxAiICOwDxASABIAEpAsgCIhs3AogCIAEgAjsB5AEgASAbNwPAASABKAK0AiECIAEpArgCIRsgASkCwAIhHAwFCyABQfABaiAGIAFBgAFqIAFB/gBqEO4EDAMLIAFB8AFqIAYgAUHkAWogAUH9AGoQowMLIAFBxgBqIAEtAPMBOgAAIAFBMGogAUGQAmopAgA3AwAgAUE4aiABQZgCaikCADcDACABIAEvAPEBOwFEIAEgASkCiAI3AyggASkC+AEhGyABKAL0ASECIAEpAoACIhwgAS0A8AEiBEEpRg0GGgsgAUGCAWogAUHGAGotAAA6AAAgAUGoAWogAUEwaikDADcDACABQbABaiABQThqKQMANwMAIAEgAS8BRDsBgAEgASABKQMoNwOgAQwCCyABQeYBaiABLQDzAToAACABQcgBaiABQZACaikCADcDACABQdABaiABQZgCaikCADcDACABIAEvAPEBOwHkASABIAEpAogCNwPAASABKQL4ASEbIAEoAvQBIQIgASkCgAIiHCABLQDwASIEQSlGDQQaCyABQYIBaiABQeYBai0AADoAACABQagBaiABQcgBaikDADcDACABQbABaiABQdABaikDADcDACABIAEvAeQBOwGAASABIAEpA8ABNwOgAQsgAUHQAmogAUGoAWopAwA3AgAgAUHYAmogAUGwAWopAwA3AgAgASAEOgCwAiABIAEvAYABOwCxAiABIBw3AsACIAEgGzcCuAIgASACNgK0AiABIAEpA6ABNwLIAiABIAFBggFqLQAAOgCzAiABQfABaiABQbACaiAFIAMQohMgAS0A8AEiA0EpRgRAIAFB2wBqIAFBhAJqKAIAIgI2AAAgAUHTAGogAUH8AWopAgAiGzcAACABIAEpAvQBIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUHXAGoiBCABQYACaikAADcAACABQdAAaiIFIAFB+QFqKQAANwMAIAFB6ABqIgYgAUGQAmopAgA3AwAgAUHwAGoiByABQZgCaikCADcDACABIAEpAPEBNwNIIAEgASkCiAI3A2AQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQNgNwIgIABBvJqAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBAsM+gILIAEpArQCIRsgASkCvAIMAQsgASkCuAIhGyABKAK0AiECIAEpAsACCzcCDCAAIBs3AgQgACACNgIACyABQYADaiQADPECCyAFIAYQ4yEhBiAJLAABIQogCS0AAiEHIAMtAAEhBSADLQACIQMjAEGgA2siASQAAkAgAAJ+AkACQAJAAkACQAJAAkACQAJAAkACQCAHwCADwEwEQCABIAU6AJ4BIAEgBToAZCABIAM6AGUgASADIAdrIgnAIgI2AsQCIAFCADcDqAFCCiEcIAFCCjcDoAFCASEeAkAgAyAHRg0AA0AgAkEBcQRAIAFBADYCPCABQSBqIB4gHSAcIBsgAUE8ahD2DCABKAI8DQQgASkDKCEdIAEpAyAhHiACQQFGDQILIAFBADYCHCABIBwgGyAcIBsgAUEcahD2DCABKAIcDQMgASkDCCEbIAEpAwAhHCACQQF2IQIMAAsACyABIB43A0AgASAdNwNIIAEgAUFAazYCoAEgCSAKasAgBcBKBEAgBC0ANA0EIAEgAUGeAWo2AsgBIAEgAUHkAGo2AsQBIAEgAUGgAWo2AsABIAFB0AJqIAYgAUHAAWoQsQcgAS0A0AIiBEEpRw0DDAwLIAFB0AJqIAUgAxDMDiABKALQAiICQZOAgIB4Rw0KIAFBkAJqIAYgAUFAaxCtHQwHCyABIAU6AJ0BIAEgBToAngEgASADOgCfASABQZACakIKQgAQsi4gAUHQAmogASkDkAIgASkDmAIgASkDoAIgASkDqAIgByADayICwBDfASABKALQAkEBRgRAIAEpA9gCIRsgASgC1AIhAiABKQPgAgwMCyABIAEpA/gCIhs3A7gBIAEgASkD8AIiHDcDsAEgASABKQPoAiIdNwOoASABIAEpA+ACIh43A6ABIAFB0AJqIgcQ7CwgASgC0AJBAXFFDYwDIAcgHiAdIBwgGyABKQPgAiABKQPoAiABKQPwAiABKQP4AhCaCCABAn4gAS0A0AJBAUYEQCABLQDRAgRAQoCAgICAgICAgH8hG0IAIR1CACEeQgAMAgsgAUEANgKgAiABQQE2ApQCIAFBjJSAATYCkAIgAUIENwKYAiABQZACakGUlIABEO8sAAsgASkD+AIhGyABKQPwAiEeIAEpA+gCIR0gASkD4AILIhw3A8ABIAEgHTcDyAEgASAeNwPQASABIBs3A9gBIAFCACAdIBxCAFKtfH0iHTcD6AEgAUIAIBx9Ihw3A+ABIAEgHEIAUiAdQgBSIB1QG0F/c61CAYMiHCAeQn+FfCIdNwPwASABIBwgHVatIBtCf4V8NwP4ASABIAFB4AFqNgKMAiABIAFBwAFqNgKIAiABIAFBoAFqNgKEAiAKIAJrwCAFwE4EQCAELQA0DQQgASABQZ0BajYCzAIgASABQZ4BajYCyAIgASABQYQCajYCxAIgAUHQAmogBiABQcQCahDaAyABLQDQAiIEQSlGDQsgAUHmAGogAS0A0wIiAjoAACABQdAAaiABQfgCaikCADcDACABQcgAaiABQfACaikCADcDACABIAI6AJMCIAEgAS8A0QIiAjsAkQIgASABKQLoAiIbNwKoAiABIAI7AWQgASAbNwNAIAEoAtQCIQIgASkC2AIhGyABKQLgAiEcDAYLIAFB0AJqIAUgAxDMDiABKALQAiICQZOAgIB4Rw0JIAFBkAJqIAYgAUGEAmoQsx0MBAsgAUECNgLUAiABQYiYgAE2AtACIAFCAjcC3AIgAUH6DzYCzAEgAUH7DzYCxAEgASABQcABajYC2AIgASABQcQCajYCyAEgASABQaABajYCwAEgAUGUAmogAUHQAmoQmQ4gASkClAIhG0GIgICAeCECIAEpApwCDAoLIAFBhgJqIAEtANMCIgI6AAAgAUHwAWogAUH4AmopAgA3AwAgAUHoAWogAUHwAmopAgA3AwAgASACOgCTAiABIAEvANECIgI7AJECIAEgASkC6AIiGzcCqAIgASACOwGEAiABIBs3A+ABIAEoAtQCIQIgASkC2AIhGyABKQLgAiEcDAULIAFBkAJqIAYgAUGgAWogAUGeAWoQ8QQMAwsgAUGQAmogBiABQYQCaiABQZ0BahCbAwsgAUHmAGogAS0AkwI6AAAgAUHIAGogAUGwAmopAgA3AwAgAUHQAGogAUG4AmopAgA3AwAgASABLwCRAjsBZCABIAEpAqgCNwNAIAEpApgCIRsgASgClAIhAiABKQKgAiIcIAEtAJACIgRBKUYNBhoLIAFBogFqIAFB5gBqLQAAOgAAIAFByAFqIAFByABqKQMANwMAIAFB0AFqIAFB0ABqKQMANwMAIAEgAS8BZDsBoAEgASABKQNANwPAAQwCCyABQYYCaiABLQCTAjoAACABQegBaiABQbACaikCADcDACABQfABaiABQbgCaikCADcDACABIAEvAJECOwGEAiABIAEpAqgCNwPgASABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQQaCyABQaIBaiABQYYCai0AADoAACABQcgBaiABQegBaikDADcDACABQdABaiABQfABaikDADcDACABIAEvAYQCOwGgASABIAEpA+ABNwPAAQsgAUHwAmogAUHIAWopAwA3AgAgAUH4AmogAUHQAWopAwA3AgAgASAEOgDQAiABIAEvAaABOwDRAiABIBw3AuACIAEgGzcC2AIgASACNgLUAiABIAEpA8ABNwLoAiABIAFBogFqLQAAOgDTAiABQZACaiABQdACaiAFIAMQoRMgAS0AkAIiA0EpRgRAIAFB+wBqIAFBpAJqKAIAIgI2AAAgAUHzAGogAUGcAmopAgAiGzcAACABIAEpApQCIhw3AGsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUH3AGoiBCABQaACaikAADcAACABQfAAaiIFIAFBmQJqKQAANwMAIAFBiAFqIgYgAUGwAmopAgA3AwAgAUGQAWoiByABQbgCaikCADcDACABIAEpAJECNwNoIAEgASkCqAI3A4ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNoNwAJIAIgASkDgAE3AiAgAEG0mIABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwz5AgsgASkC1AIhGyABKQLcAgwBCyABKQLYAiEbIAEoAtQCIQIgASkC4AILNwIMIAAgGzcCBCAAIAI2AgALIAFBoANqJAAM8AILIAUgBhDjISEGIAktAAEhByAJLQACIQIgAy0AASEFIAMtAAIhAyMAQZADayIBJAACQAJAAkACQAJAAkACQAJAAkACQCACIANGIAUgB09xRQRAAkACQCACwCADwEoEQCABIAU6AI0BIAEgBToAjgEgASADOgCPASABQeACakIKQgAQsi4gAUHwAWogASkD4AIgASkD6AIgASkD8AIgASkD+AIgAiADayICwBDfASABKALwAUEBRgRAIAEpA4ACIRwgASkD+AEhGyABKAL0ASECDAsLIAEgASkDmAIiGzcDqAEgASABKQOQAiIcNwOgASABIAEpA4gCIh03A5gBIAEgASkDgAIiHjcDkAEgAUHwAWoiCRDsLCABKALwAUEBcUUNjAMgCSAeIB0gHCAbIAEpA4ACIAEpA4gCIAEpA5ACIAEpA5gCEJoIIAECfiABLQDwAUEBRgRAIAEtAPEBBEBCgICAgICAgICAfyEbQgAhHEIAIR1CAAwCCyABQQA2AvACIAFBATYC5AIgAUGMlIABNgLgAiABQgQ3AugCIAFB4AJqQZSUgAEQ7ywACyABKQOYAiEbIAEpA5ACIR0gASkDiAIhHCABKQOAAgsiHjcDsAEgASAcNwO4ASABIB03A8ABIAEgGzcDyAEgAUIAIBwgHkIAUq18fSIcNwPIAiABQgAgHn0iHjcDwAIgASAeQgBSIBxCAFIgHFAbQX9zrUIBgyIcIB1Cf4V8Ih03A9ACIAEgHCAdVq0gG0J/hXw3A9gCIAEgAUHAAmo2AuABIAEgAUGwAWo2AtwBIAEgAUGQAWo2AtgBIAcgAmvAIAXATgRAIAQtADQNBSABIAFBjQFqNgLsASABIAFBjgFqNgLoASABIAFB2AFqNgLkASABQfABaiAGIAFB5AFqEL8HIAEtAPABIgRBKUcNAiABKQKAAiEcIAEpAvgBIRsgASgC9AEhAgwLCyABQfABaiAFIAMQzw4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEcIAEpAvQBIRsMCwsgAUHgAmogBiABQdgBahC0HQwJCyABIAU6AFQgASAFOgDYASABIAM6ANkBIAFB4AJqQgpCABCyLiABQfABaiABKQPgAiABKQPoAiABKQPwAiABKQP4AiADIAJrIgLAEN8BIAEoAvABQQFGBEAgASkDgAIhHCABKQP4ASEbIAEoAvQBIQIMBwsgASABKQOYAjcD2AIgASABKQOQAjcD0AIgASABKQOIAjcDyAIgASABKQOAAjcDwAIgASABQcACajYCOCACIAdqwCAFwEoEQCAELQA0DQUgASABQdQAajYCmAEgASABQdgBajYClAEgASABQThqNgKQASABQfABaiAGIAFBkAFqEMAHIAEtAPABIgRBKUcNAiABKQKAAiEcIAEpAvgBIRsgASgC9AEhAgwHCyABQfABaiAFIAMQzw4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEcIAEpAvQBIRsMBwsgAUHgAmogBiABQcACahCyHQwFCyABQdYAaiABLQDzASICOgAAIAFByABqIAFBmAJqKQIANwMAIAFBQGsgAUGQAmopAgA3AwAgASACOgDjAiABIAEvAPEBIgI7AOECIAEgASkCiAIiGzcC+AIgASACOwFUIAEgGzcDOCABKAL0ASECIAEpAvgBIRsgASkCgAIhHAwJCyABQeYBaiABLQDzASICOgAAIAFBwAFqIAFBmAJqKQIANwMAIAFBuAFqIAFBkAJqKQIANwMAIAEgAjoA4wIgASABLwDxASICOwDhAiABIAEpAogCIhs3AvgCIAEgAjsB5AEgASAbNwOwASABKAL0ASECIAEpAvgBIRsgASkCgAIhHAwFCyABQQhqIAYQgBUMCAsgAUHgAmogBiABQdgBaiABQY0BahCPAwwECyABQeACaiAGIAFBOGogAUHUAGoQ6gQLIAFB5gFqIAEtAOMCOgAAIAFBuAFqIAFBgANqKQIANwMAIAFBwAFqIAFBiANqKQIANwMAIAEgAS8A4QI7AeQBIAEgASkC+AI3A7ABIAEpAvACIRwgASkC6AIhGyABKALkAiECIAEtAOACIgRBKUcNAQsgACAcNwIMIAAgGzcCBCAAIAI2AgAMBQsgAUEoaiABQbgBaikDADcCACABQTBqIAFBwAFqKQMANwIAIAEgAS8B5AE7AAkgASABKQOwATcCICABIAFB5gFqLQAAOgALIAEgHDcCGCABIBs3AhAgASACNgIMIAEgBDoACAwDCyABQdYAaiABLQDjAjoAACABQUBrIAFBgANqKQIANwMAIAFByABqIAFBiANqKQIANwMAIAEgAS8A4QI7AVQgASABKQL4AjcDOCABKQLwAiEcIAEpAugCIRsgASgC5AIhAiABLQDgAiIEQSlHDQELIAAgHDcCDCAAIBs3AgQgACACNgIADAILIAFBKGogAUFAaykDADcCACABQTBqIAFByABqKQMANwIAIAEgAS8BVDsACSABIAEpAzg3AiAgASABQdYAai0AADoACyABIBw3AhggASAbNwIQIAEgAjYCDCABIAQ6AAgLIAFB8AFqIAFBCGogBSADEKMTIAEtAPABIgNBKUYEQCABQesAaiABQYQCaigCACICNgAAIAFB4wBqIAFB/AFqKQIAIhs3AAAgASABKQL0ASIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB5wBqIgQgAUGAAmopAAA3AAAgAUHgAGoiBSABQfkBaikAADcDACABQfgAaiIGIAFBkAJqKQIANwMAIAFBgAFqIgcgAUGYAmopAgA3AwAgASABKQDxATcDWCABIAEpAogCNwNwELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNYNwAJIAIgASkDcDcCICAAQYyZgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAELDPUCCyABQZADaiQADO8CCyANQQ1rQf8BcUEHSQ0BIAhB0ABqQgpCABCyLiAIKQNQIRsgCCkDWCEcIAgpA2AhHSAIKQNoIR4gCUECaiECIAgoAkwhByAIKAJIIQMjAEFAaiIBJAAgASADNgIQIAEgBzYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIBsgHCAdIB4gAi0AACAEEPUBDAwLIAAgBSAGIBsgHCAdIB4gAi0AACAEEO4BDAsLIAAgBSAGIBsgHCAdIB4gAi0AACAEEO8BDAoLIAAgBSAGIBsgHCAdIB4gAi0AACAEEIsCDAkLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPcBDAgLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPABDAcLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPMBDAYLIAAgBSAGIBsgHCAdIB4gAi0AACAEEIwCDAULIAAgBSAGIAFBP2ogAhDWIAwECyAAIAUgBiABQT9qIAIQ0SAMAwsgACAFIAYgBBCRCQwCCyAAIAUgBiAEEJIJDAELIAAgBSAGIAQQpwELIAFBQGskAAzuAgsgCS0AASADLQABRw3kAiAFIAYQxy8hAiAJLQABIQwjAEHgAWsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQSdGBEAgA0EEaiIJEKwnIQUgAUGUAWpBGEEAQQFBARCgGCABKAKYASEDIAEoApQBQQFGDQIgASgCnAEiBkEIakHQh4EBKQAANwAAIAZByIeBASkAADcAACAGQRBqQdiHgQEpAAA3AAAgAUEYNgIwIAEgBjYCLCABIAM2AiggAUGCgICAeDYCJCAFDQEgACABQSxqIgIpAgA3AgggAEEQaiACQQhqKAIANgIAIAAgAzYCBCAAQYKAgIB4NgIADAsLIAFBJGpBL0EAQQFBARCgGCABKAIoIQIgASgCJEEBRg0CIAEoAiwiA0GsiYEBQS/8CgAAIABBLzYCDCAAIAM2AgggACACNgIEIABBgoCAgHg2AgAMCgsgAUEkahCIESABIAU2AhQgCRDrJSEGIAFBlAFqQRpBAEEBQQEQoBggASgCmAEhByABKAKUAUEBRg0CIAEoApwBIgNBCGpB6IeBASkAADcAACADQeCHgQEpAAA3AAAgA0EYakH4h4EBLwAAOwAAIANBEGpB8IeBASkAADcAACABQRo2AjAgASADNgIsIAEgBzYCKCABQYKAgIB4NgIkIAZFBEAgACABQSxqIgIpAgA3AgggAEEQaiACQQhqKAIANgIAIAAgBzYCBCAAQYKAgIB4NgIADAkLIAFBJGoiAxCIESABIAY2AhggAyACEPMvQfyHgQEgBUEwaiAEEIYBIAEoAiwhByABKAIoIQMgASgCJCIKQZOAgIB4RwRAIAAgASkCMDcCDCAAIAc2AgggACADNgIEIAAgCjYCAAwICyABIAc2AiAgASADNgIcIAFBJGogAhDyLUH8h4EBIAZBMGogBBCGASABKAIsIQogASgCKCELIAEoAiQiBEGTgICAeEcEQCAAIAEpAjA3AgwgACAKNgIIIAAgCzYCBCAAIAQ2AgAgAyADKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgCSgCACIJIAkoAgAiBEEBajYCACAEQQBIDQMgAigCQCIEIAQoAgAiDUEBajYCACANQQBIDQMgASAENgKIASABIAIpAkQ3AowBELA+QQhBBBCtNiIERQ0EIAQgBjYCBCAEIAU2AgAgAUECNgIsIAEgBDYCKCABQQI2AiQgAUEIaiABQSRqIgUQthkgASgCDCEGIAEoAgghDRCwPkEQQQQQrTYiBEUNBSAEIAo2AgwgBCALNgIIIAQgBzYCBCAEIAM2AgAgAUECNgLQASABIAQ2AswBIAFBAjYCyAEgBSACEJw2EO4lIAFBlAFqIgQgDSAGIAFByAFqIgMgBRDLHCADIAIQmjYQ7iUgBSAJIAFBiAFqIAQgAyAMELEcELA+QewAQQQQrTYiAkUNBiACQoGAgIAQNwIAIAJBCGogBUHkAPwKAAAgAEHUiIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIADAkLIAMgASgCnAFBuIeBARD9LwALIAIgASgCLEG4h4EBEP0vAAsgByABKAKcAUG4h4EBEP0vCwALQQRBCBCjPQALQQRBEBCjPQALQQRB7AAQoz0ACyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPIlCyABKAIUIgAgACgCACIAQQFrNgIAIABBAUcNACABQRRqEPIlCyABQeABaiQADO0CCwJAIA1BIGsOBwsICAACBAYICyAMQQ1rQQdJDQgLIANBAWohAiADQQJqIQcjAEHwAWsiASQAIAEgAzYCDCABIAk2AggCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCS0AAA4bAQACAwQFBgcICQAKCwAAAAAAAAAAAAAADA0MAAsgAUEDNgJkIAFB2N//ADYCYCABQgI3AmwgAUGvAzYCJCABQa8DNgIcIAEgAUEYajYCaCABIAFBDGo2AiAgASABQQhqNgIYIAFB2AFqIAFB4ABqEJkOIABBgoCAgHg2AgAgACABKQLYATcCBCAAQQxqIAFB4AFqKAIANgIADC0LIAEgAyAFIAYoAiQRBAAQoSsgACABKQMANwIEIABBk4CAgHg2AgAMLAsgBSAGEPIhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0LQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMLAsgASAFNgIUIAdBAE4NKSAELQA0DQwgAUHgAGogBiABQRRqIAFBEmoQqQYgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwsCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDCoLIAUgBhD4ISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUNDEEBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCsLIAEgBTYCFCAHQQBODSYgBC0ANA0NIAFB4ABqIAYgAUEUaiABQRJqEKIGIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKwsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwnCyAFIAYQ+yEhBiACLQAAIQIgASAHLQAAIgU6ABMgASACOgASIAEgBcAiByAHQR91IgJzIAJrIgI2ArABQQohAyABQQo2AqwBIAVFDQ1BASEFAkADQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNASACQQFGDQMLIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNACACQQF2IQIMAQsLIAFBAjYCZCABQfDI/wA2AmAgAUICNwJsIAFBwg02AtABIAFBww02AsgBIAEgAUHEAWoiAjYCaCABIAFBsAFqNgLMASABIAFBrAFqNgLEASABQdwBaiABQeAAaiIDEJkOIAEoAtwBIQQgAUHUAWogAUHoAWooAgA2AgAgASABKQLgATcCzAEgASAENgLIASABQYiAgIB4NgLEASABQQQ2AtwBIAFB7Mz/ADYC2AEgAUIDNwLkASABQfQLNgJ0IAFBuwc2AmwgAUHEDTYCZCABQbTM/wA2AmAgASADNgLgASABIAFBE2o2AnAgASABQRJqNgJoIAFBtAFqIAFB2AFqEJkOIAIQiBEgACABKQK4ATcCCCAAQRBqIAFBwAFqKAIANgIAIAAgASgCtAE2AgQgAEGCgICAeDYCAAwqCyABIAU2AhQgB0EATg0jIAQtADQNDiABQeAAaiAGIAFBFGogAUESahD1AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCoLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMJAsgBSAGEPMhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0OQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMKQsgASAFNgIUIAdBAE4NICAELQA0DQ8gAUHgAGogBiABQRRqIAFBEmoQ8gMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwpCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDCELIAUgBhD3ISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUND0EBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCgLIAEgBTYCFCAHQQBODR0gBC0ANA0QIAFB4ABqIAYgAUEUaiABQRJqEKgGIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKAsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAweCyAFIAYQ8CEhBiACLQAAIQIgASAHLQAAIgU6ABMgASACOgASIAEgBcAiByAHQR91IgJzIAJrIgI2ArABQQohAyABQQo2AqwBIAVFDRBBASEFAkADQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNASACQQFGDQMLIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNACACQQF2IQIMAQsLIAFBAjYCZCABQfDI/wA2AmAgAUICNwJsIAFBwg02AtABIAFBww02AsgBIAEgAUHEAWoiAjYCaCABIAFBsAFqNgLMASABIAFBrAFqNgLEASABQdwBaiABQeAAaiIDEJkOIAEoAtwBIQQgAUHUAWogAUHoAWooAgA2AgAgASABKQLgATcCzAEgASAENgLIASABQYiAgIB4NgLEASABQQQ2AtwBIAFB7Mz/ADYC2AEgAUIDNwLkASABQfQLNgJ0IAFBuwc2AmwgAUHEDTYCZCABQbTM/wA2AmAgASADNgLgASABIAFBE2o2AnAgASABQRJqNgJoIAFBtAFqIAFB2AFqEJkOIAIQiBEgACABKQK4ATcCCCAAQRBqIAFBwAFqKAIANgIAIAAgASgCtAE2AgQgAEGCgICAeDYCAAwnCyABIAU2AhQgB0EATg0aIAQtADQNESABQeAAaiAGIAFBFGogAUESahChBiABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCcLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMGwsgBSAGEPUhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0RQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMJgsgASAFNgIUIAdBAE4NFyAELQA0DRIgAUHgAGogBiABQRRqIAFBEmoQ9QMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwmCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDBgLIAUgBhDsISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUNEkEBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCULIAEgBTYCFCAHQQBODRQgBC0ANA0TIAFB4ABqIAYgAUEUaiABQRJqEPIDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwVCyAAIAUgBhDvISACLQAAIActAAAgBBCvCQwjCyAAIAUgBhCCIiACLQAAIActAAAgBBCwCQwiCyAAIAUgBiACLQAAIActAAAgBBDNAQwhCyAAIAUgBiACLQAAIActAAAgBBDOAQwgCyABQQE2AhQMHQsgAUEYaiAGIAFBFGogAUESahCvAwwdCyABQQE2AhQMGQsgAUEYaiAGIAFBFGogAUESahCrAwwZCyABQQE2AhQMFQsgAUEYaiAGIAFBFGogAUESahDPBAwVCyABQQE2AhQMEQsgAUEYaiAGIAFBFGogAUESahDlBAwRCyABQQE2AhQMDQsgAUEYaiAGIAFBFGogAUESahCuAwwNCyABQQE2AhQMCQsgAUEYaiAGIAFBFGogAUESahCqAwwJCyABQQE2AhQMBQsgAUEYaiAGIAFBFGogAUESahDPBAwFCyABQQE2AhQMAQsgAUEYaiAGIAFBFGogAUESahDlBAwBCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEPkDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMEQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqEMkECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDwsMgAMLIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ/AMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwPCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQ7AQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwNCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNINwAJIAIgASkDkAE3AiAgAEHQy/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwNCwz+AgsgBC0ANEUEQCABQeAAaiAGIAFBFGogAUESahD4AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA0LIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMAQsgAUEYaiAGIAFBFGogAUESahDFBAsgAUHgAGogAUEYaiABLQASIAcQoBMgAS0AYCIDQSlGBEAgAUHbAGogAUH0AGooAgAiAjYAACABQdMAaiABQewAaikCACIbNwAAIAEgASkCZCIcNwBLIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAsLIAFB1wBqIgQgAUHwAGopAAA3AAAgAUHQAGoiBSABQekAaikAADcDACABQZgBaiIGIAFBgAFqKQIANwMAIAFBoAFqIgcgAUGIAWopAgA3AwAgASABKQBhNwNIIAEgASkCeDcDkAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAsLDPwCCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEP4DIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqENQECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCQsM+gILIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ+QMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQyQQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwHCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNINwAJIAIgASkDkAE3AiAgAEHQy/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwHCwz4AgsgBC0ANEUEQCABQeAAaiAGIAFBFGogAUESahD8AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAcLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMAQsgAUEYaiAGIAFBFGogAUESahDsBAsgAUHgAGogAUEYaiABLQASIAcQoBMgAS0AYCIDQSlGBEAgAUHbAGogAUH0AGooAgAiAjYAACABQdMAaiABQewAaikCACIbNwAAIAEgASkCZCIcNwBLIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAULIAFB1wBqIgQgAUHwAGopAAA3AAAgAUHQAGoiBSABQekAaikAADcDACABQZgBaiIGIAFBgAFqKQIANwMAIAFBoAFqIgcgAUGIAWopAgA3AwAgASABKQBhNwNIIAEgASkCeDcDkAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPYCCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEPoDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqENgECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM9AILIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ/wMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwDCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQyAQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICRQ3yAiACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQfABaiQADAALDOsCCyAMQQ1rQQdJDQYLIANBAWohAiADQQJqIQcjAEGABGsiASQAIAEgAzYCmAIgASAJNgKUAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJLQAADhsBAAIDBAUGBwgJAAoLAAAAAAAAAAAAAAAMDQwACyABQQM2AvQCIAFB2N//ADYC8AIgAUICNwL8AiABQa8DNgK0AiABQa8DNgKsAiABIAFBqAJqNgL4AiABIAFBmAJqNgKwAiABIAFBlAJqNgKoAiABQegDaiABQfACahCZDiAAQYKAgIB4NgIAIAAgASkC6AM3AgQgAEEMaiABQfADaigCADYCAAwtCyABQQhqIAMgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCwLIAUgBhDyISEDIAItAAAhAiABIActAAAiBjoAnwIgASACOgCeAiABIAbAIgUgBUEfdSICcyACayICNgK8A0IKIRsgAUIKNwPAAyAGRQ0LQgEhHAJAA0ACQCACQQFxBEAgAUEgaiAcIBxCP4cgGyAbQj+HEKgeIAEpAyggASkDICIcQj+HUg0BIAJBAUYNAwsgAUEQaiAbIBtCP4ciHSAbIB0QqB4gASkDGCABKQMQIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwsCyABIBw3A6ACIAVBAE4NKSAELQA0DQwgAUHwAmogAyABQaACaiABQZ4CahDlBiABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMLAsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwqCyAFIAYQ+CEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUNDEIBIRwCQANAAkAgAkEBcQRAIAFBQGsgHCAcQj+HIBsgG0I/hxCoHiABKQNIIAEpA0AiHEI/h1INASACQQFGDQMLIAFBMGogGyAbQj+HIh0gGyAdEKgeIAEpAzggASkDMCIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKwsgASAcNwOgAiAFQQBODSYgBC0ANA0NIAFB8AJqIAMgAUGgAmogAUGeAmoQ3wYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCsLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMJwsgBSAGEPshIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDQ1CASEcAkADQAJAIAJBAXEEQCABQeAAaiAcIBxCP4cgGyAbQj+HEKgeIAEpA2ggASkDYCIcQj+HUg0BIAJBAUYNAwsgAUHQAGogGyAbQj+HIh0gGyAdEKgeIAEpA1ggASkDUCIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKgsgASAcNwOgAiAFQQBODSMgBC0ANA0OIAFB8AJqIAMgAUGgAmogAUGeAmoQ4AYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCoLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMJAsgBSAGEPMhIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDQ5CASEcAkADQAJAIAJBAXEEQCABQYABaiAcIBxCP4cgGyAbQj+HEKgeIAEpA4gBIAEpA4ABIhxCP4dSDQEgAkEBRg0DCyABQfAAaiAbIBtCP4ciHSAbIB0QqB4gASkDeCABKQNwIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwpCyABIBw3A6ACIAVBAE4NICAELQA0DQ8gAUHwAmogAyABQaACaiABQZ4CahCyBCABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKQsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwhCyAFIAYQ9yEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUND0IBIRwCQANAAkAgAkEBcQRAIAFBoAFqIBwgHEI/hyAbIBtCP4cQqB4gASkDqAEgASkDoAEiHEI/h1INASACQQFGDQMLIAFBkAFqIBsgG0I/hyIdIBsgHRCoHiABKQOYASABKQOQASIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKAsgASAcNwOgAiAFQQBODR0gBC0ANA0QIAFB8AJqIAMgAUGgAmogAUGeAmoQ5gYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCgLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMHgsgBSAGEPAhIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDRBCASEcAkADQAJAIAJBAXEEQCABQcABaiAcIBxCP4cgGyAbQj+HEKgeIAEpA8gBIAEpA8ABIhxCP4dSDQEgAkEBRg0DCyABQbABaiAbIBtCP4ciHSAbIB0QqB4gASkDuAEgASkDsAEiG0I/h1INACACQQF2IQIMAQsLIAFBAjYC9AIgAUHwyP8ANgLwAiABQgI3AvwCIAFBwg02AuADIAFBxQ02AtgDIAEgAUHUA2oiAjYC+AIgASABQbwDajYC3AMgASABQcADajYC1AMgAUHsA2ogAUHwAmoiAxCZDiABKQLsAyEbIAEgASkC9AM3AuADIAEgGzcC2AMgAUGIgICAeDYC1AMgAUEENgLsAyABQezM/wA2AugDIAFCAzcC9AMgAUH0CzYChAMgAUG7BzYC/AIgAUHEDTYC9AIgAUGszf8ANgLwAiABIAM2AvADIAEgAUGfAmo2AoADIAEgAUGeAmo2AvgCIAFBxANqIAFB6ANqEJkOIAIQiBEgASkCxAMhGyAAIAEpAswDNwIMIAAgGzcCBCAAQYKAgIB4NgIADCcLIAEgHDcDoAIgBUEATg0aIAQtADQNESABQfACaiADIAFBoAJqIAFBngJqEN4GIAEtAPACIgJBKUYEQCABQfsDaiABQYQDaigCACICNgAAIAFB8wNqIAFB/AJqKQIAIhs3AAAgASABKQL0AiIcNwDrAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwnCyABQfcDaiIDIAFBgANqKQAANwAAIAFB8ANqIgQgAUH5AmopAAA3AwAgAUHIAmogAUGQA2opAgA3AgAgAUHQAmogAUGYA2opAgA3AgAgAUGxAmogBCkDADcAACABQbgCaiADKQAANwAAIAEgASkA8QIiGzcD6AMgASABKQKIAzcCwAIgASAbNwCpAiABIAI6AKgCDBsLIAUgBhD1ISEDIAItAAAhAiABIActAAAiBjoAnwIgASACOgCeAiABIAbAIgUgBUEfdSICcyACayICNgK8A0IKIRsgAUIKNwPAAyAGRQ0RQgEhHAJAA0ACQCACQQFxBEAgAUHgAWogHCAcQj+HIBsgG0I/hxCoHiABKQPoASABKQPgASIcQj+HUg0BIAJBAUYNAwsgAUHQAWogGyAbQj+HIh0gGyAdEKgeIAEpA9gBIAEpA9ABIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwmCyABIBw3A6ACIAVBAE4NFyAELQA0DRIgAUHwAmogAyABQaACaiABQZ4CahDdBiABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJgsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwYCyAFIAYQ7CEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUNEkIBIRwCQANAAkAgAkEBcQRAIAFBgAJqIBwgHEI/hyAbIBtCP4cQqB4gASkDiAIgASkDgAIiHEI/h1INASACQQFGDQMLIAFB8AFqIBsgG0I/hyIdIBsgHRCoHiABKQP4ASABKQPwASIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMJQsgASAcNwOgAiAFQQBODRQgBC0ANA0TIAFB8AJqIAMgAUGgAmogAUGeAmoQsgQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCULIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMFQsgACAFIAYQ7yEgAi0AACAHLQAAIAQQtgkMIwsgACAFIAYQgiIgAi0AACAHLQAAIAQQtQkMIgsgACAFIAYgAi0AACAHLQAAIAQQyAEMIQsgACAFIAYgAi0AACAHLQAAIAQQyQEMIAsgAUIBNwOgAgwdCyABQagCaiADIAFBoAJqIAFBngJqEKYDDB0LIAFCATcDoAIMGQsgAUGoAmogAyABQaACaiABQZ4CahCeAwwZCyABQgE3A6ACDBULIAFBqAJqIAMgAUGgAmogAUGeAmoQnQMMFQsgAUIBNwOgAgwRCyABQagCaiADIAFBoAJqIAFBngJqEOkEDBELIAFCATcDoAIMDQsgAUGoAmogAyABQaACaiABQZ4CahClAwwNCyABQgE3A6ACDAkLIAFBqAJqIAMgAUGgAmogAUGeAmoQoAMMCQsgAUIBNwOgAgwFCyABQagCaiADIAFBoAJqIAFBngJqEKEDDAULIAFCATcDoAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDpBAwBCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADBELIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDyBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADA8LDP4CCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQoQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA8LIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDDBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADA0LDPwCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQogQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA0LIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDhBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAsLDPoCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQpwQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAsLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDeBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAkLDPgCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAkLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDyBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAcLDPYCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQmwQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAcLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahD6BAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPQCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnAQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAULIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDoBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAMLDPICCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQowQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAMLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahD1BAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAkUN8AIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYAjcACSACIAEpA6ADNwIgIABByMn/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFBgARqJAAMAAsM6QILIAxBDWtBB0kNBAsgA0EBaiECIANBAmohByMAQZAGayIBJAAgASADNgKIBCABIAk2AoQEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAktAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDAALIAFBAzYC9AQgAUHY3/8ANgLwBCABQgI3AvwEIAFBrwM2ArQEIAFBrwM2AqwEIAEgAUGoBGo2AvgEIAEgAUGIBGo2ArAEIAEgAUGEBGo2AqgEIABBBGogAUHwBGoQmQ4gAEGCgICAeDYCAAwtCyABQQhqIAMgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCwLIAUgBhDyISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDQtCASEdAkADQAJAIAJBAXEEQCABQQA2AkwgAUEwaiAdIB4gGyAcIAFBzABqEPYMIAEoAkwNASABKQM4IR4gASkDMCEdIAJBAUYNAwsgAUEANgIsIAFBEGogGyAcIBsgHCABQSxqEPYMIAEoAiwNACABKQMYIRwgASkDECEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCwLIAEgHTcDkAQgASAeNwOYBCAFQQBODSkgBC0ANA0MIAFB8ARqIAMgAUGQBGogAUGOBGoQlwYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCwLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMKgsgBSAGEPghIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUNDEIBIR0CQANAAkAgAkEBcQRAIAFBADYCjAEgAUHwAGogHSAeIBsgHCABQYwBahD2DCABKAKMAQ0BIAEpA3ghHiABKQNwIR0gAkEBRg0DCyABQQA2AmwgAUHQAGogGyAcIBsgHCABQewAahD2DCABKAJsDQAgASkDWCEcIAEpA1AhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwrCyABIB03A5AEIAEgHjcDmAQgBUEATg0mIAQtADQNDSABQfAEaiADIAFBkARqIAFBjgRqEJAGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwrCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDCcLIAUgBhD7ISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDQ1CASEdAkADQAJAIAJBAXEEQCABQQA2AswBIAFBsAFqIB0gHiAbIBwgAUHMAWoQ9gwgASgCzAENASABKQO4ASEeIAEpA7ABIR0gAkEBRg0DCyABQQA2AqwBIAFBkAFqIBsgHCAbIBwgAUGsAWoQ9gwgASgCrAENACABKQOYASEcIAEpA5ABIRsgAkEBdiECDAELCyABQQI2AvQEIAFB8Mj/ADYC8AQgAUICNwL8BCABQcINNgLsBSABQcYNNgLkBSABIAFB4AVqIgI2AvgEIAEgAUG8BWo2AugFIAEgAUHABWo2AuAFIAFB/AVqIAFB8ARqIgMQmQ4gAUGIgICAeDYC+AUgAUHoBWogAUGABmooAgA2AgAgASABKQL4BTcD4AUgASABKQKEBjcC7AUgAUEENgL8BSABQezM/wA2AvgFIAFCAzcChAYgAUH0CzYChAUgAUG7BzYC/AQgAUHEDTYC9AQgAUHAzf8ANgLwBCABIAM2AoAGIAEgAUGPBGo2AoAFIAEgAUGOBGo2AvgEIAFBxAVqIAFB+AVqEJkOIAFBgoCAgHg2AsAFIAIQiBEgAEEIaiABQcgFaigCADYCACAAIAEpAsAFNwIAIAAgASkCzAU3AgwMKgsgASAdNwOQBCABIB43A5gEIAVBAE4NIyAELQA0DQ4gAUHwBGogAyABQZAEaiABQY4EahCRBiABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKgsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwkCyAFIAYQ8yEhAyACLQAAIQIgASAHLQAAIgY6AI8EIAEgAjoAjgQgASAGwCIFIAVBH3UiAnMgAmsiAjYCvAUgAUIANwPIBUIKIRsgAUIKNwPABSAGRQ0OQgEhHQJAA0ACQCACQQFxBEAgAUEANgKMAiABQfABaiAdIB4gGyAcIAFBjAJqEPYMIAEoAowCDQEgASkD+AEhHiABKQPwASEdIAJBAUYNAwsgAUEANgLsASABQdABaiAbIBwgGyAcIAFB7AFqEPYMIAEoAuwBDQAgASkD2AEhHCABKQPQASEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCkLIAEgHTcDkAQgASAeNwOYBCAFQQBODSAgBC0ANA0PIAFB8ARqIAMgAUGQBGogAUGOBGoQkgYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCkLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMIQsgBSAGEPchIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUND0IBIR0CQANAAkAgAkEBcQRAIAFBADYCzAIgAUGwAmogHSAeIBsgHCABQcwCahD2DCABKALMAg0BIAEpA7gCIR4gASkDsAIhHSACQQFGDQMLIAFBADYCrAIgAUGQAmogGyAcIBsgHCABQawCahD2DCABKAKsAg0AIAEpA5gCIRwgASkDkAIhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwoCyABIB03A5AEIAEgHjcDmAQgBUEATg0dIAQtADQNECABQfAEaiADIAFBkARqIAFBjgRqEKAGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwoCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDB4LIAUgBhDwISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDRBCASEdAkADQAJAIAJBAXEEQCABQQA2AowDIAFB8AJqIB0gHiAbIBwgAUGMA2oQ9gwgASgCjAMNASABKQP4AiEeIAEpA/ACIR0gAkEBRg0DCyABQQA2AuwCIAFB0AJqIBsgHCAbIBwgAUHsAmoQ9gwgASgC7AINACABKQPYAiEcIAEpA9ACIRsgAkEBdiECDAELCyABQQI2AvQEIAFB8Mj/ADYC8AQgAUICNwL8BCABQcINNgLsBSABQcYNNgLkBSABIAFB4AVqIgI2AvgEIAEgAUG8BWo2AugFIAEgAUHABWo2AuAFIAFB/AVqIAFB8ARqIgMQmQ4gAUGIgICAeDYC+AUgAUHoBWogAUGABmooAgA2AgAgASABKQL4BTcD4AUgASABKQKEBjcC7AUgAUEENgL8BSABQezM/wA2AvgFIAFCAzcChAYgAUH0CzYChAUgAUG7BzYC/AQgAUHEDTYC9AQgAUHAzf8ANgLwBCABIAM2AoAGIAEgAUGPBGo2AoAFIAEgAUGOBGo2AvgEIAFBxAVqIAFB+AVqEJkOIAFBgoCAgHg2AsAFIAIQiBEgAEEIaiABQcgFaigCADYCACAAIAEpAsAFNwIAIAAgASkCzAU3AgwMJwsgASAdNwOQBCABIB43A5gEIAVBAE4NGiAELQA0DREgAUHwBGogAyABQZAEaiABQY4EahCaBiABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwbCyAFIAYQ9SEhAyACLQAAIQIgASAHLQAAIgY6AI8EIAEgAjoAjgQgASAGwCIFIAVBH3UiAnMgAmsiAjYCvAUgAUIANwPIBUIKIRsgAUIKNwPABSAGRQ0RQgEhHQJAA0ACQCACQQFxBEAgAUEANgLMAyABQbADaiAdIB4gGyAcIAFBzANqEPYMIAEoAswDDQEgASkDuAMhHiABKQOwAyEdIAJBAUYNAwsgAUEANgKsAyABQZADaiAbIBwgGyAcIAFBrANqEPYMIAEoAqwDDQAgASkDmAMhHCABKQOQAyEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCYLIAEgHTcDkAQgASAeNwOYBCAFQQBODRcgBC0ANA0SIAFB8ARqIAMgAUGQBGogAUGOBGoQmQYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCYLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMGAsgBSAGEOwhIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUNEkIBIR0CQANAAkAgAkEBcQRAIAFBADYCgAQgAUHwA2ogHSAeIBsgHCABQYAEahD2DCABKAKABA0BIAEpA/gDIR4gASkD8AMhHSACQQFGDQMLIAFBADYC7AMgAUHQA2ogGyAcIBsgHCABQewDahD2DCABKALsAw0AIAEpA9gDIRwgASkD0AMhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwlCyABIB03A5AEIAEgHjcDmAQgBUEATg0UIAQtADQNEyABQfAEaiADIAFBkARqIAFBjgRqEJgGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwlCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDBULIAAgBSAGEO8hIAItAAAgBy0AACAEELEJDCMLIAAgBSAGEIIiIAItAAAgBy0AACAEELIJDCILIAAgBSAGIAItAAAgBy0AACAEENABDCELIAAgBSAGIAItAAAgBy0AACAEEM8BDCALIAFCADcDmAQgAUIBNwOQBAwdCyABQagEaiADIAFBkARqIAFBjgRqEIsDDB0LIAFCADcDmAQgAUIBNwOQBAwZCyABQagEaiADIAFBkARqIAFBjgRqEIgDDBkLIAFCADcDmAQgAUIBNwOQBAwVCyABQagEaiADIAFBkARqIAFBjgRqEIkDDBULIAFCADcDmAQgAUIBNwOQBAwRCyABQagEaiADIAFBkARqIAFBjgRqEIoDDBELIAFCADcDmAQgAUIBNwOQBAwNCyABQagEaiADIAFBkARqIAFBjgRqEI4DDA0LIAFCADcDmAQgAUIBNwOQBAwJCyABQagEaiADIAFBkARqIAFBjgRqEIwDDAkLIAFCADcDmAQgAUIBNwOQBAwFCyABQagEaiADIAFBkARqIAFBjgRqEI0DDAULIAFCADcDmAQgAUIBNwOQBAwBCyABQagEaiADIAFBkARqIAFBjgRqEJADDAELIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCLBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMEQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEPkECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwPCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDwsM/AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCKBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEN8ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwNCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDQsM+gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCMBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEIAFCyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwLCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCwsM+AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCOBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqENIECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCQsM9gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCIBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEO0ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwHCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBwsM9AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCHBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEMsECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwFCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBQsM8gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCGBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEMYECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwDCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM8AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCJBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEP8ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICRQ3uAiACIAM6AAggAkKBgICAEDcCACACIAEpA9gENwAJIAIgASkDoAU3AiAgAEGgyv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUGQBmokAAwACwznAgsgDEENa0EHSQ0CCyAIQdAAakIKQgAQsi4gCCkDUCEbIAgpA1ghHCAIKQNgIR0gCCkDaCEeIANBAWohAiADQQJqIQMgCCgCTCEHIAgoAkghCSMAQcACayIBJAAgASAJNgIYIAEgBzYCFAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIActAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDAALIAFBAzYClAEgAUHY3/8ANgKQASABQgI3ApwBIAFBrwM2AlQgAUGvAzYCTCABIAFByABqNgKYASABIAFBGGo2AlAgASABQRRqNgJIIABBBGogAUGQAWoQmQ4gAEGCgICAeDYCAAwlCyABQQhqIAkgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCQLIAUgBhDyISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAwkCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0MIAFBkAFqIAUgAUEgaiABQR5qELMEIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwlCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDCMLIANBAXENDCABQZABaiAFIAFBIGogAUEeahCXByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJAsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwiCyAFIAYQ+CEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMIwsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENDSABQZABaiAFIAFBIGogAUEeahCtBCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJAsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwhCyADQQFxDQ0gAUGQAWogBSABQSBqIAFBHmoQnQcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCMLIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMIAsgBSAGEPshIQUgAi0AACEGIAEgAywAACICOgAfIAEgBjoAHiABQZABaiAbIBwgHSAeIAIgAkEfdSIDcyADaxDeASABKAKQAUEBRgRAIAFBgAJqIAEpApwBNwMAIAFBiAJqIAFBpAFqKAIANgIAIAEgASkClAE3A/gBIAFB7Mz/ADYCkAIgAUIDNwKcAiABQfQLNgK8AiABQbsHNgK0AiABQcQNNgKsAiABQZjN/wA2AqgCIAEgAUGoAmo2ApgCIAEgAUEfajYCuAIgASABQR5qNgKwAiABQQQ2ApQCIAFB6AFqIAFBkAJqEJkOIAFBgoCAgHg2AuQBIAFB+AFqEIgRIABBCGogAUHsAWooAgA2AgAgACABKQLkATcCACAAIAEpAvABNwIMDCILIAEgASkDuAE3AzggASABKQOwATcDMCABIAEpA6gBNwMoIAEgASkDoAE3AyAgBC0ANCEDIAJBAE4EQCADQQFxDQ4gAUGQAWogBSABQSBqIAFBHmoQsAQgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCMLIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMHwsgA0EBcQ0OIAFBkAFqIAUgAUEgaiABQR5qEJoHIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwiCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDB4LIAUgBhDzISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAwhCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0PIAFBkAFqIAUgAUEgaiABQR5qEKwEIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwiCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDB0LIANBAXENDyABQZABaiAFIAFBIGogAUEeahCZByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMIQsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwcCyAFIAYQ9yEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMIAsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENECABQZABaiAFIAFBIGogAUEeahC0BCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMIQsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwbCyADQQFxDRAgAUGQAWogBSABQSBqIAFBHmoQlAcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCALIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMGgsgBSAGEPAhIQUgAi0AACEGIAEgAywAACICOgAfIAEgBjoAHiABQZABaiAbIBwgHSAeIAIgAkEfdSIDcyADaxDeASABKAKQAUEBRgRAIAFBgAJqIAEpApwBNwMAIAFBiAJqIAFBpAFqKAIANgIAIAEgASkClAE3A/gBIAFB7Mz/ADYCkAIgAUIDNwKcAiABQfQLNgK8AiABQbsHNgK0AiABQcQNNgKsAiABQZjN/wA2AqgCIAEgAUGoAmo2ApgCIAEgAUEfajYCuAIgASABQR5qNgKwAiABQQQ2ApQCIAFB6AFqIAFBkAJqEJkOIAFBgoCAgHg2AuQBIAFB+AFqEIgRIABBCGogAUHsAWooAgA2AgAgACABKQLkATcCACAAIAEpAvABNwIMDB8LIAEgASkDuAE3AzggASABKQOwATcDMCABIAEpA6gBNwMoIAEgASkDoAE3AyAgBC0ANCEDIAJBAE4EQCADQQFxDREgAUGQAWogBSABQSBqIAFBHmoQqwQgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCALIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMGQsgA0EBcQ0RIAFBkAFqIAUgAUEgaiABQR5qEJwHIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwfCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDBgLIAUgBhD1ISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAweCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0SIAFBkAFqIAUgAUEgaiABQR5qEK4EIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwfCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDBcLIANBAXENEiABQZABaiAFIAFBIGogAUEeahCVByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMHgsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwWCyAFIAYQ7CEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMHQsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENEyABQZABaiAFIAFBIGogAUEeahCvBCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMHgsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwVCyADQQFxDRMgAUGQAWogBSABQSBqIAFBHmoQngcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADB0LIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMFAsgACAFIAYQ7yEgAi0AACADLQAAIAQQtAkMGwsgACAFIAYQgiIgAi0AACADLQAAIAQQswkMGgsgACAFIAYgAi0AACADLQAAIAQQxAEMGQsgACAFIAYgAi0AACADLQAAIAQQxQEMGAsgAUHIAGogBSABQSBqIAFBHmoQ3AQMFgsgAUHIAGogBSABQSBqIAFBHmoQ8AQMFQsgAUHIAGogBSABQSBqIAFBHmoQ2QQMEwsgAUHIAGogBSABQSBqIAFBHmoQgwUMEgsgAUHIAGogBSABQSBqIAFBHmoQ2gQMEAsgAUHIAGogBSABQSBqIAFBHmoQ0QQMDwsgAUHIAGogBSABQSBqIAFBHmoQgQUMDQsgAUHIAGogBSABQSBqIAFBHmoQ8wQMDAsgAUHIAGogBSABQSBqIAFBHmoQhQUMCgsgAUHIAGogBSABQSBqIAFBHmoQ4gQMCQsgAUHIAGogBSABQSBqIAFBHmoQzQQMBwsgAUHIAGogBSABQSBqIAFBHmoQ/AQMBgsgAUHIAGogBSABQSBqIAFBHmoQ1wQMBAsgAUHIAGogBSABQSBqIAFBHmoQ5wQMAwsgAUHIAGogBSABQSBqIAFBHmoQzAQMAQsgAUHIAGogBSABQSBqIAFBHmoQygQLIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwICyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAgLDPMCCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQN4NwAJIAIgASkDyAE3AiAgAEH4yv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwHCwzyAgsgAUGQAWogAUHIAGogAS0AHiACEKMTIAEtAJABIgNBKUYEQCABQYsBaiABQaQBaigCACICNgAAIAFBgwFqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwB7IABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAYLIAFBhwFqIgQgAUGgAWopAAA3AAAgAUGAAWoiBSABQZkBaikAADcDACABQdABaiIGIAFBsAFqKQIANwMAIAFB2AFqIgcgAUG4AWopAgA3AwAgASABKQCRATcDeCABIAEpAqgBNwPIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDeDcACSACIAEpA8gBNwIgIABB+Mr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBgsM8QILIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwFCyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPACCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQN4NwAJIAIgASkDyAE3AiAgAEH4yv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwzvAgsgAUGQAWogAUHIAGogAS0AHiACEKMTIAEtAJABIgNBKUYEQCABQYsBaiABQaQBaigCACICNgAAIAFBgwFqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwB7IABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAMLIAFBhwFqIgQgAUGgAWopAAA3AAAgAUGAAWoiBSABQZkBaikAADcDACABQdABaiIGIAFBsAFqKQIANwMAIAFB2AFqIgcgAUG4AWopAgA3AwAgASABKQCRATcDeCABIAEpAqgBNwPIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDeDcACSACIAEpA8gBNwIgIABB+Mr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM7gILIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAILDO0CCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICRQ3sAiACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQcACaiQADAALDOUCCyAMQSBGDeACIA1BAUYNASANQSBGDQMLIAxBFGsOBxMUFRYXGBkSCyAMQQJrDhkDBAUGBwgJCgsMDQICAgICAgICAgICDg8QAgsgDEEgRg3eAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAzgAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAzfAgsjAEGAAWsiASQAIAFBOGogBSAGEPIhIgNBDGoiBBCoPhD0GCAEEKg+IgUEQCADKAIQIQZBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAQQqD4gAksEQCACIAZqLQAARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM8gILIAFBOGoQoBILIAUgAkEBaiICRw0ACwsgAUEMaiABQThqIgIQyg0gAhDxLwJAAkAgASgCDEUEQCAAIAEpAhA3AgAgAEEQaiABQSBqKAIANgIAIABBCGogAUEYaikCADcCAAwBCxCwPkE0QQQQrTYiAkUN8QIgAkKBgICAEDcCACACQQhqIAFBDGpBLPwKAAAgAEGA6f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQYABaiQADAALDN4CCyMAQYABayIBJAAgAUE4aiAFIAYQ+CEiA0EMaiIFENk8EPQYIAUQ2TwiBgRAIAMoAhAhBEEAIQIDQAJAIAMgAhCHJUUEQCABIAI2AmggBRDZPCACSwRAIAQvAQAQuz5B//8DcUYEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQJqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3wAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM3QILIwBBgAFrIgEkACABQThqIAUgBhD7ISIDQQxqIgUQ2zwQ9BggBRDbPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENs8IAJLBEAgBCgCABC7PkYEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQRqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3vAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM3AILIwBBgAFrIgEkACABQThqIAUgBhDzISIDQQxqIgUQ2DwQ9BggBRDYPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENg8IAJLBEAgBCkDABDBPlEEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQhqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3uAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM2wILIwBBgAFrIgEkACABQThqIAUgBhD3ISIDQQxqIgQQqD4Q9BggBBCoPiIFBEAgAygCECEGQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAEEKg+IAJLBEAgAiAGai0AAEUEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDO4CCyABQThqEKASCyAFIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDe0CIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzaAgsjAEGAAWsiASQAIAFBOGogBSAGEPAhIgNBDGoiBRDZPBD0GCAFENk8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2TwgAksEQCAELwEARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBAmohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDewCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzZAgsjAEGAAWsiASQAIAFBOGogBSAGEPUhIgNBDGoiBRDbPBD0GCAFENs8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2zwgAksEQCAEKAIARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBBGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDesCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzYAgsjAEGAAWsiASQAIAFBOGogBSAGEOwhIgNBDGoiBRDYPBD0GCAFENg8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2DwgAksEQCAEKQMAUARAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBCGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDeoCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzXAgsjAEGAAWsiASQAIAFBOGogBSAGEPQhIgNBDGoiBRDZPBD0GCAFENk8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2TwgAksEQCABIAQvAQA7AXAgAUEAOwEMIAFB8ABqIAFBDGoQjSgEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDOwCCyABQThqEKASCyAEQQJqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3pAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM1gILIwBBgAFrIgEkACABQThqIAUgBhDvISIDQQxqIgUQ2zwQ9BggBRDbPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENs8IAJLBEAgBCoCAEMAAAAAWwRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7AILIAFBOGoQoBILIARBBGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDegCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzVAgsjAEGAAWsiASQAIAFBOGogBSAGEIIiIgNBDGoiBRDYPBD0GCAFENg8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2DwgAksEQCAEKwMARAAAAAAAAAAAYQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7AILIAFBOGoQoBILIARBCGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDecCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzUAgsjAEGQAWsiASQAIAEgBSAGKAIQEQAAIAFBIGoiAyABKAIAIgIgASgCBCgCDBEAAAJAAkAgAkUNACABKQMgQsfZ9OfexLacd4UgASkDKEKNss6UjMqS5qd/hYRQRQ0AIAIQ0zohBSABQewAaiACEPk0IAEgBDYCjAEgASAFNgKIASABQQA2AoQBIAEgAjYCaCADIAFB6ABqEL8ZIAFBEGoiAiABQSxqKQIANwMAIAFBGGoiAyABQTRqKAIANgIAIAEgASkCJDcDCAJAIAEoAiAiBEUEQCAAIAEpAwg3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQeAAaiIFIAFByABqKAIANgIAIAFB2ABqIgYgAUFAaykCADcDACABQfAAaiIHIAIpAwA3AwAgAUH4AGoiCSADKAIANgIAIAEgASkCODcDUCABIAEpAwg3A2gQsD5BNEEEEK02IgJFDecCIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDaDcCDCACIAEpA1A3AiAgAEG4joABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBFGogBykDADcCACACQRxqIAkoAgA2AgAgAkEoaiAGKQMANwIAIAJBMGogBSgCADYCAAsgAUGQAWokAAwBC0GQj4ABELI7AAsM0wILIwBBkAFrIgEkACABIAUgBigCEBEAACABQSBqIgMgASgCACICIAEoAgQoAgwRAAACQAJAIAJFDQAgASkDIELT2NP4/eb2kkiFIAEpAyhCotieiOGg6unMAIWEUEUNACACENQ6IQUgAUHsAGogAhD5NCABIAQ2AowBIAEgBTYCiAEgAUEANgKEASABIAI2AmggAyABQegAahC+GSABQRBqIgIgAUEsaikCADcDACABQRhqIgMgAUE0aigCADYCACABIAEpAiQ3AwgCQCABKAIgIgRFBEAgACABKQMINwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUHgAGoiBSABQcgAaigCADYCACABQdgAaiIGIAFBQGspAgA3AwAgAUHwAGoiByACKQMANwMAIAFB+ABqIgkgAygCADYCACABIAEpAjg3A1AgASABKQMINwNoELA+QTRBBBCtNiICRQ3mAiACIAQ2AgggAkKBgICAEDcCACACIAEpA2g3AgwgAiABKQNQNwIgIABBuI6AATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRRqIAcpAwA3AgAgAkEcaiAJKAIANgIAIAJBKGogBikDADcCACACQTBqIAUoAgA2AgALIAFBkAFqJAAMAQtBkI+AARCyOwALDNICCyMAQaABayIBJAAgAUEIaiAFIAYoAhARAAAgAUEwaiIDIAEoAggiAiABKAIMKAIMEQAAAkACQCACRQ0AIAEpAzBCq5iR8ZX61fyAf4UgASkDOEKWlPir8LHps+EAhYRQRQ0AIAEgAjYCFCABQfgAaiICIAFBFGoQ+ikgASAENgKcASADIAIQwBkgAUEgaiICIAFBPGopAgA3AwAgAUEoaiIDIAFBxABqKAIANgIAIAEgASkCNDcDGAJAIAEoAjAiBEUEQCAAIAEpAxg3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfAAaiIFIAFB2ABqKAIANgIAIAFB6ABqIgYgAUHQAGopAgA3AwAgAUGAAWoiByACKQMANwMAIAFBiAFqIgkgAygCADYCACABIAEpAkg3A2AgASABKQMYNwN4ELA+QTRBBBCtNiICRQ3lAiACIAQ2AgggAkKBgICAEDcCACACIAEpA3g3AgwgAiABKQNgNwIgIABBuI6AATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRRqIAcpAwA3AgAgAkEcaiAJKAIANgIAIAJBKGogBikDADcCACACQTBqIAUoAgA2AgALIAFBoAFqJAAMAQtBoI+AARCyOwALDNECCyAMQQFHBEAgDUECaw4ZjQGOAY8BkAGRAZIBkwGUAZUBlgGXAboCmAGZAZoBmwG6AroCjAG6ArICugKzArUCtwK6AgsgDUECaw4ZCAkKCwwNDg8QERIHBwcHBwcHBwcHB7MCtQK3AgcLIA1BFWsOBhMUFRYXGBILIA1BFGsOBBkYGhsYCyANQRRrDgccHRseIB8hGwsgDUEUaw4HIiEjISQlJiELIA1BAmsOGSYnKCkqKywtxQIuLzAxMjM0xQI1NsUCNzjFAjk6xQILIA1BAmsOGUVGR0hJSktMwwJNTk9QUVJTwwJUVcMCVldYwwJZwwILIA1BAmsOGGRlZmdoaWprwQJsbW5vcHFywQJzdMECdXZ3eMECCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADMgCCyAAIQMjAEGwAWsiByQAIAdBGGogBSAGKAIQEQAAIAdB0ABqIAcoAhgiBSAHKAIcKAIMEQAAAn8CQAJAIAVFDd8CIAcpA1BCiqLN5aLCqolqhSAHKQNYQouy+d7NmrveOYWEUEUN3wIgByAFEK0+IgA2ApgBIAdBIGpBfyAAQQdqIgEgACABSxtBA3YQ0h8gACIBQT9xIgIEQCABIAEgAmtBQGsiAUsN4QILQcAAIQIgAUHAABDRNEUN4QIgAQRAELA+IAFBwAAQrTYiAkUNAQsgBygCKCEGIABFBEAgAiEEQQAMAwtBACEEA0AgAiAEaiEJAkAgBSAEEJUlRQRAIAkgBSAEEIQaOgAAIAYgBEEDdmoiCSAJLQAAQQEgBEEHcXRyOgAADAELIAlBADoAAAsgBEEBaiIEIABHDQALDAELQcAAIAEQoz0ACyACIARqIQQgBygCmAELIQUgByAEIAJrIgQ2AqQBAkAgBCAFRgRAIAcoAiwhBSAHIAcpAiA3AlwgB0EANgJYIAcgBTYCVCAHIAY2AlAgB0EQaiAHQdAAaiIGENc7IAcoAhAhCRCwPkEcQQQQrTYiBEUN4QIgBEKBgICAEDcCACAEIAcpAlA3AgggBEEQaiAHQdgAaiIKKQIANwIAIARBGGogB0HgAGoiCygCADYCACAHIAE2AmAgB0KAgICAgAg3AlggByAANgJUIAcgAjYCUCAHQQhqIAYQ1zsgBygCCCEGELA+QRxBBBCtNiIBRQRADOICCyABQoGAgIAQNwIAIAEgBykCUDcCCCABQRBqIAopAgA3AgAgAUEYaiALKAIANgIAIAcgBTYCoAEgByAJNgKcASAHIAQ2ApgBELA+QQxBBBCtNiICRQ3jAiACIAA2AgggAiAGNgIEIAIgATYCACAHQQE2AqwBIAcgAjYCqAEgB0EBNgKkASAHQQA2AiggB0KAgICAwAA3AiAgB0HQAGoiBEGgvP8AIAAgAiAHQZgBaiAHQaQBaiAHQSBqIgEQjBMgASAEELYTELA+QThBBBCtNiIARQ3OAiAAQoGAgIAQNwIAIABBCGogAUEw/AoAACADQaDm/wA2AgggAyAANgIEIANBk4CAgHg2AgAgB0GwAWokAAwBCwzhAgsMxwILIAAhAiMAQbABayIDJAAgA0EYaiAFIAYoAhARAAAgA0HQAGogAygCGCIJIAMoAhwoAgwRAAACfwJAIAlFDd0CIAMpA1BCiqLN5aLCqolqhSADKQNYQouy+d7NmrveOYWEUEUN3QIgAyAJEK0+IgQ2ApgBIANBIGpBfyAEQQdqIgAgACAESRtBA3YQ0h8gBEEBdCIHIQUgB0E+cSIABEAgByAAa0FAayIFIAdJDd8CC0HAACEBIAVBwAAQ0TRFDeMCIAUEQBCwPiAFQcAAEK02IgFFDeUCCyADKAIoIQogBEUEQCABIQBBAAwCCyABIQBBACEGA0ACQCAJIAYQlSVFBEAgACAJIAYQhBoEf0EBBRC7Pgs7AQAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEAOwEACyAAQQJqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0EBdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDeACIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzhAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN4gIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBjL3/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRC9ExCwPkE4QQQQrTYiAEUNzQIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkH45v8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM5AILDMYCCyAAIQFBACEAQQAhAkEAIQojAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCyADKAIcKAIMEQAAAkAgC0UN2wIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3bAiADIAsQrT4iBTYCrAEgA0EgakF/IAVBB2oiBCAEIAVJG0EDdhDSHyAFQQJ0IgYhBCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkN3QILQcAAIQ0gBEHAABDRNEUN4QIgBARAELA+IARBwAAQrTYiDUUN5QILIAMoAighDkEAIQxBACEHA0AgA0HQAGohCQJ/IAUgB00EQEECIQogAAwBC0EAIQkCQCALIAcQlSUNAEEBIQkgCyAHEIQaBEBBASEKDAELELs+IQoLIAdBAWohByADIAk2AlAgA0GUAWohCSAAIgJBAWoLIQAgCSAKNgIAAkACQAJAIAMoAlAiD0ECRwRAIAwgDWohCSAPQQFxRQ0BIAkgAygClAE2AgAgDiACQQN2aiIJIAktAABBASACQQdxdHI6AAAMAgsgAyAMQQJ1IgA2AqABIAAgAygCrAFHDekCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIA42AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN4gIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiCygCADYCACADIAQ2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgDTYCUCADQQhqIAIQ1zsgAygCCCEEELA+QRxBBBCtNiICDQIM4gILIAlBADYCAAsgDEEEaiEMDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiALKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3gAiAAIAY2AgggACAENgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEGAvf8AIAUgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAEK0TELA+QThBBBCtNiIARQ3LAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZDS/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzFAgsgACEBQQAhAEEAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN2gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3aAiADIAkQrT4iBDYCrAEgA0EgakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgYhBSAGQThxIgcEQCAGIAdrQUBrIgUgBkkN3AILQcAAIQsgBUHAABDRNEUN4AIgBQRAELA+IAVBwAAQrTYiC0UN4gILQQAhCiADKAIoIQxBACEHA0AgA0HQAGohDQJ/IAQgB00EQEICIRsgAAwBC0IAIRwCQCAJIAcQlSUNAEIBIRwgCSAHEIQaBEBCASEbDAELEME+IRsLIAdBAWohByADIBw3A1AgA0GgAWohDSAAIgJBAWoLIQAgDSAbNwMAAkACQAJAIAMpA1AiG0ICUgRAIAogC2ohDSAbp0EBcUUNASANIAMpA6ABNwMAIAwgAkEDdmoiDSANLQAAQQEgAkEHcXRyOgAADAILIAMgCkEDdSIANgKUASAAIARHDekCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIAw2AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN4QIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiDCgCADYCACADIAU2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgCzYCUCADQQhqIAIQ1zsgAygCCCEFELA+QRxBBBCtNiICDQIM4QILIA1CADcDAAsgCkEIaiEKDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3fAiAAIAY2AgggACAFNgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEHQvP8AIAQgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAELETELA+QThBBBCtNiIARQ3KAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQejS/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzEAgsgACEDIwBBsAFrIgckACAHQRhqIAUgBigCEBEAACAHQdAAaiAHKAIYIgUgBygCHCgCDBEAAAJ/AkACQCAFRQ3bAiAHKQNQQoqizeWiwqqJaoUgBykDWEKLsvnezZq73jmFhFBFDdsCIAcgBRCtPiIANgKYASAHQSBqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIAAiAUE/cSICBEAgASABIAJrQUBrIgFLDd0CC0HAACECIAFBwAAQ0TRFDd0CIAEEQBCwPiABQcAAEK02IgJFDQELIAcoAighBiAARQRAIAIhBEEADAMLQQAhBANAIAIgBGohCQJAIAUgBBCVJUUEQCAJIAUgBBCEGjoAACAGIARBA3ZqIgkgCS0AAEEBIARBB3F0cjoAAAwBCyAJQQA6AAALIARBAWoiBCAARw0ACwwBC0HAACABEKM9AAsgAiAEaiEEIAcoApgBCyEFIAcgBCACayIENgKkAQJAIAQgBUYEQCAHKAIsIQUgByAHKQIgNwJcIAdBADYCWCAHIAU2AlQgByAGNgJQIAdBEGogB0HQAGoiBhDXOyAHKAIQIQkQsD5BHEEEEK02IgRFDd0CIARCgYCAgBA3AgAgBCAHKQJQNwIIIARBEGogB0HYAGoiCikCADcCACAEQRhqIAdB4ABqIgsoAgA2AgAgByABNgJgIAdCgICAgIAINwJYIAcgADYCVCAHIAI2AlAgB0EIaiAGENc7IAcoAgghBhCwPkEcQQQQrTYiAUUEQAzeAgsgAUKBgICAEDcCACABIAcpAlA3AgggAUEQaiAKKQIANwIAIAFBGGogCygCADYCACAHIAU2AqABIAcgCTYCnAEgByAENgKYARCwPkEMQQQQrTYiAkUN3wIgAiAANgIIIAIgBjYCBCACIAE2AgAgB0EBNgKsASAHIAI2AqgBIAdBATYCpAEgB0EANgIoIAdCgICAgMAANwIgIAdB0ABqIgRB6Lz/ACAAIAIgB0GYAWogB0GkAWogB0EgaiIBEIwTIAEgBBC4ExCwPkE4QQQQrTYiAEUNygIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgA0HI5f8ANgIIIAMgADYCBCADQZOAgIB4NgIAIAdBsAFqJAAMAQsM3QILDMMCCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAn8CQCAJRQ3ZAiADKQNQQoqizeWiwqqJaoUgAykDWEKLsvnezZq73jmFhFBFDdkCIAMgCRCtPiIENgKYASADQSBqQX8gBEEHaiIAIAAgBEkbQQN2ENIfIARBAXQiByEFIAdBPnEiAARAIAcgAGtBQGsiBSAHSQ3bAgtBwAAhASAFQcAAENE0RQ3fAiAFBEAQsD4gBUHAABCtNiIBRQ3hAgsgAygCKCEKIARFBEAgASEAQQAMAgsgASEAQQAhBgNAAkAgCSAGEJUlRQRAIAAgCSAGEIQaOwEAIAogBkEDdmoiCyALLQAAQQEgBkEHcXRyOgAADAELIABBADsBAAsgAEECaiEAIAZBAWoiBiAERw0ACwwACyADKAKYAQshBiADIAAgAWtBAXUiADYCpAECQCAAIAZGBEAgAygCLCEGIAMgAykCIDcCXCADQQA2AlggAyAGNgJUIAMgCjYCUCADQRBqIANB0ABqIgkQ1zsgAygCECEKELA+QRxBBBCtNiIARQ3cAiAAQoGAgIAQNwIAIAAgAykCUDcCCCAAQRBqIANB2ABqIgspAgA3AgAgAEEYaiADQeAAaiIMKAIANgIAIAMgBTYCYCADQoCAgICACDcCWCADIAc2AlQgAyABNgJQIANBCGogCRDXOyADKAIIIQUQsD5BHEEEEK02IgFFBEAM3QILIAFCgYCAgBA3AgAgASADKQJQNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAGNgKgASADIAo2ApwBIAMgADYCmAEQsD5BDEEEEK02IgBFDd4CIAAgBzYCCCAAIAU2AgQgACABNgIAIANBATYCrAEgAyAANgKoASADQQE2AqQBIANBADYCKCADQoCAgIDAADcCICADQdAAaiIFQdy8/wAgBCAAIANBmAFqIANBpAFqIANBIGoiARCMEyABIAUQqhMQsD5BOEEEEK02IgBFDckCIABCgYCAgBA3AgAgAEEIaiABQTD8CgAAIAJBmOT/ADYCCCACIAA2AgQgAkGTgICAeDYCACADQbABaiQADAELDOACCwzCAgsgACEBQQAhAEEAIQJBACEMIwBBsAFrIgMkACADQRhqIAUgBigCEBEAACADQdAAaiADKAIYIgogAygCHCgCDBEAAAJAIApFDdcCIAMpA1BCiqLN5aLCqolqhSADKQNYQouy+d7NmrveOYWEUEUN1wIgAyAKEK0+IgU2AqwBIANBIGpBfyAFQQdqIgQgBCAFSRtBA3YQ0h8gBUECdCIGIQQgBkE8cSIHBEAgBiAHa0FAayIEIAZJDdkCC0HAACENIARBwAAQ0TRFDd0CIAQEQBCwPiAEQcAAEK02Ig1FDeECCyADKAIoIQ5BACELQQAhBwNAIANB0ABqIQkCfyAFIAdNBEBBAiEMIAAMAQtBACEJIAogBxCVJUUEQCAKIAcQhBohDEEBIQkLIAdBAWohByADIAk2AlAgA0GUAWohCSAAIgJBAWoLIQAgCSAMNgIAAkACQAJAIAMoAlAiD0ECRwRAIAsgDWohCSAPQQFxRQ0BIAkgAygClAE2AgAgDiACQQN2aiIJIAktAABBASACQQdxdHI6AAAMAgsgAyALQQJ1IgA2AqABIAAgAygCrAFHDeUCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIA42AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN3gIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiCygCADYCACADIAQ2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgDTYCUCADQQhqIAIQ1zsgAygCCCEEELA+QRxBBBCtNiICDQIM3gILIAlBADYCAAsgC0EEaiELDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiALKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3cAiAAIAY2AgggACAENgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEHwu/8AIAUgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAELkTELA+QThBBBCtNiIARQ3HAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQdDn/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzBAgsgACEBQQAhAEEAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN1gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3WAiADIAkQrT4iBDYCrAEgA0EgakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgYhBSAGQThxIgcEQCAGIAdrQUBrIgUgBkkN2AILQcAAIQsgBUHAABDRNEUN3AIgBQRAELA+IAVBwAAQrTYiC0UN3gILQQAhCiADKAIoIQxBACEHA0AgA0HQAGohDQJ/IAQgB00EQEICIRsgAAwBC0IAIRwgCSAHEJUlRQRAQgEhHCAJIAcQhBqtIRsLIAdBAWohByADIBw3A1AgA0GgAWohDSAAIgJBAWoLIQAgDSAbNwMAAkACQAJAIAMpA1AiG0ICUgRAIAogC2ohDSAbp0EBcUUNASANIAMpA6ABNwMAIAwgAkEDdmoiDSANLQAAQQEgAkEHcXRyOgAADAILIAMgCkEDdSIANgKUASAAIARHDeUCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIAw2AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN3QIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiDCgCADYCACADIAU2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgCzYCUCADQQhqIAIQ1zsgAygCCCEFELA+QRxBBBCtNiICDQIM3QILIA1CADcDAAsgCkEIaiEKDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3bAiAAIAY2AgggACAFNgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEG4vP8AIAQgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAEK4TELA+QThBBBCtNiIARQ3GAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQfDk/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzAAgsgACECIwBBsAFrIgMkACADQRhqIAUgBigCEBEAACADQdAAaiADKAIYIgkgAygCHCgCDBEAAAJ/AkAgCUUN1gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3WAiADIAkQrT4iBDYCmAEgA0EgakF/IARBB2oiACAAIARJG0EDdhDSHyAEQQF0IgchBSAHQT5xIgAEQCAHIABrQUBrIgUgB0kN2AILQcAAIQEgBUHAABDRNEUN3AIgBQRAELA+IAVBwAAQrTYiAUUN3gILIAMoAighCiAERQRAIAEhAEEADAILIAEhAEEAIQYDQAJAIAkgBhCVJUUEQCAAQYD4AEEAIAkgBhCEGhs7AQAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEAOwEACyAAQQJqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0EBdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdkCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzaAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2wIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBlLz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRCrExCwPkE4QQQQrTYiAEUNxgIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkHo4v8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM3QILDL8CCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAn8CQCAJRQ3VAiADKQNQQoqizeWiwqqJaoUgAykDWEKLsvnezZq73jmFhFBFDdUCIAMgCRCtPiIENgKYASADQSBqQX8gBEEHaiIAIAAgBEkbQQN2ENIfIARBAnQiByEFIAdBPHEiAARAIAcgAGtBQGsiBSAHSQ3XAgtBwAAhASAFQcAAENE0RQ3bAiAFBEAQsD4gBUHAABCtNiIBRQ3dAgsgAygCKCEKIARFBEAgASEAQQAMAgsgASEAQQAhBgNAAkAgCSAGEJUlRQRAIABDAACAP0MAAAAAIAkgBhCEGhs4AgAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEANgIACyAAQQRqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0ECdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdgCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzZAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2gIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBrLz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRCzExCwPkE4QQQQrTYiAEUNxQIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkHA4/8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM3AILDL4CCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN0wIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3TAiADIAkQrT4iBDYCmAEgA0EgakF/IARBB2oiACAAIARJG0EDdhDSHyAEQQN0IgchBSAHQThxIgAEQCAHIABrQUBrIgUgB0kN1QILQcAAIQEgBUHAABDRNEUN2QIgBQRAELA+IAVBwAAQrTYiAUUN2wILIAMoAighCiABIQAgBEUNAEEAIQYDQAJAIAkgBhCVJUUEQCAARAAAAAAAAPA/RAAAAAAAAAAAIAkgBhCEGhs5AwAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEIANwMACyAAQQhqIQAgBCAGQQFqIgZHDQALDAALIAMgACABa0EDdSIANgKkAQJAIAAgBEYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdcCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzYAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2QIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVB9Lz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRDHExCwPkE4QQQQrTYiAEUNxAIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkGo6P8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM2wILDL0CCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLwCCyMAQYABayIBJAAgAUEIaiAFIAYQlyIiAxDTOiALEI8XAkACQCADENM6IgUEQEEAIQIgBC0ANEEBcSEEA0ACQCADIAIQliVFBEAgASADIAIQgBcgAUE0aiABQQhqIAEoAgAgASgCBBCiECABKAI0QZOAgIB4Rg0BIAFB2ABqIAFBxABqKAIANgIAIAFB0ABqIAFBPGopAgA3AwAgASABKQI0NwNIIARFBEAgACABKQI0NwIAIABBEGogAUHEAGooAgA2AgAgAEEIaiABQTxqKQIANwIADAULIAFBCGoQkRUgAUHIAGoQiBEMAQsgAUEIahCRFQsgBSACQQFqIgJHDQALCyABQcgAaiIDIAFBCGoQxxQQsD5BwABBBBCtNiICRQ3HAiACQoGAgIAQNwIAIAJBCGogA0E4/AoAACAAQejp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBCGoQii8gAUGAAWokAAwACwy7AgsgACAFIAYQrgYMugILIAhB0ABqIQcgBSAGEJciIQQjAEGwAWsiAyQAIAQoAhAhAQJAAkACQCAEKAIUIgJBBEkNACABIAJBfHFqQQRrIgVFDQAgBSgCAEF/Rg0BCyADIAQQ0zoiCTYCDCADQRBqIgYgCRDEGyAEKAIYIgUgBSgCACIKQQFqNgIAAkACQCAKQQBOBEAgAyAFNgKIASADIAQpAhw3AowBIAYgA0GIAWoQ2SAhDiACQQhJDQIgAkECdiEKIANByABqIQ8gA0HsAGohC0EAIQUDQCABQQRqIgIoAgAhBiABKAIAIQECQCAEIAUQliVFBEAgA0EQaiAOIAEgBiABaxCJEAwBCyALEOY6IAMoAmxFDQMgAygCfEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCeCIGSwRAIAEgBmshDSADKAJwIhAgAUkEQCALIBBBAXQiBiABENAqIhAgBiAQSxsQ6BkgAygCeCEGCyANBEAgAygCdCAGakEAIA38CwALIAMgATYCeAsgAyAMNgJ8IAMoAlAiASADKAJIRgRAIA9B/OmAARCxKAsgAygCTCABQQR0aiIGQgA3AwggBkIANwMAIAMgAUEBajYCUAsgBUEBaiEFIAIhASAKQQFrIgpBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAJRgRAIAcgARDcDCABEOklDAILDNwCCyAEENM6IQEgA0EUaiAEEPk0IAMgATYCMCADQQA2AiwgAyAENgIQIAcgA0EQahDFDwsgA0GwAWokACAHEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADLkCCyAAIAUgBiAEEM8HDLgCCyAIQdAAaiAFIAYgBBDPByAIKAJYIQIgCCgCVCEBIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACACNgIIIAAgATYCBCAAIAM2AgAMuAILIAggAjYClAIgCCABNgKQAiAAIAEgAigCCEEBa0F4cWpBCGogAhCvBiABIAEoAgAiAEEBazYCACAAQQFHDbcCIAhBkAJqELsjDLcCCyAIQZACaiAFIAYgBBDPByAIKAKYAiECIAgoApQCIQEgCCgCkAIiA0GTgICAeEcEQCAAIAgpApwCNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADLcCCyAIIAI2AsQDIAggATYCwAMgCEHAA2oiAygCACADKAIEIgQoAghBAWtBeHFqQQhqIAQQlyQiBEUEQEGA4oABQQxBjOKAARDLJAALIAhB0ABqIgIgBBCcCiACEOwpIQIgAEHI4P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEgASgCACIAQQFrNgIAIABBAUcNtgIgAxC7Iwy2AgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAy1AgsgCSgCBCEEIwBBoAFrIgEkACABQSBqIAUgBigCEBEAACABQeAAaiIDIAEoAiAiAiABKAIkKAIMEQAAAkACQAJAAkACQCACRQ0AIAEpA2BCwOO13tL+pZUshSABKQNoQvXOqKjR/trMpH+FhFBFDQAgAjUCMCEbIAFB6ABqQZSo0KABNgIAIAFClKjQoMGChYoUNwNgIAFBEGogG0IAIASsIhsgG0I/hxCoHiABKQMYIRsgASkDECADEKcMQoCAgIAIVCAbQgBTIBtQG0UEQCADQTdBAEEBQQEQoBggASgCZCECIAEoAmBBAUYNAiABKAJoIgNB0Or/AEE3/AoAACAAQTc2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAQLIAFBLGogAigCMCIDIAMQphQgAigCMCIERQ0CQQAhAwNAAkAgAiADEJslRQRAIAFBCGogAiADEKAbIAFBLGogASgCCCABKAIMEP0SDAELIAFBLGoQphULIAQgA0EBaiIDRw0ACwwCC0HA6v8AELI7AAsgAiABKAJoQYzJ/wAQ/S8ACyABQeAAaiIDIAFBLGoiBBDrDhCwPkHEAEEEEK02IgJFDbwCIAJCgYCAgBA3AgAgAkEIaiADQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACAEELosCyABQaABaiQADAALDLQCCyMAQZABayIBJAAgAUEQaiAFIAYoAhARAAAgAUHQAGoiAyABKAIQIgIgASgCFCgCDBEAAAJAAkAgAkUNACABKQNQQsDjtd7S/qWVLIUgASkDWEL1zqio0f7azKR/hYRQRQ0AIAFB2ABqQZas2LABNgIAIAFClqzYsOHChYsWNwNQIAMQpwwgAUEcaiACKAIwIgMgAxClFCACKAIwIgRFDQFBACEDA0ACQCACIAMQmyVFBEAgAUEIaiACIAMQoBsgAUEcaiABKAIIIAEoAgwQ/hIMAQsgAUEcahCnFQsgBCADQQFqIgNHDQALDAELQcDq/wAQsjsACyABQdAAaiIDIAFBHGoiBBDsDhCwPgJAQcQAQQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiADQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACAEELssIAFBkAFqJAAMAQsMugILDLMCCyAAIQRBACEJIwBBgANrIgckACAHQRhqIAUgBigCEBEAACAHQSBqIgAgBygCGCIFIAcoAhwoAgwRAAACQAJAIAVFDQAgBykDIELA47Xe0v6llSyFIAcpAyhC9c6oqNH+2sykf4WEUEUNACAAIAUoAjAQxBsgBSgCMCIXRQ0BIAdB5ABqIRggB0HwAGohCiAHQagBaiELIAdBqAJqIQwgB0H8AGohBiAHQdgAaiENIAdBOGohDiAHQdwCaiEQIAdBLGohFCAHQShqIQ8CQANAAkACQAJAAkACQCAFIAkQmyVFBEAgB0EQaiAFIAkQoBsgBygCECEDIAcgBygCFCIANgLcASAHIAM2AtgBAkAgAEENTwRAIAcoAighASAHQQA2AiggAQ0BDAULIAdBADYC6AEgB0IANwPgASAABEAgB0HgAWogAyAA/AoAAAsgBzUC6AEhGyAHKQPgASEcIAcoAmAiASAHKAJYRgRAIA1BgMD/ABCxKAsgBygCXCABQQR0aiICIBs+AgwgAiAcNwIEIAIgADYCACAHIAFBAWo2AmAgBygCfARAIAcoAowBIgJBAWoiA0EDdiADQQdxQQBHaiIAIAcoAogBIgFLBEAgACABayERIAcoAoABIhIgAEkEQCAGIBJBAXQiASAAEM0qIhIgASASSxsQ6BkgBygCiAEhAQsgEQRAIAcoAoQBIAFqQQAgEfwLAAsgByAANgKIAQsgByADNgKMASAHKAKEASACQQN2aiIAIAAtAABBASACQQdxdHI6AAAMBgsgByAHKAKQAUEBajYCkAEMBQsgECAUKQIANwIAIBBBCGogFEEIaigCADYCACAHQYACaiIRIA5BCGopAwAiGzcDACAHQYgCaiISIA5BEGopAwAiIDcDACAHQZACaiIWIA5BGGopAwAiHzcDACAHIAE2AtgCIAcgDikDACIcNwP4ASAbIACtIh6FIh1COIYgHUKA/gODQiiGhCAdQoCA/AeDQhiGIB1CgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAdQtii0e/CqeW/LX6FIB58Qq3+1eTUhf2o2AB+IRsCQCAAQRBNBEAgGyAcfCADKQAAICCFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgACADakEIaykAACAfhSIdQn+FfiIeQjiGIB5CgP4Dg0IohoQgHkKAgPwHg0IYhiAeQoCAgPgPg0IIhoSEIB5CCIhCgICA+A+DIB5CGIhCgID8B4OEIB5CKIhCgP4DgyAeQjiIhISEhSAdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEIBt+hUIXiSEbDAELIBsgHHwgICAAIANqQRBrIgEpAACFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgHyABKQAIhSIdQn+FfiIeQjiGIB5CgP4Dg0IohoQgHkKAgPwHg0IYhiAeQoCAgPgPg0IIhoSEIB5CCIhCgICA+A+DIB5CGIhCgID8B4OEIB5CKIhCgP4DgyAeQjiIhISEhSAdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEIBt+hUIXiSEbIB9Cf4UhHiADIQIgACEBA0AgGyAcfCAgIAIpAACFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgAikACCIhIB6FfiIdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEhSAbIB8gIYUiHUI4hiAdQoD+A4NCKIaEIB1CgID8B4NCGIYgHUKAgID4D4NCCIaEhCAdQgiIQoCAgPgPgyAdQhiIQoCA/AeDhCAdQiiIQoD+A4MgHUI4iISEhH6FQheJIRsgAkEQaiECIAFBEGsiAUEQSw0ACwsgB0HoAmogB0HYAmogGyAcQjiGIBxCgP4Dg0IohoQgHEKAgPwHg0IYhiAcQoCAgPgPg0IIhoSEIBxCCIhCgICA+A+DIBxCGIhCgID8B4OEIBxCKIhCgP4DgyAcQjiIhISEfiAbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEIBtCCIhCgICA+A+DIBtCGIhCgID8B4OEIBtCKIhCgP4DgyAbQjiIhISEIBxCf4V+IhxCOIYgHEKA/gODQiiGhCAcQoCA/AeDQhiGIBxCgICA+A+DQgiGhIQgHEIIiEKAgID4D4MgHEIYiEKAgPwHg4QgHEIoiEKA/gODIBxCOIiEhISFIBuJIAdBIGogB0HYAWogB0H4AWoQ+g0gBygC6AJBAUYEQCAHKAL8AiIBKAIAIgIgBygC+AIiFWoiEy0AACEZIAcoAmAhGiATIAcoAvACQRl2IhM6AAAgAiABKAIEIBVBCGtxakEIaiATOgAAIAEgASgCDEEBajYCDCABIAEoAgggGUEBcWs2AgggAiAVQQJ0a0EEayAaNgIAIAdBoAFqIAdB4AJqKQIANwMAIAcgBykC2AI3A5gBIAtBGGogFikDADcDACALQRBqIBIpAwA3AwAgC0EIaiARKQMANwMAIAsgBykD+AE3AwAgBygCKARAIA8QjjsLIA8gB0GYAWpBMPwKAAAMBAsgBygC+AJBBGsoAgAiASAHKAJgIgBPDQEgBygCXCICIAFBBHRqIgEpAwghGyABKQMAIRwgBygCWCAARgR/IA1BwL//ABCxKCAHKAJcBSACCyAAQQR0aiIBIBs3AwggASAcNwMAIAcgAEEBajYCYAJAIAcoAnwEQCAHKAKMASICQQFqIgNBA3YgA0EHcUEAR2oiACAHKAKIASIBSwRAIAAgAWshFSAHKAKAASITIABJBEAgBiATQQF0IgEgABDNKiITIAEgE0sbEOgZIAcoAogBIQELIBUEQCAHKAKEASABakEAIBX8CwALIAcgADYCiAELIAcgAzYCjAEgBygChAEgAkEDdmoiACAALQAAQQEgAkEHcXRyOgAADAELIAcgBygCkAFBAWo2ApABCyAMIAcpA/gBNwMAIAdBoAJqIAdB4AJqKQIANwMAIAxBCGogESkDADcDACAMQRBqIBIpAwA3AwAgDEEYaiAWKQMANwMAIAcgBykC2AI3A5gCIAcoAigEQCAPEI47CyAPIAdBmAJqQTD8CgAADAQLIAYQ5jogBygCfEUNASAHKAKMAUEBaiIBQQN2IAFBB3FBAEdqIgAgBygCiAEiAksEQCAAIAJrIQMgBygCgAEiESAASQRAIAYgEUEBdCICIAAQzSoiESACIBFLGxDoGSAHKAKIASECCyADBEAgBygChAEgAmpBACAD/AsACyAHIAA2AogBCyAHIAE2AowBIAcoAmAiACAHKAJYRgRAIA1BoL//ABCxKAsgBygCXCAAQQR0aiIBQgA3AwggAUIANwMAIAcgAEEBajYCYAwDCyABIABBsL//ABDDIQALQejB/wAQsjsACyAHKAJwIAcoAngiAiAAakkEQCACBEAgB0HQAmogCkEIaigCADYCACAHIAopAgA3A8gCIAdBADYCeCAHQoCAgIAQNwNwIAdB2AJqIAdByAJqEPIvIAcgBykC2AI3AvQCIAdBADYC8AIgByAHKALkAiICNgLsAiAHIAcoAuACNgLoAiAHQQhqIAdB6AJqENc7IAcoAgghFhCwPkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBykC6AI3AgggAUEQaiAHQfACaikCADcCACABQRhqIAdB+AJqKAIANgIAIAJBf0YNBSAHKAJsIhEgBygCZEYEQCAYQbjA/wAQkCgLIAcoAmggEUEMbGoiEiACNgIIIBIgFjYCBCASIAE2AgAgByARQQFqNgJsCyAKIAdBIGoQ1yoiASAAIAAgAUkbEIQuIAcoAnghAgsgCiADIAAQoTYgBzUCbCACrUIghoQhGyAArSADNQAAQiCGhCEcIAcoAmAiACAHKAJYRgRAIA1B8L//ABCxKAsgBygCXCAAQQR0aiIBIBs3AwggASAcNwMAIAcgAEEBajYCYCAHKAJ8BEAgBygCjAEiAkEBaiIDQQN2IANBB3FBAEdqIgAgBygCiAEiAUsEQCAAIAFrIREgBygCgAEiEiAASQRAIAYgEkEBdCIBIAAQzSoiEiABIBJLGxDoGSAHKAKIASEBCyARBEAgBygChAEgAWpBACAR/AsACyAHIAA2AogBCyAHIAM2AowBIAcoAoQBIAJBA3ZqIgAgAC0AAEEBIAJBB3F0cjoAAAwBCyAHIAcoApABQQFqNgKQAQsgCUEBaiIJIBdHDQEMBAsLDM0CCyAHQQA2AvgCIAdBATYC7AIgB0GgwP8ANgLoAiAHQgQ3AvACIAdB6AJqQajA/wAQ7ywAC0GI6/8AELI7AAsgB0GYAWoiASAHQSBqENwMELA+AkBBxABBBBCtNiIABEAgAEKBgICAEDcCACAAQQhqIAFBPPwKAAAgBEHw3/8ANgIIIAQgADYCBCAEQZOAgIB4NgIAIAdB2ABqIgAQyT4gABDmPCAHKAJ8BEAgB0H8AGoQzy8LIAdB5ABqIgAQxScgABDoOyAHQfAAaiIAEMk+IAAQ3jsgBygCKARAIAdBKGoQjjsLIAdBgANqJAAMAQsMuQILDLICCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLECCyAAIAUgBhClBAywAgsjAEGAAWsiASQAIAFBCGogBSAGEJYiIgMQ1DogCxCPFwJAAkAgAxDUOiIFBEBBACECIAQtADRBAXEhBANAAkAgAyACEJYlRQRAIAEgAyACEPIWIAFBNGogAUEIaiABKAIAIAEoAgQQohAgASgCNEGTgICAeEYNASABQdgAaiABQcQAaigCADYCACABQdAAaiABQTxqKQIANwMAIAEgASkCNDcDSCAERQRAIAAgASkCNDcCACAAQRBqIAFBxABqKAIANgIAIABBCGogAUE8aikCADcCAAwFCyABQQhqEJEVIAFByABqEIgRDAELIAFBCGoQkRULIAUgAkEBaiICRw0ACwsgAUHIAGoiAyABQQhqEMcUELA+QcAAQQQQrTYiAkUNuwIgAkKBgICAEDcCACACQQhqIANBOPwKAAAgAEHo6f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQQhqEIovIAFBgAFqJAAMAAsMrwILIAhB0ABqIQcgBSAGEJYiIQQjAEGwAWsiAyQAIAQoAhAhAQJAAkACQCAEKAIUIgJBCEkNACABIAJBeHFqQQhrIgVFDQAgBSgCAEF/Rg0BCyADIAQQ1DoiCTYCDCADQRBqIgYgCRDEGyAEKAIYIgUgBSgCACIKQQFqNgIAAkACQCAKQQBOBEAgAyAFNgKIASADIAQpAhw3AowBIAYgA0GIAWoQ2SAhDiACQRBJDQIgAkEDdiEKIANByABqIQ8gA0HsAGohC0EAIQUDQCABQQhqIgIpAwAhGyABKQMAIRwCQCAEIAUQliVFBEAgA0EQaiAOIBynIgEgG6cgAWsQiRAMAQsgCxDmOiADKAJsRQ0DIAMoAnxBAWoiDEEDdiAMQQdxQQBHaiIBIAMoAngiBksEQCABIAZrIQ0gAygCcCIQIAFJBEAgCyAQQQF0IgYgARDQKiIQIAYgEEsbEOgZIAMoAnghBgsgDQRAIAMoAnQgBmpBACAN/AsACyADIAE2AngLIAMgDDYCfCADKAJQIgEgAygCSEYEQCAPQfzpgAEQsSgLIAMoAkwgAUEEdGoiBkIANwMIIAZCADcDACADIAFBAWo2AlALIAVBAWohBSACIQEgCkEBayIKQQJPDQALDAILAAtB3OyAARCyOwALIAMgA0EQaiIBENE8IgI2ApQBIAIgCUYEQCAHIAEQ3AwgARDpJQwCCwzRAgsgBBDUOiEBIANBFGogBBD5NCADIAE2AjAgA0EANgIsIAMgBDYCECAHIANBEGoQxg8LIANBsAFqJAAgBxDsKSEBIABB8N//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyuAgsgACAFIAYgBBDQBwytAgsgCEHQAGogBSAGIAQQ0AcgCCgCWCECIAgoAlQhASAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADK0CCyAIIAI2ApQCIAggATYCkAIgACABIAIoAghBAWtBeHFqQQhqIAIQpgQgASABKAIAIgBBAWs2AgAgAEEBRw2sAiAIQZACahC7IwysAgsgCEHQAGogBSAGIAQQ0AcgCCgCWCECIAgoAlQhASAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADKwCCyAIIAI2ApQCIAggATYCkAIgCEGQAmoiAygCACADKAIEIgQoAghBAWtBeHFqQQhqIAQQliQiBEUEQEGA4oABQQxBjOKAARDLJAALIAhB0ABqIgIgBBCOCiACEOwpIQIgAEHI4P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEgASgCACIAQQFrNgIAIABBAUcNqwIgAxC7IwyrAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAyqAgsgACAFIAYQ6wsMqQILIAAgBSAGEOwLDKgCCyAIQdAAaiAFIAYQ6wsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADKgCCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgBBDPByAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDacCIAAQuyMMpwILIAhB0ABqIAUgBhDsCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMpwILIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAEENAHIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNpgIgABC7IwymAgsgCEHQAGoiASAFIAYQiyIQpBQgCEGQAmohAyMAQYABayICJAAgAkHEAGogASgCHCABKAIgQQR2IAEoAgQgASgCCBDiBgJAIAIoAkQiBEGTgICAeEcEQCADIAIpAkg3AgggA0EQaiACQdAAaikCADcCACADQYCAgIB4NgIAIAMgBDYCBCABEPkiDAELIAJBxABqIAFBPPwKAAAgAkEcakGatOjQATYCACACQShqIAFBIGooAgA2AgAgAkEQaiABQQhqKAIANgIAIAJBNGogAUEsaikCADcCACACQTxqIAFBNGopAgA3AgAgAkKatOjQocOGjRo3AhQgAiABKQIYNwMgIAIgASkCADcDCCACIAEpAiQ3AiwgAkHQAGoQwgwgAyACQQhqQTz8CgAACyACQYABaiQAIAhByANqIgEgCEGcAmopAgA3AwAgCEHQA2oiAiAIQaQCaigCADYCACAIIAgpApQCNwPAAyAIKAKQAiIDQYCAgIB4Rg2gAiAIQeQCaiAIQagCakEk/AoAACAIQdgCaiABKQMANwIAIAhB4AJqIAIoAgA2AgAgCCADNgLMAiAIIAgpA8ADNwLQAiAIQcwCahDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAylAgsgACEBIwBB4AFrIgckACAFIAYQmSIiAxDTOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahCgFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENM6GiADENM6IQkgAxDTOhogByADENM6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNtgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwzQAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQjywgB0EYaiAHKAIgIAcoAiQQux0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNwwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDcUCIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQfTy/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELYTELA+QThBBBCtNiIARQ2wAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZiHgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMzQILDMECCwzMAgsMzAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDYHRCwPkE4QQQQrTYiAEUNqwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDKQCCyMAQeABayIDJAAgBSAGEJkiIgEQ0zohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQyhcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEJIAEQ0zoaIAMgARDTOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ3HAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw3PAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRCPLCADQRhqIAMoAiAgAygCJBDuHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNwgIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMwwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ3EAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGY8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARC9ExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQYCBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMzwILDK0CCwzOAgsMywILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDaHRCwPkE4QQQQrTYiAUUNqgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDKMCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQsBcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3LAgtBwAAhCSAEQcAAENE0RQ3NAiAEBEAQsD4gBEHAABCtNiIJRQ3EAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NywIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ7RxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3SAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ3BAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgzBAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2/AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHI8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUNqgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBC/HRCwPkE4QQQQrTYiAkUNqQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDKICCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQtxcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcoCC0HAACEKIANBwAAQ0TRFDc4CIAMEQBCwPiADQcAAEK02IgpFDdACCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NywIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDWGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcN1AIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDcACIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgzAAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2+AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkG09P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACELETELA+QThBBBCtNiICRQ2pAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQciIgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1h0QsD5BOEEEEK02IgJFDagCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyhAgsgACEBIwBB4AFrIgckACAFIAYQmSIiAxDTOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDPFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENM6GiADENM6IQkgAxDTOhogByADENM6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNsgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwzMAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQjywgB0EYaiAHKAIgIAcoAiQQuh0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNvwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDcECIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQeDz/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELgTELA+QThBBBCtNiIARQ2sAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMyQILDL0CCwzIAgsMyAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDBHRCwPkE4QQQQrTYiAEUNpwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDKACCyMAQeABayIDJAAgBSAGEJkiIgEQ0zohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQsxcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEJIAEQ0zoaIAMgARDTOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ3DAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw3LAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRCPLCADQRhqIAMoAiAgAygCJBDsHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNvgIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMvwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ3AAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGw8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMywILDKkCCwzKAgsMxwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDNHRCwPkE4QQQQrTYiAUUNpgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDJ8CCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQ2hcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3HAgtBwAAhCSAEQcAAENE0RQ3JAiAEBEAQsD4gBEHAABCtNiIJRQ3AAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NxwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ6xxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3OAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ29AiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgy9AgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ27AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkG48v8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhC5ExCwPkE4QQQQrTYiAkUNpgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDHHRCwPkE4QQQQrTYiAkUNpQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDJ4CCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQ0xcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcYCC0HAACEKIANBwAAQ0TRFDcoCIAMEQBCwPiADQcAAEK02IgpFDcwCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NxwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDVGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcN0AIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDbwCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgy8AgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ26AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGc9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEK4TELA+QThBBBCtNiICRQ2lAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQ5xggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ2R0QsD5BOEEEEK02IgJFDaQCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBsIKAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwydAgsjAEHQAWsiAyQAIAUgBhCZIiIBENM6IQUgA0EgaiIHIAEQ+TQgAyAFNgI8IANBADYCOCADIAE2AhwCQAJAAkAgBC0ANEUEQCADQfQAaiADQRxqEKQXIANByABqIgIgA0GAAWooAgA2AgAgAyADKQJ4NwNAIAMoAnQiBEGTgICAeEYNASADKAKEASEBIAAgAykDQDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABENM6GiABENM6IQkgARDTOhogAyABENM6IgI2ArgBIANBQGtBfyACQQdqIgQgAiAESxtBA3YQ0h8gAkECdCIGIQQCQCAGQTxxIgIEQCAGIAJrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNwAILIAMoAkghCiADQYABaiAHQQhqKQIANwIAIANBiAFqIAdBEGopAgA3AgAgAyABNgJ0IANBADYCmAEgAyAFNgKUASADQQA2ApABIAMgBykCADcCeCACIQEgBQRAQQAhBQNAAkACQAJAIAMoAnhFBEAgAygCmAEhBwwBCyADKAKIASAFSwRAIAMoApgBIQcgAygCfCADKAKEASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQEgAyAHQQFqNgKYASADIAVBAWo2ApABDAILDMgCCyADIAVBAWo2ApABIANBEGogAygCdCAFEI8sIANBxAFqIAMoAhAgAygCFBDBASADIAdBAWo2ApgBIAMoAsQBQTFHDQAgASADKgLIATgCACAKIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQQA2AgALIAFBBGohASADKAKQASIFIAMoApQBRw0ACwsCQCADKAJ4IgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANB+ABqEPseCyADIAEgAmtBAnUiATYCxAECQCADKAK4ASABRgRAIAMoAkghASADKAJMIQcgAyADKQJANwKAASADQQA2AnwgAyAHNgJ4IAMgATYCdCADQQhqIANB9ABqIgUQ1zsgAygCCCEKELA+QRxBBBCtNiIBRQ27AiABQoGAgIAQNwIAIAEgAykCdDcCCCABQRBqIANB/ABqIgspAgA3AgAgAUEYaiADQYQBaiIMKAIANgIAIAMgBDYChAEgA0KAgICAgAg3AnwgAyAGNgJ4IAMgAjYCdCADIAUQ1zsgAygCACEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ0NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLAASADIAo2ArwBIAMgATYCuAEQsD5BDEEEEK02IgFFDb0CIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYCzAEgAyABNgLIASADQQE2AsQBIANBADYCSCADQoCAgIDAADcCQCAFQYzz/wAgCSADIANBuAFqIANBxAFqIANBQGsiAhCMEyACIAUQsxMQsD5BOEEEEK02IgFFDagCIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCwzPAgsMuQILDM4CCwzEAgsgA0HAAWogAigCADYCACADIAMpA0A3A7gBIANBxAFqIgIgA0G4AWoQ6BggA0H0AGoiBCABEJM2EO4lIANBQGsiBSACIAQQvh0QsD5BOEEEEK02IgFFDaMCIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HQAWokAAwACwycAgsjAEHgAWsiAyQAIAUgBhCZIiIBENM6IQcgA0EoaiIJIAEQ+TQgAyAHNgJEIANBADYCQCADIAE2AiQCQAJAAkAgBC0ANEUEQCADQfwAaiADQSRqENkXIANB0ABqIgIgA0GIAWooAgA2AgAgAyADKQKAATcDSCADKAJ8IgRBk4CAgHhGDQEgAygCjAEhASAAIAMpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEKIAEQ0zoaIAMgARDTOiICNgLAASADQdABakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQN0IgYhBAJAIAZBOHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2/AgsgAygC2AEhCyADQYgBaiAJQQhqKQIANwIAIANBkAFqIAlBEGopAgA3AgAgAyABNgJ8QQAhBSADQQA2AqABIAMgBzYCnAEgA0EANgKYASADIAkpAgA3AoABIAIhASAHBEADQAJAAkACQCADKAKAAUUEQCADKAKgASEHDAELIAMoApABIAVLBEAgAygCoAEhByADKAKEASADKAKMASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgKgASADIAVBAWo2ApgBDAILDMcCCyADIAVBAWo2ApgBIANBGGogAygCfCAFEI8sIANByABqIAMoAhggAygCHBDRASADIAdBAWo2AqABIAMoAkhBAXFFDQAgASADKwNQOQMAIAsgB0EDdmoiBSAFLQAAQQEgB0EHcXRyOgAADAELIAFCADcDAAsgAUEIaiEBIAMoApgBIgUgAygCnAFHDQALCwJAIAMoAoABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBgAFqEPseCyADIAEgAmtBA3UiATYCSAJAIAMoAsABIAFGBEAgAygC2AEhASADKALcASEHIAMgAykC0AE3AogBIANBADYChAEgAyAHNgKAASADIAE2AnwgA0EQaiADQfwAaiIFENc7IAMoAhAhCRCwPkEcQQQQrTYiAUUNugIgAUKBgICAEDcCACABIAMpAnw3AgggAUEQaiADQYQBaiILKQIANwIAIAFBGGogA0GMAWoiDCgCADYCACADIAQ2AowBIANCgICAgIAINwKEASADIAY2AoABIAMgAjYCfCADQQhqIAUQ1zsgAygCCCEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ8NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLIASADIAk2AsQBIAMgATYCwAEQsD5BDEEEEK02IgFFDbwCIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC2AEgAyABNgLUASADQQE2AtABIANBADYCUCADQoCAgIDAADcCSCAFQdTz/wAgCiADIANBwAFqIANB0AFqIANByABqIgIQjBMgAiAFEMcTELA+QThBBBCtNiIBRQ2nAiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsM0AILDLgCCwzPAgsMwwILIANByAFqIAIoAgA2AgAgAyADKQNINwPAASADQdABaiICIANBwAFqEOcYIANB/ABqIgQgARCTNhDuJSADQcgAaiIFIAIgBBDbHRCwPkE4QQQQrTYiAUUNogIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHYgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDJsCCyADLQABQQFrDgMLDA0KCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQtRcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3CAgtBwAAhCSAEQcAAENE0RQ3EAiAEBEAQsD4gBEHAABCtNiIJRQ27AgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NwgIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ2CZBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3JAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ24AiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgy4AgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ22AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHs8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhDEExCwPkE4QQQQrTYiAkUNoQIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDSHRCwPkE4QQQQrTYiAkUNoAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDJkCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQtBcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcECC0HAACEKIANBwAAQ0TRFDcUCIAMEQBCwPiADQcAAEK02IgpFDccCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NwgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBC/EiABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNywIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDbcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgy3AgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ21AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkHo8v8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEMATELA+QThBBBCtNiICRQ2gAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQxB0QsD5BOEEEEK02IgJFDZ8CIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBkIWAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyYAgsgAy0AAQ4CCwyRAgsgAy0AAUECaw4CDA2QAgsgAy0AAUEBaw4CDg8NCyAIQdAAaiIBIAUgBhCZIhCzFCAIQZACaiICIAEQ/SQgAhDsKSEBIABBoOH/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyUAgsgCEHQAGoiAiAFIAYQmSIQsxQgCEGQAmoiASACEP0kIAAgAUGg4f8AEK4GIAEQwx4MkwILIAhB0ABqIgEgBSAGEJkiEJwKIAhBkAJqIgIgARCtHyACEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADJICCyAAIAUgBhCvBgyRAgsgCEHQAGoiASAFIAYQmSIQnAogARDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyQAgsjAEHgAmsiASQAIAUgBhCZIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQxBcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvwILQcAAIQkgBEHAABDRNEUNygIgBARAELA+IARBwAAQrTYiCUUNuAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDcECIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3PAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNtQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgy1AgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNswIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBgPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC/EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQrBcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvQILQcAAIQkgBEHAABDRNEUNyAIgBARAELA+IARBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3NAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNswIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyzAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNsQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2wAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQYDz/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQvxMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ2XAiACIAU2AhAgAiAKNgIMIAJBDTsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABBoImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsMjwILIwBB4AJrIgEkACAFIAYQmSIhAgJAAkACQAJAAkACQCAHKAIAIgoEQCABQZwCaiAKQQhqIAcoAgQQihggASgCoAIhAyABKAKcAiIFQZOAgIB4Rg0BIAAgASkCpAI3AgggAEEQaiABQawCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgAUEBNgLAAiABQfwBaiACENAXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ0zoaIAIQ0zohDCACENM6GiABIAIQ0zoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDb4CC0HAACEJIARBwAAQ0TRFDckCIAQEQBCwPiAEQcAAEK02IglFDbcCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCIAFCATcCwAIgASAGNgK8AkEAIQUgAUEANgK4AiABIAMpAgA3AqACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw3AAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQRhqIAEoApwCIAIQjywgAUH8AWoiAiABKALAAiABKAIYIAEoAhwQggMgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNzgIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBEGogAUGcAmoiAxDXOyABKAIQIQYQsD5BHEEEEK02IgJFDbQCIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQQhqIAMQ1zsgASgCCCEEELA+QRxBBBCtNiIDDQIMtAILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDbICIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNBCACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQcTy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQxhMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAQsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLDAILIAEgAzYCVCACENM6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABIAFB1ABqNgLAAiABQfwBaiACELwXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ0zoaIAIQ0zohDCACENM6GiABIAIQ0zoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDbwCC0HAACEJIARBwAAQ0TRFDccCIAQEQBCwPiAEQcAAEK02IglFDbUCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCQQAhBSABQQA2AsQCIAEgBjYCvAIgAUEANgK4AiABIAMpAgA3AqACIAEgAUHUAGo2AsACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2+AiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQTBqIAEoApwCIAIQjywgAUH8AWoiAiABKALAAiABKAIwIAEoAjQQ+QIgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNzAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBKGogAUGcAmoiAxDXOyABKAIoIQYQsD5BHEEEEK02IgJFDbICIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQSBqIAMQ1zsgASgCICEEELA+QRxBBBCtNiIDDQIMsgILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDbACIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNrwIgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEHE8v8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEEMYTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQILIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHnAGoiBSABQYABaikAADcAACABQeAAaiIDIAFB+QBqKQAANwMAIAFBQGsiBCABQZABaikCADcDACABQcgAaiIGIAFBmAFqKQIANwMAIAFBqAFqIgkgAykDADcDACABQa8BaiIDIAUpAAA3AAAgASABKQKIATcDOCABIAEpAHE3A6ABIAFBpQJqIAkpAwA3AAAgAUGsAmogAykAADcAACABQbwCaiAEKQMANwIAIAFBxAJqIAYpAwA3AgAgASACOgCcAiABIAEpA6ABNwCdAiABIAEpAzg3ArQCIAoEQCAKIAooAgAiAkEBajYCACACQQBIDQIgBygCBCEFCyABQZwCahClDBCwPkE4QQQQrTYiAkUNlgIgAiAFNgIQIAIgCjYCDCACQY0COwEIIAJCgYCAgBA3AgAgAiABKQCrATcAFCACIAEpAzg3AiAgAEHQioABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBHGogAUGzAWooAAA2AAAgAkEoaiABQUBrKQMANwIAIAJBMGogAUHIAGopAwA3AgALIAFB4AJqJAAMAQsACwyOAgsjAEHgAmsiASQAIAUgBhCZIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQwxcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvQILQcAAIQkgBEHAABDRNEUNyAIgBARAELA+IARBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3NAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNswIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyzAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNsQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARB3PL/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBCoEyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQoxcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNuwILQcAAIQkgBEHAABDRNEUNxgIgBARAELA+IARBwAAQrTYiCUUNtAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb0CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3LAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNsQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyxAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNrwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2uAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQdzy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQqBMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ2VAiACIAU2AhAgAiAKNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAKsBNwAUIAIgASkDODcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQbMBaigAADYAACACQShqIAFBQGspAwA3AgAgAkEwaiABQcgAaikDADcCAAsgAUHgAmokAAwBCwALDI0CCyMAQeACayIBJAAgBSAGEJkiIQICQAJAAkACQAJAAkAgBygCACIKBEAgAUGcAmogCkEIaiAHKAIEEIoYIAEoAqACIQMgASgCnAIiBUGTgICAeEYNASAAIAEpAqQCNwIIIABBEGogAUGsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyACENM6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAFBATYCwAIgAUH8AWogAhDUFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENM6GiACENM6IQwgAhDTOhogASACENM6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ28AgtBwAAhCSAEQcAAENE0RQ3HAiAEBEAQsD4gBEHAABCtNiIJRQ21AgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAiABQgE3AsACIAEgBjYCvAJBACEFIAFBADYCuAIgASADKQIANwKgAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NvgIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEYaiABKAKcAiACEI8sIAFB/AFqIgIgASgCwAIgASgCGCABKAIcEIIDIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDcwCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQRBqIAFBnAJqIgMQ1zsgASgCECEGELA+QRxBBBCtNiICRQ2yAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEIaiADENc7IAEoAgghBBCwPkEcQQQQrTYiAw0CDLICCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2wAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDQQgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEG88/8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEELQTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQELIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AlQgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgASABQdQAajYCwAIgAUH8AWogAhClFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENM6GiACENM6IQwgAhDTOhogASACENM6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ26AgtBwAAhCSAEQcAAENE0RQ3FAiAEBEAQsD4gBEHAABCtNiIJRQ2zAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAkEAIQUgAUEANgLEAiABIAY2ArwCIAFBADYCuAIgASADKQIANwKgAiABIAFB1ABqNgLAAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NvAIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEwaiABKAKcAiACEI8sIAFB/AFqIgIgASgCwAIgASgCMCABKAI0EPkCIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDcoCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQShqIAFBnAJqIgMQ1zsgASgCKCEGELA+QRxBBBCtNiICRQ2wAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEgaiADENc7IAEoAiAhBBCwPkEcQQQQrTYiAw0CDLACCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2uAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDa0CIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBvPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC0EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0CCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB5wBqIgUgAUGAAWopAAA3AAAgAUHgAGoiAyABQfkAaikAADcDACABQUBrIgQgAUGQAWopAgA3AwAgAUHIAGoiBiABQZgBaikCADcDACABQagBaiIJIAMpAwA3AwAgAUGvAWoiAyAFKQAANwAAIAEgASkCiAE3AzggASABKQBxNwOgASABQaUCaiAJKQMANwAAIAFBrAJqIAMpAAA3AAAgAUG8AmogBCkDADcCACABQcQCaiAGKQMANwIAIAEgAjoAnAIgASABKQOgATcAnQIgASABKQM4NwK0AiAKBEAgCiAKKAIAIgJBAWo2AgAgAkEASA0CIAcoAgQhBQsgAUGcAmoQpQwQsD5BOEEEEK02IgJFDZQCIAIgBTYCECACIAo2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABB+ImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsMjAILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahDqFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDbQCC0HAACEJIARBwAAQ0TRFDbYCIAQEQBCwPiAEQcAAEK02IglFDa0CCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw20AiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhCPLCABQRBqIAEoAhggASgCHBCQHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDbsCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDaoCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDKoCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDagCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQazy/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELsTELA+QThBBBCtNiICRQ2TAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEEMwdELA+QThBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsMiwILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCpFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDbMCC0HAACEJIARBwAAQ0TRFDbUCIAQEQBCwPiAEQcAAEK02IglFDawCCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2zAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhCPLCABQRBqIAEoAhggASgCHBCPHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDboCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDakCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDKkCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDacCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQaTz/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELITELA+QThBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEENcdELA+QThBBBCtNiICRQ2RAiACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsMigILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEFIAFBIGoiCSACEPk0IAEgBTYCPCABQQA2AjggASACNgIcAkACQAJAIAQtADRFBEAgAUH0AGogAUEcahDYFyABQcgAaiIDIAFBgAFqKAIANgIAIAEgASkCeDcDQCABKAJ0IgRBk4CAgHhGDQEgASgChAEhAiAAIAEpA0A3AgQgACACNgIQIAAgBDYCACAAQQxqIAMoAgA2AgAMAgsgAhDTOhogAhDTOiELIAIQ0zoaIAEgAhDTOiIDNgLEASABQcgBakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNsgILQcAAIQogA0HAABDRNEUNtgIgAwRAELA+IANBwAAQrTYiCkUNuAILIAEoAtABIQwgAUGAAWogCUEIaikCADcCACABQYgBaiAJQRBqKQIANwIAIAEgAjYCdEEAIQcgAUEANgKYASABIAU2ApQBIAFBADYCkAEgASAJKQIANwJ4IAFB+ABqIQlBACECA0AgAUG4AWohDUICIRsgAiAFRwR/IAECfgJAIAEoAngEQCACIAEoAogBTw2zAiABKAJ8IAEoAoQBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApABIAFBEGogASgCdCACEI8sIAFBQGsgASgCECABKAIUEI4cIAEpA0ghGyABKQNADAELIAEgAkEBajYCkAFCAAs3A7gBIAEgASgCmAEiBkEBajYCmAEgAUHYAWoFIA0LIBs3AwACQAJAAkAgASkDuAEiG0ICUgRAIAcgCmohAiAbp0EBcUUNASACIAEpA9gBNwMAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCeCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYCQCACIAEoAsQBRw28AiABKALQASECIAEoAtQBIQUgASABKQLIATcCgAEgAUEANgJ8IAEgBTYCeCABIAI2AnQgAUEIaiABQfQAaiIGENc7IAEoAgghBxCwPkEcQQQQrTYiAkUNqAIgAkKBgICAEDcCACACIAEpAnQ3AgggAkEQaiABQfwAaiIJKQIANwIAIAJBGGogAUGEAWoiDCgCADYCACABIAM2AoQBIAFCgICAgIAINwJ8IAEgBDYCeCABIAo2AnQgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAw0CDKgCCyACQgA3AwALIAdBCGohByABKAKUASEFIAEoApABIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ0NwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLAASABIAc2ArwBIAEgAjYCuAEQsD5BDEEEEK02IgJFDaYCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC0AEgASACNgLMASABQQE2AsgBIAFBADYCSCABQoCAgIDAADcCQCABQfQAaiICQZD0/wAgCyABIAFBuAFqIAFByAFqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDZECIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQcABaiADKAIANgIAIAEgASkDQDcDuAEgAUHIAWoiAyABQbgBahC9GCABQfQAaiIEIAIQkzYQ7iUgAUFAayIFIAMgBBDCHRCwPkE4QQQQrTYiAkUNkAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDIkCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQxxcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDbECC0HAACEKIANBwAAQ0TRFDbUCIAMEQBCwPiADQcAAEK02IgpFDbcCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NsgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDqHCABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNuwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDacCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgynAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2lAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGo9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEKkTELA+QThBBBCtNiICRQ2QAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQYiDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1R0QsD5BOEEEEK02IgJFDY8CIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyIAgtBACEHIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNuwIgASkDgAFCx9n0597Etpx3hSABKQOIAUKNss6UjMqS5qd/hYRQRQ27AiACENM6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADELgXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDTOhogAhDTOiELIAIQ0zoaIAEgAhDTOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQJ0IgQhAyAEQTxxIgkEQCAEIAlrQUBrIgMgBEkNsQILQcAAIQkgA0HAABDRNEUNvwIgAwRAELA+IANBwAAQrTYiCUUNtwILIAEoAuABIQwgAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiENQQAhBkEAIQIDQCABQcgBaiEOQQIhCiACIAVHBH8CQAJAIAEoAoQBRQ0AIAIgASgClAFPDbECIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ApwBQQAhAgwBCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhCPLCABQdAAaiABKAIYIAEoAhwQsQwgASgCUEGTgICAeEYiAgRAIAEoAlQhCgwBCyABQdAAahCIEQsgASACNgLIASABIAEoAqgBIgdBAWo2AqgBIAFB7AFqBSAOCyAKNgIAAkACQAJAIAEoAsgBIgVBAkcEQCAGIAlqIQIgBUEBcUUNASACIAEoAuwBNgIAIAwgB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AlAgAiABKALUAUcNxAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDacCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiIMKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMpwILIAJBADYCAAsgBkEEaiEGIAEoAqABIQUgASgCnAEhAgwBCwsgA0KBgICAEDcCACADIAEpAoABNwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAFNgLQASABIAc2AswBIAEgAjYCyAEQsD5BDEEEEK02IgJFDaUCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC4AEgASACNgLcASABQQE2AtgBIAFBADYCWCABQoCAgIDAADcCUCABQYABaiICQfjz/wAgCyABIAFByAFqIAFB2AFqIAFB0ABqIgMQjBMgAyACEK8TDAELIAFBiAFqIAIoAgA2AgAgASABKQPYATcDgAEgAUHQAGogAUGAAWoQ4QgLELA+QThBBBCtNiICRQ2OAiACQoGAgIAQNwIAIAJBCGogAUHQAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQfABaiQADAALDIcCC0EAIQdBACEKIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNugIgASkDgAFCx9n0597Etpx3hSABKQOIAUKNss6UjMqS5qd/hYRQRQ26AiACENM6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADENcXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQN0IgQhAyAEQThxIgkEQCAEIAlrQUBrIgMgBEkNsAILQcAAIQkgA0HAABDRNEUNvgIgAwRAELA+IANBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiEOQQAhBkEAIQIDQCABQcgBaiEPQQIhCyACIAVHBH8gAQJ/AkACQCABKAKEAQRAIAIgASgClAFPDbICIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhCPLCABQdAAaiABKAIYIAEoAhwQ4AcgASgCUEGTgICAeEYEQCABKAJYIQsgASgCVCEKQQEMAwsgAUHQAGoQiBEMAQsgASACQQFqNgKcAQtBAAs2AsgBIAEgASgCqAEiB0EBajYCqAEgAUHsAWoFIA8LIAs2AgACQAJAAkAgASgCyAEiBUECRwRAIAYgCWohAiAFQQFxRQ0BIAIgCjYCACACQQRqIAEoAuwBNgIAIA0gB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAGQQN1IgI2AlAgAiABKALUAUcNwwIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDaYCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiILKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMpgILIAJBADYCACACQQRqQQA2AgALIAZBCGohBiABKAKgASEFIAEoApwBIQIMAQsLIANCgYCAgBA3AgAgAyABKQKAATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC0AEgASAHNgLMASABIAI2AsgBELA+QQxBBBCtNiICRQ2kAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AuABIAEgAjYC3AEgAUEBNgLYASABQQA2AlggAUKAgICAwAA3AlAgAUGAAWoiAkGE9P8AIAwgASABQcgBaiABQdgBaiABQdAAaiIDEIwTIAMgAhCsEwwBCyABQYgBaiACKAIANgIAIAEgASkD2AE3A4ABIAFB0ABqIAFBgAFqENkICxCwPkE4QQQQrTYiAkUNjQIgAkKBgICAEDcCACACQQhqIAFB0ABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHwAWokAAwACwyGAgsgACECIwBBgAJrIgMkACADQSBqIAUgBigCEBEAACADQYABaiIBIAMoAiAiBSADKAIkKAIMEQAAAkACQAJAAkACQCAFRQ29AiADKQOAAULH2fTn3sS2nHeFIAMpA4gBQo2yzpSMypLmp3+FhFBFDb0CIAUQ0zohByADQTBqIgkgBRD5NCADIAc2AkwgA0EANgJIIAMgBTYCLCAELQA0RQRAIAEgA0EsakEk/AoAACADIAE2AqQBIANB0ABqIAEQ4RcgA0H4AWoiASADQdwAaigCADYCACADIAMpAlQ3A/ABIAMoAlAiBEGTgICAeEYNASADKAJgIQIgACADKQPwATcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwECyAFENM6GiAFENM6IQogBRDTOhogAyAFENM6IgA2AswBIANB0AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDasCCyADKALYASELIANBjAFqIAlBCGopAgA3AgAgA0GUAWogCUEQaikCADcCACADIAU2AoABQQAhBSADQQA2AqgBIAMgBzYCoAEgA0EANgKcASADIAkpAgA3AoQBIAMgA0GAAWo2AqQBIAEhACAHRQ0DIANB0ABqQQRyIQkgA0HYAGohBwNAAkACQAJAAkAgAygChAEEQCAFIAMoApQBTw20AiADKAKIASADKAKQASAFaiIMQQN2ai0AAEH/AXMgDEEHcXZBAXENAQsgAyAFQQFqNgKcASADQRhqIAMoAoABIAUQjywgA0HQAGogAygCGCADKAIcEOkcAkAgAygCUCIFRQRAIANB+AFqIAdBCGopAwA3AwAgAyAHKQMANwPwAQwBCyAFDQILIANB6AFqIANB+AFqKQMAIhs3AwAgAyADKQPwASIcNwPgASADIAMoAqgBIgVBAWo2AqgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiIMIAwtAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgKcAQwBCyAJEIgRCyADQegBaiADQfgBaikDADcDACADIAMpA/ABNwPgASADIAMoAqgBQQFqNgKoASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCnAEiBSADKAKgAUcNAAsMAwsMwQILDK8CCyADQYgBaiABKAIANgIAIAMgAykD8AE3A4ABIANB0ABqIANBgAFqEM4IDAELAkAgAygChAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GEAWoQ+x4LIAMgACABa0EEdSIANgJQIAAgAygCzAFHDb8CIAMoAtgBIQAgAygC3AEhBSADIAMpAtABNwKMASADQQA2AogBIAMgBTYChAEgAyAANgKAASADQRBqIANBgAFqIgcQ1zsgAygCECEJELA+QRxBBBCtNiIARQ2gAiAAQoGAgIAQNwIAIAAgAykCgAE3AgggAEEQaiADQYgBaiILKQIANwIAIABBGGogA0GQAWoiDCgCADYCACADIAQ2ApABIANCgICAgIAINwKIASADIAY2AoQBIAMgATYCgAEgA0EIaiAHENc7IAMoAgghBBCwPkEcQQQQrTYiAUUEQAyhAgsgAUKBgICAEDcCACABIAMpAoABNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgADYC4AEQsD5BDEEEEK02IgBFDaICIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYC+AEgAyAANgL0ASADQQE2AvABIANBADYCWCADQoCAgIDAADcCUCADQYABaiIAQdDy/wAgCiADIANB4AFqIANB8AFqIANB0ABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUNjAIgAEKBgICAEDcCACAAQQhqIANB0ABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GAAmokAAwACwyFAgsgACEBIwBB4AFrIgckACAFIAYQmCIiAxDUOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDBFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENQ6GiADENQ6IQkgAxDUOhogByADENQ6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNlgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwywAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQ2isgB0EYaiAHKAIgIAcoAiQQux0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNowIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDaUCIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQfTy/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELYTELA+QThBBBCtNiIARQ2QAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZiHgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMrQILDKECCwysAgsMrAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDYHRCwPkE4QQQQrTYiAEUNiwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDIQCCyMAQeABayIDJAAgBSAGEJgiIgEQ1DohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQqBcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEJIAEQ1DoaIAMgARDUOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2nAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw2vAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRDaKyADQRhqIAMoAiAgAygCJBDuHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNogIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMowILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ2kAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGY8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARC9ExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQYCBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMrwILDI0CCwyuAgsMqwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDaHRCwPkE4QQQQrTYiAUUNigIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDIMCCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQzhcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2rAgtBwAAhCSAEQcAAENE0RQ2tAiAEBEAQsD4gBEHAABCtNiIJRQ2kAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NqwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ7RxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2yAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2hAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgyhAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2fAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHI8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUNigIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBC/HRCwPkE4QQQQrTYiAkUNiQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDIICCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQohcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaoCC0HAACEKIANBwAAQ0TRFDa4CIAMEQBCwPiADQcAAEK02IgpFDbACCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NqwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDWGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNtAIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDaACIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgygAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2eAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkG09P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACELETELA+QThBBBCtNiICRQ2JAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQciIgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1h0QsD5BOEEEEK02IgJFDYgCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyBAgsgACEBIwBB4AFrIgckACAFIAYQmCIiAxDUOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDsFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENQ6GiADENQ6IQkgAxDUOhogByADENQ6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNkgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwysAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQ2isgB0EYaiAHKAIgIAcoAiQQuh0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNnwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDaECIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQeDz/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELgTELA+QThBBBCtNiIARQ2MAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMqQILDJ0CCwyoAgsMqAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDBHRCwPkE4QQQQrTYiAEUNhwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDIACCyMAQeABayIDJAAgBSAGEJgiIgEQ1DohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQ0hcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEJIAEQ1DoaIAMgARDUOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2jAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw2rAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRDaKyADQRhqIAMoAiAgAygCJBDsHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNngIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMnwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ2gAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGw8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMqwILDIkCCwyqAgsMpwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDNHRCwPkE4QQQQrTYiAUUNhgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDP8BCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQoRcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2nAgtBwAAhCSAEQcAAENE0RQ2pAiAEBEAQsD4gBEHAABCtNiIJRQ2gAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NpwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ6xxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2uAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2dAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgydAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2bAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkG48v8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhC5ExCwPkE4QQQQrTYiAkUNhgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDHHRCwPkE4QQQQrTYiAkUNhQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDP4BCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQthcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaYCC0HAACEKIANBwAAQ0TRFDaoCIAMEQBCwPiADQcAAEK02IgpFDawCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NpwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDVGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNsAIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDZwCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgycAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2aAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGc9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEK4TELA+QThBBBCtNiICRQ2FAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQ5xggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ2R0QsD5BOEEEEK02IgJFDYQCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBsIKAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwz9AQsjAEHQAWsiAyQAIAUgBhCYIiIBENQ6IQUgA0EgaiIHIAEQ+TQgAyAFNgI8IANBADYCOCADIAE2AhwCQAJAAkAgBC0ANEUEQCADQfQAaiADQRxqENwXIANByABqIgIgA0GAAWooAgA2AgAgAyADKQJ4NwNAIAMoAnQiBEGTgICAeEYNASADKAKEASEBIAAgAykDQDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABENQ6GiABENQ6IQkgARDUOhogAyABENQ6IgI2ArgBIANBQGtBfyACQQdqIgQgAiAESxtBA3YQ0h8gAkECdCIGIQQCQCAGQTxxIgIEQCAGIAJrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNoAILIAMoAkghCiADQYABaiAHQQhqKQIANwIAIANBiAFqIAdBEGopAgA3AgAgAyABNgJ0IANBADYCmAEgAyAFNgKUASADQQA2ApABIAMgBykCADcCeCACIQEgBQRAQQAhBQNAAkACQAJAIAMoAnhFBEAgAygCmAEhBwwBCyADKAKIASAFSwRAIAMoApgBIQcgAygCfCADKAKEASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQEgAyAHQQFqNgKYASADIAVBAWo2ApABDAILDKgCCyADIAVBAWo2ApABIANBEGogAygCdCAFENorIANBxAFqIAMoAhAgAygCFBDBASADIAdBAWo2ApgBIAMoAsQBQTFHDQAgASADKgLIATgCACAKIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQQA2AgALIAFBBGohASADKAKQASIFIAMoApQBRw0ACwsCQCADKAJ4IgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANB+ABqEPseCyADIAEgAmtBAnUiATYCxAECQCADKAK4ASABRgRAIAMoAkghASADKAJMIQcgAyADKQJANwKAASADQQA2AnwgAyAHNgJ4IAMgATYCdCADQQhqIANB9ABqIgUQ1zsgAygCCCEKELA+QRxBBBCtNiIBRQ2bAiABQoGAgIAQNwIAIAEgAykCdDcCCCABQRBqIANB/ABqIgspAgA3AgAgAUEYaiADQYQBaiIMKAIANgIAIAMgBDYChAEgA0KAgICAgAg3AnwgAyAGNgJ4IAMgAjYCdCADIAUQ1zsgAygCACEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ0NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLAASADIAo2ArwBIAMgATYCuAEQsD5BDEEEEK02IgFFDZ0CIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYCzAEgAyABNgLIASADQQE2AsQBIANBADYCSCADQoCAgIDAADcCQCAFQYzz/wAgCSADIANBuAFqIANBxAFqIANBQGsiAhCMEyACIAUQsxMQsD5BOEEEEK02IgFFDYgCIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCwyvAgsMmQILDK4CCwykAgsgA0HAAWogAigCADYCACADIAMpA0A3A7gBIANBxAFqIgIgA0G4AWoQ6BggA0H0AGoiBCABEJM2EO4lIANBQGsiBSACIAQQvh0QsD5BOEEEEK02IgFFDYMCIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HQAWokAAwACwz8AQsjAEHgAWsiAyQAIAUgBhCYIiIBENQ6IQcgA0EoaiIJIAEQ+TQgAyAHNgJEIANBADYCQCADIAE2AiQCQAJAAkAgBC0ANEUEQCADQfwAaiADQSRqEOMXIANB0ABqIgIgA0GIAWooAgA2AgAgAyADKQKAATcDSCADKAJ8IgRBk4CAgHhGDQEgAygCjAEhASAAIAMpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEKIAEQ1DoaIAMgARDUOiICNgLAASADQdABakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQN0IgYhBAJAIAZBOHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2fAgsgAygC2AEhCyADQYgBaiAJQQhqKQIANwIAIANBkAFqIAlBEGopAgA3AgAgAyABNgJ8QQAhBSADQQA2AqABIAMgBzYCnAEgA0EANgKYASADIAkpAgA3AoABIAIhASAHBEADQAJAAkACQCADKAKAAUUEQCADKAKgASEHDAELIAMoApABIAVLBEAgAygCoAEhByADKAKEASADKAKMASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgKgASADIAVBAWo2ApgBDAILDKcCCyADIAVBAWo2ApgBIANBGGogAygCfCAFENorIANByABqIAMoAhggAygCHBDRASADIAdBAWo2AqABIAMoAkhBAXFFDQAgASADKwNQOQMAIAsgB0EDdmoiBSAFLQAAQQEgB0EHcXRyOgAADAELIAFCADcDAAsgAUEIaiEBIAMoApgBIgUgAygCnAFHDQALCwJAIAMoAoABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBgAFqEPseCyADIAEgAmtBA3UiATYCSAJAIAMoAsABIAFGBEAgAygC2AEhASADKALcASEHIAMgAykC0AE3AogBIANBADYChAEgAyAHNgKAASADIAE2AnwgA0EQaiADQfwAaiIFENc7IAMoAhAhCRCwPkEcQQQQrTYiAUUNmgIgAUKBgICAEDcCACABIAMpAnw3AgggAUEQaiADQYQBaiILKQIANwIAIAFBGGogA0GMAWoiDCgCADYCACADIAQ2AowBIANCgICAgIAINwKEASADIAY2AoABIAMgAjYCfCADQQhqIAUQ1zsgAygCCCEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ8NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLIASADIAk2AsQBIAMgATYCwAEQsD5BDEEEEK02IgFFDZwCIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC2AEgAyABNgLUASADQQE2AtABIANBADYCUCADQoCAgIDAADcCSCAFQdTz/wAgCiADIANBwAFqIANB0AFqIANByABqIgIQjBMgAiAFEMcTELA+QThBBBCtNiIBRQ2HAiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMsAILDJgCCwyvAgsMowILIANByAFqIAIoAgA2AgAgAyADKQNINwPAASADQdABaiICIANBwAFqEOcYIANB/ABqIgQgARCTNhDuJSADQcgAaiIFIAIgBBDbHRCwPkE4QQQQrTYiAUUNggIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHYgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDPsBCyADLQABQQFrDgMLDA0KCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQ4hcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2iAgtBwAAhCSAEQcAAENE0RQ2kAiAEBEAQsD4gBEHAABCtNiIJRQ2bAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NogIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ2CZBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2pAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2YAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgyYAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2WAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHs8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhDEExCwPkE4QQQQrTYiAkUNgQIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDSHRCwPkE4QQQQrTYiAkUNgAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDPkBCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQzBcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaECC0HAACEKIANBwAAQ0TRFDaUCIAMEQBCwPiADQcAAEK02IgpFDacCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NogIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBC/EiABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNqwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDZcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgyXAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2VAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkHo8v8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEMATELA+QThBBBCtNiICRQ2AAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQxB0QsD5BOEEEEK02IgJFDf8BIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBkIWAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwz4AQsgAy0AAQ4CCwzwAQsgAy0AAUECaw4CDA3vAQsgAy0AAUEBaw4CDg8NCyAIQdAAaiICIAUgBhCYIhC1FCAIQZACaiIBIAIQ/CQgACABQfjh/wAQpQQgARDDHgz0AQsgCEHQAGoiASAFIAYQmCIQtRQgCEGQAmoiAiABEPwkIAIQ7CkhASAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAM8wELIAUgBhCYIiICENQ6IQMgCEHQAGoiAUEEaiACEPk0IAEgAzYCICABQQA2AhwgASACNgIAIAhBkAJqIQJBACEGIwBBQGoiAyQAAkACQAJAAkAgASgCHCIEIAEoAiBHBEACfwJAIAEoAgQEQCAEIAEoAhRPDQUgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIARBAWoiBzYCHCADQQhqIAEoAgAiBSAEENorIAMoAgwhBiADKAIIDAELIAEgBEEBaiIHNgIcIAEoAgAhBUEACyEJIAUQ1DohCiAFENQ6GiADQRxqIgRBBCAKIAdrQQFqIgVBfyAFGyIFIAVBBE0bQQBBBEEIEKAYIAMoAiAhBSADKAIcQQFGDQMgAygCJCIHIAY2AgQgByAJNgIAIANBGGoiBkEBNgIAIAMgBzYCFCADIAU2AhAgBCABQST8CgAAIANBEGogBBCXECACQQhqIAYoAgA2AgAgAiADKQIQNwIADAELIAJBADYCCCACQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIANBQGskAAwCC0G8tIABQSBB3LSAARCfKQALIAUgAygCJEG0yP8AEP0vAAsjAEEQayIDJAAgAyACKAIANgIIIAMgAigCBCIENgIAIAMgBDYCBCADIAQgAigCCEEDdGo2AgwgASADENIOIANBEGokACABEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADPIBCyAAIAUgBhCmBAzxAQsgCEHQAGoiASAFIAYQmCIQjgogARDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAzwAQsjAEHgAmsiASQAIAUgBhCYIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQvRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnwILQcAAIQkgBEHAABDRNEUNqgIgBARAELA+IARBwAAQrTYiCUUNmAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDaECIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2vAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNlQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyVAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBgPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC/EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQrRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnQILQcAAIQkgBEHAABDRNEUNqAIgBARAELA+IARBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2tAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNkwIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyTAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2QAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQYDz/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQvxMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ33ASACIAU2AhAgAiAKNgIMIAJBDTsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABBoImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsM7wELIwBB4AJrIgEkACAFIAYQmCIhAgJAAkACQAJAAkACQCAHKAIAIgoEQCABQZwCaiAKQQhqIAcoAgQQihggASgCoAIhAyABKAKcAiIFQZOAgIB4Rg0BIAAgASkCpAI3AgggAEEQaiABQawCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgAUEBNgLAAiABQfwBaiACELoXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ1DoaIAIQ1DohDCACENQ6GiABIAIQ1DoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDZ4CC0HAACEJIARBwAAQ0TRFDakCIAQEQBCwPiAEQcAAEK02IglFDZcCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCIAFCATcCwAIgASAGNgK8AkEAIQUgAUEANgK4AiABIAMpAgA3AqACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2gAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQRhqIAEoApwCIAIQ2isgAUH8AWoiAiABKALAAiABKAIYIAEoAhwQggMgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNrgIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBEGogAUGcAmoiAxDXOyABKAIQIQYQsD5BHEEEEK02IgJFDZQCIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQQhqIAMQ1zsgASgCCCEEELA+QRxBBBCtNiIDDQIMlAILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDZICIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNBCACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQcTy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQxhMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAQsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLDAILIAEgAzYCVCACENQ6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABIAFB1ABqNgLAAiABQfwBaiACEL4XIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ1DoaIAIQ1DohDCACENQ6GiABIAIQ1DoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDZwCC0HAACEJIARBwAAQ0TRFDacCIAQEQBCwPiAEQcAAEK02IglFDZUCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCQQAhBSABQQA2AsQCIAEgBjYCvAIgAUEANgK4AiABIAMpAgA3AqACIAEgAUHUAGo2AsACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2eAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQTBqIAEoApwCIAIQ2isgAUH8AWoiAiABKALAAiABKAIwIAEoAjQQ+QIgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNrAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBKGogAUGcAmoiAxDXOyABKAIoIQYQsD5BHEEEEK02IgJFDZICIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQSBqIAMQ1zsgASgCICEEELA+QRxBBBCtNiIDDQIMkgILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDZACIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNjwIgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEHE8v8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEEMYTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQILIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHnAGoiBSABQYABaikAADcAACABQeAAaiIDIAFB+QBqKQAANwMAIAFBQGsiBCABQZABaikCADcDACABQcgAaiIGIAFBmAFqKQIANwMAIAFBqAFqIgkgAykDADcDACABQa8BaiIDIAUpAAA3AAAgASABKQKIATcDOCABIAEpAHE3A6ABIAFBpQJqIAkpAwA3AAAgAUGsAmogAykAADcAACABQbwCaiAEKQMANwIAIAFBxAJqIAYpAwA3AgAgASACOgCcAiABIAEpA6ABNwCdAiABIAEpAzg3ArQCIAoEQCAKIAooAgAiAkEBajYCACACQQBIDQIgBygCBCEFCyABQZwCahClDBCwPkE4QQQQrTYiAkUN9gEgAiAFNgIQIAIgCjYCDCACQY0COwEIIAJCgYCAgBA3AgAgAiABKQCrATcAFCACIAEpAzg3AiAgAEHQioABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBHGogAUGzAWooAAA2AAAgAkEoaiABQUBrKQMANwIAIAJBMGogAUHIAGopAwA3AgALIAFB4AJqJAAMAQsACwzuAQsjAEHgAmsiASQAIAUgBhCYIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQnRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnQILQcAAIQkgBEHAABDRNEUNqAIgBARAELA+IARBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2tAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNkwIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyTAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARB3PL/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBCoEyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQ6BcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNmwILQcAAIQkgBEHAABDRNEUNpgIgBARAELA+IARBwAAQrTYiCUUNlAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ0CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2rAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNkQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyRAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNjwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2OAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQdzy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQqBMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ31ASACIAU2AhAgAiAKNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAKsBNwAUIAIgASkDODcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQbMBaigAADYAACACQShqIAFBQGspAwA3AgAgAkEwaiABQcgAaikDADcCAAsgAUHgAmokAAwBCwALDO0BCyMAQeACayIBJAAgBSAGEJgiIQICQAJAAkACQAJAAkAgBygCACIKBEAgAUGcAmogCkEIaiAHKAIEEIoYIAEoAqACIQMgASgCnAIiBUGTgICAeEYNASAAIAEpAqQCNwIIIABBEGogAUGsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyACENQ6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAFBATYCwAIgAUH8AWogAhDrFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENQ6GiACENQ6IQwgAhDUOhogASACENQ6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ2cAgtBwAAhCSAEQcAAENE0RQ2nAiAEBEAQsD4gBEHAABCtNiIJRQ2VAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAiABQgE3AsACIAEgBjYCvAJBACEFIAFBADYCuAIgASADKQIANwKgAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NngIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEYaiABKAKcAiACENorIAFB/AFqIgIgASgCwAIgASgCGCABKAIcEIIDIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDawCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQRBqIAFBnAJqIgMQ1zsgASgCECEGELA+QRxBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEIaiADENc7IAEoAgghBBCwPkEcQQQQrTYiAw0CDJICCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2QAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDQQgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEG88/8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEELQTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQELIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AlQgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgASABQdQAajYCwAIgAUH8AWogAhDgFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENQ6GiACENQ6IQwgAhDUOhogASACENQ6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ2aAgtBwAAhCSAEQcAAENE0RQ2lAiAEBEAQsD4gBEHAABCtNiIJRQ2TAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAkEAIQUgAUEANgLEAiABIAY2ArwCIAFBADYCuAIgASADKQIANwKgAiABIAFB1ABqNgLAAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NnAIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEwaiABKAKcAiACENorIAFB/AFqIgIgASgCwAIgASgCMCABKAI0EPkCIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDaoCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQShqIAFBnAJqIgMQ1zsgASgCKCEGELA+QRxBBBCtNiICRQ2QAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEgaiADENc7IAEoAiAhBBCwPkEcQQQQrTYiAw0CDJACCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2OAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDY0CIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBvPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC0EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0CCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB5wBqIgUgAUGAAWopAAA3AAAgAUHgAGoiAyABQfkAaikAADcDACABQUBrIgQgAUGQAWopAgA3AwAgAUHIAGoiBiABQZgBaikCADcDACABQagBaiIJIAMpAwA3AwAgAUGvAWoiAyAFKQAANwAAIAEgASkCiAE3AzggASABKQBxNwOgASABQaUCaiAJKQMANwAAIAFBrAJqIAMpAAA3AAAgAUG8AmogBCkDADcCACABQcQCaiAGKQMANwIAIAEgAjoAnAIgASABKQOgATcAnQIgASABKQM4NwK0AiAKBEAgCiAKKAIAIgJBAWo2AgAgAkEASA0CIAcoAgQhBQsgAUGcAmoQpQwQsD5BOEEEEK02IgJFDfQBIAIgBTYCECACIAo2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABB+ImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsM7AELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCmFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDZQCC0HAACEJIARBwAAQ0TRFDZYCIAQEQBCwPiAEQcAAEK02IglFDY0CCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2UAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhDaKyABQRBqIAEoAhggASgCHBCQHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDZsCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYoCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDIoCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDYgCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQazy/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELsTELA+QThBBBCtNiICRQ3zASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEEMwdELA+QThBBBCtNiICRQ3yASACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsM6wELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCrFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDZMCC0HAACEJIARBwAAQ0TRFDZUCIAQEQBCwPiAEQcAAEK02IglFDYwCCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2TAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhDaKyABQRBqIAEoAhggASgCHBCPHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDZoCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYkCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDIkCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDYcCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQaTz/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELITELA+QThBBBCtNiICRQ3yASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEENcdELA+QThBBBCtNiICRQ3xASACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsM6gELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEFIAFBIGoiCSACEPk0IAEgBTYCPCABQQA2AjggASACNgIcAkACQAJAIAQtADRFBEAgAUH0AGogAUEcahDFFyABQcgAaiIDIAFBgAFqKAIANgIAIAEgASkCeDcDQCABKAJ0IgRBk4CAgHhGDQEgASgChAEhAiAAIAEpA0A3AgQgACACNgIQIAAgBDYCACAAQQxqIAMoAgA2AgAMAgsgAhDUOhogAhDUOiELIAIQ1DoaIAEgAhDUOiIDNgLEASABQcgBakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNkgILQcAAIQogA0HAABDRNEUNlgIgAwRAELA+IANBwAAQrTYiCkUNmAILIAEoAtABIQwgAUGAAWogCUEIaikCADcCACABQYgBaiAJQRBqKQIANwIAIAEgAjYCdEEAIQcgAUEANgKYASABIAU2ApQBIAFBADYCkAEgASAJKQIANwJ4IAFB+ABqIQlBACECA0AgAUG4AWohDUICIRsgAiAFRwR/IAECfgJAIAEoAngEQCACIAEoAogBTw2TAiABKAJ8IAEoAoQBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApABIAFBEGogASgCdCACENorIAFBQGsgASgCECABKAIUEI4cIAEpA0ghGyABKQNADAELIAEgAkEBajYCkAFCAAs3A7gBIAEgASgCmAEiBkEBajYCmAEgAUHYAWoFIA0LIBs3AwACQAJAAkAgASkDuAEiG0ICUgRAIAcgCmohAiAbp0EBcUUNASACIAEpA9gBNwMAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCeCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYCQCACIAEoAsQBRw2cAiABKALQASECIAEoAtQBIQUgASABKQLIATcCgAEgAUEANgJ8IAEgBTYCeCABIAI2AnQgAUEIaiABQfQAaiIGENc7IAEoAgghBxCwPkEcQQQQrTYiAkUNiAIgAkKBgICAEDcCACACIAEpAnQ3AgggAkEQaiABQfwAaiIJKQIANwIAIAJBGGogAUGEAWoiDCgCADYCACABIAM2AoQBIAFCgICAgIAINwJ8IAEgBDYCeCABIAo2AnQgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAw0CDIgCCyACQgA3AwALIAdBCGohByABKAKUASEFIAEoApABIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ0NwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLAASABIAc2ArwBIAEgAjYCuAEQsD5BDEEEEK02IgJFDYYCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC0AEgASACNgLMASABQQE2AsgBIAFBADYCSCABQoCAgIDAADcCQCABQfQAaiICQZD0/wAgCyABIAFBuAFqIAFByAFqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDfEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQcABaiADKAIANgIAIAEgASkDQDcDuAEgAUHIAWoiAyABQbgBahC9GCABQfQAaiIEIAIQkzYQ7iUgAUFAayIFIAMgBBDCHRCwPkE4QQQQrTYiAkUN8AEgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDOkBCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQ5RcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDZECC0HAACEKIANBwAAQ0TRFDZUCIAMEQBCwPiADQcAAEK02IgpFDZcCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NkgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDqHCABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNmwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgyHAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2FAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGo9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEKkTELA+QThBBBCtNiICRQ3wASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQYiDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1R0QsD5BOEEEEK02IgJFDe8BIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwzoAQtBACEHIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNmwIgASkDgAFC09jT+P3m9pJIhSABKQOIAUKi2J6I4aDq6cwAhYRQRQ2bAiACENQ6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADELkXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDUOhogAhDUOiELIAIQ1DoaIAEgAhDUOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQJ0IgQhAyAEQTxxIgkEQCAEIAlrQUBrIgMgBEkNkQILQcAAIQkgA0HAABDRNEUNnwIgAwRAELA+IANBwAAQrTYiCUUNlwILIAEoAuABIQwgAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiENQQAhBkEAIQIDQCABQcgBaiEOQQIhCiACIAVHBH8CQAJAIAEoAoQBRQ0AIAIgASgClAFPDZECIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ApwBQQAhAgwBCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhDaKyABQdAAaiABKAIYIAEoAhwQsQwgASgCUEGTgICAeEYiAgRAIAEoAlQhCgwBCyABQdAAahCIEQsgASACNgLIASABIAEoAqgBIgdBAWo2AqgBIAFB7AFqBSAOCyAKNgIAAkACQAJAIAEoAsgBIgVBAkcEQCAGIAlqIQIgBUEBcUUNASACIAEoAuwBNgIAIAwgB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AlAgAiABKALUAUcNpAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDYcCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiIMKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMhwILIAJBADYCAAsgBkEEaiEGIAEoAqABIQUgASgCnAEhAgwBCwsgA0KBgICAEDcCACADIAEpAoABNwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAFNgLQASABIAc2AswBIAEgAjYCyAEQsD5BDEEEEK02IgJFDYUCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC4AEgASACNgLcASABQQE2AtgBIAFBADYCWCABQoCAgIDAADcCUCABQYABaiICQfjz/wAgCyABIAFByAFqIAFB2AFqIAFB0ABqIgMQjBMgAyACEK8TDAELIAFBiAFqIAIoAgA2AgAgASABKQPYATcDgAEgAUHQAGogAUGAAWoQ4QgLELA+QThBBBCtNiICRQ3uASACQoGAgIAQNwIAIAJBCGogAUHQAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQfABaiQADAALDOcBC0EAIQdBACEKIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNmgIgASkDgAFC09jT+P3m9pJIhSABKQOIAUKi2J6I4aDq6cwAhYRQRQ2aAiACENQ6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADEN0XIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQN0IgQhAyAEQThxIgkEQCAEIAlrQUBrIgMgBEkNkAILQcAAIQkgA0HAABDRNEUNngIgAwRAELA+IANBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiEOQQAhBkEAIQIDQCABQcgBaiEPQQIhCyACIAVHBH8gAQJ/AkACQCABKAKEAQRAIAIgASgClAFPDZICIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhDaKyABQdAAaiABKAIYIAEoAhwQ4AcgASgCUEGTgICAeEYEQCABKAJYIQsgASgCVCEKQQEMAwsgAUHQAGoQiBEMAQsgASACQQFqNgKcAQtBAAs2AsgBIAEgASgCqAEiB0EBajYCqAEgAUHsAWoFIA8LIAs2AgACQAJAAkAgASgCyAEiBUECRwRAIAYgCWohAiAFQQFxRQ0BIAIgCjYCACACQQRqIAEoAuwBNgIAIA0gB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAGQQN1IgI2AlAgAiABKALUAUcNowIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDYYCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiILKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMhgILIAJBADYCACACQQRqQQA2AgALIAZBCGohBiABKAKgASEFIAEoApwBIQIMAQsLIANCgYCAgBA3AgAgAyABKQKAATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC0AEgASAHNgLMASABIAI2AsgBELA+QQxBBBCtNiICRQ2EAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AuABIAEgAjYC3AEgAUEBNgLYASABQQA2AlggAUKAgICAwAA3AlAgAUGAAWoiAkGE9P8AIAwgASABQcgBaiABQdgBaiABQdAAaiIDEIwTIAMgAhCsEwwBCyABQYgBaiACKAIANgIAIAEgASkD2AE3A4ABIAFB0ABqIAFBgAFqENkICxCwPkE4QQQQrTYiAkUN7QEgAkKBgICAEDcCACACQQhqIAFB0ABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHwAWokAAwACwzmAQsgACECIwBBgAJrIgMkACADQSBqIAUgBigCEBEAACADQYABaiIBIAMoAiAiBSADKAIkKAIMEQAAAkACQAJAAkACQCAFRQ2dAiADKQOAAULT2NP4/eb2kkiFIAMpA4gBQqLYnojhoOrpzACFhFBFDZ0CIAUQ1DohByADQTBqIgkgBRD5NCADIAc2AkwgA0EANgJIIAMgBTYCLCAELQA0RQRAIAEgA0EsakEk/AoAACADIAE2AqQBIANB0ABqIAEQ5hcgA0H4AWoiASADQdwAaigCADYCACADIAMpAlQ3A/ABIAMoAlAiBEGTgICAeEYNASADKAJgIQIgACADKQPwATcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwECyAFENQ6GiAFENQ6IQogBRDUOhogAyAFENQ6IgA2AswBIANB0AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDYsCCyADKALYASELIANBjAFqIAlBCGopAgA3AgAgA0GUAWogCUEQaikCADcCACADIAU2AoABQQAhBSADQQA2AqgBIAMgBzYCoAEgA0EANgKcASADIAkpAgA3AoQBIAMgA0GAAWo2AqQBIAEhACAHRQ0DIANB0ABqQQRyIQkgA0HYAGohBwNAAkACQAJAAkAgAygChAEEQCAFIAMoApQBTw2UAiADKAKIASADKAKQASAFaiIMQQN2ai0AAEH/AXMgDEEHcXZBAXENAQsgAyAFQQFqNgKcASADQRhqIAMoAoABIAUQ2isgA0HQAGogAygCGCADKAIcEOkcAkAgAygCUCIFRQRAIANB+AFqIAdBCGopAwA3AwAgAyAHKQMANwPwAQwBCyAFDQILIANB6AFqIANB+AFqKQMAIhs3AwAgAyADKQPwASIcNwPgASADIAMoAqgBIgVBAWo2AqgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiIMIAwtAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgKcAQwBCyAJEIgRCyADQegBaiADQfgBaikDADcDACADIAMpA/ABNwPgASADIAMoAqgBQQFqNgKoASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCnAEiBSADKAKgAUcNAAsMAwsMoQILDI8CCyADQYgBaiABKAIANgIAIAMgAykD8AE3A4ABIANB0ABqIANBgAFqEM4IDAELAkAgAygChAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GEAWoQ+x4LIAMgACABa0EEdSIANgJQIAAgAygCzAFHDZ8CIAMoAtgBIQAgAygC3AEhBSADIAMpAtABNwKMASADQQA2AogBIAMgBTYChAEgAyAANgKAASADQRBqIANBgAFqIgcQ1zsgAygCECEJELA+QRxBBBCtNiIARQ2AAiAAQoGAgIAQNwIAIAAgAykCgAE3AgggAEEQaiADQYgBaiILKQIANwIAIABBGGogA0GQAWoiDCgCADYCACADIAQ2ApABIANCgICAgIAINwKIASADIAY2AoQBIAMgATYCgAEgA0EIaiAHENc7IAMoAgghBBCwPkEcQQQQrTYiAUUEQAyBAgsgAUKBgICAEDcCACABIAMpAoABNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgADYC4AEQsD5BDEEEEK02IgBFDYICIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYC+AEgAyAANgL0ASADQQE2AvABIANBADYCWCADQoCAgIDAADcCUCADQYABaiIAQdDy/wAgCiADIANB4AFqIANB8AFqIANB0ABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUN7AEgAEKBgICAEDcCACAAQQhqIANB0ABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GAAmokAAwACwzlAQsgACEBIwBBgAJrIgckACAHQSRqIgIgBSAGEIwiIgMQ2CoCQAJAAkACQCAELQA0RQRAIAdBnAFqIAIQmhcgB0HQAGoiAiAHQagBaigCADYCACAHIAcpAqABNwNIIAcoApwBIgRBk4CAgHhGDQEgBygCrAEhASAAIAcpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAwsgB0H4AGogB0EkakEk/AoAACAHQfgAaiIAEJA7GiAHKAKUASEGIAAQkDshCSAHQcgAaiICIABBJPwKAAAgAhCQOxogBygCZCEAIAcgB0HIAGoQkDsgAGsiADYC7AEgB0HwAWpBfyAAQQdqIgIgACACSxtBA3YQ0h8CQCAAIgJBP3EiAwRAIAIgAiADa0FAayICSw0BC0HAACEEIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIERQ33AQsgBygC+AEhCiAHQZwBaiAHQcgAakEk/AoAACAHQQA2AsABIAQhAyAHKAK4ASIFIAcoArwBRg0DA0ACQAJAAkACQCAHKAKgAUUNACAFIAcoArABTw2RAiAHKAKkASAHKAKsASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgByAFQQFqNgK4ASAHIAcoAsABQQFqNgLAAQwBCyAHIAVBAWo2ArgBIAdBGGogB0GcAWogBRCtKiAHQRBqIAcoAhggBygCHBC7HSAHIAcoAsABIgVBAWo2AsABIActABANAQsgA0EAOgAADAELIAMgBy0AEToAACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAsgA0EBaiEDIAcoArgBIgUgBygCvAFHDQALDAMLDKECCwyNAgsgB0H4AWogAigCADYCACAHIAcpA0g3A/ABIAdB+ABqIgAgB0HwAWoQ7hggB0GcAWoiAiADEJM2EO4lIAdByABqIgMgACACENgdELA+QThBBBCtNiIABEAgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIADAILDOwBCwJAIAcoAqABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIAdBoAFqEPseCyAHIAMgBGsiAzYC4AEgAyAHKALsAUcNnwIgBygC+AEhAyAHKAL8ASEFIAcgBykC8AE3AqgBIAdBADYCpAEgByAFNgKgASAHIAM2ApwBIAdBCGogB0GcAWoiChDXOyAHKAIIIQsQsD5BHEEEEK02IgNFDf4BIANCgYCAgBA3AgAgAyAHKQKcATcCCCADQRBqIAdBpAFqIgwpAgA3AgAgA0EYaiAHQawBaiINKAIANgIAIAcgAjYCrAEgB0KAgICAgAg3AqQBIAcgADYCoAEgByAENgKcASAHIAoQ1zsgBygCACEEELA+QRxBBBCtNiICRQRADP8BCyACQoGAgIAQNwIAIAIgBykCnAE3AgggAkEQaiAMKQIANwIAIAJBGGogDSgCADYCACAHIAU2AugBIAcgCzYC5AEgByADNgLgARCwPkEMQQQQrTYiA0UNgAIgAyAANgIIIAMgBDYCBCADIAI2AgAgB0EBNgL4ASAHIAM2AvQBIAdBATYC8AEgB0EANgJQIAdCgICAgMAANwJIIAdBnAFqIgBB9PL/ACAJIAZrIAcgB0HgAWogB0HwAWogB0HIAGoiAhCMEyACIAAQthMQsD5BOEEEEK02IgBFDesBIABCgYCAgBA3AgAgAEEIaiACQTD8CgAAIAFBmIeAATYCCCABIAA2AgQgAUGTgICAeDYCAAsgB0GAAmokAAwACwzkAQsjAEGAAmsiAyQAIANBJGoiASAFIAYQjCIiAhDYKgJAAkACQCAELQA0RQRAIANBnAFqIAEQwBcgA0HQAGoiASADQagBaigCADYCACADIAMpAqABNwNIIAMoApwBIgRBk4CAgHhGDQEgAygCrAEhAiAAIAMpA0g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMAgsgA0H4AGogA0EkakEk/AoAACADQfgAaiIBEJA7GiADKAKUASEHIAEQkDshCSADQcgAaiICIAFBJPwKAAAgAhCQOxogAygCZCEBIAMgA0HIAGoQkDsgAWsiATYC7AEgA0HwAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEBdCIGIQQCQCAGQT5xIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNhwILIAMoAvgBIQogA0GcAWogA0HIAGpBJPwKAAAgA0EANgLAASACIQECQCADKAK4ASIFIAMoArwBRg0AA0ACQAJAAkAgAygCoAFFDQAgBSADKAKwAU8NjwIgAygCpAEgAygCrAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0AIAMgBUEBajYCuAEgAyADKALAAUEBajYCwAEMAQsgAyAFQQFqNgK4ASADQRhqIANBnAFqIAUQrSogA0EQaiADKAIYIAMoAhwQ7hwgAy8BECILQQJGDQMgAy8BEiEMIAMgAygCwAEiBUEBajYCwAEgC0EBcUUNACABIAw7AQAgCiAFQQN2aiILIAstAABBASAFQQdxdHI6AAAMAQsgAUEAOwEACyABQQJqIQEgAygCuAEiBSADKAK8AUcNAAsLAkAgAygCoAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GgAWoQ+x4LIAMgASACa0EBdSIBNgLgAQJAIAMoAuwBIAFGBEAgAygC+AEhASADKAL8ASEFIAMgAykC8AE3AqgBIANBADYCpAEgAyAFNgKgASADIAE2ApwBIANBCGogA0GcAWoiChDXOyADKAIIIQsQsD5BHEEEEK02IgFFDYICIAFCgYCAgBA3AgAgASADKQKcATcCCCABQRBqIANBpAFqIgwpAgA3AgAgAUEYaiADQawBaiINKAIANgIAIAMgBDYCrAEgA0KAgICAgAg3AqQBIAMgBjYCoAEgAyACNgKcASADIAoQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADIMCCyACQoGAgIAQNwIAIAIgAykCnAE3AgggAkEQaiAMKQIANwIAIAJBGGogDSgCADYCACADIAU2AugBIAMgCzYC5AEgAyABNgLgARCwPkEMQQQQrTYiAUUNhAIgASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJQIANCgICAgMAANwJIIANBnAFqIgFBmPP/ACAJIAdrIAMgA0HgAWogA0HwAWogA0HIAGoiAhCMEyACIAEQvRMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAULDKMCCwztAQsMogILDIsCCyADQfgBaiABKAIANgIAIAMgAykDSDcD8AEgA0H4AGoiASADQfABahDpGCADQZwBaiIEIAIQkzYQ7iUgA0HIAGoiAiABIAQQ2h0QsD5BOEEEEK02IgFFDeoBIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBgIGAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAmokAAwACwzjAQsjAEGQAmsiASQAIAFBLGoiAiAFIAYQjCIiAxDYKgJAAkACQCAELQA0RQRAIAFBpAFqIAIQsRcgAUHYAGoiAiABQbABaigCADYCACABIAEpAqgBNwNQIAEoAqQBIgRBk4CAgHhGDQEgASgCtAEhAyAAIAEpA1A3AgQgACADNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgAUGAAWogAUEsakEk/AoAACABQYABaiICEJA7GiABKAKcASEGIAIQkDshBSABQdAAaiIDIAJBJPwKAAAgAxCQOxogASgCbCECIAEgAUHQAGoQkDsgAmsiAjYC9AEgAUH4AWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkECdCIEIQMgBEE8cSICBEAgBCACa0FAayIDIARJDYsCC0HAACEHIANBwAAQ0TRFDaECIAMEQBCwPiADQcAAEK02IgdFDZECCyABKAKAAiELIAFBpAFqIAFB0ABqQST8CgAAIAUgBmshDCABQQA2AsgBIAFBqAFqIQ1BACEGA0AgAUHoAWohCQJAIAEoAsABIgIgASgCxAFGBEBBAiECDAELAkACQCABKAKoAUUNACACIAEoArgBTw2LAiABKAKsASABKAK0ASACaiIKQQN2ai0AAEH/AXMgCkEHcXZBAXFFDQAgASACQQFqNgLAAUEAIQoMAQsgASACQQFqNgLAASABQSBqIAFBpAFqIAIQrSogAUEYaiABKAIgIAEoAiQQ7RxBAiECIAEoAhgiCkECRg0BIAEoAhwhAgsgASAKNgLoASABIAEoAsgBIgVBAWo2AsgBIAFBjAJqIQkLIAkgAjYCAAJAAkACQCABKALoASIJQQJHBEAgBiAHaiECIAlBAXFFDQEgAiABKAKMAjYCACALIAVBA3ZqIgIgAi0AAEEBIAVBB3F0cjoAAAwCCwJAIAEoAqgBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgBkECdSICNgLoASACIAEoAvQBRw2mAiABKAKAAiECIAEoAoQCIQUgASABKQL4ATcCsAEgAUEANgKsASABIAU2AqgBIAEgAjYCpAEgAUEQaiABQaQBaiIGENc7IAEoAhAhCRCwPkEcQQQQrTYiAkUNgQIgAkKBgICAEDcCACACIAEpAqQBNwIIIAJBEGogAUGsAWoiCikCADcCACACQRhqIAFBtAFqIgsoAgA2AgAgASADNgK0ASABQoCAgICACDcCrAEgASAENgKoASABIAc2AqQBIAFBCGogBhDXOyABKAIIIQYQsD5BHEEEEK02IgMNAgyBAgsgAkEANgIACyAGQQRqIQYMAQsLIANCgYCAgBA3AgAgAyABKQKkATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC8AEgASAJNgLsASABIAI2AugBELA+QQxBBBCtNiICRQ3/ASACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AoACIAEgAjYC/AEgAUEBNgL4ASABQQA2AlggAUKAgICAwAA3AlAgAUGkAWoiAkHI8/8AIAwgASABQegBaiABQfgBaiABQdAAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUN6gEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBgAJqIAIoAgA2AgAgASABKQNQNwP4ASABQYABaiICIAFB+AFqEOgYIAFBpAFqIgQgAxCTNhDuJSABQdAAaiIDIAIgBBC/HRCwPkE4QQQQrTYiAkUN6QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDOIBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDCFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDYoCC0HAACEHIAJBwAAQ0TRFDaICIAIEQBCwPiACQcAAEK02IgdFDfEBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8NiwIgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBDWGyABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDacCIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ2AAiAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDIACCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDf4BIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQbT0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQsRMQsD5BOEEEEK02IgJFDekBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDWHRCwPkE4QQQQrTYiAkUN6AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHIiIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDOEBCyAAIQEjAEGAAmsiByQAIAdBJGoiAiAFIAYQjCIiAxDYKgJAAkACQAJAIAQtADRFBEAgB0GcAWogAhDGFyAHQdAAaiICIAdBqAFqKAIANgIAIAcgBykCoAE3A0ggBygCnAEiBEGTgICAeEYNASAHKAKsASEBIAAgBykDSDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwDCyAHQfgAaiAHQSRqQST8CgAAIAdB+ABqIgAQkDsaIAcoApQBIQYgABCQOyEJIAdByABqIgIgAEEk/AoAACACEJA7GiAHKAJkIQAgByAHQcgAahCQOyAAayIANgLsASAHQfABakF/IABBB2oiAiAAIAJLG0EDdhDSHwJAIAAiAkE/cSIDBEAgAiACIANrQUBrIgJLDQELQcAAIQQgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgRFDfMBCyAHKAL4ASEKIAdBnAFqIAdByABqQST8CgAAIAdBADYCwAEgBCEDIAcoArgBIgUgBygCvAFGDQMDQAJAAkACQAJAIAcoAqABRQ0AIAUgBygCsAFPDY0CIAcoAqQBIAcoAqwBIAVqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcUUNACAHIAVBAWo2ArgBIAcgBygCwAFBAWo2AsABDAELIAcgBUEBajYCuAEgB0EYaiAHQZwBaiAFEK0qIAdBEGogBygCGCAHKAIcELodIAcgBygCwAEiBUEBajYCwAEgBy0AEA0BCyADQQA6AAAMAQsgAyAHLQAROgAAIAogBUEDdmoiCyALLQAAQQEgBUEHcXRyOgAACyADQQFqIQMgBygCuAEiBSAHKAK8AUcNAAsMAwsMnQILDIkCCyAHQfgBaiACKAIANgIAIAcgBykDSDcD8AEgB0H4AGoiACAHQfABahDuGCAHQZwBaiICIAMQkzYQ7iUgB0HIAGoiAyAAIAIQwR0QsD5BOEEEEK02IgAEQCAAQoGAgIAQNwIAIABBCGogA0Ew/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMAgsM6AELAkAgBygCoAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgB0GgAWoQ+x4LIAcgAyAEayIDNgLgASADIAcoAuwBRw2bAiAHKAL4ASEDIAcoAvwBIQUgByAHKQLwATcCqAEgB0EANgKkASAHIAU2AqABIAcgAzYCnAEgB0EIaiAHQZwBaiIKENc7IAcoAgghCxCwPkEcQQQQrTYiA0UN+gEgA0KBgICAEDcCACADIAcpApwBNwIIIANBEGogB0GkAWoiDCkCADcCACADQRhqIAdBrAFqIg0oAgA2AgAgByACNgKsASAHQoCAgICACDcCpAEgByAANgKgASAHIAQ2ApwBIAcgChDXOyAHKAIAIQQQsD5BHEEEEK02IgJFBEAM+wELIAJCgYCAgBA3AgAgAiAHKQKcATcCCCACQRBqIAwpAgA3AgAgAkEYaiANKAIANgIAIAcgBTYC6AEgByALNgLkASAHIAM2AuABELA+QQxBBBCtNiIDRQ38ASADIAA2AgggAyAENgIEIAMgAjYCACAHQQE2AvgBIAcgAzYC9AEgB0EBNgLwASAHQQA2AlAgB0KAgICAwAA3AkggB0GcAWoiAEHg8/8AIAkgBmsgByAHQeABaiAHQfABaiAHQcgAaiICEIwTIAIgABC4ExCwPkE4QQQQrTYiAEUN5wEgAEKBgICAEDcCACAAQQhqIAJBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQYACaiQADAALDOABCyMAQYACayIDJAAgA0EkaiIBIAUgBhCMIiICENgqAkACQAJAIAQtADRFBEAgA0GcAWogARCeFyADQdAAaiIBIANBqAFqKAIANgIAIAMgAykCoAE3A0ggAygCnAEiBEGTgICAeEYNASADKAKsASECIAAgAykDSDcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwCCyADQfgAaiADQSRqQST8CgAAIANB+ABqIgEQkDsaIAMoApQBIQcgARCQOyEJIANByABqIgIgAUEk/AoAACACEJA7GiADKAJkIQEgAyADQcgAahCQOyABayIBNgLsASADQfABakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQF0IgYhBAJAIAZBPnEiAQRAIAYgAWtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2DAgsgAygC+AEhCiADQZwBaiADQcgAakEk/AoAACADQQA2AsABIAIhAQJAIAMoArgBIgUgAygCvAFGDQADQAJAAkACQCADKAKgAUUNACAFIAMoArABTw2LAiADKAKkASADKAKsASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgAyAFQQFqNgK4ASADIAMoAsABQQFqNgLAAQwBCyADIAVBAWo2ArgBIANBGGogA0GcAWogBRCtKiADQRBqIAMoAhggAygCHBDsHCADLwEQIgtBAkYNAyADLwESIQwgAyADKALAASIFQQFqNgLAASALQQFxRQ0AIAEgDDsBACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAK4ASIFIAMoArwBRw0ACwsCQCADKAKgASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQaABahD7HgsgAyABIAJrQQF1IgE2AuABAkAgAygC7AEgAUYEQCADKAL4ASEBIAMoAvwBIQUgAyADKQLwATcCqAEgA0EANgKkASADIAU2AqABIAMgATYCnAEgA0EIaiADQZwBaiIKENc7IAMoAgghCxCwPkEcQQQQrTYiAUUN/gEgAUKBgICAEDcCACABIAMpApwBNwIIIAFBEGogA0GkAWoiDCkCADcCACABQRhqIANBrAFqIg0oAgA2AgAgAyAENgKsASADQoCAgICACDcCpAEgAyAGNgKgASADIAI2ApwBIAMgChDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAM/wELIAJCgYCAgBA3AgAgAiADKQKcATcCCCACQRBqIAwpAgA3AgAgAkEYaiANKAIANgIAIAMgBTYC6AEgAyALNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ2AAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AvgBIAMgATYC9AEgA0EBNgLwASADQQA2AlAgA0KAgICAwAA3AkggA0GcAWoiAUGw8/8AIAkgB2sgAyADQeABaiADQfABaiADQcgAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMnwILDOkBCwyeAgsMhwILIANB+AFqIAEoAgA2AgAgAyADKQNINwPwASADQfgAaiIBIANB8AFqEOkYIANBnAFqIgQgAhCTNhDuJSADQcgAaiICIAEgBBDNHRCwPkE4QQQQrTYiAUUN5gEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQYACaiQADAALDN8BCyMAQZACayIBJAAgAUEsaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGkAWogAhDLFyABQdgAaiICIAFBsAFqKAIANgIAIAEgASkCqAE3A1AgASgCpAEiBEGTgICAeEYNASABKAK0ASEDIAAgASkDUDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQYABaiABQSxqQST8CgAAIAFBgAFqIgIQkDsaIAEoApwBIQYgAhCQOyEFIAFB0ABqIgMgAkEk/AoAACADEJA7GiABKAJsIQIgASABQdAAahCQOyACayICNgL0ASABQfgBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgQhAyAEQTxxIgIEQCAEIAJrQUBrIgMgBEkNhwILQcAAIQcgA0HAABDRNEUNnQIgAwRAELA+IANBwAAQrTYiB0UNjQILIAEoAoACIQsgAUGkAWogAUHQAGpBJPwKAAAgBSAGayEMIAFBADYCyAEgAUGoAWohDUEAIQYDQCABQegBaiEJAkAgASgCwAEiAiABKALEAUYEQEECIQIMAQsCQAJAIAEoAqgBRQ0AIAIgASgCuAFPDYcCIAEoAqwBIAEoArQBIAJqIgpBA3ZqLQAAQf8BcyAKQQdxdkEBcUUNACABIAJBAWo2AsABQQAhCgwBCyABIAJBAWo2AsABIAFBIGogAUGkAWogAhCtKiABQRhqIAEoAiAgASgCJBDrHEECIQIgASgCGCIKQQJGDQEgASgCHCECCyABIAo2AugBIAEgASgCyAEiBUEBajYCyAEgAUGMAmohCQsgCSACNgIAAkACQAJAIAEoAugBIglBAkcEQCAGIAdqIQIgCUEBcUUNASACIAEoAowCNgIAIAsgBUEDdmoiAiACLQAAQQEgBUEHcXRyOgAADAILAkAgASgCqAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AugBIAIgASgC9AFHDaICIAEoAoACIQIgASgChAIhBSABIAEpAvgBNwKwASABQQA2AqwBIAEgBTYCqAEgASACNgKkASABQRBqIAFBpAFqIgYQ1zsgASgCECEJELA+QRxBBBCtNiICRQ39ASACQoGAgIAQNwIAIAIgASkCpAE3AgggAkEQaiABQawBaiIKKQIANwIAIAJBGGogAUG0AWoiCygCADYCACABIAM2ArQBIAFCgICAgIAINwKsASABIAQ2AqgBIAEgBzYCpAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDP0BCyACQQA2AgALIAZBBGohBgwBCwsgA0KBgICAEDcCACADIAEpAqQBNwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgASAFNgLwASABIAk2AuwBIAEgAjYC6AEQsD5BDEEEEK02IgJFDfsBIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYCgAIgASACNgL8ASABQQE2AvgBIAFBADYCWCABQoCAgIDAADcCUCABQaQBaiICQbjy/wAgDCABIAFB6AFqIAFB+AFqIAFB0ABqIgMQjBMgAyACELkTELA+QThBBBCtNiICRQ3mASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfj+/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUGAAmogAigCADYCACABIAEpA1A3A/gBIAFBgAFqIgIgAUH4AWoQ6BggAUGkAWoiBCADEJM2EO4lIAFB0ABqIgMgAiAEEMcdELA+QThBBBCtNiICRQ3lASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfj+/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM3gELIwBBkAJrIgEkACABQRxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQZgBaiACEMgXIAFByABqIgIgAUGkAWooAgA2AgAgASABKQKcATcDQCABKAKYASIEQZOAgIB4Rg0BIAEoAqgBIQMgACABKQNANwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFB9ABqIAFBHGpBJPwKAAAgAUH0AGoiAhCQOxogASgCkAEhBCACEJA7IQUgAUFAayIDIAJBJPwKAAAgAxCQOxogASgCXCECIAEgAUFAaxCQOyACayICNgLcASABQeABakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgMhAiADQThxIgYEQCADIAZrQUBrIgIgA0kNhgILQcAAIQcgAkHAABDRNEUNngIgAgRAELA+IAJBwAAQrTYiB0UN7QELIAEoAugBIQkgAUGYAWogAUFAa0Ek/AoAACAFIARrIQpBACEGIAFBADYCvAEgAUGcAWohCwNAIAFB+AFqIQxCAiEbIAEoArQBIgQgASgCuAFHBH8gAQJ+AkAgASgCnAEEQCAEIAEoAqwBTw2HAiABKAKgASABKAKoASAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASAEQQFqNgK0ASABQRBqIAFBmAFqIAQQrSogAUGAAmogASgCECABKAIUENUbIAEpA4gCIRsgASkDgAIMAQsgASAEQQFqNgK0AUIACzcD+AEgASABKAK8ASIFQQFqNgK8ASABQfABagUgDAsgGzcDAAJAAkACQCABKQP4ASIbQgJSBEAgBiAHaiEEIBunQQFxRQ0BIAQgASkD8AE3AwAgCSAFQQN2aiIEIAQtAABBASAFQQdxdHI6AAAMAgsCQCABKAKcASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACALEPseCyABIAZBA3UiBDYCgAIgBCABKALcAUcNowIgASgC6AEhBCABKALsASEFIAEgASkC4AE3AqQBIAFBADYCoAEgASAFNgKcASABIAQ2ApgBIAFBCGogAUGYAWoiBhDXOyABKAIIIQkQsD5BHEEEEK02IgRFDfwBIARCgYCAgBA3AgAgBCABKQKYATcCCCAEQRBqIAFBoAFqIgspAgA3AgAgBEEYaiABQagBaiIMKAIANgIAIAEgAjYCqAEgAUKAgICAgAg3AqABIAEgAzYCnAEgASAHNgKYASABIAYQ1zsgASgCACEGELA+QRxBBBCtNiICDQIM/AELIARCADcDAAsgBkEIaiEGDAELCyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiALKQIANwIAIAJBGGogDCgCADYCACABIAU2AugBIAEgCTYC5AEgASAENgLgARCwPkEMQQQQrTYiBEUN+gEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKIAiABIAQ2AoQCIAFBATYCgAIgAUEANgJIIAFCgICAgMAANwJAIAFBmAFqIgJBnPT/ACAKIAEgAUHgAWogAUGAAmogAUFAayIDEIwTIAMgAhCuExCwPkE4QQQQrTYiAkUN5QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGwgoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBiAJqIAIoAgA2AgAgASABKQNANwOAAiABQfQAaiICIAFBgAJqEOcYIAFBmAFqIgQgAxCTNhDuJSABQUBrIgMgAiAEENkdELA+QThBBBCtNiICRQ3kASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM3QELIwBBgAJrIgMkACADQSRqIgEgBSAGEIwiIgIQ2CoCQAJAAkACQCAELQA0RQRAIANBnAFqIAEQ2xcgA0HQAGoiASADQagBaigCADYCACADIAMpAqABNwNIIAMoApwBIgRBk4CAgHhGDQEgAygCrAEhAiAAIAMpA0g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMAwsgA0H4AGogA0EkakEk/AoAACADQfgAaiIBEJA7GiADKAKUASEHIAEQkDshCSADQcgAaiICIAFBJPwKAAAgAhCQOxogAygCZCEBIAMgA0HIAGoQkDsgAWsiATYC7AEgA0HwAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUECdCIGIQQCQCAGQTxxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNgQILIAMoAvgBIQogA0GcAWogA0HIAGpBJPwKAAAgA0EANgLAASACIQEgAygCuAEiBSADKAK8AUYNAwNAAkACQAJAAkAgAygCoAFFDQAgBSADKAKwAU8NiQIgAygCpAEgAygCrAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0AIAMgBUEBajYCuAEgAyADKALAAUEBajYCwAEMAQsgAyAFQQFqNgK4ASADQRhqIANBnAFqIAUQrSogA0HgAWogAygCGCADKAIcEMEBIAMgAygCwAEiBUEBajYCwAEgAygC4AFBMUYNAQsgAUEANgIADAELIAEgAyoC5AE4AgAgCiAFQQN2aiILIAstAABBASAFQQdxdHI6AAALIAFBBGohASADKAK4ASIFIAMoArwBRw0ACwwDCwycAgsMhQILIANB+AFqIAEoAgA2AgAgAyADKQNINwPwASADQfgAaiIBIANB8AFqEOgYIANBnAFqIgQgAhCTNhDuJSADQcgAaiICIAEgBBC+HRCwPkE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCwzkAQsCQCADKAKgASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQaABahD7HgsgAyABIAJrQQJ1IgE2AuABIAEgAygC7AFHDZgCIAMoAvgBIQEgAygC/AEhBSADIAMpAvABNwKoASADQQA2AqQBIAMgBTYCoAEgAyABNgKcASADQRBqIANBnAFqIgoQ1zsgAygCECELELA+QRxBBBCtNiIBRQ32ASABQoGAgIAQNwIAIAEgAykCnAE3AgggAUEQaiADQaQBaiIMKQIANwIAIAFBGGogA0GsAWoiDSgCADYCACADIAQ2AqwBIANCgICAgIAINwKkASADIAY2AqABIAMgAjYCnAEgA0EIaiAKENc7IAMoAgghBBCwPkEcQQQQrTYiAkUEQAz3AQsgAkKBgICAEDcCACACIAMpApwBNwIIIAJBEGogDCkCADcCACACQRhqIA0oAgA2AgAgAyAFNgLoASADIAs2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDfgBIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCUCADQoCAgIDAADcCSCADQZwBaiIBQYzz/wAgCSAHayADIANB4AFqIANB8AFqIANByABqIgIQjBMgAiABELMTELA+QThBBBCtNiIBRQ3jASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdD//wA2AgggACABNgIEIABBk4CAgHg2AgALIANBgAJqJAAMAAsM3AELIwBBgAJrIgMkACADQRxqIgEgBSAGEIwiIgIQ2CoCQAJAAkACQAJAIAQtADRFBEAgA0GYAWogARCvFyADQcgAaiIBIANBpAFqKAIANgIAIAMgAykCnAE3A0AgAygCmAEiBEGTgICAeEYNASADKAKoASECIAAgAykDQDcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwDCyADQfQAaiADQRxqQST8CgAAIANB9ABqIgEQkDsaIAMoApABIQcgARCQOyEJIANBQGsiAiABQST8CgAAIAIQkDsaIAMoAlwhASADIANBQGsQkDsgAWsiATYC3AEgA0HgAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEDdCIGIQQCQCAGQThxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNgQILIAMoAugBIQogA0GYAWogA0FAa0Ek/AoAACADQQA2ArwBIAIhASADKAK0ASIFIAMoArgBRg0DA0ACQAJAAkACQCADKAKcAUUNACAFIAMoAqwBTw2JAiADKAKgASADKAKoASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgAyAFQQFqNgK0ASADIAMoArwBQQFqNgK8AQwBCyADIAVBAWo2ArQBIANBEGogA0GYAWogBRCtKiADQfABaiADKAIQIAMoAhQQ0QEgAyADKAK8ASIFQQFqNgK8ASADKALwAUEBcQ0BCyABQgA3AwAMAQsgASADKwP4ATkDACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAsgAUEIaiEBIAMoArQBIgUgAygCuAFHDQALDAMLQfz2/wBBKSADQZgBakH4+v8AQaj3/wAQ1R4ACwyFAgsgA0H4AWogASgCADYCACADIAMpA0A3A/ABIANB9ABqIgEgA0HwAWoQ5xggA0GYAWoiBCACEJM2EO4lIANBQGsiAiABIAQQ2x0QsD5BOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMAgsM5AELAkAgAygCnAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GcAWoQ+x4LIAMgASACa0EDdSIBNgLwASABIAMoAtwBRw0BIAMoAugBIQEgAygC7AEhBSADIAMpAuABNwKkASADQQA2AqABIAMgBTYCnAEgAyABNgKYASADQQhqIANBmAFqIgoQ1zsgAygCCCELELA+QRxBBBCtNiIBRQ32ASABQoGAgIAQNwIAIAEgAykCmAE3AgggAUEQaiADQaABaiIMKQIANwIAIAFBGGogA0GoAWoiDSgCADYCACADIAQ2AqgBIANCgICAgIAINwKgASADIAY2ApwBIAMgAjYCmAEgAyAKENc7IAMoAgAhBBCwPkEcQQQQrTYiAkUEQAz3AQsgAkKBgICAEDcCACACIAMpApgBNwIIIAJBEGogDCkCADcCACACQRhqIA0oAgA2AgAgAyAFNgLoASADIAs2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDfgBIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCSCADQoCAgIDAADcCQCADQZgBaiIBQdTz/wAgCSAHayADIANB4AFqIANB8AFqIANBQGsiAhCMEyACIAEQxxMQsD5BOEEEEK02IgFFDeMBIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB2IGAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAmokAAwBCyADQgA3AqQBIANCgYCAgMAANwKcASADQZTy/wA2ApgBQQAgA0HwAWogA0HcAWogA0GYAWpBnPL/ABCvKwALDNsBCyADLQABQQFrDgMLDA0KCyMAQZACayIBJAAgAUEsaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGkAWogAhDJFyABQdgAaiICIAFBsAFqKAIANgIAIAEgASkCqAE3A1AgASgCpAEiBEGTgICAeEYNASABKAK0ASEDIAAgASkDUDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQYABaiABQSxqQST8CgAAIAFBgAFqIgIQkDsaIAEoApwBIQYgAhCQOyEFIAFB0ABqIgMgAkEk/AoAACADEJA7GiABKAJsIQIgASABQdAAahCQOyACayICNgL0ASABQfgBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgQhAyAEQTxxIgIEQCAEIAJrQUBrIgMgBEkNggILQcAAIQcgA0HAABDRNEUNmAIgAwRAELA+IANBwAAQrTYiB0UNiAILIAEoAoACIQsgAUGkAWogAUHQAGpBJPwKAAAgBSAGayEMIAFBADYCyAEgAUGoAWohDUEAIQYDQCABQegBaiEJAkAgASgCwAEiAiABKALEAUYEQEECIQIMAQsCQAJAIAEoAqgBRQ0AIAIgASgCuAFPDYICIAEoAqwBIAEoArQBIAJqIgpBA3ZqLQAAQf8BcyAKQQdxdkEBcUUNACABIAJBAWo2AsABQQAhCgwBCyABIAJBAWo2AsABIAFBIGogAUGkAWogAhCtKiABQRhqIAEoAiAgASgCJBDYJkECIQIgASgCGCIKQQJGDQEgASgCHCECCyABIAo2AugBIAEgASgCyAEiBUEBajYCyAEgAUGMAmohCQsgCSACNgIAAkACQAJAIAEoAugBIglBAkcEQCAGIAdqIQIgCUEBcUUNASACIAEoAowCNgIAIAsgBUEDdmoiAiACLQAAQQEgBUEHcXRyOgAADAILAkAgASgCqAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AugBIAIgASgC9AFHDZ0CIAEoAoACIQIgASgChAIhBSABIAEpAvgBNwKwASABQQA2AqwBIAEgBTYCqAEgASACNgKkASABQRBqIAFBpAFqIgYQ1zsgASgCECEJELA+QRxBBBCtNiICRQ34ASACQoGAgIAQNwIAIAIgASkCpAE3AgggAkEQaiABQawBaiIKKQIANwIAIAJBGGogAUG0AWoiCygCADYCACABIAM2ArQBIAFCgICAgIAINwKsASABIAQ2AqgBIAEgBzYCpAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDPgBCyACQQA2AgALIAZBBGohBgwBCwsgA0KBgICAEDcCACADIAEpAqQBNwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgASAFNgLwASABIAk2AuwBIAEgAjYC6AEQsD5BDEEEEK02IgJFDfYBIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYCgAIgASACNgL8ASABQQE2AvgBIAFBADYCWCABQoCAgIDAADcCUCABQaQBaiICQezz/wAgDCABIAFB6AFqIAFB+AFqIAFB0ABqIgMQjBMgAyACEMQTELA+QThBBBCtNiICRQ3hASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcCGgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUGAAmogAigCADYCACABIAEpA1A3A/gBIAFBgAFqIgIgAUH4AWoQ6BggAUGkAWoiBCADEJM2EO4lIAFB0ABqIgMgAiAEENIdELA+QThBBBCtNiICRQ3gASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcCGgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM2QELIwBBkAJrIgEkACABQRxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQZgBaiACEJ8XIAFByABqIgIgAUGkAWooAgA2AgAgASABKQKcATcDQCABKAKYASIEQZOAgIB4Rg0BIAEoAqgBIQMgACABKQNANwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFB9ABqIAFBHGpBJPwKAAAgAUH0AGoiAhCQOxogASgCkAEhBCACEJA7IQUgAUFAayIDIAJBJPwKAAAgAxCQOxogASgCXCECIAEgAUFAaxCQOyACayICNgLcASABQeABakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgMhAiADQThxIgYEQCADIAZrQUBrIgIgA0kNgQILQcAAIQcgAkHAABDRNEUNmQIgAgRAELA+IAJBwAAQrTYiB0UN6AELIAEoAugBIQkgAUGYAWogAUFAa0Ek/AoAACAFIARrIQpBACEGIAFBADYCvAEgAUGcAWohCwNAIAFB+AFqIQxCAiEbIAEoArQBIgQgASgCuAFHBH8gAQJ+AkAgASgCnAEEQCAEIAEoAqwBTw2CAiABKAKgASABKAKoASAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASAEQQFqNgK0ASABQRBqIAFBmAFqIAQQrSogAUGAAmogASgCECABKAIUEL8SIAEpA4gCIRsgASkDgAIMAQsgASAEQQFqNgK0AUIACzcD+AEgASABKAK8ASIFQQFqNgK8ASABQfABagUgDAsgGzcDAAJAAkACQCABKQP4ASIbQgJSBEAgBiAHaiEEIBunQQFxRQ0BIAQgASkD8AE3AwAgCSAFQQN2aiIEIAQtAABBASAFQQdxdHI6AAAMAgsCQCABKAKcASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACALEPseCyABIAZBA3UiBDYCgAIgBCABKALcAUcNngIgASgC6AEhBCABKALsASEFIAEgASkC4AE3AqQBIAFBADYCoAEgASAFNgKcASABIAQ2ApgBIAFBCGogAUGYAWoiBhDXOyABKAIIIQkQsD5BHEEEEK02IgRFDfcBIARCgYCAgBA3AgAgBCABKQKYATcCCCAEQRBqIAFBoAFqIgspAgA3AgAgBEEYaiABQagBaiIMKAIANgIAIAEgAjYCqAEgAUKAgICAgAg3AqABIAEgAzYCnAEgASAHNgKYASABIAYQ1zsgASgCACEGELA+QRxBBBCtNiICDQIM9wELIARCADcDAAsgBkEIaiEGDAELCyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiALKQIANwIAIAJBGGogDCgCADYCACABIAU2AugBIAEgCTYC5AEgASAENgLgARCwPkEMQQQQrTYiBEUN9QEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKIAiABIAQ2AoQCIAFBATYCgAIgAUEANgJIIAFCgICAgMAANwJAIAFBmAFqIgJB6PL/ACAKIAEgAUHgAWogAUGAAmogAUFAayIDEIwTIAMgAhDAExCwPkE4QQQQrTYiAkUN4AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQhYABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBiAJqIAIoAgA2AgAgASABKQNANwOAAiABQfQAaiICIAFBgAJqEL0YIAFBmAFqIgQgAxCTNhDuJSABQUBrIgMgAiAEEMQdELA+QThBBBCtNiICRQ3fASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM2AELIAMtAAEOAgsMzwELIAMtAAFBAmsOAgwNzgELIAMtAAFBAWsOAg4PDQsjAEGAAmsiASQAIAFBEGoiAiAFIAYoAhQRAAAgAUHUAGoiAyACENINIAMQ0jwhBUEAIQMgASgCdCIEQRBPBEAgASgCcCECIARBBHYhBANAIAMgAigCAGohAyACQRBqIQIgBEEBayIEDQALCyABQZABaiAFIAMQphQgAUHEAWogAUHUAGoQ2CoCQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQcgAUGoAWohCQNAAkACQCABKALIAQRAIAIgASgC2AFPDZoCIAEoAswBIAEoAtQBIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AuABIAFBCGogAUHEAWogAhCtKiABQZABaiABKAIIIAEoAgwQoTYCQCABKAKoAQRAIAEoArgBIgRBAWoiBUEDdiAFQQdxQQBHaiIDIAEoArQBIgJLBEAgAyACayEGIAEoAqwBIgogA0kEQCAJIApBAXQiAiADEM0qIgogAiAKSxsQ6BkgASgCtAEhAgsgBgRAIAEoArABIAJqQQAgBvwLAAsgASADNgK0AQsgASAFNgK4ASABKAKwASAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAK8AUEBajYCvAELIAEoApgBIQMgASgCpAEiAiABKAKcAUYEQCAHQaC+/wAQnSgLIAEoAqABIAJBAnRqIAM2AgAgASACQQFqNgKkAQwBCyABIAJBAWo2AuABIAFBkAFqEKYVCyABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiAyABQZABaiIEEOsOELA+QcQAQQQQrTYiAkUN2wEgAkKBgICAEDcCACACQQhqIANBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAQQuiwgAUHUAGoQ3iIgAUGAAmokAAwACwzUAQsjAEGAAmsiASQAIAFBEGoiAiAFIAYoAhQRAAAgAUHUAGoiAyACENINIAMQ0jwhBUEAIQMgASgCdCIEQRBPBEAgASgCcCECIARBBHYhBANAIAMgAigCAGohAyACQRBqIQIgBEEBayIEDQALCyABQZABaiAFIAMQpRQgAUHEAWogAUHUAGoQ2CoCQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQcgAUGoAWohCQNAAkACQCABKALIAQRAIAIgASgC2AFPDZkCIAEoAswBIAEoAtQBIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AuABIAFBCGogAUHEAWogAhCtKiABQZABaiABKAIIIAEoAgwQoTYCQCABKAKoAQRAIAEoArgBIgRBAWoiBUEDdiAFQQdxQQBHaiIDIAEoArQBIgJLBEAgAyACayEGIAEoAqwBIgogA0kEQCAJIApBAXQiAiADEM0qIgogAiAKSxsQ6BkgASgCtAEhAgsgBgRAIAEoArABIAJqQQAgBvwLAAsgASADNgK0AQsgASAFNgK4ASABKAKwASAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAK8AUEBajYCvAELIAE1ApgBIRsgASgCpAEiAiABKAKcAUYEQCAHQaC+/wAQsygLIAEoAqABIAJBA3RqIBs3AwAgASACQQFqNgKkAQwBCyABIAJBAWo2AuABIAFBkAFqEKcVCyABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiAyABQZABaiIEEOwOELA+QcQAQQQQrTYiAkUN2gEgAkKBgICAEDcCACACQQhqIANBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAQQuywgAUHUAGoQ3iIgAUGAAmokAAwACwzTAQsgCEHQAGoiASAFIAYQjCIQoxQgCEGQAmoiAiABEK0fIAIQ7CkhASAAQfDf/wA2AgggACABNgIEIABBk4CAgHg2AgAM0gELIwBBgAJrIgEkACABQRBqIgIgBSAGKAIUEQAAIAFB1ABqIgMgAhDSDSADENI8IQVBACEDIAEoAnQiBEEQTwRAIAEoAnAhAiAEQQR2IQQDQCADIAIoAgBqIQMgAkEQaiECIARBAWsiBA0ACwsgAUGQAWogBSADEKYUIAFBxAFqIAFB1ABqENgqAkACQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQkgAUGoAWohBQNAAkAgCQJ/AkAgASgCyAEEQCACIAEoAtgBTw2ZAiABKALMASABKALUASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLgASABQQhqIAFBxAFqIAIQrSogAUGQAWogASgCCCABKAIMEKE2AkAgASgCqAEEQCABKAK4ASIEQQFqIgZBA3YgBkEHcUEAR2oiAyABKAK0ASICSwRAIAMgAmshByABKAKsASIKIANJBEAgBSAKQQF0IgIgAxDNKiIKIAIgCksbEOgZIAEoArQBIQILIAcEQCABKAKwASACakEAIAf8CwALIAEgAzYCtAELIAEgBjYCuAEgASgCsAEgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCvAFBAWo2ArwBCyABKAKYASEDIAEoAqQBIgIgASgCnAFHDQJBoL7/AAwBCyABIAJBAWo2AuABIAUQ5jogASgCqAFFDQQgASgCuAFBAWoiA0EDdiADQQdxQQBHaiICIAEoArQBIgRLBEAgAiAEayEGIAEoAqwBIgcgAkkEQCAFIAdBAXQiBCACEM0qIgcgBCAHSxsQ6BkgASgCtAEhBAsgBgRAIAEoArABIARqQQAgBvwLAAsgASACNgK0AQsgASADNgK4ASABKAKYASEDIAEoAqQBIgIgASgCnAFHDQFBgL7/AAsQnSgLIAEoAqABIAJBAnRqIAM2AgAgASACQQFqNgKkASABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiBCABQZABaiIDEO0OELA+QcQAQQQQrTYiAkUN2QEgAkKBgICAEDcCACACQQhqIARBPPwKAAAgAEHI6/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAMQyT4gAxDeOyABQZwBaiIAEMk+IAAQ6TsgASgCqAEEQCABQagBahDPLwsgAUHUAGoQ3iIgAUGAAmokAAwBC0Howf8AELI7AAsM0QELIwBBgAJrIgEkACABQRBqIgIgBSAGKAIUEQAAIAFB1ABqIgMgAhDSDSADENI8IQVBACEDIAEoAnQiBEEQTwRAIAEoAnAhAiAEQQR2IQQDQCADIAIoAgBqIQMgAkEQaiECIARBAWsiBA0ACwsgAUGQAWogBSADEKUUIAFBxAFqIAFB1ABqENgqAkACQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQkgAUGoAWohBQNAAkAgCQJ/AkAgASgCyAEEQCACIAEoAtgBTw2YAiABKALMASABKALUASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLgASABQQhqIAFBxAFqIAIQrSogAUGQAWogASgCCCABKAIMEKE2AkAgASgCqAEEQCABKAK4ASIEQQFqIgZBA3YgBkEHcUEAR2oiAyABKAK0ASICSwRAIAMgAmshByABKAKsASIKIANJBEAgBSAKQQF0IgIgAxDNKiIKIAIgCksbEOgZIAEoArQBIQILIAcEQCABKAKwASACakEAIAf8CwALIAEgAzYCtAELIAEgBjYCuAEgASgCsAEgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCvAFBAWo2ArwBCyABKAKYASEDIAEoAqQBIgIgASgCnAFHDQJBoL7/AAwBCyABIAJBAWo2AuABIAUQ5jogASgCqAFFDQQgASgCuAFBAWoiA0EDdiADQQdxQQBHaiICIAEoArQBIgRLBEAgAiAEayEGIAEoAqwBIgcgAkkEQCAFIAdBAXQiBCACEM0qIgcgBCAHSxsQ6BkgASgCtAEhBAsgBgRAIAEoArABIARqQQAgBvwLAAsgASACNgK0AQsgASADNgK4ASABKAKYASEDIAEoAqQBIgIgASgCnAFHDQFBgL7/AAsQsygLIAEoAqABIAJBA3RqIAOtNwMAIAEgAkEBajYCpAEgASgC4AEiAiABKALkAUcNAAsLAkAgASgCyAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUHIAWoQ+x4LIAFBxAFqIgQgAUGQAWoiAxDuDhCwPkHEAEEEEK02IgJFDdgBIAJCgYCAgBA3AgAgAkEIaiAEQTz8CgAAIABBoOz/ADYCCCAAIAI2AgQgAEGTgICAeDYCACADEMk+IAMQ3jsgAUGcAWoiABDJPiAAEOM8IAEoAqgBBEAgAUGoAWoQzy8LIAFB1ABqEN4iIAFBgAJqJAAMAQtB6MH/ABCyOwALDNABCyMAQaADayIBJAAgBSAGEIwiIQICQAJAAkACQAJAAkAgBygCACIGBEAgAUHcAmogBkEIaiAHKAIEEIoYIAEoAuACIQMgASgC3AIiBUGTgICAeEYNASAAIAEpAuQCNwIIIABBEGogAUHsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyABQZwBaiIDIAIQ2CoCQAJAAkACQCAELQA0RQRAIAFB3AJqIgIgA0Ek/AoAACABQQE2AoADIAFB6AFqIAIQuxcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABQQE2AuQBIAIQkDsaIAEoAtwBIQMgAhCQOyEEIAFB6AFqIgUgAkEo/AoAACAFEJA7GiABKAKEAiECIAEgBRCQOyACayICNgKUAiABQZgCakF/IAJBB2oiBSACIAVLG0EDdhDSHyACQQN0IgkhAiAJQThxIgUEQCAJIAVrQUBrIgIgCUkN/wELQcAAIQUgAkHAABDRNEUNmgIgAgRAELA+IAJBwAAQrTYiBUUN5gELIAEoAqACIQsgAUHcAmogAUHoAWpBKPwKAAAgBCADayEMQQAhAyABQQA2AoQDIAFB4AJqIQ0DQCABQbACaiEOQgIhGyABKAL4AiIKIAEoAvwCRwR/IAECfgJAAkAgASgC4AIEQCAKIAEoAvACTw2BAiABKALkAiABKALsAiAKaiIEQQN2ai0AAEH/AXMgBEEHcXZBAXENAQsgASAKQQFqNgL4AiABQRBqIAFB3AJqIAoQrSogAUHIAmoiBCABKAKAAyABKAIQIAEoAhQQggMgASgCyAJBk4CAgHhHBEAgBBCIEQwCCyABKALMAiIERQ0BIAEgASkC0AI3AswCIAEgBDYCyAIgAUG4AmogAUHIAmoQxCcgASkDwAIhGyABKQO4AgwCCyABIApBAWo2AvgCC0IACzcDsAIgASABKAKEAyIEQQFqNgKEAyABQagCagUgDgsgGzcDAAJAAkACQCABKQOwAiIbQgJSBEAgAyAFaiEKIBunQQFxRQ0BIAogASkDqAI3AwAgCyAEQQN2aiIKIAotAABBASAEQQdxdHI6AAAMAgsCQCABKALgAiIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACANEPseCyABIANBA3UiAzYCyAIgAyABKAKUAkcNnwIgASgCoAIhAyABKAKkAiEEIAEgASkCmAI3AugCIAFBADYC5AIgASAENgLgAiABIAM2AtwCIAFBCGogAUHcAmoiChDXOyABKAIIIQsQsD5BHEEEEK02IgNFDfUBIANCgYCAgBA3AgAgAyABKQLcAjcCCCADQRBqIAFB5AJqIg0pAgA3AgAgA0EYaiABQewCaiIOKAIANgIAIAEgAjYC7AIgAUKAgICAgAg3AuQCIAEgCTYC4AIgASAFNgLcAiABIAoQ1zsgASgCACEFELA+QRxBBBCtNiICDQIM9QELIApCADcDAAsgA0EIaiEDDAELCyACQoGAgIAQNwIAIAIgASkC3AI3AgggAkEQaiANKQIANwIAIAJBGGogDigCADYCACABIAQ2AsACIAEgCzYCvAIgASADNgK4AhCwPkEMQQQQrTYiA0UN8wEgAyAJNgIIIAMgBTYCBCADIAI2AgAgAUEBNgLQAiABIAM2AswCIAFBATYCyAIgAUEANgLwASABQoCAgIDAADcC6AEgAUHcAmoiAkGA8/8AIAwgASABQbgCaiABQcgCaiABQegBahCMEyABQewAaiACEL8TDAELIAFBoAJqIAIoAgAiAzYCACABIAEpA8ABNwOYAiABQdwCaiIEIAEoApwCIgIgAiADQQR0ahD1CSABQdACaiABQeQCaigCADYCACABQcACaiIFIAFB8AJqKAIANgIAIAEgASkC3AI3A8gCIAEgASkC6AI3A7gCELA+QQxBBBCtNiICRQ0EIAIgASkDuAI3AgAgAkEIaiAFKAIANgIAIAFBATYCyAEgASACNgLEASABQQE2AsABIAFBADYC8AEgAUKAgICAwAA3AugBIARBgPP/ACADIAEgAUHIAmogAUHAAWogAUHoAWoQjBMgAUHsAGogBBC/EyABQZgCaiICEMk+IAIQ7TsLIAEtAGwiA0EpRw0BCyABQeMAaiABQYABaigCACICNgAAIAFB2wBqIAFB+ABqKQIAIhs3AAAgASABKQJwIhw3AFMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJMIAFBnAFqIgMgAhDYKgJAAkACQCAELQA0RQRAIAFB3AJqIgIgA0Ek/AoAACABIAFBzABqNgKAAyABQegBaiACENEXIAFByAFqIgIgAUH0AWooAgA2AgAgASABKQLsATcDwAEgASgC6AEiA0GTgICAeEYNASABQfwAaiACKAIANgIAIAEgASkDwAE3AnQgASABKAL4ATYCgAEgASADNgJwDAMLIAFBwAFqIgIgAUGcAWpBJPwKAAAgASABQcwAajYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ39AQtBwAAhBSACQcAAENE0RQ2YAiACBEAQsD4gAkHAABCtNiIFRQ3kAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf8BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBKGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAiggASgCLBD5AiABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahDEJyABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2dAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEgaiABQdwCaiIKENc7IAEoAiAhCxCwPkEcQQQQrTYiA0UN8wEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAFBGGogChDXOyABKAIYIQUQsD5BHEEEEK02IgINAgzzAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3xASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQYDz/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQvxMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDfABIAIgASkDuAI3AgAgAkEIaiAFKAIANgIAIAFBATYCyAEgASACNgLEASABQQE2AsABIAFBADYC8AEgAUKAgICAwAA3AugBIARBgPP/ACADIAEgAUHIAmogAUHAAWogAUHoAWoQjBMgAUHsAGogBBC/EyABQZgCaiICEMk+IAIQ7TsLIAEtAGwiA0EpRw0CCyABQeMAaiABQYABaigCACICNgAAIAFB2wBqIAFB+ABqKQIAIhs3AAAgASABKQJwIhw3AFMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB3wBqIgQgAUH8AGopAAA3AAAgAUHYAGoiAiABQfUAaikAADcDACABQThqIgUgAUGMAWopAgA3AwAgAUFAayIJIAFBlAFqKQIANwMAIAFB8AFqIgogAikDADcDACABQfcBaiICIAQpAAA3AAAgASABKQKEATcDMCABIAEpAG03A+gBIAFB5QJqIAopAwA3AAAgAUHsAmogAikAADcAACABQfwCaiAFKQMANwIAIAFBhANqIAkpAwA3AgAgASADOgDcAiABIAEpA+gBNwDdAiABIAEpAzA3AvQCIAYEQCAGIAYoAgAiAkEBajYCACACQQBIDQIgBygCBCEECyABQdwCahClDBCwPkE4QQQQrTYiAkUN1wEgAiAENgIQIAIgBjYCDCACQQ07AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQaCJgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzwELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhDNFyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ3+AQtBwAAhBSACQcAAENE0RQ2ZAiACBEAQsD4gAkHAABCtNiIFRQ3lAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDYACIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahCZJCABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2eAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN9AEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgz0AQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3yASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQcTy/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQxhMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHE8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEMYTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQqhcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfwBC0HAACEFIAJBwAAQ0TRFDZcCIAIEQBCwPiACQcAAEK02IgVFDeMBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/gEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEJkkIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZwCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3yASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPIBCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDfABIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJBxPL/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhDGEwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7wEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHE8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEMYTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3WASACIAQ2AhAgAiAGNgIMIAJBjQI7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQdCKgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzgELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhCbFyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ39AQtBwAAhBSACQcAAENE0RQ2YAiACBEAQsD4gAkHAABCtNiIFRQ3kAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf8BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahDgGSABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2dAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN8wEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgzzAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3xASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQdzy/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQqBMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHc8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEKgTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQ5BcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfsBC0HAACEFIAJBwAAQ0TRFDZYCIAIEQBCwPiACQcAAEK02IgVFDeIBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/QEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEOAZIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZsCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3xASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPEBCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDe8BIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJB3PL/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhCoEwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7gEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHc8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEKgTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3VASACIAQ2AhAgAiAGNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzQELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhC/FyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ38AQtBwAAhBSACQcAAENE0RQ2XAiACBEAQsD4gAkHAABCtNiIFRQ3jAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf4BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahCZGiABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2cAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN8gEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgzyAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3wASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQbzz/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQtBMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEG88/8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEELQTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQ5xcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfoBC0HAACEFIAJBwAAQ0TRFDZUCIAIEQBCwPiACQcAAEK02IgVFDeEBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/AEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEJkaIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZoCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3wASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPABCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDe4BIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJBvPP/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhC0EwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7QEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEG88/8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEELQTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3UASACIAQ2AhAgAiAGNgIMIAJBjQY7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQfiJgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzAELIwBBkAJrIgEkACABQSxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQaQBaiACEKcXIAFB2ABqIgIgAUGwAWooAgA2AgAgASABKQKoATcDUCABKAKkASIEQZOAgIB4Rg0BIAEoArQBIQMgACABKQNQNwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFBgAFqIAFBLGpBJPwKAAAgAUGAAWoiAhCQOxogASgCnAEhBiACEJA7IQUgAUHQAGoiAyACQST8CgAAIAMQkDsaIAEoAmwhAiABIAFB0ABqEJA7IAJrIgI2AvQBIAFB+AFqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBAnQiBCEDIARBPHEiAgRAIAQgAmtBQGsiAyAESQ30AQtBwAAhByADQcAAENE0RQ2KAiADBEAQsD4gA0HAABCtNiIHRQ36AQsgASgCgAIhCyABQaQBaiABQdAAakEk/AoAACAFIAZrIQwgAUEANgLIASABQagBaiENQQAhBgNAIAFB6AFqIQkCQCABKALAASICIAEoAsQBRgRAQQIhAgwBCwJAAkAgASgCqAFFDQAgAiABKAK4AU8N9AEgASgCrAEgASgCtAEgAmoiCkEDdmotAABB/wFzIApBB3F2QQFxRQ0AIAEgAkEBajYCwAFBACEKDAELIAEgAkEBajYCwAEgAUEgaiABQaQBaiACEK0qIAFBGGogASgCICABKAIkEJAcQQIhAiABKAIYIgpBAkYNASABKAIcIQILIAEgCjYC6AEgASABKALIASIFQQFqNgLIASABQYwCaiEJCyAJIAI2AgACQAJAAkAgASgC6AEiCUECRwRAIAYgB2ohAiAJQQFxRQ0BIAIgASgCjAI2AgAgCyAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAgsCQCABKAKoASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACANEPseCyABIAZBAnUiAjYC6AEgAiABKAL0AUcNjwIgASgCgAIhAiABKAKEAiEFIAEgASkC+AE3ArABIAFBADYCrAEgASAFNgKoASABIAI2AqQBIAFBEGogAUGkAWoiBhDXOyABKAIQIQkQsD5BHEEEEK02IgJFDeoBIAJCgYCAgBA3AgAgAiABKQKkATcCCCACQRBqIAFBrAFqIgopAgA3AgAgAkEYaiABQbQBaiILKAIANgIAIAEgAzYCtAEgAUKAgICAgAg3AqwBIAEgBDYCqAEgASAHNgKkASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIM6gELIAJBADYCAAsgBkEEaiEGDAELCyADQoGAgIAQNwIAIAMgASkCpAE3AgggA0EQaiAKKQIANwIAIANBGGogCygCADYCACABIAU2AvABIAEgCTYC7AEgASACNgLoARCwPkEMQQQQrTYiAkUN6AEgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgKAAiABIAI2AvwBIAFBATYC+AEgAUEANgJYIAFCgICAgMAANwJQIAFBpAFqIgJBrPL/ACAMIAEgAUHoAWogAUH4AWogAUHQAGoiAxCMEyADIAIQuxMQsD5BOEEEEK02IgJFDdMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBuISAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYACaiACKAIANgIAIAEgASkDUDcD+AEgAUGAAWoiAiABQfgBahDoGCABQaQBaiIEIAMQkzYQ7iUgAUHQAGoiAyACIAQQzB0QsD5BOEEEEK02IgJFDdIBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBuISAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGQAmokAAwACwzLAQsjAEGQAmsiASQAIAFBLGoiAiAFIAYQjCIiAxDYKgJAAkACQCAELQA0RQRAIAFBpAFqIAIQnBcgAUHYAGoiAiABQbABaigCADYCACABIAEpAqgBNwNQIAEoAqQBIgRBk4CAgHhGDQEgASgCtAEhAyAAIAEpA1A3AgQgACADNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgAUGAAWogAUEsakEk/AoAACABQYABaiICEJA7GiABKAKcASEGIAIQkDshBSABQdAAaiIDIAJBJPwKAAAgAxCQOxogASgCbCECIAEgAUHQAGoQkDsgAmsiAjYC9AEgAUH4AWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkECdCIEIQMgBEE8cSICBEAgBCACa0FAayIDIARJDfMBC0HAACEHIANBwAAQ0TRFDYkCIAMEQBCwPiADQcAAEK02IgdFDfkBCyABKAKAAiELIAFBpAFqIAFB0ABqQST8CgAAIAUgBmshDCABQQA2AsgBIAFBqAFqIQ1BACEGA0AgAUHoAWohCQJAIAEoAsABIgIgASgCxAFGBEBBAiECDAELAkACQCABKAKoAUUNACACIAEoArgBTw3zASABKAKsASABKAK0ASACaiIKQQN2ai0AAEH/AXMgCkEHcXZBAXFFDQAgASACQQFqNgLAAUEAIQoMAQsgASACQQFqNgLAASABQSBqIAFBpAFqIAIQrSogAUEYaiABKAIgIAEoAiQQjxxBAiECIAEoAhgiCkECRg0BIAEoAhwhAgsgASAKNgLoASABIAEoAsgBIgVBAWo2AsgBIAFBjAJqIQkLIAkgAjYCAAJAAkACQCABKALoASIJQQJHBEAgBiAHaiECIAlBAXFFDQEgAiABKAKMAjYCACALIAVBA3ZqIgIgAi0AAEEBIAVBB3F0cjoAAAwCCwJAIAEoAqgBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgBkECdSICNgLoASACIAEoAvQBRw2OAiABKAKAAiECIAEoAoQCIQUgASABKQL4ATcCsAEgAUEANgKsASABIAU2AqgBIAEgAjYCpAEgAUEQaiABQaQBaiIGENc7IAEoAhAhCRCwPkEcQQQQrTYiAkUN6QEgAkKBgICAEDcCACACIAEpAqQBNwIIIAJBEGogAUGsAWoiCikCADcCACACQRhqIAFBtAFqIgsoAgA2AgAgASADNgK0ASABQoCAgICACDcCrAEgASAENgKoASABIAc2AqQBIAFBCGogBhDXOyABKAIIIQYQsD5BHEEEEK02IgMNAgzpAQsgAkEANgIACyAGQQRqIQYMAQsLIANCgYCAgBA3AgAgAyABKQKkATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC8AEgASAJNgLsASABIAI2AugBELA+QQxBBBCtNiICRQ3nASACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AoACIAEgAjYC/AEgAUEBNgL4ASABQQA2AlggAUKAgICAwAA3AlAgAUGkAWoiAkGk8/8AIAwgASABQegBaiABQfgBaiABQdAAaiIDEIwTIAMgAhCyExCwPkE4QQQQrTYiAkUN0gEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHgg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBgAJqIAIoAgA2AgAgASABKQNQNwP4ASABQYABaiICIAFB+AFqEOgYIAFBpAFqIgQgAxCTNhDuJSABQdAAaiIDIAIgBBDXHRCwPkE4QQQQrTYiAkUN0QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHgg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMoBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDpFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDfIBC0HAACEHIAJBwAAQ0TRFDYoCIAIEQBCwPiACQcAAEK02IgdFDdkBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8N8wEgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBCOHCABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDY8CIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ3oASAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDOgBCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDeYBIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQZD0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDdEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDCHRCwPkE4QQQQrTYiAkUN0AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMkBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDeFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDfEBC0HAACEHIAJBwAAQ0TRFDYkCIAIEQBCwPiACQcAAEK02IgdFDdgBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8N8gEgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBDqHCABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDY4CIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ3nASAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDOcBCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDeUBIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQaj0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQqRMQsD5BOEEEEK02IgJFDdABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDVHRCwPkE4QQQQrTYiAkUNzwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGIg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMgBC0EAIQcjAEGgAmsiASQAIAFBGGogBSAGKAIQEQAAIAFBoAFqIgIgASgCGCIDIAEoAhwoAgwRAAACQAJAIANFDQAgASkDoAFCq5iR8ZX61fyAf4UgASkDqAFClpT4q/Cx6bPhAIWEUEUNACABQSRqIgUgAxDYKgJAAkACQCAELQA0RQRAIAIgBUEk/AoAACABIAI2AsQBIAFByABqIAIQ1hcgAUGAAWoiAiABQdQAaigCADYCACABIAEpAkw3A3ggASgCSCIDQZOAgIB4Rg0BIAEoAlghBCAAIAEpA3g3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAUH4AGoiAiABQSRqQST8CgAAIAEgAUGgAWo2ApwBIAIQkDsaIAEoApQBIQQgAhCQOyABQcgAaiIDIAJBKPwKAAAgAxCQOxogASgCZCECIAEgAxCQOyACayICNgLwASABQfQBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgMhAiADQTxxIgYEQCADIAZrQUBrIgIgA0kN8gELQcAAIQYgAkHAABDRNEUNjwIgAgRAELA+IAJBwAAQrTYiBkUN2QELIAEoAvwBIQogAUGgAWogAUHIAGpBKPwKAAAgBGshCyABQQA2AsgBIAFBpAFqIQxBACEFA0AgAUGIAmohDUECIQkgASgCvAEiBCABKALAAUcEfwJAAkAgASgCpAFFDQAgBCABKAK0AU8N8gEgASgCqAEgASgCsAEgBGoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBEEBajYCvAFBACEEDAELIAEgBEEBajYCvAEgAUEQaiABQaABaiAEEK0qIAFBjAJqIAEoAhAgASgCFBCxDCABKAKMAkGTgICAeEYiBARAIAEoApACIQkMAQsgAUGMAmoQiBELIAEgBDYCiAIgASABKALIASIHQQFqNgLIASABQYQCagUgDQsgCTYCAAJAAkACQCABKAKIAiIJQQJHBEAgBSAGaiEEIAlBAXFFDQEgBCABKAKEAjYCACAKIAdBA3ZqIgQgBC0AAEEBIAdBB3F0cjoAAAwCCwJAIAEoAqQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAwQ+x4LIAEgBUECdSIENgKMAiAEIAEoAvABRw2UAiABKAL8ASEEIAEoAoACIQUgASABKQL0ATcCrAEgAUEANgKoASABIAU2AqQBIAEgBDYCoAEgAUEIaiABQaABaiIHENc7IAEoAgghCRCwPkEcQQQQrTYiBEUN6AEgBEKBgICAEDcCACAEIAEpAqABNwIIIARBEGogAUGoAWoiCikCADcCACAEQRhqIAFBsAFqIgwoAgA2AgAgASACNgKwASABQoCAgICACDcCqAEgASADNgKkASABIAY2AqABIAEgBxDXOyABKAIAIQYQsD5BHEEEEK02IgINAgzoAQsgBEEANgIACyAFQQRqIQUMAQsLIAJCgYCAgBA3AgAgAiABKQKgATcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAEgBTYC/AEgASAJNgL4ASABIAQ2AvQBELA+QQxBBBCtNiIERQ3mASAEIAM2AgggBCAGNgIEIAQgAjYCACABQQE2ApQCIAEgBDYCkAIgAUEBNgKMAiABQQA2AlAgAUKAgICAwAA3AkggAUGgAWoiAkH48/8AIAsgASABQfQBaiABQYwCaiABQcgAaiIDEIwTIAMgAhCvEwwBCyABQagBaiACKAIANgIAIAEgASkDeDcDoAEgAUHIAGogAUGgAWoQ4QgLELA+QThBBBCtNiICRQ3PASACQoGAgIAQNwIAIAJBCGogAUHIAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQaACaiQADAELQZCMgAEQsjsACwzHAQtBACEHQQAhCSMAQaACayIBJAAgAUEYaiAFIAYoAhARAAAgAUGgAWoiAiABKAIYIgMgASgCHCgCDBEAAAJAAkAgA0UNACABKQOgAUKrmJHxlfrV/IB/hSABKQOoAUKWlPir8LHps+EAhYRQRQ0AIAFBJGoiBSADENgqAkACQAJAIAQtADRFBEAgAiAFQST8CgAAIAEgAjYCxAEgAUHIAGogAhDfFyABQYABaiICIAFB1ABqKAIANgIAIAEgASkCTDcDeCABKAJIIgNBk4CAgHhGDQEgASgCWCEEIAAgASkDeDcCBCAAIAQ2AhAgACADNgIAIABBDGogAigCADYCAAwDCyABQfgAaiICIAFBJGpBJPwKAAAgASABQaABajYCnAEgAhCQOxogASgClAEhBCACEJA7IAFByABqIgMgAkEo/AoAACADEJA7GiABKAJkIQIgASADEJA7IAJrIgI2AvABIAFB9AFqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBA3QiAyECIANBOHEiBgRAIAMgBmtBQGsiAiADSQ3xAQtBwAAhBiACQcAAENE0RQ2OAiACBEAQsD4gAkHAABCtNiIGRQ3YAQsgASgC/AEhCyABQaABaiABQcgAakEo/AoAACAEayEMIAFBADYCyAEgAUGkAWohDUEAIQUDQCABQYgCaiEOQQIhCiABKAK8ASIEIAEoAsABRwR/IAECfwJAAkAgASgCpAEEQCAEIAEoArQBTw3zASABKAKoASABKAKwASAEaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXENAQsgASAEQQFqNgK8ASABQRBqIAFBoAFqIAQQrSogAUGMAmogASgCECABKAIUEOAHIAEoAowCQZOAgIB4RgRAIAEoApQCIQogASgCkAIhCUEBDAMLIAFBjAJqEIgRDAELIAEgBEEBajYCvAELQQALNgKIAiABIAEoAsgBIgdBAWo2AsgBIAFBhAJqBSAOCyAKNgIAAkACQAJAIAEoAogCIgpBAkcEQCAFIAZqIQQgCkEBcUUNASAEIAk2AgAgBEEEaiABKAKEAjYCACALIAdBA3ZqIgQgBC0AAEEBIAdBB3F0cjoAAAwCCwJAIAEoAqQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgBUEDdSIENgKMAiAEIAEoAvABRw2TAiABKAL8ASEEIAEoAoACIQUgASABKQL0ATcCrAEgAUEANgKoASABIAU2AqQBIAEgBDYCoAEgAUEIaiABQaABaiIHENc7IAEoAgghCRCwPkEcQQQQrTYiBEUN5wEgBEKBgICAEDcCACAEIAEpAqABNwIIIARBEGogAUGoAWoiCikCADcCACAEQRhqIAFBsAFqIgsoAgA2AgAgASACNgKwASABQoCAgICACDcCqAEgASADNgKkASABIAY2AqABIAEgBxDXOyABKAIAIQYQsD5BHEEEEK02IgINAgznAQsgBEEANgIAIARBBGpBADYCAAsgBUEIaiEFDAELCyACQoGAgIAQNwIAIAIgASkCoAE3AgggAkEQaiAKKQIANwIAIAJBGGogCygCADYCACABIAU2AvwBIAEgCTYC+AEgASAENgL0ARCwPkEMQQQQrTYiBEUN5QEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKUAiABIAQ2ApACIAFBATYCjAIgAUEANgJQIAFCgICAgMAANwJIIAFBoAFqIgJBhPT/ACAMIAEgAUH0AWogAUGMAmogAUHIAGoiAxCMEyADIAIQrBMMAQsgAUGoAWogAigCADYCACABIAEpA3g3A6ABIAFByABqIAFBoAFqENkICxCwPkE4QQQQrTYiAkUNzgEgAkKBgICAEDcCACACQQhqIAFByABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGgAmokAAwBC0GQjIABELI7AAsMxgELIAAhAiMAQbACayIDJAAgA0EYaiAFIAYoAhARAAAgA0GgAWoiASADKAIYIgUgAygCHCgCDBEAAAJAAkACQAJAAkACQAJAIAVFDQAgAykDoAFCq5iR8ZX61fyAf4UgAykDqAFClpT4q/Cx6bPhAIWEUEUNACADQSRqIgYgBRDYKiAELQA0RQRAIAEgBkEk/AoAACADIAE2AsQBIANByABqIAEQ1RcgA0GAAWoiASADQdQAaigCADYCACADIAMpAkw3A3ggAygCSCIEQZOAgIB4Rg0CIAMoAlghAiAAIAMpA3g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMBQsgA0H4AGoiACADQSRqQST8CgAAIAMgA0GgAWo2ApwBIAAQkDsaIAMoApQBIQkgABCQOyEKIANByABqIgEgAEEo/AoAACABEJA7GiADKAJkIQAgAyABEJA7IABrIgA2AuQBIANB6AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDe0BCyADKALwASELIANBoAFqIANByABqQSj8CgAAIANBADYCyAEgASEAIAMoArwBIgUgAygCwAFGDQQgA0GYAmpBBHIhDCADQaACaiEHA0ACQAJAAkACQCADKAKkAQRAIAUgAygCtAFPDfYBIAMoAqgBIAMoArABIAVqIg1BA3ZqLQAAQf8BcyANQQdxdkEBcQ0BCyADIAVBAWo2ArwBIANBEGogA0GgAWogBRCtKiADQZgCaiADKAIQIAMoAhQQ6RwCQCADKAKYAiIFRQRAIANBkAJqIAdBCGopAwA3AwAgAyAHKQMANwOIAgwBCyAFDQILIANBgAJqIANBkAJqKQMAIhs3AwAgAyADKQOIAiIcNwP4ASADIAMoAsgBIgVBAWo2AsgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiINIA0tAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgK8AQwBCyAMEIgRCyADQYACaiADQZACaikDADcDACADIAMpA4gCNwP4ASADIAMoAsgBQQFqNgLIASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCvAEiBSADKALAAUcNAAsMBAtB/Pb/AEEpIANBoAFqQfj6/wBBqPf/ABDVHgALDPEBC0GQjIABELI7AAsgA0GoAWogASgCADYCACADIAMpA3g3A6ABIANByABqIANBoAFqEM4IDAELAkAgAygCpAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GkAWoQ+x4LIAMgACABa0EEdSIANgKYAiAAIAMoAuQBRw0CIAMoAvABIQAgAygC9AEhBSADIAMpAugBNwKsASADQQA2AqgBIAMgBTYCpAEgAyAANgKgASADQQhqIANBoAFqIgcQ1zsgAygCCCELELA+QRxBBBCtNiIARQ3hASAAQoGAgIAQNwIAIAAgAykCoAE3AgggAEEQaiADQagBaiIMKQIANwIAIABBGGogA0GwAWoiDSgCADYCACADIAQ2ArABIANCgICAgIAINwKoASADIAY2AqQBIAMgATYCoAEgAyAHENc7IAMoAgAhBBCwPkEcQQQQrTYiAUUEQAziAQsgAUKBgICAEDcCACABIAMpAqABNwIIIAFBEGogDCkCADcCACABQRhqIA0oAgA2AgAgAyAFNgKQAiADIAs2AowCIAMgADYCiAIQsD5BDEEEEK02IgBFDeMBIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYCoAIgAyAANgKcAiADQQE2ApgCIANBADYCUCADQoCAgIDAADcCSCADQaABaiIAQdDy/wAgCiAJayADIANBiAJqIANBmAJqIANByABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUNzQEgAEKBgICAEDcCACAAQQhqIANByABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GwAmokAAwBCyADQgA3AqwBIANCgYCAgMAANwKkASADQZTy/wA2AqABQQAgA0GYAmogA0HkAWogA0GgAWpBnPL/ABCvKwALDMUBCyAMQQJrQQhJDaQBDK0BCyAMQQNrDhAODxAREhMUFRYXrQG6AboBugG6Aa8BugELIAxBAmsOERe5ARgZGhscHR4fIKwBuQG5AbkBuQGuAbkBCyAMQQJrDhEgIbgBIiMkJSYnKCmrASosK7gBrQG4AQsgDEECaw4RLi8wtwExMjM0NTY3qgE6OLcBOawBtwELIAxBAmsOETw9Pj+2AUBBQkNERakBtgG2AbYBtgGrAbYBCyAMQQJrDhFFRkdISbUBSktMTU6oAbUBtQG1AbUBqgG1AQsgDEECaw4RTk9QUVJTtAFUVVZXpwG0AbQBtAG0AakBtAELIAxBAmsOEVdYWVpbXF2zAV5fYKYBswGzAbMBswGoAbMBCyAMQQJrDhFgYWJjZGVmZ7IBaGmlAbIBsgGyAbIBpwGyAQsgDEECaw4RaWprbG1ub3BxsQFypAGxAbEBsQGxAaYBsQELIAxBAmsOEXJzdHV2d3h5enuwAaMBsAGwAbABsAGlAbABCwJAIAxBDWsOBqMBsAF9sAGwAaUBAAsgDEEEaw4Ce32vAQsCQCAMQQ1rDgaiAX+vAa8BrwGkAQALIAxBBGsOAn99rgELIAxBDWsOBqABrQGtAX+AAaIBngELIAxBDWsOBp8BrAGsAYkBigGhAYgBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRDQBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghENEDELA+QThBBBCtNiICRQ28ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ27ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMtAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshENgFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ4gMQsD5BOEEEEK02IgJFDbsBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDboBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyzAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQ3QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDhAxCwPkE4QQQQrTYiAkUNugEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNuQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDLIBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRD7BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchEPQDELA+QThBBBCtNiICRQ25ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ24ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMsQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPAhEPEFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8CEQ7gMQsD5BOEEEEK02IgJFDbgBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbcBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwywAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQ7QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRDtAxCwPkE4QQQQrTYiAkUNtwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNtgEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDK8BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRD1BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhEOsDELA+QThBBBCtNiICRQ22ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ21ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMrgELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPQhEMYHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9CEQwAUQsD5BOEEEEK02IgJFDbUBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbQBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwytAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQxwUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDIAxCwPkE4QQQQrTYiAkUNtAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNswEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKwBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhDMBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiEMYDELA+QThBBBCtNiICRQ2zASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2yASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMqwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEJIIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQvQUQsD5BOEEEEK02IgJFDbIBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbEBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyqAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQ0wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRDNAxCwPkE4QQQQrTYiAkUNsQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNsAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKkBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRDVBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhEMsDELA+QThBBBCtNiICRQ2wASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2vASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMqAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJUIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQvwUQsD5BOEEEEK02IgJFDa8BIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDa4BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwynAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQ4wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRDdAxCwPkE4QQQQrTYiAkUNrgEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNrQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKYBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRDcBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhENMDELA+QThBBBCtNiICRQ2tASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2sASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMpQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEOoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ1AMQsD5BOEEEEK02IgJFDawBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDasBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwykAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqgcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCvBRCwPkE4QQQQrTYiAkUNqwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNqgEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKMBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRC0BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEMADELA+QThBBBCtNiICRQ2qASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2pASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMogELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEMYFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQvgMQsD5BOEEEEK02IgJFDakBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDagBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyhAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8iEQmAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDyIRC5BRCwPkE4QQQQrTYiAkUNqAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNpwEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKABCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRCCCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghEJsFELA+QThBBBCtNiICRQ2nASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2mASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMnwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhENcFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQzAMQsD5BOEEEEK02IgJFDaYBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDaUBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyeAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQlwggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRC3BRCwPkE4QQQQrTYiAkUNpQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNpAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJ0BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRCHCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJoFELA+QThBBBCtNiICRQ2kASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2jASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMnAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEO8FIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQ2wMQsD5BOEEEEK02IgJFDaMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDaIBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwybAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQ5wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRDWAxCwPkE4QQQQrTYiAkUNogEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNoQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJoBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCsByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEKoFELA+QThBBBCtNiICRQ2hASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2gASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMmQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEMkFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQwQMQsD5BOEEEEK02IgJFDaABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZ8BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyYAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQxAUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhC7AxCwPkE4QQQQrTYiAkUNnwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNngEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJcBCyMAQTBrIgEkACABIAUgBhD/IRDvJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwycAQsMlgELIAktAAEOAgECjAELIAhB0ABqIAUgBkHQvP8AIAQQhgEgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADJUBCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBBgL3/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNlAEgABC7IwyUAQsjAEEwayIBJAAgASAFIAYQ/iEQ7yQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMmQELDJMBCyMAQTBrIgEkACABIAUgBhDxIRDvJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwyYAQsMkgELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEJMIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQuwUQsD5BOEEEEK02IgJFDZkBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZgBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyRAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQhAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRCdBRCwPkE4QQQQrTYiAkUNmAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNlwEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJABCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRCICCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEJwFELA+QThBBBCtNiICRQ2XASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2WASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMjwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJEIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQvAUQsD5BOEEEEK02IgJFDZYBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZUBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyOAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQhgggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCiBRCwPkE4QQQQrTYiAkUNlQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNlAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDI0BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRCLCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhEKMFELA+QThBBBCtNiICRQ2UASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2TASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMjAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEIkGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ3wMQsD5BOEEEEK02IgJFDZMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZIBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyLAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqwcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCrBRCwPkE4QQQQrTYiAkUNkgEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNkQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDIoBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRDfBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEL0DELA+QThBBBCtNiICRQ2RASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2QASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMiQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEPkFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQxAMQsD5BOEEEEK02IgJFDZABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDY8BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyIAQsjAEEwayIBJAAgASAFIAYQ+iEQ7CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMjQELDIcBCyAJLQABQQJrDgIBAn0LIAhB0ABqIAUgBkGAvf8AIAQQhgEgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADIYBCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBB0Lz/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNhQEgABC7IwyFAQsjAEEwayIBJAAgASAFIAYQ5SEQ7CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMigELDIQBCyMAQTBrIgEkACABIAUgBhDtIRDsJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwyJAQsMgwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEPoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQ8wMQsD5BOEEEEK02IgJFDYoBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYkBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyCAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQ6AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRDpAxCwPkE4QQQQrTYiAkUNiQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNiAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDIEBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRDmBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEOwDELA+QThBBBCtNiICRQ2IASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2HASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMgAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEPcFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQ6gMQsD5BOEEEEK02IgJFDYcBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYYBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx/CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRDuBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEOkDELA+QThBBBCtNiICRQ2GASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2FASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMfgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQ7AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRDsAxCwPkE4QQQQrTYiAkUNhQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNhAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDH0LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEPYFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ6gMQsD5BOEEEEK02IgJFDYQBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYMBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx8CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRDFByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEL4FELA+QThBBBCtNiICRQ2DASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2CASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMewsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQwgUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDHAxCwPkE4QQQQrTYiAkUNggEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNgQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHoLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEMsFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQyQMQsD5BOEEEEK02IgJFDYEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYABIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx5CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRD0BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhEOMDELA+QThBBBCtNiICRQ2AASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1/IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx4CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRDkBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghENwDELA+QThBBBCtNiICRQ1/IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDX4gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHcLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshENoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ2AMQsD5BOEEEEK02IgJFDX4gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNfSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMdgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQ6QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDVAxCwPkE4QQQQrTYiAkUNfSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ18IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx1CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRCQCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchELgFELA+QThBBBCtNiICRQ18IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXsgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHQLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhENsFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQ2AMQsD5BOEEEEK02IgJFDXsgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNeiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMcwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQ6wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRDVAxCwPkE4QQQQrTYiAkUNeiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ15IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxyCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCtByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEK0FELA+QThBBBCtNiICRQ15IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hELUFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQuQMQsD5BOEEEEK02IgJFDXggAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNdyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMcAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQwwUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhC8AxCwPkE4QQQQrTYiAkUNdyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ12IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxvCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRDZBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhEOQDELA+QThBBBCtNiICRQ12IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXUgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDG4LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPghENIFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+CEQ2QMQsD5BOEEEEK02IgJFDXUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNdCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMbQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQ8AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRDeAxCwPkE4QQQQrTYiAkUNdCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1zIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxsCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRDiBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhENIDELA+QThBBBCtNiICRQ1zIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGsLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJYIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQugUQsD5BOEEEEK02IgJFDXIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNcSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMagsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQgwggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCkBRCwPkE4QQQQrTYiAkUNcSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1wIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxpCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRDlBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhENIDELA+QThBBBCtNiICRQ1wIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDW8gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGgLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPQhEKkHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9CEQrgUQsD5BOEEEEK02IgJFDW8gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNbiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMZwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQyAUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDDAxCwPkE4QQQQrTYiAkUNbiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1tIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxmCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhDFBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiELoDELA+QThBBBCtNiICRQ1tIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWwgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGULIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEIQGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQ5QMQsD5BOEEEEK02IgJFDWwgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNayACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMZAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQgQYgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRDXAxCwPkE4QQQQrTYiAkUNayACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1qIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxjCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRCFBiABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEM4DELA+QThBBBCtNiICRQ1qIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWkgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGILIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEIgGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQ4AMQsD5BOEEEEK02IgJFDWkgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNaCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMYQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQlAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRC2BRCwPkE4QQQQrTYiAkUNaCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1nIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxgCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRCJCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJ4FELA+QThBBBCtNiICRQ1nIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWYgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDF8LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEIEIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQnwUQsD5BOEEEEK02IgJFDWYgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNZSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMXgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqAcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCsBRCwPkE4QQQQrTYiAkUNZSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1kIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxdCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRDgBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEL8DELA+QThBBBCtNiICRQ1kIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWMgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFwLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEPgFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQwgMQsD5BOEEEEK02IgJFDWMgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNYiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMWwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8iEQmQQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDyIRD2AhCwPkE4QQQQrTYiAkUNYiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1hIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxaCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRCYBCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghEPQCELA+QThBBBCtNiICRQ1hIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFkLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshEJMEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ8QIQsD5BOEEEEK02IgJFDWAgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNXyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMWAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQlAQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDwAhCwPkE4QQQQrTYiAkUNXyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1eIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxXCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRCHBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchEIUDELA+QThBBBCtNiICRQ1eIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDV0gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFYLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPAhEMEEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8CEQhAMQsD5BOEEEEK02IgJFDV0gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNXCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMVQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQvAQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRCBAxCwPkE4QQQQrTYiAkUNXCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1bIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxUCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRC9BCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhEIADELA+QThBBBCtNiICRQ1bIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVogAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFMLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEJoEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQ9QIQsD5BOEEEEK02IgJFDVogAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNWSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMUgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQlQQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhDvAhCwPkE4QQQQrTYiAkUNWSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1YIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxRCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRCMCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhELEFELA+QThBBBCtNiICRQ1YIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVcgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFALIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPghEPMHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+CEQjQUQsD5BOEEEEK02IgJFDVcgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNViACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMTwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQhQggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRCgBRCwPkE4QQQQrTYiAkUNViACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1VIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxOCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRD5ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhEJgFELA+QThBBBCtNiICRQ1VIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVQgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDE0LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEI8IIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQsAUQsD5BOEEEEK02IgJFDVQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNUyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMTAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQ9QcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCSBRCwPkE4QQQQrTYiAkUNUyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1SIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxLCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRD/ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhEKEFELA+QThBBBCtNiICRQ1SIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEoLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEPcHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQlQUQsD5BOEEEEK02IgJFDVEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNUCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMSQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQ1gUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCRAxCwPkE4QQQQrTYiAkUNUCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1PIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxICyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhD0ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiEJcFELA+QThBBBCtNiICRQ1PIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDU4gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEcLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEI0IIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQswUQsD5BOEEEEK02IgJFDU4gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNTSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMRgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQ+AcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRCPBRCwPkE4QQQQrTYiAkUNTSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1MIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxFCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRD8ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEI4FELA+QThBBBCtNiICRQ1MIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUsgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEQLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEIoIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQpgUQsD5BOEEEEK02IgJFDUsgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNSiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMQwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQjgggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRCyBRCwPkE4QQQQrTYiAkUNSiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1JIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxCCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRD7ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJMFELA+QThBBBCtNiICRQ1JIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEPYHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQkQUQsD5BOEEEEK02IgJFDUggAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNRyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMQAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQgAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRClBRCwPkE4QQQQrTYiAkUNRyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1GIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACww/CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCIBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEIYDELA+QThBBBCtNiICRQ1GIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUUgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDD4LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEPoHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQkAUQsD5BOEEEEK02IgJFDUUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNRCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMPQsjAEEwayIBJAAgASAFIAYQ+yEQ9CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABByNX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMQgsMPAsgBSAGEPohIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhD2GiACIAQQ6BggCEHQAGoiBCACIAMQ0h0gAUFAayQAIAQQ3CkhASAAQcjV/wA2AgggACABNgIEIABBk4CAgHg2AgAMOwsgCEHQAGogBSAGQYC9/wAgBBCGASAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMOwsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AQdDi/wAgBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDTogABC7Iww6CyMAQTBrIgEkACABIAUgBhDzIRDtJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHw1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCww/Cww5CyAFIAYQ/yEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOkaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAIQdAAaiAFIAZB0OL/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAw4CyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBB3OL/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNNyAAELsjDDcLIAMtAAEOAgECLQsgAy0AAQ4CAgMsCyAJLQABQQFHDSsgBSAGEPEhIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEI8vIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhD1GiACIAQQ6BggCEHQAGoiBCACIAMQzB0gAUFAayQAIAQQ3CkhASAAQZjU/wA2AgggACABNgIEIABBk4CAgHg2AgAMNAsgCS0AAQ0qIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ7xogAiAEEOgYIAhB0ABqIgQgAiADENcdIAFBQGskACAEENwpIQEgAEHQ1/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAktAAFBAmsOAgECKQsgCS0AAUECaw4CAgMoCyAFIAYQ5SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOcaIAIgBBDoGCAIQdAAaiIEIAIgAxDMHSABQUBrJAAgBBDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwwCyAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEO4aIAIgBBDoGCAIQdAAaiIEIAIgAxDMHSABQUBrJAAgBBDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwvCyAFIAYQ5SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEPAaIAIgBBDoGCAIQdAAaiIEIAIgAxDXHSABQUBrJAAgBBDcKSEBIABB0Nf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwuCyAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOcaIAIgBBDoGCAIQdAAaiIEIAIgAxDXHSABQUBrJAAgBBDcKSEBIABB0Nf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwtCyAMQQVHDSMgAy0AAUECaw4CAgMjCyADLQABQQJrDgIDBCILIAMtAAFBAmsOAggJIQsjAEEwayIBJAAgASAFIAYQ8yEQ7iQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBoNb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMLwsMKQsjAEEwayIBJAAgASAFIAYQ8yEQ8SQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB+Nb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMLgsMKAsgCS0AAQ4CAQIeCyAJLQABDgICAx0LIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ6BogAiAEEL0YIAhB0ABqIgQgAiADEMIdIAFBQGskACAEENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCULIAUgBhDxISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ8hogAiAEEL0YIAhB0ABqIgQgAiADEMIdIAFBQGskACAEENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCQLIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ5BogAiAEEL0YIAhB0ABqIgQgAiADENUdIAFBQGskACAEENwpIQEgAEH41v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIAUgBhDxISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ9BogAiAEEL0YIAhB0ABqIgQgAiADENUdIAFBQGskACAEENwpIQEgAEH41v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCILIAktAAFBA0cNGCAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOYaIAIgBBC9GCAIQdAAaiIEIAIgAxDCHSABQUBrJAAgBBDcKSEBIABBoNb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAJLQABQQJHDRcgBSAGEOUhIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhDjGiACIAQQvRggCEHQAGoiBCACIAMQ1R0gAUFAayQAIAQQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIAsCQAJAAkACQAJAAkACQAJAIAxBA2sOBwECAwQFBgcACyMAQfAAayIBJAAgAUEEaiIEIAUgBhDyISICQQxqEKg+QQEQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNLiACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCYLIwBB8ABrIgEkACABQQRqIgQgBSAGEPghIgJBDGoQ2TxBAhCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0tIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMJQsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ+yEiAkEMahDbPEEEEIIRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDvHBCwPkHEAEEEEK02IgJFDSwgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwkCyMAQfAAayIBJAAgAUEEaiIEIAUgBhDzISICQQxqENg8QQgQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNKyACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCMLIwBB8ABrIgEkACABQQRqIgQgBSAGEPchIgJBDGoQqD5BARCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0qIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIgsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8CEiAkEMahDZPEECEIIRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDvHBCwPkHEAEEEEK02IgJFDSkgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwhCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD1ISICQQxqENs8QQQQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNKCACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCALIwBB8ABrIgEkACABQQRqIgQgBSAGEOwhIgJBDGoQ2DxBCBCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0nIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMHwsgDEECa0EITw0HAkACQAJAAkACQAJAAkACQCAMQQNrDgcBAgMEBQYHAAsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8iEiAkEMahCoPkEBEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDS0gAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwlCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD4ISICQQxqENk8QQIQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNLCACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCQLIwBB8ABrIgEkACABQQRqIgQgBSAGEPshIgJBDGoQ2zxBBBCKESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ8BwQsD5BxABBBBCtNiICRQ0rIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIwsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8yEiAkEMahDYPEEIEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDSogAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwiCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD3ISICQQxqEKg+QQEQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNKSACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCELIwBB8ABrIgEkACABQQRqIgQgBSAGEPAhIgJBDGoQ2TxBAhCKESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ8BwQsD5BxABBBBCtNiICRQ0oIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIAsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ9SEiAkEMahDbPEEEEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDScgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwfCyMAQfAAayIBJAAgAUEEaiIEIAUgBhDsISICQQxqENg8QQgQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNJiACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDB4LIAkQsChFDQYLIAAgBSAGIAQQkQkMHAsgCRCwKEUNBAsgACAFIAYgBBCSCQwaCyAJELAoRQ0CCyAAIAUgBiAEEKcBDBgLIAxBBEcNDgJAAkAgAy0AAQ4CAAEQCyMAQTBrIgEkACABIAUgBhD7IRDyJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGY1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwweCwwYCyMAQTBrIgEkACABIAUgBhD7IRDwJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHQ1/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwwdCwwXCyAMQQ1GDQBBACEBIAwhAgwBCwJAAkACQAJAAkAgCS0AAUEBaw4DAQIDAAsgAxCRNkUNAyAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEPYhEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDB8LIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwaCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNGSAAELsjDBkLIAMQkTZFDQIgCEHQAGohASMAQTBrIgIkACACIAUgBhDpIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwweCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGQsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDRggABC7IwwYCyADEJE2RQ0BIAhB0ABqIQEjAEEwayICJAAgAiAFIAYQ5iEQ7CQQsD4CQEE4QQQQrTYiAwRAIANCgYCAgBA3AgAgA0EIaiACQTD8CgAAIAFB6NL/ADYCCCABIAM2AgQgAUGTgICAeDYCACACQTBqJAAMAQsMHQsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAIKAJIIAQQhgEgCCgCkAIiASABKAIAIgFBAWs2AgAgAUEBRw0XIAAQuyMMFwsgAxCRNkUNACAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEPkhEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDBwLIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwXCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNFiAAELsjDBYLQQEhAUENIQILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA1BDWsOBgECAwQFAA4LIAkQkTYNBQwNCyAJEJE2RQRAAkACQAJAAkACQAJAAkACQAJAAkACQCACQQ1rDgYCAAEkJBkkCyADLQABQQFrDgMDBAUCCyADLQABQQFrDgMGBwgFCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIFQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBTYCAAwrCyAIIAE2AowDIAggAjYCiAMgCEGIA2oQih4hAgJAAkAgCS0AAUEDdEGg7v8AaikDACIbIAMtAAFBA3RBoO7/AGopAwAiHFUgGyAcU2tB/wFxDgIBEgALIAggHKcgG6durTcDwAMgBC0ANA0PIAhB0ABqIAIgCEHAA2oQzgUgCC0AUCIBQSlHDRAgCEGjAmogCEHkAGooAgAiATYAACAIQZsCaiAIQdwAaikCACIbNwAAIAggCCkCVCIcNwCTAiAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwVCyAIQZADaiACEIAVDBMLIAUgBhD/ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ8RogAiADEL0YIAhB0ABqIgMgAiAFENQdIAFBQGskACAAIANBqNj/ACAIKAJIIAQQhgEgAxD3JAwpCyAFIAYQ/yEhAiMAQUBqIgEkACABQQxqIgUgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgMgAUEwaiICEOkaIAIgAxC9GCAIQdAAaiIDIAIgBRDIHSABQUBrJAAgACADQYDZ/wAgCCgCSCAEEIYBIAMQ9yQMKAsgBSAGEP8hIQIjAEFAaiIBJAAgAUEMaiIFIAIQkjYQ7iUgASACQQxqEI8vIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIDIAFBMGoiAhDrGiACIAMQvRggCEHQAGoiAyACIAUQyR0gAUFAayQAIAAgA0HY2f8AIAgoAkggBBCGASADEPckDCcLIAUgBhD/ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ7RogAiADEL0YIAhB0ABqIgMgAiAFENEdIAFBQGskACAAIANBsNr/ACAIKAJIIAQQhgEgAxD3JAwmCyAFIAYQ+iEhAiMAQUBqIgEkACABQQxqIgUgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgMgAUEwaiICEOYaIAIgAxC9GCAIQdAAaiIDIAIgBRDUHSABQUBrJAAgACADQajY/wAgCCgCSCAEEIYBIAMQ9yQMJQsgCEHQAGoiASAFIAYQ+iEQ9SQgACABQYDZ/wAgCCgCSCAEEIYBIAEQ9yQMJAsgBSAGEPohIQIjAEFAaiIBJAAgAUEMaiIFIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIDIAFBMGoiAhDjGiACIAMQvRggCEHQAGoiAyACIAUQyR0gAUFAayQAIAAgA0HY2f8AIAgoAkggBBCGASADEPckDCMLIAUgBhD6ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ6hogAiADEL0YIAhB0ABqIgMgAiAFENEdIAFBQGskACAAIANBsNr/ACAIKAJIIAQQhgEgAxD3JAwiCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIEQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwiCyAIIAE2ApQCIAggAjYCkAIgCEEQaiAIQZACahCKHiAIKAJILQABIAsgCwR/IAsgCygCACIBQQFqNgIAIAFBAEgNIyADKAIIBSADCxDwByAAIAgpAxA3AgQgAEGTgICAeDYCACAIKAKQAiIAIAAoAgAiAEEBazYCACAAQQFHDSEgCEGQAmoQuyMMIQsgAUUNCwJAAkACQAJAIAktAAFBAWsOAwECAwALIAUgBhD2ISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/QUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCWBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSogAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCMLIAUgBhDpISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/gUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCbBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSkgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCILIAUgBhDmISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQgAYMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCYBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCELIAUgBhD5ISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/wUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCfBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDScgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCALIAFFDQoCQAJAAkACQCAJLQABQQFrDgMAAQIDCyMAQTBrIgEkACABIAUgBhDpIRDtJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHw1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwwoCwwiCyAFIAYQ5iEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOYaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAFIAYQ+SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEPMaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwgCyAELQA0DQYgCEHQAGohByAFIAYQ9iEhBSMAQfABayIBJAAgBUEMahDYPCEGIAFBMGogBRCSNhDuJSAGQQN0IgQhAgJAAkACfgJAAkACQCAEQThxIgMEQCAEIANrQUBrIgIgBEkNawtBwAAhAyACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiA0UNMwsgASADNgJQIAEgAjYCTCABQcAANgJIIAQEQCADQQAgBPwLAAsgASAGNgJYIAEgBDYCVCABKAIwRQ0BIAEoAkQgASgCQEYNAiABQegAaiABQTBqEMg0IAFBiAFqIQIgBSgCECEEIAEpA5ABIRsDQAJAIBtQRQRAIAEpA5gBIRwMAQsDQAJ+AkAgASkDeCIcQgNSBEACQAJAAkAgHEICUQ0AIAEgHFCtQgGGNwN4IBynQQFxRQ0AIAEgASkDgAE3A8gBDAELIAEoAogBRQ0BIAFBwAFqIAIQtiogASkDwAEhHAsgHEIAUg0CCyABQgM3A3gLIAEpA2giHEICUQ0HIAFCADcDaCABKQNwDAELIAEpA8gBCyEbIBynQQFxRQ0FIAEgASkDmAFCQH0iHDcDmAEgASAbNwOQASAbUA0ACwsgAUIBIBt6Ih2GIBuFIhs3A5ABIAQgHacgHKdqQQN0IgVqKQMAIRwgAULoBzcD6AEgASAcNwOgASABQSBqIBwgHEI/h0LoB0IAEKgeIAEpAyggASkDICIcQj+HUQRAIAMgBWogHDcDAAwBCwsgAUECNgLEASABQayQ/wA2AsABIAFCAjcCzAEgAUGGDDYC5AEgAUGGDDYC3AEgASABQdgBajYCyAEgASABQegBajYC4AEgASABQaABajYC2AEgAUGwAWogAUHAAWoQmQ4gASkCuAEhGyABKQKwAQwEC0Hci/8AQSkgAUHoAGpB7I//AEGIjP8AENUeAAsgBkUNACAFKAIQIQRBACECA0AgBCkDACEbIAFC6Ac3A9gBIAEgGzcD6AEgAUEQaiAbIBtCP4dC6AdCABCoHiABKQMYIAEpAxAiG0I/h1INAiADIBs3AwAgA0EIaiEDIARBCGohBCAGIAJBAWoiAkcNAAsLIAFB6ABqIgMQlykgAUHQAGoiAigCACEGIAEoAlQhBCACIAFB8ABqIgUpAgA3AwAgASkDSCEbIAEgASkCaDcDSCABQQA2AlggASAbNwJ0IAFBADYCcCABIAQ2AmwgASAGNgJoIAFBCGogAxDXOyABKAIIIQYQsD5BHEEEEK02IgJFDTsgAkKBgICAEDcCACACIAEpAmg3AgggAkEQaiAFKQIANwIAIAJBGGogAUH4AGoiCSgCADYCACABIAQ2AsgBIAEgBjYCxAEgASACNgLAASABQdwAaiICIAFBwAFqEOQZIAkgAUFAaykCADcDACAFIAFBOGopAgA3AwAgASABKQIwNwNoIAcgAiADEMQdIAFByABqEM8vDAILIAFBAjYCbCABQayQ/wA2AmggAUICNwJ0IAFBhgw2ArgBIAFBhgw2ArABIAEgAUGsAWo2AnAgASABQdgBajYCtAEgASABQegBajYCrAEgAUHEAWogAUHoAGoQmQ4gASkCzAEhGyABKQLEAQshHCAHIBs3AhAgByAcNwIIIAdBiICAgHg2AgQgB0EpOgAAIAFByABqEM8vIAEoAjAiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEwahD7HgsgAUHwAWokAAwACyAILQBQIgFBKUYEQCAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADCALIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbACaiAIQfAAaikCADcCACAIQbgCaiAIQfgAaikCADcCACAIQZkCaiADKQMANwAAIAhBoAJqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCqAIgCCAbNwCRAiAIIAE6AJACDAcLIAFFDQkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQABDgIAASsLIAktAAFBAWsOAwIDBAELIAktAAFBAWsOAxESExALQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADDkLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ9iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDYMBC0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1LCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPERIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDIMBCyAJRQ0AIAcoAgQhCiAHKAIAIQsgBigCECEEQQAhBwNAIAFBQGsgBCkDACALIAoQ8REgASgCRCECIAEoAkAiBkGTgICAeEcNAiADIAI2AgAgA0EEaiEDIARBCGohBCAJIAdBAWoiB0cNAAsLIAFBQGsiAxCXKSABQShqIgIoAgAhByABKAIsIQQgAiABQcgAaiIGKQIANwMAIAEpAyAhGyABIAEpAkA3AyAgAUEANgIwIAEgGzcCTCABQQA2AkggASAENgJEIAEgBzYCQCABIAMQ1zsgASgCACEHELA+QRxBBBCtNiICRQ1TIAJCgYCAgBA3AgAgAiABKQJANwIIIAJBEGogBikCADcCACACQRhqIAFB0ABqIgkoAgA2AgAgASAENgKAASABIAc2AnwgASACNgJ4IAFBNGoiAiABQfgAahDlGSAJIAFBGGopAgA3AwAgBiABQRBqKQIANwMAIAEgASkCCDcDQCAFIAIgAxDMHSABQSBqEM8vDAILIAEoAkghAyABKQJMCzcCECAFIAM2AgwgBSACNgIIIAUgBjYCBCAFQSk6AAAgAUEgahDPLyABKAIIIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBCGoQ+x4LIAFBkAFqJAAMAAsgCC0AUCIBQSlGBEAgCEGjAmogCEHkAGooAgAiATYAACAIQZsCaiAIQdwAaikCACIbNwAAIAggCCkCVCIcNwCTAiAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAw4CyAIQZ8CaiICIAhB4ABqKQAANwAAIAhBmAJqIgMgCEHZAGopAAA3AwAgCEGwB2ogCEHwAGopAgA3AgAgCEG4B2ogCEH4AGopAgA3AgAgCEGZB2ogAykDADcAACAIQaAHaiACKQAANwAAIAggCCkAUSIbNwOQAiAIIAgpAmg3AqgHIAggAToAkAcgCCAbNwCRByAIQZAHahDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAIKQJUIRsgACAIKQJcNwIMIAAgGzcCBCAAIAE2AgAMNgtBASEDIAgoAlQhCQsgCCAJNgLEAyAIIAM2AsADIAUgBhDpISEGIAhBwANqIQcjAEGQAWsiASQAIAZBDGoQ2DwhCSABQQhqIAYQkjYQ7iUgCUECdCIEIQICQAJAIAhB0ABqIgUCfgJAAkACQCAEQTxxIgMEQCAEIANrQUBrIgIgBEkNgAELQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDUgLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQQgBygCBCEJIAcoAgAhByAGKAIQIQoDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogBBC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAKIB2nIBunaiILQQN0aikDACAHIAkQ8xEgASgCfCECIAEoAngiBkGTgICAeEYEQCADIAtBAnRqIAI2AgAMAQsLIAEoAoABIQMgASkChAEMBAsMgAELIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChDzESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDVAgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDULIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQZAIaiAIQfAAaikCADcCACAIQZgIaiAIQfgAaikCADcCACAIQfkHaiADKQMANwAAIAhBgAhqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCiAggCCABOgDwByAIIBs3APEHIAhB8AdqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDQLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwzC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgBSAGEOYhIQYgCEHAA2ohByMAQZABayIBJAAgBkEMahDYPCEJIAFBCGogBhCSNhDuJSAJQQJ0IgQhAgJAAkAgCEHQAGoiBQJ+AkACQAJAIARBPHEiAwRAIAQgA2tBQGsiAiAESQ19C0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1FCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPQRIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDH0LIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChD0ESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDU0gAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDILIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQfAIaiAIQfAAaikCADcCACAIQfgIaiAIQfgAaikCADcCACAIQdkIaiADKQMANwAAIAhB4AhqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcC6AggCCABOgDQCCAIIBs3ANEIIAhB0AhqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDELIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwwC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgBSAGEPkhIQYgCEHAA2ohByMAQZABayIBJAAgBkEMahDYPCEJIAFBCGogBhCSNhDuJSAJQQJ0IgQhAgJAAkAgCEHQAGoiBQJ+AkACQAJAIARBPHEiAwRAIAQgA2tBQGsiAiAESQ16C0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1CCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPIRIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDHoLIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChDyESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUogAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADC8LIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQdAJaiAIQfAAaikCADcCACAIQdgJaiAIQfgAaikCADcCACAIQbkJaiADKQMANwAAIAhBwAlqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCyAkgCCABOgCwCSAIIBs3ALEJIAhBsAlqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADC4LQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCkLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ9iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDXMLQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTsLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8REgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMcwsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPERIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUMgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMKAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhB4AdqIAhB8ABqKQIANwIAIAhB6AdqIAhB+ABqKQIANwIAIAhByQdqIAMpAwA3AAAgCEHQB2ogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwLYByAIIAE6AMAHIAggGzcAwQcgCEHAB2oQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMJwsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCYLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ6SEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDXALQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTgLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8xEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMcAsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPMRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJQsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBwAhqIAhB8ABqKQIANwIAIAhByAhqIAhB+ABqKQIANwIAIAhBqQhqIAMpAwA3AAAgCEGwCGogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwK4CCAIIAE6AKAIIAggGzcAoQggCEGgCGoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMJAsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCMLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ5iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDW0LQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTULIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ9BEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMbQsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPQRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDT0gAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMIgsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBoAlqIAhB8ABqKQIANwIAIAhBqAlqIAhB+ABqKQIANwIAIAhBiQlqIAMpAwA3AAAgCEGQCWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKYCSAIIAE6AIAJIAggGzcAgQkgCEGACWoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMIQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCALQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ+SEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDWoLQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTILIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8hEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMagsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPIRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDTogAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMHwsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBgApqIAhB8ABqKQIANwIAIAhBiApqIAhB+ABqKQIANwIAIAhB6QlqIAMpAwA3AAAgCEHwCWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwL4CSAIIAE6AOAJIAggGzcA4QkgCEHgCWoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMHgsgAUUNCAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAFBAmsOAgABKgsgCS0AAUEBaw4DAgMEAQsgCS0AAUEBaw4DERITEAtBACEDIAkoAgQiAUUNBSAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBAUDC0EAIQMgCSgCBCIBRQ0HIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIGBwULQQAhAyAJKAIEIgFFDQkgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAggJBwtBACEDIAkoAgQiAUUNCyAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CCgsJCyAIKQJUIRsgACAIKQJcNwIMIAAgGzcCBCAAIAE2AgAMOAtBASEDIAgoAlQhCQsgCCAJNgLEAyAIIAM2AsADIAhB0ABqIQcgBSAGEPYhIQUgCEHAA2ohBiMAQZABayIBJAAgBUEMahDYPCEJIAFBCGogBRCSNhDuJSAJQQN0IgMhBAJAAkACfgJAAkACQCADQThxIgIEQCADIAJrQUBrIgQgA0kNggELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDVwLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8REgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA0HoB26tIAStQsCEPX58NwMADAELCyABKQKEASEcIAStIAOtQiCGhAwECwyCAQsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPERIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNUiACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDcLIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQbAEaiAIQfAAaikCADcCACAIQbgEaiAIQfgAaikCADcCACAIQZkEaiADKQMANwAAIAhBoARqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCqAQgCCABOgCQBCAIIBs3AJEEIAhBkARqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDYLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAw1C0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ6SEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ1/C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1ZCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPMRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMfwsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPMRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNTyACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDQLIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQZAFaiAIQfAAaikCADcCACAIQZgFaiAIQfgAaikCADcCACAIQfkEaiADKQMANwAAIAhBgAVqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCiAUgCCABOgDwBCAIIBs3APEEIAhB8ARqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwyC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ5iEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ18C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1WCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPQRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMfAsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPQRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNTCACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDELIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQfAFaiAIQfAAaikCADcCACAIQfgFaiAIQfgAaikCADcCACAIQdkFaiADKQMANwAAIAhB4AVqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcC6AUgCCABOgDQBSAIIBs3ANEFIAhB0AVqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDALIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwvC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ+SEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ15C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1TCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPIRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMeQsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPIRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNSSACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADC4LIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQdAGaiAIQfAAaikCADcCACAIQdgGaiAIQfgAaikCADcCACAIQbkGaiADKQMANwAAIAhBwAZqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCyAYgCCABOgCwBiAIIBs3ALEGIAhBsAZqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADC0LQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCgLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhD2ISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDXILQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUwLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8REgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMcgsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPERIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNQiACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJwsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhB4ARqIAhB8ABqKQIANwIAIAhB6ARqIAhB+ABqKQIANwIAIAhByQRqIAMpAwA3AAAgCEHQBGogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwLYBCAIIAE6AMAEIAggGzcAwQQgCEHABGoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMJgsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCULQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhDpISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDW8LQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUkLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8xEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMbwsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPMRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNPyACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBwAVqIAhB8ABqKQIANwIAIAhByAVqIAhB+ABqKQIANwIAIAhBqQVqIAMpAwA3AAAgCEGwBWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwK4BSAIIAE6AKAFIAggGzcAoQUgCEGgBWoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIwsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCILQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhDmISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDWwLQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUYLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ9BEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMbAsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPQRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNPCACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMIQsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBoAZqIAhB8ABqKQIANwIAIAhBqAZqIAhB+ABqKQIANwIAIAhBiQZqIAMpAwA3AAAgCEGQBmogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKYBiAIIAE6AIAGIAggGzcAgQYgCEGABmoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIAsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADB8LQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhD5ISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDWkLQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUMLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8hEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMaQsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPIRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNOSACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMHgsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBgAdqIAhB8ABqKQIANwIAIAhBiAdqIAhB+ABqKQIANwIAIAhB6QZqIAMpAwA3AAAgCEHwBmogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwL4BiAIIAE6AOAGIAggGzcA4QYgCEHgBmoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMHQsgCEHQAGogBSAGQdC8/wAgBBCGASAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMHQsgCCABNgKUAiAIIAI2ApACIAhBIGogCEGQAmoiARCKHiAIKAJILQABEMERIAAgCCkDIDcCBCAAQZOAgIB4NgIAIAgoApACIgAgACgCACIAQQFrNgIAIABBAUcNHCABELsjDBwLIAhBkANqIAIgCEHAA2oQrQMMBAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIFIAhB2QBqKQAANwMAIAhBsANqIAhB8ABqKQIANwIAIAhBuANqIAhB+ABqKQIANwIAIAhBmQNqIAUpAwA3AAAgCEGgA2ogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKoAyAIIBs3AJEDIAggAToAkAMMAwsgCCAbpyAcp26tNwNQIwBBQGoiASQAIAEgCEHQAGo2AgwgAUEQaiIFIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCNCABIAFBDGo2AjwgAUEoaiIGIAFBNGoiAhDlGiACIAYQvRggCEGQA2ogAiAFENYdIAFBQGskAAwCCyAIQZACaiENIAUgBhD2ISEHQQAhCUEAIQpBACELQQAhDCMAQeABayIDJAAgB0EMahDYPCEBAkACQAJAAkAgBxCSNiIEBEBBwAAhBSADQUBrIAQQ3DsgBCgCFCECIAQoAgwhCSADKAJEIQsgAygCQCEKIAFBA3YgAUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0DIAQEQBCwPiAEQcAAEK02IgVFDTwLIANCADcCWCADIAU2AlQgAyAENgJQIANBwAA2AkwgA0HMAGogCSABIAlqIAogCxC/GAwBC0HAACEFIAFBA3YgAUEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0CIAIEQBCwPiACQcAAEK02IgVFDSkLIANCADcCWCADIAU2AlQgAyACNgJQIANBwAA2AkwgA0HMAGogARDeEEEAIQILIAFBA3QiBSEEAkAgBUE4cSIGBEAgBSAGa0FAayIEIAVJDQELQcAAIQYgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgZFDTwLIANBADYCcCADIAY2AmggAyAENgJkIANBwAA2AmAgBQRAIAUEQCAGQQAgBfwLAAsgAygCcCEMIAMoAmghBgsgAyAFNgJsIAMgASAMajYCcAJAAkAgAgRAIAEgAkcNASABIQIMBQsgAUUEQEEAIQIMBQsgBygCECEFQQAhAkEAIQQDQCADQRBqIAUpAwAiGyAbQj+HQugHQgAQqB4CQCADKQMYIAMpAxAiG0I/h1EEQCAGIBs3AwAMAQsgA0EIaiADQcwAahCGPSAEQQN2IgcgAygCDCIJTw0DIAMoAgggB2oiByAHLQAAQX4gBEEHcXdxOgAAIAJBAWohAgsgBkEIaiEGIAVBCGohBSABIARBAWoiBEcNAAsMBAsgCgRAIANBmAFqIAogCyAJIAEQvxQgA0G4AWohBSAHKAIQIQcDQAJAIAMpA8ABIhxQRQRAIAMpA8gBIRsMAQsDQAJ+AkAgAykDqAEiG0IDUgRAAkACQAJAIBtCAlENACADIBtQrUIBhjcDqAEgG6dBAXFFDQAgAyADKQOwATcD2AEMAQsgAygCuAFFDQEgA0HQAWogBRC2KiADKQPQASEbCyAbQgBSDQILIANCAzcDqAELIAMpA5gBIhtCAlENCSADQgA3A5gBIAMpA6ABDAELIAMpA9gBCyEcIBunQQFxRQ0HIAMgAykDyAFCQH0iGzcDyAEgAyAcNwPAASAcUA0ACwsgAyAcQgEgHHoiHYaFNwPAASADQTBqIAcgHacgG6dqIgFBA3QiBGopAwAiGyAbQj+HQugHQgAQqB4gAykDOCADKQMwIhtCP4dRBEAgBCAGaiAbNwMADAELIANBKGogA0HMAGoQhj0gAUEDdiIEIAMoAiwiCUkEQCADKAIoIARqIgQgBC0AAEF+IAFBB3F3cToAACACQQFqIQIMAQsLIAQgCUGIi/8AEMMhAAtBxIr/ABCyOwALIAcgCUGIi/8AEMMhAAsMAgsMYAsgA0H4AGogA0HMAGoiBxCCFCADQZgBaiIEEJcpIANB6ABqIgEoAgAhCSADKAJsIQUgASADQaABaiIGKQIANwMAIAMpA2AhGyADIAMpApgBNwNgIANBADYCcCADIBs3AqQBIANBADYCoAEgAyAFNgKcASADIAk2ApgBIAMgBBDXOyADKAIAIQkQsD5BHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCmAE3AgggAUEQaiAGKQIANwIAIAFBGGogA0GoAWoiCigCADYCACADIAU2AtgBIAMgCTYC1AEgAyABNgLQASADQYwBaiIBIANB0AFqEOQZIAogA0GIAWooAgA2AgAgBiADQYABaikCADcDACADIAMpAng3A5gBIAMgAjYCrAEgDSABIAQQxB0gA0HgAGoQzy8gBxDPLyADQeABaiQADAILDDILQdyL/wBBKSADQZgBakHsj/8AQYiM/wAQ1R4ACwsgCEGQAmoQ3CkhASAAQfDU/wA2AgggACABNgIEIABBk4CAgHg2AgAMFwsCQAJAIAgoAkwoAgQNACAIKAJIKAIERQ0AIAhB0ABqIAtBCGogAygCCBCKGCAIKAJUIQEgCCgCUCICQZOAgIB4RwRAIAAgCCkCWDcCCCAAQRBqIAhB4ABqKAIANgIAIAAgATYCBCAAIAI2AgAgCEGQA2oQ9yQMAwsgCCABNgL0AwJAAkACQAJAAkACQAJAAkAgCCgCSC0AAUEBaw4DAQIDAAsgCEHQAGoiASAIQZADakEw/AoAACAIQZACaiEFIwBBgAFrIgIkACACIAhB9ANqIgY2AgQCQAJAIAQtADRFBEAgAkHQAGogASACQQRqEKQHIAItAFAiBEEpRgRAIAJBywBqIAJB5ABqKAIAIgQ2AAAgAkHDAGogAkHcAGopAgAiGzcAACACIAIpAlQiHDcAOyAFQRRqIAQ2AAAgBUEMaiAbNwAAIAUgHDcABCAFQSk6AAAMAwsgAkHHAGoiBiACQeAAaikAADcAACACQUBrIgcgAkHZAGopAAA3AwAgAkEoaiACQfAAaikCADcCACACQTBqIAJB+ABqKQIANwIAIAJBEWogBykDADcAACACQRhqIAYpAAA3AAAgAiACKQBRIhs3AzggAiACKQJoNwIgIAIgGzcACSACIAQ6AAgMAQsgAkEIaiABIAYQlgULIAUgAkEIakEw/AoAAAsgARD3JCACQYABaiQAIAgtAJACIgFBKUcNAyAIQYsEaiAIQaQCaigCACIBNgAAIAhBgwRqIAhBnAJqKQIAIhs3AAAgCCAIKQKUAiIcNwD7AyAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyAIQdAAaiIBIAhBkANqQTD8CgAAIAhBkAJqIQUjAEGAAWsiAiQAIAIgCEH0A2oiBjYCBAJAAkAgBC0ANEUEQCACQdAAaiABIAJBBGoQpgcgAi0AUCIEQSlGBEAgAkHLAGogAkHkAGooAgAiBDYAACACQcMAaiACQdwAaikCACIbNwAAIAIgAikCVCIcNwA7IAVBFGogBDYAACAFQQxqIBs3AAAgBSAcNwAEIAVBKToAAAwDCyACQccAaiIGIAJB4ABqKQAANwAAIAJBQGsiByACQdkAaikAADcDACACQShqIAJB8ABqKQIANwIAIAJBMGogAkH4AGopAgA3AgAgAkERaiAHKQMANwAAIAJBGGogBikAADcAACACIAIpAFEiGzcDOCACIAIpAmg3AiAgAiAbNwAJIAIgBDoACAwBCyACQQhqIAEgBhCUBQsgBSACQQhqQTD8CgAACyABEPckIAJBgAFqJAAgCC0AkAIiAUEpRw0DIAhBiwRqIAhBpAJqKAIAIgE2AAAgCEGDBGogCEGcAmopAgAiGzcAACAIIAgpApQCIhw3APsDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADAgLIAhB0ABqIgEgCEGQA2pBMPwKAAAgCEGQAmohBSMAQYABayICJAAgAiAIQfQDaiIGNgIEAkACQCAELQA0RQRAIAJB0ABqIAEgAkEEahClByACLQBQIgRBKUYEQCACQcsAaiACQeQAaigCACIENgAAIAJBwwBqIAJB3ABqKQIAIhs3AAAgAiACKQJUIhw3ADsgBUEUaiAENgAAIAVBDGogGzcAACAFIBw3AAQgBUEpOgAADAMLIAJBxwBqIgYgAkHgAGopAAA3AAAgAkFAayIHIAJB2QBqKQAANwMAIAJBKGogAkHwAGopAgA3AgAgAkEwaiACQfgAaikCADcCACACQRFqIAcpAwA3AAAgAkEYaiAGKQAANwAAIAIgAikAUSIbNwM4IAIgAikCaDcCICACIBs3AAkgAiAEOgAIDAELIAJBCGogASAGEIwFCyAFIAJBCGpBMPwKAAALIAEQ9yQgAkGAAWokACAILQCQAiIBQSlHDQMgCEGLBGogCEGkAmooAgAiATYAACAIQYMEaiAIQZwCaikCACIbNwAAIAggCCkClAIiHDcA+wMgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMBwsgCEHQAGoiASAIQZADakEw/AoAACAIQZACaiEFIwBBgAFrIgIkACACIAhB9ANqIgY2AgQCQAJAIAQtADRFBEAgAkHQAGogASACQQRqEKMHIAItAFAiBEEpRgRAIAJBywBqIAJB5ABqKAIAIgQ2AAAgAkHDAGogAkHcAGopAgAiGzcAACACIAIpAlQiHDcAOyAFQRRqIAQ2AAAgBUEMaiAbNwAAIAUgHDcABCAFQSk6AAAMAwsgAkHHAGoiBiACQeAAaikAADcAACACQUBrIgcgAkHZAGopAAA3AwAgAkEoaiACQfAAaikCADcCACACQTBqIAJB+ABqKQIANwIAIAJBEWogBykDADcAACACQRhqIAYpAAA3AAAgAiACKQBRIhs3AzggAiACKQJoNwIgIAIgGzcACSACIAQ6AAgMAQsgAkEIaiABIAYQmQULIAUgAkEIakEw/AoAAAsgARD3JCACQYABaiQAIAgtAJACIgFBKUcNAyAIQYsEaiAIQaQCaigCACIBNgAAIAhBgwRqIAhBnAJqKQIAIhs3AAAgCCAIKQKUAiIcNwD7AyAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwGCyAIQYcEaiICIAhBoAJqKQAANwAAIAhBgARqIgQgCEGZAmopAAA3AwAgCEHgA2ogCEGwAmopAgA3AgAgCEHoA2ogCEG4AmopAgA3AgAgCEHJA2ogBCkDADcAACAIQdADaiACKQAANwAAIAggCCkAkQIiGzcD+AMgCCAIKQKoAjcC2AMgCCAbNwDBAyAIIAE6AMADDAQLIAhBhwRqIgIgCEGgAmopAAA3AAAgCEGABGoiBCAIQZkCaikAADcDACAIQeADaiAIQbACaikCADcCACAIQegDaiAIQbgCaikCADcCACAIQckDaiAEKQMANwAAIAhB0ANqIAIpAAA3AAAgCCAIKQCRAiIbNwP4AyAIIAgpAqgCNwLYAyAIIBs3AMEDIAggAToAwAMMAwsgCEGHBGoiAiAIQaACaikAADcAACAIQYAEaiIEIAhBmQJqKQAANwMAIAhB4ANqIAhBsAJqKQIANwIAIAhB6ANqIAhBuAJqKQIANwIAIAhByQNqIAQpAwA3AAAgCEHQA2ogAikAADcAACAIIAgpAJECIhs3A/gDIAggCCkCqAI3AtgDIAggGzcAwQMgCCABOgDAAwwCCyAIQYcEaiICIAhBoAJqKQAANwAAIAhBgARqIgQgCEGZAmopAAA3AwAgCEHgA2ogCEGwAmopAgA3AgAgCEHoA2ogCEG4AmopAgA3AgAgCEHJA2ogBCkDADcAACAIQdADaiACKQAANwAAIAggCCkAkQIiGzcD+AMgCCAIKQKoAjcC2AMgCCAbNwDBAyAIIAE6AMADDAELIAhBwANqIAhBkANqQTD8CgAACyAIKAJILQABIQEgCwRAIAsgCygCACICQQFqNgIAIAJBAEgNGCADKAIIIQMLIAhBGGogCEHAA2oiAiABIAsgAxDwByAAIAgpAxg3AgQgAEGTgICAeDYCACACEPckIAgoAogDIgAgACgCACIAQQFrNgIAIABBAUcNFiAIQYgDahC7IwwWCyAIKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDRUgCEGIA2oQuyMMFQsCQCACQRJrDgIBAgALIAJBBEcgDUETR3INCyADLQABDQsjAEEwayIBJAAgASAFIAYQ+yEQ8yQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBwNP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMGgsMFAsgCS0AASIBQQFrDgMCAwQBCyANQRJrDgIFBAkLIAMQkTZFDQcgCEHQAGohASMAQTBrIgIkACACIAUgBhDqIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwwXCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMEgsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDREgABC7IwwRCyADEJE2RQ0GIAhB0ABqIQEjAEEwayICJAAgAiAFIAYQ5yEQ7CQQsD4CQEE4QQQQrTYiAwRAIANCgYCAgBA3AgAgA0EIaiACQTD8CgAAIAFB6NL/ADYCCCABIAM2AgQgAUGTgICAeDYCACACQTBqJAAMAQsMFgsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBELIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAIKAJIIAQQhgEgCCgCkAIiASABKAIAIgFBAWs2AgAgAUEBRw0QIAAQuyMMEAsgAxCRNkUNBSAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEIEiEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDBULIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwQCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNDyAAELsjDA8LIAMQkTZFDQQgCEHQAGohASMAQTBrIgIkACACIAUgBhDuIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwwUCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMDwsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDQ4gABC7IwwOCyAJLQABQQFrDgICBAELIAktAAFBAkcNAwJAAkACQAJAIAMtAAFBAWsOAwECAwALIwBBgAJrIgEkACAFIAYQ/SEhAiABQaABakHgu/8AKAIANgIAIAFCgJTr3AM3AxggAUHYu/8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDSkLQcAAIQogA0HAABDRNEUNWSADBEAQsD4gA0HAABCtNiIKRQ0+CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1WIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1dIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDV5CACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNYCABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNLiACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDC4LIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSwgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJB2Lv/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQvBMQsD5BOEEEEK02IgJFDRcgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgz/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSsgAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARB2Lv/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQvBMQsD5BOEEEEK02IgJFDRYgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgz/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwPCyMAQYACayIBJAAgBSAGEP0hIQIgAUGgAWpBhLz/ACgCADYCACABQsCEPTcDGCABQfy7/wApAgA3A5gBIAFBmAFqIgMQpwwCQAJAAkAgBC0ANEUEQCACEL48IQQgAUGcAWogAhD3NCABIAQ2ArgBIAFBADYCtAEgASACNgKYASABIAFBGGo2ArwBIAFB2ABqIAMQshcgAUH4AWoiAiABQeQAaigCADYCACABIAEpAlw3A/ABIAEoAlgiA0GTgICAeEYNASABKAJoIQQgACABKQPwATcCBCAAIAQ2AhAgACADNgIAIABBDGogAigCADYCAAwCCyACEL48IQUgAUEoaiIJIAIQ9zQgASAFNgJEIAFBADYCQCABIAI2AiQgAhC+PBogAhC+PCELIAIQvjwaIAEgAhC+PCIDNgKIASABQdgAakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNKAtBwAAhCiADQcAAENE0RQ1YIAMEQBCwPiADQcAAEK02IgpFDT0LIAEoAmAhDCABQaQBaiAJQQhqKQIANwIAIAFBrAFqIAlBEGopAgA3AgAgASACNgKYAUEAIQcgAUEANgLAASABIAU2ArgBIAFBADYCtAEgASAJKQIANwKcASABIAFBGGo2ArwBIAFBnAFqIQlBACECA0AgAUHwAWohDUICIRsgAiAFRwR/IAECfgJAIAEoApwBRQ0AIAIgASgCrAFPDVUgASgCoAEgASgCqAEgAmoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgAkEBajYCtAFCAAwBCyABIAJBAWo2ArQBIAEoArwBKQMAIhxQDVwgASgCmAEoAhAgAkEEdGoiAigCBCEFIAIoAgAhBiACKQMIIh1CgICAgICAgICAf1EgHEJ/UXENXUIAIAUgBnINABogHSAcfyEbQgELNwPwASABIAEoAsABIgZBAWo2AsABIAFB4AFqBSANCyAbNwMAAkACQAJAIAEpA/ABIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPgATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoApwBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAkQ+x4LIAEgB0EDdSICNgLwASACIAEoAogBRw1fIAEoAmAhAiABKAJkIQUgASABKQJYNwKkASABQQA2AqABIAEgBTYCnAEgASACNgKYASABQRBqIAFBmAFqIgYQ1zsgASgCECEHELA+QRxBBBCtNiICRQ0tIAJCgYCAgBA3AgAgAiABKQKYATcCCCACQRBqIAFBoAFqIgkpAgA3AgAgAkEYaiABQagBaiIMKAIANgIAIAEgAzYCqAEgAUKAgICAgAg3AqABIAEgBDYCnAEgASAKNgKYASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMLQsgAkIANwMACyAHQQhqIQcgASgCuAEhBSABKAK0ASECDAELCyADQoGAgIAQNwIAIAMgASkCmAE3AgggA0EQaiAJKQIANwIAIANBGGogDCgCADYCACABIAU2AugBIAEgBzYC5AEgASACNgLgARCwPkEMQQQQrTYiAkUNKyACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AvgBIAEgAjYC9AEgAUEBNgLwASABQQA2AmAgAUKAgICAwAA3AlggAUGYAWoiAkH8u/8AIAsgASABQeABaiABQfABaiABQdgAaiIDEIwTIAMgAhC1ExCwPkE4QQQQrTYiAkUNFiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDQ/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHQAGogAUH4AWooAgAiAzYCACABIAEpA/ABNwNIIAFBmAFqIgQgASgCTCICIAIgA0EEdGoQ9AkgAUHoAWogAUGgAWooAgA2AgAgAUGQAWoiBSABQawBaigCADYCACABIAEpApgBNwPgASABIAEpAqQBNwOIARCwPkEMQQQQrTYiAkUNKiACIAEpA4gBNwIAIAJBCGogBSgCADYCACABQQE2AvgBIAEgAjYC9AEgAUEBNgLwASABQQA2AmAgAUKAgICAwAA3AlggBEH8u/8AIAMgASABQeABaiABQfABaiABQdgAaiIDEIwTIAMgBBC1ExCwPkE4QQQQrTYiAkUNFSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDQ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHIAGoiABDJPiAAEO07CyABQYACaiQADAALDA4LIwBBgAJrIgEkACAFIAYQ/SEhAiABQaABakHMvP8AKAIANgIAIAFC6Ac3AxggAUHEvP8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDScLQcAAIQogA0HAABDRNEUNVyADBEAQsD4gA0HAABCtNiIKRQ08CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1UIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1bIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDVxCACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNXiABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNLCACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDCwLIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSogAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJBxLz/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQuhMQsD5BOEEEEK02IgJFDRUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgzv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSkgAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARBxLz/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQuhMQsD5BOEEEEK02IgJFDRQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgzv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwNCyMAQYACayIBJAAgBSAGEP0hIQIgAUGgAWpBkLz/ACgCADYCACABQgE3AxggAUGIvP8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDSYLQcAAIQogA0HAABDRNEUNViADBEAQsD4gA0HAABCtNiIKRQ07CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1TIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1aIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDVtCACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNXSABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNKyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDCsLIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSkgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJBiLz/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQwRMQsD5BOEEEEK02IgJFDRQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4z/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSggAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARBiLz/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQwRMQsD5BOEEEEK02IgJFDRMgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4z/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwMCyADLQABQQJHDQIjAEEwayIBJAAgASAFIAYQgCIQtSAQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABByM3/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMEQsMCwsgAy0AAUECRw0BIwBBQGoiASQAIAUgBhDrISECIAFCwIQ9NwMIIAFBEGoiAyACIAFBCGoQrh0QsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByM3/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQUBrJAAMAQsMEAsMCgsCQAJAAkACQAJAAkACQAJAAkAgDUESaw4CAQAJCyABQQFrDgMCAwQBCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIFQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBTYCAAwRCyAIIAE2AvwDIAggAjYC+AMgCEH4A2oQih4hAgJAAkACQCAJLQABQQN0QaDu/wBqKQMAIhsgAy0AAUEDdEGg7v8AaikDACIcVSAbIBxTa0H/AXEOAgECAAsgCCAcpyAbp26tNwOQAyAELQA0DQYgCEHQAGogAiAIQZADahDOBSAILQBQIgFBKUcNByAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAAIAgoAvgDIgAgACgCACIAQQFrNgIAIABBAUcNEiAIQfgDahC7IwwSCyAIQZACaiACEIAVDAcLIAggG6cgHKdurTcDUCMAQUBqIgEkACABIAhB0ABqNgIMIAFBEGoiAyACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjQgASABQQxqNgI8IAFBKGoiBCABQTRqIgIQ7BogAiAEEL0YIAhBkAJqIAIgAxDWHSABQUBrJAAMBgsgAy0AAUECRw0GIwBBgAJrIgMkACADQShqIAUgBigCEBEAACADQZABaiADKAIoIgEgAygCLCgCDBEAAAJAAkACQAJAIAEEQCADKQOQAUKo+Inf7v3i9xmFIAMpA5gBQoKIosHluO7+FoWEUA0BCyADQZABakHGAEEAQQFBARCgGCADKAKUASEBIAMoApABQQFGDWEgAygCmAEiAkHI0f8AQcYA/AoAACAAQcYANgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwCCyABLQAAQRJGBEAgAyABLQABQQN0QYDu/wBqKQMANwMwIAQtADRFBEAgARDAPCECIANBlAFqIAEQ9zQgAyACNgKwASADQQA2AqwBIAMgATYCkAEgAyADQTBqNgK0ASADQeAAaiADQZABahCuFyADQfgBaiIBIANB7ABqKAIANgIAIAMgAykCZDcD8AEgAygCYCICQZOAgIB4Rg0CIAMoAnAhBCAAIAMpA/ABNwIEIAAgBDYCECAAIAI2AgAgAEEMaiABKAIANgIADAMLIAEQwDwhByADQUBrIgkgARD3NCADIAc2AlwgA0EANgJYIAMgATYCPCABEMA8GiABEMA8IQogARDAPBogAyABEMA8IgI2AuABIANB4ABqQX8gAkEHaiIEIAIgBEsbQQN2ENIfIAJBBHQiBiEEAkAgBkEwcSICBEAgBiACa0FAayIEIAZJDQELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDTQLIAMoAmghCyADQZwBaiAJQQhqKQIANwIAIANBpAFqIAlBEGopAgA3AgAgAyABNgKQAUEAIQUgA0EANgK4ASADIAc2ArABIANBADYCrAEgAyAJKQIANwKUASADIANBMGo2ArQBIAIhASAHBEADQAJAAkACQCADKAKUAUUEQCADKAK4ASEHDAELIAMoAqQBIAVLBEAgAygCuAEhByADKAKYASADKAKgASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgK4ASADIAVBAWo2AqwBDAILDFoLIAMgBUEBajYCrAEgA0EQaiADKAKQASgCECAFQQN0aikDACIbIBtCP4cgAygCtAEpAwAiGyAbQj+HEKgeIAMgB0EBajYCuAEgAykDGCADKQMQIhtCP4dSDQAgAUIANwMAIAFBCGogGzcDACALIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQgA3AwAgAUEIakIANwMACyABQRBqIQEgAygCrAEiBSADKAKwAUcNAAsLAkAgAygClAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GUAWoQ+x4LIAMgASACa0EEdSIBNgLwAQJAIAMoAuABIAFGBEAgAygCaCEBIAMoAmwhBSADIAMpAmA3ApwBIANBADYCmAEgAyAFNgKUASADIAE2ApABIANBCGogA0GQAWoiBxDXOyADKAIIIQkQsD5BHEEEEK02IgFFDS8gAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogA0GYAWoiCykCADcCACABQRhqIANBoAFqIgwoAgA2AgAgAyAENgKgASADQoCAgICACDcCmAEgAyAGNgKUASADIAI2ApABIAMgBxDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAMMAsgAkKBgICAEDcCACACIAMpApABNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDTEgASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJoIANCgICAgMAANwJgIANBkAFqIgFB5Lv/ACAKIAMgA0HgAWogA0HwAWogA0HgAGoiAhCMEyACIAEQvhMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIADAYLDGELDBoLDGALDCkLDF8LIANB6AFqIAEoAgAiATYCACADIAMpA/ABNwPgASADQZABaiICIAMoAuQBIgQgBCABQRhsahDzCBCwPkE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjN/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HgAWoiABDJPiAAEPU7CyADQYACaiQADAALDA8LIAMtAAFBAkcNBSMAQYACayIDJAAgA0EoaiAFIAYoAhARAAAgA0GQAWogAygCKCIBIAMoAiwoAgwRAAACQAJAAkACQCABBEAgAykDkAFC+pi2+pKmisMchSADKQOYAUKjwLrZ1ubhqiaFhFANAQsgA0GQAWpBxgBBAEEBQQEQoBggAygClAEhASADKAKQAUEBRg1gIAMoApgBIgJByNH/AEHGAPwKAAAgAEHGADYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAgsgAS0AAEESRgRAIAMgAS0AAUEDdEGA7v8AaikDADcDMCAELQA0RQRAIAEQwDwhAiADQZQBaiABEPc0IAMgAjYCsAEgA0EANgKsASADIAE2ApABIAMgA0EwajYCtAEgA0HgAGogA0GQAWoQrhcgA0H4AWoiASADQewAaigCADYCACADIAMpAmQ3A/ABIAMoAmAiAkGTgICAeEYNAiADKAJwIQQgACADKQPwATcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCAAwDCyABEMA8IQcgA0FAayIJIAEQ9zQgAyAHNgJcIANBADYCWCADIAE2AjwgARDAPBogARDAPCEKIAEQwDwaIAMgARDAPCICNgLgASADQeAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQR0IgYhBAJAIAZBMHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ0zCyADKAJoIQsgA0GcAWogCUEIaikCADcCACADQaQBaiAJQRBqKQIANwIAIAMgATYCkAFBACEFIANBADYCuAEgAyAHNgKwASADQQA2AqwBIAMgCSkCADcClAEgAyADQTBqNgK0ASACIQEgBwRAA0ACQAJAAkAgAygClAFFBEAgAygCuAEhBwwBCyADKAKkASAFSwRAIAMoArgBIQcgAygCmAEgAygCoAEgBWoiCUEDdmotAABB/wFzIAlBB3F2QQFxRQ0BIAMgB0EBajYCuAEgAyAFQQFqNgKsAQwCCwxZCyADIAVBAWo2AqwBIANBEGogAygCkAEoAhAgBUEDdGopAwAiGyAbQj+HIAMoArQBKQMAIhsgG0I/hxCoHiADIAdBAWo2ArgBIAMpAxggAykDECIbQj+HUg0AIAFCADcDACABQQhqIBs3AwAgCyAHQQN2aiIFIAUtAABBASAHQQdxdHI6AAAMAQsgAUIANwMAIAFBCGpCADcDAAsgAUEQaiEBIAMoAqwBIgUgAygCsAFHDQALCwJAIAMoApQBIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBlAFqEPseCyADIAEgAmtBBHUiATYC8AECQCADKALgASABRgRAIAMoAmghASADKAJsIQUgAyADKQJgNwKcASADQQA2ApgBIAMgBTYClAEgAyABNgKQASADQQhqIANBkAFqIgcQ1zsgAygCCCEJELA+QRxBBBCtNiIBRQ0uIAFCgYCAgBA3AgAgASADKQKQATcCCCABQRBqIANBmAFqIgspAgA3AgAgAUEYaiADQaABaiIMKAIANgIAIAMgBDYCoAEgA0KAgICAgAg3ApgBIAMgBjYClAEgAyACNgKQASADIAcQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADC8LIAJCgYCAgBA3AgAgAiADKQKQATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC6AEgAyAJNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ0wIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCaCADQoCAgIDAADcCYCADQZABaiIBQeS7/wAgCiADIANB4AFqIANB8AFqIANB4ABqIgIQjBMgAiABEL4TELA+QThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByM3/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCwxgCwwZCwxfCwwoCwxeCyADQegBaiABKAIAIgE2AgAgAyADKQPwATcD4AEgA0GQAWoiAiADKALkASIEIAQgAUEYbGoQ8wgQsD5BOEEEEK02IgFFDRUgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB4AFqIgAQyT4gABD1OwsgA0GAAmokAAwACwwOCyADLQABQQJHDQQjAEGAAmsiAyQAIANBKGogBSAGKAIQEQAAIANBkAFqIAMoAigiASADKAIsKAIMEQAAAkACQAJAAkAgAQRAIAMpA5ABQu3Flqe9j+DYVIUgAykDmAFC14P/uOLrl/HcAIWEUA0BCyADQZABakHGAEEAQQFBARCgGCADKAKUASEBIAMoApABQQFGDV8gAygCmAEiAkHI0f8AQcYA/AoAACAAQcYANgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwCCyABLQAAQRJGBEAgAyABLQABQQN0QYDu/wBqKQMANwMwIAQtADRFBEAgARDAPCECIANBlAFqIAEQ9zQgAyACNgKwASADQQA2AqwBIAMgATYCkAEgAyADQTBqNgK0ASADQeAAaiADQZABahCuFyADQfgBaiIBIANB7ABqKAIANgIAIAMgAykCZDcD8AEgAygCYCICQZOAgIB4Rg0CIAMoAnAhBCAAIAMpA/ABNwIEIAAgBDYCECAAIAI2AgAgAEEMaiABKAIANgIADAMLIAEQwDwhByADQUBrIgkgARD3NCADIAc2AlwgA0EANgJYIAMgATYCPCABEMA8GiABEMA8IQogARDAPBogAyABEMA8IgI2AuABIANB4ABqQX8gAkEHaiIEIAIgBEsbQQN2ENIfIAJBBHQiBiEEAkAgBkEwcSICBEAgBiACa0FAayIEIAZJDQELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDTILIAMoAmghCyADQZwBaiAJQQhqKQIANwIAIANBpAFqIAlBEGopAgA3AgAgAyABNgKQAUEAIQUgA0EANgK4ASADIAc2ArABIANBADYCrAEgAyAJKQIANwKUASADIANBMGo2ArQBIAIhASAHBEADQAJAAkACQCADKAKUAUUEQCADKAK4ASEHDAELIAMoAqQBIAVLBEAgAygCuAEhByADKAKYASADKAKgASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgK4ASADIAVBAWo2AqwBDAILDFgLIAMgBUEBajYCrAEgA0EQaiADKAKQASgCECAFQQN0aikDACIbIBtCP4cgAygCtAEpAwAiGyAbQj+HEKgeIAMgB0EBajYCuAEgAykDGCADKQMQIhtCP4dSDQAgAUIANwMAIAFBCGogGzcDACALIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQgA3AwAgAUEIakIANwMACyABQRBqIQEgAygCrAEiBSADKAKwAUcNAAsLAkAgAygClAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GUAWoQ+x4LIAMgASACa0EEdSIBNgLwAQJAIAMoAuABIAFGBEAgAygCaCEBIAMoAmwhBSADIAMpAmA3ApwBIANBADYCmAEgAyAFNgKUASADIAE2ApABIANBCGogA0GQAWoiBxDXOyADKAIIIQkQsD5BHEEEEK02IgFFDS0gAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogA0GYAWoiCykCADcCACABQRhqIANBoAFqIgwoAgA2AgAgAyAENgKgASADQoCAgICACDcCmAEgAyAGNgKUASADIAI2ApABIAMgBxDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAMLgsgAkKBgICAEDcCACACIAMpApABNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDS8gASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJoIANCgICAgMAANwJgIANBkAFqIgFB5Lv/ACAKIAMgA0HgAWogA0HwAWogA0HgAGoiAhCMEyACIAEQvhMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIADAYLDF8LDBgLDF4LDCcLDF0LIANB6AFqIAEoAgAiATYCACADIAMpA/ABNwPgASADQZABaiICIAMoAuQBIgQgBCABQRhsahDzCBCwPkE4QQQQrTYiAUUNFCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjN/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HgAWoiABDJPiAAEPU7CyADQYACaiQADAALDA0LIAMtAAFBAkcNAyMAQYACayIDJAAgA0EoaiAFIAYoAhARAAAgA0GQAWogAygCKCIBIAMoAiwoAgwRAAACQAJAAkACQCABBEAgAykDkAFC/7qo06KElftAhSADKQOYAUKG7fP27Ny75gCFhFANAQsgA0GQAWpBxgBBAEEBQQEQoBggAygClAEhASADKAKQAUEBRg1eIAMoApgBIgJByNH/AEHGAPwKAAAgAEHGADYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAgsgAS0AAEESRgRAIAMgAS0AAUEDdEGA7v8AaikDADcDMCAELQA0RQRAIAEQwDwhAiADQZQBaiABEPc0IAMgAjYCsAEgA0EANgKsASADIAE2ApABIAMgA0EwajYCtAEgA0HgAGogA0GQAWoQrhcgA0H4AWoiASADQewAaigCADYCACADIAMpAmQ3A/ABIAMoAmAiAkGTgICAeEYNAiADKAJwIQQgACADKQPwATcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCAAwDCyABEMA8IQcgA0FAayIJIAEQ9zQgAyAHNgJcIANBADYCWCADIAE2AjwgARDAPBogARDAPCEKIAEQwDwaIAMgARDAPCICNgLgASADQeAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQR0IgYhBAJAIAZBMHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ0xCyADKAJoIQsgA0GcAWogCUEIaikCADcCACADQaQBaiAJQRBqKQIANwIAIAMgATYCkAFBACEFIANBADYCuAEgAyAHNgKwASADQQA2AqwBIAMgCSkCADcClAEgAyADQTBqNgK0ASACIQEgBwRAA0ACQAJAAkAgAygClAFFBEAgAygCuAEhBwwBCyADKAKkASAFSwRAIAMoArgBIQcgAygCmAEgAygCoAEgBWoiCUEDdmotAABB/wFzIAlBB3F2QQFxRQ0BIAMgB0EBajYCuAEgAyAFQQFqNgKsAQwCCwxXCyADIAVBAWo2AqwBIANBEGogAygCkAEoAhAgBUEDdGopAwAiGyAbQj+HIAMoArQBKQMAIhsgG0I/hxCoHiADIAdBAWo2ArgBIAMpAxggAykDECIbQj+HUg0AIAFCADcDACABQQhqIBs3AwAgCyAHQQN2aiIFIAUtAABBASAHQQdxdHI6AAAMAQsgAUIANwMAIAFBCGpCADcDAAsgAUEQaiEBIAMoAqwBIgUgAygCsAFHDQALCwJAIAMoApQBIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBlAFqEPseCyADIAEgAmtBBHUiATYC8AECQCADKALgASABRgRAIAMoAmghASADKAJsIQUgAyADKQJgNwKcASADQQA2ApgBIAMgBTYClAEgAyABNgKQASADQQhqIANBkAFqIgcQ1zsgAygCCCEJELA+QRxBBBCtNiIBRQ0sIAFCgYCAgBA3AgAgASADKQKQATcCCCABQRBqIANBmAFqIgspAgA3AgAgAUEYaiADQaABaiIMKAIANgIAIAMgBDYCoAEgA0KAgICAgAg3ApgBIAMgBjYClAEgAyACNgKQASADIAcQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADC0LIAJCgYCAgBA3AgAgAiADKQKQATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC6AEgAyAJNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ0uIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCaCADQoCAgIDAADcCYCADQZABaiIBQeS7/wAgCiADIANB4AFqIANB8AFqIANB4ABqIgIQjBMgAiABEL4TELA+QThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByM3/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCwxeCwwXCwxdCwwmCwxcCyADQegBaiABKAIAIgE2AgAgAyADKQPwATcD4AEgA0GQAWoiAiADKALkASIEIAQgAUEYbGoQ8wgQsD5BOEEEEK02IgFFDRMgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB4AFqIgAQyT4gABD1OwsgA0GAAmokAAwACwwMCyAIQZACaiACIAhBkANqEK0DDAELIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbACaiAIQfAAaikCADcCACAIQbgCaiAIQfgAaikCADcCACAIQZkCaiADKQMANwAAIAhBoAJqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCqAIgCCAbNwCRAiAIIAE6AJACCyAIQQhqIAhBkAJqIgEgCCgCSC0AARDBESAAIAgpAwg3AgQgAEGTgICAeDYCACABEPckIAgoAvgDIgAgACgCACIAQQFrNgIAIABBAUcNCSAIQfgDahC7IwwJCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAgLIAhBAzYCVCAIQdjf/wA2AlAgCEICNwJcIAhBrwM2ApwCIAhBrwM2ApQCIAggCEGQAmo2AlggCCAIQcgAajYCmAIgCCAIQcwAajYCkAIgCEHAA2ogCEHQAGoQqxggAEGCgICAeDYCACAAIAgpAsADNwIEIABBDGogCEHIA2ooAgA2AgAMBwsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAwGCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAULIAAgCCkDwAM3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwECyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAMLIAhBMGogBSAGEMgvIgUQ3DsgCCgCMCECIAgoAjQhBiAIQShqIAcQwzQgCEHQAGoiASACIAIgBkEDdGogCCgCKCICIAIgCCgCLEECdGoQyCIgCCAENgJoIAhBkAJqIQQjAEFAaiICJAAgAkGTgICAeDYCACACQThqIAFBGGooAgA2AgAgAkEwaiABQRBqKQIANwMAIAJBKGogAUEIaikCADcDACACIAEpAgA3AyAgAiACNgI8IAJBFGoiASACQSBqEIoTAkAgAigCAEGTgICAeEcEQCAEIAIpAgA3AgAgBEEQaiACQRBqKAIANgIAIARBCGogAkEIaikCADcCACABEMMnIAEQ6jsMAQsgBCACKQIUNwIEIARBk4CAgHg2AgAgBEEMaiACQRxqKAIANgIACyACQUBrJAAgCEHIA2oiASAIQZwCaigCADYCACAIIAgpApQCNwPAAyAIKAKQAiICQZOAgIB4RwRAIAgoAqACIQMgACAIKQPAAzcCBCAAIAM2AhAgACACNgIAIABBDGogASgCADYCAAwDCyAIQdgBaiABKAIANgIAIAggCCkDwAM3A9ABIAsgCygCACIBQQFqNgIAIAFBAEgNAyADKAIIIQEgCEGQAmoiAiAFEJw2EO4lIAhB0ABqIAsgASAIQdABaiACEOUPIAhByANqIgEgCEHcAGopAgA3AwAgCEHQA2oiAiAIQeQAaigCADYCACAIIAgpAlQ3A8ADIAgoAlAiA0GAgICAeEYEQCAAIAgpA8ADNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMAwsgCEGMAmogCEGAAWooAgA2AgAgCEGEAmogCEH4AGopAgA3AgAgCEH8AWogCEHwAGopAgA3AgAgCEHoAWogASkDADcCACAIQfABaiACKAIANgIAIAggCCkCaDcC9AEgCCADNgLcASAIIAgpA8ADNwLgASAIQdwBahDlKSEBIABB8N7/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCyAAIAEgAhDzEAwBCyAIQThqIAUgBigCEBEAACAIQdAAaiICIAgoAjgiASAIKAI8KAIMEQAAIAFFDQIgCCkDUEL/2euq19iLjPEAhSAIKQNYQoH04aOq+Nbqi3+FhFBFDQIgAiABQQxqQdTc/wAgAygCCCICQTBqIAQQhgEgCCgCWCEDIAgoAlQhBCAIKAJQIgVBk4CAgHhHBEAgACAIKQJcNwIMIAAgAzYCCCAAIAQ2AgQgACAFNgIADAELIAIgAigCACIFQQFqNgIAIAVBAEgNASAIKAJMKAIEIQUgCEGQAmoiBiABEJs2EO4lIAhB0ABqIAIgBSAEIAMgBhDhBiAILQBQIgFBKUYEQCAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADAELIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbwBaiAIQfAAaikCADcCACAIQcQBaiAIQfgAaikCADcCACAIQcwBaiAIQYABaigCADYCACAIQaUBaiADKQMANwAAIAhBrAFqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCtAEgCCABOgCcASAIIBs3AJ0BIAhBnAFqEOUpIQEgAEGs3f8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyAIQZAKaiQADwsAC0HE3P8AELI7AAtBsJ3/AEEgQdCd/wAQnykAC0Hgnf8AELI7AAtBBEE4EKM9AAtBBEHEABCjPQALIAIgASgCuANB0KD/ABD9LwALIAIgASgC3ARB0KD/ABD9LwALIAMgASgCyANB0KD/ABD9LwALQQRBwAAQoz0AC0EEQTwQoz0AC0HAACACEKM9AAtBoOOAAUEpIAZBmANqQfTkgAFBzOOAARDVHgALIAMgASgCDEGMyf8AEP0vAAtBpJiAARCyOwALIAEgAxCjPDYCbAw+C0EEQTQQoz0ACyABIAMQ/js2AmwMPAsgASADEPw7NgJsDDsLIAEgAxD9OzYCbAw6C0HY6f8AELI7AAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgB0HQAGpBxMj/AEHYwf8AENUeAAtBBEEcEKM9AAsgB0IANwJcIAdCgYCAgMAANwJUIAdBwLv/ADYCUEEAIAdBpAFqIAdBmAFqIAdB0ABqQci7/wAQrysAC0EEQQwQoz0AC0Gswf8AQSkgA0HQAGpBxMj/AEHYwf8AENUeAAtBwAAgBRCjPQALIANCADcCXCADQoGAgIDAADcCVCADQcC7/wA2AlBBACADQaQBaiADQZgBaiADQdAAakHIu/8AEK8rAAtBwAAgBBCjPQALIANCADcCXCADQoGAgIDAADcCVCADQcC7/wA2AlBBACADQaABaiADQawBaiADQdAAakHIu/8AEK8rAAsgA0IANwJcIANCgYCAgMAANwJUIANBwLv/ADYCUEEAIANBlAFqIANBrAFqIANB0ABqQci7/wAQrysACyADQQA2ApgBQQAgA0GUAWogA0EMaiADQZgBakHs7IABEK8rAAtBzPb/AEEgQez2/wAQnykACyAHQgA3ApABIAdCgYCAgMAANwKIASAHQZTy/wA2AoQBQQAgB0HUAWogB0HIAWogB0GEAWpBnPL/ABCvKwALQfz2/wBBKSAHQYQBakH4+v8AQaj3/wAQ1R4AC0GY9v8AQSNBvPb/ABDLJAALIANCADcCkAEgA0KBgICAwAA3AogBIANBlPL/ADYChAFBACADQdQBaiADQcgBaiADQYQBakGc8v8AEK8rAAtB/Pb/AEEpIANBhAFqQfj6/wBBqPf/ABDVHgALQfz2/wBBKSABQfwAakH4+v8AQaj3/wAQ1R4ACyABQgA3AogBIAFCgYCAgMAANwKAASABQZTy/wA2AnxBACABQdABaiABQdwBaiABQfwAakGc8v8AEK8rAAtB/Pb/AEEpIAFB9ABqQfj6/wBBqPf/ABDVHgALQcAAIAMQoz0ACyABQgA3AoABIAFCgYCAgMAANwJ4IAFBlPL/ADYCdEEAIAFBQGsgAUHEAWogAUH0AGpBnPL/ABCvKwALIANCADcCgAEgA0KBgICAwAA3AnggA0GU8v8ANgJ0QQAgA0HEAWogA0G4AWogA0H0AGpBnPL/ABCvKwALQfz2/wBBKSADQfQAakH4+v8AQaj3/wAQ1R4ACyADQgA3AogBIANCgYCAgMAANwKAASADQZTy/wA2AnxBACADQcgAaiADQcABaiADQfwAakGc8v8AEK8rAAtB/Pb/AEEpIANB/ABqQfj6/wBBqPf/ABDVHgALQfz2/wBBKSABQZwCakH4+v8AQaj3/wAQ1R4ACyABQgA3AqgCIAFCgYCAgMAANwKgAiABQZTy/wA2ApwCQQAgAUH8AWogAUHUAWogAUGcAmpBnPL/ABCvKwALQYCMgAEQsjsAC0H89v8AQSkgAUGAAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKMASABQoGAgIDAADcChAEgAUGU8v8ANgKAAUEAIAFB0ABqIAFB1AFqIAFBgAFqQZzy/wAQrysAC0H89v8AQSkgA0GAAWpB+Pr/AEGo9/8AENUeAAsgA0IANwKMASADQoGAgIDAADcChAEgA0GU8v8ANgKAAUEAIANB0ABqIANBzAFqIANBgAFqQZzy/wAQrysAC0H89v8AQSkgB0GcAWpB+Pr/AEGo9/8AENUeAAsgB0IANwKoASAHQoGAgIDAADcCoAEgB0GU8v8ANgKcAUEAIAdB4AFqIAdB7AFqIAdBnAFqQZzy/wAQrysACyADQgA3AqgBIANCgYCAgMAANwKgASADQZTy/wA2ApwBQQAgA0HgAWogA0HsAWogA0GcAWpBnPL/ABCvKwALQfz2/wBBKSADQZwBakH4+v8AQaj3/wAQ1R4AC0H89v8AQSkgAUGkAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKwASABQoGAgIDAADcCqAEgAUGU8v8ANgKkAUEAIAFB6AFqIAFB9AFqIAFBpAFqQZzy/wAQrysAC0H89v8AQSkgAUGYAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKkASABQoGAgIDAADcCnAEgAUGU8v8ANgKYAUEAIAFBgAJqIAFB3AFqIAFBmAFqQZzy/wAQrysAC0H8wP8AQSBBnMH/ABCfKQALQfz2/wBBKSABQdwCakH4+v8AQaj3/wAQ1R4ACyABQgA3AugCIAFCgYCAgMAANwLgAiABQZTy/wA2AtwCQQAgAUHIAmogAUGUAmogAUHcAmpBnPL/ABCvKwALQfz2/wBBKSABQaABakH4+v8AQaj3/wAQ1R4ACyABQgA3AqwBIAFCgYCAgMAANwKkASABQZTy/wA2AqABQQAgAUGMAmogAUHwAWogAUGgAWpBnPL/ABCvKwALQdSK/wBBI0H4iv8AEMskAAtB3Iv/AEEpIAFBQGtB7I//AEGIjP8AENUeAAtBrMH/AEEpIAFBmAFqQcTI/wBB2MH/ABDVHgALQajR/wAQ4isAC0Go0f8AEOYrAAsgAUIANwKkASABQoGAgIDAADcCnAEgAUHAu/8ANgKYAUEAIAFB8AFqIAFBiAFqIAFBmAFqQci7/wAQrysACyADQgA3ApwBIANCgYCAgMAANwKUASADQcC7/wA2ApABQQAgA0HwAWogA0HgAWogA0GQAWpByLv/ABCvKwALQazB/wBBKSADQZABakHEyP8AQdjB/wAQ1R4AC0H4zv8AQShBuNH/ABCfKQALIAEgAygCmAFBjMn/ABD9LwALIAFBAjYCECABQeC9/wA2AgwgAUICNwIYIAFBOzYCfCABQTs2AnQgASABQfAAajYCFCABIAFB7ABqNgJ4IAEgAUHoAGo2AnAgAUEMakHwvf8AEO8sAAuLyAIEE38EfgF9AXwjAEGQH2siBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEgAigCHCIHEQQAIgYtAABBAmsOJQMEBQYHCAkKCwwNAAAAAAABAgAAAAAAAAAAAAAAAAAAABUWFxgACyABIAcRBAAiBi0AAA4pHhhVVVVVVVVVVVVVVRkjJBobVVUpHCssLS4vMFUdMlUzNDVVVVVVNjdVCyAGLQABQQFrDgMNDg8MCyAGLQABQQFrDgIQEQ8LIARBkBpqIAEgAhC7IiADEOMWIAQtAJAaIgJBKUYNaCAEQe8AaiIDIARBoBpqKQAANwAAIARB6ABqIgYgBEGZGmopAAA3AwAgBEGAAWoiByAEQbAaaikCADcDACAEQYgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A2AgBCAEKQKoGjcDeEE4QQQQrTYiAUUNaiABIAI6AAggAUKBgICAEDcCACABIAQpA2A3AAkgASAEKQN4NwIgIABBtP+BATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaQsgBEGQGmogASACEKgiIAMQoRYgBC0AkBoiAkEpRg1mIARBnwFqIgMgBEGgGmopAAA3AAAgBEGYAWoiBiAEQZkaaikAADcDACAEQbABaiIHIARBsBpqKQIANwMAIARBuAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDkAEgBCAEKQKoGjcDqAFBOEEEEK02IgFFDWkgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQATcACSABIAQpA6gBNwIgIABBjICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaAsgBEGQGmogASACELEiIAMQohYgBC0AkBoiAkEpRg1kIARBzwFqIgMgBEGgGmopAAA3AAAgBEHIAWoiBiAEQZkaaikAADcDACAEQeABaiIHIARBsBpqKQIANwMAIARB6AFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDwAEgBCAEKQKoGjcD2AFBOEEEEK02IgFFDWggASACOgAIIAFCgYCAgBA3AgAgASAEKQPAATcACSABIAQpA9gBNwIgIABB5ICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZwsgBEGQGmogASACEKQiIAMQoxYgBC0AkBoiAkEpRg1iIARB/wFqIgMgBEGgGmopAAA3AAAgBEH4AWoiBiAEQZkaaikAADcDACAEQZACaiIHIARBsBpqKQIANwMAIARBmAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD8AEgBCAEKQKoGjcDiAJBOEEEEK02IgFFDWcgASACOgAIIAFCgYCAgBA3AgAgASAEKQPwATcACSABIAQpA4gCNwIgIABBvIGCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZgsgBEGQGmogASACEKoiIAMQ5BYgBC0AkBoiAkEpRg1gIARBrwJqIgMgBEGgGmopAAA3AAAgBEGoAmoiBiAEQZkaaikAADcDACAEQcACaiIHIARBsBpqKQIANwMAIARByAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDoAIgBCAEKQKoGjcDuAJBOEEEEK02IgFFDWYgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgAjcACSABIAQpA7gCNwIgIABBlIKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZQsgBEGQGmogASACEK0iIAMQpBYgBC0AkBoiAkEpRg1eIARB3wJqIgMgBEGgGmopAAA3AAAgBEHYAmoiBiAEQZkaaikAADcDACAEQfACaiIHIARBsBpqKQIANwMAIARB+AJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD0AIgBCAEKQKoGjcD6AJBOEEEEK02IgFFDWUgASACOgAIIAFCgYCAgBA3AgAgASAEKQPQAjcACSABIAQpA+gCNwIgIABB7IKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZAsgBEGQGmogASACELciIAMQpRYgBC0AkBoiAkEpRg1cIARBjwNqIgMgBEGgGmopAAA3AAAgBEGIA2oiBiAEQZkaaikAADcDACAEQaADaiIHIARBsBpqKQIANwMAIARBqANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDgAMgBCAEKQKoGjcDmANBOEEEEK02IgFFDWQgASACOgAIIAFCgYCAgBA3AgAgASAEKQOAAzcACSABIAQpA5gDNwIgIABBxIOCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYwsgBEGQGmogASACEKIiIAMQphYgBC0AkBoiAkEpRg1aIARBvwNqIgMgBEGgGmopAAA3AAAgBEG4A2oiBiAEQZkaaikAADcDACAEQdADaiIHIARBsBpqKQIANwMAIARB2ANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDsAMgBCAEKQKoGjcDyANBOEEEEK02IgFFDWMgASACOgAIIAFCgYCAgBA3AgAgASAEKQOwAzcACSABIAQpA8gDNwIgIABBnISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYgsgBEGAH2oiBiABIAIQuSIiASgCECABKAIUQQF2IAMQwhYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQzx0gBEG4HmoiAiABEMoGIAIQmB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNWCAEQe8DaiIDIARBxxlqKQAANwAAIARB6ANqIgUgBEHAGWopAwA3AwAgBEGABGoiCCAGKQMANwMAIARBiARqIgYgBykDADcDACAEIAQpA7gZNwPgAyAEIAQpA7gPNwP4A0E4QQQQrTYiAUUNYiABIAI6AAggAUKBgICAEDcCACABIAQpA+ADNwAJIAEgBCkD+AM3AiAgAEH0hIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxhCyAEQYAfaiEOIAEgAhC1IiIKKAIQIQIgCigCFEECdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF4cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCAIKAIYIQIgCCgCFEEBRg1tIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayIHJAAgCEEIaiICIAUoAgQgBSgCAGtBA3YQ7i0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiINKAIEIQsgDSgCACESAkAgB0EIaiIFKAIAIgkgBSgCBCIPRwRAIAUoAhQhDCAFKAIQIRMgBSgCDCEUIAUoAgghBSANKAIIIAtBAnRqIQ0gDyAJa0EDdiEPA0AgAiAJNgIMAkAgCSgCACIRIBNJBEAgFCARQQJ0aioCACEbDAELIAUgDCgCEE8Nd0MAAAAAIRsgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXgLIA0gGzgCACAJQQhqIQkgDUEEaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCNGwsgDiAGEOgYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARC+HSAEQbgeaiIBIAoQygYgARCTHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1WIARBnwRqIgMgBEHHGWopAAA3AAAgBEGYBGoiBSAEQcAZaikDADcDACAEQbAEaiIIIAYpAwA3AwAgBEG4BGoiBiAHKQMANwMAIAQgBCkDuBk3A5AEIAQgBCkDuA83A6gEQThBBBCtNiIBRQ1hIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAQ3AAkgASAEKQOoBDcCICAAQcyFggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGALIARBgB9qIQ4gASACEKYiIgooAhAhAiAKKAIUQQN2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBCEEIEKAYIAgoAhghAiAIKAIUQQFGDWwgCEEQaiIQQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDsLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg0oAgQhCyANKAIAIRICQCAHQQhqIgUoAgAiCSAFKAIEIg9HBEAgBSgCFCEMIAUoAhAhEyAFKAIMIRQgBSgCCCEFIA0oAgggC0EDdGohDSAPIAlrQQN2IQ8DQCACIAk2AgwCQCAJKAIAIhEgE0kEQCAUIBFBA3RqKwMAIRwMAQsgBSAMKAIQTw12RAAAAAAAAAAAIRwgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXcLIA0gHDkDACAJQQhqIQkgDUEIaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahD7GgsgDiAGEOcYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARDbHSAEQbgeaiIBIAoQygYgARCQHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1UIARBzwRqIgMgBEHHGWopAAA3AAAgBEHIBGoiBSAEQcAZaikDADcDACAEQeAEaiIIIAYpAwA3AwAgBEHoBGoiBiAHKQMANwMAIAQgBCkDuBk3A8AEIAQgBCkDuA83A9gEQThBBBCtNiIBRQ1gIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAQ3AAkgASAEKQPYBDcCICAAQaSGggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADF8LIAEgAhCzIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC8HSABQdQAaiIGIAIQygYgBhDyHCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHgB2ogBEGwGmopAgA3AgAgBEHoB2ogBEG4GmopAgA3AgAgBEHJB2ogAykDADcAACAEQdAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC2AcgBCABOgDAByAEIBc3AMEHIARBwAdqENwpIQEgAEH8hoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADF4LIAEgAhChIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDAHSABQdQAaiIGIAIQygYgBhD1HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGQCGogBEGwGmopAgA3AgAgBEGYCGogBEG4GmopAgA3AgAgBEH5B2ogAykDADcAACAEQYAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCiAggBCABOgDwByAEIBc3APEHIARB8AdqENwpIQEgAEHUh4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADF0LIAEgAhCdIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDDHSABQdQAaiIGIAIQygYgBhD6HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHACGogBEGwGmopAgA3AgAgBEHICGogBEG4GmopAgA3AgAgBEGpCGogAykDADcAACAEQbAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCuAggBCABOgCgCCAEIBc3AKEIIARBoAhqENwpIQEgAEGsiIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFwLIAEgAhCuIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDQHSABQdQAaiIGIAIQygYgBhD5HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHwCGogBEGwGmopAgA3AgAgBEH4CGogBEG4GmopAgA3AgAgBEHZCGogAykDADcAACAEQeAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC6AggBCABOgDQCCAEIBc3ANEIIARB0AhqENwpIQEgAEGEiYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFsLIAEgAhC4IiECIwBB4ABrIgEkACABIAIoAhAgAigCFEECdiADEMMWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC9HSABQdQAaiIGIAIQygYgBhD0HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNSiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHQBmogBEGwGmopAgA3AgAgBEHYBmogBEG4GmopAgA3AgAgBEG5BmogAykDADcAACAEQcAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCyAYgBCABOgCwBiAEIBc3ALEGIARBsAZqENwpIQEgAEHciYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFoLIAEgAhCjIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEDdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQRBCBCgGCAIKAIYIQYgCCgCFEEBRg1nIAhBEGoiE0EANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6i0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACEUAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIREgCSgCDCEVIAkoAgghCSANKAIIIAxBA3RqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIQIBFJBEAgFSAQQQN0aiISKAIEIRAgEigCACESDAELIAkgDigCEE8NcEEAIRBBACESIA4oAgQgCSAOKAIMaiIWQQN2ai0AACAWQQdxdkEBcQ1yCyANIBI2AgAgDUEEaiAQNgIAIAtBCGohCyANQQhqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBQgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogEygCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEJUbCyAFIAcQ6xggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDTHSAFQdQAaiIBIAoQygYgARD3HCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNSCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGAB2ogBEGwGmopAgA3AgAgBEGIB2ogBEG4GmopAgA3AgAgBEHpBmogAykDADcAACAEQfAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC+AYgBCABOgDgBiAEIBc3AOEGIARB4AZqENwpIQEgAEG0ioIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFkLIAEgAhCgIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEEdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQhBEBCgGCAIKAIYIQYgCCgCFEEBRg1mIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6S0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACESAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIRMgCSgCDCEUIAkoAgghCSANKAIIIAxBBHRqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIRIBNJBEAgAUEYaiAUIBFBBHRqIhFBCGopAwA3AwAgASARKQMANwMQDAELIAkgDigCEE8NbyAOKAIEIAkgDigCDGoiEUEDdmotAAAgEUEHcXZBAXENcSABQRhqQgA3AwAgAUIANwMQCyANIAEpAxA3AwAgDUEIaiABQRhqKQMANwMAIAtBCGohCyANQRBqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBIgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogECgCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEP4aCyAFIAcQ6hggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDFHSAFQdQAaiIBIAoQygYgARDxHCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNRiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGwB2ogBEGwGmopAgA3AgAgBEG4B2ogBEG4GmopAgA3AgAgBEGZB2ogAykDADcAACAEQaAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCqAcgBCABOgCQByAEIBc3AJEHIARBkAdqENwpIQEgAEGMi4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADFgLIARBgB9qIgYgASACEKciIgEoAhAgASgCFEECdiADEMMWIARBiBVqIgIgARCSNiADEPMSIARBkBpqIgMgBiACEModIARBuB5qIgIgARDKBiACENAYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUQgBEH/BGoiAyAEQccZaikAADcAACAEQfgEaiIFIARBwBlqKQMANwMAIARBkAVqIgggBikDADcDACAEQZgFaiIGIAcpAwA3AwAgBCAEKQO4GTcD8AQgBCAEKQO4DzcDiAVBOEEEEK02IgFFDVggASACOgAIIAFCgYCAgBA3AgAgASAEKQPwBDcACSABIAQpA4gFNwIgIABB5IuCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVwsgBEGAH2oiBiABIAIQqyIiASgCECABKAIUQQN2IAMQxBYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQxh0gBEG4HmoiAiABEMoGIAIQ0hggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQiAEQa8FaiIDIARBxxlqKQAANwAAIARBqAVqIgUgBEHAGWopAwA3AwAgBEHABWoiCCAGKQMANwMAIARByAVqIgYgBykDADcDACAEIAQpA7gZNwOgBSAEIAQpA7gPNwO4BUE4QQQQrTYiAUUNVyABIAI6AAggAUKBgICAEDcCACABIAQpA6AFNwAJIAEgBCkDuAU3AiAgAEG8jIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxWCyAEQYAfaiEJIAEgAhC8IiIFKAIQIQIgBSgCFEEEdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCELIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAggC0F4cWo2AhAgASAINgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBygCBCAHKAIAa0EDdkEAQRBBEBCgGCAIKAIYIQIgCCgCFEEBRg1iIAhBEGoiCkEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayICJAAgCEEIaiILIAcoAgQgBygCAGtBA3YQ6y0gCykCBCEXIAJBGGogB0EQaikCADcDACACQRBqIAdBCGopAgA3AwAgAiAHKQIANwMIIAIgF0IgiTcCKCACIAtBCGo2AiQgAkEIaiACQSRqEKkQIAJBMGokACAGQQhqIAooAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEIIAEgBjYCGCABIAI2AhQgASAHIAhBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCJGwsgCSAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDzEiAEQZAaaiIDIAkgARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAgoAhghAiAIKAIUQQFGDWEgCEEQaiISQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCyAOKAIAIRMCQCAHQQhqIgUoAgAiCSAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIREgBSgCCCEKIA4oAgggC0EFdGohBSAQIAlrQQN2IRADQCACIAk2AgwCQCAJKAIAIg4gFEkEQCARIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyAKIA0oAhBPDWtCACEaQgAhGUIAIRhCACEXIA0oAgQgCiANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1sCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCUEIaiEJIAVBIGohBSAKQQFqIQogC0EBaiELIBBBAWsiEA0ACwsgEyALNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiASKAIANgIAIAYgCCkCCDcCACAIQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXhxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhRsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8xIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9iggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAGLQABQQFrDgMGBwgFCyAGLQABDgIKCzoLIAYtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiAiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCACIAEgAyAGKAIEENQVIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiICIAQoAigiASAEKAIsKAIMEQAAIAFFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCACIAEgAyAGKAIEEOkCIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENg8IAMQ2DwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjwIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJ4CIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMoWIAdBDGogARCTNiADEPMSIAEoAgQhCSAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAJKAIAIgggCCgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAkpAgQ3AgAgAiAINgIAIAJBDGohAiALQQxrIQsgCUEMaiEJIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQkAIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCfAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDKFiAHQQxqIAEQkzYgAxDzEiABKAIEIQkgB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCSgCACIIIAgoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAJKQIENwIAIAIgCDYCACACQQxqIQIgC0EMayELIAlBDGohCSAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADELgCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmogASACEJEiIAMQuQIgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQkjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQsjAEEwayIBJAAgAUEIaiACQSBqIgcQhCgCQAJAAkAgASgCCCIKBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIIIA02AgQgCCAKNgIAIAFBHGoiD0EBNgIAIAEgCDYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQhCggBSgCCCIIBEAgAUEUaiEKIAUoAgwhBwNAIAooAggiDSAKKAIARgRAIApBARDqLQsgCigCBCANQQN0aiIQIAc2AgQgECAINgIAIAogDUEBajYCCCAFIAwQhCggBSgCBCEHIAUoAgAiCA0ACwsgBUEQaiQAIAtBCGogDygCADYCACALIAEpAhQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCSACKQIANwIAIAlBEGogAkEQaigCADYCACAJQQhqIAJBCGopAgA3AgAgCxDDJyALEOo7DAELIAkgAikCFDcCBCAJQZOAgIB4NgIAIAlBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIBEP8YIAEgAxC+LSAEIA42ArQaIARBhBFqIAEQ8BggBCgCwA8EQCAEQZAVaiAEQcAPaigCADYCACAEQZwVaiAEQYwRaigCADYCACAEIAQpArgPNwOIFSAEIAQpAoQRNwKUFSABIARBiBVqEK0QIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmoiASAEQYQRakEAIANBDGoiAhDYPBDyFSAEQYgVaiIDIAEQ4ScgASACENg8IAMQ1RggARDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCACAEQbgPaiIAEO4fIAAQ6DsMOAsgBkEEaiEHIAYtAAENCyAEQfwYaiAHKAIEEOojIARB2ABqIAEgAigCEBEAACAEQZAaaiAEKAJYIgIgBCgCXCgCDBEAACACRQ0GIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNBiAEQYAfaiACKAIcIAIoAiAgAxDFFiAEQdAAaiAHELAuIAQoAlAiASAEKAJUIgtGDQoDQCAEQZAaaiACIAEtAAAQ2ShBiJ+CASADEIcBIAQoApgaIQUgBCgClBohCCAEKAKQGiIJQZOAgIB4RwRAIAAgBCkCnBo3AgwgACAFNgIIIAAgCDYCBCAAIAk2AgAgBCgCgB8iACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBgB9qEPseCyAEQfwYaiIAEMMnIAAQ6jsMOQsgBCgChBkiCSAEKAL8GEYEQCAEQfwYakHgn4IBEJsoCyAEKAKAGSAJQQN0aiIKIAU2AgQgCiAINgIAIAQgCUEBajYChBkgAUEIaiIBIAtHDQALDAoLIAEgBxEEACIGLQAAQSJGDQggBCAGNgK4DyAEQQE2ApQaIARB7KaCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakH0poIBEO8sAAsgBEGQGmoiBiABIAIQxy8Qjw4gBEG4D2oiBSAGEPwVIAYgBSADELgCIAQtAJAaIgJBKUYNBiAEQZcVaiIDIARBoBpqKQAANwAAIARBkBVqIgggBEGZGmopAAA3AwAgBEGQEGogBEGwGmopAgA3AgAgBEGYEGogBEG4GmopAgA3AgAgBEGgEGogBEHAGmopAgA3AgAgBEH5D2ogCCkDADcAACAEQYAQaiADKQAANwAAIAQgBCkCqBo3AogQIAQgAjoA8A8gBCAEKQCRGjcA8Q8gBEGIFWoiAiAEQfAPahCEPiAGIAIQoRsgAiABIAcRBAAQygYgBEGoEGoiASAGIAIQjBggAiABEM0cIAYgAhC4BiAGEPcpIQEgAEGEp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAUQyR4MNQsgASAHEQQAIgYtAABBKEYNBCAEIAY2ArgPIARBATYClBogBEH8qoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQYSrggEQ7ywAC0HQjoIBELI7AAtBgJeCARCyOwALQfibggEQsjsAC0GgnoIBELI7DAULAkACQAJAAkACQAJAIAYoAgQiBi0AMEEDaw4DAQIDAAsgBCAGQTBqNgK4DyAEQQE2ApQaIARBsKqCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakG4qoIBEO8sAAsgBEGQGmohDSABIAIQnCIhDiMAQeAEayIFJAACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NTCAGKAIAIgMgCk8NTQJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAVCIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NVCABKAIAIgEgCk8NVSAPIAhBA3RqKQMAIA8gAUEDdGopAwBUDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVMgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWg0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOwKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuhUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAXZPDQQgAyALQQF0aiEGIAkgC2oLIgxBAWohCSAGQQJqIQNBACELIAEgAk8NACABQQJ0IQogBi4BACASayEPA0AgASAFKAJUIgZPDUUgBSgCUCAKaigCACIGIAJPDUYgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRyAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggA0GAgAJPDQkgBSgCLCIGQQJqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQJqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzsAACAFIAUoAixBAmo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEELIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAIQYCAAk8NAiAFKAIsIgJBAmoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkECaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg7AAAgBSAFKAIsQQJqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBg4aMGDYCACAFQoOGjJiw4MCBAzcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGJkqTIADYCACAFQomSpMiQocKECTcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCygCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADEK4TIAMgDkEgakGIn4IBIAFBnISCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAoQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQnwkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAwtBf0EAQZCvggEQwyEAC0Gwr4IBELI7AAtB0K+CARCyOwALIAQtAJAaIgFBKUYNAyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG4FmogBEGwGmopAgA3AgAgBEGhFmogAykDADcAACAEQagWaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCsBYgBCABOgCYFiAEIBc3AJkWIARBmBZqEPUpIQEgAEHcp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIARBkBpqIQ0gASACEJoiIQ4jAEHgBGsiBSQAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NSSAGKAIAIgMgCk8NSgJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAVCIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NUSABKAIAIgEgCk8NUiAPIAhBA3RqKQMAIA8gAUEDdGopAwBUDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVAgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWg0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOoKDAILDEwLIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuhUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDT4gBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABDfGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF8cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAnZPDQQgAyALQQJ0aiEGIAkgC2oLIgxBAWohCSAGQQRqIQNBACELIAEgAk8NACABQQJ0IQogBigCACASayEPA0AgASAFKAJUIgZPDUIgBSgCUCAKaigCACIGIAJPDUMgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRCAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQSAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUEgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQRqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NPyACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD4LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNPiACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGJkqTIADYCACAFQomSpMiQocKECTcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNPiACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCygCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADEK4TIAMgDkEgakGIn4IBIAFBnISCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAoQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQngkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQtBf0EAQZCvggEQwyEACyAELQCQGiIBQSlGDQEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4BZqIARBsBpqKQIANwIAIARByRZqIAMpAwA3AAAgBEHQFmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgWIAQgAToAwBYgBCAXNwDBFiAEQcAWahD1KSEBIABBtKiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZAaaiENIAEgAhCbIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAIAMoAhQiAUEHTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIRIgDigCGCETIAVBzABqIAFBA3YiAkG8/IEBEKQaIAUoAlAhByAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAchBiABDQEgBigCBCIIIAVB1ANqIhQoAgAiASgCBCIKTw1HIAYoAgAiAyAKTw1IAkACQAJAAkAgASgCACIPIAhBA3RqKQMAIA8gA0EDdGopAwBUIhFFBEBBAiEJIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCCAKTw1PIAEoAgAiASAKTw1QIA8gCEEDdGopAwAgDyABQQN0aikDAFQNAiADIQEgDCAJQQFqIglHDQALDAILQQIhCSAMQQJGDQAgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NTiABKAIAIgEgCk8NBCAPIAhBA3RqKQMAIA8gAUEDdGopAwBaDQEgAyEBIAwgCUEBaiIJRw0ACwwBCyAJIAxHDQELIBFFDQMgDEEBdiEDIAxBAnQgBmpBBGshCANAIAYoAgAhASAGIAgoAgA2AgAgCCABNgIAIAhBBGshCCAGQQRqIQYgA0EBayIDDQALDAMLIAYgDEEAIAxBAXJnQQF0QT5zIBQQ4goMAgsMSgsgDEECdCEBQQQhBgNAIAcgBiAHaiAFQdQDahC6FSABIAZBBGoiBkcNAAsLAkACQCAMRQ0AIAcgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NPCAFIBAgAUEDdGooAgAiATYC3AQgASATSQRAQQAhCCASBEAgDkEMakEAEMgZIQsLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQXhxaiEJQQAhAQNAAn8gC0UEQCADIQYgCCADIAlHDQEaDAULIAsgCSADa0EDdk8NBCADIAtBA3RqIQYgCCALagsiDEEBaiEIIAZBCGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBJrIQ8DQCABIAUoAlQiBk8NQCAFKAJQIApqKAIAIgYgAk8NQSAPIBAgBkEDdGooAgBNDQEgBiAFKALcAyIHTw1CIAUoAtgDIAZBAnRqIAw2AgAgCkEEaiEKIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNQUHAAEHAABCtNiIBRQ0/IAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUFBwABBwAAQrTYiAUUNPyAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4QQEhCyAFKAIYIgdBAk8EQCAHrSEYQQAhA0IBIRcDQCAFKAIUIANqIgFBBGooAgAgASgCACIBRwRAIAUoAkQiCEEIaiIGIAUoAjwiAksEQCAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRCIIQQhqIQYgBSgCPCECCyACIAZJBH8gBUE4aiACQQF0IgIgBhDSKiIGIAIgBksbEOgZIAUoAkQFIAgLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCICQQhqIgEgBSgCJCIGSwRAIAVBIGogBkEBdCICIAEQ0ioiASABIAJJGxDoGSAFKAIkIQYgBSgCLCICQQhqIQELIAEgBksEfyAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCLAUgAgsgBSgCKGogFzcAACAFIAUoAixBCGo2AiwgBSAFKAIwQQFqNgIwIAtBAWohCwsgA0EEaiEDIBggF0IBfCIXUg0ACwsgB0EBayEBIAdFDQQgBSgCFCABQQJ0ajUCACEXIAUoAkQiBkEIaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRCIGQQhqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQFIAYLIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBCGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiBkEIaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSAGCyAFQShqIgIoAgBqIAetNwAAIAUgBSgCLEEIaiIDNgIsIAUgBSgCMEEBajYCMCAFQaADaiIHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgBUGcAmoiARCXKSACKAIAIQggAiAFQaQCaiIGKQIANwMAIAUpAyAhFyAFIAUpApwCNwMgIAVBADYCMCAFIBc3AqgCIAVBADYCpAIgBSADNgKgAiAFIAg2ApwCIAVBCGogARDXOyAFKAIIIQhBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAVBrAJqIgkoAgA2AgAgBSADNgLcAyAFIAg2AtgDIAUgAjYC1AMgASAFQfgCaiIDIAVB1ANqIggQ+iMgBUHMAGoiCiABEM0cIAdBiZKkyAA2AgAgBUKJkqTIkKHChAk3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgARCXKSAFQUBrIgIoAgAhCyAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAs2ApwCIAUgARDXOyAFKAIAIQtBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAkoAgA2AgAgBSAHNgLcAyAFIAs2AtgDIAUgAjYC1AMgASADIAgQ+iMgAyABEM0cIAVBkAFqIgEgAxCuEyADIA5BIGpBiJ+CASABQZyEggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhGDQIgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAMLIAEgBSgCVCIDTw09IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPAsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQoAkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQsgAUEAQZCvggEQwyEACyAELQCQGiIBQSlHBEAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBiBdqIARBsBpqKQIANwIAIARB8RZqIAMpAwA3AAAgBEH4FmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AoAXIAQgAToA6BYgBCAXNwDpFiAEQegWahD1KSEBIABBjKmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwxCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwwCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwvCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAACAEQbgPahDJHgwuCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAgQiBi0AAEECaw4IAQIDBAUGBwgACyAEIAY2ArgPIARBATYClBogBEGcpoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQaSmggEQ7ywACyAEQZAaaiEGIAEgAhDEIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDjFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQ0gBEGIFWoiAiAGQcQA/AoAACAEQdcRaiAEQdcaai0AADoAACAEIAQvANUaOwDVESAEQZARaiIDIAJBxAD8CgAAIAQgAToA1BEgAxDrKSEBIABBkKCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw7CyAEQZAaaiEGIAEgAhDBIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxChFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQsgBEGIFWoiAiAGQcQA/AoAACAEQZ8SaiAEQdcaai0AADoAACAEIAQvANUaOwCdEiAEQdgRaiIDIAJBxAD8CgAAIAQgAToAnBIgAxDrKSEBIABB6KCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEGIAEgAhDAIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCiFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQkgBEGIFWoiAiAGQcQA/AoAACAEQecSaiAEQdcaai0AADoAACAEIAQvANUaOwDlEiAEQaASaiIDIAJBxAD8CgAAIAQgAToA5BIgAxDrKSEBIABBwKGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiEGIAEgAhDDIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCjFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQcgBEGIFWoiAiAGQcQA/AoAACAEQa8TaiAEQdcaai0AADoAACAEIAQvANUaOwCtEyAEQegSaiIDIAJBxAD8CgAAIAQgAToArBMgAxDrKSEBIABBmKKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAEQZAaaiEGIAEgAhDCIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDkFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQUgBEGIFWoiAiAGQcQA/AoAACAEQfcTaiAEQdcaai0AADoAACAEIAQvANUaOwD1EyAEQbATaiIDIAJBxAD8CgAAIAQgAToA9BMgAxDrKSEBIABB8KKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAEQZAaaiEGIAEgAhC/IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCkFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQMgBEGIFWoiAiAGQcQA/AoAACAEQb8UaiAEQdcaai0AADoAACAEIAQvANUaOwC9FCAEQfgTaiIDIAJBxAD8CgAAIAQgAToAvBQgAxDrKSEBIABByKOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw2CyAEQZAaaiEGIAEgAhC+IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxClFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQEgBEGIFWoiAiAGQcQA/AoAACAEQYcVaiAEQdcaai0AADoAACAEIAQvANUaOwCFFSAEQcAUaiIDIAJBxAD8CgAAIAQgAToAhBUgAxDrKSEBIABBoKSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZAaaiEGIAEgAhC9IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCmFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJHBEAgBEGIFWoiAiAGQcQA/AoAACAEQZcWaiAEQdcaai0AADoAACAEIAQvANUaOwCVFiAEQdAVaiIDIAJBxAD8CgAAIAQgAToAlBYgAxDrKSEBIABB+KSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAw0CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwzCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwyCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwxCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwwCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwvCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwuCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwtCyAHKAIAIgEgASgCACICQQFqNgIAIAJBAEgNASAGKAIIIQIgBEHAHmogBEGIH2ooAgA2AgAgBCAEKQKAHzcDuB4gBEEANgK4GSAEQcAPaiAEQYQZaigCADYCACAEIAQpAvwYNwO4DyAEQZAaaiABIAIgBEG4HmogBEG4GWogBEG4D2oQkQQgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGBEAgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADC0LIARBsBlqIARBuBpqKQIANwIAIARBqBlqIARBsBpqKQIANwIAIARBlBlqIAEpAwA3AgAgBEGcGWogAigCADYCACAEIAQpAqgaNwKgGSAEIAM2AogZIAQgBCkDiBU3AowZIARBiBlqENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCwLIARByABqIAEgAigCEBEAACAEQZAaaiICIAQoAkgiASAEKAJMKAIMEQAAAkACQCABRQ0AIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNACAEQYgVaiIFIAEoAhwgASgCICADEMUWIARBADYC6BkgBEGgGmogBEH4GWopAgA3AwAgBEGYGmogBEHwGWopAgA3AwAgBCAEKQLoGTcDkBogBEG4GWoiCCAFIAIQ2B0gARCTNiIJRQ0BIAIgCSgCBCAJKAIIQQJ2IAMQwxYgBEG4D2oiAyACIARB6BlqEL8dIARBQGsgBxCwLiAEKQNAIRcgBCABNgKgGiAEIBc3ApAaIAQgAzYCnBogBCAINgKYGiAFIAIQuxUgBEHAHmoiASAEQZQVaigCADYCACAEIAQpAowVNwO4HiAEKAKIFSICQZOAgIB4RwRAIAQoApgVIQYgACAEKQO4HjcCBCAAIAY2AhAgACACNgIAIABBDGogASgCADYCACADEP4kIAgQ/iQMLgsgBEGIGmogBEHAHmooAgA2AgAgBCAEKQO4HjcDgBogBEGQGmoiAUEAQYAE/AsAIAQgBCgCyBkiAjYCiBUgBCACIARBzBlqIgMoAgBqNgKMFSAEIAE2ApAVIARBnB5qIARBiBVqIgEQvCwgBEGwHmogAygCACICNgIAIARBnBVqIAI2AgAgBEGoFWogBEHYGWopAgA3AwAgBEGwFWogBEHgGWopAgA3AwAgBEGQFWogBEHAGWooAgA2AgAgBCAEKQLEGSIXNwOoHiAEIBc3ApQVIAQgBCkC0Bk3A6AVIAQgBCkCuBk3A4gVIAEQtAwCQCAEKAKgFSIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQaAVahD7HgsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQIgBigCCCECIARBiB9qIARBpB5qKAIANgIAIAQgBCkCnB43A4AfIARBiBVqIAEgAiAEQageaiAEQYAfaiAEQYAaahCRBCAEQcAeaiIBIARBlBVqKQIANwMAIARByB5qIgIgBEGcFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiA0GAgICAeEYEQCAAIAQpA7geNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBEG4D2oQ/iQMLgsgBEH4HmogBEGwFWopAgA3AgAgBEHwHmogBEGoFWopAgA3AgAgBEHcHmogASkDADcCACAEQeQeaiACKAIANgIAIAQgBCkCoBU3AugeIAQgAzYC0B4gBCAEKQO4HjcC1B4gBEHQHmoQ3CkhASAAQbCeggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oQ/iQMLQtB8J+CARCyOwALQYCgggEQsjsACwALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCgLIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwnCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwmCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwlCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGAsgBEEIakHEjoIBIAMQoSsgACAEKQMINwIEIABBk4CAgHg2AgAMFwsgBCAGNgK4DyAEQQE2ApQaIARByKuCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakHQq4IBEO8sAAsgBEGTBmogASgAACIBNgAAIARBiwZqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwCDBiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwVCyAEQeMFaiABKAAAIgE2AAAgBEHbBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3ANMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBQLIARBswVqIAEoAAAiATYAACAEQasFaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAowUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEwsgBEGDBWogASgAACIBNgAAIARB+wRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDzBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwSCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwRCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwQCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwPCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwOCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwNCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwMCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwLCyAEQdMEaiABKAAAIgE2AAAgBEHLBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AMMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAoLIARBowRqIAEoAAAiATYAACAEQZsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAkwQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCQsgBEHzA2ogASgAACIBNgAAIARB6wNqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDjAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwICyAEQcMDaiAEQaQaaigCACIBNgAAIARBuwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCzAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwHCyAEQZMDaiAEQaQaaigCACIBNgAAIARBiwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCDAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwGCyAEQeMCaiAEQaQaaigCACIBNgAAIARB2wJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDTAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwFCyAEQbMCaiAEQaQaaigCACIBNgAAIARBqwJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCjAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwECyAEQYMCaiAEQaQaaigCACIBNgAAIARB+wFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDzASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwDCyAEQdMBaiAEQaQaaigCACIBNgAAIARBywFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDDASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwCCyAEQaMBaiAEQaQaaigCACIBNgAAIARBmwFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCTASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwBCyAEQfMAaiAEQaQaaigCACIBNgAAIARB6wBqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwBjIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAACyAEQZAfaiQADwtBBEE4EKM9AAsgASACQbjxgQEQwyEACyABIAZB7PKBARDDIQALIAYgAkH88oEBEMMhAAsgBiAHQYzzgQEQwyEACyABIAJB6PGBARDDIQALIAEgA0HY8YEBEMMhAAtBwABBwAAQoz0AC0EEQRwQoz0AC0HA9IEBQSkgBUH4AmpBzPyBAUHs9IEBENUeAAsgAiAIKAIcQbz8gQEQ/S8ACyAGIAgoAhxBvPyBARD9LwALIAggCkHw9oMBEMMhAAsgAyAKQYD3gwEQwyEACyAIIApB8PaDARDDIQALIAEgCkGA94MBEMMhAAtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQboTNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgAUEBNgIUIAFB3LaCATYCECABQgE3AhwgAUG6EzYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpB5LaCARDvLAALje4CBBN/BH4BfQF8IwBBkB9rIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASACKAIcIgcRBAAiBi0AAEECaw4lAwQFBgcICQoLDA0AAAAAAAECAAAAAAAAAAAAAAAAAAAAFRYXGAALIAEgBxEEACIGLQAADikeGFVVVVVVVVVVVVVVGSMkGhtVVSkcKywtLi8wVR0yVTM0NVVVVVU2N1ULIAYtAAFBAWsOAw0ODwwLIAYtAAFBAWsOAhARDwsgBEGQGmogASACELsiIAMQ4RYgBC0AkBoiAkEpRg1oIARB7wBqIgMgBEGgGmopAAA3AAAgBEHoAGoiBiAEQZkaaikAADcDACAEQYABaiIHIARBsBpqKQIANwMAIARBiAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDYCAEIAQpAqgaNwN4QThBBBCtNiIBRQ1qIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDYDcACSABIAQpA3g3AiAgAEG0/4EBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxpCyAEQZAaaiABIAIQqCIgAxCbFiAELQCQGiICQSlGDWYgBEGfAWoiAyAEQaAaaikAADcAACAEQZgBaiIGIARBmRpqKQAANwMAIARBsAFqIgcgBEGwGmopAgA3AwAgBEG4AWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwOQASAEIAQpAqgaNwOoAUE4QQQQrTYiAUUNaSABIAI6AAggAUKBgICAEDcCACABIAQpA5ABNwAJIAEgBCkDqAE3AiAgAEGMgIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxoCyAEQZAaaiABIAIQsSIgAxCcFiAELQCQGiICQSlGDWQgBEHPAWoiAyAEQaAaaikAADcAACAEQcgBaiIGIARBmRpqKQAANwMAIARB4AFqIgcgBEGwGmopAgA3AwAgBEHoAWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPAASAEIAQpAqgaNwPYAUE4QQQQrTYiAUUNaCABIAI6AAggAUKBgICAEDcCACABIAQpA8ABNwAJIAEgBCkD2AE3AiAgAEHkgIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxnCyAEQZAaaiABIAIQpCIgAxCdFiAELQCQGiICQSlGDWIgBEH/AWoiAyAEQaAaaikAADcAACAEQfgBaiIGIARBmRpqKQAANwMAIARBkAJqIgcgBEGwGmopAgA3AwAgBEGYAmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPwASAEIAQpAqgaNwOIAkE4QQQQrTYiAUUNZyABIAI6AAggAUKBgICAEDcCACABIAQpA/ABNwAJIAEgBCkDiAI3AiAgAEG8gYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxmCyAEQZAaaiABIAIQqiIgAxDiFiAELQCQGiICQSlGDWAgBEGvAmoiAyAEQaAaaikAADcAACAEQagCaiIGIARBmRpqKQAANwMAIARBwAJqIgcgBEGwGmopAgA3AwAgBEHIAmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwOgAiAEIAQpAqgaNwO4AkE4QQQQrTYiAUUNZiABIAI6AAggAUKBgICAEDcCACABIAQpA6ACNwAJIAEgBCkDuAI3AiAgAEGUgoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxlCyAEQZAaaiABIAIQrSIgAxCeFiAELQCQGiICQSlGDV4gBEHfAmoiAyAEQaAaaikAADcAACAEQdgCaiIGIARBmRpqKQAANwMAIARB8AJqIgcgBEGwGmopAgA3AwAgBEH4AmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPQAiAEIAQpAqgaNwPoAkE4QQQQrTYiAUUNZSABIAI6AAggAUKBgICAEDcCACABIAQpA9ACNwAJIAEgBCkD6AI3AiAgAEHsgoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxkCyAEQZAaaiABIAIQtyIgAxCfFiAELQCQGiICQSlGDVwgBEGPA2oiAyAEQaAaaikAADcAACAEQYgDaiIGIARBmRpqKQAANwMAIARBoANqIgcgBEGwGmopAgA3AwAgBEGoA2oiBSAEQbgaaikCADcDACAEIAQpAJEaNwOAAyAEIAQpAqgaNwOYA0E4QQQQrTYiAUUNZCABIAI6AAggAUKBgICAEDcCACABIAQpA4ADNwAJIAEgBCkDmAM3AiAgAEHEg4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxjCyAEQZAaaiABIAIQoiIgAxCgFiAELQCQGiICQSlGDVogBEG/A2oiAyAEQaAaaikAADcAACAEQbgDaiIGIARBmRpqKQAANwMAIARB0ANqIgcgBEGwGmopAgA3AwAgBEHYA2oiBSAEQbgaaikCADcDACAEIAQpAJEaNwOwAyAEIAQpAqgaNwPIA0E4QQQQrTYiAUUNYyABIAI6AAggAUKBgICAEDcCACABIAQpA7ADNwAJIAEgBCkDyAM3AiAgAEGchIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxiCyAEQYAfaiIGIAEgAhC5IiIBKAIQIAEoAhRBAXYgAxC+FiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDPHSAEQbgeaiICIAEQygYgAhCYHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1YIARB7wNqIgMgBEHHGWopAAA3AAAgBEHoA2oiBSAEQcAZaikDADcDACAEQYAEaiIIIAYpAwA3AwAgBEGIBGoiBiAHKQMANwMAIAQgBCkDuBk3A+ADIAQgBCkDuA83A/gDQThBBBCtNiIBRQ1iIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD4AM3AAkgASAEKQP4AzcCICAAQfSEggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGELIARBgB9qIQ4gASACELUiIgsoAhAhASALKAIUQQJ2IQIjAEEwayIHJAACQAJAIAMQkjYiBkUNACAGKAIURQ0AIAMoAhAhBSADKAIUIQggByAGNgIgIAcgAjYCHCAHIAE2AhggB0EANgIUIAcgBSAIQXxxajYCECAHIAU2AgwgB0EkaiEGIwBBIGsiCSQAIAlBFGogB0EMaiIBKAIEIAEoAgBrQQJ2QQBBBEEEEKAYIAkoAhghAiAJKAIUQQFGDW0gCUEQaiIQQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQRBrIggkACAJQQhqIgIgASgCBCABKAIAa0ECdhDuLSAIIAIpAgRCIIk3AgggCCACQQhqNgIEIwBBMGsiAiQAIAhBBGoiDSgCBCEKIA0oAgAhEQJAIAEoAgAiBSABKAIEIg9HBEAgASgCFCEMIAEoAhAhEyABKAIMIRQgASgCCCEBIA0oAgggCkECdGohDSAPIAVrQQJ2IQ8DQCACIAU2AgwCQCATIAUoAgAiEksEQCAUIBJBAnRqKgIAIRsMAQsgASAMKAIQTw14QwAAAAAhGyAMKAIEIAEgDCgCDGoiEkEDdmotAAAgEkEHcXZBAXENeQsgDSAbOAIAIAVBBGohBSANQQRqIQ0gAUEBaiEBIApBAWohCiAPQQFrIg8NAAsLIBEgCjYCACACQTBqJAAMAAsgCEEQaiQAIAZBCGogECgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhBiADKAIUIQUgByACNgIYIAcgATYCFCAHIAYgBUF8cWo2AhAgByAGNgIMIAdBJGoiBiAHQQxqEI4bCyAOIAYQ6BggB0EwaiQAIARBiBVqIgEgCxCSNiADEPISIARBkBpqIgMgDiABEL4dIARBuB5qIgEgCxDKBiABEJMeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVYgBEGfBGoiAyAEQccZaikAADcAACAEQZgEaiIFIARBwBlqKQMANwMAIARBsARqIgggBikDADcDACAEQbgEaiIGIAcpAwA3AwAgBCAEKQO4GTcDkAQgBCAEKQO4DzcDqARBOEEEEK02IgFFDWEgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQBDcACSABIAQpA6gENwIgIABBzIWCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMYAsgBEGAH2ohDiABIAIQpiIiCygCECEBIAsoAhRBA3YhAiMAQTBrIgckAAJAAkAgAxCSNiIGRQ0AIAYoAhRFDQAgAygCECEFIAMoAhQhCCAHIAY2AiAgByACNgIcIAcgATYCGCAHQQA2AhQgByAFIAhBfHFqNgIQIAcgBTYCDCAHQSRqIQYjAEEgayIJJAAgCUEUaiAHQQxqIgEoAgQgASgCAGtBAnZBAEEIQQgQoBggCSgCGCECIAkoAhRBAUYNbCAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiCCQAIAlBCGoiAiABKAIEIAEoAgBrQQJ2EOwtIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEEwayICJAAgCEEEaiINKAIEIQogDSgCACERAkAgASgCACIFIAEoAgQiD0cEQCABKAIUIQwgASgCECETIAEoAgwhFCABKAIIIQEgDSgCCCAKQQN0aiENIA8gBWtBAnYhDwNAIAIgBTYCDAJAIBMgBSgCACISSwRAIBQgEkEDdGorAwAhHAwBCyABIAwoAhBPDXdEAAAAAAAAAAAhHCAMKAIEIAEgDCgCDGoiEkEDdmotAAAgEkEHcXZBAXENeAsgDSAcOQMAIAVBBGohBSANQQhqIQ0gAUEBaiEBIApBAWohCiAPQQFrIg8NAAsLIBEgCjYCACACQTBqJAAMAAsgCEEQaiQAIAZBCGogECgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhBiADKAIUIQUgByACNgIYIAcgATYCFCAHIAYgBUF8cWo2AhAgByAGNgIMIAdBJGoiBiAHQQxqEJMbCyAOIAYQ5xggB0EwaiQAIARBiBVqIgEgCxCSNiADEPISIARBkBpqIgMgDiABENsdIARBuB5qIgEgCxDKBiABEJAeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVQgBEHPBGoiAyAEQccZaikAADcAACAEQcgEaiIFIARBwBlqKQMANwMAIARB4ARqIgggBikDADcDACAEQegEaiIGIAcpAwA3AwAgBCAEKQO4GTcDwAQgBCAEKQO4DzcD2ARBOEEEEK02IgFFDWAgASACOgAIIAFCgYCAgBA3AgAgASAEKQPABDcACSABIAQpA9gENwIgIABBpIaCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMXwsgASACELMiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGELwdIAFB1ABqIgYgAhDKBiAGEPIcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1SIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAHaiAEQbAaaikCADcCACAEQegHaiAEQbgaaikCADcCACAEQckHaiADKQMANwAAIARB0AdqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYByAEIAE6AMAHIAQgFzcAwQcgBEHAB2oQ3CkhASAAQfyGggE2AgggACABNgIEIABBk4CAgHg2AgAMXgsgASACEKEiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMAdIAFB1ABqIgYgAhDKBiAGEPUcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1QIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZAIaiAEQbAaaikCADcCACAEQZgIaiAEQbgaaikCADcCACAEQfkHaiADKQMANwAAIARBgAhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICCAEIAE6APAHIAQgFzcA8QcgBEHwB2oQ3CkhASAAQdSHggE2AgggACABNgIEIABBk4CAgHg2AgAMXQsgASACEJ0iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMMdIAFB1ABqIgYgAhDKBiAGEPocIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1OIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcAIaiAEQbAaaikCADcCACAEQcgIaiAEQbgaaikCADcCACAEQakIaiADKQMANwAAIARBsAhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CCAEIAE6AKAIIAQgFzcAoQggBEGgCGoQ3CkhASAAQayIggE2AgggACABNgIEIABBk4CAgHg2AgAMXAsgASACEK4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENAdIAFB1ABqIgYgAhDKBiAGEPkcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1MIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfAIaiAEQbAaaikCADcCACAEQfgIaiAEQbgaaikCADcCACAEQdkIaiADKQMANwAAIARB4AhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCCAEIAE6ANAIIAQgFzcA0QggBEHQCGoQ3CkhASAAQYSJggE2AgggACABNgIEIABBk4CAgHg2AgAMWwsgASACELgiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEL0dIAFB1ABqIgYgAhDKBiAGEPQcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1KIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAGaiAEQbAaaikCADcCACAEQdgGaiAEQbgaaikCADcCACAEQbkGaiADKQMANwAAIARBwAZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIBiAEIAE6ALAGIAQgFzcAsQYgBEGwBmoQ3CkhASAAQdyJggE2AgggACABNgIEIABBk4CAgHg2AgAMWgsgASACEKMiIQsjAEHgAGsiBSQAIAsoAhAhASALKAIUQQN2IQYjAEEwayICJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCCADKAIUIQkgAiAHNgIgIAIgBjYCHCACIAE2AhggAkEANgIUIAIgCCAJQXxxajYCECACIAg2AgwgAkEkaiEHIwBBIGsiCSQAIAlBFGogAkEMaiIBKAIEIAEoAgBrQQJ2QQBBBEEIEKAYIAkoAhghBiAJKAIUQQFGDWcgCUEQaiITQQA2AgAgCSAJKAIcNgIMIAkgBjYCCCMAQTBrIgYkACAJQQhqIgggASgCBCABKAIAa0ECdhDqLSAIKQIEIRcgBkEYaiABQRBqKQIANwMAIAZBEGogAUEIaikCADcDACAGIAEpAgA3AwggBiAXQiCJNwIoIAYgCEEIajYCJCMAQTBrIgEkACAGQSRqIg0oAgQhDCANKAIAIRQCQCAGQQhqIggoAgAiCiAIKAIEIg9HBEAgCCgCFCEOIAgoAhAhEiAIKAIMIRUgCCgCCCEIIA0oAgggDEEDdGohDSAPIAprQQJ2IQ8DQCABIAo2AgwCQCASIAooAgAiEEsEQCAVIBBBA3RqIhEoAgQhECARKAIAIREMAQsgCCAOKAIQTw1xQQAhEEEAIREgDigCBCAIIA4oAgxqIhZBA3ZqLQAAIBZBB3F2QQFxDXMLIA0gETYCACANQQRqIBA2AgAgCkEEaiEKIA1BCGohDSAIQQFqIQggDEEBaiEMIA9BAWsiDw0ACwsgFCAMNgIAIAFBMGokAAwACyAGQTBqJAAgB0EIaiATKAIANgIAIAcgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCCACIAY2AhggAiABNgIUIAIgByAIQXxxajYCECACIAc2AgwgAkEkaiIHIAJBDGoQjxsLIAUgBxDrGCACQTBqJAAgBUEMaiIBIAsQkjYgAxDyEiAFQSRqIgIgBSABENMdIAVB1ABqIgEgCxDKBiABEPccIARBkBpqIgFBCGogBUHcAGooAgA2AgAgASAFKQJUNwIAIAEgBSkCMDcCDCABQRRqIAVBOGooAgA2AgAgASAFKQI8NwIYIAFBIGogBUHEAGopAgA3AgAgAUEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAAgBC0AkBoiAUEpRg1IIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAHaiAEQbAaaikCADcCACAEQYgHaiAEQbgaaikCADcCACAEQekGaiADKQMANwAAIARB8AZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4BiAEIAE6AOAGIAQgFzcA4QYgBEHgBmoQ3CkhASAAQbSKggE2AgggACABNgIEIABBk4CAgHg2AgAMWQsgASACEKAiIQsjAEHgAGsiBSQAIAsoAhAhASALKAIUQQR2IQYjAEEwayICJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCCADKAIUIQkgAiAHNgIgIAIgBjYCHCACIAE2AhggAkEANgIUIAIgCCAJQXxxajYCECACIAg2AgwgAkEkaiEHIwBBIGsiCSQAIAlBFGogAkEMaiIBKAIEIAEoAgBrQQJ2QQBBCEEQEKAYIAkoAhghBiAJKAIUQQFGDWYgCUEQaiIQQQA2AgAgCSAJKAIcNgIMIAkgBjYCCCMAQTBrIgYkACAJQQhqIgggASgCBCABKAIAa0ECdhDpLSAIKQIEIRcgBkEYaiABQRBqKQIANwMAIAZBEGogAUEIaikCADcDACAGIAEpAgA3AwggBiAXQiCJNwIoIAYgCEEIajYCJCMAQTBrIgEkACAGQSRqIg0oAgQhDCANKAIAIRECQCAGQQhqIggoAgAiCiAIKAIEIg9HBEAgCCgCFCEOIAgoAhAhEyAIKAIMIRQgCCgCCCEIIA0oAgggDEEEdGohDSAPIAprQQJ2IQ8DQCABIAo2AgwCQCATIAooAgAiEksEQCABQRhqIBQgEkEEdGoiEkEIaikDADcDACABIBIpAwA3AxAMAQsgCCAOKAIQTw1wIA4oAgQgCCAOKAIMaiISQQN2ai0AACASQQdxdkEBcQ1yIAFBGGpCADcDACABQgA3AxALIA0gASkDEDcDACANQQhqIAFBGGopAwA3AwAgCkEEaiEKIA1BEGohDSAIQQFqIQggDEEBaiEMIA9BAWsiDw0ACwsgESAMNgIAIAFBMGokAAwACyAGQTBqJAAgB0EIaiAQKAIANgIAIAcgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCCACIAY2AhggAiABNgIUIAIgByAIQXxxajYCECACIAc2AgwgAkEkaiIHIAJBDGoQkhsLIAUgBxDqGCACQTBqJAAgBUEMaiIBIAsQkjYgAxDyEiAFQSRqIgIgBSABEMUdIAVB1ABqIgEgCxDKBiABEPEcIARBkBpqIgFBCGogBUHcAGooAgA2AgAgASAFKQJUNwIAIAEgBSkCMDcCDCABQRRqIAVBOGooAgA2AgAgASAFKQI8NwIYIAFBIGogBUHEAGopAgA3AgAgAUEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAAgBC0AkBoiAUEpRg1GIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAHaiAEQbAaaikCADcCACAEQbgHaiAEQbgaaikCADcCACAEQZkHaiADKQMANwAAIARBoAdqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoByAEIAE6AJAHIAQgFzcAkQcgBEGQB2oQ3CkhASAAQYyLggE2AgggACABNgIEIABBk4CAgHg2AgAMWAsgBEGAH2oiBiABIAIQpyIiASgCECABKAIUQQJ2IAMQvxYgBEGIFWoiAiABEJI2IAMQ8hIgBEGQGmoiAyAGIAIQyh0gBEG4HmoiAiABEMoGIAIQ0BggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNRCAEQf8EaiIDIARBxxlqKQAANwAAIARB+ARqIgUgBEHAGWopAwA3AwAgBEGQBWoiCCAGKQMANwMAIARBmAVqIgYgBykDADcDACAEIAQpA7gZNwPwBCAEIAQpA7gPNwOIBUE4QQQQrTYiAUUNWCABIAI6AAggAUKBgICAEDcCACABIAQpA/AENwAJIAEgBCkDiAU3AiAgAEHki4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxXCyAEQYAfaiIGIAEgAhCrIiIBKAIQIAEoAhRBA3YgAxDAFiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDGHSAEQbgeaiICIAEQygYgAhDSGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1CIARBrwVqIgMgBEHHGWopAAA3AAAgBEGoBWoiBSAEQcAZaikDADcDACAEQcAFaiIIIAYpAwA3AwAgBEHIBWoiBiAHKQMANwMAIAQgBCkDuBk3A6AFIAQgBCkDuA83A7gFQThBBBCtNiIBRQ1XIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDoAU3AAkgASAEKQO4BTcCICAAQbyMggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFYLIARBgB9qIQggASACELwiIgUoAhAhAiAFKAIUQQR2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCSADKAIUIQogASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgCSAKQXxxajYCECABIAk2AgwgAUEkaiEGIwBBIGsiCSQAIAlBFGogAUEMaiIHKAIEIAcoAgBrQQJ2QQBBEEEQEKAYIAkoAhghAiAJKAIUQQFGDWIgCUEQaiILQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQRBrIgIkACAJQQhqIgogBygCBCAHKAIAa0ECdhDrLSACIAopAgRCIIk3AgggAiAKQQhqNgIEIAcgAkEEahCrECACQRBqJAAgBkEIaiALKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCSABIAY2AhggASACNgIUIAEgByAJQXxxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQmBsLIAggBhDsGCABQTBqJAAgBEGIFWoiASAFEJI2IAMQ8hIgBEGQGmoiAyAIIAEQyx0gBEG4HmoiASAFEMoGIAEQ0xggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQCAEQd8FaiIDIARBxxlqKQAANwAAIARB2AVqIgUgBEHAGWopAwA3AwAgBEHwBWoiCCAGKQMANwMAIARB+AVqIgYgBykDADcDACAEIAQpA7gZNwPQBSAEIAQpA7gPNwPoBUE4QQQQrTYiAUUNViABIAI6AAggAUKBgICAEDcCACABIAQpA9AFNwAJIAEgBCkD6AU3AiAgAEGUjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxVCyAEQYAfaiEPIAEgAhCpIiIMKAIQIQIgDCgCFEEFdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF8cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIgkkACAJQRRqIAFBDGoiBSgCBCAFKAIAa0ECdkEAQRBBIBCgGCAJKAIYIQIgCSgCFEEBRg1hIAlBEGoiEUEANgIAIAkgCSgCHDYCDCAJIAI2AggjAEEwayIHJAAgCUEIaiICIAUoAgQgBSgCAGtBAnYQ7y0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiIOKAIEIQogDigCACETAkAgB0EIaiIFKAIAIgggBSgCBCIQRwRAIAUoAhQhDSAFKAIQIRQgBSgCDCESIAUoAgghCyAOKAIIIApBBXRqIQUgECAIa0ECdiEQA0AgAiAINgIMAkAgFCAIKAIAIg5LBEAgEiAOQQV0aiIOKQMYIRcgDikDECEYIA4pAwghGSAOKQMAIRoMAQsgCyANKAIQTw1sQgAhGkIAIRlCACEYQgAhFyANKAIEIAsgDSgCDGoiDkEDdmotAAAgDkEHcXZBAXENbQsgBSAaNwMAIAVBGGogFzcDACAFQRBqIBg3AwAgBSAZNwMIIAhBBGohCCAFQSBqIQUgC0EBaiELIApBAWohCiAQQQFrIhANAAsLIBMgCjYCACACQTBqJAAMAAsgB0EwaiQAIAZBCGogESgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhByADKAIUIQUgASAGNgIYIAEgAjYCFCABIAcgBUF8cWo2AhAgASAHNgIMIAFBJGoiBiABQQxqEIcbCyAPIAYQ7RggAUEwaiQAIARBiBVqIgEgDBCSNiADEPISIARBkBpqIgMgDyABEM4dIARBuB5qIgEgDBDKBiABENEYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDT4gBEGPBmoiAyAEQccZaikAADcAACAEQYgGaiIFIARBwBlqKQMANwMAIARBoAZqIgggBikDADcDACAEQagGaiIGIAcpAwA3AwAgBCAEKQO4GTcDgAYgBCAEKQO4DzcDmAZBOEEEEK02IgFFDVUgASACOgAIIAFCgYCAgBA3AgAgASAEKQOABjcACSABIAQpA5gGNwIgIABB7I2CATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVAsgBEEYaiABIAIoAhARAAAgBEGQGmoiASAEKAIYIgIgBCgCHCgCDBEAACACRQ0fIAQpA5AaQoqizeWiwqqJaoUgBCkDmBpCi7L53s2au945hYRQRQ0fIAEgAiADEPUoIAEQ9ikhASAAQeCOggE2AgggACABNgIEIABBk4CAgHg2AgAMUwsgBi0AAUEBaw4DBgcIBQsgBi0AAQ4CCgs6CyAGLQABQQJrDgILDDkLIARBIGogASACKAIQEQAAIARBkBpqIgcgBCgCICIBIAQoAiQoAgwRAAAgAUUNHCAEKQOQGkLA47Xe0v6llSyFIAQpA5gaQvXOqKjR/trMpH+FhFBFDRwgBigCBCEMIwBBQGoiAiQAIAIgARCSNjYCCCADKAIUIQYgAygCECEDIAIgATYCPCACIAM2AjAgAiADIAZBfHFqNgI0IAIgAkEIajYCOCACQRxqIQUjAEFAaiIDJAAgA0GTgICAeDYCCCADQTBqIAJBMGoiAUEIaikCADcDACADIAEpAgA3AyggAyADQQhqNgI4IANBHGohCCMAQTBrIgEkACABQQxqIANBKGoiBhDxIAJAAkACQCABKAIMQQFGBEAgASgCFCENIAEoAhAhDiABQRhqIgpBBEEAQQRBCBCgGCABKAIcIQkgASgCGEEBRg0CIAEoAiAiCyANNgIEIAsgDjYCACABQQhqIg1BATYCACABIAs2AgQgASAJNgIAIAFBKGogBkEQaigCADYCACABQSBqIAZBCGopAgA3AwAgASAGKQIANwMYIwBBEGsiBiQAIAZBBGogChDxICAGKAIEQQFGBEADQCAGKAIMIQsgBigCCCEOIAEoAggiCSABKAIARgRAIAEgCUEBQQRBCBDeKAsgASgCBCAJQQN0aiIPIAs2AgQgDyAONgIAIAEgCUEBajYCCCAGQQRqIAoQ8SAgBigCBA0ACwsgBkEQaiQAIAhBCGogDSgCADYCACAIIAEpAgA3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyABQTBqJAAMAQsgCSABKAIgQYj5gwEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgBSADKQIINwIAIAVBEGogA0EYaigCADYCACAFQQhqIANBEGopAgA3AgAgCBDqOwwBCyAFIAMpAhw3AgQgBUGTgICAeDYCACAFQQxqIANBJGooAgA2AgALIANBQGskACACKAIoIQMgAigCJCEBIAIoAiAhBgJAIAIoAhwiBUGTgICAeEcEQCAHIAIoAiw2AhQgByADNgIQIAcgATYCDCAHIAY2AgggByAFNgIEIAdBKToAAAwBCyACIAY2AhQgAiABNgIMIAIgATYCECACIAEgA0EDdGo2AhggByACQQxqIAwQugYLIAJBQGskACAELQCQGiIBQSlHDQ0gBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMTwsgBEEoaiABIAIoAhARAAAgBEGQGmoiByAEKAIoIgkgBCgCLCgCDBEAACAJRQ0cIAQpA5AaQv/Z66rX2IuM8QCFIAQpA5gaQoH04aOq+Nbqi3+FhFBFDRwgBigCBCEBIwBBgARrIgIkACACQcgCaiADQQxqIgYQ2zwgAWwQ8h4CQAJAAkACQAJAIAYQ2zwiDwRAIAkoAiwhECADKAIQIQggAkHUAmohDANAAkAgAyAFEIs7RQRAIAwQ5jogAigC1AJFDQQgAigC5AIgAWoiDUEDdiANQQdxQQBHaiIKIAIoAuACIgtLBEAgCiALayEOIAIoAtgCIhEgCkkEQCAMIBFBAXQiCyAKENIqIhEgCyARSxsQ6BkgAigC4AIhCwsgDgRAIAIoAtwCIAtqQQAgDvwLAAsgAiAKNgLgAgsgAiANNgLkAiACQcgCaiABELQlDAELIAIgBTYC6AMgBhDbPCAFTQ0EIAJByAJqIAgoAgAgEGwiCiABIApqEIgPCyAIQQRqIQggDyAFQQFqIgVHDQALCyACQeAAaiACQcgCaiIBENQUIAEQvC0CQCACLQBgIgFBKUYEQCACQdsAaiACQfQAaigCACIBNgAAIAJB0wBqIAJB7ABqKQIAIhc3AAAgAiACKQJkIhg3AEsgB0EUaiABNgAAIAdBDGogFzcAACAHIBg3AAQgB0EpOgAADAELIAJB1wBqIgUgAkHwAGopAAA3AAAgAkHQAGoiCCACQekAaikAADcDACACQThqIAJBgAFqKQIANwIAIAJBQGsgAkGIAWopAgA3AgAgAkEhaiAIKQMANwAAIAJBKGogBSkAADcAACACIAIpAGEiFzcDSCACIAIpAng3AjAgAiAXNwAZIAIgAToAGCACQcgCaiAJKAIMIAkoAhAiASgCCEEBa0F4cWpBCGogASACQRhqIgEQiAEgAigC0AIhCyACKALMAiEMIAIoAsgCIgVBk4CAgHhHBEAgByACKQLUAjcCECAHIAs2AgwgByAMNgIIIAcgBTYCBCAHQSk6AAAgARD+JAwBC0HAACEKIAYQ2zwiAUEDdiABQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIgFBwAAQ0TRFDQMgAQRAIAFBwAAQrTYiCkUNYgtBACEFIAJBADYC1AIgAiAKNgLQAiACIAE2AswCIAJBwAA2AsgCIAJByABqIgEgAkHIAmogCBDSJSACQRBqIAEQhj0gAigCFCEBIAIoAhAhDSAGENs8Ig4EQCADKAIQIQgDQCACIAU2AvwDIAYQ2zwgBU0NBiAIKAIAIQoCQCADIAUQizsEQCAJIAoQmiVFDQELIAVBA3YiCiABTw1sIAogDWoiCiAKLQAAQX4gBUEHcXdxOgAACyAIQQRqIQggDiAFQQFqIgVHDQALCyACQegCaiAJEMoGIAYQ2zwhASACQQA7AaADIAJBADYCnAMgAkEANgKEAyACQQA2AvgCIAIgATYC9AIgAkIENwLgAiACQgA3AtgCIAJCgICAgMAANwLQAiACQQA2AsgCIAIoAlAhASACKAJUIQMgAiACKQJINwJsIAJBADYCaCACIAM2AmQgAiABNgJgIAJBCGogAkHgAGoQ1zsgAigCCCEGQRxBBBCtNiIBRQ1WIAFCgYCAgBA3AgAgASACKQJgNwIIIAFBEGogAkHoAGopAgA3AgAgAUEYaiACQfAAaigCADYCACACIAM2AvQDIAIgBjYC8AMgAiABNgLsAyACQewBaiIDIAJByAJqIgEgAkHsA2oQrhYgAkEANgLAAiABIAwgCxDTIyACQZABaiIGIAMgARDvJSACQaQDaiIBIAYQzRwgByABENwUIAJBGGoQ/iQLIAJBgARqJAAMBAtB/PSBARCyOwALIAIgAxD8OzYC/AMgAkECNgIcIAJBiPGBATYCGCACQgI3AiQgAkE7NgL4AyACQTs2AvADIAIgAkHsA2o2AiAgAiACQfwDajYC9AMgAiACQegDajYC7AMgAkEYakGY8YEBEO8sAAtBwPSBAUEpIAJByAJqQcz8gQFB7PSBARDVHgALIAIgAxD8OzYC7AMgAkECNgLMAiACQYjxgQE2AsgCIAJCAjcC1AIgAkE7NgJsIAJBOzYCZCACIAJB4ABqNgLQAiACIAJB7ANqNgJoIAIgAkH8A2o2AmAgAkHIAmpBmPGBARDvLAALIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENs8IAMQ2zwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjQIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJwCIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMsWIAdBDGogARCTNiADEPISIAEoAgQhCCAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAIKAIAIgkgCSgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAgpAgQ3AgAgAiAJNgIAIAJBDGohAiALQQxrIQsgCEEMaiEIIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQjgIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCdAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDLFiAHQQxqIAEQkzYgAxDyEiABKAIEIQggB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCCgCACIJIAkoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAIKQIENwIAIAIgCTYCACACQQxqIQIgC0EMayELIAhBDGohCCAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADEOcCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBSABIAIQkSIhCCMAQfAEayIGJAAgCCgCGCENIAgoAhwhCyAGQdgCaiADQQxqIgkQ2zxBAEEIQQgQoBggBigC3AIhAQJAIAYoAtgCQQFHBEAgBkEANgLIBCAGIAYoAuACIgI2AsQEIAYgATYCwAQgBkEANgLUBCAGQoCAgICAATcCzAQgAQR/IAIFIAZBwARqQfCvggEQsyggBigCxAQLQgA3AwAgBkEBNgLIBEHAACEHIAkQ2zwiAUEDdiABQQdxQQBHaiIKQcD///8DcUFAayAKIApBP3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIHRQ1KC0EAIQIgBkEANgLkAiAGIAc2AuACIAYgATYC3AIgBkHAADYC2AIgBkHYBGoiASAGQdgCaiAKENIlIAZBGGogARCGPSAGKAIcIQEgBigCGCEOIAkQ2zwiDwRAIAtBA3YhByADKAIQIRADQAJAAkACQAJAIAMgAhCLO0UEQCACQQN2IgogAU8NWCAKIA5qIgogCi0AAEF+IAJBB3F3cToAACAGKALIBCIKIAYoAsAERgRAIAZBwARqQYCwggEQsygLIAYoAsQEIApBA3RqIBc3AwAgBiAKQQFqNgLIBAwECyAGIAI2AugEIAkQ2zwgAk0NACAQIAJBAnRqKAIAIgwgB08NASAMQQFqIgogB08NAiANIApBA3RqKQMAIhkgDSAMQQN0aikDACIYfSAXfCEXIAYoAsgEIgogBigCwARGBEAgBkHABGpBsLCCARCzKAsgBigCxAQgCkEDdGogFzcDACAGIApBAWo2AsgEIBggGVMEQCAGKALUBCILQQN0IQoDQCAGKALMBCALRgRAIAZBzARqQcCwggEQsygLIAYoAtAEIApqIBg3AwAgBiALQQFqIgs2AtQEIApBCGohCiAZIBhCAXwiGFINAAsLIAggDBCSOw0DIAJBA3YiCiABTw1XIAogDmoiCiAKLQAAQX4gAkEHcXdxOgAADAMLIAYgAxD8OzYC7AQgBkECNgLcAiAGQYjxgQE2AtgCIAZCAjcC5AIgBkE7NgIsIAZBOzYCJCAGIAZBIGo2AuACIAYgBkHsBGo2AiggBiAGQegEajYCICAGQdgCakGY8YEBEO8sAAsgDCAHQZCwggEQwyEACyAKIAdBoLCCARDDIQALIAJBAWoiAiAPRw0ACwsgBkEoaiAGQdQEaigCADYCACAGIAYpAswENwMgIAZB5AJqIgEgBkEgahCaEiAGQeACaiAGQcgEaigCADYCACAGIAYpAsAEIhg3A9gCIAYpAtwCIRcgBkG4A2ogAUEw/AoAACAGQYgBaiAGQeAEaikCADcDACAGIAYpAtgENwOAAQJAAkAgGKciAkGAgICAeEYEQCAGQdgAaiAGQcADaigCACIBNgIAIAYgBikCuAMiGDcDUCAFQRRqIAE2AgAgBSAYNwIMIAUgFzcCBCAFQSk6AAAMAQsgBkHQAGoiAyAGQbgDakEw/AoAACAGQeAEaiAGQYgBaikDADcDACAGIAYpA4ABNwPYBCAGQSBqIgEgA0Ew/AoAACAGIBc3AoQBIAYgAjYCgAEgBkHYAmogCCgCDCAIKAIQIgIoAghBAWtBeHFqQQhqIAIgARCKASAGKALgAiEHIAYoAtwCIQogBigC2AIiAkGTgICAeEcEQCAFIAYpAuQCNwIQIAUgBzYCDCAFIAo2AgggBSACNgIEIAVBKToAACAGQdgEahDPLyAGQYABahDjPCABEP4kDAELIAZBuANqIgIgBkGAAWoQ3iwgBiAGKQK4AzcC5AIgBkEANgLgAiAGIAYoAsQDIgs2AtwCIAYgBigCwAM2AtgCIAZBEGogBkHYAmoiAxDXOyAGKAIQIQxBHEEEEK02IgFFDUAgAUKBgICAEDcCACABIAYpAtgCNwIIIAFBEGogBkHgAmopAgA3AgAgAUEYaiAGQegCaigCADYCACAGIAs2ApwBIAYgDDYCmAEgBiABNgKUASAGQfgCaiAIEMoGIAkQ2zwhASAGQQA7AbADIAZBADYCrAMgBkEANgKUAyAGQQA2AogDIAYgATYChAMgBkIENwLwAiAGQgA3AugCIAZCgICAgMAANwLgAiAGQQA2AtgCIAYoAuAEIQEgBigC5AQhCCAGIAYpA9gENwLEAyAGQQA2AsADIAYgCDYCvAMgBiABNgK4AyAGQQhqIAIQ1zsgBigCCCEJQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAGKQK4AzcCCCABQRBqIAZBwANqKQIANwIAIAFBGGogBkHIA2ooAgA2AgAgBiAINgJYIAYgCTYCVCAGIAE2AlAgBkH8AWoiASADIAZB0ABqEK4WIAZBADYC0AIgAiAKIAcQ0yMgAyABIAIQ7yUgBkGgAWoiASADIAZBlAFqEPojIAZB/ANqIgIgARDNHCAFIAIQrh8gBkEgahD+JAsgBkHwBGokAAwDCww+C0HA9IEBQSkgBkHYAmpBzPyBAUHs9IEBENUeAAsgASAGKALgAkHgr4IBEP0vAAsgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQgjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQojAEEwayIBJAAgAUEIaiACQSBqIgcQgygCQAJAAkAgASgCCCILBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIJIA02AgQgCSALNgIAIAFBHGoiD0EBNgIAIAEgCTYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQgyggBSgCCCIJBEAgAUEUaiELIAUoAgwhBwNAIAsoAggiDSALKAIARgRAIAtBARDqLQsgCygCBCANQQN0aiIQIAc2AgQgECAJNgIAIAsgDUEBajYCCCAFIAwQgyggBSgCBCEHIAUoAgAiCQ0ACwsgBUEQaiQAIApBCGogDygCADYCACAKIAEpAhQ3AgAMAQsgCkEANgIIIApCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCCACKQIANwIAIAhBEGogAkEQaigCADYCACAIQQhqIAJBCGopAgA3AgAgChDDJyAKEOo7DAELIAggAikCFDcCBCAIQZOAgIB4NgIAIAhBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIJEP8YIAkgAxDALSAEIA42ArQaIwBBMGsiByQAIAdBDGohDSMAQUBqIgYkACAGQQhqIAlBKPwKAAAgBigCCCIKEL88IQEgBigCJCECIAoQvzwaQcAAIQUCQEF/IAEgAmsiAUEHaiIIIAEgCEsbIgFBA3YiCEHA////AXFBQGsgCCABQfgDcRsiAUHAABDRNARAIAEEQCABQcAAEK02IgVFDUgLIAZBADYCPCAGIAU2AjggBiABNgI0IAZBwAA2AjAgBkEMaiEOIAYoAiwhDyAGKAIYIRAgBigCECERIAYoAhwhEyAGKAIMIQsgBigCKCEBQQAhBUEBIQgDQAJAAkACQCABIAJGIhRFBEACfyALBEAgAiATTw0DQQAgESACIBBqIgxBA3ZqLQAAQf8BcyAMQQdxdkEBcQ0BGgsgCEEAIA8gCigCECACQQJ0aigCABCTOxsLIAVyIQUgAkEBaiECIAhBAXQiCEH+AXENBCAGIAI2AiQMAgsgBiABNgIkIAEhAiAIQf8BcUEBRw0BDAILQZz4gwFBIEG8+IMBEJ8pAAsCQCAGKAI8IgwgBigCNEcNACAKEL88IQggChC/PBogBigCPCIMQX8gCCACayIIQQdqIhIgCCASSxtBA3ZqQQFqIgggBigCNE0NACAIENUqIQggBkEwaiAGKAI0QQF0IgwgCCAIIAxJGxDoGSAGKAI8IQwLIAYoAjggDGogBToAAEEBIQggBiAMQQFqNgI8QQAhBSAURQ0BCwsgDSAGKQIwNwIAIA1BCGogBkE4aikCADcCAAJAIAtFDQAgCyALKAIAIgFBAWs2AgAgAUEBRw0AIA4Q+x4LIAZBQGskAAwBC0HM+IMBQSkgBkEwakGY+YMBQfj4gwEQ1R4ACyAHIAcpAgw3AiggB0EANgIkIAcgBygCGCIGNgIgIAcgBygCFDYCHCAHIAdBHGoQ1zsgBygCACEFQRxBBBCtNiIBRQ06IAFCgYCAgBA3AgAgASAHKQIcNwIIIARBhBFqIgIgBjYCCCACIAU2AgQgAiABNgIAIAFBEGogB0EkaikCADcCACABQRhqIAdBLGooAgA2AgAgB0EwaiQAIAQoAsAPBEAgBEGQFWogBEHAD2ooAgA2AgAgBEGcFWogBEGMEWooAgA2AgAgBCAEKQK4DzcDiBUgBCAEKQKEETcClBUgCSAEQYgVahCtECAJEOUpIQEgAEG4nYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDkLIARBkBpqIgEgBEGEEWpBACADQQxqIgIQ2zwQ8hUgBEGIFWoiAyABEOEnIAEgAhDbPCADENUYIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oiABDuHyAAEOg7DDgLIAZBBGohByAGLQABDQsgBEH8GGogBygCBBDqIyAEQdgAaiABIAIoAhARAAAgBEGQGmogBCgCWCICIAQoAlwoAgwRAAAgAkUNBiAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQYgBEGAH2ogAigCHCACKAIgIAMQwRYgBEHQAGogBxCwLiAEKAJQIgEgBCgCVCIKRg0KA0AgBEGQGmogAiABLQAAENkoQYifggEgAxCIASAEKAKYGiEFIAQoApQaIQggBCgCkBoiCUGTgICAeEcEQCAAIAQpApwaNwIMIAAgBTYCCCAAIAg2AgQgACAJNgIAIAQoAoAfIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQYAfahD7HgsgBEH8GGoiABDDJyAAEOo7DDkLIAQoAoQZIgkgBCgC/BhGBEAgBEH8GGpB4J+CARCbKAsgBCgCgBkgCUEDdGoiCyAFNgIEIAsgCDYCACAEIAlBAWo2AoQZIAFBCGoiASAKRw0ACwwKCyABIAcRBAAiBi0AAEEiRg0IIAQgBjYCuA8gBEEBNgKUGiAEQeymggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB9KaCARDvLAALIARBkBpqIgYgASACEMcvEI8OIARBuA9qIgUgBhD8FSAGIAUgAxDnAiAELQCQGiICQSlGDQYgBEGXFWoiAyAEQaAaaikAADcAACAEQZAVaiIIIARBmRpqKQAANwMAIARBkBBqIARBsBpqKQIANwIAIARBmBBqIARBuBpqKQIANwIAIARBoBBqIARBwBpqKQIANwIAIARB+Q9qIAgpAwA3AAAgBEGAEGogAykAADcAACAEIAQpAqgaNwKIECAEIAI6APAPIAQgBCkAkRo3APEPIARBiBVqIgIgBEHwD2oQhD4gBiACEKEbIAIgASAHEQQAEMoGIARBqBBqIgEgBiACEIwYIAIgARDNHCAGIAIQuAYgBhD3KSEBIABBhKeCATYCCCAAIAE2AgQgAEGTgICAeDYCACAFEMkeDDULIAEgBxEEACIGLQAAQShGDQQgBCAGNgK4DyAEQQE2ApQaIARB/KqCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGEq4IBEO8sAAtB0I6CARCyOwALQYCXggEQsjsAC0H4m4IBELI7AAtBoJ6CARCyOwwFCwJAAkACQAJAAkACQCAGKAIEIgYtADBBA2sOAwECAwALIAQgBkEwajYCuA8gBEEBNgKUGiAEQbCqggE2ApAaIARCATcCnBogBEGnBDYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpBuKqCARDvLAALIARBkBpqIQ0gASACEJwiIQ4jAEHgBGsiBSQAAkACQAJAAkACQAJ/AkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEGIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgBiEHIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIghPDU0gBigCACIDIAhPDU5BAiEKAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBJIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAhPDVUgASgCACIBIAhPDVYgDyAJQQJ0aigCACAPIAFBAnRqKAIASQ0CIAMhASAMIApBAWoiCkcNAAsMAgsgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIJIAhPDVQgASgCACIBIAhPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATw0BIAMhASAMIApBAWoiCkcNAAsMAQsgCiAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQoDQCAHKAIAIQEgByAKKAIANgIAIAogATYCACAKQQRrIQogB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOcKDAILDFALIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuRUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUIgBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQggEQRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohB0EAIQEDQAJ/IAtFBEAgCCAHIAMiBkcNARoMBQsgCyAHIANrQQF2Tw0EIAMgC0EBdGohBiAIIAtqCyIMQQFqIQggBkECaiEDQQAhCyABIAJPDQAgAUECdCEKIAYuAQAgEWshDwNAIAEgBSgCVCIGTw1GIAUoAlAgCmooAgAiBiACTw1HIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NSCAFKALYAyATaiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRSAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUUgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIglBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEEaiIIIAUoAjwiBksEQCAFQThqIAZBAXQiBiAIENIqIgggBiAISxsQ6BkgBSgCRCIKQQRqIQggBSgCPCEGCyAGIAhJBH8gBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQFIAoLIAUoAkBqIAE2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCADQYCAAk8NCSAFKAIsIgZBAmoiASAFKAIkIghLBEAgBUEgaiAIQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCCAFKAIsIgZBAmohAQsgASAISwR/IAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADOwAAIAUgBSgCLEECajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCUcNAAsgCUEBayEIIAUoAkQhASAFKAI8DAMLIAEgBSgCVCIDTw1DIAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQJ0aigCADYCICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMQgsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAgsgCUUNAkEBIQdBACEBIAUoAhQhAkEAIQhBwAALIQMgAiAIQQJ0aigCACEGIAMgAUEEaiICSQRAIAVBOGogA0EBdCIBIAIQ0ioiAiABIAJLGxDoGSAFKAI8IQMgBSgCRCIBQQRqIQILIAIgA0sEfyAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCRAUgAQsgBSgCQGogBjYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAlBgIACTw0CIAUoAiwiAkECaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQJqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCTsAACAFIAUoAixBAmoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGDhowYNgIAIAVCg4aMmLDgwIEDNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ06IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIKKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgsgARDNHCAIQYiQoMAANgIAIAVCiJCgwICBgoQINwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ06IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAKKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQuRMgAyAOQSBqQYifggEgAUHEg4IBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgCxCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCfCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQbCvggEQsjsAC0HQr4IBELI7AAsgBC0AkBoiAUEpRg0DIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbgWaiAEQbAaaikCADcCACAEQaEWaiADKQMANwAAIARBqBZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKwFiAEIAE6AJgWIAQgFzcAmRYgBEGYFmoQ9SkhASAAQdynggE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgBEGQGmohDSABIAIQmiIhDiMAQeAEayIFJAACQAJAAkACfwJAAkACQAJAIAMoAhQiAUEDTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIREgDigCGCETIAVBzABqIAFBAnYiAkG8/IEBEKQaIAUoAlAhBiAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAYhByABDQEgBigCBCIJIAVB1ANqIhQoAgAiASgCBCIITw1KIAYoAgAiAyAITw1LQQIhCgJAAkACQAJAIAEoAgAiDyAJQQJ0aigCACAPIANBAnRqKAIASSISRQRAIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1SIAEoAgAiASAITw1TIA8gCUECdGooAgAgDyABQQJ0aigCAEkNAiADIQEgDCAKQQFqIgpHDQALDAILIAxBAkYNACAHQQRqIQEDQCABQQRqIgMoAgAiCSAITw1RIAEoAgAiASAITw0EIA8gCUECdGooAgAgDyABQQJ0aigCAE8NASADIQEgDCAKQQFqIgpHDQALDAELIAogDEcNAQsgEkUNAyAMQQF2IQMgDEECdCAHakEEayEKA0AgBygCACEBIAcgCigCADYCACAKIAE2AgAgCkEEayEKIAdBBGohByADQQFrIgMNAAsMAwsgByAMQQAgDEEBcmdBAXRBPnMgFBDjCgwCCwxNCyAMQQJ0IQFBBCEHA0AgBiAGIAdqIAVB1ANqELkVIAEgB0EEaiIHRw0ACwsCQAJAIAxFDQAgBiAMQQJ0akEEayIBRQ0AIAEoAgAiASACTw0/IAUgECABQQJ0aigCACIBNgLcBCABIBNJBEBBACEIIBEEQCAOQQxqQQAQ3xkhCwsgBUHUA2pBACACQcjxgQEQsxUgDigCECIDIA4oAhRBfHFqIQdBACEBA0ACfyALRQRAIAggByADIgZHDQEaDAULIAsgByADa0ECdk8NBCADIAtBAnRqIQYgCCALagsiDEEBaiEIIAZBBGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBFrIQ8DQCABIAUoAlQiBk8NQyAFKAJQIApqKAIAIgYgAk8NRCAQIAZBAnQiE2ooAgAgD08NASAGIAUoAtwDIglPDUUgBSgC2AMgE2ogDDYCACAKQQRqIQogAiABQQFqIgFHDQALIAIhAQwACwALIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYC2AMgBSAFQdQDajYCgAMgBSAFQdwEajYC1AMgBUGgAmogBUH4AmoQmQ4MBAtBqPGBARCyOwALIAEgAkkNASAFQagCaiAFQdwDaigCADYCACAFIAUpAtQDNwKgAiAFQcwAahDpOwsgBUEYaiAFQagCaigCADYCACAFIAUpAqACNwMQQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUIgBUIANwIsIAUgATYCKCAFQsCAgICACDcCIEHAAEHAABDRNEUNQ0HAAEHAABCtNiIBRQ1CIAVCADcCRCAFIAE2AkAgBULAgICAgAg3AjggBSgCGCIJQQJJDQJBASEHQQEhAwNAIAUoAhQiAiADQQJ0aiIBKAIAIAFBBGsoAgAiAUcEQCAFKAJEIgpBBGoiCCAFKAI8IgZLBEAgBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQiCkEEaiEIIAUoAjwhBgsgBiAISQR/IAVBOGogBkEBdCIGIAgQ0ioiCCAGIAhLGxDoGSAFKAJEBSAKCyAFKAJAaiABNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIISwRAIAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQggBSgCLCIGQQRqIQELIAEgCEsEfyAFQSBqIAhBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAlHDQALIAlBAWshCCAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQCACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD8LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAlFDQJBASEHQQAhASAFKAIUIQJBACEIQcAACyEDIAIgCEECdGooAgAhBiADIAFBBGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEEaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIAY2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAk2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNNyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCigCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiILIAEQzRwgCEGIkKDAADYCACAFQoiQoMCAgYKECDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNNyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCigCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADELkTIAMgDkEgakGIn4IBIAFBxIOCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAsQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQngkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQtBf0EAQZCvggEQwyEACyAELQCQGiIBQSlGDQEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4BZqIARBsBpqKQIANwIAIARByRZqIAMpAwA3AAAgBEHQFmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgWIAQgAToAwBYgBCAXNwDBFiAEQcAWahD1KSEBIABBtKiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZAaaiENIAEgAhCbIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAIAMoAhQiAUEDTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIREgDigCGCETIAVBzABqIAFBAnYiAkG8/IEBEKQaIAUoAlAhByAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAchBiABDQEgBigCBCIJIAVB1ANqIhQoAgAiASgCBCIITw1IIAYoAgAiAyAITw1JQQIhCgJAAkACQAJAIAEoAgAiDyAJQQJ0aigCACAPIANBAnRqKAIASSISRQRAIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1QIAEoAgAiASAITw1RIA8gCUECdGooAgAgDyABQQJ0aigCAEkNAiADIQEgDCAKQQFqIgpHDQALDAILIAxBAkYNACAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1PIAEoAgAiASAITw0EIA8gCUECdGooAgAgDyABQQJ0aigCAE8NASADIQEgDCAKQQFqIgpHDQALDAELIAogDEcNAQsgEkUNAyAMQQF2IQMgDEECdCAGakEEayEKA0AgBigCACEBIAYgCigCADYCACAKIAE2AgAgCkEEayEKIAZBBGohBiADQQFrIgMNAAsMAwsgBiAMQQAgDEEBcmdBAXRBPnMgFBDhCgwCCwxLCyAMQQJ0IQFBBCEGA0AgByAGIAdqIAVB1ANqELkVIAEgBkEEaiIGRw0ACwsCQAJAIAxFDQAgByAMQQJ0akEEayIBRQ0AIAEoAgAiASACTw09IAUgECABQQJ0aigCACIBNgLcBCABIBNJBEBBACEHIBEEQCAOQQxqQQAQyBkhCwsgBUHUA2pBACACQcjxgQEQsxUgDigCECIDIA4oAhRBeHFqIQhBACEBA0ACfyALRQRAIAcgCCADIgZHDQEaDAULIAsgCCADa0EDdk8NBCADIAtBA3RqIQYgByALagsiDEEBaiEHIAZBCGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBFrIQ8DQCABIAUoAlQiBk8NQSAFKAJQIApqKAIAIgYgAk8NQiAQIAZBAnQiE2ooAgAgD08NASAGIAUoAtwDIglPDUMgBSgC2AMgE2ogDDYCACAKQQRqIQogAiABQQFqIgFHDQALIAIhAQwACwALIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYC2AMgBSAFQdQDajYCgAMgBSAFQdwEajYC1AMgBUGgAmogBUH4AmoQmQ4MBAtBqPGBARCyOwALIAEgAkkNASAFQagCaiAFQdwDaigCADYCACAFIAUpAtQDNwKgAiAFQcwAahDpOwsgBUEYaiAFQagCaigCADYCACAFIAUpAqACNwMQQcAAQcAAENE0RQ1BQcAAQcAAEK02IgFFDUAgBUIANwIsIAUgATYCKCAFQsCAgICACDcCIEHAAEHAABDRNEUNQUHAAEHAABCtNiIBRQ1AIAVCADcCRCAFIAE2AkAgBULAgICAgAg3AjhBASELIAUoAhgiCEECTwRAIAitIRhBACEDQgEhFwNAIAUoAhQgA2oiAUEEaigCACABKAIAIgFHBEAgBSgCRCIHQQRqIgYgBSgCPCICSwRAIAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEIgdBBGohBiAFKAI8IQILIAIgBkkEfyAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRAUgBwsgBSgCQGogATYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCALQQFqIQsLIANBBGohAyAYIBdCAXwiF1INAAsLIAhBAWshASAIRQ0EIAUoAhQgAUECdGooAgAhAiAFKAJEIgZBBGoiAyAFKAI8IgFLBEAgBUE4aiABQQF0IgEgAxDSKiIDIAEgA0sbEOgZIAUoAkQiBkEEaiEDIAUoAjwhAQsgASADSQR/IAVBOGogAUEBdCIBIAMQ0ioiAyABIANLGxDoGSAFKAJEBSAGCyAFKAJAaiACNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQhqIgMgBSgCJCIBSwRAIAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsIgZBCGohAyAFKAIkIQELIAEgA0kEfyAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLAUgBgsgBUEoaiICKAIAaiAIrTcAACAFIAUoAixBCGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiB0GFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAVBnAJqIgEQlykgAigCACEIIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAINgKcAiAFQQhqIAEQ1zsgBSgCCCEIQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIJKAIANgIAIAUgAzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIIEPojIAVBzABqIgogARDNHCAHQYiQoMAANgIAIAVCiJCgwICBgoQINwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAEQlykgBUFAayICKAIAIQsgBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSALNgKcAiAFIAEQ1zsgBSgCACELQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAJKAIANgIAIAUgBzYC3AMgBSALNgLYAyAFIAI2AtQDIAEgAyAIEPojIAMgARDNHCAFQZABaiIBIAMQuRMgAyAOQSBqQYifggEgAUHEg4IBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4Rg0CIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgChCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwDCyABIAUoAlQiA08NPiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD0LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEKAJIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAELIAFBAEGQr4IBEMMhAAsgBC0AkBoiAUEpRwRAIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYgXaiAEQbAaaikCADcCACAEQfEWaiADKQMANwAAIARB+BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKAFyAEIAE6AOgWIAQgFzcA6RYgBEHoFmoQ9SkhASAAQYypggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMLwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAgBEG4D2oQyR4MLgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIEIgYtAABBAmsOCAECAwQFBgcIAAsgBCAGNgK4DyAEQQE2ApQaIARBnKaCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGkpoIBEO8sAAsgBEGQGmohBiABIAIQxCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4RYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0NIARBiBVqIgIgBkHEAPwKAAAgBEHXEWogBEHXGmotAAA6AAAgBCAELwDVGjsA1REgBEGQEWoiAyACQcQA/AoAACAEIAE6ANQRIAMQ6ykhASAAQZCgggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGQGmohBiABIAIQwSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0LIARBiBVqIgIgBkHEAPwKAAAgBEGfEmogBEHXGmotAAA6AAAgBCAELwDVGjsAnRIgBEHYEWoiAyACQcQA/AoAACAEIAE6AJwSIAMQ6ykhASAAQeigggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBiABIAIQwCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0JIARBiBVqIgIgBkHEAPwKAAAgBEHnEmogBEHXGmotAAA6AAAgBCAELwDVGjsA5RIgBEGgEmoiAyACQcQA/AoAACAEIAE6AOQSIAMQ6ykhASAAQcChggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmohBiABIAIQwyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0HIARBiBVqIgIgBkHEAPwKAAAgBEGvE2ogBEHXGmotAAA6AAAgBCAELwDVGjsArRMgBEHoEmoiAyACQcQA/AoAACAEIAE6AKwTIAMQ6ykhASAAQZiiggE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgBEGQGmohBiABIAIQwiIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4hYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0FIARBiBVqIgIgBkHEAPwKAAAgBEH3E2ogBEHXGmotAAA6AAAgBCAELwDVGjsA9RMgBEGwE2oiAyACQcQA/AoAACAEIAE6APQTIAMQ6ykhASAAQfCiggE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgBEGQGmohBiABIAIQvyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0DIARBiBVqIgIgBkHEAPwKAAAgBEG/FGogBEHXGmotAAA6AAAgBCAELwDVGjsAvRQgBEH4E2oiAyACQcQA/AoAACAEIAE6ALwUIAMQ6ykhASAAQcijggE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgBEGQGmohBiABIAIQviIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0BIARBiBVqIgIgBkHEAPwKAAAgBEGHFWogBEHXGmotAAA6AAAgBCAELwDVGjsAhRUgBEHAFGoiAyACQcQA/AoAACAEIAE6AIQVIAMQ6ykhASAAQaCkggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGQGmohBiABIAIQvSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQoBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRwRAIARBiBVqIgIgBkHEAPwKAAAgBEGXFmogBEHXGmotAAA6AAAgBCAELwDVGjsAlRYgBEHQFWoiAyACQcQA/AoAACAEIAE6AJQWIAMQ6ykhASAAQfikggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMNAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLQsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQEgBigCCCECIARBwB5qIARBiB9qKAIANgIAIAQgBCkCgB83A7geIARBADYCuBkgBEHAD2ogBEGEGWooAgA2AgAgBCAEKQL8GDcDuA8gBEGQGmogASACIARBuB5qIARBuBlqIARBuA9qEJEEIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4RgRAIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwtCyAEQbAZaiAEQbgaaikCADcCACAEQagZaiAEQbAaaikCADcCACAEQZQZaiABKQMANwIAIARBnBlqIAIoAgA2AgAgBCAEKQKoGjcCoBkgBCADNgKIGSAEIAQpA4gVNwKMGSAEQYgZahDcKSEBIABBsJ6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAwsCyAEQcgAaiABIAIoAhARAAAgBEGQGmoiAiAEKAJIIgEgBCgCTCgCDBEAAAJAAkAgAUUNACAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQAgBEGIFWoiBSABKAIcIAEoAiAgAxDBFiAEQQA2AugZIARBoBpqIARB+BlqKQIANwMAIARBmBpqIARB8BlqKQIANwMAIAQgBCkC6Bk3A5AaIARBuBlqIgggBSACENgdIAEQkzYiCUUNASACIAkoAgQgCSgCCEECdiADEL8WIARBuA9qIgMgAiAEQegZahC/HSAEQUBrIAcQsC4gBCkDQCEXIAQgATYCoBogBCAXNwKQGiAEIAM2ApwaIAQgCDYCmBogBSACELsVIARBwB5qIgEgBEGUFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiAkGTgICAeEcEQCAEKAKYFSEGIAAgBCkDuB43AgQgACAGNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAgAxD+JCAIEP4kDC4LIARBiBpqIARBwB5qKAIANgIAIAQgBCkDuB43A4AaIARBkBpqIgFBAEGABPwLACAEIAQoAsgZIgI2AogVIAQgAiAEQcwZaiIDKAIAajYCjBUgBCABNgKQFSAEQZweaiAEQYgVaiIBELwsIARBsB5qIAMoAgAiAjYCACAEQZwVaiACNgIAIARBqBVqIARB2BlqKQIANwMAIARBsBVqIARB4BlqKQIANwMAIARBkBVqIARBwBlqKAIANgIAIAQgBCkCxBkiFzcDqB4gBCAXNwKUFSAEIAQpAtAZNwOgFSAEIAQpArgZNwOIFSABELQMAkAgBCgCoBUiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEGgFWoQ+x4LIAcoAgAiASABKAIAIgJBAWo2AgAgAkEASA0CIAYoAgghAiAEQYgfaiAEQaQeaigCADYCACAEIAQpApweNwOAHyAEQYgVaiABIAIgBEGoHmogBEGAH2ogBEGAGmoQkQQgBEHAHmoiASAEQZQVaikCADcDACAEQcgeaiICIARBnBVqKAIANgIAIAQgBCkCjBU3A7geIAQoAogVIgNBgICAgHhGBEAgACAEKQO4HjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIARBuA9qEP4kDC4LIARB+B5qIARBsBVqKQIANwIAIARB8B5qIARBqBVqKQIANwIAIARB3B5qIAEpAwA3AgAgBEHkHmogAigCADYCACAEIAQpAqAVNwLoHiAEIAM2AtAeIAQgBCkDuB43AtQeIARB0B5qENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qEP4kDC0LQfCfggEQsjsAC0GAoIIBELI7AAsACyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwpCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwoCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJQsgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADCQLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCMLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCILIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCELIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB8LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB4LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB0LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBwLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBsLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBoLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBgLIARBCGpBxI6CASADEKErIAAgBCkDCDcCBCAAQZOAgIB4NgIADBcLIAQgBjYCuA8gBEEBNgKUGiAEQcirggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB0KuCARDvLAALIARBkwZqIAEoAAAiATYAACAEQYsGaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAgwYgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMFQsgBEHjBWogASgAACIBNgAAIARB2wVqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDTBSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwUCyAEQbMFaiABKAAAIgE2AAAgBEGrBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AKMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBMLIARBgwVqIAEoAAAiATYAACAEQfsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA8wQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCwsgBEHTBGogASgAACIBNgAAIARBywRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDDBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwKCyAEQaMEaiABKAAAIgE2AAAgBEGbBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AJMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAkLIARB8wNqIAEoAAAiATYAACAEQesDaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA4wMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCAsgBEHDA2ogBEGkGmooAgAiATYAACAEQbsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAswMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBwsgBEGTA2ogBEGkGmooAgAiATYAACAEQYsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAgwMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBgsgBEHjAmogBEGkGmooAgAiATYAACAEQdsCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA0wIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBQsgBEGzAmogBEGkGmooAgAiATYAACAEQasCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAowIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBAsgBEGDAmogBEGkGmooAgAiATYAACAEQfsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA8wEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAwsgBEHTAWogBEGkGmooAgAiATYAACAEQcsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAwwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAgsgBEGjAWogBEGkGmooAgAiATYAACAEQZsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAkwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAQsgBEHzAGogBEGkGmooAgAiATYAACAEQesAaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAYyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAsgBEGQH2okAA8LQQRBOBCjPQALQQRBHBCjPQALIAEgAkG48YEBEMMhAAsgASAGQezygQEQwyEACyAGIAJB/PKBARDDIQALIAYgCUGM84EBEMMhAAsgASACQejxgQEQwyEACyABIANB2PGBARDDIQALQcAAQcAAEKM9AAtBwPSBAUEpIAVB+AJqQcz8gQFB7PSBARDVHgALIAIgCSgCHEG8/IEBEP0vAAsgBiAJKAIcQbz8gQEQ/S8AC0HAACABEKM9AAsgCSAIQfD2gwEQwyEACyADIAhBgPeDARDDIQALIAkgCEHw9oMBEMMhAAsgASAIQYD3gwEQwyEAC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyABQQE2AhQgAUHctoIBNgIQIAFCATcCHCABQbsTNgIsIAEgAUEoajYCGCABIAFBDGo2AiggAUEQakHktoIBEO8sAAsgCiABQYD0gQEQwyEAC7DzAgQTfwR+AX0BfCMAQZAfayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwiBxEEACIGLQAAQQJrDiUDBAUGBwgJCgsMDQAAAAAAAQIAAAAAAAAAAAAAAAAAAAAVFhcYAAsgASAHEQQAIggtAAAOKR4YVVVVVVVVVVVVVVUZIyQaG1VVKRwrLC0uLzBVHTJVMzQ1VVVVVTY3VQsgBi0AAUEBaw4DDQ4PDAsgBi0AAUEBaw4CEBEPCyAEQZAaaiABIAIQuyIgAxDfFiAELQCQGiICQSlGDWggBEHvAGoiAyAEQaAaaikAADcAACAEQegAaiIGIARBmRpqKQAANwMAIARBgAFqIgcgBEGwGmopAgA3AwAgBEGIAWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwNgIAQgBCkCqBo3A3hBOEEEEK02IgFFDWogASACOgAIIAFCgYCAgBA3AgAgASAEKQNgNwAJIAEgBCkDeDcCICAAQbT/gQE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGkLIARBkBpqIAEgAhCoIiADEJUWIAQtAJAaIgJBKUYNZiAEQZ8BaiIDIARBoBpqKQAANwAAIARBmAFqIgYgBEGZGmopAAA3AwAgBEGwAWoiByAEQbAaaikCADcDACAEQbgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A5ABIAQgBCkCqBo3A6gBQThBBBCtNiIBRQ1pIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAE3AAkgASAEKQOoATcCICAAQYyAggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGgLIARBkBpqIAEgAhCxIiADEJYWIAQtAJAaIgJBKUYNZCAEQc8BaiIDIARBoBpqKQAANwAAIARByAFqIgYgBEGZGmopAAA3AwAgBEHgAWoiByAEQbAaaikCADcDACAEQegBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A8ABIAQgBCkCqBo3A9gBQThBBBCtNiIBRQ1oIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAE3AAkgASAEKQPYATcCICAAQeSAggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGcLIARBkBpqIAEgAhCkIiADEJcWIAQtAJAaIgJBKUYNYiAEQf8BaiIDIARBoBpqKQAANwAAIARB+AFqIgYgBEGZGmopAAA3AwAgBEGQAmoiByAEQbAaaikCADcDACAEQZgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A/ABIAQgBCkCqBo3A4gCQThBBBCtNiIBRQ1nIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD8AE3AAkgASAEKQOIAjcCICAAQbyBggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGYLIARBkBpqIAEgAhCqIiADEOAWIAQtAJAaIgJBKUYNYCAEQa8CaiIDIARBoBpqKQAANwAAIARBqAJqIgYgBEGZGmopAAA3AwAgBEHAAmoiByAEQbAaaikCADcDACAEQcgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A6ACIAQgBCkCqBo3A7gCQThBBBCtNiIBRQ1mIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDoAI3AAkgASAEKQO4AjcCICAAQZSCggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGULIARBkBpqIAEgAhCtIiADEJgWIAQtAJAaIgJBKUYNXiAEQd8CaiIDIARBoBpqKQAANwAAIARB2AJqIgYgBEGZGmopAAA3AwAgBEHwAmoiByAEQbAaaikCADcDACAEQfgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A9ACIAQgBCkCqBo3A+gCQThBBBCtNiIBRQ1lIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AI3AAkgASAEKQPoAjcCICAAQeyCggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGQLIARBkBpqIAEgAhC3IiADEJkWIAQtAJAaIgJBKUYNXCAEQY8DaiIDIARBoBpqKQAANwAAIARBiANqIgYgBEGZGmopAAA3AwAgBEGgA2oiByAEQbAaaikCADcDACAEQagDaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A4ADIAQgBCkCqBo3A5gDQThBBBCtNiIBRQ1kIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDgAM3AAkgASAEKQOYAzcCICAAQcSDggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGMLIARBkBpqIAEgAhCiIiADEJoWIAQtAJAaIgJBKUYNWiAEQb8DaiIDIARBoBpqKQAANwAAIARBuANqIgYgBEGZGmopAAA3AwAgBEHQA2oiByAEQbAaaikCADcDACAEQdgDaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A7ADIAQgBCkCqBo3A8gDQThBBBCtNiIBRQ1jIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDsAM3AAkgASAEKQPIAzcCICAAQZyEggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGILIARBgB9qIgYgASACELkiIgEoAhAgASgCFEEBdiADELoWIARBiBVqIgIgARCSNiADEPISIARBkBpqIgMgBiACEM8dIARBuB5qIgIgARDKBiACEJgeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVggBEHvA2oiAyAEQccZaikAADcAACAEQegDaiIFIARBwBlqKQMANwMAIARBgARqIgggBikDADcDACAEQYgEaiIGIAcpAwA3AwAgBCAEKQO4GTcD4AMgBCAEKQO4DzcD+ANBOEEEEK02IgFFDWIgASACOgAIIAFCgYCAgBA3AgAgASAEKQPgAzcACSABIAQpA/gDNwIgIABB9ISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMYQsgBEGAH2ohDiABIAIQtSIiCygCECEBIAsoAhRBAnYhAiMAQTBrIgckAAJAAkAgAxCSNiIGRQ0AIAYoAhRFDQAgAygCECEFIAMoAhQhCCAHIAY2AiAgByACNgIcIAcgATYCGCAHQQA2AhQgByAFIAhBfHFqNgIQIAcgBTYCDCAHQSRqIQYjAEEgayIJJAAgCUEUaiAHQQxqIgEoAgQgASgCAGtBAnZBAEEEQQQQoBggCSgCGCECIAkoAhRBAUYNbSAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiCCQAIAlBCGoiAiABKAIEIAEoAgBrQQJ2EO4tIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEEwayICJAAgCEEEaiINKAIEIQogDSgCACERAkAgASgCACIFIAEoAgQiD0cEQCABKAIUIQwgASgCECETIAEoAgwhFCABKAIIIQEgDSgCCCAKQQJ0aiENIA8gBWtBAnYhDwNAIAIgBTYCDAJAIBMgBSgCACISSwRAIBQgEkECdGoqAgAhGwwBCyABIAwoAhBPDXhDAAAAACEbIAwoAgQgASAMKAIMaiISQQN2ai0AACASQQdxdkEBcQ15CyANIBs4AgAgBUEEaiEFIA1BBGohDSABQQFqIQEgCkEBaiEKIA9BAWsiDw0ACwsgESAKNgIAIAJBMGokAAwACyAIQRBqJAAgBkEIaiAQKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEGIAMoAhQhBSAHIAI2AhggByABNgIUIAcgBiAFQXxxajYCECAHIAY2AgwgB0EkaiIGIAdBDGoQjhsLIA4gBhDoGCAHQTBqJAAgBEGIFWoiASALEJI2IAMQ8hIgBEGQGmoiAyAOIAEQvh0gBEG4HmoiASALEMoGIAEQkx4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNViAEQZ8EaiIDIARBxxlqKQAANwAAIARBmARqIgUgBEHAGWopAwA3AwAgBEGwBGoiCCAGKQMANwMAIARBuARqIgYgBykDADcDACAEIAQpA7gZNwOQBCAEIAQpA7gPNwOoBEE4QQQQrTYiAUUNYSABIAI6AAggAUKBgICAEDcCACABIAQpA5AENwAJIAEgBCkDqAQ3AiAgAEHMhYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxgCyAEQYAfaiEOIAEgAhCmIiILKAIQIQEgCygCFEEDdiECIwBBMGsiByQAAkACQCADEJI2IgZFDQAgBigCFEUNACADKAIQIQUgAygCFCEIIAcgBjYCICAHIAI2AhwgByABNgIYIAdBADYCFCAHIAUgCEF8cWo2AhAgByAFNgIMIAdBJGohBiMAQSBrIgkkACAJQRRqIAdBDGoiASgCBCABKAIAa0ECdkEAQQhBCBCgGCAJKAIYIQIgCSgCFEEBRg1sIAlBEGoiEEEANgIAIAkgCSgCHDYCDCAJIAI2AggjAEEQayIIJAAgCUEIaiICIAEoAgQgASgCAGtBAnYQ7C0gCCACKQIEQiCJNwIIIAggAkEIajYCBCMAQTBrIgIkACAIQQRqIg0oAgQhCiANKAIAIRECQCABKAIAIgUgASgCBCIPRwRAIAEoAhQhDCABKAIQIRMgASgCDCEUIAEoAgghASANKAIIIApBA3RqIQ0gDyAFa0ECdiEPA0AgAiAFNgIMAkAgEyAFKAIAIhJLBEAgFCASQQN0aisDACEcDAELIAEgDCgCEE8Nd0QAAAAAAAAAACEcIAwoAgQgASAMKAIMaiISQQN2ai0AACASQQdxdkEBcQ14CyANIBw5AwAgBUEEaiEFIA1BCGohDSABQQFqIQEgCkEBaiEKIA9BAWsiDw0ACwsgESAKNgIAIAJBMGokAAwACyAIQRBqJAAgBkEIaiAQKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEGIAMoAhQhBSAHIAI2AhggByABNgIUIAcgBiAFQXxxajYCECAHIAY2AgwgB0EkaiIGIAdBDGoQkxsLIA4gBhDnGCAHQTBqJAAgBEGIFWoiASALEJI2IAMQ8hIgBEGQGmoiAyAOIAEQ2x0gBEG4HmoiASALEMoGIAEQkB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNVCAEQc8EaiIDIARBxxlqKQAANwAAIARByARqIgUgBEHAGWopAwA3AwAgBEHgBGoiCCAGKQMANwMAIARB6ARqIgYgBykDADcDACAEIAQpA7gZNwPABCAEIAQpA7gPNwPYBEE4QQQQrTYiAUUNYCABIAI6AAggAUKBgICAEDcCACABIAQpA8AENwAJIAEgBCkD2AQ3AiAgAEGkhoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxfCyABIAIQsyIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQvB0gAUHUAGoiBiACEMoGIAYQ8hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDVIgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4AdqIARBsBpqKQIANwIAIARB6AdqIARBuBpqKQIANwIAIARByQdqIAMpAwA3AAAgBEHQB2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgHIAQgAToAwAcgBCAXNwDBByAEQcAHahDcKSEBIABB/IaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxeCyABIAIQoSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwB0gAUHUAGoiBiACEMoGIAYQ9RwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDVAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBkAhqIARBsBpqKQIANwIAIARBmAhqIARBuBpqKQIANwIAIARB+QdqIAMpAwA3AAAgBEGACGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AogIIAQgAToA8AcgBCAXNwDxByAEQfAHahDcKSEBIABB1IeCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxdCyABIAIQnSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwx0gAUHUAGoiBiACEMoGIAYQ+hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDU4gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBwAhqIARBsBpqKQIANwIAIARByAhqIARBuBpqKQIANwIAIARBqQhqIAMpAwA3AAAgBEGwCGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ArgIIAQgAToAoAggBCAXNwChCCAEQaAIahDcKSEBIABBrIiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxcCyABIAIQriIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0B0gAUHUAGoiBiACEMoGIAYQ+RwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDUwgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB8AhqIARBsBpqKQIANwIAIARB+AhqIARBuBpqKQIANwIAIARB2QhqIAMpAwA3AAAgBEHgCGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AugIIAQgAToA0AggBCAXNwDRCCAEQdAIahDcKSEBIABBhImCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxbCyABIAIQuCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQvR0gAUHUAGoiBiACEMoGIAYQ9BwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDUogBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AZqIARBsBpqKQIANwIAIARB2AZqIARBuBpqKQIANwIAIARBuQZqIAMpAwA3AAAgBEHABmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgGIAQgAToAsAYgBCAXNwCxBiAEQbAGahDcKSEBIABB3ImCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxaCyABIAIQoyIhCyMAQeAAayIFJAAgCygCECEBIAsoAhRBA3YhBiMAQTBrIgIkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEIIAMoAhQhCSACIAc2AiAgAiAGNgIcIAIgATYCGCACQQA2AhQgAiAIIAlBfHFqNgIQIAIgCDYCDCACQSRqIQcjAEEgayIJJAAgCUEUaiACQQxqIgEoAgQgASgCAGtBAnZBAEEEQQgQoBggCSgCGCEGIAkoAhRBAUYNZyAJQRBqIhNBADYCACAJIAkoAhw2AgwgCSAGNgIIIwBBMGsiBiQAIAlBCGoiCCABKAIEIAEoAgBrQQJ2EOotIAgpAgQhFyAGQRhqIAFBEGopAgA3AwAgBkEQaiABQQhqKQIANwMAIAYgASkCADcDCCAGIBdCIIk3AiggBiAIQQhqNgIkIwBBMGsiASQAIAZBJGoiDSgCBCEMIA0oAgAhFAJAIAZBCGoiCCgCACIKIAgoAgQiD0cEQCAIKAIUIQ4gCCgCECESIAgoAgwhFSAIKAIIIQggDSgCCCAMQQN0aiENIA8gCmtBAnYhDwNAIAEgCjYCDAJAIBIgCigCACIQSwRAIBUgEEEDdGoiESgCBCEQIBEoAgAhEQwBCyAIIA4oAhBPDXFBACEQQQAhESAOKAIEIAggDigCDGoiFkEDdmotAAAgFkEHcXZBAXENcwsgDSARNgIAIA1BBGogEDYCACAKQQRqIQogDUEIaiENIAhBAWohCCAMQQFqIQwgD0EBayIPDQALCyAUIAw2AgAgAUEwaiQADAALIAZBMGokACAHQQhqIBMoAgA2AgAgByAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEIIAIgBjYCGCACIAE2AhQgAiAHIAhBfHFqNgIQIAIgBzYCDCACQSRqIgcgAkEMahCPGwsgBSAHEOsYIAJBMGokACAFQQxqIgEgCxCSNiADEPISIAVBJGoiAiAFIAEQ0x0gBUHUAGoiASALEMoGIAEQ9xwgBEGQGmoiAUEIaiAFQdwAaigCADYCACABIAUpAlQ3AgAgASAFKQIwNwIMIAFBFGogBUE4aigCADYCACABIAUpAjw3AhggAUEgaiAFQcQAaikCADcCACABQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokACAELQCQGiIBQSlGDUggBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBgAdqIARBsBpqKQIANwIAIARBiAdqIARBuBpqKQIANwIAIARB6QZqIAMpAwA3AAAgBEHwBmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AvgGIAQgAToA4AYgBCAXNwDhBiAEQeAGahDcKSEBIABBtIqCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxZCyABIAIQoCIhCyMAQeAAayIFJAAgCygCECEBIAsoAhRBBHYhBiMAQTBrIgIkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEIIAMoAhQhCSACIAc2AiAgAiAGNgIcIAIgATYCGCACQQA2AhQgAiAIIAlBfHFqNgIQIAIgCDYCDCACQSRqIQcjAEEgayIJJAAgCUEUaiACQQxqIgEoAgQgASgCAGtBAnZBAEEIQRAQoBggCSgCGCEGIAkoAhRBAUYNZiAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSAGNgIIIwBBMGsiBiQAIAlBCGoiCCABKAIEIAEoAgBrQQJ2EOktIAgpAgQhFyAGQRhqIAFBEGopAgA3AwAgBkEQaiABQQhqKQIANwMAIAYgASkCADcDCCAGIBdCIIk3AiggBiAIQQhqNgIkIwBBMGsiASQAIAZBJGoiDSgCBCEMIA0oAgAhEQJAIAZBCGoiCCgCACIKIAgoAgQiD0cEQCAIKAIUIQ4gCCgCECETIAgoAgwhFCAIKAIIIQggDSgCCCAMQQR0aiENIA8gCmtBAnYhDwNAIAEgCjYCDAJAIBMgCigCACISSwRAIAFBGGogFCASQQR0aiISQQhqKQMANwMAIAEgEikDADcDEAwBCyAIIA4oAhBPDXAgDigCBCAIIA4oAgxqIhJBA3ZqLQAAIBJBB3F2QQFxDXIgAUEYakIANwMAIAFCADcDEAsgDSABKQMQNwMAIA1BCGogAUEYaikDADcDACAKQQRqIQogDUEQaiENIAhBAWohCCAMQQFqIQwgD0EBayIPDQALCyARIAw2AgAgAUEwaiQADAALIAZBMGokACAHQQhqIBAoAgA2AgAgByAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEIIAIgBjYCGCACIAE2AhQgAiAHIAhBfHFqNgIQIAIgBzYCDCACQSRqIgcgAkEMahCSGwsgBSAHEOoYIAJBMGokACAFQQxqIgEgCxCSNiADEPISIAVBJGoiAiAFIAEQxR0gBUHUAGoiASALEMoGIAEQ8RwgBEGQGmoiAUEIaiAFQdwAaigCADYCACABIAUpAlQ3AgAgASAFKQIwNwIMIAFBFGogBUE4aigCADYCACABIAUpAjw3AhggAUEgaiAFQcQAaikCADcCACABQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokACAELQCQGiIBQSlGDUYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBsAdqIARBsBpqKQIANwIAIARBuAdqIARBuBpqKQIANwIAIARBmQdqIAMpAwA3AAAgBEGgB2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AqgHIAQgAToAkAcgBCAXNwCRByAEQZAHahDcKSEBIABBjIuCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxYCyAEQYAfaiIGIAEgAhCnIiIBKAIQIAEoAhRBAnYgAxC7FiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDKHSAEQbgeaiICIAEQygYgAhDQGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1EIARB/wRqIgMgBEHHGWopAAA3AAAgBEH4BGoiBSAEQcAZaikDADcDACAEQZAFaiIIIAYpAwA3AwAgBEGYBWoiBiAHKQMANwMAIAQgBCkDuBk3A/AEIAQgBCkDuA83A4gFQThBBBCtNiIBRQ1YIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD8AQ3AAkgASAEKQOIBTcCICAAQeSLggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFcLIARBgB9qIgYgASACEKsiIgEoAhAgASgCFEEDdiADELwWIARBiBVqIgIgARCSNiADEPISIARBkBpqIgMgBiACEMYdIARBuB5qIgIgARDKBiACENIYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUIgBEGvBWoiAyAEQccZaikAADcAACAEQagFaiIFIARBwBlqKQMANwMAIARBwAVqIgggBikDADcDACAEQcgFaiIGIAcpAwA3AwAgBCAEKQO4GTcDoAUgBCAEKQO4DzcDuAVBOEEEEK02IgFFDVcgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgBTcACSABIAQpA7gFNwIgIABBvIyCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVgsgBEGAH2ohCCABIAIQvCIiBSgCECECIAUoAhRBBHYhBiMAQTBrIgEkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEJIAMoAhQhCiABIAc2AiAgASAGNgIcIAEgAjYCGCABQQA2AhQgASAJIApBfHFqNgIQIAEgCTYCDCABQSRqIQYjAEEgayIJJAAgCUEUaiABQQxqIgcoAgQgBygCAGtBAnZBAEEQQRAQoBggCSgCGCECIAkoAhRBAUYNYiAJQRBqIgtBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiAiQAIAlBCGoiCiAHKAIEIAcoAgBrQQJ2EOstIAIgCikCBEIgiTcCCCACIApBCGo2AgQgByACQQRqEKoQIAJBEGokACAGQQhqIAsoAgA2AgAgBiAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEJIAEgBjYCGCABIAI2AhQgASAHIAlBfHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCYGwsgCCAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDyEiAEQZAaaiIDIAggARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXxxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCSQAIAlBFGogAUEMaiIFKAIEIAUoAgBrQQJ2QQBBEEEgEKAYIAkoAhghAiAJKAIUQQFGDWEgCUEQaiIRQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQTBrIgckACAJQQhqIgIgBSgCBCAFKAIAa0ECdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCiAOKAIAIRMCQCAHQQhqIgUoAgAiCCAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIRIgBSgCCCELIA4oAgggCkEFdGohBSAQIAhrQQJ2IRADQCACIAg2AgwCQCAUIAgoAgAiDksEQCASIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyALIA0oAhBPDWxCACEaQgAhGUIAIRhCACEXIA0oAgQgCyANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1tCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCEEEaiEIIAVBIGohBSALQQFqIQsgCkEBaiEKIBBBAWsiEA0ACwsgEyAKNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiARKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXxxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhxsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8hIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9SggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAILQABQQFrDgMGBwgFCyAILQABDgIKCzoLIAgtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiBiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCAIKAIEIQwjAEFAaiICJAAgAiABEJI2NgIIIAMoAhQhByADKAIQIQMgAiABNgI8IAIgAzYCMCACIAMgB0F8cWo2AjQgAiACQQhqNgI4IAJBHGohBSMAQUBqIgMkACADQZOAgIB4NgIIIANBMGogAkEwaiIBQQhqKQIANwMAIAMgASkCADcDKCADIANBCGo2AjggA0EcaiEIIwBBMGsiASQAIAFBDGogA0EoaiIHEPIgAkACQAJAIAEoAgxBAUYEQCABKAIUIQ0gASgCECEOIAFBGGoiCkEEQQBBBEEIEKAYIAEoAhwhCSABKAIYQQFGDQIgASgCICILIA02AgQgCyAONgIAIAFBCGoiDUEBNgIAIAEgCzYCBCABIAk2AgAgAUEoaiAHQRBqKAIANgIAIAFBIGogB0EIaikCADcDACABIAcpAgA3AxgjAEEQayIHJAAgB0EEaiAKEPIgIAcoAgRBAUYEQANAIAcoAgwhCyAHKAIIIQ4gASgCCCIJIAEoAgBGBEAgASAJQQFBBEEIEN4oCyABKAIEIAlBA3RqIg8gCzYCBCAPIA42AgAgASAJQQFqNgIIIAdBBGogChDyICAHKAIEDQALCyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCADcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgALIAFBMGokAAwBCyAJIAEoAiBBiPmDARD9LwALAkAgAygCCEGTgICAeEcEQCAFIAMpAgg3AgAgBUEQaiADQRhqKAIANgIAIAVBCGogA0EQaikCADcCACAIEOo7DAELIAUgAykCHDcCBCAFQZOAgIB4NgIAIAVBDGogA0EkaigCADYCAAsgA0FAayQAIAIoAighAyACKAIkIQEgAigCICEHAkAgAigCHCIFQZOAgIB4RwRAIAYgAigCLDYCFCAGIAM2AhAgBiABNgIMIAYgBzYCCCAGIAU2AgQgBkEpOgAADAELIAIgBzYCFCACIAE2AgwgAiABNgIQIAIgASADQQN0ajYCGCAGIAJBDGogDBC6BgsgAkFAayQAIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiIGIAQoAigiCSAEKAIsKAIMEQAAIAlFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCAIKAIEIQEjAEGABGsiAiQAIAJBzAJqIANBDGoiCxDbPCABbBDyHgJAAkACQAJAIAsQ2zwiDwRAIAkoAiwhECADKAIQIQggAkHYAmohDANAAkACQAJAAkAgAyAFEIs7RQRAIAwQ5jogAigC2AJFDQEgAigC6AIgAWoiDUEDdiANQQdxQQBHaiIHIAIoAuQCIgpLBEAgByAKayEOIAIoAtwCIhEgB0kEQCAMIBFBAXQiCiAHENIqIhEgCiARSxsQ6BkgAigC5AIhCgsgDgRAIAIoAuACIApqQQAgDvwLAAsgAiAHNgLkAgsgAiANNgLoAiACQcwCaiABELQlDAQLIAIgBTYC/AMgCxDbPCAFTQ0BIAgoAgAiB0EASARAIAJBEGpBFEEAQQFBARCgGCACKAIUIQMgAigCEEEBRg0DIAIoAhgiAUEQakGw/4EBKAAANgAAIAFBCGpBqP+BASkAADcAACABQaD/gQEpAAA3AAAgAkEUNgJsIAIgATYCaCACIAM2AmQgAkGGgICAeDYCYCACQcwCahC8LQwHCyACQcwCaiAHIBBsIgcgASAHahCIDwwDC0H89IEBELI7AAsgAiADEPw7NgKMASACQQI2AhQgAkGI8YEBNgIQIAJCAjcCHCACQTs2AvgDIAJBOzYC8AMgAiACQewDajYCGCACIAJBjAFqNgL0AyACIAJB/ANqNgLsAyACQRBqQZjxgQEQ7ywACyADIAIoAhhBiP2BARD9LwALIAhBBGohCCAPIAVBAWoiBUcNAAsLIAJB3ABqIAJBzAJqIgEQ1BQgAi0AXCEHIAEQvC0gB0EpRg0AIAJBzwBqIgUgAkHsAGopAAA3AAAgAkHIAGoiCCACQeUAaikAADcDACACQTBqIAJB/ABqKQIANwIAIAJBOGogAkGEAWopAgA3AgAgAkEZaiAIKQMANwAAIAJBIGogBSkAADcAACACIAIpAF0iFzcDQCACIAIpAnQ3AiggAiAXNwARIAIgBzoAECABIAkoAgwgCSgCECIBKAIIQQFrQXhxakEIaiABIAJBEGoQiAEgAigC1AIhASACKALQAiEHIAIoAswCIgVBk4CAgHhGDQEgBiACKQLYAjcCECAGIAE2AgwgBiAHNgIIIAYgBTYCBCAGQSk6AAAMAgsgAkHTAGogAkHwAGooAgAiATYAACACQcsAaiACQegAaikCACIXNwAAIAIgAikCYCIYNwBDIAZBFGogATYAACAGQQxqIBc3AAAgBiAYNwAEIAZBKToAAAwCCyACIAE2ApABIAIgBzYCjAFBwAAhBwJAIAsQ2zwiAUEDdiABQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIHRQ1gC0EAIQUgAkEANgLYAiACIAc2AtQCIAIgATYC0AIgAkHAADYCzAIgAkFAayIBIAJBzAJqIAgQ0iUgAkEIaiABEIY9IAIoAgwhASACKAIIIQogCxDbPCIMRQ0BIAMoAhAhCANAAkAgAiAFNgL8AwJAAkAgCxDbPCAFSwRAIAgoAgAiB0EASARAIAJBzAJqQRRBAEEBQQEQoBggAigC0AIhAyACKALMAkEBRgRAIAMgAigC1AJBiP2BARD9LwALIAIoAtQCIgFBEGpBsP+BASgAADYAACABQQhqQaj/gQEpAAA3AAAgAUGg/4EBKQAANwAAIAZBFDYCECAGIAE2AgwgBiADNgIIIAZBhoCAgHg2AgQgBkEpOgAAIAJBQGsQzy8gAigCjAEiASABKAIAIgFBAWs2AgAgAUEBRw0IIAJBjAFqELsjDAgLIAMgBRCLO0UNASAJIAcQmiUNAQwCCyACIAMQ/Ds2AuwDIAJBAjYC0AIgAkGI8YEBNgLMAiACQgI3AtgCIAJBOzYCaCACQTs2AmAgAiACQdwAajYC1AIgAiACQewDajYCZCACIAJB/ANqNgJcIAJBzAJqQZjxgQEQ7ywACyAFQQN2IgcgAU8NASAHIApqIgcgBy0AAEF+IAVBB3F3cToAAAsgCEEEaiEIIAwgBUEBaiIFRw0BDAMLCyAHIAFBgPSBARDDIQALQcD0gQFBKSACQcwCakHM/IEBQez0gQEQ1R4ACyACQewCaiAJEMoGIAsQ2zwhASACQQA7AaQDIAJBADYCoAMgAkEANgKIAyACQQA2AvwCIAIgATYC+AIgAkIENwLkAiACQgA3AtwCIAJCgICAgMAANwLUAiACQQA2AswCIAIoAkghASACKAJMIQMgAiACKQJANwJoIAJBADYCZCACIAM2AmAgAiABNgJcIAIgAkHcAGoQ1zsgAigCACEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAlw3AgggAUEQaiACQeQAaikCADcCACABQRhqIAJB7ABqKAIANgIAIAIgAzYC9AMgAiAHNgLwAyACIAE2AuwDIAJB8AFqIgMgAkHMAmoiASACQewDahCuFiACQQA2AsQCIAEgAigCjAEgAigCkAEQ0yMgAkGUAWoiByADIAEQ7yUgAkGoA2oiASAHEM0cIAYgARDcFCACQRBqEP4kDAILDFILIAJBEGoQ/iQLIAJBgARqJAAgBC0AkBoiAUEpRw0TIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADE4LIAEgAigCJBEEACADQQxqIgMQ2zwgAxDbPCEDSQ01IARBEGogAUEAIAMgAigCIBEFACAAIAQpAxA3AgQgAEGTgICAeDYCAAxNCyABIAIQnyIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1B0gAUHUAGoiBiACEMoGIAYQhRcgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDTMgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBwAtqIARBsBpqKQIANwIAIARByAtqIARBuBpqKQIANwIAIARBqQtqIAMpAwA3AAAgBEGwC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ArgLIAQgAToAoAsgBCAXNwChCyAEQaALahDcKSEBIABBuI+CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxMCyABIAIQtCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQyB0gAUHUAGoiBiACEMoGIAYQ/hYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDTEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB8AtqIARBsBpqKQIANwIAIARB+AtqIARBuBpqKQIANwIAIARB2QtqIAMpAwA3AAAgBEHgC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AugLIAQgAToA0AsgBCAXNwDRCyAEQdALahDcKSEBIABBkJCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxLCyABIAIQsiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQyR0gAUHUAGoiBiACEMoGIAYQ/RYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDS8gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBoAxqIARBsBpqKQIANwIAIARBqAxqIARBuBpqKQIANwIAIARBiQxqIAMpAwA3AAAgBEGQDGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApgMIAQgAToAgAwgBCAXNwCBDCAEQYAMahDcKSEBIABB6JCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxKCyABIAIQrCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0R0gAUHUAGoiBiACEMoGIAYQ/BYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDS0gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AxqIARBsBpqKQIANwIAIARB2AxqIARBuBpqKQIANwIAIARBuQxqIAMpAwA3AAAgBEHADGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgMIAQgAToAsAwgBCAXNwCxDCAEQbAMahDcKSEBIABBwJGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxJCyABIAIQpSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0h0gAUHUAGoiBiACEMoGIAYQlB4gBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSsgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4ApqIARBsBpqKQIANwIAIARB6ApqIARBuBpqKQIANwIAIARByQpqIAMpAwA3AAAgBEHQCmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgKIAQgAToAwAogBCAXNwDBCiAEQcAKahDcKSEBIABBmJKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxICyABIAIQsCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQxB0gAUHUAGoiBiACEMoGIAYQlx4gBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSkgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBkAtqIARBsBpqKQIANwIAIARBmAtqIARBuBpqKQIANwIAIARB+QpqIAMpAwA3AAAgBEGAC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AogLIAQgAToA8AogBCAXNwDxCiAEQfAKahDcKSEBIABB8JKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxHCyABIAIQniIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQzB0gAUHUAGoiBiACEMoGIAYQ+BwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDScgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBoAlqIARBsBpqKQIANwIAIARBqAlqIARBuBpqKQIANwIAIARBiQlqIAMpAwA3AAAgBEGQCWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApgJIAQgAToAgAkgBCAXNwCBCSAEQYAJahDcKSEBIABByJOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxGCyABIAIQtiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1x0gAUHUAGoiBiACEMoGIAYQ8xwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSUgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AlqIARBsBpqKQIANwIAIARB2AlqIARBuBpqKQIANwIAIARBuQlqIAMpAwA3AAAgBEHACWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgJIAQgAToAsAkgBCAXNwCxCSAEQbAJahDcKSEBIABBoJSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxFCyABIAIQryIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwh0gAUHUAGoiBiACEMoGIAYQ+xwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSMgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBgApqIARBsBpqKQIANwIAIARBiApqIARBuBpqKQIANwIAIARB6QlqIAMpAwA3AAAgBEHwCWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AvgJIAQgAToA4AkgBCAXNwDhCSAEQeAJahDcKSEBIABB+JSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxECyABIAIQuiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1R0gAUHUAGoiBiACEMoGIAYQ9hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBsApqIARBsBpqKQIANwIAIARBuApqIARBuBpqKQIANwIAIARBmQpqIAMpAwA3AAAgBEGgCmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AqgKIAQgAToAkAogBCAXNwCRCiAEQZAKahDcKSEBIABB0JWCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxDCyAEQZAaaiABIAIQlyIgAxCNAiAELQCQGiIBQSlGDR8gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBqBdqIARBqBpqQST8CgAAIARBmRdqIAMpAwA3AAAgBEGgF2ogAikAADcAACAEIAE6AJAXIAQgBCkDiBU3AJEXIARBkBdqEOwpIQEgAEGoloIBNgIIIAAgATYCBCAAQZOAgIB4NgIADEILIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeQYaiAEQbAaaikCADcCACAEQewYaiAEQbgaaikCADcCACAEQfQYaiAEQcAaaikCADcCACAEQc0YaiADKQMANwAAIARB1BhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLcGCAEIAE6AMQYIAQgFzcAxRggBEHEGGoQ5ikhASAAQZCXggE2AgggACABNgIEIABBk4CAgHg2AgAMQQsgBEGQGmogASACEJYiIAMQnAIgBC0AkBoiAUEpRg0cIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQeQXaiAEQagaakEk/AoAACAEQdUXaiADKQMANwAAIARB3BdqIAIpAAA3AAAgBCABOgDMFyAEIAQpA4gVNwDNFyAEQcwXahDsKSEBIABB6JeCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxACyAEQZAaaiELIAEgAhCLIiEBIwBBMGsiByQAIAcgASgCHCABKAIgQQR2IAMQzRYgB0EMaiABEJM2IAMQ8hIgASgCBCEIIAdBJGogASgCCCIFQQBBBEEMEKAYIAcoAighAQJAAkAgBygCJEEBRwRAIAcoAiwhAwJAIAFFDQAgBUEMbCEKIAMhAiABIQYDQCAKRQ0BIAgoAgAiCSAJKAIAIgxBAWo2AgAgDEEASA0DIAJBBGogCCkCBDcCACACIAk2AgAgAkEMaiECIApBDGshCiAIQQxqIQggBkEBayIGDQALCyAHIAU2AiwgByADNgIoIAcgATYCJCALIAcgB0EkaiAHQQxqELwgIAdBMGokAAwCCyABIAcoAixBmP2BARD9LwsACyAEQZAVaiIBIARBnBpqKQIANwMAIARBmBVqIgIgBEGkGmooAgA2AgAgBCAEKQKUGjcDiBUgBCgCkBoiA0GAgICAeEYNGiAEQaAYaiAEQagaakEk/AoAACAEQZQYaiABKQMANwIAIARBnBhqIAIoAgA2AgAgBCADNgKIGCAEIAQpA4gVNwKMGCAEQYgYahDsKSEBIABBwJiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw/CyAEQZAaaiABIAIQmSIgAxCOAiAELQCQGiIBQSlGDRggBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARB+AxqIARBqBpqQST8CgAAIARB6QxqIAMpAwA3AAAgBEHwDGogAikAADcAACAEIAE6AOAMIAQgBCkDiBU3AOEMIARB4AxqEOwpIQEgAEGYmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD4LIARBkBpqIAEgAhCYIiADEJ0CIAQtAJAaIgFBKUYNFiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEG0DWogBEGoGmpBJPwKAAAgBEGlDWogAykDADcAACAEQawNaiACKQAANwAAIAQgAToAnA0gBCAEKQOIFTcAnQ0gBEGcDWoQ7CkhASAAQfCZggE2AgggACABNgIEIABBk4CAgHg2AgAMPQsgBEGQGmohCyABIAIQjCIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEM0WIAdBDGogARCTNiADEPISIAEoAgQhCCAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCiADIQIgASEGA0AgCkUNASAIKAIAIgkgCSgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAgpAgQ3AgAgAiAJNgIAIAJBDGohAiAKQQxrIQogCEEMaiEIIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCyAHIAdBJGogB0EMahC9ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRQgBEHwDWogBEGoGmpBJPwKAAAgBEHkDWogASkDADcCACAEQewNaiACKAIANgIAIAQgAzYC2A0gBCAEKQOIFTcC3A0gBEHYDWoQ7CkhASAAQciaggE2AgggACABNgIEIABBk4CAgHg2AgAMPAsgBEGQGmogASACEJAiIAMQugIgBC0AkBoiAUEpRg0SIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbQOaiAEQbAaaikCADcCACAEQbwOaiAEQbgaaikCADcCACAEQcQOaiAEQcAaaikCADcCACAEQZ0OaiADKQMANwAAIARBpA5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKsDiAEIAE6AJQOIAQgFzcAlQ4gBEGUDmoQ5ikhASAAQaCbggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBpA9qIARBsBpqKQIANwIAIARBrA9qIARBuBpqKQIANwIAIARBtA9qIARBwBpqKAIANgIAIARBjQ9qIAMpAwA3AAAgBEGUD2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApwPIAQgAToAhA8gBCAXNwCFDyAEQYQPahDlKSEBIABBiJyCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEHIAEgAhCRIiEJIwBBwARrIgYkACAJKAIYIQ0gCSgCHCEKIAZBqAJqIANBDGoiCxDbPEEAQQhBCBCgGCAGKAKsAiEBAkAgBigCqAJBAUcEQCAGQQA2ApgEIAYgBigCsAIiAjYClAQgBiABNgKQBCAGQQA2AqQEIAZCgICAgIABNwKcBCABBH8gAgUgBkGQBGpB8K+CARCzKCAGKAKUBAtCADcDACAGQQE2ApgEQcAAIQUgCxDbPCIBQQN2IAFBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiAUHAABDRNARAIAEEQCABQcAAEK02IgVFDUoLQQAhAiAGQQA2ArQCIAYgBTYCsAIgBiABNgKsAiAGQcAANgKoAiAGQagEaiIBIAZBqAJqIAgQ0iUgBkEYaiABEIY9IAYoAhwhASAGKAIYIQ4CQAJAAkACQCALENs8Ig8EQCAKQQN2IQwgAygCECEQA0ACQAJAAkACQAJAAkACQCADIAIQiztFBEAgAkEDdiIFIAFPDQEgBSAOaiIFIAUtAABBfiACQQdxd3E6AAAgBigCmAQiBSAGKAKQBEYEQCAGQZAEakGAsIIBELMoCyAGKAKUBCAFQQN0aiAXNwMAIAYgBUEBajYCmAQMBwsgBiACNgK4BCALENs8IAJNDQEgECACQQJ0aigCACIFQQBIBEBBFCECIAZBqAJqQRRBAEEBQQEQoBggBigCrAIhCiAGKAKoAkEBRg0FIAYoArACIghBEGpBsP+BASgAADYAACAIQQhqQaj/gQEpAAA3AAAgCEGg/4EBKQAANwAAIAZBqARqEM8vIAZBnARqEOM8IAZBkARqEOM8QYaAgIB4IQMMCgsgBSAMTw0CIAVBAWoiCCAMTw0FIA0gCEEDdGopAwAiGSANIAVBA3RqKQMAIhh9IBd8IRcgBigCmAQiCCAGKAKQBEYEQCAGQZAEakGwsIIBELMoCyAGKAKUBCAIQQN0aiAXNwMAIAYgCEEBajYCmAQgGCAZUwRAIAYoAqQEIghBA3QhCgNAIAYoApwEIAhGBEAgBkGcBGpBwLCCARCzKAsgBigCoAQgCmogGDcDACAGIAhBAWoiCDYCpAQgCkEIaiEKIBkgGEIBfCIYUg0ACwsgCSAFEJI7DQYgAkEDdiIFIAFPDQMgBSAOaiIFIAUtAABBfiACQQdxd3E6AAAMBgsgBSABQYD0gQEQwyEACyAGIAMQ/Ds2ArwEIAZBAjYCrAIgBkGI8YEBNgKoAiAGQgI3ArQCIAZBOzYCLCAGQTs2AiQgBiAGQSBqNgKwAiAGIAZBvARqNgIoIAYgBkG4BGo2AiAgBkGoAmpBmPGBARDvLAALIAUgDEGQsIIBEMMhAAsgBSABQYD0gQEQwyEACyAKIAYoArACQYj9gQEQ/S8ACyAIIAxBoLCCARDDIQALIAJBAWoiAiAPRw0ACwsgBkEoaiAGQaQEaigCADYCACAGIAYpApwENwMgIAZBtAJqIAZBIGoiARCaEiAGQbACaiAGQZgEaigCACIKNgIAIAYgBikCkAQiFzcDqAIgBigCtAIhCCAGKAK4AiECIAYoArwCIQUgBigCrAIhAyAGQYgDaiIMIAZBwAJqQST8CgAAIAZB2ABqIg0gBkGwBGoiDikCADcDACAGIAYpAqgENwNQIBenIg9BgICAgHhGDQAgBkEsaiAMQST8CgAAIA4gDSkDADcDACAGIAYpA1A3A6gEIAYgBTYCKCAGIAI2AiQgBiAINgIgIAYgCjYCpAQgBiADNgKgBCAGIA82ApwEIAZBqAJqIAkoAgwgCSgCECICKAIIQQFrQXhxakEIaiACIAEQigEgBigCsAIhBSAGKAKsAiEIIAYoAqgCIgJBk4CAgHhGDQEgByAGKQK0AjcCECAHIAU2AgwgByAINgIIIAcgAjYCBCAHQSk6AAAgBkGoBGoQzy8gBkGcBGoQ4zwgARD+JAwCCyAHIAU2AhQgByACNgIQIAcgCDYCDCAHIAo2AgggByADNgIEIAdBKToAAAwBCyAGQYgDaiICIAZBnARqEN4sIAYgBikCiAM3ArQCIAZBADYCsAIgBiAGKAKUAyIKNgKsAiAGIAYoApADNgKoAiAGQRBqIAZBqAJqIgMQ1zsgBigCECEMQRxBBBCtNiIBRQ1AIAFCgYCAgBA3AgAgASAGKQKoAjcCCCABQRBqIAZBsAJqKQIANwIAIAFBGGogBkG4AmooAgA2AgAgBiAKNgJsIAYgDDYCaCAGIAE2AmQgBkHIAmogCRDKBiALENs8IQEgBkEAOwGAAyAGQQA2AvwCIAZBADYC5AIgBkEANgLYAiAGIAE2AtQCIAZCBDcCwAIgBkIANwK4AiAGQoCAgIDAADcCsAIgBkEANgKoAiAGKAKwBCEBIAYoArQEIQkgBiAGKQOoBDcClAMgBkEANgKQAyAGIAk2AowDIAYgATYCiAMgBkEIaiACENc7IAYoAgghCkEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgBikCiAM3AgggAUEQaiAGQZADaikCADcCACABQRhqIAZBmANqKAIANgIAIAYgCTYCWCAGIAo2AlQgBiABNgJQIAZBzAFqIgEgAyAGQdAAahCuFiAGQQA2AqACIAIgCCAFENMjIAMgASACEO8lIAZB8ABqIgEgAyAGQeQAahD6IyAGQcwDaiICIAEQzRwgByACEK4fIAZBIGoQ/iQLIAZBwARqJAAMAwsMPgtBwPSBAUEpIAZBqAJqQcz8gQFB7PSBARDVHgALIAEgBigCsAJB4K+CARD9LwALIAQtAJAaIgFBKUYNDyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHsDmogBEGwGmopAgA3AgAgBEH0DmogBEG4GmopAgA3AgAgBEH8DmogBEHAGmopAgA3AgAgBEHVDmogAykDADcAACAEQdwOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC5A4gBCABOgDMDiAEIBc3AM0OIARBzA5qEOYpIQEgAEHgnIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDkLIARBOGogASACEMgvIg4Q3DsgBCgCPCECIAQoAjghASAEIAM2ApAVIAQgATYCiBUgBCABIAJBA3RqNgKMFSAEQZAaaiEFIwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiAEQYgVaiIBQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEKIwBBMGsiASQAIAFBCGogAkEgaiIGEIYoAkACQAJAIAEoAggiCwRAIAEoAgwhDSABQSBqIgxBBEEAQQRBCBCgGCABKAIkIQcgASgCIEEBRg0CIAEoAigiCSANNgIEIAkgCzYCACABQRxqIg9BATYCACABIAk2AhggASAHNgIUIAFBKGogBkEIaikCADcDACABIAYpAgA3AyAjAEEQayIGJAAgBkEIaiAMEIYoIAYoAggiCQRAIAFBFGohCyAGKAIMIQcDQCALKAIIIg0gCygCAEYEQCALQQEQ6i0LIAsoAgQgDUEDdGoiECAHNgIEIBAgCTYCACALIA1BAWo2AgggBiAMEIYoIAYoAgQhByAGKAIAIgkNAAsLIAZBEGokACAKQQhqIA8oAgA2AgAgCiABKQIUNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEGI+YMBEP0vAAsCQCACKAIAQZOAgIB4RwRAIAUgAikCADcCACAFQRBqIAJBEGooAgA2AgAgBUEIaiACQQhqKQIANwIAIAoQwycgChDqOwwBCyAFIAIpAhQ3AgQgBUGTgICAeDYCACAFQQxqIAJBHGooAgA2AgALIAJBMGokACAEKAKcGiECIAQoApgaIQEgBCgClBohBiAEKAKQGiIHQZOAgIB4RwRAIAAgBCgCoBo2AhAgACACNgIMIAAgATYCCCAAIAY2AgQgACAHNgIADDkLIARBMGogCEEEahDDNCAEKAI0IQUgBCgCMCEHIARCADcCqBogBCABIAJBA3RqNgKkGiAEIAY2AqAaIAQgATYCnBogBCABNgKYGiAEIAc2ApAaIAQgByAFQQJ0ajYClBogBEG4D2ogBEGQGmoiCRD/GCAJIAMQwC0gBCAONgK0GiMAQTBrIgckACAHQQxqIQ0jAEFAaiIGJAAgBkEIaiAJQSj8CgAAIAYoAggiChC/PCEBIAYoAiQhAiAKEL88GkHAACEFAkBBfyABIAJrIgFBB2oiCCABIAhLGyIBQQN2IghBwP///wFxQUBrIAggAUH4A3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIFRQ1ICyAGQQA2AjwgBiAFNgI4IAYgATYCNCAGQcAANgIwIAZBDGohDiAGKAIsIQ8gBigCGCEQIAYoAhAhESAGKAIcIRMgBigCDCEMIAYoAighAUEAIQVBASEIA0ACQAJAAkACQCABIAJGIhRFBEACfyAMBEAgAiATTw0DQQAgESACIBBqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcQ0BGgsgCigCECACQQJ0aigCACILQQBIDQMgCEEAIA8gCxCTOxsLIAVyIQUgAkEBaiECIAhBAXQiCEH+AXENBSAGIAI2AiQMAwsgBiABNgIkIAEhAiAIQf8BcUEBRw0CDAMLQZz4gwFBIEG8+IMBEJ8pAAtBtPmDARCyOwALAkAgBigCPCILIAYoAjRHDQAgChC/PCEIIAoQvzwaIAYoAjwiC0F/IAggAmsiCEEHaiISIAggEksbQQN2akEBaiIIIAYoAjRNDQAgCBDVKiEIIAZBMGogBigCNEEBdCILIAggCCALSRsQ6BkgBigCPCELCyAGKAI4IAtqIAU6AABBASEIIAYgC0EBajYCPEEAIQUgFEUNAQsLIA0gBikCMDcCACANQQhqIAZBOGopAgA3AgACQCAMRQ0AIAwgDCgCACIBQQFrNgIAIAFBAUcNACAOEPseCyAGQUBrJAAMAQtBzPiDAUEpIAZBMGpBmPmDAUH4+IMBENUeAAsgByAHKQIMNwIoIAdBADYCJCAHIAcoAhgiBjYCICAHIAcoAhQ2AhwgByAHQRxqENc7IAcoAgAhBUEcQQQQrTYiAUUNOiABQoGAgIAQNwIAIAEgBykCHDcCCCAEQYQRaiICIAY2AgggAiAFNgIEIAIgATYCACABQRBqIAdBJGopAgA3AgAgAUEYaiAHQSxqKAIANgIAIAdBMGokACAEKALADwRAIARBkBVqIARBwA9qKAIANgIAIARBnBVqIARBjBFqKAIANgIAIAQgBCkCuA83A4gVIAQgBCkChBE3ApQVIAkgBEGIFWoQrRAgCRDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiIBIARBhBFqQQAgA0EMaiICENs8EPIVIARBiBVqIgMgARDhJyABIAIQ2zwgAxDVGCABEOUpIQEgAEG4nYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qIgAQ7h8gABDoOww4CyAIQQRqIQYgCC0AAQ0LIARB/BhqIAYoAgQQ6iMgBEHYAGogASACKAIQEQAAIARBkBpqIAQoAlgiAiAEKAJcKAIMEQAAIAJFDQYgBCkDkBpC55nB0obRrM2zf4UgBCkDmBpC5ZLhj9uJra5ShYRQRQ0GIARBgB9qIAIoAhwgAigCICADEL0WIARB0ABqIAYQsC4gBCgCUCIBIAQoAlQiCkYNCgNAIARBkBpqIAIgAS0AABDZKEGIn4IBIAMQiQEgBCgCmBohByAEKAKUGiEFIAQoApAaIglBk4CAgHhHBEAgACAEKQKcGjcCDCAAIAc2AgggACAFNgIEIAAgCTYCACAEKAKAHyIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEGAH2oQ+x4LIARB/BhqIgAQwycgABDqOww5CyAEKAKEGSIJIAQoAvwYRgRAIARB/BhqQeCfggEQmygLIAQoAoAZIAlBA3RqIgsgBzYCBCALIAU2AgAgBCAJQQFqNgKEGSABQQhqIgEgCkcNAAsMCgsgASAHEQQAIgYtAABBIkYNCCAEIAY2ArgPIARBATYClBogBEHspoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQfSmggEQ7ywACyAEQZAaaiIGIAEgAhDHLxCPDiAEQbgPaiIFIAYQ/BUgBiAFIAMQugIgBC0AkBoiAkEpRg0GIARBlxVqIgMgBEGgGmopAAA3AAAgBEGQFWoiCCAEQZkaaikAADcDACAEQZAQaiAEQbAaaikCADcCACAEQZgQaiAEQbgaaikCADcCACAEQaAQaiAEQcAaaikCADcCACAEQfkPaiAIKQMANwAAIARBgBBqIAMpAAA3AAAgBCAEKQKoGjcCiBAgBCACOgDwDyAEIAQpAJEaNwDxDyAEQYgVaiICIARB8A9qEIQ+IAYgAhChGyACIAEgBxEEABDKBiAEQagQaiIBIAYgAhCMGCACIAEQzRwgBiACELgGIAYQ9ykhASAAQYSnggE2AgggACABNgIEIABBk4CAgHg2AgAgBRDJHgw1CyABIAcRBAAiBi0AAEEoRg0EIAQgBjYCuA8gBEEBNgKUGiAEQfyqggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpBhKuCARDvLAALQdCOggEQsjsAC0GAl4IBELI7AAtB+JuCARCyOwALQaCeggEQsjsMBQsCQAJAAkACQAJAAkAgBigCBCIGLQAwQQNrDgMBAgMACyAEIAZBMGo2ArgPIARBATYClBogBEGwqoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQbiqggEQ7ywACyAEQZAaaiENIAEgAhCcIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBA00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCERIA4oAhghEyAFQcwAaiABQQJ2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCSAFQdQDaiIUKAIAIgEoAgQiC08NTyAGKAIAIgMgC08NUEECIQgCQAJAAkACQCABKAIAIg8gCUECdGooAgAgDyADQQJ0aigCAEgiEkUEQCAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgkgC08NVyABKAIAIgEgC08NWCAPIAlBAnRqKAIAIA8gAUECdGooAgBIDQIgAyEBIAwgCEEBaiIIRw0ACwwCCyAMQQJGDQAgB0EEaiEBA0AgAUEEaiIDKAIAIgkgC08NViABKAIAIgEgC08NBCAPIAlBAnRqKAIAIA8gAUECdGooAgBODQEgAyEBIAwgCEEBaiIIRw0ACwwBCyAIIAxHDQELIBJFDQMgDEEBdiEDIAxBAnQgB2pBBGshCANAIAcoAgAhASAHIAgoAgA2AgAgCCABNgIAIAhBBGshCCAHQQRqIQcgA0EBayIDDQALDAMLIAcgDEEAIAxBAXJnQQF0QT5zIBQQ5goMAgsMUgsgDEECdCEBQQQhBwNAIAYgBiAHaiAFQdQDahC4FSABIAdBBGoiB0cNAAsLAkACQCAMRQ0AIAYgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NRCAFIBAgAUECdGooAgAiATYC3AQgASATSQRAQQAhCCARBEAgDkEMakEAEJIZIQoLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQX5xaiEHQQAhAQNAAn8gCkUEQCAIIAcgAyIGRw0BGgwFCyAKIAcgA2tBAXZPDQQgAyAKQQF0aiEGIAggCmoLIgxBAWohCCAGQQJqIQNBACEKIAEgAk8NACABQQJ0IQsgBi4BACARayEPA0AgASAFKAJUIgZPDUggBSgCUCALaigCACIGIAJPDUkgECAGQQJ0IhNqKAIAIA9PDQEgBiAFKALcAyIJTw1KIAUoAtgDIBNqIAw2AgAgC0EEaiELIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNSEHAAEHAABCtNiIBRQ1HIAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUhBwABBwAAQrTYiAUUNRyAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4IAUoAhgiCUECSQ0CQQEhB0EBIQMDQCAFKAIUIgIgA0ECdGoiASgCACABQQRrKAIAIgFHBEAgAUEASA0KIAUoAkQiC0EEaiIIIAUoAjwiBksEQCAFQThqIAZBAXQiBiAIENIqIgggBiAISxsQ6BkgBSgCRCILQQRqIQggBSgCPCEGCyAGIAhJBH8gBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQFIAsLIAUoAkBqIAE2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCADQYCAAk8NCyAFKAIsIgZBAmoiASAFKAIkIghLBEAgBUEgaiAIQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCCAFKAIsIgZBAmohAQsgASAISwR/IAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADOwAAIAUgBSgCLEECajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCUcNAAsgCUEBawwDCyABIAUoAlQiA08NRSACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEQLIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAlFDQJBASEHIAUoAhQhAkEAC0ECdCACaigCACIGQQBIDQIgBSgCRCICQQRqIgMgBSgCPCIBSwRAIAVBOGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAJEIgJBBGohAyAFKAI8IQELIAEgA0kEfyAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRAUgAgsgBSgCQGogBjYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAlBgIACTw0DIAUoAiwiAkECaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQJqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCTsAACAFIAUoAixBAmoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGDhowYNgIAIAVCg4aMmLDgwIEDNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ08IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIKKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgsgARDNHCAIQYSIkCA2AgAgBUKEiJCgwICBggQ3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgBzYCpAMgARCXKSAFQUBrIgIoAgAhCCAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAg2ApwCIAUgARDXOyAFKAIAIQhBHEEEEK02IgJFDTwgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAooAgA2AgAgBSAHNgLcAyAFIAg2AtgDIAUgAjYC1AMgASADIAkQ+iMgAyABEM0cIAVBkAFqIgEgAxCtEyADIA5BIGpBiJ+CASABQeSAggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhHBEAgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCALEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEJ8JIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAULQX9BAEGQr4IBEMMhAAtBoK+CARCyOwALQbCvggEQsjsAC0HAr4IBELI7AAtB0K+CARCyOwALIAQtAJAaIgFBKUYNAyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG4FmogBEGwGmopAgA3AgAgBEGhFmogAykDADcAACAEQagWaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCsBYgBCABOgCYFiAEIBc3AJkWIARBmBZqEPUpIQEgAEHcp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIARBkBpqIQ0gASACEJoiIQ4jAEHgBGsiBSQAAkACQAJAAkACQAJ/AkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEGIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgBiEHIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIgtPDUwgBigCACIDIAtPDU1BAiEIAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBIIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVQgASgCACIBIAtPDVUgDyAJQQJ0aigCACAPIAFBAnRqKAIASA0CIAMhASAMIAhBAWoiCEcNAAsMAgsgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIJIAtPDVMgASgCACIBIAtPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATg0BIAMhASAMIAhBAWoiCEcNAAsMAQsgCCAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOQKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuBUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQggEQRAIA5BDGpBABDfGSEKCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF8cWohB0EAIQEDQAJ/IApFBEAgCCAHIAMiBkcNARoMBQsgCiAHIANrQQJ2Tw0EIAMgCkECdGohBiAIIApqCyIMQQFqIQggBkEEaiEDQQAhCiABIAJPDQAgAUECdCELIAYoAgAgEWshDwNAIAEgBSgCVCIGTw1FIAUoAlAgC2ooAgAiBiACTw1GIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NRyAFKALYAyATaiAMNgIAIAtBBGohCyACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUVBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1FQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIglBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAFBAEgNCSAFKAJEIgtBBGoiCCAFKAI8IgZLBEAgBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQiC0EEaiEIIAUoAjwhBgsgBiAISQR/IAVBOGogBkEBdCIGIAgQ0ioiCCAGIAhLGxDoGSAFKAJEBSALCyAFKAJAaiABNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIISwRAIAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQggBSgCLCIGQQRqIQELIAEgCEsEfyAFQSBqIAhBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAlHDQALIAlBAWsMAwsgASAFKAJUIgNPDUIgAiAFKAJQIAFBAnRqKAIAIgFLBEAgBSAQIAFBAnRqKAIANgIgIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYCPCAFIAVBOGo2AoADIAUgBUEgajYCOCAFQaACaiAFQfgCahCZDiAFQdQDahDpOwwBCwxBCyAFQcwAahDpOyAFQZgBaiAFQagCaigCACIBNgIAIAUgBSkCoAIiFzcDkAEgBSgCrAIhAiANQRBqIAE2AgAgDSAXNwIIIA0gAjYCFCANQY2AgIB4NgIEIA1BKToAAAwCCyAJRQ0CQQEhByAFKAIUIQJBAAtBAnQgAmooAgAiBkEASA0CIAUoAkQiAkEEaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRCICQQRqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQFIAILIAUoAkBqIAY2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAk2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNOSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCigCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiILIAEQzRwgCEGEiJAgNgIAIAVChIiQoMCAgYIENwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAKKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQrRMgAyAOQSBqQYifggEgAUHkgIIBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgCxCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCeCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQaCvggEQsjsAC0HAr4IBELI7AAsgBC0AkBoiAUEpRg0BIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAWaiAEQbAaaikCADcCACAEQckWaiADKQMANwAAIARB0BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYFiAEIAE6AMAWIAQgFzcAwRYgBEHAFmoQ9SkhASAAQbSoggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGQGmohDSABIAIQmyIhDiMAQeAEayIFJAACQAJAAkACQAJAAkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEHIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgByEGIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIgtPDUogBigCACIDIAtPDUtBAiEIAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBIIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVIgASgCACIBIAtPDVMgDyAJQQJ0aigCACAPIAFBAnRqKAIASA0CIAMhASAMIAhBAWoiCEcNAAsMAgsgDEECRg0AIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVEgASgCACIBIAtPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATg0BIAMhASAMIAhBAWoiCEcNAAsMAQsgCCAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAZqQQRrIQgDQCAGKAIAIQEgBiAIKAIANgIAIAggATYCACAIQQRrIQggBkEEaiEGIANBAWsiAw0ACwwDCyAGIAxBACAMQQFyZ0EBdEE+cyAUEOkKDAILDE0LIAxBAnQhAUEEIQYDQCAHIAYgB2ogBUHUA2oQuBUgASAGQQRqIgZHDQALCwJAAkAgDEUNACAHIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDT8gBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQcgEQRAIA5BDGpBABDIGSEKCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF4cWohCEEAIQEDQAJ/IApFBEAgByAIIAMiBkcNARoMBQsgCiAIIANrQQN2Tw0EIAMgCkEDdGohBiAHIApqCyIMQQFqIQcgBkEIaiEDQQAhCiABIAJPDQAgAUECdCELIAYoAgAgEWshDwNAIAEgBSgCVCIGTw1DIAUoAlAgC2ooAgAiBiACTw1EIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NRSAFKALYAyATaiAMNgIAIAtBBGohCyACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQiAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUIgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOEEBIQogBSgCGCIIQQJPBEAgCK0hGEEAIQNCASEXA0AgBSgCFCADaiIBQQRqKAIAIAEoAgAiAUcEQCABQQBIDQkgBSgCRCIHQQRqIgYgBSgCPCICSwRAIAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEIgdBBGohBiAFKAI8IQILIAIgBkkEfyAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRAUgBwsgBSgCQGogATYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCAKQQFqIQoLIANBBGohAyAYIBdCAXwiF1INAAsLIAhBAWshASAIRQ0EIAUoAhQgAUECdGooAgAiAkEASA0FIAUoAkQiBkEEaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgMgASADSxsQ6BkgBSgCRCIGQQRqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiIDIAEgA0sbEOgZIAUoAkQFIAYLIAUoAkBqIAI2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBCGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiBkEIaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSAGCyAFQShqIgIoAgBqIAitNwAAIAUgBSgCLEEIaiIDNgIsIAUgBSgCMEEBajYCMCAFQaADaiIHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCjYCpAMgBUGcAmoiARCXKSACKAIAIQggAiAFQaQCaiIGKQIANwMAIAUpAyAhFyAFIAUpApwCNwMgIAVBADYCMCAFIBc3AqgCIAVBADYCpAIgBSADNgKgAiAFIAg2ApwCIAVBCGogARDXOyAFKAIIIQhBHEEEEK02IgJFDTsgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAVBrAJqIgkoAgA2AgAgBSADNgLcAyAFIAg2AtgDIAUgAjYC1AMgASAFQfgCaiIDIAVB1ANqIggQ+iMgBUHMAGoiCyABEM0cIAdBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAKNgKkAyABEJcpIAVBQGsiAigCACEKIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCjYCnAIgBSABENc7IAUoAgAhCkEcQQQQrTYiAkUNOyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCSgCADYCACAFIAc2AtwDIAUgCjYC2AMgBSACNgLUAyABIAMgCBD6IyADIAEQzRwgBUGQAWoiASADEK0TIAMgDkEgakGIn4IBIAFB5ICCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEYNAiANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAsQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAwsgASAFKAJUIgNPDUAgAiAFKAJQIAFBAnRqKAIAIgFLBEAgBSAQIAFBAnRqKAIANgIgIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYCPCAFIAVBOGo2AoADIAUgBUEgajYCOCAFQaACaiAFQfgCahCZDiAFQdQDahDpOwwBCww/CyAFQcwAahDpOyAFQZgBaiAFQagCaigCACIBNgIAIAUgBSkCoAIiFzcDkAEgBSgCrAIhAiANQRBqIAE2AgAgDSAXNwIIIA0gAjYCFCANQY2AgIB4NgIEIA1BKToAAAwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCgCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDCyABQQBBkK+CARDDIQALQaCvggEQsjsAC0HAr4IBELI7AAsgBC0AkBoiAUEpRwRAIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYgXaiAEQbAaaikCADcCACAEQfEWaiADKQMANwAAIARB+BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKAFyAEIAE6AOgWIAQgFzcA6RYgBEHoFmoQ9SkhASAAQYypggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMLwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAgBEG4D2oQyR4MLgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIEIgYtAABBAmsOCAECAwQFBgcIAAsgBCAGNgK4DyAEQQE2ApQaIARBnKaCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGkpoIBEO8sAAsgBEGQGmohBiABIAIQxCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ3xYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0NIARBiBVqIgIgBkHEAPwKAAAgBEHXEWogBEHXGmotAAA6AAAgBCAELwDVGjsA1REgBEGQEWoiAyACQcQA/AoAACAEIAE6ANQRIAMQ6ykhASAAQZCgggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGQGmohBiABIAIQwSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0LIARBiBVqIgIgBkHEAPwKAAAgBEGfEmogBEHXGmotAAA6AAAgBCAELwDVGjsAnRIgBEHYEWoiAyACQcQA/AoAACAEIAE6AJwSIAMQ6ykhASAAQeigggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBiABIAIQwCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0JIARBiBVqIgIgBkHEAPwKAAAgBEHnEmogBEHXGmotAAA6AAAgBCAELwDVGjsA5RIgBEGgEmoiAyACQcQA/AoAACAEIAE6AOQSIAMQ6ykhASAAQcChggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmohBiABIAIQwyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0HIARBiBVqIgIgBkHEAPwKAAAgBEGvE2ogBEHXGmotAAA6AAAgBCAELwDVGjsArRMgBEHoEmoiAyACQcQA/AoAACAEIAE6AKwTIAMQ6ykhASAAQZiiggE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgBEGQGmohBiABIAIQwiIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4BYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0FIARBiBVqIgIgBkHEAPwKAAAgBEH3E2ogBEHXGmotAAA6AAAgBCAELwDVGjsA9RMgBEGwE2oiAyACQcQA/AoAACAEIAE6APQTIAMQ6ykhASAAQfCiggE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgBEGQGmohBiABIAIQvyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0DIARBiBVqIgIgBkHEAPwKAAAgBEG/FGogBEHXGmotAAA6AAAgBCAELwDVGjsAvRQgBEH4E2oiAyACQcQA/AoAACAEIAE6ALwUIAMQ6ykhASAAQcijggE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgBEGQGmohBiABIAIQviIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0BIARBiBVqIgIgBkHEAPwKAAAgBEGHFWogBEHXGmotAAA6AAAgBCAELwDVGjsAhRUgBEHAFGoiAyACQcQA/AoAACAEIAE6AIQVIAMQ6ykhASAAQaCkggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGQGmohBiABIAIQvSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRwRAIARBiBVqIgIgBkHEAPwKAAAgBEGXFmogBEHXGmotAAA6AAAgBCAELwDVGjsAlRYgBEHQFWoiAyACQcQA/AoAACAEIAE6AJQWIAMQ6ykhASAAQfikggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMNAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLQsgBigCACIBIAEoAgAiAkEBajYCACACQQBIDQEgCCgCCCECIARBwB5qIARBiB9qKAIANgIAIAQgBCkCgB83A7geIARBADYCuBkgBEHAD2ogBEGEGWooAgA2AgAgBCAEKQL8GDcDuA8gBEGQGmogASACIARBuB5qIARBuBlqIARBuA9qEJEEIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4RgRAIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwtCyAEQbAZaiAEQbgaaikCADcCACAEQagZaiAEQbAaaikCADcCACAEQZQZaiABKQMANwIAIARBnBlqIAIoAgA2AgAgBCAEKQKoGjcCoBkgBCADNgKIGSAEIAQpA4gVNwKMGSAEQYgZahDcKSEBIABBsJ6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAwsCyAEQcgAaiABIAIoAhARAAAgBEGQGmoiAiAEKAJIIgEgBCgCTCgCDBEAAAJAAkAgAUUNACAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQAgBEGIFWoiByABKAIcIAEoAiAgAxC9FiAEQQA2AugZIARBoBpqIARB+BlqKQIANwMAIARBmBpqIARB8BlqKQIANwMAIAQgBCkC6Bk3A5AaIARBuBlqIgUgByACENgdIAEQkzYiCUUNASACIAkoAgQgCSgCCEECdiADELsWIARBuA9qIgMgAiAEQegZahC/HSAEQUBrIAYQsC4gBCkDQCEXIAQgATYCoBogBCAXNwKQGiAEIAM2ApwaIAQgBTYCmBogByACELsVIARBwB5qIgEgBEGUFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiAkGTgICAeEcEQCAEKAKYFSEGIAAgBCkDuB43AgQgACAGNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAgAxD+JCAFEP4kDC4LIARBiBpqIARBwB5qKAIANgIAIAQgBCkDuB43A4AaIARBkBpqIgFBAEGABPwLACAEIAQoAsgZIgI2AogVIAQgAiAEQcwZaiIDKAIAajYCjBUgBCABNgKQFSAEQZweaiAEQYgVaiIBELwsIARBsB5qIAMoAgAiAjYCACAEQZwVaiACNgIAIARBqBVqIARB2BlqKQIANwMAIARBsBVqIARB4BlqKQIANwMAIARBkBVqIARBwBlqKAIANgIAIAQgBCkCxBkiFzcDqB4gBCAXNwKUFSAEIAQpAtAZNwOgFSAEIAQpArgZNwOIFSABELQMAkAgBCgCoBUiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEGgFWoQ+x4LIAYoAgAiASABKAIAIgJBAWo2AgAgAkEASA0CIAgoAgghAiAEQYgfaiAEQaQeaigCADYCACAEIAQpApweNwOAHyAEQYgVaiABIAIgBEGoHmogBEGAH2ogBEGAGmoQkQQgBEHAHmoiASAEQZQVaikCADcDACAEQcgeaiICIARBnBVqKAIANgIAIAQgBCkCjBU3A7geIAQoAogVIgNBgICAgHhGBEAgACAEKQO4HjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIARBuA9qEP4kDC4LIARB+B5qIARBsBVqKQIANwIAIARB8B5qIARBqBVqKQIANwIAIARB3B5qIAEpAwA3AgAgBEHkHmogAigCADYCACAEIAQpAqAVNwLoHiAEIAM2AtAeIAQgBCkDuB43AtQeIARB0B5qENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qEP4kDC0LQfCfggEQsjsAC0GAoIIBELI7AAsACyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwpCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwoCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJQsgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADCQLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCMLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCILIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCELIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB8LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB4LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB0LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBwLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBsLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBoLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBgLIARBCGpBxI6CASADEKErIAAgBCkDCDcCBCAAQZOAgIB4NgIADBcLIAQgCDYCuA8gBEEBNgKUGiAEQcirggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB0KuCARDvLAALIARBkwZqIAEoAAAiATYAACAEQYsGaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAgwYgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMFQsgBEHjBWogASgAACIBNgAAIARB2wVqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDTBSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwUCyAEQbMFaiABKAAAIgE2AAAgBEGrBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AKMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBMLIARBgwVqIAEoAAAiATYAACAEQfsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA8wQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCwsgBEHTBGogASgAACIBNgAAIARBywRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDDBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwKCyAEQaMEaiABKAAAIgE2AAAgBEGbBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AJMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAkLIARB8wNqIAEoAAAiATYAACAEQesDaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA4wMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCAsgBEHDA2ogBEGkGmooAgAiATYAACAEQbsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAswMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBwsgBEGTA2ogBEGkGmooAgAiATYAACAEQYsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAgwMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBgsgBEHjAmogBEGkGmooAgAiATYAACAEQdsCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA0wIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBQsgBEGzAmogBEGkGmooAgAiATYAACAEQasCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAowIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBAsgBEGDAmogBEGkGmooAgAiATYAACAEQfsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA8wEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAwsgBEHTAWogBEGkGmooAgAiATYAACAEQcsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAwwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAgsgBEGjAWogBEGkGmooAgAiATYAACAEQZsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAkwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAQsgBEHzAGogBEGkGmooAgAiATYAACAEQesAaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAYyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAsgBEGQH2okAA8LQQRBOBCjPQALQQRBHBCjPQALIAEgAkG48YEBEMMhAAsgASAGQezygQEQwyEACyAGIAJB/PKBARDDIQALIAYgCUGM84EBEMMhAAsgASACQejxgQEQwyEACyABIANB2PGBARDDIQALQcAAQcAAEKM9AAtBwPSBAUEpIAVB+AJqQcz8gQFB7PSBARDVHgALIAIgCSgCHEG8/IEBEP0vAAsgBiAJKAIcQbz8gQEQ/S8AC0HAACABEKM9AAsgCSALQfD2gwEQwyEACyADIAtBgPeDARDDIQALIAkgC0Hw9oMBEMMhAAsgASALQYD3gwEQwyEAC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyABQQE2AhQgAUHctoIBNgIQIAFCATcCHCABQe0GNgIsIAEgAUEoajYCGCABIAFBDGo2AiggAUEQakHktoIBEO8sAAuIyAIEE38EfgF9AXwjAEGQH2siBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEgAigCHCIHEQQAIgYtAABBAmsOJQMEBQYHCAkKCwwNAAAAAAABAgAAAAAAAAAAAAAAAAAAABUWFxgACyABIAcRBAAiBi0AAA4pHhhVVVVVVVVVVVVVVRkjJBobVVUpHCssLS4vMFUdMlUzNDVVVVVVNjdVCyAGLQABQQFrDgMNDg8MCyAGLQABQQFrDgIQEQ8LIARBkBpqIAEgAhC7IiADEOUWIAQtAJAaIgJBKUYNaCAEQe8AaiIDIARBoBpqKQAANwAAIARB6ABqIgYgBEGZGmopAAA3AwAgBEGAAWoiByAEQbAaaikCADcDACAEQYgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A2AgBCAEKQKoGjcDeEE4QQQQrTYiAUUNaiABIAI6AAggAUKBgICAEDcCACABIAQpA2A3AAkgASAEKQN4NwIgIABBtP+BATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaQsgBEGQGmogASACEKgiIAMQpxYgBC0AkBoiAkEpRg1mIARBnwFqIgMgBEGgGmopAAA3AAAgBEGYAWoiBiAEQZkaaikAADcDACAEQbABaiIHIARBsBpqKQIANwMAIARBuAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDkAEgBCAEKQKoGjcDqAFBOEEEEK02IgFFDWkgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQATcACSABIAQpA6gBNwIgIABBjICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaAsgBEGQGmogASACELEiIAMQqBYgBC0AkBoiAkEpRg1kIARBzwFqIgMgBEGgGmopAAA3AAAgBEHIAWoiBiAEQZkaaikAADcDACAEQeABaiIHIARBsBpqKQIANwMAIARB6AFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDwAEgBCAEKQKoGjcD2AFBOEEEEK02IgFFDWggASACOgAIIAFCgYCAgBA3AgAgASAEKQPAATcACSABIAQpA9gBNwIgIABB5ICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZwsgBEGQGmogASACEKQiIAMQqRYgBC0AkBoiAkEpRg1iIARB/wFqIgMgBEGgGmopAAA3AAAgBEH4AWoiBiAEQZkaaikAADcDACAEQZACaiIHIARBsBpqKQIANwMAIARBmAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD8AEgBCAEKQKoGjcDiAJBOEEEEK02IgFFDWcgASACOgAIIAFCgYCAgBA3AgAgASAEKQPwATcACSABIAQpA4gCNwIgIABBvIGCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZgsgBEGQGmogASACEKoiIAMQ5hYgBC0AkBoiAkEpRg1gIARBrwJqIgMgBEGgGmopAAA3AAAgBEGoAmoiBiAEQZkaaikAADcDACAEQcACaiIHIARBsBpqKQIANwMAIARByAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDoAIgBCAEKQKoGjcDuAJBOEEEEK02IgFFDWYgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgAjcACSABIAQpA7gCNwIgIABBlIKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZQsgBEGQGmogASACEK0iIAMQqhYgBC0AkBoiAkEpRg1eIARB3wJqIgMgBEGgGmopAAA3AAAgBEHYAmoiBiAEQZkaaikAADcDACAEQfACaiIHIARBsBpqKQIANwMAIARB+AJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD0AIgBCAEKQKoGjcD6AJBOEEEEK02IgFFDWUgASACOgAIIAFCgYCAgBA3AgAgASAEKQPQAjcACSABIAQpA+gCNwIgIABB7IKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZAsgBEGQGmogASACELciIAMQqxYgBC0AkBoiAkEpRg1cIARBjwNqIgMgBEGgGmopAAA3AAAgBEGIA2oiBiAEQZkaaikAADcDACAEQaADaiIHIARBsBpqKQIANwMAIARBqANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDgAMgBCAEKQKoGjcDmANBOEEEEK02IgFFDWQgASACOgAIIAFCgYCAgBA3AgAgASAEKQOAAzcACSABIAQpA5gDNwIgIABBxIOCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYwsgBEGQGmogASACEKIiIAMQrBYgBC0AkBoiAkEpRg1aIARBvwNqIgMgBEGgGmopAAA3AAAgBEG4A2oiBiAEQZkaaikAADcDACAEQdADaiIHIARBsBpqKQIANwMAIARB2ANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDsAMgBCAEKQKoGjcDyANBOEEEEK02IgFFDWMgASACOgAIIAFCgYCAgBA3AgAgASAEKQOwAzcACSABIAQpA8gDNwIgIABBnISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYgsgBEGAH2oiBiABIAIQuSIiASgCECABKAIUQQF2IAMQxhYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQzx0gBEG4HmoiAiABEMoGIAIQmB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNWCAEQe8DaiIDIARBxxlqKQAANwAAIARB6ANqIgUgBEHAGWopAwA3AwAgBEGABGoiCCAGKQMANwMAIARBiARqIgYgBykDADcDACAEIAQpA7gZNwPgAyAEIAQpA7gPNwP4A0E4QQQQrTYiAUUNYiABIAI6AAggAUKBgICAEDcCACABIAQpA+ADNwAJIAEgBCkD+AM3AiAgAEH0hIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxhCyAEQYAfaiEOIAEgAhC1IiIKKAIQIQIgCigCFEECdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF4cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCAIKAIYIQIgCCgCFEEBRg1tIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayIHJAAgCEEIaiICIAUoAgQgBSgCAGtBA3YQ7i0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiINKAIEIQsgDSgCACESAkAgB0EIaiIFKAIAIgkgBSgCBCIPRwRAIAUoAhQhDCAFKAIQIRMgBSgCDCEUIAUoAgghBSANKAIIIAtBAnRqIQ0gDyAJa0EDdiEPA0AgAiAJNgIMAkAgCSgCACIRIBNJBEAgFCARQQJ0aioCACEbDAELIAUgDCgCEE8Nd0MAAAAAIRsgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXgLIA0gGzgCACAJQQhqIQkgDUEEaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCNGwsgDiAGEOgYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARC+HSAEQbgeaiIBIAoQygYgARCTHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1WIARBnwRqIgMgBEHHGWopAAA3AAAgBEGYBGoiBSAEQcAZaikDADcDACAEQbAEaiIIIAYpAwA3AwAgBEG4BGoiBiAHKQMANwMAIAQgBCkDuBk3A5AEIAQgBCkDuA83A6gEQThBBBCtNiIBRQ1hIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAQ3AAkgASAEKQOoBDcCICAAQcyFggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGALIARBgB9qIQ4gASACEKYiIgooAhAhAiAKKAIUQQN2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBCEEIEKAYIAgoAhghAiAIKAIUQQFGDWwgCEEQaiIQQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDsLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg0oAgQhCyANKAIAIRICQCAHQQhqIgUoAgAiCSAFKAIEIg9HBEAgBSgCFCEMIAUoAhAhEyAFKAIMIRQgBSgCCCEFIA0oAgggC0EDdGohDSAPIAlrQQN2IQ8DQCACIAk2AgwCQCAJKAIAIhEgE0kEQCAUIBFBA3RqKwMAIRwMAQsgBSAMKAIQTw12RAAAAAAAAAAAIRwgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXcLIA0gHDkDACAJQQhqIQkgDUEIaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahD7GgsgDiAGEOcYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARDbHSAEQbgeaiIBIAoQygYgARCQHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1UIARBzwRqIgMgBEHHGWopAAA3AAAgBEHIBGoiBSAEQcAZaikDADcDACAEQeAEaiIIIAYpAwA3AwAgBEHoBGoiBiAHKQMANwMAIAQgBCkDuBk3A8AEIAQgBCkDuA83A9gEQThBBBCtNiIBRQ1gIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAQ3AAkgASAEKQPYBDcCICAAQaSGggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADF8LIAEgAhCzIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC8HSABQdQAaiIGIAIQygYgBhDyHCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHgB2ogBEGwGmopAgA3AgAgBEHoB2ogBEG4GmopAgA3AgAgBEHJB2ogAykDADcAACAEQdAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC2AcgBCABOgDAByAEIBc3AMEHIARBwAdqENwpIQEgAEH8hoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADF4LIAEgAhChIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDAHSABQdQAaiIGIAIQygYgBhD1HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGQCGogBEGwGmopAgA3AgAgBEGYCGogBEG4GmopAgA3AgAgBEH5B2ogAykDADcAACAEQYAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCiAggBCABOgDwByAEIBc3APEHIARB8AdqENwpIQEgAEHUh4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADF0LIAEgAhCdIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDDHSABQdQAaiIGIAIQygYgBhD6HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHACGogBEGwGmopAgA3AgAgBEHICGogBEG4GmopAgA3AgAgBEGpCGogAykDADcAACAEQbAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCuAggBCABOgCgCCAEIBc3AKEIIARBoAhqENwpIQEgAEGsiIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFwLIAEgAhCuIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDQHSABQdQAaiIGIAIQygYgBhD5HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHwCGogBEGwGmopAgA3AgAgBEH4CGogBEG4GmopAgA3AgAgBEHZCGogAykDADcAACAEQeAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC6AggBCABOgDQCCAEIBc3ANEIIARB0AhqENwpIQEgAEGEiYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFsLIAEgAhC4IiECIwBB4ABrIgEkACABIAIoAhAgAigCFEECdiADEMcWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC9HSABQdQAaiIGIAIQygYgBhD0HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNSiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHQBmogBEGwGmopAgA3AgAgBEHYBmogBEG4GmopAgA3AgAgBEG5BmogAykDADcAACAEQcAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCyAYgBCABOgCwBiAEIBc3ALEGIARBsAZqENwpIQEgAEHciYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFoLIAEgAhCjIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEDdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQRBCBCgGCAIKAIYIQYgCCgCFEEBRg1nIAhBEGoiE0EANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6i0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACEUAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIREgCSgCDCEVIAkoAgghCSANKAIIIAxBA3RqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIQIBFJBEAgFSAQQQN0aiISKAIEIRAgEigCACESDAELIAkgDigCEE8NcEEAIRBBACESIA4oAgQgCSAOKAIMaiIWQQN2ai0AACAWQQdxdkEBcQ1yCyANIBI2AgAgDUEEaiAQNgIAIAtBCGohCyANQQhqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBQgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogEygCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEJUbCyAFIAcQ6xggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDTHSAFQdQAaiIBIAoQygYgARD3HCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNSCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGAB2ogBEGwGmopAgA3AgAgBEGIB2ogBEG4GmopAgA3AgAgBEHpBmogAykDADcAACAEQfAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC+AYgBCABOgDgBiAEIBc3AOEGIARB4AZqENwpIQEgAEG0ioIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFkLIAEgAhCgIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEEdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQhBEBCgGCAIKAIYIQYgCCgCFEEBRg1mIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6S0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACESAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIRMgCSgCDCEUIAkoAgghCSANKAIIIAxBBHRqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIRIBNJBEAgAUEYaiAUIBFBBHRqIhFBCGopAwA3AwAgASARKQMANwMQDAELIAkgDigCEE8NbyAOKAIEIAkgDigCDGoiEUEDdmotAAAgEUEHcXZBAXENcSABQRhqQgA3AwAgAUIANwMQCyANIAEpAxA3AwAgDUEIaiABQRhqKQMANwMAIAtBCGohCyANQRBqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBIgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogECgCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEP4aCyAFIAcQ6hggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDFHSAFQdQAaiIBIAoQygYgARDxHCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNRiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGwB2ogBEGwGmopAgA3AgAgBEG4B2ogBEG4GmopAgA3AgAgBEGZB2ogAykDADcAACAEQaAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCqAcgBCABOgCQByAEIBc3AJEHIARBkAdqENwpIQEgAEGMi4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADFgLIARBgB9qIgYgASACEKciIgEoAhAgASgCFEECdiADEMcWIARBiBVqIgIgARCSNiADEPMSIARBkBpqIgMgBiACEModIARBuB5qIgIgARDKBiACENAYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUQgBEH/BGoiAyAEQccZaikAADcAACAEQfgEaiIFIARBwBlqKQMANwMAIARBkAVqIgggBikDADcDACAEQZgFaiIGIAcpAwA3AwAgBCAEKQO4GTcD8AQgBCAEKQO4DzcDiAVBOEEEEK02IgFFDVggASACOgAIIAFCgYCAgBA3AgAgASAEKQPwBDcACSABIAQpA4gFNwIgIABB5IuCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVwsgBEGAH2oiBiABIAIQqyIiASgCECABKAIUQQN2IAMQyBYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQxh0gBEG4HmoiAiABEMoGIAIQ0hggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQiAEQa8FaiIDIARBxxlqKQAANwAAIARBqAVqIgUgBEHAGWopAwA3AwAgBEHABWoiCCAGKQMANwMAIARByAVqIgYgBykDADcDACAEIAQpA7gZNwOgBSAEIAQpA7gPNwO4BUE4QQQQrTYiAUUNVyABIAI6AAggAUKBgICAEDcCACABIAQpA6AFNwAJIAEgBCkDuAU3AiAgAEG8jIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxWCyAEQYAfaiEJIAEgAhC8IiIFKAIQIQIgBSgCFEEEdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCELIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAggC0F4cWo2AhAgASAINgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBygCBCAHKAIAa0EDdkEAQRBBEBCgGCAIKAIYIQIgCCgCFEEBRg1iIAhBEGoiCkEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayICJAAgCEEIaiILIAcoAgQgBygCAGtBA3YQ6y0gCykCBCEXIAJBGGogB0EQaikCADcDACACQRBqIAdBCGopAgA3AwAgAiAHKQIANwMIIAIgF0IgiTcCKCACIAtBCGo2AiQgAkEIaiACQSRqEKwQIAJBMGokACAGQQhqIAooAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEIIAEgBjYCGCABIAI2AhQgASAHIAhBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCJGwsgCSAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDzEiAEQZAaaiIDIAkgARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAgoAhghAiAIKAIUQQFGDWEgCEEQaiISQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCyAOKAIAIRMCQCAHQQhqIgUoAgAiCSAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIREgBSgCCCEKIA4oAgggC0EFdGohBSAQIAlrQQN2IRADQCACIAk2AgwCQCAJKAIAIg4gFEkEQCARIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyAKIA0oAhBPDWtCACEaQgAhGUIAIRhCACEXIA0oAgQgCiANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1sCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCUEIaiEJIAVBIGohBSAKQQFqIQogC0EBaiELIBBBAWsiEA0ACwsgEyALNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiASKAIANgIAIAYgCCkCCDcCACAIQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXhxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhRsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8xIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9iggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAGLQABQQFrDgMGBwgFCyAGLQABDgIKCzoLIAYtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiAiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCACIAEgAyAGKAIEENQVIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiICIAQoAigiASAEKAIsKAIMEQAAIAFFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCACIAEgAyAGKAIEEOkCIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENg8IAMQ2DwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjwIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJ4CIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMwWIAdBDGogARCTNiADEPMSIAEoAgQhCSAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAJKAIAIgggCCgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAkpAgQ3AgAgAiAINgIAIAJBDGohAiALQQxrIQsgCUEMaiEJIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQkAIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCfAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDMFiAHQQxqIAEQkzYgAxDzEiABKAIEIQkgB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCSgCACIIIAgoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAJKQIENwIAIAIgCDYCACACQQxqIQIgC0EMayELIAlBDGohCSAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADELgCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmogASACEJEiIAMQuQIgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQkjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQsjAEEwayIBJAAgAUEIaiACQSBqIgcQhSgCQAJAAkAgASgCCCIKBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIIIA02AgQgCCAKNgIAIAFBHGoiD0EBNgIAIAEgCDYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQhSggBSgCCCIIBEAgAUEUaiEKIAUoAgwhBwNAIAooAggiDSAKKAIARgRAIApBARDqLQsgCigCBCANQQN0aiIQIAc2AgQgECAINgIAIAogDUEBajYCCCAFIAwQhSggBSgCBCEHIAUoAgAiCA0ACwsgBUEQaiQAIAtBCGogDygCADYCACALIAEpAhQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCSACKQIANwIAIAlBEGogAkEQaigCADYCACAJQQhqIAJBCGopAgA3AgAgCxDDJyALEOo7DAELIAkgAikCFDcCBCAJQZOAgIB4NgIAIAlBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIBEP8YIAEgAxC+LSAEIA42ArQaIARBhBFqIAEQ8BggBCgCwA8EQCAEQZAVaiAEQcAPaigCADYCACAEQZwVaiAEQYwRaigCADYCACAEIAQpArgPNwOIFSAEIAQpAoQRNwKUFSABIARBiBVqEK0QIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmoiASAEQYQRakEAIANBDGoiAhDYPBDyFSAEQYgVaiIDIAEQ4ScgASACENg8IAMQ1RggARDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCACAEQbgPaiIAEO4fIAAQ6DsMOAsgBkEEaiEHIAYtAAENCyAEQfwYaiAHKAIEEOojIARB2ABqIAEgAigCEBEAACAEQZAaaiAEKAJYIgIgBCgCXCgCDBEAACACRQ0GIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNBiAEQYAfaiACKAIcIAIoAiAgAxDJFiAEQdAAaiAHELAuIAQoAlAiASAEKAJUIgtGDQoDQCAEQZAaaiACIAEtAAAQ2ShBiJ+CASADEIoBIAQoApgaIQUgBCgClBohCCAEKAKQGiIJQZOAgIB4RwRAIAAgBCkCnBo3AgwgACAFNgIIIAAgCDYCBCAAIAk2AgAgBCgCgB8iACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBgB9qEPseCyAEQfwYaiIAEMMnIAAQ6jsMOQsgBCgChBkiCSAEKAL8GEYEQCAEQfwYakHgn4IBEJsoCyAEKAKAGSAJQQN0aiIKIAU2AgQgCiAINgIAIAQgCUEBajYChBkgAUEIaiIBIAtHDQALDAoLIAEgBxEEACIGLQAAQSJGDQggBCAGNgK4DyAEQQE2ApQaIARB7KaCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakH0poIBEO8sAAsgBEGQGmoiBiABIAIQxy8Qjw4gBEG4D2oiBSAGEPwVIAYgBSADELgCIAQtAJAaIgJBKUYNBiAEQZcVaiIDIARBoBpqKQAANwAAIARBkBVqIgggBEGZGmopAAA3AwAgBEGQEGogBEGwGmopAgA3AgAgBEGYEGogBEG4GmopAgA3AgAgBEGgEGogBEHAGmopAgA3AgAgBEH5D2ogCCkDADcAACAEQYAQaiADKQAANwAAIAQgBCkCqBo3AogQIAQgAjoA8A8gBCAEKQCRGjcA8Q8gBEGIFWoiAiAEQfAPahCEPiAGIAIQoRsgAiABIAcRBAAQygYgBEGoEGoiASAGIAIQjBggAiABEM0cIAYgAhC4BiAGEPcpIQEgAEGEp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAUQyR4MNQsgASAHEQQAIgYtAABBKEYNBCAEIAY2ArgPIARBATYClBogBEH8qoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQYSrggEQ7ywAC0HQjoIBELI7AAtBgJeCARCyOwALQfibggEQsjsAC0GgnoIBELI7DAULAkACQAJAAkACQAJAIAYoAgQiBi0AMEEDaw4DAQIDAAsgBCAGQTBqNgK4DyAEQQE2ApQaIARBsKqCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakG4qoIBEO8sAAsgBEGQGmohDSABIAIQnCIhDiMAQeAEayIFJAACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NTCAGKAIAIgMgCk8NTQJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAUyIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NVCABKAIAIgEgCk8NVSAPIAhBA3RqKQMAIA8gAUEDdGopAwBTDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVMgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWQ0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOgKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQtxUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAXZPDQQgAyALQQF0aiEGIAkgC2oLIgxBAWohCSAGQQJqIQNBACELIAEgAk8NACABQQJ0IQogBi4BACASayEPA0AgASAFKAJUIgZPDUUgBSgCUCAKaigCACIGIAJPDUYgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRyAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggA0GAgAJPDQkgBSgCLCIGQQJqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQJqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzsAACAFIAUoAixBAmo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEELIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAIQYCAAk8NAiAFKAIsIgJBAmoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkECaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg7AAAgBSAFKAIsQQJqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBg4aMGDYCACAFQoOGjJiw4MCBAzcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ1BIAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiALKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQsRMgAyAOQSBqQYifggEgAUG8gYIBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgChCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCfCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQbCvggEQsjsAC0HQr4IBELI7AAsgBC0AkBoiAUEpRg0DIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbgWaiAEQbAaaikCADcCACAEQaEWaiADKQMANwAAIARBqBZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKwFiAEIAE6AJgWIAQgFzcAmRYgBEGYFmoQ9SkhASAAQdynggE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgBEGQGmohDSABIAIQmiIhDiMAQeAEayIFJAACQAJAAkACfwJAAkACQAJAIAMoAhQiAUEHTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIRIgDigCGCETIAVBzABqIAFBA3YiAkG8/IEBEKQaIAUoAlAhBiAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAYhByABDQEgBigCBCIIIAVB1ANqIhQoAgAiASgCBCIKTw1JIAYoAgAiAyAKTw1KAkACQAJAAkAgASgCACIPIAhBA3RqKQMAIA8gA0EDdGopAwBTIhFFBEBBAiEJIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCCAKTw1RIAEoAgAiASAKTw1SIA8gCEEDdGopAwAgDyABQQN0aikDAFMNAiADIQEgDCAJQQFqIglHDQALDAILQQIhCSAMQQJGDQAgB0EEaiEBA0AgAUEEaiIDKAIAIgggCk8NUCABKAIAIgEgCk8NBCAPIAhBA3RqKQMAIA8gAUEDdGopAwBZDQEgAyEBIAwgCUEBaiIJRw0ACwwBCyAJIAxHDQELIBFFDQMgDEEBdiEDIAxBAnQgB2pBBGshCANAIAcoAgAhASAHIAgoAgA2AgAgCCABNgIAIAhBBGshCCAHQQRqIQcgA0EBayIDDQALDAMLIAcgDEEAIAxBAXJnQQF0QT5zIBQQ6woMAgsMTAsgDEECdCEBQQQhBwNAIAYgBiAHaiAFQdQDahC3FSABIAdBBGoiB0cNAAsLAkACQCAMRQ0AIAYgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NPiAFIBAgAUEDdGooAgAiATYC3AQgASATSQRAQQAhCSASBEAgDkEMakEAEN8ZIQsLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQXxxaiEIQQAhAQNAAn8gC0UEQCADIQYgCSADIAhHDQEaDAULIAsgCCADa0ECdk8NBCADIAtBAnRqIQYgCSALagsiDEEBaiEJIAZBBGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBJrIQ8DQCABIAUoAlQiBk8NQiAFKAJQIApqKAIAIgYgAk8NQyAPIBAgBkEDdGooAgBNDQEgBiAFKALcAyIHTw1EIAUoAtgDIAZBAnRqIAw2AgAgCkEEaiEKIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNQ0HAAEHAABCtNiIBRQ1BIAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQSAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4IAUoAhgiCEECSQ0CQQEhB0EBIQMDQCAFKAIUIgIgA0ECdGoiASgCACABQQRrKAIAIgFHBEAgBSgCRCIKQQhqIgkgBSgCPCIGSwRAIAVBOGogBkEBdCIGIAkQ0ioiCSAGIAlLGxDoGSAFKAJEIgpBCGohCSAFKAI8IQYLIAYgCUkEfyAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRAUgCgsgBSgCQGogAa03AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBBGoiASAFKAIkIglLBEAgBUEgaiAJQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCSAFKAIsIgZBBGohAQsgASAJSwR/IAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADNgAAIAUgBSgCLEEEajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCEcNAAsgCEEBayEJIAUoAkQhASAFKAI8DAMLIAEgBSgCVCIDTw0/IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPgsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAgsgCEUNAkEBIQdBACEBIAUoAhQhAkEAIQlBwAALIQMgAiAJQQJ0ajUCACEXIAMgAUEIaiICSQRAIAVBOGogA0EBdCIBIAIQ0ioiAiABIAJLGxDoGSAFKAI8IQMgBSgCRCIBQQhqIQILIAIgA0sEfyAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCRAUgAQsgBSgCQGogFzcAACAFIAUoAkRBCGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEEaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQRqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCDYAACAFIAUoAixBBGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGEiJAgNgIAIAVChIiQoMCAgYIENwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ0+IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiILKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgogARDNHCAIQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgBzYCpAMgARCXKSAFQUBrIgIoAgAhCCAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAg2ApwCIAUgARDXOyAFKAIAIQhBHEEEEK02IgJFDT4gAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAsoAgA2AgAgBSAHNgLcAyAFIAg2AtgDIAUgAjYC1AMgASADIAkQ+iMgAyABEM0cIAVBkAFqIgEgAxCxEyADIA5BIGpBiJ+CASABQbyBggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhHBEAgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEJ4JIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAELQX9BAEGQr4IBEMMhAAsgBC0AkBoiAUEpRg0BIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAWaiAEQbAaaikCADcCACAEQckWaiADKQMANwAAIARB0BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYFiAEIAE6AMAWIAQgFzcAwRYgBEHAFmoQ9SkhASAAQbSoggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGQGmohDSABIAIQmyIhDiMAQeAEayIFJAACQAJAAkACQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQcgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAHIQYgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NRyAGKAIAIgMgCk8NSAJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAUyIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NTyABKAIAIgEgCk8NUCAPIAhBA3RqKQMAIA8gAUEDdGopAwBTDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAZBBGohAQNAIAFBBGoiAygCACIIIApPDU4gASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWQ0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAZqQQRrIQgDQCAGKAIAIQEgBiAIKAIANgIAIAggATYCACAIQQRrIQggBkEEaiEGIANBAWsiAw0ACwwDCyAGIAxBACAMQQFyZ0EBdEE+cyAUEOUKDAILDEoLIAxBAnQhAUEEIQYDQCAHIAYgB2ogBUHUA2oQtxUgASAGQQRqIgZHDQALCwJAAkAgDEUNACAHIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDTwgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQggEgRAIA5BDGpBABDIGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF4cWohCUEAIQEDQAJ/IAtFBEAgAyEGIAggAyAJRw0BGgwFCyALIAkgA2tBA3ZPDQQgAyALQQN0aiEGIAggC2oLIgxBAWohCCAGQQhqIQNBACELIAEgAk8NACABQQJ0IQogBigCACASayEPA0AgASAFKAJUIgZPDUAgBSgCUCAKaigCACIGIAJPDUEgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NQiAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUFBwABBwAAQrTYiAUUNPyAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1BQcAAQcAAEK02IgFFDT8gBUIANwJEIAUgATYCQCAFQsCAgICACDcCOEEBIQsgBSgCGCIHQQJPBEAgB60hGEEAIQNCASEXA0AgBSgCFCADaiIBQQRqKAIAIAEoAgAiAUcEQCAFKAJEIghBCGoiBiAFKAI8IgJLBEAgBUE4aiACQQF0IgIgBhDSKiIGIAIgBksbEOgZIAUoAkQiCEEIaiEGIAUoAjwhAgsgAiAGSQR/IAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEBSAICyAFKAJAaiABrTcAACAFIAUoAkRBCGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCALQQFqIQsLIANBBGohAyAYIBdCAXwiF1INAAsLIAdBAWshASAHRQ0EIAUoAhQgAUECdGo1AgAhFyAFKAJEIgZBCGoiAyAFKAI8IgFLBEAgBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQiBkEIaiEDIAUoAjwhAQsgASADSQR/IAVBOGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAJEBSAGCyAFKAJAaiAXNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQhqIgMgBSgCJCIBSwRAIAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsIgZBCGohAyAFKAIkIQELIAEgA0kEfyAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLAUgBgsgBUEoaiICKAIAaiAHrTcAACAFIAUoAixBCGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiB0GFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAVBnAJqIgEQlykgAigCACEIIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAINgKcAiAFQQhqIAEQ1zsgBSgCCCEIQRxBBBCtNiICRQ1AIAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIJKAIANgIAIAUgAzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIIEPojIAVBzABqIgogARDNHCAHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgARCXKSAFQUBrIgIoAgAhCyAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAs2ApwCIAUgARDXOyAFKAIAIQtBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAkoAgA2AgAgBSAHNgLcAyAFIAs2AtgDIAUgAjYC1AMgASADIAgQ+iMgAyABEM0cIAVBkAFqIgEgAxCxEyADIA5BIGpBiJ+CASABQbyBggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhGDQIgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAMLIAEgBSgCVCIDTw09IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPAsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQoAkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQsgAUEAQZCvggEQwyEACyAELQCQGiIBQSlHBEAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBiBdqIARBsBpqKQIANwIAIARB8RZqIAMpAwA3AAAgBEH4FmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AoAXIAQgAToA6BYgBCAXNwDpFiAEQegWahD1KSEBIABBjKmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwxCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwwCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwvCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAACAEQbgPahDJHgwuCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAgQiBi0AAEECaw4IAQIDBAUGBwgACyAEIAY2ArgPIARBATYClBogBEGcpoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQaSmggEQ7ywACyAEQZAaaiEGIAEgAhDEIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDlFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQ0gBEGIFWoiAiAGQcQA/AoAACAEQdcRaiAEQdcaai0AADoAACAEIAQvANUaOwDVESAEQZARaiIDIAJBxAD8CgAAIAQgAToA1BEgAxDrKSEBIABBkKCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw7CyAEQZAaaiEGIAEgAhDBIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCnFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQsgBEGIFWoiAiAGQcQA/AoAACAEQZ8SaiAEQdcaai0AADoAACAEIAQvANUaOwCdEiAEQdgRaiIDIAJBxAD8CgAAIAQgAToAnBIgAxDrKSEBIABB6KCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEGIAEgAhDAIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCoFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQkgBEGIFWoiAiAGQcQA/AoAACAEQecSaiAEQdcaai0AADoAACAEIAQvANUaOwDlEiAEQaASaiIDIAJBxAD8CgAAIAQgAToA5BIgAxDrKSEBIABBwKGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiEGIAEgAhDDIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCpFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQcgBEGIFWoiAiAGQcQA/AoAACAEQa8TaiAEQdcaai0AADoAACAEIAQvANUaOwCtEyAEQegSaiIDIAJBxAD8CgAAIAQgAToArBMgAxDrKSEBIABBmKKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAEQZAaaiEGIAEgAhDCIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDmFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQUgBEGIFWoiAiAGQcQA/AoAACAEQfcTaiAEQdcaai0AADoAACAEIAQvANUaOwD1EyAEQbATaiIDIAJBxAD8CgAAIAQgAToA9BMgAxDrKSEBIABB8KKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAEQZAaaiEGIAEgAhC/IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCqFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQMgBEGIFWoiAiAGQcQA/AoAACAEQb8UaiAEQdcaai0AADoAACAEIAQvANUaOwC9FCAEQfgTaiIDIAJBxAD8CgAAIAQgAToAvBQgAxDrKSEBIABByKOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw2CyAEQZAaaiEGIAEgAhC+IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCrFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQEgBEGIFWoiAiAGQcQA/AoAACAEQYcVaiAEQdcaai0AADoAACAEIAQvANUaOwCFFSAEQcAUaiIDIAJBxAD8CgAAIAQgAToAhBUgAxDrKSEBIABBoKSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZAaaiEGIAEgAhC9IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCsFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJHBEAgBEGIFWoiAiAGQcQA/AoAACAEQZcWaiAEQdcaai0AADoAACAEIAQvANUaOwCVFiAEQdAVaiIDIAJBxAD8CgAAIAQgAToAlBYgAxDrKSEBIABB+KSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAw0CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwzCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwyCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwxCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwwCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwvCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwuCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwtCyAHKAIAIgEgASgCACICQQFqNgIAIAJBAEgNASAGKAIIIQIgBEHAHmogBEGIH2ooAgA2AgAgBCAEKQKAHzcDuB4gBEEANgK4GSAEQcAPaiAEQYQZaigCADYCACAEIAQpAvwYNwO4DyAEQZAaaiABIAIgBEG4HmogBEG4GWogBEG4D2oQkQQgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGBEAgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADC0LIARBsBlqIARBuBpqKQIANwIAIARBqBlqIARBsBpqKQIANwIAIARBlBlqIAEpAwA3AgAgBEGcGWogAigCADYCACAEIAQpAqgaNwKgGSAEIAM2AogZIAQgBCkDiBU3AowZIARBiBlqENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCwLIARByABqIAEgAigCEBEAACAEQZAaaiICIAQoAkgiASAEKAJMKAIMEQAAAkACQCABRQ0AIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNACAEQYgVaiIFIAEoAhwgASgCICADEMkWIARBADYC6BkgBEGgGmogBEH4GWopAgA3AwAgBEGYGmogBEHwGWopAgA3AwAgBCAEKQLoGTcDkBogBEG4GWoiCCAFIAIQ2B0gARCTNiIJRQ0BIAIgCSgCBCAJKAIIQQJ2IAMQxxYgBEG4D2oiAyACIARB6BlqEL8dIARBQGsgBxCwLiAEKQNAIRcgBCABNgKgGiAEIBc3ApAaIAQgAzYCnBogBCAINgKYGiAFIAIQuxUgBEHAHmoiASAEQZQVaigCADYCACAEIAQpAowVNwO4HiAEKAKIFSICQZOAgIB4RwRAIAQoApgVIQYgACAEKQO4HjcCBCAAIAY2AhAgACACNgIAIABBDGogASgCADYCACADEP4kIAgQ/iQMLgsgBEGIGmogBEHAHmooAgA2AgAgBCAEKQO4HjcDgBogBEGQGmoiAUEAQYAE/AsAIAQgBCgCyBkiAjYCiBUgBCACIARBzBlqIgMoAgBqNgKMFSAEIAE2ApAVIARBnB5qIARBiBVqIgEQvCwgBEGwHmogAygCACICNgIAIARBnBVqIAI2AgAgBEGoFWogBEHYGWopAgA3AwAgBEGwFWogBEHgGWopAgA3AwAgBEGQFWogBEHAGWooAgA2AgAgBCAEKQLEGSIXNwOoHiAEIBc3ApQVIAQgBCkC0Bk3A6AVIAQgBCkCuBk3A4gVIAEQtAwCQCAEKAKgFSIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQaAVahD7HgsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQIgBigCCCECIARBiB9qIARBpB5qKAIANgIAIAQgBCkCnB43A4AfIARBiBVqIAEgAiAEQageaiAEQYAfaiAEQYAaahCRBCAEQcAeaiIBIARBlBVqKQIANwMAIARByB5qIgIgBEGcFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiA0GAgICAeEYEQCAAIAQpA7geNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBEG4D2oQ/iQMLgsgBEH4HmogBEGwFWopAgA3AgAgBEHwHmogBEGoFWopAgA3AgAgBEHcHmogASkDADcCACAEQeQeaiACKAIANgIAIAQgBCkCoBU3AugeIAQgAzYC0B4gBCAEKQO4HjcC1B4gBEHQHmoQ3CkhASAAQbCeggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oQ/iQMLQtB8J+CARCyOwALQYCgggEQsjsACwALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCgLIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwnCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwmCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwlCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGAsgBEEIakHEjoIBIAMQoSsgACAEKQMINwIEIABBk4CAgHg2AgAMFwsgBCAGNgK4DyAEQQE2ApQaIARByKuCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakHQq4IBEO8sAAsgBEGTBmogASgAACIBNgAAIARBiwZqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwCDBiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwVCyAEQeMFaiABKAAAIgE2AAAgBEHbBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3ANMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBQLIARBswVqIAEoAAAiATYAACAEQasFaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAowUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEwsgBEGDBWogASgAACIBNgAAIARB+wRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDzBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwSCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwRCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwQCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwPCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwOCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwNCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwMCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwLCyAEQdMEaiABKAAAIgE2AAAgBEHLBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AMMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAoLIARBowRqIAEoAAAiATYAACAEQZsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAkwQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCQsgBEHzA2ogASgAACIBNgAAIARB6wNqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDjAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwICyAEQcMDaiAEQaQaaigCACIBNgAAIARBuwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCzAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwHCyAEQZMDaiAEQaQaaigCACIBNgAAIARBiwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCDAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwGCyAEQeMCaiAEQaQaaigCACIBNgAAIARB2wJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDTAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwFCyAEQbMCaiAEQaQaaigCACIBNgAAIARBqwJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCjAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwECyAEQYMCaiAEQaQaaigCACIBNgAAIARB+wFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDzASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwDCyAEQdMBaiAEQaQaaigCACIBNgAAIARBywFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDDASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwCCyAEQaMBaiAEQaQaaigCACIBNgAAIARBmwFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCTASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwBCyAEQfMAaiAEQaQaaigCACIBNgAAIARB6wBqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwBjIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAACyAEQZAfaiQADwtBBEE4EKM9AAsgASACQbjxgQEQwyEACyABIAZB7PKBARDDIQALIAYgAkH88oEBEMMhAAsgBiAHQYzzgQEQwyEACyABIAJB6PGBARDDIQALIAEgA0HY8YEBEMMhAAtBwABBwAAQoz0AC0EEQRwQoz0AC0HA9IEBQSkgBUH4AmpBzPyBAUHs9IEBENUeAAsgAiAIKAIcQbz8gQEQ/S8ACyAGIAgoAhxBvPyBARD9LwALIAggCkHw9oMBEMMhAAsgAyAKQYD3gwEQwyEACyAIIApB8PaDARDDIQALIAEgCkGA94MBEMMhAAtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgAUEBNgIUIAFB3LaCATYCECABQgE3AhwgAUHIEDYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpB5LaCARDvLAALy04CDX8CfiMAQfADayIGJAACQANAAkAgA0UEQEEAIQkMAQsgAigCAARAIAMhCQwBCyADQQJ0QQRrIQdBACEIA0AgB0UNAyAAQQRqIQAgB0EEayEHIAhBAWohCCACQQRqIgIoAgBFDQALIAEgCEEBa0sEQCABIAhrIQEgAyAIayEJDAELIAggAUGgi4gBEK87AAsCQCAFRQRAQQAhBQwBCyAEKAIADQAgBUECdEEEayEHQQAhCANAIAdFDQMgAEEEaiEAIAdBBGshByAIQQFqIQggBEEEaiIEKAIARQ0ACyABIAhBAWtLBEAgASAIayEBIAUgCGshBQwBCyAIIAFBsIuIARCvOwALIAkgBSAFIAlJGyEKIAQgAiAFIAlLIgMbIQwgAiAEIAMbIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAkgBSADGyIDQSFPBEAgA0EBdCAKTQ0OIANBgQJJDQggBkH4AGoiCSACIApBA25BAWoiBSADIAMgBUsbIgQQmA4gAyAFIAMgBGsiByAFIAdJGyIIIARqIgdJDQEgBkGIAWoiCyACIARBAnRqIAgQmA4gBkGYAWoiBCACIAdBAnRqIAMgB2sQmA4gCkUNAiAGQagBaiIHIAwgBRCYDiAKIAUgCiAFayICIAIgBUsbIgMgBWoiAkkNAyAGQbgBaiIIIAwgBUECdGogAxCYDiAGQcgBaiIDIAwgAkECdGogCiACaxCYDiAGQdgBaiICIAkgBBCCByAGQegBaiIEIAcgAxCCByAGQfgBaiACIAsQlwQgBkGIAmogBCAIEJcEQQEhB0EBIQQgBi0AhAEiAkEBRg0NIAYtALQBIgRBAWsOAg0JCgsgA0UNDyACIANBAnRqIREgAUECdCEPIAUgCSAFIAlLG0ECdCIDQQRqIQ0gACADaiELIAAhAwNAIAEgDkkNBAJAIAIoAgAiBEUNACAKIAEgDmsiEEsNBiAGIAAgDkECdGoiBTYC2AMgBiAFIApBAnRqIgU2AtwDIAogBkHYA2oQnjYiByAHIApLGyIIBH8gBK0hFEIAIRMgAyEHIAwhBANAIAcgEyAHNQIAfCAENQIAIBR+fCITPgIAIBNCIIghEyAHQQRqIQcgBEEEaiEEIAhBAWsiCA0ACyATpwVBAAshCSAKIBBGDQcgBiAFNgLYAyAGIAVBBGo2AtwDIAZB2ANqEJ42IgRFDQAgBEEARyEIQQAhBSALIQcDQCAHIAUgBygCACIFIAlqIgRqIhA2AgAgBCAFSSAEIBBLciIEIQUgB0EEaiEHIAhBAWsiCA0ACyAERQ0AIA0hBwNAIAcgD0YNCSADIAdqIgQgBCgCAEEBaiIENgIAIAdBBGohByAERQ0ACwsgDkEBaiEOIA9BBGshDyALQQRqIQsgA0EEaiEDIBEgAkEEaiICRw0ACwwPCyAHIANBwIuIARCwOwALIAVBAEHQi4gBELA7AAsgAiAKQeCLiAEQsDsACyAOIAFB4IyIARCvOwALIAZBADYC6AMgBkEBNgLcAyAGQfSJiAE2AtgDIAZCBDcC4AMgBkHYA2pBzIqIARDvLAALIAZBADYC6AMgBkEBNgLcAyAGQfSJiAE2AtgDIAZCBDcC4AMgBkHYA2pBnIqIARDvLAALIAZBATYCyAMgBkIANwLkAyAGQoGAgIDAADcC3AMgBkGIi4gBNgLYAyAGQcgDakHciogBIAZB2ANqQZCLiAEQqCsACwJAIANBAXYiBCAKTQRAIAZB2ANqIAogBGsiCiADIARrIg5qQQFqIgVBoIyIARC/FSAGQZADaiAGQeADaigCACIJNgIAIAYgBikC2AM3A4gDIAYoAowDIgggCSACIARBAnQiB2oiDyAOIAcgDGoiESAKEIsBIAlFDQEgCCAJQQJ0IgtqQQRrIgdFDQEgBygCAA0BIAshByAIQQRrIQsgCUH/////A3EhCAJAA0AgB0UEQEEAIQcMAgsgCEEBayEIIAcgC2ogB0EEayEHKAIARQ0ACyAIQQFqIgcgCUsNAgsgBiAHNgKQAyAHIQkMAQsgBkEANgLoAyAGQQE2AtwDIAZB9ImIATYC2AMgBkIENwLgAyAGQdgDakGQjIgBEO8sAAsCQCAJIAYoAogDQQJ2Tw0AIAZBGGogBkGIA2ogCUEEQQQQ9BQgBigCGCIHQYGAgIB4Rg0AIAcgBigCHEHMjYgBEP0vAAsCQAJAIAEgBE8EQCAAIARBAnRqIgsgASAEayINIAYoAowDIgcgBigCkAMiCBCEEyABIANB/gNxIgNJDQEgACADQQJ0aiABIANrIAcgCBCEE0EAIQggBkEANgKQAyAFBH8gBkGIA2ogBRDTGiAGKAKQAyEIIAYoAowDBSAHCyAIIAIgBCAMIAQQiwEgBigCjAMhCSAGKAKQAyIDRQ0CIAkgA0ECdCIIakEEayIHRQ0CIAcoAgANAiAIIQcgCUEEayEQIANB/////wNxIQgCQANAIAdFBEBBACEHDAILIAhBAWshCCAHIBBqIAdBBGshBygCAEUNAAsgCEEBaiIHIANLDQMLIAYgBzYCkAMgByEDDAILIAQgAUGwjIgBEK87AAsgAyABQcCMiAEQrzsACwJAAkACQAJAIAYoAogDQQJ2IANLBEAgBkEQaiAGQYgDaiADQQRBBBD0FCAGKAIQIgNBgYCAgHhHDQEgBigCjAMhCSAGKAKQAyEDCyAAIAEgCSADEIQTIAsgDSAGKAKMAyAGKAKQAxCEEyAGQdgDaiIDIA8gDiACIAQQvgYgBi0A2AMhACAGQaADaiAGQeQDaiIBKAIANgIAIAYgBikC3AM3A5gDIAMgESAKIAwgBBC+BiAGLQDYAyECIAZB0ANqIAEoAgA2AgAgBiAGKQLcAzcDyAMgAEEBRg0DAkACQAJAIAJBAWsOAgYAAQsgAA0BDAQLIAANAwtBACEHIAZBADYCkAMgBQRAIAZBiANqIAUQ0xogBigCkAMhBwsgBigCjAMgByAGKAKcAyAGKAKgAyAGKALMAyAGKALQAxCLASAGKAKMAyEIIAYoApADIgJFDQEgCCACQQJ0IgdqQQRrIgBFDQEgACgCAA0BIAhBBGshACACQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgACAHaiAHQQRrIQcoAgBFDQALIARBAWoiByACSw0CCyAGIAc2ApADIAchAgwBCyADIAYoAhRBzI2IARD9LwALAkAgBigCiANBAnYgAksEQCAGQQhqIAZBiANqIAJBBEEEEPQUIAYoAggiAEGBgICAeEcNASAGKAKMAyEIIAYoApADIQILIAsgDSAIIAIQzRAMAgsgACAGKAIMQcyNiAEQ/S8ACyALIA0gBigCnAMgBigCoAMgBigCzAMgBigC0AMQiwELIAZByANqQQRBBBDgHiAGQZgDakEEQQQQ4B4gBkGIA2pBBEEEEOAeDAcLIAINAQwCCyACDQELQQIhBEEAIQcMAQtBACEHQQAhBAsCQAJAIAYoAoABIgIEQCAGKAKwASIDDQELIAZB0ANqQbiNiAEoAgA2AgAgBkGwjYgBKQIANwPIAwwBCyAGKAKsASEIIANBAUYEQCAIKAIAIQIgBkHYA2oiAyAGQfgAahDpHSADIAIQ4w4gBkHQA2ogBkHgA2ooAgA2AgAgBiAGKQLYAzcDyAMMAQsgBigCfCEJIAJBAUYEQCAJKAIAIQIgBkHYA2oiAyAGQagBahDpHSADIAIQ4w4gBkHQA2ogBkHgA2ooAgA2AgAgBiAGKQLYAzcDyAMMAQsgBkHIA2ogCSACIAggAxCjEQsCQCAHRQRAIARBASAGKALQAxshBwwBCyAGQQA2AtADIAZByANqQQRBBBCeJAJAIAYoAtADIghFDQAgBigCzAMiAiAIQQJ0IgdqQQRrIgNFDQAgAygCAA0AIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0BCyAGIAc2AtADIAchCAtBASEHIAggBigCyANBAnZPDQAgBkHwAGogBkHIA2ogCEEEQQQQ9BQgBigCcCICQYGAgIB4Rg0AIAIgBigCdEHMjYgBEP0vAAsgBkGgAmogBkHQA2ooAgA2AgAgBiAGKQPIAzcDmAIgBiAHOgCkAkEBIQdBASEEAkAgBi0ApAEiAkEBRg0AAkACQAJAAkAgBi0A1AEiBEEBaw4CBAEACyACDQEMAgsgAg0BC0EAIQdBACEEDAELQQIhBEEAIQcLAkACQCAGKAKgASICBEAgBigC0AEiAw0BCyAGQdADakG4jYgBKAIANgIAIAZBsI2IASkCADcDyAMMAQsgBigCzAEhCCADQQFGBEAgCCgCACECIAZB2ANqIgMgBkGYAWoQ6R0gAyACEOMOIAZB0ANqIAZB4ANqKAIANgIAIAYgBikC2AM3A8gDDAELIAYoApwBIQkgAkEBRgRAIAkoAgAhAiAGQdgDaiIDIAZByAFqEOkdIAMgAhDjDiAGQdADaiAGQeADaigCADYCACAGIAYpAtgDNwPIAwwBCyAGQcgDaiAJIAIgCCADEKMRCwJAIAdFBEAgBEEBIAYoAtADGyEEDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQQgCCAGKALIA0ECdk8NACAGQegAaiAGQcgDaiAIQQRBBBD0FCAGKAJoIgJBgYCAgHhGDQAgAiAGKAJsQcyNiAEQ/S8ACyAGQbACaiAGQdADaiICKAIANgIAIAYgBikDyAM3A6gCIAYgBDoAtAIgAiAGQeABaikCADcDACAGIAYpAtgBNwPIAyAGQeADaiIDIAZBkAFqKQIANwMAIAYgBikCiAE3A9gDIAZBiANqIAZByANqIgQgBkHYA2oiBxDRBSACIAZB8AFqKQIANwMAIAYgBikC6AE3A8gDIAMgBkHAAWopAgA3AwAgBiAGKQK4ATcD2AMgBkGYA2ogBCAHENEFIAZBgANqIAZBoANqKAIANgIAIAZB8AJqIAZBkANqKAIANgIAIAYgBikCmAM3A/gCIAYgBikCiAM3A+gCAkACfwJAAkAgBi0AlAMiAkEBRg0AAkACQAJAIAYtAKQDQQFrDgIDAQALIAINAQwDCyACDQILQQAMAgsCfwJAAkAgBigC8AIiAgRAIAYoAoADIgMNAQsgBkHQA2pBuI2IASgCADYCACAGQbCNiAEpAgA3A8gDDAELIAYoAvwCIQQgA0EBRgRAIAQoAgAhAiAGQeADaiIDIAZBkANqKAIANgIAIAYgBikCiAM3A9gDIAZB2ANqIAIQ4w4gBkHQA2ogAygCADYCACAGIAYpA9gDNwPIAyAGQfgCagwCCyAGKALsAiEHIAJBAUYEQCAHKAIAIQIgBkHgA2oiAyAGQaADaigCADYCACAGIAYpApgDNwPYAyAGQdgDaiACEOMOIAZB0ANqIAMoAgA2AgAgBiAGKQPYAzcDyAMgBkHoAmoMAgsgBkHIA2ogByACIAQgAxCjEQsgBkGYA2pBBEEEEOAeIAZB6AJqCyIHQQRBBBDgHiAGQQA2AtADIAZByANqQQRBBBCeJAJAIAYoAtADIghFDQAgBigCzAMiAiAIQQJ0IgdqQQRrIgNFDQAgAygCAA0AIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0BCyAGIAc2AtADIAchCAtBASEHIAggBigCyANBAnZPDQIgBkHgAGogBkHIA2ogCEEEQQQQ9BQgBigCYCICQYGAgIB4Rg0CIAIgBigCZEHMjYgBEP0vAAtBAgsgBkHIA2ogBkGIA2ogBkGYA2oQzxNBASAGKALQAxshBwsgBkHAAmogBkHQA2ooAgA2AgAgBiAGKQPIAzcDuAIgBiAHOgDEAkEBIQdBASEEAkAgBi0AhAIiAkEBRg0AAkACQAJAAkAgBi0AlAIiBEEBaw4CBAEACyACDQEMAgsgAg0BC0EAIQdBACEEDAELQQIhBEEAIQcLAkACQCAGKAKAAiICBEAgBigCkAIiAw0BCyAGQdADakG4jYgBKAIANgIAIAZBsI2IASkCADcDyAMMAQsgBigCjAIhCCADQQFGBEAgCCgCACECIAZB2ANqIgMgBkH4AWoQ6R0gAyACEOMOIAZB0ANqIAZB4ANqKAIANgIAIAYgBikC2AM3A8gDDAELIAYoAvwBIQkgAkEBRgRAIAkoAgAhAiAGQdgDaiIDIAZBiAJqEOkdIAMgAhDjDiAGQdADaiAGQeADaigCADYCACAGIAYpAtgDNwPIAwwBCyAGQcgDaiAJIAIgCCADEKMRCwJAIAdFBEAgBEEBIAYoAtADGyEHDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQcgCCAGKALIA0ECdk8NACAGQdgAaiAGQcgDaiAIQQRBBBD0FCAGKAJYIgJBgYCAgHhGDQAgAiAGKAJcQcyNiAEQ/S8ACyAGQdACaiAGQdADaiIDKAIANgIAIAYgBikDyAM3A8gCIAYgBzoA1AIgBkHgA2oiAiAGQaABaikCADcDACAGIAYpApgBNwPYAyAGQcgDaiIEIAZB+AFqIAZB2ANqIgcQ0QUgBkGYA2oiCCAEEPoOIAIgBkGAAWopAgA3AwAgBiAGKQJ4NwPYAyAGQYgDaiAIIAcQqAMgAiAGQdABaikCADcDACAGIAYpAsgBNwPYAyAEIAZBiAJqIAcQ0QUgCCAEEPoOIAIgBkGwAWopAgA3AwAgBiAGKQKoATcD2AMgBCAIIAcQqAMgBkGAA2ogAygCADYCACAGQfACaiAGQZADaigCADYCACAGIAYpAsgDNwP4AiAGIAYpAogDNwPoAgJAAn8CQAJAIAYtAJQDIgJBAUYNAAJAAkACQCAGLQDUA0EBaw4CAwEACyACDQEMAwsgAg0CC0EADAILAn8CQAJAIAYoAvACIgIEQCAGKAKAAyIDDQELIAZBoANqQbiNiAEoAgA2AgAgBkGwjYgBKQIANwOYAwwBCyAGKAL8AiEEIANBAUYEQCAEKAIAIQIgBkHgA2oiAyAGQZADaigCADYCACAGIAYpAogDNwPYAyAGQdgDaiACEOMOIAZBoANqIAMoAgA2AgAgBiAGKQPYAzcDmAMgBkH4AmoMAgsgBigC7AIhByACQQFGBEAgBygCACECIAZB4ANqIgMgBkHQA2ooAgA2AgAgBiAGKQLIAzcD2AMgBkHYA2ogAhDjDiAGQaADaiADKAIANgIAIAYgBikD2AM3A5gDIAZB6AJqDAILIAZBmANqIAcgAiAEIAMQoxELIAZByANqQQRBBBDgHiAGQegCagsiB0EEQQQQ4B4gBkEANgKgAyAGQZgDakEEQQQQniQCQCAGKAKgAyIIRQ0AIAYoApwDIgIgCEECdCIHakEEayIDRQ0AIAMoAgANACACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNAQsgBiAHNgKgAyAHIQgLQQEhByAIIAYoApgDQQJ2Tw0CIAZB0ABqIAZBmANqIAhBBEEEEPQUIAYoAlAiAkGBgICAeEYNAiACIAYoAlRBzI2IARD9LwALQQILIAZBmANqIAZBiANqIAZByANqEM8TQQEgBigCoAMbIQcLIAZB4AJqIAZBoANqKAIANgIAIAYgBikDmAM3A9gCIAYgBzoA5AIgBkHYA2ogBkHYAmogBkG4AmoQpAYgBi0A5AMhAyAGKALcAyECIAYoAtgDIQggBigC4AMiCQRAIAJBBGshDCAJQQJ0IQdBACEEA0AgByAMaiILIAsoAgAiC0EQdiINIA0gBEEQdHJBA24iBEEDbGtBEHQgC0H//wNxciILQQNuIg0gBEEQdHI2AgAgCyANQQNsayEEIAdBBGsiBw0ACwsgBiAJNgLQAyAGIAg2AsgDIAYgAjYCzAMCQCAJRQ0AIAIgCUECdCIEakEEayIHRQ0AIAcoAgANACAEIQcgAkEEayECIAlB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAlLDQELIAYgBzYC0AMgByEJCwJAAkACQCAIQQJ2IAlLBEAgBkHIAGogBkHIA2ogCUEEQQQQ9BQgBigCSCIHQYGAgIB4Rw0BCyAGQaADaiAGQdADaigCADYCACAGIAYpAsgDNwOYAyADQQFHBEAgA0EBIAYoAqADGyEHDAMLIAZBADYCoAMgBkGYA2pBBEEEEJ4kIAYoAqADIghFDQEgBigCnAMiAiAIQQJ0IgdqQQRrIgNFDQEgAygCAA0BIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0CCyAGIAc2AqADIAchCAwBCyAHIAYoAkxBzI2IARD9LwALQQEhByAIIAYoApgDQQJ2Tw0AIAZBQGsgBkGYA2ogCEEEQQQQ9BQgBigCQCICQYGAgIB4Rg0AIAIgBigCREHMjYgBEP0vAAsgBkHwAmoiAiAGQaADaigCADYCACAGIAYpA5gDNwPoAiAGIAc6APQCIAZB4ANqIgMgBkHAAmopAwA3AwAgBiAGKQO4AjcD2AMgBkHIA2oiByAGQdgDaiIEIAZByAJqEKQGIAZB+AJqIAcQ/AggAyAGQdACaikDADcDACAGIAYpA8gCNwPYAyAGQYgDaiIHIAQgBkGYAmoQpAYCQAJAAkACQAJAIAYtAPQCIgNBAUYEQCAGLQCUAyECIAQgBxDpHSAGIAI6AOQDDAELIAIoAgAhBCAGKALsAiEHAkACQAJAAkACQAJAAkAgBi0AlAMiAkEBaw4CAAIBCyAGQeADaiAGQfACaigCADYCACAGIAYpA+gCNwPYAyAGQQIgA2s6AOQDDAoLIANFDQEMAgsgA0UNAQsCfyAEIAYoApADIgNHBEAgAyAESyADIARJawwBCyAGKAKMA0EEayEIIAdBBGshCSADQQJ0IQcCQANAIAdFDQEgByAJaiEEIAcgCGogB0EEayEHKAIAIgMgBCgCACIERg0ACyADIARLIAMgBElrDAELQX9BACAHGwsiB0H/AXEOAgIEAQsgBkHQA2ogBkHwAmooAgA2AgAgBiAGKQPoAjcDyAMgBkGYA2ogBkHIA2ogBkGIA2oQ7QggBkHgA2ogBkGgA2ooAgAiAzYCACAGIAYpApgDNwPYAyAGIAJBASADGzoA5AMMBgtBAiEHAkACQAJAIAJBAWsOAgIAAQtBACEHCyAGQeADaiICIAZB8AJqKAIANgIAIAYgBikD6AI3A9gDIAZB2ANqIAZBiANqEO8UIAZB0ANqIAIoAgAiAjYCACAGIAYpA9gDNwPIAyAHQQEgAhshBwwFCyAGQeADaiAGQfACaigCADYCACAGIAYpA+gCNwPYAyAGQdgDaiAGQYgDahDvFCAGIAYpA9gDNwPIAyAGQQA2AtADIAZByANqQQRBBBCeJCAGKALQAyIIRQ0DIAYoAswDIgIgCEECdCIHakEEayIDRQ0DIAMoAgANAyACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNBAsgBiAHNgLQAyAHIQgMAwsgBkHgA2pBlIqIASkCADcDACAGQYyKiAEpAgA3A9gDCyAGQegCakEEQQQQ4B4MAwsgBkHgA2ogBkHwAmooAgA2AgAgBiAGKQPoAjcD2AMgBkHIA2ogBkGIA2ogBkHYA2oQ8goCQCACQQFHBEAgAkEBIAYoAtADGyEHDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQcgCCAGKALIA0ECdk8NACAGQThqIAZByANqIAhBBEEEEPQUIAYoAjgiAkGBgICAeEYNACACIAYoAjxBzI2IARD9LwALIAZB4ANqIAZB0ANqKAIANgIAIAYgBikCyAM3A9gDIAYgBzoA5AMMAgtBASEHIAggBigCyANBAnZPDQAgBkEwaiAGQcgDaiAIQQRBBBD0FCAGKAIwIgJBgYCAgHhGDQAgAiAGKAI0QcyNiAEQ/S8ACyAGQeADaiAGQdADaigCADYCACAGIAYpA8gDNwPYAyAGIAc6AOQDCyAGQcgDaiAGQdgDaiIDEPwIIAYtALQCIQICQCAGKAKwAgRAIAZBgICAgHg2AtgDIAYgBkGoAmo2AtwDIAZBmANqIANBAEEBEKgFDAELIAZBmANqIAZBqAJqEOkdCwJAIAJBAUcEQCACQQEgBigCoAMbIQcMAQsgBkEANgKgAyAGQZgDakEEQQQQniQCQCAGKAKgAyIIRQ0AIAYoApwDIgIgCEECdCIHakEEayIDRQ0AIAMoAgANACACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNAQsgBiAHNgKgAyAHIQgLQQEhByAIIAYoApgDQQJ2Tw0AIAZBKGogBkGYA2ogCEEEQQQQ9BQgBigCKCICQYGAgIB4Rg0AIAIgBigCLEHMjYgBEP0vAAsgBkHgA2oiAyAGQaADaigCADYCACAGIAYpApgDNwPYAyAGIAc6AOQDIAZB6AJqIAZByANqIAZB2ANqENEFIAZBmANqIAZB+AJqIAZBqAJqEJcEIAZBkANqIgIpAwAhEyACQZSKiAEpAgA3AwAgBkHQA2oiBCATNwMAIAYpA4gDIRMgBkGMiogBKQIANwOIAyAGIBM3A8gDAkAgBi0ApAMiAkEBRgRAIAMgBCkDADcDACAGIAYpA8gDNwPYAwwBCwJAAkACQAJAAkACQAJAAkACQCAGLQDUAyIDQQFrDgIDAAELIAJFDQEMBwsgAkUNBgsCfyAGKALQAyIEIAYoAqADIgdHBEAgBCAHSyAEIAdJawwBCyAGKALMA0EEayEJIAYoApwDQQRrIQwgBEECdCEHAkADQCAHRQ0BIAcgDGohCCAHIAlqIAdBBGshBygCACIEIAgoAgAiCEYNAAsgBCAISyAEIAhJawwBC0F/QQAgBxsLQf8BcQ4CAgMBCyAGQdgDaiAGQZgDahDpHSAGIAI6AOQDDAMLIAZBwANqIAZB0ANqKAIANgIAIAYgBikDyAM3A7gDIAZBrANqIAZBmANqIAZBuANqEPIKIAZB4ANqIAZBtANqKAIAIgM2AgAgBiAGKQKsAzcD2AMgBiACQQEgAxs6AOQDDAQLIAZB4ANqQZSKiAEpAgA3AwAgBkGMiogBKQIANwPYAwwBCyAGQeADaiICIAZB0ANqKAIANgIAIAYgBikDyAM3A9gDIAZB2ANqIAZBmANqEO8UIAZBwANqIAIoAgA2AgAgBiAGKQPYAzcDuAMCQCADQQFHBEAgA0EBIAYoAsADGyEHDAELIAZBADYCwAMgBkG4A2pBBEEEEJ4kAkAgBigCwAMiCEUNACAGKAK8AyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYCwAMgByEIC0EBIQcgCCAGKAK4A0ECdk8NACAGQSBqIAZBuANqIAhBBEEEEPQUIAYoAiAiAkGBgICAeEYNACACIAYoAiRBzI2IARD9LwALIAZB4ANqIAZBwANqKAIANgIAIAYgBikDuAM3A9gDIAYgBzoA5AMMAgsgBkHIA2pBBEEEEOAeDAELIAZBwANqIAZB0ANqKAIANgIAIAYgBikDyAM3A7gDIAZBrANqIAZBuANqIAZBmANqEO0IIAZB4ANqIAZBtANqKAIAIgI2AgAgBiAGKQKsAzcD2AMgBiADQQEgAhs6AOQDCyAGQYgDaiIEQQRBBBDgHiAGQZADaiAGQeADaiIDKQMANwMAIAYgBikD2AM3A4gDIAZBmANqQQRBBBDgHiAGQYADaiICKQMAIRMgAkGUiogBKQIANwMAIAZB0ANqIBM3AwAgBikD+AIhEyAGQYyKiAEpAgA3A/gCIAYgEzcDyAMgBkHYA2ogBkHIA2ogBkHoAmoiBxCkBiAGQfgCaiIIQQRBBBDgHiACIAMpAgA3AwAgBiAGKQLYAzcD+AIgBiAGQagCajYC6AMgBiAHNgLkAyAGIAQ2AuADIAYgCDYC3AMgBiAGQZgCajYC2ANBECEHA0AgB0ECdiEDAkACQAJAAkACQCAGQdgDaiAHaigCACICLQAMQQFrDgIEAQALIAEgAyAFbCIDSQ0BIAAgA0ECdGogASADayACKAIEIAIoAggQzRAMAwsgASADIAVsIgNJDQEgACADQQJ0aiABIANrIAIoAgQgAigCCBCEEwwCCyADIAFB8IuIARCvOwALIAMgAUGAjIgBEK87AAsgB0EEayIHQXxHDQALIAZBiANqQQRBBBDgHiAGQfgCakEEQQQQ4B4gBkHoAmpBBEEEEOAeIAZBqAJqQQRBBBDgHiAGQZgCakEEQQQQ4B4MAgsgACABIAIgAyAMIApBAXYiBBCLASABIARPBEAgASAEayEBIAogBGshBSAAIARBAnQiBGohACAEIAxqIQQMAQsLIAQgAUHQjIgBEK87AAsgBkHwA2okAAvYVAIVfwR+IwBBsAJrIgMkACABKAIIIgZBBGohBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGQXtNBEAgBCABKAIEIgVLDUYgA0HoAWoiByABKAIAIgQgBSAGIAQgBmoiCCgAAGsQ9jQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQQwQzCBB//8DcSIHBEAgBiAHaiIHQQRqIQkgB0F7Sw0+IAUgCUkNPyACDQELIANB6AFqIgIgBCAFIAYgCCgAAGsQ9jQgAkEIEMwgIgJB//8DcUUEQEEAIQcMggELIAYgAkH//wNxaiICIAVLDYMBIAIgBGotAAAiB0EBaw4YAQMLBAcCFgwNDg8RNhcKExUQBgkSFAUIgQELIAQgB2ooAAAgB2oiAkEEaiEGIAJBe0sNPiAFIAZJDT8gA0HoAWoiBiAEIAUgAiACIARqKAAAaxD2NAJAIAZBBhDMIEH//wNxIgYEQCACIAZqIgJBBGohBiACQXtLDUIgBSAGTw0BIAYgBUGAuf4AELA7AAtBlLr+ABCyOwALIAIgBGooAAAgAmoiAkEEaiEGIAJBe0sNQSAFIAZJDUIgA0HoAWoiBiAEIAUgAiACIARqIggoAABrEPY0IAZBBBDMIEH//wNxIgYEfyACIAZqIgYgBUsNRCAEIAZqKAAAQQhrBUF4CyEGIANB6AFqIgcgBCAFIAIgCCgAAGsQ9jQgB0EGEMwgIghB//8DcQR/IAIgCEH//wNxaiICIAVLDYMBIAIgBGotAABBAEcFQQALIQICfwJAAkACQAJAAkAgBkEddw4IAQIAAwAAAAQACyADQQA2AvgBIANBATYC7AEgA0HEuv4ANgLoASADQgQ3AvABIANB6AFqQcy6/gAQ7ywAC0ECQQYgAhsMAwtBA0EHIAIbDAILQQRBCCACGwwBC0EFQQkgAhsLIQVBDEEEEK02IgJFDUQgAiAFOgAAIANB6AFqIAFBABCMAUEMQQQQrTYiAUUNRSABIAMpAugBNwIAIAFBCGogA0HwAWooAgA2AgAgACABNgIIIAAgAjYCBCAAQSI6AAAMfwsgAEEAOgAADH4LIABBAToAAAx9CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUMgAiAGaiICIAVLDX8gAiAEai0AAEECRw1DIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgZFDUMgAygCOCIFQQRqIQEgBUF7Sw1EIAEgAygCNCIESw1FIAcgBiAEIAUgBSAGaiIIKAAAaxD2NEEAIQJBACEBIAdBBBDMIEH//wNxIgcEQCAFIAdqIgEgBEsNgQEgASAGaigAACEBCyADQegBaiIHIAYgBCAFIAgoAABrEPY0IAdBBhDMICIIQf//A3EEQCAFIAhB//8DcWoiAiAESw1HIAIgBmotAABBAEchAgsgAUEIa0Eddw4IFRYUFxQUFBgUCyAAQRQ6AAAMewsgAEEXOgAADHoLIABBFjoAAAx5CyAAQRg6AAAMeAsgAEEaOgAADHcLIABBGToAAAx2CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUAgAiAGaiICIAVLDXggAiAEai0AAEEPRw1AIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUAgAygCOCIBQQRqIQQgAUF7Sw16IAQgAygCNCICSw17IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBAR/IAEgBGoiASACSw19IAEgBWooAAAFQQALIQEgAEEVOgAAIAAgATYCBAx1CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUAgAiAGaiICIAVLDXcgAiAEai0AAEEDRw1AIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUAgAygCOCIBQQRqIQQgAUF7Sw15IAQgAygCNCICSw16IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBEUNEiABIARqIgEgAksNeyABIAVqLwAAIgEOAxITFBELIANB6AFqIgAgBCAFIAYgCCgAAGsQ9jQgAEEIEMwgQf//A3EiAkUNQCACIAZqIgIgBUsNdiACIARqLQAAQQhHDUAgA0EANgLoASADQTBqIgYgAUEKIAAQvBQgAygCMCIFRQ1AIAMoAjgiAUEEaiEEIAFBe0sNeCAEIAMoAjQiAksNeSAAIAUgAiABIAEgBWooAABrEPY0IABBBBDMIEH//wNxIgRFDRQgASAEaiIBIAJLDXpBDiABIAVqLwAAIgFFDRUaIAFBAUYNFCADIAE7AdwBIANBAjYC7AEgA0HcvP4ANgLoASADQgE3AvQBIANBxQs2AjQgAyAGNgLwASADIANB3AFqNgIwIABB7Lz+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQCACIAZqIgIgBUsNdSACIARqLQAAQQlHDUAgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBEUNQCADKAI4IgJBBGohASACQXtLDUEgASADKAI0IgVLDUIgByAEIAUgAiACIARqIgYoAABrEPY0IAdBBhDMIEH//wNxIgEEfyABIAJqIgEgBUsNfSABIARqKAAABUEgCyEBIANB6AFqIgggBCAFIAIgBigAAGsQ9jQgCEEEEMwgIgZB//8DcQR/IAIgBkH//wNxaiICIAVLDXYgAiAEai8AAAVBAQshAiABQSBGDRUgAUHAAEYNFgxxCyADQegBaiIJIAQgBSAGIAgoAABrEPY0IAlBCBDMIEH//wNxIgJFDUIgAiAGaiICIAVLDXQgAiAEai0AAEEKRw1CQQAhBiADQQA2AugBIANBMGogAUEKIAkQvBQgAygCMCICRQ1CIAMgAykCNCIYNwLgASADIAI2AtwBIANBCGogA0HcAWpBBhC9FCAYQiCIpyEBIAMoAggiBQRAIAMgBSADKAIMEJQnIAMoAgQhByADKAIAIQYLIAFBBGohBCAYQv////+/f1YNdiAEIBinIgVLDXMgA0HoAWoiBCACIAUgASABIAJqKAAAaxD2NCAEQQQQzCBB//8DcSIERQRAQQAhAgxwCyABIARqIgEgBUsNeyABIAJqLwAAIgJBBEkNbyADIAI7AdABIANBAjYC7AEgA0GMvv4ANgLoASADQgE3AvQBIANBxgs2AjQgAyADQTBqNgLwASADIANB0AFqNgIwIANB6AFqQZy+/gAQ7ywACyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUIgAiAGaiICIAVLDXMgAiAEai0AAEELRw1CIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUIgAygCOCIBQQRqIQQgAUF7Sw11IAQgAygCNCICSw12IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBEUNGiABIARqIgEgAksNdyABIAVqLwAAIgEOAxobHBkLIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQiACIAZqIgIgBUsNciACIARqLQAAQRJHDUIgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBUUNQiADKAI4IgFBBGohBCABQXtLDXQgBCADKAI0IgJLDXUgByAFIAIgASABIAVqKAAAaxD2NCAHQQQQzCBB//8DcSIERQ0eIAEgBGoiASACSw12IAEgBWovAAAiAQ4EHR4fIBwLIANBADYC6AEgA0EwaiABQQ4gA0HoAWoiBBC8FCADKAIwIgVFDUIgAygCOCIBIAMoAjQiAksNdSABIAVqKAAAQQFGDSAgA0EANgL4ASADQQE2AuwBIANBgMD+ADYC6AEgA0IENwLwASAEQYjA/gAQ7ywACyADQQA2AugBIANBMGogAUEOIANB6AFqIgQQvBQgAygCMCIFRQ1CIAMoAjgiASADKAI0IgJLDXQgASAFaigAAEEBRg0gIANBADYC+AEgA0EBNgLsASADQdDA/gA2AugBIANCBDcC8AEgBEHYwP4AEO8sAAsgA0EANgLoASADQTBqIAFBDiADQegBaiIKELwUIAMoAjAiCUUNQiADKAI4IgIgAygCNCIHSw1DIAIgCWoiCygAAEEBRw0hIAogBCAFIAYgCCgAAGsQ9jQgCkEIEMwgQf//A3EiCA0gDGkLIANBADYC6AEgA0EwaiICIAFBDiADQegBaiIGELwUIAMoAjAiBEUNQyADKAI4IgEgAygCNCIFSw11IAEgBGoiCCgAAEECRg0iIAEgBUsNdSAIKAAAIQAgA0E7NgI0IAMgADYC3AEgA0EBNgLsASADQeTB/gA2AugBIANCATcC9AEgAyADQdwBajYCMCADIAI2AvABIAZB7MH+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQyACIAZqIgIgBUsNbSACIARqLQAAQRFHDUMgA0EANgLoASADQTBqIgQgAUEKIAcQvBQgAygCMCIGRQ1DIAMoAjghAiADKAI0IQUgA0EANgLoASAEIAFBDiAHELwUIAMoAjAiCEUNRCADKAI4IgEgAygCNCIESw1uIAEgCGooAABBAUYNIiADQQA2AvgBIANBATYC7AEgA0G8wv4ANgLoASADQgQ3AvABIAdBxML+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNRCACIAZqIgIgBUsNbCACIARqLQAAQQdHDUQgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBUUNRCADKAI4IgJBBGohBCACQXtLDUUgBCADKAI0IgFLDUYgByAFIAEgAiACIAVqIgQoAABrEPY0IAMgB0EIEMwgQf//A3EiBgR/IAIgBmoiBiABSw1IIAUgBmooAAAFQYABCyIINgLcASADQegBaiIGIAUgASACIAQoAABrEPY0AkAgBkEEEMwgIgZB//8DcUUEQEEAIQcMAQsgAiAGQf//A3FqIgYgAUsNSSAFIAZqKAAAIgdBgAJPDUoLIANB6AFqIgYgBSABIAIgBCgAAGsQ9jQCQCAGQQYQzCBB//8DcSIERQRAQQAhBQwBCyACIARqIgIgAUsNSyACIAVqKAAAIgVBgAFrQf99TQ1MCyAIQSBrQRt3IgFBCEkNIgxlCyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUsgAiAGaiICIAVLDWsgAiAEai0AAEEORw1LIANBADYC6AEgA0EwaiIFIAFBCiAHELwUIAMoAjAiBkUNSyADKAI4IghBBGohAiAIQXtLDUwgAiADKAI0IgRLDU0gByAGIAQgCCAGIAhqIgooAABrEPY0IAdBBBDMIEH//wNxIgJFDSIgAiAIaiICIARLDU5BASACIAZqLwAAIgJBAUYNIxogAkUNIiADIAI7AdwBIANBATYC7AEgA0H0w/4ANgLoASADQgE3AvQBIANBxws2AjQgAyAFNgLwASADIANB3AFqNgIwIAdB/MP+ABDvLAALIAMgAjoA4AEgAyABNgLcASADQQM2AuwBIANBpLv+ADYC6AEgA0ICNwL0ASADQcgLNgI8IAMgA0HgAWo2AjggA0GcAzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBvLv+ABDvLAALIAJFBEAgAEEGOgAADGcLIABBAjoAAAxmCyACRQRAIABBBzoAAAxmCyAAQQM6AAAMZQsgAkUEQCAAQQg6AAAMZQsgAEEEOgAADGQLIAJFBEAgAEEJOgAADGQLIABBBToAAAxjCyADIAE7AdwBIANBAjYC7AEgA0GUvP4ANgLoASADQgE3AvQBIANByQs2AjQgAyADQTBqNgLwASADIANB3AFqNgIwIANB6AFqQaS8/gAQ7ywACyAAQQo6AAAMYQsgAEELOgAADGALIABBDDoAAAxfC0EPCzoAAAxdCyACQf//A3EOAgECWwsgAkH//wNxQQJrDgICA1oLIABBEDsBAAxaCyAAQZACOwEADFkLIABBkQQ7AQAMWAsgAEGRBjsBAAxXCyADIAE7AdwBIANBAjYC7AEgA0Hkvv4ANgLoASADQgE3AvQBIANBygs2AjQgAyADQTBqNgLwASADIANB3AFqNgIwIANB6AFqQfS+/gAQ7ywACyAAQRM7AQAMVQsgAEGTAjsBAAxUCyAAQZMEOwEADFMLIAMgATsB3AEgA0ECNgLsASADQbC//gA2AugBIANCATcC9AEgA0HGCzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBwL/+ABDvLAALIABBEjsBAAxRCyAAQZICOwEADFALIABBkgQ7AQAMTwsgAEGSBjsBAAxOCyABQQhqIgQgAUEEaiIBSQ00IAIgBEkNNSADIAI2AjQgAyAFNgIwIAMgASAFaigAACABajYCOCADQegBaiICIANBMGoQ8ANB0ABBCBCtNiIBRQ1VIAFCgYCAgBA3AwAgAUEIaiACQcgA/AoAACAAQRs6AAAgACABNgIEDE0LIAFBCGoiBCABQQRqIgFJDTUgAiAESQ02IAMgAjYCNCADIAU2AjAgAyABIAVqKAAAIAFqNgI4IANB6AFqIgIgA0EwahDwA0HQAEEIEK02IgFFDVQgAUKBgICAEDcDACABQQhqIAJByAD8CgAAIABBHjoAACAAIAE2AgQMTAsgBiAIaiIGIAVLDTYgBCAGai0AAEEQRw1IIANBADYC6AEgA0EwaiIIIAFBCiADQegBaiIFELwUIAMoAjAiBEUNSCALKAAARQ1UIAJBCGoiASACQQRqIgZJDTcgASAHSw04IAMoAjghASADKAI0IQIgAyAHNgI0IAMgCTYCMCADIAYgCWooAAAgBmo2AjggBSAIEPADQdAAQQgQrTYiBkUNUyAGQoGAgIAQNwMAIAZBCGogBUHIAPwKAAAgAUEEaiEIIAFBe0sNOSACIAhJDTogBSAEIAIgASABIARqKAAAaxD2NCAAIAVBBBDMIEH//wNxIgUEfyABIAVqIgEgAksNUyABIARqKAAABUEACzYCBCAAIAY2AgggAEEdOgAADEsLIANBADYC+AEgA0EBNgLsASADQYDA/gA2AugBIANCBDcC8AEgA0HoAWpBiMH+ABDvLAALIANBADYC6AEgA0EwaiABQQ4gA0HoAWoiAhC8FAJ/IAMoAjAiBARAIAMoAjgiASADKAI0IgVLDVUgAyAFNgLsASADIAFBBGo2AvABIAMgBDYC6AEgAyABIARqKAAANgL0ASMAQTBrIgEkACABQSBqIAJBCGopAgA3AwAgASACKQIANwMYIAFBDGohBCMAQSBrIgIkAAJAAkACQCABQRhqIgkiBRD/FCIHBEAgAkEQaiIGQQQgBSgCDEEBaiIIQX8gCBsiCCAIQQRNG0EAQQRBBBCgGCACKAIUIQggAigCEEEBRg0CIAIoAhgiCiAHNgIAIAJBDGoiC0EBNgIAIAIgCjYCCCACIAg2AgQgAkEYaiAFQQhqKQIANwMAIAIgBSkCADcDECAGEP8UIggEQCACQQRqIQUDQCAFKAIIIgcgBSgCAEYEQCAFIAYoAgxBAWoiCkF/IAobEIAuCyAFKAIEIAdBAnRqIAg2AgAgBSAHQQFqNgIIIAYQ/xQiCA0ACwsgBEEIaiALKAIANgIAIAQgAikCBDcCAAwBCyAEQQA2AgggBEKAgICAwAA3AgALIAJBIGokAAwBCyAIIAIoAhhBjID/ABD9LwALIAEoAgwhBiABKAIQIQIgASABKAIUIgU2AhggASAFQQJ0IgUgCRC/ISABKAIAIQQgASgCBCEIIAUEQCAEQQhqIAIgBfwKAAALIAFBADYCJCABIAI2AhwgASAGNgIYIAEgAUEvajYCICABQRhqIgIQxicgAhDpOyADQRhqIgIgCDYCBCACIAQ2AgAgAUEwaiQAIAMoAhghBSADKAIcDAELIANBEGoQwSwgAygCECEFIAMoAhQLIQEgACAFNgIEIABBIDoAACAAIAE2AggMSQsgAUEIaiICIAFBBGoiBkkNOCACIAVLDTkgAyAFNgLsASADIAQ2AugBIAMgBCAGaigAACAGajYC8AEgA0FAayIGIANB6AFqIgcQ8AMgCCgAAEEBTQ1RIAFBDGoiASACSQ06IAEgBUsNOyADIAU2AuwBIAMgBDYC6AEgAyACIARqKAAAIAJqNgLwASADQYgBaiIFIAcQ8ANB0ABBCBCtNiIBRQ1QIAFCgYCAgBA3AwAgAUEIaiAGQcgA/AoAAEHQAEEIEK02IgJFDVAgAkKBgICAEDcDACACQQhqIAVByAD8CgAAIAAgAjYCCCAAIAE2AgQgAEEoOgAADEgLIAFBCGoiByABQQRqIgFJDTsgBCAHSQ08IAMgBDYCNCADIAg2AjAgAyABIAhqKAAAIAFqNgI4IANB6AFqIgEgA0EwahDwA0HQAEEIEK02IghFDU8gCEKBgICAEDcDACAIQQhqIAFByAD8CgAAIAJBBGohBCACQXtLDT0gBCAFSw1JIAEgBiAFIAIgAiAGaigAAGsQ9jQgACABQQQQzCBB//8DcSIBBH8gASACaiICIAVLDUsgAiAGai0AAEEARwVBAAs6AAEgACAINgIEIABBJzoAAAxHC0GLASABdkEBcUUNQiAAIAU6AAIgACAHOgABIABCo8iAqIKAgIAmIAFBA3StiDwAAAxGC0EACyETIANBADYC2AEgA0KAgICAgAE3AtABIANBADYC6AEgA0HcAWogAUEOIANB6AFqELwUAkAgAygC3AEiCUUNACADKALkASIBIAMoAuABIgdLDTwgASAJaiILKAAAIgxFDQAgAUEEaiECQQAhBQNAIAUgCygAAE8NTyACQXtLDT8gAkEEaiIBIAdLDUAgAyAHNgI0IAMgCTYCMCADIAIgAiAJaigAAGo2AjggA0HoAWogA0EwahDwAyADKALYASICIAMoAtABRgRAIANB0AFqQczD/gAQtygLIAMoAtQBIAJByABsaiADQegBakHIAPwKAAAgAyACQQFqNgLYASABIQIgDCAFQQFqIgVHDQALCyADQegBaiICIAYgBCAIIAooAABrEPY0An8gAkEGEMwgQf//A3EiAQRAIAEgCGoiAUEEaiEFIAFBe0sNPiAEIAVJDUEgASAGaigAACABaiIBIARLDUogAyAENgLsASADIAFBBGo2AvABIAMgBjYC6AEgAyABIAZqKAAANgL0ASADQThqIANB2AFqKAIANgIAIAMgAykC0AE3AzAjAEHQAGsiBSQAIANBMGoiBCgCACEGIAQoAgQhASAEKAIIIQQgBUIANwMYIAVCADcDECAFQShqIAJBCGopAgA3AwAgBUIANwJEIAUgASAEQcgAbGo2AkAgBSAGNgI8IAUgATYCOCAFIAE2AjQgBSACKQIANwMgIAUgBUEQajYCMCMAQdAAayICJAAgAkEgaiIBIAVBIGpBLPwKAAAgAkEUaiEJIwBBQGoiBCQAIAQgARDfDgJAAkACQCAEKAIEIgoEQCAELQAAIQsgBEEUaiIGQQMgASgCICABKAIYa0HIAG4iCCABKAIMIgcgByAISxsiCCAIQQNNG0EBakEAQQRBCBCgGCAEKAIYIQggBCgCFEEBRg0CIAQoAhwiByAKNgIEIAcgCzoAACAEQRBqIg5BATYCACAEIAc2AgwgBCAINgIIIAYgAUEs/AoAACMAQRBrIggkACAIQQhqIAYQ3w4gCCgCDCIKBEAgBEEIaiEHIAgtAAghCwNAIAcoAggiDCAHKAIARgRAIAcgBigCICAGKAIYa0HIAG4iDSAGKAIMIhAgDSAQSRtBAWoQ/y0LIAcoAgQgDEEDdGoiDSAKNgIEIA0gCzoAACAHIAxBAWo2AgggCCAGEN8OIAgtAAAhCyAIKAIEIgoNAAsLIAZBFGoQ0BwgCEEQaiQAIAlBCGogDigCADYCACAJIAQpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBFGoQ0BwLIARBQGskAAwBCyAIIAQoAhxBjID/ABD9LwALIAIoAhQhCCACKAIYIQQgAiACKAIcIgY2AiAgAkEIaiAGQQN0IgYgARC/ISACKAIIIQEgAigCDCEHIAYEQCABQQhqIAQgBvwKAAALIAJBADYCLCACIAQ2AiQgAiAINgIgIAIgAkHPAGo2AiggAkEgaiIEEN8mIAQQ6jsgBUEIaiIEIAc2AgQgBCABNgIAIAJB0ABqJAAgA0EoaiAFKQMINwMAIAVB0ABqJAAgAygCKCEFIAMoAiwMAQsgA0HwAWogA0HYAWooAgAiBTYCACADIAMpAtABNwPoASMAQUBqIgckACADQegBaiICKAIAIQQgAigCBCEBIAIoAgghAiAHQgA3AxggB0IANwMQIAdCADcDOCAHIAEgAkHIAGxqNgI0IAcgBDYCMCAHIAE2AiwgByABNgIoIAcgB0EQaq0gBa1C/wGDQiiGhDcDICMAQUBqIgYkACAGQTBqIAdBIGoiAUEYaikCADcDACAGQShqIAFBEGopAgA3AwAgBkEgaiABQQhqKQIANwMAIAYgASkCADcDGCAGQQxqIQsjAEHwAGsiBCQAAkACQAJAAkACQCAGQRhqIhAiAiwABCIIIAIsAAUiCU4NACACIAhBAWoiCjoABCAEIAg6AB8gBEIBQgAgCEH/AHEQxiMgAigCACIBKQMAIhggBCkDACIZgyABKQMIIhogBCkDCCIbg4RQRQ0CIAEgGCAZhDcDACABIBogG4Q3AwggAigCDCIFIAIoAhQiDEYNACACIAVByABqIg42AgwgBSgCNCINQYCAgIB4Rg0AIARBKGoiASAFQTT8CgAAIARB6ABqIAVBQGspAwA3AwAgBCANNgJcIAQgBSkDODcDYCABENApIQ0gAUEEQQMgDCAOa0HIAG4iBSAJIArAIgprIgwgBSAMSRsiBSAFQQNNG0EBaiAJIApMG0EAQQRBCBCgGCAEKAIsIQUgBCgCKEEBRg0DIAQoAjAiCSANNgIEIAkgCDoAACAEQRhqIhRBATYCACAEIAk2AhQgBCAFNgIQIARBQGsgAkEYaikCADcDACAEQThqIAJBEGopAgA3AwAgBEEwaiACQQhqKQIANwMAIAQgAikCADcDKCAEQRBqIQkjAEHwAGsiCCQAAkACQAJAIAEsAAQiAiABLAAFIg5ODQAgAkF/cyENIAEoAgAhDCAIQeAAaiIVQQhqIRYDQCABIAJBAWoiBToABCAIIAI6AB8gCEIBQgAgAkH/AHEQxiMgDCkDACIYIAgpAwAiGYMgDCkDCCIaIAgpAwgiG4OEUEUNAiAMIBggGYQ3AwAgDCAaIBuENwMIIAEoAgwiCiABKAIUIg9GDQEgASAKQcgAaiIRNgIMIAooAjQiEkGAgICAeEYNASAIQShqIhcgCkE0/AoAACAWIApBQGspAwA3AwAgFSAKKQM4NwMAIAggEjYCXCAXENApIRIgCSgCCCIKIAkoAgBGBEAgCUEBIA8gEWtByABuIg8gDSAOaiIRIA8gEUkbQQFqIAUgDk4bEP8tCyAJKAIEIApBA3RqIg8gEjYCBCAPIAI6AAAgCSAKQQFqNgIIIA1BAWshDSAFIgIgDkcNAAsLIAFBCGoQ0BwgCEHwAGokAAwBCyAIQQE2AiwgCEH07f4ANgIoIAhCATcCNCAIQfQLNgIkIAggCEEgajYCMCAIIAhBH2o2AiAgCEEoakH87f4AEO8sAAsgC0EIaiAUKAIANgIAIAsgBCkCEDcCAAwBCyALQQA2AgggC0KAgICAwAA3AgAgAkEIahDQHAsgBEHwAGokAAwCCyAEQQE2AiwgBEH07f4ANgIoIARCATcCNCAEQfQLNgIkIAQgBEEgajYCMCAEIARBH2o2AiAgBEEoakH87f4AEO8sAAsgBSAEKAIwQYyA/wAQ/S8ACyAGKAIMIQQgBigCECEBIAYgBigCFCICNgIYIAYgAkEDdCICIBAQvyEgBigCACEFIAYoAgQhCCACBEAgBUEIaiABIAL8CgAACyAGQQA2AiQgBiABNgIcIAYgBDYCGCAGIAZBP2o2AiAgBkEYaiIBEN8mIAEQ6jsgB0EIaiIBIAg2AgQgASAFNgIAIAZBQGskACADQSBqIAcpAwg3AwAgB0FAayQAIAMoAiAhBSADKAIkCyEBIAAgBTYCBCAAIBM6AAEgAEEhOgAAIAAgATYCCAxECyAGIARBkLn+ABCxOwALIAcgCUGAuf4AELE7AAsgCSAFQYC5/gAQsDsACyACIAZBkLn+ABCxOwALIAYgBUGQuf4AELA7AAsgAiAGQYC5/gAQsTsACyACIAZBkLn+ABCxOwALIAYgBUGQuf4AELA7AAsgBiAFQfS1/gAQrzsAC0EEQQwQoz0AC0EEQQwQoz0AC0Hcuv4AELI7AAsgBSABQZC5/gAQsTsACyABIARBkLn+ABCwOwALIAIgBEH0tf4AEK87AAtBzLv+ABCyOwALQdy7/gAQsjsAC0G0vP4AELI7AAtB/Lz+ABCyOwALIAIgAUGQuf4AELE7AAsgASAFQZC5/gAQsDsAC0Hgvf4AELI7AAtBrL7+ABCyOwALQYS//gAQsjsAC0HQv/4AELI7AAtBmMD+ABCyOwALQejA/gAQsjsACyACIAdB9LX+ABCvOwALQZjB/gAQsjsAC0H8wf4AELI7AAtBjML+ABCyOwALQdTC/gAQsjsACyACIARBkLn+ABCxOwALIAQgAUGQuf4AELA7AAsgBiABQfS1/gAQrzsACyAGIAFB9LX+ABCvOwALQYS4/gBBKyADQegBakH0t/4AQeTC/gAQ1R4ACyACIAFB9LX+ABCvOwALQYS4/gBBKyADQegBakH0t/4AQfTC/gAQ1R4AC0G8w/4AELI7AAsgCCACQZC5/gAQsTsACyACIARBkLn+ABCwOwALIAIgBEH0tf4AEK87AAsgASAEQYC5/gAQsTsACyAEIAJBgLn+ABCwOwALIAEgBEGAuf4AELE7AAsgBCACQYC5/gAQsDsACyAGIAVB9LX+ABCvOwALIAYgAUGAuf4AELE7AAsgASAHQYC5/gAQsDsACyABIAhBkLn+ABCxOwALIAggAkGQuf4AELA7AAsgBiACQYC5/gAQsTsACyACIAVBgLn+ABCwOwALIAIgAUGAuf4AELE7AAsgASAFQYC5/gAQsDsACyABIAdBgLn+ABCxOwALIAcgBEGAuf4AELA7AAsgAiAEQZC5/gAQsTsACyABIAdB9LX+ABCvOwALIAEgBUGAuf4AELE7AAsgAiACQQRqQYC5/gAQsTsACyACQQRqIAdBgLn+ABCwOwALIAUgBEGAuf4AELA7AAsgA0EBNgLsASADQaTD/gA2AugBIANCATcC9AEgA0GcAzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBrMP+ABDvLAALQfjA/gAQsjsACyAAIAc2AgggACAGNgIEIAAgAjoAASAAQQ06AAAMAQsgAyACOwHgASADIAE2AtwBIANBAzYC7AEgA0G4vf4ANgLoASADQgI3AvQBIANBxgs2AjwgAyADQeABajYCOCADQZwDNgI0IAMgA0EwajYC8AEgAyADQdwBajYCMCADQegBakHQvf4AEO8sAAsgA0GwAmokAA8LIAMgBzoA3AEgA0ECNgLsASADQaTE/gA2AugBIANCATcC9AEgA0HLCzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBtMT+ABDvLAALIAQgBUGQuf4AELA7AAsgAiAFQfS1/gAQrzsACyABIARB9LX+ABCvOwALIAEgBEGQuf4AELE7AAsgBCACQZC5/gAQsDsACyABIAJB9LX+ABCvOwALQQhB0AAQoz0AC0GEtv4AQSJBqLb+ABCfKQALIAEgBUH0tf4AEK87AAu4TwIHfwN+IwBB4ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASACKAIcIgYRBAAiBS0AAEECaw4lARsaGRgXFhUUExIAAAAAABEQAAAAAAAAAAAAAAAAAAAADw4NDAALIAEgBhEEACIFLQAAQQ1rDg0JCAcGBQoKBAoDCgIBCgsgASACEPIhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgBEE4aiEHIAIoAhAhCCACKAIUIQMCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQE2AgggBiABIAhqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMHQsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwbCwwcCyABIAIQmCIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ8RYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwdCwwZCyABIAIQmSIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ/xYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwcCwwYCyABIAIQliIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ8hYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwbCwwXCyABIAIQlyIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQgBcgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwaCwwWCwJAAkAgBS0AAUECaw4CAAEGCyAAIAEgAhDlISADEM0LDBYLIAAgASACEO0hIAMQzQsMFQsCQAJAIAUtAAEOAgABBQsgACABIAIQ/iEgAxDOCwwVCyAAIAEgAhDxISADEM4LDBQLIAAgASACEPohIAMQzQsMEwsgACABIAIQ/yEgAxDOCwwSCwJAAkACQAJAIAUtAAFBAWsOAwECAwALIAAgASACEPYhIAMQzQsMFAsgACABIAIQ6SEgAxDNCwwTCyAAIAEgAhDmISADEM0LDBILIAAgASACEPkhIAMQzQsMEQsgASAGEQQAIQAgBEGnBDYCVCAEIAA2AgwgBEECNgIcIARByLWDATYCGCAEQgE3AiQgBCAEQQxqNgJQIAQgBEHQAGo2AiAgBEEYakHYtYMBEO8sAAsgASACEOMhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEFdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQSA2AgggBiAIIAFBBXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMEgsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwQCwwRCyABIAIQ/CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQR2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBEDYCCCAGIAggAUEEdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwRCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADA8LDBALIAEgAhDoISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBA3YhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEINgIIIAYgCCABQQN0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDBALIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMDgsMDwsgASACEOQhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEECdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQQ2AgggBiAIIAFBAnRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMDwsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwNCwwOCwJAAkACQCAFLQABQQFrDgIBAgALIAAgASACEIAiIAMQzgsMDQsgACABIAIQ6yEgAxDNCwwMCyABIAIQ/SEhBSMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCECAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASACNgIMIAYgAxDINCAFKAIUQQR2IQMgAUE4aiEIIAUoAhAhCQJAA0ACQCABKQNAIgxQRQRAIAEpA0ghCwwBCwNAAn4CQCABKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgASALUK1CAYY3AyggC6dBAXFFDQAgASABKQMwNwNYDAELIAEoAjhFDQEgAUHQAGogCBC2KiABKQNQIQsLIAtCAFINAgsgAUIDNwMoCyABKQMYIgtCAlENBSABQgA3AxggASkDIAwBCyABKQNYCyEMIAunQQFxRQ0DIAEgASkDSEJAfSILNwNIIAEgDDcDQCAMUA0ACwsgASAMQgEgDHoiDYaFNwNAIAUgDacgC6dqIgIQizshCiACIANJBEAgASgCFCIGIAEoAgxGBEAgAUEMakH4tIMBEJAoCyABKAIQIAZBDGxqIgdBEDYCCCAHIAkgAkEEdGpBACAKGzYCBCAHIAI2AgAgASAGQQFqNgIUDAELCyACIANB6LSDARDDIQALIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCyACIAEoAiBB2LSDARD9LwALDAsLAkACQAJAAkAgBS0AAUEBaw4DAQIDAAsgACABIAIQ6iEgAxDNCwwNCyAAIAEgAhDnISADEM0LDAwLIAAgASACEIEiIAMQzQsMCwsgACABIAIQ7iEgAxDNCwwKCyABIAIQgiIhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQN2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBCDYCCCAGIAggAUEDdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwMCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAoLDAsLIAEgAhDvISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBAnYhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEENgIIIAYgCCABQQJ0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAsLIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMCQsMCgsgASACEPQhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEBdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQI2AgggBiAIIAFBAXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMCgsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwICwwJCyABIAIQ7CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQN2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBCDYCCCAGIAggAUEDdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwJCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAcLDAgLIAEgAhD1ISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBAnYhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEENgIIIAYgCCABQQJ0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAgLIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMBgsMBwsgASACEPAhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEBdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQI2AgggBiAIIAFBAXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMBwsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwFCwwGCyABIAIQ9yEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCAEQThqIQcgAigCECEIIAIoAhQhAwJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBATYCCCAGIAEgCGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwGCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAQLDAULIAEgAhDzISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBA3YhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEINgIIIAYgCCABQQN0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAULIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMAwsMBAsgASACEPshIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEECdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQQ2AgggBiAIIAFBAnRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMBAsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwCCwwDCyABIAIQ+CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRg0CIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQF2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBAjYCCCAGIAggAUEBdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwCCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIACyAEQeAAaiQADwsgASADQei0gwEQwyEACyABIAQoAiBB2LSDARD9LwALIAUgASgCIEHotYMBEP0vAAuOUgIJfwR+IwBB8ARrIgQkACAEIAI2AhQgBCACQShqIgc2AhgCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAoIgVBFGsOFQUEBQIFBQILAQcLAQgJCgEBAQELDAALIAVFDQILIARB2AFqIAEgAhDxFSAEKALcASECIAQoAtgBIgNBk4CAgHhGDQsgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgAjYCBCAAIAM2AgAMEAsgAygCDCICBEAgAyACQQFrNgIMIAMgAygCCCIFQQFqIgcgAygCACIGQQAgBiAHTRtrNgIIIAMoAgQgBUEDdGopAwBCAnwhDQsgBEECNgLcASAEQdzW/gA2AtgBIARCATcC5AEgBEGnBDYCvAIgBCAEQbgCajYC4AEgBCAEQRhqNgK4AiAEQfwAaiAEQdgBahCZDiAEQYyAgIB4NgJ4IAINAyAEKQJ8IQ0gACAEKQKEATcCDCAAIA03AgQgAEGMgICAeDYCAAwPCyAEQdgBaiABIAIQ8RUgBCgC3AEhAiAEKALYASIDQZOAgIB4RwRAIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAI2AgQgACADNgIADA8LIAQgAikAACINNwPgAyAEIAIpAAgiDjcD6AMgDSAOUQRAIARBlARqIAcQxgYgBEIANwLIBCAEQQA2ArAEIARBADYCpAQgBCANPgKgBCAEQgQ3AowEIARCADcChAQgBEKAgICAwAA3AvwDIARBADYC9AMgACABIARB9ANqEMsQDA8LIARBAzYCfCAEQaDW/gA2AnggBEIDNwKEASAEQe4GNgLsASAEQe4GNgLkASAEQdILNgLcASAEIARB2AFqNgKAASAEIARB4ANqNgLoASAEIARB6ANqNgLgASAEIARBFGo2AtgBIARBuAJqIQMjAEEQayIBJAAgBEH4AGoiAigCDCEFAkACQAJAAkACQAJAAkAgAigCBA4CAAECCyAFDQFBASEFQQAhAgwCCyAFDQAgAigCACIFKAIEIQIgBSgCACEFDAELIAMgAhCZDgwBCyABQQRqIAJBAEEBQQEQoBggASgCCCEHIAEoAgRBAUYNASABKAIMIQYgAgRAIAYgBSAC/AoAAAsgAyACNgIIIAMgBjYCBCADIAc2AgALIAFBEGokAAwBCyAHIAEoAgxBnNX+ABD9LwALIABBhYCAgHg2AgAgACAEKQK4AjcCBCAAQQxqIARBwAJqKAIANgIADA4LIARB2AFqIAEgAhDxFSAEKALcASECIAQoAtgBIgNBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgAjYCBCAAIAM2AgAMDgsgBEH4AGogARCIFiAEQegEaiIDIARBhAFqIgUoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADA4LIARB2ARqIAMoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIDIAUoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgVBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAU2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNDiAEQdAEahD7HgwOCyAEQeQBaiIDIAQpA7gCNwIAIANBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgACABIAIgByAEQdgBaiICQQIQ6wZBACEAA0AgAigCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAhD7HgsgAEEBcUEBIQAgAyECRQ0ACwwNCyAEQdgBaiABIAIQ8RUgBCgC3AEhAiAEKALYASIDQZOAgIB4RwRAIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAI2AgQgACADNgIADA0LIARB+ABqIAEQiBYgBEGoA2oiAyAEQYQBaiIFKAIANgIAIAQgBCkCfDcDoAMgBCgCeCIGQZOAgIB4RwRAIAQoAogBIQEgACAEKQOgAzcCBCAAIAE2AhAgACAGNgIAIABBDGogAygCADYCAAwNCyAEQZADaiADKAIANgIAIAQgBCkDoAM3A4gDIARB+ABqIAEQiBYgBEHoBGoiAyAFKAIANgIAIAQgBCkCfDcD4AQgBCgCeCIFQZOAgIB4RwRAIAQoAogBIQEgACAEKQPgBDcCBCAAIAE2AhAgACAFNgIAIABBDGogAygCADYCACAEKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQ0gBEGIA2oQ+x4MDQsgBEHYBGogBEHoBGoiBSgCADYCACAEIAQpA+AENwPQBCAEQfgAaiABEIgWIARBwAJqIgMgBEGEAWooAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQdAEahD7HgsgBCgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0NIARBiANqEPseDA0LIARB+AFqIAMoAgA2AgAgBEHgAWogBEGQA2ooAgA2AgAgBEHsAWogBSgCADYCACAEIAQpA7gCNwPwASAEIAQpA4gDNwPYASAEIAQpA+AENwLkASAAIAEgAiAHIARB2AFqIgBBAxDrBkEAIQEDQCAAIAFqIgIoAgAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAIQ+x4LIAFBDGoiAUEkRw0ACwwMCyAEQfgAaiIHEIgRIAQgATYC6AEgBCANNwPgASAEQgA3A9gBIwBBQGoiAyQAIANBk4CAgHg2AgAgA0EwaiAEQdgBaiICQRBqKQMANwMAIANBKGogAkEIaikDADcDACADIAIpAwA3AyAgAyADNgI4IANBFGohCCMAQUBqIgIkACACQRRqIANBIGoiBRDqJAJAAkACQCACKAIUBEAgAkEgaiIJIAUQ2hkgCUEEIAIoAiBBAWoiBkF/IAYbIgYgBkEETRtBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgogAikCFDcCACAKQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAKNgIMIAIgBjYCCCACQThqIAVBGGopAwA3AwAgAkEwaiAFQRBqKQMANwMAIAJBKGogBUEIaikDADcDACACIAUpAwA3AyAjAEEgayIFJAAgBUEIaiAJEOokIAUoAggEQCACQQhqIQYDQCAGKAIIIgogBigCAEYEQCAFQRRqIAkQ2hkgBiAFKAIUQQFqIgxBfyAMGxD9LQsgBigCBCAKQQxsaiIMIAUpAgg3AgAgDEEIaiAFQRBqKAIANgIAIAYgCkEBajYCCCAFQQhqIAkQ6iQgBSgCCA0ACwsgBUEgaiQAIAhBCGogCygCADYCACAIIAIpAgg3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyACQUBrJAAMAQsgBiACKAIoQZT2/gAQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgByADKQIANwIAIAdBEGogA0EQaigCADYCACAHQQhqIANBCGopAgA3AgAgCBDFJyAIEOg7DAELIAcgAykCFDcCBCAHQZOAgIB4NgIAIAdBDGogA0EcaigCADYCAAsgA0FAayQAIARBwAJqIgIgBEGEAWooAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgNBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAM2AgAgAEEMaiACKAIANgIADAwLIARB6ARqIAIoAgA2AgAgBCAEKQO4AjcD4AQgBEHYAWogASAEKAIUEPEVIAQoAtwBIQIgBCgC2AEiA0GTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACACNgIEIAAgAzYCACAEQeAEaiIAEMUnIAAQ6DsMDAsgACABIAIgBCgCGCAEKALkBCAEKALoBBDrBiAEQeAEaiIAEMUnIAAQ6DsMCwsgBEHYAWogASACEPEVIAQoAtwBIQUgBCgC2AEiBkGTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAFNgIEIAAgBjYCAAwLCyAEQdgBaiABEIgWIARBgAFqIgYgBEHkAWooAgA2AgAgBCAEKQLcATcDeCAEKALYASIIQZOAgIB4RwRAIAQoAugBIQEgACAEKQN4NwIEIAAgATYCECAAIAg2AgAgAEEMaiAGKAIANgIADAsLIARBwAJqIAYoAgA2AgAgBCAEKQN4NwO4AiAEQdgBaiABIAIoAjBBCGogAxCOASAEKALgASECIAQoAtwBIQMgBCgC2AEiBkGTgICAeEcEQCAAIAQpAuQBNwIMIAAgAjYCCCAAIAM2AgQgACAGNgIAIAQoArgCIgAgACgCACIAQQFrNgIAIABBAUcNCyAEQbgCahD7HgwLCyAAIAEgBSAHIARBuAJqIgBBASADIAIQrwogBCgCuAIiASABKAIAIgFBAWs2AgAgAUEBRw0KIAAQ+x4MCgsgBEHYAWogASACEPEVIAQoAtwBIQggBCgC2AEiBUGTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAINgIEIAAgBTYCAAwKCyAEQdgBaiABEIgWIARBgAFqIgUgBEHkAWooAgA2AgAgBCAEKQLcATcDeCAEKALYASIHQZOAgIB4RwRAIAQoAugBIQEgACAEKQN4NwIEIAAgATYCECAAIAc2AgAgAEEMaiAFKAIANgIADAoLIARB6ARqIAUoAgA2AgAgBCAEKQN4NwPgBCAEQQA2AsACIARCgICAgMAANwK4AiAEIAJBLGoiBRCvLiAEKAIAIgIgBCgCBCIKRwRAA0AgBEHYAWogASACKAIAQQhqIAMQjgEgBCgC4AEhByAEKALcASEGIAQoAtgBIglBk4CAgHhHBEAgACAEKQLkATcCDCAAIAc2AgggACAGNgIEIAAgCTYCACAEQbgCaiIAEMMnIAAQ6jsgBCgC4AQiACAAKAIAIgBBAWs2AgAgAEEBRw0MIARB4ARqEPseDAwLIAQoAsACIgkgBCgCuAJGBEAgBEG4AmpB7Nb+ABCbKAsgBCgCvAIgCUEDdGoiCyAHNgIEIAsgBjYCACAEIAlBAWo2AsACIAJBBGoiAiAKRw0ACwsgBEGAAWogBEHoBGooAgA2AgAgBCAEKQPgBDcDeCAEQeABaiAEQcACaigCADYCACAEIAQpArgCNwPYASAEQfgAaiEJIAUhAiAEQdgBaiEHIwBB0AFrIgUkACAFIAgoAAgiBjYCACABLQBEIQMgCCgAACEIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBgRAIAVBBGogCUEAIAgQ8hUgA0EBcUUNASAFQSBqIAVBEGopAgA3AwAgBSAFKQIINwMYIAUoAgQhASAHKAIIDQMMCAsgBygCCA0BQQAhAQwHCyAFQbgBaiIBIAVBBGoQ4ScgBiAFKALMASIDRwRAIAUgAzYCqAEgBUEDNgJ4IAVBuNv+ADYCdCAFQgI3AoABIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCfCAFIAVBqAFqNgJoIAUgBTYCYCAAQQRqIAVB9ABqEJkOIABBjYCAgHg2AgAgBSgCuAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIAcQwycgBxDqOwwJCyAFQSBqIAVBxAFqKQIANwMAIAUgBSkCvAE3AxggBSgCuAEhASAHKAIIRQ0GDAILQQAhASADQQFxRQ0BCyACKAIAIgMgAygCACIIQQFqNgIAIAhBAEgNCCACKAIEIQIgBUHAAWogB0EIaigCADYCACAFIAcpAgA3A7gBIAVBgAFqIAVBIGopAwA3AgAgBSABNgJ0IAUgBSkDGDcCeCAFIAY2AogBIAVBLGohASAFQfQAaiEHIAVBuAFqIggoAghFBEBBiPaFAUHPAEHY9oUBEMskAAsgCCgCBCIKKAIAIAooAgQiCigCCEEBa0F4cWpBCGogCigCJBEEACEKIAEgAjYCFCABIAM2AhAgAUEgOgAMIAEgCjYCGCABIAcpAgA3AhwgAUEkaiAHQQhqKQIANwIAIAFBLGogB0EQaikCADcCACABIAgpAgA3AgAgAUEIaiAIQQhqKAIANgIADAELIAIoAgAiAyADKAIAIghBAWo2AgAgCEEASA0HIAIoAgQhAiAFQbABaiAHQQhqKAIANgIAIAUgBykCADcDqAEgBUHEAWogBUEgaikDADcCACAFIAE2ArgBIAUgBSkDGDcCvAEgBSAGNgLMASAFQfQAaiADIAIgBUGoAWogBUG4AWoQ5Q8gBUHoAGoiASAFQYABaikCADcDACAFQfAAaiICIAVBiAFqKAIANgIAIAUgBSkCeDcDYCAFKAJ0IgNBgICAgHhGDQEgBUHcAGogBUGkAWooAgA2AgAgBUHUAGogBUGcAWopAgA3AgAgBUHMAGogBUGUAWopAgA3AgAgBUE4aiABKQMANwIAIAVBQGsgAigCADYCACAFIAUpAowBNwJEIAUgBSkDYDcCMCAFIAM2AiwLQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAFQSxqQTT8CgAAIABB0Nv+ADYCCCAAIAE2AgQgAEGTgICAeDYCACAGDQQMAwsgACAFKQNgNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBkUNAgwDC0EEQTwQoz0ACyAFQcQBaiAFQSBqKQMANwIAIAUgATYCuAEgBSAFKQMYNwK8ASAFIAY2AswBIAVB9ABqIgIgCCAFQbgBahDVGEE8QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQdDb/gA2AgggACABNgIEIABBk4CAgHg2AgAgBxDDJyAHEOo7IAYNAQsgCSgCACIAIAAoAgAiAEEBazYCACAAQQFHDQAgCRD7HgsgBUHQAWokAAwCC0EEQTwQoz0LAAsMCQsgBEHYAWogASACEPEVIAQoAtwBIQUgBCgC2AEiB0GTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAFNgIEIAAgBzYCAAwJCyAFKAAAIQUCQCABLgFAQQNKDQAgBEHYAWogARCIFiAEQYABaiIHIARB5AFqKAIANgIAIAQgBCkC3AE3A3ggBCgC2AEiBkGTgICAeEcEQCAEKALoASEBIAAgBCkDeDcCBCAAIAE2AhAgACAGNgIAIABBDGogBygCADYCAAwKCyAEQcACaiAHKAIANgIAIAQgBCkDeCINNwO4AiANpyIHIAcoAgAiB0EBazYCACAHQQFHDQAgBEG4AmoQ+x4LIARB2AFqIAEQiBYgBEGAAWoiByAEQeQBaigCADYCACAEIAQpAtwBNwN4IAQoAtgBIgZBk4CAgHhHBEAgBCgC6AEhASAAIAQpA3g3AgQgACABNgIQIAAgBjYCACAAQQxqIAcoAgA2AgAMCQsgBEHAAmogBygCADYCACAEIAQpA3g3A7gCIARB4ARqIgcgBEG4AmoiBkEAIAUQ5hUgBEH8AmogBxDjGSAEKAK4AiIHIAcoAgAiB0EBazYCACAHQQFGBEAgBhD7HgsCQCAEKAIYLQABQQFGBEAgBEHYAWogARCIFiAEQYABaiIHIARB5AFqKAIANgIAIAQgBCkC3AE3A3ggBCgC2AEiBkGTgICAeEYNASAEKALoASEBIAAgBCkDeDcCBCAAIAE2AhAgACAGNgIAIABBDGogBygCADYCAAwJCyAEQQA2AogDDAYLIARBwAJqIAcoAgA2AgAgBCAEKQN4NwO4AiAEQeAEaiIHIARBuAJqIgZBACAFQQJ0EOYVIARBlANqIAcQ5RkgBCgCuAIiBSAFKAIAIgVBAWs2AgAgBUEBRgRAIAYQ+x4LIARBkANqIARBnANqKAIANgIAIAQgBCkClAM3A4gDDAULIARB2AFqIAEgAhDxFSAEKALcASEIIAQoAtgBIgJBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgCDYCBCAAIAI2AgAMCAsgBEHYAWogARCIFiAEQegEaiICIARB5AFqIgMoAgA2AgAgBCAEKQLcATcD4AQgBCgC2AEiBUGTgICAeEcEQCAEKALoASEBIAAgBCkD4AQ3AgQgACABNgIQIAAgBTYCACAAQQxqIAIoAgA2AgAMCAsgBEHYBGogAigCADYCACAEIAQpA+AENwPQBCAEQdgBaiABEIgWIARBwAJqIgIgAygCADYCACAEIAQpAtwBNwO4AiAEKALYASIDQZOAgIB4RwRAIAQoAugBIQEgACAEKQO4AjcCBCAAIAE2AhAgACADNgIAIABBDGogAigCADYCACAEKALQBCIAIAAoAgAiAEEBazYCACAAQQFHDQggBEHQBGoQ+x4MCAsgBEGEAWoiAyAEKQO4AjcCACADQQhqIARBwAJqKAIANgIAIARBgAFqIARB6ARqKAIANgIAIAQgBCkD4AQ3A3ggBEHYAWohBSAEKAIUIgItAChBIkcEfkIABSACKQMgIQ1CAQshDiAEQRRqIQkjAEFAaiICJABBASEGAkAgDqdBAXEEQCAFIA03AwhBACEGDAELIAJBAjYCJCACQYzY/gA2AiAgAkIBNwIsIAJB0gs2AjwgAiAJNgI4IAIgAkE4ajYCKCACQRBqIAJBIGoQmQ4gAkGEgICAeDYCDCAFIAIpAgw3AgQgBUEMaiACQRRqKQIANwIAIAVBFGogAkEcaigCADYCAAsgBSAGNgIAIAJBQGskAAJAAkAgBCgC2AFBAUYEQCAEKALcASEBIAQpA+ABIQ0gACAEKQPoATcCDCAAIA03AgQgACABNgIADAELIAQgBCkD4AE3A7gCIARBuAJqIQlBACEFIAEoAjgiAigCDARAIAIoAgAiBkEQayELIAIoAgQiCiACQRBqIAkQjQ4iDadxIQUgDUIZiEL/AINCgYKEiJCgwIABfiEPIAkpAwAhEEEAIQICfwNAAkAgBSAGaikAACIOIA+FIg1Cf4UgDUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyINUEUEQANAIBAgCyANeqdBA3YgBWogCnEiDEEEdGspAwBRDQIgDUIBfSANgyINUEUNAAsLQQAgDiAOQgGGg0KAgYKEiJCgwIB/g1BFDQIaIAUgAkEIaiICaiAKcSEFDAELCyAGQQAgDGtBBHRqCyICQRBrQQAgAhshBQsgBEHYAWohBiMAQUBqIgIkAAJAIAVBCGpBACAFGyIFBEAgBkGTgICAeDYCACAGIAU2AgQMAQsgAkEBNgIkIAJBzNj+ADYCICACQgE3AiwgAkHuBjYCPCACIAk2AjggAiACQThqNgIoIAJBEGogAkEgahCZDiACQYSAgIB4NgIMIAYgAikCDDcCACAGQQhqIAJBFGopAgA3AgAgBkEQaiACQRxqKAIANgIACyACQUBrJAAgBCgC3AEhBSAEKALYASICQZOAgIB4Rg0BIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAU2AgQgACACNgIACyAEQfgAaiECQQAhAANAIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQ+x4LIABBAXFBASEAIAMhAkUNAAsMCAsgBSgCACIGIAYoAgAiAkEBajYCACACQQBIDQUgBEH4AGohAiAFKAIEIQkjAEHwAmsiBSQAIAUgBzYCBAJAAkAgBy0AAEEiRgRAIAgpAAghDSACKAIAIgcgBygCACIKQQFqNgIAIApBAEgNASAFIAc2AtABIAUgAikCBDcC1AECQCANQgBXBEAgByAHKAIAIgdBAWs2AgAgBUEANgIIIAdBAUcNASAFQdABahD7HgwBCyAFQRBqIAVB2AFqKAIANgIAIAUgBSkC0AE3AwgLIAVB8AFqIAUoAgQQxgYgBUEAOwGoAiAFQQA2AqQCIAVBADYCjAIgBUEANgKAAiAFQgQ3AugBIAVCADcC4AEgBUKAgICAwAA3AtgBIAVBADYC0AEgBSAIKQAAPgL8ASACKAIMIgcgBygCACIIQQFqNgIAIAhBAEgNASAFIAc2AqwCIAUgAikCEDcCsAIgBUH0AGoiCiAFQdABaiIHIAVBrAJqIggQ+iMgCCAGIAkQ0yMgByAKIAgQ7yUgBUEYaiIGIAcgBUEIahCuFiAFIA0+AhwgBUEBNgIYIAAgASAGEMsQIAVB8AJqJAAMAgsgBUEBNgLUASAFQfjc/gA2AtABIAVCATcC3AEgBUGvAzYCeCAFIAVB9ABqNgLYASAFIAVBBGo2AnQgBUHQAWpBgN3+ABDvLAsAC0EAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACADIQJFDQALDAcLIARB2AFqIAEgAhDxFSAEKALcASEGIAQoAtgBIgVBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgBjYCBCAAIAU2AgAMBwsgBEH4AGogARCIFiAEQegEaiIFIARBhAFqIggoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IglBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAk2AgAgAEEMaiAFKAIANgIADAcLIARB2ARqIAUoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIFIAgoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IghBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAg2AgAgAEEMaiAFKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNByAEQdAEahD7HgwHCyAEQeQBaiIFIAQpA7gCNwIAIAVBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgBEH4AGogASACKAIsQQhqIAMQjgEgBCgCgAEhAyAEKAJ8IQggBCgCeCICQZOAgIB4RwRAIAAgBCkChAE3AgwgACADNgIIIAAgCDYCBCAAIAI2AgAgBEHYAWohAkEAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACAFIQJFDQALDAcLIAAgASAGIAcgBEHYAWoiAkECIAggAxCvCkEAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACAFIQJFDQALDAYLIARB2AFqIAEgAhDxFSAEKALcASEGIAQoAtgBIgVBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgBjYCBCAAIAU2AgAMBgsgBEHYAWogASACKAIsQQhqIAMQjgEgBCgC4AEhCCAEKALcASEFIAQoAtgBIglBk4CAgHhHBEAgACAEKQLkATcCDCAAIAg2AgggACAFNgIEIAAgCTYCAAwGCyAEIAg2AuQEIAQgBTYC4AQgBEHYAWogASACKAIwQQhqIAMQjgEgBCgC4AEhAiAEKALcASEDIAQoAtgBIglBk4CAgHhGDQEgACAEKQLkATcCDCAAIAI2AgggACADNgIEIAAgCTYCACAFIAUoAgAiAEEBazYCACAAQQFHDQUgBEHgBGoQuyMMBQsgBEH4AGogARCIFiAEQegEaiIDIARBhAFqIgUoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADAULIARB2ARqIAMoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIDIAUoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgVBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAU2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNBSAEQdAEahD7HgwFCyAEQeQBaiIDIAQpA7gCNwIAIANBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgACABIAIgByAEQdgBaiICQQIQ6wZBACEAA0AgAigCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAhD7HgsgAEEBcUEBIQAgAyECRQ0ACwwECyAGKQAAIQ0gBEH4AWogBxDGBiAEQgA3AqwCIARBADYClAIgBEEANgKIAiAEIA0+AoQCIARCBDcC8AEgBEIANwLoASAEQoCAgIDAADcC4AEgBEEANgLYASAEQbgCaiIHIAUgCBDTIyAEQfgAaiIIIARB2AFqIgUgBxDvJSAFIAMgAhDTIyAEQRxqIgIgCCAFEO8lIARBATYCHCAEIAYpAAg+AiAgACABIAIQyxAMAwsgAkEsaiIHKAIEIQYjAEEQayIFJAAgBUEEaiAGQQBBBEEIEKAYIAUoAgghBiAFKAIEQQFGBEAgBiAFKAIMQfzW/gAQ/S8ACyAFKAIMIQkgBEGgA2oiCEEANgIIIAggCTYCBCAIIAY2AgAgBUEQaiQAIARBCGogBxCwLgJAIAQoAggiBSAEKAIMIgpGDQADQAJAIARB2AFqIAEgBUEEaigCAEEIaiADEI4BIAQoAuABIQYgBCgC3AEhCCAEKALYASIJQZOAgIB4Rw0AIAQoAqgDIgkgBCgCoANGBEAgBEGgA2pB5Nf+ABCbKAsgBCgCpAMgCUEDdGoiCyAGNgIEIAsgCDYCACAEIAlBAWo2AqgDIAogBUEIaiIFRw0BDAILCyAAIAQpAuQBNwIMIAAgBjYCCCAAIAg2AgQgACAJNgIAIARBoANqIgAQwycgABDqOyAEKAKIAyIARQ0CIAAgACgCACIAQQFrNgIAIABBAUcNAiAEQYgDahD7HgwCCwJAAkAgAS0AREUEQCAHKAIAIgEgASgCACIDQQFqNgIAIANBAEgNAyACKAIwIQIgBEHYBGogBEGEA2ooAgA2AgAgBCAEKQL8AjcD0AQgBEHoBGogBEGQA2ooAgA2AgAgBCAEKQOIAzcD4AQgBEHAAmogBEGoA2ooAgA2AgAgBCAEKQKgAzcDuAIgBEHYAWogASACIARB0ARqIARB4ARqIARBuAJqEJEEIARBgAFqIgEgBEHkAWopAgA3AwAgBEGIAWoiAiAEQewBaigCADYCACAEIAQpAtwBNwN4IAQoAtgBIgNBgICAgHhGDQIgBEHYA2ogBEGAAmopAgA3AgAgBEHQA2ogBEH4AWopAgA3AgAgBEG8A2ogASkDADcCACAEQcQDaiACKAIANgIAIAQgBCkC8AE3AsgDIAQgBCkDeDcCtAMgBCADNgKwAwwBCyAHKAIAIgEgASgCACIDQQFqNgIAIANBAEgNAiACKAIwIQIgBEHgAWogBEGoA2ooAgA2AgAgBCAEKQKgAzcD2AEgBEGwA2ogASACIARB/AJqIARBiANqIARB2AFqEI4QCyAEQbADahDcKSEBIABBjNf+ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyAAIAQpA3g3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwCCwALIAQoAvwCIgAgACgCACIAQQFrNgIAIABBAUcNACAEQfwCahD7HgsgBEHwBGokAAv6SgIMfwJ+IwBBgAprIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A0AJBDUYEQCACQfACaiABQdACaiIJEMIGIAJB+AFqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAEpAogCIQ4gAUKAgICAwAA3A4gCIAIgDjcD8AEgAkGIAWohDCACQfABaiINIQMjAEHQAGsiBCQAAkACQAJAAkACfwJAAkACQAJAIAktAABBDUYEQCAJLQABQQFrDgMCAwQBCyAEQQA2AkggBEEBNgI8IARBmJvPADYCOCAEQgQ3AkAgBEE4akGgm88AEO8sAAtBwAAhByADKAIIIghBA3QiBUHA////B3FBQGsgBSAIQQdxGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgdFDQYLIARCADcCLCAEIAc2AiggBCAGNgIkIARBwAA2AiAgAygCBCEFIAMoAgAhCiAIBEAgBSAIQQxsaiELQQAhBiAFIQMDQCADQQhqNAIAQoCjBX4gAykCAEKAlOvcA398IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgKSQxZEGfTcAACAEIAQoAixBCGoiBjYCLCAEIAQoAjBBAWo2AjAgA0EMaiIDIAtHDQALCyAEIAU2AjwgBCAKNgI4IARBOGoiA0EEQQwQ4B4gAxCXKSAEQShqIgUoAgAhCCAEKAIsIQYgBSAEQUBrIgcpAgA3AwAgBCkDICEPIAQgBCkCODcDICAEQQA2AjAgBCAPNwJEIARBADYCQCAEIAY2AjwgBCAINgI4IAQgAxDXOyAEKAIADAMLQcAAIQcgAygCCCIIQQN0IgVBwP///wdxQUBrIAUgCEEHcRsiBkHAABDRNEUNAyAGBEAgBkHAABCtNiIHRQ0FCyAEQgA3AiwgBCAHNgIoIAQgBjYCJCAEQcAANgIgIAMoAgQhBSADKAIAIQogCARAIAUgCEEMbGohC0EAIQYgBSEDA0AgA0EIajQCAEKAuJkpfiADKQIAQsCEPX98IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgKCZh4T5L303AAAgBCAEKAIsQQhqIgY2AiwgBCAEKAIwQQFqNgIwIANBDGoiAyALRw0ACwsgBCAFNgI8IAQgCjYCOCAEQThqIgNBBEEMEOAeIAMQlykgBEEoaiIFKAIAIQggBCgCLCEGIAUgBEFAayIHKQIANwMAIAQpAyAhDyAEIAQpAjg3AyAgBEEANgIwIAQgDzcCRCAEQQA2AkAgBCAGNgI8IAQgCDYCOCAEQQhqIAMQ1zsgBCgCCAwCC0HAACEHIAMoAggiCEEDdCIFQcD///8HcUFAayAFIAhBB3EbIgZBwAAQ0TRFDQIgBgRAIAZBwAAQrTYiB0UNBAsgBEIANwIsIAQgBzYCKCAEIAY2AiQgBEHAADYCICADKAIEIQUgAygCACEKIAgEQCAFIAhBDGxqIQtBACEGIAUhAwNAIANBCGo0AgBCgMDd7sECfiADKQIAQugHf3whDyAGQQhqIgggBCgCJCIHSwRAIARBIGogB0EBdCIGIAgQxCoiByAGIAdLGxDoGSAEKAIsIgZBCGohCCAEKAIkIQcLIAcgCEkEfyAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLAUgBgsgBCgCKGogD0KAgKKd2MfJ9gJ9NwAAIAQgBCgCLEEIaiIGNgIsIAQgBCgCMEEBajYCMCADQQxqIgMgC0cNAAsLIAQgBTYCPCAEIAo2AjggBEE4aiIDQQRBDBDgHiADEJcpIARBKGoiBSgCACEIIAQoAiwhBiAFIARBQGsiBykCADcDACAEKQMgIQ8gBCAEKQI4NwMgIARBADYCMCAEIA83AkQgBEEANgJAIAQgBjYCPCAEIAg2AjggBEEQaiADENc7IAQoAhAMAQtBwAAhByADKAIIIghBA3QiBUHA////B3FBQGsgBSAIQQdxGyIGQcAAENE0RQ0BIAYEQCAGQcAAEK02IgdFDQMLIARCADcCLCAEIAc2AiggBCAGNgIkIARBwAA2AiAgAygCBCEFIAMoAgAhCiAIBEAgBSAIQQxsaiELQQAhBiAFIQMDQCADKQIAIANBCGo0AgBCgIC8isnSE358IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgIDQ0aSJ2K7uAH03AAAgBCAEKAIsQQhqIgY2AiwgBCAEKAIwQQFqNgIwIANBDGoiAyALRw0ACwsgBCAFNgI8IAQgCjYCOCAEQThqIgNBBEEMEOAeIAMQlykgBEEoaiIFKAIAIQggBCgCLCEGIAUgBEFAayIHKQIANwMAIAQpAyAhDyAEIAQpAjg3AyAgBEEANgIwIAQgDzcCRCAEQQA2AkAgBCAGNgI8IAQgCDYCOCAEQRhqIAMQ1zsgBCgCGAshBUEcQQQQrTYiA0UNAiADQoGAgIAQNwIAIAMgBCkCODcCCCAMIAY2AgggDCAFNgIEIAwgAzYCACADQRBqIAcpAgA3AgAgA0EYaiAEQcgAaigCADYCACAEQSBqEM8vIARB0ABqJAAMAwtBjJfPAEEpIARBOGpBiJjPAEG4l88AENUeAAtBwAAgBhCjPQALQQRBHBCjPQALIAJBADsBqAMgAkEANgKkAyACQQA2AowDIAJBADYCgAMgAkIENwLoAiACQgA3AuACIAJCgICAgMAANwLYAiACQQA2AtACIAIgASgCpAI2AvwCIA0gAkHQAmoiAyAMEPojIAMgARDWGCACQZQBaiIFIA0gAxCuFiACQawDaiAFEM0cIAICfwJAAkACQAJAIAEtANACQQ1GBEAgAS0A0QJBAWsOAwIDBAELIAJBADYC4AIgAkEBNgLUAiACQZzZzQA2AtACIAJCBDcC2AIgAkHQAmpBnOHNABDvLAALIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxC/E0E4QQQQrTYiA0UNGyADQoGAgIAQNwIAIANBCGogBUEw/AoAAEG83s0ADAMLIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxDGE0E4QQQQrTYiA0UNGiADQoGAgIAQNwIAIANBCGogBUEw/AoAAEGU380ADAILIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxCoE0E4QQQQrTYiA0UNGSADQoGAgIAQNwIAIANBCGogBUEw/AoAAEHs380ADAELIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxC0E0E4QQQQrTYiA0UNGCADQoGAgIAQNwIAIANBCGogBUEw/AoAAEHE4M0ACyIFNgL0AyACIAM2AvADAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJLQAAIgRBAmsOBgECMjIDBAALAkACQAJAAkAgBEEiaw4FATUaAgMACyAEQQ9GDQcMNAsgASgC2AIiBC0AAEEjaw4ECgcICRcLIAMgBSgCCEEBa0F4cWpBCGoiAyAFKAIcIgQRBAAtAABBBGsOAhkaGAsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBBEEAC0AAEEEaw4CHB0bCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0wIAJBCGogAyAFKAIQEQAAIAJB0AJqIAIoAggiAyACKAIMKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkGoBGoiBSADEJYgQThBBBCtNiIDRQ01IANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQfjizQAhBQwxCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0vIAJBEGogAyAFKAIQEQAAIAJB0AJqIAIoAhAiAyACKAIUKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkGIBWoiBSADEKIgQThBBBCtNiIDRQ00IANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQeDjzQAhBQwwCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0uIAJBGGogAyAFKAIQEQAAIAJB0AJqIAIoAhgiAyACKAIcKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkH4A2oiBSADEJwgQThBBBCtNiIDRQ0zIANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQcjkzQAhBQwvCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0tIAJBIGogAyAFKAIQEQAAIAJB0AJqIAIoAiAiAyACKAIkKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkHYBGoiBSADEJUgQThBBBCtNiIDRQ0yIANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQbDlzQAhBQwuCyADIAUoAghBAWtBeHFqQQhqIAUoAhwRBABB3OLNABC4CEUNLCACQdACaiACQfADakG0yM0AQYjmzQAQ6SMgAigC2AIhAyACKALUAiEFIAIoAtACIgRBk4CAgHhHBEAgAiACKQLcAjcCxAUgAiADNgLABSACIAU2ArwFIAIgBDYCuAUgACACQbgFahCmJQwvCyACIAM2AvQBIAIgBTYC8AEgAkHQAmogAkHwAWoiBEG0yM0AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgZBk4CAgHhHBEAgAiACKQLcAjcC2AUgAiAFNgLUBSACIAM2AtAFIAIgBjYCzAUgACACQcwFahCmJSACKALwASIAIAAoAgAiAEEBazYCACAAQQFHDS8gBBC7IwwvCyACKALwASIEIAQoAgAiBEEBazYCACAEQQFHDS0gAkHwAWoQuyMMLQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBhEEAC0AAEEEaw4CBAUDCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHCIGEQQALQAAQQRrDgIHCAYLIAMgBSgCCEEBa0F4cWpBCGoiAyAFKAIcIgYRBAAtAABBBGsOAgoLCQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBhEEAC0AAEEERg0nIAMgBhEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMKgsgAyAGEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwpCyACQTBqIAMgBSgCEBEAACACQYAJaiACKAIwIgMgAigCNCgCDBEAACADRQ0ZIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0ZIAJB0AJqIAMQmSAMAQsgAkE4aiADIAUoAhARAAAgAkGACWogAigCOCIDIAIoAjwoAgwRAAAgA0UNGSACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0ZIAJB0AJqIAMQoSALIAJB8AFqIAJB0AJqIAQtAAEgBC0AAhCiEyACLQDwASIDQSlGBEAgAkH7CGogAkGEAmooAgAiATYAACACQfMIaiACQfwBaikCACIONwAAIAJB6AdqIA43AwAgAkHwB2ogATYCACACIAIpAvQBIg43AOsIIAIgDjcD4AcgACACQeAHahCmJQwnCyACQfcIaiIFIAJBgAJqKQAANwAAIAJB8AhqIgQgAkH5AWopAAA3AwAgAkHQCGogAkGQAmopAgA3AgAgAkHYCGogAkGYAmopAgA3AgAgAkG5CGogBCkDADcAACACQcAIaiAFKQAANwAAIAIgAikA8QEiDjcD6AggAiACKQKIAjcCyAggAiAONwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgRB1N3NACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AoAIIAIgBTYC/AcgAiADNgL4ByACIAY2AvQHIAAgAkH0B2oQpiUgBBDaJAwnCyACQbAIahDaJAwlCyADIAYRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCULIAJBQGsgAyAFKAIQEQAAIAJBgAlqIAIoAkAiAyACKAJEKAIMEQAAIANFDRcgAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDRcgAkHQAmogAxCjIAwBCyACQcgAaiADIAUoAhARAAAgAkGACWogAigCSCIDIAIoAkwoAgwRAAAgA0UNFyACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0XIAJB0AJqIAMQmiALIAJB8AFqIAJB0AJqIAQtAAEgBC0AAhChEyACLQDwASIDQSlGBEAgAkH7CGogAkGEAmooAgAiATYAACACQfMIaiACQfwBaikCACIONwAAIAJBkAhqIA43AwAgAkGYCGogATYCACACIAIpAvQBIg43AOsIIAIgDjcDiAggACACQYgIahCmJQwjCyACQfcIaiIFIAJBgAJqKQAANwAAIAJB8AhqIgQgAkH5AWopAAA3AwAgAkHQCGogAkGQAmopAgA3AgAgAkHYCGogAkGYAmopAgA3AgAgAkG5CGogBCkDADcAACACQcAIaiAFKQAANwAAIAIgAikA8QEiDjcD6AggAiACKQKIAjcCyAggAiAONwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgRBnOfNACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AqgIIAIgBTYCpAggAiADNgKgCCACIAY2ApwIIAAgAkGcCGoQpiUgBBDaJAwjCyACQbAIahDaJAwhCyADIAYRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCELIAJB0ABqIAMgBSgCEBEAACACQYAJaiACKAJQIgMgAigCVCgCDBEAACADRQ0VIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0VIAJB0AJqIAMQniAMAQsgAkHYAGogAyAFKAIQEQAAIAJBgAlqIAIoAlgiAyACKAJcKAIMEQAAIANFDRUgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFSACQdACaiADEKcgCyACQfABaiACQdACaiAELQABIAQtAAIQoxMgAi0A8AEiA0EpRgRAIAJB+whqIAJBhAJqKAIAIgE2AAAgAkHzCGogAkH8AWopAgAiDjcAACACQbgJaiAONwMAIAJBwAlqIAE2AgAgAiACKQL0ASIONwDrCCACIA43A7AJIAAgAkGwCWoQpiUMHwsgAkH3CGoiBSACQYACaikAADcAACACQfAIaiIEIAJB+QFqKQAANwMAIAJB0AhqIAJBkAJqKQIANwIAIAJB2AhqIAJBmAJqKQIANwIAIAJBuQhqIAQpAwA3AAAgAkHACGogBSkAADcAACACIAIpAPEBIg43A+gIIAIgAikCiAI3AsgIIAIgDjcAsQggAiADOgCwCCACQdACaiACQbAIaiIEQZTozQAgCRDpIyACKALYAiEFIAIoAtQCIQMgAigC0AIiBkGTgICAeEcEQCACIAIpAtwCNwLQCSACIAU2AswJIAIgAzYCyAkgAiAGNgLECSAAIAJBxAlqEKYlIAQQ2iQMHwsgAkGwCGoQ2iQMHQsgAkHQAmogAkHwA2pBtMjNACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIEQZOAgIB4Rg0cIAIgAikC3AI3AuQJIAIgBTYC4AkgAiADNgLcCSACIAQ2AtgJIAAgAkHYCWoQpiUMHQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBBEEAEHc4s0AELgIRQ0aIAMgBBEEAC0AAEEERw0UIAJB4ABqIAMgBSgCEBEAACACQbAIaiACKAJgIgMgAigCZCgCDBEAACADRQ0TIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0TIAJB0AJqIgUgAxCZICACQfABaiAFIAEtANECIAEtANICEKITIAItAPABIgNBKUYEQCACQZMJaiACQYQCaigCACIBNgAAIAJBiwlqIAJB/AFqKQIAIg43AAAgAkHoBWogDjcDACACQfAFaiABNgIAIAIgAikC9AEiDjcAgwkgAiAONwPgBSAAIAJB4AVqEKYlDB0LIAJBjwlqIgUgAkGAAmopAAA3AAAgAkGICWoiBCACQfkBaikAADcDACACQZgGaiACQZACaikCADcCACACQaAGaiACQZgCaikCADcCACACQYEGaiAEKQMANwAAIAJBiAZqIAUpAAA3AAAgAiACKQKIAjcCkAYgAiADOgD4BSACIAIpAPEBNwD5BUHU3c0AIQUgAkH4BWoQ3CkhAwwbCyADIAQRBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADBsLIAJB6ABqIAMgBSgCEBEAACACQbAIaiACKAJoIgMgAigCbCgCDBEAACADRQ0TIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0TIAJB0AJqIAMQoyAMAQsgAkHwAGogAyAFKAIQEQAAIAJBsAhqIAIoAnAiAyACKAJ0KAIMEQAAIANFDRMgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNEyACQdACaiADEJogCyACQfABaiACQdACaiABLQDRAiABLQDSAhChEyACLQDwASIFQSlGBEAgAkGTCWogAkGEAmooAgAiATYAACACQYsJaiACQfwBaikCACIONwAAIAJBsAZqIA43AwAgAkG4BmogATYCACACIAIpAvQBIg43AIMJIAIgDjcDqAYgACACQagGahCmJQwZCyACQY8JaiIDIAJBgAJqKQAANwAAIAJBiAlqIgQgAkH5AWopAAA3AwAgAkHIBmoiBiACQZACaikCADcDACACQdAGaiIHIAJBmAJqKQIANwMAIAJB4AZqIgggBCkDADcDACACQecGaiIEIAMpAAA3AAAgAiACKQKIAjcDwAYgAiACKQDxATcD2AZBOEEEEK02IgNFDRsgAyAFOgAIIANCgYCAgBA3AgAgAyACKQPYBjcACSADIAIpA8AGNwIgIANBEWogCCkDADcAACADQRhqIAQpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGc580AIQUMFwsgAyAEEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwXCyACQfgAaiADIAUoAhARAAAgAkGwCGogAigCeCIDIAIoAnwoAgwRAAAgA0UNESACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNESACQdACaiADEKQgDAELIAJBgAFqIAMgBSgCEBEAACACQbAIaiACKAKAASIDIAIoAoQBKAIMEQAAIANFDREgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNESACQdACaiADEJsgCyACQfABaiACQdACaiABLQDRAiABLQDSAhCjEyACLQDwASIFQSlGBEAgAkGTCWogAkGEAmooAgAiATYAACACQYsJaiACQfwBaikCACIONwAAIAJB+AZqIA43AwAgAkGAB2ogATYCACACIAIpAvQBIg43AIMJIAIgDjcD8AYgACACQfAGahCmJQwVCyACQY8JaiIDIAJBgAJqKQAANwAAIAJBiAlqIgQgAkH5AWopAAA3AwAgAkGQB2oiBiACQZACaikCADcDACACQZgHaiIHIAJBmAJqKQIANwMAIAJBqAdqIgggBCkDADcDACACQa8HaiIEIAMpAAA3AAAgAiACKQKIAjcDiAcgAiACKQDxATcDoAdBOEEEEK02IgNFDRcgAyAFOgAIIANCgYCAgBA3AgAgAyACKQOgBzcACSADIAIpA4gHNwIgIANBEWogCCkDADcAACADQRhqIAQpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGU6M0AIQUMEwsgAkEANgLgAiACQQE2AtQCIAJBnNnNADYC0AIgAkIENwLYAiACQdACakGk2c0AEO8sAAtB6OLNABCyOwALQdDjzQAQsjsAC0G45M0AELI7AAtBoOXNABCyOwALQdzmzQAQsjsAC0Hs5s0AELI7AAtB/ObNABCyOwALQYznzQAQsjsAC0H0580AELI7AAtBhOjNABCyOwALQezozQAQsjsACyADIAQRBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADAcLQZjpzQAQsjsAC0Go6c0AELI7AAtBuOnNABCyOwALQcjpzQAQsjsACyACQShqIAMgBSgCEBEAACACQYAJaiACKAIoIgMgAigCLCgCDBEAAAJAIANFDQAgAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDQAgAkHQAmoiBSADEJQgIAJB8AFqIAUgBC0AASAELQACEKATIAItAPABIgNBKUYEQCACQfsIaiACQYQCaigCACIBNgAAIAJB8whqIAJB/AFqKQIAIg43AAAgAkHAB2ogDjcDACACQcgHaiABNgIAIAIgAikC9AEiDjcA6wggAiAONwO4ByAAIAJBuAdqEKYlDAQLIAJB9whqIgUgAkGAAmopAAA3AAAgAkHwCGoiBCACQfkBaikAADcDACACQdAIaiACQZACaikCADcCACACQdgIaiACQZgCaikCADcCACACQbkIaiAEKQMANwAAIAJBwAhqIAUpAAA3AAAgAiACKQDxASIONwPoCCACIAIpAogCNwLICCACIA43ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBEG8280AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgZBk4CAgHhHBEAgAiACKQLcAjcC2AcgAiAFNgLUByACIAM2AtAHIAIgBjYCzAcgACACQcwHahCmJSAEENokDAQLIAJBsAhqENokDAILQZTmzQAQsjsACyACQdACaiACQfADakG0yM0AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgRBk4CAgHhGDQAgAiACKQLcAjcC+AkgAiAFNgL0CSACIAM2AvAJIAIgBDYC7AkgACACQewJahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIQ4gAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgDjcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIQ4gAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAONwPIAiABIAQ2AsQCIAFCADcCpAIgACAFNgIIIAAgAzYCBCAAQQg2AgAgAigC8AMiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAvADIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkHwA2oQuyMLIAJBgApqJAAPC0EEQTgQoz0AC9o5Agd/AX4jAEGACmsiAiQAIAFB0AJqIQUCQAJAIAEtANACIgNBCUcEQCADQSRGDQEgAkEFOgCAAQwCCyACQQk6AIABDAELIAJBgAFqIAUQwgYLIAEpAogCIQkgAUKAgICAgAE3A4gCIAJB2AJqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAIgCTcD0AIgAkGMAWoiBCACQdACaiIDIAUQ3hggAkH4AmogAkGIAWooAgA2AgAgAiACKQKAATcC8AIgAkEAOwGoAyACQQA2AqQDIAJBADYCjAMgAkEANgKAAyACQgQ3AugCIAJCADcC4AIgAkKAgICAwAA3AtgCIAJBADYC0AIgAiABKAKkAjYC/AIgAkH0AWoiBiADIAQQ+iMgAyABENYYIAJBmAFqIgQgBiADEK4WIAJBrANqIAQQzRwCQCACAn8CQAJAAkACQAJAIAItAMQDIgNBBWsOBQIBAQEDAAsgA0EkRg0DC0HMwc0AQShBrN7NABCfKQALIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxCxE0E4QQQQrTYiA0UNAyADQoGAgIAQNwIAIANBCGogBEEw/AoAAEGk3M0ADAILIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxCuE0E4QQQQrTYiA0UNAiADQoGAgIAQNwIAIANBCGogBEEw/AoAAEH83M0ADAELIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxC3E0E4QQQQrTYiA0UNASADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHU3c0ACyIENgL0AyACIAM2AvADAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUtAAAiBkECaw4GAQIxMQMEAAsCQAJAAkACQCAGQSJrDgUBNBoCAwALIAZBD0YNBwwzCyABKALYAiIGLQAAQSNrDgQKBwgJFwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBREEAC0AAEEEaw4CGRoYCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIFEQQALQAAQQRrDgIcHRsLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS8gAiADIAQoAhARAAAgAkHQAmogAigCACIDIAIoAgQoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQagEaiIEIAMQliBBOEEEEK02IgNFDTQgA0KBgICAEDcCACADQQhqIARBMPwKAABB+OLNACEEDDALIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS4gAkEIaiADIAQoAhARAAAgAkHQAmogAigCCCIDIAIoAgwoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQYgFaiIEIAMQoiBBOEEEEK02IgNFDTMgA0KBgICAEDcCACADQQhqIARBMPwKAABB4OPNACEEDC8LIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS0gAkEQaiADIAQoAhARAAAgAkHQAmogAigCECIDIAIoAhQoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQfgDaiIEIAMQnCBBOEEEEK02IgNFDTIgA0KBgICAEDcCACADQQhqIARBMPwKAABByOTNACEEDC4LIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDSwgAkEYaiADIAQoAhARAAAgAkHQAmogAigCGCIDIAIoAhwoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQdgEaiIEIAMQlSBBOEEEEK02IgNFDTEgA0KBgICAEDcCACADQQhqIARBMPwKAABBsOXNACEEDC0LIAMgBCgCCEEBa0F4cWpBCGogBCgCHBEEAEHc4s0AELgIRQ0rIAJB0AJqIAJB8ANqQbTIzQBBiObNABDpIyACKALYAiEDIAIoAtQCIQQgAigC0AIiBkGTgICAeEcEQCACIAIpAtwCNwLEBSACIAM2AsAFIAIgBDYCvAUgAiAGNgK4BSAAIAJBuAVqEKYlDC4LIAIgAzYC+AEgAiAENgL0ASACQdACaiACQfQBaiIGQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLYBSACIAQ2AtQFIAIgAzYC0AUgAiAFNgLMBSAAIAJBzAVqEKYlIAIoAvQBIgAgACgCACIAQQFrNgIAIABBAUcNLiAGELsjDC4LIAIoAvQBIgUgBSgCACIFQQFrNgIAIAVBAUcNLCACQfQBahC7IwwsCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRrDgIEBQMLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBGsOAgcIBgsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBxEEAC0AAEEEaw4CCgsJCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRGDSYgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwpCyADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCgLIAJBKGogAyAEKAIQEQAAIAJBgAlqIAIoAigiAyACKAIsKAIMEQAAIANFDRggAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDRggAkHQAmogAxCZIAwBCyACQTBqIAMgBCgCEBEAACACQYAJaiACKAIwIgMgAigCNCgCDBEAACADRQ0YIAIpA4AJQo2j65PMtMaQ9wCFIAIpA4gJQtmr7PbZ4MX0jH+FhFBFDRggAkHQAmogAxChIAsgAkH0AWogAkHQAmogBi0AASAGLQACEKITIAItAPQBIgNBKUYEQCACQfsIaiACQYgCaigCACIBNgAAIAJB8whqIAJBgAJqKQIAIgk3AAAgAkHoB2ogCTcDACACQfAHaiABNgIAIAIgAikC+AEiCTcA6wggAiAJNwPgByAAIAJB4AdqEKYlDCYLIAJB9whqIgQgAkGEAmopAAA3AAAgAkHwCGoiBiACQf0BaikAADcDACACQdAIaiACQZQCaikCADcCACACQdgIaiACQZwCaikCADcCACACQbkIaiAGKQMANwAAIAJBwAhqIAQpAAA3AAAgAiACKQD1ASIJNwPoCCACIAIpAowCNwLICCACIAk3ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBkHU3c0AIAUQ6SMgAigC2AIhBCACKALUAiEDIAIoAtACIgVBk4CAgHhHBEAgAiACKQLcAjcCgAggAiAENgL8ByACIAM2AvgHIAIgBTYC9AcgACACQfQHahCmJSAGENokDCYLIAJBsAhqENokDCQLIAMgBxEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMJAsgAkE4aiADIAQoAhARAAAgAkGACWogAigCOCIDIAIoAjwoAgwRAAAgA0UNFiACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNFiACQdACaiADEKMgDAELIAJBQGsgAyAEKAIQEQAAIAJBgAlqIAIoAkAiAyACKAJEKAIMEQAAIANFDRYgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFiACQdACaiADEJogCyACQfQBaiACQdACaiAGLQABIAYtAAIQoRMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQZAIaiAJNwMAIAJBmAhqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A4gIIAAgAkGICGoQpiUMIgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQZznzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwKoCCACIAQ2AqQIIAIgAzYCoAggAiAFNgKcCCAAIAJBnAhqEKYlIAYQ2iQMIgsgAkGwCGoQ2iQMIAsgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwgCyACQcgAaiADIAQoAhARAAAgAkGACWogAigCSCIDIAIoAkwoAgwRAAAgA0UNFCACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNFCACQdACaiADEJ4gDAELIAJB0ABqIAMgBCgCEBEAACACQYAJaiACKAJQIgMgAigCVCgCDBEAACADRQ0UIAIpA4AJQo2j65PMtMaQ9wCFIAIpA4gJQtmr7PbZ4MX0jH+FhFBFDRQgAkHQAmogAxCnIAsgAkH0AWogAkHQAmogBi0AASAGLQACEKMTIAItAPQBIgNBKUYEQCACQfsIaiACQYgCaigCACIBNgAAIAJB8whqIAJBgAJqKQIAIgk3AAAgAkG4CWogCTcDACACQcAJaiABNgIAIAIgAikC+AEiCTcA6wggAiAJNwOwCSAAIAJBsAlqEKYlDB4LIAJB9whqIgQgAkGEAmopAAA3AAAgAkHwCGoiBiACQf0BaikAADcDACACQdAIaiACQZQCaikCADcCACACQdgIaiACQZwCaikCADcCACACQbkIaiAGKQMANwAAIAJBwAhqIAQpAAA3AAAgAiACKQD1ASIJNwPoCCACIAIpAowCNwLICCACIAk3ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBkGU6M0AIAUQ6SMgAigC2AIhBCACKALUAiEDIAIoAtACIgVBk4CAgHhHBEAgAiACKQLcAjcC0AkgAiAENgLMCSACIAM2AsgJIAIgBTYCxAkgACACQcQJahCmJSAGENokDB4LIAJBsAhqENokDBwLIAJB0AJqIAJB8ANqQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEYNGyACIAIpAtwCNwLkCSACIAQ2AuAJIAIgAzYC3AkgAiAFNgLYCSAAIAJB2AlqEKYlDBwLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgYRBABB3OLNABC4CEUNGSADIAYRBAAtAABBBEcNEyACQdgAaiADIAQoAhARAAAgAkGwCGogAigCWCIDIAIoAlwoAgwRAAAgA0UNEiACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNEiACQdACaiIEIAMQmSAgAkH0AWogBCABLQDRAiABLQDSAhCiEyACLQD0ASIDQSlGBEAgAkGTCWogAkGIAmooAgAiATYAACACQYsJaiACQYACaikCACIJNwAAIAJB6AVqIAk3AwAgAkHwBWogATYCACACIAIpAvgBIgk3AIMJIAIgCTcD4AUgACACQeAFahCmJQwcCyACQY8JaiIEIAJBhAJqKQAANwAAIAJBiAlqIgUgAkH9AWopAAA3AwAgAkGYBmogAkGUAmopAgA3AgAgAkGgBmogAkGcAmopAgA3AgAgAkGBBmogBSkDADcAACACQYgGaiAEKQAANwAAIAIgAikCjAI3ApAGIAIgAzoA+AUgAiACKQD1ATcA+QVB1N3NACEEIAJB+AVqENwpIQMMGgsgAyAFEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwaCyACQeAAaiADIAQoAhARAAAgAkGwCGogAigCYCIDIAIoAmQoAgwRAAAgA0UNEiACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNEiACQdACaiADEKMgDAELIAJB6ABqIAMgBCgCEBEAACACQbAIaiACKAJoIgMgAigCbCgCDBEAACADRQ0SIAIpA7AIQo2j65PMtMaQ9wCFIAIpA7gIQtmr7PbZ4MX0jH+FhFBFDRIgAkHQAmogAxCaIAsgAkH0AWogAkHQAmogAS0A0QIgAS0A0gIQoRMgAi0A9AEiBEEpRgRAIAJBkwlqIAJBiAJqKAIAIgE2AAAgAkGLCWogAkGAAmopAgAiCTcAACACQbAGaiAJNwMAIAJBuAZqIAE2AgAgAiACKQL4ASIJNwCDCSACIAk3A6gGIAAgAkGoBmoQpiUMGAsgAkGPCWoiAyACQYQCaikAADcAACACQYgJaiIFIAJB/QFqKQAANwMAIAJByAZqIgYgAkGUAmopAgA3AwAgAkHQBmoiByACQZwCaikCADcDACACQeAGaiIIIAUpAwA3AwAgAkHnBmoiBSADKQAANwAAIAIgAikCjAI3A8AGIAIgAikA9QE3A9gGQThBBBCtNiIDRQ0aIAMgBDoACCADQoGAgIAQNwIAIAMgAikD2AY3AAkgAyACKQPABjcCICADQRFqIAgpAwA3AAAgA0EYaiAFKQAANwAAIANBKGogBikDADcCACADQTBqIAcpAwA3AgBBnOfNACEEDBYLIAMgBREEACEBIAJBrwM2AuwIIAIgATYCpAkgAkECNgK0CCACQYjpzQA2ArAIIAJCATcCvAggAiACQaQJajYC6AggAiACQegIajYCuAggAEEEaiACQbAIahCZDiAAQQM2AgAMFgsgAkHwAGogAyAEKAIQEQAAIAJBsAhqIAIoAnAiAyACKAJ0KAIMEQAAIANFDRAgAikDsAhCpK/0+qipnZAthSACKQO4CELjrPqF49vQ9WyFhFBFDRAgAkHQAmogAxCkIAwBCyACQfgAaiADIAQoAhARAAAgAkGwCGogAigCeCIDIAIoAnwoAgwRAAAgA0UNECACKQOwCEKNo+uTzLTGkPcAhSACKQO4CELZq+z22eDF9Ix/hYRQRQ0QIAJB0AJqIAMQmyALIAJB9AFqIAJB0AJqIAEtANECIAEtANICEKMTIAItAPQBIgRBKUYEQCACQZMJaiACQYgCaigCACIBNgAAIAJBiwlqIAJBgAJqKQIAIgk3AAAgAkH4BmogCTcDACACQYAHaiABNgIAIAIgAikC+AEiCTcAgwkgAiAJNwPwBiAAIAJB8AZqEKYlDBQLIAJBjwlqIgMgAkGEAmopAAA3AAAgAkGICWoiBSACQf0BaikAADcDACACQZAHaiIGIAJBlAJqKQIANwMAIAJBmAdqIgcgAkGcAmopAgA3AwAgAkGoB2oiCCAFKQMANwMAIAJBrwdqIgUgAykAADcAACACIAIpAowCNwOIByACIAIpAPUBNwOgB0E4QQQQrTYiA0UNFiADIAQ6AAggA0KBgICAEDcCACADIAIpA6AHNwAJIAMgAikDiAc3AiAgA0ERaiAIKQMANwAAIANBGGogBSkAADcAACADQShqIAYpAwA3AgAgA0EwaiAHKQMANwIAQZTozQAhBAwSC0Ho4s0AELI7AAtB0OPNABCyOwALQbjkzQAQsjsAC0Gg5c0AELI7AAtB3ObNABCyOwALQezmzQAQsjsAC0H85s0AELI7AAtBjOfNABCyOwALQfTnzQAQsjsAC0GE6M0AELI7AAtB7OjNABCyOwALIAMgBhEEACEBIAJBrwM2AuwIIAIgATYCpAkgAkECNgK0CCACQYjpzQA2ArAIIAJCATcCvAggAiACQaQJajYC6AggAiACQegIajYCuAggAEEEaiACQbAIahCZDiAAQQM2AgAMBwtBmOnNABCyOwALQajpzQAQsjsAC0G46c0AELI7AAtByOnNABCyOwALIAJBIGogAyAEKAIQEQAAIAJBgAlqIAIoAiAiAyACKAIkKAIMEQAAAkAgA0UNACACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNACACQdACaiIEIAMQlCAgAkH0AWogBCAGLQABIAYtAAIQoBMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQcAHaiAJNwMAIAJByAdqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A7gHIAAgAkG4B2oQpiUMBAsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQbzbzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLYByACIAQ2AtQHIAIgAzYC0AcgAiAFNgLMByAAIAJBzAdqEKYlIAYQ2iQMBAsgAkGwCGoQ2iQMAgtBlObNABCyOwALIAJB0AJqIAJB8ANqQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEYNACACIAIpAtwCNwL4CSACIAQ2AvQJIAIgAzYC8AkgAiAFNgLsCSAAIAJB7AlqEKYlDAELAn9BgICAgHggASgC4AEiBUGBgICAeEYNABpBgICAgHggBUGAgICAeEYNABogASkC5AEhCSABQQA2AugBIAFCgICAgCA3A+ABIAULIQUgAUG4AmoQtDAgASAJNwK8AiABIAU2ArgCIAEoApQCIgVBgICAgHhHBEAgASkDmAIhCSABQQA2ApwCIAFCgICAgCA3ApQCCyABQcQCahC0MCABIAk3A8gCIAEgBTYCxAIgAUIANwKkAiAAIAQ2AgggACADNgIEIABBCDYCACACKALwAyIAIAAoAgAiAEEBazYCACAAQQFGDQEMAgsgAigC8AMiACAAKAIAIgBBAWs2AgAgAEEBRw0BCyACQfADahC7IwsgAkGACmokAA8LQQRBOBCjPQAL2jkCB38BfiMAQYAKayICJAAgAUHQAmohBQJAAkAgAS0A0AIiA0EIRwRAIANBI0YNASACQQQ6AIABDAILIAJBCDoAgAEMAQsgAkGAAWogBRDCBgsgASkCiAIhCSABQoCAgIDAADcDiAIgAkHYAmogAUGQAmoiAygCADYCACADQQA2AgAgAiAJNwPQAiACQYwBaiIEIAJB0AJqIgMgBRDdGCACQfgCaiACQYgBaigCADYCACACIAIpAoABNwLwAiACQQA7AagDIAJBADYCpAMgAkEANgKMAyACQQA2AoADIAJCBDcC6AIgAkIANwLgAiACQoCAgIDAADcC2AIgAkEANgLQAiACIAEoAqQCNgL8AiACQfQBaiIGIAMgBBD6IyADIAEQ1hggAkGYAWoiBCAGIAMQrhYgAkGsA2ogBBDNHAJAIAICfwJAAkACQAJAAkAgAi0AxAMiA0EEaw4FAgEBAQMACyADQSNGDQMLQczBzQBBKEGU3M0AEJ8pAAsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADEK0TQThBBBCtNiIDRQ0DIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQYzazQAMAgsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADELkTQThBBBCtNiIDRQ0CIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQeTazQAMAQsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADEMMTQThBBBCtNiIDRQ0BIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQbzbzQALIgQ2AvQDIAIgAzYC8AMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBS0AACIGQQJrDgYBAjExAwQACwJAAkACQAJAIAZBImsOBQE0GgIDAAsgBkEPRg0HDDMLIAEoAtgCIgYtAABBI2sOBAoHCAkXCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIFEQQALQAAQQRrDgIZGhgLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgURBAAtAABBBGsOAhwdGwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLyACIAMgBCgCEBEAACACQdACaiACKAIAIgMgAigCBCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJBqARqIgQgAxCWIEE4QQQQrTYiA0UNNCADQoGAgIAQNwIAIANBCGogBEEw/AoAAEH44s0AIQQMMAsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLiACQQhqIAMgBCgCEBEAACACQdACaiACKAIIIgMgAigCDCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJBiAVqIgQgAxCiIEE4QQQQrTYiA0UNMyADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHg480AIQQMLwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLSACQRBqIAMgBCgCEBEAACACQdACaiACKAIQIgMgAigCFCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJB+ANqIgQgAxCcIEE4QQQQrTYiA0UNMiADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHI5M0AIQQMLgsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLCACQRhqIAMgBCgCEBEAACACQdACaiACKAIYIgMgAigCHCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJB2ARqIgQgAxCVIEE4QQQQrTYiA0UNMSADQoGAgIAQNwIAIANBCGogBEEw/AoAAEGw5c0AIQQMLQsgAyAEKAIIQQFrQXhxakEIaiAEKAIcEQQAQdzizQAQuAhFDSsgAkHQAmogAkHwA2pBtMjNAEGI5s0AEOkjIAIoAtgCIQMgAigC1AIhBCACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AsQFIAIgAzYCwAUgAiAENgK8BSACIAY2ArgFIAAgAkG4BWoQpiUMLgsgAiADNgL4ASACIAQ2AvQBIAJB0AJqIAJB9AFqIgZBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AtgFIAIgBDYC1AUgAiADNgLQBSACIAU2AswFIAAgAkHMBWoQpiUgAigC9AEiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAYQuyMMLgsgAigC9AEiBSAFKAIAIgVBAWs2AgAgBUEBRw0sIAJB9AFqELsjDCwLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBGsOAgQFAwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBxEEAC0AAEEEaw4CBwgGCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRrDgIKCwkLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBEYNJiADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCkLIAMgBxEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMKAsgAkEoaiADIAQoAhARAAAgAkGACWogAigCKCIDIAIoAiwoAgwRAAAgA0UNGCACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNGCACQdACaiADEJkgDAELIAJBMGogAyAEKAIQEQAAIAJBgAlqIAIoAjAiAyACKAI0KAIMEQAAIANFDRggAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNGCACQdACaiADEKEgCyACQfQBaiACQdACaiAGLQABIAYtAAIQohMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQegHaiAJNwMAIAJB8AdqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A+AHIAAgAkHgB2oQpiUMJgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQdTdzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwKACCACIAQ2AvwHIAIgAzYC+AcgAiAFNgL0ByAAIAJB9AdqEKYlIAYQ2iQMJgsgAkGwCGoQ2iQMJAsgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwkCyACQThqIAMgBCgCEBEAACACQYAJaiACKAI4IgMgAigCPCgCDBEAACADRQ0WIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0WIAJB0AJqIAMQoyAMAQsgAkFAayADIAQoAhARAAAgAkGACWogAigCQCIDIAIoAkQoAgwRAAAgA0UNFiACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0WIAJB0AJqIAMQmiALIAJB9AFqIAJB0AJqIAYtAAEgBi0AAhChEyACLQD0ASIDQSlGBEAgAkH7CGogAkGIAmooAgAiATYAACACQfMIaiACQYACaikCACIJNwAAIAJBkAhqIAk3AwAgAkGYCGogATYCACACIAIpAvgBIgk3AOsIIAIgCTcDiAggACACQYgIahCmJQwiCyACQfcIaiIEIAJBhAJqKQAANwAAIAJB8AhqIgYgAkH9AWopAAA3AwAgAkHQCGogAkGUAmopAgA3AgAgAkHYCGogAkGcAmopAgA3AgAgAkG5CGogBikDADcAACACQcAIaiAEKQAANwAAIAIgAikA9QEiCTcD6AggAiACKQKMAjcCyAggAiAJNwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgZBnOfNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AqgIIAIgBDYCpAggAiADNgKgCCACIAU2ApwIIAAgAkGcCGoQpiUgBhDaJAwiCyACQbAIahDaJAwgCyADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCALIAJByABqIAMgBCgCEBEAACACQYAJaiACKAJIIgMgAigCTCgCDBEAACADRQ0UIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0UIAJB0AJqIAMQniAMAQsgAkHQAGogAyAEKAIQEQAAIAJBgAlqIAIoAlAiAyACKAJUKAIMEQAAIANFDRQgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFCACQdACaiADEKcgCyACQfQBaiACQdACaiAGLQABIAYtAAIQoxMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQbgJaiAJNwMAIAJBwAlqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A7AJIAAgAkGwCWoQpiUMHgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQZTozQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLQCSACIAQ2AswJIAIgAzYCyAkgAiAFNgLECSAAIAJBxAlqEKYlIAYQ2iQMHgsgAkGwCGoQ2iQMHAsgAkHQAmogAkHwA2pBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4Rg0bIAIgAikC3AI3AuQJIAIgBDYC4AkgAiADNgLcCSACIAU2AtgJIAAgAkHYCWoQpiUMHAsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBhEEAEHc4s0AELgIRQ0ZIAMgBhEEAC0AAEEERw0TIAJB2ABqIAMgBCgCEBEAACACQbAIaiACKAJYIgMgAigCXCgCDBEAACADRQ0SIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0SIAJB0AJqIgQgAxCZICACQfQBaiAEIAEtANECIAEtANICEKITIAItAPQBIgNBKUYEQCACQZMJaiACQYgCaigCACIBNgAAIAJBiwlqIAJBgAJqKQIAIgk3AAAgAkHoBWogCTcDACACQfAFaiABNgIAIAIgAikC+AEiCTcAgwkgAiAJNwPgBSAAIAJB4AVqEKYlDBwLIAJBjwlqIgQgAkGEAmopAAA3AAAgAkGICWoiBSACQf0BaikAADcDACACQZgGaiACQZQCaikCADcCACACQaAGaiACQZwCaikCADcCACACQYEGaiAFKQMANwAAIAJBiAZqIAQpAAA3AAAgAiACKQKMAjcCkAYgAiADOgD4BSACIAIpAPUBNwD5BUHU3c0AIQQgAkH4BWoQ3CkhAwwaCyADIAURBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADBoLIAJB4ABqIAMgBCgCEBEAACACQbAIaiACKAJgIgMgAigCZCgCDBEAACADRQ0SIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0SIAJB0AJqIAMQoyAMAQsgAkHoAGogAyAEKAIQEQAAIAJBsAhqIAIoAmgiAyACKAJsKAIMEQAAIANFDRIgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNEiACQdACaiADEJogCyACQfQBaiACQdACaiABLQDRAiABLQDSAhChEyACLQD0ASIEQSlGBEAgAkGTCWogAkGIAmooAgAiATYAACACQYsJaiACQYACaikCACIJNwAAIAJBsAZqIAk3AwAgAkG4BmogATYCACACIAIpAvgBIgk3AIMJIAIgCTcDqAYgACACQagGahCmJQwYCyACQY8JaiIDIAJBhAJqKQAANwAAIAJBiAlqIgUgAkH9AWopAAA3AwAgAkHIBmoiBiACQZQCaikCADcDACACQdAGaiIHIAJBnAJqKQIANwMAIAJB4AZqIgggBSkDADcDACACQecGaiIFIAMpAAA3AAAgAiACKQKMAjcDwAYgAiACKQD1ATcD2AZBOEEEEK02IgNFDRogAyAEOgAIIANCgYCAgBA3AgAgAyACKQPYBjcACSADIAIpA8AGNwIgIANBEWogCCkDADcAACADQRhqIAUpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGc580AIQQMFgsgAyAFEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwWCyACQfAAaiADIAQoAhARAAAgAkGwCGogAigCcCIDIAIoAnQoAgwRAAAgA0UNECACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNECACQdACaiADEKQgDAELIAJB+ABqIAMgBCgCEBEAACACQbAIaiACKAJ4IgMgAigCfCgCDBEAACADRQ0QIAIpA7AIQo2j65PMtMaQ9wCFIAIpA7gIQtmr7PbZ4MX0jH+FhFBFDRAgAkHQAmogAxCbIAsgAkH0AWogAkHQAmogAS0A0QIgAS0A0gIQoxMgAi0A9AEiBEEpRgRAIAJBkwlqIAJBiAJqKAIAIgE2AAAgAkGLCWogAkGAAmopAgAiCTcAACACQfgGaiAJNwMAIAJBgAdqIAE2AgAgAiACKQL4ASIJNwCDCSACIAk3A/AGIAAgAkHwBmoQpiUMFAsgAkGPCWoiAyACQYQCaikAADcAACACQYgJaiIFIAJB/QFqKQAANwMAIAJBkAdqIgYgAkGUAmopAgA3AwAgAkGYB2oiByACQZwCaikCADcDACACQagHaiIIIAUpAwA3AwAgAkGvB2oiBSADKQAANwAAIAIgAikCjAI3A4gHIAIgAikA9QE3A6AHQThBBBCtNiIDRQ0WIAMgBDoACCADQoGAgIAQNwIAIAMgAikDoAc3AAkgAyACKQOIBzcCICADQRFqIAgpAwA3AAAgA0EYaiAFKQAANwAAIANBKGogBikDADcCACADQTBqIAcpAwA3AgBBlOjNACEEDBILQejizQAQsjsAC0HQ480AELI7AAtBuOTNABCyOwALQaDlzQAQsjsAC0Hc5s0AELI7AAtB7ObNABCyOwALQfzmzQAQsjsAC0GM580AELI7AAtB9OfNABCyOwALQYTozQAQsjsAC0Hs6M0AELI7AAsgAyAGEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwHC0GY6c0AELI7AAtBqOnNABCyOwALQbjpzQAQsjsAC0HI6c0AELI7AAsgAkEgaiADIAQoAhARAAAgAkGACWogAigCICIDIAIoAiQoAgwRAAACQCADRQ0AIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0AIAJB0AJqIgQgAxCUICACQfQBaiAEIAYtAAEgBi0AAhCgEyACLQD0ASIDQSlGBEAgAkH7CGogAkGIAmooAgAiATYAACACQfMIaiACQYACaikCACIJNwAAIAJBwAdqIAk3AwAgAkHIB2ogATYCACACIAIpAvgBIgk3AOsIIAIgCTcDuAcgACACQbgHahCmJQwECyACQfcIaiIEIAJBhAJqKQAANwAAIAJB8AhqIgYgAkH9AWopAAA3AwAgAkHQCGogAkGUAmopAgA3AgAgAkHYCGogAkGcAmopAgA3AgAgAkG5CGogBikDADcAACACQcAIaiAEKQAANwAAIAIgAikA9QEiCTcD6AggAiACKQKMAjcCyAggAiAJNwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgZBvNvNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AtgHIAIgBDYC1AcgAiADNgLQByACIAU2AswHIAAgAkHMB2oQpiUgBhDaJAwECyACQbAIahDaJAwCC0GU5s0AELI7AAsgAkHQAmogAkHwA2pBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4Rg0AIAIgAikC3AI3AvgJIAIgBDYC9AkgAiADNgLwCSACIAU2AuwJIAAgAkHsCWoQpiUMAQsCf0GAgICAeCABKALgASIFQYGAgIB4Rg0AGkGAgICAeCAFQYCAgIB4Rg0AGiABKQLkASEJIAFBADYC6AEgAUKAgICAIDcD4AEgBQshBSABQbgCahC0MCABIAk3ArwCIAEgBTYCuAIgASgClAIiBUGAgICAeEcEQCABKQOYAiEJIAFBADYCnAIgAUKAgICAIDcClAILIAFBxAJqELQwIAEgCTcDyAIgASAFNgLEAiABQgA3AqQCIAAgBDYCCCAAIAM2AgQgAEEINgIAIAIoAvADIgAgACgCACIAQQFrNgIAIABBAUYNAQwCCyACKALwAyIAIAAoAgAiAEEBazYCACAAQQFHDQELIAJB8ANqELsjCyACQYAKaiQADwtBBEE4EKM9AAvdMQIbfwJ+IwBBgClrIgUkACAAKAIcIgYoAhAiGiAGKAI8IhhrIRkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAJIBEACQCAGLAAEQQBMBEAgGEEATg0BIAVBADYClBIgBUEBNgKIEiAFQdj5+wA2AoQSIAVCBDcCjBIgBUGEEmpB4Pn7ABDvLAALIAAoAixBAkYEQCAGQagBaiEDQv+A/58PIR0CQANAAkAgHUIBg1ANACADIARqLwEARQ0AQQAhBAwCCyAdQgGIIR0gBEEEaiIEQYABRw0AC0EBIQQgBi8BzAENACAGLwHQAQ0AIAYvAdwBDQAgBkGoAmohBEEAIQMDQCADIgJBgAdHBEAgA0EEaiEDIAIgBGovAQBFDQELCyACQYAHRyEECyAAIAQ2AiwLIAVBCGpB8ML7AEH8EfwKAABBACEEA0AgBUEIaiAEaiIDKAIAIQIgAyAEIAZqQaQBaiIDKAIANgIAIAMgAjYCACAEQQRqIgRB/BFHDQALIAUoAggiAygCBCEJIAMoAgAhCyADKAIUIQcgBUGEEmoiAkEAQbkW/AsAIAdBvgRJBEAgAiAFQQxqIgwgBxDHGSENAkACQAJAAkACQAJAIAUoAvgjIgRBAU0EQCAGKAJ4QQFrIQMgBigCfCEIIAVBgCRqIQoDQCAFIARBAWoiAjYC+CMgBUGEEmogAkECdGogDUEBaiIEQQAgDUECSCIPGyICNgIAIAJBvARLDQIgBiADNgJ4IAIgCmpBADoAACAMIAJBAnQiDmpBATsBACAJBEAgAiAJTw0YIAYgCCALIA5qLwECayIINgJ8CyAEIA0gDxshDSADQQFrIQMgBSgC+CMiBEECSQ0ACwsgBSANNgKAEiAEQQF2IQQDQCAFQYQSaiICIAxBvQQgBBD/DSAEQQFrIgQNAAsgAiAMQb0EIAcQ8AwgBSgCCCIDLwEYIQggAygCECEQIAMoAgwhEiADKAIIIRMgAygCBCEOIAMoAgAhFiAFKAKAEiEUIAVB+ChqQgA3AwAgBUHwKGpCADcDACAFQegoakIANwMAIAVCADcD4CggBSgC/CMiA0G8BEsNBQJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQQJ0IgcgAmooAgAiAkG9BEkEQEEAIQkgDCACQQJ0akECakEAOwEAAkAgA0G8BEYNACADQbwEayEEIAUgB2pBiBJqIQMgBigCfCEHIAYoAnghCwNAIAMoAgAiCkG8BEsNEyAMIApBAnQiF2oiES8BAiICQb0ETw0SIBEgDCACQQJ0akECai8BAEEBakH//wNxIhUgCCAIIBVLGyIPOwECAkAgCiAUSw0AIA9BD0sNEiAFQeAoaiAPQQF0aiICIAIvAQBBAWo7AQBBACECIAogEE8EQCAKIBBrIgIgEk8NEiACIBNqLQAAIQILIAYgES8BACIRIAIgD2psIAtqIgs2AnggDkUNACAKIA5PDR8gBiACIBYgF2ovAQJqIBFsIAdqIgc2AnwLIAkgCCAVSWohCSADQQRqIQMgBEEBaiIEDQALIAlFDQAgCEEBayECIAVB4ChqIAhBAXRqIgpBAmohByAIQRBJIQ8CQANAIAchAyACIQQDQCAEQQ9LDSQgBEEBayEEIANBBGsgA0ECayEDLwEAIg5FDQALIANBAmsgDkEBazsBACAEQQ5GDSIgAyADLwEAQQJqOwEAIA9FDSAgCiAKLwEAQQFrOwEAIAlBAmsiCUEASg0ACyAIRQ0BIAVBgBJqIQpBvQQhAwwACwNAAkAgBUHgKGogCCIHQQF0ai8BACIIRQ0AAkADQCAKIANBAnRqIQQgAyECAkADQCACQQFrIgNBvARLDQEgBCgCACEJIARBBGshBCADIQIgCSAUSw0ACyAJQbwESw0CIAwgCUECdGoiAi8BAiIEIAdHBEAgAiAHOwECIAYgCyACLwEAIgIgB2xB//8DcWogAiAEbEH//wNxayILNgJ4CyAIQQFrIghB//8DcUUNAwwBCwsMIgsgCUG9BEG89vsAEMMhAAsgB0EBayEIIAdBAUcNAAsLIAVB2ChqIAVB+ChqKQMANwMAIAVB0ChqIAVB8ChqKQMANwMAIAVByChqIAVB6ChqKQMANwMAIAUgBSkD4Cg3A8AoIAxBvQQgDSAFQcAoahCODUEAIQQDQCAFQQhqIgcgBGoiAygCACECIAMgBCAGakGkAWoiAygCADYCACADIAI2AgAgBEEEaiIEQfwRRw0ACyAHQYDV+wBB/AH8CgAAQQAhBANAIAVBCGogBGoiAygCACECIAMgBCAGakGgE2oiAygCADYCACADIAI2AgAgBEEEaiIEQfwBRw0ACyAFKAIIIgMoAgQhCSADKAIAIQsgAygCFCEHIAVBhBJqIgJBAEG5FvwLACAHQT5PDQwgAiAFQQxqIgwgBxDHGSENIAUoAvgjIgRBAU0EQCAGKAJ4QQFrIQMgBigCfCEIIAVBgCRqIQoDQCAFIARBAWoiAjYC+CMgBUGEEmogAkECdGogDUEBaiIEQQAgDUECSCIPGyICNgIAIAJBPEsNCSAGIAM2AnggAiAKakEAOgAAIAwgAkECdCIOakEBOwEAIAkEQCACIAlPDSUgBiAIIAsgDmovAQJrIgg2AnwLIAQgDSAPGyENIANBAWshAyAFKAL4IyIEQQJJDQALCyAFIA02AoACIARBAXYhBANAIAVBhBJqIgIgDEE9IAQQ/w0gBEEBayIEDQALIAIgDEE9IAcQ8AwgBSgCCCIDLwEYIQggAygCECEQIAMoAgwhEiADKAIIIRMgAygCBCEOIAMoAgAhFiAFKAKAAiEUIAVB+ChqQgA3AwAgBUHwKGpCADcDACAFQegoakIANwMAIAVCADcD4CggBSgC/CMiA0G8BEsNISADQQJ0IgcgAmooAgAiAkE9SQRAQQAhCSAMIAJBAnRqQQJqQQA7AQACQCADQbwERg0AIANBvARrIQQgBSAHakGIEmohAyAGKAJ8IQcgBigCeCELA0AgAygCACIKQTxLDQ4gDCAKQQJ0IhdqIhEvAQIiAkE9Tw0NIBEgDCACQQJ0akECai8BAEEBakH//wNxIhUgCCAIIBVLGyIPOwECAkAgCiAUSw0AIA9BD0sNDSAFQeAoaiAPQQF0aiICIAIvAQBBAWo7AQBBACECIAogEE8EQCAKIBBrIgIgEk8NDSACIBNqLQAAIQILIAYgES8BACIRIAIgD2psIAtqIgs2AnggDkUNACAKIA5PDR8gBiACIBYgF2ovAQJqIBFsIAdqIgc2AnwLIAkgCCAVSWohCSADQQRqIQMgBEEBaiIEDQALIAlFDQAgCEEBayECIAVB4ChqIAhBAXRqIgpBAmohByAIQRBJIQ8CQANAIAchAyACIQQDQCAEQQ9LDSUgBEEBayEEIANBBGsgA0ECayEDLwEAIg5FDQALIANBAmsgDkEBazsBACAEQQ5GDSMgAyADLwEAQQJqOwEAIA9FDSEgCiAKLwEAQQFrOwEAIAlBAmsiCUEASg0ACyAIRQ0BIAVBgBJqIQpBvQQhAwwACwNAAkAgBUHgKGogCCIHQQF0ai8BACIIRQ0AAkADQCAKIANBAnRqIQQgAyECAkADQCACQQFrIgNBvARLDQEgBCgCACEJIARBBGshBCADIQIgCSAUSw0ACyAJQTxLDQIgDCAJQQJ0aiICLwECIgQgB0cEQCACIAc7AQIgBiALIAIvAQAiAiAHbEH//wNxaiACIARsQf//A3FrIgs2AngLIAhBAWsiCEH//wNxRQ0DDAELCwwjCyAJQT1BvPb7ABDDIQALIAdBAWshCCAHQQFHDQALCyAFQdgoaiAFQfgoaikDADcDACAFQdAoaiAFQfAoaikDADcDACAFQcgoaiAFQegoaikDADcDACAFIAUpA+AoNwPAKCAMQT0gDSAFQcAoahCODUEAIQQDQCAFQQhqIgcgBGoiAygCACECIAMgBCAGakGgE2oiAygCADYCACADIAI2AgAgBEEEaiIEQfwBRw0ACyAGQZwVaiIDIAZBqAFqIg9BvQQgBigCnBMQ7wsgAyAGQaQTaiISQT0gBigCmBUQ7wsgB0H81vsAQaQB/AoAAEEAIQQDQCAFQQhqIARqIgMoAgAhAiADIAQgBmpBnBVqIgMoAgA2AgAgAyACNgIAIARBBGoiBEGkAUcNAAsgBSgCCCIDKAIEIQkgAygCACELIAMoAhQhByAFQYQSaiICQQBBuRb8CwAgB0EoTw0HIAIgBUEMaiIMIAcQxxkhDSAFKAL4IyIEQQFNBEAgBigCeEEBayEDIAYoAnwhCCAFQYAkaiEKA0AgBSAEQQFqIgI2AvgjIAVBhBJqIAJBAnRqIA1BAWoiBEEAIA1BAkgiDhsiAjYCACACQSZLDQQgBiADNgJ4IAIgCmpBADoAACAMIAJBAnQiEGpBATsBACAJBEAgAiAJTw0mIAYgCCALIBBqLwECayIINgJ8CyAEIA0gDhshDSADQQFrIQMgBSgC+CMiBEECSQ0ACwsgBSANNgKoASAEQQF2IQQDQCAFQYQSaiICIAxBJyAEEP8NIARBAWsiBA0ACyACIAxBJyAHEPAMIAUoAggiAy8BGCEIIAMoAhAhFCADKAIMIREgAygCCCEXIAMoAgQhECADKAIAIRsgBSgCqAEhFSAFQfgoakIANwMAIAVB8ChqQgA3AwAgBUHoKGpCADcDACAFQgA3A+AoIAUoAvwjIgNBvARLDSIgA0ECdCIHIAJqKAIAIgJBJ0kEQEEAIQkgDCACQQJ0akECakEAOwEAAkAgA0G8BEYNACADQbwEayEEIAUgB2pBiBJqIQMgBigCfCEHIAYoAnghCwNAIAMoAgAiCkEmSw0JIAwgCkECdCIcaiITLwECIgJBJ08NCCATIAwgAkECdGpBAmovAQBBAWpB//8DcSIWIAggCCAWSxsiDjsBAgJAIAogFUsNACAOQQ9LDQggBUHgKGogDkEBdGoiAiACLwEAQQFqOwEAQQAhAiAKIBRPBEAgCiAUayICIBFPDQggAiAXai0AACECCyAGIBMvAQAiEyACIA5qbCALaiILNgJ4IBBFDQAgCiAQTw0fIAYgAiAbIBxqLwECaiATbCAHaiIHNgJ8CyAJIAggFklqIQkgA0EEaiEDIARBAWoiBA0ACyAJRQ0AIAhBAWshAiAFQeAoaiAIQQF0aiIKQQJqIQcgCEEQSSEOAkADQCAHIQMgAiEEA0AgBEEPSw0mIARBAWshBCADQQRrIANBAmshAy8BACIQRQ0ACyADQQJrIBBBAWs7AQAgBEEORg0kIAMgAy8BAEECajsBACAORQ0iIAogCi8BAEEBazsBACAJQQJrIglBAEoNAAsgCEUNASAFQYASaiEKQb0EIQMMAAsDQAJAIAVB4ChqIAgiB0EBdGovAQAiCEUNAAJAA0AgCiADQQJ0aiEEIAMhAgJAA0AgAkEBayIDQbwESw0BIAQoAgAhCSAEQQRrIQQgAyECIAkgFUsNAAsgCUEmSw0CIAwgCUECdGoiAi8BAiIEIAdHBEAgAiAHOwECIAYgCyACLwEAIgIgB2xB//8DcWogAiAEbEH//wNxayILNgJ4CyAIQQFrIghB//8DcUUNAwwBCwsMJAsgCUEnQbz2+wAQwyEACyAHQQFrIQggB0EBRw0ACwsgBUHYKGogBUH4KGopAwA3AwAgBUHQKGogBUHwKGopAwA3AwAgBUHIKGogBUHoKGopAwA3AwAgBSAFKQPgKDcDwCggDEEnIA0gBUHAKGoQjg1BACEEA0AgBUEIaiAEaiIDKAIAIQIgAyAEIAZqQZwVaiIDKAIANgIAIAMgAjYCACAEQQRqIgRBpAFHDQALIAZBohVqIQdBEiEEA0ACQAJAIARBnPn7AGotAAAiA0EmTQRAIAcgA0ECdGovAQBFDQEgBCEDDAILIANBJ0HA+fsAEMMhAAtBAiEDIARBAWsiBEECSw0BCwsgBiAGKAJ4IANBA2xqIgRBEWo2AngCQCAGKAJ8QQpqQQN2IgIgBEEbakEDdiIESwRAIAYtAANBBEcNAQsgAiEECyAZQQRqIARNIBhBAE5xDRggAiAERg0ZIAZB2ABqIghBAiABEIwmAkACQCADQQFqIg1BBEkNACAGKAKcEyILQQFqIgJBgQJJDQAgBigCmBUiDEEBaiIJDQELIAVBADYClBIgBUEBNgKIEiAFQdz4+wA2AoQSIAVCBDcCjBIgBUGEEmpB5Pj7ABDvLAALAkACQAJAAkAgDUETSyACQZ4CS3IgCUEfT3JFBEAgAq1CgQJ9IR0CQCAGLQBwIgJBBWoiBEH/AXFBwABPBEAgCCAdIAQQ8BAgBi0AcCEEDAELIAYgBDoAcCAGIAYpA2ggHSACrYaENwNoCyAJrUIBfSEdAkAgBEEFaiICQf8BcUHAAE8EQCAIIB0gAhDwECAGLQBwIQIMAQsgBiACOgBwIAYgBikDaCAdIASthoQ3A2gLIA2tQgR9IR0CQCACQQRqIgRB/wFxQcAATwRAIAggHSAEEPAQDAELIAYgBDoAcCAGIAYpA2ggHSACrYaENwNoC0F/IQQDQCAEQZ35+wBqLQAAIgJBJksNAiAHIAJBAnRqMwEAIR0CQCAGLQBwIg1BA2oiAkH/AXFBwABPBEAgCCAdIAIQ8BAMAQsgBiACOgBwIAYgBikDaCAdIA2thoQ3A2gLIAMgBEEBaiIERw0ACyAIIA9BvQQgBkGgFWoiAyALENQJIAggEkE9IAMgDBDUCSAGKAJIIgMgBigCRCICSw0CIAMgA0EDcGsiDUEDTwRAIAYoAkAhBANAIARBAmotAAAhAgJAIAQvAAAiCUUEQCAIIA9BvQQgAhDJKgwBCyACQbDY+wBqLQAAIgdBHU8NBiAPIAdBAnRqIgsvAYYIIQMgCzMBhAghHSAHQdTa+wBqLQAAIgsEQCACIAdB8dr7AGotAABrrSADQT9xrYYgHYQhHSADIAtqIQMLIAlBAWsiCUH//wNxEMoqQf8BcSIHQR5PDQcgEiAHQQJ0aiILLwECIQIgCzMBACEeIAdBsNv7AGotAAAiCwRAIAkgB0EBdEHO2/sAai8BAGutQv//A4MgAkE/ca2GIB6EIR4gAiALaiECCyAeIANBP3GthiAdhCEdIAYtAHAiByACIANqaiIDQf8BcUHAAE8EQCAIIB0gAxDwEAwBCyAGIAM6AHAgBiAGKQNoIB0gB62GhDcDaAsgBEEDaiEEIA1BA2siDUECSw0ACyAAKAIcIQYLIAhBgAIgD0G9BBCrIQwfCyAFQQA2ApQSIAVBATYCiBIgBUGE+fsANgKEEiAFQgQ3AowSIAVBhBJqQYz5+wAQ7ywACyACQSdBsPn7ABDDIQALIAMgAkG0wvsAELA7AAsgBUEANgKUEiAFQQE2AogSIAVBvNr7ADYChBIgBUIENwKMEiAFQYQSakHE2vsAEO8sAAsgBUEANgKUEiAFQQE2AogSIAVBmNv7ADYChBIgBUIENwKMEiAFQYQSakGg2/sAEO8sAAsgAkEnQez1+wAQwyEACyACQT1B7PX7ABDDIQALIAJBvQRB7PX7ABDDIQALIAJBJ0G89fsAEMMhAAsgAiARQfz2+wAQwyEACyAOQRBB7Pb7ABDDIQALIAJBJ0Hc9vsAEMMhAAsgCkEnQcz2+wAQwyEACyAHQSdBrPX7ABCwOwALIAJBPUG89fsAEMMhAAsgAiASQfz2+wAQwyEACyAPQRBB7Pb7ABDDIQALIAJBPUHc9vsAEMMhAAsgCkE9Qcz2+wAQwyEACyAHQT1BrPX7ABCwOwALIAJBvQRBvPX7ABDDIQALIAIgEkH89vsAEMMhAAsgD0EQQez2+wAQwyEACyACQb0EQdz2+wAQwyEACyAKQb0EQcz2+wAQwyEACwwOCyAHQb0EQaz1+wAQsDsACyAZQQRqIBlBBWpNDQEMAgsgBkEHNgJ8IBlBfEcgGEEASHINAQsgBiAYIBogARD4DAwBCyAGQdgAaiICQQEgARCMJiAGKAJIIgMgBigCRCIESw0BIAMgA0EDcGsiA0EDTwRAIAYoAkAhBANAIARBAmotAAAhCAJAIAQvAAAiB0UEQCACQfzc+wBBoAIgCBDJKgwBCyACIAggBxC7EgsgBEEDaiEEIANBA2siA0ECSw0ACwsgAkGAAkH83PsAQaACEKshCyAGELEaIAEEQCAGQdgAahDwFQsgACgCHCIBIAEoAhA2AjwgABDiGCAFQYApaiQADwsgAyAEQbTC+wAQsDsACyAKIBBBjPf7ABDDIQALIAogDkGM9/sAEMMhAAsgCiAOQYz3+wAQwyEACyAIQRBBnPb7ABDDIQALIAJBAWtBvQRBrPb7ABDDIQALQRBBEEGM9vsAEMMhAAsgBEEQQfz1+wAQwyEACyADQb0EQdz1+wAQwyEACyACIAlBzPX7ABDDIQALuA4BCn8jAEGQAmsiCSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAyAEKAIcEQQAIgUtAABBAmsOCAABAgMEBQYHCAsgAyAEELsiIQgMDwsgAyAEEKgiIQUMDQsgAyAEELEiIQQMCwsgAyAEEKQiIQQMCQsgAyAEEKoiIQgMBwsgAyAEEK0iIQUMBQsgAyAEELciIQQMAwsgAyAEEKIiIQQMAQsgCSAFNgLQASAJQQE2AowBIAlBvP6BATYCiAEgCUIBNwKUASAJQa8DNgLsASAJIAlB6AFqNgKQASAJIAlB0AFqNgLoASAAQQRqIAlBiAFqEJkOIABBjYCAgHg2AgAMCAsgCUGIAWoiAyAEEIAVIAAgASACIAMQhwEgAxD+JAwHCyAJQYgBaiIDIAQQgBUgACABIAIgAxCIASADEP4kDAYLIwBBMGsiCCQAIAhBGGohCiAFKAIQIgMhBCADIAUoAhRBfnFqIQYjAEEgayIDJAAgA0EUaiAGIARrQQF2QQBBBEEEEKAYIAMoAhghByADKAIUQQFGBEAMBwsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIgcgBiAEa0EBdiILEIUuIAcoAgghDCAHIAQgBkcEfyALIAxqIAcoAgQgDEECdGohBgNAIAYgBC8BADYCACAEQQJqIQQgBkEEaiEGIAtBAWsiCw0ACwUgDAs2AgggCkEIaiANKAIANgIAIAogAykCCDcCACADQSBqJAAgCEEMaiIEIAoQ6BggCiAFEJI2EO4lIAlBiAFqIgMgBCAKEMcdIAhBMGokACAAIAEgAiADEIgBIAMQ/iQMBQsjAEEwayIKJAAgCkEYaiEGIAgoAhAiAyEEIAMgCCgCFGohBSMAQSBrIgMkACADQRRqIAUgBGtBAEEEQQQQoBggAygCGCEHIAMoAhRBAUYEQAwGCyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAHNgIIIANBCGoiByAFIARrIgwQhS4gBygCCCELIAcgBCAFRwR/IAUgC2ogBGsgBygCBCALQQJ0aiEFA0AgBSAELQAANgIAIARBAWohBCAFQQRqIQUgDEEBayIMDQALBSALCzYCCCAGQQhqIA0oAgA2AgAgBiADKQIINwIAIANBIGokACAKQQxqIgQgBhDoGCAGIAgQkjYQ7iUgCUGIAWoiAyAEIAYQxx0gCkEwaiQAIAAgASACIAMQiAEgAxD+JAwECyMAQTBrIgMkACAEKAIMIgUgBSgCACIIQQFqNgIAIAhBAEgEQAALIAMgBTYCGCADIAQpAhA3AhwgA0EMaiIIIANBGGoiBUEAIARBDGoQ2DwQ/hwgBSAEEJI2EO4lIAlBiAFqIgQgCCAFENkdIANBMGokACAAIAEgAiAEEIcBIAQQ/iQMAwsjAEEwayIDJAAgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIBEAACyADIAU2AhggAyAEKQIQNwIcIANBDGoiCCADQRhqIgVBACAEQQxqENs8EIAdIAUgBBCSNhDuJSAJQYgBaiIEIAggBRDHHSADQTBqJAAgACABIAIgBBCIASAEEP4kDAILIwBBMGsiCCQAIAhBGGohCiAFKAIQIgMhBCADIAUoAhRBfnFqIQYjAEEgayIDJAAgA0EUaiAGIARrQQF2QQBBBEEEEKAYIAMoAhghByADKAIUQQFGBEAMAwsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIgcgBiAEa0EBdiILEIUuIAcoAgghDCAHIAQgBkcEfyALIAxqIAcoAgQgDEECdGohBgNAIAYgBC4BADYCACAEQQJqIQQgBkEEaiEGIAtBAWsiCw0ACwUgDAs2AgggCkEIaiANKAIANgIAIAogAykCCDcCACADQSBqJAAgCEEMaiIEIAoQ6BggCiAFEJI2EO4lIAlBiAFqIgMgBCAKEMcdIAhBMGokACAAIAEgAiADEIgBIAMQ/iQMAQsjAEEwayIKJAAgCkEYaiEGIAgoAhAiAyEEIAMgCCgCFGohBSMAQSBrIgMkACADQRRqIAUgBGtBAEEEQQQQoBggAygCGCEHIAMoAhRBAUYEQAwCCyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAHNgIIIANBCGoiByAFIARrIgwQhS4gBygCCCELIAcgBCAFRwR/IAUgC2ogBGsgBygCBCALQQJ0aiEFA0AgBSAELAAANgIAIARBAWohBCAFQQRqIQUgDEEBayIMDQALBSALCzYCCCAGQQhqIA0oAgA2AgAgBiADKQIINwIAIANBIGokACAKQQxqIgQgBhDoGCAGIAgQkjYQ7iUgCUGIAWoiAyAEIAYQxx0gCkEwaiQAIAAgASACIAMQiAEgAxD+JAsgCUGQAmokAA8LIAcgAygCHEHs/YMBEP0vAAvFKgIdfwR+IwBBoAprIgMkAAJAAkACQAJAAkACQAJAIAEpAwAiIFBFBEAgASkDCCIhUEUEQCABKQMQIiJQRQRAICAgICAifCIjWARAICAgIVoEQCABLAAaIRIgAS4BGCEBIAMgID4CACADQQFBAiAgQoCAgIAQVCIGGzYCoAEgA0EAICBCIIinIAYbNgIEIANBCGpBAEGYAfwLACADICE+AqQBIANBAUECICFCgICAgBBUIgYbNgLEAiADQQAgIUIgiKcgBhs2AqgBIANBrAFqQQBBmAH8CwAgAyAiPgLIAiADQQFBAiAiQoCAgIAQVCIGGzYC6AMgA0EAICJCIIinIAYbNgLMAiADQdACakEAQZgB/AsAIANB8ANqQQBBnAH8CwAgA0EBNgLsAyADQQE2AowFIAGsICNCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciBsEhDwJAIAFBAE4EQCADIAEQtgYaIANBpAFqIAEQtgYaIANByAJqIAEQtgYaDAELIANB7ANqQQAgAWvBELYGGgsCQCAPQQBIBEAgA0EAIA9rQf//A3EiARDeBSADQaQBaiABEN4FIANByAJqIAEQ3gUMAQsgA0HsA2ogBkH//wFxEN4FCyADQfwIaiADQaQB/AoAAAJAAkACQAJAIAMoAugDIgYgAygCnAoiASABIAZJGyIEQShNBEAgBEUEQEEAIQQMBAsgBEEBcSEKIARBAUcNAQwCCwwMCyAEQT5xIQsgA0H8CGohASADQcgCaiEHA0AgASAIIAEoAgAiECAHKAIAaiIJaiIINgIAIAFBBGoiDCAMKAIAIhEgB0EEaigCAGoiDCAJIBBJIAggCUlyaiIJNgIAIAwgEUkgCSAMSXIhCCAHQQhqIQcgAUEIaiEBIAsgBUECaiIFRw0ACwsgCgR/IAVBAnQiASADQfwIamoiBSAFKAIAIgUgA0HIAmogAWooAgBqIgEgCGoiCTYCACABIAVJIAEgCUtyBSAIC0UNACAEQShGDQEgA0H8CGogBEECdGpBATYCACAEQQFqIQQLIAMgBDYCnAogBCADKAKMBSIBIAEgBEkbIgFBKUkEQCABQQJ0IQECQAJAAn8CQANAIAFFDQEgAUEEayIBIANB7ANqaigCACIEIAEgA0H8CGpqKAIAIgVGDQALIAQgBUsgBCAFSWsMAQtBf0EAIAEbCyASTgRAIAMoAqABIgVBKU8NAgJAIAVFBEBBACEFDAELIAVBAWtB/////wNxIgFBAWoiBEEDcSEHAkAgAUEDSQRAIAMhAUIAISEMAQsgBEH8////B3EhCCADIQFCACEhA0AgASABNQIAQgp+ICF8IiA+AgAgAUEEaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQhqIgQgBDUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBCAENQIAQgp+ICBCIIh8IiA+AgAgIEIgiCEhIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAhfCIgPgIAIAFBBGohASAgQiCIISEgB0EBayIHDQALCyAgQoCAgIAQVA0AIAVBKEYNESADIAVBAnRqICE+AgAgBUEBaiEFCyADIAU2AqABIAMoAsQCIgRBKU8NDSADAn9BACAERQ0AGiAEQQFrQf////8DcSIBQQFqIgVBA3EhBwJAIAFBA0kEQCADQaQBaiEBQgAhIAwBCyAFQfz///8HcSEIIANBpAFqIQFCACEgA0AgASABNQIAQgp+ICB8IiA+AgAgAUEEaiIFIAU1AgBCCn4gIEIgiHwiID4CACABQQhqIgUgBTUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBSAFNQIAQgp+ICBCIIh8IiE+AgAgIUIgiCEgIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAgfCIhPgIAIAFBBGohASAhQiCIISAgB0EBayIHDQALCyAEICFCgICAgBBUDQAaIARBKEYNESADQaQBaiAEQQJ0aiAgPgIAIARBAWoLNgLEAiADIAYEfyAGQQFrQf////8DcSIBQQFqIgRBA3EhBwJAIAFBA0kEQCADQcgCaiEBQgAhIAwBCyAEQfz///8HcSEIIANByAJqIQFCACEgA0AgASABNQIAQgp+ICB8IiA+AgAgAUEEaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQhqIgQgBDUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBCAENQIAQgp+ICBCIIh8IiE+AgAgIUIgiCEgIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAgfCIhPgIAIAFBBGohASAhQiCIISAgB0EBayIHDQALCyAhQoCAgIAQVARAIAMgBjYC6AMMAwsgBkEoRg0RIANByAJqIAZBAnRqICA+AgAgBkEBagVBAAs2AugDDAELIA9BAWohDwsgA0GQBWogA0HsA2pBpAH8CgAAIANBkAVqQQEQtgYhEyADQbQGaiIBIANB7ANqIgZBpAH8CgAAIAFBAhC2BiEUIANB2AdqIgEgBkGkAfwKAAACQAJAAkACQAJAIAFBAxC2BiIXKAKgASIRIAMoAqABIgUgBSARSRsiBkEoTQRAIANBjAVqIRggA0GwBmohGSADQdQHaiEaIBMoAqABIRUgFCgCoAEhFiADKAKMBSEQQQAhCQNAIAkhDCAGQQJ0IQECfwJAAkACQANAIAFFDQEgASAaaiEEIAFBBGsiASADaigCACIJIAQoAgAiBEYNAAsgBCAJSw0BDAILIAFFDQELIAUhBkEADAELIAYEQEEBIQhBACEFIAZBAUcEQCAGQT5xIQogAyIBQdgHaiEHA0AgASAIIAEoAgAiCyAHKAIAQX9zaiIEaiIINgIAIAFBBGoiCSAJKAIAIg0gB0EEaigCAEF/c2oiCSAEIAtJIAQgCEtyaiIENgIAIAkgDUkgBCAJSXIhCCAHQQhqIQcgAUEIaiEBIAogBUECaiIFRw0ACwsgBkEBcQR/IAMgBUECdCIBaiIEIAQoAgAiBCABIBdqKAIAQX9zaiIBIAhqIgU2AgAgASAESSABIAVLcgUgCAtFDRULIAMgBjYCoAFBCAshCiAWIAYgBiAWSRsiBEEpTw0SIARBAnQhAQJAAkACQANAIAFFDQEgASAZaiEFIAFBBGsiASADaigCACIJIAUoAgAiBUYNAAsgBSAJTQ0BIAYhBAwCCyABRQ0AIAYhBAwBCyAEBEBBASEIQQAhBSAEQQFHBEAgBEE+cSELIAMiAUG0BmohBwNAIAEgCCABKAIAIg0gBygCAEF/c2oiBmoiCDYCACABQQRqIgkgCSgCACIOIAdBBGooAgBBf3NqIgkgBiANSSAGIAhLcmoiBjYCACAJIA5JIAYgCUlyIQggB0EIaiEHIAFBCGohASALIAVBAmoiBUcNAAsLIARBAXEEfyADIAVBAnQiAWoiBiAGKAIAIgYgASAUaigCAEF/c2oiASAIaiIFNgIAIAEgBkkgASAFS3IFIAgLRQ0VCyADIAQ2AqABIApBBHIhCgsgFSAEIAQgFUkbIgZBKU8NAyAGQQJ0IQECQAJAAkADQCABRQ0BIAEgGGohBSABQQRrIgEgA2ooAgAiCSAFKAIAIgVGDQALIAUgCU0NASAEIQYMAgsgAUUNACAEIQYMAQsgBgRAQQEhCEEAIQUgBkEBRwRAIAZBPnEhCyADIgFBkAVqIQcDQCABIAggASgCACINIAcoAgBBf3NqIgRqIgg2AgAgAUEEaiIJIAkoAgAiDiAHQQRqKAIAQX9zaiIJIAQgDUkgBCAIS3JqIgQ2AgAgCSAOSSAEIAlJciEIIAdBCGohByABQQhqIQEgCyAFQQJqIgVHDQALCyAGQQFxBH8gAyAFQQJ0IgFqIgQgBCgCACIEIAEgE2ooAgBBf3NqIgEgCGoiBTYCACABIARJIAEgBUtyBSAIC0UNFQsgAyAGNgKgASAKQQJqIQoLIBAgBiAGIBBJGyIEQSlPDRIgBEECdCEBAkACQAJAA0AgAUUNASABQQRrIgEgA2ooAgAiBSABIANB7ANqaigCACIJRg0ACyAFIAlPDQEgBiEEDAILIAFFDQAgBiEEDAELIAQEQEEBIQhBACEFIARBAUcEQCAEQT5xIQsgAyIBQewDaiEHA0AgASAIIAEoAgAiDSAHKAIAQX9zaiIGaiIINgIAIAFBBGoiCSAJKAIAIg4gB0EEaigCAEF/c2oiCSAGIA1JIAYgCEtyaiIGNgIAIAkgDkkgBiAJSXIhCCAHQQhqIQcgAUEIaiEBIAsgBUECaiIFRw0ACwsgBEEBcQR/IAMgBUECdCIBaiIGIAYoAgAiBiADQewDaiABaigCAEF/c2oiASAIaiIFNgIAIAEgBkkgASAFS3IFIAgLRQ0VCyADIAQ2AqABIApBAWohCgsgDEERRg0FIAIgDGoiDSAKQTBqOgAAIAMoAsQCIgYgBCAEIAZJGyIBQSlPDRQgDEEBaiEJIAFBAnQhAQJ/AkADQCABRQ0BIAFBBGsiASADaigCACIFIAEgA0GkAWpqKAIAIgdGDQALIAUgB0sgBSAHSWsMAQtBf0EAIAEbCyEbIANB/AhqIANBpAH8CgAAIAMoAugDIgsgAygCnAoiASABIAtJGyIKQShLDQQCQCAKRQRAQQAhCgwBC0EAIQhBACEFIApBAUcEQCAKQT5xIRwgA0H8CGohASADQcgCaiEHA0AgASAIIAEoAgAiHSAHKAIAaiIOaiIeNgIAIAFBBGoiCCAIKAIAIh8gB0EEaigCAGoiCCAOIB1JIA4gHktyaiIONgIAIAggH0kgCCAOS3IhCCAHQQhqIQcgAUEIaiEBIBwgBUECaiIFRw0ACwsgCkEBcQR/IAVBAnQiASADQfwIamoiBSAFKAIAIgUgA0HIAmogAWooAgBqIgEgCGoiBzYCACABIAVJIAEgB0tyBSAIC0UNACAKQShGDRYgA0H8CGogCkECdGpBATYCACAKQQFqIQoLIAMgCjYCnAogCiAQIAogEEsbIgFBKU8NFCABQQJ0IQECfwJAA0AgAUUNASABQQRrIgEgA0HsA2pqKAIAIgUgASADQfwIamooAgAiB0YNAAsgBSAHSyAFIAdJawwBC0F/QQAgARsLIBJOIgEgEiAbSiIFRXFFBEAgAQ0SIAUNAwwRC0EAIQwgAwJ/QQAgBEUNABogBEEBa0H/////A3EiAUEBaiIFQQNxIQcCQCABQQNJBEAgAyEBQgAhIAwBCyAFQfz///8HcSEIIAMhAUIAISADQCABIAE1AgBCCn4gIHwiID4CACABQQRqIgUgBTUCAEIKfiAgQiCIfCIgPgIAIAFBCGoiBSAFNQIAQgp+ICBCIIh8IiA+AgAgAUEMaiIFIAU1AgBCCn4gIEIgiHwiIT4CACAhQiCIISAgAUEQaiEBIAhBBGsiCA0ACwsgBwRAA0AgASABNQIAQgp+ICB8IiE+AgAgAUEEaiEBICFCIIghICAHQQFrIgcNAAsLIAQgIUKAgICAEFQNABogBEEoRg0WIAMgBEECdGogID4CACAEQQFqCyIFNgKgAQJAIAZFDQAgBkEBa0H/////A3EiAUEBaiIEQQNxIQcCQCABQQNJBEAgA0GkAWohAUIAISEMAQsgBEH8////B3EhCCADQaQBaiEBQgAhIQNAIAEgATUCAEIKfiAhfCIgPgIAIAFBBGoiBCAENQIAQgp+ICBCIIh8IiA+AgAgAUEIaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQxqIgQgBDUCAEIKfiAgQiCIfCIgPgIAICBCIIghISABQRBqIQEgCEEEayIIDQALCyAHBEADQCABIAE1AgBCCn4gIXwiID4CACABQQRqIQEgIEIgiCEhIAdBAWsiBw0ACwsgIEKAgICAEFQEQCAGIQwMAQsgBkEoRg0WIANBpAFqIAZBAnRqICE+AgAgBkEBaiEMCyADIAw2AsQCAkAgC0UEQEEAIQsMAQsgC0EBa0H/////A3EiAUEBaiIGQQNxIQcCQCABQQNJBEAgA0HIAmohAUIAISAMAQsgBkH8////B3EhCCADQcgCaiEBQgAhIANAIAEgATUCAEIKfiAgfCIgPgIAIAFBBGoiBiAGNQIAQgp+ICBCIIh8IiA+AgAgAUEIaiIGIAY1AgBCCn4gIEIgiHwiID4CACABQQxqIgYgBjUCAEIKfiAgQiCIfCIhPgIAICFCIIghICABQRBqIQEgCEEEayIIDQALCyAHBEADQCABIAE1AgBCCn4gIHwiIT4CACABQQRqIQEgIUIgiCEgIAdBAWsiBw0ACwsgIUKAgICAEFQNACALQShGDRYgA0HIAmogC0ECdGogID4CACALQQFqIQsLIAMgCzYC6AMgESAFIAUgEUkbIgZBKE0NAAsLIAZBKEGQjIoBELA7AAsgA0EBELYGGiADKAKMBSIBIAMoAqABIgYgASAGSxsiAUEpTw0DIAFBAnQhASADQQRrIQYgA0HoA2ohBANAIAFFDQ0gASAEaiEFIAEgBmogAUEEayEBKAIAIgcgBSgCACIFRg0ACyAFIAdNDQ0MDgsgBkEoQZCMigEQsDsACyAKQShBkIyKARCwOwALQRFBEUHw2YkBEMMhAAsMDQsgBUEoQZCMigEQsDsACwwLCwwLC0Gg2okBQTdB2NqJARCfKQALQejaiQFBNkGg24kBEJ8pAAtBhNmJAUEcQaDZiQEQnykAC0HU2IkBQR1B9NiJARCfKQALQajYiQFBHEHE2IkBEJ8pAAsgAQ0BCyACIAlqIQRBACEHQX8hAQJAAkACQANAIAEgDEYNASABQQFqIQEgByANaiAHQQFrIgYhBy0AAEE5Rg0ACyAGIAxqIgEgAmpBAWoiBCAELQAAQQFqOgAAIAFBAmoiASAJTQ0BIAEgCUHA6okBEK87AAsgAkExOgAAIAwEQCACQQFqQTAgDPwLAAsgCUERTw0BIARBMDoAACAPQQFqIQ8gDEECaiEJDAILIAZBf0YNASAGQX9zIgFFDQEgBiANakECakEwIAH8CwAMAQsgCUERQYDaiQEQwyEACyAJQRFNBEAgACAPOwEIIAAgCTYCBCAAIAI2AgAgA0GgCmokAA8LIAlBEUGQ2okBELA7AAsgBEEoQZCMigEQsDsAC0GgjIoBQRpBkIyKARCfKQALIAFBKEGQjIoBELA7AAtBKEEoQZCMigEQwyEAC+Y5Ag5/A34jAEGQBWsiAyQAIAMgAjoALyABLQBAIQggASgCPCEEIAEoAjghCQJ/QQAgASgCDCILRQ0AGiABQRBqQZzZzwBBEBDRDCERIAEoAgAiBkEYayEMIAEoAgQiCiARp3EhBSARQhmIQv8Ag0KBgoSIkKDAgAF+IRMDQAJAIAUgBmopAAAiEiAThSIRQn+FIBFCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiEVBFBEADQEGc2c8AQRAgDEEAIBF6p0EDdiAFaiAKcWsiDUEYbGoQnzYNAiARQgF9IBGDIhFQRQ0ACwtBACASIBJCAYaDQoCBgoSIkKDAgH+DUEUNAhogBSAOQQhqIg5qIApxIQUMAQsLIANByARqIAYgDUEYbGoiB0EIaygCACAHQQRrKAIAEM8KIAMoAswEIQcgAy0AyARBf3NBAXELIQZBLCEFAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAoQQFrDigBAgMEBQYHCAkKCwwaDRscDg8QERIRExQUFR4WHR4WHxcYICAgICEZAAsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EJOgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwtCyADQQA7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCwLIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBAToA0gQgA0GIEDsB0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMKwsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EBOgDSBCADQYggOwHQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwqCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCkLIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMKAsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EAOgDSBCADQYgQOwHQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwnCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQA6ANIEIANBiCA7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCYLIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0gQgA0GIwAA7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCULIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0gQgA0GIgAE7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCQLIANBBzsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQoKAgIBwNwLkBCADQQ06ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCMLIANBBDsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMIgsgA0EFOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwhCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQU6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCALIAFBKWohBSALRQ0dIAFBEGpB9N7PAEEPENEMIREgASgCACILQRhrIQwgASgCBCIKIBGncSEBIBFCGYhC/wCDQoGChIiQoMCAAX4hE0EAIQIDQCABIAtqKQAAIhIgE4UiEUJ/hSARQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhFQRQRAA0BBAUH03s8AQQ8gDCAReqdBA3YgAWogCnFBaGxqEJ82DSEaIBFCAX0gEYMiEVBFDQALCyASIBJCAYaDQoCBgoSIkKDAgH+DUEUNHiABIAJBCGoiAmogCnEhAQwACwALIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMHgsgA0GHLDsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQoyAgIBwNwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDB0LIANBBjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMHAsgA0EHOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQn83AugEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAMgASgCLDYC5AQgACADQcgEahDlAQwbCyADQQY7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDBoLIANBBjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMGQsgA0EGOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EAOgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwYCyADQQA2AtgEIANBATYCzAQgA0GA4c8ANgLIBCADQgQ3AtAEIANByARqQYjhzwAQ7ywACyADQQA2AtgEIANBATYCzAQgA0Hw4c8ANgLIBCADQgQ3AtAEIANByARqQfjhzwAQ7ywACyADQfwEaiABQTRqEN0gIANB8ARqIAFBKGoQwwYgASkDICERIAEtAEEhAiADQcgEaiIEIAEQsS4gAyACOgCJBSADIBE3A+gEIAMgCDoAiAUgA0HoAmoiAiABKAIwEMMGIANBgARqIgEgBCACEKQrIAAgASADLQAvEJUBIAEQgy8MFQsgA0HIBGpBNUEAQQFBARCgGCADKALMBCEBIAMoAsgEQQFGDQggAygC0AQiAkH44s8AQTX8CgAAIABBNTYCFCAAIAI2AhAgACABNgIMIABBAzYCCCAAQQE2AgAMFAsgAS0AKSICRQ0QIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0J/NwLkBCADQQc6ANAEIAMgBzYCzAQgAyAGNgLIBCADQX82AuwEIAMgAkEBazoA0QQgAyABKAIsQQBHIAEoAjBBAEdxOgDSBCAAIANByARqEOUBDBMLIAJFBEAgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwTCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQU6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDBILIAEtACkiC0UNDQJ/QQAhBQJAIAEoAgxFDQAgAUEQakH03s8AQQ8Q0QwhESABKAIAIgxBGGshDSABKAIEIgogEadxIQIgEUIZiEL/AINCgYKEiJCgwIABfiETA0AgAiAMaikAACISIBOFIhFCf4UgEUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIRUEUEQANAQQFB9N7PAEEPIA0gEXqnQQN2IAJqIApxQWhsahCfNg0EGiARQgF9IBGDIhFQRQ0ACwsgEiASQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAFQQhqIgVqIApxIQIMAAsAC0EACyECIAtBAUYEQCADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADIAI6ANIEIANBBjsB0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMEgsgAyABQSlqNgLoAiADQQE2AswEIANByN/PADYCyAQgA0IBNwLUBCADQaoINgKEBCADIANBgARqNgLQBCADIANB6AJqNgKABCADQcgEakHQ388AEO8sAAtBMCEFCyABIAVqKAIAIQEgAkUNBiABKAJAIAEoAkRBvODPAEEHEMEuDQYgA0HIBGoiAiABQQhqEO0oIANBgARqIgEgAkG84M8AQQcQshsgAiABIAMtAC8QlQEgAygCyAQEQCADQcQAaiADQeAEaikDACIRNwIAIANBPGogA0HYBGopAwAiEjcCACADIAMpA9AEIhM3AjQgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIAEQgy8MEAsgA0EwaiIBIANByARqQQRyQTT8CgAAIAEQ5SkhASADQYAEahCDLwwHCyADQRBqIAFBLGoiARDDNCADKAIURQ0DIANBCGogARDDNCADKAIMIQEgAyADKAIIIgI2AoAEIAMgAiABQQJ0ajYChAQgAyADQS9qNgKIBCADQcgEaiEKIwBBQGoiAiQAIAJBCDYCCCACQThqIANBgARqIgFBCGooAgA2AgAgAiABKQIANwMwIAIgAkEIajYCPCACQSRqIQ0jAEEwayIBJAAgAUEIaiACQTBqIgUgAUEgaiILIAUoAgwQ4hICQAJAAkACQCABKAIIQQFxRQ0AIAEoAgwiDkUNACALQQRBAEEEQQQQoBggASgCJCEMIAEoAiBBAUYNAiABKAIoIg8gDjYCACABQRxqIhBBATYCACABIA82AhggASAMNgIUIAFBKGogBUEIaikCADcDACABIAUpAgA3AyAgAUEUaiEMIwBBIGsiBSQAIAVBEGogCyAFQR9qIAsoAgwQ4hICQCAFKAIQQQFxRQ0AIAUoAhQiD0UNAANAIAwoAggiDiAMKAIARgRAIAwgDkEBQQRBBBDQKAsgDCgCBCAOQQJ0aiAPNgIAIAwgDkEBajYCCCAFQQhqIAsgBUEfaiALKAIMEOISIAUoAghBAXFFDQEgBSgCDCIPDQALCyAFQSBqJAAgDUEIaiAQKAIANgIAIA0gASkCFDcCAAwBCyANQQA2AgggDUKAgICAwAA3AgALIAFBMGokAAwBCyAMIAEoAihByJfPABD9LwALAkAgAigCCEEIRwRAIAogAikDCDcDACAKQRBqIAJBGGopAwA3AwAgCkEIaiACQRBqKQMANwMAIA0QoicgDUEEQQQQ4B4MAQsgCiACKQIkNwIEIApBCDYCACAKQQxqIAJBLGooAgA2AgALIAJBQGskACADQfACaiIBIANB1ARqKAIANgIAIAMgAykCzAQ3A+gCIAMoAsgEIgJBCEcEQCADKQPYBCERIAAgAykD6AI3AgwgACARNwMYIAAgAjYCCCAAQQE2AgAgAEEUaiABKAIANgIADA8LIANBgAJqIAEoAgA2AgAgAyADKQPoAjcD+AEgA0EDOwHwBCADIAQ2AuwEIAMgCTYC6AQgA0EROgDcBCADQQA2AtgEIANCgICAgMAANwLQBCADQQA2AsgEIANBgARqIANByARqIANB+AFqEM4jIANB0AJqIANBmARqKQIANwMAIANByAJqIgEgA0GQBGopAgA3AwAgA0HAAmoiAiADQYgEaikCADcDACADQYQDaiADQdQCaigCADYCACADIAMpAoAENwO4AiADIAg6AJADIAMgAy0AqQQ6AJEDIAMgAykCoAQ3AogDIAMgAykCzAI3AvwCIANB+AJqIAEoAgA2AgAgAyACKQMANwLwAiADIAc2AuwCIAMgBjYC6AIgACADQegCahDCDgwOC0F/IQUCf0EBIAEtACkiAkECa0H/AXFBCEkNABpBAiACQRNJDQAaRAAAAAAAACRAIAIQ3iBEAAAAAAAA8D+gEOcPRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMhBUEHCyEKIANBADoA8gQgAyAKOgDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADIAI2AugEIAMgBTYC5AQgAyACNgLYBCADQQQ6ANAEIAMgBzYCzAQgAyAGNgLIBCADIAEsACoiATYC7AQgAyABNgLUBCAAIANByARqEOUBDA0LIAEoAiwiAS0AMEEgRg0CIANBADYC2AQgA0EBNgLMBCADQfDizwA2AsgEIANCBDcC0AQgAEEMaiADQcgEahCnGCAAQQE2AgAgAEEDNgIIDAwLIAEgAygC0ARB5KPPABD9LwALIANBADYC2AQgA0EBNgLMBCADQcjhzwA2AsgEIANCBDcC0AQgAEEMaiADQcgEahCnGCAAQQE2AgAgAEEDNgIIDAoLIAFBNGohBQJ/IAIEQEGI4s8AIQJBCQwBCyABKAJAIQIgASgCRAshCiADIANBL2o2AoQCIANBIGogBRDDNAJAIAMoAiQEQCADQcgEaiADQYQCakGk4s8AQQMgAygCIBCuCiADKALMBCEBIAMoAsgEIgtBCEcEQCAAIAMpA9AENwMQIABBGGogA0HYBGopAwA3AwAgACABNgIMIAAgCzYCCCAAQQE2AgAMDAsgAyABNgKIAiADQRhqIAUQwzQgAygCHCIFQQJJDQEgA0HIBGogA0GEAmpBuOLPAEEFIAMoAhhBBGoQrgogAygCzAQhBSADKALIBCILQQhHBEAgACADKQPQBDcDECAAQRhqIANB2ARqKQMANwMAIAAgBTYCDCAAIAs2AgggAEEBNgIAIAEgASgCACIAQQFrNgIAIABBAUcNDCADQYgCahCDIAwMCyADQQM7AZADIAMgBDYCjAMgAyAJNgKIAyADQRE6APwCIANBADYC+AIgA0KAgICAwAA3AvACIANBADYC6AJBBEEEEKYvIQQgA0EDOwGoBCADIAo2AqQEIAMgAjYCoAQgA0EROgCUBCADQQA2ApAEIANCgICAgMAANwKIBCADQQA2AoAEQQhBBBCmLyICIAU2AgQgAiABNgIAIANBAjYCoAEgAyACNgKcASADQQI2ApgBIANB1ANqIgEgA0GABGogA0GYAWoQziMgA0ECOgD8AyADQcgEaiABEMIOIAMoAsgEQQFGBEAgA0G0A2ogA0HgBGopAwAiETcCACADQawDaiADQdgEaikDACISNwIAIAMgAykD0AQiEzcCpAMgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIARBBEEEEPg6IANB8AJqIgAQoicgAEEEQQQQ4B4MDAsgA0GgA2oiASADQcgEakEEckE0/AoAACAEIAEQ5Sk2AgAgA0EBNgKcAyADIAQ2ApgDIANBATYClAMgA0G4AmogA0HoAmogA0GUA2oQziMgA0GcAmogA0HIAmooAgA2AgAgAyADKQLAAjcClAIgAyAIOgC0AiADQQE6AKACIAMgBzYCkAIgAyAGNgKMAiADIAMtAOECOgC1AiADIAMpAtgCNwKsAiAAIANBjAJqEMIODAsLQQBBAEGU4s8AEMMhAAtBASAFQajizwAQwyEACyADQcgEaiABQQhqIAIQlQEgAygCyAQEQCADQfgAaiADQeAEaikDACIRNwIAIANB8ABqIANB2ARqKQMAIhI3AgAgAyADKQPQBCITNwJoIABBGGogETcCACAAQRBqIBI3AgAgACATNwIIIABBATYCAAwJCyADQeQAaiICIANByARqQQRyQTT8CgAAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAACyADQQM7AeACIAMgBDYC3AIgAyAJNgLYAiADQRE6AMwCIANBADYCyAIgA0KAgICAwAA3AsACIANBADYCuAJBBEEEEK02IgJFDQEgA0EDOwGoBCADQQQ2AqQEIANBw+DPADYCoAQgA0EROgCUBCADQQA2ApAEIANCgICAgMAANwKIBCADQQA2AoAEQQRBBBCtNiIERQ0CIAQgATYCACADQYQDaiADQZQEaiIBQQhqKAIANgIAIAMgASkCADcC/AIgA0GIBGoiARCiJyABQQRBBBDgHiADQQI7AZADIANBBDYCjAMgA0HD4M8ANgKIAyADQQE2AvgCIAMgBDYC9AIgA0EBNgLwAiADQQA2AugCIANByARqIANB6AJqEMIOIAMoAsgEBEAgA0HYAWogA0HgBGopAwAiETcCACADQdABaiADQdgEaikDACISNwIAIAMgAykD0AQiEzcCyAEgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIAJBBEEEEPg6IANBwAJqIgAQoicgAEEEQQQQ4B4MCAsgA0HEAWoiASADQcgEakEEckE0/AoAACACIAEQ5Sk2AgAgA0EBNgKcAyADIAI2ApgDIANBATYClAMgA0GMAmogA0G4AmogA0GUA2oQziMgA0GoAWogA0GcAmooAgA2AgAgAyADKQKUAjcCoAEgAyAIOgDAASADQQI6AKwBIAMgBzYCnAEgAyAGNgKYASADIAMtALUCOgDBASADIAMpAqwCNwK4ASAAIANBmAFqEMIODAcLQQRBPBCjPQALQQRBBBCjPQALQQRBBBCjPQALIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMAwsgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwCC0EACyECQQEhAQJAAkACQCAFLQAAQQJrDgICAQALIAMgBTYC6AIgA0EBNgLMBCADQaTgzwA2AsgEIANCATcC1AQgA0GqCDYChAQgAyADQYAEajYC0AQgAyADQegCajYCgAQgA0HIBGpBrODPABDvLAALQQIhAQsgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgAyACOgDSBCADIAE6ANEEIANBBjoA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QELIANBkAVqJAAL+TMCDX8CfiMAQYAXayICJAACQAJAIAACfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AxAdBAWsOAwYMAAELIABBCGohDSAAQSBqIQsCQCAALQAgQQFrDgQEDAMFAAsgACgCGCEEIAApAxAhDyAAKAIMIQMgACgCCCEFDAELIABBADoAICAAIAAoArAHIgQ2AhggACAAKQMAIg83AxAgACAAKALAByIDNgIMIAAgACgCvAciBTYCCCAAQSBqIQsgAEEIaiENCyAAEOgmNgIcIAJBtAFqIgwgDyAErRDYHyACQZgNaiEGIABBHGojAEHgA2siBCQAIARByAFqIAUgAxC4GUHIt8MAKAIAIQNBxLfDACgCACEJQcC3wwAtAAAhBwJAIAQoAsgBQQJGBEBCAyEPIAQoAswBIQogA0UgB0EKSXINASAJIANBARD4OgwBC0HMt8MAKQIAIQ8gBEGQAmoQ/iwgBEHHA2pBw7fDAC0AADoAACAEIAc6AMQDIAQgDzcD0AMgBCADNgLMAyAEIAk2AsgDIARBwbfDAC8AADsAxQMgBEHQAmogBEHIAWpByAD8CgAAIARBAToA2AMgBEGAlOvcAzYCoAMgBEEANgKoAyAEQoSAgIDwADcCvAMgBCkDkAIhDyAEKAKYAiEKIARBBGogBEGcAmpBxAH8CgAACygCACIDIAMoAgAiCUEBajYCAAJAIAlBAE4EQCAGIAo2AgggBiAPNwMAIAYgAzYC0AEgBkEMaiAEQQRqQcQB/AoAACAEQeADaiQADAELAAsgAkGoAmoiBCAGQaCXwwAgDBCLDiAAQShqIgkgBEGAB/wKAAAgAEEAOgCoByAAQagHaiEKDAcLIABBKGohCSAAQagHaiEKIAAtAKgHQQFrDgMDCAcGC0Gol8MAEOgrAAsgAEEoaiEDIABBhAJqIQYCQCAALQCEAkEBaw4DBAcAEwsgAEH4AWohCSAAQYACaiEFAkAgAC0AgAJBAWsOAwMHFwALIAkoAgAhBAwVC0HYl8MAEOgrAAtBjJbDABDoKwALQdiVwwAQ6CsAC0GclsMAEOgrAAsgAEGAAmogCUHYAfwKAABCAyEPIAAoAogCIQQgACkDgAIiEEIDUQRAIAAoAtADIgYgBigCACIGQQFrNgIAIAZBAUcNDSAAQdADahCdJwwNCyACQdQLaiAAQTRqQcQB/AoAACACIAQ2AtALIAIgEDcDyAsgAkGYDWoiBSAAQdADaiACQcgLahDOEiAAQdgDaiAFQdAD/AoAAAsgAEHYA2ohDAJAAkACQCAALQCkB0EBaw4DAQMCAAsgAEEAOgClByAAQagFaiIFIAxB0AH8CgAAIAAQrz42AvgGIABB+AZqIQdB25HDACEEQQchAwJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A3AZBAWsOCgABAgMEBQYHCAkKC0HikcMAIQRBAyEDDAkLQeWRwwAhBEEEIQMMCAtB6ZHDACEEQQMhAwwHC0HskcMAIQRBBiEDDAYLQfKRwwAhBEEEIQMMBQtB9pHDACEEQQUhAwwEC0H7kcMAIQQMAwtBgpLDACEEQQUhAwwCCyACQZgBaiAAQd0GahD/LCACKAKcASEDIAIoApgBIQQMAQsgAkGgAWogAEHgBmoQ1zsgAigCpAEhAyACKAKgASEECyAHIAQgAxDtOiACQZABahDTJSACKAKUASEEAkAgAigCkAFBAXFFDQAgAkGIAWogBBCEGSACKAKMASEEIAIoAogBIgZFDQAgBiAEEPo6IQQMCgsgACAENgL8BiAAQQE6AKUHIAJB2BVqIAUQ+y4gAkHwEmogAkHgFWopAgA3AwAgAiACKQLYFTcD6BIgAkGAAWogAkHoEmoQ7RIgAigCgAEiBARAIABB/AZqIQggAigChAEhBgNAAkAgBCgCAARAIAQoAgghBSAEKAIEIQMMAQtBBiEFQeyIwwAhAwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0ABEEBaw5QAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QC0EOIQVB8ojDACEDDE8LQQ8hBUGAicMAIQMMTgtBDyEFQY+JwwAhAwxNC0ENIQVBnonDACEDDEwLQSAhBUGricMAIQMMSwtBHCEFQcuJwwAhAwxKC0EcIQVB54nDACEDDEkLQRshBUGDisMAIQMMSAtBHSEFQZ6KwwAhAwxHC0EWIQVBu4rDACEDDEYLQR4hBUHRisMAIQMMRQtBHSEFQe+KwwAhAwxEC0EDIQVBjIvDACEDDEMLQQUhBUGPi8MAIQMMQgtBByEFQZSLwwAhAwxBC0ENIQVBm4vDACEDDEALQQ0hBUGoi8MAIQMMPwtBDCEFQbWLwwAhAww+C0ERIQVBwYvDACEDDD0LQQohBUHSi8MAIQMMPAtBEyEFQdyLwwAhAww7C0EQIQVB74vDACEDDDoLQRAhBUH/i8MAIQMMOQtBDiEFQY+MwwAhAww4C0EQIQVBnYzDACEDDDcLQQ0hBUGtjMMAIQMMNgtBFyEFQbqMwwAhAww1C0EjIQVB0YzDACEDDDQLQQwhBUH0jMMAIQMMMwtBgI3DACEDDDILQQMhBUGGjcMAIQMMMQtBBCEFQYmNwwAhAwwwC0EEIQVBjY3DACEDDC8LQZGNwwAhAwwuC0EHIQVBl43DACEDDC0LQQkhBUGejcMAIQMMLAtBBCEFQaeNwwAhAwwrC0EEIQVBq43DACEDDCoLQQghBUGvjcMAIQMMKQtBESEFQbeNwwAhAwwoC0ENIQVByI3DACEDDCcLQQghBUHVjcMAIQMMJgtBEyEFQd2NwwAhAwwlC0ENIQVB8I3DACEDDCQLQQQhBUH9jcMAIQMMIwtBCCEFQYGOwwAhAwwiC0EMIQVBiY7DACEDDCELQZWOwwAhAwwgC0GbjsMAIQMMHwtBEiEFQaGOwwAhAwweC0ETIQVBs47DACEDDB0LQQ8hBUHGjsMAIQMMHAtBGyEFQdWOwwAhAwwbC0EFIQVB8I7DACEDDBoLQQchBUH1jsMAIQMMGQtBDyEFQfyOwwAhAwwYC0EHIQVBi4/DACEDDBcLQQshBUGSj8MAIQMMFgtBFCEFQZ2PwwAhAwwVC0EYIQVBsY/DACEDDBQLQREhBUHJj8MAIQMMEwtBFiEFQdqPwwAhAwwSC0EVIQVB8I/DACEDDBELQYWQwwAhAwwQC0EKIQVBi5DDACEDDA8LQRkhBUGVkMMAIQMMDgtBAiEFQa6QwwAhAwwNC0EHIQVBsJDDACEDDAwLQREhBUG3kMMAIQMMCwtBCiEFQciQwwAhAwwKC0EHIQVB0pDDACEDDAkLQRkhBUHZkMMAIQMMCAtBBCEFQfKQwwAhAwwHC0EDIQVB9pDDACEDDAYLQQchBUH5kMMAIQMMBQtBECEFQYCRwwAhAwwEC0EWIQVBkJHDACEDDAMLQRYhBUGmkcMAIQMMAgtBDyEFQbyRwwAhAwwBC0EQIQVBy5HDACEDCyACQfgAaiAGEOMgIAIoAngiBEUEQCACENUpIQQMCwsgAkHwAGogCCADIAUgBCACKAJ8ELooAkAgAigCcEEBcUUNACACQegAaiACKAJ0EIQZIAIoAmgiBEUNACAEIAIoAmwQ+johBAwLCyACQeAAaiACQegSahDtEiACKAJkIQYgAigCYCIEDQALCyAAQQA6AKUHIAIgACgC/AY2AugSIAcgAkHoEmoQ7DogAigC6BIiBEGEAU8EQCAEEPIfCyAALQDwBkUEQCAHEKU7CyAAKALUBiIEQQRHBEAgByAEEKQ7CyAAKALYBiIEQQdHBEAgByAEEJI9CyAAKALABkEBRw0EIABBxAZqIgQQ5igNBCACQdgAaiAEEMohIAIoAlwhBCACKAJYQQFxDQggAiAENgLoEiAHIAJB6BJqEMwtIAIoAugSIgRBhAFJDQQgBBDyHwwEC0GglMMAEOgrAAsgAEGYB2ohBCAAQaAHaiEHAkAgAC0AoAdBAWsOAwIBBQALIAQoAgAhAwwDCwALQdiVwwAQ6CsACyACQegSahCZHyACKALsEiEEIAIoAugSDQMgAkHgFWogAkH4EmopAgAiDzcDACACIAIpAvASIhA3A9gVIAAgBDYCgAcgACAQNwKEByAAQYwHaiAPNwIAIABBgAdqIQQgACgCuAYiBkGAlOvcA0cEQCAEIAApA7AGIAYQzRELIAIgBBDROzYC6BIgByACQegSahDNLSACKALoEiIEQYQBTwRAIAQQ8h8LIAJB0ABqIAAoAvwFIAAoAoAGIAcQgCQgAigCVCEEAkAgAigCUEEBcUUNACACQcgAaiAEEIQZIAIoAkwhBCACKAJIIgZFDQAgBiAEEPo6IQQMAwsgACAENgKUByAAQZQHahCMFyEDIABBADoAoAcgACADNgKYByAAQaAHaiEHIABBmAdqIQQLIAAgAxD7DjYCnAcLIAJBQGsgAEGcB2oiAyABEMcYAkACQAJAAkACQAJAAkACQAJAIAIoAkAiBUECRwRAIAIoAkQhBiADKAIAIgggCCgCAEEBayIINgIAIAhFBEAgAxCyGgsCQAJAAkAgBUEBcUUNACACQThqIAYQhBkgAigCPCEGIAIoAjgiA0UNACAGIQUMAQsgAiAGNgLoEiACQegSaiIDEKM7DQEgA0EjQQBBAUEBEKAYIAIoAuwSIQUgAigC6BJBAUYNAyACKALwEiIIQeiVwwBBI/wKAABBDEEEEK02IgNFDQQgA0EjNgIIIAMgCDYCBCADIAU2AgBBvJLDACEFIAZBhAFJDQAgBhDyHwsgB0EBOgAAIAQQ5CggAiAFNgLUEyACIAM2AtATIAJBADYC4BUgAkKAgICAEDcC2BUgAkGQh8MANgLsEiACQqCAgIAONwLwEiACIAJB2BVqNgLoEiACQdATaiACQegSahCDNg0EIAJBqBRqIAJB4BVqKAIAIgQ2AgAgAiACKQLYFTcDoBQgAigCpBQgBEGylcMAQSQQwS4hBCACQaAUahDeOwJ/IARFBEAgAigC0BMhAyACKALUEwwBCyACQdATahC8KkEBIQNBoLPDAAshBEEBIAIgAyAEENgpIQQgACgClAciBkGEAUkNCyAGEPIfDAsLIAdBAToAACAEEOQoIAIgBjYCxBEgAkHoEmoiBBDZKSACQcgRaiAEIAJBxBFqIgMQjz0Q4BIgAkGgFGoiByADEOImIAIoAqgUIQggAigCpBQhDiACQQA2AuAVIAJBADYC2BUgAkEANgLoFSAEIAJB2BVqIA4gCBC8GiACKALoEkECRg0EIAJBkBJqIARByAD8CgAAIAcQ3jsgAiADEJA9NgLYEiAEIAJB2BJqEMcSIAItAOwSIgRBA0YNBSAEQQJGDQYgAigC6BIhAyACIAQ6AOASIAIgAzYC3BIgAkEwaiACQdwSahD8KSACKAIwIgRBAkcEQCACQeQVaiEFIAIoAjQhAwNAIARBAXENCSACIAM2AuQSIAJBKGogAkHkEmoQyCQgAigCKEEBcQ0KIAJBuBZqIgcgAigCLBCrKyACQaAUaiIEIAIoArwWIAIoAsAWEJA1IAJB6BJqIgMgBBDIEyACKALoEkGAgICAeEYNCyACQegVaiACQfgSaikCADcDACACQeAVaiACQfASaikCACIPNwMAIAIgAikC6BIiEDcD2BUgAkHYE2ogDz4CACACIBA3A9ATIAJBqBRqIAVBCGooAgA2AgAgAiAFKQIANwOgFCADIAJByBFqIghByAD8CgAAIAggAyACQdATaiIDIAQQsA0gBBDeOyADEN47IAcQ3jsgAigC5BIiBEGEAU8EQCAEEPIfCyACQSBqIAJB3BJqEPwpIAIoAiQhAyACKAIgIgRBAkcNAAsLIAIoAtwSIgRBhAFPBEAgBBDyHwsgAi0A0REhBCACLQDQESEDAkACQAJAIAIpA8gRIg9CA1EEQCAGQYQBTwRAIAYQ8h8LIAJBoBRqIAJBkBJqQcgA/AoAACACQfgUaiAAQZAHaigCADYCACACQfAUaiAAQYgHaikCADcCACACIAApAoAHNwLoFCACQbAUaiIFEN47IAJB6BRqEL0oDAELIAIgBDoA2RMgAiADOgDYEyACIA83A9ATIAJB2hNqIAJB0hFqQT78CgAAIAIgBjYCmBQgAkGgFGogAkGQEmpByAD8CgAAIAJB+BRqIABBkAdqKAIANgIAIAJB8BRqIABBiAdqKQIANwIAIAIgACkCgAc3AugUIAJB2BVqIAJBoBRqQdwA/AoAACACQbgWaiIEIAJBkBJqQcgA/AoAACACQegSaiACQdATaiAEIAJBoBZqEJMgIAIpA+gSIg9CA1INASACLQDxEiEEIAItAPASIQMLQgMhD0EBIAIgAyAEEKweIQQMAQsgAigC8BIhBCACQfwUaiACQfQSakHcAPwKAAALIAIoAtgSIgZBhAFPBEAgBhDyHwsgACgClAciBkGEAU8EQCAGEPIfCyAAQQA6AKUHIAAoAvgGIgNBhAFJDQ4MDQsgAEEDOgCgByAAQQM6AKQHDBELIAUgAigC8BJBvJbDABD9LwALQQRBDBCjPQALQbiHwwBBNyACQaAUakGoh8MAQfCHwwAQ1R4AC0GwlMMAQQkQlz0AC0G5lMMAQRAQlz0AC0HJlMMAQRgQlz0AC0HhlMMAQR4Qlz0AC0H/lMMAQRIQlz0AC0GRlcMAQSEQlz0ACyAAQYAHahC9KAsgAC0ApQdFDQAgACgC/AYiBkGEAUkNACAGEPIfCyAAQQA6AKUHQgMhDyAAKAL4BiIDQYMBSw0AIABBqAVqEKkeIABBAToApAcMAgsgAxDyHwsgAEGoBWoQqR4gAEEBOgCkByAPQgRRDQMLIAJB6BBqIAJB/BRqQdwA/AoAACAMEM0kIAAoAtADIgYgBigCACIGQQFrNgIAIAZBAUcNACAAQdADahCdJwsgAkGoCWogAkHoEGpB3AD8CgAAIApBAToAACACQYQKaiIGIAJBqAlqQdwA/AoAACAJEKoeIA9CA1ENCCACQewKaiAGQdwA/AoAACACIAQ2AugKIAIgDzcD4AogAkHAAWogAkHgCmoQkRMgAigCyAEhBCACKQPAASIPQgNRDQggAkGYDWogAkHMAWpB3AD8CgAAIAAgBDYCMCAAIA83AyggAEE0aiACQZgNakHcAPwKAAAgAEGQAWogAkGoAmpB9AD8CgAAIABBADoAhAIgAEEoaiEDIABBhAJqIQYLIABBkAFqIANB6AD8CgAAIAJBGGogAEHYAWoQxyQgAigCHCEEIAIoAhhBAXFFDQEgAkEQaiAEEIQZIAIoAhQhBCACKAIQIgVFDQFBBSACIAUgBBDYKSEEDAYLIApBAzoAAEEDDAMLIABBADoAgAIgACAENgL4ASAAQYACaiEFIABB+AFqIQkLIAAgBBD7DjYC/AELIAJBCGogAEH8AWoiBCABEMcYIAIoAggiAUECRwRAIAIoAgwhBiAEKAIAIgcgBygCAEEBayIHNgIAIAdFBEAgBBCyGgsCQCABQQFxRQ0AIAIgBhCEGSACKAIEIQYgAigCACIBRQ0AIAVBAToAACAJEOQoQQUgAiABIAYQ2CkhBAwECyAFQQE6AAAgCRDkKCACIAY2AvwUIAIgAkH8FGoQlD02AtgVIAJBwAFqIgEgAkHYFWoiBBCWPUGslsMAEM4YIAQgAigCxAEgAigCyAEQgyQgAkHIC2ogARDnFSACKQLQCyEPIAIoAswLIQEgAigCyAshBiACKALYFSIEQYQBTwRAIAQQ8h8LIAIoAvwUIgRBhAFPBEAgBBDyHwsgAEGQAWoQoSUgAEEBOgCEAiADENItIAZFBEAgASEEDAULIAIgATYC7BIgAiAGNgLoEiACIA83AvASIAJByAtqIA+nIgVBAEEBQQEQoBggAigCzAshAyACKALIC0EBRg0CIAIoAtALIQQgBQRAIAQgASAF/AoAAAsgAkH0EmogASAFIAYoAhARAQAgACgCHCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEcaiEGDAULIAVBAzoAACAGQQM6AABBBAshACALIAA6AABBASEDQQMMBQsgAyACKALQC0G8lsMAEP0vAAsgAEGQAWoQoSUgAEEBOgCEAiADENItCyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRxqIQZBgICAgHghAwwBCyALQQE6AAAgDRCcJwwECyAGEJ0nCyALQQE6AAAgDRCcJyADQYCAgIB4Rg0CIAIgBTYCsAEgAiAENgKsASACIAM2AqgBIAJBmA1qIAAoArQHIAJBqAFqEMUmIAIoApgNQYCAgIB4Rw0BIABBuAdqEN47QQAhA0EBCzoAxAcgAkGAF2okACADDwsgAkGwAmogAkGgDWooAgA2AgAgAiACKQKYDTcDqAJBoIjDAEErIAJBqAJqQdyIwwBB+JfDABDVHgALIAIgBDYCqAJBoIjDAEErIAJBqAJqQcyIwwBB6JfDABDVHgALqjICIH8BfiMAQcAEayIFJAAgBUGABGogASAEEN0QIAUoAogEIRggBSgChAQhBwJAIAUoAoAEIgRBioCAgHhHBEAgACAFKQKMBDcCDCAAQRxqIAVBnARqKQIANwIAIABBFGogBUGUBGopAgA3AgAgACAYNgIIIAAgBzYCBCAAIAQ2AgAMAQsgB0EBcQRAIAVBgARqIAEoAgAiEiAYEJMOIAUoAoQEIQcCQCAFKAKABCIEQYqAgIB4RwRAIAVB/ANqIAVBoARqKAIANgIAIAVB9ANqIAVBmARqKQIANwIAIAVB7ANqIAVBkARqKQIANwIAIAUgBSkCiAQ3AuQDIAUgBzYC4AMgBSAENgLcAwwBCyAFQYAEaiEKIwBBMGsiCCQAIAhBDGogEkF/IAcgGGoiBCAEIAdJGyIHEJMOIAgoAhAhCQJAIAgoAgwiBEGKgICAeEcEQCAKIAgpAhQ3AgggCkEgaiAIQSxqKAIANgIAIApBGGogCEEkaikCADcCACAKQRBqIAhBHGopAgA3AgAgCiAJNgIEIAogBDYCAAwBC0F/IAdBBGoiBCAEIAdJGyIGQQNxBEAgCiAGNgIcIApBxwA2AhggCkGf4/4ANgIUIApBgICAgHg2AhAgCkIENwIIIApChICAgAg3AgAMAQsCQAJAQX8gBkF/IAlBAnQgCUH/////A0sbIgdqIgQgBCAGSRsiCSASKAIETQRAIBIgEigCFCAHaiIENgIUQYiAgIB4IQcgBCASKAIIKAIISw0BDAILIAhBDGogBiAJEL8vIAgoAgwiB0GKgICAeEYNAQsgCiAIKQIQNwIEIApBHGogCEEoaikCADcCACAKQRRqIAhBIGopAgA3AgAgCkEMaiAIQRhqKQIANwIAIAogBzYCAAwBCyAKIAk2AgggCiAGNgIEIApBioCAgHg2AgALIAhBMGokACAFKAKIBCEJIAUoAoQEIQQgBSgCgAQiB0GKgICAeEcEQCAFQfgDaiAFQZwEaikCADcCACAFQfADaiAFQZQEaikCADcCACAFIAUpAowENwLoAyAFIAk2AuQDIAUgBDYC4AMgBSAHNgLcAwwBCyAJIARrIgdBACAHIAlNGyIHQQJ2IAdBA3FBAEdqIgcEQCAEQX9zIRlBACAHayEkIAVBiAFqIRwgBUH8AGohHSAFQcABaiEeIAVBsAFqIR8gBUHUAmohICAFQfADaiEOIAVBlARqIQ0gBUH4AmohECAFQYQEaiEbIAVB6AJqISEgBUHsAmohGiAFQYgEaiERIAVB4ANqISIgBUHkAGohDyAFQdgAaiETIAVB1ABqIRQDQCAFQYAEaiASIAQQkw4gBSgChAQhCQJAIAUoAoAEIgdBioCAgHhHBEAgEyARKQIANwIAIBNBGGogEUEYaigCADYCACATQRBqIBFBEGopAgA3AgAgE0EIaiARQQhqKQIANwIAIAUgCTYCVCAFIAc2AlAMAQsgBUGABGogEiAJIBkgCSAZSRsgBGoQtAYgBUH4AWoiCSAbQQhqIgopAgA3AwAgBSAbKQIANwPwASAFKAKABCIHQYqAgIB4RwRAIA8gDSkCADcCACAPQQhqIA1BCGopAgA3AgAgFEEIaiAJKQMANwIAIBQgBSkD8AE3AgAgBSAHNgJQDAELIAVBiAJqIAkpAwA3AwAgBSAFKQPwATcDgAIgBUHcA2ogBUGAAmpB7ef+AEEEQQQQrQggBUHoAWoiCSAiQQhqKQIANwMAIAUgIikCADcD4AEgBSgC3AMiB0GKgICAeEcEQCAPIA4pAgA3AgAgD0EIaiAOQQhqKQIANwIAIBRBCGogCSkDADcCACAUIAUpA+ABNwIAIAUgBzYCUAwBCyAFQZgCaiAJKQMANwMAIAUgBSkD4AE3A5ACIAVBgARqIAVBkAJqQQYQ3RAgBSgCiAQhDCAFKAKEBCEGAkACfiAFKAKABCIIQYqAgIB4RwRAIAVByAJqIA1BCGopAgA3AwAgBSANKQIANwPAAiAFKQKMBAwBCyAGQQFxRQ0BAkAgDEEBaiIHQX8gBxsiByAFKAKQAiIJKAIETQRAIAkgCSgCFEEBaiIHNgIUIAkoAggoAgggB08EQCAFQYqAgIB4NgKABAwCCyAFQYiAgIB4NgKABAwBCyAFQYAEaiAMIAcQvy8LIAVBCDYC9AIgBUHx5/4ANgLwAiAFQYCAgIB4NgLsAiAFIAw2AugCIAVBATYC5AIgBUHcA2ogBUGABGogBUHkAmoQgRQgBSgC3AMiCEGKgICAeEYNASAFQcgCaiAOQQhqKQIANwMAIAUgDikCADcDwAIgBSgC5AMhDCAFKALgAyEGIAUpAugDCyElIA8gBSkDwAI3AgAgD0EIaiAFQcgCaikDADcCACAFICU3AlwgBSAMNgJYIAUgBjYCVCAFIAg2AlAMAQsgBSAFKQOYAjcCqAIgBSAFKQOQAjcCoAIgBUGABGogBUGgAmpBChDdECAFKAKIBCEIIAUoAoQEIQYCfyAFKAKABCIMQYqAgIB4RwRAIAUoAqAEIQsgBSgCnAQhFSAFKAKYBCEWIAUoApQEIRcgBSgCkAQhCiAFKAKMBAwBCyAFQYAEaiAFQaACakEIEN0QIAUoAogEIQkgBSgChAQhByAFKAKABCIMQYqAgIB4RwRAIAUoAqAEIQsgBSgCnAQhFSAFKAKYBCEWIAUoApQEIRcgBSgCkAQhCiAHIQYgCSEIIAUoAowEDAELAkACQAJ+AkACQAJ+AkACQAJAAkACQAJAIAdBAXEEQCAGQQFxRQ0MIAlBAWoiB0F/IAcbIgcgBSgCoAIiBigCBEsNASAGIAYoAhRBAWoiBzYCFCAGKAIIKAIIIAdPBEAgBUGKgICAeDYCgAQMAwsgBUGIgICAeDYCgAQMAgsgBkEBcQ0LDAILIAVBgARqIAkgBxC/LwsgBUEJNgL0AiAFQfnn/gA2AvACIAVBgICAgHg2AuwCIAUgCTYC6AIgBUEBNgLkAiAFQdwDaiAFQYAEaiAFQeQCahCBFCAFKALcAyIMQYqAgIB4RwRAIAUoAvwDIQsgBSgC+AMhFSAFKAL0AyEWIAUoAvADIRcgBSgC7AMhCiAFKALkAyEIIAUoAuADIQYgBSgC6AMMCwsgCSAFKAKgAiIGKAIEIgdLDQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIAIAlqLQAAQQFrDhoBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGgALIAVBioCAgHg2AtwDDBoLIAVB3ANqIAZBqOj+AEEKIAgQqBAMGQsgBUGABGoiByAGIAgQ+AYgBUEJNgLQAiAFQbLo/gA2AswCIAVBgICAgHg2AsgCIAUgCDYCxAIgBUECNgLAAiAFQdwDaiAHIAVBwAJqEIEUDBgLIAVB3ANqIAYgCBDeCAwXCyAFQdwDaiAGQc7o/gBBDCAIEKgQDBYLIAVB3ANqIAZB2uj+AEEKIAgQqBAMFQsgBUHcA2ogBkHk6P4AQQogCBCoEAwUCyAFQdwDaiAGIAgQogMMEwsgBUHcA2ogBkH76P4AQQogCBDfCAwSCyAFQdwDaiAGIAgQlQYMEQsgBUHcA2ogBiAIEOMHDBALIAVB3ANqIAZBnun+AEEOIAgQ3wgMDwsgBUHcA2ogBkGs6f4AQQogCBCoEAwOCyAFQdwDaiAGQbbp/gBBDSAIEKgQDA0LIAVB3ANqIAYgCBCpBQwMCyAFQdwDaiAGIAgQ4AgMCwsgBUHcA2ogBiAIEN0IDAoLIAVB3ANqIAYgCBCCCQwJCyAFQdwDaiAGQf/p/gBBDiAIEN8IDAgLIAVB3ANqIAZBjer+AEERIAgQqBAMBwsgBUHcA2ogBkGe6v4AQQ8gCBCoEAwGCyAFQdwDaiAGQa3q/gBBDyAIEKgQDAULIAVB3ANqIAZBvOr+AEETIAgQqBAMBAsgBUHcA2ogBkHP6v4AQRAgCBCoEAwDCyAFQdwDaiAGQd/q/gBBDiAIEKgQDAILIAVB3ANqIAZB7er+AEEOIAgQqBAMAQsgBUHcA2ogBkH76v4AQRMgCBCoEAsgBUEFNgKQBCAFQYLo/gA2AowEIAVBgICAgHg2AogEIAUgCDYChAQgBUEBNgKABCAFQeQCaiAFQdwDaiAFQYAEahCBFCAFKALkAiIMQYqAgIB4Rg0AIAUoAoQDIQsgBSgCgAMhFSAFKAL8AiEWIAUoAvgCIRcgBSgC9AIhCiAFKALsAiEIIAUoAugCIQYgBSgC8AIMCgsgBSAFKQKoAjcCuAIgBSAFKQKgAjcCsAIgBUGABGogBUGwAmpBDBDdECAFKAKIBCEMIAUoAoQEIQYgBSgCgAQiCEGKgICAeEcEQCAFQdgBaiANQQhqKQIANwMAIAUgDSkCADcD0AEgBSkCjAQMBwsgBkEBcUUNByAFQYAEaiAFKAKwAiIJIAwQkw4gBSgChAQhBiAFKAKABCIHQYqAgIB4RwRAIBogESkCADcCACAaQRhqIBFBGGooAgA2AgAgGkEQaiARQRBqKQIANwIAIBpBCGogEUEIaikCADcCACAFIAY2AugCIAUgBzYC5AIMBgsgBUGABGogCUF/IAYgDGoiByAGIAdLGxC0BiAFQZADaiIJIAopAgA3AwAgBSAbKQIANwOIAyAFKAKABCIHQYqAgIB4RwRAIBAgDSkCADcCACAQQQhqIA1BCGopAgA3AgAgIUEIaiAJKQMANwIAICEgBSkDiAM3AgAgBSAHNgLkAgwGCyAFQaADaiAJKQMANwMAIAUgBSkDiAM3A5gDIAVBgARqIAVBmANqQQQQ3RAgBSgCiAQhBiAFKAKEBCELIAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAQLIAtBAXFFDQQgBkEHcQRAIAUgBjYCnAQgBUEDNgKYBCAFQbDk/gA2ApQEIAVBgICAgHg2ApAEIAVCBDcCiAQgBUKEgICACDcCgAQMAwtBfyAGQQhqIgcgBiAHSxsiByAFKAKYAyIJKAIESw0BIAkgCSgCFEEIaiIHNgIUIAkoAggoAgggB08EQCAFQYqAgIB4NgKABAwDCyAFQYiAgIB4NgKABAwCCyAJIAdB0OH+ABCvOwALIAVBgARqIAYgBxC/LwsgBUECNgK4BCAFQefm/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQOgAzcCtAMgBSAFKQOYAzcCrAMgBUGABGogBUGsA2pBBhDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQEgBUGABGoiByAFKAKsAyAGEPgGIAVBCTYCuAQgBUHN5/4ANgK0BCAFQYCAgIB4NgKwBCAFIAY2AqwEIAVBATYCqAQgBUHcA2ogByAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQK0AzcCxAMgBSAFKQKsAzcCvAMgBUGABGogBUG8A2pBCBDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQECQCAGQQFqIgdBfyAHGyIHIAUoArwDIgkoAgRNBEAgCSAJKAIUQQFqIgc2AhQgCSgCCCgCCCAHTwRAIAVBioCAgHg2AoAEDAILIAVBiICAgHg2AoAEDAELIAVBgARqIAYgBxC/LwsgBUEJNgK4BCAFQdbn/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQLEAzcC1AMgBSAFKQK8AzcCzAMgBUGABGogBUHMA2pBChDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQECQCAGQQFxBEAgBSAGNgKcBCAFQQM2ApgEIAVBueT+ADYClAQgBUGAgICAeDYCkAQgBUIENwKIBCAFQoSAgIAINwKABAwBC0F/IAZBAmoiByAGIAdLGyIHIAUoAswDIgkoAgRNBEAgCSAJKAIUQQJqIgc2AhQgCSgCCCgCCCAHTwRAIAVBioCAgHg2AoAEDAILIAVBiICAgHg2AoAEDAELIAVBgARqIAYgBxC/LwsgBUEONgK4BCAFQd/n/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSgCzAMiByAHKAIMQQFrNgIMIAVBioCAgHg2AuQCCyAFQQo2ApAEIAVBh+j+ADYCjAQgBUGAgICAeDYCiAQgBSAMNgKEBCAFQQE2AoAEIAVBwAJqIAVB5AJqIAVBgARqEIEUIAUoAsACIghBioCAgHhGDQEgBUHYAWogIEEIaikCADcDACAFICApAgA3A9ABIAUoAsgCIQwgBSgCxAIhBiAFKQLMAgshJSAPIAUpA9ABNwIAIA9BCGogBUHYAWopAwA3AgAgBSAlNwJcIAUgDDYCWCAFIAY2AlQgBSAINgJQDAMLIAUgBSkCuAI3AuQDIAUgBSkCsAI3AtwDIAVBrAFqIAVB3ANqQZHo/gBBCEEOEJcBIAVBoAFqIgkgH0EIaikCADcDACAFIB8pAgA3A5gBIAUoAqwBIgdBioCAgHhHBEAgDyAeKQIANwIAIA9BCGogHkEIaikCADcCACAUQQhqIAkpAwA3AgAgFCAFKQOYATcCACAFIAc2AlAMAwsgESAJKQMANwMAIAUgBSkDmAE3A4AEIAVB9ABqIAVBgARqQRAQ7wMgBSgCeCEJIAUoAnQiB0GKgICAeEcEQCATIB0pAgA3AgAgDyAcKQIANwIAIBNBCGogHUEIaigCADYCACAPQQhqIBxBCGopAgA3AgAgBSAJNgJUIAUgBzYCUAwDCyAJIAkoAgxBAWs2AgwgBUGKgICAeDYCUAwCC0EFIQtBguj+ACEVQQkhF0H55/4AIQpBBCEGQQAhDEEAIQhBgICAgHghFkGAgICAeAshByAFIAs2AnAgBSAVNgJsIAUgFjYCaCAFIBc2AmQgBSAKNgJgIAUgBzYCXCAFIAg2AlggBSAGNgJUIAUgDDYCUAsgBSAENgKIBCAFICM2AoQEIAVBADYCgAQgBUEsaiAFQdAAaiAFQYAEahCBFCAFKAIsIgdBioCAgHhHBEAgBUH4A2ogBUHIAGopAgA3AgAgBUHwA2ogBUFAaykCADcCACAFQegDaiAFQThqKQIANwIAIAUgBSkCMDcC4AMgBSAHNgLcAwwDCyAEQQRqIQQgGUEEayEZICQgI0EBaiIjag0ACwsgBUGKgICAeDYC3AMLIAUgAzYCkAQgBSACNgKMBCAFQYCAgIB4NgKIBCAFIBg2AoQEIAVBATYCgAQgAEEEaiEDIAVBCGogBUHcA2ogBUGABGoQgRQCQCAFKAIIIgJBioCAgHhHBEAgAyAFKQIMNwIAIANBGGogBUEkaikCADcCACADQRBqIAVBHGopAgA3AgAgA0EIaiAFQRRqKQIANwIADAELIAMgASkCADcCACADQQhqIAFBCGopAgA3AgALIAAgAjYCAAwBCyAAQYqAgIB4NgIAIAAgASkCADcCBCAAQQxqIAFBCGopAgA3AgALIAVBwARqJAAL81gCCn8CfiMAQfAEayILJAAgAUEYaiEPIAatIRQCQAJAAkACQAJAAkACQAJAAkAgAS0AGCINRQRAIAQoAggiBiAEKAIARgRAIARBkNL+ABCuKAsgBCgCBCAGQQR0aiIHIBQ3AAggByAUNwAAIAQgBkEBajYCCAwBCyAEKAIIIgogBCgCAEYEQCAEQaDS/gAQrigLIAQoAgQgCkEEdGoiECAHrTcACCAQIBQ3AAAgBCAKQQFqNgIIAkAgDUEoRiANQSFGciAJLgECQQROcQ0AAkACQAJAIAEoAiwEQCALQYgEaiABQSxqEKA2DAELQcAAIQogBkEDdiAGQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgZBwAAQ0TRFDQsgBgRAIAZBwAAQrTYiCkUNAgsgC0EANgL8ASALIAo2AvgBIAsgBjYC9AEgC0HAADYC8AEgC0GAAmogC0HwAWogBxDSJSALIAspAoACNwLcAiALQQA2AtgCIAsgCygCjAIiBzYC1AIgCyALKAKIAjYC0AIgC0HoAWogC0HQAmoQ1zsgCygC6AEhCkEcQQQQrTYiBkUNAiAGQoGAgIAQNwIAIAYgCykC0AI3AgggBkEQaiALQdgCaikCADcCACAGQRhqIAtB4AJqKAIANgIAIAsgBzYCkAQgCyAKNgKMBCALIAY2AogECyALQeABaiALQYgEaiIGENw7IAtB0AJqIAsoAuABIAsoAuQBIAIgAyAFIAggCS0ABhC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIAIAsoAogEIgAgACgCACIAQQFrNgIAIABBAUcNCSAGEPseDAkLIAspA9gCIQUgCygCiAQiBiAGKAIAIgZBAWs2AgAgBkEBRw0CIAtBiARqEPseDAILQcAAIAYQoz0ACwwJCwJAAkACQAJAAkACQAJAIA1BAmsOJQQEBAQEBAQEBAQEAwMDAwMDAwADAgEAAgEDAwMDAwMDAwQEBAQDCwJAAkAgASgCJARAIAtBoAFqIAEQ3DsgCygCpAFFDQEgC0HQAmogCygCoAEgARCvEiALQZAEaiIGIAtB2AJqIgcoAgA2AgAgCyALKQLQAjcDiAQgCygC3AIhDCALKALgAiEOIAtBmAFqIAEQ3DsgCygCnAEiCkEBTQ0CIAtB3AJqIAsoApgBQQxqIAwgDhDmFSAHIAYoAgA2AgAgCyALKQOIBDcD0AIMCAtBAEHAABDRNEUNDyALQQA2AuACIAtCgICAgIAINwLYAiALQsAANwLQAiALQZABaiALQdACahDXOyALKAKQASEMQRxBBBCtNiIGRQ0QIAZCgYCAgBA3AgAgBiALKQLQAjcCCCAGQRBqIAtB2AJqKQIANwIAIAZBGGogC0HgAmooAgA2AgBBAEHAABDRNEUNDyALQQA2ApgEIAtCgICAgIAINwKQBCALQsAANwKIBCALQYgBaiALQYgEahDXOyALKAKIASEOQRxBBBCtNiIHRQ0QIAdCgYCAgBA3AgAgByALKQKIBDcCCCAHQRBqIAtBkARqKQIANwIAIAdBGGogC0GYBGooAgA2AgAgC0EANgLkAiALIA42AuACIAsgBzYC3AIgC0EANgLYAiALIAw2AtQCIAsgBjYC0AIMBwtBAEEAQcDR/gAQwyEAC0EBIApB0NH+ABDDIQALIAtBsAFqIAEQ3DsgCygCtAEiB0UNBiALKAKwASEGIAdBDGwhByAJLQAGIQoDQCALQagBaiAGENw7IAtB0AJqIAsoAqgBIAsoAqwBIAIgAyAFIAggChC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIADAwLIAZBDGohBiALKQPYAiEFIAdBDGsiBw0ACwwGCwJAAkAgASgCJARAIAtB2AFqIAEQ3DsgCygC3AFFDQEgC0HQAmogCygC2AEgARCuEiALQZAEaiIGIAtB2AJqIgcoAgA2AgAgCyALKQLQAjcDiAQgCygC3AIhDCALKALgAiEOIAtB0AFqIAEQ3DsgCygC1AEiCkEBTQ0CIAtB3AJqIAsoAtABQQxqIAwgDhDmFSAHIAYoAgA2AgAgCyALKQOIBDcD0AIMBQtBAEHAABDRNEUNDSALQQA2AuACIAtCgICAgIAINwLYAiALQsAANwLQAiALQcgBaiALQdACahDXOyALKALIASEMQRxBBBCtNiIGRQ0OIAZCgYCAgBA3AgAgBiALKQLQAjcCCCAGQRBqIAtB2AJqKQIANwIAIAZBGGogC0HgAmooAgA2AgBBAEHAABDRNEUNDSALQQA2ApgEIAtCgICAgIAINwKQBCALQsAANwKIBCALQcABaiALQYgEahDXOyALKALAASEOQRxBBBCtNiIHRQ0OIAdCgYCAgBA3AgAgByALKQKIBDcCCCAHQRBqIAtBkARqKQIANwIAIAdBGGogC0GYBGooAgA2AgAgC0EANgLkAiALIA42AuACIAsgBzYC3AIgC0EANgLYAiALIAw2AtQCIAsgBjYC0AIMBAtBAEEAQcDR/gAQwyEAC0EBIApB0NH+ABDDIQALIA1BDWtBBk0NAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDUEaTARAIA1BAUYNASANQRVHDRIMDwsCQAJAIA1BG2sOCAETAwETExMQAAsgDUEnRw0SCyALQegAaiABENw7IAsgCygCbCIGNgLIAiAGQQFHDQIgC0HgAGogARDvPCALIAsoAmQiBjYCzAIgBkEBRw0DIA1BG2sOBAYFBQcECyALQdAAaiABENw7IAsgCygCVCIGNgLEAiAGQQFHDQkgC0HIAGogARDcOyALKAJMRQ0KIAtBiARqIgYgCygCSCABKAIoIAEoAiQQtSogC0FAayAGENw7IAtB0AJqIAsoAkAgCygCRCACIAMgBSAIIAktAAYQtRIgCygC0AIEQCALKALUAiEBIAspA9gCIQUgACALKQPgAjcDECAAIAU3AwggACABNgIEIABBATYCACALKAKIBCIAIAAoAgAiAEEBazYCACAAQQFHDRYgBhD7HgwWCyALKQPYAiEFIAsoAogEIgYgBigCACIGQQFrNgIAIAZBAUcNEiALQYgEahD7HgwSCyALQfgAaiABEO88IAsgCygCfCIGNgKkAyAGQQFHDQogASgCJCEHIAEoAighDCABKAIcIQYgC0HwAGogARDvPCALKAJ0RQ0LIAtB0AJqIgEgCygCcCAGIAxsIAYgB2wQ1ghBACEGIAtBiARqIAEgAiADIAQgBSALKAL0AiALKAKQA0EAIAsoAvwCGyAIIAkQmAECfyALKAKIBARAIAspA5gEIQUgCygCjAQhASAAIAspA5AENwMIIAAgATYCBEEBIQZBEAwBCyALKQOQBCEFQQgLIABqIAU3AwAgACAGNgIAIAtB0AJqEP4mDBQLIAtBADYC0AJBACALQcgCakGw0v4AIAtB0AJqQbzT/gAQrysACyALQQA2AtACQQAgC0HMAmpBsNL+ACALQdACakGs0/4AEK8rAAsgDUEnRg0DC0H00v4AQShBnNP+ABCfKQALIAtB0AJqIAEQpQ4MAgsgC0HQAmohByMAQUBqIgYkAAJAAkACQAJAAkAgASgCJARAIAZBGGogARDcOyAGKAIcRQ0BIAZBLGogBigCGCABEK4SIAZBKGoiDCAGQTRqKAIANgIAIAYgBikCLDcDICAGKAI4IQ4gBigCPCEKIAZBEGogARDvPCAGKAIURQ0CIAdBDGogBigCECAOIAoQ1gggB0EIaiAMKAIANgIAIAcgBikDIDcCAAwFC0EAQcAAENE0RQ0DIAZBADYCPCAGQoCAgICACDcCNCAGQsAANwIsIAZBCGogBkEsahDXOyAGKAIIIQ5BHEEEEK02IgxFDRYgDEKBgICAEDcCACAMIAYpAiw3AgggDEEQaiAGQTRqKQIANwIAIAxBGGogBkE8aigCADYCACAGIAEQ7zwgBigCBEUNAiAHQQxqIAYoAgBBAEEAENYIIAdBADYCCCAHIA42AgQgByAMNgIADAQLQQBBAEHg0f4AEMMhAAtBAEEAQfDR/gAQwyEAC0EAQQBBgNL+ABDDIQALQYDI/gBBKSAGQSxqQfzI/gBBrMj+ABDVHgALIAZBQGskAAwBCyALQdACaiABEKUOCyALQbADaiALQdgCaigCADYCACALIAspAtACNwOoAyALQYgEaiALQdwCakHEAPwKAAAgC0HYAGogC0GoA2oQ3DsgC0HQAmogCygCWCALKAJcIAIgAyAFIAggCS0ABhC1EkEBIQYCfyALKALQAkEBRgRAIAspA+ACIQUgCygC1AIhASAAIAspA9gCNwMIIAAgATYCBEEQDAELIAtB0AJqIAtBiARqIAIgAyAEIAspA9gCIAsoAqwEIAsoAsgEQQAgCygCtAQbIAggCRCYASALKALQAkEBRgRAIAspA+ACIQUgCygC1AIhASAAIAspA9gCNwMIIAAgATYCBEEQDAELIAspA9gCIQVBACEGQQgLIABqIAU3AwAgACAGNgIAIAtBiARqEP4mIAsoAqgDIgAgACgCACIAQQFrNgIAIABBAUcNDCALQagDahD7HgwMCyALQQA2AtACQQAgC0HEAmpBsNL+ACALQdACakHE0v4AEK8rAAtBAEEAQbTS/gAQwyEACyALQQA2AtACQQAgC0GkA2pBsNL+ACALQdACakHk0v4AEK8rAAtBAEEAQdTS/gAQwyEACyALQThqIAEQ3DsgCyALKAI8IgY2AsACAkAgBkEBRgRAIAtBMGogARDcOyALKAI0DQFBAEEAQczT/gAQwyEACyALQQA2AtACQQAgC0HAAmpBsNL+ACALQdACakH80/4AEK8rAAsgCygCMCEGIAtBiARqIA8Q5gsCQAJAIAsoApAEBEAgC0HQAmoCfwJAIAsoAowEIgcoAgAiCkEDRwRAIAEoAigiDkEAIAcoAgQgChsiDCABKAIkbCIHIAYoAggiCklyDQELIAtBIGogBhDcOyALKAIkIQYgCygCIAwBCyALQShqIAYQ3DsgCiAMIA5sIgxrIgYgByAGIAdJGyIGIAxqIgcgBkkNAiAHIAsoAiwiCksNAyALKAIoIAxqCyAGIAIgAyAFIAggCS0ABhC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIAIAtBiARqEOg7DAsLIAspA9gCIQUgC0GIBGoQ6DsMBgtBAEEAQdzT/gAQwyEACyAMIAdB7NP+ABCxOwALIAcgCkHs0/4AELA7DAgLIAtBsAJqIgYgC0HYAmoiCigCADYCACALQbwCaiALQeQCaigCADYCACALIAspA9ACIhQ3A6gCIAsgCykC3AI3ArQCIAtB4AJqIAYpAwA3AgAgC0HoAmogC0G4AmopAwA3AgAgC0KBgICAIDcC0AIgCyAUNwLYAgJAIBSnIgZFBEBBAiEMQQEhDgwBCyAJLQAGIRAgCiEHA0AgCyAHKQIENwKsAyALIAY2AqgDIAtBuAFqIAtBqANqIgYQ3DsgC0GIBGogCygCuAEgCygCvAEgAiADIAUgCCAQELUSIAsoAogEBEAgCygCjAQhASALKQOQBCEFIAAgCykDmAQ3AxAgACAFNwMIIAAgATYCBCAAQQE2AgAgCygCqAMiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAogCygC0AIgCygC1AIQ6yQMCQsgCykDkAQhBSALKAKoAyIGIAYoAgAiBkEBazYCACAGQQFGBEAgC0GoA2oQ+x4LIAsoAtQCIgwgCygC0AIiBkcEQCALIAZBAWoiDjYC0AIgCiAGQQxsaiIHKAIAIgZFDQIMAQsLIAwhDgsgCiAOIAwQ6yQMAgsgC0GYAmoiBiALQdgCaiIKKAIANgIAIAtBpAJqIAtB5AJqKAIANgIAIAsgCykD0AIiFDcDkAIgCyALKQLcAjcCnAIgC0HgAmogBikDADcCACALQegCaiALQaACaikDADcCACALQoGAgIAgNwLQAiALIBQ3AtgCAkAgFKciBkUEQEECIQxBASEODAELIAktAAYhECAKIQcDQCALIAcpAgQ3AqwDIAsgBjYCqAMgC0GAAWogC0GoA2oiBhDcOyALQYgEaiALKAKAASALKAKEASACIAMgBSAIIBAQtRIgCygCiAQEQCALKAKMBCEBIAspA5AEIQUgACALKQOYBDcDECAAIAU3AwggACABNgIEIABBATYCACALKAKoAyIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhD7HgsgCiALKALQAiALKALUAhDrJAwICyALKQOQBCEFIAsoAqgDIgYgBigCACIGQQFrNgIAIAZBAUYEQCALQagDahD7HgsgCygC1AIiDCALKALQAiIGRwRAIAsgBkEBaiIONgLQAiAKIAZBDGxqIgcoAgAiBkUNAgwBCwsgDCEOCyAKIA4gDBDrJAwBCyALQRhqIAEQ3DsgCygCHCIHRQ0AIAsoAhghBiAHQQxsIQcgCS0ABiEKA0ACQCALQRBqIAYQ3DsgC0HQAmogCygCECALKAIUIAIgAyAFIAggChC1EiALKALQAkEBRg0AIAZBDGohBiALKQPYAiEFIAdBDGsiBw0BDAILCyALKALUAiEBIAspA9gCIQUgACALKQPgAjcDECAAIAU3AwggACABNgIEIABBATYCAAwECyANQSJGDQIgDUEoRg0BCyALIAEQ7zwgCygCBCIBRQ0BIAsoAgAhBiABQcQAbCEHA0AgC0HQAmogBiACIAMgBCAFIAZBJGooAgAgBkFAaygCAEEAIAZBLGooAgAbIAggCRCYASALKALQAgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIADAQLIAZBxABqIQYgCykD2AIhBSAHQcQAayIHDQALDAELIAtBzARqIA8QxQYgASgCKCEHIAEoAiQhCiALQdgEaiABEL4VIAtB5ARqIAFBDGoQgAsgASgCLCIGBEAgBiAGKAIAIgxBAWo2AgAgDEEASA0DIAEoAkAhDSABKAI8IQ8gASgCOCEMIAEoAjQhDiABKAIwIQELIAtB8AJqIAtB1ARqKAIANgIAIAtB2AJqIAtB4ARqKAIANgIAIAtB5AJqIAtB7ARqKAIANgIAIAsgCykCzAQ3A+gCIAsgBzYC+AIgCyAKNgL0AiALIAspAtgENwPQAiALIAspAuQENwLcAiALIA02ApADIAsgDzYCjAMgCyAMNgKIAyALIA42AoQDIAsgATYCgAMgCyAGNgL8AiALQYgEaiEQIwBB8ARrIgokAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAtB0AJqIgEtABhBKEYEQCABKAIcIgYtADBBA2sOAwIDBAELIAogAUEYajYC9AIgCkEBNgKYBCAKQaTP/gA2ApQEIApCATcCoAQgCkGnBDYCvAMgCiAKQbgDajYCnAQgCiAKQfQCajYCuAMgEEEIaiAKQZQEahCZDiAQQoCAgIDYgYCAgH83AgAgARD+JgwHCyAKIAZBMGo2AvQCIApBATYCmAQgCkHMzv4ANgKUBCAKQgE3AqAEIApBpwQ2ArwDIAogCkG4A2o2ApwEIAogCkH0Amo2ArgDIApBlARqQdTO/gAQ7ywACyAKQZQEaiIGIAFBxAD8CgAAIApByAFqIAYQnwkCQAJAIAooAuQBDQBBACEGAkAgCigC3AEiAUECSQ0AIAooAtgBIAFBfnFqQQJrIgFFDQAgAS4BACEGCyAGIAooAuABRw0AIApBoAFqIApByAFqQSj8CgAADAELQQAhBgJAIApB1AFqIgEoAhBFDQAgASgCDEUNACABQQAQkhkhBgsgBiEOAn9BACEGQQAgASgCDCIHRQ0AGgJAIAEoAggiDEECSQ0AIAEoAgQgDEF+cWpBAmsiDUUNACANLgEAIQYLIAEoAhAgB2ogBkcEQCABIAdBAWsQkhkMAQsgDEEBdkEBawshBiAKKALkASESIAYgDmtBAWoiEUEBdCIHQT5xIgwEQCAHIAcgDGtBQGsiB0sNCgtBwAAhDCAHQcAAENE0RQ0KIAcEQCAHQcAAEK02IgxFDQwLIApCADcCpAIgCiAMNgKgAiAKIAc2ApwCIApBwAA2ApgCIAYgDkkNDCAGIAooAtwBQQF2IgdLDQ0gBiAORwRAIAZBAXQgDkEBdCIGayEMIAooAtgBIAZqIQdBACEGA0AgBy8BACETIAdBAmohByAGQQJqIg0gCigCnAIiD0sEQCAKQZgCaiAPQQF0IgYgDRDLKiINIAYgDUsbEOgZIAooApwCIQ8gCigCpAIiBkECaiENCyANIA9LBH8gCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKkAgUgBgsgCigCoAJqIBMgEms7AAAgCiAKKAKkAkECaiIGNgKkAiAKIAooAqgCQQFqNgKoAiAMQQJrIgwNAAsLIApByAFqKAIYIg1BgIACTw0HIAooAqQCIgxBAmoiBiAKKAKcAiIHSwRAIApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCnAIhByAKKAKkAiIMQQJqIQYLIAYgB0sEfyAKQZgCaiAHQQF0IgcgBhDLKiIGIAYgB0kbEOgZIAooAqQCBSAMCyAKQaACaiIHKAIAaiANOwAAIAogCigCpAJBAmoiDDYCpAIgCiAKKAKoAkEBajYCqAIgCkG8BGpBg4aMGDYCACAKQoOGjJiw4MCBAzcCtAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIApBADsB7AQgCkEANgLoBCAKQQA2AtAEIApBADYCxAQgCiARNgLABCAKQbgDaiIGEJcpIAcoAgAhDSAHIApBwANqIg8pAgA3AwAgCikDmAIhFCAKIAopArgDNwOYAiAKQQA2AqgCIAogFDcCxAMgCkEANgLAAyAKIAw2ArwDIAogDTYCuAMgCkEQaiAGENc7IAooAhAhDUEcQQQQrTYiB0UNEyAHQoGAgIAQNwIAIAcgCikCuAM3AgggB0EQaiAPKQIANwIAIAdBGGogCkHIA2ooAgA2AgAgCiAMNgL8AiAKIA02AvgCIAogBzYC9AIgBiAKQZQEaiIHIApB9AJqIgwQ+iMgCkGwAmoiDSAGEM0cIApBCGogCkHoAWoiDyAOIBEQyyUgDCAKKAIIIAooAgwQ0yMgCkG0BGogCkHIAWoiDhDFBiAOKAIYIREgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApCBDcCrAQgCkIANwKkBCAKQoCAgIDAADcCnAQgCkEANgKUBCAGIAcgDRDvJSAHIAYgDBDvJSAGIAcQzRwgCkGgAWogBhCfCSAKQZgCahDPLyAOEKIMIAooAtQBIgYgBigCACIGQQFrNgIAIAZBAUYEQCABEPseCyAKKALoASIBIAEoAgAiAUEBazYCACABQQFHDQAgDxC7IwsgCi0AoAEiAUEpRw0CIApBmwFqIApBtAFqKAIAIgE2AAAgCkGTAWogCkGsAWopAgAiFDcAACAKIAopAqQBIhU3AIsBIBBBFGogATYAACAQQQxqIBQ3AAAgECAVNwAEIBBBgICAgHg2AgAMBQsgCkGUBGoiBiABQcQA/AoAACAKQcgBaiAGEJ4JAkACQCAKKALkAQ0AQQAhBgJAIAooAtwBIgFBBEkNACAKKALYASABQXxxakEEayIBRQ0AIAEoAgAhBgsgBiAKKALgAUcNACAKQaABaiAKQcgBakEo/AoAAAwBC0EAIQYCQCAKQdQBaiIBKAIQRQ0AIAEoAgxFDQAgAUEAEN8ZIQYLIAYhDgJ/QQAhBkEAIAEoAgwiB0UNABoCQCABKAIIIgxBBEkNACABKAIEIAxBfHFqQQRrIg1FDQAgDSgCACEGCyABKAIQIAdqIAZHBEAgASAHQQFrEN8ZDAELIAxBAnZBAWsLIQYgCigC5AEhEiAGIA5rQQFqIhFBAnQiB0E8cSIMBEAgByAHIAxrQUBrIgdLDQkLQcAAIQwgB0HAABDRNEUNCSAHBEAgB0HAABCtNiIMRQ0LCyAKQgA3AqQCIAogDDYCoAIgCiAHNgKcAiAKQcAANgKYAiAGIA5JDQsgBiAKKALcAUECdiIHSw0MIAYgDkcEQCAGQQJ0IA5BAnQiBmshDCAKKALYASAGaiEHQQAhBgNAIAcoAgAhEyAHQQRqIQcgBkEEaiINIAooApwCIg9LBEAgCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKcAiEPIAooAqQCIgZBBGohDQsgDSAPSwR/IApBmAJqIA9BAXQiBiANEMsqIg0gBiANSxsQ6BkgCigCpAIFIAYLIAooAqACaiATIBJrNgAAIAogCigCpAJBBGoiBjYCpAIgCiAKKAKoAkEBajYCqAIgDEEEayIMDQALCyAKQcgBaigCGCINQQBIDQcgCigCpAIiDEEEaiIGIAooApwCIgdLBEAgCkGYAmogB0EBdCIHIAYQyyoiBiAGIAdJGxDoGSAKKAKcAiEHIAooAqQCIgxBBGohBgsgBiAHSwR/IApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCpAIFIAwLIApBoAJqIgcoAgBqIA02AAAgCiAKKAKkAkEEaiIMNgKkAiAKIAooAqgCQQFqNgKoAiAKQbwEakGEiJAgNgIAIApChIiQoMCAgYIENwK0BCAKQgQ3AqwEIApCADcCpAQgCkKAgICAwAA3ApwEIApBADYClAQgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApBuANqIgYQlykgBygCACENIAcgCkHAA2oiDykCADcDACAKKQOYAiEUIAogCikCuAM3A5gCIApBADYCqAIgCiAUNwLEAyAKQQA2AsADIAogDDYCvAMgCiANNgK4AyAKQSBqIAYQ1zsgCigCICENQRxBBBCtNiIHRQ0SIAdCgYCAgBA3AgAgByAKKQK4AzcCCCAHQRBqIA8pAgA3AgAgB0EYaiAKQcgDaigCADYCACAKIAw2AvwCIAogDTYC+AIgCiAHNgL0AiAGIApBlARqIgcgCkH0AmoiDBD6IyAKQbACaiINIAYQzRwgCkEYaiAKQegBaiIPIA4gERDLJSAMIAooAhggCigCHBDTIyAKQbQEaiAKQcgBaiIOEMUGIA4oAhghESAKQQA7AewEIApBADYC6AQgCkEANgLQBCAKQQA2AsQEIAogETYCwAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIAYgByANEO8lIAcgBiAMEO8lIAYgBxDNHCAKQaABaiAGEJ4JIApBmAJqEM8vIA4QogwgCigC1AEiBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAEQ+x4LIAooAugBIgEgASgCACIBQQFrNgIAIAFBAUcNACAPELsjCyAKLQCgASIBQSlHDQIgCkGbAWogCkG0AWooAgAiATYAACAKQZMBaiAKQawBaikCACIUNwAAIAogCikCpAEiFTcAiwEgEEEUaiABNgAAIBBBDGogFDcAACAQIBU3AAQgEEGAgICAeDYCAAwECyAKQZQEaiIGIAFBxAD8CgAAIApByAFqIAYQoAkCQAJAIAooAuQBDQBBACEGAkAgCigC3AEiAUEISQ0AIAooAtgBIAFBeHFqQQhrIgFFDQAgASgCACEGCyAGIAooAuABRw0AIApBoAFqIApByAFqQSj8CgAADAELQQAhBgJAIApB1AFqIgEoAhBFDQAgASgCDEUNACABQQAQyBkhBgsgBiEOAn9BACEGQQAgASgCDCIHRQ0AGgJAIAEoAggiDEEISQ0AIAEoAgQgDEF4cWpBCGsiDUUNACANKAIAIQYLIAEoAhAgB2ogBkcEQCABIAdBAWsQyBkMAQsgDEEDdkEBawshBiAKNQLkASEUIAYgDmtBAWoiEUEDdCIHQThxIgwEQCAHIAcgDGtBQGsiB0sNCAtBwAAhDCAHQcAAENE0RQ0IIAcEQCAHQcAAEK02IgxFDQoLIApCADcCpAIgCiAMNgKgAiAKIAc2ApwCIApBwAA2ApgCIAYgDkkNCiAGIAooAtwBQQN2IgdLDQsgBiAORwRAIAZBA3QgDkEDdCIGayEMIAooAtgBIAZqIQdBACEGA0AgBykDACEVIAdBCGohByAGQQhqIg0gCigCnAIiD0sEQCAKQZgCaiAPQQF0IgYgDRDLKiINIAYgDUsbEOgZIAooApwCIQ8gCigCpAIiBkEIaiENCyANIA9LBH8gCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKkAgUgBgsgCigCoAJqIBUgFH03AAAgCiAKKAKkAkEIaiIGNgKkAiAKIAooAqgCQQFqNgKoAiAMQQhrIgwNAAsLIApByAFqKAIYIQ0gCigCpAIiDEEIaiIGIAooApwCIgdLBEAgCkGYAmogB0EBdCIHIAYQyyoiBiAGIAdJGxDoGSAKKAKcAiEHIAooAqQCIgxBCGohBgsgBiAHSwR/IApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCpAIFIAwLIApBoAJqIgcoAgBqIA2tNwAAIAogCigCpAJBCGoiDDYCpAIgCiAKKAKoAkEBajYCqAIgCkG8BGpBhYqUKDYCACAKQoWKlKjQoMGCBTcCtAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIApBADsB7AQgCkEANgLoBCAKQQA2AtAEIApBADYCxAQgCiARNgLABCAKQbgDaiIGEJcpIAcoAgAhDSAHIApBwANqIg8pAgA3AwAgCikDmAIhFCAKIAopArgDNwOYAiAKQQA2AqgCIAogFDcCxAMgCkEANgLAAyAKIAw2ArwDIAogDTYCuAMgCkEwaiAGENc7IAooAjAhDUEcQQQQrTYiB0UNESAHQoGAgIAQNwIAIAcgCikCuAM3AgggB0EQaiAPKQIANwIAIAdBGGogCkHIA2ooAgA2AgAgCiAMNgL8AiAKIA02AvgCIAogBzYC9AIgBiAKQZQEaiIHIApB9AJqIgwQ+iMgCkGwAmoiDSAGEM0cIApBKGogCkHoAWoiDyAOIBEQyyUgDCAKKAIoIAooAiwQ0yMgCkG0BGogCkHIAWoiDhDFBiAOKAIYIREgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApCBDcCrAQgCkIANwKkBCAKQoCAgIDAADcCnAQgCkEANgKUBCAGIAcgDRDvJSAHIAYgDBDvJSAGIAcQzRwgCkGgAWogBhCgCSAKQZgCahDPLyAOEKIMIAooAtQBIgYgBigCACIGQQFrNgIAIAZBAUYEQCABEPseCyAKKALoASIBIAEoAgAiAUEBazYCACABQQFHDQAgDxC7IwsgCi0AoAEiAUEpRw0CIApBmwFqIApBtAFqKAIAIgE2AAAgCkGTAWogCkGsAWopAgAiFDcAACAKIAopAqQBIhU3AIsBIBBBFGogATYAACAQQQxqIBQ3AAAgECAVNwAEIBBBgICAgHg2AgAMAwsgCkGXAWoiBiAKQbABaikAADcAACAKQZABaiIHIApBqQFqKQAANwMAIApB2ABqIApBwAFqKQIANwIAIApBwQBqIAcpAwA3AAAgCkHIAGogBikAADcAACAKIAopAKEBIhQ3A4gBIAogCikCuAE3AlAgCiABOgA4IAogFDcAOSAQIApBOGoQgT4MAgsgCkGXAWoiBiAKQbABaikAADcAACAKQZABaiIHIApBqQFqKQAANwMAIApBgAFqIApBwAFqKQIANwIAIApB6QBqIAcpAwA3AAAgCkHwAGogBikAADcAACAKIAopAKEBIhQ3A4gBIAogCikCuAE3AnggCiABOgBgIAogFDcAYSAQIApB4ABqEP09DAELIApBlwFqIgYgCkGwAWopAAA3AAAgCkGQAWoiByAKQakBaikAADcDACAKQZACaiAKQcABaikCADcCACAKQfkBaiAHKQMANwAAIApBgAJqIAYpAAA3AAAgCiAKKQChASIUNwOIASAKIAopArgBNwKIAiAKIAE6APABIAogFDcA8QEgECAKQfABahD6PQsgCkHwBGokAAwHC0G8z/4AELI7AAtBvM/+ABCyOwALQczH/gBBI0Hwx/4AEMskAAtBgMj+AEEpIApBlARqQfzI/gBBrMj+ABDVHgALQcAAIAcQoz0ACyAOIAZBrM/+ABCxOwALIAYgB0Gsz/4AELA7AAsgC0H4A2oiASALQZQEaikCADcDACALQYAEaiIGIAtBnARqKAIANgIAIAsgCykCjAQ3A/ADIAsoAogEIgdBgICAgHhGBEAgACALKQPwAzcCBCAAQQE2AgAgAEEUaiAGKAIANgIAIABBDGogASkDADcCAAwCCyALQcADaiALQaAEakEs/AoAACALQbQDaiALQfgDaikDADcCACALQbwDaiALQYAEaigCADYCACALIAc2AqgDIAsgCykD8AM3AqwDIAtBCGogC0GoA2oQ7zwgCygCDCIBBEAgCygCCCEGIAFBxABsIQcDQCALQdACaiAGIAIgAyAEIAUgBkEkaigCACAGQUBrKAIAQQAgBkEsaigCABsgCCAJEJgBIAsoAtACBEAgCygC1AIhASALKQPYAiEFIAAgCykD4AI3AxAgACAFNwMIIAAgATYCBCAAQQE2AgAgC0GoA2oQ/iYMBAsgBkHEAGohBiALKQPYAiEFIAdBxABrIgcNAAsLIAtBqANqEP4mCyAAQQA2AgAgACAFNwMICyALQfAEaiQADwsAC0GAyP4AQSkgC0HQAmpB/Mj+AEGsyP4AENUeAAtBBEEcEKM9AAuRLgELfyMAQcABayICJAACQCABKAIMIgUEQCABKAIIIQQgASAFQQFrNgIMIAEgBEEMajYCCAJAAkACQAJAAkACQCAELQAAIgdBAWsOBgABAgMEBQELIAJBgAFqIARBBGoQzCIgAigChAEhBSACKAKAASEDDAQLIAQoAgghBSAEKAIEIQMgBC0AAyEIIAQtAAIhASAELQABIQYMAwsgAkGIAWogBEEEahDMIiACKAKMASEFIAIoAogBIQMMAgsgBC0AAiEBIAQtAAEhBgwBC0EEIQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEETIAQtAAEiBEEEayAEQQNNG0H/AXFBAWsOEwABAgMEBQYHCAkKCwwNDg8QERITC0EFIQYMEgtBBiEGDBELQQchBgwQC0EIIQYMDwtBCSEGDA4LQQohBgwNC0ELIQYMDAtBDCEGDAsLQQ0hBgwKC0EOIQYMCQtBDyEGDAgLQRAhBgwHC0ERIQYMBgtBEiEGDAULQRMhBgwEC0EUIQYMAwtBFSEGDAILQRYhBgwBCyAEIQYLIAAgBTYCCCAAIAM2AgQgACAIOgADIAAgAToAAiAAIAY6AAEgACAHOgAADAELAkACQAJAAkACQAJAIAEoAgQiCQRAAn8gASgCACIHLAAAIgRBAE4EQCAEQf8BcQwBCyAHLQABQT9xIQUgBEEfcSEDIANBBnQgBXIgBEFfTQ0AGiAHLQACQT9xIAVBBnRyIQUgBSADQQx0ciAEQXBJDQAaIANBEnRBgIDwAHEgBy0AA0E/cSAFQQZ0cnILIQQgByAJaiELIARBH0wEQCAEQQlrQQVJDQQMAwsgBEEgRg0DIARBJUYNASAEQYCAxABHDQILIAJBBzoAmAEMBAsgB0EBaiEFQQAhBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACfwJAAkACQCAJQQFGDQAgBSwAACIDQb9/TA0EAkAgCUEBayIEAn8CQAJAAkACQCADQQBIBEAgBy0AAkE/cSEGIANBH3EhCCADQV9LDQEgCEEGdCAGciEDDAILIANB/wFxIQMMAgsgBy0AA0E/cSAGQQZ0ciEGIANBcEkEQCAGIAhBDHRyIQMMAQsgCEESdEGAgPAAcSAHLQAEQT9xIAZBBnRyciIDQYCAxABGDQULIANBgAFPDQELQQEMAQtBAiADQYAQSQ0AGkEDQQQgA0GAgARJGwsiCE0EQCAEIAhGDQEMUgsgBSAIaiwAAEG/f0wNUQsgBSAIaiEFIAQgCGshBEEDIQoCQCADQS1rDgQCCgoDAAtBASADQSNGDQMaIANB3wBHDQlBAiEKQQAMAwsgAkGYAWogASAHIAkgBBCMIAxTC0EAIQpBAAwBC0EBIQpBAAshDCAFIAtHBEACQCAFLAAAIgNBAEgEQCAFLQABQT9xIQYgA0EfcSEIIANBX0sNASAIQQZ0IAZyIQMMBAsgA0H/AXEhA0EBIQYMBAsgBS0AAkE/cSAGQQZ0ciEGIANBcEkEQCAGIAhBDHRyIQMMAwsgCEESdEGAgPAAcSAFLQADQT9xIAZBBnRyciIDQYCAxABHDQILIAJBmAFqIAEgByAJIAQQjCAMUAsgByAJQQEgCUGQuIYBEKM2AAtBASEGIANBgAFPDQELQQEMAQtBACEGQQIgA0GAEEkNABpBA0EEIANBgIAESRsLIQgCQCAEIAhNBEAgBCAIRg0BDEgLIAUgCGosAABBv39MDUcLIAUgCGohBSAEIAhrIQQgDA0BCyADQSVrDlYWQUFBQUEXQUEEQUFBQQVBQQZBQQcDQUFBQUFBQD8+PUE8Ozo5QUFBOEFBN0E2NTQzMjEwLy5BQUFBQUEtLCsqKSgnLEEmJSQjIkEhIB8eHRwbGhkYAUELAkACfwJAIAZFBEAgAkEANgKkASADQYAQSQ0BIANBgIAETwRAIAIgA0ESdkHwAXI6AKQBIAIgA0EGdkE/cUGAAXI6AKYBIAIgA0EMdkE/cUGAAXI6AKUBQQQhBiACQaQBakEDcgwDCyACIANBDHZB4AFyOgCkASACIANBBnZBP3FBgAFyOgClAUEDIQYgAkGkAWpBAnIMAgsgA0H6AEcNAgxECyACIANBBnZBwAFyOgCkAUECIQYgAkGkAWpBAXILIANBP3FBgAFyOgAAIAJBpAFqIAZBwLiGAUEBEMEuDQILIAJBmAFqIAEgByAJIAQQjCAMSQsgAkGFJjsBpAEMQQsgA0Elaw5WEz4+Pj4+FD4+AT4+Pj4CPj4DPj4EAD4+Pj4+Pj08Ozo+OTg3Nj4+PjU+PjQ+MzIxMC8uLSwrPj4+Pj4+KikoJyYlJCk+IyIhIB8+Hh0cGxoZGBcWFT8+CyAFIARBqLqGAUEDEPQuDQQgBSAEQau6hgFBAhD0Lg0FIAJB+gA2ArgBQQEhAyAFIAQgAkG4AWpBARD0LkUEQCACQaQBaiABIAcgCSAEEIwgDEELIAJBEGogBSAEQQFBsLqGARCNJyACQYUeOwGkASACKAIUIQQgAigCECEFDEALIAIgBTYCsAEgAiAEIAVqNgK0AQJAAkACQAJAAkACQCACQbABahD1FiIDQYCAxABHBEAgAkHIAGogBSAEAn9BASADQYABSQ0AGkECIANBgBBJDQAaQQNBBCADQYCABEkbC0HguoYBEI0nIAIoAkwhBCACKAJIIQUgA0Ezaw4HBAICBQICBgELIAJBmAFqIAEgByAJIAQQjCAMSwsgA0HmAEYNAQsgAkGkAWogASAHIAkgBBCMIAxCCyACQYUUOwGkAQxBCyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkEgaiAFIARBAkEDQQQgA0GAgARJGyADQYAQSRtB8LqGARCNJyACKAIkIQQgAigCICEFDBMLIAJBGGogBSAEQQFB8LqGARCNJyACKAIcIQQgAigCGCEFIANB5gBHDRIgAkGFFjsBpAEMQAsgAiAFNgK4ASACIAQgBWo2ArwBIAJBuAFqEPUWIgNBgIDEAEYNByADQYABTwRAIAJBMGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQYC7hgEQjScgAigCNCEEIAIoAjAhBQwRCyACQShqIAUgBEEBQYC7hgEQjScgAigCLCEEIAIoAighBSADQeYARw0QIAJBhRg7AaQBDD8LIAIgBTYCuAEgAiAEIAVqNgK8ASACQbgBahD1FiIDQYCAxABGDQcgA0GAAU8EQCACQUBrIAUgBEECQQNBBCADQYCABEkbIANBgBBJG0GQu4YBEI0nIAIoAkQhBCACKAJAIQUMDwsgAkE4aiAFIARBAUGQu4YBEI0nIAIoAjwhBCACKAI4IQUgA0HmAEcNDiACQYUaOwGkAQw+CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkHYAGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQaC7hgEQjScgAigCXCEEIAIoAlghBQwNCyACQdAAaiAFIARBAUGgu4YBEI0nIAIoAlQhBCACKAJQIQUgA0HmAEcNDCACQYUCOwGkAQw9CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkHoAGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQbC7hgEQjScgAigCbCEEIAIoAmghBQwLCyACQeAAaiAFIARBAUGwu4YBEI0nIAIoAmQhBCACKAJgIQUgA0HmAEcNCiACQYUEOwGkAQw8CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkH4AGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQcC7hgEQjScgAigCfCEEIAIoAnghBQwJCyACQfAAaiAFIARBAUHAu4YBEI0nIAIoAnQhBCACKAJwIQUgA0HmAEcNCCACQYUGOwGkAQw7CyACIAUgBEEDQdC6hgEQjScgAkGFIjsBpAFBASEDIAIoAgQhBCACKAIAIQUMOwsgAkEIaiAFIARBAkHAuoYBEI0nIAJBhSA7AaQBQQEhAyACKAIMIQQgAigCCCEFDDoLIAJBmAFqIAEgByAJIAQQjCAMPwsgAkGYAWogASAHIAkgBBCMIAw+CyACQZgBaiABIAcgCSAEEIwgDD0LIAJBmAFqIAEgByAJIAQQjCAMPAsgAkGYAWogASAHIAkgBBCMIAw7CyACQZgBaiABIAcgCSAEEIwgDDoLIAJBpAFqIAEgByAJIAQQjCAMMgsgAkGkAWogASAHIAkgBBCMIAwxCyACQaQBaiABIAcgCSAEEIwgDDALIAJBpAFqIAEgByAJIAQQjCAMLwsgAkGkAWogASAHIAkgBBCMIAwuCyACQaQBaiABIAcgCSAEEIwgDC0LQQEhAyACQQE2AqwBIAJB0LuGATYCqAEgAkEAOgCkAQwtCyACQYUsOwGkAQwrC0EBIQMgAkEBOgCmASACQYQEOwGkAQwrCyABQQQ2AgwgAUHMvIYBNgIIIAJBpAFqQcC8hgEQgQ9BACEDDCoLIAJBADoApgEgAkGEGDsBpAEMKAsgAUEENgIMIAFB+LmGATYCCCACQQI6AKYBIAJBhBA7AaQBQQAhAwwoCyACQQA6AKYBIAJBhBo7AaQBDCYLQQEhAyACQQE2AqwBIAJB9bmGATYCqAEgAkECOgCkAQwmCyACQQA6AKYBIAJBhCg7AaQBDCQLIAFBBjYCDCABQeS+hgE2AgggAkGkAWpB2L6GARCBD0EAIQMMJAsgAkEAOgCmASACQYQMOwGkAQwiCyACQYUSOwGkAQwhC0EBIQMgAkEBNgKsASACQfS5hgE2AqgBIAJBAjoApAEMIQtBASEDIAJBAToApgEgAkGEDjsBpAEMIAsgAkECOgCmASACQYQgOwGkAQweCyACQQI6AKYBIAJBhB47AaQBDB0LQQEhAyACQQE6AKYBIAJBhBw7AaQBDB0LQQEhAyACQQE6AKYBIAJBhAo7AaQBDBwLQQEhAyACQQE6AKYBIAJBhCY7AaQBDBsLIAJBAjoApgEgAkGEEDsBpAEMGQtBASEDIAJBAToApgEgAkGEEDsBpAEMGQsgAUEMNgIMIAFBjL2GATYCCCACQaQBakGAvYYBEIEPQQAhAwwYCyACQYUIOwGkAQwWCyACQYUMOwGkAQwVCyACQYUcOwGkAQwUC0EBIQMgAkEBOgCmASACQQQ7AaQBDBQLIAFBBDYCDCABQai+hgE2AgggAkGkAWpBnL6GARCBD0EAIQMMEwtBASEDIAJBAToApgEgAkGEFDsBpAEMEgtBASEDIAJBAToApgEgAkGEFjsBpAEMEQtBASEDIAJBAToApgEgAkGEEjsBpAEMEAsgAUEENgIMIAFBxLmGATYCCCACQQE6AKYBIAJBhB47AaQBQQAhAwwPC0EBIQMgAkEBOgCmASACQYQkOwGkAQwOCyABQQI2AgwgAUGsuYYBNgIIIAJBAToApgEgAkGEHjsBpAFBACEDDA0LIAJBhRA7AaQBDAsLQQEhAyACQQE6AKYBIAJBhCI7AaQBDAsLQQEhAyACQQE6AKYBIAJBhCA7AaQBDAoLQQEhAyACQQE6AKYBIAJBhB47AaQBDAkLQQEhAyACQQE6AKYBIAJBhAY7AaQBDAgLIAFBBDYCDCABQfi4hgE2AgggAkEBOgCmASACQQQ7AaQBQQAhAwwHCyABQQQ2AgwgAUHEuIYBNgIIIAJBAToApgEgAkGEDjsBpAFBACEDDAYLQQEhAyACQQE6AKYBIAJBhAI7AaQBDAULIAJBhQo7AaQBDAMLIAJBhQ47AaQBDAILIAJBpAFqIAEgByAJIAQQjCAMAQsgAkEFOwGkAQtBASEDCwJAIApBA0cEQCADIAItAKQBQQRGcUUNASACIAo6AJoBIAIgAi0ApQE6AJkBIAJBBDoAmAEMBwsgAkGgAWogAkGsAWooAgA2AgAgAiACKQKkATcCmAEMBgsgAkGYAWogASAHIAkgBBCMIAJAIAItAKQBQQFrDgMABgAGCyACKAKsASIDRQ0FIAIoAqgBIANBARD4OgwFCyAFIAQgCCAEQbC4hgEQozYACyAFIAQgCCAEQaC4hgEQozYACyAEQYABSQ0BAkACQCAEQQh2IgNBH00EQCADRQ0BIANBFkcgBEGALUdyDQQMAwsgA0EgRg0BIANBMEcgBEGA4ABHcg0DDAILIARB/wFxQfvUiQFqLQAAQQFxDQEMAgsgBEH/AXFB+9SJAWotAABBAnFFDQELIAchBAJAA0ACfyAEIgUsAAAiA0EATgRAIANB/wFxIQMgBEEBagwBCyAFLQABQT9xIQYgA0EfcSEEIANBX00EQCAEQQZ0IAZyIQMgBUECagwBCyAFLQACQT9xIAZBBnRyIQYgA0FwSQRAIAYgBEEMdHIhAyAFQQNqDAELIARBEnRBgIDwAHEgBS0AA0E/cSAGQQZ0cnIhAyAFQQRqCyEEAkAgA0EgRiADQQlrQQVJcg0AIANBgAFJDQICQCADQQh2IgZBH00EQCAGRQ0BIAZBFkcNBCADQYAtRg0CDAQLIAZBIEcEQCAGQTBHDQQgA0GA4ABGDQIMBAsgA0H/AXFB+9SJAWotAABBAnENAQwDCyADQf8BcUH71IkBai0AAEEBcUUNAgsgCCAFayAEaiEIIAQgC0cNAAsgCSEICyAIRQRAQdG7hgFBHkGQvIYBEJ8pAAsCQAJAIAggCU8EQCAIIAlGDQEMAgsgByAIaiwAAEG/f0wNAQsgAkECOgCYASACIAc2ApwBIAIgCDYCoAEgByAIaiEFIAkgCGshBAwCCyAHIAlBACAIQaC8hgEQozYAC0EAIQUgByEEA0ACQCAFIQMgBCALRgRAIAkhAwwBCwJ/IAQsAAAiBUEATgRAIAVB/wFxIQUgBEEBagwBCyAELQABQT9xIQYgBUEfcSEIIAVBX00EQCAIQQZ0IAZyIQUgBEECagwBCyAELQACQT9xIAZBBnRyIQYgBUFwSQRAIAYgCEEMdHIhBSAEQQNqDAELIAhBEnRBgIDwAHEgBC0AA0E/cSAGQQZ0cnIhBSAEQQRqCyEIIAVBCWsiBkEXTUEAQQEgBnRBn4CABHEbDQBBACEKAkAgBUGAAUkNAAJAAkAgBUEIdiIGQR9NBEAgBkUNASAGQRZHDQMgBUGALUYhCgwDCyAGQSBGDQEgBkEwRw0CIAVBgOAARiEKDAILIAVB/wFxQfvUiQFqLQAAIQoMAQsgBUH/AXFB+9SJAWotAABBAnFBAXYhCgsgBUElRg0AIAMgBGsgCGohBSAIIQQgCkEBcUUNAQsLIANFBEBB0buGAUEeQfC7hgEQnykACwJAIAMgCU8EQCADIAlGDQEMAwsgAyAHaiwAAEG/f0wNAgsgAkEAOgCYASACIAc2ApwBIAIgAzYCoAEgAyAHaiEFIAkgA2shBAsgAi0AmAEiA0EHRgRAIABBBzoAAAwCCyAAIAIpAJkBNwABIABBCGogAkGgAWooAAA2AAAgASAENgIEIAEgBTYCACAAIAM6AAAMAQsgByAJQQAgA0GAvIYBEKM2AAsgAkHAAWokAAuFJQIafwN+IwBBwAZrIggkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABKQMAIh9QRQRAIAEpAwgiIFANASABKQMQIiFQDQIgHyAhfCAfVA0DIB8gIFQNBCABLgEYIQEgCCAfPgIMIAhBAUECIB9CgICAgBBUIgYbNgKsASAIQQAgH0IgiKcgBhs2AhAgCEEUakEAQZgB/AsAIAhBtAFqQQBBnAH8CwAgCEEBNgKwASAIQQE2AtACIAGsIB9CAX15fULCmsHoBH5CgKHNoLQCfEIgiKciBsEhDQJAIAFBAE4EQCAIQQxqIAEQtgYaDAELIAhBsAFqQQAgAWvBELYGGgsCQCANQQBIBEAgCEEMakEAIA1rQf//A3EQ3gUMAQsgCEGwAWogBkH//wFxEN4FCyAIQZwFaiAIQbABakGkAfwKAAAgAyIHQQpPBEAgCEGUBWohCwNAIAgoArwGIgFBKU8NEQJAIAFFDQAgAUH/////A2ohBiABQQJ0IQUCfyABQQFGBEBCACEfIAhBnAVqIAVqDAELIAUgC2ohASAGQf////8DcUEBakH+////B3EhCUIAIR8DQCABQQRqIgUgBTUCACAfQiCGhCIfQoCU69wDgCIgPgIAIAEgATUCACAfICBCgJTr3AN+fUIghoQiH0KAlOvcA4AiID4CACAfICBCgJTr3AN+fSEfIAFBCGshASAJQQJrIgkNAAsgH0IghiEfIAFBCGoLIAZBAXENAEEEayIBIB8gATUCAIRCgJTr3AOAPgIACyAHQQlrIgdBCUsNAAsLIAdBAnRBuOmJAWooAgBBAXQiB0UNBSAIKAK8BiIBQSlPDQ8gAQR/IAFB/////wNqIQYgAUECdCEFIAetIR8CfyABQQFGBEBCACEgIAhBnAVqIAVqDAELIAUgCGpBlAVqIQEgBkH/////A3FBAWpB/v///wdxIQlCACEgA0AgAUEEaiIFIAU1AgAgIEIghoQiICAfgCIhPgIAIAEgATUCACAgIB8gIX59QiCGhCIgIB+AIiE+AgAgICAfICF+fSEgIAFBCGshASAJQQJrIgkNAAsgIEIghiEgIAFBCGoLIQEgBkEBcUUEQCABQQRrIgEgICABNQIAhCAfgD4CAAsgCCgCvAYFQQALIQECQAJAAkAgCCgCrAEiBiABIAEgBkkbIgVBKE0EQCAFRQRAQQAhBQwECyAFQQFxIQwgBUEBRw0BQQAhBwwCCyAFQShBkIyKARCwOwALIAVBPnEhDkEAIQcgCEGcBWohASAIQQxqIQkDQCABIAEoAgAiEiAJKAIAaiILIAdBAXFqIhQ2AgAgAUEEaiIHIAcoAgAiFSAJQQRqKAIAaiIHIAsgEkkgCyAUS3JqIgs2AgAgByAVSSAHIAtLciEHIAlBCGohCSABQQhqIQEgDiAKQQJqIgpHDQALCyAMBH8gCkECdCIBIAhBnAVqaiILIAcgCygCACIHIAhBDGogAWooAgBqIgFqIgs2AgAgASAHSSABIAtLcgUgBwtBAXFFDQAgBUEoRg0RIAhBnAVqIAVBAnRqQQE2AgAgBUEBaiEFCyAIIAU2ArwGIAgoAtACIgogBSAFIApJGyIBQSlPDQ8gAUECdCEBAkACQANAIAFFDQEgAUEEayIBIAhBnAVqaigCACIFIAEgCEGwAWpqKAIAIgdGDQALIAUgB08NAQwICyABDQcLIA1BAWohDQwHC0Go2IkBQRxBsNuJARCfKQALQdTYiQFBHUHA24kBEJ8pAAtBhNmJAUEcQdDbiQEQnykAC0Ho2okBQTZBwNyJARCfKQALQaDaiQFBN0Gw3IkBEJ8pAAtB14yKAUEbQZCMigEQnykACyAGRQRAQQAhBiAIQQA2AqwBDAELIAZBAWtB/////wNxIgFBAWoiBUEDcSEJAkAgAUEDSQRAIAhBDGohAUIAIR8MAQsgBUH8////B3EhByAIQQxqIQFCACEfA0AgASABNQIAQgp+IB98Ih8+AgAgAUEEaiIFIAU1AgBCCn4gH0IgiHwiHz4CACABQQhqIgUgBTUCAEIKfiAfQiCIfCIfPgIAIAFBDGoiBSAFNQIAQgp+IB9CIIh8IiA+AgAgIEIgiCEfIAFBEGohASAHQQRrIgcNAAsLIAkEQANAIAEgATUCAEIKfiAffCIgPgIAIAFBBGohASAgQiCIIR8gCUEBayIJDQALCyAgQoCAgIAQWgRAIAZBKEYNCiAIQQxqIAZBAnRqIB8+AgAgBkEBaiEGCyAIIAY2AqwBC0EAIQVBASEMIA3BIgEgBMEiB0giGg0EIA0gBGvBIAMgASAHayADSRsiC0UNBEEAIgFFBEAgCEHUAmogCEGwAWpBpAH8CgAAC0EBIRIgCEHUAmpBARC2BiEUIAFFBEAgCEH4A2ogCEGwAWpBpAH8CgAACyAIQfgDakECELYGIRUgAUUEQCAIQZwFaiAIQbABakGkAfwKAAALIAhBrAFqIRsgCEHQAmohHCAIQfQDaiEdIAhBmAVqIR4gCEGcBWpBAxC2BiEWIBQoAqABIRcgFSgCoAEhGCAWKAKgASEZQQAhDiAIKAKsASEGIAgoAtACIQoCQANAIAZBKU8NCyAGQQJ0IQRBACEBAn8CQAJAA0AgASAERg0BIAhBDGogAWogAUEEaiEBKAIARQ0ACyAZIAYgBiAZSRsiBEEpTw0FIARBAnQhAQJAA0AgAUUNASABIB5qIQUgAUEEayIBIAhBDGpqKAIAIgcgBSgCACIFRg0ACyAFIAdNDQJBAAwDCyABRQ0BQQAMAgsgAyALSQ0FAkAgCyAORg0AIAsgDmsiAUUNACACIA5qQTAgAfwLAAsgACANOwEIIAAgCzYCBAwJC0EBIQdBACEGIARBAUcEQCAEQT5xIQwgCEEMaiEBIAhBnAVqIQkDQCABIAEoAgAiDyAJKAIAQX9zaiIFIAdBAXFqIhA2AgAgAUEEaiIHIAcoAgAiESAJQQRqKAIAQX9zaiIHIAUgD0kgBSAQS3JqIgU2AgAgByARSSAFIAdJciEHIAlBCGohCSABQQhqIQEgDCAGQQJqIgZHDQALCyAEQQFxBH8gBkECdCIBIAhBDGpqIgYgBigCACIGIAEgFmooAgBBf3NqIgEgB2oiBTYCACABIAZJIAEgBUtyBSAHC0EBcUUNDSAIIAQ2AqwBIAQhBkEICyEMIBggBiAGIBhJGyIEQSlPDQQgBEECdCEBAkACQAJAA0AgAUUNASABIB1qIQUgAUEEayIBIAhBDGpqKAIAIgcgBSgCACIFRg0ACyAFIAdNDQEgBiEEDAILIAFFDQAgBiEEDAELIAQEQEEBIQdBACEGIARBAUcEQCAEQT5xIQ8gCEEMaiEBIAhB+ANqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIFIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAUgEEkgBSARS3JqIgU2AgAgByATSSAFIAdJciEHIAlBCGohCSABQQhqIQEgDyAGQQJqIgZHDQALCyAEQQFxBH8gBkECdCIBIAhBDGpqIgYgBigCACIGIAEgFWooAgBBf3NqIgEgB2oiBTYCACABIAZJIAEgBUtyBSAHC0EBcUUNDgsgCCAENgKsASAMQQRyIQwLIBcgBCAEIBdJGyIFQSlPDQUgBUECdCEBAkACQAJAA0AgAUUNASABIBxqIQYgAUEEayIBIAhBDGpqKAIAIgcgBigCACIGRg0ACyAGIAdNDQEgBCEFDAILIAFFDQAgBCEFDAELIAUEQEEBIQdBACEGIAVBAUcEQCAFQT5xIQ8gCEEMaiEBIAhB1AJqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIEIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAQgEEkgBCARS3JqIgQ2AgAgByATSSAEIAdJciEHIAlBCGohCSABQQhqIQEgDyAGQQJqIgZHDQALCyAFQQFxBH8gBkECdCIBIAhBDGpqIgQgBCgCACIEIAEgFGooAgBBf3NqIgEgB2oiBjYCACABIARJIAEgBktyBSAHC0EBcUUNDgsgCCAFNgKsASAMQQJqIQwLIAogBSAFIApJGyIGQSlPDQsgBkECdCEBAkACQAJAA0AgAUUNASABIBtqIQQgAUEEayIBIAhBDGpqKAIAIgcgBCgCACIERg0ACyAEIAdNDQEgBSEGDAILIAFFDQAgBSEGDAELIAYEQEEBIQdBACEFIAZBAUcEQCAGQT5xIQ8gCEEMaiEBIAhBsAFqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIEIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAQgEEkgBCARS3JqIgQ2AgAgByATSSAEIAdJciEHIAlBCGohCSABQQhqIQEgDyAFQQJqIgVHDQALCyAGQQFxBH8gBUECdCIBIAhBDGpqIgQgBCgCACIEIAhBsAFqIAFqKAIAQX9zaiIBIAdqIgU2AgAgASAESSABIAVLcgUgBwtBAXFFDQ4LIAggBjYCrAEgDEEBaiEMCyADIA5NDQEgAiAOaiAMQTBqOgAAIAZBKU8NCwJAIAZFBEBBACEGDAELIAZBAWtB/////wNxIgFBAWoiBEEDcSEJAkAgAUEDSQRAIAhBDGohAUIAISAMAQsgBEH8////B3EhByAIQQxqIQFCACEgA0AgASABNQIAQgp+ICB8Ih8+AgAgAUEEaiIEIAQ1AgBCCn4gH0IgiHwiHz4CACABQQhqIgQgBDUCAEIKfiAfQiCIfCIfPgIAIAFBDGoiBCAENQIAQgp+IB9CIIh8Ih8+AgAgH0IgiCEgIAFBEGohASAHQQRrIgcNAAsLIAkEQANAIAEgATUCAEIKfiAgfCIfPgIAIAFBBGohASAfQiCIISAgCUEBayIJDQALCyAfQoCAgIAQVA0AIAZBKEYNCyAIQQxqIAZBAnRqICA+AgAgBkEBaiEGCyAIIAY2AqwBIA5BAWohDiASIAsgEksiAWohEiABDQALQQAhDCALIQUMBQsgDiADQZDciQEQwyEACyAEQShBkIyKARCwOwALIAsgA0Gg3IkBELA7AAsgBEEoQZCMigEQsDsACyAFQShBkIyKARCwOwALAkACfwJAAkAgCkEpSQRAAkAgCkUEQEEAIQoMAQsgCkEBa0H/////A3EiAUEBaiIEQQNxIQkCQCABQQNJBEAgCEGwAWohAUIAIR8MAQsgBEH8////B3EhByAIQbABaiEBQgAhHwNAIAEgATUCAEIFfiAffCIfPgIAIAFBBGoiBCAENQIAQgV+IB9CIIh8Ih8+AgAgAUEIaiIEIAQ1AgBCBX4gH0IgiHwiHz4CACABQQxqIgQgBDUCAEIFfiAfQiCIfCIgPgIAICBCIIghHyABQRBqIQEgB0EEayIHDQALCyAJBEADQCABIAE1AgBCBX4gH3wiID4CACABQQRqIQEgIEIgiCEfIAlBAWsiCQ0ACwsgIEKAgICAEFQNACAKQShGDQkgCEGwAWogCkECdGogHz4CACAKQQFqIQoLIAggCjYC0AIgCiAGIAYgCkkbIgFBKU8NByABQQJ0IQEgCEEIaiEHIAhBrAFqIQsCQAJ/AkADQCABRQ0BIAEgC2ohBiABIAdqIAFBBGshASgCACIEIAYoAgAiBkYNAAsgBCAGSyAEIAZJawwBC0F/QQAgARsLQf8BcQ4CAAIDC0EAIAwNAxogAyAFQQFrIgFLBEAgASACai0AAEEBcQ0CDAMLIAEgA0Hg24kBEMMhAAsgCkEoQZCMigEQsDsACyADIAVJDQQgAiAFaiEGQQAhAQJAAkADQCABIAVqRQ0BIAFBAWsiASAGaiIELQAAQTlGDQALIAQgBC0AAEEBajoAACABIAVqQQFqIgYgBU0NASAGIAVBwOqJARCvOwALAkAgDARAQTEhAQwBCyACQTE6AABBMCEBIAVBAWsiBEUgBEVyDQAgAkEBakEwIAT8CwALIA1BAWohDSAaIAMgBU1yDQEgBiABOgAAIAVBAWohBQwBCyABQX9GDQAgAUF/cyIBRQ0AIARBAWpBMCAB/AsACyADIAVJDQEgBQshASAAIA07AQggACABNgIEDAELIAUgA0GA3IkBELA7AAsgACACNgIAIAhBwAZqJAAPCyAFIANB8NuJARCwOwALIAFBKEGQjIoBELA7AAtBKEEoQZCMigEQwyEACyAGQShBkIyKARCwOwALQaCMigFBGkGQjIoBEJ8pAAunLgIKfwJ+IwBBwBVrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtACBBAWsOBAIIAQMACyACQZAKaiIDIABBCGooAgA2AgAgAiAAKQIANwOICiACQdgLaiIGIABBGGpBwLfDACACQYgKaiIEENQQIAMgAEEUaigCADYCACACIAApAgw3A4gKIAJB+AJqIgMgBkHs9sIAIAQQiw4gAEEoaiIIIANBgAf8CgAAIABBADoAqAcgAEGoB2ohCgwFCyAAQShqIQggAEGoB2ohCiAALQCoB0EBaw4DAgYFBAtB9PbCABDoKwALIABBKGohAyAAQYQCaiEIAkACQCAALQCEAkEBaw4DAQYAEgsgAEH4AWohBiAAQYACaiEEAkAgAC0AgAJBAWsOAwMGFgALIAYoAgAhBQwUC0G888IAEOgrAAtBrPPCABDoKwALQfjywgAQ6CsACyAAQYACaiAIQdgB/AoAAEIDIQwgACgCiAIhBSAAKQOAAiINQgNRBEAgACgC0AMiAyADKAIAIgNBAWs2AgAgA0EBRw0NIABB0ANqEJ0nDA0LIAJBlApqIABBNGpBxAH8CgAAIAIgBTYCkAogAiANNwOICiACQdgLaiIDIABB0ANqIAJBiApqEM4SIABB2ANqIANB0AP8CgAACyAAQdgDaiELAkACQAJAIAAtAKQHQQFrDgMBAwIACyAAQQA6AKUHIABBqAVqIgMgC0HQAfwKAAAgABCvPjYC+AYgAEH4BmohB0GH6sIAIQVBByEEAkACQAJAAkACQAJAAkACQAJAAkACQCAALQDcBkEBaw4KAAECAwQFBgcICQoLQY7qwgAhBUEDIQQMCQtBkerCACEFQQQhBAwIC0GV6sIAIQVBAyEEDAcLQZjqwgAhBUEGIQQMBgtBnurCACEFQQQhBAwFC0Gi6sIAIQVBBSEEDAQLQafqwgAhBQwDC0Gu6sIAIQVBBSEEDAILIAJBmAFqIABB3QZqEP8sIAIoApwBIQQgAigCmAEhBQwBCyACQaABaiAAQeAGahDXOyACKAKkASEEIAIoAqABIQULIAcgBSAEEO06IAJBkAFqENMlIAIoApQBIQUCQCACKAKQAUEBcUUNACACQYgBaiAFEIQZIAIoAowBIQUgAigCiAEiBkUNACAGIAUQ+johBQwKCyAAIAU2AvwGIABBAToApQcgAkGYFGogAxD7LiACQbARaiACQaAUaikCADcDACACIAIpApgUNwOoESACQYABaiACQagRahDtEiACKAKAASIFBEAgAEH8BmohCSACKAKEASEGA0ACQCAFKAIABEAgBSgCCCEDIAUoAgQhBAwBC0EGIQNBmOHCACEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFLQAEQQFrDlAAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1ALQQ4hA0Ge4cIAIQQMTwtBDyEDQazhwgAhBAxOC0EPIQNBu+HCACEEDE0LQQ0hA0HK4cIAIQQMTAtBICEDQdfhwgAhBAxLC0EcIQNB9+HCACEEDEoLQRwhA0GT4sIAIQQMSQtBGyEDQa/iwgAhBAxIC0EdIQNByuLCACEEDEcLQRYhA0Hn4sIAIQQMRgtBHiEDQf3iwgAhBAxFC0EdIQNBm+PCACEEDEQLQQMhA0G448IAIQQMQwtBBSEDQbvjwgAhBAxCC0EHIQNBwOPCACEEDEELQQ0hA0HH48IAIQQMQAtBDSEDQdTjwgAhBAw/C0EMIQNB4ePCACEEDD4LQREhA0Ht48IAIQQMPQtBCiEDQf7jwgAhBAw8C0ETIQNBiOTCACEEDDsLQRAhA0Gb5MIAIQQMOgtBECEDQavkwgAhBAw5C0EOIQNBu+TCACEEDDgLQRAhA0HJ5MIAIQQMNwtBDSEDQdnkwgAhBAw2C0EXIQNB5uTCACEEDDULQSMhA0H95MIAIQQMNAtBDCEDQaDlwgAhBAwzC0Gs5cIAIQQMMgtBAyEDQbLlwgAhBAwxC0EEIQNBteXCACEEDDALQQQhA0G55cIAIQQMLwtBveXCACEEDC4LQQchA0HD5cIAIQQMLQtBCSEDQcrlwgAhBAwsC0EEIQNB0+XCACEEDCsLQQQhA0HX5cIAIQQMKgtBCCEDQdvlwgAhBAwpC0ERIQNB4+XCACEEDCgLQQ0hA0H05cIAIQQMJwtBCCEDQYHmwgAhBAwmC0ETIQNBiebCACEEDCULQQ0hA0Gc5sIAIQQMJAtBBCEDQanmwgAhBAwjC0EIIQNBrebCACEEDCILQQwhA0G15sIAIQQMIQtBwebCACEEDCALQcfmwgAhBAwfC0ESIQNBzebCACEEDB4LQRMhA0Hf5sIAIQQMHQtBDyEDQfLmwgAhBAwcC0EbIQNBgefCACEEDBsLQQUhA0Gc58IAIQQMGgtBByEDQaHnwgAhBAwZC0EPIQNBqOfCACEEDBgLQQchA0G358IAIQQMFwtBCyEDQb7nwgAhBAwWC0EUIQNByefCACEEDBULQRghA0Hd58IAIQQMFAtBESEDQfXnwgAhBAwTC0EWIQNBhujCACEEDBILQRUhA0Gc6MIAIQQMEQtBsejCACEEDBALQQohA0G36MIAIQQMDwtBGSEDQcHowgAhBAwOC0ECIQNB2ujCACEEDA0LQQchA0Hc6MIAIQQMDAtBESEDQePowgAhBAwLC0EKIQNB9OjCACEEDAoLQQchA0H+6MIAIQQMCQtBGSEDQYXpwgAhBAwIC0EEIQNBnunCACEEDAcLQQMhA0Gi6cIAIQQMBgtBByEDQaXpwgAhBAwFC0EQIQNBrOnCACEEDAQLQRYhA0G86cIAIQQMAwtBFiEDQdLpwgAhBAwCC0EPIQNB6OnCACEEDAELQRAhA0H36cIAIQQLIAJB+ABqIAYQ4yAgAigCeCIGRQRAIAIQ1SkhBQwLCyACQfAAaiAJIAQgAyAGIAIoAnwQuigCQCACKAJwQQFxRQ0AIAJB6ABqIAIoAnQQhBkgAigCaCIDRQ0AIAMgAigCbBD6OiEFDAsLIAJB4ABqIAJBqBFqEO0SIAIoAmQhBiACKAJgIgUNAAsLIABBADoApQcgAiAAKAL8BjYCqBEgByACQagRahDsOiACKAKoESIDQYQBTwRAIAMQ8h8LIAAtAPAGRQRAIAcQpTsLIAAoAtQGIgNBBEcEQCAHIAMQpDsLIAAoAtgGIgNBB0cEQCAHIAMQkj0LIAAoAsAGQQFHDQQgAEHEBmoiAxDmKA0EIAJB2ABqIAMQyiEgAigCXCEFIAIoAlhBAXENCCACIAU2AqgRIAcgAkGoEWoQzC0gAigCqBEiA0GEAUkNBCADEPIfDAQLQcDxwgAQ6CsACyAAQZgHaiEFIABBoAdqIQcCQCAALQCgB0EBaw4DAgEFAAsgBSgCACEEDAMLAAtB+PLCABDoKwALIAJBqBFqEJkfIAIoAqwRIQUgAigCqBENAyACQaAUaiACQbgRaikCACIMNwMAIAIgAikCsBEiDTcDmBQgACAFNgKAByAAIA03AoQHIABBjAdqIAw3AgAgAEGAB2ohAyAAKAK4BiIGQYCU69wDRwRAIAMgACkDsAYgBhDNEQsgAiADENE7NgKoESAHIAJBqBFqEM0tIAIoAqgRIgNBhAFPBEAgAxDyHwsgAkHQAGogACgC/AUgACgCgAYgBxCAJCACKAJUIQUCQCACKAJQQQFxRQ0AIAJByABqIAUQhBkgAigCTCEFIAIoAkgiA0UNACADIAUQ+johBQwDCyAAIAU2ApQHIABBlAdqEIwXIQQgAEEAOgCgByAAIAQ2ApgHIABBoAdqIQcgAEGYB2ohBQsgACAEEPsONgKcBwsgAkFAayAAQZwHaiIDIAEQxxgCQAJAAkACQAJAAkACQAJAAkAgAigCQCIEQQJHBEAgAigCRCEGIAMoAgAiCSAJKAIAQQFrIgk2AgAgCUUEQCADELIaCwJAAkACQCAEQQFxRQ0AIAJBOGogBhCEGSACKAI8IQYgAigCOCIERQ0AIAYhAwwBCyACIAY2AqgRIAJBqBFqIgMQozsNASADQSNBAEEBQQEQoBggAigCrBEhAyACKAKoEUEBRg0DIAIoArARIglBiPPCAEEj/AoAAEEMQQQQrTYiBEUNBCAEQSM2AgggBCAJNgIEIAQgAzYCAEHo6sIAIQMgBkGEAUkNACAGEPIfCyAHQQE6AAAgBRDkKCACIAM2ApQSIAIgBDYCkBIgAkEANgKgFCACQoCAgIAQNwKYFCACQezewgA2AqwRIAJCoICAgA43ArARIAIgAkGYFGo2AqgRIAJBkBJqIAJBqBFqEIM2DQQgAkHoEmogAkGgFGooAgAiAzYCACACIAIpApgUNwPgEiACKALkEiADQdLywgBBJBDBLiEDIAJB4BJqEN47QQEgAgJ/IANFBEAgAigClBIhBSACKAKQEgwBCyACQZASahC8KkGgs8MAIQVBAQsgBRDYKSEFIAAoApQHIgNBhAFJDQsgAxDyHwwLCyAHQQE6AAAgBRDkKCACIAY2AoQQIAJBqBFqIgMQ2SkgAkGIEGogAyACQYQQaiIEEI89EOASIAJB4BJqIgUgBBDiJiACKALoEiEHIAIoAuQSIQkgAkEANgKgFCACQQA2ApgUIAJBADYCqBQgAyACQZgUaiAJIAcQvBogAigCqBFBAkYNBCACQdAQaiADQcgA/AoAACAFEN47IAIgBBCQPTYCmBEgAyACQZgRahDHEiACLQCsESIDQQNGDQUgA0ECRg0GIAIoAqgRIQQgAiADOgCgESACIAQ2ApwRIAJBMGogAkGcEWoQ/CkgAigCMCIFQQJHBEAgAkGkFGohByACKAI0IQQDQCAFQQFxDQkgAiAENgKkESACQShqIAJBpBFqEMgkIAIoAihBAXENCiACQfgUaiIFIAIoAiwQqysgAkHgEmoiAyACKAL8FCACKAKAFRCQNSACQagRaiIEIAMQyBMgAigCqBFBgICAgHhGDQsgAkGoFGogAkG4EWopAgA3AwAgAkGgFGogAkGwEWopAgAiDDcDACACIAIpAqgRIg03A5gUIAJBmBJqIAw+AgAgAiANNwOQEiACQegSaiAHQQhqKAIANgIAIAIgBykCADcD4BIgBCACQYgQaiIJQcgA/AoAACAJIAQgAkGQEmoiBCADELANIAMQ3jsgBBDeOyAFEN47IAIoAqQRIgNBhAFPBEAgAxDyHwsgAkEgaiACQZwRahD8KSACKAIkIQQgAigCICIFQQJHDQALCyACKAKcESIDQYQBTwRAIAMQ8h8LIAItAJEQIQUgAi0AkBAhBAJAAkACQCACKQOIECIMQgNRBEAgBkGEAU8EQCAGEPIfCyACQeASaiACQdAQakHIAPwKAAAgAkG4E2ogAEGQB2ooAgA2AgAgAkGwE2ogAEGIB2opAgA3AgAgAiAAKQKABzcCqBMgAkHwEmoQ3jsgAkGoE2oQvSgMAQsgAiAFOgCZEiACIAQ6AJgSIAIgDDcDkBIgAkGaEmogAkGSEGpBPvwKAAAgAiAGNgLYEiACQeASaiACQdAQakHIAPwKAAAgAkG4E2ogAEGQB2ooAgA2AgAgAkGwE2ogAEGIB2opAgA3AgAgAiAAKQKABzcCqBMgAkGYFGogAkHgEmpB3AD8CgAAIAJB+BRqIgMgAkHQEGpByAD8CgAAIAJBqBFqIAJBkBJqIAMgAkHgFGoQkyAgAikDqBEiDEIDUg0BIAItALERIQUgAi0AsBEhBAtCAyEMQQEgAiAEIAUQrB4hBQwBCyACKAKwESEFIAJBvBNqIAJBtBFqQdwA/AoAAAsgAigCmBEiA0GEAU8EQCADEPIfCyAAKAKUByIDQYQBTwRAIAMQ8h8LIABBADoApQcgACgC+AYiBEGEAUkNDgwNCyAAQQM6AKAHIABBAzoApAcMEQsgAyACKAKwEUHc88IAEP0vAAtBBEEMEKM9AAtBlN/CAEE3IAJB4BJqQYTfwgBBzN/CABDVHgALQdDxwgBBCRCXPQALQdnxwgBBEBCXPQALQenxwgBBGBCXPQALQYHywgBBHhCXPQALQZ/ywgBBEhCXPQALQbHywgBBIRCXPQALIABBgAdqEL0oCyAALQClB0UNACAAKAL8BiIDQYQBSQ0AIAMQ8h8LIABBADoApQdCAyEMIAAoAvgGIgRBgwFLDQAgAEGoBWoQqR4gAEEBOgCkBwwCCyAEEPIfCyAAQagFahCpHiAAQQE6AKQHIAxCBFENAwsgAkGoD2ogAkG8E2pB3AD8CgAAIAsQzSQgACgC0AMiAyADKAIAIgNBAWs2AgAgA0EBRw0AIABB0ANqEJ0nCyAKQQE6AAAgCBCqHiAMQgNRDQUgAiAFNgKYAiACIAw3A5ACIAJBnAJqIAJBqA9qQdwA/AoAACACQagBaiIDIAJBkAJqEJETIAIpA6gBQgNRDQYgAkHYC2oiBiADQegA/AoAACAIIAZB3AH8CgAAIABBADoAhAIgAEEoaiEDIABBhAJqIQgLIABBkAFqIANB6AD8CgAAIAJBGGogAEHYAWoQxyQgAigCHCEFIAIoAhhBAXFFDQEgAkEQaiAFEIQZIAIoAhQhBSACKAIQIgZFDQFBBSACIAYgBRDYKSEEDAgLQQMhBSAKQQM6AABBASEEDAYLIABBADoAgAIgACAFNgL4ASAAQYACaiEEIABB+AFqIQYLIAAgBRD7DjYC/AELIAJBCGogAEH8AWoiBSABEMcYIAIoAggiAUECRwRAIAIoAgwhCCAFKAIAIgcgBygCAEEBayIHNgIAIAdFBEAgBRCyGgsCQCABQQFxBEAgAiAIEIQZIAIoAgQhCCACKAIAIgENAQsgBEEBOgAAIAYQ5CggAiAINgKQAiACIAJBkAJqEJQ9NgKoESACQYgKaiIBIAJBqBFqIgYQlj1BzPPCABDOGCAGIAIoAowKIAIoApAKEIMkIAJB+AJqIAEQ5xUgAikCgAMhDCACKAL8AiEEIAIoAvgCIQEgAigCqBEiBkGDAUsEQCAGEPIfCyACKAKQAiIGQYQBTwRAIAYQ8h8LIABBkAFqEKElIABBAToAhAIgAxDSLSABRQ0HIAIgDDcCgAogAiAENgL8CSACIAE2AvgJIAJB2AtqIAAoAhwgAkH4CWoQxiYgAigC2AsNBCAAKAIYIgEgASgCACIBQQFrNgIAQQEhBUEAIQQgAUEBRw0FIABBGGoQnScMBQsgBEEBOgAAIAYQ5ChBBSACIAEgCBDYKSEEDAULIARBAzoAACAIQQM6AABBASEEQQQhBQwDCyACIAU2AtgLQZzgwgBBKyACQdgLakHI4MIAQYT3wgAQ1R4ACyACIAIoArABNgLYC0Gc4MIAQSsgAkHYC2pByODCAEGU98IAENUeAAsgAkGAA2ogAkHgC2opAgA3AwAgAiACKQLYCzcD+AJBnODCAEErIAJB+AJqQYzgwgBBtPfCABDVHgALIAAgBToAICACQcAVaiQAIAQPCyAAQZABahChJSAAQQE6AIQCIAMQ0i0LIAIgBDYC+AJBnODCAEErIAJB+AJqQcjgwgBBpPfCABDVHgALpy4CC38CfiMAQcAVayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAgQQFrDgQCCAEDAAsgAkGQCmoiAyAAQQhqKAIANgIAIAIgACkCADcDiAogAkHYC2oiBiAAQRhqQcC3wwAgAkGICmoiBBDUECADIABBFGooAgA2AgAgAiAAKQIMNwOICiACQfgCaiIDIAZBzLrDACAEEIsOIABBKGoiCCADQYAH/AoAACAAQQA6AKgHIABBqAdqIQoMBQsgAEEoaiEIIABBqAdqIQogAC0AqAdBAWsOAwIGBQQLQdS6wwAQ6CsACyAAQShqIQMgAEGEAmohCAJAAkAgAC0AhAJBAWsOAwEGABILIABB+AFqIQYgAEGAAmohBAJAIAAtAIACQQFrDgMDBhYACyAGKAIAIQUMFAtBrLjDABDoKwALQZy4wwAQ6CsAC0Hot8MAEOgrAAsgAEGAAmogCEHYAfwKAABCAyENIAAoAogCIQUgACkDgAIiDkIDUQRAIAAoAtADIgMgAygCACIDQQFrNgIAIANBAUcNDSAAQdADahCdJwwNCyACQZQKaiAAQTRqQcQB/AoAACACIAU2ApAKIAIgDjcDiAogAkHYC2oiAyAAQdADaiACQYgKahDOEiAAQdgDaiADQdAD/AoAAAsgAEHYA2ohCwJAAkACQCAALQCkB0EBaw4DAQMCAAsgAEEAOgClByAAQagFaiIDIAtB0AH8CgAAIAAQrz42AvgGIABB+AZqIQdB87HDACEFQQchBAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A3AZBAWsOCgABAgMEBQYHCAkKC0H6scMAIQVBAyEEDAkLQf2xwwAhBUEEIQQMCAtBgbLDACEFQQMhBAwHC0GEssMAIQVBBiEEDAYLQYqywwAhBUEEIQQMBQtBjrLDACEFQQUhBAwEC0GTssMAIQUMAwtBmrLDACEFQQUhBAwCCyACQZgBaiAAQd0GahD/LCACKAKcASEEIAIoApgBIQUMAQsgAkGgAWogAEHgBmoQ1zsgAigCpAEhBCACKAKgASEFCyAHIAUgBBDtOiACQZABahDTJSACKAKUASEFAkAgAigCkAFBAXFFDQAgAkGIAWogBRCEGSACKAKMASEFIAIoAogBIgZFDQAgBiAFEPo6IQUMCgsgACAFNgL8BiAAQQE6AKUHIAJBmBRqIAMQ+y4gAkGwEWogAkGgFGopAgA3AwAgAiACKQKYFDcDqBEgAkGAAWogAkGoEWoQ7RIgAigCgAEiBQRAIABB/AZqIQkgAigChAEhBgNAAkAgBSgCAARAIAUoAgghAyAFKAIEIQQMAQtBBiEDQYSpwwAhBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBS0ABEEBaw5QAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QC0EOIQNBiqnDACEEDE8LQQ8hA0GYqcMAIQQMTgtBDyEDQaepwwAhBAxNC0ENIQNBtqnDACEEDEwLQSAhA0HDqcMAIQQMSwtBHCEDQeOpwwAhBAxKC0EcIQNB/6nDACEEDEkLQRshA0GbqsMAIQQMSAtBHSEDQbaqwwAhBAxHC0EWIQNB06rDACEEDEYLQR4hA0HpqsMAIQQMRQtBHSEDQYerwwAhBAxEC0EDIQNBpKvDACEEDEMLQQUhA0Gnq8MAIQQMQgtBByEDQayrwwAhBAxBC0ENIQNBs6vDACEEDEALQQ0hA0HAq8MAIQQMPwtBDCEDQc2rwwAhBAw+C0ERIQNB2avDACEEDD0LQQohA0Hqq8MAIQQMPAtBEyEDQfSrwwAhBAw7C0EQIQNBh6zDACEEDDoLQRAhA0GXrMMAIQQMOQtBDiEDQaeswwAhBAw4C0EQIQNBtazDACEEDDcLQQ0hA0HFrMMAIQQMNgtBFyEDQdKswwAhBAw1C0EjIQNB6azDACEEDDQLQQwhA0GMrcMAIQQMMwtBmK3DACEEDDILQQMhA0GercMAIQQMMQtBBCEDQaGtwwAhBAwwC0EEIQNBpa3DACEEDC8LQamtwwAhBAwuC0EHIQNBr63DACEEDC0LQQkhA0G2rcMAIQQMLAtBBCEDQb+twwAhBAwrC0EEIQNBw63DACEEDCoLQQghA0HHrcMAIQQMKQtBESEDQc+twwAhBAwoC0ENIQNB4K3DACEEDCcLQQghA0HtrcMAIQQMJgtBEyEDQfWtwwAhBAwlC0ENIQNBiK7DACEEDCQLQQQhA0GVrsMAIQQMIwtBCCEDQZmuwwAhBAwiC0EMIQNBoa7DACEEDCELQa2uwwAhBAwgC0GzrsMAIQQMHwtBEiEDQbmuwwAhBAweC0ETIQNBy67DACEEDB0LQQ8hA0HersMAIQQMHAtBGyEDQe2uwwAhBAwbC0EFIQNBiK/DACEEDBoLQQchA0GNr8MAIQQMGQtBDyEDQZSvwwAhBAwYC0EHIQNBo6/DACEEDBcLQQshA0Gqr8MAIQQMFgtBFCEDQbWvwwAhBAwVC0EYIQNBya/DACEEDBQLQREhA0Hhr8MAIQQMEwtBFiEDQfKvwwAhBAwSC0EVIQNBiLDDACEEDBELQZ2wwwAhBAwQC0EKIQNBo7DDACEEDA8LQRkhA0GtsMMAIQQMDgtBAiEDQcawwwAhBAwNC0EHIQNByLDDACEEDAwLQREhA0HPsMMAIQQMCwtBCiEDQeCwwwAhBAwKC0EHIQNB6rDDACEEDAkLQRkhA0HxsMMAIQQMCAtBBCEDQYqxwwAhBAwHC0EDIQNBjrHDACEEDAYLQQchA0GRscMAIQQMBQtBECEDQZixwwAhBAwEC0EWIQNBqLHDACEEDAMLQRYhA0G+scMAIQQMAgtBDyEDQdSxwwAhBAwBC0EQIQNB47HDACEECyACQfgAaiAGEOMgIAIoAngiBkUEQCACENUpIQUMCwsgAkHwAGogCSAEIAMgBiACKAJ8ELooAkAgAigCcEEBcUUNACACQegAaiACKAJ0EIQZIAIoAmgiA0UNACADIAIoAmwQ+johBQwLCyACQeAAaiACQagRahDtEiACKAJkIQYgAigCYCIFDQALCyAAQQA6AKUHIAIgACgC/AY2AqgRIAcgAkGoEWoQ7DogAigCqBEiA0GEAU8EQCADEPIfCyAALQDwBkUEQCAHEKU7CyAAKALUBiIDQQRHBEAgByADEKQ7CyAAKALYBiIDQQdHBEAgByADEJI9CyAAKALABkEBRw0EIABBxAZqIgMQ5igNBCACQdgAaiADEMohIAIoAlwhBSACKAJYQQFxDQggAiAFNgKoESAHIAJBqBFqEMwtIAIoAqgRIgNBhAFJDQQgAxDyHwwEC0GItsMAEOgrAAsgAEGYB2ohBSAAQaAHaiEHAkAgAC0AoAdBAWsOAwIBBQALIAUoAgAhBAwDCwALQei3wwAQ6CsACyACQagRahCZHyACKAKsESEFIAIoAqgRDQMgAkGgFGogAkG4EWopAgAiDTcDACACIAIpArARIg43A5gUIAAgBTYCgAcgACAONwKEByAAQYwHaiANNwIAIABBgAdqIQMgACgCuAYiBkGAlOvcA0cEQCADIAApA7AGIAYQzRELIAIgAxDROzYCqBEgByACQagRahDNLSACKAKoESIDQYQBTwRAIAMQ8h8LIAJB0ABqIAAoAvwFIAAoAoAGIAcQgCQgAigCVCEFAkAgAigCUEEBcUUNACACQcgAaiAFEIQZIAIoAkwhBSACKAJIIgNFDQAgAyAFEPo6IQUMAwsgACAFNgKUByAAQZQHahCMFyEEIABBADoAoAcgACAENgKYByAAQaAHaiEHIABBmAdqIQULIAAgBBD7DjYCnAcLIAJBQGsgAEGcB2oiAyABEMcYAkACQAJAAkACQAJAAkACQAJAIAIoAkAiBEECRwRAIAIoAkQhBiADKAIAIgkgCSgCAEEBayIJNgIAIAlFBEAgAxCyGgsCQAJAAkAgBEEBcUUNACACQThqIAYQhBkgAigCPCEGIAIoAjgiBEUNACAGIQMMAQsgAiAGNgKoESACQagRaiIDEKM7DQEgA0EjQQBBAUEBEKAYIAIoAqwRIQMgAigCqBFBAUYNAyACKAKwESIJQfi3wwBBI/wKAABBDEEEEK02IgRFDQQgBEEjNgIIIAQgCTYCBCAEIAM2AgBB3LPDACEDIAZBhAFJDQAgBhDyHwsgB0EBOgAAIAUQ5CggAiADNgKUEiACIAQ2ApASIAJBADYCoBQgAkKAgICAEDcCmBQgAkH4pMMANgKsESACQqCAgIAONwKwESACIAJBmBRqNgKoESACQZASaiACQagRahCDNg0EIAJB6BJqIAJBoBRqKAIAIgM2AgAgAiACKQKYFDcD4BIgAigC5BIgA0Gat8MAQSQQwS4hAyACQeASahDeO0EBIAICfyADRQRAIAIoApQSIQUgAigCkBIMAQsgAkGQEmoQvCpBoLPDACEFQQELIAUQ2CkhBSAAKAKUByIDQYQBSQ0LIAMQ8h8MCwsgB0EBOgAAIAUQ5CggAiAGNgKEECACQagRaiIDENkpIAJBiBBqIAMgAkGEEGoiBBCPPRDgEiACQeASaiIFIAQQ4iYgAigC6BIhByACKALkEiEJIAJBADYCoBQgAkEANgKYFCACQQA2AqgUIAMgAkGYFGogCSAHELwaIAIoAqgRQQJGDQQgAkHQEGogA0HIAPwKAAAgBRDeOyACIAQQkD02ApgRIAMgAkGYEWoQxxIgAi0ArBEiA0EDRg0FIANBAkYNBiACKAKoESEEIAIgAzoAoBEgAiAENgKcESACQTBqIAJBnBFqEPwpIAIoAjAiBUECRwRAIAJBpBRqIQcgAigCNCEEA0AgBUEBcQ0JIAIgBDYCpBEgAkEoaiACQaQRahDIJCACKAIoQQFxDQogAkH4FGoiBSACKAIsEKsrIAJB4BJqIgMgAigC/BQgAigCgBUQkDUgAkGoEWoiBCADEMgTIAIoAqgRQYCAgIB4Rg0LIAJBqBRqIAJBuBFqKQIANwMAIAJBoBRqIAJBsBFqKQIAIg03AwAgAiACKQKoESIONwOYFCACQZgSaiANPgIAIAIgDjcDkBIgAkHoEmogB0EIaigCADYCACACIAcpAgA3A+ASIAQgAkGIEGoiCSACQZASaiIMIAMQsA0gCSAEQcgA/AoAACADEN47IAwQ3jsgBRDeOyACKAKkESIDQYQBTwRAIAMQ8h8LIAJBIGogAkGcEWoQ/CkgAigCJCEEIAIoAiAiBUECRw0ACwsgAigCnBEiA0GEAU8EQCADEPIfCyACLQCRECEFIAItAJAQIQQCQAJAAkAgAikDiBAiDUIDUQRAIAZBhAFPBEAgBhDyHwsgAkHgEmogAkHQEGpByAD8CgAAIAJBuBNqIABBkAdqKAIANgIAIAJBsBNqIABBiAdqKQIANwIAIAIgACkCgAc3AqgTIAJB8BJqEN47IAJBqBNqEL0oDAELIAIgBToAmRIgAiAEOgCYEiACIA03A5ASIAJBmhJqIAJBkhBqQT78CgAAIAIgBjYC2BIgAkHgEmogAkHQEGpByAD8CgAAIAJBuBNqIABBkAdqKAIANgIAIAJBsBNqIABBiAdqKQIANwIAIAIgACkCgAc3AqgTIAJBmBRqIAJB4BJqQdwA/AoAACACQfgUaiIDIAJB0BBqQcgA/AoAACACQagRaiACQZASaiADIAJB4BRqEJMgIAIpA6gRIg1CA1INASACLQCxESEFIAItALARIQQLQgMhDUEBIAIgBCAFEKweIQUMAQsgAigCsBEhBSACQbwTaiACQbQRakHcAPwKAAALIAIoApgRIgNBhAFPBEAgAxDyHwsgACgClAciA0GEAU8EQCADEPIfCyAAQQA6AKUHIAAoAvgGIgRBhAFJDQ4MDQsgAEEDOgCgByAAQQM6AKQHDBELIAMgAigCsBFBzLjDABD9LwALQQRBDBCjPQALQaClwwBBNyACQeASakGQpcMAQdilwwAQ1R4AC0GYtsMAQQkQlz0AC0GhtsMAQRAQlz0AC0GxtsMAQRgQlz0AC0HJtsMAQR4Qlz0AC0HntsMAQRIQlz0AC0H5tsMAQSEQlz0ACyAAQYAHahC9KAsgAC0ApQdFDQAgACgC/AYiA0GEAUkNACADEPIfCyAAQQA6AKUHQgMhDSAAKAL4BiIEQYMBSw0AIABBqAVqEKkeIABBAToApAcMAgsgBBDyHwsgAEGoBWoQqR4gAEEBOgCkByANQgRRDQMLIAJBqA9qIAJBvBNqQdwA/AoAACALEM0kIAAoAtADIgMgAygCACIDQQFrNgIAIANBAUcNACAAQdADahCdJwsgCkEBOgAAIAgQyCEgDUIDUQ0FIAIgBTYCmAIgAiANNwOQAiACQZwCaiACQagPakHcAPwKAAAgAkGoAWoiAyACQZACahCREyACKQOoAUIDUQ0GIAJB2AtqIgYgA0HoAPwKAAAgCCAGQdwB/AoAACAAQQA6AIQCIABBKGohAyAAQYQCaiEICyAAQZABaiADQegA/AoAACACQRhqIABB2AFqEMckIAIoAhwhBSACKAIYQQFxRQ0BIAJBEGogBRCEGSACKAIUIQUgAigCECIGRQ0BQQUgAiAGIAUQ2CkhBAwIC0EDIQUgCkEDOgAAQQEhBAwGCyAAQQA6AIACIAAgBTYC+AEgAEGAAmohBCAAQfgBaiEGCyAAIAUQ+w42AvwBCyACQQhqIABB/AFqIgUgARDHGCACKAIIIgFBAkcEQCACKAIMIQggBSgCACIHIAcoAgBBAWsiBzYCACAHRQRAIAUQshoLAkAgAUEBcQRAIAIgCBCEGSACKAIEIQggAigCACIBDQELIARBAToAACAGEOQoIAIgCDYCkAIgAiACQZACahCUPTYCqBEgAkGICmoiASACQagRaiIGEJY9Qby4wwAQzhggBiACKAKMCiACKAKQChCDJCACQfgCaiABEOcVIAIpAoADIQ0gAigC/AIhBCACKAL4AiEBIAIoAqgRIgZBgwFLBEAgBhDyHwsgAigCkAIiBkGEAU8EQCAGEPIfCyAAQZABahCkKSAAQQE6AIQCIAMQ1S0gAUUNByACIA03AoAKIAIgBDYC/AkgAiABNgL4CSACQdgLaiAAKAIcIAJB+AlqEMYmIAIoAtgLDQQgACgCGCIBIAEoAgAiAUEBazYCAEEBIQVBACEEIAFBAUcNBSAAQRhqEJ0nDAULIARBAToAACAGEOQoQQUgAiABIAgQ2CkhBAwFCyAEQQM6AAAgCEEDOgAAQQEhBEEEIQUMAwsgAiAFNgLYC0HgpsMAQSsgAkHYC2pBjKfDAEHkusMAENUeAAsgAiACKAKwATYC2AtB4KbDAEErIAJB2AtqQYynwwBB9LrDABDVHgALIAJBgANqIAJB4AtqKQIANwMAIAIgAikC2As3A/gCQeCmwwBBKyACQfgCakHQpsMAQZS7wwAQ1R4ACyAAIAU6ACAgAkHAFWokACAEDwsgAEGQAWoQpCkgAEEBOgCEAiADENUtCyACIAQ2AvgCQeCmwwBBKyACQfgCakGMp8MAQYS7wwAQ1R4AC7P5AwIjfwR+IwBBkAFrIgokAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg4CAAECCyAKQRBqQStBAEEBQQEQoBggCigCFCEBIAooAhBBAUYNAiAKKAIYIgJB2POCAUEr/AoAACAAQSs2AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADCgLIAogASgCACICQQAgAiABKAIEIgEoAiQRBAAgASgCIBEFACAAIAopAwA3AgQgAEGTgICAeDYCAAwnCyAKIAEoAgAgASgCBCgCHBEEACIINgIMIAJBA3QiBEEIayEDIAEgBGohBQNAIAMgBkYNAiABIAZqIQQgBkEIaiEGIARBCGooAgAgBEEMaigCACgCHBEEACAIELwIDQALIApBEGoiBEHcx4IBEKUrIAopAxghJyAKKQMQISggBCAKQY8BakEEQQhBEBCdFCAKKAIUIQQCQCAKKAIQIgZFBEAgCjUCGCEmDAELIAopAhghJiAEQQlqIghFDQAgBkH/ASAI/AsACyAKICc3AyggCiAoNwMgIAogJjcDGCAKIAQ2AhQgCiAGNgIQIApBATYCRCAKQYDzggE2AkAgCkIBNwJMIApBpwQ2AoQBIAogCkGAAWo2AkggCiAKQQxqNgKAASAKQTRqIApBQGsQmQ4gCkEQaiAKKAIMELoMGgJAIAJFDQADQCAKQRBqIAEoAgAiAiABQQRqKAIAKAIcIgQRBAAQugwhBgJAAkAgCigCHEELRwRAIAZFDQEMAgsgCkE0akGI84IBQY3zggEQvSYMAwsgCkE0aiIGQbTzggFBtvOCARC9JiACIAQRBAAgCkEANgKIASAKQoCAgIAQNwKAASAKQeDHggE2AkQgCkKggICADjcCSCAKIApBgAFqNgJAIApBQGsQrhANBSAKQeAAaiAKQYgBaigCACICNgIAIAogCikCgAE3A1ggBiAKKAJcIgQgAiAEahC9JiAKQdgAahDeOwsgAUEIaiIBIAVHDQALCyAKQTRqQaDzggFBovOCARC9JiAKQcgAaiIBIApBPGooAgA2AgAgCiAKKQI0NwNAIApBEGpBBEEIENknIABBjYCAgHg2AgAgACAKKQNANwIEIABBDGogASgCADYCAAwmCyABIAooAhhBpMmCARD9LwALIAgtAABBAWsOKBEhIB8eHRwbGhkYFxACAQ8OIyINEgwLCgkIBxISBhIFEgQWFRQTEgMSC0GIyIIBQTcgCkGPAWpB+MeCAUHAyIIBENUeAAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNMyAFKAIMIQYgA0E8aiIEQo+evPjw4cOHDzcCKCAEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBMGpBj568+AA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQxSVFBEAgB0EoakGPnrz4ADYCACAHQo+evPjw4cOHDzcDIAw1CyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPohIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDSQgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxDAEyABQYADaiQAQThBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBiN+CATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADCMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQRBBBCgGCAFKAIIIQcgBSgCBEEBRg0yIAUoAgwhBiADQTxqIgRCjpy48ODBg4cONwIoIAQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEEwakGOnLjwADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDCJUUEQCAHQShqQY6cuPAANgIAIAdCjpy48ODBg4cONwMgDDQLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/yEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNIyACKAIQIQcgA0EIaiACKAIUIglBAnYiDBDuLSAJQXxxIgkEQCADKAIMIAMoAhBBAnRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENs8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgMAANwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8RggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHEMQTIAFBgANqJABBOEEEEK02IgFFDSMgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEHI5IIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMIgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCELIAogCEEEajYCbAJAAkACQAJAIAgoAgQtADBBA2sOAwECAwALIApBATYCFCAKQaTyggE2AhAgCkIBNwIcIApBsxA2AkQgCiAKQUBrNgIYIAogCkHsAGo2AkAgCkEQakGs8oIBEO8sAAsjAEHwAmsiCyQAIAtBBGohBCABIAJBA3RqIQgjAEEQayIFJAACQAJAA0AgASAIRg0BIAFBBGohAiABKAIAIAFBCGoiAyEBIAIoAgAQjiIiAigCGEUNAAsgBUEEaiIBQQRBAEEEQQQQoBggBSgCCCEGIAUoAgRBAUYNNyAFKAIMIgcgAjYCACAFQQxqIglBATYCACAFIAc2AgggBSAGNgIEA0ACQAJAAkAgAyAIRwRAIAMoAgAgA0EEaigCABCOIiIGKAIYDQEMAgsMAgsgASgCCCICIAEoAgBGBEAgASACQQFBBEEEEN4oCyABKAIEIAJBAnRqIAY2AgAgASACQQFqNgIICyADQQhqIQMMAQsLIARBCGogCSgCADYCACAEIAUpAgQ3AgAMAQsgBEEANgIIIARCgICAgMAANwIACyAFQRBqJAAgCygCDCEbIAsoAgghFSALQQA7AbQBIAsgFTYCrAEgCyAVIBtBAnRqIhw2ArABIAtBATYCqAEgC0EQaiEJIwBBIGsiBiQAAkACQAJAAkACQAJAIAtBqAFqIh0iAi8BACIBQQJGDQAgAiABQQFHIgFBAXQ7AQAgAQ0AIAIvAQIhBAwBCyACKAIEIgFFDQEgASACKAIIRg0BIAIgAUEEajYCBCABKAIAIgEoAhQiBEECSQ07IAEoAhAgBEF+cWpBAmsiAUUNOyACIAEvAQAgAi8BDGoiBDsBDAsgBkEQaiIBQQRBAEECQQIQoBggBigCFCEIIAYoAhBBAUYNAiAGKAIYIgcgBDsBACAGQQxqIgxBATYCACAGIAc2AgggBiAINgIEIAZBGGogAkEIaikCADcDACAGIAIpAgA3AxAgBkEEaiEDIAEvAQwhCCABKAIEIQIgASgCCCENIAEvAQIhDiABLwEAIQcCQANAAkACfwJAIAdBAkYNACABIAdBAUciBEEBdDsBAEEAIQUgBA0AQQAhByAODAELIAJFIAIgDUZyDQMgASACQQRqIgQ2AgQgAigCACICKAIUIgdBAkkNASACKAIQIAdBfnFqQQJrIgJFDQEgASACLwEAIAhqIgg7AQxBAiEHQQEhBSAEIQIgCAshECADKAIIIgQgAygCAEYEQCADQQEgB0EBciAFGxDtLQsgAygCBCAEQQF0aiAQOwEAIAMgBEEBajYCCAwBCwsMOwsgCUEIaiAMKAIANgIAIAkgBikCBDcCAAwBCyAJQQA2AgggCUKAgICAIDcCAAsgBkEgaiQADAELIAggBigCGEHQyIIBEP0vAAsCQAJAIAsoAhgiAUUNACALKAIUIAFBAXRqQQJrIgFFDQAgAS4BACEfIAtBsAFqIAtBGGooAgA2AgAgCyALKQIQNwOoASALQQA2AswBIAtCADcCvAEgCyAcNgK4ASALIBU2ArQBIwBBEGsiGCQAIBhBBGohGSMAQeAAayIRJAAgEUEgaiISIB1BMPwKAAAgEUEUaiEWIwBBQGoiEyQAIBIiBygCFCIBIAcoAggiDCABIAxLGyENIAcoAgQgAUEBdGohCSAHKAIMIQIgBygCECEOIAcoAhghBSAHKAIAQYCAgIB4RiEQIAcoAhwiAyEGAkACQAJAAkACQAJ/AkACQANAAkAgBQRAIAUgBkcNASAHQQA2AhgLIBAEQCADIQYMBAsgAiAORg0DIAcgAUEBaiIENgIUIAcgAkEEaiIINgIMIAEgDUYNAiACKAIAIgEoAhAiBUUNAyAHIAU2AhggByAJLwEAOwEgIAcgBSABKAIUQX5xaiIGNgIcIAlBAmohCSAEIQEgCCECDAELCyAHIAVBAmoiATYCGCAHKAIoIQkgBygCJCECIAcvASAgBS8BAGoMAgsgDSAMQZy4ggEQwyEACyAHKAIkIgRFDQIgBCAHKAIoIglGDQEgByAEQQJqIgI2AiRBACEBIAcvASwgBC8BAGoLIQQgE0EQaiIPQQMgBiABa0EBdkEAIAEbIAkgAmtBAXZBACACG2oiASABQQNNG0EBakEAQQJBAhCgGCATKAIUIQEgEygCEEEBRg0DIBMoAhgiAiAEOwEAIBNBDGoiIEEBNgIAIBMgAjYCCCATIAE2AgQgDyAHQTD8CgAAIBNBBGohFyAPKAIUIQ0gDygCBCEhIA8oAgghGiAPKAIQISIgDygCAEGAgICAeEYhIyAPKAIMIgghByAPKAIcIgIhDiAPKAIYIgkhBQJAAkACQANAIA0gGiANIBpLGyEeICEgDUEBdGohFCAIIQQgAiEBIA0hBiAHIQMgDiEMAkACfwJAAkADQCAFBEAgBSAMRw0DIA9BADYCGEEAIQkLICMEQCACIQEgDiEMIAghBAwCCyADICJGBEAgBiENIAMhBwwCCyAPIAZBAWoiEDYCFCAPIANBBGoiBDYCDCAGIB5GDQcgAygCACIDKAIQIgUEQCAPIAU2AhggDyAULwEAOwEgIA8gBSADKAIUQX5xaiIBNgIcIBRBAmohFCAFIQkgECEGIAQhAyABIQwMAQsLIAZBAWohDSAEIQcLIA8oAiQiAkUNBCACIA8oAihGDQIgDyACQQJqNgIkIA8vASwgAi8BAGohFEEAIQUgASECIAQhCCAMDAELIA8gBUECaiIJNgIYIA8vASAgBS8BAGohFCABIQIgBCEIIAYhDSADIQcgCSEFIAwLIQ4gFygCCCIBIBcoAgBGBEAgFyACIAlrQQF2QQFqQQEgCRsgDygCKCAPKAIkIgRrQQF2QQAgBBtqEO0tIAkhBSACIQ4gCCEHCyAXKAIEIAFBAXRqIBQ7AQAgFyABQQFqNgIIDAELCyAPQQA2AiQLIA8QtDAMAQsgHiAaQZy4ggEQwyEACyAWQQhqICAoAgA2AgAgFiATKQIENwIADAILIAdBADYCJAsgFkEANgIIIBZCgICAgCA3AgAgBxC0MAsgE0FAayQADAELIAEgEygCGEHAg4QBEP0vAAsgEUHQAGogFhDfLCARIBEpAlA3AiwgEUEANgIoIBEgESgCXCICNgIkIBEgESgCWDYCICARQQhqIBIQ1zsgESgCCCEEQRxBBBCtNiIBRQRADEELIAFCgYCAgBA3AgAgASARKQIgNwIIIBkgAjYCCCAZIAQ2AgQgGSABNgIAIAFBEGogEUEoaikCADcCACABQRhqIBFBMGooAgA2AgAgEUHgAGokACALQRxqIgFBDGogGUEAIBgoAgxBAXYQ/BwgAUEIakGDhowYNgIAIAFCg4aMmLDgwIEDNwIAIAFBADYCGCAYQRBqJAAgC0GEAmoiAiAVIBwQvRsgHSALKAKIAiALKAKMAhCdASALKAKwASEEIAsoAqwBIQYCQCALKAKoASIIQZOAgIB4RwRAIAAgCykCtAE3AgwgACAENgIIIAAgBjYCBCAAIAg2AgAgAkEEQQgQ4B4gARCBJQwBCyALQYQCaiIBQQRBCBDgHiAbRQ0oIAtByAFqIBUoAgAQywYgC0EAOwGAAiALQQA2AvwBIAtBADYC5AEgC0EANgLYASALIB82AtQBIAtCBDcCwAEgC0IANwK4ASALQoCAgIDAADcCsAEgC0EANgKoAUGIAUEEEK02IgJFDSkgASALQRxqQTD8CgAAIAIgARD5PSACQcQAaiAGIAQQ0yMgC0ECNgKMAiALIAI2AogCIAtBAjYChAIgC0HMAGoiAiALQagBaiIEIAEQ/CIgASACEM0cIAQgARDnFiALKAKoASICQZOAgIB4RwRAIAAgCykCrAE3AgQgAEEMaiALQbQBaikCADcCACAAIAI2AgAgARCDJwwBCyALQagBaiIBIAtBhAJqQcQA/AoAACALQcgCaiICIAEQnwlBMEEEEK02IgFFDSogAUKBgICAEDcCACABQQhqIAJBKPwKAAAgAEHI74IBNgIIIAAgATYCBCAAQZOAgIB4NgIACyALQQRqQQRBBBDgHiALQfACaiQADAELQfjtggEQsjsACwwiCyMAQfACayILJAAgC0EEaiEEIAEgAkEDdGohCCMAQRBrIgUkAAJAAkADQCABIAhGDQEgAUEEaiECIAEoAgAgAUEIaiIDIQEgAigCABCNIiICKAIYRQ0ACyAFQQRqIgFBBEEAQQRBBBCgGCAFKAIIIQYgBSgCBEEBRg02IAUoAgwiByACNgIAIAVBDGoiCUEBNgIAIAUgBzYCCCAFIAY2AgQDQAJAAkACQCADIAhHBEAgAygCACADQQRqKAIAEI0iIgYoAhgNAQwCCwwCCyABKAIIIgIgASgCAEYEQCABIAJBAUEEQQQQ3igLIAEoAgQgAkECdGogBjYCACABIAJBAWo2AggLIANBCGohAwwBCwsgBEEIaiAJKAIANgIAIAQgBSkCBDcCAAwBCyAEQQA2AgggBEKAgICAwAA3AgALIAVBEGokACALKAIMIRwgCygCCCEWIAtBADYCuAEgCyAWNgKwASALQgE3AqgBIAsgFiAcQQJ0aiIdNgK0ASALQRBqIQkjAEEwayIGJAACQAJAAkACQAJAAkAgC0GoAWoiHiICKAIAIgFBAkYNACACIAFBAUciAUEBdDYCACABDQAgAigCBCEEDAELIAIoAggiAUUNASABIAIoAgxGDQEgAiABQQRqNgIIIAEoAgAiASgCFCIEQQRJDTogASgCECAEQXxxakEEayIBRQ06IAIgASgCACACKAIQaiIENgIQCyAGQRhqIgFBBEEAQQRBBBCgGCAGKAIcIQggBigCGEEBRg0CIAYoAiAiByAENgIAIAZBFGoiDEEBNgIAIAYgBzYCECAGIAg2AgwgBkEoaiACQRBqKAIANgIAIAZBIGogAkEIaikCADcDACAGIAIpAgA3AxggBkEMaiEDIAEoAhAhCCABKAIIIQIgASgCDCENIAEoAgQhDiABKAIAIQcCQANAAkACfwJAIAdBAkYNACABIAdBAUciBEEBdDYCAEEAIQUgBA0AQQAhByAODAELIAJFIAIgDUZyDQMgASACQQRqIgQ2AgggAigCACICKAIUIgdBBEkNASACKAIQIAdBfHFqQQRrIgJFDQEgASACKAIAIAhqIgg2AhBBAiEHQQEhBSAEIQIgCAshECADKAIIIgQgAygCAEYEQCADQQEgB0EBciAFGxDuLQsgAygCBCAEQQJ0aiAQNgIAIAMgBEEBajYCCAwBCwsMOgsgCUEIaiAMKAIANgIAIAkgBikCDDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAZBMGokAAwBCyAIIAYoAiBB0MiCARD9LwALAkACQCALKAIYIgFFDQAgCygCFCABQQJ0akEEayIBRQ0AIAEoAgAhICALQbABaiALQRhqKAIANgIAIAsgCykCEDcDqAEgC0EANgLMASALQgA3ArwBIAsgHTYCuAEgCyAWNgK0ASMAQRBrIhkkACAZQQRqIRojAEHgAGsiEyQAIBNBIGoiDyAeQTD8CgAAIBNBFGohFyMAQUBqIhQkACAPKAIUIgEgDygCCCIDIAEgA0sbIQwgDygCBCABQQJ0aiEJIA8oAgwhAiAPKAIQIQ0gDygCGCEFIA8oAgBBgICAgHhGIQ4gDygCHCIHIQYCQAJAAkACQAJAAn8CQAJAA0ACQCAFBEAgBSAGRw0BIA9BADYCGAsgDgRAIAchBgwECyACIA1GDQMgDyABQQFqIgQ2AhQgDyACQQRqIgg2AgwgASAMRg0CIAIoAgAiASgCECIFRQ0DIA8gBTYCGCAPIAkoAgA2AiAgDyAFIAEoAhRBfHFqIgY2AhwgCUEEaiEJIAQhASAIIQIMAQsLIA8gBUEEaiIBNgIYIA8oAighCSAPKAIkIQIgDygCICAFKAIAagwCCyAMIANBnLiCARDDIQALIA8oAiQiBEUNAiAEIA8oAigiCUYNASAPIARBBGoiAjYCJEEAIQEgDygCLCAEKAIAagshBCAUQRBqIhFBAyAGIAFrQQJ2QQAgARsgCSACa0ECdkEAIAIbaiIBIAFBA00bQQFqQQBBBEEEEKAYIBQoAhQhASAUKAIQQQFGDQMgFCgCGCICIAQ2AgAgFEEMaiIhQQE2AgAgFCACNgIIIBQgATYCBCARIA9BMPwKAAAgFEEEaiEYIBEoAhQhAyARKAIEISIgESgCCCEbIBEoAhAhIyARKAIAQYCAgIB4RiEkIBEoAgwiByEGIBEoAhwiCCENIBEoAhgiCSEFAkACQAJAA0AgAyAbIAMgG0sbIR8gIiADQQJ0aiElQQAhFSAHIQQgCCECIAMhASAGIQ4gDSEMAkACfwJAAkACQANAIAYgFWohEiAFBEAgBSAMRw0EIBFBADYCGEEAIQkLICQEQCAIIQIgDSEMIAchBCADIQEMAwsgEiAjRg0BIBEgAUEBaiIQNgIUIBEgBiAVakEEajYCDCABIB9GDQggDkEEaiEEIBIoAgAiDigCECIFBEAgESAFNgIYIBEgFSAlaigCADYCICARIAUgDigCFEF8cWoiAjYCHCAVQQRqIRUgBSEJIBAhASAEIQ4gAiEMDAELCyABQQFqIQEgBCEGDAELIAYgFWohBgsgESgCJCIIRQ0EIAggESgCKEYNAiARIAhBBGo2AiQgESgCLCAIKAIAaiEOQQAhBSACIQggBCEHIAEhAyAMDAELIBEgBUEEaiIJNgIYIBEoAiAgBSgCAGohDiACIQggBCEHIAEhAyASIQYgCSEFIAwLIQ0gGCgCCCIBIBgoAgBGBEAgGCAIIAlrQQJ2QQFqQQEgCRsgESgCKCARKAIkIgJrQQJ2QQAgAhtqEO4tIAkhBSAIIQ0gByEGCyAYKAIEIAFBAnRqIA42AgAgGCABQQFqNgIIDAELCyARQQA2AiQLIBEQlzAMAQsgHyAbQZy4ggEQwyEACyAXQQhqICEoAgA2AgAgFyAUKQIENwIADAILIA9BADYCJAsgF0EANgIIIBdCgICAgMAANwIAIA8QlzALIBRBQGskAAwBCyABIBQoAhhBwIOEARD9LwALIBNB0ABqIBcQ4CwgEyATKQJQNwIsIBNBADYCKCATIBMoAlwiAjYCJCATIBMoAlg2AiAgE0EIaiAPENc7IBMoAgghBEEcQQQQrTYiAUUEQAxACyABQoGAgIAQNwIAIAEgEykCIDcCCCAaIAI2AgggGiAENgIEIBogATYCACABQRBqIBNBKGopAgA3AgAgAUEYaiATQTBqKAIANgIAIBNB4ABqJAAgC0EcaiIBQQxqIBpBACAZKAIMQQJ2EIAdIAFBCGpBhIiQIDYCACABQoSIkKDAgIGCBDcCACABQQA2AhggGUEQaiQAIAtBhAJqIgIgFiAdEL0bIB4gCygCiAIgCygCjAIQnQEgCygCsAEhBCALKAKsASEGAkAgCygCqAEiCEGTgICAeEcEQCAAIAspArQBNwIMIAAgBDYCCCAAIAY2AgQgACAINgIAIAJBBEEIEOAeIAEQgSUMAQsgC0GEAmoiAUEEQQgQ4B4gHEUNJyALQcgBaiAWKAIAEMsGIAtBADsBgAIgC0EANgL8ASALQQA2AuQBIAtBADYC2AEgCyAgNgLUASALQgQ3AsABIAtCADcCuAEgC0KAgICAwAA3ArABIAtBADYCqAFBiAFBBBCtNiICRQ0oIAEgC0EcakEw/AoAACACIAEQ8T0gAkHEAGogBiAEENMjIAtBAjYCjAIgCyACNgKIAiALQQI2AoQCIAtBzABqIgIgC0GoAWoiBCABEPwiIAEgAhDNHCAEIAEQ5xYgCygCqAEiAkGTgICAeEcEQCAAIAspAqwBNwIEIABBDGogC0G0AWopAgA3AgAgACACNgIAIAEQgycMAQsgC0GoAWoiASALQYQCakHEAPwKAAAgC0HIAmoiAiABEJ4JQTBBBBCtNiIBRQ0pIAFCgYCAgBA3AgAgAUEIaiACQSj8CgAAIABBmO6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgC0EEakEEQQQQ4B4gC0HwAmokAAwBC0H47YIBELI7AAsMIQsjAEHwAmsiCyQAIAtBBGohBCABIAJBA3RqIQgjAEEQayIFJAACQAJAA0AgASAIRg0BIAFBBGohAiABKAIAIAFBCGoiAyEBIAIoAgAQjyIiAigCGEUNAAsgBUEEaiIBQQRBAEEEQQQQoBggBSgCCCEGIAUoAgRBAUYNNSAFKAIMIgcgAjYCACAFQQxqIglBATYCACAFIAc2AgggBSAGNgIEA0ACQAJAAkAgAyAIRwRAIAMoAgAgA0EEaigCABCPIiIGKAIYDQEMAgsMAgsgASgCCCICIAEoAgBGBEAgASACQQFBBEEEEN4oCyABKAIEIAJBAnRqIAY2AgAgASACQQFqNgIICyADQQhqIQMMAQsLIARBCGogCSgCADYCACAEIAUpAgQ3AgAMAQsgBEEANgIIIARCgICAgMAANwIACyAFQRBqJAAgCygCDCEbIAsoAgghFCALQgA3A8ABIAsgFDYCuAEgC0IANwOwASALQgE3A6gBIAsgFCAbQQJ0aiIcNgK8ASALQRBqIQcjAEEwayIGJAACQAJAAkACQAJAAkAgC0GoAWoiHSICKQMAIiZCAlENACACICZQrUIBhjcDACAmp0EBcUUNACACKQMIISYMAQsgAigCECIBRQ0BIAEgAigCFEYNASACIAFBBGo2AhAgASgCACIBKAIUIgRBCEkNOSABKAIQIARBeHFqQQhrIgFFDTkgAiABKQMAIAIpAxh8IiY3AxgLIAZBEGoiAUEEQQBBCEEIEKAYIAYoAhQhBCAGKAIQQQFGDQIgBigCGCIIICY3AwAgBkEMaiIDQQE2AgAgBiAINgIIIAYgBDYCBCAGQShqIAJBGGopAwA3AwAgBkEgaiACQRBqKQMANwMAIAZBGGogAkEIaikDADcDACAGIAIpAwA3AxAgBkEEaiEIIAEpAxghKCABKAIQIQIgASgCFCEFIAEpAwghKSABKQMAISYCQANAAkBCAiEnAn4CQCAmQgJRDQAgASAmUK1CAYYiJzcDACAmp0EBcUUNACAnISYgKQwBCyACRSACIAVGcg0DIAEgAkEEaiIENgIQIAIoAgAiAigCFCIJQQhJDQEgAigCECAJQXhxakEIayICRQ0BIAEgAikDACAofCIoNwMYIAQhAiAnISYgKAshJyAIKAIIIgQgCCgCAEYEQCAIQQEgJqdBAWogJkICURsQ7C0LIAgoAgQgBEEDdGogJzcDACAIIARBAWo2AggMAQsLDDkLIAdBCGogAygCADYCACAHIAYpAgQ3AgAMAQsgB0EANgIIIAdCgICAgIABNwIACyAGQTBqJAAMAQsgBCAGKAIYQdDIggEQ/S8ACwJAAkAgCygCGCIBRQ0AIAsoAhQgAUEDdGpBCGsiAUUNACABKAIAIR8gC0GwAWogC0EYaigCADYCACALIAspAhA3A6gBIAtBADYC0AEgC0IANwK8ASALIBw2ArgBIAsgFDYCtAEjAEEQayIXJAAgF0EEaiEYIwBB4ABrIhEkACARQRhqIhIgHUE4/AoAACARQQxqIRUjAEHQAGsiEyQAIBIiBygCFCIBIAcoAggiCSABIAlLGyEMIAcoAgQgAUEDdGohDSAHKAIMIQIgBygCECEOIAcoAhghBSAHKAIAQYCAgIB4RiEQIAcoAhwiAyEGAkACQAJAAkACQAJ+AkACQANAAkAgBQRAIAUgBkcNASAHQQA2AhgLIBAEQCADIQYMBAsgAiAORg0DIAcgAUEBaiIENgIUIAcgAkEEaiIINgIMIAEgDEYNAiACKAIAIgEoAhAiBUUNAyAHIAU2AhggByANKQMANwMgIAcgBSABKAIUQXhxaiIGNgIcIA1BCGohDSAEIQEgCCECDAELCyAHIAVBCGoiATYCGCAHKAIsIQ0gBygCKCECIAcpAyAgBSkDAHwMAgsgDCAJQZy4ggEQwyEACyAHKAIoIgRFDQIgBCAHKAIsIg1GDQEgByAEQQhqIgI2AihBACEBIAcpAzAgBCkDAHwLISYgE0EYaiIPQQMgBiABa0EDdkEAIAEbIA0gAmtBA3ZBACACG2oiASABQQNNG0EBakEAQQhBCBCgGCATKAIcIQEgEygCGEEBRg0DIBMoAiAiAiAmNwMAIBNBFGoiIEEBNgIAIBMgAjYCECATIAE2AgwgDyAHQTj8CgAAIBNBDGohFiAPKAIUIQ0gDygCBCEhIA8oAgghGSAPKAIQISIgDygCAEGAgICAeEYhIyAPKAIMIgEhAiAPKAIcIg4hByAPKAIYIgkhBQJAAkACQANAIA0gGSANIBlLGyEeICEgDUEDdGohGiABIQQgDiEMIA0hBiACIQMgByEIAkACfwJAAkADQCAFBEAgBSAIRw0DIA9BADYCGEEAIQkLICMEQCAOIQwgByEIIAEhBAwCCyADICJGBEAgBiENIAMhAgwCCyAPIAZBAWoiEDYCFCAPIANBBGoiBDYCDCAGIB5GDQcgAygCACIDKAIQIgUEQCAPIAU2AhggDyAaKQMANwMgIA8gBSADKAIUQXhxaiIMNgIcIBpBCGohGiAFIQkgECEGIAQhAyAMIQgMAQsLIAZBAWohDSAEIQILIA8oAigiAUUNBCABIA8oAixGDQIgDyABQQhqNgIoIA8pAzAgASkDAHwhJkEAIQUgCCEHIAQhASAMDAELIA8gBUEIaiIJNgIYIA8pAyAgBSkDAHwhJiAIIQcgBCEBIAYhDSADIQIgCSEFIAwLIQ4gFigCCCIEIBYoAgBGBEAgFiAOIAlrQQN2QQFqQQEgCRsgDygCLCAPKAIoIgJrQQN2QQAgAhtqEOwtIAkhBSAOIQcgASECCyAWKAIEIARBA3RqICY3AwAgFiAEQQFqNgIIDAELCyAPQQA2AigLIA8QhTAMAQsgHiAZQZy4ggEQwyEACyAVQQhqICAoAgA2AgAgFSATKQIMNwIADAILIAdBADYCKAsgFUEANgIIIBVCgICAgIABNwIAIAcQhTALIBNB0ABqJAAMAQsgASATKAIgQcCDhAEQ/S8ACyARQdAAaiAVEN4sIBEgESkCUDcCJCARQQA2AiAgESARKAJcIgI2AhwgESARKAJYNgIYIBEgEhDXOyARKAIAIQRBHEEEEK02IgFFBEAMPwsgAUKBgICAEDcCACABIBEpAhg3AgggGCACNgIIIBggBDYCBCAYIAE2AgAgAUEQaiARQSBqKQIANwIAIAFBGGogEUEoaigCADYCACARQeAAaiQAIAtBHGoiAUEMaiAYQQAgFygCDEEDdhD+HCABQQhqQYWKlCg2AgAgAUKFipSo0KDBggU3AgAgAUEANgIYIBdBEGokACALQYQCaiICIBQgHBC9GyAdIAsoAogCIAsoAowCEJ0BIAsoArABIQQgCygCrAEhBgJAIAsoAqgBIghBk4CAgHhHBEAgACALKQK0ATcCDCAAIAQ2AgggACAGNgIEIAAgCDYCACACQQRBCBDgHiABEIElDAELIAtBhAJqIgFBBEEIEOAeIBtFDSYgC0HIAWogFCgCABDLBiALQQA7AYACIAtBADYC/AEgC0EANgLkASALQQA2AtgBIAsgHzYC1AEgC0IENwLAASALQgA3ArgBIAtCgICAgMAANwKwASALQQA2AqgBQYgBQQQQrTYiAkUNJyABIAtBHGpBMPwKAAAgAiABEPA9IAJBxABqIAYgBBDTIyALQQI2AowCIAsgAjYCiAIgC0ECNgKEAiALQcwAaiICIAtBqAFqIgQgARD8IiABIAIQzRwgBCABEOcWIAsoAqgBIgJBk4CAgHhHBEAgACALKQKsATcCBCAAQQxqIAtBtAFqKQIANwIAIAAgAjYCACABEIMnDAELIAtBqAFqIgEgC0GEAmpBxAD8CgAAIAtByAJqIgIgARCgCUEwQQQQrTYiAUUNKCABQoGAgIAQNwIAIAFBCGogAkEo/AoAACAAQfDuggE2AgggACABNgIEIABBk4CAgHg2AgALIAtBBGpBBEEEEOAeIAtB8AJqJAAMAQtB+O2CARCyOwALDCALIAogCEEEajYCaAJAAkACQAJAAkACQAJAAkACQCAIKAIELQAAQQJrDggBAgMEBQYHCAALIApBATYCFCAKQcDxggE2AhAgCkIBNwIcIApBxRM2AkQgCiAKQUBrNgIYIAogCkHoAGo2AkAgCkEQakHI8YIBEO8sAAsgCkEQaiEMIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiDSgCACIEIA0oAgQiBkcEQCANIARBCGoiCDYCACAEKAIAIAQoAgQQhCIiAygCICEEIA0oAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg09IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiANQQhqKAIANgIAIAkgDSkCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQhCIiESgCICALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiAyAFKAIUIgggBSgCCBCLD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIAwgASACIA0Q+hQMAQsgBUG4AWogAyAIQQAgBRDIAiAFKALMASEJIAUoAsgBIQ0gBSgCxAEhASAFKALAASECIAUoArwBIQQgBSgCuAFBAUYEQCAMIAk2AhAgDCANNgIMIAwgATYCCCAMIAI2AgQgDCAENgIADAELIAVBuAFqIAUoAghBAEEBQQEQoBggBSgCvAEhBgJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgBjYCGCAFQgA3AtABIAUgAiABQQxsaiISNgLMASAFIAQ2AsgBIAUgAjYCxAEgBSACNgLAASAFIAM2ArgBIAUgAyAIQQJ0aiILNgK8ASAFQcABaiEOIAhFDQEgAyEBA0ACQCAFIAFBBGoiBDYCuAEgAiASRg0AIAUgAkEMaiIGNgLEASACKAIAIhBBgICAgHhGDQAgBSACKQIENwLwASAFIBA2AuwBIAEoAgAQtzogBSABKAIAQRhqEPQvIAUoAgAiAiAFKAIEIhFHBEADQEEAIQEgAiwAACIQIAUoAvQBSQRAIAUoAvABIBBqLQAAIQELIAUoAiAiECAFKAIYRgRAIAVBGGpByMyCARCjKAsgBSgCHCAQaiABOgAAIAUgEEEBajYCICACQQFqIgIgEUcNAAsLQQBHIAdyIQcgBUHsAWoQ3jsgBiECIAQiASALRw0BCwsgDhC6ICAHQQFxRQ0CQcAAIQEgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNQSACBEAgAkHAABCtNiIBRQ0yCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAIQQJ0IQIDQAJAIAMoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogAygCACgCIBDmEAsgA0EEaiEDIAJBBGsiAg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsgBiAFKALAAUHQy4IBEP0vAAsgDhC6IAsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEO4YIAVBPGoiBCACIAVBJGoQ2B0gBSAFQcgAaigCCCICNgJsIAIgBSgCCEcNPiABIARBMPwKAAAgBUHwAGoiAiABIA0gCRDHFUHQAEEEEK02IgFFDS4gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIAxBsM2CATYCCCAMIAE2AgQgDEGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCYLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIMiIgMQyzwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNPCAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIMiIhEQyzwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQig9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQwwIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBAkECEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgEoAiAiCUECTwRAIAEoAhwhBiAJQX5xIQEDQEEAIQkgBi4BACIPIAUoAvQBSQRAIAUoAvABIA9BAXRqLwEAIQkLIAUoAiAiDyAFKAIYRgRAIAVBGGpByMyCARCtKAsgBkECaiEGIAUoAhwgD0EBdGogCTsBACAFIA9BAWo2AiAgAUECayIBDQALCyAMIBFyIQwgBUHsAWoQnTwgByEGIAIiASADRw0ACyADIQIMAgsgCxC4IAwDCwwyCyAHIQgLIAUgCDYCxAEgBSACNgK4ASALELggIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAOQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDLPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPwsMLgsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEOkYIAVBPGoiBCACIAVBJGoQ2h0gBSAFQcgAahDZPCICNgJsIAIgBSgCCEcNPSABIARBMPwKAAAgBUHwAGoiAiABIBIgEBDHFUHQAEEEEK02IgFFDS0gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1BkNCCATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCULIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIciIgMQyTwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOyAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIciIhEQyTwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQiQ9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQxAIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBBEEEEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgEoAiAiCUEETwRAIAEoAhwhBiAJQXxxIQEDQEEAIQkgBigCACIPIAUoAvQBSQRAIAUoAvABIA9BAnRqKAIAIQkLIAUoAiAiDyAFKAIYRgRAIAVBGGpByMyCARCdKAsgBkEEaiEGIAUoAhwgD0ECdGogCTYCACAFIA9BAWo2AiAgAUEEayIBDQALCyAMIBFyIQwgBUHsAWoQ6TsgByEGIAIiASADRw0ACyADIQIMAgsgCxCRIAwDCwwxCyAHIQgLIAUgCDYCxAEgBSACNgK4ASALEJEgIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAOQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDJPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPgsMLQsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEOgYIAVBPGoiBCACIAVBJGoQvx0gBSAFQcgAahDbPCICNgJsIAIgBSgCCEcNPCABIARBMPwKAAAgBUHwAGoiAiABIBIgEBDHFUHQAEEEEK02IgFFDSwgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1B4M6CATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJQsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCQLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIUiIgMQyjwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOiAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIUiIhEQyjwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIJIAUoAggQ4g9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgCUEAIAUQwAIgBSgCzAEhDiAFKALIASEQIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAONgIQIA0gEDYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBCEEIEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAJQQJ0aiIDNgK8ASAFQcABaiESIAkEQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIgtBgICAgHhGDQMgBSAGKQIENwLwASAFIAs2AuwBIAEoAgAQtzpBAEchDyABKAIAIgEoAiAiC0EITwRAIAEoAhwhBiALQXhxIQEDQEIAISYgBigCACILIAUoAvQBSQRAIAUoAvABIAtBA3RqKQMAISYLIAUoAiAiCyAFKAIYRgRAIAVBGGpByMyCARCzKAsgBkEIaiEGIAUoAhwgC0EDdGogJjcDACAFIAtBAWo2AiAgAUEIayIBDQALCyAMIA9yIQwgBUHsAWoQ4zwgByEGIAMgAiIBRw0ACyADIQIMAgsgEhC7IAwDCwwwCyAHIQgLIAUgCDYCxAEgBSACNgK4ASASELsgIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAJQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDKPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPQsMLAsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEL0YIAVBPGoiBCACIAVBJGoQ1h0gBSAFQcgAahDYPCICNgJsIAIgBSgCCEcNOyABIARBMPwKAAAgBUHwAGoiAiABIBAgDhDHFUHQAEEEEK02IgFFDSsgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1B6NCCATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJAsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIkiIgMoAiAhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOSAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIkiIhEoAiAgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQjQ9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQxwIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBAUEBEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgYoAiAiAQRAIAYoAhwhBgNAQQAhCSAGLQAAIg8gBSgC9AFJBEAgBSgC8AEgD2otAAAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEKkZCyAGQQFqIQYgBSgCHCAPaiAJOgAAIAUgD0EBajYCICABQQFrIgENAAsLIAwgEXIhDCAFQewBahDeOyAHIQYgAiIBIANHDQALIAMhAgwCCyALELogDAMLDC8LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQuiAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAKAIgEOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww8CwwrCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ7hggBUE8aiIEIAIgBUEkahDBHSAFIAVByABqKAIIIgI2AmwgAiAFKAIIRw06IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUGIzoIBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwjCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIgsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQiCIiAxDLPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg04IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQiCIiERDLPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIg4gBSgCCBCMD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAOQQAgBRDBAiAFKALMASEQIAUoAsgBIRIgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIBA2AhAgDSASNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEECQQIQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIA5BAnRqIgM2ArwBIAVBwAFqIQsgDgRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiCUGAgICAeEYNAyAFIAYpAgQ3AvABIAUgCTYC7AEgASgCABC3OkEARyERIAEoAgAiASgCICIJQQJPBEAgASgCHCEGIAlBfnEhAQNAQQAhCSAGLwEAIg8gBSgC9AFJBEAgBSgC8AEgD0EBdGovAQAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEK0oCyAGQQJqIQYgBSgCHCAPQQF0aiAJOwEAIAUgD0EBajYCICABQQJrIgENAAsLIAwgEXIhDCAFQewBahCdPCAHIQYgAiIBIANHDQALIAMhAgwCCyALELggDAMLDC4LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQuCAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMs8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww7CwwqCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ6RggBUE8aiIEIAIgBUEkahDNHSAFIAVByABqENk8IgI2AmwgAiAFKAIIRw05IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKSABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUHwy4IBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwiCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIQsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQiiIiAxDJPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg03IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQiiIiERDJPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIg4gBSgCCBDkD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAOQQAgBRDCAiAFKALMASEQIAUoAsgBIRIgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIBA2AhAgDSASNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEEEQQQQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIA5BAnRqIgM2ArwBIAVBwAFqIQsgDgRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiCUGAgICAeEYNAyAFIAYpAgQ3AvABIAUgCTYC7AEgASgCABC3OkEARyERIAEoAgAiASgCICIJQQRPBEAgASgCHCEGIAlBfHEhAQNAQQAhCSAGKAIAIg8gBSgC9AFJBEAgBSgC8AEgD0ECdGooAgAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEJ0oCyAGQQRqIQYgBSgCHCAPQQJ0aiAJNgIAIAUgD0EBajYCICABQQRrIgENAAsLIAwgEXIhDCAFQewBahDpOyAHIQYgAiIBIANHDQALIAMhAgwCCyALEJEgDAMLDC0LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQkSAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMk8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww6CwwpCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ6BggBUE8aiIEIAIgBUEkahDHHSAFIAVByABqENs8IgI2AmwgAiAFKAIIRw04IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUG4z4IBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwhCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIAsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQhiIiAxDKPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg02IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQhiIiERDKPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIgkgBSgCCBDjD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAJQQAgBRDAAiAFKALMASEOIAUoAsgBIRAgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIA42AhAgDSAQNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEEIQQgQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIAlBAnRqIgM2ArwBIAVBwAFqIRIgCQRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiC0GAgICAeEYNAyAFIAYpAgQ3AvABIAUgCzYC7AEgASgCABC3OkEARyEPIAEoAgAiASgCICILQQhPBEAgASgCHCEGIAtBeHEhAQNAQgAhJiAGKAIAIgsgBSgC9AFJBEAgBSgC8AEgC0EDdGopAwAhJgsgBSgCICILIAUoAhhGBEAgBUEYakHIzIIBELMoCyAGQQhqIQYgBSgCHCALQQN0aiAmNwMAIAUgC0EBajYCICABQQhrIgENAAsLIAwgD3IhDCAFQewBahDjPCAHIQYgAyACIgFHDQALIAMhAgwCCyASELsgDAMLDCwLIAchCAsgBSAINgLEASAFIAI2ArgBIBIQuyAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIAlBAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMo8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww5CwwoCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ5xggBUE8aiIEIAIgBUEkahDZHSAFIAVByABqENg8IgI2AmwgAiAFKAIIRw03IAEgBEEw/AoAACAFQfAAaiICIAEgECAOEMcVQdAAQQQQrTYiAUUNJyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUHYzIIBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwgCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMHwsjAEHgAWsiBiQAIAZBADYCFCAGQQA6ABsgBiABNgJ0IAYgASACQQN0ajYCeCAGIAZBG2o2AoABIAYgBkEUajYCfCMAQSBrIgEkACABQRRqIAZB9ABqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB0MiCARD9LwALIAFBEGoiEkEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIHJAAgAigCBCACKAIAa0EDdiIFIAFBCGoiAygCACADKAIIIgRrSwRAIAMgBCAFQQRBBBDeKCADKAIIIQQLIAhBBGohBSAGQRxqIQkgByADKAIENgIMIAcgBDYCCCAHIANBCGo2AgQgB0EEaiIDKAIEIQggAygCACACKAIAIgQgAigCBCIORwRAIAIoAgwhDCACKAIIIQ0gAygCCCAIQQJ0aiECIAggDiAEa0EDdiIDaiEIA0AgDSAEKAIAIg4gBEEEaigCACIQKAIkEQQAIA0oAgBqNgIAIAwgDiAQKAJEEQQAQQBHIAwtAAByOgAAIAIgDiAQEMgvNgIAIARBCGohBCACQQRqIQIgA0EBayIDDQALCyAINgIAIAdBEGokACAJQQhqIBIoAgA2AgAgCSABKQIINwIAIAFBIGokAAJAAkACQAJAAkACQCAGLQAbRQRAIAZBADYCKAwBC0HAACEBIAYoAhQiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDQEgAgRAIAJBwAAQrTYiAUUNAwsgBkIANwK0ASAGIAE2ArABIAYgAjYCrAEgBkHAADYCqAEgBigCJCIBBEAgBigCICECIAFBAnQhAQNAAkAgAigCABCcNiIEBEAgBkGoAWogBBCVLwwBCyAGQagBaiACKAIAKAIYEOYQCyACQQRqIQIgAUEEayIBDQALCyAGQfQAaiIBIAZBqAFqIgIQhRQgBkEoaiABEOEnIAIQzy8LIAZBCGogBRDDNCAGIAYoAgw2ArABIAZBADYCrAEgBiAGQRxqNgKoASAGQfQAaiEIIwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiAGQagBaiIBQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEDIwBBMGsiASQAIAFBCGogAkEgaiIEEIgoAkACQAJAIAEoAggiDQRAIAEoAgwhDiABQSBqIglBBEEAQQRBCBCgGCABKAIkIQcgASgCIEEBRg0CIAEoAigiDCAONgIEIAwgDTYCACABQRxqIhBBATYCACABIAw2AhggASAHNgIUIAFBKGogBEEIaikCADcDACABIAQpAgA3AyAjAEEQayIEJAAgBEEIaiAJEIgoIAQoAggiDARAIAFBFGohByAEKAIMIQ0DQCAHKAIIIg4gBygCAEYEQCAHQQEQ6i0LIAcoAgQgDkEDdGoiEiANNgIEIBIgDDYCACAHIA5BAWo2AgggBCAJEIgoIAQoAgQhDSAEKAIAIgwNAAsLIARBEGokACADQQhqIBAoAgA2AgAgAyABKQIUNwIADAELIANBADYCCCADQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEGI+YMBEP0vAAsCQCACKAIAQZOAgIB4RwRAIAggAikCADcCACAIQRBqIAJBEGooAgA2AgAgCEEIaiACQQhqKQIANwIAIAMQwycgAxDqOwwBCyAIIAIpAhQ3AgQgCEGTgICAeDYCACAIQQxqIAJBHGooAgA2AgALIAJBMGokACAGQcgAaiIBIAZBgAFqKAIANgIAIAYgBikCeDcDQAJAIAYoAnQiAkGTgICAeEcEQCAGKAKEASEEIAAgBikDQDcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCACAGKAIoIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAZBKGoQ+x4MAQsgBkHYAGogASgCADYCACAGIAYpA0A3A1AgBSgCACIBIAEoAgAiAkEBajYCACACQQBIDQMgBSgCBCECIAZBuAFqIAZBOGopAgA3AwAgBkGwAWogBkEwaikCADcDACAGIAYpAig3A6gBIAZB9ABqIAEgAiAGQdAAaiAGQagBaiAGKAIUEM8DIAZB6ABqIgEgBkGAAWopAgA3AwAgBkHwAGoiAiAGQYgBaigCADYCACAGIAYpAng3A2AgBigCdCIEQYCAgIB4RgRAIAAgBikDYDcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADAELIAZB2AFqIgIgBkGkAWooAgA2AgAgBkHQAWoiCCAGQZwBaikCADcDACAGQcgBaiIHIAZBlAFqKQIANwMAIAYgBikCjAE3A8ABQTxBBBCtNiIBRQ0EIAEgBDYCCCABQoGAgIAQNwIAIAEgBikDYDcCDCABIAYpA8ABNwIgIABBoO2CATYCCCAAIAE2AgQgAUEUaiAGQegAaikDADcCACABQRxqIAZB8ABqKAIANgIAIAFBKGogBykDADcCACABQTBqIAgpAwA3AgAgAUE4aiACKAIANgIAIABBk4CAgHg2AgALIAZBHGpBBEEEEOAeIAZB4AFqJAAMBAtBsMCCAUEpIAZB9ABqQeDIggFB3MCCARDVHgALQcAAIAIQoz0LAAtBBEE8EKM9AAsMHgsgCEEEaiEVIwBBgAJrIgMkACADQQA2AhAgA0EAOgAWIANBADoAFyADIAE2AnggAyABIAJBA3RqNgJ8IAMgA0EXajYCiAEgAyADQRZqNgKEASADIANBEGo2AoABIANBGGohBiMAQTBrIgEkAAJAIANB+ABqIgIQ3xUiBwRAIAFBGGoiCEEDIAIoAgQgAigCAGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCABKAIcIQQgASgCGEEBRg03IAEoAiAiBSAHNgIAIAFBFGoiCUEBNgIAIAEgBTYCECABIAQ2AgwgAUEoaiACQRBqKAIANgIAIAFBIGogAkEIaikCADcDACABIAIpAgA3AxggCBDfFSICBEAgAUEMaiEEA0AgBCgCCCIHIAQoAgBGBEAgBCAHIAgoAgQgCCgCAGtBA3ZBAWpBBEEEEN4oCyAEKAIEIAdBAnRqIAI2AgAgBCAHQQFqNgIIIAgQ3xUiAg0ACwsgBkEIaiAJKAIANgIAIAYgASkCDDcCAAwBCyAGQQA2AgggBkKAgICAwAA3AgALIAFBMGokAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AFkUEQCADQQA2AiQMAQtBwAAhAiADKAIQIgFBA3YgAUEHcUEAR2oiAUHA////A3FBQGsgASABQT9xGyIBQcAAENE0RQ0xIAEEQCABQcAAEK02IgJFDQILIANCADcCvAEgAyACNgK4ASADIAE2ArQBIANBwAA2ArABIAMoAiAiAgRAIAMoAhwhASACQQJ0IQIDQAJAIAEoAgAQmTYiBARAIANBsAFqIAQQlS8MAQsgA0GwAWogASgCABC/OhDmEAsgAUEEaiEBIAJBBGsiAg0ACwsgA0H4AGoiASADQbABaiICEIUUIANBJGogARDhJyACEM8vCyADLQAXIhJFBEAgA0HIAGogAygCHCIBIAEgAygCIEECdGoQvxsMBgtBACECIANB+ABqIAMoAiAiBEEAQQRBCBCgGCADKAJ8IQYgAygCeEEBRg0BIANBADYCRCADIAMoAoABIgE2AkAgAyAGNgI8IARFDQQgAygCHCEBIARBAnQhBANAIAEoAgAiAigCHCIGQQhJBEBBAEEAQajSggEQwyEACyACKAIYIgggBkF4cWpBCGsiBkUNAyADQQhqIAJBDGogCCgCACICIAYoAgAgAmsQyyUgAygCDCEGIAMoAgghCCADKAJEIgIgAygCPEYEQCADQTxqQcjSggEQmygLIAFBBGohASADKAJAIAJBA3RqIgcgBjYCBCAHIAg2AgAgAyACQQFqIgI2AkQgBEEEayIEDQALDAMLQcAAIAEQoz0ACyAGIAMoAoABQcDRggEQ/S8MBAtBuNKCARCyOwALIAMoAkAhAQsgA0HIAGogASABIAJBA3RqEL4bCyADQfgAaiADKAJMIAMoAlAQnQEgAygCgAEhCyADKAJ8IQ8gAygCeCIRQZOAgIB4RwRAIAAgAykChAE3AgwgACALNgIIIAAgDzYCBCAAIBE2AgAMAwsgA0EANgKMASADQQA2AoABIAMgAygCHCIBNgJ4IAMgASADKAIgQQJ0ajYCfCADQdQAaiETIwBBIGsiCSQAIANB+ABqIhYiASgCBCEUIAEoAgAhByAJQRBqIAEoAhgiBSABKAIcIhBrQQFqQQAgBSAQTxtBACABKAIUIggbIgJBfyACIAEoAgwiDCABKAIQIg1rQQFqIgRqIgYgBCAGSxsgDCANSRsgAiABKAIIIgEbQQFqQQBBCEEIEKAYIAkoAhQhAgJAIAkoAhBBAUcEQCAJQQA2AgwgCSAJKAIYIgQ2AgggCSACNgIEIAIEfyAEBSAJQQRqQaCFhAEQsyggCSgCCAtCADcDAEEAIQRBASEOA0AgCSAONgIMAn8CQAJAAkACQCABQQAgDCANTxtFBEAgB0UNAiAHIBRHDQEMAgsgDUEBSw0DDEILA0AgByICKAIAIgYoAhgiAQRAIAYoAhwiBkEDdiEMIAJBBGohByAGQRBPDQNBAiENIAcgFEcNAQsLIAJBBGohBwsCQCAIRSAFIBBJckUEQCAQQQFNDQEgBUEBayEFIAgiAUEIaiEIQQAMBAsgCUEYaiAJQQxqKAIANgIAIAkgCSkCBDcDECATIAlBEGoQvRggCUEgaiQADAYLDEALQQIhDQsgDEEBayEMIAFBCGoLIQYgBCABKAIIIAEoAgBrIARqIgJNBEAgCSgCBCAORgRAIAlBBGpB8IWEARCzKAsgCSgCCCAOQQN0aiACrTcDACAOQQFqIQ4gBiEBIAIhBAwBCwtB0IWEAUEOQeCFhAEQyyQACww/CyAVKAIAIgEgASgCACICQQFqNgIAIAJBAEgNACADQcABaiADQTRqKQIANwMAIANBuAFqIANBLGopAgA3AwAgAyADKQIkNwOwASAWIAEgEyAPIAsgA0GwAWoQ5QcgAy0AeCICQSlGBEAgA0HzAGogA0GMAWooAgAiATYAACADQesAaiADQYQBaikCACImNwAAIAMgAykCfCInNwBjIABBEGogATYAACAAQQhqICY3AAAgACAnNwAADAMLIANB7wBqIgEgA0GIAWopAAA3AAAgA0HoAGoiBCADQYEBaikAADcDACADQdABaiIGIANBmAFqKQIANwMAIANB2AFqIgggA0GgAWopAgA3AwAgA0HgAWoiByADQagBaikCADcDACADQfABaiIFIAQpAwA3AwAgA0H3AWoiBCABKQAANwAAIAMgAykCkAE3A8gBIAMgAykAeTcD6AFBwABBBBCtNiIBRQ0BIAEgAjoACCABQoGAgIAQNwIAIAEgAykD6AE3AAkgASADKQPIATcCICAAQdDRggE2AgggACABNgIEIAFBEWogBSkDADcAACABQRhqIAQpAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCCkDADcCACABQThqIAcpAwA3AgAgAEGTgICAeDYCACADQcgAakEEQQgQ4B4gEkUNAyADQTxqIgAQwycgABDqOwwDCwALQQRBwAAQoz0ACyADQcgAakEEQQgQ4B4gEgRAIANBPGoiABDDJyAAEOo7CyARQZOAgIB4Rg0AIAMoAiQiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EkahD7HgsgA0EYakEEQQQQ4B4gA0GAAmokAAwdCyAIQQRqIRUjAEGAAmsiAyQAIANBADYCECADQQA6ABYgA0EAOgAXIAMgATYCeCADIAEgAkEDdGo2AnwgAyADQRdqNgKIASADIANBFmo2AoQBIAMgA0EQajYCgAEgA0EYaiEGIwBBMGsiASQAAkAgA0H4AGoiAhD5FSIHBEAgAUEYaiIIQQMgAigCBCACKAIAa0EDdiIEIARBA00bQQFqQQBBBEEEEKAYIAEoAhwhBCABKAIYQQFGDTYgASgCICIFIAc2AgAgAUEUaiIJQQE2AgAgASAFNgIQIAEgBDYCDCABQShqIAJBEGooAgA2AgAgAUEgaiACQQhqKQIANwMAIAEgAikCADcDGCAIEPkVIgIEQCABQQxqIQQDQCAEKAIIIgcgBCgCAEYEQCAEIAcgCCgCBCAIKAIAa0EDdkEBakEEQQQQ3igLIAQoAgQgB0ECdGogAjYCACAEIAdBAWo2AgggCBD5FSICDQALCyAGQQhqIAkoAgA2AgAgBiABKQIMNwIADAELIAZBADYCCCAGQoCAgIDAADcCAAsgAUEwaiQAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAWRQRAIANBADYCJAwBC0HAACECIAMoAhAiAUEDdiABQQdxQQBHaiIBQcD///8DcUFAayABIAFBP3EbIgFBwAAQ0TRFDTAgAQRAIAFBwAAQrTYiAkUNAgsgA0IANwK8ASADIAI2ArgBIAMgATYCtAEgA0HAADYCsAEgAygCICICBEAgAygCHCEBIAJBAnQhAgNAAkAgASgCABCZNiIEBEAgA0GwAWogBBCVLwwBCyADQbABaiABKAIAEMA6EOYQCyABQQRqIQEgAkEEayICDQALCyADQfgAaiIBIANBsAFqIgIQhRQgA0EkaiABEOEnIAIQzy8LIAMtABciEkUEQCADQcgAaiADKAIcIgEgASADKAIgQQJ0ahC/GwwGC0EAIQIgA0H4AGogAygCICIEQQBBBEEIEKAYIAMoAnwhBiADKAJ4QQFGDQEgA0EANgJEIAMgAygCgAEiATYCQCADIAY2AjwgBEUNBCADKAIcIQEgBEECdCEEA0AgASgCACICKAIcIgZBBEkEQEEAQQBBqNKCARDDIQALIAIoAhgiCCAGQXxxakEEayIGRQ0DIANBCGogAkEMaiAIKAIAIgIgBigCACACaxDLJSADKAIMIQYgAygCCCEIIAMoAkQiAiADKAI8RgRAIANBPGpByNKCARCbKAsgAUEEaiEBIAMoAkAgAkEDdGoiByAGNgIEIAcgCDYCACADIAJBAWoiAjYCRCAEQQRrIgQNAAsMAwtBwAAgARCjPQALIAYgAygCgAFBwNGCARD9LwwEC0G40oIBELI7AAsgAygCQCEBCyADQcgAaiABIAEgAkEDdGoQvhsLIANB+ABqIAMoAkwgAygCUBCdASADKAKAASELIAMoAnwhDyADKAJ4IhFBk4CAgHhHBEAgACADKQKEATcCDCAAIAs2AgggACAPNgIEIAAgETYCAAwDCyADQQA2AowBIANBADYCgAEgAyADKAIcIgE2AnggAyABIAMoAiBBAnRqNgJ8IANB1ABqIRMjAEEgayIJJAAgA0H4AGoiFiIBKAIEIRQgASgCACEHIAlBEGogASgCGCIFIAEoAhwiEGtBAWpBACAFIBBPG0EAIAEoAhQiCBsiAkF/IAIgASgCDCINIAEoAhAiDmtBAWoiBGoiBiAEIAZLGyANIA5JGyACIAEoAggiARtBAWpBAEEEQQQQoBggCSgCFCECAkAgCSgCEEEBRwRAIAlBADYCDCAJIAkoAhgiBjYCCCAJIAI2AgRBACEEIAIEfyAGBSAJQQRqQaCFhAEQnSggCSgCCAtBADYCAEEBIQwDQCAJIAw2AgwCfwJAAkACQAJAIAFBACANIA5PG0UEQCAHRQ0CIAcgFEcNAQwCCyAOQQFLDQMMQQsDQCAHIgIoAgAiBigCGCIBBEAgBigCHCIGQQJ2IQ0gAkEEaiEHIAZBCE8NA0ECIQ4gByAURw0BCwsgAkEEaiEHCyAIRSAFIBBJckUEQCAQQQFNDUAgBUEBayEFIAgiAUEEaiEIQQAMAwsgBEEATgRAIAlBGGogCUEMaigCADYCACAJIAkpAgQ3AxAgEyAJQRBqEOgYIAlBIGokAAwGC0GwhYQBQQ9BwIWEARDLJAALQQIhDgsgDUEBayENIAFBBGoLIQYgBCABKAIEIAEoAgBrIARqIgJNBEAgCSgCBCAMRgRAIAlBBGpB8IWEARCdKAsgCSgCCCAMQQJ0aiACNgIAIAxBAWohDCAGIQEgAiEEDAELC0HQhYQBQQ5B4IWEARDLJAALDD4LIBUoAgAiASABKAIAIgJBAWo2AgAgAkEASA0AIANBwAFqIANBNGopAgA3AwAgA0G4AWogA0EsaikCADcDACADIAMpAiQ3A7ABIBYgASATIA8gCyADQbABahDkByADLQB4IgJBKUYEQCADQfMAaiADQYwBaigCACIBNgAAIANB6wBqIANBhAFqKQIAIiY3AAAgAyADKQJ8Iic3AGMgAEEQaiABNgAAIABBCGogJjcAACAAICc3AAAMAwsgA0HvAGoiASADQYgBaikAADcAACADQegAaiIEIANBgQFqKQAANwMAIANB0AFqIgYgA0GYAWopAgA3AwAgA0HYAWoiCCADQaABaikCADcDACADQeABaiIHIANBqAFqKQIANwMAIANB8AFqIgUgBCkDADcDACADQfcBaiIEIAEpAAA3AAAgAyADKQKQATcDyAEgAyADKQB5NwPoAUHAAEEEEK02IgFFDQEgASACOgAIIAFCgYCAgBA3AgAgASADKQPoATcACSABIAMpA8gBNwIgIABB2NKCATYCCCAAIAE2AgQgAUERaiAFKQMANwAAIAFBGGogBCkAADcAACABQShqIAYpAwA3AgAgAUEwaiAIKQMANwIAIAFBOGogBykDADcCACAAQZOAgIB4NgIAIANByABqQQRBCBDgHiASRQ0DIANBPGoiABDDJyAAEOo7DAMLAAtBBEHAABCjPQALIANByABqQQRBCBDgHiASBEAgA0E8aiIAEMMnIAAQ6jsLIBFBk4CAgHhGDQAgAygCJCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQSRqEPseCyADQRhqQQRBBBDgHiADQYACaiQADBwLQQAhBCMAQcABayIHJAAgASEGIAIhCANAIAYoAgAgBkEEaigCACgCJBEEACAEaiEEIAZBCGohBiAIQQFrIggNAAsgB0EIaiAEEMQbIAEgAkEDdGohBgNAIAEoAgAhBCABQQRqKAIAIQgjAEEgayICJAAgAkEIaiAEIAgoAhARAAAgAkEQaiACKAIIIgQgAigCDCgCDBEAAAJAIAQEQCACKQMQQquYkfGV+tX8gH+FIAIpAxhClpT4q/Cx6bPhAIWEUA0BC0Ho8IMBQQ9B+PCDARDLJAALIAJBIGokACAHQQhqIgIgBBDICyABQQhqIgEgBkcNAAsgB0GEAWoiBCACENsMAkBBxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBPPwKAAAgAEH4yoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBQGsQ5jwgBygCZARAIAdB5ABqEM8vCyAHQcwAaiIAEMUnIAAQ6DsgB0HYAGoQ3jsgBygCEARAIAdBEGoQjjsLIAdBwAFqJAAMAQsMJgsMGwsjAEGQAWsiAyQAIANByABqIgQgASACEK0YIAMoAkhBgYCAgHhHDSUgAygCTEUNJSADKAJQIQYgAygCVCEIIAQQrSEgA0EUaiAIIAYQpRQgASACQQN0aiEOIANBLGohCSADQSBqIQ0DQAJAIAEoAgAgASgCBBCTIiICENQ6RQ0AIAIoAhQiBUEISQ0oIAVBA3YhCAJAIAM1AhwiJiACKAIQIgQpAwAiJ1EEQCANIAhBAWsiBhDsLSAGQQN0IgcEQCADKAIkIAMoAihBA3RqIARBCGogB/wKAAALIAMgAygCKCAGajYCKAwBCyADQcgAaiAIQQFrQQBBCEEIEKAYIAMoAkwhByADKAJIQQFGDSpBACEGIANBADYCjAEgAyADKAJQIgw2AogBIAMgBzYChAEgBUF4cSIHQQhHBEAgJiAnfSEmIAdBCGshByAEQQhqIQxBACEFA0AgJiAFIAxqKQMAfCEnIAMoAoQBIAZGBEAgA0GEAWpB4L+CARCzKAsgAygCiAEgBWogJzcDACADIAZBAWoiBjYCjAEgByAFQQhqIgVHDQALIAMoAogBIQwLIA0gBhDsLSAGQQN0IgcEQCADKAIkIAMoAihBA3RqIAwgB/wKAAALIAMgAygCKCAGajYCKCADQYQBahDjPAsgA0EIaiACQRhqENw7IAQoAgAhBiADKAIMIQUgAygCCCEMIAIQ1DoiByAITw0sIAQgB0EDdGooAgAiCCAGSQ0qIAUgCEkNKyADQRRqIAYgDGogCCAGaxChNiACEJM2IgQEQCAJIAQQ4SYMAQsgAhDUOiECIAMoAiwEQCAJIAIQ5hAMAQsgAyADKAJAIAJqNgJACyABQQhqIgEgDkcNAAsgA0HIAGoiAiADQRRqIgQQ7g5BxABBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABByOyCATYCCCAAIAE2AgQgAEGTgICAeDYCACAEEN47IA0Q4zwgAygCLARAIAkQzy8LIANBkAFqJAAMGgsjAEGQAWsiAyQAIANByABqIgQgASACELAYIAMoAkhBgYCAgHhHDSQgAygCTEUNJCADKAJQIQYgAygCVCEIIAQQrSEgA0EUaiAIIAYQphQgASACQQN0aiEOIANBLGohCSADQSBqIQ0DQAJAIAEoAgAgASgCBBCSIiICENM6RQ0AIAIoAhQiBUEESQ0nIAVBAnYhCAJAIAMoAhwiECACKAIQIgQoAgAiEkYEQCANIAhBAWsiBhDuLSAGQQJ0IgcEQCADKAIkIAMoAihBAnRqIARBBGogB/wKAAALIAMgAygCKCAGajYCKAwBCyADQcgAaiAIQQFrQQBBBEEEEKAYIAMoAkwhByADKAJIQQFGDSlBACEGIANBADYCjAEgAyADKAJQIgw2AogBIAMgBzYChAEgBUF8cSIHQQRHBEAgECASayEMIAdBBGshByAEQQRqIRBBACEFA0AgDCAFIBBqKAIAaiESIAMoAoQBIAZGBEAgA0GEAWpB4L+CARCdKAsgAygCiAEgBWogEjYCACADIAZBAWoiBjYCjAEgByAFQQRqIgVHDQALIAMoAogBIQwLIA0gBhDuLSAGQQJ0IgcEQCADKAIkIAMoAihBAnRqIAwgB/wKAAALIAMgAygCKCAGajYCKCADQYQBahDpOwsgA0EIaiACQRhqENw7IAQoAgAhBiADKAIMIQUgAygCCCEMIAIQ0zoiByAITw0rIAQgB0ECdGooAgAiCCAGSQ0pIAUgCEkNKiADQRRqIAYgDGogCCAGaxChNiACEJM2IgQEQCAJIAQQ4SYMAQsgAhDTOiECIAMoAiwEQCAJIAIQ5hAMAQsgAyADKAJAIAJqNgJACyABQQhqIgEgDkcNAAsgA0HIAGoiAiADQRRqIgQQ7Q5BxABBBBCtNiIBRQ0jIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABBmOuCATYCCCAAIAE2AgQgAEGTgICAeDYCACAEEN47IA0Q6TsgAygCLARAIAkQzy8LIANBkAFqJAAMGQtBACEEIwBBwAFrIgckACABIQYgAiEIA0AgBigCACAGQQRqKAIAKAIkEQQAIARqIQQgBkEIaiEGIAhBAWsiCA0ACyAHQQhqIAQQxBsgASACQQN0aiEGA0AgASgCACEEIAFBBGooAgAhCCMAQSBrIgIkACACQQhqIAQgCCgCEBEAACACQRBqIAIoAggiBCACKAIMKAIMEQAAAkAgBARAIAIpAxBCr/OQ2JScx/szhSACKQMYQqClxfTN0NGkjX+FhFANAQtB6PCDAUEPQfjwgwEQyyQACyACQSBqJAAgB0EIaiICIAQQyAsgAUEIaiIBIAZHDQALIAdBhAFqIgQgAhDcDAJAQcQAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTz8CgAAIABBoMqCATYCCCAAIAE2AgQgAEGTgICAeDYCACAHQUBrEOY8IAcoAmQEQCAHQeQAahDPLwsgB0HMAGoiABDFJyAAEOg7IAdB2ABqEN47IAcoAhAEQCAHQRBqEI47CyAHQcABaiQADAELDCMLDBgLIwBBkAFrIgMkACADQcgAaiIEIAEgAhCuGCADKAJIQYGAgIB4Rw0iIAMoAkxFDSIgAygCUCEGIAMoAlQhCCAEEK0hIANBFGogCCAGEKUUIAEgAkEDdGohDiADQSxqIQkgA0EgaiENA0ACQCABKAIAIAEoAgQQlSIiAhDUOkUNACACKAIUIgVBCEkNJSAFQQN2IQgCQCADNQIcIiYgAigCECIEKQMAIidRBEAgDSAIQQFrIgYQ7C0gBkEDdCIHBEAgAygCJCADKAIoQQN0aiAEQQhqIAf8CgAACyADIAMoAiggBmo2AigMAQsgA0HIAGogCEEBa0EAQQhBCBCgGCADKAJMIQcgAygCSEEBRg0nQQAhBiADQQA2AowBIAMgAygCUCIMNgKIASADIAc2AoQBIAVBeHEiB0EIRwRAICYgJ30hJiAHQQhrIQcgBEEIaiEMQQAhBQNAICYgBSAMaikDAHwhJyADKAKEASAGRgRAIANBhAFqQeC/ggEQsygLIAMoAogBIAVqICc3AwAgAyAGQQFqIgY2AowBIAcgBUEIaiIFRw0ACyADKAKIASEMCyANIAYQ7C0gBkEDdCIHBEAgAygCJCADKAIoQQN0aiAMIAf8CgAACyADIAMoAiggBmo2AiggA0GEAWoQ4zwLIANBCGogAkEYahDcOyAEKAIAIQYgAygCDCEFIAMoAgghDCACENQ6IgcgCE8NKSAEIAdBA3RqKAIAIgggBkkNJyAFIAhJDSggA0EUaiAGIAxqIAggBmsQoTYgAhCTNiIEBEAgCSAEEOEmDAELIAIQ1DohAiADKAIsBEAgCSACEOYQDAELIAMgAygCQCACajYCQAsgAUEIaiIBIA5HDQALIANByABqIgIgA0EUaiIEEOwOQcQAQQQQrTYiAUUNISABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQfDrggE2AgggACABNgIEIABBk4CAgHg2AgAgBBDeOyANEOM8IAMoAiwEQCAJEM8vCyADQZABaiQADBcLIwBBkAFrIgMkACADQcgAaiIEIAEgAhCvGCADKAJIQYGAgIB4Rw0hIAMoAkxFDSEgAygCUCEGIAMoAlQhCCAEEK0hIANBFGogCCAGEKYUIAEgAkEDdGohDiADQSxqIQkgA0EgaiENA0ACQCABKAIAIAEoAgQQlCIiAhDTOkUNACACKAIUIgVBBEkNJCAFQQJ2IQgCQCADKAIcIhAgAigCECIEKAIAIhJGBEAgDSAIQQFrIgYQ7i0gBkECdCIHBEAgAygCJCADKAIoQQJ0aiAEQQRqIAf8CgAACyADIAMoAiggBmo2AigMAQsgA0HIAGogCEEBa0EAQQRBBBCgGCADKAJMIQcgAygCSEEBRg0mQQAhBiADQQA2AowBIAMgAygCUCIMNgKIASADIAc2AoQBIAVBfHEiB0EERwRAIBAgEmshDCAHQQRrIQcgBEEEaiEQQQAhBQNAIAwgBSAQaigCAGohEiADKAKEASAGRgRAIANBhAFqQeC/ggEQnSgLIAMoAogBIAVqIBI2AgAgAyAGQQFqIgY2AowBIAcgBUEEaiIFRw0ACyADKAKIASEMCyANIAYQ7i0gBkECdCIHBEAgAygCJCADKAIoQQJ0aiAMIAf8CgAACyADIAMoAiggBmo2AiggA0GEAWoQ6TsLIANBCGogAkEYahDcOyAEKAIAIQYgAygCDCEFIAMoAgghDCACENM6IgcgCE8NKCAEIAdBAnRqKAIAIgggBkkNJiAFIAhJDScgA0EUaiAGIAxqIAggBmsQoTYgAhCTNiIEBEAgCSAEEOEmDAELIAIQ0zohAiADKAIsBEAgCSACEOYQDAELIAMgAygCQCACajYCQAsgAUEIaiIBIA5HDQALIANByABqIgIgA0EUaiIEEOsOQcQAQQQQrTYiAUUNICABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQYjqggE2AgggACABNgIEIABBk4CAgHg2AgAgBBDeOyANEOk7IAMoAiwEQCAJEM8vCyADQZABaiQADBYLAkACQCAILQABQQJrDgIAAQULQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBCEEIEKAYIAUoAgghByAFKAIEQQFGDScgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQdDnhQEpAgA3AiggBEEwakHY54UBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEPYjRQRAIAdBKGpBqPyDASgCADYCACAHQaD8gwEpAgA3AyAMKQsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDlISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0YIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQwhMgAUGAA2okAEE4QQQQrTYiAUUNGCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQbDeggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwXCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJiAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARB6OeFASkCADcCKCAEQTBqQfDnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ8SNFBEAgB0EoakHo+oMBKAIANgIAIAdB4PqDASkCADcDIAwoCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO0hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDRcgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxCpEyABQYADaiQAQThBBBCtNiIBRQ0XIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhB8OOCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADBYLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwVCwJAAkAgCC0AAQ4CAAEEC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQRBBBCgGCAFKAIIIQcgBSgCBEEBRg0mIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEGI54UBKQIANwIoIARBMGpBkOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDzI0UEQCAHQShqQcj7gwEoAgA2AgAgB0HA+4MBKQIANwMgDCgLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/iEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNFyACKAIQIQcgA0EIaiACKAIUIglBAnYiDBDuLSAJQXxxIgkEQCADKAIMIAMoAhBBAnRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENs8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgMAANwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8RggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHELsTIAFBgANqJABBOEEEEK02IgFFDRcgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEGo3IIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMFgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADBULQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBBEEEEKAYIAUoAgghByAFKAIEQQFGDSUgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQYzohQEpAgA3AiggBEEwakGU6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEO4jRQRAIAdBKGpB3PqDASgCADYCACAHQdT6gwEpAgA3AyAMJwsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDxISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0WIAIoAhAhByADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAwAA3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDxGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQshMgAUGAA2okAEE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQZDWggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwVCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFAsCQAJAAkACQCAILQABQQFrDgMBAgMAC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBCBCgGCAFKAIIIQcgBSgCBEEBRg0nIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEGg54UBKQIANwIoIARBMGpBqOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiByQAIAdBEGpBuMmEASgCADYCACAHQbDJhAEpAgA3AwggBi0AACEIIAYtAAEgB0EIaiICEL8MRSAIQQ1GcUUEQCAHQShqQajnhQEoAgA2AgAgB0Gg54UBKQIANwMgDDELIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD2ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0YIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQvxMgAUGAA2okAEE4QQQQrTYiAUUNGCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQcDiggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwXCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJiAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBsOiFASkCADcCKCAEQTBqQbjohQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQaTKhAEoAgA2AgAgB0GcyoQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQFGcUUEQCAHQShqQbjohQEoAgA2AgAgB0Gw6IUBKQIANwMgDDALIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDpISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0XIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQxhMgAUGAA2okAEE4QQQQrTYiAUUNFyABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQYDoggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwWCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJSAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBuOeFASkCADcCKCAEQTBqQcDnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQYDKhAEoAgA2AgAgB0H4yYQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQJGcUUEQCAHQShqQcDnhQEoAgA2AgAgB0G454UBKQIANwMgDC8LIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDmISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0WIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQqBMgAUGAA2okAEE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQbjgggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwVCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJCAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBvOiFASkCADcCKCAEQTBqQcTohQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQdzJhAEoAgA2AgAgB0HUyYQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQNGcUUEQCAHQShqQcTohQEoAgA2AgAgB0G86IUBKQIANwMgDC4LIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD5ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0VIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQtBMgAUGAA2okAEE4QQQQrTYiAUUNFSABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQfjaggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwUCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMEwtBACEEIwBB4ABrIgckACABIQYgAiEIA0AgBigCACAGQQRqKAIAKAIkEQQAIARqIQQgBkEIaiEGIAhBAWsiCA0ACyAHQQRqIAQQ9BggASACQQN0aiEGIAdBGGohAgNAIAdBBGogASgCACABQQRqKAIAEMUvIgQQlS8CQCAEEJs2IggEQCACIAgQ4SYMAQsgBCgCECEEIAcoAhgEQCACIAQQ5hAMAQsgByAHKAIsIARqNgIsCyABQQhqIgEgBkcNAAsgB0E0aiIEIAdBBGoiBhDKDQJAQTRBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBLPwKAAAgAEGw6YIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAYQzy8gBygCGARAIAIQzy8LIAdB4ABqJAAMAQtBBEE0EKM9AAsMEgsgCkHwAGoiBCABIAIgCBC+DiAAIAEgAiAEEPoUDBELQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoh4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpBxMmEASgCADYCACAIQbzJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJkcEQCAIQShqQdDohQEoAgA2AgAgCEHI6IUBKQIANwMgDCwLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDjISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0SIAIoAhAhCCADQQhqIAIoAhQiCUEFdiIMEO8tIAlBYHEiCQRAIAMoAgwgAygCEEEFdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ3DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ2hRBOEEEEK02IgFFDRIgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Ho4YIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ5TwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMEQsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADBALQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoB4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpByMqEASgCADYCACAIQcDKhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJUcEQCAIQShqQfznhQEoAgA2AgAgCEH054UBKQIANwMgDCsLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD8ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0RIAIoAhAhCCADQQhqIAIoAhQiCUEEdiIMEOstIAlBcHEiCQRAIAMoAgwgAygCEEEEdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2jwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ0xRBOEEEEK02IgFFDREgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Gw04IBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ5jwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMEAsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA8LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoR4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpB6MmEASgCADYCACAIQeDJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJEcEQCAIQShqQYjohQEoAgA2AgAgCEGA6IUBKQIANwMgDCoLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDoISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0QIAIoAhAhCCADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ0hRBOEEEEK02IgFFDRAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Hw2IIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ4zwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMDwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA4LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQnx4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpBoMmEASgCADYCACAIQZjJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBI0cEQCAIQShqQcznhQEoAgA2AgAgCEHE54UBKQIANwMgDCkLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDkISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0PIAIoAhAhCCADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ1xRBOEEEEK02IgFFDQ8gAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0H45YIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMDgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA0LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQ9h4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhC+JUUEQCAHQShqQYyYsOAANgIAIAdCjJiw4MCBg4YMNwMgDB8LIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQgiIhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNDiACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENgUQThBBBCtNiIBRQ0OIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhBqOeCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADA0LIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwMC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIANBPGoiBCAIEPEeIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQwSVFBEAgB0EoakGLlqzYADYCACAHQouWrNiw4cKFCzcDIAweCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO8hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQ0gAigCECEHIANBCGogAigCFCIJQQJ2IgwQ7i0gCUF8cSIJBEAgAygCDCADKAIQQQJ0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDNFEE4QQQQrTYiAUUNDSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQZjYggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwMCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMCwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD0HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMYlRQRAIAdBKGpBipSo0AA2AgAgB0KKlKjQoMGChQo3AyAMHQsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD0ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0MIAIoAhAhByADQQhqIAIoAhQiCUEBdiIMEO0tIAlBfnEiCQRAIAMoAgwgAygCEEEBdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2TwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIgcQ1RRBOEEEEK02IgFFDQwgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgCEGg2oIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAcQnTwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMCwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAoLQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQ7x4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhC/JUUEQCAHQShqQYmSpMgANgIAIAdCiZKkyJChwoQJNwMgDBwLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ7CEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNCyACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENkUQThBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhB4NSCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAoLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwJC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIANBPGoiBCAIEPIeIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQvSVFBEAgB0EoakGIkKDAADYCACAHQoiQoMCAgYKECDcDIAwbCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPUhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQogA0EIaiACKAIQIAIoAhRBAnYQjTUCQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDUFEE4QQQQrTYiAUUNCiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQdjdggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwJCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMCAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBDzHiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMQlRQRAIAdBKGpBh46cODYCACAHQoeOnLjw4MGDBzcDIAwaCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPAhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQkgAigCECEHIANBCGogAigCFCIJQQF2IgwQ7S0gCUF+cSIJBEAgAygCDCADKAIQQQF0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDZPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDPFEE4QQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQYjUggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxCdPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwICyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD3HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMklRQRAIAdBKGpBhoyYMDYCACAHQoaMmLDgwIGDBjcDIAwZCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPchIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQggA0EIaiACKAIQIAIoAhQQoTYCQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMaigCCCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDRFEE4QQQQrTYiAUUNCCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQcDXggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDeOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwHCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD4HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMMlRQRAIAdBKGpBhYqUKDYCACAHQoWKlKjQoMGCBTcDIAwYCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPMhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQcgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDbFEE4QQQQrTYiAUUNByABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQbjVggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwGCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD5HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMAlRQRAIAdBKGpBhIiQIDYCACAHQoSIkKDAgIGCBDcDIAwXCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPshIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQYgAigCECEHIANBCGogAigCFCIJQQJ2IgwQ7i0gCUF8cSIJBEAgAygCDCADKAIQQQJ0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDQFEE4QQQQrTYiAUUNBiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQeDfggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwFCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD1HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMclRQRAIAdBKGpBg4aMGDYCACAHQoOGjJiw4MCBAzcDIAwWCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPghIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQUgAigCECEHIANBCGogAigCFCIJQQF2IgwQ7S0gCUF+cSIJBEAgAygCDCADKAIQQQF0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDZPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDOFEE4QQQQrTYiAUUNBSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQdjoggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxCdPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwECyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBDwHiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMglRQRAIAdBKGpBgoSIEDYCACAHQoKEiJCgwICBAjcDIAwVCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPIhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQQgAigCECEJIANBCGogAigCFCIHEIEuIAcEQCADKAIMIAMoAhBqIAkgB/wKAAALIAMgAygCECAHajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqKAIIIQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENYUQThBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhB0OaCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEN47IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCwJAAkACQCAILQABQQFrDgIBAgALQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBBEEEEKAYIAUoAgghByAFKAIEQQFGDRQgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQaTohQEpAgA3AiggBEEwakGs6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEO8jRQRAIAdBKGpBgPuDASgCADYCACAHQfj6gwEpAgA3AyAMFgsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABCAIiECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0FIAIoAhAhByADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAwAA3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDxGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQrxMgAUGAA2okAEE4QQQQrTYiAUUNBSABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQdDbggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwECyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEEQQgQoBggBSgCCCEHIAUoAgRBAUYNEyAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBrOeFASkCADcCKCAEQTBqQbTnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ8iNFBEAgB0EoakH0+oMBKAIANgIAIAdB7PqDASkCADcDIAwVCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEOshIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQQgAigCECEHIANBCGogAigCFCIJQQN2IgwQ6i0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgIDAADcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHELQYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxCsEyABQYADaiQAQThBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBoOWCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOo7IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwCC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBEBCgGCAFKAIIIQcgBSgCBEEBRg0SIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEHU6IUBKQIANwIoIARBMGpB3OiFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDsI0UEQCAHQShqQbz7gwEoAgA2AgAgB0G0+4MBKQIANwMgDBQLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/SEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNAyACKAIQIQcgA0EIaiACKAIUIglBBHYiDBDpLSAJQXBxIgkEQCADKAIMIAMoAhBBBHRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENo8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgIABNwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQtxggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHEL4TIAFBgANqJABBOEEEEK02IgFFDQMgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEGA3YIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ7TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMAgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAELAkACQAJAAkAgCC0AAUEBaw4DAQIDAAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNFCAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARB3OeFASkCADcCKCAEQTBqQeTnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ7SNFBEAgB0EoakGE/IMBKAIANgIAIAdB/PuDASkCADcDIAwWCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEOohIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQUgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxC8EyABQYADaiQAQThBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBmOOCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAQLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwDC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBCBCgGCAFKAIIIQcgBSgCBEEBRg0TIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEH85oUBKQIANwIoIARBMGpBhOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDwI0UEQCAHQShqQZD8gwEoAgA2AgAgB0GI/IMBKQIANwMgDBULIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ5yEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNBCACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgIABNwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8xggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHELUTIAFBgANqJABBOEEEEK02IgFFDQQgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEHI2YIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ4zwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMAwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBCEEIEKAYIAUoAgghByAFKAIEQQFGDRIgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQZjohQEpAgA3AiggBEEwakGg6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEPUjRQRAIAdBKGpB1PuDASgCADYCACAHQcz7gwEpAgA3AyAMFAsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABCBIiECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0DIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQuhMgAUGAA2okAEE4QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQZDhggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwCCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNESAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBlOeFASkCADcCKCAEQTBqQZznhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ9CNFBEAgB0EoakGk+4MBKAIANgIAIAdBnPuDASkCADcDIAwTCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO4hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQIgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxDBEyABQYADaiQAQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhB6NaCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAELIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgCkGQAWokAA8LIANCADcCSCADQoGAgIDAADcCQCADQYi/ggE2AjwgA0H8AGogA0HwAGogA0E8akGQv4IBEKMrAAtBBEE4EKM9AAtBAEEAQYjuggEQwyEAC0EEQYgBEKM9AAtBBEEwEKM9AAtBwAAgAhCjPQALQQRB0AAQoz0ACyADIAUoAsABQdDLggEQ/S8AC0GwwIIBQSkgA0H4AGpB4MiCAUHcwIIBENUeAAtBBEHEABCjPQALQeDqggFBKEGI64IBEJ8pAAtBAEEAQbC/ggEQwyEACyAHIAMoAlBBwL+CARD9LwALIAYgCEGQwIIBELE7AAsgCCAFQZDAggEQsDsACyAHIAhBgMCCARDDIQALIAcgBSgCDEHs5oUBEP0vAAsgB0ECNgIMIAdB3PyDATYCCCAHQgI3AhQgB0GtAzYCPCAHIAY2AjggB0GtAzYCNCAHIAdBMGo2AhAgByAHQSBqNgIwIAdBCGpB7PyDARDvLAALIAYgBSgCDEHQyIIBEP0vAAtBjLiCARCyOwALIAQgCSgCGEHQyIIBEP0vAAtBsMCCAUEpIAVBuAFqQeDIggFB3MCCARDVHgALIAVBADYCuAFBACAFQewAaiAFQQhqIAVBuAFqQeDLggEQrysACyAEIAEoAiBB0MiCARD9LwALQQFBAUGAhoQBEMMhAAsgB0ECNgIMIAdBlOmFATYCCCAHQgI3AhQgB0GtAzYCPCAHIAY2AjggB0GtAzYCNCAHIAdBMGo2AhAgByAHQSBqNgIwIAJBpOmFARDvLAALIAhBAjYCDCAIQZTphQE2AgggCEICNwIUIAhBrQM2AjwgCCAGNgI4IAhBrQM2AjQgCCAIQTBqNgIQIAggCEEgajYCMCACQaTphQEQ7ywAC0EEQRwQoz0ACyACIAkoAhhBkIWEARD9LwAL21ACDH8DfiMAQeAVayIEJAACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCACLQAMIgVBG2sOBgMCBAUCBgELIAIoAgQiBygCCEECRg0HIAIoAgghCyAHIAcoAgAiBUEBajYCACAFQQBIDR4gBCAHNgI8IAMgCxDyJkUEQCAHIAcoAgAiAkEBazYCAEEAIQcgAkEBRw0eIARBPGoQgyAMHgsjAEEgayIDJAAgB0EIaiIFKAIAQQJGBEAgA0EANgIYIANBATYCDCADQfyszwA2AgggA0IENwIQIANBCGpBhK3PABDvLAALIAUtADAhCCADQSBqJAAgAi8BGCEDIAIvARohBkEcQQQQrTYiBUUNCCAFIAM7ARogBSAGOwEYIAUgBzYCFCAFQQA2AhAgBUKAgICAwAA3AgggBUKBgICAEDcCACAEIAU2AkAgBEGwEGogASgCACALIAEoAgQoAhARAQAgBCgCuBAhAyAEKAK0ECEHIAQoArAQIgZBCEcEQCAEQThqIARBxBBqKAIANgIAIAQgBCkCvBA3AzAgBSAFKAIAIgFBAWs2AgAgAUEBRw0dIARBQGsQ2SEMHQsgBEHEAGogAkEMahDDBgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAhB/wFxQQFrDgcCAwQFBgALAQsgBC0ARCICQRdrDgQIBwcIBgsgBEGwEGohAiMAQfABayIGJAAgBiADNgIQIAYgBzYCDCAGIAU2AhQCQAJAIARBxABqIggtAABBKUcEQCAGQSBqIAhBCGooAgA2AgAgBiAIKQIANwMYDAELIAZBqAFqIAVBCGoQiwUgBigC3AEiCEGAgICAeEYEQCAGQYABaiAGQbgBaikDACIQNwMAIAZB+ABqIAZBsAFqKQMAIhE3AwAgBiAGKQOoASISNwNwIAJBGGogEDcDACACQRBqIBE3AwAgAiASNwMIIAJCBjcDACAFIAUoAgAiAkEBazYCACACQQFGBEAgBkEUahDZIQsgBkEMahC8KgwCCyAGQfAAaiIJIAZBqAFqQTT8CgAAIAZB6ABqIAZB6AFqKQMANwMAIAYgBikD4AE3A2AgBkEoaiIKIAlBNPwKAAAgBiAINgJcIAZBGGogBkHQAGoQwgYgChCALwtBACEJIwBBMGsiCCQAIAggBTYCBAJAIAUuARgiCkEATARAIAhBgYCAgHg2AggMAQsCQCAKQQFHDQAgBS8BGg0AIAUoAhQiCUEIaiAJKAIIQQJGQQJ0ai0AICIJQQNHIAlBAEdxIQkLIAhBCGogCEEEaiAJEJUSCyACIAU2AqACIAJBADYCkAIgAkKAgICAEDcDiAIgBS4BGiEFIAJB4AFqIAhBCGpBKPwKAAAgAkICNwOYAiACQgA3AqQCIAJCBTcDACACIAVBAExBH3Q2ApQCIAhBMGokACACQYCAgIB4NgLEAiACQYCAgIB4NgK4AiACIAM2ArQCIAIgBzYCsAIgAiAGKQMYNwPQAiACQdgCaiAGQSBqKAIANgIACyAGQfABaiQAIARB2ABqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDUCAEKALAECEDIAQoArwQIQIgBCgCuBAhBiAEKQOwECIQQgZRDQogBEHgAGoiCCAEQdAQakHAAvwKAABB4AJBCBCmLyIHIAM2AhAgByACNgIMIAcgBjYCCCAHIBA3AwAgByAEKQNQNwIUIAdBHGogBSgCADYCACAHQSBqIAhBwAL8CgAAQczGzwAhAwwoCwJAIAQtAEQEQCAEQbAQaiAHIAMgBSAEQcQAahDwDSAEQfgFaiIFIARBzBBqKAIANgIAIAQgBCkCxBA3A/AFIAQoAsAQIQMgBCgCvBAhAiAEKAK4ECEGIAQpA7AQIhBCBlINASAEQThqIAUoAgA2AgAgBCAEKQPwBTcDMCACDCcLIARBsBBqIAUQyhUgBEGoA2oiBSAEQcwQaigCADYCACAEQQA6AIATIARBgICAgHg2AvQSIARBgICAgHg2AugSIAQgAzYC5BIgBCAHNgLgEiAEIAQpAsQQNwOgAyAEKALAECEDIAQoArwQIQIgBCgCuBAhBiAEKQOwECIQQgZRBEAgBEE4aiAFKAIANgIAIAQgBCkDoAM3AzAgBEHEAGoQnQwgAgwnCyAEQbADaiIFIARB0BBqQcAC/AoAAEHgAkEIEKYvIgcgAzYCECAHIAI2AgwgByAGNgIIIAcgEDcDACAHIAQpA6ADNwIUIAdBHGogBEGoA2ooAgA2AgAgB0EgaiAFQcAC/AoAACAEQcQAahCdDEH0xs8AIQMMKAsgBEGABmoiBSAEQdAQakHAAvwKAABB4AJBCBCmLyIHIAM2AhAgByACNgIMIAcgBjYCCCAHIBA3AwAgByAEKQPwBTcCFCAHQRxqIARB+AVqKAIANgIAIAdBIGogBUHAAvwKAABBnMfPACEDDCcLIARBsBBqIAcgAyAFIARBxABqEO8NIARByAhqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDwAggBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0jIARB0AhqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkDwAg3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBxMfPACEDDCYLIARBsBBqIAcgAyAFIARBxABqEPANIARBmAtqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDkAsgBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0hIARBoAtqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkDkAs3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABB7MfPACEDDCULIARBsBBqIAcgAyAFIARBxABqEPANIARB6A1qIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcD4A0gBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0fIARB8A1qIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkD4A03AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBlMjPACEDDCQLIARBsBBqIAcgAyAFIARBxABqEO8NIARB2BVqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcD0BUgBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0dIARBkBNqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkD0BU3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBvMjPACEDDCMLIAJBIkYNAgsgBEGwEGohBiMAQaAHayICJAAgAiADNgIQIAIgBzYCDCACIAU2AhQCQAJAIARBxABqIggtAABBKUcEQCACQSBqIAhBCGooAgA2AgAgAiAIKQIANwMYDAELIAJBqAFqIAVBCGoQiwUgAigC3AEiBUGAgICAeEYEQCACQYABaiACQbgBaikDACIQNwMAIAJB+ABqIAJBsAFqKQMAIhE3AwAgAiACKQOoASISNwNwIAZBEGogEDcDACAGQQhqIBE3AwAgBiASNwMAIAIoAhQiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBFGoQ2SELIAJBDGoQvCoMAgsgAkHwAGoiCSACQagBakE0/AoAACACQegAaiACQegBaikDADcDACACIAIpA+ABNwNgIAJBKGoiCCAJQTT8CgAAIAIgBTYCXCACQRhqIAJB0ABqEMEGIAgQ/i4LAkAgBgJ/AkACQAJAIAItABgiBUEUaw4GAQQCBAECAAsgBUEla0ECTw0DCyACIAIoAhQiCDYCKEEAIQUCQCAILgEYIglBAEwEQCACQYGAgIB4NgLQBgwBCwJAIAlBAUcNACAILwEaDQAgCCgCFCIFQQhqIAUoAghBAkZBAnRqLQAgIgVBA0cgBUEAR3EhBQsgAkHQBmogAkEoaiAFEJUSCyAILgEaIQogAkGwAWoiCUEANgIAIAJCgICAgMAANwKoASACQagBakEBEIYtIAJBmARqIAkoAgA2AgAgAiACKQKoATcDkAQgAkG4AWoiDCACQSBqKAIANgIAIAIgAikDGDcDsAFBsANBCBCtNiIFRQ0rIAVCBTcDACAFQQhqIAJB8AFqQawC/AoAACAFQQA2ArwCIAVCgICAgBA3ArQCIAVBwAJqIAJB0AZqQSj8CgAAIAVBgICAgHg2ApQDIAVBgICAgHg2AogDIAUgAzYChAMgBSAHNgKAAyAFQgA3A/gCIAUgCDYC9AIgBUICNwLsAiAFIApBAExBH3Q2AugCIAUgAikDqAE3A5gDIAVBoANqIAkpAwA3AwAgBUGoA2ogDCgCADYCAEGgic0ADAELIAIgAigCFCIINgIoQQAhBQJAIAguARgiCUEATARAIAJBgYCAgHg2AvgGDAELAkAgCUEBRw0AIAgvARoNACAIKAIUIgVBCGogBSgCCEECRkECdGotACAiBUEDRyAFQQBHcSEFCyACQfgGaiACQShqIAUQlRILIAguARohCiACQbABaiIJQQA2AgAgAkKAgICAgAE3AqgBIAJBqAFqQQEQhy0gAkHIBmogCSgCADYCACACIAIpAqgBNwPABiACQbgBaiIMIAJBIGooAgA2AgAgAiACKQMYNwOwAUGwA0EIEK02IgVFDSogBUIFNwMAIAVBCGogAkGgBGpBrAL8CgAAIAVBADYCvAIgBUKAgICAEDcCtAIgBUHAAmogAkH4BmpBKPwKAAAgBUGAgICAeDYClAMgBUGAgICAeDYCiAMgBSADNgKEAyAFIAc2AoADIAVCADcD+AIgBSAINgL0AiAFQgI3AuwCIAUgCkEATEEfdDYC6AIgBSACKQOoATcDmAMgBUGgA2ogCSkDADcDACAFQagDaiAMKAIANgIAQfiIzQALNgIIIAYgBTYCBCAGQQg2AgAMAQsgAkH0ic0ANgKoASACQgE3ArQBIAJBrQM2AiwgAiACQShqNgKwASACIAJBGGoiAzYCKCACQQE2AqwBIAZBBGogAkGoAWoQmQ4gBkEANgIAIAMQlAwgAigCFCIDIAMoAgAiA0EBazYCACADQQFGBEAgAkEUahDZIQsgAkEMahC8KgsgAkGgB2okACAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0hIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAwgCyAEQbAQaiEGIwBBkAJrIgIkACACIAM2AgggAiAHNgIEIAIgBTYCDAJAAkAgBEHEAGoiCC0AAEEpRwRAIAJBGGogCEEIaigCADYCACACIAgpAgAiEDcDECAQpyEFDAELIAJBoAFqIAVBCGoQiwUgAigC1AEiBUGAgICAeEYEQCACQfgAaiACQbABaikDACIQNwMAIAJB8ABqIAJBqAFqKQMAIhE3AwAgAiACKQOgASISNwNoIAZBEGogEDcDACAGQQhqIBE3AwAgBiASNwMAIAIoAgwiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBDGoQ2SELIAJBBGoQvCoMAgsgAkHoAGoiCSACQaABakE0/AoAACACQeAAaiACQeABaikDADcDACACIAIpA9gBNwNYIAJBIGoiCCAJQTT8CgAAIAIgBTYCVCACQRpBFyACLQBIQT1xQRhGGyIFOgAQIAgQ/i4LAkACQCAFQf8BcUEXaw4EAQAAAQALIAJBkJDNADYCoAEgAkIBNwKsASACQa0DNgIkIAIgAkEgajYCqAEgAiACQRBqIgM2AiAgAkEBNgKkASAGQQRqIAJBoAFqEJkOIAZBADYCACADEJQMIAIoAgwiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBDGoQ2SELIAJBBGoQvCoMAQsgAiACKAIMIgg2AqABQQAhBQJAIAguARgiCUEATARAIAJBgYCAgHg2AugBDAELAkAgCUEBRw0AIAgvARoNACAIKAIUIgVBCGogBSgCCEECRkECdGotACAiBUEDRyAFQQBHcSEFCyACQegBaiACQaABaiAFEJUSCyAILgEaIQkgAkGwAWoiCiACQRhqKAIANgIAIAIgAikDEDcDqAFBsANBCBCtNiIFBEAgBUIENwO4AiAFQgA3A7ACIAVCgICAgIACNwOoAiAFQgU3AwAgBUHAAmogAkHoAWpBKPwKAAAgBUGAgICAeDYClAMgBUGAgICAeDYCiAMgBSADNgKEAyAFIAc2AoADIAVCADcD+AIgBSAINgL0AiAFQgI3AuwCIAUgCUEATEEfdDYC6AIgBSACKQOgATcDmAMgBUGgA2ogAkGoAWopAwA3AwAgBUGoA2ogCigCADYCACAGQayPzQA2AgggBiAFNgIEIAZBCDYCAAwBCwwnCyACQZACaiQAIAQoArgQIQMgBCgCtBAhByAEKAKwECIGQQhGDSAgBEE4aiAEQcQQaigCADYCACAEIAQpArwQNwMwDB8LIARBsBBqIAcgAyAFIARBxABqELgBIAQoArgQIQMgBCgCtBAhByAEKAKwECIGQQhGDR8gBEE4aiAEQcQQaigCADYCACAEIAQpArwQNwMwDB4LIAQtAERBIkcEQCAEQbAQaiEIIwBBwARrIgIkACACIAM2AhAgAiAHNgIMIAIgBTYCFAJAAkACQCAEQcQAaiIGLQAAQSlHBEAgAkEgaiAGQQhqKAIANgIAIAIgBikCADcDGAwBCyACQagBaiAFQQhqEIsFIAIoAtwBIgZBgICAgHhGBEAgAkGAAWogAkG4AWopAwAiEDcDACACQfgAaiACQbABaikDACIRNwMAIAIgAikDqAEiEjcDcCAIQRBqIBA3AwAgCEEIaiARNwMAIAggEjcDAAwCCyACQfAAaiIJIAJBqAFqQTT8CgAAIAJB6ABqIAJB6AFqKQMANwMAIAIgAikD4AE3A2AgAkEoaiIKIAlBNPwKAAAgAiAGNgJcIAJBGGogAkHQAGoQwQYgChD+LgsCQAJAAkACQAJAAkACQAJAAkACQAJAIAVBCGoiBhDdJUH/AXEiCUEHRgRAIAIgBhDeJSIJNgL0AQJAIAItABgiBkEjaw4EBwgJCgALIAZBE2sOAwMCCwELIAIgCToAcCACQQE2AqwBIAJB2JbNADYCqAEgAkIBNwK0ASACQbEDNgIsIAIgAkEoajYCsAEgAiACQfAAajYCKAwJCyAGQQpGDQILIAJBATYCrAEgAkGUls0ANgKoASACQgE3ArQBIAJBrQM2AiwgAiACQShqNgKwASACIAJBGGo2AigMBwsgCUEMRw0BDAcLIAlBAkYNBiACQQE2AqwBIAJB6JLNADYCqAEgAkIBNwK0ASACQTs2AiwgAiACQShqNgKwASACIAJB9AFqNgIoDAULIAJBATYCrAEgAkGck80ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMBAsgCUEETQ0EIAJBATYCrAEgAkHgk80ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAwsgCUEITQ0DIAJBATYCrAEgAkGklM0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAgsgCUEQTQ0CIAJBATYCrAEgAkHolM0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAQsgCUEgTQ0BIAJBATYCrAEgAkHUlc0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigLIAhBBGogAkGoAWoQmQ4gCEEANgIAIAJBGGoQlAwMAQsgAkH4AGogAkEgaigCADYCACACIAIpAxg3A3AgAiAFNgK8BEEAIQYCQCAFLgEYIgpBAEwEQCACQYGAgIB4NgKoAQwBCwJAIApBAUcNACAFLwEaDQAgBSgCFCIGQQhqIAYoAghBAkZBAnRqLQAgIgZBA0cgBkEAR3EhBgsgAkGoAWogAkG8BGogBhCVEgsgBS4BGiEKIAJBkARqIAJBqAFqQSj8CgAAIAJBOGoiDCACQfgAaigCADYCACACIAIpA3A3AzBBqANBCBCtNiIGBEAgBkIFNwMAIAZBCGogAkH4AWpBwAL8CgAAIAZBgICAgHg2AowDIAZBgICAgHg2AoADIAYgAzYC/AIgBiAHNgL4AiAGQgA3AuwCIAYgBTYC6AIgBkICNwPgAiAGIApBAExBH3Q2AtwCIAZBADYC2AIgBkKAgICAEDcD0AIgBkEANgLIAiAGIAIpAyg3A5ADIAZBmANqIAJBMGopAwA3AwAgBkGgA2ogDCgCADYCACAGIAk2AqQDIAhB8JTNADYCCCAIIAY2AgQgCEEINgIADAILQQhBqAMQoz0ACyAFIAUoAgAiA0EBazYCACADQQFGBEAgAkEUahDZIQsgAkEMahC8KgsgAkHABGokACAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0fIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAweCyAEQbAQaiAHIAMgBSAEQcQAahC4ASAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0eIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAwdCyAEQThqIAUoAgA2AgAgBCAEKQNQNwMwIAIMGwsgBUEnRg0FCyAEIAJBDGo2AvANIARBAjYCtBAgBEGcw88ANgKwECAEQgE3ArwQIARBpwQ2ApQTIAQgBEGQE2o2ArgQIAQgBEHwDWo2ApATIARBsBBqQazDzwAQ7ywACyAAIAEgAiADQQAQqgkMHwsgBCACKAIIIgU2AqALIAVBAUcNBSAEQbAQaiABIAIoAgQgAxCeASAEKAK4ECEFIAQoArQQIQEgBCgCsBAiA0EIRwRAIAAgBCkCvBA3AgwgAEEUaiAEQcQQaigCADYCACAAIAU2AgggACABNgIEIAAgAzYCAAwfCyABRQRAQQAhAgwTCyAEQfANaiIGIAEgBSgCEBEEABDDBiACKAIQIQcgBEHkEGogAigCFCIDQTxqEN0gIARB2BBqIANBMGoQwwYgAy8BSCEIIAMpAyghECAEQbAQaiIJIANBCGoQsS4gBCAQNwPQECAEIAg7AfAQIARBkBNqIgggCSAGEKQrQdAAQQgQrTYiA0UNBiADQoGAgIAQNwMAIANBCGogCEHIAPwKAAAgAi0AHCEGIAIvARghCCACLwEaIQlBIEEEEK02IgJFDQcgAiAGOgAcIAIgCDsBGiACIAk7ARggAiAHNgIUIAIgBTYCECACIAE2AgwgAiADNgIIIAIgBzYCBCACQR06AAAMEgsgACABIAIgA0EBEKoJDB0LIAIoAgQhCCACKAIIIQUgBEEIaiACQRBqIgYQwzQgBCAFNgKwAyAEIAQoAgwiBzYCYCAFIAdHDQYgBEGwEGoiCSAFQQBBBEEIEKAYIAQoArQQIQcgBCgCsBBBAUYNByAEQQA2AogGIAQgBCgCuBA2AoQGIAQgBzYCgAYgBEHwDWogBRCUFyAEIAYQwzQgBCgCBCEHIAQgBCgCACIGNgKwECAEIAYgB0ECdGo2ArQQIAUgCRCeNiIHIAUgB0kbIgtFDQ0gBEHYEGohCiAEQeQQaiEMA0AgBEGwEGogASAIIAMQngEgBCgCuBAhCSAEKAK0ECEFIAQoArAQIgdBCEcEQCAAIAQpArwQNwIMIABBFGogBEHEEGooAgA2AgAgACAJNgIIIAAgBTYCBCAAIAc2AgAMEAsgBQRAIARB0AhqIg0gBSAJKAIQEQQAEMMGIAwgBigCACIHQTxqEN0gIAogB0EwahDDBiAHLwFIIQ4gBykDKCEQIARBsBBqIg8gB0EIahCxLiAEIBA3A9AQIAQgDjsB8BAgBEGQE2oiByAPIA0QpCsgBEHwDWogBxCIKSAEKAKIBiIHIAQoAoAGRgRAIARBgAZqQbzJzwAQmygLIAQoAoQGIAdBA3RqIg0gCTYCBCANIAU2AgAgBCAHQQFqNgKIBgsgBkEEaiEGIAhBIGohCCALQQFrIgsNAAsMDAsgBCACKAIIIgU2AsAIIAVBAkcNByAEQbAQaiABIAIoAgQiByADEJ4BIAQoArgQIQggBCgCtBAhBSAEKAKwECIGQQhHBEAgACAEKQK8EDcCDCAAQRRqIARBxBBqKAIANgIAIAAgCDYCCCAAIAU2AgQgACAGNgIADBwLIAQgCDYC5A0gBCAFNgLgDSAEQbAQaiABIAdBIGogAxCeASAEKAK4ECELIAQoArQQIQcgBCgCsBAiAUEIRwRAIAAgBCkCvBA3AgwgAEEUaiAEQcQQaigCADYCACAAIAs2AgggACAHNgIEIAAgATYCACAFRQ0cIARB4A1qELwqDBwLIAQgCzYCjAYgBCAHNgKIBiAEIAg2AoQGIAQgBTYCgAYCQAJAIAUEQCAHDQEgAEEEakHQxM8AQS8QgSAgAEEANgIAIARBgAZqELwqDB4LIAcNASAAQgg3AwAMHQsgBEHQFWoiCSAFIAgoAhARBAAQwwYgBEHgAGoiCiAHIAsoAhARBAAQwwYgAigCECIBLQAwQSBHDQkgBEEoaiABQTRqIgYQwzQgBCAEKAIsIgM2ApALIANBAkcNCiAEQaALaiINIAFBCGoQ7ShBkAFBCBCmLyEBIARBIGogBhDDNCAEKAIkRQ0LIARBsBBqIgMgBCgCICgCAEEIahDtKCAEQfANaiIMIAMgCRCkKyAEQRhqIAYQwzQgBCgCHCIGQQFLBEAgAyAEKAIYKAIEQQhqEO0oIARBkBNqIgYgAyAKEKQrIAEgDEHIAPwKAAAgAUHIAGogBkHIAPwKAAAgBEECNgK4ECAEIAE2ArQQIARBAjYCsBAgBEEQaiADEP4jIARBIDoAkBMgBCAEKQMQNwKUEyAEQdAIaiIBIA0gBhCkKyAEIAEQ0Ck2ArQDIARBJzoAsAMgBCACLQANOgCxAyACLwEaIQwgAi8BGCENIAItABwhDiMAQTBrIgEkAAJAAkACQAJAAkAgBEGwA2oiCi0AAEEnRgRAIAooAgQiBi0AMEEgRw0BIAEgBkE0ahDDNCABKAIEQQJHDQEgBi0ASEUEQCABQQhqIAZBMGoQwwZBEEEEEK02IglFDQMgCSALNgIMIAkgBzYCCCAJIAg2AgQgCSAFNgIAIAFBKGoiBSABQRBqKAIANgIAIAEgASkCCDcDIEEgQQQQrTYiAkUNBCACQQI2AgggAiAJNgIEIAJBAjYCACACIAEpAyA3AgwgAkEAOgAcIAIgDUEBajsBGiACQQJBASAOGyAMajsBGCACQRRqIAUoAgA2AgAgBiAGKAIAIgVBAWo2AgAgBUEASA0FIAMgDjoAJCADIA07ASIgAyAMOwEgIANBlMnPADYCHCADIAI2AhggAyAGNgIQIANBGzoADCADIAopAgA3AgAgA0EIaiAKQQhqKAIANgIAIAFBMGokAAwGCyABQQA2AhggAUEBNgIMIAFB4M3PADYCCCABQgQ3AhAgAUEIakHozc8AEO8sAAsgAUEANgIYIAFBATYCDCABQZjPzwA2AgggAUIENwIQIAFBCGpBoM/PABDvLAALIAFBADYCGCABQQE2AgwgAUHEzs8ANgIIIAFCBDcCECABQQhqQczOzwAQ7ywAC0EEQRAQoz0AC0EEQSAQoz0LAAtBKEEEEKYvIgEgA0Eo/AoAACAAQeDDzwA2AgggACABNgIEIABBCDYCAAwdC0EBIAZB0MPPABDDIQALIABBBGpB0MTPAEEvEIEgIABBADYCACAEQYgGahC8KgwbC0GYxM8AQShB5MjPABCfKQwWC0EEQRwQoz0ACyAEQQA2ArAQQQAgBEGgC2pBoMXPACAEQbAQakG8xs8AEK8rAAtBCEHQABCjPQALQQRBIBCjPQALIARBADYCsBBBACAEQeAAaiAEQbADaiAEQbAQakH0yM8AEK8rAAsgByAEKAK4EEGEyc8AEP0vAAsgBEEANgKwEEEAIARBwAhqQbzDzwAgBEGwEGpBgMXPABCvKwALQZjEzwBBKEHAxM8AEJ8pAAsgBEEANgKwEEEAIARBkAtqQbzDzwAgBEGwEGpBiMTPABCvKwALQQBBAEHAw88AEMMhAAsgBCgCiAZFDQAgBEGwEGoiASAEQfANakEw/AoAACAEQZATaiABEPEfIARBqAtqIgMgBEGIBmooAgA2AgAgBCAEKQKABjcDoAsgAi8BGiEFIAIvARghByACLQAcIQIgBCgCkBMhBiAEKAKUEyEIQSBBBBCtNiIBRQ0CIAEgBCkDoAs3AgAgASACOgAcIAEgBzsBGiABIAU7ARggASAINgIUIAEgBjYCECABQSA6AAwgAUEIaiADKAIANgIAIABBlMnPADYCCCAAIAE2AgQgAEEINgIAIARBmBNqEJMnDA8LIABCCDcDAAsgBEGQDmoiABDHJyAAEOk7IARB8A1qEJMnIARBgAZqIgAQgSMgAEEEQQgQ4B4MDQtBBEEgEKM9AAsgAEGUxs8ANgIIIAAgAjYCBCAAQQg2AgAMCwsgBEE4aiAFKAIANgIAIAQgBCkD0BU3AzAgAgwDCyAEQThqIAUoAgA2AgAgBCAEKQPgDTcDMCACDAILIARBOGogBSgCADYCACAEIAQpA5ALNwMwIAIMAQsgBEE4aiAFKAIANgIAIAQgBCkDwAg3AzAgAgshByAGQQhGDQELIAAgBCkDMDcCDCAAQRRqIARBOGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAY2AgAMBQsgB0UNASABKAIMIgJFDQIgAigCACALEPImRQRAIAAgAzYCCCAAIAc2AgQgAEEINgIADAULIAIoAgQoAgAiBSAFKAIAIgZBAWo2AgAgBkEASA0AIAItAAghCCABKAIIKAIAIgYEQCAGIAYoAgAiAUEBajYCACABQQBIDQELIwBBIGsiAiQAIAJBCGogBUEIahCoISACKAIMIgFBADoAACABKAIoIQlBAEHAABDRNEUEQEG0rM0AQSkgAkEQakGYs80AQeCszQAQ1R4ACyACQRBqQfCxzQAQpSsgAikDECEQIAIpAxghESAEQbAQaiIBIAU2AjwgASADNgIkIAEgBzYCICABIAhBAXE6AFQgAUEANgJQIAFCwAA3A0ggAULAADcDQCABIAk2AjQgAUIANwIsIAEgCzYCKCABQYCyzQApAwA3AwAgAUEIakGIss0AKQMANwMAIAEgBjYCOCABIBE3AxggASAQNwMQIAJBIGokAEHYAEEIEK02IgJFDQMgAiABQdgA/AoAACAAQcDCzwA2AgggACACNgIEIABBCDYCAAwECwALIABCCDcDAAwCCyAAIAM2AgggACAHNgIEIABBCDYCAAwBC0EIQdgAEKM9AAsgBEHgFWokAA8LQQhBsAMQoz0AC8ksAQl/IwBB8AFrIgQkACAEQQA2ApwBIARCgICAgMAANwKUAQJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAIgVBAWsOKAECAgICAwMDAwQEBB8FBiAgBwgJCgsMDQ4PEBESExEUFRYXGBkaGxwACyADQQE6ADggAyADKAIwENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQE6AAwgACACNgIEIABBATYCAAwnCyADQQE6ADggAyADKAIwENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQY6AAwgACACNgIEIABBATYCAAwmCyADQQRBABDCDyEBIANBAToAOCADKAIwIQIgA0EGQQEQrhEgA0EEIAVBAnRBnMb+AGooAgBBABDKDiADIAIQ2AchAiADQQA2AhQgA0EAOgA4IABBAjoADCAAIAI2AgggACABNgIEIABBATYCAAwlCyADQQRBABDCDyEBIANBAToAOCADKAIwIQIgA0EGQQAQrhEgA0EEIAVBAnRBjMb+AGooAgBBABDKDiADIAIQ2AchAiADQQA2AhQgA0EAOgA4IABBAjoADCAAIAI2AgggACABNgIEIABBATYCAAwkCyADQQRBABDCDyEHIANBAToAOCADKAIwIQFBASECIAVBC2sOAiEZGAsgA0EBOgA4IAQgAzYCuAEgBCADKAIwIgE2ArwBIARBuAFqQQAQvA4gAyABENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQg6AAwgACACNgIEIABBATYCAAwiCyADQQE6ADggBCADNgK4ASAEIAMoAjAiATYCvAEgBEG4AWpBARC8DiADIAEQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBCDoADCAAIAI2AgQgAEEBNgIADCELIANBAToAOCADKAIwIQIgAyABLQABQQEQuw4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQRI6AAwgACACNgIEIABBATYCAAwgCyADQQE6ADggAygCMCEFQQEhAiABLQABQQFrDgIaGBkLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBBDoADCAAIAI2AgQgAEEBNgIADB4LIANBAToAOCADKAIwIQIgA0EEIAEoAgRBABDKDiADIAIQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBDzoADCAAIAI2AgQgAEEBNgIADB0LIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBEzoADCAAIAI2AgQgAEEBNgIADBwLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBFzoADCAAIAI2AgQgAEEBNgIADBsLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBBToADCAAIAI2AgQgAEEBNgIADBoLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBFDoADCAAIAI2AgQgAEEBNgIADBkLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBGDoADCAAIAI2AgQgAEEBNgIADBgLIAMgAiABKAIEQQhqEKsCIQEgA0EBOgA4IAMgAygCMBDYByECIANBADYCFCADQQA6ADggBCABNgK4ASADIARBuAFqQQEQwg8hASAAIAI2AgggAEEMOgAMIAAgATYCBCAAQQE2AgAMFwsgBEEANgLIASAEQQE2ArwBIARBzMX+ADYCuAEgBEIENwLAASAEQbgBakHUxf4AEO8sAAsgAyACIAEoAghBCGoQqwIhAiADQQE6ADggAygCMCEFIANBBCABKAIEQQAQyg4gAyAFENgHIQEgA0EANgIUIANBADoAOCAEIAI2ArgBIAMgBEG4AWpBARDCDyECIAAgATYCCCAAQRA6AAwgACACNgIEIABBATYCAAwVCyADIAIgASgCBEEIahCrAiEBIANBAToAOCADIAMoAjAQ2AchAiADQQA2AhQgA0EAOgA4IAQgATYCuAEgAyAEQbgBakEBEMIPIQEgACACNgIIIABBFToADCAAIAE2AgQgAEEBNgIADBQLIARBADYCwAEgBEKAgICAwAA3ArgBIARBOGogAUEEahCvLiAEKAI4IgEgBCgCPCIGRwRAA0AgAyACIAEoAgBBCGoQqwIhByAEKALAASIFIAQoArgBRgRAIARBuAFqQeTF/gAQnSgLIAQoArwBIAVBAnRqIAc2AgAgBCAFQQFqNgLAASABQQRqIgEgBkcNAAsLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IAMgBCgCvAEgBCgCwAEQwg8hAiAAIAE2AgggAEENOgAMIAAgAjYCBCAAQQE2AgAgBEG4AWpBBEEEEOAeDBMLIARBADYCqAEgBEKAgICAwAA3AqABIARBiAFqIAFBBGoiBxCwLiAEKAKIASIFIAQoAowBIghHBEADQCADIAIgBUEEaigCAEEIahCrAiEKIAQoAqgBIgYgBCgCoAFGBEAgBEGgAWpB9MX+ABCdKAsgBCgCpAEgBkECdGogCjYCACAEIAZBAWo2AqgBIAVBCGoiBSAIRw0ACwsgAS0AASEKIARBgAFqIAcQsC4gBCgCgAEhASAEKAKEASEFIwBBIGsiAiQAIAJBFGogBSABa0EDdkEAQQRBBBCgGCACKAIYIQYgAigCFEEBRgRAIAYgAigCHEHQt/4AEP0vAAsgBEGsAWohCSACQRBqIgtBADYCACACIAIoAhw2AgwgAiAGNgIIIAJBCGoiBiAFIAFrQQN2IgcQ7i0gBigCCCEIIAYgASAFRwR/IAcgCGogBigCBCAIQQJ0aiEFA0AgBSABLAAANgIAIAFBCGohASAFQQRqIQUgB0EBayIHDQALBSAICzYCCCAJQQhqIAsoAgA2AgAgCSACKQIINwIAIAJBIGokACADQQQgAygCNCIBIAFBBE0bNgI0IAQoArABIQcgA0EwaiEGIAQoArQBIghBAnQhAQJAQQAgAygCMCIFa0EDcSICIAMoAgggBWtNDQAgAygCCCADKAIwayACTw0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAIQjTcCQCABQQRqIgIgAygCCCADKAIwayIFTQ0AIAJBgICAgHhLDRAgAiAFTQ0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAEQjTcgBEH4AGogAxDcOyAEQfAAaiAEKAJ4IAQoAnwgAygCMCICIAIgAWtByLb+ABDXJiAEKAJ0IQEgBCgCcCECIARBBDYC7AEgBCACNgLkASAEIAFBA3E2AuABIAQgAUF8cSIBNgLoASAEIAEgAmo2AtwBIwBBEGsiAiQAIAIgByAIQQJ0aiILNgIMIAIgBzYCCCACQQhqEJ42IQkgBEHcAWoiBSgCECIMRQRAQeT0/gAQ4isACyAEQbgBaiIBQQA2AhwgASALNgIEIAEgBzYCACABIAUpAgA3AgggAUEQaiAFQQhqKQIANwIAIAFBGGogBUEQaigCADYCACABIAUoAgwgDG4iASAJIAEgCUkbNgIgIAJBEGokACAEKALYASIBIAQoAtQBIgJLBEAgASACayEFIAQoArgBIAJBAnRqIQEgBCgCyAEgAiAEKALQASIHbGohAgNAIAIgASgCADYAACABQQRqIQEgAiAHaiECIAVBAWsiBQ0ACwsgAyAIEKkRIQcgBEGsAWoQ6TsgA0EBOgA4IAMoAjAhAQJ/IApFBEAgASADLQA6QQFHDQEaCyADQQIgAygCNCICIAJBAk0bNgI0AkAgAUEBcSICIAMoAgggAWtNDQAgAygCCCADKAIwayACTw0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAIQjTcgAygCCCADKAIwa0EBSyICIAJyRQRAA0AgAxD7FiADKAIIIAMoAjBrQQJJDQALCyAGQQIQjTcgBEHoAGogAxDcOyAEKAJsIQIgBCgCaCEFIARB4ABqIAMoAjAQjDcgBEHYAGogBSACIAQoAmAgBCgCZEGwt/4AENcmIAQoAlxBAU0NFCAEKAJYIAo7AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIIQQQ7AQQgCCAFNgIAIAMgAkEBajYCFCADKAIwCyEFIANBBCADKAI0IgIgAkEETRs2AjQCQEEAIAVrQQNxIgIgAygCCCAFa00NACADKAIIIAMoAjBrIAJPDQADQCADEPsWIAMoAgggAygCMGsgAkkNAAsLIAYgAhCNNyADKAIIIAMoAjBrQQNLIgIgAnJFBEADQCADEPsWIAMoAgggAygCMGtBBEkNAAsLIAZBBBCNNyAEQdAAaiADENw7IAQoAlQhAiAEKAJQIQUgBEHIAGogAygCMBCMNyAEQUBrIAUgAiAEKAJIIAQoAkxBsLf+ABDXJiAEKAJEIgJBA00NEyAEKAJAIAIgB2s2AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIGQQY7AQQgBiAFNgIAIAMgAkEBajYCFCADIAEQ2AchASADQQA2AhQgA0EAOgA4IAMgBCgCpAEgBCgCqAEQwg8hAiAAIAE2AgggAEEOOgAMIAAgAjYCBCAAQQE2AgAgBEGgAWpBBEEEEOAeDBILIAAgASgCCCACIAMQnwEMEQsgA0EBOgA4IAMoAjAhAiADQQQgAS0AAUEAEMoOIANBBiABLAACQQAQyg4gA0EIQSBBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwQCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBwABBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwPCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBgAFBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwOCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBgAJBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwNCyADIAIgASgCBEEIahCrAiECIANBAToAOCADKAIwIQUgA0EEIAEtAAEQrhEgAyAFENgHIQEgA0EANgIUIANBADoAOCAEIAI2ArgBIAMgBEG4AWpBARDCDyECIAAgATYCCCAAQRE6AAwgACACNgIEIABBATYCAAwMCyADIAIgASgCBEEIahCrAiEFIAMgAiABKAIIQQhqEKsCIQEgA0EBOgA4IAQgATYCvAEgBCAFNgK4ASADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IAMgBEG4AWpBAhDCDyECIAAgATYCCCAAQRY6AAwgACACNgIEIABBATYCAAwLC0EAIQIgAy0AOkEBRw0JDAgLQQIhAgwHCyADIAEoAgQiAkEIakEBIAIbIAEoAghBACACGyICELQLIQUgA0EBOgA4IAMoAjAhBiADIAEtAAFBABC7DiACBEAgA0EGIAUQ/A4LIAMgBhDYByEBIANBADYCFCADQQA6ADggA0EEQQAQwg8hAiAAIAE2AgggAEEKOgAMIAAgAjYCBCAAQQE2AgAMCAsgA0EBOgA4IAMoAjAhAiADQQYgAS0AASIBQQJ0QbTG/gBqKAIAQSAQyg4gAyABQQEQuw4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQk6AAwgACACNgIEIABBATYCAAwHC0ECIQIMAQtBACECQQQgAy0AOkEBRw0BGgsgA0EwaiEGIANBAiADKAI0IgEgAUECTRs2AjQCQCAFQQFxIgEgAygCCCAFa00NACADKAIIIAMoAjBrIAFPDQADQCADEPsWIAMoAgggAygCMGsgAUkNAAsLIAYgARCNNyADKAIIIAMoAjBrQQFLIgEgAXJFBEADQCADEPsWIAMoAgggAygCMGtBAkkNAAsLIAZBAhCNNyAEQTBqIAMQ3DsgBCgCNCEBIAQoAjAhBiAEQShqIAMoAjAQjDcgBEEgaiAGIAEgBCgCKCAEKAIsQbC3/gAQ1yYgBCgCJEEBTQ0FIAQoAiAgAjsAACADKAIwIQIgAygCFCIBIAMoAgxGBEAgA0EMakG4tv4AEJsoCyADKAIQIAFBA3RqIgZBBDsBBCAGIAI2AgAgAyABQQFqNgIUIAQoApwBIQIgBCgCmAELIQEgAyAFENgHIQUgA0EANgIUIANBADoAOCADIAEgAhDCDyEBIAAgBTYCCCAAQQs6AAwgACABNgIEIABBATYCAAwDC0HYtv4AQSVBgLf+ABCfKQALIANBMGohBiADQQIgAygCNCIFIAVBAk0bNgI0AkAgAUEBcSIFIAMoAgggAWtNDQAgAygCCCADKAIwayAFTw0AA0AgAxD7FiADKAIIIAMoAjBrIAVJDQALCyAGIAUQjTcgAygCCCADKAIwa0EBSyIFIAVyRQRAA0AgAxD7FiADKAIIIAMoAjBrQQJJDQALCyAGQQIQjTcgBEEYaiADENw7IAQoAhwhBSAEKAIYIQYgBEEQaiADKAIwEIw3IARBCGogBiAFIAQoAhAgBCgCFEGwt/4AENcmIAQoAgxBAU0NAiAEKAIIIAI7AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIGQQQ7AQQgBiAFNgIAIAMgAkEBajYCFAsgAyABENgHIQEgA0EANgIUIANBADoAOCAAQQM6AAwgACABNgIIIAAgBzYCBCAAQQE2AgALIARBlAFqQQRBBBDgHiAEQfABaiQADwsgBEEANgLIASAEQQE2ArwBIARB7Lf+ADYCuAEgBEIENwLAASAEQbgBakHAt/4AEO8sAAvtOAENfyMAQbABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AGEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnSAALIARBBGoiAiABQcQA/AoAAAJ/IwBBMGsiBSQAIAUgAkEYaiIBNgIQAkACQCABQaSphgEQyAgEQCAFQQhqIAIQ3DsgBSAFKAIMIgE2AhQgAQ0BIAIoAiwNAiACKAIkIAIQjCcgBUEwaiQADAMLIAVCADcCJCAFQoGAgIDAADcCHCAFQbCqhgE2AhggBUEQakGIqoYBIAVBGGpBuKqGARCjKwALIAVCADcCJCAFQoGAgIDAADcCHCAFQdSrhgE2AhhBACAFQRRqQbCihgEgBUEYakHcq4YBEK8rAAsgBUEANgIoIAVBATYCHCAFQZSrhgE2AhggBUIENwIgIAVBGGpBnKuGARDvLAALIQJBDEEEEK02IgFFDUAgASACNgIIIAFCgYCAgBA3AgBBpJ6EASECDEgLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0RBBNEEEEK02IgFFDUAgAUKBgICAEDcCACABQQhqIAJBLPwKAABB/J6EASECDEcLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQthNBOEEEEK02IgFFDUcgAUKBgICAEDcCACABQQhqIAJBMPwKAABBpJOEASECDEYLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQvRNBOEEEEK02IgFFDUYgAUKBgICAEDcCACABQQhqIAJBMPwKAABBxJCEASECDEULIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQrRNBOEEEEK02IgFFDUUgAUKBgICAEDcCACABQQhqIAJBMPwKAABBzJKEASECDEQLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQsRNBOEEEEK02IgFFDUQgAUKBgICAEDcCACABQQhqIAJBMPwKAABBrJWEASECDEMLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQuBNBOEEEEK02IgFFDUMgAUKBgICAEDcCACABQQhqIAJBMPwKAABBnJGEASECDEILIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQqhNBOEEEEK02IgFFDUIgAUKBgICAEDcCACABQQhqIAJBMPwKAABB9JGEASECDEELIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQuRNBOEEEEK02IgFFDUEgAUKBgICAEDcCACABQQhqIAJBMPwKAABB1JSEASECDEALIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQrhNBOEEEEK02IgFFDUAgAUKBgICAEDcCACABQQhqIAJBMPwKAABB/JOEASECDD8LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQqxNBOEEEEK02IgFFDT8gAUKBgICAEDcCACABQQhqIAJBMPwKAABB1J+EASECDD4LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQsxNBOEEEEK02IgFFDT4gAUKBgICAEDcCACABQQhqIAJBMPwKAABBrKCEASECDD0LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQxxNBOEEEEK02IgFFDT0gAUKBgICAEDcCACABQQhqIAJBMPwKAABBhKGEASECDDwLIAEtABlBAWsOAxscHRoLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQxBNBOEEEEK02IgFFDTsgAUKBgICAEDcCACABQQhqIAJBMPwKAABBvKSEASECDDoLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQwBNBOEEEEK02IgFFDTogAUKBgICAEDcCACABQQhqIAJBMPwKAABBlKWEASECDDkLIAEtABkOAhwdGwsgAS0AGUECaw4CHR4aCyABLQAZQQFrDgMfICEeCyABLQAZQQFrDgIiIyELIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQjQxBxABBBBCtNiIBRQ02IAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQeSthAEhAgw0CyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEMsSQcAAQQQQrTYiAUUNNiABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEG8roQBIQIMMwsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCLDEHEAEEEEK02IgFFDTQgAUKBgICAEDcCACABQQhqIAJBPPwKAABBlK+EASECDDILIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0Q1BxABBBBCtNiIBRQ0zIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQeyvhAEhAgwxCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEI4MQcQAQQQQrTYiAUUNMiABQoGAgIAQNwIAIAFBCGogAkE8/AoAAEHEsIQBIQIMMAsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCMDEHEAEEEEK02IgFFDTEgAUKBgICAEDcCACABQQhqIAJBPPwKAABBnLGEASECDC8LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0g1BxABBBBCtNiIBRQ0wIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQfSxhAEhAgwuCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEK8fQcAAQQQQrTYiAUUNMCABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEHMsoQBIQIMLQsgBEEEaiICIAFBxAD8CgAAIARB7ABqIQ4jAEHgAGsiCiQAIApBBGohBkEAIQEjAEGAAmsiAyQAIANBOGogAhDcOwJAAkACQAJAAkACQAJAAkAgAygCPEECRgRAIANBKGogAhDvPCADKAIsQQFHDQIgA0EYaiACEO88IAMoAhxFDQQgA0H0AWogAygCGCIHQRhqENgGIAcoAighDSAHKAIkIQUgA0GMAWogBxC+FSADQaQBaiAHQQxqEIALIAcoAiwiCQRAIAkgCSgCACIBQQFqNgIAIAFBAEgNBCAHKAJAIQsgBygCPCEIIAcoAjghDCAHKAI0IQEgBygCMCEHCyADQeAAaiADQfwBaigCADYCACADQcgAaiADQZQBaigCADYCACADQdQAaiADQawBaigCADYCACADIAMpAvQBNwNYIAMgDTYCaCADIAU2AmQgAyADKQKMATcDQCADIAMpAqQBNwJMIAMgCzYCgAEgAyAINgJ8IAMgDDYCeCADIAE2AnQgAyAHNgJwIAMgCTYCbCACQRhqIQsgAi0AGEEcRw0BIAMgAigCHEEwaiIFNgKIASADQdgAaiIBIAUQxwhFDQUgA0GkAWoiCSADQUBrQcQA/AoAACADQRBqIAkQoAEgAygCFCEMIAMoAhAhDSADQQhqIAIQ3DsgAygCDEUNBiADKAIIIgUoAgAiCCAIKAIAIgFBAWo2AgAgAUEASA0DIAMgCDYCpAEgAyAFKQIENwKoASADQegBaiAJIAIoAiggAigCJBCAHSADIAIQ3DsgAygCBCIBQQFLBEAgAygCACIFKAIMIgggCCgCACIBQQFqNgIAIAFBAEgNBCADIAg2AowBIAMgBSkCEDcCkAEgCSADQYwBaiACKAIoIAIoAiQQgB0gBiALENgGIAZBLGogAkEsakEAIAIoAiwbEO4lIAYgDDYCECAGIA02AgwgBkEcaiADQfABaigCADYCACAGIAMpAugBNwIUIAYgAykCpAE3AiAgBkEoaiADQawBaigCADYCAAwJC0EBIAFBhJiGARDDIQALIANBMGogAhDcOyADQTs2AkQgA0EBNgKoASADQeyahgE2AqQBIANCATcCsAEgAyADKAI0NgKMASADIANBjAFqNgJAIAMgA0FAazYCrAEgBkEIaiADQaQBahCZDiAGQSk6AAAgBkGNgICAeDYCBAwHCyADIAs2AvQBIANBAzYCkAEgA0GwmYYBNgKMASADQgM3ApgBIANBrwM2ArgBIANBxwI2ArABIANBzI6GATYCrAEgA0HHAjYCqAEgA0HMjoYBNgKkASADIANBpAFqNgKUASADIANB9AFqNgK0AQwFCyADQSBqIAIQ7zwgA0E7NgJEIANBATYCqAEgA0GQmoYBNgKkASADQgE3ArABIAMgAygCJDYCjAEgAyADQYwBajYCQCADIANBQGs2AqwBIAZBCGogA0GkAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMBQsAC0EAQQBB5JeGARDDIQALIAMgATYC9AEgA0EDNgKQASADQeCYhgE2AowBIANCAzcCmAEgA0GvAzYCuAEgA0GvAzYCsAEgA0HHAjYCqAEgA0HMjoYBNgKkASADIANBpAFqNgKUASADIANBiAFqNgK0ASADIANB9AFqNgKsAQwBC0EAQQBB9JeGARDDIQALIAZBCGogA0GMAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQgA0FAaxCLJwsgAhCLJyADQYACaiQAAkAgCi0ABEEpRwRAIA4gBkHEAPwKAAAgCkHgAGokAAwBCwwxC0HMAEEEEK02IgFFDSYgAUKBgICAEDcCACABQQhqIA5BxAD8CgAAQaSzhAEhAgwsCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFENwUQTxBBBCtNiIBRQ0mIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAQfyzhAEhAgwrCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEK4fQcAAQQQQrTYiAUUNLSABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEHUtIQBIQIMKgsgBEEEaiICIAFBxAD8CgAAIARB7ABqIQ4jAEHgAGsiCiQAIApBBGohBkEAIQEjAEGAAmsiAyQAIANBOGogAhDcOwJAAkACQAJAAkACQAJAAkAgAygCPEECRgRAIANBKGogAhDvPCADKAIsQQFHDQIgA0EYaiACEO88IAMoAhxFDQQgA0H0AWogAygCGCIHQRhqENgGIAcoAighDSAHKAIkIQUgA0GMAWogBxC+FSADQaQBaiAHQQxqEIALIAcoAiwiCQRAIAkgCSgCACIBQQFqNgIAIAFBAEgNBCAHKAJAIQsgBygCPCEIIAcoAjghDCAHKAI0IQEgBygCMCEHCyADQeAAaiADQfwBaigCADYCACADQcgAaiADQZQBaigCADYCACADQdQAaiADQawBaigCADYCACADIAMpAvQBNwNYIAMgDTYCaCADIAU2AmQgAyADKQKMATcDQCADIAMpAqQBNwJMIAMgCzYCgAEgAyAINgJ8IAMgDDYCeCADIAE2AnQgAyAHNgJwIAMgCTYCbCACQRhqIQsgAi0AGEEfRw0BIAMgAigCHEEwaiIFNgKIASADQdgAaiIBIAUQxwhFDQUgA0GkAWoiCSADQUBrQcQA/AoAACADQRBqIAkQoAEgAygCFCEMIAMoAhAhDSADQQhqIAIQ3DsgAygCDEUNBiADKAIIIgUoAgAiCCAIKAIAIgFBAWo2AgAgAUEASA0DIAMgCDYCpAEgAyAFKQIENwKoASADQegBaiAJIAIoAiggAigCJBD+HCADIAIQ3DsgAygCBCIBQQFLBEAgAygCACIFKAIMIgggCCgCACIBQQFqNgIAIAFBAEgNBCADIAg2AowBIAMgBSkCEDcCkAEgCSADQYwBaiACKAIoIAIoAiQQ/hwgBiALENgGIAZBLGogAkEsakEAIAIoAiwbEO4lIAYgDDYCECAGIA02AgwgBkEcaiADQfABaigCADYCACAGIAMpAugBNwIUIAYgAykCpAE3AiAgBkEoaiADQawBaigCADYCAAwJC0EBIAFBhJiGARDDIQALIANBMGogAhDcOyADQTs2AkQgA0EBNgKoASADQeyahgE2AqQBIANCATcCsAEgAyADKAI0NgKMASADIANBjAFqNgJAIAMgA0FAazYCrAEgBkEIaiADQaQBahCZDiAGQSk6AAAgBkGNgICAeDYCBAwHCyADIAs2AvQBIANBAzYCkAEgA0GwmYYBNgKMASADQgM3ApgBIANBrwM2ArgBIANBxwI2ArABIANB3I+GATYCrAEgA0HHAjYCqAEgA0Hcj4YBNgKkASADIANBpAFqNgKUASADIANB9AFqNgK0AQwFCyADQSBqIAIQ7zwgA0E7NgJEIANBATYCqAEgA0GQmoYBNgKkASADQgE3ArABIAMgAygCJDYCjAEgAyADQYwBajYCQCADIANBQGs2AqwBIAZBCGogA0GkAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMBQsAC0EAQQBB5JeGARDDIQALIAMgATYC9AEgA0EDNgKQASADQeCYhgE2AowBIANCAzcCmAEgA0GvAzYCuAEgA0GvAzYCsAEgA0HHAjYCqAEgA0Hcj4YBNgKkASADIANBpAFqNgKUASADIANBiAFqNgK0ASADIANB9AFqNgKsAQwBC0EAQQBB9JeGARDDIQALIAZBCGogA0GMAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQgA0FAaxCLJwsgAhCLJyADQYACaiQAAkAgCi0ABEEpRwRAIA4gBkHEAPwKAAAgCkHgAGokAAwBCwwuC0HMAEEEEK02IgFFDSUgAUKBgICAEDcCACABQQhqIA5BxAD8CgAAQay1hAEhAgwpCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEIYXQTxBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAQYS2hAEhAgwoCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFELcEQThBBBCtNiIBRQ0oIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAQdy2hAEhAgwnCyABKAIcIgItAABBAmsOCBYXGBkaGxwdFQsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRDDE0E4QQQQrTYiAUUNJiABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEGsvYQBIQIMJQsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRC3E0E4QQQQrTYiAUUNJSABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEGEvoQBIQIMJAsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCwE0E4QQQQrTYiAUUNJCABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEHcvoQBIQIMIwsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRDFE0E4QQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEG0v4QBIQIMIgsgBEHsAGoiBSABQcQA/AoAACAEQQRqIgIgBRC4BkHsAEEEEK02IgFFDR8gAUKBgICAEDcCACABQQhqIAJB5AD8CgAAQYzAhAEhAgwhCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEL8TIAEQ3CkhAUHcoYQBIQIMIAsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhDGEyABENwpIQFBtKKEASECDB8LIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQqBMgARDcKSEBQYyjhAEhAgweCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELQTIAEQ3CkhAUHko4QBIQIMHQsgBCABQRhqNgJoIARBATYCCCAEQeSohAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpB7KiEARDvLAALIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQuxMgARDcKSEBQeylhAEhAgwbCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELITIAEQ3CkhAUHEpoQBIQIMGgsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhDCEyABENwpIQFBnKeEASECDBkLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQqRMgARDcKSEBQfSnhAEhAgwYCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELwTIAEQ3CkhAUH8qIQBIQIMFwsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhC1EyABENwpIQFB1KmEASECDBYLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQuhMgARDcKSEBQayqhAEhAgwVCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEMETIAEQ3CkhAUGEq4QBIQIMFAsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhCvEyABENwpIQFB3KuEASECDBMLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQrBMgARDcKSEBQbSshAEhAgwSCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEL4TIAEQ3CkhAUGMrYQBIQIMEQsgBCACNgJoIARBATYCCCAEQZS9hAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpBnL2EARDvLAALIARBBGoiAiABEJ4IIAIQ6ykhAUG0t4QBIQIMDwsgBEEEaiICIAEQpAggAhDrKSEBQYy4hAEhAgwOCyAEQQRqIgIgARCiCCACEOspIQFB5LiEASECDA0LIARBBGoiAiABEKAIIAIQ6ykhAUG8uYQBIQIMDAsgBEEEaiICIAEQnQggAhDrKSEBQZS6hAEhAgwLCyAEQQRqIgIgARCfCCACEOspIQFB7LqEASECDAoLIARBBGoiAiABEKMIIAIQ6ykhAUHEu4QBIQIMCQsgBEEEaiICIAEQoQggAhDrKSEBQZy8hAEhAgwIC0EEQQwQoz0AC0EEQTQQoz0AC0EEQcwAEKM9AAtBBEE8EKM9AAtBBEHMABCjPQALQQRBPBCjPQALQQRB7AAQoz0ACwJAAkACQAJAIAEoAhwiAi0AMEEDaw4DAgEAAwsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhCgCSABEPUpIQFBlMKEASECDAMLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQngkgARD1KSEBQbzBhAEhAgwCCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEJ8JIAEQ9SkhAUHkwIQBIQIMAQsgBCACQTBqNgJoIARBATYCCCAEQZTDhAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpBnMOEARDvLAALIAAgAjYCBCAAIAE2AgAgBEGwAWokAA8LQQRBOBCjPQALQQRBxAAQoz0AC0EEQcAAEKM9AAsgCkHYAGogCkEYaigCADYCACAKQdAAaiAKQRBqKQIANwMAIAogCikCCDcDSEGEl4YBQc0AIApByABqQdCLhgFB1JeGARDVHgALnjECEH8DfiMAQfAbayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AsAdBAWsOAwIHAQALIAJBvA9qIABBrAdqKAIANgIAIAIgACkCpAc3ArQPIAJBkAFqIgMgAkGoCGpBmAf8CgAAIAAgA0GYB/wKAAAgAEEAOgCYByAAQZgHaiEIDAMLIABBmAdqIQgCQAJAIAAtAJgHQQFrDgMBBwAECyAAQYAHaiEJIAAtAIAHQQFrDgMCBgUEC0GM2sIAEOgrAAtB3NrCABDoKwALQezZwgAQ6CsACyACQcgPaiAAQZQHaigCADYCACACIAApAowHNwPADyAAEOgmNgKIByACQagIaiIDIABBiAdqQdS3wwAgAkHAD2oQ1BAgACADQYAH/AoAACAAQQA6AIAHIABBgAdqIQkLIABB2AFqIABB2AH8CgAAIAAoAuABIQMgACkD2AEiEkIDUQRAIAAoAqgDIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQagDahCdJwsgAEEBOgCAByAAEKoeDBALIAJBxBBqIABBDGpBxAH8CgAAIAIgAzYCwBAgAiASNwO4ECACQYgSaiIDIABBqANqIAJBuBBqEM4SIABBsANqIANB0AP8CgAACyAAQbADaiELAkACQAJAIAAtAPwGQQFrDgMBAwIACyAAQQA6AP0GIABBgAVqIgQgC0HQAfwKAAAgABCvPjYC0AYgAEHQBmohB0Gf1MIAIQVBByEDAkACQAJAAkACQAJAAkACQAJAAkACQCAALQC0BkEBaw4KAAECAwQFBgcICQoLQabUwgAhBUEDIQMMCQtBqdTCACEFQQQhAwwIC0Gt1MIAIQVBAyEDDAcLQbDUwgAhBUEGIQMMBgtBttTCACEFQQQhAwwFC0G61MIAIQVBBSEDDAQLQb/UwgAhBQwDC0HG1MIAIQVBBSEDDAILIAJBgAFqIABBtQZqEP8sIAIoAoQBIQMgAigCgAEhBQwBCyACQYgBaiAAQbgGahDXOyACKAKMASEDIAIoAogBIQULIAcgBSADEO06IAJB+ABqENMlIAIoAnwhBQJAIAIoAnhBAXFFDQAgAkHwAGogBRCEGSACKAJ0IQUgAigCcCIDRQ0AIAMgBRD6OiEDDAoLIAAgBTYC1AYgAEEBOgD9BiACQcgaaiAEEPsuIAJB4BdqIAJB0BpqKQIANwMAIAIgAikCyBo3A9gXIAJB6ABqIAJB2BdqEO0SIAIoAmgiBQRAIABB1AZqIQ0gAigCbCEGA0ACQCAFKAIABEAgBSgCCCEEIAUoAgQhAwwBC0EGIQRBsMvCACEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFLQAEQQFrDlAAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1ALQQ4hBEG2y8IAIQMMTwtBDyEEQcTLwgAhAwxOC0EPIQRB08vCACEDDE0LQQ0hBEHiy8IAIQMMTAtBICEEQe/LwgAhAwxLC0EcIQRBj8zCACEDDEoLQRwhBEGrzMIAIQMMSQtBGyEEQcfMwgAhAwxIC0EdIQRB4szCACEDDEcLQRYhBEH/zMIAIQMMRgtBHiEEQZXNwgAhAwxFC0EdIQRBs83CACEDDEQLQQMhBEHQzcIAIQMMQwtBBSEEQdPNwgAhAwxCC0EHIQRB2M3CACEDDEELQQ0hBEHfzcIAIQMMQAtBDSEEQezNwgAhAww/C0EMIQRB+c3CACEDDD4LQREhBEGFzsIAIQMMPQtBCiEEQZbOwgAhAww8C0ETIQRBoM7CACEDDDsLQRAhBEGzzsIAIQMMOgtBECEEQcPOwgAhAww5C0EOIQRB087CACEDDDgLQRAhBEHhzsIAIQMMNwtBDSEEQfHOwgAhAww2C0EXIQRB/s7CACEDDDULQSMhBEGVz8IAIQMMNAtBDCEEQbjPwgAhAwwzC0HEz8IAIQMMMgtBAyEEQcrPwgAhAwwxC0EEIQRBzc/CACEDDDALQQQhBEHRz8IAIQMMLwtB1c/CACEDDC4LQQchBEHbz8IAIQMMLQtBCSEEQeLPwgAhAwwsC0EEIQRB68/CACEDDCsLQQQhBEHvz8IAIQMMKgtBCCEEQfPPwgAhAwwpC0ERIQRB+8/CACEDDCgLQQ0hBEGM0MIAIQMMJwtBCCEEQZnQwgAhAwwmC0ETIQRBodDCACEDDCULQQ0hBEG00MIAIQMMJAtBBCEEQcHQwgAhAwwjC0EIIQRBxdDCACEDDCILQQwhBEHN0MIAIQMMIQtB2dDCACEDDCALQd/QwgAhAwwfC0ESIQRB5dDCACEDDB4LQRMhBEH30MIAIQMMHQtBDyEEQYrRwgAhAwwcC0EbIQRBmdHCACEDDBsLQQUhBEG00cIAIQMMGgtBByEEQbnRwgAhAwwZC0EPIQRBwNHCACEDDBgLQQchBEHP0cIAIQMMFwtBCyEEQdbRwgAhAwwWC0EUIQRB4dHCACEDDBULQRghBEH10cIAIQMMFAtBESEEQY3SwgAhAwwTC0EWIQRBntLCACEDDBILQRUhBEG00sIAIQMMEQtBydLCACEDDBALQQohBEHP0sIAIQMMDwtBGSEEQdnSwgAhAwwOC0ECIQRB8tLCACEDDA0LQQchBEH00sIAIQMMDAtBESEEQfvSwgAhAwwLC0EKIQRBjNPCACEDDAoLQQchBEGW08IAIQMMCQtBGSEEQZ3TwgAhAwwIC0EEIQRBttPCACEDDAcLQQMhBEG608IAIQMMBgtBByEEQb3TwgAhAwwFC0EQIQRBxNPCACEDDAQLQRYhBEHU08IAIQMMAwtBFiEEQerTwgAhAwwCC0EPIQRBgNTCACEDDAELQRAhBEGP1MIAIQMLIAJB4ABqIAYQ4yAgAigCYCIGRQRAIAIQ1SkhAwwLCyACQdgAaiANIAMgBCAGIAIoAmQQuigCQCACKAJYQQFxRQ0AIAJB0ABqIAIoAlwQhBkgAigCUCIDRQ0AIAMgAigCVBD6OiEDDAsLIAJByABqIAJB2BdqEO0SIAIoAkwhBiACKAJIIgUNAAsLIABBADoA/QYgAiAAKALUBjYC2BcgByACQdgXahDsOiACKALYFyIDQYQBTwRAIAMQ8h8LIAAtAMgGRQRAIAcQpTsLIAAoAqwGIgNBBEcEQCAHIAMQpDsLIAAoArAGIgNBB0cEQCAHIAMQkj0LIAAoApgGQQFHDQQgAEGcBmoiAxDmKA0EIAJBQGsgAxDKISACKAJEIQMgAigCQEEBcQ0IIAIgAzYC2BcgByACQdgXahDMLSACKALYFyIDQYQBSQ0EIAMQ8h8MBAtBgNjCABDoKwALIABB8AZqIQUgAEH4BmohBwJAIAAtAPgGQQFrDgMCAQUACyAFKAIAIQMMAwsAC0G42cIAEOgrAAsgAkHYF2oQmR8gAigC3BchAyACKALYFw0DIAJB0BpqIAJB6BdqKQIAIhI3AwAgAiACKQLgFyITNwPIGiAAIAM2AtgGIAAgEzcC3AYgAEHkBmogEjcCACAAQdgGaiEDIAAoApAGIgRBgJTr3ANHBEAgAyAAKQOIBiAEEM0RCyACIAMQ0Ts2AtgXIAcgAkHYF2oQzS0gAigC2BciA0GEAU8EQCADEPIfCyACQThqIAAoAtQFIAAoAtgFIAcQgCQgAigCPCEFAkAgAigCOEEBcUUNACACQTBqIAUQhBkgAigCNCEFIAIoAjAiA0UNACADIAUQ+johAwwDCyAAIAU2AuwGIABB7AZqEIwXIQMgAEEAOgD4BiAAIAM2AvAGIABB+AZqIQcgAEHwBmohBQsgACADEPsONgL0BgsgAkEoaiAAQfQGaiIDIAEQxxgCQAJAAkACQAJAAkACQAJAAkAgAigCKCIBQQJHBEAgAigCLCEGIAMoAgAiBCAEKAIAQQFrIgQ2AgAgBEUEQCADELIaCwJAAkACQCABQQFxRQ0AIAJBIGogBhCEGSACKAIkIQYgAigCICIDRQ0AIAYhBAwBCyACIAY2AtgXIAJB2BdqIgEQozsNASABQSNBAEEBQQEQoBggAigC3BchASACKALYF0EBRg0DIAIoAuAXIgRByNnCAEEj/AoAAEEMQQQQrTYiA0UNBCADQSM2AgggAyAENgIEIAMgATYCAEGA1cIAIQQgBkGEAUkNACAGEPIfCyAHQQE6AAAgBRDkKCACIAQ2AsQYIAIgAzYCwBggAkEANgLQGiACQoCAgIAQNwLIGiACQezIwgA2AtwXIAJCoICAgA43AuAXIAIgAkHIGmo2AtgXIAJBwBhqIAJB2BdqEIM2DQQgAkGYGWogAkHQGmooAgAiATYCACACIAIpAsgaNwOQGSACKAKUGSABQZLZwgBBJBDBLiEBIAJBkBlqEN47QQEgAgJ/IAFFBEAgAigCxBghBSACKALAGAwBCyACQcAYahC8KkGgs8MAIQVBAQsgBRDYKSEDIAAoAuwGIgFBhAFJDQsgARDyHwwLCyAHQQE6AAAgBRDkKCACIAY2ArQWIAJB2BdqIgEQ2SkgAkG4FmogASACQbQWaiIDEI89EOASIAJBkBlqIgQgAxDiJiACKAKYGSEFIAIoApQZIQcgAkEANgLQGiACQQA2AsgaIAJBADYC2BogASACQcgaaiAHIAUQvBogAigC2BdBAkYNBCACQYAXaiABQcgA/AoAACAEEN47IAIgAxCQPTYCyBcgASACQcgXahDHEiACLQDcFyIBQQNGDQUgAUECRg0GIAIoAtgXIQMgAiABOgDQFyACIAM2AswXIAJBGGogAkHMF2oQ/CkgAigCGCIFQQJHBEAgAkHUGmohBCACKAIcIQMDQCAFQQFxDQkgAiADNgLUFyACQRBqIAJB1BdqEMgkIAIoAhBBAXENCiACQagbaiIFIAIoAhQQqysgAkGQGWoiASACKAKsGyACKAKwGxCQNSACQdgXaiIDIAEQyBMgAigC2BdBgICAgHhGDQsgAkHYGmogAkHoF2opAgA3AwAgAkHQGmogAkHgF2opAgAiEjcDACACIAIpAtgXIhM3A8gaIAJByBhqIBI+AgAgAiATNwPAGCACQZgZaiAEQQhqKAIANgIAIAIgBCkCADcDkBkgAyACQbgWaiIHQcgA/AoAACAHIAMgAkHAGGoiAyABELANIAEQ3jsgAxDeOyAFEN47IAIoAtQXIgFBhAFPBEAgARDyHwsgAkEIaiACQcwXahD8KSACKAIMIQMgAigCCCIFQQJHDQALCyACKALMFyIBQYQBTwRAIAEQ8h8LIAItAMEWIQUgAi0AwBYhAwJAAkACQCACKQO4FiISQgNRBEAgBkGEAU8EQCAGEPIfCyACQZAZaiACQYAXakHIAPwKAAAgAkHoGWogAEHoBmooAgA2AgAgAkHgGWogAEHgBmopAgA3AgAgAiAAKQLYBjcC2BkgAkGgGWoQ3jsgAkHYGWoQvSgMAQsgAiAFOgDJGCACIAM6AMgYIAIgEjcDwBggAkHKGGogAkHCFmpBPvwKAAAgAiAGNgKIGSACQZAZaiIBIAJBgBdqIgRByAD8CgAAIAJB6BlqIABB6AZqKAIANgIAIAJB4BlqIABB4AZqKQIANwIAIAIgACkC2AY3AtgZIAJByBpqIAFB3AD8CgAAIAJBqBtqIgEgBEHIAPwKAAAgAkHYF2ogAkHAGGogASACQZAbahCTICACKQPYFyISQgNSDQEgAi0A4RchBSACLQDgFyEDC0IDIRJBASACIAMgBRCsHiEDDAELIAIoAuAXIQMgAkHsGWogAkHkF2pB3AD8CgAACyACKALIFyIBQYQBTwRAIAEQ8h8LIAAoAuwGIgFBhAFPBEAgARDyHwsgAEEAOgD9BiAAKALQBiIFQYQBSQ0ODA0LIABBAzoA+AYgAEEDOgD8BgwPCyABIAIoAuAXQfzZwgAQ/S8AC0EEQQwQoz0AC0GUycIAQTcgAkGoG2pBhMnCAEHMycIAENUeAAtBkNjCAEEJEJc9AAtBmdjCAEEQEJc9AAtBqdjCAEEYEJc9AAtBwdjCAEEeEJc9AAtB39jCAEESEJc9AAtB8djCAEEhEJc9AAsgAEHYBmoQvSgLIAAtAP0GRQ0AIAAoAtQGIgFBhAFJDQAgARDyHwsgAEEAOgD9BkIDIRIgACgC0AYiBUGDAUsNACAAQYAFahCpHiAAQQE6APwGDAILIAUQ8h8LIABBgAVqEKkeIABBAToA/AYgEkIEUQ0BCyACQdgVaiACQewZakHcAPwKAAAgCxDNJCAAKAKoAyIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGoA2oQnScLIABBAToAgAcgABCqHiASQgNRDQMgAkHcD2ogAkHYFWpB3AD8CgAAIAIgAzYC2A8gAiASNwPQDyACQagIaiEHQgAhEkIAIRMjAEEwayIGJAAgBkEoakH87cMAKQIANwMAIAZB9O3DACkCADcDICAGQSBqIQRBACEFIAJB0A9qIg4iASgCKCIJBH8gASAEEKEJIQMgAS8BOCILIANB//8DcSIPcSEDIAEoAiQhDSABKAIYIRAgASgCHCERAkACQANAIAMhAUEAIQMgASARTw0AQQAhCiAQIAFBAnRqIgwvAQAiA0H//wNGDQIgBSABIAwvAQIiDCALcWsgC3FLDQICQAJAIAwgD0cNACADIAlPDQEgBCgCAEUgDSADQTRsaiIKKAIgIgxBAEdGDQAgCkEgaiEKIAwEQCAKIAQQjDVFDQEMBAsgCi0ABCAELQAERg0DCyABQQFqIQMgBUEBaiEFDAELCyADIAlBwOHDABDDIQALIA0gA0E0bGpBDGohCgsgCgVBAAshASAEKAIAIgMEQCAEQQxqIAQoAgQgBCgCCCADKAIQEQEACwJAIAFFDQAgBkEYaiABEOMgIAYoAhgiA0UNAAJAAkACQAJAAkAgBigCHCIEDgIFAAELQQEhASADLQAAQStrDgMEAQQBCyADLQAAQStGBEAgBEEBayEBIANBAWohAyAEQRJJDQEMAgsgBCIBQRFPDQELA0AgAy0AAEEwayIEQQlLDQMgA0EBaiEDIAStIBJCCn58IRIgAUEBayIBDQALDAELA0AgAUUNASAGIBJCAEIKQgAQqB4gAy0AAEEwayIEQQlLDQIgBikDCEIAUg0CIANBAWohAyABQQFrIQEgBikDACIUIAStfCISIBRaDQALDAELIAcgEjcDCEIBIRMLIAcgEzcDACAGQTBqJAAgAigCqAhFDQEgAikDsAgiEkKAgICAEFoNAiAOEMspIAIoApAQIgEEQCABEOkmIAFBEEEEEPg6CyACKAKYECIBQYQBTwRAIAEQ8h8LIBKnIQMgAkGkEGoQvSggAigCoBAiAUEQahDeOyABQcgAQQQQ+DogACgCiAciASABKAIAIgFBAWs2AgAgAUEBRgRAIABBiAdqEJ0nC0EAIQUMBAsgCUEDOgAAIAhBAzoAAEECIQUMBAtBnNrCABCyOwALQcTKwgBBKyACQagbakGgy8IAQazawgAQ1R4ACyAAKAKIByIBIAEoAgAiAUEBazYCAEEBIQUgAUEBRw0AIABBiAdqEJ0nCyAIQQE6AAALAkAgBUECRgRAQQMhBAwBCyAAEOYnQQEhBCAFQQFxRQRAIAAoAqAHIQcjAEEQayIBJAAgASAHNgIMQQEhCAJAAkACQCAHQQhqIgYtACQNACAGLQAIIAZBAToACA0AIAYoAgANAUEAIQggBkEAOgAIIAYgAzYCBCAGQQE2AgAgBi0AJEUNACAGLQAIIAZBAToACA0AIAZBADoACCAGKAIAIQggBkEANgIAIAYoAgQgAyAIGyEDCyABIAM2AgQgASAINgIADAELQYiBwwBBIEGogcMAEJ8pAAsgASgCBCEDIAEoAgAhCCAGEJQfIAcgBygCACIGQQFrNgIAIAZBAUYEQCABQQxqENkjCyACIAg2AgAgAiADNgIEIAFBEGokACACKAIAQQFxRQ0BIAIgAigCBDYCqAhBxMrCAEErIAJBqAhqQfDKwgBB/NrCABDVHgALIAIgAzYCqAhBxMrCAEErIAJBqAhqQZDLwgBB7NrCABDVHgALIAAgBDoAsAcgAkHwG2okACAFQQJGC4egAgISfwl+IwBB8AZrIggkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANBEGoiCSgCECABIAIoAiQiBREEAE0EQCADKAIAIgdBBGsOAgIDAQsgCCAJKAIQNgIgIAggASAFEQQANgIkIAhBAjYCpAUgCEGsrIMBNgKgBSAIQgI3AqwFIAhBOzYC1AIgCEE7NgLMAiAIIAhByAJqNgKoBSAIIAhBJGo2AtACIAggCEEgajYCyAIgCEGEAmogCEGgBWoQmQ4gAEGNgICAeDYCACAAIAgpAoQCNwIEIABBDGogCEGMAmooAgA2AgAMPQsgASACKAIcIgYRBAAiBS0AAEECaw4lAwQFBgcICQoLDA0CAgICAg4PAgICAgICAgICAgICAgICEBESEwILIAhBEGogAUEAIAMoAjwgAigCIBEFACAAIAgpAxA3AgQgAEGTgICAeDYCAAw7CyAIQRhqIAEgAigCHBEEABCUKSAAIAgpAxg3AgQgAEGTgICAeDYCAAw6CyABIAYRBAAiBS0AAEEBaw4oGCYmJiYmJiYmJiYmGRobHB0mJh4fICEiIyQmJiYmJi8lMSYmJiYmMiYLIAhBoAVqIgUgASACELsiIAMQ9BMgBRDcKSEBIABBrISDATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAIQaAFaiIFIAEgAhCoIiADEOETIAUQ3CkhASAAQYSFgwE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgCEGgBWoiBSABIAIQsSIgAxDiEyAFENwpIQEgAEHchYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADDYLIAhBoAVqIgUgASACEKQiIAMQ4xMgBRDcKSEBIABBtIaDATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAIQaAFaiIFIAEgAhCqIiADEPUTIAUQ3CkhASAAQYyHgwE2AgggACABNgIEIABBk4CAgHg2AgAMNAsgCEGgBWoiBSABIAIQrSIgAxDkEyAFENwpIQEgAEHkh4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAhBoAVqIgUgASACELciIAMQ5RMgBRDcKSEBIABBvIiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAIQaAFaiIFIAEgAhCiIiADEOYTIAUQ3CkhASAAQZSJgwE2AgggACABNgIEIABBk4CAgHg2AgAMMQsgASACELkiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAXYgAxCJBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEKsTIAFBoAJqJAAgAxDcKSEBIABB7ImDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwwCyABIAIQtSIhCyMAQaACayIHJAAgB0EIaiEKIAsoAhAhDiALKAIUQQJ2IQkjAEHAAWsiBCQAAkACQAJAAkACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDPz8ACyAEQfgAaiICIAMoAjxBAEEEQQQQoBggBCgCfCEGIAQoAnhBAUYNQCAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNSCABIAlLDUkgBEEkaiABIAJrIgEQ7i0gAUECdCIFBEAgBCgCKCAEKAIsQQJ0aiAOIAJBAnRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC4GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhAiAEIAQoArABIgxBAnQiATYCJCABIQYgAUE8cSIFBEAgASAFa0FAayIGIAFJDUELQcAAIQUgBkHAABDRNEUNQSAGBEAgBkHAABCtNiIFRQ0FCyAEQfgAaiINIARBMGpBOPwKAAAgBCAJNgK8ASAEIA42ArgBIAQgAjYCtAEgBCAMNgKwASAEQRhqIA0Q1hAgBSECIAQoAhhBAXEEQCAEKAIcIQEDQCABIAQoArwBIglPDQcgAiAEKAK4ASABQQJ0aioCADgAACACQQRqIQIgBEEQaiAEQfgAahDWECAEKAIUIQEgBCgCEEEBcQ0ACyAEKAIkIQELIAQgAiAFayICNgJsIAEgAkcNQiAEIAY2AogBIARCgICAgIAINwKAASAEIAE2AnwgBCAFNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCEFQRxBBBCtNiICRQ1DIAJCgYCAgBA3AgAgAiAEKQJ4NwIIIAogATYCCCAKIAU2AgQgCiACNgIAIAJBEGogBEGAAWopAgA3AgAgAkEYaiAEQYgBaigCADYCAAwCCyADKAIIIQEgAygCDCECIAQgCTYChAEgBCAONgKAASAEIAEgAkECdGo2AnwgBCABNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBBBCgGCABKAIYIQYgASgCFEEBRg07IAFBEGoiD0EANgIAIAEgASgCHDYCDCABIAY2AggjAEEQayIFJAAgAUEIaiIGIAIoAgQgAigCAGtBAnYQ7i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCAFQQRqIg4oAgQhBiAOKAIAIRACQCACKAIAIgkgAigCBCINRwRAIAIoAgwhDCACKAIIIREgDigCCCAGQQJ0aiECIA0gCWtBAnYhDgNAIAkoAgAiDSAMTw1RIAIgESANQQJ0aioCADgCACAJQQRqIQkgAkEEaiECIAZBAWohBiAOQQFrIg4NAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELgYDAELIARB+ABqIAMoAjxBAEEEQQQQoBggBCgCfCEBIAQoAnhBAUYNQiAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCIBBEAgAygCCCICIAFBA3RqIQYDQCACQQRqKAIAIgEgAigCACIFSQ0GIAEgCUsNByAEQewAaiABIAVrIgEQ7i0gAUECdCIMBEAgBCgCcCAEKAJ0QQJ0aiAOIAVBAnRqIAz8CgAACyAEIAQoAnQgAWo2AnQgAkEIaiICIAZHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC4GAsgBEHAAWokAAwFCww6C0HAACAGEKM9AAsgASAJQeyvgwEQwyEACyAFIAFBvK+DARCxOwALIAEgCUG8r4MBELA7AAsgB0GgAWogCxDMBiAHQQA7AdgBIAdBADYC1AEgB0EANgK8ASAHQQA2ArABIAdCBDcCmAEgB0IANwKQASAHQoCAgIDAADcCiAEgB0EANgKAASAHIAMoAjw2AqwBIAdBFGoiASAHQYABaiICIAoQ+iMgB0HwAGogCxCSNiADEOYYIAcoAnQEQCAHKAJwIQMgB0GIAWogB0EcakHUAPwKAAAgByADNgKEASAHQQE2AoABIAEgAiAHQfQAahCuFgsgB0HcAWoiASAHQRRqEM0cIAhBoAVqIgIgARCzEyAHQaACaiQAIAIQ3CkhASAAQcSKgwE2AgggACABNgIEIABBk4CAgHg2AgAMLwsgASACEKYiIQ4jAEGgAmsiByQAIAdBCGohCiAOKAIQIQsgDigCFEEDdiEJIwBBwAFrIgQkAAJAIAkgA0EQaiIBKAIQTwRAAkACQAJAAkACQCADKAIAQQFrDgUBAgM6OgALIARB+ABqIgIgAygCPEEAQQhBCBCgGCAEKAJ8IQYgBCgCeEEBRg07IARBADYCLCAEIAQoAoABNgIoIAQgBjYCJCACIAEQyTQgBEHsAGogAhDVCSAEKAJsQQFGBEADQCAEKAJ0IgEgBCgCcCICSQ1DIAEgCUsNRCAEQSRqIAEgAmsiARDsLSABQQN0IgUEQCAEKAIoIAQoAixBA3RqIAsgAkEDdGogBfwKAAALIAQgBCgCLCABajYCLCAEQewAaiAEQfgAahDVCSAEKAJsDQALCyAEQYABaiAEQSxqKAIANgIAIAQgBCkCJDcDeCAKIARB+ABqELMYDAMLIARB+ABqIgIgASADKAI8ELEmIARBMGogAkE4/AoAACAEKAK0ASEBIAQgBCgCsAEiDEEDdCIGNgIkIAYiAkE4cSIFBEAgAiACIAVrQUBrIgJLDTwLQcAAIQUgAkHAABDRNEUNPCACBEAgAkHAABCtNiIFRQ1DCyAEQfgAaiINIARBMGpBOPwKAAAgBCAJNgK8ASAEIAs2ArgBIAQgATYCtAEgBCAMNgKwASAEQRhqIA0Q1hAgBSEBIAQoAhhBAXEEQCAEKAIcIQkDQCAJIAQoArwBIgtPDUUgASAEKAK4ASAJQQN0aisDADkAACABQQhqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw09IAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDT4gAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBCEEIEKAYIAEoAhghBiABKAIUQQFGDTYgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDsLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAIAIoAgAiCSACKAIEIg1HBEAgAigCDCEMIAIoAgghESALKAIIIAZBA3RqIQIgDSAJa0ECdiELA0AgCSgCACINIAxPDUwgAiARIA1BA3RqKwMAOQMAIAlBBGohCSACQQhqIQIgBkEBaiEGIAtBAWsiCw0ACwsgECAGNgIADAALIAVBEGokACAEQewAaiICQQhqIA8oAgA2AgAgAiABKQIINwIAIAFBIGokACAKIAIQsxgMAQsgBEH4AGogAygCPEEAQQhBCBCgGCAEKAJ8IQEgBCgCeEEBRg09IARBADYCdCAEIAQoAoABNgJwIAQgATYCbCADKAIMIgIEQCADKAIIIgEgAkEDdGohBQNAIAFBBGooAgAiAiABKAIAIgZJDUQgAiAJSw1FIARB7ABqIAIgBmsiAhDsLSACQQN0IgwEQCAEKAJwIAQoAnRBA3RqIAsgBkEDdGogDPwKAAALIAQgBCgCdCACajYCdCABQQhqIgEgBUcNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAKIARB+ABqELMYCyAEQcABaiQADAELDDULIAdBoAFqIA4QzAYgB0EAOwHYASAHQQA2AtQBIAdBADYCvAEgB0EANgKwASAHQgQ3ApgBIAdCADcCkAEgB0KAgICAwAA3AogBIAdBADYCgAEgByADKAI8NgKsASAHQRRqIgEgB0GAAWoiAiAKEPojIAdB8ABqIA4QkjYgAxDmGCAHKAJ0BEAgBygCcCEDIAdBiAFqIAdBHGpB1AD8CgAAIAcgAzYChAEgB0EBNgKAASABIAIgB0H0AGoQrhYLIAdB3AFqIgEgB0EUahDNHCAIQaAFaiICIAEQxxMgB0GgAmokACACENwpIQEgAEGci4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADC4LIAUtAAFBAWsOAwYHCAULIAUtAAFBAWsOAgkKCAsgASACEKciIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMMTIAFBoAJqJAAgAxDcKSEBIABB3JCDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwrCyABIAIQqyIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQtxMgAUGgAmokACADENwpIQEgAEG0kYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCoLIAEgAhC8IiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBBHYhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDNTUACyAEQfgAaiICIAMoAjxBAEEQQRAQoBggBCgCfCEGIAQoAnhBAUYNNiAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNPiABIAlLDT8gBEEkaiABIAJrIgEQ6y0gAUEEdCIFBEAgBCgCKCAEKAIsQQR0aiALIAJBBHRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC1GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBBHQiBjYCJCAGIgJBMHEiBQRAIAIgAiAFa0FAayICSw03C0HAACEFIAJBwAAQ0TRFDTcgAgRAIAJBwAAQrTYiBUUNPgsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw1AIAQoArgBIAlBBHRqIgkpAwAhFiABIAkpAwg3AAggASAWNwAAIAFBEGohASAEQRBqIARB+ABqENYQIAQoAhQhCSAEKAIQQQFxDQALCyAEIAEgBWsiATYCbCABIAZHDTggBCACNgKIASAEQoCAgICACDcCgAEgBCAGNgJ8IAQgBTYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNOSABQoGAgIAQNwIAIAEgBCkCeDcCCCAKIAY2AgggCiACNgIEIAogATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEBIAMoAgwhAiAEIAk2AoQBIAQgCzYCgAEgBCABIAJBAnRqNgJ8IAQgATYCeCMAQSBrIgEkACABQRRqIARB+ABqIgIoAgQgAigCAGtBAnZBAEEQQRAQoBggASgCGCEGIAEoAhRBAUYNMSABQRBqIglBADYCACABIAEoAhw2AgwgASAGNgIIIwBBEGsiBSQAIAFBCGoiBiACKAIEIAIoAgBrQQJ2EOstIAUgBikCBEIgiTcCCCAFIAZBCGo2AgQgAiAFQQRqEJEZIAVBEGokACAEQewAaiICQQhqIAkoAgA2AgAgAiABKQIINwIAIAFBIGokACAKIAIQtRgMAQsgBEH4AGogAygCPEEAQRBBEBCgGCAEKAJ8IQEgBCgCeEEBRg04IARBADYCdCAEIAQoAoABNgJwIAQgATYCbCADKAIMIgIEQCADKAIIIgEgAkEDdGohBQNAIAFBBGooAgAiAiABKAIAIgZJDT8gAiAJSw1AIARB7ABqIAIgBmsiAhDrLSACQQR0IgwEQCAEKAJwIAQoAnRBBHRqIAsgBkEEdGogDPwKAAALIAQgBCgCdCACajYCdCABQQhqIgEgBUcNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAKIARB+ABqELUYCyAEQcABaiQADAELDDALIAdBoAFqIA4QzAYgB0EAOwHYASAHQQA2AtQBIAdBADYCvAEgB0EANgKwASAHQgQ3ApgBIAdCADcCkAEgB0KAgICAwAA3AogBIAdBADYCgAEgByADKAI8NgKsASAHQRRqIgEgB0GAAWoiAiAKEPojIAdB8ABqIA4QkjYgAxDmGCAHKAJ0BEAgBygCcCEDIAdBiAFqIAdBHGpB1AD8CgAAIAcgAzYChAEgB0EBNgKAASABIAIgB0H0AGoQrhYLIAdB3AFqIgEgB0EUahDNHCAIQaAFaiICIAEQsBMgB0GgAmokACACENwpIQEgAEGMkoMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCkLIAEgAhCpIiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBBXYhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDNDQACyAEQfgAaiICIAMoAjxBAEEQQSAQoBggBCgCfCEGIAQoAnhBAUYNNSAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNPSABIAlLDT4gBEEkaiABIAJrIgEQ7y0gAUEFdCIFBEAgBCgCKCAEKAIsQQV0aiALIAJBBXRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC5GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBBXQiBjYCJCAGIgJBIHEiBQRAIAIgAiAFa0FAayICSw02C0HAACEFIAJBwAAQ0TRFDTYgAgRAIAJBwAAQrTYiBUUNPQsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw0/IAQoArgBIAlBBXRqIgkpAwghFiAJKQMAIRcgCSkDGCEYIAFBEGogCSkDEDcAACABQRhqIBg3AAAgASAXNwAAIAEgFjcACCABQSBqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw03IAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDTggAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBEEEgEKAYIAEoAhghBiABKAIUQQFGDTAgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDvLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAAkAgAigCACIJIAIoAgQiDUcEQCACKAIMIQwgAigCCCERIAsoAgggBkEFdGohAiANIAlrQQJ2IQ0DQCAJKAIAIgsgDE8NAiARIAtBBXRqIgspAwAhFiACQRBqIAspAxA3AwAgCykDCCEXIAJBGGogCykDGDcDACACIBY3AwAgAiAXNwMIIAlBBGohCSACQSBqIQIgBkEBaiEGIA1BAWsiDQ0ACwsgECAGNgIADAELIAsgDEG8tIIBEMMhAAsgBUEQaiQAIARB7ABqIgJBCGogDygCADYCACACIAEpAgg3AgAgAUEgaiQAIAogAhC5GAwBCyAEQfgAaiADKAI8QQBBEEEgEKAYIAQoAnwhASAEKAJ4QQFGDTcgBEEANgJ0IAQgBCgCgAE2AnAgBCABNgJsIAMoAgwiAgRAIAMoAggiASACQQN0aiEFA0AgAUEEaigCACICIAEoAgAiBkkNPiACIAlLDT8gBEHsAGogAiAGayICEO8tIAJBBXQiDARAIAQoAnAgBCgCdEEFdGogCyAGQQV0aiAM/AoAAAsgBCAEKAJ0IAJqNgJ0IAFBCGoiASAFRw0ACwsgBEGAAWogBEH0AGooAgA2AgAgBCAEKQJsNwN4IAogBEH4AGoQuRgLIARBwAFqJAAMAQsMLwsgB0GgAWogDhDMBiAHQQA7AdgBIAdBADYC1AEgB0EANgK8ASAHQQA2ArABIAdCBDcCmAEgB0IANwKQASAHQoCAgIDAADcCiAEgB0EANgKAASAHIAMoAjw2AqwBIAdBFGoiASAHQYABaiICIAoQ+iMgB0HwAGogDhCSNiADEOYYIAcoAnQEQCAHKAJwIQMgB0GIAWogB0EcakHUAPwKAAAgByADNgKEASAHQQE2AoABIAEgAiAHQfQAahCuFgsgB0HcAWoiASAHQRRqEM0cIAhBoAVqIgIgARDFEyAHQaACaiQAIAIQ3CkhASAAQeSSgwE2AgggACABNgIEIABBk4CAgHg2AgAMKAsgASACELMiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACELwTIAFBoAJqJAAgAxDcKSEBIABB9IuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwnCyABIAIQoSIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQtRMgAUGgAmokACADENwpIQEgAEHMjIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCYLIAEgAhCdIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC6EyABQaACaiQAIAMQ3CkhASAAQaSNgwE2AgggACABNgIEIABBk4CAgHg2AgAMJQsgASACEK4iIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMETIAFBoAJqJAAgAxDcKSEBIABB/I2DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwkCyABIAIQuCIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEECdiADEIoFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQrxMgAUGgAmokACADENwpIQEgAEHUjoMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIAEgAhCjIiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBA3YhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDLi4ACyAEQfgAaiICIAMoAjxBAEEEQQgQoBggBCgCfCEGIAQoAnhBAUYNLyAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNNyABIAlLDTggBEEkaiABIAJrIgEQ6i0gAUEDdCIFBEAgBCgCKCAEKAIsQQN0aiALIAJBA3RqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC0GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBA3QiBjYCJCAGIgJBOHEiBQRAIAIgAiAFa0FAayICSw0wC0HAACEFIAJBwAAQ0TRFDTAgAgRAIAJBwAAQrTYiBUUNNwsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw05IAEgBCgCuAEgCUEDdGopAgA3AAAgAUEIaiEBIARBEGogBEH4AGoQ1hAgBCgCFCEJIAQoAhBBAXENAAsLIAQgASAFayIBNgJsIAEgBkcNMSAEIAI2AogBIARCgICAgIAINwKAASAEIAY2AnwgBCAFNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0yIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAogBjYCCCAKIAI2AgQgCiABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQEgAygCDCECIAQgCTYChAEgBCALNgKAASAEIAEgAkECdGo2AnwgBCABNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBCBCgGCABKAIYIQYgASgCFEEBRg0qIAFBEGoiD0EANgIAIAEgASgCHDYCDCABIAY2AggjAEEQayIFJAAgAUEIaiIGIAIoAgQgAigCAGtBAnYQ6i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCAFQQRqIgsoAgQhBiALKAIAIRACQCACKAIAIgkgAigCBCINRwRAIAIoAgwhDCACKAIIIREgCygCCCAGQQN0aiECIA0gCWtBAnYhCwNAIAkoAgAiDSAMTw1AIAIgESANQQN0aikCADcCACAJQQRqIQkgAkEIaiECIAZBAWohBiALQQFrIgsNAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELQYDAELIARB+ABqIAMoAjxBAEEEQQgQoBggBCgCfCEBIAQoAnhBAUYNMSAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCICBEAgAygCCCIBIAJBA3RqIQUDQCABQQRqKAIAIgIgASgCACIGSQ04IAIgCUsNOSAEQewAaiACIAZrIgIQ6i0gAkEDdCIMBEAgBCgCcCAEKAJ0QQN0aiALIAZBA3RqIAz8CgAACyAEIAQoAnQgAmo2AnQgAUEIaiIBIAVHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC0GAsgBEHAAWokAAwBCwwpCyAHQaABaiAOEMwGIAdBADsB2AEgB0EANgLUASAHQQA2ArwBIAdBADYCsAEgB0IENwKYASAHQgA3ApABIAdCgICAgMAANwKIASAHQQA2AoABIAcgAygCPDYCrAEgB0EUaiIBIAdBgAFqIgIgChD6IyAHQfAAaiAOEJI2IAMQ5hggBygCdARAIAcoAnAhAyAHQYgBaiAHQRxqQdQA/AoAACAHIAM2AoQBIAdBATYCgAEgASACIAdB9ABqEK4WCyAHQdwBaiIBIAdBFGoQzRwgCEGgBWoiAiABEKwTIAdBoAJqJAAgAhDcKSEBIABBrI+DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiCyABIAIQoCIhDiMAQaACayIHJAAgB0EIaiEKIA4oAhAhCyAOKAIUQQR2IQkjAEHAAWsiBCQAAkAgCSADQRBqIgEoAhBPBEACQAJAAkACQAJAIAMoAgBBAWsOBQECAy0tAAsgBEH4AGoiAiADKAI8QQBBCEEQEKAYIAQoAnwhBiAEKAJ4QQFGDS4gBEEANgIsIAQgBCgCgAE2AiggBCAGNgIkIAIgARDJNCAEQewAaiACENUJIAQoAmxBAUYEQANAIAQoAnQiASAEKAJwIgJJDTYgASAJSw03IARBJGogASACayIBEOktIAFBBHQiBQRAIAQoAiggBCgCLEEEdGogCyACQQR0aiAF/AoAAAsgBCAEKAIsIAFqNgIsIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAogBEH4AGoQtxgMAwsgBEH4AGoiAiABIAMoAjwQsSYgBEEwaiACQTj8CgAAIAQoArQBIQEgBCAEKAKwASIMQQR0IgY2AiQgBiICQTBxIgUEQCACIAIgBWtBQGsiAksNLwtBwAAhBSACQcAAENE0RQ0vIAIEQCACQcAAEK02IgVFDTYLIARB+ABqIg0gBEEwakE4/AoAACAEIAk2ArwBIAQgCzYCuAEgBCABNgK0ASAEIAw2ArABIARBGGogDRDWECAFIQEgBCgCGEEBcQRAIAQoAhwhCQNAIAkgBCgCvAEiC08NOCAEKAK4ASAJQQR0aiIJKQAAIRYgAUEIaiAJQQhqKQAANwAAIAEgFjcAACABQRBqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw0wIAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDTEgAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBCEEQEKAYIAEoAhghBiABKAIUQQFGDSkgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDpLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAIAIoAgAiCSACKAIEIg1HBEAgAigCDCEMIAIoAgghESALKAIIIAZBBHRqIQIgDSAJa0ECdiELA0AgCSgCACINIAxPDT8gESANQQR0aiINKQMAIRYgAkEIaiANQQhqKQMANwMAIAIgFjcDACAJQQRqIQkgAkEQaiECIAZBAWohBiALQQFrIgsNAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELcYDAELIARB+ABqIAMoAjxBAEEIQRAQoBggBCgCfCEBIAQoAnhBAUYNMCAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCICBEAgAygCCCIBIAJBA3RqIQUDQCABQQRqKAIAIgIgASgCACIGSQ03IAIgCUsNOCAEQewAaiACIAZrIgIQ6S0gAkEEdCIMBEAgBCgCcCAEKAJ0QQR0aiALIAZBBHRqIAz8CgAACyAEIAQoAnQgAmo2AnQgAUEIaiIBIAVHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC3GAsgBEHAAWokAAwBCwwoCyAHQaABaiAOEMwGIAdBADsB2AEgB0EANgLUASAHQQA2ArwBIAdBADYCsAEgB0IENwKYASAHQgA3ApABIAdCgICAgMAANwKIASAHQQA2AoABIAcgAygCPDYCrAEgB0EUaiIBIAdBgAFqIgIgChD6IyAHQfAAaiAOEJI2IAMQ5hggBygCdARAIAcoAnAhAyAHQYgBaiAHQRxqQdQA/AoAACAHIAM2AoQBIAdBATYCgAEgASACIAdB9ABqEK4WCyAHQdwBaiIBIAdBFGoQzRwgCEGgBWoiAiABEL4TIAdBoAJqJAAgAhDcKSEBIABBhJCDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAIQQhqIAEgAigCEBEAACAIQaAFaiIFIAgoAggiAiAIKAIMKAIMEQAAIAJFDRwgCCkDoAVCiqLN5aLCqolqhSAIKQOoBUKLsvnezZq73jmFhFBFDRwjAEGgAmsiASQAIAFBCGoiBiACIAMQlQIgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQQE6AKABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBCABQYABaiIJIAYQ+iMgAUHwAGogAhCbNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAQgCSABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAUgAhDRECABQaACaiQAIAUQ9ikhASAAQcyTgwE2AgggACABNgIEIABBk4CAgHg2AgAMIAsgBS0AAUEBaw4DDg8QDQsgASACEKUiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMQTIAFBoAJqJAAgAxDcKSEBIABBhJeDATYCCCAAIAE2AgQgAEGTgICAeDYCAAweCyABIAIQsCIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQwBMgAUGgAmokACADENwpIQEgAEHcl4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADB0LIAUtAAEOAg4PCQsgBS0AAUECaw4CDxAICyAIQaAFaiEGIAEgAhCXIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEEQQQQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgk2ApwBIAQgAjYCmAEgAgR/IAkFIARBmAFqQYywgwEQnSggBCgCnAELQQA2AgAgBEGgAWoiAkEBNgIAIAUoAhAhCSAFKAIUIQcgBEEIaiAFQRhqENw7IARBGGogAigCADYCACAEIAdBAnYiCjYCLCAEIAk2AiggBEEANgI4IARBADYCJCAEQoCAgIAQNwIcIAQgBCkCmAE3AxAgBCAEKQMINwMwIARBOGohBwJAAkACQAJAAkAgAygCAEEBaw4FAAECIiIDCyAEQYACaiICIANBEGoiCSABELEmIAQgBzYCyAIgBCAEKQMoNwPAAiAEQRBqIgcgAhCZEyACIAkgARCxJiAHIAIQ3RIMAwsgAygCDCELIAMoAgghAiAEIAc2ApACIAQgCjYCjAIgBCAJNgKIAiAEIAI2AoACIAQgAiALQQJ0aiIJNgKEAiAEQRBqIgcgBEGAAmoQtyAgByACIAkQihYMAgsgBEEQaiIJIAMoAggiAiACIAMoAgxBA3RqIgcgARDNEyAJIAIgBxD6FQwBCyAEQYACaiICIANBEGoiCRDJNCAEQRBqIgcgAiABELQRIAIgCRDJNCAHIAIQ9hMLIARBqAJqQZSo0KABNgIAIARClKjQoMGChYoUNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIARBGGooAgA2AgAgBCAEKQMQNwOYASAEQfQBaiIBIARBmAFqIgIQ8RggAiAEQYACaiIJIAEQ+iMgBEGIAmoiByAEQRxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAkQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogCSAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAYgARCNDCAEQaADaiQADAELDB0LIAYQ7CkhASAAQZSbgwE2AgggACABNgIEIABBk4CAgHg2AgAMGgsjAEEgayIFJAAgBUEIaiABIAIoAhARAAAgBUEQaiAFKAIIIgEgBSgCDCgCDBEAACAFKQMYIRYgBSkDECEXIAVBIGokACABQQAgF0LA47Xe0v6llSyFIBZC9c6oqNH+2sykf4WEUBsiCkUEQEG48oMBQRdB0PKDARDLJAALIAhBoAVqIQ4jAEGgA2siASQAIAFBCGogCkEMahDcOyABIAooAjQiAjYCECABKAIMIQYgASgCCCEHIAEgAUEQajYCFAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQCADKAIAQQFrDgUBAgMEBAALIAMoAjwiCSACbCIFQT9xIgIEQCAFIAUgAmtBQGsiBUsNMAtBwAAhAiAFQcAAENE0RQ0LIAUEQCAFQcAAEK02IgJFDQ0LIAFBADYCmAMgASACNgKUAyABIAU2ApADIAFBwAA2AowDIAFB6AFqIgsgA0EQahDJNCABQdwBaiALENUJQcAAIAEoAtwBQQFHDQoaA0AgASgCFCgCACIFIAEoAuQBbCICIAUgASgC4AFsIgVJDQUgAiAGSw0GIAEoApgDIgQgAiAFayICaiILIAEoApADIgxLBEAgAUGMA2ogDEEBdCIEIAsQ1CoiCyAEIAtLGxDoGSABKAKYAyEECyACBEAgASgClAMgBGogBSAHaiAC/AoAAAsgASABKAKYAyACajYCmAMgAUHcAWogAUHoAWoQ1QkgASgC3AENAAsgASgCmAMhBCABKAKUAyECIAEoApADIQUgASgCjAMMCgsgAUEYaiADQRBqIAMoAjwiCRCxJiABIAY2AlwgASAHNgJYIAEoAhAgASABQRRqNgJgIAlsIgVBP3EiAgRAIAUgBSACa0FAayIFSw0vC0HAACECIAVBwAAQ0TRFDQogBQRAIAVBwAAQrTYiAkUNDAsgAUEANgL0ASABIAI2AvABIAEgBTYC7AEgAUHAADYC6AEgAUHoAWohBSMAQdAAayICJAAgAkEQaiIEIAFBGGoiBkHAAPwKAAAgBigCSCEMIAYoAkQhCyAGKAJAIQ0gAkEIaiAEENYQAkACQAJAIAIoAghBAXEEQCACKAIMIQYDQCAMKAIAKAIAIgQgBkEBamwiByAEIAZsIgZJDQIgByALSw0DIAUoAgwiByAEaiIPIAUoAgQiEEsEQCAFIBBBAXQiByAPENMqIg8gByAPSxsQ6BkgBSgCDCEHCyAEBEAgBSgCCCAHaiAGIA1qIAT8CgAACyAFIAUoAgwgBGo2AgwgAiACQRBqENYQIAIoAgQhBiACKAIAQQFxDQALCyACQdAAaiQADAILIAYgB0HMtIIBELE7AAsgByALQcy0ggEQsDsACwwHCyABIAY2AnggASAHNgJ0IAEgAygCCCIFNgJsIAEgBSADKAIMQQJ0ajYCcCABIAFBFGo2AnwgAygCPCIJIAJsIgVBP3EiAgRAIAUgBSACa0FAayIFSw0uC0HAACECIAVBwAAQ0TRFDQkgBQRAIAVBwAAQrTYiAkUNCwsgAUEANgL0ASABIAI2AvABIAEgBTYC7AEgAUHAADYC6AEgAUHoAWohAgJAAkACQCABQewAaiIFKAIAIgQgBSgCBCIGRwRAIAUoAhAhDSAFKAIMIQcgBSgCCCEPIAYgBGtBAnYhCwNAIA0oAgAoAgAiBSAEKAIAIgxBAWpsIgYgBSAMbCIMSQ0CIAYgB0sNAyACKAIMIgYgBWoiECACKAIEIhFLBEAgAiARQQF0IgYgEBDTKiIQIAYgEEsbEOgZIAIoAgwhBgsgBQRAIAIoAgggBmogDCAPaiAF/AoAAAsgAiACKAIMIAVqNgIMIARBBGohBCALQQFrIgsNAAsLDAILIAwgBkHctIIBELE7AAsgBiAHQdy0ggEQsDsACwwGCyADKAI8IgkgAmwiBUE/cSICBEAgBSAFIAJrQUBrIgVLDS0LQcAAIQIgBUHAABDRNEUNCCAFBEAgBUHAABCtNiICRQ0KCyABQQA2AvQBIAEgAjYC8AEgASAFNgLsASABQcAANgLoAUHAACADKAIMIgtFDQcaIAMoAggiBSALQQN0aiEMA0AgASgCFCgCACILIAVBBGooAgBsIgIgCyAFKAIAbCILSQ0EIAIgBksNBSACIAtrIgIgBGoiDSABKALsASIPSwRAIAFB6AFqIA9BAXQiBCANENQqIg0gBCANSxsQ6BkgASgC9AEhBAsgAgRAIAEoAvABIARqIAcgC2ogAvwKAAALIAEgASgC9AEgAmoiBDYC9AEgBUEIaiIFIAxHDQALDAYLQfytgwFBKEGwsoMBEJ8pAAsgBSACQZCygwEQsTsACyACIAZBkLKDARCwOwALIAsgAkGgsoMBELE7AAsgAiAGQaCygwEQsDsACyABKAL0ASEECyABKALwASECIAEoAuwBIQUgASgC6AELIQYgAUGIAmogChDMBiABQQA7AcACIAFBADYCvAIgAUEANgKkAiABQQA2ApgCIAEgCTYClAIgAUIENwKAAiABQgA3AvgBIAFCgICAgMAANwLwASABQQA2AugBIAEgBTYCnAMgASAGNgKYAyABQQA2ApQDIAEgBDYCkAMgASACNgKMAyABIAFBjANqIgUQ1zsgASgCACEGQRxBBBCtNiICBEAgAkKBgICAEDcCACACIAEpAowDNwIIIAJBEGogAUGUA2opAgA3AgAgAkEYaiABQZwDaigCADYCACABIAQ2AuQBIAEgBjYC4AEgASACNgLcASABQYABaiICIAFB6AFqIgYgAUHcAWoQ+iMgBSAKEJI2IAMQ5hggASgCkAMEQCABKAKMAyEDIAFB8AFqIAFBiAFqQdQA/AoAACABIAM2AuwBIAFBATYC6AEgAiAGIAFBkANqEK4WCyABQcgCaiICIAFBgAFqEM0cIA4gAhDLEiABQaADaiQADAMLDCcLQbj6ggFBKSABQegBakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgDhDmKSEBIABB7JuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwZCyAIQaAFaiEJIAEgAhCWIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEIQQgQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgY2ApwBIAQgAjYCmAEgAgR/IAYFIARBmAFqQYywgwEQsyggBCgCnAELQgA3AwAgBEGgAWoiAkEBNgIAIAUoAhAhByAFKAIUIQYgBCAFQRhqENw7IARBKGogAigCADYCACAEQQA2AjQgBEKAgICAEDcCLCAEIAZBA3YiCjYCFCAEIAc2AhAgBEIANwMIIAQgBCkCmAE3AyAgBCAEKQMANwMYIARBIGohAgJAAkACQAJAAkAgAygCAEEBaw4FAAECICADCyAEQYACaiIGIANBEGoiByABELEmIAQgBCkDEDcDwAIgBCAEQQhqIgo2AsgCIAIgBhChFCAGIAcgARCxJiAKIAYQ3hIMAwsgAygCDCELIAMoAgghBiAEIAo2AowCIAQgBzYCiAIgBCAGNgKAAiAEIAYgC0ECdGoiBzYChAIgBCAEQQhqIgo2ApACIAIgBEGAAmoQtiAgCiAGIAcQiRYMAgsgBEEIaiIHIAMoAggiBiAGIAMoAgxBA3RqIgogARCiFCAHIAYgChD7FQwBCyAEQYACaiIGIANBEGoiBxDJNCAEQQhqIgogBiABEJgSIAYgBxDJNCAKIAYQ9xMLIARBqAJqQZas2LABNgIAIARClqzYsOHChYsWNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIAJBCGooAgA2AgAgBCACKQIANwOYASAEQfQBaiIBIARBmAFqIgIQ8xggAiAEQYACaiIGIAEQ+iMgBEGIAmoiByAEQSxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAYQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogBiAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAkgARCLDCAEQaADaiQADAELDBsLIAkQ7CkhASAAQcScgwE2AgggACABNgIEIABBk4CAgHg2AgAMGAsgCEGgBWohCyABIAIQiyIhCiMAQaACayIHJAAgByAKKAIcIAooAiBBBHYgAxCGBiAHQewBakGXrty4ATYCACAHQpeu3Ljx4sWLFzcC5AEgB0IENwLcASAHQgA3AtQBIAdCgICAgMAANwLMASAHQQA2AsQBIAdBADsBnAIgB0EANgKYAiAHQQA2AoACIAdBADYC9AEgByADKAI8NgLwASAHQegAaiAHQcQBaiIBIAcQ+iMgCigCBCEJIAEgCigCCCIOQQBBBEEMEKAYIAcoAsgBIQUCQAJAIAcoAsQBQQFHBEAgBygCzAEhBgJAIAVFDQAgDkEMbCEEIAYhAiAFIQEDQCAERQ0BIAkoAgAiDCAMKAIAIg1BAWo2AgAgDUEASA0DIAJBBGogCSkCBDcCACACIAw2AgAgAkEMaiECIARBDGshBCAJQQxqIQkgAUEBayIBDQALCyAHIAU2AswBIAcgBjYCxAEgByAGNgLIASAHIAYgDkEMbGo2AtABIAdB8ABqIAdBxAFqIgEQriYgB0EMaiICIAdB6ABqIgVB3AD8CgAAIAUgChCTNiADEOYYIAcoAmwEQCAHKAJoIQMgB0HMAWogB0EUakHUAPwKAAAgByADNgLIASAHQQE2AsQBIAIgASAHQewAahCuFgsgB0HEAWoiASAHQQxqEM0cIAsgARDRDSAHQaACaiQADAILIAUgBygCzAFBzIKDARD9LwsACyALEOwpIQEgAEGcnYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADBcLIAhBoAVqIQYgASACEJkiIQUjAEGgA2siBCQAIARBgAJqIAMoAjwiAUEBakEAQQRBBBCgGCAEKAKEAiECAkAgBCgCgAJBAUcEQCAEQQA2AqABIAQgBCgCiAIiCTYCnAEgBCACNgKYASACBH8gCQUgBEGYAWpBjLCDARCdKCAEKAKcAQtBADYCACAEQaABaiICQQE2AgAgBSgCECEJIAUoAhQhByAEQQhqIAVBGGoQ3DsgBEEYaiACKAIANgIAIAQgB0ECdiIKNgIsIAQgCTYCKCAEQQA2AjggBEEANgIkIARCgICAgBA3AhwgBCAEKQKYATcDECAEIAQpAwg3AzAgBEE4aiEHAkACQAJAAkACQCADKAIAQQFrDgUAAQIeHgMLIARBgAJqIgIgA0EQaiIJIAEQsSYgBCAHNgLIAiAEIAQpAyg3A8ACIARBEGoiByACEJkTIAIgCSABELEmIAcgAhDdEgwDCyADKAIMIQsgAygCCCECIAQgBzYCkAIgBCAKNgKMAiAEIAk2AogCIAQgAjYCgAIgBCACIAtBAnRqIgk2AoQCIARBEGoiByAEQYACahC3ICAHIAIgCRCKFgwCCyAEQRBqIgkgAygCCCICIAIgAygCDEEDdGoiByABEM0TIAkgAiAHEPoVDAELIARBgAJqIgIgA0EQaiIJEMk0IARBEGoiByACIAEQtBEgAiAJEMk0IAcgAhD2EwsgBEGoAmpBmLDgwAE2AgAgBEKYsODAgYOGjBg3AqACIARCBDcCmAIgBEIANwKQAiAEQoCAgIDAADcCiAIgBEEANgKAAiAEQQA7AdgCIARBADYC1AIgBEEANgK8AiAEQQA2ArACIAQgATYCrAIgBEGgAWogBEEYaigCADYCACAEIAQpAxA3A5gBIARB9AFqIgEgBEGYAWoiAhDxGCACIARBgAJqIgkgARD6IyAEQYgCaiIHIARBHGoiCkEIaigCADYCACAEIAopAgA3A4ACIAEgCRCTGSAEQTxqIgogAiABEPojIAIgBRCTNiADEOYYIAQoApwBBEAgBCgCmAEhASAHIARBxABqQdQA/AoAACAEIAE2AoQCIARBATYCgAIgCiAJIARBnAFqEK4WCyAEQdwCaiIBIARBPGoQzRwgBiABEI4MIARBoANqJAAMAQsMGQsgBhDsKSEBIABB9J2DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwWCyAIQaAFaiEJIAEgAhCYIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEIQQgQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgY2ApwBIAQgAjYCmAEgAgR/IAYFIARBmAFqQYywgwEQsyggBCgCnAELQgA3AwAgBEGgAWoiAkEBNgIAIAUoAhAhByAFKAIUIQYgBCAFQRhqENw7IARBKGogAigCADYCACAEQQA2AjQgBEKAgICAEDcCLCAEIAZBA3YiCjYCFCAEIAc2AhAgBEIANwMIIAQgBCkCmAE3AyAgBCAEKQMANwMYIARBIGohAgJAAkACQAJAAkAgAygCAEEBaw4FAAECHR0DCyAEQYACaiIGIANBEGoiByABELEmIAQgBCkDEDcDwAIgBCAEQQhqIgo2AsgCIAIgBhChFCAGIAcgARCxJiAKIAYQ3hIMAwsgAygCDCELIAMoAgghBiAEIAo2AowCIAQgBzYCiAIgBCAGNgKAAiAEIAYgC0ECdGoiBzYChAIgBCAEQQhqIgo2ApACIAIgBEGAAmoQtiAgCiAGIAcQiRYMAgsgBEEIaiIHIAMoAggiBiAGIAMoAgxBA3RqIgogARCiFCAHIAYgChD7FQwBCyAEQYACaiIGIANBEGoiBxDJNCAEQQhqIgogBiABEJgSIAYgBxDJNCAKIAYQ9xMLIARBqAJqQZmy5MgBNgIAIARCmbLkyJGjxowZNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIAJBCGooAgA2AgAgBCACKQIANwOYASAEQfQBaiIBIARBmAFqIgIQ8xggAiAEQYACaiIGIAEQ+iMgBEGIAmoiByAEQSxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAYQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogBiAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAkgARCMDCAEQaADaiQADAELDBgLIAkQ7CkhASAAQcyegwE2AgggACABNgIEIABBk4CAgHg2AgAMFQsgCEGgBWohCyABIAIQjCIhCiMAQaACayIHJAAgByAKKAIcIAooAiBBBHYgAxCGBiAHQewBakGatOjQATYCACAHQpq06NChw4aNGjcC5AEgB0IENwLcASAHQgA3AtQBIAdCgICAgMAANwLMASAHQQA2AsQBIAdBADsBnAIgB0EANgKYAiAHQQA2AoACIAdBADYC9AEgByADKAI8NgLwASAHQegAaiAHQcQBaiIBIAcQ+iMgCigCBCEJIAEgCigCCCIOQQBBBEEMEKAYIAcoAsgBIQUCQAJAIAcoAsQBQQFHBEAgBygCzAEhBgJAIAVFDQAgDkEMbCEEIAYhAiAFIQEDQCAERQ0BIAkoAgAiDCAMKAIAIg1BAWo2AgAgDUEASA0DIAJBBGogCSkCBDcCACACIAw2AgAgAkEMaiECIARBDGshBCAJQQxqIQkgAUEBayIBDQALCyAHIAU2AswBIAcgBjYCxAEgByAGNgLIASAHIAYgDkEMbGo2AtABIAdB8ABqIAdBxAFqIgEQriYgB0EMaiICIAdB6ABqIgVB3AD8CgAAIAUgChCTNiADEOYYIAcoAmwEQCAHKAJoIQMgB0HMAWogB0EUakHUAPwKAAAgByADNgLIASAHQQE2AsQBIAIgASAHQewAahCuFgsgB0HEAWoiASAHQQxqEM0cIAsgARDSDSAHQaACaiQADAILIAUgBygCzAFBzIKDARD9LwsACyALEOwpIQEgAEGkn4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADBQLIAUtAAFFDQoLIAhBhAJqIgUgASACKAIUEQAAEKkvIQEgCEEBNgKoBSAIIAE2AqQFIAhBATYCoAUgASAFNgIAIAhByAJqIAhBoAVqQQAgAygCPBDALCAHQQNHDQwgAygCDCICRQ0NIAMoAggiASACQQN0aiECA0AgCEHIAmpBACABKAIAIAFBBGooAgAQ2BsgAUEIaiIBIAJHDQALDA0LIAEgAhCfIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC/EyABQaACaiQAIAMQ3CkhASAAQaSUgwE2AgggACABNgIEIABBk4CAgHg2AgAMEQsgASACELQiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMYTIAFBoAJqJAAgAxDcKSEBIABB/JSDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwQCyABIAIQsiIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQqBMgAUGgAmokACADENwpIQEgAEHUlYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADA8LIAEgAhCsIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC0EyABQaACaiQAIAMQ3CkhASAAQayWgwE2AgggACABNgIEIABBk4CAgHg2AgAMDgsgASACEJ4iIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACELsTIAFBoAJqJAAgAxDcKSEBIABBtJiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwNCyABIAIQtiIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEECdiADEIoFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQshMgAUGgAmokACADENwpIQEgAEGMmYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAwLIAEgAhCvIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhDCEyABQaACaiQAIAMQ3CkhASAAQeSZgwE2AgggACABNgIEIABBk4CAgHg2AgAMCwsgASACELoiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEKkTIAFBoAJqJAAgAxDcKSEBIABBvJqDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwKCyAIQaAFaiEFIAEgAhDILyELQQAhBiMAQeAAayIBJAAgASALENw7IAEoAgQhBCABKAIAIQIgASADNgJAIAEgAjYCOCABIAIgBEEDdGo2AjwgAUEUaiEHIwBBMGsiBCQAIARBk4CAgHg2AgAgBEEoaiABQThqIgJBCGooAgA2AgAgBCACKQIANwMgIAQgBDYCLCAEQRRqIQ4jAEEwayICJAAgAkEIaiAEQSBqIgkQhygCQAJAAkAgAigCCCIPBEAgAigCDCEQIAJBIGoiDEEEQQBBBEEIEKAYIAIoAiQhCiACKAIgQQFGDQIgAigCKCINIBA2AgQgDSAPNgIAIAJBHGoiEUEBNgIAIAIgDTYCGCACIAo2AhQgAkEoaiAJQQhqKQIANwMAIAIgCSkCADcDICMAQRBrIgkkACAJQQhqIAwQhyggCSgCCCINBEAgAkEUaiEKIAkoAgwhDwNAIAooAggiECAKKAIARgRAIApBARDqLQsgCigCBCAQQQN0aiISIA82AgQgEiANNgIAIAogEEEBajYCCCAJIAwQhyggCSgCBCEPIAkoAgAiDQ0ACwsgCUEQaiQAIA5BCGogESgCADYCACAOIAIpAhQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyACQTBqJAAMAQsgCiACKAIoQYj5gwEQ/S8ACwJAIAQoAgBBk4CAgHhHBEAgByAEKQIANwIAIAdBEGogBEEQaigCADYCACAHQQhqIARBCGopAgA3AgAgDhDDJyAOEOo7DAELIAcgBCkCFDcCBCAHQZOAgIB4NgIAIAdBDGogBEEcaigCADYCAAsgBEEwaiQAIAFBEGoiAiABQSBqKAIANgIAIAEgASkCGDcDCAJAAkACQCABKAIUIgRBk4CAgHhHBEAgASgCJCEDIAUgASkDCDcCCCAFIAM2AhQgBSAENgIEIAVBgICAgHg2AgAgBUEQaiACKAIANgIADAELIAFBMGogAigCADYCACABIAEpAwg3AyggAUEUaiALEJw2IAMQ5hggASgCGAR/IAEoAhQhBiABQcwAaiABQRhqQQAgAygCPBDyFSABQUBrIAFB2ABqKQIANwMAIAEgASkCUDcDOCABKAJMBUEACyEEIAstAAxBIEYEfyALQRBqBUH49oUBQShBrPiFARCfKQALIgkoAgAiAiACKAIAIgdBAWo2AgAgB0EASA0BIAUgASkDODcCICAFIAEpAyg3AgAgBSAGNgIwIAUgBDYCHCAFIAI2AhAgBUEgOgAMIAUgAygCPDYCGCAFIAkoAgQ2AhQgBUEoaiABQUBrKQMANwIAIAVBCGogAUEwaigCADYCAAsgAUHgAGokAAwBCwALIAhB0AJqIgEgCEGsBWopAgA3AwAgCEHYAmoiAiAIQbQFaigCADYCACAIIAgpAqQFNwPIAiAIKAKgBSIDQYCAgIB4Rg0IIAhB0AFqIAhB0AVqKAIANgIAIAhByAFqIAhByAVqKQIANwIAIAhBwAFqIAhBwAVqKQIANwIAIAhBrAFqIAEpAwA3AgAgCEG0AWogAigCADYCACAIIAgpArgFNwK4ASAIIAM2AqABIAggCCkDyAI3AqQBIAhBoAFqEOUpIQEgAEH8n4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAkLIwBBIGsiBSQAIAVBCGogASACKAIQEQAAIAVBEGogBSgCCCIBIAUoAgwoAgwRAAAgBSkDGCEWIAUpAxAhFyAFQSBqJAAgAUEAIBdC55nB0obRrM2zf4UgFkLlkuGP24mtrlKFhFAbIgZFBEBB0PODAUELQdzzgwEQyyQACyAIQaAFaiEJIwBBoAFrIgEkAAJAAkACQCAGLQAMQSFHDQAgBi0ADUEBRg0AIAYoAhgiAiACKAIAIgVBAWo2AgAgBUEASA0BIAEgAjYCUCABIAYpAhw3AlQgAUEANgI4IAFB8ABqIgUgAUHQAGogAUE4aiICENgdIAFBCGoiDyAFIAMQ9BMgBRCCJSABIAZBEGoiEBCwLiABKQMAIRYgASADNgJEIAEgBjYCQCABIBY3AjgjAEFAaiIDJAAgA0GTgICAeDYCCCADQTBqIAJBCGopAgA3AwAgAyACKQIANwMoIAMgA0EIajYCOCADQRxqIQojAEEwayICJAAgAiADQShqIgQQryECQAJAAkAgAigCACIMBEAgAigCBCENIAJBGGoiC0EEQQBBBEEIEKAYIAIoAhwhByACKAIYQQFGDQIgAigCICIOIA02AgQgDiAMNgIAIAJBFGoiEUEBNgIAIAIgDjYCECACIAc2AgwgAkEoaiAEQRBqKAIANgIAIAJBIGogBEEIaikCADcDACACIAQpAgA3AxgjAEEQayIEJAAgBEEIaiALEK8hIAQoAggiDgRAIAJBDGohByAEKAIMIQwDQCAHKAIIIg0gBygCAEYEQCAHQQEQ6i0LIAcoAgQgDUEDdGoiEiAMNgIEIBIgDjYCACAHIA1BAWo2AgggBCALEK8hIAQoAgQhDCAEKAIAIg4NAAsLIARBEGokACAKQQhqIBEoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgAkEwaiQADAELIAcgAigCIEGI+YMBEP0vAAsCQCADKAIIQZOAgIB4RwRAIAUgAykCCDcCACAFQRBqIANBGGooAgA2AgAgBUEIaiADQRBqKQIANwIAIAoQwycgChDqOwwBCyAFIAMpAhw3AgQgBUGTgICAeDYCACAFQQxqIANBJGooAgA2AgALIANBQGskACABQdgAaiICIAFB/ABqKAIANgIAIAEgASkCdDcDUAJAIAEoAnAiA0GTgICAeEcEQCABKAKAASEFIAkgASkDUDcCCCAJIAU2AhQgCSADNgIEIAlBgICAgHg2AgAgCUEQaiACKAIANgIAIA8QgiUMAQsgAUHoAGogAigCADYCACABIAEpA1A3A2AgECgCACICIAIoAgAiA0EBajYCACADQQBIDQIgBigCFCEDIAFBhAFqIAFBHGooAgA2AgAgAUGQAWogAUEoaikCADcDACABQZgBaiABQTBqKQIANwMAIAFB+ABqIAFBEGooAgA2AgAgASABKQIUNwJ8IAEgASkCIDcDiAEgASABKQIINwNwIAFBADYCOCAJIAIgAyABQRRqIAFBOGogAUHgAGoQjhAgAUHwAGoQtwwgASgCiAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUGIAWoQ+x4LIAFBoAFqJAAMAgtB/K2DAUEoQcCygwEQnykLAAsgCEHQAmoiASAIQawFaikCADcDACAIQdgCaiICIAhBtAVqKAIANgIAIAggCCkCpAU3A8gCIAgoAqAFIgNBgICAgHhGBEAgACAIKQPIAjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADAkLIAhB/AFqIAhByAVqKQIANwIAIAhB9AFqIAhBwAVqKQIANwIAIAhB4AFqIAEpAwA3AgAgCEHoAWogAigCADYCACAIIAgpArgFNwLsASAIIAM2AtQBIAggCCkDyAI3AtgBIAhB1AFqENwpIQEgAEHUoIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIAEgBhEEACIFLQAAQSJGDQUgCCAFNgKEAiAIQQE2AqQFIAhBjKiDATYCoAUgCEIBNwKsBSAIQa8DNgLMAiAIIAhByAJqNgKoBSAIIAhBhAJqNgLIAiAIQaAFakGUqIMBEO8sAAsgASAGEQQAIgUtAABBKEYNAyAIIAU2AoQCIAhBATYCpAUgCEHQq4MBNgKgBSAIQgE3AqwFIAhBrwM2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQdirgwEQ7ywACyAIQZgEaiICIAkQyTQjAEEQayIBJAAgAUEEaiACENUJIAEoAgRBAUYEQCAIQcgCaiEDA0AgA0EAIAEoAgggASgCDBDYGyABQQRqIAIQ1QkgASgCBA0ACwsgAUEQaiQACyAIQaAFaiIBIAhByAJqQcwB/AoAACAIQdwEaiICIAEQ6iwgCCACEKABIAAgCCkDADcCBCAAQZOAgIB4NgIAIAhBhAJqIgBBGGoQtwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwwEC0G8k4MBELI7AAsCQAJAAkACQAJAAkAgBSgCBCIFLQAwQQNrDgMBAgMACyAIIAVBMGo2AoQCIAhBATYCpAUgCEH4qoMBNgKgBSAIQgE3AqwFIAhBpwQ2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQYCrgwEQ7ywACyABIAIQnCIhDiMAQbABayIBJAAgAUEEaiICIA4oAhhBvKyDARCZFSABQgA3AxAgAUEANgIYIAFBADsBHiAOQQxqIgUQ2TwhCiABIANBEGo2AlwgASAFNgJYIAEgAUEYajYCbCABIAI2AmggASABQR5qNgJkIAEgAUEQajYCYCABQSBqIRQgAUHYAGohAyMAQTBrIgIkAEHAACEHAkACQAJAAkAgCkEGdiIFIApBP3EiD0EAR2oiBkEDdCIEQcD///8DcUFAayAEIAZBB3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIHRQ0CC0EAIQQgCkHAAE8EQCAFrSEcIAMoAhQhDCADKAIQIRAgAygCDCERIAMoAgghEiADKAIEIQ0gAygCACEVA0AgGUIGhiEdIBlCAXwhGUIAIRdCACEYA0AgFyAdfCIWIBUoAghBAXYiBa1aDSIgES8BACEGQQAhBSAVKAIEIBanQQF0ajIBACIWIA01AhAiGiAWIBpUGyIaIBIpAwAiG1YEQCAaIBt9IRYgG6chCQNAIBEgBiANKAIEIAkgDSgCDGoiE0EDdmotAAAgE0EHcXYiE0EBcWoiBjsBACAFIBNyIQUgCUEBaiEJIBZCAX0iFkIAUg0ACwsgDCgCACIJIBAoAggiE08NBiAQKAIEIAlBAXRqIAY7AQAgDCAMKAIAIAVBAXFqNgIAIBIgGjcDACAFrUIBgyAXhiAYhCEYIBdCAXwiF0LAAFINAAsgBCAHaiAYNwMAIARBCGohBCAZIBxSDQALCyAPBEAgCkFAca0hGyAPrSEcIAMoAhQhDCADKAIQIQ8gAygCDCEQIAMoAgghESADKAIEIQ0gAygCACEDQgAhF0IAIRgDQCAXIBt8IhYgAygCCEEBdiIFrVoNISAQLwEAIQZBACEFIAMoAgQgFqdBAXRqMgEAIhYgDTUCECIZIBYgGVQbIhkgESkDACIaVgRAIBkgGn0hFiAapyEJA0AgECAGIA0oAgQgCSANKAIMaiISQQN2ai0AACASQQdxdiISQQFxaiIGOwEAIAUgEnIhBSAJQQFqIQkgFkIBfSIWQgBSDQALCyAMKAIAIgkgDygCCCISTw0EIA8oAgQgCUEBdGogBjsBACAMIAwoAgAgBUEBcWo2AgAgESAZNwMAIAWtQgGDIBeGIBiEIRggF0IBfCIXIBxSDQALIAQgB2ogGDcAACAEQQhqIQQLIAIgCzYCLCACQoCAgICACDcCJCACIAc2AhwgAiAKQQN2IApBB3FBAEdqIgMgBCADIARJGyIFNgIgIAJBCGogAkEcahDXOyACKAIIIQZBHEEEEK02IgNFDRYgA0KBgICAEDcCACADIAIpAhw3AgggA0EQaiACQSRqKQIANwIAIANBGGogAkEsaigCADYCACACIAU2AhggAiAGNgIUIAIgAzYCECAUIAJBEGpBACAKEPIVIAJBMGokAAwECwwdC0HAACALEKM9AAsgCSASQdj1gwEQwyEACyAJIBNB2PWDARDDIQALIAFBADYCNCABKAIYIgIgASgCDE0EQCABIAI2AgwLIAhBoAVqIQMgASAOQSBqNgJMIAFB2ABqIAFBzABqQcysgwEgAUEgaiIGEMIQIAEoAmAhAiABKAJcIQUCQCABKAJYIgRBk4CAgHhHBEAgAyABKQJkNwIQIAMgAjYCDCADIAU2AgggAyAENgIEIANBKToAACAGEM0mIAFBBGoQnTwMAQsgASACNgJUIAEgBTYCUCABQeAAaiABQQxqKAIANgIAIAEgASkCBDcDWCABQYwBaiICIAFB2ABqIgYQ6RggAUEANgKYASAGIAIgAUGYAWoQ2h0jAEHwAmsiAiQAIAIgBhDPBiACQQxqIgUgAUHQAGoiCkHArYMBKAIAEQQAEM8GIAJB0AFqIgRBuISEAUEIIAJBABCbFAJAQdAAQQgQrTYiCQRAIAlCgYCAgBA3AwAgCUEIaiAEQcgA/AoAACAEQcCEhAFBBiAFQQEQmxRB0ABBCBCtNiIHRQ0fIAdCgYCAgBA3AwAgB0EIaiAEQcgA/AoAAAJ/IwBBMGsiBSQAAkAgBkEMaiIOENk8IgsEfyAFIAtBAWsiCzYCACAOENk8IAtNDQEgBigCECALQQF0ai4BAAVBAAsgBUEwaiQADAELIAUgBhD+OzYCHAwfCyEFIAJBADsBqAIgAkEANgKkAiACQQA2AowCIAJBADYCgAIgAiAFNgL8ASACIAc2AvgBIAIgCTYC9AEgAkEoOgDwASACQgQ3AugBIAJCADcC4AEgAkKAgICAwAA3AtgBIAJBADYC0AEgAkGsAmoiCSAGEKUuIAJB9ABqIgUgBCAJEO8lIAQgCkG4rYMBKAIAEQAAIAJBGGoiCSAFIAQQ7yUgBSAJEM0cIAQgBRDnFgJAIAIoAtABIgRBk4CAgHhHBEAgAyACKQLUATcCCCADQRBqIAJB3AFqKQIANwIAIANBKToAACADIAQ2AgQgBRCFJwwBCyACQdABaiIFIAJB9ABqQcQA/AoAACADIAUQnwkLIAJB8AJqJAAMAQsMHgsgBhCCJSABKAJQIgIgAigCACICQQFrNgIAIAJBAUYEQCAKELsjCyABQSBqEM0mCyABQbABaiQAIAgtAKAFIgFBKUYNAyAIQdcCaiICIAhBsAVqKQAANwAAIAhB0AJqIgMgCEGpBWopAAA3AwAgCEHIAGogCEHABWopAgA3AgAgCEExaiADKQMANwAAIAhBOGogAikAADcAACAIIAgpAKEFIhY3A8gCIAggCCkCuAU3AkAgCCABOgAoIAggFjcAKSAIQShqEPUpIQEgAEGkqIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAYLIAEgAhCaIiEOIwBBsAFrIgEkACABQQRqIgJBACAOKAIYQbysgwEQsxUgAUIANwMQIAFBADYCGCABQQA2AhwgDkEMaiIFENs8IQogASADQRBqNgJcIAEgBTYCWCABIAFBGGo2AmwgASACNgJoIAEgAUEcajYCZCABIAFBEGo2AmAgAUEgaiEUIAFB2ABqIQMjAEEwayICJABBwAAhBwJAAkACQAJAIApBBnYiBSAKQT9xIg9BAEdqIgZBA3QiBEHA////A3FBQGsgBCAGQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiB0UNAgtBACEEIApBwABPBEAgBa0hHCADKAIUIQwgAygCECEQIAMoAgwhESADKAIIIRIgAygCBCENIAMoAgAhFQNAIBlCBoYhHSAZQgF8IRlCACEXQgAhGANAIBcgHXwiFiAVKAIIQQJ2IgWtWg0hIBEoAgAhBkEAIQUgFSgCBCAWp0ECdGo0AgAiFiANNQIQIhogFiAaVBsiGiASKQMAIhtWBEAgGiAbfSEWIBunIQkDQCARIAYgDSgCBCAJIA0oAgxqIhNBA3ZqLQAAIBNBB3F2IhNBAXFqIgY2AgAgBSATciEFIAlBAWohCSAWQgF9IhZCAFINAAsLIAwoAgAiCSAQKAIIIhNPDQYgECgCBCAJQQJ0aiAGNgIAIAwgDCgCACAFQQFxajYCACASIBo3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhdCwABSDQALIAQgB2ogGDcDACAEQQhqIQQgGSAcUg0ACwsgDwRAIApBQHGtIRsgD60hHCADKAIUIQwgAygCECEPIAMoAgwhECADKAIIIREgAygCBCENIAMoAgAhA0IAIRdCACEYA0AgFyAbfCIWIAMoAghBAnYiBa1aDSAgECgCACEGQQAhBSADKAIEIBanQQJ0ajQCACIWIA01AhAiGSAWIBlUGyIZIBEpAwAiGlYEQCAZIBp9IRYgGqchCQNAIBAgBiANKAIEIAkgDSgCDGoiEkEDdmotAAAgEkEHcXYiEkEBcWoiBjYCACAFIBJyIQUgCUEBaiEJIBZCAX0iFkIAUg0ACwsgDCgCACIJIA8oAggiEk8NBCAPKAIEIAlBAnRqIAY2AgAgDCAMKAIAIAVBAXFqNgIAIBEgGTcDACAFrUIBgyAXhiAYhCEYIBdCAXwiFyAcUg0ACyAEIAdqIBg3AAAgBEEIaiEECyACIAs2AiwgAkKAgICAgAg3AiQgAiAHNgIcIAIgCkEDdiAKQQdxQQBHaiIDIAQgAyAESRsiBTYCICACQQhqIAJBHGoQ1zsgAigCCCEGQRxBBBCtNiIDRQ0VIANCgYCAgBA3AgAgAyACKQIcNwIIIANBEGogAkEkaikCADcCACADQRhqIAJBLGooAgA2AgAgAiAFNgIYIAIgBjYCFCACIAM2AhAgFCACQRBqQQAgChDyFSACQTBqJAAMBAsMHAtBwAAgCxCjPQALIAkgEkHY9YMBEMMhAAsgCSATQdj1gwEQwyEACyABQQA2AjQgASgCGCICIAEoAgxNBEAgASACNgIMCyAIQaAFaiEDIAEgDkEgajYCTCABQdgAaiABQcwAakHMrIMBIAFBIGoiBhDCECABKAJgIQIgASgCXCEFAkAgASgCWCIEQZOAgIB4RwRAIAMgASkCZDcCECADIAI2AgwgAyAFNgIIIAMgBDYCBCADQSk6AAAgBhDNJiABQQRqEOk7DAELIAEgAjYCVCABIAU2AlAgAUHgAGogAUEMaigCADYCACABIAEpAgQ3A1ggAUGMAWoiAiABQdgAaiIGEOgYIAFBADYCmAEgBiACIAFBmAFqEL8dIwBB8AJrIgIkACACIAYQzwYgAkEMaiIFIAFB0ABqIgpBwK2DASgCABEEABDPBiACQdABaiIEQbiEhAFBCCACQQAQmxQCQEHQAEEIEK02IgkEQCAJQoGAgIAQNwMAIAlBCGogBEHIAPwKAAAgBEHAhIQBQQYgBUEBEJsUQdAAQQgQrTYiB0UNHiAHQoGAgIAQNwMAIAdBCGogBEHIAPwKAAACfyMAQTBrIgUkAAJAIAZBDGoiDhDbPCILBH8gBSALQQFrIgs2AgAgDhDbPCALTQ0BIAYoAhAgC0ECdGooAgAFQQALIAVBMGokAAwBCyAFIAYQ/Ds2AhwMHgshBSACQQA7AagCIAJBADYCpAIgAkEANgKMAiACQQA2AoACIAIgBTYC/AEgAiAHNgL4ASACIAk2AvQBIAJBKDoA8AEgAkIENwLoASACQgA3AuABIAJCgICAgMAANwLYASACQQA2AtABIAJBrAJqIgkgBhCpLiACQfQAaiIFIAQgCRDvJSAEIApBuK2DASgCABEAACACQRhqIgkgBSAEEO8lIAUgCRDNHCAEIAUQ5xYCQCACKALQASIEQZOAgIB4RwRAIAMgAikC1AE3AgggA0EQaiACQdwBaikCADcCACADQSk6AAAgAyAENgIEIAUQhScMAQsgAkHQAWoiBSACQfQAakHEAPwKAAAgAyAFEJ4JCyACQfACaiQADAELDB0LIAYQgiUgASgCUCICIAIoAgAiAkEBazYCACACQQFGBEAgChC7IwsgAUEgahDNJgsgAUGwAWokACAILQCgBSIBQSlGDQEgCEHXAmoiAiAIQbAFaikAADcAACAIQdACaiIDIAhBqQVqKQAANwMAIAhB8ABqIAhBwAVqKQIANwIAIAhB2QBqIAMpAwA3AAAgCEHgAGogAikAADcAACAIIAgpAKEFIhY3A8gCIAggCCkCuAU3AmggCCABOgBQIAggFjcAUSAIQdAAahD1KSEBIABB/KiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCyABIAIQmyIhCyMAQcABayIBJAAgAUEMaiICIAsoAhhBvKyDARC2FSABQgA3AxggAUEANgIkIAFCADcDKCALQQxqIgUQ2DwhByABIANBEGo2AmwgASAFNgJoIAEgAUEkajYCfCABIAI2AnggASABQShqNgJ0IAEgAUEYajYCcCABQTBqIRUgAUHoAGohAyMAQTBrIgIkAEHAACEJAkACQAJAAkAgB0EGdiIFIAdBP3EiDUEAR2oiBkEDdCIEQcD///8DcUFAayAEIAZBB3EbIgpBwAAQ0TQEQCAKBEAgCkHAABCtNiIJRQ0CC0EAIQQgB0HAAE8EQCAFrSEdIAMoAhQhDiADKAIQIQ8gAygCDCEQIAMoAgghESADKAIEIQwgAygCACESA0AgGkIGhiEeIBpCAXwhGkIAIRdCACEYA0AgFyAefCIWIBIoAghBA3YiBa1aDSAgECkDACEZQQAhBSASKAIEIBanQQN0aikDACIWIAw1AhAiGyAWIBtUGyIbIBEpAwAiHFYEQCAbIBx9IRYgHKchBgNAIBAgGSAMKAIEIAYgDCgCDGoiFEEDdmotAAAgFEEHcXYiFEEBca18Ihk3AwAgBSAUciEFIAZBAWohBiAWQgF9IhZCAFINAAsLIA4oAgAiBiAPKAIIIhRPDQYgDygCBCAGQQN0aiAZNwMAIA4gDigCACAFQQFxajYCACARIBs3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhdCwABSDQALIAQgCWogGDcDACAEQQhqIQQgGiAdUg0ACwsgDQRAIAdBQHGtIRwgDa0hHSADKAIUIQ4gAygCECENIAMoAgwhDyADKAIIIRAgAygCBCEMIAMoAgAhA0IAIRdCACEYA0AgFyAcfCIWIAMoAghBA3YiBa1aDR8gDykDACEZQQAhBSADKAIEIBanQQN0aikDACIWIAw1AhAiGiAWIBpUGyIaIBApAwAiG1YEQCAaIBt9IRYgG6chBgNAIA8gGSAMKAIEIAYgDCgCDGoiEUEDdmotAAAgEUEHcXYiEUEBca18Ihk3AwAgBSARciEFIAZBAWohBiAWQgF9IhZCAFINAAsLIA4oAgAiBiANKAIIIhFPDQQgDSgCBCAGQQN0aiAZNwMAIA4gDigCACAFQQFxajYCACAQIBo3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhcgHVINAAsgBCAJaiAYNwAAIARBCGohBAsgAiAKNgIsIAJCgICAgIAINwIkIAIgCTYCHCACIAdBA3YgB0EHcUEAR2oiAyAEIAMgBEkbIgU2AiAgAkEIaiACQRxqENc7IAIoAgghBkEcQQQQrTYiA0UNFCADQoGAgIAQNwIAIAMgAikCHDcCCCADQRBqIAJBJGopAgA3AgAgA0EYaiACQSxqKAIANgIAIAIgBTYCGCACIAY2AhQgAiADNgIQIBUgAkEQakEAIAcQ8hUgAkEwaiQADAQLDBsLQcAAIAoQoz0ACyAGIBFB2PWDARDDIQALIAYgFEHY9YMBEMMhAAsgAUEANgJEIAEoAiQiAiABKAIUTQRAIAEgAjYCFAsgCEGgBWohAyABIAtBIGo2AlwgAUHoAGogAUHcAGpBzKyDASABQTBqIgYQwhAgASgCcCECIAEoAmwhBQJAIAEoAmgiBEGTgICAeEcEQCADIAEpAnQ3AhAgAyACNgIMIAMgBTYCCCADIAQ2AgQgA0EpOgAAIAYQzSYgAUEMahDjPAwBCyABIAI2AmQgASAFNgJgIAFB8ABqIAFBFGooAgA2AgAgASABKQIMNwNoIAFBnAFqIgIgAUHoAGoiBhC9GCABQQA2AqgBIAYgAiABQagBahDWHSMAQfACayICJAAgAiAGEM8GIAJBDGoiBSABQeAAaiIKQcCtgwEoAgARBAAQzwYgAkHQAWoiBEG4hIQBQQggAkEAEJsUAkBB0ABBCBCtNiIJBEAgCUKBgICAEDcDACAJQQhqIARByAD8CgAAIARBwISEAUEGIAVBARCbFEHQAEEIEK02IgdFDR0gB0KBgICAEDcDACAHQQhqIARByAD8CgAAAn8jAEEwayIFJAACQCAGQQxqIg4Q2DwiCwR/IAUgC0EBayILNgIAIA4Q2DwgC00NASAGKAIQIAtBA3RqKAIABUEACyAFQTBqJAAMAQsgBSAGEP07NgIcDB0LIQUgAkEAOwGoAiACQQA2AqQCIAJBADYCjAIgAkEANgKAAiACIAU2AvwBIAIgBzYC+AEgAiAJNgL0ASACQSg6APABIAJCBDcC6AEgAkIANwLgASACQoCAgIDAADcC2AEgAkEANgLQASACQawCaiIJIAYQqC4gAkH0AGoiBSAEIAkQ7yUgBCAKQbitgwEoAgARAAAgAkEYaiIJIAUgBBDvJSAFIAkQzRwgBCAFEOcWAkAgAigC0AEiBEGTgICAeEcEQCADIAIpAtQBNwIIIANBEGogAkHcAWopAgA3AgAgA0EpOgAAIAMgBDYCBCAFEIUnDAELIAJB0AFqIgUgAkH0AGpBxAD8CgAAIAMgBRCgCQsgAkHwAmokAAwBCwwcCyAGEIIlIAEoAmAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAoQuyMLIAFBMGoQzSYLIAFBwAFqJAAgCC0AoAUiAUEpRwRAIAhB1wJqIgIgCEGwBWopAAA3AAAgCEHQAmoiAyAIQakFaikAADcDACAIQZgBaiAIQcAFaikCADcCACAIQYEBaiADKQMANwAAIAhBiAFqIAIpAAA3AAAgCCAIKQChBSIWNwPIAiAIIAgpArgFNwKQASAIIAE6AHggCCAWNwB5IAhB+ABqEPUpIQEgAEHUqYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAULIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAQLIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAMLIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAILAkACQAJAAkACQAJAAkACQAJAIAUoAgQiBS0AAEECaw4IAQIDBAUGBwgACyAIIAU2AoQCIAhBATYCpAUgCEG4p4MBNgKgBSAIQgE3AqwFIAhBpwQ2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQcCngwEQ7ywACyABIAIQxCIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ9BMgAkHcAGoiBiIDIAEQ9z0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQsgAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQngggAkGgAmokACADEOspIQEgAEGsoYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIAEgAhDBIiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxDhEyACQdwAaiIGIgMgARD5PSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNCiADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARCkCCACQaACaiQAIAMQ6ykhASAAQYSigwE2AgggACABNgIEIABBk4CAgHg2AgAMBwsgASACEMAiIQUjAEGgAmsiAiQAIAJBuAFqIgEgBUEMaiADEOITIAJB3ABqIgYiAyABEPE9IAEgAxChGyACQZQCaiIEIAUQzAYgAyABIAQQjBhBxABBBBCtNiIDRQ0JIAMgBUE8ahDDLSACQQE2AsABIAIgAzYCvAEgAkEBNgK4ASACIAYgARD8IiABIAIQzRwgCEGgBWoiAyABEKIIIAJBoAJqJAAgAxDrKSEBIABB3KKDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyABIAIQwyIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ4xMgAkHcAGoiBiIDIAEQ8D0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQggAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQoAggAkGgAmokACADEOspIQEgAEG0o4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAULIAEgAhDCIiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxD1EyACQdwAaiIGIgMgARD3PSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNByADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARCdCCACQaACaiQAIAMQ6ykhASAAQYykgwE2AgggACABNgIEIABBk4CAgHg2AgAMBAsgASACEL8iIQUjAEGgAmsiAiQAIAJBuAFqIgEgBUEMaiADEOQTIAJB3ABqIgYiAyABEPk9IAEgAxChGyACQZQCaiIEIAUQzAYgAyABIAQQjBhBxABBBBCtNiIDRQ0GIAMgBUE8ahDDLSACQQE2AsABIAIgAzYCvAEgAkEBNgK4ASACIAYgARD8IiABIAIQzRwgCEGgBWoiAyABEJ8IIAJBoAJqJAAgAxDrKSEBIABB5KSDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyABIAIQviIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ5RMgAkHcAGoiBiIDIAEQ8T0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQUgAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQowggAkGgAmokACADEOspIQEgAEG8pYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILIAEgAhC9IiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxDmEyACQdwAaiIGIgMgARDwPSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNBCADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARChCCACQaACaiQAIAMQ6ykhASAAQZSmgwE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgACAIKQPIAjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIACyAIQfAGaiQADwtB/K2DAUEoQYCygwEQnykACyACIAQoAogCQfyvgwEQ/S8AC0EEQcQAEKM9AAsgBiABKAIcQaCCgwEQ/S8AC0H8rYMBQShB3K+DARCfKQALQbSugwFBOEHsroMBEJ8pAAsgBiAEKAKAAUH8roMBEP0vAAtB9PmCAUEjQZj6ggEQyyQAC0G4+oIBQSkgBEH4AGpBsIKDAUHk+oIBENUeAAsgBEIANwKEASAEQoGAgIDAADcCfCAEQaj7ggE2AnhBACAEQewAaiAEQSRqIARB+ABqQbD7ggEQrysAC0EEQRwQoz0ACyABIAQoAoABQayvgwEQ/S8ACyACIAFBjK+DARCxOwALIAEgCUGMr4MBELA7AAtBwAAgAhCjPQALIAkgC0Hsr4MBEMMhAAsgBiACQbyvgwEQsTsACyACIAlBvK+DARCwOwALQfD0gwFBKSACQRxqQaz1gwFBnPWDARDVHgALIBanIAVByPWDARDDIQALIAVBAjYCCCAFQZiEhAE2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBUEcajYCKCAFIAU2AiAgBUEEakGohIQBEO8sAAtBCEHQABCjPQALIA0gDEG8tIIBEMMhAAv5gwECJ38BfiMAQYAHayIFJAACQCABKAIIIhAEQCAFIAEoAgQiDygCACISQRhqIhw2AiQgDyAQQQJ0aiEKQQEhBiAPIQsDQAJAIAhBAXEEQCAKIAtHDQEMBAsgBiAKIAtrQQJ2Tw0DIAsgBkECdGohCwsgBSALKAIAQRhqIgQ2AqgBIBwgBBDKCARAIAtBBGohC0EAIQZBASEIDAEFIAVCADcCxAMgBUKBgICAwAA3ArwDIAVBkJaHATYCuAMgBUEkaiAFQagBaiAFQbgDakGYlocBEKMrAAsACwALQQBBAEHwk4cBEMMhAAsgEEECdCEkQQAhCANAIAgiCyAkRwRAIAhBBGohCCALIA9qKAIAIgQoAixFDQEgBCgCQEUNAQsLIAUgAiALICRHcjoAKwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBAiADKAIAIgJB/////wdqIAJBgICAgHhNGw4FAgAFBQEFCyAcLQAAIgJBHWtBAkkgAkEbRnINAgwECyAFIAMoAgQiAjYCLCAFQbgDaiAcIAIQtAEMAgsgAygCBEUNAgJAAkAgHC0AAEEUaw4GAAQBBAABBAsgBSADKAIMIgI2AiwgAygCCCEEIAJBAnRBBGoiAkE8cSILBEAgAiACIAtrQUBrIgJLDQULIAJBwAAQ0TRFDQUCfyACRQRAIAVCwAA3AqQGIAVCwAA3AqwGIAVBpAZqQcAAEOgZIAUoAqwGIQggBSgCsAYMAQsgAkHAABCtNiIIRQ0HIAVBADYCsAYgBSAINgKsBiAFIAI2AqgGIAVBwAA2AqQGQQALIAhqQQA2AAAgBSAFKAKwBkEEajYCsAYgBUGwAWogBUGsBmopAgA3AwAgBSAFKQKkBjcDqAECQCAEQT9xIgJFBEAgBCECDAELIAQgAmtBQGsiAiAESQ0FC0HAACELIAJBwAAQ0TRFDQUgAgRAIAJBwAAQrTYiC0UNBwsgBUHAA2ogBUGwAWopAwA3AwAgBSAFKQOoATcDuAMgBUEANgLUAyAFIAs2AtADIAUgAjYCzAMgBUHAADYCyAMMAgsgBSADKAIMIgI2AiwgAygCCCEEIAJBA3RBCGoiAkE4cSILBEAgAiACIAtrQUBrIgJLDQQLIAJBwAAQ0TRFDQQCfyACRQRAIAVCwAA3AqQGIAVCwAA3AqwGIAVBpAZqQcAAEOgZIAUoAqwGIQggBSgCsAYMAQsgAkHAABCtNiIIRQ0GIAVBADYCsAYgBSAINgKsBiAFIAI2AqgGIAVBwAA2AqQGQQALIAhqQgA3AAAgBSAFKAKwBkEIajYCsAYgBUGwAWogBUGsBmopAgA3AwAgBSAFKQKkBjcDqAECQCAEQT9xIgJFBEAgBCECDAELIAQgAmtBQGsiAiAESQ0EC0HAACELIAJBwAAQ0TRFDQQgAgRAIAJBwAAQrTYiC0UNBgsgBUHAA2ogBUGwAWopAwA3AwAgBSAFKQOoATcDuAMgBUEANgLUAyAFIAs2AtADIAUgAjYCzAMgBUHAADYCyAMMAQsgBSADKAIEIgI2AiwgBUG4A2ogHCACELQBCyAFQThqIAVBwANqKQMANwMAIAVByABqIAVB0ANqKQMANwMAIAUgBSkDuAM3AzAgBSAFKQPIAzcDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgHC0AACICQRtJDQAgAkEcaw4NAQUHAQYCAwAAAAAHBAcLIAVBADYCWCAFQoCAgIDAADcCUAwMCyAFQQA2AsgDIAVBATYCvAMgBUG8kocBNgK4AyAFQgQ3AsADIAVBuANqQYCUhwEQ7ywACyAFIBJBHGooAgQ2AsgDIAVBADYCxAMgBSABNgK4AyAFIAVBLGo2AsADIAUgBUErajYCvAMjAEEgayICJAAgAkEUaiAFQbgDaiIIKAIQIgQgCCgCDGsiBkEAIAQgBk8bQQBBBEHMARCgGCACKAIYIQYgAigCFEEBRg0YIAJBEGoiG0EANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIHJAAgCCgCECIEIAgoAgxrIgZBACAEIAZPGyIGIAJBCGoiBCgCACAEKAIIIglrSwRAIAQgCSAGQQRBzAEQ3iggBCgCCCEJCyAFQdAAaiEWIAcgBCgCBDYCDCAHIAk2AgggByAEQQhqNgIEIwBB8AFrIgQkACAHQQRqIgkoAgQhBiAJKAIAIAgoAgwiDCAIKAIQIhNJBH8gCCgCCCEaIAgoAgQhHSAGIBNqIAxrIAkoAgggBkHMAWxqIRQgCCgCACEYA0AgBCAMNgLQASAYKAIIIQggBCAYKAIEIgY2AgQgBCAGIAhBAnRqNgIIIAQgBEHQAWo2AgwjAEEgayIIJAAgCEEUaiAEQQRqIgYoAgQgBigCAGtBAnZBAEEEQQQQoBggCCgCGCEJIAgoAhRBAUYEQAwZCyAIQRBqIh9BADYCACAIIAgoAhw2AgwgCCAJNgIIIwBBEGsiDSQAIAYoAgQgBigCAGtBAnYiFSAIQQhqIg4oAgAgDigCCCIJa0sEQCAOIAkgFUEEQQQQ3iggDigCCCEJCyAEQdQBaiEVIA0gDigCBDYCDCANIAk2AgggDSAOQQhqNgIEIA1BBGoiESgCBCEOIBEoAgAhIAJAAkAgBigCACIJIAYoAgQiF0cEQCAGKAIIISEgESgCCCAOQQJ0aiERIBcgCWtBAnYhFwNAICEoAgAiGSAJKAIAIiIoAhQiI08NAiARICIoAhAgGUHEAGxqNgIAIAlBBGohCSARQQRqIREgDkEBaiEOIBdBAWsiFw0ACwsgICAONgIADAELIBkgI0HciYcBEMMhAAsgDUEQaiQAIBVBCGogHygCADYCACAVIAgpAgg3AgAgCEEgaiQAIB0tAAAhCCAaKAIAIQkgBEGFgICAeDYC4AEgBCAJNgLkASAGIBUgCCAEQeABahCjASAUIAZBzAH8CgAAIBRBzAFqIRQgEyAMQQFqIgxHDQALBSAGCzYCACAEQfABaiQAIAdBEGokACAWQQhqIBsoAgA2AgAgFiACKQIINwIAIAJBIGokAAwKCyAFQQA2AlggBUKAgICAwAA3AlAMCQsgBUHsAGoiDSEHIwBBIGsiAiQAIAJBFGogCiAPa0ECdkEAQQRBBBCgGCACKAIYIQggAigCFEEBRg0TIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIJJAAgCiAPIgRrQQJ2IgYgAkEIaiIIKAIAIAgoAggiC2tLBEAgCCALIAZBBEEEEN4oIAgoAgghCwsgCSAIKAIENgIMIAkgCzYCCCAJIAhBCGo2AgQgCUEEaiILKAIEIQYgCygCACEMAkACQCAEIApHBEAgCygCCCAGQQJ0aiELIAogBGtBAnYhCANAIAQoAgAiFCgCFEUNAiALIBQoAhA2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCEEBayIIDQALCyAMIAY2AgAMAQtBAEEAQayJhwEQwyEACyAJQRBqJAAgB0EIaiAOKAIANgIAIAcgAikCCDcCACACQSBqJAAjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRMgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQfgAaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDAJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIhQoAhQiFUEBTQ0CIAsgFCgCEEHEAGo2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCEEBayIIDQALCyAMIAY2AgAMAQtBASAVQbyJhwEQwyEACyAJQRBqJAAgB0EIaiAOKAIANgIAIAcgAikCCDcCACACQSBqJABBmANBBBCtNiICRQ0DIAUoAiwhBCAFQYWAgIB4NgK4AyAFIAQ2ArwDIAVBqAFqIgQgDUEAIAVBuANqIgsQowEgBS0AKyEIIAUoAiwhBiAFQYWAgIB4NgKkBiAFIAY2AqgGIAsgByAIIAVBpAZqEKMBQQAiC0UEQCACIARBzAH8CgAACyACQcwBaiAFQbgDakHMAfwKAAAgBUECNgJYIAUgAjYCVCAFQQI2AlAMCAsjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRIgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQYQBaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDgJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIgwoAhRFDQIgCyAMKAIQNgIAIARBBGohBCALQQRqIQsgBkEBaiEGIAhBAWsiCA0ACwsgDiAGNgIADAELQQBBAEHMiYcBEMMhAAsgCUEQaiQAIAdBCGogDSgCADYCACAHIAIpAgg3AgAgAkEgaiQAIAMoAgBBgoCAgHhGDQUgEigCHCAFKAIsbCEIQYWAgIB4IQsMBgsgEkEcaiECIAMoAgAiC0GBgICAeE8EQCAFQRhqIAIQwzQgBSAFKAIcNgLIAyAFQQA2AsQDIAUgATYCuAMgBSAFQSxqNgLAAyAFIAVBK2o2ArwDIwBBIGsiAiQAIAJBFGogBUG4A2oiCCgCECIEIAgoAgxrIgZBACAEIAZPG0EAQQRBzAEQoBggAigCGCEGIAIoAhRBAUYNFSACQRBqIhtBADYCACACIAIoAhw2AgwgAiAGNgIIIwBBEGsiByQAIAgoAhAiBCAIKAIMayIGQQAgBCAGTxsiBiACQQhqIgQoAgAgBCgCCCIJa0sEQCAEIAkgBkEEQcwBEN4oIAQoAgghCQsgBUHQAGohFiAHIAQoAgQ2AgwgByAJNgIIIAcgBEEIajYCBCMAQfABayIEJAAgB0EEaiIJKAIEIQYgCSgCACAIKAIMIgwgCCgCECITSQR/IAgoAgghGiAIKAIEIR0gBiATaiAMayAJKAIIIAZBzAFsaiEUIAgoAgAhGANAIAQgDDYC0AEgGCgCCCEIIAQgGCgCBCIGNgIEIAQgBiAIQQJ0ajYCCCAEIARB0AFqNgIMIwBBIGsiCCQAIAhBFGogBEEEaiIGKAIEIAYoAgBrQQJ2QQBBBEEEEKAYIAgoAhghCSAIKAIUQQFGBEAMFgsgCEEQaiIfQQA2AgAgCCAIKAIcNgIMIAggCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhUgCEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBVBBEEEEN4oIA4oAgghCQsgBEHUAWohFSANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhEoAgQhDiARKAIAISACQAJAIAYoAgAiCSAGKAIEIhdHBEAgBigCCCEhIBEoAgggDkECdGohESAXIAlrQQJ2IRcDQCAhKAIAIhkgCSgCACIiKAIUIiNPDQIgESAiKAIQIBlBxABsajYCACAJQQRqIQkgEUEEaiERIA5BAWohDiAXQQFrIhcNAAsLICAgDjYCAAwBCyAZICNBnImHARDDIQALIA1BEGokACAVQQhqIB8oAgA2AgAgFSAIKQIINwIAIAhBIGokACAdLQAAIQggGigCACEJIARBhYCAgHg2AuABIAQgCTYC5AEgBiAVIAggBEHgAWoQowEgFCAGQcwB/AoAACAUQcwBaiEUIBMgDEEBaiIMRw0ACwUgBgs2AgAgBEHwAWokACAHQRBqJAAgFkEIaiAbKAIANgIAIBYgAikCCDcCACACQSBqJAAMBwsgAygCDCEEIAtBgICAgHhHBEAgBSAENgIsIAVBEGogAhDDNCADKAIIIQIgAygCBCELIAUgBSgCFCIENgLEAyAFQQA2AsADIAUgATYC0AMgBUEANgLIAyAFIAs2ArgDIAUgAiAEIAIgBEkbNgLMAyAFIAsgAkEEdGo2ArwDIAUgBUErajYC1AMjAEEgayICJAAgAkEUaiAFQbgDaiIEKAIUIAQoAhBrQQBBBEHMARCgGCACKAIYIQYgAigCFEEBRg0VIAJBEGoiGkEANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIHJAAgBCgCFCAEKAIQayIGIAJBCGoiCCgCACAIKAIIIglrSwRAIAggCSAGQQRBzAEQ3iggCCgCCCEJCyAFQdAAaiETIAcgCCgCBDYCDCAHIAk2AgggByAIQQhqNgIEIwBB8AFrIggkACAHQQRqIg0oAgQhCSANKAIAIAQoAhQiDiAEKAIQIgZHBH8gDiAGayEYIAQoAhwhHSAJIA5qIAZrIAQoAgggBmohDCANKAIIIAlBzAFsaiEUIAQoAgAgBkEEdGohFSAEKAIYIRcDQCAIIAw2AtABIBcoAgghBCAIIBcoAgQiBjYCBCAIIAYgBEECdGo2AgggCCAIQdABajYCDCMAQSBrIgQkACAEQRRqIAhBBGoiBigCBCAGKAIAa0ECdkEAQQRBBBCgGCAEKAIYIQkgBCgCFEEBRgRAIAkgBCgCHEG8hYcBEP0vAAsgBEEQaiIfQQA2AgAgBCAEKAIcNgIMIAQgCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhEgBEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBFBBEEEEN4oIA4oAgghCQsgCEHUAWohESANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhYoAgQhDiAWKAIAISACQAJAIAYoAgAiCSAGKAIEIhlHBEAgBigCCCEhIBYoAgggDkECdGohFiAZIAlrQQJ2IRkDQCAhKAIAIhsgCSgCACIiKAIUIiNPDQIgFiAiKAIQIBtBxABsajYCACAJQQRqIQkgFkEEaiEWIA5BAWohDiAZQQFrIhkNAAsLICAgDjYCAAwBCyAbICNB/IiHARDDIQALIA1BEGokACARQQhqIB8oAgA2AgAgESAEKQIINwIAIARBIGokACAdLQAAIQQgCEHgAWoiCSAVEMYQIAYgESAEIAkQowEgFCAGQcwB/AoAACAUQcwBaiEUIAxBAWohDCAVQRBqIRUgGEEBayIYDQALBSAJCzYCACAIQfABaiQAIAdBEGokACATQQhqIBooAgA2AgAgEyACKQIINwIAIAJBIGokAAwHCyAFIAQ2AiwgBSAENgJoIAVBCGogAhDDNCAFIAUoAgw2AsgDIAVBADYCxAMgBSABNgK4AyAFIAVB6ABqNgLAAyAFIAVBK2o2ArwDIwBBIGsiAiQAIAJBFGogBUG4A2oiCCgCECIEIAgoAgxrIgZBACAEIAZPG0EAQQRBzAEQoBggAigCGCEGIAIoAhRBAUYNFCACQRBqIhtBADYCACACIAIoAhw2AgwgAiAGNgIIIwBBEGsiByQAIAgoAhAiBCAIKAIMayIGQQAgBCAGTxsiBiACQQhqIgQoAgAgBCgCCCIJa0sEQCAEIAkgBkEEQcwBEN4oIAQoAgghCQsgBUHQAGohFiAHIAQoAgQ2AgwgByAJNgIIIAcgBEEIajYCBCMAQfABayIEJAAgB0EEaiIJKAIEIQYgCSgCACAIKAIMIgwgCCgCECITSQR/IAgoAgghGiAIKAIEIR0gBiATaiAMayAJKAIIIAZBzAFsaiEUIAgoAgAhGANAIAQgDDYC0AEgGCgCCCEIIAQgGCgCBCIGNgIEIAQgBiAIQQJ0ajYCCCAEIARB0AFqNgIMIwBBIGsiCCQAIAhBFGogBEEEaiIGKAIEIAYoAgBrQQJ2QQBBBEEEEKAYIAgoAhghCSAIKAIUQQFGBEAMFQsgCEEQaiIfQQA2AgAgCCAIKAIcNgIMIAggCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhUgCEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBVBBEEEEN4oIA4oAgghCQsgBEHUAWohFSANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhEoAgQhDiARKAIAISACQAJAIAYoAgAiCSAGKAIEIhdHBEAgBigCCCEhIBEoAgggDkECdGohESAXIAlrQQJ2IRcDQCAhKAIAIhkgCSgCACIiKAIUIiNPDQIgESAiKAIQIBlBxABsajYCACAJQQRqIQkgEUEEaiERIA5BAWohDiAXQQFrIhcNAAsLICAgDjYCAAwBCyAZICNBjImHARDDIQALIA1BEGokACAVQQhqIB8oAgA2AgAgFSAIKQIINwIAIAhBIGokACAdLQAAIQggGigCACEJIARBhYCAgHg2AuABIAQgCTYC5AEgBiAVIAggBEHgAWoQowEgFCAGQcwB/AoAACAUQcwBaiEUIBMgDEEBaiIMRw0ACwUgBgs2AgAgBEHwAWokACAHQRBqJAAgFkEIaiAbKAIANgIAIBYgAikCCDcCACACQSBqJAAMBgsjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRAgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQdwAaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDgJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIgwoAhRFDQIgCyAMKAIQNgIAIARBBGohBCALQQRqIQsgBkEBaiEGIAhBAWsiCA0ACwsgDiAGNgIADAELQQBBAEHsiIcBEMMhAAsgCUEQaiQAIAdBCGogDSgCADYCACAHIAIpAgg3AgAgAkEgaiQAIAMoAgBBgoCAgHhGDQFBhYCAgHghCCAFKAIsIQsMAgtBBEGYAxCjPQALIAMoAgQhCwJAIANBCGoQmhQiBEUNACAEKQIIISsgBCgCBCAEKAIAIQggBEEQQQQQ+DogBUGFgICAeDYCuAMgBSALNgK8AyAIQYaAgIB4Rg0AIAVBuANqENIaIQsMAQtBhYCAgHghCCAFKQLAAyErC0HMAUEEEK02IgIEQCAFICs3ArABIAUgCzYCrAEgBSAINgKoASAFQbgDaiIEIAVB3ABqIAUtACsgBUGoAWoQowEgAiAEQcwB/AoAACAFQQE2AlggBSACNgJUIAVBATYCUAwDC0EEQcwBEKM9AAsgAygCBCEIAkAgA0EIahCaFCIERQRAIBIoAhwgCGwhCAwBCyAEKQIIISsgBCgCBCAEKAIAIQsgBEEQQQQQ+DogBUGFgICAeDYCuAMgBSASKAIcIAhsIgg2ArwDIAtBhoCAgHhGDQAgBUG4A2oQ0hohCAwBC0GFgICAeCELIAUpAsADISsLQcwBQQQQrTYiAkUNASAFICs3ArABIAUgCDYCrAEgBSALNgKoASAFQbgDaiIEIAVBhAFqIAUtACsgBUGoAWoQowEgAiAEQcwB/AoAACAFQQE2AlggBSACNgJUIAVBATYCUAtBACEGAkAgHC0AAEEiRwRAQYCAgIB4IQgMAQsgEEEBaiECIA8hBAJAAkADQCACQQFrIgJBAkkNASAEKAIAIgsoAhRFDQUgBEEEaiIEKAIAIggoAhRFDQYgCygCECAIKAIQEKIRDQALIAMoAgBBhICAgHhHDQEgBUEANgLIAyAFQQE2ArwDIAVByJSHATYCuAMgBUIENwLAAyAFQbgDakHQlIcBEO8sAAsgDygCACICKAIUBEAgBUGkBmogAigCECICQRhqENwGIAIoAighJiACKAIkISQgBUGoAWogAhC+FSAFQbgDaiACQQxqEIALIAIoAiwiCwRAIAsgCygCACIEQQFqNgIAIARBAEgNByACKAIwIScgAigCQCEoIAIoAjwhKSACKAI4ISogAigCNCElCyAFQZAGaiAFQawGaigCADYCACAFQaAGaiAFQcADaigCADYCACAFIAUpAqQGNwOIBiAFIAUpArgDNwOYBiAFKAKoASEIIAUpAqwBISsMAgtBAEEAQZCUhwEQwyEACyMAQSBrIgIkACACQRRqIAogD2tBAnZBAEEEQQQQoBggAigCGCEIIAIoAhRBAUYNCyACQRBqIg1BADYCACACIAIoAhw2AgwgAiAINgIIIwBBEGsiCCQAIAogDyIEa0ECdiIJIAJBCGoiBigCACAGKAIIIgtrSwRAIAYgCyAJQQRBBBDeKCAGKAIIIQsLIAVBkAFqIQcgCCAGKAIENgIMIAggCzYCCCAIIAZBCGo2AgQgCEEEaiILKAIEIQYgCygCACEOAkACQCAEIApHBEAgCygCCCAGQQJ0aiELIAogBGtBAnYhCQNAIAQoAgAiDCgCFEUNAiALIAwoAhA2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCUEBayIJDQALCyAOIAY2AgAMAQtBAEEAQeyJhwEQwyEACyAIQRBqJAAgB0EIaiANKAIANgIAIAcgAikCCDcCACACQSBqJAAgBSgClAEiAiEEIAIgBSgCmAFBAnRqIQkjAEEgayICJAAgAkEUaiAJIARrQQJ2IgdBAEEEQQQQoBggAigCGCEGIAIoAhRBAUYNDiACQRBqIg1BADYCACACIAIoAhw2AgwgAiAGNgIIIAJBCGoiCygCACALKAIIIghrIAdJBEAgCyAIIAdBBEEEEN4oIAsoAgghCAsgBUGcAWohBiALIAQgCUcEfyAHIAhqIAsoAgQgCEECdGohCANAIAggBCgCACgCJDYCACAEQQRqIQQgCEEEaiEIIAdBAWsiBw0ACwUgCAs2AgggBkEIaiANKAIANgIAIAYgAikCCDcCACACQSBqJABBACECIAUoAqQBIgsEQCAFKAKgASEEA0AgBCgCACACaiECIARBBGohBCALQQFrIgsNAAsLIAVBhYCAgHg2ArgDIAUgAjYCvAMgBUGoAWogBUGQAWpBACAFQbgDahCjASAFKAKkASICBEAgBSgCoAEhBCACQQJ0IQtBACECA0AgBUGoAWogAkEAIAQoAgAQ2BsgAkEBaiECIARBBGohBCALQQRrIgsNAAsLIAVBuANqIgIgBUGoAWpBzAH8CgAAIAVBpAZqIgQgAhDZASAFQfQCaiAEEM0cIAVBoAZqIAVBiANqKAIANgIAIAVBkAZqIAVBlANqKAIANgIAIAUgBSkCgAM3A5gGIAUgBSkCjAM3A4gGIAUoAvQCIQggBSkC+AIhKyAFKAKYAyEkIAUoApwDISYgBSgCoAMhCyAFKAKkAyEnIAUoAqgDISUgBSgCrAMhKiAFKAKwAyEpIAUoArQDISggBUGcAWpBBEEEEOAeQQEhBgsgBSAGOgD0AgJAAkACQCAcLQAAIgRBF2sOBAEAAAEACyAFQQA2ArABIAVCgICAgMAANwKoAQwBCyAFQQA2AswDIAVBADYCwAMgBSAKNgK8AyAFIA82ArgDIAVBqAFqIRUjAEEwayIMJAAgBUG4A2oiBigCDCEOIAYoAhAhCSAGKAIEIQ0gBigCACECIAYoAgghBwJAAkACQAJAAkACQAJAAkADQCAHBEACQCAJRQRAIAcgDkYNASAGIAdBDGoiAjYCCEEAIQkMBgsgBkEANgIQIAkgDiAHa0EMbkkNAwsgBkEANgIIQQAhCQsgAkUgAiANRnJFBEBBASEJIAZBATYCECAGIAJBBGoiBDYCACAGIAIoAgAiAigCBCIHNgIIIAYgByACKAIIQQxsaiIONgIMIAQhAgwBCwsgBigCFCICRQ0DAkAgBigCHCINRQRAQQAgAkEMaiACIAYoAhhGIgcbIQRBACACIAcbIQcMAQtBACEEIAZBADYCHEEAIQcgDSAGKAIYIAJrQQxuTw0AIAIgDUEMbGoiB0EMaiEECyAGIAQ2AhRBACECDAELIAYgByAJQQxsaiIHQQxqIgI2AghBACEJCyAHRQ0BCyAHKAIAIgQgBCgCACINQQFqNgIAIA1BAEgNAiAHKAIIIRAgBygCBCEHIAxBEGoiDUEDIAIEfyAOIAJrQQxuIgIgCWsiCUEAIAIgCU8bBUEACyAGKAIUIgIEfyAGKAIYIAJrQQxuIgIgBigCHGsiCUEAIAIgCU8bBUEAC2oiAiACQQNNG0EBakEAQQRBDBCgGCAMKAIUIQkgDCgCEEEBRg0DIAwoAhgiAiAQNgIIIAIgBzYCBCACIAQ2AgAgDEEMaiIYQQE2AgAgDCACNgIIIAwgCTYCBCAMQShqIAZBGGopAgA3AwAgDEEgaiAGQRBqKQIANwMAIAxBGGogBkEIaikCADcDACAMIAYpAgA3AxAgDEEEaiEQIA0oAhwhFCANKAIUIQIgDSgCGCEWIA0oAgwhESANKAIQIQ4gDSgCACEHIA0oAgghBiANKAIEIRcCQANAAkACQAJAIAYEQAJAIA5FBEAgBiARRg0BIA0gBkEMaiIJNgIIQQAhDiACIQQMBQsgDUEANgIQIA4gESAGa0EMbkkNAgsgDUEANgIIQQAhDgsgB0UgByAXRnJFBEBBASEOIA1BATYCECANIAdBBGoiBDYCACANIAcoAgAiCSgCBCIGNgIIIA0gBiAJKAIIQQxsaiIRNgIMIAQhBwwECyACRQ0EAkAgFEUEQEEAIAJBDGogAiAWRiIGGyEEQQAgAiAGGyEGDAELQQAhBCANQQA2AhxBACEGIBQgFiACa0EMbk8NACACIBRBDGxqIgZBDGohBAsgDSAENgIUQQAhFEEAIQkMAQsgDSAGIA5BDGxqIgZBDGoiCTYCCEEAIQ4gAiEECyAGRQ0CCyAGKAIAIhMgEygCACICQQFqNgIAIAJBAE4EQCAGKAIIIRkgBigCBCEbIBAoAggiBiAQKAIARgRAQQEhAiAJBEAgESAJa0EMbiICIA5rIhpBACACIBpPG0EBaiECCyAQIAYgBAR/IBYgBGtBDG4iGiAUayIdQQAgGiAdTxsFQQALIAJqQQRBDBDeKAsgECgCBCAGQQxsaiICIBk2AgggAiAbNgIEIAIgEzYCACAQIAZBAWo2AgggBCECIAkhBgwBCwsACyAVQQhqIBgoAgA2AgAgFSAMKQIENwIADAELIBVBADYCCCAVQoCAgIDAADcCAAsgDEEwaiQADAILAAsgCSAMKAIYQdiLhwEQ/S8ACyAcLQAAIQQLQYAcIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBEH/AXFBAWsOKAABAgMLBAUGBwgJCgsDCwMLCwwNDg8QDQ8QERITFBIVFhoDCxcYERkgC0GBHCECDB8LQYIcIQIMHgtBgxwhAgwdC0GEHCECDBwLQYIcIQIMGwtBgxwhAgwaC0GEHCECDBkLQYUcIQIMGAtBgxwhAgwXC0GEHCECDBYLQYUcIQIMFQtBhRwhAgwUCyASLQAZQQJ0QdyXhwFqKAIAIQIMEwtBhhwhAgwSC0GHHCECDBELQYgcIQIMEAtBiRwhAgwPC0GGHCECDA4LIAVBADYCyAMgBUEBNgK8AyAFQbyShwE2ArgDIAVCBDcCwAMgBUG4A2pBuJOHARDvLAALQYocIQIMDAtBiBwhAgwLC0GLHCECDAoLQYwcQY0cIBItABkbIQIMCQtBiRwhAgwIC0GOHCECDAcLQY8cIQIMBgsgEigCHC0AAEECayICQf8BcUEISQ0EQcSQhwFBKEHIk4cBEJ8pAAtBBEHMARCjPQALQQBBAEGolocBEMMhAAtBAEEAQbiWhwEQwyELAAsgAkH/AXFBAnRB6JeHAWooAgAhAgtBBEEEEK02IhVFBEAMBwsgFSACNgIAIAUgCjYCvAMgBSAPNgK4AyAFIAVBK2o2AsADIwBBIGsiAiQAIAJBFGogBUG4A2oiBCgCBCAEKAIAa0ECdkEAQQRBCBCgGCACKAIYIQYgAigCFEEBRgRADAgLIAJBEGoiFEEANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIGJAAgBCgCBCAEKAIAa0ECdiINIAJBCGoiBygCACAHKAIIIglrSwRAIAcgCSANQQRBCBDeKCAHKAIIIQkLIAVBhAVqIRIgBiAHKAIENgIMIAYgCTYCCCAGIAdBCGo2AgQjAEEQayIOJAAgBkEEaiINKAIEIQkgDSgCACAEKAIAIgcgBCgCBCIQRwRAIAQoAgghFiANKAIIIAlBA3RqIQwgCSAQIAdrQQJ2IhBqIQkDQCAHKAIAIQQgFi0AACETIwBBEGsiDSQAAkAgDkEIaiIYAn8gBCgCLARAIA1BCGogBEEsaiITENw7IA0oAgwhFyANKAIIIRlBDEEEEK02IgRFDQ0gBCATNgIIIAQgGTYCACAEIBc2AgRB/I+HAQwBC0EBIQRBrJCHAUGUkIcBIBMbCzYCBCAYIAQ2AgAgDUEQaiQADAALIAwgDikDCDcCACAHQQRqIQcgDEEIaiEMIBBBAWsiEA0ACwsgCTYCACAOQRBqJAAgBkEQaiQAIBJBCGogFCgCADYCACASIAIpAgg3AgAgAkEgaiQAAkAgBS0AK0UEQCAFQQA2ApAFDAELIAVBkAVqIAUoAiwiAkEDdiACQQdxQQBHahDSHwsCQAJAAkACQAJAAkAgHC0AACICQRdrDgQCAQECAAsgAkEiRg0CCyMAQSBrIg0kACANQRRqIAogD2tBAnZBAEEEQQgQoBggDSgCGCECIA0oAhRBAUYEQCACIA0oAhxB2IuHARD9LwALIA1BEGoiGUEANgIAIA0gDSgCHDYCDCANIAI2AggjAEEQayIOJAAgCiAPa0ECdiIEIA1BCGoiAigCACACKAIIIgdrSwRAIAIgByAEQQRBCBDeKCACKAIIIQcLIA4gAigCBDYCDCAOIAc2AgggDiACQQhqNgIEIwBBEGsiFCQAIA5BBGoiAigCBCEGIAIoAgAgCiAPRwRAIAIoAgggBkEDdGohCSAGIAogD2tBAnYiEWohBgNAIBRBCGohFiAPKAIAIQpBACETIwBBgAJrIgckAEG4p4cBIQJBASEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKLQAYQQFrDigAAQIDBAUGBwgJCgsfHh8eHx8MDQ4PEA0PEBESExQSFR0WFxgZGhEbIAsgB0EIaiEMIwBBEGsiAiQAAkAgCigCCARAIAJBCGogCigCBBDcOyACKAIMIRIgAigCCCEQQQxBBBCtNiIERQ0yIAQgCjYCCCAEIBA2AgAgBCASNgIEIAxBzKCHATYCBCAMIAQ2AgAgAkEQaiQADAELQQBBAEG8oIcBEMMhAAsgBygCDCECIAcoAgghBAwfCyMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNHyAEIAw2AgAgBCAKNgIEIAdBEGoiCkGsmocBNgIEIAogBDYCACACQRBqJAAgBygCFCECIAcoAhAhBAweCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNHiAEIAw2AgAgBCAKNgIEIAdBGGoiCkHEmocBNgIEIAogBDYCACACQRBqJAAgBygCHCECIAcoAhghBAwdCyAHQSBqIAoQ/CMgBygCJCECIAcoAiAhBAwcCyAHQShqIAoQ+yMgBygCLCECIAcoAighBAwbCyMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNGyAEIAw2AgAgBCAKNgIEIAdBMGoiCkGUmocBNgIEIAogBDYCACACQRBqJAAgBygCNCECIAcoAjAhBAwaCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNGiAEIAw2AgAgBCAKNgIEIAdBOGoiCkGcmYcBNgIEIAogBDYCACACQRBqJAAgBygCPCECIAcoAjghBAwZCyMAQRBrIgIkACACQQhqIApBABDnHSACKAIMIQogAigCCCEMQQhBBBCtNiIERQ0ZIAQgDDYCACAEIAo2AgQgB0FAayIKQeyYhwE2AgQgCiAENgIAIAJBEGokACAHKAJEIQIgBygCQCEEDBgLIwBBEGsiAiQAIAJBCGogChDlHSACKAIMIQogAigCCCEMQQhBBBCtNiIERQ0YIAQgDDYCACAEIAo2AgQgB0HIAGoiCkHkmYcBNgIEIAogBDYCACACQRBqJAAgBygCTCECIAcoAkghBAwXCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNFyAEIAw2AgAgBCAKNgIEIAdB0ABqIgpB3JqHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAlQhAiAHKAJQIQQMFgsjAEEQayICJAAgAkEIaiAKQQAQ5x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNFiAEIAw2AgAgBCAKNgIEIAdB2ABqIgpBvJiHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAlwhAiAHKAJYIQQMFQsjAEEQayICJAAgAkEIaiAKEOMdIAIoAgwhCiACKAIIIQxBCEEEEK02IgRFDRUgBCAMNgIAIAQgCjYCBCAHQeAAaiIKQfyZhwE2AgQgCiAENgIAIAJBEGokACAHKAJkIQIgBygCYCEEDBQLIAotABlBAWsOAhIPEQsgB0GAAWohDCMAQRBrIgIkACACQQhqIApBABDnHQJAAkAgCigCCCIEQQJPBEAgAigCDCESIAIoAgghECACIAooAgRBDGoQ3DsgAigCBCEKIAIoAgAhE0EQQQQQrTYiBEUNASAEIBM2AgggBCAQNgIAIAQgCjYCDCAEIBI2AgQgDEHEo4cBNgIEIAwgBDYCACACQRBqJAAMAgtBASAEQbSjhwEQwyEAC0EEQRAQoz0ACyAHKAKEASECIAcoAoABIQQMEgsgB0GIAWohDCMAQRBrIgIkAAJAAkAgCi0AGEEVRgRAIAooAggEQCAKKAIcIRIgAkEIaiAKKAIEENw7IAIoAgwiECASIAooAihsIgpJDQIgAigCCCETQQxBBBCtNiIERQ0mIAQgEjYCCCAEIBAgCms2AgQgBCAKIBNqNgIAIAxBhKGHATYCBCAMIAQ2AgAgAkEQaiQADAMLQQBBAEHkoIcBEMMhAAtBnKGHAUEoQcShhwEQnykACyAKIBBB9KCHARCvOwALIAcoAowBIQIgBygCiAEhBAwRCyAHQZABaiEMIwBBEGsiAiQAIAJBCGogChDjHQJAAkAgCigCCCIEQQJPBEAgAigCDCESIAIoAgghECACIAooAgRBDGoQ3DsgAigCBCEKIAIoAgAhE0EQQQQQrTYiBEUNASAEIBM2AgggBCAQNgIAIAQgCjYCDCAEIBI2AgQgDEHco4cBNgIEIAwgBDYCACACQRBqJAAMAgtBASAEQbSjhwEQwyEAC0EEQRAQoz0ACyAHKAKUASECIAcoApABIQQMEAsgB0EANgL4ASAHQQE2AuwBIAdB7JGHATYC6AEgB0IENwLwASAHQegBakH0kYcBEO8sAAsjAEEQayICJAAgAkEIaiAKQQAQ5x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNDyAEIAw2AgAgBCAKNgIEIAdBmAFqIgpBjKKHATYCBCAKIAQ2AgAgAkEQaiQAIAcoApwBIQIgBygCmAEhBAwOCyAHQQA2AvgBIAdBATYC7AEgB0G8kocBNgLoASAHQgQ3AvABIAdB6AFqQcSShwEQ7ywACyAHQaABaiECAkAgCi0AGEEdRgRAIAooAhwhCkEEQQQQrTYiBEUNHSAEIAo2AgAgAkGAp4cBNgIEIAIgBDYCAAwBC0HIpocBQShBmKeHARCfKQALIAcoAqQBIQIgBygCoAEhBAwMCyMAQRBrIgIkACACQQhqIAoQ4x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNDCAEIAw2AgAgBCAKNgIEIAdBqAFqIgpB9KGHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAqwBIQIgBygCqAEhBAwLC0HQp4cBIQIMCgsgB0EANgL4ASAHQQE2AuwBIAdBoJOHATYC6AEgB0IENwLwASAHQegBakGok4cBEO8sAAsgB0HAAWogChD8IyAHKALEASECIAcoAsABIQQMCAsgB0HIAWogChD7IyAHKALMASECIAcoAsgBIQQMBwsgB0HQAWogChD9IyAHKALUASECIAcoAtABIQQMBgsjAEEQayIMJAAgDEEIaiEYIwBBEGsiEiQAAkACQCAKKAIIIgIEQCAKKAIEIQIjAEEQayIQJAAgEEEIaiACENw7QRAhFwJAIBAoAgwiBCAQKAIIIhpBEBD4LyICSQRAIAQhAkEAIQQMAQsgAiAaaiEXIAQgAmsiE0EfcSEEIBNBBXYhEwsgAiAEcgRAQbSlhwFBOEHspYcBEJ8pAAsgEkEIaiICIBM2AgQgAiAXNgIAIBBBEGokACASKAIMIgQgCigCKCICSQ0BIBIoAgghCiAYIAQgAms2AgQgGCAKIAJBBXRqNgIAIBJBEGokAAwCC0EAIAJBsOSGARDDIQALIAIgBEHA5IYBEK87AAsgDCgCDCEEIAwoAgghCkEIQQQQrTYiAkUNBiACIAo2AgAgAiAENgIEIAdB2AFqIgRBtJmHATYCBCAEIAI2AgAgDEEQaiQAIAcoAtwBIQIgBygC2AEhBAwFC0EEQQQQrTYiAkUEQAwUCyACIAo2AgAgB0HgAWoiBEHsuIcBNgIEIAQgAjYCACAHKALkASECIAcoAuABIQQMBAsgB0H4AGogChD9IyAHKAJ8IQIgBygCeCEEDAMLIAotABlFBEAjAEEQayICJAAgAkEIaiAKENIeIAIoAgwhCiACKAIIIQxBCEEEEK02IgRFDQQgBCAMNgIAIAQgCjYCBCAHQbgBaiIKQeinhwE2AgQgCiAENgIAIAJBEGokACAHKAK8ASECIAcoArgBIQQMAwsgB0GwAWohDCMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCESIAIoAgghECACIApBARDnHQJAAkAgCi0AGEEhRgRAIAIoAgQhEyACKAIAIRhBFEEEEK02IgRFDQEgBCAYNgIMIAQgEDYCACAEIBM2AhAgBCAKQRxqNgIIIAQgEjYCBCAMQZCohwE2AgQgDCAENgIAIAJBEGokAAwCC0HIpocBQShBqKiHARCfKQALQQRBFBCjPQALIAcoArQBIQIgBygCsAEhBAwCCyAHQfAAaiAKEPwjIAcoAnQhAiAHKAJwIQQMAQsgB0HoAGogChD7IyAHKAJsIQIgBygCaCEECyAWIAQ2AgAgFiACNgIEIAdBgAJqJAAMAQtBBEEIEKM9AAsgCSAUKQMINwIAIA9BBGohDyAJQQhqIQkgEUEBayIRDQALCyAGNgIAIBRBEGokACAOQRBqJAAgBUGgBWoiAkEIaiAZKAIANgIAIAIgDSkCCDcCACANQSBqJAAMAgsgBUEANgKkBiAFIAo2ArwDIAUgDzYCuAMgBSAFQaQGajYCwAMjAEEgayICJAAgAkEUaiAFQbgDaiIEKAIEIAQoAgBrQQJ2QQBBBEEIEKAYIAIoAhghBiACKAIUQQFGDQogAkEQaiIUQQA2AgAgAiACKAIcNgIMIAIgBjYCCCMAQRBrIg8kACAEKAIEIAQoAgBrQQJ2IgcgAkEIaiIJKAIAIAkoAggiBmtLBEAgCSAGIAdBBEEIEN4oIAkoAgghBgsgBUGgBWohDiAPIAkoAgQ2AgwgDyAGNgIIIA8gCUEIajYCBCMAQRBrIgokACAPQQRqIgcoAgQhBiAHKAIAIRECQAJAIAQoAgAiCSAEKAIEIhJHBEAgBCgCCCEMIAcoAgggBkEDdGohDSASIAlrQQJ2IRIDQCAMKAIAIhAgCSgCACIHKAIIQQFraiIEIBBJDQIgDCAENgIAIwBBEGsiBCQAIARBCGogBxDmHSAEKAIMIRYgBCgCCCETQQxBBBCtNiIHRQRADBALIAcgEDYCCCAHIBM2AgAgByAWNgIEIApBCGoiEEH8kIcBNgIEIBAgBzYCACAEQRBqJAAgDSAKKQMINwIAIAlBBGohCSANQQhqIQ0gBkEBaiEGIBJBAWsiEg0ACwsgESAGNgIAIApBEGokAAwBC0GMiocBQRpBqIqHARDLJAALIA9BEGokACAOQQhqIBQoAgA2AgAgDiACKQIINwIAIAJBIGokAAwBCyAFQQA2AqQGIAUgCjYCvAMgBSAPNgK4AyAFIAVB9AJqNgLEAyAFIAVBpAZqNgLAAyAFQawFaiEGIwBBQGoiBCQAIARBk4CAgHg2AgggBEEwaiAFQbgDaiICQQhqKQIANwMAIAQgAikCADcDKCAEIARBCGo2AjggBEEcaiEJIwBBMGsiAiQAIAIgBEEoaiIPEIwoAkACQAJAIAIoAgAiDgRAIAIoAgQhDCACQRhqIg1BBEEAQQRBCBCgGCACKAIcIQcgAigCGEEBRg0CIAIoAiAiCiAMNgIEIAogDjYCACACQRRqIhJBATYCACACIAo2AhAgAiAHNgIMIAJBKGogD0EQaigCADYCACACQSBqIA9BCGopAgA3AwAgAiAPKQIANwMYIwBBEGsiDyQAIA9BCGogDRCMKCAPKAIIIgwEQCACQQxqIQcgDygCDCEOA0AgBygCCCIKIAcoAgBGBEAgByAKQQFBBEEIEN4oCyAHKAIEIApBA3RqIhAgDjYCBCAQIAw2AgAgByAKQQFqNgIIIA8gDRCMKCAPKAIEIQ4gDygCACIMDQALCyAPQRBqJAAgCUEIaiASKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAJBMGokAAwBCyAHIAIoAiBB2MOHARD9LwALAkAgBCgCCEGTgICAeEcEQCAGIAQpAgg3AgAgBkEQaiAEQRhqKAIANgIAIAZBCGogBEEQaikCADcCACAJEIEjIAlBBEEIEOAeDAELIAYgBCkCHDcCBCAGQZOAgIB4NgIAIAZBDGogBEEkaigCADYCAAsgBEFAayQAIAUoAqwFQZOAgIB4Rw0BIAVBqAVqIAVBuAVqKAIANgIAIAUgBSkCsAU3A6AFCyAFQfwFaiAcENwGIAVB6AVqIAVB2ABqKAIANgIAIAVB9AVqIAVBmAVqKQIANwIAIAVByAVqIAVBOGopAwA3AwAgBUHYBWogBUHIAGopAwA3AwAgAEHkAGogBUGwAWooAgA2AgAgACAFKQKoATcCXCAFIAUpAlA3A+AFIAUgBSkCkAU3AuwFIAUgBSkDMDcDwAUgBSAFKQNANwPQBSAAQQhqIAFBCGooAgA2AgAgACABKQIANwIAIABBDGogBUHABWpByAD8CgAAIAAgKzcChAEgACAINgKAASAAQgA3AlQgACAoNgLAASAAICk2ArwBIAAgKjYCuAEgACAlNgK0ASAAICc2ArABIAAgCzYCrAEgACAmNgKoASAAICQ2AqQBIAAgBSkDmAY3AowBIABBlAFqIAVBoAZqKAIANgIAIAAgBSkDiAY3ApgBIABBoAFqIAVBkAZqKAIANgIAIABB2JOHATYCyAEgACAVNgLEASAAQfAAaiAFQagFaigCADYCACAAIAUpA6AFNwJoIABB/ABqIAVBjAVqKAIANgIAIAAgBSkChAU3AnQgAxDSGiAFQYAHaiQADwsgBUHIA2ogBUG8BWooAgA2AgAgBUHAA2ogBUG0BWopAgA3AwAgBSAFKQKsBTcDuANB4JSHAUEjIAVBuANqQfiLhwFBhJWHARDVHgALIAVBAjYCvAMgBUG0lYcBNgK4AyAFQgE3AsQDIAVBkBw2AqwBIAUgAzYCqAEgBSAFQagBajYCwAMgBUG4A2pBxJWHARDvLAALQdiKhwFBI0H8iocBEMskAAtBnIuHAUEpIAVBuANqQeiLhwFByIuHARDVHgALQcAAIAIQoz0ACyAIIAIoAhxB2IuHARD9LwALIAkgCCgCHEG8hYcBEP0vAAtBBEEEEKM9AAsgBiACKAIcQdiLhwEQ/S8AC0EEQQwQoz0AC9ooAhF/A34jAEHQB2siAyQAIAECfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkAgAS0AhANBAWsOAxkMAQALIANBkAFqIgUQuy8gA0EYaiIGIAVBARCWKiABKQMAIRQgASgCgAMhBCABQQhqIg4gBkH4APwKAAAgAUEAOgD8AiABIAQ2AvgCIAEgFDcDgAEgAUH8AmohDwwBCyABQQhqIQ4gAUH8AmohDwJAIAEtAPwCQQFrDgMPCwIACyABKQOAASEUIAEoAvgCIQQLIAFBiAFqIgYgDkH4APwKAAAgAUEAOgCZAiABIAQ2ApQCIAEgBjYCkAIgASAUNwOAAiABQZkCaiEQIAFBgAJqIREMAQsgAUGAAmohESABQZkCaiEQAkAgAS0AmQJBAWsOBAcJAggACyABKQOAAiEUIAEoApQCIQQgASgCkAIhBgsgAUEBOgCYAiABIAY2AogCIAFBADoAyAIgASAGNgK4AiABIBQ3A6ACIAEgBDYCjAIgASABQYwCaiIENgK8AiABQcgCaiEKIAFBoAJqIRIMAQsgAUGgAmohEiABQcgCaiEKAkAgAS0AyAJBAWsOBAwHAgQACyABKQOgAiEUIAEoArwCIQQgASgCuAIhBgsgASAENgLEAiABIAY2AsACIAEgFDcDqAIgFEIIWgRAIAEgFEEIIAYoAgQiBSAFQQhNG61CCCAGKAIAG30iFUIAIBQgFVobIhU3A7ACIAQoAgAhBSADQQA6AKgBIAMgFDcDmAEgAyAVNwOQASADIAU2AqABIANBEGogA0GQAWoQyiMgAygCECEGIAFBnN7CADYC1AIgASAGNgLQAkGc3sIADAILQQIhBiADQQI2ApQBIANBjO3CADYCkAEgA0IBNwKcASADQTw2AswGIAMgAUGoAmo2AsgGIAMgA0HIBmo2ApgBIANBuARqIANBkAFqEJkOIAMgAygAvQQ2AqAHIAMgA0HABGooAAA2AKMHIAMoArgEIQUgAy0AvAQhB0GAgICAeCEJDBoLIAEoAtACIQYgASgC1AILIQUgA0GQAWogBiACIAUoAgwRAQBBAyADKAKQASIGQQlGDRIaIAMgAykAmQE3A7AGIAMgA0GgAWooAAA2ALcGIAMtAJgBIQcgAygClAEhBSADKAKkASEIIAFB0AJqIgQQvCogBkEIRwRAIAMgAygAtwY2AKcHIAMgAykDsAY3A6AHDBgLIAEgAykDsAY3AO0CIAEgBzoA7AIgASAFNgLoAiABQfQCaiADKAC3BjYAACADIAEoAvACIgU2AsAGIAEpA6gCIAEpA7ACfSIUQoCAgIAQWg0JIAMgFKciBjYCxAYCQCAFIAZPBEAgBEIANwMAIAVBCGshCCAFQQdNDQwgASABKALsAiAIaikAADcD0AIgA0GQAWogBBCKGSADLQCYASEHIAMoApQBIQUgAygCkAEiBkEIRg0BIAMgAykAmQE3A6AHIAMgA0GgAWooAAA2AKcHIAMoAqQBIQgMGAtBAiEGIANBAjYClAEgA0Go78IANgKQASADQgI3ApwBIANBOzYCxAQgA0E7NgK8BCADIANBuARqNgKYASADIANBwAZqNgLABCADIANBxAZqNgK4BCADQcgGaiADQZABahCZDgwWCyABIAc6ANwCIAEgBTYC2AIgASkDqAIiFCAFQQhqIgatIhVUDQsgBSAISw0PIBQgASkDsAIgFXx9IhRCgICAgBBaDQwgCCAUpyIESQ0NIAggASgC8AIiBUsNDiADQZABaiABKALAAiABKALsAiAEaiAIIARrIAFB2AJqEP8ZIAMgAykAmQE3A7gEIAMgA0GgAWooAAA2AL8EIAMoAqQBIQggAy0AmAEhByADKAKUASEFIAMoApABIQYgAygC4AEiCUGAgICAeEYEQCADIAMpA7gENwOgByADIAMoAL8ENgCnBwwXCyADQegGaiADQagBakE4/AoAACADQcgHaiADQewBaigCADYCACADIAMpAuQBNwPAByADIAMpA7gENwOgByADIAMoAL8ENgCnByABKAKwAiETIANBkAFqIAFB6AJqIAQQzRUgA0G4B2ogA0GcAWooAgA2AgAgAyADKQKUATcDsAcgAygCkAEMFAsgASgC5AIhBCABKALgAiEGDBALQbDxwgAQ6CsACyABQaACaiEKIAFB8AJqIQQgAS0A8AJBAWsOAwMAAgELAAsgASgCvAIhBSABKAK4AiEGDBQLIAEoArQCIQUgASgCsAIhBgwUC0GQ8cIAEOgrAAtBuO/CABDoKwALQZztwgAQ6CsAC0Gs7cIAQSsgA0GQAWpB/N/CAEHY7cIAENUeAAsgCCAFQejtwgAQsTsACyADIAY2AtQGQQIhBiADQQI2ApQBIANB6O7CADYCkAEgA0ICNwKcASADQTs2AsQEIANBPDYCvAQgAyABQagCajYCuAQgAyADQbgEajYCmAEgAyADQdQGajYCwAQgA0HIBmohByMAQRBrIgUkACADQZABaiIEKAIMIQkCQAJAAkACQAJAAkACQCAEKAIEDgIAAQILIAkNAUEBIQlBACEEDAILIAkNACAEKAIAIgkoAgQhBCAJKAIAIQkMAQsgByAEEJkODAELIAVBBGogBEEAQQFBARCgGCAFKAIIIQsgBSgCBEEBRg0BIAUoAgwhDCAEBEAgDCAJIAT8CgAACyAHIAQ2AgggByAMNgIEIAcgCzYCAAsgBUEQaiQADAELIAsgBSgCDEHc88IAEP0vAAsMCQtB+O3CAEEvIANBkAFqQfzfwgBBqO7CABDVHgALIAQgCEG47sIAELE7AAsgCCAFQbjuwgAQsDsACyABKALEAigCACEFIANBADoAqAEgAyAUQgh9NwOYASADIBQgFX03A5ABIAMgBTYCoAEgA0EIaiADQZABahDKIyADKAIIIQZBnN7CACEEIAFBnN7CADYC5AIgASAGNgLgAgwBC0G89sIAEOgrAAsgA0GQAWogBiACIAQoAgwRAQAgAygCkAEiBkEJRw0BQQQLIQEgCiABOgAAQQMMEAsgAyADKQCZATcD2AYgAyADQaABaiIFKAAANgDfBiADLQCYASEHIAMoApQBIQQgAygCpAEhCCABQeACahC8KiAGQQhHBEAgAyADKADfBjYApwcgAyADKQPYBjcDoAcgBCEFDAMLIANBxARqIg0gAygA3wY2AAAgAyADKQPYBjcAvQQgAyAHOgC8BCADIAQ2ArgEIANBkAFqIAEoAsACIAMoArwEIgsgAygCwAQiDCABQdgCahD/GSADIAMpAJkBNwPIBiADIAUoAAA2AM8GIAMoAqQBIQggAy0AmAEhByADKAKUASEFIAMoApABIQYgAygC4AEiCUGAgICAeEYEQCADIAMpA8gGNwOgByADIAMoAM8GNgCnByANIAsgDCAEKAIQEQEADAMLIANB6AZqIANBqAFqQTj8CgAAIANByAdqIANB7AFqKAIANgIAIAMgAykC5AE3A8AHIAMgAykDyAY3A6AHIAMgAygAzwY2AKcHIANBxARqIAsgDCAEKAIQEQEAQQALIQ0gAUH0AmogASgC7AIgASgC8AIgASgC6AIoAhARAQAMAwsgAyADKADNBjYCoAcgAyADQdAGaigAADYAowcgAygCyAYhBSADLQDMBiEHCyABQfQCaiABKALsAiABKALwAiABKALoAigCEBEBAAtBgICAgHghCQsgAyADKACnBzYArwUgAyADKQOgBzcDqAUgA0HwBGogA0HoBmpBOPwKAAAgA0HoBGoiBCADQcgHaigCADYCACADQdgEaiILIANBuAdqKAIANgIAIAMgAykDwAc3A+AEIAMgAykDsAc3A9AEIApBAToAACADIAMpA6gFNwOQBiADIAMoAK8FNgCXBiADQdgFaiIMIANB8ARqQTj8CgAAIANB0AVqIgogBCgCADYCACADQcAFaiIEIAsoAgA2AgAgAyADKQPgBDcDyAUgAyADKQPQBDcDuAUgEhCiKSAJQYCAgIB4Rg0EIANByARqIAQoAgA2AgAgAyANNgK8BCADIBM2ArgEIAMgAykDuAU3AsAEIAEoAogCQRBqENIWIAEoAogCIgQgBzoAGCAEIAU2AhQgBCAGNgIQIAQgAykDkAY3ABkgBCAINgIkIARBIGogAygAlwY2AAAgBEEoaiAMQTj8CgAAIAQgCTYCYCAEQewAaiAKKAIANgIAIAQgAykDyAU3AmQCQCABKAKIAiIGLQBwRQRAIAYtAHFFDQELIAFBADoAmAIgASAGNgK4AiABIAMpArgENwLAAiABQQA6APACIAEgASgCjAIiBTYCvAIgAUHIAmogA0HABGopAgA3AgAgAUHQAmogA0HIBGooAgA2AgAgAUGgAmohCiABQfACaiEEDAELQQghBiANRQ0NIANByARqIAMoAsAEIAMoAsQEIA0oAhARAQAMDQsgASAFNgLYAiABIAY2AtQCIAEgASkCwAI3AtwCIAFB7AJqIAFB0AJqKAIANgIAIAFB5AJqIAFByAJqKQIANwIAAkAgBigCYEGAgICAeEcEQCADQfAEaiAGENwLIAMoAvAERQ0DIAEgAykDgAUiFTcDqAIgASADKQP4BCIUNwOgAiABKALgAgRAIBQgAUHcAmo1AgAiFloNAgsgASgC2AIhBSADQQA6AKgBIAMgFTcDmAEgAyAUNwOQASADIAU2AqABIAMgA0GQAWoQyiMgAygCACEGQZzewgAhBSABQZzewgA2ArQCIAEgBjYCsAIMAgsgA0GQAWpBHkEAQQFBARCgGCADKAKUASEFIAMoApABQQFGDQUgAygCmAEhAiADQQA2AugGIAJBFmpBhvHCACkAADcAACACQRBqQYDxwgApAAA3AAAgAkEIakH48MIAKQAANwAAIAJB8PDCACkAADcAACADQR42AvQGIAMgAjYC8AYgAyAFNgLsBgwICyAUIBZ9IhRCgICAgBBaBEAgA0HoBmoQ2yQMCAsgFSAWfSIVQoCAgIAQWgRAIANB6AZqENskDAgLIBWnIgIgASgC6AJLDQUgA0GwB2ogAUHgAmogFKcgAhDSEAwGCyADQZABaiAGIAIgBSgCDBEBACADKAKQASICQQlHDQEgBEEDOgAADAcLIANBCDYC6AYMBQsgA0HIB2oiBSADQZwBaikCADcDACADIAMpApQBNwPAByADKAKkASEGIAFBsAJqELwqIAJBCEcEQCADQfQGaiAFKQMANwIAIAMgAykDwAc3AuwGIAMgBjYC/AYgAyACNgLoBgwFCyADQbgHaiAFKQMANwMAIAMgAykDwAc3A7AHDAMLIAFBgAI7AZgCIAMgAykDkAY3A6AGIAMgAygAlwY2AKcGIAZBCUYNBgwJCyAFIAMoApgBQdzzwgAQ/S8AC0G48MIAQShB4PDCABCfKQALIAMgAzUCuAciFDcD0AQgAyABKQOoAiABKQOgAiIVfSIWNwPgBCAUIBZSBEAgA0EANgKQASADQdAEaiADQeAEaiADQZABakGg8cIAEK4rAAsgA0GQAWoiAiABKALUAiADQbAHaiIFIBUQphICQCADKAKQASIGQQhHDQAgAiABKALUAiAFIAEpA6ACEJ8GIAMoApABIgZBCEcNACADQQg2AugGIANBvAdqIAMoArQHIAMoArgHIAMoArAHKAIQEQEADAELIANB/AZqIANBpAFqKAIANgIAIANB9AZqIANBnAFqKQIANwIAIAMgAykClAE3AuwGIAMgBjYC6AYgA0G8B2ogAygCtAcgAygCuAcgAygCsAcoAhARAQALIAEoAuACIgIEQCABQewCaiABKALkAiABKALoAiACKAIQEQEACyADIAMpAPEGNwPIBiADIANB+AZqKAAANgDPBiADLQDwBiEHIAMoAuwGIQUgAygC/AYhCCADKALoBiEGIARBAToAACAGQQlHDQMLQQQLIQEgECABOgAACyAPQQM6AAAMAwsgAyADKADPBjYApwYgAyADKQPIBjcDoAYgChDFIQsgAUGAAjsBmAILIAMgAygApwY2AM8DIAMgAykDoAY3A8gDIBEQlywCfyAGQQhHBEAgA0HoA2ogAygAzwM2AAAgAyADKQPIAzcA4QMgA0GAgICAeDYCqAQgAyAINgLsAyADIAc6AOADIAMgBTYC3AMgAyAGNgLYA0GAgICAeAwBCyADQdgDaiABQYgBahD+FCADKALcAyEFIAMoAtgDIQYgAygCqAQLIQIgAUGYAWoQ0hYgA0HYAmoiBCADQegDaikDADcDACADIAMpA+ADNwPQAiADQZgCaiIHIANB8ANqQTj8CgAAIAFBAToA/AIgA0GQAmoiASADQbQEaigCADYCACADIAMpAqwENwOIAiACQYGAgIB4Rg0AIANBsANqIgggBCkDADcDACADIAMpA9ACNwOoAyADQfACaiAHQTj8CgAAIANB6AJqIAEoAgA2AgAgAyADKQOIAjcD4AIgDhD2LAJAAkAgAkGAgICAeEYEQCADQcADaiAIKQMANwMAIAMgAykDqAM3A7gDIAYhByAFIQQMAQtBCCEHQegAQQgQrTYiBEUNASAEIAU2AgwgBCAGNgIIIARCgYCAgBA3AwAgBCADKQOoAzcDECAEQRhqIANBsANqKQMANwMAIARBIGogA0HwAmpBOPwKAAAgBCACNgJYIAQgAykD4AI3AlwgBEHkAGogA0HoAmooAgA2AgALIAAgBDYCBCAAIAc2AgAgACADKQO4AzcDCCAAQRBqIANBwANqKQMANwMAQQEMAgtBCEHoABCjPQALIABBCTYCAEEDCzoAhAMgA0HQB2okAAujrwEDM38Jfgd9IwBBoNYCayISJAAgEkEcakEAQYCAAfwLACASQZyAAWpBAEGQwAH8CwACQCAJKAIEIg1FDQAgCSgCACEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCrMACAkACQAJAIAkoAhAgDUYEQAJAIAkoAiAiDUUEQEEAIQwMAQsgCSgCHCEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCsMACIA0gCSgCLEcNAQJAIAkoAjQiDUUEQEEAIQwMAQsgCSgCMCEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCtMACIA0gCSgCQEcNAiAJKAIYIgxBgYABTyAMRXINAyAJKAIUIREgDEECdCEQIBJBHGohDQNAIA0gESgCADoAACANQQFqIQ0gEUEEaiERIBBBBGsiEA0ACwwDCyASQQA2AvjLAiASQazAAmogCUEQaiASQfjLAmpByKTQABCoKwALIBJBADYC+MsCIBJBsMACaiAJQSxqIBJB+MsCakHYpNAAEKgrAAsgEkEANgL4ywIgEkG0wAJqIAlBQGsgEkH4ywJqQeik0AAQqCsACyAJKAJIIg5BgYABTyAORXJFBEAgCSgCRCERIA5BAnQhECASQazAAWohDQNAIA0gESgCADoAACANQQFqIQ0gEUEEaiERIBBBBGsiEA0ACwsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDEGBgAFJBEAgDkGQwABqIg9BkcABTw0BIBJBADYCzMACIBJBADYCwMACIBIgDDYCvMACIBIgDzYCyMACIBIgEkGcgAFqNgLEwAIgEiASQRxqNgK4wAIgD0GEwABJDQ8gEkGggAFqQQRBgMAA/AsAIBJB/MsCaiEQIBIgCikCSDcB+MsCQQAhESAPQYbAAGsiDUEAIA0gD00bIRQgDkEMaiEWIBJB+MsCaiENQQEhEwNAIA0vAQAiDmdBEGshFUEAIQwgDgRAQX8gFUF/c0EPcSIMdCAOakEDdEH4/wNxIAx2IQwLIBFBhMAAciEOIBEgFkYNAyASQZyAAWogDmogDEGAfyAVQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQYbAAHIhDSARIBRGDQQgEkGcgAFqIA1qIA5BgH8gDEEDdGtyOgAAQQEhESATQQFxQQAhEyAQIQ0NAAsgEiAKLwFGIhQ7Af7LAiASIAovAUQiFjsB/MsCIBIgCi8BQiIXOwH6ywIgEiAKLwFAIhg7AfjLAkEAIREgD0GKwABrIg1BACANIA9NGyEbIA9BiMAAayINQQAgDSAPTRshGSASQfjLAmohDUEBIRMDQCANLwEAIgxnQRBrIRVBACEOIAwEQCAMQX8gFUF/c0EPcSIOdGpBA3RB+P8DcSAOdiEOCyARQYjAAHIhDCARIBlGDQUgEkGcgAFqIAxqIA5BgH8gFUEDdGtyOgAAIA0vAQIiDWdBEGshDCANBH8gDUF/IAxBf3NBD3EiDnRqQQN0Qfj/A3EgDnYFQQALIQ4gEUGKwAByIQ0gESAbRg0GIBJBnIABaiANaiAOQYB/IAxBA3RrcjoAAEEBIREgE0EBcUEAIRMgECENDQALIBIgFDsB/ssCIBIgFjsB/MsCIBIgFzsB+ssCIBIgGDsB+MsCQQAhESAPQY7AAGsiDUEAIA0gD00bIRQgD0GMwABrIg1BACANIA9NGyEWIBJB+MsCaiENQQEhEwNAIA0vAQAiDGdBEGshFUEAIQ4gDARAIAxBfyAVQX9zQQ9xIg50akEDdEH4/wNxIA52IQ4LIBFBjMAAciEMIBEgFkYNByASQZyAAWogDGogDkGAfyAVQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQY7AAHIhDSARIBRGDQggEkGcgAFqIA1qIA5BgH8gDEEDdGtyOgAAQQEhESATQQFxQQAhEyAQIQ0NAAsgEiALQQAgC0H/AXFBBEcbOgCcgAECQCAKLQBZIi1BAWtB/wFxQQFNBEAgEkH4ywJqIgwgAEEAIBIQwAkgEkHQwAJqIg4gDEGAAfwKAAAjAEGAAWsiDSQAIA1B+ABqIABBgIAEELkpIA0oAnghDyANKAJ8IREgDUHwAGogAEGAgAQQuSkgDSgCcCEVIA0oAnQhEyANQegAaiAAQYCABBC5KSANKAJoIRQgDSgCbCEWIA1B4ABqIABBgIAEELkpIA0oAmAhFyANKAJkIRggDUHYAGogAEGAgAQQuSkgDSgCWCEbIA0oAlwhGSANQdAAaiAAQYCABBC5KSANKAJQIRogDSgCVCEcIA1ByABqIABBgIAEELkpIA0oAkghHSANKAJMIR4gDUFAayAAQYCABBC5KSANKAJAIR8gDSgCRCEjIA1BOGogAEGAgAQQuSkgDSgCOCEkIA0oAjwhJSANQTBqIABBgIAEELkpIA0oAjAhJiANKAI0IScgDUEoaiAAQYCABBC5KSANKAIoISggDSgCLCEpIA1BIGogAEGAgAQQuSkgDSgCICEqIA0oAiQhKyANQRhqIABBgIAEELkpIA0oAhghICANKAIcISEgDUEQaiAAQYCABBC5KSANKAIQISwgDSgCFCEiIA1BCGogAEGAgAQQuSkgDSgCCCEuIA0oAgwhMCAMQfcBakIANwAAIAxCADcD8AEgDEIANwPoASAMIDA2AuQBIAwgLjYC4AEgDEIANwPYASAMICI2AtQBIAwgLDYC0AEgDEIANwPIASAMICE2AsQBIAwgIDYCwAEgDEIANwO4ASAMICs2ArQBIAwgKjYCsAEgDEIANwOoASAMICk2AqQBIAwgKDYCoAEgDEIANwOYASAMICc2ApQBIAwgJjYCkAEgDEIANwOIASAMICU2AoQBIAwgJDYCgAEgDEIANwN4IAwgIzYCdCAMIB82AnAgDEIANwNoIAwgHjYCZCAMIB02AmAgDEIANwNYIAwgHDYCVCAMIBo2AlAgDEIANwNIIAwgGTYCRCAMIBs2AkAgDEIANwM4IAwgGDYCNCAMIBc2AjAgDEIANwMoIAwgFjYCJCAMIBQ2AiAgDEIANwMYIAwgEzYCFCAMIBU2AhAgDEIANwMIIAwgETYCBCAMIA82AgAgDUGAAWokACASQdDBAmoiDSAMQYAC/AoAACMAQfABayIMJAAgDCAENgIgIAwgBjYCHCAMIAU2AhggDEEANgIUIAwgBDYCECAMIAM2AgwgDEEANgIkIA0gDEEMaiIcIhUgDkEAIAxBJGoiFCAUENwIIAxBtAFqIg8gFSAVEIQ7QQF2EJgTIAxBATYCjAEgDEIBNwKEASANIA8gDkEBIAxBhAFqIhEgFBDcCCAPIBUgFRCEO0EBdhCYEyAMQQI2AowBIAxCgYCAgBA3AoQBIA0gDEHMAWoiFyAOQQIgFCARENwIIA8gFSAcEIQ7QQJ2EJgTIAxBAzYCjAEgDEKBgICAEDcChAEgDSAPIA5BAyARIBQQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAPIAxBDGoQhDtBAnYQmBMgDEEDNgLsASAMQoGAgIAgNwLkASAMQQQ2AlwgDEKBgICAMDcCVCANIAxBnAFqIhggDkEEIAxB5AFqIhYgDEHUAGoiExDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyAMQQU2AlwgDEKBgICAMDcCVCANIBEgDkEFIBMgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyAMQQY2AlwgDEKBgICAMDcCVCANIBggDkEGIBMgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQc2AjggDEKBgICAwAA3AjAgDSATIA5BByAMQTBqIhkgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQg2AuwBIAxCgYCAgPAANwLkASANIAxB7ABqIhsgDkEIIBkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBggDEEMahCEO0EDdhCYEyAMQQc2AkQgDEKBgICA0AA3AjwgDEEJNgLsASAMQoGAgIDwADcC5AEgDSATIA5BCSAMQTxqIhkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBggDEEMahCEO0EDdhCYEyAMQQo2AuwBIAxCgYCAgPAANwLkASANIBsgDkEKIBkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQc2AlAgDEKBgICA4AA3AkggDEELNgLsASAMQoGAgIDwADcC5AEgDSATIA5BCyAMQcgAaiIZIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyARIAxBDGoQhDtBA3YQmBMgDEEMNgLsASAMQoGAgIDwADcC5AEgDSAbIA5BDCAZIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyAYIAxBDGoQhDtBA3YQmBMgDEENNgLsASAMQoGAgIDwADcC5AEgDSATIA5BDSAUIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyAYIAxBDGoQhDtBA3YQmBMgDEEONgLsASAMQoGAgIDwADcC5AEgDSAbIA5BDiAUIBYQ3AggDEHwAWokAAwBCyASQfjLAmoiDSAAQQFBABDACSASQdDAAmogDUGAAfwKAAAjAEGAAWsiDCQAIAxB+ABqEP4nIAwoAnghDyAMKAJ8IREgDEHwAGoQ/icgDCgCcCEOIAwoAnQhFSAMQegAahD+JyAMKAJoIRMgDCgCbCEUIAxB4ABqEP4nIAwoAmAhFiAMKAJkIRcgDEHYAGoQ/icgDCgCWCEYIAwoAlwhGyAMQdAAahD+JyAMKAJQIRkgDCgCVCEaIAxByABqEP4nIAwoAkghHCAMKAJMIR0gDEFAaxD+JyAMKAJAIR4gDCgCRCEfIAxBOGoQ/icgDCgCOCEjIAwoAjwhJCAMQTBqEP4nIAwoAjAhJSAMKAI0ISYgDEEoahD+JyAMKAIoIScgDCgCLCEoIAxBIGoQ/icgDCgCICEpIAwoAiQhKiAMQRhqEP4nIAwoAhghKyAMKAIcISAgDEEQahD+JyAMKAIQISEgDCgCFCEsIAxBCGoQ/icgDCgCCCEiIAwoAgwhLiANQfcBakIANwAAIA1CADcD8AEgDUIANwPoASANIC42AuQBIA0gIjYC4AEgDUIANwPYASANICw2AtQBIA0gITYC0AEgDUIANwPIASANICA2AsQBIA0gKzYCwAEgDUIANwO4ASANICo2ArQBIA0gKTYCsAEgDUIANwOoASANICg2AqQBIA0gJzYCoAEgDUIANwOYASANICY2ApQBIA0gJTYCkAEgDUIANwOIASANICQ2AoQBIA0gIzYCgAEgDUIANwN4IA0gHzYCdCANIB42AnAgDUIANwNoIA0gHTYCZCANIBw2AmAgDUIANwNYIA0gGjYCVCANIBk2AlAgDUIANwNIIA0gGzYCRCANIBg2AkAgDUIANwM4IA0gFzYCNCANIBY2AjAgDUIANwMoIA0gFDYCJCANIBM2AiAgDUIANwMYIA0gFTYCFCANIA42AhAgDUIANwMIIA0gETYCBCANIA82AgAgDEGAAWokACASQdDBAmogDUGAAvwKAAALIBIgBDYC5MMCIBIgBjYC4MMCIBIgBTYC3MMCIBJBADYC2MMCIBIgBDYC1MMCIBIgAzYC0MMCIBJBEGoQ/ScgEigCFCEFIBIoAhAhDAJAIC1BA0kEQCAMIQQgBSEGDAELIBJB0MMCaiIVIQ0jAEHQAWsiAyQAIANByABqIBJBuMACaiIOENgOIAMvAUgiBiADLwFKIgRyRQRAIAMgCi8BQiIEOwFKIAMgCi8BQCIGOwFICyAEIAZyQf//A3FFBEAgA0GIgICAAjYCSEEIIQZBgMAAIQQLIAMvAUwiDyADLwFOIhNyRQRAIAMgCi8BRiITOwFOIAMgCi8BRCIPOwFMCyAPIBNyRQRAIAMgBDsBTiADIAY7AUwLIBJB+MsCaiERIANB0ABqIgRBIBCjFSADQUBrIARBzILOABCYISADKQNAIT9BACEGIARBgICAAUHEntAAEJkVIANBOGogBEHMgs4AEKohIAMpAzghQCAEQYCAgAFBxJ7QABCZFSADQTBqIARBzILOABCqISADKQMwIUEgBEGAgIABQcSe0AAQmRUgA0EoaiAEQcyCzgAQqiEgAykDKCFCIARBgICAAUHEntAAEJkVIANBIGogBEHMgs4AEKohIAMpAyAhQyAEQYCAgAFBxJ7QABCZFSADQRhqIARBzILOABCqISADKQMYIUQgBEGAgIABQcSe0AAQmRUgA0EQaiAEQcyCzgAQqiEgAykDECFFIARBgICAAUHEntAAEJkVIANBCGogBEHMgs4AEKohIAMpAwghRiAEQYCAgAFBxJ7QABCZFSADIARBzILOABCqISADKQMAIUcgA0HYAGogDUEIaikCADcDACADQeAAaiANQRBqKQIANwMAIAMgDjYCbCADIAA2AmggA0GAAjsByAEgAyADKQNINwPAASADQgA3A7gBIAMgPzcDsAEgAyBHNwOoASADIEY3A6ABIAMgRTcDmAEgAyBENwOQASADIEM3A4gBIAMgQjcDgAEgAyBBNwN4IAMgQDcDcCADIA0pAgA3A1ADQCADQdAAaiIOIAZqIg1BIGooAgAhBCANQSRqKAIAIg0EQCANQQF0IQ9BACENA0AgBCANQQJ0QTxxQQRqOwEAIA1BAWohDSAEQQJqIQQgD0ECayIPDQALCyAGQQhqIgZBwABHDQALIBEgDkH8APwKAAAgA0HQAWokACABIQ0gCCgCACEdQQAhFkEAIRsjAEGwAmsiDyQAIA9BMGogFUEQaikCADcDACAPQShqIBVBCGopAgA3AwAgDyAVKQIANwMgIA9BQGsgB0EIaikCADcDACAPIAcpAgA3AzhBgICAgHghF0GAgICAeCEUIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFAsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRcLQYCAgIB4IRgCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRgLIA9BGGpBABCENyAPIA8vARg7AIECIA9BBDoAgAIgESAPQYACahCdDiAVEIQ7IQYgAgRAIA0gAkEEdGohISAKQQRqISwgCSgCAEEBaiEiIAkoAghBBGohLkEBIAooAhh0QRBrIR4gD0GYAmohGSAJKAIwITAgCSgCOCExIAkoAjwhHyAJKAI0ITIgCSgCHCEzIAkoAiQhNCAJKAIoISMgCSgCICE1IA9BOGpBBHIhJCAJKAIMISUgCSgCBCE2IAotAFohJiALQf8BcUEERiEnQQAhAwNAIA9BgAJqIA9BIGogBiANKAIAIgQgBCAGSxsQmBMgD0HYAGoiEyAPQZACaiIoKQIANwMAIA9B0ABqIi8gD0GIAmoiKSkCADcDACAPIA8pAoACNwNIIA9B8ABqIBlBEGoiKikCADcDACAPQegAaiAZQQhqIispAgA3AwAgDyAZKQIANwNgIA9ByABqEIQ7ITcgFRCEOxogD0HgAGoQhDsaIA0oAgQhDiAPQRBqIA0gLBDJEiAPKAIUIiAhGgJAAkACQAJAAkACQCAPKAIQIhwEQCAcQQFrIQQgHEEFTw0BIA9BOGogBEECdGooAgAgIGohGgsgD0HIAGoQhDsgBk0EQCAPQcgAahCEO0UNBSAPQeABaiI4IBMpAwA3AwAgD0HYAWoiOSAvKQMANwMAIA8gDykDSDcD0AECQCAPQdABahCEOyAUSwRAIC4gA0ECdGohEyADIQQDQCAPQYACaiAPQdABaiAUEJgTIA9BoAFqICgpAgA3AwAgD0GYAWogKSkCADcDACAPQYABaiIDICspAgA3AwAgD0GIAWoiFCAqKQIANwMAIA8gDykCgAI3A5ABIA8gGSkCADcDeAJAIA9BkAFqIi8QhDtFDQACQCAnBEAgJg0BIBEgLxC/GgwCCyARIA9BkAFqEL8aDAELIBEgD0GQAWoQwBoLIA9BkAFqEIQ7IS8gOCAUKQMANwMAIDkgAykDADcDACAPIA8pA3g3A9ABQYCAgIB4IRQgBEEBaiIDIDZJBEAgAyAlTw0DIBMoAgAhFCAPQQhqIAQgImotAAAQhDcgD0EEOgCAAiAPIA8vAQg7AIECIBEgD0GAAmoQnQ4LIAYgL2shBiATQQRqIRMgAyEEIA9B0AFqEIQ7IBRLDQALCyAnRQ0EICYNAyARIA9B0AFqEL8aDAULIARBAWogJUGEq9AAEMMhAAsMGwsgBEEEQfin0AAQwyEACyARIA9B0AFqEMAaDAELIBEgD0HQAWoQvxoLIA9B0AFqEIQ7RQ0AIAYgD0HQAWoQhDtrIQQgFCAPQdABahCEO2shFAwBCyAGIQQLIA5BGHZBgAFxIA5BGXZywCAOQf///w9xaiEOAkAgHiAdIDdqIh0gHSAeSxsiBiAaTwRAIA4gBCAEIA5LGyITBEAgDyATNgKIAiAPIBo2AoQCIA9BADoAgAIgESAPQYACahCdDgsgBCATayEGICBFIBxBAUZxDQEgDykDOCE/ICRBCGogD0FAaygCADYCACAkID83AgAgDyAaNgI4DAELAkACQAJAAkAgDkEDSwRAIA5BGU8NHSAOQQJ0QcCp0ABqKAIAIBogBkF/c2oiGkF/IA5BpKnQAGotAAAiIHRBf3NxIi8gDmxqIgYgDmoiEyAGSQ0BIBNBoL8HSw0CIA9BkAFqIhxBAEEm/AsAIBxBJiAGQaTp8wBqIA4gDiAaICB2IgYQogkiEyAESwRAQQAhBiAERQ0GIA9BgAJqIhogD0HgAGoiICAEEJgTIBEgGhC/GiAPQQA2AswBIA9CATcCxAEgD0IANwK8ASAPIBw2ArgBIBogIEEAEJgTIA9BuAFqIgQgGhDEFA0GIA9BADYC0AEgBCAaIA9B0AFqQbSq0AAQhisACyAPQQA6AIsCIA8gBjoAiQIgDyAOOgCIAiAPIC82AoQCIA9BAToAgAIgDyATOgCKAiARIA9BgAJqIgYQnQ4gE0EnTw0DIA9CADcCyAEgD0KAgICAEDcCwAEgDyATNgK8ASAPIA9BkAFqNgK4ASAGIA9B4ABqIBMQmBMgD0G4AWogBhDEFEUNBCAEIBNrIQYMBQsMGwsgBiATQaSq0AAQsTsACyATQaC/B0GkqtAAELA7AAsgD0EANgKQAiAPQQE2AoQCIA9B+KDQADYCgAIgD0IENwKIAiAPQYACakHEqtAAEO8sAAsgD0EANgLQASAPQbgBaiAPQYACaiAPQdABakHUqtAAEIYrAAsCQAJAAkACQCAXQQFrIhcNAEGAgICAeCEXIDUgFkEBaiIWTQ0AIBYgI08NASA0IBZBAnRqKAIAIRcgD0EDOgCAAiAPIBYgM2otAAA6AIECIBEgD0GAAmoQnQ4LIA5FDQIgDS8BDEGAAUkNAiAYQQFrIhgNAkGAgICAeCEYIDIgG0EBaiIbTQ0CIBsgH08NASAxIBtBAnRqKAIAIRggD0EFOgCAAiAPIBsgMGotAAA6AIECIBEgD0GAAmoQnQ4MAgsgFiAjQeSq0AAQwyEACyAbIB9B9KrQABDDIQALIA9BgAJqIA9B4ABqIBMQmBMgD0GgAWogKCkCADcDACAPQZgBaiApKQIANwMAIA9B8AFqIgQgKykCADcDACAPQfgBaiIOICopAgA3AwAgDyAPKQKAAjcDkAEgDyAZKQIANwPoASAPQZABahCEOyAPQTBqIA4pAwA3AwAgD0EoaiAEKQMANwMAIA8gDykD6AE3AyAgHWohHSANQRBqIg0gIUcNAAsLIA9BsAJqJAAMAQsMFQsgEkEIaiASKAKQzAIgEigC5MwCELgpIBIoAgwhBiASKAIIIQQgBQRAIAwgBUEBEPg6CyAEIQNBACEOIwBBIGsiDCQAIAwgBjYCBAJAAkACQAJAAkAgEkH4ywJqIgUoAmwgBkYEQCAFKAJkIhEgBk0NASARIAZBA3RBD2pNDQIgBgRAIAMgBmohFiAFKAJgIhdBIGohDwNAIBEgDkEDdEEIaiIVSQ0FIBEgFWtBB00NBiAOQQFqIQ4gA0EBaiAXIBVBAnRqKgIAIUlBACETQQAhFUEAIRQDQCAPIBRqKgIAIkogSSBKQwAAAECSIEldIhgbIUkgFSATIBgbIRMgFUEBaiEVIBRBBGoiFEEgRw0ACyADIBM6AAAgD0EgaiEPIgMgFkcNAAsLIAxBIGokAAwFCyAMQQA2AghBACAMQQRqIAVB7ABqIAxBCGpBnNPMABCvKwALQazTzABBPkHs08wAEJ8pAAtB/NPMAEHNAEHM1MwAEJ8pAAsgDEEANgIYIAxBATYCDCAMQeDSzAA2AgggDEIENwIQIAxBCGpB3NTMABDvLAALIAxBADYCGCAMQQE2AgwgDEHg0swANgIIIAxCBDcCECAMQQhqQezUzAAQ7ywAC0EAIQ0jAEEgayIDJAAgA0EANgIcIANCgICAgMAANwIUIANBCGogA0EUakGMh84AEJghIAUoAmQhDCAFKAJgIQ8gBSADKQMINwJgIAwEQCAPIAxBAnRBBBD4OgtBACEMA0AgA0EANgIcIANCgICAgCA3AhQgAyADQRRqQYyHzgAQqiEgBSAMaiIRQSRqKAIAIQ8gEUEgaiIRKAIAIQ4gESADKQMANwIAIA8EQCAOIA9BAXRBAhD4OgsgDEEIaiIMQcAARw0ACyADQSBqJAADQCAFIA1qIgNBJGooAgAiDARAIANBIGooAgAgDEEBdEECEPg6CyANQQhqIg1BwABHDQALIAUoAmQiAwRAIAUoAmAgA0ECdEEEEPg6CwsgEkIANwP4ywIgEkH4ywJqIg1BCCASQcfDAmoiLkEIQfTYzgAQ1SwgEiASKQP4ywI3A9DKAiASQYjMAmoiMCASQcjAAmopAgA3AwAgEkGAzAJqIjEgEkHAwAJqKQIANwMAIBIgEikCuMACNwP4ywIgEkHowwJqIhMhDCASQdDDAmoiGyEPIAotAFshEUEAIQUjAEGQCWsiAyQAIANBCGogEUEARyIUQYCAxAAQux4gAygCDCEOIAMoAgghFSADIBRBgICAEBC7HiADKAIEIRQgAygCACEWA0AgA0GQA2ogBWoiF0KBgICAEDcCACAXQQpqQQE6AAAgF0EIakGAgAE7AQAgBUEMaiIFQcABRw0AC0EAIQUDQCADQdAEaiAFaiIXQoGAgIAQNwIAIBdBCmpBAToAACAXQQhqQYCAATsBACAFQQxqIgVBwAFHDQALQQAiBUUEQCADQRBqIANBkANqQcAB/AoAAAsgEkHQygJqIANB0AFqIANB0ARqQcAB/AoAAANAIANBkAZqIAVqQQBBgAH8CwAgBUGAAWoiBUGAA0cNAAsgA0HgBGogD0EQaikCADcDACADQdgEaiAPQQhqKQIANwMAIANB8ARqIA1BCGopAgA3AwAgA0H4BGogDUEQaikCADcDACADIA8pAgA3A9AEIAMgDSkCADcD6AQpAAAhPyARBEAgFSAOEOYSIBYgFBDmEgsgDCADQdAEakEw/AoAACAMQQA2AkAgDCAUNgI8IAwgFjYCOCAMIA42AjQgDCAVNgIwIAxBxABqIANBEGpBgAP8CgAAIAwgPzcCxAMgDEHMA2ogA0GQBmpBgAP8CgAAIAxBgAI7AcwGIANBkAlqJAAgCCgCACEFIBEEQCABIQ8gBSEVQQAhGEEAIRkjAEGwAmsiDiQAIA5BMGogG0EQaikCADcDACAOQShqIBtBCGopAgA3AwAgDiAbKQIANwMgIA5BQGsgB0EIaikCADcDACAOIAcpAgA3AzhBgICAgHghGkGAgICAeCEXIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFwsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRoLQYCAgIB4IRwCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRwLIA5BGGpBABCENyAOIA4vARg7AIECIA5BBDoAgAIgEyAOQYACahC0DiAbEIQ7IREgAgRAIA8gAkEEdGohMiAKQQRqITMgCSgCAEEBaiE0IAkoAghBBGohNUEBIAooAhh0QRBrISMgDkGYAmohHSAJKAIwITYgCSgCOCEvIAkoAjwhJCAJKAI0ITcgCSgCHCE4IAkoAiQhOSAJKAIoISUgCSgCICE6IA5BOGpBBHIhJiAJKAIMIScgCSgCBCE7IAotAFohKCALQf8BcUEERiEpQQAhAwNAIA5BgAJqIA5BIGogESAPKAIAIgwgDCARSxsQmBMgDkHYAGoiFiAOQZACaiIqKQIANwMAIA5B0ABqIiIgDkGIAmoiKykCADcDACAOIA4pAoACNwNIIA5B8ABqIB1BEGoiICkCADcDACAOQegAaiAdQQhqIiEpAgA3AwAgDiAdKQIANwNgIA5ByABqEIQ7ITwgGxCEOxogDkHgAGoQhDsaIA8oAgQhFCAOQRBqIA8gMxDJEiAOKAIUIiwhHgJAAkACQAJAAkACQCAOKAIQIh8EQCAfQQFrIQwgH0EFTw0BIA5BOGogDEECdGooAgAgLGohHgsgDkHIAGoQhDsgEU0EQCAOQcgAahCEO0UNBSAOQeABaiI9IBYpAwA3AwAgDkHYAWoiPiAiKQMANwMAIA4gDikDSDcD0AECQCAOQdABahCEOyAXSwRAIDUgA0ECdGohFiADIQwDQCAOQYACaiAOQdABaiAXEJgTIA5BoAFqICopAgA3AwAgDkGYAWogKykCADcDACAOQYABaiIDICEpAgA3AwAgDkGIAWoiFyAgKQIANwMAIA4gDikCgAI3A5ABIA4gHSkCADcDeAJAIA5BkAFqIiIQhDtFDQACQCApBEAgKA0BIBMgIhDEGgwCCyATIA5BkAFqEMQaDAELIBMgDkGQAWoQxRoLIA5BkAFqEIQ7ISIgPSAXKQMANwMAID4gAykDADcDACAOIA4pA3g3A9ABQYCAgIB4IRcgDEEBaiIDIDtJBEAgAyAnTw0DIBYoAgAhFyAOQQhqIAwgNGotAAAQhDcgDkEEOgCAAiAOIA4vAQg7AIECIBMgDkGAAmoQtA4LIBEgImshESAWQQRqIRYgAyEMIA5B0AFqEIQ7IBdLDQALCyApRQ0EICgNAyATIA5B0AFqEMQaDAULIAxBAWogJ0GEq9AAEMMhAAsMGwsgDEEEQfin0AAQwyEACyATIA5B0AFqEMUaDAELIBMgDkHQAWoQxBoLIA5B0AFqEIQ7RQ0AIBEgDkHQAWoQhDtrIQwgFyAOQdABahCEO2shFwwBCyARIQwLIBRBGHZBgAFxIBRBGXZywCAUQf///w9xaiEUAkAgIyAVIDxqIiIgIiAjSxsiESAeTwRAIBQgDCAMIBRLGyIWBEAgDiAWNgKIAiAOIB42AoQCIA5BADoAgAIgEyAOQYACahC0DgsgDCAWayERICxFIB9BAUZxDQEgDikDOCE/ICZBCGogDkFAaygCADYCACAmID83AgAgDiAeNgI4DAELAkACQAJAAkAgFEEDSwRAIBRBGU8NHSAUQQJ0QcCp0ABqKAIAIB4gEUF/c2oiFkF/IBRBpKnQAGotAAAiH3RBf3NxIiwgFGxqIhEgFGoiFSARSQ0BIBVBoL8HSw0CIA5BkAFqIh5BAEEm/AsAIB5BJiARQaTp8wBqIBQgFCAWIB92IhEQogkiFiAMSwRAQQAhESAMRQ0GIA5BgAJqIhUgDkHgAGoiHyAMEJgTIBMgFRDEGiAOQQA2AswBIA5CATcCxAEgDkIANwK8ASAOIB42ArgBIBUgH0EAEJgTIA5BuAFqIgwgFRDEFA0GIA5BADYC0AEgDCAVIA5B0AFqQbSq0AAQhisACyAOQQA6AIsCIA4gEToAiQIgDiAUOgCIAiAOICw2AoQCIA5BAToAgAIgDiAWOgCKAiATIA5BgAJqIhEQtA4gFkEnTw0DIA5CADcCyAEgDkKAgICAEDcCwAEgDiAWNgK8ASAOIA5BkAFqNgK4ASARIA5B4ABqIBYQmBMgDkG4AWogERDEFEUNBCAMIBZrIREMBQsMGwsgESAVQaSq0AAQsTsACyAVQaC/B0GkqtAAELA7AAsgDkEANgKQAiAOQQE2AoQCIA5B+KDQADYCgAIgDkIENwKIAiAOQYACakHEqtAAEO8sAAsgDkEANgLQASAOQbgBaiAOQYACaiAOQdABakHUqtAAEIYrAAsCQAJAAkACQCAaQQFrIhoNAEGAgICAeCEaIDogGEEBaiIYTQ0AIBggJU8NASA5IBhBAnRqKAIAIRogDkEDOgCAAiAOIBggOGotAAA6AIECIBMgDkGAAmoQtA4LIBRFDQIgDy8BDEGAAUkNAiAcQQFrIhwNAkGAgICAeCEcIDcgGUEBaiIZTQ0CIBkgJE8NASAvIBlBAnRqKAIAIRwgDkEFOgCAAiAOIBkgNmotAAA6AIECIBMgDkGAAmoQtA4MAgsgGCAlQeSq0AAQwyEACyAZICRB9KrQABDDIQALIA5BgAJqIA5B4ABqIBYQmBMgDkGgAWogKikCADcDACAOQZgBaiArKQIANwMAIA5B8AFqIgwgISkCADcDACAOQfgBaiIVICApAgA3AwAgDiAOKQKAAjcDkAEgDiAdKQIANwPoASAOQZABahCEOyAOQTBqIBUpAwA3AwAgDkEoaiAMKQMANwMAIA4gDikD6AE3AyAgImohFSAPQRBqIg8gMkcNAAsLIA5BsAJqJAAMAQsMFQtBACERQQEhAyANIBNBAUEAELUQIA0gE0EAQQAQtRAgDSATQQBBARC1ECASQbjKAmogE0EBQQAQnh8gEkHAygJqIBNBAEEAEJ4fIBJByMoCaiATQQBBARCeHyASQbTHAmoQuCwgEkH0xwJqELgsIBJBtMgCahC4LCASQfTIAmoQuCwgEkG0yQJqELgsIBJB9MkCahC4LCASIBIpA8DKAjcB+MsCIBIoApDEAiIPQYbAAGsiDEEAIAwgD00bIRQgD0GEwABrIgxBACAMIA9NGyEWIBIoAozEAiEVA0AgDS8BACIMZ0EQayETQQAhDiAMBEAgDEF/IBNBf3NBD3EiDnRqQQN0Qfj/A3EgDnYhDgsgEUGEwAByIQwgESAWRg0KIAwgFWogDkGAfyATQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQYbAAHIhDSARIBRGDQsgDSAVaiAOQYB/IAxBA3RrcjoAAEEBIREgA0EAIQMgECENDQALIBIgEikDuMoCNwH4ywJBACERIBIoApDEAiIPQYrAAGsiA0EAIAMgD00bIRQgD0GIwABrIgNBACADIA9NGyEWIBJB+MsCaiENQQEhAyASKAKMxAIhFQNAIA0vAQAiDGdBEGshE0EAIQ4gDARAIAxBfyATQX9zQQ9xIg50akEDdEH4/wNxIA52IQ4LIBFBiMAAciEMIBEgFkYNDCAMIBVqIA5BgH8gE0EDdGtyOgAAIA0vAQIiDWdBEGshDCANBH8gDUF/IAxBf3NBD3EiDnRqQQN0Qfj/A3EgDnYFQQALIQ4gEUGKwAByIQ0gESAURg0NIA0gFWogDkGAfyAMQQN0a3I6AABBASERIANBACEDIBAhDQ0ACyASIBIpA8jKAjcB+MsCQQAhESASKAKQxAIiD0GOwABrIgNBACADIA9NGyEUIA9BjMAAayIDQQAgAyAPTRshFiASQfjLAmohDUEBIQMgEigCjMQCIRUDQCANLwEAIgxnQRBrIRNBACEOIAwEQCAMQX8gE0F/c0EPcSIOdGpBA3RB+P8DcSAOdiEOCyARQYzAAHIhDCARIBZGDQ4gDCAVaiAOQYB/IBNBA3RrcjoAACANLwECIg1nQRBrIQwgDQR/IA1BfyAMQX9zQQ9xIg50akEDdEH4/wNxIA52BUEACyEOIBFBjsAAciENIBEgFEYNDyANIBVqIA5BgH8gDEEDdGtyOgAAQQEhESADQQAhAyAQIQ0NAAsLIBJCADcD+MsCIBJB+MsCaiIRQQggLkEIQfTYzgAQ1SwgEkGIxAJqIgMpAgAhPyADQoCAgIAQNwIAIBJBkMQCaiIDKQIAIUAgA0IANwIAIBIgEikD+MsCNwPwywIgMCBANwMAIDEgPzcDACASKQKAxAIhPyASQgE3AoDEAiASID83A/jLAiMAQZABayIDJAAgCi0AXCEWIANB0ABqIQ1BACEOQQAhFUEAIRMCQAJAAkACQCARKAIQIhBBicAATwRAIBBBicAARg0BIBBBisAATQ0CIBBBi8AARg0DIBEoAgwiEC0AikAhDCAQLQCIQCIPQQhPBEAgD0EHcSAPQQN2QQFrQQ9xIg90Qfj/A3FBA3ZBASAPdHIhFQsgEC0AiUAhDyAMQQhPBEAgDEEHcSAMQQN2QQFrQQ9xIgx0Qfj/A3FBA3ZBASAMdHIhDgsgEC0Ai0AhECAPQQhPBEAgD0EHcSAPQQN2QQFrQQ9xIgx0Qfj/A3FBA3ZBASAMdHIhEwsgDSAQQQhPBH8gEEEHcSAQQQN2QQFrQQ9xIhB0Qfj/A3FBA3ZBASAQdHIFQQALOwEGIA0gEzsBBCANIA47AQIgDSAVOwEADAQLQYjAACAQQbz0zgAQwyEAC0GJwABBicAAQcz0zgAQwyEAC0GKwABBisAAQdz0zgAQwyEAC0GLwABBi8AAQez0zgAQwyEACyADQdgAaiARENgOIAMvAVAiDCADLwFSIg5yRQRAIAMgCi8BSiIOOwFSIAMgCi8BSCIMOwFQCyAMIA5yRQRAIANBiICAgAI2AlBBgMAAIQ5BCCEMCyADLwFUIg8gAy8BViITckUEQCADIAovAU4iEzsBViADIAovAUwiDzsBVAsgDyATckUEQCADIA47AVYgAyAMOwFUCyADLwFYIgwgAy8BWiIOckUEQCADIAovAUIiDjsBWiADIAovAUAiDDsBWAsgDCAOckUEQCADQYiAgIACNgJYQYDAACEOQQghDAsgAy8BXCIPIAMvAV4iE3JFBEAgAyAKLwFGIhM7AV4gAyAKLwFEIg87AVwLIA8gE3JFBEAgAyAOOwFeIAMgDDsBXAsgEkHQygJqIRQgEkHQwwJqIRMgEkHwywJqIANByABqEP4nIAMpA0ghPyADQUBrIBZBAEciEEGAIhCtGSADKAJEIQwgAygCQCEPIANBOGogEEGAIhCtGSADKAI8IQ4gAygCOCEVIANBMGogEEGAIhCtGSADKAI0IRYgAygCMCEXIANBKGogEEGAgAgQrRkgAygCLCEYIAMoAighGyADQSBqIBBBgIAIEK0ZIAMoAiQhGSADKAIgIRogA0EYaiAQQYCACBCtGSADKAIcIRwgAygCGCEdIANBEGogEEGAgAgQrRkgAygCFCEeIAMoAhAhHyADQQhqIBBBgIDUABCtGSADKAIMISMgAygCCCEkIwBBQGoiDSQAAn8gEEUEQCANQQA2AiggDUKAgICAwAA3AiAgDUEIaiANQSBqQYyHzgAQniEgDSgCCCEQIA0oAgwMAQsgDUE4akIANwMAIA1BMGpCADcDACANQShqQgA3AwAgDUIANwMgIA1BFGoiECANQSBqQYDAABCHHCANIBBBzILOABCeISANKAIAIRAgDSgCBAshJiADIBA2AgAgAyAmNgIEIA1BQGskACADQegAaiATQQhqKQIANwMAIANB8ABqIBNBEGopAgA3AwAgA0GAAWogEUEIaikCADcDACADQYgBaiARQRBqKQIANwMAIAMgEykCADcDYCADIBEpAgA3A3gpAAAhQCADKQMAIUEgAykDUCFCIAMpA1ghQyAPIAwQ/SYgFSAOEP0mIBcgFhD9JiAbIBgQ/SYgGiAZEP0mIB0gHBD9JiAfIB4Q/SYgJCAjEP0mIBQgA0HgAGpBMPwKAAAgFEGAAjsBnAEgFCBDNwKUASAUIEI3AowBIBQgQDcChAEgFEEANgKAASAUIEE3AnggFCAjNgJ0IBQgJDYCcCAUIB42AmwgFCAfNgJoIBQgHDYCZCAUIB02AmAgFCAZNgJcIBQgGjYCWCAUIBg2AlQgFCAbNgJQIBQgFjYCTCAUIBc2AkggFCAONgJEIBQgFTYCQCAUIAw2AjwgFCAPNgI4IBQgPzcCMCADQZABaiQAIAotAFwEQCABIQ4gBSEPQQAhG0EAIRcjAEGwAmsiECQAIBBBMGogE0EQaikCADcDACAQQShqIBNBCGopAgA3AwAgECATKQIANwMgIBBBQGsgB0EIaikCADcDACAQIAcpAgA3AzhBgICAgHghGEGAgICAeCEWIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFgsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRgLQYCAgIB4IRkCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRkLIBBBGGpBABCENyAQIBAvARg7AIECIBBBBDoAgAIgFCAQQYACahDVDiATEIQ7IQwgAgRAIA4gAkEEdGohLCAKQQRqISIgCSgCAEEBaiEuIAkoAghBBGohMEEBIAooAhh0QRBrIR4gEEGYAmohGiAJKAIwITEgCSgCOCEyIAkoAjwhHyAJKAI0ITMgCSgCHCE0IAkoAiQhNSAJKAIoISMgCSgCICE2IBBBOGpBBHIhJCAJKAIMISUgCSgCBCEvIAotAFohJiALQf8BcUEERiEnQQAhAwNAIBBBgAJqIBBBIGogDCAOKAIAIg0gDCANSRsQmBMgEEHYAGoiFSAQQZACaiIoKQIANwMAIBBB0ABqIiEgEEGIAmoiKSkCADcDACAQIBApAoACNwNIIBBB8ABqIBpBEGoiKikCADcDACAQQegAaiAaQQhqIispAgA3AwAgECAaKQIANwNgIBBByABqEIQ7ITcgExCEOxogEEHgAGoQhDsaIA4oAgQhESAQQRBqIA4gIhDJEiAQKAIUIiAhHAJAAkACQAJAAkACQCAQKAIQIh0EQCAdQQFrIQ0gHUEFTw0BIBBBOGogDUECdGooAgAgIGohHAsgEEHIAGoQhDsgDE0EQCAQQcgAahCEO0UNBSAQQeABaiI4IBUpAwA3AwAgEEHYAWoiOSAhKQMANwMAIBAgECkDSDcD0AECQCAQQdABahCEOyAWSwRAIDAgA0ECdGohFSADIQ0DQCAQQYACaiAQQdABaiAWEJgTIBBBoAFqICgpAgA3AwAgEEGYAWogKSkCADcDACAQQYABaiIDICspAgA3AwAgEEGIAWoiFiAqKQIANwMAIBAgECkCgAI3A5ABIBAgGikCADcDeAJAIBBBkAFqIiEQhDtFDQACQCAnBEAgJg0BIBQgIRDCGgwCCyAUIBBBkAFqEMIaDAELIBQgEEGQAWoQwxoLIBBBkAFqEIQ7ISEgOCAWKQMANwMAIDkgAykDADcDACAQIBApA3g3A9ABQYCAgIB4IRYgDUEBaiIDIC9JBEAgAyAlTw0DIBUoAgAhFiAQQQhqIA0gLmotAAAQhDcgEEEEOgCAAiAQIBAvAQg7AIECIBQgEEGAAmoQ1Q4LIAwgIWshDCAVQQRqIRUgAyENIBBB0AFqEIQ7IBZLDQALCyAnRQ0EICYNAyAUIBBB0AFqEMIaDAULIA1BAWogJUGEq9AAEMMhAAsMGwsgDUEEQfin0AAQwyEACyAUIBBB0AFqEMMaDAELIBQgEEHQAWoQwhoLIBBB0AFqEIQ7RQ0AIAwgEEHQAWoQhDtrIQ0gFiAQQdABahCEO2shFgwBCyAMIQ0LIBFBGHZBgAFxIBFBGXZywCARQf///w9xaiERAkAgHiAPIDdqIiEgHiAhSRsiDCAcTwRAIBEgDSANIBFLGyIVBEAgECAVNgKIAiAQIBw2AoQCIBBBADoAgAIgFCAQQYACahDVDgsgDSAVayEMICBFIB1BAUZxDQEgECkDOCE/ICRBCGogEEFAaygCADYCACAkID83AgAgECAcNgI4DAELAkACQAJAAkAgEUEDSwRAIBFBGU8NHSARQQJ0QcCp0ABqKAIAIBwgDEF/c2oiFUF/IBFBpKnQAGotAAAiHXRBf3NxIiAgEWxqIgwgEWoiDyAMSQ0BIA9BoL8HSw0CIBBBkAFqIhxBAEEm/AsAIBxBJiAMQaTp8wBqIBEgESAVIB12IgwQogkiFSANSwRAQQAhDCANRQ0GIBBBgAJqIg8gEEHgAGoiHSANEJgTIBQgDxDCGiAQQQA2AswBIBBCATcCxAEgEEIANwK8ASAQIBw2ArgBIA8gHUEAEJgTIBBBuAFqIg0gDxDEFA0GIBBBADYC0AEgDSAPIBBB0AFqQbSq0AAQhisACyAQQQA6AIsCIBAgDDoAiQIgECAROgCIAiAQICA2AoQCIBBBAToAgAIgECAVOgCKAiAUIBBBgAJqIgwQ1Q4gFUEnTw0DIBBCADcCyAEgEEKAgICAEDcCwAEgECAVNgK8ASAQIBBBkAFqNgK4ASAMIBBB4ABqIBUQmBMgEEG4AWogDBDEFEUNBCANIBVrIQwMBQsMGwsgDCAPQaSq0AAQsTsACyAPQaC/B0GkqtAAELA7AAsgEEEANgKQAiAQQQE2AoQCIBBB+KDQADYCgAIgEEIENwKIAiAQQYACakHEqtAAEO8sAAsgEEEANgLQASAQQbgBaiAQQYACaiAQQdABakHUqtAAEIYrAAsCQAJAAkACQCAYQQFrIhgNAEGAgICAeCEYIDYgG0EBaiIbTQ0AIBsgI08NASA1IBtBAnRqKAIAIRggEEEDOgCAAiAQIBsgNGotAAA6AIECIBQgEEGAAmoQ1Q4LIBFFDQIgDi8BDEGAAUkNAiAZQQFrIhkNAkGAgICAeCEZIDMgF0EBaiIXTQ0CIBcgH08NASAyIBdBAnRqKAIAIRkgEEEFOgCAAiAQIBcgMWotAAA6AIECIBQgEEGAAmoQ1Q4MAgsgGyAjQeSq0AAQwyEACyAXIB9B9KrQABDDIQALIBBBgAJqIBBB4ABqIBUQmBMgEEGgAWogKCkCADcDACAQQZgBaiApKQIANwMAIBBB8AFqIg0gKykCADcDACAQQfgBaiIPICopAgA3AwAgECAQKQKAAjcDkAEgECAaKQIANwPoASAQQZABahCEOyAQQTBqIA8pAwA3AwAgEEEoaiANKQMANwMAIBAgECkD6AE3AyAgIWohDyAOQRBqIg4gLEcNAAsLIBBBsAJqJAAMAQsMFQtBACERQQAhDyMAQaDAAGsiDSQAIA1BGGpCADcDACANQRBqQgA3AwAgDUEIakIANwMAIA1CADcDACANQSBqQQBBgMAA/AsAIBQoAnwiAwRAIBQoAnghDCADQQV0IRNBACEDA0AgDEEAQdiEzgAQoi4qAgAhSSAMQQJB6ITOABCiLioCACFMIAxBA0H4hM4AEKIuKgIAIUsgDEEEQYiFzgAQoi4qAgAhSiAMQQVBmIXOABCiLioCACFIIAxBBkGohc4AEKIuKgIAIU0gDEEHQbiFzgAQoi4qAgAiTkMAAIA/kvwFIj8gTvwFIkEgPyBBVBsiPyBNQwAAgEGS/AUiQiA/IEJUGyI/IEj8BSJAID8gQFQbIkMgSvwFIkQgQyBEVBsiP7UhSgJAAkACQAJAIAxBAUHIhc4AEKIuKgIAQwAAwECSIkggS0MAAIBBkiJLXUUgSCBMXUVyIEggSV1FckUgSCBKXXFFBEAgTEMAAMBAkiJIIEtdRSBIIEldRXJFIEggSl1xRQRAIEkgS0MAAMBAkiJIXiBIIEpdcUUEQCBKQwAAwECSIEldRQRAIANBgMAASQRAQQAhDiANQSBqIANqQQA6AAAMCAsgA0GAwABB2IXOABDDIQALIANBgMAASQ0FIANBgMAAQeiFzgAQwyEACyADQYDAAEkNAyADQYDAAEH4hc4AEMMhAAsgA0GAwABJDQEgA0GAwABBiIbOABDDIQALIANBgMAATwRAIANBgMAAQZiGzgAQwyEAC0EBIQ4gDUEgaiADakEBOgAADAMLQQIhDiANQSBqIANqQQI6AAAMAgtBAyEOIA1BIGogA2pBAzoAAAwBCyANQSBqIANqIhBBB0EEID8gQVEbIg46AAAgQyBEWiIVID8gQlFyRSA/IEBScQ0AIBBBBEEFQQYgPyBAURsgFRsiDjoAAAsCQCA/UARAIA1BIGogA2ogDzoAAAwBCyANIA5BAnRqIhAgECgCAEEBaiIQNgIAIBAgESAQIBFLIhAbIREgDiAPIBAbIQ8LIAxBIGohDCADQQFqIQMgE0EgayITDQALCwJAIBQoAigiA0GDwABLBEAgFCgCJEEEakGAwAAgDUEgakGAwABB/IbOABDVLCANQaDAAGokAAwBC0GEwAAgA0Hshs4AELA7AAsLIBJB8MoCaiIDKQIAIT8gA0KAgICAEDcCACASQfjKAmoiAykCACFAIANCADcCACASQfDVAmogQDcDACASQejVAmogPzcDACASKQLoygIhPyASQgE3AujKAiASID83A+DVAiMAQeAAayIDJAAgA0EANgJcIANCgICAgMAANwJUIANByABqIANB1ABqQYyHzgAQniEgEkHQygJqIg0oAnwhECANKAJ4IQwgDSADKQNINwJ4IBAEQCAMIBBBBXRBBBD4OgsgA0EANgJcIANCgICAgCA3AlQgA0FAayADQdQAakGMh84AEKEhIA0oAjwhECANKAI4IQwgDSADKQNANwI4IBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0E4aiADQdQAakGMh84AEKEhIA0oAkQhECANKAJAIQwgDSADKQM4NwJAIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EwaiADQdQAakGMh84AEKEhIA0oAkwhECANKAJIIQwgDSADKQMwNwJIIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EoaiADQdQAakGMh84AEKEhIA0oAlQhECANKAJQIQwgDSADKQMoNwJQIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EgaiADQdQAakGMh84AEKEhIA0oAlwhECANKAJYIQwgDSADKQMgNwJYIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EYaiADQdQAakGMh84AEKEhIA0oAmQhECANKAJgIQwgDSADKQMYNwJgIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EQaiADQdQAakGMh84AEKEhIA0oAmwhECANKAJoIQwgDSADKQMQNwJoIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EIaiADQdQAakGMh84AEKEhIA0oAnQhECANKAJwIQwgDSADKQMINwJwIBAEQCAMIBBBBXRBAhD4OgsgA0HgAGokACAKLQBaIRAgEkH4zgJqIBJB6MMCakHQBvwKAAAgEkH4zQJqIBJB0MACakGAAfwKAAAgEkH4ywJqIgMgEkHQwQJqQYAC/AoAACASQdjVAmogEkHgwwJqKQIANwMAIBJB0NUCaiASQdjDAmopAgA3AwAgEiASKQLQwwI3A8jVAiASIAJBEWxBBHZBBGoQ+SYgEiAANgKU1gIgEkEANgKI1gIgEiAQOgCZ1gIgEiAtOgCY1gIgEiAGNgKE1gIgEiAENgKA1gIgEkEAOwGa1gIgEkIANwKM1gIgEiASKQMANwP41QIgCAJ/IAEhBCACIQBBACEMQQAhDiMAQbACayIGJAAgBkEwaiASQdDDAmoiE0EQaikCADcDACAGQShqIBNBCGopAgA3AwAgBiATKQIANwMgIAZBQGsgB0EIaikCADcDACAGIAcpAgA3AzhBgICAgHghEUGAgICAeCEQAkAgCSgCEEEBRwRAIAkoAgxFDQEgCSgCCCgCACEQCwJAIAkoAixBAUcEQCAJKAIoRQ0BIAkoAiQoAgAhEQtBgICAgHghDwJAIAkoAkBBAUcEQCAJKAI8RQ0BIAkoAjgoAgAhDwsgBkEYakEAEIQ3IAYgBi8BGDsAgQIgBkEEOgCAAiADIAZBgAJqELkRIBMQhDshAiAABEAgBCAAQQR0aiEjIApBBGohJCAJKAIAQQFqISUgCSgCCEEEaiEmQQEgCigCGHRBEGshFCAGQZgCaiEVIAkoAjAhJyAJKAI4ISggCSgCPCEWIAkoAjQhKSAJKAIcISogCSgCJCErIAkoAighFyAJKAIgISAgBkE4akEEciEYIAkoAgwhGyAJKAIEISEgCi0AWiEZIAtB/wFxQQRGIQtBACEAA0AgBkGAAmogBkEgaiACIAQoAgAiASABIAJLGxCYEyAGQdgAaiIHIAZBkAJqIhopAgA3AwAgBkHQAGoiLSAGQYgCaiIcKQIANwMAIAYgBikCgAI3A0ggBkHwAGogFUEQaiIdKQIANwMAIAZB6ABqIBVBCGoiHikCADcDACAGIBUpAgA3A2AgBkHIAGoQhDshLCATEIQ7GiAGQeAAahCEOxogBCgCBCEIIAZBEGogBCAkEMkSIAYoAhQiHyEJAkACQAJAAkACQAJAIAYoAhAiCgRAIApBAWshASAKQQVPDQEgBkE4aiABQQJ0aigCACAfaiEJCyAGQcgAahCEOyACTQRAIAZByABqEIQ7RQ0FIAZB4AFqIiIgBykDADcDACAGQdgBaiIuIC0pAwA3AwAgBiAGKQNINwPQAQJAIAZB0AFqEIQ7IBBLBEAgJiAAQQJ0aiEHIAAhAQNAIAZBgAJqIAZB0AFqIBAQmBMgBkGgAWogGikCADcDACAGQZgBaiAcKQIANwMAIAZBgAFqIgAgHikCADcDACAGQYgBaiIQIB0pAgA3AwAgBiAGKQKAAjcDkAEgBiAVKQIANwN4AkAgBkGQAWoiLRCEO0UNAAJAIAsEQCAZDQEgAyAtEMcaDAILIAMgBkGQAWoQxxoMAQsgAyAGQZABahDIGgsgBkGQAWoQhDshLSAiIBApAwA3AwAgLiAAKQMANwMAIAYgBikDeDcD0AFBgICAgHghECABQQFqIgAgIUkEQCAAIBtPDQMgBygCACEQIAZBCGogASAlai0AABCENyAGQQQ6AIACIAYgBi8BCDsAgQIgAyAGQYACahC5EQsgAiAtayECIAdBBGohByAAIQEgBkHQAWoQhDsgEEsNAAsLIAtFDQQgGQ0DIAMgBkHQAWoQxxoMBQsgAUEBaiAbQYSr0AAQwyEACwwcCyABQQRB+KfQABDDIQALIAMgBkHQAWoQyBoMAQsgAyAGQdABahDHGgsgBkHQAWoQhDtFDQAgAiAGQdABahCEO2shASAQIAZB0AFqEIQ7ayEQDAELIAIhAQsgCEEYdkGAAXEgCEEZdnLAIAhB////D3FqIQgCQCAUIAUgLGoiLSAUIC1JGyICIAlPBEAgCCABIAEgCEsbIgcEQCAGIAc2AogCIAYgCTYChAIgBkEAOgCAAiADIAZBgAJqELkRCyABIAdrIQIgH0UgCkEBRnENASAGKQM4IT8gGEEIaiAGQUBrKAIANgIAIBggPzcCACAGIAk2AjgMAQsCQAJAAkACQCAIQQNLBEAgCEEZTw0eIAhBAnRBwKnQAGooAgAgCSACQX9zaiIHQX8gCEGkqdAAai0AACIKdEF/c3EiHyAIbGoiAiAIaiIFIAJJDQEgBUGgvwdLDQIgBkGQAWoiCUEAQSb8CwAgCUEmIAJBpOnzAGogCCAIIAcgCnYiAhCiCSIHIAFLBEBBACECIAFFDQYgBkGAAmoiBSAGQeAAaiIKIAEQmBMgAyAFEMcaIAZBADYCzAEgBkIBNwLEASAGQgA3ArwBIAYgCTYCuAEgBSAKQQAQmBMgBkG4AWoiASAFEMQUDQYgBkEANgLQASABIAUgBkHQAWpBtKrQABCGKwALIAZBADoAiwIgBiACOgCJAiAGIAg6AIgCIAYgHzYChAIgBkEBOgCAAiAGIAc6AIoCIAMgBkGAAmoiAhC5ESAHQSdPDQMgBkIANwLIASAGQoCAgIAQNwLAASAGIAc2ArwBIAYgBkGQAWo2ArgBIAIgBkHgAGogBxCYEyAGQbgBaiACEMQURQ0EIAEgB2shAgwFCwwcCyACIAVBpKrQABCxOwALIAVBoL8HQaSq0AAQsDsACyAGQQA2ApACIAZBATYChAIgBkH4oNAANgKAAiAGQgQ3AogCIAZBgAJqQcSq0AAQ7ywACyAGQQA2AtABIAZBuAFqIAZBgAJqIAZB0AFqQdSq0AAQhisACwJAAkACQAJAIBFBAWsiEQ0AQYCAgIB4IREgICAMQQFqIgxNDQAgDCAXTw0BICsgDEECdGooAgAhESAGQQM6AIACIAYgDCAqai0AADoAgQIgAyAGQYACahC5EQsgCEUNAiAELwEMQYABSQ0CIA9BAWsiDw0CQYCAgIB4IQ8gKSAOQQFqIg5NDQIgDiAWTw0BICggDkECdGooAgAhDyAGQQU6AIACIAYgDiAnai0AADoAgQIgAyAGQYACahC5EQwCCyAMIBdB5KrQABDDIQALIA4gFkH0qtAAEMMhAAsgBkGAAmogBkHgAGogBxCYEyAGQaABaiAaKQIANwMAIAZBmAFqIBwpAgA3AwAgBkHwAWoiASAeKQIANwMAIAZB+AFqIgUgHSkCADcDACAGIAYpAoACNwOQASAGIBUpAgA3A+gBIAZBkAFqEIQ7IAZBMGogBSkDADcDACAGQShqIAEpAwA3AwAgBiAGKQPoATcDICAtaiEFIARBEGoiBCAjRw0ACwsgBkGwAmokACAFDAMLDBYLDBYLDBYLNgIAAn8jAEEwayIAJAAgAygClAogAygChApNBEAgA0EAOgCiCiADQQA2ApQKIANBgAJqIQUgAygCnAoaQQAhAiMAQRBrIgEkAANAIAFBCGoQ/icgAiAFaiIEKAIAIAQgASgCCDYCACAEQQRqIgQoAgAgBCABKAIMNgIAEIAxIAJBEGoiAkGAAUcNAAsgAUEQaiQAIAMoApwKGkEAIQIjAEEQayIBJAADQCABQQhqEP4nIAIgA2oiBCgCACAEIAEoAgg2AgAgBEEEaiIEKAIAIAQgASgCDDYCABCAMSACQRBqIgJB8AFHDQALIAFBEGokACADKAKcChojAEEgayIBJAAgAUEANgIcIAFCgICAgCA3AhQgAUEIaiABQRRqQYyHzgAQqiEgA0GAA2oiAigCNCEEIAIoAjAhBSACIAEpAwg3AjAgBARAIAUgBEEBdEECEPg6CyABQQA2AhwgAUKAgICAIDcCFCABIAFBFGpBjIfOABCqISACKAI8IQQgAigCOCEFIAIgASkDADcCOCAEBEAgBSAEQQF0QQIQ+DoLIAFBIGokACAAQQA2AiAgAEKAgICAwAA3AhggAEEQaiAAQRhqQYyHzgAQmSEgAygChAohASADKAKACiECIAMgACkDEDcDgAogAQRAIAIgAUEUbEEEEPg6CyADKAKcCiAAQQhqEP0nIAMoAogKIAMgACgCCDYCiAogAygCjAogAyAAKAIMNgKMChDgNSADLQCjCiAAQTBqJAAMAQsgAEEANgIoIABBATYCHCAAQfig0AA2AhggAEIENwIgIABBGGpBlK3QABDvLAALDQ4gAygChAIEQCMAQRBrIgAkACAAQejvigE2AgwgAEEEaiECAkAgAEEMahC2FCIBKAIQRQRAIAJBwAA2AgQgAkEENgIAIAEgASgCCEEBayICNgIIIAJFBEAgAUEAOgAMIAFCADcDAAsMAQtB4LKJARCbPgALIAAtAAQiAUEERiABQQNHckUEQCAAKAIIIgEoAgAhAiABKAIEIgQoAgAiBQRAIAIgBREDAAsgBCgCBCIFBEAgAiAFIAQoAggQ+DoLIAFBDEEEEPg6CyAAQRBqJAALIAMoAoQKIgAEQCADKAKACiAAQRRsQQQQ+DoLQQAhAANAIAAgA2oiAUGEAmooAgAiAgRAIAFBgAJqKAIAIAJBAnRBBBD4OgsgAEEQaiIAQYABRw0ACyADKAKMCiIABEAgAygCiAogAEEBEPg6C0EAIQADQCAAIANqIgFBBGooAgAiAgRAIAEoAgAgAkECdEEEEPg6CyAAQRBqIgBB8AFHDQALIAMoArQDIgAEQCADKAKwAyAAQQF0QQIQ+DoLIAMoArwDIgAEQCADKAK4AyAAQQF0QQIQ+DoLIA0oAjQiAARAIA0oAjAgAEECdEEEEPg6CyANKAI8IgAEQCANKAI4IABBBXRBAhD4OgsgDSgCRCIABEAgDSgCQCAAQQV0QQIQ+DoLIA0oAkwiAARAIA0oAkggAEEFdEECEPg6C0EAIQEDQCABIA1qIgBB1ABqKAIAIgIEQCAAQdAAaigCACACQQV0QQIQ+DoLIAFBCGoiAUEgRw0ACyANKAJ0IgAEQCANKAJwIABBBXRBAhD4OgsgDSgCfCIABEAgDSgCeCAAQQV0QQQQ+DoLIBJBoNYCaiQADwsgEkEANgKIzAIgEkEBNgL8ywIgEkH4oNAANgL4ywIgEkIENwKAzAIgEkH4ywJqQfik0AAQ7ywACyASQQA2AojMAiASQQE2AvzLAiASQfig0AA2AvjLAiASQgQ3AoDMAiASQfjLAmpBiKXQABDvLAALIA4gD0HYxNAAEMMhAAsgDSAPQejE0AAQwyEACyAMIA9BuMTQABDDIQALIA0gD0HIxNAAEMMhAAsgDCAPQfjE0AAQwyEACyANIA9BiMXQABDDIQALIAwgD0HYxNAAEMMhAAsgDSAPQejE0AAQwyEACyAMIA9BuMTQABDDIQALIA0gD0HIxNAAEMMhAAsgDCAPQfjE0AAQwyEACyANIA9BiMXQABDDIQALQfSi0ABBKyASQfDLAmpBsKPQAEGYpdAAENUeAAtBhMAAIA9BqMTQABCwOwALQYio0ABBKUG0qNAAEJ8pAAtBxKjQAEEfQeSo0AAQnykAC0H0qNAAQR9BlKnQABCfKQALQQBBAEHop9AAEMMhAAtBAEEAQdin0AAQwyEAC0EAQQBByKfQABDDIQAL8yACDH8DfiMAQYAEayIEJAAgBEEAOwH8AyABKAIYIQwCQCABKAIcIgpFDQADQCAGIAxqLQAAQTBHDQEgCiAGQQFqIgZHDQALIAohBgsCQAJAAkACQAJAAkACQAJAAkADQEEAIQcCfwJAIAIgBWtBCEkgCiAGa0EISXJFBEAgBiAMaikAACIPQsaMmbLkyJGjxgB8IA9CsODAgYOGjJgwfSIPhEKAgYKEiJCgwIB/g1ANAQtBAAwBCyAPQgp+IA9CCIh8Ig9CEIhC/4GAgPAfg0KBgICAgOIJfiAPQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiKchByAGQQhqIQYgBUEIaiEFQQgLIQMCQCACIAVNBEAgAyELDAELIAogBmsiCEEAIAggCk0bIgggA2ohCQNAIAgEQCAHQQpsIAYgDGotAABBMGtB/wFxaiEHIAVBAWohBSADQQFqIQsgBkEBaiEGIANBB0sNAiAIQQFrIQggCyEDIAIgBUsNAQwCCwsCQCABKAIQIgpFDQBBACEDAkAgBSABKAIUIgFFcg0AA0AgAyAKai0AAEEwRw0BIAEgA0EBaiIDRw0ACyABIQMLIAFBCGshDCACQQhrIQ4CQANAAkACQCACIAVrQQhJIAlBCmtBd0tyIAEgA2tBCElyDQAgDCADayELIA4gBWshCANAIAMgCmopAAAiD0LGjJmy5MiRo8YAfCAPQrDgwIGDhoyYMH0iD4RCgIGChIiQoMCAf4NCAFINASAPQgp+IA9CCIh8Ig9CEIhC/4GAgPAfg0KBgICAgOIJfiAPQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiKcgB0GAwtcvbGohByAFQQhqIQUgCUEIaiEGIANBCGohAyAIQQhJIAlBAmtBd0tyDQIgCEEIayEIIAtBB0sgC0EIayELIAYhCQ0ACwwBCyAJIQYLAkAgAiAFTSAGQQhLckUEQCADIAEgASADSRshCSAHIQgDQCADIAlGBEAgCCEHIAYhCQwGCyAIQQpsIAMgCmotAABBMGtB/wFxaiEIIAVBAWohBSAGQQFqIQcgA0EBaiEDIAZBB0sNAiAHIQYgAiAFSw0ACwwBCyAHIQggBiEHCwJAAkAgAiAFRwRAIAQvAfwDIgZFDQIgBkECdCEGIARBCGohB0IAIQ8MAQsCQCAHRQ0AAkAgB0EUSQRAAkAgBC8B/AMiBkUNACAGQQJ0IQYgB0EDdEHQ04ABajUCACERIARBCGohBUIAIQ8DQCAFIBEgBTUCAH4gD3wiED4CACAFQQRqIQUgEEIgiCEPIAZBBGsiBg0ACyAQQoCAgIAQVA0AIAQvAfwDIgZB/ABLDQIgBEEIaiAGQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAIRQ0CIARBCGohBUF/IQcDQAJAIAdBAWoiByAELwH8AyIGTwRAIAZB/ABLDQEgBEEIaiAGQQJ0aiAINgIAIAQgBC8B/ANBAWo7AfwDDAULIAUgBSgCACIGIAhqIgk2AgBBASEIIAVBBGohBSAGIAlLDQEMBAsLQdDVgAEQsjsACyAHQRRB8NSAARDDIQALQdDVgAEQsjsACyADIApqIQVBACADayEDA0AgASADakEHTQRAQQAgA2shAwNAIAEgA00NDiADIApqIANBAWohAy0AAEEwRg0ACwJAAkAgBC8B/AMiAUUNACABQQJ0IQUgBEEIaiEDQgAhDwNAIAMgAzUCAEIKfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBUEEayIFDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIBTwRAIAFB/ABNBEAgBEEIaiABQQJ0akEBNgIAIAQgBC8B/ANBAWo7AfwDDAILDBMLIAMgAygCAEEBaiIBNgIAIANBBGohAyABRQ0BCwsgAkEBaiEFDA8LDA8LIANBCGshAyAFKQAAIAVBCGohBUKw4MCBg4aMmDBRDQALAkACQCAELwH8AyIBRQ0AIAFBAnQhBSAEQQhqIQNCACEPA0AgAyADNQIAQgp+IA98IhA+AgAgA0EEaiEDIBBCIIghDyAFQQRrIgUNAAsgEEKAgICAEFQNACAELwH8AyIBQfwASw0BIARBCGogAUECdGogDz4CACAEIAQvAfwDQQFqOwH8AwsgBEEIaiEDQX8hBQNAAkAgBUEBaiIFIAQvAfwDIgFPBEAgAUH8AE0EQCAEQQhqIAFBAnRqQQE2AgAgBCAELwH8A0EBajsB/AMMAgsMEQsgAyADKAIAQQFqIgE2AgAgA0EEaiEDIAFFDQELCyACQQFqIQUMDQsMDQsDQCAHIAc1AgBCgJTr3AN+IA98IhA+AgAgB0EEaiEHIBBCIIghDyAGQQRrIgYNAAsgEEKAgICAEFQNACAELwH8AyIGQfwASw0CIARBCGogBkECdGogDz4CACAEIAQvAfwDQQFqOwH8AwtBACEHQQAhCSAIRQ0AIARBCGohBkF/IQsCQANAAkAgC0EBaiILIAQvAfwDIglPBEAgCUH8AEsNAyAEQQhqIAlBAnRqIAg2AgAgBCAELwH8A0EBajsB/AMMAQsgBiAGKAIAIgkgCGoiDTYCAEEBIQggBkEEaiEGIAkgDUsNAQsLQQAhCQwBCwtBwNWAARCyOwALQcDVgAEQsjsACyAJRQ0HAkACQCAELwH8AyIBRQ0AIAFBAnQhBiAJQQN0QdDTgAFqNQIAIREgBEEIaiEDQgAhDwNAIAMgESADNQIAfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBkEEayIGDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIAdFDQggBEEIaiEDQX8hBgNAAkAgBkEBaiIGIAQvAfwDIgFPBEAgAUH8AEsNASAEQQhqIAFBAnRqIAc2AgAgBCAELwH8A0EBajsB/AMMCwsgAyADKAIAIgEgB2oiAjYCAEEBIQcgA0EEaiEDIAEgAksNAQwKCwtB8NWAARCyOwALQfDVgAEQsjsACyACIAVGDQECQCAELwH8AyIDRQ0AIANBAnQhCCAEQQhqIQNCACEPA0AgAyADNQIAQoCU69wDfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gCEEEayIIDQALIBBCgICAgBBUDQAgBC8B/AMiA0H8AEsNAyAEQQhqIANBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIAdFDQAgBEEIaiEDQX8hCANAAkAgCEEBaiIIIAQvAfwDIglPBEAgCUH8AEsNASAEQQhqIAlBAnRqIAc2AgAgBCAELwH8A0EBajsB/AMMAwsgAyADKAIAIgkgB2oiCzYCAEEBIQcgA0EEaiEDIAkgC0sNAQwCCwsLQYDVgAEQsjsACyALRQ0CAkAgBC8B/AMiA0UNACADQQJ0IQUgC0EDdEHQ04ABajUCACERIARBCGohA0IAIQ8DQCADIBEgAzUCAH4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgNB/ABLDQIgBEEIaiADQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAHRQ0CIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIITwRAIAhB/ABLDQEgBEEIaiAIQQJ0aiAHNgIAIAQgBC8B/ANBAWo7AfwDDAULIAMgAygCACIIIAdqIgk2AgBBASEHIANBBGohAyAIIAlLDQEMBAsLQZDVgAEQsjsAC0GA1YABELI7AAtBkNWAARCyOwALIAYgDGohBUEAIAZrIQMDQCADIApqQQdNBEBBACADayEDAkADQCADIApPDQEgAyAMaiADQQFqIQMtAABBMEYNAAsCQAJAIAQvAfwDIgFFDQAgAUECdCEFIARBCGohA0IAIQ8DQCADIAM1AgBCCn4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgFB/ABLDQEgBEEIaiABQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAEQQhqIQNBfyEFA0ACQCAFQQFqIgUgBC8B/AMiAU8EQCABQfwATQRAIARBCGogAUECdGpBATYCACAEIAQvAfwDQQFqOwH8AwwCCwwKCyADIAMoAgBBAWoiATYCACADQQRqIQMgAUUNAQsLIAJBAWohBQwFCwwGCyABKAIQIgZFDQIgASgCFCEBQQAhAyAGIQUDQCABIANqQQdNBEBBACADayEDA0AgASADTQ0FIAMgBmogA0EBaiEDLQAAQTBGDQALAkACQCAELwH8AyIBRQ0AIAFBAnQhBSAEQQhqIQNCACEPA0AgAyADNQIAQgp+IA98IhA+AgAgA0EEaiEDIBBCIIghDyAFQQRrIgUNAAsgEEKAgICAEFQNACAELwH8AyIBQfwASw0BIARBCGogAUECdGogDz4CACAEIAQvAfwDQQFqOwH8AwsgBEEIaiEDQX8hBQNAAkAgBUEBaiIFIAQvAfwDIgFPBEAgAUH8AE0EQCAEQQhqIAFBAnRqQQE2AgAgBCAELwH8A0EBajsB/AMMAgsMDAsgAyADKAIAQQFqIgE2AgAgA0EEaiEDIAFFDQELCyACQQFqIQUMBgsMCAsgA0EIayEDIAUpAAAgBUEIaiEFQrDgwIGDhoyYMFENAAsCQAJAIAQvAfwDIgFFDQAgAUECdCEFIARBCGohA0IAIQ8DQCADIAM1AgBCCn4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgFB/ABLDQEgBEEIaiABQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAEQQhqIQNBfyEFA0ACQCAFQQFqIgUgBC8B/AMiAU8EQCABQfwATQRAIARBCGogAUECdGpBATYCACAEIAQvAfwDQQFqOwH8AwwCCwwKCyADIAMoAgBBAWoiATYCACADQQRqIQMgAUUNAQsLIAJBAWohBQwECwwGCyADQQhrIQMgBSkAACAFQQhqIQVCsODAgYOGjJgwUQ0ACwJAAkAgBC8B/AMiAUUNACABQQJ0IQUgBEEIaiEDQgAhDwNAIAMgAzUCAEIKfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBUEEayIFDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIBTwRAIAFB/ABNBEAgBEEIaiABQQJ0akEBNgIAIAQgBC8B/ANBAWo7AfwDDAILDAcLIAMgAygCAEEBaiIBNgIAIANBBGohAyABRQ0BCwsgAkEBaiEFDAILDAMLIAIhBQsgACAEQQhqQfgD/AoAACAAIAU2AvgDIARBgARqJAAPC0Hg1YABELI7AAtBoNWAARCyOwALQbDVgAEQsjsAC6suAiN/B34jAEHwAmsiBCQAIARBCGogASACKAIkIgURBAAQxBsgBEGYAWogASACIAMQ2wEgBCgCoAEhByAEKAKcASEJAkACQCAEKAKYASIGQZOAgIB4RwRAIAAgBCkCpAEiJz4CDCAAIAc2AgggACAJNgIEIAAgJ0IgiD4CECAAIAY2AgAMAQsgBCAHNgKEASAEIAk2AoABIAQgAy0AMDYCiAEgASACKAI0EQQAIQ8gBEEANgKUASAEQoCAgIAQNwKMAQJAIAEgBREEACIhRQ0AIARBzABqISIgBEHYAGohECAEQagBaiERIARBmAJqIRIgBEEgaiETIARBzAJqIRggBEEUaiEZIARBEGohFCAEQUBrIRUgBEHkAGohDEEAIQMCQANAAkACQAJAAkACQAJAAkACQCAPBEAgAyAPKAIQTw0DIA8oAgQgDygCDCADaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgBEEANgKUASAEIAM2AowCIAQgBEGAAWoiATYCiAIgBEGYAWogBEGIAmogBEGMAWoiAkGI/v8AENMVIAQoApgBIgdBk4CAgHhGDQEgACAEKQKcATcCBCAAQQxqIARBpAFqKQIANwIAIAAgBzYCACACEN47IAEQvCoMCwsgDBDmOiAEKAJkRQ0CIAQoAnRBAWoiB0EDdiAHQQdxQQBHaiIBIAQoAnAiAksEQCABIAJrIQkgBCgCaCIFIAFJBEAgDCAFQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIFIAIgBUsbEOgZIAQoAnAhAgsgCQRAIAQoAmwgAmpBACAJ/AsACyAEIAE2AnALIAQgBzYCdCAEKAJIIgEgBCgCQEYEQCAVQfD0/wAQsSgLIAQoAkQgAUEEdGoiAkIANwMIIAJCADcDACAEIAFBAWo2AkgMBQsgBCAEKAKUASIHNgLcASAEIAQoApABIgk2AtgBAkAgB0ENTwRAIAQoAhAhASAEQQA2AhAgAQ0BDAULIARBADYC6AEgBEIANwPgASAHBEAgBEHgAWogCSAH/AoAAAsgBDUC6AEhJyAEKQPgASEpIAQoAkgiASAEKAJARgRAIBVB0PX/ABCxKAsgBCgCRCABQQR0aiICICc+AgwgAiApNwIEIAIgBzYCACAEIAFBAWo2AkggBCgCZARAIAQoAnQiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBCgCcCIBSwRAIAIgAWshBSAEKAJoIgYgAkkEQCAMIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBCgCcCEBCyAFBEAgBCgCbCABakEAIAX8CwALIAQgAjYCcAsgBCAJNgJ0IAQoAmwgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAYLIAQgBCgCeEEBajYCeAwFCyAYIBkpAgA3AgAgGEEIaiAZQQhqKAIANgIAIARB6AFqIhogE0EIaikDACInNwMAIARB8AFqIhsgE0EQaikDACIsNwMAIARB+AFqIhwgE0EYaikDACIrNwMAIAQgATYCyAIgBCATKQMAIik3A+ABICcgB60iKoUiKEI4hiAoQoD+A4NCKIaEIChCgID8B4NCGIYgKEKAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhELSgaqbq/qC16d/fiInQjiGICdCgP4Dg0IohoQgJ0KAgPwHg0IYhiAnQoCAgPgPg0IIhoSEICdCCIhCgICA+A+DICdCGIhCgID8B4OEICdCKIhCgP4DgyAnQjiIhISEIChC2KLR78Kp5b8tfoUgKnxCrf7V5NSF/ajYAH4hJwJAIAdBEE0EQCAnICl8IAkpAAAgLIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCAHIAlqQQhrKQAAICuFIihCf4V+IipCOIYgKkKA/gODQiiGhCAqQoCA/AeDQhiGICpCgICA+A+DQgiGhIQgKkIIiEKAgID4D4MgKkIYiEKAgPwHg4QgKkIoiEKA/gODICpCOIiEhISFIChCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJ36FQheJIScMAQsgJyApfCAsIAcgCWpBEGsiASkAAIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCArIAEpAAiFIihCf4V+IipCOIYgKkKA/gODQiiGhCAqQoCA/AeDQhiGICpCgICA+A+DQgiGhIQgKkIIiEKAgID4D4MgKkIYiEKAgPwHg4QgKkIoiEKA/gODICpCOIiEhISFIChCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJ36FQheJIScgK0J/hSEqIAkhASAHIQIDQCAnICl8ICwgASkAAIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCABKQAIIi0gKoV+IihCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhISFICcgKyAthSIoQjiGIChCgP4Dg0IohoQgKEKAgPwHg0IYhiAoQoCAgPgPg0IIhoSEIChCCIhCgICA+A+DIChCGIhCgID8B4OEIChCKIhCgP4DgyAoQjiIhISEfoVCF4khJyABQRBqIQEgAkEQayICQRBLDQALCyAnIClCOIYgKUKA/gODQiiGhCApQoCA/AeDQhiGIClCgICA+A+DQgiGhIQgKUIIiEKAgID4D4MgKUIYiEKAgPwHg4QgKUIoiEKA/gODIClCOIiEhIR+ICdCOIYgJ0KA/gODQiiGhCAnQoCA/AeDQhiGICdCgICA+A+DQgiGhIQgJ0IIiEKAgID4D4MgJ0IYiEKAgPwHg4QgJ0IoiEKA/gODICdCOIiEhIQgKUJ/hX4iKUI4hiApQoD+A4NCKIaEIClCgID8B4NCGIYgKUKAgID4D4NCCIaEhCApQgiIQoCAgPgPgyApQhiIQoCA/AeDhCApQiiIQoD+A4MgKUI4iISEhIUgJ4khK0EAIRZBACEdQQAhHiMAQRBrIg0kACAEQcgCaiIBKAIIRQRAIA1BCGohF0EAIQUjAEHgAGsiAiQAIAIgBEHgAWo2AhwgASgCDCEIIAIgAkEcajYCIAJAIAggCEEBaiIGTQRAAkAgASgCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAGSQRAAkACQCAIQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgAigCFCEFIAIoAhAiBkGBgICAeEcNBAsgAkHQAGogAUEQaiIKQQQgBRD7FCACKAJYIQUgAigCVCEGIAIoAlAiCEUNAyACIAIoAlw2AkwgAiAFNgJIIAIgBjYCRCACIAg2AkAgAkEIaiACQUBrEME0IAIoAgwiBQRAIAIoAghB/wEgBfwLAAsgAigCSCEFIAIoAkQhBiACKAJAIghFDQMgAiACKAJMNgI8IAIgBTYCOCACIAY2AjQgAiAINgIwIAJChICAgIABNwIoIAIgCjYCJCACQTBqISMgAiABKAIMIh8EfyAIQQhqISQgASgCACIgKQMAQn+FQoCBgoSIkKDAgH+DISpBACEOA0AgKlAEQANAIA5BCGohDiAgQQhqIiApAwBCgIGChIiQoMCAf4MiJ0KAgYKEiJCgwIB/UQ0ACyAnQoCBgoSIkKDAgH+FISoLIAggBiACKAIgKAIAIgopAwgiJyABKAIAICp6p0EDdiAOakECdCIla0EEazUCAIUiKUI4hiApQoD+A4NCKIaEIClCgID8B4NCGIYgKUKAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhELSgaqbq/qC16d/fiInQjiGICdCgP4Dg0IohoQgJ0KAgPwHg0IYhiAnQoCAgPgPg0IIhoSEICdCCIhCgICA+A+DICdCGIhCgID8B4OEICdCKIhCgP4DgyAnQjiIhISEIClC2KLR78Kp5b8tfoUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCAKKQMAIilCf4V+IihCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJyApQjiGIClCgP4Dg0IohoQgKUKAgPwHg0IYhiApQoCAgPgPg0IIhoSEIClCCIhCgICA+A+DIClCGIhCgID8B4OEIClCKIhCgP4DgyApQjiIhISEfoUgJ4mnIiZxIgpqKQAAQoCBgoSIkKDAgH+DIidQBEBBCCELA0AgCiALaiEKIAtBCGohCyAIIAYgCnEiCmopAABCgIGChIiQoMCAf4MiJ1ANAAsLICpCAX0gKoMhKiAIICd6p0EDdiAKaiAGcSIKaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAIIApqICZBGXYiCzoAACAkIApBCGsgBnFqIAs6AAAgCCAKQQJ0a0EEayABKAIAICVrQQRrKAAANgAAIB9BAWsiHw0ACyABKAIMBUEACyIGNgI8IAIgBSAGazYCOCABICNBBBD6KiACQSRqEPUnDAELIAEgAkEgakGA3oABEO4JC0GBgICAeCEGDAELEN0nIAIoAgQhBSACKAIAIQYLIBcgBTYCBCAXIAY2AgAgAkHgAGokAAsgBEHYAmohAiAEQQhqIQogASgCBCIGICuncSEFICtCGYhC/wCDQoGChIiQoMCAAX4hKCAEQdgBaiIIKAIEIQ4gCCgCACELIAEoAgAhCANAAkAgBSAIaikAACIpICiFIidCf4UgJ0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEnAn8CQCACAn4CQANAICdQDQEgDSAKIAEoAgAgJ3qnQQN2IAVqIAZxIhdBAnRrQQRrKAIAEPgSICdCAX0gJ4MhJyALIA4gDSgCACANKAIEEJ87RQ0ACyACICs3AwggAiABKAIAQQAgF2tBAnRqNgIQQgAMAQsgKUKAgYKEiJCgwIB/gyEnIB5FBEAgJ1ANAiAneqdBA3YgBWogBnEhFgtBASAnIClCAYaDUA0CGiACIAggFmosAABBAE4EfyAIKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBYLNgIQIAIgKzcDCEIBCzcDACACIAE2AhQgDUEQaiQADAILQQALIR4gBSAdQQhqIh1qIAZxIQUMAQsLIAQoAtgCQQFGBEAgBCgC7AIiASgCACICIAQoAugCIgVqIgYtAAAhCCAEKAJIIQogBiAEKALgAkEZdiIGOgAAIAIgASgCBCAFQQhrcWpBCGogBjoAACABIAEoAgxBAWo2AgwgASABKAIIIAhBAXFrNgIIIAIgBUECdGtBBGsgCjYCACAEQaABaiAEQdACaikCADcDACAEIAQpAsgCNwOYASARQRhqIBwpAwA3AwAgEUEQaiAbKQMANwMAIBFBCGogGikDADcDACARIAQpA+ABNwMAIAQoAhAEQCAUEI47CyAUIARBmAFqQTD8CgAADAQLIAQoAugCQQRrKAIAIgIgBCgCSCIBTw0CIAQoAkQiByACQQR0aiICKQMIIScgAikDACEpIAQoAkAgAUYEfyAVQZD1/wAQsSggBCgCRAUgBwsgAUEEdGoiAiAnNwMIIAIgKTcDACAEIAFBAWo2AkgCQCAEKAJkBEAgBCgCdCIHQQFqIglBA3YgCUEHcUEAR2oiAiAEKAJwIgFLBEAgAiABayEFIAQoAmgiBiACSQRAIAwgBkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiBiABIAZLGxDoGSAEKAJwIQELIAUEQCAEKAJsIAFqQQAgBfwLAAsgBCACNgJwCyAEIAk2AnQgBCgCbCAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBCAEKAJ4QQFqNgJ4CyASIAQpA+ABNwMAIARBkAJqIARB0AJqKQIANwMAIBJBCGogGikDADcDACASQRBqIBspAwA3AwAgEkEYaiAcKQMANwMAIAQgBCkCyAI3A4gCIAQoAhAEQCAUEI47CyAUIARBiAJqQTD8CgAADAQLQcz2/wBBIEHs9v8AEJ8pAAtBuPf/ABCyOwALIAIgAUGA9f8AEMMhAAsgBCgCWCAEKAJgIgEgB2pJBEAgAQRAIARBwAJqIBBBCGooAgA2AgAgBCAQKQIANwO4AiAEQQA2AmAgBEKAgICAEDcDWCAEQcgCaiAEQbgCahDyLyAEIAQpAsgCNwLkAiAEQQA2AuACIAQgBCgC1AIiAjYC3AIgBCAEKALQAjYC2AIgBCAEQdgCahDXOyAEKAIAIQhBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAtgCNwIIIAFBEGogBEHgAmopAgA3AgAgAUEYaiAEQegCaigCADYCACACQX9GDQUgBCgCVCIFIAQoAkxGBEAgIkGI9v8AEJAoCyAEKAJQIAVBDGxqIgYgAjYCCCAGIAg2AgQgBiABNgIAIAQgBUEBajYCVAsgECAEQQhqENcqIgEgByABIAdLGxCELiAEKAJgIQELIBAgCSAHEKE2IAQ1AlQgAa1CIIaEIScgB60gCTUAAEIghoQhKSAEKAJIIgEgBCgCQEYEQCAVQcD1/wAQsSgLIAQoAkQgAUEEdGoiAiAnNwMIIAIgKTcDACAEIAFBAWo2AkggBCgCZARAIAQoAnQiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBCgCcCIBSwRAIAIgAWshBSAEKAJoIgYgAkkEQCAMIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBCgCcCEBCyAFBEAgBCgCbCABakEAIAX8CwALIAQgAjYCcAsgBCAJNgJ0IAQoAmwgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAQgBCgCeEEBajYCeAsgA0EBaiIDICFHDQEMAwsLQQRBHBCjPQALIARBADYC6AIgBEEBNgLcAiAEQfD1/wA2AtgCIARCBDcC4AIgBEHYAmpB+PX/ABDvLAALIARBmAFqIgIgBEEIahDbDEHEAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEGw/f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIARBjAFqEN47IARBgAFqELwqCyAEQUBrEOY8IAQoAmQEQCAEQeQAahDPLwsgBEHMAGoiABDFJyAAEOg7IARB2ABqEN47IAQoAhAEQCAEQRBqEI47CyAEQfACaiQADwtBBEHEABCjPQALyiQCD38DfiMAQcAJayIDJAAgAQJ/AkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A8AJBAWsOAxYNAQALIANBGGoiBRC7LyADQZABaiIEIAUgASgC7AIiBQR/QQJBACAFLQAEGwVBAAsQliogASgC6AIhBSABIARB4AL8CgAAIAFBADoA5AIgASAFNgLgAiABQeQCaiENDAELIAFB5AJqIQ0CQCABLQDkAkEBaw4DEAwCAAsgASgC4AIhBQsgAUH4AGoiBCABQfgA/AoAACABQQA6AIECIAEgBTYC/AEgASAENgL4ASABQfABaiEIIAFBgQJqIQ4MAQsgAUHwAWohCCABQYECaiEOAkAgAS0AgQJBAWsOBAgKAgkACyABKAL8ASEFIAEoAvgBIQQLIAFBAToAgAIgASAENgLwASABQQA6AJQCIAEgBDYChAIgASAFNgL0ASABIAFB9AFqIgU2AogCIAFBlAJqIQogAUGEAmohDwwBCyABQYQCaiEPIAFBlAJqIQoCQCABLQCUAkEBaw4EDQgCBAALIAEoAogCIQUgASgChAIhBAsgASAFNgKQAiABIAQ2AowCIAQoAgAhBiAEKAIEIQQgA0EAOgAgIAMgBTYCGCADQQggBCAEQQhNG0EIIAYbNgIcIANBEGogA0EYahDPKSADKAIQIQQgASADKAIUIgU2ApwCIAEgBDYCmAIMAQsgASgCnAIhBSABKAKYAiEECyADQRhqIAQgAiAFKAIMEQEAQQMgAygCGCIEQQlGDQ8aIAMgAykAITcDmAggAyADQShqKAAANgCfCCADLQAgIQcgAygCHCEGIAMoAiwhCSABQZgCahC8KiAEQQhHBEAgAyADKACfCDYAlwkgAyADKQOYCDcDkAkMFAsgASADKQOYCDcAvQIgASAHOgC8AiABIAY2ArgCIAFBxAJqIAMoAJ8INgAAIAMgASgCwAIiBTYCpAggBUEISQ0BIAFCADcDoAIgASABKAK8AiAFakEIaykAADcDoAIgA0EYaiABQaACahCKGSADLQAgIQcgAygCHCEGIAMoAhgiBEEIRwRAIAMgAykAITcDkAkgAyADQShqKAAANgCXCSADKAIsIQkMEgsgASAHOgCsAiABIAY2AqgCIAEgBjYCmAIgASAGQQhqIgc2ApwCIAYgBUEIayIESw0MIAQgBSAHayIFSQ0KIAQgASgCwAIiB0sNCyADQRhqIAEoAowCIAEoArwCIAVqIAYgAUGoAmoQ/xkgAyADKQAhNwOgBiADIANBKGooAAA2AKcGIAMoAiwhCSADLQAgIQcgAygCHCEGIAMoAhghBCADKAJoIgtBgICAgHhGBEAgAyADKQOgBjcDkAkgAyADKACnBjYAlwkMEgsgA0HYCGogA0EwakE4/AoAACADQagJaiADQfQAaigCADYCACADIAMpAmw3A6AJIAMgAykDoAY3A5AJIAMgAygApwY2AJcJIANBGGogAUG4AmogBRDNFSADQdAIaiADQSRqKAIANgIAIAMgAykCHDcDyAggAygCGCEMDBILIAEoArQCIQUgASgCsAIhBAwNC0ECIQQgA0ECNgIcIANBnPzCADYCGCADQgI3AiQgA0E7NgKsBiADQTs2AqQGIANB4PvCADYCoAYgAyADQaAGajYCICADIANBpAhqNgKoBiADQbAJaiADQRhqEJkOIAMgAygAtQk2ApAJIAMgA0G4CWooAAA2AJMJIAMoArAJIQYgAy0AtAkhBwwPC0Gw+8IAEOgrAAsgAUGIAmohCiABQdgCaiEFIAEtANgCQQFrDgMDAAIBCwALIAEoAqQCIQYgASgCoAIhBAwPCyABKAKcAiEGIAEoApgCIQQMDwtBuP3CABDoKwALQdD8wgAQ6CsAC0HA+8IAEOgrAAsgBSAEQdD7wgAQsTsACyAEIAdB0PvCABCwOwALIAEoApACIQQgA0EAOgAgIAMgBzYCHCADIAQ2AhggA0EIaiADQRhqEM8pIAMoAgghBCABIAMoAgwiBTYCtAIgASAENgKwAgwBC0HA+sIAEOgrAAsgA0EYaiAEIAIgBSgCDBEBACADKAIYIgRBCUcNAUEECyEBIAogAToAAEEDDA8LIAMgAykAITcDqAggAyADQShqKAAANgCvCCADLQAgIQcgAygCHCEGIAMoAiwhCSABQbACahC8KiAEQQhHBEAgAyADKACvCDYAlwkgAyADKQOoCDcDkAkMAQsgA0G8CWoiBSADKACvCDYAACADIAMpA6gINwC1CSADIAc6ALQJIAMgBjYCsAkgAygCuAkiBCABKAKcAk8EQCABKAKMAiEEIANBoAZqIANBsAlqQQAgASgCmAIQ0hAgA0EYaiAEIAMoAqQGIAMoAqgGIAFBqAJqEP8ZIAMgAykAITcDuAggAyADQShqKAAANgC/CCADKAIsIQkgAy0AICEHIAMoAhwhBiADKAIYIQQgAygCaCILQYCAgIB4RgRAIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIAUgAygCtAkgAygCuAkgAygCsAkoAhARAQAgA0GsBmogAygCpAYgAygCqAYgAygCoAYoAhARAQAMAgsgA0HYCGogA0EwakE4/AoAACADQagJaiADQfQAaigCADYCACADIAMpAmw3A6AJIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIANBvAlqIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIAMgBDYCxAhBAiEEIANBAjYCHCADQcD8wgA2AhggA0ICNwIkIANBOzYCrAYgA0E7NgKkBiADIAFBnAJqNgKgBiADIANBoAZqNgIgIAMgA0HECGo2AqgGIANBuAhqIANBGGoQmQ4gAyADKAC9CDYCkAkgAyADQcAIaigAADYAkwkgAygCuAghBiADLQC8CCEHIAUgAygCtAkgAygCuAkgAygCsAkoAhARAQALIAFBxAJqIAEoArwCIAEoAsACIAEoArgCKAIQEQEADAELIAFBxAJqIAEoArwCIAEoAsACIAEoArgCKAIQEQEADAELQYCAgIB4IQsLIAMgAygAlwk2AJcHIAMgAykDkAk3A5AHIANB2AZqIANB2AhqQTj8CgAAIANB0AZqIgUgA0GoCWooAgA2AgAgA0HABmoiECADQdAIaigCADYCACADIAMpA6AJNwPIBiADIAMpA8gINwO4BiAKQQE6AAAgAyADKQOQBzcD+AcgAyADKACXBzYA/wcgA0HAB2oiESADQdgGakE4/AoAACADQbgHaiIKIAUoAgA2AgAgA0GoB2oiBSAQKAIANgIAIAMgAykDyAY3A7AHIAMgAykDuAY3A6AHIA8QoykgC0GAgICAeEYNBCADQbAGaiAFKAIANgIAIAMgDDYCpAYgA0EANgKgBiADIAMpA6AHNwKoBiAIKAIAQRBqENIWIAgoAgAiBSAHOgAYIAUgBjYCFCAFIAQ2AhAgBSADKQP4BzcAGSAFIAk2AiQgBUEgaiADKAD/BzYAACAFQShqIBFBOPwKAAAgBSALNgJgIAVB7ABqIAooAgA2AgAgBSADKQOwBzcCZAJAIAgoAgAiBC0AcEUEQCAELQBxRQ0BCyABQQA6AIACIAEgBDYCoAIgASADKQKgBjcCqAIgAUEAOgDYAiABIAEoAvQBIgY2AqQCIAFBsAJqIANBqAZqKQIANwIAIAFBuAJqIANBsAZqKAIANgIAIAFBiAJqIQogAUHYAmohBQwBC0EIIQQgDEUNDSADQbAGaiADKAKoBiADKAKsBiAMKAIQEQEADA0LIAEgBjYCwAIgASAENgK8AiABIAEpAqgCNwLEAiABQdQCaiABQbgCaigCADYCACABQcwCaiABQbACaikCADcCAAJAIAQoAmBBgICAgHhHBEAgA0HYBmogBBDcCyADKALYBkUNAyABIAMpA+gGIhM3A5ACIAEgAykD4AYiEjcDiAIgASgCyAIEQCASIAFBxAJqNQIAIhRaDQILIAEoAsACIQQgA0EAOgAsIAMgEzcDICADIBI3AxggAyAENgIoIAMgA0EYahDNKSADKAIAIQQgASADKAIEIgY2ApwCIAEgBDYCmAIMAgsgA0EYakEeQQBBAUEBEKAYIAMoAhwhBCADKAIYQQFGDQUgAygCICECIANBADYC2AggAkEWakGu/cIAKQAANwAAIAJBEGpBqP3CACkAADcAACACQQhqQaD9wgApAAA3AAAgAkGY/cIAKQAANwAAIANBHjYC5AggAyACNgLgCCADIAQ2AtwIDAgLIBIgFH0iEkKAgICAEFoEQCADQdgIahDbJAwICyATIBR9IhNCgICAgBBaBEAgA0HYCGoQ2yQMCAsgE6ciAiABKALQAksNBSADQaAJaiABQcgCaiASpyACENIQDAYLIANBGGogBCACIAYoAgwRAQAgAygCGCICQQlHDQEgBUEDOgAADAcLIANBCDYC2AgMBQsgA0G4CWoiBCADQSRqKQIANwMAIAMgAykCHDcDsAkgAygCLCEGIAFBmAJqELwqIAJBCEcEQCADQeQIaiAEKQMANwIAIAMgAykDsAk3AtwIIAMgBjYC7AggAyACNgLYCAwFCyADQagJaiAEKQMANwMAIAMgAykDsAk3A6AJDAMLIAFBgAI7AYACIAMgAykD+Ac3A4gIIAMgAygA/wc2AI8IIARBCUYNBgwJCyAEIAMoAiBB7P/CABD9LwALQeD8wgBBKEGI/cIAEJ8pAAsgAyADNQKoCSISNwPIBiADIAEpA5ACIAEpA4gCIhN9IhQ3A7gIIBIgFFIEQCADQQA2AhggA0HIBmogA0G4CGogA0EYakHI/cIAEK4rAAsgA0EYaiICIAEoArwCIANBoAlqIgYgExCmEgJAIAMoAhgiBEEIRw0AIAIgASgCvAIgBiABKQOIAhCfBiADKAIYIgRBCEcNACADQQg2AtgIIANBrAlqIAMoAqQJIAMoAqgJIAMoAqAJKAIQEQEADAELIANB7AhqIANBLGooAgA2AgAgA0HkCGogA0EkaikCADcCACADIAMpAhw3AtwIIAMgBDYC2AggA0GsCWogAygCpAkgAygCqAkgAygCoAkoAhARAQALIAEoAsgCIgIEQCABQdQCaiABKALMAiABKALQAiACKAIQEQEACyADIAMpAOEINwPICCADIANB6AhqKAAANgDPCCADLQDgCCEHIAMoAtwIIQYgAygC7AghCSADKALYCCEEIAVBAToAACAEQQlHDQMLQQQLIQEgDiABOgAACyANQQM6AAAMAwsgAyADKADPCDYAjwggAyADKQPICDcDiAggChDFIQsgAUGAAjsBgAILIAMgAygAjwg2ALcFIAMgAykDiAg3A7AFIAgQmCwCfyAEQQhHBEAgA0HQBWogAygAtwU2AAAgAyADKQOwBTcAyQUgAyAJNgLUBSADIAc6AMgFQYCAgIB4DAELIANBwAVqIAFB+ABqEP4UIAMoAsQFIQYgAygCwAUhBCADKAKQBgshAiABQYgBahDSFiADQcAEaiIFIANB0AVqKQMANwMAIAMgAykDyAU3A7gEIANBgARqIgggA0HYBWpBOPwKAAAgAUEBOgDkAiADQfgDaiIHIANBnAZqKAIANgIAIAMgAykClAY3A/ADIAJBgYCAgHhGDQAgA0GYBWoiCSAFKQMANwMAIAMgAykDuAQ3A5AFIANB2ARqIAhBOPwKAAAgA0HQBGogBygCADYCACADIAMpA/ADNwPIBCABEPcsAkACQCACQYCAgIB4RgRAIANBqAVqIAkpAwA3AwAgAyADKQOQBTcDoAUgBCEIIAYhBQwBC0EIIQhB6ABBCBCtNiIFRQ0BIAUgBjYCDCAFIAQ2AgggBUKBgICAEDcDACAFIAMpA5AFNwMQIAVBGGogA0GYBWopAwA3AwAgBUEgaiADQdgEakE4/AoAACAFIAI2AlggBSADKQPIBDcCXCAFQeQAaiADQdAEaigCADYCAAsgACAFNgIEIAAgCDYCACAAIAMpA6AFNwMIIABBEGogA0GoBWopAwA3AwBBAQwCC0EIQegAEKM9AAsgAEEJNgIAQQMLOgDwAiADQcAJaiQAC6cmAg9/A34jAEHACWsiAyQAIAECfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAIAEtAOwCQQFrDgMWDQEACyADQfgCaiIEELsvIANBGGoiBiAEQQEQliogASgC6AIhBSABIAZB4AL8CgAAIAFBADoA5AIgASAFNgLgAiABQeQCaiEODAELIAFB5AJqIQ4CQCABLQDkAkEBaw4DEAwCAAsgASgC4AIhBQsgAUH4AGoiBCABQfgA/AoAACABQQA6AIECIAEgBTYC/AEgASAENgL4ASABQfABaiEIIAFBgQJqIQ8MAQsgAUHwAWohCCABQYECaiEPAkAgAS0AgQJBAWsOBAgKAgkACyABKAL8ASEFIAEoAvgBIQQLIAFBAToAgAIgASAENgLwASABQQA6AJQCIAEgBDYChAIgASAFNgL0ASABIAFB9AFqIgU2AogCIAFBlAJqIQogAUGEAmohEAwBCyABQYQCaiEQIAFBlAJqIQoCQCABLQCUAkEBaw4EDQgCBAALIAEoAogCIQUgASgChAIhBAsgASAFNgKQAiABIAQ2AowCIAQoAgAhBiAEKAIEIQQgA0EAOgCkAyADIAU2AvgCIANBCCAEIARBCE0bQQggBhs2AvwCIANBEGogA0H4AmoQzCkgAygCECEEIAFBzN3CADYCnAIgASAENgKYAkHM3cIADAELIAEoApgCIQQgASgCnAILIQUgA0H4AmogBCACIAUoAgwRAQBBAyADKAL4AiIEQQlGDQ8aIAMgAykAgQM3A5gIIAMgA0GIA2ooAAA2AJ8IIAMtAIADIQcgAygC/AIhBiADKAKMAyEJIAFBmAJqELwqIARBCEcEQCADIAMoAJ8INgCXCSADIAMpA5gINwOQCQwUCyABIAMpA5gINwC9AiABIAc6ALwCIAEgBjYCuAIgAUHEAmogAygAnwg2AAAgAyABKALAAiIFNgKkCCAFQQhJDQEgAUIANwOgAiABIAEoArwCIAVqQQhrKQAANwOgAiADQfgCaiABQaACahCKGSADLQCAAyEHIAMoAvwCIQYgAygC+AIiBEEIRwRAIAMgAykAgQM3A5AJIAMgA0GIA2ooAAA2AJcJIAMoAowDIQkMEgsgASAHOgCsAiABIAY2AqgCIAEgBjYCmAIgASAGQQhqIgc2ApwCIAYgBUEIayIESw0MIAQgBSAHayIFSQ0KIAQgASgCwAIiB0sNCyADQfgCaiABKAKMAiABKAK8AiAFaiAGIAFBqAJqEP8ZIAMgAykAgQM3A6AGIAMgA0GIA2ooAAA2AKcGIAMoAowDIQkgAy0AgAMhByADKAL8AiEGIAMoAvgCIQQgAygCyAMiC0GAgICAeEYEQCADIAMpA6AGNwOQCSADIAMoAKcGNgCXCQwSCyADQdgIaiADQZADakE4/AoAACADQagJaiADQdQDaigCADYCACADIAMpAswDNwOgCSADIAMpA6AGNwOQCSADIAMoAKcGNgCXCSADQfgCaiABQbgCaiAFEM0VIANB0AhqIANBhANqKAIANgIAIAMgAykC/AI3A8gIIAMoAvgCIQwMEgsgASgCtAIhBSABKAKwAiEEDA0LQQIhBCADQQI2AvwCIANBmPDCADYC+AIgA0ICNwKEAyADQTs2AqwGIANBOzYCpAYgA0H478IANgKgBiADIANBoAZqNgKAAyADIANBpAhqNgKoBiADQbAJaiADQfgCahCZDiADIAMoALUJNgKQCSADIANBuAlqKAAANgCTCSADKAKwCSEGIAMtALQJIQcMDwtByO/CABDoKwALIAFBiAJqIQogAUHYAmohBSABLQDYAkEBaw4DAwACAQsACyABKAKkAiEGIAEoAqACIQQMDwsgASgCnAIhBiABKAKYAiEEDA8LQZDxwgAQ6CsAC0Go8MIAEOgrAAtB2O/CABDoKwALIAUgBEHo78IAELE7AAsgBCAHQejvwgAQsDsACyABKAKQAiEEIANBADoApAMgAyAENgL4AiADIAc2AvwCIANBCGogA0H4AmoQzCkgAygCCCEEQczdwgAhBSABQczdwgA2ArQCIAEgBDYCsAIMAQtB3PTCABDoKwALIANB+AJqIAQgAiAFKAIMEQEAIAMoAvgCIgRBCUcNAUEECyEBIAogAToAAEEDDA8LIAMgAykAgQM3A6gIIAMgA0GIA2ooAAA2AK8IIAMtAIADIQcgAygC/AIhBiADKAKMAyEJIAFBsAJqELwqIARBCEcEQCADIAMoAK8INgCXCSADIAMpA6gINwOQCQwBCyADQbwJaiIFIAMoAK8INgAAIAMgAykDqAg3ALUJIAMgBzoAtAkgAyAGNgKwCSADKAK4CSIEIAEoApwCTwRAIAEoAowCIQQgA0GgBmogA0GwCWpBACABKAKYAhDSECADQfgCaiAEIAMoAqQGIAMoAqgGIAFBqAJqEP8ZIAMgAykAgQM3A7gIIAMgA0GIA2ooAAA2AL8IIAMoAowDIQkgAy0AgAMhByADKAL8AiEGIAMoAvgCIQQgAygCyAMiC0GAgICAeEYEQCADIAMpA7gINwOQCSADIAMoAL8INgCXCSAFIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIANB2AhqIANBkANqQTj8CgAAIANBqAlqIANB1ANqKAIANgIAIAMgAykCzAM3A6AJIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIANBvAlqIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIAMgBDYCxAhBAiEEIANBAjYC/AIgA0Go78IANgL4AiADQgI3AoQDIANBOzYCrAYgA0E7NgKkBiADIAFBnAJqNgKgBiADIANBoAZqNgKAAyADIANBxAhqNgKoBiADQbgIaiADQfgCahCZDiADIAMoAL0INgKQCSADIANBwAhqKAAANgCTCSADKAK4CCEGIAMtALwIIQcgBSADKAK0CSADKAK4CSADKAKwCSgCEBEBAAsgAUHEAmogASgCvAIgASgCwAIgASgCuAIoAhARAQAMAQsgAUHEAmogASgCvAIgASgCwAIgASgCuAIoAhARAQAMAQtBgICAgHghCwsgAyADKACXCTYAlwcgAyADKQOQCTcDkAcgA0HYBmoiDSADQdgIakE4/AoAACADQdAGaiIFIANBqAlqKAIANgIAIANBwAZqIhEgA0HQCGooAgA2AgAgAyADKQOgCTcDyAYgAyADKQPICDcDuAYgCkEBOgAAIAMgAykDkAc3A/gHIAMgAygAlwc2AP8HIANBwAdqIgogDUE4/AoAACADQbgHaiINIAUoAgA2AgAgA0GoB2oiBSARKAIANgIAIAMgAykDyAY3A7AHIAMgAykDuAY3A6AHIBAQoykgC0GAgICAeEYNBCADQbAGaiAFKAIANgIAIAMgDDYCpAYgA0EANgKgBiADIAMpA6AHNwKoBiAIKAIAQRBqENIWIAgoAgAiBSAHOgAYIAUgBjYCFCAFIAQ2AhAgBSADKQP4BzcAGSAFIAk2AiQgBUEgaiADKAD/BzYAACAFQShqIApBOPwKAAAgBSALNgJgIAVB7ABqIA0oAgA2AgAgBSADKQOwBzcCZAJAIAgoAgAiBC0AcEUEQCAELQBxRQ0BCyABQQA6AIACIAEgBDYCoAIgASADKQKgBjcCqAIgAUEAOgDYAiABIAEoAvQBIgY2AqQCIAFBsAJqIANBqAZqKQIANwIAIAFBuAJqIANBsAZqKAIANgIAIAFBiAJqIQogAUHYAmohBQwBC0EIIQQgDEUNDSADQbAGaiADKAKoBiADKAKsBiAMKAIQEQEADA0LIAEgBjYCwAIgASAENgK8AiABIAEpAqgCNwLEAiABQdQCaiABQbgCaigCADYCACABQcwCaiABQbACaikCADcCAAJAIAQoAmBBgICAgHhHBEAgA0HYBmogBBDcCyADKALYBkUNAyABIAMpA+gGIhM3A5ACIAEgAykD4AYiEjcDiAIgASgCyAIEQCASIAFBxAJqNQIAIhRaDQILIAEoAsACIQYjAEHgAGsiBCQAIARB1ABqIAZBCGoQ3SAgBigCFCIGIAYoAgAiB0EBajYCACAHQQBIBEAACyAEQcgAaiAEQdwAaigCADYCACAEIAQpAlQ3A0AgBCAGNgI8IARBADoATCAEIBM3AxAgBCASNwMIIARBCGohBwJAQcgAQQgQrTYiBgRAIAYgB0HIAPwKAAAgBEH83cIANgIEIAQgBjYCAAwBC0EIQcgAEKM9AAsgAyAEKQMANwMAIARB4ABqJAAgAygCACEEQfzdwgAhBiABQfzdwgA2ApwCIAEgBDYCmAIMAgsgA0HYCGpBHkEAQQFBARCgGCADKALcCCEEIAMoAtgIQQFGDQUgAygC4AghAiADQQA2AvgCIAJBFmpBhvHCACkAADcAACACQRBqQYDxwgApAAA3AAAgAkEIakH48MIAKQAANwAAIAJB8PDCACkAADcAACADQR42AoQDIAMgAjYCgAMgAyAENgL8AgwICyASIBR9IhJCgICAgBBaBEAgA0H4AmoQ2yQMCAsgEyAUfSITQoCAgIAQWgRAIANB+AJqENskDAgLIBOnIgIgASgC0AJLDQUgA0GgCWogAUHIAmogEqcgAhDSEAwGCyADQdgIaiAEIAIgBigCDBEBACADKALYCCICQQlHDQEgBUEDOgAADAcLIANBCDYC+AIMBQsgA0G4CWoiBCADQeQIaikCADcDACADIAMpAtwINwOwCSADKALsCCEGIAFBmAJqELwqIAJBCEcEQCADQYQDaiAEKQMANwIAIAMgAykDsAk3AvwCIAMgBjYCjAMgAyACNgL4AgwFCyADQagJaiAEKQMANwMAIAMgAykDsAk3A6AJDAMLIAFBgAI7AYACIAMgAykD+Ac3A4gIIAMgAygA/wc2AI8IIARBCUYNBgwJCyAEIAMoAuAIQdzzwgAQ/S8AC0G48MIAQShB4PDCABCfKQALIAMgAzUCqAkiEjcDyAYgAyABKQOQAiABKQOIAiITfSIUNwO4CCASIBRSBEAgA0EANgLYCCADQcgGaiADQbgIaiADQdgIakGg8cIAEK4rAAsgA0HYCGoiAiABKAK8AiADQaAJaiIGIBMQphICQCADKALYCCIEQQhHDQAgAiABKAK8AiAGIAEpA4gCEJ8GIAMoAtgIIgRBCEcNACADQQg2AvgCIANBrAlqIAMoAqQJIAMoAqgJIAMoAqAJKAIQEQEADAELIANBjANqIANB7AhqKAIANgIAIANBhANqIANB5AhqKQIANwIAIAMgAykC3Ag3AvwCIAMgBDYC+AIgA0GsCWogAygCpAkgAygCqAkgAygCoAkoAhARAQALIAEoAsgCIgIEQCABQdQCaiABKALMAiABKALQAiACKAIQEQEACyADIAMpAIEDNwPICCADIANBiANqKAAANgDPCCADLQCAAyEHIAMoAvwCIQYgAygCjAMhCSADKAL4AiEEIAVBAToAACAEQQlHDQMLQQQLIQEgDyABOgAACyAOQQM6AAAMAwsgAyADKADPCDYAjwggAyADKQPICDcDiAggChDFIQsgAUGAAjsBgAILIAMgAygAjwg2ALcFIAMgAykDiAg3A7AFIAgQmCwCfyAEQQhHBEAgA0HQBWogAygAtwU2AAAgAyADKQOwBTcAyQUgAyAJNgLUBSADIAc6AMgFQYCAgIB4DAELIANBwAVqIAFB+ABqEP4UIAMoAsQFIQYgAygCwAUhBCADKAKQBgshAiABQYgBahDSFiADQcAEaiIFIANB0AVqKQMANwMAIAMgAykDyAU3A7gEIANBgARqIgggA0HYBWpBOPwKAAAgAUEBOgDkAiADQfgDaiIHIANBnAZqKAIANgIAIAMgAykClAY3A/ADIAJBgYCAgHhGDQAgA0GYBWoiCSAFKQMANwMAIAMgAykDuAQ3A5AFIANB2ARqIAhBOPwKAAAgA0HQBGogBygCADYCACADIAMpA/ADNwPIBCABEPcsAkACQCACQYCAgIB4RgRAIANBqAVqIAkpAwA3AwAgAyADKQOQBTcDoAUgBCEIIAYhBQwBC0EIIQhB6ABBCBCtNiIFRQ0BIAUgBjYCDCAFIAQ2AgggBUKBgICAEDcDACAFIAMpA5AFNwMQIAVBGGogA0GYBWopAwA3AwAgBUEgaiADQdgEakE4/AoAACAFIAI2AlggBSADKQPIBDcCXCAFQeQAaiADQdAEaigCADYCAAsgACAFNgIEIAAgCDYCACAAIAMpA6AFNwMIIABBEGogA0GoBWopAwA3AwBBAQwCC0EIQegAEKM9AAsgAEEJNgIAQQMLOgDsAiADQcAJaiQAC7lFAhV/AX4jAEHgMGsiCSQAQQIhDQJAAkACQAJAAkACQCAARQRAIAEoAoAOQRxJDQELIAFB8A1qIQ8CQCAADQAgASgC+A1BwABHDQAgDyACIAMQyyBFDQELIAEoAtgPIQogCSABKALQDyIFNgIEIAlB0CBqIgQQhSAgCUEYaiABQaAOaiIGKQIANwMAIAlBEGogAUGYDmoiBykCADcDACABKQKQDiEZIAEgCSkC0CA3ApAOIAcgCUHYIGoiBykCADcCACAGIAlB4CBqIgYpAgA3AgAgCSAZNwMIIAQQhSAgCUEwaiABQdAOaiIMKQIANwMAIAlBKGogAUHIDmoiCCkCADcDACABKQLADiEZIAEgCSkC0CA3AsAOIAggBykCADcCACAMIAYpAgA3AgAgCSAZNwMgIAQQhSAgCUHIAGogAUG4DmoiDCkCADcDACAJQUBrIAFBsA5qIggpAgA3AwAgASkCqA4hGSABIAkpAtAgNwKoDiAIIAcpAgA3AgAgDCAGKQIANwIAIAkgGTcDOCABQYgPaiEXIAFB4A1qIRYgAEEBcyESIAFBqA5qIRMgAUHADmohFCABQZAOaiEVIAlB0ABqIAlBCGoQsRUgCUHQEGogCUEgahCxFSAEIAlBOGoQsRUgAS0AihEhCAJAAkACQAJAA0AgBSEHIAUhBgNAQWEhDQJAAkACQAJAAkACQCAIQf8BcUEHaw4EAAEDAgkLQQIhDSAARQRAIAEoAoAOQRtNDQkLIAEoAqwPRQRAIAAgFyAPQQEgAiADENoHRQ0JQQchCCABQQc6AIoRIAEgASgCwA87AfAQDAYLAn8gCUEEaiEQIAlB0CBqIQUjAEEQayIEJAAgBEEANgIEIARBADYCCCAEQQA2AgwCQAJAAkACQAJ/IAECfwJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQCAARQRAIAEvAfAQIgdBgAJJBEAgBSAHQQN0aiIFKAIEIQcgBSgCACELIAEpA/ANIRkgASgC+A0iBUEwTwRAIAEgGUIwiCIZNwPwDSABKAL8DSIGQQhqIQwgBkF3Sw0DIAMgDEkNKSABIAZBBmo2AvwNIAEgASgCgA5BBms2AoAOIAEgAiAGaiIGNQAAQhCGIAYxAARCMIaEIAYxAAVCOIaEIBmEIhk3A/ANIAVBMHMhBQsgGSAFQT9xrYinIg5B/wFxIgwgB08NAyALIAxBAnRqIgYvAQAhCCAGLQACIgZBCEsEQCAGQQhrQf8BcSIGQSFPDQUgCCAMaiAGQQJ0Qfic8wBqKAIAIA5BCHZxaiIGIAdPDQYgCyAGQQJ0aiIHLQACIQYgBy8BACEIIAVBCGohBQsgASAFIAZqNgL4DUEAIQxCACEZQQAhBkEAIQsgCAwHCyAHQYACQcSn8wAQwyEACyABLwHwECIHQYACSQ0EIAdBgAJB1KfzABDDIQALIAYgDEGcnvMAELE7AAsgDCAHQaye8wAQwyEACyAGQSFB/J3zABDDIQALIAYgB0G8nvMAEMMhAAsgASgCgA4hCyABKAL8DSEGIAEoAvgNIQwgASkD8A0hGUEAIAUgB0EDdGoiBSgCACAFKAIEIAFB8A1qIARBBGogAiADEJ8TRQ0LGiAEKAIECyIFQcAFSQRAIAEgBUEDdCIFQeun8wBqLQAAIgc2AoQQIAEgBUHqp/MAaiwAADYCqBAgByABKAL4D2oiByABKALkDiIITw0BIAVB5qfzAGovAQAhESAFQemn8wBqLQAAIQ4gBUHop/MAai0AACEIIBAgBUHkp/MAai8BACIYNgIAIAEgASgC4A4gB2otAAA6AIURIAANAiAIDQMgASgC+A0hBQwJCyAFQcAFQeTT8wAQwyEACyAHIAhB9NPzABDDIQALIAFB8A1qIQUgCA0BIARBADYCCAwECwJ+An8CQCAIQQhNIAEoAvgNIgVBN0txRQRAIAhBEE0gBUEvS3ENASABKQPwDSEZIAVBH0sEQCABIAVBIHMiBTYC+A0gASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBiAHQXtLDQYgAyAGSQ0eIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANCyAIQSFPDQYgGSAFQT9xrYgMAwsgASABKQPwDUI4iCIZNwPwDSABKAL8DSILQQhqIQcgC0F3Sw0NIAMgB0kNDiABIAtBB2o2AvwNIAEgASgCgA5BB2s2AoAOIAIgC2oiBzUAAEIIhiAHMQAEQiiGhCAHMQAFQjCGhCAHMQAGQjiGhCAZhCEZIAVBOHMMAQsgASABKQPwDUIwiCIZNwPwDSABKAL8DSILQQhqIQcgC0F3Sw0MIAMgB0kNDSABIAtBBmo2AvwNIAEgASgCgA5BBms2AoAOIAIgC2oiBzUAAEIQhiAHMQAEQjCGhCAHMQAFQjiGhCAZhCEZIAVBMHMLIQUgASAZNwPwDSAZIAVBP3GtiAshGSABIAUgCGoiBTYC+A0gBCAIQQJ0Qfic8wBqKAIAIBmncTYCCAwFCyAFIAggBEEIaiACIAMQ7R8NAgwDCyAHIAZBjJ7zABCxOwALIAhBIUH8nfMAEMMhAAtBACAORQ0CGiAFIA4gBEEMaiACIAMQ7R9FDQAgBCgCDAwCCyABIAs2AoAOIAEgBjYC/A0gASAMNgL4DSABIBk3A/ANQQAMAgsCfgJ/AkAgDkEITSAFQTdLcUUEQCAOQRBNIAVBL0txDQEgASkD8A0hGSAFQR9LBEAgASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBiAHQXtLDQcgAyAGSQ0YIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANIAVBIHMhBQsgDkEhTw0HIBkgBUE/ca2IDAMLIAEgASkD8A1COIgiGTcD8A0gASgC/A0iC0EIaiEHIAtBd0sNByADIAdJDQggASALQQdqNgL8DSABIAEoAoAOQQdrNgKADiACIAtqIgc1AABCCIYgBzEABEIohoQgBzEABUIwhoQgBzEABkI4hoQgGYQhGSAFQThzDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iC0EIaiEHIAtBd0sNBiADIAdJDQcgASALQQZqNgL8DSABIAEoAoAOQQZrNgKADiACIAtqIgc1AABCEIYgBzEABEIwhoQgBzEABUI4hoQgGYQhGSAFQTBzCyEFIAEgGTcD8A0gGSAFQT9xrYgLIRkgASAFIA5qNgL4DSAOQQJ0Qfic8wBqKAIAIBmncQsgEWo2AqQQIBAgBCgCCCAYajYCACABIAEoAqwPQQFrNgKsD0EBCyAEQRBqJAAMBAsgByAGQYye8wAQsTsACyAOQSFB/J3zABDDIQALIAsgB0GcnvMAELE7AAsgByADQZye8wAQsDsACyAJKAIEIQUgEnJFDQggBUUEQEEJIQggAUEJOgCKEUEAIQVBACEHQQAhBgwGC0EIIQggAUEIOgCKESABIAEoAogQIAVrNgKIEAwGCyABKAKAEEUNAiAJQQA2AtQwIAlBADYC2DAgACAJQdAAaiABLQCEEUEDdGoiCCgCACAIKAIEIA8gCUHUMGogCUHYMGogAiADEKooA0BBAiENAkACQCAARQRAIAEoAoAOQRxJDQELAkAgASgCqA8NACAAIAEgAiADEI0tIBJyQQFHDQEgACAJQdAAaiABLQCEEUEDdGoiCCgCACAIKAIEIA8gCUHUMGogCUHYMGogAiADEKooIAEoAoAQDQBBCCEIIAFBCDoAihEMCAsCQAJAIABFBEAgCCgCACEOIAgoAgQhBCAJQdgwaiENAkAgCUHUMGoiESgCACIQQQhNBEAgDyAPKAIIIBBqNgIIIA0oAgAhCwwBCwJAAkAgDygCCCILQTBPBEAgDygCDCIFQQhqIQwgBUF3Sw0BIAMgDEkNGSAPKQMAIRkgDyAFQQZqNgIMIA8gDygCEEEGazYCECAPIAIgBWoiBTUAAEIQhiAZQjCIhCAFMQAEQjCGhCAFMQAFQjiGhDcDACALQTBzIQsLIBBBCGsiDEEhTw0BIAQgDSgCACAPKQMAIAtBP3GtiKciBUH/AXFqIAxBAnRB+JzzAGooAgAgBUEIdnFqIgVLBEAgDyALIA4gBUECdGoiBS0AAmpBCGo2AgggBS8BACELDAMLIAUgBEGMn/MAEMMhAAsgBSAMQZye8wAQsTsACwwTC0EAIA4gBCAPIBEgDSACIAMQqiggCiABKALcDiIFTw0BIAEoAtgOIApqIAs6AAAMAgsgCUEANgLcMCAIKAIAIAgoAgQgDyAJQdwwaiACIAMQnxNFDQIgASgC3A4iBSAKSwRAIAEoAtgOIApqIAkoAtwwOgAADAILIAogBUHU1fMAEMMhAAsgCiAFQcTV8wAQwyEACyABKAKoDyIFDQFBcyENCyAGIQUMCQsgASAFQQFrNgKoDyAKQQFqIgQgASgC6A9HBEAgCSAGQQFrIgU2AgQgBSEHIAUhBiAEIQogBQ0BDAULCyABQQ06AIoRQQEhDSAKQQFqIQogB0EBayEFDAcLIAZBH3UgBnEhCyABKALoDyEHIAYhBSAKIQQCQAJAAkADQCAFQQBMDQIgASgC7A8gBCABKAKoEGtxIgggASgC3A4iDE8NAyAEIAxPDQEgASgC2A4iDCAEaiAIIAxqLQAAOgAAIAVBAWshBSAHIARBAWoiBEcNAAsgAUEQOgCKESAGIApqIAdrIQVBASENIAchCgwJCyAEIAxBpNfzABDDIQALIAkgC0EBayIFNgIEIAEoAogQQQBKBEBBByEIIAFBBzoAihEgBSEHIAUhBiAEIQoMBQsgAUEOOgCKEUEBIQ0gBCEKDAcLIAggDEGU1/MAEMMhAAsCQAJAIAEoAqgQIgRBAEgEQCABKAKwD0UEQAJ/AkAgACABQYgPaiABQfANakECIAIgAxDaByIHBEAgASABKALID0ECdCIENgL4DyABKAKEECAEaiIEIAEoAuQOIgZPDQEgASABKALgDiAEai0AADoAhRELIAcMAQsgBCAGQeSl8wAQwyEACyASckEBRw0DCyAJQdAQaiEEQQAhDiMAQRBrIhEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAEQCARQQA2AgggASgCgA4hDSABKAL8DSEIIAEoAvgNIQYgASkD8A0hGSAEIAEtAIURQQN0aiIEKAIAIAQoAgQgAUHwDWogEUEIaiACIAMQnxNFDQ0gASARKAIIIgs2AqgQDAELIAQgAS0AhRFBA3RqIgQoAgQhBiAEKAIAIQwgASkD8A0hGSABKAL4DSIOQTBPBEAgASAZQjCIIhk3A/ANIAEoAvwNIgdBCGohBCAHQXdLDRwgAyAESQ0dIAEgB0EGajYC/A0gASABKAKADkEGazYCgA4gASACIAdqIgQ1AABCEIYgBDEABEIwhoQgBDEABUI4hoQgGYQiGTcD8A0gDkEwcyEOCyAZIA5BP3GtiKciC0H/AXEiBCAGTw0BIAwgBEECdGoiCC8BACEHIAEgCC0AAiINQQhLBH8gDUEIa0H/AXEiCEEhTw0DIAQgB2ogCEECdEH4nPMAaigCACALQQh2cWoiBCAGTw0EIA5BCGohDiAMIARBAnRqIgQtAAIhDSAELwEABSAHC0H//wNxIgs2AqgQIAEgDiANQf8BcWo2AvgNQQAhBkIAIRlBACEIQQAhDQsgAUEANgKEECALQRBJBEAgASgC8A8hBAJAIAEoAqgQIgdFBEAgAUEBNgKEECABIARBAWsiBDYC8A8gASABIARBA3FBAnRqKALgDTYCqBAMAQtBgMr+UiAHQQF0Igx2QQNxIQYgAUGb/r/VeiAMdSAEakEDcUECdGooAuANIQQgB0EBcUUEQCABQf////8HIAQgBmsiBCAEQQBMGzYCqBAMAQsgASAEIAZqNgKoEAsgASABKAKwD0EBazYCsA9BASEODAwLIAsgASgCkBAiDmsiEEEASA0KAkACfwJAAn4CfwJAAkAgAEUEQCABKAKMECIIDQUgEEEBdkEBaiEGIBBBD00gASgC+A0iC0E3S3ENASAQQR9NIAtBL0txDQIgASkD8A0hGSALQR9LBEAgASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBCAHQXtLDQwgAyAESQ0NIAEgBDYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANIAtBIHMhCwsgEEHAAE8NDSAZIAtBP3GtiAwEC0EAIQ4gEUEANgIMIAEoApQQIQcgAUHwDWogECABKAKMEHYiDEEBdkEBaiILIBFBDGogAiADEO0fRQ0GIAEoApAQIQ4gASgCjBAhCCARKAIMDAULIAEgASkD8A1COIgiGTcD8A0gASgC/A0iB0EIaiEEIAdBd0sNICADIARJDSEgASAHQQdqNgL8DSABIAEoAoAOQQdrNgKADiACIAdqIgQ1AABCCIYgBDEABEIohoQgBDEABUIwhoQgBDEABkI4hoQgGYQhGSALQThzDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iB0EIaiEEIAdBd0sNHyADIARJDSAgASAHQQZqNgL8DSABIAEoAoAOQQZrNgKADiACIAdqIgQ1AABCEIYgBDEABEIwhoQgBDEABUI4hoQgGYQhGSALQTBzCyELIAEgGTcD8A0gGSALQT9xrYgLIRkgASAGIAtqNgL4DSAOIBBBAXFBAnIgBnRqIAZBAnRB+JzzAGooAgAgGadxakEEayELDA0LIBAgCHYiDEEBdkEBaiELIAEoApQQIQcCfiABAn4CQCAMQQ9NIAEoAvgNIg1BN0txRQRAIAxBH00gDUEvS3ENASABKQPwDSEZIA1BH0sEQCABIA1BIHMiDTYC+A0gASAZQiCIIhk3A/ANIAEoAvwNIgRBBGohBiAEQXtLDQ8gAyAGSQ0fIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIARqNQAAQiCGIBmEIhk3A/ANCyAMQcAATw0PIBkgDUE/ca2IDAMLIAEgASkD8A1COIgiGTcD8A0gASgC/A0iBkEIaiEEIAZBd0sNCyADIARJDSAgDUE4cyENIAEgBkEHajYC/A0gASABKAKADkEHazYCgA4gAiAGaiIENQAAQgiGIAQxAARCKIaEIAQxAAVCMIaEIAQxAAZCOIaEIBmEDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iBkEIaiEEIAZBd0sNCyADIARJDR8gDUEwcyENIAEgBkEGajYC/A0gASABKAKADkEGazYCgA4gAiAGaiIENQAAQhCGIAQxAARCMIaEIAQxAAVCOIaEIBmECyIZNwPwDSAZIA1BP3GtiAshGSABIAsgDWo2AvgNIAtBAnRB+JzzAGooAgAgGadxCyEEIAxBAXFBAnIgC3RBBGutIAStfCAIQT9xrYanIA4gByAQcWpqIQsMCwsgASANNgKADiABIAg2AvwNIAEgBjYC+A0gASAZNwPwDSABQX82AqgQDAsLIAQgBkGsnvMAEMMhAAsgCEEhQfyd8wAQwyEACyAEIAZBvJ7zABDDIQALIAcgBEGMnvMAELE7AAsgBCADQYye8wAQsDsACyAGQSFB/J3zABDDIQALIAYgBEGcnvMAELE7AAsgBiAEQZye8wAQsTsACyAEIAZBjJ7zABCxOwALIAtBIUH8nfMAEMMhAAsgASALQQ9rNgKoECABIAEoArAPQQFrNgKwD0EBIQ4LIBFBEGokACAOIBJyQQFHDQIMAQsgASAERTYChBAgASABKALwD0EBayIFNgLwDyABIBYgBUEDcUECdGooAgA2AqgQCyABKALkDyIGIAEoAtwPIgVHBEAgASABKALcECAKaiAFIAogASgC4A9IGyIGNgLkDwsgCSABKAKkECIFNgIEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYgASgCqBAiBEgEQCAEQfz///8HSg0aIAVBBGtBFUkNAUF0IQ0MGQsgASABKALwDyIHQQFqNgLwDyABIAEoAogQIAVrNgKIECAWIAdBA3FBAnRqIAQ2AgAgASgC7A8gCiAEa3EiCEEQaiEHIAhBb0sNBCAHIAEoAtwOIgRLDQUgCkEQaiEGIApBb0sNBiAEIAZJDQcgASgC2A4iBCAIaiIMKQAAIRkgBCAKaiIEQQhqIAxBCGopAAA3AAAgBCAZNwAAAkAgCCAFIApqIgxJIAUgCGoiBCAKS3ENACAMIAEoAugPIgtPIAQgC09yDQACQCAFQRFIDQAgASgC3A4hBCABKALYDiELIAVBIE0EQCAIQSBqIgggB0kNCyAEIAhJDQwgCkEgaiIKIAZJDQ0gBCAKSQ0OIAcgC2oiCikAACEZIAYgC2oiBEEIaiAKQQhqKQAANwAAIAQgGTcAAAwBCyAFQRBrIQojAEEgayIIJAACQAJAAkACQAJAAkACQAJAAkACQCAGIAdNBEAgBCAHSQ0CIAogBCAHayIESw0DIAYgCmoiBCAKSQ0EIAQgB0sNBSAKRQ0BIAYgC2ogByALaiAK/AoAAAwBCyAEIAZJDQUgByAKaiINIApJDQYgBiANSQ0HIAogBCAGayIESw0IIApFDQAgBiALaiAHIAtqIAr8CgAACyAIQSBqJAAMCAsgCEEANgIYIAhBATYCDCAIQfCc8wA2AgggCEIENwIQIAhBCGpBpNTzABDvLAALIAogBEG01PMAELA7AAsgBiAEQcTU8wAQsTsACyAEIAdBxNTzABCwOwALIAhBADYCGCAIQQE2AgwgCEHwnPMANgIIIAhCBDcCECAIQQhqQdTU8wAQ7ywACyAHIA1B5NTzABCxOwALIA0gBkHk1PMAELA7AAsgCiAEQfTU8wAQsDsACwsgASgCiBAhBAwCC0EKIQggAUEKOgCKEQwWCyAFQcjW8wBqLQAAIgxBIU8NHCAFQQJ0QeTV8wBqKAIAIQcgASABKALwDyABKAKEEGo2AvAPIAQgBkF/c2oiBCAMdSIGQfgASgRAQXUhDQwYCyAMQQJ0Qfic8wBqKAIAIARxIAVsIAdqIgQgBWoiByAESQ0LIAdBoL8HSw0MIARBpOnzAGohBAJAIAZFBEAgBSAKaiIMIAVJDQ8gDCABKALcDiIHSw0QIAUEQCABKALYDiAKaiAEIAX8CgAACyAFIQQMAQsgASgC3A4iByAKSQ0QIAEoAtgOIApqIAcgCmsgBCAFIAUgBhCiCSIEIApqIQwLIAEgASgCiBAgBGsiBDYCiBAgDCABKALoD04NAQsgBEEATA0BQQchCCABQQc6AIoRIAUhByAFIQYgDCEKDBMLIAFBDzoAihEMDgsgAUEOOgCKEQwNCyAIIAdBhNTzABCxOwALIAcgBEGE1PMAELA7AAsgCiAGQZTU8wAQsTsACyAGIARBlNTzABCwOwALIAcgCEGE1PMAELE7AAsgCCAEQYTU8wAQsDsACyAGIApBlNTzABCxOwALIAogBEGU1PMAELA7AAsgBCAHQeTW8wAQsTsACyAHQaC/B0Hk1vMAELA7AAsgCiAMQfTW8wAQsTsACyAMIAdB9NbzABCwOwALIAogB0GE1/MAEK87AAtBASENIAwhCgwGC0ECIQ0MBQsgASgC7A8iBiAKQQFrcSIEIAEoAtwOIgVPBEAgBCAFQYTV8wAQwyEACwJAAkAgBSAGIApBAmtxIgZLBEAgBCABKALYDiIMai0AACEFIAYgDGotAAAhCCABLQCSE0EBRyAKQQJOcg0BQQAhCEEAIQUMAgsgBiAFQZTV8wAQwyEACyAKQQJIDQAgAUEAOgCSEwsCQANAAkAgAA0AIAEoAoAOQRtLDQAgAUEIOgCKEQwGCwJAAkACQAJAAkACQCABKAKoD0UEQCAAIAEgAiADEI0tIBJyQQFHDQwgASgCgBANAQsgASgC9A8gASgC6BAiBCAIQf8BcWpBgAJqLQAAIAQgBUH/AXFqLQAAcmoiBCABKAL8DiIGTw0BIAlB0ABqIAEoAvgOIARqLQAAQQN0aiIEKAIEIQggBCgCACELIABFBEAgASkD8A0hGSABKAL4DSIEQTBPBEAgASAEQTBzIgQ2AvgNIAEgGUIwiCIZNwPwDSABKAL8DSIGQQhqIQwgBkF3Sw0EIAMgDEkNFiABIAZBBmo2AvwNIAEgASgCgA5BBms2AoAOIAEgAiAGaiIGNQAAQhCGIAYxAARCMIaEIAYxAAVCOIaEIBmEIhk3A/ANCyAZIARBP3GtiKciEEH/AXEiDiAITw0EIAsgDkECdGoiDC8BACEGIAwtAAIiDUEISwRAIAEgBEEIaiIENgL4DSANQQhrQf8BcSIMQSFPDRMgBiAOaiAMQQJ0Qfic8wBqKAIAIBBBCHZxaiIGIAhPDQYgCyAGQQJ0aiIGLQACIQ0gBi8BACEGCyABIAQgDUH/AXFqNgL4DSAGQf//A3EhBgwGCyAJQQA2AtwwIAsgCCAPIAlB3DBqIAIgAxCfE0UNCyAJKALcMCEGDAULQQghCCABQQg6AIoRIAkgBzYCBCAHIgUhBgwICyAEIAZBpNXzABDDIQALIAYgDEGcnvMAELE7AAsgDiAIQaye8wAQwyEACyAGIAhBvJ7zABDDIQALAkAgASgC3A4iBCAKSwRAIAEoAtgOIApqIAY6AAAgASgCqA8iBA0BQXMhDSAHIQUMCAsgCiAEQbTV8wAQwyEACyABIARBAWs2AqgPIApBAWoiBCABKALoD0YNASAFIQggBiEFIAQhCiAHQQFrIgcNAAsgCUEANgIEDAELIAFBDToAihFBASENIApBAWohCiAHQQFrIQUMBAsgASgCiBBBAEoEQEEJIQggAUEJOgCKEUEAIQVBACEHQQAhBiAEIQoMAQsLCyABQQ46AIoRQQEhDUEAIQUgBCEKDAELQQIhDSAHIQULIAEgBTYC0A8gASAKNgLYDyAJQdAgaiIAEIUgIAlB4BBqIgEgCUEYaiIFKQMANwMAIAlB2BBqIgIgCUEQaiIDKQMANwMAIAMgCUHYIGoiAykCADcDACAFIAlB4CBqIgUpAgA3AwAgCSAJKQMINwPQECAJIAkpAtAgNwMIIAMgFUEIaiIKKQIANwMAIAUgFUEQaiIEKQIANwMAIAkgFSkCADcD0CAgFSAJKQPQEDcCACAKIAIpAwA3AgAgBCABKQMANwIAIAAQmSogABCFICABIAlBMGoiCikDADcDACACIAlBKGoiBCkDADcDACAEIAMpAgA3AwAgCiAFKQIANwMAIAkgCSkDIDcD0BAgCSAJKQLQIDcDICADIBRBCGoiCikCADcDACAFIBRBEGoiBCkCADcDACAJIBQpAgA3A9AgIBQgCSkD0BA3AgAgCiACKQMANwIAIAQgASkDADcCACAAEJkqIAAQhSAgASAJQcgAaiIKKQMANwMAIAIgCUFAayIEKQMANwMAIAQgAykCADcDACAKIAUpAgA3AwAgCSAJKQM4NwPQECAJIAkpAtAgNwM4IAMgE0EIaiIDKQIANwMAIAUgE0EQaiIFKQIANwMAIAkgEykCADcD0CAgEyAJKQPQEDcCACADIAIpAwA3AgAgBSABKQMANwIAIAAQmSoMAQtBcCENCyAJQThqEJkqIAlBIGoQmSogCUEIahCZKgsgCUHgMGokACANDwsgBiADQYye8wAQsDsACyAMQSFB/J3zABDDIQALIAcgBEGcnvMAELE7AAsgBCADQZye8wAQsDsACyAMIANBnJ7zABCwOwALvx8BBn8gACgCCCIFBEAgACgCBCEGA0ACQCAGIARBuAVsaiIAKQMAQgJSBEAgACgCmAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAVqENkhCyAAKAKcBSIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGcBWoQriALIABBwARqELwqIABByARqENcpIABBsAFqIQECQAJAAkACQEECIAAoApACIgNBgICAgHhzIANBAE4bDgIBAgALIABBkAJqEN47IABBnAJqEN47IABBqAJqEN0pIABBrAJqEN0pDAILIABBlAJqEN47DAELIABBlAJqEN47IABBoAJqEN0pCyABKAIAQYCAgIB4RwRAIABByAFqQQgQ7iggARDeOyAAQbwBakEEQQgQ4B4gAEGAAmoQ4zwLAkAgACgCzAJFDQAgACgC0AIiAUUNACAAQdwCaiAAKALUAiAAKALYAiABKAIQEQEACwJAIAAoAuACRQ0AIAAoAuQCIgFFDQAgAEHwAmogACgC6AIgACgC7AIgASgCEBEBAAsgACgCwAJBgICAgHhHBEAgAEHAAmpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAENIhIABBoAVqEMMcIABB9ARqQQRBCBDgHiAAQYAFahCdPCAAQYwFahCdPCAAQYADaiIBEIcZIAFBCEGIARDgHiAAQZADahDtJyAAQYgEahDHKCAAQdAEahDxJgwBCwJAAkACQAJAAkACQAJAAkAgACgCCEEBaw4HAgMEBQYHAAELIAAoApAFIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZAFahDZIQsgACgClAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBlAVqEK4gCyAAQbgEahC8KiAAQcAEahDXKSAAKAJ4IQEgACgCfCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJoQYCAgIB4RwRAIABBIGpBCBDuKCAAQdAAaiIBENwlIAFBBEEQEOAeIABB6ABqEOM8CyAAKAK0ASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEG0AWoQ2SELAkAgACgCgAFFDQAgACgChAEiAUUNACAAQZABaiAAKAKIASAAKAKMASABKAIQEQEACwJAIAAoApQBRQ0AIAAoApgBIgFFDQAgAEGkAWogACgCnAEgACgCoAEgASgCEBEBAAsgACgCqAFBgICAgHhHBEAgAEGoAWpBBEEgEOAeCyAAQeADahCFMCAAQewDahCFMAJAIAAoArACRQ0AIAAoArQCIgFFDQAgAEHAAmogACgCuAIgACgCvAIgASgCEBEBAAsCQCAAKALEAkUNACAAKALIAiIBRQ0AIABB1AJqIAAoAswCIAAoAtACIAEoAhARAQALIABB2AJqEIUwIABB5AJqEIUwIABBmAVqEMMcIABB7ARqQQRBCBDgHiAAQfgEahCdPCAAQYQFahCdPCAAQfgCaiIBEIcZIAFBCEGIARDgHiAAQYgDahDtJyAAQYAEahDHKCAAKALIBEUNByAAKALMBCIBBEAgAEHYBGogACgC0AQgACgC1AQgASgCEBEBAAsgACgC3AQiAUUNByAAQegEaiAAKALgBCAAKALkBCABKAIQEQEADAcLIAAoAqQEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaQEahDZIQsgACgCqAQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBqARqEK4gCyAAQfADahC8KiAAQfgDahDXKSAAKAJ4IQEgACgCfCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJoQYCAgIB4RwRAIABBIGpBCBDuKCAAQdAAahDeOyAAQegAahDjPAsgACgCjAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBjAFqENkhCyAAKAKAAUGAgICAeEcEQCAAQYABakEEQSAQ4B4LIABBmANqEIUwIABBpANqEIUwIABBiAJqEIUwIABBlAJqEIUwIABBrARqEMMcIABBgARqQQRBCBDgHiAAQYwEahCdPCAAQZgEahCdPCAAQbACaiIBEIcZIAFBCEGIARDgHiAAQcACahDtJyAAQbgDahDHKAwGCyAAKALIBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHIBGoQ2SELIAAoAswEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcwEahCuIAsgAEGIBGoQvCogAEGQBGoQ1ykgACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDpOyAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LIABBsANqEIUwIABBvANqEIUwIABBqAJqEIUwIABBtAJqEIUwIABB0ARqEMMcIABBpARqQQRBCBDgHiAAQbAEahCdPCAAQbwEahCdPCAAQcgCaiIBEIcZIAFBCEGIARDgHiAAQdgCahDtJyAAQdADahDHKAwFCyAAKAL0BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH0BGoQ2SELIAAoAvgEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgEahCuIAsgAEHABGoQvCogAEHIBGoQ1ykgACgCmAEhASAAKAKcASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAKIAUGAgICAeEcEQCAAQUBrQQgQ7iggAEHwAGoQ4zwgAEGIAWoQ4zwLIAAoAqwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQawBahDZIQsgACgCoAFBgICAgHhHBEAgAEGgAWpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAQcgCahCFMCAAQdQCahCFMCAAQfwEahDDHCAAQdAEakEEQQgQ4B4gAEHcBGoQnTwgAEHoBGoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxygMBAsgACgC+AQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB+ARqENkhCyAAKAL8BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH8BGoQriALIABBqARqELwqIABBsARqENcpIAAoApgBIQEgACgCnAEiAygCACICBEAgASACEQMACyADKAIEIgIEQCABIAIgAygCCBD4OgsgACgCiAFBgICAgHhHBEAgAEFAa0EIEO4oIABB8ABqQQRBDBDgHiAAQYgBahDjPAsgACgCrAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBrAFqENkhCyAAKAKgAUGAgICAeEcEQCAAQaABakEEQSAQ4B4LIABB0ANqEIUwIABB3ANqEIUwIABByAJqEIUwIABB1AJqEIUwIABBgAVqEMMcIABB1ARqQQRBCBDgHiAAQeAEahCdPCAAQewEahCdPCAAQegCaiIBEIcZIAFBCEGIARDgHiAAQfgCahDtJyAAQfADahDHKAwDCyAAKALIBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHIBGoQ2SELIAAoAswEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcwEahCuIAsgAEGIBGoQvCogAEGQBGoQ1ykgACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDpOyAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LIABBsANqEIUwIABBvANqEIUwIABBqAJqEIUwIABBtAJqEIUwIABB0ARqEMMcIABBpARqQQRBCBDgHiAAQbAEahCdPCAAQbwEahCdPCAAQcgCaiIBEIcZIAFBCEGIARDgHiAAQdgCahDtJyAAQdADahDHKAwCCyAAKAL0BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH0BGoQ2SELIAAoAvgEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgEahCuIAsgAEHABGoQvCogAEHIBGoQ1ykgACgCmAEhASAAKAKcASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAKIAUGAgICAeEcEQCAAQUBrQQgQ7iggAEHwAGoQ4zwgAEGIAWoQ4zwLIAAoAqwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQawBahDZIQsgACgCoAFBgICAgHhHBEAgAEGgAWpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAQcgCahCFMCAAQdQCahCFMCAAQfwEahDDHCAAQdAEakEEQQgQ4B4gAEHcBGoQnTwgAEHoBGoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxygMAQsgACgCkAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAVqENkhCyAAKAKUBSIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGUBWoQriALIABBuARqELwqIABBwARqENcpIAAoAnghASAAKAJ8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAmhBgICAgHhHBEAgAEEgakEIEO4oIABB0ABqIgEQ3CUgAUEEQRAQ4B4gAEHoAGoQ4zwLIAAoArQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbQBahDZIQsCQCAAKAKAAUUNACAAKAKEASIBRQ0AIABBkAFqIAAoAogBIAAoAowBIAEoAhARAQALAkAgACgClAFFDQAgACgCmAEiAUUNACAAQaQBaiAAKAKcASAAKAKgASABKAIQEQEACyAAKAKoAUGAgICAeEcEQCAAQagBakEEQSAQ4B4LIABB4ANqEIUwIABB7ANqEIUwIABBwAFqENIhIABBmAVqEMMcIABB7ARqQQRBCBDgHiAAQfgEahCdPCAAQYQFahCdPCAAQfgCaiIBEIcZIAFBCEGIARDgHiAAQYgDahDtJyAAQYAEahDHKCAAQcgEahDxJgsgACgCsAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBsAVqEIgcCyAEQQFqIgQgBUcNAAsLC+wjAgt/AX4jAEEQayIJJAACQAJAAkACQAJAAkAgAEH1AU8EQCAAQcz/e0sEQEEAIQAMBwsgAEELaiIBQXhxIQRBxPOKASgCACIIRQ0EQR8hB0EAIARrIQMgAEH0//8HTQRAIARBBiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmohBwsgB0ECdEGo8IoBaigCACICRQRAQQAhAEEAIQEMAgtBACEAIARBGSAHQQF2a0EAIAdBH0cbdCEFQQAhAQNAAkAgAigCBEF4cSIGIARJDQAgBiAEayIGIANPDQAgAiEBIAYiAw0AQQAhAyABIQAMBAsgAigCFCIGIAAgBiACIAVBHXZBBHFqKAIQIgJHGyAAIAYbIQAgBUEBdCEFIAINAAsMAQsCQAJAAkACQEHA84oBKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIEQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgZBA3QiAUG48YoBaiIFIAFBwPGKAWooAgAiACgCCCIDRg0BIAMgBTYCDCAFIAM2AgggACABEPMuDAkLIARByPOKASgCAE0NByABDQFBxPOKASgCACIARQ0HIABoQQJ0QajwigFqKAIAIgEoAgRBeHEgBGshAyABIQIDQAJAIAEoAhAiAA0AIAEoAhQiAA0AIAIgBBCYPiEIIAIoAhghBwJAAkAgAiACKAIMIgBGBEAgAkEUQRAgAigCFCIAG2ooAgAiAQ0BQQAhAAwCCyACKAIIIgEgADYCDCAAIAE2AggMAQsgAkEUaiACQRBqIAAbIQUDQCAFIQYgASIAQRRqIABBEGogACgCFCIBGyEFIABBFEEQIAEbaigCACIBDQALIAZBADYCAAsgB0UNBQJAIAIoAhxBAnRBqPCKAWoiASgCACACRwRAIAIgBygCEEcEQCAHIAA2AhQgAA0CDAgLIAcgADYCECAADQEMBwsgASAANgIAIABFDQULIAAgBzYCGCACKAIQIgEEQCAAIAE2AhAgASAANgIYCyACKAIUIgFFDQUgACABNgIUIAEgADYCGAwFCyAAKAIEQXhxIARrIgEgAyABIANJIgEbIQMgACACIAEbIQIgACEBDAALAAtBwPOKASACQX4gBndxNgIAIAAgARDzLgwHCwJAQQIgAHQiBUEAIAVrciABIAB0cWgiBkEDdCIBQbjxigFqIgUgAUHA8YoBaigCACIAKAIIIgNHBEAgAyAFNgIMIAUgAzYCCAwBC0HA84oBIAJBfiAGd3E2AgALIAAgBEEDcjYCBCAAIAQQmD4iBiABIARrIgQQ0DRByPOKASgCACICBEBB0POKASgCACEBAn9BwPOKASgCACIFQQEgAkEDdnQiA3FFBEBBwPOKASADIAVyNgIAIAJBeHFBuPGKAWoiAwwBCyACQXhxIgJBuPGKAWohAyACQcDxigFqKAIACyEFIAMgATYCCCAFIAE2AgwgASADNgIMIAEgBTYCCAtB0POKASAGNgIAQcjzigEgBDYCAAwGC0HE84oBQcTzigEoAgBBfiACKAIcd3E2AgALAkACQCADQRBPBEAgAiAEQQNyNgIEIAggAxDQNEHI84oBKAIAIgFFDQFB0POKASgCACEAAn9BwPOKASgCACIFQQEgAUEDdnQiBnFFBEBBwPOKASAFIAZyNgIAIAFBeHFBuPGKAWoiAQwBCyABQXhxIgVBuPGKAWohASAFQcDxigFqKAIACyEFIAEgADYCCCAFIAA2AgwgACABNgIMIAAgBTYCCAwBCyACIAMgBGoQ8y4MAQtB0POKASAINgIAQcjzigEgAzYCAAsgAhCZPiIARQ0DDAULIAAgAXJFBEBBACEBQQIgB3QiAEEAIABrciAIcSIARQ0DIABoQQJ0QajwigFqKAIAIQALIABFDQELA0AgACABIAAoAgRBeHEiBSAEayIGIANJIgcbIQggACgCECICRQRAIAAoAhQhAgsgASAIIAQgBUsiABshASADIAYgAyAHGyAAGyEDIAIiAA0ACwsgAUUNACAEQcjzigEoAgAiAE0gAyAAIARrT3ENACABIAQQmD4hByABKAIYIQgCQAJAIAEgASgCDCIARgRAIAFBFEEQIAEoAhQiABtqKAIAIgINAUEAIQAMAgsgASgCCCICIAA2AgwgACACNgIIDAELIAFBFGogAUEQaiAAGyEFA0AgBSEGIAIiAEEUaiAAQRBqIAAoAhQiAhshBSAAQRRBECACG2ooAgAiAg0ACyAGQQA2AgALAkAgCEUNAAJAAkAgASgCHEECdEGo8IoBaiICKAIAIAFHBEAgASAIKAIQRwRAIAggADYCFCAADQIMBAsgCCAANgIQIAANAQwDCyACIAA2AgAgAEUNAQsgACAINgIYIAEoAhAiAgRAIAAgAjYCECACIAA2AhgLIAEoAhQiAkUNASAAIAI2AhQgAiAANgIYDAELQcTzigFBxPOKASgCAEF+IAEoAhx3cTYCAAsCQCADQRBPBEAgASAEQQNyNgIEIAcgAxDQNCADQYACTwRAIAcgAxDsEAwCCwJ/QcDzigEoAgAiAEEBIANBA3Z0IgJxRQRAQcDzigEgACACcjYCACADQfgBcUG48YoBaiIADAELIANB+AFxIgJBuPGKAWohACACQcDxigFqKAIACyEDIAAgBzYCCCADIAc2AgwgByAANgIMIAcgAzYCCAwBCyABIAMgBGoQ8y4LIAEQmT4iAA0CCwJAAkAgBEHI84oBKAIAIgFLBEAgBEHM84oBKAIAIgBPBEAgCUEEaiAEQa+ABGpBgIB8cRDLIiAJKAIEIgFFBEBBACEADAYLIAkoAgwhA0HY84oBIAkoAggiBUHY84oBKAIAaiIANgIAQdzzigEgAEHc84oBKAIAIgIgACACSxs2AgACQEHU84oBKAIABEBBqPGKASEAA0AgABCuOyABRg0CIAAoAggiAA0ACwwEC0Hk84oBKAIAIgBBACAAIAFNG0UEQEHk84oBIAE2AgALQejzigFB/x82AgBBtPGKASADNgIAQazxigEgBTYCAEGo8YoBIAE2AgBBxPGKAUG48YoBNgIAQczxigFBwPGKATYCAEHA8YoBQbjxigE2AgBB1PGKAUHI8YoBNgIAQcjxigFBwPGKATYCAEHc8YoBQdDxigE2AgBB0PGKAUHI8YoBNgIAQeTxigFB2PGKATYCAEHY8YoBQdDxigE2AgBB7PGKAUHg8YoBNgIAQeDxigFB2PGKATYCAEH08YoBQejxigE2AgBB6PGKAUHg8YoBNgIAQfzxigFB8PGKATYCAEHw8YoBQejxigE2AgBBhPKKAUH48YoBNgIAQfjxigFB8PGKATYCAEGA8ooBQfjxigE2AgBBjPKKAUGA8ooBNgIAQYjyigFBgPKKATYCAEGU8ooBQYjyigE2AgBBkPKKAUGI8ooBNgIAQZzyigFBkPKKATYCAEGY8ooBQZDyigE2AgBBpPKKAUGY8ooBNgIAQaDyigFBmPKKATYCAEGs8ooBQaDyigE2AgBBqPKKAUGg8ooBNgIAQbTyigFBqPKKATYCAEGw8ooBQajyigE2AgBBvPKKAUGw8ooBNgIAQbjyigFBsPKKATYCAEHE8ooBQbjyigE2AgBBzPKKAUHA8ooBNgIAQcDyigFBuPKKATYCAEHU8ooBQcjyigE2AgBByPKKAUHA8ooBNgIAQdzyigFB0PKKATYCAEHQ8ooBQcjyigE2AgBB5PKKAUHY8ooBNgIAQdjyigFB0PKKATYCAEHs8ooBQeDyigE2AgBB4PKKAUHY8ooBNgIAQfTyigFB6PKKATYCAEHo8ooBQeDyigE2AgBB/PKKAUHw8ooBNgIAQfDyigFB6PKKATYCAEGE84oBQfjyigE2AgBB+PKKAUHw8ooBNgIAQYzzigFBgPOKATYCAEGA84oBQfjyigE2AgBBlPOKAUGI84oBNgIAQYjzigFBgPOKATYCAEGc84oBQZDzigE2AgBBkPOKAUGI84oBNgIAQaTzigFBmPOKATYCAEGY84oBQZDzigE2AgBBrPOKAUGg84oBNgIAQaDzigFBmPOKATYCAEG084oBQajzigE2AgBBqPOKAUGg84oBNgIAQbzzigFBsPOKATYCAEGw84oBQajzigE2AgBBuPOKAUGw84oBNgIAQdTzigEgASABEJk+IgBBB2pBeHEgAGsiARCYPiIANgIAQczzigEgBSABa0EoayIBNgIAIAAgAUEBcjYCBCAAIAEQmD5BKDYCBEHg84oBQYCAgAE2AgAMBAsgACgCDCICQQFxIAJBAXYgA0dyDQIgAEHU84oBKAIAEM8tRQ0CIAAgACgCBCAFajYCBEHM84oBKAIAIQFB1POKASgCACIAIAAQmT4iAEEHakF4cSAAayICEJg+IQBBzPOKASABIAVqIAJrIgE2AgBB1POKASAANgIAIAAgAUEBcjYCBCAAIAEQmD5BKDYCBEHg84oBQYCAgAE2AgAMAwtBzPOKASAAIARrIgE2AgBB1POKAUHU84oBKAIAIgAgBBCYPiICNgIAIAIgAUEBcjYCBCAAIARBA3I2AgQMAwtB0POKASgCACEAIAEgBGsiAkEPTQRAQdDzigFBADYCAEHI84oBQQA2AgAgACABEPMuDAMLIAAgBBCYPiEBQcjzigEgAjYCAEHQ84oBIAE2AgAgASACENA0IAAgBEEDcjYCBAwCC0Hk84oBQeTzigEoAgAiACABIAAgAUkbNgIAIAEgBWohBkGo8YoBIQACQAJAA0AgBiAAKAIAIgJHBEAgACgCCCIADQEMAgsLIAAoAgwiBkEBcQ0AIAZBAXYgA0YNAQtB1POKASgCACECQajxigEhAAJAA0AgAiAAKAIATwRAIAAQrjsgAksNAgsgACgCCCIADQALQQAhAAsgAiAAEK47IgtBL2siABCZPiIGQQdqQXhxIAZrIABqIgAgACACQRBqSRsiBhCZPiEHIAZBGBCYPiEAQdTzigEgASABEJk+IghBB2pBeHEgCGsiChCYPiIINgIAQczzigEgBSAKa0EoayIKNgIAIAggCkEBcjYCBCAIIAoQmD5BKDYCBEHg84oBQYCAgAE2AgAgBkEbNgIEQajxigEpAgAhDCAHQQhqQbDxigEpAgA3AgAgByAMNwIAQbTxigEgAzYCAEGs8YoBIAU2AgBBqPGKASABNgIAQbDxigEgBzYCAANAIABBBBCYPiAAQQc2AgQiAEEEaiALSQ0ACyACIAZGDQEgAiAGIAJrIgAgAiAAEJg+EIkuIABBgAJPBEAgAiAAEOwQDAILAn9BwPOKASgCACIBQQEgAEEDdnQiBXFFBEBBwPOKASABIAVyNgIAIABB+AFxQbjxigFqIgAMAQsgAEH4AXEiAUG48YoBaiEAIAFBwPGKAWooAgALIQMgACACNgIIIAMgAjYCDCACIAA2AgwgAiADNgIIDAELIAAgATYCACAAIAAoAgQgBWo2AgQgARCZPiEAIAIQmT4hBSABIABBB2pBeHEgAGtqIgAgBBCYPiEBIAAgBEEDcjYCBCACIAVBB2pBeHEgBWtqIgMgACAEamshBAJAQdTzigEoAgAgA0cEQCADQdDzigEoAgBGDQEgAygCBCICQQNxQQFGBEAgAyACQXhxIgIQhQ8gAiAEaiEEIAMgAhCYPiEDCyABIAQgAxCJLiAEQYACTwRAIAEgBBDsEAwECwJ/QcDzigEoAgAiAkEBIARBA3Z0IgVxRQRAQcDzigEgAiAFcjYCACAEQfgBcUG48YoBaiIEDAELIARB+AFxIgJBuPGKAWohBCACQcDxigFqKAIACyEDIAQgATYCCCADIAE2AgwgASAENgIMIAEgAzYCCAwDC0HU84oBIAE2AgBBzPOKAUHM84oBKAIAIARqIgI2AgAgASACQQFyNgIEDAILQdDzigEgATYCAEHI84oBQcjzigEoAgAgBGoiAjYCACABIAIQ0DQMAQtBACEAQczzigEoAgAiASAETQ0BQczzigEgASAEayIBNgIAQdTzigFB1POKASgCACIAIAQQmD4iAjYCACACIAFBAXI2AgQgACAEQQNyNgIECyAAEJk+IQALIAlBEGokACAAC5gcAg5/Bn4jAEEgayINJAAgACABaiESAkACQCABQQ9NDQAgAEEBaiIOIARNBEAgAyAOaiAEIA5rQcAAIAdrIhYgCBD6HSEPIABBAmoiByACQRBrIgIgASAIayIBIAEgAksbIABqIhRLDQEgFkE/ca0hHCAIQThsQThxrSEdIAwoAgAhESAJKAIAIRcgCigCACEYIAkoAgQhFUF/IRADQEEhIQIDQAJAAkACQAJAAkACQCAHIgEgBE0EQCABIANqIAQgAWsgFiAIEPodIRMgBCAOSQ0BIAQgDiAQayIHSQ0CIAcgDklBACADIA5qIhkgBCAOayIaIAMgB2ogBCAHayAIEKgRG0UEQCAGIA9LBEAgBSAPQQJ0aiIPKAIAIQcgDyAONgIAIAQgB0kNBSAZIBogAyAHaiAEIAdrIAgQqBENBwwICyAPIAZB+ILSABDDIQALIAYgD0sNBCAPIAZBmIPSABDDIQALIAEgBEHIgtIAEK87AAsgDiAEQdiC0gAQrzsACyAHIARB6ILSABCvOwALIAcgBEGIg9IAEK87AAsgBSAPQQJ0aiAONgIACyAOIAdrIg9B8P8PSw0AAkACQAJAAkAgByAIaiICIARNBEAgBCAIIA5qIgFJDQEgAiADaiAEIAJrIAEgA2ogBCABayASIAFrELIgIQIgDiAAayIBIAsQpA4gDCARQQFqNgIAIAEgFUsNAiAAIA5LDQMgFyABIAAgA2ogAUHog9IAENUsIAkgFSABayIVNgIEIAkgASAXaiIXNgIAIAogASAYaiIYNgIAIA8gEEcEQCAPIAsQ6x4MBQsgCygCBCIABEAgCygCACIBQcAANgIAIAsgAEEBazYCBCALIAFBBGo2AgAgECEPDAULQQBBAEH4g9IAEMMhAAsgAiAEQaiD0gAQrzsACyABIARBuIPSABCvOwALIAEgFUHIg9IAELA7AAsgACAOQdiD0gAQsTsACyAMIBFBAmoiEDYCAAJ/AkACQAJAAkACQCACIAhqIgJBDE8EQCACQcgATwRAIAJBiAFPBEAgCygCBCEAIAJByBBPBEAgAEUNBCALKAIAIgEgAkEIdEHBjyFrNgIAIABBAUcEQAwJC0EAQQBByIDSABDDIQALIABFDQQgCygCACIBIAJByABrIgdnQSBqQT9zIhNBfyATdCAHakEIdHJBNGo2AgAgAEEBRwRADAgLQQBBAEHogNIAEMMhAAsgCygCBCIARQ0EIAsoAgAiASACQQhrIgdBBXZBNmogB0EIdEGAPnFyNgIAIABBAUcEQCABQcAANgIEIAFBCGohASAAQQJrIQBBAgwIC0EAQQBBiIHSABDDIQALIAsoAgQiAQRAIAsoAgAiEyACQQhrIgAgACAAZ0EgakE/c0EBayIAdiIRIAB0a0EIdCARIABBAXRqQRxqcjYCACABQQFrIQAgE0EEaiEBQQEMBwtBAEEAQZiB0gAQwyEACyALKAIEIgBFDQMgCygCACIBIAJBFGo2AgAgAEEBayEAIAFBBGohAUEBDAULQQBBAEG4gNIAEMMhAAtBAEEAQdiA0gAQwyEAC0EAQQBB+IDSABDDIQALQQBBAEGogdIAEMMhAAsgAUHAADYCBCABQQhqIQEgAEECayEAQQILIQcgCyAANgIEIAsgATYCACAMIAcgEGoiETYCACACIA5qIgAgFE8NBAJAAkACQAJAAkACQAJAAkACQAJAIAhBBEYEQCAEIABBA2siAUkNASANQgA3AwAgBCABa0EHTQ0QIA1BCCABIANqQQhByI7SABDVLCAGIA01AgAiG0KAgICA0Pfpmh5+IByIpyICTQ0CIA0xAAYhHiANMQAFIA0xAAQhICAFIAJBAnRqIgIgATYCACAGIBsgIEIghoQiG0IYhkKAgICAcINCvc/W8QF+IByIpyIBTQ0DQiiGIB5CMIaEIBuEQgiGQoCAgIBwgyEbIAUgAUECdGogAEECazYCACACIABBAWs2AgAMCgsgAEEETQ0DIAQgAEEFayIBSQ0EIA1CADcDACAEIAFrQQdNDQ8gDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NBSAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciAU0NBiAFIAFBAnRqIABBBGs2AgAgBiAbQhCIIB2GQr3P1vEBfiAciKciAU0NByAFIAFBAnRqIABBA2s2AgAgDUIANwMAIAQgAEECayIBa0EHTQ0PIA1BCCABIANqQQhByI7SABDVLCAGIA0pAwAiGyAdhkK9z9bxAX4gHIinIgJNDQggBSACQQJ0aiABNgIAIBtCCIggHYZCvc/W8QF+IByIpyIBIAZJBEAgG0IQiCAdhiEbIAUgAUECdGogAEEBazYCAAwKCyABIAZBuIXSABDDIQALIAEgBEGIhNIAEK87AAsgAiAGQZiE0gAQwyEACyABIAZBqITSABDDIQALQbiE0gBBH0HYhNIAEJ8pAAsgASAEQeiE0gAQrzsACyACIAZB+ITSABDDIQALIAEgBkGIhdIAEMMhAAsgASAGQZiF0gAQwyEACyACIAZBqIXSABDDIQALIBtCvc/W8QF+IByIpyIBIAZPBEAgASAGQciF0gAQwyEACyAFIAFBAnRqIgEoAgAhDiABIAA2AgACQAJAIAAgDmsiB0Hw/w9LDQACQAJAAkACQAJAAkACQAJAA0ACQCAHIRAgACAESw0AIAQgDkkNAiAAIANqIAQgAGsgAyAOaiAEIA5rIAgQqBFFDQogBCAIIA5qIgJJDQMgBCAAIAhqIgFJDQQCfyACIANqIAQgAmsgASADaiAEIAFrIBIgAWsQsiAgCGoiAkEKTwRAIAJBhgFPBEAgCygCBCEHIAJBxhBPBEAgAkEIdEHBiyFrIAcNAxpBAEEAQbiB0gAQwyEACyAHBEAgAkHGAGsiAWdBIGpBP3MiD0F/IA90IAFqQQh0ckE0agwDC0EAQQBByIHSABDDIQALIAsoAgQiBwRAIAJBBmsiASABIAFnQSBqQT9zQQFrIgF2Ig8gAXRrQQh0IA8gAUEBdGpBLGpyDAILQQBBAEHYgdIAEMMhAAsgCygCBCIHRQ0GIAJBJmoLIQEgCygCACIPIAE2AgAgCyAHQQFrNgIEIAsgD0EEajYCACAQIAsQ6x4gDCARQQJqIhE2AgAgACACaiIAIBRPDRAgAEEETQ0GAkACQAJAAkACQAJAAn4CQAJAAkAgCEEERwRAIAQgAEEFayIBSQ0SIA1CADcDACAEIAFrQQdNDRwgDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NASAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciAU0NAiAFIAFBAnRqIABBBGs2AgAgBiAbQhCIIB2GQr3P1vEBfiAciKciAUsNAyABIAZB2IbSABDDIQALIAQgAEEDayIBSQ0SIA1CADcDACAEIAFrQQdNDRsgDUEIIAEgA2pBCEHIjtIAENUsIAYgDTUCACIbQoCAgIDQ9+maHn4gHIinIgJNDQYgDTEABiEeIA0xAAUhHyANMQAEISAgBSACQQJ0aiABNgIAIAYgGyAgQiCGhCIbQhiGQoCAgIBwg0K9z9bxAX4gHIinIgFNDQcgBSABQQJ0aiAAQQJrNgIAIAYgH0IohiAeQjCGhCAbhCIbQhCGQoCAgIBwg0K9z9bxAX4gHIinIg5NDQggG0IIhkKAgICAcIMMAwsgAiAGQbiG0gAQwyEACyABIAZByIbSABDDIQALIAUgAUECdGogAEEDazYCACANQgA3AwAgBCAAQQJrIgFrQQdNDRAgDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NASAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciDk0NAiAbQhCIIB2GCyEbIAUgDkECdGogAEEBazYCACAGIBtCvc/W8QF+IByIpyIBSw0FIAEgBkHIh9IAEMMhAAsgAiAGQeiG0gAQwyEACyAOIAZB+IbSABDDIQALIAIgBkGYh9IAEMMhAAsgASAGQaiH0gAQwyEACyAOIAZBuIfSABDDIQALIAUgAUECdGoiASgCACEOIAEgADYCACAQIQ8gACAOayIHQfH/D0kNAQwLCwsgACAEQdiF0gAQrzsACyAOIARB6IXSABCvOwALIAIgBEH4hdIAEK87AAsgASAEQYiG0gAQrzsAC0EAQQBB6IHSABDDIQALQbiE0gBBH0GYhtIAEJ8pAAsgASAEQaiG0gAQrzsACyABIARBiIfSABCvOwALDAcLIA8hEAsgAEEBaiEOIAAgBEkEQCADIA5qIAQgDmsgFiAIEPodIQ8gAEECaiIHIBRLDQUMAwsgDiAEQdiH0gAQrzsACyACQQV2IQcgAkEBaiECIBMhDyAUIAcgASIOaiIHTw0ACwsMAQsgDiAEQbiC0gAQrzsACwJAAkAgACASSQRAIBIgAGsiASALEKQOIAwgDCgCAEEBajYCACAJKAIEIgIgAUkNASAEIBJJDQIgCSgCACIEIAEgACADaiABQYiI0gAQ1SwgCSACIAFrNgIEIAkgASAEajYCACAKIAooAgAgAWo2AgALIA1BIGokAA8LIAEgAkHoh9IAELA7AAsgEiAEQfiH0gAQsDsACyANQQA2AhggDUEBNgIMIA1BwP/RADYCCCANQgQ3AhAgDUEIakG4jtIAEO8sAAvfIAIRfwZ+IwBBgANrIgUkACABQegAaiEMQQEhBgJAAkACQAJAAkACQAJAAkACQAJAIAEpA2hCA1IEQCABKALQASIHQQBIDQEgASgC1AEiBkEASA0BIAYgB2oiByABKAL4AUoNASAHQQBIBEBBASEEIAVBATYCTCAFQay+zQA2AkggBUIBNwJUIAVBpgQ2AqwCIAUgBUGoAmo2AlAgBSAFQRRqNgKoAiAAQQxqIAVByABqEJkOIABBADYCCCAAQgw3AwAMBgsgAS0A2AEiBkECRiAGciEGCyAEQQBHIAZxIhANASAFQQhqIAJBCGopAgA3AwAgBSACKQIANwMADAMLIAVBBDYCrAIgBUGc/c0ANgKoAiAFQgM3ArQCIAVBnAM2AlwgBSABQfgBajYCWCAFQZwDNgJUIAUgAUHUAWo2AlAgBUGcAzYCTCAFIAFB0AFqNgJIIAUgBUHIAGo2ArACIAVB0AFqIAVBqAJqEJkOIABBADYCCCAAIAUpAtABNwIMIABBFGogBUHYAWooAgA2AgAgAEIMNwMADAELIAEoAvgBIgZBAEgEQCAFQQE2AkwgBUGsvs0ANgJIIAVCATcCVCAFQaYENgKsAiAFIAVBqAJqNgJQIAUgBUEUajYCqAIgAEEMaiAFQcgAahCZDiAAQQA2AgggAEIMNwMADAELIAUgBjYCECAFQcgAaiIIIAZBAEEBQQEQoBggBSgCTCEJAkACQAJAAkAgBSgCSEEBRwRAIAVBADYCyAEgBSAFKAJQNgLEASAFIAk2AsABIAcgAigCCCIJSw0BIAVBwAFqIgogAigCBCAHEKE2IAYgB0YNAyACKAIIIgkgB0kNAiAIIAQoAgAgAigCBCAHaiAJIAdrIApBASAGIAdrIAQoAgQoAhARCwAgBSgCSCIEQQhGDQMgACAFKQNQNwMQIABBGGogBUHYAGopAwA3AwAgACAFKAJMNgIMIAAgBDYCCAwECyAJIAUoAlBBvP3NABD9LwALIAcgCUHM/c0AELA7AAsgByAJQez9zQAQrzsACyAGIAUoAsgBIgRGBEAgBUHQAGogBUHIAWooAgA2AgAgBSAFKQLAATcDSCAFIAVByABqEOcVDAMLIAUgBDYCFCAFQQM2AkwgBUG8/s0ANgJIIAVCAjcCVCAFQTs2ArQCIAVBOzYCrAIgBSAFQagCajYCUCAFIAVBEGo2ArACIAUgBUEUajYCqAIgBUHQAWogBUHIAGoQmQ4gAEEANgIIIAAgBSkC0AE3AgwgAEEUaiAFQdgBaigCADYCAAsgAEIMNwMAIAVBwAFqEN47C0EBIQQMAQsCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAvQBDgQCAAEDAAsgBUECNgJMIAVBgP/NADYCSCAFQgE3AlQgBUHmBjYCrAIgBSABQfQBajYCqAIgBSAFQagCajYCUCAFQcgAakGQ/80AEO8sAAsgAS0A8AEiB0EDRw0CQQEhByAFQcgAakEeQQBBAUEBEKAYIAUoAkwhBCAFKAJIQQFHDQcgBCAFKAJQQbT1zQAQ/S8ACyABKQMAIhZCA1INA0EBIQRBACEHIAVBqAJqQRtBAEEBQQEQoBggBSgCrAIhBiAFKAKoAkEBRw0CDBALIAwpAwAiFkIDUg0EQQEhB0EAIQQgBUGoAmpBG0EAQQFBARCgGCAFKAKsAiEGIAUoAqgCQQFHDQMMDwsgBUGwAmogBUEIaikDADcDACAFIAUpAwA3A6gCIAEoAugBIgNBAEgEQEEBIQcgBUEBNgJMIAVBrL7NADYCSCAFQgE3AlQgBUGmBDYC1AEgBSAFQdABajYCUCAFIAVBFGo2AtABIABBDGogBUHIAGoQmQ4gAEEANgIIIABCDDcDACAFQbQCaiAFKAKsAiAFKAKwAiAFKAKoAigCEBEBAEEBIQQMBwsgBUHIAGogASgC7AEQxhogBS0ATCEIIAUoAkgiBEEIRwRAIAAgBSkATTcADSAAQRxqIAVB3ABqKAAANgAAIABBFWogBUHVAGopAAA3AAAgACAIOgAMIAAgBDYCCCAAQgw3AwAgBUG0AmogBSgCrAIgBSgCsAIgBSgCqAIoAhARAQBBASEHQQEhBAwHCyAHQQFxIQogBSkDqAIhFyAFKQOwAiEWQgshGAwHCyAFKAKwAiIDQRdqQdX/zQAoAAA2AAAgA0EQakHO/80AKQAANwAAIANBCGpBxv/NACkAADcAACADQb7/zQApAAA3AAAgAEEbNgIUIAAgAzYCECAAIAY2AgwgAEEANgIIIABCDDcDAAwECyABKQMIIRcgASkDECEYIAEpAxghGSAFQegAaiABQSBqQcgA/AoAACAFIBk3A2AgBSAYNwNYIAUgFzcDUCAFIBY3A0ggBUHIAWogBUEIaikDADcDACAFIAUpAwA3A8ABIAUoAqABIgdBAEgEQEEBIQQgBUEBNgKsAiAFQay+zQA2AqgCIAVCATcCtAIgBUGmBDYC1AEgBSAFQdABajYCsAIgBSAFQRRqNgLQASAAQQxqIAVBqAJqEJkOQQAhByAAQQA2AgggAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAULIAVBqAJqIAUoAqQBEMYaIAUtAKwCIQQCQAJAIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIAQ6AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiAFKAKoARDGGiAFLQCsAiEOIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIA46AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiAFKAKsARDGGiAFLQCsAiEPIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIA86AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiIGIAVByABqQdgA/AoAACAFQdABaiADIAYQqgIgBSkD6AEhGSAFLwHmASENIAUtAOUBIQogBS0A5AEhCCAFKALgASEDIAUpA9gBIRYgBSkD0AEiF0IJUg0BIAAgGTcDGCAAIA07ARYgACAKOgAVIAAgCDoAFCAAIAM2AhAgACAWNwMIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBAAtBASEEQQAhBwwFCyAFQRhqIAVB8AFqQTD8CgAAIAUpA6ACIRogBSkDwAEhGyAFKALIASEGIAUoAswBIRFBASESQgkhGAwFCyAFKAKwAiIDQRdqQfD/zQAoAAA2AAAgA0EQakHp/80AKQAANwAAIANBCGpB4f/NACkAADcAACADQdn/zQApAAA3AAAgAEEbNgIUIAAgAzYCECAAIAY2AgwgAEEANgIIIABCDDcDAAwCCyABKQNwIRcgASkDeCEYIAEpA4ABIRkgBUHoAGogAUGIAWpB2AD8CgAAIAUgGTcDYCAFIBg3A1ggBSAXNwNQIAUgFjcDSCAFLQC4ASELIAVByAFqIAVBCGopAwA3AwAgBSAFKQMANwPAASAFKAKgASIGQQBIBEBBASEHIAVBATYCrAIgBUGsvs0ANgKoAiAFQgE3ArQCIAVBpgQ2AtQBIAUgBUHQAWo2ArACIAUgBUEUajYC0AEgAEEMaiAFQagCahCZDkEAIQQgAEEANgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwDCyAFQagCaiAFKAKsARDGGiAFLQCsAiEJAkACQCAFKAKoAiIEQQhHBEAgACAFKQCtAjcADSAAQRxqIAVBvAJqKAAANgAAIABBFWogBUG1AmopAAA3AAAgACAJOgAMIAAgBDYCCCAAQgw3AwAgBUHMAWogBSgCxAEgBSgCyAEgBSgCwAEoAhARAQAgBUHIAGoQ8SsMAQsgBSgCpAEiEUEASARAIABBCGoQ2yQgAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAELIAUoAqgBIgdBAEgEQCAAQQhqENskIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFKAKwASIEQQBIBEAgAEEIahDbJCAAQgw3AwAgBUHMAWogBSgCxAEgBSgCyAEgBSgCwAEoAhARAQAgBUHIAGoQ8SsMAQsgBSgCtAEiE0EASARAIABBCGoQ2yQgAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAELIAVBqAJqIgggBUHIAGpB2AD8CgAAIAVB0AFqIAMgCBCqAiAFLwHuASENIAUtAO0BIQogBS0A7AEhCCAFKALoASEDIAUpA+ABIRYgBSkD2AEhFyAFKQPQASIYQglSDQEgACANOwEeIAAgCjoAHSAAIAg6ABwgACADNgIYIAAgFjcDECAAIBc3AwggAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAC0EAIQRBASEHDAMLIAUpA/ABIRkgBUEYaiAFQfgBakEw/AoAACALQQJGIAtyQQFxIRQgBEGAgID4B3EhCyAEQRB2IQ8gBEEIdiEOIAUpA8ABIRogBSkDyAEhG0EBDAQLIAUoAlAiA0EWakG2/80AKQAANwAAIANBEGpBsP/NACkAADcAACADQQhqQaj/zQApAAA3AAAgA0Gg/80AKQAANwAAIABBHjYCFCAAIAM2AhAgACAENgIMIABBADYCCCAAQgw3AwBBASEECyAFQQxqIAUoAgQgBSgCCCAFKAIAKAIQEQEACyAQDQMMBAtBAAsgACAZNwMgIAAgDTsBHiAAIAo6AB0gACAIOgAcIAAgAzYCGCAAIBY3AxAgACAXNwMIIAAgGDcDACAAQShqIAVBGGpBMPwKAAAgACAJOgB9IAAgFDoAfCAAIBM2AnggACAHNgJwIAAgETYCbCAAIAY2AmggACAbNwNgIAAgGjcDWCAAIARB/wFxIA9B/wFxQRB0IAtyIA5B/wFxQQh0cnI2AnQgEARAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIBIgASkDAEIDUXJFBEAgARDxKwsgDCkDAEIDUXINBAwDC0EBIQcLIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALAkAgB0UNACABKQMAQgNRDQAgARDxKwsgBEUNASAMKQMAQgNRDQELIAwQ8SsLIAVBgANqJAAPCyAGIAUoArACQbT1zQAQ/S8AC4guAhF/AX4jAEHQBGsiAyQAIAMgAjYCeEEBIQYCQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAIAEtAAAiBEECaw4lBgABAgYAAQIAAQICAQIBAgIDBwcHBwcHBwcHBwcHBwcHAQIEBQcLQQIhBgwFC0EEIQYMBAtBCCEGDAMLIAEtAAFBAnRB/ISHAWooAgAhBgwCC0EQIQYMAQtBICEGC0EMQQQQrTYiB0UNBSADQZQDaiACIAZsENIfIAMgAykClAM3AvwDIANBADYC+AMgAyADKAKgAyIENgL0AyADIAMoApwDNgLwAyADQfAAaiADQfADahDXOyADKAJwIQgMAwtBBCEHIAQhBUEEIQYgBCEIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBA4pHwEAAAAAAAAAAAAAAAAAAAAAAAACAwQFAgQFDAAGBwALCAkAAAAADAoACyADIAE2ArQCIANBATYC9AMgA0G45oYBNgLwAyADQgE3AvwDIANBpwQ2ApgDIAMgA0GUA2o2AvgDIAMgA0G0Amo2ApQDIANB8ANqQcDmhgEQ7ywAC0EMQQQQrTYiB0UNHiADQZQDaiACQQN2IAJBB3FBAEdqENIfIAMgAykClAM3AvwDQQAhBSADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0EIaiADQfADahDXOyADKAIIIQgMHAtBGEEEEK02IgdFDREgA0GUA2oiCiACQQJ0QQRqENIfIAMgAykClAM3AvwDIANBADYC+AMgAyADKAKgAyIFNgL0AyADIAMoApwDNgLwAyADQRhqIANB8ANqIgQQ1zsgAygCGCEIQRxBBBCtNiICRQ0fIAJCgYCAgBA3AgAgAiADKQLwAzcCCCACQRBqIANB+ANqIg8pAgA3AgAgAkEYaiADQYAEaiIMKAIANgIAIApBABDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiCTYC9AMgAyADKAKcAzYC8AMgA0EQaiAEENc7IAMoAhAhCkEcQQQQrTYiBEUNHyAEQoGAgIAQNwIAIAQgAykC8AM3AgggBEEQaiAPKQIANwIADBoLQQxBBBCtNiIHRQ0cIANBlANqIAEoAgQgAmwQ0h8gAyADKQKUAzcC/ANBACEFIANBADYC+AMgAyADKAKgAyIENgL0AyADIAMoApwDNgLwAyADQSBqIANB8ANqENc7IAMoAiAhCAwaC0EYQQQQrTYiB0UNECADQZQDaiIKIAJBA3RBCGoQ0h8gAyADKQKUAzcC/AMgA0EANgL4AyADIAMoAqADIgU2AvQDIAMgAygCnAM2AvADIANBMGogA0HwA2oiBBDXOyADKAIwIQhBHEEEEK02IgJFDR0gAkKBgICAEDcCACACIAMpAvADNwIIIAJBEGogA0H4A2opAgA3AgAgAkEYaiADQYAEaiIMKAIANgIAIApBABDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiCTYC9AMgAyADKAKcAzYC8AMgA0EoaiAEENc7IAMoAighCkEcQQQQrTYiBEUNHSAEQoGAgIAQNwIAIAQgAykC8AM3AgggBEEQaiADQfgDaikCADcCAAwYC0EMQQQQrTYiB0UNGiADQZQDaiACQQR0ENIfIAMgAykClAM3AvwDQQAhBSADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0E4aiADQfADahDXOyADKAI4IQgMGAtBxABBBBCtNiIGRQ0aIAYgASgCCEEwaiABKAIEIAJsEK8BQQEhBUEADBULQQxBBBCtNiIHRQ0YIANBlANqIAJBA3RBCGoQ0h8gAyADKQKUAzcC/AMgA0EANgL4AyADIAMoAqADIgQ2AvQDIAMgAygCnAM2AvADIANByABqIANB8ANqENc7IAMoAkghAkEcQQQQrTYiBUUNGiAFQoGAgIAQNwIAIAUgAykC8AM3AgggBUEQaiADQfgDaikCADcCACAFQRhqIANBgARqKAIANgIAIAcgBDYCCCAHIAI2AgQgByAFNgIAQcQAQQQQrTYiBkUNGSAGIAEoAgRBMGpBABCvAQwTCyADQeAAaiABQQRqIgoQsC4gAygCYCIEIAMoAmRGDQ0gBC0AACEEIwBBMGsiDCQAIAxBEGohCCMAQSBrIgkkACAJQRRqIAJBAEEBQQEQoBggCSgCGCEFAkAgCSgCFEEBRwRAIAlBADYCECAJIAkoAhw2AgwgCSAFNgIIIAlBCGogAhCBLiAJKAIQIQUgAgRAIAIEQCAJKAIMIAVqIAQgAvwLAAsgAiAFaiEFCyAIIAkpAgg3AgAgCEEIaiAFNgIAIAlBIGokAAwBCyAFIAkoAhxBhKSHARD9LwALIAwoAhQhAiAMKAIYIQUgDCAMKAIQNgIsIAxCgICAgBA3AiQgDCAFNgIgIAwgAjYCHCAMQQhqIAxBHGoQ1zsgDCgCCCECQRxBBBCtNiIIRQ0ZIAhCgYCAgBA3AgAgCCAMKQIcNwIIIANB/ABqIgQgBTYCCCAEIAI2AgQgBCAINgIAIAhBEGogDEEkaikCADcCACAIQRhqIAxBLGooAgA2AgAgDEEwaiQAIAFBAWoiCC0AAA0EQQwQyy8iB0EIaiADQYQBaigCADYCACAHIAMpAnw3AgBBAQwFC0EMQQQQrTYiB0UNFkEBIQQCQAJAAkACQAJAAkACQAJAIAEoAgQiBS0AAEECaw4lBwYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAULQQQhBAwGC0EIIQQMBQsgBS0AAUECdEH8hIcBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtB8OSGARCyOwALQQIhBAsgA0GUA2ogAiAEbBDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0HoAGogA0HwA2oQ1zsgAygCaCECQRxBBBCtNiIFRQ0YIAVCgYCAgBA3AgAgBSADKQLwAzcCCCAFQRBqIANB+ANqKQIANwIAIAVBGGogA0GABGooAgA2AgAgByAENgIIIAcgAjYCBCAHIAU2AgBBxABBBBCtNiIGRQ0XIAYgASgCCEEAEK8BDBELIAEoAgQiBEEwaiEIIAQtADBBA2sOAwUGBwQLIANB0ABqIAFBBGoQwzQgAygCVCEEIAMgAygCUCICNgLwAyADIAIgBEECdGo2AvQDIAMgA0H4AGo2AvgDIwBBIGsiDiQAIA5BFGogA0HwA2oiAigCBCACKAIAa0ECdkEAQQRBxAAQoBggDigCGCEEIA4oAhRBAUYEQCAEIA4oAhxByNqGARD9LwALIANBlANqIQ8gDkEQaiIKQQA2AgAgDiAOKAIcNgIMIA4gBDYCCCMAQRBrIg0kACACKAIEIAIoAgBrQQJ2IgQgDkEIaiIFKAIAIAUoAggiC2tLBEAgBSALIARBBEHEABDeKCAFKAIIIQsLIA0gBSgCBDYCDCANIAs2AgggDSAFQQhqNgIEIwBB0ABrIgwkACANQQRqIgkoAgQhBiAJKAIAIAIoAgAiCyACKAIEIgVHBEAgAigCCCEEIAkoAgggBkHEAGxqIQkgBiAFIAtrQQJ2IgVqIQYDQCAMQQxqIgIgCygCAEEwaiAEKAIAEK8BIAkgAkHEAPwKAAAgC0EEaiELIAlBxABqIQkgBUEBayIFDQALCyAGNgIAIAxB0ABqJAAgDUEQaiQAIA9BCGogCigCADYCACAPIA4pAgg3AgAgDkEgaiQAIAMoApQDIQUgAygCmAMhBiADKAKcAyEIQQEhE0EAIQQMEwtBDEEEEK02IgdFDRMgA0GUA2ogAkECdEEEahDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0FAayADQfADahDXOyADKAJAIQJBHEEEEK02IgVFDRUgBUKBgICAEDcCACAFIAMpAvADNwIIIAVBEGogA0H4A2opAgA3AgAgBUEYaiADQYAEaigCADYCACAHIAQ2AgggByACNgIEIAcgBTYCAEHEAEEEEK02IgZFDRQgBiABKAIEQTBqQQAQrwEMDgsgAygCeCICQQBIDQlBGBDLLyEHIwBBMGsiCyQAIAtBEGohCUEAIQwjAEEgayINJAAgDUEUaiACQQAgAkEAShtBAEEEQQQQoBggDSgCGCEEIA0oAhRBAUYEQCAEIA0oAhxBhKSHARD9LwALIA1BEGoiBUEANgIAIA0gDSgCHDYCDCANIAQ2AgggAkEAIAJBAEobIgQgDUEIaiIPKAIAIA8oAggiBmtLBEAgDyAGIARBBEEEEN4oIA8oAgghBgsgDyACQQBKBH8gAiAGaiAPKAIEIAZBAnRqIQYDQCAGIAw2AgAgBkEEaiEGIAIgDEEBaiIMRw0ACwUgBgs2AgggCUEIaiAFKAIANgIAIAkgDSkCCDcCACANQSBqJAAgCygCFCEFIAsoAhghAiALIAsoAhBBAnQ2AiwgC0KAgICAwAA3AiQgCyACQQJ0IgQ2AiAgCyAFNgIcIAtBCGogC0EcahDXOyALKAIIIQJBHEEEEK02IglFDRQgCUKBgICAEDcCACAJIAspAhw3AgggA0HwA2oiBSAENgIIIAUgAjYCBCAFIAk2AgAgCUEQaiALQSRqKQIANwIAIAlBGGogC0EsaigCADYCACALQTBqJAAgB0EIaiADQYQBaigCADYCACAHIAMpAnw3AgAgByADKQLwAzcCDCAHQRRqIANB+ANqKAIANgIAQQILIQQgA0HYAGogChCwLiADKQNYIRQgAyAINgL8AyADQQA2AvgDIAMgFDcC8AMgAyADQfgAajYCgAQjAEEgayIRJAAgEUEUaiADQfADaiICKAIEIAIoAgBrQQN2QQBBBEHEABCgGCARKAIYIQUgESgCFEEBRgRAIAUgESgCHEHI2oYBEP0vAAsgA0GIAWohDCARQRBqIgpBADYCACARIBEoAhw2AgwgESAFNgIIIwBBIGsiEiQAIAIoAgQiCSACKAIAIgZrQQN2IgUgEUEIaiIIKAIAIAgoAggiEGtLBEAgCCAQIAVBBEHEABDeKCAIKAIIIRALIAgoAgQhBSACKQIMIRQgEiACKAIINgIcIBIgFDcCFCASIAU2AhAgEiAQNgIMIBIgCEEIajYCCCMAQdAAayIOJAAgEkEIaiIQKAIEIQsgECgCACAGIAlHBEAgECgCFCEPIBAoAhAhBSAQKAIMIQIgBkEEaiENIBAoAgggC0HEAGxqIRAgCyAJIAZrQQN2IglqIQsDQAJAAkAgD0UNACACLQAARQ0AIA5BDGogDSgCAEEwakEAEK8BDAELIA5BDGogDSgCAEEwaiAFKAIAEK8BCyAQIA5BDGpBxAD8CgAAIA1BCGohDSAQQcQAaiEQIA9BAWohDyAJQQFrIgkNAAsLIAs2AgAgDkHQAGokACASQSBqJAAgDEEIaiAKKAIANgIAIAwgESkCCDcCACARQSBqJAAgAygCkAEhCCADKAKMASEGIAMoAogBIQUMEAsgAyAINgK0AiADQQE2AvQDIANB9OWGATYC8AMgA0IBNwL8AyADQacENgKYAyADIANBlANqNgL4AyADIANBtAJqNgKUAyADQfADakH85YYBEO8sAAsgAkGAgAJPDQcgA0GUA2ohCiMAQSBrIgQkAAJAQcAAQcAAENE0BEBBwABBwAAQrTYiBUUNFSAFIAI7AQAgBELAgICAgAg3AhggBEICNwIQIAQgBTYCDCAEIARBDGoQ1zsgBCgCACECQRxBBBCtNiIFRQ0TIAVCgYCAgBA3AgAgBSAEKQIMNwIIIApBAjYCCCAKIAI2AgQgCiAFNgIAIAVBEGogBEEUaikCADcCACAFQRhqIARBHGooAgA2AgAgBEEgaiQADAELDBMLDAILIAJBAEgNByADQZQDaiEKIwBBIGsiBCQAAkBBwABBwAAQ0TQEQEHAAEHAABCtNiIFRQ0UIAUgAjYCACAEQsCAgICACDcCGCAEQgQ3AhAgBCAFNgIMIAQgBEEMahDXOyAEKAIAIQJBHEEEEK02IgVFDRIgBUKBgICAEDcCACAFIAQpAgw3AgggCkEENgIIIAogAjYCBCAKIAU2AgAgBUEQaiAEQRRqKQIANwIAIAVBGGogBEEcaigCADYCACAEQSBqJAAMAQsMEgsMAQsgAyACrTcD8AMgA0GUA2ohBSADQfADaiECIwBBIGsiCiQAAkBBwABBwAAQ0TQEQEHAAEHAABCtNiIERQ0TIAQgAikDADcDACAKQsCAgICACDcCGCAKQgg3AhAgCiAENgIMIAogCkEMahDXOyAKKAIAIQJBHEEEEK02IgRFDREgBEKBgICAEDcCACAEIAopAgw3AgggBUEINgIIIAUgAjYCBCAFIAQ2AgAgBEEQaiAKQRRqKQIANwIAIARBGGogCkEcaigCADYCACAKQSBqJAAMAQtB+KSHAUEpIApBDGpB/KWHAUGkpYcBENUeAAsLIANBkARqIAgQ2gYgA0EAOwHIBCADQQA2AsQEIANBADYCrAQgA0IBNwKcBCADQgQ3AogEIANCADcCgAQgA0KAgICAwAA3AvgDIANBADYC8ANBDEEEEK02IgRFDQwgBCADKQKUAzcCACAEQQhqIANBnANqKAIANgIAIANB+ANqIgIQxScgAkEEQQwQ4B4gA0EBNgKABCADIAQ2AvwDIANBATYC+AMgA0GUAWoiBCADQfADakHcAPwKAAAgA0HwAWoiAiAEEM0cQYgBQQQQrTYiBkUNBiAGQcQAaiABKAIIQTBqQQEQrwEgBiACQcQA/AoAAEEAIQRBAiEFQQIhCAwLC0EEQRgQoz0AC0EEQRgQoz0AC0HQ5IYBELI7AAtB4OSGARCyOwALQYDlhgFBDEGM5YYBEMskAAtBgOWGAUEMQZzlhgEQyyQAC0EEQYgBEKM9AAtBASEFQQELIQRBASEIQQEhEwwCCyAEQRhqIAwoAgA2AgAgByAJNgIUIAcgCjYCECAHIAQ2AgwgByAFNgIIIAcgCDYCBCAHIAI2AgBBASETQQAhBUECIQRBACEIDAELQRxBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAiADKQLwAzcCCCACQRBqIANB+ANqKQIANwIAIAJBGGogA0GABGooAgA2AgAgByAENgIIIAcgCDYCBCAHIAI2AgBBASEEQQQhBkEAIQhBASETCyADQZAEaiABENoGIANBADsByAQgA0EANgLEBCADQQA2AqwEIANBADYCoAQgA0IENwKIBCADQgA3AoAEIANCgICAgMAANwL4AyADQQA2AvADIAMgAygCeDYCnAQgA0H4A2oiARDFJyABQQRBDBDgHiADIAQ2AoAEIAMgBzYC/AMgAyAENgL4AyADQZQDaiADQfADakHcAPwKAAAgAygCsAMiBARAIAMoAqwDIQcDQCAHEKUeIAdBxABqIQcgBEEBayIEDQALCyADQagDakEEQcQAEOAeIAMgCDYCsAMgAyAGNgKsAyADIAU2AqgDIANBuAJqIgQgA0GUA2oiAkHcAPwKAAAgEwRAIANB8ANqIgEgBEHcAPwKAAAgAiADKAJ4EOU6IAQgASACEMIZCyAAIANBuAJqEM0cIANB0ARqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAtBBEEcEKM9AAtB+KSHAUEpIARBDGpB/KWHAUGkpYcBENUeAAtBwABBwAAQoz0AC8gbAhp/AX4jAEFAaiIIJAAgACgCDCAAKAIEIAAoAswBIQsgACgCyAEhDCAIIAAoAhw2AjwgACgChAEhDyAAKAKAASEUIAhBOGpBADYCACAIQgA3AzAgBkEEdEEGIAwgDEEGTxtBA2tBACAMQQNPG0ECdGpB0KvRAGoCQCAAKALUASIGBEAgCEEgaiAGQRBqKAIANgIAIAhBGGogBkEIaikCADcDACAIIAYpAgA3AxAMAQsgCEEgakEANgIAIAhBGGpCADcDACAIQgA3AxALIAxBA0YhDCALQf8fSSEYIAMgBGohFSgCACEZIABB8ABqIRJqIQogCEIANwIkIAhBADYCLCAIQRBqQQAgBBCRFiAAQQA2AqgBIAAoArABIQYCQCAAAn8gACgCjAFFBEAgBEEITQRAIABBATYCqAELIAAoAqwBIgkoAoQIQQJGBEBBACEEIABBADYCqAECQCAGQQJGDQAgAEEANgKIAUEAIQcDQCAHQYACRg0BIAAoAnAgBGpBAUELIAkgB0ECdGotAAQiBmt0QQEgBhsiBjYCACAAIAAoAogBIAZqNgKIASAEQQRqIQQgB0EBaiEHIAAoAqwBIQkMAAsAC0EAIQcgAEEANgKMAUEBIAkvALgZIgRBAWt0QQEgBBtBAnQgCWpBwBlqIQQgACgCdCEGA0AgB0GQAUcEQCAGIAdqQQFBAUEKIAQoAgBB//8DaiIOQRB2a3QgDkGAgARJGyIONgIAIAAgDiAAKAKMAWo2AowBIARBCGohBCAHQQRqIQcMAQsLQQAhByAAQQA2ApABQQEgCS8AjA4iBEEBa3RBASAEG0ECdCAJakGUDmohBCAAKAJ4IQYDQCAHQdQBRwRAIAYgB2pBAUEBQQogBCgCAEH//wNqIg5BEHZrdCAOQYCABEkbIg42AgAgACAOIAAoApABajYCkAEgBEEIaiEEIAdBBGohBwwBCwtBACEHIABBADYClAFBASAJLwCICCIEQQFrdEEBIAQbQQJ0IAlqQZAIaiEEIAAoAnwhBgNAIAdBgAFGDQQgBiAHakEBQQFBCiAEKAIAQf//A2oiDkEQdmt0IA5BgIAESRsiDjYCACAAIA4gACgClAFqNgKUASAEQQhqIQQgB0EEaiEHDAALAAsgBkECRwRAIAhB/wE2AgQgACgCcCAIQQRqIAMgBBCYFRogACAAKAJwQf8BQQhBABDjJTYCiAELIAAoAnRBgKzRAEGQAfwKAAAgAEGArNEAQSQQhiw2AowBIAAoAnghBEEAIQcDQCAHQdQBRwRAIAQgB2pBATYCACAHQQRqIQcMAQsLIABBNTYCkAEgACgCfEGQrdEAQYAB/AoAAEGQrdEAQSAQhiwMAQsgBkECRwRAIAAgACgCcEH/AUEMEMorNgKIAQsgACAAKAJ0QSNBCxDKKzYCjAEgACAAKAJ4QTRBCxDKKzYCkAEgACgCfEEfQQsQyisLNgKUAQtBA0EEIAwbIQ4gC0H/HyAYGyEaIBVBCGshGyASIAUQuhIgD0EcaiEYIBVBIGshFyADIAMgCkZqIRMgAyEMA0ACQAJAAkACfwJAIBMgG0kEQCAIIBQgACAIQTxqIBMgFSACIAwgE0YgDiAZERIANgIEIAhBEGogFCAIQQRqIBMgA2sgFSATaxDdFiAIKAIEIgsEQCATIAxrIRBBACEHA0AgB0EMRwRAIAcgD2pBEGogAiAHaigCADYCACAHQQRqIQcMAQsLIA8gEDYCDCAPQQA2AgggDyAQIBIgBRDkEiIKNgIAIBogFCALQQN0aiIEQQRrKAIAIgZJBEAgBEEIaygCACEJQQAhBAwFC0EBIQdBACASIAUQ5BIhBiAYIQQDQCAHIA5GBEAgBiAKaiEKQQAhCSAOIQQDQCAJIAtHBEAgDyAEQRxsaiEHIBQgCUEDdGoiBigCBCENIAYoAgAhBgNAIAQgDU0EQCAGIAQgEiAFELAOIREgB0EMaiAQNgIAIAdBBGogBjYCACAHQQhqIAQ2AgAgByAKIBFqNgIAIAdBHGohByAEQQFqIQQMAQsLIAlBAWohCQwBCwsgBEEBayEHQQEhDQNAAkAgByANSQ0AIA8gDUEcbGoiCkEca0EBIQYgCkEUaygCAEUEQCAKQRBrKAIAQQFqIQYLIA0gE2ohESgCACEJAn9BgBAgACgCsAFBAkYNABpBgAwgACgCqAFBAUYNABogACgCmAEiEEGAAmshBCAAKAJwIBFBAWstAABBAnRqKAIAQQFqIhZnIQsgECAEAn8gBQRAQR8gC2siC0EIdCAWQQh0IAt2agwBC0GAPiALQQh0awsiC0kEfyAEBSALC2sLIQQCfwJAAkAgBiASIAUQ5BIgBCAJamogBkEBayASIAUQ5BJrIgsgCigCACIETARAIAogBjYCDCAKQgA3AgQgCiALNgIAIApBCGohFgwBCyAKQQhqIRYgCigCCCIGDQEgBCELCyAKIApBDGsiBCkCADcCECAKQRhqIARBCGooAgA2AgBBASEJQQAMAQsgCEEEaiAPIA0gBmtBHGxqQRBqIAooAgQgCigCDEUQjxogCkEYaiAIQQxqKAIANgIAIAogCCkCBDcCEEEAIQkgBCELQQELIQQCQCARIBtLDQAgByANRg0BIAVFBEAgCkEcaigCACALQYABakwNAQtBACEQIAkEQCAKKAIMIRALQQAgEiAFEOQSIAggFCAAIAhBPGogESAVIApBEGogBCAOIBkREgA2AgQgCEEQaiAUIAhBBGogESADayAVIBFrEN0WIAgoAgQiHEUNACAUIBxBA3RqIgRBBGsoAgAiBiAaSyAGIA1qQf8fS3INByALaiEfQQAhEQNAIBEgHEYNASAUIBFBA3RqIgQoAgQhBiAOIQsgEQRAIARBBGsoAgBBAWohCwsgBCgCACEWIAYgDWohCQNAAkAgBiALSQ0AIBYgBiASIAUQsA4gH2ohHQJAAkAgByAGIA1qIh5PBEAgHSAPIB5BHGxqKAIATg0BCyAYIAdBHGxqIQQgByAJIAcgCUsbIgogB2shBwNAIAcEQCAEQYCAgIAENgIAIARBHGohBCAHQQFrIQcMAQsLIA8gHkEcbGoiBCAQNgIMIAQgFjYCBCAEIAY2AgggBCAdNgIAIAohBwwBCyAFRQ0BCyAJQQFrIQkgBkEBayEGDAELCyARQQFqIREMAAsACyANQQFqIQ0MAQsLIAhBOGogDyAHQRxsaiIEQRhqKAIANgIAIAggBCkCEDcDMCAEKAIEIQkgBCgCACEgIAcgBCgCDCIQIAQoAggiBmprIgRBACAEIAdNGwwFBSAEQYCAgIAENgIAIARBHGohBCAHQQFqIQcMAQsACwALIBNBAWohEwwGCyAIQUBrJAAgFSAMaw8LIARBCGsoAgAhCSANIBYoAgAEf0EABSAKKAIMC2siBEEAIARBgCBNGwshBCAGRQ0BCyAIQQRqIA8gBEEcbGpBEGogCSAQRRCPGiACQQhqIAhBDGooAgA2AgAgAiAIKQIENwIADAELIAIgDyAEQRxsaiIGKQIQNwIAIAJBCGogBkEYaigCADYCAEEAIQYLIA8gBEEcbGoiB0EoaiAQNgIAIAdBJGogBjYCACAHQSBqIAk2AgAgB0EcaiAgNgIAIAdBLGogCCkDMDcCACAHQTRqIAhBOGooAgA2AgAgBEEBaiIQIQsDQCAEBEAgDyAEQRxsaiIGKAAMIQogBkEIaiIJKAAAIQ0gB0EYaiAGQRhqKAIANgIAIAdBEGogBkEQaikCADcCACAHQQhqIAkpAgA3AgAgByAGKQIANwIAIAQgCiANamsiBkEAIAQgBk8bIQQgB0EcayEHIAtBAWshCwwBCwsDQAJ/AkAgCyAQTQRAIA8gC0EcbGoiBCgCDCIGIAxqIAQoAggiCkUNAhogBCgCBCEJIAAoArABQQJHBEAgBiEHIAwhBANAIAcEQCASKAIAIAQtAABBAnRqIg0gDSgCAEECajYCACAHQQFrIQcgBEEBaiEEDAELCyAAIAAoAogBIAZBAXRqNgKIAQsgACgCdCAGQcAATwR/QTIgBmdrBSAGQcCu0QBqLQAAC0ECdGoiBCAEKAIAQQFqNgIAIAAgACgCjAFBAWo2AowBIAAoAnxBHyAJZ2tBAnRqIgQgBCgCAEEBajYCACAAIAAoApQBQQFqNgKUASAAKAJ4An8gCkEDayIEQYABTwRAQcMAIARnawwBCyAEQcCv0QBqLQAAC0ECdGoiByAHKAIAQQFqNgIAIAAgACgCkAFBAWo2ApABIAEoAgwhByAXIAYgDGoiDU8EQCAMKQAAISEgB0EIaiAMQQhqKQAANwAAIAcgITcAACAGQRFJDQIgASgCDEEQaiAMQRBqIAZBEGsQ2BkMAgsgDCAXTQRAIAcgDCAXIAxrIgwQ2BkgByAMaiEHIBchDAsDQCAMIA1PDQIgByAMLQAAOgAAIAdBAWohByAMQQFqIQwMAAsACyASIAUQuhIMAwsgASABKAIMIAZqNgIMAkAgBkH//wNNBEAgASgCBCEHDAELIAFBATYCJCABIAEoAgQiByABKAIAa0EDdTYCKAsgByAJNgIAIAcgBjsBBCAEQYCABE8EQCABQQI2AiQgASAHIAEoAgBrQQN1NgIoCyAHIAQ7AQYgASAHQQhqNgIEIAogDWoiDAshEyALQQFqIQsMAAsACwAL4DICE38DfiMAQYACayICJAAgASEDAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAA4pKSorLC0uLzAxAAECAwQFBgcICQoLDA0ODxAREjMTFDMVKBYXGRobHB0zC0H114cBIQVBgICAgHgMMQtB9teHASEFQYCAgIB4DDALQffXhwEhBUGAgICAeAwvC0H414cBIQVBgICAgHgMLgtBBCEKIANBBGohBSADKAIEIQYgAy0AAUEBaw4DGhscGQtBgICAgHghBkGs2IcBIQVBAyEKDDMLQYCAgIB4IQZBr9iHASEFQQMhCgwyC0GAgICAeCEGQbLYhwEhBUEDIQogAy0AAQ4CMR4rC0GAgICAeCEGQbjYhwEhBUEDIQogAy0AAUECaw4CMB4qCyADLQABQQJ0QdDahwFqKAIAIQUMLgsgAy0AAUECdEHg2ocBaigCACEFDC0LQdPYhwEhBUGAgICAeAwmCyACIANBBGo2AiggAkEBNgLMASACQdjYhwE2AsgBIAJCATcC1AEgAkGpCDYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQmQ4MKQtB4NiHASEFQYCAgIB4DCQLQYCAgIB4IQZB4diHASEFQQIhCgwqC0Hj2IcBIQVBgICAgHgMIgtB5NiHASEFQYCAgIB4DCELQYCAgIB4IQZB5diHASEFQQIhCgwnC0GAgICAeCEGQefYhwEhBUECIQoMJgsgAiADQQRqNgIoIAJBATYCzAEgAkHs2IcBNgLIASACQgE3AtQBIAJBqQg2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEJkODCILQYCAgIB4IQZB9NiHASEFQQIhCgwkC0GAgICAeCEGQfbYhwEhBUECIQoMIwsgAygCBCEDDAELCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkGc2YcBNgLIAQweCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkG42YcBNgLIAQwdCyACIANBAWo2AhggAiADQQJqNgIoIAJBAjYCzAEgAkHQ2YcBNgLIAQwcCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkHk2YcBNgLIAQwbC0GAgICAeCEGQfzZhwEhBUECIQoMHAtBgICAgHghBkH+2YcBIQVBAiEKDBsLIAYNA0GAgICAeCEGQfnXhwEhBQwaCyAGDQNBgICAgHghBkGI2IcBIQUMGQsgBg0DQYCAgIB4IQZBlNiHASEFDBgLIAYNA0GAgICAeCEGQaDYhwEhBQwXCyACIAU2AiggAkEBNgLMASACQYDYhwE2AsgBIAJCATcC1AEgAkH5FzYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQvhgMEwsgAiAFNgIoIAJBATYCzAEgAkGM2IcBNgLIASACQgE3AtQBIAJB+Rc2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEL4YDBILIAIgBTYCKCACQQE2AswBIAJBmNiHATYCyAEgAkIBNwLUASACQfkXNgJcIAIgAkHYAGo2AtABIAIgAkEoajYCWCACQZABaiACQcgBahC+GAwRCyACIAU2AiggAkEBNgLMASACQaTYhwE2AsgBIAJCATcC1AEgAkH5FzYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQvhgMEAtBtdiHASEFDBILQbvYhwEhBQwRCyADKAIEQQhqIgUgAygCCEEDdGohByMAQSBrIgokACAKQRRqIAcgBWtBA3ZBAEEEQQwQoBggCigCGCEGIAooAhRBAUYEQCAGIAooAhxBvNWHARD9LwALIApBEGoiEEEANgIAIAogCigCHDYCDCAKIAY2AggjAEEQayIEJAAgByAFa0EDdiIIIApBCGoiBigCACAGKAIIIgtrSwRAIAYgCyAIQQRBDBDcKCAGKAIIIQsLIAJBKGohDiAEIAYoAgQ2AgwgBCALNgIIIAQgBkEIajYCBCMAQTBrIgYkACAEQQRqIggoAgQhCyAIKAIAIRECQAJAAkAgBSAHRwRAIAgoAgggC0EMbGohCCAHIAVrQQN2IQ0DQAJ/IAUsAAAiB0EATgRAQQNBARCtNiIJRQ0EIAYgCTYCKCAGQQM2AiRBAAwBC0EEQQEQrTYiCUUNBCAJQS06AAAgBiAJNgIoIAZBBDYCJEEBCyEJIAZBLGoiEiAJNgIAIAZBIWohCQJAIAcgB8BBB3UiDHMgDGsiDEH/AXEiD0EKSQRAQQMhBwwBCyAJQQJqIAwgD0HkAG4iDEHkAGxrQf8BcUEBdCITQePziQFqLQAAOgAAIAlBASIHaiATQeLziQFqLQAAOgAAC0EAIA8gDEH/AXEbRQRAIAkgB0EBayIHaiAMQQF0Qf4BcUHj84kBai0AADoAAAsgBkEIaiIMQQMgB2s2AgQgDCAHIAlqNgIAIAZBJGogBigCCCIHIAcgBigCDGoQvCYgBkEYaiASKAIAIgc2AgAgBiAGKQIkIhU3AxAgCEEIaiAHNgIAIAggFTcCACAFQQhqIQUgCEEMaiEIIAtBAWohCyANQQFrIg0NAAsLIBEgCzYCACAGQTBqJAAMAgtBAUEDQdzbhwEQ/S8AC0EBQQRB3NuHARD9LwALIARBEGokACAOQQhqIBAoAgA2AgAgDiAKKQIINwIAIApBIGokACADLQABDQsgAkGQAWoiBiACKAIsIgMgAigCMCIEQfjYhwFBARDxAyACQfgcNgIcIAJBATYCzAEgAkGA2YcBNgLIAQwMC0Hs14cBIQVBgICAgHgMCAtB7deHASEFQYCAgIB4DAcLQe7XhwEhBUGAgICAeAwGC0Hv14cBIQVBgICAgHgMBQtB8NeHASEFQYCAgIB4DAQLQfHXhwEhBUGAgICAeAwDC0Hy14cBIQVBgICAgHgMAgtB89eHASEFQYCAgIB4DAELQfTXhwEhBUGAgICAeAshBkEBIQoMBgsgAiADNgIoIAJBAjYCzAEgAkHA2ocBNgLIASACQgE3AtQBIAJBrwM2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEJkOIAIpApABIRUgACACKAKYATYCECAAIBU3AwggAEKBgICA8IGAgIB/NwMADAYLIAJBkAFqIgYgAigCLCIDIAIoAjAiBEH42IcBQQEQ8QMgAkH4HDYCHCACQQE2AswBIAJBjNmHATYCyAELIAJCATcC1AEgAiAGNgIYIAIgAkEYajYC0AEgAkHYAGogAkHIAWoQvhggBkEBQQEQ4B4gAigCWCEGIAIoAlwhBSACKAJgIQogBARAA0AgA0EBQQEQ4B4gA0EMaiEDIARBAWsiBA0ACwsgAkEoakEEQQwQ4B4MAwsgAigCkAEhBiACKAKUASEFIAIoApgBIQoMAgsgAkICNwLUASACQfYcNgKcASACQfccNgKUASACIAJBkAFqNgLQASACIAJBKGo2ApgBIAIgAkEYajYCkAEgAkHYAGogAkHIAWoQmQ4gAigCWCEGIAIoAlwhBSACKAJgIQoMAQtBgICAgHghBkEDIQoLIAIgCjYCFCACIAU2AhAgAiAGNgIMQQQhBAJAIAICfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AACIHQRtrDg4CBAECBAMFBAQEBAQCAAQLQeAAQQgQrTYiA0UNByACQcgBaiABKAIEQQhqEOgMIAIoAsgBRQ0GIAJB6ABqIAJB3AFqKAIAIgE2AgAgAkHgAGogAkHUAWopAgAiFTcDACACIAIpAswBIhY3A1ggAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIANB4ABBCBD4OgwLC0EIIQQLQTBBCBCtNiIDRQ0MIAJByAFqIAEgBGooAgBBCGoQ6AwgAigCyAFFDQMgAkGgAWogAkHcAWooAgAiATYCACACQZgBaiACQdQBaikCACIVNwMAIAIgAikCzAEiFjcDkAEgAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIANBMEEIEPg6DAkLIAJByAFqIQsgASgCBEEIaiIDIAEoAghBAnRqIQQjAEEwayIBJAAgAUGTgICAeDYCBCABIAQ2AiggASADNgIkIAEgAUEEajYCLCABQRhqIQwjAEHQAGsiAyQAIANBCGoiDiABQSRqIgcQxhgCQCADKAIIQQFGBEAgA0HEAGoiCUEEQQBBCEEwEKAYIAMoAkghBCADKAJEQQFGDQwgAygCTCIIIANBEGoiDUEw/AoAACADQcwAaiIPQQE2AgAgAyAINgJIIAMgBDYCRCANIAdBCGooAgA2AgAgAyAHKQIANwMIIwBBQGoiCCQAIAhBCGogDhDGGCAIKAIIQQFGBEAgCEEQaiENIAkoAggiBEEwbCEHA0AgCSgCACAERgRAIAkgBEEBQQhBMBDcKAsgCSgCBCAHaiANQTD8CgAAIAkgBEEBaiIENgIIIAhBCGogDhDGGCAHQTBqIQcgCCgCCA0ACwsgCEFAayQAIAxBCGogDygCADYCACAMIAMpAkQ3AgAMAQsgDEEANgIIIAxCgICAgIABNwIACyADQdAAaiQAAkAgASgCBEGTgICAeEcEQCALIAEpAgQ3AgAgC0EQaiABQRRqKAIANgIAIAtBCGogAUEMaikCADcCACABKAIgIgQEQCABKAIcIQMDQCADQShqKAIAIgcEQCADIAcRAwALIANBMGohAyAEQQFrIgQNAAsLIAFBGGpBCEEwEOAeDAELIAsgASkCGDcCBCALQZOAgIB4NgIAIAtBDGogAUEgaigCADYCAAsgAUEwaiQAIAJBmAFqIgEgAkHUAWooAgA2AgAgAiACKQLMATcDkAEgAigCyAEiA0GTgICAeEcEQCACKALYASEFIAAgAikDkAE3AgggACAFNgIUIAAgAzYCBCAAQQE2AgAgAEEQaiABKAIANgIADAkLIAJBIGogASgCADYCACACIAIpA5ABNwMYDAYLQQAhBCACQQA2AiAgAkKAgICAgAE3AxhBCCEDQQEhFAwECyACQcgBaiELIAEoAgRBCGoiAyABKAIIQQN0aiEEIwBBMGsiASQAIAFBk4CAgHg2AgQgASAENgIoIAEgAzYCJCABIAFBBGo2AiwgAUEYaiEMIwBB0ABrIgMkACADQQhqIg4gAUEkaiIHEI0WAkAgAygCCEEBRgRAIANBxABqIglBBEEAQQhBMBCgGCADKAJIIQQgAygCREEBRg0KIAMoAkwiCCADQRBqIg1BMPwKAAAgA0HMAGoiD0EBNgIAIAMgCDYCSCADIAQ2AkQgDSAHQQhqKAIANgIAIAMgBykCADcDCCMAQUBqIggkACAIQQhqIA4QjRYgCCgCCEEBRgRAIAhBEGohDSAJKAIIIgRBMGwhBwNAIAkoAgAgBEYEQCAJIARBAUEIQTAQ3CgLIAkoAgQgB2ogDUEw/AoAACAJIARBAWoiBDYCCCAIQQhqIA4QjRYgB0EwaiEHIAgoAggNAAsLIAhBQGskACAMQQhqIA8oAgA2AgAgDCADKQJENwIADAELIAxBADYCCCAMQoCAgICAATcCAAsgA0HQAGokAAJAIAEoAgRBk4CAgHhHBEAgCyABKQIENwIAIAtBEGogAUEUaigCADYCACALQQhqIAFBDGopAgA3AgAgASgCICIEBEAgASgCHCEDA0AgA0EoaigCACIHBEAgAyAHEQMACyADQTBqIQMgBEEBayIEDQALCyABQRhqQQhBMBDgHgwBCyALIAEpAhg3AgQgC0GTgICAeDYCACALQQxqIAFBIGooAgA2AgALIAFBMGokACACQZgBaiIBIAJB1AFqKAIANgIAIAIgAikCzAE3A5ABIAIoAsgBIgNBk4CAgHhHBEAgAigC2AEhBSAAIAIpA5ABNwIIIAAgBTYCFCAAIAM2AgQgAEEBNgIAIABBEGogASgCADYCAAwHCyACQSBqIAEoAgA2AgAgAiACKQOQATcDGAwECyACQZQBaiIEIAJB0AFqQTD8CgAAIAMgBEEw/AoAAEEBIQQgAkEBNgIgIAIgAzYCHCACQQE2AhgMAgsgAkHcAGoiBCACQdABakEw/AoAACACQShqIgcgBEEw/AoAACACQcgBaiABKAIIQQhqEOgMIAIoAsgBQQFGBEAgAkGgAWogAkHcAWooAgAiATYCACACQZgBaiACQdQBaikCACIVNwMAIAIgAikCzAEiFjcDkAEgAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIAIoAlAiAARAIAcgABEDAAsgA0HgAEEIEPg6DAULIAJBlAFqIgEgAkHQAWpBMPwKAAAgA0EwaiABQTD8CgAAIAMgBEEw/AoAACACQQI2AiAgAiADNgIcIAJBAjYCGAwCC0EIQeAAEKM9AAsgB0EiRwRAQgAgB0EnRw0CGkIEQgAgAS0AARshFkIADAILIAJByAFqIAEoAggQsQEgAigCyAFBAUYEQCACQaABaiACQdwBaigCACIBNgIAIAJBmAFqIAJB1AFqKQIAIhU3AwAgAiACKQLMASIWNwOQASAAQRRqIAE2AgAgAEEMaiAVNwIAIAAgFjcCBCAAQQE2AgAgFEUEQANAIANBKGooAgAiAARAIAMgABEDAAsgA0EwaiEDIARBAWsiBA0ACyACKAIMIQYLIAJBGGpBCEEwEOAeDAMLIAJBlAFqIgEgAkHQAWpBMPwKAAAgAkHYAGogAUEw/AoAAEIBDAELQgALNwPIASACQdABaiACQdgAakEw/AoAACMAQTBrIgMkACADIAJBGGoiASgCADYCKCADIAEoAgQiBDYCJCADIAQ2AiAgAyAEIAEoAghBMGxqNgIsIwBBIGsiByQAIAdBFGogA0EgaiIIKAIMIAgoAgRrQTBuQQBBBEEEEKAYIAcoAhghASAHKAIUQQFGBEAgASAHKAIcQazIhwEQ/S8ACyAHQRBqIhFBADYCACAHIAcoAhw2AgwgByABNgIIIwBBIGsiASQAIAgoAgwgCCgCBGtBMG4iCyAHQQhqIgkoAgAgCSgCCCIEa0sEQCAJIAQgC0EEQQQQ3CggCSgCCCEECyACQZABaiELIAJByAFqIQ8gA0EQaiEMIAkoAgQhDiABQQhqIAhBCGopAgA3AwAgASAIKQIANwMAIAEgDjYCHCABIAQ2AhggASAJQQhqNgIUIAFBFGohCCMAQTBrIg4kAAJAAkAgASgCBCIJIAEoAgwiEkYEQCAIKAIEIQQMAQsgCCgCCCAIKAIEIgRBAnRqIQ0DQCAOIAlBMPwKAAAgASAJQTBqIgk2AgRBMEEIEK02IhBFDQYgECAOQTD8CgAAIAggBEEBaiIENgIEIA0gEDYCACANQQRqIQ0gCSASRw0ACwsgCCgCACAENgIAIwBBEGsiCSQAIAEoAgwiDSABKAIEIghrQTBuIQQgCCANRwRAA0AgCEEoaigCACINBEAgCCANEQMACyAIQTBqIQggBEEBayIEDQALCyAJIAEoAgA2AgwgCSABKAIINgIIIAlBCGpBCEEwEOAeIAlBEGokACAOQTBqJAAMAAsgAUEgaiQAIAxBCGogESgCADYCACAMIAcpAgg3AgAgB0EgaiQAIANBCGogDEG854cBEJghIAMoAgwhBCADKAIIIQcgDCAFIAoQvw8CQAJAIAMoAhBBgICAgHhGBEAgAygCFCEFQQAhCiAPKAIAQQFGBEBBMEEIEK02IgpFDQcgCiAPQQhqQTD8CgAAC0EYQQQQrTYiAUUNASABIAo2AhQgASAHNgIMIAFBgICAgHg2AgAgCyABNgI0IAtB9Rw2AjAgCyAKNgIsIAsgBzYCKCALQgA3AxggC0IANwIMIAsgBTYCCCALQQA2AgAgASAENgIQIAsgBK03AyAgA0EwaiQADAILIANBKGogA0EYaikCADcDACADIAMpAhA3AyBBzNWHAUErIANBIGpB+NWHAUHA1ocBENUeAAtBBEEYEKM9AAsgAigCkAFBAUYEQCACQThqIAJBpAFqKAIAIgE2AgAgAkEwaiACQZwBaikCACIVNwMAIAIgAikClAEiFjcDKCAAQRRqIAE2AgAgAEEMaiAVNwIAIAAgFjcCBCAAQQE2AgAgBkGAgICAeEYNAiACQQxqQQFBARDgHgwCCyAAIAIpA7ABNwMgIAJBNGogAkGgAWopAwAiFTcCACAAQShqIAJBuAFqKQMANwMAIABBMGogAkHAAWopAwA3AwAgAiACKQOYASIXNwIsIABBEGogFTcCACAAIBc3AgggACAWNwMYIABBADYCACAGQYCAgIB4Rg0BIAJBDGpBAUEBEOAeDAELIAZBgICAgHhGDQAgAkEMakEBQQEQ4B4LIAJBgAJqJAAPCyAEIAMoAkxB3OyHARD9LwALQQhBMBCjPQAL8R4CA38BfiMAQZACayIDJAAgA0HsAWogASACEJMOIAMoAvABIQQCQCADKALsASIFQYqAgIB4RwRAIAAgAykC9AE3AgggAEEgaiADQYwCaigCADYCACAAQRhqIANBhAJqKQIANwIAIABBEGogA0H8AWopAgA3AgAgACAENgIEIAAgBTYCAAwBCyADQewBaiABQX8gAiAEaiIBIAEgBEkbELQGIANBEGoiASADQfgBaikCADcDACADIAMpAvABNwMIIAMoAuwBIgJBioCAgHhHBEAgACADKQKAAjcCFCAAQRxqIANBiAJqKQIANwIAIABBDGogASkDADcCACAAIAMpAwg3AgQgACACNgIADAELIANBIGogASkDADcDACADIAMpAwg3AxggA0HsAWogA0EYakEEEN0QIAMoAvQBIQIgAygC8AEhAQJAIAACfiADKALsASIEQYqAgIB4RwRAIANBqAFqIANBiAJqKQIANwMAIAMgAykCgAI3A6ABIAMpAvgBDAELIAFBAXFFDQECQCACQQdxBEAgAyACNgKIAiADQQM2AoQCIANBsOT+ADYCgAIgA0GAgICAeDYC/AEgA0IENwL0ASADQoSAgIAINwLsAQwBC0F/IAJBCGoiASABIAJJGyIEIAMoAhgiASgCBE0EQCABIAEoAhRBCGoiBDYCFCABKAIIKAIIIARPBEAgA0GKgICAeDYC7AEMAgsgA0GIgICAeDYC7AEMAQsgA0HsAWogAiAEEL8vCyADQQY2ArABIANBtub+ADYCrAEgA0GAgICAeDYCqAEgAyACNgKkASADQQE2AqABIANByAFqIANB7AFqIANBoAFqEIEUIAMoAsgBIgRBioCAgHhGDQEgA0GoAWogA0HkAWopAgA3AwAgAyADKQLcATcDoAEgAygC0AEhAiADKALMASEBIAMpAtQBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA6ABNwIUIABBHGogA0GoAWopAwA3AgAMAQsgAyADKQMgNwIwIAMgAykDGDcCKCADQewBaiADQShqQQYQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAIoIgQgAhCTDiADKALwASEBAkAgAygC7AEiBUGKgICAeEcEQCADQegBaiADQYwCaigCADYCACADQeABaiADQYQCaikCADcCACADQdgBaiADQfwBaikCADcCACADIAMpAvQBNwLQASADIAE2AswBIAMgBTYCyAEMAQsgA0HsAWogBEF/IAEgAmoiBCABIARLGxDLDyADKALsASIBQYqAgIB4RwRAIANB3AFqIANBgAJqKQIANwIAIANB5AFqIANBiAJqKQIANwIAIAMgAykC+AE3AtQBIAMgAykC8AE3AswBCyADIAE2AsgBCyADQQU2AvwBIANBvOb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQIwNwJAIAMgAykCKDcCOCADQewBaiADQThqQQgQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAI4IgQgAhCTDiADKALwASEBAkAgAygC7AEiBUGKgICAeEcEQCADQegBaiADQYwCaigCADYCACADQeABaiADQYQCaikCADcCACADQdgBaiADQfwBaikCADcCACADIAMpAvQBNwLQASADIAE2AswBIAMgBTYCyAEMAQsgA0HsAWogBEF/IAEgAmoiBCABIARLGxDLDyADKALsASIBQYqAgIB4RwRAIANB3AFqIANBgAJqKQIANwIAIANB5AFqIANBiAJqKQIANwIAIAMgAykC+AE3AtQBIAMgAykC8AE3AswBCyADIAE2AsgBCyADQQc2AvwBIANBweb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQJANwJQIAMgAykCODcCSCADQewBaiADQcgAakEKEN0QIAMoAvQBIQIgAygC8AEhAQJAIAACfiADKALsASIEQYqAgIB4RwRAIANB0AFqIANBiAJqKQIANwMAIAMgAykCgAI3A8gBIAMpAvgBDAELIAFBAXFFDQEgA0HsAWogAygCSCIEIAIQkw4gAygC8AEhAQJAIAMoAuwBIgVBioCAgHhHBEAgA0HoAWogA0GMAmooAgA2AgAgA0HgAWogA0GEAmopAgA3AgAgA0HYAWogA0H8AWopAgA3AgAgAyADKQL0ATcC0AEgAyABNgLMASADIAU2AsgBDAELIANB7AFqIARBfyABIAJqIgQgASAESxsQtAYgA0HgAGoiASADQfgBaikCADcDACADIAMpAvABNwNYIAMoAuwBIgRBioCAgHhHBEAgA0HkAWogA0GIAmopAgA3AgAgA0HUAWogASkDADcCACADIAMpAoACNwLcASADIAMpA1g3AswBIAMgBDYCyAEMAQsgA0HwAGogASkDADcDACADIAMpA1g3A2ggA0HsAWogA0HoAGpBBBDdECADKAL0ASEBIAMoAvABIQQCQAJ+IAMoAuwBIgVBioCAgHhHBEAgA0GQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDiAEgAykC+AEMAQsgBEEBcUUNAQJAIAFBAWoiBEF/IAQbIgUgAygCaCIEKAIETQRAIAQgBCgCFEEBaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgLsAQwCCyADQYiAgIB4NgLsAQwBCyADQewBaiABIAUQvy8LIANBBTYCmAEgA0Gr5v4ANgKUASADQYCAgIB4NgKQASADIAE2AowBIANBATYCiAEgA0HIAWogA0HsAWogA0GIAWoQgRQgAygCyAEiBUGKgICAeEYNASADQZABaiADQeQBaikCADcDACADIAMpAtwBNwOIASADKALQASEBIAMoAswBIQQgAykC1AELIQYgA0HkAWogA0GQAWopAwA3AgAgAyAGNwLUASADIAE2AtABIAMgBDYCzAEgAyAFNgLIASADIAMpA4gBNwLcAQwBCyADIAMpA3A3AoABIAMgAykDaDcCeCADQewBaiADQfgAakEGEN0QIAMoAvQBIQEgAygC8AEhBAJAAn4gAygC7AEiBUGKgICAeEcEQCADQZABaiADQYgCaikCADcDACADIAMpAoACNwOIASADKQL4AQwBCyAEQQFxRQ0BAkAgAUEBaiIEQX8gBBsiBSADKAJ4IgQoAgRNBEAgBCAEKAIUQQFqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2AuwBDAILIANBiICAgHg2AuwBDAELIANB7AFqIAEgBRC/LwsgA0EGNgKYASADQbDm/gA2ApQBIANBgICAgHg2ApABIAMgATYCjAEgA0EBNgKIASADQcgBaiADQewBaiADQYgBahCBFCADKALIASIFQYqAgIB4Rg0BIANBkAFqIANB5AFqKQIANwMAIAMgAykC3AE3A4gBIAMoAtABIQEgAygCzAEhBCADKQLUAQshBiADQeQBaiADQZABaikDADcCACADIAY3AtQBIAMgATYC0AEgAyAENgLMASADIAU2AsgBIAMgAykDiAE3AtwBDAELIAMoAngiASABKAIMQQFrNgIMIANBioCAgHg2AsgBCyADQQs2AvwBIANByOb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQJQNwKQASADIAMpAkg3AogBIANB7AFqIANBiAFqQQwQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAKIASIEIAIQkw4gAygC8AEhAQJAIAMoAuwBIgVBioCAgHhHBEAgA0HoAWogA0GMAmooAgA2AgAgA0HgAWogA0GEAmopAgA3AgAgA0HYAWogA0H8AWopAgA3AgAgAyADKQL0ATcC0AEgAyABNgLMASADIAU2AsgBDAELIANB7AFqIARBfyABIAJqIgQgASAESxsQhg4gAygC7AEiAUGKgICAeEcEQCADQdwBaiADQYACaikCADcCACADQeQBaiADQYgCaikCADcCACADIAMpAvgBNwLUASADIAMpAvABNwLMAQsgAyABNgLIAQsgA0EUNgL8ASADQdPm/gA2AvgBIANBgICAgHg2AvQBIAMgAjYC8AEgA0EBNgLsASADQaABaiADQcgBaiADQewBahCBFCADKAKgASIEQYqAgIB4Rg0BIANB0AFqIANBvAFqKQIANwMAIAMgAykCtAE3A8gBIAMoAqgBIQIgAygCpAEhASADKQKsAQs3AgwgACACNgIIIAAgATYCBCAAIAQ2AgAgACADKQPIATcCFCAAQRxqIANB0AFqKQMANwIADAELIAMoAogBIgEgASgCDEEBazYCDCAAQYqAgIB4NgIACyADQZACaiQAC/8bAhZ/AX4jAEEwayIJJAAgAUH/AXEhEyAAKAIcIgQsAAQiFEEESiEVA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCJCIFQYUCTQRAIAQoAiAiCkEBdCEGIApBhgJrIQwDQCAEKAJQIAUgBCgCECICamshBQJAAkACQAJAAkACQAJAAkACQCAMIAQoAiBqIAJNBEAgBiAEKAIYIgJLDQEgCkEASA0CIAoEQCAEKAIUIgIgAiAKaiAK/AoAAAsgBCAELwEMIgIgCkH//wNxIgNrIgdBACACIAdPGzsBDCACIANNBEAgBEEAOwE0CyAEIAQoAhAgCmsiAjYCECAEIAQoAjwgCms2AjwgBCACIAQoAoABIgMgAiADSRs2AoABIAQQlBYgBSAKaiEFCyAAKAIERQRAIAAoAhwhBAwMCyAFQQFNDQIgACAAKAIcIgIoAiQgAigCEGogBRDMEyEDIAAoAhwiAiADIAIoAiRqIgM2AiQgAyACKAKAASIDakEDSQ0IIAIoAhAiByADayEFIAIvATZBgAhNBEAgAyAHRg0IIAVBAWshAyACLQAGQQFGBEAgAiADENkZGgwJCyACKAIYIgcgA0kNBCAHIANrIgdBA00NBSACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIg8vAQAiDiADQf//A3FGDQggAigCIEEBayADcSIHIAIoAiwiEE8NBiACKAIoIAdBAXRqIA47AQAgDyADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0HE//wAEMMhAAsgBUEBaiIHIANJDQYgByADQdT//AAQwyEACyAGIAJBhP/8ABCwOwALIAlBADYCKCAJQQE2AhwgCUHc+vwANgIYIAlCBDcCICAJQRhqQZT//AAQ7ywACyAJQQA2AiggCUEBNgIcIAlBrP/8ADYCGCAJQgQ3AiAgCUEYakG0//wAEO8sAAsgAyAHQeT7/AAQrzsAC0EEIAdB9Pv8ABCwOwALIAcgEEGE/PwAEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAHai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiRBAUZrIgNFDQACQCACLQAGQQFGBEAgAiAFIAMQ4BMMAQsgAiAFIAMQ6xQLIAIgAigCgAEgA2s2AoABCyAAKAIcIgQoAiQiBUGFAksNAiAAKAIEDQALDAELAkAgFEEFTgRAIApB//8DcSIDDQELIAQoAhAhAwwCCwJ/AkAgBSADQQRqTQ0AAkAgA0EDTQRAQQEhAiADQQFHDQEgCAwDCyAIIApqIQUgCEEBakH//wNxIgIgC0H//wNxIgNJBEAgBUH//wNxIANNDQIgBSALa0H//wNxIQIgBC0ABkEBRgRAIAQgAyACEOATDAMLIAQgAyACEOsUDAILIAMgBUH//wNxTwRAIAsgCGtB//8DcSEDIAQtAAZBAUYEQCAEIAIgAxDgEwwDCyAEIAIgAxDrFAwCCyAKQQFrQf//A3EhAyAELQAGQQFGBEAgBCACIAMQ4BMMAgsgBCACIAMQ6xQMAQsgCEEBakH//wNxIgIgC0H//wNxIgNJDQAgAyAIIApqQf//A3FPBEAgCyAIa0H//wNxIQMgBC0ABkEBRgRAIAQgAiADEOATDAILIAQgAiADEOsUDAELIAQtAAZBAUYEQCAEIAJB//8DEOATDAELIAQgAkH//wMQ6xQLIAohAiAICyEDIA0hDwwJCyAEKAIQIgMgBCgCUEGGAmtLBEAgCUEANgIoIAlBATYCHCAJQYCA/QA2AhggCUIENwIgIAlBGGpBiID9ABDvLAALIAQoAiQiAkGGAk8NACATRQRAQQAhBAwLCyACRQRAIARBAiADIANBAk8bNgKAASABQf8BcUEERg0DIAAoAhwoAkgEQEEAIQQgAEEAEJIBIAAoAhBFDQwLQQEhBAwLC0EAIQUgAkEDTQ0BCyAEKAIYIgIgA0kNAiACIANrIgJBA00NAyAEKAIwIAQoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgovAQAiBSADQf//A3FGDQAgBCgCIEEBayADcSICIAQoAiwiBk8NBCAEKAIoIAJBAXRqIAU7AQAgCiADOwEAIAAoAhwiBCgCECEDC0EBIQJBACEKIAVFDQQgA60gBa19IhhCAFcNBEEAIQ8gGCAEKAIgQYYCa61VDQUgCUEQaiAEIAUQkwcgCSgCECECIAAoAhwgCS8BFCIPOwEMAkAgACgCHCIGKAIkQQEgAkEBIAJB/P8DcRsiAiAPIANB//8DcSIHTxsiBUH//wNxIgxBBGpNDQAgBUEBayEOAkACQCAMQQNNBEAgB0H//wNGDQMgDkH//wNxIgxFDQMgA0EBakH//wNxIQIgAyAFakH//wNxIAdLDQIgBi0ABkEBRw0BIAYgAkEAEOATDAMLIAdB//8DRg0IIANBAWpB//8DcSEMIAcgAyAFakH//wNxTwRAIAYtAAZBAUYEQCAGIAxBABDgEwwKCyAGIAxBABDrFAwJCyAOQf//A3EhBSAGLQAGQQFGBEAgBiAMIAUQ4BMMCQsgBiAMIAUQ6xQMCAsgBiACQQAQ6xQMAQsgBi0ABkEBRgRAIAYgAiAMEOATDAELIAYgAiAMEOsUCyAFIQIMBQsgAEEBEJIBQQNBAiAAKAIQGyEEDAcLIAMgAkHk+/wAEK87AAtBBCACQfT7/AAQsDsACyACIAZBhPz8ABDDIQALQQAhDwsgFUUNAQtBACEKIAAoAhwiBSgCJEGGAk0NACACIANqQf//A3EiBiAFKAJQQYYCa08NACAFIAY2AhACQAJAIAAoAhwiBCgCGCIIIAQoAhAiC08EQCAIIAtrIghBA0sEQAJAIAQoAjAgBCgCFCALaigAAEGx893xeWxBD3ZB/v8HcWoiDS8BACIIIAtB//8DcUcEQCAEKAIgQQFrIAtxIgogBCgCLCIFTw0BIAQoAiggCkEBdGogCDsBACANIAs7AQAgACgCHCIEKAIQIQsLQQAhDQJAAkAgCEUNACALrSAIrX0iGEIAVw0AIBggBCgCIEGGAmutVQ0AIAlBCGogBCAIEJMHIAkoAgghCiAAKAIcIAkvAQwiDTsBDCAAKAIcIQQgDSALQf//A3EiEU8NACAKQf//A3FBA0sNAQsgCyEIQQEhCgwFCyACQf//A3EiBUECSSAFIA1BAWpB//8DcUtyDQMgBSALQQFqIhZB//8DcUsNAyANIAVrQQFqIgYgBCgCGCIITQRAIAggC0H//wNxIgcgBWtBAWoiDE8EQCAGIAhHBEAgCCAMRwRAIAQoAhQiBSAGai0AACAFIAxqLQAARw0HIAggDU8EQCAHIAhNBEAgBSAHaiEOIAUgDWohEEEAIRIgESAEKAIgQYYCa0H//wNxayIIQQAgCCARTRtB//8DcSERIAshCCAKIQcgDSEMIAIhBgNAAkACQAJAIAUgEEcEQCAFIA5GDQIgEEEBayIQLQAAIA5BAWsiDi0AAEcNAgwBCyAFIA5GIAUhECAFIQ5FDQELIAZB//8DcUUgCEH//wNxIBFNciAHQf//A3FB/wFLcg0AIAxB//8DcUEBSw0BCyASRSAGQf//A3FBAUtyDQsgFiELIAchCiAMIQ0gBiECDAwLIBJBAWshEiAGQQFrIQYgB0EBaiEHIAxBAWshDCAIQQFrIQgMAAsACyAHIAhB1Pv8ABCwOwALIA0gCEHE+/wAELA7AAtBAEEAQbT7/AAQwyEAC0EAQQBBpPv8ABDDIQALIAwgCEGU+/wAEK87AAsgBiAIQYT7/AAQrzsACyAKIAVBhPz8ABDDIQALQQQgCEH0+/wAELA7AAsgCyAIQeT7/AAQrzsACyALIQgLIAQgA0H//wNxNgIQCyAAKAIcIQYCQAJAAkACQAJAAkACQAJAAkAgAkH//wNxIgVBBE8EQCAGKAJEIgcgBigCSCICSQ0BIAcgAmsiB0ECTQ0CIAYoAkAgAmoiByAFQQNrIgI6AAIgByADIA9rIgNBCHY6AAEgByADOgAAIAYgBigCSEEDajYCSCAGQf8BIAYtADpBAWoiByAHQf8BTxs6ADogA0H//wNxQQFrIgMgBigCIEGGAmtPDQMgAxDKKkH/AXFBHk8NAyACQYACTw0EIAYgAkHk/PwAai0AAEECdGpBrAlqIgIgAi8BAEEBajsBACADEMoqQf8BcSICQT1PDQUgBiAGKAIkIAVrNgIkIAYgAkECdGoiAiACLwGkE0EBajsBpBMgBigCSCAGKAJEIAAoAhwiBiAGKAIQIAVqNgIQQQNrRw0JDAgLIAYoAhgiByAGKAIQIgNJDQUgByADayIHIAVJDQYgAkH//wNxRQ0IIAYoAhQgA2ohBCAGQaQBaiEHIAZBQGshDEEAIQMgBSECA0AgDCAHIAQtAAAQliMhDyAGIAYoAiRBAWs2AiQgAyAPciEDIARBAWohBCACQQFrIgINAAsgACgCHCICIAIoAhAgBWo2AhAgA0EBcQ0HDAgLIAIgB0GU/PwAEK87AAtBAyAHQaT8/AAQsDsACyAJQQA2AiggCUEBNgIcIAlBzPz8ADYCGCAJQgQ3AiAgCUEYakHU/PwAEO8sAAsgAkGAAkHk/vwAEMMhAAsgAkE9QfT+/AAQwyEACyADIAdB5Pr8ABCvOwALIAUgB0H0+vwAELA7AAtBACEEIABBABCSASAAKAIQRQ0BCyAAKAIcIQQMAQsLIAlBMGokACAEC80XAQV/IwBB0ABrIgMkAAJAAkACQAJAAkACQEEAQcAAENE0BEAgA0LAADcCECADQsAANwIIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AACIFQQFrDigBAgICAgICAgICAgICAgICAgICAwQFBgMFBgcICQoLCQwOAgICAgcJAAtBAEHAABDRNEUNESAAIAMpAgg3AgAgAELAADcCGCAAQsAANwIQIABBCGogA0EQaikCADcCAAwQC0HAACEBIAJBA3YgAkEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0QIAIEQCACQcAAEK02IgFFDRILIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwPC0EBIQQCQAJAAkACQAJAAkACQAJAIAVBA2sOJAYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAcLQQQhBAwGC0EIIQQMBQsgAS0AAUECdEHQl4cBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtBvI+HARCyOwALQQIhBAsgAiAEbCICQT9xIgEEQCACIAIgAWtBQGsiAksNEgtBwAAhASACQcAAENE0RQ0PIAIEQCACQcAAEK02IgFFDRELIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwOCyACQQJ0QQRqIgFBPHEiBARAIAEgASAEa0FAayIBSw0RCyABQcAAENE0RQ0OAn8gAUUEQCADQsAANwIYIANCwAA3AiAgA0EYakHAABDoGSADKAIgIQQgAygCJAwBCyABQcAAEK02IgRFDRIgA0EANgIkIAMgBDYCICADIAE2AhwgA0HAADYCGEEACyAEakEANgAAIAMgAygCJEEEajYCJCADQTBqIANBIGopAgA3AwAgAyADKQIYNwMoAkAgAkE/cSIBRQRAIAIhAQwBCyACIAFrQUBrIgEgAkkNEQtBwAAhAiABQcAAENE0RQ0OIAEEQCABQcAAEK02IgJFDRILIAAgAykDKDcCACAAQQA2AhwgACACNgIYIAAgATYCFCAAQcAANgIQIABBCGogA0EwaikDADcCAAwJCyABKAIEIAJsIgJBP3EiAQRAIAIgAiABa0FAayICSw0QC0HAACEBIAJBwAAQ0TRFDQ0gAgRAIAJBwAAQrTYiAUUNDwsgACADKQIINwIQIABBADYCDCAAIAE2AgggACACNgIEIABBwAA2AgAgAEEYaiADQRBqKQIANwIADAwLIAJBA3RBCGoiAUE4cSIEBEAgASABIARrQUBrIgFLDQ8LIAFBwAAQ0TRFDQwCfyABRQRAIANCwAA3AhggA0LAADcCICADQRhqQcAAEOgZIAMoAiAhBCADKAIkDAELIAFBwAAQrTYiBEUNECADQQA2AiQgAyAENgIgIAMgATYCHCADQcAANgIYQQALIARqQgA3AAAgAyADKAIkQQhqNgIkIANBMGogA0EgaikCADcDACADIAMpAhg3AygCQCACQT9xIgFFBEAgAiEBDAELIAIgAWtBQGsiASACSQ0PC0HAACECIAFBwAAQ0TRFDQwgAQRAIAFBwAAQrTYiAkUNEAsgACADKQMoNwIAIABBADYCHCAAIAI2AhggACABNgIUIABBwAA2AhAgAEEIaiADQTBqKQMANwIADAcLIAJBBHQiAkEwcSIBBEAgAiACIAFrQUBrIgJLDQ4LQcAAIQEgAkHAABDRNEUNCyACBEAgAkHAABCtNiIBRQ0NCyAAIAMpAgg3AhAgAEEANgIMIAAgATYCCCAAIAI2AgQgAEHAADYCACAAQRhqIANBEGopAgA3AgAMCgsgAkECdEEEaiICQTxxIgEEQCACIAIgAWtBQGsiAksNDQsgAkHAABDRNEUNCgJ/IAJFBEAgA0LAADcCKCADQsAANwIwIANBKGpBwAAQ6BkgAygCMCEBIAMoAjQMAQsgAkHAABCtNiIBRQ0MIANBADYCNCADIAE2AjAgAyACNgIsIANBwAA2AihBAAshAiABIAJqQQA2AAAgACADKQIoNwIAIAAgAykCCDcCECAAQRhqIANBEGopAgA3AgAgAyADKAI0QQRqNgI0IABBCGogA0EwaikCADcCAAwJCyACQQJ0IgQhAiAEQTxxIgEEQCAEIAFrQUBrIgIgBEkNDAtBwAAhBSACQcAAENE0RQ0JIAIEQCACQcAAEK02IgVFDQsLIAEEQCAEIAQgAWtBQGsiBEsNDAtBwAAhASAEQcAAENE0RQ0JIAQEQCAEQcAAEK02IgFFDQ4LIABBADYCHCAAIAE2AhggACAENgIUIABCgICAgIAINwIMIAAgBTYCCCAAIAI2AgQgAEHAADYCAAwEC0EAQcAAENE0RQ0IIAAgAykCCDcCACAAQsAANwIYIABCwAA3AhAgAEEIaiADQRBqKQIANwIADAcLIAJBA3RBCGoiAkE4cSIBBEAgAiACIAFrQUBrIgJLDQoLIAJBwAAQ0TRFDQcCfyACRQRAIANCwAA3AiggA0LAADcCMCADQShqQcAAEOgZIAMoAjAhASADKAI0DAELIAJBwAAQrTYiAUUNCSADQQA2AjQgAyABNgIwIAMgAjYCLCADQcAANgIoQQALIQIgASACakIANwAAIAAgAykCKDcCACAAIAMpAgg3AhAgAEEYaiADQRBqKQIANwIAIAMgAygCNEEIajYCNCAAQQhqIANBMGopAgA3AgAMBgsgAkEDdCIEIQIgBEE4cSIBBEAgBCABa0FAayICIARJDQkLQcAAIQUgAkHAABDRNEUNBiACBEAgAkHAABCtNiIFRQ0ICyABBEAgBCAEIAFrQUBrIgRLDQkLQcAAIQEgBEHAABDRNEUNBiAEBEAgBEHAABCtNiIBRQ0LCyAAQQA2AhwgACABNgIYIAAgBDYCFCAAQoCAgICACDcCDCAAIAU2AgggACACNgIEIABBwAA2AgAMAQsgAiEEIAJBP3EiBQRAIAIgBWtBQGsiBCACSQ0IC0HAACEFIARBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNCgsgAS0AAUUNAiADQTxqIQYjAEEQayIHJAACQAJAAkACQCACQQJ0IgFBP3EiAgRAIAEgASACa0FAayIBSw0BC0HAACECIAFBwAAQ0TRFDQEgAQRAIAFBwAAQrTYiAkUNAwsgBkEANgIMIAYgAjYCCCAGIAE2AgQgBkHAADYCACAHQRBqJAAMAwtB2IqHAUEjQfyKhwEQyyQAC0Gci4cBQSkgB0EPakHoi4cBQciLhwEQ1R4AC0HAACABEKM9AAsgAEEANgIMIAAgBTYCCCAAIAQ2AgQgAEHAADYCACAAIAMpAjw3AhAgAEEYaiADQcQAaikCADcCAAsgA0EIahDPLwwDC0EBIQQCQAJAAkACQAJAAkACQAJAIAEoAgQiAS0AAEECaw4lBwYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAULQQQhBAwGC0EIIQQMBQsgAS0AAUECdEHQl4cBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtBrI+HARCyOwALQQIhBAsgAiAEbCICQT9xIgEEQCACIAIgAWtBQGsiAksNBgtBwAAhASACQcAAENE0RQ0DIAIEQCACQcAAEK02IgFFDQULIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwCCyAAIAMpAgg3AhAgAEEANgIMIAAgBTYCCCAAIAQ2AgQgAEHAADYCACAAQRhqIANBEGopAgA3AgAMAQsMAQsgA0HQAGokAA8LQZyLhwFBKSADQc8AakHoi4cBQciLhwEQ1R4AC0HAACACEKM9AAtB2IqHAUEjQfyKhwEQyyQAC0HAACABEKM9AAtBwAAgBBCjPQAL/iACEX8BfiMAQYACayIFJAAgBSADNgJMIAUgAjYCSCAFIAM2ApQBIAUgAjYCkAEgBUGQAWoQ7hIhCyAFKAKQASEOIAUgBSgClAEiCDYCVCAFIA42AlACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAtBL0YgC0HcAEZyRQRAIAtBgIDEAEcNBCAERQ0FIAQoAghBAUcNASAEKAIUIQggBCgCDCIDDQJBACEDDAMLAkAgC0HcAEcNACABKAIYIgZFDQAgBkEAIAEoAhwoAhQRAAALIAUgCDYClAEgBSAONgKQASAFQZABaiIGEO4SIQcgBSgClAEhCSAFKAKQASEKIAdBL0YgB0HcAEZyDQwgAUGwh8QAQbeHxAAQgSZBByENIAVB0ABqEI0XIARFcg0KIwBBEGsiByQAIAcgBBC2ESAHKAIEIQkgBygCACEKIAdBLzYCDCAGIAogCSAHQQxqQQEQ9C4EfyAGQQE7ASQgBkEANgIcIAZBAToAGCAGQS82AhQgBkEANgIMIAYgCUEBayIJNgIgIAYgCTYCECAGIAk2AgggBiAKQQFqNgIEQS8FQYCAxAALNgIAIAdBEGokACAFKAKQAUGAgMQARwRAIAVB6ABqIAZBKPwKAAAgBS0AjQENDAJAAkACfwJAIAUoAngiCSAFKAJ0IgdJDQAgCSAFKAJwIgxLDQAgBSgCbCESIAVB+wBqIRMgBUH8AGohFANAIAUoAmwgB2ohDyATIAUtAIABIgpqLQAAIRACQAJAAkAgCSAHayIRQQdNBEAgByAJRg0BQQAhBgNAIAYgD2otAAAgEEYNBCARIAZBAWoiBkcNAAsMAQsgBUEoaiAQIA8gERCdEiAFKAIoQQFxDQEgBSgCeCEJCyAFIAk2AnQMAwsgBSgCLCEGIAUtAIABIQogBSgCcCEMIAUoAnQhBwsgBSAGIAdqQQFqIgc2AnQCQCAHIApJIAcgDEtyDQAgCkEFSQRAIAcgCmsiBiAFKAJsaiAKIBQgChDBLkUEQCAFKAJwIQwgBSgCdCEHDAILIBIgBSgChAEiB2ohCSAGIAdrDAQLIApBBEGEhsQAELA7AAsgBSgCeCIJIAdJDQEgCSAMTQ0ACwsgBS0AjQENDyAFQQE6AI0BAkAgBS0AjAFBAUYEQCAFKAKIASEHIAUoAoQBIQYMAQsgBSgCiAEiByAFKAKEASIGRg0QCyAFKAJsIAZqIQkgByAGawtBAkcNACAJLQAAQd8BcUHBAGtB/wFxQRlLDQAgCS0AAUE6Rg0BC0EAIQkCQAJAIAVBIGoiDCAEIgYtADQEfyAEKAIYIQkgBCgCFCEKIAQoAiwiByAEKAIoIgZJDQECQCAGRQ0AIAYgCU8EQCAGIAlHDQMMAQsgBiAKaiwAAEG/f0wNAgsCQCAHRQ0AIAcgCU8EQCAHIAlGDQEMAwsgByAKaiwAAEG/f0wNAgsgBiAKaiEJIAcgBmsFIAYLNgIEIAwgCTYCAAwBCyAKIAkgBiAHQdCXxAAQozYACyAFKAIgIgZFDQwgASAGIAYgBSgCJGoQgSYgBUHgAWogBEE9aikAADcDACAFIAQpADU3A9gBIAQtADQhFSABKAIIIQ0MDAsgASgCCCEEIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAEQQFqNgIIIAEgCSAJQQJqEIEmDAsLQfiHxAAQsjsACyAEKAIYIQMgBCgCFCEIDAELAkAgBCgCGCICIANNBEAgAiADRw0BDAILIAMgCGosAABBv39KDQELIAggAkEAIANByIjEABCjNgALIAEgCCADIAhqEIEmIABBADYCCCAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQIAAgBCkCNDcCNCAAQTxqIARBPGopAgA3AgAgAEHEAGogBEHEAGotAAA6AAAgACAEKAIwNgIwIAAgBCkCADcCACAAIAQpAiA3AiAgACAEKQIoNwIoIAAgBCgCHDYCHAwMCyAEDQELIAFBiInEAEGQicQAEIEmIAVBADoAkAEgBSABQQAgBUGQAWoiBEEHIAIgAxC/ASAEIAFBAEEEIAUoAgAgBSgCBBDOESAFKAKQASICQQJGDQEgBSkClAEhFiAFKAKcASEDIABBADoANCAAQQc2AjAgAEKHgICA8AA3AiggAEKEgICA8AA3AiAgAEEAOwEcIAAgAzYCDCAAIBY3AgQgACACNgIAIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAMCgsCQAJAAkACQCALQSNHBEAgC0E/Rg0BIAVByABqEI0XDQMgBCgCAEUNAiAEQQRqIQYMBwsgBUGQAWoiBiABQST8CgAAIAAgBiAEIAIgAxCPEAwNCwJ/IAQoAgBFBEAgBEEMaiAEKAIIDQEaIAQoAhghBiAEKAIUIQgMBAsgBEEEagsgBCgCFCEIKAIAIgZFBEBBACEGDAMLAkAgBCgCGCIHIAZNBEAgBiAHRg0EDAELIAYgCGosAABBv39KDQMLDA0LIAQoAggEQCAEQQxqIQYMBQsgBCgCGCEGIAQoAhQhCAwFCyABQYiJxABBkInEABCBJiAFQQA6AJABIAVBCGogAUEAIAVBkAFqIgRBByACIAMQvwEgBCABQQBBBCAFKAIIIAUoAgwQzhEgBSgCkAEiAkECRg0BIAUpApQBIRYgBSgCnAEhAyAAQQA6ADQgAEEHNgIwIABCh4CAgPAANwIoIABChICAgPAANwIgIABBADsBHCAAIAM2AgwgACAWNwIEIAAgAjYCACAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQDAoLIAEgCCAGIAhqEIEmIAVBkAFqIAFBACAEKAIgIgYgAiADEM4RIAUoApABIgJBAkcNAQsgBS0AlAEhAiAAQQI2AgAgACACOgAEDAYLIAUpApQBIRYgBSgCnAEhAyAAIAI2AgAgACADNgIMIAAgBjYCICAAIBY3AgQgAEEYaiABQQhqKAIANgIAIAAgASkCADcCECAAIAQpAjQ3AjQgAEE8aiAEQTxqKQIANwIAIABBxABqIARBxABqLQAAOgAAIAAgBCgCHDYCHCAAIAQpAiw3AiwgACAEKQIkNwIkDAcLIAQoAhQhCCAGKAIAIgZFBEBBACEGDAELAkAgBCgCGCIHIAZNBEAgBiAHRg0CDAELIAYgCGosAABBv39KDQELDAcLIAEgCCAGIAhqEIEmIAFBACAEKAIwIgYQrhsgBUEBOgCQASAFQRBqIAFBACAFQZABaiIIIAYgAiADEL8BIAUoAhQhAiAFKAIQIQMgCCABQST8CgAAIAAgCEEAIAQoAiAgBCgCJCAEKAIoIAQoAiwgBEE0aiAELwEcIAQvAR4gBiADIAIQ0QcMBQsgBUEAOgCQASAFQRhqIAFBACAFQZABaiIEIA0gC0HcAEYgC0EjayIGQRxNQQBBASAGdEGBoICAAXEbcgR/IAIFIAghAyAOCyADEL8BIAQgAUEAQQQgBSgCGCAFKAIcEM4RIAUoApABIgJBAkYEQCAFLQCUASECIABBAjYCACAAIAI6AAQMAwsgBSkClAEhFiAFKAKcASEDIAAgBSkD2AE3ADUgACAVOgA0IAAgDTYCMCAAIA02AiwgAEEHNgIoIABChICAgPAANwIgIABBADsBHCAAIAM2AgwgACAWNwIEIAAgAjYCACAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQIABBPWogBUHgAWopAwA3AAAMBAtBiIjEABCyOwALAkAgB0HcAEcNACABKAIYIgJFDQAgAkEAIAEoAhwoAhQRAAALIAFBsIfEAEG3h8QAEIEmIAVBkAFqIgYgCiAJENcIIAUtAJQBIQQCfwJAAkACQAJ/AkACQCAFKAKQASIIQYGAgIB4Rg0AIAUgBSkAlQEiFjcD2AEgBSAFQZwBaigAADYA3wEgBSgCoAEhAiAFKAKkASEDIAVBwAFqIgcgBSgA2wE2AAAgBSAWPgC9ASAFIAQ6ALwBIAUgCDYCuAEgBUFAayAFQbgBahDcOyAFKAJERQ0DIAVB+AFqIAcoAgA2AgAgBSAFKQK4ATcD8AEgBiAFQfABahCaAyAFLQCRASEEIAUtAJABIgZBA0YNACAFQeoBaiAFQaIBai8BADsBACAFQeIBaiAFQZoBaikBADcBACAFIAUpAZIBNwHaASAFIAQ6ANkBIAUgBjoA2AEgBkUEQCAFKALgASAFKALkAUHsi8QAQQkQwS4NAgsgBUH4AGoiBCAFQegBaigCADYCACAFQfAAaiIIIAVB4AFqKQIANwMAIAUgBSkC2AE3A2hBASEGIAVBATYClAEgBUGQi8QANgKQASAFQgE3ApwBIAVB6QI2AvQBIAUgBUHwAWo2ApgBIAUgBUHoAGo2AvABIAEgBUGQAWoiBxDbOw0EIAVBoAFqIAQoAgA2AgAgBUGYAWogCCkDADcDACAFIAUpA2g3A5ABIAVBxwFqIAcQrh4gBS0AxwEMAgsgAEECNgIAIAAgBDoABAwGCyAFQdwBahCGMEEAIQZBAAshCCAFQeAAaiAFQdABaikAADcDACAFIAUpAMgBNwNYIAEoAgghBCAFIAhB/wFxQQBHOgBoIAZFDQIgBUE4aiABQQAgBUHoAGogAiADEM0NIAUoAjwhAyAFKAI4DAMLIAVBuAFqEIYwIAEoAgghBEEAIQggBUEAOgBoDAELQcyExABBKyAFQZABakG8hMQAQfiLxAAQ1R4ACyABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgBEEBajYCCCAFQTBqIAFBACAFQegAaiAEIAIgAxC/ASAFKAI0IQMgBSgCMAshCSAFLQBoRQRAIAVBkAFqIQIjAEEQayIIJAAgCEEIakEHIAQgASgCCCIHQdiHxAAQhyogASgCBCELIAgoAgwhBAJAIAgoAggiBkUNAAJAIAYgB08EQCAGIAdHDQEMAgsgBiALaiwAAEG/f0oNAQtB1prEAEEuQdiHxAAQnykACwJAIARFDQACQCAEIAdPBEAgBCAHRw0BDAILIAQgC2osAABBv39KDQELQYSbxABBLEHYh8QAEJ8pAAsgAiAENgIQIAIgBjYCDCACIAE2AgggAiAEIAtqNgIEIAIgBiALajYCACAIQRBqJAACQCACKAIMIgYgAigCECIESw0AIAIoAggiAigCCCIIIARJDQAgAiAGNgIIIAggBGshBwJAIAQgBkYEQCAEIAhGDQIMAQsgBCAIRg0BIAdFDQAgAigCBCIIIAZqIAQgCGogB/wKAAALIAIgBiAHajYCCAtBACEIQQchBAsgBUGQAWogAUEAQQQgCSADEM4RIAUoApABIgJBAkcNASAFLQCUASECIABBAjYCACAAIAI6AAQLIAEQ3jsMAQsgBSkClAEhFiAFKAKcASEDIAAgBSkDWDcANSAAIAg6ADQgACAENgIwIAAgBDYCLCAAQQc2AiggAEKEgICA8AA3AiAgAEEAOwEcIAAgAzYCDCAAIBY3AgQgACACNgIAIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgAEE9aiAFQeAAaikDADcAAAsgBUGAAmokAA8LIAggB0EAIAZBlJXEABCjNgAL7iQCCX8DfiMAQfADayIFJAACQAJAAkACQCABQShqIgggBBDzLSIHELgIDQAgBy0AACEGAn8gCC0AAEEiRgRAIAZBIkYEQCAHKAIIIQcLIAEoAjAMAQsgBkEiRgRAIAcoAgghBwsgCAsiBiAHELgIDQACQAJAAkACQAJAAkAgBi0AAEEUaw4HBQcAAQIDBAcLIActAABBFGsOBAUGBgUGCyAHLQAAQT1xQRRHDQUMBAsgBy0AAEEZa0H/AXFBAk8NBAwDCyAHLQAAQT1xQRhHDQMMAgsgBy0AAEE+cUEYRg0BDAILIActAABBPnFBFkcNAQsgAS0AQCEJAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBBDzLSIHEIY2RQRAQQQhBiAHLQAAQRtrDg0EAgMEAgUCAQICAgIEAgsgBCgCACIBIAEoAgAiB0EBajYCACAHQQBIDQsgACACIAMgCUEBcSABIAQoAgQQ8RsMFAsgBygCCBCGNg0ECyAFIAc2AjAgBUECNgLMAiAFQaTCzQA2AsgCIAVCATcC1AIgBUGnBDYCrAIgBSAFQagCajYC0AIgBSAFQTBqNgKoAiAAQQxqIAVByAJqEJkOIABBhICAgHg2AgAgAEEBNgIIDBILQQghBgsgAkEBaiECIAYgB2ohCkECQQEgCUEBcRsgA2ohByAILQAAIgZBG2sOBAMJBAUCCyMAQSBrIgEkACABQQhqIAQoAgAgBCgCBCIEKAIIQQFrQXhxakEIaiAEKAIQEQAAIAFBEGogASgCCCIIIAEoAgwoAgwRAAACQCAIBEAgASkDEEK+uaqJmdKNmuAAhSABKQMYQsWRgbqRwsPNNIWEUA0BC0HI+4UBQQxB1PuFARDLJAALIAFBIGokACAFIAI7ARQgBSADIAlB/wFxajsBFiAFQQhqIAdBBGoQwzQgBSgCCCECIAUoAgwhAyAFIAgQ3DsgBUHIAmoiASACIAIgA0ECdGogBSgCACICIAIgBSgCBEEDdGoQySIgBSAFQRRqNgLgAiAFQagCaiEDIwBB0ABrIgIkACACQQg2AgggAkHIAGogAUEYaigCADYCACACQUBrIAFBEGopAgA3AwAgAkE4aiABQQhqKQIANwMAIAIgASkCADcDMCACIAJBCGo2AkwgAkEkaiEGIwBBgAFrIgEkACABQRhqIgkgAkEwaiIEEJ8dAkACQAJAIAEoAhhBhICAgHhHBEAgAUHgAGoiCkEEQQBBBEHIABCgGCABKAJkIQcgASgCYEEBRg0CIAEoAmgiCyAJQcgA/AoAACABQRRqIgxBATYCACABIAs2AhAgASAHNgIMIAFB+ABqIARBGGopAgA3AwAgAUHwAGogBEEQaikCADcDACABQegAaiAEQQhqKQIANwMAIAEgBCkCADcDYCMAQdAAayIEJAAgBEEIaiAKEJ8dIAQoAghBhICAgHhHBEAgAUEMaiEHA0AgBygCCCIJIAcoAgBGBEAgByAJQQFBBEHIABDQKAsgBygCBCAJQcgAbGogBEEIaiILQcgA/AoAACAHIAlBAWo2AgggCyAKEJ8dIAQoAghBhICAgHhHDQALCyAEQdAAaiQAIAZBCGogDCgCADYCACAGIAEpAgw3AgAMAQsgBkEANgIIIAZCgICAgMAANwIACyABQYABaiQADAELIAcgASgCaEHIl88AEP0vAAsCQCACKAIIQQhHBEAgAyACKQMINwMAIANBEGogAkEYaikDADcDACADQQhqIAJBEGopAwA3AwAgAigCLCIDBEAgAigCKCEBA0AgARDiCyABQcgAaiEBIANBAWsiAw0ACwsgAkEkakEEQcgAEOAeDAELIAMgAikCJDcCBCADQQg2AgAgA0EMaiACQSxqKAIANgIACyACQdAAaiQAIAVBOGoiASAFQbQCaigCADYCACAFIAUpAqwCNwMwIAUoAqgCIgJBCEcEQCAFKQO4AiEOIAAgBSkDMDcCDCAAIA43AxggACACNgIIIABBhICAgHg2AgAgAEEUaiABKAIANgIADBALIAAgBSkDMDcCBCAAQQxqIAEoAgA2AgAgAEEUaiAIEJw2EO4lIABBg4CAgHg2AgAgACAFKAEUNgIQDA8LIAQoAgAiASABKAIAIgdBAWo2AgAgB0EASA0FIAAgAiADIAlBAXEgASAEKAIEEPEbDA4LIAZBJ0cNBiMAQSBrIgEkACABQQhqIAQoAgAgBCgCBCIEKAIIQQFrQXhxakEIaiAEKAIQEQAAIAFBEGogASgCCCIEIAEoAgwoAgwRAAAgASkDGCEOIAEpAxAhDyABQSBqJAAgBEEAIA9ClY2j2tTIv9zGAIUgDkKzz/m4y5qOxTKFhFAbIgZFBEBB8N7QAEEJQfze0AAQyyQACyAGKAIYIQggBUGoAmogBkEMahDCBiAGKAIcIgEEQCABIAEoAgAiA0EBajYCACADQQBIDQUgBigCLCEJIAYoAighCyAGKAIkIQwgBigCICENIAYoAjAhAwsgBUHIAmoiBCAGELwVIAVB3AJqIAVBsAJqKAIANgIAIAUgCDYC4AIgBSADNgL4AiAFIAk2AvQCIAUgCzYC8AIgBSAMNgLsAiAFIA02AugCIAUgATYC5AIgBSAFKQKoAjcC1AJBPEEEEK02IgFFDQUgAUKBgICAEDcCACABQQhqIARBNPwKAAAgBUH0wM0ANgLcASAFIAE2AtgBIAQgCigCAEEIaiACIAcgBUHYAWoiAxC2ASAFKALIAiIIQYSAgIB4Rw0DIAVBvAJqIAVB4AJqKQMAIg43AgAgBUG0AmogBUHYAmopAwAiDzcCACAFIAUpA9ACIhA3AqwCIABBGGogDjcCACAAQRBqIA83AgAgACAQNwIIIABBhICAgHg2AgAgASABKAIAIgBBAWs2AgAgAEEBRw0NIAMQuyMMDQsgBCgCACAEKAIEIgMoAghBAWtBeHFqQQhqIQQjAEEgayIBJAAgAUEIaiAEIAMoAhARAAAgAUEQaiABKAIIIgMgASgCDCgCDBEAACABKQMYIQ4gASkDECEPIAFBIGokACADQQAgD0L75PLhsbPtw3yFIA5CgbfKnrar7cxuhYRQGyIGRQRAQYzf0ABBCkGY39AAEMskAAsgBUHIAmogCigCAEEIaiACIAcgBkEMahC2ASAFKALIAiIIQYSAgIB4Rg0KIAVBwAJqIgEgBUHkAmooAgA2AgAgBUG4AmoiAyAFQdwCaikCADcDACAFQbACaiIEIAVB1AJqKQIANwMAIAUgBSkCzAI3A6gCIAVByABqIgogBUHoAmpBKPwKAAAgBUH4AGoiCyAEKQMANwMAIAVBgAFqIgwgAykDADcDACAFQYgBaiINIAEoAgA2AgAgBSAFKQOoAjcDcCAGKAIUIgEgASgCACIDQQFqNgIAIANBAEgNAyAGKAIcIQMgBigCGCEJQcgAQQQQrTYiBEUNDSAEIAg2AgAgBCAFKQNwNwIEIARBDGogCykDADcCACAEQRRqIAwpAwA3AgAgBEEcaiANKAIANgIAIARBIGogCkEo/AoAACAFQTBqIAYQmTYQ7iUgAUEQdiEGDAgLIwBBIGsiAyQAIANBCGogBCgCACAEKAIEIgQoAghBAWtBeHFqQQhqIAQoAhARAAAgA0EQaiADKAIIIgQgAygCDCgCDBEAACADKQMYIQ4gAykDECEPIANBIGokACAEQQAgD0L/2euq19iLjPEAhSAOQoH04aOq+Nbqi3+FhFAbIgNFBEBByN7QAEEVQeDe0AAQyyQACyAFQcgCaiAKKAIAQQhqIAIgByADQQxqELYBIAUoAsgCIgZBhICAgHhGDQYgBUHAAmoiBCAFQeQCaigCADYCACAFQbgCaiIJIAVB3AJqKQIANwMAIAVBsAJqIgggBUHUAmopAgA3AwAgBSAFKQLMAjcDqAIgBUGQA2oiCiAFQegCakEo/AoAACAFQcADaiILIAgpAwA3AwAgBUHIA2oiCCAJKQMANwMAIAVB0ANqIgkgBCgCADYCACAFIAUpA6gCNwO4AyAFQdgDaiADEJs2EO4lQcgAQQQQrTYiBEUNDCAEIAY2AgAgBCAFKQO4AzcCBCAEQQxqIAspAwA3AgAgBEEUaiAIKQMANwIAIARBHGogCSgCADYCACAEQSBqIApBKPwKAAAgBUE4aiAFQegDaikCADcDACAFIAUpAuADNwMwIAEoAiwhCSAFKALYAyEDIAIhASAHIQYgBS8B3AMhAiAFLwHeAyEHQYKAgIB4DAgLIAQoAgAgBCgCBCIDKAIIQQFrQXhxakEIaiEEIwBBIGsiASQAIAFBCGogBCADKAIQEQAAIAFBEGogASgCCCIDIAEoAgwoAgwRAAAgASkDGCEOIAEpAxAhDyABQSBqJAAgA0EAIA9C4//bxtnAsr/aAIUgDkLrqof3kZGQlSSFhFAbIgRFBEBBjN/QAEEKQZjf0AAQyyQACyAFQcgCaiAKKAIAQQhqIAIgByAEQQxqELYBIAUoAsgCIgZBhICAgHhGDQQgBUHAAmoiASAFQeQCaigCADYCACAFQbgCaiIDIAVB3AJqKQIANwMAIAVBsAJqIgkgBUHUAmopAgA3AwAgBSAFKQLMAjcDqAIgBUGQAWoiCCAFQegCakEo/AoAACAFQcABaiIKIAkpAwA3AwAgBUHIAWoiCyADKQMANwMAIAVB0AFqIgwgASgCADYCACAFIAUpA6gCNwO4ASAEKAIUIgEgASgCACIDQQFqNgIAIANBAEgNASAEKAIcIQMgBCgCGCEJIAVBMGogBBCZNhDuJUHIAEEEEK02IgRFDQsgBCAGNgIAIAQgBSkDuAE3AgQgBEEMaiAKKQMANwIAIARBFGogCykDADcCACAEQRxqIAwoAgA2AgAgBEEgaiAIQSj8CgAAIAFBEHYhBkGBgICAeAwHCyAFQcACaiIBIAVB5AJqKAIANgIAIAVBuAJqIgMgBUHcAmopAgA3AwAgBUGwAmoiBCAFQdQCaikCADcDACAFIAUpAswCNwOoAiAFQeABaiIKIAVB6AJqQSj8CgAAIAVBkAJqIgsgBCkDADcDACAFQZgCaiIMIAMpAwA3AwAgBUGgAmoiDSABKAIANgIAIAUgBSkDqAI3A4gCIAYoAkAiASABKAIAIgNBAWo2AgAgA0EASA0AIAYoAkghAyAGKAJEIQlByABBBBCtNiIERQ0KIAQgCDYCACAEIAUpA4gCNwIEIARBDGogCykDADcCACAEQRRqIAwpAwA3AgAgBEEcaiANKAIANgIAIARBIGogCkEo/AoAACAFQTBqIAYQmjYQ7iUgBSgC2AEiBiAGKAIAIghBAWs2AgAgAUEQdiEGIAhBAUcNBSAFQdgBahC7IwwFCwALQQRBPBCjPQALQczBzQBBKEH0wc0AEJ8pAAsgBUG8AmogBUHgAmopAwAiDjcCACAFQbQCaiAFQdgCaikDACIPNwIAIAUgBSkD0AIiEDcCrAIgAEEYaiAONwIAIABBEGogDzcCACAAIBA3AgggAEGEgICAeDYCAAwFCyAFQbwCaiAFQeACaikDACIONwIAIAVBtAJqIAVB2AJqKQMAIg83AgAgBSAFKQPQAiIQNwKsAiAAQRhqIA43AgAgAEEQaiAPNwIAIAAgEDcCCCAAQYSAgIB4NgIADAQLQYCAgIB4CyEIIAAgBzsBFiAAIAI7ARQgACADNgIQIAAgCTYCDCAAIAY7AQogACABOwEIIAAgBDYCBCAAIAg2AgAgACAFKQMwNwIYIAAgBSkCGDcCMCAAQSBqIAVBOGopAwA3AgAgAEEoaiAFQUBrKQMANwIAIABBOGogBUEgaikCADcCACAAQUBrIAVBKGopAgA3AgAMAgsgBUG8AmogBUHgAmopAwAiDjcCACAFQbQCaiAFQdgCaikDACIPNwIAIAUgBSkD0AIiEDcCrAIgAEEYaiAONwIAIABBEGogDzcCACAAIBA3AgggAEGEgICAeDYCAAwBCyAFIAFBNGo2AhAgBSAINgLYASAFIAQQ8y02AhggBUEDNgKsAiAFQdzAzQA2AqgCIAVCAzcCtAIgBUGnBDYC3AIgBUGnBDYC1AIgBUGEATYCzAIgBSAFQcgCajYCsAIgBSAFQRhqNgLYAiAFIAVB2AFqNgLQAiAFIAVBEGo2AsgCIAVBMGoiASAFQagCahCZDiAAQQxqIAEQ3SAgAEGEgICAeDYCACAAQQM2AgggARDeOwsgBUHwA2okAA8LQQRByAAQoz0AC9+sAQITfwJ+IwBBgANrIgYkACAGQQA6ABQgBkGAgICAeDYCECAGQsCAgICAyNAHNwIIIAZBADYCLCAGQgA3AiQgBiACNgIcIAYgATYCGCAGIAZBCGo2AiAgBkHIAmogBkEYakEAEJQOIAYoAswCIQ0CQAJAIAYoAsgCIgNBioCAgHhHBEAgBkHAAWogBkHkAmopAgA3AwAgBiAGKQLcAjcDuAEgBikC1AIhFiAGKALQAiEHDAELIAZByAJqIAZBGGogDRC1BiAGKQLUAiEWIAYoAtACIQcgBigCzAIhDSAGKALIAiIDQYqAgIB4RwRAIAZBwAFqIAZB5AJqKQIANwMAIAYgBikC3AI3A7gBDAELIAYgFjcCOCAGIAc2AjQgBiANNgIwIAZByAJqIAZBMGpBBBDdECAGKALQAiEHIAYoAswCIQ0gBigCyAIiA0GKgICAeEcEQCAGQcABaiAGQeQCaikCADcDACAGIAYpAtwCNwO4ASAGKQLUAiEWDAELAkACQCANQQFxRQ0AAkAgB0EBcQRAIAYgBzYC5AIgBkEDNgLgAiAGQcn2/gA2AtwCIAZBgICAgHg2AtgCIAZCBDcC0AIgBkKEgICACDcCyAIMAQtBfyAHQQJqIgMgAyAHSRsiDSAGKAIwIgMoAgRNBEAgAyADKAIUQQJqIg02AhQgAygCCCgCCCANTwRAIAZBioCAgHg2AsgCDAILIAZBiICAgHg2AsgCDAELIAZByAJqIAcgDRC/LwsgBkEHNgLIASAGQbD3/gA2AsQBIAZBgICAgHg2AsABIAYgBzYCvAEgBkEBNgK4ASAGQZQCaiAGQcgCaiAGQbgBahCBFCAGKAKUAiIDQYqAgIB4Rg0ADAELIAYgBikCODcCSCAGIAYpAjA3AkAgBkHIAmogBkFAa0EIEN0QIAYoAtACIQ0gBigCzAIhBwJAIAYoAsgCIgNBioCAgHhHBEAgBkH4AWogBkHkAmopAgA3AgAgBkHwAWogBkHcAmopAgA3AgAgBiAGKQLUAjcC6AEgBiANNgLkASAGIAc2AuABDAELIAZByAJqIAZBQGtBBhDdECAGKALQAiEFIAYoAswCIQggBigCyAIiA0GKgICAeEcEQCAGQfgBaiAGQeQCaikCADcCACAGQfABaiAGQdwCaikCADcCACAGIAYpAtQCNwLoASAGIAU2AuQBIAYgCDYC4AEMAQsCQAJAAkAgCEEBcQRAIAdBAXENAQwDCyAHQQFxDQIgBkHgAWohDQwBCwJAIAVBAWoiB0F/IAcbIgMgBigCQCIHKAIETQRAIAcgBygCFEEBaiIDNgIUIAcoAggoAgggA08EQCAGQYqAgIB4NgLIAgwCCyAGQYiAgIB4NgLIAgwBCyAGQcgCaiAFIAMQvy8LIAZBCzYCyAEgBkG39/4ANgLEASAGQYCAgIB4NgLAASAGIAU2ArwBIAZBATYCuAEgBkGUAmogBkHIAmogBkG4AWoQgRQgBigClAIiA0GKgICAeEcEQCAGQfgBaiAGQbACaikCADcCACAGQfABaiAGQagCaikCADcCACAGQegBaiAGQaACaikCADcCACAGIAYpApgCNwLgAQwDCyAGKAJAIgcoAgQiAyAFTwRAAkACQAJAAkACQAJAAkAgBygCACAFai0AAEEBaw4FAQIDBAUACyAGQYqAgIB4NgLIAgwFCyAGQcgCaiMAQbACayIFJAAgBUGMAmogByANEJMOIAUoApACIQMCQCAFKAKMAiIIQYqAgIB4RwRAIAVBJGogBUGsAmooAgA2AgAgBUEcaiAFQaQCaikCADcCACAFQRRqIAVBnAJqKQIANwIAIAUgBSkClAI3AgwgBSADNgIIIAUgCDYCBAwBCyAFQYwCaiAHQX8gAyANaiIHIAMgB0sbELQGIAVB+ABqIgcgBUGYAmopAgA3AwAgBSAFKQKQAjcDcCAFKAKMAiIDQYqAgIB4RwRAIAVBIGogBUGoAmopAgA3AgAgBUEQaiAHKQMANwIAIAUgBSkCoAI3AhggBSAFKQNwNwIIIAUgAzYCBAwBCyAFQYgBaiAHKQMANwMAIAUgBSkDcDcDgAEgBUGMAmogBUGAAWpBBBDdECAFKAKUAiEHIAUoApACIQgCQAJ+IAUoAowCIgRBioCAgHhHBEAgBUG4AWogBUGoAmopAgA3AwAgBSAFKQKgAjcDsAEgBSkCmAIMAQsgCEEBcUUNAQJAIAdBAXEEQCAFIAc2AqgCIAVBAzYCpAIgBUG55P4ANgKgAiAFQYCAgIB4NgKcAiAFQgQ3ApQCIAVChICAgAg3AowCDAELQX8gB0ECaiIDIAMgB0kbIgggBSgCgAEiAygCBE0EQCADIAMoAhRBAmoiCDYCFCADKAIIKAIIIAhPBEAgBUGKgICAeDYCjAIMAgsgBUGIgICAeDYCjAIMAQsgBUGMAmogByAIEL8vCyAFQQo2AsABIAVBjuv+ADYCvAEgBUGAgICAeDYCuAEgBSAHNgK0ASAFQQE2ArABIAVB6AFqIAVBjAJqIAVBsAFqEIEUIAUoAugBIgRBioCAgHhGDQEgBUG4AWogBUGEAmopAgA3AwAgBSAFKQL8ATcDsAEgBSgC8AEhByAFKALsASEIIAUpAvQBCyEWIAVBIGogBUG4AWopAwA3AgAgBSAWNwIQIAUgBzYCDCAFIAg2AgggBSAENgIEIAUgBSkDsAE3AhgMAQsgBSAFKQOIATcCmAEgBSAFKQOAATcCkAEgBUHEAWogBUGQAWpBmOv+AEEGQQYQlwEgBUHoAGoiByAFQdABaikCADcDACAFIAUpAsgBNwNgIAUoAsQBIgNBioCAgHhHBEAgBUEgaiAFQeABaikCADcCACAFQRBqIAcpAwA3AgAgBSAFKQLYATcCGCAFIAUpA2A3AgggBSADNgIEDAELIAVBqAFqIAcpAwA3AwAgBSAFKQNgNwOgASAFQTxqIAVBoAFqQQgQ7wMgBUEwaiIHIAVByABqKQIANwMAIAUgBSkCQDcDKCAFKAI8IgNBioCAgHhHBEAgBUEgaiAFQdgAaikCADcCACAFQRBqIAcpAwA3AgAgBSAFKQJQNwIYIAUgBSkDKDcCCCAFIAM2AgQMAQsgBUG4AWogBUEwaikDADcDACAFIAUpAyg3A7ABIAVBjAJqIAVBsAFqQQoQ3RAgBSgClAIhByAFKAKQAiEIAkACfiAFKAKMAiIEQYqAgIB4RwRAIAVB8AFqIAVBqAJqKQIANwMAIAUgBSkCoAI3A+gBIAUpApgCDAELIAhBAXFFDQEgBUGMAmogBSgCsAEiAyAHEJMOIAUoApACIQkCQCAFKAKMAiIIQYqAgIB4RwRAIAVBiAJqIAVBrAJqKAIANgIAIAVBgAJqIAVBpAJqKQIANwIAIAVB+AFqIAVBnAJqKQIANwIAIAUgBSkClAI3AvABIAUgCTYC7AEgBSAINgLoAQwBCyAFQYwCaiEIIwBBMGsiBCQAIARBDGogA0F/IAcgCWoiCyAJIAtLGyIJEJMOIAQoAhAhCwJAIAQoAgwiCkGKgICAeEcEQCAIIAQpAhQ3AgggCEEgaiAEQSxqKAIANgIAIAhBGGogBEEkaikCADcCACAIQRBqIARBHGopAgA3AgAgCCALNgIEIAggCjYCAAwBC0F/IAlBBGoiCiAJIApLGyIJQQdxBEAgCCAJNgIcIAhBHzYCGCAIQYDj/gA2AhQgCEGAgICAeDYCECAIQgQ3AgggCEKEgICACDcCAAwBCwJAAkBBfyAJQX8gC0EDdCALQf////8BSxsiCmoiCyAJIAtLGyILIAMoAgRNBEAgAyADKAIUIApqIg42AhRBiICAgHghCiAOIAMoAggoAghLDQEMAgsgBEEMaiAJIAsQvy8gBCgCDCIKQYqAgIB4Rg0BCyAIIAQpAhA3AgQgCEEcaiAEQShqKQIANwIAIAhBFGogBEEgaikCADcCACAIQQxqIARBGGopAgA3AgAgCCAKNgIADAELIAggCzYCCCAIIAk2AgQgCEGKgICAeDYCAAsgBEEwaiQAIAUoAowCIgNBioCAgHhHBEAgBUH8AWogBUGgAmopAgA3AgAgBUGEAmogBUGoAmopAgA3AgAgBSAFKQKYAjcC9AEgBSAFKQKQAjcC7AELIAUgAzYC6AELIAVBCDYCnAIgBUGe6/4ANgKYAiAFQYCAgIB4NgKUAiAFIAc2ApACIAVBATYCjAIgBUHEAWogBUHoAWogBUGMAmoQgRQgBSgCxAEiBEGKgICAeEYNASAFQfABaiAFQeABaikCADcDACAFIAUpAtgBNwPoASAFKALMASEHIAUoAsgBIQggBSkC0AELIRYgBUEgaiAFQfABaikDADcCACAFIBY3AhAgBSAHNgIMIAUgCDYCCCAFIAQ2AgQgBSAFKQPoATcCGAwBCyAFKAKwASIHIAcoAgxBAWs2AgwgBUGKgICAeDYCBAsgBUEVNgKcAiAFQeH3/gA2ApgCIAVBgICAgHg2ApQCIAUgDTYCkAIgBUECNgKMAiAFQQRqIAVBjAJqEIEUIAVBsAJqJAAMBAsgBkHIAmojAEHQAWsiAyQAIANBlAFqIAcgDRCTDiADKAKYASEFAkAgAygClAEiCEGKgICAeEcEQCADQSxqIANBtAFqKAIANgIAIANBJGogA0GsAWopAgA3AgAgA0EcaiADQaQBaikCADcCACADIAMpApwBNwIUIAMgBTYCECADIAg2AgwMAQsgA0GUAWogB0F/IAUgDWoiByAFIAdLGxC0BiADQThqIgcgA0GgAWopAgA3AwAgAyADKQKYATcDMCADKAKUASIFQYqAgIB4RwRAIANBKGogA0GwAWopAgA3AgAgA0EYaiAHKQMANwIAIAMgAykCqAE3AiAgAyADKQMwNwIQIAMgBTYCDAwBCyADQcgAaiAHKQMANwMAIAMgAykDMDcDQCADQZQBaiADQUBrQQQQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQECQCAHQQdxBEAgAyAHNgKwASADQQM2AqwBIANBsOT+ADYCqAEgA0GAgICAeDYCpAEgA0IENwKcASADQoSAgIAINwKUAQwBC0F/IAdBCGoiBSAFIAdJGyIIIAMoAkAiBSgCBE0EQCAFIAUoAhRBCGoiCDYCFCAFKAIIKAIIIAhPBEAgA0GKgICAeDYClAEMAgsgA0GIgICAeDYClAEMAQsgA0GUAWogByAIEL8vCyADQQI2AsgBIANB5+b+ADYCxAEgA0GAgICAeDYCwAEgAyAHNgK8ASADQQE2ArgBIANB8ABqIANBlAFqIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADIAMpA0g3AlggAyADKQNANwJQIANBlAFqIANB0ABqQQYQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQEgA0GUAWoiBSADKAJQIAcQsgEgA0EENgLIASADQenm/gA2AsQBIANBgICAgHg2AsABIAMgBzYCvAEgA0EBNgK4ASADQfAAaiAFIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADIAMpAlg3AmggAyADKQJQNwJgIANBlAFqIANB4ABqQQgQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQECQCAHQQFqIgVBfyAFGyIIIAMoAmAiBSgCBE0EQCAFIAUoAhRBAWoiCDYCFCAFKAIIKAIIIAhPBEAgA0GKgICAeDYClAEMAgsgA0GIgICAeDYClAEMAQsgA0GUAWogByAIEL8vCyADQQc2AsgBIANB7eb+ADYCxAEgA0GAgICAeDYCwAEgAyAHNgK8ASADQQE2ArgBIANB8ABqIANBlAFqIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADKAJgIgcgBygCDEEBazYCDCADQYqAgIB4NgIMCyADQR42AqQBIANB9vf+ADYCoAEgA0GAgICAeDYCnAEgAyANNgKYASADQQI2ApQBIANBDGogA0GUAWoQgRQgA0HQAWokAAwDCyMAQUBqIgMkACADQQhqIgUgByANELIBIANBGjYCPCADQZT4/gA2AjggA0GAgICAeDYCNCADIA02AjAgA0ECNgIsIAZByAJqIAUgA0EsahCBFCADQUBrJAAMAgsgBkHIAmpCACEWIwBBkAJrIgQkACAEQewBaiAHIA0Qkw4gBCgC8AEhAwJAIAQoAuwBIgVBioCAgHhHBEAgBEEkaiAEQYwCaigCADYCACAEQRxqIARBhAJqKQIANwIAIARBFGogBEH8AWopAgA3AgAgBCAEKQL0ATcCDCAEIAM2AgggBCAFNgIEDAELIARB7AFqIAdBfyADIA1qIgcgAyAHSxsQtAYgBEHoAGoiByAEQfgBaikCADcDACAEIAQpAvABNwNgIAQoAuwBIgNBioCAgHhHBEAgBEEgaiAEQYgCaikCADcCACAEQRBqIAcpAwA3AgAgBCAEKQKAAjcCGCAEIAQpA2A3AgggBCADNgIEDAELIARB+ABqIAcpAwA3AwAgBCAEKQNgNwNwIARB7AFqIARB8ABqQQYQ3RAgBCgC9AEhByAEKALwASEDAn8gBCgC7AEiCUGKgICAeEcEQCAEKAKMAiELIAQoAogCIQogBCgCgAIhDCAEKAL8ASEOIAQoAvgBIQ8gBCgChAIMAQsgBEHsAWogBEHwAGpBBBDdECAEKAL0ASEFIAQoAvABIQggBCgC7AEiCUGKgICAeEcEQCAEKAKMAiELIAQoAogCIQogBCgCgAIhDCAEKAL8ASEOIAQoAvgBIQ8gBSEHIAghAyAEKAKEAgwBCwJAAkAgCEEBcQRAIANBAXENAQwCCyADQQFxDQFBBCEHQYCAgIB4IQ5Bguj+ACEMQQAhA0GAgICAeCEJQQUMAgsCQCAFQQFqIgNBfyADGyIIIAQoAnAiAygCBE0EQCADIAMoAhRBAWoiCDYCFCADKAIIKAIIIAhPBEAgBEGKgICAeDYC7AEMAgsgBEGIgICAeDYC7AEMAQsgBEHsAWogBSAIEL8vCyAEQQk2ArQBIARB+ef+ADYCsAEgBEGAgICAeDYCrAEgBCAFNgKoASAEQQE2AqQBIARByAFqIARB7AFqIARBpAFqEIEUIAQoAsgBIglBioCAgHhHBEAgBCgC6AEhCyAEKALkASEKIAQoAtwBIQwgBCgC2AEhDiAEKALUASEPIAQoAtABIQcgBCgCzAEhAyAEKALgAQwCCwJAAn8CQAJAIAQoAnAiAygCBCIIIAVPBEACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADKAIAIAVqLQAAQQFrDhoBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGgALIARBioCAgHg2AsgBDBoLIARByAFqIANBqOj+AEEKIAcQqBAMGQsgBEHsAWoiBSADIAcQ+AYgBEEJNgKgASAEQbLo/gA2ApwBIARBgICAgHg2ApgBIAQgBzYClAEgBEECNgKQASAEQcgBaiAFIARBkAFqEIEUDBgLIARByAFqIAMgBxDeCAwXCyAEQcgBaiADQc7o/gBBDCAHEKgQDBYLIARByAFqIANB2uj+AEEKIAcQqBAMFQsgBEHIAWogA0Hk6P4AQQogBxCoEAwUCyAEQcgBaiADIAcQogMMEwsgBEHIAWogA0H76P4AQQogBxDfCAwSCyAEQcgBaiADIAcQlQYMEQsgBEHIAWogAyAHEOMHDBALIARByAFqIANBnun+AEEOIAcQ3wgMDwsgBEHIAWogA0Gs6f4AQQogBxCoEAwOCyAEQcgBaiADQbbp/gBBDSAHEKgQDA0LIARByAFqIAMgBxCpBQwMCyAEQcgBaiADIAcQ4AgMCwsgBEHIAWogAyAHEN0IDAoLIARByAFqIAMgBxCCCQwJCyAEQcgBaiADQf/p/gBBDiAHEN8IDAgLIARByAFqIANBjer+AEERIAcQqBAMBwsgBEHIAWogA0Ge6v4AQQ8gBxCoEAwGCyAEQcgBaiADQa3q/gBBDyAHEKgQDAULIARByAFqIANBvOr+AEETIAcQqBAMBAsgBEHIAWogA0HP6v4AQRAgBxCoEAwDCyAEQcgBaiADQd/q/gBBDiAHEKgQDAILIARByAFqIANB7er+AEEOIAcQqBAMAQsgBEHIAWogA0H76v4AQRMgBxCoEAsgBEEFNgL8ASAEQYLo/gA2AvgBIARBgICAgHg2AvQBIAQgBzYC8AEgBEEBNgLsASAEQaQBaiAEQcgBaiAEQewBahCBFCAEKAKkASIJQYqAgIB4RwRAIAQoAsQBIQsgBCgCwAEhCiAEKAK4ASEMIAQoArQBIQ4gBCgCsAEhDyAEKAKsASEHIAQoAqgBIQMgBCgCvAEMBwsgBCAEKQN4NwKIASAEIAQpA3A3AoABIARBPGogBEGAAWoQ+wIgBEEwaiIHIARByABqKQIANwMAIAQgBCkCQDcDKCAEKAI8IgNBioCAgHhHBEAgBEEgaiAEQdgAaikCADcCACAEQRBqIAcpAwA3AgAgBCAEKQJQNwIYIAQgBCkDKDcCCCAEIAM2AgQMCAsgBEGYAWogBykDADcDACAEIAQpAyg3A5ABIARB7AFqIARBkAFqQQoQ3RAgBCgC9AEhCSAEKALwASEDAkACfiAEKALsASIHQYqAgIB4RwRAIARB0AFqIARBiAJqKQIANwMAIAQgBCkCgAI3A8gBIAQpAvgBDAELIANBAXFFDQEgBEHsAWogBCgCkAEiAyAJEJMOIAQoAvABIQcCQCAEKALsASIFQYqAgIB4RwRAIARB6AFqIARBjAJqKAIANgIAIARB4AFqIARBhAJqKQIANwIAIARB2AFqIARB/AFqKQIANwIAIAQgBCkC9AE3AtABIAQgBzYCzAEgBCAFNgLIAQwBCyAEQewBaiADQX8gByAJaiIDIAMgB0kbEIYOIAQoAuwBIgdBioCAgHhHBEAgBEHcAWogBEGAAmopAgA3AgAgBEHkAWogBEGIAmopAgA3AgAgBCAEKQL4ATcC1AEgBCAEKQLwATcCzAELIAQgBzYCyAELIARBBzYC/AEgBEHI7f4ANgL4ASAEQYCAgIB4NgL0ASAEIAk2AvABIARBATYC7AEgBEGkAWogBEHIAWogBEHsAWoQgRQgBCgCpAEiB0GKgICAeEYNASAEQdABaiAEQcABaikCADcDACAEIAQpArgBNwPIASAEKAKsASEJIAQoAqgBIQMgBCkCsAELIRYgBEEgaiAEQdABaikDADcCACAEIBY3AhAgBCAJNgIMIAQgAzYCCCAEIAc2AgQgBCAEKQPIATcCGAwICyAEIAQpA5gBNwJEIAQgBCkDkAE3AjwgBEHsAWogBEE8akEMEN0QIAQoAvQBIQkgBCgC8AEhAyAEKALsASIHQYqAgIB4RwRAIAQpAogCIRYgBCgChAIhCyAEKAKAAiEKIAQoAvgBIQwgBCgC/AEMBAsgA0EBcUUEQEHp5v4AIQpBBCELQQQhCUEAIQNBgICAgHghB0GAgICAeAwEC0F/IAlBEGoiByAHIAlJGyIDIAQoAjwiBygCBEsNASAHIAcoAhRBEGoiAzYCFCAHKAIIKAIIIANPBEAgBEGKgICAeDYC7AEMAwsgBEGIgICAeDYC7AEMAgsgBSAIQdDh/gAQrzsACyAEQewBaiAJIAMQvy8LIARBBDYCtAEgBEHp5v4ANgKwASAEQYCAgIB4NgKsASAEIAk2AqgBIARBATYCpAEgBEHIAWogBEHsAWogBEGkAWoQgRQgBCgCyAEiB0GKgICAeEYNASAEKQLkASEWIAQoAuABIQsgBCgC3AEhCiAEKALUASEMIAQoAtABIQkgBCgCzAEhAyAEKALYAQshBSAEIBY3AiAgBCALNgIcIAQgCjYCGCAEIAU2AhQgBCAMNgIQIAQgCTYCDCAEIAM2AgggBCAHNgIEDAMLIAQoAjwiByAHKAIMQQFrNgIMIARBioCAgHg2AgQMAgtBBCEDQQAhB0H55/4AIQ5BCSEMQYLo/gAhCkEFIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAMNgIYIAQgDjYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQLIARBFTYC/AEgBEGu+P4ANgL4ASAEQYCAgIB4NgL0ASAEIA02AvABIARBAjYC7AEgBEEEaiAEQewBahCBFCAEQZACaiQADAELIAZByAJqQgAhFiMAQaACayIEJAAgBEH8AWogByANEJMOIAQoAoACIQMCQCAEKAL8ASIFQYqAgIB4RwRAIARBJGogBEGcAmooAgA2AgAgBEEcaiAEQZQCaikCADcCACAEQRRqIARBjAJqKQIANwIAIAQgBCkChAI3AgwgBCADNgIIIAQgBTYCBAwBCyAEQfwBaiAHQX8gAyANaiIHIAMgB0sbELQGIARB6ABqIgcgBEGIAmopAgA3AwAgBCAEKQKAAjcDYCAEKAL8ASIDQYqAgIB4RwRAIARBIGogBEGYAmopAgA3AgAgBEEQaiAHKQMANwIAIAQgBCkCkAI3AhggBCAEKQNgNwIIIAQgAzYCBAwBCyAEQfgAaiAHKQMANwMAIAQgBCkDYDcDcCAEQfwBaiAEQfAAakEGEN0QIAQoAoQCIQcgBCgCgAIhAwJ/IAQoAvwBIglBioCAgHhHBEAgBCgCnAIhCyAEKAKYAiEKIAQoApACIQ4gBCgCjAIhDCAEKAKIAiEPIAQoApQCDAELIARB/AFqIARB8ABqQQQQ3RAgBCgChAIhBSAEKAKAAiEIIAQoAvwBIglBioCAgHhHBEAgBCgCnAIhCyAEKAKYAiEKIAQoApACIQ4gBCgCjAIhDCAEKAKIAiEPIAUhByAIIQMgBCgClAIMAQsCQAJAIAhBAXEEQCADQQFxDQEMAgsgA0EBcQ0BQQQhB0GAgICAeCEMQYLo/gAhDkEAIQNBgICAgHghCUEFDAILAkAgBUEBaiIDQX8gAxsiCCAEKAJwIgMoAgRNBEAgAyADKAIUQQFqIgg2AhQgAygCCCgCCCAITwRAIARBioCAgHg2AvwBDAILIARBiICAgHg2AvwBDAELIARB/AFqIAUgCBC/LwsgBEEJNgKwASAEQfnn/gA2AqwBIARBgICAgHg2AqgBIAQgBTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFCAEKALYASIJQYqAgIB4RwRAIAQoAvgBIQsgBCgC9AEhCiAEKALsASEOIAQoAugBIQwgBCgC5AEhDyAEKALgASEHIAQoAtwBIQMgBCgC8AEMAgsCQAJ+AkACQCAEKAJwIgMoAgQiCCAFTwRAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAygCACAFai0AAEEBaw4aAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRoACyAEQYqAgIB4NgLYAQwaCyAEQdgBaiADQajo/gBBCiAHEKgQDBkLIARB/AFqIgUgAyAHEPgGIARBCTYC1AEgBEGy6P4ANgLQASAEQYCAgIB4NgLMASAEIAc2AsgBIARBAjYCxAEgBEHYAWogBSAEQcQBahCBFAwYCyAEQdgBaiADIAcQ3ggMFwsgBEHYAWogA0HO6P4AQQwgBxCoEAwWCyAEQdgBaiADQdro/gBBCiAHEKgQDBULIARB2AFqIANB5Oj+AEEKIAcQqBAMFAsgBEHYAWogAyAHEKIDDBMLIARB2AFqIANB++j+AEEKIAcQ3wgMEgsgBEHYAWogAyAHEJUGDBELIARB2AFqIAMgBxDjBwwQCyAEQdgBaiADQZ7p/gBBDiAHEN8IDA8LIARB2AFqIANBrOn+AEEKIAcQqBAMDgsgBEHYAWogA0G26f4AQQ0gBxCoEAwNCyAEQdgBaiADIAcQqQUMDAsgBEHYAWogAyAHEOAIDAsLIARB2AFqIAMgBxDdCAwKCyAEQdgBaiADIAcQggkMCQsgBEHYAWogA0H/6f4AQQ4gBxDfCAwICyAEQdgBaiADQY3q/gBBESAHEKgQDAcLIARB2AFqIANBnur+AEEPIAcQqBAMBgsgBEHYAWogA0Gt6v4AQQ8gBxCoEAwFCyAEQdgBaiADQbzq/gBBEyAHEKgQDAQLIARB2AFqIANBz+r+AEEQIAcQqBAMAwsgBEHYAWogA0Hf6v4AQQ4gBxCoEAwCCyAEQdgBaiADQe3q/gBBDiAHEKgQDAELIARB2AFqIANB++r+AEETIAcQqBALIARBBTYCjAIgBEGC6P4ANgKIAiAEQYCAgIB4NgKEAiAEIAc2AoACIARBATYC/AEgBEGgAWogBEHYAWogBEH8AWoQgRQgBCgCoAEiCUGKgICAeEcEQCAEKALAASELIAQoArwBIQogBCgCtAEhDiAEKAKwASEMIAQoAqwBIQ8gBCgCqAEhByAEKAKkASEDIAQoArgBDAcLIAQgBCkDeDcCiAEgBCAEKQNwNwKAASAEQTxqIARBgAFqEPsCIARBMGoiByAEQcgAaikCADcDACAEIAQpAkA3AyggBCgCPCIDQYqAgIB4RwRAIARBIGogBEHYAGopAgA3AgAgBEEQaiAHKQMANwIAIAQgBCkCUDcCGCAEIAQpAyg3AgggBCADNgIEDAgLIARBmAFqIAcpAwA3AwAgBCAEKQMoNwOQASAEQfwBaiAEQZABakEKEN0QIAQoAoQCIQkgBCgCgAIhAyAEKAL8ASIHQYqAgIB4RwRAIARBqAFqIARBmAJqKQIANwMAIAQgBCkCkAI3A6ABIAQpAogCDAQLIANBAXFFDQQgCUEHcQRAIAQgCTYCmAIgBEEDNgKUAiAEQbDk/gA2ApACIARBgICAgHg2AowCIARCBDcChAIgBEKEgICACDcC/AEMAwtBfyAJQQhqIgcgByAJSRsiAyAEKAKQASIHKAIESw0BIAcgBygCFEEIaiIDNgIUIAcoAggoAgggA08EQCAEQYqAgIB4NgL8AQwDCyAEQYiAgIB4NgL8AQwCCyAFIAhB0OH+ABCvOwALIARB/AFqIAkgAxC/LwsgBEEPNgKwASAEQaTs/gA2AqwBIARBgICAgHg2AqgBIAQgCTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFCAEKALYASIHQYqAgIB4Rg0BIARBqAFqIARB9AFqKQIANwMAIAQgBCkC7AE3A6ABIAQoAuABIQkgBCgC3AEhAyAEKQLkAQshFiAEQSBqIARBqAFqKQMANwIAIAQgFjcCECAEIAk2AgwgBCADNgIIIAQgBzYCBCAEIAQpA6ABNwIYDAMLIAQgBCkDmAE3AswBIAQgBCkDkAE3AsQBIARB/AFqIARBxAFqQQ4Q3RAgBCgChAIhByAEKAKAAiEDAn8gBCgC/AEiCUGKgICAeEcEQCAEKAKcAiELIAQoApgCIQogBCgCkAIhDiAEKAKMAiEMIAQoAogCIQ8gBCgClAIMAQsgBEH8AWogBEHEAWpBDBDdECAEKAKEAiEFIAQoAoACIQggBCgC/AEiCUGKgICAeEcEQCAEKAKcAiELIAQoApgCIQogBCgCkAIhDiAEKAKMAiEMIAQoAogCIQ8gBSEHIAghAyAEKAKUAgwBCwJAAkAgCEEBcQRAIANBAXENAQwCCyADQQFxDQFBBCEHQYCAgIB4IQxBw+z+ACEOQQAhA0GAgICAeCEJQQsMAgsCQCAFQQFqIgNBfyADGyIIIAQoAsQBIgMoAgRNBEAgAyADKAIUQQFqIgg2AhQgAygCCCgCCCAITwRAIARBioCAgHg2AvwBDAILIARBiICAgHg2AvwBDAELIARB/AFqIAUgCBC/LwsgBEEQNgKwASAEQbPs/gA2AqwBIARBgICAgHg2AqgBIAQgBTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFAJAAn8CQAJAAkACQCAEKALYASIJQYqAgIB4RgRAIAUgBCgCxAEiCCgCBCIDSw0CAkACQAJAAkACQCAIKAIAIAVqLQAAQQFrDgMBAgMACyAEQYqAgIB4NgL8AQwDCyAEQfwBaiMAQfABayIDJAAgA0HMAWogCCAHEJMOIAMoAtABIQUCQCADKALMASIJQYqAgIB4RwRAIANBLGogA0HsAWooAgA2AgAgA0EkaiADQeQBaikCADcCACADQRxqIANB3AFqKQIANwIAIAMgAykC1AE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQcwBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQdgBaikCADcDACADIAMpAtABNwMwIAMoAswBIghBioCAgHhHBEAgA0EoaiADQegBaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLgATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANBzAFqIANBQGtBBBDdECADKALUASEJIAMoAtABIQUCQAJ/IAMoAswBIghBioCAgHhHBEAgAykC6AEhFiADKALgASELIAMoAtwBIQogAygC2AEhDCADKALkAQwBCyAFQQFxRQRAQYCAgIB4IQpBpuv+ACELQQQhCUEAIQVBgICAgHghCEELDAELIANBzAFqIgUgAygCQCAJEPgGIANBCzYCkAEgA0Gm6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogBSADQYABahCBFCADKAKoASIIQYqAgIB4Rg0BIAMpAsQBIRYgAygCvAEhCyADKAK4ASEKIAMoArQBIQwgAygCsAEhCSADKAKsASEFIAMoAsABCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQNINwJYIAMgAykDQDcCUCADQcwBaiADQdAAakEGEN0QIAMoAtQBIQkgAygC0AEhBQJAAn4gAygCzAEiCEGKgICAeEcEQCADQbABaiADQegBaikCADcDACADIAMpAuABNwOoASADKQLYAQwBCyAFQQFxRQ0BIANBzAFqIAMoAlAiCCAJEJMOIAMoAtABIQUCQCADKALMASILQYqAgIB4RwRAIANByAFqIANB7AFqKAIANgIAIANBwAFqIANB5AFqKQIANwIAIANBuAFqIANB3AFqKQIANwIAIAMgAykC1AE3ArABIAMgBTYCrAEgAyALNgKoAQwBCyADQcwBaiAIQX8gBSAJaiIIIAUgCEsbEIYOIAMoAswBIgVBioCAgHhHBEAgA0G8AWogA0HgAWopAgA3AgAgA0HEAWogA0HoAWopAgA3AgAgAyADKQLYATcCtAEgAyADKQLQATcCrAELIAMgBTYCqAELIANBDjYC3AEgA0Gx6/4ANgLYASADQYCAgIB4NgLUASADIAk2AtABIANBATYCzAEgA0GAAWogA0GoAWogA0HMAWoQgRQgAygCgAEiCEGKgICAeEYNASADQbABaiADQZwBaikCADcDACADIAMpApQBNwOoASADKAKIASEJIAMoAoQBIQUgAykCjAELIRYgA0EoaiADQbABaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQOoATcCIAwBCyADIAMpAlg3AmggAyADKQJQNwJgIANBzAFqIANB4ABqQQgQ3RAgAygC1AEhCSADKALQASEFAkACfyADKALMASIIQYqAgIB4RwRAIAMpAugBIRYgAygC4AEhCyADKALcASEKIAMoAtgBIQwgAygC5AEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkG/6/4AIQtBACEFQYCAgIB4IQhBDQwBCwJAQX8gCUEQaiIFIAUgCUkbIgggAygCYCIFKAIETQRAIAUgBSgCFEEQaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgLMAQwCCyADQYiAgIB4NgLMAQwBCyADQcwBaiAJIAgQvy8LIANBDTYCkAEgA0G/6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogA0HMAWogA0GAAWoQgRQgAygCqAEiCEGKgICAeEYNASADKQLEASEWIAMoArwBIQsgAygCuAEhCiADKAK0ASEMIAMoArABIQkgAygCrAEhBSADKALAAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMgAykCaDcCeCADIAMpAmA3AnAgA0HMAWogA0HwAGpBChDdECADKALUASEJIAMoAtABIQUCQAJ+IAMoAswBIghBioCAgHhHBEAgA0GIAWogA0HoAWopAgA3AwAgAyADKQLgATcDgAEgAykC2AEMAQsgBUEBcUUNAQJAIAlBAWoiBUF/IAUbIgggAygCcCIFKAIETQRAIAUgBSgCFEEBaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgLMAQwCCyADQYiAgIB4NgLMAQwBCyADQcwBaiAJIAgQvy8LIANBCzYCkAEgA0HM6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogA0HMAWogA0GAAWoQgRQgAygCqAEiCEGKgICAeEYNASADQYgBaiADQcQBaikCADcDACADIAMpArwBNwOAASADKAKwASEJIAMoAqwBIQUgAykCtAELIRYgA0EoaiADQYgBaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQOAATcCIAwBCyADKAJwIgUgBSgCDEEBazYCDCADQYqAgIB4NgIMCyADQSc2AtwBIANBzuz+ADYC2AEgA0GAgICAeDYC1AEgAyAHNgLQASADQQI2AswBIANBDGogA0HMAWoQgRQgA0HwAWokAAwCCyAEQfwBaiMAQfABayIDJAAgA0G0AWogCCAHEJMOIAMoArgBIQUCQCADKAK0ASIJQYqAgIB4RwRAIANBLGogA0HUAWooAgA2AgAgA0EkaiADQcwBaikCADcCACADQRxqIANBxAFqKQIANwIAIAMgAykCvAE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQbQBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQcABaikCADcDACADIAMpArgBNwMwIAMoArQBIghBioCAgHhHBEAgA0EoaiADQdABaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLIATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANBtAFqIANBQGtBBBDdECADKAK8ASEJIAMoArgBIQUCQAJ+IAMoArQBIghBioCAgHhHBEAgA0HgAWogA0HQAWopAgA3AwAgAyADKQLIATcD2AEgAykCwAEMAQsgBUEBcUUNAQJAIAlBAXEEQCADIAk2AtABIANBAzYCzAEgA0G55P4ANgLIASADQYCAgIB4NgLEASADQgQ3ArwBIANChICAgAg3ArQBDAELQX8gCUECaiIFIAUgCUkbIgggAygCQCIFKAIETQRAIAUgBSgCFEECaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgK0AQwCCyADQYiAgIB4NgK0AQwBCyADQbQBaiAJIAgQvy8LIANBDjYC6AEgA0HX6/4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgA0GQAWogA0G0AWogA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADQeABaiADQawBaikCADcDACADIAMpAqQBNwPYASADKAKYASEJIAMoApQBIQUgAykCnAELIRYgA0EoaiADQeABaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQPYATcCIAwBCyADIAMpA0g3AlggAyADKQNANwJQIANBtAFqIANB0ABqQQYQ3RAgAygCvAEhCSADKAK4ASEFAkACfyADKAK0ASIIQYqAgIB4RwRAIAMpAtABIRYgAygCyAEhCyADKALEASEKIAMoAsABIQwgAygCzAEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkHl6/4AIQtBACEFQYCAgIB4IQhBCgwBCyADQbQBaiIFIAMoAlAgCRD4BiADQQo2AugBIANB5ev+ADYC5AEgA0GAgICAeDYC4AEgAyAJNgLcASADQQE2AtgBIANBkAFqIAUgA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADKQKsASEWIAMoAqQBIQsgAygCoAEhCiADKAKcASEMIAMoApgBIQkgAygClAEhBSADKAKoAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMgAykCWDcCaCADIAMpAlA3AmAgA0G0AWogA0HgAGpBCBDdECADKAK8ASEJIAMoArgBIQUCQAJ/IAMoArQBIghBioCAgHhHBEAgAykC0AEhFiADKALIASELIAMoAsQBIQogAygCwAEhDCADKALMAQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQe/r/gAhC0EAIQVBgICAgHghCEEMDAELAkBBfyAJQRBqIgUgBSAJSRsiCCADKAJgIgUoAgRNBEAgBSAFKAIUQRBqIgg2AhQgBSgCCCgCCCAITwRAIANBioCAgHg2ArQBDAILIANBiICAgHg2ArQBDAELIANBtAFqIAkgCBC/LwsgA0EMNgLoASADQe/r/gA2AuQBIANBgICAgHg2AuABIAMgCTYC3AEgA0EBNgLYASADQZABaiADQbQBaiADQdgBahCBFCADKAKQASIIQYqAgIB4Rg0BIAMpAqwBIRYgAygCpAEhCyADKAKgASEKIAMoApwBIQwgAygCmAEhCSADKAKUASEFIAMoAqgBCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQJoNwJ4IAMgAykCYDcCcCADQbQBaiADQfAAakEKEN0QIAMoArwBIQkgAygCuAEhBQJAAn8gAygCtAEiCEGKgICAeEcEQCADKQLQASEWIAMoAsgBIQsgAygCxAEhCiADKALAASEMIAMoAswBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpBpuv+ACELQQAhBUGAgICAeCEIQQsMAQsgA0G0AWoiBSADKAJwIAkQ+AYgA0ELNgLoASADQabr/gA2AuQBIANBgICAgHg2AuABIAMgCTYC3AEgA0EBNgLYASADQZABaiAFIANB2AFqEIEUIAMoApABIghBioCAgHhGDQEgAykCrAEhFiADKAKkASELIAMoAqABIQogAygCnAEhDCADKAKYASEJIAMoApQBIQUgAygCqAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAng3AogBIAMgAykCcDcCgAEgA0G0AWogA0GAAWpBDBDdECADKAK8ASEJIAMoArgBIQUCQAJ/IAMoArQBIghBioCAgHhHBEAgAykC0AEhFiADKALIASELIAMoAsQBIQogAygCwAEhDCADKALMAQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQb/r/gAhC0EAIQVBgICAgHghCEENDAELAkBBfyAJQRBqIgUgBSAJSRsiCCADKAKAASIFKAIETQRAIAUgBSgCFEEQaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgK0AQwCCyADQYiAgIB4NgK0AQwBCyADQbQBaiAJIAgQvy8LIANBDTYC6AEgA0G/6/4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgA0GQAWogA0G0AWogA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADKQKsASEWIAMoAqQBIQsgAygCoAEhCiADKAKcASEMIAMoApgBIQkgAygClAEhBSADKAKoAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMoAoABIgUgBSgCDEEBazYCDCADQYqAgIB4NgIMCyADQSc2AsQBIANB9ez+ADYCwAEgA0GAgICAeDYCvAEgAyAHNgK4ASADQQI2ArQBIANBDGogA0G0AWoQgRQgA0HwAWokAAwBCyAEQfwBaiMAQYACayIDJAAgA0HcAWogCCAHEJMOIAMoAuABIQUCQCADKALcASIJQYqAgIB4RwRAIANBLGogA0H8AWooAgA2AgAgA0EkaiADQfQBaikCADcCACADQRxqIANB7AFqKQIANwIAIAMgAykC5AE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQdwBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQegBaikCADcDACADIAMpAuABNwMwIAMoAtwBIghBioCAgHhHBEAgA0EoaiADQfgBaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLwATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANB3AFqIANBQGtBBBDdECADKALkASEJIAMoAuABIQUCQAJ/IAMoAtwBIghBioCAgHhHBEAgAykC+AEhFiADKALwASELIAMoAuwBIQogAygC6AEhDCADKAL0AQwBCyAFQQFxRQRAQYCAgIB4IQpB5ev+ACELQQQhCUEAIQVBgICAgHghCEEKDAELIANB3AFqIgUgAygCQCAJEPgGIANBCjYCpAEgA0Hl6/4ANgKgASADQYCAgIB4NgKcASADIAk2ApgBIANBATYClAEgA0G4AWogBSADQZQBahCBFCADKAK4ASIIQYqAgIB4Rg0BIAMpAtQBIRYgAygCzAEhCyADKALIASEKIAMoAsQBIQwgAygCwAEhCSADKAK8ASEFIAMoAtABCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQNINwJcIAMgAykDQDcCVCADQdwBaiADQdQAakEGEN0QIAMoAuQBIQkgAygC4AEhBQJAAn8gAygC3AEiCEGKgICAeEcEQCADKQL4ASEWIAMoAvABIQsgAygC7AEhCiADKALoASEMIAMoAvQBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpB++v+ACELQQAhBUGAgICAeCEIQQ0MAQsgA0HcAWogAygCVCIIIAkQkw4gAygC4AEhBQJAIAMoAtwBIgtBioCAgHhHBEAgA0HYAWogA0H8AWooAgA2AgAgA0HQAWogA0H0AWopAgA3AgAgA0HIAWogA0HsAWopAgA3AgAgAyADKQLkATcCwAEgAyAFNgK8ASADIAs2ArgBDAELIANB3AFqIAhBfyAFIAlqIgggBSAISxsQyw8gAygC3AEiBUGKgICAeEcEQCADQcwBaiADQfABaikCADcCACADQdQBaiADQfgBaikCADcCACADIAMpAugBNwLEASADIAMpAuABNwK8AQsgAyAFNgK4AQsgA0ENNgLsASADQfvr/gA2AugBIANBgICAgHg2AuQBIAMgCTYC4AEgA0EBNgLcASADQZQBaiADQbgBaiADQdwBahCBFCADKAKUASIIQYqAgIB4Rg0BIAMpArABIRYgAygCqAEhCyADKAKkASEKIAMoAqABIQwgAygCnAEhCSADKAKYASEFIAMoAqwBCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQJcNwJsIAMgAykCVDcCZCADQdwBaiADQeQAakEIEN0QIAMoAuQBIQkgAygC4AEhBQJAAn8gAygC3AEiCEGKgICAeEcEQCADKQL4ASEWIAMoAvABIQsgAygC7AEhCiADKALoASEMIAMoAvQBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpBpuv+ACELQQAhBUGAgICAeCEIQQsMAQsgA0HcAWoiBSADKAJkIAkQ+AYgA0ELNgKkASADQabr/gA2AqABIANBgICAgHg2ApwBIAMgCTYCmAEgA0EBNgKUASADQbgBaiAFIANBlAFqEIEUIAMoArgBIghBioCAgHhGDQEgAykC1AEhFiADKALMASELIAMoAsgBIQogAygCxAEhDCADKALAASEJIAMoArwBIQUgAygC0AELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAmw3AnwgAyADKQJkNwJ0IANB3AFqIANB9ABqQQoQ3RAgAygC5AEhCSADKALgASEFAkACfyADKALcASIIQYqAgIB4RwRAIAMpAvgBIRYgAygC8AEhCyADKALsASEKIAMoAugBIQwgAygC9AEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkGI7P4AIQtBACEFQYCAgIB4IQhBDgwBCyADQdwBaiADKAJ0IgggCRCTDiADKALgASEFAkAgAygC3AEiC0GKgICAeEcEQCADQdgBaiADQfwBaigCADYCACADQdABaiADQfQBaikCADcCACADQcgBaiADQewBaikCADcCACADIAMpAuQBNwLAASADIAU2ArwBIAMgCzYCuAEMAQsgA0HcAWogCEF/IAUgCWoiCCAFIAhLGxDLDyADKALcASIFQYqAgIB4RwRAIANBzAFqIANB8AFqKQIANwIAIANB1AFqIANB+AFqKQIANwIAIAMgAykC6AE3AsQBIAMgAykC4AE3ArwBCyADIAU2ArgBCyADQQ42AuwBIANBiOz+ADYC6AEgA0GAgICAeDYC5AEgAyAJNgLgASADQQE2AtwBIANBlAFqIANBuAFqIANB3AFqEIEUIAMoApQBIghBioCAgHhGDQEgAykCsAEhFiADKAKoASELIAMoAqQBIQogAygCoAEhDCADKAKcASEJIAMoApgBIQUgAygCrAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAnw3AowBIAMgAykCdDcChAEgA0HcAWogA0GEAWpBDBDdECADKALkASEJIAMoAuABIQUCQAJ/IAMoAtwBIghBioCAgHhHBEAgAykC+AEhFiADKALwASELIAMoAuwBIQogAygC6AEhDCADKAL0AQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQZbs/gAhC0EAIQVBgICAgHghCEEJDAELIANB3AFqIAMoAoQBIgggCRCTDiADKALgASEFAkAgAygC3AEiC0GKgICAeEcEQCADQdgBaiADQfwBaigCADYCACADQdABaiADQfQBaikCADcCACADQcgBaiADQewBaikCADcCACADIAMpAuQBNwLAASADIAU2ArwBIAMgCzYCuAEMAQsgA0HcAWogCEF/IAUgCWoiCCAFIAhLGxCIDiADKALcASIFQYqAgIB4RwRAIANBzAFqIANB8AFqKQIANwIAIANB1AFqIANB+AFqKQIANwIAIAMgAykC6AE3AsQBIAMgAykC4AE3ArwBCyADIAU2ArgBCyADQQk2AuwBIANBluz+ADYC6AEgA0GAgICAeDYC5AEgAyAJNgLgASADQQE2AtwBIANBlAFqIANBuAFqIANB3AFqEIEUIAMoApQBIghBioCAgHhGDQEgAykCsAEhFiADKAKoASELIAMoAqQBIQogAygCoAEhDCADKAKcASEJIAMoApgBIQUgAygCrAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADKAKEASIFIAUoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0EnNgLsASADQZzt/gA2AugBIANBgICAgHg2AuQBIAMgBzYC4AEgA0ECNgLcASADQQxqIANB3AFqEIEUIANBgAJqJAALIARBCzYCsAEgBEHD7P4ANgKsASAEQYCAgIB4NgKoASAEIAc2AqQBIARBATYCoAEgBEHYAWogBEH8AWogBEGgAWoQgRQgBCgC2AEiCUGKgICAeEYNAQsgBCgC+AEhCyAEKAL0ASEKIAQoAuwBIQ4gBCgC6AEhDCAEKALkASEPIAQoAuABIQcgBCgC3AEhAyAEKALwAQwHCyAEIAQpAswBNwJEIAQgBCkCxAE3AjwgBEH8AWogBEE8akEQEN0QIAQoAoQCIQkgBCgCgAIhAyAEKAL8ASIHQYqAgIB4RwRAIAQpApgCIRcgBCgClAIhCyAEKAKQAiEKIAQoAogCIQ4gBCgCjAIMBAsgA0EBcUUEQEHp5v4AIQpBBCELQQQhCUEAIQNBgICAgHghB0GAgICAeAwEC0F/IAlBEGoiByAHIAlJGyIDIAQoAjwiBygCBEsNASAHIAcoAhRBEGoiAzYCFCAHKAIIKAIIIANPBEAgBEGKgICAeDYC/AEMAwsgBEGIgICAeDYC/AEMAgsgBSADQdDh/gAQrzsACyAEQfwBaiAJIAMQvy8LIARBBDYCsAEgBEHp5v4ANgKsASAEQYCAgIB4NgKoASAEIAk2AqQBIARBATYCoAEgBEHYAWogBEH8AWogBEGgAWoQgRQgBCgC2AEiB0GKgICAeEYNASAEKQL0ASEXIAQoAvABIQsgBCgC7AEhCiAEKALkASEOIAQoAuABIQkgBCgC3AEhAyAEKALoAQshBSAEIBc3AiAgBCALNgIcIAQgCjYCGCAEIAU2AhQgBCAONgIQIAQgCTYCDCAEIAM2AgggBCAHNgIEDAULIAQoAjwiByAHKAIMQQFrNgIMIARBioCAgHg2AgQMBAtBBCEDQQAhB0Gz7P4AIQxBECEOQcPs/gAhCkELIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAONgIYIAQgDDYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQMAgtBBCEDQQAhB0H55/4AIQxBCSEOQYLo/gAhCkEFIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAONgIYIAQgDDYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQLIARBGzYCjAIgBEHD+P4ANgKIAiAEQYCAgIB4NgKEAiAEIA02AoACIARBAjYC/AEgBEEEaiAEQfwBahCBFCAEQaACaiQACyAGQQY2AsgBIAZBwvf+ADYCxAEgBkGAgICAeDYCwAEgBiANNgK8ASAGQQE2ArgBIAZBlAJqIAZByAJqIAZBuAFqEIEUIAZB4AFqIQ0gBigClAIiA0GKgICAeEYNASANIAYpApgCNwIAIA1BGGogBkGwAmopAgA3AgAgDUEQaiAGQagCaikCADcCACANQQhqIAZBoAJqKQIANwIADAMLIAUgA0H09P4AEK87AAsgDUEIaiAGQcgAaikCADcCACANIAYpAkA3AgAgBiAGKQLoATcCWCAGIAYpAuABNwJQIAZByAJqIAZB0ABqQQoQ3RAgBigC0AIhByAGKALMAiENIAYoAsgCIgNBioCAgHhHBEAgBkHAAWogBkHkAmopAgA3AwAgBiAGKQLcAjcDuAEgBikC1AIhFgwECwJAIA1BAXFFDQACQCAHQQdxBEAgBiAHNgLkAiAGQQM2AuACIAZBwPb+ADYC3AIgBkGAgICAeDYC2AIgBkIENwLQAiAGQoSAgIAINwLIAgwBC0F/IAdBCGoiAyADIAdJGyINIAYoAlAiAygCBE0EQCADIAMoAhRBCGoiDTYCFCADKAIIKAIIIA1PBEAgBkGKgICAeDYCyAIMAgsgBkGIgICAeDYCyAIMAQsgBkHIAmogByANEL8vCyAGQQo2AuwBIAZByPf+ADYC6AEgBkGAgICAeDYC5AEgBiAHNgLgASAGQQE2AtwBIAZBlAJqIAZByAJqIAZB3AFqEIEUIAYoApQCIgNBioCAgHhGDQAMAwsgBiAGKQJYNwJoIAYgBikCUDcCYCAGQcgCaiAGQeAAakEMEN0QIAYoAtACIQcgBigCzAIhDSAGKALIAiIDQYqAgIB4RwRAIAZBwAFqIAZB5AJqKQIANwMAIAYgBikC3AI3A7gBIAYpAtQCIRYMBAsCQCANQQFxRQ0AIAZByAJqIAYoAmAiCyAHEJQOIAYoAswCIQMCQCAGKALIAiINQYqAgIB4RwRAIAZBtAJqIAZB6AJqKAIANgIAIAZBrAJqIAZB4AJqKQIANwIAIAZBpAJqIAZB2AJqKQIANwIAIAYgBikC0AI3ApwCIAYgAzYCmAIgBiANNgKUAgwBCyAGQcgCaiALQX8gAyAHaiINIAMgDUsbEIcOIAYoAtACIQMgBigCzAIhDSAGKALIAiIFQYqAgIB4RwRAIAZBsAJqIAZB5AJqKQIANwIAIAZBqAJqIAZB3AJqKQIANwIAIAYgBikC1AI3AqACIAYgAzYCnAIgBiANNgKYAiAGIAU2ApQCDAELIAMgDWsiBUEAIAMgBU8bIgNBAnYgA0EDcUEAR2oiBQRAIA1Bf3MhA0EAIAVrIRUgBkHwAWohDCAGQeQBaiEOIAZBqAJqIQ8gBkGYAmohEiAGQcwBaiEFIAZB3AJqIRAgBkHMAmohEyAGQbwBaiEJIAZBwAFqIQggBkHQAmohBANAIAZByAJqIAsgDRCUDiAGKALMAiEKAkAgBigCyAIiEUGKgICAeEcEQCAIIAQpAgA3AgAgCEEYaiAEQRhqKAIANgIAIAhBEGogBEEQaikCADcCACAIQQhqIARBCGopAgA3AgAgBiAKNgK8ASAGIBE2ArgBDAELIAZByAJqIAsgCiADIAMgCksbIA1qELUGIAZBwAJqIgogE0EIaikCADcDACAGIBMpAgA3A7gCIAYoAsgCIhFBioCAgHhHBEAgBSAQKQIANwIAIAVBCGogEEEIaikCADcCACAJQQhqIAopAwA3AgAgCSAGKQO4AjcCACAGIBE2ArgBDAELIAZB+AJqIAopAwA3AwAgBiAGKQO4AjcD8AIgBkGUAmogBkHwAmpB3vj+AEEDQQQQrgggBkGIAmoiCiASQQhqKQIANwMAIAYgEikCADcDgAIgBigClAIiEUGKgICAeEcEQCAFIA8pAgA3AgAgBUEIaiAPQQhqKQIANwIAIAlBCGogCikDADcCACAJIAYpA4ACNwIAIAYgETYCuAEMAQsgBCAKKQMANwMAIAYgBikDgAI3A8gCIAZB3AFqIAZByAJqQeH4/gBBBUEGEK4IIAYoAuABIQogBigC3AEiEUGKgICAeEcEQCAIIA4pAgA3AgAgBSAMKQIANwIAIAhBCGogDkEIaigCADYCACAFQQhqIAxBCGopAgA3AgAgBiAKNgK8ASAGIBE2ArgBDAELIAogCigCDEEBazYCDCAGQYqAgIB4NgK4AQsgBiANNgLQAiAGIBQ2AswCIAZBADYCyAIgBkGUAWogBkG4AWogBkHIAmoQgRQgBigClAEiCkGKgICAeEcEQCAGQbACaiAGQbABaikCADcCACAGQagCaiAGQagBaikCADcCACAGQaACaiAGQaABaikCADcCACAGIAYpApgBNwKYAiAGIAo2ApQCDAMLIA1BBGohDSADQQRrIQMgFSAUQQFqIhRqDQALCyAGQYqAgIB4NgKUAgsgBkEPNgLYAiAGQdL3/gA2AtQCIAZBgICAgHg2AtACIAYgBzYCzAIgBkEBNgLIAiAGQfAAaiAGQZQCaiAGQcgCahCBFCAGKAJwIgNBioCAgHhGDQAgBkHAAWogBkGMAWopAgA3AwAgBiAGKQKEATcDuAEgBikCfCEWIAYoAnghByAGKAJ0IQ0MBAsgBigCYCIHIAcoAgxBAWs2AgwgAkEDSwRAIAAgAjYCCCAAIAE2AgQgAEGKgICAeDYCACAAIAEoAAA2AgwMBQtBBCACQfD2/gAQsDsACyAGQQY2AvwBIAZBwvf+ADYC+AEgBkKLgICAgICAgIB/NwLwASAGQbf3/gA2AuwBIAZBgICAgHg2AugBIAZCBDcC4AFBACEDCyAGQcABaiAGQfgBaikCADcDACAGIAYpAvABNwO4ASAGKQLoASEWIAYoAuQBIQcgBigC4AEhDQwBCyAGQcABaiAGQbACaikCADcDACAGIAYpAqgCNwO4ASAGKQKgAiEWIAYoApwCIQcgBigCmAIhDQsgACAWNwIMIAAgBzYCCCAAIA02AgQgACADNgIAIAAgBikDuAE3AhQgAEEcaiAGQcABaikDADcCAAsgBkGAA2okAAv4GgIDfwN+IwBBoARrIgUkACAFIAI2AhAgBSABNgIMIAUgAzYCFAJAAkACQCAELQAAQSlHBEAgBUEgaiAEQQhqKAIANgIAIAUgBCkCADcDGAwBCyAFQagBaiADQQhqEIsFIAUoAtwBIgNBgICAgHhGBEAgBUGAAWogBUG4AWopAwAiCDcDACAFQfgAaiAFQbABaikDACIJNwMAIAUgBSkDqAEiCjcDcCAAQRBqIAg3AwAgAEEIaiAJNwMAIAAgCjcDACAFKAIUIgAgACgCACIAQQFrNgIAIABBAUYEQCAFQRRqENkhCyAFQQxqELwqDAILIAVB8ABqIAVBqAFqQTT8CgAAIAVB6ABqIAVB6AFqKQMANwMAIAUgBSkD4AE3A2AgBUEoaiIEIAVB8ABqQTT8CgAAIAUgAzYCXCAFQRhqIAVB0ABqEMIGIAQQgC8LAkACQCAFLQAYQSJGBEAgBSgCICEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUoAhwtAABBAmsOCAABAgMEBQYHCAsgAy0AACIDQRlLDQdBASADdCIDQYCAwAlxDQggA0GAgIAScUUNByAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEH8y80AIQMMEwsgAy0AACIDQRlLDQZBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBiAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHMzM0AIQMMEgsgAy0AACIDQRlLDQVBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBSAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGczc0AIQMMEQsgAy0AACIDQRlLDQRBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBCAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHszc0AIQMMEAsgAy0AACIDQRlLDQNBASADdCIDQYCAwAlxDQggA0GAgIAScUUNAyAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEG8zs0AIQMMDwsgAy0AACIDQRlLDQJBASADdCIDQYCAwAlxDQggA0GAgIAScUUNAiAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGMz80AIQMMDgsgAy0AACIDQRlLDQFBASADdCIDQYCAwAlxDQggA0GAgIAScUUNASAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHcz80AIQMMDQsgAy0AACIDQRlLDQBBASADdCIDQYCAwAlxDQggA0GAgIAScQ0JCyAFQQE2AqwBIAVBkNHNADYCqAEMCgsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQwgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBB1MvNACEDDAoLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0LIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQaTMzQAhAwwJCyAFQagBaiIDIAUoAhQQhxMgBUE4aiIGIAVBIGooAgA2AgAgBSAFKQMYNwMwQagDQQgQrTYiBEUNCiAEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAVBMGopAwA3AwAgBEGgA2ogBigCADYCAEH0zM0AIQMMCAsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQkgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBBxM3NACEDDAcLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0IIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQZTOzQAhAwwGCyAFQagBaiIDIAUoAhQQhxMgBUE4aiIGIAVBIGooAgA2AgAgBSAFKQMYNwMwQagDQQgQrTYiBEUNByAEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAVBMGopAwA3AwAgBEGgA2ogBigCADYCAEHkzs0AIQMMBQsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQYgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBBtM/NACEDDAQLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0FIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQYTQzQAhAwwDCyAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGs0M0AIQMMAgsgBUEBNgKsASAFQdzRzQA2AqgBCyAFQgE3ArQBIAVBrQM2AiwgBSAFQShqNgKwASAFIAVBGGoiATYCKCAAQQRqIAVBqAFqEJkOIABBADYCACABEJUMIAUoAhQiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBFGoQ2SELIAVBDGoQvCoMAQsgACADNgIIIAAgBDYCBCAAQQg2AgALIAVBoARqJAAPC0EIQagDEKM9AAu5KgIOfwJ+IwBBoAFrIgIkACABKAIoIQUgASgCJCELIAJBIGogAUEYaiIKEOYLAkACQCACLQAsQQEgASgCLCIOGwRAAkAgASgCCCIJIAIoAigiA0kNACADIAlHBEAgAi0ALUEBcUUNAQsgBSALaiEEIAEoAgQhDSADRQ0CIARBA3YgBEEHcUEAR2ohDCANQQRqIQUgAigCJEEIaiEGIAStIRADQCACIAc2ApwBAkACQAJAAkACQAJAAkAgBkEIaygCAEEBaw4DBgAGAQsgAiAMNgI4IAVBBGooAgAiCCAMSQ0BDAULIAIgBjYCMCACQX8gECAGQQRrNQIAfiIRpyARQiCIpxsiCDYCNCAIIAVBBGooAgAiD0sNAiAGKAIAIghpQQFHDQEgBSgCACAIEPgvIghFDQQgAiAGKAIAIAhrIgEgCCABIAhJGzYCkAEgAkHQ6oYBNgJ4IAJCBDcChAEgAkE7NgJoIAJB3AE2AmAgAkHzGzYCWCACIAo2AlQgAkE7NgJQIAJBBDYCfCACIAJBzABqNgKAASACIAJBkAFqNgJkIAIgAkEwajYCXCACIAJBnAFqNgJMDAMLIAIgCDYCkAEgAkHc64YBNgJ4IAJCBDcChAEgAkE7NgJoIAJB8xs2AmAgAiAKNgJcIAJBOzYCWCACQTs2AlAgAkEENgJ8IAIgAkHMAGo2AoABIAIgAkGQAWo2AmQgAiACQZwBajYCVCACIAJBOGo2AkwMAgsgAkEANgJcIAJBATYCUCACQbDahgE2AkwgAkIENwJUIAJBzABqQbjahgEQ7ywACyACIA82ApABIAJBnOuGATYCeCACQgQ3AoQBIAJBOzYCaCACQfMbNgJgIAIgCjYCXCACQTs2AlggAkE7NgJQIAJBBDYCfCACIAJBzABqNgKAASACIAJBkAFqNgJkIAIgAkGcAWo2AlQgAiACQTRqNgJMCyAAQQRqIAJB+ABqEJkOIABBjYCAgHg2AgAMBQsgBUEMaiEFIAZBDGohBiADIAdBAWoiB0cNAAsMAgsgAiADNgKcASACIAk2ApABIAJBAzYCfCACQajshgE2AnggAkIDNwKEASACQTs2AmAgAkHzGzYCWCACIAo2AlQgAkE7NgJQIAIgAkHMAGo2AoABIAIgAkGQAWo2AlwgAiACQZwBajYCTCAAQQRqIAJB+ABqEJkOIABBjYCAgHg2AgAMAgsgAkECNgJQIAJBgOeGATYCTCACQgE3AlggAkHzGzYCfCACIAo2AnggAiACQfgAajYCVCAAQQRqIAJBzABqEJkOIABBjYCAgHg2AgAMAQsgAUEkaiEIAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA4EQCABKAJAIgUgC0sNASACQRhqIAFBLGoQ3DsgAiACKAIcIgU2AjwgAiAEQQN2IARBB3FBAEdqIgc2AkAgBSAHSQ0CIAEoAjwiBSALRw0DCwJAAkACQAJAAkACQAJAAkACQCAKLQAAIgxBG2sODgcAAQIDBAUGDAwMDAcIDAsgAkHMAGoiBCABIAEoAhxBMGoQvSMgAigCUCEFIAIoAkwiB0GTgICAeEcNGyAFKAIkIQ1BACEJIwBB0ABrIgMkACADQThqIAEiB0EAIAEoAiQiBRCfESADKAJAIQsgAygCPCEBAkAgAygCOCIGQZOAgIB4RwRAIAQgAykCRDcCDCAEIAs2AgggBCABNgIEIAQgBjYCAAwBCyADQThqIAdBASAFEJ8RIAMoAkAhCCADKAI8IQUgAygCOCIGQZOAgIB4RwRAIAQgAykCRDcCDCAEIAg2AgggBCAFNgIEIAQgBjYCAAwBCwJAIA1FDQAgBSEGIAEhCgJAA0AgAyAJNgIEAkAgCCAJRwRAIAUoAgAiDEEATg0BIANBAzYCJCADQbDxhgE2AiAgA0IDNwIsIANBrQM2AkwgAyAHQRhqNgJIIANBnAM2AkQgAyAGNgJAIANBOzYCPCADIANBOGo2AiggAyADQQRqNgI4IANBEGogA0EgahCZDiAEIAMpAhQ3AgggBEEQaiADQRxqKAIANgIAIAQgAygCEDYCBCAEQY2AgIB4NgIADAULIAggCEHo74YBEMMhAAsgAyAMNgIIIAkgC0YNASABKAIAIg5BAEgEQCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQZwDNgJEIAMgCjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwECyANIAwgDmpPBEAgBUEEaiEFIAZBBGohBiABQQRqIQEgCkEEaiEKIA0gCUEBaiIJRw0BDAMLCyADQQM2AiQgA0GA8YYBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQTs2AkQgA0E7NgI8IAMgA0E4ajYCKCADIANBBGo2AkAgAyADQQhqNgI4IARBBGogA0EgahCZDiAEQY2AgIB4NgIADAILIAsgC0H474YBEMMhAAsgBEGTgICAeDYCAAsgA0HQAGokACACKAJMIgdBk4CAgHhGDRkMGgsgAiABQRxqNgJEIAJBzABqIgQgASABKAIgQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRogASgCHCIHQR92IQMgAkHEAGohCSMAQUBqIgYkAAJAIAMEQCAGQQI2AhwgBkHA94YBNgIYIAZCAjcCJCAGQakINgI8IAYgCTYCOCAGQa0DNgI0IAYgAUEYajYCMCAGIAZBMGo2AiAgBkEIaiAGQRhqEJkOIAZBjYCAgHg2AgQgBCAGKQIENwIAIARBCGogBkEMaikCADcCACAEQRBqIAZBFGooAgA2AgAMAQsgBEGTgICAeDYCACAEIAc2AgQLIAZBQGskACACKAJQIQQgAigCTCIHQZOAgIB4RwRAIAIoAlwhASACKQJUIRAgBCEFDBwLIAIgBDYCnAEgC60gBK1+IhBCIIinDREgBSgCJCAQp08NGCACQQQ2AnwgAkH48oYBNgJ4IAJCBDcChAEgAkGtAzYCaCACIAo2AmQgAkE7NgJgIAJBOzYCWCACIAg2AlQgAkE7NgJQIAIgBUEkajYCTCACIAJBzABqNgKAASACIAJBnAFqNgJcIAJBkAFqIAJB+ABqELsYDBULIAJBzABqIgQgASABKAIcQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRkgBCABIAUoAiQQ5wggAigCTCIHQZOAgIB4Rw0YDBcLIAJBzABqIgQgASABKAIcQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRggBSgCJCENQQAhCSMAQdAAayIDJAAgA0E4aiABIgdBACABKAIkIgUQnhEgAygCQCELIAMoAjwhAQJAIAMoAjgiBkGTgICAeEcEQCAEIAMpAkQ3AgwgBCALNgIIIAQgATYCBCAEIAY2AgAMAQsgA0E4aiAHQQEgBRCeESADKAJAIQggAygCPCEFIAMoAjgiBkGTgICAeEcEQCAEIAMpAkQ3AgwgBCAINgIIIAQgBTYCBCAEIAY2AgAMAQsCQCANRQ0AIAUhBiABIQoCQAJAA0ACQCAIIAlHBEAgBSkDACIQQoCAgIAQVA0BIAMgCTYCBCADQQM2AiQgA0Gw8YYBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQe4GNgJEIAMgBjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwGCyAIIAhB6O+GARDDIQALIAMgEKciDDYCCCAJIAtGDQEgASkDACIQQoCAgIAQWgRAIAMgCTYCBCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQe4GNgJEIAMgCjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwFCyAMIAwgEKdqIg5LDQIgDSAOTwRAIAVBCGohBSAGQQhqIQYgAUEIaiEBIApBCGohCiANIAlBAWoiCUcNAQwECwsgAyAJNgIEIANBAzYCJCADQYDxhgE2AiAgA0IDNwIsIANBrQM2AkwgAyAHQRhqNgJIIANBOzYCRCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCQCADIANBCGo2AjggBEEEaiADQSBqEJkOIARBjYCAgHg2AgAMAwsgCyALQfjvhgEQwyEAC0GI8IYBQTBBuPCGARDLJAALIARBk4CAgHg2AgALIANB0ABqJAAgAigCTCIHQZOAgIB4Rw0XDBYLIAJBCGogAUEcaiIFEMM0IAJBzABqIAEgAigCDBCRGiACKAJMIgdBk4CAgHhHDRYgAiAFEMM0IAIoAgRBAnQhAyACKAIAQQRrIQRBACEFA0AgA0UNCSACIAU2AkggAkHMAGoiBiABIAUgBEEEaiIEKAIAQTBqEMUOIAIoAkwiB0GTgICAeEcNFyADQQRrIQMgBUEBaiEFIAIoAlAiBygCJCALTw0ACyACIAQoAgBBPGo2ApwBIAJBBjYCfCACQezzhgE2AnggAkIFNwKEASACQTs2AnAgAiAINgJsIAJBOzYCaCACIAdBJGo2AmQgAkH0GzYCYCACQTs2AlggAkGtAzYCUCACIAo2AkwgAiAGNgKAASACIAJBnAFqNgJcIAIgAkHIAGo2AlQgAkGQAWogAkH4AGoQuxgMEgsgAkHMAGogASABQRxqIgUoAgQQkRogAigCTCIHQZOAgIB4Rw0VIAJBEGogBRCwLiACKAIQIgMgAigCFCIKRg0UQQAhBiABLQAZIQsDQCACIAY2AnQgAkHMAGogASAGIANBBGooAgBBMGoQxQ4gAigCUCEFIAIoAkwiB0GTgICAeEcNFwJAIAtFBEAgBSgCJCAESQ0BCyAGQQFqIQYgA0EIaiIDIApHDQEMCQsLIAIgBDYCnAEgAkEENgJ8IAJB7PSGATYCeCACQgM3AoQBIAJBOzYCYCACQTs2AlggAiAFQSRqNgJUIAJBOzYCUCACIAJBzABqNgKAASACIAJBnAFqNgJcIAIgAkH0AGo2AkwgAkGQAWogAkH4AGoQuxgMEQsgAkHMAGogASABKAIgEL0jIAIoAkwiB0GTgICAeEcNFAwSCyACQcwAaiIEIAEgASgCHEEwahC9IyACKAJQIQUgAigCTCIHQZOAgIB4Rw0UIAQgASAFKAIkEOwIIAIoAkwiB0GTgICAeEcNEwwFCyACQcwAaiIEIAFBAhCRGiACKAJMIgdBk4CAgHhHDRIgBCABQQAgASgCHCIGQTBqEMUOIAIoAlAhBSACKAJMIgdBk4CAgHhHDRMgBCABQQEgASgCIEEwahDFDiACKAJQIQQgAigCTCIHQZOAgIB4RwRAIAIoAlwhASACKQJUIRAgBCEFDBULIAUoAiQgBCgCJEYEQCAFKAIsRQ0GIAJBzABqQYz1hgFB1AAQjSAgAikCUCEQIAIoAkwMEAsgAkECNgJQIAJB2PaGATYCTCACQgI3AlggAkE7NgKEASACIARBJGo2AoABIAJBOzYCfCACIAVBJGo2AnggAiACQfgAajYCVCACQZABaiACQcwAahC7GAwOCyACIAU2ApABIAJBAzYCUCACQYDohgE2AkwgAkICNwJYIAJBOzYChAEgAiAINgKAASACQTs2AnwgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQmQ4gAEGNgICAeDYCAAwUCyACQQI2AlAgAkHM44YBNgJMIAJCAjcCWCACQTs2AoQBIAJBOzYCfCACIAJB+ABqNgJUIAIgAkFAazYCgAEgAiACQTxqNgJ4IABBBGogAkHMAGoQmQ4gAEGNgICAeDYCAAwTCyACIAU2ApABIAJBAjYCUCACQbznhgE2AkwgAkICNwJYIAJBOzYChAEgAiAINgKAASACQTs2AnwgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQuxggAEGNgICAeDYCAAwSCyABKAIUIgUNCQsCQCAMQRRrDgYCDQMNAgMACyAMQSJGDQsgDEEoRw0MIAEoAhwhBgsgBi0ASA0CIAYtADBBA2tB/wFxQQNPDQMMCwsgCUEBTQ0EIAJBzABqIAEgDSgCFBDsCCACKAJMIgFBk4CAgHhGDQogACACKQJQNwIEIABBDGogAkHYAGopAgA3AgAgACABNgIADA4LIAlBAU0NBCACQcwAaiABIA0oAhQQ5wggAigCTCIBQZOAgIB4Rg0JIAAgAikCUDcCBCAAQQxqIAJB2ABqKQIANwIAIAAgATYCAAwNCyAAQQRqQbjphgFBygAQjSAgAEGNgICAeDYCAAwMCyACQQE2AlAgAkGw6YYBNgJMIAJCATcCWCACQacENgJ8IAIgBkEwajYCkAEgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQuxggAEGNgICAeDYCAAwLC0HI8YYBQc4AQZjyhgEQyyQAC0EBIAlBmOiGARDDIQALQQEgCUGo6IYBEMMhAAsgAiAFNgKcASACQQI2AlAgAkGU94YBNgJMIAJCAjcCWCACQTs2AoQBIAJBrQM2AnwgAiAKNgJ4IAIgAkH4AGo2AlQgAiACQZwBajYCgAEgAkGQAWogAkHMAGoQuxgLIAIpApQBIRAgAigCkAELIQVBjYCAgHghBwwECyACIAFBHGo2ApABIAEoAhwtAABBAmtB/wFxQQhJDQAgAkEBNgJQIAJB6OiGATYCTCACQgE3AlggAkHFEzYCfCACIAJB+ABqNgJUIAIgAkGQAWo2AnggAEEEaiACQcwAahC7GCAAQY2AgIB4NgIADAQLIABBk4CAgHg2AgAMAwsgAigCXCEBIAIpAlQhECACKAJQIQUMAQsgAigCXCEBIAIpAlQhEAsgACABNgIQIAAgEDcCCCAAIAU2AgQgACAHNgIACyACQSBqQQRBDBDgHiACQaABaiQAC9EYAgd+CH8jAEHQAWsiCiQAAkACQAJAAkAgAQRAIAogATYCCCAKIAI2AgwCQCACQQ1PBEAgACgCCCELIABBADYCCCALDQEMBQsgCkEANgIYIApCADcDECACBEAgCkEQaiABIAL8CgAACyAKNQIYIQMgCikDECEFIAAoAkAiASAAKAI4RgRAIABBOGpBoOuAARCxKAsgACgCPCABQQR0aiILIAM+AgwgCyAFNwIEIAsgAjYCACAAIAFBAWo2AkAgACgCXARAIAAoAmwiC0EBaiIMQQN2IAxBB3FBAEdqIgIgACgCaCIBSwRAIAIgAWshDSAAKAJgIg4gAkkEQCAAQdwAaiAOQQF0IgEgAhDQKiIOIAEgDksbEOgZIAAoAmghAQsgDQRAIAAoAmQgAWpBACAN/AsACyAAIAI2AmgLIAAgDDYCbCAAKAJkIAtBA3ZqIgAgAC0AAEEBIAtBB3F0cjoAAAwGCyAAIAAoAnBBAWo2AnAMBQsgCkE0aiAAQRRqKAIANgIAIApBQGsgAEEgaikDACIDNwMAIApByABqIABBKGopAwAiCDcDACAKQdAAaiAAQTBqKQMAIgc3AwAgCiALNgIoIAogACkCDDcCLCAKIAApAxgiBTcDOCADIAKtIgaFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIAZ8Qq3+1eTUhf2o2AB+IQMCQCACQRBNBEAgAyAFfCABKQAAIAiFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASACakEIaykAACAHhSIEQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAN+hUIXiSEDDAELIAMgBXwgCCABIAJqQRBrIgspAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgByALKQAIhSIEQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAN+hUIXiSEDIAdCf4UhBiABIQwgAiELA0AgAyAFfCAIIAwpAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgDCkACCIJIAaFfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhSADIAcgCYUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhH6FQheJIQMgDEEQaiEMIAtBEGsiC0EQSw0ACwsgAEEIaiELIApB2ABqIApBKGogAyAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEfiADQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAVCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhISFIAOJIAAgCkEIaiAKQThqEPoNIAooAlhBAUYEQCAKKAJsIgwoAgAiDSAKKAJoIg5qIg8tAAAhECAAKAJAIREgDyAKKAJgQRl2Ig86AAAgDSAMKAIEIA5BCGtxakEIaiAPOgAAIAwgDCgCDEEBajYCDCAMIAwoAgggEEEBcWs2AgggDSAOQQJ0a0EEayARNgIAIApBqAFqIApBMGopAgA3AwAgCiAKKQIoNwOgASAKQcgBaiAKQdAAaikDADcDACAKQcABaiAKQcgAaikDADcDACAKQbgBaiAKQUBrKQMANwMAIAogCikDODcDsAEgACgCCARAIAsQjjsLIAsgCkGgAWpBMPwKAAAMBAsgCigCaEEEaygCACIMIAAoAkAiAU8NASAAKAI8IgIgDEEEdGoiDCkDCCEDIAwpAwAhBSAAKAI4IAFGBH8gAEE4akHg6oABELEoIAAoAjwFIAILIAFBBHRqIgIgAzcDCCACIAU3AwAgACABQQFqNgJAAkAgACgCXARAIAAoAmwiDEEBaiINQQN2IA1BB3FBAEdqIgEgACgCaCICSwRAIAEgAmshDiAAKAJgIg8gAUkEQCAAQdwAaiAPQQF0IgIgARDQKiIPIAIgD0sbEOgZIAAoAmghAgsgDgRAIAAoAmQgAmpBACAO/AsACyAAIAE2AmgLIAAgDTYCbCAAKAJkIAxBA3ZqIgAgAC0AAEEBIAxBB3F0cjoAAAwBCyAAIAAoAnBBAWo2AnALIApB+ABqIApBMGopAgA3AwAgCkGIAWogCkFAaykDADcDACAKQZABaiAKQcgAaikDADcDACAKQZgBaiAKQdAAaikDADcDACAKIAopAig3A3AgCiAKKQM4NwOAASALKAIABEAgCxCOOwsgCyAKQfAAakEw/AoAAAwECyAAQdwAaiINEOY6IAAoAlxFDQEgACgCbEEBaiILQQN2IAtBB3FBAEdqIgEgACgCaCICSwRAIAEgAmshDCAAKAJgIg4gAUkEQCANIA5BAXQiAiABENAqIg0gAiANSxsQ6BkgACgCaCECCyAMBEAgACgCZCACakEAIAz8CwALIAAgATYCaAsgACALNgJsIAAoAkAiASAAKAI4RgRAIABBOGpB/OmAARCxKAsgACgCPCABQQR0aiICQgA3AwggAkIANwMAIAAgAUEBajYCQAwDCyAMIAFB0OqAARDDIQALQdzsgAEQsjsACyAAQdAAaiEMIAAoAlAgACgCWCILIAJqSQRAIAAQuRAgDCAAENcqIgsgAiACIAtJGxCELiAAKAJYIQsLIAwgASACEKE2IAA1AkwgC61CIIaEIQMgAq0gATUAAEIghoQhBSAAKAJAIgEgACgCOEYEQCAAQThqQZDrgAEQsSgLIAAoAjwgAUEEdGoiAiADNwMIIAIgBTcDACAAIAFBAWo2AkAgACgCXARAIAAoAmwiC0EBaiIMQQN2IAxBB3FBAEdqIgIgACgCaCIBSwRAIAIgAWshDSAAKAJgIg4gAkkEQCAAQdwAaiAOQQF0IgEgAhDQKiIOIAEgDksbEOgZIAAoAmghAQsgDQRAIAAoAmQgAWpBACAN/AsACyAAIAI2AmgLIAAgDDYCbCAAKAJkIAtBA3ZqIgAgAC0AAEEBIAtBB3F0cjoAAAwBCyAAIAAoAnBBAWo2AnALIApB0AFqJAALjiYCB34UfyMAQdABayIMJAACQAJAAkACQCABBEAgDCABNgIIIAwgAjYCDAJAIAJBDU8EQCAAKAIIIQsgAEEANgIIIAsNAQwFCyAMQQA2AhggDEIANwMQIAIEQCAMQRBqIAEgAvwKAAALIAw1AhghAyAMKQMQIQUgACgCQCIBIAAoAjhGBEAgAEE4akGg64ABELEoCyAAKAI8IAFBBHRqIgsgAz4CDCALIAU3AgQgCyACNgIAIAAgAUEBajYCQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiAiAAKAJoIgFLBEAgAiABayEPIAAoAmAiDSACSQRAIABB3ABqIA1BAXQiASACENAqIg0gASANSxsQ6BkgACgCaCEBCyAPBEAgACgCZCABakEAIA/8CwALIAAgAjYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAYLIAAgACgCcEEBajYCcAwFCyAMQTRqIABBFGooAgA2AgAgDEFAayAAQSBqKQMAIgM3AwAgDEHIAGogAEEoaikDACIINwMAIAxB0ABqIABBMGopAwAiBzcDACAMIAs2AiggDCAAKQIMNwIsIAwgACkDGCIFNwM4IAMgAq0iBoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUgBnxCrf7V5NSF/ajYAH4hAwJAIAJBEE0EQCADIAV8IAEpAAAgCIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABIAJqQQhrKQAAIAeFIgRCf4V+IgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBkIIiEKAgID4D4MgBkIYiEKAgPwHg4QgBkIoiEKA/gODIAZCOIiEhISFIARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgA36FQheJIQMMAQsgAyAFfCAIIAEgAmpBEGsiCykAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAHIAspAAiFIgRCf4V+IgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBkIIiEKAgID4D4MgBkIYiEKAgPwHg4QgBkIoiEKA/gODIAZCOIiEhISFIARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgA36FQheJIQMgB0J/hSEGIAEhCiACIQsDQCADIAV8IAggCikAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAKKQAIIgkgBoV+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFIAMgByAJhSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoVCF4khAyAKQRBqIQogC0EQayILQRBLDQALCyADIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIR+IANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgBUJ/hX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgA4khByMAQRBrIhEkACAMQShqIgsoAghFBEAgEUEIaiEUIwBB4ABrIgokACAKIAxBOGo2AhwgCygCDCEOIAogCkEcajYCIAJAIA4gDkEBaiINTQRAAkAgCygCBCIOIA5BAWpBA3ZBB2wgDkEISRsiDkEBdiANSQRAAkACQCAOQQFqIg8gDSANIA9JGyIOQQ9PBEAgDkH/////AUsNAUF/IA5BA3RBB25BAWtndkEBaiEPDAILQQRBCEEQIA5BCEkbIA5BBEkbIQ8MAQsQ3ScgCigCFCEPIAooAhAiDUGBgICAeEcNBAsgCkHQAGogDkEEIA8Q+xQgCigCWCEPIAooAlQhDSAKKAJQIg5FDQMgCiAKKAJcNgJMIAogDzYCSCAKIA02AkQgCiAONgJAIApBCGogCkFAaxDBNCAKKAIMIg8EQCAKKAIIQf8BIA/8CwALIAooAkghDyAKKAJEIQ0gCigCQCIORQ0DIAogCigCTDYCPCAKIA82AjggCiANNgI0IAogDjYCMCAKQoSAgICAATcCKCAKIAtBEGo2AiQgCkEwaiEYIAogCygCDCIWBH8gDkEIaiEZIAsoAgAiFykDAEJ/hUKAgYKEiJCgwIB/gyEGA0AgBlAEQANAIBNBCGohEyAXQQhqIhcpAwBCgIGChIiQoMCAf4MiA0KAgYKEiJCgwIB/UQ0ACyADQoCBgoSIkKDAgH+FIQYLIA4gDSAKKAIgKAIAIhApAwgiAyALKAIAIAZ6p0EDdiATakECdCIaa0EEazUCAIUiBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAVC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAQKQMAIgVCf4V+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgAyAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEfoUgA4mnIhtxIhBqKQAAQoCBgoSIkKDAgH+DIgNQBEBBCCESA0AgECASaiEQIBJBCGohEiAOIA0gEHEiEGopAABCgIGChIiQoMCAf4MiA1ANAAsLIAZCAX0gBoMhBiAOIAN6p0EDdiAQaiANcSIQaiwAAEEATgRAIA4pAwBCgIGChIiQoMCAf4N6p0EDdiEQCyAOIBBqIBtBGXYiEjoAACAZIBBBCGsgDXFqIBI6AAAgDiAQQQJ0a0EEayALKAIAIBprQQRrKAAANgAAIBZBAWsiFg0ACyALKAIMBUEACyINNgI8IAogDyANazYCOCALIBhBBBD6KiAKQSRqEPUnDAELIAsgCkEgakHAyIUBEO4JC0GBgICAeCENDAELEN0nIAooAgQhDyAKKAIAIQ0LIBQgDzYCBCAUIA02AgAgCkHgAGokAAsgAEEIaiEPIAxB2ABqIQogCygCBCIOIAencSENIAdCGYhC/wCDQoGChIiQoMCAAX4hBCAMQQhqIhAoAgQhEyAQKAIAIRIgCygCACEQA0ACQCANIBBqKQAAIgUgBIUiA0J/hSADQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIQMCfwJAIAoCfgJAA0AgA1ANASARIAAgCygCACADeqdBA3YgDWogDnEiFEECdGtBBGsoAgAQ+BIgA0IBfSADgyEDIBIgEyARKAIAIBEoAgQQnztFDQALIAogBzcDCCAKIAsoAgBBACAUa0ECdGo2AhBCAAwBCyAFQoCBgoSIkKDAgH+DIQMgHEUEQCADUA0CIAN6p0EDdiANaiAOcSEVC0EBIAMgBUIBhoNQDQIaIAogECAVaiwAAEEATgR/IBApAwBCgIGChIiQoMCAf4N6p0EDdgUgFQs2AhAgCiAHNwMIQgELNwMAIAogCzYCFCARQRBqJAAMAgtBAAshHCANIB1BCGoiHWogDnEhDQwBCwsgDCgCWEEBRgRAIAwoAmwiCygCACIKIAwoAmgiDWoiDi0AACEQIAAoAkAhESAOIAwoAmBBGXYiDjoAACAKIAsoAgQgDUEIa3FqQQhqIA46AAAgCyALKAIMQQFqNgIMIAsgCygCCCAQQQFxazYCCCAKIA1BAnRrQQRrIBE2AgAgDEGoAWogDEEwaikCADcDACAMIAwpAig3A6ABIAxByAFqIAxB0ABqKQMANwMAIAxBwAFqIAxByABqKQMANwMAIAxBuAFqIAxBQGspAwA3AwAgDCAMKQM4NwOwASAAKAIIBEAgDxCOOwsgDyAMQaABakEw/AoAAAwECyAMKAJoQQRrKAIAIgIgACgCQCIBTw0BIAAoAjwiCyACQQR0aiICKQMIIQMgAikDACEFIAAoAjggAUYEfyAAQThqQeDqgAEQsSggACgCPAUgCwsgAUEEdGoiAiADNwMIIAIgBTcDACAAIAFBAWo2AkACQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiASAAKAJoIgJLBEAgASACayENIAAoAmAiDiABSQRAIABB3ABqIA5BAXQiAiABENAqIg4gAiAOSxsQ6BkgACgCaCECCyANBEAgACgCZCACakEAIA38CwALIAAgATYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgDEH4AGogDEEwaikCADcDACAMQYgBaiAMQUBrKQMANwMAIAxBkAFqIAxByABqKQMANwMAIAxBmAFqIAxB0ABqKQMANwMAIAwgDCkCKDcDcCAMIAwpAzg3A4ABIA8oAgAEQCAPEI47CyAPIAxB8ABqQTD8CgAADAQLIABB3ABqIg8Q5jogACgCXEUNASAAKAJsQQFqIgtBA3YgC0EHcUEAR2oiASAAKAJoIgJLBEAgASACayEKIAAoAmAiDSABSQRAIA8gDUEBdCICIAEQ0CoiDyACIA9LGxDoGSAAKAJoIQILIAoEQCAAKAJkIAJqQQAgCvwLAAsgACABNgJoCyAAIAs2AmwgACgCQCIBIAAoAjhGBEAgAEE4akH86YABELEoCyAAKAI8IAFBBHRqIgJCADcDCCACQgA3AwAgACABQQFqNgJADAMLIAIgAUHQ6oABEMMhAAtB3OyAARCyOwALIABB0ABqIQogACgCUCAAKAJYIgsgAmpJBEAgABC5ECAKIAAQ1yoiCyACIAIgC0kbEIQuIAAoAlghCwsgCiABIAIQoTYgADUCTCALrUIghoQhAyACrSABNQAAQiCGhCEFIAAoAkAiASAAKAI4RgRAIABBOGpBkOuAARCxKAsgACgCPCABQQR0aiICIAM3AwggAiAFNwMAIAAgAUEBajYCQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiAiAAKAJoIgFLBEAgAiABayEPIAAoAmAiDSACSQRAIABB3ABqIA1BAXQiASACENAqIg0gASANSxsQ6BkgACgCaCEBCyAPBEAgACgCZCABakEAIA/8CwALIAAgAjYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgDEHQAWokAAupGgIDfwF+IwBB0CtrIgYkACAGIAI2AiQgBiADNgIwIAYgBTYCLCAGIAE2AiggBiADNgI8IAYgBTYCOCAGIAE2AjQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAAIgdBAmtBC0kgB0Eja0EESXIgB0ENa0EHSXJFBEBBBCEIIAdBFGsOFAMCAwMDAwMIEgcIEgQSBRISEhIRAQsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNEyADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNEyAGQYAhaiACIAMgBBD5FiAGQeAFaiAGQYghaikDADcDACAGQegFaiAGQZAhaikDADcDACAGIAE2AqgmIAYgBikDgCE3A9gFIAZBQGsgBkGYIWpBmAX8CgAAIAUoAggiAiAFKAIARgRAIAVBqO3PABCgKAsgBSgCBCACQbgFbGoiAUICNwMAIAEgBikD2AU3AwggAUEQaiAGQeAFaikDADcDACABQRhqIAZB6AVqKQMANwMAIAFBIGogBkFAa0GYBfwKAAAgBSACQQFqNgIIDB0LIAdBAk8NEAsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNESADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNESAGQYAhaiACIAMgBBD5FiAGQZALaiAGQYghaikDADcDACAGQZgLaiAGQZAhaikDADcDACAGIAE2AqgmIAYgBikDgCE3A4gLIAZB8AVqIAZBmCFqQZgF/AoAACAFKAIIIgIgBSgCAEYEQCAFQZjqzwAQoCgLIAUoAgQgAkG4BWxqIgFCAjcDACABIAYpA4gLNwMIIAFBEGogBkGQC2opAwA3AwAgAUEYaiAGQZgLaikDADcDACABQSBqIAZB8AVqQZgF/AoAACAFIAJBAWo2AggMGwsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNECADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNECAGQfggaiACIAMgBBCcAyAGQagLaiICIAZBiCFqKQMANwMAIAZBsAtqIgMgBkGQIWopAwA3AwAgBiABNgKoJiAGIAYpA4AhNwOgCyAGKQP4ICIJQgNSDQIgACAGKQOgCzcDACAAQRBqIAMpAwA3AwAgAEEIaiACKQMANwMADBsLIAZBCGogAkEEahCvLiAGKAIIIgIgBigCDCIHRg0ZDAQLIAIoAggtAAAiAUEaTQRAQQEgAXQiAkGAgMAacQ0FIAJBgICAJHENByABQRVGDQYLIAQoAgAiAyAEKAIERg0RIAQgA0EEajYCACAGQfggaiECIAZBKGohBxCpLyEEEKovIgFCADcCFCABQoCAgIDAADcCDCABQQA6AAggAUKCgICAEDcCACAEIAE2AgAgAygCACIDIAMoAgAiCEEBajYCAAJAAkAgCEEASA0AIAcoAggoAgAiByAHKAIAIghBAWo2AgAgCEEASA0AIAJBCGogAyAHIAQQ+RYgAiABNgKwBSACQgI3AwAMAQsACyAGQeggaiIBIAZBiCFqKQMANwMAIAZB8CBqIgIgBkGQIWopAwA3AwAgBiAGKQOAITcD4CAgBikD+CAiCUIDUg0KIAAgBikD4CA3AwAgAEEQaiACKQMANwMAIABBCGogASkDADcDAAwZCyAGQbgLaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUG46s8AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQOgCzcDCCABQRBqIAZBqAtqKQMANwMAIAFBGGogBkGwC2opAwA3AwAgAUEgaiAGQbgLakGYBfwKAAAgBSACQQFqNgIIDBcLQQghCAsgBkH4IGogASACIAhqKAIAQTBqIAMgBCAFELwBIAYoAvggIgFBCEYNFSAAIAYpAvwgNwIEIABBFGogBkGMIWooAgA2AgAgAEEMaiAGQYQhaikCADcCACAAIAE2AgAMFgsDQAJAIAZB+CBqIAEgAigCAEEwaiADIAQgBRC8ASAGKAL4ICIIQQhHDQAgByACQQRqIgJHDQEMFgsLIAAgBikC/CA3AgQgAEEUaiAGQYwhaigCADYCACAAQQxqIAZBhCFqKQIANwIAIAAgCDYCAAwVCyAEKAIAIgEgBCgCBEYNDSAEIAFBBGo2AgAgBkH4IGogBkE0aiABEPgdIAZB2BBqIgEgBkGIIWopAwA3AwAgBkHgEGoiAiAGQZAhaikDADcDACAGIAYpA4AhNwPQECAGKQP4ICIJQgNSDQMgACAGKQPQEDcDACAAQRBqIAIpAwA3AwAgAEEIaiABKQMANwMADBQLIAQoAgAiASAEKAIERg0NIAQgAUEEajYCACAGQfggaiAGQTRqIAEQ+B0gBkG4G2oiASAGQYghaikDADcDACAGQcAbaiICIAZBkCFqKQMANwMAIAYgBikDgCE3A7AbIAYpA/ggIglCA1INASAAIAYpA7AbNwMAIABBEGogAikDADcDACAAQQhqIAEpAwA3AwAMEwsgBCgCACIBIAQoAgRGDQ0gBCABQQRqNgIAIAZB+CBqIAZBNGogARD4HSAGQYgWaiIBIAZBiCFqKQMANwMAIAZBkBZqIgIgBkGQIWopAwA3AwAgBiAGKQOAITcDgBYgBikD+CAiCUIDUg0CIAAgBikDgBY3AwAgAEEQaiACKQMANwMAIABBCGogASkDADcDAAwSCyAGQcgbaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUHY6s8AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQOwGzcDCCABQRBqIAZBuBtqKQMANwMAIAFBGGogBkHAG2opAwA3AwAgAUEgaiAGQcgbakGYBfwKAAAgBSACQQFqNgIIDBALIAZB6BBqIAZBmCFqQZgF/AoAACAFKAIIIgIgBSgCAEYEQCAFQfjqzwAQoCgLIAUoAgQgAkG4BWxqIgEgCTcDACABIAYpA9AQNwMIIAFBEGogBkHYEGopAwA3AwAgAUEYaiAGQeAQaikDADcDACABQSBqIAZB6BBqQZgF/AoAACAFIAJBAWo2AggMDwsgBkGYFmogBkGYIWpBmAX8CgAAIAUoAggiAiAFKAIARgRAIAVBmOvPABCgKAsgBSgCBCACQbgFbGoiASAJNwMAIAEgBikDgBY3AwggAUEQaiAGQYgWaikDADcDACABQRhqIAZBkBZqKQMANwMAIAFBIGogBkGYFmpBmAX8CgAAIAUgAkEBajYCCAwOCyAGQbAmaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUG4688AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQPgIDcDCCABQRBqIAZB6CBqKQMANwMAIAFBGGogBkHwIGopAwA3AwAgAUEgaiAGQbAmakGYBfwKAAAgBSACQQFqNgIIDA0LIAIoAgQiAi0AMEEgRw0JIAZBGGogAkE0aiICEMM0IAYoAhxFDQogBkH4IGogASAGKAIYKAIAQTBqIAMgBCAFELwBIAYoAvggIgdBCEcEQCAAIAYpAvwgNwIEIABBFGogBkGMIWooAgA2AgAgAEEMaiAGQYQhaikCADcCACAAIAc2AgAMDgsgBkEQaiACEMM0IAYoAhQiAkECSQ0LIAZB+CBqIAEgBigCECgCBEEwaiADIAQgBRC8ASAGKAL4ICIBQQhGDQwgACAGKQL8IDcCBCAAQRRqIAZBjCFqKAIANgIAIABBDGogBkGEIWopAgA3AgAgACABNgIADA0LIAZBAjYC/CAgBkGI7c8ANgL4ICAGQgE3AoQhIAZBrwM2AswrIAYgBkHIK2o2AoAhIAYgBkEkajYCyCsgAEEEaiAGQfggahCZDiAAQQE2AgAMDAtBmO3PABCyOwsAC0GI6s8AELI7AAtBqOrPABCyOwALQajrzwAQsjsAC0Ho6s8AELI7AAtByOrPABCyOwALQYjrzwAQsjsACyAGQQA2AoghIAZBATYC/CAgBkGk7M8ANgL4ICAGQgQ3AoAhIAZB+CBqQazszwAQ7ywAC0EAQQBByOvPABDDIQALQQEgAkHY688AEMMhAAsgAEEINgIACyAGQdAraiQAC62+AgMofwN+AXwjAEGACmsiDCQAAkACQAJAAkACQAJAIAxB+AlqAn8CQAJ/AkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQCwBUEBaw4GBwUBAgMEAAsgAEGBgoAINgCxBSAAQYGAgIB4NgK8ASAAQQA6ALgBIAAgACkDmAE3A6gBIAAgAEGoAWoiAzYCuAUgACADNgKYBSAAQbABaiAAQaABaikDADcDAAsgDEEQaiEFIwBBEGsiAyQAAkAgAEG4BWoiBygCACIKBEAgA0EIaiAKIAEQ0RNBASECIAUgAygCCEEBcQR/QQAFIAdBADYCACADIAogARDREyADKAIAIQIgAygCBAs2AgQgBSACNgIAIANBEGokAAwBC0HMlsMAQRxB6JbDABCfKQALQQEhAyAMKAIQQQFxBEBBAyEgDBsLAkAgDCgCFCIDBEAgAygCAEGAgICAeEYNASADEPEtIQogAEEAOgCyBSAMQagHaiAAQYgFaikDADcDACAMQbAHaiAAQZAFaigCADYCACAMQgM3A5AHIAwgACkDgAU3A6AHIABBADoAsQUgDEGoAWoiFCAAQZgB/AoAACMAQfADayIIJAAgCEGwAWoQzzUCQCAUKQMAQgJSBEAgCEHYAmogFEGYAfwKAAAMAQsgCEHYAmoQshILIAhBCGoiAiAIQbABaiAIQdgCahDrHyMAQeABayIHJAAgB0EANgLcASAHQoCAgIAQNwLUASMAQZAEayIDJAAgAyAKNgIMIANBEGogAkGYAfwKAAAgAyADLQCnAToAtAEgA0EMNgKwASADQciBwwA2AqwBIAIoApgBQYCAgIB4RwRAIAMgAikCnAE3AqwBCyAAQdABaiESIAxBkAdqIQQgB0EgaiEFIAdB1AFqIREgAkGYAWohEyADQdgBaiADQawBaiAKQQhqIgoQ0AoCQAJAAkACQCADKALYAUEBRgRAIANBhANqIANB8AFqKQMAIio3AgAgA0H8AmogA0HoAWopAwAiKzcCACADIAMpA+ABIiw3AvQCIAVBGGogKjcCACAFQRBqICs3AgAgBSAsNwIIIAVBgICAgHg2AgAgA0EQahDMLCATEIYwIAMoAgwiAiACKAIAIgJBAWs2AgAgAkEBRgRAIANBDGoQ+CMLIBEQ3jsMAQsgA0HAAWogA0HkAWopAgA3AwAgA0HIAWogA0HsAWopAgA3AwAgA0HQAWogA0H0AWooAgA2AgAgAyADKQLcATcDuAEgAi0ApAFFBEAgCiADQRBqEN4OCyADKAKgASEWIANB2AFqIgogA0EQakGYAfwKAABBoAFBCBCtNiIGRQ0BIAZCgYCAgBA3AwAgBkEIaiAKQZgB/AoAACADIAY2AtQBIANBiARqIBFBCGooAgA2AgAgAyARKQIANwOABCADQbgBahDaLSEJIAYgBigCACICQQFqNgIAIAJBAEgNAiMAQfAAayICJAAgAiAGNgIQIAIgCTYCDCMAQRBrIgskACALQQRqQYDAAEEAQQFBARCgGCALKAIIIRUgCygCBEEBRgRAIBUgCygCDEHQhsMAEP0vAAsgCygCDCEXIAJBFGoiEUEAOgAMIBFBADYCCCARIBc2AgQgESAVNgIAIBEgA0GABGoiFSkCADcCECARQRhqIBVBCGooAgA2AgAgC0EQaiQAIAJBADYCMCAJIAkoAgAiC0EBajYCAAJAAkAgC0EATgRAIAJBNGoiFyAJEKUSIAJB0ABqIRUjAEEQayILJAAgC0EIaiIZIBFBxL7DAEEEEKcaAkACQCALLQAIQQRGDQAgCykDCCIqQv8Bg0IEUQ0AIAsgKjcDCCAVIBkQgSsMAQsgFUEINgIACyALQRBqJAACQCACKAJQIgtBCEcEQCAKIAIpAlQ3AgwgCkEcaiACQeQAaigCADYCACAKQRRqIAJB3ABqKQIANwIAIApBgICAgHg2AgAgCiALNgIIIBcQ/iggERDTKSAREN47IAJBJGoQ3jsgBiAGKAIAIgpBAWs2AgAgCkEBRgRAIAJBEGoQriALIAIoAgwiCiAKKAIAIgpBAWs2AgAgCkEBRw0BIAJBDGoQgyAMAQsgAkHoAGoiCyACQSxqKQIANwMAIAJB4ABqIhUgAkEkaikCADcDACACQdgAaiIXIAJBHGopAgA3AwAgAiACKQIUNwNQQSRBBBCtNiIRRQ0CIBFCgYCAgBA3AgAgESACKQI0NwIIIAogAikDUDcCACARQRBqIAJBPGopAgA3AgAgEUEYaiACQcQAaikCADcCACARQSBqIAJBzABqKAIANgIAIApBCGogFykDADcCACAKQRBqIBUpAwA3AgAgCkEYaiALKQMANwIAIApBADoAbCAKQQA2AmggCiAGNgJkIAogETYCYCAKIAk2AlwgCkEANgJYIApCgICAgMAANwNQIApCBDcDSCAKQgA3A0AgCkKAgICAwAA3AzggCkIENwMwIApCADcDKCAKQoCAgICAATcDIAsgAkHwAGokAAwCCwALQQRBJBCjPQALIAMoAtgBIgpBgICAgHhGBEAgA0H0A2ogA0HwAWopAwAiKjcCACADQewDaiADQegBaikDACIrNwIAIAMgAykD4AEiLDcC5AMgBUEYaiAqNwIAIAVBEGogKzcCACAFICw3AgggBUGAgICAeDYCACAGIAYoAgAiAkEBazYCACACQQFGBEAgA0HUAWoQriALIANBuAFqEP4oIBMQhjAgAygCDCICIAIoAgAiAkEBazYCACACQQFHDQEgA0EMahD4IwwBCyADQfgDaiICIANB9AFqKAIANgIAIANB8ANqIhEgA0HsAWopAgA3AwAgA0HoA2oiCyADQeQBaikCADcDACADIAMpAtwBNwPgAyADQfACaiIJIANB+AFqQdAA/AoAACADQcgDaiIVIAspAwA3AwAgA0HQA2oiCyARKQMANwMAIANB2ANqIhEgAigCADYCACADIAMpA+ADNwPAAyADQfABaiIXIANB0AFqKAIANgIAIANB6AFqIhkgA0HIAWopAwA3AwAgA0HgAWoiHCADQcABaikDADcDACADIAMpA7gBNwPYASADKAIMIgIgAigCACIdQQFqNgIAIB1BAEgNAiAFIAMpA9gBNwJwIAVBiAFqIBcoAgA2AgAgBUGAAWogGSkDADcCACAFQfgAaiAcKQMANwIAIAVBHGogESgCADYCACAFQRRqIAspAwA3AgAgBUEMaiAVKQMANwIAIAUgAykDwAM3AgQgBUEgaiAJQdAA/AoAACAFIBY2AqwBIAVBgICAgHg2ApQBIAUgBjYCkAEgBSACNgKMASAFIAo2AgAgBSADKAIMNgKoASATEIYwCyADQZAEaiQADAILQQhBoAEQoz0LAAsCQCAHKAIgIgNBgICAgHhGBEAgB0EUaiAHQThqKQMAIio3AgAgB0EMaiAHQTBqKQMAIis3AgAgByAHKQMoIiw3AgQgEkEYaiAqNwIAIBJBEGogKzcCACASICw3AgggEkIENwMAAkAgBCgCEEUNACAEQRRqEJI+IAQoAhQiA0GEAUkNACADEPIfCwJAIAQoAhgiA0UNACADIAMoAgBBAWsiAzYCACADDQAgBEEYahCyGgsCQCAEKAIcIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIARBHGoQshoLIAQoAiAiA0UNASADIAMoAgBBAWsiAzYCACADDQEgBEEgahCyGgwBCyAHQRhqIgIgB0E8aigCADYCACAHQRBqIgUgB0E0aikCADcDACAHQQhqIgogB0EsaikCADcDACAHIAcpAiQ3AwAgEkHIAGogB0FAa0GQAfwKAAAgEkHEAGogAigCADYCACASQTxqIAUpAwA3AgAgEkE0aiAKKQMANwIAIBIgBykDADcCLCASIARBKPwKAAAgEiADNgIoCyAHQeABaiQAIAhB8ANqJAAgACkD0AFCBFEEQCAMQfAGaiIDIABB6AFqKQMANwMAIAxB6AZqIgIgAEHgAWopAwA3AwAgDCAAKQPYATcD4AYgAEEAOgC0BSAAKAKUBSEFQRhBCBCtNiIBRQ0JIAEgDCkD4AY3AwAgAUEQaiADKQMANwMAIAFBCGogAikDADcDACAMIAE2AqwBIAxBATYCqAEgBCAFIBQQxyYgDCgCkAdBBnFBBkYNHCAEEO4NDBwLIABBAToAswUgAEGoA2ogEkHYAfwKAAAgAEEAOgC0BSAAKAKUBSEDIAxBBjYCqAEgDEGQB2oiAiADIAxBqAFqEMcmIAwoApAHQQZxQQZHBEAgAhDuDQtBAAwPCyAAQQA6ALQFIAAoApQFIQIgDEGoAWoiBUEQQQBBAUEBEKAYIAwoAqwBIQMgDCgCqAFBAUYNCCAMKAKwASIBQQhqQYTcwgApAAA3AAAgAUH828IAKQAANwAAIAxBEDYCmAcgDCABNgKUByAMIAM2ApAHIAFBEBCTPiEDIAxBkAdqIgEQ3jsgDCADNgKsASAMQQU2AqgBIAEgAiAFEMcmIAwoApAHQQZxQQZGDRogARDuDQwaCyAAQQA6ALQFIAAoApQFIQIgDEEANgKYByAMQoCAgIAQNwKQByAMQezIwgA2AqwBIAxCoICAgA43ArABIAwgDEGQB2oiATYCqAEgA0EEaiAMQagBaiIDEKwRDQggDEE4aiAMQZgHaigCACIFNgIAIAwgDCkCkAc3AzAgDCgCNCAFEJM+IQUgDEEwahDeOyAMIAU2AqwBIAxBBTYCqAEgASACIAMQxyYgDCgCkAdBBnFBBkYNGSABEO4NDBkLIAAoArgFISNBAQwMCyAAQfgFaiEmAkAgAC0A+AVBAWsOAwgCCwALIAAoAuQFIQ8gACgC4AUhJEECDAsLIABBuAVqISAgAEGACmohJgJAIAAtAIAKQQFrDgMJAQAMCyAAQegIaiEkIABB6AlqISUCQCAALQDoCUEBaw4ECAEOAAILIAAoAvQJISMgACgC8AkhAwwOCwALIAAoAuAJIQMMCgtB7NvCABDoKwALQQhBGBCjPQALIAMgDCgCsAFB/NnCABD9LwALQZTJwgBBNyAMQTBqQYTJwgBBzMnCABDVHgALQZTXwgAQ6CsAC0Gk18IAEOgrAAtBhNfCABDoKwALQQMLIQMDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDgMAAQIDCyAAIABBmAVqIiM2ArgFDAwLICMoAgAiAigCFCEDIAJBgYCAgHg2AhQgAEG4BWohIAJAIANBgYCAgHhHBEAgDEEoaiACQSBqKQIANwIAIAwgAzYCHCAMIAIpAhg3AiAMAQsgDEEcaiACIAEQqRogDCgCHCEDCyADQYKAgIB4Rw0FQQEhA0EEISAMGgsgJCgCUCAMQagBaiAkQShqIA8Q9gkgDCgCqAEiA0EIRwRAIAxBQGsgDEG8AWooAgA2AgAgDEE4aiAMQbQBaikCADcDACAMIAwpAqwBNwMwDAQLICQoAlBGDQEgAEEAOgD0BSAAICQ2AugFQQMhAwwMCyAMQagBaiAAQegFaiABEMYOIAwoAqgBIgNBCUYNByAMQZgIaiAMQbwBaigCADYCACAMQZAIaiAMQbQBaikCADcDACAMIAwpAqwBNwOICCAALQD0BUEDRgRAIABB7AVqELwqCyADQQhHDQELQQghAwwBCyAMQUBrIAxBmAhqKAIANgIAIAxBOGogDEGQCGopAwA3AwAgDCAMKQOICDcDMAsgDEGICWoiAiAMQUBrKAIANgIAIAxBgAlqIgUgDEE4aikDADcDACAMIAwpAzA3A/gIICZBAToAACAMQZwHaiAFKQMANwIAIAxBpAdqIAIoAgA2AgAgDCAMKQP4CDcClAcgDCADNgKQByADQQhHBEAgDEGQB2oQySMLIABBzAVqEOkrIAAoArgFQYCAgIB4Rw0FDAELIAAgDCkCHCIqNwKcBSAAQawFaiAMQSxqIgMoAgA2AgAgAEGkBWogDEEkaiICKQIANwIAICqnQYGAgIB4Rg0CICAgDCkCHCIqNwIAICBBEGogAygCADYCACAgQQhqIAIpAgA3AgAgKqdBgICAgHhHDQELIABBuAVqEPUuDAMLIAAgDCkCHDcCzAUgAEEAOgD4BSAAIABBzAVqIg82AuQFIAAgAEGoA2oiJDYC4AUgAEHcBWogDEEsaigCADYCACAAQdQFaiAMQSRqKQIANwIAIABB+AVqISYMBAsgAEEAOgCzBSAMQagBaiIDIABBqANqQdgB/AoAACAgIANByAT8CgAAIABBADoAgAogAEGACmohJgwFCyAmQQM6AABBASEDQQUhIAwQC0EAIQMMAgtBASEDDAELQQIhAwwACwALIABBkAdqIgMgIEHYAfwKAAAgAEEAOgDoCSAAIAM2AuAJIABB6AhqISQgAEHoCWohJQsgACADNgLkCSAMQZAHaiEeIwBBIGsiJyQAICdBCGogA0EoaiIcEP8GAkAgJygCCCIDQQhHBEAgHiAnKQIMNwIMIB5BHGogJ0EcaigCADYCACAeQRRqICdBFGopAgA3AgAgHkEDNgIAIB4gAzYCCAwBC0IAISojAEGQAmsiFSQAAkACQAJAAkACQCAcLQBsRQRAIBwoAmggHCgCKEYNAkEoIQIgFUGYAWpBKEEAQQFBARCgGCAVKAKcASEDIBUoApgBQQFGDQQgFSgCoAEiBUGUwcMAQSj8CgAADAELQSUhAiAVQZgBakElQQBBAUEBEKAYIBUoApwBIQMgFSgCmAFBAUYNAyAVKAKgASIFQbzBwwBBJfwKAAALIB4gAjYCFCAeIAU2AhAgHiADNgIMIB5BADYCCCAeQQM2AgAMAQsgFUGYAWohGSMAQbABayIUJAAgHEEBOgBsAkACQAJAIBwoAigiAwRAIBwoAiQhAiADQQZ0IQMDQCAUQegAaiAcIBwoAjAgHCgCNCACEIEHIBQoAmgiBUEIRwRAIBkgFCkCbDcCDCAZQRxqIBRB/ABqKAIANgIAIBlBFGogFEH0AGopAgA3AgAgGUEDNgIAIBkgBTYCCAwDCyACQUBrIQIgA0FAaiIDDQALCwJ/IBwoAmRBCGoQ1TQiAwRAIAMoAgghAiAcKAJYIQUgAygCBCEDIBQgHCgCVCIKNgJwIBQgAzYCaCAUIAogBUEYbGo2AnQgFCADIAJBGGxqNgJsIBRBCGogFEHoAGoQqRUgFCkCDCEqIBQoAggMAQtBgICAgHggHCgCWEUNABogFEHoAGogHEHQAGoQxBAgFCkCbCEqIBQoAmgLIQIgFEEUaiAcKAIkIgMgAyAcKAIoQQZ0ahCkGyAUIBwoAmRBCGoQ5TsgFCgCACEHIBRB6ABqIBQoAgQiA0EAQQFBARCgGCAUKAJsIQUgFCgCaEEBRg0BIBQoAnAhCiADBEAgCiAHIAP8CgAACyAUQShqIBRBHGooAgA2AgAgFEEANgJYIBRBADYCUCAUIAM2AkAgFCAKNgI8IBQgBTYCOCAUIBQpAhQ3AyAgFCAcNgJEIBQgHEHgAGo2AkwgFCAcQdwAajYCSCAUQQJBASAcKAJkLQCdARs2AmAgFEGAgICAeDYCLCACQYCAgIB4RwRAIBRB6ABqIgMgFEEgaiIFQcQA/AoAACAUQfQAahCHMCAUICo3AnggFCACNgJ0IAUgA0HEAPwKAAALIBQgHCkCPDcDUCAUIBwpAkg3A1hBACEGQgAhKiMAQZACayISJAAgFEEgaiIXKAIIIgIEQCAXKAIEQShqIR0DQCAdKQMAICp8ISogHUHQAGohHSACQQFrIgINAAsLAkACQAJAAkAgFygCMCIhRQ0AIBJByABqIQkgFygCNCEbIwBBIGsiCCQAAkACQCAXKAIIIgNFDQAgFygCBCIRIANB0ABsaiEiIBdBJGohFgJAA0ACQCARKAI4IgMEQCAGIBtPDQMgA0HoA2whEyARKAI0QawDaiEdICEgBkEMbGoiGigCCCEQQQAhC0F/IQ8DQCAQIA9BAWoiD0YNAiAaKAIEIAtqIgIoAgBBgICAgHhHBEAgFigCACgCHCENIAhBCGohDiMAQdAAayIDJAAgAyAWNgIgIANCgICAgJCAgICAfzcCCCADQoCAgIAgNwIAIANBADsBJCADQShqIQojAEFAaiIFJAAgBUEMakH9usIAQQsQgCAgBUEsaiADEOcnAkAgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgBUEsaiIHQYi7wgBBCkENQQEQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwBCyAFQSxqIgcQhjAgByADQQIgAigCCCIEEKwUIAUoAiwiB0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAHNgIADAELIAQEQCACKAIEIQcDQCAFQSxqIAMgBy0AABDRGSAFKAIsIh9BBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogHzYCAAwDCyAHQQFqIQcgBEEBayIEDQALCyADEMYhIAVBLGoiB0GSu8IAQQpBDUECEOgcIAVBGGogAyAHEK0UIAUoAhgiBEEERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiAENgIAIAcQhjAMAQsgBUEsaiIHEIYwIAcgA0EIIAIoAhQiBBCsFCAFKAIsIgdBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogBzYCAAwBCyAEBEAgAigCEEEIaiEHIARBDGwhBANAIAVBLGogAyAHQQRrKAIAIAcoAgAQphsgBSgCLCIfQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIB82AgAMAwsgB0EMaiEHIARBDGsiBA0ACwsgAxDGISAFQSxqIgdBnLvCAEEKQQ1BAxDoHCAFQRhqIAMgBxCtFCAFKAIYIgRBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBDYCACAHEIYwDAELIAVBLGoiBxCGMCAHIANBCCACKAIgIgQQrBQgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgBARAIAIoAhxBCGohByAEQQxsIQQDQCAFQSxqIAMgB0EEaygCACAHKAIAEKYbIAUoAiwiH0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAfNgIADAMLIAdBDGohByAEQQxrIgQNAAsLIAMQxiEgBUEsaiIHQaa7wgBBDkEGQQQQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwBCyAFQSxqIgcQhjAgByADIAIoAkgQqhsgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgAxDGISACKAIkQYCAgIB4RwRAIAVBLGoiB0G0u8IAQQtBDUEFEOgcIAVBGGogAyAHEK0UIAUoAhgiBEEERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiAENgIAIAcQhjAMAgsgBUEsaiIHEIYwIAcgA0EHIAIoAiwiBBCsFCAFKAIsIgdBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogBzYCAAwCCyAEBEAgAigCKCEHIARBA3QhBANAIAVBLGogAyAHKQMAEK0bIAUoAiwiH0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAfNgIADAQLIAdBCGohByAEQQhrIgQNAAsLIAMQxiELIAIoAjBBgICAgHhHBEAgBUEsaiIHQb+7wgBBG0ENQQYQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwCCyAFQSxqIgcQhjAgByADQQcgAigCOCIEEKwUIAUoAiwiB0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAHNgIADAILIAQEQCACKAI0IQcgBEEDdCEEA0AgBUEsaiADIAcpAwAQrRsgBSgCLCIfQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIB82AgAMBAsgB0EIaiEHIARBCGsiBA0ACwsgAxDGIQsgAigCPEGAgICAeEcEQCAFQSxqIgdB2rvCAEEbQQ1BBxDoHCAFQRhqIAMgBxCtFCAFKAIYIgRBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBDYCACAHEIYwDAILIAVBLGoiBxCGMCAHIANBByACKAJEIgQQrBQgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAgsgBARAIAIoAkAhByAEQQN0IQQDQCAFQSxqIAMgBykDABCtGyAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwECyAHQQhqIQcgBEEIayIEDQALCyADEMYhCyAFQSxqIAMQgDYgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgCiADEOUoCyAFQQxqEN47IAVBQGskAAJAIAMoAigiAkEERwRAIANByABqIANBNGopAgA3AgAgAyADKQIsNwJAIAMgAjYCPCAOIANBPGoQpSUMAQsgDkEINgIACyADELouIANB0ABqJAAgCCgCCCICQQhHBEAgCSAIKQIMNwIEIAlBFGogCEEcaigCADYCACAJQQxqIAhBFGopAgA3AgAMCAsgFigCACgCHCEDIB1BBGtBATYCACAdQZQDayANrTcDACAdQZwDa0IBNwMAIB0gAyANazYCAAsgHUHoA2ohHSALQcwAaiELIBNB6ANrIhMNAAsLIAZBAWohBiAiIBFB0ABqIhFHDQEMAwsLIBAgEEHgncMAEMMhAAsgBiAbQdCdwwAQwyEAC0EIIQILIAkgAjYCACAIQSBqJAAgEigCSCIdQQhGDQAMAQsCQCAXKAI4Ih9FDQAgEkHIAGohECAXKAI8IQ4jAEEgayIJJAACQAJAIBcoAggiA0UNACAXKAIEIhEgA0HQAGxqISggF0EkaiEbQQAhBgJAA0ACQCARKAI4IgMEQCAGIA5PDQMgESgCNCEdIANB6ANsIRMgHyAGQQxsaiIpKAIIIQ1BACELQX8hDwNAIA0gD0EBaiIPRg0CICkoAgQgC2oiAigCAEGAgICAeEcEQCAbKAIAKAIcISEgCUEIaiEiIwBB0ABrIgMkACADIBs2AiAgA0KAgICAkICAgIB/NwIIIANCgICAgCA3AgAgA0EAOwEkIANBKGohByMAQUBqIgokACAKQQxqQaa9wgBBCxCAICAKQSxqIAMQ5ycCQCAKKAIsIgVBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgBTYCAAwBCyAKQSxqIgVBsb3CAEEOQQ1BARDoHCAKQRhqIAMgBRCtFCAKKAIYIgRBBEcEQCAHIAopAhw3AgQgB0EMaiAKQSRqKQIANwIAIAcgBDYCACAFEIYwDAELIApBLGoiBRCGMCAFIANBCiACKAIIIgUQrBQgCigCLCIEQQRHBEAgByAKKQIwNwIEIAdBDGogCkE4aikCADcCACAHIAQ2AgAMAQsgBQRAIAIoAgQhCCAFQRhsIRYDQCAKQSxqIQQjAEFAaiIFJAAgBUEMakGgv8IAQQwQgCAgBUEsaiADEOcnAkAgBSgCLCIaQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIBo2AgAMAQsgBUEsaiIaQay/wgBBBkEHQQEQ6BwgBUEYaiADIBoQrRQgBSgCGCIYQQRHBEAgBCAFKQIcNwIEIARBDGogBUEkaikCADcCACAEIBg2AgAgGhCGMAwBCyAFQSxqIhoQhjAgGiADIAgpAwAQrRsgBSgCLCIaQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIBo2AgAMAQsgAxDGISAFQSxqIhpBsr/CAEEUQQZBAhDoHCAFQRhqIAMgGhCtFCAFKAIYIhhBBEcEQCAEIAUpAhw3AgQgBEEMaiAFQSRqKQIANwIAIAQgGDYCACAaEIYwDAELIAVBLGoiGhCGMCAaIAMgCCgCEBCqGyAFKAIsIhpBBEcEQCAEIAUpAjA3AgQgBEEMaiAFQThqKQIANwIAIAQgGjYCAAwBCyADEMYhIAVBLGoiGkHGv8IAQQ9BB0EDEOgcIAVBGGogAyAaEK0UIAUoAhgiGEEERwRAIAQgBSkCHDcCBCAEQQxqIAVBJGopAgA3AgAgBCAYNgIAIBoQhjAMAQsgBUEsaiIaEIYwIBogAyAIKQMIEK0bIAUoAiwiGkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCAaNgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiGkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCAaNgIADAELIAQgAxDlKAsgBUEMahDeOyAFQUBrJAAgCigCLCIFQQRHBEAgByAKKQIwNwIEIAdBDGogCkE4aikCADcCACAHIAU2AgAMAwsgCEEYaiEIIBZBGGsiFg0ACwsgAxDGISACKAIMQYCAgIB4RwRAIApBLGoiBUG/vcIAQR9BDUECEOgcIApBGGogAyAFEK0UIAooAhgiBEEERwRAIAcgCikCHDcCBCAHQQxqIApBJGopAgA3AgAgByAENgIAIAUQhjAMAgsgCkEsaiIFEIYwIAUgA0EHIAIoAhQiBRCsFCAKKAIsIgRBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgBDYCAAwCCyAFBEAgAigCECEIIAVBA3QhFgNAIApBLGogAyAIKQMAEK0bIAooAiwiAkEERwRAIAcgCikCMDcCBCAHQQxqIApBOGopAgA3AgAgByACNgIADAQLIAhBCGohCCAWQQhrIhYNAAsLIAMQxiELIApBLGogAxCANiAKKAIsIgJBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgAjYCAAwBCyAHIAMQ5SgLIApBDGoQ3jsgCkFAayQAAkAgAygCKCICQQRHBEAgA0HIAGogA0E0aikCADcCACADIAMpAiw3AkAgAyACNgI8ICIgA0E8ahClJQwBCyAiQQg2AgALIAMQui4gA0HQAGokACAJKAIIIgJBCEcEQCAQIAkpAgw3AgQgEEEUaiAJQRxqKAIANgIAIBBBDGogCUEUaikCADcCAAwICyAbKAIAKAIcIQMgHUGgA2pBATYCACAdQQhqICGtNwMAIB1CATcDACAdQaQDaiADICFrNgIACyALQRhqIQsgHUHoA2ohHSATQegDayITDQALCyAGQQFqIQYgKCARQdAAaiIRRw0BDAMLCyANIA1BgJ7DABDDIQALIAYgDkHwncMAEMMhAAtBCCECCyAQIAI2AgAgCUEgaiQAIBIoAkgiHUEIRg0ADAELIBJBBGogFygCLCgCAEEIaigCCBD0HyAXKAIAIQMgFykCBCErIBJBgICAgHg2AhAgEkECNgIcIBJBgICAgHg2AjwgEiArNwLEASASIAM2AsABIBdBDGohGgJAIBcoAgxBgICAgHhHBEAgEkHMAWogGhDEEAwBCyASQYCAgIB4NgLMAQsgFygCQCEDIBJB6AFqIgIgFygCKCgCAEEIahCuFSASQeABaiIFIBJB9AFqKAIANgIAIBIgEikC7AE3A9gBAkAgEigC6AEiCkEIRgRAIBdBGGohHQJAIBcoAhhBgICAgHhHBEAgAiAdEN0gDAELIBJBgICAgHg2AugBCyASQagBaiASQQxqKAIANgIAIBJB0ABqIBJBJGopAgA3AwAgEkHYAGogEkEsaikCADcDACASQeAAaiASQTRqKQIANwMAIBJBtAFqIBJBxABqKAIANgIAIBIgEikCBDcDoAEgEiASKQIcNwNIIBIgEikCPDcCrAEgEiADNgK4ASASQfgAaiASQeABaigCADYCACASQYQBaiASQcgBaigCADYCACASQZABaiASQdQBaigCADYCACASQZwBaiASQfABaigCADYCACASICo3A2ggEiASKQPYATcDcCASIBIpAsABNwJ8IBIgEikCzAE3A4gBIBIgEikC6AE3ApQBIBcoAiQoAhwhKSASQegBaiEfIwBB0ABrIgMkACADIBdBJGoiKDYCICADQoCAgICQgICAgH83AgggA0KAgICAIDcCACADQQA7ASQgA0EoaiERIBJByABqIRsjAEFAaiIKJAAgCkEMakH+vcIAQQwQgCAgCkEsaiADEOcnAkAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAQsgCkEsaiICQYq+wgBBB0EGQQEQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwBCyAKQSxqIgIQhjAgAiADIBsoAnAQqhsgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAQsgAxDGISAKQSxqIgJBkb7CAEEGQQ1BAhDoHCAKQRhqIAMgAhCtFCAKKAIYIgVBBEcEQCARIAopAhw3AgQgEUEMaiAKQSRqKQIANwIAIBEgBTYCACACEIYwDAELIApBLGoiAhCGMCACIANBCiAbKAIwIgIQrBQgCigCLCIFQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAU2AgAMAQsgAgRAIBsoAiwhEyACQeAAbCEhA0AgCkEsaiEEIwBBQGoiByQAIAdBDGpB97/CAEENEIAgIAdBLGogAxDnJwJAIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIBMoAgBBAUYEQCAHQSxqIgJBhMDCAEEEQQZBARDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgEygCBBCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIIBEAgEygCDCEFIAdBLGoiAkGIwMIAQQtBBkECEOgcIAdBGGogAyACEK0UIAcoAhgiBkEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAGNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAFEKobIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAILIAMQxiELIBMoAhAEQCAHQSxqIgJBk8DCAEEPQQZBAxDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgEygCFBCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyAHQSxqIgJBosDCAEEEQQhBBBDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAELIAdBLGoiAhCGMCACIAMgEygCWCATKAJcEKYbIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIAMQxiEgEygCGEEBRgRAIBMoAhwhBSAHQSxqIgJBpsDCAEEMQQZBBRDoHCAHQRhqIAMgAhCtFCAHKAIYIgZBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBjYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgBRCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIgBEAgB0EsaiICQbLAwgBBDkEGQQYQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgBCAHKQIcNwIEIARBDGogB0EkaikCADcCACAEIAU2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIBMoAiQQqhsgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgEygCKARAIBMoAiwhBSAHQSxqIgJBlbzCAEEFQQZBBxDoHCAHQRhqIAMgAhCtFCAHKAIYIgZBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBjYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgBRCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIwBEAgEygCNCEFIAdBLGoiAkGavMIAQQlBBkEIEOgcIAdBGGogAyACEK0UIAcoAhgiBkEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAGNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAFEKobIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAILIAMQxiELIBMoAjgEQCATKAI8IQUgB0EsaiICQcDAwgBBCEEGQQkQ6BwgB0EYaiADIAIQrRQgBygCGCIGQQRHBEAgBCAHKQIcNwIEIARBDGogB0EkaikCADcCACAEIAY2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgEygCQEESRwRAIAdBLGoiAkHIwMIAQQtBCkEKEOgcIAdBGGogAyACEK0UIAcoAhgiBUEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgB0EsaiIFEIYwIBNBQGshCyMAQUBqIgIkACACQQxqQa68wgBBCxCAICACQSxqIAMQ5ycCQCACKAIsIgZBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwBCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEQIAsoAgAiBkECayAGQQFNG0EBaw4QAQIDBAUGBwgJCgsMDQ4PEAALIAJBLGoiBkG5vMIAQQZBCkEBEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEgsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBrLnCAEEKEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0QIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADBELIAJBLGoiBkG/vMIAQQNBCkECEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEQsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBvbbCAEEHEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0PIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADBALIAJBLGoiBkHCvMIAQQRBCkEDEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEAsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBprfCAEEIEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0OIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADA8LIAJBLGoiBkHGvMIAQQRBCkEEEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMDwsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBhrfCAEEIEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0NIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADA4LIAJBLGoiBkHKvMIAQQdBCkEFEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMDgsgAkEsaiIIEIYwIAtBBGohCyMAQUBqIgYkACAGQQxqQYq8wgBBCxCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyAGQSxqIglBlbzCAEEFQQZBARDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAMgCygCABCqGyAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyADEMYhIAZBLGoiCUGavMIAQQlBBkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALKAIEEKobIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAMQxiEgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQwgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMDQsgAkEsaiIGQdG8wgBBBEEKQQYQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwNCyACQSxqIggQhjAjAEEgayIGJAAgBkH+tsIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQsgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMDAsgAkEsaiIGQdW8wgBBBEEKQQcQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwMCyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpBkrjCAEEIEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAZBLGoiCUGauMIAQQ9BAkEBEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALLQAAENEZIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAMQxiEgBkEsaiIJQam4wgBBBEEKQQIQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwBCyAGQSxqIgkQhjAgCSALQQFqIAMQpwkgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgAxDGISAGQSxqIAMQgDYgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgCCADEOUoCyAGQQxqEN47IAZBQGskACACKAIsIgZBBEYNCiAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwLCyACQSxqIgZB2bzCAEEJQQpBCBDoHCACQRhqIAMgBhCtFCACKAIYIghBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCDYCACAGEIYwDAsLIAJBLGoiCBCGMCALQQRqIQsjAEFAaiIGJAAgBkEMakH/wMIAQQ0QgCAgBkEsaiADEOcnAkAgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAQsgBkEsaiIJQZq4wgBBD0ECQQEQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwBCyAGQSxqIgkQhjAgCSADIAstAAAQ0RkgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAQsgAxDGISAGQSxqIglBqbjCAEEEQQpBAhDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAtBAWogAxCnCSAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyADEMYhIAZBLGogAxCANiAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAZBDGoQ3jsgBkFAayQAIAIoAiwiBkEERg0JIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAoLIAJBLGoiBkHivMIAQQdBCkEKEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMCgsgAkEsaiIIEIYwIAtBBGohCyMAQUBqIgYkACAGQQxqQaa2wgBBBxCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyAGQSxqIglBrbbCAEEIQQNBARDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAMgCy0AARCJGiAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyADEMYhIAZBLGoiCUG1tsIAQQhBAkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALLQAAENEZIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAMQxiEgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQggBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMCQsgAkEsaiIGQem8wgBBB0EKQQsQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwJCyACQSxqIggQhjAjAEEgayIGJAAgBkGut8IAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQcgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMCAsgAkEsaiIGQfC8wgBBBEEKQQwQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwICyACQSxqIggQhjAjAEEgayIGJAAgBkGOt8IAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQYgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBwsgAkEsaiIGQfS8wgBBBEEKQQ0Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwHCyACQSxqIggQhjAjAEEgayIGJAAgBkH2tsIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQUgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBgsgAkEsaiIGQfi8wgBBBEEKQQ4Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwGCyACQSxqIggQhjAjAEEgayIGJAAgBkHGuMIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQQgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBQsgAkEsaiIGQfy8wgBBB0EKQQ8Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwFCyACQSxqIggQhjAjAEEgayIGJAAgBkGjvMIAQQsQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQMgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBAsgAkEsaiIGQYO9wgBBB0EKQRAQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwECyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpB3r3CAEELEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAstAABBAUYEQCALLQABIQkgBkEsaiILQem9wgBBFUEDQQEQ6BwgBkEYaiADIAsQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCxCGMAwCCyAGQSxqIgsQhjAgCyADIAkQiRogBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAgsgAxDGIQsgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQIgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMAwsgAkEsaiIGQYq9wgBBCEEKQREQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwDCyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpB+b7CAEEMEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAsoAgBBgICAgHhHBEAgBkEsaiIJQYW/wgBBA0EIQQEQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwCCyAGQSxqIgkQhjAgCSADIAsoAgQgCygCCBCmGyAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwCCyADEMYhCyAGQSxqIAMQgDYgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgCCADEOUoCyAGQQxqEN47IAZBQGskACACKAIsIgZBBEYNASAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwCCyACQSxqIgZBkr3CAEEJQQpBEhDoHCACQRhqIAMgBhCtFCACKAIYIghBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCDYCACAGEIYwDAILIAJBLGoiCBCGMCMAQUBqIgYkACAGQQxqQeG/wgBBDRCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyALKAIIQYCAgIB4RwRAIAZBLGoiCUGFv8IAQQNBCEEBEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAgsgBkEsaiIJEIYwIAkgAyALKAIMIAsoAhAQphsgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAgsgAxDGIQsgCygCAARAIAZBLGoiCUHuv8IAQQlBBkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAgsgBkEsaiIJEIYwIAkgAyALKAIEEKobIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAILIAMQxiELIAZBLGogAxCANiAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAZBDGoQ3jsgBkFAayQAIAIoAiwiBkEERg0AIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAELIAMQxiEgAkEsaiADEIA2IAIoAiwiBkEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgB0EsaiADEIA2IAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIAQgAxDlKAsgB0EMahDeOyAHQUBrJAAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAwsgE0HgAGohEyAhQeAAayIhDQALCyADEMYhIApBLGoiAkHUt8IAQQhBB0EDEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAQsgCkEsaiICEIYwIAIgAyAbKQMgEK0bIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAELIAMQxiEgCkEsaiICQZe+wgBBCkENQQQQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwBCyAKQSxqIgIQhjAgAiADQQogGygCPCICEKwUIAooAiwiBUEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESAFNgIADAELIAIEQCAbKAI4IRMgAkHQAGwhIQNAIApBLGohCyMAQUBqIgYkACAGQQxqQba3wgBBCBCAICAGQSxqIAMQ5ycCQCAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwBCyAGQSxqIgJBvrfCAEEHQQ1BARDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAELIAZBLGoiAhCGMCACIANBCiATKAI4IgIQrBQgBigCLCIFQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAU2AgAMAQsgAgRAIBMoAjQhFiACQegDbCEiA0AgBkEsaiEIIwBBQGoiByQAIAdBDGpB7LnCAEELEIAgIAdBLGogAxDnJwJAIAcoAiwiAkEERwRAIAggBykCMDcCBCAIQQxqIAdBOGopAgA3AgAgCCACNgIADAELIBYoAtADQYCAgIB4RwRAIAdBLGoiAkH3ucIAQQlBCEEBEOgcIAdBGGogAyACEK0UIAcoAhgiBUEERwRAIAggBykCHDcCBCAIQQxqIAdBJGopAgA3AgAgCCAFNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAWKALUAyAWKALYAxCmGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAHQSxqIgJB67fCAEELQQdBAhDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAELIAdBLGoiAhCGMCACIAMgFikDyAMQrRsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAQsgAxDGISAWKQMgQgJSBEAgB0EsaiICQYC6wgBBCUEKQQMQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgUQhjAgFkEgaiEPIwBBQGoiAiQAIAJBDGpBjMHCAEEOEIAgIAJBLGogAxDnJwJAIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAELIAJBLGoiBEGEwMIAQQRBBkEBEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAyAPKAL4AhCqGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwBCyADEMYhIAJBLGoiBEGawcIAQQlBDUECEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgA0EGIA8oAtACIgQQrBQgAigCLCIJQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAk2AgAMAQsgBARAIA8oAswCIRAgBEECdCENA0AgAkEsaiADIBAoAgAQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAwsgEEEEaiEQIA1BBGsiDQ0ACwsgAxDGISACQSxqIgRBo8HCAEEOQQ1BAxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIANBCCAPKALcAiIEEKwUIAIoAiwiCUEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAJNgIADAELIAQEQCAPKALYAkEIaiEQIARBDGwhDQNAIAJBLGogAyAQQQRrKAIAIBAoAgAQphsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAwsgEEEMaiEQIA1BDGsiDQ0ACwsgAxDGISACQSxqIgRBscHCAEEFQQZBBBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDygC/AIQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRBtsHCAEEKQQdBBRDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDqAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRBwMHCAEEXQQdBBhDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDsAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRB9rfCAEEVQQdBBxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDuAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISAPKALgAkGAgICAeEcEQCACQSxqIgRBob7CAEESQQ1BCBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIANBCiAPKALoAiIEEKwUIAIoAiwiCUEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAJNgIADAILIAQEQCAPKALkAiEQIARBGGwhDQNAIAJBLGogECADEPgKIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAQLIBBBGGohECANQRhrIg0NAAsLIAMQxiELIAJBLGoiBEHXwcIAQRBBB0EJEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAyAPKQPAAhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwBCyADEMYhIA8oAgBBAUYEQCAPKQMIISogAkEsaiIEQefBwgBBEUEHQQoQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADICoQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDygCEARAIA8pAxghKiACQSxqIgRB+MHCAEEWQQdBCxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAMgKhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwCCyADEMYhCyAPKQMwQgJSBEAgAkEsaiIEQY7CwgBBCkEKQQwQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgkQhjAgD0EwaiEQIwBBQGoiBCQAIARBDGpBzrjCAEEKEIAgIARBLGogAxDnJwJAIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAELIBAoAiBBgICAgHhHBEAgBEEsaiINQdi4wgBBA0EIQQEQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIBAoAiQgECgCKBCmGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAIsQYCAgIB4RwRAIARBLGoiDUHbuMIAQQNBCEECEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAQKAIwIBAoAjQQphsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgECgCAARAIBApAwghKiAEQSxqIg1B3rjCAEEKQQdBAxDoHCAEQRhqIAMgDRCtFCAEKAIYIg5BBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgDjYCACANEIYwDAILIARBLGoiDRCGMCANIAMgKhCtGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAIQBEAgECkDGCEqIARBLGoiDUHouMIAQQ5BB0EEEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAqEK0bIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAILIAMQxiELIBAoAjhBgICAgHhHBEAgBEEsaiINQfa4wgBBCUEIQQUQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIBAoAjwgECgCQBCmGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAJEQYCAgIB4RwRAIARBLGoiDUH/uMIAQQlBCEEGEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAQKAJIIBAoAkwQphsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgEC0AUCIOQQJHBEAgBEEsaiINQYi5wgBBEkECQQcQ6BwgBEEYaiADIA0QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIA5BAXEQ0RkgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgEC0AUSINQQJHBEAgBEEsaiIQQZq5wgBBEkECQQgQ6BwgBEEYaiADIBAQrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgEBCGMAwCCyAEQSxqIhAQhjAgECADIA1BAXEQ0RkgBCgCLCIQQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIBA2AgAMAgsgAxDGIQsgBEEsaiADEIA2IAQoAiwiEEEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAQNgIADAELIAkgAxDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDygC7AJBgICAgHhHBEAgAkEsaiIEQZjCwgBBDkENQQ0Q6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADQQogDygC9AIiBBCsFCACKAIsIglBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgCTYCAAwCCyAEBEAgDygC8AIhECAEQQxsIQ0DQCACQSxqIQkjAEFAaiIEJAAgBEEMakH/w8IAQREQgCAgBEEsaiADEOcnAkAgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgBEEsaiIOQZDEwgBBCUEGQQEQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIBAoAgAQqhsgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISAEQSxqIg5BmcTCAEEIQQZBAhDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAELIARBLGoiDhCGMCAOIAMgECgCBBCqGyAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyADEMYhIARBLGoiDkGhxMIAQQVBBkEDEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAQsgBEEsaiIOEIYwIA4gAyAQKAIIEKobIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAMQxiEgBEEsaiADEIA2IAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAkgAxDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMBAsgEEEMaiEQIA1BDGsiDQ0ACwsgAxDGIQsgDygCIARAIA8pAyghKiACQSxqIgRBpsLCAEETQQdBDhDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAMgKhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwCCyADEMYhCyAPKAKgAgRAIA8oAqQCIQkgAkEsaiIEQbnCwgBBE0EGQQ8Q6BwgAkEYaiADIAQQrRQgAigCGCIQQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIBA2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADIAkQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDykDiAFCAlIEQCACQSxqIgRBzMLCAEEPQQpBEBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiCRCGMCAPQYgBaiEQIwBBQGoiBCQAIARBDGpB8MLCAEEOEIAgIARBLGogAxDnJwJAIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAELIBAoAgBBAUYEQCAQKQMIISogBEEsaiINQb+9wgBBH0EHQQEQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADICoQrRsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgECgCEEGAgICAeEcEQCAEQSxqIg1B/sLCAEEaQQ1BAhDoHCAEQRhqIAMgDRCtFCAEKAIYIg5BBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgDjYCACANEIYwDAILIARBLGoiDRCGMCANIANBByAQKAIYIg4QrBQgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgDgRAIBAoAhQhDSAOQQN0IQ4DQCAEQSxqIAMgDSkDABCtGyAEKAIsIhhBBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgGDYCAAwECyANQQhqIQ0gDkEIayIODQALCyADEMYhCyAQKAIcQYCAgIB4RwRAIARBLGoiDUGYw8IAQRpBDUEDEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gA0EHIBAoAiQiDRCsFCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwCCyANBEAgECgCICEOIA1BA3QhDQNAIARBLGogAyAOKQMAEK0bIAQoAiwiEEEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAQNgIADAQLIA5BCGohDiANQQhrIg0NAAsLIAMQxiELIARBLGogAxCANiAEKAIsIhBBBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgEDYCAAwBCyAJIAMQ5SgLIARBDGoQ3jsgBEFAayQAIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAILIAMQxiELIA8pA7ABQgNSBEAgAkEsaiIEQdvCwgBBFUEKQREQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIhAQhjAgD0GwAWohDSMAQUBqIg8kACAPQQxqQcXFwgBBFBCAICAPQSxqIAMQ5ycCQCAPKAIsIgRBBEcEQCAQIA8pAjA3AgQgEEEMaiAPQThqKQIANwIAIBAgBDYCAAwBCyANKQMAQgJSBEAgD0EsaiIEQdnFwgBBBEEKQQEQ6BwgD0EYaiADIAQQrRQgDygCGCIJQQRHBEAgECAPKQIcNwIEIBBBDGogD0EkaikCADcCACAQIAk2AgAgBBCGMAwCCyAPQSxqIgkQhjAjAEFAaiIEJAAgBEEMakHBucIAQQsQgCAgBEEsaiADEOcnAkAgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgBEEsaiIOQcy5wgBBBEEEQQEQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIA0rA0AQzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISAEQSxqIg5B0LnCAEEEQQRBAhDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAELIARBLGoiDhCGMCAOIAMgDSsDSBDPJCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyADEMYhIARBLGoiDkHUucIAQQRBBEEDEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAQsgBEEsaiIOEIYwIA4gAyANKwNQEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAMQxiEgBEEsaiIOQdi5wgBBBEEEQQQQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIA0rA1gQzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISANKAIAQQFGBEAgDSsDCCEtIARBLGoiDkHcucIAQQRBBEEFEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAgsgBEEsaiIOEIYwIA4gAyAtEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAILIAMQxiELIA0oAhAEQCANKwMYIS0gBEEsaiIOQeC5wgBBBEEEQQYQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwCCyAEQSxqIg4QhjAgDiADIC0QzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAgsgAxDGIQsgDSgCIARAIA0rAyghLSAEQSxqIg5B5LnCAEEEQQRBBxDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAILIARBLGoiDhCGMCAOIAMgLRDPJCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwCCyADEMYhCyANKAIwBEAgDSsDOCEtIARBLGoiDkHoucIAQQRBBEEIEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAgsgBEEsaiIOEIYwIA4gAyAtEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAILIAMQxiELIARBLGogAxCANiAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyAJIAMQ5SgLIARBDGoQ3jsgBEFAayQAIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAILIAMQxiELIA0oAmBBgICAgHhHBEAgD0EsaiIEQd3FwgBBEEENQQIQ6BwgD0EYaiADIAQQrRQgDygCGCIJQQRHBEAgECAPKQIcNwIEIBBBDGogD0EkaikCADcCACAQIAk2AgAgBBCGMAwCCyAPQSxqIgQQhjAgBCADQQYgDSgCaCIJEKwUIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAILIAkEQCANKAJkIQQgCUECdCEOA0AgD0EsaiADIAQoAgAQqhsgDygCLCIJQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAk2AgAMBAsgBEEEaiEEIA5BBGsiDg0ACwsgAxDGIQsgD0EsaiADEIA2IA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAELIBAgAxDlKAsgD0EMahDeOyAPQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgAkEsaiADEIA2IAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCAARAIBYpAwghKiAHQSxqIgJBibrCAEETQQdBBBDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgKhCtGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAWKAKgAwRAIBYoAqQDIQUgB0EsaiICQZy6wgBBE0EGQQUQ6BwgB0EYaiADIAIQrRQgBygCGCIEQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAQ2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCEARAIBYpAxghKiAHQSxqIgJBr7rCAEETQQdBBhDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgKhCtGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAWKAKoAwRAIBYoAqwDIQUgB0EsaiICQcK6wgBBE0EGQQcQ6BwgB0EYaiADIAIQrRQgBygCGCIEQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAQ2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCsANBgYCAgHhHBEAgB0EsaiICQdW6wgBBD0EKQQgQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgkQhjAgFkGwA2ohDyMAQUBqIgUkACAFQQxqQf3EwgBBFBCAICAFQSxqIAMQ5ycCQCAFKAIsIgJBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgAjYCAAwBCwJAAkAgDygCAEGAgICAeEcEQCAFQSxqIgJBq8XCAEEaQQpBAhDoHCAFQRhqIAMgAhCtFCAFKAIYIgRBBEYNASAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgBDYCACACEIYwDAMLIAVBLGoiAkGRxcIAQRpBCkEBEOgcIAVBGGogAyACEK0UIAUoAhgiBEEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAENgIAIAIQhjAMAwsgBUEsaiIEEIYwIwBBIGsiAiQAIAJBssbCAEEXEIAgIAJBDGogAxDnJwJAIAIoAgwiD0EERwRAIAQgAikCEDcCBCAEQQxqIAJBGGopAgA3AgAgBCAPNgIADAELIAJBDGogAxCANiACKAIMIg9BBEcEQCAEIAIpAhA3AgQgBEEMaiACQRhqKQIANwIAIAQgDzYCAAwBCyAEIAMQ5SgLIAIQ3jsgAkEgaiQAIAUoAiwiAkEERg0BIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAILIAVBLGoiBBCGMCMAQUBqIgIkACACQQxqQY/GwgBBFxCAICACQSxqIAMQ5ycCQCACKAIsIhBBBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgEDYCAAwBCyACQSxqIhBBo8HCAEEOQQ1BARDoHCACQRhqIAMgEBCtFCACKAIYIg1BBEcEQCAEIAIpAhw3AgQgBEEMaiACQSRqKQIANwIAIAQgDTYCACAQEIYwDAELIAJBLGoiEBCGMCAQIANBCCAPKAIIIg0QrBQgAigCLCIQQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIBA2AgAMAQsgDQRAIA8oAgRBCGohECANQQxsIQ0DQCACQSxqIAMgEEEEaygCACAQKAIAEKYbIAIoAiwiDkEERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAONgIADAMLIBBBDGohECANQQxrIg0NAAsLIAMQxiEgDygCDEGAgICAeEcEQCACQSxqIhBBpsbCAEEMQQhBAhDoHCACQRhqIAMgEBCtFCACKAIYIg1BBEcEQCAEIAIpAhw3AgQgBEEMaiACQSRqKQIANwIAIAQgDTYCACAQEIYwDAILIAJBLGoiEBCGMCAQIAMgDygCECAPKAIUEKYbIAIoAiwiD0EERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAPNgIADAILIAMQxiELIAJBLGogAxCANiACKAIsIg9BBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgDzYCAAwBCyAEIAMQ5SgLIAJBDGoQ3jsgAkFAayQAIAUoAiwiAkEERg0AIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiAkEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigC3ANBgICAgHhHBEAgB0EsaiICQeS6wgBBGUEIQQkQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIBYoAuADIBYoAuQDEKYbIAcoAiwiAkEERwRAIAggBykCMDcCBCAIQQxqIAdBOGopAgA3AgAgCCACNgIADAILIAMQxiELIAdBLGogAxCANiAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwBCyAIIAMQ5SgLIAdBDGoQ3jsgB0FAayQAIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAMLIBZB6ANqIRYgIkHoA2siIg0ACwsgAxDGISAGQSxqIgJBxbfCAEEPQQdBAhDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAELIAZBLGoiAhCGMCACIAMgEykDIBCtGyAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwBCyADEMYhIAZBLGoiAkHUt8IAQQhBB0EDEOgcIAZBGGogAyACEK0UIAYoAhgiBUEERwRAIAsgBikCHDcCBCALQQxqIAZBJGopAgA3AgAgCyAFNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgAyATKQMoEK0bIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAELIAMQxiEgEygCPEGAgICAeEcEQCAGQSxqIgJB3LfCAEEPQQ1BBBDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIANBCiATKAJEIgIQrBQgBigCLCIFQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAU2AgAMAgsgAgRAIBMoAkAhFiACQQN0ISIDQCAGQSxqIQUjAEFAaiICJAAgAkEMakHTwMIAQQ0QgCAgAkEsaiADEOcnAkAgAigCLCIHQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAc2AgAMAQsgAkEsaiIHQeDAwgBBCkEGQQEQ6BwgAkEYaiADIAcQrRQgAigCGCIEQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAQ2AgAgBxCGMAwBCyACQSxqIgcQhjAgByADIBYoAgAQqhsgAigCLCIHQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAc2AgAMAQsgAxDGISACQSxqIgdB6sDCAEEKQQJBAhDoHCACQRhqIAMgBxCtFCACKAIYIgRBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgBDYCACAHEIYwDAELIAJBLGoiBxCGMCAHIAMgFi0ABBDRGSACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyADEMYhIAJBLGoiB0H0wMIAQQtBAkEDEOgcIAJBGGogAyAHEK0UIAIoAhgiBEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAENgIAIAcQhjAMAQsgAkEsaiIHEIYwIAcgAyAWLQAFENEZIAIoAiwiB0EERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAHNgIADAELIAMQxiEgAkEsaiADEIA2IAIoAiwiB0EERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAHNgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBigCLCICQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAI2AgAMBAsgFkEIaiEWICJBCGsiIg0ACwsgAxDGIQsgEygCAARAIBMpAwghKiAGQSxqIgJB67fCAEELQQdBBRDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIAMgKhCtGyAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwCCyADEMYhCyATKAIQBEAgEykDGCEqIAZBLGoiAkH2t8IAQRVBB0EGEOgcIAZBGGogAyACEK0UIAYoAhgiBUEERwRAIAsgBikCHDcCBCALQQxqIAZBJGopAgA3AgAgCyAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgAyAqEK0bIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAILIAMQxiELIBMvAUgEQCATLwFKIQUgBkEsaiICQYu4wgBBB0EFQQcQ6BwgBkEYaiADIAIQrRQgBigCGCIHQQRHBEAgCyAGKQIcNwIEIAtBDGogBkEkaikCADcCACALIAc2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiADIAUQqBsgBigCLCICQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAI2AgAMAgsgAxDGIQsgBkEsaiADEIA2IAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAELIAsgAxDlKAsgBkEMahDeOyAGQUBrJAAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAwsgE0HQAGohEyAhQdAAayIhDQALCyADEMYhIBsoAkBBgICAgHhHBEAgCkEsaiICQaG+wgBBEkENQQUQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwCCyAKQSxqIgIQhjAgAiADQQogGygCSCICEKwUIAooAiwiBUEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESAFNgIADAILIAIEQCAbKAJEIRMgAkEYbCEhA0AgCkEsaiATIAMQ+AogCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMBAsgE0EYaiETICFBGGsiIQ0ACwsgAxDGIQsgGygCTEGAgICAeEcEQCAKQSxqIgJBs77CAEEKQQhBBhDoHCAKQRhqIAMgAhCtFCAKKAIYIgVBBEcEQCARIAopAhw3AgQgEUEMaiAKQSRqKQIANwIAIBEgBTYCACACEIYwDAILIApBLGoiAhCGMCACIAMgGygCUCAbKAJUEKYbIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAILIAMQxiELIBsoAlhBgICAgHhHBEAgCkEsaiICQb2+wgBBDUENQQcQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwCCyAKQSxqIgIQhjAgAiADQQogGygCYCITEKwUIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAILIBMEQANAIApBLGohBSMAQUBqIgIkACACQQxqQfW7wgBBCxCAICACQSxqIAMQ5ycCQCACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyACQSxqIgdBgLzCAEEKQQpBARDoHCACQRhqIAMgBxCtFCACKAIYIgRBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgBDYCACAHEIYwDAELIAJBLGoiBBCGMCMAQSBrIgckACAHQcfDwgBBEBCAICAHQQxqIAMQ5ycCQCAHKAIMIgZBBEcEQCAEIAcpAhA3AgQgBEEMaiAHQRhqKQIANwIAIAQgBjYCAAwBCyAHQQxqIAMQgDYgBygCDCIGQQRHBEAgBCAHKQIQNwIEIARBDGogB0EYaikCADcCACAEIAY2AgAMAQsgBCADEOUoCyAHEN47IAdBIGokACACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyADEMYhIAJBLGogAxCANiACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyAFIAMQ5SgLIAJBDGoQ3jsgAkFAayQAIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAQLIBNBAWsiEw0ACwsgAxDGIQsgGygCAEECRwRAIApBLGoiAkHKvsIAQRRBCkEIEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAgsgCkEsaiIEEIYwIwBBQGoiBSQAIAVBDGpBpsTCAEETEIAgIAVBLGogAxDnJwJAIAUoAiwiAkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCACNgIADAELAkACQCAbKAIAQQFGBEAgBUEsaiICQcPEwgBBDkEKQQIQ6BwgBUEYaiADIAIQrRQgBSgCGCIHQQRGDQEgBCAFKQIcNwIEIARBDGogBUEkaikCADcCACAEIAc2AgAgAhCGMAwDCyAFQSxqIgJBucTCAEEKQQpBARDoHCAFQRhqIAMgAhCtFCAFKAIYIgdBBEcEQCAEIAUpAhw3AgQgBEEMaiAFQSRqKQIANwIAIAQgBzYCACACEIYwDAMLIAVBLGoiBxCGMCAbQQRqIQYjAEFAaiICJAAgAkEMakHEtsIAQQgQgCAgAkEsaiADEOcnAkAgAigCLCIIQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAg2AgAMAQsgBigCAEGAgICAeEcEQCACQSxqIghBzLbCAEEKQQhBARDoHCACQRhqIAMgCBCtFCACKAIYIgtBBEcEQCAHIAIpAhw3AgQgB0EMaiACQSRqKQIANwIAIAcgCzYCACAIEIYwDAILIAJBLGoiCBCGMCAIIAMgBigCBCAGKAIIEKYbIAIoAiwiCEEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAINgIADAILIAMQxiELIAYoAgxBgICAgHhHBEAgAkEsaiIIQda2wgBBD0EIQQIQ6BwgAkEYaiADIAgQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgCBCGMAwCCyACQSxqIggQhjAgCCADIAYoAhAgBigCFBCmGyACKAIsIghBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgCDYCAAwCCyADEMYhCyAGLQAYIghBAkcEQCACQSxqIgZB5bbCAEERQQJBAxDoHCACQRhqIAMgBhCtFCACKAIYIgtBBEcEQCAHIAIpAhw3AgQgB0EMaiACQSRqKQIANwIAIAcgCzYCACAGEIYwDAILIAJBLGoiBhCGMCAGIAMgCEEBcRDRGSACKAIsIgZBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgBjYCAAwCCyADEMYhCyACQSxqIAMQgDYgAigCLCIGQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAY2AgAMAQsgByADEOUoCyACQQxqEN47IAJBQGskACAFKAIsIgJBBEYNASAEIAUpAjA3AgQgBEEMaiAFQThqKQIANwIAIAQgAjYCAAwCCyAFQSxqIgcQhjAgG0EEaiEGIwBBQGoiAiQAIAJBDGpBtrnCAEELEIAgIAJBLGogAxDnJwJAIAIoAiwiCEEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAINgIADAELIAYoAgBBgICAgHhHBEAgAkEsaiIIQcy2wgBBCkEIQQEQ6BwgAkEYaiADIAgQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgCBCGMAwCCyACQSxqIggQhjAgCCADIAYoAgQgBigCCBCmGyACKAIsIghBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgCDYCAAwCCyADEMYhCyAGKAIMQYCAgIB4RwRAIAJBLGoiCEHWtsIAQQ9BCEECEOgcIAJBGGogAyAIEK0UIAIoAhgiC0EERwRAIAcgAikCHDcCBCAHQQxqIAJBJGopAgA3AgAgByALNgIAIAgQhjAMAgsgAkEsaiIIEIYwIAggAyAGKAIQIAYoAhQQphsgAigCLCIIQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAg2AgAMAgsgAxDGIQsgBi0AGCIIQQJHBEAgAkEsaiIGQeW2wgBBEUECQQMQ6BwgAkEYaiADIAYQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgBhCGMAwCCyACQSxqIgYQhjAgBiADIAhBAXEQ0RkgAigCLCIGQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAY2AgAMAgsgAxDGIQsgAkEsaiADEIA2IAIoAiwiBkEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAGNgIADAELIAcgAxDlKAsgAkEMahDeOyACQUBrJAAgBSgCLCICQQRGDQAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIAI2AgAMAQsgAxDGISAFQSxqIAMQgDYgBSgCLCICQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIAI2AgAMAQsgBCADEOUoCyAFQQxqEN47IAVBQGskACAKKAIsIgJBBEcEQCARIAopAjA3AgQgEUEMaiAKQThqKQIANwIAIBEgAjYCAAwCCyADEMYhCyAbKAJkQYCAgIB4RwRAIApBLGoiAkHevsIAQRtBCEEJEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAgsgCkEsaiICEIYwIAIgAyAbKAJoIBsoAmwQphsgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAgsgAxDGIQsgCkEsaiADEIA2IAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAELIBEgAxDlKAsgCkEMahDeOyAKQUBrJAACQCADKAIoIgJBBEcEQCADQcgAaiADQTRqKQIANwIAIAMgAykCLDcCQCADIAI2AjwgHyADQTxqEKUlDAELIB9BCDYCAAsgAxC6LiADQdAAaiQAIBIoAugBIgNBCEcEQCAZIBIpAuwBNwIMIBlBHGogEkH8AWooAgA2AgAgGUEUaiASQfQBaikCADcCACAZQQM2AgAgGSADNgIIDAILIBIgKCgCACIDKAIcIClrNgLMASASQegBaiICIAMgEkHMAWpBBBCnGgJAIBItAOgBQQRGDQAgEikD6AEiKkL/AYNCBFENACASICo3A+gBIBlBCGogAhCBKyAZQQM2AgAMAgsgEkHoAWoiAyAoKAIAQYD2zwBBBBCnGgJAIBItAOgBQQRGDQAgEikD6AEiKkL/AYNCBFENACASICo3A+gBIBlBCGogAxCBKyAZQQM2AgAMAgsgEigCEEGAgICAeEcEQCASQYgCaiICIBJBGGooAgA2AgAgEiASKQIQNwOAAiASQfwAaiIDEPQbIAMQ7zsgA0EIaiACKAIANgIAIAMgEikDgAI3AgALIBkgEkHIAGpB+AD8CgAAIBoQhzAMBAsgEikD+AEhKiAZIBIpA9gBNwIMIBkgKjcDGCAZIAo2AgggGUEDNgIAIBlBFGogBSgCADYCACASQcwBahCHMCASQcABaiIDEPQbIAMQ7zsgEkE8ahCGMCASQRxqELsuIBJBEGoQkjAgEkEEahCRMAwCCyASQcgAahCSKCASQRBqEJIwDAELIBkgEikCTDcCDCAZQRxqIBJB3ABqKAIANgIAIBlBFGogEkHUAGopAgA3AgAgGUEDNgIAIBkgHTYCCCAXEPQbIBcQ7zsLIBdBDGoQhzAgF0EYaiEdCyAdEIYwIBJBkAJqJAALIBRBsAFqJAAMAQsgBSAUKAJwQfDFwwAQ/S8ACyAVKAKYASIDQQNGBEAgFUGMAWogFUGwAWopAwAiKjcCACAVQYQBaiAVQagBaikDACIrNwIAIBUgFSkDoAEiLDcCfCAeQRhqICo3AgAgHkEQaiArNwIAIB4gLDcCCCAeQQM2AgAMAQsgFUGQAWoiAiAVQbQBaigCADYCACAVQYgBaiIFIBVBrAFqKQIANwMAIBVBgAFqIgogFUGkAWopAgA3AwAgFSAVKQKcATcDeCAVQSBqIBVBuAFqQdgA/AoAACAVQQxqIAopAwA3AgAgFUEUaiAFKQMANwIAIBVBHGogAigCADYCACAVIAM2AgAgFSAVKQN4NwIEIBVBmAFqIgMgHBCdGQJAIBUtAJgBQQRGDQAgFSkDmAEiKkL/AYNCBFENACAVICo3A5gBIB5BCGogAxCBKyAeQQM2AgAgFRDYHAwBCyAeIBVB+AD8CgAACyAVQZACaiQADAELIAMgFSgCoAFB8MXDABD9LwALCyAnQSBqJAAgDCgCkAciA0EDRgRAIAxBgAdqIAxBpAdqKQIAIio3AwAgDEGIB2ogDEGsB2ooAgAiATYCACAMQfAJaiAqNwMAIAxB+AlqIAE2AgAgDCAMKQKcByIqNwP4BiAMICo3A+gJIAwoApgHIQMMBgsgDEGAB2oiIyAMQaQHaikCADcDACAMQYgHaiICIAxBrAdqKAIANgIAIAwgDCkCnAc3A/gGIAwpApQHISogDEGICGoiBSAMQbAHakHYAPwKAAAgACAqNwLsCCAAIAM2AugIIAAgDCkD+AY3AvQIIABB/AhqICMpAwA3AgAgAEGECWogAigCADYCACAAQYgJaiAFQdgA/AoAACAAQQA6APwJIAAgACgC5Ak2AvAJCyAMQZAHaiAAQfAJaiABEMYOQQMgDCgCkAciA0EJRg0BGiAMQfAIaiAMQaQHaigCADYCACAMQegIaiAMQZwHaikCADcDACAMIAwpApQHNwPgCCAALQD8CUEDRgRAIABB9AlqELwqCyAMQeAIaiADQQhHDQMaIAAoAuQJIQMgDEEAOgCUByAMIAM2ApAHQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgDEGQB2oiAikCADcCACADQQhqIAJBCGooAgA2AgAgDEEIaiICQfyjwwA2AgQgAiADNgIAIAwoAgghAyAAIAwoAgwiIzYC9AkgACADNgLwCQsgDEGQB2ogAyABICMoAgwRAQAgDCgCkAciA0EJRw0BQQQLIQEgJSABOgAADAQLIAxBiAlqIAxBpAdqKAIANgIAIAxBgAlqIAxBnAdqKQIANwMAIAwgDCkClAc3A/gIIABB8AlqELwqIANBCEYNAiAMQfgIagsiAUEQaigCADYCACAMQfAJaiABQQhqKQIANwMAIAwgASkCADcD6AkgJBDUHAsgJUEBOgAAQQMhJQwCCyAMQfAJaiAAQfwIaikCADcDACAMQfgJaiAAQYQJaigCADYCACAMIAApAvQINwPoCSAAKALwCCEDIAAoAuwIISMgACgC6AghJSAMQZAJaiAAQYgJakHYAPwKAAAgAEEBOgDoCSAlQQRHDQELICZBAzoAAEEBIQNBBiEgDAILICQQ5SogAEGQB2oQ1AwgDEHYBmoiASAMQfgJaigCADYCACAMQdAGaiICIAxB8AlqKQMANwMAIAwgDCkD6Ak3A8gGIAxB8AVqIgUgDEGQCWpB2AD8CgAAIABBAToAgAogDEHEAGogAikDADcCACAMQcwAaiABKAIANgIAIAwgAzYCOCAMICM2AjQgDCAMKQPIBjcCPCAMICU2AjAgDEHQAGogBUHYAPwKAAAgIBDRLQJAICVBA0cEQCAMQTBqENQcDAELIAxBOGoQySMLIABBADoAswULIABBqAFqEJ0vIAAtALIFBEAgAEGABWoQhxoLQQAhA0EBISAgAC0AsQVFDQAgACkDAEICUQ0AIAAQoCkLIAAgIDoAsAUgDEGACmokACADC+LdBARcfw1+GH0CfCMAQdAAayI7JAAgOyAAKQPoASAAKQP4AX0iYaciCTYCKCAAKAL4KSEjIAAQ+A4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtALoqDQAgAQRAIABBAToAuioLIAAQ+A4gYUEBIAAoAiR0rVYNACA7IAAtAL4qNgIsIAAgACkD6AEgACkD8AF9pyIEIAkgBCAJSxtBAXRBjwRqEMkaAkACQAJAAkACQAJAAkACQCAAKALMAQRAIAAoAsgBIAAtALgqOgAAAkACQCAAKALMASIEQQFLBEAgAEG+KmohKyAAKALIASAALQC5KjoAASAALQC9Kg4EAQICCwILQQEgBEHAvNAAEMMhAAsgAC0AX0EBRw0AIAAoAsgBIQcgACgCzAEhBiMAQSBrIgQkAEEBQgAgO0EsaiIMIAcgBhDlEkECQgMgDCAHIAYQ5RJBAUIAIAwgByAGEOUSQQJCASAMIAcgBhDlEiAEQRhqQQA7AQAgBEIANwMQIABBCGoiDTUCICFgQQEhBQJAA0AgBCAFakEPaiIKIGCnIh1B/wBxOgAAIGBCgAFUDQEgCiAdQYABcjoAACBgQgeIIWAgBUEBaiIFQQtHDQALQQohBQsgBEEIaiAEQRhqLwEAOwEAIAQgBCkDEDcDAEEIIAWtQgN8IAwgByAGEOUSIAwgDCgCAEEHaiIKQXhxNgIAAkACQCAGIApBA3YiCksEQCAHIApqQQA6AAAgDS0AVEUNASANLQBVDQEgBEGBAToADyAEQeGvAjsADQwCCyAKIAZBzOzRABDDIQALIARB4a8COwANIA0tAFZFBEAgBEGAAToADwwBCyAEQYIBOgAPC0EAIQoDQEEIIARBDWogCmoxAAAgDCAHIAYQ5RIgCkEBaiIKQQNHDQALQQhCASAMIAcgBhDlEgJAIAVBC0kEQEEAIQoDQEEIIAQgCmoxAAAgDCAHIAYQ5RIgBSAKQQFqIgpHDQALIARBIGokAAwBCyAFQQpBrO7RABCwOwALIDsoAiwiBkEDdiIbIAAoAswBIgRPDQIgG0EBaiIFIARPDQggACgCyAEhBCADIBs2AgAgBCAbai0AACEHIAQgBWotAAAhBCAAIAZBB3E6AL4qIABCADcDACAAQQE6AL0qIAAgByAEQQh0cjsBuCoLIAAtAFxFBEAgAEEDOgC9KgwJCyAJRQRAQQAhCQwJCyAAKQP4AUICWgRAIAAtALwqRQ0DCyAAKALwKSIFIAAoAowqIgRJDQMgK0EAIAAoAuwpIARqIgYgBSAEayIEIAAoAvABICMgAEEIakECIAkgCUECTxsiByAAQbAqaiA7QSxqIAAoAsgBIAAoAswBQQAQtQ4gOygCLCINQQN2IhsgACgCzAEiBU8NBCAbQQFqIgwgBU8NBSAAKALIASIFIBtqLQAAIQogBSAMai0AACEFIAAgDUEHcToAviogACAALQC/KjoAwCogACAKIAVBCHRyOwG4KiAjIAApA/ABImCnIgxxIgUgBE8NBiAAIAUgBmotAAAiBToAvyoCQCAJQQFGIg1FBEAgACAFOgDAKiAMQQFqICNxIgUgBE8NASAAIAUgBmotAAA6AL8qCyAAQgA3AwAgAyAbNgIAIAAgYCAHrSJhfDcD8AEgACAAKQP4ASBhfCJgNwP4ASAAQQNBAiAALQC9KkECRhtBAyANGzoAvSogOyAJIAdrIgk2AiggACkD6AEgYH0hYQwJCyAFIARBiL7QABDDIQALQQBBAEGwvNAAEMMhAAsgGyAEQdC80AAQwyEAC0HwvNAAQcgAQbi90AAQnykACyAEIAVByL3QABCvOwALIBsgBUHYvdAAEMMhAAsgDCAFQei90AAQwyEACyAFIARB+L3QABDDIQALIAUgBEHgvNAAEMMhAAsgOyAAKQP4ARDLKyIHNgIwAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIgRBAUYEQEEBIQQgACgC3AENASA7QSBqICtBgIAIELkpIDsoAiQhBCA7KAIgIQUgACgC3AEiBgRAIAAoAtgBIAZBAnRBBBD4OgsgACAENgLcASAAIAU2AtgBIDtBGGogK0GAgAgQuCkgOygCHCEEIDsoAhghBSAAKALkASIGBEAgACgC4AEgBkEBEPg6CyAAIAQ2AuQBIAAgBTYC4AEgACgCHCEECyAEQQJPDQELIDtBADYCQCABRSBhUHENCCAAKALwKSIGIAAoAowqIgVJDQEgACgC7CkhDCA7IABB0AJqIABB0AFqIAQgCSA7QUBrELwQIAcgI3EhAiAGIAVrIQQgBSAMaiEFIDsoAgQhBiA7KAIAIQcCQCAAKAIcRQRAIAIgBEsNBCACIAVqIAQgAmsgCSABIAcgBiA7KAJAIABB0CJqIABB0CNqIABBpCpqIABB0CVqIDtBLGogACgCyAEgACgCzAEQghcMAQsgAiAESw0EIAIgBWogBCACayAJIAEgACgC2AEgACgC3AEgACgC4AEgACgC5AEgByAGIDsoAkAgO0EsaiAAKALIASAAKALMARDhDAsgOygCLCIFQQN2IgEgACgCzAEiAk8NBCACIAFBAWoiBEsEQCABIAAoAsgBIgJqLQAAIQEgAiAEai0AACECIAAgBUEHcToAviogACABIAJBCHRyOwG4KiAAKQP4ARDLKxogACkD6AEiYBDLKxogAEIANwMAIAAgYDcD+AEgOygCLEEDdiEbDAkLIAQgAkHYvtAAEMMhAAsgAEGUKmohDyAAKAKUKiAJQQF2akEBaiIEIAAoApAqTQ0GIAAgCUECdiAEakEQaiIENgKQKiA7QcgAakIANwMAIDtCADcDQCA7QTRqIgUgO0FAayAEEIMcIDtBEGogBUHMgs4AEJ0hIDsoAhQhBSA7KAIQIQYCQCAAKALEASIJRQ0AIA8oAgAiBCAFSw0FIAQgCUsNBiAEQQR0IgQEQCAGIAAoAsABIAT8CgAACyA7QQA2AkggO0KAgICAwAA3AkAgO0EIaiA7QUBrQYyHzgAQnSEgOygCCCEHIAAoAsQBIQQgACA7KAIMIgk2AsQBIAAoAsABIQwgACAHNgLAASAEBEAgDCAEQQR0QQQQ+DogACgCxAEhCQsgCUUNACAAKALAASAJQQR0QQQQ+DoLIAAgBTYCxAEgACAGNgLAAQwGCyAFIAZBmL7QABCvOwALIAIgBEGovtAAEK87AAsgAiAEQbi+0AAQrzsACyABIAJByL7QABDDIQALIAQgBUHovtAAELA7AAsgBCAJQfi+0AAQsDsACwJAAkACQCAAKALwKSIFIAAoAowqIgRPBEAgAEEIaiElIAAoArQqIQcgACgC7CkgBGohCCAFIARrIRAgOygCMCEEIDsoAighCSMAQeAAayI9JAAgAEHoAGoiQSgCACEFAkACQAJAIARFBEAgBUUNASBBIAEgCSAIIBAQ/hBFDQMgQRCUKkIANwIcDAMLIAUNAQtBCiEGAkACQCAlKAIUIgVBCkgNACAlLQBQQQFGDQBBKCESDAELAkACQCAFQQlrDgIBAQALQSghEiAFQQRHICUoAiAiBkH//z9NckUEQEE2IQYMAgsgBUEFSARAIAUhBgwCCwJAICUoAhgiDEERTgRAAkAgJS0AUEUEQCAGQYGAgAJJIAxBEk1yDQEMAwsgBkGBgMAASQ0AIAxBEksNAgsgJUEFNgIoICVBCSAFQQFrIgwgDEEJTxs2AjAgJUEOQQ8gBkGBgMAASRtBDyAFQQdJIgYbNgIsQQRBCkEQIAVBCUkbIAYbIQZBOCESDAMLQShBKUEqIAVBCUkbIAVBB0kbIQYMAgsgJUKGgICA8AE3AiggJUEFNgI0ICVBCSAFQQFrIgYgBkEJTxs2AjBBBEEKQRAgBUEJSRsgBUEHSRshBkE4IRIMAQsgJUEQNgI4ICVCiYCAgPABNwIoICVBCDYCMEEEIQZBNCESCyASICVqIAY2AgAgPUEIaiEdIAchDCMAQUBqIhckACAlQShqIQUCQAJAAkACQAJAAkACQAJAAkACQCAlKAIoIgZBAmsOCQABAgMHBwcEBQYLIB0gBSkCADcCDCAdQRxqIAVBEGopAgA3AgAgHUEUaiAFQQhqKQIANwIAIBcgK0GJgAQQuSkgFygCACEFIBcoAgQhBiAdQQA2AiwgHUEANgIoIB1BATYCJCAdIAY2AgggHSAFNgIEIB1BATYCACAdICUoAjwiBUGcBCAFGzYCMAwICyAdIAUpAgA3AgwgHUEcaiAFQRBqKQIANwIAIB1BFGogBUEIaikCADcCACAXQQhqICtBioAEELkpIBcoAgghBSAXKAIMIQYgHUEANgIsIB1BADYCKCAdQQE2AiQgHSAGNgIIIB0gBTYCBCAdQQI2AgAgHSAlKAI8IgVBnAQgBRs2AjAMBwsgHSAFKQIANwIMIB1BHGogBUEQaikCADcCACAdQRRqIAVBCGopAgA3AgAgF0EQaiArQYiACBC5KSAXKAIQIQUgFygCFCEGIB1BADYCLCAdQQA2AiggHUEBNgIkIB0gBjYCCCAdIAU2AgQgHUEDNgIAIB0gJSgCPCIFQZwEIAUbNgIwDAYLIwBBIGsiBiQAIAZBCGogK0IBICUoAiwiB0E/ca2GImAgJSgCMCISQT9xrSJhhqcQuSkgBigCDCEMIAYoAgghDSAGQRRqIgUgYKciDkHEntAAEJkVIAYgBUHMgs4AEKohICVBKGohBSAGKAIEIQogBigCACERAn8CfwJAAkACQAJAIBJBBGsOAwACAQILIAdBH3FBDkcNASAdIA02AgwgHSAKNgIIIB0gETYCBCAdIAUpAgA3AhQgHUEcaiAFQQhqKQIANwIAQRAhCiAdQSRqIAVBEGopAgA3AgBBByENICUoAjwiBUGcBCAFGwwDCyAHQR9xQQ9GDQELIB1BADYCNCAdQgE3AiwgHSASNgIcIB0gBzYCGCAdIAw2AhAgHSANNgIMIB0gCjYCCCAdIBE2AgQgHSAlKQI0NwIgIB0gJSgCKDYCFCAdQShqICVBPGooAgAiBTYCAEEgIAdrIQxCfyBhhqdBf3MhByAFQZwEIAUbIRFBBSENQcgAIQVBxAAhFkHAACEwQTghCkE8DAILIB0gDTYCDCAdIAo2AgggHSARNgIEIB0gBSkCADcCFCAdQRxqIAVBCGopAgA3AgBBECEKIB1BJGogBUEQaikCADcCAEEGIQ0gJSgCPCIFQZwEIAUbCyERQTghBUE0IRZBACEHQTAhMEEBIQ5BACESQSwLIAogHWogDDYCACAdaiAONgIAIB0gMGogBzYCACAWIB1qIBI2AgAgHSANNgIAIAUgHWogETYCACAGQSBqJAAMBQsgHSAFKQIANwIUIB1BJGogBUEQaikCADcCACAdQRxqIAVBCGopAgA3AgAgF0E0aiIFQYCAAkHEntAAEJkVIBdBIGogBUHMgs4AEKohIBcoAiAhBSAXKAIkIQYgF0EYaiArQYCAgAQQuSkgFygCGCEHIBcoAhwhDCAdQQA2AjQgHUEANgIwIB1BATYCLCAdIAw2AhAgHSAHNgIMIB0gBjYCCCAdIAU2AgQgHUEJNgIAIB0gJSgCPCIFQZwEIAUbNgI4DAQLIwBBEGsiDSQAICUoAhghBSANQQhqICtBgIAIELkpQQFBASAFdCIKayESIA0oAgghBiANKAIMIhEEQCARQQJ0IQcgBiEFA0AgBSASNgIAIAVBBGohBSAHQQRrIgcNAAsLIB1BBGoiBSAlKQIoNwIYIAVBKGogJUE4aikCADcCACAFQSBqICVBMGopAgA3AgAgDSArIApBAXQQuSkgDSkDACFgIAVBADYCOCAFQgE3AjAgBSAMNgIUIAUgCkEBazYCECAFIBI2AjwgBSARNgIEIAUgBjYCACAFIGA3AgggDUEQaiQAIB1BCjYCAAwDCyAGQTZGDQELIwBBIGsiBSQAIAVBCGogK0IBICUoAiwiBkE/ca2GImAgJSgCMCIHQT9xrSJhhqcQuSkgBSkDCCFiIAVBFGoiDCBgp0HEntAAEJkVIAUgDEHMgs4AEKohIAUpAwAhYCAdQQA2AlAgHUIBNwNIIB0gBzYCOCAdIAY2AjQgHSAHNgIsIB1CfyBhhqdBf3M2AiggHUEBIAZ0NgIkIB1BwAAgBms2AiAgHSBiNwMQIB0gYDcDCCAdICUpAjQ3AjwgHUHEAGogJUE8aigCACIGNgIAIB0gJSgCKDYCMCAdIAZBnAQgBhs2AlQgHUJ/ICUoAjRBOGxBOHGtiDcDGCAdQQg2AgAgBUEgaiQADAELIB0gBSkCADcCDCAdQRxqIAVBEGopAgA3AgAgHUEUaiAFQQhqKQIANwIAIBdBKGogK0GMgMAAELkpIBcoAighBSAXKAIsIQYgHUEANgIsIB1BADYCKCAdQQE2AiQgHSAGNgIIIB0gBTYCBCAdQQQ2AgAgHSAlKAI8IgVBnAQgBRs2AjALIBdBQGskACBBEPMTIEEgHUHYAPwKAAAgPUEYaiIGICVBOGopAgA3AwAgPUEQaiIHICVBMGopAgA3AwAgPSAlKQIoNwMIIEEQlCoiBUEQaiAGKQMANwIAIAVBCGogBykDADcCACAFID0pAwg3AgAgQSgCAARAIEEQlCpBADYCGAsgQRCUKkEBNgIYDAELIEFBACAJIAggEBD+EBoLID1B4ABqJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgQSgCAEEBaw4KAQIDBAUGBwgJCgALQeTNzgBBDEGAzs4AEO0sAAsgCUEHSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDCHCAFIAggECAjIARBAmsQwhwgBSAIIBAgIyAEQQFrEMIcCwwJCyAJQQdJIARBAk1yRQRAIEFBBGoiBSAIIBAgIyAEQQNrENsaIAUgCCAQICMgBEECaxDbGiAFIAggECAjIARBAWsQ2xoLDAgLIAlBB0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQ3RogBSAIIBAgIyAEQQJrEN0aIAUgCCAQICMgBEEBaxDdGgsMBwsgCUEHSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDcGiAFIAggECAjIARBAmsQ3BogBSAIIBAgIyAEQQFrENwaCwwGCyAJQQNJIARBAk1yRQRAIEFBBGoiBSAIIBAgIyAEQQNrENYTIAUgCCAQICMgBEECaxDWEyAFIAggECAjIARBAWsQ1hMLDAULIAlBA0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQ2RYgBSAIIBAgIyAEQQJrENkWIAUgCCAQICMgBEEBaxDZFgsMBAsgCUEDSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDaFiAFIAggECAjIARBAmsQ2hYgBSAIIBAgIyAEQQFrENoWCwwDCyAJQQdJIARBAk1yRQRAIEFBCGoiBSAIIBAgIyAEQQNrEJAWIAUgCCAQICMgBEECaxCQFiAFIAggECAjIARBAWsQkBYLDAILIAlBA0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQiRMgBSAIIBAgIyAEQQJrEIkTIAUgCCAQICMgBEEBaxCJEwsMAQsgQUEEaiEHIEEoAhghDCMAQRBrIgYkAAJAIAlBA0kgBEH/AE1yDQAgBEGAAWsiBSAFIAlqIg0gBCAEIA1LGyINTw0AA0AgBygCECEKIAZBADYCDCAHIAggECAFICMgDEGAASAKQQ8gBCAFayIKIApBD00bayAGQQxqQQhBABCDBxogBUEBaiIFIA1HDQALCyAGQRBqJAALIAAoAuwpIQUgACgC8CkhByAAKQPwARDLKyEMIAApA+gBIAApA/ABfachDQJAICUoAgBBA2siBkEESQ0AQQIhBiAlKAIUQQlMDQBBAkEDIAUgByAMICMgDRC/CxshBgsgBiE9AkAgACgClCpFDQAgACgCnCoNACA7QShqIQcgO0EwaiEMAkACQAJAAkAgACgClCpBAWsiBCAAKALEASIFSQRAIAA1AiAhYSAAKALAASAEQQR0aiIENQIEIWIgACkD+AEhYyAAKAL4KSENIAAoAoACIgWsIWAgBCAAQQxqELMgIgZBEE8gBq1CD30gYFJxDQQgYCBjIGJC////D4N9ImJCASBhhkIQfSJhIGEgYlYbVg0DIAcoAgAiBkUNA0EAIAVrIRAgBkEBayEFIAAoAowqIQogACgC8CkhCSAAKALsKSEdIAwoAgAhBgNAIAYgDXEgCmoiCCAJTw0CIAYgEGogDXEgCmoiEiAJTw0DIAggHWotAAAgEiAdai0AAEcNBCAHIAU2AgAgDCAGQQFqIgY2AgAgBCAEKAIEQQFqNgIEIAVBAWsiBUF/Rw0ACwwDCyAEIAVBmMHQABDDIQALIAggCUGowdAAEMMhAAsgEiAJQbjB0AAQwyEACyAEKAIEIgVB////D3EgBUEZdmohBiAELwEOAn8CQAJAIAQoAgAiBUEGTwRAIAVBggFJDQEgBUHCEEkNAkEVIAVBwjBJDQMaQRZBFyAFQcKwAUkbDAMLIAUMAgsgBUECayIFZ0EgakE/c0EBayIHQQF0IAUgB3ZqQQJqDAELIAVBwgBrZ0EgakE/c0EKagshBUH/B3EhBwJ/AkAgBkEKTwRAIAZBhgFJDQFBFyAGQcYQTw0CGiAGQcYAa2dBIGpBP3NBDGoMAgsgBkECawwBCyAGQQZrIgZnQSBqQT9zQQFrIglBAXQgBiAJdmpBBGoLIgZBB3EgBUEDdEE4cXIhCSAEAn8gByAFQf//A3FBB0tyRSAGQf//A3FBEElxRQRAIAVB+P8DcUEDdkEDbCAGQfj/A3FBA3ZqIgRBBnRBwJrIAiAEQQF0dkHAAXFqIAlyQUBrDAELIAkgCUHAAHIgBkH//wNxQQhJGws7AQwLIDsoAjAhBCA7KAIoIQkLIAAoAvApIgwgACgCjCoiBUkNASAAKALEASINIAAoApQqIgdJDQIgACgC7CkgBWohBiAMIAVrIQUgACgCtCohCiAAQYACaiEmIABBnCpqIRogACgCwAEgB0EEdGohHSANIAdrIRAgAEGYKmohOgJAAkACQAJAAkACQAJAAkACQAJAAkACQCBBKAIAQQFrDgoJAQIDBAUGBwgKAAtBlOLOAEEjQbjizgAQ7SwACyMAQTBrIgckACAaKAIAIREgBCAJaiIMIARBCGpLBEAgQUEEaiEXIAxBB2siIiAEIAlBB0sbIRlBASAlKAIYdEEQayEwQcAAQYAEICUoAhQiCUEJSBsiJ0ECdCEkICVBBGohHCAEICdqIQ4gDEEBayEeIAdBCGohGCAJQQVIISADQCAYQgA3AwAgGEEIakEANgIAIAdC5A83AwACfwJ/AkAgFyAGIAUgIyAKICYgBCAMIARrIg0gMCAEIAQgMEsbIAcQ7wgEQCAeIARrIQ1BACEJA0AgB0IANwIkIAdC5A83AxggByANIAcoAggiCEEBayISIA0gEkkbQQAgIBs2AiAgFyAGIAUgIyAKICYgBCAJaiISQQFqIgsgDSAwIAsgCyAwSxsiDiAHQRhqEO8IRQ0CIAcpAxggBykDAEKvAXxUDQIgB0EQaiAHQShqKQMANwMAIBggB0EgaikDADcDACAHIAcpAxg3AwAgEkEJaiAMSSAJQQJNcQRAIA1BAWshDSAJQQFqIQkMAQUgEkEBaiESIAcoAgghCCAJIBFqQQFqDAQLAAsACyAOIARBAWoiCU8EQCAJIQQgEUEBagwDCyAiIARBEWoiCEsEQCAOICRqIAlPBEBBACENA0AgFyAGIAUgIyAJIA1qENsaIA1BAmoiDUEIRw0ACyAEQQlqIQQgEUEJagwEC0EAIQ0DQCAXIAYgBSAjIAkgDWoQ2xogDUEEaiINQRBHDQALIAghBCARQRFqDAMLIAwhBCANIBFqDAILIDAgEiASIDBLGyEOIAkgEWoLIQ0CQAJ/AkAgBygCECIJIA5LDQBBACEEIAkgJigCACILRg0CQQEgJigCBCIEIAlGDQEaAkAgCUEDaiIRIAtrIgtBB08EQCARIARrIgRBB0kNAUECICYoAgggCUYNAxogCSAmKAIMRw0CQQMMAwtB6IjUywAgC0ECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgCUEPagsiBEUgCSAOS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgCTYCAAsgEEUNFCAIQQF0ICdqIBJqIQ4gHSAcIA0gCCAHKAIMIAhzIAQQgA0gOiA6KAIAIA1qNgIAAn8jAEEgayILJAACQAJAAkACQAJAIBkgCCASaiIEIAQgGUsbIi0iDSASQQJqIglBEGpPBEAgDSAJayIhQQRPBEAgIUECdiEqIBcoAgQhCCAXKAIAIREgCSENA0AgBSANICNxIhJJDSUgBSASa0EKTQ0HIAtCADcDCCALQQhqIhZBCCAGIBJqIhVBCEHU2c4AENUsIAsxAAwhYCALNQIIIWEgC0IANwMIIBZBCCAVQQFqQQhB1NnOABDVLCALMQAMIWIgCzUCCCFjIAtCADcDCCAWQQggFUECakEIQdTZzgAQ1SwgCzEADCFkIAs1AgghZSALQgA3AwggFkEIIBVBA2pBCEHU2c4AENUsIBJBA3ZBAXEiFiBgQjiGIGFCGIaEQr3P1vHR9+maHn5CMIinaiIVIAhPDQMgCzUCCCFgIAsxAAwhYSARIBVBAnRqIBI2AgAgFiBiQjiGIGNCGIaEQr3P1vHR9+maHn5CMIinaiIVIAhPDQQgESAVQQJ0aiASQQFqNgIAIBYgZEI4hiBlQhiGhEK9z9bx0ffpmh5+QjCIp2oiFSAITw0FIBEgFUECdGogEkECajYCACAWIGFCOIYgYEIYhoRCvc/W8dH36ZoefkIwiKdqIhYgCE8NBiARIBZBAnRqIBJBA2o2AgAgDUEEaiENICpBAWsiKg0ACwsgIUF8cSAJaiEJCyALQSBqJAAgCQwFCyAVIAhBlOHOABDDIQALIBUgCEGk4c4AEMMhAAsgFSAIQbThzgAQwyEACyAWIAhBxOHOABDDIQALDB4LIg0gLUkEQANAIBcgBiAFICMgDRDbGiAtIA1BAWoiDUcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQALIREgBEEIaiAMSQ0ACwsgGiAMIBFqIARrNgIAIA8gDygCACAUajYCACAHQTBqJAAMCQtBwNHRAEEAICUtAFUbIRlBACEwIwBBMGsiEiQAIBooAgAhDCAEIAlqIgsgBEEIaksEQCBBQQRqIREgC0EHayIcIAQgCUEHSxshJ0EBICUoAhh0QRBrIQ5BwABBgAQgJSgCFCIJQQlIGyItQQJ0IR4gJUEEaiEgIAQgLWohCCALQQFrISwgJSgCECEhIBJBCGohGCAJQQVIIS4DQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgESAZIAYgBSAjIAogJiAEIAsgBGsiCSAOIAQgBCAOSxsgISASELUIBEAgLCAEayEJQQAhBwNAIBJCADcCJCASQuQPNwMYIBIgCSASKAIIQQFrIg0gCSANSRtBACAuGzYCICARIBkgBiAFICMgCiAmIAQgB2oiDUEBaiIIIAkgDiAIIAggDksbICEgEkEYahC1CEUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIAdBAksgDUEJaiALT3JFBEAgCUEBayEJIAdBAWohBwwBCwsgDUEBaiENIAcgDGpBAWoMAgsgCCAEQQFqIgdPBEAgDEEBaiEMIAcMAwsgHCAEQRFqIg1LBEAgCCAeaiAHTwRAQQAhCQNAIBEgBiAFICMgByAJahDdGiAJQQJqIglBCEcNAAsgDEEJaiEMIARBCWoMBAtBACEJA0AgESAGIAUgIyAHIAlqEN0aIAlBBGoiCUEQRw0ACyAMQRFqIQwgDQwDCyAJIAxqIQwgCwwCCyAHIAxqCyEMIBIoAgghCQJAAn8CQCASKAIQIgQgDiANIA0gDksbIghLDQBBACEHIAQgJigCACIXRg0CQQEgJigCBCIHIARGDQEaAkAgBEEDaiIUIBdrIhdBB08EQCAUIAdrIgdBB0kNAUECICYoAgggBEYNAxogBCAmKAIMRw0CQQMMAwtB6IjUywAgF0ECdHZBD3EMAgtBzrXs/gAgB0ECdHZBD3EMAQsgBEEPagsiB0UgBCAIS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBDYCAAsgEEUNFCANIC1qIAlBAXRqIQggHSAgIAwgCSASKAIMIAlzIAcQgA0gOiA6KAIAIAxqNgIAAn8gJyASKAIIIA1qIgQgBCAnSxsiKiEJIwBBIGsiByQAAkACQAJAAkACQCANQQJqIgRBEGogCU0EQCAJIARrIiJBBE8EQCAiQQJ2ISQgESgCBCEMIBEoAgAhFCAEIQkDQCAFIAkgI3EiF0kNJiAFIBdrQQpNDQcgB0IANwMIIAdBCGoiFkEIIAYgF2oiFUEIQdTZzgAQ1SwgBzEADCFgIAc1AgghYSAHQgA3AwggFkEIIBVBAWpBCEHU2c4AENUsIAcxAAwhYiAHNQIIIWMgB0IANwMIIBZBCCAVQQJqQQhB1NnOABDVLCAHMQAMIWQgBzUCCCFlIAdCADcDCCAWQQggFUEDakEIQdTZzgAQ1SwgF0EDdkEDcSIWIGBCOIYgYUIYhoRCvc/W8dH36ZoefkIviKdqIhUgDE8NAyAHNQIIIWAgBzEADCFhIBQgFUECdGogFzYCACAWIGJCOIYgY0IYhoRCvc/W8dH36ZoefkIviKdqIhUgDE8NBCAUIBVBAnRqIBdBAWo2AgAgFiBkQjiGIGVCGIaEQr3P1vHR9+maHn5CL4inaiIVIAxPDQUgFCAVQQJ0aiAXQQJqNgIAIBYgYUI4hiBgQhiGhEK9z9bx0ffpmh5+Qi+Ip2oiFiAMTw0GIBQgFkECdGogF0EDajYCACAJQQRqIQkgJEEBayIkDQALCyAiQXxxIARqIQQLIAdBIGokACAEDAULIBUgDEGU4c4AEMMhAAsgFSAMQaThzgAQwyEACyAVIAxBtOHOABDDIQALIBYgDEHE4c4AEMMhAAsMHwsiCSAqSQRAA0AgESAGIAUgIyAJEN0aICogCUEBaiIJRw0ACwsgMEEBaiEwIBBBAWshECAdQRBqIR1BACEMIBIoAgggDWoLIgRBCGogC0kNAAsLIBogCyAMaiAEazYCACAPIA8oAgAgMGo2AgAgEkEwaiQADAgLIwBBMGsiByQAIBooAgAhESAEIAlqIgwgBEEIaksEQCBBQQRqIRcgDEEHayIiIAQgCUEHSxshFUEBICUoAhh0QRBrITBBwABBgAQgJSgCFCIJQQlIGyIZQQJ0ISQgJUEEaiEcIAQgGWohDiAMQQFrIR4gB0EIaiEYIAlBBUghIANAIBhCADcDACAYQQhqQQA2AgAgB0LkDzcDAAJ/An8CQCAXIAYgBSAjIAogJiAEIAwgBGsiDSAwIAQgBCAwSxsgBxDuCARAIB4gBGshDUEAIQkDQCAHQgA3AiQgB0LkDzcDGCAHIA0gBygCCCIIQQFrIhIgDSASSRtBACAgGzYCICAXIAYgBSAjIAogJiAEIAlqIhJBAWoiCyANIDAgCyALIDBLGyIOIAdBGGoQ7ghFDQIgBykDGCAHKQMAQq8BfFQNAiAHQRBqIAdBKGopAwA3AwAgGCAHQSBqKQMANwMAIAcgBykDGDcDACASQQlqIAxJIAlBAk1xBEAgDUEBayENIAlBAWohCQwBBSASQQFqIRIgBygCCCEIIAkgEWpBAWoMBAsACwALIA4gBEEBaiIJTwRAIAkhBCARQQFqDAMLICIgBEERaiIISwRAIA4gJGogCU8EQEEAIQ0DQCAXIAYgBSAjIAkgDWoQ3BogDUECaiINQQhHDQALIARBCWohBCARQQlqDAQLQQAhDQNAIBcgBiAFICMgCSANahDcGiANQQRqIg1BEEcNAAsgCCEEIBFBEWoMAwsgDCEEIA0gEWoMAgsgMCASIBIgMEsbIQ4gCSARagshDQJAAn8CQCAHKAIQIgkgDksNAEEAIQQgCSAmKAIAIgtGDQJBASAmKAIEIgQgCUYNARoCQCAJQQNqIhEgC2siC0EHTwRAIBEgBGsiBEEHSQ0BQQIgJigCCCAJRg0DGiAJICYoAgxHDQJBAwwDC0HoiNTLACALQQJ0dkEPcQwCC0HOtez+ACAEQQJ0dkEPcQwBCyAJQQ9qCyIERSAJIA5Lcg0AICYgJigCCDYCDCAmICYpAgA3AgQgJiAJNgIACyAQRQ0SIAhBAXQgGWogEmohDiAdIBwgDSAIIAcoAgwgCHMgBBCADSA6IDooAgAgDWo2AgACfyMAQSBrIgskAAJAAkACQAJAAkAgFSAIIBJqIgQgBCAVSxsiJyINIBJBAmoiCUEQak8EQCANIAlrIi1BBE8EQCAtQQJ2ISEgFygCBCEIIBcoAgAhESAJIQ0DQCAFIA0gI3EiEkkNIyAFIBJrQQpNDQcgBiASaiIWQQsQlhogFkEBakEKEJYaISwgFkECakEJEJYaIS4gFkEDakEIEJYaITggEkEDdkEDcSIWaiIqIAhPDQMgESAqQQJ0aiASNgIAIBYgLGoiKiAITw0EIBEgKkECdGogEkEBajYCACAWIC5qIiogCE8NBSARICpBAnRqIBJBAmo2AgAgFiA4aiIWIAhPDQYgESAWQQJ0aiASQQNqNgIAIA1BBGohDSAhQQFrIiENAAsLIC1BfHEgCWohCQsgC0EgaiQAIAkMBQsgKiAIQZThzgAQwyEACyAqIAhBpOHOABDDIQALICogCEG04c4AEMMhAAsgFiAIQcThzgAQwyEACwwcCyINICdJBEADQCAXIAYgBSAjIA0Q3BogJyANQQFqIg1HDQALCyAUQQFqIRQgEEEBayEQIB1BEGohHUEACyERIARBCGogDEkNAAsLIBogDCARaiAEazYCACAPIA8oAgAgFGo2AgAgB0EwaiQADAcLQcDR0QBBACAlLQBVGyEgIwBBMGsiEiQAIBooAgAhByAlKAIYIQ0gJSgCFCEIICYgQUEEaiIMKAIgEPUNIAQgCWoiMCAEQQRqSwRAIDBBA2sgBCAJQQNLGyEsQQEgDXRBEGshDkHAAEGABCAIQQlIGyIuQQJ0ITMgMEEEayEoICVBBGohEyAEIC5qIQ0gMEEBayE1ICUoAhAhOCASQQhqIScgCEEFSCE0A0AgJ0IANwMAICdBCGpBADYCACASQuQPNwMAAn8CfwJAIAwgICAGIAUgIyAKICYgBCAwIARrIgggDiAEIAQgDksbIDggEhDPBQRAIDUgBGshDUEAIREDQCASQgA3AiQgEkLkDzcDGCASIA0gEigCCEEBayIJIAkgDUsbQQAgNBs2AiAgDCAgIAYgBSAjIAogJiAEIBFqIglBAWoiCCANIA4gCCAIIA5LGyA4IBJBGGoQzwVFDQIgEikDGCASKQMAQq8BfFQNAiASQRBqIBJBKGopAwA3AwAgJyASQSBqKQMANwMAIBIgEikDGDcDACARQQJLIAlBBWogME9yRQRAIA1BAWshDSARQQFqIREMAQsLIAlBAWohCSAHIBFqQQFqDAILIA0gBEEBaiIJTwRAIAdBAWohByAJDAMLICggBEERaiIfSwRAIA0gM2ogCU8EQAJAAkACQAJAAkACQAJAAkACQAJAIAUgCSAjcSIRSwRAIBFBAWoiCCAFTw0sIBFBAmoiCyAFTw0tIBFBA2oiFCAFTw0BIBFBBGoiFSAFTw0uIBFBBWoiGSAFTw0vIBFBBmoiLSAFTw0CIBFBB2oiISAFTw0DIAlBCGogI3EiFyAFTw0EIBdBAWoiKiAFTw0FIAwoAgQiFiAGIBFqMQAAIAYgCGoxAABCCIaEIAYgC2oxAABCEIaEIAYgFGoxAABCGIaEImFCvc/W8QF+Qv////8PgyAMKAI0QT9xrSJgiKciC00NJCAMKAIMIREgDCgCCCEIIAYgFWoxAAAhYiAGIBlqMQAAIWMgBiAhajEAACFkIAYgLWoxAAAhZSAGICpqMQAAIWYgBiAXajEAACFnIAwoAgAiFCALQQF0aiIXIBcvAQAiIUEBajsBACAWIGJCIIYgY0IohoQgYYQiYUIQiEK9z9bxAX5C/////w+DIGCIpyIVTQ0wIAwoAjwhFyAUIBVBAXRqIhkgGS8BACIqQQFqOwEAIBYgZUIwhiBkQjiGhCBhhCJhQiCIQr3P1vEBfkL/////D4MgYIinIhlNDTEgFCAZQQF0aiItIC0vAQAiIkEBajsBACAWIGdCEIYgZkIYhoQgYUIwiIRCvc/W8QF+Qv////8PgyBgiKciLU0NBiAUIC1BAXRqIhQgFC8BACIWQQFqOwEAIBcgIXEgCyAMKAJAIgt0aiIUIBFPDQcgCCAUQQJ0aiAJNgIAIBcgKnEgFSALdGoiFCARTw0IIAggFEECdGogCUECajYCACAXICJxIBkgC3RqIhQgEU8NCSAIIBRBAnRqIAlBBGo2AgAgFiAXcSAtIAt0aiIWIBFJDQoMIgsMIgsgFCAFQeDRzgAQwyEACyAtIAVBkNLOABDDIQALICEgBUGg0s4AEMMhAAsgFyAFQbDSzgAQwyEACyAqIAVBwNLOABDDIQALIC0gFkGA084AEMMhAAsgFCARQZDTzgAQwyEACyAUIBFBoNPOABDDIQALIBQgEUGw084AEMMhAAsgCCAWQQJ0aiAJQQZqNgIAIAdBCWohByAEQQlqDAQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIgRLBEAgBEEBaiILIAVPDQEgBEECaiIXIAVPDQIgBEEDaiIUIAVPDQMgBEEEaiIWIAVPDTcgBEEFaiIVIAVPDTggBEEGaiIZIAVPDTkgBEEHaiItIAVPDQQgCUEIaiJHICNxIhEgBU8NLCARQQFqIiEgBU8NBSARQQJqIiogBU8NBiARQQNqIiIgBU8NByARQQRqIiQgBU8NCCARQQVqIhwgBU8NCSARQQZqIh4gBU8NCiARQQdqIkUgBU8NCyAMKAIEIgggBCAGajEAACAGIAtqMQAAQgiGhCAGIBdqMQAAQhCGhCAGIBRqMQAAQhiGhEK9z9bxAX5C/////w+DIAwoAjRBP3GtImCIpyIXTQ0MIAwoAgwhBCAMKAIIIQsgBiAWajEAACFhIAYgFWoxAAAhYiAGIBlqMQAAIWMgBiAtajEAACFkIAYgEWoxAAAhZSAGICFqMQAAIWYgBiAqajEAACFnIAYgImoxAAAhaCAGICRqMQAAIWkgBiAcajEAACFqIAYgHmoxAAAhayAGIEVqMQAAIWwgDCgCACIUIBdBAXRqIhEgES8BACItQQFqOwEAIAggYSBiQgiGhCBjQhCGhCBkQhiGhEK9z9bxAX5C/////w+DIGCIpyIWTQ06IAwoAjwhESAUIBZBAXRqIhUgFS8BACIhQQFqOwEAIAggZkIIhiBlhCBnQhCGhCBoQhiGhEK9z9bxAX5C/////w+DIGCIpyIVTQ07IBQgFUEBdGoiGSAZLwEAIipBAWo7AQAgCCBqQgiGIGmEIGtCEIaEIGxCGIaEQr3P1vEBfkL/////D4MgYIinIhlNDTwgFCAZQQF0aiIIIAgvAQAiFEEBajsBACARIC1xIBcgDCgCQCIIdGoiFyAETw0NIAsgF0ECdGogCTYCACARICFxIBYgCHRqIhcgBE8NDiALIBdBAnRqIAlBBGo2AgAgESAqcSAVIAh0aiIXIARPDQ8gCyAXQQJ0aiBHNgIAIBEgFHEgGSAIdGoiESAESQ0QDCoLDCoLIAsgBUHAzs4AEMMhAAsgFyAFQdDOzgAQwyEACyAUIAVB4M7OABDDIQALIC0gBUGgz84AEMMhAAsgISAFQcDPzgAQwyEACyAqIAVB0M/OABDDIQALICIgBUHgz84AEMMhAAsgJCAFQfDPzgAQwyEACyAcIAVBgNDOABDDIQALIB4gBUGQ0M4AEMMhAAsgRSAFQaDQzgAQwyEACyAXIAhBsNDOABDDIQALIBcgBEHw0M4AEMMhAAsgFyAEQYDRzgAQwyEACyAXIARBkNHOABDDIQALIAsgEUECdGogCUEMajYCACAHQRFqIQcgHwwDCyAHIAhqIQcgMAwCCyAHIBFqCyEIIBIoAgghDQJAAn8CQCASKAIQIgcgDiAJIAkgDksbIgtLDQBBACEEIAcgJigCACIRRg0CQQEgJigCBCIEIAdGDQEaAkAgB0EDaiIXIBFrIhFBB08EQCAXIARrIgRBB0kNAUECICYoAgggB0YNAxogByAmKAIMRw0CQQMMAwtB6IjUywAgEUECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgB0EPagsiBEUgByALS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBzYCACAmIAwoAiAQ9Q0LIBBFDRIgCSAuaiANQQF0aiENIB0gEyAIIBIoAggiByAHIBIoAgxzIAQQgA0gOiA6KAIAIAhqNgIAAn8gLCASKAIIIAlqIgQgBCAsSxsiRSEHIwBBMGsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCUECaiIEQQhqIAdNBEAgCCAMKAIEIgs2AgggCCAMKAI4IhE2AgwgCyARRw07IAwoAgwhESAMKAIIIRQgDCgCACEWIAggCyAMKAJAIhd0IhU2AhQgCCARNgIQIBEgFUcNECAHIARrIh9BBE8EQCAXQR9xIRUgH0ECdiFHIAw1AjRCP4MhYCAMKAI8IRkgBCEHA0AgByAjcSIXIAVPDQMgF0EBaiItIAVPDQQgF0ECaiIhIAVPDQUgF0EDaiIqIAVPDQYgF0EEaiIkIAVPDQcgF0EFaiIcIAVPDQggF0EGaiIeIAVPDQkgCyAGIBdqMQAAIAYgLWoxAABCCIaEIAYgIWoxAABCEIaEIAYgKmoxAABCGIaEImFCvc/W8QF+Qv////8PgyBgiKciIk0NCiAGICRqMQAAIWIgBiAeajEAACFjIAYgHGoxAAAhZCAWICJBAXRqIiQgJC8BACI2QQFqOwEAIAsgYkIghiBhhCJhQgiIQr3P1vEBfkL/////D4MgYIinIiRNDQsgFiAkQQF0aiIcIBwvAQAiKUEBajsBACALIGRCKIYgY0IwhoQgYYQiYUIQiEK9z9bxAX5C/////w+DIGCIpyIcTQ0MIBYgHEEBdGoiHiAeLwEAIjFBAWo7AQAgCyBhQhiIQr3P1vEBfkL/////D4MgYIinIh5NDQ0gFiAeQQF0aiIvIC8vAQAiL0EBajsBACAZIDZxICIgFXRqIiIgEU8NDiAUICJBAnRqIBc2AgAgGSApcSAkIBV0aiIXIBFPDQ8gFCAXQQJ0aiAtNgIAIBkgMXEgHCAVdGoiFyARTw0QIBQgF0ECdGogITYCACAZIC9xIB4gFXRqIhcgEU8NESAUIBdBAnRqICo2AgAgB0EEaiEHIEdBAWsiRw0ACwsgH0F8cSAEaiEECyAIQTBqJAAgBAwQCyAXIAVB6OLOABDDIQALIC0gBUH44s4AEMMhAAsgISAFQYjjzgAQwyEACyAqIAVBmOPOABDDIQALICQgBUGo484AEMMhAAsgHCAFQbjjzgAQwyEACyAeIAVByOPOABDDIQALICIgC0HY484AEMMhAAsgJCALQejjzgAQwyEACyAcIAtB+OPOABDDIQALIB4gC0GI5M4AEMMhAAsgIiARQZjkzgAQwyEACyAXIBFBqOTOABDDIQALIBcgEUG45M4AEMMhAAsgFyARQcjkzgAQwyEACwwrCyIEIEVJBEADQCAMIAYgBSAjIAQQ1hMgRSAEQQFqIgRHDQALCyAYQQFqIRggEEEBayEQIB1BEGohHUEAIQcgEigCCCAJagsiBEEEaiAwSQ0ACwsgGiAHIDBqIARrNgIAIA8gDygCACAYajYCACASQTBqJAAMBgtBwNHRAEEAICUtAFUbIS0jAEEwayISJAAgGigCACEHICUoAhghDSAlKAIUIQggJiBBQQRqIgwoAiAQ9Q0gBCAJaiIXIARBBGpLBEAgF0EDayAEIAlBA0sbISFBASANdEEQayEwQcAAQYAEIAhBCUgbIipBAnQhRSAXQQRrIR8gJUEEaiFHIAQgKmohDSAXQQFrITMgJSgCECEiIBJBCGohGCAIQQVIISgDQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgDCAtIAYgBSAjIAogJiAEIBcgBGsiCCAwIAQgBCAwSxsgIiASEKsGBEAgMyAEayENQQAhEQNAIBJCADcCJCASQuQPNwMYIBIgDSASKAIIQQFrIgkgCSANSxtBACAoGzYCICAMIC0gBiAFICMgCiAmIAQgEWoiCUEBaiIIIA0gMCAIIAggMEsbICIgEkEYahCrBkUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIBFBAksgCUEFaiAXT3JFBEAgDUEBayENIBFBAWohEQwBCwsgCUEBaiEJIAcgEWpBAWoMAgsgDSAEQQFqIglPBEAgB0EBaiEHIAkMAwsgHyAEQRFqIhNLBEAgDSBFaiAJTwRAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIhFLBEAgEUEBaiIIIAVPDSsgEUECaiILIAVPDSwgEUEDaiIWIAVPDQEgEUEEaiIVIAVPDS0gEUEFaiIZIAVPDS4gEUEGaiInIAVPDQIgEUEHaiIkIAVPDQMgCUEIaiAjcSIOIAVPDQQgDkEBaiIcIAVPDQUgBiARajEAACAGIAhqMQAAQgiGhCAGIAtqMQAAQhCGhCAGIBZqMQAAQhiGhCJgp0G9z9bxAWxBEXYiCyAMKAIEIhZPDSMgDCgCDCERIAwoAgghCCAGIBVqMQAAIAYgGWoxAAAhYiAGICRqMQAAIWMgBiAnajEAACFkIAYgDmoxAAAhZSAGIBxqMQAAIWYgDCgCACIOIAtBAXRqIhUgFS8BACIkQQFqOwEAQiCGIGJCKIaEIGCEImBCEIinQb3P1vEBbEERdiIVIBZPDS8gDiAVQQF0aiIZIBkvAQAiHEEBajsBACBkQjCGIGNCOIaEIGCEImBCIIinQb3P1vEBbEERdiIZIBZPDTAgDiAZQQF0aiInICcvAQAiHkEBajsBACBlQhCGIGBCMIiEIGZCGIaEp0G9z9bxAWxBEXYiJyAWTw0GIA4gJ0EBdGoiDiAOLwEAIg5BAWo7AQAgJEE/cSALQQZ0ciILIBFPDQcgCCALQQJ0aiAJNgIAIBxBP3EgFUEGdHIiCyARTw0IIAggC0ECdGogCUECajYCACAeQT9xIBlBBnRyIgsgEU8NCSAIIAtBAnRqIAlBBGo2AgAgDkE/cSAnQQZ0ciIWIBFJDQoMIQsMIQsgFiAFQeDRzgAQwyEACyAnIAVBkNLOABDDIQALICQgBUGg0s4AEMMhAAsgDiAFQbDSzgAQwyEACyAcIAVBwNLOABDDIQALICcgFkGA084AEMMhAAsgCyARQZDTzgAQwyEACyALIBFBoNPOABDDIQALIAsgEUGw084AEMMhAAsgCCAWQQJ0aiAJQQZqNgIAIAdBCWohByAEQQlqDAQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIgRLBEAgBEEBaiIIIAVPDQEgBEECaiILIAVPDQIgBEEDaiIOIAVPDQMgBEEEaiIWIAVPDTYgBEEFaiIVIAVPDTcgBEEGaiIZIAVPDTggBEEHaiInIAVPDQQgCUEIaiI1ICNxIhEgBU8NKyARQQFqIiQgBU8NBSARQQJqIhwgBU8NBiARQQNqIh4gBU8NByARQQRqIiAgBU8NCCARQQVqIiwgBU8NCSARQQZqIi4gBU8NCiARQQdqIjggBU8NCyAEIAZqLQAAIAYgCGotAABBCHRyIAYgC2otAABBEHRyIAYgDmotAABBGHRyQb3P1vEBbEERdiIOIAwoAgQiCE8NDCAMKAIMIQQgDCgCCCELIAYgFmotAAAgBiAVai0AACAGIBlqLQAAIRkgBiAnai0AACEnIAYgEWotAAAhNCAGICRqLQAAISQgBiAcai0AACEcIAYgHmotAAAhHiAGICBqLQAAISAgBiAsai0AACEsIAYgLmotAAAhLiAGIDhqLQAAITggDCgCACIRIA5BAXRqIjYgNi8BACI2QQFqOwEAQQh0ciAZQRB0ciAnQRh0ckG9z9bxAWxBEXYiFiAITw05IBEgFkEBdGoiFSAVLwEAIidBAWo7AQAgJEEIdCA0ciAcQRB0ciAeQRh0ckG9z9bxAWxBEXYiFSAITw06IBEgFUEBdGoiGSAZLwEAIiRBAWo7AQAgLEEIdCAgciAuQRB0ciA4QRh0ckG9z9bxAWxBEXYiGSAITw07IBEgGUEBdGoiCCAILwEAIhFBAWo7AQAgNkE/cSAOQQZ0ciIIIARPDQ0gCyAIQQJ0aiAJNgIAICdBP3EgFkEGdHIiCCAETw0OIAsgCEECdGogCUEEajYCACAkQT9xIBVBBnRyIgggBE8NDyALIAhBAnRqIDU2AgAgEUE/cSAZQQZ0ciIRIARJDRAMKQsMKQsgCCAFQcDOzgAQwyEACyALIAVB0M7OABDDIQALIA4gBUHgzs4AEMMhAAsgJyAFQaDPzgAQwyEACyAkIAVBwM/OABDDIQALIBwgBUHQz84AEMMhAAsgHiAFQeDPzgAQwyEACyAgIAVB8M/OABDDIQALICwgBUGA0M4AEMMhAAsgLiAFQZDQzgAQwyEACyA4IAVBoNDOABDDIQALIA4gCEGw0M4AEMMhAAsgCCAEQfDQzgAQwyEACyAIIARBgNHOABDDIQALIAggBEGQ0c4AEMMhAAsgCyARQQJ0aiAJQQxqNgIAIAdBEWohByATDAMLIAcgCGohByAXDAILIAcgEWoLIQggEigCCCENAkACfwJAIBIoAhAiByAwIAkgCSAwSxsiC0sNAEEAIQQgByAmKAIAIhFGDQJBASAmKAIEIgQgB0YNARoCQCAHQQNqIg4gEWsiEUEHTwRAIA4gBGsiBEEHSQ0BQQIgJigCCCAHRg0DGiAHICYoAgxHDQJBAwwDC0HoiNTLACARQQJ0dkEPcQwCC0HOtez+ACAEQQJ0dkEPcQwBCyAHQQ9qCyIERSAHIAtLcg0AICYgJigCCDYCDCAmICYpAgA3AgQgJiAHNgIAICYgDCgCIBD1DQsgEEUNESAJICpqIA1BAXRqIQ0gHSBHIAggEigCCCIHIAcgEigCDHMgBBCADSA6IDooAgAgCGo2AgACfyAhIBIoAgggCWoiBCAEICFLGyInIQcjAEEwayIIJAACQAJAAkACQAJAAkACQCAJQQJqIgRBCGogB00EQCAIIAwoAgQiCzYCCCAIQYCAAjYCDCALQYCAAkcNMSAMKAIIIREgDCgCACEOIAggDCgCDCILNgIQIAhBgICAATYCFCALQYCAgAFHDTIgByAEayIkQQRPBEAgJEECdiEcIAQhBwNAIAcgI3EiCyAFTw0DIAtBAWoiFiAFTw0EIAtBAmoiFSAFTw0FIAtBA2oiGSAFTw0GIAtBBGoiHiAFTw0HIAtBBWoiICAFTw0IIAtBBmoiLCAFTw0JIAYgHmoxAAAhYCAOIAYgC2oxAAAgBiAWajEAAEIIhoQgBiAVajEAAEIQhoQgBiAZajEAAEIYhoQiYadBvc/W8QFsQRF2Ih5BAXRqIi4gLi8BACIuQQFqOwEAIA4gYEIghiBhhCJgQgiIp0G9z9bxAWxBEXYiOEEBdGoiEyATLwEAIhNBAWo7AQAgDiAGICBqMQAAQiiGIAYgLGoxAABCMIaEIGCEImBCEIinQb3P1vEBbEERdiIgQQF0aiIsICwvAQAiLEEBajsBACAOIGBCGIinQb3P1vEBbEERdiI1QQF0aiI0IDQvAQAiNEEBajsBACARIB5BCHQgLkE/cUECdHJqIAs2AgAgESA4QQh0IBNBP3FBAnRyaiAWNgIAIBEgIEEIdCAsQT9xQQJ0cmogFTYCACARIDVBCHQgNEE/cUECdHJqIBk2AgAgB0EEaiEHIBxBAWsiHA0ACwsgJEF8cSAEaiEECyAIQTBqJAAgBAwHCyALIAVB6OLOABDDIQALIBYgBUH44s4AEMMhAAsgFSAFQYjjzgAQwyEACyAZIAVBmOPOABDDIQALIB4gBUGo484AEMMhAAsgICAFQbjjzgAQwyEACyAsIAVByOPOABDDIQALIgQgJ0kEQANAIAwgBiAFICMgBBDZFiAnIARBAWoiBEcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQAhByASKAIIIAlqCyIEQQRqIBdJDQALCyAaIAcgF2ogBGs2AgAgDyAPKAIAIBRqNgIAIBJBMGokAAwFC0HA0dEAQQAgJS0AVRshLSMAQTBrIhIkACAaKAIAIQcgJSgCGCENICUoAhQhCCAmIEFBBGoiDCgCIBD1DSAEIAlqIhcgBEEEaksEQCAXQQNrIAQgCUEDSxshIUEBIA10QRBrITBBwABBgAQgCEEJSBsiKkECdCFFIBdBBGshHyAlQQRqIUcgBCAqaiENIBdBAWshMyAlKAIQISIgEkEIaiEYIAhBBUghKANAIBhCADcDACAYQQhqQQA2AgAgEkLkDzcDAAJ/An8CQCAMIC0gBiAFICMgCiAmIAQgFyAEayIIIDAgBCAEIDBLGyAiIBIQrAYEQCAzIARrIQ1BACERA0AgEkIANwIkIBJC5A83AxggEiANIBIoAghBAWsiCSAJIA1LG0EAICgbNgIgIAwgLSAGIAUgIyAKICYgBCARaiIJQQFqIgggDSAwIAggCCAwSxsgIiASQRhqEKwGRQ0CIBIpAxggEikDAEKvAXxUDQIgEkEQaiASQShqKQMANwMAIBggEkEgaikDADcDACASIBIpAxg3AwAgEUECSyAJQQVqIBdPckUEQCANQQFrIQ0gEUEBaiERDAELCyAJQQFqIQkgByARakEBagwCCyANIARBAWoiCU8EQCAHQQFqIQcgCQwDCyAfIARBEWoiE0sEQCANIEVqIAlPBEACQAJAAkACQAJAAkACQAJAAkACQCAFIAkgI3EiEUsEQCARQQFqIgggBU8NKiARQQJqIgsgBU8NKyARQQNqIhYgBU8NASARQQRqIhUgBU8NLCARQQVqIhkgBU8NLSARQQZqIicgBU8NAiARQQdqIiQgBU8NAyAJQQhqICNxIg4gBU8NBCAOQQFqIhwgBU8NBSAGIBFqMQAAIAYgCGoxAABCCIaEIAYgC2oxAABCEIaEIAYgFmoxAABCGIaEImCnQb3P1vEBbEESdiILIAwoAgQiFk8NIiAMKAIMIREgDCgCCCEIIAYgFWoxAAAgBiAZajEAACFiIAYgJGoxAAAhYyAGICdqMQAAIWQgBiAOajEAACFlIAYgHGoxAAAhZiAMKAIAIg4gC0EBdGoiFSAVLwEAIiRBAWo7AQBCIIYgYkIohoQgYIQiYEIQiKdBvc/W8QFsQRJ2IhUgFk8NLiAOIBVBAXRqIhkgGS8BACIcQQFqOwEAIGRCMIYgY0I4hoQgYIQiYEIgiKdBvc/W8QFsQRJ2IhkgFk8NLyAOIBlBAXRqIicgJy8BACIeQQFqOwEAIGVCEIYgYEIwiIQgZkIYhoSnQb3P1vEBbEESdiInIBZPDQYgDiAnQQF0aiIOIA4vAQAiDkEBajsBACAkQQ9xIAtBBHRyIgsgEU8NByAIIAtBAnRqIAk2AgAgHEEPcSAVQQR0ciILIBFPDQggCCALQQJ0aiAJQQJqNgIAIB5BD3EgGUEEdHIiCyARTw0JIAggC0ECdGogCUEEajYCACAOQQ9xICdBBHRyIhYgEUkNCgwgCwwgCyAWIAVB4NHOABDDIQALICcgBUGQ0s4AEMMhAAsgJCAFQaDSzgAQwyEACyAOIAVBsNLOABDDIQALIBwgBUHA0s4AEMMhAAsgJyAWQYDTzgAQwyEACyALIBFBkNPOABDDIQALIAsgEUGg084AEMMhAAsgCyARQbDTzgAQwyEACyAIIBZBAnRqIAlBBmo2AgAgB0EJaiEHIARBCWoMBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFIAkgI3EiBEsEQCAEQQFqIgggBU8NASAEQQJqIgsgBU8NAiAEQQNqIg4gBU8NAyAEQQRqIhYgBU8NNSAEQQVqIhUgBU8NNiAEQQZqIhkgBU8NNyAEQQdqIicgBU8NBCAJQQhqIjUgI3EiESAFTw0qIBFBAWoiJCAFTw0FIBFBAmoiHCAFTw0GIBFBA2oiHiAFTw0HIBFBBGoiICAFTw0IIBFBBWoiLCAFTw0JIBFBBmoiLiAFTw0KIBFBB2oiOCAFTw0LIAQgBmotAAAgBiAIai0AAEEIdHIgBiALai0AAEEQdHIgBiAOai0AAEEYdHJBvc/W8QFsQRJ2Ig4gDCgCBCIITw0MIAwoAgwhBCAMKAIIIQsgBiAWai0AACAGIBVqLQAAIAYgGWotAAAhGSAGICdqLQAAIScgBiARai0AACE0IAYgJGotAAAhJCAGIBxqLQAAIRwgBiAeai0AACEeIAYgIGotAAAhICAGICxqLQAAISwgBiAuai0AACEuIAYgOGotAAAhOCAMKAIAIhEgDkEBdGoiNiA2LwEAIjZBAWo7AQBBCHRyIBlBEHRyICdBGHRyQb3P1vEBbEESdiIWIAhPDTggESAWQQF0aiIVIBUvAQAiJ0EBajsBACAkQQh0IDRyIBxBEHRyIB5BGHRyQb3P1vEBbEESdiIVIAhPDTkgESAVQQF0aiIZIBkvAQAiJEEBajsBACAsQQh0ICByIC5BEHRyIDhBGHRyQb3P1vEBbEESdiIZIAhPDTogESAZQQF0aiIIIAgvAQAiEUEBajsBACA2QQ9xIA5BBHRyIgggBE8NDSALIAhBAnRqIAk2AgAgJ0EPcSAWQQR0ciIIIARPDQ4gCyAIQQJ0aiAJQQRqNgIAICRBD3EgFUEEdHIiCCAETw0PIAsgCEECdGogNTYCACARQQ9xIBlBBHRyIhEgBEkNEAwoCwwoCyAIIAVBwM7OABDDIQALIAsgBUHQzs4AEMMhAAsgDiAFQeDOzgAQwyEACyAnIAVBoM/OABDDIQALICQgBUHAz84AEMMhAAsgHCAFQdDPzgAQwyEACyAeIAVB4M/OABDDIQALICAgBUHwz84AEMMhAAsgLCAFQYDQzgAQwyEACyAuIAVBkNDOABDDIQALIDggBUGg0M4AEMMhAAsgDiAIQbDQzgAQwyEACyAIIARB8NDOABDDIQALIAggBEGA0c4AEMMhAAsgCCAEQZDRzgAQwyEACyALIBFBAnRqIAlBDGo2AgAgB0ERaiEHIBMMAwsgByAIaiEHIBcMAgsgByARagshCCASKAIIIQ0CQAJ/AkAgEigCECIHIDAgCSAJIDBLGyILSw0AQQAhBCAHICYoAgAiEUYNAkEBICYoAgQiBCAHRg0BGgJAIAdBA2oiDiARayIRQQdPBEAgDiAEayIEQQdJDQFBAiAmKAIIIAdGDQMaIAcgJigCDEcNAkEDDAMLQeiI1MsAIBFBAnR2QQ9xDAILQc617P4AIARBAnR2QQ9xDAELIAdBD2oLIgRFIAcgC0tyDQAgJiAmKAIINgIMICYgJikCADcCBCAmIAc2AgAgJiAMKAIgEPUNCyAQRQ0QIAkgKmogDUEBdGohDSAdIEcgCCASKAIIIgcgByASKAIMcyAEEIANIDogOigCACAIajYCAAJ/ICEgEigCCCAJaiIEIAQgIUsbIichByMAQTBrIggkAAJAAkACQAJAAkACQAJAIAlBAmoiBEEIaiAHTQRAIAggDCgCBCILNgIIIAhBgIABNgIMIAtBgIABRw0wIAwoAgghESAMKAIAIQ4gCCAMKAIMIgs2AhAgCEGAgBA2AhQgC0GAgBBHDTEgByAEayIkQQRPBEAgJEECdiEcIAQhBwNAIAcgI3EiCyAFTw0DIAtBAWoiFiAFTw0EIAtBAmoiFSAFTw0FIAtBA2oiGSAFTw0GIAtBBGoiHiAFTw0HIAtBBWoiICAFTw0IIAtBBmoiLCAFTw0JIAYgHmoxAAAhYCAOIAYgC2oxAAAgBiAWajEAAEIIhoQgBiAVajEAAEIQhoQgBiAZajEAAEIYhoQiYadBvc/W8QFsQRJ2Ih5BAXRqIi4gLi8BACIuQQFqOwEAIA4gYEIghiBhhCJgQgiIp0G9z9bxAWxBEnYiOEEBdGoiEyATLwEAIhNBAWo7AQAgDiAGICBqMQAAQiiGIAYgLGoxAABCMIaEIGCEImBCEIinQb3P1vEBbEESdiIgQQF0aiIsICwvAQAiLEEBajsBACAOIGBCGIinQb3P1vEBbEESdiI1QQF0aiI0IDQvAQAiNEEBajsBACARIB5BBnQgLkEPcUECdHJqIAs2AgAgESA4QQZ0IBNBD3FBAnRyaiAWNgIAIBEgIEEGdCAsQQ9xQQJ0cmogFTYCACARIDVBBnQgNEEPcUECdHJqIBk2AgAgB0EEaiEHIBxBAWsiHA0ACwsgJEF8cSAEaiEECyAIQTBqJAAgBAwHCyALIAVB6OLOABDDIQALIBYgBUH44s4AEMMhAAsgFSAFQYjjzgAQwyEACyAZIAVBmOPOABDDIQALIB4gBUGo484AEMMhAAsgICAFQbjjzgAQwyEACyAsIAVByOPOABDDIQALIgQgJ0kEQANAIAwgBiAFICMgBBDaFiAnIARBAWoiBEcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQAhByASKAIIIAlqCyIEQQRqIBdJDQALCyAaIAcgF2ogBGs2AgAgDyAPKAIAIBRqNgIAIBJBMGokAAwEC0HA0dEAQQAgJS0AVRshFEEAITAjAEEwayIHJAAgGigCACERICUoAhghCCAlKAIUIQ0gJiBBQQhqIgsoAjgQ9Q0gBCAJaiIMIARBCGpLBEAgDEEHayIZIAQgCUEHSxshGEEBIAh0QRBrIRdBwABBgAQgDUEJSBsiFkECdCEnICVBBGohLSAEIBZqIQggDEEBayEhICUoAhAhFSAHQQhqIQ4gDUEFSCEqA0AgDkIANwMAIA5BCGpBADYCACAHQuQPNwMAAkACfwJAIAsgFCAGIAUgIyAKICYgBCAMIARrIg0gFyAEIAQgF0sbIBUgBxDzBQRAICEgBGshDUEAIQkDQCAHQgA3AiQgB0LkDzcDGCAHIA0gBygCCEEBayIIIAggDUsbQQAgKhs2AiAgCyAUIAYgBSAjIAogJiAEIAlqIhJBAWoiCCANIBcgCCAIIBdLGyAVIAdBGGoQ8wVFDQIgBykDGCAHKQMAQq8BfFQNAiAHQRBqIAdBKGopAwA3AwAgDiAHQSBqKQMANwMAIAcgBykDGDcDACAJQQJLIBJBCWogDE9yRQRAIA1BAWshDSAJQQFqIQkMAQsLIBJBAWohEiAJIBFqQQFqDAILIAggBEEBaiIJTwRAIBFBAWohESAJIQQMAwsgGSAEQRFqIhJLBEAgCCAnaiAJTwRAQQAhDQNAIAsgBiAFICMgCSANahCQFiANQQJqIg1BCEcNAAsgBEEJaiEEIBFBCWohEQwEC0EAIQ0DQCALIAYgBSAjIAkgDWoQkBYgDUEEaiINQRBHDQALIBFBEWohESASIQQMAwsgDSARaiERIAwhBAwCCyAJIBFqCyENIAcoAgghCAJAAn8CQCAHKAIQIgkgFyASIBIgF0sbIhFLDQBBACEEIAkgJigCACIiRg0CQQEgJigCBCIEIAlGDQEaAkAgCUEDaiIkICJrIiJBB08EQCAkIARrIgRBB0kNAUECICYoAgggCUYNAxogCSAmKAIMRw0CQQMMAwtB6IjUywAgIkECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgCUEPagsiBEUgCSARS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgCTYCACAmIAsoAjgQ9Q0LIBBFDQ4gEiAWaiAIQQF0aiEIIB0gLSANIAcoAggiCSAJIAcoAgxzIAQQgA0gOiA6KAIAIA1qNgIAIDBBAWohMCAQQQFrIRAgHUEQaiEdQQAhESASQQJqIg0gGCAHKAIIIBJqIgQgBCAYSxsiCU8NAANAIAsgBiAFICMgDRCQFiAJIA1BAWoiDUcNAAsgBygCCCASaiEECyAEQQhqIAxJDQALCyAaIAwgEWogBGs2AgAgDyAPKAIAIDBqNgIAIAdBMGokAAwDC0HA0dEAQQAgJS0AVRshFEEAITAjAEEwayIHJAAgGigCACERICUoAhghCCAlKAIUIQ0gJkEQEPUNIAQgCWoiDCAEQQRqSwRAIEFBBGohFyAMQQNrIAQgCUEDSxshGEEBIAh0QRBrIQtBwABBgAQgDUEJSBsiFkECdCEZIAxBBGshJyAlQQRqIS0gBCAWaiEIIAxBAWshISAlKAIQIRUgB0EIaiEOIA1BBUghKgNAIA5CADcDACAOQQhqQQA2AgAgB0LkDzcDAAJAAn8CQCAXIBQgBiAFICMgCiAmIAQgDCAEayINIAsgBCAEIAtLGyAVIAcQuwQEQCAhIARrIQ1BACEJA0AgB0IANwIkIAdC5A83AxggByANIAcoAghBAWsiCCAIIA1LG0EAICobNgIgIBcgFCAGIAUgIyAKICYgBCAJaiISQQFqIgggDSALIAggCCALSxsgFSAHQRhqELsERQ0CIAcpAxggBykDAEKvAXxUDQIgB0EQaiAHQShqKQMANwMAIA4gB0EgaikDADcDACAHIAcpAxg3AwAgCUECSyASQQVqIAxPckUEQCANQQFrIQ0gCUEBaiEJDAELCyASQQFqIRIgCSARakEBagwCCyAIIARBAWoiCU8EQCARQQFqIREgCSEEDAMLICcgBEERaiISSwRAIAggGWogCU8EQEEAIQ0DQCAXIAYgBSAjIAkgDWoQiRMgDUECaiINQQhHDQALIARBCWohBCARQQlqIREMBAtBACENA0AgFyAGIAUgIyAJIA1qEIkTIA1BBGoiDUEQRw0ACyARQRFqIREgEiEEDAMLIA0gEWohESAMIQQMAgsgCSARagshDSAHKAIIIQgCQAJ/AkAgBygCECIJIAsgEiALIBJJGyIRSw0AQQAhBCAJICYoAgAiIkYNAkEBICYoAgQiBCAJRg0BGgJAIAlBA2oiJCAiayIiQQdPBEAgJCAEayIEQQdJDQFBAiAmKAIIIAlGDQMaIAkgJigCDEcNAkEDDAMLQeiI1MsAICJBAnR2QQ9xDAILQc617P4AIARBAnR2QQ9xDAELIAlBD2oLIgRFIAkgEUtyDQAgJiAmKAIINgIMICYgJikCADcCBCAmIAk2AgAgJkEQEPUNCyAQRQ0NIBIgFmogCEEBdGohCCAdIC0gDSAHKAIIIgkgCSAHKAIMcyAEEIANIDogOigCACANajYCACAwQQFqITAgEEEBayEQIB1BEGohHUEAIREgEkECaiINIBggBygCCCASaiIEIAQgGEsbIglPDQADQCAXIAYgBSAjIA0QiRMgCSANQQFqIg1HDQALIAcoAgggEmohBAsgBEEEaiAMSQ0ACwsgGiAMIBFqIARrNgIAIA8gDygCACAwajYCACAHQTBqJAAMAgtBwNHRAEEAICUtAFUbIRlBACEwIwBBMGsiEiQAIBooAgAhDCAEIAlqIgsgBEEIaksEQCBBQQRqIREgC0EHayIcIAQgCUEHSxshJ0EBICUoAhh0QRBrIRdBwABBgAQgJSgCFCIJQQlIGyItQQJ0IR4gJUEEaiEgIAQgLWohCCALQQFrISwgJSgCECEhIBJBCGohGCAJQQVIIS4DQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgESAZIAYgBSAjIAogJiAEIAsgBGsiCSAXIAQgBCAXSxsgISASEL4JBEAgLCAEayEJQQAhBwNAIBJCADcCJCASQuQPNwMYIBIgCSASKAIIQQFrIg0gCSANSRtBACAuGzYCICARIBkgBiAFICMgCiAmIAQgB2oiDUEBaiIIIAkgFyAIIAggF0sbICEgEkEYahC+CUUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIAdBAksgDUEJaiALT3JFBEAgCUEBayEJIAdBAWohBwwBCwsgDUEBaiENIAcgDGpBAWoMAgsgCCAEQQFqIgdPBEAgDEEBaiEMIAcMAwsgHCAEQRFqIg1LBEAgCCAeaiAHTwRAQQAhCQNAIBEgBiAFICMgByAJahDCHCAJQQJqIglBCEcNAAsgDEEJaiEMIARBCWoMBAtBACEJA0AgESAGIAUgIyAHIAlqEMIcIAlBBGoiCUEQRw0ACyAMQRFqIQwgDQwDCyAJIAxqIQwgCwwCCyAHIAxqCyEMIBIoAgghCQJAAn8CQCASKAIQIgQgFyANIA0gF0sbIghLDQBBACEHIAQgJigCACIORg0CQQEgJigCBCIHIARGDQEaAkAgBEEDaiIUIA5rIg5BB08EQCAUIAdrIgdBB0kNAUECICYoAgggBEYNAxogBCAmKAIMRw0CQQMMAwtB6IjUywAgDkECdHZBD3EMAgtBzrXs/gAgB0ECdHZBD3EMAQsgBEEPagsiB0UgBCAIS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBDYCAAsgEEUNDSANIC1qIAlBAXRqIQggHSAgIAwgCSASKAIMIAlzIAcQgA0gOiA6KAIAIAxqNgIAAn8gJyASKAIIIA1qIgQgBCAnSxsiKiEJIwBBIGsiByQAAkACQAJAAkACQCANQQJqIgRBEGogCU0EQCAJIARrIiJBBE8EQCAiQQJ2ISQgESgCBCEMIBEoAgAhFCAEIQkDQCAFIAkgI3EiDkkNHyAFIA5rQQpNDQcgB0IANwMIIAdBCGoiFkEIIAYgDmoiFUEIQdTZzgAQ1SwgBzEADCFgIAc1AgghYSAHQgA3AwggFkEIIBVBAWpBCEHU2c4AENUsIAcxAAwhYiAHNQIIIWMgB0IANwMIIBZBCCAVQQJqQQhB1NnOABDVLCAHMQAMIWQgBzUCCCFlIAdCADcDCCAWQQggFUEDakEIQdTZzgAQ1SwgDCBgQjiGIGFCGIaEQr3P1vHR9+maHn5CMIinIhZNDQMgBzUCCCFgIAcxAAwhYSAUIBZBAnRqIA42AgAgDCBiQjiGIGNCGIaEQr3P1vHR9+maHn5CMIinIhZNDQQgFCAWQQJ0aiAOQQFqNgIAIAwgZEI4hiBlQhiGhEK9z9bx0ffpmh5+QjCIpyIWTQ0FIBQgFkECdGogDkECajYCACAMIGFCOIYgYEIYhoRCvc/W8dH36ZoefkIwiKciFk0NBiAUIBZBAnRqIA5BA2o2AgAgCUEEaiEJICRBAWsiJA0ACwsgIkF8cSAEaiEECyAHQSBqJAAgBAwFCyAWIAxBlOHOABDDIQALIBYgDEGk4c4AEMMhAAsgFiAMQbThzgAQwyEACyAWIAxBxOHOABDDIQALDBgLIgkgKkkEQANAIBEgBiAFICMgCRDCHCAqIAlBAWoiCUcNAAsLIDBBAWohMCAQQQFrIRAgHUEQaiEdQQAhDCASKAIIIA1qCyIEQQhqIAtJDQALCyAaIAsgDGogBGs2AgAgDyAPKAIAIDBqNgIAIBJBMGokAAwBC0HA0dEAQQAgJS0AVRshByBBQQRqIRIgJSgCFEEKTARAIAchCyAEIQwgBiENIAUhCEEAIQUjAEEgayIXJAAgJSgCGCEwIBdBCGogCUEBaiIGEOsgIBcoAgwhESAXKAIIIQcCQCAGBEAgByEEA0AgBSARRg0CIARCgICAgOCz8v/+ADcCACAEQRBqQQA2AgAgBEEIakIBNwIAIARBFGohBCAGIAVBAWoiBUcNAAsLIA8gDygCAAJ/IAkhBUEBIDB0QRBrITAjAEGwIGsiDyQAICUoAhQhBiAPQaAYakEAQYAI/AsAIBEEQCAHQgA3AgAgB0EANgIIIA9BMGpBAEGAFvwLACAPQRhqIAVBAmoQuR4gDykDGCFgIA9BEGogJSgCDCIEQQBHIAQgBWoQvB4gDyAFNgK4FiAPQQA2ArQWIA9BoAQgBCAEQaAETxs2ArAWIA8gYDcCKCAPIA8pAxA3AiAgD0EgaiAMIA0gCCAjEP4NIA9BvBZqQQBB5AH8CwAgBUEETwRAIAwgBUH/AGsiBEEAIAQgBU0baiEYQZYBQcUCIAZBC0gbIRZBACEEA0ACQAJAAkAgBSAMIAQgDSAIICMgCiAlIDAgJgJ/QQAgEiALIA0gCCAjIAogBCAMaiIOIAUgBGsgMCAOIA4gMEsbICUgD0GgGGoiFUGAARDvByIGRQ0AGiAGQQFrIRQgBkGBAU8NASAGIBYgFEEDdCAVaikDACJgQiWIp08NABogDyBgNwOgGEEBCyIUIA9BoBhqQYABIA9BIGogD0G8FmogByAREOwBIgZBACAGQYCAAU8bIQYgFEEBRgRAIAYgDykDoBhCJYinIhQgBiAUSxsgBiAUIBZLGyEGCyAGQQJPDQEgBCEGDAILIBRBgAFBnLfQABDDIQALIBIgDSAIICMgDkEBaiAYIAYgDmoiDiAOIBhLGxDLFSAEQQRqIQQgBkEBayEUA0AgBEEDayEGIAQgBU8NASAMIAYgMCAmIA9BIGogD0G8FmogByAREIYPIARBAWohBCAUQQFrIhQNAAsLIAZBAWohBCAGQQRqIAVJDQALCyAPQQA2AqwgIA9CgICAgMAANwKkICAPQQhqIA9BpCBqQYyHzgAQmCEgDygCLCEEIA8oAighBiAPIA8pAwg3AiggBARAIAYgBEECdEEEEPg6CyAPQQA2AqwgIA9CgICAgMAANwKkICAPIA9BpCBqQYyHzgAQmCEgDygCJCEEIA8oAiAhBiAPIA8pAwA3AiAgBARAIAYgBEECdEEEEPg6CwJAIAUgEUkEQCAHIAVBFGxqIQQDQCAEQRBqKAIAQf///z9xDQIgBEEIaigCAEEBRw0CIARBFGshBCAFQQFrIgUgEUkNAAsLIAUgEUH8tNAAEMMhAAsgBEKBgICAcDcCAEEAIQQCQAJAIAUEQANAIAUgEU8NAiAFIAcgBUEUbGoiBSgCEEH///8/cSAFKAIIQf///w9xaiIGayIFIBFPDQMgByAFQRRsaiINIAY2AgQgDUEBNgIAIARBAWohBCAFDQALCyAPQSBqEJgqIA9BsCBqJAAgBAwDCyAFIBFBjLXQABDDIQALIAUgEUGctdAAEMMhAAtBAEEAQYy30AAQwyEAC2o2AgAgCSAMIDAgByARICYgGiAlIB0gECA6EJUNIBdBADYCHCAXQoCAgIDAADcCFCAXIBdBFGpBjIfOABCZISAXKAIEIQQgFygCACEFIBEEQCAHIBFBFGxBBBD4OgsgBARAIAUgBEEUbEEEEPg6CyAXQSBqJAAMAgsgESARQcy00AAQwyEACyAHIRggBCEMIAYhCCAFIQ0gCiERIBIhFyAdITBBACEKIwBBkBdrIhYkAEEBICUoAhh0An8gCUUEQCAWQcgAahD+JyAWKAJIIScgFigCTAwBCyAWQdAAaiArIAkQuSkgFigCUCEnIBYoAlQLIRVBEGshLSAWQeAAakIANwMAIBZCADcDWCAWQUBrIAlBAnQiBhC4HiAWKAJEIRIgFigCQCEdAkAgCUEESQ0AIAwgCUH/AGsiBEEAIAQgCU0baiEZAkACQANAIApBgAFqIgcgBksEQCAGIAcgBhshBQNAIAUiBEEBdCEFIAQgB0kNAAsgFkE4aiAEELgeIBYoAjwhFCAWKAI4IQcCQAJAAkAgBkUNAAJAIAYgFE0EQCAGIBJLDQEgByAGQQN0Ig5qIQYgFkHoAGoiISIFQQA2AhAgBSAOIB1qIg42AgwgBSAdNgIIIAUgBjYCBCAFIAc2AgAgBSAOIB1rQQN2IgUgBiAHa0EDdiIGIAUgBkkbNgIUIBYoAnwiBiAWKAJ4IgVNBEAgFkEANgJwIBZCgICAgIABNwJoIBZBMGogIUGMh84AEKMhIBYoAjQhBSAWKAIwIQ4MBAsgBiAFayEGIAVBA3QiDiAWKAJoaiEFIBYoAnAgDmohDgNAIAUgDikDADcDACAFQQhqIQUgDkEIaiEOIAZBAWsiBg0ACwwCCyAWQQA2AnggFkEBNgJsIBZB+KDQADYCaCAWQgQ3AnAgFkHoAGpBvLfQABDvLAALIBZBADYCeCAWQQE2AmwgFkH4oNAANgJoIBZCBDcCcCAWQegAakHMt9AAEO8sAAsgFkEANgJwIBZCgICAgIABNwJoIBZBKGogFkHoAGpBjIfOABCjISAWKAIsIQUgFigCKCEOIBJFDQELIB0gEkEDdEEIEPg6CyAFBEAgDiAFQQN0QQgQ+DoLIAchHSAUIRIgBCEGCyAKIBJNBEAgFyAYIAggDSAjIBEgCyAMaiIFIAkgC2sgLSAFIAUgLUsbICUgHSAKQQN0aiIOIBIgCmsQ7wchBAJ/AkAgCyAVSQRAICcgC0ECdGoiFCAENgIAIAQNASALDAILIAsgFUHst9AAEMMhAAsCQCASIAQgCmoiBEEBayIHSwRAIB0gB0EDdGopAwAiYEL//////5cKVg0BIAQhCiALDAILIAcgEkH8t9AAEMMhAAsgCiASTw0DIA4gYDcDACAUQQE2AgAgFyAIIA0gIyAFQQFqIBkgBSBgQiWIpyIEaiIFIAUgGUsbEMsVIARBAWsiBSAVIAtBAWoiB2tLDQQCQCAFRQ0AIARBAnRBBGsiBEUNACAnIAdBAnRqQQAgBPwLAAsgCkEBaiEKIAUgC2oLIgRBAWohCyAEQQRqIAlJDQEMBAsLIAogEkHct9AAEK87AAsgCiASQYy40AAQwyEACyAWQQA2AnggFkEBNgJsIBZB+KDQADYCaCAWQgQ3AnAgFkHoAGpBnLjQABDvLAALIBooAgAhKiA6KAIAIRwgFiAmNgJoIBYgJkEQajYCbAJAIBZB6ABqEJ42IgRFDQBBBCAEIARBBE8bQQJ0IgRFDQAgFkHYAGogJiAE/AoAAAtBASEKIA8oAgAhISAWQSBqIAlBAWoiIhDrICAWKAIkIRQgFigCICEHIBZB+ABqQQBBgBb8CwAgFkHoAGohHiAWQRhqIAlBAmoQuR4gFikDGCFgIBZBEGogJSgCDCIEQQBHIAQgCWoQvB4gFiAJNgKAFyAWQQA2AvwWIBZBoAQgBCAEQaAETxs2AvgWIBYgYDcCcCAWIBYpAxA3AmgCQAJAA0AgIgRAQQAhBSAHIQQDQCAFIBRGDQMgBEKAgICA4LPy//4ANwIAIARBEGpBADYCACAEQQhqQgE3AgAgBEEUaiEEICIgBUEBaiIFRw0ACwsCQCAKIhcEQCAWQegAaiAMIAggDSAjEP4NDAELIA8oAgAgIWshGEEAIQ5DAAAAACFvIwBBsCprIgskACALQQBBgAj8CwAgC0GACGpBAEGAFvwLACALQYAeakEAQbAE/AsAIAtBsCJqQQBBgAj8CwAgGARAIAwgKmshBQNAAkACQAJAIA4gEEcEQCAwIA5BBHRqIgQvAQwiCkHABU8NASAELwEOIRkgBCgCBCEkIAQoAgAhBiALQYAIaiAKQQJ0aiIEIAQoAgBBAWo2AgAgCkH/AEsNAgwDCyAQIBBBnLbQABDDIQALIApBwAVBrLbQABDDIQALIBlB/wdxIgRBiwFNBEAgC0GAHmogBEECdGoiBCAEKAIAQQFqNgIADAELIARBjAFBvLbQABDDIQALIAUhBAJAIAYiCkUNAANAIA0gBCAjcSIZSwRAIAsgCCAZai0AAEECdGoiGSAZKAIAQQFqNgIAIARBAWohBCAKQQFrIgoNAQwCCwsgGSANQcy20AAQwyEACyAFIAZqICRB////D3FqIQUgDkEBaiIOIBhHDQALC0EQIQQgC0GAAkGAAkEBIAtBsCJqQYACEJMNIAtBgAhqQcAFQcAFQQAgFkHoAGoiBUEQakHABRCTDSALQYAeakGMASAFKAKQFkEAIAUoAgAgBSgCBBCTDUOeyf9+IW0DQCBtIG0gBCAFaioCACJuIG0gbl0bIG4gblwbIW0gBEEEaiIEQZAWRw0ACyAFIG04ApQWAkACQAJAIAUoAgwiBgRAIAUoApgWIQ5BACEEIAUoAggiBUEANgIAIA4EQCAFQQRqIQogBkEBayEYQwAAAAAhbQNAIAQgDGogI3EiBSANTw0DIAQgGEYNBCAKIG0gbyALQbAiaiAFIAhqLQAAQQJ0aioCAJIib5IibjgCACBvIG4gbZOTIW8gCkEEaiEKIG4hbSAOIARBAWoiBEcNAAsLIAtBsCpqJAAMAwtBAEEAQey10AAQwyEACyAFIA1B/LXQABDDIQALIAYgBkGMttAAEMMhAAsLIDogHDYCACAPICE2AgAgGiAqNgIAIBYgHjYCiBcgFiAWQdgAaiIFNgKEFwJAIBZBhBdqEJ42IgRFDQBBBCAEIARBBE8bQQJ0IgRFDQAgJiAFIAT8CgAAC0EAIQogDwJ/IAkhBUEAIQRBACELIwBB8AFrIhgkACAUBEAgJSgCFCEGIAdCADcCACAHQQA2AgggGEEMakEAQeQB/AsAIAVBBE8EQCAWQegAaiEkQZYBQcUCIAZBC0gbISAgJ0EEaiEsA0ACQAJAIAQgFUkEQCALIBJNBEAgBSAMIAQgCCANICMgESAlIC0gJiAnIARBAnQiLmooAgAiDiAdIAtBA3RqIBIgC2sgJCAYQQxqIAcgFBDsASIGQQAgBkGAgAFPGyEGIAsgDmohCyAOQQFGBEAgC0EBayIOIBJPDQMgBiAdIA5BA3RqKQMAQiWIpyIOIAYgDksbIAYgDiAgSxshBgsgBkECSQRAIAQhBgwECyAEQQRqIQQgBkEBayEZICwgLmohDgNAIARBA2shBiAEIAVPDQQgDCAGIC0gJiAkIBhBDGogByAUEIYPIAYgFUkEQCAEQQFqIQQgDigCACALaiELIA5BBGohDiAZQQFrIhlFDQUMAQsLIARBA2sgFUH0stAAEMMhAAsgCyASQdSy0AAQrzsACyAEIBVBxLLQABDDIQALIA4gEkHkstAAEMMhAAsgBkEBaiEEIAZBBGogBUkNAAsLAkAgBSAUSQRAIAcgBUEUbGohBANAIARBEGooAgBB////P3ENAiAEQQhqKAIAQQFHDQIgBEEUayEEIAVBAWsiBSAUSQ0ACwsgBSAUQfy00AAQwyEACyAEQoGAgIBwNwIAQQAhBAJAAkAgBQRAA0AgBSAUTw0CIAUgByAFQRRsaiIFKAIQQf///z9xIAUoAghB////D3FqIgZrIgUgFE8NAyAHIAVBFGxqIgsgBjYCBCALQQE2AgAgBEEBaiEEIAUNAAsLIBhB8AFqJAAgBAwDCyAFIBRBjLXQABDDIQALIAUgFEGctdAAEMMhAAtBAEEAQbSy0AAQwyEACyAhajYCACAJIAwgLSAHIBQgJiAaICUgMCAQIDoQlQ0gFw0ACwwBCyAUIBRBzLTQABDDIQALIBZBADYCjBcgFkKAgICAwAA3AoQXIBZBCGogFkGEF2pBjIfOABCYISAWKAJ0IQQgFigCcCEFIBYgFikDCDcCcCAEBEAgBSAEQQJ0QQQQ+DoLIBZBADYCjBcgFkKAgICAwAA3AoQXIBYgFkGEF2pBjIfOABCYISAWKAJsIQQgFigCaCEFIBYgFikDADcCaCAEBEAgBSAEQQJ0QQQQ+DoLIBQEQCAHIBRBFGxBBBD4OgsgEgRAIB0gEkEDdEEIEPg6CyAnIBUQgDEgFkHoAGoQmCogFkGQF2okAAtBAUEYICUoAhwiBCAlKAIYIgUgBCAFShtBAWoiBCAEQRhOG3QhBCAAKQPwASFgIAApA+gBIAAQ+A4gASACcg0DIAAoApQqIgIgACgCmCoiBWpB/98ASSAAKAIcQQNKckUNAyBgfadBASAAKAIkdGogBEsNAyAFIARBA3YiBE8gAiAET3INAyAAKQP4ARDLKyAAKQPoASJgEMsrIAAgYDcD+AFNDQQgACgCaEUNBCBBEJQqQQA2AhgMBAsgBCAFQYi/0AAQrzsACyAFIAxBmL/QABCvOwALIAcgDUGov9AAEK87AAsCQAJAAkACQAJAAkAgGigCACICBEAgACgClCoiBCAAKALEASIFTw0BIAAoAsABIARBBHRqIgRBkAg7AQ4gBEKAgIDAADcCBCAEIAI2AgAgBAJ/AkACQCACQQZPBEAgAkGCAUkNASACQcIQSQ0CQRUgAkHCMEkNAxpBFkEXIAJBwrABSRsMAwsgAgwCCyACQQJrIgJnQSBqQT9zQQFrIgRBAXQgAiAEdmpBAmoMAQsgAkHCAGtnQSBqQT9zQQpqCyICQfj/A3FBA3ZBA2wiBEEGdEHAmsgCIARBAXR2QcABcWogAkEDdEE4cXJBwgBqOwEMIAAoApwqIQIgAEEANgKcKiAAIAAoApQqQQFqNgKUKiAAIAIgACgCmCpqNgKYKgsgAUUEQCAAKQPoASAAKQPwAVENBwsgACgC8CkiBCAAKAKMKiICSQ0BIAAoAuwpIAJqITogBCACayEqIAApA+gBIAApA/ABImB9pyFEID1B/wFxIU4gAC0AvyohFiAALQDAKiEwIAAoApgqIQYgACgClCohEiAAKALAASEdIAAoAsQBIT0gAEHAAmohSSAAQbAqaiFPIDtBLGohNSAAKALIASE2IAAoAswBITRBACECIwBB8AFrIhckACAlLQBUIQUCQAJAAkACQAJAAkACQCAlLQBWIglFBEAgASECIAVBAXENAQsgYBDLKyERIBdBDGogJUEMaikCADcCACAXQTBqICVBMGopAgA3AgAgF0E4aiAlQThqKQIANwIAIBcgJSkCBDcCBCAXICUpAig3AiggJSgCICENICUoAiQhCiAlKABZIQcgJSkCGCFhICUoAgAhDCAlKAIUIQQgJS8BUCEIIBdByABqICVByABqKQIANwIAIBcgCDsBUCAXIAQ2AhQgFyAMNgIAIBcgYTcCGCAXIAc2AFkgFyAKNgIkIBcgDTYCICAXIAk6AFYgFyAFOgBUIBcgJSkCQDcCQCAXICUvAFc7AFcgFyAlLQBVOgBVIBcgJS8BUjsBUiBERQRAQQJCAyA1IDYgNBDfEyA1IDUoAgBBB2pBeHE2AgAMBwsCfyMAQZAIayIFJABBASEMAkACQCASIERBCHZBAmpPDQAgBrMgRLMibUOkcH0/lF5FDQAgBUEQakEAQYAI/AsAIERBDGoiBkENbiEMIAZBDU8EQCBgpyEHA0AgByAjcSIGICpPDQMgBUEQaiAGIDpqLQAAQQJ0aiIGIAYoAgBBAWo2AgAgB0ENaiEHIAxBAWsiDA0ACwsgBUEIaiAFQRBqQYACQYACEIERIG1DpHD9QJRDAABQQZUgBSgCDLMibSAFKgIIIm4gbSBuXhtdRSEMCyAFQZAIaiQAIAwMAQsgBiAqQZT40QAQwyEAC0UEQCAmIEkpAgA3AgAgJkEIaiBJQQhqKQIANwIAICsgAiA6ICogESAjICUgRCBPIDUgNiA0QQAQtQ4MBgsgNSgCACJaQQN2IllBAWoiBSA0Tw0BIDYgWWoiWy0AACFcIAUgNmoiXS0AACFeIARBA0gNAiAEQQNGDQMjAEHwAGsiBSQAIAVB2ABqEP0nIAUpA1ghYCAFQdAAahD+JyAXQeAAaiIhIgYgBSkDUDcCCCAGIGA3AgAgBkIANwIQIAVByABqEP0nIAUpA0ghYCAFQUBrEP4nIAYgBSkDQDcCICAGIGA3AhggBkIANwIoIAVBOGoQ/ScgBSkDOCFgIAVBMGoQ/icgBiAFKQMwNwI4IAYgYDcCMCAGQgA3AkAgBUEoahD+JyAFKQMoIWAgBUEgahD+JyAFKQMgIWEgBUEANgJsIAVCgICAgMAANwJkIAVBGGogBUHkAGoiCUGMh84AEKIhIAUpAxghYiAFQQA2AmwgBUKAgICAwAA3AmQgBUEQaiAJQYyHzgAQnCEgBSkDECFjIAVBADYCbCAFQoCAgIDAADcCZCAFQQhqIAlBjIfOABCgISAFKQMIIWQgBkEANgJwIAYgYDcCSCAGIGE3AlAgBkIANwJ0IAYgYjcCWCAGIGM3AmAgBkIANwJ8IAYgZDcCaCAFQfAAaiQAAkAgBEEKTwRAIBEhCSAWIQwgMCENIwBBwBdrIigkACAoQQA2AsABIChCgICAgBA3ArgBIChByABqIChBuAFqQYyHzgAQkCEgKCgCTCFFICgoAkghRyAXLQBTIgRFBEAgKEHcAGogF0EMaiIiKQIANwIAIChBgAFqIBdBMGoiJCkCADcCACAoQYgBaiAXQThqIhwpAgA3AgAgKCAXKQIENwJUICggFykCKDcCeCAXLQBcIQUgFygCGCEGIBcoAhwhByAXKAIgIQogFygCJCEIIBctAFEhDyAXLQBZIQsgFy0AWiEQIBctAFshDiAXKAIAIRQgFygCFCEYIBctAFAhGiAoQZgBaiAXQcgAaiIeKQIANwIAICggGjoAoAEgKCAYNgJkICggFDYCUCAoIA46AKsBICggEDoAqgEgKCALOgCpASAoIA86AKEBICggCDYCdCAoIAo2AnAgKCAHNgJsICggBjYCaCAoIAU6AKwBICggFykCQDcCkAEgFy0AUiEbIBctAFQhFSAXLQBVIRkgFy0AViEnIBctAFchLSAoIBctAFgiIDoAqAEgKCAtOgCnASAoICc6AKYBICggGToApQEgKCAVOgCkASAoIAQ6AKMBICggGzoAogEgKEHEAWogIikCADcCACAoQegBaiAkKQIANwIAIChB8AFqIBwpAgA3AgAgKEGAAmogHikCADcCACAoIBo6AIgCICggGDYCzAEgKCAUNgK4ASAoIAU6AJQCICggDjoAkwIgKCAQOgCSAiAoIAs6AJECICggDzoAiQIgKCAINgLcASAoIAo2AtgBICggBzYC1AEgKCAGNgLQASAoIBcpAgQ3ArwBICggFykCKDcC4AEgKCAXKQJANwL4ASAoICA6AJACICggLToAjwIgKCAnOgCOAiAoIBk6AI0CICggFToAjAIgKCAEOgCLAiAoIBs6AIoCIBdBBGohBiAoQbwBaiEKIChB1ABqIQRELp+Hoq5CfVQhhQFBACEHQQEhC0EAIQgDQCCFASGGAQJAIAciBUEPSw0AA0ACQCAoQgA3A7ABIChBuAFqIAggByAIdCIFEMQVIAggKCgCVEcgBSAoKAJYR3IgC3EhCyAdID0gEiAEIAogKEGwAWoQhxBFDQAgKCsDsAEihQEghgFkDQAgBiAKKQIANwIAIAZBCGogCkEIaikCADcCAEEQIQUghQEhhgEgB0EBaiIHQRBHDQEMAgsLIIYBIYUBIAchBQsgBUEBayIHQQAgBSAHTxtBAXYhByAIQQFqIghBBEcNAAsCQCALQQFxRQ0AIChCADcDsAEgHSA9IBIgBCAEIChBsAFqEIcQGiAoKwOwASCFAWNFDQAgBiAEKQIANwIAIAZBCGogBEEIaikCADcCAAsgHSEFIwBBIGsiByQAAkACQAJAIAYoAgAiCiAEKAIARgRAIAQoAgQgBigCBEYNAQsgEiA9Sw0BIBJFDQAgEkEEdCEIIAqtIWAgBigCBCEGA0ACQCAFQQRqKAIAQf///w9xRQ0AIAVBDGovAQBB/wBNDQAgBSAEELMgIAYgYCAFQQ5qIAVBCGoQlhgLIAVBEGohBSAIQRBrIggNAAsLIAdBIGokAAwBCyAHQQA2AhggB0EBNgIMIAdBrJfSADYCCCAHQgQ3AhAgB0EIakGkmNIAEO8sAAsLICFBGGohJyAhQTBqIS0jAEEwayJGJAAgRkEYaiArAn8gHSEEQQAgEiIFRQ0AGiAFQQFrID1JBEBBACEGA0AgBCgCACAGaiEGIARBEGohBCAFQQFrIgUNAAsgBgwBCyA9ID1BgKHWABDDIQALIhAQuCkgHSEKIAkhBCBGKAIYIiwhFCBGKAIcIi4hD0EAIQVBACEOAkACQAJAAkACQAJAAkACQAJAIBIEQCAjQQFqIQsDQAJAAkAgDiA9RwRAIAooAgAiCCAEICNxIgRqICNLDQEgBSEGDAILID0gPUGQodYAEMMhAAsgCyAEayIHIAVqIgYgB0kNAyAGIA9LDQQgBCALSw0FICMgKk8NBiAFIBRqIAcgBCA6aiAHQcCh1gAQ1SwgCCAHayEIQQAhBAsCQCAIRQRAIAQhByAGIQUMAQsgBiAIaiIFIAZJDQcgBSAPSw0IIAQgCGoiByAESQ0JIAcgKksNCiAGIBRqIAggBCA6aiAIQfCh1gAQ1SwLIApBBGooAgBB////D3EgB2ohBCAKQRBqIQogEiAOQQFqIg5HDQALCwwICyAFIAZBoKHWABCxOwALIAYgD0GgodYAELA7AAsgBCALQbCh1gAQsTsACyALICpBsKHWABCwOwALIAYgBUHQodYAELE7AAsgBSAPQdCh1gAQsDsACyAEIAdB4KHWABCxOwALIAcgKkHgodYAELA7AAsgLCELIC4hGUEAIQcjAEHgCGsiMyQAAkAgEEUEQCAhQQE2AhAMAQsgEEGAAU8EQCAzQcgAaiIKQQBBhAj8CwAgM0Gj4P/7BzYCzAggM0HUCGoiDiAKQeQAIBBBoARuQQFqIgQgBEHkAE8bIg8QgRwgM0FAayAOQcyCzgAQoiEgMygCQCIUIQYgMygCRCIgIQQjAEEQayIFJAAgBUEHNgIMAkAgDwRAIBAgD24hGCAEIA9PBEAgBiAPQYgIbGohCCAGIQQDQCAEQQBBhAj8CwAgBEGECGpBo+D/+wc2AgAgBEGICGoiBCAIRw0ACyAQQccAayEaQQAhCANAIAggD24hBAJAIAdFDQAgBUEMahDdLiEbIA8gEE0EQCAbIBhwIARqIQQMAQtB/N7MABDnKwALIAQgGiAEQcYAaiAQSRsiBCAZSwRAIAQgGUGM38wAEK87AAsgBiAEIAtqIBkgBGtBxgAQkiQgCCAQaiEIIAZBiAhqIQYgDyAHQQFqIgdHDQALIAVBEGokAAwCCyAPIARBrOrMABCwOwALQezezAAQ4isAC0EAIRgjAEGQCGsiByQAIAdBBzYCBAJAIA8EQAJAIA8gEEEBdEHGAG5qQeMAaiIEIAQgD3AiBUcEQCAEIAVrIRpBACEEA0AgB0EIaiIFQQBBhAj8CwAgB0Gj4P/7BzYCjAggB0EEaiEbQQAhCAJAAkACQCAQIgZBxgBLBEAgGxDdLiAQQcUAayIIRQ0BIAhwIgggGUsNAkHGACEGCyAFIAggC2ogGSAIayAGEJIkDAILQazYzAAQ5ysACyAIIBlBvNjMABCvOwALIAQgIE8NAiAEQQFqIgVBACAFIA9HGyAYQQFqIRggFCAEQYgIbGoiBiAHKAKICCAGKAKACGo2AoAIQQAhBEEAIQgDQCAGIAhBAnRqIhsgB0EIaiAEaigCACAbKAIAajYCACAIQQFqIQggBEEEaiIEQYAIRw0ACyEEIBggGkkNAAsLIAdBkAhqJAAMAgsgBCAgQdzezAAQwyEAC0HM3swAEOIrAAsgM0E4aiArIBAQuCkgMygCPCETIDMoAjghOSAKIA9BCHQQoxUgM0EwaiAKQcyCzgAQmCEgMygCNCEeIDMoAjAhBiAzQeAAakIANwMAIDNB2ABqQgA3AwAgM0HQAGpCADcDACAzQgA3A0ggDiAKIA9BB2pBA3YiBBCHHCAzQShqIA5BzILOABCeISAzKAIsITggMygCKCEFIDNBIGogKyAEIBBsELgpIDMoAiQhHyAzKAIgIS8gCiAPQcSe0AAQmRUgM0EYaiAKQcyCzgAQqiEgMygCHCEyIDMoAhghQkEDQQogFygCFEEMSBshCgNAIAshDkEAIQhBACEbIwBBgAFrIhwkAAJAIA9FDQACQAJAAkACQCAgBEBBASEbIA9BAUcNASAQRQ0FA0AgCCATRg0DIAggOWpBADoAACAIQQFqIgggEEcNAAsMBQsMNAsgHiAPQQh0IgRPBEAgD0EHaiE+AkAgD0H///8BcUUNACAPQQp0IgRFDQAgBkEAIAT8CwALID5BA3YhKSAUQYAIaiEHIAYhBANAIAggIEYEQCAgICBB/NfMABDDIQALAn0gBygCACIYQYACTwRAIBizEOoSDAELIBhBAnRBwIfzAGoqAgALIW0gCCAeRg0DIAQgbTgCACAHQYgIaiEHIARBBGohBCAPIAhBAWoiCEcNAAsgD0ECdCEYIA9B/AdsIRogD0H/AWwhGyAUQfwHaiEVQYACISIDQCAiQQFrISJBACEIIAYhByAVIQQCQAJAAkADQCAIIB5GDQEgCCAgRg0CIAcqAgAhbSAEKAIAELksIW4gHiAIIBtqIiRLBEAgByAaaiBtIG6TOAIAIAdBBGohByAEQYgIaiEEIA8gCEEBaiIIRg0EDAELCyAkIB5B7NfMABDDIQALIB4gHkHM18wAEMMhAAsgICAgQdzXzAAQwyEACyAaIBhrIRogGyAPayEbIBVBBGshFSAiDQALIDgEQCA4QQV0IQcgBSEIA0AgCEIANwIAIAhBGGpCADcCACAIQRBqQgA3AgAgCEEIakIANwIAIAhBIGohCCAHQSBrIgcNAAsLIB8gECApbCIETwRAIAQEQCAvQQAgBPwLAAsgECAZTQRAIBBFDQUgDiAQaiFIIA9BeHEhGCAPQQdxIj9BAnQhJCAFIClBBXRqIVAgBSAPQQN2IlFBBXRqIVIgD0EISSFTQQAhIkEAITECQANAIBMgMUYEQCATIBNBnNbMABDDIQALAkACQAJAIA8gDi0AAGwiNyAeTQRAIDggUUkNASAxIDlqITxDmXaWfiFtIFMNAyAeIDdrIUAgBiA3QQJ0aiFDQQAhGkEAIRUgBSEEA0AgFUEDdCIHIEBLBEAgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQZzXzAAQ7ywACyBAIAdrQQdNDQMgBEEgaiAVQQFqIRUgHEH4AGogQyAHQQJ0aiIHQRhqKQIANwMAIBxB8ABqIAdBEGopAgA3AwAgHEHoAGogB0EIaikCADcDACAcIAcpAgA3A2BBACEIQQAhBwNAIAQgCGoiSiAcQeAAaiAIaioCACBKKgIAkjgCACBtIAQgB0G818wAEKIuKgIAIm5eBEAgPCAHIBpqOgAAIG4hbQsgCEEEaiEIIAdBAWoiB0EIRw0ACyAaQQhqIRoiBCBSRw0ACwwDCyAcQQA2AnAgHEEBNgJkIBxB4NLMADYCYCAcQgQ3AmggHEHgAGpBrNbMABDvLAALIBxBADYCcCAcQQE2AmQgHEHg0swANgJgIBxCBDcCaCAcQeAAakG81swAEO8sAAsgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQazXzAAQ7ywACwJAAkAgGCA3aiIEIB5NBEAgPyAeIARrSw0BAkAgPwRAIAYgBEECdGohB0EAIQggJCEaIAUhBCAYIRsDQCAIIBhqIjdBA3YiFSA4Tw0CIAQgG0ECdEFgcWoiQCAHKgIAIEAqAgCSOAIAIG0gBSAVQQV0aiIVIAhB/NbMABCiLioCAF4EQCAVIAhBjNfMABCiLiA8IDc6AAAqAgAhbQsgB0EEaiEHIARBBGohBCAIQQFqIQggG0EBaiEbIBpBBGsiGg0ACwtDzczgQSFuIDFB0A9PDQMgMbNDKVyPPZRDAAD6RJVDuB5FP5JDzczgQZQhbgwDCyAVIDhB7NbMABDDIQALIBxBADYCcCAcQQE2AmQgHEHg0swANgJgIBxCBDcCaCAcQeAAakHM1swAEO8sAAsgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQdzWzAAQ7ywACyAxQQFqITEgDkEBaiEOQQAhCANAIBxB4ABqIAhqIG04AgAgCEEEaiIIQSBHDQALIBwqAnwhfSAcKgJ4IX4gHCoCdCF/IBwqAnAhgAEgHCoCbCGBASAcKgJoIYIBIBwqAmQhgwEgHCoCYCGEAUEAIQgDQCAcQeAAaiAIaiBuOAIAIAhBBGoiCEEgRw0ACyAcQRhqIhsgHEH4AGoiFSkCADcDACAcQRBqIjcgHEHwAGoiPCkCADcDACAcQQhqIkAgHEHoAGoiQykCADcDACAcIBwpAmA3AwAgKSA4TQRAID5BCE8EQCAiIQcgBSEIA0AgCEEEaiJKKgIAIW0gCEEIaiJMKgIAIW4gCEEMaiJUKgIAIW8gCEEQaiJVKgIAIXAgCEEUaiJWKgIAIXEgCEEYaiJXKgIAIXIgCCoCACFzIBwgCEEcaiJYKgIAIH2TOAI8IBwgciB+kzgCOCAcIHEgf5M4AjQgHCBwIIABkzgCMCAcIG8ggQGTOAIsIBwgbiCCAZM4AiggHCBtIIMBkzgCJCAcIHMghAGTOAIgIBUgGykDADcDACA8IDcpAwA3AwAgQyBAKQMANwMAIBwgHCkDADcDYCAcQSBqIgRBAEHs38wAEKIuKgIAIW0gHEHgAGoiGkEAQfzfzAAQoi4qAgAhbiAEQQFBjODMABCiLioCACFvIBpBAUGc4MwAEKIuKgIAIXAgBEECQazgzAAQoi4qAgAhcSAaQQJBvODMABCiLioCACFyIARBA0HM4MwAEKIuKgIAIXMgGkEDQdzgzAAQoi4qAgAhdCAEQQRB7ODMABCiLioCACF1IBpBBEH84MwAEKIuKgIAIXYgBEEFQYzhzAAQoi4qAgAhdyAaQQVBnOHMABCiLioCACF4IARBBkGs4cwAEKIuKgIAIXkgGkEGQbzhzAAQoi4qAgAheiAEQQdBzOHMABCiLioCACF7IBpBB0Hc4cwAEKIuIUsgHCB5IHpgQQZ0NgJYIBwgdyB4YEEFdDYCVCAcIHUgdmBBBHQ2AlAgHCBzIHRgQQN0NgJMIBwgcSByYEECdDYCSCAcIG8gcGBBAXQ2AkQgHCBtIG5gNgJAIBwgeyBLKgIAYEEHdDYCXCAcQUBrEMwrIUsgByAfTw0EIAcgL2oiTSBNLQAAIEtyOgAAIBUgGykDADcDACA8IDcpAwA3AwAgQyBAKQMANwMAIBwgHCkDADcDYCAEQQBB7OHMABCiLioCACFtIBpBAEH84cwAEKIuKgIAIW4gBEEBQYzizAAQoi4qAgAhbyAaQQFBnOLMABCiLioCACFwIARBAkGs4swAEKIuKgIAIXEgGkECQbzizAAQoi4qAgAhciAEQQNBzOLMABCiLioCACFzIBpBA0Hc4swAEKIuKgIAIXQgBEEEQezizAAQoi4qAgAhdSAaQQRB/OLMABCiLioCACF2IARBBUGM48wAEKIuKgIAIXcgGkEFQZzjzAAQoi4qAgAheCAEQQZBrOPMABCiLioCACF5IBpBBkG848wAEKIuKgIAIXogBEEHQczjzAAQoi4qAgAheyAaQQdB3OPMABCiLioCACF8IFcgeSB6IHkgel0bOAIAIFYgdyB4IHcgeF0bOAIAIFUgdSB2IHUgdl0bOAIAIFQgcyB0IHMgdF0bOAIAIEwgcSByIHEgcl0bOAIAIEogbyBwIG8gcF0bOAIAIAggbSBuIG0gbl0bOAIAIFggeyB8IHsgfF0bOAIAIAdBAWohByAIQSBqIgggUEcNAAsLICIgKWohIiAOIEhHDQEMCAsLICkgOEHM38wAELA7AAsgByAfQdzfzAAQwyEACyAQIBlBzNXMABCwOwALIAQgH0G81cwAELA7AAsgBCAeQazVzAAQsDsACyATIBNBnNjMABDDIQALIB4gHkGM2MwAEMMhAAsCQCATIBBBAWsiB0sEQCAHDQFBASEbDAILIAcgE0Hc1cwAEMMhAAsgKSAQQQJrIg5sIQQgByA5ai0AACEIIA4hB0EBIRsCQAJAA0AgBCAIQQN2QR9xaiIYIB9PDQEgGCAvai0AACAIQQdxdkEBcQRAIAcgE08NAyAbIAhB/wFxIAcgOWotAAAiCEdqIRsLIA4gE0kEQCAHIDlqIAg6AAAgBCApayEEIAdBAWsiB0F/Rg0EDAELCyAHIBNBjNbMABDDIQALIAhB+AFxQQN2IARqIB9B7NXMABDDIQALIAcgE0H81cwAEMMhAAsgHEGAAWokAAJAAkACQCA5IBMgECBCIDIgDxCWEiIPIgQgIE0EQCAEBEAgFCAEQYgIbGohByAUIQQDQCAEQQBBhAj8CwAgBEGECGpBo+D/+wc2AgAgBEGICGoiBCAHRw0ACwsCQCAQBEBBACEEA0AgBCATRg0EICAgBCA5ai0AACIHTQ0FIAQgGUYNAiAUIAdBiAhsaiAEIAtqLQAAELYpIARBAWoiBCAQRw0ACwsMBAsgGSAZQbzfzAAQwyEACyAEICBBrOrMABCwOwALIBMgE0Gc38wAEMMhAAsgByAgQazfzAAQwyEACyAKQQFrIgoNAAsgHgRAIAYgHkECdEEEEPg6CyA4BEAgBSA4QQV0QQQQ+DoLICsgLyAfEOA1IDIEQCBCIDJBAXRBAhD4OgsgIARAIBQgIEGICGxBBBD4OgtBACEYQQAhKUEAITdBACFCQQAhPiMAQaAZayIfJAAgH0GIAWogKyAbELkpIB8oAowBITEgHygCiAEhFCAfQYABaiArIBsQuSkgHygChAEhLyAfKAKAASEkIB9BmBFqIgVBAEGECPwLACAfQaPg//sHNgKcGSAfQZAJaiIEIAUgG0EEdEHwB2pBBnYiDhCBHCAfQfgAaiAEQcyCzgAQoiEgHygCfCEaIB8oAnghFSAfQfAAaiArIA4QuSkgHygCdCEGIB8oAnAhCiAFQQBBhAj8CwAgH0Gj4P/7BzYCnBkgBCAFQcAAIBsgG0HAAE8bEIEcIB9B6ABqIARBzILOABCiISAfKAJsITIgHygCaCE/IB9BoBFqQgA3AwAgH0IANwOYESAEIAVBgRAQgxwgH0HgAGogBEHMgs4AEJ0hIB8oAmQhHCAfKAJgISBBACIFRQRAIB9BkAFqQQBBgAL8CwALIB9BkANqQQBBgAL8CwAgH0GQBWpBAEGAAvwLACAfQZAHakEAQYAC/AsAIBAEQCAQQQFrIQcDQAJAAkACQCAYIC9JBEAgJCAYQQJ0aiIEIAQoAgBBAWo2AgAgBUEBaiEEIAUgB0cNAQwCCyAYIC9B/NzMABDDIQALAkAgBSATSQRAIAQgE08NASAFIDlqIgUtAAAgBUEBai0AAEcNAgwDCyAFIBNBjN3MABDDIQALIAVBAWogE0Gc3cwAEMMhAAsgGEEBaiEYCyAEIgUgEEcNAAsLIAshOAJAIBtFBEAgBiELIAohBAwBCyAUIQggGyEeIA4hEEEAIQUCQAJAAkACQANAQcAAIBsgN2siBCAEQcAATxshD0EBQcAAIB4gHkHAAE8bIgQgBEEBTRshQEEAISICQAJAAkACQAJAAkACQANAICIgMkYNASA/ICJBiAhsaiIEQQBBgAj8CwAgBEKAgICAsIT8v/8ANwKACCAiIDdqIgcgL08NAiAkIAdBAnRqKAIAIgcEQCAFIBkgBSAZSRshGANAIBggGUYNBSAEIAUgOGotAAAQtikgGEEBaiEYIAVBAWohBSAHQQFrIgcNAAsLIAQgBBChBzgChAggIkECdCIEIB9BkAVqIgdqICI2AgAgH0GQA2oiCyAEaiAiNgIAIAQgH0GQAWoiGGpBATYCACAiQQFqIiIgQEcNAAsgDiA/IDIgGEHAACAHQcAAIAtBwAAgICAcIA8gD0HAAEGAEBCPBiI8IEJqIg9PDQYgDiAPIA4bIQcDQCAHIgRBAXQhByAEIA9JDQALIB9BmBFqIgdBAEGECPwLACAfQaPg//sHNgKcGSAfQZAJaiIPIAcgBBCBHCAfQdgAaiAPQcyCzgAQoiEgDiAfKAJcIgdLDQMgDiAaSw0EIB8oAlghDwJAIA5FDQAgDkGICGwiC0UNACAPIBUgC/wKAAALIBpFDQUgFSAaQYgIbEEEEPg6DAULIDIgMkHM3MwAEMMhAAsgLyA3IC8gN0sbIC9B3NzMABDDIQALIAUgGUHs3MwAEMMhAAsgDiAHQYzbzAAQsDsACyAOIBpBnNvMABCwOwALIAchGiAPIRUgBCEOCwJAIDwgPmoiBCAQTQRAIAYhCyAKIQQgECEPDAELIBAgBCAQGyEYA0AgGCIPQQF0IRggBCAPSw0ACyAfQdAAaiArIA8QuSkCQCAfKAJUIgsgEE8EQCAGIBBJDQEgHygCUCEEIBBBAnQiBwRAIAQgCiAH/AoAAAsgCiAGEIAxDAILIBAgC0Gs28wAELA7AAsgECAGQbzbzAAQsDsACyA8BEBBACEYIAsgPmsiBkEAIAYgC00bIQogGiBCayIGQQAgBiAaTRshQyAEID5BAnRqISIgFSBCQYgIbGohECAfQZADaiEHA0AgGEHAAEYNNyAHKAIAIgYgMk8NAyAYIENGDQQgECA/IAZBiAhsakGICPwKAAAgBkHAAE8NOCAKIBhGDQUgIiAfQZABaiAGQQJ0aigCADYCACAHKAIAIgZBwABPDTkgH0GQB2ogBkECdGogGDYCACAHQQRqIQcgIkEEaiEiIBBBiAhqIRAgGEEBaiIGIRggBiA8Rw0ACyAGID5qIT4gBiBCaiFCC0EAIQcgH0GQBWohGCAIIQYCQANAIBgoAgAiCkE/Sw0GIAcgN2oiECAxTw0BIAYgH0GQB2ogCkECdGooAgAgKWo2AgAgGEEEaiEYIAZBBGohBiBAIAdBAWoiB0cNAAsgCEGAAmohCCAeQUBqIR4gKSA8aiEpIA8hECAEIQogCyEGIDdBQGsiNyAbTw0GDAELCyAQIDFB3NvMABDDIQALIAYgMkH828wAEMMhAAsgGCBCaiAaQYzczAAQwyEACyAYID5qIAtBrNzMABDDIQALIApBwABBzNvMABDDIQALIB9BADYCoBEgH0KAgICAwAA3ApgRIB9ByABqIB9BmBFqQYyHzgAQoiEgHygCTCEeIB8oAkghNyAyBEAgPyAyQYgIbEEEEPg6CwJAIClBAXYgKWwiBSApQQZ0IgYgBSAGSRsiCkGAEE0EQCAcIQYgICEiDAELIB9BoBFqQgA3AwAgH0IANwOYESAfQZAJaiIFIB9BmBFqIApBAWoQgxwgH0FAayAFQcyCzgAQnSEgHygCRCEGIB8oAkAhIiAcRQ0AICAgHEEEdEEEEPg6CyAfQThqICsgKRC5KQJAIB8oAjwiDyApTwRAIB8oAjghCCApBEAgKUECdCEHQQAhBSAIIRgDQCAYIAU2AgAgBUEBaiEFIBhBBGohGCAHQQRrIgcNAAsLIBUgGiAEIAsgFCAxIAggDyAiIAYgKSAbQYACIAoQjwYhByAfQQA2AqARIB9CgICAgMAANwKYESAfQTBqIB9BmBFqQYyHzgAQnSEgHygCNCEgIB8oAjAhQiAGBEAgIiAGQQR0QQQQ+DoLIB9BKGoQ/icgHygCLCEyIB8oAighPiAEIAsQgDEgH0EgaiArICkQuSkgHygCICEcAkAgHygCJCIORQ0AIA5BAnQiBEUNACAcQf8BIAT8CwALIBtFDQFBACEiQQAhCkEAISkCQANAIB9BkAlqQQBBhAj8CwAgH0Gj4P/7BzYClBECQAJAAkACQCApIC9HBEAgJCApQQJ0IhBqKAIAIhgEQCAiIBkgGSAiSxshBQNAIAUgGUYNBCAfQZAJaiAiIDhqLQAAELYpIAVBAWohBSAiQQFqISIgGEEBayIYDQALCyApDQEgFCEFIDFFDTsMBAsgLyAvQfzZzAAQwyEACyApQQFrIgQgMUkNASAEIDFBnNrMABDDIQALICIgGUH82swAEMMhAAsgFCAEQQJ0aiEFCwJAIBogBSgCACILSwRAIB8oApARBH0gH0GYEWogH0GQCWpBiAj8CgAAIB8gFSALQYgIbGoiBCgCgAggHygCmBlqNgKYGUEAIQUDQCAfQZgRaiIGIAVqIhggBCAFaigCACAYKAIAajYCACAFQQRqIgVBgAhHDQALIAYQoQcgBCoChAiTBUMAAAAACyFtIAdFDQFBACEGA0ACQAJAAn0CQCAGIA9HBEAgCCAGQQJ0aiIYKAIAIgQgGk8NAyAfKAKQEQ0BQwAAAAAMAgsgDyAPQdzazAAQwyEACyAfQZgRaiAfQZAJakGICPwKAAAgHyAVIARBiAhsaiIEKAKACCAfKAKYGWo2ApgZQQAhBQNAIB9BmBFqIj8gBWoiPCAEIAVqKAIAIDwoAgBqNgIAIAVBBGoiBUGACEcNAAsgPxChByAEKgKECJMLIm4gbV1FDQEgGCgCACELIG4hbQwBCyAEIBpB7NrMABDDIQALIAZBAWoiBiAHRw0ACwwBCyALIBpBrNrMABDDIQALICkgMUcEQCAQIBRqIAs2AgAgCyAOTw0CIBwgC0ECdGoiBCgCAEF/RgRAIAQgCjYCACAKQQFqIQoLIClBAWoiKSAbRw0BDAQLCyAxIDFBvNrMABDDIQALIAsgDkHM2swAEMMhAAsgKSAPQczYzAAQsDsACyAfQRhqEP4nIB8oAhwhGSAfKAIYITggCCAPEIAxIB9BADYCoBEgH0KAgICAwAA3ApgRIB9BEGogH0GYEWpBjIfOABCiISAfKAIUIQggHygCECEpIBoEQCAVIBpBiAhsQQQQ+DoLAkAgGyAhKAIEIgRNBEAgBCELDAELIAQgGyAEGyEFA0AgBSIGQQF0IQUgBiAbSQ0ACyAfQQhqICsgBhC4KSAfKAIMIgsgBE8EQCAfKAIIIgUgBCAhKAIAIARB7NjMABDVLCAhKAIEIQQgISALNgIEICEoAgAhBiAhIAU2AgAgKyAGIAQQ4DUMAQsgBCALQdzYzAAQsDsACwJAAkACQAJAAkACQAJAAkACQCAhAn8CQCAbICEoAgwiBEsEQCAEIBsgBBshBQNAIAUiBkEBdCEFIAYgG0kNAAsgHyArIAYQuSkgBCAfKAIEIhBLDQUgHygCACEPIARBAnQiBARAIA8gISgCCCAE/AoAAAsgISgCDCEEICEgEDYCDCAhKAIIICEgDzYCCCAEEIAxICEoAgQhCwwBCyAbRQRAQQAhGEEBDAILICEoAgghDyAEIRALIBtBAWshGiAhKAIAIRVBACEiICQhCiAUIQdBACEYQQAhBkEAIQUDQCAFIC9GDQIgBUEBaiEEIAooAgAgBmohBgJAIAUgGkcEQCAFIDFPDQcgBCAxTw0IIAcoAgAgB0EEaigCAEYNAQsgBSAxTw0IIAcoAgAiBSAOTw0JIAsgGE0NCiAVIBhqIBwgBUECdGooAgAiBToAACAQIBhNDQQgDyAYQQJ0aiAGNgIAIAVB/wFxIgUgIkH/AXEiBiAFIAZLGyEiIBhBAWohGEEAIQYLIApBBGohCiAHQQRqIQcgBCIFIBtHDQALICJB/wFxQQFqCzYCECAhIBg2AhQgHCAOEIAxICQgLxCAMSAUIDEQgDEgGQRAIDggGUECdEEEEPg6CyAgBEAgQiAgQQR0QQQQ+DoLIB4EQCA3IB5BiAhsQQQQ+DoLIDIEQCA+IDJBAnRBBBD4OgsgCARAICkgCEGICGxBBBD4OgsgH0GgGWokAAwICyAvIC9BjNnMABDDIQALIBggEEHs2cwAEMMhAAsgBCAQQfzYzAAQsDsACyAFIDFBnNnMABDDIQALIAVBAWogMUGs2cwAEMMhAAsgBSAxQbzZzAAQwyEACyAFIA5BzNnMABDDIQALIBggC0Hc2cwAEMMhAAsgKyA5IBMQ4DUMAQsCQCAhKAIEIgQgISgCFCIFQQFqIg9PBEAgBCEKDAELIAQgDyAEGyEFA0AgBSIGQQF0IQUgBiAPSQ0ACyAzQRBqICsgBhC4KSAzKAIUIgogBE8EQCAzKAIQIgUgBCAhKAIAIARBzN3MABDVLCAhKAIEIQQgISAKNgIEICEoAgAhBiAhIAU2AgAgKyAGIAQQ4DUgISgCFCIFQQFqIQ8MAQsgBCAKQbzdzAAQsDsACwJAAkACQCAPICEoAgwiBE0EQCAEIQ8MAQsgBCAPIAQbIQUDQCAFIgZBAXQhBSAGIA9JDQALIDNBCGogKyAGELkpIAQgMygCDCIPSw0BIDMoAgghBSAEQQJ0IgQEQCAFICEoAgggBPwKAAALICEoAgwhBCAhIA82AgwgISgCCCAhIAU2AgggBBCAMSAhKAIUIQUgISgCBCEKCyAhQQE2AhAgBSAKTw0BICEoAgAgBWpBADoAACAFIA9JBEAgISAFQQFqNgIUICEoAgggBUECdGogEDYCAAwDCyAFIA9B/N3MABDDIQALIAQgD0Hc3cwAELA7AAsgBSAKQezdzAAQwyEACyAzQeAIaiQAICsgLCAuEOA1QQAhDiBGQSRqIgQgEkHEntAAEJkVIEZBEGogBEHMgs4AEKohIEYoAhQhICBGKAIQIRkCQAJAID0gEiASID1LGyIEBEAgHUEMaiEUIBkhBQNAIA4gIEYNAiAFIBQvAQA7AQAgBUECaiEFIBRBEGohFCAEIA5BAWoiDkcNAAsLIBkhDyAgIQsgJyEbQQAhBkEAIQgjAEHgFmsiKSQAAkAgEkUEQCAbQQE2AhAMAQsgEkGAAU8EQCApQcgAaiIUQQBBhBb8CwAgKUGj4P/7BzYCzBYgKUHUFmoiGiAUQTIgEkGSBG5BAWoiBCAEQTJPGyIQEIQcIClBQGsgGkHMgs4AEJwhICkoAkAiGCEFICkoAkQiLiEEIwBBEGsiByQAIAdBBzYCDAJAIBAEQCASIBBuIQogBCAQTwRAIAUgEEGIFmxqIQ4gBSEEA0AgBEEAQYQW/AsAIARBhBZqQaPg//sHNgIAIARBiBZqIgQgDkcNAAsgEkEpayEOA0AgBiAQbiEEAkAgCEUNACAHQQxqEN0uIRUgECASTQRAIBUgCnAgBGohBAwBC0H83swAEOcrAAsgBCAOIARBKGogEkkbIgQgC0sEQCAEIAtBjN/MABCvOwALIAUgDyAEQQF0aiALIARrQSgQ4x4gBiASaiEGIAVBiBZqIQUgECAIQQFqIghHDQALIAdBEGokAAwCCyAQIARBrOrMABCwOwALQezezAAQ4isAC0EAIQojAEGQFmsiByQAIAdBBzYCBAJAIBAEQAJAIBAgEkEBdEEobmpB4wBqIgQgBCAQcCIFRwRAIAQgBWshDkEAIQQDQCAHQQhqIghBAEGEFvwLACAHQaPg//sHNgKMFiAHQQRqIRVBACEGAkACQAJAIBIiBUEoSwRAIBUQ3S4gEkEnayIGRQ0BIAZwIgYgC0sNAkEoIQULIAggDyAGQQF0aiALIAZrIAUQ4x4MAgtBrNjMABDnKwALIAYgC0G82MwAEK87AAsgBCAuTw0CIARBAWoiBUEAIAUgEEcbIApBAWohCiAYIARBiBZsaiIIIAcoAogWIAgoAoAWajYCgBZBACEEQQAhBgNAIAggBkECdGoiFSAHQQhqIARqKAIAIBUoAgBqNgIAIAZBAWohBiAEQQRqIgRBgBZHDQALIQQgCiAOSQ0ACwsgB0GQFmokAAwCCyAEIC5B3N7MABDDIQALQczezAAQ4isACyApQThqICsgEhC4KSApKAI8ITEgKSgCOCFCIBQgEEHABWwQoxUgKUEwaiAUQcyCzgAQmCEgKSgCNCEsICkoAjAhDiApQeAAakIANwMAIClB2ABqQgA3AwAgKUHQAGpCADcDACApQgA3A0ggGiAUIBBBB2pBA3YiBBCHHCApQShqIBpBzILOABCeISApKAIsITggKSgCKCEFIClBIGogKyAEIBJsELgpICkoAiQhHyApKAIgIS8gFCAQQcSe0AAQmRUgKUEYaiAUQcyCzgAQqiEgKSgCHCE5ICkoAhghN0EDQQogFygCFEEMSBshBwNAIA8hFUEAIQpBACEIIwBBgAFrIh4kAAJAIBBFDQACQAJAAkACQCAuBEBBASEIIBBBAUcNASASRQ0FA0AgCiAxRg0DIAogQmpBADoAACAKQQFqIgogEkcNAAsMBQsMNgsgLCAQQcAFbCIETwRAIBBBgBZsIgRFIARFckUEQCAOQQAgBPwLAAsgEEEHaiJDQQN2ITMgGEGAFmohBiAOIQQDQCAKIC5GBEAgLiAuQfzXzAAQwyEACwJ9IAYoAgAiCEGAAk8EQCAIsxDqEgwBCyAIQQJ0QcCH8wBqKgIACyFtIAogLEYNAyAEIG04AgAgBkGIFmohBiAEQQRqIQQgECAKQQFqIgpHDQALIBBBAnQhJCAQQfwVbCEUIBBBvwVsIQggGEH8FWohGkHABSEiA0AgIkEBayEiQQAhCiAOIQYgGiEEAkACQAJAA0AgCiAsRg0BIAogLkYNAiAGKgIAIW0gBCgCABC5LCFuICwgCCAKaiIcSwRAIAYgFGogbSBukzgCACAGQQRqIQYgBEGIFmohBCAQIApBAWoiCkYNBAwBCwsgHCAsQezXzAAQwyEACyAsICxBzNfMABDDIQALIC4gLkHc18wAEMMhAAsgFCAkayEUIAggEGshCCAaQQRrIRogIg0ACyA4BEAgOEEFdCEGIAUhCgNAIApCADcCACAKQRhqQgA3AgAgCkEQakIANwIAIApBCGpCADcCACAKQSBqIQogBkEgayIGDQALCyAfIBIgM2wiBE8EQCAEBEAgL0EAIAT8CwALIAsgEk8EQCASRQ0FIBUgEkEBdGohSCAQQXhxISIgEEEHcSI+QQJ0IRwgBSAzQQV0aiFQIAUgEEEDdiJRQQV0aiFSIBBBCEkhU0EAISRBACETAkADQCATIDFGBEAgMSAxQZzWzAAQwyEACwJAAkACQCAQIBUvAQBsIjIgLE0EQCA4IFFJDQEgEyBCaiE/Q5l2ln4hbSBTDQMgLCAyayE8IA4gMkECdGohQEEAIRRBACEaIAUhBANAIBpBA3QiBiA8SwRAIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakGc18wAEO8sAAsgPCAGa0EHTQ0DIARBIGogGkEBaiEaIB5B+ABqIEAgBkECdGoiBkEYaikCADcDACAeQfAAaiAGQRBqKQIANwMAIB5B6ABqIAZBCGopAgA3AwAgHiAGKQIANwNgQQAhCkEAIQYDQCAEIApqIkogHkHgAGogCmoqAgAgSioCAJI4AgAgbSAEIAZBvNfMABCiLioCACJuXgRAID8gBiAUajoAACBuIW0LIApBBGohCiAGQQFqIgZBCEcNAAsgFEEIaiEUIgQgUkcNAAsMAwsgHkEANgJwIB5BATYCZCAeQeDSzAA2AmAgHkIENwJoIB5B4ABqQazWzAAQ7ywACyAeQQA2AnAgHkEBNgJkIB5B4NLMADYCYCAeQgQ3AmggHkHgAGpBvNbMABDvLAALIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakGs18wAEO8sAAsCQAJAICIgMmoiBCAsTQRAID4gLCAEa0sNAQJAID4EQCAOIARBAnRqIQZBACEKIBwhFCAFIQQgIiEIA0AgCiAiaiIyQQN2IhogOE8NAiAEIAhBAnRBYHFqIjwgBioCACA8KgIAkjgCACBtIAUgGkEFdGoiGiAKQfzWzAAQoi4qAgBeBEAgGiAKQYzXzAAQoi4gPyAyOgAAKgIAIW0LIAZBBGohBiAEQQRqIQQgCkEBaiEKIAhBAWohCCAUQQRrIhQNAAsLQwAAWEEhbiATQdAPTw0DIBOzQylcjz2UQwAA+kSVQ7geRT+SQwAAWEGUIW4MAwsgGiA4QezWzAAQwyEACyAeQQA2AnAgHkEBNgJkIB5B4NLMADYCYCAeQgQ3AmggHkHgAGpBzNbMABDvLAALIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakHc1swAEO8sAAsgE0EBaiETIBVBAmohFUEAIQoDQCAeQeAAaiAKaiBtOAIAIApBBGoiCkEgRw0ACyAeKgJ8IX0gHioCeCF+IB4qAnQhfyAeKgJwIYABIB4qAmwhgQEgHioCaCGCASAeKgJkIYMBIB4qAmAhhAFBACEKA0AgHkHgAGogCmogbjgCACAKQQRqIgpBIEcNAAsgHkEYaiIUIB5B+ABqIhopAgA3AwAgHkEQaiIyIB5B8ABqIj8pAgA3AwAgHkEIaiI8IB5B6ABqIkApAgA3AwAgHiAeKQJgNwMAIDMgOE0EQCBDQQhPBEAgJCEGIAUhCgNAIApBBGoiSioCACFtIApBCGoiTCoCACFuIApBDGoiVCoCACFvIApBEGoiVSoCACFwIApBFGoiVioCACFxIApBGGoiVyoCACFyIAoqAgAhcyAeIApBHGoiWCoCACB9kzgCPCAeIHIgfpM4AjggHiBxIH+TOAI0IB4gcCCAAZM4AjAgHiBvIIEBkzgCLCAeIG4gggGTOAIoIB4gbSCDAZM4AiQgHiBzIIQBkzgCICAaIBQpAwA3AwAgPyAyKQMANwMAIEAgPCkDADcDACAeIB4pAwA3A2AgHkEgaiIEQQBB7N/MABCiLioCACFtIB5B4ABqIghBAEH838wAEKIuKgIAIW4gBEEBQYzgzAAQoi4qAgAhbyAIQQFBnODMABCiLioCACFwIARBAkGs4MwAEKIuKgIAIXEgCEECQbzgzAAQoi4qAgAhciAEQQNBzODMABCiLioCACFzIAhBA0Hc4MwAEKIuKgIAIXQgBEEEQezgzAAQoi4qAgAhdSAIQQRB/ODMABCiLioCACF2IARBBUGM4cwAEKIuKgIAIXcgCEEFQZzhzAAQoi4qAgAheCAEQQZBrOHMABCiLioCACF5IAhBBkG84cwAEKIuKgIAIXogBEEHQczhzAAQoi4qAgAheyAIQQdB3OHMABCiLiFLIB4geSB6YEEGdDYCWCAeIHcgeGBBBXQ2AlQgHiB1IHZgQQR0NgJQIB4gcyB0YEEDdDYCTCAeIHEgcmBBAnQ2AkggHiBvIHBgQQF0NgJEIB4gbSBuYDYCQCAeIHsgSyoCAGBBB3Q2AlwgHkFAaxDMKyFLIAYgH08NBCAGIC9qIk0gTS0AACBLcjoAACAaIBQpAwA3AwAgPyAyKQMANwMAIEAgPCkDADcDACAeIB4pAwA3A2AgBEEAQezhzAAQoi4qAgAhbSAIQQBB/OHMABCiLioCACFuIARBAUGM4swAEKIuKgIAIW8gCEEBQZzizAAQoi4qAgAhcCAEQQJBrOLMABCiLioCACFxIAhBAkG84swAEKIuKgIAIXIgBEEDQczizAAQoi4qAgAhcyAIQQNB3OLMABCiLioCACF0IARBBEHs4swAEKIuKgIAIXUgCEEEQfzizAAQoi4qAgAhdiAEQQVBjOPMABCiLioCACF3IAhBBUGc48wAEKIuKgIAIXggBEEGQazjzAAQoi4qAgAheSAIQQZBvOPMABCiLioCACF6IARBB0HM48wAEKIuKgIAIXsgCEEHQdzjzAAQoi4qAgAhfCBXIHkgeiB5IHpdGzgCACBWIHcgeCB3IHhdGzgCACBVIHUgdiB1IHZdGzgCACBUIHMgdCBzIHRdGzgCACBMIHEgciBxIHJdGzgCACBKIG8gcCBvIHBdGzgCACAKIG0gbiBtIG5dGzgCACBYIHsgfCB7IHxdGzgCACAGQQFqIQYgCkEgaiIKIFBHDQALCyAkIDNqISQgFSBIRw0BDAgLCyAzIDhBzN/MABCwOwALIAYgH0Hc38wAEMMhAAsgEiALQczVzAAQsDsACyAEIB9BvNXMABCwOwALIAQgLEGs1cwAELA7AAsgMSAxQZzYzAAQwyEACyAsICxBjNjMABDDIQALAkAgMSASQQFrIgZLBEAgBg0BQQEhCAwCCyAGIDFB3NXMABDDIQALIDMgEkECayIUbCEEIAYgQmotAAAhCiAUIQZBASEIAkACQANAIAQgCkEDdkEfcWoiGiAfTw0BIBogL2otAAAgCkEHcXZBAXEEQCAGIDFPDQMgCCAKQf8BcSAGIEJqLQAAIgpHaiEICyAUIDFJBEAgBiBCaiAKOgAAIAQgM2shBCAGQQFrIgZBf0YNBAwBCwsgBiAxQYzWzAAQwyEACyAKQfgBcUEDdiAEaiAfQezVzAAQwyEACyAGIDFB/NXMABDDIQALIB5BgAFqJAAgDyEEAkACQAJAIEIgMSASIDcgOSAQEJYSIhAgLk0EQCAQBEAgGCAQQYgWbGohCiAYIQYDQCAGQQBBhBb8CwAgBkGEFmpBo+D/+wc2AgAgBkGIFmoiBiAKRw0ACwsCQCASBEBBACEGA0AgBiAxRg0EIC4gBiBCai0AACIKTQ0FIAYgC0YNAiAYIApBiBZsaiAELwEAELcpIARBAmohBCASIAZBAWoiBkcNAAsLDAQLIAsgC0G838wAEMMhAAsgECAuQazqzAAQsDsACyAxIDFBnN/MABDDIQALIAogLkGs38wAEMMhAAsgB0EBayIHDQALICwEQCAOICxBAnRBBBD4OgsgOARAIAUgOEEFdEEEEPg6CyArIC8gHxDgNSA5BEAgNyA5QQF0QQIQ+DoLIC4EQCAYIC5BiBZsQQQQ+DoLQQAhCkEAIS9BACEaQQAhP0EAITwjAEGgNWsiEyQAIBNBiAFqICsgCCIVELkpIBMoAowBITkgEygCiAEhFCATQYABaiArIAgQuSkgEygChAEhNyATKAKAASEsIBNBmB9qIgVBAEGEFvwLACATQaPg//sHNgKcNSATQZAJaiIEIAUgCEEEdEHwB2pBBnYiCBCEHCATQfgAaiAEQcyCzgAQnCEgEygCfCEkIBMoAnghIiATQfAAaiArIAgQuSkgEygCdCEOIBMoAnAhByAFQQBBhBb8CwAgE0Gj4P/7BzYCnDUgBCAFQcAAIBUgFUHAAE8bEIQcIBNB6ABqIARBzILOABCcISATKAJsIT4gEygCaCFAIBNBoB9qQgA3AwAgE0IANwOYHyAEIAVBgRAQgxwgE0HgAGogBEHMgs4AEJ0hIBMoAmQhLiATKAJgIR9BACIFRQRAIBNBkAFqQQBBgAL8CwALIBNBkANqQQBBgAL8CwAgE0GQBWpBAEGAAvwLACATQZAHakEAQYAC/AsAIBIEQCASQQFrIQYDQAJAAkACQCAKIDdJBEAgLCAKQQJ0aiIEIAQoAgBBAWo2AgAgBUEBaiEEIAUgBkcNAQwCCyAKIDdB/NzMABDDIQALAkAgBSAxSQRAIAQgMU8NASAFIEJqIgUtAAAgBUEBai0AAEcNAgwDCyAFIDFBjN3MABDDIQALDDkLIApBAWohCgsgBCIFIBJHDQALCyAPITMgCyEeAkAgFUUEQCAOIQQgByEYDAELIBQhECAVITggCCEPQQAhHAJAAkACQANAQcAAIBUgHGsiBCAEQcAATxshC0EBQcAAIDggOEHAAE8bIgQgBEEBTRshSEEAITICQAJAAkACQAJAAkACQANAIDIgPkYNASBAIDJBiBZsaiIEQQBBgBb8CwAgBEKAgICAsIT8v/8ANwKAFiAcIDJqIgUgN08NAiAsIAVBAnRqKAIAIgYEQCAaIB4gGiAeSRshBSAzIBpBAXRqIQoDQCAFIB5GDQUgBCAKLwEAELcpIAVBAWohBSAKQQJqIQogGkEBaiEaIAZBAWsiBg0ACwsgBCAEEKAHOAKEFiAyQQJ0IgQgE0GQBWoiBWogMjYCACATQZADaiIGIARqIDI2AgAgBCATQZABaiIEakEBNgIAIDJBAWoiCiEyIAogSEcNAAsgCCBAID4gBEHAACAFQcAAIAZBwAAgHyAuIAsgC0HAAEGAEBCNBiJDID9qIgVPDQYgCCAFIAgbIQoDQCAKIgRBAXQhCiAEIAVJDQALIBNBmB9qIgVBAEGEFvwLACATQaPg//sHNgKcNSATQZAJaiIGIAUgBBCEHCATQdgAaiAGQcyCzgAQnCEgCCATKAJcIgVLDQMgCCAkSw0EIBMoAlghBgJAIAhFDQAgCEGIFmwiCkUNACAGICIgCvwKAAALICRFDQUgIiAkQYgWbEEEEPg6DAULID4gPkHM3MwAEMMhAAsgNyAcIBwgN0kbIDdB3NzMABDDIQALIBogHkHs3MwAEMMhAAsgCCAFQYzbzAAQsDsACyAIICRBnNvMABCwOwALIAUhJCAGISIgBCEICwJAIDwgQ2oiBCAPTQRAIA4hBCAHIRggDyELDAELIA8gBCAPGyEFA0AgBSILQQF0IQUgBCALSw0ACyATQdAAaiArIAsQuSkCQCATKAJUIgQgD08EQCAOIA9JDQEgEygCUCEYIA9BAnQiBQRAIBggByAF/AoAAAsgByAOEIAxDAILIA8gBEGs28wAELA7AAsgDyAOQbzbzAAQsDsACyBDBEBBACEFIAQgPGsiBkEAIAQgBk8bIQcgJCA/ayIGQQAgBiAkTRshDiAYIDxBAnRqIQ8gIiA/QYgWbGohMiATQZADaiEKA0AgBUHAAEYNOCAKKAIAIgYgPk8NAyAFIA5GDQQgMiBAIAZBiBZsakGIFvwKAAAgBkHAAE8NOSAFIAdGDT0gDyATQZABaiAGQQJ0aigCADYCACAKKAIAIgZBwABPDTogE0GQB2ogBkECdGogBTYCACAKQQRqIQogD0EEaiEPIDJBiBZqITIgBUEBaiIFIENHDQALIAUgPGohPCAFID9qIT8LQQAhCiATQZAFaiEFIBAhBgJAA0AgBSgCACIHQT9LDQUgCiAcaiIPIDlPDQEgBiATQZAHaiAHQQJ0aigCACAvajYCACAFQQRqIQUgBkEEaiEGIEggCkEBaiIKRw0ACyAQQYACaiEQIDhBQGohOCAvIENqIS8gCyEPIBghByAEIQ4gHEFAayIcIBVPDQUMAQsLIA8gOUHc28wAEMMhAAsgBiA+QfzbzAAQwyEACyAFID9qICRBjNzMABDDIQALIAdBwABBzNvMABDDIQALIBNBADYCoB8gE0KAgICAwAA3ApgfIBNByABqIBNBmB9qQYyHzgAQnCEgEygCTCE4IBMoAkghPyA+BEAgQCA+QYgWbEEEEPg6CwJAIC9BAXYgL2wiBSAvQQZ0IgYgBSAGSRsiC0GAEE0EQCAuIQYgHyEPDAELIBNBoB9qQgA3AwAgE0IANwOYHyATQZAJaiIFIBNBmB9qIAtBAWoQgxwgE0FAayAFQcyCzgAQnSEgEygCRCEGIBMoAkAhDyAuRQ0AIB8gLkEEdEEEEPg6CyATQThqICsgLxC5KQJAIBMoAjwiCCAvTwRAIBMoAjghByAvBEAgL0ECdCEaQQAhBSAHIQoDQCAKIAU2AgAgBUEBaiEFIApBBGohCiAaQQRrIhoNAAsLICIgJCAYIAQgFCA5IAcgCCAPIAYgLyAVQYACIAsQjQYhCyATQQA2AqAfIBNCgICAgMAANwKYHyATQTBqIBNBmB9qQYyHzgAQnSEgEygCNCEuIBMoAjAhPiAGBEAgDyAGQQR0QQQQ+DoLIBNBKGoQ/icgEygCLCEfIBMoAighPCAYIAQQgDEgE0EgaiArIC8QuSkgEygCICEYAkAgEygCJCIQRQ0AIBBBAnQiBEUNACAYQf8BIAT8CwALIBVFDQFBACEPQQAhDkEAIS8CQANAIBNBkAlqQQBBhBb8CwAgE0Gj4P/7BzYClB8CQAJAAkACQCAvIDdHBEAgLCAvQQJ0IhxqKAIAIhoEQCAPIB4gDyAeSRshBSAzIA9BAXRqIQoDQCAFIB5GDQQgE0GQCWogCi8BABC3KSAFQQFqIQUgCkECaiEKIA9BAWohDyAaQQFrIhoNAAsLIC8NASAUIQUgOUUNPQwECyA3IDdB/NnMABDDIQALIC9BAWsiBCA5SQ0BIAQgOUGc2swAEMMhAAsgDyAeQfzazAAQwyEACyAUIARBAnRqIQULAkAgJCAFKAIAIgpLBEAgEygCkB8EfSATQZgfaiATQZAJakGIFvwKAAAgEyAiIApBiBZsaiIEKAKAFiATKAKYNWo2Apg1QQAhBQNAIBNBmB9qIgYgBWoiGiAEIAVqKAIAIBooAgBqNgIAIAVBBGoiBUGAFkcNAAsgBhCgByAEKgKEFpMFQwAAAAALIW0gC0UNAUEAIQYDQAJAAkACfQJAIAYgCEcEQCAHIAZBAnRqIhooAgAiBCAkTw0DIBMoApAfDQFDAAAAAAwCCyAIIAhB3NrMABDDIQALIBNBmB9qIBNBkAlqQYgW/AoAACATICIgBEGIFmxqIgQoAoAWIBMoApg1ajYCmDVBACEFA0AgE0GYH2oiMiAFaiJAIAQgBWooAgAgQCgCAGo2AgAgBUEEaiIFQYAWRw0ACyAyEKAHIAQqAoQWkwsibiBtXUUNASAaKAIAIQogbiFtDAELIAQgJEHs2swAEMMhAAsgBkEBaiIGIAtHDQALDAELIAogJEGs2swAEMMhAAsgLyA5RwRAIBQgHGogCjYCACAKIBBPDQIgGCAKQQJ0aiIEKAIAQX9GBEAgBCAONgIAIA5BAWohDgsgL0EBaiIvIBVHDQEMBAsLIDkgOUG82swAEMMhAAsgCiAQQczazAAQwyEACyAvIAhBzNjMABCwOwALIBNBGGoQ/icgEygCHCEPIBMoAhghDiAHIAgQgDEgE0EANgKgHyATQoCAgIDAADcCmB8gE0EQaiATQZgfakGMh84AEJwhIBMoAhQhCCATKAIQIR4gJARAICIgJEGIFmxBBBD4OgsCQCAVIBsoAgQiBE0EQCAEIRwMAQsgBCAVIAQbIQUDQCAFIgZBAXQhBSAGIBVJDQALIBNBCGogKyAGELgpIBMoAgwiHCAETwRAIBMoAggiBSAEIBsoAgAgBEHs2MwAENUsIBsoAgQhBCAbIBw2AgQgGygCACEGIBsgBTYCACArIAYgBBDgNQwBCyAEIBxB3NjMABCwOwALAkACQAJAAkACQAJAAkACQCAbAn8CQCAVIBsoAgwiBEsEQCAEIBUgBBshBQNAIAUiBkEBdCEFIAYgFUkNAAsgEyArIAYQuSkgBCATKAIEIgdLDQUgEygCACEiIARBAnQiBARAICIgGygCCCAE/AoAAAsgGygCDCEEIBsgBzYCDCAbKAIIIBsgIjYCCCAEEIAxIBsoAgQhHAwBCyAVRQRAQQAhCkEBDAILIBsoAgghIiAEIQcLIBVBAWshJCAbKAIAITNBACEyICwhCyAUIRpBACEKQQAhBkEAIQUDQCAFIDdGDQIgBUEBaiEEIAsoAgAgBmohBgJAIAUgJEcEQCAFIDlPDQcgBCA5Tw1DIBooAgAgGkEEaigCAEYNAQsgBSA5Tw0HIBooAgAiBSAQTw0IIAogHE8NCSAKIDNqIBggBUECdGooAgAiBToAACAHIApNDQQgIiAKQQJ0aiAGNgIAIAVB/wFxIgUgMkH/AXEiBiAFIAZLGyEyIApBAWohCkEAIQYLIAtBBGohCyAaQQRqIRogBCIFIBVHDQALIDJB/wFxQQFqCzYCECAbIAo2AhQgGCAQEIAxICwgNxCAMSAUIDkQgDEgDwRAIA4gD0ECdEEEEPg6CyAuBEAgPiAuQQR0QQQQ+DoLIDgEQCA/IDhBiBZsQQQQ+DoLIB8EQCA8IB9BAnRBBBD4OgsgCARAIB4gCEGIFmxBBBD4OgsgE0GgNWokAAwHCyA3IDdBjNnMABDDIQALIAogB0Hs2cwAEMMhAAsgBCAHQfzYzAAQsDsACyAFIDlBnNnMABDDIQALIAUgOUG82cwAEMMhAAsgBSAQQczZzAAQwyEACyAKIBxB3NnMABDDIQALICsgQiAxEOA1DAELAkAgGygCBCIEIBsoAhQiBUEBaiIQTwRAIAQhBwwBCyAEIBAgBBshBQNAIAUiBkEBdCEFIAYgEEkNAAsgKUEQaiArIAYQuCkgKSgCFCIHIARPBEAgKSgCECIFIAQgGygCACAEQczdzAAQ1SwgGygCBCEEIBsgBzYCBCAbKAIAIQYgGyAFNgIAICsgBiAEEOA1IBsoAhQiBUEBaiEQDAELIAQgB0G83cwAELA7AAsCQAJAAkAgECAbKAIMIgRNBEAgBCEQDAELIAQgECAEGyEFA0AgBSIGQQF0IQUgBiAQSQ0ACyApQQhqICsgBhC5KSAEICkoAgwiEEsNASApKAIIIQUgBEECdCIEBEAgBSAbKAIIIAT8CgAACyAbKAIMIQQgGyAQNgIMIBsoAgggGyAFNgIIIAQQgDEgGygCFCEFIBsoAgQhBwsgG0EBNgIQIAUgB08NASAbKAIAIAVqQQA6AAAgBSAQSQRAIBsgBUEBajYCFCAbKAIIIAVBAnRqIBI2AgAMAwsgBSAQQfzdzAAQwyEACyAEIBBB3N3MABCwOwALIAUgB0Hs3cwAEMMhAAsgKUHgFmokACAgBEAgGSAgQQF0QQIQ+DoLQQAhBSBGQSRqIgQgEkHEntAAEJkVIEZBCGogBEHMgs4AEKohIEYoAgwhHiBGKAIIITgCQAJAIBIEQCAdQQ5qIQ5BACEUA0AgFCA9Rg0CAkAgDkEKaygCAEH///8PcUUNACAOQQJrLwEAQf8ATQ0AIAUgHk8NBCA4IAVBAXRqIA4vAQBB/wdxOwEAIAVBAWohBQsgDkEQaiEOIBIgFEEBaiIURw0ACwsgOCEPIB4hGCAtIRtBACEGQQAhCCMAQeARayIpJAACQCAFIgtFBEAgG0EBNgIQDAELIAtBgAFPBEAgKUHIAGoiFEEAQYQR/AsAIClBo+D/+wc2AswRIClB1BFqIhogFEEyIAtBoARuQQFqIgQgBEEyTxsiEBCCHCApQUBrIBpBzILOABCgISApKAJAIhUhBSApKAJEIi4hBCMAQRBrIgckACAHQQc2AgwCQCAQBEAgCyAQbiEKIAQgEE8EQCAFIBBBiBFsaiEOIAUhBANAIARBAEGEEfwLACAEQYQRakGj4P/7BzYCACAEQYgRaiIEIA5HDQALIAtBKWshDgNAIAYgEG4hBAJAIAhFDQAgB0EMahDdLiEZIAsgEE8EQCAZIApwIARqIQQMAQtB/N7MABDnKwALIAQgDiAEQShqIAtJGyIEIBhLBEAgBCAYQYzfzAAQrzsACyAFIA8gBEEBdGogGCAEa0EoEOIeIAYgC2ohBiAFQYgRaiEFIBAgCEEBaiIIRw0ACyAHQRBqJAAMAgsgECAEQazqzAAQsDsAC0Hs3swAEOIrAAtBACEKIwBBkBFrIgckACAHQQc2AgQCQCAQBEACQCAQIAtBAXRBKG5qQeMAaiIEIAQgEHAiBUcEQCAEIAVrIQ5BACEEA0AgB0EIaiIIQQBBhBH8CwAgB0Gj4P/7BzYCjBEgB0EEaiEZQQAhBgJAAkACQCALIgVBKEsEQCAZEN0uIAtBJ2siBkUNASAGcCIGIBhLDQJBKCEFCyAIIA8gBkEBdGogGCAGayAFEOIeDAILQazYzAAQ5ysACyAGIBhBvNjMABCvOwALIAQgLk8NAiAEQQFqIgVBACAFIBBHGyAKQQFqIQogFSAEQYgRbGoiCCAHKAKIESAIKAKAEWo2AoARQQAhBEEAIQYDQCAIIAZBAnRqIhkgB0EIaiAEaigCACAZKAIAajYCACAGQQFqIQYgBEEEaiIEQYARRw0ACyEEIAogDkkNAAsLIAdBkBFqJAAMAgsgBCAuQdzezAAQwyEAC0HM3swAEOIrAAsgKUE4aiArIAsQuCkgKSgCPCExICkoAjghQiAUIBBBoARsEKMVIClBMGogFEHMgs4AEJghICkoAjQhLCApKAIwIQ4gKUHgAGpCADcDACApQdgAakIANwMAIClB0ABqQgA3AwAgKUIANwNIIBogFCAQQQdqQQN2IgQQhxwgKUEoaiAaQcyCzgAQniEgKSgCLCEfICkoAighBSApQSBqICsgBCALbBC4KSApKAIkITMgKSgCICE5IBQgEEHEntAAEJkVIClBGGogFEHMgs4AEKohICkoAhwhMiApKAIYIT5BA0EKIBcoAhRBDEgbIQcDQCAPISJBACEKQQAhCCMAQYABayIgJAACQCAQRQ0AAkACQAJAAkAgLgRAQQEhCCAQQQFHDQEgC0UNBQNAIAogMUYNAyAKIEJqQQA6AAAgCkEBaiIKIAtHDQALDAULDDgLICwgEEGgBGwiBE8EQCAQQYARbCIERSAERXJFBEAgDkEAIAT8CwALIBBBB2oiSEEDdiETIBVBgBFqIQYgDiEEA0AgCiAuRgRAIC4gLkH818wAEMMhAAsCfSAGKAIAIghBgAJPBEAgCLMQ6hIMAQsgCEECdEHAh/MAaioCAAshbSAKICxGDQMgBCBtOAIAIAZBiBFqIQYgBEEEaiEEIBAgCkEBaiIKRw0ACyAQQQJ0ISQgEEH8EGwhFCAQQZ8EbCEIIBVB/BBqIRpBoAQhGQNAIBlBAWshGUEAIQogDiEGIBohBAJAAkACQANAIAogLEYNASAKIC5GDQIgBioCACFtIAQoAgAQuSwhbiAsIAggCmoiHEsEQCAGIBRqIG0gbpM4AgAgBkEEaiEGIARBiBFqIQQgECAKQQFqIgpGDQQMAQsLIBwgLEHs18wAEMMhAAsgLCAsQczXzAAQwyEACyAuIC5B3NfMABDDIQALIBQgJGshFCAIIBBrIQggGkEEayEaIBkNAAsgHwRAIB9BBXQhBiAFIQoDQCAKQgA3AgAgCkEYakIANwIAIApBEGpCADcCACAKQQhqQgA3AgAgCkEgaiEKIAZBIGsiBg0ACwsgMyALIBNsIgRPBEAgBARAIDlBACAE/AsACyALIBhNBEAgC0UNBSAiIAtBAXRqIVAgEEF4cSEZIBBBB3EiP0ECdCEcIAUgE0EFdGohUSAFIBBBA3YiUkEFdGohUyAQQQhJIUpBACEkQQAhLwJAA0AgLyAxRgRAIDEgMUGc1swAEMMhAAsCQAJAAkAgECAiLwEAbCI3ICxNBEAgHyBSSQ0BIC8gQmohPEOZdpZ+IW0gSg0DICwgN2shQCAOIDdBAnRqIUNBACEUQQAhGiAFIQQDQCAaQQN0IgYgQEsEQCAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpBnNfMABDvLAALIEAgBmtBB00NAyAEQSBqIBpBAWohGiAgQfgAaiBDIAZBAnRqIgZBGGopAgA3AwAgIEHwAGogBkEQaikCADcDACAgQegAaiAGQQhqKQIANwMAICAgBikCADcDYEEAIQpBACEGA0AgBCAKaiJMICBB4ABqIApqKgIAIEwqAgCSOAIAIG0gBCAGQbzXzAAQoi4qAgAibl4EQCA8IAYgFGo6AAAgbiFtCyAKQQRqIQogBkEBaiIGQQhHDQALIBRBCGohFCIEIFNHDQALDAMLICBBADYCcCAgQQE2AmQgIEHg0swANgJgICBCBDcCaCAgQeAAakGs1swAEO8sAAsgIEEANgJwICBBATYCZCAgQeDSzAA2AmAgIEIENwJoICBB4ABqQbzWzAAQ7ywACyAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpBrNfMABDvLAALAkACQCAZIDdqIgQgLE0EQCA/ICwgBGtLDQECQCA/BEAgDiAEQQJ0aiEGQQAhCiAcIRQgBSEEIBkhCANAIAogGWoiN0EDdiIaIB9PDQIgBCAIQQJ0QWBxaiJAIAYqAgAgQCoCAJI4AgAgbSAFIBpBBXRqIhogCkH81swAEKIuKgIAXgRAIBogCkGM18wAEKIuIDwgNzoAACoCACFtCyAGQQRqIQYgBEEEaiEEIApBAWohCiAIQQFqIQggFEEEayIUDQALC0OamWlBIW4gL0HQD08NAyAvs0MpXI89lEMAAPpElUO4HkU/kkOamWlBlCFuDAMLIBogH0Hs1swAEMMhAAsgIEEANgJwICBBATYCZCAgQeDSzAA2AmAgIEIENwJoICBB4ABqQczWzAAQ7ywACyAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpB3NbMABDvLAALIC9BAWohLyAiQQJqISJBACEKA0AgIEHgAGogCmogbTgCACAKQQRqIgpBIEcNAAsgICoCfCF9ICAqAnghfiAgKgJ0IX8gICoCcCGAASAgKgJsIYEBICAqAmghggEgICoCZCGDASAgKgJgIYQBQQAhCgNAICBB4ABqIApqIG44AgAgCkEEaiIKQSBHDQALICBBGGoiFCAgQfgAaiIaKQIANwMAICBBEGoiNyAgQfAAaiI8KQIANwMAICBBCGoiQCAgQegAaiJDKQIANwMAICAgICkCYDcDACATIB9NBEAgSEEITwRAICQhBiAFIQoDQCAKQQRqIkwqAgAhbSAKQQhqIlQqAgAhbiAKQQxqIlUqAgAhbyAKQRBqIlYqAgAhcCAKQRRqIlcqAgAhcSAKQRhqIlgqAgAhciAKKgIAIXMgICAKQRxqIksqAgAgfZM4AjwgICByIH6TOAI4ICAgcSB/kzgCNCAgIHAggAGTOAIwICAgbyCBAZM4AiwgICBuIIIBkzgCKCAgIG0ggwGTOAIkICAgcyCEAZM4AiAgGiAUKQMANwMAIDwgNykDADcDACBDIEApAwA3AwAgICAgKQMANwNgICBBIGoiBEEAQezfzAAQoi4qAgAhbSAgQeAAaiIIQQBB/N/MABCiLioCACFuIARBAUGM4MwAEKIuKgIAIW8gCEEBQZzgzAAQoi4qAgAhcCAEQQJBrODMABCiLioCACFxIAhBAkG84MwAEKIuKgIAIXIgBEEDQczgzAAQoi4qAgAhcyAIQQNB3ODMABCiLioCACF0IARBBEHs4MwAEKIuKgIAIXUgCEEEQfzgzAAQoi4qAgAhdiAEQQVBjOHMABCiLioCACF3IAhBBUGc4cwAEKIuKgIAIXggBEEGQazhzAAQoi4qAgAheSAIQQZBvOHMABCiLioCACF6IARBB0HM4cwAEKIuKgIAIXsgCEEHQdzhzAAQoi4hTSAgIHkgemBBBnQ2AlggICB3IHhgQQV0NgJUICAgdSB2YEEEdDYCUCAgIHMgdGBBA3Q2AkwgICBxIHJgQQJ0NgJIICAgbyBwYEEBdDYCRCAgIG0gbmA2AkAgICB7IE0qAgBgQQd0NgJcICBBQGsQzCshTSAGIDNPDQQgBiA5aiJfIF8tAAAgTXI6AAAgGiAUKQMANwMAIDwgNykDADcDACBDIEApAwA3AwAgICAgKQMANwNgIARBAEHs4cwAEKIuKgIAIW0gCEEAQfzhzAAQoi4qAgAhbiAEQQFBjOLMABCiLioCACFvIAhBAUGc4swAEKIuKgIAIXAgBEECQazizAAQoi4qAgAhcSAIQQJBvOLMABCiLioCACFyIARBA0HM4swAEKIuKgIAIXMgCEEDQdzizAAQoi4qAgAhdCAEQQRB7OLMABCiLioCACF1IAhBBEH84swAEKIuKgIAIXYgBEEFQYzjzAAQoi4qAgAhdyAIQQVBnOPMABCiLioCACF4IARBBkGs48wAEKIuKgIAIXkgCEEGQbzjzAAQoi4qAgAheiAEQQdBzOPMABCiLioCACF7IAhBB0Hc48wAEKIuKgIAIXwgWCB5IHogeSB6XRs4AgAgVyB3IHggdyB4XRs4AgAgViB1IHYgdSB2XRs4AgAgVSBzIHQgcyB0XRs4AgAgVCBxIHIgcSByXRs4AgAgTCBvIHAgbyBwXRs4AgAgCiBtIG4gbSBuXRs4AgAgSyB7IHwgeyB8XRs4AgAgBkEBaiEGIApBIGoiCiBRRw0ACwsgEyAkaiEkICIgUEcNAQwICwsgEyAfQczfzAAQsDsACyAGIDNB3N/MABDDIQALIAsgGEHM1cwAELA7AAsgBCAzQbzVzAAQsDsACyAEICxBrNXMABCwOwALIDEgMUGc2MwAEMMhAAsgLCAsQYzYzAAQwyEACwJAIDEgC0EBayIGSwRAIAYNAUEBIQgMAgsgBiAxQdzVzAAQwyEACyATIAtBAmsiFGwhBCAGIEJqLQAAIQogFCEGQQEhCAJAAkADQCAEIApBA3ZBH3FqIhogM08NASAaIDlqLQAAIApBB3F2QQFxBEAgBiAxTw0DIAggCkH/AXEgBiBCai0AACIKR2ohCAsgFCAxSQRAIAYgQmogCjoAACAEIBNrIQQgBkEBayIGQX9GDQQMAQsLIAYgMUGM1swAEMMhAAsgCkH4AXFBA3YgBGogM0Hs1cwAEMMhAAsgBiAxQfzVzAAQwyEACyAgQYABaiQAIA8hBAJAAkACQCBCIDEgCyA+IDIgEBCWEiIQIC5NBEAgEARAIBUgEEGIEWxqIQogFSEGA0AgBkEAQYQR/AsAIAZBhBFqQaPg//sHNgIAIAZBiBFqIgYgCkcNAAsLAkAgCwRAQQAhBgNAIAYgMUYNBCAuIAYgQmotAAAiCk0NBSAGIBhGDQIgFSAKQYgRbGogBC8BABC1KSAEQQJqIQQgCyAGQQFqIgZHDQALCwwECyAYIBhBvN/MABDDIQALIBAgLkGs6swAELA7AAsgMSAxQZzfzAAQwyEACyAKIC5BrN/MABDDIQALIAdBAWsiBw0ACyAsBEAgDiAsQQJ0QQQQ+DoLIB8EQCAFIB9BBXRBBBD4OgsgKyA5IDMQ4DUgMgRAID4gMkEBdEECEPg6CyAuBEAgFSAuQYgRbEEEEPg6C0EAIQpBACEvQQAhGkEAIT9BACE8IwBBoCtrIhMkACATQYgBaiArIAgiFRC5KSATKAKMASE5IBMoAogBIRQgE0GAAWogKyAIELkpIBMoAoQBITcgEygCgAEhICATQZgaaiIFQQBBhBH8CwAgE0Gj4P/7BzYCnCsgE0GQCWoiBCAFIAhBBHRB8AdqQQZ2IggQghwgE0H4AGogBEHMgs4AEKAhIBMoAnwhIiATKAJ4IRkgE0HwAGogKyAIELkpIBMoAnQhDiATKAJwIQcgBUEAQYQR/AsAIBNBo+D/+wc2ApwrIAQgBUHAACAVIBVBwABPGxCCHCATQegAaiAEQcyCzgAQoCEgEygCbCE+IBMoAmghQCATQaAaakIANwMAIBNCADcDmBogBCAFQYEQEIMcIBNB4ABqIARBzILOABCdISATKAJkISwgEygCYCEfQQAiBUUEQCATQZABakEAQYAC/AsACyATQZADakEAQYAC/AsAIBNBkAVqQQBBgAL8CwAgE0GQB2pBAEGAAvwLACALBEAgC0EBayEGA0ACQAJAAkAgCiA3SQRAICAgCkECdGoiBCAEKAIAQQFqNgIAIAVBAWohBCAFIAZHDQEMAgsgCiA3QfzczAAQwyEACwJAIAUgMUkEQCAEIDFPDQEgBSBCaiIFLQAAIAVBAWotAABHDQIMAwsgBSAxQYzdzAAQwyEACww7CyAKQQFqIQoLIAQiBSALRw0ACwsgDyEzIBghHAJAIBVFBEAgDiEEIAchGAwBCyAUIRAgFSEuIAghD0EAISQCQAJAAkADQEHAACAVICRrIgQgBEHAAE8bIQtBAUHAACAuIC5BwABPGyIEIARBAU0bIUhBACEyAkACQAJAAkACQAJAAkADQCAyID5GDQEgQCAyQYgRbGoiBEEAQYAR/AsAIARCgICAgLCE/L//ADcCgBEgJCAyaiIFIDdPDQIgICAFQQJ0aigCACIGBEAgGiAcIBogHEkbIQUgMyAaQQF0aiEKA0AgBSAcRg0FIAQgCi8BABC1KSAFQQFqIQUgCkECaiEKIBpBAWohGiAGQQFrIgYNAAsLIAQgBBCiBzgChBEgMkECdCIEIBNBkAVqIgVqIDI2AgAgE0GQA2oiBiAEaiAyNgIAIAQgE0GQAWoiBGpBATYCACAyQQFqIgohMiAKIEhHDQALIAggQCA+IARBwAAgBUHAACAGQcAAIB8gLCALIAtBwABBgBAQjgYiQyA/aiIFTw0GIAggBSAIGyEKA0AgCiIEQQF0IQogBCAFSQ0ACyATQZgaaiIFQQBBhBH8CwAgE0Gj4P/7BzYCnCsgE0GQCWoiBiAFIAQQghwgE0HYAGogBkHMgs4AEKAhIAggEygCXCIFSw0DIAggIksNBCATKAJYIQYCQCAIRQ0AIAhBiBFsIgpFDQAgBiAZIAr8CgAACyAiRQ0FIBkgIkGIEWxBBBD4OgwFCyA+ID5BzNzMABDDIQALIDcgJCAkIDdJGyA3QdzczAAQwyEACyAaIBxB7NzMABDDIQALIAggBUGM28wAELA7AAsgCCAiQZzbzAAQsDsACyAFISIgBiEZIAQhCAsCQCA8IENqIgQgD00EQCAOIQQgByEYIA8hCwwBCyAPIAQgDxshBQNAIAUiC0EBdCEFIAQgC0sNAAsgE0HQAGogKyALELkpAkAgEygCVCIEIA9PBEAgDiAPSQ0BIBMoAlAhGCAPQQJ0IgUEQCAYIAcgBfwKAAALIAcgDhCAMQwCCyAPIARBrNvMABCwOwALIA8gDkG828wAELA7AAsgQwRAQQAhBSAEIDxrIgZBACAEIAZPGyEHICIgP2siBkEAIAYgIk0bIQ4gGCA8QQJ0aiEPIBkgP0GIEWxqITIgE0GQA2ohCgNAIAVBwABGDTogCigCACIGID5PDQMgBSAORg0EIDIgQCAGQYgRbGpBiBH8CgAAIAZBwABPDTsgBSAHRg0/IA8gE0GQAWogBkECdGooAgA2AgAgCigCACIGQcAATw08IBNBkAdqIAZBAnRqIAU2AgAgCkEEaiEKIA9BBGohDyAyQYgRaiEyIAVBAWoiBSBDRw0ACyAFIDxqITwgBSA/aiE/C0EAIQogE0GQBWohBSAQIQYCQANAIAUoAgAiB0E/Sw0FIAogJGoiDyA5Tw0BIAYgE0GQB2ogB0ECdGooAgAgL2o2AgAgBUEEaiEFIAZBBGohBiBIIApBAWoiCkcNAAsgEEGAAmohECAuQUBqIS4gLyBDaiEvIAshDyAYIQcgBCEOICRBQGsiJCAVTw0FDAELCyAPIDlB3NvMABDDIQALIAYgPkH828wAEMMhAAsgBSA/aiAiQYzczAAQwyEACyAHQcAAQczbzAAQwyEACyATQQA2AqAaIBNCgICAgMAANwKYGiATQcgAaiATQZgaakGMh84AEKAhIBMoAkwhLiATKAJIIT8gPgRAIEAgPkGIEWxBBBD4OgsCQCAvQQF2IC9sIgUgL0EGdCIGIAUgBkkbIgtBgBBNBEAgLCEGIB8hDwwBCyATQaAaakIANwMAIBNCADcDmBogE0GQCWoiBSATQZgaaiALQQFqEIMcIBNBQGsgBUHMgs4AEJ0hIBMoAkQhBiATKAJAIQ8gLEUNACAfICxBBHRBBBD4OgsgE0E4aiArIC8QuSkCQCATKAI8IgggL08EQCATKAI4IQcgLwRAIC9BAnQhGkEAIQUgByEKA0AgCiAFNgIAIAVBAWohBSAKQQRqIQogGkEEayIaDQALCyAZICIgGCAEIBQgOSAHIAggDyAGIC8gFUGAAiALEI4GIQsgE0EANgKgGiATQoCAgIDAADcCmBogE0EwaiATQZgaakGMh84AEJ0hIBMoAjQhLCATKAIwIT4gBgRAIA8gBkEEdEEEEPg6CyATQShqEP4nIBMoAiwhHyATKAIoITwgGCAEEIAxIBNBIGogKyAvELkpIBMoAiAhGAJAIBMoAiQiEEUNACAQQQJ0IgRFDQAgGEH/ASAE/AsACyAVRQ0BQQAhD0EAIQ5BACEvAkADQCATQZAJakEAQYQR/AsAIBNBo+D/+wc2ApQaAkACQAJAAkAgLyA3RwRAICAgL0ECdCIkaigCACIaBEAgDyAcIA8gHEkbIQUgMyAPQQF0aiEKA0AgBSAcRg0EIBNBkAlqIAovAQAQtSkgBUEBaiEFIApBAmohCiAPQQFqIQ8gGkEBayIaDQALCyAvDQEgFCEFIDlFDT8MBAsgNyA3QfzZzAAQwyEACyAvQQFrIgQgOUkNASAEIDlBnNrMABDDIQALIA8gHEH82swAEMMhAAsgFCAEQQJ0aiEFCwJAICIgBSgCACIKSwRAIBMoApAaBH0gE0GYGmogE0GQCWpBiBH8CgAAIBMgGSAKQYgRbGoiBCgCgBEgEygCmCtqNgKYK0EAIQUDQCATQZgaaiIGIAVqIhogBCAFaigCACAaKAIAajYCACAFQQRqIgVBgBFHDQALIAYQogcgBCoChBGTBUMAAAAACyFtIAtFDQFBACEGA0ACQAJAAn0CQCAGIAhHBEAgByAGQQJ0aiIaKAIAIgQgIk8NAyATKAKQGg0BQwAAAAAMAgsgCCAIQdzazAAQwyEACyATQZgaaiATQZAJakGIEfwKAAAgEyAZIARBiBFsaiIEKAKAESATKAKYK2o2ApgrQQAhBQNAIBNBmBpqIjIgBWoiQCAEIAVqKAIAIEAoAgBqNgIAIAVBBGoiBUGAEUcNAAsgMhCiByAEKgKEEZMLIm4gbV1FDQEgGigCACEKIG4hbQwBCyAEICJB7NrMABDDIQALIAZBAWoiBiALRw0ACwwBCyAKICJBrNrMABDDIQALIC8gOUcEQCAUICRqIAo2AgAgCiAQTw0CIBggCkECdGoiBCgCAEF/RgRAIAQgDjYCACAOQQFqIQ4LIC9BAWoiLyAVRw0BDAQLCyA5IDlBvNrMABDDIQALIAogEEHM2swAEMMhAAsgLyAIQczYzAAQsDsACyATQRhqEP4nIBMoAhwhDyATKAIYIQ4gByAIEIAxIBNBADYCoBogE0KAgICAwAA3ApgaIBNBEGogE0GYGmpBjIfOABCgISATKAIUIQggEygCECEcICIEQCAZICJBiBFsQQQQ+DoLAkAgFSAbKAIEIgRNBEAgBCEkDAELIAQgFSAEGyEFA0AgBSIGQQF0IQUgBiAVSQ0ACyATQQhqICsgBhC4KSATKAIMIiQgBE8EQCATKAIIIgUgBCAbKAIAIARB7NjMABDVLCAbKAIEIQQgGyAkNgIEIBsoAgAhBiAbIAU2AgAgKyAGIAQQ4DUMAQsgBCAkQdzYzAAQsDsACwJAAkACQAJAAkACQAJAAkAgGwJ/AkAgFSAbKAIMIgRLBEAgBCAVIAQbIQUDQCAFIgZBAXQhBSAGIBVJDQALIBMgKyAGELkpIAQgEygCBCIHSw0FIBMoAgAhGSAEQQJ0IgQEQCAZIBsoAgggBPwKAAALIBsoAgwhBCAbIAc2AgwgGygCCCAbIBk2AgggBBCAMSAbKAIEISQMAQsgFUUEQEEAIQpBAQwCCyAbKAIIIRkgBCEHCyAVQQFrISIgGygCACEzQQAhMiAgIQsgFCEaQQAhCkEAIQZBACEFA0AgBSA3Rg0CIAVBAWohBCALKAIAIAZqIQYCQCAFICJHBEAgBSA5Tw0HIAQgOU8NRSAaKAIAIBpBBGooAgBGDQELIAUgOU8NByAaKAIAIgUgEE8NCCAKICRPDQkgCiAzaiAYIAVBAnRqKAIAIgU6AAAgByAKTQ0EIBkgCkECdGogBjYCACAFQf8BcSIFIDJB/wFxIgYgBSAGSxshMiAKQQFqIQpBACEGCyALQQRqIQsgGkEEaiEaIAQiBSAVRw0ACyAyQf8BcUEBags2AhAgGyAKNgIUIBggEBCAMSAgIDcQgDEgFCA5EIAxIA8EQCAOIA9BAnRBBBD4OgsgLARAID4gLEEEdEEEEPg6CyAuBEAgPyAuQYgRbEEEEPg6CyAfBEAgPCAfQQJ0QQQQ+DoLIAgEQCAcIAhBiBFsQQQQ+DoLIBNBoCtqJAAMBwsgNyA3QYzZzAAQwyEACyAKIAdB7NnMABDDIQALIAQgB0H82MwAELA7AAsgBSA5QZzZzAAQwyEACyAFIDlBvNnMABDDIQALIAUgEEHM2cwAEMMhAAsgCiAkQdzZzAAQwyEACyArIEIgMRDgNQwBCwJAIBsoAgQiBCAbKAIUIgVBAWoiEE8EQCAEIQcMAQsgBCAQIAQbIQUDQCAFIgZBAXQhBSAGIBBJDQALIClBEGogKyAGELgpICkoAhQiByAETwRAICkoAhAiBSAEIBsoAgAgBEHM3cwAENUsIBsoAgQhBCAbIAc2AgQgGygCACEGIBsgBTYCACArIAYgBBDgNSAbKAIUIgVBAWohEAwBCyAEIAdBvN3MABCwOwALAkACQAJAIBAgGygCDCIETQRAIAQhEAwBCyAEIBAgBBshBQNAIAUiBkEBdCEFIAYgEEkNAAsgKUEIaiArIAYQuSkgBCApKAIMIhBLDQEgKSgCCCEFIARBAnQiBARAIAUgGygCCCAE/AoAAAsgGygCDCEEIBsgEDYCDCAbKAIIIBsgBTYCCCAEEIAxIBsoAhQhBSAbKAIEIQcLIBtBATYCECAFIAdPDQEgGygCACAFakEAOgAAIAUgEEkEQCAbIAVBAWo2AhQgGygCCCAFQQJ0aiALNgIADAMLIAUgEEH83cwAEMMhAAsgBCAQQdzdzAAQsDsACyAFIAdB7N3MABDDIQALIClB4BFqJAAgHgRAIDggHkEBdEECEPg6CyBGQTBqJAAMAwsgPSA9QYzezAAQwyEACyAFIB5BnN7MABDDIQALICAgIEGs3swAEMMhAAtBASEHAkAgFygCJARAIEchBSBFIQgMAQsgISgCECEFIwBBIGsiBCQAIARBFGogBUEAQQFBARCgGCAEKAIYIQYgBCgCFEEBRgRAIAYgBCgCHEHEntAAEP0vAAsgBEEQaiIHQQA2AgAgBCAEKAIcNgIMIAQgBjYCCCAEQQhqIAUQhhwgKEG4AWoiBUEIaiAHKAIANgIAIAUgBCkCCDcCACAEQSBqJAAgKEFAayAFQcyCzgAQkCEgKCgCRCEIICgoAkAhBSBFBEAgRyBFQQEQ+DoLQcAAIQcgCEUEQEEAIQgMAQsgCEUNACAFIE4gCPwLAAsgISgCECEKIChBuAFqIgRBAEGECPwLACAoQaPg//sHNgK8CSAoQdAAaiIGIAQgByAKbCIUEIEcIChBOGogBkHMgs4AEKIhICgoAjwhDiAoKAI4IRsgISgCQCEHIARBAEGEEfwLACAoQaPg//sHNgK8EiAGIAQgB0ECdBCCHCAoQTBqIAZBzILOABCgISAoKAI0IRogKCgCMCEVICEgISgCKCIHNgJ8IARBAEGEFvwLACAoQaPg//sHNgK8FyAGIAQgBxCEHCAoQShqIAZBzILOABCcISAoKAIsIQ8gKCgCKCEZICEoAmQiBARAICEoAmAgBEGIFmxBBBD4OgsgISAPNgJkICEgGTYCYEEAIQojAEEwayIGJAAgBiAhKAIMBH8gISgCCCgCAAVBAAs2AgwgBkIANwIEIAYgITYCACAGICcoAgwEfyAnKAIIKAIABUEACzYCHCAGQgA3AhQgBiAnNgIQIAYgLSgCDAR/IC0oAggoAgAFQQALNgIsIAZCADcCJCAGIC02AiAgEgRAA0ACQAJAAkACQCAKID1HBEAgBkEQahCwHiAGKAIYIgQgD08NASAZIARBiBZsaiAdIApBBHRqIhAvAQwiGBC3KSAQKAIAIgtFDQQDQCAGELAeIAYoAgghByAIBEAgByAITw0EIAdBBnQCfwJAAkACQAJAIAUgB2otAABBAWsOAwECAwALIAxBP3EMAwsgDEH8AXFBAnYMAgsgDUH/AXFBtJPiAGotAAAgDEH/AXFBtJHiAGotAAByDAELIA1B/wFxQbSV4gBqLQAAIAxB/wFxQbSV4gBqLQAAQQN0agtB/wFxaiEHCyAHIA5PDQQgKiAJICNxIgRLBEAgGyAHQYgIbGogBCA6ai0AACIEELYpIAlBAWohCSAMIQ0gBCEMIAtBAWsiC0UNBgwBCwsgBCAqQYzszAAQwyEACyA9ID1BnOvMABDDIQALIAQgD0Gs68wAEMMhAAsgByAIQezrzAAQwyEACyAHIA5B/OvMABDDIQALIBAoAgRB////D3EiBCAJaiEJAkAgBEUNAAJAAkACQAJAICogCUECayAjcSIESwRAIAlBAWsgI3EiByAqTw0BIAQgOmotAAAhDSAHIDpqLQAAIQwgGEH/AE0NBSAYQQdxIQQgBkEgahCwHiAGKAIoQQJ0IScgGEEGdiILQQRLQQEgC3RBFXFFcg0CQQMhByAEQQNJDQMMBAsgBCAqQbzrzAAQwyEACyAHICpBzOvMABDDIQALQQMhByALQQdHIARBAktyDQELIAQhBwsgGiAHICdqIgRLBEAgFSAEQYgRbGogEC8BDkH/B3EQtSkMAQsgBCAaQdzrzAAQwyEACyAKQQFqIgogEkcNAAsLIAZBMGokACAIBEAgBSAIQQEQ+DoLICEgISgCEEEGdCIENgJwIChBIGogKyAEELkpICgoAiQhBCAoKAIgIQUgISgCTCIGBEAgISgCSCAGQQJ0QQQQ+DoLICEgBDYCTCAhIAU2AkggISAhKAJwIgQ2AnggKEG4AWoiBUEAQYQI/AsAIChBo+D/+wc2ArwJIChB0ABqIgYgBSAEEIEcIChBGGogBkHMgs4AEKIhICgoAhwhDyAoKAIYIRAgISgCXCIEBEAgISgCWCAEQYgIbEEEEPg6CyAhIA82AlwgISAQNgJYICFB+ABqICEoAkghBiAhKAJMIQpBACEHQQAhGSMAQdAAayInJAACfyAUIgRFBEAgJ0EYahD+JyAnKAIcIS0gJygCGCEMICdBEGoQ/icgJygCFCEUICcoAhAMAQsgJ0EoaiArIAQQuSkgJygCLCEtICcoAighDCAnQSBqICsgBBC5KSAnKAIkIRQgJygCIAshGCAnQcgAakIANwMAICdCADcDQCAnQTRqIgUgJ0FAa0GBEBCDHCAnQQhqIAVBzILOABCdISAnKAIMIQ0gJygCCCEFAkAgBEUNACAMIQkCQAJAAkADQCAHIC1GDQEgCUEBNgIAIAlBBGohCSAEIAdBAWoiB0cNAAtBACEJIAYhC0EAIQcCQAJAAkADQCAHIA5GDQEgByAPRg0CIAkgEGoiCCAJIBtqIiJBhAj8CgAAIAhBhAhqICIQoQc4AgAgByAKRg0DIAsgBzYCACAJQYgIaiEJIAtBBGohCyAHQQFqIgcgBEcNAAsgBCEIQQAhCwNAIBQgGWsiIkEAIBQgIk8bIR5BwAAgBCALayIJIAlBwABPGyEkQQFBwAAgCCAIQcAATxsiCSAJQQFNGyEgIBggGUECdCIsaiEJQQAhBwJAA0AgByAeRg0BIAkgByALajYCACAJQQRqIQkgICAHQQFqIgdHDQALIAogC0kNBiAUIBlJDQcgECAPIAwgLSAGIAtBAnRqIAogC2sgGCAsaiAiIAUgDSAkICRBgAJBgBAQjwYgGWohGSAIQUBqIQggC0FAayILIARPDQgMAQsLIAcgGWogFEHc6MwAEMMhAAsgDiAOQezozAAQwyEACyAPIA9B/OjMABDDIQALIAogCkGM6cwAEMMhAAsgLSAtQZzpzAAQwyEACyALIApBvOjMABCvOwALIBkgFEHM6MwAEK87AAtBgBAhBwJAAkAgGUEBdiAZbCIJIBlBBnQiCCAIIAlLGyILQYAQSQRAIBAgDyAMIC0gBiAKIBggFCAFIA0gGSAEQYACIAsQjwYhByANRQ0CDAELA0AgByIJQQF0IQcgCSALTQ0ACyAnIAkQ4RoCQCAnKAIEIglB/w9LBEAgDUH/D00NASAnKAIAIgggBUGAgAL8CgAAIAUgDUEEdEEEEPg6IBAgDyAMIC0gBiAKIBggFCAIIAkgGSAEQYACIAsQjwYhByAJIQ0gCCEFDAILQYAQIAlBnOjMABCwOwALQYAQIA1BrOjMABCwOwALIAUgDUEEdEEEEPg6CyAMIC0QgDEgGyEJIBghBSAHIQxBACEIIwBBkAhrIg0kAAJAIARFDQACQANAAn8gCEUEQCAGIAoNARpBAEEAQbzkzAAQwyEACyAKIAhBAWsiB00EQCAHIApBzOTMABDDIQALIAYgB0ECdGoLIQcCfQJAIAggDkcEQCAHKAIAIgsgD08NBCAJIAhBiAhsaiIiKAKACCIeDQFDAAAAAAwCCyAOIA5B3OTMABDDIQALIA1BCGogIkGICPwKAAAgDSAQIAtBiAhsaiIZKAKACCANKAKICGo2AogIQQAhBwNAIA1BCGoiLSAHaiIkIAcgGWooAgAgJCgCAGo2AgAgB0EEaiIHQYAIRw0ACyAtEKEHIBkqAoQIkwshbQJAIAxFDQBBACEZAkADQCAUIBlGDQEgDyAFIBlBAnRqKAIAIi1LBEAgHgR9IA1BCGogIkGICPwKAAAgDSAQIC1BiAhsaiIkKAKACCANKAKICGo2AogIQQAhBwNAIA1BCGoiICAHaiIsIAcgJGooAgAgLCgCAGo2AgAgB0EEaiIHQYAIRw0ACyAgEKEHICQqAoQIkwVDAAAAAAsibiBtIG0gbl4iBxshbSAtIAsgBxshCyAZQQFqIhkgDEcNAQwDCwsgLSAPQZzlzAAQwyEACyAUIBRBjOXMABDDIQALIAggCkcEQCAGIAhBAnRqIAs2AgAgCEEBaiIHIQggBCAHRw0BDAMLCyAKIApB/OTMABDDIQALIAsgD0Hs5MwAEMMhAAsCQAJAAkAgDARAQQAhBwNAIAcgFEYNAyAFKAIAIgggD08NAiAQIAhBiAhsaiIIQQBBhAj8CwAgCEGj4P/7BzYChAggBUEEaiEFIAwgB0EBaiIHRw0ACwsgBARAQQAhByAJIQUDQAJAAkAgByAKRwRAIAYgB0ECdGooAgAiCCAPTw0BIAcgDkcEQCAHQQFqIQwgECAIQYgIbGoiCCAJIAdBiAhsaigCgAggCCgCgAhqNgKACEEAIQcDQCAHIAhqIgsgBSAHaigCACALKAIAajYCACAHQQRqIgdBgAhHDQALDAMLIA4gDkGM5MwAEMMhAAsgCiAKQezjzAAQwyEACyAIIA9B/OPMABDDIQALIAVBiAhqIQUgDCIHIARHDQALCyANQZAIaiQADAILIAggD0Gs5MwAEMMhAAsgFCAUQZzkzAAQwyEACyAYIBQQgDFBACEJQQAhBUEAIQdBACEUIwBBMGsiDCQAAkAgBEUEQCAMQQhqEP4nIAwoAgwhBCAMKAIIIAxBADYCLCAMQoCAgIDAADcCJCAMIAxBJGpBjIfOABCiISAMKAIEIQcgDCgCACEIIAQQgDEMAQsgDEEYaiArIAQQuSkgDCgCHCENIAwoAhgiCyEFAkACQAJAA0AgCSANRg0BIAVBfzYCACAFQQRqIQUgBCAJQQFqIglHDQALIAYhBUEAIQkCQAJAA0AgCSAKRg0BIAUoAgAiCCANTw0CIAsgCEECdGoiCCgCAEF/RgRAIAggBzYCACAHQQFqIQcLIAVBBGohBSAEIAlBAWoiCUcNAAsgDEEQaiEJIwBBsAhrIgUkAAJ/IAdFBEAgBUEANgIwIAVCgICAgMAANwIoIAVBCGogBUEoakGMh84AEKIhIAUoAgghByAFKAIMDAELIAVBKGoiCEEAQYQI/AsAIAVBo+D/+wc2AqwIIAVBHGoiGCAIIAcQgRwgBUEQaiAYQcyCzgAQoiEgBSgCECEHIAUoAhQLIQggCSAHNgIAIAkgCDYCBCAFQbAIaiQAQQAhBSAMKAIUIQcgDCgCECEIAkACQAJAAkADQCAKIBRGDQEgBigCACIJIA1PDQIgBSALIAlBAnRqKAIARgRAIAkgD08NBCAFIAdPDQUgCCAFQYgIbGogECAJQYgIbGpBiAj8CgAAIAYoAgAhCSAFQQFqIQULIAkgDU8NCSAGIAsgCUECdGooAgA2AgAgBkEEaiEGIAQgFEEBaiIURw0ACyALIA0QgDEgBUUEQEEAIQUMCgtBACEGQQAhCQNAIAcgCUYNCCAJIA9HBEAgBiAQaiAGIAhqQYgI/AoAACAGQYgIaiEGIAUgCUEBaiIJRg0LDAELCyAPIA9BjOfMABDDIQALIAogCkGc58wAEMMhAAsgCSANQaznzAAQwyEACyAJIA9BvOfMABDDIQALIAUgB0HM58wAEMMhAAsgCiAKQeznzAAQwyEACyAIIA1B/OfMABDDIQALIA0gDUGM6MwAEMMhAAsgByAHQfzmzAAQwyEACyAJIA1B3OfMABDDIQALIAcEQCAIIAdBiAhsQQQQ+DoLIAxBMGokACAFNgIAICdB0ABqJAAgDgRAIBsgDkGICGxBBBD4OgsCQCAXKAIkRQ0AICEoAhAiC0UNACALQQh0IQUgC0EGdEFAaiEMA0AgC0EBayILQQJ0IQYgDCEHQYB+IQgCQAJAA0AgCyAhKAJMIgRPDQEgBCAHSwRAICEoAkgiBCAFaiAIaiAEIAZqKAIANgIAIAdBAWohByAIQQRqIghFDQMMAQsLIAcgBEGc7cwAEMMhAAsgCyAEQYztzAAQwyEACyAFQYACayEFIAxBQGohDCALDQALCyAhICEoAkBBAnQiBDYCdCAoQRBqICsgBBC5KSAoKAIUIQQgKCgCECEFICEoAlQiBgRAICEoAlAgBkECdEEEEPg6CyAhIAQ2AlQgISAFNgJQICEgISgCdCIENgKAASAoQbgBaiIFQQBBhBH8CwAgKEGj4P/7BzYCvBIgKEHQAGoiBiAFIAQQghwgKEEIaiAGQcyCzgAQoCEgKCgCDCEPICgoAgghECAhKAJsIgQEQCAhKAJoIARBiBFsQQQQ+DoLICEgEDYCaCAhIA82AmwgISgCdCEEICFBgAFqICEoAlAhBiAhKAJUIQpBACENQQAhBSMAQdAAayIbJAACfyAERQRAIBtBGGoQ/icgGygCHCEZIBsoAhghCyAbQRBqEP4nIBsoAhQhCCAbKAIQDAELIBtBKGogKyAEELkpIBsoAiwhGSAbKAIoIQsgG0EgaiArIAQQuSkgGygCJCEIIBsoAiALIRQgG0HIAGpCADcDACAbQgA3A0AgG0E0aiIJIBtBQGtBgRAQgxwgG0EIaiAJQcyCzgAQnSEgGygCDCEYIBsoAgghDgJAIARFDQAgCyEHAkACQAJAA0AgDSAZRg0BIAdBATYCACAHQQRqIQcgBCANQQFqIg1HDQALQQAhByAGIQlBACENAkACQAJAA0AgDSAaRg0BIA0gD0YNAiAHIBBqIgwgByAVaiInQYQR/AoAACAMQYQRaiAnEKIHOAIAIAogDUYNAyAJIA02AgAgB0GIEWohByAJQQRqIQkgDUEBaiINIARHDQALIAQhDEEAIQkDQCAIIAVrIidBACAIICdPGyEhQcAAIAQgCWsiByAHQcAATxshLUEBQcAAIAwgDEHAAE8bIgcgB0EBTRshJCAUIAVBAnQiHGohB0EAIQ0CQANAIA0gIUYNASAHIAkgDWo2AgAgB0EEaiEHICQgDUEBaiINRw0ACyAJIApLDQYgBSAISw0HIBAgDyALIBkgBiAJQQJ0aiAKIAlrIBQgHGogJyAOIBggLSAtQYACQYAQEI4GIAVqIQUgDEFAaiEMIAlBQGsiCSAETw0IDAELCyAFIA1qIAhB3OjMABDDIQALIBogGkHs6MwAEMMhAAsgDyAPQfzozAAQwyEACyAKIApBjOnMABDDIQALIBkgGUGc6cwAEMMhAAsgCSAKQbzozAAQrzsACyAFIAhBzOjMABCvOwALQYAQIQ0CQAJAIAVBAXYgBWwiCSAFQQZ0IgcgByAJSxsiDEGAEEkEQCAQIA8gCyAZIAYgCiAUIAggDiAYIAUgBEGAAiAMEI4GIQ0gGEUNAgwBCwNAIA0iCUEBdCENIAkgDE0NAAsgGyAJEOEaAkAgGygCBCIJQf8PSwRAIBhB/w9NDQEgGygCACIHIA5BgIAC/AoAACAOIBhBBHRBBBD4OiAQIA8gCyAZIAYgCiAUIAggByAJIAUgBEGAAiAMEI4GIQ0gCSEYIAchDgwCC0GAECAJQZzozAAQsDsAC0GAECAYQazozAAQsDsACyAOIBhBBHRBBBD4OgsgCyAZEIAxIBUhCSAUIQVBACEMIwBBkBFrIgskAAJAIARFDQACQANAAn8gDEUEQCAGIAoNARpBAEEAQbzkzAAQwyEACyAKIAxBAWsiB00EQCAHIApBzOTMABDDIQALIAYgB0ECdGoLIQcCfQJAIAwgGkcEQCAHKAIAIg4gD08NBCAJIAxBiBFsaiInKAKAESIhDQFDAAAAAAwCCyAaIBpB3OTMABDDIQALIAtBCGogJ0GIEfwKAAAgCyAQIA5BiBFsaiIYKAKAESALKAKIEWo2AogRQQAhBwNAIAtBCGoiGSAHaiItIAcgGGooAgAgLSgCAGo2AgAgB0EEaiIHQYARRw0ACyAZEKIHIBgqAoQRkwshbQJAIA1FDQBBACEYAkADQCAIIBhGDQEgDyAFIBhBAnRqKAIAIhlLBEAgIQR9IAtBCGogJ0GIEfwKAAAgCyAQIBlBiBFsaiItKAKAESALKAKIEWo2AogRQQAhBwNAIAtBCGoiJCAHaiIcIAcgLWooAgAgHCgCAGo2AgAgB0EEaiIHQYARRw0ACyAkEKIHIC0qAoQRkwVDAAAAAAsibiBtIG0gbl4iBxshbSAZIA4gBxshDiAYQQFqIhggDUcNAQwDCwsgGSAPQZzlzAAQwyEACyAIIAhBjOXMABDDIQALIAogDEcEQCAGIAxBAnRqIA42AgAgDEEBaiIHIQwgBCAHRw0BDAMLCyAKIApB/OTMABDDIQALIA4gD0Hs5MwAEMMhAAsCQAJAAkAgDQRAQQAhBwNAIAcgCEYNAyAFKAIAIgwgD08NAiAQIAxBiBFsaiIMQQBBhBH8CwAgDEGj4P/7BzYChBEgBUEEaiEFIA0gB0EBaiIHRw0ACwsgBARAQQAhByAJIQUDQAJAAkAgByAKRwRAIAYgB0ECdGooAgAiDSAPTw0BIAcgGkcEQCAHQQFqIQwgECANQYgRbGoiDSAJIAdBiBFsaigCgBEgDSgCgBFqNgKAEUEAIQcDQCAHIA1qIg4gBSAHaigCACAOKAIAajYCACAHQQRqIgdBgBFHDQALDAMLIBogGkGM5MwAEMMhAAsgCiAKQezjzAAQwyEACyANIA9B/OPMABDDIQALIAVBiBFqIQUgDCIHIARHDQALCyALQZARaiQADAILIAwgD0Gs5MwAEMMhAAsgCCAIQZzkzAAQwyEACyAUIAgQgDEgKyEJQQAhB0EAIQVBACEMQQAhDiMAQTBrIg0kAAJAIARFBEAgDUEIahD+JyANKAIMIQQgDSgCCCANQQA2AiwgDUKAgICAwAA3AiQgDSANQSRqQYyHzgAQoCEgDSgCBCEMIA0oAgAhCCAEEIAxDAELIA1BGGogCSAEELkpIA0oAhwhCSANKAIYIgshBQJAAkACQANAIAcgCUYNASAFQX82AgAgBUEEaiEFIAQgB0EBaiIHRw0ACyAGIQVBACEHAkACQANAIAcgCkYNASAFKAIAIgggCU8NAiALIAhBAnRqIggoAgBBf0YEQCAIIAw2AgAgDEEBaiEMCyAFQQRqIQUgBCAHQQFqIgdHDQALIA1BEGohByMAQbARayIFJAACfyAMRQRAIAVBADYCMCAFQoCAgIDAADcCKCAFQQhqIAVBKGpBjIfOABCgISAFKAIIIQwgBSgCDAwBCyAFQShqIghBAEGEEfwLACAFQaPg//sHNgKsESAFQRxqIhQgCCAMEIIcIAVBEGogFEHMgs4AEKAhIAUoAhAhDCAFKAIUCyEIIAcgDDYCACAHIAg2AgQgBUGwEWokAEEAIQUgDSgCFCEMIA0oAhAhCAJAAkACQAJAA0AgCiAORg0BIAYoAgAiByAJTw0CIAUgCyAHQQJ0aigCAEYEQCAHIA9PDQQgBSAMTw0FIAggBUGIEWxqIBAgB0GIEWxqQYgR/AoAACAGKAIAIQcgBUEBaiEFCyAHIAlPDQkgBiALIAdBAnRqKAIANgIAIAZBBGohBiAEIA5BAWoiDkcNAAsgCyAJEIAxIAVFBEBBACEFDAoLQQAhBkEAIQcDQCAHIAxGDQggByAPRwRAIAYgEGogBiAIakGIEfwKAAAgBkGIEWohBiAFIAdBAWoiB0YNCwwBCwsgDyAPQYznzAAQwyEACyAKIApBnOfMABDDIQALIAcgCUGs58wAEMMhAAsgByAPQbznzAAQwyEACyAFIAxBzOfMABDDIQALIAogCkHs58wAEMMhAAsgCCAJQfznzAAQwyEACyAJIAlBjOjMABDDIQALIAwgDEH85swAEMMhAAsgByAJQdznzAAQwyEACyAMBEAgCCAMQYgRbEEEEPg6CyANQTBqJAAgBTYCACAbQdAAaiQAIBoEQCAVIBpBiBFsQQQQ+DoLIChBwBdqJAAMAQtBASEJIBdBATYC5AEgF0IENwLoAQJ/IAoEQEEEIQVBAAwBCyARIQkgF0HkAWohECAXQegBaiEPQwAAAAAhbkMAAAAAIW1BACEOIwBBwA5rIgokAAJAAkACQAJAIERBwABJIAQiBkEETHINAAJAIA1B//8/TQRAIAlBQGshDCAJIERqIRQMAQsgCkEwakEAQYAB/AsAIApBsAFqQQBBgA38CwAgCUFAayIMIAkgRGoiFE0EQCAMIQ0gCSEHAkACQANAIAcgI3EiBCAqTw0BICogB0EBaiAjcSIFSwRAIA0gB0ECaksEQCAOQT5qIQ4gBCA6ai0AACEIIAUgOmotAAAhBUECIQsDQAJAAkAgKiAHIAtqICNxIgRLBEAgBCA6ai0AACEEIAhB/wFxQYACckG0ieIAai0AACAFQf8BcUG0ieIAai0AAHIiCEHAAE8NASAEQQN2QQJ0IhggCkEwamoiGiAaKAIAQQFqNgIAIAhBAnRBpPzRAGotAAAiCEENSQ0CIAhBDUHk/tEAEMMhAAsgBCAqQcT+0QAQwyEACyAIQcAAQdT+0QAQwyEACyAKQbABaiAIQQd0aiAYaiIIIAgoAgBBAWo2AgAgBSEIIAQhBSALQQFqIgtBwABHDQALCyAHQYAgaiEHIA1BgCBqIg0gFEsNAwwBCwsgBSAqQbT+0QAQwyEACyAEICpBpP7RABDDIQALIA6zIW4LIApBKGogCkEwakEgQSAQgRFBACELIAoqAighbwNAIApBIGogCkGwAWogC2pBIEEgEIERIG0gCioCIJIhbSALQYABaiILQYANRw0AC0MAAIA/IG6VIm4gbZQibUMAAEBAXiBuIG+UIG2TQ83MTD5dcg0AIA9BwAA2AgQgD0Gk/NEANgIAIBBBDTYCAAwBCyAKQbABakEAQST8CwACQAJAIAwgFE0EQANAIAkgI3EiBCAqTw0FIAwgCUEBaksEQCAEIDpqLQAAQQR2QQxxQaT/0QBqKAIAIQVBASELA0AgCSALaiAjcSIEICpPDQggBUEDbCAEIDpqLQAAQQR2QQxxQaT/0QBqKAIAIgVqIgRBCEsNBCAKQbABaiAEQQJ0aiIEIAQoAgBBAWo2AgAgC0EBaiILQcAARw0ACwsgCUGAIGohCSAMQYAgaiIMIBRNDQALC0EAIQsgCkG4DmpBADYCACAKQgA3A7AOIApBQGtCADcDACAKQThqQgA3AwAgCkIANwMwIApBsAFqIQUDQCAKQbAOaiIEIAtB/wFxQQNwQQJ0aiIJIAUoAgAiByAJKAIAajYCACAKQTBqIgkgCyALQQZrIAtBBkkbQQJ0aiIMIAcgDCgCAGo2AgAgBUEEaiEFIAtBAWoiC0EJRw0ACyAKQRhqIARBA0EDEIERIAoqAhggCkEQaiAJQQZBAxCBESAKKgIQIXAgCkEIaiAKQTxqQQNBAxCBEUMAAAAAIW0gCkGwAWohC0EJIQUgCioCCCFxA0AgCiALIAVBAxCBESALQQxqIQsgbSAKKgIAkiFtIAVBA2siBQ0AC0MAAIA/IAooArgOIAooArQOIAooArAOamqzlSJulCJvQwAAIEGUIG0gbpQgBkEHSRshbSBvIHAgcZIgbpQibpNDzcxMPl0gbyBtk0PNzEw+XXENASBuIG2TQwrXozxdRQRAIA9BwAA2AgQgD0Gk+NEANgIAIBBBAzYCAAwDCyAPQcAANgIEIA9BpPrRADYCACAQQQI2AgAMAgsgBEEJQZT/0QAQwyEACyAQQQE2AgALIApBwA5qJAAMAgsgBCAqQfT+0QAQwyEACyAEICpBhP/RABDDIQALIBcoAugBIQUgFygC5AEhCSAXKALsAQshBiAXQeAAaiEEAkAgCUEBRgRAICsgOiAqIBEgIyAWIDAgTkEBQQRBACAdID0gEiAEENIHDAELICsgOiAqIBEgIyAWIDAgTiAJIAUgBiAdID0gEiAEENIHCwtBoAQgFygCDCIEIARBoARPGyEGQQAhCSMAQcAFayIEJAAgBEEAQcAF/AsAAkACQCAXQeAAaiIHKAJ4Ig0EQCAHKAJYIQwgBygCXCEFA0AgBSAJRg0CQYACIAxBgAIgBBCpBCAMQYgIaiEMIA0gCUEBaiIJRw0ACwsCQCAHKAJ8Ig0EQCAHKAJgIQwgBygCZCEFQQAhCQNAIAUgCUYNAkHABSAMQcAFIAQQqQQgDEGIFmohDCANIAlBAWoiCUcNAAsLAkAgBygCgAEiDQRAIAcoAmghDCAHKAJsIQVBACEJA0AgBSAJRg0CIAYgDEGgBCAEEKkEIAxBiBFqIQwgDSAJQQFqIglHDQALCyAEQcAFaiQADAMLIAUgBUGs78wAEMMhAAsgBSAFQbzvzAAQwyEACyAFIAVBzO/MABDDIQALIB0hBUEAIQsjAEGQFmsiBiQAIAZB7A5qIgkgOiAqIBEiHSBEICMQ7xYCQCAXLQBRRQ0AIBIgPU0EQCAGKAL4DiEIIAYoAvQOIQ8gBigC8A4hECAGKALsDiEOIwBBIGsiBCQAAkACQAJAAkACQAJAAkACQCAHKAIUIgwgBygCBE0EQCAMIAcoAgxLDQEgBygCcCIUIAcoAkxLDQIgBygCLCINIAcoAhxLDQMgDSAHKAIkSw0EIAcoAkQiCiAHKAI0Sw0FIAogBygCPEsNBiAHKAJ0IhggBygCVEsNByAHKAIAIRogBygCCCEbIAcoAkghFSAHKAIQIRkgBygCGCEnIAcoAiAhLSAHKAIwISEgBygCKCEiIAcoAjghJCAJIBg2AkggCSAKNgI8IAkgJDYCOCAJIAo2AjQgCSAhNgIwIAkgIjYCLCAJIA02AiggCSAtNgIkIAkgDTYCICAJICc2AhwgCSAUNgIYIAkgFTYCFCAJIBk2AhAgCSAMNgIMIAkgGzYCCCAJIAw2AgQgCSAaNgIAIAkgBygCUDYCRCAJIAcoAkA2AkAgBEEgaiQADAgLIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQcim0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakHYptAAEO8sAAsgBEEANgIYIARBATYCDCAEQfig0AA2AgggBEIENwIQIARBCGpB6KbQABDvLAALIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQfim0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakGIp9AAEO8sAAsgBEEANgIYIARBATYCDCAEQfig0AA2AgggBEIENwIQIARBCGpBmKfQABDvLAALIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQain0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakG4p9AAEO8sAAsgKyAFIBIgDiAQIA8gCCBJIE8gCSAXIE4QpQEMAQsgBkEANgL8DiAGQQE2AvAOIAZB+KDQADYC7A4gBkIENwL0DiAGQewOakHopdAAEO8sAAsgFygCDCEQIBctAFIhGiACIEQgNSA2IDQQkRcgBkIANwPYByAGQewOaiIEIAZB2AdqQYELEIkcIAZBOGogBEHMgs4AEJ8hIAcoAhQhCSAHKAIIIQpBACEYAn9BACAHKAIMIghFDQAaQQAgCUUNABogCigCAAshFCAGKAI8IQQgBigCOCENIAcoAgQhDyAHKAIAIQ4gBygCECEMIAZB+ABqQQBB1Ab8CwAgBkEwahD9JyAGKQMwIWAgBkEANgL0DiAGQoCAgIAgNwLsDiAGQShqIAZB7A5qQYyHzgAQqiEgBkEANgLUByAGIBQ2AtAHIAZBADYCzAcgBkIBNwJwIAYgCTYCbCAGIAw2AmggBkGAAjYCZCAGIGA3AlQgBiAINgJQIAYgCjYCTCAGIA82AkggBiAONgJEIAYgBikDKDcCXCAHKAIgIRQgBygCJCIbRSAHKAIsIhVFckUEQCAUKAIAIRgLIAcoAhwhGSAHKAIYIScgBygCKCEtIAZBjAhqQQBB1Ab8CwAgBkEgahD9JyAGKQMgIWAgBkEANgL0DiAGQoCAgIAgNwLsDiAGQRhqIAZB7A5qQYyHzgAQqiEgBkEANgLoDiAGIBg2AuQOIAZBADYC4A4gBkIBNwKECCAGIBU2AoAIIAYgLTYC/AcgBkHABTYC+AcgBiBgNwLoByAGIBs2AuQHIAYgFDYC4AcgBiAZNgLcByAGICc2AtgHIAYgBikDGDcC8AcgBygCOCEUIAcoAjwiGEUgBygCRCIbRXJFBEAgFCgCACELCyAHKAI0IRUgBygCMCEZIAcoAkAhJyAGQaAPakEAQdQG/AsAIAZBEGoQ/ScgBikDECFgIAZBADYCiBYgBkKAgICAIDcCgBYgBkEIaiAGQYAWakGMh84AEKohIAZBADYC/BUgBiALNgL4FSAGQQA2AvQVIAZCATcCmA8gBiAbNgKUDyAGICc2ApAPIAZBoAQgECAQQaAETxsgECAaGzYCjA8gBiBgNwL8DiAGIBg2AvgOIAYgFDYC9A4gBiAVNgLwDiAGIBk2AuwOIAYgBikDCDcChA8gDiAPIAogCCAJIAwgDSAEIAZB8ABqIDUgNiA0EPQKIAYoAtgHIAYoAtwHIAYoAuAHIAYoAuQHIAYoAoAIIAYoAvwHIA0gBCAGQYQIaiA1IDYgNBD0CiAGKALsDiAGKALwDiAGKAL0DiAGKAL4DiAGKAKUDyAGKAKQDyANIAQgBkGYD2ogNSA2IDQQ9ApBAiAXKAIEIgmtIDUgNiA0EOUSQQQgFygCCCAJdq0gNSA2IDQQ5RIgDARAIE6tQv8BgyFgA0BBAiBgIDUgNiA0EOUSIAxBAWsiDA0ACwsCQCAHKAJwIi1FBEAgBygCeCIMQQYgDSAEIDUgNiA0ENQLDAELICsgBygCSCAHKAJMIC0gBygCeCIMIA0gBCA1IDYgNBCDCgsCQCAHKAJ0IiFFBEAgBygCgAEiDkECIA0gBCA1IDYgNBDUCwwBCyArIAcoAlAgBygCVCAhIAcoAoABIg4gDSAEIDUgNiA0EIMKCyAHKAJYIQ8gBygCXCEnQQAhCyMAQSBrIgkkAAJ/IAZBxABqIgooAiAiGiAMbCIIRQRAIAlBEGoQ/ScgCSgCECEUIAkoAhQMAQsgCUEYaiArIAgQuCkgCSgCGCEUIAkoAhwLIRsgCigCFCIYBEAgCigCECAYQQEQ+DoLIAogGzYCFCAKIBQ2AhAgCUEIaiAIELoeIAkoAgwhFSAJKAIIIQggCigCHCIYBEAgCigCGCAYQQF0QQIQ+DoLIAogFTYCHCAKIAg2AhgCQAJAAkACQCAMBEAgGkEBdCEKQQAhGEEAIRkDQCALICdGDQIgGSAbSw0DIBUgGUkNBCAPQYACIBpBgAIgDSAEIBQgGWogGCAbaiAIIBUgGGogNSA2IDQQ8gggCCAKaiEIIBggGmshGCAZIBpqIRkgD0GICGohDyAMIAtBAWoiC0cNAAsLIAlBIGokAAwDCyAnICdB5KzQABDDIQALIBkgG0H0rNAAEK87AAsgGSAVQYSt0AAQrzsACyAHKAJgIRggBygCZCEbIAcoAnwhFUEAIQsjAEEgayIMJAACfyAGQdgHaiIJKAIgIgogFWwiCEUEQCAMQRBqEP0nIAwoAhAhFCAMKAIUDAELIAxBGGogKyAIELgpIAwoAhghFCAMKAIcCyEPIAkoAhQiGgRAIAkoAhAgGkEBEPg6CyAJIA82AhQgCSAUNgIQIAxBCGogCBC6HiAMKAIMIRogDCgCCCEZIAkoAhwiCARAIAkoAhggCEEBdEECEPg6CyAJIBo2AhwgCSAZNgIYAkACQAJAAkAgFQRAIApBAXQhJ0EAIQhBACEJA0AgCyAbRg0CIAkgD0sNAyAJIBpLDQQgGEHABSAKQcAFIA0gBCAJIBRqIAggD2ogGSAIIBpqIDUgNiA0EPIIIBkgJ2ohGSAIIAprIQggCSAKaiEJIBhBiBZqIRggFSALQQFqIgtHDQALCyAMQSBqJAAMAwsgGyAbQeSs0AAQwyEACyAJIA9B9KzQABCvOwALIAkgGkGErdAAEK87AAsgBygCaCEYIAcoAmwhG0EAIQ8jAEEgayIMJAACfyAGQewOaiIJKAIgIgogDmwiCEUEQCAMQRBqEP0nIAwoAhAhCyAMKAIUDAELIAxBGGogKyAIELgpIAwoAhghCyAMKAIcCyEUIAkoAhQiGgRAIAkoAhAgGkEBEPg6CyAJIBQ2AhQgCSALNgIQIAxBCGogCBC6HiAMKAIMIRogDCgCCCEZIAkoAhwiCARAIAkoAhggCEEBdEECEPg6CyAJIBo2AhwgCSAZNgIYAkACQAJAAkAgDgRAIApBAXQhFUEAIQhBACEJA0AgDyAbRg0CIAkgFEsNAyAJIBpLDQQgGEGgBCAKIBAgDSAEIAkgC2ogCCAUaiAZIAggGmogNSA2IDQQ8gggFSAZaiEZIAggCmshCCAJIApqIQkgGEGIEWohGCAOIA9BAWoiD0cNAAsLIAxBIGokAAwDCyAbIBtB5KzQABDDIQALIAkgFEH0rNAAEK87AAsgCSAaQYSt0AAQrzsACyAGQQA2AogWIAZCgICAgMAANwKAFiAGIAZBgBZqQYyHzgAQnyEgBigCBCEJIAYoAgAhCCAEBEAgDSAEQQN0QQQQ+DoLAkAgEkUNACAHKAJUIQ8gBygCUCELIAcoAkwhECAHKAJIIRRBACEOAkADQAJAAkACQCAOID1HBEAgBkGIFmogBSAOQQR0aiIEQQhqKQIANwMAIAYgBCkCADcDgBYgBkHYB2ogBi8BjBYiDSA1IDYgNBCWFCAGQYAWaiA1IDYgNBCSDSAGKAKAFiEMIC0NAgNAIAxFDQQgHSAjcSIEICpPDQIgBkHEAGogBCA6ai0AACA1IDYgNBCWFCAMQQFrIQwgHUEBaiEdDAALAAsgPSA9Qfil0AAQwyEACyAEICpBiKbQABDDIQALA0AgDEUNASAwIQQgFiIwIAQgThDbIiEKICogHSAjcSIESwRAIAZBxABqIAQgOmotAAAiFiAKQf8BcSAUIBAgNSA2IDRBBhCsEiAMQQFrIQwgHUEBaiEdDAELCyAEICpBuKbQABDDIQALIAYoAoQWQf///w9xIgQgHWohHQJAAkAgBEUNACAdQQJrICNxIgQgKk8NAyAdQQFrICNxIgwgKk8NASAEIDpqLQAAITAgDCA6ai0AACEWIA1B/wBNDQAgBi8BjhYiBEEKdiAEQf8HcSENIAY1AogWAkAgIUUEQCAGQewOaiANIDUgNiA0EJYUDAELIAYvAYwWIgxBB3EhBAJAAkAgDEEGdiIKQQRLQQEgCnRBFXFFckUEQEEDIQwgBEEDSQ0BDAILQQMhDCAKQQdHIARBAktyDQELIAQhDAsgBkHsDmogDSAMIAsgDyA1IDYgNEECEKwSCyA1IDYgNBDlEgsgDkEBaiIOIBJHDQEMAwsLIAwgKkGoptAAEMMhAAsgBCAqQZim0AAQwyEACyAGQewOaiArEPYbIAZB2AdqICsQ9hsgBkHEAGogKxD2GyACBEAgNSA2IDQQtCkLIAkEQCAIIAlBA3RBBBD4OgsgBkHsDmoQiysgBkHYB2oQiysgBkHEAGoQiysgBkGQFmokACMAQUBqIgQkACAHICsQ4R4gB0EYaiArEOEeIAdBMGogKxDhHiAEQShqEP4nIAcoAkwhBSAEKAIoIQYgByAEKAIsNgJMIAcoAkggByAGNgJIIAUQgDEgB0EANgJwIARBIGoQ/icgBygCVCEFIAQoAiAhBiAHIAQoAiQ2AlQgBygCUCAHIAY2AlAgBRCAMSAHQQA2AnQgBEEANgI8IARCgICAgMAANwI0IARBGGogBEE0akGMh84AEKIhIAcoAlwhBSAHKAJYIQYgByAEKQMYNwJYIAUEQCAGIAVBiAhsQQQQ+DoLIAdBADYCeCAEQQA2AjwgBEKAgICAwAA3AjQgBEEQaiAEQTRqQYyHzgAQnCEgBygCZCEFIAcoAmAhBiAHIAQpAxA3AmAgBQRAIAYgBUGIFmxBBBD4OgsgB0EANgJ8IARBADYCPCAEQoCAgIDAADcCNCAEQQhqIARBNGpBjIfOABCgISAHKAJsIQUgBygCaCEGIAcgBCkDCDcCaCAFBEAgBiAFQYgRbEEEEPg6CyAHQQA2AoABIARBQGskACAHEIorIAdBGGoQiisgB0EwahCKKyAHKAJMIgQEQCAHKAJIIARBAnRBBBD4OgsgBygCVCIEBEAgBygCUCAEQQJ0QQQQ+DoLIAcoAlwiBARAIAcoAlggBEGICGxBBBD4OgsgBygCZCIEBEAgBygCYCAEQYgWbEEEEPg6CyAHKAJsIgQEQCAHKAJoIARBiBFsQQQQ+DoLDAQLQey70ABBIUGQvNAAEJ8pAAsgBSA0QaC80AAQwyEACyMAQYDJAGsiBCQAIARBjAhqIgUgOiAqIBEgRCAjEO8WAkAgJS0AUUUNACASID1NBEAgBCgCmAghBiAEKAKUCCEJIAQoApAIIQcgBCgCjAghDCAFEPMoICsgHSASIAwgByAJIAYgSSBPIAUgJUEAEKUBDAELIARBADYCnAggBEEBNgKQCCAEQfig0AA2AowIIARCBDcClAggBEGMCGpBlKvQABDvLAALICU1AgxCAX0iYHmnQT9zQQAgYEICWhshCyACIEQgNSA2IDQQkRdBDUIAIDUgNiA0EOUSAkAgEkGBAU8EQCAEQQRqIgVBAEGECPwLACAEQaPg//sHNgKICCAEQYwIaiIGQQBBhBb8CwAgBEGj4P/7BzYCkB4gBEGUHmoiCUEAQYQR/AsAIARBo+D/+wc2ApgvIARBnC9qIgdBAEGAAvwLACAEQZwxaiIMQQBBgAT8CwAgBEGcNWoiDUEAQcAF/AsAIARB3DpqIgpBAEGAC/wLACAEQdzFAGoiCEEAQYwB/AsAIARB6MYAaiIPQQBBmAL8CwAgOiAqIBEgIyAdID0gEiAFIAYgCRCSFiAFQYACIAQoAoQIQQggB0GAAiAMQYACIDUgNiA0EKMCIAZBwAUgBCgCjB5BCiANQcAFIApBwAUgNSA2IDQQowIgCUGgBCAEKAKULyALQQFqIAhBjAEgD0GMASA1IDYgNBCjAiA6ICogESAjIB0gPSASIAcgDCANIAogCEGMASAPQYwBIDUgNiA0ELENDAELQQAhByAEQYwIakEAQYAI/AsAIARB3DpqQQBBgAL8CwAgBEGUHmpBAEGABPwLACASBEAgESEFQQAhDANAAkACQCAMID1HBEAgHSAMQQR0aiIGKAIEIQ0gBigCACIGIQ4gBg0BDAILID0gPUGkq9AAEMMhAAsDQCAqIAUgI3EiCUsEQCAEQYwIaiAJIDpqLQAAQQJ0aiIJIAkoAgBBAWo2AgAgBUEBaiEFIA5BAWsiDg0BDAILCyAJICpBtKvQABDDIQALIAYgB2ohByAFIA1B////D3FqIQUgDEEBaiIMIBJHDQALCyAEQYwIakGAAiAHQQggBEHcOmoiBUGAAiAEQZQeaiIGQYACIDUgNiA0EKMCQThCg+DBscHImMkAIDUgNiA0EOUSQQNCACA1IDYgNBDlEkEcQoO4pxsgNSA2IDQQ5RIgOiAqIBEgIyAdID0gEiAFIAZBhpjiAEGQ++IAQcaX4gBBwABBkPriAEHAACA1IDYgNBCxDQsgAgRAIDUgNiA0ELQpCyAEQYDJAGokAAwBCyMAQZChAWsiBCQAIARBiMkAaiIFIDogKiARIEQgIxDvFgJAICUtAFFFDQAgEiA9TQRAIAQoApRJIQYgBCgCkEkhCSAEKAKMSSEHIAQoAohJIQwgBRDzKCArIB0gEiAMIAcgCSAGIEkgTyAFICVBABClAQwBCyAEQQA2AphJIARBATYCjEkgBEH4oNAANgKISSAEQgQ3ApBJIARBiMkAakHEq9AAEO8sAAsgBEEMaiIGQQBBhAj8CwAgBEGj4P/7BzYCkAggBEGUCGoiCUEAQYQW/AsAIARBo+D/+wc2ApgeIARBnB5qIgdBAEGEEfwLACAEQaPg//sHNgKgLyAEQaQvaiIMQQBBgAL8CwAgBEGkMWoiDUEAQYAE/AsAIARBpDVqIgpBAEHABfwLACAEQeQ6aiIIQQBBgAv8CwAgBEHkxQBqIg9BAEGMAfwLACAEQfDGAGoiC0EAQZgC/AsAIARBiMkAaiIFQQBBiNgA/AsAICUoAgwhECACIEQgNSA2IDQQkRcgOiAqIBEgIyAdID0gEiAGIAkgBxCSFkENQgAgNSA2IDQQ5RIgBkGAAkGAAkGAAiAFQYELIAxBgAIgDUGAAiA1IDYgNBDyCCAJQcAFQcAFQcAFIAVBgQsgCkHABSAIQcAFIDUgNiA0EPIIIAdBoARBjAEgECAFQYELIA9BjAEgC0GMASA1IDYgNBDyCCA6ICogESAjIB0gPSASIAwgDSAKIAggD0GMASALQYwBIDUgNiA0ELENIAIEQCA1IDYgNBC0KQsgBEGQoQFqJAALIEQgWWpBBGogNSgCAEEDdkkEQCBbIFw6AAAgXSBeOgAAICYgSSkCADcCACA1IFpB/wFxNgIAICZBCGogSUEIaikCADcCACArIAIgOiAqIBEgIyAlIEQgTyA1IDYgNEEBELUOCwsgASACRg0AQQFCASA1IDYgNBDlEkEBQgEgNSA2IDQQ5RIgNSA1KAIAQQdqIgFBeHE2AgAgNCABQQN2IgFNBEAgASA0Qczs0QAQwyEACyABIDZqQQA6AAALIBdB8AFqJAAgOygCLCIFQQN2IgEgACgCzAEiAk8NAiABQQFqIgQgAk8NAyABIAAoAsgBIgJqLQAAIQEgAiAEai0AACECIAAgBUEHcToAviogACAAKQPoASJgNwPwASAAIAEgAkEIdHI7AbgqIAApA/gBEMsrIGAQyysgACBgNwP4AU0NBSAAKAJoDQQMBQsgBCAFQbi/0AAQwyEACyACIARByL/QABCvOwALIAEgAkHYv9AAEMMhAAsgBCACQei/0AAQwyEACyBBEJQqQQA2AhgLAkACQCAAKALwKSICIAAoAowqIgFPBEACQCAAKQPwASJgUA0AIGCnIgVBAWsgI3EiBCACIAFrIgJPDQIgACAEIAAoAuwpIAFqIgZqLQAAOgC/KiBgQgFRDQAgBUECayAjcSIBIAJPDQMgACABIAZqLQAAOgDAKgsgAEIANwKUKiAAQgA3AwAgSSAmKQMANwMAIAMgOygCLEEDdjYCACBJQQhqICZBCGopAwA3AwAMBAsgASACQfi/0AAQrzsACyAEIAJBiMDQABDDIQALIAEgAkGYwNAAEMMhAAsgAyAbNgIAC0EBIRsLIDtB0ABqJAAgGw8LIAdBADYCKCAHQQE2AhwgB0GY184ANgIYIAdCBDcCICAHQRhqQfThzgAQ7ywACyASQQA2AiggEkEBNgIcIBJBmNfOADYCGCASQgQ3AiAgEkEYakH04c4AEO8sAAsgFiARQcDTzgAQwyEACyARIAVBsNHOABDDIQALIAsgFkHQ0s4AEMMhAAsgESAEQaDRzgAQwyEACyAEIAVBsM7OABDDIQALIBEgBUGwz84AEMMhAAsgC0EANgIYIAtBATYCDCALQZjXzgA2AgggC0IENwIQIAtBCGpB9ODOABDvLAALIAtBADYCGCALQQE2AgwgC0GY184ANgIIIAtCBDcCECALQQhqQYThzgAQ7ywACyAHQQA2AhggB0EBNgIMIAdBmNfOADYCCCAHQgQ3AhAgB0EIakH04M4AEO8sAAsgB0EANgIYIAdBATYCDCAHQZjXzgA2AgggB0IENwIQIAdBCGpBhOHOABDvLAALIAggBUHA0c4AEMMhAAsgCyAFQdDRzgAQwyEACyAVIAVB8NHOABDDIQALIBkgBUGA0s4AEMMhAAsgFSAWQeDSzgAQwyEACyAZIBZB8NLOABDDIQALIBYgBUHwzs4AEMMhAAsgFSAFQYDPzgAQwyEACyAZIAVBkM/OABDDIQALIBYgCEHA0M4AEMMhAAsgFSAIQdDQzgAQwyEACyAZIAhB4NDOABDDIQALIAhBADYCGEEAIAhBCGogCEEMaiAIQRhqQcjizgAQrysACyAIQQA2AhhBACAIQRBqIAhBFGogCEEYakHY4s4AEK8rAAtBAEEAQZzVzAAQwyEAC0HAAEHAAEHs28wAEMMhAAsgBkHAAEGc3MwAEMMhAAsgBkHAAEG83MwAEMMhAAtBAEEAQYzazAAQwyEACyAFQQFqIDFBnN3MABDDIQALIAUgPGogBEGs3MwAEMMhAAsgBUEBaiA5QazZzAAQwyEAC+UZAQ9/IwBBQGoiCyQAIAsgBjYCICALIAU2AhwgBEEBaiEOIAtBN2ohEyALQThqIRQgAy0AACERA0AgASgCCCEKAn8CQAJAAkAgBSAGRgRAQQAhDCAFIQcMAQsgBiAFayEMIAUhBwNAIAsgByIIQQFqIgc2AhwCQCAILQAAIgnAQQBODQAgCyAIQQJqIgc2AhwgCC0AAUE/cSEPIAlBH3EhDSAJQd8BTQRAIA1BBnQgD3IhCQwBCyALIAhBA2oiBzYCHCAILQACQT9xIA9BBnRyIQ8gCUHwAUkEQCAPIA1BDHRyIQkMAQsgCyAIQQRqIgc2AhwgDUESdEGAgPAAcSAILQADQT9xIA9BBnRyciEJCwJAAkACQAJAAkACQAJAAkAgCUEuTARAIAlBDUYgCUEJa0ECSXINASAJQSNHDQcMBAsgCUHbAEwEQCAJQS9GDQIgCUE/Rg0EDAcLIAlB3ABHBEAgCUGAgMQARw0HDAoLIAJB/wFxQQJGDQYgAS0AICINQQJGDQYgASAFIAwgBiAIayANIAIQ6hUgASgCGCIFRQ0CIAVBACABKAIcKAIUEQAADAILIAEgBSAMIAYgCGsgAS0AICACEOoVIAYgB2shDCAHIQUMBgsgAS0AICINQQJGDQQgASAFIAwgBiAIayANIAIQ6hULIAEoAgghCSABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgCUEBaiIFNgIIIAEoAgQhDCAJIApJDQIgCgRAIAogDGosAABBv39MDQMMAgsgCQ0BQQEhD0EAIQpBACEJIAcMCQsgAS0AIA0CIAEgBSAMIAYgCGtBACACEOoVIAsgBjYCICALIAg2AhwgCCEHDAYLIAkgDGosAABBv39MDQBBASEPDAYLIAwgBSAKIAlBiI3EABCjNgALIAEoAhgiDQRAIA0gASgCHCAJIAtBHGoQkAwLIAJB/wFxDQAgASgCCCIJIARNDQAgASgCBCENAkAgCSAOTQ0AIA0gDmosAABBv39KDQAgDSAJIA4gCUHYjMQAEKM2AAsgCSAOa0ECRw0AIA0gDmoiCS0AAEHfAXFBwQBrQf8BcUEZSw0AIAktAAFBOkcNACABIAUgDCAGIAhrIgwgAS0AIEEAEOoVIAEoAgghBSABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgBUEBajYCCCAKQQFqIQogCCEFCyAGIAdHDQALCyABIAUgDEEAIAEtACAgAhDqFQsgASgCBCEMIAEoAggiCSAKTwRAQQAhDyAKRSAJIApNcg0BIAogDGosAABBv39KDQELIAwgCSAKIAlB+IzEABCjNgALIAcLIQUCQAJAAkAgCiAMaiIHIAkgCmsiCEGYjcQAQQIQwS4NACAHIAhBmo3EAEEGEMEuDQAgByAIQaCNxABBBhDBLg0AIAcgCEGmjcQAQQYQwS4NACAHIAhBrI3EAEEGEMEuDQAgByAIQbKNxABBBBDBLg0AIAcgCEG2jcQAQQQQwS4NACAHIAhBuo3EAEEEEMEuDQAgByAIQb6NxABBBBDBLg0AAkAgByAIQcKNxABBARDBLg0AIAcgCEHDjcQAQQMQwS4NACAHIAhBxo3EAEEDEMEuDQAgAkH/AXEgCiAOR3IgCEECR3INAiAHLQAAQd8BcUHBAGtB/wFxQRlLDQIgBy0AASIIQfwARyAIQTpHcQ0CIAsgBzYCJCALIAkgDGo2AigCQCALQSRqEPUWIgdBgIDEAEYNAAJAAkAgASgCCCIIIA5PBEAgDkUgCCAOTXJFBEAgASgCBCAOaiwAAEG/f0wNAgsgASAONgIICwwBC0GohcQAQTBBzI3EABCfKQALIAEoAgghCiABAn9BASAHQYABSSIJDQAaQQIgB0GAEEkNABpBA0EEIAdBgIAESRsLIgwQ2C0gASgCBCABKAIIaiEIAkACQCAJRQRAIAdBgBBJDQEgB0GAgARPBEAgCCAHQT9xQYABcjoAAyAIIAdBEnZB8AFyOgAAIAggB0EGdkE/cUGAAXI6AAIgCCAHQQx2QT9xQYABcjoAAQwDCyAIIAdBP3FBgAFyOgACIAggB0EMdkHgAXI6AAAgCCAHQQZ2QT9xQYABcjoAAQwCCyAIIAc6AAAMAQsgCCAHQT9xQYABcjoAASAIIAdBBnZBwAFyOgAACyABIAogDGo2AgggASgCCCEHIAFBARDYLSABKAIEIAEoAghqQTo6AAAgASAHQQFqNgIIIA9FDQAgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIAdBAmo2AggLIBFBAXFBACERRQ0CIAEoAhgiBwRAIAdBBSABKAIcKAIUEQAACyADQQA6AAAMAgsCQAJAIAEoAggiByAKSQRAIAchCgwBCyAKRSAHIApNckUEQCABKAIEIApqLAAAQb9/TA0CCyABIAo2AggLIAEoAgQhByALQS82AiQgCgR/IAtBJGpBASAHIApqQQFrQQEQwS4NAyABKAIIBUEACyEHIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAHQQFqNgIIDAILQaiFxABBMEGMjsQAEJ8pAAsCQAJAAkAgASgCCCIHIApJBEAgByEKDAELIApFIAcgCk1yRQRAIAEoAgQgCmosAABBv39MDQILIAEgCjYCCAsgASgCBCEHIAtBLzYCJCAKRQ0BIAtBJGpBASAHIApqQQFrQQEQwS5FDQEgASgCBCENAkAgASgCCCIKQQFrIggEQCAKRQ0BIAggDWosAABBv39MDQELIAsgCDYCNEEAIQcgC0EANgIwIAsgCDYCLCALIA02AiggC0EBOgA8IAtBLzYCJCALQS82AjggCCEJA0AgC0EQaiATIAstADxqLQAAIAcgDWogCSAHaxCjCiALKAIQQQFxRQ0DAkAgCygCMCIHIAsoAhRqIgkgCy0APCIQQQFrIhJJDQAgCSASayIMIBBqIhUgDEkgCCAVSXINAAJAAkACQAJAIBBBBUkEQCAMIA1qIgcgECAUIBAQwS5FBEAgCygCMCEHDAYLIAQgDEsNCQJAIAkgEkYNACAKIAxNBEAgCiAMRg0BDAYLIAcsAABBv39MDQULIAogDEYNAyAHLQAAIghBI2siCUEcS0EBIAl0QYGggIABcUVyDQEMAgsgEEEEQZSGxAAQsDsACyAIQdwARw0BCyAKIAxrIghBAUYNAAJAAkAgBywAASIKQb9/SgRAIAhBAWsiCEECSSAKQd8BcUHBAGtB/wFxQRlLcg0DIActAAIiCkH8AEcgCkE6R3ENAyAIQQJGDQkgBy0AAyIHQSNrIghBHE0NAQwCCyAHIAhBASAIQeSUxAAQozYAC0EBIAh0QYGggIABcQ0HCyAHQdwARg0GCyABKAIIIgpFDQVBfyEHAkAgASgCBCAKaiIIQQFrLAAAQQBODQACfyAIQQJrLQAAIgnAIgxBv39KBEAgCUEfcQwBCyAMQT9xAn8gCEEDay0AACIJwCIMQb9/SgRAIAlBD3EMAQsgDEE/cSAIQQRrLQAAQQdxQQZ0cgtBBnRyCyIIQQJJDQBBfiEHIAhBIEkNAEF9QXwgCEGACEkbIQcLIAEgByAKajYCCAwFCyANIAogDCAKQcyPxAAQozYACyALIAk2AjQgCCAJSQ0DIAcgCU0NAAsMAgsgDSAKQQAgCEG8j8QAEKM2AAtBqIXEAEEwQayOxAAQnykACyABIAIgBBCuGyAPRQ0BIAEoAgghByABKAIEIQggC0EvNgIkIAcEfyALQSRqQQEgByAIakEBa0EBEMEuDQEgASgCCAVBAAshByABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgB0EBajYCCAsgDw0BCwsgAkH/AXFFBEAgASgCCCECIAEoAgQhBwJAIARFDQACQCACIARNBEAgAiAERw0BDAILIAQgB2osAABBv39KDQELQdiFxABBK0HMjsQAEJ8pAAsCQCACIARPBEAgC0EkaiACIARrIgJBAEEBQQEQoBggCygCKCEIIAsoAiRBAUcNASAIIAsoAixBzI7EABD9LwALIwBBMGsiACQAIAAgAjYCBCAAIAQ2AgAgAEEDNgIMIABBrMWJATYCCCAAQgI3AhQgACAAQQRqrUKAgICAsAeENwMoIAAgAK1CgICAgLAHhDcDICAAIABBIGo2AhAgAEEIakHMjsQAEO8sAAsgCygCLCEDIAEgBDYCCCACBEAgAyAEIAdqIAL8CgAACyALIAI2AiwgCyADNgIoIAsgCDYCJCABKAIIIQQgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIARBAWo2AgggC0EIaiADIAJBLxDJEyABIAsoAggiASABIAsoAgxqEIEmIAtBJGoQ3jsLIAAgBjYCBCAAIAU2AgAgC0FAayQAC5kZAil/F34jAEGQAWsiAyQAIAEoAgQhAiADQYABaiABKAIIIhVBAEEIQcACEKAYIAMoAoQBIRMCQCADKAKAAUEBRwRAIAMoAogBIRYCQCATRQ0AIAIgFUHAAmxqIR4gA0H+AGohFyATIRgDQCACIB5GDQEgAigCvAIiGSAZKAIAIgFBAWo2AgAgAUEASA0DIANBzABqIAJBgAJqENYeAkAgAigCjAJBgICAgHhHBEAgA0HYAGogAkGMAmoQ3SAMAQsgA0GAgICAeDYCWAsgAikD+AEhNyACKQPwASE4IAIpA+gBITkgAigC1AEhHyACKALQASEgIAIpA+ABITogAikD2AEhO0IAITJCACEzIAIoAgBBAUYEQCACKQMIITxCASEzCyACKAIQQQFGBEAgAikDGCE9QgEhMgtCCCErIAIpA2AiMEIIUgRAAn8CQAJ+AkACQAJAAkACQAJAAkACQCAwp0EBaw4HAQIDBAUGBwALIAItAIoBIQsgAi0AiQEhDCACLQCIASEBIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAi0AjQEhByACLQCMASEIQgAhKyADQeQAaiEJIAItAIsBDAkLIAMgAigCjAEiCEEIdjoAZCAIQRB2IQ0gAigCiAEhASACLQCbASEHIAItAJoBIQQgAi0AmQEhBiACLQCYASEFIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAigClAEhDiACKAKQASEPQgEhKwwHCyACQZoBai0AACEEIAItAKsBIQcgAi0AqgEhECACLQCpASERIAItAKgBIRIgAikDoAEhMSACKAKcASEKIAIvAY4BIQ0gAi0AjAEhCCACKQOAASEuIAIpA3ghLCACKQNwIS8gAikDaCEtIAIpA5ABISsgAi8BmAEgAigCiAEhASACLQCNASEGIAMgAi0AmwE6AEAgAyAGOgBkIAFBEHYhCyABQQh2IQwgBEEQdHIiBUEIdiEGICtCIIinIQ4gK6chD0ICISsgA0EwaiEJIAFBGHYMBwtBACEFQQAhASACKAKIAUEBRgRAIAIoApQBIQ4gAigCkAEhDyACLwGOASENIAItAI0BIQQgAi0AjAEhCEEBIQELIAIoApgBQQFGBEAgAikCoAEhMSACKAKcASEKQQEhBQsgAyAEOgBkIANBADoAQCACLQCrASEHIAItAKoBIRAgAi0AqQEhESACLQCoASESIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS1CAyErIANBMGohCUEAIQtBACEMQQAhBEEAIQZBAAwGCyADIAIoAowBIghBCHY6AGQgCEEQdiENIAIoApQBIQ4gAigCiAEhASACLQCbASEHIAItAJoBIQQgAi0AmQEhBiACLQCYASEFIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAigCkAEhD0IEISsMBAsgAkGaAWotAAAhBCACLQCrASEHIAItAKoBIRAgAi0AqQEhESACLQCoASESIAIpA6ABITEgAigCnAEhCiACLwGOASENIAItAIwBIQggAikDgAEhLiACKQN4ISwgAikDcCEvIAIpA2ghLSACKQOQASErIAIvAZgBIAIoAogBIQEgAi0AjQEhBiADIAItAJsBOgBAIAMgBjoAZCABQRB2IQsgAUEIdiEMIARBEHRyIgVBCHYhBiArQiCIpyEOICunIQ9CBSErIANBMGohCSABQRh2DAQLQQAhCkEAIQEgAigCiAFBAUYEQAJAIAIoAowBIgEEQCADQfAAaiACQZgBaiACKAKQASACKAKUASABKAIAEQUADAELIANBADYCcAtBASEBCyACKAKcAUEBRgRAAkAgAigCoAEiBARAIANBgAFqIAJBrAFqIAIoAqQBIAIoAqgBIAQoAgARBQAMAQsgA0EANgKAAQtBASEKC0IAISxCACEtIAIoAmhBAUYEQCACKQNwIS9CASEtCyACKAJ4QQFGBEAgAikDgAEhLkIBISwLIAMgAy0AcToAZCADIAMtAH86AEAgAi0AswEhByACLQCyASEaIAItALEBIRsgAi0AsAEhHCAXLQAAIQQgAy8BciENIAMtAHAhCCADKAJ0IQ8gAygCeCEOIAMpA4ABITEgAy0AiAEhEiADLQCJASERIAMtAIoBIRAgAy8BfCADIAMtAIsBOgAwIARBEHRyIgVBCHYhBiADQSBqIQlCBgwBC0EAIQpBACEBIAIoAogBQQFGBEACQCACKAKMASIBBEAgA0HwAGogAkGYAWogAigCkAEgAigClAEgASgCABEFAAwBCyADQQA2AnALQQEhAQsgAigCnAFBAUYEQAJAIAIoAqABIgQEQCADQYABaiACQawBaiACKAKkASACKAKoASAEKAIAEQUADAELIANBADYCgAELQQEhCgtCACEsQgAhLSACKAJoQQFGBEAgAikDcCEvQgEhLQsgAigCeEEBRgRAIAIpA4ABIS5CASEsCyADIAMtAHE6AGQgAyADLQB/OgBAIAItALMBIQcgAi0AsgEhGiACLQCxASEbIAItALABIRwgFy0AACEEIAMvAXIhDSADLQBwIQggAygCdCEPIAMoAnghDiADKQOAASExIAMtAIgBIRIgAy0AiQEhESADLQCKASEQIAMvAXwgAyADLQCLAToAMCAEQRB0ciIFQQh2IQYgA0EgaiEJQgcLISsgAygCjAEhIUEAIQtBACEMQQAMAQsgA0FAayEJQQAhC0EAIQxBAAshFCAJIAc6AAAgBUH/AXEgBkH/AXFBCHQgBEEQdHJyIQQgAUH/AXEgC0H/AXFBEHQgFEEYdHIgDEH/AXFBCHRyciEHIAMtAGQhDCADLQBAIQsgAy0AMCEJIAMtACAhBQsCQCACKAKYAkGAgICAeEcEQCADQeQAaiACQZgCahC1FgwBCyADQYCAgIB4NgJkC0IAITBCACE0IAIoAiBBAUYEQCACKQMoIT5CASE0CyACKAK8ASEUIAIoArgBIQYgAigCMEEBRgRAIAIpAzghP0IBITALIAIoAsQBISIgAigCwAEhI0IAITVCACE2IAIoAkBBAUYEQCACKQNIIUBCASE2CyACKALMASEkIAIoAsgBISUgAigCUEEBRgRAIAIpA1ghQUIBITULAkAgAigCpAJBgICAgHhHBEAgA0HwAGogAkGkAmoQpR0MAQsgA0GAgICAeDYCcAsgFiAdQcACbGohAQJAIAIoArACQYCAgIB4RwRAIANBgAFqIAJBsAJqEKUdDAELIANBgICAgHg2AoABCyAdQQFqIR0gAkHAAmohAiADQcgAaiImIANB1ABqKAIANgIAIAMgAykCTDcDQCADQThqIicgA0HgAGooAgA2AgAgAyADKQJYNwMwIANBKGoiKCADQewAaigCADYCACADIAMpAmQ3AyAgA0EYaiIpIANB+ABqKAIANgIAIAMgAykCcDcDECADQQhqIiogA0GIAWooAgA2AgAgAyADKQKAATcDACABQZoBaiAEQRB2OgAAIAEgBDsBmAEgASA3NwP4ASABIDg3A/ABIAEgOTcD6AEgASA6NwPgASABIDs3A9gBIAEgHzYC1AEgASAgNgLQASABICQ2AswBIAEgJTYCyAEgASAiNgLEASABICM2AsABIAEgFDYCvAEgASAGNgK4ASABIAU6ALMBIAEgGjoAsgEgASAbOgCxASABIBw6ALABIAEgITYCrAEgASAJOgCrASABIBA6AKoBIAEgEToAqQEgASASOgCoASABIDE3A6ABIAEgCjYCnAEgASALOgCbASABIA42ApQBIAEgDzYCkAEgASANOwGOASABIAw6AI0BIAEgCDoAjAEgASAHNgKIASABIC43A4ABIAEgLDcDeCABIC83A3AgASAtNwNoIAEgKzcDYCABIEE3A1ggASA1NwNQIAEgQDcDSCABIDY3A0AgASA/NwM4IAEgMDcDMCABID43AyggASA0NwMgIAEgPTcDGCABIDI3AxAgASA8NwMIIAEgMzcDACABQYgCaiAmKAIANgIAIAEgAykDQDcDgAIgASADKQMwNwKMAiABQZQCaiAnKAIANgIAIAEgAykDIDcDmAIgAUGgAmogKCgCADYCACABIAMpAxA3AqQCIAFBrAJqICkoAgA2AgAgAUG4AmogKigCADYCACABIAMpAwA3A7ACIAEgGTYCvAIgGEEBayIYDQALCyAAIBU2AgggACAWNgIEIAAgEzYCACADQZABaiQADwsgEyADKAKIAUHQtcIAEP0vCwAL/SYDEX8FfgF9IwBB8ABrIgokAAJAIAJFDQACQAJAIAEtAABBK2sOAwACAQILQQEhDAwBC0EBIQxBASETCwJAAkACQAJAAkACQAJ/AkACQAJAQQRBAgJ/AkACQAJAAkAgAiAMSwRAAkAgAiAMIgZrIg1BCEkNACANIQMDQCABIAZqKQAAIhRCxoyZsuTIkaPGAHwgFEKw4MCBg4aMmDB9IhSEQoCBgoSIkKDAgH+DQgBSDQEgF0KAwtcvfiAUQgp+IBRCCIh8IhRCEIhC/4GAgPAfg0KBgICAgOIJfiAUQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFyAGQQhqIQYgA0EIayIDQQdLDQALCwJAIAIgBksEQEEAIAJrIQkgBkEBaiEDIAEgBmohBgJAA0AgBi0AACIHQTBrIgRB/wFxQQlLDQEgASADakEAIAIgA0sbIQYgF0IKfiAErUL/AYN8IRcgCSADQQFqIgNqQQFHDQALIAEgDGohCCANrSEWIA0hCyACIQdBACEDIAIhBgwFCyADQQFrIQYgB0EuRg0BC0EAIQMgBiEEDAILAkAgAiADa0EISQRAIAMhBAwBCyACIANrIQsgAyEEA0AgASAEaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBdCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRcgBEEIaiEEIAtBCGsiC0EHSw0ACwsCQCACIARNDQADQCABIARqLQAAQTBrIgdB/wFxQQlLDQEgF0IKfiAHrUL/AYN8IRcgAiAEQQFqIgRHDQALIAIhBAsgASADaiESQgAgBCADayIFrX0hGEEBIQMMAQsgACAMNgIEIABBAzYCAAwOCyABIAxqIQggBiAMayILrSEWIAIgBE0EQCAEIQcMAQsgASAEai0AACIHQcEAa0H/AXFBGklBBXQgB3IiB0HlAEYgBSALaiIJRQ0DGiAHQeUARwRAIAQhBwwCCwJAIARBAWoiByACTw0AAkACQCABIAdqLQAAQStrDgMBAgACCyAEQQJqIQdBASEODAELIARBAmohBwtBBSEPIAIgB00NCCAHIQMCQANAIAEgA2otAABBMGsiBEH/AXFBCUsNASAVQgp+IAStQv8Bg3wgFSAVQoCAgIABUxshFSACIANBAWoiA0cNAAsgAiEDCyADIAdGDQhCACAVfSAVIA4bIhUgGHwhGCADIQcMAQsgBSALaiIJRQ0BC0EAIAlBEyIETQ0FGiABIAxqIQ8gDCACayEOIAlBE2shEEEAIQMDQCADIA9qLQAAIhFBMEcNAyAOIANBAWoiA2oNAAsgECANayIDQQAgAyAQTRshECACIQkMAwsgByEEQQALIANyIgMbIQ8gBCAMIAMbIQcMBAsgECADayIJQQAgCSAQTRshECACIAMgDGoiCSARQS5GIAIgCUtxIhFqIglNBEAgCSEDDAILIA8gEWogA2ohDyAOIBFqIANqIQ4gCSEDA0AgDy0AAEEwRw0CIA9BAWohDyADQQFqIQMgDkEBaiIODQALCyACIQMLIAMgCWsiESAQSQRAQQAhAwJAIAYgDEYNAANAIAMgCGotAABBMEcNASALIANBAWoiA0cNAAsgCyEDC0IAIRcCQCALIANrIgZBCEkNACAGQQhrIQYDQCADIAhqKQAAIhRCxoyZsuTIkaPGAHwgFEKw4MCBg4aMmDB9IhSEQoCBgoSIkKDAgH+DQgBSDQEgF0KAwtcvfiAUQgp+IBRCCIh8IhRCEIhC/4GAgPAfg0KBgICAgOIJfiAUQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFyADQQhqIQMgBEEIayIEQQlJDQEgBkEHSyAGQQhrIQYNAAsLIARFIQ4CQCAERSADIAtPckUEQANAIBdCCn4gAyAIai0AAEEwa61C/wGDfCEXIARBAUYhDiAEQQFrIQYgA0EBaiIDIAtPDQIgBEEBRyAGIQQNAAwCCwALIAQhBgsCQCAODQACQCASBEBBACEDAkAgBUUgF0IAUnINAANAIAMgEmotAABBMEcNASAFIANBAWoiA0cNAAsgBSEDCyAGQQlJDQEgBSADayIEQQhJDQEgBEEIayEEA0AgAyASaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0CIBdCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRcgA0EIaiEDIAZBCGsiBkEJSQ0CIARBB0sgBEEIayEEDQALDAELQcDWgAEQsjsAC0IAIRYgBkUgAyAFT3INACAGQQFrIQQDQCAXQgp+IAMgEmotAABBMGutQv8Bg3whFyADQQFqIgMgBU8NASAEIgZBAWshBCAGDQALCyAVIAOtfSAWfCEYCyAQIBFLCyEDQQIhDyACIAdGDQELIA1BA0kNA0EAIQMgAiAMayIEQQAgAiAETxshBSABIAxqIQsgDEEDaiEIA0AgA0EDRgRAQwAAwH8hGQwECyADIAVGDQIgA0Hg1oABaiEGIAMgC2ogA0EBaiEDLQAAIgQgBi0AACIBRiABIARzQSBGcg0ACwwBCyAKIAM6AEkgCiATOgBIIAogCzYCRCAKIAg2AkAgCiAFNgI8IAogEjYCOCAKIBc3AzAgCiAYPgIoIAogGEIgiD4CLCAKQSBqIQJBACEBIwBBEGsiByQAAkACfSAKQShqIgQpAwAiFUJ2UyAVQhFVcg0BIAQpAwgiFEKAgIAIVg0BIAQtACFBAXENASAVQgtZBEAgByAUQgAgFadBA3RBsPGAAWopAwBCABCoHiAHKQMIUEUNAiAHKQMAIhRCgICACFYNAiAUtUP5AhVQlAwBCyAVpyEBIBS1IRkgFUIAWQRAIAFBAnRBwO+AAWoqAgAgGZQMAQsgGUHA74ABIAFBAnRrKgIAlQsiGYwgGSAELQAgGyEZQQEhAQsgAiAZOAIEIAIgATYCACAHQRBqJAAgCigCIEEBcQRAIAoqAiQhGSAAQTE2AgAgACAZOAIEDAQLIApB0ABqIAopAygiFCAXEMALAkACQAJAIANFIAooAlgiBkEASHJFBEAgCkHgAGogFCAXQgF8EMALIAooAmggBkYEQCAKKQNQIhUgCikDYFENAwsgFKciA0HWAmoiAUGKBUsNAyAXeSIUpyECIApBEGogAUEEdEHwmIEBaiIBKQMAQgAgFyAUhiIVQgAQqB4gCikDGCIXQv//////B4NC//////8HUQRAIAopAxAhFCAKIAEpAwhCACAVQgAQqB4gCikDCEJ/hSAUVK0gF3whFwsgA0HqpA1sQRB1IBdCP4hQIgEgAmprQen+AWshBiAXIAGthiEVDAELIAopA1AhFSAGQQBODQELIApB4ABqIQ0gBkGAgAJqIQsjAEHwC2siBSQAIApBKGoiAykDACEWIAMpAwgiFEKQzgBaBEADQCAWQgR8IRYgFEL/wdcvViAUQpDOAIAhFA0ACwsgFELkAFoEQANAIBZCAnwhFiAUQo/OAFYgFELkAIAhFA0ACwsgFEIKWgRAA0AgFkIBfCEWIBRC4wBWIBRCCoAhFA0ACwsgBUH8A2oiAiADQfIAEKYBIAVBBGoiASACQfgD/AoAAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgFqcgBSgC9AdrQQFqIgdBAEgEQCAFQfgHaiABQfgD/AoAAAJ/IAtBAWsiBkFXTARAIBVBwABBASALayIBIAFBwABOG0E/ca2IQgAgAUE/TBsiFkL///8DVgwBC0IAIBVCKIhC////A4MgC0EoaiICQf4BSiIBGyEWQf8BIAIgARsLIQECfyABQRd0rSAWhKciAkGAgID8B3EiAUUEQCAWp0H///8DcSEIQep+DAELIAJB////A3FBgICABHIhCCABQRd2QZcBawshASAFQQE7AfAHIAUgCEEBdEEBcjYC/AMgBUEANgKABCAFQfwDakEAIAdrEM4KRQ0BAkAgASAHayIHQQBMBEAgB0EATg0JQQAgB2siB0EfcSIEDQEMCAsgB0EfcSIERQ0FQSAgBGshAwJAIAUvAfAHIgFFBEBBACECDAELIAFBAnQhCSAFQfwDaiEIQQAhAgNAIAggAiADdiAIKAIAIgIgBHRyNgIAIAhBBGohCCAJQQRrIgkNAAsLIAIgA3YiAkUNBSAFLwHwByIBQfwASw0GIAVB/ANqIAFBAnRqIAI2AgAgBSAFLwHwB0EBajsB8AcMBQtBICAEayEDAkAgBS8B7AsiAUUEQEEAIQIMAQsgAUECdCEJIAVB+AdqIQhBACECA0AgCCACIAN2IAgoAgAiAiAEdHI2AgAgCEEEaiEIIAlBBGsiCQ0ACwsgAiADdiICRQ0GIAUvAewLIgFB/ABLDQggBUH4B2ogAUECdGogAjYCACAFIAUvAewLQQFqOwHsCwwGCyAFQQRqIAcQzgpFDQIgB0EfcSIERQ0BQSAgBGshAwJAIAUvAfgDIgFFBEBBACECDAELIAFBAnQhCSAFQQRqIQhBACECA0AgCCACIAN2IAgoAgAiAiAEdHI2AgAgCEEEaiEIIAlBBGsiCQ0ACwsgAiADdiICRQ0BIAUvAfgDIgFB/ABLDQIgBUEEaiABQQJ0aiACNgIAIAUgBS8B+ANBAWo7AfgDDAELQYDWgAEQsjsACyAFLwH4AyEBAn4CQAJAIAdBIEkEQCABIQIMAQsgB0EFdiIDIAFqIgJB/QBLDQMgAUUEQEEAIQhCACEWQgAhFAwCCyADQQJ0IQQgAUECdCIDBEAgBUEEaiIBIARqIAEgA/wKAAALIAQEQCAFQQRqQQAgBPwLAAsgBSACOwH4AwtCACEWQgAhFAJAAn4CQAJAAkAgAkH//wNxIggOAwUBAgALIAhBAnQiCCAFQQRqaiIBQQxrKQIAIhVBICABQQRrKAIAIgNnIgFrrYggA60gAUEgc60iFIaEIRZBACEJIBUgFIZCAFINAyAFQQxrIQMDQCAIQQxGIgkNBCADIAhqIAhBBGshCCgCAEUNAAsMAwsgBSAIQQJ0aigCACIBrSABZ0Egc62GDAELIAhBAnQgBWpBBGspAgAiFCAUeYYLIRZBASEJC0EAIQMCQCACQf//A3EiAkUNACAFIAJBAnRqIgFFDQAgASgCAGchAwsgFkIoiCEUIAJBBXQgA2shCEIBIBZC//////8fgyIVQoCAgICAEFYgCSAVQoCAgICAEFJyRXINARoLIBZC//////8/g0KAgICAgDBRrQshFSANQf8BQf4AQf8AIBQgFXwiFEKAgIAIVBsgCGoiASABQf4BSyIBGzYCCCANQgAgFEL///8DgyABGzcDAAwIC0Gw1oABELI7AAsgB0EgSQ0CIAdBBXYiASAFLwHwByICaiIDQf0ASw0AIAJFDQIgAUECdCEEIAJBAnQiAgRAIAVB/ANqIgEgBGogASAC/AoAAAsgBARAIAVB/ANqQQAgBPwLAAsgBSADOwHwBwwCC0Gg1oABELI7AAsgB0EgSQ0AIAdBBXYiASAFLwHsCyICaiIDQf0ASw0BIAJFDQAgAUECdCEEIAJBAnQiAgRAIAVB+AdqIgEgBGogASAC/AoAAAsgBARAIAVB+AdqQQAgBPwLAAsgBSADOwHsCwsgBS8B7AsiAyAFLwHwByIBRg0BIAEgA0kgASADS2sMAgtBkNaAARCyOwALIAFBAnQhAiADQQJ0IQggBUH4A2ohByAFQfQHaiEEA0BBACAIRSACRXINARogAiAHaiEDIAQgCGogAkEEayECIAhBBGshCCgCACIJIAMoAgAiAUYNAAsgASAJSSABIAlLawshAiANAn8gBkFYTgRAIBVCKIghFEIAAn4CQAJAAkAgAkH/AXEOAgECAAtCAAwCCyAUQgGDDAELQgELIBR8IhRC////A4NBKEEpIBRCgICACFQbIAtqIgJB/gFKIgEbIRZB/wEgAiABGwwBC0IAIRYgFUHAAEEBIAtrIgEgAUHAAE4bQT9xrYhCACABQT9MGyEUAkACQAJAIAJB/wFxDgIAAQILIBRCAYMhFgwBC0IBIRYLIBQgFnwiFkL///8DVgs2AgggDSAWNwMACyAFQfALaiQAIAooAmghBiAKKQNgIRULIABBMTYCACAAIAZBF3StIBWEp74iGYwgGSATGzgCBAwECyABQYsFQdDWgAEQwyEACwJAIA1BCEkNACAMQQhyIQFBACEDA0AgA0EIRgRAQwAAgH8hGSABIQgMAwsgAyAFRg0BIANB5taAAWohCSADIAtqIANBAWohAy0AACIGIAktAAAiBEYgBCAGc0EgRnINAAsLQQAhAwNAIANBA0YEQEMAAIB/IRkMAgsgAyAFRg0CIANB49aAAWohBiADIAtqIANBAWohAy0AACIEIAYtAAAiAUYgASAEc0EgRnINAAsMAQsgAiAIRw0AIABBMTYCACAAIBmMIBkgExs4AgQMAQsgACAHNgIEIAAgDzYCAAsgCkHwAGokAAuaGAIGfw1+IwBB8AJrIgQkACAEIAM2AgwgBCABIAIQ9AggBCAEKAIEIgE2AhQgBCAEKAIAIgI2AhAgBEEBOwHEAiAEIAE2AsACIARBADYCvAIgBEEBOgC4AiAEQS42ArQCIAQgATYCsAIgBEEANgKsAiAEIAE2AqgCIAQgAjYCpAIgBEEuNgKgAiAEQRhqIARBoAJqENIVAkACQAJAAkACQAJAAkACQCAEKAIgIghBAk0EQCAIRQ0DIAQoAhwiBigCACEBIAYoAgQiAg0BQQAhAgwCCyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAYLAkACQCABLQAAQStrDgMBAgACC0EBIQkgAkEBRwRAIAEsAAFBv39MDQQLIAJBAWshAiABQQFqIQEMAQsgAkEBRwRAIAEsAAFBv39MDQQLIAJBAWshAiABQQFqIQELIAQgAjYCKCAEIAE2AiRBASEHIAhBAkYEQCAGKAIIIQcgBigCDCEFCyAEIAU2AjAgBCAHNgIsIAJFDQMgAS0AAEEwa0H/AXFBCkkNAyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAQLQQBBAEGUm4ABEMMhAAsgASACQQEgAkGkm4ABEKM2AAsgASACQQEgAkG0m4ABEKM2AAsCQCAFRQ0AIActAABBMGtB/wFxQQpJDQAgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwBCwJAAkACQAJAAkAgAyAFTwRAIANBACADIAVLGyIBQYCABE8NASAEIAE7AfwBIARBADYC+AEgBEHMATYC9AEgBEEBNgK0AiAEQfybgAE2ArACIARBATYCpAIgBEH0m4ABNgKgAiAEQQI2AqwCIAQgBEEsajYC8AEgBCAEQfABaiICNgKoAiAEQcABaiIBIARBoAJqIgMQmQ4gBEECNgKkAiAEQZScgAE2AqACIARCAjcCrAIgBEH+DzYC/AEgBEHMATYC9AEgBCACNgKoAiAEIAE2AvgBIAQgBEEkajYC8AEgBEE0aiADEJkOIAEQ3jsMBQsgBEGgAmoiBiAHIAUQzBAgBCgCoAJBAXENAyAEIAQpA8gCIhI3A1ggBCAEKQPAAiITNwNQIAQgBCkDuAIiFDcDSCAEIAQpA7ACIhU3A0AgBEHwAWpCCkIAELIuIAYgBCkD8AEgBCkD+AEgBCkDgAIgBCkDiAIgBSADaxDfASAEKAKgAkEBRgRAIAAgBCkCpAI3AgQgAEEMaiAEKAKsAjYCACAEKQOwAiEKIABBATYCACAAIAo3AxAMBgsgBCkDyAIhDiAEKQPAAiEPIAQpA7gCIRAgBCkDsAIhESAEQaACaiIDQgJCABCyLiADIBEgECAPIA4gBCkDoAIgBCkDqAIgBCkDsAIgBCkDuAIQmggCfiAELQCgAkEBRgRAQoCAgICAgICAgH8gBC0AoQINARoMCAsgBCkDwAIhDCAEKQO4AiEKIAQpA7ACIQ0gBCkDyAILIRYgBCANNwNgIAQgCjcDaCAEIAw3A3AgBCAWNwN4IARCACAKIA1CAFKtfH0iCjcDiAEgBEIAIA19Ig03A4ABIAQgDUIAUiAKQgBSIApQG0F/c61CAYMiCiAMQn+FfCIMNwOQASAEIAogDFatIBZCf4V8NwOYASAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCfiAELQCgAkEBRgRAIAQtAKECBEBCgICAgICAgICAfyENQgAhCkIADAILDAgLIAQpA8gCIQ0gBCkDuAIhCiAEKQOwAiELIAQpA8ACCyEMIARBoAJqIBUgFCATIBIgESAQIA8gDhCaCAJAIAQtAKACQQFGBEAgBC0AoQIEQCAEQbgBakIANwMAIARBsAFqQgA3AwAgBEIANwOoASAEQgA3A6ABDAILIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBpJSAARDvLAALIAQgBCkD6AI3A7gBIAQgBCkD4AI3A7ABIAQgBCkD2AI3A6gBIAQgBCkD0AI3A6ABCwJAIARBQGtB0JOAARD7GyIDQf8BcUECRyADwEEATnFFBEAgBEGgAWogBEGAAWoQ+xvAQQBMDQEMAwsgBEGgAWogBEHgAGoQ+xsiA0H/AXFBAkYgA8BBAEhyDQIgDSAMIAtCAXwiDiAKIA5QrXwiD4RQrXwiCiAMVK18IQ0MAwsgC0IBfSEOIAogC1CtfSEPIAwgCiALhFCtIgt9IQogDSALIAxWrX0hDQwCCyAEQQA2ArACIARBATYCpAIgBEGwl4ABNgKgAiAEQgQ3AqgCIARBoAJqQeSbgAEQ7ywACyALIQ4gCiEPIAwhCgsCfiACRQRAQgAhC0IAIQxCACERQgAMAQsgBEGgAmogASACEMwQIAQgBCgCoAJBAXEEfkIABSAEIAQpA8gCNwOYAiAEIAQpA8ACNwOQAiAEIAQpA7gCNwOIAiAEIAQpA7ACNwOAAkIBCzcD8AEgBEIANwP4ASAEQaACaiIBIARB8AFqIARBEGoQkhcgBEHAAWogASAEQQxqEOYNIAQoAsABQQFGBEAgACAEKQLEATcCBCAAQQxqIAQoAswBNgIAIAQpA9ABIQogAEEBNgIAIAAgCjcDEAwECyAEKQPoASERIAQpA+ABIQwgBCkD0AEhCyAEKQPYAQshECAEQQE2AvQBIARB9JuAATYC8AEgBEIBNwL8ASAEQf8PNgLEASAEIAsgDnwiDjcDoAIgBCALIA5WIgGtIA8gEHx8Igs3A6gCIAQgCiAMfCIKIAEgCyAQVCALIBBRG618Igs3A7ACIAQgCiALVq0gCiAMVK0gDSARfHx8NwO4AiAEIARBwAFqNgL4ASAEIARBoAJqNgLAASAEQTRqIARB8AFqEJkODAELIARBATYCpAIgBEHUnIABNgKgAiAEQgE3AqwCIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKAIANgIAIAQpAvwBIQogAEEBNgIAIAAgCjcDEAwBCyAEKAI8IQIgCQRAIARBNGpBARCELiACBEAgBCgCOCIBQQFqIAEgAvwKAAALIAQoAjhBLToAACAEIAJBAWoiAjYCPAsgBEGgAmoiASAEKAI4IAIQzBAgBCgCoAJBAXEEQCAEQQM2AqQCIARBkJ2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQeicgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogARCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIEIABBDGogBEH4AWooAgA2AgAgBCkC/AEhCiAAQQE2AgAgACAKNwMQIARBNGoQ3jsMAQsgBEGgAmogBCkDsAIgBCkDuAIgBCkDwAIgBCkDyAIQ1iMgAAJ/AkAgBCgCoAJBAXFFDQAgBCkDuAIgBCkDsAIiCkKAgICAgICAgIB/fSAKVK18QgBSDQAgACAKNwMIQQAMAQsgBEECNgKkAiAEQeSdgAE2AqACIARCAjcCrAIgBEHMATYCzAEgBEHonIABNgLIASAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIARBoAJqEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaikCADcCACAAQRRqIARBgAJqKAIANgIAQQELNgIAIARBNGoQ3jsLIARBGGoQ6jsgBEHwAmokAA8LIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBlJSAARDvLAALyhoCCn8DfiMAQdACayIEJAAgBCADNgIIAkACQAJAAkACQCACIANNBEAgBCACNgKwASAEQQI2ApwCIARB8MDPADYCmAIgBEICNwKkAiAEQTs2AuwBIARBOzYC5AEgBCAEQeABajYCoAIgBCAEQbABajYC6AEgBCAEQQhqNgLgASAAQQRqIARBmAJqEJkOIABBADYCAAwBCyABIANB4ABsaiEGAkAgAw0AIAYoAhhBAUYEQCAGKAIcDQELIARBAzsBNCAEQRE6ACAgBEEANgIcIARCgICAgMAANwIUIARBADYCDCAEIAYpAlg3AiwgBEGYAmoiASAEQQxqEMIOAkAgBCgCmAJBAUcEQCAEQeABaiICIAFBBHJBNPwKAABBPEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBNPwKAAAgACABNgIIIABCiICAgBA3AwAMAwsgBEHwAWogBEGwAmopAwA3AwAgBEHoAWogBEGoAmopAwA3AwAgBCAEKQOgAjcD4AFBzJ7PAEErIARB4AFqQbyezwBB1L/PABDVHgALDAQLIARBmAJqIQkgBigCICEKIAYoAiQhCCMAQTBrIgUkAAJAIApBAXEEQCAFIAg2AgwgCEEWTwRAIAVBATYCFCAFQcz4zgA2AhAgBUIBNwIcIAVBnAM2AiwgBSAFQShqNgIYIAUgBUEMajYCKCAJQQRqIAVBEGoQmQ4gCUEANgIADAILIAhBAWohBwsgCUEINgIAIAkgBzoABAsgBUEwaiQAIAQtAJwCIQkgBCgCmAIiBUEIRwRAIAAgBCkAnQI3AAUgAEEUaiAEQawCaigAADYAACAAQQ1qIARBpQJqKQAANwAAIAAgCToABCAAIAU2AgAMAQsCQCAGKAJAIgVBEkcEQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEQIAVBAmsgBUEBTRtBAWsOEAABAgMEBQYHCAkKCwwNDg8QCyAEQQM2ApgCDBALIARBBDYCmAIMDwsgBEEFNgKYAgwOCyAEQQY2ApgCIAQgBikCRDcCnAIMDQsgBEEHNgKYAgwMCyAEQQg2ApgCIAQgBi8BRDsBnAIMCwsgBEEJNgKYAiAEIAYvAUQ7AZwCDAoLIARBCjYCmAIgBCAGLwFEOwGcAgwJCyAEQQs2ApgCDAgLIARBDDYCmAIMBwsgBEENNgKYAgwGCyAEQQ42ApgCDAULIARBDzYCmAIMBAsgBEEQNgKYAiAEIAYvAUQ7AZwCDAMLAkAgBigCREGAgICAeEcEQCAEQeABaiAGQcQAahDdIAwBCyAEQYCAgIB4NgLgAQsgBEGkAmogBEHoAWooAgA2AgAgBCAEKQLgATcCnAIgBEERNgKYAgwCCwJAIAYoAkhBgICAgHhHBEAgBEHgAWogBkHIAGoQ3SAMAQsgBEGAgICAeDYC4AELIARBqAJqIARB6AFqKAIANgIAIAQgBTYCmAIgBCAEKQLgATcCoAIgBCAGKAJENgKcAgwBCyAEQQI2ApgCCyAEQThqIQVBBCEHQQ8hCgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRAgBEGYAmoiCCgCACILQQJrIAtBAU0bQQFrDhABAgMEBQYHCAkKCwwNDhAPAAsgBUEAOgAADBELIAVBAToAAAwQCyAFQQI6AAAMDwsgBUEDOgAADA4LIAVBBDoAACAFIAgpAgQ3AgQMDQsgBUEFOgAADAwLIAVBBjoAAAwKCyAFQQc6AAAMCQsgBUEIOgAADAgLIAVBCToAAAwICyAFQQo6AAAMBwsgBUELOgAADAYLIAVBDDoAAAwFCyAFQQ06AAAMBAsgBUEOOgAADAMLQQghB0EQIQoLIAUgCjoAACAHIAhqEIYwDAELIAUgCC0ABDoAAiAFIAgtAAU6AAELIAQtADhBCEcNASAELQA5QQhrIgVBBXQgBUH4AXFBA3ZyQf8BcSIFQQdNQQBBASAFdEGLAXEbDQEgCEE7QQBBAUEBEKAYIAQoApwCIQEgBCgCmAJBAUYNBiAEKAKgAiICQZi/zwBBO/wKAAAgAEE7NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAILIARBEToAOAsgBigCPCEFIAYoAjghCAJAAkACQAJAIAYoAhhBAUcNACAGKAIcIgdFDQBBAyEKIAEgA0HgAGxqIgYoAhBBAUcNAyAEQZgCaiAGQRBqKAIEEOUeIAQoApgCIgZBCGsOAgIDAQsCQCABIANB4ABsaiICKAIQBEAgBEGYAmogAkEQaigCBBDlHiAELQCcAiECIAQoApgCIgdBCEYNASAAIAQpAJ0CNwAFIABBFGogBEGsAmooAAA2AAAgAEENaiAEQaUCaikAADcAACAAIAI6AAQgACAHNgIADAULIARBmAJqQTVBAEEBQQEQoBggBCgCnAIhASAEKAKYAkEBRg0IIAQoAqACIgJB9L/PAEE1/AoAACAAQTU2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAsgBigCAEEBRgRAIARBmAJqIAYoAgQQ5B4gBC0AnAIhBiAEKAKYAiIHQQhHBEAgACAEKQCdAjcABSAAQRRqIARBrAJqKAAANgAAIABBDWogBEGlAmopAAA3AAAgACAGOgAEIAAgBzYCAAwFCyAEQdQAaiAEQUBrKAIANgIAIAQgBCkCODcCTCAEIAk6AG4gBCAGOgBtIAQgAjoAbCAEIAEgA0HgAGxqIgEpAlg3AlggBCABKAIMQX8gASgCCBs2AmAgBCABKAI0QX8gASgCMBs2AmQgBCABKAIsQX8gASgCKBs2AmggBCAFNgJIIAQgCDYCRCAEQZgCaiAEQcQAahDlASAEKAKYAkEBRgRAIARBhAFqIARBsAJqKQMAIg43AgAgBEH8AGogBEGoAmopAwAiDzcCACAEIAQpA6ACIhA3AnQgAEEQaiAONwIAIABBCGogDzcCACAAIBA3AgAMBQsgBEHwAGoiASAEQZgCakEEckE0/AoAACAAIAEQ5Sk2AgggACADQQFqNgIEIABBCDYCAAwECyAEQbgBaiAEQUBrKAIAIgY2AgAgBCAEKQI4Ig43A7ABIAEgA0HgAGxqKQJYIQ8gBEH8AWogBjYCACAEQQA2AvABIARCgICAgMAANwLoASAEIAU2AuQBIAQgCDYC4AEgBCAONwL0ASAEIAk6AIkCIAQgAkEDIAMbOgCIAiAEIA83AoACIARBmAJqIgEgBEHgAWoiAhDCDiAEKAKYAg0FIAIgAUEEckE0/AoAAEE8QQQQrTYiAUUNBiABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAIAE2AgggACADQQFqNgIEIABBCDYCAAwDCyAAIAQpAJ0CNwAFIABBDWogBEGlAmopAAA3AAAgAEEUaiAEQawCaigAADYAACAAIAQtAJwCOgAEIAAgBjYCAAwCCyAELQCcAiEKCyAEQQA2AqwBIARCgICAgMAANwKkASADQQFqIQYgB0EASgRAA0AgBEGYAmogASACIAYQwwEgBCgCoAIhCyAEKAKcAiEGIAQoApgCIgxBCEcEQCAAIAQpAqQCNwIMIABBFGogBEGsAmooAgA2AgAgACALNgIIIAAgBjYCBCAAIAw2AgAgBEGkAWoiABCiJyAAQQRBBBDgHgwDCyAEKAKsASIMIAQoAqQBRgRAIARBpAFqQbzAzwAQnSgLIAQoAqgBIAxBAnRqIAs2AgAgBCAMQQFqNgKsASAHQQFrIgcNAAsLIARBtAJqIARBQGsoAgA2AgAgBCAEKQI4NwKsAiAEIAk6AMECIARBADYCqAIgBEKAgICAwAA3AqACIARBADYCmAIgBCABIANB4ABsaikCWDcCuAIgBEEDOgDAAiAEQegBaiIHIARBrAFqKAIANgIAIAQgBCkCpAE3A+ABIARBsAFqIARBmAJqIgIgBEHgAWoiARDOIyAEKALUASELIAQtANgBIQkgBC0A2QEhDCAEQfwBaiAEQcwBaikCADcCACAEQfABaiINIARBwAFqKAIANgIAIAQgBCkCxAE3AvQBIAQgBCkCuAE3AugBIAQgDDoAiQIgBCAJIAogCkEDRhsgCSADGzoAiAIgBCALNgKEAiAEIAU2AuQBIAQgCDYC4AEgAiABEMIOIAQoApgCQQFGDQEgASACQQRyQTT8CgAAQTxBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAkEIaiABQTT8CgAAIAAgAjYCCCAAIAY2AgQgAEEINgIACyAEQdACaiQADwsgDSAEQbACaikDADcDACAHIARBqAJqKQMANwMAIAQgBCkDoAI3A+ABQcyezwBBKyAEQeABakG8ns8AQazAzwAQ1R4ACyAEQfABaiAEQbACaikDADcDACAEQegBaiAEQagCaikDADcDACAEIAQpA6ACNwPgAUHMns8AQSsgBEHgAWpBvJ7PAEHkv88AENUeAAtBBEE8EKM9AAsgASAEKAKgAkHko88AEP0vAAvBHQIHfwR+IwBBgANrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQcwATQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgQBCyAGQQE2AuQBIAZB+J6AATYC4AEgBkIBNwLsASAGQfQLNgLUAiAGQbyegAE2AtACIAYgBkHQAmo2AugBIABBBGogBkHgAWoQmQ4gAEGNgICAeDYCAAwNCyAGIAQ2ArABIAZBAjYC5AEgBkGsnoABNgLgASAGQgE3AuwBIAZBrwM2AtQCIAYgBkHQAmo2AugBIAYgBkGwAWo2AtACIABBBGogBkHgAWoQmQ4gAEGGgICAeDYCAAwMCyAGQRhqIAEgAigCEBEAACAGQeABaiICIAYoAhgiASAGKAIcKAIMEQAAAkAgAUUNACAGKQPgAULH2fTn3sS2nHeFIAYpA+gBQo2yzpSMypLmp3+FhFBFDQAgBiAGLQAvOgB7IAYgAzoAeiAFLQA0RQRAIAEQ0zohAyAGQeQBaiABEPk0IAYgAzYCgAIgBkEANgL8ASAGIAE2AuABIAYgBkH6AGo2AogCIAYgBkH7AGo2AoQCIAZB0AJqIQgjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohByMAQfAAayICJAAgAkEQaiIKIAEQ7RQCQAJAAkAgAikDGCACKQMQQgKFhFBFBEAgAkFAayIEIAEQwikgBEEEIAIoAkBBAWoiBUF/IAUbIgUgBUEETRtBAEEQQTAQoBggAigCRCEFIAIoAkBBAUYNAiACKAJIIgkgCkEw/AoAACACQQxqIgtBATYCACACIAk2AgggAiAFNgIEIAQgAUEw/AoAACMAQUBqIgEkACABIAQQ7RQgASkDCCABKQMAQgKFhFBFBEAgAkEEaiEFA0ACQCAFKAIIIgogBSgCAEcNACABQTRqIAQQwikgASgCNEEBaiIJQX8gCRsiCSAFKAIAIAUoAggiDGtNDQAgBSAMIAlBEEEwEN4oCyAFKAIEIApBMGxqIAFBMPwKAAAgBSAKQQFqNgIIIAEgBBDtFCABKQMIIAEpAwBCAoWEUEUNAAsLAkAgBCgCBCIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAEQQRqEPseCyABQUBrJAAgB0EIaiALKAIANgIAIAcgAikCBDcCAAwBCyAHQQA2AgggB0KAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQfAAaiQADAELIAUgAigCSEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAggAykCADcCACAIQRBqIANBEGooAgA2AgAgCEEIaiADQQhqKQIANwIAIAcQ5DwMAQsgCCADKQIUNwIEIAhBk4CAgHg2AgAgCEEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHcAmooAgA2AgAgBiAGKQLUAjcDsAEgBigC0AIiBEGTgICAeEYNBCAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC4AIhAgwMCyABENM6IQcgBkGAAWoiBCABEPk0IAYgBzYCnAEgBkEANgKYASAGIAE2AnwgARDTOhogARDTOiEKIAEQ0zoaIAYgARDTOiICNgK8AiAGQcACakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQV0IgghAwJAIAhBIHEiAgRAIAggAmtBQGsiAyAISQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAYoAsgCIQkgBkHcAmogBEEIaikCADcCACAGQeQCaiAEQRBqKQIANwIAIAYgATYC0AJBACECIAZBADYC/AIgBiAHNgLwAiAGQQA2AuwCIAYgBCkCADcC1AIgBiAGQfoAajYC+AIgBiAGQfsAajYC9AIgBSEEIAdFDQcgBkHgAWpBBHIhBwNAAkACQAJAAkACQCAGKALUAkUNACACIAYoAuQCTw0CIAYoAtgCIAYoAuACIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAGIAJBAWo2AuwCDAELIAYgAkEBajYC7AIgBkEQaiAGKALQAiACEI8sIAZB4AFqIAYoAhAgBigCFCAGKAL0AiwAABDWASAGKALgASIBQQFGBEAgAUUNASAHEIgRDAELIAYpA/ABIg0gBikD+AEiDiAGKQOAAiIPIAYpA4gCIhAgBigC+AItAAAQ3B0NAgsgBiAGKAL8AkEBajYC/AIgBEEYakIANwMAIARBEGpCADcDACAEQQhqQgA3AwAgBEIANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBiAGKAL8AiIBQQFqNgL8AiAEQRhqIBA3AwAgBEEQaiAPNwMAIAQgDjcDCCAEIA03AwAgCSABQQN2aiICIAItAABBASABQQdxdHI6AAALIARBIGohBCAGKALsAiICIAYoAvACRw0ACwwHC0HAACADEKM9AAtB5JSAAUEpIAZB4AFqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYC5AEgBkG0n4ABNgLgASAGQgE3AuwBIAZB9As2AtQCIAYgBkHQAmo2AugBIAYgBkEvajYC0AIgAEEEaiAGQeABahCZDiAAQY2AgIB4NgIADAoLIAZBIGogASACKAIQEQAAIAZB0AJqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPQAkKrmJHxlfrV/IB/hSAGKQPYAkKWlPir8LHps+EAhYRQRQ0AIAZB4AFqIAEgAyAGLQAvIAUQtQIgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBiAGKQLoASINNwOwASAGKALkASECIAYoAvQBIQMgAEEMaiABNgAAIAAgDTcABCAAIAM2AhAgACACNgIADAsLIAZB+ABqIAYtAOMBOgAAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZBOGogBkHwAWooAgA2AgAgBiAGLwDhATsBdiAGIAYpAvgBNwNQIAYgBikC6AE3AzAgBigC5AEhASAGKAL0ASEFDAQLQYSegAEQsjsACyAGQcgCaiABKAIAIgE2AgAgBiAGKQOwATcDwAIgBkHgAWoiAiAGKALEAiIDIAMgAUEwbGoQzwggBkHQAmogAiAGLQB6IAYtAHsQoxMgBi0A0AIiAkEpRgRAIAZBuAFqIAZB4AJqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAtgCIg03A7ABIAYgDTcDaCAGKALUAiEEIAYoAuQCIQIgBkHAAmoQ5DwMCAsgBkH4AGogBi0A0wI6AAAgBkG4AWogBkHgAmooAgAiATYCACAGQdgAaiAGQfACaikCADcDACAGQeAAaiAGQfgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A0QI7AXYgBiAGKQLYAiINNwOwASAGIAYpAugCNwNQIAYgDTcDaCAGKALUAiEBIAYoAuQCIQUgBkHAAmoQ5DwMAQsCQCAGKALUAiIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQdQCahD7HgsgBiAEIAVrQQV1IgE2ArACIAEgBigCvAJHDQIgBigCyAIhASAGKALMAiEEIAYgBikCwAI3AuwBIAZBADYC6AEgBiAENgLkASAGIAE2AuABIAZBCGogBkHgAWoiAhDXOyAGKAIIIQdBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAYpAuABNwIIIAFBEGogBkHoAWoiCSkCADcCACABQRhqIAZB8AFqIgsoAgA2AgAgBiADNgLwASAGQoCAgICACDcC6AEgBiAINgLkASAGIAU2AuABIAYgAhDXOyAGKAIAIQNBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAYpAuABNwIIIAJBEGogCSkCADcCACACQRhqIAsoAgA2AgAgBiAENgK4AiAGIAc2ArQCIAYgATYCsAJBDEEEEK02IgFFDQQgASAINgIIIAEgAzYCBCABIAI2AgAgBkEBNgLIAiAGIAE2AsQCIAZBATYCwAIgBkEANgLYAiAGQoCAgIDAADcC0AIgBkHgAWoiAkHokYABIAogBiAGQbACaiAGQcACaiAGQdACaiIBEIwTIAEgAhDFEyAGQbABaiABIAYtAHogBi0AexCjEyAGLQCwASICQSlGBEAgBkHwAGogBkHAAWooAgA2AgAgBiAGKQK4ASINNwOgASAGIA03A2ggBigCtAEhBCAGKALEASECDAcLIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzALQThBBBCtNiIDRQ0DIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBjJmAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwFCyAGQgA3AuwBIAZCgYCAgMAANwLkASAGQcSRgAE2AuABQQAgBkGwAmogBkG8AmogBkHgAWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg03A0AgAEEMaiABNgAAIAAgDTcABCAAIAI2AhAgACAENgIACyAGQYADaiQAC8EdAgd/BH4jAEGAA2siBiQAIAYgBDoALwJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkAgBEH/AXFBzABNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYC5AEgBkH4noABNgLgASAGQgE3AuwBIAZB9As2AtQCIAZBvJ6AATYC0AIgBiAGQdACajYC6AEgAEEEaiAGQeABahCZDiAAQY2AgIB4NgIADA0LIAYgBDYCsAEgBkECNgLkASAGQayegAE2AuABIAZCATcC7AEgBkGvAzYC1AIgBiAGQdACajYC6AEgBiAGQbABajYC0AIgAEEEaiAGQeABahCZDiAAQYaAgIB4NgIADAwLIAZBGGogASACKAIQEQAAIAZB4AFqIgIgBigCGCIBIAYoAhwoAgwRAAACQCABRQ0AIAYpA+ABQtPY0/j95vaSSIUgBikD6AFCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgARDUOiEDIAZB5AFqIAEQ+TQgBiADNgKAAiAGQQA2AvwBIAYgATYC4AEgBiAGQfoAajYCiAIgBiAGQfsAajYChAIgBkHQAmohCCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEHIwBB8ABrIgIkACACQRBqIgogARDuFAJAAkACQCACKQMYIAIpAxBCAoWEUEUEQCACQUBrIgQgARDAKSAEQQQgAigCQEEBaiIFQX8gBRsiBSAFQQRNG0EAQRBBMBCgGCACKAJEIQUgAigCQEEBRg0CIAIoAkgiCSAKQTD8CgAAIAJBDGoiC0EBNgIAIAIgCTYCCCACIAU2AgQgBCABQTD8CgAAIwBBQGoiASQAIAEgBBDuFCABKQMIIAEpAwBCAoWEUEUEQCACQQRqIQUDQAJAIAUoAggiCiAFKAIARw0AIAFBNGogBBDAKSABKAI0QQFqIglBfyAJGyIJIAUoAgAgBSgCCCIMa00NACAFIAwgCUEQQTAQ3igLIAUoAgQgCkEwbGogAUEw/AoAACAFIApBAWo2AgggASAEEO4UIAEpAwggASkDAEIChYRQRQ0ACwsCQCAEKAIEIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIARBBGoQ+x4LIAFBQGskACAHQQhqIAsoAgA2AgAgByACKQIENwIADAELIAdBADYCCCAHQoCAgICAAjcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB8ABqJAAMAQsgBSACKAJIQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgCCADKQIANwIAIAhBEGogA0EQaigCADYCACAIQQhqIANBCGopAgA3AgAgBxDkPAwBCyAIIAMpAhQ3AgQgCEGTgICAeDYCACAIQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQdwCaigCADYCACAGIAYpAtQCNwOwASAGKALQAiIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALgAiECDAwLIAEQ1DohByAGQYABaiIEIAEQ+TQgBiAHNgKcASAGQQA2ApgBIAYgATYCfCABENQ6GiABENQ6IQogARDUOhogBiABENQ6IgI2ArwCIAZBwAJqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBBXQiCCEDAkAgCEEgcSICBEAgCCACa0FAayIDIAhJDQELQcAAIQUgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBUUNAQsgBigCyAIhCSAGQdwCaiAEQQhqKQIANwIAIAZB5AJqIARBEGopAgA3AgAgBiABNgLQAkEAIQIgBkEANgL8AiAGIAc2AvACIAZBADYC7AIgBiAEKQIANwLUAiAGIAZB+gBqNgL4AiAGIAZB+wBqNgL0AiAFIQQgB0UNByAGQeABakEEciEHA0ACQAJAAkACQAJAIAYoAtQCRQ0AIAIgBigC5AJPDQIgBigC2AIgBigC4AIgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAYgAkEBajYC7AIMAQsgBiACQQFqNgLsAiAGQRBqIAYoAtACIAIQ2isgBkHgAWogBigCECAGKAIUIAYoAvQCLAAAENYBIAYoAuABIgFBAUYEQCABRQ0BIAcQiBEMAQsgBikD8AEiDSAGKQP4ASIOIAYpA4ACIg8gBikDiAIiECAGKAL4Ai0AABDcHQ0CCyAGIAYoAvwCQQFqNgL8AiAEQRhqQgA3AwAgBEEQakIANwMAIARBCGpCADcDACAEQgA3AwAMAgtBtJSAAUEgQdSUgAEQnykACyAGIAYoAvwCIgFBAWo2AvwCIARBGGogEDcDACAEQRBqIA83AwAgBCAONwMIIAQgDTcDACAJIAFBA3ZqIgIgAi0AAEEBIAFBB3F0cjoAAAsgBEEgaiEEIAYoAuwCIgIgBigC8AJHDQALDAcLQcAAIAMQoz0AC0HklIABQSkgBkHgAWpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQAC0H0nYABELI7AAsgBkEBNgLkASAGQbSfgAE2AuABIAZCATcC7AEgBkH0CzYC1AIgBiAGQdACajYC6AEgBiAGQS9qNgLQAiAAQQRqIAZB4AFqEJkOIABBjYCAgHg2AgAMCgsgBkEgaiABIAIoAhARAAAgBkHQAmogBigCICIBIAYoAiQoAgwRAAACQCABRQ0AIAYpA9ACQquYkfGV+tX8gH+FIAYpA9gCQpaU+Kvwsemz4QCFhFBFDQAgBkHgAWogASADIAYtAC8gBRC1AiAGLQDgASICQSlGBEAgBkG4AWogBkHwAWooAgAiATYCACAGIAYpAugBIg03A7ABIAYoAuQBIQIgBigC9AEhAyAAQQxqIAE2AAAgACANNwAEIAAgAzYCECAAIAI2AgAMCwsgBkH4AGogBi0A4wE6AAAgBkHYAGogBkGAAmopAgA3AwAgBkHgAGogBkGIAmopAgA3AwAgBkE4aiAGQfABaigCADYCACAGIAYvAOEBOwF2IAYgBikC+AE3A1AgBiAGKQLoATcDMCAGKALkASEBIAYoAvQBIQUMBAtBhJ6AARCyOwALIAZByAJqIAEoAgAiATYCACAGIAYpA7ABNwPAAiAGQeABaiICIAYoAsQCIgMgAyABQTBsahDPCCAGQdACaiACIAYtAHogBi0AexCjEyAGLQDQAiICQSlGBEAgBkG4AWogBkHgAmooAgAiATYCACAGQfAAaiABNgIAIAYgBikC2AIiDTcDsAEgBiANNwNoIAYoAtQCIQQgBigC5AIhAiAGQcACahDkPAwICyAGQfgAaiAGLQDTAjoAACAGQbgBaiAGQeACaigCACIBNgIAIAZB2ABqIAZB8AJqKQIANwMAIAZB4ABqIAZB+AJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDRAjsBdiAGIAYpAtgCIg03A7ABIAYgBikC6AI3A1AgBiANNwNoIAYoAtQCIQEgBigC5AIhBSAGQcACahDkPAwBCwJAIAYoAtQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZB1AJqEPseCyAGIAQgBWtBBXUiATYCsAIgASAGKAK8AkcNAiAGKALIAiEBIAYoAswCIQQgBiAGKQLAAjcC7AEgBkEANgLoASAGIAQ2AuQBIAYgATYC4AEgBkEIaiAGQeABaiICENc7IAYoAgghB0EcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBikC4AE3AgggAUEQaiAGQegBaiIJKQIANwIAIAFBGGogBkHwAWoiCygCADYCACAGIAM2AvABIAZCgICAgIAINwLoASAGIAg2AuQBIAYgBTYC4AEgBiACENc7IAYoAgAhA0EcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgBikC4AE3AgggAkEQaiAJKQIANwIAIAJBGGogCygCADYCACAGIAQ2ArgCIAYgBzYCtAIgBiABNgKwAkEMQQQQrTYiAUUNBCABIAg2AgggASADNgIEIAEgAjYCACAGQQE2AsgCIAYgATYCxAIgBkEBNgLAAiAGQQA2AtgCIAZCgICAgMAANwLQAiAGQeABaiICQeiRgAEgCiAGIAZBsAJqIAZBwAJqIAZB0AJqIgEQjBMgASACEMUTIAZBsAFqIAEgBi0AeiAGLQB7EKMTIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg03A6ABIAYgDTcDaCAGKAK0ASEEIAYoAsQBIQIMBwsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFCyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgNFDQMgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEGMmYABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAULIAZCADcC7AEgBkKBgICAwAA3AuQBIAZBxJGAATYC4AFBACAGQbACaiAGQbwCaiAGQeABakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDTcDQCAAQQxqIAE2AAAgACANNwAEIAAgAjYCECAAIAQ2AgALIAZBgANqJAALhhgCBn8NfiMAQfACayIEJAAgBCADNgIMIAQgASACEPQIIAQgBCgCBCIBNgIUIAQgBCgCACICNgIQIARBATsBxAIgBCABNgLAAiAEQQA2ArwCIARBAToAuAIgBEEuNgK0AiAEIAE2ArACIARBADYCrAIgBCABNgKoAiAEIAI2AqQCIARBLjYCoAIgBEEYaiAEQaACahDSFQJAAkACQAJAAkACQAJAAkAgBCgCICIIQQJNBEAgCEUNAyAEKAIcIgYoAgAhASAGKAIEIgINAUEAIQIMAgsgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwGCwJAAkAgAS0AAEEraw4DAQIAAgtBASEJIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBDAELIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBCyAEIAI2AiggBCABNgIkQQEhByAIQQJGBEAgBigCCCEHIAYoAgwhBQsgBCAFNgIwIAQgBzYCLCACRQ0DIAEtAABBMGtB/wFxQQpJDQMgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwEC0EAQQBBlJuAARDDIQALIAEgAkEBIAJBpJuAARCjNgALIAEgAkEBIAJBtJuAARCjNgALAkAgBUUNACAHLQAAQTBrQf8BcUEKSQ0AIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMAQsCQAJAAkACQAJAIAMgBU8EQCADQQAgAyAFSxsiAUGAgARPDQEgBCABOwH8ASAEQQA2AvgBIARBzAE2AvQBIARBATYCtAIgBEH8m4ABNgKwAiAEQQE2AqQCIARB9JuAATYCoAIgBEECNgKsAiAEIARBLGo2AvABIAQgBEHwAWoiAjYCqAIgBEHAAWoiASAEQaACaiIDEJkOIARBAjYCpAIgBEGUnIABNgKgAiAEQgI3AqwCIARB/g82AvwBIARBzAE2AvQBIAQgAjYCqAIgBCABNgL4ASAEIARBJGo2AvABIARBNGogAxCZDiABEN47DAULIARBoAJqIgYgByAFEMwQIAQoAqACQQFxDQMgBCAEKQPIAiISNwNYIAQgBCkDwAIiEzcDUCAEIAQpA7gCIhQ3A0ggBCAEKQOwAiIVNwNAIARB8AFqQgpCABCyLiAGIAQpA/ABIAQpA/gBIAQpA4ACIAQpA4gCIAUgA2sQ3wEgBCgCoAJBAUYEQCAAIAQpAqQCNwIEIABBDGogBCgCrAI2AgAgBCkDsAIhCiAAQQE2AgAgACAKNwMQDAYLIAQpA8gCIQ4gBCkDwAIhDyAEKQO4AiEQIAQpA7ACIREgBEGgAmoiA0ICQgAQsi4gAyARIBAgDyAOIAQpA6ACIAQpA6gCIAQpA7ACIAQpA7gCEJoIAn4gBC0AoAJBAUYEQEKAgICAgICAgIB/IAQtAKECDQEaDAgLIAQpA8ACIQwgBCkDuAIhCiAEKQOwAiENIAQpA8gCCyEWIAQgDTcDYCAEIAo3A2ggBCAMNwNwIAQgFjcDeCAEQgAgCiANQgBSrXx9Igo3A4gBIARCACANfSINNwOAASAEIA1CAFIgCkIAUiAKUBtBf3OtQgGDIgogDEJ/hXwiDDcDkAEgBCAKIAxWrSAWQn+FfDcDmAEgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAn4gBC0AoAJBAUYEQCAELQChAgRAQoCAgICAgICAgH8hDUIAIQpCAAwCCwwICyAEKQPIAiENIAQpA7gCIQogBCkDsAIhCyAEKQPAAgshDCAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCQCAELQCgAkEBRgRAIAQtAKECBEAgBEG4AWpCADcDACAEQbABakIANwMAIARCADcDqAEgBEIANwOgAQwCCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQaSUgAEQ7ywACyAEIAQpA+gCNwO4ASAEIAQpA+ACNwOwASAEIAQpA9gCNwOoASAEIAQpA9ACNwOgAQsCQCAEQUBrQdCTgAEQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIARBoAFqIARBgAFqEPsbwEEATA0BDAMLIARBoAFqIARB4ABqEPsbIgNB/wFxQQJGIAPAQQBIcg0CIA0gDCALQgF8Ig4gCiAOUK18Ig+EUK18IgogDFStfCENDAMLIAtCAX0hDiAKIAtQrX0hDyAMIAogC4RQrSILfSEKIA0gCyAMVq19IQ0MAgsgBEEANgKwAiAEQQE2AqQCIARBsJeAATYCoAIgBEIENwKoAiAEQaACakHkm4ABEO8sAAsgCyEOIAohDyAMIQoLAn4gAkUEQEIAIQtCACEMQgAhEUIADAELIARBoAJqIAEgAhDMECAEIAQoAqACQQFxBH5CAAUgBCAEKQPIAjcDmAIgBCAEKQPAAjcDkAIgBCAEKQO4AjcDiAIgBCAEKQOwAjcDgAJCAQs3A/ABIARCADcD+AEgBEGgAmoiASAEQfABaiAEQRBqEJIXIARBwAFqIAEgBEEMahDmDSAEKALAAUEBRgRAIAAgBCkCxAE3AgQgAEEMaiAEKALMATYCACAEKQPQASEKIABBATYCACAAIAo3AxAMBAsgBCkD6AEhESAEKQPgASEMIAQpA9ABIQsgBCkD2AELIRAgBEEBNgL0ASAEQfSbgAE2AvABIARCATcC/AEgBEH/DzYCxAEgBCALIA58Ig43A6ACIAQgCyAOViIBrSAPIBB8fCILNwOoAiAEIAogDHwiCiABIAsgEFQgCyAQURutfCILNwOwAiAEIAogC1atIAogDFStIA0gEXx8fDcDuAIgBCAEQcABajYC+AEgBCAEQaACajYCwAEgBEE0aiAEQfABahCZDgwBCyAEQQE2AqQCIARB1JyAATYCoAIgBEIBNwKsAiAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIARBoAJqEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaigCADYCACAEKQL8ASEKIABBATYCACAAIAo3AxAMAQsgBCgCPCECIAkEQCAEQTRqQQEQhC4gAgRAIAQoAjgiAUEBaiABIAL8CgAACyAEKAI4QS06AAAgBCACQQFqIgI2AjwLIARBoAJqIgEgBCgCOCACEMwQIAQoAqACQQFxBEAgBEEDNgKkAiAEQZCdgAE2AqACIARCAjcCrAIgBEHMATYCzAEgBEHInYABNgLIASAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIAEQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKAIANgIAIAQpAvwBIQogAEEBNgIAIAAgCjcDECAEQTRqEN47DAELIARBoAJqIAQpA7ACIAQpA7gCIAQpA8ACIAQpA8gCENYjIAACfyAEKAKgAkEBcQRAIAQpA7gCIQogACAEKQOwAjcDECAAIAo3AxhBAAwBCyAEQQI2AqQCIARB5J2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQcidgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKQIANwIAIABBFGogBEGAAmooAgA2AgBBAQs2AgAgBEE0ahDeOwsgBEEYahDqOyAEQfACaiQADwsgBEEANgKAAiAEQQE2AvQBIARBjJSAATYC8AEgBEIENwL4ASAEQfABakGUlIABEO8sAAvtFwIGfw1+IwBB8AJrIgQkACAEIAM2AgwgBCABIAIQ9AggBCAEKAIEIgE2AhQgBCAEKAIAIgI2AhAgBEEBOwHEAiAEIAE2AsACIARBADYCvAIgBEEBOgC4AiAEQS42ArQCIAQgATYCsAIgBEEANgKsAiAEIAE2AqgCIAQgAjYCpAIgBEEuNgKgAiAEQRhqIARBoAJqENIVAkACQAJAAkACQAJAAkACQCAEKAIgIghBAk0EQCAIRQ0DIAQoAhwiBigCACEBIAYoAgQiAg0BQQAhAgwCCyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBBGogBEGgAmoQmQ4gAEGNgICAeDYCAAwGCwJAAkAgAS0AAEEraw4DAQIAAgtBASEJIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBDAELIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBCyAEIAI2AiggBCABNgIkQQEhByAIQQJGBEAgBigCCCEHIAYoAgwhBQsgBCAFNgIwIAQgBzYCLCACRQ0DIAEtAABBMGtB/wFxQQpJDQMgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQRqIARBoAJqEJkOIABBjYCAgHg2AgAMBAtBAEEAQZSbgAEQwyEACyABIAJBASACQaSbgAEQozYACyABIAJBASACQbSbgAEQozYACwJAIAVFDQAgBy0AAEEwa0H/AXFBCkkNACAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBBGogBEGgAmoQmQ4gAEGNgICAeDYCAAwBCwJAAkACQAJAAkAgAyAFTwRAIANBACADIAVLGyIBQYCABE8NASAEIAE7AfwBIARBADYC+AEgBEHMATYC9AEgBEEBNgK0AiAEQfybgAE2ArACIARBATYCpAIgBEH0m4ABNgKgAiAEQQI2AqwCIAQgBEEsajYC8AEgBCAEQfABaiICNgKoAiAEQcABaiIBIARBoAJqIgMQmQ4gBEECNgKkAiAEQZScgAE2AqACIARCAjcCrAIgBEH+DzYC/AEgBEHMATYC9AEgBCACNgKoAiAEIAE2AvgBIAQgBEEkajYC8AEgBEE0aiADEJkOIAEQ3jsMBQsgBEGgAmoiBiAHIAUQzBAgBCgCoAJBAXENAyAEIAQpA8gCIhI3A1ggBCAEKQPAAiITNwNQIAQgBCkDuAIiFDcDSCAEIAQpA7ACIhU3A0AgBEHwAWpCCkIAELIuIAYgBCkD8AEgBCkD+AEgBCkDgAIgBCkDiAIgBSADaxDfASAEKAKgAkEBRgRAIAAgBCkCpAI3AgAgAEEIaiAEKAKsAjYCACAAIAQpA7ACNwIMDAYLIAQpA8gCIQ4gBCkDwAIhDyAEKQO4AiEQIAQpA7ACIREgBEGgAmoiA0ICQgAQsi4gAyARIBAgDyAOIAQpA6ACIAQpA6gCIAQpA7ACIAQpA7gCEJoIAn4gBC0AoAJBAUYEQEKAgICAgICAgIB/IAQtAKECDQEaDAgLIAQpA8ACIQwgBCkDuAIhCiAEKQOwAiENIAQpA8gCCyEWIAQgDTcDYCAEIAo3A2ggBCAMNwNwIAQgFjcDeCAEQgAgCiANQgBSrXx9Igo3A4gBIARCACANfSINNwOAASAEIA1CAFIgCkIAUiAKUBtBf3OtQgGDIgogDEJ/hXwiDDcDkAEgBCAKIAxWrSAWQn+FfDcDmAEgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAn4gBC0AoAJBAUYEQCAELQChAgRAQoCAgICAgICAgH8hDUIAIQpCAAwCCwwICyAEKQPIAiENIAQpA7gCIQogBCkDsAIhCyAEKQPAAgshDCAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCQCAELQCgAkEBRgRAIAQtAKECBEAgBEG4AWpCADcDACAEQbABakIANwMAIARCADcDqAEgBEIANwOgAQwCCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQaSUgAEQ7ywACyAEIAQpA+gCNwO4ASAEIAQpA+ACNwOwASAEIAQpA9gCNwOoASAEIAQpA9ACNwOgAQsCQCAEQUBrQdCTgAEQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIARBoAFqIARBgAFqEPsbwEEATA0BDAMLIARBoAFqIARB4ABqEPsbIgNB/wFxQQJGIAPAQQBIcg0CIA0gDCALQgF8Ig4gCiAOUK18Ig+EUK18IgogDFStfCENDAMLIAtCAX0hDiAKIAtQrX0hDyAMIAogC4RQrSILfSEKIA0gCyAMVq19IQ0MAgsgBEEANgKwAiAEQQE2AqQCIARBsJeAATYCoAIgBEIENwKoAiAEQaACakHkm4ABEO8sAAsgCyEOIAohDyAMIQoLAn4gAkUEQEIAIQtCACEMQgAhEUIADAELIARBoAJqIAEgAhDMECAEIAQoAqACQQFxBH5CAAUgBCAEKQPIAjcDmAIgBCAEKQPAAjcDkAIgBCAEKQO4AjcDiAIgBCAEKQOwAjcDgAJCAQs3A/ABIARCADcD+AEgBEGgAmoiASAEQfABaiAEQRBqEJIXIARBwAFqIAEgBEEMahDmDSAEKALAAUEBRgRAIAAgBCkCxAE3AgAgAEEIaiAEKALMATYCACAAIAQpA9ABNwIMDAQLIAQpA+gBIREgBCkD4AEhDCAEKQPQASELIAQpA9gBCyEQIARBATYC9AEgBEH0m4ABNgLwASAEQgE3AvwBIARB/w82AsQBIAQgCyAOfCIONwOgAiAEIAsgDlYiAa0gDyAQfHwiCzcDqAIgBCAKIAx8IgogASALIBBUIAsgEFEbrXwiCzcDsAIgBCAKIAtWrSAKIAxUrSANIBF8fHw3A7gCIAQgBEHAAWo2AvgBIAQgBEGgAmo2AsABIARBNGogBEHwAWoQmQ4MAQsgBEEBNgKkAiAEQdScgAE2AqACIARCATcCrAIgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiAEQaACahCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIAIABBCGogBEH4AWooAgA2AgAgACAEKQL8ATcCDAwBCyAEKAI8IQIgCQRAIARBNGpBARCELiACBEAgBCgCOCIBQQFqIAEgAvwKAAALIAQoAjhBLToAACAEIAJBAWoiAjYCPAsgBEGgAmoiASAEKAI4IAIQzBAgBCgCoAJBAXEEQCAEQQM2AqQCIARBkJ2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQdydgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogARCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIAIABBCGogBEH4AWooAgA2AgAgACAEKQL8ATcCDCAEQTRqEN47DAELIARBoAJqIAQpA7ACIAQpA7gCIAQpA8ACIAQpA8gCENYjAkACQCAEKAKgAkEBcUUNACAEKQOwAiIKQoCAgIAIfCILQv////8PViAEKQO4AiAKIAtWrXwiC0IAUiALUBsNACAAQZOAgIB4NgIAIAAgCj4CBAwBCyAEQQI2AqQCIARB5J2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQdydgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCACAAQQhqIARB+AFqKQIANwIAIABBEGogBEGAAmooAgA2AgALIARBNGoQ3jsLIARBGGoQ6jsgBEHwAmokAA8LIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBlJSAARDvLAALuB0CCH8CfiMAQYADayIGJAAgBiAEOgAvAkACQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAAkACQAJAAkAgBEH/AXFBEk0EQCABIAIoAhwRBAAiBC0AAEEYaw4DAgIDAQsgBkEBNgKUAiAGQfiegAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBkG+n4ABNgLgASAGIAZB4AFqNgKYAiAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMEgsgBiAENgKwASAGQQI2ApQCIAZBrJ6AATYCkAIgBkIBNwKcAiAGQa8DNgLkASAGIAZB4AFqNgKYAiAGIAZBsAFqNgLgASAAQQRqIAZBkAJqEJkOIABBhoCAgHg2AgAMEQsgBkEYaiABIAIoAhARAAAgBkGQAmoiAiAGKAIYIgEgBigCHCgCDBEAACABRQ0FIAYpA5ACQsfZ9OfexLacd4UgBikDmAJCjbLOlIzKkuanf4WEUEUNBSAGIAYtAC86AHsgBiADOgB6AkACQCAFLQA0RQRAIAEQ0zohAyAGQZQCaiABEPk0IAYgAzYCsAIgBkEANgKsAiAGIAE2ApACIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqIQUjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohCCMAQdAAayICJAAgAkEQaiIHIAEQsiQCQAJAAkAgAikDECIOQgJSBEAgAikDGCEPIAJBxABqIgQgARDCKSAEQQQgAigCREEBaiIEQX8gBBsiBCAEQQRNG0EAQQhBEBCgGCACKAJIIQQgAigCREEBRg0CIAIoAkwiCSAPNwMIIAkgDjcDACACQQxqIgtBATYCACACIAk2AgggAiAENgIEIAcgAUEw/AoAACMAQSBrIgEkACABIAcQsiQgASkDACIOQgJSBEAgAkEEaiEEA0AgASkDCCEPAkAgBCgCCCIJIAQoAgBHDQAgAUEUaiAHEMIpIAEoAhRBAWoiCkF/IAobIgogBCgCACAEKAIIIgxrTQ0AIAQgDCAKQQhBEBDeKAsgBCgCBCAJQQR0aiIKIA83AwggCiAONwMAIAQgCUEBajYCCCABIAcQsiQgASkDACIOQgJSDQALCwJAIAcoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgB0EEahD7HgsgAUEgaiQAIAhBCGogCygCADYCACAIIAIpAgQ3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHQAGokAAwBCyAEIAIoAkxBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAFIAMpAgA3AgAgBUEQaiADQRBqKAIANgIAIAVBCGogA0EIaikCADcCACAIEO07DAELIAUgAykCFDcCBCAFQZOAgIB4NgIAIAVBDGogA0EcaigCADYCAAsgA0HQAGokACAGQbgBaiIBIAZB7AFqKAIANgIAIAYgBikC5AE3A7ABIAYoAuABIgRBk4CAgHhGDQEgBkHwAGogASgCADYCACAGIAYpA7ABNwNoIAYoAvABIQIMEgsgARDTOiEFIAZBgAFqIgQgARD5NCAGIAU2ApwBIAZBADYCmAEgBiABNgJ8IAEQ0zoaIAEQ0zohCyABENM6GiAGIAEQ0zoiAjYC5AIgBkHoAmpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIIIQcgCEE4cSICBEAgCCACa0FAayIHIAhJDQkLQcAAIQkgB0HAABDRNEUNCSAHBEAgB0HAABCtNiIJRQ0LCyAGKALwAiEKIAZBnAJqIARBCGopAgA3AgAgBkGkAmogBEEQaikCADcCACAGIAE2ApACQQAhAiAGQQA2ArwCIAYgBTYCsAIgBkEANgKsAiAGIAQpAgA3ApQCIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqQQRyIQwgBkGUAmohDUEAIQQDQCAGQdgCaiEBQgIhDiAEIAVHBH8gBgJ+AkACQAJAIAYoApQCRQ0AIAQgBigCpAJPDREgBigCmAIgBigCoAIgBGoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAYgBEEBajYCrAIMAQsgBiAEQQFqNgKsAiAGQRBqIAYoApACIAQQjywgBkHgAWogBigCECAGKAIUIAYoArQCLAAAEMIBIAYoAuABIgFBAUcNASABRQ0AIAwQiBELQgAMAQsgBikD6AEiDiAGKAK4Ai0AABDFKa0LNwPYAiAGIAYoArwCIgNBAWo2ArwCIAZB+AJqBSABCyAONwMAAkACQAJAIAYpA9gCIg5CAlIEQCACIAlqIQEgDqdBAXFFDQEgASAGKQP4AjcDACAKIANBA3ZqIgEgAS0AAEEBIANBB3F0cjoAAAwCCwJAIAYoApQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIA0Q+x4LIAYgAkEDdSIBNgLgASABIAYoAuQCRw0QIAYoAvACIQEgBigC9AIhAyAGIAYpAugCNwKcAiAGQQA2ApgCIAYgAzYClAIgBiABNgKQAiAGQQhqIAZBkAJqIgIQ1zsgBigCCCEEQRxBBBCtNiIBRQ0RIAFCgYCAgBA3AgAgASAGKQKQAjcCCCABQRBqIAZBmAJqIgUpAgA3AgAgAUEYaiAGQaACaiIKKAIANgIAIAYgBzYCoAIgBkKAgICAgAg3ApgCIAYgCDYClAIgBiAJNgKQAiAGIAIQ1zsgBigCACEHQRxBBBCtNiICDQJBBEEcEKM9AAsgAUIANwMACyACQQhqIQIgBigCsAIhBSAGKAKsAiEEDAELCyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAFKQIANwIAIAJBGGogCigCADYCACAGIAM2AuACIAYgBDYC3AIgBiABNgLYAkEMQQQQrTYiAUUNDiABIAg2AgggASAHNgIEIAEgAjYCACAGQQE2AvACIAYgATYC7AIgBkEBNgLoAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQdyRgAEgCyAGIAZB2AJqIAZB6AJqIAZB4AFqIgEQjBMgASACELcTIAZBsAFqIAEgBi0AeiAGLQB7EKITIAYtALABIgJBKUcNASAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg43A6ABIAYgDjcDaCAGKAK0ASEEIAYoAsQBIQIMEQsgBkHwAmogASgCACIBNgIAIAYgBikDsAE3A+gCIAZBkAJqIgIgBigC7AIiAyADIAFBBHRqEIMJIAZB4AFqIAIgBi0AeiAGLQB7EKITIAYtAOABIgJBKUcNAiAGQbgBaiAGQfABaigCACIBNgIAIAZB8ABqIAE2AgAgBiAGKQLoASIONwOwASAGIA43A2ggBigC5AEhBCAGKAL0ASECIAZB6AJqEO07DBALIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQwCCyAGQSBqIAEgAigCEBEAACAGQeABaiAGKAIgIgEgBigCJCgCDBEAACABRQ0MIAYpA+ABQquYkfGV+tX8gH+FIAYpA+gBQpaU+Kvwsemz4QCFhFBFDQwgBkGQAmogASADIAYtAC8gBRC3AiAGLQCQAiICQSlHDQIgBkG4AWogBkGgAmooAgAiATYCACAGIAYpApgCIg43A7ABIAYoApQCIQIgBigCpAIhAyAAQQxqIAE2AAAgACAONwAEIAAgAzYCECAAIAI2AgAMDwsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASIONwOwASAGIAYpAvgBNwNQIAYgDjcDaCAGKALkASEBIAYoAvQBIQUgBkHoAmoQ7TsLIAZBOGogBkHwAGooAgA2AgAgBiAGKQNoNwMwDAsLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAoLIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAsLQfSdgAEQsjsAC0GUk4ABQSNBuJOAARDLJAALQeSUgAFBKSAGQZACakHIl4ABQZCVgAEQ1R4AC0HAACAHEKM9AAtBtJSAAUEgQdSUgAEQnykACyAGQgA3ApwCIAZCgYCAgMAANwKUAiAGQcSRgAE2ApACQQAgBkHgAWogBkHkAmogBkGQAmpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQYSegAEQsjsAC0E4QQQQrTYiAwRAIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBvJqAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwCC0EEQTgQoz0ACyAGQcgAaiAGQfAAaigCACIBNgIAIAYgBikDaCIONwNAIABBDGogATYAACAAIA43AAQgACACNgIQIAAgBDYCAAsgBkGAA2okAAu4HQIIfwJ+IwBBgANrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkACQAJAAkACQCAEQf8BcUESTQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgMBCyAGQQE2ApQCIAZB+J6AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGQb6fgAE2AuABIAYgBkHgAWo2ApgCIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwSCyAGIAQ2ArABIAZBAjYClAIgBkGsnoABNgKQAiAGQgE3ApwCIAZBrwM2AuQBIAYgBkHgAWo2ApgCIAYgBkGwAWo2AuABIABBBGogBkGQAmoQmQ4gAEGGgICAeDYCAAwRCyAGQRhqIAEgAigCEBEAACAGQZACaiICIAYoAhgiASAGKAIcKAIMEQAAIAFFDQUgBikDkAJC09jT+P3m9pJIhSAGKQOYAkKi2J6I4aDq6cwAhYRQRQ0FIAYgBi0ALzoAeyAGIAM6AHoCQAJAIAUtADRFBEAgARDUOiEDIAZBlAJqIAEQ+TQgBiADNgKwAiAGQQA2AqwCIAYgATYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohBSMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQRBqIgcgARC2JAJAAkACQCACKQMQIg5CAlIEQCACKQMYIQ8gAkHEAGoiBCABEMApIARBBCACKAJEQQFqIgRBfyAEGyIEIARBBE0bQQBBCEEQEKAYIAIoAkghBCACKAJEQQFGDQIgAigCTCIJIA83AwggCSAONwMAIAJBDGoiC0EBNgIAIAIgCTYCCCACIAQ2AgQgByABQTD8CgAAIwBBIGsiASQAIAEgBxC2JCABKQMAIg5CAlIEQCACQQRqIQQDQCABKQMIIQ8CQCAEKAIIIgkgBCgCAEcNACABQRRqIAcQwCkgASgCFEEBaiIKQX8gChsiCiAEKAIAIAQoAggiDGtNDQAgBCAMIApBCEEQEN4oCyAEKAIEIAlBBHRqIgogDzcDCCAKIA43AwAgBCAJQQFqNgIIIAEgBxC2JCABKQMAIg5CAlINAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQSBqJAAgCEEIaiALKAIANgIAIAggAikCBDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAQgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAUgAykCADcCACAFQRBqIANBEGooAgA2AgAgBUEIaiADQQhqKQIANwIAIAgQ7TsMAQsgBSADKQIUNwIEIAVBk4CAgHg2AgAgBUEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHsAWooAgA2AgAgBiAGKQLkATcDsAEgBigC4AEiBEGTgICAeEYNASAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC8AEhAgwSCyABENQ6IQUgBkGAAWoiBCABEPk0IAYgBTYCnAEgBkEANgKYASAGIAE2AnwgARDUOhogARDUOiELIAEQ1DoaIAYgARDUOiICNgLkAiAGQegCakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgghByAIQThxIgIEQCAIIAJrQUBrIgcgCEkNCQtBwAAhCSAHQcAAENE0RQ0JIAcEQCAHQcAAEK02IglFDQsLIAYoAvACIQogBkGcAmogBEEIaikCADcCACAGQaQCaiAEQRBqKQIANwIAIAYgATYCkAJBACECIAZBADYCvAIgBiAFNgKwAiAGQQA2AqwCIAYgBCkCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWpBBHIhDCAGQZQCaiENQQAhBANAIAZB2AJqIQFCAiEOIAQgBUcEfyAGAn4CQAJAAkAgBigClAJFDQAgBCAGKAKkAk8NESAGKAKYAiAGKAKgAiAEaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXFFDQAgBiAEQQFqNgKsAgwBCyAGIARBAWo2AqwCIAZBEGogBigCkAIgBBDaKyAGQeABaiAGKAIQIAYoAhQgBigCtAIsAAAQwgEgBigC4AEiAUEBRw0BIAFFDQAgDBCIEQtCAAwBCyAGKQPoASIOIAYoArgCLQAAEMUprQs3A9gCIAYgBigCvAIiA0EBajYCvAIgBkH4AmoFIAELIA43AwACQAJAAkAgBikD2AIiDkICUgRAIAIgCWohASAOp0EBcUUNASABIAYpA/gCNwMAIAogA0EDdmoiASABLQAAQQEgA0EHcXRyOgAADAILAkAgBigClAIiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgDRD7HgsgBiACQQN1IgE2AuABIAEgBigC5AJHDRAgBigC8AIhASAGKAL0AiEDIAYgBikC6AI3ApwCIAZBADYCmAIgBiADNgKUAiAGIAE2ApACIAZBCGogBkGQAmoiAhDXOyAGKAIIIQRBHEEEEK02IgFFDREgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogBkGYAmoiBSkCADcCACABQRhqIAZBoAJqIgooAgA2AgAgBiAHNgKgAiAGQoCAgICACDcCmAIgBiAINgKUAiAGIAk2ApACIAYgAhDXOyAGKAIAIQdBHEEEEK02IgINAkEEQRwQoz0ACyABQgA3AwALIAJBCGohAiAGKAKwAiEFIAYoAqwCIQQMAQsLIAJCgYCAgBA3AgAgAiAGKQKQAjcCCCACQRBqIAUpAgA3AgAgAkEYaiAKKAIANgIAIAYgAzYC4AIgBiAENgLcAiAGIAE2AtgCQQxBBBCtNiIBRQ0OIAEgCDYCCCABIAc2AgQgASACNgIAIAZBATYC8AIgBiABNgLsAiAGQQE2AugCIAZBADYC6AEgBkKAgICAwAA3AuABIAZBkAJqIgJB3JGAASALIAYgBkHYAmogBkHoAmogBkHgAWoiARCMEyABIAIQtxMgBkGwAWogASAGLQB6IAYtAHsQohMgBi0AsAEiAkEpRw0BIAZB8ABqIAZBwAFqKAIANgIAIAYgBikCuAEiDjcDoAEgBiAONwNoIAYoArQBIQQgBigCxAEhAgwRCyAGQfACaiABKAIAIgE2AgAgBiAGKQOwATcD6AIgBkGQAmoiAiAGKALsAiIDIAMgAUEEdGoQgwkgBkHgAWogAiAGLQB6IAYtAHsQohMgBi0A4AEiAkEpRw0CIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg43A7ABIAYgDjcDaCAGKALkASEEIAYoAvQBIQIgBkHoAmoQ7TsMEAsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFDAILIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAIAFFDQwgBikD4AFCq5iR8ZX61fyAf4UgBikD6AFClpT4q/Cx6bPhAIWEUEUNDCAGQZACaiABIAMgBi0ALyAFELcCIAYtAJACIgJBKUcNAiAGQbgBaiAGQaACaigCACIBNgIAIAYgBikCmAIiDjcDsAEgBigClAIhAiAGKAKkAiEDIABBDGogATYAACAAIA43AAQgACADNgIQIAAgAjYCAAwPCyAGQfgAaiAGLQDjAToAACAGQbgBaiAGQfABaigCACIBNgIAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDhATsBdiAGIAYpAugBIg43A7ABIAYgBikC+AE3A1AgBiAONwNoIAYoAuQBIQEgBigC9AEhBSAGQegCahDtOwsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzAMCwsgBkH4AGogBi0AkwI6AAAgBkHYAGogBkGwAmopAgA3AwAgBkHgAGogBkG4AmopAgA3AwAgBkE4aiAGQaACaigCADYCACAGIAYvAJECOwF2IAYgBikCqAI3A1AgBiAGKQKYAjcDMCAGKAKUAiEBIAYoAqQCIQUMCgsgBkEBNgKUAiAGQbSfgAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBiAGQeABajYCmAIgBiAGQS9qNgLgASAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMCwtB9J2AARCyOwALQZSTgAFBI0G4k4ABEMskAAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQcAAIAcQoz0AC0G0lIABQSBB1JSAARCfKQALIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQeQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBhJ6AARCyOwALQThBBBCtNiIDBEAgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEG8moABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAILQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg43A0AgAEEMaiABNgAAIAAgDjcABCAAIAI2AhAgACAENgIACyAGQYADaiQAC+8VAg1/A34jAEHwBGsiAiQAIAJB6AJqIAEQ2wsgAkH4A2oiByACQfgCaikDADcDACACQYAEaiIDIAJBgANqKQMANwMAIAIgAikD8AI3A/ADAkAgAikD6AIiD0ICUQRAIAAgAikD8AM3AwAgAEEQaiADKQMANwMAIABBCGogBykDADcDAAwBCyACQShqIAJBiANqQTD8CgAAIAJBGGogAkH4A2oiBykDADcDACACQSBqIAJBgARqIgUpAwA3AwAgAiAPNwMIIAIgAikD8AM3AxAgASgCgAUiAy4BGiEEIAMuARghBiABIAEpA5gCIAEpA8gDfDcDmAIgBSACQThqKAIANgIAIAcgAkEwaikDADcDACACIAIpAygiDzcD8AMgAkGMBGogAkHEAGopAgA3AgAgAkGUBGogAkHMAGooAgA2AgAgAiACKQI8NwKEBCABQbABaiEHIAFByANqIQwCQAJAAkAgD6dBAXEEQCACKAKEBEEBRw0BIAJBiAJqIgUgAkE0aikCADcDACACIAIpAiw3A4ACIAJBsAFqIgggAkHIAGopAwA3AwAgAiACKQNANwOoASADQQhqIgMgAkGAAmoiCSABQaACaiADIAkQphEgASgCgAVBCGoiAyACQagBaiIJIAFBtAJqIAMgCRCnESABLQCWBSACQZQDaiAFKQMANwIAIAJBqANqIAgpAwA3AwAgAiACKQOAAjcCjAMgAiACKQOoATcDoAMgAkEBNgKcAyACQQE2AogDIAJBgQI2ArADIAJCATcD+AIgAkIANwPoAiACIAEpA8gDNwOAA0ECRwRAIAJCAjcDWCACQegCahCnJQwECyACQdgAaiACQegCakHQAPwKAAAMAwsgAkICNwNYDAELIAJCAjcDWCACKAL0AyIDRQ0AIAJBgARqIAIoAvgDIAIoAvwDIAMoAhARAQALIAIoAoQERQ0AIAIoAogEIgNFDQAgAkGUBGogAigCjAQgAigCkAQgAygCEBEBAAsgASACQdgAakEAIAIpA1hCAlIbIAIpAwggAikDEBCRByAHIAwQ8yYgAigCCEEBRgRAIAIpAxAhDyABAn4gASgC4AFBAUYEQCABKQPoAQwBCyABQgE3A+ABQgALIA98NwPoAQsgAikDWCEPIAJBgAJqIAJB4ABqIgNByAD8CgAAAkACQCAPQgJSBEAgAiAPNwPwAyACQfgDaiADQcgA/AoAACABKAKEBUEIaiABKAKABUEIahCrEg0BIAJB8ANqEKclCyACQgg3A6gBDAELIAJB+AJqIAJBgAJqQcgA/AoAACACIA83A/ACIAJCBzcD6AIgAkGoAWogASACQegCahDjBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgChAUtAJ0BBEBBACEDIAJBADYC2AIgAkKAgICAEDcC0AJBACEHIARBAEoNAQwDCyACQoCAgIAQNwLQAiACQQA2AtgCIARBAEwNASABKAL4BCEFIAJB8ANqIgMgBCABKAL8BCIHEKsNIAMgBSAHEK4JIAJB6AJqIgQgA0GAAfwKAAAgAkHcAmoiAyAEENAQIAJB0AJqIAIoAuACIAIoAuQCEKE2IAMQ3jsMAQsgASgC+AQhBSACQfADaiIHIAQgASgC/AQiBBDtFiAHIAUgBBCuCSACQegCaiIEIAdBgAH8CgAAIAJB3AJqIgUgBBDQECACQdACaiACKALgAiACKALkAiIHEKE2IAUQ3jsMAQsgBkEASgRAIAEoAuwEIQQgAkHwA2oiAyAGIAEoAvAEIgUQqw0gAyAEIAUQrgkgAkHoAmoiBCADQYAB/AoAACACQdwCaiIDIAQQ0BAgAkHQAmogAigC4AIgAigC5AIQoTYgAxDeOwsgAkHQAmoiBSACKAIcIAIoAiAQoTYgAigC2AIhBAJAIAEoArAERQ0AIAJB6AJqIgggBEEAQQFBARCgGCACKALsAiEDIAIoAugCQQFHBEAgAkEANgL4AyACIAIoAvACNgL0AyACIAM2AvADIAggASgCsAQgAigC1AIgAigC2AIgAkHwA2oiAyABKAK0BCgCDBEHACACKALoAiIIQQhHBEAgACACKQLsAjcCBCAAQRRqIAJB/AJqKAIANgIAIABBDGogAkH0AmopAgA3AgAgACAINgIAIAMQ3jsgBRDeOwwECyACQfACaiIDIAJB+ANqKAIANgIAIAIgAikC8AM3A+gCIAJB0AJqEN47IAJB2AJqIAMoAgA2AgAgAiACKQPoAjcD0AIMAQsgAyACKALwAkHYgs8AEP0vAAsgAkH4A2ogAkHYAmooAgA2AgAgAiACKQPQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC6AMhBSACLQBUIQMgAkGAAmogAkGoAWpB0AD8CgAAIAIoAvQCIQggAigC8AIhCSACKQPoAiEPQgkhEEECIQpBAiELIAIpA/gBDAYLIAZBAEoEQCABKALsBCEEIAJB8ANqIgMgBiABKALwBCIGEO0WIAMgBCAGEK4JIAJB6AJqIgYgA0GAAfwKAAAgAkHcAmoiBCAGENAQIAJB0AJqIAIoAuACIAIoAuQCIgMQoTYgBBDeOwsgAigCICIGIAMgB2pqIQQgASgCsAQiCEUNASACKALYAiEFIAJB6AJqIAggAigCHCAGIAJB0AJqIgYgASgCtAQoAgwRBwAgAigC6AIiCEEIRg0CIAAgAikC7AI3AgQgAEEUaiACQfwCaigCADYCACAAQQxqIAJB9AJqKQIANwIAIAAgCDYCACAGEN47CyACQagBahCsKQwFCyACQdACaiACKAIcIAYQoTYMAQtBASAEIAIoAtgCIAVrSw0BGiACQdACaiIGIAUQ9DQgBiACKAIcIAIoAiAQoTYLQQALIQYgAkH4A2ogAkHYAmooAgA2AgAgAiACKQLQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC7AMhBSABKALIAyEIIAEoAugDIQkgAi0AVCENIAIpA6gBIRAgAkGAAmogAkGwAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiELIAIpA/ACIQ8gAikD6AILIREgASgCWEGAgICAeEcNASACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAJB8ANqIAEgAkHoAmoQpgogAigC8AMiB0EIRg0CIAAgAikC9AM3AgQgAEEUaiACQYQEaigCADYCACAAQQxqIAJB/ANqKQIANwIAIAAgBzYCAAsgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAFB6AJqIAJB6AJqEOogCyABQQA2AvwEIAFBADYC8AQgASABKQP4ASABNQLsA3w3A/gBIAwQ6SAgAEEINgIAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQALIAJB8ARqJAAL5xUCDX8DfiMAQfAEayICJAAgAkHoAmogARDbCyACQfgDaiIHIAJB+AJqKQMANwMAIAJBgARqIgMgAkGAA2opAwA3AwAgAiACKQPwAjcD8AMCQCACKQPoAiIPQgJRBEAgACACKQPwAzcDACAAQRBqIAMpAwA3AwAgAEEIaiAHKQMANwMADAELIAJBKGogAkGIA2pBMPwKAAAgAkEYaiACQfgDaiIHKQMANwMAIAJBIGogAkGABGoiBSkDADcDACACIA83AwggAiACKQPwAzcDECABKAKABSIDLgEaIQQgAy4BGCEGIAEgASkDmAIgASkDyAN8NwOYAiAFIAJBOGooAgA2AgAgByACQTBqKQMANwMAIAIgAikDKCIPNwPwAyACQYwEaiACQcQAaikCADcCACACQZQEaiACQcwAaigCADYCACACIAIpAjw3AoQEIAFBsAFqIQcgAUHIA2ohDAJAAkACQCAPp0EBcQRAIAIoAoQEQQFHDQEgAkGIAmoiBSACQTRqKQIANwMAIAIgAikCLDcDgAIgAkGwAWoiCCACQcgAaikDADcDACACIAIpA0A3A6gBIAJBgAJqIgkgAUGgAmogA0EIaiAJENkYIAJBqAFqIgMgAUG0AmogASgCgAVBCGogAxDaGCABLQCWBSACQZQDaiAFKQMANwIAIAJBqANqIAgpAwA3AwAgAiACKQOAAjcCjAMgAiACKQOoATcDoAMgAkEBNgKcAyACQQE2AogDIAJBgQI2ArADIAJCATcD+AIgAkIANwPoAiACIAEpA8gDNwOAA0ECRwRAIAJCAjcDWCACQegCahCnJQwECyACQdgAaiACQegCakHQAPwKAAAMAwsgAkICNwNYDAELIAJCAjcDWCACKAL0AyIDRQ0AIAJBgARqIAIoAvgDIAIoAvwDIAMoAhARAQALIAIoAoQERQ0AIAIoAogEIgNFDQAgAkGUBGogAigCjAQgAigCkAQgAygCEBEBAAsgASACQdgAakEAIAIpA1hCAlIbIAIpAwggAikDEBCRByAHIAwQ8yYgAigCCEEBRgRAIAIpAxAhDyABAn4gASgC4AFBAUYEQCABKQPoAQwBCyABQgE3A+ABQgALIA98NwPoAQsgAikDWCEPIAJBgAJqIAJB4ABqIgNByAD8CgAAAkACQCAPQgJSBEAgAiAPNwPwAyACQfgDaiADQcgA/AoAACABKAKEBUEIaiABKAKABUEIahCrEg0BIAJB8ANqEKclCyACQgg3A6gBDAELIAJB+AJqIAJBgAJqQcgA/AoAACACIA83A/ACIAJCBjcD6AIgAkGoAWogASACQegCahDjBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgChAUtAJ0BBEBBACEDIAJBADYC2AIgAkKAgICAEDcC0AJBACEHIARBAEoNAQwDCyACQoCAgIAQNwLQAiACQQA2AtgCIARBAEwNASABKAL4BCEFIAJB8ANqIgMgBCABKAL8BCIHEKsNIAMgBSAHEK4JIAJB6AJqIgQgA0GAAfwKAAAgAkHcAmoiAyAEENAQIAJB0AJqIAIoAuACIAIoAuQCEKE2IAMQ3jsMAQsgASgC+AQhBSACQfADaiIHIAQgASgC/AQiBBDtFiAHIAUgBBCuCSACQegCaiIEIAdBgAH8CgAAIAJB3AJqIgUgBBDQECACQdACaiACKALgAiACKALkAiIHEKE2IAUQ3jsMAQsgBkEASgRAIAEoAuwEIQQgAkHwA2oiAyAGIAEoAvAEIgUQqw0gAyAEIAUQrgkgAkHoAmoiBCADQYAB/AoAACACQdwCaiIDIAQQ0BAgAkHQAmogAigC4AIgAigC5AIQoTYgAxDeOwsgAkHQAmoiBSACKAIcIAIoAiAQoTYgAigC2AIhBAJAIAEoArAERQ0AIAJB6AJqIgggBEEAQQFBARCgGCACKALsAiEDIAIoAugCQQFHBEAgAkEANgL4AyACIAIoAvACNgL0AyACIAM2AvADIAggASgCsAQgAigC1AIgAigC2AIgAkHwA2oiAyABKAK0BCgCDBEHACACKALoAiIIQQhHBEAgACACKQLsAjcCBCAAQRRqIAJB/AJqKAIANgIAIABBDGogAkH0AmopAgA3AgAgACAINgIAIAMQ3jsgBRDeOwwECyACQfACaiIDIAJB+ANqKAIANgIAIAIgAikC8AM3A+gCIAJB0AJqEN47IAJB2AJqIAMoAgA2AgAgAiACKQPoAjcD0AIMAQsgAyACKALwAkHYgs8AEP0vAAsgAkH4A2ogAkHYAmooAgA2AgAgAiACKQPQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC6AMhBSACLQBUIQMgAkGAAmogAkGoAWpB0AD8CgAAIAIoAvQCIQggAigC8AIhCSACKQPoAiEPQgkhEEECIQpBAiELIAIpA/gBDAYLIAZBAEoEQCABKALsBCEEIAJB8ANqIgMgBiABKALwBCIGEO0WIAMgBCAGEK4JIAJB6AJqIgYgA0GAAfwKAAAgAkHcAmoiBCAGENAQIAJB0AJqIAIoAuACIAIoAuQCIgMQoTYgBBDeOwsgAigCICIGIAMgB2pqIQQgASgCsAQiCEUNASACKALYAiEFIAJB6AJqIAggAigCHCAGIAJB0AJqIgYgASgCtAQoAgwRBwAgAigC6AIiCEEIRg0CIAAgAikC7AI3AgQgAEEUaiACQfwCaigCADYCACAAQQxqIAJB9AJqKQIANwIAIAAgCDYCACAGEN47CyACQagBahCsKQwFCyACQdACaiACKAIcIAYQoTYMAQtBASAEIAIoAtgCIAVrSw0BGiACQdACaiIGIAUQ9DQgBiACKAIcIAIoAiAQoTYLQQALIQYgAkH4A2ogAkHYAmooAgA2AgAgAiACKQLQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC7AMhBSABKALIAyEIIAEoAugDIQkgAi0AVCENIAIpA6gBIRAgAkGAAmogAkGwAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiELIAIpA/ACIQ8gAikD6AILIREgASgCWEGAgICAeEcNASACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAJB8ANqIAEgAkHoAmoQpgogAigC8AMiB0EIRg0CIAAgAikC9AM3AgQgAEEUaiACQYQEaigCADYCACAAQQxqIAJB/ANqKQIANwIAIAAgBzYCAAsgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAFB6AJqIAJB6AJqEOogCyABQQA2AvwEIAFBADYC8AQgASABKQP4ASABNQLsA3w3A/gBIAwQ6SAgAEEINgIAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQALIAJB8ARqJAAL5TACD38DfiMAQfAEayIDJAAgA0HoAmohByMAQdACayICJAAgAUGwAWoiECIEKQKcASERIARBADYCnAEgBCkCsAEhEiAEQQA2ArABIAJBEGogBEGsAWooAgA2AgAgAkEIaiAEQaQBaikCADcDACACQSBqIARBuAFqKQIANwMAIAJBKGogBEHAAWooAgA2AgAgAiARNwMAIAIgEjcDGAJAAkACQAJAAkAgBCgCAEGAgICAeEcEQCACQagBaiAEKAJYIghBA3YgCEEHcUEAR2oiBUHAACAEKAIUIgZBAWsiCUEAIAYgCU8brXmnayIGQf8BcSIJQQN2IAZBB3FBAEdqQQFqbCIKIAlBAWogBWwiBSAFIApJG0EBakEAQQFBARCgGCACKAKsASEFIAIoAqgBQQFHBEAgAigCsAEiCSAGOgAAIAJBATYCQCACIAk2AjwgAiAFNgI4IAJByABqIgpBAEHAAPwLACACQQA2ApgBIAJBADoARCACQgA3AzAgAiAGOgCkASACQgA3ApwBIAJCADcDiAEgAkJ/NwOQAQJAIAgEQCAEKAJUIQYgCEEDdCEFA0AgAigCnAEhCQJAAkAgBikDACIRIAIpA4gBUgRAIAlBB0sEQCACQTBqEL0NCyACIBE3A4gBIAJBATYCnAEMAQsgAiAJQQFqIgk2ApwBIAlBCEsNAQsgAigCmAEiCUEHSw0DIAogCUEDdGogETcDACACIAIoApgBQQFqIgk2ApgBIAlBCEcNACACQTBqEMonCyAGQQhqIQYgBUEIayIFDQALCyAEQQA2AlggBCkDSCERIARCADcDSCACQagBaiACQTBqQfgA/AoAACACKAKQAiIGIAIoApQCIgQgAigCmAIiBXJyRQ0EAkAgBQ0AIAQgBkcEQCAERSAGcg0BDAULIAQNBAsgBkEBa0EHSQRAIAJBwAFqIQQDQCAEIAZBA3RqQgA3AwAgAiACKAKQAkEBaiIGNgKQAiAGQQhJDQALIAIoApgCIQULIAIgBSAGajYCmAIgAkGoAWpBARD6CyACQQA2ApQCDAQLIAlBCEG8gs4AEMMhAAsgBSACKAKwAUGA+c0AEP0vAAsCQAJAAkACQAJAAkACQEECIAQoAmAiBkGAgICAeHMgBkEAThtBAWsOAgECAAsgBCkCZCERIARCgICAgBA3AmQgAkGwAWogBEHsAGoiCCgCADYCAEEAIQYgCEEANgIAIAIgETcDqAEMBQsgAkGoAWogBCgCcBCNDSACQThqIgYgAkG0AWopAgA3AwAgAiACKQKsATcDMCACKAKoASIIQQhHBEAgAigCvAEhBCAHIAIpAzA3AgwgByAENgIcIAcgCDYCCCAHQgI3AwAgB0EUaiAGKQMANwIADAQLIAJBqAJqIAYpAwAiETcDACACIAIpAzA3A6ACIAJBqAFqIAQoAmwiBSARpyIGakEAQQFBARCgGCACKAKsASEIIAIoAqgBQQFGDQEgAkE4aiIJQQA2AgAgAiACKAKwATYCNCACIAg2AjAgAkEwaiIIIAIoAqQCIgogBhChNiAIIAQoAmggBRChNiAEQQA2AmwgAkGwAWogCSgCADYCACACIAIpAjA3A6gBIAJBrAJqIAogBiACKAKgAigCEBEBAEEFIQYMBAsgAkGoAWogBCgCeBCNDSACQThqIgYgAkG0AWoiCCkCADcDACACIAIpAqwBNwMwIAIoAqgBIgVBCEcEQCACKAK8ASEEIAcgAikDMDcCDCAHIAQ2AhwgByAFNgIIIAdCAjcDACAHQRRqIAYpAwA3AgAMAwsgAkHIAmogBikDADcDACACIAIpAzA3A8ACIAJBqAFqIAQoAnwQjQ0gBiAIKQIANwMAIAIgAikCrAE3AzAgAigCqAEiBkEIRwRAIAIoArwBIQQgByACKQMwNwIMIAcgBDYCHCAHIAY2AgggB0ICNwMAIAdBFGogAkE4aikDADcCACACQcwCaiACKALEAiACKALIAiACKALAAigCEBEBAAwDCyACQagCaiACQThqIgYpAwAiETcDACACIAIpAzA3A6ACIAJBqAFqIAQoAmgiCSARpyIIIAIoAsgCampBAEEBQQEQoBggAigCrAEhBSACKAKoAUEBRg0BIAZBADYCACACIAIoArABNgI0IAIgBTYCMCACQTBqIgUgAigCxAIgAigCyAIQoTYgBSACKAKkAiIKIAgQoTYgBSAEKAJkIAkQoTYgBEEANgJ0IARBADYCaCACQbABaiAGKAIANgIAIAIgAikCMDcDqAEgAkGsAmogCiAIIAIoAqACKAIQEQEAIAJBzAJqIAIoAsQCIAIoAsgCIAIoAsACKAIQEQEAQQYhBgwDCyAIIAIoArABQZD3zQAQ/S8ACyAFIAIoArABQcD3zQAQ/S8ACwJAIAIoAhhFDQAgAigCHCIERQ0AIAJBKGogAigCICACKAIkIAQoAhARAQALIAIoAgBFDQMgAigCBCIERQ0DIAJBEGogAigCCCACKAIMIAQoAhARAQAMAwsgBCkDgAEhESAEQgA3A4ABIAdBEGogAkGoAWoQ5xUgByAGOgBMIAcgETcDCCAHQgE3AwAgBCgCiAEhBiAEQQA2AogBIAcgAikDADcCICAHQShqIAJBCGopAwA3AgAgB0EwaiACQRBqKAIANgIAIAcgAikDGDcCNCAHQTxqIAJBIGopAwA3AgAgB0HEAGogAkEoaigCADYCACAHIAY2AkgMAgsgAkGoAWoQvQ0LIAJBsAJqIgYgAkG4AWoiBSkDADcDACACQagCaiIJIAJBsAFqKQMANwMAIAIgAikDqAEiEjcDoAIgAi0AtAIhBCACIBI3A7gCIARBA3YgBEEHcUEAR2oiBEEJTw0BIAkgAkG4AmogBBChNiACQcgCaiAGKAIANgIAIAIgAikDqAI3A8ACIAUgAkHAAmoQ5xUgAkHQAWogAkEIaikDADcDACACQdgBaiACQRBqKAIANgIAIAJB5AFqIAJBIGopAwA3AgAgAkHsAWogAkEoaigCADYCACACQQc6APQBIAIgCDYC8AEgAiARNwOwASACQgE3A6gBIAIgAikDADcDyAEgAiACKQMYNwLcASAHIAJBqAFqQdAA/AoAAAsgAkHQAmokAAwBCyAEQQhBjILOABCwOwALIANB+ANqIgIgA0H4AmopAwA3AwAgA0GABGoiBCADQYADaikDADcDACADIAMpA/ACNwPwAwJAIAMpA+gCIhFCAlEEQCAAIAMpA/ADNwMAIABBEGogBCkDADcDACAAQQhqIAIpAwA3AwAMAQsgA0EoaiADQYgDakEw/AoAACADQRhqIANB+ANqIgQpAwA3AwAgA0EgaiADQYAEaiIHKQMANwMAIAMgETcDCCADIAMpA/ADNwMQIAEoApgFIgIuARohCCACLgEYIQYgASABKQNoIAEpA+ADfDcDaCAHIANBOGooAgA2AgAgBCADQTBqKQMANwMAIAMgAykDKCIRNwPwAyADQYwEaiADQcQAaikCADcCACADQZQEaiADQcwAaigCADYCACADIAMpAjw3AoQEIAFB4ANqIQ0CQAJAAkAgEadBAXEEQCADKAKEBEEBRw0BIANBiAJqIgcgA0E0aikCADcDACADIAMpAiw3A4ACIANBsAFqIgQgA0HIAGopAwA3AwAgAyADKQNANwOoASADQYACaiIFIAFB8ABqIAJBCGogBRDZGCADQagBaiICIAFBhAFqIAEoApgFQQhqIAIQ2hggAS0ArgUgA0GUA2ogBykDADcCACADQagDaiAEKQMANwMAIAMgAykDgAI3AowDIAMgAykDqAE3A6ADIANBATYCnAMgA0EBNgKIAyADQYECNgKwAyADQgE3A/gCIANCADcD6AIgAyABKQPgAzcDgANBAkcEQCADQgI3A1ggA0HoAmoQpyUMBAsgA0HYAGogA0HoAmpB0AD8CgAADAMLIANCAjcDWAwBCyADQgI3A1ggAygC9AMiAkUNACADQYAEaiADKAL4AyADKAL8AyACKAIQEQEACyADKAKEBEUNACADKAKIBCICRQ0AIANBlARqIAMoAowEIAMoApAEIAIoAhARAQALIANB2ABqQQAgAykDWEICUhshBCADKQMIIREgAykDECESIwBBgAFrIgIkACABLQDcAyEFAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABNQKEBCITIAEpA+ADUgRAIAVBAXFFDQcgBEUNBCAEKAIgRQ0CIAQoAjRFDQMgBEEkaiEFIARBOGohCSABKALQBEUNBiABQeQEaiEKIAFB1ARqIQsgAS0ArAUNAQwFCyAFQQFxRQ0GIAJBADYCSCACQoCAgIAQNwJAIAJBADYCWCACQoCAgIAQNwJQIAFBkANqQQEgAkFAayACQdAAaiATEJUUDAYLIAEoApgFQQhqIAsgBRCJDUUEQCABKAKYBUEIaiAKIAkQiQ1FDQQLIAFBADoArAUMAwtByIDPABCyOwALQdiAzwAQsjsACyABQQA6ANwDDAILIAEtAK0FRQ0AIAEoApgFQQhqIAUgCxCJDUUEQCABKAKYBUEIaiAJIAoQiQ1FDQELIAFBADoArQULAkAgBSgCACIFBEAgAkHgAGogBEEwaiAEKAIoIAQoAiwgBSgCABEFAAwBCyACQQA2AmALIAFB0ARqAkAgCSgCACIJBEAgAkHwAGogBEHEAGogBCgCPCAEKAJAIAkoAgARBQAMAQsgAkEANgJwCyABQZADaiEJIAJBMGoiCiACKQJwNwMAIAJBKGoiCyACQegAaikCADcDACACQThqIgwgAkH4AGopAgA3AwAgAiACKQJgNwMgEPEmIAFBATYC0AQgASACKQMgNwLUBCABQdwEaiALKQMANwIAIAFB5ARqIAopAwA3AgAgAUHsBGogDCkDADcCACABEOkfRQRAIAJBGGogBBDuJyACKAIYIgxFDQIgAkHQAGogAigCHCIFQQBBAUEBEKAYIAIoAlQhCiACKAJQQQFGDQMgAigCWCELIAUEQCALIAwgBfwKAAALIAIgBTYCSCACIAs2AkQgAiAKNgJAIAJBEGogBBDvJyACKAIQIgtFDQQgAkHQAGogAigCFCIEQQBBAUEBEKAYIAIoAlQhBSACKAJQQQFGDQUgAigCWCEKIAQEQCAKIAsgBPwKAAALIAIgBDYCWCACIAo2AlQgAiAFNgJQIAlBACACQUBrIAJB0ABqIAEpA+ADEJUUDAELIAEoApwFIgUoAjwhCiAFKAI4IQUgAkEIaiAEEO4nIAIoAggiC0UNBSACQUBrIgwgASAFIAogCyACKAIMEJ4NIAEoApwFIgUoAjwhCiAFKAI4IQUgAiAEEO8nIAIoAgAiBEUNBiACQdAAaiILIAEgBSAKIAQgAigCBBCaDCAJQQAgDCALIAEpA+ADEJUUCyABQZADaiABQegDaiABQfQDahCWEyABKAKQBEGAgICAeEcEQCABQYgEaiIEIAE1AoQEEKYnIAQgESASENcZCyACQYABaiQADAYLQeiAzwAQsjsACyAKIAIoAlhBwPXOABD9LwALQfiAzwAQsjsACyAFIAIoAlhBwPXOABD9LwALQYiBzwAQsjsAC0GYgc8AELI7AAsgASANEPMmIAMoAghBAUYEQCADKQMQIREgAQJ+IAEoAjBBAUYEQCABKQM4DAELIAFCATcDMEIACyARfDcDOAsgAykDWCERIANBgAJqIANB4ABqIgJByAD8CgAAAkACQCARQgJSBEAgAyARNwPwAyADQfgDaiACQcgA/AoAACABKAKcBUEIaiABKAKYBUEIahCrEg0BIANB8ANqEKclCyADQgg3A6gBDAELIANB+AJqIANBgAJqQcgA/AoAACADIBE3A/ACIANCBjcD6AIgA0GoAWogASADQegCahDkBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCnAUtAJ0BBEBBACECIANBADYC2AIgA0KAgICAEDcC0AJBACEHIAhBAEoNAQwDCyADQoCAgIAQNwLQAiADQQA2AtgCIAhBAEwNASABKAKQBSEEIANB8ANqIgIgCCABKAKUBSIHEKsNIAIgBCAHEK4JIANB6AJqIgQgAkGAAfwKAAAgA0HcAmoiAiAEENAQIANB0AJqIAMoAuACIAMoAuQCEKE2IAIQ3jsMAQsgASgCkAUhByADQfADaiIEIAggASgClAUiCBDtFiAEIAcgCBCuCSADQegCaiIHIARBgAH8CgAAIANB3AJqIgQgBxDQECADQdACaiADKALgAiADKALkAiIHEKE2IAQQ3jsMAQsgBkEASgRAIAEoAoQFIQQgA0HwA2oiAiAGIAEoAogFIggQqw0gAiAEIAgQrgkgA0HoAmoiBCACQYAB/AoAACADQdwCaiICIAQQ0BAgA0HQAmogAygC4AIgAygC5AIQoTYgAhDeOwsgA0HQAmoiCCADKAIcIAMoAiAQoTYgAygC2AIhBAJAIAEoAsgERQ0AIANB6AJqIgUgBEEAQQFBARCgGCADKALsAiECIAMoAugCQQFHBEAgA0EANgL4AyADIAMoAvACNgL0AyADIAI2AvADIAUgASgCyAQgAygC1AIgAygC2AIgA0HwA2oiAiABKALMBCgCDBEHACADKALoAiIFQQhHBEAgACADKQLsAjcCBCAAQRRqIANB/AJqKAIANgIAIABBDGogA0H0AmopAgA3AgAgACAFNgIAIAIQ3jsgCBDeOwwECyADQfACaiICIANB+ANqKAIANgIAIAMgAykC8AM3A+gCIANB0AJqEN47IANB2AJqIAIoAgA2AgAgAyADKQPoAjcD0AIMAQsgAiADKALwAkHYgs8AEP0vAAsgA0H4A2ogA0HYAmooAgA2AgAgAyADKQPQAjcD8AMgA0HoAmogA0HwA2oQ5xUgASgCgAQhCCADLQBUIQIgA0GAAmogA0GoAWpB0AD8CgAAIAMoAvQCIQUgAygC8AIhCSADKQPoAiERQgkhEkECIQpBAiELIAMpA/gBDAYLIAZBAEoEQCABKAKEBSEEIANB8ANqIgIgBiABKAKIBSIGEO0WIAIgBCAGEK4JIANB6AJqIgQgAkGAAfwKAAAgA0HcAmoiBiAEENAQIANB0AJqIAMoAuACIAMoAuQCIgIQoTYgBhDeOwsgAygCICIGIAIgB2pqIQQgASgCyAQiBUUNASADKALYAiEIIANB6AJqIAUgAygCHCAGIANB0AJqIgYgASgCzAQoAgwRBwAgAygC6AIiBUEIRg0CIAAgAykC7AI3AgQgAEEUaiADQfwCaigCADYCACAAQQxqIANB9AJqKQIANwIAIAAgBTYCACAGEN47CyADQagBahCsKQwFCyADQdACaiADKAIcIAYQoTYMAQtBASAEIAMoAtgCIAhrSw0BGiADQdACaiIGIAgQ9DQgBiADKAIcIAMoAiAQoTYLQQALIQYgA0H4A2ogA0HYAmooAgA2AgAgAyADKQLQAjcD8AMgA0HoAmogA0HwA2oQ5xUgASgChAQhCCABKALgAyEFIAEoAoAEIQkgAy0AVCEOIAMpA6gBIRIgA0GAAmogA0GwAWpB0AD8CgAAIAJBGHYhDyACQRB2IQogAkEIdiELIAMpA/ACIREgAykD6AILIRMgECgCAEGAgICAeEcNASADIBI3A+gCIANB8AJqIANBgAJqQdAA/AoAACADIAQ2AugDIAMgDjoA5QMgAyAGOgDkAyADIAc2AuADIAMgDzoA3wMgAyAKOgDeAyADIAs6AN0DIAMgAjoA3AMgAyAINgLYAyADIAU2AtQDIAMgCTYC0AMgAyARNwPIAyADIBM3A8ADIANB8ANqIAEgA0HoAmoQpQogAygC8AMiAkEIRg0CIAAgAykC9AM3AgQgAEEUaiADQYQEaigCADYCACAAQQxqIANB/ANqKQIANwIAIAAgAjYCAAsgA0EkaiADKAIcIAMoAiAgAygCGCgCEBEBAAwCCyADIBI3A+gCIANB8AJqIANBgAJqQdAA/AoAACADIAQ2AugDIAMgDjoA5QMgAyAGOgDkAyADIAc2AuADIAMgDzoA3wMgAyAKOgDeAyADIAs6AN0DIAMgAjoA3AMgAyAINgLYAyADIAU2AtQDIAMgCTYC0AMgAyARNwPIAyADIBM3A8ADIAFBgANqIANB6AJqEOogCyABQQA2ApQFIAFBADYCiAUgASABKQNIIAE1AoQEfDcDSCANEOkgIABBCDYCACADQSRqIAMoAhwgAygCICADKAIYKAIQEQEACyADQfAEaiQAC8odAgl/AX4jAEGAA2siBiQAIAYgBDoALwJAAkACQAJAAkACQCAEwEEATgRAAkACQCAEQf8BcUEJTQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgQBCyAGQQE2ApQCIAZB+J6AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGQbyfgAE2AuABIAYgBkHgAWo2ApgCIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwICyAGIAQ2ArABIAZBAjYClAIgBkGsnoABNgKQAiAGQgE3ApwCIAZBrwM2AuQBIAYgBkHgAWo2ApgCIAYgBkGwAWo2AuABIABBBGogBkGQAmoQmQ4gAEGGgICAeDYCAAwHCyAGQRhqIAEgAigCEBEAACAGQZACaiICIAYoAhgiASAGKAIcKAIMEQAAAkAgAUUNACAGKQOQAkLH2fTn3sS2nHeFIAYpA5gCQo2yzpSMypLmp3+FhFBFDQAgBiAGLQAvOgB7IAYgAzoAeiAFLQA0RQRAIAEQ0zohAyAGQZQCaiABEPk0IAYgAzYCsAIgBkEANgKsAiAGIAE2ApACIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqIQcjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohCCMAQdAAayICJAAgAkEIaiABIAJBIGoiBCABKAIsEP8KAkACQAJAIAIoAggiCUF+cUECRwRAIAIoAgwhDCAEIAEQwikgBEEEIAIoAiBBAWoiBUF/IAUbIgUgBUEETRtBAEEEQQgQoBggAigCJCEFIAIoAiBBAUYNAiACKAIoIgogDDYCBCAKIAk2AgAgAkEcaiINQQE2AgAgAiAKNgIYIAIgBTYCFCAEIAFBMPwKAAAjAEEgayIBJAAgAUEIaiAEIAFBFGogBCgCLBD/CiABKAIIIgpBfnFBAkcEQCACQRRqIQUgASgCDCEJA0ACQCAFKAIIIgwgBSgCAEcNACABQRRqIAQQwikgASgCFEEBaiILQX8gCxsiCyAFKAIAIAUoAggiDmtNDQAgBSAOIAtBBEEIEN4oCyAFKAIEIAxBA3RqIgsgCTYCBCALIAo2AgAgBSAMQQFqNgIIIAEgBCABQRRqIAQoAiwQ/wogASgCBCEJIAEoAgAiCkF+cUECRw0ACwsCQCAEKAIEIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIARBBGoQ+x4LIAFBIGokACAIQQhqIA0oAgA2AgAgCCACKQIUNwIADAELIAhBADYCCCAIQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgBSACKAIoQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgByADKQIANwIAIAdBEGogA0EQaigCADYCACAHQQhqIANBCGopAgA3AgAgCBDqOwwBCyAHIAMpAhQ3AgQgB0GTgICAeDYCACAHQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQewBaigCADYCACAGIAYpAuQBNwOwASAGKALgASIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALwASECDAcLIAEQ0zohAyAGQYABaiICIAEQ+TQgBiADNgKcASAGQQA2ApgBIAYgATYCfCABENM6GiABENM6IQwgARDTOhogBiABENM6IgQ2AuQCIAZB6AJqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBAnQiCCEHAkAgCEE8cSIEBEAgCCAEa0FAayIHIAhJDQELQcAAIQogB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiCkUNAQsgBigC8AIhDSAGQZwCaiACQQhqKQIANwIAIAZBpAJqIAJBEGopAgA3AgAgBiABNgKQAiAGQQA2ArwCIAYgAzYCsAIgBkEANgKsAiAGIAIpAgA3ApQCIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZBlAJqIQtBACECQQAhBAJAAkACQANAIAZB2AJqIQFBAiEFIAMgBEcEfyAGAn8CQAJAAkAgBigClAJFDQAgBCAGKAKkAk8NASAGKAKYAiAGKAKgAiAEaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXFFDQAgBiAEQQFqNgKsAgwCCyAGIARBAWo2AqwCIAZBEGogBigCkAIgBBCPLCAGQeABaiIBIAYoAhAgBigCFCAGKAK0AiwAABDHASAGKALgAUGTgICAeEcEQCABEIgRDAILIAYoAuQBIgUgBigCuAItAAAQxCkMAgtBtJSAAUEgQdSUgAEQnykAC0EACzYC2AIgBiAGKAK8AiIJQQFqNgK8AiAGQfwCagUgAQsgBTYCAAJAAkACQCAGKALYAiIDQQJHBEAgAiAKaiEBIANBAXFFDQEgASAGKAL8AjYCACANIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwCCwJAIAYoApQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAsQ+x4LIAYgAkECdSIBNgLgASABIAYoAuQCRw0EIAYoAvACIQEgBigC9AIhAyAGIAYpAugCNwKcAiAGQQA2ApgCIAYgAzYClAIgBiABNgKQAiAGQQhqIAZBkAJqIgIQ1zsgBigCCCEEQRxBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgASAGKQKQAjcCCCABQRBqIAZBmAJqIgUpAgA3AgAgAUEYaiAGQaACaiIJKAIANgIAIAYgBzYCoAIgBkKAgICAgAg3ApgCIAYgCDYClAIgBiAKNgKQAiAGIAIQ1zsgBigCACEHQRxBBBCtNiICDQJBBEEcEKM9AAsgAUEANgIACyACQQRqIQIgBigCsAIhAyAGKAKsAiEEDAELCyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAFKQIANwIAIAJBGGogCSgCADYCACAGIAM2AuACIAYgBDYC3AIgBiABNgLYAkEMQQQQrTYiAUUNAiABIAg2AgggASAHNgIEIAEgAjYCACAGQQE2AvACIAYgATYC7AIgBkEBNgLoAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQYCSgAEgDCAGIAZB2AJqIAZB6AJqIAZB4AFqIgEQjBMgASACEMMTIAZBsAFqIAEgBi0AeiAGLQB7EKATIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg83A6ABIAYgDzcDaCAGKAK0ASEEIAYoAsQBIQIMDQsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFDAoLIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQeQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBwAAgBxCjPQALQeSUgAFBKSAGQZACakHIl4ABQZCVgAEQ1R4AC0GUk4ABQSNBuJOAARDLJAALQfSdgAEQsjsACyAGQQE2ApQCIAZBtJ+AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGIAZB4AFqNgKYAiAGIAZBL2o2AuABIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwFCyAGQSBqIAEgAigCEBEAACAGQeABaiAGKAIgIgEgBigCJCgCDBEAAAJAIAFFDQAgBikD4AFCq5iR8ZX61fyAf4UgBikD6AFClpT4q/Cx6bPhAIWEUEUNACAGQZACaiABIAMgBi0ALyAFEL0CIAYtAJACIgJBKUYEQCAGQbgBaiAGQaACaigCACIBNgIAIAYgBikCmAIiDzcDsAEgBigClAIhAiAGKAKkAiEDIABBDGogATYAACAAIA83AAQgACADNgIQIAAgAjYCAAwGCyAGQfgAaiAGLQCTAjoAACAGQdgAaiAGQbACaikCADcDACAGQeAAaiAGQbgCaikCADcDACAGQThqIAZBoAJqKAIANgIAIAYgBi8AkQI7AXYgBiAGKQKoAjcDUCAGIAYpApgCNwMwIAYoApQCIQEgBigCpAIhBQwDC0GEnoABELI7AAsgBkHwAmogASgCACIBNgIAIAYgBikDsAE3A+gCIAZBkAJqIgIgBigC7AIiAyADIAFBA3RqEPkIIAZB4AFqIAIgBi0AeiAGLQB7EKATIAYtAOABIgJBKUYEQCAGQbgBaiAGQfABaigCACIBNgIAIAZB8ABqIAE2AgAgBiAGKQLoASIPNwOwASAGIA83A2ggBigC5AEhBCAGKAL0ASECIAZB6AJqEOo7DAMLIAZB+ABqIAYtAOMBOgAAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHYAGogBkGAAmopAgA3AwAgBkHgAGogBkGIAmopAgA3AwAgBkHwAGogATYCACAGIAYvAOEBOwF2IAYgBikC6AEiDzcDsAEgBiAGKQL4ATcDUCAGIA83A2ggBigC5AEhASAGKAL0ASEFIAZB6AJqEOo7CyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgMEQCADIAI6AAggA0KBgICAEDcCACADIAYvAXY7AAkgAyABNgIMIAMgBikDMDcCECADIAU2AhwgAyAGKQNQNwIgIANBC2ogBkH4AGotAAA6AAAgA0EYaiAGQThqKAIANgIAIANBKGogBkHYAGopAwA3AgAgA0EwaiAGQeAAaikDADcCACAAQeSZgAE2AgggACADNgIEIABBk4CAgHg2AgAMAgtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDzcDQCAAQQxqIAE2AAAgACAPNwAEIAAgAjYCECAAIAQ2AgALIAZBgANqJAALyh0CCX8BfiMAQYADayIGJAAgBiAEOgAvAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQQlNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYClAIgBkH4noABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAZBvJ+AATYC4AEgBiAGQeABajYCmAIgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAgLIAYgBDYCsAEgBkECNgKUAiAGQayegAE2ApACIAZCATcCnAIgBkGvAzYC5AEgBiAGQeABajYCmAIgBiAGQbABajYC4AEgAEEEaiAGQZACahCZDiAAQYaAgIB4NgIADAcLIAZBGGogASACKAIQEQAAIAZBkAJqIgIgBigCGCIBIAYoAhwoAgwRAAACQCABRQ0AIAYpA5ACQtPY0/j95vaSSIUgBikDmAJCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgARDUOiEDIAZBlAJqIAEQ+TQgBiADNgKwAiAGQQA2AqwCIAYgATYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohByMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQQhqIAEgAkEgaiIEIAEoAiwQ/goCQAJAAkAgAigCCCIJQX5xQQJHBEAgAigCDCEMIAQgARDAKSAEQQQgAigCIEEBaiIFQX8gBRsiBSAFQQRNG0EAQQRBCBCgGCACKAIkIQUgAigCIEEBRg0CIAIoAigiCiAMNgIEIAogCTYCACACQRxqIg1BATYCACACIAo2AhggAiAFNgIUIAQgAUEw/AoAACMAQSBrIgEkACABQQhqIAQgAUEUaiAEKAIsEP4KIAEoAggiCkF+cUECRwRAIAJBFGohBSABKAIMIQkDQAJAIAUoAggiDCAFKAIARw0AIAFBFGogBBDAKSABKAIUQQFqIgtBfyALGyILIAUoAgAgBSgCCCIOa00NACAFIA4gC0EEQQgQ3igLIAUoAgQgDEEDdGoiCyAJNgIEIAsgCjYCACAFIAxBAWo2AgggASAEIAFBFGogBCgCLBD+CiABKAIEIQkgASgCACIKQX5xQQJHDQALCwJAIAQoAgQiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgBEEEahD7HgsgAUEgaiQAIAhBCGogDSgCADYCACAIIAIpAhQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHQAGokAAwBCyAFIAIoAihBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAHIAMpAgA3AgAgB0EQaiADQRBqKAIANgIAIAdBCGogA0EIaikCADcCACAIEOo7DAELIAcgAykCFDcCBCAHQZOAgIB4NgIAIAdBDGogA0EcaigCADYCAAsgA0HQAGokACAGQbgBaiIBIAZB7AFqKAIANgIAIAYgBikC5AE3A7ABIAYoAuABIgRBk4CAgHhGDQQgBkHwAGogASgCADYCACAGIAYpA7ABNwNoIAYoAvABIQIMBwsgARDUOiEDIAZBgAFqIgIgARD5NCAGIAM2ApwBIAZBADYCmAEgBiABNgJ8IAEQ1DoaIAEQ1DohDCABENQ6GiAGIAEQ1DoiBDYC5AIgBkHoAmpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEECdCIIIQcCQCAIQTxxIgQEQCAIIARrQUBrIgcgCEkNAQtBwAAhCiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIKRQ0BCyAGKALwAiENIAZBnAJqIAJBCGopAgA3AgAgBkGkAmogAkEQaikCADcCACAGIAE2ApACIAZBADYCvAIgBiADNgKwAiAGQQA2AqwCIAYgAikCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkGUAmohC0EAIQJBACEEAkACQAJAA0AgBkHYAmohAUECIQUgAyAERwR/IAYCfwJAAkACQCAGKAKUAkUNACAEIAYoAqQCTw0BIAYoApgCIAYoAqACIARqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAGIARBAWo2AqwCDAILIAYgBEEBajYCrAIgBkEQaiAGKAKQAiAEENorIAZB4AFqIgEgBigCECAGKAIUIAYoArQCLAAAEMcBIAYoAuABQZOAgIB4RwRAIAEQiBEMAgsgBigC5AEiBSAGKAK4Ai0AABDEKQwCC0G0lIABQSBB1JSAARCfKQALQQALNgLYAiAGIAYoArwCIglBAWo2ArwCIAZB/AJqBSABCyAFNgIAAkACQAJAIAYoAtgCIgNBAkcEQCACIApqIQEgA0EBcUUNASABIAYoAvwCNgIAIA0gCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAILAkAgBigClAIiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgCxD7HgsgBiACQQJ1IgE2AuABIAEgBigC5AJHDQQgBigC8AIhASAGKAL0AiEDIAYgBikC6AI3ApwCIAZBADYCmAIgBiADNgKUAiAGIAE2ApACIAZBCGogBkGQAmoiAhDXOyAGKAIIIQRBHEEEEK02IgFFDQUgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogBkGYAmoiBSkCADcCACABQRhqIAZBoAJqIgkoAgA2AgAgBiAHNgKgAiAGQoCAgICACDcCmAIgBiAINgKUAiAGIAo2ApACIAYgAhDXOyAGKAIAIQdBHEEEEK02IgINAkEEQRwQoz0ACyABQQA2AgALIAJBBGohAiAGKAKwAiEDIAYoAqwCIQQMAQsLIAJCgYCAgBA3AgAgAiAGKQKQAjcCCCACQRBqIAUpAgA3AgAgAkEYaiAJKAIANgIAIAYgAzYC4AIgBiAENgLcAiAGIAE2AtgCQQxBBBCtNiIBRQ0CIAEgCDYCCCABIAc2AgQgASACNgIAIAZBATYC8AIgBiABNgLsAiAGQQE2AugCIAZBADYC6AEgBkKAgICAwAA3AuABIAZBkAJqIgJBgJKAASAMIAYgBkHYAmogBkHoAmogBkHgAWoiARCMEyABIAIQwxMgBkGwAWogASAGLQB6IAYtAHsQoBMgBi0AsAEiAkEpRgRAIAZB8ABqIAZBwAFqKAIANgIAIAYgBikCuAEiDzcDoAEgBiAPNwNoIAYoArQBIQQgBigCxAEhAgwNCyAGQfgAaiAGLQCzAToAACAGQdgAaiAGQdABaikCADcDACAGQeAAaiAGQdgBaikCADcDACAGQfAAaiAGQcABaigCADYCACAGIAYvALEBOwF2IAYgBikCyAE3A1AgBiAGKQK4ATcDaCAGKAK0ASEBIAYoAsQBIQUMCgsgBkIANwKcAiAGQoGAgIDAADcClAIgBkHEkYABNgKQAkEAIAZB4AFqIAZB5AJqIAZBkAJqQcyRgAEQrysAC0EEQRwQoz0AC0EEQQwQoz0AC0HAACAHEKM9AAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAULIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPgAUKrmJHxlfrV/IB/hSAGKQPoAUKWlPir8LHps+EAhYRQRQ0AIAZBkAJqIAEgAyAGLQAvIAUQvQIgBi0AkAIiAkEpRgRAIAZBuAFqIAZBoAJqKAIAIgE2AgAgBiAGKQKYAiIPNwOwASAGKAKUAiECIAYoAqQCIQMgAEEMaiABNgAAIAAgDzcABCAAIAM2AhAgACACNgIADAYLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAMLQYSegAEQsjsACyAGQfACaiABKAIAIgE2AgAgBiAGKQOwATcD6AIgBkGQAmoiAiAGKALsAiIDIAMgAUEDdGoQ+QggBkHgAWogAiAGLQB6IAYtAHsQoBMgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg83A7ABIAYgDzcDaCAGKALkASEEIAYoAvQBIQIgBkHoAmoQ6jsMAwsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASIPNwOwASAGIAYpAvgBNwNQIAYgDzcDaCAGKALkASEBIAYoAvQBIQUgBkHoAmoQ6jsLIAZBOGogBkHwAGooAgA2AgAgBiAGKQNoNwMwC0E4QQQQrTYiAwRAIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABB5JmAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwCC0EEQTgQoz0ACyAGQcgAaiAGQfAAaigCACIBNgIAIAYgBikDaCIPNwNAIABBDGogATYAACAAIA83AAQgACACNgIQIAAgBDYCAAsgBkGAA2okAAvZHQIHfwR+IwBB8AJrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQSZNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYClAIgBkH4noABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAZBvZ+AATYC4AEgBiAGQeABajYCmAIgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADA0LIAYgBDYCsAEgBkECNgKUAiAGQayegAE2ApACIAZCATcCnAIgBkGvAzYC5AEgBiAGQeABajYCmAIgBiAGQbABajYC4AEgAEEEaiAGQZACahCZDiAAQYaAgIB4NgIADAwLIAZBGGogASACKAIQEQAAIAZBkAJqIgQgBigCGCICIAYoAhwoAgwRAAACQCACRQ0AIAYpA5ACQtPY0/j95vaSSIUgBikDmAJCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgAhDUOiEBIAZBlAJqIAIQ+TQgBiABNgKwAiAGQQA2AqwCIAYgAjYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohBSMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBEEs/AoAACADIAM2AkwgA0EUaiEKIwBB0ABrIgIkACACQRBqIgcgARC3HQJAAkACQCACKQMYIg0gAikDECIOQgKFhFBFBEAgAikDKCEPIAIpAyAhECACQcQAaiIEIAEQwCkgBEEEIAIoAkRBAWoiBEF/IAQbIgQgBEEETRtBAEEQQSAQoBggAigCSCEIIAIoAkRBAUYNAiACKAJMIgQgDzcDGCAEIBA3AxAgBCANNwMIIAQgDjcDACACQQxqIgtBATYCACACIAQ2AgggAiAINgIEIAcgAUEw/AoAACMAQTBrIgEkACABIAcQtx0gASkDCCINIAEpAwAiDkIChYRQRQRAIAJBBGohBANAIAEpAxghDyABKQMQIRACQCAEKAIIIgkgBCgCAEcNACABQSRqIAcQwCkgASgCJEEBaiIIQX8gCBsiCCAEKAIAIAQoAggiDGtNDQAgBCAMIAhBEEEgEN4oCyAEKAIEIAlBBXRqIgggDzcDGCAIIBA3AxAgCCANNwMIIAggDjcDACAEIAlBAWo2AgggASAHELcdIAEpAwgiDSABKQMAIg5CAoWEUEUNAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQTBqJAAgCkEIaiALKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAggAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAUgAykCADcCACAFQRBqIANBEGooAgA2AgAgBUEIaiADQQhqKQIANwIAIAoQ5TwMAQsgBSADKQIUNwIEIAVBk4CAgHg2AgAgBUEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHsAWooAgA2AgAgBiAGKQLkATcDsAEgBigC4AEiBEGTgICAeEYNBCAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC8AEhAgwMCyACENQ6IQcgBkGAAWoiBCACEPk0IAYgBzYCnAEgBkEANgKYASAGIAI2AnwgAhDUOhogAhDUOiEKIAIQ1DoaIAYgAhDUOiIBNgLUAiAGQeACakF/IAFBB2oiAyABIANLG0EDdhDSHyABQQR0IgMhBQJAIANBMHEiAQRAIAMgAWtBQGsiBSADSQ0BC0HAACEBIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgFFDQELIAYoAugCIQggBkGcAmogBEEIaikCADcCACAGQaQCaiAEQRBqKQIANwIAIAYgAjYCkAJBACECIAZBADYCvAIgBiAHNgKwAiAGQQA2AqwCIAYgBCkCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgASEEIAdFDQcgBkHgAWpBBHIhBwNAAkACQAJAAkACQAJAAkAgBigClAJFDQAgAiAGKAKkAk8NBCAGKAKYAiAGKAKgAiACaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQAgBiACQQFqNgKsAgwBCyAGIAJBAWo2AqwCIAZBEGogBigCkAIgAhDaKyAGQeABaiAGKAIQIAYoAhQgBigCtAIsAAAQxgEgBigC4AEiAkEBRw0BIAJFDQAgBxCIEQsgBiAGKAK8AkEBajYCvAIMAQsgBikD8AEiDSAGKQP4ASIOIAYoArgCLQAAEP8gIAYgBigCvAIiAkEBajYCvAINAgsgBEIANwMIIARCADcDAAwCC0G0lIABQSBB1JSAARCfKQALIAQgDTcDACAEIA43AwggCCACQQN2aiIJIAktAABBASACQQdxdHI6AAALIARBEGohBCAGKAKsAiICIAYoArACRw0ACwwHC0HAACAFEKM9AAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAoLIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPgAUKrmJHxlfrV/IB/hSAGKQPoAUKWlPir8LHps+EAhYRQRQ0AIAZBkAJqIAEgAyAGLQAvIAUQvgIgBi0AkAIiAkEpRgRAIAZBuAFqIAZBoAJqKAIAIgE2AgAgBiAGKQKYAiINNwOwASAGKAKUAiECIAYoAqQCIQMgAEEMaiABNgAAIAAgDTcABCAAIAM2AhAgACACNgIADAsLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAQLQYSegAEQsjsACyAGQegCaiABKAIAIgE2AgAgBiAGKQOwATcD4AIgBkGQAmoiAiAGKALkAiIDIAMgAUEFdGoQ9gggBkHgAWogAiAGLQB6IAYtAHsQoRMgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg03A7ABIAYgDTcDaCAGKALkASEEIAYoAvQBIQIgBkHgAmoQ5TwMCAsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASINNwOwASAGIAYpAvgBNwNQIAYgDTcDaCAGKALkASEBIAYoAvQBIQUgBkHgAmoQ5TwMAQsCQCAGKAKUAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAGQZQCahD7HgsgBiAEIAFrQQR1IgI2AuABIAIgBigC1AJHDQIgBigC6AIhAiAGKALsAiEEIAYgBikC4AI3ApwCIAZBADYCmAIgBiAENgKUAiAGIAI2ApACIAZBCGogBkGQAmoiBxDXOyAGKAIIIQhBHEEEEK02IgJFDQMgAkKBgICAEDcCACACIAYpApACNwIIIAJBEGogBkGYAmoiCSkCADcCACACQRhqIAZBoAJqIgsoAgA2AgAgBiAFNgKgAiAGQoCAgICACDcCmAIgBiADNgKUAiAGIAE2ApACIAYgBxDXOyAGKAIAIQVBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogCSkCADcCACABQRhqIAsoAgA2AgAgBiAENgLcAiAGIAg2AtgCIAYgAjYC1AJBDEEEEK02IgJFDQQgAiADNgIIIAIgBTYCBCACIAE2AgAgBkEBNgLoAiAGIAI2AuQCIAZBATYC4AIgBkEANgLoASAGQoCAgIDAADcC4AEgBkGQAmoiAkH0kYABIAogBiAGQdQCaiAGQeACaiAGQeABaiIBEIwTIAEgAhCwEyAGQbABaiABIAYtAHogBi0AexChEyAGLQCwASICQSlGBEAgBkHwAGogBkHAAWooAgA2AgAgBiAGKQK4ASINNwOgASAGIA03A2ggBigCtAEhBCAGKALEASECDAcLIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzALQThBBBCtNiIDRQ0DIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBtJiAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwFCyAGQgA3ApwCIAZCgYCAgMAANwKUAiAGQcSRgAE2ApACQQAgBkHgAWogBkHUAmogBkGQAmpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg03A0AgAEEMaiABNgAAIAAgDTcABCAAIAI2AhAgACAENgIACyAGQfACaiQAC9kdAgd/BH4jAEHwAmsiBiQAIAYgBDoALwJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkAgBEH/AXFBJk0EQCABIAIoAhwRBAAiBC0AAEEYaw4DAgIEAQsgBkEBNgKUAiAGQfiegAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBkG9n4ABNgLgASAGIAZB4AFqNgKYAiAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMDQsgBiAENgKwASAGQQI2ApQCIAZBrJ6AATYCkAIgBkIBNwKcAiAGQa8DNgLkASAGIAZB4AFqNgKYAiAGIAZBsAFqNgLgASAAQQRqIAZBkAJqEJkOIABBhoCAgHg2AgAMDAsgBkEYaiABIAIoAhARAAAgBkGQAmoiBCAGKAIYIgIgBigCHCgCDBEAAAJAIAJFDQAgBikDkAJCx9n0597Etpx3hSAGKQOYAkKNss6UjMqS5qd/hYRQRQ0AIAYgBi0ALzoAeyAGIAM6AHogBS0ANEUEQCACENM6IQEgBkGUAmogAhD5NCAGIAE2ArACIAZBADYCrAIgBiACNgKQAiAGIAZB+gBqNgK4AiAGIAZB+wBqNgK0AiAGQeABaiEFIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAEQSz8CgAAIAMgAzYCTCADQRRqIQojAEHQAGsiAiQAIAJBEGoiByABELkdAkACQAJAIAIpAxgiDSACKQMQIg5CAoWEUEUEQCACKQMoIQ8gAikDICEQIAJBxABqIgQgARDCKSAEQQQgAigCREEBaiIEQX8gBBsiBCAEQQRNG0EAQRBBIBCgGCACKAJIIQggAigCREEBRg0CIAIoAkwiBCAPNwMYIAQgEDcDECAEIA03AwggBCAONwMAIAJBDGoiC0EBNgIAIAIgBDYCCCACIAg2AgQgByABQTD8CgAAIwBBMGsiASQAIAEgBxC5HSABKQMIIg0gASkDACIOQgKFhFBFBEAgAkEEaiEEA0AgASkDGCEPIAEpAxAhEAJAIAQoAggiCSAEKAIARw0AIAFBJGogBxDCKSABKAIkQQFqIghBfyAIGyIIIAQoAgAgBCgCCCIMa00NACAEIAwgCEEQQSAQ3igLIAQoAgQgCUEFdGoiCCAPNwMYIAggEDcDECAIIA03AwggCCAONwMAIAQgCUEBajYCCCABIAcQuR0gASkDCCINIAEpAwAiDkIChYRQRQ0ACwsCQCAHKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAdBBGoQ+x4LIAFBMGokACAKQQhqIAsoAgA2AgAgCiACKQIENwIADAELIApBADYCCCAKQoCAgICAAjcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgCCACKAJMQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBSADKQIANwIAIAVBEGogA0EQaigCADYCACAFQQhqIANBCGopAgA3AgAgChDlPAwBCyAFIAMpAhQ3AgQgBUGTgICAeDYCACAFQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQewBaigCADYCACAGIAYpAuQBNwOwASAGKALgASIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALwASECDAwLIAIQ0zohByAGQYABaiIEIAIQ+TQgBiAHNgKcASAGQQA2ApgBIAYgAjYCfCACENM6GiACENM6IQogAhDTOhogBiACENM6IgE2AtQCIAZB4AJqQX8gAUEHaiIDIAEgA0sbQQN2ENIfIAFBBHQiAyEFAkAgA0EwcSIBBEAgAyABa0FAayIFIANJDQELQcAAIQEgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiAUUNAQsgBigC6AIhCCAGQZwCaiAEQQhqKQIANwIAIAZBpAJqIARBEGopAgA3AgAgBiACNgKQAkEAIQIgBkEANgK8AiAGIAc2ArACIAZBADYCrAIgBiAEKQIANwKUAiAGIAZB+gBqNgK4AiAGIAZB+wBqNgK0AiABIQQgB0UNByAGQeABakEEciEHA0ACQAJAAkACQAJAAkACQCAGKAKUAkUNACACIAYoAqQCTw0EIAYoApgCIAYoAqACIAJqIglBA3ZqLQAAQf8BcyAJQQdxdkEBcUUNACAGIAJBAWo2AqwCDAELIAYgAkEBajYCrAIgBkEQaiAGKAKQAiACEI8sIAZB4AFqIAYoAhAgBigCFCAGKAK0AiwAABDGASAGKALgASICQQFHDQEgAkUNACAHEIgRCyAGIAYoArwCQQFqNgK8AgwBCyAGKQPwASINIAYpA/gBIg4gBigCuAItAAAQ/yAgBiAGKAK8AiICQQFqNgK8Ag0CCyAEQgA3AwggBEIANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBCANNwMAIAQgDjcDCCAIIAJBA3ZqIgkgCS0AAEEBIAJBB3F0cjoAAAsgBEEQaiEEIAYoAqwCIgIgBigCsAJHDQALDAcLQcAAIAUQoz0AC0HklIABQSkgBkGQAmpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQAC0H0nYABELI7AAsgBkEBNgKUAiAGQbSfgAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBiAGQeABajYCmAIgBiAGQS9qNgLgASAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMCgsgBkEgaiABIAIoAhARAAAgBkHgAWogBigCICIBIAYoAiQoAgwRAAACQCABRQ0AIAYpA+ABQquYkfGV+tX8gH+FIAYpA+gBQpaU+Kvwsemz4QCFhFBFDQAgBkGQAmogASADIAYtAC8gBRC+AiAGLQCQAiICQSlGBEAgBkG4AWogBkGgAmooAgAiATYCACAGIAYpApgCIg03A7ABIAYoApQCIQIgBigCpAIhAyAAQQxqIAE2AAAgACANNwAEIAAgAzYCECAAIAI2AgAMCwsgBkH4AGogBi0AkwI6AAAgBkHYAGogBkGwAmopAgA3AwAgBkHgAGogBkG4AmopAgA3AwAgBkE4aiAGQaACaigCADYCACAGIAYvAJECOwF2IAYgBikCqAI3A1AgBiAGKQKYAjcDMCAGKAKUAiEBIAYoAqQCIQUMBAtBhJ6AARCyOwALIAZB6AJqIAEoAgAiATYCACAGIAYpA7ABNwPgAiAGQZACaiICIAYoAuQCIgMgAyABQQV0ahD2CCAGQeABaiACIAYtAHogBi0AexChEyAGLQDgASICQSlGBEAgBkG4AWogBkHwAWooAgAiATYCACAGQfAAaiABNgIAIAYgBikC6AEiDTcDsAEgBiANNwNoIAYoAuQBIQQgBigC9AEhAiAGQeACahDlPAwICyAGQfgAaiAGLQDjAToAACAGQbgBaiAGQfABaigCACIBNgIAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDhATsBdiAGIAYpAugBIg03A7ABIAYgBikC+AE3A1AgBiANNwNoIAYoAuQBIQEgBigC9AEhBSAGQeACahDlPAwBCwJAIAYoApQCIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAZBlAJqEPseCyAGIAQgAWtBBHUiAjYC4AEgAiAGKALUAkcNAiAGKALoAiECIAYoAuwCIQQgBiAGKQLgAjcCnAIgBkEANgKYAiAGIAQ2ApQCIAYgAjYCkAIgBkEIaiAGQZACaiIHENc7IAYoAgghCEEcQQQQrTYiAkUNAyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAGQZgCaiIJKQIANwIAIAJBGGogBkGgAmoiCygCADYCACAGIAU2AqACIAZCgICAgIAINwKYAiAGIAM2ApQCIAYgATYCkAIgBiAHENc7IAYoAgAhBUEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgBikCkAI3AgggAUEQaiAJKQIANwIAIAFBGGogCygCADYCACAGIAQ2AtwCIAYgCDYC2AIgBiACNgLUAkEMQQQQrTYiAkUNBCACIAM2AgggAiAFNgIEIAIgATYCACAGQQE2AugCIAYgAjYC5AIgBkEBNgLgAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQfSRgAEgCiAGIAZB1AJqIAZB4AJqIAZB4AFqIgEQjBMgASACELATIAZBsAFqIAEgBi0AeiAGLQB7EKETIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg03A6ABIAYgDTcDaCAGKAK0ASEEIAYoAsQBIQIMBwsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFCyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgNFDQMgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEG0mIABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAULIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQdQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDTcDQCAAQQxqIAE2AAAgACANNwAEIAAgAjYCECAAIAQ2AgALIAZB8AJqJAALoSYDEX8EfgF8IwBB8ABrIggkAAJAIAJFDQACQAJAIAEtAABBK2sOAwACAQILQQEhCgwBC0EBIQpBASETCwJAIAIgCk0NAAJAIAIgCiIEayILQQhJDQAgCyEDA0AgASAEaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBZCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgBEEIaiEEIANBCGsiA0EHSw0ACwsgAAJ8AkACQAJAAkACQAJAAkACfwJAIAIgBEsEQEEAIAJrIQUgBEEBaiEDIAEgBGohBAJAA0AgBC0AACIGQTBrIglB/wFxQQlLDQEgASADakEAIAIgA0sbIQQgFkIKfiAJrUL/AYN8IRYgBSADQQFqIgNqQQFHDQALIAEgCmohDyALrSEXIAshCSACIQUgAiEEDAQLIANBAWshBCAGQS5GDQELIAQhBUEADAELAkAgAiADa0EISQRAIAMhBQwBCyACIANrIQYgAyEFA0AgASAFaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBZCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgBUEIaiEFIAZBCGsiBkEHSw0ACwsCQCACIAVNDQADQCABIAVqLQAAQTBrIgZB/wFxQQlLDQEgFkIKfiAGrUL/AYN8IRYgAiAFQQFqIgVHDQALIAIhBQtCACAFIANrIg2tfSEVIAEgA2oLIRAgASAKaiEPIAQgCmsiCa0hFyACIAVNDQAgCSANaiIHRQ0DIAEgBWotAAAiA0HBAGtB/wFxQRpJQQV0IANyQeUARw0BAkAgBUEBaiIGIAJPDQACQAJAIAEgBmotAABBK2sOAwECAAILIAVBAmohBkEBIQwMAQsgBUECaiEGCyACIAZNDQNCACEUIAYhBQJAA0AgASAFai0AAEEwayIDQf8BcUEJSw0BIBRCCn4gA61C/wGDfCAUIBRCgICAgAFTGyEUIAIgBUEBaiIFRw0ACyACIQULIAUgBkYNA0IAIBR9IBQgDBsiFCAVfCEVDAILIAkgDWoiB0UNAgtCACEUC0EAIQNBEyIGIAdJBEAgASAKaiEMIAogAmshDiAHQRNrIQcCQAJAAkADQCADIAxqLQAAIhJBMEcNASAOIANBAWoiA2oNAAsgByALayIDQQAgAyAHTRshESACIQcMAQsgByADayIRQQAgByARTxshESACIAMgCmoiByASQS5GIAIgB0txIhJqIgdNBEAgByEDDAILIAwgEmogA2ohDCAOIBJqIANqIQ4gByEDA0AgDC0AAEEwRw0CIAxBAWohDCADQQFqIQMgDkEBaiIODQALCyACIQMLIAMgB2siByARSQRAQQAhAwJAIAQgCkYNAANAIAMgD2otAABBMEcNASAJIANBAWoiA0cNAAsgCSEDC0IAIRYCQCAJIANrIgRBCEkNACAEQQhrIQQDQCADIA9qKQAAIhVCxoyZsuTIkaPGAHwgFUKw4MCBg4aMmDB9IhWEQoCBgoSIkKDAgH+DQgBSDQEgFkKAwtcvfiAVQgp+IBVCCIh8IhZCEIhC/4GAgPAfg0KBgICAgOIJfiAWQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFiADQQhqIQMgBkEIayIGQQlJDQEgBEEHSyAEQQhrIQQNAAsLIAZFIQ4CQCAGRSADIAlPckUEQANAIBZCCn4gAyAPai0AAEEwa61C/wGDfCEWIAZBAUYhDiAGQQFrIQQgA0EBaiIDIAlPDQIgBkEBRyAEIQYNAAwCCwALIAYhBAsCQCAODQACQCAQBEBBACEDAkAgDUUgFkIAUnINAANAIAMgEGotAABBMEcNASANIANBAWoiA0cNAAsgDSEDCyAEQQlJDQEgDSADayIGQQhJDQEgBkEIayEGA0AgAyAQaikAACIVQsaMmbLkyJGjxgB8IBVCsODAgYOGjJgwfSIVhEKAgYKEiJCgwIB/g0IAUg0CIBZCgMLXL34gFUIKfiAVQgiIfCIWQhCIQv+BgIDwH4NCgYCAgIDiCX4gFkL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgA0EIaiEDIARBCGsiBEEJSQ0CIAZBB0sgBkEIayEGDQALDAELQcDWgAEQsjsAC0IAIRcgBEUgAyANT3INACAEQQFrIQYDQCAWQgp+IAMgEGotAABBMGutQv8Bg3whFiADQQFqIgMgDU8NASAGIgRBAWshBiAEDQALCyAUIAOtfSAXfCEVCyAHIBFJIQMLIAIgBUYNAQtCACEWIAtBA0kNBEEAIQMgAiAKayIFQQAgAiAFTxshBSABIApqIQQgCkEDaiEJA0AgA0EDRgRARAAAAAAAAPh/IRgMBAsgAyAFRg0CIANB4NaAAWohASADIARqIANBAWohAy0AACIGIAEtAAAiAUYgASAGc0EgRnINAAsMAQsgCCADOgBJIAggEzoASCAIIAk2AkQgCCAPNgJAIAggDTYCPCAIIBA2AjggCCAWNwMwIAggFT4CKCAIIBVCIIg+AiwgCEHgAGohBUIAIRUjAEEQayIBJAACQCAIQShqIgIpAwAiFEJqUyAUQiVVcg0AIAIpAwgiF0KAgICAgICAEFYNACACLQAhQQFxDQAgBQJ8IBRCF1kEQCABIBdCACAUp0EDdEHQ8IABaikDAEIAEKgeIAEpAwhCAFINAiABKQMAIhRCgICAgICAgBBWDQIgFLpEktVNBs/wgESiDAELIBSnIQQgF7ohGCAUQgBZBEAgBEEDdEGA8IABaisDACAYogwBCyAYQYDwgAEgBEEDdGsrAwCjCyIYmiAYIAItACAbOQMIQgEhFQsgBSAVNwMAIAFBEGokACAIKAJgQQFGBEAgCCsDaAwDCyAIQdAAaiAIKQMoIhUgFhDSCwJAAkACQCADRSAIKAJYIgRBAEhyRQRAIAhB4ABqIBUgFkIBfBDSCyAIKAJoIARGBEAgCCkDUCIUIAgpA2BRDQMLIBWnIgJB1gJqIgFBigVLDQMgFnkiFKchAyAIQRBqIAFBBHRB8JiBAWoiASkDAEIAIBYgFIYiFEIAEKgeIAgpAxgiFkL/A4NC/wNRBEAgCCkDECEVIAggASkDCEIAIBRCABCoHiAIKQMIQn+FIBVUrSAWfCEWCyACQeqkDWxBEHUgFkI/iFAiASADamtBzPcBayEEIBYgAa2GIRQMAQsgCCkDUCEUIARBAE4NAQsgCEHgAGohCSAUIRYgBEGAgAJqIQYjAEHwC2siAyQAIAhBKGoiASkDACEVIAEpAwgiFEKQzgBaBEADQCAVQgR8IRUgFEL/wdcvViAUQpDOAIAhFA0ACwsgFELkAFoEQANAIBVCAnwhFSAUQo/OAFYgFELkAIAhFA0ACwsgFEIKWgRAA0AgFUIBfCEVIBRC4wBWIBRCCoAhFA0ACwsgA0H8A2oiAiABQYEGEKYBIANBBGoiASACQfgD/AoAAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgFacgAygC9AdrQQFqIgRBAEgEQCADQfgHaiABQfgD/AoAAAJ/IAZBAWsiCkF0TARAIBZBwABBASAGayIBIAFBwABOG0E/ca2IQgAgAUE/TBsiFUL/////////B1YMAQtCACAWQguIQv////////8HgyAGQQtqIgFB/g9KIgIbIRVB/w8gASACGwshASADIBVC/////////weDIhQgFEKAgICAgICACIQgAa1CNIYgFYRCgICAgICAgPj/AIMiFVAiARsiFEIfiD4CgAQgA0EBQQIgFEKAgICACFQbOwHwByADIBSnQQF0QQFyNgL8AyADQfwDakEAIARrEM4KRQ0BAkBBzXcgFUI0iKdBtAhrIAEbIARrIgRBAEwEQCAEQQBODQlBACAEayIEQR9xIgcNAQwICyAEQR9xIgdFDQVBICAHayELAkAgAy8B8AciAUUEQEEAIQEMAQsgAUECdCEFIANB/ANqIQJBACEBA0AgAiABIAt2IAIoAgAiASAHdHI2AgAgAkEEaiECIAVBBGsiBQ0ACwsgASALdiIBRQ0FIAMvAfAHIgJB/ABLDQYgA0H8A2ogAkECdGogATYCACADIAMvAfAHQQFqOwHwBwwFC0EgIAdrIQsCQCADLwHsCyIBRQRAQQAhAQwBCyABQQJ0IQUgA0H4B2ohAkEAIQEDQCACIAEgC3YgAigCACIBIAd0cjYCACACQQRqIQIgBUEEayIFDQALCyABIAt2IgFFDQYgAy8B7AsiAkH8AEsNCCADQfgHaiACQQJ0aiABNgIAIAMgAy8B7AtBAWo7AewLDAYLIANBBGogBBDOCkUNAiAEQR9xIgZFDQFBICAGayEHAkAgAy8B+AMiAUUEQEEAIQEMAQsgAUECdCEFIANBBGohAkEAIQEDQCACIAEgB3YgAigCACIBIAZ0cjYCACACQQRqIQIgBUEEayIFDQALCyABIAd2IgFFDQEgAy8B+AMiAkH8AEsNAiADQQRqIAJBAnRqIAE2AgAgAyADLwH4A0EBajsB+AMMAQtBgNaAARCyOwALIAMvAfgDIQICfgJAAkAgBEEgSQRAIAIhAQwBCyAEQQV2IgUgAmoiAUH9AEsNAyACRQRAQQAhAkIAIRVCACEUDAILIAVBAnQhBSACQQJ0IgIEQCADQQRqIgQgBWogBCAC/AoAAAsgBQRAIANBBGpBACAF/AsACyADIAE7AfgDC0IAIRVCACEUAkACfgJAAkACQCABQf//A3EiAg4DBQECAAsgAkECdCICIANBBGpqIgVBDGspAgAiFEEgIAVBBGsoAgAiBWciBGutiCAFrSAEQSBzrSIWhoQhFUEAIQUgFCAWhkIAUg0DIANBDGshBANAIAJBDEYiBQ0EIAIgBGogAkEEayECKAIARQ0ACwwDCyADIAJBAnRqKAIAIgKtIAJnQSBzrYYMAQsgAkECdCADakEEaykCACIUIBR5hgshFUEBIQULQQAhAgJAIAFB//8DcSIBRQ0AIAMgAUECdGoiBEUNACAEKAIAZyECCyAVQguIIRQgAUEFdCACayECQgEgFUL/D4MiFkKACFYgBSAWQoAIUnJFcg0BGgsgFUL/H4NCgBhRrQshFiAJQf8PQf4HQf8HIBQgFnwiFEKAgICAgICAEFQbIAJqIgEgAUH+D0siARs2AgggCUIAIBRC/////////weDIAEbNwMADAgLQbDWgAEQsjsACyAEQSBJDQIgBEEFdiIBIAMvAfAHIgJqIgVB/QBLDQAgAkUNAiABQQJ0IQEgAkECdCICBEAgA0H8A2oiBCABaiAEIAL8CgAACyABBEAgA0H8A2pBACAB/AsACyADIAU7AfAHDAILQaDWgAEQsjsACyAEQSBJDQAgBEEFdiIBIAMvAewLIgJqIgVB/QBLDQEgAkUNACABQQJ0IQEgAkECdCICBEAgA0H4B2oiBCABaiAEIAL8CgAACyABBEAgA0H4B2pBACAB/AsACyADIAU7AewLCyADLwHsCyICIAMvAfAHIgFGDQEgASACSSABIAJLawwCC0GQ1oABELI7AAsgAUECdCEBIAJBAnQhAiADQfgDaiEHIANB9AdqIQsDQEEAIAJFIAFFcg0BGiABIAdqIQQgAiALaiABQQRrIQEgAkEEayECKAIAIgUgBCgCACIERg0ACyAEIAVJIAQgBUtrCyEBIAkCfyAKQXVOBEAgFkILiCEUQgACfgJAAkACQCABQf8BcQ4CAQIAC0IADAILIBRCAYMMAQtCAQsgFHwiFEL/////////B4NBC0EMIBRCgICAgICAgBBUGyAGaiIBQf4PSiICGyEVQf8PIAEgAhsMAQtCACEVIBZBwABBASAGayICIAJBwABOG0E/ca2IQgAgAkE/TBshFAJAAkACQCABQf8BcQ4CAAECCyAUQgGDIRUMAQtCASEVCyAUIBV8IhVC/////////wdWCzYCCCAJIBU3AwALIANB8AtqJAAgCCgCaCEEIAgpA2AhFAsgBK1CNIYgFIS/IhiaIBggExsMAwsgAUGLBUHQ1oABEMMhAAsCQCALQQhJDQAgCkEIciEBQQAhAwNAIANBCEYEQEQAAAAAAADwfyEYIAEhCQwDCyADIAVGDQEgA0Hm1oABaiEGIAMgBGogA0EBaiEDLQAAIgcgBi0AACIGRiAGIAdzQSBGcg0ACwtBACEDA0AgA0EDRgRARAAAAAAAAPB/IRgMAgsgAyAFRg0DIANB49aAAWohASADIARqIANBAWohAy0AACIGIAEtAAAiAUYgASAGc0EgRnINAAsMAgsgAiAJRw0BIBiaIBggExsLOQMIQgEhFgsgACAWNwMAIAhB8ABqJAAL6BcCDH8DfiMAQZADayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCACIFKAIIQQJGBEAgBS0ALUECaw4DAgIDAQsgACABIAIgAxDsCQwNCyAAIAEgAiADEPgCDAwLIAMvAQwhCUEBIQgCQAJAAkAgBS0ALCIGQQAgBkEDRxtBAWsOAgEAAgsgBEHIAmpBFkEAQQFBARCgGCAEKALMAiECIAQoAsgCQQFGDQMgBCgC0AIiAUEOakGO188AKQAANwAAIAFBCGpBiNfPACkAADcAACABQYDXzwApAAA3AAAgAEEWNgIUIAAgATYCECAAIAI2AgwgAEEDNgIIIABBgoCAgHg2AgAMCwtBASENQQIhCAsgAy8BDiEMIARB2ABqIAVBCGoiBRCKJiAEKAJcQQFHDQIgBEHIAGogBRCKJgJAAkAgBCgCTARAIAQoAkgiBSgCACIGQQhqIgcgBigCCEECRkECdGotACBBAmsOAgIPAQtBAEEAQbDTzwAQwyEACyAEQcgCakEjQQBBAUEBEKAYIAQoAswCIQEgBCgCyAJBAUYNBCAEKALQAiICQZzWzwBBI/wKAAAgAEEjNgIUIAAgAjYCECAAIAE2AgwgAEEDNgIIIABBgoCAgHg2AgAMCgsgBEFAayAHEIomIAQoAkRBAUYNCCAEQThqIAUoAgBBCGoQiiYgBCgCPEECRw0EIARBKGogBSgCAEEIahCKJiAEKAIsRQ0FIAQoAighByAEQSBqIAUoAgBBCGoQiiYgBCgCJCICQQFNDQYgBygCACICQQhqIAIoAghBAkZBAnRqLQAgIgJBA0YNDAJAAkACQAJAAkAgAkECSQRAIAQoAiBBBGoiCigCACICQQhqIAIoAghBAkZBAnRqLQAgQQJrDgICEgELIABBDGpBxdXPAEEbEIEgIABBgoCAgHg2AgAgAEEDNgIIDA4LIAMtAABBJ2sOAwMCAQILIABBDGpBqNXPAEEdEIEgIABBgoCAgHg2AgAgAEEDNgIIDAwLIARBKToAyAJBACEGDAkLIAQgAzYCoAEgBEEBNgLMAiAEQaDVzwA2AsgCIARCATcC1AIgBEGnBDYChAIgBCAEQYACajYC0AIgBCAEQaABajYCgAIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwKCyADKAIEIgItADBBIEcEQCAEIAJBMGo2AqABIARBATYCzAIgBEHs1M8ANgLIAiAEQgE3AtQCIARBpwQ2AoQCIAQgBEGAAmo2AtACIAQgBEGgAWo2AoACIABBDGogBEHIAmoQpxggAEGCgICAeDYCACAAQQM2AggMCgsgBEEYaiACQTRqIgIQwzQgBCgCHEECRwRAIARBEGogAhDDNCAEQTs2AoQCIARBATYCzAIgBEG81M8ANgLIAiAEQgE3AtQCIAQgBCgCFDYCoAEgBCAEQaABajYCgAIgBCAEQYACajYC0AIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwKCyAEQQhqIAIQwzQCQCAEKAIMBEAgBCgCCCgCACEGIAQgAhDDNCAEKAIEIgJBAU0NASADQQRqIQsgAy0AASEOIAQoAgAoAgQgBEHIAmogBkEwahDDBiAGQQhqIQ9BCGohBgwJC0EAQQBB4NPPABDDIQALQQEgAkHw088AEMMhAAsgACABIAIgAxC7AgwKCyACIAQoAtACQeSjzwAQ/S8ACyAEQdAAaiAFEIomIARBOzYChAIgBEEBNgLMAiAEQfjWzwA2AsgCIARCATcC1AIgBCAEKAJUNgKgASAEIARBoAFqNgKAAiAEIARBgAJqNgLQAiAAQQxqIARByAJqEJkOIABBgoCAgHg2AgAgAEEDNgIIDAYLIAEgBCgC0AJB5KPPABD9LwALIARBMGogBSgCAEEIahCKJiAEQTs2AoQCIARBATYCzAIgBEGU1s8ANgLIAiAEQgE3AtQCIAQgBCgCNDYCoAEgBCAEQaABajYCgAIgBCAEQYACajYC0AIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwEC0EAQQBBwNPPABDDIQALQQEgAkHQ088AEMMhAAsgBEGIAWogBEHQAmooAgA2AgAgBCAIIAxqIgg7AY4BIAQgCUEBaiIJOwGMASAEIAQpAsgCNwOAASAEQcgCaiABIAcgBEGAAWoQ0gEgBCgCyAIiAkGCgICAeEYEQCAEQZQCaiAEQeACaikDACIQNwIAIARBjAJqIARB2AJqKQMAIhE3AgAgBCAEKQPQAiISNwKEAiAAQRhqIBA3AgAgAEEQaiARNwIAIAAgEjcCCCAAQYKAgIB4NgIADAILIARB7ABqIARB1AJqKQIANwIAIARB9ABqIARB3AJqKQIANwIAIARB/ABqIARB5AJqKAIANgIAIAQgBCkCzAI3AmQgBCACNgJgAkAgBgRAIARByAJqIAZBKGoQwwYMAQsgBEEpOgDIAgsgBEGYAWogBEHQAmooAgA2AgAgBCAIOwGeASAEIAk7AZwBIAQgBCkCyAI3A5ABIARByAJqIAEgCiAEQZABahDSASAEKALIAiIBQYKAgIB4RgRAIARBlAJqIARB4AJqKQMAIhA3AgAgBEGMAmogBEHYAmopAwAiETcCACAEIAQpA9ACIhI3AoQCIABBGGogEDcCACAAQRBqIBE3AgAgACASNwIIIABBgoCAgHg2AgAgBEHgAGoQti8MAgsgBEGYAmogBEHkAmooAgAiAjYCACAEQZACaiAEQdwCaikCACIQNwMAIARBiAJqIARB1AJqKQIAIhE3AwAgBCAEKQLMAiISNwOAAiAEQdwBaiACNgIAIARB1AFqIBA3AgAgBEHMAWogETcCACAEQagBaiAEQegAaikCADcDACAEQbABaiAEQfAAaikCADcDACAEQbgBaiAEQfgAaikCADcDACAEIBI3AsQBIAQgBCkCYCIQNwOgASAEIAE2AsABIARBwAFqIQICQCABQYGAgIB4RiAQpyIMQYGAgIB4RnJFBEAgBEHIAmoiASAHKAIAQQhqIARB4ABqIA8QqwkgAUEAOgBAIARBgAJqIgcgAUHIAPwKAAAgBxDQKSEHIAEgCigCAEEIaiACIAYQqwkgARDQKSEBAkAgCwRAIARB4AFqIAsoAgBBCGoQsS4MAQsgBEHIAmpBqJ7PABClKyAEQegBakGwnM8AKQMANwMAIARBqJzPACkDADcD4AEgBCAEKQPQAjcD+AEgBCAEKQPIAjcD8AELIAUoAgAiBUEIaiAFKAIIQQJGQQJ0aiIFKAIQIQogBSgCDCELIAQgATYChAIgBCAHNgKAAiMAQSBrIgEkACABQQhqIQYgBEGAAmoiBykCACEQQRBBBBCtNiIFRQRAQQRBEBCjPQALIAUgEDcCCCAFQoGAgIAQNwIAIAZBAjYCBCAGIAU2AgAgAUEgOgAUIAEgASkDCDcCGCAEQcgCaiIFIAsgCiABQRRqQQAQmxQgAUEgaiQAIAcgBSAEQeABahCcJSAHENApIQVBwABBBBCmLyEBIAAgDToAHCAAIAg7ARogACAJOwEYIAAgBTYCECAAIA5BAXE6AA0gAEEnOgAMIABBAjYCCCAAIAE2AgQgAEECNgIAIAFBGGogBEH4AGopAgA3AgAgAUEQaiAEQfAAaikCADcCACABQQhqIARB6ABqKQIANwIAIAEgBCkCYDcCACABIAIpAgA3AiAgAUEoaiACQQhqKQIANwIAIAFBMGogAkEQaikCADcCACABQThqIAJBGGopAgA3AgAMAQsgAEGBgICAeDYCACAMQYGAgIB4RwR/IARBrAFqEJ0MIARBoAFqEMkoIAQoAsABBSABC0GBgICAeEYNACAEQcwBahCdDCACEMkoCyADLQAAQSlHDQIMAwsgBEHQAmogA0EIaikCADcDACAEIAMpAgA3A8gCIAAgASACIARByAJqELsCDAILIAMtAABBKUYNAQsgAxCdDAsgBEGQA2okAA8LQZ+6zwBBK0HMus8AEJ8pAAvUGAINfwN+IwBBkAhrIgIkAAJAAkAgASkDACIPQgJRBEACQAJAAkACQAJAAkAgASkDECIPUEUEQCACQcQEaiEGIAJBqAJqIQcgAkGQAmohBCACQYgFaiEIIAJB8ARqIQMgASgCQEEIaiELIAEoAhwhDCACQeAEakEEciEKIAEpAwghECABKAIYIQUDQCACQeAEaiALIBAQ9A8gBCAKQQhqKQIANwMAIAIgCikCADcDiAIgAigC4AQiCUEIRwRAIAJBiAdqIAJBkAJqKQMAIg83AwAgAiACKQOIAiIQNwOAByACKAL0BCEBIABBFGogDzcCACAAIBA3AgwgACABNgIcIAAgCTYCCCAAQg03AwAMCwsgAkHABGogBCkDADcDACACIAIpA4gCNwO4BCABQQA2AhgCQCAFBEAgAiAFQYgC/AoAACAFQYgCQQgQ+DoMAQsgAkHgBGoiCSACQbgEahDyEyACKQPoBCIRQgRSBEAgAkGIB2oiDSADQQhqKQMANwMAIAJBkAdqIg4gA0EQaikDADcDACACIAMpAwA3A4AHIAIoAuAEIQUgByAIQegB/AoAACAEQRBqIA4pAwA3AwAgBEEIaiANKQMANwMAIAQgAikDgAc3AwAgAiARNwOIAiAJIAUgDxCOGiACKALgBCIJQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgCTYCCCACQYgCahD8LAwGCyABIA8gBa0iEX0iDzcDECABIBAgEXwiEDcDCCACIAJBiAJqQYgC/AoAAAwBCyACQZAHaiADQRBqKQMAIg83AwAgAkGIB2ogA0EIaikDACIQNwMAIAIgAykDACIRNwOAByAAQRhqIA83AwAgAEEQaiAQNwMAIAAgETcDCCAAQg03AwAMBAsgAkHgBGogAigC/AEgAigC+AEgDxCFGSACKALgBCIFQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgBTYCCCACEPwsDAQLIAEgDyACKAL8ASIFrSIRfSIPNwMQIAEgECARfCIQNwMIIAIgBTYClAQgAigC9AFBAUcEQCACQeAEaiIEIAVBAEEBQQEQoBggAigC5AQhAyACKALgBEEBRg0FIAJBADYCoAQgAiACKALoBDYCnAQgAiADNgKYBCACQegEaiACQcAEaikDADcDACACIAIpA7gENwPgBCACIBE3A/gEIAIgETcD8AQgAkGIAmogBCACQZgEahDTByACLQCIAkEERgRAIAIoAowCIQMMBwsgAikDiAIiD0L/AYNCBFINAyAPQiCIpyEDDAYLIAIQ/CwgBiACKAK8BCACKALABCACKAK4BCgCEBEBAEEAIQUgD1BFDQALCyAAQgw3AwAMCAsgAiAPNwOIAiAAQQhqIAJBiAJqEIErIABCDTcDACACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBAAwDCyAGIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAYLIAMgAigC6ARBiIDOABD9LwALIAIgAzYCpAQgAkHsBGogAigC5AQgAigC6AQgAigC4AQoAhARAQAgAyAFRwRAIAJBAjYC5AQgAkHEgM4ANgLgBCACQgI3AuwEIAJBOzYClAIgAkE7NgKMAiACIAJBiAJqNgLoBCACIAJBpARqNgKQAiACIAJBlARqNgKIAiAAQQxqIAJB4ARqEJkOIABCDTcDACAAQQI2AggMAQsgAkGwBGogAkGgBGooAgA2AgAgAiACKQKYBDcDqAQgAkHgBGoiAyACQYgC/AoAACACQcgEaiIEIAJBqARqEOcVIAJBiAJqIAMgBCABLQBEIAFBOGpBACABKAI4GxCuASACQYgHaiIEIAJBmAJqKQMANwMAIAJBkAdqIgMgAkGgAmopAwA3AwAgAiACKQOQAjcDgAcgAikDiAIiD0IMUgRAIAJBsAdqIAJBqAJqQeAA/AoAACACQaAHaiAEKQMANwMAIAJBqAdqIAMpAwA3AwAgAiACKQOABzcDmAcgD0IJVA0CIA+nQQlrIgNBAkkNAiADQQJHDQQgAUEAOgAgDAQLIAAgAikDgAc3AwggAEINNwMAIABBGGogAykDADcDACAAQRBqIAJBiAdqKQMANwMADAQLIAJBmARqEN47IAIQ/CwMAwsgASAMQQFqNgIcDAELIAFCADcDAAJAAn4gD6ciCkEBcQRAIAEoAhghAyABKQMIDAELIAEoAiwiA0UNASABIANBAWs2AiwgASABKAIoIgNBAWoiBCABKAIgIgVBACAEIAVPG2s2AiggASgCJCADQRhsaiIEKAIQIQMgBCkDAAshDyADQQBIBEAgAkEBNgLkBCACQay+zQA2AuAEIAJCATcC7AQgAkGmBDYCjAIgAiACQYgCajYC6AQgAiACNgKIAiAAQQxqIAJB4ARqEJkOIABBADYCCCAAQg03AwAMAwsgAkHgBGohBSABKAJAQQhqIQYjAEFAaiIEJAAgBEEoaiAGIA8Q9A8gBEEgaiIGIARBNGopAgA3AwAgBCAEKQIsNwMYAkAgBCgCKCIHQQhHBEAgBCgCPCEDIAUgBCkDGDcCBCAFIAM2AhQgBUEMaiAGKQMANwIADAELIARBEGoiCCAGKQMANwMAIAQgBCkDGDcDCCAFQQRqIARBCGogAxDNFSAEQRRqIAQoAgwgCCgCACAEKAIIKAIQEQEACyAFIAc2AgAgBEFAayQAIAJBkAJqIgMgAkHsBGopAgA3AwAgAiACKQLkBDcDiAIgAigC4AQiBEEIRwRAIAIoAvQEIQEgACACKQOIAjcCDCAAIAE2AhwgACAENgIIIABCDTcDACAAQRRqIAMpAwA3AgAMAwsgAkHABGogAykDACIPNwMAIAIgAikDiAI3A7gEIAEoAjQhBSACQeAEaiEEIAIoArwEIQYjAEGwAmsiAyQAIANCADcDCCADIA+nIgc2AgQgAyAGNgIAIANBKGogAxCPFCADQRhqIgggA0E4aikDADcDACADQSBqIgsgA0FAaykDADcDACADIAMpAzA3AxACQCADKQMoIg9CBFEEQCAEIAMpAxA3AxAgBEIENwMIIARBIGogCykDADcDACAEQRhqIAgpAwA3AwAMAQsgBEEoaiADQcgAakHoAfwKAAAgBEEgaiADQSBqKQMANwMAIARBGGogA0EYaikDADcDACAEIAMpAxA3AxAgBCAPNwMIIAQgAykDCD4CAAsgA0GwAmokACACKQPoBCIPQgRSBEAgAkEIaiIDIAJB+ARqKQMANwMAIAJBEGoiBCACQYAFaikDADcDACACIAIpA/AENwMAIAIoAuAEIQYgAkGIAmogAkGIBWpB6AH8CgAAIAJB2ARqIAQpAwA3AwAgAkHQBGogAykDADcDACACIAIpAwA3A8gEIAJB8AZqIAJBuARqIAYQ6hQgCkEBcUUEQCABIAVBAWo2AjQLIAJB8ARqIAJB0ARqKQMANwMAIAJB+ARqIAJB2ARqKQMANwMAIAIgDzcD4AQgAiACKQPIBDcD6AQgAkGABWogAkGIAmpB6AH8CgAAIAIgAkHgBGogAkHwBmogAS0ARCABQThqQQAgASgCOBsQrgEgAkGIB2oiAyACQRBqKQMANwMAIAJBkAdqIgQgAkEYaikDADcDACACIAIpAwg3A4AHIAJBxARqIQEgAikDACIPQgxRBEAgACACKQOABzcDCCAAQg03AwAgAEEYaiAEKQMANwMAIABBEGogAykDADcDACABIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAQLIAJBsAdqIAJBIGpB4AD8CgAAIAJBoAdqIAJBiAdqKQMANwMAIAJBqAdqIAJBkAdqKQMANwMAIAIgAikDgAc3A5gHIAEgAigCvAQgAigCwAQgAigCuAQoAhARAQAMAgsgAkEQaiACQYAFaikDACIPNwMAIAJBCGogAkH4BGopAwAiEDcDACACIAIpA/AEIhE3AwAgAEEYaiAPNwMAIABBEGogEDcDACAAIBE3AwggAEINNwMAIAJBxARqIAYgByACKAK4BCgCEBEBAAwCCyAAQgw3AwAMAQsgACAPNwMAIABBCGogAkGYB2pB+AD8CgAACyACQZAIaiQAC+IqAhR/BH4jAEGQA2siAiQAIAJBnAJqIAEQpQggAkG4AWoiBCACQagCaigCADYCACACIAIpAqACNwOwASACKAKwAiEFIAIoAqwCIQMCQAJAAkAgAigCnAJBAUYEQCAAIAIpA7ABNwIEIAAgBTYCFCAAIAM2AhAgAEEEOgAAIABBDGogBCgCADYCAAwBCyACQSBqIAQoAgA2AgAgAiACKQOwATcDGAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCACIAIpArQCNwIwIAIgBTYCLCACIAM2AiggAigCICIEQQRqIQUgBEF7Sw0BIAUgAigCHCIDSw0CIAJBnAJqIgUgAigCGCIGIAMgBCAEIAZqIgcoAABrEPY0IAVBBhDMIEH//wNxIgVFBEBBACEFDAoLIAQgBWoiBSADSw0NAkACQAJAAkACQAJAAkACQAJAIAUgBmotAAAiBUEBaw4DAAIBEgsgAkGwAWogAkEYahC4FCACKAKwASIBDQMgAkGcAmpBKkEAQQFBARCgGCACKAKgAiEBIAIoApwCQQFHDQIMFAsgAkGcAmoiCSAGIAMgBCAHKAAAaxD2NAJAIAlBBhDMIEH//wNxIgVFDQAgBCAFaiIFIANLDRUgBSAGai0AAEEDRw0AIAkgAkEYahCSFSACKAKcAiIFDQULIAJBnAJqQSpBAEEBQQEQoBggAigCoAIhASACKAKcAkEBRw0DDBMLIAJBnAJqIgkgBiADIAQgBygAAGsQ9jQCQCAJQQYQzCBB//8DcSIFRQ0AIAQgBWoiBSADSw0UIAUgBmotAABBAkcNACAJIAJBGGoQkhUgAigCnAIiBQ0GCyACQZwCakE0QQBBAUEBEKAYIAIoAqACIQEgAigCnAJBAUcNBAwSCyACKAKkAiIDQczNzABBKvwKAAAgAEEqNgIQIAAgAzYCDCAAIAE2AgggAEGEgICAeDYCBCAAQQQ6AAAMDwsgAiACKQK0ATcCWCACIAE2AlQgAkHgAGogAkHUAGoQtwMgAkFAayACQfgAaikDADcDACACQcgAaiACQYABaikDADcDACACIAIpA3A3AzhBASEGQQAhBSACKAJsIQEgAigCaCEEIAIpA2AhFgwMCyACKAKkAiIDQarOzABBKvwKAAAgAEEqNgIQIAAgAzYCDCAAIAE2AgggAEGMgICAeDYCBCAAQQQ6AAAMDQsgAiACKQKgAjcCjAEgAiAFNgKIASACQZwCaiIFIAYgAyAEIAcoAABrEPY0IAVBBBDMIEH//wNxIgUEfyAEIAVqIgQgA0sNBiAEIAZqLwAABUEACyEEIAEoAngiAyADKAIAIgVBAWo2AgAgAiAEOwGWASAFQQBIDQYgAigCMCEEIAIoAjQhBSACIAIpAig3AogDIAJBADYChAMgAiAFNgKAAyACIAQ2AvwCIAJBCGogAkH8AmoQ1zsgAigCCCEGQRxBBBCtNiIERQ0HIARCgYCAgBA3AgAgBCACKQL8AjcCCCAEQRBqIAJBhANqKQIANwIAIARBGGogAkGMA2ooAgA2AgAgAiAFNgLsAiACIAY2AugCIAIgBDYC5AIgAkGcAmogAkHkAmogAkGIAWogAyABQdgAaiACQZYBahDsBgJAAkAgAi0A4AJBAkYEQCACQYgCaiACQawCaigCACIBNgIAIAJBgAJqIAJBpAJqKQIAIhY3AwAgAiACKQKcAiIXNwP4ASAAQRRqIAE2AgAgAEEMaiAWNwIAIAAgFzcCBCAAQQQ6AAAMAQsgAkGQAmoiAyACQbQCaikCADcDACACQYgCaiIEIAJBrAJqKQIANwMAIAJBgAJqIgUgAkGkAmopAgA3AwAgAkHgAWogAkHMAmopAgA3AwAgAkHoAWogAkHUAmopAgA3AwAgAkHvAWogAkHbAmooAAA2AAAgAkH3AWogAkHjAmotAAA6AAAgAiACKQKcAjcD+AEgAiACKQLEAjcD2AEgAiACLwDhAjsA9QEgAkG4AWogBSkDADcDACACQcABaiAEKQMANwMAIAJByAFqIAMpAwA3AwAgAiACKQP4ATcDsAEgAiABKAIoNgLUASACIAEtAH06APQBIAEoAiAhAyACQQA6APMBIAIgASgCJEEAIANBgICAgHhHGzYC0AEgAkGYAWogAkGwAWoQkwIgAigCnAEhAyACKQKgASEWIAIoAqgBIQQgAigCrAEhASACKAKYAUEBRw0BIAAgATYCFCAAIAQ2AhAgACAWNwMIIAAgAzYCBCAAQQQ6AAAgAigC5AIhBAsgBCAEKAIAIgBBAWs2AgAgAEEBRw0OIAJB5AJqEPseDA4LIAIoAuQCIgUgBSgCACIFQQFrNgIAIAVBAUYEQCACQeQCahD7HgtBACEGQQEhBQwKCyACKAKkAiIDQfbNzABBNPwKAAAgAEE0NgIQIAAgAzYCDCAAIAE2AgggAEGEgICAeDYCBCAAQQQ6AAAMCwsgAiACKQKgAjcC9AIgAiAFNgLwAiACQZwCaiIFIAYgAyAEIAcoAABrEPY0IAIgBUEEEMwgQf//A3EiBQR/IAQgBWoiBCADSw0HIAQgBmovAAAFQQALOwHkAiACKAIwIQQgAigCNCEDIAIgAikCKDcCqAIgAkEANgKkAiACIAM2AqACIAIgBDYCnAIgAkEQaiACQZwCahDXOyACKAIQIQRBHEEEEK02IgdFDQcgB0KBgICAEDcCACAHIAIpApwCNwIIIAdBEGogAkGkAmopAgA3AgAgB0EYaiACQawCaigCADYCACACIAM2AqABIAIgBDYCnAEgAiAHNgKYASACQbABaiEDIAJBmAFqIREgASgCeEEIaiEFIAFB2ABqIQwgAkHkAmohEiABLQB9IRMjAEHgAmsiASQAIAJB8AJqIgYoAggiCkEEaiEEAkACQAJAAkACQAJAAkACQCAKQXtNBEAgBCAGKAIEIglLDQEgAUGIAmoiBCAGKAIAIg0gCSAKIAogDWoiFCgAAGsQ9jQgASAEQQQQzCBB//8DcSIEBH4gBCAKaiIEIAlLDQMgBCANaikAAAVCAAsiFjcDECMAQUBqIgYkACAGIBY3AwggBSgCACEEIAUoAgQhBSAGQQA2AiQgBkEANgIUIAYgBEEIaiIENgI0IAYgBCAFQQJ0ajYCOCAGIAZBCGo2AjwgAUEYaiEPIwBBQGoiBCQAAkACQAJAIAZBFGoiCBDLDSIOBEAgBEEUaiIFQQMgCCgCHCAIKAIUa0ECdkEAIAgoAhAbIAgoAgwgCCgCBGtBAnZBACAIKAIAG2oiCyALQQNNG0EBakEAQQRBBBCgGCAEKAIYIQsgBCgCFEEBRg0CIARBEGoiFUEBNgIAIAQoAhwiECAONgIAIAQgEDYCDCAEIAs2AgggBSAIQSz8CgAAIAUQyw0iEARAIARBCGoiCCgCCCILQQJ0IQ4DQCAIKAIAIAtGBEAgCCALIAUoAgwgBSgCBGtBAnZBACAFKAIAGyAFKAIcIAUoAhRrQQJ2QQFqQQEgBSgCEBtqQQRBBBDcKAsgCCALQQFqIgs2AgggCCgCBCAOaiAQNgIAIA5BBGohDiAFEMsNIhANAAsLIAUQ/SIgD0EIaiAVKAIANgIAIA8gBCkCCDcCAAwBCyAPQQA2AgggD0KAgICAwAA3AgAgCBD9IgsgBEFAayQADAELIAsgBCgCHEH43IcBEP0vAAsgBkFAayQAIAEoAiBFBEAgAUECNgKMAiABQcDh/gA2AogCIAFCATcClAIgAUHuBjYCxAEgASABQcABajYCkAIgASABQRBqNgLAASABQfwAaiABQYgCahCZDiADIAEpAoABNwIIIANBEGogAUGIAWooAgA2AgAgAyABKAJ8NgIEIANBjYCAgHg2AgAMCQsgASgCHCgCACIELQAoQSJHDQcgAUEkaiIFIAQoAjAQxgZByABBCBCtNiIERQ0DIARBAUEAIAVBARCbFCABQQE2AoABIAEgBDYCfCABQQE2AnggAUGIAmpBpPb+ABClKyABKQOQAiEWIAEpA4gCIRcgAUEIaiABQfgAahD+IyABKAIMIQYgASgCCCEIIAFB1AJqIgQgDSAJIAogFCgAAGsQ9jQCQCAEQQYQzCBB//8DcSIEBEAgBCAKaiIEQQRqIQUgBEF7Sw0GIAUgCU0NASAFIAlBzNX+ABCwOwALQYzh/gAQsjsACyABIAk2AtgCIAEgDTYC1AIgASAEIA1qKAAAIARqNgLcAkEwQQgQrTYiBEUNBSAEIAY2AgwgBCAINgIIIARCgYCAgBA3AwAgBCAWNwMoIAQgFzcDICAEQbD2/gApAwA3AxAgBEEYakG49v4AKQMANwMAIAFBiAJqIBEgAUHUAmogBCAMIBIQ7AYgAS0AzAJBAkYEQCABQdABaiABQZgCaigCACIENgIAIAFByAFqIAFBkAJqKQIAIhY3AwAgASABKQKIAiIXNwPAASADQRBqIAQ2AgAgA0EIaiAWNwIAIAMgFzcCAAwJCyABQcABaiIEIAFBiAJqQcMA/AoAACABQb8BaiABQc8Cai0AADoAACABIAEvAM0COwC9ASABQfgAaiIFIARBwwD8CgAAIAEgEzoAvAEgAUEAOgC7ASABQeAAaiAFEJMCIAFB0ABqIgQgAUHsAGopAgA3AwAgAUHYAGoiBSABQfQAaigCADYCACABIAEpAmQ3A0ggASgCYEEBRgRAIAMgASkDSDcCACADQRBqIAUoAgA2AgAgA0EIaiAEKQMANwIADAkLIAFBQGsgBSgCADYCACABQThqIAQpAwA3AwAgASABKQNINwMwIAFBMGpBABCPLSIFKAIAIgQgBCgCACIGQQFqNgIAIAZBAEgNBiAFKAIEIQUgASgCPCIGIAYoAgAiBkEBazYCACAGQQFGBEAgAUE8ahD4IwsgAUEwaiIGEMMnIAYQ6jsgAyAFNgIIIAMgBDYCBCADQZOAgIB4NgIADAgLIAogBEHc1f4AELE7AAsgBCAJQdzV/gAQsDsACyAEIAlBzNT+ABCvOwALQQhByAAQoz0ACyAEIAVBzNX+ABCxOwALQQhBMBCjPQsACyABQQI2AowCIAFBwOH+ADYCiAIgAUIBNwKUAiABQe4GNgLEASABIAFBwAFqNgKQAiABIAFBEGo2AsABIAFB/ABqIAFBiAJqEJkOIAEpAnwhFiADIAEpAoQBNwIMIAMgFjcCBCADQY2AgIB4NgIACyABQRhqEOk7IAFB4AJqJAAgAigCuAEhASACKAK0ASEDIAIoArABIgRBk4CAgHhHBEAgACACKQK8ATcDECAAIAE2AgwgACADNgIIIAAgBDYCBCAAQQQ6AAAgByAHKAIAIgBBAWs2AgAgAEEBRw0MIBEQ+x4MDAsgByAHKAIAIgRBAWs2AgAgAiABNgKAAyACIAM2AvwCIARBAUYEQCACQZgBahD7HgsgAkHwAmoiARCRGCEHIAEQwxghFiACKAL8AiIEIAQoAgAiAUEBajYCACABQQBIDQQgAkGcAmohBSACKAKAAyEBQQAhBiMAQZABayIDJAAgAyABNgIcIAMgBDYCGCADIBY3AxACQAJAIAdFBEAgBCAEKAIAIgdBAWo2AgAgB0EASA0BIANBCGogDCAWIAQgARClCyADIAMoAgw2AnQgAyADKAIIIgc2AnACQCAHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACADQfAAahC7IwsgBUGTgICAeDYCAAwCCwJAAkAgDCgCDEUNACAMKAIAIglBEGshCiAMKAIEIgggDEEQaiADQRBqEI0OIhencSEHIBdCGYhC/wCDQoGChIiQoMCAAX4hGQNAIAcgCWopAAAiGCAZhSIXQn+FIBdCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiF1BFBEADQCAWIAogF3qnQQN2IAdqIAhxIg1BBHRrKQMAUQ0EIBdCAX0gF4MiF1BFDQALCyAYIBhCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAZBCGoiBmogCHEhBwwACwALIANBAjYCdCADQdDg/gA2AnAgA0IBNwJ8IANB7gY2AkggAyADQcQAajYCeCADIANBEGo2AkQgA0HcAGogA0HwAGoQmQ4gBSADKQJgNwIIIAVBEGogA0HoAGooAgA2AgAgBSADKAJcNgIEIAVBjYCAgHg2AgAMAgsgA0HA3/4ANgJAIANBwN/+ADYCOCADIAlBACANa0EEdGpBCGs2AjQgAyADQRhqNgI8IANBIGogA0E0akECEJ0BIAMoAiBBk4CAgHhHBEAgA0HoAGogA0EwaigCADYCACADQeAAaiADQShqKQIANwMAIAMgAykCIDcDWCADQQE2AnQgA0GE4f4ANgJwIANCATcCfCADQecENgKMASADIANBiAFqNgJ4IAMgA0HYAGoiBzYCiAEgA0HIAGogA0HwAGoQmQ4gBxCIESADKQJIIRYgBSADKQJQNwIMIAUgFjcCBCAFQY2AgIB4NgIADAILIAMgDCAWIAMoAiQgAygCKBClCyADIAMoAgQ2AnQgAyADKAIAIgc2AnACQCAHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACADQfAAahC7IwsgBUGTgICAeDYCAAwBCwALIAMoAhgiBSAFKAIAIgVBAWs2AgAgBUEBRgRAIANBGGoQuyMLIANBkAFqJAAgAigCnAIiA0GTgICAeEcEQCAAIAIpAqACNwIIIABBEGogAkGoAmopAgA3AgAgAEEEOgAAIAAgAzYCBCAEIAQoAgAiAEEBazYCACAAQQFHDQwgAkH8AmoQuyMMDAsgAkHwAmoiBRDDGCEWIAUQkRghB0EAIQZBAiEFDAgLIABBAzoAAAwKCyAEIAVB0MzMABCxOwALIAUgA0HQzMwAELA7AAsgBCADQYzJzAAQrzsLAAtBBEEcEKM9AAsgBCADQYzJzAAQrzsAC0EEQRwQoz0ACyAAIAE2AhQgACAENgIQIAAgFjcDCCAAIAM2AgQgACAHOgABIAAgBToAACAAIAIpAzg3AxggAEEgaiACQUBrKQMANwMAIABBKGogAkHIAGopAwA3AwAgBkUNAiACQShqEM8vDAILIAIgBToAmAEgAkECNgKgAiACQbzNzAA2ApwCIAJCATcCqAIgAkGaAzYCtAEgAiACQbABajYCpAIgAiACQZgBajYCsAEgAEEIaiACQZwCahCZDiAAQQQ6AAAgAEGEgICAeDYCBAsgAkEoahDPLwsgAkGQA2okAA8LIAEgAigCpAJBsMzMABD9LwALIAUgA0GMycwAEK87AAunFQIUfwN9IwBB8AhrIgokACAAKAKMASIGIAAoAnwiCEkEQCAAIAg2AowBIAghBgsgACgCdCEJAkACQAJAAkACQAJAAkACQAJAAkAgACgChAFFBEAgASgCDEUNAiABKAIIIAY2AgAgASgCBEUNAUEAIQYgASgCAEEAOgAAIAlFDQZBGiAJayIHQQAgB0EaTRshCCAJQQJ0IREgAEEIaiELIAIhBwNAIAMgBkYEQCADIANBuPHMABDDIQALIAogB0GAAiAAKAJwEIERIAsgCigCBLMiGiAKKgIAIhsgGiAbXhsiGjgCACAGIAhHBEAgCyARaiAaOAIAIAdBiAhqIQcgC0EEaiELIAkgBkEBaiIGRw0BDAgLCyAGIAlqQRpByPHMABDDIQALIAZFDQYgCkEkakEAQTT8CwAgCkHoAGoiCEEAQYQI/AsAIApBo+D/+wc2AuwIIApB3ABqIhEgCCAJQQF0EIEcIApBGGogEUHMgs4AEKIhIAooAhwhECAKKAIYIREgCEEAQegA/AsAIApBADYCXCAKQQA2AlggCQRAIAlBiAhsIRQgAEEIaiEWIBEhCCACIQsDQAJAAkACQAJAAkAgAyAAKAKQASAHaiIGSwRAIApBEGogAiAGQYgIbGoiF0GAAiAAKAJwEIERIAdBDUYNASAHQQFqIQ8gCkEkaiAHQQJ0aiIYIAooAhSzIhogCioCECIbIBogG14bOAIAQQAhBiAKQdwAaiENQQEhDgNAIAYgCWwgB2oiDCAQTw0EIAAgBkECdGooAgAiFSAHaiESIBEgDEGICGxqIhMgF0GICPwKAAAgAyASTQ0FIBMgAiASQYgIbGooAoAIIBMoAoAIajYCgAggCCAGIBRsaiESIAsgFUGICGxqIRVBACEGA0AgBiASaiIZIAYgFWooAgAgGSgCAGo2AgAgBkEEaiIGQYAIRw0ACyAKQQhqIBNBgAIgACgCcBCBESAMQRlLDQMgDEECdCIGIApB6ABqaiAKKAIMsyIaIAoqAggiGyAaIBteGyIaOAIAIA0gDSoCACAaIBgqAgCTIAYgFmoqAgCTkjgCAEEBIQYgDiAKQdgAaiENQQAhDg0ACwwFCyAGIANB+PPMABDDIQALQQ1BDUGI9MwAEMMhAAsgDEEaQbj0zAAQwyEACyAMIBBBmPTMABDDIQALIBIgA0Go9MwAEMMhAAsgCEGICGohCCALQYgIaiELIA8iByAJRw0ACwsCQAJAAkACQAJAIAEoAhAiDyAAKAJ4TwRAIAoqAlwhGyAKKgJYIRoMAQsgCioCWCEaIAoqAlwiGyAAKgKAASIcXkUNACAaIBxeDQELIAAoAoQBIQcgASgCDCEIIBogG0MAAKDBkl1FBEAgB0EBayIHIAhPDQIgASgCCCAHQQJ0aiIHIAcoAgAgACgCjAFqNgIAAkACQAJAAkAgCQRAIAMgACgCACIMayIHQQAgAyAHTxshEiAJQQJ0IRMgAEEIaiELIAIgDEGICGxqIQ4gCkHoAGohByARIQhBACEGA0AgBiAQRg0CIAYgEkYNAyAOIAhBiAj8CgAAIAZBGkYNBCALIAcqAgAiGjgCACAPQQFGBEAgBiAJaiINQRlLDQogCyATaiAaOAIACyAGIAAoApABaiINIANPDQUgAiANQYgIbGoiDUEAQYQI/AsAIA1Bo+D/+wc2AoQIIA5BiAhqIQ4gCEGICGohCCALQQRqIQsgB0EEaiEHIAkgBkEBaiIGRw0ACwsgAEEANgKMASAAIAAoApQBQQFqIgI2ApQBIAJBAkkNDSAAIAAoAnwgACgCiAFqNgKIAQwNCyAQIBBB6PHMABDDIQALIAYgDGogA0H48cwAEMMhAAtBGkEaQYjyzAAQwyEACyANIANBqPLMABDDIQALIAcgCE8NAyABKAIIIAdBAnRqIAAoAowBNgIAIAAoAoQBIgdBAmsiBiABKAIEIghPBEAgBiAIQcjyzAAQwyEACyAHIAhJDQcgByAIQdjyzAAQwyEACyAAKAKEASIHIAEoAgwiCE8EQCAHIAhBqPPMABDDIQALIAEoAgggB0ECdGogACgCjAE2AgAgACgChAEiByABKAIEIghJDQUgByAIQbjzzAAQwyEACyAHIAhB2PHMABDDIQALIA1BGkGY8swAEMMhAAsgByAIQbjyzAAQwyEAC0EAQQBBmPHMABDDIQALQQBBAEGI8cwAEMMhAAsgASgCACAHaiAPOgAAIAAoAgAhByAAIAkgD2w2AgAgACAHNgIEAkACQAJAAkAgCQRAIABBCGoiByAJQQJ0aiEIQRogCSAJQRpPG0ECdCEOQQAhC0GYfyEGA0AgBiAOakUNBSAGIAhqQegAaiAGIAdqQegAaiIMKgIAOAIAIAZBTEYNAiAMIAYgCmpBjAFqKgIAOAIAIAZBBGohBiAJIAtBAWoiC0cNAAsLIAEgD0EBajYCECAAIAAoAoQBQQFqNgKEASAAIAAoApABIAlqIgc2ApABAkAgByAEKAIATw0AIAMgB0kNAiAAKAJ0IgggAyAHayIDSw0DIAhFDQAgAiAHQYgIbGoiBiAIQYgIbGohAgNAIAZBAEGECPwLACAGQYQIakGj4P/7BzYCACAGQYgIaiIGIAJHDQALCyAAQQA2ApQBIABBADYCjAEgACAAKAJ8NgKIAQwFC0ENQQ1B6PPMABDDIQALIAcgA0HI88wAEK87AAsgCCADQazqzAAQsDsACyAJIAtqQRpB2PPMABDDIQALIAcgASgCACIIaiAGIAhqLQAAOgAAIAAoAgQhDyAAIAAoAgA2AgQgACAPNgIAAkAgCUUNAEEaIAlrIgdBACAHQRpNGyENIAMgD2siB0EAIAMgB08bIRIgECAJayIHQQAgByAQTRshEyAAQQhqIQsgESAJQYgIbGohDiACIA9BiAhsaiEIIAlBAnQiFCAKQegAamohB0EAIQYCQANAAkAgBiATRwRAIAYgEkcNASAGIA9qIANB+PLMABDDIQALIAYgCWogEEHo8swAEMMhAAsgCCAOQYgI/AoAACAGIA1GDQEgCyAUaiALKgIAOAIAIAsgByoCADgCACADIAYgACgCkAFqIgxLBEAgAiAMQYgIbGoiDEEAQYQI/AsAIAxBo+D/+wc2AoQIIA5BiAhqIQ4gB0EEaiEHIAhBiAhqIQggC0EEaiELIAkgBkEBaiIGRw0BDAMLCyAMIANBmPPMABDDIQALIAYgCWpBGkGI88wAEMMhAAsgAEEANgKUASAAQQA2AowBIAAgACgCfDYCiAEgACAAKAKEAUEBajYChAELIBBFDQEgESAQQYgIbEEEEPg6DAELIAAgACgChAFBAWo2AoQBIAEgASgCEEEBajYCECAAIAAoApABIAlqIgc2ApABAkAgByAEKAIATw0AIAMgB0kNAiAAKAJ0IgggAyAHayIDSw0DIAhFDQAgAiAHQYgIbGoiBiAIQYgIbGohAgNAIAZBAEGECPwLACAGQYQIakGj4P/7BzYCACAGQYgIaiIGIAJHDQALCyAAQQA2AowBCyAFRQ0CIAEgACgChAE2AhQgBCABKAIQIAlsNgIADAILIAcgA0Go8cwAEK87AAsgCCADQazqzAAQsDsACyAKQfAIaiQAC9kWAgZ/DX4jAEHwAmsiBCQAIAQgAzYCDCAEIAEgAhD0CCAEIAQoAgQiATYCFCAEIAQoAgAiAjYCECAEQQE7AcQCIAQgATYCwAIgBEEANgK8AiAEQQE6ALgCIARBLjYCtAIgBCABNgKwAiAEQQA2AqwCIAQgATYCqAIgBCACNgKkAiAEQS42AqACIARBGGogBEGgAmoQ0hUCQAJAAkACQAJAAkACQAJAIAQoAiAiCEECTQRAIAhFDQMgBCgCHCIGKAIAIQEgBigCBCICDQFBACECDAILIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMBgsCQAJAIAEtAABBK2sOAwECAAILQQEhCSACQQFHBEAgASwAAUG/f0wNBAsgAkEBayECIAFBAWohAQwBCyACQQFHBEAgASwAAUG/f0wNBAsgAkEBayECIAFBAWohAQsgBCACNgIoIAQgATYCJEEBIQcgCEECRgRAIAYoAgghByAGKAIMIQULIAQgBTYCMCAEIAc2AiwgAkUNAyABLQAAQTBrQf8BcUEKSQ0DIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMBAtBAEEAQZSbgAEQwyEACyABIAJBASACQaSbgAEQozYACyABIAJBASACQbSbgAEQozYACwJAIAVFDQAgBy0AAEEwa0H/AXFBCkkNACAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAELAkACQAJAAkACQCADIAVPBEAgA0EAIAMgBUsbIgFBgIAETw0BIAQgATsB/AEgBEEANgL4ASAEQcwBNgL0ASAEQQE2ArQCIARB/JuAATYCsAIgBEEBNgKkAiAEQfSbgAE2AqACIARBAjYCrAIgBCAEQSxqNgLwASAEIARB8AFqIgI2AqgCIARBwAFqIgEgBEGgAmoiAxCZDiAEQQI2AqQCIARBlJyAATYCoAIgBEICNwKsAiAEQf4PNgL8ASAEQcwBNgL0ASAEIAI2AqgCIAQgATYC+AEgBCAEQSRqNgLwASAEQTRqIAMQmQ4gARDeOwwFCyAEQaACaiIGIAcgBRDMECAEKAKgAkEBcQ0DIAQgBCkDyAIiEjcDWCAEIAQpA8ACIhM3A1AgBCAEKQO4AiIUNwNIIAQgBCkDsAIiFTcDQCAEQfABakIKQgAQsi4gBiAEKQPwASAEKQP4ASAEKQOAAiAEKQOIAiAFIANrEN8BIAQoAqACQQFGBEAgACAEKQKkAjcCBCAAQQxqIAQoAqwCNgIAIAQpA7ACIQogAEEBNgIAIAAgCjcDEAwGCyAEKQPIAiEOIAQpA8ACIQ8gBCkDuAIhECAEKQOwAiERIARBoAJqIgNCAkIAELIuIAMgESAQIA8gDiAEKQOgAiAEKQOoAiAEKQOwAiAEKQO4AhCaCAJ+IAQtAKACQQFGBEBCgICAgICAgICAfyAELQChAg0BGgwICyAEKQPAAiEMIAQpA7gCIQogBCkDsAIhDSAEKQPIAgshFiAEIA03A2AgBCAKNwNoIAQgDDcDcCAEIBY3A3ggBEIAIAogDUIAUq18fSIKNwOIASAEQgAgDX0iDTcDgAEgBCANQgBSIApCAFIgClAbQX9zrUIBgyIKIAxCf4V8Igw3A5ABIAQgCiAMVq0gFkJ/hXw3A5gBIARBoAJqIBUgFCATIBIgESAQIA8gDhCaCAJ+IAQtAKACQQFGBEAgBC0AoQIEQEKAgICAgICAgIB/IQ1CACEKQgAMAgsMCAsgBCkDyAIhDSAEKQO4AiEKIAQpA7ACIQsgBCkDwAILIQwgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAkAgBC0AoAJBAUYEQCAELQChAgRAIARBuAFqQgA3AwAgBEGwAWpCADcDACAEQgA3A6gBIARCADcDoAEMAgsgBEEANgKAAiAEQQE2AvQBIARBjJSAATYC8AEgBEIENwL4ASAEQfABakGklIABEO8sAAsgBCAEKQPoAjcDuAEgBCAEKQPgAjcDsAEgBCAEKQPYAjcDqAEgBCAEKQPQAjcDoAELAkAgBEFAa0HQk4ABEPsbIgNB/wFxQQJHIAPAQQBOcUUEQCAEQaABaiAEQYABahD7G8BBAEwNAQwDCyAEQaABaiAEQeAAahD7GyIDQf8BcUECRiADwEEASHINAiANIAwgC0IBfCIOIAogDlCtfCIPhFCtfCIKIAxUrXwhDQwDCyALQgF9IQ4gCiALUK19IQ8gDCAKIAuEUK0iC30hCiANIAsgDFatfSENDAILIARBADYCsAIgBEEBNgKkAiAEQbCXgAE2AqACIARCBDcCqAIgBEGgAmpB5JuAARDvLAALIAshDiAKIQ8gDCEKCwJ+IAJFBEBCACELQgAhDEIAIRFCAAwBCyAEQaACaiABIAIQzBAgBCAEKAKgAkEBcQR+QgAFIAQgBCkDyAI3A5gCIAQgBCkDwAI3A5ACIAQgBCkDuAI3A4gCIAQgBCkDsAI3A4ACQgELNwPwASAEQgA3A/gBIARBoAJqIgEgBEHwAWogBEEQahCSFyAEQcABaiABIARBDGoQ5g0gBCgCwAFBAUYEQCAAIAQpAsQBNwIEIABBDGogBCgCzAE2AgAgBCkD0AEhCiAAQQE2AgAgACAKNwMQDAQLIAQpA+gBIREgBCkD4AEhDCAEKQPQASELIAQpA9gBCyEQIARBATYC9AEgBEH0m4ABNgLwASAEQgE3AvwBIARB/w82AsQBIAQgCyAOfCIONwOgAiAEIAsgDlYiAa0gDyAQfHwiCzcDqAIgBCAKIAx8IgogASALIBBUIAsgEFEbrXwiCzcDsAIgBCAKIAtWrSAKIAxUrSANIBF8fHw3A7gCIAQgBEHAAWo2AvgBIAQgBEGgAmo2AsABIARBNGogBEHwAWoQmQ4MAQsgBEEBNgKkAiAEQdScgAE2AqACIARCATcCrAIgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiAEQaACahCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIEIABBDGogBEH4AWooAgA2AgAgBCkC/AEhCiAAQQE2AgAgACAKNwMQDAELIAQoAjwhAiAJBEAgBEE0akEBEIQuIAIEQCAEKAI4IgFBAWogASAC/AoAAAsgBCgCOEEtOgAAIAQgAkEBaiICNgI8CyAEQaACaiIBIAQoAjggAhDMECAEKAKgAkEBcQRAIARBAzYCpAIgBEGQnYABNgKgAiAEQgI3AqwCIARBzAE2AswBIARBtJ2AATYCyAEgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiABEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaigCADYCACAEKQL8ASEKIABBATYCACAAIAo3AxAgBEE0ahDeOwwBCyAEKQOwAiEKIAQpA7gCIQsgBCkDwAIhDCAAIAQpA8gCNwMoIAAgDDcDICAAIAs3AxggACAKNwMQIABBADYCACAEQTRqEN47CyAEQRhqEOo7IARB8AJqJAAPCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQZSUgAEQ7ywAC5ATAgZ/CH4jAEHwAGsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQEQCAAKAIAIgAoAhRFDQEgACgCECIAKAIIRQ0CAkACQAJAAkACQCABLQA8QShGBEAgACgCBCEIIAUgASgCQCIHQTBqNgIcIActADBBA2sOAwIDBAELIAVBADYCYCAFQQE2AlQgBUGUuocBNgJQIAVCBDcCWCAFQdAAakGcuocBEO8sAAsgBUEBNgJUIAVBiLCHATYCUCAFQgE3AlwgBUGvAzYCbCAFIAVB6ABqNgJYIAUgBUEcajYCaCAFQdAAakHUuYcBEO8sAAsgASgCKCIKRQ0GIAEoAiQiBxCUGiEGIAA1AiQhDUEAIQEgBUEANgJYIAVCgICAgBA3AlAgBSAGOwFoIAUgCBDGGyADIARqIQYgBTUCBEIBfCEPIAUoAgAhBEKAgICAECEMQoCAgIAQIQ5BACEIA0ACQCANUA0AIA9CAX0iD1ANACABIQAgBC4BACIBQQBIDQkgEEIBfCEQAkACQCAAIANNIAEgA0txRQRAIAEgBk0gACADT3ENASABIAZJIAAgBk9yDQIgBS4BaCAGIABrwWoiAMEgAEcNFCAFIAA7AWggBUHQAGogBUHoAGpBAhChNiAIRQ0VIAtC/////w+DIA58IQtBASEIDAMLIAUuAWggASAGIAEgBkkbIANrwWoiAMEgAEcNECAFIAA7AWggBUHQAGogBUHoAGpBAhChNkEBIQggDCELDAELIAUuAWggASAAa8FqIgDBIABHDRAgBSAAOwFoIAVB0ABqIAVB6ABqQQIQoTYgCEUNESALQv////8PgyAQQiCGhCELQQEhCAsgDUIBfSENIAxCgYCAgBB8IQwgBEECaiEEIA5CgICAgBB8IQ4gASAGSQ0BCwsgBUEoaiAFQdgAaigCACIANgIAIAUgBSkCUDcDICAFQSBqIQMgAEUNAiAFKAIkIQEgBygCGCIEIABqIgYgBygCECIJSwRAIAdBDGogCUEBdCIEIAYQ4CoiBiAEIAZLGxDoGSAHKAIYIQQLIAAEQCAHKAIUIARqIAEgAPwKAAALIAcgBygCGCAAajYCGCAHIAcoAlggAEEBdmo2AlggCEUNESAKQQFGDRIgB0HMAWogAiALpyALQiCIpxDYGwwCCyABKAIoIgpFDQcgASgCJCIHEJIaIQEgADUCJCENIAVBADYCWCAFQoCAgIAQNwJQIAUgATYCaCAFQQhqIAgQxxsgAyAEaiEGIAU1AgxCAXwhDyAFKAIIIQRCgICAgBAhDEKAgICAECEOQQAhAUEAIQgDQAJAIA1QDQAgD0IBfSIPUA0AIAEhACAEKAIAIgFBAEgNCiAQQgF8IRACQAJAIAAgA00gASADS3FFBEAgASAGTSAAIANPcQ0BIAEgBkkgACAGT3INAiAGIABrIgBBAEggACAFKAJoIgFqIgAgAUhHDRMgBSAANgJoIAVB0ABqIAVB6ABqQQQQoTYgCEUNFCALQv////8PgyAOfCELQQEhCAwDCyABIAYgASAGSRsgA2siAEEASCAAIAUoAmgiCGoiACAISEcNDyAFIAA2AmggBUHQAGogBUHoAGpBBBChNkEBIQggDCELDAELIAEgAGsiAEEASCAAIAUoAmgiCWoiACAJSEcNDyAFIAA2AmggBUHQAGogBUHoAGpBBBChNiAIRQ0QIAtC/////w+DIBBCIIaEIQtBASEICyANQgF9IQ0gDEKBgICAEHwhDCAEQQRqIQQgDkKAgICAEHwhDiABIAZJDQELCyAFQThqIAVB2ABqKAIAIgA2AgAgBSAFKQJQNwMwIAVBMGohAyAARQ0BIAUoAjQhASAHKAIYIgQgAGoiBiAHKAIQIglLBEAgB0EMaiAJQQF0IgQgBhDgKiIGIAQgBksbEOgZIAcoAhghBAsgAARAIAcoAhQgBGogASAA/AoAAAsgByAHKAIYIABqNgIYIAcgBygCWCAAQQJ2ajYCWCAIRQ0QIApBAUYNESAHQcwBaiACIAunIAtCIIinENgbDAELIAEoAigiCkUNCCABKAIkIgcQkxohDCAANQIkIQ1BACEBIAVBADYCWCAFQoCAgIAQNwJQIAUgDDcDaCAFQRBqIAgQxRsgAyAEaiEGIAU1AhRCAXwhDyAFKAIQIQRCgICAgBAhDEKAgICAECEOQQAhCANAAkAgDVANACAPQgF9Ig9QDQAgBCkDACIRQoCAgIAQWg0LIBBCAXwhEAJAAkAgASIAIANNIAMgEaciAUlxRQRAIAEgBk0gACADT3ENASABIAZJIAAgBk9yDQIgBiAAa60iDEIAVCAMIAUpA2giDXwiDCANU0cNEiAFIAw3A2ggBUHQAGogBUHoAGpBCBChNiAIRQ0TIAtC/////w+DIA58IQtBASEIDAMLIAYgASABIAZLGyADa60iC0IAVCALIAUpA2giEXwiCyARU0cNDiAFIAs3A2ggBUHQAGogBUHoAGpBCBChNkEBIQggDCELDAELIAEgAGutIhFCAFQgESAFKQNoIhJ8IhEgElNHDQ4gBSARNwNoIAVB0ABqIAVB6ABqQQgQoTYgCEUNDyALQv////8PgyAQQiCGhCELQQEhCAsgDUIBfSENIAxCgYCAgBB8IQwgBEEIaiEEIA5CgICAgBB8IQ4gASAGSQ0BCwsgBUHIAGogBUHYAGooAgAiADYCACAFIAUpAlA3A0AgBUFAayEDIABFDQAgBSgCRCEBIAcoAhgiBCAAaiIGIAcoAhAiCUsEQCAHQQxqIAlBAXQiBCAGEOAqIgYgBCAGSxsQ6BkgBygCGCEECyAABEAgBygCFCAEaiABIAD8CgAACyAHIAcoAhggAGo2AhggByAHKAJYIABBA3ZqNgJYIAhFDQ8gCkEBRg0QIAdBzAFqIAIgC6cgC0IgiKcQ2BsLIAMQ3jsLIAVB8ABqJAAPC0EAQQBBhLmHARDDIQALQQBBAEGUuYcBEMMhAAtBAEEAQaS5hwEQwyEAC0HosIcBELI7AAtBAEEAQbS5hwEQwyEAC0HosIcBELI7AAtBAEEAQcS5hwEQwyEAC0HosIcBELI7AAtBqK+HAUEQQfC3hwEQyyQAC0Gor4cBQRBBjLWHARDLJAALQay1hwFBsQJB4LeHARDLJAALQaivhwFBEEH4sIcBEMskAAtBmLGHAUHkA0H8tIcBEMskAAtBkLiHAUE6Qcy4hwEQyyQAC0EBQQFB3LiHARDDIQAL0RQBEH8jAEHAB2siAiQAIAJBmANqIAEoAgwiAyABKAIQIgQoAhgRAAAgAigCoAMhBiACKAKcAyEFAkACQAJAIAIoApgDIgdBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAGNgIIIAAgBTYCBCAAIAc2AgAMAQsgAiAGNgIgIAIgBTYCHAJAAkACQCACQRxqEPUtRQRAIAJBEGogAyAEKAIgEQAAIAIoAhAiBw0CIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRw0BDAULIAIgARCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAgsgAigCoAMiAUEYakGc1NAAKQAANwAAIAFBEGpBlNTQACkAADcAACABQQhqQYzU0AApAAA3AAAgAUGE1NAAKQAANwAAIABBIDYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACKAIUIQUgAkEIaiADIAQoAiQRAAAgAigCCCIMRQRAIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRg0DIAIoAqADIgFBGGpBvNTQACkAADcAACABQRBqQbTU0AApAAA3AAAgAUEIakGs1NAAKQAANwAAIAFBpNTQACkAADcAACAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAMAQsgAigCDCEGIAJBHGoQ9C0aAkAgBkUNACAMLwEARQ0AIAJBmANqQSlBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRg0EIAIoAqADIgNBiNHQAEEp/AoAACAAQSk2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAQsgAkGYA2ogAkEcahD0LUEBakEAQQhBCBCgGCACKAKcAyEDAkACQAJAAkACQAJAIAIoApgDQQFHBEAgAkEANgIsIAIgAigCoAM2AiggAiADNgIkAkAgAS0AGEUEQCACQQA2AjAMAQtBwAAhBCACQRxqEPQtIgNBA3YgA0EHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQQLIAJCADcCPCACIAQ2AjggAiADNgI0IAJBwAA2AjALIAJBxABqIgQgAkEcaiINEMMtQQRBBBCtNiIDRQ0DIAJBATYCoAMgAiADNgKcAyACQQE2ApgDIAMgBDYCAEEAIQMgAkGIAWogAkGYA2pBACANEPQtEMAsIAYgBSAFIAZLGyINRQRAQQAhBEEAIQYMBQsgAS8BFsEhEEEAIQRBACEGA0ACQAJAAkACQAJAIAwuAQAiBSAQSiAFIBBIa0H/AXEOAgIBAAsgAigCLCIFIAIoAiRGBEAgAkEkakHU1NAAELMoCyACKAIoIAVBA3RqIAOtNwMAIAIgBUEBajYCLCAHLgEAIgggAS4BFCIRSARAIAQEQCACQYgBakEAIA4gAyAGahDYGwsCQCACKAIwRQ0AIAIoAkAiCUEBaiIKQQN2IApBB3FBAEdqIgUgAigCPCIESwRAIAUgBGshCyACKAI0Ig8gBUkEQCACQTBqIA9BAXQiBCAFQcD///8DcUFAayAFIAVBP3EbIg8gBCAPSxsQ6BkgAigCPCEECyALBEAgAigCOCAEakEAIAv8CwALIAIgBTYCPAsgAiAKNgJAIAhBAWpB//8DcSARQf//A3FHDQAgAigCOCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAALIAZBAWohBkEAIQQMAwsgDiADIAZqIAQbIQ4gA0EBaiEDIAIoAjBFBEBBASEEDAMLIAIoAkAiCUEBaiIKQQN2IApBB3FBAEdqIgUgAigCPCIESwRAIAUgBGshCyACKAI0IgggBUkEQCACQTBqIAhBAXQiBCAFQcD///8DcUFAayAFIAVBP3EbIgggBCAISxsQ6BkgAigCPCEECyALBEAgAigCOCAEakEAIAv8CwALIAIgBTYCPAsgAiAKNgJAQQEhBCACKAI4IAlBA3ZqIgUgBS0AAEEBIAlBB3F0cjoAAAwCCyAHLgEAIAEuARRODQEgAkGYA2pBO0EAQQFBARCgGCACKAKcAyEBIAIoApgDQQFHDQIMDgsgA0EBaiEDCyAHQQJqIQcgDEECaiEMIA1BAWsiDQ0BDAYLCyACKAKgAyIDQeTU0ABBO/wKAAAgAEE7NgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAULIAMgAigCoANBtNHQABD9LwALQZSf0ABBKSACQZgDakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAsgAigCLCIFIAIoAiRGBEAgAkEkakHU0dAAELMoCyACKAIoIAVBA3RqIAOtNwMAIAIgBUEBajYCLAJAIAZFBEAgAkHUAmogAkEcahDDLQwBCyAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLIAJBmANqIgQgAkGIAWpBzAH8CgAAIAJB1AJqIAQQ6iwLAkACQCACKAL4AiADRgRAIAJB6ARqIgMgAigCKCACKAIsQQN0EIs9IAJBuANqIAEQxAYgAkEAOwHwAyACQQA2AuwDIAJBADYC1AMgAkEANgLIAyACQgQ3ArADIAJCADcCqAMgAkKAgICAwAA3AqADIAJBADYCmAMgAiACKAIsQQFrNgLEAyACQdAFaiIEIAJBmANqIgEgAxD6IyABIAJB1AJqQcQA/AoAACACQfQEaiAEIAEQ7yUgAigCMEUNAiACIAIoAkAiAzYCsAYgAiACKAIsQQFrIgQ2ArQGIAMgBEYNASACQQA2ApgDQQAgAkGwBmogAkG0BmogAUHk0dAAEK8rAAsgAkGYA2pBKkEAQQFBARCgGCACKAKcAyEBIAIoApgDQQFGDQcgAigCoAMiA0HM0tAAQSr8CgAAIABBKjYCDCAAIAM2AgggACABNgIEIABBADYCACACQdQCahD6JiAGRQ0CDAMLIAJBmANqIgEgAkH0BGoiBEHcAPwKAAAgAkHYBWogAkE4aikCADcDACACIAIpAjA3A9AFIAIgAzYC4AUgAkG4BmoiAyACQdAFahCIGSAEIAEgAxCuFgsgAkGYA2oiASACQfQEakHcAPwKAAAgAkHEBmoiAyABEM0cIAJBiAdqIgQgAxCuHwJAQcAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTj8CgAAIABBrNPQADYCCCAAIAE2AgQgAEEINgIAIAYNASACQYgBahCXFwwBC0EEQcAAEKM9AAsgAkHEAGoQ+iYgAkEkahDjPCACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNAyACQRxqELsjDAMLIAJBiAFqEJcXCyACQcQAahD6JiACKAIwBEAgAkEwahDPLwsgAkEkahDjPAsgAigCHCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEcahC7IwsgAkHAB2okAA8LIAMgAigCoANBpMbQABD9LwALIAEgAigCoANBpMbQABD9LwALlRgBE38jAEGQA2siAiQAIAJBzABqIAFBDGpB0AD8CgAAQQEhEEEEIQZBASEMAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAItAIgBIgtBFGsOFQMBAwQDAwQBAQIBAQIFAQEBAQEBAgALIAtFDQELQQxBBBCtNiIGRQ0FIAIoAlQhBSACKAJYIQkgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAk2AqACIAIgBTYCnAIgAkEQaiACQZwCahDXOyACKAIQIQRBHEEEEK02IgVFDQ8gBUKBgICAEDcCACAFIAIpApwCNwIIIAVBEGogAkGkAmopAgA3AgAgBUEYaiACQawCaigCADYCACAGIAk2AgggBiAENgIEIAYgBTYCAEEBIQULIAtBIkYNA0EBIQ0gBQwLC0EYQQQQrTYiBkUNBCACKAJUIQMgAigCWCEMIAIgAikCTDcCqAIgAkEANgKkAiACIAw2AqACIAIgAzYCnAIgAkEgaiACQZwCaiIJENc7IAIoAiAhA0EcQQQQrTYiB0UNDSAHQoGAgIAQNwIAIAcgAikCnAI3AgggB0EQaiACQaQCaiIQKQIANwIAIAdBGGogAkGsAmoiBSgCADYCACACKAJkIQQgAigCaCENIAIgAikCXDcCqAIgAkEANgKkAiACIA02AqACIAIgBDYCnAIgAkEYaiAJENc7IAIoAhghCUEcQQQQrTYiCEUNDQwJCyACQYADaiABQeQAaigCADYCACACIAEpAlw3A/gCIAIoAlQhAyACKAJYIQUgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAU2AqACIAIgAzYCnAIgAkEoaiACQZwCahDXOyACKAIoIQlBHEEEEK02IgNFDQwgA0KBgICAEDcCACADIAIpApwCNwIIIANBEGogAkGkAmopAgA3AgAgA0EYaiACQawCaigCADYCACACIAU2AsgBIAIgCTYCxAEgAiADNgLAASACQfgCaiACQcABakHolocBEPkbIAIoAvwCIQYgAigCgAMhBSACKAL4AgwJCyACLQCJAQ0GQQxBBBCtNiIGRQ0DIAIoAlQhAyACKAJYIQUgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAU2AqACIAIgAzYCnAIgAkFAayACQZwCahDXOyACKAJAIQlBHEEEEK02IgNFDQsgA0KBgICAEDcCACADIAIpApwCNwIIIANBEGogAkGkAmopAgA3AgAgA0EYaiACQawCaigCADYCACAGIAU2AgggBiAJNgIEIAYgAzYCAEEBIQ1BASEFQQEMCAtBxABBBBCtNiIJRQ0DIAEoAoABIgRBgICAgHhGDQQgCUEEaiABQYQBakHAAPwKAAAgCSAENgIAQQEhDSACQQE2AqQBIAIgCTYCoAEgAkEBNgKcASAFIQlBASEHDAgLQQRBDBCjPQALQQRBGBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC0H4locBELI7AAsCQEEYQQQQrTYiBgRAIAIoAlQhAyACKAJYIQwgAiACKQJMNwKoAiACQQA2AqQCIAIgDDYCoAIgAiADNgKcAiACQThqIAJBnAJqIgkQ1zsgAigCOCEDQRxBBBCtNiIHRQ0GIAdCgYCAgBA3AgAgByACKQKcAjcCCCAHQRBqIAJBpAJqIhApAgA3AgAgB0EYaiACQawCaiIFKAIANgIAIAIoAmQhBCACKAJoIQ0gAiACKQJcNwKoAiACQQA2AqQCIAIgDTYCoAIgAiAENgKcAiACQTBqIAkQ1zsgAigCMCEJQRxBBBCtNiIIRQ0BDAILQQRBGBCjPQALDAQLIAhCgYCAgBA3AgAgCCACKQKcAjcCCCAIQRBqIBApAgA3AgAgCEEYaiAFKAIANgIAIAYgDTYCFCAGIAk2AhAgBiAINgIMIAYgDDYCCCAGIAM2AgQgBiAHNgIAQQEhDUEAIRBBACEMQQIhBUECCyEJIAIoAnQhBCACKAJwIQMgAiACKAJsNgKkAiACIAM2AqACIAIgAzYCnAIgAiADIARBzAFsajYCqAIjAEEQayIOJAAgAkGcAmoiAygCCCETIA5BCGohDyADKAIAIgchBCADKAIMGiMAQfACayIIJAAgAygCBCIKIAMoAgwiEUcEQANAIAhByABqIhIgCkHMAfwKAAAgAyAKQcwBaiIKNgIEIAhBlAJqIhQgEhDZASAIQQRqIhIgFBDNHCAEIBJBxAD8CgAAIARBxABqIQQgCiARRw0ACwsgDyAENgIEIA8gBzYCACAIQfACaiQAIA4oAgwhESMAQRBrIggkACADQQA2AgggAygCDCEKIAMoAgQhBCADQQQ2AgAgCEKAgICAwAA3AgggCEEIakEEQcwBEOAeIANBBDYCDCADQQQ2AgQgCiAEa0HMAW4hDyAEIApHBEADQCAEEPUQIARBzAFqIQQgD0EBayIPDQALCyAIQRBqJAAgAkGcAWoiBCAHNgIEIAQgE0EDbDYCACAEIBEgB2tBxABuNgIIIwBBEGsiBCQAIAMoAgwiCiADKAIEIgdrQcwBbiEIIAcgCkcEQANAIAcQ9RAgB0HMAWohByAIQQFrIggNAAsLIAQgAygCADYCDCAEIAMoAgg2AgggBEEIakEEQcwBEOAeIARBEGokACAOQRBqJABBASEIQQAhByALRQRAQQAhAwwCC0EAIQMgC0EoRg0BC0EAIQggAigCeCIERQ0AIAIoAoQBIQsgAigCgAEhCiACIAIoAnw2AqwCIAIgBDYCqAIgAkEANgKkAiACIAs2AqACIAIgCjYCnAIgAkEIaiACQZwCaiIKENc7IAIoAgghDkEcQQQQrTYiBEUNASAEQoGAgIAQNwIAIAQgAikCnAI3AgggBEEQaiACQaQCaikCADcCACAEQRhqIAJBrAJqKAIANgIAIAIgCzYCgAMgAiAONgL8AiACIAQ2AvgCIAogAkH4AmpBACACKAKYARDyFSACQcgBaiILIAJBqAJqIg4pAgA3AwAgAkHQAWoiDyACKAKUATYCACACIAIpAqACNwPAASACKAKcAiIERQ0AIA4gCykDADcCACACQbACaiAPKAIAIgM2AgAgAiAENgKcAiACIAIpA8ABNwKgAiADRQRAIAQgBCgCACIEQQFrNgIAQQAhAyAEQQFHDQEgChD7HgwBCyACQbgBaiACQdABaigCADYCACACQbABaiACQcgBaikDADcDACACIAIpA8ABNwOoASAEIQMLIAJBxAJqIAJBiAFqIgRBCGooAgA2AgAgAkEAOwH0AiACQQA2AvACIAJBADYC2AIgAkEANgLMAiACIAIoApgBNgLIAiACQgQ3ArQCIAJCADcCrAIgAkKAgICAwAA3AqQCIAJBADYCnAIgAiAEKQIANwK8AiACIAM2AvgCIAJBhANqIAJBsAFqKQMANwIAIAJBjANqIAJBuAFqKAIANgIAIAIgAikDqAE3AvwCIAJBwAFqIgQgAkGcAmoiAyACQfgCahDCGSACQcgBaiILEMUnIAtBBEEMEOAeIAIgBTYC0AEgAiAGNgLMASACIAk2AsgBIAMgBEHcAPwKAAAgACADIAJBnAFqEPwiAkAgCEUNACACKAJ4RQ0AIAJB+ABqEM8vCyAMBEAgAkHMAGoQzy8LIBAEQCACQdwAahDPLwsCQCAHBEAgAkHsAGoiABCKFCAAQQRBzAEQ4B4gAUEEQQQQ4B4MAQsgAUEEQQQQ4B4gASgCgAFBgICAgHhGDQAgAUGYAWoQzAwgAUGAAWoiABDFJyAAQQRBDBDgHiABKAKUASIDBEAgASgCkAEhBgNAIAYQpR4gBkHEAGohBiADQQFrIgMNAAsLIAFBjAFqQQRBxAAQ4B4gASgCrAEiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUGsAWoQ+x4LIA0EQCABQdwAaiIAEMUnIABBBEEMEOAeCyABQegAaiIAEIEjIABBBEEIEOAeIAFB9ABqIgAQgSMgAEEEQQgQ4B4gASgCxAEhACABKALIASIBKAIAIgMEQCAAIAMRAwALIAEoAgQiAwRAIAAgAyABKAIIEPg6CyACQZADaiQADwtBBEEcEKM9AAu8FAEJfiAAIAEpAwAiBUJ/hSIHIAIpAwAiCSABKQMIIgQgA62FIgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCAGQtii0e/CqeW/LX6FIgggAikDGCIKhSIEQtii0e/CqeW/LX4gBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhYUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEIARC2KLR78Kp5b8tfoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH4iBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhCAEIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQiBn6FIASJNwMYIAAgAikDCCILIAggAikDECIMhSIEQtii0e/CqeW/LX4gBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhYUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIARC2KLR78Kp5b8tfoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCAHfiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAQgBn6FIASJNwMQIAAgCiAIIAuFIgRC2KLR78Kp5b8tfiAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEQtKBqpur+oLXp39+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFhSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEQtKBqpur+oLXp39+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgBELYotHvwqnlvy1+hSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAd+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgBCAGfoUgBIk3AwggACAMIAggCYUiBELYotHvwqnlvy1+IARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhIWFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhCAEQtii0e/CqeW/LX6FIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgB34iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhCAEIAZ+hSAEiTcDAAv2XwIMfwF+IwBBQGoiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwiBREEACIELQAAQQJrDiUBAgMEBQYHCAkKCwAAAAAADA0AAAAAAAAAAAAAAAAAAAAODxARAAsgASAFEQQAIgQtAAAOKRgZOjo6Ojo6Ojo6OjoaGxwdHjo6HyAhIiMkJSY6Jyg6KSo0Ojo6Ois1OgsgASACELsiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNPCABIAQ2AgggASADNgIEIAEgAjYCACAAQfCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgASACEKgiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOyABIAQ2AgggASADNgIEIAEgAjYCACAAQbCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgASACELEiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOiABIAQ2AgggASADNgIEIAEgAjYCACAAQfCNgQE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgASACEKQiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOSABIAQ2AgggASADNgIEIAEgAjYCACAAQZCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgASACEKoiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOCABIAQ2AgggASADNgIEIAEgAjYCACAAQbCPgQE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgASACEK0iIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNyABIAQ2AgggASADNgIEIAEgAjYCACAAQeCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgASACELciIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNiABIAQ2AgggASADNgIEIAEgAjYCACAAQfCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMNAsgASACEKIiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNSABIAQ2AgggASADNgIEIAEgAjYCACAAQZCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgASACELkiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNCABIAQ2AgggASADNgIEIAEgAjYCACAAQfCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgASACELUiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNMyABIAQ2AgggASADNgIEIAEgAjYCACAAQYCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMMQsgASACEKYiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNMiABIAQ2AgggASADNgIEIAEgAjYCACAAQYCNgQE2AgggACABNgIEIABBk4CAgHg2AgAMMAsgBC0AAUEBaw4DBgcIBQsgBC0AAUEBaw4CCQoICyABIAIQpyIiAhDNICEEAn8jAEEwayIBJAAgAi0AAEEjRgRAIAItAAIgAUEwaiQADAELIAFBATYCECABQZSH/wA2AgwgAUIBNwIYIAFBpwQ2AiggASACNgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakGch/8AEO8sAAshBSADKAIsIQYgAygCKCEDQRBBBBCtNiIBRQ0uIAEgBToADSABIAQ6AAwgASAGNgIIIAEgAzYCBCABIAI2AgAgAEHQjYEBNgIIIAAgATYCBCAAQZOAgIB4NgIADC0LIAEgAhCrIiICENAgIQQCfyMAQTBrIgEkACACLQAAQSRGBEAgAi0AAiABQTBqJAAMAQsgAUEBNgIQIAFBnIX/ADYCDCABQgE3AhggAUGnBDYCKCABIAI2AiwgASABQSRqNgIUIAEgAUEsajYCJCABQQxqQaSF/wAQ7ywACyEFIAMoAiwhBiADKAIoIQNBEEEEEK02IgFFDS0gASAFOgANIAEgBDoADCABIAY2AgggASADNgIEIAEgAjYCACAAQeCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMLAsgASACELwiIgIQziAhBAJ/IwBBMGsiASQAIAItAABBJUYEQCACLQACIAFBMGokAAwBCyABQQE2AhAgAUGYhv8ANgIMIAFCATcCGCABQacENgIoIAEgAjYCLCABIAFBJGo2AhQgASABQSxqNgIkIAFBDGpBoIb/ABDvLAALIQUgAygCLCEGIAMoAighA0EQQQQQrTYiAUUNLCABIAU6AA0gASAEOgAMIAEgBjYCCCABIAM2AgQgASACNgIAIABB0JKBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwrCyABIAIQqSIiAhDPICEEAn8jAEEwayIBJAAgAi0AAEEmRgRAIAItAAIgAUEwaiQADAELIAFBATYCECABQZCI/wA2AgwgAUIBNwIYIAFBpwQ2AiggASACNgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakGYiP8AEO8sAAshBSADKAIsIQYgAygCKCEDQRBBBBCtNiIBRQ0rIAEgBToADSABIAQ6AAwgASAGNgIIIAEgAzYCBCABIAI2AgAgAEHQj4EBNgIIIAAgATYCBCAAQZOAgIB4NgIADCoLIAEgAhCzIiECIAMoAiwhBCADKAIoIQUgAy0AMSEDQRBBBBCtNiIBRQ0qIAEgAzoADCABIAQ2AgggASAFNgIEIAEgAjYCACAAQeCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMKQsgASACEKEiIQIgAygCLCEEIAMoAighBSADLQAxIQNBEEEEEK02IgFFDSkgASADOgAMIAEgBDYCCCABIAU2AgQgASACNgIAIABBkI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwoCyABIAIQnSIhAiADKAIsIQQgAygCKCEFIAMtADEhA0EQQQQQrTYiAUUNKCABIAM6AAwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGQk4EBNgIIIAAgATYCBCAAQZOAgIB4NgIADCcLIAEgAhCuIiECIAMoAiwhBCADKAIoIQUgAy0AMSEDQRBBBBCtNiIBRQ0nIAEgAzoADCABIAQ2AgggASAFNgIEIAEgAjYCACAAQZCQgQE2AgggACABNgIEIABBk4CAgHg2AgAMJgsgASACELgiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJyABIAQ2AgggASADNgIEIAEgAjYCACAAQcCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMJQsgASACEKMiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJiABIAQ2AgggASADNgIEIAEgAjYCACAAQdCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMJAsgASACEKAiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJSABIAQ2AgggASADNgIEIAEgAjYCACAAQfCPgQE2AgggACABNgIEIABBk4CAgHg2AgAMIwsjAEEgayIEJAAgBEEIaiABIAIoAhARAAAgBEEQaiAEKAIIIgIgBCgCDCgCDBEAAAJAIAIEQCAEKQMQQpC+kouvm5r/BoUgBCkDGELvzbTtqOGJ4U2FhFANAQtB9PuFAUE3Qaz8hQEQyyQACyAEQSBqJAAgAygCLCEEIAMoAighA0EUQQQQrTYiAUUNJSABIAQ2AhAgASADNgIMIAEgAjYCCCABIAQ2AgQgASADNgIAIABB4JCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiAiAEKAIMKAIMEQAAAkAgAgRAIAQpAxBCiqLN5aLCqolqhSAEKQMYQouy+d7NmrveOYWEUA0BC0GU+4UBQSJBuPuFARDLJAALIARBIGokACADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0jIAEgBDYCCCABIAM2AgQgASACNgIAIABB8JCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAELQABQQFrDgMSExQRCyABIAIQpSIhAiADKAIsIQQgAygCKCEFIAMoAgQhBiADKAIAIQNBFEEEEK02IgFFDSIgASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQcCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMHwsgASACELAiIQIgAygCLCEEIAMoAighBSADKAIMIQYgAygCCCEDQRRBBBCtNiIBRQ0hIAEgBjYCECABIAM2AgwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGwkYEBNgIIIAAgATYCBCAAQZOAgIB4NgIADB4LIAQtAAEOAhITHAsgBC0AAUECaw4CExQbCyABIAIQlyIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0dIAEgBDYCCCABIAM2AgQgASACNgIAIABBoI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwbCyAIIAEgAigCEBEAACAIQSBqIAgoAgAiAiAIKAIEKAIMEQAAIAJFDRUgCCkDIELA47Xe0v6llSyFIAgpAyhC9c6oqNH+2sykf4WEUEUNFSADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0cIAEgBDYCCCABIAM2AgQgASACNgIAIABBsJOBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwaCyABIAIQliIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0bIAEgBDYCCCABIAM2AgQgASACNgIAIABBsI6BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwZCyABIAIQiyIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0aIAEgBDYCCCABIAM2AgQgASACNgIAIABBwI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwYCyABIAIQmSIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0ZIAEgBDYCCCABIAM2AgQgASACNgIAIABBsJCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwXCyABIAIQmCIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0YIAEgBDYCCCABIAM2AgQgASACNgIAIABBoI6BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwWCyABIAIQjCIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0XIAEgBDYCCCABIAM2AgQgASACNgIAIABBsI2BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwVCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiBSAEKAIMKAIMEQAAAkAgBQRAIAQpAxBC++Ty4bGz7cN8hSAEKQMYQoG3yp62q+3MboWEUA0BC0Hu1oABQSBBkNeAARDLJAALIARBIGokACMAQSBrIgEkACABQQxqIAUoAgwgBSgCECICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEEIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAENgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNGCACIAc2AhAgAiADNgIMIAIgBTYCCCACIAQ2AgQgAiAGNgIAIABBwJKBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADBQLIAhBCGogASACKAIQEQAAIAhBIGogCCgCCCIHIAgoAgwoAgwRAAAgB0UNDyAIKQMgQv/Z66rX2IuM8QCFIAgpAyhCgfTho6r41uqLf4WEUEUNDyMAQTBrIgQkACAEIAc2AgQgBEEYaiEGIwBBIGsiBSQAIAVBDGogBEEEaigCACIJKAIMIAkoAhAiASgCCEEBa0F4cWpBCGogASADENsBIAUoAhQhASAFKAIQIQICfyAFKAIMIgtBk4CAgHhHBEAgBiAFKQIYNwIMIAIMAQsgBiABNgIMIAIhASAJKAIsCyECIAYgATYCCCAGIAI2AgQgBiALNgIAIAVBIGokACAEQRBqIgEgBEEkaigCADYCACAEIAQpAhw3AwgCQAJAAkAgBCgCGCICQZOAgIB4RwRAIAQoAighAyAAIAQpAwg3AgQgACADNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAMAQsgBEEgaiICIAEoAgA2AgAgBCAEKQMINwMYIAMoAiwhBSADKAIoIQNBGEEEEK02IgFFDQEgASAFNgIIIAEgAzYCBCABIAc2AgAgASAEKQMYNwIMIAFBFGogAigCADYCACAAQcCQgQE2AgggACABNgIEIABBk4CAgHg2AgALIARBMGokAAwBC0EEQRgQoz0ACwwTCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiBSAEKAIMKAIMEQAAAkAgBQRAIAQpAxBC4//bxtnAsr/aAIUgBCkDGELrqof3kZGQlSSFhFANAQtB7taAAUEgQZDXgAEQyyQACyAEQSBqJAAjAEEgayIBJAAgAUEMaiAFKAIMIAUoAhAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBCABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBDYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDRYgAiAHNgIQIAIgAzYCDCACIAU2AgggAiAENgIEIAIgBjYCACAAQdCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwSCyABIAIQxSIhDSMAQTBrIgQkACAEIA02AgQgBEEYaiEHIwBBMGsiBSQAAkAgBEEEaigCACIBLQAMQSBGBEAgBUEIaiABENw7IAUoAgghBiAFKAIMIQkgBSABQRBqEK8uIAVBFGoiAiAGIAYgCUEDdGogBSgCACAFKAIEEMgiIAUgAzYCLCMAQUBqIgEkACABQZOAgIB4NgIAIAFBOGogAkEYaigCADYCACABQTBqIAJBEGopAgA3AwAgAUEoaiACQQhqKQIANwMAIAEgAikCADcDICABIAE2AjwgAUEUaiELIwBBQGoiAiQAIAJBEGogAUEgaiIGEIcgAkACQAJAIAIoAhAEQCACQSBqIgxBBEEAQQRBEBCgGCACKAIkIQkgAigCIEEBRg0CIAIoAigiCiACKQIQNwIAIApBCGogAkEYaikCADcCACACQQxqIg5BATYCACACIAo2AgggAiAJNgIEIAJBOGogBkEYaikCADcDACACQTBqIAZBEGopAgA3AwAgAkEoaiAGQQhqKQIANwMAIAIgBikCADcDICMAQRBrIgYkACAGIAwQhyAgBigCAARAIAJBBGohCQNAIAkoAggiCiAJKAIARgRAIAkgCkEBQQRBEBDeKAsgCSgCBCAKQQR0aiIPIAYpAgA3AgAgD0EIaiAGQQhqKQIANwIAIAkgCkEBajYCCCAGIAwQhyAgBigCAA0ACwsgBkEQaiQAIAtBCGogDigCADYCACALIAIpAgQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyACQUBrJAAMAQsgCSACKAIoQbi1gAEQ/S8ACwJAIAEoAgBBk4CAgHhHBEAgByABKQIANwIAIAdBEGogAUEQaigCADYCACAHQQhqIAFBCGopAgA3AgAgASgCHCICBEAgASgCGCEGA0AgBhDOKiAGQRBqIQYgAkEBayICDQALCyABQRRqQQRBEBDgHgwBCyAHIAEpAhQ3AgQgB0GTgICAeDYCACAHQQxqIAFBHGooAgA2AgALIAFBQGskACAFQTBqJAAMAQtBpO2AAUEoQZD0gAEQnykACyAEQRBqIgEgBEEkaigCADYCACAEIAQpAhw3AwgCQAJAAkAgBCgCGCICQZOAgIB4RwRAIAQoAighAyAAIAQpAwg3AgQgACADNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAMAQsgBEEgaiICIAEoAgA2AgAgBCAEKQMINwMYIAMoAiwhBSADKAIoIQNBGEEEEK02IgFFDQEgASAEKQMYNwIAIAEgBTYCFCABIAM2AhAgASANNgIMIAFBCGogAigCADYCACAAQaCQgQE2AgggACABNgIEIABBk4CAgHg2AgALIARBMGokAAwBC0EEQRgQoz0ACwwRCyABIAIQxiIhCyMAQTBrIgIkACACIAs2AgQgAkEYaiEFIwBBMGsiASQAAkACQAJAIAJBBGooAgAiCS0ADEEhRgRAIAFBCGogCUEQaiINELAuIAFBEGogASgCCCIHIAEoAgwiCkYEf0EBBSAHLQAAIQQjAEEQayIGJAAgCiAHQQhqIgdHBEAgCiAHa0EDdiEKA0AgBiAHLQAAIgw6AA4gBiAEOgANIAQgDCAGQQ5qLAAAIgQgBkENaiwAACIMSiAEIAxIa8BBAEgbIQQgB0EIaiEHIApBAWsiCg0ACwsgBkEQaiQAIATAQQFqC0Gg84ABEKIaIAEgDRCwLiABKAIAIgQgASgCBCIHRg0CA0AgAUEcaiAJIAQsAAAiBhDZKCIKKAIAIAooAgQiCigCCEEBa0F4cWpBCGogCiADENsBIAEoAhwiCkGTgICAeEcEQCABKQIgIRAgBSABKQIoNwIMIAUgEDcCBCAFIAo2AgAgASgCGCIEBEAgASgCFCEGA0AgBigCAARAIAYQzioLIAZBEGohBiAEQQFrIgQNAAsLIAFBEGpBBEEQEOAeDAULIAEoAhgiCiAGTQ0CIAEoAiQhCiABKAIgIQ0gBEEEaigCACIMKAJEIQ4gDCgCQCEMIAEoAhQgBkEEdGoiBigCAARAIAZBCGoQvCoLIAYgCjYCDCAGIA02AgggBiAONgIEIAYgDDYCACAEQQhqIgQgB0cNAAsMAgtBpO2AAUEoQYj1gAEQnykACyAGIApB+PSAARDDIQALIAUgASkCEDcCBCAFQZOAgIB4NgIAIAUgCS0ADToAECAFQQxqIAFBGGooAgA2AgALIAFBMGokACACQRBqIgEgAkEkaikCADcDACACIAIpAhw3AwgCQCACKAIYIgRBk4CAgHhHBEAgACACKQMINwIEIAAgBDYCACAAQQxqIAEpAwA3AgAMAQsgAkEgaiIEIAEpAwA3AwAgAiACKQMINwMYIAMoAiwhBSADKAIoIQNBHEEEEK02IgFFDRUgASACKQMYNwIAIAEgBTYCGCABIAM2AhQgASALNgIQIAFBCGogBCkDADcCACAAQaCMgQE2AgggACABNgIEIABBk4CAgHg2AgALIAJBMGokAAwQCyABIAIQxyIhByMAQTBrIgEkACABIAc2AgQgAUEYaiEEIwBBIGsiAiQAIAJBDGogAUEEaigCACIJEPMvIgUoAgAgBSgCBCIFKAIIQQFrQXhxakEIaiAFIAMQ2wEgAigCFCEFIAIoAhAhBgJAIAIoAgwiC0GTgICAeEcEQCAEIAIpAhg3AgwgBCAFNgIIIAQgBjYCBCAEIAs2AgAMAQsgAiAFNgIIIAIgBjYCBCACQQxqIAkQ8i0iCSgCACAJKAIEIgkoAghBAWtBeHFqQQhqIAkgAxDbASACKAIUIQkgAigCECELIAIoAgwiCkGTgICAeEcEQCAEIAIpAhg3AgwgBCAJNgIIIAQgCzYCBCAEIAo2AgAgAkEEahC8KgwBCyAEIAk2AhAgBCALNgIMIAQgBTYCCCAEIAY2AgQgBEGTgICAeDYCAAsgAkEgaiQAIAFBEGoiAiABQSRqKQIANwMAIAEgASkCHDcDCAJAIAEoAhgiBEGTgICAeEcEQCAAIAEpAwg3AgQgACAENgIAIABBDGogAikDADcCAAwBCyABQSBqIgQgAikDADcDACABIAEpAwg3AxggAygCLCEFIAMoAighA0EcQQQQrTYiAkUNFCACIAEpAxg3AgAgAiAFNgIYIAIgAzYCFCACIAc2AhAgAkEIaiAEKQMANwIAIABBwJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEwaiQADA8LIAEgAhCfIiEEIwBBMGsiASQAIAEgBDYCBCABQRhqIAFBBGogAxCZGCABQRBqIgIgAUEkaikCADcDACABIAEpAhw3AwgCQCABKAIYIgVBk4CAgHhHBEAgACABKQMINwIEIAAgBTYCACAAQQxqIAIpAwA3AgAMAQsgAUEgaiIFIAIpAwA3AwAgASABKQMINwMYIAMoAiwhBiADKAIoIQNBHEEEEK02IgJFDRMgAiABKQMYNwIAIAIgBjYCGCACIAM2AhQgAiAENgIQIAJBCGogBSkDADcCACAAQZCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBMGokAAwOCyABIAIQtCIhBCMAQTBrIgEkACABIAQ2AgQgAUEYaiABQQRqIAMQmRggAUEQaiICIAFBJGopAgA3AwAgASABKQIcNwMIAkAgASgCGCIFQZOAgIB4RwRAIAAgASkDCDcCBCAAIAU2AgAgAEEMaiACKQMANwIADAELIAFBIGoiBSACKQMANwMAIAEgASkDCDcDGCADKAIsIQYgAygCKCEDQRxBBBCtNiICRQ0SIAIgASkDGDcCACACIAY2AhggAiADNgIUIAIgBDYCECACQQhqIAUpAwA3AgAgAEGAkIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQTBqJAAMDQsgASACELIiIQQjAEEwayIBJAAgASAENgIEIAFBGGogAUEEaiADEJkYIAFBEGoiAiABQSRqKQIANwMAIAEgASkCHDcDCAJAIAEoAhgiBUGTgICAeEcEQCAAIAEpAwg3AgQgACAFNgIAIABBDGogAikDADcCAAwBCyABQSBqIgUgAikDADcDACABIAEpAwg3AxggAygCLCEGIAMoAighA0EcQQQQrTYiAkUNESACIAEpAxg3AgAgAiAGNgIYIAIgAzYCFCACIAQ2AhAgAkEIaiAFKQMANwIAIABBgI+BATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEwaiQADAwLIAEgAhCsIiEEIwBBMGsiASQAIAEgBDYCBCABQRhqIAFBBGogAxCZGCABQRBqIgIgAUEkaikCADcDACABIAEpAhw3AwgCQCABKAIYIgVBk4CAgHhHBEAgACABKQMINwIEIAAgBTYCACAAQQxqIAIpAwA3AgAMAQsgAUEgaiIFIAIpAwA3AwAgASABKQMINwMYIAMoAiwhBiADKAIoIQNBHEEEEK02IgJFDRAgAiABKQMYNwIAIAIgBjYCGCACIAM2AhQgAiAENgIQIAJBCGogBSkDADcCACAAQaCTgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBMGokAAwLCyABIAIQniIhAiADKAIsIQQgAygCKCEFIAMoAiQhBiADKAIgIQNBFEEEEK02IgFFDQ0gASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQaCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMCgsgASACELYiIQIgAygCLCEEIAMoAighBSADKAIkIQYgAygCICEDQRRBBBCtNiIBRQ0MIAEgBjYCECABIAM2AgwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGAkoEBNgIIIAAgATYCBCAAQZOAgIB4NgIADAkLIAEgAhCvIiECIAMoAiwhBCADKAIoIQUgAygCJCEGIAMoAiAhA0EUQQQQrTYiAUUNCyABIAY2AhAgASADNgIMIAEgBDYCCCABIAU2AgQgASACNgIAIABBkI2BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwICyABIAIQuiIhAiADKAIsIQQgAygCKCEFIAMoAiQhBiADKAIgIQNBFEEEEK02IgFFDQogASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQbCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMBwsgASAFEQQAIgQtAABBIkYNBEHwgoEBQShB7IqBARCfKQALIAEgBREEACIELQAAQShGDQJB8IKBAUEoQeCLgQEQnykAC0HoiYEBELI7AAtB+ImBARCyOwALAkACQAJAAkAgBCgCBCIELQAwQQNrDgMBAgMACyAIIARBMGo2AjggCEEBNgIkIAhByIuBATYCICAIQgE3AiwgCEGnBDYCGCAIIAhBFGo2AiggCCAIQThqNgIUIAhBIGpB0IuBARDvLAALIAEgAhCcIiEEIwBBIGsiASQAIAFBDGogBCgCICAEKAIkIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0IIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHgjYEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMBAsgASACEJoiIQQjAEEgayIBJAAgAUEMaiAEKAIgIAQoAiQiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQcgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQeCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwDCyABIAIQmyIhBCMAQSBrIgEkACABQQxqIAQoAiAgBCgCJCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNBiACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBgJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAILAkACQAJAAkACQAJAAkACQAJAIAQoAgQiBC0AAEECaw4IAQIDBAUGBwgACyAIIAQ2AjggCEEBNgIkIAhB1IqBATYCICAIQgE3AiwgCEGnBDYCGCAIIAhBFGo2AiggCCAIQThqNgIUIAhBIGpB3IqBARDvLAALIAEgAhDEIiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0MIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHQkIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMCAsgASACEMEiIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQsgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQfCMgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwHCyABIAIQwCIhBCMAQSBrIgEkACABQQxqIAQoAjwgBCgCQCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNCiACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBoJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAYLIAEgAhDDIiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0JIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHQkYEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMBQsgASACEMIiIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQggAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQeCPgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwECyABIAIQvyIhBCMAQSBrIgEkACABQQxqIAQoAjwgBCgCQCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNByACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBwI2BATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAMLIAEgAhC+IiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0GIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEGAk4EBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMAgsgASACEL0iIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQUgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQaCNgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwBCyAIIAQ2AhAgCEECNgIkIAhBkIyBATYCICAIQgE3AiwgCEGnBDYCPCAIIAhBOGo2AiggCCAIQRBqNgI4IAhBFGohAyMAQRBrIgEkACAIQSBqIgIoAgwhBAJAAkACQAJAAkACQAJAIAIoAgQOAgABAgsgBA0BQQEhBEEAIQIMAgsgBA0AIAIoAgAiBCgCBCECIAQoAgAhBAwBCyADIAIQmQ4MAQsgAUEEaiACQQBBAUEBEKAYIAEoAgghBSABKAIEQQFGDQEgASgCDCEGIAIEQCAGIAQgAvwKAAALIAMgAjYCCCADIAY2AgQgAyAFNgIACyABQRBqJAAMAQsgBSABKAIMQbiHgQEQ/S8ACyAAQYCAgIB4NgIAIAAgCCkCFDcCBCAAQQxqIAhBHGooAgA2AgALIAhBQGskAA8LQQRBEBCjPQALQQRBDBCjPQALQQRBFBCjPQALQQRBHBCjPQAL1xUBEH8jAEHAB2siAiQAIAJBmANqIAEoAgwiAyABKAIQIgYoAhgRAAAgAigCoAMhBCACKAKcAyEFAkACQAJAIAIoApgDIgdBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAENgIIIAAgBTYCBCAAIAc2AgAMAQsgAiAENgIgIAIgBTYCHAJAAkACQCACQRxqEPUtRQRAIAJBEGogAyAGKAIgEQAAIAIoAhAiBw0CIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRw0BDAULIAIgARCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAgsgAigCoAMiAUEYakGc1NAAKQAANwAAIAFBEGpBlNTQACkAADcAACABQQhqQYzU0AApAAA3AAAgAUGE1NAAKQAANwAAIABBIDYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACKAIUIQUgAkEIaiADIAYoAiQRAAAgAigCCCIMRQRAIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRg0DIAIoAqADIgFBGGpBvNTQACkAADcAACABQRBqQbTU0AApAAA3AAAgAUEIakGs1NAAKQAANwAAIAFBpNTQACkAADcAACAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAMAQsgAigCDCEEAkAgAkEcahD0LUEATgRAIARFDQEgDC8BAEUNASACQZgDakEpQQBBAUEBEKAYIAIoApwDIQEgAigCmANBAUYNBSACKAKgAyIDQYjR0ABBKfwKAAAgAEEpNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAILIAJBHGoQ9C0hASACQTs2AowBIAIgATYC0AUgAkECNgKcAyACQZzT0AA2ApgDIAJCATcCpAMgAiACQdAFajYCiAEgAiACQYgBajYCoAMgAEEEaiACQZgDahCZDiAAQQA2AgAMAQsgAkGYA2ogAkEcahD0LUEBakEAQQRBBBCgGCACKAKcAyEDAkACQAJAAkACQAJAAkACQCACKAKYA0EBRwRAIAJBADYCLCACIAIoAqADNgIoIAIgAzYCJAJAIAEtABhFBEAgAkEANgIwDAELQcAAIQYgAkEcahD0LSIDQQN2IANBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0ECyACQgA3AjwgAiAGNgI4IAIgAzYCNCACQcAANgIwCyACQcQAaiIGIAJBHGoiDRDDLUEEQQQQrTYiA0UNAyACQQE2AqADIAIgAzYCnAMgAkEBNgKYAyADIAY2AgBBACEGIAJBiAFqIAJBmANqQQAgDRD0LRDALCAEIAUgBCAFSRsiDUUEQEEAIQRBACEDDAYLIAEvARbBIRBBACEDQQAhBAJAA0ACQAJAAkACQCAMLgEAIgUgEEogBSAQSGtB/wFxDgICAQALIANBAEgNCSACKAIsIgUgAigCJEYEQCACQSRqQdTU0AAQnSgLIAIoAiggBUECdGogAzYCACACIAVBAWo2AiwgBy4BACIIIAEuARQiEUgEQCAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLAkAgAigCMEUNACACKAJAIglBAWoiCkEDdiAKQQdxQQBHaiIFIAIoAjwiBEsEQCAFIARrIQsgAigCNCIPIAVJBEAgAkEwaiAPQQF0IgQgBUHA////A3FBQGsgBSAFQT9xGyIPIAQgD0sbEOgZIAIoAjwhBAsgCwRAIAIoAjggBGpBACAL/AsACyACIAU2AjwLIAIgCjYCQCAIQQFqQf//A3EgEUH//wNxRw0AIAIoAjggCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAACyAGQQFqIQZBACEEDAMLIA4gAyAGaiAEGyEOIANBAWohAyACKAIwRQRAQQEhBAwDCyACKAJAIglBAWoiCkEDdiAKQQdxQQBHaiIFIAIoAjwiBEsEQCAFIARrIQsgAigCNCIIIAVJBEAgAkEwaiAIQQF0IgQgBUHA////A3FBQGsgBSAFQT9xGyIIIAQgCEsbEOgZIAIoAjwhBAsgCwRAIAIoAjggBGpBACAL/AsACyACIAU2AjwLIAIgCjYCQEEBIQQgAigCOCAJQQN2aiIFIAUtAABBASAJQQdxdHI6AAAMAgsgBy4BACABLgEUTg0BIAJBmANqQTtBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRw0DDBALIANBAWohAwsgB0ECaiEHIAxBAmohDCANQQFrIg0NAAsgA0EATg0GQcTR0AAQsjsACyACKAKgAyIDQeTU0ABBO/wKAAAgAEE7NgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAYLIAMgAigCoANBtNHQABD9LwALQZSf0ABBKSACQZgDakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAtBxNTQABCyOwALIAIoAiwiBSACKAIkRgRAIAJBJGpB1NHQABCdKAsgAigCKCAFQQJ0aiADNgIAIAIgBUEBajYCLAJAIAZFBEAgAkHUAmogAkEcahDDLQwBCyAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLIAJBmANqIgQgAkGIAWpBzAH8CgAAIAJB1AJqIAQQ6iwLIAIoAvgCIANGBEAgAkHoBGoiAyACKAIoIAIoAixBAnQQiz0gAkG4A2ogARDEBiACQQA7AfADIAJBADYC7AMgAkEANgLUAyACQQA2AsgDIAJCBDcCsAMgAkIANwKoAyACQoCAgIDAADcCoAMgAkEANgKYAyACIAIoAixBAWs2AsQDIAJB0AVqIgQgAkGYA2oiASADEPojIAEgAkHUAmpBxAD8CgAAIAJB9ARqIAQgARDvJSACKAIwRQ0DIAIgAigCQCIDNgKwBiACIAIoAixBAWsiBDYCtAYgAyAERwRAIAJBADYCmANBACACQbAGaiACQbQGaiABQeTR0AAQrysACyACQZgDaiIBIAJB9ARqIgRB3AD8CgAAIAJB2AVqIAJBOGopAgA3AwAgAiACKQIwNwPQBSACIAM2AuAFIAJBuAZqIgMgAkHQBWoQiBkgBCABIAMQrhYMAwsgAEEEaiEDIwBBEGsiASQAIAFBBGpBKkEAQQFBARCgGCABKAIIIQQCQCABKAIEQQFHBEAgASgCDCIFQczS0ABBKvwKAAAgA0EqNgIIIAMgBTYCBCADIAQ2AgAgAUEQaiQADAELIAQgASgCDEGkxtAAEP0vAAsgAEEANgIAIAJB1AJqEPomIAYNAQsgAkGIAWoQlxcLIAJBxABqEPomIAIoAjAEQCACQTBqEM8vCyACQSRqEOk7DAELIAJBmANqIgEgAkH0BGpB3AD8CgAAIAJBxAZqIgMgARDNHCACQYgHaiIBIAMQrx8gARDmKSEBIABB9NHQADYCCCAAIAE2AgQgAEEINgIAIAZFBEAgAkGIAWoQlxcLIAJBxABqEPomIAJBJGoQ6TsgAigCHCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEcahC7IwwBCyACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNACACQRxqELsjCyACQcAHaiQADwsgAyACKAKgA0GkxtAAEP0vAAsgASACKAKgA0GkxtAAEP0vAAutFgILfwN+IwBBkAhrIgIkAAJAAkACQCABKQMAIg1CAlINACACQcQEaiEGIAJBqAJqIQggAkGQAmohBCACQYgFaiEJIAJB8ARqIQMgAkHgBGpBBHIhBwJAAkACQANAIAEpAxBQBEAgAEIMNwMADAcLIAJB4ARqIAEoAkBBCGogASkDCBDhMCAEIAdBCGopAgA3AwAgAiAHKQIANwOIAiACKALgBCIFQQhHBEAgAigC9AQhASAAIAIpA4gCNwIMIAAgATYCHCAAIAU2AgggAEINNwMAIABBFGogAkGQAmopAwA3AgAMBwsgAkHABGogBCkDADcDACACIAIpA4gCNwO4BCABKAIYIQUgAUEANgIYAkAgBQRAIAIgBUGIAvwKAAAgBUGIAkEIEPg6IAEpAxAhDQwBCyACQeAEaiIKIAJBuARqIAEoAhwgAS0AIBDxEyACKQPoBCINQgRSBEAgAkGIB2oiCyADQQhqKQMANwMAIAJBkAdqIgwgA0EQaikDADcDACACIAMpAwA3A4AHIAIoAuAEIQUgCCAJQegB/AoAACAEQRBqIAwpAwA3AwAgBEEIaiALKQMANwMAIAQgAikDgAc3AwAgAiANNwOIAiAKIAUgASkDEBCOGiACKALgBCIKQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgCjYCCCACQYgCahD8LAwECyABIAWtIg0gASkDCHw3AwggASABKQMQIA19Ig03AxAgAiACQYgCakGIAvwKAAAMAQsgAkGQB2ogA0EQaikDACINNwMAIAJBiAdqIANBCGopAwAiDjcDACACIAMpAwAiDzcDgAcgAEEYaiANNwMAIABBEGogDjcDACAAIA83AwggAEINNwMADAILIAJB4ARqIAIoAvwBIAIoAvgBIA0QhRkgAigC4AQiBUEIRwRAIAAgAikC5AQ3AgwgAEEcaiACQfQEaigCADYCACAAQRRqIAJB7ARqKQIANwIAIABCDTcDACAAIAU2AgggAhD8LAwCCyABIAIoAvwBIgWtIg0gASkDCHw3AwggASABKQMQIA19NwMQIAIgBTYClAQgAigC9AFBAUYEQCACEPwsIAYgAigCvAQgAigCwAQgAigCuAQoAhARAQAgASkDACINQgJSDQUMAQsLIAJB4ARqIgQgBUEAQQFBARCgGCACKALkBCEDIAIoAuAEQQFGDQEgAkEANgKgBCACIAIoAugENgKcBCACIAM2ApgEIAJB6ARqIAJBwARqKQMANwMAIAIgAikDuAQ3A+AEIAIgDTcD+AQgAiANNwPwBCACQYgCaiAEIAJBmARqENMHAkACQCACAn8gAi0AiAJBBEYEQCACKAKMAgwBCyACKQOIAiINQv8Bg0IEUg0BIA1CIIinCyIDNgKkBCACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBACADIAVHBEAgAkECNgLkBCACQYDMwwA2AuAEIAJCAjcC7AQgAkE7NgKUAiACQTs2AowCIAIgAkGIAmo2AugEIAIgAkGkBGo2ApACIAIgAkGUBGo2AogCIABBDGogAkHgBGoQmQ4gAEINNwMAIABBAjYCCAwCCyACQbAEaiACQaAEaigCADYCACACIAIpApgENwOoBCACQeAEaiIDIAJBiAL8CgAAIAJByARqIgQgAkGoBGoQ5xUgAkGIAmogAyAEIAEtAEQgAUE4akEAIAEoAjgbEK4BIAJBiAdqIgQgAkGYAmopAwA3AwAgAkGQB2oiAyACQaACaikDADcDACACIAIpA5ACNwOAByACKQOIAiINQgxSBEAgAkGwB2ogAkGoAmpB4AD8CgAAIAJBoAdqIAQpAwA3AwAgAkGoB2ogAykDADcDACACIAIpA4AHNwOYByANQglUDQUgDadBCWsiA0ECSQ0FIANBAkcNByABQQA6ACAMBwsgACACKQOABzcDCCAAQg03AwAgAEEYaiADKQMANwMAIABBEGogAkGIB2opAwA3AwAMBwsgAiANNwOIAiAAQQhqIAJBiAJqEIErIABCDTcDACACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBAAsgAkGYBGoQ3jsgAhD8LAwFCyAGIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAQLIAMgAigC6ARBxMvDABD9LwALIAEgASgCHEEBajYCHAwBCyABQgA3AwACQAJ+IA2nIgVBAXEEQCABKAIYIQMgASkDCAwBCyACQeAEaiABQSBqEOEcIAIoAuAEQQFHDQEgAigC+AQhAyACKQPoBAshDSADQQBIBEAgAEEIahDbJCAAQg03AwAMAwsgAkHgBGogASgCQEEIaiANIAMQzy4gAkGQAmoiAyACQewEaikCADcDACACIAIpAuQENwOIAiACKALgBCIEQQhHBEAgAigC9AQhASAAIAIpA4gCNwIMIAAgATYCHCAAIAQ2AgggAEINNwMAIABBFGogAykDADcCAAwDCyACQcAEaiADKQMAIg03AwAgAiACKQOIAjcDuAQgAkHgBGohBCACKAK8BCEGIAEoAjQaIAVBAXEhBSMAQbACayIDJAAgA0IANwMIIAMgDaciBzYCBCADIAY2AgAgA0EoaiADEI8UIANBGGoiCCADQThqKQMANwMAIANBIGoiCSADQUBrKQMANwMAIAMgAykDMDcDEAJAIAMpAygiDUIEUQRAIAQgAykDEDcDECAEQgQ3AwggBEEgaiAJKQMANwMAIARBGGogCCkDADcDAAwBCyAEQShqIANByABqQegB/AoAACAEQSBqIANBIGopAwA3AwAgBEEYaiADQRhqKQMANwMAIAQgAykDEDcDECAEIA03AwggBCADKQMIPgIACyADQbACaiQAIAIpA+gEIg1CBFIEQCACQQhqIgMgAkH4BGopAwA3AwAgAkEQaiIEIAJBgAVqKQMANwMAIAIgAikD8AQ3AwAgAigC4AQhBiACQYgCaiACQYgFakHoAfwKAAAgAkHYBGogBCkDADcDACACQdAEaiADKQMANwMAIAIgAikDADcDyAQgAkHwBmogAkG4BGogBhDqFCAFRQRAIAEgASgCNEEBajYCNAsgAkHwBGogAkHQBGopAwA3AwAgAkH4BGogAkHYBGopAwA3AwAgAiANNwPgBCACIAIpA8gENwPoBCACQYAFaiACQYgCakHoAfwKAAAgAiACQeAEaiACQfAGaiABLQBEIAFBOGpBACABKAI4GxCuASACQYgHaiIDIAJBEGopAwA3AwAgAkGQB2oiBCACQRhqKQMANwMAIAIgAikDCDcDgAcgAkHEBGohASACKQMAIg1CDFEEQCAAIAIpA4AHNwMIIABCDTcDACAAQRhqIAQpAwA3AwAgAEEQaiADKQMANwMAIAEgAigCvAQgAigCwAQgAigCuAQoAhARAQAMBAsgAkGwB2ogAkEgakHgAPwKAAAgAkGgB2ogAkGIB2opAwA3AwAgAkGoB2ogAkGQB2opAwA3AwAgAiACKQOABzcDmAcgASACKAK8BCACKALABCACKAK4BCgCEBEBAAwCCyACQRBqIAJBgAVqKQMAIg03AwAgAkEIaiACQfgEaikDACIONwMAIAIgAikD8AQiDzcDACAAQRhqIA03AwAgAEEQaiAONwMAIAAgDzcDCCAAQg03AwAgAkHEBGogBiAHIAIoArgEKAIQEQEADAILIABCDDcDAAwBCyAAIA03AwAgAEEIaiACQZgHakH4APwKAAALIAJBkAhqJAAL0BICA38SfiMAQfADayIGJAAgBiAENwOIAyAGIAM3A4ADIAYgAjcD+AIgBiABNwPwAiAGIAU2ApwDIAACfwJAIAVFBEAgBkGgA2pCAUIAELIuIAYpA7gDIQogBikDsAMhDCAGKQOoAyELIAYpA6ADIRMMAQsgBkGgA2pCAUIAELIuIAYpA7gDIQ4gBikDsAMhDSAGKQOoAyEJIAYpA6ADIRECQCAFQQFHBEADQAJ+AkACQCAFQQFxRQRAIAEgA4QhECACIASEIRIgDSEMIA4hCiARIQsgCSEPDAELQgAhDCABIAOEIhAgAiAEhCIShFAEQEIAIQpCACELQgAhDwwBC0IAIQpCACELQgAhDyANIBGEIAkgDoSEUA0AIA5CP4ciCiANhSIMIA5CP4h8Ig0gCiARhSIPIApUIgcgCSAKhSIQIApUIAlQG60iCX0hCyAMIA1WrSAKIA6FfCAJIA1WrX0hDCAEQj+HIgkgA4UiESAEQj+IfCINIAEgCYUiASAJVCIIIAIgCYUiAyAJVCACUButIgJ9IhIgDSARVK0gBCAJhXwiESACIA1WrX0iFIRQRSALIAyEQgBScQ0FIAZB4AJqIA8gCn0iAkIAIAEgCX0iD0IAEKgeIAZBwAJqIBAgCn0gB619IgpCACAPQgAQqB4gBkHQAmogAkIAIAMgCX0gCK19IhBCABCoHiAGQbACaiAKQgAgEEIAEKgeIAZBgAJqIAxCACAPQgAQqB4gBkGQAmogEEIAIAtCABCoHiAGQaACaiALQgAgD0IAEKgeIAxCAFIgEEIAUnEgBikDiAJCAFJyIAYpA5gCQgBSciAGKQOoAiILIAYpA4ACIAYpA5ACfHwiDyALVHINBSAGKQPAAiEMIAYpA+gCIQsgBikDyAIgBikDsAIhFSAGKQO4AiEWIAYpA9ACIRcgBikD2AIhGCAGKQOgAiEZIAYpA+ACIRogBkHQAWogCkIAIBJCABCoHiAGQeABaiAUQgAgAkIAEKgeIAZB8AFqIAJCACASQgAQqB4gCkIAUiAUQgBScSAGKQPYAUIAUnIgBikD6AFCAFJyIAYpA/gBIgIgBikD0AEgBikD4AF8fCISIAJUcg0FIAsgDHwiAiALVK18IhAgFXwiCiAYIAIgF3wiCyACVK18fCICIBl8IgwgAlQiByAHrSACIApUrSAWIAogEFStfHwiCiAPfHwiAiAKVCACIApRGw0FIAwgDCAGKQPwAXwiDFYiByAHrSACIBJ8fCIKIAJUIAIgClEbDQUgCiAEIA6FIgRCP4ciAoUgAn0gAiAMhSIOIAJUrX0gDiACfSIOIAIgGoUiECACVCIHIAIgC4UiDyACVCALUButIgtUrX0iCiAEhUIAUw0FIA4gC30hDCAPIAJ9IAetfSEPIBAgAn0hCwwBCyAQIBKEUARAQgAhAyALIREgDyEJIAwhDSAKIQ5CACEEQgAhAkIADAILIARCP4ciCSAEhSADIAmFIgMgBEI/iHwiDSADVK18IREgAiAJhSEDIAEgCYUhAQsgDSABIAlUIgcgAyAJVCADIAlRG62FIBGEQgBSDQMgBkHAAWogASAJfSIBQgAgAUIAEKgeIAZBsAFqIAFCACADIAl9IAetfSIBQgAQqB4gBkGgAWogAUIAIAFCABCoHiAGKQOoASAGKQO4ASIEIAYpA8gBIgIgBikDsAEiCXwiASACVK18IgIgBikDoAF8IgMgAlStfCADIAMgBCABIAl8IgIgAVStfHwiA1atfCIEQgBTDQMgCyERIA8hCSAMIQ0gCiEOIAYpA8ABQn2DCyEBIAVBA0sgBUEBdiEFDQALCyANIBGEIAkgDoSEUARAQgAhC0IAIQxCACEKDAILQgAhC0IAIQxCACEKIAEgA4QgAiAEhIRQDQEgAyAEQj+HIgOFIgsgBEI/iHwiCiABIAOFIgwgA1QiBSACIAOFIg8gA1QgAlAbrSIBfSECIAogC1StIAMgBIV8IAEgClatfSEKIA5CP4ciASANhSITIA5CP4h8Ig0gASARhSIQIAFUIgcgASAJhSISIAFUIAlQG60iCX0iCyANIBNUrSABIA6FfCAJIA1WrX0iEYRQRSACIAqEQgBScQ0AIAZBkAFqIAwgA30iCUIAIBAgAX0iDUIAEKgeIAZB8ABqIAlCACASIAF9IAetfSIBQgAQqB4gBkGAAWogDyADfSAFrX0iA0IAIA1CABCoHiAGQeAAaiADQgAgAUIAEKgeIAZBMGogEUIAIAlCABCoHiAGQUBrIANCACALQgAQqB4gBkHQAGogC0IAIAlCABCoHiARQgBSIANCAFJxIAYpAzhCAFJyIAYpA0hCAFJyIAYpA1giAyAGKQMwIAYpA0B8fCILIANUcg0AIAYpA3AhCSAGKQOYASEDIAYpA3ggBikDYCEMIAYpA2ghDyAGKQOAASETIAYpA4gBIRAgBikDUCESIAYpA5ABIRQgBiABQgAgAkIAEKgeIAZBEGogCkIAIA1CABCoHiAGQSBqIA1CACACQgAQqB4gAUIAUiAKQgBScSAGKQMIQgBSciAGKQMYQgBSciAGKQMoIgEgBikDACAGKQMQfHwiDSABVHINACADIAl8IgEgA1StfCIKIAx8IgIgECABIBN8IgMgAVStfHwiASASfCIJIAFUIgUgBa0gASACVK0gDyACIApUrXx8IgIgC3x8IgEgAlQgASACURsNACAJIAkgBikDIHwiCVYiBSAFrSABIA18fCICIAFUIAEgAlEbDQAgAiAEIA6FIgRCP4ciAYUgAX0gASAJhSICIAFUrX0gAiABfSICIAEgFIUiCSABVCIFIAEgA4UiDiABVCADUButIgNUrX0iCiAEhUIAUw0AIAIgA30hDCAOIAF9IAWtfSELIAkgAX0hEwwBCyAGQQI2AqQDIAZB8Mj/ADYCoAMgBkICNwKsAyAGQcINNgLsAyAGQYMMNgLkAyAGIAZB4ANqNgKoAyAGIAZBnANqNgLoAyAGIAZB8AJqNgLgAyAGQdADaiAGQaADahCZDiAGQYiAgIB4NgLMAyAAIAYpAswDNwIEIABBDGogBkHUA2opAgA3AgAgAEEUaiAGQdwDaigCADYCAEEBDAELIAAgDDcDICAAIBM3AxAgACAKNwMoIAAgCzcDGEEACzYCACAGQfADaiQAC9ASAgN/En4jAEHwA2siBiQAIAYgBDcDiAMgBiADNwOAAyAGIAI3A/gCIAYgATcD8AIgBiAFNgKcAyAAAn8CQCAFRQRAIAZBoANqQgFCABCyLiAGKQO4AyEKIAYpA7ADIQwgBikDqAMhCyAGKQOgAyETDAELIAZBoANqQgFCABCyLiAGKQO4AyEOIAYpA7ADIQ0gBikDqAMhCSAGKQOgAyERAkAgBUEBRwRAA0ACfgJAAkAgBUEBcUUEQCABIAOEIRAgAiAEhCESIA0hDCAOIQogESELIAkhDwwBC0IAIQwgASADhCIQIAIgBIQiEoRQBEBCACEKQgAhC0IAIQ8MAQtCACEKQgAhC0IAIQ8gDSARhCAJIA6EhFANACAOQj+HIgogDYUiDCAOQj+IfCINIAogEYUiDyAKVCIHIAkgCoUiECAKVCAJUButIgl9IQsgDCANVq0gCiAOhXwgCSANVq19IQwgBEI/hyIJIAOFIhEgBEI/iHwiDSABIAmFIgEgCVQiCCACIAmFIgMgCVQgAlAbrSICfSISIA0gEVStIAQgCYV8IhEgAiANVq19IhSEUEUgCyAMhEIAUnENBSAGQeACaiAPIAp9IgJCACABIAl9Ig9CABCoHiAGQcACaiAQIAp9IAetfSIKQgAgD0IAEKgeIAZB0AJqIAJCACADIAl9IAitfSIQQgAQqB4gBkGwAmogCkIAIBBCABCoHiAGQYACaiAMQgAgD0IAEKgeIAZBkAJqIBBCACALQgAQqB4gBkGgAmogC0IAIA9CABCoHiAMQgBSIBBCAFJxIAYpA4gCQgBSciAGKQOYAkIAUnIgBikDqAIiCyAGKQOAAiAGKQOQAnx8Ig8gC1RyDQUgBikDwAIhDCAGKQPoAiELIAYpA8gCIAYpA7ACIRUgBikDuAIhFiAGKQPQAiEXIAYpA9gCIRggBikDoAIhGSAGKQPgAiEaIAZB0AFqIApCACASQgAQqB4gBkHgAWogFEIAIAJCABCoHiAGQfABaiACQgAgEkIAEKgeIApCAFIgFEIAUnEgBikD2AFCAFJyIAYpA+gBQgBSciAGKQP4ASICIAYpA9ABIAYpA+ABfHwiEiACVHINBSALIAx8IgIgC1StfCIQIBV8IgogGCACIBd8IgsgAlStfHwiAiAZfCIMIAJUIgcgB60gAiAKVK0gFiAKIBBUrXx8IgogD3x8IgIgClQgAiAKURsNBSAMIAwgBikD8AF8IgxWIgcgB60gAiASfHwiCiACVCACIApRGw0FIAogBCAOhSIEQj+HIgKFIAJ9IAIgDIUiDiACVK19IA4gAn0iDiACIBqFIhAgAlQiByACIAuFIg8gAlQgC1AbrSILVK19IgogBIVCAFMNBSAOIAt9IQwgDyACfSAHrX0hDyAQIAJ9IQsMAQsgECAShFAEQEIAIQMgCyERIA8hCSAMIQ0gCiEOQgAhBEIAIQJCAAwCCyAEQj+HIgkgBIUgAyAJhSIDIARCP4h8Ig0gA1StfCERIAIgCYUhAyABIAmFIQELIA0gASAJVCIHIAMgCVQgAyAJURuthSARhEIAUg0DIAZBwAFqIAEgCX0iAUIAIAFCABCoHiAGQbABaiABQgAgAyAJfSAHrX0iAUIAEKgeIAZBoAFqIAFCACABQgAQqB4gBikDqAEgBikDuAEiBCAGKQPIASICIAYpA7ABIgl8IgEgAlStfCICIAYpA6ABfCIDIAJUrXwgAyADIAQgASAJfCICIAFUrXx8IgNWrXwiBEIAUw0DIAshESAPIQkgDCENIAohDiAGKQPAAUJ9gwshASAFQQNLIAVBAXYhBQ0ACwsgDSARhCAJIA6EhFAEQEIAIQtCACEMQgAhCgwCC0IAIQtCACEMQgAhCiABIAOEIAIgBISEUA0BIAMgBEI/hyIDhSILIARCP4h8IgogASADhSIMIANUIgUgAiADhSIPIANUIAJQG60iAX0hAiAKIAtUrSADIASFfCABIApWrX0hCiAOQj+HIgEgDYUiEyAOQj+IfCINIAEgEYUiECABVCIHIAEgCYUiEiABVCAJUButIgl9IgsgDSATVK0gASAOhXwgCSANVq19IhGEUEUgAiAKhEIAUnENACAGQZABaiAMIAN9IglCACAQIAF9Ig1CABCoHiAGQfAAaiAJQgAgEiABfSAHrX0iAUIAEKgeIAZBgAFqIA8gA30gBa19IgNCACANQgAQqB4gBkHgAGogA0IAIAFCABCoHiAGQTBqIBFCACAJQgAQqB4gBkFAayADQgAgC0IAEKgeIAZB0ABqIAtCACAJQgAQqB4gEUIAUiADQgBScSAGKQM4QgBSciAGKQNIQgBSciAGKQNYIgMgBikDMCAGKQNAfHwiCyADVHINACAGKQNwIQkgBikDmAEhAyAGKQN4IAYpA2AhDCAGKQNoIQ8gBikDgAEhEyAGKQOIASEQIAYpA1AhEiAGKQOQASEUIAYgAUIAIAJCABCoHiAGQRBqIApCACANQgAQqB4gBkEgaiANQgAgAkIAEKgeIAFCAFIgCkIAUnEgBikDCEIAUnIgBikDGEIAUnIgBikDKCIBIAYpAwAgBikDEHx8Ig0gAVRyDQAgAyAJfCIBIANUrXwiCiAMfCICIBAgASATfCIDIAFUrXx8IgEgEnwiCSABVCIFIAWtIAEgAlStIA8gAiAKVK18fCICIAt8fCIBIAJUIAEgAlEbDQAgCSAJIAYpAyB8IglWIgUgBa0gASANfHwiAiABVCABIAJRGw0AIAIgBCAOhSIEQj+HIgGFIAF9IAEgCYUiAiABVK19IAIgAX0iAiABIBSFIgkgAVQiBSABIAOFIg4gAVQgA1AbrSIDVK19IgogBIVCAFMNACACIAN9IQwgDiABfSAFrX0hCyAJIAF9IRMMAQsgBkECNgKkAyAGQYiYgAE2AqADIAZCAjcCrAMgBkH6DzYC7AMgBkGDDDYC5AMgBiAGQeADajYCqAMgBiAGQZwDajYC6AMgBiAGQfACajYC4AMgBkHQA2ogBkGgA2oQmQ4gBkGIgICAeDYCzAMgACAGKQLMAzcCBCAAQQxqIAZB1ANqKQIANwIAIABBFGogBkHcA2ooAgA2AgBBAQwBCyAAIAw3AyAgACATNwMQIAAgCjcDKCAAIAs3AxhBAAs2AgAgBkHwA2okAAuBHwIPfwR+IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgYgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIFQQhHBEAgAygCLCEHIAQgAykDCDcCDCAEIAc2AhwgBCAFNgIIIARCAjcDACAEQRRqIAYpAwA3AgAMAwsgA0E4aiAGKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBSABKAKMASIHKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAUgBygCEBEEAAshBiAEIAMpAzA3AzAgASgCoAEhBSABQQA2AqABIAEpAxAhESABQQA2AhAgBCARNwMQIAEpAyAhESABQQA2AiAgBCARNwMgIAEpAwAhESABQgA3AwAgBCABKQMINwMIIAQgETcDACAEQRhqIAFBGGopAwA3AwAgBEEoaiABQShqKQMANwMAIARBOGogA0E4aikDADcDACAEIAY6AEQgBCAFNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwAiEjcDACACQSBqIAJB8ANqKQMANwMAIAIgETcDCCACIAIpA+ADNwMQIAEoAugEIgMuARohCCADLgEYIQYgASABKQO4AyIUIAEpA7ACfDcDsAIgAUGoAWogAUG4A2ohDAJ/AkAgEqdBAXEEQCACKAIoQQFxDQELIAJCAjcDUEEADAELIAIoAiQhAyACKQIcIRICQCABKALoAUEBRgRAIAEpAuwBIBJVIAEoAvQBIgQgA0ogAyAERhtBAUcNAQsgASADNgL0ASABIBI3AuwBIAFBATYC6AELIAIoAjQhBCACKQIsIRMCQCABKAL4AUEBRgRAIBMgASkC/AFVIAQgASgChAIiBUogBCAFRhtBAUcNAQsgASAENgKEAiABIBM3AvwBIAFBATYC+AELIAEtAP4EQQJHBEAgAkICNwNQQQAMAQsgAkGBAjYCkAEgAiAENgKMASACIBM3AoQBIAJBATYCgAEgAiADNgJ8IAIgEjcCdCACQQE2AnAgAiAUNwNoIAJCATcDYCACQgA3A1AgAkHQAGoLIQQgAikDECESIwBBQGoiAyQAIAEtALQDIQUCQAJAAkACQAJAAkACQAJAAkACQCABNQLcAyITIAEpA7gDUgRAIAVBAXFFDQcgBEUNBCAEKAIgRQ0CIAQoAjBFDQMgBEEkaiEFIARBNGohByABKAKoBEUNBiABLQD8BA0BDAULIAVBAXFFDQYgA0EANgIoIANCgICAgBA3AiAgA0EANgI4IANCgICAgBA3AjAgAUHoAmpBASADQSBqIANBMGogExCVFAwGCwJAAkAgASgCtAQiCiAEKAIsIglGBEAgASkCrAQgBSkCAFcNAQwCCyAJIApIDQELIAEoAsAEIgogBCgCPCIJRgRAIAEpA7gEIAcpAgBXDQUMAQsgCSAKTg0ECyABQQA6APwEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgC0AwwCCyABLQD9BEUNAAJAAkAgBCgCLCIKIAEoArQEIglGBEAgBSkCACABKQKsBFcNAQwCCyAJIApIDQELIAQoAjwiCiABKALABCIJRgRAIAcpAgAgASkDuARXDQIMAQsgCSAKTg0BCyABQQA6AP0ECyABQegCaiEKIANBEGoiCSAFQQhqKAIANgIAIANBHGogB0EIaigCADYCACABQQE2AqgEIAEgBSkCACITNwKsBCADIAcpAgA3AhQgAUG0BGogCSkDADcCACABQbwEaiADQRhqKQMANwIAIAMgEzcDCCABEOofBEAgA0EgaiIJIAEgASgC7AQiCygCOCALKAI8IAVBDBCfDSADQTBqIgUgASABKALsBCILKAI4IAsoAjwgB0EMEJsMIApBACAJIAUgASkDuAMQlRQMAQsgA0EwaiIJQQxBAEEBQQEQoBggAygCNCELIAMoAjBBAUYNASADKAI4Ig1BCGogBUEIaigAADYAACANIAUpAAA3AAAgA0EMNgIoIAMgDTYCJCADIAs2AiAgCUEMQQBBAUEBEKAYIAMoAjQhBSADKAIwQQFGDQIgAygCOCILQQhqIAdBCGooAAA2AAAgCyAHKQAANwAAIANBDDYCOCADIAs2AjQgAyAFNgIwIApBACADQSBqIAkgASkDuAMQlRQLIAFB6AJqIAFBwANqIAFBzANqEJYTIAEoAugDQYCAgIB4RwRAIAFB4ANqIgUgATUC3AMQpicgBSARIBIQ1xkLIANBQGskAAwCCyALIAMoAjhBwPXOABD9LwALIAUgAygCOEHA9c4AEP0vAAsgDBD1JiACKAIIQQFGBEAgAikDECERIAECfiABKALYAUEBRgRAIAEpA+ABDAELIAFCATcD2AFCAAsgEXw3A+ABCyACKQNQIREgAkHgA2oiAyACQdgAakHAAPwKAAACQAJAIBFCAlENACABKALsBEEIaiABKALoBEEIahCrEkUNACACQegCaiADQcAA/AoAACACIBE3A+ACIAJCAzcD2AIgAkGYAWogASACQdgCahDqBgwBCyACQgg3A5gBCwJAAkACQAJ+An8CQAJAAkACQAJAAkACQCABKALsBC0AnQFBAUYEQEEAIQMgAkEANgLIAiACQoCAgIAQNwLAAkEAIQQgCEEASg0BDAMLIAJCgICAgBA3AsACIAJBADYCyAIgCEEATA0BIAEoAuAEIQUgAkHgA2oiAyAIIAEoAuQEIgQQqw0gAyAFIAQQrgkgAkHYAmoiBSADQYAB/AoAACACQcwCaiIDIAUQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwwBCyABKALgBCEFIAJB4ANqIgQgCCABKALkBCIHEO0WIAQgBSAHEK4JIAJB2AJqIgUgBEGAAfwKAAAgAkHMAmoiByAFENAQIAJBwAJqIAIoAtACIAIoAtQCIgQQoTYgBxDeOwwBCyAGQQBKBEAgASgC1AQhBSACQeADaiIDIAYgASgC2AQiBxCrDSADIAUgBxCuCSACQdgCaiIFIANBgAH8CgAAIAJBzAJqIgMgBRDQECACQcACaiACKALQAiACKALUAhChNiADEN47CyACQcACaiIHIAIoAjwgAigCQBChNiACKALIAiEFAkAgASgCoARFDQAgAkHYAmoiCCAFQQBBAUEBEKAYIAIoAtwCIQMgAigC2AJBAUcEQCACQQA2AugDIAIgAigC4AI2AuQDIAIgAzYC4AMgCCABKAKgBCACKALEAiACKALIAiACQeADaiIDIAEoAqQEKAIMEQcAIAIoAtgCIghBCEcEQCAAIAIpAtwCNwIEIABBFGogAkHsAmooAgA2AgAgAEEMaiACQeQCaikCADcCACAAIAg2AgAgAxDeOyAHEN47DAQLIAJB4AJqIgMgAkHoA2ooAgA2AgAgAiACKQLgAzcD2AIgAkHAAmoQ3jsgAkHIAmogAygCADYCACACIAIpA9gCNwPAAgwBCyADIAIoAuACQdiCzwAQ/S8ACyACQegDaiACQcgCaigCADYCACACIAIpA8ACNwPgAyACQdgCaiACQeADahDnFSABKALYAyEHIAItAEwhAyACQfABaiACQZgBakHQAPwKAAAgAigC5AIhCCACKALgAiEKIAIpA9gCIRFCCSESQQIhCUECIQsgAikD6AEMBgsgBkEASgRAIAEoAtQEIQUgAkHgA2oiAyAGIAEoAtgEIgYQ7RYgAyAFIAYQrgkgAkHYAmoiBiADQYAB/AoAACACQcwCaiIFIAYQ0BAgAkHAAmogAigC0AIgAigC1AIiAxChNiAFEN47CyACKAJAIgYgAyAEamohBSABKAKgBCIIRQ0BIAIoAsgCIQcgAkHYAmogCCACKAI8IAYgAkHAAmoiBiABKAKkBCgCDBEHACACKALYAiIIQQhGDQIgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAYQ3jsLIAJBmAFqEKwpDAULIAJBwAJqIAIoAjwgBhChNgwBC0EBIAUgAigCyAIgB2tLDQEaIAJBwAJqIgYgBxD0NCAGIAIoAjwgAigCQBChNgtBAAshBiACQegDaiACQcgCaigCADYCACACIAIpAsACNwPgAyACQdgCaiACQeADahDnFSABKALcAyEHIAEoArgDIQggASgC2AMhCiACLQBMIQ4gAikDmAEhEiACQfABaiACQaABakHQAPwKAAAgA0EYdiEPIANBEHYhCSADQQh2IQsgAikD4AIhESACKQPYAgshEyABKAJ4QYCAgIB4Rw0BIAIgEjcD2AIgAkHgAmogAkHwAWpB0AD8CgAAIAIgBTYC2AMgAiAOOgDVAyACIAY6ANQDIAIgBDYC0AMgAiAPOgDPAyACIAk6AM4DIAIgCzoAzQMgAiADOgDMAyACIAc2AsgDIAIgCDYCxAMgAiAKNgLAAyACIBE3A7gDIAIgEzcDsAMgAkHgA2ogASACQdgCahCnCiACKALgAyIDQQhGDQIgACACKQLkAzcCBCAAQRRqIAJB9ANqKAIANgIAIABBDGogAkHsA2opAgA3AgAgACADNgIACyACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAwCCyACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAU2AtgDIAIgDjoA1QMgAiAGOgDUAyACIAQ2AtADIAIgDzoAzwMgAiAJOgDOAyACIAs6AM0DIAIgAzoAzAMgAiAHNgLIAyACIAg2AsQDIAIgCjYCwAMgAiARNwO4AyACIBM3A7ADIAFB2AJqIAJB2AJqEOogCyABQQA2AuQEIAFBADYC2AQgASABKQOQAiABNQLcA3w3A5ACIAwQ6SAgAEEINgIAIAJBxABqIAIoAjwgAigCQCACKAI4KAIQEQEACyACQeAEaiQAC7QUARJ/IwBBoAdrIgIkACACQZgDaiABKAIMIAEoAhAoAhgRAAAgAigCoAMhBSACKAKcAyEEAkACQAJAIAIoApgDIgNBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAFNgIIIAAgBDYCBCAAIAM2AgAMAQsgAiAFNgIkIAIgBDYCIAJAAkACQAJAIAJBIGoQ9S1FBEAgAkEYaiABKAIMIAEoAhAoAiARAAAgAigCGCINDQIgAkGYA2pBH0EAQQFBARCgGCACKAKcAyEFIAIoApgDQQFHDQEMBgsgAkEIaiABEJQpIAIoAgghASAAIAIoAgw2AgggACABNgIEIABBCDYCAAwCCyACKAKgAyIBQRdqQevLzwApAAA3AAAgAUEQakHky88AKQAANwAAIAFBCGpB3MvPACkAADcAACABQdTLzwApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAU2AgQgAEEANgIADAELIAIoAhwhBiACQRBqIAEoAgwgASgCECgCJBEAACACKAIQIgVFBEAgAkGYA2pBH0EAQQFBARCgGCACKAKcAyEFIAIoApgDQQFGDQQgAigCoAMiAUEXakGKzM8AKQAANwAAIAFBEGpBg8zPACkAADcAACABQQhqQfvLzwApAAA3AAAgAUHzy88AKQAANwAAIABBHzYCDCAAIAE2AgggACAFNgIEIABBADYCAAwBCwJAIAIoAhQiCEUNACAFLwEARQ0AIAJBmANqQSlBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRg0FIAIoAqADIgVB7MnPAEEp/AoAACAAQSk2AgwgACAFNgIIIAAgATYCBCAAQQA2AgAMAQsCQAJAAkACQAJ/AkACQAJAAkACQAJAAkAgAS0AHEUEQCACQQA2AigMAQtBwAAhBCACQSBqEPQtIgNBA3YgA0EHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAJCADcCNCACIAQ2AjAgAiADNgIsIAJBwAA2AigLIAJBPGoiAyACQSBqIgkQwy1BBEEEEK02IgRFDQIgAkEBNgKgAyACIAQ2ApwDIAJBATYCmAMgBCADNgIAIAJBgAFqIAJBmANqQQEgCRD0LRDALCACQQA2AswCIAJBADYC0AIgAUEUaiEJIAggBiAGIAhLGyIRRQRAQQAhCAwGCyACQcgFakEEciEOQQAhCEEAIQQCQAJAA0ACQAJAAkACQAJAIAUuAQAiAyABLgEaIgZKIAMgBkhrQf8BcQ4CAAMBCyACIAIoAswCQQFqNgLMAiACQdACaiEDDAELIAQEQCACKALQAiAJKAIARw0FCyAIQQFqIQggAkEANgLQAiANLgEAIhIgAS4BGEgEQCAEQQFxBEAgAkGAAWpBACAPIAIoAswCENgbCyACQYABaiAJKAIAEIcXIAJBzAJqIQNBACEEIAIoAihFDQEgAS8BGCETIAIoAjgiC0EBaiIMQQN2IAxBB3FBAEdqIgYgAigCNCIHSwRAIAYgB2shCiACKAIsIhAgBkkEQCACQShqIBBBAXQiByAGQcD///8DcUFAayAGIAZBP3EbIhAgByAQSxsQ6BkgAigCNCEHCyAKBEAgAigCMCAHakEAIAr8CwALIAIgBjYCNAsgAiAMNgI4IBJBAWpB//8DcSATRw0BIAIoAjAgC0EDdmoiBiAGLQAAQQEgC0EHcXRyOgAADAELIAJBATYC0AIgAigCKARAIAIoAjgiB0EBaiILQQN2IAtBB3FBAEdqIgYgAigCNCIDSwRAIAYgA2shDCACKAIsIgogBkkEQCACQShqIApBAXQiAyAGQcD///8DcUFAayAGIAZBP3EbIgogAyAKSxsQ6BkgAigCNCEDCyAMBEAgAigCMCADakEAIAz8CwALIAIgBjYCNAsgAiALNgI4IAIoAjAgB0EDdmoiAyADLQAAQQEgB0EHcXRyOgAACyAPIAIoAswCIARBAXEbIQ8gAkHMAmohA0EBIQQLIAMgAygCAEEBajYCAAwBCyANLgEAIAEuARhIDQcLIA1BAmohDSAFQQJqIQUgEUEBayIRDQALIARBAXFFDQcgDw0BIAJB1AJqIAJBIGoQwy1BAQwICyACQQM2ApwDIAJBzMzPADYCmAMgAkICNwKkAyACQTs2AuACIAIgCTYC3AIgAkE7NgLYAiACIAJB1AJqNgKgAyACIAJB0AJqNgLUAiAOIAJBmANqEJkODAULIAJBgAFqIgVBACAPIAIoAswCENgbIAJBmANqIgQgBUHMAfwKAAAgAkHUAmogBBDqLEEADAYLQeCbzwBBKSACQZgDakGsns8AQYyczwAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAsgAkGYA2pBO0EAQQFBARCgGCACKAKcAyEBIAIoApgDQQFGDQsgAigCoAMiBUHkzM8AQTv8CgAAIAJBOzYC1AUgAiAFNgLQBSACIAE2AswFCyAAIA4pAgA3AgQgAEEUaiAOQRBqKAIANgIAIABBDGogDkEIaikCADcCACAAQQA2AgAMAgsgAkGYA2oiBSACQYABakHMAfwKAAAgAkHUAmogBRDqLEEACyEFIAIoAvgCIgQgCSgCACAIbEYEQCACQbgDaiABEMMGIAJBADsB8AMgAkEANgLsAyACQQA2AtQDIAJBADYCyAMgAiAINgLEAyACQgQ3ArADIAJCADcCqAMgAkKAgICAwAA3AqADIAJBADYCmAMgAkHIBWoiASACQdQCakHEAPwKAAAgAkHsBGoiBCACQZgDaiIDIAEQ7yUgAigCKARAIAJBoAZqIAJBOGooAgA2AgAgAkGYBmogAkEwaikCADcDACACIAIpAig3A5AGIAMgBEHcAPwKAAAgASACQZAGahCIGSAEIAMgARCuFgsgAkGoBmoiASACQewEahDNHCACQewGaiIEIAEQ3BRBPEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIARBNPwKAAAgAEGYys8ANgIIIAAgATYCBCAAQQg2AgAgBQ0DDAYLIAIgBDYC6AQgAkEDNgKcAyACQbzLzwA2ApgDIAJCAjcCpAMgAkE7NgLUBSACQTs2AswFIAIgCTYCyAUgAiACQcgFajYCoAMgAiACQegEajYC0AUgAEEEaiACQZgDahCZDiAAQQA2AgAgAkHUAmoQ9yYgBUUNAwsgAkGAAWoQlhcMAgtBBEE8EKM9AAsgAkGAAWoQlhcMAgsgAkE8ahD3JiACKAIoRQ0AIAJBKGoQzy8LIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0BIAJBIGoQuyMMAQsgAkE8ahD3JiACKAIgIgAgACgCACIAQQFrNgIAIABBAUcNACACQSBqELsjCyACQaAHaiQADwsgBSACKAKgA0Hko88AEP0vAAsgASACKAKgA0Hko88AEP0vAAu/GgIOfwJ+IwBB4AJrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A7AJBAWsOBAIABAgBCwALIAFBAToA7wIgAUEAOwDtAiABQfgAaiIHIAFB+AD8CgAAIAEgASgCwAIiBDYCyAIgA0EwaiABQbACaigCADYCACABIAEpArQCNwLMAiABQdQCaiABQbwCaigCADYCACABIAEoAsQCNgLYAiADIAEpAqgCNwMoIAEoAtwBQQhqIAQQiC0hDiABKALcAUEIahDXNCIMRQ0DIAwoAggiBEUNAyABKALIAiIGIARPDQEgDCgCBCAGQQxsaiIEKAIIIQwgBCgCBCEIDAMLQdj+wgAQ6CsACyAGIARB/P7CABDDIQALQQEhBgwBCyADQTRqIQQgAUHMAmohDSMAQSBrIgkkAAJAIAcoAlhBgICAgHhGBEAgBEGBgICAeDYCAAwBCyAHKAJgIgZFBEAgBEGBgICAeDYCAAwBCwJAIAcoAlwiBSgCACAFKAIEKAIMEQQAIgsoAgBBgICAgHhHBEAgCUEUaiALEOceDAELIAlBgICAgHg2AhQLIAlBEGogCUEcaigCADYCACAJIAkpAhQ3AwggBSAGQQN0aiELA0AgCUEIaiIGIAUoAgAgBUEEaigCACgCDBEEABCOFyAFQQhqIgUgC0cNAAsgBiANEJEUIwBBMGsiBSQAIAcoAmRBCGoQhTwiDSgCCCEPIAUgDRD7OxCKJkEAIQcgBUEIakEAIAUoAgRBjP/CABCzFQJAAkAgD0UEQCAFQQA2AhwgBUKAgICAwAA3AhQMAQsgBSgCECELAkADQCANIAcQ7BkiCiALTw0BIAUoAgwiECAKQQJ0aiIKIAooAgBBAWo2AgAgDyAHQQFqIgdHDQALQQAhByAFQQA2AhwgBUKAgICAwAA3AhQDQAJAIAYgBxDyJkUNACALIA0gBxDsGSIKSwRAIBAgCkECdGooAgBBAUcNASAFKAIcIgogBSgCFEYEQCAFQRRqQaz/wgAQlygLIAUoAhggCkECdGogBzYCACAFIApBAWo2AhwMAQsgCiALQZz/wgAQwyEACyAPIAdBAWoiB0cNAAsgBSgCHEUNASAFQShqIAVBHGooAgA2AgAgBSAFKQIUNwMgIAQgDSAFQSBqEOgVDAILIAogC0G8/8IAEMMhAAsgBEGBgICAeDYCACAFQRRqEOk7CyAFQQhqEOk7IAVBMGokACAGEIYwCyAJQSBqJAACQCADKAI0QYGAgIB4RwRAIAEgAykCNDcC3AIgAUHkAmogA0E8aigCADYCAAwBCyADQSBqIA4QhjwgAUHcAmogAygCJBD/OgsgA0H4AGoiBCABKALYAiABKALoARCTJCADQccAaiAEQTD8CgAAQcAAQQgQrTYiBARAIARBADoACCAEQoGAgIAQNwMAIARBCWogA0FAayIGQTf8CgAAIAEgBDYC6AIgDikDECERIANBGGogDhCGPCAGIAMoAhwQ/xsgASAMNgKEAiABIAg2AoACIAEgET4CiAIgASADKQJANwLwASABQfgBaiADQcgAaigCADYCACABIAEoAsgCNgKMAiABIAEoAtwBQQhqNgL8ASABIAFB6AJqNgKUAiABIAFB3AJqNgKQAiABKALQASADIAEoAtgCNgJMIANBgICAgHg2AkAgAUGYAmogBiADQShqEOsnIAFBAToA7gJBgICAgHhGDQIgAUEAOgD4AiABIAEpA5ACNwPwAiABIAEoAtQBIgQ2AswDIAEgBCABKALYAUEDdGoiCDYC0ANBACEGDAELQQhBwAAQoz0ACwNAIAZFBEAgBCAIRg0CIAEgBDYC/AIgASAEQQhqNgLMAyABQZgCaiIGEJAjRQRAIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAMBgsgBhCFNiEGIAEoAvwCIgUoAgAgBSgCBCgCDBEEACEFIAFBADoAqAMgASABQdwCajYClAMgASAGNgKMAyABIAU2AogDIAEgAUH4AGo2AoQDIAEgAUHwAWo2AoADIAEgASgC2AI2ApADQQEhBgwBCyADQUBrIgcgAUGAA2oiCSACEM8CAkAgAygCQCIIQQlHBEAgAygCVCEFIAMpAkwhESADKAJIIQYgAygCRCEEIAkQvihCBCESIAhBCEcNBiADIAFB8AJqNgKEASADIAFB5AFqNgKAASADQej+wgA2AnwgAyABQfABajYCeCAHIANB+ABqIAEoAuABIgRBCGpBACAEGyABKAL8AiIEKAIAIAQoAgQoAgwRBAAQlBggAygCSCEGIAMoAkQhBCADKAJAIghBCEcEQCADKAJUIQUgAykCTCERDAcLIAFBADoA7gIgA0GAAWogAUGgAmopAgA3AwAgAyABKQKYAjcDeCADQUBrIANB+ABqIAQgBiABKAL8AiIEKAIAIAQoAgQQrQYgAykCTCERIAMoAkghBiADKAJEIQQgAygCQCIIQQhHBEAgAygCVCEFDAcLIAEgETcDoAIgASAGNgKcAiABIAQ2ApgCIAFBAToA7gIgASgC0AMhCCABKALMAyEEDAELIABCBTcDAEEDDAcLQQAhBgwACwALIANBEGogAUGYAmoiBBCoICADKAIUIAEoAogCIgYgAygCEEEBcRsiBUUEQCABQQA6AO8CIAEpA3ghEiABKAKAASEIIAEoAoQBIQQgASgCiAEhBiABKQKMASERIAEoApQBIQUgA0GIAmogAUGYAWpB2AD8CgAADAMLIAFBADoA7gIgA0HAAWogBEEIaikCADcDACADIAQpAgA3A7gBIANBQGsgA0G4AWogBhCcLCADQZABaiADQdgAaikDADcDACADQZgBaiADQeAAaigCADYCACADIAMpA1A3A4gBIAMgASkDyAE3A3ggAyABKQPAATcDgAEgAUG8A2oiBiADQfgAahDBBSABQQE6AO0CIANBCGoiBCAGEKggIARBBHIgAUGIAmogAygCCEEBcRsoAgAhBCABKALIAQRAIAEgASgCzAEiCCAEIAVraiIFQQAgBSAITRs2AswBCyAERQRAIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAMAgsgASgCwAEEQCABIAEoAsQBIARrNgLEAQsgBhCFNiEEIAFBADoAmAMgAUEANgKEAyABIAQ2AvwCIAEgAUHMAmo2AvgCIAEgAUH4AGo2AvQCIAEgAUHwAWo2AvACIAEgASgC2AI2AoADCyADQUBrIAFB8AJqIgcgAhDPAiADKAJAIghBCUYEQCAAQgU3AwBBBAwECyADKAJUIQUgAykCTCERIAMoAkghBiADKAJEIQQgBxC+KEIEIRIgCEEIRw0AIAFBADoA7QIgA0HIAGogAUHEA2opAgA3AwAgAyABKQK8AzcDQCADQfgAaiIHIANBQGsiBhDvDiADQQE6ALQBIAMgASkDkAI3AqwBIAMgAUHkAWo2AsABIANB6P7CADYCvAEgAyABQfABaiICNgK4ASABKALgASEEIAMgA0GsAWo2AsQBIAYgA0G4AWogBEEIakEAIAQbIAFBzAJqIgkQlBggAygCSCEGIAMoAkQhBCADKAJAIghBCEcEQCADKAJUIQUgAykCTCERIAcQjzAMAQsgA0HIAWogBCAGIANB+ABqEPkUIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAgA0HwAWogA0HUAWopAgA3AwAgA0H4AWogA0HcAWopAgA3AwAgA0GAAmogA0HkAWooAgA2AgAgAyADKQLMATcD6AEgAygCyAEhDCABQQA7AO0CIAIQ9yUgAkEEQQQQ4B4gASgC6AIiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB6AJqEIkpCyABQdwCahCGMCAJEIYwIAFBADoA7wIMAgsgAS0A7QIEQCABQbwDahCOMAsgAUEAOgDtAgsgAS0A7gIEQCABQZgCahCOMAsgAUEAOgDuAiABQfABaiICEPclIAJBBEEEEOAeIAEoAugCIgIgAigCACICQQFrNgIAIAJBAUYEQCABQegCahCJKQsgAUHcAmoQhjAgAUHMAmoQhjAgAS0A7wIEQCABQfgAahCPEwsgAUEAOgDvAkGBgICAeCEMCyAAIAU2AhwgACARNwIUIAAgBjYCECAAIAQ2AgwgACAINgIIIAAgEjcDACAAQSBqIANBiAJqQdgA/AoAACAAIAw2AnggACADKQPoATcCfCAAQYQBaiADQfABaikDADcCACAAQYwBaiADQfgBaikDADcCACAAQZQBaiADQYACaigCADYCAEEBCzoA7AIgA0HgAmokAAuXGgIOfwJ+IwBBsAJrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AnAJBAWsOBAIABAgBCwALIAFBAToAnwIgAUEAOwCdAiABQdAAaiIHIAFB0AD8CgAAIAEgASgC8AEiBDYC+AEgA0EoaiABQeABaigCADYCACABIAEpAuQBNwL8ASABQYQCaiABQewBaigCADYCACABIAEoAvQBNgKIAiADIAEpAtgBNwMgIAEoAowBQQhqIAQQiC0hDiABKAKMAUEIahDXNCIMRQ0DIAwoAggiBEUNAyABKAL4ASIGIARPDQEgDCgCBCAGQQxsaiIEKAIIIQwgBCgCBCEIDAMLQdj+wgAQ6CsACyAGIARB/P7CABDDIQALQQEhBgwBCyADQSxqIQQgAUH8AWohDSMAQSBrIgkkAAJAIAcoAjBBgICAgHhGBEAgBEGBgICAeDYCAAwBCyAHKAI4IgZFBEAgBEGBgICAeDYCAAwBCwJAIAcoAjQiBSgCACAFKAIEKAIMEQQAIgsoAgBBgICAgHhHBEAgCUEUaiALEOceDAELIAlBgICAgHg2AhQLIAlBEGogCUEcaigCADYCACAJIAkpAhQ3AwggBSAGQQN0aiELA0AgCUEIaiIGIAUoAgAgBUEEaigCACgCDBEEABCOFyAFQQhqIgUgC0cNAAsgBiANEJEUIwBBMGsiBSQAIAcoAjxBCGoQhTwiDSgCCCEPIAUgDRD7OxCKJkEAIQcgBUEIakEAIAUoAgRBjP/CABCzFQJAAkAgD0UEQCAFQQA2AhwgBUKAgICAwAA3AhQMAQsgBSgCECELAkADQCANIAcQ7BkiCiALTw0BIAUoAgwiECAKQQJ0aiIKIAooAgBBAWo2AgAgDyAHQQFqIgdHDQALQQAhByAFQQA2AhwgBUKAgICAwAA3AhQDQAJAIAYgBxDyJkUNACALIA0gBxDsGSIKSwRAIBAgCkECdGooAgBBAUcNASAFKAIcIgogBSgCFEYEQCAFQRRqQaz/wgAQlygLIAUoAhggCkECdGogBzYCACAFIApBAWo2AhwMAQsgCiALQZz/wgAQwyEACyAPIAdBAWoiB0cNAAsgBSgCHEUNASAFQShqIAVBHGooAgA2AgAgBSAFKQIUNwMgIAQgDSAFQSBqEOgVDAILIAogC0G8/8IAEMMhAAsgBEGBgICAeDYCACAFQRRqEOk7CyAFQQhqEOk7IAVBMGokACAGEIYwCyAJQSBqJAACQCADKAIsQYGAgIB4RwRAIAEgAykCLDcCjAIgAUGUAmogA0E0aigCADYCAAwBCyADQRhqIA4QhjwgAUGMAmogAygCHBD/OgsgA0HwAGoiBCABKAKIAiABKAKYARCTJCADQT9qIARBMPwKAABBwABBCBCtNiIEBEAgBEEAOgAIIARCgYCAgBA3AwAgBEEJaiADQThqIgZBN/wKAAAgASAENgKYAiAOKQMQIREgA0EQaiAOEIY8IAYgAygCFBD/GyABIAw2ArQBIAEgCDYCsAEgASARPgK4ASABIAMpAjg3AqABIAFBqAFqIANBQGsoAgA2AgAgASABKAL4ATYCvAEgASABKAKMAUEIajYCrAEgASABQZgCajYCxAEgASABQYwCajYCwAEgASgCgAEgAyABKAKIAjYCRCADQYCAgIB4NgI4IAFByAFqIAYgA0EgahDrJyABQQE6AJ4CQYCAgIB4Rg0CIAFBADoAqAIgASABKQPAATcDoAIgASABKAKEASIENgL8AiABIAQgASgCiAFBA3RqIgg2AoADQQAhBgwBC0EIQcAAEKM9AAsDQCAGRQRAIAQgCEYNAiABIAQ2AqwCIAEgBEEIajYC/AIgAUHIAWoiBhCQI0UEQCABQQA6AJ8CIAEpA1AhEiABKAJYIQggASgCXCEEIAEoAmAhBiABKQJkIREgASgCbCEFIANBgAJqIAFB8ABqQTD8CgAADAYLIAYQhTYhBiABKAKsAiIFKAIAIAUoAgQoAgwRBAAhBSABQQA6ANgCIAEgAUGMAmo2AsQCIAEgBjYCvAIgASAFNgK4AiABIAFB0ABqNgK0AiABIAFBoAFqNgKwAiABIAEoAogCNgLAAkEBIQYMAQsgA0E4aiIHIAFBsAJqIgkgAhDoAgJAIAMoAjgiCEEJRwRAIAMoAkwhBSADKQJEIREgAygCQCEGIAMoAjwhBCAJEL4oQgIhEiAIQQhHDQYgAyABQaACajYCfCADIAFBlAFqNgJ4IANB6P7CADYCdCADIAFBoAFqNgJwIAcgA0HwAGogASgCkAEiBEEIakEAIAQbIAEoAqwCIgQoAgAgBCgCBCgCDBEEABCUGCADKAJAIQYgAygCPCEEIAMoAjgiCEEIRwRAIAMoAkwhBSADKQJEIREMBwsgAUEAOgCeAiADQfgAaiABQdABaikCADcDACADIAEpAsgBNwNwIANBOGogA0HwAGogBCAGIAEoAqwCIgQoAgAgBCgCBBCtBiADKQJEIREgAygCQCEGIAMoAjwhBCADKAI4IghBCEcEQCADKAJMIQUMBwsgASARNwPQASABIAY2AswBIAEgBDYCyAEgAUEBOgCeAiABKAKAAyEIIAEoAvwCIQQMAQsgAEIDNwMAQQMMBwtBACEGDAALAAsgA0EIaiABQcgBaiIEEKggIAMoAgwgASgCuAEiBiADKAIIQQFxGyIFRQRAIAFBADoAnwIgASkDUCESIAEoAlghCCABKAJcIQQgASgCYCEGIAEpAmQhESABKAJsIQUgA0GAAmogAUHwAGpBMPwKAAAMAwsgAUEAOgCeAiADQbgBaiAEQQhqKQIANwMAIAMgBCkCADcDsAEgA0E4aiADQbABaiAGEJwsIANBiAFqIANB0ABqKQMANwMAIANBkAFqIANB2ABqKAIANgIAIAMgAykDSDcDgAEgAyABKQN4NwNwIAMgASkDcDcDeCABQewCaiIGIANB8ABqEMEFIAFBAToAnQIgAyAGEKggIANBBHIgAUG4AWogAygCAEEBcRsoAgAhBCABKAJ4BEAgASABKAJ8IgggBCAFa2oiBUEAIAUgCE0bNgJ8CyABQfAAaiEHIARFBEAgAUEAOgCfAiABKQNQIRIgASgCWCEIIAEoAlwhBCABKAJgIQYgASkCZCERIAEoAmwhBSADQYACaiAHQTD8CgAADAILIAcoAgAEQCABIAEoAnQgBGs2AnQLIAYQhTYhBCABQQA6AMgCIAFBADYCtAIgASAENgKsAiABIAFB/AFqNgKoAiABIAFB0ABqNgKkAiABIAFBoAFqNgKgAiABIAEoAogCNgKwAgsgA0E4aiABQaACaiIHIAIQ6AIgAygCOCIIQQlGBEAgAEIDNwMAQQQMBAsgAygCTCEFIAMpAkQhESADKAJAIQYgAygCPCEEIAcQvihCAiESIAhBCEcNACABQQA6AJ0CIANBQGsgAUH0AmopAgA3AwAgAyABKQLsAjcDOCADQfAAaiIHIANBOGoiBhDvDiADQQE6AKwBIAMgASkDwAE3AqQBIAMgAUGUAWo2ArgBIANB6P7CADYCtAEgAyABQaABaiICNgKwASABKAKQASEEIAMgA0GkAWo2ArwBIAYgA0GwAWogBEEIakEAIAQbIAFB/AFqIgkQlBggAygCQCEGIAMoAjwhBCADKAI4IghBCEcEQCADKAJMIQUgAykCRCERIAcQjzAMAQsgA0HAAWogBCAGIANB8ABqEPkUIAFBADoAnwIgASkDUCESIAEoAlghCCABKAJcIQQgASgCYCEGIAEpAmQhESABKAJsIQUgA0GAAmogAUHwAGpBMPwKAAAgA0HoAWogA0HMAWopAgA3AwAgA0HwAWogA0HUAWopAgA3AwAgA0H4AWogA0HcAWooAgA2AgAgAyADKQLEATcD4AEgAygCwAEhDCABQQA7AJ0CIAIQ9yUgAkEEQQQQ4B4gASgCmAIiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBmAJqEIkpCyABQYwCahCGMCAJEIYwIAFBADoAnwIMAgsgAS0AnQIEQCABQewCahCOMAsgAUEAOgCdAgsgAS0AngIEQCABQcgBahCOMAsgAUEAOgCeAiABQaABaiICEPclIAJBBEEEEOAeIAEoApgCIgIgAigCACICQQFrNgIAIAJBAUYEQCABQZgCahCJKQsgAUGMAmoQhjAgAUH8AWoQhjAgAS0AnwIEQCABQdAAahDYFQsgAUEAOgCfAkGBgICAeCEMCyAAIAU2AhwgACARNwIUIAAgBjYCECAAIAQ2AgwgACAINgIIIAAgEjcDACAAQSBqIANBgAJqQTD8CgAAIAAgDDYCUCAAIAMpA+ABNwJUIABB3ABqIANB6AFqKQMANwIAIABB5ABqIANB8AFqKQMANwIAIABB7ABqIANB+AFqKAIANgIAQQELOgCcAiADQbACaiQAC4EdAg9/A34jAEHABGsiAiQAIAJBuAJqIQQjAEFAaiIDJAACQAJ/IAEoAmhBgICAgHhHBEAgA0EYaiABQSBqELwKIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIgdBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAc2AgggBEICNwMAIARBFGogBikDADcCAAwDCyADQThqIAYpAwA3AwAgAyADKQMINwMwQQcMAQsgA0EYaiABKAJ4IgcgASgCfCIFKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQcgBCADKQMINwIMIAQgBzYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAcgBSgCEBEEAAshBiAEIAMpAzA3AyAgBCAGOgA0IAEoApABIQYgAUEANgKQASABKQMQIREgAUEANgIQIAEpAxghEiABQQA2AhggASkDACETIAFCADcDACAEIBI3AxggBCARNwMQIAQgASkDCDcDCCAEIBM3AwAgBCAGNgIwIARBKGogA0E4aikDADcDAAsgA0FAayQAIAJByANqIgMgAkHIAmopAwA3AwAgAkHQA2oiBCACQdACaikDADcDACACIAIpA8ACNwPAAwJAIAIpA7gCIhFCAlEEQCAAIAIpA8ADNwMAIABBEGogBCkDADcDACAAQQhqIAMpAwA3AwAMAQsgAkE4aiACQegCaikDADcDACACQTBqIAJB4AJqKQMANwMAIAJBGGoiBiADKQMANwMAIAJBIGogBCkDADcDACACIAIpA9gCNwMoIAIgAikDwAM3AxAgAiARNwMIIAEoArgEIgMuARohCCADLgEYIQcgASABKQOQAiABKQOYA3w3A5ACIAFBmAFqIAFBmANqIQwCQAJAIAYoAgBBAUYEQCACKAIgDQELIAJCAjcDQEEAIQQMAQsgAigCJCEGIAIgAigCHCIENgLAAyACIAY2ArgCAkAgASgC2AFBAUYEQCADQQhqIAFB3AFqIAJBwANqEOwVRQ0BCyABIAQ2AtwBIAFBATYC2AELAkAgASgC4AFBAUYEQCABKAK4BEEIaiACQbgCaiABQeQBahDsFUUNAQsgASAGNgLkASABQQE2AuABCwJ/IAEtAM4EQQJHBEBCAiERQQAMAQsgAkGBAjYCcCACIAY2AmwgAkEBNgJoIAIgBDYCZCACQQE2AmAgAkIBNwNQIAIgDCkDADcDWEIAIREgAkFAawshBCACIBE3A0AgAikDCCERCyACKQMQIRIjAEEgayIDJAAgAS0AlAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1ArwDIhMgASkDmANSBEAgBUEBcUUNByAERQ0EIAQoAiBFDQIgBCgCKEUNAyAEQSRqIQUgBEEsaiEEIAEoAogERQ0GIAFBkARqIQogAUGMBGohCSABLQDMBA0BDAULIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUHIAmpBASADIANBEGogExCVFAwGCyABKAK4BEEIaiAJIAUQ7BVFBEAgASgCuARBCGogCiAEEOwVRQ0ECyABQQA6AMwEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgCUAwwCCyABLQDNBEUNACABKAK4BEEIaiAFIAkQ7BVFBEAgASgCuARBCGogBCAKEOwVRQ0BCyABQQA6AM0ECyABQcgCaiEKIAFBATYCiAQgASAEKAIANgKQBCABIAUoAgA2AowEIAEQ6B8EQCADIAEgASgCvAQiCSgCOCAJKAI8IAVBBBCdDSADQRBqIgUgASABKAK8BCIJKAI4IAkoAjwgBEEEEJkMIApBACADIAUgASkDmAMQlRQMAQsgA0EQaiIJQQRBAEEBQQEQoBggAygCFCELIAMoAhBBAUYNASADKAIYIhAgBSgCADYAACADQQQ2AgggAyAQNgIEIAMgCzYCACAJQQRBAEEBQQEQoBggAygCFCEFIAMoAhBBAUYNAiADKAIYIgsgBCgCADYAACADQQQ2AhggAyALNgIUIAMgBTYCECAKQQAgAyAJIAEpA5gDEJUUCyABQcgCaiABQaADaiABQawDahCWEyABKALIA0GAgICAeEcEQCABQcADaiIEIAE1ArwDEKYnIAQgESASENcZCyADQSBqJAAMAgsgCyADKAIYQcD1zgAQ/S8ACyAFIAMoAhhBwPXOABD9LwALIAwQ9CYgAigCCEEBRgRAIAIpAxAhESABAn4gASgCyAFBAUYEQCABKQPQAQwBCyABQgE3A8gBQgALIBF8NwPQAQsgAikDQCERIAJBwANqIgMgAkHIAGpBMPwKAAACQAJAIBFCAlENACABKAK8BEEIaiABKAK4BEEIahCrEkUNACACQcgCaiADQTD8CgAAIAIgETcDwAIgAkIBNwO4AiACQfgAaiABIAJBuAJqEOcGDAELIAJCCDcDeAsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCvAQtAJ0BQQFGBEBBACEEIAJBADYCqAIgAkKAgICAEDcCoAJBACEGIAhBAEoNAQwDCyACQoCAgIAQNwKgAiACQQA2AqgCIAhBAEwNASABKAKwBCEEIAJBwANqIgMgCCABKAK0BCIGEKsNIAMgBCAGEK4JIAJBuAJqIgQgA0GAAfwKAAAgAkGsAmoiAyAEENAQIAJBoAJqIAIoArACIAIoArQCEKE2IAMQ3jsMAQsgASgCsAQhBiACQcADaiIDIAggASgCtAQiBRDtFiADIAYgBRCuCSACQbgCaiIGIANBgAH8CgAAIAJBrAJqIgMgBhDQECACQaACaiACKAKwAiACKAK0AiIGEKE2IAMQ3jsMAQsgB0EASgRAIAEoAqQEIQQgAkHAA2oiAyAHIAEoAqgEIgUQqw0gAyAEIAUQrgkgAkG4AmoiBCADQYAB/AoAACACQawCaiIDIAQQ0BAgAkGgAmogAigCsAIgAigCtAIQoTYgAxDeOwsgAkGgAmoiBSACKAIsIAIoAjAQoTYgAigCqAIhAwJAIAEoAoAERQ0AIAJBuAJqIgggA0EAQQFBARCgGCACKAK8AiEEIAIoArgCQQFHBEAgAkEANgLIAyACIAIoAsACNgLEAyACIAQ2AsADIAggASgCgAQgAigCpAIgAigCqAIgAkHAA2oiBCABKAKEBCgCDBEHACACKAK4AiIIQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACAINgIAIAQQ3jsgBRDeOwwECyACQcACaiIEIAJByANqKAIANgIAIAIgAikCwAM3A7gCIAJBoAJqEN47IAJBqAJqIAQoAgA2AgAgAiACKQO4AjcDoAIMAQsgBCACKALAAkHYgs8AEP0vAAsgAkHIA2ogAkGoAmooAgA2AgAgAiACKQOgAjcDwAMgAkG4AmogAkHAA2oQ5xUgASgCuAMhBSACLQA8IQQgAkHQAWogAkH4AGpB0AD8CgAAIAIoAsQCIQggAigCwAIhCiACKQPIASERQgkhEkECIQlBAiELIAIpA7gCDAYLIAdBAEoEQCABKAKkBCEEIAJBwANqIgMgByABKAKoBCIHEO0WIAMgBCAHEK4JIAJBuAJqIgQgA0GAAfwKAAAgAkGsAmoiAyAEENAQIAJBoAJqIAIoArACIAIoArQCIgQQoTYgAxDeOwsgAigCMCIHIAQgBmpqIQMgASgCgAQiCEUNASACKAKoAiEFIAJBuAJqIAggAigCLCAHIAJBoAJqIgcgASgChAQoAgwRBwAgAigCuAIiCEEIRg0CIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgCDYCACAHEN47CyACQfgAahCsKQwFCyACQaACaiACKAIsIAcQoTYMAQtBASADIAIoAqgCIAVrSw0BGiACQaACaiIHIAUQ9DQgByACKAIsIAIoAjAQoTYLQQALIQcgAkHIA2ogAkGoAmooAgA2AgAgAiACKQKgAjcDwAMgAkG4AmogAkHAA2oQ5xUgASgCvAMhBSABKAKYAyEIIAEoArgDIQogAi0APCENIAIpA3ghEiACQdABaiACQYABakHQAPwKAAAgBEEYdiEOIARBEHYhCSAEQQh2IQsgAikDuAIhESACKQPAAgshEyABKAJoQYCAgIB4Rw0BIAIgEjcDuAIgAkHAAmogAkHQAWpB0AD8CgAAIAIgAzYCuAMgAiANOgC1AyACIAc6ALQDIAIgBjYCsAMgAiAOOgCvAyACIAk6AK4DIAIgCzoArQMgAiAEOgCsAyACIAU2AqgDIAIgCDYCpAMgAiAKNgKgAyACIBM3A5gDIAIgETcDkAMgAkHAA2ogASACQbgCahCoCiACKALAAyIDQQhGDQIgACACKQLEAzcCBCAAQRRqIAJB1ANqKAIANgIAIABBDGogAkHMA2opAgA3AgAgACADNgIACyACQTRqIAIoAiwgAigCMCACKAIoKAIQEQEADAILIAIgEjcDuAIgAkHAAmogAkHQAWpB0AD8CgAAIAIgAzYCuAMgAiANOgC1AyACIAc6ALQDIAIgBjYCsAMgAiAOOgCvAyACIAk6AK4DIAIgCzoArQMgAiAEOgCsAyACIAU2AqgDIAIgCDYCpAMgAiAKNgKgAyACIBM3A5gDIAIgETcDkAMgAUG4AmogAkG4AmoQ6iALIAFBADYCtAQgAUEANgKoBCABIAEpA/ABIAE1ArwDfDcD8AEgDBDpICAAQQg2AgAgAkE0aiACKAIsIAIoAjAgAigCKCgCEBEBAAsgAkHABGokAAuhFQEKfyMAQeAAayICJAAgASgCFCEEIAIgASgCGCIDQQBBAUEBEKAYIAIoAgQhBQJAAkACQAJAIAIoAgBBAUcEQCACKAIIIQYgAwRAIAYgBCAD/AoAAAsgAS0AKiEKIAEtACghCyABLQAIIgdBEUcEQAJAAkACQCAHQQRrDgUBAgAAAQILIAEtAAkhCCABLQAKIQkMAQsgAkEIaiABQRNqLQAAOgAAIAIgASkACzcDACABLQAKIQkgAS0ACSEICyACQdAAaiACQQhqLQAAOgAAIAIgAikDADcDSAsgAUEUaiEEIAJBH2ogAkHQAGotAAA6AAAgAiAKOgAhIAIgCzoAICACIAM2AhAgAiAGNgIMIAIgBTYCCCACIAk6ABYgAiAIOgAVIAIgBzoAFCACIAIpA0g3ABcgAiABKQIANwIAAkACQAJAAkACQAJAAkAgAS0AKSIDQQdGIAEoAhwiCUEASHFFBEAgAUEqaiEIIAdBEUYNCiACIAFBCGo2AiQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKRQRAAkACQAJAIAdBBGsOBQECAAABAgsgAS0ACSEFIAEtAAohBgwBCyACQThqIAFBE2otAAA6AAAgAiABKQALNwMwIAEtAAohBiABLQAJIQULIAJB0wBqIAJBOGotAAA6AAAgAiAGOgBKIAIgBToASSACIAc6AEggAiACKQMwNwBLIAIgAkHIAGoQmhA6ACEMAQsCQAJAAkAgB0EEaw4FAQIAAAECCyABLQAJIQUgAS0ACiEGDAELIAJBOGogAUETai0AADoAACACIAEpAAs3AzAgAS0ACiEGIAEtAAkhBQsgAkHTAGogAkE4ai0AADoAACACIAY6AEogAiAFOgBJIAIgBzoASCACIAIpAzA3AEsgAkHIAGoQmhBB/wFxIApHDQELIAcODgECAgMNBAUGBwgJChILFQsgAkEENgI0IAJBlLLPADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGoBDYCVCACIAg2AlAgAkGqBDYCTCACIAJByABqNgI4IAIgAkEkajYCSCAAQQxqIAJBMGoQmQ4gAEEBNgIAIABBADYCCAwWCyADQQZGDRQMEwsgAkEDNgJMIAJByK3PADYCSCACQgI3AlQgAkHMATYCPCACIAQ2AjggAkGqBDYCNCACIAJBMGo2AlAgAiACQSRqNgIwIABBDGogAkHIAGoQmQ4gAEEBNgIAIABBADYCCAwUCyADQQZGDRIMEQsgA0EBRg0RDBALIANBAWsOAggJDwsgA0ECRg0PDA4LIANBAWsOAggJDQsgA0EBRg0NDAwLIANBBkYNDAwLCyADQQZHDQoMCwsgA0EHRg0HDAkLIAJBAzYCTCACQfy1zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBnAM2AjQgAiABQRxqNgIwIAIgAkEwajYCUCAAQQxqIAJByABqEJkOIABBATYCACAAQQA2AggMCgsgAiACKAIkIgVBBGo2AiggAiAFQQhqNgIsAkAgASgCDCABKAIkRwRAIAJBBDYCNCACQfyuzwA2AjAgAkIDNwI8IAJBzAE2AlwgAiAENgJYIAJBnAM2AlQgAiABQSRqNgJQIAJBqQg2AkwgAiACQcgAajYCOCACIAJBKGo2AkggAEEMaiACQTBqEKcYQQAhBQwBCyABKAIQIAEoAiBHBEAgAkEENgI0IAJBqK7PADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGcAzYCVCACIAFBIGo2AlAgAkGpCDYCTCACIAJByABqNgI4IAIgAkEsajYCSCAAQQxqIAJBMGoQpxhBACEFDAELIAJByABqIAEQnAggAigCSCIFQQhGDQkgACACKQJMNwIMIABBHGogAkHcAGooAgA2AgAgAEEUaiACQdQAaikCADcCAAsgAEEBNgIAIAAgBTYCCAwJCyABLQAJRQ0HDAYLIAIoAiQtAAENBiACQQI2AkwgAkHUr88ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAcLIAEsAAlBIUgNBQwECyABLQAJQcAARg0EDAMLIANBB0cNAiAJQRBGDQMgAkECNgJMIAJBtLDPADYCSCACQgE3AlQgAkHMATYCNCACIAQ2AjAgAiACQTBqNgJQIABBDGogAkHIAGoQpxggAEEBNgIAIABBADYCCAwECyAJQQJGDQIgAkECNgJMIAJBmLHPADYCSCACQgE3AlQgAkHMATYCNCACIAQ2AjAgAiACQTBqNgJQIABBDGogAkHIAGoQpxggAEEBNgIAIABBADYCCAwDCyAFIAIoAghB5KPPABD9LwALIAIgAigCJDYCLCACIAM6ACggAkEENgI0IAJBwLHPADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGxAzYCVCACQaoENgJMIAIgAkHIAGo2AjggAiACQShqNgJQIAIgAkEsajYCSCAAQQxqIAJBMGoQmQ4gAEEBNgIAIABBADYCCAwBCwJAAkACQAJAAkACQAJAAkACQCAKDhcIAQAAAAMEBQUGBgYFBQUGBQUFBgEBAgALIAJBAzYCTCACQby1zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBqAQ2AjQgAiAINgIwIAIgAkEwajYCUCAAQQxqIAJByABqEKcYIABBATYCACAAQQA2AggMCAsgA0EGRw0FDAYLIANBB0YgCUEMRnENBSACQQI2AkwgAkGEtc8ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAYLIANBBkYNBCACQQI2AkwgAkH4ss8ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAULIAJByABqIAEQnAggAigCSCIEQQhGDQMgACACKQJMNwIMIABBHGogAkHcAGooAgA2AgAgAEEUaiACQdQAaikCADcCACAAQQE2AgAgACAENgIIDAQLIANBAUYNAiACQQM2AkwgAkHEs88ANgJIIAJCAjcCVCACQcwBNgI8IAIgBDYCOCACQagENgI0IAIgCDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCZDiAAQQE2AgAgAEEANgIIDAMLIANBAkYNASACQQM2AkwgAkGAtM8ANgJIIAJCAjcCVCACQcwBNgI8IAIgBDYCOCACQagENgI0IAIgCDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCZDiAAQQE2AgAgAEEANgIIDAILIAJBAzYCTCACQZi0zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBqAQ2AjQgAiAINgIwIAIgAkEwajYCUCAAQQxqIAJByABqEJkOIABBATYCACAAQQA2AggMAQsgAEEEaiACQST8CgAAIAAgAzoANCAAIAk2AiggAEEANgIAIAAgASkCIEIgiTcCLAwBCyACQQhqEN47CyACQeAAaiQAC+McAg5/BH4jAEGgBGsiAiQAIAJBmAJqIQUjAEFAaiIDJAACQAJ/IAEoAlhBgICAgHhHBEAgA0EYaiABQRBqELwKIANBEGoiCiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIgRBCEcEQCADKAIsIQcgBSADKQMINwIMIAUgBzYCHCAFIAQ2AgggBUICNwMAIAVBFGogCikDADcCAAwDCyADQThqIAopAwA3AwAgAyADKQMINwMwQQcMAQsgA0EYaiABKAJoIgQgASgCbCIHKAIcEQAAIANBEGoiCiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQQgBSADKQMINwIMIAUgBDYCHCAFIAg2AgggBUICNwMAIAVBFGogCikDADcCAAwCCyADQThqIAopAwA3AwAgAyADKQMINwMwIAQgBygCEBEEAAshCiAFIAMpAzA3AxAgBSAKOgAmIAEoAoABIQogAUEANgKAASABLwCFASEEIAFBggQ7AIUBIAEpAwAhECABQgA3AwAgBSABKQMINwMIIAUgEDcDACAFIAQ7ASQgBSAKNgIgIAVBGGogA0E4aikDADcDAAsgA0FAayQAIAJBqANqIgMgAkGoAmopAwA3AwAgAkGwA2oiBSACQbACaikDADcDACACIAIpA6ACNwOgA0ICIRECQCACKQOYAiIQQgJRBEAgACACKQOgAzcDACAAQRBqIAUpAwA3AwAgAEEIaiADKQMANwMADAELIAJBGGogAykDADcDACACQSBqIAUpAwA3AwAgAiACKQOgAzcDECACIAIpA7gCIhI3AyggAiAQNwMIIAEoApQEIgMuARohCCADLgEYIQcgASABKQOAAyITIAEpA/ABfDcD8AEgAUGIAWohBSABQYADaiEKQQAhAwJAIBJCIIinIgRB/wFxQQJGDQAgEkIoiKciBkH/AXFBAkYNACABLQCQAiIJQQJHIARBAXMgCXFBAXFFcUUEQCABIAQ6AJACCyABLQCRAiIJQQJHIAYgCUEBc3FBAXFFcUUEQCABIAY6AJECCyABLQCsBEECRw0AIAIgBjoAVSACIAQ6AFQgAkGBAjYCUCACIBM3A0ggAkIBNwNAIAJBMGohA0IAIRELIAIgETcDMCACKQMQIREjAEEgayIEJAAgAS0A/AIhBgJAAkACQAJAAkACQAJAAkACQCABNQKkAyISIAEpA4ADUgRAIAZBAXFFDQcgA0UNBCADLQAkIgZBAkYNAiADLQAlIglBAkYNAyABLQCoBCILQQJGDQYgAS0AqgQNAQwFCyAGQQFxRQ0GIARBADYCCCAEQoCAgIAQNwIAIARBADYCGCAEQoCAgIAQNwIQIAFBsAJqQQEgBCAEQRBqIBIQlRQMBgsgBkEBcUUgC0EBcXFFBEAgCUEBcSABLQCpBEEBR3INBAsgAUEAOgCqBAwDC0HIgM8AELI7AAtB2IDPABCyOwALIAFBADoA/AIMAgsgAS0AqwRFDQAgC0EBcUUgBkEBcXFFBEAgCUEBcUUNASABLQCpBEEBcQ0BCyABQQA6AKsECyABQbACaiELIAEgCToAqQQgASAGOgCoBCABEOYfBEAgBCABIAEoApgEIgYoAjggBigCPCADQSRqQQEQmw0gBEEQaiIGIAEgASgCmAQiCSgCOCAJKAI8IANBJWpBARCXDCALQQAgBCAGIAEpA4ADEJUUDAELIARBEGoiDEEBQQBBAUEBEKAYIAQoAhQhAyAEKAIQQQFGDQEgBCgCGCIPIAY6AAAgBEEBNgIIIAQgDzYCBCAEIAM2AgAgDEEBQQBBAUEBEKAYIAQoAhQhAyAEKAIQQQFGDQEgBCgCGCIGIAk6AAAgBEEBNgIYIAQgBjYCFCAEIAM2AhAgC0EAIAQgDCABKQOAAxCVFAsgAUGwAmogAUGIA2ogAUGUA2oQlhMgASgCsANBgICAgHhHBEAgAUGoA2oiAyABNQKkAxCmJyADIBAgERDXGQsgBEEgaiQADAELIAMgBCgCGEHA9c4AEP0vAAsCQCAKIgMoAhRBgICAgHhGDQAgBSgCfEGAgICAeEYNACAFQfwAaiADQRRqEPsXCwJAIAMoAghBgICAgHhGDQAgBSgCcEGAgICAeEYNACAFQfAAaiADQQhqEPsXCyACKAIIQQFGBEAgAikDECEQIAECfiABKAK4AUEBRgRAIAEpA8ABDAELIAFCATcDuAFCAAsgEHw3A8ABCyACQagDaiIDIAJBQGspAwA3AwAgAkGwA2oiBCACQcgAaikDADcDACACQbgDaiIGIAJB0ABqKQMANwMAIAIgAikDODcDoAMCQAJAIAIpAzAiEEICUQ0AIAEoApgEQQhqIAEoApQEQQhqEKsSRQ0AIAJBwAJqIAYpAwA3AwAgAkG4AmogBCkDADcDACACQbACaiADKQMANwMAIAIgAikDoAM3A6gCIAIgEDcDoAIgAkIANwOYAiACQdgAaiABIAJBmAJqEOkGDAELIAJCCDcDWAsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCmAQtAJ0BQQFGBEBBACEDIAJBADYCiAIgAkKAgICAEDcCgAJBACEFIAhBAEoNAQwDCyACQoCAgIAQNwKAAiACQQA2AogCIAhBAEwNASABKAKMBCEEIAJBoANqIgMgCCABKAKQBCIFEKsNIAMgBCAFEK4JIAJBmAJqIgQgA0GAAfwKAAAgAkGMAmoiAyAEENAQIAJBgAJqIAIoApACIAIoApQCEKE2IAMQ3jsMAQsgASgCjAQhBCACQaADaiIFIAggASgCkAQiCBDtFiAFIAQgCBCuCSACQZgCaiIEIAVBgAH8CgAAIAJBjAJqIgggBBDQECACQYACaiACKAKQAiACKAKUAiIFEKE2IAgQ3jsMAQsgB0EASgRAIAEoAoAEIQQgAkGgA2oiAyAHIAEoAoQEIggQqw0gAyAEIAgQrgkgAkGYAmoiBCADQYAB/AoAACACQYwCaiIDIAQQ0BAgAkGAAmogAigCkAIgAigClAIQoTYgAxDeOwsgAkGAAmoiCCACKAIcIAIoAiAQoTYgAigCiAIhBAJAIAEoAugDRQ0AIAJBmAJqIgYgBEEAQQFBARCgGCACKAKcAiEDIAIoApgCQQFHBEAgAkEANgKoAyACIAIoAqACNgKkAyACIAM2AqADIAYgASgC6AMgAigChAIgAigCiAIgAkGgA2oiAyABKALsAygCDBEHACACKAKYAiIGQQhHBEAgACACKQKcAjcCBCAAQRRqIAJBrAJqKAIANgIAIABBDGogAkGkAmopAgA3AgAgACAGNgIAIAMQ3jsgCBDeOwwECyACQaACaiIDIAJBqANqKAIANgIAIAIgAikCoAM3A5gCIAJBgAJqEN47IAJBiAJqIAMoAgA2AgAgAiACKQOYAjcDgAIMAQsgAyACKAKgAkHYgs8AEP0vAAsgAkGoA2ogAkGIAmooAgA2AgAgAiACKQOAAjcDoAMgAkGYAmogAkGgA2oQ5xUgASgCoAMhCCACLQAuIQMgAkGwAWogAkHYAGpB0AD8CgAAIAIoAqQCIQYgAigCoAIhCSACKQOYAiEQQQIhC0IJIRFBAiEMIAIpA6gBDAYLIAdBAEoEQCABKAKABCEEIAJBoANqIgMgByABKAKEBCIHEO0WIAMgBCAHEK4JIAJBmAJqIgQgA0GAAfwKAAAgAkGMAmoiByAEENAQIAJBgAJqIAIoApACIAIoApQCIgMQoTYgBxDeOwsgAigCICIHIAMgBWpqIQQgASgC6AMiBkUNASACKAKIAiEIIAJBmAJqIAYgAigCHCAHIAJBgAJqIgcgASgC7AMoAgwRBwAgAigCmAIiBkEIRg0CIAAgAikCnAI3AgQgAEEUaiACQawCaigCADYCACAAQQxqIAJBpAJqKQIANwIAIAAgBjYCACAHEN47CyACQdgAahCsKQwFCyACQYACaiACKAIcIAcQoTYMAQtBASAEIAIoAogCIAhrSw0BGiACQYACaiIHIAgQ9DQgByACKAIcIAIoAiAQoTYLQQALIQcgAkGoA2ogAkGIAmooAgA2AgAgAiACKQKAAjcDoAMgAkGYAmogAkGgA2oQ5xUgASgCpAMhCCABKAKAAyEGIAEoAqADIQkgAi0ALiENIAIpA1ghESACQbABaiACQeAAakHQAPwKAAAgA0EYdiEOIANBEHYhDCADQQh2IQsgAikDoAIhECACKQOYAgshEiABKAJYQYCAgIB4Rw0BIAIgETcDmAIgAkGgAmogAkGwAWpB0AD8CgAAIAIgBDYCmAMgAiANOgCVAyACIAc6AJQDIAIgBTYCkAMgAiAOOgCPAyACIAw6AI4DIAIgCzoAjQMgAiADOgCMAyACIAg2AogDIAIgBjYChAMgAiAJNgKAAyACIBA3A/gCIAIgEjcD8AIgAkGgA2ogASACQZgCahCpCiACKAKgAyIDQQhGDQIgACACKQKkAzcCBCAAQRRqIAJBtANqKAIANgIAIABBDGogAkGsA2opAgA3AgAgACADNgIACyACQSRqIAIoAhwgAigCICACKAIYKAIQEQEADAILIAIgETcDmAIgAkGgAmogAkGwAWpB0AD8CgAAIAIgBDYCmAMgAiANOgCVAyACIAc6AJQDIAIgBTYCkAMgAiAOOgCPAyACIAw6AI4DIAIgCzoAjQMgAiADOgCMAyACIAg2AogDIAIgBjYChAMgAiAJNgKAAyACIBA3A/gCIAIgEjcD8AIgAUGgAmogAkGYAmoQ6iALIAFBADYCkAQgAUEANgKEBCABIAEpA9ABIAE1AqQDfDcD0AEgChDpICAAQQg2AgAgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAsgAkGgBGokAAuFHQIOfwN+IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgcgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIGQQhHBEAgAygCLCEFIAQgAykDCDcCDCAEIAU2AhwgBCAGNgIIIARCAjcDACAEQRRqIAcpAwA3AgAMAwsgA0E4aiAHKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBiABKAKMASIFKAIcEQAAIANBEGoiByADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQYgBCADKQMINwIMIAQgBjYCHCAEIAg2AgggBEICNwMAIARBFGogBykDADcCAAwCCyADQThqIAcpAwA3AwAgAyADKQMINwMwIAYgBSgCEBEEAAshByAEIAMpAzA3AzAgASgCoAEhBiABQQA2AqABIAEpAwAhECABQgA3AwAgASkDECESIAFCADcDECABKQMgIREgAUIANwMgIAQgASkDKDcDKCAEIBE3AyAgBCABKQMYNwMYIAQgEjcDECAEIAEpAwg3AwggBCAQNwMAIARBOGogA0E4aikDADcDACAEIAc6AEQgBCAGNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwA3AwAgAkEgaiACQfADaikDACIQNwMAIAIgAikD4AMiEjcDECACIBE3AwggASgC5AQiAy4BGiEIIAMuARghBiABIAEpA7ACIAEpA9ADfDcDsAIgAUGoAWohByABQdADaiEMAkACQCARp0EBcQRAIAIoAhgNAQsgAkICNwNQQQAhBAwBCyACIBI3A+ADIAIgEDcD2AICQCABKALIAUEBRgRAIANBCGogAUHQAWogAkHgA2oQ8xtFDQELIAEgEjcD0AEgAUIBNwPIAQsCQCABKALYAUEBRgRAIAEoAuQEQQhqIAJB2AJqIAFB4AFqEPMbRQ0BCyABIBA3A+ABIAFCATcD2AELAn8gAS0A+gRBAkcEQEICIRFBAAwBCyACQYECNgKQAUIBIREgAkIBNwOAASACQgA3A3AgAiAQNwNoIAJCATcDYCACIBI3A1ggAiAMKQMANwOIASACQdAAagshBCACIBE3A1ALIAIpAyghECACKQMwIRIjAEEgayIDJAAgAS0AzAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1AvQDIhEgASkD0ANSBEAgBUEBcUUNByAERQ0EIAQoAgBFDQIgBCgCEEUNAyAEQQhqIQUgBEEYaiEEIAEoAtACRQ0GIAFB4AJqIQogAUHYAmohCSABLQD4BA0BDAULIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUGAA2pBASADIANBEGogERCVFAwGCyABKALkBEEIaiAJIAUQ8xtFBEAgASgC5ARBCGogCiAEEPMbRQ0ECyABQQA6APgEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgDMAwwCCyABLQD5BEUNACABKALkBEEIaiAFIAkQ8xtFBEAgASgC5ARBCGogBCAKEPMbRQ0BCyABQQA6APkECyABQYADaiEKIAFCATcD0AIgASAEKQMANwPgAiABIAUpAwA3A9gCIAEQ5R8EQCADIAEgASgC6AQiCSgCOCAJKAI8IAVBCBCaDSADQRBqIgUgASABKALoBCIJKAI4IAkoAjwgBEEIEJYMIApBACADIAUgASkD0AMQlRQMAQsgA0EQaiIJQQhBAEEBQQEQoBggAygCFCELIAMoAhBBAUYNASADKAIYIg8gBSkDADcAACADQQg2AgggAyAPNgIEIAMgCzYCACAJQQhBAEEBQQEQoBggAygCFCEFIAMoAhBBAUYNAiADKAIYIgsgBCkDADcAACADQQg2AhggAyALNgIUIAMgBTYCECAKQQAgAyAJIAEpA9ADEJUUCyABQYADaiABQdgDaiABQeQDahCWEyABKAKABEGAgICAeEcEQCABQfgDaiIEIAE1AvQDEKYnIAQgECASENcZCyADQSBqJAAMAgsgCyADKAIYQcD1zgAQ/S8ACyAFIAMoAhhBwPXOABD9LwALIAcgDBD1JiACKAIoQQFGBEAgAikDMCEQIAECfiABKAL4AUEBRgRAIAEpA4ACDAELIAFCATcD+AFCAAsgEHw3A4ACCyACKQNQIRAgAkHgA2oiAyACQdgAakHAAPwKAAACQAJAIBBCAlENACABKALoBEEIaiABKALkBEEIahCrEkUNACACQegCaiADQcAA/AoAACACIBA3A+ACIAJCAjcD2AIgAkGYAWogASACQdgCahDoBgwBCyACQgg3A5gBCwJAAkACQAJ+An8CQAJAAkACQAJAAkACQCABKALoBC0AnQFBAUYEQEEAIQQgAkEANgLIAiACQoCAgIAQNwLAAkEAIQcgCEEASg0BDAMLIAJCgICAgBA3AsACIAJBADYCyAIgCEEATA0BIAEoAtwEIQQgAkHgA2oiAyAIIAEoAuAEIgcQqw0gAyAEIAcQrgkgAkHYAmoiBCADQYAB/AoAACACQcwCaiIDIAQQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwwBCyABKALcBCEHIAJB4ANqIgMgCCABKALgBCIFEO0WIAMgByAFEK4JIAJB2AJqIgcgA0GAAfwKAAAgAkHMAmoiAyAHENAQIAJBwAJqIAIoAtACIAIoAtQCIgcQoTYgAxDeOwwBCyAGQQBKBEAgASgC0AQhBCACQeADaiIDIAYgASgC1AQiBRCrDSADIAQgBRCuCSACQdgCaiIEIANBgAH8CgAAIAJBzAJqIgMgBBDQECACQcACaiACKALQAiACKALUAhChNiADEN47CyACQcACaiIFIAIoAjwgAigCQBChNiACKALIAiEDAkAgASgCuARFDQAgAkHYAmoiCCADQQBBAUEBEKAYIAIoAtwCIQQgAigC2AJBAUcEQCACQQA2AugDIAIgAigC4AI2AuQDIAIgBDYC4AMgCCABKAK4BCACKALEAiACKALIAiACQeADaiIEIAEoArwEKAIMEQcAIAIoAtgCIghBCEcEQCAAIAIpAtwCNwIEIABBFGogAkHsAmooAgA2AgAgAEEMaiACQeQCaikCADcCACAAIAg2AgAgBBDeOyAFEN47DAQLIAJB4AJqIgQgAkHoA2ooAgA2AgAgAiACKQLgAzcD2AIgAkHAAmoQ3jsgAkHIAmogBCgCADYCACACIAIpA9gCNwPAAgwBCyAEIAIoAuACQdiCzwAQ/S8ACyACQegDaiACQcgCaigCADYCACACIAIpA8ACNwPgAyACQdgCaiACQeADahDnFSABKALwAyEFIAItAEwhBCACQfABaiACQZgBakHQAPwKAAAgAigC5AIhCCACKALgAiEKIAIpA+gBIRBCCSESQQIhCUECIQsgAikD2AIMBgsgBkEASgRAIAEoAtAEIQQgAkHgA2oiAyAGIAEoAtQEIgYQ7RYgAyAEIAYQrgkgAkHYAmoiBCADQYAB/AoAACACQcwCaiIDIAQQ0BAgAkHAAmogAigC0AIgAigC1AIiBBChNiADEN47CyACKAJAIgYgBCAHamohAyABKAK4BCIIRQ0BIAIoAsgCIQUgAkHYAmogCCACKAI8IAYgAkHAAmoiBiABKAK8BCgCDBEHACACKALYAiIIQQhGDQIgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAYQ3jsLIAJBmAFqEKwpDAULIAJBwAJqIAIoAjwgBhChNgwBC0EBIAMgAigCyAIgBWtLDQEaIAJBwAJqIgYgBRD0NCAGIAIoAjwgAigCQBChNgtBAAshBiACQegDaiACQcgCaigCADYCACACIAIpAsACNwPgAyACQdgCaiACQeADahDnFSABKAL0AyEFIAEoAtADIQggASgC8AMhCiACLQBMIQ0gAikDmAEhEiACQfABaiACQaABakHQAPwKAAAgBEEYdiEOIARBEHYhCSAEQQh2IQsgAikD2AIhECACKQPgAgshESABKAJ4QYCAgIB4Rw0BIAIgEjcD2AIgAkHgAmogAkHwAWpB0AD8CgAAIAIgAzYC2AMgAiANOgDVAyACIAY6ANQDIAIgBzYC0AMgAiAOOgDPAyACIAk6AM4DIAIgCzoAzQMgAiAEOgDMAyACIAU2AsgDIAIgCDYCxAMgAiAKNgLAAyACIBE3A7gDIAIgEDcDsAMgAkHgA2ogASACQdgCahCkCiACKALgAyIDQQhGDQIgACACKQLkAzcCBCAAQRRqIAJB9ANqKAIANgIAIABBDGogAkHsA2opAgA3AgAgACADNgIACyACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAwCCyACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAM2AtgDIAIgDToA1QMgAiAGOgDUAyACIAc2AtADIAIgDjoAzwMgAiAJOgDOAyACIAs6AM0DIAIgBDoAzAMgAiAFNgLIAyACIAg2AsQDIAIgCjYCwAMgAiARNwO4AyACIBA3A7ADIAFB8AJqIAJB2AJqEOogCyABQQA2AuAEIAFBADYC1AQgASABKQOQAiABNQL0A3w3A5ACIAwQ6SAgAEEINgIAIAJBxABqIAIoAjwgAigCQCACKAI4KAIQEQEACyACQeAEaiQAC9IcAw9/A34CfSMAQcAEayICJAAgAkG4AmohBCMAQUBqIgMkAAJAAn8gASgCaEGAgICAeEcEQCADQRhqIAFBIGoQvAogA0EQaiIGIANBJGopAgA3AwAgAyADKQIcNwMIIAMoAhgiBUEIRwRAIAMoAiwhByAEIAMpAwg3AgwgBCAHNgIcIAQgBTYCCCAEQgI3AwAgBEEUaiAGKQMANwIADAMLIANBOGogBikDADcDACADIAMpAwg3AzBBBwwBCyADQRhqIAEoAngiBSABKAJ8IgcoAhwRAAAgA0EQaiIGIANBJGopAgA3AwAgAyADKQIcNwMIIAMoAhgiCEEIRwRAIAMoAiwhBSAEIAMpAwg3AgwgBCAFNgIcIAQgCDYCCCAEQgI3AwAgBEEUaiAGKQMANwIADAILIANBOGogBikDADcDACADIAMpAwg3AzAgBSAHKAIQEQQACyEGIAQgAykDMDcDICABKAKQASEFIAFBADYCkAEgASgCECEHIAFBADYCECABKAIYIQggAUEANgIYIAEpAwAhESABQgA3AwAgBCABKgIcOAIcIAQgCDYCGCAEIAEqAhQ4AhQgBCAHNgIQIAQgASkDCDcDCCAEIBE3AwAgBEEoaiADQThqKQMANwMAIAQgBjoANCAEIAU2AjALIANBQGskACACQcgDaiIDIAJByAJqKQMANwMAIAJB0ANqIgQgAkHQAmopAwA3AwAgAiACKQPAAjcDwAMCQCACKQO4AiIRQgJRBEAgACACKQPAAzcDACAAQRBqIAQpAwA3AwAgAEEIaiADKQMANwMADAELIAJBOGogAkHoAmopAwA3AwAgAkEwaiACQeACaikDADcDACACQRhqIgYgAykDADcDACACQSBqIAQpAwA3AwAgAiACKQPYAjcDKCACIAIpA8ADNwMQIAIgETcDCCABKAK4BCIDLgEaIQcgAy4BGCEEIAEgASkDmAMiEiABKQOQAnw3A5ACIAFBmAFqIAFBmANqIQwCfwJAIAYoAgBBAUYEQCACKAIgDQELIAJCAjcDQEEADAELIAIqAiQhFAJAIAIqAhwiFSAVXA0AIAEoAtgBQQFGBEAgASoC3AEgFV5FDQELIAEgFTgC3AEgAUEBNgLYAQsCQCAUIBRcDQAgASgC4AFBAUYEQCAUIAEqAuQBXkUNAQsgASAUOALkASABQQE2AuABCyABLQDOBEECRwRAIAJCAjcDQEEADAELIAJBgQI2AnAgAiAUOAJsIAJBATYCaCACIBU4AmQgAkEBNgJgIAIgEjcDWCACQgE3A1AgAkIANwNAIAJBQGsLIQYgAikDECESIwBBIGsiAyQAIAEtAJQDIQUCQAJAAkACQAJAAkACQAJAAkACQCABNQK8AyITIAEpA5gDUgRAIAVBAXFFDQcgBkUNASAGKAIgRQ0DIAYoAihFDQQgBkEkaiEIIAZBLGohBSABKAKIBA0CIAgqAgAhFAwGCyAFQQFxRQ0GIANBADYCCCADQoCAgIAQNwIAIANBADYCGCADQoCAgIAQNwIQIAFByAJqQQEgAyADQRBqIBMQlRQMBgsgAUEAOgCUAwwFCyAIKgIAIRQgAS0AzARFDQIgASoCjAQgFF5FBEAgASoCkAQgBSoCAF5FDQMLIAFBADoAzAQMAgtByIDPABCyOwALQdiAzwAQsjsACyABLQDNBEUNACAUIAEqAowEXkUEQCAFKgIAIAEqApAEXkUNAQsgAUEAOgDNBAsgAUHIAmohCyABIBQ4AowEIAFBATYCiAQgASAFKgIAOAKQBCABEOgfBEAgAyABIAEoArwEIgkoAjggCSgCPCAIQQQQnQ0gA0EQaiIIIAEgASgCvAQiCSgCOCAJKAI8IAVBBBCZDCALQQAgAyAIIAEpA5gDEJUUDAELIANBEGoiCUEEQQBBAUEBEKAYIAMoAhQhCiADKAIQQQFGDQEgAygCGCIQIAgoAgA2AAAgA0EENgIIIAMgEDYCBCADIAo2AgAgCUEEQQBBAUEBEKAYIAMoAhQhCCADKAIQQQFGDQIgAygCGCIKIAUoAgA2AAAgA0EENgIYIAMgCjYCFCADIAg2AhAgC0EAIAMgCSABKQOYAxCVFAsgAUHIAmogAUGgA2ogAUGsA2oQlhMgASgCyANBgICAgHhHBEAgAUHAA2oiBSABNQK8AxCmJyAFIBEgEhDXGQsgA0EgaiQADAILIAogAygCGEHA9c4AEP0vAAsgCCADKAIYQcD1zgAQ/S8ACyAMEPQmIAIoAghBAUYEQCACKQMQIREgAQJ+IAEoAsgBQQFGBEAgASkD0AEMAQsgAUIBNwPIAUIACyARfDcD0AELIAIpA0AhESACQcADaiIDIAJByABqQTD8CgAAAkACQCARQgJRDQAgASgCvARBCGogASgCuARBCGoQqxJFDQAgAkHIAmogA0Ew/AoAACACIBE3A8ACIAJCBDcDuAIgAkH4AGogASACQbgCahDnBgwBCyACQgg3A3gLAkACQAJAAn4CfwJAAkACQAJAAkACQAJAIAEoArwELQCdAUEBRgRAQQAhAyACQQA2AqgCIAJCgICAgBA3AqACQQAhBiAHQQBKDQEMAwsgAkKAgICAEDcCoAIgAkEANgKoAiAHQQBMDQEgASgCsAQhBSACQcADaiIDIAcgASgCtAQiBhCrDSADIAUgBhCuCSACQbgCaiIFIANBgAH8CgAAIAJBrAJqIgMgBRDQECACQaACaiACKAKwAiACKAK0AhChNiADEN47DAELIAEoArAEIQUgAkHAA2oiBiAHIAEoArQEIgcQ7RYgBiAFIAcQrgkgAkG4AmoiBSAGQYAB/AoAACACQawCaiIHIAUQ0BAgAkGgAmogAigCsAIgAigCtAIiBhChNiAHEN47DAELIARBAEoEQCABKAKkBCEFIAJBwANqIgMgBCABKAKoBCIHEKsNIAMgBSAHEK4JIAJBuAJqIgUgA0GAAfwKAAAgAkGsAmoiAyAFENAQIAJBoAJqIAIoArACIAIoArQCEKE2IAMQ3jsLIAJBoAJqIgcgAigCLCACKAIwEKE2IAIoAqgCIQUCQCABKAKABEUNACACQbgCaiIIIAVBAEEBQQEQoBggAigCvAIhAyACKAK4AkEBRwRAIAJBADYCyAMgAiACKALAAjYCxAMgAiADNgLAAyAIIAEoAoAEIAIoAqQCIAIoAqgCIAJBwANqIgMgASgChAQoAgwRBwAgAigCuAIiCEEIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgCDYCACADEN47IAcQ3jsMBAsgAkHAAmoiAyACQcgDaigCADYCACACIAIpAsADNwO4AiACQaACahDeOyACQagCaiADKAIANgIAIAIgAikDuAI3A6ACDAELIAMgAigCwAJB2ILPABD9LwALIAJByANqIAJBqAJqKAIANgIAIAIgAikDoAI3A8ADIAJBuAJqIAJBwANqEOcVIAEoArgDIQcgAi0APCEDIAJB0AFqIAJB+ABqQdAA/AoAACACKALEAiEIIAIoAsACIQsgAikDuAIhEUIJIRJBAiEJQQIhCiACKQPIAQwGCyAEQQBKBEAgASgCpAQhBSACQcADaiIDIAQgASgCqAQiBBDtFiADIAUgBBCuCSACQbgCaiIEIANBgAH8CgAAIAJBrAJqIgUgBBDQECACQaACaiACKAKwAiACKAK0AiIDEKE2IAUQ3jsLIAIoAjAiBCADIAZqaiEFIAEoAoAEIghFDQEgAigCqAIhByACQbgCaiAIIAIoAiwgBCACQaACaiIEIAEoAoQEKAIMEQcAIAIoArgCIghBCEYNAiAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAg2AgAgBBDeOwsgAkH4AGoQrCkMBQsgAkGgAmogAigCLCAEEKE2DAELQQEgBSACKAKoAiAHa0sNARogAkGgAmoiBCAHEPQ0IAQgAigCLCACKAIwEKE2C0EACyEEIAJByANqIAJBqAJqKAIANgIAIAIgAikCoAI3A8ADIAJBuAJqIAJBwANqEOcVIAEoArwDIQcgASgCmAMhCCABKAK4AyELIAItADwhDSACKQN4IRIgAkHQAWogAkGAAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiEJIAIpA8ACIREgAikDuAILIRMgASgCaEGAgICAeEcNASACIBI3A7gCIAJBwAJqIAJB0AFqQdAA/AoAACACIAU2ArgDIAIgDToAtQMgAiAEOgC0AyACIAY2ArADIAIgDjoArwMgAiAKOgCuAyACIAk6AK0DIAIgAzoArAMgAiAHNgKoAyACIAg2AqQDIAIgCzYCoAMgAiARNwOYAyACIBM3A5ADIAJBwANqIAEgAkG4AmoQqAogAigCwAMiA0EIRg0CIAAgAikCxAM3AgQgAEEUaiACQdQDaigCADYCACAAQQxqIAJBzANqKQIANwIAIAAgAzYCAAsgAkE0aiACKAIsIAIoAjAgAigCKCgCEBEBAAwCCyACIBI3A7gCIAJBwAJqIAJB0AFqQdAA/AoAACACIAU2ArgDIAIgDToAtQMgAiAEOgC0AyACIAY2ArADIAIgDjoArwMgAiAKOgCuAyACIAk6AK0DIAIgAzoArAMgAiAHNgKoAyACIAg2AqQDIAIgCzYCoAMgAiARNwOYAyACIBM3A5ADIAFBuAJqIAJBuAJqEOogCyABQQA2ArQEIAFBADYCqAQgASABKQPwASABNQK8A3w3A/ABIAwQ6SAgAEEINgIAIAJBNGogAigCLCACKAIwIAIoAigoAhARAQALIAJBwARqJAAL2DYCE38FfiMAQbAEayIDJAAgASkCyAIhGSABQQA2AsgCIANBGGogAUHYAmoiBCgCADYCACADQRBqIgIgAUHQAmoiBykCADcDACAEQQA2AgAgB0KAgICAEDcDACADIBk3AwggA0EAOwGwAiADQQA2AqwCIANBADYClAIgA0EANgKIAiADQRU6APgBIANCBDcC8AEgA0IANwLoASADQoCAgIDAADcC4AEgA0EANgLYASADIAEoAuwCNgKEAiADIAEoAqQDNgL8ASADQegDaiACEPIvIAMgAykC6AM3AogBIANBADYChAEgAyADKAL0AyICNgKAASADIAMoAvADNgJ8IAMgA0H8AGoiBxDXOyADKAIAIQYCQAJAAkACQAJAAkACQAJAAkACQAJAQRxBBBCtNiIEBEAgBEKBgICAEDcCACAEIAMpAnw3AgggBEEQaiADQYQBaikCADcCACAEQRhqIANBjAFqKAIANgIAIAMgAjYCvAIgAyAGNgK4AiADIAQ2ArQCIAcgA0HYAWoiAiADQbQCahD6IyMAQRBrIgQkAAJAIAEoAqACQYGAgIB4RwRAIARBBGogAUGgAmoQ4xwMAQsgBEEANgIECwJAAkACQCABKALoAigCFCIGQQhqIAYoAghBAkZBAnRqLQAgDgQAAQEAAQsgAkEANgIAIAQoAgQiBkUNASAGIAYoAgAiBkEBazYCACAGQQFHDQEgBEEEahD7HgwBCyACIAQpAgQ3AgAgAkEIaiAEQQxqKAIANgIACyAEQRBqJAAgA0EgaiIEIAcgAhCuFiACIAQQzRwgByACEMsSAkACQAJAAkACQAJAIAEtAJgDIgRBI2sOBAECAwQACwJAIARBCkcEQCAEQRNGDQEgA0HYAWoiBCADQfwAakE4/AoAAEHAAEEEEK02IgJFDQggAkKBgICAEDcCACACQQhqIARBOPwKAABBzJrNACEEDA0LIwBBQGoiBSQAIAUgA0H8AGo2AgQgBUEIaiINIAVBBGoiBBD2LyAFIAQQjD42AjggBUEANgI0IAUgBDYCMCAFIAVBP2o2AiwjAEEgayIEJAAgBEEUaiAFQSxqIgcoAgwiAiAHKAIIayIGQQAgAiAGTxtBAEECQQIQoBggBCgCGCECIAQoAhRBAUYNECAFQSBqIQkgBEEQaiIOQQA2AgAgBCAEKAIcNgIMIAQgAjYCCCMAQRBrIgIkACAEQQhqIgYgBygCDCIIIAcoAghrIgtBACAIIAtPGxDtLSACIAYpAgRCIIk3AgggAiAGQQhqNgIEIwBBEGsiBiQAIAJBBGoiCigCBCEIIAooAgAhDwJAAkAgBygCCCILIAcoAgwiDEkEQCAHKAIEIRAgCigCCCAIQQF0aiEKA0AgBkEIaiAQIAsQrC4gBigCDCIRQQFNDQIgCiAGKAIILwAAOwEAIApBAmohCiAIQQFqIQggDCALQQFqIgtHDQALCyAPIAg2AgAgBkEQaiQADAELQQIgEUGQ6NAAELA7AAsgAkEQaiQAIAlBCGogDigCADYCACAJIAQpAgg3AgAgBEEgaiQAIAcgCRDpGCADQdgBaiIEIAcgDRDPHSAFQUBrJABBOEEEEK02IgJFDQ8gAkKBgICAEDcCACACQQhqIARBMPwKAABB8JbNACEEQQEhBQwMCwJAAkACQCABLQCZA0EBaw4CAQIACyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiDSAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBBEEEEKAYIAQoAhghAiAEKAIUQQFGDREgBUEgaiEJIARBEGoiDkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayICJAAgBEEIaiIGIAcoAgwiCCAHKAIIayILQQAgCCALTxsQ7i0gAiAGKQIEQiCJNwIIIAIgBkEIajYCBCMAQRBrIgYkACACQQRqIgooAgQhCCAKKAIAIQ8CQAJAIAcoAggiCyAHKAIMIgxJBEAgBygCBCEQIAooAgggCEECdGohCgNAIAZBCGogECALEKwuIAYoAgwiEUEDTQ0CIAogBigCCCgAADYCACAKQQRqIQogCEEBaiEIIAwgC0EBaiILRw0ACwsgDyAINgIAIAZBEGokAAwBC0EEIBFB4OfQABCwOwALIAJBEGokACAJQQhqIA4oAgA2AgAgCSAEKQIINwIAIARBIGokACAHIAkQ6BggA0HYAWoiBCAHIA0QvR0gBUFAayQAQThBBBCtNiICRQ0QIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQciXzQAhBEEBIQUMDQsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIg4gBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQQRBCBCgGCAEKAIYIQIgBCgCFEEBRg0QIAVBIGohCSAEQRBqIg9BADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiAiQAIARBCGoiBiAHKAIMIgggBygCCGsiC0EAIAggC08bEOotIAIgBikCBEIgiTcCCCACIAZBCGo2AgQjAEEQayIGJAAgAkEEaiIKKAIEIQggCigCACEMAkACQAJAIAcoAggiCyAHKAIMIhBJBEAgBygCBCERIAooAgggCEEDdGohCgNAIAZBCGogESALEKwuIAYoAgwiDUEHTQ0CIA1BC00NAyAKIAYoAggpAAQ3AgAgCkEIaiEKIAhBAWohCCAQIAtBAWoiC0cNAAsLIAwgCDYCACAGQRBqJAAMAgtBCCANQfDn0AAQsDsAC0EMIA1BgOjQABCwOwALIAJBEGokACAJQQhqIA8oAgA2AgAgCSAEKQIINwIAIARBIGokACAHIAkQ6xggA0HYAWoiBCAHIA4Q0x0gBUFAayQAQThBBBCtNiICRQ0PIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQaCYzQAhBEEBIQUMDAsgA0HYAWpBJEEAQQFBARCgGCADKALcASEBIAMoAtgBQQFGDQcgAygC4AEiBEH4mM0AQST8CgAAIABBJDYCDCAAIAQ2AgggACABNgIEIABBATYCAAwMCyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiESAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBBEEEEKAYIAQoAhghAiAEKAIUQQFGDQ4gBUEgaiENIARBEGoiEkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIIJAAgBEEIaiICIAcoAgwiBiAHKAIIayIJQQAgBiAJTxsQ7i0gCCACKQIEQiCJNwIIIAggAkEIajYCBCMAQRBrIgkkACAIQQRqIgYoAgQhAiAGKAIAIAcoAggiCyAHKAIMIg9JBH8gBygCBCETIAIgD2ogC2sgBigCCCACQQJ0aiEOA0AgCUEIaiATIAsQrC4gDgJ/IAkoAgghCiAJKAIMIQYjAEEgayICJAACQCAGQQVJBEAgBkUNASACIAosAABBB3UiDDYCGCACIAYgCmo2AgQgAiAKNgIAIAIQgzsiEARAIBAgBiAGIBBLGyIMBEAgAiAGa0EcaiAKIAz8CgAACyACKAIYIQwLIAJBIGokACAMDAILIAJBATYCBCACQfT8zgA2AgAgAkIBNwIMIAJBOzYCHCACQaD9zgA2AhgMEwtBAEEAQYz9zgAQwyEACyICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycjYCACAOQQRqIQ4gDyALQQFqIgtHDQALBSACCzYCACAJQRBqJAAgCEEQaiQAIA1BCGogEigCADYCACANIAQpAgg3AgAgBEEgaiQAIAcgDRDoGCADQdgBaiIEIAcgERDKHSAFQUBrJAAgA0HoA2ogBCABLQCZAyABLQCaAxCgEyADLQDoAyIEQSlGDQMgA0HPAmoiBSADQfgDaikAADcAACADQcgCaiIHIANB8QNqKQAANwMAIANB4AJqIgYgA0GIBGopAgA3AwAgA0HoAmoiCCADQZAEaikCADcDACADIAMpAOkDNwPAAiADIAMpAoAENwPYAkE4QQQQrTYiAkUNDSACIAQ6AAggAkKBgICAEDcCACACIAMpA8ACNwAJIAIgAykD2AI3AiAgAkERaiAHKQMANwAAIAJBGGogBSkAADcAACACQShqIAYpAwA3AgAgAkEwaiAIKQMANwIAQZyZzQAhBEEBIQUMCgsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIhAgBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQQhBCBCgGCAEKAIYIQIgBCgCFEEBRg0NIAVBIGohDSAEQRBqIhFBADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiCSQAIARBCGoiAiAHKAIMIgYgBygCCGsiCEEAIAYgCE8bEOwtIAkgAikCBEIgiTcCCCAJIAJBCGo2AgQjAEEQayIGJAAgCUEEaiIIKAIEIQIgCCgCACAHKAIIIgsgBygCDCIPSQR/IAcoAgQhEiACIA9qIAtrIAgoAgggAkEDdGohDgNAIAYgEiALEKwuIAZBCGohDCAGKAIAIQogBigCBCEIIwBBIGsiAiQAAkACQCAIQQlJBEAgCEUNASACIAosAABBB3WsIhU3AxggAiAIIApqNgIEIAIgCjYCACAMIAIQgzsiDAR+IAwgCCAIIAxLGyIMBEAgAiAIa0EgaiAKIAz8CgAACyACKQMYBSAVCzcAACACQSBqJAAMAgsgAkEBNgIEIAJB9PzOADYCACACQgE3AgwgAkE7NgIcIAJBpP3OADYCGAwSC0EAQQBBjP3OABDDIQALIA4gBikDCCIVQjiGIBVCgP4Dg0IohoQgFUKAgPwHg0IYhiAVQoCAgPgPg0IIhoSEIBVCCIhCgICA+A+DIBVCGIhCgID8B4OEIBVCKIhCgP4DgyAVQjiIhISENwMAIA5BCGohDiAPIAtBAWoiC0cNAAsFIAILNgIAIAZBEGokACAJQRBqJAAgDUEIaiARKAIANgIAIA0gBCkCCDcCACAEQSBqJAAgByANEL0YIANB2AFqIgQgByAQEMYdIAVBQGskACADQegDaiAEIAEtAJkDIAEtAJoDEKITIAMtAOgDIgRBKUYNCCADQf8CaiIFIANB+ANqKQAANwAAIANB+AJqIgcgA0HxA2opAAA3AwAgA0GQA2oiBiADQYgEaikCADcDACADQZgDaiIIIANBkARqKQIANwMAIAMgAykA6QM3A/ACIAMgAykCgAQ3A4gDQThBBBCtNiICRQ0MIAIgBDoACCACQoGAgIAQNwIAIAIgAykD8AI3AAkgAiADKQOIAzcCICACQRFqIAcpAwA3AAAgAkEYaiAFKQAANwAAIAJBKGogBikDADcCACACQTBqIAgpAwA3AgBB9JnNACEEQQEhBQwJCyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiDiAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBEEEQEKAYIAQoAhghAiAEKAIUQQFGDQwgBUEgaiELIARBEGoiD0EANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIGJAAgBEEIaiICIAcoAgwiCCAHKAIIayIJQQAgCCAJTxsQ6y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQSBrIgIkACAGQQRqIgooAgQhCSAKKAIAIAcoAggiCCAHKAIMIg1JBH8gBygCBCEMIAkgDWogCGsgCigCCCAJQQR0aiEJA0AgAkEIaiAMIAgQrC4gAkEQaiACKAIIIAIoAgwQuRQgAikDGCEVIAkgAikDECIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISENwMIIAkgFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhDcDACAJQRBqIQkgDSAIQQFqIghHDQALBSAJCzYCACACQSBqJAAgBkEQaiQAIAtBCGogDygCADYCACALIAQpAgg3AgAgBEEgaiQAIAcgCxDsGCADQdgBaiIEIAcgDhDLHSAFQUBrJAAgA0HoA2ogBCABLQCZAyABLQCaAxChEyADLQDoAyIEQSlGDQYgA0GvA2oiBSADQfgDaikAADcAACADQagDaiIHIANB8QNqKQAANwMAIANBwANqIgYgA0GIBGopAgA3AwAgA0HIA2oiCCADQZAEaikCADcDACADIAMpAOkDNwOgAyADIAMpAoAENwO4A0E4QQQQrTYiAkUNCyACIAQ6AAggAkKBgICAEDcCACACIAMpA6ADNwAJIAIgAykDuAM3AiAgAkERaiAHKQMANwAAIAJBGGogBSkAADcAACACQShqIAYpAwA3AgAgAkEwaiAIKQMANwIAQayKzQAhBEEBIQUMCAsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIg4gBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQRBBIBCgGCAEKAIYIQIgBCgCFEEBRg0LIAVBIGohCyAEQRBqIg9BADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiCCQAIARBCGoiAiAHKAIMIgYgBygCCGsiCUEAIAYgCU8bEO8tIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEHQAGsiAiQAIAhBBGoiCigCBCEGIAooAgAgBygCCCIJIAcoAgwiDUkEfyAHKAIEIQwgBiANaiAJayAKKAIIIAZBBXRqIQYDQCACQQhqIAwgCRCsLiACQRBqIgogAigCCCACKAIMELsQIAJBMGogChCmKyACKQNIIRUgAikDQCEWIAIpAzghFyAGQRhqIAIpAzAiGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAYQgiIQoCAgPgPgyAYQhiIQoCA/AeDhCAYQiiIQoD+A4MgGEI4iISEhDcDACAGQRBqIBdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQ3AwAgBiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISENwMIIAYgFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhDcDACAGQSBqIQYgDSAJQQFqIglHDQALBSAGCzYCACACQdAAaiQAIAhBEGokACALQQhqIA8oAgA2AgAgCyAEKQIINwIAIARBIGokACAHIAsQ7RggA0HYAWoiBCAHIA4Qzh0gBUFAayQAIANB6ANqIAQgAS0AmQMgAS0AmgMQoxMgAy0A6AMiBEEpRg0EIANB3wNqIgUgA0H4A2opAAA3AAAgA0HYA2oiByADQfEDaikAADcDACADQaAEaiIGIANBiARqKQIANwMAIANBqARqIgggA0GQBGopAgA3AwAgAyADKQDpAzcD0AMgAyADKQKABDcDmARBOEEEEK02IgJFDQogAiAEOgAIIAJCgYCAgBA3AgAgAiADKQPQAzcACSACIAMpA5gENwIgIAJBEWogBykDADcAACACQRhqIAUpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogCCkDADcCAEGUi80AIQRBASEFDAcLIANB0wJqIANB/ANqKAIAIgE2AAAgA0HLAmogA0H0A2opAgAiFTcAACADIAMpAuwDIhY3AMMCIANB6AFqIAE2AgAgA0HgAWogFTcDACADIBY3A9gBIAAgA0HYAWoQpiUMBwtBBEEcEKM9AAtBBEHAABCjPQALIAEgAygC4AFB1P3MABD9LwALIANB4wNqIANB/ANqKAIAIgE2AAAgA0HbA2ogA0H0A2opAgAiFTcAACADIAMpAuwDIhY3ANMDIANB6AFqIAE2AgAgA0HgAWogFTcDACADIBY3A9gBIAAgA0HYAWoQpiUMAwsgA0GzA2ogA0H8A2ooAgAiATYAACADQasDaiADQfQDaikCACIVNwAAIAMgAykC7AMiFjcAowMgA0HoAWogATYCACADQeABaiAVNwMAIAMgFjcD2AEgACADQdgBahCmJQwCCyADQYMDaiADQfwDaigCACIBNgAAIANB+wJqIANB9ANqKQIAIhU3AAAgAyADKQLsAyIWNwDzAiADQegBaiABNgIAIANB4AFqIBU3AwAgAyAWNwPYASAAIANB2AFqEKYlDAELAn9BgICAgHggASgCoAIiB0GBgICAeEYNABpBgICAgHggB0GAgICAeEYNABogASkCpAIhGSABQQA2AqgCIAFCgICAgCA3A6ACIAcLIQcgAUGAA2oQtDAgASAZNwKEAyABIAc2AoADIAEoAtwCIgdBgICAgHhHBEAgASkD4AIhGSABQQA2AuQCIAFCgICAgCA3AtwCCyABQYwDahC0MCABIBk3A5ADIAEgBzYCjAMgAUIANwLsAiAAIAQ2AgggACACNgIEIABBCDYCACAFRQ0BCyADQfwAahDZJAsgA0GwBGokAA8LQQRBOBCjPQALIAIgBCgCHEHE0swAEP0vAAsgAiACQRhqNgIIIAJB/PzOABDvLAALzxwDD38DfgJ8IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgYgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIFQQhHBEAgAygCLCEHIAQgAykDCDcCDCAEIAc2AhwgBCAFNgIIIARCAjcDACAEQRRqIAYpAwA3AgAMAwsgA0E4aiAGKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBSABKAKMASIHKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAUgBygCEBEEAAshBiAEIAMpAzA3AzAgASgCoAEhBSABQQA2AqABIAEpAwAhESABQgA3AwAgASkDECESIAFCADcDECABKQMgIRMgAUIANwMgIAQgASkDKDcDKCAEIBM3AyAgBCABKwMYOQMYIAQgEjcDECAEIAErAwg5AwggBCARNwMAIARBOGogA0E4aikDADcDACAEIAY6AEQgBCAFNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwA3AwAgAkEgaiIDIAJB8ANqKQMANwMAIAIgAikD4AM3AxAgAiARNwMIIAEoAuQEIgQuARohByAELgEYIQQgASABKQPQAyISIAEpA7ACfDcDsAIgAUGoAWogAUHQA2ohDAJ/AkAgEadBAXEEQCACKAIYDQELIAJCAjcDUEEADAELIAMrAwAhFAJAIAIrAxAiFSAVYg0AIAEoAsgBQQFGBEAgASsD0AEgFWRFDQELIAEgFTkD0AEgAUIBNwPIAQsCQCAUIBRiDQAgASgC2AFBAUYEQCAUIAErA+ABZEUNAQsgASAUOQPgASABQgE3A9gBCyABLQD6BEECRwRAIAJCAjcDUEEADAELIAJBgQI2ApABIAIgEjcDiAEgAkIBNwOAASACQgA3A3AgAiAUOQNoIAJCATcDYCACIBU5A1ggAkIBNwNQIAJB0ABqCyEGIAIpAyghESACKQMwIRIjAEEgayIDJAAgAS0AzAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1AvQDIhMgASkD0ANSBEAgBUEBcUUNByAGRQ0BIAYoAgBFDQMgBigCEEUNBCAGQQhqIQggBkEYaiEFIAEoAtACDQIgCCsDACEUDAYLIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUGAA2pBASADIANBEGogExCVFAwGCyABQQA6AMwDDAULIAgrAwAhFCABLQD4BEUNAiABKwPYAiAUZEUEQCABKwPgAiAFKwMAZEUNAwsgAUEAOgD4BAwCC0HIgM8AELI7AAtB2IDPABCyOwALIAEtAPkERQ0AIBQgASsD2AJkRQRAIAUrAwAgASsD4AJkRQ0BCyABQQA6APkECyABQYADaiELIAEgFDkD2AIgAUIBNwPQAiABIAUrAwA5A+ACIAEQ5R8EQCADIAEgASgC6AQiCSgCOCAJKAI8IAhBCBCaDSADQRBqIgggASABKALoBCIJKAI4IAkoAjwgBUEIEJYMIAtBACADIAggASkD0AMQlRQMAQsgA0EQaiIJQQhBAEEBQQEQoBggAygCFCEKIAMoAhBBAUYNASADKAIYIhAgCCkDADcAACADQQg2AgggAyAQNgIEIAMgCjYCACAJQQhBAEEBQQEQoBggAygCFCEIIAMoAhBBAUYNAiADKAIYIgogBSkDADcAACADQQg2AhggAyAKNgIUIAMgCDYCECALQQAgAyAJIAEpA9ADEJUUCyABQYADaiABQdgDaiABQeQDahCWEyABKAKABEGAgICAeEcEQCABQfgDaiIFIAE1AvQDEKYnIAUgESASENcZCyADQSBqJAAMAgsgCiADKAIYQcD1zgAQ/S8ACyAIIAMoAhhBwPXOABD9LwALIAwQ9SYgAigCKEEBRgRAIAIpAzAhESABAn4gASgC+AFBAUYEQCABKQOAAgwBCyABQgE3A/gBQgALIBF8NwOAAgsgAikDUCERIAJB4ANqIgMgAkHYAGpBwAD8CgAAAkACQCARQgJRDQAgASgC6ARBCGogASgC5ARBCGoQqxJFDQAgAkHoAmogA0HAAPwKAAAgAiARNwPgAiACQgU3A9gCIAJBmAFqIAEgAkHYAmoQ6AYMAQsgAkIINwOYAQsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgC6AQtAJ0BQQFGBEBBACEDIAJBADYCyAIgAkKAgICAEDcCwAJBACEGIAdBAEoNAQwDCyACQoCAgIAQNwLAAiACQQA2AsgCIAdBAEwNASABKALcBCEFIAJB4ANqIgMgByABKALgBCIGEKsNIAMgBSAGEK4JIAJB2AJqIgUgA0GAAfwKAAAgAkHMAmoiAyAFENAQIAJBwAJqIAIoAtACIAIoAtQCEKE2IAMQ3jsMAQsgASgC3AQhBSACQeADaiIGIAcgASgC4AQiBxDtFiAGIAUgBxCuCSACQdgCaiIFIAZBgAH8CgAAIAJBzAJqIgcgBRDQECACQcACaiACKALQAiACKALUAiIGEKE2IAcQ3jsMAQsgBEEASgRAIAEoAtAEIQUgAkHgA2oiAyAEIAEoAtQEIgcQqw0gAyAFIAcQrgkgAkHYAmoiBSADQYAB/AoAACACQcwCaiIDIAUQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwsgAkHAAmoiByACKAI8IAIoAkAQoTYgAigCyAIhBQJAIAEoArgERQ0AIAJB2AJqIgggBUEAQQFBARCgGCACKALcAiEDIAIoAtgCQQFHBEAgAkEANgLoAyACIAIoAuACNgLkAyACIAM2AuADIAggASgCuAQgAigCxAIgAigCyAIgAkHgA2oiAyABKAK8BCgCDBEHACACKALYAiIIQQhHBEAgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAMQ3jsgBxDeOwwECyACQeACaiIDIAJB6ANqKAIANgIAIAIgAikC4AM3A9gCIAJBwAJqEN47IAJByAJqIAMoAgA2AgAgAiACKQPYAjcDwAIMAQsgAyACKALgAkHYgs8AEP0vAAsgAkHoA2ogAkHIAmooAgA2AgAgAiACKQPAAjcD4AMgAkHYAmogAkHgA2oQ5xUgASgC8AMhByACLQBMIQMgAkHwAWogAkGYAWpB0AD8CgAAIAIoAuQCIQggAigC4AIhCyACKQPYAiERQgkhEkECIQlBAiEKIAIpA+gBDAYLIARBAEoEQCABKALQBCEFIAJB4ANqIgMgBCABKALUBCIEEO0WIAMgBSAEEK4JIAJB2AJqIgQgA0GAAfwKAAAgAkHMAmoiBSAEENAQIAJBwAJqIAIoAtACIAIoAtQCIgMQoTYgBRDeOwsgAigCQCIEIAMgBmpqIQUgASgCuAQiCEUNASACKALIAiEHIAJB2AJqIAggAigCPCAEIAJBwAJqIgQgASgCvAQoAgwRBwAgAigC2AIiCEEIRg0CIAAgAikC3AI3AgQgAEEUaiACQewCaigCADYCACAAQQxqIAJB5AJqKQIANwIAIAAgCDYCACAEEN47CyACQZgBahCsKQwFCyACQcACaiACKAI8IAQQoTYMAQtBASAFIAIoAsgCIAdrSw0BGiACQcACaiIEIAcQ9DQgBCACKAI8IAIoAkAQoTYLQQALIQQgAkHoA2ogAkHIAmooAgA2AgAgAiACKQLAAjcD4AMgAkHYAmogAkHgA2oQ5xUgASgC9AMhByABKALQAyEIIAEoAvADIQsgAi0ATCENIAIpA5gBIRIgAkHwAWogAkGgAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiEJIAIpA+ACIREgAikD2AILIRMgASgCeEGAgICAeEcNASACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAU2AtgDIAIgDToA1QMgAiAEOgDUAyACIAY2AtADIAIgDjoAzwMgAiAKOgDOAyACIAk6AM0DIAIgAzoAzAMgAiAHNgLIAyACIAg2AsQDIAIgCzYCwAMgAiARNwO4AyACIBM3A7ADIAJB4ANqIAEgAkHYAmoQpAogAigC4AMiA0EIRg0CIAAgAikC5AM3AgQgAEEUaiACQfQDaigCADYCACAAQQxqIAJB7ANqKQIANwIAIAAgAzYCAAsgAkHEAGogAigCPCACKAJAIAIoAjgoAhARAQAMAgsgAiASNwPYAiACQeACaiACQfABakHQAPwKAAAgAiAFNgLYAyACIA06ANUDIAIgBDoA1AMgAiAGNgLQAyACIA46AM8DIAIgCjoAzgMgAiAJOgDNAyACIAM6AMwDIAIgBzYCyAMgAiAINgLEAyACIAs2AsADIAIgETcDuAMgAiATNwOwAyABQfACaiACQdgCahDqIAsgAUEANgLgBCABQQA2AtQEIAEgASkDkAIgATUC9AN8NwOQAiAMEOkgIABBCDYCACACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAsgAkHgBGokAAvHMgMdfwV+AXwjAEHQDGsiAiQAAkACQAJAAkACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQCIA0EBaw4DCwIBAAsgAEHAAWogAEHAAfwKAAALAkACQAJAAkACQAJAAkACQAJAAkAgAC0A+AJBAWsOAxIKAQALIAJBKGogACgC8AIgACgC9AIQ+iggAkHAAWogAigCKCACKAIsEI81IAAgACsDwAEiJPwDIhM2AswBIAAgJEQAABAAAADwQWIiCDYCyAEgAEHQAWogAkEwakGcAfwKAAAgAEEAOgDsAiAAQewCaiEXIABByAFqIRwMAQsgAEHIAWohHCAAQewCaiEXAkAgAC0A7AJBAWsOAwsJAgALIAAoAswBIRMgACgCyAEhCAsgACATNgLUASAAIAg2AtABIABBADoA8AEgACAAKQPgAjcD2AEgAEHgAWogAEHoAmooAgA2AgAgAEHwAWohEyAAQdABaiEYDAELIABB0AFqIRggAEHwAWohEwJAIAAtAPABQQFrDgQNBwIGAAsgGCgCACEICyAAQYACOwDxASAAIAApAtgBNwLkASAAQewBaiAAQeABaigCADYCACAIQQFxRQ0BIAAoAtQBIQgMDwsgAEH0AWohECAAQYQCaiEMAkAgAC0AhAJBAWsOAwkFAAILIAAoAoACIQkMAgsgAkHYCWogAEHkAWoQ3SAgAEEAOgCEAiAAQfwBaiACQeAJaikCADcCACAAIAIpAtgJNwL0ASAAQYQCaiEMIABB9AFqIRALIAJB2AVqIgQgEEEIaigCADYCACACIBApAgA3A9AFIAJBIGohAwJAQTBBBBCtNiIHBEAgB0EAOgAsIAdBADoAKCAHQQA2AiAgB0EAOgAcIAdBADYCFCAHQQA6ABAgB0EANgIIIAdCgoCAgBA3AgAgAyAHNgIEIAMgBzYCAAwBC0EEQTAQoz0ACyACKAIkIQkgAigCICEDQbgHQQgQrTYiCEUNBSAIIAM2AqAHIAggAikD0AU3AqQHIAhBADoAsAcgCEGsB2ogBCgCADYCACAIQeTGwgAQ1BogACAJNgKAAgsgAkEYaiEHIwBBEGsiDSQAAn8CQCAJQQhqIgktACQNACANQQhqIAEoAgAiAygCBCADKAIAKAIAEQAAIAktABQgDSgCDCESIA0oAgghBCAJQQE6ABRFBEAgCSgCDCIDBEAgCSgCECADKAIMEQMACyAJQQA6ABQgCSASNgIQIAkgBDYCDCAJLQAkDQFBAgwCCyASIAQoAgwRAwALIAktAAghAyAJQQE6AAhBASADDQAaIAlBADoACCAJKAIAIAlBADYCACAJKAIEIRJBAXMLIQMgByASNgIEIAcgAzYCACANQRBqJABBAiEJAkAgAigCGCIDQQJGBEAgDEEDOgAADAELIAIoAhwhCCAAQYACahCsLCADQQFxDQcgDEEBOgAAQQAhCQsgCUECRgRAQQMhCAwRCyAQEJIuIAlBAXFFDQtBBEEEEK02IgNFBEBBBEEEEKM9AAsgAkGQCGoiASADNgIEIAMgCDYCACABQQM2AgAMDgsgAEHAAmohDCAAQdwCaiEQAkAgAC0A3AJBAWsOAwgBAAILIAAoAtgCIQkgACgC1AIhCAwMCwALIAAoAsgCIQggACkDwAIMCQtB/NzCABDoKwALQQhBuAcQoz0AC0G82sIAEOgrAAtBxMrCAEErIAJB0AVqQbTKwgBBzNrCABDVHgALQZzbwgAQ6CsAC0H01sIAEOgrAAtBjN3CABDoKwALQdzIwgAQ6CsACyAAQQA6APIBIAJB4AlqIABB7AFqKAIANgIAIAIgACkC5AE3A9gJQQxBBBCtNiIERQRAQQRBDBCjPQALIAQgAkHYCWoiAykCADcCACAEQQhqIANBCGooAgA2AgAgAkHoBGoiA0IANwMgIANBgCA2AjAgA0GImMMANgIcIAMgBDYCGCADQQA2AhAgA0KAgICAEDcDCCADQgA3AwAgAyAIrTcDKCAAQYgCaiADQTj8CgAAIABBAToA8QEgAEIDNwP4ASAAQQA6ANwCIAAgAEH4AWoiCDYCyAIgAEIANwPAAiAAQdwCaiEQIABBwAJqIQxCAAs3AswCIAJBADoAyAwgAiAINgLADCACIABBzAJqNgLEDCACQRBqIQcgAkHYCWohAwJAQfgCQQgQrTYiBARAIAQgA0H4AvwKAAAgB0HI+MIANgIEIAcgBDYCAAwBC0EIQfgCEKM9AAsgAigCECEIIAAgAigCFCIJNgLYAiAAIAg2AtQCCyACQdgJaiAIIAEgCSgCDBEBAAJAAkAgAigC2AkiBEEJRgRAIBBBAzoAAAwBCyACQaAGaiIBIAJB6AlqKQMANwMAIAIgAikD4Ak3A5gGIAIoAtwJIQMgAEHUAmoQvCoCQCAEQQhHBEAgAkHgBWogASkDADcDACACIAIpA5gGNwPYBSACIAM2AtQFIAIgBDYC0AUgACgCzAIiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEHMAmoQ+CMMAQsgAiAAKQLMAjcD2AkgAkHQBWogAyACQdgJahDtAQsgAkHIBWoiASACQdwFaigCADYCACACIAIpAtQFNwPABSACKQPgBSEfIAIoAtAFIQQgEEEBOgAAIARBCUcNAQtBBCEIDAMLIAJBuAVqIgMgASgCADYCACACIAIpA8AFNwOwBSAMEN8gAkAgBEEIRwRAIAJB5AlqIAMoAgA2AgAgAiACKQOwBTcC3AkgAiAfNwPoCSACIAQ2AtgJIAJBkAhqIAJB2AlqEMgmIAJCBTcDiAgMAQsgAkGoBWogAkG4BWooAgA2AgAgAiACKQOwBTcDoAUgAEEAOgDxASACQdAFaiIMIABB+AFqQcgA/AoAACACQYCAgIB4NgK4BiACQQA2ApgGIAJBgICAgHg2AsQGIAJBADYCqAYgAkEANgKgBiACQQA2ArAGIAJB2AlqIQQgAkGYBmohAyMAQbABayIPJAAgDyACQaAFahDFCiAPKAIMIQkgDygCCCENIA8oAgQhBwJAIA8oAgAiAUEGRwRAIAQgCTYCFCAEIA02AhAgBCAHNgIMIAQgATYCCCAEQgQ3AwACQCAMKAIYQYCAgIB4RwRAIAxBGGoQ3jsMAQsgDCgCECEHIAwoAhQiBCgCACIBBEAgByABEQMACyAEKAIEIgFFDQAgByABIAQoAggQ+DoLIAwoAighByAMKAIsIgQoAgAiAQRAIAcgAREDAAsgBCgCBCIBRQ0BIAcgASAEKAIIEPg6DAELIA9BEGoiASAMQcgA/AoAACAPQYAINgKkASAPIAk2AqABIA8gDTYCnAEgDyAHNgKYASAPQYCAgIB4NgKMASAPQYCAgIB4NgKAASAPQYCAgIB4NgJ0IA9BgICAgHg2AmggD0KAgICAgICAoAY3A6gBIA9BADYCYCAPQQA2AlgjAEGwAmsiBSQAIAMoAgBBAUYEQCABIAEoAogBKAIIIg0gAygCBCIHIAcgDUsbNgKUAQsgAygCCEEBRgRAIAFBATYCSCABIAMoAgw2AkwLIAMoAhBBAUYEQCABQQE2AlAgASADKAIUNgJUCwJAIAMoAixBgICAgHhHBEAgASgCiAFBCGoQhTwhByAFQZABaiADKAIwIAMoAjQgBxDSEyAFQdAAaiINIAVBnAFqKAIANgIAIAUgBSkClAE3A0ggBSgCkAEiB0EGRwRAIAQgBSkDSDcCDCAEIAc2AgggBEIENwMAIARBFGogDSgCADYCAAJAIAEoAhhBgICAgHhHBEAgAUEYahDeOwwBCyABKAIQIQ0gASgCFCIHKAIAIgQEQCANIAQRAwALIAcoAgQiBEUNACANIAQgBygCCBD4OgsgASgCKCENIAEoAiwiBygCACIEBEAgDSAEEQMACyAHKAIEIgQEQCANIAQgBygCCBD4OgsgAUGIAWoiBygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgBxCXFQsgASgCjAEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAFBjAFqEPgjCwJAIAEoApABIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBkAFqENseCyABQdgAahCXMCABQeQAahCGMCABQfAAahCeLyABQfwAahCOMCABKAKYASIERQ0CIAQgBCgCACIEQQFrNgIAIARBAUcNAiABQZgBahCBLAwCCyAFQTBqIhkgDSgCADYCACAFIAUpA0g3AyggBUGQAWogAUGgAfwKAAAgBUHIAGoiBiABQcgA/AoAACAFQUBrIhogAUHgAGoiCCgCADYCACAFQSBqIgwgAUH4AGoiCSgCADYCACAFQRBqIg0gAUGEAWoiBygCADYCACAFIAEpA1g3AzggBSABKQNwNwMYIAUgASkCfDcDCCAFKQOYAiEgIAUpA6ACISEgBSkDqAIhIiAFKQPYASEjIAUpA+ABIR8gBUH0AWoQhjAgASAGQcgA/AoAACABIB83A1AgASAjNwNIIAEgBSkDODcDWCAIIBooAgA2AgAgASAFKQMoNwJkIAFB7ABqIBkoAgA2AgAgASAFKQMYNwNwIAkgDCgCADYCACABIAUpAwg3AnwgByANKAIANgIAIAEgIjcDmAEgASAhNwOQASABICA3A4gBCyADKAIgQYCAgIB4RwRAIAVBkAFqIgcgAUGgAfwKAAAgBUE4aiADQSBqEIkdIAVByABqIgYgB0HIAPwKAAAgBUEwaiIJIAVB/AFqKAIANgIAIAVBIGoiDSAFQYgCaigCADYCACAFQRBqIgcgBUGUAmooAgA2AgAgBSAFKQL0ATcDKCAFIAUpA4ACNwMYIAUgBSkCjAI3AwggBSkDmAIhICAFKQOgAiEhIAUpA6gCISIgBSkD2AEhIyAFKQPgASEfIAVB6AFqEJcwIAEgBkHIAPwKAAAgASAfNwNQIAEgIzcDSCABIAUpAzg3A1ggAUHgAGogBUFAaygCADYCACABIAUpAyg3AmQgAUHsAGogCSgCADYCACABIAUpAxg3A3AgAUH4AGogDSgCADYCACABIAUpAwg3AnwgAUGEAWogBygCADYCACABICI3A5gBIAEgITcDkAEgASAgNwOIAQsgBCABQaAB/AoAAAsgBUGwAmokAAsgD0GwAWokACACQcgFaiIBIAJB6AlqKQMANwMAIAIgAikD4Ak3A8AFAkACQCACKQPYCSIfQgRRBEAgAkGYCGogASkDADcDACACIAIpA8AFNwOQCCACQgU3A4gIIAMQgSoMAQsgAkHoBmogAkHwCWoiBUGIAfwKAAAgAkHgBmogAkHIBWopAwA3AwAgAiAfNwPQBiACIAIpA8AFNwPYBiACQZgGahCBKiACQdgJaiELIwBB4AFrIgYkACAGQSBqIAJB0AZqIgooAogBIhBBCGoiARCEPCAGIAYoAiQiBDYCLCAKQYgBaiEHAkACfwJAIAooAlhBgICAgHhHBEAgBkHYAWogCkHYAGoiAUEIaigCACIbNgIAIAYgASkCADcD0AEgG0ECdCEDQQAhDCAGKALUASESA0AgAyAMRg0CIAwgEmogDEEEaiEMKAIAIARJDQALIAYgDCASakEEazYCMCAGQQI2AowBIAZB4NbDADYCiAEgBkICNwKUASAGQTs2AkwgBkHcATYCRCAGIAZBQGs2ApABIAYgBkEsajYCSCAGIAZBMGo2AkAgC0EMaiAGQYgBahCZDiALQgU3AwAgC0EANgIIIAZB0AFqEOk7IAoQ/RsgCigCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIAcQlxULIAooAowBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAKQYwBahD4IwsCQCAKKAKQASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAKQZABahDbHgsgCkHkAGoQhjAgCkHwAGoQni8gCkH8AGoQjjAgCigCmAEiAUUNAyABIAEoAgAiAUEBazYCACABQQFHDQMgCkGYAWoQgSwMAwsgBkEYaiABEIQ8IAZBiAFqIAYoAhxBkNDDABCKOyAGKAKQASEbIAYoAowBIRIgBygCACEQIAYoAogBDAELIAYoAtABCyEPIBAoAgghHSAKKAKUASEeIAZBiAFqIgQgCkHIAPwKAAAgBkHYAWoiAyAKQfgAaigCADYCACAKKQJwIR8gECAQKAIAIgFBAWo2AgAgBiAfNwPQAQJAIAFBAE4EQCAKKAKcASEZIAooApgBIRogCigCVCEIIAooAlAhDCAKKAJMIQkgCigCSCENIAooApABIRYgBkFAayAEQcgA/AoAACAGQThqIAMoAgA2AgAgBiAGKQPQATcDMAJAAn8gFgRAIBYtABRBIEcNAiAGQRBqIwBBMGsiESQAIBEgCkHkAGo2AgAgEUEEaiEUIwBBQGoiDiQAIA4gETYCDCAOQQA2AhAgFkEYaiIBKAIEIQMgASgCACEBIA4gDkEQajYCGCAOIA5BDGo2AhQgDiABQQhqIgE2AjAgDiABIANBAnRqNgI0IA4gDkEUajYCOCAOQRxqIA5BMGoQixcgDkEgaiEVAkAgDigCHCIEQZOAgIB4RwRAIBQgDigCLDYCECAUIBUpAgA3AgQgFEEMaiAVQQhqKAIANgIADAELIA5BOGogFUEIaigCACIDNgIAIA4gFSkCADcDMCAOIA4oAjQiASABIANBAnRqEJsYIA4pAwAhHyAVEPglIA5BMGpBBEEEEOAeIBQgHzcCBAsgFCAENgIAIA5BQGskACARKAIEQZOAgIB4RwRAIBFBKGogEUEUaigCADYCACARQSBqIBFBDGopAgA3AwAgESARKQIENwMYQbDQwwBBKyARQRhqQaDQwwBB2M/DABDVHgALIBEpAgg3AwAgEUEwaiQAIAYoAhAhBCAGKAIUDAELIAZBCGoQwSwgBigCCCEEIAYoAgwLIQMgBkGIAWoiASAEIAMQzhxBMEEIEK02IgNFDQIgA0KBgICAEDcDACADQQhqIAFBKPwKAAAgCyAKKQJkNwKoASALQbABaiAKQewAaigCADYCACALIAopAnw3ArQBIAtBvAFqIApBhAFqKAIANgIAIAooAogBIQEgCyAGQUBrQcgA/AoAACALIB0gHiAdIB5JGzYCyAEgCyADNgLEASALIAE2AsABIAtBgYCAgHg2AogBIAsgGzYChAEgC0EANgKAASALIBI2AnwgCyAPNgJ4IAsgGTYCcCALIBo2AmwgCyAWNgJoIAsgEDYCZCALIAg2AlQgCyAMNgJQIAsgCTYCTCALIA02AkggC0HgAGogBkE4aigCADYCACALIAYpAzA3A1ggCigCjAEiASABKAIAIgFBAWs2AgAgAUEBRw0DIApBjAFqEPgjDAMLIAZBADYCmAEgBkEBNgKMASAGQbjXwwA2AogBIAZCBDcCkAEgBkGIAWpBwNfDABDvLAsAC0EIQTAQoz0ACyAGQeABaiQAIAJB+AdqIAJB6AlqKQMANwMAIAJBgAhqIAUpAwA3AwAgAiACKQPgCTcD8AcgAkGQCGohASACKQPYCSIfQgVSDQEgASACQfAHahDIJiACQgU3A4gICyACQaAFahCyHwwBCyACQagIaiACQfgJakGwAfwKAAAgAUEQaiACQYAIaikDADcDACABQQhqIAJB+AdqKQMANwMAIAEgAikD8Ac3AwAgAkGgBWoQsh8gAEEAOwDxAQwCCyAALQDxAQRAIABB+AFqEP0bCyAAQQA6APEBCyAALQDyAQRAIABB5AFqEN47CyAAQQA6APIBQgUhHwsgAkHQAWogAkGQCGpByAH8CgAAQQEhCCATQQE6AAAgGBDNIgJ/IB9CBVEEQCACQeAJaiACQdgBaikDADcDACACIAIpA9ABNwPYCSACQdgJahDTGQwBCyACQbADaiACQeABakG4AfwKAAAgAkGoA2ogAkHYAWopAwA3AwAgAiAfNwOYAyACIAIpA9ABNwOgA0EAIQgCfyMAQRBrIgMkAEHQAUEIEK02IgEEQCABIAJBmANqQdAB/AoAACADQQhqIAFB/M/DABCAKSADKAIIIAMoAgwQzSwQgSkgA0EQaiQADAELQQhB0AEQoz0ACwshASAXQQE6AAAMAQsgEyAIOgAAIBdBAzoAAEECIQgLAkAgCEECRgRAQQMhASAAQQM6APgCDAELIBwQ9SwgAEEBOgD4AgJAIAhBAXEEQCACIAE2AogIIAJBgAE2AtgJIAIgAEGEA2ogAkHYCWogAkGICGoQwiMgAigCACACKAIEENYvIgFBhAFPBEAgARDyHwsgAigC2AkiAUGEAU8EQCABEPIfCyACKAKICCIBQYQBSQ0BIAEQ8h8MAQsgAiABNgKICCACQYABNgLYCSACQQhqIABBgANqIAJB2AlqIAJBiAhqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoAtgJIgFBhAFPBEAgARDyHwsgAigCiAgiAUGEAUkNACABEPIfCyAAKAKAAyIBQYQBTwRAIAEQ8h8LQQEhASAAKAKEAyIDQYQBSQ0AIAMQ8h8LIAAgAToAiAMgAkHQDGokACAIQQJGC/4RAx1/A30CfiMAQRBrIhYkACAHKAIUIRQgASACIAggCSANIA4gDyAQEIYPIA0oAgwiCSACSwRAIAkgDkEAIA4oAuABIhNrQQdxQRxsaiISKAIQIhFLBEBBAiEXIA0oAggiISACQQJ0aiEiAkACQCACQQJqIhggAEsNACASKgIYIA0qApQWkiAiKgIAICEgEUECdGoqAgCTkiEuIAJBFGwgD2pBLGohEUEKIQlBBCESA0AgAiAXaiAQTw0CIBFBBGsoAgAEfUMAAAAABSARKgIACyAuX0UNASAuQwAAgD+SIC4gF0EBaiIXIAlGIhsbIS4gEUEUaiERIBJBACAbGyAJaiEJIBIgG3QhEiACIBdqIABNDQALCwJAIBNFBEBBACEUDAELIAggASACaiIcIAggHEkbISNBlgFBxQIgFEELSCIBGyEoIAAgAmshJCATQQFBBSABGyIAIAAgE0sbISkgDUEQaiElIAMgBSAccSIdaiEqIAQgHWshKyAXQQFrIRsgBzUCBCEyIAcoAgghLCANKAIAISYgDSgCBCEeQQAhFEEAIRgDQAJAAkACQAJAIAIgDiAYIgAgDigC4AFrQQdxQRxsaiIZKAIQayITQQZPBEAgE0GCAU8EQCATQcIQSQ0CQRUhASATQcIwSQ0EQRZBFyATQcKwAUkbIQEMBAsgE0ECayIBZ0EgakE/c0EBayIHQQF0IAEgB3ZqIgdBAmoiAUH//wNxIREgB0EWTw0CDAQLIBMhAQwCCyATQcIAa2dBIGpBP3NBCmohAQwBCyARQRhBhLPQABDDIQALIAFB//8DcSERCyAAQQFqIRggGSoCFCARQQJ0QYif4gBqKAIAs5IgIioCACAhKgIAk5IhLiABQQN0QThxISAgAUH4/wNxQQN2QQNsISdBACEIIBshBwJAAkADQAJAIAcgJE8NACAHIB1qIg0gBE8NAiAFIA1JDQAgJiAIQQJ0aiEJIAhBG3RBgICAQGshEiADIA1qLQAAIRogCCERA0ACQCAZIBFBhLHQAGotAABBA3FBAnRqKAIAIBFBlLHQAGosAABqIh8gI0sNACAcIB9rIgggHE8NACAFIAhxIgggB2oiDSAFSw0AAkACQAJAAkACQAJAIAQgDUsEQCAaIAMgDWotAABHDQcgBCAISQ0BIAQgHUkNAiADIAhqIAQgCGsgKiArICQQsiAgCCAGEKEuIQ0gESAeTw0DAkAgByANTw0AIC4gCSoCAJIhMCASIBNyIRogB0EBaiEJIBFFIAFB//8DcUEISXFFIRUDQEH+/wMhEgJ9AkAgCUEKTwR/IAlBhgFPBEBBFyEHIAlBxhBJBEAgCUHGAGtnQSBqQT9zQQxqIQcLIAdBB3EgIHIhCCAHIRIMAgtBBCESIAlBBmsiB2dBIGpBP3NBAWsiCEEBdCAHIAh2agUgCQsgEmoiEkEHcSAgciEIIBUgEkH//wNxIgdBD0tyRQRAIAggCEHAAHIgB0EISRshEiAuIAdBAnRByKDiAGooAgCzkgwCCyAHQRhPDQgLIAggEkH4/wNxQQN2ICdqIhJBBnRBwJrIAiASQQF0dkHAAXFqQUBrIi1yQf//A3EhEiAtQcD/A3EiCEHABU8NCCAuIDAgCEGAAUkbIAdBAnRByKDiAGooAgCzkgsgAiAJaiIHIBBPDQggJSASQQJ0aioCAJIhLyAPIAdBFGxqIgcoAgAEfUMAAAAABSAHKgIECyAvXgRAIAcgGjYCECAHIB82AgwgByAvOAIEIAdBADYCACAHIAlBgICAkAFyNgIIIAkgFCAJIBRLGyEUCyAJIA1JIggEQCAIIAkiB2oiCCEJIAggDU0NAQwCCwsgCSEHCyARQQFqIQggEUEOSw0JDAoLIA0gBEG0sdAAEMMhAAsgCCAEQcSx0AAQrzsACyAdIARB1LHQABCvOwALIBEgHkG8tdAAEMMhAAsgB0EYQaSy0AAQwyEACyASQcAFQay10AAQwyEACyAHIBBB5LHQABDDIQALIAlBBGohCSASQYCAgEBrIRIgEUEBaiIRQRBHDQALCwsgCkUgAEEBS3INAUEAIRIgFyERAkADQCAMIBJGDQEgCyASQQN0aikDACExIBZBADsBCiAWQQA2AgwgMaciGUEPaiAsIDIgFkEKaiAWQQxqEJYYIBYvAQoiAUH/B3EiACAeSQRAIBEgMUIliKciByAHIBFJGyIIIAggESAHIChLGyAZICNLIh8bIhEgB00EQCAuIAFBCnazkiAmIABBAnRqKgIAkiEvIAdBAWohASARQRl0QYCAgJABaiEAIDFCIIinQR9xIgggByAIGyEaIA8gAiARakEUbGohCQNAQf7/AyEIIBogESAfGyIHIQ0CQAJAAkACQAJAIAdBCk8EfyAHQYYBTwRAQRchDSAHQcYQSQRAIAdBxgBrZ0EgakE/c0EMaiENCyANIQgMAgsgB0EGayIIZ0EgakE/c0EBayINQQF0IAggDXZqIQ1BBAUgCAsgDWoiCEH//wNxIg1BGE8NAQsgCEH4/wNxQQN2ICdqIhVBBnRBwJrIAiAVQQF0dkHAAXFqQUBrIhUgCEEHcSAgcnJB//8DcSEIIBVBwP8DcUHABU8NASACIBFqIhUgEE8NAiAJKAIADQMgLyANQQJ0Qcig4gBqKAIAs5IgJSAIQQJ0aioCAJIiMCAJQQRqIggqAgBdRQ0DIAlBADYCACAJQRBqIBM2AgAgCUEMaiAZNgIAIAggMDgCACAJQQhqIAAgB0EZdGsgEXI2AgAgESAUIBEgFEsbIRQMAwsgDUEYQaSy0AAQwyEACyAIQcAFQay10AAQwyEACyAVIBBBhLLQABDDIQALIAlBFGohCSAAQYCAgBBqIQAgASARQQFqIhFHDQALIAEhEQsgEkEBaiISIApHDQEMBAsLIAAgHkG8tdAAEMMhAAsgDCAMQfSx0AAQwyEACyANIARBpLHQABDDIQALIBggKUcNAAsLIBZBEGokACAUDwsgECAYIBAgGEsbIBBB7LTQABDDIQALIBEgCUHctdAAEMMhAAsgAiAJQcy10AAQwyEAC6xMAh5/CH4jAEHQAmsiAyQAIAMgATYCIAJAAkACQAJAAkAgAigCACIFBEAgAyAFNgIkIAUgBSgCACICQQFqNgIAIAJBAEgNAiADIAE2ArgBIAEoAjQhASADIAU2ArwBIANBgICAgHg2AqACIANBKGogAUEIaiADQaACaiAFQQhqIgEQsAoCQAJAIAMoAigiAkGCgICAeEYEQCADQfwBaiADQUBrKQMAIiE3AgAgA0H0AWogA0E4aikDACIiNwIAIAMgAykDMCIjNwLsASAAQRBqICE3AgAgAEEIaiAiNwIAIAAgIzcCAAwBCyADQYACaiADQcQAaigCACIFNgIAIANB+AFqIANBPGopAgAiITcDACADQcwBaiADQTRqKQIANwIAIANB1AFqICE3AgAgA0HcAWogBTYCACADIAMpAiw3AsQBIAMgAykDSCIhNwLgASADIAI2AsABIAMgITcChAIgA0EYaiADQYQCaiICEMM0IAMgAygCHCIFNgKMAiADQRBqIAEQwzQgAyADKAIUIgc2ApACAkAgBSAHRgRAIANBADYCnAIgA0KAgICAwAA3ApQCIANBCGogARDDNCADKAIMIQUgAygCCCEBIAMgAhDDNCADQaACaiABIAEgBUECdGogAygCACIBIAEgAygCBEECdGoQiyggAygCtAIiAiADKAKwAiIBSwRAIAIgAWshAiABQQJ0IgEgAygCoAJqIQUgAygCqAIgAWohAQNAIAUoAgBBMGogASgCAEEwahC5CEUEQCADIAUoAgBBPGo2AsQCIAMgBSgCAEEwajYCyAIgAyABKAIAQTBqNgLMAiADQQA2AvgBIANBAzYC7AEgA0H4p88ANgLoASADQa8DNgI8IANBrwM2AjQgA0GEATYCLCADIANBzAJqNgI4IAMgA0HIAmo2AjAgAyADQcQCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakGQqM8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAgsgBSgCACIILQBIIAEoAgAiBy0ASEcEfyADIAhBPGo2AswCIAMgBSgCAC0ASDoAxAIgAyABKAIALQBIOgDIAiADQQA2AvgBIANBAzYC7AEgA0HMqM8ANgLoASADQaQINgI8IANBpAg2AjQgA0GEATYCLCADIANByAJqNgI4IAMgA0HEAmo2AjAgAyADQcwCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakHkqM8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAiABKAIAIQcgBSgCAAUgCAtBCGogB0EIahDlDEUEQCADIAUoAgBBPGo2AsQCIAMgBSgCAEEIajYCyAIgAyABKAIAQQhqNgLMAiADQQA2AvgBIANBAzYC7AEgA0GQqc8ANgLoASADQaUINgI8IANBpQg2AjQgA0GEATYCLCADIANBzAJqNgI4IAMgA0HIAmo2AjAgAyADQcQCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakGoqc8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAgsgBUEEaiEFIAFBBGohASACQQFrIgINAAsLIAMoApwCIgIEQCADQegBaiIBIAMoApgCIAJBlKfPAEECEOQ6IANBATYCLCADQbynzwA2AiggA0IBNwI0IANBpgg2ArwCIAMgA0G4Amo2AjAgAyABNgK4AiAAQQRqIANBKGoQmQ4gAEEDNgIAIAEQ3jsgA0GUAmoiABDRKyAAEOg7DAILIAMoArwBIQIgAygCuAEhBwJAIAMoAsABIgFBgYCAgHhGBEBBACEFDAELQShBBBCtNiIFRQ0IIAUgATYCCCAFQoGAgIAQNwIAIAUgA0HEAWoiASkCADcCDCAFQRRqIAFBCGopAgA3AgAgBUEcaiABQRBqKQIANwIAIAVBJGogAUEYaigCADYCAAsgACAFNgIMIAAgAjYCCCAAIAc2AgQgAEEINgIAIANBlAJqIgAQ0SsgABDoOyADKAKEAiIAIAAoAgAiAEEBazYCACAAQQFHDQMgA0GEAmoQhR0MAwsgA0ECNgIsIANB+KnPADYCKCADQgI3AjQgA0E7NgL0ASADQTs2AuwBIAMgA0HoAWo2AjAgAyADQZACajYC8AEgAyADQYwCajYC6AEgA0GgAmoiASADQShqEJkOIABBBGogARDdICAAQQM2AgAgARDeOwsgAygChAIiACAAKAIAIgBBAWs2AgAgAEEBRgRAIANBhAJqEIUdCyADQcABahC2LyADKAK8ASEFCyAFIAUoAgAiAEEBazYCACAAQQFGBEAgA0G8AWoQ+CMLIAMoArgBIgAgACgCACIAQQFrNgIAIABBAUcNACADQbgBahCXFQsgAygCJCIAIAAoAgAiAEEBazYCACAAQQFHDQEgA0EkahD4IwwBC0EAIQUgAi0ABUUEQCABQRxqQQAgASgCHEGAgICAeEcbIQULIAEoAjQgA0GAgICAeDYC6AEgA0EoaiERQQhqIRwgA0HoAWohGyMAQaACayIEJAACQAJAIAVFDQAgBSgCBCIHIAUoAghBGGxqIQsjAEEwayIFJAAgBUEgakGons8AEKUrIAVBCGoiCkGwnM8AKQMANwMAIAVBGGoiDiAFKQMoNwMAIAVBEGoiCCIMIAUpAyA3AwAgBUGonM8AKQMANwMAIwBBQGoiAiQAIAVBACAIEN0rIAcgC0cEQCAHQQxqIQggCyAHa0EYbiELIAJBGGohBgNAAkAgCCgCAEGAgICAeEYNACACQQxqIgkgCEEMaxDdICAGIAgQ3SAgAkEIaiITIAZBCGooAgA2AgAgAiAGKQIANwMAIAIoAgwiEkGAgICAeEYNACACKQIQISEgAkE4aiATKAIANgIAIAIgAikDADcDMCACICE3AiggAiASNgIkIAkgBSACQSRqIAJBMGoQzgkgCRCGMAsgCEEYaiEIIAtBAWsiCw0ACwsgAkFAayQAIARB0AFqIgJBGGogDikDADcDACACQRBqIAwpAwA3AwAgAkEIaiAKKQMANwMAIAIgBSkDADcDACAFQTBqJAAgBCgC3AFFBEAgAhCTJwwBCyAEQegAaiICIARB3AFqKQIANwMAIARB8ABqIgcgBEHkAWopAgA3AwAgBEH4AGoiBSAEQewBaigCADYCACAEIAQpAtQBNwNgIAQoAtABIhBFDQAgBEEUaiACKQMANwIAIARBHGogBykDADcCACAEQSRqIAUoAgA2AgAgBCAQNgIIIAQgBCkDYDcCDAwBCyAEQdABakGons8AEKUrIARBEGpBsJzPACkDADcDACAEQaiczwApAwA3AwggBCAEKQPYATcDICAEIAQpA9ABNwMYCyAEQdQAaiEGIwBBIGsiCCQAIAhBCGohCyAEQQhqIgJBEGpBvNnPAEEMENEMISFBACEKIwBBEGsiCSQAIAIoAgAiDkEYayETIAIoAgQiDCAhp3EhBSAhQhmIQv8Ag0KBgoSIkKDAgAF+ISQCQAJAA0ACQCAFIA5qKQAAIiMgJIUiIUJ/hSAhQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiFQRQRAA0BBvNnPAEEMIBNBACAheqdBA3YgBWogDHFrIhJBGGxqEJ82DQIgIUIBfSAhgyIhUEUNAAsLICMgI0IBhoNCgIGChIiQoMCAf4NQRQ0CIAUgCkEIaiIKaiAMcSEFDAELCyAJIA4gEkEYbGoiDjYCDEGAASEFIAIoAgAiCiAKIAlBDGooAgBrQRhtIgxqIhMpAAAiISAhQgGGg0KAgYKEiJCgwIB/g3qnQQN2IAogAigCBCAMQQhrcWoiCikAACIhICFCAYaDQoCBgoSIkKDAgH+DeadBA3ZqQQdNBEAgAiACKAIIQQFqNgIIQf8BIQULIBMgBToAACAKQQhqIAU6AAAgAiACKAIMQQFrNgIMIAsgDkEYayICKQIANwIAIAtBEGogAkEQaikCADcCACALQQhqIAJBCGopAgA3AgAMAQsgC0GAgICAeDYCAAsgCUEQaiQAAkAgCCgCCEGAgICAeEYEQCAGQYCAgIB4NgIADAELIAYgCCkCFDcCACAGQQhqIAhBHGooAgA2AgAgCEEIahDeOwsgCEEgaiQAAkACQAJAAkACQAJAAkACQAJAIAQoAlRBgICAgHhHBEAgBEGQAWogBEHcAGooAgAiBzYCACAEIAQpAlQ3A4gBIARBlAFqIRMgBCgCjAEhCyMAQSBrIg4kACAOIAdBA3EiAjYCACAOIAdBAnYgAkEAR2pBA2w2AgQgDigCACEIIA5BCGoiHSAOKAIEQYzzzgAQzhggDkEUaiEFIA4oAgwhFiAOKAIQIRRBACECQQAhCiMAQRBrIhUkAEH62c8ALQAAIRBB+dnPAC0AACEXIBVBCGohBgJAAkAgCEEBRw0AIAdBAWshCQJAIAcEQCAJIAtqLQAAIgxBPUcNAQwCCyAJQQBBrJaBARDDIQALIAxBu9rPAGotAABB/wFHDQAgBiAMrUIIhiAJrUIghoQ3AgAMAQsgByAIayIJQQAgByAJTxsiCSAJQQRrIgxBACAJIAxPGyAIGyIIQQJ2QQNsIBRNBEAgBkEFOgAAIAYgCDYCBAwBCyAGQQQ6AAALAkACQAJAAkACQAJAAkACQCAHAn8gFS0ACEEFRgRAIBUoAgwMAQsgFSkDCCIhQv8Bg0IFUg0BICFCIIinCyIMQWBxIg9PBEAgD0UNAgJAAkADQAJAAkAgFCACQRhqIghPBEACQAJAIAogC2oiCS0AACIGQbvazwBqMQAAIiFC/wFRDQAgCUEBai0AACIGQbvazwBqMQAAIiJC/wFRBEAgCkEBaiEKDAELIAlBAmotAAAiBkG72s8AajEAACIjQv8BUQRAIApBAmohCgwBCyAJQQNqLQAAIgZBu9rPAGoxAAAiJEL/AVEEQCAKQQNqIQoMAQsgCUEEai0AACIGQbvazwBqMQAAIiVC/wFRBEAgCkEEaiEKDAELIAlBBWotAAAiBkG72s8AajEAACImQv8BUQRAIApBBWohCgwBCyAJQQZqLQAAIgZBu9rPAGoxAAAiJ0L/AVEEQCAKQQZqIQoMAQsgCUEHai0AACIGQbvazwBqMQAAIihC/wFSDQEgCkEHaiEKCyAFQQI2AgAgBSAGrUIIhiAKrUIghoQ3AgQMCgsgAiAWaiINICJCNIYgIUI6hoQiISAjQi6GhCIiICRCKIaEICVCIoaEIiMgJkIchoQiJEIIiEKAgID4D4MgI0IYiEKAgPwHg4QgIkIoiEKA/gODICFCOIiEhD4AACANQQRqICQgJ0IWhoQgKEIQhoQiIUKAgPwHg0IYhiAhQoCAgPgPg0IIhoRCIIg9AABBCCEGIAlBCGotAAAiAkG72s8AajEAACIhQv8BUg0BDAILIAJBGGogFEGsl4EBELA7AAtBCSEGIAlBCWotAAAiAkG72s8AajEAACIiQv8BUQ0AQQohBiAJQQpqLQAAIgJBu9rPAGoxAAAiI0L/AVENAEELIQYgCUELai0AACICQbvazwBqMQAAIiRC/wFRDQBBDCEGIAlBDGotAAAiAkG72s8AajEAACIlQv8BUQ0AQQ0hBiAJQQ1qLQAAIgJBu9rPAGoxAAAiJkL/AVENAEEOIQYgCUEOai0AACICQbvazwBqMQAAIidC/wFRDQBBDyEGIAlBD2otAAAiAkG72s8AajEAACIoQv8BUQ0AIA1BBmogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BCmogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AAEEQIQYgCUEQai0AACICQbvazwBqMQAAIiFC/wFRDQJBESEGIAlBEWotAAAiAkG72s8AajEAACIiQv8BUQ0CQRIhBiAJQRJqLQAAIgJBu9rPAGoxAAAiI0L/AVENAkETIQYgCUETai0AACICQbvazwBqMQAAIiRC/wFRDQJBFCEGIAlBFGotAAAiAkG72s8AajEAACIlQv8BUQ0CQRUhBiAJQRVqLQAAIgJBu9rPAGoxAAAiJkL/AVENAkEWIQYgCUEWai0AACICQbvazwBqMQAAIidC/wFRDQJBFyEGIAlBF2otAAAiAkG72s8AajEAACIoQv8BUQ0CIA1BDGogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BEGogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AAEEYIQYgCUEYai0AACICQbvazwBqMQAAIiFC/wFRDQNBGSEGIAlBGWotAAAiAkG72s8AajEAACIiQv8BUQ0DQRohBiAJQRpqLQAAIgJBu9rPAGoxAAAiI0L/AVENA0EbIQYgCUEbai0AACICQbvazwBqMQAAIiRC/wFRDQNBHCEGIAlBHGotAAAiAkG72s8AajEAACIlQv8BUQ0DQR0hBiAJQR1qLQAAIgJBu9rPAGoxAAAiJkL/AVENA0EeIQYgCUEeai0AACICQbvazwBqMQAAIidC/wFRDQNBHyEGIAlBH2otAAAiAkG72s8AajEAACIoQv8BUQ0DIA1BEmogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BFmogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AACAIIQIgDyAKQSBqIgpHDQEMBgsLIAVBAjYCACAFIAYgCmqtQiCGIAKtQgiGhDcCBAwFCyAFQQI2AgAgBSAGIApqrUIghiACrUIIhoQ3AgQMBAsgBUECNgIAIAUgBiAKaq1CIIYgAq1CCIaENwIEDAMLIA8gB0HsloEBELA7AAsgBUECNgIAIAUgITcCBAwBCyAMQQJ2IghBA2whCSAPQQJ2IgZBA2whAiAGIAhLDQEgCSAUSw0CIAcgDEkNAwJ/AkAgDEEccSIYBEAgAiAWaiEZIAkgAmshDSALIA9qIRpBACEGQQMhAgNAIAIgDUsNCCAGIBpqIgotAAAiCEG72s8Aai0AACIeQf8BRg0CIAYgD2oiEkEBaiAKQQFqLQAAIghBu9rPAGotAAAiH0H/AUYNAxogEkECaiAKQQJqLQAAIghBu9rPAGotAAAiIEH/AUYNAxogEkEDaiAKQQNqLQAAIghBu9rPAGotAAAiCkH/AUYNAxogAiAZakEDayIIQQJqICBBDnQiEiAKQQh0ckEIdjoAACAIIBIgH0EUdCIIckEIdkGA/gNxIAggHkEadHJBGHZyOwAAIAJBA2ohAiAYIAZBBGoiBkcNAAsLIBdBAXEhGUEAIQZBACEKQQAhDUEAIRJBACEIIwBBEGsiDyQAIA9BADYCDAJAAn4CfwJAAkAgByAMTwRAQQAgByAMRg0DGiAHIAtqIRcgCyAMaiEKA0BBACELA0AgCyANaiEYIAogC2oiGi0AACICQT1HBEAgDCASaq1CIIZCgPoAhCALDQcaIAJBu9rPAGotAAAiCEH/AUYNBCAGQQRHBEAgGEEBaiENIA9BDGogBmogCDoAACAGQQFqIQYgAiEIIBpBAWoiCiAXRw0DQQAMBwtBBEEEQcyWgQEQwyEACyAYQQJPBEAgEiAYIAsbIRIgCiALQQFqIgtqIBdGDQUMAQsLCyAMIA1qIAtqrUIghkKA+gCEDAQLIAwgB0G8loEBEK87AAsgAq1CCIYgDCANaiALaq1CIIaEDAILIBcgCmsLIQ0CQAJAAkACQCAHQQAgBkECSRtFBEAgEEH/AXFBAWsOAgECAwsgBiAMaq1CIIZCAYQMBAsgBiANakEDcUUNAQwCCyANDQELIBlBASAPLQANQRR0IA8tAAxBGnRyIA8tAA5BDnRyIA8tAA9BCHRyIgsgBkEGbCICQRhxdBsEQCAGQQJPBEBBASACQQN2IgIgAkEBTRshBwNAIAkgFmohCCAKQYB+cUEFckEEIAJBgH5xQQVyIAkgFE8bIgIgAkEFcUEFRhsiCkEFcUEFRwRAIAqtIAitQiCGhAwFCyAIIAtBGHY6AAAgCUEBaiEJIAtBCHQhCyAHQQFrIgcNAAsLIAUgCTYCCCAFIAwgEmo2AgQgBSANQQBHNgIADAMLIAYgDGpBAWutQiCGIAitQv8Bg0IIhoRCAoQMAQtCAwshISAFQQI2AgAgBSAhNwIECyAPQRBqJAAMAgsgBiAPagshAiAFQQI2AgAgBSACrUIghiAIrUIIhoQ3AgQLIBVBEGokAAwECyACIAlB/JaBARCxOwALIAkgFEH8loEBELA7AAsgDCAHQYyXgQEQsDsACyACIA1BnJeBARCwOwALIA4pAhghIQJAAkACQCAOKAIUQQJGBEAgIUL/AYNCBFENAiATQYCAgIB4NgIAIBMgITcCBCAdEN47DAELIA5BCGogIUIgiKcQ9DQgE0EIaiAOQRBqKAIANgIAIBMgDikCCDcCAAsgDkEgaiQADAELIwBBIGsiACQAIABBATYCBCAAQazwzgA2AgAgAEIBNwIMIABCuPPOgMAZNwMYIAAgAEEYajYCCCAAQcDzzgAQ7ywACwJAIAQoApQBQYCAgIB4RgRAIAQgBCkCmAE3A/gBIARBAjYC1AEgBEG03c8ANgLQASAEQgI3AtwBIARBpwg2ArgBIARBzAE2ArABIARBwNzPADYCrAEgBCAEQawBajYC2AEgBCAEQfgBajYCtAEgBEHsAGogBEHQAWoQmQ5BACEFQQMhBwwBCyAEQagBaiAEQZwBaigCACIFNgIAIAQgBCkClAE3A6ABIAQoAqQBIQcCQCAFQQlJDQAgB0G73M8AEIg7RQ0AIAdBCGohByAFQQhrIQULIARBrAFqIgIgByAFELcBAn8CQCAEKAKsAUGKgICAeEcEQCAEQdABaiIFIAJBJPwKAAAgBEECNgL8ASAEQfTczwA2AvgBIARCAjcChAIgBEGoCDYCnAIgBEHMATYClAIgBEHA3M8ANgKQAiAEIARBkAJqNgKAAiAEIAU2ApgCIARB7ABqIARB+AFqEJkOQQAhBQJ/AkACQAJAAkACQAJAAkBBASAEKALQASICQYCAgIB4cyACQQBOGw4HAAECAwQFBgkLIARB4AFqEIYwIARB1AFqDAYLIARB3AFqEIYwIARB6AFqEIYwIARB0AFqDAULIARB1AFqDAQLIARB1AFqDAMLIARB4AFqEIYwIARB1AFqDAILIARB1AFqDAELIARB1AFqCyICENUmIAIQ4DsMAQsgBCgCuAEiBUEEaiEHIAVBe0sNBiAHIAQoArQBIgJLDQcgBEHQAWoiByAEKAKwASIIIAIgBSAFIAhqIhAoAABrEPY0AkAgB0EGEMwgQf//A3EiC0UNACAFIAtqIgsgAksNCSAIIAtqLQAAQQFHDQAgByAIIAIgBSAQKAAAaxD2NCAHQQgQzCBB//8DcSILRQ0AIAUgC2oiBUEEaiELIAVBe0sNCiACIAtJDQwgBCACNgJkIAQgCDYCYCAEIAUgCGooAAAgBWo2AmggByAEQeAAaiICELcDIAQoAtABRQ0AIAIgB0Eo/AoAACAEKAJgIQUgBCgCaAwCC0EAIQUgBEHgAGpBH0EAQQFBARCgGCAEKAJkIQcgBCgCYEEBRg0KIAQoAmgiAkEXakHb3c8AKQAANwAAIAJBEGpB1N3PACkAADcAACACQQhqQczdzwApAAA3AAAgAkHE3c8AKQAANwAAIARBHzYCdCAEIAI2AnAgBCAHNgJsC0EDCyEHIARBoAFqEN47CyAEQYgBahDeOyAEKAJsIRAgBCgCcCEPIAQoAnQhDSAEKAJ4IRQgBCgCfCEVIAUEQCAEKAJkIRYgBCkDgAEhIgwCCyARQYKAgIB4NgIoIBEgFTYCFCARIBQ2AhAgESANNgIMIBEgDzYCCCARIBA2AgQgESAHNgIAIARBCGoQkycgGxCGMAwCC0EAIQULIAQgIjcDSCAEIBU2AkQgBCAUNgJAIAQgDTYCPCAEIA82AjggBCAQNgI0IAQgBzYCMCAEIBY2AiwgBCAFNgIoIARB0AFqIgIgHCAbIAUEfyACIARBMGoQ+CggBEHoAGogBEHYAWopAwA3AwAgBEHwAGogBEHgAWopAwA3AwAgBCAEKQPQATcDYCAEIARBCGo2AqwBIAQoAugBIQsjAEEwayIHJAAgBEHgAGoiCSgCCCEKIAkoAhAhDiAHQSRqIRUgBEGsAWooAgAhAiAJKQMAISEDQAJAIAkgIVAEfgJAIAsEQANAIA5BwAFrIQ4gCikDACAKQQhqIQpCgIGChIiQoMCAf4MiIUKAgYKEiJCgwIB/UQ0ADAILAAsgB0EwaiQADAILIAkgCjYCCCAJIA42AhAgIUKAgYKEiJCgwIB/hQUgIQsiIiAiQgF9gyIhNwMAIAdBDGoiBSAOICJ6p0EDdkFobGoiE0EYaxDdICAHQRhqIgwhCEEAIQYgAkEQaiISIAUQ+AshIyACKAIEIg8gI6dxIRAgI0IZiEL/AINCgYKEiJCgwIABfiElIAUoAgghFiAFKAIEIRcgAigCACENAkACQANAAkAgDSAQaikAACIkICWFIiJCf4UgIkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIiUEUEQANAIA0gInqnQQN2IBBqIA9xQWhsaiIUQRRrKAIAIBRBEGsoAgAgFyAWEMEuDQIgIkIBfSAigyIiUEUNAAsLICQgJEIBhoNCgIGChIiQoMCAf4NQRQ0CIBAgBkEIaiIGaiAPcSEQDAELCyAIQYCAgIB4NgIIIAggAjYCBCAIIBQ2AgAgBRDeOwwBCyACQQEgEhDdKyAIIAI2AhQgCCAjNwMAIAhBEGogBUEIaigCADYCACAIIAUpAgA3AggLIAcoAiAiBUGAgICAeEcEQCAHKAIsIRAgBykDGCEiIAcgBykCJDcCHCAHIAU2AhggFSATQQxrEN0gIBAoAgAiCCAQKAIEIg8gIqciDXEiBWopAABCgIGChIiQoMCAf4MiIlAEQEEIIQYDQCAFIAZqIQUgBkEIaiEGIAggBSAPcSIFaikAAEKAgYKEiJCgwIB/gyIiUA0ACwsgCCAieqdBA3YgBWogD3EiBWosAAAiBkEATgRAIAggCCkDAEKAgYKEiJCgwIB/g3qnQQN2IgVqLQAAIQYLIAUgCGogDUEZdiINOgAAIAggBUEIayAPcWpBCGogDToAACAQIBAoAgggBkEBcWs2AgggECAQKAIMQQFqNgIMIAggBUFobGpBGGsiBSAMKQIANwIAIAVBCGogDEEIaikCADcCACAFQRBqIAxBEGopAgA3AgALIAtBAWshCwwBCwsgBEEoakEAIAQoAigbBUEACxCwCiAEKALQASICQYKAgIB4RgRAIARB9ABqIARB6AFqKQMAIiE3AgAgBEHsAGogBEHgAWopAwAiIjcCACAEIAQpA9gBIiM3AmQgEUEQaiAhNwIAIBFBCGogIjcCACARICM3AgAgEUGCgICAeDYCKCAEQShqEIUrIARBCGoQkycMAQsgBEH4AGogBEHsAWooAgAiBTYCACAEQfAAaiAEQeQBaikCACIhNwMAIARB6ABqIARB3AFqKQIAIiI3AwAgBCAEKQLUASIjNwNgIAQpA/ABISQgEUHEAGogBTYCACARQTxqICE3AgAgEUE0aiAiNwIAIBEgIzcCLCARQSBqIARBIGopAwA3AwAgEUEYaiAEQRhqKQMANwMAIBFBEGogBEEQaikDADcDACARIAQpAwg3AwggESACNgIoIBEgJDcDACAEQShqEIUrCyAEQaACaiQADAYLIAUgB0GEpM8AELE7AAsgByACQYSkzwAQsDsACyALIAJB0JvPABCvOwALIAUgC0H0o88AELE7AAsgByAEKAJoQeSjzwAQ/S8ACyALIAJB9KPPABCwOwALIAMoAlAiB0GCgICAeEYEQCADQdABaiADQThqKQMAIiE3AwAgA0HIAWogA0EwaikDACIiNwMAIAMgAykDKCIjNwPAASAAQRBqICE3AwAgAEEIaiAiNwMAIAAgIzcDACABIAEoAgAiAEEBazYCACAAQQFHDQEgA0EgahCXFQwBCyADQcABaiICIANBKGpBKPwKAAAgA0GwAWoiCCADQewAaigCADYCACADQagBaiILIANB5ABqKQIANwMAIANBoAFqIhAgA0HcAGopAgA3AwAgAyADKQJUNwOYASADQfAAaiIFIAJBKPwKAABBMEEIEK02IgJFDQMgAkKBgICAEDcDACACQQhqIAVBKPwKAABBACEFIAdBgYCAgHhHBEBBKEEEEK02IgVFDQUgBSAHNgIIIAVCgYCAgBA3AgAgBSADKQOYATcCDCAFQRRqIBApAwA3AgAgBUEcaiALKQMANwIAIAVBJGogCCgCADYCAAsgACAFNgIMIAAgAjYCCCAAIAE2AgQgAEEINgIACyADQdACaiQADwsAC0EEQSgQoz0AC0EIQTAQoz0AC0EEQSgQoz0AC5gUAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPUeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqENMeIAkoAkAEQCAJKQNIIhNCgIACfEKAgARUDQILIAlBkAJqQYOGjBg2AgAgCUKDhoyYsODAgQM3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAUY3AQYgAEEMaiAJQcwAaikBADcBACAAIAkvAUQ7AQQgAEGCgICAeDYCAAsgCUEMahC4LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCtKAsgCSgCECAIQQF0aiATPQEACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahDTHkEAIQogCSgCQEEBRw0AIAkpA0giFEKAgAJ8QoCABFQhCiAUpyEICyAJQQxqIAogCBDeCwwBCyANEOY6IAkoAhhFDQMgCSgCKEEBaiIOQQN2IA5BB3FBAEdqIgogCSgCJCIISwRAIAogCGshCyAJKAIcIhIgCkkEQCANIBJBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIhIgCCASSxsQ6BkgCSgCJCEICyALBEAgCSgCICAIakEAIAv8CwALIAkgCjYCJAsgCSAONgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCtKAsgCSgCECAIQQF0akEAOwEAIAkgCEEBajYCFAsgAkEgaiECIBAgB0EBaiIHRw0BDAMLCyAJIAEQgDw2AnAgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgKcASAJQTs2ApQBIAkgCUGQAWo2ArgBIAkgCUHwAGo2ApgBIAkgCUGIAmo2ApABDAQLQaCVgAEQsjsACyAJQbABaiICIAlBDGoiBxDOFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQZiggAE2AgggACABNgIEIABBk4CAgHg2AgAgBxC4LQsgCUGwAmokAA8LQQRBOBCjPQALIAlBsAFqQeSSgAEQ7ywAC5sUAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPkeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEJ0oCyAJKAIQIAhBAnRqQQA2AgAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqENMeIAkoAkBBAUYEQCAJKQNIIhNCgICAgAh8QoCAgIAQVA0CCyAJQZACakGEiJAgNgIAIAlChIiQoMCAgYIENwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAlBsAFqEJkOIAEQqQwgACAJKQJINwIIIABBEGogCUHQAGooAgA2AgAgACAJKAJENgIEIABBgoCAgHg2AgALIAlBDGoQuS0MBwsCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQnSgLIAkoAhAgCEECdGogEz4CAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIgpBEGsiCCkDACEUIAgpAwghEyAKKQMAIRUgCikDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBU3A4ABIAkgEzcDeCAJIBQ3A3ACQAJAAkAgF1BFBEAgCUGwAWoiCiAUIBMgFSAWIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAoQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAQsgCUGHgICAeDYCRAsgCUEBNgJAIAwQiBFBACEKDAELIAkpA8ABIRQgCSkDyAEhEyAJKQPQASEVIAkgCSkD2AE3A8gBIAkgFTcDwAEgCSATNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQ0x4gCSgCQCAJKQNIIhRCgICAgAh8QoCAgIAQVHEhCiAUpyEICyAJQQxqIAogCBDfCwwBCyANEOY6IAkoAhhFDQMgCSgCKEEBaiIOQQN2IA5BB3FBAEdqIgogCSgCJCIISwRAIAogCGshCyAJKAIcIhIgCkkEQCANIBJBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIhIgCCASSxsQ6BkgCSgCJCEICyALBEAgCSgCICAIakEAIAv8CwALIAkgCjYCJAsgCSAONgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCdKAsgCSgCECAIQQJ0akEANgIAIAkgCEEBajYCFAsgAkEgaiECIBAgB0EBaiIHRw0BDAMLCyAJIAEQgDw2AnAgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgKcASAJQTs2ApQBIAkgCUGQAWo2ArgBIAkgCUHwAGo2ApgBIAkgCUGIAmo2ApABDAQLQaCVgAEQsjsACyAJQbABaiICIAlBDGoiBxDQFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQfiigAE2AgggACABNgIEIABBk4CAgHg2AgAgBxC5LQsgCUGwAmokAA8LQQRBOBCjPQALIAlBsAFqQeSSgAEQ7ywAC44UAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPMeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqEJEfIAkoAkAEQCAJKQNIIhNCgIAEVA0CCyAJQZACakGHjpw4NgIAIAlCh46cuPDgwYMHNwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAlBsAFqEJkOIAEQqQwgACAJKQFGNwEGIABBDGogCUHMAGopAQA3AQAgACAJLwFEOwEEIABBgoCAgHg2AgALIAlBDGoQuC0MBwsCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQrSgLIAkoAhAgCEEBdGogEz0BAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIgpBEGsiCCkDACEUIAgpAwghEyAKKQMAIRUgCikDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBU3A4ABIAkgEzcDeCAJIBQ3A3ACQAJAAkAgF1BFBEAgCUGwAWoiCiAUIBMgFSAWIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAoQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAQsgCUGHgICAeDYCRAsgCUEBNgJAIAwQiBFBACEKDAELIAkpA8ABIRQgCSkDyAEhEyAJKQPQASEVIAkgCSkD2AE3A8gBIAkgFTcDwAEgCSATNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQkR9BACEKIAkoAkBBAUcNACAJKQNIIhRCgIAEVCEKIBSnIQgLIAlBDGogCiAIEN4LDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHEM8UQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBwJ+AATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELgtCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALnxQCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPkeIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEzcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAPIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhEEGIgICAeAshASAAIBA3AgwgACAPNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQnSgLIAUoAmAgBEECdGpBADYCAAwDCyAFQRBqIA8gEyARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECIQNwPAASAQQoCAgIAIfCITQoCAgIAQVCAPIBAgE1atfFBxDQEgBUGYAmpBhIiQIDYCACAFQoSIkKDAgIGCBDcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkCgAI3AgggAEEQaiAFQYgCaigCADYCACAAIAUoAvwBNgIEIABBgoCAgHg2AgALIAVB3ABqELktDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCdKAsgBSgCYCAEQQJ0aiAQPgIACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAgICACHwiEEKAgICAEFQgBSkDCCAPIBBWrXxQcSEEIA+nIQYLIAVB3ABqIAQgBhDfCwwBCyAJEOY6IAUoAmhFDQMgBSgCeEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshByAFKAJsIg4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCdCEECyAHBEAgBSgCcCAEakEAIAf8CwALIAUgBjYCdAsgBSAKNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQnSgLIAUoAmAgBEECdGpBADYCACAFIARBAWo2AmQLIANBEGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP87NgKQAiAFQQI2AvwBIAVB1JKAATYC+AEgBUICNwKEAiAFQTs2AuwBIAVBOzYC5AEgBSAFQeABajYCgAIgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH4AWpB5JKAARDvLAALQaCVgAEQsjsACyAFQZABaiICIAVB3ABqIgMQ0BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEH4ooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVBoAJqJAAPC0EEQTgQoz0AC5cUAgp/BX5CCiEPIwBBoAJrIgUkACAFIAM6AFsgASACEPwhIQEgBSADwCICNgKQAiAFQgA3A+gBIAVCCjcD4AFCASERAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQQA2AlQgBUFAayARIBIgDyAQIAVB1ABqEPYMIAUoAlQNAyAFKQNIIRIgBSkDQCERIAJBAUYNAgsgBUEANgI8IAVBIGogDyAQIA8gECAFQTxqEPYMIAUoAjwNAiAFKQMoIRAgBSkDICEPIAJBAXYhAgwACwALIAVB3ABqIAFBDGoiDRDaPBD1HiAELQA0IA0Q2jwhDA0DIAxFDQQgBUHoAGohCEEAIQNBACECA0ACQAJAAkACQCABIAIQhyVFBEAgBSACNgKQAiANENo8IAJNDQcgASgCECADaiIEKQMAIQ8gBSAEKQMIIhM3A9gBIAUgDzcD0AEgBSARNwOQAiAFIBI3A5gCIBEgEoRQBH9Bh4CAgHgFIBEgEoNCf1IgDyATQoCAgICAgICAgH+FhEIAUnINAiAFQQI2ApQBIAVB9JeAATYCkAEgBUICNwKcASAFQfsPNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfwBaiAFQZABahCZDiAFKQL8ASEPIAUpAoQCIRBBiICAgHgLIQEgACAQNwIMIAAgDzcCBCAAIAE2AgAMAgsgCBDmOiAFKAJoRQ0HIAUoAnhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQogBSgCbCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAnQhBAsgCgRAIAUoAnAgBGpBACAK/AsACyAFIAY2AnQLIAUgCTYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEK0oCyAFKAJgIARBAXRqQQA7AQAMAwsgBUEQaiAPIBMgESASEIMZIAUgBSkDGCIPNwPIASAFIAUpAxAiEDcDwAEgEEKAgAJ8IhNCgIAEVCAPIBAgE1atfFBxDQEgBUGYAmpBg4aMGDYCACAFQoOGjJiw4MCBAzcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkB/gE3AQYgAEEMaiAFQYQCaikBADcBACAAIAUvAfwBOwEEIABBgoCAgHg2AgALIAVB3ABqELgtDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCtKAsgBSgCYCAEQQF0aiAQPQEACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAgAJ8IhBCgIAEVCAFKQMIIA8gEFatfFBxIQQgD6chBgsgBUHcAGogBCAGEN4LDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDOFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQZiggAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUGgAmokAA8LQQRBOBCjPQALjhQCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ8h4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRUgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFTcDmAEgCSATNwOQASAYUAR/QYeAgIB4BSAJQbABaiIIIBMgFSAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRRBiICAgHgLIQEgACAUNwIMIAAgBjcCBCAAIAE2AgAMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQnSgLIAkoAhAgCEECdGpBADYCAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFTcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFDcDcCAJIBM3A8gBIAkgFTcDwAEgCSAWNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQkR8gCSgCQEEBRgRAIAkpA0giE0KAgICAEFQNAgsgCUGQAmpBiJCgwAA2AgAgCUKIkKDAgIGChAg3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAkg3AgggAEEQaiAJQdAAaigCADYCACAAIAkoAkQ2AgQgAEGCgICAeDYCAAsgCUEMahC5LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCdKAsgCSgCECAIQQJ0aiATPgIACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahCRHyAJKAJAIAkpA0giFEKAgICAEFRxIQogFKchCAsgCUEMaiAKIAgQ3wsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQnSgLIAkoAhAgCEECdGpBADYCACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ1BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIoYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQuS0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAvvEAINfwZ+IwBBoAJrIgUkAAJAAkACQAJAAkACQAJ/AkACQAJAAkAgAUEESwRAIANBBEsEQCAFQQA2AogBIAVBiAFqIgdBBCAAQQRB3NHRABDVLCAFKAKIASEMIAVBADYCiAEgB0EEIAJBBEHc0dEAENUsQQAgDCAFKAKIAUcNBhoCQCAEQQVPBEAgAC0ABCACLQAERg0BC0EEIAQgBEEETxsMBwsgAUEFayEKIABBBWohBiADQQVrIQsgAkEFaiEIQQAhByAEQQVrIglBCEkNBCAFQgA3AwggCkEHSwRAIAVBCGoiB0EIIAZBCEH80dEAENUsIAUpAwghEyAFQgA3AwggC0EHSwRAIAdBCCAIQQhB/NHRABDVLCATIAUpAwgiElIEQCASIBOFeqdBA3YhAAwICyABQQ1rIQogAEENaiEGIANBDWshCyACQQ1qIQggBEENayIJQRBJBEBBCCEHDAYLIAVBkAJqIhBCADcDACAFQgA3A4gCIAVBEGoiEUIANwMAIAVCADcDCCAKQQ9LBEAgBUGIAmoiDUEQIAZBEEHM0tEAENUsIAtBD0sEQCABQR1rIQogAEEdaiEGIAVBCGoiB0EQIAhBEEHM0tEAENUsIARBHWshCSADQR1rIQsgAkEdaiEIQQghDkEBIQ8DQCAFQgA3A4gBIAVBiAFqIgxBCCANQQhB/NHRABDVLCAFKQOIASETIAVCADcDiAEgDEEIIAdBCEH80dEAENUsIAUpA4gBIhIgE1IEQCASIBOFeqdBA3YgDmohAAwLCyAOQQhqIQ4gD0EAIQ8gECENIBEhBw0AC0EYIQcgCUEgSQ0HQQAiDEUEQCAFQQhqQQBBgAH8CwALIAxFBEAgBUGIAWpBAEGAAfwLAAsgCkEfSwRAIAVBCGpBICAGQSBB3NLRABDVLCALQR9LBEAgAUE9ayEKIABBPWohBiAFQYgBakEgIAhBIEHc0tEAENUsIARBPWshCSADQT1rIQsgAkE9aiEIQQAhBwNAIAVCADcDiAIgBUGIAmoiDUEIIAVBCGogB2pBCEH80dEAENUsIAUpA4gCIRMgBUIANwOIAiANQQggBUGIAWogB2pBCEH80dEAENUsIAUpA4gCIhIgE1IEQCAHQRhqIQYMCgsgB0EIaiIHQSBHDQALIAlBwABJBEBBOCEHDAoLIApBP0sEQCAFQQhqQcAAIAZBwABB7NLRABDVLCALQT9LBEAgAUH9AGshCiAAQf0AaiEGIAVBiAFqQcAAIAhBwABB7NLRABDVLCAEQf0AayEJIANB/QBrIQsgAkH9AGohCEEAIQIDQCAFQgA3A4gCIAVBiAJqIgBBCCAFQQhqIAJqQQhB/NHRABDVLCAFKQOIAiETIAVCADcDiAIgAEEIIAVBiAFqIAJqQQhB/NHRABDVLCAFKQOIAiISIBNSBEAgAkE4aiEGDAwLIAJBCGoiAkHAAEcNAAsgCUGAAUkEQEH4ACEHDAwLIARB/QFrQYB/cUH4AWohB0H4ACEAA0ACQCAKQf8ASwRAIAVBCGpBgAEgBkGAAUH809EAENUsIAtB/wBNDRMgCkGAAWshCiAGQYABaiEGIAVBiAFqQYABIAhBgAFB/NPRABDVLCAAQYABaiEBIAlBgAFrIQkgC0GAAWshCyAIQYABaiEIQQAhAgNAAkAgBUIANwOIAiAFQYgCaiIDQQggBUEIaiACakEIQfzR0QAQ1SwgBSkDiAIhEyAFQgA3A4gCIANBCCAFQYgBaiACakEIQfzR0QAQ1SwgEyAFKQOIAiISUg0AIAJBCGoiAkGAAUcNAQwDCwsgACACaiEGDA0LDBILIAEhACAJQYABTw0ACwwLCwwQCwwPCwwPCwwOCwwOCwwNCwwNCwwMCyAFQQA2ApgBIAVBATYCjAEgBUG40NEANgKIASAFQgQ3ApABIAVBiAFqQbzS0QAQ7ywACyAFQQA2ApgBIAVBATYCjAEgBUG40NEANgKIASAFQgQ3ApABIAVBiAFqQazS0QAQ7ywACyASIBOFeqdBA3YgBmohAAwCCyAJQQhJDQBBACAHayECAkADQCAFQgA3AwggCkEHTQ0KIAVBCGoiAEEIIAZBCEH80dEAENUsIAUxAA8hFCAFMQAOIRUgBTEADSEWIAUxAAwhFyAFNQIIIRIgBUIANwMIIAtBB00NCiAAQQggCEEIQfzR0QAQ1SwgBSkDCCITIBdCIIYgEoQgFkIohoQgFUIwhoQgFEI4hoQiElEEQCAGQQhqIQYgCkEIayEKIAJBCGshAiAIQQhqIQggC0EIayELIAlBCGsiCUEHTQ0CDAELCyASIBOFeqdBA3YgAmshAAwCC0EAIAJrIQcLIAkgCksEQEH80tEAQS5BrNPRABCfKQALIAkgC0sNAiAHQQFrIQAgCSECA0AgAgRAIAJBAWshAiAAQQFqIQAgCC0AACEDIAYtAAAgCEEBaiEIIAZBAWohBiADRg0BDAILCyAHIAlqIQALIABBBWoLIAVBoAJqJAAPC0G809EAQS5B7NPRABCfKQALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB/NPRABDvLAALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB7NLRABDvLAALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB3NLRABDvLAALIAVBADYCmAEgBUEBNgKMASAFQbjQ0QA2AogBIAVCBDcCkAEgBUGIAWpBzNLRABDvLAALIAVBADYCmAEgBUEBNgKMASAFQbjQ0QA2AogBIAVCBDcCkAEgBUGIAWpB7NHRABDvLAALhhQCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ8B4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRUgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFTcDmAEgCSATNwOQASAYUAR/QYeAgIB4BSAJQbABaiIIIBMgFSAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRRBiICAgHgLIQEgACAUNwIMIAAgBjcCBCAAIAE2AgAMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQoygLIAkoAhAgCGpBADoAAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFTcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFDcDcCAJIBM3A8gBIAkgFTcDwAEgCSAWNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQ0x4gCSgCQEEBRgRAIAkpA0giE0KAAXxCgAJUDQILIAlBkAJqQYKEiBA2AgAgCUKChIiQoMCAgQI3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAEU3AAUgAEEMaiAJQcwAaikAADcAACAAIAktAEQ6AAQgAEGCgICAeDYCAAsgCUEMahC3LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCjKAsgCSgCECAIaiATPAAACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahDTHiAJKAJAIAkpA0giFEKAAXxCgAJUcSEKIBSnIQgLIAlBDGogCiAIEPELDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEKMoCyAJKAIQIAhqQQA6AAAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHENYUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0KOAATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELctCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALihQCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPAeIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEzcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAPIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhEEGIgICAeAshASAAIBA3AgwgACAPNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQoygLIAUoAmAgBGpBADoAAAwDCyAFQRBqIA8gEyARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECIQNwPAASAQQoABfCITQoACVCAPIBAgE1atfFBxDQEgBUGYAmpBgoSIEDYCACAFQoKEiJCgwICBAjcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkA/QE3AAUgAEEMaiAFQYQCaikAADcAACAAIAUtAPwBOgAEIABBgoCAgHg2AgALIAVB3ABqELctDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCjKAsgBSgCYCAEaiAQPAAACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAAXwiEEKAAlQgBSkDCCAPIBBWrXxQcSEEIA+nIQYLIAVB3ABqIAQgBhDxCwwBCyAJEOY6IAUoAmhFDQMgBSgCeEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshByAFKAJsIg4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCdCEECyAHBEAgBSgCcCAEakEAIAf8CwALIAUgBjYCdAsgBSAKNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQoygLIAUoAmAgBGpBADoAACAFIARBAWo2AmQLIANBEGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP87NgKQAiAFQQI2AvwBIAVB1JKAATYC+AEgBUICNwKEAiAFQTs2AuwBIAVBOzYC5AEgBSAFQeABajYCgAIgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH4AWpB5JKAARDvLAALQaCVgAEQsjsACyAFQZABaiICIAVB3ABqIgMQ1hRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHQo4ABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQty0LIAVBoAJqJAAPC0EEQTgQoz0AC/4TAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPceIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEKkZCyAJKAIQIAhqQQA6AAAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqEJEfIAkoAkBBAUYEQCAJKQNIIhNCgAJUDQILIAlBkAJqQYaMmDA2AgAgCUKGjJiw4MCBgwY3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAEU3AAUgAEEMaiAJQcwAaikAADcAACAAIAktAEQ6AAQgAEGCgICAeDYCAAsgCUEMahC3LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCpGQsgCSgCECAIaiATPAAACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahCRHyAJKAJAIAkpA0giFEKAAlRxIQogFKchCAsgCUEMaiAKIAgQ8AsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQqRkLIAkoAhAgCGpBADoAACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ0RRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGopIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQty0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAuVEQESfyMAQeAAayIIJAACQCAFQQAgBGtBA3EiB2siBkEAIAUgBk8bQYAmSQRAQb5/IQMMAQsgAkH/AUsEQEFSIQMMAQsgBCAHakEAIAUgB08bIglBAEGAJvwLACAJQQhqIQsgCUGAIGohBiACQQFqIg4hBSABIQQDQCAFBEAgBiAEKAIAIgdBvQEgB2drIAdBpQFJG0ECdGoiByAHLwEAQQFqOwEAIAVBAWshBSAEQQRqIQQMAQUCQEEAIQUDQCAFQYR6RgRAIAlBhiBqIQdBACEFA0AgBSAORgRAQQAhBQNAAkAgBUHoAEYEQCACQYACaiEKIAJBA3QhBQNAIApBAWshCiAFIAlqIAVBCGsiAiEFQQhqKAIAIgFFDQALIAIgCWoiDUEUakGAAjsBACANQQxqQYACOwEAIAkgDUEIaigCACABajYCiBAgCkH/AWshESAKQf4BayEHIAlBkBBqIQEgA0ELIAMbIQwgDUEXaiEGIA1BhxBqIQRBgAIgCiAKQYACTBtBgAJrIQUDQCAFRQ0CIAFBgICAgAQ2AgAgAUEIaiEBIAVBAWshBQwACwALIAUgCWoiAUGWJWovAQAgAUGUJWovAQAiAWsiBEECTgRAIAsgAUEDdGpBACAEQQFrEMgNCyAFQQRqIQUMAQsLIAlBgICAgHg2AgBBgAIhBUGAAiAKIApBgAJMGyETIAlBkBBqIQIgCkGBAmshAUGAAiEDA0AgBSATRkUEQCALIAMgCyABQQN0aigCACIPIAsgA0EDdGooAgAiEE8iFGoiEiABIA8gEElrIg8gCyAPQQN0aigCACIQIAsgEkEDdGooAgAiFU8iFhtBA3RqIhcgBUEBaiIFOwEEIAsgAyABIBQbQQN0aiIBIAU7AQQgAiAXKAIAIAEoAgBqNgIAIA8gECAVSWshASASIBZqIQMgAkEIaiECDAELCyANQY8QakEAOgAAIApBAWshBQNAIAVB/wFMBEAgB0EAIAdBAEobIQQgCUEPaiEFA0AgBARAIAUgCyAFQQNrLwEAQQN0akEHai0AAEEBajoAACAEQQFrIQQgBUEIaiEFDAELCyANQRdqLQAAIgMgDE0NBkEBIAMgDGsiCnQhAkEAIQEgAyEFA0AgBUH/AXEiBCAMTQRAA0AgB0EBayEHIAYtAAAgBkEIayIDIQYgDEYNAAsgCEHwAUE4/AsAIANBCGohBCAMIQYgByEFA0AgBUEASARAIAEgCnUhBiAIQfwAaiECA0ACQAJAIAZBAEwEQCAJQR9qIQIgCUEXaiEDIAgoAgQhBQwBC0EgIAZnIgFrIQUgAiABQQJ0ayEEA0AgBUECSQRAQQEhBQwDCyAEQQRqKAIAIgFB8OHDh39HBEAgBCgCACIDQfDhw4d/Rg0DIAsgAUEDdGooAgAgCyADQQN0aigCAEEBdE0NAwsgBUEBayEFIARBBGshBAwACwALA0AgBkEAIAZBAEobIQEgBUGQnrz4AGohBCADIAVBA3RqIQUCQANAIAEgBkYNASAEBEAgBSAFLQAAQQFrOgAAIARBAWohBCAFQQhqIQUgBkEBaiEGDAELCyAHQQFqIQQgAiAHQQN0aiEFA0AgBEEBayEEIAVBEGshByAFQQhrIgEhBSAMIActAABGDQALIAEgAS0AAEEBazoAACAGQQFqIQYgBEEBaiEFIAQhBwwBCwsgDCEDDAwLQQ0gBSAFQQ1NGyEBIAggBUECdGohBAJAA0AgASAFRgRAIAggAUECdGooAgAhAwwCCyAEKAIAIgNB8OHDh39GBEAgBEEEaiEEIAVBAWohBQwBCwsgBSEBCyALIANBA3RqQQdqIgQgBC0AAEEBajoAAEHw4cOHfyEFIAggAUEBayIEQQJ0aiIKIAMgCigCACIKIApB8OHDh39GGzYCAEF/IAR0IAZqIQYgCCABQQJ0aiADBH9B8OHDh38gA0EBayIDIAsgA0EDdGpBB2otAAAgDCABa0cbBSAFCzYCAAwACwAFIAQtAAAiAiAGSQRAIAggDCACa0ECdGogBTYCACACIQYLIARBCGshBCAFQQFrIQUMAQsACwAFIAYgDDoAACABIAJqQX8gAyAEa3RqIQEgB0EBayEHIAZBCGsiBi0AACEFDAELAAsABSAEIAsgBEEDay8BAEEDdGpBB2otAABBAWo6AAAgBEEIayEEIAVBAWshBQwBCwALAAUgByABKAIAIgRBvQEgBGdrIARBpQFJG0ECdGoiBiAGLwEAIgZBAWo7AQAgCyAGQQN0aiIGIAU6AAYgBiAENgIAIAFBBGohASAFQQFqIQUMAQsACwAFIAUgCWoiBEH6JWogBEH4JWoiBy8BACAEQfwlai8BAGoiBDsBACAHIAQ7AQAgBUEEayEFDAELAAsACwsLIANBDEsEQEF/IQMMAQsgCEEYakEAOwEAIAhBEGpCADcDACAIQgA3AwggCEIANwMAIAhB2ABqQQA7AQAgCEHQAGpCADcDACAIQgA3A0ggCEIANwNAIAlBD2ohBEF/IBEgEUEASBtBAWohBQNAIAUEQCAIIAQtAABBAXRqIgEgAS8BAEEBajsBACAFQQFrIQUgBEEIaiEEDAEFIANBAXQhBSADIQRBACEBA0AgBEEATARAIAlBD2ohBCAAQQRqIQUgDiEBA0AgAQRAIAUgBEEBay0AAEECdGogBC0AADYCACABQQFrIQEgBEEIaiEEDAEFA0AgDgRAIAhBQGsgBSgCACICQf8BcSIBQQF0aiIEIAQvAQAiBEEBajsBACABBEAgBSAEQSAgAWt0IAJyNgIACyAOQQFrIQ4gBUEEaiEFDAELCyAAIAM2AgALCwUgCEFAayAFaiABOwEAIARBAWshBCAFIAhqLwEAIAFqQf7/A3FBAXYhASAFQQJrIQUMAQsLCwsLIAhB4ABqJAAgAwuAFAIKfwV+QgohDyMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIA8gECAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIA8gECAPIBAgBUE8ahD2DCAFKAI8DQIgBSkDKCEQIAUpAyAhDyACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ8h4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAiARIBKEUAR/QYeAgIB4BSARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCdKAsgBSgCYCAEQQJ0akEANgIADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBBQIA9CgICAgBBUcQ0BIAVBmAJqQYiQoMAANgIAIAVCiJCgwICBgoQINwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQKAAjcCCCAAQRBqIAVBiAJqKAIANgIAIAAgBSgC/AE2AgQgAEGCgICAeDYCAAsgBUHcAGoQuS0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEJ0oCyAFKAJgIARBAnRqIA8+AgALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoCAgIAQVHEhBCAPpyEGCyAFQdwAaiAEIAYQ3wsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEJ0oCyAFKAJgIARBAnRqQQA2AgAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENQUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByKGAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQaACaiQADwtBBEE4EKM9AAv7EwIKfwV+QgohDyMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIA8gECAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIA8gECAPIBAgBUE8ahD2DCAFKAI8DQIgBSkDKCEQIAUpAyAhDyACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ8x4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAiARIBKEUAR/QYeAgIB4BSARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBBQIA9CgIAEVHENASAFQZgCakGHjpw4NgIAIAVCh46cuPDgwYMHNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQH+ATcBBiAAQQxqIAVBhAJqKQEANwEAIAAgBS8B/AE7AQQgAEGCgICAeDYCAAsgBUHcAGoQuC0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEK0oCyAFKAJgIARBAXRqIA89AQALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoCABFRxIQQgD6chBgsgBUHcAGogBCAGEN4LDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDPFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcCfgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUGgAmokAA8LQQRBOBCjPQAL8BMCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPceIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhECAFIAQpAwgiEzcD2AEgBSAQNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAQIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIRAgBSkChAIhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQqRkLIAUoAmAgBGpBADoAAAwDCyAFQRBqIBAgEyARIBIQgxkgBSAFKQMYIhA3A8gBIAUgBSkDECIPNwPAASAQUCAPQoACVHENASAFQZgCakGGjJgwNgIAIAVChoyYsODAgYMGNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQD9ATcABSAAQQxqIAVBhAJqKQAANwAAIAAgBS0A/AE6AAQgAEGCgICAeDYCAAsgBUHcAGoQty0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEKkZCyAFKAJgIARqIA88AAALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoACVHEhBCAPpyEGCyAFQdwAaiAEIAYQ8AsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEKkZCyAFKAJgIARqQQA6AAAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENEUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBqKSAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELctCyAFQaACaiQADwtBBEE4EKM9AAvxEwIKfwV+QgohECMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIBAgDyAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIBAgDyAQIA8gBUE8ahD2DCAFKAI8DQIgBSkDKCEPIAUpAyAhECACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ+B4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJ/AkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAkGHgICAeCARIBKEUA0CGiARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQEgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4DAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCzKAsgBSgCYCAEQQN0akIANwMADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBAgD0KAgICAgICAgIB/fSAPVK18UA0BIAVBmAJqQYWKlCg2AgAgBUKFipSo0KDBggU3A5ACIAVBAjYClAEgBUHgpYABNgKQASAFQgI3ApwBIAVBrQM2AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmoiATYC6AEgBSAFQcABajYC4AEgBUH8AWogBUGQAWoQmQ4gARCpDCAFKQL8ASEQIAUpAoQCIQ9BgoCAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAgBUHcAGoQui0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABELMoCyAFKAJgIARBA3RqIA83AwALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgLQASANENo8IAJNDQIgASgCECADaiIEKQMAIQ8gBSAEKQMIIhM3A8gBIAUgDzcDwAEgBSARNwPQASAFIBI3A9gBIAVB3ABqAn4CQAJAIBEgEoRQRQRAIBEgEoNCf1IgDyATQoCAgICAgICAgH+FhEIAUnINAiAFQQI2AvwBIAVB9JeAATYC+AEgBUICNwKEAiAFQfsPNgKcAiAFQfsPNgKUAiAFIAVBkAJqNgKAAiAFIAVB0AFqNgKYAiAFIAVBwAFqNgKQAiALIAVB+AFqEJkOIAVBiICAgHg2AuABIAggBSkC4AE3AgAgCEEIaiAFQegBaikCADcCACAIQRBqIAVB8AFqKAIANgIADAELIAVBh4CAgHg2ApQBCyAFQQE2ApABIAgQiBFCAAwBCyAFIA8gEyARIBIQgxkgBSkDACIPIBAgBSkDCCAPQoCAgICAgICAgH99IA9UrXxQIgQbIRAgBK0LIBAQ2gsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABELMoCyAFKAJgIARBA3RqQgA3AwAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQaACaiQADwtBBEE4EKM9AAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDtGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDtGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ/BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ/BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ/BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ/BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ/BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD8GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD8GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD2GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD2GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD1GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD1GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD7GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD7GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD0GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD0GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDuGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDuGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDxGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDxGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDvGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDvGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDwGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDwGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD3GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD3GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDyGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDyGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD4GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD4GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD5GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD5GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvIEwIKfwZ+IwBBsAJrIgkkACAJIAc6AAsgASACEOMhIQEgCUGwAWogAyAEIAUgBiAHwBDfAQJAAkACQCAJKAKwAUEBRgRAIAlByABqIAkpArwBNwMAIAlB0ABqIAlBxAFqKAIANgIAIAkgCSkCtAE3A0AgCUEDNgIQIAlBrKWAATYCDCAJQgI3AhggCUH0CzYCfCAJQcQNNgJ0IAlBtJ2AATYCcCAJIAlB8ABqNgIUIAkgCUELajYCeCAJQZQBaiAJQQxqEJkOIAlBgoCAgHg2ApABIAlBQGsQiBEgAEEIaiAJQZgBaigCADYCACAAIAkpApABNwIAIAAgCSkCnAE3AgwMAQsgCSkD2AEhBiAJKQPQASEDIAkpA8gBIQQgCSkDwAEhBSAJQQxqIAFBDGoiERDcPBD4HiAILQA0IQIgERDcPCEQAkAgAkUEQCAQRQ0BIAlBGGohDEEQIQIgAyAFhCAEIAaEhCEYQQAhBwJAA0ACQAJAAkACfwJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NBSABKAIQIAJqIghBEGsiCikDACETIAopAwghFCAIKQMAIRYgCCkDCCEXIAkgBjcDWCAJIAM3A1AgCSAENwNIIAkgBTcDQCAJIBc3A6gBIAkgFjcDoAEgCSAUNwOYASAJIBM3A5ABQYeAgIB4IBhQDQIaIAlBsAFqIgggEyAUIBYgFyAFIAQgAyAGEJoIIAktALABQQFHDQEgCUECNgK0ASAJQfSXgAE2ArABIAlCAjcCvAEgCUGDDDYCrAIgCUGDDDYCpAIgCSAJQaACajYCuAEgCSAJQUBrNgKoAiAJIAlBkAFqNgKgAiAJQYwCaiAIEJkOIAkpAowCIQYgCSkClAIhFUGIgICAeAwCCyAMEOY6IAkoAhhFDQYgCSgCKEEBaiINQQN2IA1BB3FBAEdqIgogCSgCJCIISwRAIAogCGshDiAJKAIcIgsgCkkEQCAMIAtBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIgsgCCALSxsQ6BkgCSgCJCEICyAOBEAgCSgCICAIakEAIA78CwALIAkgCjYCJAsgCSANNgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCzKAsgCSgCECAIQQN0akIANwMADAMLIAkgCSkD2AEiEzcDiAEgCSAJKQPQASIUNwOAASAJIAkpA8gBIhY3A3ggCSAJKQPAASIVNwNwIAkgEzcDyAEgCSAUNwPAASAJIBY3A7gBIAkgFTcDsAEgCUFAayAJQbABaiIIENMeIAkoAkANASAJQZACakGFipQoNgIAIAlChYqUqNCgwYIFNwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAgQmQ4gARCpDCAJKQJEIQYgCSkCTCEVQYKAgIB4CyEBIAAgFTcCDCAAIAY3AgQgACABNgIAIAlBDGoQui0MBwsgCSkDSCETAkAgCSgCGARAIAkoAigiDUEBaiIOQQN2IA5BB3FBAEdqIgggCSgCJCIKSwRAIAggCmshCyAJKAIcIg8gCEkEQCAMIA9BAXQiCiAIQcD///8DcUFAayAIIAhBP3EbIg8gCiAPSxsQ6BkgCSgCJCEKCyALBEAgCSgCICAKakEAIAv8CwALIAkgCDYCJAsgCSAONgIoIAkoAiAgDUEDdmoiCCAILQAAQQEgDUEHcXRyOgAADAELIAkgCSgCLEEBajYCLAsgCSgCFCIIIAkoAgxGBEAgCUEMakGEk4ABELMoCyAJKAIQIAhBA3RqIBM3AwALIAkgCEEBajYCFCACQSBqIQIgECAHQQFqIgdHDQEMBAsLIAkgARCAPDYCkAEgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgJMIAlBOzYCRCAJIAlBQGs2ArgBIAkgCUGQAWo2AkggCSAJQYgCajYCQAwFC0GglYABELI7AAsgEEUNACAJQRhqIQ0gCUFAa0EEciEMIAlBjAJqIQ8gAyAFhCAEIAaEhCEXQRAhAkEAIQcCQANAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQIgASgCECACaiIIQRBrIgopAwAhFSAKKQMIIRMgCCkDACEUIAgpAwghFiAJIAY3A6gBIAkgAzcDoAEgCSAENwOYASAJIAU3A5ABIAkgFjcDiAEgCSAUNwOAASAJIBM3A3ggCSAVNwNwIAlBDGoCfgJAIBdQRQRAIAlBsAFqIgggFSATIBQgFiAFIAQgAyAGEJoIIAktALABQQFGBEAgCUECNgK0ASAJQfSXgAE2ArABIAlCAjcCvAEgCUGDDDYCrAIgCUGDDDYCpAIgCSAJQaACajYCuAEgCSAJQZABajYCqAIgCSAJQfAAajYCoAIgDyAIEJkOIAlBiICAgHg2AogCIAwgCSkCiAI3AgAgDEEIaiAJQZACaikCADcCACAMQRBqIAlBmAJqKAIANgIADAILIAkpA8ABIRUgCSkDyAEhEyAJKQPQASEUIAkgCSkD2AE3A8gBIAkgFDcDwAEgCSATNwO4ASAJIBU3A7ABIAlBQGsgCUGwAWoQ0x4gCSkDQAwCCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUIACyAJKQNIENoLDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABELMoCyAJKAIQIAhBA3RqQgA3AwAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELotCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALyRMCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ7x4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAn8CQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRQgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFDcDmAEgCSATNwOQAUGHgICAeCAYUA0CGiAJQbABaiIIIBMgFCAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0BIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRVBiICAgHgMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQsygLIAkoAhAgCEEDdGpCADcDAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFDcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFTcDcCAJIBM3A8gBIAkgFDcDwAEgCSAWNwO4ASAJIBU3A7ABIAlBQGsgCUGwAWoiCBCRHyAJKAJADQEgCUGQAmpBiZKkyAA2AgAgCUKJkqTIkKHChAk3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCBCZDiABEKkMIAkpAkQhBiAJKQJMIRVBgoCAgHgLIQEgACAVNwIMIAAgBjcCBCAAIAE2AgAgCUEMahC6LQwHCyAJKQNIIRMCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQsygLIAkoAhAgCEEDdGogEzcDAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIghBEGsiCikDACEVIAopAwghEyAIKQMAIRQgCCkDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBQ3A4ABIAkgEzcDeCAJIBU3A3AgCUEMagJ+AkAgF1BFBEAgCUGwAWoiCCAVIBMgFCAWIAUgBCADIAYQmgggCS0AsAFBAUYEQCAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAgQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAgsgCSkDwAEhFSAJKQPIASETIAkpA9ABIRQgCSAJKQPYATcDyAEgCSAUNwPAASAJIBM3A7gBIAkgFTcDsAEgCUFAayAJQbABahCRHyAJKQNADAILIAlBh4CAgHg2AkQLIAlBATYCQCAMEIgRQgALIAkpA0gQ2gsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQsygLIAkoAhAgCEEDdGpCADcDACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ2RRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGgooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQui0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDbPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDyEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDbPBDuLSACKAIUIgdBAnYhCiACKAIQIQICQAJAIAdBBE8EQCAKQQJ0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQRqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQRrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EETwRAIApBAnQhBANAIANBCGogASACKAIAEIAXIANB0ABqIAMoAgggAygCDBChNiACQQRqIQIgBEEEayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2zwQ7i0gAigCFCIJQQJ2IQogAigCECECIAlBBE8EQCAKQQJ0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEEaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EEayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBBE8EQCAKQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEIAXIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENs8EO4tIAIoAhQiCkECdiELIAIoAhAhBQJAIApBBE8EQCALQQJ0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EEaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBBGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQRPBEAgC0ECdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABCAFyADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQRqIQUgBEEBaiEEIAJBBGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2zwQ7i0gAigCFCIKQQJ2IQsgAigCECEFAkACQCAKQQRPBEAgC0ECdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBBGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQRrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEETwRAIAtBAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEIAXIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGUqNCgATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClKjQoMGChYoUNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDbPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDyEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDbPBDuLSACKAIUIgdBAnYhCiACKAIQIQICQAJAIAdBBE8EQCAKQQJ0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQRqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQRrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EETwRAIApBAnQhBANAIANBCGogASACKAIAEP8WIANB0ABqIAMoAgggAygCDBChNiACQQRqIQIgBEEEayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2zwQ7i0gAigCFCIJQQJ2IQogAigCECECIAlBBE8EQCAKQQJ0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEEaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EEayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBBE8EQCAKQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEP8WIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENs8EO4tIAIoAhQiCkECdiELIAIoAhAhBQJAIApBBE8EQCALQQJ0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EEaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBBGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQRPBEAgC0ECdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABD/FiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQRqIQUgBEEBaiEEIAJBBGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2zwQ7i0gAigCFCIKQQJ2IQsgAigCECEFAkACQCAKQQRPBEAgC0ECdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBBGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQRrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEETwRAIAtBAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEP8WIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGYsODAATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmLDgwIGDhowYNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDYPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDYPBDuLSACKAIUIgdBA3YhCiACKAIQIQICQAJAIAdBCE8EQCAKQQN0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQhqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQhrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EITwRAIApBA3QhBANAIANBCGogASACKAIAEIAXIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2DwQ7i0gAigCFCIJQQN2IQogAigCECECIAlBCE8EQCAKQQN0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEIaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EIayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBCE8EQCAKQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEIAXIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENg8EO4tIAIoAhQiCkEDdiELIAIoAhAhBQJAIApBCE8EQCALQQN0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EIaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBCGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQhPBEAgC0EDdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABCAFyADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQhqIQUgBEEBaiEEIAJBCGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2DwQ7i0gAigCFCIKQQN2IQsgAigCECEFAkACQCAKQQhPBEAgC0EDdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBCGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQhrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEITwRAIAtBA3QhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEIAXIANB0ABqIAMoAhggAygCHBChNgsgBUEIaiEFIARBAWohBCAHQQhrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGUqNCgATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClKjQoMGChYoUNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDYPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDYPBDuLSACKAIUIgdBA3YhCiACKAIQIQICQAJAIAdBCE8EQCAKQQN0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQhqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQhrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EITwRAIApBA3QhBANAIANBCGogASACKAIAEP8WIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2DwQ7i0gAigCFCIJQQN2IQogAigCECECIAlBCE8EQCAKQQN0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEIaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EIayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBCE8EQCAKQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEP8WIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENg8EO4tIAIoAhQiCkEDdiELIAIoAhAhBQJAIApBCE8EQCALQQN0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EIaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBCGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQhPBEAgC0EDdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABD/FiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQhqIQUgBEEBaiEEIAJBCGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2DwQ7i0gAigCFCIKQQN2IQsgAigCECEFAkACQCAKQQhPBEAgC0EDdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBCGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQhrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEITwRAIAtBA3QhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEP8WIANB0ABqIAMoAhggAygCHBChNgsgBUEIaiEFIARBAWohBCAHQQhrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGYsODAATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmLDgwIGDhowYNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAvMIAIkfwJ+IwBBMGsiCCQAIAAoAhwiAigCIEGGAmshHSACLQAHIQQgAUH/AXEhHiACLwE2QYAISyEfAn8DQAJAIAQhIAJAAkAgAigCJCIDQYYCTwRAIAIoAhAhAwwBCyACKAIgIgRBAXQhBiAEQYYCayELA0ACQCACKAJQIAMgAigCECIFamshAwJAAkACQAJAAkACQAJAAkACQCALIAIoAiBqIAVNBEAgBiACKAIYIgVLDQEgBEEASA0CIAQEQCACKAIUIgUgBCAFaiAE/AoAAAsgAiACLwEMIgUgBEH//wNxIgdrIglBACAFIAlPGzsBDCAFIAdNBEAgAkEAOwE0CyACIAIoAhAgBGsiBTYCECACIAIoAjwgBGs2AjwgAiAFIAIoAoABIgcgBSAHSRs2AoABIAIQlBYgAyAEaiEDCyAAKAIERQRAIAAoAhwhAgwKCyADQQFNDQIgACAAKAIcIgIoAiQgAigCEGogAxDMEyECIAAoAhwiAyACIAMoAiRqIgU2AiQgBSADKAKAASICakEDSQ0IIAMoAhAiByACayEFIAMvATZBgAhNBEAgAiAHRg0IIAVBAWshAiADLQAGQQFGBEAgAyACENkZGgwJCyADKAIYIgcgAkkNBCAHIAJrIgdBA00NBSADKAIwIAMoAhQgAmooAABBsfPd8XlsQQ92Qf7/B3FqIgkvAQAiEiACQf//A3FGDQggAygCIEEBayACcSIHIAMoAiwiFk8NBiADKAIoIAdBAXRqIBI7AQAgCSACOwEADAgLIAMoAhgiAiAFTQRAIAUgAkH45/wAEMMhAAsgBUEBaiIHIAJJDQYgByACQYjo/AAQwyEACyAGIAVBuOf8ABCwOwALIAhBADYCKCAIQQE2AhwgCEHw4/wANgIYIAhCBDcCICAIQRhqQcjn/AAQ7ywACyAIQQA2AiggCEEBNgIcIAhB4Of8ADYCGCAIQgQ3AiAgCEEYakHo5/wAEO8sAAsgAiAHQZjk/AAQrzsAC0EEIAdBqOT8ABCwOwALIAcgFkG45PwAEMMhAAsgAyADKAIUIgIgBWotAABBBXQgAiAHai0AACICcyACQbHz3fF5bEEQdiADLQAGGzYChAELIAMoAoABIAMoAiRBAUZrIgJFDQACQCADLQAGQQFGBEAgAyAFIAIQ4BMMAQsgAyAFIAIQ6xQLIAMgAygCgAEgAms2AoABCyAAKAIcIgIoAiQiA0GFAksNACAAKAIEDQELCyACKAIQIgMgAigCUEGGAmtLBEAgCEEANgIoIAhBATYCHCAIQbTo/AA2AhggCEIENwIgIAhBGGpBvOj8ABDvLAALIAIoAiQiBEGGAk8NACAeRQ0CIARFBEACQCACLQAHRQ0AIANBAWsiAyACKAIYIgRJBEAgAkFAayACQaQBaiACKAIUIANqLQAAEJYjGiAAKAIcQQA6AAcgACgCHCICKAIQIQMMAQsgAyAEQfjj/AAQwyEACyACQQIgAyADQQJPGzYCgAECQCABQf8BcUEERwRAIAAoAhwoAkgNAUEBDAcLIABBARCSAUEDQQIgACgCEBsMBgsgAEEAEJIBIAAoAhBBAEcMBQsgBEEDSw0AIAIgAi8BDDsBDiAAKAIcIQJBAiEDDAELAkACQAJAAkAgAi0ABkEBRgRAIAIgAxDZGSEEDAELIAIoAhgiBCADSQ0BIAQgA2siBEEDTQ0CIAIoAjAgAigCFCADaigAAEGx893xeWxBD3ZB/v8HcWoiBi8BACIEIANB//8DcUYNACACKAIgQQFrIANxIgUgAigCLCIHTw0DIAIoAiggBUEBdGogBDsBACAGIAM7AQALIAAoAhwiAyADLwEMOwEOQQIhAyAAKAIcIgIoAhAgBEH//wNxIgVrIgZBAEwgBiAdSnIgBUVyDQMgAi8BNCACLwE4Tw0DAn8gH0UEQCAIQRBqIAIgBBCTByAIKAIQIQMgCC8BFAwBCyAIQQhqIRxBACEHQQAhDCMAQSBrIgokAAJAAkACQAJAAn8CQAJAAkAgAigCGCIPIAIoAhAiDU8EQEF/QXlBfSACLwE0IgNBAiADGyIDQQdLGyADQQNNGyADaiIJIA9LDQEgAi8BDCEWIAIoAhQiECANaiERIA8gDWshEyACKAIkIRogAi8BCCEXIAIvATYhDiANIAIoAiAiGGtBhgJqIgVBACAFIA1NGyESIAkgEGohFCACLwEKISEgA0EDSQRAIBIhCyAQDAULIBBFIAMgE09yDQIgEUEDaiEFAn8gAi0ABiILQQFGBEAgES0AAiARLQABQQV0cwwBCyARLQACQbHz3fF5bEEQdgshBiADIAVqQQJrIAVGDQMgA0ECayEZIAIoAjAhGwNAIBsgBSAMai0AACIVIAZBBXRB4P8BcXMgFUGx893xeWxBEHYgCxsiBkEBdGovAQAiFSAEQf//A3EiBCAEIBVLIhUbIQQgDEEBaiIMIAcgFRshByAMIBlHDQALDAMLIA0gD0Go4fwAEK87AAsgCSAPQbjh/AAQrzsACyAKQQA2AhggCkEBNgIMIApBzOP8ADYCCCAKQgQ3AhAgCkEIakHU4/wAEO8sAAsgBEH//wNxIAcgEmoiC0H//wNxTQ0BIBQgB0H//wNxIgVrIRQgECAFawshBSAPIAkgDWoiBk8EQCACKAJQIglBhgJrIgxBACAJIAxPGyANTwRAIA0gBEH//wNxTQ0FIBhBAWshGCAOIA5BAnYgAyAXSRshDCAGIBBqIRkgDUEBayEbIBFBAmohFSAJIBBqQQFrISIgAigCMCEjIAIoAighFyACKAIsIQ4gE0ECa0H/AUshJCACLQAGQQFxISUDQAJAAkACQAJAAkACQAJAAkAgA0EITwRAIBkpAAAhJgNAICYgFCAEQf//A3EiAmopAABRBEAgAiAFaikAACARKQAAUQ0DCyAMQQFrIgxB//8DcUUNECAOIAIgGHEiBEsEQCAXIARBAXRqLwEAIgQgC0H//wNxSw0BDBELCyAEIA5BgOL8ABDDIQALIBEpAAAhJgNAICYgBSAEQf//A3EiBmopAAAiJ1ENASAmICeFeqdBA3YiAiADSw0CIAxBAWsiDEH//wNxRQ0PIA4gBiAYcSIESwRAIBcgBEEBdGovAQAiBCALQf//A3FLDQEMEAsLIAQgDkGQ4vwAEMMhAAsgE0EBTQ0BICRFDQIgBSAEQf//A3FqQQJqIQJBACEGA0ACQCAGIBVqLQAAIAIgBmotAABHBEAgBiEJDAELQYACIQkgBkEBaiIGQYACRw0BCwsgCUECaiECCyACIBFqICJLDQICQCACIANLBEAgBCAHayEWIAIgGksEQCAaIQMMDwsgAiAhTw0NAkACQCACQQRPBEBBeUF9IAJBB0sbIAJqIgkgDWoiBiAPTQ0BDA8LIAIgG2oiBiAPSw0OIAJBAWshCSAGIBBqIRkMAQsgBiAQaiEZIAIgFkH//wNxIhRqIA1JDQILIAUgCWohFCACIQMLIAxBAWsiDEH//wNxRQ0NIAQgGHFB//8DcSIEIA5PDQQgFyAEQQF0ai8BACIEIAtB//8DcU0NDQwGCyACQQNrIQdBACEFIBYhA0EAIQQDQAJAIA4gBCAUaiAYcSIGSwRAIBcgBkEBdGovAQAiBiADQf//A3FJBEAgBCEFIAYiAyAEIBJqQf//A3FNDQ8LIAQgB0kNAQwHCyAGIA5BsOP8ABDDIQALIAQgBCAHSWoiBCAHTQ0ACwwEC0ECIBNBoOL8ABCvOwALQdjv/AAQsjsACyAKQQA2AhggCkEBNgIMIApBvOL8ADYCCCAKQgQ3AhAgCkEIakHE4vwAEO8sAAsgBCAOQeTi/AAQwyEACwJAIAJBBGsiByATTQRAIBMgB2tBAk0NASAHIBFqIgQtAAIhBgJAICMCfyAlBEAgBC0AAEEKdEGA+AFxIAQtAAFBBXRzIAZzDAELIAZBsfPd8XlsQRB2C0EBdGovAQAiBCADQf//A3FPBEAgBSASaiELIAUhByADIQQMAQsgBCAHIBJqIgtB//8DcU0NCQsgECAHQf//A3FrIgUgCWohFCACIQMMAgsgByATQfTi/AAQrzsACyAKQQA2AhggCkEBNgIMIApBmOP8ADYCCCAKQgQ3AhAgCkEIakGg4/wAEO8sAAsgDSAEQf//A3FLDQALDAULIApBADYCGCAKQQE2AgwgCkHo4fwANgIIIApCBDcCECAKQQhqQfDh/AAQ7ywACyAGIA9ByOH8ABCvOwALIBogAyADIBpLGyEDDAILIAYgD0HU4vwAEK87AAsgAiEDCyAcIBY7AQQgHCADNgIAIApBIGokACAIKAIIIQMgCC8BDAshBCAAKAIcIAQ7AQwgACgCHCECIANBBUsNA0ECIAMgAi0AA0EBRhshAwwDCyADIARBmOT8ABCvOwALQQQgBEGo5PwAELA7AAsgBSAHQbjk/AAQwyEACwJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLwE0IgVBA0kgAyAFS3IiBARAICBBAXENASACIAM7ATQgACgCHEEBOgAHIAAoAhwiAyADKAIQQQFqNgIQIAAoAhwiAyADKAIkQQFrNgIkDAwLIAIoAkQiBiACKAJIIgNJDQMgBiADayIGQQJNDQQgAi8BDiELIAIoAhAhBiACKAIkIQkgAigCQCADaiIHIAVBA2siAzoAAiAHIAYgC0F/c2oiBUEIdjoAASAHIAU6AAAgAiACKAJIQQNqNgJIIAJB/wEgAi0AOkEBaiIHIAdB/wFPGzoAOiAFQQFrIgUgAigCIEGGAmtPDQUgBRDKKkH/AXFBHk8NBSADQYACTw0GIAIgA0GY5fwAai0AAEECdGpBrAlqIgMgAy8BAEEBajsBACAFEMoqQf8BcSIDQT1PDQcgAiADQQJ0aiIDIAMvAaQTQQFqOwGkEyACKAJIIQcgAigCRCAAKAIcIgMgAy8BNEEBazsBNCAAKAIcIgMgAygCJCADLwE0azYCJEEDayELIAAoAhwiAy8BNCECIAYgCWpBA2siBiADKAIQIgVNDQIgBiAFayIGIAJBAWsiCSAGIAlJGyEGIAVBAWohBSADLQAGQQFHDQEgAyAFIAYQ4BMMAgsgAigCEEEBayIFIAIoAhgiBk8NByACQUBrIAJBpAFqIAIoAhQgBWotAAAQliMNCAwJCyADIAUgBhDrFAsgACgCHEEAOwE0IAAoAhxBADoAByAAKAIcIgMgAygCECACajYCECAHIAtHDQggAEEAEJIBQQAgACgCEEUNCxoMCAsgAyAGQcjk/AAQrzsAC0EDIAZB2OT8ABCwOwALIAhBADYCKCAIQQE2AhwgCEGA5fwANgIYIAhCBDcCICAIQRhqQYjl/AAQ7ywACyADQYACQZjn/AAQwyEACyADQT1BqOf8ABDDIQALIAUgBkGI5PwAEMMhAAsgAEEAEJIBCyAAKAIcIAM7ATQgACgCHCIDIAMoAhBBAWo2AhAgACgCHCIDIAMoAiRBAWs2AiQgACgCEEUNAQsgACgCHCECDAELC0EACyAIQTBqJAALyhMCCn8FfkIKIRAjAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAQIA8gBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAQIA8gECAPIAVBPGoQ9gwgBSgCPA0CIAUpAyghDyAFKQMgIRAgAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EO8eIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACfwJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAJBh4CAgHggESAShFANAhogESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0BIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhE0GIgICAeAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQsygLIAUoAmAgBEEDdGpCADcDAAwDCyAFQRBqIA8gECARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECITNwPAASAPUA0BIAVBmAJqQYmSpMgANgIAIAVCiZKkyJChwoQJNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgBSkC/AEhDyAFKQKEAiETQYKAgIB4CyEBIAAgEzcCDCAAIA83AgQgACABNgIAIAVB3ABqELotDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCzKAsgBSgCYCAEQQN0aiATNwMACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCITNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYASAFQdwAagJ+AkACQCARIBKEUEUEQCARIBKDQn9SIA8gE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQgAMAQsgBSAPIBMgESASEIMZIAUpAwAgECAFKQMIUCIEGyEQIAStCyAQENoLDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCzKAsgBSgCYCAEQQN0akIANwMAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDZFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaCigAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC6LQsgBUGgAmokAA8LQQRBOBCjPQALhh0CDX8BfiMAQbABayIDJAAgASgCMCICQQRqIQQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkF7TQRAIAQgASgCLCIFSw0PIANB8ABqIgQgASgCKCIGIAUgAiACIAZqKAAAaxD2NAJAIARBDBDMIEH//wNxIgRFBEBBACEGDAELIAIgBGoiAkEEaiEEIAJBe0sNAiAEIAVLDQMgAiAGaigAACACaiECCyADQQA2ApABIANBADYCgAEgAyACNgJ8IAMgBTYCeCADIAY2AnQgA0EBNgJwIANBoAFqIQgjAEFAaiICJAAgAiADQfAAaiIGIgUQww8CQAJAAkAgAigCAEEBRgRAIAIpAwghDyACQTRqIgRBBEF/IAUoAhwiByAFKAIsQQAgBSgCIBsiCWoiCiAHIApLGyAJIAUoAhAbQQFqIgdBfyAHGyIHIAdBBE0bQQBBCEEIEKAYIAIoAjghByACKAI0QQFGDQIgAigCPCIJIA83AwAgAkE8aiIKQQE2AgAgAiAJNgI4IAIgBzYCNCACIAVBMPwKAAAjAEEQayIFJAAgBSACEMMPIAUoAgBBAUYEQANAIAUpAwghDyAEKAIIIgcgBCgCAEYEQCAEQX8gAigCHCIJIAIoAixBACACKAIgGyINaiILIAkgC0sbIA0gAigCEBtBAWoiCUF/IAkbEOwtCyAEKAIEIAdBA3RqIA83AwAgBCAHQQFqNgIIIAUgAhDDDyAFKAIADQALCyAFQRBqJAAgCEEIaiAKKAIANgIAIAggAikCNDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgALIAJBQGskAAwBCyAHIAIoAjxB/NT+ABD9LwALIANBADYCGCADIAMoAqgBNgIcIAMgAykCoAE3AhAgASgCMCICQQRqIQQgAkF7Sw0OIAQgASgCLCIFSw0PIAYgASgCKCIEIAUgAiACIARqKAAAaxD2NCAGQQQQzCBB//8DcSIIBH8gAiAIaiICIAVLDQQgAiAEaigAAAVBAAshAiADQQE6ACggAyACNgIkIANBATYCICABKAI0IgIgAigCACIEQQFqNgIAIARBAEgNBCABQTRqIQ0gAyACNgIsIAEoAiAiCEUNCyABKAIkIQpBACEHIANBADYCqAEgA0KAgICAwAA3AqABIANBCGogAkEIahDDNCADKAIMIgJFDQUgAygCCCIJIAJBAnRqIQ4gCkECdCEFA0ACQAJAIAoEQEEAIQYgBSEEIAghAgNAIAIoAgAgB0YNAiAGQQFqIQYgAkEEaiECIARBBGsiBA0ACwsgA0HwAGogASAJKAIAQQhqIANBEGoQygcgAygCcCICQZOAgIB4Rg0BIAAgAykCdDcCCCAAQRBqIANB/ABqKQIANwIAIAAgAjYCBAwJCyADQfAAaiABIAkoAgBBCGogA0EQahCOASADKAJ4IQIgAygCdCEEIAMoAnAiC0GTgICAeEcEQCAAIAMpAnw3AhAgACACNgIMIAAgBDYCCCAAIAs2AgQMCQsgAygCqAEiCyADKAKgAUYEQCADQaABakGk3v4AEJAoCyADKAKkASALQQxsaiIMIAI2AgggDCAENgIEIAwgBjYCACADIAtBAWo2AqgBCyAHQQFqIQcgCUEEaiIJIA5HDQALDAULDA0LIAIgBEHM1f4AELE7AAsgBCAFQczV/gAQsDsACyACIAVBzNT+ABCvOwsACyADKAKoASEEIAMoAqQBIQcgAyADQeQAajYCcAJAIARBAkkNACAEQRVPBEAgA0HwAGohBiMAQYAgayICJAACQEGq2CggBCAEQarYKE8bIgUgBCAEQQF2ayIJIAUgCUsbIglB1gJPBEAjAEEQayIFJAAgBUEEaiAJQQBBBEEMEKAYIAUoAgghCSAFKAIEQQFGBEAgCSAFKAIMQZzu/gAQ/S8ACyAFKAIMIQsgAkEANgIIIAIgCzYCBCACIAk2AgAgBUEQaiQAIAcgBCACKAIEIAIoAggiBUEMbGogAigCACAFayAEQcEASSAGEIAKIAIQ1iYgAkEEQQwQ4B4MAQsgByAEIAJB1QIgBEHBAEkgBhCACgsgAkGAIGokAAwBCwJAIAQEQCAEQQFHBEAgByAEQQxsaiELIAdBDCIFaiEGA0AgBigCACIJIAZBDGsoAgBJBEAgBikCBCEPIAUhBAJ/A0AgBCAHaiICIAJBDGsiDCkCADcCACACQQhqIAxBCGooAgA2AgAgByAEQQxGDQEaIARBDGshBCAJIAJBGGsoAgBJDQALIAQgB2oLIgIgDzcCBCACIAk2AgALIAVBDGohBSAGQQxqIgYgC0cNAAsLDAELAAsLIANB8ABqIAMoAixBCGogCCAKEKcUIANBOGoiAiADQfwAaikCADcDACADQUBrIgQgA0GEAWooAgA2AgAgAyADKQJ0NwMwIAMoAnAiBUUEQCAAIAMpAzA3AgQgAEEUaiAEKAIANgIAIABBDGogAikDADcCAAwBCyADQdAAaiICIANBkAFqKQMANwMAIAMgAykDiAE3A0hBMEEIEK02IghFDQEgCCAFNgIIIAhCgYCAgBA3AwAgCCADKQMwNwIMIAggAykDSDcDICAIQRRqIANBOGopAwA3AgAgCEEcaiADQUBrKAIANgIAIAhBKGogAikDADcDACADKAKgASEEIAMgAygCpAEiAiADKAKoAUEMbGo2AnwgAyAENgJ4IAMgAjYCdCADIAI2AnAgA0HwAGoiBCgCCCELIAQoAgAiBSEHIAQoAgQiAiAEKAIMIgZHBEADQCAHIAJBBGopAgA3AgAgB0EIaiEHIAJBDGoiAiAGRw0ACyAEIAI2AgQLIANB2ABqIQkgC0EMbCEGIwBBEGsiCiQAIARBADYCCCAEKAIMIQwgBCgCBCECIARBBDYCACAKQoCAgIDAADcCCCAKQQhqQQRBDBDgHiAEQQQ2AgwgBEEENgIEIAwgAmtBDG4hDiACIAxHBEAgAkEEaiECA0AgAigCACIMIAwoAgAiDEEBazYCACAMQQFGBEAgAhC7IwsgAkEMaiECIA5BAWsiDg0ACwsgCkEQaiQAIAUhAgJAIAtFDQAgBiAGQXhxIgpGDQAgCkUEQEEEIQIgBkUNASAFIAZBBBD4OgwBCyAFIAZBBCAKEJc1IgINAEEEIAoQoz0ACyAJIAI2AgQgCSAGQQN2NgIAIAkgByAFa0EDdjYCCCMAQRBrIgIkACAEKAIMIgcgBCgCBCIFa0EMbiEGIAUgB0cEQCAFQQRqIQUDQCAFKAIAIgcgBygCACIHQQFrNgIAIAdBAUYEQCAFELsjCyAFQQxqIQUgBkEBayIGDQALCyACIAQoAgA2AgwgAiAEKAIINgIIIAJBCGpBBEEMEOAeIAJBEGokAAJAAkAgAS0AREUEQCADKAIcRQ0BQejd/gBBLEGU3v4AEJ8pAAsgASgCMCICQQRqIQUgAkF7Sw0EIAUgASgCLCIESw0FIANB8ABqIgYgASgCKCIFIAQgAiACIAVqKAAAaxD2NEEAIQEgBkEEEMwgQf//A3EiBgRAIAIgBmoiASAESw0HIAEgBWooAAAhAQsgACADKQJYNwIEIAAgATYCFCAAIAg2AhAgAEEANgIAIABBDGogA0HgAGooAgA2AgAMAQsgACAIIANB2ABqIANBIGoQjTsLIAMoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0HIANBLGoQ+CMMBwsgAEEBNgIAIANBoAFqIgAQ1iYgAEEEQQwQ4B4MBQtBCEEwEKM9AAsgAiAFQdzV/gAQsTsACyAFIARB3NX+ABCwOwALIAEgBEHM1P4AEK87AAsgA0EANgJsIANCgICAgMAANwJkIAMgAkEIahCvLgJAIAMoAgAiAiADKAIEIgZGDQADQAJAIANB8ABqIAEgAigCAEEIaiADQRBqEI4BIAMoAnghBCADKAJ0IQUgAygCcCIIQZOAgIB4Rw0AIAMoAmwiCCADKAJkRgRAIANB5ABqQcTe/gAQmygLIAMoAmggCEEDdGoiByAENgIEIAcgBTYCACADIAhBAWo2AmwgBiACQQRqIgJHDQEMAgsLIAAgAykCfDcCECAAIAQ2AgwgACAFNgIIIAAgCDYCBCAAQQE2AgAgA0HkAGoiABDDJyAAEOo7DAELAkACQCABLQBERQRAIAMoAhxFDQFB6N3+AEEsQbTe/gAQnykACyADKAIsIQggA0GoAWogA0HsAGooAgA2AgAgAyADKQJkNwOgASABKAIwIgJBBGohBCACQXtLDQQgBCABKAIsIgVLDQUgA0HwAGoiBCABKAIoIgEgBSACIAEgAmooAABrEPY0QQAhByAEQQQQzCBB//8DcSIEBEAgAiAEaiICIAVLDQIgASACaigAACEHCyAAIAMpA6ABNwIEIABBDGogA0GoAWooAgA2AgAgACAHNgIUIAAgCDYCECAAQQA2AgAMAwsgAygCLCEBIANB+ABqIANB7ABqKAIANgIAIAMgAykCZDcDcCAAIAEgA0HwAGogA0EgahCNOwwCCyACIAVBzNT+ABCvOwALIAMoAiwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIANBLGoQ+CMLCyADQfAAaiEAIANBEGoiCCECIAMoAhwhBCMAQRBrIgEkACABQQhqIAQQ6joCQCABKAIMIgYgASgCCCIERgRAIABCADcCACAAQQhqQgA3AgAMAQsgACACKAIIIARqIgUgAigCACICQQAgAiAFTRtrIgU2AgAgBiAEayIEIAIgBWsiBk0EQCAAQgA3AgggACAEIAVqNgIEDAELIABBADYCCCAAIAI2AgQgACAEIAZrNgIMCyABQRBqJAAgCBDjPCANKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCANEPgjCyADQbABaiQADwsgAiAEQdzV/gAQsTsACyAEIAVB3NX+ABCwOwAL7CkCFH8BfiMAQZABayIIJAAgASgCCCEJIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQFqNgIIIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQJqIhM2AgggCCADNgJYIAggAjYCVCAIIAM2AmwgCCACNgJoIAEoAhwhBiABKAIYIREgBEH/AXFBAkYhDQNAAkACQAJAIAhB6ABqEO4SIglB2wBMBEACQCAJQT9rDgIEAgALIAlBI0YgCUEvRnINAwwCCyAJQdwARwRAIAlBgIDEAEcNAgwDCyANRQ0CDAELIBEEQCARQQpBAiAOGyAGKAIUEQAACyAIKAJsIQwgCCgCaCEOIAohCwsgCkEBaiEKDAELCwJAAkAgDkUEQCACIQ4gEyEHIAMhDAwBCwJAAkACQCALBEAgC0EASg0BDAMLIAggDDYCICAIIA42AhwgCEGIAWohCSAIQRxqEO4SIgJBI2siA0EcSw0BQQAhEUEBIAN0QYGggIABcUUNAUEAIQoMBAtBACERAkACQAJAA0AgAiADRg0DIAIhCQNAAn8gCSwAACICQQBOBEAgAkH/AXEhCiAJQQFqDAELIAktAAFBP3EhBiACQR9xIQogAkFfTQRAIApBBnQgBnIhCiAJQQJqDAELIAktAAJBP3EgBkEGdHIhBiACQXBJBEAgBiAKQQx0ciEKIAlBA2oMAQsgCkESdEGAgPAAcSAJLQADQT9xIAZBBnRyciIKQYCAxABGDQUgCUEEagshAkEBIAp0QYDMAHFFIApBDUtyRQRAIAMgAiIJRw0BDAULCyAIIAI2AlQCQAJ/QQEgCkGAAUkNABpBAiAKQYAQSQ0AGkEDQQQgCkGAgARJGwsiBiADIAlrIg1PBEAgBiANRg0BDAQLIAYgCWosAABBv39MDQMLIApBgIDEAEYNAwJAIBFFIApBOkZxRQRAIAEoAhgiDQRAIA0gASgCHCAKIAhB1ABqEJAMCyARQQFzIA9yIQ8gCEGAi8QANgIkIAggBjYCICAIIAk2AhwgASAIQRxqEK8eDAELIAEoAgghByALQQFGBEAgByEJIA8gEXJBAXENAwwIC0EBIREgAUEBENgtIAEoAgQgASgCCGpBOjoAACABIAdBAWo2AggLIAtBAUogC0EBayELDQALIA8gEXIhAyARQQFxRQRAIAEoAggiCSEHIANBAXENAQwGCyADQQFxRQ0FIAEoAgghCQsgAUEBENgtIAEoAgQgASgCCGpBwAA6AAAgASAJQQFqNgIIDAQLIAkgDUEAIAZBzIbEABCjNgALQeCKxAAQsjsACyACQYCAxABGIARB/wFxQQJGcg0AQQAhESATIQdBACEKIAJB3ABHDQEMAgsgEyEHCyAIIA42AogBIAhBGGohCSAHIREgDCEKCyAJIAo2AgACQAJAIAgoAogBIgNFBEAgESELDAELIAEoAgghFyAIQegAaiENIAgoAhghD0EAIQxBACEOIwBB4ABrIgYkACAGIA82AhwgBiADNgIYAkACQAJAAkACQAJAAkACQAJAIARB/wFxBEAgAyAPRw0BDAILIAZBLGogAyAPENcIIAYtADAhAyAGKAIsIgdBgYCAgHhGBEAgDUEDOgAAIA0gAzoAAQwJCyAGIAYpADEiGjcDSCAGIAZBOGooAAA2AE8gBigCPCEUIAYoAkAhFSAGQShqIAYoAEs2AAAgBiAaPgAlIAYgAzoAJCAGIAc2AiAgBkEIaiAGQSBqIhYQ3DsgBkEsaiEHIAYoAgghCSAGKAIMIQsjAEEgayIDJAAgAyALNgIcIAMgCTYCGCADQYCAgIB4NgIUIAMgA0EUahCaAwJAIAMtAABBA0YEQCAHIAMtAAE6AAEgB0EDOgAADAELIwBBEGsiCSQAAkACQAJAAkAgAy0AACIYQQFrDgIBAgALIAlBCGoiDCADQQxqKAIANgIAIAkgAykCBDcDACAHQQRqIQojAEEQayILJAACQAJAAkAgCSgCAEGAgICAeEcEQCAKIAkpAgA3AgAgCkEIaiAMKAIANgIADAELIAkoAgQhGSALQQRqIAkoAggiDEEAQQFBARCgGCALKAIIIRAgCygCBEEBRg0BIAsoAgwhEiAMBEAgEiAZIAz8CgAACyAKIAw2AgggCiASNgIEIAogEDYCAAsgC0EQaiQADAELIBAgCygCDEHssMwAEP0vAAsMAgsgByADKAABNgABDAELIAcgAykAATcAASAHQQlqIANBCWopAAA3AAALIAcgGDoAACAJQRBqJAALIANBIGokACAGLQAtIQcgBi0ALCIDQQNGBEAgDUEDOgAAIA0gBzoAASAWEIYwDAkLIAZB2gBqIAZBPmovAQA7AQAgBkHSAGogBkE2aikBADcBACAGIAYpAS43AUogBiAHOgBJIAYgAzoASCAGQcgAakEBciELAkACQAJAIANBAWsOAgABAgsgBkHGAGogC0ECai0AADoAACAGIAsvAAA7AUQgBi0ATCEMDAkLIAZBxgBqIAtBAmotAAA6AAAgBiALLwAAOwFEIAYtAFghDiAGKAJUIQsgBigCUCEPIAYoAkwhDAwICyAGKAJQIg8gBigCVCILQeyLxABBCRDBLkUEQCAGKAJMIQwMCAsgBkHMAGoQ3jtBgICAgHghDEEBIQ9BACELDAcLIAMhBwNAAn8gBywAACIJQQBOBEAgCUH/AXEhCyAHQQFqDAELIActAAFBP3EhCiAJQR9xIQsgCUFfTQRAIAtBBnQgCnIhCyAHQQJqDAELIActAAJBP3EgCkEGdHIhCiAJQXBJBEAgCiALQQx0ciELIAdBA2oMAQsgC0ESdEGAgPAAcSAHLQADQT9xIApBBnRyciELIAdBBGoLIQcCQAJAAkACQAJAAkACQAJAIAtBPkwEQEEBIQ4CQAJAAkAgC0EMTARAIAtBCWtBAkkNAQwKCyALQS5KDQIgC0ENRw0BC0EBIRQMCQsgC0EjRw0HDAkLIAtBOkYNASALQS9GDQgMBgsCQCALQdsAaw4DBAIFAAsgC0GAgMQARg0HIAtBP0cNBQwHCyASRQ0GDAELIARB/wFxQQJHDQULQQEhDiAMQQFqIQwMAwtBASESIAxBAWohDEEBIQ4MAgtBASEOIAxBAWohDEEAIRIMAQtBASEOIAxBAWohDCALQYABSQ0AQQIhDiALQYAQSQ0AQQNBBCALQYCABEkbIQ4LIA4gEGohECAHIA9HDQELCyAUDQELIA8gA2shCSAMQQFqIQcDQCAHQQFrIgcEQCAGQRhqEO4SQYCAxABHDQELCyAQRQ0CIAkgEEsNASAJIBBGDQIMBAsgBkE0aiIDQQA2AgAgBkKAgICAEDcCLCAGQSxqIAZBGGogDBCWKCAGQShqIAMoAgA2AgAgBiAGKQIsNwMgDAILIAMgEGosAABBv39MDQILIAYgEDYCKCAGIAM2AiQgBkGAgICAeDYCIAsCQAJAIARB/wFxQQFGBEAgBkEQaiAGQSBqIgMQ3DsgBigCFA0BIA1BAzsBACADEIYwDAULIAZB0ABqIAZBKGooAgA2AgAgBiAGKQMgNwNIIAZBLGohCyMAQeAAayIDJAAgA0EoaiAGQcgAaiIMENw7IAMoAiwhByADKAIoIANB2wA2AjQgByADQTRqQQEQ9C4hCSADQSBqIAwQ3DsgAygCJCEHIAMoAiAhCgJAAkAgCUUEQCAHIApqIQ8DQAJAAkACQAJAIAogD0cEQAJ/IAosAAAiB0EATgRAIAdB/wFxIQkgCkEBagwBCyAKLQABQT9xIQ4gB0EfcSEJIAdBX00EQCAJQQZ0IA5yIQkgCkECagwBCyAKLQACQT9xIA5BBnRyIQ4gB0FwSQRAIA4gCUEMdHIhCSAKQQNqDAELIAlBEnRBgIDwAHEgCi0AA0E/cSAOQQZ0cnIhCSAKQQRqCyEKAkAgCUEuTARAIAlBDU0NAQwFCyAJQS9rIgdBEU0NAgwDC0EBIAl0QYHMAHFFDQMMBAsgA0EYaiAMENw7IANBoJjEADYCXCADIAMpAxg3AlQgC0EBaiEOIANByABqIQkjAEEwayIHJAAgB0EQaiADQdQAaiIPEOURAkACQCAHKAIQIhAEQCAHKAIUIQogB0EIaiAPEOURIAcoAggiEg0BIAkgCjYCCCAJIBA2AgQgCUGAgICAeDYCAAwCCyAJQQA2AgggCUKAgICAGDcCAAwBCyAHKAIMIRYgB0EkaiAKQQBBAUEBEKAYIAcoAighFCAHKAIkQQFHBEAgBygCLCEVIAoEQCAVIBAgCvwKAAALIAdBIGoiECAKNgIAIAcgFTYCHCAHIBQ2AhggB0EYaiIKIBIgEiAWahCCJiAKIA8Qrx4gCUEIaiAQKAIANgIAIAkgBykCGDcCAAwBCyAUIAcoAixBoLHMABD9LwALIAdBMGokACADQTdqIQcgAygCSEGAgICAeEcEQCAHIAMpAkg3AAAgB0EIaiADQdAAaigCADYAACALQQA6AAAgDiADKQA0NwAAIA5BB2ogA0E7aikAADcAAAwHCyAHIAwpAAA3AAAgB0EIaiAMQQhqKAAANgAAIAtBADoAACAOIAMpADQ3AAAgDkEHaiADQTtqKQAANwAADAcLQQEgB3RBgdAOcQ0CCyAJQdsAa0EESQ0BIAlB/ABHDQIMAQsgCUEgaw4EAAEBAAELCyALQYMKOwEADAELIANB3QA2AjQCQCAHBEAgA0E0akEBIAcgCmpBAWtBARDBLg0BCyALQYMIOwEADAELIANBEGogDBDcOyADKAIUIQcgAygCECEJIANBCGogDBDcOwJAIAMoAgwiDkEBayIKRQ0AAkAgB0EBTQRAIAdBAUYNAQwCCyAJLAABQUBIDQELAkAgByAKTQRAIAcgCkcNAgwBCyAJIApqLAAAQb9/TA0BCyADQTRqIAlBAWogDkECaxCxBiALAn8gAy0ANEEBRgRAIAsgAy0ANToAAUEDDAELIAsgA0E1aiIHKQAANwABIAtBCWogB0EIaikAADcAAEECCzoAAAwBCyAJIAdBASAKQbCYxAAQozYACyAMEIYwCyADQeAAaiQAIAYtAC0hAyAGLQAsIgdBA0YNASANIAYpAS43AQIgDUESaiAGQT5qLwEAOwEAIA1BCmogBkE2aikBADcBACANIAYpAhg3AhQgDSADOgABIA0gBzoAAAwECyAGQdAAaiAGQShqKAIANgIAIAYgBikDIDcDSCAGQSxqIAZByABqEJoDIAYtAC0hAyAGLQAsIgdBA0cEQCANIAYpAS43AQIgDUESaiAGQT5qLwEAOwEAIA1BCmogBkE2aikBADcBACANIAYpAhg3AhQgDSADOgABIA0gBzoAAAwECyANQQM6AAAgDSADOgABDAMLIA1BAzoAACANIAM6AAEMAgsgAyAJQQAgEEHci8QAEKM2AAsgDSADOgAAIA0gBi8BRDsAASANIBU2AhggDSAUNgIUIA0gDjoAECANIAs2AgwgDSAPNgIIIA0gDDYCBCANQQNqIAZBxgBqLQAAOgAAIAZBIGoQhjALIAZB4ABqJAAgCC0AaSELIAgtAGgiA0EDRg0AIAhB5gBqIAhB+gBqLwEAOwEAIAhB3gBqIAhB8gBqKQEANwEAIAggCCkBajcBViAIIAs6AFUgCCADOgBUIAgoAnwhCSAIKAKAASEKIAhBATYCbCAIQZCLxAA2AmggCEIBNwJ0IAhB6QI2AowBIAggCEGIAWo2AnAgCCAIQdQAajYCiAECQAJAIAEgDRDbO0UEQCABKAIIIQYgCC0AVA0BIAhBEGogCEHYAGoQ3DsgCCgCFA0BIAggCjYCbCAIIAk2AmhBqIvEAEEBIA0QhRUhAkEAIQsgBEH/AXFBAkcNAiACRQ0BDAILQcyExABBKyAIQegAakG8hMQAQZiLxAAQ1R4ACyAIIAo2AmwgCCAJNgJoQQAhCwJAAn9BACAIQegAahDuEkE6Rw0AGiAIKAJsIQogCCgCaCEJIAEtACAhB0EAIQ5BACECAkADQCAIIAo2AmwgCCAJNgJoIAhB6ABqEO4SIgNBgIDEAEYNASADQTBrIgxBCkkEQCAIKAJsIQogCCgCaCEJQQEhDiAMIAJBCmxqIgJB//8DTQ0BDAQLCyAHDQAgA0EjayIMQRxNQQBBASAMdEGBoICAAXEbDQAgA0HcAEcNAgsCQCAOQQFxRQRAIAdBAUcNASAIIAo2AmwgCCAJNgJoIAhB6ABqEO4SQYCAxABHDQMMAQsgASgCBCEDAkACQCAFRQ0AIAEoAggiByAFTQRAIAUgB0YNAQwCCyADIAVqLAAAQb9/TA0BCyAIQQhqIQxBASEOQdAAIQcCQCADIAVBtIbEAEEEEMEuDQAgAyAFQb2GxABBAhDBLg0AQbsDIQcgAyAFQbiGxABBBRDBLg0AIAMgBUG/hsQAQQMQwS4NAEEVIQcgAyAFQcKGxABBAxDBLiEOCyAMIAc7AQIgDCAOOwEAIAgvAQhBAXEEQCAILwEKIAJB//8DcUYNAgsgASgCCCEDIAFBARDYLSABKAIEIAEoAghqQTo6AAAgASADQQFqNgIIQQAhAyAIQewAakEAOgAAIAhBADYCaCACIQcCQANAIANBBGpBBEsNASADIAhqQewAaiAHIAdB//8DcSIMQQpuIgdBCmxrQTByOgAAIANBAWshAyAMQQpPDQALIAEgAyAIQe0AaiIHaiAHEIEmQQEMAwtBf0EFQfSUxAAQwyEACyADIAdBACAFQcyLxAAQozYAC0EACyEHIAhB+ABqIAhB5ABqKAIANgIAIAhB8ABqIAhB3ABqKQIANwMAIAggCCkCVDcDaCAIQSRqIAhB6ABqEK4eIAhByABqIAhBLGopAgA3AwAgCEHQAGogCEE0ai0AADoAACAIIAgpAiQ3A0AgEyAXRwRAIAgtAEBFDQMLIAEoAgghEyAIQQE6ABwgCCABIAQgCEEcaiIDIAkgChDNDSAIKAIEIQkgCCgCACELIAMgAUEk/AoAACAAIAMgBCAFIBEgFyAGIAhBQGsgByACIBMgCyAJENEHDAMLQQIhCwsgCC0AVA0AIAhB2ABqEIYwCyAAQQI2AgAgACALOgAEIAEQ3jsLIAhBkAFqJAALhBACEH8DfiMAQfABayIDJAAgA0EwaiABENw7IAMgASgCDCIJNgI8IAMoAjQhCCADKAIwIQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMEBAALQcAAIQEgAigCPCIEQQN2IARBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBUHAABDRNEUNCSAFBEAgBUHAABCtNiIBRQ0MCyADQgA3AugBIAMgATYC5AEgAyAFNgLgAUHAACEGIANBwAA2AtwBIANBkAFqIgQgAkEQahDJNCADQdABaiAEENUJQQAhBCADIAMoAtABQQFGBH8DQCADQdwBaiADKALUASAJaiADKALYASAJaiALIAgQvxggA0HQAWogA0GQAWoQ1QkgAygC0AENAAsgAygC6AEhBCADKALkASEBIAMoAtwBIQYgAygC4AEFIAULNgKgASADIAY2ApwBIANBADYCmAEgAyAENgKUASADIAE2ApABIAMgA0GQAWoQ1zsgAygCACECQRxBBBCtNiIBRQ0KIAFCgYCAgBA3AgAgASADKQKQATcCCCAAIAQ2AgggACACNgIEDAcLIANBQGsgAkEQaiACKAI8ELEmIAMgCDYChAEgAyALNgKAASADKAJ4IQJBwAAhBCADIANBPGo2AogBIAJBBnYiCSACQT9xIghBAEdqIgFBA3QiBUHA////A3FBQGsgBSABQQdxGyIFQcAAENE0RQ0IIAUEQCAFQcAAEK02IgRFDQsLQQAhASACQcAASQ0FA0AgBkEBaiEGQgAhE0IAIRQDQCADQRhqIANBQGsQ1hACQCADKAIYQQFxBEAgAygCiAEoAgAgAygCHGoiCkEDdiIHIAMoAoQBIgtJDQEgByALQaj6ggEQwyEACwwKCyADKAKAASAHai0AACAKQQdxdkEBca0gE4YgFIQhFCATQgF8IhNCwABSDQALIAEgBGogFDcDACABQQhqIQEgBiAJRw0ACwwFC0HAACEMIAIoAgghBSACKAIMIgpBBnYiESAKQT9xIg5BAEdqIgFBA3QiAkHA////AHFBQGsgAiABQQdxGyINQcAAENE0RQ0HIA0EQCANQcAAEK02IgxFDQMLIAUhASAKQcAASQ0DIApBAnQhBiABIQQDQCAEQYACaiEBIA9BAWohD0IAIRNBACECQgAhFANAAkAgAiAGRwRAIAIgBGooAgAgCWoiEkEDdiIQIAhJDQEgECAIQaj6ggEQwyEACwwJCyALIBBqLQAAIBJBB3F2QQFxrSAThiAUhCEUIAJBBGohAiATQgF8IhNCwABSDQALIAcgDGogFDcDACAGQYACayEGIAdBCGohByABIQQgDyARRw0ACwwDC0HAACEBIAIoAjwiBUEDdiAFQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiAUUNCQsgA0IANwLoASADIAE2AuQBIAMgBTYC4AFBwAAhBiADQcAANgLcASADIAIoAgwiBwR/IAIoAggiAiAHQQN0aiEBA0AgA0HcAWogAigCACAJaiACQQRqKAIAIAlqIAsgCBC/GCACQQhqIgIgAUcNAAsgAygC6AEhBCADKALkASEBIAMoAtwBIQYgAygC4AEFIAULNgKgASADIAY2ApwBIANBADYCmAEgAyAENgKUASADIAE2ApABIANBKGogA0GQAWoQ1zsgAygCKCECQRxBBBCtNiIBRQ0HIAFCgYCAgBA3AgAgASADKQKQATcCCCAAIAQ2AgggACACNgIEDAQLQfytgwFBKEGkroMBEJ8pAAtBwAAgDRCjPQALIA4EQCAFIApBAnRqIQQgDq0hFUIAIRNCACEUA0ACQCABIARHBEAgASgCACAJaiIFQQN2IgIgCEkNASACIAhBqPqCARDDIQALDAULIAIgC2otAAAgBUEHcXZBAXGtIBOGIBSEIRQgAUEEaiEBIBNCAXwiEyAVUg0ACyAHIAxqIBQ3AAAgB0EIaiEHCyADIA02AqABIANCgICAgIAINwKYASADIAw2ApABIAMgCkEDdiAKQQdxQQBHaiIBIAcgASAHSRsiAjYClAEgA0EgaiADQZABahDXOyADKAIgIQRBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCkAE3AgggACACNgIIIAAgBDYCBAwCCwwECyAIBEAgCK0hFUIAIRNCACEUA0AgA0EQaiADQUBrENYQAkAgAygCEEEBcQRAIAMoAogBKAIAIAMoAhRqIghBA3YiBiADKAKEASIHSQ0BIAYgB0Go+oIBEMMhAAsMBAsgAygCgAEgBmotAAAgCEEHcXZBAXGtIBOGIBSEIRQgE0IBfCITIBVSDQALIAEgBGogFDcAACABQQhqIQELIAMgBTYCoAEgA0KAgICAgAg3ApgBIAMgBDYCkAEgAyACQQN2IAJBB3FBAEdqIgIgASABIAJLGyICNgKUASADQQhqIANBkAFqENc7IAMoAgghBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCkAE3AgggACACNgIIIAAgBDYCBAsgACABNgIAIAFBEGogA0GYAWopAgA3AgAgAUEYaiADQaABaigCADYCACADQfABaiQADwtBwPuCARCyOwALQbj6ggFBKSADQZABakGwgoMBQeT6ggEQ1R4AC0EEQRwQoz0AC0HAACAFEKM9AAvsEQIMfwF+QQohBiMAQcABayIFJAAgBSADOgALIAEgAhDkISELIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAasfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgBqwiESARfiIRQiCIpyARpyIGQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQYgBUH0AGogBUGsAWoiBygCADYCACAFIAUpAqQBNwJsIAUgBjYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogBygCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiALQQxqIg8Q2zwQ9R4gBC0ANCEBIA8Q2zwhDgJAIAFFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhBkEAIQICQANAAkACQAJAAkACQCALIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgCygCECAGaigCACEBIAUgAzYCsAEgBSABNgKYASADBH8gDSABQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQdBiICAgHgFQYeAgIB4CyEBIAAgBzYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQogBSgCHCIJIARJBEAgDCAJQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIJIAEgCUsbEOgZIAUoAiQhAQsgCgRAIAUoAiAgAWpBACAK/AsACyAFIAQ2AiQLIAUgCDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQrSgLIAUoAhAgBEEBdGpBADsBAAwDCyAFIAEgA20iBzYClAEgB0GAgAJqQYCABEkNASAFQbgBakGDhowYNgIAIAVCg4aMmLDgwIEDNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgACAFKQGiATcBBiAAQQxqIAVBqAFqKQEANwEAIAAgBS8BoAE7AQQgAEGCgICAeDYCAAsgBUEMahC4LQwHCwJAIAUoAhgEQCAFKAIoIghBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQkgBSgCHCIQIARJBEAgDCAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoAiQhAQsgCQRAIAUoAiAgAWpBACAJ/AsACyAFIAQ2AiQLIAUgCjYCKCAFKAIgIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBCAFKAIMRgRAIAVBDGpBhJOAARCtKAsgBSgCECAEQQF0aiAHOwEACyAFIARBAWo2AhQgBkEEaiEGIA4gAkEBaiICRw0BDAQLCwwFC0GglYABELI7AAsgDkUNACAFQRhqIQwgBUGgAWohCiADQX9HIQlBACEGQQAhAgJAA0ACQAJAIAsgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NAiALKAIQIAZqKAIAIQQgBSADNgKYASAFIAQ2ApQBAn8CQCADBEAgCUUgBEGAgICAeEZxRQRAIAQgA20hBEEBDAMLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCiAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEQQEMAgsgBUGHgICAeDYCQAsgBUFAaxCIEUEACyEBIAVBDGogASAEQYCAAmpBgIAESXEgBBDeCwwBCyAMEOY6IAUoAhhFDQMgBSgCKEEBaiIEQQN2IARBB3FBAEdqIgEgBSgCJCIHSwRAIAEgB2shCCAFKAIcIg0gAUkEQCAMIA1BAXQiByABQcD///8DcUFAayABIAFBP3EbIg0gByANSxsQ6BkgBSgCJCEHCyAIBEAgBSgCICAHakEAIAj8CwALIAUgATYCJAsgBSAENgIoIAUoAhQiASAFKAIMRgRAIAVBDGpB9JKAARCtKAsgBSgCECABQQF0akEAOwEAIAUgAUEBajYCFAsgBkEEaiEGIA4gAkEBaiICRw0BDAMLCwwEC0GglYABELI7AAsgBUHkAGoiAiAFQQxqIgMQzhRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGYoIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuC0LIAVBwAFqJAAPC0EEQTgQoz0ACyAFIAsQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcASAFQeQAakHkkoABEO8sAAuwEgIMfwJ+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ7x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQsygLIAUoAhAgBEEDdGpCADcDAAwDCyAFIAQgA20iCDYClAEgCEEATg0BIAVBuAFqQYmSpMgANgIAIAVCiZKkyJChwoQJNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgBSkCoAEhESAAIAUpAqgBNwIMIAAgETcCBCAAQYKAgIB4NgIACyAFQQxqELotDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABELMoCyAFKAIQIARBA3RqIAitNwMACyAFIARBAWo2AhQgB0EEaiEHIA4gAkEBaiICRw0BDAQLCyAFIAEQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcAQwFC0GglYABELI7AAsgDkUNACAFQRhqIQYgBUGgAWohCyADQX9HIQpBACEHQQAhAgNAAkAgBUEMagJ+AkACQAJAIAEgAhCHJUUEQCAFIAI2ApgBIA8Q2zwgAk0NASABKAIQIAdqKAIAIQQgBSADNgKYASAFIAQ2ApQBAkAgAwRAIApFIARBgICAgHhGcUUEQCAEIANtIQQMBgsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASALIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiEjcDQCASp0GTgICAeEcNASAFKAJEIQQMBQsgBUGHgICAeDYCQAsgBUFAaxCIEUIADAQLIAYQ5jogBSgCGEUNASAFKAIoQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAIkIghLBEAgBCAIayEJIAUoAhwiDSAESQRAIAYgDUEBdCIIIARBwP///wNxQUBrIAQgBEE/cRsiDSAIIA1LGxDoGSAFKAIkIQgLIAkEQCAFKAIgIAhqQQAgCfwLAAsgBSAENgIkCyAFIAw2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABELMoCyAFKAIQIARBA3RqQgA3AwAgBSAEQQFqNgIUDAQLIAUgARD8OzYCsAEgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQbABajYCpAEgBSAFQZgBajYCnAEMCAtBoJWAARCyOwALIAStIBEgBEEATiIEGyERIAStCyARENoLCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDZFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaCigAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC6LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC7ISAgx/AX5BCiEHIwBBwAFrIgUkACAFIAM6AAsgASACEOQhIQEgBSADwCICNgJAIAVBCjYCsAECQAJAAkACQCADQf8BcUUEQEEBIQMMAQtBASEDA0ACQCACQQFxBEAgA6wgB6x+IhFCIIinIBGnIgNBH3VHDQEgAkEBRg0DCyAHrCIRIBF+IhFCIIinIBGnIgdBH3VHDQAgAkEBdiECDAELCyAFQQI2AhAgBUGImIABNgIMIAVCAjcCGCAFQfoPNgJwIAVB/A82AmggBSAFQeQAaiIBNgIUIAUgBUFAayICNgJsIAUgBUGwAWo2AmQgBUGgAWoiAyAFQQxqIgQQmQ4gBSgCoAEhByAFQfQAaiAFQawBaiIIKAIANgIAIAUgBSkCpAE3AmwgBSAHNgJoIAVBiICAgHg2AmQgBUEDNgIQIAVBrKWAATYCDCAFQgI3AhggBUH0CzYCTCAFQcQNNgJEIAVB3J2AATYCQCAFIAI2AhQgBSAFQQtqNgJIIAMgBBCZDiABEIgRIAAgBSkCpAE3AgggAEEQaiAIKAIANgIAIAAgBSgCoAE2AgQgAEGCgICAeDYCAAwBCyAFQQxqIAFBDGoiDxDbPBDyHiAELQA0IQIgDxDbPCEOAkAgAkUEQCAORQ0BIAVBGGohDCADQX9HIQ1BACEHQQAhAgJAA0ACQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NBSABKAIQIAdqKAIAIQQgBSADNgKwASAFIAQ2ApgBIAMEfyANIARBgICAgHhHcg0CIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABajYCSCAFIAVBmAFqNgJAIAVBoAFqIAVB5ABqEJkOIAVB4ABqIAVBrAFqKAIANgIAIAUgBSkCpAE3A1ggBSgCoAEhCEGIgICAeAVBh4CAgHgLIQEgACAINgIEIAAgATYCACAAIAUpA1g3AgggAEEQaiAFQeAAaigCADYCAAwCCyAMEOY6IAUoAhhFDQYgBSgCKEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCyAFKAIcIgogBkkEQCAMIApBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgogBCAKSxsQ6BkgBSgCJCEECyALBEAgBSgCICAEakEAIAv8CwALIAUgBjYCJAsgBSAJNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCdKAsgBSgCECAEQQJ0akEANgIADAMLIAUgBCADbSIINgKUASAIQQBODQEgBUG4AWpBiJCgwAA2AgAgBUKIkKDAgIGChAg3A7ABIAVBAjYCaCAFQeClgAE2AmQgBUICNwJwIAVBrQM2AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABaiIBNgJIIAUgBUGUAWo2AkAgBUGgAWogBUHkAGoQmQ4gARCpDCAAIAUpAqQBNwIIIABBEGogBUGsAWooAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIACyAFQQxqELktDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABEJ0oCyAFKAIQIARBAnRqIAg2AgALIAUgBEEBajYCFCAHQQRqIQcgDiACQQFqIgJHDQEMBAsLIAUgARD8OzYCQCAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBQGs2AqQBIAUgBUGwAWo2ApwBDAULQaCVgAEQsjsACyAORQ0AIAVBGGohBiAFQaABaiELIANBf0chCkEAIQdBACECA0ACQCAFQQxqAn8CQAJAAkAgASACEIclRQRAIAUgAjYCmAEgDxDbPCACTQ0BIAEoAhAgB2ooAgAhBCAFIAM2ApgBIAUgBDYClAECQCADBEAgCkUgBEGAgICAeEZxRQRAIAQgA20hBAwGCyAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgK8ASAFQfwPNgK0ASAFIAVBsAFqNgJsIAUgBUGYAWo2ArgBIAUgBUGUAWo2ArABIAsgBUHkAGoQmQ4gBUHIAGogBUGkAWopAgA3AwAgBUHQAGogBUGsAWooAgA2AgAgBUGIgICAeDYCnAEgBSAFKQKcASIRNwNAIBGnQZOAgIB4Rw0BIAUoAkQhBAwFCyAFQYeAgIB4NgJACyAFQUBrEIgRQQAMBAsgBhDmOiAFKAIYRQ0BIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiCEsEQCAEIAhrIQkgBSgCHCINIARJBEAgBiANQQF0IgggBEHA////A3FBQGsgBCAEQT9xGyINIAggDUsbEOgZIAUoAiQhCAsgCQRAIAUoAiAgCGpBACAJ/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQnSgLIAUoAhAgBEECdGpBADYCACAFIARBAWo2AhQMBAsgBSABEPw7NgKwASAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBsAFqNgKkASAFIAVBmAFqNgKcAQwIC0GglYABELI7AAsgBEF/c0EfdgsgBBDfCwsgB0EEaiEHIA4gAkEBaiICRw0ACwsgBUHkAGoiAiAFQQxqIgMQ1BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIoYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVBwAFqJAAPC0EEQTgQoz0ACyAFQeQAakHkkoABEO8sAAuZFQIMfwN+IwBB4ABrIgMkAAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgVBH3UgBUH/////B2txQQFrDgQBBAMCAAsgAyABNgJYIAMgAjYCXCACIAFrIQUCQAJAIAAoAgxBgICAgHhHBEAgAEEMaiIEIAUQ7S0gACAFEO4tIAAoAixFDQEgAiAAKAI8TQ0CQfTFzQBBKkGgxs0AEJ8pAAsgACABIAIQiTsMBwsgBCAFIAAvAUQQqSUgACABIAIQiTsMBgsgAyACNgIcIAMgAEEsaiIKNgIQIAMgAEHEAGo2AhQgAyABNgIYIwBBEGsiByQAIAQgA0EQaiICKAIMIgYgAigCCGsiCEEAIAYgCE8bEO0tIAcgBCkCBEIgiTcCCCAHIARBCGo2AgQgB0EEaiIIKAIEIQYgCCgCACACKAIIIgQgAigCDCIJSQR/IAIoAgQhCyAGIAlqIARrIAgoAgggBkEBdGohBiACKAIAIQgDQCAGIAsvAQAgCCgCBCAEIAgoAgxqIg1BA3ZqLQAAIA1BB3F2QQFxRWs7AQAgBkECaiEGIAkgBEEBaiIERw0ACwUgBgs2AgAgB0EQaiQAIANBCGogChDcOyACIAMoAgggAygCDCAAKAI4IAFqIAUQvxQgAyADQdgAajYCSCMAQRBrIgEkACACQSBqIQQDQAJAAkAgAikDKCIQUEUEQCACKQMwIQ8MAQsDQAJ+AkAgAikDECIPQgNSBEACQAJAAkAgD0ICUQ0AIAIgD1CtQgGGNwMQIA+nQQFxRQ0AIAEgAikDGDcDCAwBCyAEKAIARQ0BIAEgBBC2KiABKQMAIQ8LIA9CAFINAgsgAkIDNwMQCyACKQMAIg9CAlENBCACQgA3AwAgAikDCAwBCyABKQMICyEQIA+nQQFxRQ0CIAIgEDcDKCACIAIpAzBCQH0iDzcDMCAQUA0ACwsgAiAQQgEgEHoiEYaFNwMoIAIoAjgoAgAgEacgD6dqaiEGIAAoAggiByAAKAIARgRAIABBARDuLQsgACgCBCAHQQJ0aiAGNgIAIAAgB0EBajYCCAwBCwsgAUEQaiQADAULIAEgAkEBaiIETQRAIAAoAhBBAnYiBSAETwRAIABBFGohByAAKAIEIQUgBCABayEGIAAoAgwgAUECdGohBCAAKAIYRQ0FIAZBAkkNBwNAAkAgACgCKCABSwRAIAAoAhwgASAAKAIkaiIGQQN2ai0AACAGQQdxdkEBcUUEQCAFIAcQ0BIMAgsgBCgCACIGIARBBGooAgAiCEcEQCADIAg2AlggAyAGNgJUIAUgBiAIEJkCIAMgBzYCGCADIANB1ABqNgIUIAMgA0HYAGo2AhAgBSADQRBqEOYUDAILIAUgBxDREgwBCwwKCyAEQQRqIQQgAiABQQFqIgFHDQALDAcLIAQgBUG0ws0AELA7AAsgASAEQbTCzQAQsTsACyAAKAIMIQggACgCCCEFIAAoAhQEQCABIAJPDQUgAEEQaiEMIAhByABsIQYgA0HcAGohDgJAA0AgACgCJCABSwRAAn8gACgCGCAAKAIgIAFqIgRBA3ZqLQAAIARBB3F2QQFxRQRAAkAgCEUNACAGIQcgBSEEIApFDQADQCAEIAkgARCZAiAEQcgAaiEEIAdByABrIgcNAAsLIAsgASANQQFxGyELQQAhCkEBDAELAkAgDUEBcUUNACADIAE2AlwgAyALNgJYIAhFDQAgBiEHIAUhBANAIAMgDDYCGCADIA42AhQgAyADQdgAajYCECAEIANBEGoQ1hYgBEHIAGohBCAHQcgAayIHDQALCyAJIAEgChshCUEBIQpBAAsiBCENIAIgAUEBaiIBRw0BDAILCwwHCwJAIAQEQCADIAI2AlwgAyALNgJYIAhFDQcgA0HcAGohACAIQcgAbCEEIAUhAQNAIAMgDDYCGCADIAA2AhQgAyADQdgAajYCECABIANBEGoQ1hYgAUHIAGohASAEQcgAayIEDQALDAELIAhFDQYLIApFDQUgCEHIAGwhAQNAIAUgCSACEJkCIAVByABqIQUgAUHIAGsiAQ0ACwwFCyAIRQ0EIAhByABsIQQDQCAFIAEgAhCZAiAFQcgAaiEFIARByABrIgQNAAsMBAsgACgCECAAKAIEIQUgAyAAKAIMIgY2AlAgAEEIaiEHBEAgASACTw0EAkADQCAAKAIgIAFLBEACfwJAAkAgACgCFCABIAAoAhxqIgZBA3ZqLQAAIAZBB3F2QQFxRQRAIARBAXFFDQIgAygCUCIEDQEgAyABIAlrNgIQIAUgByADQRBqENcWDAILIAkgASAEQQFxGyEJQQEMAgsgAyABIARsIgY2AlggAyAEIAlsIgQ2AlQgBSAEIAYQmQIgAyAHNgIcIAMgA0HUAGo2AhggAyADQdgAajYCFCADIANB0ABqNgIQIAUgA0EQahD7EgsgBSAHENISQQALIQQgAUEBaiIBIAJHDQEMAgsLDAYLIARFDQQgAygCUCIARQRAIAMgAiAJazYCECAFIAcgA0EQahDXFgwFCyADIAAgAmwiATYCWCADIAAgCWwiADYCVCAFIAAgARCZAiADIAc2AhwgAyADQdQAajYCGCADIANB2ABqNgIUIAMgA0HQAGo2AhAgBSADQRBqEPsSDAQLIAZFBEAgAyACIAFrNgIQIAUgByADQRBqENcWDAQLIAMgAiAGbCIANgJYIAMgASAGbCIBNgJUIAUgASAAEJkCIAMgBzYCHCADIANB1ABqNgIYIAMgA0HYAGo2AhQgAyADQdAAajYCECAFIANBEGoQ+xIMAwsCQCABIAJBAWoiBE0EQCAAKAIQQQN2IgUgBE8EQCAAQRRqIQcgACgCBCEFIAQgAWshBiAAKAIMIAFBA3RqIQQgACgCGEUNAiAGQQJJDQUDQAJAIAAoAiggAUsEQCAAKAIcIAEgACgCJGoiBkEDdmotAAAgBkEHcXZBAXFFBEAgBSAHENASDAILIAQoAgAiBiAEQQhqKAIAIghHBEAgAyAINgJYIAMgBjYCVCAFIAYgCBCZAiADIAc2AhggAyADQdQAajYCFCADIANB2ABqNgIQIAUgA0EQahDmFAwCCyAFIAcQ0RIMAQsMCAsgBEEIaiEEIAIgAUEBaiIBRw0ACwwFCyAEIAVBtMLNABCwOwALIAEgBEG0ws0AELE7AAsgBkECSQ0CIAIgAWtBAmohAQNAAkAgBCgCACIAIARBCGoiBCgCACICRwRAIAMgAjYCWCADIAA2AlQgBSAAIAIQmQIgAyAHNgIYIAMgA0HUAGo2AhQgAyADQdgAajYCECAFIANBEGoQ5hQMAQsgBSAHENESCyABQQFrIgFBA08NAAsMAgsgBkECSQ0BIAIgAWtBAmohAQNAAkAgBCgCACIAIARBBGoiBCgCACICRwRAIAMgAjYCWCADIAA2AlQgBSAAIAIQmQIgAyAHNgIYIAMgA0HUAGo2AhQgAyADQdgAajYCECAFIANBEGoQ5hQMAQsgBSAHENESCyABQQFrIgFBA08NAAsMAQsgACgCGEGAgICAeEYNACAAQRhqIAUgAC8BRhCpJQsgA0HgAGokAA8LQYSszQBBIEGkrM0AEJ8pAAuyEgIMfwF+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ8x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQrSgLIAUoAhAgBEEBdGpBADsBAAwDCyAFIAQgA20iCDYClAEgCEGAgARJDQEgBUG4AWpBh46cODYCACAFQoeOnLjw4MGDBzcDsAEgBUECNgJoIAVB4KWAATYCZCAFQgI3AnAgBUGtAzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqIgE2AkggBSAFQZQBajYCQCAFQaABaiAFQeQAahCZDiABEKkMIAAgBSkBogE3AQYgAEEMaiAFQagBaikBADcBACAAIAUvAaABOwEEIABBgoCAgHg2AgALIAVBDGoQuC0MBwsCQCAFKAIYBEAgBSgCKCIJQQFqIgtBA3YgC0EHcUEAR2oiBiAFKAIkIgRLBEAgBiAEayEKIAUoAhwiECAGSQRAIAwgEEEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiECAEIBBLGxDoGSAFKAIkIQQLIAoEQCAFKAIgIARqQQAgCvwLAAsgBSAGNgIkCyAFIAs2AiggBSgCICAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAIsQQFqNgIsCyAFKAIUIgQgBSgCDEYEQCAFQQxqQYSTgAEQrSgLIAUoAhAgBEEBdGogCDsBAAsgBSAEQQFqNgIUIAdBBGohByAOIAJBAWoiAkcNAQwECwsgBSABEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEMBQtBoJWAARCyOwALIA5FDQAgBUEYaiEGIAVBoAFqIQsgA0F/RyEKQQAhB0EAIQIDQAJAIAVBDGoCfwJAAkACQCABIAIQhyVFBEAgBSACNgKYASAPENs8IAJNDQEgASgCECAHaigCACEEIAUgAzYCmAEgBSAENgKUAQJAIAMEQCAKRSAEQYCAgIB4RnFFBEAgBCADbSEEDAYLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCyAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEDAULIAVBh4CAgHg2AkALIAVBQGsQiBFBAAwECyAGEOY6IAUoAhhFDQEgBSgCKEEBaiIMQQN2IAxBB3FBAEdqIgQgBSgCJCIISwRAIAQgCGshCSAFKAIcIg0gBEkEQCAGIA1BAXQiCCAEQcD///8DcUFAayAEIARBP3EbIg0gCCANSxsQ6BkgBSgCJCEICyAJBEAgBSgCICAIakEAIAn8CwALIAUgBDYCJAsgBSAMNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCtKAsgBSgCECAEQQF0akEAOwEAIAUgBEEBajYCFAwECyAFIAEQ/Ds2ArABIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUGwAWo2AqQBIAUgBUGYAWo2ApwBDAgLQaCVgAEQsjsACyAEQYCABEkLIAQQ3gsLIAdBBGohByAOIAJBAWoiAkcNAAsLIAVB5ABqIgIgBUEMaiIDEM8UQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBwJ+AATYCCCAAIAE2AgQgAEGTgICAeDYCACADELgtCyAFQcABaiQADwtBBEE4EKM9AAsgBUHkAGpB5JKAARDvLAALrxICDH8BfkEKIQcjAEHAAWsiBSQAIAUgAzoACyABIAIQ5CEhASAFIAPAIgI2AkAgBUEKNgKwAQJAAkACQAJAIANB/wFxRQRAQQEhAwwBC0EBIQMDQAJAIAJBAXEEQCADrCAHrH4iEUIgiKcgEaciA0EfdUcNASACQQFGDQMLIAesIhEgEX4iEUIgiKcgEaciB0EfdUcNACACQQF2IQIMAQsLIAVBAjYCECAFQYiYgAE2AgwgBUICNwIYIAVB+g82AnAgBUH8DzYCaCAFIAVB5ABqIgE2AhQgBSAFQUBrIgI2AmwgBSAFQbABajYCZCAFQaABaiIDIAVBDGoiBBCZDiAFKAKgASEHIAVB9ABqIAVBrAFqIggoAgA2AgAgBSAFKQKkATcCbCAFIAc2AmggBUGIgICAeDYCZCAFQQM2AhAgBUGspYABNgIMIAVCAjcCGCAFQfQLNgJMIAVBxA02AkQgBUHcnYABNgJAIAUgAjYCFCAFIAVBC2o2AkggAyAEEJkOIAEQiBEgACAFKQKkATcCCCAAQRBqIAgoAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIADAELIAVBDGogAUEMaiIPENs8EPAeIAQtADQhAiAPENs8IQ4CQCACRQRAIA5FDQEgBUEYaiEMIANBf0chDUEAIQdBACECAkADQAJAAkACQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDxDbPCACTQ0FIAEoAhAgB2ooAgAhBCAFIAM2ArABIAUgBDYCmAEgAwR/IA0gBEGAgICAeEdyDQIgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqNgJIIAUgBUGYAWo2AkAgBUGgAWogBUHkAGoQmQ4gBUHgAGogBUGsAWooAgA2AgAgBSAFKQKkATcDWCAFKAKgASEIQYiAgIB4BUGHgICAeAshASAAIAg2AgQgACABNgIAIAAgBSkDWDcCCCAAQRBqIAVB4ABqKAIANgIADAILIAwQ5jogBSgCGEUNBiAFKAIoQQFqIglBA3YgCUEHcUEAR2oiBiAFKAIkIgRLBEAgBiAEayELIAUoAhwiCiAGSQRAIAwgCkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiCiAEIApLGxDoGSAFKAIkIQQLIAsEQCAFKAIgIARqQQAgC/wLAAsgBSAGNgIkCyAFIAk2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABEKMoCyAFKAIQIARqQQA6AAAMAwsgBSAEIANtIgg2ApQBIAhBgAFqQYACSQ0BIAVBuAFqQYKEiBA2AgAgBUKChIiQoMCAgQI3A7ABIAVBAjYCaCAFQeClgAE2AmQgBUICNwJwIAVBrQM2AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABaiIBNgJIIAUgBUGUAWo2AkAgBUGgAWogBUHkAGoQmQ4gARCpDCAAIAUpAKEBNwAFIABBDGogBUGoAWopAAA3AAAgACAFLQCgAToABCAAQYKAgIB4NgIACyAFQQxqELctDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABEKMoCyAFKAIQIARqIAg6AAALIAUgBEEBajYCFCAHQQRqIQcgDiACQQFqIgJHDQEMBAsLIAUgARD8OzYCQCAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBQGs2AqQBIAUgBUGwAWo2ApwBDAULQaCVgAEQsjsACyAORQ0AIAVBGGohBiAFQaABaiELIANBf0chCkEAIQdBACECA0ACQCAFQQxqAn8CQAJAAkAgASACEIclRQRAIAUgAjYCmAEgDxDbPCACTQ0BIAEoAhAgB2ooAgAhBCAFIAM2ApgBIAUgBDYClAECQCADBEAgCkUgBEGAgICAeEZxRQRAIAQgA20hBAwGCyAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgK8ASAFQfwPNgK0ASAFIAVBsAFqNgJsIAUgBUGYAWo2ArgBIAUgBUGUAWo2ArABIAsgBUHkAGoQmQ4gBUHIAGogBUGkAWopAgA3AwAgBUHQAGogBUGsAWooAgA2AgAgBUGIgICAeDYCnAEgBSAFKQKcASIRNwNAIBGnQZOAgIB4Rw0BIAUoAkQhBAwFCyAFQYeAgIB4NgJACyAFQUBrEIgRQQAMBAsgBhDmOiAFKAIYRQ0BIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiCEsEQCAEIAhrIQkgBSgCHCINIARJBEAgBiANQQF0IgggBEHA////A3FBQGsgBCAEQT9xGyINIAggDUsbEOgZIAUoAiQhCAsgCQRAIAUoAiAgCGpBACAJ/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQoygLIAUoAhAgBGpBADoAACAFIARBAWo2AhQMBAsgBSABEPw7NgKwASAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBsAFqNgKkASAFIAVBmAFqNgKcAQwIC0GglYABELI7AAsgBEGAAWpBgAJJCyAEEPELCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDWFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdCjgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC84QAg1/AX4jAEHAAWsiAyQAIANBOGogAkEMaiIEENs8QQFqQQBBCEEIEKAYIAMoAjwhBQJAAkACQAJAIAMoAjhBAUcEQCADQQA2AjQgAyADKAJAIgc2AjAgAyAFNgIsIAUEfyAHBSADQSxqQfCrggEQsyggAygCMAtCADcDACADQQE2AjQgASgCECEMIAEoAhQgA0E4aiABEJM2IAIQ8hJBA3YhBwJAIAEQtzoNACACEK46DQAgA0EsaiAEENs8EOwtIAIoAhQiCkECdiEJIAIoAhAhAiAKQQRJDQMgCUECdCEFIAIhBANAAkAgByAEKAIAIgZBAWoiC0sEQCAGIAdJDQEgBiAHQcCsggEQwyEACyALIAdBsKyCARDDIQALIAwgC0EDdGooAgAgDCAGQQN0aigCAGsgCGoiCK0hECADKAI0IgYgAygCLEYEQCADQSxqQdCsggEQsygLIARBBGohBCADKAIwIAZBA3RqIBA3AwAgAyAGQQFqNgI0IAVBBGsiBQ0ACwwDCyACEK46DQEgA0EsaiAEENs8EOwtIAIoAhQiCkECdiEJIAIoAhAhAgJAAkACQCAKQQRPBEAgCUECdCEFIAIhBANAIAEgBCgCACIGEJU7BEAgBkEBaiILIAdPDQQgBiAHTw0DIAggDCALQQN0aigCAGogDCAGQQN0aigCAGshCAsgAygCNCIGIAMoAixGBEAgA0EsakGwrYIBELMoCyAEQQRqIQQgAygCMCAGQQN0aiAIrTcDACADIAZBAWo2AjQgBUEEayIFDQALCyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBBE8EQCAJQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEPIWIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAYLIAYgB0GgrYIBEMMhAAsgCyAHQZCtggEQwyEACyAFIAMoArgBQfCsggEQ/S8ACyAFIAMoAkBB4KuCARD9LwALIAEQtzoEQCADKAI4BEAgA0EsaiAEENs8EOwtIAIoAhQiC0ECdiENIAIoAhAhCAJAAkACQAJAIAtBBE8EQCANQQJ0IQogAygCRCECIAMoAjwhDyADKAJIIQQgCCEFA0AgBEUNBSAPIAJBA3ZqLQAAIAJBB3F2QQFxBEAgBSgCACIJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQYCvggEQsygLIAVBBGohBSADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFrIQQgAkEBaiECIApBBGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASECIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCALQQRPBEAgDUECdCEHIAMoAkQhAiADKAI8IQUgAygCSCEEA0ACQCAEBEAgBSACQQN2ai0AACACQQdxdkEBcUUNASADQSBqIAEgCCgCABDyFiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAIQQRqIQggBEEBayEEIAJBAWohAiAHQQRrIgcNAAsgAygCWCEECwwHCyAJIAdB8K6CARDDIQALIA4gB0HgroIBEMMhAAsgAiADKAK4AUHAroIBEP0vAAtBkPSBAUEgQbD0gQEQnykAC0GgroIBELI7AAsgA0EsaiAEENs8EOwtIAIoAhQiC0ECdiENIAIoAhAhBQJAAkACQCALQQRPBEAgDUECdCEKQQAhBCAFIQgDQCAIKAIAIQkgAiAEEIs7BEAgCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGQroIBELMoCyAIQQRqIQggAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBaiEEIApBBGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASEIIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgCDYCUCALQQRPBEAgDUECdCEHA0AgAiAEEIs7BEAgA0EYaiABIAUoAgAQ8hYgA0HQAGogAygCGCADKAIcEKE2CyAFQQRqIQUgBEEBaiEEIAdBBGsiBw0ACyADKAJYIQQLDAQLIAkgB0GAroIBEMMhAAsgDiAHQfCtggEQwyEACyAIIAMoArgBQdCtggEQ/S8ACyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAUEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBBE8EQCAJQQJ0IQQDQCADQQhqIAEgAigCABDyFiADQdAAaiADKAIIIAMoAgwQoTYgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEQIANB7ABqIANBoAFqEL0YIAMgBDYCuAEgAyAQNwOwASADQfgAaiADQbABahCTGSADQegAakGWrNiwATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClqzYsOHChYsWNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAACADQcABaiQADwsgBSADKAK4AUGQrIIBEP0vAAvOEAINfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBBDbPEEBakEAQQhBCBCgGCADKAI8IQUCQAJAAkACQCADKAI4QQFHBEAgA0EANgI0IAMgAygCQCIHNgIwIAMgBTYCLCAFBH8gBwUgA0EsakHwq4IBELMoIAMoAjALQgA3AwAgA0EBNgI0IAEoAhAhDCABKAIUIANBOGogARCTNiACEPISQQN2IQcCQCABELc6DQAgAhCuOg0AIANBLGogBBDbPBDsLSACKAIUIgpBAnYhCSACKAIQIQIgCkEESQ0DIAlBAnQhBSACIQQDQAJAIAcgBCgCACIGQQFqIgtLBEAgBiAHSQ0BIAYgB0HArIIBEMMhAAsgCyAHQbCsggEQwyEACyAMIAtBA3RqKAIAIAwgBkEDdGooAgBrIAhqIgitIRAgAygCNCIGIAMoAixGBEAgA0EsakHQrIIBELMoCyAEQQRqIQQgAygCMCAGQQN0aiAQNwMAIAMgBkEBajYCNCAFQQRrIgUNAAsMAwsgAhCuOg0BIANBLGogBBDbPBDsLSACKAIUIgpBAnYhCSACKAIQIQICQAJAAkAgCkEETwRAIAlBAnQhBSACIQQDQCABIAQoAgAiBhCVOwRAIAZBAWoiCyAHTw0EIAYgB08NAyAIIAwgC0EDdGooAgBqIAwgBkEDdGooAgBrIQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCzKAsgBEEEaiEEIAMoAjAgBkEDdGogCK03AwAgAyAGQQFqNgI0IAVBBGsiBQ0ACwsgA0GwAWogCEEAQQFBARCgGCADKAK0ASEFIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgBTYCUCAKQQRPBEAgCUECdCEEA0AgASACKAIAIgUQlTsEQCADQRBqIAEgBRDxFiADQdAAaiADKAIQIAMoAhQQoTYLIAJBBGohAiAEQQRrIgQNAAsgAygCWCEECwwGCyAGIAdBoK2CARDDIQALIAsgB0GQrYIBEMMhAAsgBSADKAK4AUHwrIIBEP0vAAsgBSADKAJAQeCrggEQ/S8ACyABELc6BEAgAygCOARAIANBLGogBBDbPBDsLSACKAIUIgtBAnYhDSACKAIQIQgCQAJAAkACQCALQQRPBEAgDUECdCEKIAMoAkQhAiADKAI8IQ8gAygCSCEEIAghBQNAIARFDQUgDyACQQN2ai0AACACQQdxdkEBcQRAIAUoAgAiCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGAr4IBELMoCyAFQQRqIQUgAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBayEEIAJBAWohAiAKQQRrIgoNAAsLIANBsAFqIAZBAEEBQQEQoBggAygCtAEhAiADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAI2AlAgC0EETwRAIA1BAnQhByADKAJEIQIgAygCPCEFIAMoAkghBANAAkAgBARAIAUgAkEDdmotAAAgAkEHcXZBAXFFDQEgA0EgaiABIAgoAgAQ8RYgA0HQAGogAygCICADKAIkEKE2DAELQZD0gQFBIEGw9IEBEJ8pAAsgCEEEaiEIIARBAWshBCACQQFqIQIgB0EEayIHDQALIAMoAlghBAsMBwsgCSAHQfCuggEQwyEACyAOIAdB4K6CARDDIQALIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIANBLGogBBDbPBDsLSACKAIUIgtBAnYhDSACKAIQIQUCQAJAAkAgC0EETwRAIA1BAnQhCkEAIQQgBSEIA0AgCCgCACEJIAIgBBCLOwRAIAlBAWoiDiAHTw0EIAcgCU0NAyAGIAwgDkEDdGooAgBqIAwgCUEDdGooAgBrIQYLIAMoAjQiCSADKAIsRgRAIANBLGpBkK6CARCzKAsgCEEEaiEIIAMoAjAgCUEDdGogBq03AwAgAyAJQQFqNgI0IARBAWohBCAKQQRrIgoNAAsLIANBsAFqIAZBAEEBQQEQoBggAygCtAEhCCADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAg2AlAgC0EETwRAIA1BAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEPEWIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwECyAJIAdBgK6CARDDIQALIA4gB0HwrYIBEMMhAAsgCCADKAK4AUHQrYIBEP0vAAsgA0GwAWogCEEAQQFBARCgGCADKAK0ASEFIAMoArABQQFGDQFBACEEIANBADYCWCADIAMoArgBNgJUIAMgBTYCUCAKQQRPBEAgCUECdCEEA0AgA0EIaiABIAIoAgAQ8RYgA0HQAGogAygCCCADKAIMEKE2IAJBBGohAiAEQQRrIgQNAAsgAygCWCEECwsgA0GoAWogA0E0aigCADYCACADIAMpAiw3A6ABIAMpA1AhECADQewAaiADQaABahC9GCADIAQ2ArgBIAMgEDcDsAEgA0H4AGogA0GwAWoQkxkgA0HoAGpBmbLkyAE2AgAgA0GMAWogA0FAaykCADcCACADQZQBaiADQcgAaikCADcCACADQpmy5MiRo8aMGTcDYCADIAMpAjg3AoQBIAAgA0HgAGpBPPwKAAAgA0HAAWokAA8LIAUgAygCuAFBkKyCARD9LwALzhACDX8BfiMAQcABayIDJAAgA0E4aiACQQxqIgQQ2DxBAWpBAEEIQQgQoBggAygCPCEFAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBzYCMCADIAU2AiwgBQR/IAcFIANBLGpB8KuCARCzKCADKAIwC0IANwMAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkEDdiEHAkAgARC3Og0AIAIQrjoNACADQSxqIAQQ2DwQ7C0gAigCFCIKQQN2IQkgAigCECECIApBCEkNAyAJQQN0IQUgAiEEA0ACQCAHIAQoAgAiBkEBaiILSwRAIAYgB0kNASAGIAdBwKyCARDDIQALIAsgB0GwrIIBEMMhAAsgDCALQQN0aigCACAMIAZBA3RqKAIAayAIaiIIrSEQIAMoAjQiBiADKAIsRgRAIANBLGpB0KyCARCzKAsgBEEIaiEEIAMoAjAgBkEDdGogEDcDACADIAZBAWo2AjQgBUEIayIFDQALDAMLIAIQrjoNASADQSxqIAQQ2DwQ7C0gAigCFCIKQQN2IQkgAigCECECAkACQAJAIApBCE8EQCAJQQN0IQUgAiEEA0AgASAEKAIAIgYQlTsEQCAGQQFqIgsgB08NBCAGIAdPDQMgCCAMIAtBA3RqKAIAaiAMIAZBA3RqKAIAayEICyADKAI0IgYgAygCLEYEQCADQSxqQbCtggEQsygLIARBCGohBCADKAIwIAZBA3RqIAitNwMAIAMgBkEBajYCNCAFQQhrIgUNAAsLIANBsAFqIAhBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgCkEITwRAIAlBA3QhBANAIAEgAigCACIFEJU7BEAgA0EQaiABIAUQ8hYgA0HQAGogAygCECADKAIUEKE2CyACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMBgsgBiAHQaCtggEQwyEACyALIAdBkK2CARDDIQALIAUgAygCuAFB8KyCARD9LwALIAUgAygCQEHgq4IBEP0vAAsgARC3OgRAIAMoAjgEQCADQSxqIAQQ2DwQ7C0gAigCFCILQQN2IQ0gAigCECEIAkACQAJAAkAgC0EITwRAIA1BA3QhCiADKAJEIQIgAygCPCEPIAMoAkghBCAIIQUDQCAERQ0FIA8gAkEDdmotAAAgAkEHcXZBAXEEQCAFKAIAIglBAWoiDiAHTw0EIAcgCU0NAyAGIAwgDkEDdGooAgBqIAwgCUEDdGooAgBrIQYLIAMoAjQiCSADKAIsRgRAIANBLGpBgK+CARCzKAsgBUEIaiEFIAMoAjAgCUEDdGogBq03AwAgAyAJQQFqNgI0IARBAWshBCACQQFqIQIgCkEIayIKDQALCyADQbABaiAGQQBBAUEBEKAYIAMoArQBIQIgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyACNgJQIAtBCE8EQCANQQN0IQcgAygCRCECIAMoAjwhBSADKAJIIQQDQAJAIAQEQCAFIAJBA3ZqLQAAIAJBB3F2QQFxRQ0BIANBIGogASAIKAIAEPIWIANB0ABqIAMoAiAgAygCJBChNgwBC0GQ9IEBQSBBsPSBARCfKQALIAhBCGohCCAEQQFrIQQgAkEBaiECIAdBCGsiBw0ACyADKAJYIQQLDAcLIAkgB0HwroIBEMMhAAsgDiAHQeCuggEQwyEACyACIAMoArgBQcCuggEQ/S8AC0GQ9IEBQSBBsPSBARCfKQALQaCuggEQsjsACyADQSxqIAQQ2DwQ7C0gAigCFCILQQN2IQ0gAigCECEFAkACQAJAIAtBCE8EQCANQQN0IQpBACEEIAUhCANAIAgoAgAhCSACIAQQizsEQCAJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQsygLIAhBCGohCCADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFqIQQgCkEIayIKDQALCyADQbABaiAGQQBBAUEBEKAYIAMoArQBIQggAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAINgJQIAtBCE8EQCANQQN0IQcDQCACIAQQizsEQCADQRhqIAEgBSgCABDyFiADQdAAaiADKAIYIAMoAhwQoTYLIAVBCGohBSAEQQFqIQQgB0EIayIHDQALIAMoAlghBAsMBAsgCSAHQYCuggEQwyEACyAOIAdB8K2CARDDIQALIAggAygCuAFB0K2CARD9LwALIANBsAFqIAhBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0BQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgCkEITwRAIAlBA3QhBANAIANBCGogASACKAIAEPIWIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsLIANBqAFqIANBNGooAgA2AgAgAyADKQIsNwOgASADKQNQIRAgA0HsAGogA0GgAWoQvRggAyAENgK4ASADIBA3A7ABIANB+ABqIANBsAFqEJMZIANB6ABqQZas2LABNgIAIANBjAFqIANBQGspAgA3AgAgA0GUAWogA0HIAGopAgA3AgAgA0KWrNiw4cKFixY3A2AgAyADKQI4NwKEASAAIANB4ABqQTz8CgAAIANBwAFqJAAPCyAFIAMoArgBQZCsggEQ/S8AC84QAg1/AX4jAEHAAWsiAyQAIANBOGogAkEMaiIEENg8QQFqQQBBCEEIEKAYIAMoAjwhBQJAAkACQAJAIAMoAjhBAUcEQCADQQA2AjQgAyADKAJAIgc2AjAgAyAFNgIsIAUEfyAHBSADQSxqQfCrggEQsyggAygCMAtCADcDACADQQE2AjQgASgCECEMIAEoAhQgA0E4aiABEJM2IAIQ8xJBA3YhBwJAIAEQtzoNACACEK46DQAgA0EsaiAEENg8EOwtIAIoAhQiCkEDdiEJIAIoAhAhAiAKQQhJDQMgCUEDdCEFIAIhBANAAkAgByAEKAIAIgZBAWoiC0sEQCAGIAdJDQEgBiAHQcCsggEQwyEACyALIAdBsKyCARDDIQALIAwgC0EDdGooAgAgDCAGQQN0aigCAGsgCGoiCK0hECADKAI0IgYgAygCLEYEQCADQSxqQdCsggEQsygLIARBCGohBCADKAIwIAZBA3RqIBA3AwAgAyAGQQFqNgI0IAVBCGsiBQ0ACwwDCyACEK46DQEgA0EsaiAEENg8EOwtIAIoAhQiCkEDdiEJIAIoAhAhAgJAAkACQCAKQQhPBEAgCUEDdCEFIAIhBANAIAEgBCgCACIGEJU7BEAgBkEBaiILIAdPDQQgBiAHTw0DIAggDCALQQN0aigCAGogDCAGQQN0aigCAGshCAsgAygCNCIGIAMoAixGBEAgA0EsakGwrYIBELMoCyAEQQhqIQQgAygCMCAGQQN0aiAIrTcDACADIAZBAWo2AjQgBUEIayIFDQALCyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBCE8EQCAJQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEPEWIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAYLIAYgB0GgrYIBEMMhAAsgCyAHQZCtggEQwyEACyAFIAMoArgBQfCsggEQ/S8ACyAFIAMoAkBB4KuCARD9LwALIAEQtzoEQCADKAI4BEAgA0EsaiAEENg8EOwtIAIoAhQiC0EDdiENIAIoAhAhCAJAAkACQAJAIAtBCE8EQCANQQN0IQogAygCRCECIAMoAjwhDyADKAJIIQQgCCEFA0AgBEUNBSAPIAJBA3ZqLQAAIAJBB3F2QQFxBEAgBSgCACIJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQYCvggEQsygLIAVBCGohBSADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFrIQQgAkEBaiECIApBCGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASECIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCALQQhPBEAgDUEDdCEHIAMoAkQhAiADKAI8IQUgAygCSCEEA0ACQCAEBEAgBSACQQN2ai0AACACQQdxdkEBcUUNASADQSBqIAEgCCgCABDxFiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAIQQhqIQggBEEBayEEIAJBAWohAiAHQQhrIgcNAAsgAygCWCEECwwHCyAJIAdB8K6CARDDIQALIA4gB0HgroIBEMMhAAsgAiADKAK4AUHAroIBEP0vAAtBkPSBAUEgQbD0gQEQnykAC0GgroIBELI7AAsgA0EsaiAEENg8EOwtIAIoAhQiC0EDdiENIAIoAhAhBQJAAkACQCALQQhPBEAgDUEDdCEKQQAhBCAFIQgDQCAIKAIAIQkgAiAEEIs7BEAgCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGQroIBELMoCyAIQQhqIQggAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBaiEEIApBCGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASEIIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgCDYCUCALQQhPBEAgDUEDdCEHA0AgAiAEEIs7BEAgA0EYaiABIAUoAgAQ8RYgA0HQAGogAygCGCADKAIcEKE2CyAFQQhqIQUgBEEBaiEEIAdBCGsiBw0ACyADKAJYIQQLDAQLIAkgB0GAroIBEMMhAAsgDiAHQfCtggEQwyEACyAIIAMoArgBQdCtggEQ/S8ACyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAUEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBCE8EQCAJQQN0IQQDQCADQQhqIAEgAigCABDxFiADQdAAaiADKAIIIAMoAgwQoTYgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEQIANB7ABqIANBoAFqEL0YIAMgBDYCuAEgAyAQNwOwASADQfgAaiADQbABahCTGSADQegAakGZsuTIATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmbLkyJGjxowZNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAACADQcABaiQADwsgBSADKAK4AUGQrIIBEP0vAAunEgIMfwF+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ9x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQqRkLIAUoAhAgBGpBADoAAAwDCyAFIAQgA20iCDYClAEgCEGAAkkNASAFQbgBakGGjJgwNgIAIAVChoyYsODAgYMGNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgACAFKQChATcABSAAQQxqIAVBqAFqKQAANwAAIAAgBS0AoAE6AAQgAEGCgICAeDYCAAsgBUEMahC3LQwHCwJAIAUoAhgEQCAFKAIoIglBAWoiC0EDdiALQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQogBSgCHCIQIAZJBEAgDCAQQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIQIAQgEEsbEOgZIAUoAiQhBAsgCgRAIAUoAiAgBGpBACAK/AsACyAFIAY2AiQLIAUgCzYCKCAFKAIgIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBCAFKAIMRgRAIAVBDGpBhJOAARCpGQsgBSgCECAEaiAIOgAACyAFIARBAWo2AhQgB0EEaiEHIA4gAkEBaiICRw0BDAQLCyAFIAEQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcAQwFC0GglYABELI7AAsgDkUNACAFQRhqIQYgBUGgAWohCyADQX9HIQpBACEHQQAhAgNAAkAgBUEMagJ/AkACQAJAIAEgAhCHJUUEQCAFIAI2ApgBIA8Q2zwgAk0NASABKAIQIAdqKAIAIQQgBSADNgKYASAFIAQ2ApQBAkAgAwRAIApFIARBgICAgHhGcUUEQCAEIANtIQQMBgsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASALIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiETcDQCARp0GTgICAeEcNASAFKAJEIQQMBQsgBUGHgICAeDYCQAsgBUFAaxCIEUEADAQLIAYQ5jogBSgCGEUNASAFKAIoQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAIkIghLBEAgBCAIayEJIAUoAhwiDSAESQRAIAYgDUEBdCIIIARBwP///wNxQUBrIAQgBEE/cRsiDSAIIA1LGxDoGSAFKAIkIQgLIAkEQCAFKAIgIAhqQQAgCfwLAAsgBSAENgIkCyAFIAw2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABEKkZCyAFKAIQIARqQQA6AAAgBSAEQQFqNgIUDAQLIAUgARD8OzYCsAEgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQbABajYCpAEgBSAFQZgBajYCnAEMCAtBoJWAARCyOwALIARBgAJJCyAEEPALCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDRFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaikgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC50SAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBD1HiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBAAwDCyAFIBEgD38iEDcDqAEgEEKAgAJ8QoCABFQNASAFQdgBakGDhowYNgIAIAVCg4aMmLDgwIEDNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAAgBSkBZjcBBiAAQQxqIAVB7ABqKQEANwEAIAAgBS8BZDsBBCAAQYKAgIB4NgIACyAFQSxqELgtDAgLAkAgBSgCOARAIAUoAkgiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCRCIGSwRAIAQgBmshByAFKAI8IgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCRCEGCyAHBEAgBSgCQCAGakEAIAf8CwALIAUgBDYCRAsgBSAKNgJIIAUoAkAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCTEEBajYCTAsgBSgCNCIEIAUoAixGBEAgBUEsakGEk4ABEK0oCyAFKAIwIARBAXRqIBA9AQALIAUgBEEBajYCNCADQQhqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCMCAFQYiYgAE2AiwgBUICNwI4IAVB+g82AmwgBUH9DzYCZCAFIAVB4ABqNgI0IAUgBUHQAWo2AmggBSAFQbgBaiIBNgJgIAVB/ABqIAVBLGoiAhCZDiAFKQJ8IQ8gBSAFKQKEATcChAEgBSAPNwJ8IAVBiICAgHg2AnggBUEDNgIwIAVBrKWAATYCLCAFQgI3AjggBUH0CzYCxAEgBUHEDTYCvAEgBUHonIABNgK4ASAFIAE2AjQgBSAFQStqNgLAASAFQeQAaiACEJkOIAVB+ABqEIgRIAUpAmQhDyAAIAUpAmw3AgwgACAPNwIEIABBgoCAgHg2AgAMBAsgBSABEP07NgK4ASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgJsIAVBOzYCZCAFIAVB4ABqNgKAASAFIAVBuAFqNgJoIAUgBUHQAWo2AmAMBQtBoJWAARCyOwALIAxFDQAgBUE4aiEJIAVB4ABqQQRyIQggBUG8AWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDRDYPCACTQ0CIAUgASgCECADaikDACIQNwOoASAFIA83A7ABAkACQAJAIA9QRQRAIA9Cf1IgEEKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUEAIQQMAQsgECAPfyIQQoCAAnxCgIAEVCEEIBCnIQYLIAVBLGogBCAGEN4LDAELIAkQ5jogBSgCOEUNAyAFKAJIQQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEHIAUoAjwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSAGNgJECyAFIAo2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEK0oCyAFKAIwIARBAXRqQQA7AQAgBSAEQQFqNgI0CyADQQhqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD9OzYC0AEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCxAEgBUE7NgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4AQwEC0GglYABELI7AAsgBUH4AGoiAiAFQSxqIgMQzhRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGYoIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuC0LIAVB4AFqJAAPC0EEQTgQoz0ACyAFQfgAakHkkoABEO8sAAulEgIKfwN+QgohECMAQeABayIFJAAgBSADOgArIAEgAhDoISEBIAUgA8AiAjYC0AEgBUIKNwO4AUIBIQ8CQAJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEQaiAPIA9CP4cgECAQQj+HEKgeIAUpAxggBSkDECIPQj+HUg0DIAJBAUYNAgsgBSAQIBBCP4ciESAQIBEQqB4gBSkDCCAFKQMAIhBCP4dSDQIgAkEBdiECDAALAAsgBUEsaiABQQxqIg0Q2DwQ+R4gBC0ANCANENg8IQwNAyAMRQ0EIAVBOGohCEEAIQNBACECA0ACQAJAAkACQCABIAIQhyVFBEAgBSACNgLQASANENg8IAJNDQcgBSABKAIQIANqKQMAIhE3A7ABIAUgDzcD0AEgD1AEf0GHgICAeAUgD0J/UiARQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4ASAFQeQAaiAFQfgAahCZDiAFKQJkIRAgBSkCbCEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCOEUNByAFKAJIQQFqIglBA3YgCUEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEKIAUoAjwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJEIQQLIAoEQCAFKAJAIARqQQAgCvwLAAsgBSAGNgJECyAFIAk2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEJ0oCyAFKAIwIARBAnRqQQA2AgAMAwsgBSARIA9/IhA3A6gBIBBCgICAgAh8QoCAgIAQVA0BIAVB2AFqQYSIkCA2AgAgBUKEiJCgwICBggQ3A9ABIAVBAjYCfCAFQeClgAE2AnggBUICNwKEASAFQa0DNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqIgE2AsABIAUgBUGoAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAEQqQwgACAFKQJoNwIIIABBEGogBUHwAGooAgA2AgAgACAFKAJkNgIEIABBgoCAgHg2AgALIAVBLGoQuS0MCAsCQCAFKAI4BEAgBSgCSCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJEIgZLBEAgBCAGayEHIAUoAjwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJEIQYLIAcEQCAFKAJAIAZqQQAgB/wLAAsgBSAENgJECyAFIAo2AkggBSgCQCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgQgBSgCLEYEQCAFQSxqQYSTgAEQnSgLIAUoAjAgBEECdGogED4CAAsgBSAEQQFqNgI0IANBCGohAyAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQkgBUHgAGpBBHIhCCAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIhA3A6gBIAUgDzcDsAECQAJAAkAgD1BFBEAgD0J/UiAQQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLcASAFQf0PNgLUASAFIAVB0AFqNgKAASAFIAVBsAFqNgLYASAFIAVBqAFqNgLQASALIAVB+ABqEJkOIAVBiICAgHg2ArgBIAggBSkCuAE3AgAgCEEIaiAFQcABaikCADcCACAIQRBqIAVByAFqKAIANgIADAELIAVBh4CAgHg2AmQLIAVBATYCYCAIEIgRQQAhBAwBCyAQIA9/IhBCgICAgAh8QoCAgIAQVCEEIBCnIQYLIAVBLGogBCAGEN8LDAELIAkQ5jogBSgCOEUNAyAFKAJIQQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEHIAUoAjwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSAGNgJECyAFIAo2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEJ0oCyAFKAIwIARBAnRqQQA2AgAgBSAEQQFqNgI0CyADQQhqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD9OzYC0AEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCxAEgBUE7NgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4AQwEC0GglYABELI7AAsgBUH4AGoiAiAFQSxqIgMQ0BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEH4ooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVB4AFqJAAPC0EEQTgQoz0ACyAFQfgAakHkkoABEO8sAAvUFQISfwd+IwBBQGoiECQAIBBBKGpCADcDACAQQSBqQgA3AwAgEEEYakIANwMAIBBCADcDEAJAAkACQAJAAkAgAgRAIABBBGshFyABrSEdQoCAgIBwISBBASEAA0ACQAJAAkAgHSAhUgRAIBdBBGoiFygCACILRQ0DIB9CBFQNAQwCCyABIAFB9LDQABDDIQALIBBBEGogH6dBA3RqICE3AwALIAIgC2shAiAfQgF8IR8LIABBAmohACAgQoCAgICAgEB9ISAgE0EBaiETICFCAXwhISACDQALIB9CAVYNASAQKQMQIR4LQQRCASAIIAkgChDlEiADIB4gCCAJIAoQ5RIgBSAepyIATQ0CIAAgBGpBADoAACAAIAdPDQEgBiAAQQF0akEAOwEADAQLIAUgE08EQCATBEAgBEEAIBP8CwALIBNBAWshHCAQQQhqIQsjAEEwayICJAACfyAARQRAIAJBADYCJCACQoCAgIDAADcCHCACQQhqIAJBHGpBjIfOABCfISACKAIIIQAgAigCDAwBCyACQgA3AyggAkEcaiIPIAJBKGogABCJHCACQRBqIA9BzILOABCfISACKAIQIQAgAigCFAshDyALIAA2AgAgCyAPNgIEIAJBMGokAEIAICF9ISIgECgCDCEMIBAoAgghD0EBIRYDQCAWrSEjIBchDiAcIQsgIiEdICAhHkEAIQ0DQAJAAkAgASAcSwRAIA4oAgAiAA0BDAILIAsgAUGksNAAEMMhAAsCQAJAAkAgACAWSQRAIAwgDU0NASAPIA1BA3RqIB4gI3w3AgAMAwsgDCANSw0BIA0gDEHEsNAAEMMhAAsgDSAMQbSw0AAQwyEACyAPIA1BA3RqIB4gAK18NwIACyANQQFqIQ0LIA5BBGshDiALQQFrIQsgHkKAgICAgIBAfCEeIB1CAXwiHVBFDQALAkAgDUEMTQRAIA1BAkkNAUEBIAwgDEEBTRshESAPIQJBASELA0ACQCALIBFHBEAgC0EBaiEOIA8gC0EDdGopAgAiHachEiACIQADQCAAKAIAIBJNDQIgAEEIaiAAKQIANwIAIABBCGshACALQQFrIgsNAAtBACELDAELIBEgDEH84dAAEMMhAAsgCyAMSQRAIA8gC0EDdGogHTcCACACQQhqIQIgDiILIA1HDQEMAwsLIAsgDEGM4tAAEMMhAAsgDUE5SUEBdCEUA0ACQCAUQQJ0QYiQ0gBqKAIAIg4gDU8NACAOIAwgDCAOSRshFUEAIRFBACAOQQN0IhhrIRkgDyECIA4hAAJAA0ACfwJAIAAgFUcEQCAAQQFqIRIgDyAAQQN0aikCACIdpyEaIAIhACARIQsDQCALIAxPDQUgACgCACAaTQ0CIAAgGGogACkCADcCACAAIBlqIQAgCyAOSSALIA5rIQtFDQALIAsgDmoMAgsgFSAMQczh0AAQwyEACyALIA5qCyIAIAxJBEAgDyAAQQN0aiAdNwIAIAJBCGohAiARQQFqIREgEiIAIA1HDQEMAwsLIAAgDEHs4dAAEMMhAAsgCyAMQdzh0AAQwyEACyAUQQFqIhRBBkcNAAsLIAwgDUEBaiIOTQRAIA4gDEGErtAAEMMhAAsgDyAOQQN0akJ/NwIAIAwgDU0EQCANIAxBlK7QABDDIQALIA8gDUEDdGoiC0J/NwIAAkAgDUEBayIUQQBMBEAgDUEBdCEVDAELIA1BAXQhFSANQQJqIRFBACENA0ACQAJAAkACQAJAIAwgDUsEQCAMIA5NDQEgDSAPIA1BA3RqKAIAIgAgDyAOQQN0aigCACISTWoiAiAMTw0CIA4gACASSyIAaiISIAxPDQMgDiANIAAbIgAgDE8NBCASIAIgDyACQQN0aigCACIOIA8gEkEDdGooAgAiGEsiGRsiDSAMSQ0FIA0gDEGEsNAAEMMhAAsgDSAMQbSv0AAQwyEACyAOIAxBxK/QABDDIQALIAIgDEHUr9AAEMMhAAsgEiAMQeSv0AAQwyEACyAAIAxB9K/QABDDIQALIA8gDUEDdGooAgAhGiAPIABBA3RqKAIAIRsgC0EOaiANOwEAIAtBDGogADsBACALQQhqIgAgGiAbajYCACAMIBFHBEAgAiAOIBhNaiENIBIgGWohDiALQRBqQn83AgAgEUEBaiERIAAhCyAUQQFrIhRFDQIMAQsLIAwgDEGUsNAAEMMhAAsgFkEBdCEWIBVBAWsgDyAMIAQgBUEOEIkRRQ0ACyAQQQA2AjwgEEKAgICAwAA3AjQgECAQQTRqQYyHzgAQnyEgECgCBCEAIBAoAgAhASAPIAxBA3RBBBD4OiAABEAgASAAQQN0QQQQ+DoLIAQgBSATIAYgBxCzCyAfQgVaBEAgIUIBfSEgQShC1KrVqvUfIAggCSAKEOUSIARBAWohA0EIIQtCACEfA0ACfgJAIB+nIgEgBUkEQCABIARqLQAAIQAgHyAgVA0BQgEhHSAfQgF8DAILIAEgBUGkrtAAEMMhAAsgASADaiECICEgH30iHUIBfSEiIAUgAWutQgF9ISNCACEeA0ACQAJAIB4gI1IEQCACLQAAIABGDQEgHkIBfCEdDAILIAUgBUG0rtAAEMMhAAsgAkEBaiECICIgHkIBfCIeUg0BCwsgHSAffAshHwJAAkACQAJAAkACQAJAAkACQCAARQRAIB2nIgBBwAVJDQEgAEHABUHErtAAEMMhAAsgACALQf8BcUcEQCAAQRJPDQMgAEG0l+IAai0AACAAQQJ0QcjN4gBqNQIAIAggCSAKEOUSIB1CAX0hHQsgHUICVg0DIB1QRQ0BDAcLIABBAnQiAEHIoeIAaiECIABByLfiAGohDgwFCyAAQRFLDQIgAEECdEHIzeIAaiEBA0AgAEG0l+IAai0AACABNQIAIAggCSAKEOUSIB1CAX0iHVBFDQALDAULIABBEkHUrtAAEMMhAAsgHadBA2siAUHABU8NASABQQJ0IgFBkM7iAGohAiABQZDk4gBqIQ4gACELDAILIABBEkH0rtAAEMMhAAsgAUHABUHkrtAAEMMhAAsgDigCACACNQIAIAggCSAKEOUSDAELIAAhCwsgHyAgWA0ACwwFC0ECQgEgCCAJIAoQ5RJBAiAfQgF9IAggCSAKEOUSIB+nIgZBAWshESAQQRhqIQtBACEBDAMLIBMgBUH0rdAAELA7AAsgACAHQeSw0AAQwyEACyAAIAVB1LDQABDDIQALA0ACQCABIgBBAWoiASAGTw0AIBBBEGogAEEDdGohByALIQIgESEAAkADQCACKQMAIh2nIg8gBUkEQCAFIAcpAwAiHqciDE0NAiAEIA9qLQAAIAQgDGotAABJBEAgAiAeNwMAIAcgHTcDAAsgAkEIaiECIABBAWsiAA0BDAMLCyAPIAVBlK/QABDDIQALIAwgBUGkr9AAEMMhAAsgC0EIaiELIBFBAWshESABIAZHDQALIAMgECkDECIdIAggCSAKEOUSIAMgECkDGCAIIAkgChDlEgJAIB9CAn0iHkIBWARAIB6nQQFrDQIMAQsgAyAQKQMgIAggCSAKEOUSIAMgECkDKCAIIAkgChDlEiAdpyIAIAVJBEBBASAAIARqLQAAQQFGrSAIIAkgChDlEgwCCyAAIAVBhK/QABDDIQALIAMgECkDICAIIAkgChDlEgsgEEFAayQAC5MSAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDzHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBAAwDCyAFIBEgD38iEDcDqAEgEEKAgARUDQEgBUHYAWpBh46cODYCACAFQoeOnLjw4MGDBzcD0AEgBUECNgJ8IAVB4KWAATYCeCAFQgI3AoQBIAVBrQM2AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWoiATYCwAEgBSAFQagBajYCuAEgBUHkAGogBUH4AGoQmQ4gARCpDCAAIAUpAWY3AQYgAEEMaiAFQewAaikBADcBACAAIAUvAWQ7AQQgAEGCgICAeDYCAAsgBUEsahC4LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCtKAsgBSgCMCAEQQF0aiAQPQEACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiEDcDqAEgBSAPNwOwAQJAAkACQCAPUEUEQCAPQn9SIBBCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCCAFKQK4ATcCACAIQQhqIAVBwAFqKQIANwIAIAhBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAgQiBFBACEEDAELIBAgD38iEEKAgARUIQQgEKchBgsgBUEsaiAEIAYQ3gsMAQsgCRDmOiAFKAI4RQ0DIAUoAkhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQcgBSgCPCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAkQhBAsgBwRAIAUoAkAgBGpBACAH/AsACyAFIAY2AkQLIAUgCjYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBACAFIARBAWo2AjQLIANBCGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP07NgLQASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgLEASAFQTs2ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBDAQLQaCVgAEQsjsACyAFQfgAaiICIAVBLGoiAxDPFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcCfgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUHgAWokAA8LQQRBOBCjPQALIAVB+ABqQeSSgAEQ7ywAC5gSAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDyHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQnSgLIAUoAjAgBEECdGpBADYCAAwDCyAFIBEgD38iEDcDqAEgEEKAgICAEFQNASAFQdgBakGIkKDAADYCACAFQoiQoMCAgYKECDcD0AEgBUECNgJ8IAVB4KWAATYCeCAFQgI3AoQBIAVBrQM2AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWoiATYCwAEgBSAFQagBajYCuAEgBUHkAGogBUH4AGoQmQ4gARCpDCAAIAUpAmg3AgggAEEQaiAFQfAAaigCADYCACAAIAUoAmQ2AgQgAEGCgICAeDYCAAsgBUEsahC5LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCdKAsgBSgCMCAEQQJ0aiAQPgIACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiEDcDqAEgBSAPNwOwAQJAAkACQCAPUEUEQCAPQn9SIBBCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCCAFKQK4ATcCACAIQQhqIAVBwAFqKQIANwIAIAhBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAgQiBFBACEEDAELIBAgD38iEEKAgICAEFQhBCAQpyEGCyAFQSxqIAQgBhDfCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCdKAsgBSgCMCAEQQJ0akEANgIAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENQUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByKGAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALkBICCn8DfkIKIRAjAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEPAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogDyAPQj+HIBAgEEI/hxCoHiAFKQMYIAUpAxAiD0I/h1INAyACQQFGDQILIAUgECAQQj+HIhEgECAREKgeIAUpAwggBSkDACIQQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPAeIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDYPCACTQ0HIAUgASgCECADaikDACIRNwOwASAFIA83A9ABIA9QBH9Bh4CAgHgFIA9Cf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEgBUHkAGogBUH4AGoQmQ4gBSkCZCEQIAUpAmwhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAjhFDQcgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshCiAFKAI8IgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCRCEECyAKBEAgBSgCQCAEakEAIAr8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCjKAsgBSgCMCAEakEAOgAADAMLIAUgESAPfyIQNwOoASAQQoABfEKAAlQNASAFQdgBakGChIgQNgIAIAVCgoSIkKDAgIECNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAAgBSkAZTcABSAAQQxqIAVB7ABqKQAANwAAIAAgBS0AZDoABCAAQYKAgIB4NgIACyAFQSxqELctDAgLAkAgBSgCOARAIAUoAkgiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCRCIGSwRAIAQgBmshByAFKAI8IgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCRCEGCyAHBEAgBSgCQCAGakEAIAf8CwALIAUgBDYCRAsgBSAKNgJIIAUoAkAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCTEEBajYCTAsgBSgCNCIEIAUoAixGBEAgBUEsakGEk4ABEKMoCyAFKAIwIARqIBA8AAALIAUgBEEBajYCNCADQQhqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCMCAFQYiYgAE2AiwgBUICNwI4IAVB+g82AmwgBUH9DzYCZCAFIAVB4ABqNgI0IAUgBUHQAWo2AmggBSAFQbgBaiIBNgJgIAVB/ABqIAVBLGoiAhCZDiAFKQJ8IQ8gBSAFKQKEATcChAEgBSAPNwJ8IAVBiICAgHg2AnggBUEDNgIwIAVBrKWAATYCLCAFQgI3AjggBUH0CzYCxAEgBUHEDTYCvAEgBUHonIABNgK4ASAFIAE2AjQgBSAFQStqNgLAASAFQeQAaiACEJkOIAVB+ABqEIgRIAUpAmQhDyAAIAUpAmw3AgwgACAPNwIEIABBgoCAgHg2AgAMBAsgBSABEP07NgK4ASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgJsIAVBOzYCZCAFIAVB4ABqNgKAASAFIAVBuAFqNgJoIAUgBUHQAWo2AmAMBQtBoJWAARCyOwALIAxFDQAgBUE4aiEJIAVB4ABqQQRyIQggBUG8AWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDRDYPCACTQ0CIAUgASgCECADaikDACIQNwOoASAFIA83A7ABAkACQAJAIA9QRQRAIA9Cf1IgEEKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUEAIQQMAQsgECAPfyIQQoABfEKAAlQhBCAQpyEGCyAFQSxqIAQgBhDxCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCjKAsgBSgCMCAEakEAOgAAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENYUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0KOAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELctCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALiBICCn8DfkIKIRAjAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEPAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogDyAPQj+HIBAgEEI/hxCoHiAFKQMYIAUpAxAiD0I/h1INAyACQQFGDQILIAUgECAQQj+HIhEgECAREKgeIAUpAwggBSkDACIQQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPceIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDYPCACTQ0HIAUgASgCECADaikDACIRNwOwASAFIA83A9ABIA9QBH9Bh4CAgHgFIA9Cf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEgBUHkAGogBUH4AGoQmQ4gBSkCZCEQIAUpAmwhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAjhFDQcgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshCiAFKAI8IgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCRCEECyAKBEAgBSgCQCAEakEAIAr8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCpGQsgBSgCMCAEakEAOgAADAMLIAUgESAPfyIQNwOoASAQQoACVA0BIAVB2AFqQYaMmDA2AgAgBUKGjJiw4MCBgwY3A9ABIAVBAjYCfCAFQeClgAE2AnggBUICNwKEASAFQa0DNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqIgE2AsABIAUgBUGoAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAEQqQwgACAFKQBlNwAFIABBDGogBUHsAGopAAA3AAAgACAFLQBkOgAEIABBgoCAgHg2AgALIAVBLGoQty0MCAsCQCAFKAI4BEAgBSgCSCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJEIgZLBEAgBCAGayEHIAUoAjwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJEIQYLIAcEQCAFKAJAIAZqQQAgB/wLAAsgBSAENgJECyAFIAo2AkggBSgCQCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgQgBSgCLEYEQCAFQSxqQYSTgAEQqRkLIAUoAjAgBGogEDwAAAsgBSAEQQFqNgI0IANBCGohAyAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQkgBUHgAGpBBHIhCCAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIhA3A6gBIAUgDzcDsAECQAJAAkAgD1BFBEAgD0J/UiAQQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLcASAFQf0PNgLUASAFIAVB0AFqNgKAASAFIAVBsAFqNgLYASAFIAVBqAFqNgLQASALIAVB+ABqEJkOIAVBiICAgHg2ArgBIAggBSkCuAE3AgAgCEEIaiAFQcABaikCADcCACAIQRBqIAVByAFqKAIANgIADAELIAVBh4CAgHg2AmQLIAVBATYCYCAIEIgRQQAhBAwBCyAQIA9/IhBCgAJUIQQgEKchBgsgBUEsaiAEIAYQ8AsMAQsgCRDmOiAFKAI4RQ0DIAUoAkhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQcgBSgCPCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAkQhBAsgBwRAIAUoAkAgBGpBACAH/AsACyAFIAY2AkQLIAUgCjYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQqRkLIAUoAjAgBGpBADoAACAFIARBAWo2AjQLIANBCGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP07NgLQASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgLEASAFQTs2ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBDAQLQaCVgAEQsjsACyAFQfgAaiICIAVBLGoiAxDRFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaikgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHgAWokAA8LQQRBOBCjPQALIAVB+ABqQeSSgAEQ7ywAC/QRAgp/A35CCiEPIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhEAJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIBAgEEI/hyAPIA9CP4cQqB4gBSkDGCAFKQMQIhBCP4dSDQMgAkEBRg0CCyAFIA8gD0I/hyIRIA8gERCoHiAFKQMIIAUpAwAiD0I/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDvHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACfwJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAQNwPQAUGHgICAeCAQUA0CGiAQQn9SIBFCgICAgICAgICAf1JyDQEgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhDyAFKQJsIRBBiICAgHgMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQsygLIAUoAjAgBEEDdGpCADcDAAwDCyAFIBEgEH8iDzcDqAEgD0IAWQ0BIAVB2AFqQYmSpMgANgIAIAVCiZKkyJChwoQJNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAUpAmQhDyAFKQJsIRBBgoCAgHgLIQEgACAQNwIMIAAgDzcCBCAAIAE2AgAgBUEsahC6LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCzKAsgBSgCMCAEQQN0aiAPNwMACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiETcDqAEgBSAQNwOwASAFQSxqAn4CQAJAIBBQRQRAIBBCf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUIADAELIBEgEH8iESAPIBFCAFkiBBshDyAErQsgDxDaCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCzKAsgBSgCMCAEQQN0akIANwMAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENkUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBoKKAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALvx8CE38BfiMAQZABayIHJABBuH8hBgJAIARBgIAISw0AAn8CQCAEQQJJDQACQAJAAkACQAJAAkAgAy0AACIKQQNxIg1BAWsOAwMBAAILIAAoAojqAQ0AQWIMBgsgBEEFSQ0EQQMhCyADKAAAIQYgACgCsOsBGkG6fyEJIAFBAQJ/AkACQAJAIApBAnZBA3EiCEECaw4CAQIACyAIQQBHIQwgBkEOdkH/B3EhCCAGQQR2Qf8HcQwCCyAGQRJ2IQhBASEMQQQhCyAGQQR2Qf//AHEMAQsgAy0ABEEKdCAGQRZ2ciEIQQUhC0EBIQwgBkEEdkH//w9xCyIKG0UNAiAKQYCACEsNBEFoIApBBkkgDHENBRogCCALaiIPIARLDQRBgIAIIAIgAkGAgAhPGyIGIApJDQIgACABIAIgCiAFIAZBABCYGgJAIAAoAqDrAUUgCkGBBklyDQBBACEGA0AgBkGDgAFLDQEgBkFAayEGDAALAAsCfyANQQNGBEAgAyALaiEFIAAoAgwhBiAAKAL06wEhCSAMRQRAIAkgCiAFIAggBhC/HwwCCyAJIAogBSAIIAYQqAQMAQsgAEGs1QFqIQ4gAyALaiEFIABBqNAAaiEGIAAoAvTrASEJIAxFBEACfyAGIAUgCCAOQYAUEIUEIgtBiH9LBEAgCwwBCyAIIAtLBH8gCSAKIAUgC2ogCCALayAGEL8fBUG4fwsLDAELAn9Bun8gCkUNABpBbCAIRQ0AGiAGIAUgCCAOQYAUEIUEIgtBiH9NBH9BuH8gCCALTQ0BGiAJIAogBSALaiAIIAtrIAYQqAQFIAsLCwsgACgC/OsBQQJGBEAgAEGA7AFqIAAoAvjrAUGAgARrQYCABPwKAAAgCkGAgARrIgYEQCAAKAL06wEiCUHg/wNqIAkgBvwKAAALIAAgACgC9OsBQeD/A2o2AvTrASAAIAAoAvjrAUEgazYC+OsBC0FsIQlBiH9LDQIgACAKNgKI6wEgAEEBNgKI6gEgACAAKAL06wE2AvjqASANQQJHDQMgACAAQajQAGo2AgwMAwtBAiEIAn8CQAJAAkAgCkECdkEDcUEBaw4DAQACAAtBASEIIApBA3YMAgsgAy8AAEEEdgwBCyAEQQJGDQRBAyEIIAMvAAAgAy0AAkEQdHJBBHYLIQZBun8hCSABRSAGQQBHcQ0BQYCACCACIAJBgIAITxsiCiAGSQ0BIAAgASACIAYgBSAKQQEQmBogBCAGIAhqIgVBIGpJBEBBbCEJIAQgBUkNAiADIAhqIQkgACgC9OsBIQgCQCAAKAL86wFBAkYEQCAGQYCABGsiCgRAIAggCSAK/AoAAAsgAEGA7AFqIAkgCmpBgIAE/AoAAAwBCyAGRQ0AIAggCSAG/AoAAAsgACAGNgKI6wEgACAAKAL06wE2AvjqASAFDAULIABBADYC/OsBIAAgBjYCiOsBIAAgAyAIaiIJNgL46gEgACAGIAlqNgL46wEgBQwECwJ/AkACQAJAIApBAnZBA3FBAWsOAwEAAgALIApBA3YhBkEBDAILIARBAkYNBCADLwAAQQR2IQZBAgwBCyAEQQRJDQMgAy8AACADLQACQRB0ckEEdiEGQQMLIQhBun8hCSABQQEgBhtFDQBBbCEJIAZBgIAISw0AQbp/IQkgAiAGSQ0AIAAgASACIAYgBUGAgAggAiACQYCACE8bQQEQmBogAyAIaiIKLQAAIQUgACgC9OsBIQkCQCAAKAL86wFBAkYEQCAGQYCABGsiCwRAIAkgBSAL/AsACyAAQYDsAWogCi0AAEGAgAT8CwAMAQsgBkUNACAJIAUgBvwLAAsgACAGNgKI6wEgACAAKAL06wE2AvjqASAIQQFqIQkLIAkMAgsgDwwBC0FsCyIGQYh/Sw0AIAIgACgC0OkBIgUgAiAFSRshCyAAKAK06QEhDAJ/IAdBPGohCCADIAZqIg8hA0G4fyEJAkAgBCAGayIRIgVFDQAgAy0AACIERQRAIAhBADYCAEEBQbh/IAVBAUYbDAILAn8gA0EBaiAEwCIGQQBODQAaIAZBf0YEQCAFQQNJDQIgAy8AAUGA/gFqIQQgA0EDagwBCyAFQQFGDQEgAy0AASAEQQh0ckGAgAJrIQQgA0ECagshCiAIIAQ2AgAgCkEBaiIGIAMgBWoiBUsNAEFsIQkgAEEQaiAAIAotAAAiCEEGdkEjQQkgBiAFIAZrQYC20QBBkLfRAEHAt9EAIAAoAozqASAAKAKg6wEgBCAAQazVAWoiChCGEiINQYh/Sw0AIABBmCBqIABBCGogCEEEdkEDcUEfQQggBiANaiIGIAUgBmtB0LvRAEHQvNEAQfC80QAgACgCjOoBIAAoAqDrASAEIAoQhhIiDUGIf0sNACAAQaAwaiAAQQRqIAhBAnZBA3FBNEEJIAYgDWoiBiAFIAZrQYC/0QBB4MDRAEGgwdEAIAAoAozqASAAKAKg6wEgBCAKEIYSIgRBiH9LDQAgBCAGaiADayEJCyAJCyIJQYh/SwRAIAkhBgwBC0EAIQMgBygCPCENIAFBAEcgAkEAR3FFBEBBun8hBiANQQBKDQELAkAgASALaiAMayIEQf3//x9JDQAgDQRAIARB/P//H0shAyAAKAIIIgRBCmohDiAEKAIEIQZBACEEQQAhBQNAIAUgBnZFBEAgBCAOLQAAIgggBCAISxshBCAOQQhqIQ4gBUEBaiEFDAELCyAEQRlLDQELQQAhAwsgESAJayEKIAkgD2ohCSAAQQA2AqDrAQJAAn8CQAJAAkAgACgC/OsBDgMBAgACCyAHIAAoAvjqASIINgJAIAEgAmohDyAAKAL46wEhDgJ/IA0EfyAAKAK46QEhESAAKAK06QEhEyAAKAKw6QEhBSAAQQE2AozqAUGs0AEhBANAIARBuNABRwRAIAQgB2pBrM8BayAAIARqKAIANgIAIARBBGohBAwBCwtBbCEGIAdB1ABqIgIgCSAKEN0TQYh/Sw0GIABBrNABaiEXIAdB6ABqIAIgACgCABDbLiAHQfAAaiACIAAoAggQ2y4gB0H4AGogAiAAKAIEENsuIAdByABqIAIgAxCICiABIQQCQANAIAggBygCSCIKaiISIAAoAvjrASICTQRAIAcoAkwhDCAHIAQgCmoiAiAHKAJQIhBrIgs2AkQgEkEgayEVAkACQAJAIA4gEkkNACAEIAogDGoiCWogFUsNACAJQSBqIA8gBGtNDQELIAdBOGogB0HQAGooAgA2AgAgByAHKQJINwMwAn8gB0FAayEWIAUhAkG6fyEJAkAgB0EwaiIIKAIEIgsgCCgCACIQaiIKIA8gBGtLDQBBbCAOIBYoAgAiEmsgEEkNARogCCgCCCEUIBAgEmoiGCAESyAEIBJLcQ0AIAQgEGoiDCAUayEIIAQgEiAQEP4YIBYgGDYCAAJAAkAgDCACayAUTwRAIAghAgwBC0FsIQkgFCAMIBNrSw0CIBEgESAIIAJrIglqIgggC2pPBEAgC0UNAiAMIAggC/wKAAAMAgtBACAJayIQBEAgDCAIIBD8CgAACyAJIAtqIQsgDCAJayEMCyAMIBUgAiALQQEQsRQLIAohCQsgCQshCQwBCyAIKQAAIRkgBEEIaiAIQQhqKQAANwAAIAQgGTcAACAKQRFPBEAgBEEQaiAIQRBqIApBEGtBABDRFQsgByASNgJAIAcgAjYCjAEgAiAFayAQSQRAIAIgE2sgEEkNCyARIBEgCyAFayIIaiIKIAxqTwRAIAxFDQIgAiAKIAz8CgAADAILQQAgCGsiCwRAIAIgCiAL/AoAAAsgByAFNgJEIAcgAiAIayICNgKMASAIIAxqIQwgBSELCyAQQRBPBEAgAiALIAxBABDRFQwBCyAHQYwBaiAHQcQAaiAQEMUZIAxBCUkNACAHKAKMASAHKAJEIAxBCGtBARDRFQsgCUGIf0sEQCAJIQYMCgsgBCAJaiEEIA1BAUYNAiAHQdQAaiICEP0YGiAHQcgAaiACIAMQiAogDUEBayENIAcoAkAhCAwBCwsgDUEATA0HIAIgCEcEQEG6fyEGIAIgCGsiAiAPIARrSw0IIAQgCCACEP4YIAcgCiACazYCSCACIARqIQQLIABBADYC/OsBIAdBKGogB0HQAGooAgA2AgAgByAAQYDsAWo2AkAgByAHKQJINwMgIAQgDyAHQSBqIAdBQGsgAEGA7AVqIg4gBSATIBEQhg0iBkGIf0sNByAEIAZqIQQgDUEBRg0AIAdB1ABqEP0YGkECIQIDQCAHQcgAaiAHQdQAaiIJIAMQiAogB0EYaiAHQdAAaigCADYCACAHIAcpAkg3AxAgBCAPIAdBEGogB0FAayAOIAUgEyAREIYNIgZBiX9PDQggBCAGaiEEIAIgDUYNASACQQFqIQIgCRD9GBoMAAsAC0FsIQYgB0HUAGoQ/RhBAkkNBkEAIQIDQCACQQxHBEAgAiAXaiACIAdqQYABaigCADYCACACQQRqIQIMAQsLIAcoAkAiCCAAKAL86wFBAkcNARogBAUgAQshAiAOIAhrIgMgDyACa0sNBEEAIQQgAgRAIAMEQCACIAggA/wKAAALIAIgA2ohBAsgAEEANgL86wEgAEGA7AVqIQ4gAEGA7AFqCyECIA4gAmsiACAPIARrSw0DIAQEfyAABEAgBCACIAD8CgAACyAAIARqBUEACyABayEGDAQLIAEgAmoMAQsgACgC9OsBCyEFIAcgACgC+OoBIgI2AowBIAIgACgCiOsBaiEIIAEhBCANBEAgACgCuOkBIQsgACgCtOkBIQwgACgCsOkBIQ4gAEEBNgKM6gFBrNABIQQDQCAEQbjQAUcEQCAEIAdqQazPAWsgACAEaigCADYCACAEQQRqIQQMAQsLQWwhBiAHQdQAaiICIAkgChDdE0GIf0sNAiAAQazQAWohCSAHQegAaiACIAAoAgAQ2y4gB0HwAGogAiAAKAIIENsuIAdB+ABqIAIgACgCBBDbLiANQQFrIQIgASEEA0AgB0HIAGogB0HUAGogAxCICiAHQQhqIAdB0ABqKAIANgIAIAcgBykCSDcDACAEIAUgByAHQYwBaiAIIA4gDCALEIYNIgBBiX9PBEAgACEGDAQLIAAgBGohBCACBEAgAkEBayECIAdB1ABqEP0YGgwBCwsgB0HUAGoQ/RhBAkkNAkEAIQIDQCACQQxHBEAgAiAJaiACIAdqQYABaigCADYCACACQQRqIQIMAQsLIAcoAowBIQILQbp/IQYgCCACayIAIAUgBGtLDQEgBAR/IAAEQCAEIAIgAPwKAAALIAAgBGoFQQALIAFrIQYMAQtBun8hBgsgB0GQAWokACAGC/kYBA5/CH4BfQF8IwBB4AFrIgMkAAJAAkAgAikDAEICUQRAQgghEwwBCyADQSBqIAJB2AD8CgAAIAMgAykDKEIAIAMoAiAbIhQ3A3gCQAJAAkACQAJAAkACQAJAAn8CQCAUQgBZBEAgAygCZEGAgICAeEcNASADKAJYQYCAgIB4Rw0BQSAhCUEsIQpBAQwCCyADQQE2AqwBIANB1IrOADYCqAEgA0IBNwK0ASADQe4GNgLEASADIANBwAFqNgKwASADIANB+ABqNgLAASAAQQxqIANBqAFqEJkOIABCCTcDACAAQQA2AgggA0FAaxCGMCADQcwAahCGMAwCC0EBIQ1BOCEJQcQAIQpBAAshDCADKQM4IRYgAykDMCEVIANBiAFqIAIgCmoiBUEIaigCADYCACADIAUpAgA3A4ABIANBmAFqIAIgCWoiBkEIaigCADYCACADIAYpAgA3A5ABQQQhAgJAAkACQAJAAkACQCABQf8BcSIKDgYEAgEAAgEDCyADQagBaiAFIAZBDBDvEiADKAKoASICQQhHDQQMBwtBCCECCyADQagBaiAFIAYgAhDvEiADKAKoASICQQhHDQILIBZCIIinIQkgFqchASAVpyECAkACQAJAAkACQAJAIApBAmsOBgAKAQIDBAULIwBBEGsiBCQAAkACQCADQagBaiILIAUoAgBBgICAgHhHBH4gBEEIaiAFQQhqKAIAIgc2AgAgBCAFKQIANwMAIAdBB00NASAEKAIEKQAAIREgBBDeOyALIBE3AwhCAQVCAAs3AwAgBEEQaiQADAELQQggB0Hwi84AELA7AAsgAykDsAEhFiADKQOoASEVIwBBEGsiBCQAAkACQCALIAYoAgBBgICAgHhHBH4gBEEIaiAGQQhqKAIAIgc2AgAgBCAGKQIANwMAIAdBB00NASAEKAIEKQAAIREgBBDeOyALIBE3AwhCAQVCAAs3AwAgBEEQaiQADAELQQggB0GAjM4AELA7AAsgAykDsAEhESAVpyEGIAMpA6gBIhKnIQVCAiETDAgLIANBGGohAiMAQRBrIgQkAAJAAkAgBSgCAEGAgICAeEYEf0EABSAEQQhqIAVBCGooAgAiATYCACAEIAUpAgA3AwAgAUEDTQ0BIAQoAgQqAAAhGSAEEN47QQELIQEgAiAZOAIEIAIgATYCACAEQRBqJAAMAQtBBCABQZCMzgAQsDsACyADKAIcIQogAygCGCECIANBEGohBEMAAAAAIRkjAEEQayIIJAACQAJAIAYoAgBBgICAgHhGBH9BAAUgCEEIaiAGQQhqKAIAIgE2AgAgCCAGKQIANwMAIAFBA00NASAIKAIEKgAAIRkgCBDeO0EBCyEBIAQgGTgCBCAEIAE2AgAgCEEQaiQADAELQQQgAUGgjM4AELA7AAsgAygCECIBQf8Bca0gAkEIdEGA/gNxrUKAgIQIQgAgDBuEhCEXQgQhE0IBIRIgAygCFCEJIBQhEQwLCyMAQRBrIgQkAAJAAkAgA0GoAWoiCyAFKAIAQYCAgIB4RwR+IARBCGogBUEIaigCACIHNgIAIAQgBSkCADcDACAHQQdNDQEgBCgCBCsAACEaIAQQ3jsgCyAaOQMIQgEFQgALNwMAIARBEGokAAwBC0EIIAdBsIzOABCwOwALIAMpA7ABIRYgAykDqAEhFSMAQRBrIgQkAAJAAkAgCyAGKAIAQYCAgIB4RwR+IARBCGogBkEIaigCACIHNgIAIAQgBikCADcDACAHQQdNDQEgBCgCBCsAACEaIAQQ3jsgCyAaOQMIQgEFQgALNwMAIARBEGokAAwBC0EIIAdBwIzOABCwOwALIAMpA7ABIREgFachBiADKQOoASISpyEFQgUhEwwGC0EAIQIgAygCgAEiAUGAgICAeEcEQCADIAMpAoQBNwKsASADIAE2AqgBIANBxAFqIANBqAFqEOcVQQEhAgsgAygCkAEiAUGAgICAeEcEQCADIAMpApQBNwLYASADIAE2AtQBIANBrAFqIANB1AFqEOcVQQEhCCADKAK4ASEOIAMtALUBIQYgAykCrAEhGCADLQC3ASELIAMtALQBIQUgAy0AtgEhBwsgAy0AcUEBcSEPIAMtAHBBAXEhECADKALQASIErSISQoCAgPgPgyERIAMoAswBIQkgAygCyAEhASADKALEASEKQgYhEwwHCyADKAKAASICQYCAgIB4RgR/QQAFIAMgAykChAE3AsQBIAMgAjYCwAEgA0GsAWogA0HAAWoQ5xUgAzUCuAEhEiADKAK0ASEJIAMoArABIQEgAygCrAEhCkEBCyECIAMoApABIgVBgICAgHhHBEAgAyADKQKUATcCxAEgAyAFNgLAASADQawBaiADQcABahDnFUEBIQggAygCuAEhDiADLQC1ASEGIAMpAqwBIRggAy0AtwEhCyADLQC0ASEFIAMtALYBIQcLIBJCgICA+A+DIREgAy0AcUEBcSEPIAMtAHBBAXEhECASpyEEQgchEwwGCyADQQhqIQIjAEEQayIIJAACQAJAIAUoAgBBgICAgHhGBH9BAAUgCEEIaiAFQQhqKAIAIgE2AgAgCCAFKQIANwMAIAFBA00NASAIKAIEKAAAIQQgCBDeO0EBCyEBIAIgBDYCBCACIAE2AgAgCEEQaiQADAELQQQgAUHQi84AELA7AAsgAygCDCEKIAMoAgghAkEAIQQjAEEQayIIJAACQAJAIAYoAgBBgICAgHhGBH9BAAUgCEEIaiAGQQhqKAIAIgE2AgAgCCAGKQIANwMAIAFBA00NASAIKAIEKAAAIQQgCBDeO0EBCyEBIAMgBDYCBCADIAE2AgAgCEEQaiQADAELQQQgAUHgi84AELA7AAsgAygCACIBQf8Bca0gAkEIdEGA/gNxrUKAgIQIQgAgDBuEhCEXQgEhEiADKAIEIQkgFCERQgEhEwwHCyADQagBaiAFIAZBARDvEiADKAKoASICQQhGDQULIAAgAykCrAE3AgwgAEEcaiADQbwBaigCADYCACAAQRRqIANBtAFqKQIANwIAIABCCTcDACAAIAI2AgggAygCkAFBgICAgHhHBEAgA0GQAWoQ3jsLIAMoAoABQYCAgIB4RwRAIANBgAFqEN47CyANBEAgA0FAaxCGMCADQcwAahCGMAsgDEUNCQsgA0HYAGoQhjAgA0HkAGoQhjAMCAtCASEXQQAhCiAUIRggDCIHIQsMAwtBACECAkACQCADKAKAAUGAgICAeEcEQCADQcgBaiAFQQhqKAIAIgE2AgAgAyAFKQIANwPAASADIAE2AqABIAFBDEcNASADKALEASICKAAIIQkgAigABCEBIAIoAAAhCiADQcABahDeO0EBIQILIAMoApABQYCAgIB4RgR/QQAFIANByAFqIAZBCGooAgAiBzYCACADIAYpAgA3A8ABIAMgBzYCpAEgB0EMRw0CIAMoAsQBIgcpAAQhGCAHKAAAIQggA0HAAWoQ3jtBAQshBEIDIRMgDCELIAwhByACIQYgBCEFDAILIANBADYCqAFBACADQaABakGMis4AIANBqAFqQZCKzgAQrysACyADQQA2AqgBQQAgA0GkAWpBjIrOACADQagBakGgis4AEK8rAAsgBK1C/wGDIBJCgP7/B4MgCK1CIIYgEYSEhCEXQgEhEiAUIREMAQtBAiEBQQIhCSADKAKAASICQYCAgIB4RwRAIAMgAykChAEiETcCrAEgAyACNgKoASARQv////8PWA0CIBGnLQAAQQBHIQkgA0GoAWoQ3jsLIAMoApABIgJBgICAgHhHBEAgAyADKQKUASIRNwKsASADIAI2AqgBIBFC/////w9YDQMgEactAABBAEchASADQagBahDeOwsgCUECR0EIdEGAgIQIQQAgDBtyIAFBAkdyIQIgAUEIdCAJciEKQgEhEiAUIRELIA0EQCADQUBrEIYwIANBzABqEIYwCyAMRQ0CIANB2ABqEIYwIANB5ABqEIYwDAILQQBBAEGwi84AEMMhAAtBAEEAQcCLzgAQwyEACyAAIAw6AFMgACAMOgBSIAAgDzoAUSAAIBA6AFAgACAONgJMIAAgCzoASyAAIAc6AEogACAGOgBJIAAgBToASCAAIBg3A0AgACAXNwM4IAAgCTYCNCAAIAE2AjAgACAKNgIsIAAgAjYCKCAAIBE3AyAgACASNwMYIAAgFjcDECAAIBU3AwggACATNwMACyADQeABaiQAC8IQAgp/AX4jAEGgAWsiAyQAIAIoAgwiDARAIAAgAhD9CiELCyAAIAIoAjggAigCPBC0CyEIIANB+ABqIAJBKGogASAAEJ8BAkACQCACLQAoQSJGBEAgASgCACIBBEAgAigCLCABQSBqIQQgASgCJCEGAkAgASgCKCIFRQ0AIAYgBUEDdGpBCGsiCUUNACAJKQMAQgF8IQ0LIAQoAgAgBUYEfyAEQczP/gAQsyggASgCJAUgBgsgBUEDdGogDTcDACABIAVBAWo2AiggAEEBOgA4IAAoAjAhBSACLQBBIQktAAAiAUECa0H/AXEiBEEHTQRAIABBBkEPIAR2QQFxEK4RIABBBCABwEECdEH8xf4AaigCAEEAEMoOCyAAQTBqIQEgACAFENgHIQcgAEEBOgA4IABBADYCFCAAKAIwIQUCfyANUARAIAUgAC0AOkEBRw0BGgsgAEEIIAAoAjQiBCAEQQhNGzYCNAJAQQAgBWtBB3EiBCAAKAIIIAVrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgASAEEI03IAAoAgggACgCMGtBB0siBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwa0EISQ0ACwsgAUEIEI03IANB8ABqIAAQ3DsgAygCdCEEIAMoAnAhBiADQegAaiAAKAIwEIw3IANB4ABqIAYgBCADKAJoIAMoAmxBsLf+ABDXJiADKAJkQQdNDQQgAygCYCANNwAAIAAoAjAhBiAAKAIUIgQgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgBEEDdGoiCkEEOwEEIAogBjYCACAAIARBAWo2AhQgACgCMAshBiAAQQQgACgCNCIEIARBBE0bNgI0AkBBACAGa0EDcSIEIAAoAgggBmtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyABIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyABQQQQjTcgA0HYAGogABDcOyADKAJcIQQgAygCWCEGIANB0ABqIAAoAjAQjDcgA0HIAGogBiAEIAMoAlAgAygCVEGwt/4AENcmIAMoAkwiBEEDTQ0DIAMoAkggBCAHazYAACAAQQxqIQQgACgCMCEHIAAoAhQiBiAAKAIMRgRAIARBuLb+ABCbKAsgACgCECAGQQN0aiIKQQY7AQQgCiAHNgIAIAAgBkEBajYCFCAAQQggCUEBcRCuESAAIAUQ2AchByAAQQE6ADggAEEANgIUIAAoAjAhBiAAQQQgCBD8DiAAQQQgACgCNCIFIAVBBE0bNgI0AkBBACAAKAIwIghrQQNxIgUgACgCCCAIa00NACAAKAIIIAAoAjBrIAVPDQADQCAAEPsWIAAoAgggACgCMGsgBUkNAAsLIAEgBRCNNyAAKAIIIAAoAjBrQQNLIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAFBBBCNNyADQUBrIAAQ3DsgAygCRCEBIAMoAkAhBSADQThqIAAoAjAQjDcgA0EwaiAFIAEgAygCOCADKAI8QbC3/gAQ1yYgAygCNCIBQQNNDQMgAygCMCABIAdrNgAAIAAoAjAhBSAAKAIUIgEgACgCDEYEQCAEQbi2/gAQmygLIAAoAhAgAUEDdGoiBEEMOwEEIAQgBTYCACAAIAFBAWo2AhQMAgsgA0EANgKYASADQQE2AowBIANB/MT+ADYCiAEgA0IENwKQASADQYgBakGExf4AEO8sAAsgAEEBOgA4IAAoAjAhBiAAQQQgCBD8DgsCQCADLQCEASIBRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiBSAFQQFNGzYCNCAAKAIIGiAAQTBqIgVBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIAVBARCNNyADQShqIAAQ3DsgAygCLCEFIAMoAighBCADQSBqIAAoAjAQjDcgA0EYaiAEIAUgAygCICADKAIkQbC3/gAQ1yYgAygCHEUNASADKAIYIAE6AAAgACgCMCEFIAAoAhQiASAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECABQQN0aiIEQQg7AQQgBCAFNgIAIAAgAUEBajYCFAsgAEEGIAItAEAQrhEgAygCeEEBRgRAIABBDiADKAJ8EPwOCyAAQQQgACgCNCIBIAFBBE0bNgI0IAMoAoABIQUgAEEwaiECAkBBACAAKAIwIgRrQQNxIgEgACgCCCAEa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAIgARCNNyAAKAIIIAAoAjBrQQNLIgEgAXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAJBBBCNNyADQRBqIAAQ3DsgAygCFCEBIAMoAhAhAiADQQhqIAAoAjAQjDcgAyACIAEgAygCCCADKAIMQbC3/gAQ1yYgAygCBCIBQQNNDQAgAygCACABIAVrNgAAIAAoAjAhAiAAKAIUIgEgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgAUEDdGoiBUEKOwEEIAUgAjYCACAAIAFBAWo2AhQgDARAIABBECALEPwOCyAAIAYQ2AcgAEEANgIUIABBADoAOCADQaABaiQADwsgA0EANgKYASADQQE2AowBIANB7Lf+ADYCiAEgA0IENwKQASADQYgBakHAt/4AEO8sAAvWDwEHfiAAKQMIIgMgAUEAR62FIgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAFQtii0e/CqeW/LX6FIQMgACkDACEFAkAgAUUNACAAKQMYIQcgACkDECEGIAMgAq0iCIUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUgCHxCrf7V5NSF/ajYAH4hCCACQQhNBEACfiACQQFNBEBCACEEQgAgAkEBRw0BGiABMQAAIgQMAQsgASACaiEAIAJBA00EQCABMwAAIQQgAEEBazEAAAwBCyABNQAAIQQgAEEEazUAAAshAyAFIAh8IAQgBoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhCADIAeFIgZCf4V+IgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhISFIAZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgB0IIiEKAgID4D4MgB0IYiEKAgPwHg4QgB0IoiEKA/gODIAdCOIiEhIQgBH6FQheJIQMMAQsgAkEQTQRAIAUgCHwgASkAACAGhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAEgAmpBCGspAAAgB4UiB0J/hX4iBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhIUgB0I4hiAHQoD+A4NCKIaEIAdCgID8B4NCGIYgB0KAgID4D4NCCIaEhCAHQgiIQoCAgPgPgyAHQhiIQoCA/AeDhCAHQiiIQoD+A4MgB0I4iISEhCADfoVCF4khAwwBCyAFIAh8IAYgASACakEQayIAKQAAhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAcgACkACIUiBEJ/hX4iCEI4hiAIQoD+A4NCKIaEIAhCgID8B4NCGIYgCEKAgID4D4NCCIaEhCAIQgiIQoCAgPgPgyAIQhiIQoCA/AeDhCAIQiiIQoD+A4MgCEI4iISEhIUgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCADfoVCF4khAyAHQn+FIQgDQCADIAV8IAYgASkAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABKQAIIgkgCIV+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFIAMgByAJhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEfoVCF4khAyABQRBqIQEgAkEQayICQRBLDQALCyADIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIR+IANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgBUJ/hX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgA4kL3g4BHX8jAEEQayISJABBBiAAKALEASIIIAhBBk8bIQlBBiAAKALIASIIIAhBBk8bIQ0gACgCBCIRIAAoAgwiEGohFSAHQQJJIgxFBEAgACgCtAEiCCgCBCIWIAgoAgxqIR4gCCgCACETCyADIARqIQ4gCUEESyEXIA1BBEshFCACKAIEIQggAigCACEKIAMgAyAVayAeIBNrRmohBAJ/IAcEQCAIIQsgCiEPQQAMAQtBACAKIAogBCARayILIBAgC0EBIAAoArgBdCIPayAQIAsgEGsgD0sbIAAoAhgbayILSyIYGyEPIApBACAYGyEcQQAgCCAIIAtLIgobIQsgCEEAIAobCyEhIA5BEGshHyAJQQQgFxshGCANQQQgFBshGSAAQQA2AtwBIAVBAkciIkUEQCAAIBEgGSAAKAIcIB8QoBoLIB8gDkEIayAFQQJGGyEaIBZBACAWIBNrIBBqIh0gDBtrISMgFiAdayEkIAdBAkkhGwNAIA8gEWohIEEAIA9rIRQCfwJAAkACQANAIAQgGk8NASAEQQFqIQgCQCAbRQRAQQAhCiAEICBrQQFqIgkgEGtBfEsNASAWIAkgHWtqIAkgEWogCSAQSSIJGyINKAAAIAgoAABHDQEgBEEFaiANQQRqIA4gEyAOIAkbIBUQzShBBGohCiAGDQEMBAtBACEKIAcgD0VyDQAgCCAUaigAACAIKAAARw0AIARBBWoiCiAKIBRqIA4QgBRBBGohCiAGRQ0DCyASQf+T69wDNgIMIAAgBCAOIBJBDGogGSAYIAUgBxC3BiIJIAogCSAKSyIJGyIKQQNNBEAgACAEIANrIghB/w9LNgLcASAEIAhBCHZqQQFqIQQMAQsLIAQgCCAJGyEIIBIoAgxBASAJGyENAkAgBkUNAANAIAQgGk8NASAEQQFqIQkCQCAHIA1FckUEQCAPRQ0BIAkoAAAgCSAUaigAAEcNASAEQQVqIgwgDCAUaiAOEIAUIgxBe0sNASANZyAKQQNsakEeayAMQQRqIgxBA2xODQFBASENIAkhCCAMIQoMAQsgGw0AIAkgIGsiDCAQa0F8Sw0AIBYgDCAda2ogDCARaiAMIBBJIgwbIhcoAAAgCSgAAEcNACAEQQVqIBdBBGogDiATIA4gDBsgFRDNKCIMQXtLDQAgDWcgCkEDbGpBHmsgDEEEaiIMQQNsTg0AQQEhDSAJIQggDCEKCyASQf+T69wDNgIIAkAgACAJIA4gEkEIaiAZIBggBSAHELcGIgxBBEkNACASKAIIIhdnIAxBAnRqQR9rIA1nIApBAnRqQRtrTA0AIBchDSAMIQogCSIIIQQMAQsgBkECRyAJIBpPcg0BIARBAmohCQJAIAcgDUVyRQRAIA9FDQEgCSgAACAJIBRqKAAARw0BIARBBmoiBCAEIBRqIA4QgBQiBEF7Sw0BIA1nIApBAnRqQR5rIARBBGoiBEECdE4NAUEBIQ0gCSEIIAQhCgwBCyAbDQAgCSAgayIMIBBrQXxLDQAgFiAMIB1raiAMIBFqIAwgEEkiDBsiFygAACAJKAAARw0AIARBBmogF0EEaiAOIBMgDiAMGyAVEM0oIgRBe0sNACANZyAKQQJ0akEeayAEQQRqIgRBAnRODQBBASENIAkhCCAEIQoLIBJB/5Pr3AM2AgQgACAJIA4gEkEEaiAZIBggBSAHELcGIgRBBEkNASASKAIEIgxnIARBAnRqQR9rIA1nIApBAnRqQRhrTA0BIAwhDSAEIQogCSIIIQQMAAsACyANQQRJDQICQCAHDQBBACANayELA0AgAyAITw0BIAggC2oiCUEDaiAVTQ0BIAhBAWsiBC0AACAJQQJqLQAARw0BIApBAWohCiAEIQgMAAsACwJAIBsNACAkIBEgCCANIBFqa0EDaiIEIBBJIgsbIARqIQQgHiAVIAsbIQkDQCAEIAlNIAMgCE9yDQEgCEEBayILLQAAIARBAWsiBC0AAEcNASAKQQFqIQogCyEIDAALAAsgDyELIA1BA2sMAwsgAiAPIBwgDxs2AgAgAiALIBwgISAPGyAhIBwbIAsbNgIEIBJBEGokACAOIANrDwtBASENCyAPCyEEIAEgCCADayADIA4gDSAKEIUSIAAoAtwBBEAgIkUEQCAAIBEgGSAAKAIcIB8QoBoLIABBADYC3AELIAggCmohAyAbRQRAA0ACQCALIQggAyAaSw0AIAMgCCARamsiCyAQa0F8Sw0AIAsgIyARIAsgEEkiCxtqIgooAAAgAygAAEcNACABQQAgAyAOQQEgA0EEaiAKQQRqIA4gEyAOIAsbIBUQzShBBGoiCxCFEiADIAtqIQMgBCELIAghBAwBCwsgCCELCyAEIQ8gAyEEIAcNAANAAkAgCyIERSADIBpLcg0AIAMoAAAgAyAEaygAAEcNACABQQAgAyAOQQEgA0EEaiIIIAggBGsgDhCAFEEEaiIIEIUSIAMgCGohAyAPIQsgBCEPDAELCyADIQQMAAsAC5oQAhJ/BX4jAEFAaiICJAAgAkEAOgAQIAJCADcDACACQoGAgIAQNwMIA0AgASACaiIDKAIAIQUgAyAAIAFqQTBqIgMoAgA2AgAgAyAFNgIAIAFBBGoiAUEYRw0AC0EAIQEgAkEANgIkIAJCATcCHANAIAJBHGogAWoiAygCACEFIAMgACABakHIAGoiAygCADYCACADIAU2AgAgAUEEaiIBQQxHDQALQcz/+wAhCkGABCEJAkACQAJAAkAgAC0AmAFBAWsOAwABAgMLIABBpAFqIQpBtAohCQwCCyAAQfQqaiEKQbQKIQkMAQsgAEHE1ABqIQpB0AQhCQtBzI/8ACEMQSAhCwJAAkACQAJAIAAtAKABQQFrDgMAAQIDCyAAQaQBaiEMQbQKIQsMAgsgAEH0KmohDEG0CiELDAELIABBxNQAaiEMQdAEIQsLIAAoAgwiA0FAaiIBQUFJBEAgAEEwaiENIABByABqIQ9CfyAANQKcAYZCfyAANQKUAYYhFSABIANLIQcCQCACLQAQIgRBCk8EQCACKQMAIRQgAigCCCEDDAELIAIgBEE4ciIFOgAQIAIgAigCCCIGIARBA3ZBB3NqIgM2AgggAiACKQMAIAYpAAAgBK2GhCIUNwMAIAUhBAsgAEEIaiEQQn+FIRcgFUJ/hSEVQQAgASAHGyEOIAIoAgwhEgJAA0ACQCACIAMgBEH/AXEiAUEDdkEHc2oiBTYCCCADKQAAIASthiAUhCETAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAAoApQBSQRAIAkgEyAVg6ciAUsNASABIAlBoJT8ABDDIQALIAkgFCAVg6ciAU0NAQsgBEE4ciEEIAogAUECdGoiAy8BACEGIAMtAAMhCAJAAkACQCADLQACIgENACACKAIkIgMgAigCICIBTw0EIAIoAhwgA2ogBjoAACACIANBAWoiBzYCJCAJIBMgCK2IIhMgFYOnIgFNDQUgBCAIayEEIAogAUECdGoiAS8BACEGIAEtAAMhCCABLQACIgENACAHIAIoAiAiAU8NBiACKAIcIAdqIAY6AAAgAiADQQJqIgM2AiQgCSATIAitiCITIBWDpyIBSw0BIAEgCUHQlPwAEMMhAAsgBCAIayEEIBMgCK2IIRQMAQsgBCAIIAogAUECdGoiAS0AAyIHamshBCATIAdBP3GtiCEUIAEvAQAhBiABLQACIgFFDQwLAkACQANAIAFBEHENASABQcAAcQ0CIAYgFEJ/IAGtQi+DhkJ/hYOnakH//wNxIgMgCUkEQCAEIAogA0ECdGoiAy0AAyIBayEEIBQgAUE/ca2IIRQgAy8BACEGIAMtAAIiAUUNDgwBCwsgAyAJQeCU/AAQwyEACyACIAQgAUEPcWsiBDoAECACIBQgAa1CD4MiFogiEzcDACALIBMgF4OnIgNLDQUgAyALQfCU/AAQwyEAC0EAQdOzwgAgAUEgcSIDGyEBQQxBHiADGyEJQRwhBiAFIQMMBQsgASAJQbCU/AAQwyEACyADIAFBtPH8ABDDIQALIAEgCUHAlPwAEMMhAAsgByABQbTx/AAQwyEACyAMIANBAnRqIggtAAMhESAILQACIQECfyAEQf8BcUEcTwRAIAUhAyAEDAELIAIgBSAEQfgBcUEDdkEHc2oiAzYCCCAFKQAAIASthiAThCETIARBOHILIAgvAQAhCCARayEEIBMgEa2IIRMgAUEQcUUEQANAIAFBwABxBEBB77PCACEBQRYhBkEeIQkgEyEUDAMLIAsgCCATQn8gAa1CL4OGQn+Fg6dqQf//A3EiBU0NAyAEIAwgBUECdGoiBS0AAyIBayEEIBMgAUE/ca2IIRMgBS8BACEIIAUtAAIiAUEQcUUNAAsLIAYgFEJ/IBaGQn+Fg6dqIQYgAiAEIAFBD3FrIgQ6ABAgAiATIAGtQg+DIhaIIhQ3AwAgCCATQn8gFoZCf4WDp2pB//8DcSIIIAIoAiQiBU0EQCACQRxqIAggBkH//wNxEIcNDAgLAkAgCCAFayIBIAAoAhBNBEAgACgCFCIFDQEgDiABayEHDAYLIAAtAAFBBHFFDQNB3bLCACEBQR4hCUEeIQYMAQsgASAFSw0DIAUgAWshBwwECyAAIAk6AAAMBwsgBSALQYCV/AAQwyEACyACQQA2AjggAkEBNgIsIAJB2JH8ADYCKCACQgQ3AjAgAkEoakGQlfwAEO8sAAsgDiABIAVrIgFrIQcgASAGQf//A3FPDQAgAkEcaiAQIAcgDhDUEiAGIAFrIQZBACEHIAUhAQsgAkEcaiIFIBAgByAGQf//A3EiBiABIAEgBksbIAdqENQSIAEgBk8NAiAFIAggBiABaxCHDQwCCyACKAIkIQMLIAIgBDoAECACIBQ3AwAgAyACKAIgIgFPDQMgAigCHCADaiAGOgAAIAIgA0EBajYCJCAFIQMLQQAhASASIANrIARB+AFxQQN2akEOTQ0AIAIoAiAgAigCJGtBgwJLDQELCyACQRBqIgUgBEEHcToAACACQQhqIgcgAyAEQfgBcUEDdms2AgAgDyACKQIcNwIAIA9BCGogAkEkaigCADYCACANQRBqIAUpAwA3AwAgDSAUQn8gBK1CB4OGQn+FgyITNwMAIA1BCGogBykDADcDACACIBM3AwAgAQRAIAAgBjYCiAEgACABNgKEAQsgAkFAayQADwsgAyABQbTx/AAQwyEAC0H47/wAQcoAQcTw/AAQnykAC9rXAwIQfwZ+IwBB0ABrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkUEQCASQThqQS9BAEEBQQEQoBggEigCPCEBIBIoAjhBAUYNASASKAJAIgJBkM6DAUEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQY2AgIB4NgIADAMLIBIgASgCACABKAIEKAIcEQQAIhA2AhAgASACQQN0aiEIQQEhBiABIQUDQAJ/IAcEQCAFIAUgCEcNARoMBAsgBiAIIAVrQQN2Tw0DIAUgBkEDdGoLIgpBCGohBUEAIQZBASEHIAooAgAiCSAKKAIEKAIcIgoRBAAgEBC9CA0ACyASIAkgChEEADYCICASQQM2AjwgEkH4zYMBNgI4IBJCAjcCRCASQacENgIwIBJBpwQ2AiggEiASQSRqNgJAIBIgEkEgajYCLCASIBJBEGo2AiQgEkEUaiASQThqEJkOIABBjYCAgHg2AgAgACASKQIUNwIEIABBDGogEkEcaigCADYCAAwCCyABIBIoAkBB2MuDARD9LwALAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBARAIBAtAABBAmsOJQECAwQFBgcICQoLGRobHB0MDR43HyAhIiM3Nzc3NyQ3JQ4PEBE3CyASQQhqIBAQlCkgACASKQMINwIEIABBk4CAgHg2AgAMNwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNQyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1JIAIpAxBC8vypnuWPoZ0rhSACKQMYQtmLjbqZvu3vr3+FhFBFDUkgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiBzYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgIoAgQgAigCAGtBA3ZBAEEBQQEQoBggASgCGCEDIAEoAhRBAUYNRCABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiBCACKAIEIAIoAgBrQQN2EIEuIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgAiADQQRqEMASIANBEGokACAFQSxqIgNBCGogBigCADYCACADIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgAxDuGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgMgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIEIAEgAhDYHSABIBAQzQYgARCaHiADIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBBC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHQ3YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBBEEEEOAeIAVB0AFqJAAMAQsMOAsMNgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNQiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1IIAIpAxBCmcTpt9SjhcVuhSACKQMYQpiWydPQ9J6WrX+FhFBFDUggCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCcGyAFQbwBaiIBIAQQ6RggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ2h0gASAQEM0GIAEQmR4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+NGDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDcLDDULQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDUEgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRyACKQMQQqSv9PqoqZ2QLYUgAikDGELjrPqF49vQ9WyFhFBFDUcgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQvx0gASAQEM0GIAEQkh4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBmM+DATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDYLDDQLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDUAgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRiACKQMQQo2j65PMtMaQ9wCFIAIpAxhC2avs9tngxfSMf4WEUEUNRiALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDWHSABIBAQzQYgARCVHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGY2oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMNQsMMwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1FIAIpAxBC+/bY6vDijZ/GAIUgAikDGEKZhqW/+K+hjtIAhYRQRQ1FIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgc2AnAjAEEgayIBJAAgAUEUaiAFQegAaiICKAIEIAIoAgBrQQN2QQBBAUEBEKAYIAEoAhghAyABKAIUQQFGDUAgAUEQaiIGQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgMkACABQQhqIgQgAigCBCACKAIAa0EDdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAIgA0EEahDAEiADQRBqJAAgBUEsaiIDQQhqIAYoAgA2AgAgAyABKQIINwIAIAFBIGokACAFQbwBaiIBIAMQ7hggBUH4AGogBUEkaikCADcDACAFQfAAaiIDIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiBCABIAIQwR0gASAQEM0GIAEQmx4gAyAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAQQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBiNaDATYCCCAAIAE2AgQgAEGTgICAeDYCACAHQQRBBBDgHiAFQdABaiQADAELDDQLDDILQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDT4gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRCACKQMQQsmQrefTvtn4nH+FIAIpAxhC8fLKq+fn0cbCAIWEUEUNRCALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEJwbIAVBvAFqIgEgBBDpGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDNHSABIBAQzQYgARCWHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGg0YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMMwsMMQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1DIAIpAxBC0fH3zJy66f5OhSACKQMYQtbCj5mYvPKj8QCFhFBFDUMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiBzYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYNPiABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiBCACKAIEIAIoAgBrQQN2EIUuIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgAiADQQRqEPURIANBEGokACAFQSxqIgNBCGogBigCADYCACADIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgAxDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgMgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIEIAEgAhDHHSABIBAQzQYgARCPHiADIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBBC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHY34MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBBEEEEOAeIAVB0AFqJAAMAQsMMgsMMAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPCABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1CIAIpAxBC3KeGzZSXyb2Wf4UgAikDGEKF8OaFkNqf4wyFhFBFDUIgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQ5xggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ2R0gASAQEM0GIAEQkR4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+NyDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDELDC8LQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDTsgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNQSACKQMQQofA7OjEzr/RyQCFIAIpAxhCvr+ev6/DpIL4AIWEUEUNQSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEJwbIAVBvAFqIgEgBBDpGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDPHSABIBAQzQYgARCYHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHA2YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMMAsMLgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNOiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1AIAIpAxBCzLSi/ZWEi6FkhSACKQMYQv6Kjfy6sNua3ACFhFBFDUAgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYNOyAFQSxqIQggAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDuLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCigCBCEGIAooAgAhEQJAAkAgBCgCACIDIAQoAgQiCUcEQCAKKAIIIAZBAnRqIQogCSADa0EDdiEMIAQoAgghCwNAIAMoAgAiCSALKAIIIg9PDUIgCygCBCAJQQJ0aigCACEJIAIgA0EEaigCACIPNgIAIAlBDGoQ2zwgD00NAiAKIAkoAhAgD0ECdGoqAgA4AgAgA0EIaiEDIApBBGohCiAGQQFqIQYgDEEBayIMDQALCyARIAY2AgAgAkEwaiQADAELIAIgCRD8OzYCHAxCCyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCCDcCACABQSBqJAAgBUG8AWoiASAIEOgYIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEEL4dIAEgEBDNBiABEJMeIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQbDggwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwvCwwtC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg05IAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDT8gAikDEELut8rBy8Ln6Ll/hSACKQMYQvCO45ubiNaLEYWEUEUNPyALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIONgJwIwBBIGsiASQAIAFBFGogBUHoAGoiBCgCBCAEKAIAa0EDdkEAQQhBCBCgGCABKAIYIQMgASgCFEEBRg06IAVBLGohCCABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAiAEKAIEIAQoAgBrQQN2EOwtIAcgAikCBEIgiTcCCCAHIAJBCGo2AgQjAEEwayICJAAgB0EEaiIKKAIEIQYgCigCACERAkAgBCgCACIDIAQoAgQiCUcEQCAKKAIIIAZBA3RqIQogCSADa0EDdiEMIAQoAgghCwNAIAMoAgAiCSALKAIIIg9PDUAgCygCBCAJQQJ0aigCACEJIAIgA0EEaigCACIPNgIAIAlBDGoQ2DwgD00NQSAKIAkoAhAgD0EDdGorAwA5AwAgA0EIaiEDIApBCGohCiAGQQFqIQYgDEEBayIMDQALCyARIAY2AgAgAkEwaiQADAALIAdBEGokACAIQQhqIA0oAgA2AgAgCCABKQIINwIAIAFBIGokACAFQbwBaiIBIAgQ5xggBUH4AGogBUEkaikCADcDACAFQfAAaiICIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiAyABIAQQ2x0gASAQEM0GIAEQkB4gAiAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAMQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB4NaDATYCCCAAIAE2AgQgAEGTgICAeDYCACAOQQRBBBDgHiAFQdABaiQADAELDC4LDCwLIBAtAAFBAWsOAwYHCAULIBAtAAFBAWsOAgkKCAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNNiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ08IAIpAxBCn8K+osy/yKAhhSACKQMYQtbFlMaY/fXY+ACFhFBFDTwgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQyh0gASAQEM0GIAEQ0BggBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB6NiDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDCsLDCkLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDTUgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNOyACKQMQQrXD/r6MnKqmwwCFIAIpAxhCkvvHkL7smP6jf4WEUEUNOyALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDGHSABIBAQzQYgARDSGCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHY1IMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMKgsMKAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNNCABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ06IAIpAxBCh/nb2tfR/Jg8hSACKQMYQrbv6LX0pYK+ln+FhFBFDTogCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEQQRAQoBggASgCGCEDIAEoAhRBAUYNNSAFQSxqIQogAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDrLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCCgCBCEGIAgoAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCCgCCCAGQQR0aiEIIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw07IAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENo8IA9NDT0gCSgCECAPQQR0aiIJKQMAIRUgCCAJKQMINwMIIAggFTcDACADQQhqIQMgCEEQaiEIIAZBAWohBiAMQQFrIgwNAAsLIBEgBjYCACACQTBqJAAMAAsgB0EQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgChDsGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgIgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIDIAEgBBDLHSABIBAQzQYgARDTGCACIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgAxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo44MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIA5BBEEEEOAeIAVB0AFqJAAMAQsMKQsMJwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNMyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ05IAIpAxBC47Di8bKTqs3WAIUgAikDGEKw3+Dy+LaU9Id/hYRQRQ05IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIg42AnAjAEEgayIBJAAgAUEUaiAFQegAaiIEKAIEIAQoAgBrQQN2QQBBEEEgEKAYIAEoAhghAyABKAIUQQFGDTQgBUEsaiEKIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAM2AggjAEEQayIGJAAgAUEIaiICIAQoAgQgBCgCAGtBA3YQ7y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQTBrIgIkACAGQQRqIgMoAgQhCCADKAIAIRECQAJAIAQoAgAiByAEKAIEIglHBEAgAygCCCAIQQV0aiEDIAkgB2tBA3YhDCAEKAIIIQsDQCAHKAIAIgkgCygCCCIPTw07IAsoAgQgCUECdGooAgAhCSACIAdBBGooAgAiDzYCACAJQQxqENw8IA9NDQIgCSgCECAPQQV0aiIJKQMAIRUgCSkDCCEWIAkpAxAhFyADQRhqIAkpAxg3AwAgA0EQaiAXNwMAIAMgFjcDCCADIBU3AwAgB0EIaiEHIANBIGohAyAIQQFqIQggDEEBayIMDQALCyARIAg2AgAgAkEwaiQADAELIAIgCRCAPDYCHAw7CyAGQRBqJAAgCkEIaiANKAIANgIAIAogASkCCDcCACABQSBqJAAgBUG8AWoiASAKEO0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEEM4dIAEgEBDNBiABENEYIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQfDagwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwoCwwmC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0yIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTggAikDEEKo+Inf7v3i9xmFIAIpAxhCgoiiweW47v4WhYRQRQ04IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACELwdIAEgEBDNBiABEPIcIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQbDVgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwnCwwlC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0xIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTcgAikDEEL6mLb6kqaKwxyFIAIpAxhCo8C62dbm4aomhYRQRQ03IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMAdIAEgEBDNBiABEPUcIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjbgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwmCwwkC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0wIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTYgAikDEELtxZanvY/g2FSFIAIpAxhC14P/uOLrl/HcAIWEUEUNNiALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDDHSABIBAQzQYgARD6HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGo3oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMJQsMIwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNLyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ01IAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUEUNNSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDQHSABIBAQzQYgARD5HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEG44oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMJAsMIgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNLiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ00IAIpAxBCyeD6hKnPk5YvhSACKQMYQsvdpdKuhoKM/ACFhFBFDTQgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQvR0gASAQEM0GIAEQ9BwgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBoNyDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDCMLDCELQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDS0gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNMyACKQMQQrWospbEp++mTIUgAikDGEL384vm1Y6BzQKFhFBFDTMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEEQQgQoBggASgCGCEDIAEoAhRBAUYNLiAFQSxqIQggAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDqLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCigCBCEGIAooAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCigCCCAGQQN0aiEKIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw00IAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENg8IA9NDTUgCiAJKAIQIA9BA3RqKQIANwIAIANBCGohAyAKQQhqIQogBkEBaiEGIAxBAWsiDA0ACwsgESAGNgIAIAJBMGokAAwACyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCCDcCACABQSBqJAAgBUG8AWoiASAIEOsYIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEENMdIAEgEBDNBiABEPccIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZDjgwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwiCwwgC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0sIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTIgAikDEELi0/LH09WDnP4AhSACKQMYQsXZuYGappOlgH+FhFBFDTIgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEIQRAQoBggASgCGCEDIAEoAhRBAUYNLSAFQSxqIQogAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDpLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCCgCBCEGIAgoAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCCgCCCAGQQR0aiEIIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw0zIAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENo8IA9NDTUgCSgCECAPQQR0aiIJKQMAIRUgCEEIaiAJQQhqKQMANwMAIAggFTcDACADQQhqIQMgCEEQaiEIIAZBAWohBiAMQQFrIgwNAAsLIBEgBjYCACACQTBqJAAMAAsgB0EQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgChDqGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgIgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIDIAEgBBDFHSABIBAQzQYgARDxHCACIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgAxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg4YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIA5BBEEEEOAeIAVB0AFqJAAMAQsMIQsMHwsgEC0AAUEBaw4DDQ4PDAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNKiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0wIAIpAxBCvubD2YGShrNWhSACKQMYQry/laP9rPK1N4WEUEUNMCALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIgbIAVBvAFqIgEgBBDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDSHSABIBAQzQYgARCUHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHI0IMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMHwsMHQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNKSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0vIAIpAxBCl9Gwm93/uJVZhSACKQMYQvyis4+I6LHY9gCFhFBFDS8gCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQxB0gASAQEM0GIAEQlx4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBiOGDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDB4LDBwLIBAtAAEOAg0OGgsgEC0AAUECaw4CDg8ZCyMAQbABayIGJAAgBkEAOgA0IAYgATYCECAGIAEgAkEDdGo2AhQgBiAGQTRqNgIYIwBBIGsiASQAIAFBFGogBkEQaiIFKAIEIAUoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDSYgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgckACAFKAIEIAUoAgBrQQN2IgggAUEIaiIQKAIAIBAoAggiAmtLBEAgECACIAhBBEEEEN4oIBAoAgghAgsgBkH0AGohCiAHIBAoAgQ2AgwgByACNgIIIAcgEEEIajYCBCMAQSBrIgIkACAHQQRqIgkoAgQhCCAJKAIAIRECQCAFKAIAIhAgBSgCBCILRwRAIAUoAgghDCAJKAIIIAhBAnRqIQkgCyAQa0EDdiELA0AgEEEEaigCACEPIBAoAgAhDiAMIAwtAAAEf0EBBSAOIA8oAkQRBABBAEcLOgAAIAJBCGogDiAPKAIQEQAAIAJBEGogAigCCCIPIAIoAgwoAgwRAAAgD0UNLCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUEUNLCAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQRBBBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCdKCAGKAJ4C0EANgIAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDAJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0eIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0gIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEIAXIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQ6BggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBlKjQoAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZClKjQoMGChYoUNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEGA5YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMHAsMGQsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0lIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSsgAikDEELCjPf26svc0YR/hSACKQMYQuWT9Jj5r/joqH+FhFBFDSsgCSAPNgIAIBBBCGohECAJQQRqIQkgCEEBaiEIIAtBAWsiCw0ACwsgESAINgIAIAJBIGokAAwACyAHQRBqJAAgCkEIaiANKAIANgIAIAogASkCCDcCACABQSBqJABBACECIAYtADRBAUYEQCAGIAQ2AhQgBiADNgIQIAYgCjYCGCAGQZgBaiIBIAQgBRDACCAFIAEQ4ScgBkGIAWogBkEcaikCADcDACAGQZABaiAGQSRqKAIANgIAIAYgBikCFDcDgAEgBigCECECCyAGQRhqIAZB/ABqKAIANgIAIAZBKGogBkGIAWopAwA3AwAgBkEwaiAGQZABaigCADYCACAGIAYpAnQ3AxAgBiACNgIcIAYgBikDgAE3AyAgBkEANgI0IAZBmAFqIARBAWpBAEEIQQgQoBggBigCnAEhAQJAIAYoApgBQQFHBEAgBkEANgJ8IAYgBigCoAEiAjYCeCAGIAE2AnQgAQR/IAIFIAZB9ABqQdDkgwEQsyggBigCeAtCADcDACAGQQE2AnwgBiADNgKYASAGIAMgBEEDdGoiBDYCnAEgBiAGQTRqNgKkASAGIAZBEGo2AqABIAZB9ABqIAZBmAFqIgEQwScgASAGKAI0QQBBAUEBEKAYIAYoApwBIQIgBigCmAFBAUYNHSAGQRxqIQEgBkEANgKIASAGIAYoAqABNgKEASAGIAI2AoABA0AgAygCACICIAYoAhgiBU8NHyAGQQhqIAYoAhQgAkECdGooAgAgA0EEaigCABDyFiAGQYABaiAGKAIIIAYoAgwQoTYgA0EIaiIDIARHDQALIAZBoAFqIgIgBkH8AGooAgA2AgAgBiAGKQJ0NwOYASAGQcQAaiAGQZgBaiIDEL0YIAIgBkGIAWooAgA2AgAgBiAGKQKAATcDmAEgBkHQAGogAxCTGSAGQUBrQZas2LABNgIAIAZB5ABqIAFBCGopAgA3AgAgBkHsAGogAUEQaikCADcCACAGQpas2LDhwoWLFjcDOCAGIAEpAgA3AlxBxABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiAGQThqQTz8CgAAIABBqOeDATYCCCAAIAE2AgQgAEGTgICAeDYCACAGQRBqQQRBBBDgHiAGQbABaiQADAELDBsLDBgLIwBB0AFrIgYkACAGQQA6AEAgBiABNgIAIAYgASACQQN0ajYCBCAGIAZBQGs2AggjAEEgayIBJAAgAUEUaiAGKAIEIAYoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDSQgAUEQaiIOQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgUkACAGKAIEIAYoAgBrQQN2IhAgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIBBBBEEEEN4oIAIoAgghBwsgBkGUAWohCCAFIAIoAgQ2AgwgBSAHNgIIIAUgAkEIajYCBCMAQSBrIgIkACAFQQRqIgooAgQhECAKKAIAIQ0CQCAGKAIAIgcgBigCBCIMRwRAIAYoAgghCSAKKAIIIBBBAnRqIQogDCAHa0EDdiEMA0AgB0EEaigCACELIAcoAgAhDyAJIAktAAAEf0EBBSAPIAsoAkQRBABBAEcLOgAAIAJBCGogDyALKAIQEQAAIAJBEGogAigCCCILIAIoAgwoAgwRAAAgC0UNKiACKQMQQq/zkNiUnMf7M4UgAikDGEKgpcX0zdDRpI1/hYRQRQ0qIAogCzYCACAHQQhqIQcgCkEEaiEKIBBBAWohECAMQQFrIgwNAAsLIA0gEDYCACACQSBqJAAMAAsgBUEQaiQAIAhBCGogDigCADYCACAIIAEpAgg3AgAgAUEgaiQAQQAhASAGLQBAQQFGBEAgBiAENgIEIAYgAzYCACAGIAg2AgggBkG4AWoiASAEIAYQvgggBiABEOEnIAZBqAFqIAZBDGopAgA3AwAgBkGwAWogBkEUaigCADYCACAGIAYpAgQ3A6ABIAYoAgAhAQsgBkEIaiICIAZBnAFqKAIANgIAIAZBGGogBkGoAWopAwA3AwAgBkEgaiAGQbABaigCADYCACAGIAYpApQBNwMAIAYgATYCDCAGIAYpA6ABNwMQIAZBADYCMCAGQoCAgIDAADcCKCAGQbgBaiACKAIAIgVBAWpBAEEEQQQQoBggBigCvAEhAQJAIAYoArgBQQFHBEAgBiAGKALAASICNgI4IAYgATYCNCACQQA2AgAgBkEBNgI8QQAhAiAFBEAgBigCBCEHQQIhASAFQQJ0IRBBACEFA0AgBSAHaigCACgCCCACaiECIAYoAjQgAUEBa0YEQCAGQTRqQfjugwEQnSgLIAYoAjggBWpBBGogAjYCACAGIAE2AjwgAUEBaiEBIBAgBUEEaiIFRw0ACwsgBkFAayIFIAIQqBUgBiADNgK4ASAGIAMgBEEDdGo2ArwBIAYgBkEoajYCzAEgBiAFNgLIASAGIAZBNGoiAjYCxAEgBiAGNgLAASAGQcwAaiIBIAZBuAFqIgMQ/xogBkGUAWoiBCABELoYIAZBqAFqIAZBMGooAgA2AgAgBiAGKQIoNwOgASAGQcgBaiAGQQxqIgFBEGopAgA3AwAgBkHAAWogAUEIaikCADcDACAGIAEpAgA3A7gBIAZB2ABqIgcgBCAGQaABaiADELwgQcQAQQQQrTYiAUUNHiABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQYjvgwE2AgggACABNgIEIABBk4CAgHg2AgAgBRDqOyACEOk7IAZBBEEEEOAeIAZB0AFqJAAMAQsMHgsMFwsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0jIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSkgAikDEELH2fTn3sS2nHeFIAIpAxhCjbLOlIzKkuanf4WEUEUNKSAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQRBBBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCdKCAGKAJ4C0EANgIAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDAJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0bIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0dIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEP8WIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQ6BggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBmLDgwAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZCmLDgwIGDhowYNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDR0gAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEHQ5oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMGQsMFgsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0iIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSggAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUEUNKCAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQhBCBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCzKCAGKAJ4C0IANwMAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDBJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0aIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0cIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEPEWIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQvRggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBmbLkyAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZCmbLkyJGjxowZNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDRwgAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEH45YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMGAsMFQsjAEHQAWsiBiQAIAZBADoAQCAGIAE2AgAgBiABIAJBA3RqNgIEIAYgBkFAazYCCCMAQSBrIgEkACABQRRqIAYoAgQgBigCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNISABQRBqIg5BADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiBSQAIAYoAgQgBigCAGtBA3YiECABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgEEEEQQQQ3iggAigCCCEHCyAGQZQBaiEIIAUgAigCBDYCDCAFIAc2AgggBSACQQhqNgIEIwBBIGsiAiQAIAVBBGoiCigCBCEQIAooAgAhDQJAIAYoAgAiByAGKAIEIgxHBEAgBigCCCEJIAooAgggEEECdGohCiAMIAdrQQN2IQwDQCAHQQRqKAIAIQsgBygCACEPIAkgCS0AAAR/QQEFIA8gCygCRBEEAEEARws6AAAgAkEIaiAPIAsoAhARAAAgAkEQaiACKAIIIgsgAigCDCgCDBEAACALRQ0nIAIpAxBCq5iR8ZX61fyAf4UgAikDGEKWlPir8LHps+EAhYRQRQ0nIAogCzYCACAHQQhqIQcgCkEEaiEKIBBBAWohECAMQQFrIgwNAAsLIA0gEDYCACACQSBqJAAMAAsgBUEQaiQAIAhBCGogDigCADYCACAIIAEpAgg3AgAgAUEgaiQAQQAhASAGLQBAQQFGBEAgBiAENgIEIAYgAzYCACAGIAg2AgggBkG4AWoiASAEIAYQvgggBiABEOEnIAZBqAFqIAZBDGopAgA3AwAgBkGwAWogBkEUaigCADYCACAGIAYpAgQ3A6ABIAYoAgAhAQsgBkEIaiICIAZBnAFqKAIANgIAIAZBGGogBkGoAWopAwA3AwAgBkEgaiAGQbABaigCADYCACAGIAYpApQBNwMAIAYgATYCDCAGIAYpA6ABNwMQIAZBADYCMCAGQoCAgIDAADcCKCAGQbgBaiACKAIAIgVBAWpBAEEEQQQQoBggBigCvAEhAQJAIAYoArgBQQFHBEAgBiAGKALAASICNgI4IAYgATYCNCACQQA2AgAgBkEBNgI8QQAhAiAFBEAgBigCBCEHQQIhASAFQQJ0IRBBACEFA0AgBSAHaigCACgCCCACaiECIAYoAjQgAUEBa0YEQCAGQTRqQfjugwEQnSgLIAYoAjggBWpBBGogAjYCACAGIAE2AjwgAUEBaiEBIBAgBUEEaiIFRw0ACwsgBkFAayIFIAIQqBUgBiADNgK4ASAGIAMgBEEDdGo2ArwBIAYgBkEoajYCzAEgBiAFNgLIASAGIAZBNGoiAjYCxAEgBiAGNgLAASAGQcwAaiIBIAZBuAFqIgMQ/xogBkGUAWoiBCABELoYIAZBqAFqIAZBMGooAgA2AgAgBiAGKQIoNwOgASAGQcgBaiAGQQxqIgFBEGopAgA3AwAgBkHAAWogAUEIaikCADcDACAGIAEpAgA3A7gBIAZB2ABqIgcgBCAGQaABaiADEL0gQcQAQQQQrTYiAUUNGyABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQaDugwE2AgggACABNgIEIABBk4CAgHg2AgAgBRDqOyACEOk7IAZBBEEEEOAeIAZB0AFqJAAMAQsMGwsMFAsjAEHwAWsiBiQAIAZBADoAOCAGIAE2AkQgBiABIAJBA3RqNgJIIAYgBkE4ajYCTCMAQSBrIgEkACABQRRqIAZBxABqIgooAgQgCigCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNICABQRBqIhFBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiBSQAIAooAgQgCigCAGtBA3YiCCABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCEEEQQQQ3iggAigCCCEHCyAGQcgBaiEJIAUgAigCBDYCDCAFIAc2AgggBSACQQhqNgIEIwBBIGsiAiQAIAVBBGoiDCgCBCEIIAwoAgAhEwJAIAooAgAiByAKKAIEIg9HBEAgCigCCCELIAwoAgggCEECdGohDCAPIAdrQQN2IQ8DQCAHQQRqKAIAIQ4gBygCACENIAsgCy0AAAR/QQEFIA0gDigCRBEEAEEARws6AAAgAkEIaiANIA4oAhARAAAgAkEQaiACKAIIIg4gAigCDCgCDBEAACAORQ0mIAIpAxBCvrmqiZnSjZrgAIUgAikDGELFkYG6kcLDzTSFhFBFDSYgDCAONgIAIAdBCGohByAMQQRqIQwgCEEBaiEIIA9BAWsiDw0ACwsgEyAINgIAIAJBIGokAAwACyAFQRBqJAAgCUEIaiARKAIANgIAIAkgASkCCDcCACABQSBqJABBACECIAYtADhBAUYEQCAGIAQ2AkggBiADNgJEIAYgCTYCTEEAIQlBACEFIwBBMGsiCCQAQcAAIQwCQAJAIARBBnYiASAEQT9xIg9BAEdqIgJBA3QiB0HA////A3FBQGsgByACQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiDEUNAgsgBEHAAEkNAiABrSEZIAooAgghDiAKKAIAIQcgCigCBCIRrSEaA0AgF0IBfCEXIAchASAFIQJCACEVQgAhFgNAAkAgGiAVIBh8VgRAIAEoAgAiDSAOKAIIIhNJDQEgDSATQfj1gwEQwyEACyACIBFB6PWDARDDIQALIAFBBGohEyABQQhqIQEgAkEBaiECIA4oAgQgDUECdGooAgAgEygCABCTO60gFYYgFoQhFiAVQgF8IhVCwABSDQALIAkgDGogFjcDACAYQkB9IRggB0GABGohByAFQUBrIQUgCUEIaiEJIBcgGVINAAsMAgtB8PSDAUEpIAhBHGpBrPWDAUGc9YMBENUeAAtBwAAgCxCjPQALIA8EQCAKKAIEIgUgBEFAcSICayIBQQAgASAFTRutIRcgCigCACAEQQN0QYB8cWohASAPrSEYIAooAgghB0IAIRVCACEWA0ACQCAVIBdSBEAgASgCACIPIAcoAggiDkkNASAPIA5B+PWDARDDIQALIAIgBUHo9YMBEMMhAAsgAUEEaiEOIAFBCGohASACQQFqIQIgBygCBCAPQQJ0aigCACAOKAIAEJM7rSAVhiAWhCEWIBVCAXwiFSAYUg0ACyAJIAxqIBY3AAAgCUEIaiEJCyAGQfgAaiECIAggCzYCLCAIQoCAgICACDcCJCAIIAw2AhwgCCAEQQN2IARBB3FBAEdqIgEgCSABIAlJGyIFNgIgIAhBCGogCEEcahDXOyAIKAIIIQcCQEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAIKQIcNwIIIAFBEGogCEEkaikCADcCACABQRhqIAhBLGooAgA2AgAgCCAFNgIYIAggBzYCFCAIIAE2AhAgAiAIQRBqQQAgBBDyFSAIQTBqJAAMAQtBBEEcEKM9AAsgCiACEOEnIAZB4AFqIAZB0ABqKQIANwMAIAZB6AFqIAZB2ABqKAIANgIAIAYgBikCSDcD2AEgBigCRCECCyAGQRhqIAZB0AFqKAIANgIAIAZBKGogBkHgAWopAwA3AwAgBkEwaiAGQegBaigCADYCACAGIAYpAsgBNwMQIAYgAjYCHCAGIAYpA9gBNwMgIAZBADYCQCAGQoCAgIDAADcCOCAGQQhqIBBBBGoiBRDDNCAGQRxqIQECQAJAAkACQCAGKAIMIgoEQEEAIQIDQCAGKAIYIRAgBigCFCEHIAYgAjYC2AEgBiAHIBBBAnRqNgJIIAYgBzYCRCAGIAZB2AFqNgJMIAZB+ABqIgggBkHEAGoiB0HIy4MBEIQbIAcgBigCfCAGKAKAASADIAQQrwIgBigCTCEHIAYoAkghECAGKAJEIglBk4CAgHhHBEAgACAGKQJQNwIMIAAgBzYCCCAAIBA2AgQgACAJNgIAIAhBBEEIEOAeIAZBOGoiABDDJyAAEOo7IAZBEGpBBEEEEOAeIAYoAhwiAEUNAyAAIAAoAgAiAEEBazYCACAAQQFHDQMgARD7HgwDCyAGKAJAIgggBigCOEYEQCAGQThqQbjwgwEQmygLIAYoAjwgCEEDdGoiCSAHNgIEIAkgEDYCACAGIAhBAWo2AkAgBkH4AGpBBEEIEOAeIAogAkEBaiICRw0ACwsgBSgCACICIAIoAgAiA0EBajYCACADQQBIDQEgBSgCBCEDIAZB0AFqIAZBQGsoAgA2AgAgBiAGKQI4NwPIASAGQYgBaiABQRBqKQIANwMAIAZBgAFqIAFBCGopAgA3AwAgBiABKQIANwN4IAZBxABqIAIgAyAGQcgBaiAGQfgAahDlDyAGQeABaiIBIAZB0ABqKQIANwMAIAZB6AFqIgIgBkHYAGooAgA2AgAgBiAGKQJINwPYASAGKAJEIgNBgICAgHhGBEAgACAGKQPYATcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIAZBEGpBBEEEEOAeDAELIAZBqAFqIgQgBkH0AGooAgA2AgAgBkGgAWoiBSAGQewAaikCADcDACAGQZgBaiIHIAZB5ABqKQIANwMAIAZBuAFqIhAgASkDADcDACAGQcABaiIIIAIoAgA2AgAgBiAGKQJcNwOQASAGIAYpA9gBNwOwAUE8QQQQrTYiAUUNAiABIAM2AgggAUKBgICAEDcCACABIAYpA7ABNwIMIAEgBikDkAE3AiAgAEHg74MBNgIIIAAgATYCBCABQRRqIBApAwA3AgAgAUEcaiAIKAIANgIAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAgAUE4aiAEKAIANgIAIABBk4CAgHg2AgAgBkEQakEEQQQQ4B4LIAZB8AFqJAAMAgsAC0EEQTwQoz0ACwwTCyASIBBBBGo2AjQgECgCBC0AAEECaw4ICQoLDA0ODxAIC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0eIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDSQgAikDEELktsqsz8HjheAAhSACKQMYQs3RnZud/LiouX+FhFBFDSQgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ1B0gASAQEM0GIAEQhRcgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBuNeDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDBMLDBELQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDR0gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNIyACKQMQQuSpxfLdiuHGNIUgAikDGEK1yYmVqZf6txmFhFBFDSMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQyB0gASAQEM0GIAEQ/hYgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBgNSDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDBILDBALQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDRwgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNIiACKQMQQrX4x6jW3dS3vn+FIAIpAxhCp/LU/K+vgKllhYRQRQ0iIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMkdIAEgEBDNBiABEP0WIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcDOgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwRCwwPC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0bIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDSEgAikDEEKLtaPljNen43SFIAIpAxhCsKP53sDxp9eEf4WEUEUNISALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDRHSABIBAQzQYgARD8FiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHwz4MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMEAsMDgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNGiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0gIAIpAxBC65CWiN2g5IZghSACKQMYQrmNv6eS/6CCYYWEUEUNICALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIgbIAVBvAFqIgEgBBDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDMHSABIBAQzQYgARD4HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGo04MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMDwsMDQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNGSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0fIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFBFDR8gCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ1x0gASAQEM0GIAEQ8xwgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBkNiDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDA4LDAwLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDRggAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNHiACKQMQQsX5y/+RruGl8wCFIAIpAxhC7vSymv2ZrpRChYRQRQ0eIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMIdIAEgEBDNBiABEPscIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdDSgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwNCwwLC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0XIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDR0gAikDEEKGgdCQuIeTo5l/hSACKQMYQqPV46Dasvufe4WEUEUNHSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDVHSABIBAQzQYgARD2HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGA34MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMDAsMCgsgEkEBNgI8IBJBmM2DATYCOCASQgE3AkQgEkHFEzYCKCASIBJBJGo2AkAgEiASQTRqNgIkIBJBOGpBoM2DARDvLAALIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0XIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCEIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQiw9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhCZGyACIAggBSAGKAIYIAYoAhwQyAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPAeIAMgBEEDdGohCwNAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiAiB0kNAQwWCyAKEOY6IAYoAkBFDRcgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQQAhBCAGKAI8IgIgBigCNEcNA0GoxYMBIQEMAgsgASAGKAIoIgdPDRcgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACaiwAACIBTQ0YIAcoAgQgAWotAAAhBAJAIAYoAkAEQCAGKAJQIgdBAWoiCUEDdiAJQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQwgBigCRCIPIAJJBEAgCiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAYoAkwhAQsgDARAIAYoAkggAWpBACAM/AsACyAGIAI2AkwLIAYgCTYCUCAGKAJIIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAGIAYoAlRBAWo2AlQLIAYoAjwiAiAGKAI0Rw0CQbjFgwEhAQwBCwwUCyAGQTRqIAEQoygLIAYoAjggAmogBDoAACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICENYUIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0VIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQfDpgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhDeOyAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBENcrIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMCQsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0WIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCDIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQig9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhCXGyACIAggBSAGKAIYIAYoAhwQwwIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPUeIAMgBEEDdGohCwNAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiBBAXYiB0kNAQwVCyAKEOY6IAYoAkBFDRYgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQQAhBCAGKAI8IgIgBigCNEcNA0GoxYMBIQEMAgsgASAGKAIoIgdPDRYgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACQQF0ai4BACIBTQ0XIAcoAgQgAUEBdGovAQAhBAJAIAYoAkAEQCAGKAJQIgdBAWoiCUEDdiAJQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQwgBigCRCIPIAJJBEAgCiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAYoAkwhAQsgDARAIAYoAkggAWpBACAM/AsACyAGIAI2AkwLIAYgCTYCUCAGKAJIIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAGIAYoAlRBAWo2AlQLIAYoAjwiAiAGKAI0Rw0CQbjFgwEhAQwBCwwTCyAGQTRqIAEQrSgLIAYoAjggAkEBdGogBDsBACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICEM4UIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0UIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQdDsgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhCdPCAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBENUrIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMCAsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAcLIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0VIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCHIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQiQ9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhD6GiACIAggBSAGKAIYIAYoAhwQxAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPkeIAMgBEEDdGohCwNAAkACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIEQQxqIANBBGooAgAiAhCLOwRAIAIgBCgCIEECdiIHSQ0BDBULIAoQ5jogBigCQEUNFiAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0EQajFgwEhAQwDCyABIAYoAigiB08NFiAEKAIcIAJBAnRqKAIAIgIgBigCJCABQQxsaiIBKAIIIgRPDQEgASgCBCACQQJ0aigCACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQNBuMWDASEBDAILDBMLIAIgBEGI6YMBEMMhAAsgBkE0aiABEJ0oCyAGKAI4IAJBAnRqIAQ2AgAgBiACQQFqNgI8IANBCGoiAyALRw0ACyAGQbABaiIBIAZBNGoiAhDQFCAGQegAaiIDIAEgBigCLCAGKAIwEMcVQdAAQQQQrTYiAUUNEyABQoGAgIAQNwIAIAFBCGogA0HIAPwKAAAgEEH464MBNgIIIBAgATYCBCAQQZOAgIB4NgIAIAIQ6TsgBigCQARAIAoQzy8LIAZB3ABqELkMIAZBIGoiARCwKyABQQRBDBDgHiAGQRRqIgEQwicgAUEEQRQQ4B4LIAZBCGpBBEEEEOAeIAZB4AFqJAAgEigCQCEBIBIoAjwhAiASKAI4IgNBk4CAgHhHBEAgACASKQJENwIMIAAgATYCCCAAIAI2AgQgACADNgIADAcLIAIgARCaLCEBIABB+MuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyMAQeABayIGJAAjAEEgayIFJAAgBUEUaiABIAJBA3RqIgkgAWtBA3ZBAEEEQQQQoBggBSgCGCEHIAUoAhRBAUYNFCAFQRBqIg9BADYCACAFIAUoAhw2AgwgBSAHNgIIIwBBEGsiCCQAIAkgAWtBA3YiECAFQQhqIgooAgAgCigCCCIHa0sEQCAKIAcgEEEEQQQQ3iggCigCCCEHCyASQThqIRAgBkEIaiELIAggCigCBDYCDCAIIAc2AgggCCAKQQhqNgIEIAhBBGoiDCgCBCEKIAwoAgAgCSABIgdHBEAgDCgCCCAKQQJ0aiEMIAogCSABa0EDdiIJaiEKA0AgDCAHKAIAIAdBBGooAgAQhSI2AgAgB0EIaiEHIAxBBGohDCAJQQFrIgkNAAsLIAo2AgAgCEEQaiQAIAtBCGogDygCADYCACALIAUpAgg3AgAgBUEgaiQAAkAgBigCDCIIIAYoAhAiBSAEEOIPRQRAIBAgASACIAMgBBD9DwwBCyAGIAQ2AkQgBiADNgJAIAZBADYCPCAGIAg2AjQgBiAIIAVBAnRqNgI4IAZBFGoiASAGQTRqIgIQ+RogAiAIIAUgBigCGCAGKAIcEMACIAZBuAFqIgIgBkFAayIKKQIANwMAIAZBwAFqIgcgBkHIAGooAgA2AgAgBiAGKQI4NwOwASAGKAI0QQFGBEAgECAGKQOwATcCACAQQRBqIAcoAgA2AgAgEEEIaiACKQMANwIAIAEQwicgAUEEQRQQ4B4MAQsgBkEwaiAHKAIANgIAIAZBKGogAikDADcDACAGIAYpA7ABNwMgIAZBNGogBBD4HiADIARBA3RqIQwDQAJAAkAgBSADKAIAIgFLBEACQCAIIAFBAnRqKAIAIglBDGogA0EEaigCACICEIs7BEAgAiAJKAIgQQN2IgdJDQEMEwsgChDmOiAGKAJARQ0UIAYoAlBBAWoiBEEDdiAEQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQcgBigCRCIJIAJJBEAgCiAJQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIJIAEgCUsbEOgZIAYoAkwhAQsgBwRAIAYoAkggAWpBACAH/AsACyAGIAI2AkwLIAYgBDYCUEIAIRUgBigCPCIBIAYoAjRHDQNBqMWDASECDAILIAEgBigCKCIHTw0UIAYoAiQgAUEMbGoiBygCCCIEIAkoAhwgAkEDdGopAwCnIgFNDRUgBygCBCABQQN0aikDACEVAkAgBigCQARAIAYoAlAiBEEBaiIHQQN2IAdBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshCSAGKAJEIgsgAkkEQCAKIAtBAXQiASACQcD///8DcUFAayACIAJBP3EbIgsgASALSxsQ6BkgBigCTCEBCyAJBEAgBigCSCABakEAIAn8CwALIAYgAjYCTAsgBiAHNgJQIAYoAkggBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCIBIAYoAjRHDQJBuMWDASECDAELDBELIAZBNGogAhCzKAsgBigCOCABQQN0aiAVNwMAIAYgAUEBajYCPCADQQhqIgMgDEcNAAsgBkGwAWoiASAGQTRqIgIQ2xQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDRIgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBmOmDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEOM8IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1isgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwGCyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMBQsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDRMgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIkiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBCND0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEJkbIAIgCCAFIAYoAhggBigCHBDHAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ9x4gAyAEQQN0aiELA0ACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIJQQxqIANBBGooAgAiAhCLOwRAIAIgCSgCICIHSQ0BDBILIAoQ5jogBigCQEUNEyAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0DQajFgwEhAQwCCyABIAYoAigiB08NEyAGKAIkIAFBDGxqIgcoAggiBCAJKAIcIAJqLQAAIgFNDRQgBygCBCABai0AACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQJBuMWDASEBDAELDBALIAZBNGogARCpGQsgBigCOCACaiAEOgAAIAYgAkEBajYCPCADQQhqIgMgC0cNAAsgBkGwAWoiASAGQTRqIgIQ0RQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDREgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBoOuDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEN47IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1ysgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwFCyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMBAsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDRIgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIgiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBCMD0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEJcbIAIgCCAFIAYoAhggBigCHBDBAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ8x4gAyAEQQN0aiELA0ACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIJQQxqIANBBGooAgAiAhCLOwRAIAIgCSgCIEEBdiIHSQ0BDBELIAoQ5jogBigCQEUNEiAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0DQajFgwEhAQwCCyABIAYoAigiB08NEiAGKAIkIAFBDGxqIgcoAggiBCAJKAIcIAJBAXRqLwEAIgFNDRMgBygCBCABQQF0ai8BACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQJBuMWDASEBDAELDA8LIAZBNGogARCtKAsgBigCOCACQQF0aiAEOwEAIAYgAkEBajYCPCADQQhqIgMgC0cNAAsgBkGwAWoiASAGQTRqIgIQzxQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDRAgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBgOiDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEJ08IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1SsgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwECyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMAwsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDREgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIoiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBDkD0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEPoaIAIgCCAFIAYoAhggBigCHBDCAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ8h4gAyAEQQN0aiELA0ACQAJAAkAgBSADKAIAIgFLBEACQCAIIAFBAnRqKAIAIgRBDGogA0EEaigCACICEIs7BEAgAiAEKAIgQQJ2IgdJDQEMEQsgChDmOiAGKAJARQ0SIAYoAlBBAWoiBEEDdiAEQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQcgBigCRCIJIAJJBEAgCiAJQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIJIAEgCUsbEOgZIAYoAkwhAQsgBwRAIAYoAkggAWpBACAH/AsACyAGIAI2AkwLIAYgBDYCUEEAIQQgBigCPCICIAYoAjRHDQRBqMWDASEBDAMLIAEgBigCKCIHTw0SIAQoAhwgAkECdGooAgAiAiAGKAIkIAFBDGxqIgEoAggiBE8NASABKAIEIAJBAnRqKAIAIQQCQCAGKAJABEAgBigCUCIHQQFqIglBA3YgCUEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEMIAYoAkQiDyACSQRAIAogD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAGKAJMIQELIAwEQCAGKAJIIAFqQQAgDPwLAAsgBiACNgJMCyAGIAk2AlAgBigCSCAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBiAGKAJUQQFqNgJUCyAGKAI8IgIgBigCNEcNA0G4xYMBIQEMAgsMDwsgAiAEQYjpgwEQwyEACyAGQTRqIAEQnSgLIAYoAjggAkECdGogBDYCACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICENQUIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0PIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQajtgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhDpOyAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBELArIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMAwsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0QIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCGIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQ4w9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhD5GiACIAggBSAGKAIYIAYoAhwQwAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEO8eIAMgBEEDdGohDANAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiBBA3YiB0kNAQwPCyAKEOY6IAYoAkBFDRAgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQgAhFSAGKAI8IgEgBigCNEcNA0GoxYMBIQIMAgsgASAGKAIoIgdPDRAgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACQQN0aikDAKciAU0NESAHKAIEIAFBA3RqKQMAIRUCQCAGKAJABEAgBigCUCIEQQFqIgdBA3YgB0EHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEJIAYoAkQiCyACSQRAIAogC0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCyABIAtLGxDoGSAGKAJMIQELIAkEQCAGKAJIIAFqQQAgCfwLAAsgBiACNgJMCyAGIAc2AlAgBigCSCAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBiAGKAJUQQFqNgJUCyAGKAI8IgEgBigCNEcNAkG4xYMBIQIMAQsMDQsgBkE0aiACELMoCyAGKAI4IAFBA3RqIBU3AwAgBiABQQFqNgI8IANBCGoiAyAMRw0ACyAGQbABaiIBIAZBNGoiAhDZFCAGQegAaiIDIAEgBigCLCAGKAIwEMcVQdAAQQQQrTYiAUUNDiABQoGAgIAQNwIAIAFBCGogA0HIAPwKAAAgEEHI6oMBNgIIIBAgATYCBCAQQZOAgIB4NgIAIAIQ4zwgBigCQARAIAoQzy8LIAZB3ABqELkMIAZBIGoiARDWKyABQQRBDBDgHiAGQRRqIgEQwicgAUEEQRQQ4B4LIAZBCGpBBEEEEOAeIAZB4AFqJAAgEigCQCEBIBIoAjwhAiASKAI4IgNBk4CAgHhHBEAgACASKQJENwIMIAAgATYCCCAAIAI2AgQgACADNgIADAILIAIgARCaLCEBIABB+MuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwBCyAAIAEgAiADIAQQ/Q8LIBJB0ABqJAAPC0EEQTgQoz0ACyABIAYoAqABQcDkgwEQ/S8ACyACIAYoAqABQfDkgwEQ/S8ACyACIAVB2OWDARDDIQALQQRBxAAQoz0ACyABIAYoAsABQYDugwEQ/S8ACyACIAdB6OiDARDDIQALIAEgBUHY6IMBEMMhAAtByMWDARCyOwALIAEgB0H46IMBEMMhAAsgASAEQYjpgwEQwyEAC0EEQdAAEKM9AAsgAiABKAIcQcjLgwEQ/S8ACyADIAEoAhxByMuDARD9LwALIAcgBSgCHEHIy4MBEP0vAAtB7LSCARCyOwALIAkgD0H8tIIBEMMhAAsgAiAJEP07NgIcDAELIAIgCRD/OzYCHAsgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywAC5YRAQx/IwBBIGsiBiQAIAFB/wFxIQsCQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAkACQAJAIAAoAhwiAigCJCIDQYYCTwRAIAIoAhAhAwwBCyACKAIgIgRBAXQhCCAEQYYCayEJA0ACQCACKAJQIAMgAigCECIFamshAwJAAkACQAJAAkACQAJAAkACQCAJIAIoAiBqIAVNBEAgCCACKAIYIgVLDQEgBEEASA0CIAQEQCACKAIUIgUgBCAFaiAE/AoAAAsgAiACLwEMIgUgBEH//wNxIgdrIgpBACAFIApPGzsBDCAFIAdNBEAgAkEAOwE0CyACIAIoAhAgBGsiBTYCECACIAIoAjwgBGs2AjwgAiAFIAIoAoABIgcgBSAHSRs2AoABIAIQlBYgAyAEaiEDCyAAKAIERQRAIAAoAhwhAgwKCyADQQFNDQIgACAAKAIcIgIoAiQgAigCEGogAxDMEyEDIAAoAhwiAiADIAIoAiRqIgM2AiQgAyACKAKAASIDakEDSQ0IIAIoAhAiByADayEFIAIvATZBgAhNBEAgAyAHRg0IIAVBAWshAyACLQAGQQFGBEAgAiADENkZGgwJCyACKAIYIgcgA0kNBCAHIANrIgdBA00NBSACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgovAQAiDCADQf//A3FGDQggAigCIEEBayADcSIHIAIoAiwiDU8NBiACKAIoIAdBAXRqIAw7AQAgCiADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0H8+fwAEMMhAAsgBUEBaiIHIANJDQYgByADQYz6/AAQwyEACyAIIAVBvPn8ABCwOwALIAZBADYCGCAGQQE2AgwgBkH09fwANgIIIAZCBDcCECAGQQhqQcz5/AAQ7ywACyAGQQA2AhggBkEBNgIMIAZB5Pn8ADYCCCAGQgQ3AhAgBkEIakHs+fwAEO8sAAsgAyAHQZz2/AAQrzsAC0EEIAdBrPb8ABCwOwALIAcgDUG89vwAEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAHai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiRBAUZrIgNFDQACQCACLQAGQQFGBEAgAiAFIAMQ4BMMAQsgAiAFIAMQ6xQLIAIgAigCgAEgA2s2AoABCyAAKAIcIgIoAiQiA0GFAksNACAAKAIEDQELCyACKAIQIgMgAigCUEGGAmtLBEAgBkEANgIYIAZBATYCDCAGQbj6/AA2AgggBkIENwIQIAZBCGpBwPr8ABDvLAALIAIoAiQiBEGGAk8NACALRQRAQQAhAgwFCyAERQRAIAJBAiADIANBAk8bNgKAASABQf8BcUEERwRAIAAoAhwoAkgEQEEAIQIgAEEAEJIBIAAoAhBFDQcLQQEhAgwGCyAAQQEQkgFBA0ECIAAoAhAbIQIMBQsgBEEDSw0AIAIoAhgiBCADSwRAIAIoAhQgA2otAAAhBQwCCyADIARB/PX8ABDDIQALIANBBGohBCADQXtLDQUgBCACKAIYIgVLDQYgAigCFCADaigAACIFQbHz3fF5bEEQdkEBdCIHIAIoAjBqLwEAIgQgA0H//wNxRwRAIAIoAiBBAWsgA3EiCCACKAIsIglPDQggAigCKCAIQQF0aiAEOwEAIAIoAjAgB2ogAzsBACAAKAIcIgIoAhAhAwsgBEUNACADIARrIgNBAEwNACADIAIoAiBBhgJrSg0AIAYgAiAEEJMHIAYoAgAhAyAAKAIcIAYvAQQ7AQwgACgCHCECIANBBEkNACACKAJEIgUgAigCSCIESQ0IIAUgBGsiBUECTQ0JIAIvAQwhCCACKAIQIQcgAigCQCAEaiIFIANBA2siBDoAAiAFIAcgCGsiCEEIdjoAASAFIAg6AAAgAiACKAJIQQNqNgJIIAJB/wEgAi0AOkEBaiIFIAVB/wFPGzoAOiAIQQFrIgUgAigCIEGGAmtPDQogBRDKKkH/AXFBHk8NCiAEQYACTw0LIAIgBEGc9/wAai0AAEECdGpBrAlqIgQgBC8BAEEBajsBACAFEMoqQf8BcSIEQT1PDQwgAiAEQQJ0aiIEIAQvAaQTQQFqOwGkEyACKAJIIQUgAigCRCEIIAAoAhwiAiACKAIkIANrNgIkIAAoAhwiAi8BOCADTwRAIAIoAiRBA0sNAgsgAiACKAIQIANqNgIQIAAoAhwiAigCGCIEIAIoAhBBAWsiA0kNDSAEIANrIgRBA00NDiACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgcvAQAiCSADQf//A3FGDQIgAigCIEEBayADcSIEIAIoAiwiCk8NDyACKAIoIARBAXRqIAk7AQAgByADOwEADAILIAJBQGsgAkGkAWogBRCWIyAAKAIcIgMgAygCJEEBazYCJCAAKAIcIgMgAygCEEEBajYCEEUNA0EAIQIgAEEAEJIBIAAoAhANAwwCCyACIAIoAhBBAWo2AhAgA0EBayECIAAoAhwiAygCECEEAkAgAy0ABkEBRgRAIAMgBCACEOATDAELIAMgBCACEOsUCyAAKAIcIgMgAygCECACajYCEAsgBSAIQQNrRw0BQQAhAiAAQQAQkgEgACgCEA0BCwsgBkEgaiQAIAIPCyADIARBjPb8ABCxOwALIAQgBUGM9vwAELA7AAsgCCAJQbz2/AAQwyEACyAEIAVBzPb8ABCvOwALQQMgBUHc9vwAELA7AAsgBkEANgIYIAZBATYCDCAGQYT3/AA2AgggBkIENwIQIAZBCGpBjPf8ABDvLAALIARBgAJBnPn8ABDDIQALIARBPUGs+fwAEMMhAAsgAyAEQZz2/AAQrzsAC0EEIARBrPb8ABCwOwALIAQgCkG89vwAEMMhAAuJEAIMfwF+QQohBiMAQcABayIFJAAgBSADOgALIAEgAhDkISELIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAasfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgBqwiESARfiIRQiCIpyARpyIGQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiBigCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogBigCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiALQQxqIg8Q2zwQ+R4gBC0ANCEBIA8Q2zwhDgJAIAFFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhBEEAIQICQANAAkACQCAFQQxqAn8CQCALIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQQgCygCECAEaigCACEBIAUgAzYCsAEgBSABNgKYASADBH8gDSABQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQdBiICAgHgFQYeAgIB4CyEBIAAgBzYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAgBUEMahC5LQwJCyAMEOY6IAUoAhhFDQUgBSgCKEEBaiIIQQN2IAhBB3FBAEdqIgYgBSgCJCIBSwRAIAYgAWshCiAFKAIcIgkgBkkEQCAMIAlBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIgkgASAJSxsQ6BkgBSgCJCEBCyAKBEAgBSgCICABakEAIAr8CwALIAUgBjYCJAsgBSAINgIoQQAhASAFKAIUIgYgBSgCDEcNAkH0koABDAELIAEgA20hAQJAIAUoAhgEQCAFKAIoIghBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAiQiB0sEQCAGIAdrIQkgBSgCHCIQIAZJBEAgDCAQQQF0IgcgBkHA////A3FBQGsgBiAGQT9xGyIQIAcgEEsbEOgZIAUoAiQhBwsgCQRAIAUoAiAgB2pBACAJ/AsACyAFIAY2AiQLIAUgCjYCKCAFKAIgIAhBA3ZqIgcgBy0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBiAFKAIMRwRAIAEhBwwCCyABIQdBhJOAAQsQnSgLIAUoAhAgBkECdGogATYCACAFIAZBAWo2AhQgBEEEaiEEIA4gAkEBaiICRw0BDAQLCwwFC0GglYABELI7AAsgDkUNACAFQRhqIQcgBUGgAWohCiADQX9HIQlBACEGQQAhAgJAA0ACQAJAIAsgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NAiALKAIQIAZqKAIAIQQgBSADNgKYASAFIAQ2ApQBIAVBDGoCfwJAIAMEQCAJRSAEQYCAgIB4RnFFBEAgBCADbSEEQQEMAwsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASAKIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiETcDQCARp0GTgICAeEcNASAFKAJEIQRBAQwCCyAFQYeAgIB4NgJACyAFQUBrEIgRQQALIAQQ3wsMAQsgBxDmOiAFKAIYRQ0DIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQggBSgCHCINIARJBEAgByANQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyINIAEgDUsbEOgZIAUoAiQhAQsgCARAIAUoAiAgAWpBACAI/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgEgBSgCDEYEQCAFQQxqQfSSgAEQnSgLIAUoAhAgAUECdGpBADYCACAFIAFBAWo2AhQLIAZBBGohBiAOIAJBAWoiAkcNAQwDCwsMBAtBoJWAARCyOwALIAVB5ABqIgIgBUEMaiIDENAUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+KKAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQcABaiQADwtBBEE4EKM9AAsgBSALEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEgBUHkAGpB5JKAARDvLAAL3xACDH8CfkEKIQYjAEHAAWsiBSQAIAUgAzoACyABIAIQ5CEhASAFIAPAIgI2AkAgBUEKNgKwAQJAAkACQAJAIANB/wFxRQRAQQEhAwwBC0EBIQMDQAJAIAJBAXEEQCADrCAGrH4iEUIgiKcgEaciA0EfdUcNASACQQFGDQMLIAasIhEgEX4iEUIgiKcgEaciBkEfdUcNACACQQF2IQIMAQsLIAVBAjYCECAFQYiYgAE2AgwgBUICNwIYIAVB+g82AnAgBUH8DzYCaCAFIAVB5ABqIgE2AhQgBSAFQUBrIgI2AmwgBSAFQbABajYCZCAFQaABaiIDIAVBDGoiBBCZDiAFKAKgASEGIAVB9ABqIAVBrAFqIggoAgA2AgAgBSAFKQKkATcCbCAFIAY2AmggBUGIgICAeDYCZCAFQQM2AhAgBUGspYABNgIMIAVCAjcCGCAFQfQLNgJMIAVBxA02AkQgBUHcnYABNgJAIAUgAjYCFCAFIAVBC2o2AkggAyAEEJkOIAEQiBEgACAFKQKkATcCCCAAQRBqIAgoAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIADAELIAVBDGogAUEMaiIPENs8EPgeIAQtADQhAiAPENs8IQ4CQCACRQRAIA5FDQEgBUEYaiEMIANBf0chDUEAIQRBACECAkADQAJAAkAgBUEMagJ/AkAgASACEIclRQRAIAUgAjYCsAEgDxDbPCACTQ0EIAEoAhAgBGooAgAhBiAFIAM2ArABIAUgBjYCmAEgAwR/IA0gBkGAgICAeEdyDQIgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqNgJIIAUgBUGYAWo2AkAgBUGgAWogBUHkAGoQmQ4gBUHgAGogBUGsAWooAgA2AgAgBSAFKQKkATcDWCAFKAKgASEIQYiAgIB4BUGHgICAeAshASAAIAg2AgQgACABNgIAIAAgBSkDWDcCCCAAQRBqIAVB4ABqKAIANgIAIAVBDGoQui0MCQsgDBDmOiAFKAIYRQ0FIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIHIAUoAiQiBksEQCAHIAZrIQsgBSgCHCIKIAdJBEAgDCAKQQF0IgYgB0HA////A3FBQGsgByAHQT9xGyIKIAYgCksbEOgZIAUoAiQhBgsgCwRAIAUoAiAgBmpBACAL/AsACyAFIAc2AiQLIAUgCTYCKEIAIREgBSgCFCIGIAUoAgxHDQJB9JKAAQwBCyAGIANtIQgCQCAFKAIYBEAgBSgCKCIJQQFqIgtBA3YgC0EHcUEAR2oiByAFKAIkIgZLBEAgByAGayEKIAUoAhwiECAHSQRAIAwgEEEBdCIGIAdBwP///wNxQUBrIAcgB0E/cRsiECAGIBBLGxDoGSAFKAIkIQYLIAoEQCAFKAIgIAZqQQAgCvwLAAsgBSAHNgIkCyAFIAs2AiggBSgCICAJQQN2aiIGIAYtAABBASAJQQdxdHI6AAAMAQsgBSAFKAIsQQFqNgIsCyAIrCERIAUoAhQiBiAFKAIMRw0BQYSTgAELELMoCyAFKAIQIAZBA3RqIBE3AwAgBSAGQQFqNgIUIARBBGohBCAOIAJBAWoiAkcNAQwECwsgBSABEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEMBQtBoJWAARCyOwALIA5FDQAgBUEYaiEHIAVBoAFqIQsgA0F/RyEKQQAhBkEAIQIDQAJAIAVBDGoCfgJAAkACQCABIAIQhyVFBEAgBSACNgKYASAPENs8IAJNDQEgASgCECAGaigCACEEIAUgAzYCmAEgBSAENgKUAQJAIAMEQCAKRSAEQYCAgIB4RnFFBEAgBCADbSEEDAYLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCyAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEDAULIAVBh4CAgHg2AkALIAVBQGsQiBFCAAwECyAHEOY6IAUoAhhFDQEgBSgCKEEBaiIMQQN2IAxBB3FBAEdqIgQgBSgCJCIISwRAIAQgCGshCSAFKAIcIg0gBEkEQCAHIA1BAXQiCCAEQcD///8DcUFAayAEIARBP3EbIg0gCCANSxsQ6BkgBSgCJCEICyAJBEAgBSgCICAIakEAIAn8CwALIAUgBDYCJAsgBSAMNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCzKAsgBSgCECAEQQN0akIANwMAIAUgBEEBajYCFAwECyAFIAEQ/Ds2ArABIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUGwAWo2AqQBIAUgBUGYAWo2ApwBDAgLQaCVgAEQsjsACyAErCESQgELIBIQ2gsLIAZBBGohBiAOIAJBAWoiAkcNAAsLIAVB5ABqIgIgBUEMaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQcABaiQADwtBBEE4EKM9AAsgBUHkAGpB5JKAARDvLAALrhYDBn8DfgF8IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEH85s4ANgI4IARCATcCRCAEQYkINgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARCTEiAELQA8IQUgBCgCOCICQQRHBEAgBEE/ai0AACEDIAQvAD0hBiAEKQJEIQogAEELaiAEKAJAIgFBGHY6AAAgACABQQh2OwAJIAAgCjcCDCAAIAE6AAggACACNgIAIAAgA0EYdCAGQQh0ciAFcjYCBAwMCyAEKAJAIgJBAEoEQCADQQFrIQMDQCAEQThqIAEgBSADELMCIAQoAjgiBkEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBjYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqIAEQkxIgBC0APCEFIAQoAjgiAkEERwRAIARBP2otAAAhAyAELwA9IQYgBCkCRCEKIABBC2ogBCgCQCIBQRh2OgAAIAAgAUEIdjsACSAAIAo3AgwgACABOgAIIAAgAjYCACAAIANBGHQgBkEIdHIgBXI2AgQMCwsgBCgCQCICQQBKBEAgA0EBayEDA0AgBEE4aiABIAUgAxCzAiAEKAI4IgZBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAY2AgAMDQsgAkEBayICDQALCyAAQQQ2AgAMCgsgBEE4aiEFIwBBIGsiAiQAIAJBCGogAUEMahD/EwJAAkACfyACLQAIQQRGBEAgAigCDAwBCyACKQMIIgpC/wGDQgRSDQEgCkIgiKcLIglFBEAgBUEEakEQQRBBABD1NCAFQQQ2AgAMAgsgAkEIaiABEJsTIAItAAwhBiACKAIIIgdBBEcEQCAFIAIpAA03AAUgBUEMaiACQRRqKQAANwAAIAUgBjoABCAFIAc2AgAMAgsgAkEIaiAGQfABcUEEdhCuLSACLQAMIQcgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAc6AAQgBSAINgIADAILIAJBCGogBkEPcRCuLSACLQAMIQYgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAY6AAQgBSAINgIADAILIAVBBGogByAGIAkQ9TQgBUEENgIADAELIAIgCjcDCCAFIAJBCGoQ0AkLIAJBIGokACAEKQI8IQogBCgCOCICQQRHBEAgACAEKQJENwIMIAAgCjcCBCAAIAI2AgAMCgsCQAJAIAqnIgJBAEoEQCAKQiCIpyIFQf8BcUEQRg0CIApCKIinIgZB/wFxQRBGDQEgA0EBayEDA0AgBEE4aiABIAUgAxCzAiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgBEE4aiABIAYgAxCzAiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgAkEBayICDQALCyAAQQQ2AgAMCwtBwOfOAEEsQeznzgAQyyQAC0GE584AQSpBsOfOABDLJAALIARBOGogARDxJyAEQShqIgIgBEHEAGoiBSgCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgNwMIIARBCGoQhjAgBEE4aiABELIOIAIgBSkCADcDACAEQTBqIgIgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQYgBEE8aiEDA0AgBEEYaiACKAIAIgU2AgAgBEEQaiAEQShqIgcpAwA3AwAgBCAEKQMgNwMIIAVB/wFxRQ0CIARBOGogASAFIAYQswIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIAIARBCGoQhjAMDAsgBEEIahCGMCAEQThqIAEQsg4gByADQQhqKQIANwMAIAIgA0EQaigCADYCACAEIAMpAgA3AyAgBCgCOEUNAAsLIAAgBCkDIDcCACAAQRBqIAIoAgA2AgAgAEEIaiAEQShqKQMANwIADAkLIARBCGoQhjAgACABEKopDAgLIARBOGohBiMAQSBrIgUkACAFQQxqIAEQ6Q8gBSgCGCECIAUoAhQhASAFKAIQIQMCQCAFKAIMIgdBBEcEQCAGIAUoAhw2AhAgBiACNgIMIAYgATYCCCAGIAM2AgQgBiAHNgIADAELIAVBDGogASACEJ0JAkACQCAFKAIMRQRAIAKtIQogASECDAELIAUpAhAhCiADQYCAgIB4Rw0BIAEhAwsgBiAKPgIMIAYgAjYCCCAGIAM2AgQgBkEENgIADAELIAUgCjcCGCAFIAI2AhQgBSABNgIQIAUgAzYCDCAGIAVBDGoQyBwLIAVBIGokACAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAgLIARBKGogBEHEAGooAgA2AgAgBCAEKQI8NwMgIARBIGoQ3jsgAEEENgIADAcLIARBOGogARCRIyAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwHCyAAQQQ2AgAMBgsgBEE4aiABEIkmIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMBgsgAEEENgIADAULIARBOGogARCGJiAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAULIABBBDYCAAwECyAEQThqIQMjAEEQayICJAAgASgCDCIBKAIEIgetIQoCQAJAIAdC/////w8gASkDCCILIAtC/////w9aG6drIgVBACAFIAdNG0EITwRAIAEoAgAgCyAKIAogC1Ybp2orAAAhDUEEIQcMAQtBqKHQACkCACIMpyIHQQh2IQYgDEIgiKchBSAMQv8Bg0IEUg0BCyALQgh8IQoLIAEgCjcDCCADAn8gB0H/AXEiAUEERwRAIAIgBTYCDCACIAZBCHQgAXI2AgggA0EEaiACQQhqENAJQQEMAQsgAyANOQMIQQALNgIAIAJBEGokACAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwECyAAQQQ2AgAMAwsgBEE4aiABEJsTIAQoAjgiAUEERwRAIAAgBCkAPTcABSAAQQxqIARBxABqKQAANwAAIAAgBC0APDoABAsgACABNgIADAILIARBOGogARDrEyAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAILIABBBDYCAAwBCyAEIAI6ADcgBEEBNgI8IARBlOjOADYCOCAEQgE3AkQgBEG6BzYCJCAEIARBIGo2AkAgBCAEQQhqNgIgIAQgBEE3ajYCCCAAQQRqIARBOGoQmQ4gAEEAOgAQIABBATYCAAsgBEHQAGokAAvCFQIGfwF+IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEH85s4ANgI4IARCATcCRCAEQYkINgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARCSEiAELQA8IQUgBCgCOCICQQRHBEAgBEE/ai0AACEDIAQvAD0hBiAEKQJEIQogAEELaiAEKAJAIgFBGHY6AAAgACABQQh2OwAJIAAgCjcCDCAAIAE6AAggACACNgIAIAAgA0EYdCAGQQh0ciAFcjYCBAwMCyAEKAJAIgJBAEoEQCADQQFrIQMDQCAEQThqIAEgBSADELQCIAQoAjgiBkEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBjYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqIAEQkhIgBC0APCEFIAQoAjgiAkEERwRAIARBP2otAAAhAyAELwA9IQYgBCkCRCEKIABBC2ogBCgCQCIBQRh2OgAAIAAgAUEIdjsACSAAIAo3AgwgACABOgAIIAAgAjYCACAAIANBGHQgBkEIdHIgBXI2AgQMCwsgBCgCQCICQQBKBEAgA0EBayEDA0AgBEE4aiABIAUgAxC0AiAEKAI4IgZBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAY2AgAMDQsgAkEBayICDQALCyAAQQQ2AgAMCgsgBEE4aiEFIwBBIGsiAiQAIAJBCGogAUEMahCNFAJAAkACfyACLQAIQQRGBEAgAigCDAwBCyACKQMIIgpC/wGDQgRSDQEgCkIgiKcLIglFBEAgBUEEakEQQRBBABD1NCAFQQQ2AgAMAgsgAkEIaiABEMQZIAItAAwhBiACKAIIIgdBBEcEQCAFIAIpAA03AAUgBUEMaiACQRRqKQAANwAAIAUgBjoABCAFIAc2AgAMAgsgAkEIaiAGQfABcUEEdhCuLSACLQAMIQcgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAc6AAQgBSAINgIADAILIAJBCGogBkEPcRCuLSACLQAMIQYgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAY6AAQgBSAINgIADAILIAVBBGogByAGIAkQ9TQgBUEENgIADAELIAIgCjcDCCAFIAJBCGoQ0AkLIAJBIGokACAEKQI8IQogBCgCOCICQQRHBEAgACAEKQJENwIMIAAgCjcCBCAAIAI2AgAMCgsCQAJAIAqnIgJBAEoEQCAKQiCIpyIFQf8BcUEQRg0CIApCKIinIgZB/wFxQRBGDQEgA0EBayEDA0AgBEE4aiABIAUgAxC0AiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgBEE4aiABIAYgAxC0AiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgAkEBayICDQALCyAAQQQ2AgAMCwtBwOfOAEEsQeznzgAQyyQAC0GE584AQSpBsOfOABDLJAALIARBOGogARDxJyAEQShqIgIgBEHEAGoiBSgCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgNwMIIARBCGoQhjAgBEE4aiABELMOIAIgBSkCADcDACAEQTBqIgIgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQYgBEE8aiEDA0AgBEEYaiACKAIAIgU2AgAgBEEQaiAEQShqIgcpAwA3AwAgBCAEKQMgNwMIIAVB/wFxRQ0CIARBOGogASAFIAYQtAIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIAIARBCGoQhjAMDAsgBEEIahCGMCAEQThqIAEQsw4gByADQQhqKQIANwMAIAIgA0EQaigCADYCACAEIAMpAgA3AyAgBCgCOEUNAAsLIAAgBCkDIDcCACAAQRBqIAIoAgA2AgAgAEEIaiAEQShqKQMANwIADAkLIARBCGoQhjAgACABEKopDAgLIARBOGohBiMAQSBrIgUkACAFQQxqIAEQ6A8gBSgCGCECIAUoAhQhASAFKAIQIQMCQCAFKAIMIgdBBEcEQCAGIAUoAhw2AhAgBiACNgIMIAYgATYCCCAGIAM2AgQgBiAHNgIADAELIAVBDGogASACEJ0JAkACQCAFKAIMRQRAIAKtIQogASECDAELIAUpAhAhCiADQYCAgIB4Rw0BIAEhAwsgBiAKPgIMIAYgAjYCCCAGIAM2AgQgBkEENgIADAELIAUgCjcCGCAFIAI2AhQgBSABNgIQIAUgAzYCDCAGIAVBDGoQyBwLIAVBIGokACAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAgLIARBKGogBEHEAGooAgA2AgAgBCAEKQI8NwMgIARBIGoQ3jsgAEEENgIADAcLIARBOGogARCSIyAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwHCyAAQQQ2AgAMBgsgBEE4aiABEIgmIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMBgsgAEEENgIADAULIARBOGogARCHJiAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAULIABBBDYCAAwECyMAQRBrIgIkACACQgA3AwAgAkEIaiIDIAEoAgwgAkEIEJshIARBOGoiAQJ/AkAgAi0ACEEERg0AIAIxAAhCBFENACACKAIIIQUgAiACKAIMNgIMIAIgBTYCCCABQQRqIAMQ0AlBAQwBCyABIAIrAwA5AwhBAAs2AgAgAkEQaiQAIAQoAjhBAUYEQCAAIAQpAjw3AgAgAEEQaiAEQcwAaigCADYCACAAQQhqIARBxABqKQIANwIADAQLIABBBDYCAAwDCyAEQThqIAEQxBkgBCgCOCIBQQRHBEAgACAEKQA9NwAFIABBDGogBEHEAGopAAA3AAAgACAELQA8OgAECyAAIAE2AgAMAgsgBEE4aiABEOwTIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMAgsgAEEENgIADAELIAQgAjoANyAEQQE2AjwgBEGU6M4ANgI4IARCATcCRCAEQboHNgIkIAQgBEEgajYCQCAEIARBCGo2AiAgBCAEQTdqNgIIIABBBGogBEE4ahCZDiAAQQA6ABAgAEEBNgIACyAEQdAAaiQAC9cVAgh/BH4jAEGAA2siBSQAIAUgAzoAIyAFIAI6ACIgBSABNgIcAkACQAJAAkACQAJAIAQtADRFBEAgBUHwAWoiAiAFQRxqEPopIAUgBUEiajYCmAIgBSAFQSNqNgKUAiAFQcwCaiEIIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASACQSz8CgAAIAMgAzYCTCADQRRqIQojAEHwAGsiAiQAIAJBEGoiCSABEOwUAkACQAJAIAIpAxggAikDEEIChYRQRQRAIAJBQGsiBCABEKMqIARBBCACKAJAQQFqIgZBfyAGGyIGIAZBBE0bQQBBEEEwEKAYIAIoAkQhBiACKAJAQQFGDQIgAigCSCIHIAlBMPwKAAAgAkEMaiILQQE2AgAgAiAHNgIIIAIgBjYCBCAEIAFBMPwKAAAjAEFAaiIBJAAgASAEEOwUIAEpAwggASkDAEIChYRQRQRAIAJBBGohBgNAAkAgBigCCCIJIAYoAgBHDQAgAUE0aiAEEKMqIAEoAjRBAWoiB0F/IAcbIgcgBigCACAGKAIIIgxrTQ0AIAYgDCAHQRBBMBDeKAsgBigCBCAJQTBsaiABQTD8CgAAIAYgCUEBajYCCCABIAQQ7BQgASkDCCABKQMAQgKFhFBFDQALCwJAIAQoAgQiBkUNACAGIAYoAgAiBkEBazYCACAGQQFHDQAgBEEEahD7HgsgAUFAayQAIApBCGogCygCADYCACAKIAIpAgQ3AgAMAQsgCkEANgIIIApCgICAgIACNwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHwAGokAAwBCyAGIAIoAkhBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAIIAMpAgA3AgAgCEEQaiADQRBqKAIANgIAIAhBCGogA0EIaikCADcCACAKEOQ8DAELIAggAykCFDcCBCAIQZOAgIB4NgIAIAhBDGogA0EcaigCADYCAAsgA0HQAGokACAFQegAaiIBIAVB2AJqKAIANgIAIAUgBSkC0AI3A2AgBSgCzAIiAkGTgICAeEYNASAFKALcAiEDIAAgBSkDYDcCCCAAIAM2AhQgACACNgIEIABBKToAACAAQRBqIAEoAgA2AgAMAwsgBUEkaiICIAVBHGoQ+ikgBUGUAWoiASACQST8CgAAIAUgBUEiajYCvAEgBSAFQSNqNgK4ASABEJA7GiAFKAKwASEIIAEQkDshCiAFQcABaiICIAFBLPwKAAAgAhCQOxogBSgC3AEhASAFIAIQkDsgAWsiATYCuAIgBUG8AmpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEFdCIGIQQCQCAGQSBxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhASAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIBRQ0BCyAFKALEAiEJIAVBzAJqIAVBwAFqQSz8CgAAIAVBADYC+AIgASEDIAUoAugCIgIgBSgC7AJGDQQgBUHwAWpBBHIhBwNAAkACQAJAAkACQCAFKALQAkUNACACIAUoAuACTw0CIAUoAtQCIAUoAtwCIAJqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcUUNACAFIAJBAWo2AugCDAELIAUgAkEBajYC6AIgBUEQaiAFQcwCaiACEK0qIAVB8AFqIAUoAhAgBSgCFCAFKALwAiwAABDWASAFKALwASICQQFGBEAgAkUNASAHEIgRDAELIAUpA4ACIg0gBSkDiAIiDiAFKQOQAiIPIAUpA5gCIhAgBSgC9AItAAAQ3B0NAgsgBSAFKAL4AkEBajYC+AIgA0EYakIANwMAIANBEGpCADcDACADQQhqQgA3AwAgA0IANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBSAFKAL4AiICQQFqNgL4AiADQRhqIBA3AwAgA0EQaiAPNwMAIAMgDjcDCCADIA03AwAgCSACQQN2aiILIAstAABBASACQQdxdHI6AAALIANBIGohAyAFKALoAiICIAUoAuwCRw0ACwwEC0HAACAEEKM9AAtB5JSAAUEpIAVB8AFqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAsgBUHIAWogASgCACIBNgIAIAUgBSkDYDcDwAEgBUHwAWoiAiAFKALEASIDIAMgAUEwbGoQzwggBUHMAmogAiAFLQAiIAUtACMQoxMgBS0AzAIiAUEpRgRAIAVB8wBqIAVB4AJqKAIAIgE2AAAgBUHrAGogBUHYAmopAgAiDTcAACAFIAUpAtACIg43AGMgAEEUaiABNgAAIABBDGogDTcAACAAIA43AAQgAEEpOgAAIAVBwAFqEOQ8DAILIAAgBSkC5AI3AhggBUHvAGoiAiAFQdwCaikAADcAACAFQegAaiIDIAVB1QJqKQAANwMAIABBIGogBUHsAmopAgA3AgAgAEEoaiAFQfQCaikCADcCACAFIAUpAM0CIg03A2AgAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA03AAEgACABOgAAIAVBwAFqEOQ8DAELAkAgBSgC0AIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgBUHQAmoQ+x4LIAUgAyABa0EFdSICNgL8AiACIAUoArgCRw0BIAUoAsQCIQIgBSgCyAIhAyAFIAUpArwCNwL8ASAFQQA2AvgBIAUgAzYC9AEgBSACNgLwASAFQQhqIAVB8AFqIgkQ1zsgBSgCCCEHQRxBBBCtNiICRQ0CIAJCgYCAgBA3AgAgAiAFKQLwATcCCCACQRBqIAVB+AFqIgspAgA3AgAgAkEYaiAFQYACaiIMKAIANgIAIAUgBDYCgAIgBUKAgICAgAg3AvgBIAUgBjYC9AEgBSABNgLwASAFIAkQ1zsgBSgCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASAFKQLwATcCCCABQRBqIAspAgA3AgAgAUEYaiAMKAIANgIAIAUgAzYCxAIgBSAHNgLAAiAFIAI2ArwCQQxBBBCtNiICRQ0DIAIgBjYCCCACIAQ2AgQgAiABNgIAIAVBATYCyAEgBSACNgLEASAFQQE2AsABIAVBADYC1AIgBUKAgICAwAA3AswCIAVB8AFqIgJB6JGAASAKIAhrIAUgBUG8AmogBUHAAWogBUHMAmoiARCMEyABIAIQxRMgBUHgAGogASAFLQAiIAUtACMQoxMgBS0AYCIBQSlGBEAgBUHbAGogBUH0AGooAgAiATYAACAFQdMAaiAFQewAaikCACINNwAAIAUgBSkCZCIONwBLIABBFGogATYAACAAQQxqIA03AAAgACAONwAEIABBKToAAAwBCyAAIAUpAng3AhggBUHXAGoiAiAFQfAAaikAADcAACAFQdAAaiIDIAVB6QBqKQAANwMAIABBIGogBUGAAWopAgA3AgAgAEEoaiAFQYgBaikCADcCACAFIAUpAGEiDTcDSCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAALIAVBgANqJAAPCyAFQgA3AvwBIAVCgYCAgMAANwL0ASAFQcSRgAE2AvABQQAgBUH8AmogBUG4AmogBUHwAWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALuhgCDn8BfiMAQeACayICJAACQAJAAkACQAJAAkACQAJAAkACQCABKAIIIgMEQCACQfABaiEJIAEoAgQhCCMAQTBrIgQkACAEQQg2AgAgBCAIIANBA3RqNgIoIAQgCDYCJCAEIAQ2AiwgBEEYaiEHIwBBMGsiAyQAIANBCGogBEEkaiIFEPMnAkACQAJAIAMoAggiCwRAIAMoAgwhDSADQSBqIgpBBEEAQQRBCBCgGCADKAIkIQYgAygCIEEBRg0CIAMoAigiDCANNgIEIAwgCzYCACADQRxqIg5BATYCACADIAw2AhggAyAGNgIUIANBKGogBUEIaigCADYCACADIAUpAgA3AyAjAEEQayIFJAAgBUEIaiAKEPMnIAUoAggiDARAIANBFGohBiAFKAIMIQsDQCAGKAIIIg0gBigCAEYEQCAGQQEQ6i0LIAYoAgQgDUEDdGoiDyALNgIEIA8gDDYCACAGIA1BAWo2AgggBSAKEPMnIAUoAgQhCyAFKAIAIgwNAAsLIAVBEGokACAHQQhqIA4oAgA2AgAgByADKQIUNwIADAELIAdBADYCCCAHQoCAgIDAADcCAAsgA0EwaiQADAELIAYgAygCKEHIl88AEP0vAAsCQCAEKAIAQQhHBEAgCSAEKQMANwMAIAlBEGogBEEQaikDADcDACAJQQhqIARBCGopAwA3AwAgBxDDJyAHEOo7DAELIAkgBCkCGDcCBCAJQQg2AgAgCUEMaiAEQSBqKAIANgIACyAEQTBqJAAgAkEwaiIDIAJB/AFqKAIANgIAIAIgAikC9AE3AyggAigC8AEiBEEIRg0BIAIpA4ACIRAgACACKQMoNwIEIAAgEDcDECAAIAQ2AgAgAEEMaiADKAIANgIADAkLIAJBADYCMCACQoCAgIDAADcCKCMAQfAAayIBJAAgASACQShqIgMoAgA2AlAgASADKAIEIgQ2AkggASAENgJMIAEgBCADKAIIQQxsajYCVCABQegAaiIDQgQ3AgAgAUHgAGoiBEIANwIAIAFCgICAgMAANwJYIAFByABqIAFB2ABqIgUgAUHkAGoQ+h4gAUFAayADKQIANwMAIAFBOGogBCkCACIQNwMAIAFBGGogED4CACABQShqIAFBxABqKAIANgIAIAEgASkCWCIQNwMwIAEgEDcDECABIAEpAjw3AyAgAUEIaiABQRBqELYZIAEoAgwhAyABKAIIIQQgAUEANgJYIAJB8AFqIgkgBCADIAFBIGogBRDLHCABQfAAaiQAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAJQTT8CgAAIABB+NbQADYCCCAAIAE2AgQgAEEINgIADAgLIAJBIGogAygCACIDNgIAIAIgAikDKDcDGCADRQRAIAJB8AFqQTNBAEEBQQEQoBggAigC9AEhASACKALwAUEBRg0JIAIoAvgBIgNB/NfQAEEz/AoAACAAQTM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMBwsgA0EDdCEEIAIoAhwiAxD0LSEJAkADQCAERQ0BIARBCGshBCADEPQtIANBCGohAyAJRg0ACyACQfABakErQQBBAUEBEKAYIAIoAvQBIQEgAigC8AFBAUYNCSACKAL4ASIDQfTV0ABBK/wKAAAgAEErNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAcLIAJBkAJqIAFBDGoQxAYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACIAk2ApwCIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACKAIcIgMgAigCIEEDdGohCiMAQSBrIgUkACAFQRRqIAogA2tBA3ZBAEEEQcQAEKAYIAUoAhghBCAFKAIUQQFGBEAgBCAFKAIcQfyh0AAQ/S8ACyACQcwCaiEMIAVBEGoiDkEANgIAIAUgBSgCHDYCDCAFIAQ2AggjAEEQayIGJAAgBUEIaiIHIAogA2tBA3YiBBD+LSAGIAcpAgRCIIk3AgggBiAHQQhqNgIEIwBB0ABrIgskACAGQQRqIg0oAgQhByANKAIAIAMgCkcEQCANKAIIIAdBxABsaiEKIAQgB2ohBwNAIAtBDGoiDSADEMMtIAogDUHEAPwKAAAgCkHEAGohCiADQQhqIQMgBEEBayIEDQALCyAHNgIAIAtB0ABqJAAgBkEQaiQAIAxBCGogDigCADYCACAMIAUpAgg3AgAgBUEgaiQAIAJBKGogAkHwAWogDBD8IiABLQAcRQ0FIAJBEGogCCgCACAIKAIEKAIgEQAAIAIoAhAiBEUNASACKAIUIQVBwAAhBiAJQQN2IAlBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0ECyACQgA3ApABIAIgBjYCjAEgAiADNgKIASACQcAANgKEASACQQhqIAgoAgAgCCgCBCgCJBEAAAJAIAIoAggiAwRAIAIoAgwhCCACIAU2ApwBIAIgCDYCmAEgBSAIRg0BIAJBADYC8AFBACACQZgBaiACQZwBaiACQfABakHo1tAAEK8rAAsgBUUNBSAFQQF0IQUgAS4BGCEKA0AgBC4BACEMIAIoApQBIghBAWoiBkEDdiAGQQdxQQBHaiIBIAIoApABIgNLBEAgASADayEHIAIoAogBIgsgAUkEQCACQYQBaiALQQF0IgMgAUHA////A3FBQGsgASABQT9xGyILIAMgC0sbEOgZIAIoApABIQMLIAcEQCACKAKMASADakEAIAf8CwALIAIgATYCkAELIAIgBjYClAEgCiAMTARAIAIoAowBIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAsgBEECaiEEIAVBAmsiBQ0ACwwFCyAFRQ0EIAEuARghDCABLgEaIQsDQAJAIAMuAQAgC0oNACAELgEAIQ0gAigClAEiBkEBaiIHQQN2IAdBB3FBAEdqIgEgAigCkAEiCEsEQCABIAhrIQogAigCiAEiDiABSQRAIAJBhAFqIA5BAXQiCCABQcD///8DcUFAayABIAFBP3EbIg4gCCAOSxsQ6BkgAigCkAEhCAsgCgRAIAIoAowBIAhqQQAgCvwLAAsgAiABNgKQAQsgAiAHNgKUASAMIA1KDQAgAigCjAEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAACyADQQJqIQMgBEECaiEEIAVBAWsiBQ0ACwwEC0EEQTwQoz0AC0Gf1tAAQTZB2NbQABDLJAALQZSf0ABBKSACQfABakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAsCQAJAIAkgAigClAFGBEAgAkHwAWoiBCACQShqIgVB3AD8CgAAIAIoAowBIQEgAigCkAEhAyACIAIpAoQBNwLYAiACQQA2AtQCIAIgAzYC0AIgAiABNgLMAiACIAJBzAJqENc7IAIoAgAhCUEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCzAI3AgggAUEQaiACQdQCaikCADcCACABQRhqIAJB3AJqKAIANgIAIAIgAzYCqAEgAiAJNgKkASACIAE2AqABIAUgBCACQaABahCuFgwDCyACQfABakEsQQBBAUEBEKAYIAIoAvQBIQEgAigC8AFBAUYNASACKAL4ASIDQdDX0ABBLPwKAAAgAEEsNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIAIAJBhAFqEM8vIAJByABqEJ8MAkAgAigCWCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQdgAahD7HgsCQCACKAJkIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJB5ABqEPseCyACQTBqIgAQxScgABDoOyACQTxqIgAQpCwgABD1PAwDC0EEQRwQoz0ACwwDCyACQfABaiIBIAJBKGpB3AD8CgAAIAJBrAFqIgMgARDNHCABIAMQhhdBPEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAUE0/AoAACAAQfjW0AA2AgggACADNgIEIABBCDYCACACQRhqIgAQwycgABDqOwwCC0EEQTwQoz0ACyACQRhqIgAQwycgABDqOwsgAkHgAmokAA8LIAEgAigC+AFBpMbQABD9LwALvhUCCH8CfiMAQfACayIFJAAgBSADOgAjIAUgAjoAIiAFIAE2AhwCQAJAAkACQAJAAkACQAJAAkACQCAELQA0RQRAIAVB8AFqIgIgBUEcahD6KSAFIAVBImo2ApgCIAUgBUEjajYClAIgBUGQAWohBiMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQRBqIgcgARCwJAJAAkACQCACKQMQIg1CAlIEQCACKQMYIQ4gAkHEAGoiBCABEKMqIARBBCACKAJEQQFqIgRBfyAEGyIEIARBBE0bQQBBCEEQEKAYIAIoAkghBCACKAJEQQFGDQIgAigCTCIKIA43AwggCiANNwMAIAJBDGoiC0EBNgIAIAIgCjYCCCACIAQ2AgQgByABQTD8CgAAIwBBIGsiASQAIAEgBxCwJCABKQMAIg1CAlIEQCACQQRqIQQDQCABKQMIIQ4CQCAEKAIIIgogBCgCAEcNACABQRRqIAcQoyogASgCFEEBaiIJQX8gCRsiCSAEKAIAIAQoAggiDGtNDQAgBCAMIAlBCEEQEN4oCyAEKAIEIApBBHRqIgkgDjcDCCAJIA03AwAgBCAKQQFqNgIIIAEgBxCwJCABKQMAIg1CAlINAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQSBqJAAgCEEIaiALKAIANgIAIAggAikCBDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAQgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAYgAykCADcCACAGQRBqIANBEGooAgA2AgAgBkEIaiADQQhqKQIANwIAIAgQ7TsMAQsgBiADKQIUNwIEIAZBk4CAgHg2AgAgBkEMaiADQRxqKAIANgIACyADQdAAaiQAIAVB6ABqIgEgBUGcAWooAgA2AgAgBSAFKQKUATcDYCAFKAKQASICQZOAgIB4Rg0BIAUoAqABIQMgACAFKQNgNwIIIAAgAzYCFCAAIAI2AgQgAEEpOgAAIABBEGogASgCADYCAAwDCyAFQSRqIgIgBUEcahD6KSAFQcABaiIBIAJBJPwKAAAgBSAFQSJqNgLoASAFIAVBI2o2AuQBIAEQkDsaIAUoAtwBIQMgARCQOyEEIAVBkAFqIgIgAUEs/AoAACACEJA7GiAFKAKsASEBIAUgAhCQOyABayIBNgK0AiAFQbgCakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQN0IgIhASACQThxIgYEQCACIAZrQUBrIgEgAkkNBAtBwAAhByABQcAAENE0RQ0EIAEEQCABQcAAEK02IgdFDQYLIAUoAsACIQggBUHwAWogBUGQAWpBLPwKAAAgBCADayEKQQAhAyAFQQA2ApwCIAVB2AJqQQRyIQsgBUH0AWohCQNAIAVB0AJqIQxCAiENIAUoAowCIgYgBSgCkAJHBH8gBQJ+AkACQAJAIAUoAvQBRQ0AIAYgBSgChAJPDQwgBSgC+AEgBSgCgAIgBmoiBEEDdmotAABB/wFzIARBB3F2QQFxRQ0AIAUgBkEBajYCjAIMAQsgBSAGQQFqNgKMAiAFQRBqIAVB8AFqIAYQrSogBUHYAmogBSgCECAFKAIUIAUoApQCLAAAEMIBIAUoAtgCIgRBAUcNASAERQ0AIAsQiBELQgAMAQsgBSkD4AIiDSAFKAKYAi0AABDFKa0LNwPQAiAFIAUoApwCIgRBAWo2ApwCIAVByAJqBSAMCyANNwMAAkACQAJAIAUpA9ACIg1CAlIEQCADIAdqIQYgDadBAXFFDQEgBiAFKQPIAjcDACAIIARBA3ZqIgYgBi0AAEEBIARBB3F0cjoAAAwCCwJAIAUoAvQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAkQ+x4LIAUgA0EDdSIDNgLYAiADIAUoArQCRw0LIAUoAsACIQMgBSgCxAIhBCAFIAUpArgCNwL8ASAFQQA2AvgBIAUgBDYC9AEgBSADNgLwASAFQQhqIAVB8AFqIgYQ1zsgBSgCCCEIQRxBBBCtNiIDRQ0MIANCgYCAgBA3AgAgAyAFKQLwATcCCCADQRBqIAVB+AFqIgspAgA3AgAgA0EYaiAFQYACaiIJKAIANgIAIAUgATYCgAIgBUKAgICAgAg3AvgBIAUgAjYC9AEgBSAHNgLwASAFIAYQ1zsgBSgCACEGQRxBBBCtNiIBDQJBBEEcEKM9AAsgBkIANwMACyADQQhqIQMMAQsLIAFCgYCAgBA3AgAgASAFKQLwATcCCCABQRBqIAspAgA3AgAgAUEYaiAJKAIANgIAIAUgBDYCwAIgBSAINgK8AiAFIAM2ArgCQQxBBBCtNiIDRQ0JIAMgAjYCCCADIAY2AgQgAyABNgIAIAVBATYC4AIgBSADNgLcAiAFQQE2AtgCIAVBADYCmAEgBUKAgICAwAA3ApABIAVB8AFqIgJB3JGAASAKIAUgBUG4AmogBUHYAmogBUGQAWoiARCMEyABIAIQtxMgBUHgAGogASAFLQAiIAUtACMQohMgBS0AYCIBQSlHDQEgBUHbAGogBUH0AGooAgAiATYAACAFQdMAaiAFQewAaikCACINNwAAIAUgBSkCZCIONwBLIABBFGogATYAACAAQQxqIA03AAAgACAONwAEIABBKToAAAwCCyAFQcgBaiABKAIAIgE2AgAgBSAFKQNgNwPAASAFQfABaiICIAUoAsQBIgMgAyABQQR0ahCDCSAFQZABaiACIAUtACIgBS0AIxCiEyAFLQCQASIBQSlGBEAgBUHzAGogBUGkAWooAgAiATYAACAFQesAaiAFQZwBaikCACINNwAAIAUgBSkClAEiDjcAYyAAQRRqIAE2AAAgAEEMaiANNwAAIAAgDjcABCAAQSk6AAAgBUHAAWoQ7TsMAgsgACAFKQKoATcCGCAFQe8AaiICIAVBoAFqKQAANwAAIAVB6ABqIgMgBUGZAWopAAA3AwAgAEEgaiAFQbABaikCADcCACAAQShqIAVBuAFqKQIANwIAIAUgBSkAkQEiDTcDYCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAAgBUHAAWoQ7TsMAQsgACAFKQJ4NwIYIAVB1wBqIgIgBUHwAGopAAA3AAAgBUHQAGoiAyAFQekAaikAADcDACAAQSBqIAVBgAFqKQIANwIAIABBKGogBUGIAWopAgA3AgAgBSAFKQBhIg03A0ggAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA03AAEgACABOgAACyAFQfACaiQADwtBlJOAAUEjQbiTgAEQyyQAC0HklIABQSkgBUHwAWpByJeAAUGQlYABENUeAAtBwAAgARCjPQALQbSUgAFBIEHUlIABEJ8pAAsgBUIANwL8ASAFQoGAgIDAADcC9AEgBUHEkYABNgLwAUEAIAVB2AJqIAVBtAJqIAVB8AFqQcyRgAEQrysAC0EEQRwQoz0AC0EEQQwQoz0AC9cQAg9/AX4jAEHABGsiAyQAIAEoAhghDiABKAIcIQcgA0GoAmogAkEMaiINENg8QQBBBEEEEKAYIAMoAqwCIQQgAygCqAJBAUcEQCADQQA2ApgEIAMgAygCsAIiBTYClAQgAyAENgKQBCADQQA2AqQEIANCgICAgMAANwKcBCAEBH8gBQUgA0GQBGpB8K+CARCdKCADKAKUBAtBADYCACADQQE2ApgEQcAAIQUgDRDYPCIEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgA0EANgK0AiADIAU2ArACIAMgBDYCrAIgA0HAADYCqAIgA0GoBGoiBCADQagCaiAGENIlIANBGGogBBCGPSADKAIcIQkgAygCGCEPAkACQAJAAkACQCANENg8IhAEQCAHQQJ2IQogAigCECERQQAhBANAAkACQAJAAkACQAJAAkAgAiAEEIs7RQRAIARBA3YiBSAJTw0BIAUgD2oiBSAFLQAAQX4gBEEHcXdxOgAAIAMoApgEIgUgAygCkARGBEAgA0GQBGpBgLCCARCdKAsgAygClAQgBUECdGogDDYCACADIAVBAWo2ApgEDAcLIAMgBDYCuAQgDRDYPCAETQ0BIBEgBEEDdGopAwAiEkKAgICAEFoEQEEUIQUgA0GoAmpBFEEAQQFBARCgGCADKAKsAiEIIAMoAqgCQQFGDQUgAygCsAIiBkEQakGw/4EBKAAANgAAIAZBCGpBqP+BASkAADcAACAGQaD/gQEpAAA3AAAgA0GoBGoQzy8gA0GcBGoQ6TsgA0GQBGoQ6TtBhoCAgHghBAwKCyAKIBKnIgtNDQIgC0EBaiIFIApPDQUgDiAFQQJ0aigCACIHIA4gC0ECdGooAgAiBmsgDGohDCADKAKYBCIFIAMoApAERgRAIANBkARqQbCwggEQnSgLIAMoApQEIAVBAnRqIAw2AgAgAyAFQQFqNgKYBCAGIAdIBEAgAygCpAQiCEECdCEFA0AgAygCnAQgCEYEQCADQZwEakHAsIIBEJ0oCyADKAKgBCAFaiAGNgIAIAMgCEEBaiIINgKkBCAFQQRqIQUgByAGQQFqIgZHDQALCyABIAsQkjsNBiAEQQN2IgUgCU8NAyAFIA9qIgUgBS0AAEF+IARBB3F3cToAAAwGCyAFIAlBgPSBARDDIQALIAMgAhD9OzYCvAQgA0ECNgKsAiADQYjxgQE2AqgCIANCAjcCtAIgA0E7NgIsIANBOzYCJCADIANBIGo2ArACIAMgA0G8BGo2AiggAyADQbgEajYCICADQagCakGY8YEBEO8sAAsgCyAKQZCwggEQwyEACyAFIAlBgPSBARDDIQALIAggAygCsAJBiP2BARD9LwALIAUgCkGgsIIBEMMhAAsgBEEBaiIEIBBHDQALCyADQShqIANBpARqKAIANgIAIAMgAykCnAQ3AyAgA0G0AmogA0EgaiICEJkSIANBsAJqIANBmARqKAIAIgg2AgAgAyADKQKQBCISNwOoAiADKAK0AiEGIAMoArgCIQUgAygCvAIhByADKAKsAiEEIANBiANqIgkgA0HAAmpBJPwKAAAgA0HYAGoiCiADQbAEaiILKQIANwMAIAMgAykCqAQ3A1AgEqciDEGAgICAeEYNACADQSxqIAlBJPwKAAAgCyAKKQMANwMAIAMgAykDUDcDqAQgAyAHNgIoIAMgBTYCJCADIAY2AiAgAyAINgKkBCADIAQ2AqAEIAMgDDYCnAQgA0GoAmogASgCDCABKAIQIgQoAghBAWtBeHFqQQhqIAQgAhCJASADKAKwAiEGIAMoAqwCIQggAygCqAIiBEGTgICAeEYNASAAIAMpArQCNwIQIAAgBjYCDCAAIAg2AgggACAENgIEIABBKToAACADQagEahDPLyADQZwEahDpOyACEP4kDAILIAAgBzYCFCAAIAU2AhAgACAGNgIMIAAgCDYCCCAAIAQ2AgQgAEEpOgAADAELIANBiANqIgQgA0GcBGoQ4CwgAyADKQKIAzcCtAIgA0EANgKwAiADIAMoApQDIgc2AqwCIAMgAygCkAM2AqgCIANBEGogA0GoAmoiBRDXOyADKAIQIQlBHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAMpAqgCNwIIIAJBEGogA0GwAmopAgA3AgAgAkEYaiADQbgCaigCADYCACADIAc2AmwgAyAJNgJoIAMgAjYCZCADQcgCaiABEMoGIA0Q2DwhASADQQA7AYADIANBADYC/AIgA0EANgLkAiADQQA2AtgCIAMgATYC1AIgA0IENwLAAiADQgA3ArgCIANCgICAgMAANwKwAiADQQA2AqgCIAMoArAEIQEgAygCtAQhAiADIAMpA6gENwKUAyADQQA2ApADIAMgAjYCjAMgAyABNgKIAyADQQhqIAQQ1zsgAygCCCEHQRxBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgASADKQKIAzcCCCABQRBqIANBkANqKQIANwIAIAFBGGogA0GYA2ooAgA2AgAgAyACNgJYIAMgBzYCVCADIAE2AlAgA0HMAWoiASAFIANB0ABqEK4WIANBADYCoAIgBCAIIAYQ0yMgBSABIAQQ7yUgA0HwAGoiASAFIANB5ABqEPojIANBzANqIgIgARDNHCAAIAIQrx8gA0EgahD+JAsgA0HABGokAA8LQQRBHBCjPQALQQRBHBCjPQALQcAAIAQQoz0AC0HA9IEBQSkgA0GoAmpBzPyBAUHs9IEBENUeAAsgBCADKAKwAkHgr4IBEP0vAAvXEAIMfwN+IwBBwARrIgMkACABKAIYIQsgASgCHCEIIANBqAJqIAJBDGoiChDYPEEAQQhBCBCgGCADKAKsAiEFIAMoAqgCQQFHBEAgA0EANgKYBCADIAMoArACIgY2ApQEIAMgBTYCkAQgA0EANgKkBCADQoCAgICAATcCnAQgBQR/IAYFIANBkARqQfCvggEQsyggAygClAQLQgA3AwAgA0EBNgKYBEHAACEGIAoQ2DwiBUEDdiAFQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgRBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELQQAhBSADQQA2ArQCIAMgBjYCsAIgAyAENgKsAiADQcAANgKoAiADQagEaiIEIANBqAJqIAcQ0iUgA0EYaiAEEIY9IAMoAhwhCSADKAIYIQwCQAJAAkACQAJAIAoQ2DwiDQRAIAhBA3YhCCACKAIQIQ4DQAJAAkACQAJAAkACQAJAIAIgBRCLO0UEQCAFQQN2IgQgCU8NASAEIAxqIgQgBC0AAEF+IAVBB3F3cToAACADKAKYBCIEIAMoApAERgRAIANBkARqQYCwggEQsygLIAMoApQEIARBA3RqIBA3AwAgAyAEQQFqNgKYBAwHCyADIAU2ArgEIAoQ2DwgBU0NASAOIAVBA3RqKQMAIg9CgICAgBBaBEBBFCEFIANBqAJqQRRBAEEBQQEQoBggAygCrAIhByADKAKoAkEBRg0FIAMoArACIgRBEGpBsP+BASgAADYAACAEQQhqQaj/gQEpAAA3AAAgBEGg/4EBKQAANwAAIANBqARqEM8vIANBnARqEOM8IANBkARqEOM8QYaAgIB4IQIMCgsgCCAPpyIGTQ0CIAZBAWoiBCAITw0FIAsgBEEDdGopAwAiESALIAZBA3RqKQMAIg99IBB8IRAgAygCmAQiBCADKAKQBEYEQCADQZAEakGwsIIBELMoCyADKAKUBCAEQQN0aiAQNwMAIAMgBEEBajYCmAQgDyARUwRAIAMoAqQEIgRBA3QhBwNAIAMoApwEIARGBEAgA0GcBGpBwLCCARCzKAsgAygCoAQgB2ogDzcDACADIARBAWoiBDYCpAQgB0EIaiEHIBEgD0IBfCIPUg0ACwsgASAGEJI7DQYgBUEDdiIEIAlPDQMgBCAMaiIEIAQtAABBfiAFQQdxd3E6AAAMBgsgBCAJQYD0gQEQwyEACyADIAIQ/Ts2ArwEIANBAjYCrAIgA0GI8YEBNgKoAiADQgI3ArQCIANBOzYCLCADQTs2AiQgAyADQSBqNgKwAiADIANBvARqNgIoIAMgA0G4BGo2AiAgA0GoAmpBmPGBARDvLAALIAYgCEGQsIIBEMMhAAsgBCAJQYD0gQEQwyEACyAHIAMoArACQYj9gQEQ/S8ACyAEIAhBoLCCARDDIQALIAVBAWoiBSANRw0ACwsgA0EoaiADQaQEaigCADYCACADIAMpApwENwMgIANBtAJqIANBIGoiCRCaEiADQbACaiADQZgEaigCACIHNgIAIAMgAykCkAQiDzcDqAIgAygCtAIhBCADKAK4AiEFIAMoArwCIQYgAygCrAIhAiADQYgDaiIIIANBwAJqQST8CgAAIANB2ABqIgsgA0GwBGoiDCkCADcDACADIAMpAqgENwNQIA+nIg1BgICAgHhGDQAgA0EsaiAIQST8CgAAIAwgCykDADcDACADIAMpA1A3A6gEIAMgBjYCKCADIAU2AiQgAyAENgIgIAMgBzYCpAQgAyACNgKgBCADIA02ApwEIANBqAJqIAEoAgwgASgCECICKAIIQQFrQXhxakEIaiACIAkQigEgAygCsAIhBCADKAKsAiEHIAMoAqgCIgJBk4CAgHhGDQEgACADKQK0AjcCECAAIAQ2AgwgACAHNgIIIAAgAjYCBCAAQSk6AAAgA0GoBGoQzy8gA0GcBGoQ4zwgCRD+JAwCCyAAIAY2AhQgACAFNgIQIAAgBDYCDCAAIAc2AgggACACNgIEIABBKToAAAwBCyADQYgDaiIFIANBnARqEN4sIAMgAykCiAM3ArQCIANBADYCsAIgAyADKAKUAyIJNgKsAiADIAMoApADNgKoAiADQRBqIANBqAJqIgYQ1zsgAygCECEIQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQKoAjcCCCACQRBqIANBsAJqKQIANwIAIAJBGGogA0G4AmooAgA2AgAgAyAJNgJsIAMgCDYCaCADIAI2AmQgA0HIAmogARDKBiAKENg8IQEgA0EAOwGAAyADQQA2AvwCIANBADYC5AIgA0EANgLYAiADIAE2AtQCIANCBDcCwAIgA0IANwK4AiADQoCAgIDAADcCsAIgA0EANgKoAiADKAKwBCEBIAMoArQEIQIgAyADKQOoBDcClAMgA0EANgKQAyADIAI2AowDIAMgATYCiAMgA0EIaiAFENc7IAMoAgghCkEcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCiAM3AgggAUEQaiADQZADaikCADcCACABQRhqIANBmANqKAIANgIAIAMgAjYCWCADIAo2AlQgAyABNgJQIANBzAFqIgEgBiADQdAAahCuFiADQQA2AqACIAUgByAEENMjIAYgASAFEO8lIANB8ABqIgEgBiADQeQAahD6IyADQcwDaiICIAEQzRwgACACEK4fIANBIGoQ/iQLIANBwARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAEEKM9AAtBwPSBAUEpIANBqAJqQcz8gQFB7PSBARDVHgALIAUgAygCsAJB4K+CARD9LwAL0BACD38BfiMAQcAEayIDJAAgASgCGCEOIAEoAhwhByADQagCaiACQQxqIg0Q2zxBAEEEQQQQoBggAygCrAIhBCADKAKoAkEBRwRAIANBADYCmAQgAyADKAKwAiIFNgKUBCADIAQ2ApAEIANBADYCpAQgA0KAgICAwAA3ApwEIAQEfyAFBSADQZAEakHwr4IBEJ0oIAMoApQEC0EANgIAIANBATYCmARBwAAhBSANENs8IgRBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyADQQA2ArQCIAMgBTYCsAIgAyAENgKsAiADQcAANgKoAiADQagEaiIEIANBqAJqIAYQ0iUgA0EYaiAEEIY9IAMoAhwhCiADKAIYIQ8CQAJAAkACQAJAIA0Q2zwiEARAIAdBAnYhCyACKAIQIRFBACEEA0ACQAJAAkACQAJAAkACQCACIAQQiztFBEAgBEEDdiIFIApPDQEgBSAPaiIFIAUtAABBfiAEQQdxd3E6AAAgAygCmAQiBSADKAKQBEYEQCADQZAEakGAsIIBEJ0oCyADKAKUBCAFQQJ0aiAMNgIAIAMgBUEBajYCmAQMBwsgAyAENgK4BCANENs8IARNDQEgESAEQQJ0aigCACIJQQBIBEBBFCEFIANBqAJqQRRBAEEBQQEQoBggAygCrAIhCCADKAKoAkEBRg0FIAMoArACIgZBEGpBsP+BASgAADYAACAGQQhqQaj/gQEpAAA3AAAgBkGg/4EBKQAANwAAIANBqARqEM8vIANBnARqEOk7IANBkARqEOk7QYaAgIB4IQQMCgsgCSALTw0CIAlBAWoiBSALTw0FIA4gBUECdGooAgAiByAOIAlBAnRqKAIAIgZrIAxqIQwgAygCmAQiBSADKAKQBEYEQCADQZAEakGwsIIBEJ0oCyADKAKUBCAFQQJ0aiAMNgIAIAMgBUEBajYCmAQgBiAHSARAIAMoAqQEIghBAnQhBQNAIAMoApwEIAhGBEAgA0GcBGpBwLCCARCdKAsgAygCoAQgBWogBjYCACADIAhBAWoiCDYCpAQgBUEEaiEFIAcgBkEBaiIGRw0ACwsgASAJEJI7DQYgBEEDdiIFIApPDQMgBSAPaiIFIAUtAABBfiAEQQdxd3E6AAAMBgsgBSAKQYD0gQEQwyEACyADIAIQ/Ds2ArwEIANBAjYCrAIgA0GI8YEBNgKoAiADQgI3ArQCIANBOzYCLCADQTs2AiQgAyADQSBqNgKwAiADIANBvARqNgIoIAMgA0G4BGo2AiAgA0GoAmpBmPGBARDvLAALIAkgC0GQsIIBEMMhAAsgBSAKQYD0gQEQwyEACyAIIAMoArACQYj9gQEQ/S8ACyAFIAtBoLCCARDDIQALIARBAWoiBCAQRw0ACwsgA0EoaiADQaQEaigCADYCACADIAMpApwENwMgIANBtAJqIANBIGoiAhCZEiADQbACaiADQZgEaigCACIINgIAIAMgAykCkAQiEjcDqAIgAygCtAIhBiADKAK4AiEFIAMoArwCIQcgAygCrAIhBCADQYgDaiIJIANBwAJqQST8CgAAIANB2ABqIgogA0GwBGoiCykCADcDACADIAMpAqgENwNQIBKnIgxBgICAgHhGDQAgA0EsaiAJQST8CgAAIAsgCikDADcDACADIAMpA1A3A6gEIAMgBzYCKCADIAU2AiQgAyAGNgIgIAMgCDYCpAQgAyAENgKgBCADIAw2ApwEIANBqAJqIAEoAgwgASgCECIEKAIIQQFrQXhxakEIaiAEIAIQiQEgAygCsAIhBiADKAKsAiEIIAMoAqgCIgRBk4CAgHhGDQEgACADKQK0AjcCECAAIAY2AgwgACAINgIIIAAgBDYCBCAAQSk6AAAgA0GoBGoQzy8gA0GcBGoQ6TsgAhD+JAwCCyAAIAc2AhQgACAFNgIQIAAgBjYCDCAAIAg2AgggACAENgIEIABBKToAAAwBCyADQYgDaiIEIANBnARqEOAsIAMgAykCiAM3ArQCIANBADYCsAIgAyADKAKUAyIHNgKsAiADIAMoApADNgKoAiADQRBqIANBqAJqIgUQ1zsgAygCECEJQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQKoAjcCCCACQRBqIANBsAJqKQIANwIAIAJBGGogA0G4AmooAgA2AgAgAyAHNgJsIAMgCTYCaCADIAI2AmQgA0HIAmogARDKBiANENs8IQEgA0EAOwGAAyADQQA2AvwCIANBADYC5AIgA0EANgLYAiADIAE2AtQCIANCBDcCwAIgA0IANwK4AiADQoCAgIDAADcCsAIgA0EANgKoAiADKAKwBCEBIAMoArQEIQIgAyADKQOoBDcClAMgA0EANgKQAyADIAI2AowDIAMgATYCiAMgA0EIaiAEENc7IAMoAgghB0EcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCiAM3AgggAUEQaiADQZADaikCADcCACABQRhqIANBmANqKAIANgIAIAMgAjYCWCADIAc2AlQgAyABNgJQIANBzAFqIgEgBSADQdAAahCuFiADQQA2AqACIAQgCCAGENMjIAUgASAEEO8lIANB8ABqIgEgBSADQeQAahD6IyADQcwDaiICIAEQzRwgACACEK8fIANBIGoQ/iQLIANBwARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAEEKM9AAtBwPSBAUEpIANBqAJqQcz8gQFB7PSBARDVHgALIAQgAygCsAJB4K+CARD9LwAL4REBCX8jAEHQAWsiBCQAIAQgAjYCFAJAAkAgAigCACICKAIIQQJGBEAgBEEIaiACQQhqIgoQiiYgBCgCDCICQQFHBEAgBEEBNgKMASAEQdDYzwA2AogBIARCATcClAEgBEE7NgIwIAQgAjYCQCAEIARBLGo2ApABIAQgBEFAazYCLCAAQQxqIARBiAFqEJkOIABBgoCAgHg2AgAgAEEDNgIIDAILAn8CQAJAAkAgBCgCCCIJKAIAIgJBCGoiByACKAIIIgZBAkZBAnRqLQAgQQJGBEACQCAKIAooAgBBAkZBAnRqLQAgQQFrDgMCAwAEC0Gfus8AQStBzLrPABCfKQALIARBiAFqQRtBAEEBQQEQoBggBCgCjAEhAiAEKAKIAUEBRg0GIAQoApABIgFBF2pBn9jPACgAADYAACABQRBqQZjYzwApAAA3AAAgAUEIakGQ2M8AKQAANwAAIAFBiNjPACkAADcAACAAQRs2AhQgACABNgIQIAAgAjYCDCAAQQM2AgggAEGCgICAeDYCAAwFCyADLwEOQQFqIQtBAQwCCyAEQYgBakEcQQBBAUEBEKAYIAQoAowBIQIgBCgCiAFBAUYNBCAEKAKQASIBQRhqQYTYzwAoAAA2AAAgAUEQakH8188AKQAANwAAIAFBCGpB9NfPACkAADcAACABQezXzwApAAA3AAAgAEEcNgIUIAAgATYCECAAIAI2AgwgAEEDNgIIIABBgoCAgHg2AgAMAwsgAy8BDiELQQALIQxBBCECAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAIgVBG2sOBAEDAAECC0EIIQILIAIgA2ooAgAhBSAGQQJHDQQgBUEIaiECDAMLIAVBKUYNAQsgBCADNgJAIARBATYCjAEgBEHk188ANgKIASAEQgE3ApQBIARBpwQ2AjAgBCAEQSxqNgKQASAEIARBQGs2AiwgAEEMaiAEQYgBahCnGCAAQYKAgIB4NgIAIABBAzYCCAwLC0EAIQIgBkECRw0CCyAEIAcQiiYCQCAEKAIEQQFHDQAgBCgCACEIIAkoAgBBCGohByMAQRBrIgYkAAJ/QQAgBygCAEECRw0AGiAGQQRqIAdBBGoQiRkgBi0ABCIFQRFHBEAgBUECRgwBCyAHLQAlQQRGCyAGQRBqJAANBkEAIQUjAEEQayIGJAACQCAHKAIAQQJHDQAgBkEIaiAHEIomIAYoAgxBAUcNACAGKAIIKAIAIgVBCGogBSgCCEECRkECdGotACBBAkYhBQsgBkEQaiQAIAUNBiAJKAIAIgVBCGogBSgCCEECRkECdGoiBSgCDCAFKAIQQZbXzwBBBRDBLg0AIAkoAgAiBUEIaiAFKAIIQQJGQQJ0aiIFKAIQIQYgBSgCDCAEQQI2AowBIARBpNfPADYCiAEgBEIBNwKUASAEIAogCigCAEECRkECdGopAgw3AkAgBEHMATYCPCAEIARBOGo2ApABIAQgBEFAazYCOCAEQSxqIgcgBEGIAWoQpxggBiAEKAIwIAQoAjQQwS4gBxDeO0UNBgsgAy8BDCEFIAJFDQMgBEGIAWogAkEoahDDBgwECyADLwEMIQIgBEGIAWogBUEwahDDBgwBCyADLwEMIQIgBEEpOgCIAQsgBEEgaiAEQZABaiIFKAIANgIAIAQgCzsBJiAEIAI7ASQgBCAEKQKIATcDGCAEQYgBaiABIAkgBEEYahDsCSAEKAKIAUH/////B2pBAk8NBCAAIAQpA4gBNwMAIABBGGogBEGgAWopAwA3AwAgAEEQaiAEQZgBaikDADcDACAAQQhqIAUpAwA3AwAMBgsgBEEpOgCIAQsgBEHQAGogBEGQAWoiAigCADYCACAEIAs7AVYgBCAFOwFUIAQgBCkCiAE3A0ggBEGIAWogASAJIARByABqEPgCIAQoAogBQf////8HakECTw0BIAAgBCkDiAE3AwAgAEEYaiAEQaABaikDADcDACAAQRBqIARBmAFqKQMANwMAIABBCGogAikDADcDAAwECyALQQFqIQYgAy8BDEEBaiEHAkAgAgRAIARBiAFqIAJBKGoQwwYMAQsgBEEpOgCIAQsgBEHgAGogBEGQAWooAgA2AgAgBCAGOwFmIAQgBzsBZCAEIAQpAogBNwNYIARB6ABqIAEgCCAEQdgAahDSAQJAIAQoAmhB/////wdqQQFNBEAgACAEKQNoNwMAIABBGGogBEGAAWopAwA3AwAgAEEQaiAEQfgAaikDADcDACAAQQhqIARB8ABqKQMANwMADAELIARBiAFqIgEgCCgCAEEIaiAEQegAaiACEKsJIAEQ0CkhBQJ/An8CQAJAAkAgAy0AAEEdaw4CAQIAC0EbDAILQR0hAiADKAIEDAILQR4LIQIgBQshAUEgQQQQpi8hCCAAIAw6ABwgACAGOwEaIAAgBzsBGCAAIAU2AhQgACABNgIQIAAgAjoADCAAQQE2AgggACAINgIEIABBATYCACAIQRhqIARBgAFqKQMANwIAIAhBEGogBEH4AGopAwA3AgAgCEEIaiAEQfAAaikDADcCACAIIAQpA2g3AgALDAMLIAAgBCkDiAE3AwAgACAELwClATsAHSAAIAw6ABwgAEEYaiAEQaABaigCADYCACAAQRBqIARBmAFqKQMANwMAIABBCGogAikDADcDACAAQR9qIARBpwFqLQAAOgAADAILIAAgBCkDiAE3AwAgACAELwClATsAHSAAIAw6ABwgAEEYaiAEQaABaigCADYCACAAQRBqIARBmAFqKQMANwMAIABBCGogBSkDADcDACAAQR9qIARBpwFqLQAAOgAADAELIARBAjYCjAEgBEGM2c8ANgKIASAEQgE3ApQBIARBogg2AjAgBCAEQSxqNgKQASAEIARBFGo2AiwgAEEMaiAEQYgBahCZDiAAQYKAgIB4NgIAIABBAzYCCAsgAy0AAEEpRwRAIAMQnQwLIARB0AFqJAAPCyACIAQoApABQeSjzwAQ/S8AC4EOASt/IwBBEGsiISQAAkAgAyABKAIEIAEoAhxqSQ0AIAEgAyAEIAkgCBClCSABKAIQIgwgAyABKAIEIhNrIgpBASABKAK4AXQiC2sgDCAKIAxrIAtLGyABKAIYGyIcQQFLIQwgCkF/IAEoArwBQQFrdEF/cyIlayILIApLIRcgASgCZCIsIAogJXFBA3RqIRggASgCXCADIAEoAsABIiYgCRCjHUECdGohJ0EDQQQgCUEDRiIRGyEdIAEoAswBIg1B/x9JIRAgASgCDCESIAEoAgghGSABKALEASEOIAhBAkciLUUEQCAcIAEoArQBIhQoAgAiIiAUKAIEIiNrIh9rIRpBfyAUKAK8AUEBa3RBf3MhHiAUKALAASEmIBQoAhAhFQsgHEEBIAwbIShBACALIBcbISkgGEEEaiEXICcoAgAhDyANQf8fIBAbISogCkEJaiEWIBIgE2ohGyASIBlqISRBASAOdCEQIB8gHmsgFSAeIB8gFWtJGyAVIAhBAkYbIS5BA0EAIAZBA2pBA08bIS9BAyAGayEwIAogHGshMSADIB1qISAgCiASayEyICMgGmshMyAHQQFrIQwgBSAGQQJ0aiELIAogFSAaamshNEEAIQZBACENA0AgBiAvRwRAIAoCfyAGIDBGBEAgBSgCAEEBawwBCyALKAIACyIHayEOAkACfyAyIAdBAWsiK0sEQCAOIBxJDQIgAygAACIOQQh0IA4gERsgAyAHaygAACIOQQh0IA4gERtHDQIgICAgIAdrIAQQgBQMAQsgCEEBRgRAIA4gEmtBfEsgKyAxT3INAiADKAAAIgdBCHQgByARGyAOIBlqIgcoAAAiDkEIdCAOIBEbRw0CICAgByAdaiAEICQgGxDNKAwBCyAtICsgNE9yIA4gEmtBfEtyDQEgAygAACIHQQh0IAcgERsgDiAzaiIHKAAAIg5BCHQgDiARG0cNASAgIAcgHWogBCAiIBsQzSgLIB1qIgcgDE0NACAAIA1BA3RqIgwgBzYCBCAMIAZBAWo2AgAgDUEBaiENIAcgKksNAyAHIgwgA2ogBEYNAwsgC0EEaiELIAZBAWohBgwBCwsgAQJ/AkAgCUEDRyAMQQJLcg0AIAIoAgAiBiAKIAYgCksbIQtBICABKAIgayEFIAMoAAAhESABKAJgIQcDQCAGIAtGRQRAIAcgBiATaigAAEGA+p6tA2wgBXZBAnRqIAY2AgAgBkEBaiEGDAELCyACIAo2AgAgByARQYD6nq0DbCAFdkECdGooAgAiAiAoSQ0AIAogAmsiBUH//w9LDQACfwJAAkACQCAIDgMBAAEACyACIBJJDQELIAMgAiATaiAEEIAUDAELIAMgAiAZaiAEICQgGxDNKAsiBkEDSQ0AIAAgBjYCBCAAIAVBA2o2AgAgBiAqTQRAQQEhDSAGIQwgAyAGaiAERw0BC0EBIQ0gCkEBagwBCyAnIAo2AgAgCkEDaiEKQQAhC0EAIQUCQAJAA0AgEEUgDyAoSXINASAFIAsgBSALSRshAgJ/AkACQAJAIAgOAwEAAQALIAIgD2ogEkkNAQsgAiADaiAPIBNqIAJqIAQQgBQgAmohBiATDAELIBkgEyACIANqIA8gGWogAmogBCAkIBsQzSggAmoiBiAPaiASSRsLIQICQCAGIAxLBEAgACANQQN0aiIHIAY2AgQgByAKIA9rNgIAIAYgD2ogFiAGIBYgD2tLGyEWIA1BAWohDSADIAZqIARGIAZBgCBLcg0BIAYhDAsgLCAPICVxQQN0aiEHAkACQCACIA9qIAZqLQAAIAMgBmotAABJBEAgGCAPNgIAIA8gKUsNASAhQQxqIRgMBQsgFyAPNgIAIA8gKUsEQCAHIRcgBiELDAILICFBDGohFwwECyAGIQUgB0EEaiIYIQcLIBBBAWshECAHKAIAIQ8MAQsLIBBBACAIQQJHGyEQDAELIAwhBgsgF0EANgIAIBhBADYCAAJAIBBFIAhBAkdyDQAgFCgCXCADICYgCRCjHUECdGohByATIBpqIQkgFCgCZCEMQQAhC0EAIQUDQCAQRQ0BIAcoAgAiByAVTQ0BIAYgAyAFIAsgBSALSRsiAmogByAjaiIIIAJqIAQgIiAbEM0oIAJqIgJJBEAgACANQQN0aiIGIAI2AgQgBiAKIAcgGmoiBms2AgAgAiAGaiAWIAIgFiAGa0sbIRYgDUEBaiENIAJBgCBLDQIgAiIGIANqIARGDQILIAcgLk0NASAQQQFrIRAgAiAFIAggByAJaiACIAdqIB9JGyACai0AACACIANqLQAASSIIGyEFIAsgAiAIGyELIAwgByAecUEDdGogCEECdGohBwwACwALIBZBCGsLNgIcCyAhQRBqJAAgDQvVFQIKfwJ+IwBB4AJrIgUkACAFIAM6ACMgBSACOgAiIAUgATYCHAJAAkAgBC0ANEUEQCAFQewBaiICIAVBHGoQ+ikgBSAFQSJqNgKUAiAFIAVBI2o2ApACIAVBkAFqIQgjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohByMAQdAAayICJAAgAkEIaiABIAJBIGoiBCABKAIsEIELAkACQAJAIAIoAggiC0F+cUECRwRAIAIoAgwhCiAEIAEQoyogBEEEIAIoAiBBAWoiBkF/IAYbIgYgBkEETRtBAEEEQQgQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgkgCjYCBCAJIAs2AgAgAkEcaiINQQE2AgAgAiAJNgIYIAIgBjYCFCAEIAFBMPwKAAAjAEEgayIBJAAgAUEIaiAEIAFBFGogBCgCLBCBCyABKAIIIglBfnFBAkcEQCACQRRqIQYgASgCDCELA0ACQCAGKAIIIgogBigCAEcNACABQRRqIAQQoyogASgCFEEBaiIMQX8gDBsiDCAGKAIAIAYoAggiDmtNDQAgBiAOIAxBBEEIEN4oCyAGKAIEIApBA3RqIgwgCzYCBCAMIAk2AgAgBiAKQQFqNgIIIAEgBCABQRRqIAQoAiwQgQsgASgCBCELIAEoAgAiCUF+cUECRw0ACwsCQCAEKAIEIgZFDQAgBiAGKAIAIgZBAWs2AgAgBkEBRw0AIARBBGoQ+x4LIAFBIGokACAHQQhqIA0oAgA2AgAgByACKQIUNwIADAELIAdBADYCCCAHQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgBiACKAIoQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgCCADKQIANwIAIAhBEGogA0EQaigCADYCACAIQQhqIANBCGopAgA3AgAgBxDqOwwBCyAIIAMpAhQ3AgQgCEGTgICAeDYCACAIQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHoAGoiASAFQZwBaigCADYCACAFIAUpApQBNwNgIAUoApABIgJBk4CAgHhGDQEgBSgCoAEhAyAAIAUpA2A3AgggACADNgIUIAAgAjYCBCAAQSk6AAAgAEEQaiABKAIANgIADAILIAVBJGoiAiAFQRxqEPopIAVBwAFqIgEgAkEk/AoAACAFIAVBImo2AugBIAUgBUEjajYC5AEgARCQOxogBSgC3AEhAyABEJA7IQYgBUGQAWoiAiABQSz8CgAAIAIQkDsaIAUoAqwBIQEgBSACEJA7IAFrIgE2ArACIAVBtAJqQX8gAUEHaiICIAEgAksbQQN2ENIfIAFBAnQiAiEEAkAgAkE8cSIBBEAgAiABa0FAayIEIAJJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQsgBSgCvAIhCSAFQewBaiAFQZABakEs/AoAACAGIANrIQsgBUEANgKYAiAFQfABaiEKQQAhAwJAAkACQANAIAVByAJqIQ1BAiEBIAUoAogCIgYgBSgCjAJHBH8gBQJ/AkACQAJAIAUoAvABRQ0AIAYgBSgCgAJPDQEgBSgC9AEgBSgC/AEgBmoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAUgBkEBajYCiAIMAgsgBSAGQQFqNgKIAiAFQRBqIAVB7AFqIAYQrSogBUHMAmoiBiAFKAIQIAUoAhQgBSgCkAIsAAAQxwEgBSgCzAJBk4CAgHhHBEAgBhCIEQwCCyAFKALQAiIBIAUoApQCLQAAEMQpDAILQbSUgAFBIEHUlIABEJ8pAAtBAAs2AsgCIAUgBSgCmAIiB0EBajYCmAIgBUHEAmoFIA0LIAE2AgACQAJAAkAgBSgCyAIiBkECRwRAIAMgCGohASAGQQFxRQ0BIAEgBSgCxAI2AgAgCSAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAgsCQCAFKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAKEPseCyAFIANBAnUiATYCzAIgASAFKAKwAkcNBCAFKAK8AiEBIAUoAsACIQYgBSAFKQK0AjcC+AEgBUEANgL0ASAFIAY2AvABIAUgATYC7AEgBUEIaiAFQewBaiIDENc7IAUoAgghB0EcQQQQrTYiAUUNBSABQoGAgIAQNwIAIAEgBSkC7AE3AgggAUEQaiAFQfQBaiIJKQIANwIAIAFBGGogBUH8AWoiCigCADYCACAFIAQ2AvwBIAVCgICAgIAINwL0ASAFIAI2AvABIAUgCDYC7AEgBSADENc7IAUoAgAhBEEcQQQQrTYiAw0CQQRBHBCjPQALIAFBADYCAAsgA0EEaiEDDAELCyADQoGAgIAQNwIAIAMgBSkC7AE3AgggA0EQaiAJKQIANwIAIANBGGogCigCADYCACAFIAY2ArwCIAUgBzYCuAIgBSABNgK0AkEMQQQQrTYiAUUNAiABIAI2AgggASAENgIEIAEgAzYCACAFQQE2AtQCIAUgATYC0AIgBUEBNgLMAiAFQQA2ApgBIAVCgICAgMAANwKQASAFQewBaiICQYCSgAEgCyAFIAVBtAJqIAVBzAJqIAVBkAFqIgEQjBMgASACEMMTIAVB4ABqIAEgBS0AIiAFLQAjEKATIAUtAGAiAUEpRgRAIAVB2wBqIAVB9ABqKAIAIgE2AAAgBUHTAGogBUHsAGopAgAiDzcAACAFIAUpAmQiEDcASyAAQRRqIAE2AAAgAEEMaiAPNwAAIAAgEDcABCAAQSk6AAAMCAsgACAFKQJ4NwIYIAVB1wBqIgIgBUHwAGopAAA3AAAgBUHQAGoiAyAFQekAaikAADcDACAAQSBqIAVBgAFqKQIANwIAIABBKGogBUGIAWopAgA3AgAgBSAFKQBhIg83A0ggAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA83AAEgACABOgAADAcLIAVCADcC+AEgBUKBgICAwAA3AvABIAVBxJGAATYC7AFBACAFQcwCaiAFQbACaiAFQewBakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBwAAgBBCjPQALQeSUgAFBKSAFQewBakHIl4ABQZCVgAEQ1R4AC0GUk4ABQSNBuJOAARDLJAALIAVByAFqIAEoAgAiATYCACAFIAUpA2A3A8ABIAVB7AFqIgIgBSgCxAEiAyADIAFBA3RqEPkIIAVBkAFqIAIgBS0AIiAFLQAjEKATIAUtAJABIgFBKUYEQCAFQfMAaiAFQaQBaigCACIBNgAAIAVB6wBqIAVBnAFqKQIAIg83AAAgBSAFKQKUASIQNwBjIABBFGogATYAACAAQQxqIA83AAAgACAQNwAEIABBKToAACAFQcABahDqOwwBCyAAIAUpAqgBNwIYIAVB7wBqIgIgBUGgAWopAAA3AAAgBUHoAGoiAyAFQZkBaikAADcDACAAQSBqIAVBsAFqKQIANwIAIABBKGogBUG4AWopAgA3AgAgBSAFKQCRASIPNwNgIABBEGogAikAADcAACAAQQlqIAMpAwA3AAAgACAPNwABIAAgAToAACAFQcABahDqOwsgBUHgAmokAAv0FQIIfwR+IwBB8AJrIgUkACAFIAM6ACsgBSACOgAqIAUgATYCJAJAAkACQAJAAkACQCAELQA0RQRAIAVB+AFqIgIgBUEkahD6KSAFIAVBKmo2AqACIAUgBUErajYCnAIgBUGYAWohByMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEKIwBB0ABrIgIkACACQRBqIgkgARC4HQJAAkACQCACKQMYIg0gAikDECIOQgKFhFBFBEAgAikDKCEPIAIpAyAhECACQcQAaiIEIAEQoyogBEEEIAIoAkRBAWoiBEF/IAQbIgQgBEEETRtBAEEQQSAQoBggAigCSCEGIAIoAkRBAUYNAiACKAJMIgQgDzcDGCAEIBA3AxAgBCANNwMIIAQgDjcDACACQQxqIghBATYCACACIAQ2AgggAiAGNgIEIAkgAUEw/AoAACMAQTBrIgEkACABIAkQuB0gASkDCCINIAEpAwAiDkIChYRQRQRAIAJBBGohBANAIAEpAxghDyABKQMQIRACQCAEKAIIIgsgBCgCAEcNACABQSRqIAkQoyogASgCJEEBaiIGQX8gBhsiBiAEKAIAIAQoAggiDGtNDQAgBCAMIAZBEEEgEN4oCyAEKAIEIAtBBXRqIgYgDzcDGCAGIBA3AxAgBiANNwMIIAYgDjcDACAEIAtBAWo2AgggASAJELgdIAEpAwgiDSABKQMAIg5CAoWEUEUNAAsLAkAgCSgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAJQQRqEPseCyABQTBqJAAgCkEIaiAIKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAYgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAcgAykCADcCACAHQRBqIANBEGooAgA2AgAgB0EIaiADQQhqKQIANwIAIAoQ5TwMAQsgByADKQIUNwIEIAdBk4CAgHg2AgAgB0EMaiADQRxqKAIANgIACyADQdAAaiQAIAVB8ABqIgEgBUGkAWooAgA2AgAgBSAFKQKcATcDaCAFKAKYASICQZOAgIB4Rg0BIAUoAqgBIQMgACAFKQNoNwIIIAAgAzYCFCAAIAI2AgQgAEEpOgAAIABBEGogASgCADYCAAwDCyAFQSxqIgIgBUEkahD6KSAFQcgBaiIBIAJBJPwKAAAgBSAFQSpqNgLwASAFIAVBK2o2AuwBIAEQkDsaIAUoAuQBIQkgARCQOyEKIAVBmAFqIgIgAUEs/AoAACACEJA7GiAFKAK0ASEBIAUgAhCQOyABayIBNgK8AiAFQcACakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQR0IgchBAJAIAdBMHEiAQRAIAcgAWtBQGsiBCAHSQ0BC0HAACEBIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgFFDQELIAUoAsgCIQYgBUH4AWogBUGYAWpBLPwKAAAgBUEANgKkAiABIQMgBSgClAIiAiAFKAKYAkYNBCAFQdACakEEciELA0ACQAJAAkACQAJAAkACQCAFKAL8AUUNACACIAUoAowCTw0EIAUoAoACIAUoAogCIAJqIghBA3ZqLQAAQf8BcyAIQQdxdkEBcUUNACAFIAJBAWo2ApQCDAELIAUgAkEBajYClAIgBUEYaiAFQfgBaiACEK0qIAVB0AJqIAUoAhggBSgCHCAFKAKcAiwAABDGASAFKALQAiICQQFHDQEgAkUNACALEIgRCyAFIAUoAqQCQQFqNgKkAgwBCyAFKQPgAiINIAUpA+gCIg4gBSgCoAItAAAQ/yAgBSAFKAKkAiICQQFqNgKkAg0CCyADQgA3AwggA0IANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgAyANNwMAIAMgDjcDCCAGIAJBA3ZqIgggCC0AAEEBIAJBB3F0cjoAAAsgA0EQaiEDIAUoApQCIgIgBSgCmAJHDQALDAQLQcAAIAQQoz0AC0HklIABQSkgBUH4AWpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQACyAFQdABaiABKAIAIgE2AgAgBSAFKQNoNwPIASAFQfgBaiICIAUoAswBIgMgAyABQQV0ahD2CCAFQZgBaiACIAUtACogBS0AKxChEyAFLQCYASIBQSlGBEAgBUH7AGogBUGsAWooAgAiATYAACAFQfMAaiAFQaQBaikCACINNwAAIAUgBSkCnAEiDjcAayAAQRRqIAE2AAAgAEEMaiANNwAAIAAgDjcABCAAQSk6AAAgBUHIAWoQ5TwMAgsgACAFKQKwATcCGCAFQfcAaiICIAVBqAFqKQAANwAAIAVB8ABqIgMgBUGhAWopAAA3AwAgAEEgaiAFQbgBaikCADcCACAAQShqIAVBwAFqKQIANwIAIAUgBSkAmQEiDTcDaCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAAgBUHIAWoQ5TwMAQsCQCAFKAL8ASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAFQfwBahD7HgsgBSADIAFrQQR1IgI2AtACIAIgBSgCvAJHDQEgBSgCyAIhAiAFKALMAiEDIAUgBSkCwAI3AoQCIAVBADYCgAIgBSADNgL8ASAFIAI2AvgBIAVBEGogBUH4AWoiBhDXOyAFKAIQIQtBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAUpAvgBNwIIIAJBEGogBUGAAmoiCCkCADcCACACQRhqIAVBiAJqIgwoAgA2AgAgBSAENgKIAiAFQoCAgICACDcCgAIgBSAHNgL8ASAFIAE2AvgBIAVBCGogBhDXOyAFKAIIIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAUpAvgBNwIIIAFBEGogCCkCADcCACABQRhqIAwoAgA2AgAgBSADNgLIAiAFIAs2AsQCIAUgAjYCwAJBDEEEEK02IgJFDQMgAiAHNgIIIAIgBDYCBCACIAE2AgAgBUEBNgLYAiAFIAI2AtQCIAVBATYC0AIgBUEANgKgASAFQoCAgIDAADcCmAEgBUH4AWoiAkH0kYABIAogCWsgBSAFQcACaiAFQdACaiAFQZgBaiIBEIwTIAEgAhCwEyAFQegAaiABIAUtACogBS0AKxChEyAFLQBoIgFBKUYEQCAFQeMAaiAFQfwAaigCACIBNgAAIAVB2wBqIAVB9ABqKQIAIg03AAAgBSAFKQJsIg43AFMgAEEUaiABNgAAIABBDGogDTcAACAAIA43AAQgAEEpOgAADAELIAAgBSkCgAE3AhggBUHfAGoiAiAFQfgAaikAADcAACAFQdgAaiIDIAVB8QBqKQAANwMAIABBIGogBUGIAWopAgA3AgAgAEEoaiAFQZABaikCADcCACAFIAUpAGkiDTcDUCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAALIAVB8AJqJAAPCyAFQgA3AoQCIAVCgYCAgMAANwL8ASAFQcSRgAE2AvgBQQAgBUHQAmogBUG8AmogBUH4AWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALrxACCn8DfkIKIQ8jAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEQAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogECAQQj+HIA8gD0I/hxCoHiAFKQMYIAUpAxAiEEI/h1INAyACQQFGDQILIAUgDyAPQj+HIhEgDyAREKgeIAUpAwggBSkDACIPQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPgeIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQZBACECA0ACQCAFQSxqAn8CQCABIAIQhyVFBEAgBSACNgLQASANENg8IAJNDQYgBSABKAIQIApqKQMAIg83A7ABIAUgEDcD0AEgEFAEf0GHgICAeAUgEEJ/UiAPQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4ASAFQeQAaiAFQfgAahCZDiAFKQJkIREgBSkCbCEPQYiAgIB4CyEBIAAgDzcCDCAAIBE3AgQgACABNgIAIAVBLGoQui0MCgsgBhDmOiAFKAI4RQ0GIAUoAkhBAWoiCEEDdiAIQQdxQQBHaiIDIAUoAkQiBEsEQCADIARrIQkgBSgCPCIHIANJBEAgBiAHQQF0IgQgA0HA////A3FBQGsgAyADQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCQRAIAUoAkAgBGpBACAJ/AsACyAFIAM2AkQLIAUgCDYCSEIAIQ8gBSgCNCIDIAUoAixHDQJB9JKAAQwBCyAPIBB/IQ8CQCAFKAI4BEAgBSgCSCIIQQFqIglBA3YgCUEHcUEAR2oiAyAFKAJEIgRLBEAgAyAEayEHIAUoAjwiCyADSQRAIAYgC0EBdCIEIANBwP///wNxQUBrIAMgA0E/cRsiCyAEIAtLGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSADNgJECyAFIAk2AkggBSgCQCAIQQN2aiIDIAMtAABBASAIQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgMgBSgCLEcEQCAPIREMAgsgDyERQYSTgAELELMoCyAFKAIwIANBA3RqIA83AwAgBSADQQFqNgI0IApBCGohCiAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQggBUHgAGpBBHIhCiAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIg83A6gBIAUgEDcDsAEgBUEsagJ+AkACQCAQUEUEQCAQQn9SIA9CgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCiAFKQK4ATcCACAKQQhqIAVBwAFqKQIANwIAIApBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAoQiBFCAAwBCyAPIBB/IRFCAQsgERDaCwwBCyAIEOY6IAUoAjhFDQMgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAIIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCzKAsgBSgCMCAEQQN0akIANwMAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALhBYCD38DfiMAQdABayIFJAAgBUGIAWoiBiACQQBBBEEIEKAYIAUoAowBIQcCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBzYCGCAGIAJBAEEEQQwQoBggBSgCjAEhByAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBzYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhBwNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQICfwJAIAcoAgAiCBCTNiIGBEAgAg0BIAYhAgtBAAwBCyAFQYgBaiAGIAIQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiECQQELIRMCQAJAAkACQCAIKAI8IAgoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIJQcAAENE0BEACQAJAIAlFBEBBwAAhCgwBCyAJQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAJNgJgIAVBwAA2AlwgBgRAQQAhESAGIAlLBEAgBUHcAGogCUEBdBDoGSAFKAJoIREgBSgCZCEKCyAGBEAgCiARakEAIAb8CwALIAUgBjYCaAsgBSAQNgJsIAJFDQIgBUGIAWogAhDINCAIKAIgQQN2IQIgCCgCHCEIA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAggBkEDdGopAwAgBUEQaiAFQdwAahCGPaciCUEDdiIGIAUoAhQiCkkNASAGIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAGaiIGIAYtAABBASAJQQdxdHI6AAAMAAsAC0HAACAJEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAgoAiAiBkEISQ0AIAgoAhwhAiAGQXhxIQYDQCACKQMAIAVBCGogBUHcAGoQhj2nIglBA3YiCCAFKAIMIgpPDQIgBSgCCCAIaiIIIAgtAABBASAJQQdxdHI6AAAgAkEIaiECIAZBCGsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgggBSkCMDcCACAIQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIIIAw2AgQgCCAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAdBBGoiByAORw0ACwwCCyAHIAUoApABQfizgwEQ/S8ACyAHIAUoApABQeizgwEQ/S8ACyAFQawBaiIKIQYjAEEgayIDJAAgA0EUakJ/IA2tQoABfHkiFIinQQFqIgJBfyACGyICQQBBCEEYEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQZyzgwEQ/S8ACyADQRBqIglBADYCACADIAMoAhw2AgwgAyAENgIIIAIiCCADQQhqIgQoAgAgBCgCCCIHa0sEQCAEIAcgAkEIQRgQ3iggBCgCCCEHCyAEIAIEfyACIAdqIAQoAgQgB0EYbGohAgNAIAJCADcDACACQRhqIQIgCEEBayIIDQALBSAHCzYCCCAGQQhqIAkoAgA2AgAgBiADKQIINwIAIANBIGokACAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgcgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAHQSz8CgAAIAMgAzYCTCADQRRqIQYjAEHQAGsiAiQAIAJBFGogARC8JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiCEEEQQBBBEEMEKAYIAIoAiQhByACKAIgQQFGDQIgAigCKCIJIAIpAhQ3AgAgCUEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCTYCDCACIAc2AgggCCABQTD8CgAAIwBBEGsiASQAIAFBBGogCBC8JSABKAIEQYCAgIB4RwRAIAJBCGohBwNAIAcoAggiCSAHKAIARgRAIAcgCUEBQQRBDBDeKAsgBygCBCAJQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAcgCUEBajYCCCABQQRqIAgQvCUgASgCBEGAgICAeEcNAAsLIAhBDGoQuSAgAUEQaiQAIAZBCGogCygCADYCACAGIAIpAgg3AgAMAQsgBkEANgIIIAZCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgByACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgBhDWKyAGQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1isgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEIQRgQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAuvFAIPfwN+IwBB0AFrIgUkACAFQYgBaiIJIAJBAEEEQQgQoBggBSgCjAEhBgJAIAUoAogBQQFHBEAgBUEANgIgIAUgBSgCkAE2AhwgBSAGNgIYIAkgAkEAQQRBDBCgGCAFKAKMASEGIAUoAogBQQFHBEAgBUEANgIsIAUgBSgCkAE2AiggBSAGNgIkIAEgAkECdGohDiACRQ0CIAVBqAFqIRIgASEJA0AgAyALQRRsakEAIAQgC0sbQQAgAxshBgJ/AkAgCSgCACIHEJM2IgIEQCAGDQEgAiEGC0EADAELIAVBiAFqIAIgBhDKIiAFQdgAaiAFQZgBaigCADYCACAFQdAAaiAFQZABaikCADcDACAFIAUpAogBNwNIIAVByABqIQZBAQshEwJAAkACQAJAIAcoAjwgBygCQCIMKAIIQQFrQXhxakEIaiIPIAwoAiQRBAAiEEEDdiAQQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIghBwAAQ0TQEQAJAAkAgCEUEQEHAACEKDAELIAhBwAAQrTYiCkUNAQsgBUIANwJoIAUgCjYCZCAFIAg2AmAgBUHAADYCXCACBEBBACERIAIgCEsEQCAFQdwAaiAIQQF0EOgZIAUoAmghESAFKAJkIQoLIAIEQCAKIBFqQQAgAvwLAAsgBSACNgJoCyAFIBA2AmwgBkUNAiAFQYgBaiAGEMg0IAcoAiBBAXYhAiAHKAIcIQgDQAJAIAUpA7ABIhVQRQRAIAUpA7gBIRQMAQsDQAJ+AkAgBSkDmAEiFEIDUgRAAkACQAJAIBRCAlENACAFIBRQrUIBhjcDmAEgFKdBAXFFDQAgBSAFKQOgATcDyAEMAQsgBSgCqAFFDQEgBUHAAWogEhC2KiAFKQPAASEUCyAUQgBSDQILIAVCAzcDmAELIAUpA4gBIhRCAlENCCAFQgA3A4gBIAUpA5ABDAELIAUpA8gBCyEVIBSnQQFxRQ0GIAUgBSkDuAFCQH0iFDcDuAEgBSAVNwOwASAVUA0ACwsgBSAVQgEgFXoiFoaFNwOwAQJAIAIgFqcgFKdqIgZLBEAgCCAGQQF0ai8BACEGIAVBEGogBUHcAGoQhj0gBSgCFCIKIAZBA3YiB0sNASAHIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAHaiIHIActAABBASAGQQdxdHI6AAAMAAsAC0HAACAIEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAcoAiAiBkECSQ0AIAcoAhwhAiAGQX5xIQYDQCACLwEAIQcgBUEIaiAFQdwAahCGPSAFKAIMIgogB0EDdiIITQ0CIAUoAgggCGoiCCAILQAAQQEgB0EHcXRyOgAAIAJBAmohAiAGQQJrIgYNAAsLIAVBiAFqIgIgBUHcAGoiBhCGFCAGEM8vIAVBMGogDyAMIAIQjQEgBSgCOCEGIAUoAiwiAiAFKAIkRgRAIAVBJGpBmLSDARCQKAsgBSgCKCACQQxsaiIHIAUpAjA3AgAgB0EIaiAFQThqKAIANgIAIAUgAkEBajYCLCAFKAIgIgIgBSgCGEYEQCAFQRhqQai0gwEQmygLIAUoAhwgAkEDdGoiByAMNgIEIAcgDzYCACAFIAJBAWo2AiAgBSgCiAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiAFqEPseCyATRQ0BIAUoAkgiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAVByABqEPseDAELIAggCkHQsoMBEMMhAAsgC0EBaiELIAYgDWohDSAJQQRqIgkgDkcNAAsMAgsgBiAFKAKQAUH4s4MBEP0vAAsgBiAFKAKQAUHos4MBEP0vAAsgBUGsAWoiCkJ/IA2tQoABfHkiFIinQQFqIgJBfyACG0Gcs4MBEKIaIAUgFD4CqAEgBUKXkpyq27a1wj83A6ABIAVC3aHxy/y2itZANwOYASAFQuyYpKfz2Zmqvn83A5ABIAVC96bAxuO8iJTFADcDiAEgBUHcAGoiBiANQQBBBEEIEKAYIAUoAmAhAiAFKAJcQQFHBEAgBUEANgJEIAUgBSgCZDYCQCAFIAI2AjwgBSgCJCEDIAUoAighAiAFKAIsIQQgBUIANwJ4IAUgAiAEQQxsajYCdCAFIAM2AnAgBSACNgJsIAUgAjYCaCAFQQA2AmQgBSAONgJgIAUgATYCXCAFIAVBPGo2AoQBIAUgBUGIAWo2AoABIAVByABqIQQjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAZBLPwKAAAgAyADNgJMIANBFGohCSMAQdAAayICJAAgAkEUaiABELYlAkACQAJAIAIoAhRBgICAgHhHBEAgAkEgaiIHQQRBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgggAikCFDcCACAIQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAINgIMIAIgBjYCCCAHIAFBMPwKAAAjAEEQayIBJAAgAUEEaiAHELYlIAEoAgRBgICAgHhHBEAgAkEIaiEGA0AgBigCCCIIIAYoAgBGBEAgBiAIQQFBBEEMEN4oCyAGKAIEIAhBDGxqIgwgASkCBDcCACAMQQhqIAFBDGooAgA2AgAgBiAIQQFqNgIIIAFBBGogBxC2JSABKAIEQYCAgIB4Rw0ACwsgB0EMahC5ICABQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgAgAUEMahC5IAsgAkHQAGokAAwBCyAGIAIoAihBiPmDARD9LwALAkAgAygCAEGTgICAeEcEQCAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAJENUrIAlBBEEMEOAeDAELIAQgAykCFDcCBCAEQZOAgIB4NgIAIARBDGogA0EcaigCADYCAAsgA0HQAGokACAFQcgBaiIBIAVB1ABqKAIANgIAIAUgBSkCTDcDwAECQCAFKAJIIgJBk4CAgHhHBEAgBSgCWCEDIAAgBSkDwAE3AgggACADNgIUIAAgAjYCBCAAQQE2AgAgAEEQaiABKAIANgIADAELIAVB0ABqIgMgBUHIAWooAgA2AgAgBSAFKQPAATcDSCAFQdwAaiAFKAIcIAUoAiAgBSgCQCAFKAJEEK8CIAUoAmQhASAFKAJgIQIgBSgCXCIEQZOAgIB4RwRAIAAgBSkCaDcCECAAIAE2AgwgACACNgIIIAAgBDYCBCAAQQE2AgAgBUHIAGoiABDVKyAAQQRBDBDgHgwBCyAAIAUpA0g3AgQgAEEMaiADKAIANgIAIAAgATYCFCAAIAI2AhAgAEEANgIACyAFQTxqQQRBCBDgHiAKQQRBEBDgHiAFQRhqQQRBCBDgHiAFQdABaiQADwsgAiAFKAJkQYi0gwEQ/S8AC68UAg9/A34jAEHQAWsiBSQAIAVBiAFqIgkgAkEAQQRBCBCgGCAFKAKMASEGAkAgBSgCiAFBAUcEQCAFQQA2AiAgBSAFKAKQATYCHCAFIAY2AhggCSACQQBBBEEMEKAYIAUoAowBIQYgBSgCiAFBAUcEQCAFQQA2AiwgBSAFKAKQATYCKCAFIAY2AiQgASACQQJ0aiEOIAJFDQIgBUGoAWohEiABIQkDQCADIAtBFGxqQQAgBCALSxtBACADGyEGAn8CQCAJKAIAIgcQkzYiAgRAIAYNASACIQYLQQAMAQsgBUGIAWogAiAGEMoiIAVB2ABqIAVBmAFqKAIANgIAIAVB0ABqIAVBkAFqKQIANwMAIAUgBSkCiAE3A0ggBUHIAGohBkEBCyETAkACQAJAAkAgBygCPCAHKAJAIgwoAghBAWtBeHFqQQhqIg8gDCgCJBEEACIQQQN2IBBBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiCEHAABDRNARAAkACQCAIRQRAQcAAIQoMAQsgCEHAABCtNiIKRQ0BCyAFQgA3AmggBSAKNgJkIAUgCDYCYCAFQcAANgJcIAIEQEEAIREgAiAISwRAIAVB3ABqIAhBAXQQ6BkgBSgCaCERIAUoAmQhCgsgAgRAIAogEWpBACAC/AsACyAFIAI2AmgLIAUgEDYCbCAGRQ0CIAVBiAFqIAYQyDQgBygCIEECdiECIAcoAhwhCANAAkAgBSkDsAEiFVBFBEAgBSkDuAEhFAwBCwNAAn4CQCAFKQOYASIUQgNSBEACQAJAAkAgFEICUQ0AIAUgFFCtQgGGNwOYASAUp0EBcUUNACAFIAUpA6ABNwPIAQwBCyAFKAKoAUUNASAFQcABaiASELYqIAUpA8ABIRQLIBRCAFINAgsgBUIDNwOYAQsgBSkDiAEiFEICUQ0IIAVCADcDiAEgBSkDkAEMAQsgBSkDyAELIRUgFKdBAXFFDQYgBSAFKQO4AUJAfSIUNwO4ASAFIBU3A7ABIBVQDQALCyAFIBVCASAVeiIWhoU3A7ABAkAgAiAWpyAUp2oiBksEQCAIIAZBAnRqKAIAIQYgBUEQaiAFQdwAahCGPSAGQQN2IgcgBSgCFCIKSQ0BIAcgCkHQsoMBEMMhAAsgBiACQci0gwEQwyEACyAFKAIQIAdqIgcgBy0AAEEBIAZBB3F0cjoAAAwACwALQcAAIAgQoz0AC0HgsoMBQSkgBUGIAWpBrLODAUGMs4MBENUeAAsgBygCICIGQQRJDQAgBygCHCECIAZBfHEhBgNAIAIoAgAhByAFQQhqIAVB3ABqEIY9IAdBA3YiCCAFKAIMIgpPDQIgBSgCCCAIaiIIIAgtAABBASAHQQdxdHI6AAAgAkEEaiECIAZBBGsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgcgBSkCMDcCACAHQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIHIAw2AgQgByAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAlBBGoiCSAORw0ACwwCCyAGIAUoApABQfizgwEQ/S8ACyAGIAUoApABQeizgwEQ/S8ACyAFQawBaiIKQn8gDa1CgAF8eSIUiKdBAWoiAkF/IAIbQZyzgwEQohogBSAUPgKoASAFQpeSnKrbtrXCPzcDoAEgBULdofHL/LaK1kA3A5gBIAVC7Jikp/PZmaq+fzcDkAEgBUL3psDG47yIlMUANwOIASAFQdwAaiIGIA1BAEEEQQgQoBggBSgCYCECIAUoAlxBAUcEQCAFQQA2AkQgBSAFKAJkNgJAIAUgAjYCPCAFKAIkIQMgBSgCKCECIAUoAiwhBCAFQgA3AnggBSACIARBDGxqNgJ0IAUgAzYCcCAFIAI2AmwgBSACNgJoIAVBADYCZCAFIA42AmAgBSABNgJcIAUgBUE8ajYChAEgBSAFQYgBajYCgAEgBUHIAGohBCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBkEs/AoAACADIAM2AkwgA0EUaiEJIwBB0ABrIgIkACACQRRqIAEQuCUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgdBBEEAQQRBDBCgGCACKAIkIQYgAigCIEEBRg0CIAIoAigiCCACKQIUNwIAIAhBCGogAkEcaigCADYCACACQRBqIgtBATYCACACIAg2AgwgAiAGNgIIIAcgAUEw/AoAACMAQRBrIgEkACABQQRqIAcQuCUgASgCBEGAgICAeEcEQCACQQhqIQYDQCAGKAIIIgggBigCAEYEQCAGIAhBAUEEQQwQ3igLIAYoAgQgCEEMbGoiDCABKQIENwIAIAxBCGogAUEMaigCADYCACAGIAhBAWo2AgggAUEEaiAHELglIAEoAgRBgICAgHhHDQALCyAHQQxqELkgIAFBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIADAELIAlBADYCCCAJQoCAgIDAADcCACABQQxqELkgCyACQdAAaiQADAELIAYgAigCKEGI+YMBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAQgAykCADcCACAEQRBqIANBEGooAgA2AgAgBEEIaiADQQhqKQIANwIAIAkQsCsgCUEEQQwQ4B4MAQsgBCADKQIUNwIEIARBk4CAgHg2AgAgBEEMaiADQRxqKAIANgIACyADQdAAaiQAIAVByAFqIgEgBUHUAGooAgA2AgAgBSAFKQJMNwPAAQJAIAUoAkgiAkGTgICAeEcEQCAFKAJYIQMgACAFKQPAATcCCCAAIAM2AhQgACACNgIEIABBATYCACAAQRBqIAEoAgA2AgAMAQsgBUHQAGoiAyAFQcgBaigCADYCACAFIAUpA8ABNwNIIAVB3ABqIAUoAhwgBSgCICAFKAJAIAUoAkQQrwIgBSgCZCEBIAUoAmAhAiAFKAJcIgRBk4CAgHhHBEAgACAFKQJoNwIQIAAgATYCDCAAIAI2AgggACAENgIEIABBATYCACAFQcgAaiIAELArIABBBEEMEOAeDAELIAAgBSkDSDcCBCAAQQxqIAMoAgA2AgAgACABNgIUIAAgAjYCECAAQQA2AgALIAVBPGpBBEEIEOAeIApBBEEQEOAeIAVBGGpBBEEIEOAeIAVB0AFqJAAPCyACIAUoAmRBiLSDARD9LwALrxQCD38DfiMAQdABayIFJAAgBUGIAWoiCSACQQBBBEEIEKAYIAUoAowBIQYCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBjYCGCAJIAJBAEEEQQwQoBggBSgCjAEhBiAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBjYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhCQNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQYCfwJAIAkoAgAiBxCTNiICBEAgBg0BIAIhBgtBAAwBCyAFQYgBaiACIAYQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiEGQQELIRMCQAJAAkACQCAHKAI8IAcoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyIIQcAAENE0BEACQAJAIAhFBEBBwAAhCgwBCyAIQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAINgJgIAVBwAA2AlwgAgRAQQAhESACIAhLBEAgBUHcAGogCEEBdBDoGSAFKAJoIREgBSgCZCEKCyACBEAgCiARakEAIAL8CwALIAUgAjYCaAsgBSAQNgJsIAZFDQIgBUGIAWogBhDINCAHKAIgQQF2IQIgBygCHCEIA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAggBkEBdGouAQAhBiAFQRBqIAVB3ABqEIY9IAZBA3YiByAFKAIUIgpJDQEgByAKQdCygwEQwyEACyAGIAJByLSDARDDIQALIAUoAhAgB2oiByAHLQAAQQEgBkEHcXRyOgAADAALAAtBwAAgCBCjPQALQeCygwFBKSAFQYgBakGss4MBQYyzgwEQ1R4ACyAHKAIgIgZBAkkNACAHKAIcIQIgBkF+cSEGA0AgAi4BACEHIAVBCGogBUHcAGoQhj0gB0EDdiIIIAUoAgwiCk8NAiAFKAIIIAhqIgggCC0AAEEBIAdBB3F0cjoAACACQQJqIQIgBkECayIGDQALCyAFQYgBaiICIAVB3ABqIgYQhhQgBhDPLyAFQTBqIA8gDCACEI0BIAUoAjghBiAFKAIsIgIgBSgCJEYEQCAFQSRqQZi0gwEQkCgLIAUoAiggAkEMbGoiByAFKQIwNwIAIAdBCGogBUE4aigCADYCACAFIAJBAWo2AiwgBSgCICICIAUoAhhGBEAgBUEYakGotIMBEJsoCyAFKAIcIAJBA3RqIgcgDDYCBCAHIA82AgAgBSACQQFqNgIgIAUoAogBIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgBahD7HgsgE0UNASAFKAJIIgIgAigCACICQQFrNgIAIAJBAUcNASAFQcgAahD7HgwBCyAIIApB0LKDARDDIQALIAtBAWohCyAGIA1qIQ0gCUEEaiIJIA5HDQALDAILIAYgBSgCkAFB+LODARD9LwALIAYgBSgCkAFB6LODARD9LwALIAVBrAFqIgpCfyANrUKAAXx5IhSIp0EBaiICQX8gAhtBnLODARCiGiAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgYgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAGQSz8CgAAIAMgAzYCTCADQRRqIQkjAEHQAGsiAiQAIAJBFGogARC6JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiB0EEQQBBBEEMEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCIIIAIpAhQ3AgAgCEEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCDYCDCACIAY2AgggByABQTD8CgAAIwBBEGsiASQAIAFBBGogBxC6JSABKAIEQYCAgIB4RwRAIAJBCGohBgNAIAYoAggiCCAGKAIARgRAIAYgCEEBQQRBDBDeKAsgBigCBCAIQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAYgCEEBajYCCCABQQRqIAcQuiUgASgCBEGAgICAeEcNAAsLIAdBDGoQuSAgAUEQaiQAIAlBCGogCygCADYCACAJIAIpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgBiACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgCRDVKyAJQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1SsgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEEQRAQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAuvFAIPfwN+IwBB0AFrIgUkACAFQYgBaiIJIAJBAEEEQQgQoBggBSgCjAEhBgJAIAUoAogBQQFHBEAgBUEANgIgIAUgBSgCkAE2AhwgBSAGNgIYIAkgAkEAQQRBDBCgGCAFKAKMASEGIAUoAogBQQFHBEAgBUEANgIsIAUgBSgCkAE2AiggBSAGNgIkIAEgAkECdGohDiACRQ0CIAVBqAFqIRIgASEJA0AgAyALQRRsakEAIAQgC0sbQQAgAxshBgJ/AkAgCSgCACIHEJM2IgIEQCAGDQEgAiEGC0EADAELIAVBiAFqIAIgBhDKIiAFQdgAaiAFQZgBaigCADYCACAFQdAAaiAFQZABaikCADcDACAFIAUpAogBNwNIIAVByABqIQZBAQshEwJAAkACQAJAIAcoAjwgBygCQCIMKAIIQQFrQXhxakEIaiIPIAwoAiQRBAAiEEEDdiAQQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIghBwAAQ0TQEQAJAAkAgCEUEQEHAACEKDAELIAhBwAAQrTYiCkUNAQsgBUIANwJoIAUgCjYCZCAFIAg2AmAgBUHAADYCXCACBEBBACERIAIgCEsEQCAFQdwAaiAIQQF0EOgZIAUoAmghESAFKAJkIQoLIAIEQCAKIBFqQQAgAvwLAAsgBSACNgJoCyAFIBA2AmwgBkUNAiAFQYgBaiAGEMg0IAcoAiBBAnYhAiAHKAIcIQgDQAJAIAUpA7ABIhVQRQRAIAUpA7gBIRQMAQsDQAJ+AkAgBSkDmAEiFEIDUgRAAkACQAJAIBRCAlENACAFIBRQrUIBhjcDmAEgFKdBAXFFDQAgBSAFKQOgATcDyAEMAQsgBSgCqAFFDQEgBUHAAWogEhC2KiAFKQPAASEUCyAUQgBSDQILIAVCAzcDmAELIAUpA4gBIhRCAlENCCAFQgA3A4gBIAUpA5ABDAELIAUpA8gBCyEVIBSnQQFxRQ0GIAUgBSkDuAFCQH0iFDcDuAEgBSAVNwOwASAVUA0ACwsgBSAVQgEgFXoiFoaFNwOwAQJAIAIgFqcgFKdqIgZLBEAgCCAGQQJ0aigCACEGIAVBEGogBUHcAGoQhj0gBkEDdiIHIAUoAhQiCkkNASAHIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAHaiIHIActAABBASAGQQdxdHI6AAAMAAsAC0HAACAIEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAcoAiAiBkEESQ0AIAcoAhwhAiAGQXxxIQYDQCACKAIAIQcgBUEIaiAFQdwAahCGPSAHQQN2IgggBSgCDCIKTw0CIAUoAgggCGoiCCAILQAAQQEgB0EHcXRyOgAAIAJBBGohAiAGQQRrIgYNAAsLIAVBiAFqIgIgBUHcAGoiBhCGFCAGEM8vIAVBMGogDyAMIAIQjQEgBSgCOCEGIAUoAiwiAiAFKAIkRgRAIAVBJGpBmLSDARCQKAsgBSgCKCACQQxsaiIHIAUpAjA3AgAgB0EIaiAFQThqKAIANgIAIAUgAkEBajYCLCAFKAIgIgIgBSgCGEYEQCAFQRhqQai0gwEQmygLIAUoAhwgAkEDdGoiByAMNgIEIAcgDzYCACAFIAJBAWo2AiAgBSgCiAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiAFqEPseCyATRQ0BIAUoAkgiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAVByABqEPseDAELIAggCkHQsoMBEMMhAAsgC0EBaiELIAYgDWohDSAJQQRqIgkgDkcNAAsMAgsgBiAFKAKQAUH4s4MBEP0vAAsgBiAFKAKQAUHos4MBEP0vAAsgBUGsAWoiCkJ/IA2tQoABfHkiFIinQQFqIgJBfyACG0Gcs4MBEKIaIAUgFD4CqAEgBUKXkpyq27a1wj83A6ABIAVC3aHxy/y2itZANwOYASAFQuyYpKfz2Zmqvn83A5ABIAVC96bAxuO8iJTFADcDiAEgBUHcAGoiBiANQQBBBEEIEKAYIAUoAmAhAiAFKAJcQQFHBEAgBUEANgJEIAUgBSgCZDYCQCAFIAI2AjwgBSgCJCEDIAUoAighAiAFKAIsIQQgBUIANwJ4IAUgAiAEQQxsajYCdCAFIAM2AnAgBSACNgJsIAUgAjYCaCAFQQA2AmQgBSAONgJgIAUgATYCXCAFIAVBPGo2AoQBIAUgBUGIAWo2AoABIAVByABqIQQjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAZBLPwKAAAgAyADNgJMIANBFGohCSMAQdAAayICJAAgAkEUaiABELslAkACQAJAIAIoAhRBgICAgHhHBEAgAkEgaiIHQQRBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgggAikCFDcCACAIQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAINgIMIAIgBjYCCCAHIAFBMPwKAAAjAEEQayIBJAAgAUEEaiAHELslIAEoAgRBgICAgHhHBEAgAkEIaiEGA0AgBigCCCIIIAYoAgBGBEAgBiAIQQFBBEEMEN4oCyAGKAIEIAhBDGxqIgwgASkCBDcCACAMQQhqIAFBDGooAgA2AgAgBiAIQQFqNgIIIAFBBGogBxC7JSABKAIEQYCAgIB4Rw0ACwsgB0EMahC5ICABQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgAgAUEMahC5IAsgAkHQAGokAAwBCyAGIAIoAihBiPmDARD9LwALAkAgAygCAEGTgICAeEcEQCAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAJELArIAlBBEEMEOAeDAELIAQgAykCFDcCBCAEQZOAgIB4NgIAIARBDGogA0EcaigCADYCAAsgA0HQAGokACAFQcgBaiIBIAVB1ABqKAIANgIAIAUgBSkCTDcDwAECQCAFKAJIIgJBk4CAgHhHBEAgBSgCWCEDIAAgBSkDwAE3AgggACADNgIUIAAgAjYCBCAAQQE2AgAgAEEQaiABKAIANgIADAELIAVB0ABqIgMgBUHIAWooAgA2AgAgBSAFKQPAATcDSCAFQdwAaiAFKAIcIAUoAiAgBSgCQCAFKAJEEK8CIAUoAmQhASAFKAJgIQIgBSgCXCIEQZOAgIB4RwRAIAAgBSkCaDcCECAAIAE2AgwgACACNgIIIAAgBDYCBCAAQQE2AgAgBUHIAGoiABCwKyAAQQRBDBDgHgwBCyAAIAUpA0g3AgQgAEEMaiADKAIANgIAIAAgATYCFCAAIAI2AhAgAEEANgIACyAFQTxqQQRBCBDgHiAKQQRBEBDgHiAFQRhqQQRBCBDgHiAFQdABaiQADwsgAiAFKAJkQYi0gwEQ/S8AC5ITAgl/AX4jAEHwAGsiAiQAAkACQAJAAn8CQAJAAkACQAJAAkACQCAAIAFBKxCcFEUEQCAAIAFBLRCcFEUNAQsCQCABQQFNBEAgAUEBRg0BDAwLIAAsAAFBv39MDQsLIAIgAUEBayIDNgIoIAJBADYCJCACIAM2AiAgAkEtNgIYIAJBLTYCLCACQQE6ADAgAiAAQQFqIgM2AhwgAkHIAGogAkEYahDqDiACKAJIQQFHDQggAigCTCIGQQNNDQggBkEBaiIFRQ0IIAEgBUsiCg0BIAEgBUYNAgwJCwJAAkACQAJAIAFBCk0EQCACQSBqQQA7AQAgAkIANwMYIAIgADYCSCACIAAgAWo2AkwgAkHIAGoQgzsiA0UNDEEKIAMgA0EKTxshBEEAIQMDQCACQRhqIANqIAAgA2otAABBMGsiBToAACAFQf8BcUEKSSADQQ9xdCAGciEGIAQgA0EBaiIDRw0ACyACLQAcIgBB/QFHDQJBACEEIAZB//8DcSIAQa4DSw0BIABBrwFGDQMgAEHvAkcNDCACLQAfQf0BRw0MIAItACAhACACLQAeIAItAB1BCmxqDAsLIAJBGGpBASAAIAEQggMgAigCGEGTgICAeEYEQCACQegAaiACQSRqKAIANgIAIAIgAikCHDcDYCACQcgAaiACQRxqQQAQ9xEgAigCSCIEDQxB5MKAAUErQZDDgAEQyyQACyACQdgAaiACQShqKAIANgIAIAJB0ABqIAJBIGopAgA3AwAgAiACKQIYIgs3A0ggC6dBk4CAgHhGBEAgAigCTCEEDAwLIAJByABqEIgRDAYLIABBrwNGDQIgAEHvBkcNCiACLQAfQf0BRw0KIAItACEgAi0AIEEKbGohACACLQAeIAItAB1BCmxqDAkLQQAhBCABQQhHIAZB//8DcUH/AUdyDQkgAi0AGyACLQAZQeQAbCACLQAYQegHbGogAi0AGkEKbGpqQf//A3EgAi0AHSAAQQpsakH/AXEgAi0AHyACLQAeQQpsakH/AXEQjichBAwJCyACLQAeQf0BRw0IIAItAB8hAAwGCyACLQAeQf0BRw0HIAItACAgAi0AH0EKbGohAAwFCyAAIAVqLAAAQb9/TA0HCwJAAkACQAJAAkACQCAALQAAQStrDgMAAgECCyAFQQhLDQIMAwsgBUEJTwRAA0AgBkUNBSADLQAAQTBrIgdBCUsNCyAIrEIKfiILQiCIpyALpyIJQR91Rw0LIANBAWohAyAGQQFrIQYgCSAJIAdrIghKIAdBAEpzRQ0ACwwKCwNAIAMtAABBMGsiB0EJSw0KIANBAWohAyAIQQpsIAdrIQggBkEBayIGDQALDAMLIAAhAyAFIgZBCEkNAQsDQCAGRQ0CIAMtAABBMGsiB0EJSw0IIAisQgp+IgtCIIinIAunIglBH3VHDQggA0EBaiEDIAZBAWshBiAHQQBIIAkgByAJaiIISnNFDQALDAcLA0AgAy0AAEEwayIHQQlLDQcgA0EBaiEDIAcgCEEKbGohCCAGQQFrIgYNAAsLAkAgCkUEQCABIAVGDQEMBAsgACAFaiwAAEG/f0wNAwsgAkEQaiAAIAVqIAEgBWsQ9RIgAigCECIBRQ0FIAIoAhQhACACQQE2AkAgAkEBOwE8IAJBADYCNCACQQE6ADAgAkEtNgIsIAJBADYCJCACIAE2AhwgAkEtNgIYIAIgADYCOCACIAA2AiggAiAANgIgIAJByABqIAJBGGoQ6g4CfyACKAJIRQRAIAItAD0NAiACQQE6AD0CQCACLQA8QQFGBEAgAigCOCEGIAIoAjQhAAwBCyACKAI4IgYgAigCNCIARg0DCyAGIABrIQQgAigCHCAAagwBCyACKAI0IQAgAiACKAJQNgI0IAIoAkwgAGshBCAAIAFqCyEDAkACQAJAAkACQCAEDgIKAAELQQAhBEEBIQAgAy0AAEEraw4DCQEJAQsgAy0AAEErRgRAIARBAWshACADQQFqIQMgBEEKSQ0BDAILIAQiAEEJTw0BC0EAIQRBACEGA0AgAy0AAEEwayIBQQlLDQggA0EBaiEDIAEgBkEKbGohBiAAQQFrIgANAAsMAQtBACEGA0AgAEUNAUEAIQQgBq1CCn4iC0IgiKcNByADLQAAQTBrIgFBCUsNByADQQFqIQMgAEEBayEAIAEgC6ciBWoiBiAFTw0ACwwGCyACQQhqIQlBACEHQQAhAyMAQRBrIgQkAAJAAkACQCACQRhqIgAoAigiAQ4CAgEACyAAIAFBAWs2AiggAC0AJQ0BIAAoAgQhAyAEQQRqIAAQ6g4gBCgCBEEBRgRAIAAoAhwhASAAIAQoAgw2AhwgASADaiEHIAQoAgggAWshAwwCCyAALQAlDQEgAEEBOgAlAkAgAC0AJEEBRgRAIAAoAiAhBSAAKAIcIQEMAQsgACgCICIFIAAoAhwiAUYNAgsgBSABayEDIAAoAgQgAWohBwwBCyAAQQA2AiggAC0AJQ0AIABBAToAJQJAIAAtACRBAUYEQCAAKAIgIQUgACgCHCEBDAELIAAoAiAiBSAAKAIcIgFGDQELIAUgAWshAyAAKAIEIAFqIQcLIAkgAzYCBCAJIAc2AgAgBEEQaiQAIAIoAggiAEUNACACQcgAaiIEAn8CQAJAAkACQAJAAkACQAJAIAIoAgwiAw4CAAECCyAEQQA6AAFBAQwHC0EBIQEgAC0AAEEraw4DBQEFAQsgAC0AAEErRgRAIANBAWshASAAQQFqIQAgA0EKSQ0BDAILIAMiAUEJTw0BC0EAIQMDQCAALQAAQTBrIgVBCUsNBCAAQQFqIQAgBSADQQpsaiEDIAFBAWsiAQ0ACwwBC0EAIQMDQCABRQ0BIAAtAAAhBSADrUIKfiILQiCIpw0CIAVBMGsiA0EKTw0DIABBAWohACABQQFrIQEgAyALpyIFaiIDIAVPDQALIARBAjoAAUEBDAMLIAQgAzYCBEEADAILIAVBMGtB/wFxQQpPDQAgBEECOgABQQEMAQsgBEEBOgABQQELOgAAIAItAEhFDQELQQAhBAwECyAIIAYgAigCTBCOJyEEDAMLIAAgASAFIAFB7MWAARCjNgALIAItAB0LIQEgAi0AGyACLQAZQeQAbCACLQAYQegHbGogAi0AGkEKbGpqQf//A3EgAUH/AXEgAEH/AXEQjichBAsgAkHwAGokACAEDwsgACABQQAgBUHcxYABEKM2AAsgACABQQEgAUHMxYABEKM2AAuSDwIHfwF+IwBB4ABrIgYkACAGIAM2AiggBiACNgIkIAZBJGoQ7hIhByAGKAIoIQwgBigCJCELAkACQAJAAkACQAJAAkACQCAHQT5MBEAgB0EjRg0BIAdBL0YNAgwGCyAHQT9GDQIgB0HcAEYNASAHQYCAxABHDQUCQCAFKAIIQQFGBEAgBSgCFCEHIAUoAgwiCUUEQEEAIQkMAgsCQCAFKAIYIgIgCU0EQCACIAlHDQEMAwsgByAJaiwAAEG/f0oNAgsgByACQQAgCUGwicQAEKM2AAsgBSgCGCEJIAUoAhQhBwsgASAHIAcgCWoQgSYgAEEANgIIIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgACAFKQI0NwI0IABBPGogBUE8aikCADcCACAAQcQAaiAFQcQAai0AADoAACAAIAUoAjA2AjAgACAFKQIANwIAIAAgBSkCIDcCICAAIAUpAig3AiggACAFKAIcNgIcDAYLIAZBJGoiBCABQST8CgAAIAAgBCAFIAIgAxCPEAwFCyADIQcgAiEJA0AgBiAHNgIoIAYgCTYCJCAGQSRqEO4SIgpB3ABHIApBL0dxDQIgCEEBaiEIIAYoAighByAGKAIkIQkMAAsACwJ/IAUoAgBFBEAgBUEMaiAFKAIIDQEaIAUoAhghCSAFKAIUIQcMAwsgBUEEagsgBSgCFCEHKAIAIglFBEBBACEJDAILAkAgBSgCGCIIIAlNBEAgCCAJRg0DDAELIAcgCWosAABBv39KDQILIAcgCEEAIAlBlJXEABCjNgALAkAgCEEBTQRAIAUoAhQhAwJAIAUoAjAiCEUNACAFKAIYIgIgCE0EQCACIAhGDQEMAwsgAyAIaiwAAEG/f0wNAgsgASADIAMgCGoQgSYgASgCCCECIAFBARDYLSABKAIEIAEoAghqQS86AAAgASACQQFqNgIIIAZBAToAJCAGQRhqIAEgBCAGQSRqIgcgCCALIAwQvwEgBigCHCEDIAYoAhghAiAHIAFBJPwKAAAgACAHIAQgBSgCICAFKAIkIAUoAiggBSgCLCAFQTRqIAUvARwgBS8BHiAIIAIgAxDRBwwECwJAIAEoAhgiC0UNACABKAIcIQogBkEAOgBcIAYgAzYCWCAGIAI2AlQgBkEsaiIIQQA2AgAgBkKAgICAEDcCJCAGQSRqIAZB1ABqELocIAZB0ABqIAgoAgAiCDYCACAGIAYpAiQ3A0ggBigCTCAIQZyHxABBAhDBLiAGQcgAahDeOw0AIAtBAyAKKAIUEQAACyAFKAIUIQoCQAJAIAUoAiAiCEEBaiILRQ0AIAUoAhgiBSALTQRAIAUgC0YNAQwCCyAKIAtqLAAAQb9/TA0BCyABIAogCiALahCBJiAGIAM2AiggBiACNgIkQZyHxABBAiAGQSRqIgUQhRUEQCAGKAIoIQMgBigCJCECIAUgAUEk/AoAACAAIAUgAiADIAQgCBCUAgwFCyAGQSRqIgIgAUEk/AoAACAAIAIgCSAHIAQgCBCUAgwECyAKIAVBACALQZSVxAAQozYACyADIAJBACAIQZSVxAAQozYACyABIAcgByAJahCBJiAGQSRqIAEgBCAFKAIgIgQgAiADEM4RIAYoAiQiA0ECRgRAIAYtACghAiAAQQI2AgAgACACOgAEIAEQ3jsMAgsgBikCKCENIAYoAjAhAiAAIAM2AgAgACACNgIMIAAgBDYCICAAIA03AgQgAEEYaiABQQhqKAIANgIAIAAgASkCADcCECAAIAUpAjQ3AjQgAEE8aiAFQTxqKQIANwIAIABBxABqIAVBxABqLQAAOgAAIAAgBSgCHDYCHCAAIAUpAiw3AiwgACAFKQIkNwIkDAELAkACQCAFKAIABEAgBUEEaiEHDAELIAUoAggEQCAFQQxqIQcMAQsgBSgCFCEJIAUoAhgiCCEHDAELIAUoAhghCCAFKAIUIQkgBygCACIHRQRAQQAhBwwBCwJAIAcgCE8EQCAHIAhHDQEgByEIDAILIAcgCWosAABBv39KDQELDAILIAEgCSAHIAlqEIEmIAEgBCAFKAIwIgoQjwsCQAJAIAogASgCCEcNAAJAIAUoAiAiB0UNACAHIAhPBEAgByAIRg0BDAMLIAcgCWosAABBv39MDQILIAkgBxCPJEH/AXFBAkYEQCAGIAM2AiggBiACNgIkIAZBJGoQ7hJBgIDEAEYNAQsgASgCCCEHIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAHQQFqNgIICyAGIAM2AiggBiACNgIkAn8gBkEkaiIHEO4SQS9HBEAgBkEBOgAkIAZBEGogASAEIAcgCiACIAMQvwEgBigCECEIIAYoAhQMAQsgBigCKCEDIAYoAiQhAiAGQQE6ACQgBkEIaiABIAQgBkEkaiAKIAIgAxC/ASAGKAIIIQggBigCDAshAyAGQSRqIgIgAUEk/AoAACAAIAIgBCAFKAIgIAUoAiQgBSgCKCAFKAIsIAVBNGogBS8BHCAFLwEeIAogCCADENEHDAELDAELIAZB4ABqJAAPCyAJIAhBACAHQZSVxAAQozYAC6AUAg9/A34jAEHQAWsiBSQAIAVBiAFqIgkgAkEAQQRBCBCgGCAFKAKMASEGAkAgBSgCiAFBAUcEQCAFQQA2AiAgBSAFKAKQATYCHCAFIAY2AhggCSACQQBBBEEMEKAYIAUoAowBIQYgBSgCiAFBAUcEQCAFQQA2AiwgBSAFKAKQATYCKCAFIAY2AiQgASACQQJ0aiEOIAJFDQIgBUGoAWohEiABIQkDQCADIAtBFGxqQQAgBCALSxtBACADGyEGAn8CQCAJKAIAIgcQkzYiAgRAIAYNASACIQYLQQAMAQsgBUGIAWogAiAGEMoiIAVB2ABqIAVBmAFqKAIANgIAIAVB0ABqIAVBkAFqKQIANwMAIAUgBSkCiAE3A0ggBUHIAGohBkEBCyETAkACQAJAAkAgBygCPCAHKAJAIgwoAghBAWtBeHFqQQhqIg8gDCgCJBEEACIQQQN2IBBBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiCEHAABDRNARAAkACQCAIRQRAQcAAIQoMAQsgCEHAABCtNiIKRQ0BCyAFQgA3AmggBSAKNgJkIAUgCDYCYCAFQcAANgJcIAIEQEEAIREgAiAISwRAIAVB3ABqIAhBAXQQ6BkgBSgCaCERIAUoAmQhCgsgAgRAIAogEWpBACAC/AsACyAFIAI2AmgLIAUgEDYCbCAGRQ0CIAVBiAFqIAYQyDQgBygCHCEIIAcoAiAhAgNAAkAgBSkDsAEiFVBFBEAgBSkDuAEhFAwBCwNAAn4CQCAFKQOYASIUQgNSBEACQAJAAkAgFEICUQ0AIAUgFFCtQgGGNwOYASAUp0EBcUUNACAFIAUpA6ABNwPIAQwBCyAFKAKoAUUNASAFQcABaiASELYqIAUpA8ABIRQLIBRCAFINAgsgBUIDNwOYAQsgBSkDiAEiFEICUQ0IIAVCADcDiAEgBSkDkAEMAQsgBSkDyAELIRUgFKdBAXFFDQYgBSAFKQO4AUJAfSIUNwO4ASAFIBU3A7ABIBVQDQALCyAFIBVCASAVeiIWhoU3A7ABAkAgAiAWpyAUp2oiBksEQCAGIAhqLQAAIQYgBUEQaiAFQdwAahCGPSAFKAIUIgogBkEDdiIHSw0BIAcgCkHQsoMBEMMhAAsgBiACQci0gwEQwyEACyAFKAIQIAdqIgcgBy0AAEEBIAZBB3F0cjoAAAwACwALQcAAIAgQoz0AC0HgsoMBQSkgBUGIAWpBrLODAUGMs4MBENUeAAsgBygCICIGRQ0AIAcoAhwhAgNAIAItAAAhByAFQQhqIAVB3ABqEIY9IAUoAgwiCiAHQQN2IghNDQIgBSgCCCAIaiIIIAgtAABBASAHQQdxdHI6AAAgAkEBaiECIAZBAWsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgcgBSkCMDcCACAHQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIHIAw2AgQgByAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAlBBGoiCSAORw0ACwwCCyAGIAUoApABQfizgwEQ/S8ACyAGIAUoApABQeizgwEQ/S8ACyAFQawBaiIKQn8gDa1CgAF8eSIUiKdBAWoiAkF/IAIbQZyzgwEQohogBSAUPgKoASAFQpeSnKrbtrXCPzcDoAEgBULdofHL/LaK1kA3A5gBIAVC7Jikp/PZmaq+fzcDkAEgBUL3psDG47yIlMUANwOIASAFQdwAaiIGIA1BAEEEQQgQoBggBSgCYCECIAUoAlxBAUcEQCAFQQA2AkQgBSAFKAJkNgJAIAUgAjYCPCAFKAIkIQMgBSgCKCECIAUoAiwhBCAFQgA3AnggBSACIARBDGxqNgJ0IAUgAzYCcCAFIAI2AmwgBSACNgJoIAVBADYCZCAFIA42AmAgBSABNgJcIAUgBUE8ajYChAEgBSAFQYgBajYCgAEgBUHIAGohBCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBkEs/AoAACADIAM2AkwgA0EUaiEJIwBB0ABrIgIkACACQRRqIAEQuSUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgdBBEEAQQRBDBCgGCACKAIkIQYgAigCIEEBRg0CIAIoAigiCCACKQIUNwIAIAhBCGogAkEcaigCADYCACACQRBqIgtBATYCACACIAg2AgwgAiAGNgIIIAcgAUEw/AoAACMAQRBrIgEkACABQQRqIAcQuSUgASgCBEGAgICAeEcEQCACQQhqIQYDQCAGKAIIIgggBigCAEYEQCAGIAhBAUEEQQwQ3igLIAYoAgQgCEEMbGoiDCABKQIENwIAIAxBCGogAUEMaigCADYCACAGIAhBAWo2AgggAUEEaiAHELklIAEoAgRBgICAgHhHDQALCyAHQQxqELkgIAFBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIADAELIAlBADYCCCAJQoCAgIDAADcCACABQQxqELkgCyACQdAAaiQADAELIAYgAigCKEGI+YMBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAQgAykCADcCACAEQRBqIANBEGooAgA2AgAgBEEIaiADQQhqKQIANwIAIAkQ1ysgCUEEQQwQ4B4MAQsgBCADKQIUNwIEIARBk4CAgHg2AgAgBEEMaiADQRxqKAIANgIACyADQdAAaiQAIAVByAFqIgEgBUHUAGooAgA2AgAgBSAFKQJMNwPAAQJAIAUoAkgiAkGTgICAeEcEQCAFKAJYIQMgACAFKQPAATcCCCAAIAM2AhQgACACNgIEIABBATYCACAAQRBqIAEoAgA2AgAMAQsgBUHQAGoiAyAFQcgBaigCADYCACAFIAUpA8ABNwNIIAVB3ABqIAUoAhwgBSgCICAFKAJAIAUoAkQQrwIgBSgCZCEBIAUoAmAhAiAFKAJcIgRBk4CAgHhHBEAgACAFKQJoNwIQIAAgATYCDCAAIAI2AgggACAENgIEIABBATYCACAFQcgAaiIAENcrIABBBEEMEOAeDAELIAAgBSkDSDcCBCAAQQxqIAMoAgA2AgAgACABNgIUIAAgAjYCECAAQQA2AgALIAVBPGpBBEEIEOAeIApBBEEQEOAeIAVBGGpBBEEIEOAeIAVB0AFqJAAPCyACIAUoAmRBiLSDARD9LwALoBQCD38DfiMAQdABayIFJAAgBUGIAWoiCSACQQBBBEEIEKAYIAUoAowBIQYCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBjYCGCAJIAJBAEEEQQwQoBggBSgCjAEhBiAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBjYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhCQNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQYCfwJAIAkoAgAiBxCTNiICBEAgBg0BIAIhBgtBAAwBCyAFQYgBaiACIAYQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiEGQQELIRMCQAJAAkACQCAHKAI8IAcoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyIIQcAAENE0BEACQAJAIAhFBEBBwAAhCgwBCyAIQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAINgJgIAVBwAA2AlwgAgRAQQAhESACIAhLBEAgBUHcAGogCEEBdBDoGSAFKAJoIREgBSgCZCEKCyACBEAgCiARakEAIAL8CwALIAUgAjYCaAsgBSAQNgJsIAZFDQIgBUGIAWogBhDINCAHKAIcIQggBygCICECA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAYgCGosAAAhBiAFQRBqIAVB3ABqEIY9IAZBA3YiByAFKAIUIgpJDQEgByAKQdCygwEQwyEACyAGIAJByLSDARDDIQALIAUoAhAgB2oiByAHLQAAQQEgBkEHcXRyOgAADAALAAtBwAAgCBCjPQALQeCygwFBKSAFQYgBakGss4MBQYyzgwEQ1R4ACyAHKAIgIgZFDQAgBygCHCECA0AgAiwAACEHIAVBCGogBUHcAGoQhj0gB0EDdiIIIAUoAgwiCk8NAiAFKAIIIAhqIgggCC0AAEEBIAdBB3F0cjoAACACQQFqIQIgBkEBayIGDQALCyAFQYgBaiICIAVB3ABqIgYQhhQgBhDPLyAFQTBqIA8gDCACEI0BIAUoAjghBiAFKAIsIgIgBSgCJEYEQCAFQSRqQZi0gwEQkCgLIAUoAiggAkEMbGoiByAFKQIwNwIAIAdBCGogBUE4aigCADYCACAFIAJBAWo2AiwgBSgCICICIAUoAhhGBEAgBUEYakGotIMBEJsoCyAFKAIcIAJBA3RqIgcgDDYCBCAHIA82AgAgBSACQQFqNgIgIAUoAogBIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgBahD7HgsgE0UNASAFKAJIIgIgAigCACICQQFrNgIAIAJBAUcNASAFQcgAahD7HgwBCyAIIApB0LKDARDDIQALIAtBAWohCyAGIA1qIQ0gCUEEaiIJIA5HDQALDAILIAYgBSgCkAFB+LODARD9LwALIAYgBSgCkAFB6LODARD9LwALIAVBrAFqIgpCfyANrUKAAXx5IhSIp0EBaiICQX8gAhtBnLODARCiGiAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgYgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAGQSz8CgAAIAMgAzYCTCADQRRqIQkjAEHQAGsiAiQAIAJBFGogARC3JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiB0EEQQBBBEEMEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCIIIAIpAhQ3AgAgCEEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCDYCDCACIAY2AgggByABQTD8CgAAIwBBEGsiASQAIAFBBGogBxC3JSABKAIEQYCAgIB4RwRAIAJBCGohBgNAIAYoAggiCCAGKAIARgRAIAYgCEEBQQRBDBDeKAsgBigCBCAIQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAYgCEEBajYCCCABQQRqIAcQtyUgASgCBEGAgICAeEcNAAsLIAdBDGoQuSAgAUEQaiQAIAlBCGogCygCADYCACAJIAIpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgBiACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgCRDXKyAJQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1ysgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEEQRAQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAueDwIEfwF+IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEG4ps4ANgI4IARCATcCRCAEQbkHNgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARDJDyAELQBAIQYgBCgCPCECIAQoAjgiBUEERwRAIAAgBCkAQTcACSAAQRBqIARByABqKAAANgAAIAAgBjoACCAAIAI2AgQgACAFNgIADAwLIAJBAEoEQCADQQFrIQMDQCAEQThqIAEgBiADEMkCIAQoAjgiBUEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBTYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqELMeIAQtAEAhBiAEKAI8IQIgBCgCOCIFQQRHBEAgACAEKQBBNwAJIABBEGogBEHIAGooAAA2AAAgACAGOgAIIAAgAjYCBCAAIAU2AgAMCwsgAkEASgRAIANBAWshAwNAIARBOGogASAGIAMQyQIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIADA0LIAJBAWsiAg0ACwsgABCzHgwKCyAEQThqELMeIAQpAjwhCCAEKAI4IgJBBEcEQCAAIAQpAkQ3AgwgACAINwIEIAAgAjYCAAwKCwJAAkAgCKciAkEASgRAIAhCIIinIgZB/wFxQRBGDQIgCEIoiKciBUH/AXFBEEYNASADQQFrIQMDQCAEQThqIAEgBiADEMkCIAQoAjgiB0EERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBzYCAAwOCyAEQThqIAEgBSADEMkCIAQoAjgiB0EERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBzYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLC0H8ps4AQSxBqKfOABDLJAALQcCmzgBBKkHsps4AEMskAAsgBEE4aiABEPAnIARBKGoiAiAEQcQAaigCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgIgg3AwggCKdBgICAgHhHBEAgBEEIahDeOwsgBEE4aiABENMJIARBKGoiAiAEQcQAaikCADcDACAEQTBqIgYgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQcgBEE8aiEDA0AgBEEYaiAGKAIAIgU2AgAgBEEQaiACKQMANwMAIAQgBCkDIDcDCCAFQf8BcUUNAiAEQThqIAEgBSAHEMkCIAQoAjgiBUEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBTYCACAEQQhqEIYwDAwLIARBCGoQhjAgBEE4aiABENMJIAIgA0EIaikCADcDACAGIANBEGooAgA2AgAgBCADKQIANwMgIAQoAjhFDQALCyAAIAQpAyA3AgAgAEEQaiAGKAIANgIAIABBCGogAikDADcCAAwJCyAEQQhqEIYwIAAgARCoKQwICyAEQThqIAEQwhUgBCgCOEEERwRAIAAgBCkCODcCACAAQRBqIARByABqKAIANgIAIABBCGogBEFAaykCADcCAAwICyAEQShqIARBxABqKAIANgIAIAQgBCkCPDcDICAEQSBqEN47IABBBDYCAAwHCyAEQThqIAEQwBwgBCgCOEEBRgRAIAAgBCkCPDcCACAAQRBqIARBzABqKAIANgIAIABBCGogBEHEAGopAgA3AgAMBwsgAEEENgIADAYLIARBOGogARDAHAJAIAQoAjhFDQAgBCgCPCIBQQRGDQAgBCkDQCEIIAAgBCkDSDcCDCAAIAg3AgQgACABNgIADAYLIABBBDYCAAwFCyAEQThqIAEQwBwCQCAEKAI4RQ0AIAQoAjwiAUEERg0AIAQpA0AhCCAAIAQpA0g3AgwgACAINwIEIAAgATYCAAwFCyAAQQQ2AgAMBAsgASgCECICQQdLBEAgAEEENgIAIAEgAkEIazYCECABIAEoAgxBCGo2AgwMBAtBCCACQcSzzgAQsDsACyAEQThqIAEQkhggBCgCOEEERwRAIAAgBCkCODcCACAAQRBqIARByABqKAIANgIAIABBCGogBEFAaykCADcCAAwDCyAAQQQ2AgAMAgsgBEE4aiABENoQIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMAgsgAEEENgIADAELIAQgAjoANyAEQQE2AjwgBEHQp84ANgI4IARCATcCRCAEQboHNgIkIAQgBEEgajYCQCAEIARBCGo2AiAgBCAEQTdqNgIIIABBBGogBEE4ahCZDiAAQQA6ABAgAEEBNgIACyAEQdAAaiQAC4kVAgp/BH4jAEGQA2siAiQAIAFB8ABqIQdBASEEAkACQAJAIAEoAnAiA0UEQAJAAkAgASgCbCABKAI4RwRAIAJBqAJqQSVBAEEBQQEQoBggAigCrAIhAyACKAKoAkEBRgRAIAMgAigCsAJB8MXDABD9LwALIAIoArACIgRB2cTDAEEl/AoAACAAQSU2AgwgACAENgIIIAAgAzYCBCAAQQA2AgAMAQsgASkCMCEMIAFCgICAgIABNwMwIAJBCGogAUE4aiIDKAIANgIAIANBADYCACACIAw3AwAgASgCYCIDIAMoAgAiBEEBajYCACAEQQBIDQUgAkGoAmohBCMAQRBrIgUkACAFQQRqIAMoAhBBAEEIQcACEKAYIAUoAgghBiAFKAIEQQFGBEAgBiAFKAIMQeT4zwAQ/S8ACyAFKAIMIQggBEIANwMQIARCADcDACAEQRhqQgA3AwAgBCADNgI8IARBADsBOCAEQoCAgICAgICAgH83AyggBCAINgIkIAQgBjYCICAFQRBqJAAgAkHoAWohAyAEKAIoIgYEQCAEKAIkIQUDQCAFEPASIAVBwAJqIQUgBkEBayIGDQALCyAEQSBqQQhBwAIQ4B4gBEEoaiACQQhqKAIANgIAIAQgAikCADcCICADIARBwAD8CgAAIAJBsAFqIAJB8AFqKQMANwMAIAIgAikD6AE3A6gBIAIgASkDGDcDgAIgAkHAAWogAkGAAmpBKPwKAAAgAiABKQMIQgAgASgCABs3A7gBAkAgASgCZEEIaiIFQfgAakEAIAUoAnhBgICAgHhHGyIFBEAgAyAFEJMYDAELIANBgICAgHg2AgALIAJBqAFqIgZBLGohBSAGKAIsQYCAgIB4RwRAIAVBBEEIEOAeCyAFIAMpAgA3AgAgBUEIaiADQQhqKAIANgIAIAQgBkHAAPwKAAAgAkEBOwHgAiACIAEvAXQ7AeICIAJB+AFqIAJBuAJqQTD8CgAAIAJCATcD6AEgAiABKQMgNwPwASACQegAaiEFIwBBMGsiBCQAAkAgAygCPCgCECIIIAMoAigiBkYEQCAFIANBwAD8CgAADAELIAQgCDYCGCAEIAY2AhwgBEECNgIEIARBkPnPADYCACAEQgI3AgwgBEE7NgIsIARBOzYCJCAEIARBIGo2AgggBCAEQRxqNgIoIAQgBEEYajYCICAFQQxqIAQQmQ4gBUICNwMAIAVBADYCCCAGBEAgAygCJCEFA0AgBRDwEiAFQcACaiEFIAZBAWsiBg0ACwsgA0EgakEIQcACEOAeIAMoAixBgICAgHhHBEAgA0EsakEEQQgQ4B4LIANBPGoiAygCACIFIAUoAgAiBUEBazYCACAFQQFHDQAgAxCGHwsgBEEwaiQAIAJB2ABqIgMgAkH4AGopAwA3AwAgAkHgAGoiBCACQYABaikDADcDACACIAIpA3A3A1AgAikDaCIMQgJSDQEgACACKQNQNwMAIABBEGogBCkDADcDACAAQQhqIAMpAwA3AwALIAEoAmAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAFB4ABqEIYfCyABKAJkIgAgACgCACIAQQFrNgIAIABBAUYEQCABQeQAahCuIAsCQCAHKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAcQ7h0LIAFBMGoiABCfLCAAEPM7IAFBPGoiABCGKSAAEOg7IAFByABqIgAQ1x4gAEEEQcwAEOAeIAFB1ABqIgAQ5ScgAEEEQRgQ4B4MAgsgAkHIAGogAkGgAWopAwA3AwAgAkFAayACQZgBaikDADcDACACQThqIAJBkAFqKQMANwMAIAJBIGoiAyACQdgAaikDADcDACACQShqIAJB4ABqKQMANwMAIAIgAikDiAE3AzAgAiACKQNQNwMYIAIgDDcDECACQegBaiACQTBqEMABIAMpAwAhDAJAIAIoAjxBgICAgHhHBEAgAkGoAmogAkE8ahCTGAwBCyACQYCAgIB4NgKoAgsgAikDKCENIAIoAkwiBCAEKAIAIgNBAWo2AgAgA0EASA0DIAJBsAFqIgUgAkHwAWooAgA2AgAgAkHwAGoiBiACQbACaigCADYCACACIAIpAugBNwOoASACIAIpAqgCNwNoIAIvAUohCCACLwFIIQkgAikDGCEOIAIpAxAhDwJAAkBByABBCBCtNiIDBEAgAyANNwMgIAMgDDcDGCADIA43AxAgAyAPNwMIIANCgYCAgBA3AwAgAyACKQOoATcDKCADIAIpA2g3AjQgAyAENgJEIAMgCDsBQiADIAk7AUAgA0EwaiAFKAIANgIAIANBPGogBigCADYCAAJAIAcoAgAiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgBxDuHQsgASADNgJwIAEoAighBSABQQA2AiggBUUNASABKAIsIQMgASgCaCEGIAJBqAJqIgggAkEQakHAAPwKAAAgAkHwAmogAUHEAGooAgA2AgAgAkH8AmogAUHQAGooAgA2AgAgAkGMA2ogAUHcAGooAgA2AgAgAiAGNgKAAyACIAEpAjw3A+gCIAIgASkCSDcC9AIgAiABKQJUNwKEAyMAQfAAayIEJAAgBCAGNgJgIARBCGoiCSAIQcAA/AoAACAEQdAAaiACQegCaiIIQQhqKAIANgIAIARB3ABqIAJB9AJqIgpBCGooAgA2AgAgBEHsAGogAkGEA2oiC0EIaigCADYCACAEIAgpAgA3A0ggBCAKKQIANwJUIAQgCykCADcCZCACQegBaiAFIAYgCSAEQcgAaiAEQdQAaiAEQeQAaiADKAIMEQsAIAMoAgQiBgRAIAUgBiADKAIIEPg6CyAEQfAAaiQAIAIoAugBIgNBCEYNAiAAIAIpAuwBNwIEIABBFGogAkH8AWooAgA2AgAgAEEMaiACQfQBaikCADcCACAAIAM2AgAgAUHgAGoiACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABCGHwsgAUHkAGoiACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABCuIAsgAUEwaiEAAkAgBygCACIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAHEO4dCyAAEJ8sIAAQ8zsMBAtBCEHIABCjPQALIAJBEGoQ/yULIAcoAgAiA0UNAiAFRSEECyADIAMoAgAiBUEBajYCACAFQQBIDQIgAEEINgIAIAAgAzYCBCABKAJgIgAgACgCACIAQQFrNgIAIABBAUYEQCABQeAAahCGHwsgASgCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUHkAGoQriALAkAgBygCACIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAHEO4dCyABQTBqIgAQnywgABDzOyAERQ0AIAFBPGoiABCGKSAAEOg7IAFByABqIgAQ1x4gAEEEQcwAEOAeIAFB1ABqIgAQ5ScgAEEEQRgQ4B4LAkAgASgCKCIARQ0AIAEoAiwiASgCACIDBEAgACADEQMACyABKAIEIgNFDQAgACADIAEoAggQ+DoLIAJBkANqJAAPC0HAxcMAELI7CwALxg4BGn8jAEFAaiIKJAAgCkEYakIANwMAIApBEGpCADcDACAKQQhqQgA3AwAgCkIANwMAAkAgAyAETwRAIAQEQCAEQQF0IQsgAiEJA0AgCS8BACIMQRBPDQMgCiAMQQF0aiIMIAwvAQBBAWo7AQAgCUECaiEJIAtBAmsiCw0ACwsgCkE4aiAKQRhqKQMANwMAIApBMGogCkEQaikDADcDACAKQShqIApBCGopAwA3AwAgCiAKKQMANwMgIApBPmohCUEOIQ0CQAJAA0AgCS8BAARAQQEhDAJAIA1BAWoiFEECSQ0AIApBIGpBAnIhCSANIQsDQCAJLwEADQEgCUECaiEJIAxBAWohDCALQQFrIgsNAAsgFCEMCyAMIBQgByAHIBRLGyIHIAcgDEkbIQ9BAiEJQQEhCwNAIAtBAXQgCSAKai8BAGsiC0EASARAIABBfzYCAAwECyAJQQJqIglBIEcNAAsgC0EAIAFB/wFxRSANchtFBEAgCkE4akIANwMAIApBMGpCADcDACAKQShqQgA3AwAgCkIANwMgQQQhCSAKLwEiIQsDQCAKQSBqIAlqIAsgCSAKakECay8BAGoiCzsBACAJQQJqIglBIEcNAAsgBARAIARBAXQhBEEAIQsgAiEJA0ACQCAJLwEAIgdFDQAgB0EPTQRAIApBIGogB0EBdGoiByAHLwEAIgdBAWo7AQAgB0GgAkkEQCAIIAdBAXRqIAs7AQAMAgsgB0GgAkG8hf0AEMMhAAsgB0EQQayF/QAQwyEACyAJQQJqIQkgC0EBaiELIARBAmsiBA0ACwsgD0EfcSEEQQIhGUEUIRVBAiEaAkACQAJAAkAgAUH/AXEiGEEBaw4CAAECCyAEQQtPDQJBkIL9ACEaQc6C/QAhGUGBAiEVQR8hGAwBCyAEQQlLDQFBjIP9ACEaQcyD/QAhGUEgIRhBACEVC0EBIAR0IhZBAWshHyAVQQFrQf//A3EhICABQf8BcUEBayEhQQAhByAPIQ5BfyEEA0ACQCAVIAggEEEBdGovAQAiAUsEQCABQQAgASAgSSIJGyEBQQBB4AAgCRshHAwBCyABIBVrQf//A3EiASAYSQRAIBogAUEBdCIJai8BACEBIAkgGWotAAAhHAwBCyABIBhBnIT9ABDDIQALAkACQAJAAkACQAJ/AkACQAJAAkAgByASdiARaiIHIAZNBEACQEEBIAwgEmsiG3QiHUEBayAOdkEBcUEBIA50IiIgG3ZqIhMEQCAGIAdrIR4gBSAHQQJ0aiEJIB1BAnQhB0EAIQsDQCALIB5PDQIgCSABOwEAIAlBA2ogGzoAACAJQQJqIBw6AAAgByAJaiEJIAsgHWohCyATQQFrIhMNAAsLIAxBD0sNAkGAgICAeCAMQQFrdiAXaiIXQRh0IBdBgP4DcUEIdHIgF0EIdkGA/gNxIBdBGHZyciIBQQR2QY+evPgAcSABQY+evPgAcUEEdHIiAUECdkGz5syZA3EgAUGz5syZA3FBAnRyIgFBAXZB1arVqgVxIAFB1arVqgVxQQF0ciEHIBBBAWohECAKIAxBAXRqIgEgAS8BAEEBayIBOwEAAkACQCABQf//A3FFBEAgDSAMa0F/Rg0BIBBBoAJPDQYgAyAIIBBBAXRqLwEAIgFNDQcgAiABQQF0ai8BACEMCyAMIA9NDQ0gByAfcSIBIARHDQEMDQsgFw0IDAkLQQEgDCASIA8gEhsiEmsiDnQiCyAMIBRPDQYaIA0gEmtBAWohDiAKIAxBAXRqIQkgDCETA0AgCyAJLwEAayIEQQBMBEAgEyASayEODAcLIAlBAmohCSAEQQF0IQsgE0EBaiITIBRJDQALDAULIAsgHkGchf0AEMMhAAsgByAGQayE/QAQrzsACyAMQRBBvIT9ABDDIQALIBBBoAJBzIT9ABDDIQALIAEgA0HchP0AEMMhAAtBASAOdAsgFmohFgJAAkACQCAhDgIAAQILIBZBtApNDQEMCAsgFkHQBEsNBwsgASAGSQRAIAUgAUECdGoiBCAPOgADIAQgDjoAAiAEIBEgImoiETsBACABIQQMBQsgASAGQYyF/QAQwyEACyAGIBFJDQIgByAGIBFrIgFPDQEgBSARQQJ0aiAHQQJ0aiIBIBs6AAMgAUHAADoAAiABQQA7AQALIAAgFjYCCCAAIA82AgQgAEEANgIADAgLIAcgAUH8hP0AEMMhAAsgESAGQeyE/QAQrzsACyAQQaACRw0AC0GgAkGgAkGMhP0AEMMhAAsgAEEBNgIADAMLIABBfzYCAAwCCyAJQQJrIQkgDUEBayINQX9HDQALIAZFDQEgBUGAgIAKNgEAIAZBAUcEQCAAQQI2AgggBUGAgIAKNgEEIABCgICAgBA3AgAMAQtBAUEBQYCC/QAQwyEACyAKQUBrJAAPC0EAQQBB8IH9ABDDIQALIAQgA0Hggf0AELA7AAsgDEEQQcyF/QAQwyEAC+ofAjd/An4jAEEgayITJAACQCAAKAIAIgpFBEBBRCEKDAELAkAgCkEBRgRAIAEgAiAAQbgBaiAAKQPIBEIBfSAAKAKQBBCiDiIlQYh/Sw0BIABBAjYCACACICVrIQIgASAlaiEBCyAERQ0AIABB2BBqIjYgAyAEIAAoAsAREIMXRQRAIABBADYCwBEgACAAKALkEDYC9BALIAAoAowCQQFGBEAgAEGQBmogAyAEQQAQgxcaCyAAKAK8ASEKIAAoAsQEIQsgACgC3AEEQCAAQeAEaiADIAQQiQwLIABBuAFqITdBASAKdCErIABBqBRqISYgAEHUFGohLCAAQYAVaiEtIABB5AVqIRwgAEGYBGohOCABIQ0gBCEfA0ACQCALIQYgAyEQAkACQAJAAkAgHwRAQbp/IQogAkEGSQ0IIDYgOCA3IBAgECAfIAYgBiAfSxsiC2oiAxCbDgJAIAAoAvAQIgcgK2ogAyAAKALcECIOa08EQCAHIAAoAuQQRg0BC0EAIQcgAEEANgKMEiAAQQA2AvAQCwJAIBAgDmsiDiAHICtqTQRAIAAoAugQIQcMAQsgACgC6BAiByAOICtrIg5JBEAgACAONgLoECAOIQcLIAcgACgC5BBLBEAgACAHNgLkEAsgAEEANgKMEiAAQQA2AvAQCyAHIAAoAvQQSwRAIAAgBzYC9BALIAVBACAGIB9PGyEYIAAoAuwBBEAgACAQIAsQkAciBkGIf0sEQCAGIQoMCgsCQAJAIAYNAAJAIAAoAtwFDQAgHCgCBCAcKAIAa0EgSSAcKAIMIBwoAghrQQpJcUUNACAQIAsQug5FDQAgDSAQLQAAOgADIA0gC0ENdjoAAiANIBggC0EDdHJBAnI7AABBBCEGDAILIBAhF0EAIQxBACERIwBB0AJrIgkkAAJAIABB5AVqIi4gACgC0BAgACgC1BAgAEG4AWogCUEMaiAAKAK4EhCsCSIIQYh/Sw0AIAkoAgxBAkYhDiACIA1qISQgCyAQaiEwIAAoAggaIAAoAtQQIh1BjA5qITEgHUG4GWohMiAdQYgIaiEzIAAoArgSISAgACgC0BAhLyAAKALoBSI0QQhrITkgCUGgAWohOiAJQRBqITsgACgC7AEhPCAAKAL8BSEnIAAoAvgFISggACgC9AUhKSAAKALwBSE1IAAoAuwFIRlBASEUIA0hDyAAKALkBSIhIRoCQANAAn8gISA0RgRAQQEhKiA1IBlrDAELIAlByAJqIC4gGiAMQQN0aiIGEOckIAxBAWohDCA1IBlrIAkoAsgCIBFqIAYgOUYiKhsLIREgCUH/ATYCuAIgESEIAkACQAJAAkAgCSgCDA4EAwABAQILQQEhCAwCCyAgIAlBuAJqIBkgESAgQdjFABDgJUGIf0sNASAdICAgCSgCuAIQ5SMgCSgCkAFBACAOG2pBA2ohCAwBC0EAIQgLAkAgKkF/cyAMBH8gCSgCmAEgJ0EfIAwgM0EAQeCY0QBBBUEcICAQ3BUgCSgClAEgKUEjIAwgMkGgmdEAQdCZ0QBBBkEjICAQ3BVqIAkoApwBIChBNCAMIDFBoJrRAEHgmtEAQQZBNCAgENwVaiAJKAKoAkEAIBQbakEDagVBAwsgCGpBA2ogPE1xDQAgGiAMQQN0IghqQQAhFiAaIQYDQCAIQQBKBEAgCUG4AmogLiAGEOckIAhBCGshCCAGQQhqIQYgCSgCvAIgFmohFgwBCwsgD0EDaiEeICQgD2tBA2shGwJ/AkACQCARRQ0AAkACQCAJKAIMIhIOAgIAAQsgDiEHIB4gGSAREO4gDAMLIB5BA0EEIBFBgAhByAFBACAOGyIGa0kbIBFBgIABIAZrT2oiFWohBkEAIQggDkUgEkECR3JFBEAgCSgCkAEiBwRAIAYgOyAH/AoAAAsgBiAJKAKQASIIaiEGCyAkIAZrIQcCfyAVQQNGBEAgBiAHIBkgESAdEK0SDAELIAYgByAZIBEgHRCKEgsiB0EBa0GHf0sNAyAOIAcgCGoiIyARSXJFBEBBACEHIB4gGyAZIBEQ5hwMAwsgFSAjQf//AEtBBEEDICNB/wdLG2pPDQELIA4hByAeIBsgGSAREOYcDAELIBJBAyAOGyESIAYgB2ogEUEEdCEGAkACQAJAAkAgFUEEaw4CAQIACyAPIAYgEmogI0EOdGoiBjsAAyAPIAZBEHY6AAUMAgsgHiAGIBJqICNBEnRqQQhqNgAADAELIA8gI0EKdjoAByAPIAYgEmogI0EWdGpBDGo2AAMLQQAhByAeawsiCEGIf0sNAyAIRQ0AICQgCCAeaiIVa0EESA0CIAAoArwBIQYCQAJ/IAxB/wBPBEAgDEH//QFNBEAgFSAMOgABIBUgDEEIdkGAAXI6AAAgFUECagwCCyAVQf8BOgAAIBUgDEGA/gFrOwABIBVBA2oMAQsgFSAMOgAAQQEhCCAMRQRAIBQhBgwCCyAVQQFqCyEbIAZBGUshEiAbQQFqIQYCQCAUBEAgGyAJKAKYAUEEdCAJKAKUAUEGdGogCSgCnAFBAnRqOgAAIAkoAqgCIggEQCAGIDogCPwKAAALIAYgCSgCqAJqIQYMAQsgG0H8AToAAAsgBiAkIAZrIDEgKCAzICcgMiApIBogDCASEP0GIghBiH9LDQQCQCAURQ0AIAkoAqwCIhJFDQAgCCASakEESQ0CCyAGIAhqIgYgG2tBBEgNASAGIBVrIghBiH9LDQRBACEGIAhFDQELIA8gCCAVaiISIA9rIghBA3RBGGsiG0EQdjoAAiAPIBsgGEEARyAqcXJBBHI7AAAgCEGIf0sNAyAIRQ0AIAggESAWaiIWTw0AIAwgJ2ohJyAMIChqISggDCApaiEpIBEgGWohGSAWIBdqIRdBACERQQAhDCAHIQ4gBiEUIBIhDyEaCyAqRQ0ACyAOBEAgHSAvQYgI/AoAAAsgFARAQQAhCCAJKAKUAUEBa0ECSQ0CIAkoApwBQQFrQQJJDQIgCSgCmAFBA2tBfUsNAgsCQCAXIDBPDQAgMCAXayIHQQNqIgggJCAPa0sNASAPIAdBA3QgGGoiBjsAACAPIAZBEHY6AAIgBwRAIA9BA2ogFyAH/AoAAAsgCEGIf0sNAiAIIA9qIQ8gGiA0Tw0AIAlBwAJqIC9B8CNqKAIAIgw2AgAgCSAvKQLoIyI9NwO4AiA9pyEGIAkoArwCIRYDQCAaICFLBEAgISgCACEHIAlBsAJqIC4gIRDnJAJAAkAgB0EETwRAIAkgBjYCvAIgCSAWNgLAAiAHQQNrIQggFiEMDAELAn8CQAJAIAcgCSgCsAJFakEBayIHDgQEAQEAAQsgBkEBawwBCyAJQbgCaiAHQQJ0aigCAAshCCAJIAY2ArwCIAkgDCAWIAdBAUYbIgw2AsACCyAJIAg2ArgCIAYhFiAIIQYLICFBCGohIQwBCwsgHSAJKQO4AjcC6CMgHUHwI2ogCUHAAmooAgA2AgALIA8gDWshCAwBC0G6fyEICyAJQdACaiQAIAgiBkG6f0YNACAGQYh/SwRAIAYhCgwMCyAGRQ0AIAYgCyALQQcgACgC1AEiByAHQQdNG0EBa3ZrQQFqTw0AIAAgACkD0BBCIIk3A9AQDAELIAtBA2oiBiACSw0KIA0gC0ENdjoAAiANIBggC0EDdHI7AAAgCwRAIA1BA2ogECAL/AoAAAsgBiEKIAZBiH9LDQoLIAAoAtAQIgooAtwjQQJHDQQgCkEBNgLcIwwECyAAKAK4AkEBRgRAIAAgECALEJAHIgZBiH9LBEAgBiEKDAoLIAZBAUYEQCAAKALQECIGKALcI0ECRgRAIAZBATYC3CMLIAtBA2oiBiACSw0KIA0gC0ENdjoAAiANIBggC0EDdHI7AAAgC0UNAyANQQNqIBAgC/wKAAAMAwsgACgC5AUhBiAAKALoBUEAISIgE0EANgIUIBMgLTYCECAGa0EDdSIKQQVPBEAgE0EQakEAIAogACAcEIYWIBMoAhAgEygCFCIiQQJ0aiAKNgIACyATQRhqIhYgACgC0BAiBkHwI2ooAgAiCjYCACATQQhqIAo2AgAgEyAGKQLoIyI9NwMQIBMgPTcDACAsQQBBLPwLACAiRQRAIAAgHCATQRBqIBMgDSACIBAgCyAYQQAQrQkhCgwEC0EAIRIgJiAcQQAgLSgCABCvFUEAIRcgDSEIQQAhCiACIQ4DQCAXICJNBEAgJhDsHyEaIAAoAqgUIgZBBmohDyAAKAKsFCAGa0EDdSEUQQAhBkEAIQcDQCAGIBRHBEAgByAPLwEAakEDaiEHIAAoAtAUIAZGBEAgB0GAgARqIAcgACgCzBRBAkYbIQcLIA9BCGohDyAGQQFqIQYMAQsLIAcgGmohBgJ/IBcgIkYEQCALIBJrIQcgGAwBCyAsIBwgLSAXQQJ0aiIHKAIAIAdBBGooAgAQrxUgBiEHQQALIRQgACAmIBNBEGogEyAIIA4gECAHIBRBARCtCSIUQYh/SwRAIBQhCgwGCyAmICxBLPwKAAAgBiASaiESIBdBAWohFyAKIBRqIQogDiAUayEOIAggFGohCCAHIBBqIRAMAQsLIAAoAtAQIgYgEykDEDcC6CMgBkHwI2ogFigCADYCAAwDCwJ/IA1BA2ohCCACQQNrIQ5BACEHAkACQAJAAkACQEEBIAAgECALEJAHIgZBAUZBAnQgBkGJf08bDgUABAQEAQQLIAAoAswFBEAgABCKDSAAIAApA9AQQiCJNwPQEEEADAULIABB5AVqIAAoAtAQIAAoAtQQIABBuAFqIAggDiALIAAoArgSIAAoAggQqwohBwJAIAAoAtwFIAdBGEtyDQAgECALELoORQ0AIAggEC0AADoAAEEBIQcMAQsgB0ECa0GHf0kNAQsgACgC0BAhBgwBCyAAKALUECEGIAAgACgC0BA2AtQQIAAgBjYC0BALIAYoAtwjQQJGBEAgBkEBNgLcIwsgByEGCyAGCyIGQYh/SwRAIAYhCgwJCyANAn8CQAJAAkAgBg4CAAECCyALQQNqIgYgAksNCyANIAtBDXY6AAIgDSAYIAtBA3RyOwAAIAsEQCAIIBAgC/wKAAALIAYiCkGJf0kNBwwLCyAYIAtBA3RyQQJyDAELIAZBA3QgGHJBBHILIgo7AAAgDSAKQRB2OgACIAZBA2ohCgwECyAFRSABIA1PckUEQCAAQQM2AgALIA0gAWshCgwECyAGIQoLIApBiX9JDQEMBQsgBiEKCyAAQQA2AtwFIAIgCmshAiAKIA1qIQ0gHyALayEfDAELCyAKQYh/Sw0BIAAgACkD0AQgBK18Ij43A9AEIAAgACkD2AQgCiAlaiIBrXw3A9gEQbh/IAEgACkDyAQiPSA+QgF8VBsgASA9QgBSGyEKDAELICUhCgsgE0EgaiQAIAoLgg4BB34gACkDCCIDIAKtIgeFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIAd8Qq3+1eTUhf2o2AB+IQggACkDGCEHIAApAxAhBiAAKQMAIQQCQCACQQhNBEACfiACQQFNBEBCACACQQFHDQEaIAExAAAiBQwBCyABIAJqIQAgAkEDTQRAIAEzAAAhBSAAQQFrMQAADAELIAE1AAAhBSAAQQRrNQAACyEDIAQgCHwgBSAGhSIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEIAMgB4UiBkJ/hX4iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUgBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAHQgiIQoCAgPgPgyAHQhiIQoCA/AeDhCAHQiiIQoD+A4MgB0I4iISEhCAFfoVCF4khAwwBCyACQRBNBEAgBCAIfCABKQAAIAaFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASACakEIaykAACAHhSIHQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAHQjiGIAdCgP4Dg0IohoQgB0KAgPwHg0IYhiAHQoCAgPgPg0IIhoSEIAdCCIhCgICA+A+DIAdCGIhCgID8B4OEIAdCKIhCgP4DgyAHQjiIhISEIAN+hUIXiSEDDAELIAQgCHwgBiABIAJqQRBrIgApAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgByAAKQAIhSIFQn+FfiIIQjiGIAhCgP4Dg0IohoQgCEKAgPwHg0IYhiAIQoCAgPgPg0IIhoSEIAhCCIhCgICA+A+DIAhCGIhCgID8B4OEIAhCKIhCgP4DgyAIQjiIhISEhSAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAN+hUIXiSEDIAdCf4UhCANAIAMgBHwgBiABKQAAhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAEpAAgiCSAIhX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgAyAHIAmFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIR+hUIXiSEDIAFBEGohASACQRBrIgJBEEsNAAsLIAMgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH4gA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQn+FfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhSADiQuxEAEOfyMAQSBrIgckACAAKAIcIgItAAUhAwJAAkACQCABQf8BcUEERwRAIAMNAkEBIQQgAigCJEUNAgwBC0ECIQQCQCADDgMBAAIACyACQdgAakGAAkHMhv0AQaACEKshQQAhAyACQQA6AAUgAiACKAIQNgI8IAAQ4hggACgCEEUNAiAAKAIcIQILIAJB2ABqQQEgAUH/AXFBBEYQjCYgACgCHCICIAQ6AAUgAiACKAIQNgI8C0ECQQEgAUH/AXEiC0EERiIMGyENA0ACQAJAAkACQAJAIAIoAmRBCGogAigCTEECdE8EQCAAEOIYIAAoAhBFDQEgACgCHCECCyACKAIkIgNBhgJPDQIgAigCICIEQQF0IQggBEGGAmshCQNAIAIoAlAgAyACKAIQIgVqayEDAkACQAJAAkACQAJAAkACQAJAIAkgAigCIGogBU0EQCAIIAIoAhgiBUsNASAEQQBIDQIgBARAIAIoAhQiBSAEIAVqIAT8CgAACyACIAIvAQwiBSAEQf//A3EiBmsiCkEAIAUgCk8bOwEMIAUgBk0EQCACQQA7ATQLIAIgAigCECAEayIFNgIQIAIgAigCPCAEazYCPCACIAUgAigCgAEiBiAFIAZJGzYCgAEgAhCUFiADIARqIQMLIAAoAgRFBEAgACgCHCECDAwLIANBAU0NAiAAIAAoAhwiAigCJCACKAIQaiADEMwTIQMgACgCHCICIAMgAigCJGoiAzYCJCACKAKAASIGIANqQQNJDQggAigCECIDIAZrIQUgAi8BNkGACE0EQCADIAZGDQggBUEBayEDIAItAAZBAUYEQCACIAMQ2RkaDAkLIAIoAhgiBiADSQ0EIAYgA2siBkEDTQ0FIAIoAhQgA2ooAABBsfPd8XlsQRB2QQF0IgogAigCMGovAQAiDiADQf//A3FGDQggAigCIEEBayADcSIGIAIoAiwiD08NBiACKAIoIAZBAXRqIA47AQAgAigCMCAKaiADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0Gskf0AEMMhAAsgBUEBaiIGIANJDQYgBiADQbyR/QAQwyEACyAIIAVB7JD9ABCwOwALIAdBADYCGCAHQQE2AgwgB0Hohf0ANgIIIAdCBDcCECAHQQhqQfyQ/QAQ7ywACyAHQQA2AhggB0EBNgIMIAdBlJH9ADYCCCAHQgQ3AhAgB0EIakGckf0AEO8sAAsgAyAGQbyQ/QAQrzsAC0EEIAZBzJD9ABCwOwALIAYgD0HckP0AEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAGai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiQiA0EBRmsiBkUNAAJAIAItAAZBAUYEQCACIAUgBhDgEwwBCyACIAUgBhDrFAsgAiACKAKAASAGazYCgAEgAigCJCEDCyADQYUCSw0CIAAoAgQNAAsMAQtBACEDIAFB/wFxQQRHDQUgACgCBA0FIAAoAhwiAC0AcA0FIAAtAAVFQQF0IQMMBQsgAigCECIEIAIoAlBBhgJrSwRAIAdBADYCGCAHQQE2AgwgB0Hokf0ANgIIIAdCBDcCECAHQQhqQfCR/QAQ7ywACyALIAIoAiQiA0GGAk9yRQRAQQAhAwwFCwJAAkAgA0UEQCACQQIgBCAEQQJPGzYCgAEgAi0ABQRAIAJB2ABqIgNBgAJBzIb9AEGgAhCrISABQf8BcUEERgRAIAMQ8BULIAJBADoABSACIAIoAhA2AjwgABDiGCAAKAIQRQ0CC0EDQQEgAUH/AXFBBEYbIQMMBwsgAi0ABQ0BIAJB2ABqQQEgDBCMJiAAKAIcIgIgDToABSACIAIoAhAiBDYCPCACKAIkIQMMAQsgAUH/AXFBBEZBAXQhAwwFCyADQQNLDQAgBCACKAIYIgNPDQEgAigCFCAEai0AACEGDAILAkACQAJAAkACQAJAIAIoAhgiBCACKAIQIgNPBEAgBCADayIEQQNNDQEgAigCFCADaigAACIGQbHz3fF5bEEQdkEBdCIIIAIoAjBqLwEAIgQgA0H//wNxRwRAIAIoAiBBAWsgA3EiBSACKAIsIglPDQMgAigCKCAFQQF0aiAEOwEAIAIoAjAgCGogAzsBACACKAIQIQMLIAMgBGsiCEEATA0IIAggAigCIEGGAmtKDQggAigCGCIFIARJDQMgBSAEayIJQQNNDQQgBiAEIAIoAhQiCmoiBCgAAEcNCCAFIANBAmoiA0kNBQJ/IAMgCmohCiAEQQJqIQQgCUECayEJAkAgBSADa0H/AUsEQCAJQf8BTQ0BQQAhAwNAIAMgAyAKai0AACADIARqLQAARw0DGiADQQFqIgNBgAJHDQALQYACDAILQdjv/AAQsjsAC0Ho7/wAELI7AAtBAmoiA0EESQ0IIAhBgIAETw0GIAJB2ABqQYICIAIoAiQiBCADIAMgBEsbIgMgA0GCAk8bIgNBA2sgCBC7EiACIAIoAiQgA2s2AiQgAiACKAIQIANqNgIQDAkLIAMgBEHcj/0AEK87AAtBBCAEQeyP/QAQsDsACyAFIAlB3JD9ABDDIQALIAQgBUH8j/0AEK87AAtBBCAJQYyQ/QAQsDsACyADIAVBnJD9ABCvOwALQfCF/QBBKyAHQQhqQZyG/QBBrJD9ABDVHgALIAQgA0HMj/0AEMMhAAsgAkHYAGpBzIb9AEGgAiAGEMkqIAAoAhwiAiACKAIQQQFqNgIQIAIgAigCJEEBazYCJAwACwALIAdBIGokACADC+4PAg1/An4jAEHQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AKEEBaw4EBgACBAELAAsgASABKAIAIgQ2AhggASABKAIINgIcIAEgASgCFDYCICABKAIEIQggASgCDCEGIAEoAhAhBSABIAQoAgwgBCgCHBCILSIHNgIkIAEoAhghBAJAIAZFDQAgBCgCECILRQ0AIAQoAhQhDCABQSxqIgkgBiAFIAQoAhgQuAkgAUEANgJAIAFCgICAgMAANwI4IAEoAhgiBCgCBCEHIAQoAgghBCADQRBqIAEoAiQQhjwgASgCHCENIAMoAhQhBSADKAIQIQogAyABQThqNgKUASADIAY2ApABIAMgCTYCjAEgAyABQSBqNgKIASADIAw2AoQBIAMgCzYCgAEgAyANNgJ8IANBADYCeCADQQA2AnAgAyAKNgJoIAMgByAEQQJ0ajYCZCADIAc2AmAgA0EANgJQIANBADYCQCADIAUgBCAEIAVLGzYCdCADIAogBUHAAmxqNgJsIANBmAFqIgQgA0FAaxCdECADQQA6AMwBIAMgCDYCpAEgA0EIaiAEEM4pIAMoAgghBCABIAMoAgwiBTYCSCABIAQ2AkQMAgsgBCgCCCEGIAQoAgQhBCABKAIcIQUgAyAHNgKoASADIAU2AqQBIANBADYCoAEgAyAENgKYASADIAQgBkECdGo2ApwBIANBQGsiBCADQZgBahDHDyADQQA6AHQgAyAINgJMIAMgBBDOKSADKAIAIQQgASADKAIEIgU2AjAgASAENgIsDAMLIAEoAkghBSABKAJEIQQLIANBQGsgBCACIAUoAgwRAQAgAygCQCICQQlHDQMgAEEJNgIAQQMhAgwICyABKAIwIQUgASgCLCEECyADQUBrIAQgAiAFKAIMEQEAIAMoAkAiAkEJRw0CIABBCTYCAEEEIQIMBgtBiP7CABDoKwALIAMpA1AhECADKAJMIQUgAygCSCEEIAMoAkQhBiABQcQAahC8KiACQQhHBEAgAUE4aiIIENYrIAgQ6DsgAUEsahDqOwwDCyADIAY2AiAgAyAENgIYIAMgBDYCHCADIAQgBUEEdGo2AiQgAyABKAI4NgKgASADIAEoAjwiAiABKAJAQQxsajYCpAEgAyACNgKcASADIAI2ApgBIAEoAhgiAigCCCIEBEAgAigCBCIGIARBAnRqIQogA0E8aiELQQAhCANAAkAgBigCAA0AIAEoAhwgCBDyJkUNACADKAKcASICIAMoAqQBRg0AIAMgAkEMajYCnAEgAigCACIMQYCAgIB4Rg0AIANBQGsgAikCBCIQQiCIpyIHQQBBBEEQEKAYIAMoAkQhAgJAIAMoAkBBAUcEQCADQQA2AjAgAyADKAJINgIsIAMgAjYCKCAQQoCAgIAQWgRAQQAhBCADKAIcIQkgAygCJCENQQAhBQNAAkAgDSAEIAlqIgJHBEAgAyACQRBqNgIcIAIoAgAiDg0BC0Go/sIAELI7AAsgA0HIAGoiDyACQQxqKAIANgIAIAMgAkEEaikCADcDQCADKAIoIAVGBEAgA0EoakG4/sIAEJ4oCyADKAIsIARqIgIgDjYCACACQQRqIAMpA0A3AgAgAkEMaiAPKAIANgIAIAMgBUEBaiIFNgIwIARBEGohBCAFIAdHDQALCyADQUBrIgQgASgCJCAIEIktEOwgIAMpA0ghESADKAIoIQkgAygCLCECIAMoAjAhBSADQgA3AmAgAyACIAVBBHRqNgJcIAMgCTYCWCADIAI2AlQgAyACNgJQIAMgEKciAiAHQQN0ajYCTCADIAw2AkggAyACNgJEIAMgAjYCQCADQTRqIAQQ9xhBHEEEEK02IgJFDQEgAkEANgIIIAJCgYCAgBA3AgAgAiADKQI0NwIMIAIgET4CGCACQRRqIAsoAgA2AgACQCAGKAIAIgRFDQAgBCAEKAIAIgVBAWs2AgAgBUEBRw0AIAYQ3xgLIAYgAjYCAAwCCyACIAMoAkhBmP7CABD9LwALQQRBHBCjPQALIAhBAWohCCAGQQRqIgYgCkcNAAsLIANBmAFqELsgIANBGGoQuxwgAUEsahDqOwwBCyADKQNQIRAgAygCTCEFIAMoAkghBCADKAJEIQYgAUEsahC8KiACQQhHDQEgAyAGNgKgASADIAQgBUEEdGo2AqQBIAMgBDYCnAEgAyAENgKYASABKAIYIgIoAggiBARAIAIoAgQhAiAEQQJ0IQVBACEEIANBIGohCANAAkAgAigCAA0AIAEoAhwgBBDyJkUNACADKAKcASIGIAMoAqQBRg0AIAMgBkEQajYCnAEgBigCACIHRQ0AIAggBkEMaigCADYCACADIAYpAgQ3AxggA0FAayABKAIkIAQQiS0Q7CAgAykDQCEQQRxBBBCtNiIGRQ0FIAYgBzYCCCAGQoGAgIAQNwIAIAYgAykDGDcCDCAGIBA+AhggBkEUaiAIKAIANgIAAkAgAigCACIHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACACEN8YCyACIAY2AgALIAJBBGohAiAEQQFqIQQgBUEEayIFDQALCyADQZgBahC7HAtBCCECCyAAIBA3AxAgACAFNgIMIAAgBDYCCCAAIAY2AgQgACACNgIAQQEhAgwBC0EEQRwQoz0ACyABIAI6ACggA0HQAWokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC6CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDmAiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDmAiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7AcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQlgkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQlgkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEI0KIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC2CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7QcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQlwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQlwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEJ8QIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrENQIIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACENQIIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCNCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQiAkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEI4JIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC3CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7gcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQmwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQmwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIsJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCMCiACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ6wcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQmQkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQmQkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIwJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKALIASABKALMASgCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgLYASABIAIoAvABIgU2AtQBIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgC0AEiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCyAEgASgCzAEoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6ANwBIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYC2AEgASAFNgLUASABKALQASIDLgEaQQBMDQYgAkG4AmogASgCyAEgASgCzAEoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6ANwBIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgC0AEhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARDqByACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAsgBIAEoAswBKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxCaCSACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhCaCSACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQigkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAsgBIAEoAswBKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2AtgBIAEgAigC8AEiBTYC1AEgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKALQASIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKALIASABKALMASgCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoA3AEgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgLYASABIAU2AtQBIAEoAtABIgMuARpBAEwNBiACQbgCaiABKALIASABKALMASgCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoA3AEgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKALQASEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BENcHIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCyAEgASgCzAEoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEJgJIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEJgJIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCGCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQhQkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIcJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCJCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL+w8CBn8DfiMAQeACayIHJAAgAS0AaCEMIAcgAjoAowECQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXEOCAUABgYGAQIABgsgB0HIAmogA0EIaikCADcDACAHIAMpAgA3A8ACIAdB0AFqIAdBwAJqIAQgBSAGEJkNIAdBsAFqIAdBiAJqKQMANwMAIAdBuAFqIAdBkAJqKAIANgIAIAcgBykDgAI3A6gBIAcpA9ABIQ0gBygC2AEhCCAHKALcASEKIAcoAuABIQkgBygC5AEhBiAHKALoASECIAcoAuwBIQMgBygC8AEhBCAHKAL0ASEFIAcpA/gBIQ4gBy0AlAIhDCAHQaYBaiAHQZcCai0AADoAACAHIAcvAJUCOwGkASAHKQOYAiEPDAcLIAdByAFqIgYgA0EIaikCADcDACAHIAMpAgA3A8ABIAdBADYCuAIgB0KAgICAEDcCsAIgB0HAAmoiAiAHQbACaiIDEOcVIAdB6AFqQgA3AwAgB0HwAWpCADcDACAHQYwCakIANwIAIAdBlAJqQgA3AgAgB0GcAmpCADcCACAHQeABaiAHQcgCaikDADcDACAHQQA6AKgCIAdCADcChAIgB0EANgL4ASAHQgE3AvwBIAdBADYC0AEgB0EANgKkAiAHIAcpA8ACNwPYASADIAdBzAFqIgsgBygCxAEgBigCACAHKALAASgCABEFACACIAdB0AFqIAMQuAQCQAJAIAcoAsACIghBCEcEQCAHKALUAiEFIAcoAtACIQQgBygCzAIhAyAHKALIAiECIAcoAsQCIQYMAQsgB0GwAmpBACAHKAKIAkGEkc0AELMVIAdBwAJqIAdB0AFqIAcoArQCIgogBygCuAIiCRDoCQJAIAcoAsACIghBCEcEQCAHKALUAiEFIAcoAtACIQQgBygCzAIhAyAHKALIAiECIAcoAsQCIQYMAQsCQAJAAkAgCUUEQEEAIQIMAQsgCUECdCEGQQAhAiAKIQMDQCADKAIAIgRBAEgNAiACIARqIQIgA0EEaiEDIAZBBGsiBg0ACwsgB0HQAWoQ3hwgAmogBygCyAEiA00NBEEqIQMgB0HAAmpBKkEAQQFBARCgGCAHKALEAiEGIAcoAsACQQFGDQ4gBygCyAIiAkH4jc0AQSr8CgAADAELQSchAyAHQcACakEnQQBBAUEBEKAYIAcoAsQCIQYgBygCwAJBAUYNDSAHKALIAiICQaKOzQBBJ/wKAAALQQAhCAsgB0GwAmoQ6TsLIAdB0AFqEIItIAsgBygCxAEgBygCyAEgBygCwAEoAhARAQAMAwsgBygCzAEhBCAHKALEASECIAcoAsABIQYgBygCsAIhCCAHQdABaiIFEN4cIAUQgi1BACEFIAhBgICAgHhGDQGtQoCAgIAQQgAgDEEBcRuEIQ5CBCENDAYLIAdBuAJqIANBCGopAgA3AwAgByADKQIANwOwAiAHQdABaiAHQbACahCxBCAHKALQAUEBRgRAIAcoAuwBIQUgBygC6AEhBCAHKALkASEDIAcoAuABIQIgBygC3AEhBiAHKALYASEIDAILIAdByAJqIAdBhAJqKQIANwMAIAdB0AJqIgsgB0GMAmooAgA2AgAgByAHKQL8ATcDwAIgBygC8AEhBSAHKALsASEEIAcoAugBIQMgBygC5AEhAiAHKALgASEGIAcoAtwBIQkgBygC1AEiCEGAgICAeEcNBAsgCSEICyAHIAU2AmwgByAENgJoIAcgAzYCZCAHIAI2AmAgByAGNgJcIAcgCDYCWAwECyAHQcgCaiADQQhqKQIANwMAIAcgAykCADcDwAIgB0HQAWogB0HAAmoQ/BsgByAMOgDkASAGIAQgBUEBcRshAiAHKALQASEIIAcoAtQBIQogBygC2AEhCSAHKALkASEDQgIhDUEAIQYMAgsgB0EBNgLUASAHQdyMzQA2AtABIAdCATcC3AEgB0GuAzYCxAIgByAHQcACajYC2AEgByAHQaMBajYCwAIgB0HcAGogB0HQAWoQmQ4gB0EANgJYIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgBykC9AEhDiAHKALYASEKIAdBuAFqIAsoAgA2AgAgB0GwAWogB0HIAmopAwA3AwAgByAHKQPAAjcDqAFCBSENCyAHQYgBaiAHQbABaikDADcDACAHQZABaiAHQbgBaigCADYCACAHQZcBaiAHQaYBai0AADoAACAHIA43A3ggByAFNgJ0IAcgBDYCcCAHIAM2AmwgByACNgJoIAcgBjYCZCAHIAk2AmAgByAKNgJcIAcgCDYCWCAHIAcpA6gBNwOAASAHIAw6AJQBIAcgBy8BpAE7AJUBIAcgDzcDmAEgDUIGUQ0AIAdByABqIgMgB0HYAGoiBEEQaikDADcDACAHQUBrIgIgBEEIaikDADcDACAHIAQpAwA3AzggB0EIaiAHQfAAakEw/AoAACABEMEaIAEgDTcDACABIAcpAzg3AwggAUEQaiACKQMANwMAIAFBGGogAykDADcDACABQSBqIAdBCGpBMPwKAAAgAEEINgIADAELIAdByABqIAdB6ABqKQMAIg03AwAgB0FAayAHQeAAaikDACIONwMAIAcgBykDWCIPNwM4IABBEGogDTcDACAAQQhqIA43AwAgACAPNwMACyAHQeACaiQADwsgBiAHKALIAkHU/cwAEP0vAAusDwIPfwJ+IwBB8ARrIgMkACABKAIYIQ0gASgCHCEHIANB2AJqIAJBDGoiCBDbPEEAQQRBBBCgGCADKALcAiEFIAMoAtgCQQFHBEAgA0EANgLIBCADIAMoAuACIgQ2AsQEIAMgBTYCwAQgA0EANgLUBCADQoCAgIDAADcCzAQgBQR/IAQFIANBwARqQfCvggEQnSggAygCxAQLQQA2AgAgA0EBNgLIBEHAACEEIAgQ2zwiBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIANBADYC5AIgAyAENgLgAiADIAU2AtwCIANBwAA2AtgCIANB2ARqIgUgA0HYAmogBhDSJSADQRhqIAUQhj0gAygCHCEGIAMoAhghDiAIENs8IhAEQCAHQQJ2IQcgAigCECERQQAhBQNAAkACQAJAAkACQAJAIAIgBRCLO0UEQCAFQQN2IgQgBk8NASAEIA5qIgQgBC0AAEF+IAVBB3F3cToAACADKALIBCIEIAMoAsAERgRAIANBwARqQYCwggEQnSgLIAMoAsQEIARBAnRqIAs2AgAgAyAEQQFqNgLIBAwGCyADIAU2AugEIAgQ2zwgBU0NASARIAVBAnRqKAIAIgkgB08NAiAJQQFqIgQgB08NBCANIARBAnRqKAIAIg8gDSAJQQJ0aigCACIKayALaiELIAMoAsgEIgQgAygCwARGBEAgA0HABGpBsLCCARCdKAsgAygCxAQgBEECdGogCzYCACADIARBAWo2AsgEIAogD0gEQCADKALUBCIMQQJ0IQQDQCADKALMBCAMRgRAIANBzARqQcCwggEQnSgLIAMoAtAEIARqIAo2AgAgAyAMQQFqIgw2AtQEIARBBGohBCAPIApBAWoiCkcNAAsLIAEgCRCSOw0FIAVBA3YiBCAGTw0DIAQgDmoiBCAELQAAQX4gBUEHcXdxOgAADAULIAQgBkGA9IEBEMMhAAsgAyACEPw7NgLsBCADQQI2AtwCIANBiPGBATYC2AIgA0ICNwLkAiADQTs2AiwgA0E7NgIkIAMgA0EgajYC4AIgAyADQewEajYCKCADIANB6ARqNgIgIANB2AJqQZjxgQEQ7ywACyAJIAdBkLCCARDDIQALIAQgBkGA9IEBEMMhAAsgBCAHQaCwggEQwyEACyAFQQFqIgUgEEcNAAsLIANBKGogA0HUBGooAgA2AgAgAyADKQLMBDcDICADQeQCaiICIANBIGoQmRIgA0HgAmogA0HIBGooAgA2AgAgAyADKQLABCISNwPYAiADKQLcAiETIANBuANqIAJBMPwKAAAgA0GIAWogA0HgBGopAgA3AwAgAyADKQLYBDcDgAECQAJAAkAgEqciAkGAgICAeEYEQCADQdgAaiADQcADaigCACIBNgIAIAMgAykCuAMiEjcDUCAAQRRqIAE2AgAgACASNwIMIAAgEzcCBCAAQSk6AAAMAQsgA0HQAGogA0G4A2pBMPwKAAAgA0HgBGogA0GIAWopAwA3AwAgAyADKQOAATcD2AQgA0EgaiIEIANB0ABqQTD8CgAAIAMgEzcChAEgAyACNgKAASADQdgCaiABKAIMIAEoAhAiAigCCEEBa0F4cWpBCGogAiAEIgIQiQEgAygC4AIhBiADKALcAiEHIAMoAtgCIgVBk4CAgHhHBEAgACADKQLkAjcCECAAIAY2AgwgACAHNgIIIAAgBTYCBCAAQSk6AAAgA0HYBGoQzy8gA0GAAWoQ6TsgAhD+JAwBCyADQbgDaiIFIANBgAFqEOAsIAMgAykCuAM3AuQCIANBADYC4AIgAyADKALEAyIJNgLcAiADIAMoAsADNgLYAiADQRBqIANB2AJqIgQQ1zsgAygCECEKQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQLYAjcCCCACQRBqIANB4AJqKQIANwIAIAJBGGogA0HoAmooAgA2AgAgAyAJNgKcASADIAo2ApgBIAMgAjYClAEgA0H4AmogARDKBiAIENs8IQEgA0EAOwGwAyADQQA2AqwDIANBADYClAMgA0EANgKIAyADIAE2AoQDIANCBDcC8AIgA0IANwLoAiADQoCAgIDAADcC4AIgA0EANgLYAiADKALgBCEBIAMoAuQEIQIgAyADKQPYBDcCxAMgA0EANgLAAyADIAI2ArwDIAMgATYCuAMgA0EIaiAFENc7IAMoAgghCEEcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCuAM3AgggAUEQaiADQcADaikCADcCACABQRhqIANByANqKAIANgIAIAMgAjYCWCADIAg2AlQgAyABNgJQIANB/AFqIgEgBCADQdAAahCuFiADQQA2AtACIAUgByAGENMjIAQgASAFEO8lIANBoAFqIgEgBCADQZQBahD6IyADQfwDaiICIAEQzRwgACACEK8fIANBIGoQ/iQLIANB8ARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAFEKM9AAtBwPSBAUEpIANB2AJqQcz8gQFB7PSBARDVHgALIAUgAygC4AJB4K+CARD9LwAL6Q8CDX8CfiMAQdABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAoQQFrDgQGAAIEAQsACyABIAEoAgAiBDYCGCABIAEoAgg2AhwgASABKAIUNgIgIAEoAgQhCCABKAIMIQYgASgCECEFIAEgBCgCDCAEKAIcEIgtIgc2AiQgASgCGCEEAkAgBkUNACAEKAIQIgtFDQAgBCgCFCEMIAFBLGoiCSAGIAUgBCgCGBC4CSABQQA2AkAgAUKAgICAwAA3AjggASgCGCIEKAIEIQcgBCgCCCEEIANBGGogASgCJBCGPCABKAIcIQ0gAygCHCEFIAMoAhghCiADIAFBOGo2AswBIAMgBjYCyAEgAyAJNgLEASADIAFBIGo2AsABIAMgDDYCvAEgAyALNgK4ASADIA02ArQBIANBADYCsAEgA0EANgKoASADIAo2AqABIAMgByAEQQJ0ajYCnAEgAyAHNgKYASADQQA2AogBIANBADYCeCADIAUgBCAEIAVLGzYCrAEgAyAKIAVBwAJsajYCpAEgA0EkaiIEIANB+ABqEJ0QIANBEGogCCAEEPQXIAMoAhAhBCABIAMoAhQiBTYCSCABIAQ2AkQMAgsgBCgCCCEGIAQoAgQhBCABKAIcIQUgAyAHNgKIASADIAU2AoQBIANBADYCgAEgAyAENgJ4IAMgBCAGQQJ0ajYCfCADQdwAaiIEIANB+ABqEMcPIANBCGogCCAEEPQXIAMoAgghBCABIAMoAgwiBTYCMCABIAQ2AiwMAwsgASgCSCEFIAEoAkQhBAsgA0H4AGogBCACIAUoAgwRAQAgAygCeCICQQlHDQMgAEEJNgIAQQMhAgwICyABKAIwIQUgASgCLCEECyADQfgAaiAEIAIgBSgCDBEBACADKAJ4IgJBCUcNAiAAQQk2AgBBBCECDAYLQYj+wgAQ6CsACyADKQOIASEQIAMoAoQBIQUgAygCgAEhBCADKAJ8IQYgAUHEAGoQvCogAkEIRwRAIAFBOGoiCBDWKyAIEOg7IAFBLGoQ6jsMAwsgAyAGNgI4IAMgBDYCMCADIAQ2AjQgAyAEIAVBBHRqNgI8IAMgASgCODYCcCADIAEoAjwiAiABKAJAQQxsajYCdCADIAI2AmwgAyACNgJoIAEoAhgiAigCCCIEBEAgAigCBCIGIARBAnRqIQogA0HYAGohC0EAIQgDQAJAIAYoAgANACABKAIcIAgQ8iZFDQAgAygCbCICIAMoAnRGDQAgAyACQQxqNgJsIAIoAgAiDEGAgICAeEYNACADQfgAaiACKQIEIhBCIIinIgdBAEEEQRAQoBggAygCfCECAkAgAygCeEEBRwRAIANBADYCTCADIAMoAoABNgJIIAMgAjYCRCAQQoCAgIAQWgRAQQAhBCADKAI0IQkgAygCPCENQQAhBQNAAkAgDSAEIAlqIgJHBEAgAyACQRBqNgI0IAIoAgAiDg0BC0Go/sIAELI7AAsgA0GAAWoiDyACQQxqKAIANgIAIAMgAkEEaikCADcDeCADKAJEIAVGBEAgA0HEAGpBuP7CABCeKAsgAygCSCAEaiICIA42AgAgAkEEaiADKQN4NwIAIAJBDGogDygCADYCACADIAVBAWoiBTYCTCAEQRBqIQQgBSAHRw0ACwsgA0H4AGoiBCABKAIkIAgQiS0Q7CAgAykDgAEhESADKAJEIQkgAygCSCECIAMoAkwhBSADQgA3ApgBIAMgAiAFQQR0ajYClAEgAyAJNgKQASADIAI2AowBIAMgAjYCiAEgAyAQpyICIAdBA3RqNgKEASADIAw2AoABIAMgAjYCfCADIAI2AnggA0HQAGogBBD3GEEcQQQQrTYiAkUNASACQQA2AgggAkKBgICAEDcCACACIAMpAlA3AgwgAiARPgIYIAJBFGogCygCADYCAAJAIAYoAgAiBEUNACAEIAQoAgAiBUEBazYCACAFQQFHDQAgBhDfGAsgBiACNgIADAILIAIgAygCgAFBmP7CABD9LwALQQRBHBCjPQALIAhBAWohCCAGQQRqIgYgCkcNAAsLIANB6ABqELsgIANBMGoQuxwgAUEsahDqOwwBCyADKQOIASEQIAMoAoQBIQUgAygCgAEhBCADKAJ8IQYgAUEsahC8KiACQQhHDQEgAyAGNgJwIAMgBCAFQQR0ajYCdCADIAQ2AmwgAyAENgJoIAEoAhgiAigCCCIEBEAgAigCBCECIARBAnQhBUEAIQQgA0E4aiEIA0ACQCACKAIADQAgASgCHCAEEPImRQ0AIAMoAmwiBiADKAJ0Rg0AIAMgBkEQajYCbCAGKAIAIgdFDQAgCCAGQQxqKAIANgIAIAMgBikCBDcDMCADQfgAaiABKAIkIAQQiS0Q7CAgAykDeCEQQRxBBBCtNiIGRQ0FIAYgBzYCCCAGQoGAgIAQNwIAIAYgAykDMDcCDCAGIBA+AhggBkEUaiAIKAIANgIAAkAgAigCACIHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACACEN8YCyACIAY2AgALIAJBBGohAiAEQQFqIQQgBUEEayIFDQALCyADQegAahC7HAtBCCECCyAAIBA3AxAgACAFNgIMIAAgBDYCCCAAIAY2AgQgACACNgIAQQEhAgwBC0EEQRwQoz0ACyABIAI6ACggA0HQAWokAAvGDwIMfwJ+IwBBgARrIgQkACAEQcwCaiACQQxqIgkQ2DwgA2wQ8h4CQAJAAkACQCAJENg8Ig4EQCABKAIsIQ8gAigCECEHIARB2AJqIQoDQAJAAkACQAJAIAIgBRCLO0UEQCAKEOY6IAQoAtgCRQ0BIAQoAugCIANqIgxBA3YgDEEHcUEAR2oiBiAEKALkAiIISwRAIAYgCGshDSAEKALcAiILIAZJBEAgCiALQQF0IgggBhDSKiILIAggC0sbEOgZIAQoAuQCIQgLIA0EQCAEKALgAiAIakEAIA38CwALIAQgBjYC5AILIAQgDDYC6AIgBEHMAmogAxC0JQwECyAEIAU2AvwDIAkQ2DwgBU0NASAHKQMAIhBCgICAgBBaBEAgBEEQakEUQQBBAUEBEKAYIAQoAhQhAiAEKAIQQQFGDQMgBCgCGCIBQRBqQbD/gQEoAAA2AAAgAUEIakGo/4EBKQAANwAAIAFBoP+BASkAADcAACAEQRQ2AmwgBCABNgJoIAQgAjYCZCAEQYaAgIB4NgJgIARBzAJqELwtDAcLIARBzAJqIA8gEKdsIgYgAyAGahCIDwwDC0H89IEBELI7AAsgBCACEP07NgKMASAEQQI2AhQgBEGI8YEBNgIQIARCAjcCHCAEQTs2AvgDIARBOzYC8AMgBCAEQewDajYCGCAEIARBjAFqNgL0AyAEIARB/ANqNgLsAyAEQRBqQZjxgQEQ7ywACyACIAQoAhhBiP2BARD9LwALIAdBCGohByAOIAVBAWoiBUcNAAsLIARB3ABqIARBzAJqIgMQ1BQgBC0AXCEFIAMQvC0gBUEpRg0AIARBzwBqIgcgBEHsAGopAAA3AAAgBEHIAGoiBiAEQeUAaikAADcDACAEQTBqIARB/ABqKQIANwIAIARBOGogBEGEAWopAgA3AgAgBEEZaiAGKQMANwAAIARBIGogBykAADcAACAEIAQpAF0iEDcDQCAEIAQpAnQ3AiggBCAQNwARIAQgBToAECADIAEoAgwgASgCECIDKAIIQQFrQXhxakEIaiADIARBEGoQiAEgBCgC1AIhAyAEKALQAiEFIAQoAswCIgdBk4CAgHhGDQEgACAEKQLYAjcCECAAIAM2AgwgACAFNgIIIAAgBzYCBCAAQSk6AAAMAgsgBEHTAGogBEHwAGooAgAiATYAACAEQcsAaiAEQegAaikCACIQNwAAIAQgBCkCYCIRNwBDIABBFGogATYAACAAQQxqIBA3AAAgACARNwAEIABBKToAAAwCCyAEIAM2ApABIAQgBTYCjAFBwAAhBgJAIAkQ2DwiA0EDdiADQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgNBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgZFDQELQQAhBSAEQQA2AtgCIAQgBjYC1AIgBCADNgLQAiAEQcAANgLMAiAEQUBrIgMgBEHMAmogBxDSJSAEQQhqIAMQhj0gBCgCDCEDIAQoAgghCCAJENg8IgpFDQIgAigCECEHA0ACQCAEIAU2AvwDAkACQCAJENg8IAVLBEAgBykDACIQQoCAgIAQWgRAIARBzAJqQRRBAEEBQQEQoBggBCgC0AIhAiAEKALMAkEBRgRAIAIgBCgC1AJBiP2BARD9LwALIAQoAtQCIgFBEGpBsP+BASgAADYAACABQQhqQaj/gQEpAAA3AAAgAUGg/4EBKQAANwAAIABBFDYCECAAIAE2AgwgACACNgIIIABBhoCAgHg2AgQgAEEpOgAAIARBQGsQzy8gBCgCjAEiACAAKAIAIgBBAWs2AgAgAEEBRw0JIARBjAFqELsjDAkLIAIgBRCLO0UNASABIBCnEJolDQEMAgsgBCACEP07NgLsAyAEQQI2AtACIARBiPGBATYCzAIgBEICNwLYAiAEQTs2AmggBEE7NgJgIAQgBEHcAGo2AtQCIAQgBEHsA2o2AmQgBCAEQfwDajYCXCAEQcwCakGY8YEBEO8sAAsgBUEDdiIGIANPDQEgBiAIaiIGIAYtAABBfiAFQQdxd3E6AAALIAdBCGohByAKIAVBAWoiBUcNAQwECwsgBiADQYD0gQEQwyEAC0HAACADEKM9AAtBwPSBAUEpIARBzAJqQcz8gQFB7PSBARDVHgALIARB7AJqIAEQygYgCRDYPCEBIARBADsBpAMgBEEANgKgAyAEQQA2AogDIARBADYC/AIgBCABNgL4AiAEQgQ3AuQCIARCADcC3AIgBEKAgICAwAA3AtQCIARBADYCzAIgBCgCSCEBIAQoAkwhAiAEIAQpAkA3AmggBEEANgJkIAQgAjYCYCAEIAE2AlwgBCAEQdwAahDXOyAEKAIAIQNBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCXDcCCCABQRBqIARB5ABqKQIANwIAIAFBGGogBEHsAGooAgA2AgAgBCACNgL0AyAEIAM2AvADIAQgATYC7AMgBEHwAWoiAiAEQcwCaiIBIARB7ANqEK4WIARBADYCxAIgASAEKAKMASAEKAKQARDTIyAEQZQBaiIDIAIgARDvJSAEQagDaiIBIAMQzRwgACABENwUIARBEGoQ/iQMAgtBBEEcEKM9AAsgBEEQahD+JAsgBEGABGokAAv5DAEgfyMAQRBrIhgkACAAKAIEIgkgACgCHCIGaiABTQRAIAYgASAJayIPIAYgD0sbIQxBfyAAKAK8AUEBa3RBf3MhECAAKAJkIRUgACgCwAEhCyAAKAJcIQoDQCAGIAxGRQRAIAogBiAJaiALIAQQox1BAnRqIgcoAgAhCCAHIAY2AgAgFSAGIBBxQQN0aiIHQQE2AgQgByAINgIAIAZBAWohBgwBCwsgACAPNgIcQQAhECAPQX8gACgCvAFBAWt0QX9zIh5rIgdBACAHIA9NGyIfIAAoAhAiCCAPQQEgACgCuAF0IgdrIAggDyAIayAHSxsgACgCGBsiJCAfICRLGyEgQQEgACgCxAF0IhEhFyAKIAEgACgCwAEgBBCjHUECdGoiJSEGAkADQCAGKAIAIgcgIE0NASAVIAcgHnFBA3RqIgYoAgQiCEEBRyAXQQJJckUEQCAGIBA2AgQgF0EBayEXIAchEAwBCwsgCEEBRw0AIAZCADcCAAsgFUEEaiEZA0AgECINBEAgACgCCCIhIAAoAgwiGmoiEiACIA0gGkkiCxshIiAZIA0gHnFBA3RqKAIAIRAgFSANQX8gACgCvAFBAWt0QX9zIhNxQQN0aiIbKAIAIQYgDUEBIAAoArgBdCIIayAAKAIQIgcgDSAHayAISxshFCAJIBpqIRwgISAJIAsbIA1qISMgG0EEaiEOQQAhCkEAIQxBACELAkADQCAKIBdGIAYgFE1yDQECQCAFQQFHIAsgDCALIAxJGyIIIAZqIBpPciIHRSANIBpPcUUEQCAIICNqIAkgISAHGyAGaiIWIAhqICIQgBQgCGohBwwBCyAGICFqIgcgBiAJaiAIICNqIAcgCGogIiASIBwQzSggCGoiByAGaiAaSRshFgsgByAjaiIdICJGDQEgFSAGIBNxQQN0aiEIAkACQAJAIAcgFmotAAAgHS0AAEkEQCAbIAY2AgAgBiAgSw0BIBhBDGohGwwFCyAOIAY2AgAgBiAgTQ0CIAghDiAHIQwMAQsgCEEEaiIIIRsgByELCyAKQQFqIQogCCgCACEGDAELCyAYQQxqIQ4LIA5BADYCACAbQQA2AgAgF0EBaiEXDAELCyAAKAIIIRQgACgCDCESICUoAgAhBiAlIA82AgAgD0EJaiEWIAkgEmohHCASIBRqIR0gFSAPIB5xQQN0aiITQQRqIQ5BACEMIAVBAUchDUEAIQtBACEKAkADQCARRSAGICRNcg0BIAEgDCALIAsgDEsbIghqIQcCfyANRSAGIAhqIBJJcUUEQCAHIAYgCWogCGogAhCAFCAIaiEHIAkMAQsgFCAJIAcgBiAUaiAIaiACIB0gHBDNKCAIaiIHIAZqIBJJGwshEAJAIAcgCk0NACADKAIAZyAPIAZrIghBAWpnayAHIAprQQJ0SARAIAMgCEEDajYCACAHIQoLIAYgB2ogFiAHIBYgBmtLGyEWIAEgB2ogAkcNACARQQAgBUECRxshEQwCCyAVIAYgHnFBA3RqIQgCQAJAAkAgBiAQaiAHai0AACABIAdqLQAASQRAIBMgBjYCACAGIB9LDQEgGEEIaiETDAULIA4gBjYCACAGIB9NDQIgByELIAghDgwBCyAHIQwgCEEEaiITIQgLIBFBAWshESAIKAIAIQYMAQsLIBhBCGohDgsgDkEANgIAIBNBADYCAAJAIBFFIAVBAkdyDQAgACgCtAEiBSgCACIcIAUoAgQiHWsiGUF/IAUoArwBQQFrdEF/cyISayAFKAIQIhMgGSATayASSxshFCAFKAJcIAEgBSgCwAEgBBCjHUECdGohDCAJIAAoAgxqIQ0gASAJIAAoAhAgGWtqIg5rIgRBA2ohECAEQQFqIQcgBSgCZCEFQQAhC0EAIQgDQCARRQ0BIAwoAgAiCSATTQ0BIAogASALIAggCCALSxsiBmogCSAdaiIEIAZqIAIgHCANEM0oIAZqIgZJBEAgAygCAEEBamcgByAJa2drIAYgCmtBAnRIBEAgAyAQIAlrNgIAIAYhCgsgASAGaiACRg0CCyAFIAkgEnFBA3RqIQwCQCAEIAkgDmogBiAJaiAZSRsgBmotAAAgASAGai0AAEkEQCAJIBRNDQMgDEEEaiEMIAYhCyAIIQYMAQsgCSAUTQ0CCyARQQFrIREgBiEIDAALAAsgACAWQQhrNgIcCyAYQRBqJAAgCgujGQIcfwR+IwBB8ABrIgMkAAJAAkAgAkUNACABQUBrIRYgAUEQaiEYA0ACQAJAAkACQAJAAkACQAJAIAEoAjQiBgRAIAMgASgCLCAGbjYCPAJAIAEoAgxFDQAgGCADQTxqEOsMIR8gASgCACIGQQxrIQcgASgCBCIKIB+ncSEFIB9CGYhC/wCDQoGChIiQoMCAAX4hIUEAIQQgAygCPCETA0ACQCAFIAZqKQAAIiAgIYUiH0J/hSAfQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIh9QRQRAA0AgEyAHIB96p0EDdiAFaiAKcUF0bCIMaigCAEYNAiAfQgF9IB+DIh9QRQ0ACwsgICAgQgGGg0KAgYKEiJCgwIB/g1BFDQIgBSAEQQhqIgRqIApxIQUMAQsLIAYgDGoiBkEIaygCACIFIAUoAgAiBEEBajYCACAEQQBIDQYgBkEEaygCACEGDAgLIANBMGogASgCPEEIahCoISABKAIoIQUgAygCNCEEIAMgAygCPCITNgJcIAMgBTYCWEEAIQ4CQAJAIANBKGoiCCAEKAIUBH8gBEEYaiADQdgAahDnCyEfIAQoAgwiCiAfp3EhDCAfQhmIQv8Ag0KBgoSIkKDAgAF+ISEgBCgCCCEHQQAhDQNAAkAgByAMaikAACIgICGFIh9Cf4UgH0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIfUEUEQANAIAcgH3qnQQN2IAxqIApxQQR0ayIGQRBrKAIAIAVGBEAgEyAGQQxrKAIARg0DCyAfQgF9IB+DIh9QRQ0ACwtBACEGICAgIEIBhoNCgIGChIiQoMCAf4NQRQ0AIAwgDUEIaiINaiAKcSEMDAELCyAGQRBrQQAgBhsFQQALIgZBCGpBACAGGyIGBH8gBigCACIOIA4oAgAiBUEBajYCACAFQQBIDQEgBigCBAUgBgs2AgQgCCAONgIADAELAAsgAygCLCEGIAMoAighBSAEQQA6AAAgBQRAIAUgBSgCACIEQQFqNgIAIARBAEgNBiADQSBqIAEgAygCPCAFIAYQ+QogAyADKAIkNgJcIAMgAygCICIENgJYIARFDQggBCAEKAIAIgRBAWs2AgAgBEEBRw0IIANB2ABqELsjDAgLIAEoAjQiCCADKAI8IhNsIgogASgCMCIGTQRAIAEoAiQhBSABKAIgIQwMAwsgAyAKIAZrIgc2AlAgA0HYAGogASgCICIMIAcgASgCJCIFKAIcEQEAIAMoAlwhBiADKAJYIgRBCEcNAyADIAY2AlQgBiAHRw0BIAEgCjYCMAwCC0Gk1s0AEOIrDAQLIANBADYCWEEAIANB1ABqIANB0ABqIANB2ABqQbTWzQAQrysACyADQdgAaiAMIAggBSgCFBEBACADKAJcIQYgAygCWCIEQQhGDQELIANByABqIANB7ABqKAIANgIAIAMgAykCZDcDQCADKAJgIQwMAgsgBkUNBSADQdgAaiAMIAUoAhgRAAAgAygCYCEMIAMoAlwhBSADKAJYIgRBCEcEQCADQcgAaiADQewAaigCADYCACADIAMpAmQ3A0AgBSEGDAILIANBGGogASgCPEEIahCoISABKAIoIQ0gAygCHCEUIAUgBSgCACIEQQFqNgIAIARBAEgNACADIAw2AlwgAyAFNgJYAkACQCADQdgAahC8KyIZIBQoAjBqIBQoAixNBEBBACEVQQAhEUEAIQ4jAEEQayIKJAAgCiATIgc2AgwgCiANNgIIIBRBCGoiBEEQaiIIIApBCGoQ5wshICAEKAIIRQRAIwBB0ABrIgckACAHIAg2AhwgBCgCDCEQIAcgB0EcajYCIAJAAkAgECAQQQFqIghNBEACQCAEKAIEIgkgCUEBakEDdkEHbCAJQQhJGyIJQQF2IAhJBEACfyAJQQFqIgkgCCAIIAlJGyIIQQ9PBEAgCEH/////AUsNBUF/IAhBA3RBB25BAWtndkEBagwBC0EEQQhBECAIQQhJGyAIQQRJGwshCCAHQUBrIARBEGoiC0EQQQggCBCdFCAHKAJEIQkgBygCQCINRQRAIAcoAkghCAwFCyAHKQJIIR8gCUEJaiIIBEAgDUH/ASAI/AsACyAHIB9CIIg+AjwgByAfpyIaNgI4IAcgCTYCNCAHIA02AjAgB0KQgICAgAE3AiggByALNgIkIAdBMGohGyAHIBAEfyANQQhqIRwgBCgCACIXKQMAQn+FQoCBgoSIkKDAgH+DIR9BACEIA0AgH1AEQANAIAhBCGohCCAXQQhqIhcpAwBCgIGChIiQoMCAf4MiH0KAgYKEiJCgwIB/UQ0ACyAfQoCBgoSIkKDAgH+FIR8LIA0gCSAHKAIcIAQoAgAgH3qnQQN2IAhqIh1BBHRrQRBrEOcLpyIecSILaikAAEKAgYKEiJCgwIB/gyIhUARAQQghDwNAIAsgD2ohCyAPQQhqIQ8gDSAJIAtxIgtqKQAAQoCBgoSIkKDAgH+DIiFQDQALCyAfQgF9IB+DIR8gDSAheqdBA3YgC2ogCXEiC2osAABBAE4EQCANKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgCyANaiAeQRl2Ig86AAAgHCALQQhrIAlxaiAPOgAAIA0gC0F/c0EEdGoiCyAEKAIAIB1Bf3NBBHRqIg8pAAA3AAAgC0EIaiAPQQhqKQAANwAAIBBBAWsiEA0ACyAEKAIMBUEACyIINgI8IAcgGiAIazYCOCAEIBtBBBD6KiAHQSRqENAmDAELIAQgB0EgakHspc8AQRAQxQkLQYGAgIB4IQkMAgsQ4ycgBygCDCEIIAcoAgghCQwBCxDjJyAHKAIUIQggBygCECEJCyAKIAg2AgQgCiAJNgIAIAdB0ABqJAAgCigCCCENIAooAgwhBwsgA0EQaiEPIAQoAgQiCyAgp3EhCCAgQhmIIiFC/wCDQoGChIiQoMCAAX4hIiAEKAIAIQkDQAJAAn8CQAJAAkAgCCAJaikAACIgICKFIh9Cf4UgH0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIfUEUEQANAIAkgH3qnQQN2IAhqIAtxQQR0ayIQQRBrKAIAIA1GBEAgByAQQQxrKAIARg0DCyAfQgF9IB+DIh9QRQ0ACwsgIEKAgYKEiJCgwIB/gyEfIBVFBEAgH1ANAyAfeqdBA3YgCGogC3EhEQtBASAfICBCAYaDUA0DGkEAIQggCSARaiwAACIVQQBOBEAgCSAJKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhFQsgCSARaiAhp0H/AHEiDjoAACAJIBFBCGsgC3FqQQhqIA46AAAgBCAEKAIIIBVBAXFrNgIIIAQgBCgCDEEBajYCDCAJIBFBBHRrIg5BEGsgDTYCACAOQQxrIAc2AgAgDkEIayAFNgIAIA5BBGsgDDYCAAwBCyAQQQRrIgQoAgAhDiAEIAw2AgAgEEEIayIEKAIAIQggBCAFNgIACyAPIA42AgQgDyAINgIAIApBEGokAAwCC0EACyEVIAggDkEIaiIOaiALcSEIDAELCyADKAIQRQ0BQdjpzQBBJEH86c0AEJ8pAAsgBSAFKAIAIgRBAWs2AgAgBEEBRw0BIANB2ABqELsjDAELIBQgFCgCMCAZajYCMAsgFEEAOgAAIANBCGogASATIAUgDBD5CiADIAMoAgw2AlwgAyADKAIIIgU2AlgCQCAFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQdgAahC7IwsgASABKAIwIAZqIgQ2AjAgASABKAI4IgUEfyAFIAUoAgggBmo2AgggASgCMAUgBAsgASgCLCIEayIFIAIgEmsiCiAFIApJGyIFIARqNgIsIBYgBRDZECAFIBJqIRIgBiABKAI0SQ0FDAMLAAsgACAMNgIIIAAgBjYCBCAAIAQ2AgAgACADKQNANwIMIABBFGogA0HIAGooAgA2AgAMBAsgAyAGNgJcIAYoAgghBCADIAU2AlggBSAEQQFrQXhxakEIaiAGKAIkEQQAIAEoAjQgAygCPGxqIgYgASgCLCIFTQRAIAMoAlgiASABKAIAIgFBAWs2AgAgAUEBRw0DIANB2ABqELsjDAMLIAYgBWsiBiACIBJrIgQgBCAGSxshBiABIAEoAjgiBAR/IAQgBCgCDCAGajYCDCABKAIsBSAFCyAGajYCLCAWIAYQ2RAgAygCWCIFIAUoAgAiBUEBazYCACAFQQFGBEAgA0HYAGoQuyMLIAYgEmohEgsgAiASSw0ACwsgAEEINgIAIAAgEjYCBAsgA0HwAGokAAvBDgIGfwh+IwBB8AFrIgMkACABQQxqENo8IQcgA0HYAGogARCSNhDuJSAHQQV0IgQhBQJAAkACQAJAAkACQAJAAkAgBEEgcSIGBEAgBCAGa0FAayIFIARJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgAyAGNgJ4IAMgBTYCdCADQcAANgJwIAQEQCAGQQAgBPwLAAsgAyAHNgKAASADIAQ2AnwgAygCWEUNAyADKAJsIAMoAmhGDQQgA0GQAWogA0HYAGoQyDQgA0GwAWohBCACKAIIIQUgAigCACECIAEoAhAhBwJAA0ACQCADKQO4ASIKUEUEQCADKQPAASEJDAELA0ACfgJAIAMpA6ABIglCA1IEQAJAAkACQCAJQgJRDQAgAyAJUK1CAYY3A6ABIAmnQQFxRQ0AIAMgAykDqAE3A9gBDAELIAMoArABRQ0BIANB0AFqIAQQtiogAykD0AEhCQsgCUIAUg0CCyADQgM3A6ABCyADKQOQASIJQgJRDQogA0IANwOQASADKQOYAQwBCyADKQPYAQshCiAJp0EBcUUNCCADIAMpA8ABQkB9Igk3A8ABIAMgCjcDuAEgClANAAsLIAMgCkIBIAp6IguGhTcDuAFCgICAgICAgICAfyEMQgAhDQJAAn4CQAJAIAcgC6cgCadqIghBBHRqIgEpAwAiDiABKQMIIg9CgICAgICAgICAf4WEQgBSIAIoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCUIAIQsMAQsgCSAKhFANAyADQUBrIA4gDyAKIAkQgxkgA0EwaiADKQNAIgsgAykDSCIMIAogCRCoHkIAIA4gAykDMCIQfSAJIAqDQn9RIgEbIQ1CACAPIAMpAzh9IA4gEFStfSABGyEJIA9CAFkNAQsgCyANIAIoAggiASkDAFggCSABKQMIIgpXIAkgClEbrSIKfSEJIAwgCiALVq19DAELIAwgCyANIAIoAgQiASkDAFogCSABKQMIIgpZIAkgClEbrXwiCSALVK18CyELIANB0AFqIgEgCSALELIuIAEgAykD0AEiCSADKQPYASILIAMpA+ABIgogAykD6AEiDCAFLQAAENAOIAMoAtABIgFBk4CAgHhHDQIgBiAIQQV0aiIBIAw3AxggASAKNwMQIAEgCzcDCCABIAk3AwAMAQsLQcyP/wAQ4isACyADKQLUASEJIAAgAykC3AE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQZABakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACECA0BCgICAgICAgICAfyEMAn4CQAJAIAQpAwAiDSAEKQMIIg5CgICAgICAgICAf4WEQgBSIAUoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCkIAIQlCACELDAELIAkgCoRQDQggA0EgaiANIA4gCiAJEIMZIANBEGogAykDICILIAMpAygiDCAKIAkQqB5CACANIAMpAxAiD30gCSAKg0J/USIBGyEKQgAgDiADKQMYfSANIA9UrX0gARshCSAOQgBZDQELIAsgCiAFKAIIIgEpAwBYIAkgASkDCCIKVyAJIApRG60iCn0hCSAMIAogC1atfQwBCyAMIAsgCiAFKAIEIgEpAwBaIAkgASkDCCIKWSAJIApRG618IgkgC1StfAshCyADQZABaiIBIAkgCxCyLiABIAMpA5ABIgkgAykDmAEiCyADKQOgASIKIAMpA6gBIgwgCC0AABDQDiADKAKQASIBQZOAgIB4Rw0CIAYgCTcDACAGQRhqIAw3AwAgBkEQaiAKNwMAIAYgCzcDCCAEQRBqIQQgBkEgaiEGIAcgAkEBaiICRw0ACwsgA0GQAWoiAhCXKSADQfgAaiIBKAIAIQUgAygCfCEGIAEgA0GYAWoiBCkCADcDACADKQNwIQkgAyADKQKQATcDcCADQQA2AoABIAMgCTcCnAEgA0EANgKYASADIAY2ApQBIAMgBTYCkAEgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCkAE3AgggAUEQaiAEKQIANwIAIAFBGGogA0GgAWoiBygCADYCACADIAY2AtgBIAMgBTYC1AEgAyABNgLQASADQYQBaiIBIANB0AFqEOIZIAcgA0HoAGopAgA3AwAgBCADQeAAaikCADcDACADIAMpAlg3A5ABIAAgASACEM4dIANB8ABqEM8vDAILIAMpApQBIQkgACADKQKcATcCEAsgACAJNwIIIABBKToAACAAIAE2AgQgA0HwAGoQzy8gAygCWCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQdgAahD7HgsgA0HwAWokAA8LQcyP/wAQ4isAC0EEQRwQoz0AC4APAgh/BH4jAEGQAWsiAiQAIAJB+ABqIAEQ8ScgAkHoAGoiBCACQYQBaiIFKAIANgIAIAIgAikCfDcDYAJAIAIoAngiBkEERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAY2AgggAEICNwMAIABBFGogBCgCADYCAAwBCyACQdAAaiAEKAIANgIAIAIgAikDYDcDSCACQcgAahCGMCACQYCAgIB4NgIIIAJBgICAgHg2AhggAkGAgICAeDYCKCACQYCAgIB4NgI4IAJB+ABqIAEQsw4gBCAFKQIANwMAIAJB8ABqIgYgAkGMAWooAgA2AgAgAiACKQJ8NwNgAkACQAJAAkAgAigCeEUEQCACQfwAaiEEQQIhB0ECIQgDQCACQdgAaiAGKAIAIgM2AgAgAkHQAGogAkHoAGoiBSkDADcDACACIAIpA2A3A0gCQAJAIANB/wFxBEAgAkH4AGogAkHIAGoQ/BcgAi8BfCEDIAIoAngiCUEERwRAIAAgAikBfjcBDiAAQRRqIAJBhAFqKQEANwEAIAAgAzsBDCAAIAk2AgggAEICNwMADAgLAkACQAJAAkACQAJAAkACQAJAIANBAWsOCAABAgMEBQYHCAsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERg0JIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDwsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDwsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQRhqEIYwIAJBIGogAygCADYCACACIAIpA3g3AxgMCQsgAkH4AGogARCSIyACKAJ4DQwgAikDgAEhDEIBIQoMCAsgAkH4AGogARCSIyACKAJ4DQogAikDgAEhDUIBIQsMBwsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDAsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQShqEIYwIAJBMGogAygCADYCACACIAIpA3g3AygMBgsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMCwsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQThqEIYwIAJBQGsgAygCADYCACACIAIpA3g3AzgMBQsgAkH4AGogARDsEyACLQB8IQcgAigCeCIDQQRGDQQgACACKQB9NwANIABBFGogAkGEAWopAAA3AAAgACAHOgAMIAAgAzYCCCAAQgI3AwAMCQsgAkH4AGogARDsEyACLQB8IQggAigCeCIDQQRGDQMgACACKQB9NwANIABBFGogAkGEAWopAAA3AAAgACAIOgAMIAAgAzYCCCAAQgI3AwAMCAsgAkH4AGogASACLQBYQcAAELQCIAIoAngiA0EERg0CIAAgAikCfDcCDCAAQRRqIAJBhAFqKQIANwIAIABCAjcDACAAIAM2AggMBwsgAkHIAGoQhjAgAkH4AGogARCqKSACKAJ4IgFBBEcEQCAAIAIpAnw3AgwgAEEUaiACQYQBaikCADcCACAAQgI3AwAgACABNgIIDAgLIAAgAikDCDcCICAAIAIpAxg3AiwgACACKQMoNwI4IAAgAikDODcCRCAAIAc6AFAgACAIOgBRIAAgDTcDGCAAIAs3AxAgACAMNwMIIAAgCjcDACAAQShqIAJBEGooAgA2AgAgAEE0aiACQSBqKAIANgIAIABBQGsgAkEwaigCADYCACAAQcwAaiACQUBrKAIANgIADAgLIAJBgAFqIgMgBSgCADYCACACIAIpA2A3A3ggAkEIahCGMCACQRBqIAMoAgA2AgAgAiACKQN4NwMICyACQcgAahCGMCACQfgAaiABELMOIAUgBEEIaikCADcDACAGIARBEGooAgA2AgAgAiAEKQIANwNgIAIoAnhFDQALCyAAIAIpA2A3AgggAEICNwMAIABBGGogBigCADYCACAAQRBqIAJB6ABqKQMANwIADAMLIAIoAnwhASACKQOAASEKIAAgAikDiAE3AhQgACAKNwIMIAAgATYCCCAAQgI3AwAMAQsgAigCfCEBIAIpA4ABIQogACACKQOIATcCFCAAIAo3AgwgACABNgIIIABCAjcDAAsgAkHIAGoQhjALIAJBOGoQhjAgAkEoahCGMCACQRhqEIYwIAJBCGoQhjALIAJBkAFqJAALgA8CCH8EfiMAQZABayICJAAgAkH4AGogARDxJyACQegAaiIEIAJBhAFqIgUoAgA2AgAgAiACKQJ8NwNgAkAgAigCeCIGQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgBjYCCCAAQgI3AwAgAEEUaiAEKAIANgIADAELIAJB0ABqIAQoAgA2AgAgAiACKQNgNwNIIAJByABqEIYwIAJBgICAgHg2AgggAkGAgICAeDYCGCACQYCAgIB4NgIoIAJBgICAgHg2AjggAkH4AGogARCyDiAEIAUpAgA3AwAgAkHwAGoiBiACQYwBaigCADYCACACIAIpAnw3A2ACQAJAAkACQCACKAJ4RQRAIAJB/ABqIQRBAiEHQQIhCANAIAJB2ABqIAYoAgAiAzYCACACQdAAaiACQegAaiIFKQMANwMAIAIgAikDYDcDSAJAAkAgA0H/AXEEQCACQfgAaiACQcgAahD8FyACLwF8IQMgAigCeCIJQQRHBEAgACACKQF+NwEOIABBFGogAkGEAWopAQA3AQAgACADOwEMIAAgCTYCCCAAQgI3AwAMCAsCQAJAAkACQAJAAkACQAJAAkAgA0EBaw4IAAECAwQFBgcICyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRGDQkgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwPCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwPCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBGGoQhjAgAkEgaiADKAIANgIAIAIgAikDeDcDGAwJCyACQfgAaiABEJEjIAIoAngNDCACKQOAASEMQgEhCgwICyACQfgAaiABEJEjIAIoAngNCiACKQOAASENQgEhCwwHCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwMCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBKGoQhjAgAkEwaiADKAIANgIAIAIgAikDeDcDKAwGCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwLCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBOGoQhjAgAkFAayADKAIANgIAIAIgAikDeDcDOAwFCyACQfgAaiABEOsTIAItAHwhByACKAJ4IgNBBEYNBCAAIAIpAH03AA0gAEEUaiACQYQBaikAADcAACAAIAc6AAwgACADNgIIIABCAjcDAAwJCyACQfgAaiABEOsTIAItAHwhCCACKAJ4IgNBBEYNAyAAIAIpAH03AA0gAEEUaiACQYQBaikAADcAACAAIAg6AAwgACADNgIIIABCAjcDAAwICyACQfgAaiABIAItAFhBwAAQswIgAigCeCIDQQRGDQIgACACKQJ8NwIMIABBFGogAkGEAWopAgA3AgAgAEICNwMAIAAgAzYCCAwHCyACQcgAahCGMCACQfgAaiABEKopIAIoAngiAUEERwRAIAAgAikCfDcCDCAAQRRqIAJBhAFqKQIANwIAIABCAjcDACAAIAE2AggMCAsgACACKQMINwIgIAAgAikDGDcCLCAAIAIpAyg3AjggACACKQM4NwJEIAAgBzoAUCAAIAg6AFEgACANNwMYIAAgCzcDECAAIAw3AwggACAKNwMAIABBKGogAkEQaigCADYCACAAQTRqIAJBIGooAgA2AgAgAEFAayACQTBqKAIANgIAIABBzABqIAJBQGsoAgA2AgAMCAsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQQhqEIYwIAJBEGogAygCADYCACACIAIpA3g3AwgLIAJByABqEIYwIAJB+ABqIAEQsg4gBSAEQQhqKQIANwMAIAYgBEEQaigCADYCACACIAQpAgA3A2AgAigCeEUNAAsLIAAgAikDYDcCCCAAQgI3AwAgAEEYaiAGKAIANgIAIABBEGogAkHoAGopAwA3AgAMAwsgAigCfCEBIAIpA4ABIQogACACKQOIATcCFCAAIAo3AgwgACABNgIIIABCAjcDAAwBCyACKAJ8IQEgAikDgAEhCiAAIAIpA4gBNwIUIAAgCjcCDCAAIAE2AgggAEICNwMACyACQcgAahCGMAsgAkE4ahCGMCACQShqEIYwIAJBGGoQhjAgAkEIahCGMAsgAkGQAWokAAucDQIKfwN+IwBBsAFrIgIkACABQQxqENg8IQUCQAJAAkAgARCSNiIDBEBBwAAhBiACQRBqIAMQ3DsgAygCFCEKIAMoAgwhByACKAIUIQggAigCECEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgZFDQMLIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCSAIEL8YDAELQcAAIQYgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBkUNAgsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCkUNAiAFIApGDQMgCQRAIAJB6ABqIAkgCCAHIAUQvxQgAkGIAWohCSABKAIQIQcgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogCRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgByAOpyAMp2oiCEEDdGorAwC2vCIFQf///wNxIQQgBUGAgICAeHEhAwJAIAVBgICA/AdxIgFBgICA/AdGBEAgBEENdiADQRB2ciAEQQBHQQl0ckGA+AFyIQMMAQsgA0EQdiEDIAFBgICAuARNBEAgAUGAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgAUENdiAEQQ12akGAgAFqIANyaiEDDAILIAFBgICAmANJDQEgBEGAgIAEciIFQR4gAUEXdiIEa3YhASAFQR0gBGsiBHZBAXEEfyABQQMgBHRBAWsgBXFBAEdqBSABCyADciEDDAELIANBgPgBciEDCyAGIAhBAXRqIAM7AQAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhA0EAIQkDQCADKwMAtrwiB0H///8DcSEIIAdBgICAgHhxIQECQCAHQYCAgPwHcSIEQYCAgPwHRgRAIAhBDXYgAUEQdnIgCEEAR0EJdHJBgPgBciEBDAELIAFBEHYhASAEQYCAgLgETQRAIARBgICAxANPBEAgB0EMdiAHQf/fAHFBAEdxIARBDXYgCEENdmpBgIABaiABcmohAQwCCyAEQYCAgJgDSQ0BIAhBgICABHIiB0EeIARBF3YiCGt2IQQgB0EdIAhrIgh2QQFxBH8gBEEDIAh0QQFrIAdxQQBHagUgBAsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiADQQhqIQMgBSAJQQFqIglHDQALCyACQcgAaiACQRxqIgQQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhCSACKAI8IQUgASACQfAAaiIGKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgCTYCaCACQQhqIAMQ1zsgAigCCCEJQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAGKQIANwIAIAFBGGogAkH4AGoiBygCADYCACACIAU2AqgBIAIgCTYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAcgAkHYAGooAgA2AgAgBiACQdAAaikCADcDACACIAIpAkg3A2ggAiAKNgJ8IAAgASADEM8dIAJBMGoQzy8gBBDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC5wNAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEGIAJBEGogAxDcOyADKAIUIQogAygCDCEHIAIoAhQhCCACKAIQIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBkUNAwsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAJIAgQvxgMAQtBwAAhBiAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0CCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQMCQAJAAkAgBEE+cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAKRQ0CIAUgCkYNAyAJBEAgAkHoAGogCSAIIAcgBRC/FCACQYgBaiEJIAEoAhAhByACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAJELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAHIA6nIAynaiIIQQN0aikDALS8IgVB////A3EhBCAFQYCAgIB4cSEDAkAgBUGAgID8B3EiAUGAgID8B0YEQCAEQQ12IANBEHZyIARBAEdBCXRyQYD4AXIhAwwBCyADQRB2IQMgAUGAgIC4BE0EQCABQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSABQQ12IARBDXZqQYCAAWogA3JqIQMMAgsgAUGAgICYA0kNASAEQYCAgARyIgVBHiABQRd2IgRrdiEBIAVBHSAEayIEdkEBcQR/IAFBAyAEdEEBayAFcUEAR2oFIAELIANyIQMMAQsgA0GA+AFyIQMLIAYgCEEBdGogAzsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEDQQAhCQNAIAMpAwC0vCIHQf///wNxIQggB0GAgICAeHEhAQJAIAdBgICA/AdxIgRBgICA/AdGBEAgCEENdiABQRB2ciAIQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIARBgICAuARNBEAgBEGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgBEENdiAIQQ12akGAgAFqIAFyaiEBDAILIARBgICAmANJDQEgCEGAgIAEciIHQR4gBEEXdiIIa3YhBCAHQR0gCGsiCHZBAXEEfyAEQQMgCHRBAWsgB3FBAEdqBSAECyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIANBCGohAyAFIAlBAWoiCUcNAAsLIAJByABqIAJBHGoiBBCCFCACQegAaiIDEJcpIAJBOGoiASgCACEJIAIoAjwhBSABIAJB8ABqIgYpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAJNgJoIAJBCGogAxDXOyACKAIIIQlBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQfgAaiIHKAIANgIAIAIgBTYCqAEgAiAJNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgByACQdgAaigCADYCACAGIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAo2AnwgACABIAMQzx0gAkEwahDPLyAEEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALnA0CCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEIIAIoAhAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAkgCBC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAkEQCACQegAaiAJIAggByAFEL8UIAJBiAFqIQkgASgCECEHIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAkQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAcgDqcgDKdqIghBAnRqKAIAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAygCALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgA0EEaiEDIAUgCUEBaiIJRw0ACwsgAkHIAGogAkEcaiIEEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQkgAigCPCEFIAEgAkHwAGoiBikCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAk2AmggAkEIaiADENc7IAIoAgghCUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBikCADcCACABQRhqIAJB+ABqIgcoAgA2AgAgAiAFNgKoASACIAk2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAHIAJB2ABqKAIANgIAIAYgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCjYCfCAAIAEgAxDPHSACQTBqEM8vIAQQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuOEQIFfwF+IwBBgANrIgIkACABKQKIAiEHIAFCgICAgIABNwOIAiACQdABaiABQZACaiIDKAIANgIAIANBADYCACACIAc3A8gBIAJBBGoiBSACQcgBaiIDIAFB0AJqIgYQ3hggAkEAOwGgAiACQQA2ApwCIAJBADYChAIgAkEANgL4ASACQQw6AOgBIAJCBDcC4AEgAkIANwLYASACQoCAgIDAADcC0AEgAkEANgLIASACIAEoAqQCNgL0ASACQewAaiIEIAMgBRD6IyADIAEQ1hggAkEQaiIFIAQgAxCuFiADIAUQzRwgBCADEMcTAkACQAJAAkACQAJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGoiAyAEQTD8CgAAIAJBhOLNADYCqAIgAiAFNgKkAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGLQAAIgRBAmsOBgECHh4DBAALAkACQAJAAkAgBEEiaw4FASEXAgMACyAEQQ9GDQcMIAsgASgC2AItAABBI2sOBAoHCAkUCyADLQAAQQRrDgIVFhcLIAMtAABBBGsOAhcYGQsgA0Hc4s0AELgIRQ0cQejizQAQsjsACyADQdzizQAQuAhFDRtB0OPNABCyOwALIANB3OLNABC4CEUNGkG45M0AELI7AAsgA0Hc4s0AELgIRQ0ZQaDlzQAQsjsACyADQdzizQAQuAhFDRggAkHIAWogAkGkAmpBtMjNAEGI5s0AEOkjIAIoAtABIQMgAigCzAEhBCACKALIASIFQZOAgIB4RwRAIAIgAikC1AE3ArgCIAIgAzYCtAIgAiAENgKwAiACIAU2AqwCIAAgAkGsAmoQpiUMGwsgAiADNgJwIAIgBDYCbCACQcgBaiACQewAaiIEQbTIzQAgBhDpIyACKALQASEDIAIoAswBIQYgAigCyAEiBUGTgICAeEcEQCACIAIpAtQBNwLMAiACIAM2AsgCIAIgBjYCxAIgAiAFNgLAAiAAIAJBwAJqEKYlIAIoAmwiACAAKAIAIgBBAWs2AgAgAEEBRw0bIAQQuyMMGwsgAigCbCIEIAQoAgAiBEEBazYCACAEQQFHDRkgAkHsAGoQuyMMGQsgAy0AAEEEaw4CAwQFCyADLQAAQQRrDgIFBgcLIAMtAABBBGsOAgcICQsgAy0AAEEERg0TIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADBYLQdzmzQAQsjsAC0Hs5s0AELI7AAsgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMEwtB/ObNABCyOwALQYznzQAQsjsACyACQQI2AswBIAJBzObNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEKIYIABBAzYCAAwQC0H0580AELI7AAtBhOjNABCyOwALIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADA0LIAJByAFqIAJBpAJqQbTIzQAgBhDpIyACKALQASEDIAIoAswBIQYgAigCyAEiBEGTgICAeEYNCyACIAIpAtQBNwLkAiACIAM2AuACIAIgBjYC3AIgAiAENgLYAiAAIAJB2AJqEKYlDAwLIANB3OLNABC4CEUNCSADLQAAQQRGDQcgAkECNgLMASACQYjpzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCZDiAAQQM2AgAMCwtBmOnNABCyOwALQajpzQAQsjsACyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEJkOIABBAzYCAAwIC0G46c0AELI7AAtByOnNABCyOwALIAJBAjYCzAEgAkGI6c0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQmQ4gAEEDNgIADAULQQRBOBCjPQALQezozQAQsjsAC0GU5s0AELI7AAsgAkHIAWogAkGkAmpBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIEQZOAgIB4Rg0AIAIgAikC1AE3AvgCIAIgAzYC9AIgAiAGNgLwAiACIAQ2AuwCIAAgAkHsAmoQpiUMAQsCf0GAgICAeCABKALgASIEQYGAgIB4Rg0AGkGAgICAeCAEQYCAgIB4Rg0AGiABKQLkASEHIAFBADYC6AEgAUKAgICAIDcD4AEgBAshBCABQbgCahC0MCABIAc3ArwCIAEgBDYCuAIgASgClAIiBEGAgICAeEcEQCABKQOYAiEHIAFBADYCnAIgAUKAgICAIDcClAILIAFBxAJqELQwIAEgBzcDyAIgASAENgLEAiABQgA3AqQCIAAgAzYCCCAAIAY2AgQgAEEINgIAIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUYNAQwCCyACKAKkAiIAIAAoAgAiAEEBazYCACAAQQFHDQELIAJBpAJqELsjCyACQYADaiQAC44RAgV/AX4jAEGAA2siAiQAIAEpAogCIQcgAUKAgICAwAA3A4gCIAJB0AFqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAIgBzcDyAEgAkEEaiIFIAJByAFqIgMgAUHQAmoiBhDdGCACQQA7AaACIAJBADYCnAIgAkEANgKEAiACQQA2AvgBIAJBCzoA6AEgAkIENwLgASACQgA3AtgBIAJCgICAgMAANwLQASACQQA2AsgBIAIgASgCpAI2AvQBIAJB7ABqIgQgAyAFEPojIAMgARDWGCACQRBqIgUgBCADEK4WIAMgBRDNHCAEIAMQsxMCQAJAAkACQAJAAkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiIDIARBMPwKAAAgAkGs4c0ANgKoAiACIAU2AqQCAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYtAAAiBEECaw4GAQIeHgMEAAsCQAJAAkACQCAEQSJrDgUBIRcCAwALIARBD0YNBwwgCyABKALYAi0AAEEjaw4ECgcICRQLIAMtAABBBGsOAhUWFwsgAy0AAEEEaw4CFxgZCyADQdzizQAQuAhFDRxB6OLNABCyOwALIANB3OLNABC4CEUNG0HQ480AELI7AAsgA0Hc4s0AELgIRQ0aQbjkzQAQsjsACyADQdzizQAQuAhFDRlBoOXNABCyOwALIANB3OLNABC4CEUNGCACQcgBaiACQaQCakG0yM0AQYjmzQAQ6SMgAigC0AEhAyACKALMASEEIAIoAsgBIgVBk4CAgHhHBEAgAiACKQLUATcCuAIgAiADNgK0AiACIAQ2ArACIAIgBTYCrAIgACACQawCahCmJQwbCyACIAM2AnAgAiAENgJsIAJByAFqIAJB7ABqIgRBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIFQZOAgIB4RwRAIAIgAikC1AE3AswCIAIgAzYCyAIgAiAGNgLEAiACIAU2AsACIAAgAkHAAmoQpiUgAigCbCIAIAAoAgAiAEEBazYCACAAQQFHDRsgBBC7IwwbCyACKAJsIgQgBCgCACIEQQFrNgIAIARBAUcNGSACQewAahC7IwwZCyADLQAAQQRrDgIDBAULIAMtAABBBGsOAgUGBwsgAy0AAEEEaw4CBwgJCyADLQAAQQRGDRMgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMFgtB3ObNABCyOwALQezmzQAQsjsACyACQQI2AswBIAJBzObNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEKIYIABBAzYCAAwTC0H85s0AELI7AAtBjOfNABCyOwALIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADBALQfTnzQAQsjsAC0GE6M0AELI7AAsgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMDQsgAkHIAWogAkGkAmpBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIEQZOAgIB4Rg0LIAIgAikC1AE3AuQCIAIgAzYC4AIgAiAGNgLcAiACIAQ2AtgCIAAgAkHYAmoQpiUMDAsgA0Hc4s0AELgIRQ0JIAMtAABBBEYNByACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEJkOIABBAzYCAAwLC0GY6c0AELI7AAtBqOnNABCyOwALIAJBAjYCzAEgAkGI6c0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQmQ4gAEEDNgIADAgLQbjpzQAQsjsAC0HI6c0AELI7AAsgAkECNgLMASACQYjpzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCZDiAAQQM2AgAMBQtBBEE4EKM9AAtB7OjNABCyOwALQZTmzQAQsjsACyACQcgBaiACQaQCakG0yM0AIAYQ6SMgAigC0AEhAyACKALMASEGIAIoAsgBIgRBk4CAgHhGDQAgAiACKQLUATcC+AIgAiADNgL0AiACIAY2AvACIAIgBDYC7AIgACACQewCahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIQcgAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgBzcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIQcgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAHNwPIAiABIAQ2AsQCIAFCADcCpAIgACADNgIIIAAgBjYCBCAAQQg2AgAgAigCpAIiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkGkAmoQuyMLIAJBgANqJAALmQ0CCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEIIAIoAhAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAkgCBC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAkEQCACQegAaiAJIAggByAFEL8UIAJBiAFqIQkgASgCECEHIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAkQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAcgDqcgDKdqQQF0IghqLgEAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIaiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAy4BALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgA0ECaiEDIAUgCUEBaiIJRw0ACwsgAkHIAGogAkEcaiIEEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQkgAigCPCEFIAEgAkHwAGoiBikCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAk2AmggAkEIaiADENc7IAIoAgghCUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBikCADcCACABQRhqIAJB+ABqIgcoAgA2AgAgAiAFNgKoASACIAk2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAHIAJB2ABqKAIANgIAIAYgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCjYCfCAAIAEgAxDPHSACQTBqEM8vIAQQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuYDQIKfwN+IwBBsAFrIgIkACABQQxqENs8IQUCQAJAAkAgARCSNiIDBEBBwAAhBiACQRBqIAMQ3DsgAygCFCEKIAMoAgwhByACKAIUIQggAigCECEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgZFDQMLIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCSAIEL8YDAELQcAAIQYgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBkUNAgsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCkUNAiAFIApGDQMgCQRAIAJB6ABqIAkgCCAHIAUQvxQgAkGIAWohCSABKAIQIQcgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogCRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgByAOpyAMp2oiCEECdGooAgAiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAygCACIHQf///wNxIQggB0GAgICAeHEhAQJAIAdBgICA/AdxIgRBgICA/AdGBEAgCEENdiABQRB2ciAIQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIARBgICAuARNBEAgBEGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgBEENdiAIQQ12akGAgAFqIAFyaiEBDAILIARBgICAmANJDQEgCEGAgIAEciIHQR4gBEEXdiIIa3YhBCAHQR0gCGsiCHZBAXEEfyAEQQMgCHRBAWsgB3FBAEdqBSAECyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIANBBGohAyAFIAlBAWoiCUcNAAsLIAJByABqIAJBHGoiBBCCFCACQegAaiIDEJcpIAJBOGoiASgCACEJIAIoAjwhBSABIAJB8ABqIgYpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAJNgJoIAJBCGogAxDXOyACKAIIIQlBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQfgAaiIHKAIANgIAIAIgBTYCqAEgAiAJNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgByACQdgAaigCADYCACAGIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAo2AnwgACABIAMQzx0gAkEwahDPLyAEEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALlQ0CCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEJIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggCRC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAgEQCACQegAaiAIIAkgByAFEL8UIAJBiAFqIQcgASgCECEIIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAcQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAggDqcgDKdqIglqLAAAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAJQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQlBACEDA0AgAyAJaiwAALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgQQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIGKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAGKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgBiACQdAAaikCADcDACACIAIpAkg3A2ggAiAKNgJ8IAAgASADEM8dIAJBMGoQzy8gBBDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC4QRAQl/IwBBoAJrIgYkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgARDzLSIILQAAQRtrDg4DDQAEDQECDQ0NDQ0HCA0LIAZBCGogARC5JiAGQbABaiIHIAYoAggiASAGKAIMKAIMEQAAIAFFDQggBikDsAFC/9nrqtfYi4zxAIUgBikDuAFCgfTho6r41uqLf4WEUEUNCCAHIAgoAghBCGogAUEMaiACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQwgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwPCyABQbjJ/gAQxSIhByAGQRhqIAhBBGoQwzQgBigCGCEBIAYoAhwhCCAGQRBqIAcQ3DsgBkGwAWogASABIAhBAnRqIAYoAhAiASABIAYoAhRBA3RqEMkiIAYoAsQBIgEgBigCwAEiCE0NCyABIAhrIQcgBigCsAEgCEECdGohASAGKAK4ASAIQQN0aiEIDAMLIAFBuMn+ABDGIiEHIAZBIGogCEEEahCwLiAGKAIgIgEgBigCJCIIRg0KDAMLIwBBIGsiByQAIAdBCGogAUHIyf4AKAIAEQAAIAdBEGogBygCCCIBIAcoAgwoAgwRAAACQCABBEAgBykDEEL75PLhsbPtw3yFIAcpAxhCgbfKnrar7cxuhYRQDQELQcj7/gBBIEHo+/4AEMskAAsgB0EgaiQAIAZBsAFqIAgoAgRBCGogAUEMaiACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQkgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwMCyMAQSBrIgckACAHQQhqIAFByMn+ACgCABEAACAHQRBqIAcoAggiASAHKAIMKAIMEQAAAkAgAQRAIAcpAxBC4//bxtnAsr/aAIUgBykDGELrqof3kZGQlSSFhFANAQtByPv+AEEgQej7/gAQyyQACyAHQSBqJAAgBkGwAWogCCgCBEEIaiABQQxqIAIgAyAEIAUQygMgBigCsAEiAUGTgICAeEYNCCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACABNgIADAsLA0ACQCAGQbABaiABKAIAQQhqIAggAiADIAQgBRDKAyAGKAKwASIJQZOAgIB4Rw0AIAFBBGohASAIQQhqIQggB0EBayIHDQEMCQsLIAAgBikCtAE3AgQgAEEMaiAGQbwBaikCADcCACAAIAk2AgAMCgsDQAJAIAcgAS0AABDZKCEJIAZBsAFqIAFBBGooAgBBCGogCSACIAMgBCAFEMoDIAYoArABIglBk4CAgHhHDQAgCCABQQhqIgFHDQEMCAsLIAAgBikCtAE3AgQgAEEMaiAGQbwBaikCADcCACAAIAk2AgAMCQsgAUG4yf4AEMciIQcCQCAIKAIEIgEtADBBIEYEQCAGQThqIAFBNGoiARDDNCAGKAI8QQJGDQEgCCgCBCEBCyAGQQE2ArQBIAZBiMv+ADYCsAEgBkIBNwK8ASAGQa8DNgJoIAYgAUEwajYClAIgBiAGQeQAajYCuAEgBiAGQZQCajYCZCAGQbABakGQy/4AEO8sAAsgBkEwaiABEMM0IAYoAjRFDQIgBigCMCEIIAZBKGogARDDNCAGKAIsIgFBAU0NAyAGKAIoIQEgBkGwAWogCCgCAEEIaiAHEPMvIAIgAyAEIAUQygMgBigCsAEiCEGTgICAeEcEQCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACAINgIADAkLIAZBsAFqIAEoAgRBCGogBxDyLSACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQUgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwICyAGQeQAaiIHIAEQwy0gBkHYAGogBxDvPCAGKAJcQQJHBEAgBkHQAGogBxDvPCAGQTs2ApgCIAZBATYCtAEgBkH0y/4ANgKwASAGQgE3ArwBIAYgBigCVDYCiAIgBiAGQYgCajYClAIgBiAGQZQCajYCuAEgAEEEaiAGQbABahCZDiAAQY2AgIB4NgIADAcLIAZByABqIAZB5ABqEO88IAYoAkwiAUEBSw0DQQEgAUGgy/4AEMMhAAtBkMr+AEErQbzK/gAQyyQAC0EAQQBBzMr+ABDDIQALQQEgAUHcyv4AEMMhDAILIAZB/AFqIAYoAkgiAUHcAGoQxQYgASgCbCEJIAEoAmghCyAGQYgCaiABQcQAahC+FSAGQZQCaiABQdAAahCACyABKAJwIgcEQCAHIAcoAgAiCkEBajYCACAKQQBIDQIgASgChAEhCiABKAKAASEMIAEoAnwhDSABKAJ4IQ4gASgCdCEBCyAGQdABaiAGQYQCaigCADYCACAGQbgBaiAGQZACaigCADYCACAGQcQBaiAGQZwCaigCADYCACAGIAYpAvwBNwPIASAGIAk2AtgBIAYgCzYC1AEgBiAGKQKIAjcDsAEgBiAGKQKUAjcCvAEgBiAKNgLwASAGIAw2AuwBIAYgDTYC6AEgBiAONgLkASAGIAE2AuABIAYgBzYC3AEgBkFAayAGQbABaiIHEKABIAYgBigCRDYCrAEgBiAGKAJAIgE2AqgBIAcgCCgCCEEIaiAGQagBaiIIIAIgAyAEIAUQygMgBigCsAEiAkGTgICAeEcEQCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACACNgIAIAEgASgCACIAQQFrNgIAIABBAUcNAyAIELsjDAMLIAEgASgCACIBQQFrNgIAIAFBAUYEQCAGQagBahC7IwsgBkHkAGoQ/iYLIABBk4CAgHg2AgAMAgsACyAGQeQAahD+JgsgBkGgAmokAAvqDgIVfwN+IwBBgANrIgQkACADLwEOIQoCfwJAAkACQCACKAIAIgJBCGoiDSACKAIIQQJGQQJ0ai0AICICQQAgAkEDRxsiEEEBaw4CAAIBC0EBIREgCkEBaiEKCyADLwEMDAELIApBAWohCiADLwEMQQFqCyEOIARBIGogDRCKJiAEKAIkIQIgBCgCICESAkACQAJAIAMtAAAiCEEgRwRAIAhBKUcNAQwCCyAEQRhqIANBBGoiCxDDNCAEKAIcIAJGDQEgBCACNgJcIARBEGogCxDDNCAEIAQoAhQ2ArgCIARBAjYC1AEgBEHY0s8ANgLQASAEQgI3AtwBIARBOzYCNCAEQTs2AiwgBCAEQShqNgLYASAEIARBuAJqNgIwIAQgBEHcAGo2AiggAEEMaiAEQdABahCZDiAAQYKAgIB4NgIAIABBAzYCCAwCCyAEIAM2ArgCIARBATYC1AEgBEGY088ANgLQASAEQgE3AtwBIARBpwQ2AiwgBCAEQShqNgLYASAEIARBuAJqNgIoIABBDGogBEHQAWoQmQ4gAEGCgICAeDYCACAAQQM2AggMAQsgBEEoaiACEJQXIARB0AFqIgggAkEAQQRBIBCgGCAEKALUASEJAkACQAJAIAQoAtABQQFHBEAgBEEANgJkIAQgBCgC2AE2AmAgBCAJNgJcIAJFDQIgAkECdCETIARBtAFqIQkgCEEEciEMIAhBAXIhD0EAIQIgBEGAAWpBAXIiFEEHaiEVQQAhCANAAkAgAiASaiEGAn8gC0UEQEEpIQVBAAwBCyAEQQhqIAsQwzQCQCAEKAIMIgUgCEsEQCAEKAIIIAJqIgUoAgAiBygCQCAHKAJEIAYoAgAiB0EIaiAHKAIIQQJGQQJ0aiIHKAIMIAcoAhAQwS4NASAEIAYoAgAiAUEIaiABKAIIQQJGQQJ0aikCDDcCdCAEIAUoAgBBPGo2AnwgBEECNgLUASAEQZDSzwA2AtABIARCAjcC3AEgBEGEATYCxAIgBEHMATYCvAIgBCAEQbgCajYC2AEgBCAEQfwAajYCwAIgBCAEQfQAajYCuAIgAEEMaiAEQdABahCZDiAAQYKAgIB4NgIAIABBAzYCCAwICyAIIAVBuNHPABDDIQALIARB0AFqIAUoAgBBMGoQwwYgBCAPKQAANwNoIAQgD0EHaigAADYAbyAELQDQASEFIAQgCxDDNCAIIAQoAgQiB08NASAEKAIAIAJqKAIAQQhqCyEHIBQgBCkDaDcAACAVIAQoAG82AAAgBCAKOwGOASAEIA47AYwBIAQgBToAgAEgBEHQAWogASAGIARBgAFqENIBIAQoAtABIgVBgoCAgHhGBEAgBEGkAWogBEHoAWopAwAiGTcCACAEQZwBaiAEQeABaikDACIaNwIAIAQgBCkD2AEiGzcClAEgAEEYaiAZNwIAIABBEGogGjcCACAAIBs3AgggAEGCgICAeDYCAAwGCyAEQagBaiIWIAxBGGooAgA2AgAgBEGgAWoiFyAMQRBqKQIANwMAIARBmAFqIhggDEEIaikCADcDACAEIAwpAgA3A5ABIAVBgYCAgHhHBEAgCSAEKQOQATcCACAJQQhqIBgpAwA3AgAgCUEQaiAXKQMANwIAIAlBGGogFigCADYCACAEIAU2ArABIARB0AFqIgUgBigCAEEIaiAEQbABaiAHEKsJIARBKGogBRCIKSAEKAJkIgUgBCgCXEYEQCMAQRBrIgYkACAGQQhqIARB3ABqIgcgBygCAEEBQQRBIBC3ESAGKAIIIgdBgYCAgHhHBEAgByAGKAIMQcjRzwAQ/S8ACyAGQRBqJAALIAQoAmAgBUEFdGoiBiAEKQKwATcCACAGQQhqIARBuAFqKQIANwIAIAZBEGogBEHAAWopAgA3AgAgBkEYaiAEQcgBaikCADcCACAEIAVBAWo2AmQLIAhBAWohCCACQQRqIgIgE0cNAQwDCwsgCCAHQaDTzwAQwyEACyAJIAQoAtgBQajRzwAQ/S8ACyAEKAJkRQ0AIARB0AFqIgEgBEEoakEw/AoAACAEQbgCaiABEPEfIARBoAJqIgEgBEHkAGooAgA2AgAgBCAROgC0AiAEIAo7AbICIAQgDjsBsAIgBEEgOgCkAiAEIAQpAlw3A5gCIAQgBCkDuAI3A6gCIARBwAJqEJMnAkAgEEECRgRAIARB4AJqIARBmAJqIA0gDSgCAEECRkECdGoiASgCDCABKAIQENoTDAELIARB+AJqIARBsAJqKQMANwMAIARB8AJqIARBqAJqKQMANwMAIARB6AJqIAEpAwA3AwAgBCAEKQOYAjcD4AILIAAgBCkD4AI3AgAgAEEYaiAEQfgCaikDADcCACAAQRBqIARB8AJqKQMANwIAIABBCGogBEHoAmopAwA3AgAMAgsgAEGBgICAeDYCAAsgBEHcAGoiABC+HyAAQQRBIBDgHiAEQcgAaiIAEMcnIAAQ6TsgBEEoahCTJwsgAy0AAEEpRwRAIAMQnQwLIARBgANqJAAL7Q4CBn8BfiMAQbABayIEJAAgBCADNgIYIAQgAjYCFCAEIARBFGo2AhwCQAJAAkACQCADQQpPBEAgBEH4AGpCADcDACAEQfAAakIANwMAIARB6ABqQgA3AwAgBEIANwNgQSAgAyADQSBPGyEHA0AgBEHgAGoiCCAGaiACIAZqLQAAQTBrIgk6AAAgCUH/AXFBCkkgBnQgBXIhBSAHIAZBAWoiBkcNAAsgBEE4aiAEQfgAaikDADcDACAEQTBqIARB8ABqKQMANwMAIARBKGogBEHoAGopAwA3AwAgBCAEKQNgNwMgIAQgBTYCQCAEQSBqEI0cIgZFBEAgBEESNgJUIARB3MSAATYCUCAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEHQAGo2AqgBIAQgBEEUajYCoAEgBEGIAWogCBCZDiAAIAQpAowBNwIIIABBEGogBEGUAWooAgA2AgAgACAEKAKIATYCBCAAQYSAgIB4NgIADAULIANBCkYEQCAEQgA3AkggBCAGNgJEIARB4ABqIgIgASAEQcQAahCMLCAEQdAAaiACEL4sIAQoAlAEQCAAIAQpAlA3AgQgAEGTgICAeDYCACAAQQxqIARB2ABqKQIANwIADAYLIARBHzYCnAEgBEHuxIABNgKYASAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEGYAWo2AqgBIAQgBEEUajYCoAEgBEGIAWogBEHgAGoQmQ4gBEGEgICAeDYChAEgAEEQaiAEQZQBaigCADYCACAAQQhqIARBjAFqKQIANwIAIAAgBCkChAE3AgAMBQsgBC0AKiIFQSRGIAVBxABGciAFQfABRnJFBEAgBEEbNgKkASAEQdDDgAE2AqABIARBAjYCZCAEQczEgAE2AmAgBEICNwJsIARBzAE2ApABIARBzAE2AogBIAQgBEGEAWo2AmggBCAEQaABajYCjAEgBCAEQRRqNgKEASAAQQRqIARB4ABqEJkOIABBhICAgHg2AgAMBQsgBEHQAGogBEEgahCDBiAEKAJQRQRAIARBEjYCSCAEQY3FgAE2AkQgBEECNgJkIARBzMSAATYCYCAEQgI3AmwgBEHMATYCrAEgBEHMATYCpAEgBCAEQaABajYCaCAEIARBxABqNgKoASAEIARBFGo2AqABIARBiAFqIARB4ABqEJkOIAQpAogBIQogACAEKQKQATcCDCAAIAo3AgQgAEGEgICAeDYCAAwFCyAEKAJcIQUgBCAEKQJUNwJIIAQgBjYCRCADQSFJDQFBICEGIAVBIEcNAQNAIAIgBmotAABBMGtB/wFxQQlLBEAgBiEFDAMLIAMgBkEBaiIGRw0ACwwCCyAEQS02AqQBIARB/MOAATYCoAEgBEECNgJkIARBzMSAATYCYCAEQgI3AmwgBEHMATYCkAEgBEHMATYCiAEgBCAEQYQBajYCaCAEIARBoAFqNgKMASAEIARBFGo2AoQBIARBJGogBEHgAGoQmQ4gBEGEgICAeDYCICAAQRBqIARBMGooAgA2AgAgAEEIaiAEQShqKQIANwIAIAAgBCkCIDcCAAwDCyADIAVLDQELIARB4ABqIgIgASAEQcQAahCMLCAEQdAAaiACEL4sIAQoAlAEQCAAIAQpAlA3AgQgAEGTgICAeDYCACAAQQxqIARB2ABqKQIANwIADAILIARBHzYCnAEgBEHuxIABNgKYASAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEGYAWo2AqgBIAQgBEEUajYCoAEgBEGIAWogBEHgAGoQmQ4gBEGEgICAeDYChAEgAEEQaiAEQZQBaigCADYCACAAQQhqIARBjAFqKQIANwIAIAAgBCkChAE3AgAMAQsCQAJAIAIgBWotAAAiAkH6AEYEQCAFIANBAWtGDQEMAgsgBSADQQFrRyACQdoAR3INAQsgAEEEaiABIARBxABqEPAtIABBk4CAgHg2AgAMAQsgBEEIaiAEKAIUIAQoAhggBRDqJSAEIAQoAgggBCgCDBCvDiAEQeAAaiAEKAIAIAQoAgQQihggBCgCZCECIAQoAmAiA0GTgICAeEcEQCAAIAQpAmg3AgggAEEQaiAEQfAAaigCADYCACAAIAI2AgQgACADNgIADAELIAQgAjYCmAEgBEHgAGoiAiAEQZgBaiAEQcQAahCMLCAEQYQBaiIDIAIQviwgAiADIARBHGoQ3hUgBEGoAWoiAiAEQewAaikCADcDACAEIAQpAmQ3A6ABIAQoAmAiA0GTgICAeEcEQCAAIAQpA6ABNwIEIAAgAzYCACAAQQxqIAIpAwA3AgAMAQsgBEHYAGogAikDADcDACAEIAQpA6ABNwNQIABBBGogASAEQdAAahDwLSAAQZOAgIB4NgIACyAEQbABaiQAC4gOAgp/BH4jAEHAAWsiBCQAAkACfyAAIAGEUARAQSYhAyACQSZqQTA6AAAMAgsCQCABUCAAQoCAhP6m3uERVHFFBEAgBEHwAGogAEIAQu3UifOh8+uFU0IAEKgeIARBgAFqIAFCAELt1InzofPrhVNCABCoHiAEQeAAaiAAQgBC1vDNiPul2dI5QgAQqB4gBEGQAWogAUIAQtbwzYj7pdnSOUIAEKgeIARBoAFqIAAgAUIAQgAQqB4gBEGwAWogBCkDkAEiDSAEKQOIASAEKQOAASIBIAQpA3h8Ig4gAVStfCIPIAQpA2ggBCkDYCIBIA58IAFUrXx8Ig58IgEgBCkDoAF8IhBCM4ggASAQVq0gBCkDqAEgASANVK0gBCkDmAEgDiAPVK18fHx8Ig1CDYaEIgEgDUIziCINQoCA/IHZoZ5uQgAQqB4gAiAEKQOwASAAfCIAIABCkM4AgCIOQpDOAH59pyIDQf//A3FB5ABuIgVBAXQiBkHi84kBai0AADoAIyACIAZB4/OJAWotAAA6ACQgAiADIAVB5ABsa0EBdEH+/wdxIgNB4vOJAWotAAA6ACUgAiADQePziQFqLQAAOgAmIAIgDkKQzgCCpyIDQeQAbiIFQQF0IgZB4/OJAWotAAA6ACAgAiAGQeLziQFqLQAAOgAfIAIgAyAFQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAiIAIgA0Hi84kBai0AADoAISACIABCgMLXL4BCkM4AgqciA0HkAG4iBUEBdCIGQePziQFqLQAAOgAcIAIgBkHi84kBai0AADoAGyACIABCgKCUpY0dgKdBkM4AcCIGQeQAbiIHQQF0IghB4/OJAWotAAA6ABggAiAIQeLziQFqLQAAOgAXIAIgAyAFQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAeIAIgA0Hi84kBai0AADoAHSACIAYgB0HkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAGiACIANB4vOJAWotAAA6ABkgDVAgAUKAgIT+pt7hEVRxRQ0BIAEhAEEXDAILQScMAQsgBEEQaiABQgBC7dSJ86Hz64VTQgAQqB4gBEEgaiANQgBC7dSJ86Hz64VTQgAQqB4gBCABQgBC1vDNiPul2dI5QgAQqB4gBEEwaiANQgBC1vDNiPul2dI5QgAQqB4gBEFAayABIA1CAEIAEKgeIARB0ABqIAQpAzAiDSAEKQMoIAQpAyAiACAEKQMYfCIOIABUrXwiDyAEKQMIIAQpAwAiACAOfCAAVK18fCIOfCIAIAQpA0B8IhBCM4ggACAQVq0gBCkDSCAAIA1UrSAEKQM4IA4gD1StfHx8fCINQg2GhCIAIA1CM4hCgID8gdmhnm5CABCoHiACIAQpA1AgAXwiAUKQzgCAIg1CkM4AgqciA0HkAG4iBUEBdCIGQePziQFqLQAAOgAQIAIgBkHi84kBai0AADoADyACIAFCgMLXL4BCkM4AgqciBkHkAG4iB0EBdCIIQePziQFqLQAAOgAMIAIgCEHi84kBai0AADoACyACIAFCgKCUpY0dgKdBkM4AcCIIQeQAbiIJQQF0IgpB4/OJAWotAAA6AAggAiAKQeLziQFqLQAAOgAHIAIgASANQpDOAH59pyIKQf//A3FB5ABuIgtBAXQiDEHj84kBai0AADoAFCACIAxB4vOJAWotAAA6ABMgAiADIAVB5ABsa0H//wNxQQF0IgNB4/OJAWotAAA6ABIgAiADQeLziQFqLQAAOgARIAIgBiAHQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAOIAIgA0Hi84kBai0AADoADSACIAggCUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoACiACIANB4vOJAWotAAA6AAkgAiAKIAtB5ABsa0H//wNxQQF0IgNB4/OJAWotAAA6ABYgAiADQeLziQFqLQAAOgAVQQcLIQMCQCAAQugHVARAIAAhAQwBCyACQQRrIQYDQCADIAZqIgVBAWogACAAQpDOAIAiAUKQzgB+faciB0H//wNxQeQAbiIIQQF0IglB4/OJAWotAAA6AAAgBSAJQeLziQFqLQAAOgAAIAVBA2ogByAIQeQAbGtB//8DcUEBdCIHQePziQFqLQAAOgAAIAVBAmogB0Hi84kBai0AADoAACADQQRrIQMgAEL/rOIEViABIQANAAsLIAFCCVYEQCACIANqQQFrIAGnIgUgBUH//wNxQeQAbiIFQeQAbGtB//8DcUEBdCIGQePziQFqLQAAOgAAIAIgA0ECayIDaiAGQeLziQFqLQAAOgAAIAWtIQELIAFQDQAgAiADQQFrIgNqIAGnQQF0QR5xQePziQFqLQAAOgAACyAEQcABaiQAIAML1BECE38BfiMAQZACayICJAAgAkHUAWogAUEIEN0QIAIoAtwBIQwgAigC2AEhBgJAIAIoAtQBIgRBioCAgHhHBEAgACACKQLgATcCDCAAQRxqIAJB8AFqKQIANwIAIABBFGogAkHoAWopAgA3AgAgACAMNgIIIAAgBjYCBCAAIAQ2AgAMAQsgBkEBcQRAIAJB1AFqIAEoAgAiBiAMEJMOIAIoAtgBIQUCQCACKALUASIEQYqAgIB4RwRAIAJB0AFqIAJB9AFqKAIANgIAIAJByAFqIAJB7AFqKQIANwIAIAJBwAFqIAJB5AFqKQIANwIAIAIgAikC3AE3ArgBIAIgBTYCtAEgAiAENgKwAQwBCyACQdQBaiEEIwBBMGsiAyQAIANBDGogBkF/IAUgDGoiByAFIAdLGyIFEJMOIAMoAhAhBwJAIAMoAgwiCUGKgICAeEcEQCAEIAMpAhQ3AgggBEEgaiADQSxqKAIANgIAIARBGGogA0EkaikCADcCACAEQRBqIANBHGopAgA3AgAgBCAHNgIEIAQgCTYCAAwBC0F/IAVBBGoiCSAFIAlLGyIFQQNxBEAgBCAFNgIcIARBywA2AhggBEG/5P4ANgIUIARBgICAgHg2AhAgBEIENwIIIARChICAgAg3AgAMAQsCQAJAQX8gBUF/IAdBAnQgB0H/////A0sbIglqIgcgBSAHSxsiByAGKAIETQRAIAYgBigCFCAJaiIKNgIUQYiAgIB4IQkgCiAGKAIIKAIISw0BDAILIANBDGogBSAHEL8vIAMoAgwiCUGKgICAeEYNAQsgBCADKQIQNwIEIARBHGogA0EoaikCADcCACAEQRRqIANBIGopAgA3AgAgBEEMaiADQRhqKQIANwIAIAQgCTYCAAwBCyAEIAc2AgggBCAFNgIEIARBioCAgHg2AgALIANBMGokACACKALcASEDIAIoAtgBIQQgAigC1AEiBUGKgICAeEcEQCACQcwBaiACQfABaikCADcCACACQcQBaiACQegBaikCADcCACACIAIpAuABNwK8ASACIAM2ArgBIAIgBDYCtAEgAiAFNgKwAQwBCyADIARrIgVBACADIAVPGyIDQQJ2IANBA3FBAEdqIgMEQCAEQX9zIQlBACADayEUIAJBgAFqIQ4gAkH0AGohDyACQcQBaiEQIAJB6AFqIQogAkHcAGohBSACQdgBaiERIAJBzABqIRIgAkHQAGohByACQdwBaiENA0AgAkHUAWogBiAEEJMOIAIoAtgBIQMCQCACKALUASIIQYqAgIB4RwRAIAcgDSkCADcCACAHQRhqIA1BGGooAgA2AgAgB0EQaiANQRBqKQIANwIAIAdBCGogDUEIaikCADcCACACIAM2AkwgAiAINgJIDAELIAJB1AFqIAYgAyAJIAMgCUkbIARqELQGIAJBmAFqIgMgEUEIaikCADcDACACIBEpAgA3A5ABIAIoAtQBIghBioCAgHhHBEAgBSAKKQIANwIAIAVBCGogCkEIaikCADcCACASQQhqIAMpAwA3AgAgEiACKQOQATcCACACIAg2AkgMAQsgAkGoAWogAykDADcDACACIAIpA5ABNwOgASACQdQBaiACQaABakEEEN0QIAIoAtwBIQMgAigC2AEhCAJAAn4gAigC1AEiC0GKgICAeEcEQCACQYACaiAKQQhqKQIANwMAIAIgCikCADcD+AEgAikC4AEMAQsgCEEBcUUNAQJAIANBB3EEQCACIAM2AvABIAJBAzYC7AEgAkGw5P4ANgLoASACQYCAgIB4NgLkASACQgQ3AtwBIAJChICAgAg3AtQBDAELQX8gA0EIaiIIIAMgCEsbIgsgAigCoAEiCCgCBE0EQCAIIAgoAhRBCGoiCzYCFCAIKAIIKAIIIAtPBEAgAkGKgICAeDYC1AEMAgsgAkGIgICAeDYC1AEMAQsgAkHUAWogAyALEL8vCyACQQU2AogCIAJBw+3+ADYChAIgAkGAgICAeDYCgAIgAiADNgL8ASACQQE2AvgBIAJBsAFqIAJB1AFqIAJB+AFqEIEUIAIoArABIgtBioCAgHhGDQEgAkGAAmogEEEIaikCADcDACACIBApAgA3A/gBIAIoArgBIQMgAigCtAEhCCACKQK8AQshFSAFIAIpA/gBNwIAIAVBCGogAkGAAmopAwA3AgAgAiAVNwJUIAIgAzYCUCACIAg2AkwgAiALNgJIDAELIAIgAikDqAE3AtwBIAIgAikDoAE3AtQBIAJB7ABqIAJB1AFqQe3n/gBBBEEGEK0IIAIoAnAhAyACKAJsIghBioCAgHhHBEAgByAPKQIANwIAIAUgDikCADcCACAHQQhqIA9BCGooAgA2AgAgBUEIaiAOQQhqKQIANwIAIAIgAzYCTCACIAg2AkgMAQsgAyADKAIMQQFrNgIMIAJBioCAgHg2AkgLIAIgBDYC3AEgAiATNgLYASACQQA2AtQBIAJBJGogAkHIAGogAkHUAWoQgRQgAigCJCIDQYqAgIB4RwRAIAJBzAFqIAJBQGspAgA3AgAgAkHEAWogAkE4aikCADcCACACQbwBaiACQTBqKQIANwIAIAIgAikCKDcCtAEgAiADNgKwAQwDCyAEQQRqIQQgCUEEayEJIBQgE0EBaiITag0ACwsgAkGKgICAeDYCsAELIAJBBTYC5AEgAkGf7P4ANgLgASACQYCAgIB4NgLcASACIAw2AtgBIAJBATYC1AEgAEEEaiEGIAIgAkGwAWogAkHUAWoQgRQCQCACKAIAIgRBioCAgHhHBEAgBiACKQIENwIAIAZBGGogAkEcaikCADcCACAGQRBqIAJBFGopAgA3AgAgBkEIaiACQQxqKQIANwIADAELIAYgASkCADcCACAGQQhqIAFBCGopAgA3AgALIAAgBDYCAAwBCyAAQQU2AhggAEGf7P4ANgIUIABBgICAgHg2AhAgAEIENwIIIABCgICAgAg3AgALIAJBkAJqJAALpg4CB38DfiMAQcABayIHJAAgByABOgADAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcQ4IAwAFBQUBAgAFCyAHQagBaiACQQhqKQIANwMAIAcgAikCADcDoAEgB0EwaiAHQaABaiADIAQgBRCZDSAHQRBqIAdB6ABqKQMANwMAIAdBGGogB0HwAGooAgA2AgAgByAHKQNgNwMIIAdB0wBqLQAAIQIgBykDMCEOIAcoAjghCiAHKAI8IQsgBygCQCEEIAcoAkQhAyAHKAJIIQUgBygCTCEBIActAFAhBiAHKAJUIQkgBykDWCEPIAcvAFEgB0EGaiAHQfcAai0AADoAACAHIAcvAHU7AQQgAkEQdHIhAiAHLQB0IQwgBykDeCEQDAULIAdBKGoiAyACQQhqKQIANwMAIAcgAikCADcDICAHQQA2ApgBIAdCgICAgBA3ApABIAdBoAFqIgIgB0GQAWoiARDnFSAHQcgAakIANwMAIAdB0ABqQgA3AwAgB0HsAGpCADcCACAHQfQAakIANwIAIAdB/ABqQgA3AgAgB0FAayAHQagBaikDADcDACAHQQA6AIgBIAdCADcCZCAHQQA2AlggB0IBNwJcIAdBADYCMCAHQQA2AoQBIAcgBykDoAE3AzggASAHQSxqIgogBygCJCADKAIAIAcoAiAoAgARBQAgAiAHQTBqIAEQuAQCQAJAIAcoAqABIgJBCEcEQCAHKAK0ASEJIAcoArABIQggBygCrAEhASAHKAKoASEFIAcoAqQBIQMMAQsgB0GQAWpBACAHKAJoQeiNzQAQsxUgB0GgAWogB0EwaiAHKAKUASILIAcoApgBIgQQ6AkCQCAHKAKgASICQQhHBEAgBygCtAEhCSAHKAKwASEIIAcoAqwBIQEgBygCqAEhBSAHKAKkASEDDAELAkACQAJAIARFBEBBACEBDAELIARBAnQhBUEAIQEgCyECA0AgAigCACIDQQBIDQIgASADaiEBIAJBBGohAiAFQQRrIgUNAAsLIAdBMGoQ3hwgAWogBygCKCIBTQ0EQSohASAHQaABakEqQQBBAUEBEKAYIAcoAqQBIQMgBygCoAFBAUYNDSAHKAKoASIFQfiNzQBBKvwKAAAMAQtBJyEBIAdBoAFqQSdBAEEBQQEQoBggBygCpAEhAyAHKAKgAUEBRg0MIAcoAqgBIgVBoo7NAEEn/AoAAAtBACECCyAHQZABahDpOwsgB0EwahCCLSAKIAcoAiQgBygCKCAHKAIgKAIQEQEADAcLIAcoApABIQogBygCLCEIIAcoAiQhBSAHKAIgIQMgB0EwaiICEN4cIQ0gAhCCLSAKQYCAgIB4Rw0CIAQhAgwGCyAHQZgBaiACQQhqKQIANwMAIAcgAikCADcDkAEgB0EwaiAHQZABahCxBCAHKAIwQQFGBEAgBygCSCIIQQh2IQIgBygCTCEJIAcoAkQhASAHKAJAIQUgBygCPCEDIAcoAjghBAwFCyAHQagBaiIMIAdB5ABqKQIANwMAIAdBsAFqIg0gB0HsAGooAgA2AgAgByAHKQJcNwOgASAHKAJMIghBCHYhAiAHKAJQIQkgBygCSCEBIAcoAkQhBSAHKAJAIQMgBygCPCEEIAcoAjQiCkGAgICAeEYNBCAHKQJUIQ8gBygCOCELIAdBGGogDSgCADYCACAHQRBqIAwpAwA3AwAgByAHKQOgATcDCEIFIQ4gBiEMIAghBgwDCyAFIAMgBEEBcRshASACKAIMIQMgAigCCCEEIAIoAgQhCyACKAIAIQpCAiEOQQAhBQwCCyANrUKAgICAEEIAIAYbhCEPIAhBCHYhAkIEIQ4gCCEGDAELIAdBATYCNCAHQdyMzQA2AjAgB0IBNwI8IAdBrgM2AqQBIAcgB0GgAWo2AjggByAHQQNqNgKgASAAQQxqIAdBMGoQmQ4gAEIGNwMAIABBADYCCCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAMLIAAgAjsAISAAIA83AyggACAJNgIkIAAgBjoAICAAIAE2AhwgACAFNgIYIAAgAzYCFCAAIAQ2AhAgACALNgIMIAAgCjYCCCAAIA43AwAgACAHKQMINwMwIAAgDDoARCAAQSNqIAJBEHY6AAAgAEE4aiAHQRBqKQMANwMAIABBQGsgB0EYaigCADYCACAAIBA3A0ggAEHHAGogB0EGai0AADoAACAAIAcvAQQ7AEUMAgsgACACOwAZIAAgCTYCHCAAIAg6ABggACABNgIUIAAgBTYCECAAIAM2AgwgACAENgIIIABCBjcDACAAQRtqIAJBEHY6AAAMAQsgACAJNgIcIAAgCDYCGCAAIAE2AhQgACAFNgIQIAAgAzYCDCAAIAI2AgggAEIGNwMACyAHQcABaiQADwsgAyAHKAKoAUHU/cwAEP0vAAvQDQEOfyMAQSBrIgckACAAKAIcIgIoAiAiBCACKAJcQQVrIgIgAiAESxshDSAAKAIEIQUgAUH/AXEiC0EERyEOAkADQCAAKAIEIQYgACgCECIEIAAoAhwiAi0AcEEqakH4AXFBA3YiCUkNAQJAQf//AyACKAIQIAIoAjxrIgpBACAKQQBKGyIMIAZqIgMgBCAJayIEIAMgBEkbIgkgCUH//wNPGyIEIA1PDQAgCUUEQCAOIAMgBEdyDQMMAQsgC0UgAyAER3INAgsgAkEAQQAgC0EERiADIARGcSIPEPgMAkACQAJAAkACQAJAAkACQCACKAJkIgNBA0sEQCACIANBBGsiBjYCZAJ/IAYEQCACKAJgDAELIAJBADYCYEEACyEDIAIoAlwiCSADIAZqIgNrQQFNDQEgAyAJSw0CIAIoAlggA2ogBDsAACACIAIoAmRBAmoiAzYCZCACKAJcIgYgAigCYCADaiIDa0EBTQ0DIAMgBksNBCACKAJYIANqIARBf3M7AAAgAiACKAJkQQJqNgJkIAAQ4hggCkEASgRAIAAoAhwiAygCPCIGIAMoAhgiAksNBiAAKAIMIQogBCAMIAQgDEkbIgIEQCAKIAMoAhQgBmogAvwKAAALIAAgAiAKajYCDCAAIAAoAhAgAms2AhAgACAAKAIUIAJqNgIUIAMgAygCPCACajYCPCAEIAJrIQQLIARFDQggACgCBCICRQ0IIAAoAgwhAyAAIAIgBCACIAIgBEsbIgJrNgIEIAAoAhwiBC0AAiEKIAAoAgAhBiACBEAgAyAGIAL8CgAACwJAIApBAWsOAgcACAsgBCAEKAKgASADIAIQ3Qc2AqABDAcLIAdBADYCGCAHQQE2AgwgB0Gk7/wANgIIIAdCBDcCECAHQQhqQYju/AAQ7ywACyAHQQA2AhggB0EBNgIMIAdB0O/8ADYCCCAHQgQ3AhAgB0EIakGY7vwAEO8sAAsgAyAJQZju/AAQrzsACyAHQQA2AhggB0EBNgIMIAdB0O/8ADYCCCAHQgQ3AhAgB0EIakGo7vwAEO8sAAsgAyAGQaju/AAQrzsACyAGIAJBuO78ABCvOwALIAAgACgCMCADIAIQ6Ac2AjALIAAgAiAGajYCACAAIAIgA2o2AgwgACAAKAIIIAJqNgIIIAAgACgCECACazYCECAAIAAoAhQgAmo2AhQLIA9FDQALIAAoAgQhBkEBIQgLIAUgBkcEQAJAIAUgBmsiBCAAKAIcIgIoAiAiA0kEQCAEIAIoAlAgAigCECIFa08EQCACIAUgA2siBTYCECACKAIUIAIoAhgiCyADIAMgCyADayIDIAUgAyAFSRtqQcju/AAQwh4gAi0AOiIDQQJJBEAgAiADQQFqOgA6CyACIAIoAhAiBSACKAKAASIDIAMgBUsbNgKAAQsgAkEUaiAFIAQgBWogACgCACAEaxDSJiACIAIoAhAgBGoiAzYCECACIAIoAiAgAigCgAEiBWsiCyAEIAQgC0sbIAVqNgKAAQwBCyACQQI6ADogAkEUakEAIAMgACgCACADaxDSJiACIAIoAiAiAzYCgAEgAiADNgIQCyACIAM2AjwLAkAgCARAQQMhBAwBCwJAAkACQCABQf8BcSIERQRAIAAoAhwhAgwBCyAAKAIcIQIgBEEERg0AIAZFDQELIAYgAigCUCACKAIQIgRrIgNNDQEgAigCPCIIIAIoAiAiBUgNASACIAQgBWsiBDYCECACIAggBWs2AjwgAigCFCACKAIYIgggBSAFIAggBWsiBSAEIAQgBUsbakHY7vwAEMIeIAItADoiBEEBTQRAIAIgBEEBajoAOgsgAiACKAIQIgQgAigCgAEiBSAEIAVJGzYCgAEgAigCICADaiEDDAELIAIoAhAiBCACKAI8RgRAQQEhBAwCCyACKAJQIARrIQMLAkAgBiADIAMgBksbIgZFBEAgAigCICEDDAELIAAgBCAGEMwTGiAAKAIcIgIgAigCECAGaiIENgIQIAIgAigCICIDIAIoAoABIgVrIgggBiAGIAhLGyAFajYCgAELAkAgBCACKAI8IghrIgYgA0H//wMgAigCXCACLQBwQSpqQfgBcUEDdmsiBCAEQf//A08bIgUgAyAFSRtOBEAgACgCBEUhAwwBC0EAIQQgAUH/AXEiA0EERyAGQQBMcSADRXINAUEBIQMgACgCBA0BCyACIAggBSAGIAUgBkkbIgIgCGogAUH/AXFBBEYgA3EgBSAGT3EiARD4DCAAKAIcIgQgBCgCPCACajYCPCAAEOIYQQJBACABGyEECyAHQSBqJAAgBAu5FgIRfwN+IwBB0AFrIgIkAAJAIAEoAlAiCEUEQCACIAEoAiAgASgCJCgCEBEEABCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAQsgASgCLCEEIAJBKGogAUFAayIOEPwTAkACQCABKAI0IgMEQCACQQA2AkQgAkKAgICAwAA3AjwgBCAIayIFIANuIgggBEEBayIKIANuIgdLDQIgAUEQaiENA0AgASgCNCIDRQ0CIAIgAyAIbCIEIANuNgJIAkAgAyAEakEBayIDIAogAyAKSRsiCSAEIAUgBCAFSxsiBkkNACACQcwAaiIDIAJBKGogBiAFayAJIAZrQQFqIg8QpRogAxDnOkUEQCACKAJMIgQgBCgCACIEQQFrNgIAIARBAUcNASADEPseDAELIAJB8ABqIAJB3ABqKAIANgIAIAJB6ABqIAJB1ABqKQIANwMAIAIgAikCTDcDYCACQQA2AnQCQAJAIAEoAgxFDQAgDSACQcgAahDrDCETIAEoAgAiCUEMayEQIAEoAgQiCyATp3EhAyATQhmIQv8Ag0KBgoSIkKDAgAF+IRVBACEMIAIoAkghEQNAIAMgCWopAAAiFCAVhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCARIBAgE3qnQQN2IANqIAtxQXRsIhJqKAIARg0EIBNCAX0gE4MiE1BFDQALCyAUIBRCAYaDQoCBgoSIkKDAgH+DUEUNASADIAxBCGoiDGogC3EhAwwACwALQdTWzQBBwwBBmNfNABDLJAALIAJBIGogCSASaiIDQQhrKAIAIANBBGsoAgAiAygCCEEBa0F4cWpBCGogBiAEayAPIAMoAiARBQAgAiACKQMgNwKMASACQZQBaiACQYwBaiIGQbTIzQAgAkHgAGoQwhAgAigCnAEhBCACKAKYASEDIAIoApQBIglBk4CAgHhHBEAgAiACKQKgATcCtAEgAiAENgKwASACIAM2AqwBIAIgCTYCqAEgACACQagBahCmJSACKAKMASIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgAkHgAGoQzSYgAkE8aiIAEMMnIAAQ6jsgAigCKCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAkEoahD7HgwGCyACKAJEIgYgAigCPEYEQCACQTxqQajXzQAQmygLIAIoAkAgBkEDdGoiCSAENgIEIAkgAzYCACACIAZBAWo2AkQgAigCjAEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBjAFqELsjCyACQeAAahDNJgsgByAITQ0DIAggByAIS2oiCCAHTQ0ACwwCC0HE1s0AEOIrAAtBpNbNABDiKwALAkACQAJAAkBBAEHAABDRNARAIA4Qzy8gAUEANgJQIAFCwAA3A0ggAULAADcDQCABKAI0IgRFDQEgAiABKAIsIARuNgJMIAEoAgwiAwRAIAEoAgAiCEEIaiEFIAgpAwBCf4VCgIGChIiQoMCAf4MhEyACQcwAaigCACEJA0AgE1AEQANAIAhB4ABrIQggBSkDACAFQQhqIQVCgIGChIiQoMCAf4MiE0KAgYKEiJCgwIB/UQ0ACyATQoCBgoSIkKDAgH+FIRMLIAkgCCATeqdBA3ZBdGxqIgRBDGsoAgBLBEAjAEEQayIHJAAgByAENgIMQYABIQYgASgCACIKIAogB0EMaigCAGtBDG0iC2oiDCkAACIUIBRCAYaDQoCBgoSIkKDAgH+DeqdBA3YgCiABKAIEIAtBCGtxaiIKKQAAIhQgFEIBhoNCgIGChIiQoMCAf4N5p0EDdmpBB00EQCABIAEoAghBAWo2AghB/wEhBgsgDCAGOgAAIApBCGogBjoAACABIAEoAgxBAWs2AgwgBEEIayIEKAIAIgYgBigCACIGQQFrNgIAIAZBAUYEQCAEELsjCyAHQRBqJAALIBNCAX0gE4MhEyADQQFrIgMNAAsLAkAgAS0AVEUNACABKAI0IgRFDQMgASgCLCAEbiIEQQJJDQAgAkEYaiABKAI8QQhqEKghIARBAWshDCACKAIcIgZBCGohBCABKAIoIQ5BACEIA0AgAiAONgKUASACIAg2ApgBIwBBEGsiAyQAIARBEGogAkGUAWoiBRDnCyETIwBBEGsiCiQAIAQoAgAiCUEQayENIAQoAgQiCyATp3EhByATQhmIQv8Ag0KBgoSIkKDAgAF+IRUgBSgCBCEPIAUoAgAhEEEAIQUCQAJAA0ACQCAHIAlqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgDSATeqdBA3YgB2ogC3EiEUEEdGsiEigCACAQRgRAIA8gEigCBEYNAwsgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0CIAcgBUEIaiIFaiALcSEHDAELCyAKIAlBACARa0EEdGoiCTYCDEGAASEFIAQoAgAiByAHIApBDGooAgBrQQR1IgtqIg0pAAAiEyATQgGGg0KAgYKEiJCgwIB/g3qnQQN2IAcgBCgCBCALQQhrcWoiBykAACITIBNCAYaDQoCBgoSIkKDAgH+DeadBA3ZqQQdNBEAgBCAEKAIIQQFqNgIIQf8BIQULIA0gBToAACAHQQhqIAU6AAAgBCAEKAIMQQFrNgIMIAMgCUEQayIFKQIANwIAIANBCGogBUEIaikCADcCAAwBCyADQQA2AggLIApBEGokACACQRBqIAMpAgg3AwAgA0EQaiQAAkAgAigCECIDRQ0AIAIoAhQhBSACIAM2AmAgAiAFNgJkIAJB4ABqIgUQvCshByAGIAYoAjAgB2s2AjAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAUQuyMLIAhBAWoiCCAMSQ0ACyAGQQA6AAALAkACQAJAIAIoAkQiAw4CAQACCyAAQQg2AgAgAiACKAI8NgJoIAIgAigCQCIBNgJgIAIgAUEIaiIENgJsIAIgBDYCZCAAIAEpAgA3AgQgAkHgAGoQshwMBgsgAkEIaiABKAIgIAEoAiQoAhARBAAQlCkgAigCCCEBIAAgAigCDDYCCCAAIAE2AgQgAEEINgIADAQLIAJBlAFqIQggAigCQCEEIwBBIGsiASQAIAFBFGogBCADQQN0aiIFIARrQQN2QQBBBEEIEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQZCyzQAQ/S8ACyABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiByAFIARrQQN2EOotIAMgBykCBEIgiTcCCCADIAdBCGo2AgQgBCAFIANBBGoQ3xsgA0EQaiQAIAhBCGogBigCADYCACAIIAEpAgg3AgAgAUEgaiQAIAJB4ABqIAIoApgBIAIoApwBEJ0BIAIoAmghASACKAJkIQQgAigCYCIDQZOAgIB4RwRAIAIgAikCbDcCyAEgAiABNgLEASACIAQ2AsABIAIgAzYCvAEgACACQbwBahCmJSAIEOo7IAJBPGoiABDDJyAAEOo7IAIoAigiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAJBKGoQ+x4MBgsgACABNgIIIAAgBDYCBCAAQQg2AgAgAkGUAWoQ6jsMAwtBtKzNAEEpIAJB4ABqQZizzQBB4KzNABDVHgALQaTWzQAQ4isAC0Gk1s0AEOIrAAsgAkE8aiIAEMMnIAAQ6jsLIAIoAigiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBKGoQ+x4LIAJB0AFqJAALvQwCE34IfyMAQeAAayIXJAACQAJ/AkACQAJAAkACQAJAAkAgASkDACIDUEUEQCABKQMIIgVQDQEgASkDECIEUA0CIAMgBHwiBCADVA0DIAMgBVQNBCAEQoCAgICAgICAIFoNBSAXIAEvARgiATsBOCAXIAMgBX0iBjcDMCAXIAYgBHkiBYYiCiAFiCIHNwNAIAYgB1INCSAXIAE7ATggFyADNwMwIBcgAyAFQj+DIgaGIgcgBogiBjcDQCADIAZSDQlBoH8gASAFp2siGGvBQdAAbEGwpwVqQc4QbSIBQdEATw0GIBdBIGogAUEEdCIBQdDciQFqKQMAIgNCACAEIAWGQgAQqB4gF0EQaiADQgAgCkIAEKgeIBcgA0IAIAdCABCoHkIBQQAgGCABQdjciQFqLwEAamtBP3GtIgmGIgdCAX0hCyAXKQMQQj+HIQ8gFykDAEI/iCEQIBcpAwghESABQdrciQFqLwEAIQEgFykDGCESIBcpAygiFCAXKQMgQj+IIhV8Ig1CAXwiCCAJiKciGEGQzgBPBEAgGEHAhD1JDQggGEGAwtcvTwRAQQhBCSAYQYCU69wDSSIWGyEZQYDC1y9BgJTr3AMgFhsMCgtBBkEHIBhBgK3iBEkiFhshGUHAhD1BgK3iBCAWGwwJCyAYQeQATwRAQQJBAyAYQegHSSIWGyEZQeQAQegHIBYbDAkLQQpBASAYQQlLIhkbDAgLQajYiQFBHEHw5okBEJ8pAAtB1NiJAUEdQYDniQEQnykAC0GE2YkBQRxBkOeJARCfKQALQejaiQFBNkGw6IkBEJ8pAAtBoNqJAUE3QaDoiQEQnykAC0Gw54kBQS1B4OeJARCfKQALIAFB0QBB4OaJARDDIQALQQRBBSAYQaCNBkkiFhshGUGQzgBBoI0GIBYbCyEWIAggC4MhBCAQIBF8IQwgGSABa0EBaiEbIA8gEn0gCHxCAXwiDiALgyEFQQAhAQJAAkACQAJAAkACQAJAAkACQANAIBggFm4hGiABQRFGDQIgASACaiIdIBpBMGoiHDoAAAJAIBggFiAabGsiGK0gCYYiEyAEfCIDIA5aBEAgASAZRw0BIAFBAWohAUIBIQMDQCAFIQogAyEGIAFBEU8NBiABIAJqIARCCn4iBCAJiKdBMGoiFjoAACABQQFqIQEgA0IKfiEDIAVCCn4iBSAEIAuDIgRYDQALIAUgBH0iDiAHVCEYIAMgCCAMfX4iCCADfCEJIAQgCCADfSILWg0IIAcgDlgNAwwICyAOIAN9IgUgFq0gCYYiBlQhFiAIIAx9IgdCAXwhCiAFIAZUIAMgB0IBfSIJWnINBSANIAx9IAQgE3wiBX0hCCANIA98IBJ9IAUgBnx9QgJ8IQwgBCAQfCARfCAVfSAUfSATfCEHQgAhBANAIAMgBnwiBSAJVCAEIAh8IAYgB3xackUEQEEAIRYMBwsgHSAcQQFrIhw6AAAgBCAMfCILIAZUIRYgBSAJWg0HIAYgB3whByAEIAZ9IQQgBSEDIAYgC1gNAAsMBgsgAUEBaiEBIBZBCkkgFkEKbiEWRQ0AC0Hw54kBEOIrAAsgASACakEBayEZIAcgDEIKfiANQgp+fSAGfnwhDEIAIAR9IQggCkIKfiAHfSEKA0AgBCAHfCIDIAtUIAggC3wgBCAMfFpyRQRAQQAhGAwGCyAZIBZBAWsiFjoAACAIIAp8Ig0gB1QhGCADIAtaDQYgCCAHfSEIIAMhBCAHIA1YDQALDAULQRFBEUGA6IkBEMMhAAsgAUERQZDoiQEQwyEACyADIQULAkAgBSAKWiAWcg0AIAogBSAGfCIDWCAKIAV9IAMgCn1UcQ0AIABBADYCAAwECyAFIA5CBH1YIAVCAlpxRQRAIABBADYCAAwECyAAIBs7AQggACABQQFqNgIEDAILIAQhAwsCQCADIAlaIBhyDQAgCSADIAd8IgRYIAkgA30gBCAJfVRxDQAgAEEANgIADAILIAMgBSAGQlh+fFggAyAGQhR+WnFFBEAgAEEANgIADAILIAAgGzsBCCAAIAE2AgQLIAAgAjYCAAsgF0HgAGokAA8LIBdBADYCSCAXQUBrIBdBMGogF0HIAGpB/NaJARCuKwAL4gwCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQYgAigCFCELIAIoAhAhCiAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBiAFIAZqIAogCxC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEAgAwRAIANBwAAQrTYiB0UNBQsgAkEANgJAIAIgBzYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAdBACAE/AsACyACKAJAIQggAigCOCEHCyACIAQ2AjwgAiAFIAhqNgJAIAlFDQIgBSAJRg0DIAoEQCACQegAaiAKIAsgBiAFEL8UIAJBiAFqIQUgASgCECEIIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAggDqcgDKdqIgZBA3RqKQMAtbwiAUH///8DcSEDAkAgAUGAgID8B3EiBEGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhBAwBCyAEQYCAgLgESwRAQYD4ASEEDAELIAFBgICAxANPBEAgBEENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohBAwBCyABQYCAgJgDSQRAQQAhBAwBCyADQYCAgARyIgNBHiABQRd2IgFrdiEEIANBHSABayIBdkEBcUUNACAEQQMgAXRBAWsgA3FBAEdqIQQLIAcgBkEBdGogBDsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhCANAIAQpAwC1vCIBQf///wNxIQMCQCABQYCAgPwHcSIGQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEDDAELIAZBgICAuARLBEBBgPgBIQMMAQsgAUGAgIDEA08EQCAGQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEDDAELIAFBgICAmANJBEBBACEDDAELIANBgICABHIiBkEeIAFBF3YiAWt2IQMgBkEdIAFrIgF2QQFxRQ0AIANBAyABdEEBayAGcUEAR2ohAwsgByADOwEAIAdBAmohByAEQQhqIQQgBSAIQQFqIghHDQALCyACQcgAaiACQRxqIgcQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhCCACKAI8IQQgASACQfAAaiIFKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgCDYCaCACQQhqIAMQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogAkH4AGoiBigCADYCACACIAQ2AqgBIAIgCDYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAYgAkHYAGooAgA2AgAgBSACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEM8dIAJBMGoQzy8gBxDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC+IMAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEGIAIoAhQhCyACKAIQIQogBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAYgBSAGaiAKIAsQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQMCQAJAAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAIAMEQCADQcAAEK02IgdFDQULIAJBADYCQCACIAc2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAHQQAgBPwLAAsgAigCQCEIIAIoAjghBwsgAiAENgI8IAIgBSAIajYCQCAJRQ0CIAUgCUYNAyAKBEAgAkHoAGogCiALIAYgBRC/FCACQYgBaiEFIAEoAhAhCCACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAIIA6nIAynaiIGQQJ0aigCALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQQMAQsgBEGAgIC4BEsEQEGA+AEhBAwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQQMAQsgAUGAgICYA0kEQEEAIQQMAQsgA0GAgIAEciIDQR4gAUEXdiIBa3YhBCADQR0gAWsiAXZBAXFFDQAgBEEDIAF0QQFrIANxQQBHaiEECyAHIAZBAXRqIAQ7AQAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQgDQCAEKAIAs7wiAUH///8DcSEDAkAgAUGAgID8B3EiBkGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIAFBgICAxANPBEAgBkENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohAwwBCyABQYCAgJgDSQRAQQAhAwwBCyADQYCAgARyIgZBHiABQRd2IgFrdiEDIAZBHSABayIBdkEBcUUNACADQQMgAXRBAWsgBnFBAEdqIQMLIAcgAzsBACAHQQJqIQcgBEEEaiEEIAUgCEEBaiIIRw0ACwsgAkHIAGogAkEcaiIHEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQggAigCPCEEIAEgAkHwAGoiBSkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAg2AmggAkEIaiADENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBSkCADcCACABQRhqIAJB+ABqIgYoAgA2AgAgAiAENgKoASACIAg2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAGIAJB2ABqKAIANgIAIAUgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDPHSACQTBqEM8vIAcQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvKDgIGfwF+IwBBsAFrIgQkACAEIAM2AhggBCACNgIUIAQgBEEUajYCHAJAAkACQAJAIANBCk8EQCAEQYABakIANwMAIARB+ABqQgA3AwAgBEHwAGpCADcDACAEQgA3A2hBICADIANBIE8bIQcDQCAEQegAaiIIIAZqIAIgBmotAABBMGsiCToAACAJQf8BcUEKSSAGdCAFciEFIAcgBkEBaiIGRw0ACyAEQThqIARBgAFqKQMANwMAIARBMGogBEH4AGopAwA3AwAgBEEoaiAEQfAAaikDADcDACAEIAQpA2g3AyAgBCAFNgJAIARBIGoQjRwiBkUEQCAEQRI2AlwgBEHcxIABNgJYIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQdgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAIEJkOIAAgBCkClAE3AgggAEEQaiAEQZwBaigCADYCACAAIAQoApABNgIEIABBhICAgHg2AgAMBQsgA0EKRgRAIARCADcCXCAEIAY2AlggBEHoAGogBEHYAGoQ7RcCQCAEKAJoDQAgBCgCbCIBRQ0AIAAgBCkCcDcCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyAEQR82AkwgBEHuxIABNgJIIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQcgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAEQegAahCZDiAEQYSAgIB4NgKMASAAQRBqIARBnAFqKAIANgIAIABBCGogBEGUAWopAgA3AgAgACAEKQKMATcCAAwFCyAELQAqIgVBJEYgBUHEAEZyIAVB8AFGckUEQCAEQRs2AqQBIARB0MOAATYCoAEgBEECNgJsIARBzMSAATYCaCAEQgI3AnQgBEHMATYCmAEgBEHMATYCkAEgBCAEQYwBajYCcCAEIARBoAFqNgKUASAEIARBFGo2AowBIABBBGogBEHoAGoQmQ4gAEGEgICAeDYCAAwFCyAEQdgAaiAEQSBqEIMGIAQoAlhFBEAgBEESNgJMIARBjcWAATYCSCAEQQI2AmwgBEHMxIABNgJoIARCAjcCdCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJwIAQgBEHIAGo2AqgBIAQgBEEUajYCoAEgBEGQAWogBEHoAGoQmQ4gBCkCkAEhCiAAIAQpApgBNwIMIAAgCjcCBCAAQYSAgIB4NgIADAULIAQoAmQhBSAEIAQpAlw3AkwgBCAGNgJIIANBIUkNAUEgIQYgBUEgRw0BA0AgAiAGai0AAEEwa0H/AXFBCUsEQCAGIQUMAwsgAyAGQQFqIgZHDQALDAILIARBLTYCpAEgBEH8w4ABNgKgASAEQQI2AmwgBEHMxIABNgJoIARCAjcCdCAEQcwBNgKYASAEQcwBNgKQASAEIARBjAFqNgJwIAQgBEGgAWo2ApQBIAQgBEEUajYCjAEgBEEkaiAEQegAahCZDiAEQYSAgIB4NgIgIABBEGogBEEwaigCADYCACAAQQhqIARBKGopAgA3AgAgACAEKQIgNwIADAMLIAMgBUsNAQsgBEHoAGogBEHIAGoQ7RcCQCAEKAJoDQAgBCgCbCIBRQ0AIAAgBCkCcDcCCCAAIAE2AgQgAEGTgICAeDYCAAwCCyAEQR82AlwgBEHuxIABNgJYIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQdgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAEQegAahCZDiAEQYSAgIB4NgKMASAAQRBqIARBnAFqKAIANgIAIABBCGogBEGUAWopAgA3AgAgACAEKQKMATcCAAwBCwJAAkAgAiAFai0AACICQfoARgRAIAUgA0EBa0YNAQwCCyAFIANBAWtHIAJB2gBHcg0BCyAAQQRqIARByABqEMovIABBk4CAgHg2AgAMAQsgBEEIaiAEKAIUIAQoAhggBRDqJSAEIAQoAgggBCgCDBCvDiAEQegAaiAEKAIAIAQoAgQQihggBCgCbCECIAQoAmgiA0GTgICAeEcEQCAAIAQpAnA3AgggAEEQaiAEQfgAaigCADYCACAAIAI2AgQgACADNgIADAELIAQgAjYCVCAEQegAaiICIARB1ABqIARByABqEIwsIARBjAFqIgMgAhC+LCACIAMgBEEcahDeFSAEQagBaiICIARB9ABqKQIANwMAIAQgBCkCbDcDoAEgBCgCaCIDQZOAgIB4RwRAIAAgBCkDoAE3AgQgACADNgIAIABBDGogAikDADcCAAwBCyAEQeAAaiACKQMANwMAIAQgBCkDoAE3A1ggAEEEaiAEQdgAahDKLyAAQZOAgIB4NgIACyAEQbABaiQAC/INAQl/IwBB0AFrIgUkACAFQcwAahCGICAFQQA2ApABIAVCgICAgBA3AogBIAVBADYCnAEgBUKAgICAEDcClAEgBUEANgKoASAFQoCAgIAQNwKgAQJAAkACQAJAAkACQAJAIAMtAAAiCkUEQEECIQYMAQsgAy0AASEGIAUgBSgCfCILNgK8ASAFIAVBzABqIgk2ArgBIAVBAToAhAEgBUG4AWoiBxC7ESAHIAYQhxEgCSALENgHIQsgBUEANgJgIAVBADoAhAEgByAGEOIbQQIhBgJAIAUoArgBIgdB7f///wdqDgIAAQILIAUtALwBIQYLIAVBuAFqIAIgBUGUAWogBUGgAWogBUGIAWpCACACKAIkIgcgAigCQEEAIAIoAiwbIAYgAxCYASAFKAK4AUEBRgRAIAUoArwBIQIgBSkDwAEhASAAIAUpA8gBNwIQIAAgATcCCCAAIAI2AgQMAgsgBUEANgK0ASAFQoCAgICAATcCrAEgBUGsAWogAhCpGCAFKAKoASICIAMtAAZBAWtB/wFxIgZqIAZBf3NxIAJrIgJBwQBPDQIgBUGgAWpB/Mz+ACACEKE2IAVBzABqIgIgBSgCmAEgBSgCnAEQ1RAhCSACIAUoAowBIAUoApABENUQIQwgBSgCtAEiBgRAIAIgBSgCsAEgBhCyDSEICyAFQQE6AIQBIAUgBSgCfCINNgK8ASAFIAVBzABqIgI2ArgBIAJBBCAHrRDLDiAFQbgBaiICIAwQ8Q4gAiAJEPAOIAoEQCACIAsQ8g4LIAYEQCAFQbgBaiAIEPMOCyAFQfwAaiECIAVBzABqIggiByANENgHIQogBUEBOgCEASAFQQA2AmAgBSgCfCELIAdBBCABEMsOIAVBBCAFKAKAASIGIAZBBE0bNgKAAQJAQQAgBSgCfCIJa0EDcSIGIAcoAgggCWtNDQAgCCgCCCAFKAJ8ayAGTw0AA0AgBUHMAGoiBxD7FiAHKAIIIAUoAnxrIAZJDQALCyACIAYQjTcgBUHMAGooAgggBSgCfGtBA0siCCAIckUEQANAIAVBzABqIgYQ+xYgBigCCCAFKAJ8a0EESQ0ACwsgAkEEEI03IAVBQGsgBUHMAGoQ3DsgBSgCRCEGIAUoAkAhByAFQThqIAUoAnwQjDcgBUEwaiAHIAYgBSgCOCAFKAI8QazH/gAQ1yYgBSgCNCIGQQNNDQUgBSgCMCAGIAprNgAAIAVB2ABqIQYgBSgCfCEKIAUoAmAiByAFKAJYRgRAIAZBxMb+ABCbKAsgBSgCXCAHQQN0aiIJQQY7AQQgCSAKNgIAIAUgB0EBajYCYAJAIARFBEAgBS0AhgFBAUcNAQsgBUEBIAUoAoABIgcgB0EBTRs2AoABIAVBzABqKAIIGiACQQAQjTcgBUHMAGooAgggBSgCfEciCCAIckUEQANAIAVBzABqIgcQ+xYgBygCCCAFKAJ8Rg0ACwsgAkEBEI03IAVBKGogBUHMAGoQ3DsgBSgCLCECIAUoAighByAFQSBqIAUoAnwQjDcgBUEYaiAHIAIgBSgCICAFKAIkQazH/gAQ1yYgBSgCHEUNBiAFKAIYIAQ6AAAgBSgCfCEEIAUoAmAiAiAFKAJYRgRAIAZBxMb+ABCbKAsgBSgCXCACQQN0aiIGQQg7AQQgBiAENgIAIAUgAkEBajYCYAsgBUHMAGoiAiALENgHIQYgBUEANgJgIAVBAToAhAEgBSAFKAJ8Igc2ArwBIAUgAjYCuAEgBUG4AWoiBCADLwECEMQOIARBAhCfEiACQQogBTUCqAEQyw4gBCAGEPAOIAIgBxDYByEDIAVBADYCYCAFQQA6AIQBIAIgAxCkDCAFQRBqIAIQ3DsgBSgCFCECIAUoAhAhAyAFQQhqIAUoAnwQjDcgBSADIAIgBSgCCCAFKAIMQeTG/gAQ1yYgBSgCACEGIAQgBSgCBCICQQBBAUEBEKAYIAUoArwBIQMgBSgCuAFBAUYNAyAFKALAASEEIAIEQCAEIAYgAvwKAAALIAAgAjYCCCAAIAQ2AgQgACADNgIAIABBFGogBUGoAWooAgA2AgAgACAFKQKgATcCDCAFQawBahDjPAwECyAAIAUpAL0BNwAJIABBEGogBUHEAWopAAA3AAAgACAFLQC8AToACCAAIAc2AgQLIABBgICAgHg2AgAgBUGgAWoQ3jsMAgsgAkHAAEHczf4AELA7AAsgAyAFKALAAUGoyf4AEP0vAAsgBUGUAWpBAUEQEOAeIAVBiAFqQQFBEBDgHiAFQcwAahDMKiAFQdABaiQADwsgBUEANgLIASAFQQE2ArwBIAVB9Mj+ADYCuAEgBUIENwLAASAFQbgBakG8x/4AEO8sAAvfDAIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhBiACKAIUIQsgAigCECEKIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAGIAUgBmogCiALEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQCADBEAgA0HAABCtNiIHRQ0FCyACQQA2AkAgAiAHNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgB0EAIAT8CwALIAIoAkAhCCACKAI4IQcLIAIgBDYCPCACIAUgCGo2AkAgCUUNAiAFIAlGDQMgCgRAIAJB6ABqIAogCyAGIAUQvxQgAkGIAWohBSABKAIQIQggAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgCCAOpyAMp2pBAXQiBmovAQCzvCIBQf///wNxIQMCQCABQYCAgPwHcSIEQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEEDAELIARBgICAuARLBEBBgPgBIQQMAQsgAUGAgIDEA08EQCAEQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEEDAELIAFBgICAmANJBEBBACEEDAELIANBgICABHIiA0EeIAFBF3YiAWt2IQQgA0EdIAFrIgF2QQFxRQ0AIARBAyABdEEBayADcUEAR2ohBAsgBiAHaiAEOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEIA0AgBC8BALO8IgFB////A3EhAwJAIAFBgICA/AdxIgZBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQMMAQsgBkGAgIC4BEsEQEGA+AEhAwwBCyABQYCAgMQDTwRAIAZBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQMMAQsgAUGAgICYA0kEQEEAIQMMAQsgA0GAgIAEciIGQR4gAUEXdiIBa3YhAyAGQR0gAWsiAXZBAXFFDQAgA0EDIAF0QQFrIAZxQQBHaiEDCyAHIAM7AQAgB0ECaiEHIARBAmohBCAFIAhBAWoiCEcNAAsLIAJByABqIAJBHGoiBxCCFCACQegAaiIDEJcpIAJBOGoiASgCACEIIAIoAjwhBCABIAJB8ABqIgUpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAINgJoIAJBCGogAxDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQfgAaiIGKAIANgIAIAIgBDYCqAEgAiAINgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgBiACQdgAaigCADYCACAFIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQzx0gAkEwahDPLyAHEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL2wwCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQYgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBiAFIAZqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEAgAwRAIANBwAAQrTYiB0UNBQsgAkEANgJAIAIgBzYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAdBACAE/AsACyACKAJAIQsgAigCOCEHCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogBiAFEL8UIAJBiAFqIQUgASgCECEGIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIghqLQAAs7wiAUH///8DcSEDAkAgAUGAgID8B3EiBEGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhBAwBCyAEQYCAgLgESwRAQYD4ASEEDAELIAFBgICAxANPBEAgBEENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohBAwBCyABQYCAgJgDSQRAQQAhBAwBCyADQYCAgARyIgNBHiABQRd2IgFrdiEEIANBHSABayIBdkEBcUUNACAEQQMgAXRBAWsgA3FBAEdqIQQLIAcgCEEBdGogBDsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEIQQAhBANAIAQgCGotAACzvCIBQf///wNxIQMCQCABQYCAgPwHcSIGQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEDDAELIAZBgICAuARLBEBBgPgBIQMMAQsgAUGAgIDEA08EQCAGQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEDDAELIAFBgICAmANJBEBBACEDDAELIANBgICABHIiBkEeIAFBF3YiAWt2IQMgBkEdIAFrIgF2QQFxRQ0AIANBAyABdEEBayAGcUEAR2ohAwsgByADOwEAIAdBAmohByAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBxCCFCACQegAaiIDEJcpIAJBOGoiASgCACEGIAIoAjwhBCABIAJB8ABqIgUpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAGNgJoIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgCCACQdgAaigCADYCACAFIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQzx0gAkEwahDPLyAHEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1gwCCn8DfiMAQbABayICJAAgAUEMahDZPCEGAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAGQQN2IAZBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAGIAdqIAggChC/GAwBC0HAACEEIAZBA3YgBkEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAGEN4QCyAGQQN0IgUhBAJAIAVBOHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAENgI0IAJBwAA2AjAgBQRAIAUEQCADQQAgBfwLAAsgAigCQCELIAIoAjghAwsgAiAFNgI8IAIgBiALajYCQCAJRQ0FIAYgCUYNBiAIBEAgAkHoAGogCCAKIAcgBhC/FCACQYgBaiEGIAEoAhAhBSACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAGELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAFIA6nIAynaiIEQQF0ai8BACIBrSEMIAMgBEEDdGoCfiAMQjCGIAFB//8BcUUNABogAUH/B3EhBCAMQv8HgyEOIAxCgIACgyEMIAFBgPgBcSIBQYD4AUYEQCAMQjCGIgxCgICAgICAgPj/AIQgBEUNARogDCAOQiqGhEKAgICAgICA/P8AhAwBCyAMQjCGIgwgAUEKdkHwB2qtQjSGIA5CKoaEhCABDQAaIA4gBGciAUEQa0H//wNxQSVqrYZC/////////weDQYYIIAFrrUI0hoQgDIQLNwMADAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBkUNACABKAIQIQRBACEBA0AgAwJ+IAQvAQAiBa0iDUIwhiAFQf//AXFFDQAaIAVB/wdxIQcgDUL/B4MhDCANQoCAAoMhDSAFQYD4AXEiBUGA+AFGBEAgDUIwhiINQoCAgICAgID4/wCEIAdFDQEaIA0gDEIqhoRCgICAgICAgPz/AIQMAQsgDUIwhiINIAVBCnZB8AdqrUI0hiAMQiqGhIQgBQ0AGiAMIAdnIgVBEGtB//8DcUElaq2GQv////////8Hg0GGCCAFa61CNIaEIA2ECzcDACADQQhqIQMgBEECaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGogAkEcaiIFEIIUIAJB6ABqIgQQlykgAkE4aiIBKAIAIQcgAigCPCEGIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBjYCbCACIAc2AmggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAGNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBBDbHSACQTBqEM8vIAUQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC84NAgZ/CH4jAEHgAWsiAyQAIAFBDGoQ2jwhByADQdgAaiABEJI2EO4lIAdBBHQiBCEFAkACQAJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AnggAyAFNgJ0IANBwAA2AnAgBARAIAZBACAE/AsACyADIAc2AoABIAMgBDYCfCADKAJYRQ0DIAMoAmwgAygCaEYNBCADQZABaiADQdgAahDINCADQbABaiEEIAIoAgghBSACKAIAIQIgASgCECEHAkADQAJAIAMpA7gBIgpQRQRAIAMpA8ABIQkMAQsDQAJ+AkAgAykDoAEiCUIDUgRAAkACQAJAIAlCAlENACADIAlQrUIBhjcDoAEgCadBAXFFDQAgAyADKQOoATcD0AEMAQsgAygCsAFFDQEgA0HIAWogBBC2KiADKQPIASEJCyAJQgBSDQILIANCAzcDoAELIAMpA5ABIglCAlENCiADQgA3A5ABIAMpA5gBDAELIAMpA9ABCyEKIAmnQQFxRQ0IIAMgAykDwAFCQH0iCTcDwAEgAyAKNwO4ASAKUA0ACwsgAyAKQgEgCnoiC4aFNwO4AUKAgICAgICAgIB/IQxCACENAkACfgJAAkAgByALpyAJp2pBBHQiCGoiASkDACIOIAEpAwgiD0KAgICAgICAgIB/hYRCAFIgAigCACIBKQMIIgkgASkDACIKg0J/UnJFBEBCACEJQgAhCwwBCyAJIAqEUA0DIANBQGsgDiAPIAogCRCDGSADQTBqIAMpA0AiCyADKQNIIgwgCiAJEKgeQgAgDiADKQMwIhB9IAkgCoNCf1EiARshDUIAIA8gAykDOH0gDiAQVK19IAEbIQkgD0IAWQ0BCyALIA0gAigCCCIBKQMAWCAJIAEpAwgiClcgCSAKURutIgp9IQkgDCAKIAtWrX0MAQsgDCALIA0gAigCBCIBKQMAWiAJIAEpAwgiClkgCSAKURutfCIJIAtUrXwLIQsgA0HIAWogCSALIAUtAAAQrQ4gAygCyAEiAUGTgICAeEcNAiAGIAhqIgEgCzcDCCABIAk3AwAMAQsLQcyP/wAQ4isACyADKQLMASEJIAAgAykC1AE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQZABakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACECA0BCgICAgICAgICAfyEMAn4CQAJAIAQpAwAiDSAEKQMIIg5CgICAgICAgICAf4WEQgBSIAUoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCkIAIQlCACELDAELIAkgCoRQDQggA0EgaiANIA4gCiAJEIMZIANBEGogAykDICILIAMpAygiDCAKIAkQqB5CACANIAMpAxAiD30gCSAKg0J/USIBGyEKQgAgDiADKQMYfSANIA9UrX0gARshCSAOQgBZDQELIAsgCiAFKAIIIgEpAwBYIAkgASkDCCIKVyAJIApRG60iCn0hCSAMIAogC1atfQwBCyAMIAsgCiAFKAIEIgEpAwBaIAkgASkDCCIKWSAJIApRG618IgkgC1StfAshCyADQZABaiAJIAsgCC0AABCtDiADKAKQASIBQZOAgIB4Rw0CIAYgCTcDACAGIAs3AwggBEEQaiEEIAZBEGohBiAHIAJBAWoiAkcNAAsLIANBkAFqIgIQlykgA0H4AGoiASgCACEFIAMoAnwhBiABIANBmAFqIgQpAgA3AwAgAykDcCEJIAMgAykCkAE3A3AgA0EANgKAASADIAk3ApwBIANBADYCmAEgAyAGNgKUASADIAU2ApABIANBCGogAhDXOyADKAIIIQVBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogBCkCADcCACABQRhqIANBoAFqIgcoAgA2AgAgAyAGNgLQASADIAU2AswBIAMgATYCyAEgA0GEAWoiASADQcgBahDiGSAHIANB6ABqKQIANwMAIAQgA0HgAGopAgA3AwAgAyADKQJYNwOQASAAIAEgAhDLHSADQfAAahDPLwwCCyADKQKUASEJIAAgAykCnAE3AhALIAAgCTcCCCAAQSk6AAAgACABNgIEIANB8ABqEM8vIAMoAlgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0HYAGoQ+x4LIANB4AFqJAAPC0HMj/8AEOIrAAtBBEEcEKM9AAubDQIKfwV+IwBBgAJrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQcgAaiAFENw7IAUoAhQhByAFKAIMIQogBCgCTCEMIAQoAkghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AmAgBCAGNgJcIAQgBTYCWCAEQcAANgJUIARB1ABqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AmAgBCAGNgJcIAQgBzYCWCAEQcAANgJUIARB1ABqIAgQ3hBBACEHCyAIQQR0IgkhBQJAIAlBMHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCeCAEIAY2AnAgBCAFNgJsIARBwAA2AmggCQRAIAkEQCAGQQAgCfwLAAsgBCgCeCENIAQoAnAhBgsgBCAJNgJ0IAQgCCANajYCeCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyACKQMIIQ4gAikDACEPIAMtAAAhAyABKAIQIQUgBEGgAWpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDiAPhFAEQCAEQoGAgIDwgICAgH83A6ABIAkQiBEMAQsgBEEQaiAFMwEAwyIQIBBCP4cgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEGgAWogCyAMIAogCBC/FCAEQeABakEEciEIIARBwAFqIQUgAikDCCEQIAIpAwAhESADLQAAIQMgASgCECEJA0ACQCAEKQPIASIPUEUEQCAEKQPQASEODAELA0ACfgJAIAQpA7ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A7ABIA6nQQFxRQ0AIAQgBCkDuAE3A+gBDAELIAQoAsABRQ0BIARB4AFqIAUQtiogBCkD4AEhDgsgDkIAUg0CCyAEQgM3A7ABCyAEKQOgASIOQgJRDQYgBEIANwOgASAEKQOoAQwBCyAEKQPoAQshDyAOp0EBcUUNBCAEIAQpA9ABQkB9Ig43A9ABIAQgDzcDyAEgD1ANAAsLIAQgD0IBIA96IhKGhTcDyAEgEqcgDqdqIQECQCAQIBGEUARAIARCgYCAgPCAgICAfzcD4AEgCBCIEQwBCyAEQTBqIAkgAUEBdGozAQDDIg4gDkI/hyARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALmQ0CCn8FfiMAQYACayIEJAAgAUEMahDbPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBTQCACIQIBBCP4cgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAFQQRqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEGgAWogCyAMIAogCBC/FCAEQeABakEEciEIIARBwAFqIQUgAikDCCEQIAIpAwAhESADLQAAIQMgASgCECEJA0ACQCAEKQPIASIPUEUEQCAEKQPQASEODAELA0ACfgJAIAQpA7ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A7ABIA6nQQFxRQ0AIAQgBCkDuAE3A+gBDAELIAQoAsABRQ0BIARB4AFqIAUQtiogBCkD4AEhDgsgDkIAUg0CCyAEQgM3A7ABCyAEKQOgASIOQgJRDQYgBEIANwOgASAEKQOoAQwBCyAEKQPoAQshDyAOp0EBcUUNBCAEIAQpA9ABQkB9Ig43A9ABIAQgDzcDyAEgD1ANAAsLIAQgD0IBIA96IhKGhTcDyAEgEqcgDqdqIQECQCAQIBGEUARAIARCgYCAgPCAgICAfzcD4AEgCBCIEQwBCyAEQTBqIAkgAUECdGo0AgAiDiAOQj+HIBEgEBCDGSAEKQMwIg4gBCkDOCIPIAMQ/yBFDQAgBiABQQR0aiIBIA83AwggASAONwMADAELIARBKGogBEHUAGoQhj0gAUEDdiICIAQoAiwiCkkEQCAEKAIoIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARBgAFqIARB1ABqIgYQghQgBEGgAWoiAhCXKSAEQfAAaiIBKAIAIQUgBCgCdCEDIAEgBEGoAWoiCCkCADcDACAEKQNoIQ4gBCAEKQKgATcDaCAEQQA2AnggBCAONwKsASAEQQA2AqgBIAQgAzYCpAEgBCAFNgKgASAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAqABNwIIIAFBEGogCCkCADcCACABQRhqIARBsAFqIgkoAgA2AgAgBCADNgLoASAEIAU2AuQBIAQgATYC4AEgBEGUAWoiASAEQeABahDiGSAJIARBkAFqKAIANgIAIAggBEGIAWopAgA3AwAgBCAEKQKAATcDoAEgBCAHNgK0ASAAIAEgAhDLHSAEQegAahDPLyAGEM8vIARBgAJqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGgAWpB7I//AEGIjP8AENUeAAuZDQIKfwV+IwBBgAJrIgQkACABQQxqENg8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQcgAaiAFENw7IAUoAhQhByAFKAIMIQogBCgCTCEMIAQoAkghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AmAgBCAGNgJcIAQgBTYCWCAEQcAANgJUIARB1ABqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AmAgBCAGNgJcIAQgBzYCWCAEQcAANgJUIARB1ABqIAgQ3hBBACEHCyAIQQR0IgkhBQJAIAlBMHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCeCAEIAY2AnAgBCAFNgJsIARBwAA2AmggCQRAIAkEQCAGQQAgCfwLAAsgBCgCeCENIAQoAnAhBgsgBCAJNgJ0IAQgCCANajYCeCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyACKQMIIQ4gAikDACEPIAMtAAAhAyABKAIQIQUgBEGgAWpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDiAPhFAEQCAEQoGAgIDwgICAgH83A6ABIAkQiBEMAQsgBEEQaiAFKQMAIhAgEEI/hyAPIA4QgxkgBCkDECIQIAQpAxgiESADEP8gRQ0AIAYgEDcDACAGIBE3AwgMAQsgBEEIaiAEQdQAahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEQaiEGIAVBCGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQaABaiALIAwgCiAIEL8UIARB4AFqQQRyIQggBEHAAWohBSACKQMIIRAgAikDACERIAMtAAAhAyABKAIQIQkDQAJAIAQpA8gBIg9QRQRAIAQpA9ABIQ4MAQsDQAJ+AkAgBCkDsAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDsAEgDqdBAXFFDQAgBCAEKQO4ATcD6AEMAQsgBCgCwAFFDQEgBEHgAWogBRC2KiAEKQPgASEOCyAOQgBSDQILIARCAzcDsAELIAQpA6ABIg5CAlENBiAEQgA3A6ABIAQpA6gBDAELIAQpA+gBCyEPIA6nQQFxRQ0EIAQgBCkD0AFCQH0iDjcD0AEgBCAPNwPIASAPUA0ACwsgBCAPQgEgD3oiEoaFNwPIASASpyAOp2ohAQJAIBAgEYRQBEAgBEKBgICA8ICAgIB/NwPgASAIEIgRDAELIARBMGogCSABQQN0aikDACIOIA5CP4cgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5QNAgp/BX4jAEGAAmsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiBSEJAkAgBUEwcSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAk2AmwgBEHAADYCaCAFBEAgBQRAIAZBACAF/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAU2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAEgBWoxAADCIhAgEEI/hyAPIA4QgxkgBCkDECIQIAQpAxgiESADEP8gRQ0AIAYgEDcDACAGIBE3AwgMAQsgBEEIaiAEQdQAahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEQaiEGIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiABIAlqMQAAwiIOIA5CP4cgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5kNAgp/BX4jAEGAAmsiBCQAIAFBDGoQ2TwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiCSEFAkAgCUEwcSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAU2AmwgBEHAADYCaCAJBEAgCQRAIAZBACAJ/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAk2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAUzAQBC//8Dg0IAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBAXRqMwEAQv//A4NCACARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALjw0CCn8FfiMAQYACayIEJAAgAUEMahDbPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBTUCAEIAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUEEaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBAnRqNQIAQgAgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5ANAgp/BX4jAEGAAmsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiBSEJAkAgBUEwcSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAk2AmwgBEHAADYCaCAFBEAgBQRAIAZBACAF/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAU2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAEgBWoxAABC/wGDQgAgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAJEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQaABaiALIAwgCiAIEL8UIARB4AFqQQRyIQggBEHAAWohBSACKQMIIRAgAikDACERIAMtAAAhAyABKAIQIQkDQAJAIAQpA8gBIg9QRQRAIAQpA9ABIQ4MAQsDQAJ+AkAgBCkDsAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDsAEgDqdBAXFFDQAgBCAEKQO4ATcD6AEMAQsgBCgCwAFFDQEgBEHgAWogBRC2KiAEKQPgASEOCyAOQgBSDQILIARCAzcDsAELIAQpA6ABIg5CAlENBiAEQgA3A6ABIAQpA6gBDAELIAQpA+gBCyEPIA6nQQFxRQ0EIAQgBCkD0AFCQH0iDjcD0AEgBCAPNwPIASAPUA0ACwsgBCAPQgEgD3oiEoaFNwPIASASpyAOp2ohAQJAIBAgEYRQBEAgBEKBgICA8ICAgIB/NwPgASAIEIgRDAELIARBMGogASAJajEAAEL/AYNCACARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALgg0CCn8EfiMAQeABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBBXQiCSEFAkAgCUEgcSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQUDQCAEQfAAaiACIAEpAwAgASkDCCABQRBqKQMAIAFBGGopAwAQ7QkCQAJAIAQoAnBBAXFFDQAgBCkDgAEiDiAEKQOIASIPIAQpA5ABIhAgBCkDmAEiESAJENwdRQ0AIAYgDjcDACAGQRhqIBE3AwAgBkEQaiAQNwMAIAYgDzcDCAwBCyAEQQhqIARBJGoQhj0gBUEDdiIDIAQoAgwiCk8NAyAEKAIIIANqIgMgAy0AAEF+IAVBB3F3cToAACAHQQFqIQcLIAZBIGohBiABQSBqIQEgCCAFQQFqIgVHDQALDAcLIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBkAFqIQggAy0AACEFIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwO4AQwBCyAEKAKQAUUNASAEQbABaiAIELYqIAQpA7ABIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQwgBEIANwNwIAQpA3gMAQsgBCkDuAELIQ8gDqdBAXFFDQogBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIARBsAFqIAIgCSAQpyAOp2oiA0EFdCIKaiIBKQMAIAEpAwggASkDECABKQMYEO0JAkAgBCgCsAFBAXFFDQAgBCkDwAEiDiAEKQPIASIPIAQpA9ABIhAgBCkD2AEiESAFENwdRQ0AIAYgCmoiASARNwMYIAEgEDcDECABIA83AwggASAONwMADAELIARBEGogBEEkahCGPSADQQN2IgEgBCgCFCIKSQRAIAQoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAdBAWohBwwBCwsgASAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCuAEgBCAFNgK0ASAEIAE2ArABIARB5ABqIgEgBEGwAWoQ4hkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEM4dIARBOGoQzy8gBhDPLyAEQeABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALjw0CCn8FfiMAQYACayIEJAAgAUEMahDYPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBSkDAEIAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUEIaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBA3RqKQMAQgAgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC6AMAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBEGogAxDcOyADKAIUIQkgAygCDCEGIAIoAhQhCiACKAIQIQggBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwIoIAIgBTYCJCACIAM2AiAgAkHAADYCHCACQRxqIAYgBCAGaiAIIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AiggAiAFNgIkIAIgAzYCICACQcAANgIcIAJBHGogBBDeEAsgBEECdCIHIQMCQAJAAkAgB0E8cSIFBEAgByAFa0FAayIDIAdJDQELQcAAIQUgA0HAABDRNARAIAMEQCADQcAAEK02IgVFDQULIAJBADYCQCACIAU2AjggAiADNgI0IAJBwAA2AjAgBwRAIAcEQCAFQQAgB/wLAAsgAigCQCELIAIoAjghBQsgAiAHNgI8IAIgBCALajYCQCAJRQ0CIAQgCUYNAyAIBEAgAkHoAGogCCAKIAYgBBC/FCACQYgBaiEHIAEoAhAhBiACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAHELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQAQJ/IAYgDqcgDKdqIghBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQEgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQiA0GAgID8B3IgAUUNARogAyABQQ10ckGAgID+B3IMAQsgBEEQdCIEIANBDXRBgICA/ABxIAFBDXRyQYCAgMADanIgAw0AGiABIAFnQRBrIgFB//8DcUEIanRB////A3EgBEGAgIDYA3IgAUEXdGtyCyEBIAUgCEECdGogATYCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgASgCECEDQQAhAQNAIAUCfyADLwEAIgZB//8BcUUEQCAGQRB0DAELIAZB/wdxIQcgBkGAgAJxIQggBkGA+AFxIgZBgPgBRgRAIAhBEHQiBkGAgID8B3IgB0UNARogBiAHQQ10ckGAgID+B3IMAQsgCEEQdCIIIAZBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgBg0AGiAHIAdnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyCzYCACAFQQRqIQUgA0ECaiEDIAQgAUEBaiIBRw0ACwsgAkHIAGogAkEcaiIHEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQYgAigCPCEEIAEgAkHwAGoiBSkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAY2AmggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBSkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAY2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAUgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAcQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuNDQIIfwJ+IwBBQGoiAyQAAkACQAJAIAAQ9w4EQCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEAQQIhBCABKAIAIgBFDQEgAUEMaiABKAIEIAEoAgggACgCEBEBAAwBCyAAIAEQoQkiBiAALwE4cSEEAkACQAJAAkADQCAAKAIcIQgDQCAEIQdBACEEIAcgCE8NAAsgACgCGCAHQQJ0aiIILwEAIgRB//8DRg0BIAUgByAALwE4IgkgCC8BAiIIcWsgCXFNBEACQCAIIAZB//8DcUcNACAAKAIoIgggBE0NBCABKAIARSAAKAIkIARBNGxqIgkoAiAiCkEAR0YNACAJQSBqIQkgCgRAIAkgARCMNUUNASAAKAIoIQgMBwsgCS0ABCABLQAERg0GCyAHQQFqIQQgBUEBaiEFDAELCyAAKQMAIQsgA0EIaiABQQhqKQIANwMAIAMgASkCADcDACADQSBqIAJBEGoiBCgCADYCACADQRhqIAJBCGoiCCkCADcDACADIAIpAgA3AxACQCAAKAIoIgFB//8BTQRAIANBPGoiCSAEKAIANgIAIANBNGogCCkCADcCACADIAIpAgA3AiwgAEEgaiICKAIAIAFGBEAgAkHMqMMAEJMoCyAFQf8DSyALQgJScSEIIAAoAiQgAUE0bGoiAiADKQIkNwIEQQAhBSACQQA2AgAgAkEUaiADQTRqKQIANwIAIAJBDGogA0EsaikCADcCACACQRxqIAkoAgA2AgAgA0EIaikDACELIAMpAwAhDCACIAY7ATAgAiAMNwIgIAJBKGogCzcCACAAIAFBAWo2AiggACgCHCEJIAAoAhghCgNAIAchBEEAIQcgBCAJTw0AIAogBEECdGoiBy8BACICQf//A0YNAiAHIAE7AQAgBy8BAiAHIAY7AQIgBEEBaiEHIAVBAWohBSEGIAIhAQwACwALIANBHGogAygCFCADKAIYIAMoAhAoAhARAQAgAygCACIARQ0DIANBDGogAygCBCADKAIIIAAoAhARAQAMAwsgByAGOwECIAcgATsBAAJAIAhBf3MgBUGAAUlxDQAgACkDAEIAUg0AIABCATcDAAtBACEEDAQLIAAoAighBSADQQhqIAFBCGopAgA3AwAgAyABKQIANwMAIANBIGogAkEQaiIBKAIANgIAIANBGGogAkEIaiIEKQIANwMAIAMgAikCADcDEAJAIAVB//8BTQRAIANBPGoiCCABKAIANgIAIANBNGogBCkCADcCACADIAIpAgA3AiwgAEEgaiIBKAIAIAVGBEAgAUHMqMMAEJMoCyAAKAIkIAVBNGxqIgEgAykCJDcCBEEAIQQgAUEANgIAIAFBDGogA0EsaikCADcCACABQRRqIANBNGopAgA3AgAgAUEcaiAIKAIANgIAIANBCGopAwAhCyADKQMAIQwgASAGOwEwIAEgDDcCICABQShqIAs3AgAgACAFQQFqNgIoIAcgACgCHCIBTw0BIAAoAhggB0ECdGoiACAGOwECIAAgBTsBAAwFCyADQRxqIAMoAhQgAygCGCADKAIQKAIQEQEAIAMoAgAiAEUNAiADQQxqIAMoAgQgAygCCCAAKAIQEQEADAILIAcgAUG8qMMAEMMhAAsgBCAIQZyowwAQwyEAC0ECIQQMAQsgBCAITw0BIABBLGohBgJAIAAoAiQgBEE0bGoiBygCAEEBRgRAIAcoAgghCCAAKAI0IgUgACgCLEYEQCAGQfynwwAQlCgLIAAoAjAgBUEkbGoiBiAENgIMIAZBADYCCCAGIAg2AgQgBkEBNgIAIAYgAikCADcCECAGQRhqIAJBCGopAgA3AgAgBkEgaiACQRBqKAIANgIAIAAgBUEBaiICNgI0IAUgCEkNBCAHIAU2AgggB0EBNgIAIAAoAjAgCEEkbGoiACAFNgIMIABBATYCCAwBCyAAKAI0IgUgACgCLEYEQCAGQeynwwAQlCgLIAAoAjAgBUEkbGoiBiAENgIMIAZBADYCCCAGIAQ2AgQgBkEANgIAIAZBIGogAkEQaigCADYCACAGQRhqIAJBCGopAgA3AgAgBiACKQIANwIQIAcgBTYCBCAHQQE2AgAgACAFQQFqNgI0IAcgBTYCCAtBASEEIAEoAgAiAEUNACABQQxqIAEoAgQgASgCCCAAKAIQEQEACyADQUBrJAAgBA8LIAQgCEGsqMMAEMMhAAsgCCACQYyowwAQwyEAC6ISAg9/AX4jAEHwAWsiAyQAIAEoAgAiCEEwaiERAkACfyAILQAwIglBKEcEQCARIQEgCUEiRw0CIAgoAjgMAQsgCCgCOEEwagsiAS0AACEJCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAlB/wFxQRtrDg0ABgECBgMEBgYGBgYFBgsgA0GYAWogAUEEaiACEJMDIAMoApwBIQIgAygCmAEiAUGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgATYCAAwICyACDQYgAEKTgICACDcCAAwHCyADQZgBaiABQQhqIAIQkwMgAygCnAEhBiADKAKYASICQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAY2AgQgACACNgIADAcLIAYEQCABKAIEIQIMBgsgAEKTgICACDcCAAwGCyADQZgBaiABQQRqIAIQkwMgAygCnAEhAiADKAKYASIBQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAI2AgQgACABNgIADAYLIAINBCAAQpOAgIAINwIADAULIANBEGogAUEEahDDNCADKAIUIQEgAygCECEEIAMgAjYCoAEgAyAENgKYASADIAQgAUECdGo2ApwBIANBKGogA0GYAWoQixcgA0EsaiEEIAMoAigiAUGTgICAeEcEQCAAIAMoAjg2AhAgACABNgIAIAAgBCkCADcCBCAAQQxqIARBCGooAgA2AgAMBQsgA0GgAWogBEEIaigCACICNgIAIAMgBCkCADcDmAEgA0EIaiADKAKcASIBIAEgAkECdGoQmxggAyADKAIMIgY2AlQgAyADKAIIIgI2AlAgBBD4JSADQZgBakEEQQQQ4B4gAyADQdAAaiIBEMM0IAMoAgQNAyAAQpOAgIAINwIAIAIgAigCACIAQQFrNgIAIABBAUcNBCABEIUdDAQLIANBIGogAUEEahCwLiADKQMgIRIgAyACNgKgASADIBI3ApgBIANBPGohDyMAQTBrIgckACAHQZOAgIB4NgIAIAdBKGogA0GYAWoiAkEIaigCADYCACAHIAIpAgA3AyAgByAHNgIsIAdBFGohECMAQTBrIgUkACAFQRRqIAdBIGoiDBD+FwJAAkACQCAFKAIUQQFGBEAgBSgCHCEEIAUtABghAiAFQSBqIg1BBEEAQQRBCBCgGCAFKAIkIQogBSgCIEEBRg0CIAUoAigiBiAENgIEIAYgAjoAACAFQRBqIgtBATYCACAFIAY2AgwgBSAKNgIIIAVBKGogDEEIaikCADcDACAFIAwpAgA3AyAjAEEQayIOJAAgDkEEaiANEP4XIA4oAgRBAUYEQCAFQQhqIQwDQCAOKAIMIQYgDi0ACCEEIAwoAggiCiAMKAIARgRAIAwgCkEBQQRBCBDQKAsgDCgCBCAKQQN0aiICIAY2AgQgAiAEOgAAIAwgCkEBajYCCCAOQQRqIA0Q/hcgDigCBA0ACwsgDkEQaiQAIBBBCGogCygCADYCACAQIAUpAgg3AgAMAQsgEEEANgIIIBBCgICAgMAANwIACyAFQTBqJAAMAQsgCiAFKAIoQbiBwwAQ/S8ACwJAIAcoAgBBk4CAgHhHBEAgDyAHKQIANwIAIA9BEGogB0EQaigCADYCACAPQQhqIAdBCGopAgA3AgAgEBCfJSAQQQRBCBDgHgwBCyAPIAcpAhQ3AgQgD0GTgICAeDYCACAPQQxqIAdBHGooAgA2AgALIAdBMGokACADQUBrIQsgAygCPCICQZOAgIB4RwRAIAAgAygCTDYCECAAIAI2AgAgACALKQIANwIEIABBDGogC0EIaigCADYCAAwECyADQaABaiALQQhqKAIAIgQ2AgAgAyALKQIANwOYASADQRhqIAMoApwBIgIgAiAEQQN0ahCcGCADIAMoAhwiBjYCVCADIAMoAhgiAjYCUCALEJ8lIANBmAFqQQRBCBDgHiADQdAAahCOPkUEQCABLQABIQ0MAwsgAEKTgICACDcCACACIAIoAgAiAEEBazYCACAAQQFHDQMgA0HQAGoQhh0MAwsgA0GYAWogAUEEaiACEJMDIAMoApwBIQIgAygCmAEiBkGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgBjYCAAwDCyACBEAgAS0AASENDAILIABCk4CAgAg3AgAMAgsgAigCACgCACgCACACKAIEIgIoAgAQ8iYgAiACKAIAQQFqNgIAQQAhCQRAIAggCCgCACIBQQFqNgIAIAghCSABQQBIDQQLIABBk4CAgHg2AgAgACAJNgIEDAELAkACQCARLQAAIgFBIkcEQCABQShGDQEgAiEEIAYhAQwCCxDNLyEEIANBmAFqIAgoAjQQwAYgBEEIaiADQaABaigCADYCACAEIAMpApgBNwIAQQxBBBCtNiIBRQ0DIAEgBjYCCCABIAI2AgQgASANOgABIAEgCToAAEEiIQkMAQsgCCgCNCIEIAQoAgAiAUEBajYCACABQQBIDQMgA0HMAWogCCgCOCIKQTxqEN0gIANBwAFqIApBMGoQwAYgCi8BSCELIAopAyghEiADQZgBaiIBIApBCGoQsS4gAyASNwO4ASADIAs7AdgBIAMgBjYC7AEgAyACNgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiAiABIANB5AFqEKQrQdAAQQgQrTYiAUUNBCABQoGAgIAQNwMAIAFBCGogAkHIAPwKAABBKCEJCyADQcwBaiAIQTxqEN0gIANBwAFqIBEQwAYgCC8BSCERIAgpAyghEiADQZgBaiICIAhBCGoQsS4gAyASNwO4ASADIBE7AdgBIAMgATYC7AEgAyAENgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiASACIANB5AFqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogAUHIAPwKAAAgAEGTgICAeDYCACAAIAI2AgQLIANB8AFqJAAPC0EEQQwQoz0LAAtBCEHQABCjPQALQQhB0AAQoz0AC6ISAg9/AX4jAEHwAWsiAyQAIAEoAgAiCEEwaiERAkACfyAILQAwIglBKEcEQCARIQEgCUEiRw0CIAgoAjgMAQsgCCgCOEEwagsiAS0AACEJCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAlB/wFxQRtrDg0ABgECBgMEBgYGBgYFBgsgA0GYAWogAUEEaiACEJQDIAMoApwBIQIgAygCmAEiAUGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgATYCAAwICyACDQYgAEKTgICACDcCAAwHCyADQZgBaiABQQhqIAIQlAMgAygCnAEhBiADKAKYASICQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAY2AgQgACACNgIADAcLIAYEQCABKAIEIQIMBgsgAEKTgICACDcCAAwGCyADQZgBaiABQQRqIAIQlAMgAygCnAEhAiADKAKYASIBQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAI2AgQgACABNgIADAYLIAINBCAAQpOAgIAINwIADAULIANBEGogAUEEahDDNCADKAIUIQEgAygCECEEIAMgAjYCoAEgAyAENgKYASADIAQgAUECdGo2ApwBIANBKGogA0GYAWoQihcgA0EsaiEEIAMoAigiAUGTgICAeEcEQCAAIAMoAjg2AhAgACABNgIAIAAgBCkCADcCBCAAQQxqIARBCGooAgA2AgAMBQsgA0GgAWogBEEIaigCACICNgIAIAMgBCkCADcDmAEgA0EIaiADKAKcASIBIAEgAkECdGoQmxggAyADKAIMIgY2AlQgAyADKAIIIgI2AlAgBBD4JSADQZgBakEEQQQQ4B4gAyADQdAAaiIBEMM0IAMoAgQNAyAAQpOAgIAINwIAIAIgAigCACIAQQFrNgIAIABBAUcNBCABEIUdDAQLIANBIGogAUEEahCwLiADKQMgIRIgAyACNgKgASADIBI3ApgBIANBPGohDyMAQTBrIgckACAHQZOAgIB4NgIAIAdBKGogA0GYAWoiAkEIaigCADYCACAHIAIpAgA3AyAgByAHNgIsIAdBFGohECMAQTBrIgUkACAFQRRqIAdBIGoiDBD/FwJAAkACQCAFKAIUQQFGBEAgBSgCHCEEIAUtABghAiAFQSBqIg1BBEEAQQRBCBCgGCAFKAIkIQogBSgCIEEBRg0CIAUoAigiBiAENgIEIAYgAjoAACAFQRBqIgtBATYCACAFIAY2AgwgBSAKNgIIIAVBKGogDEEIaikCADcDACAFIAwpAgA3AyAjAEEQayIOJAAgDkEEaiANEP8XIA4oAgRBAUYEQCAFQQhqIQwDQCAOKAIMIQYgDi0ACCEEIAwoAggiCiAMKAIARgRAIAwgCkEBQQRBCBDQKAsgDCgCBCAKQQN0aiICIAY2AgQgAiAEOgAAIAwgCkEBajYCCCAOQQRqIA0Q/xcgDigCBA0ACwsgDkEQaiQAIBBBCGogCygCADYCACAQIAUpAgg3AgAMAQsgEEEANgIIIBBCgICAgMAANwIACyAFQTBqJAAMAQsgCiAFKAIoQbiBwwAQ/S8ACwJAIAcoAgBBk4CAgHhHBEAgDyAHKQIANwIAIA9BEGogB0EQaigCADYCACAPQQhqIAdBCGopAgA3AgAgEBCfJSAQQQRBCBDgHgwBCyAPIAcpAhQ3AgQgD0GTgICAeDYCACAPQQxqIAdBHGooAgA2AgALIAdBMGokACADQUBrIQsgAygCPCICQZOAgIB4RwRAIAAgAygCTDYCECAAIAI2AgAgACALKQIANwIEIABBDGogC0EIaigCADYCAAwECyADQaABaiALQQhqKAIAIgQ2AgAgAyALKQIANwOYASADQRhqIAMoApwBIgIgAiAEQQN0ahCcGCADIAMoAhwiBjYCVCADIAMoAhgiAjYCUCALEJ8lIANBmAFqQQRBCBDgHiADQdAAahCOPkUEQCABLQABIQ0MAwsgAEKTgICACDcCACACIAIoAgAiAEEBazYCACAAQQFHDQMgA0HQAGoQhh0MAwsgA0GYAWogAUEEaiACEJQDIAMoApwBIQIgAygCmAEiBkGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgBjYCAAwDCyACBEAgAS0AASENDAILIABCk4CAgAg3AgAMAgsgAigCACgCACgCACACKAIEIgIoAgAQ8iYgAiACKAIAQQFqNgIAQQAhCQRAIAggCCgCACIBQQFqNgIAIAghCSABQQBIDQQLIABBk4CAgHg2AgAgACAJNgIEDAELAkACQCARLQAAIgFBIkcEQCABQShGDQEgAiEEIAYhAQwCCxDNLyEEIANBmAFqIAgoAjQQwAYgBEEIaiADQaABaigCADYCACAEIAMpApgBNwIAQQxBBBCtNiIBRQ0DIAEgBjYCCCABIAI2AgQgASANOgABIAEgCToAAEEiIQkMAQsgCCgCNCIEIAQoAgAiAUEBajYCACABQQBIDQMgA0HMAWogCCgCOCIKQTxqEN0gIANBwAFqIApBMGoQwAYgCi8BSCELIAopAyghEiADQZgBaiIBIApBCGoQsS4gAyASNwO4ASADIAs7AdgBIAMgBjYC7AEgAyACNgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiAiABIANB5AFqEKQrQdAAQQgQrTYiAUUNBCABQoGAgIAQNwMAIAFBCGogAkHIAPwKAABBKCEJCyADQcwBaiAIQTxqEN0gIANBwAFqIBEQwAYgCC8BSCERIAgpAyghEiADQZgBaiICIAhBCGoQsS4gAyASNwO4ASADIBE7AdgBIAMgATYC7AEgAyAENgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiASACIANB5AFqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogAUHIAPwKAAAgAEGTgICAeDYCACAAIAI2AgQLIANB8AFqJAAPC0EEQQwQoz0LAAtBCEHQABCjPQALQQhB0AAQoz0AC/5UAg5/A34jAEGwAWsiBSQAIAUgAjYCPCAFIAE2AjggBUEANgJoIAVCgICAgMAANwJgIAVBATsBrAEgBUEANgKoASAFIAEgAmo2AqQBIAUgATYCoAEgBSACNgKcASAFIAE2ApgBIAUgAjYClAEgBUEANgKQASAFQRhqIAVBkAFqEK8LAkACQCAFKAIYIghFDQAgBSgCHCEHA0AgByAIaiELQQAhAiAIIQECQAJAAkADQCACIQQgASICIAtGDQECfyACLAAAIgFBAE4EQCABQf8BcSEGIAJBAWoMAQsgAi0AAUE/cSEKIAFBH3EhBiABQV9NBEAgBkEGdCAKciEGIAJBAmoMAQsgAi0AAkE/cSAKQQZ0ciEKIAFBcEkEQCAKIAZBDHRyIQYgAkEDagwBCyAGQRJ0QYCA8ABxIAItAANBP3EgCkEGdHJyIQYgAkEEagsiASAEIAJraiECIAZBMGtBCkkgBkEta0ECSXINAAsCQCAERQ0AIAQgB08EQCAEIAdGDQEMBwsgBCAIaiwAAEG/f0wNBgsgByAEayEGIAQgCGohASAJIAUoAmBHDQJB3M+AASECDAELIAVBEGogBUGQAWoQrwsgBSgCECIBBEAgBSgCFCEGIAUoAmAgCUcEQCAHIQQMAwtB7M+AASECIAchBAwBCyAFKAJgIAlGBEAgBUHgAGpB/M+AARCeKAsgBSgCZCAJQQR0aiIBQQA2AgggASAHNgIEIAEgCDYCACAFIAlBAWo2AmgMAwsgBUHgAGogAhCeKAsgBSgCZCAJQQR0aiICIAY2AgwgAiABNgIIIAIgBDYCBCACIAg2AgAgBSAJQQFqIgk2AmggBUEIaiAFQZABahCvCyAFKAIMIQcgBSgCCCIIDQALCyAFQcgAaiAFQegAaiIOKAIAIgE2AgAgBSAFKQJgNwNAIAUoAkQhByAFIAM2AmggBSAHIAFBBHQiD2o2AmQgBSAHNgJgIAVBkAFqIQEjAEEwayIDJAAgA0GTgICAeDYCACADQShqIAVB4ABqIgJBCGooAgA2AgAgAyACKQIANwMgIAMgAzYCLCADQRRqIQYjAEFAaiICJAAgAkEYaiADQSBqIggQhRgCQAJAAkAgAi8BKARAIAJBMGoiCkEEQQBBCEEYEKAYIAIoAjQhCSACKAIwQQFGDQIgAigCOCIEIAIpAxg3AwAgBEEQaiACQShqKQMANwMAIARBCGogAkEgaikDADcDACACQRRqIgxBATYCACACIAQ2AhAgAiAJNgIMIAJBOGogCEEIaikCADcDACACIAgpAgA3AzAjAEEgayIEJAAgBEEIaiAKEIUYIAQvARgEQCACQQxqIQgDQCAIKAIIIgkgCCgCAEYEQCAIIAlBAUEIQRgQ3igLIAgoAgQgCUEYbGoiCyAEKQMINwMAIAtBEGogBEEYaiINKQMANwMAIAtBCGogBEEQaikDADcDACAIIAlBAWo2AgggBEEIaiAKEIUYIA0vAQANAAsLIARBIGokACAGQQhqIAwoAgA2AgAgBiACKQIMNwIADAELIAZBADYCCCAGQoCAgICAATcCAAsgAkFAayQADAELIAkgAigCOEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAEgAykCADcCACABQRBqIANBEGooAgA2AgAgAUEIaiADQQhqKQIANwIAIAZBCEEYEOAeDAELIAEgAykCFDcCBCABQZOAgIB4NgIAIAFBDGogA0EcaigCADYCAAsgA0EwaiQAAkACQCAFKAKQAUGTgICAeEYEQCAFKAKcASEDIAUoApgBIQIgBSAFKAKUATYCgAEgBSACNgJ4IAUgAiADQRhsajYChAEgBSACNgJ8IAVBoAFqIgxCAjcCACAFQZgBaiINQgA3AgAgBUKAgICAgAE3ApABIAVBnAFqIQIjAEEQayIDJAACQCAFQfgAaiIEKAIMIgggBCgCBCIGRg0AIAggBmtBGG4iCCABKAIAIAEoAggiBmtLBEAgASAGIAhBCEEQEN4oCyAIIAIoAgAgAigCCCIGa00NACACIAYgCEECQQIQ3igLIANBCGogBEEIaikCADcDACADIAQpAgA3AwAjAEEQayIIJAAgAygCBCIEIAMoAgwiEEcEQCABKAIEIAEoAggiCUEEdGohBiACKAIEIAIoAggiCkEBdGohCwNAIARBEGovAQAhESAEKQMAIRIgBkEIaiAEQQhqKQMANwMAIAYgEjcDACALIBE7AQAgBkEQaiEGIAtBAmohCyAKQQFqIQogCUEBaiEJIARBGGoiBCAQRw0ACyABIAk2AgggAyAENgIEIAIgCjYCCAsgCCADKAIANgIMIAggAygCCDYCCCAIQQhqQQhBGBDgHiAIQRBqJAAgA0EQaiQAIAVB8ABqIAwpAgA3AwAgDiANKQIAIhI3AwAgBSAFKQKQASITNwNgIAVB2ABqIBI+AgAgBSATNwNQIAVBgAFqIAVB9ABqKAIAIgI2AgAgBSAFKQJsNwN4IAUoAkAhBAJAIAJFDQAgBSgCfCEBIAJBAXQhA0EAIQJBACEGA0AgAiAPRg0BIAIgB2oiCCgCAEUNASABLwEAIgkgBnFB/x9xRQRAIAFBAmohASACQRBqIQIgBiAJciEGIANBAmsiA0UNAgwBCwsgBSAIQQxqKAIAQQAgCEEIaigCACIBGzYCjAEgBSABQQEgARs2AogBIAVBAzYClAEgBUG8z4ABNgKQASAFQgI3ApwBIAVBzAE2AmwgBUHEDTYCZCAFIAVB4ABqNgKYASAFIAVBiAFqNgJoIAUgBUE4ajYCYCAFQShqIAVBkAFqIgEQmQ4gBSAHNgKUASAFIAQ2ApABIAFBBEEQEOAeIAVB+ABqQQJBAhDgHiAFQdAAakEIQRAQ4B4MAgsgBSAHNgKUASAFIAQ2ApABIAVBkAFqIgFBBEEQEOAeIAUoAlghAiAFKAKAASEDIAUoAlQhBCAFKAJ8IQcgBUEANgKgASAFIAc2ApgBIAUgBDYCkAEgBSADIAIgAiADSxs2AqQBIAUgByADQQF0ajYCnAEgBSAEIAJBBHRqNgKUASMAQSBrIgIkACACQRRqIAEoAhQgASgCEGtBAEEIQRgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBlMKAARD9LwALIAVBKGohCSACQRBqIgpBADYCACACIAIoAhw2AgwgAiADNgIIIAEoAhQiCCABKAIQIgdrIgYgAkEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAZBCEEYEN4oIAMoAgghBAsgAyAHIAhHBH8gBCAIaiAHayABKAIAIAdBBHRqIQggASgCCCAHQQF0aiEHIAMoAgQgBEEYbGohAwNAIAhBCGopAwAhEiAIKQMAIRMgA0EQaiAHLwEAOwEAIANBCGogEjcDACADIBM3AwAgCEEQaiEIIAdBAmohByADQRhqIQMgBkEBayIGDQALBSAECzYCCCAJQQhqIAooAgA2AgAgCSACKQIINwIAIAJBIGokACAFQfgAakECQQIQ4B4gBUHQAGpBCEEQEOAeIAUoAjAhAyAFKAIsIQIgBSAFKAIoNgJoIAUgAjYCYCAFIAIgA0EYbGo2AmwgBSACNgJkIAVBmAFqQgA3AwAgBUIANwOQASMAQeAAayIIJAACQCAFQeAAaiIOKAIEIgIgDigCDCINRwRAIAhBDGohCiAIQShqIQ8gCEHIAGohCwNAIAsgAikDADcDACAOIAJBGGoiAzYCBCALQRBqIAJBEGopAwA3AwAgC0EIaiACQQhqKQMANwMAIAhBQGsgAUEIaiIQKQMANwMAIAggASkDADcDOCAIQThqIQcgCCkDSCESIAgpA1AhEyAILwFYIQYjAEGQAmsiAiQAIAIgEzcDuAEgAiASNwOwASAIQSBqIgQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGaEEBaw4LAQIDBAUGBwgJCgsACyACQuQANwPIASACIBI3A8ABIAJBEGogEiASQj+HQuQAQgAQqB4gAikDECISQj+HIhQgAikDGFINCyACQgw3A8gBIAIgEjcDwAEgAiASIBRCDEIAEKgeIAIpAwggAikDACISQj+HUgRAIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwYCyACIBNCDH5CgMDK84SjAn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMGAsgE0KAgICACH1C/////29YBEAgAkECNgLsASACQdTMgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwYCyACIAcoAggiCTYCwAEgAiATpyIGNgLIASAGQQBIIAkgBiAJaiIGSkYNGCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcUQNgKMAiACQcUQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYiAgIB4NgIEDBcLIAJCCjcDyAEgAiASNwPAASACQTBqIBIgEkI/h0IKQgAQqB4gAikDMCISQj+HIhQgAikDOFINFSACQgw3A8gBIAIgEjcDwAEgAkEgaiASIBRCDEIAEKgeIAIpAyggAikDICISQj+HUgRAIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwXCyACIBNCDH5CgIDpg7HeFn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMFwsgE0KAgICACH1C/////29YBEAgAkECNgLsASACQZTNgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwXCyACIAcoAggiCTYCwAEgAiATpyIGNgLIASAGQQBIIAkgBiAJaiIGSkYNFyACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcUQNgKMAiACQcUQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYiAgIB4NgIEDBYLIAJCDDcDyAEgAiASNwPAASACQUBrIBIgEkI/h0IMQgAQqB4gAikDSCACKQNAIhJCP4dSDRMgAiATQgx+QoCAmqbqr+MBfyITNwPIASACIBI3A8ABIBNCAFMgEiASIBN8IhNVRwRAIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwWCyATQoCAgIAIfUL/////b1gEQCACQQI2AuwBIAJB0M2AATYC6AEgAkIBNwL0ASACQccQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKAAiACIAJBsAFqNgLIASACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYSAgIB4NgIEDBYLIAIgBygCCCIJNgLAASACIBOnIgY2AsgBIAZBAEggCSAGIAlqIgZKRg0WIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxRA2AowCIAJBxRA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBiICAgHg2AgQMFQsgEkKAgICACH1CgICAgHBUDREgAiAHKAIIIgk2AsABIAIgEqciBjYCyAEgBkEASCAJIAYgCWoiBkpGBEAgAiAHKAIMIgw2AsABIAIgE0IDfkKAgOmDsd4Wf6ciCTYCyAEgCUEASCAMIAkgDGoiCUpGDQoLIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxRA2AowCIAJBxRA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBiICAgHg2AgQMFAsgAkIHNwPIASACIBI3A8ABIAJB0ABqIBIgEkI/h0IHQgAQqB4gAikDWCACKQNQIhJCP4dSDQ8gEkKAgICACH1C/////29YBEAgAkECNgLsASACQcDOgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwUCyAHKAIIIQYgAiAHKAIMIgw2AsABIAIgEqciCTYCyAEgCUEASCAMIAkgDGoiCUpHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHFEDYCjAIgAkHFEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGIgICAeDYCBAwUCyACIAcpAwAiFDcDwAEgAiATQqAvfkKQzgB/IhI3A8gBIBJCAFMgFCASIBR8IhJVRg0VIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwTCyASQoCAgIAIfUKAgICAcFQNDSAHKAIIIQYgAiAHKAIMIgw2AsABIAIgEqciCTYCyAEgCUEASCAMIAkgDGoiCUpHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHFEDYCjAIgAkHFEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGIgICAeDYCBAwTCyACIAcpAwAiFDcDwAEgAiATQuAGfkKQzgB/IhI3A8gBIBJCAFMgFCASIBR8IhJVRg0UIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwSCyACQoDA4oXj6AA3A8gBIAIgEjcDwAEgAkHgAGogEiASQj+HQoDA4oXj6ABCABCoHiACKQNoIAIpA2AiEkI/h1INCyACIBNCJH5CkM4AfyITNwPIASACIBI3A8ABIBNCAFMgEiASIBN8IhNVRwRAIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwSCyAHKAIMIQkgBygCCCEGIAIgBykDACISNwPAASACIBM3A8gBIBNCAFMgEiASIBN8IhJVRg0TIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwRCyACQoCwncLfATcDyAEgAiASNwPAASACQfAAaiASIBJCP4dCgLCdwt8BQgAQqB4gAikDeCACKQNwIhJCP4dSDQkgAiATQgZ+QqCNBn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMEQsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNEiACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMEAsgAkKAlOvcAzcDyAEgAiASNwPAASACQYABaiASIBJCP4dCgJTr3ANCABCoHiACKQOIASACKQOAASISQj+HUg0HIAIgE0LAhD1/IhM3A8gBIAIgEjcDwAEgE0IAUyASIBIgE3wiE1VHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDBALIAcoAgwhCSAHKAIIIQYgAiAHKQMAIhI3A8ABIAIgEzcDyAEgE0IAUyASIBIgE3wiElVGDREgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA8LIAJCwIQ9NwPIASACIBI3A8ABIAJBkAFqIBIgEkI/h0LAhD1CABCoHiACKQOYASACKQOQASISQj+HUg0FIAIgE0KAlOvcA38iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDwsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNECACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDgsgAkLoBzcDyAEgAiASNwPAASACQaABaiASIBJCP4dC6AdCABCoHiACKQOoASACKQOgASISQj+HUg0DIAIgE0KAoJSljR1/IhM3A8gBIAIgEjcDwAEgE0IAUyASIBIgE3wiE1VHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA4LIAcoAgwhCSAHKAIIIQYgAiAHKQMAIhI3A8ABIAIgEzcDyAEgE0IAUyASIBIgE3wiElVGDQ8gAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA0LIAIgE0KAgJqm6q/jAX8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDQsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNDiACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDAsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAsLIAcpAwAhEgwMCyACQQI2AuwBIAJB1MKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMCQsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAgLIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwHCyACQQI2AuwBIAJB1MKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMBgsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAULIAJBAjYC7AEgAkHwzoABNgLoASACQgE3AvQBIAJB7gY2AoQCIAIgAkGAAmo2AvABIAIgAkGwAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBjYCAgHg2AgQMBAsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAMLIAJBAjYC7AEgAkGEzoABNgLoASACQgE3AvQBIAJBxxA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AoACIAIgAkGwAWo2AsgBIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBhICAgHg2AgQMAgsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAELIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAtBAQwCCyAHKQMAIRIgBygCDCEJCyAEIAk2AhQgBCAGNgIQIAQgEjcDCEEACzYCACACQZACaiQAIAgoAiAEQCAIQRhqIAhBNGooAgAiAjYCACAIQRBqIAhBLGopAgAiEjcDACAIIAgpAiQiEzcDCCAAQRRqIAI2AgAgAEEMaiASNwIAIAAgEzcCBCAAQQE2AgAMAwsgCiAPKQIANwIAIApBCGoiAiAPQQhqKQIANwIAIBAgAikCADcCACABIAopAgA3AgAgAyICIA1HDQALCyAAQQA2AgAgACABKQMANwMIIABBEGogAUEIaikDADcDAAsgCEHgAGokACAFIAUoAmA2ApQBIAUgBSgCaDYCkAEgAUEIQRgQ4B4MAgsgBUGQAWoiARCIESAFQQE2ApQBIAVB1M+AATYCkAEgBUIBNwKcASAFQcQNNgJkIAUgBUHgAGo2ApgBIAUgBUE4ajYCYCAFQShqIAEQmQ4gBUFAa0EEQRAQ4B4LIAUpAighEiAAIAUpAjA3AxAgACASNwMIIABCgYCAgMCAgICAfzcDAAsgBUGwAWokAA8LIAggB0EAIARBhMKAARCjNgALtQwCBH8BfiMAQUBqIgMkACADQQxqQaD+zwBBChCAICADQSxqIAIQ8icCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyABKAIgQYCAgIB4RwRAIANBLGoiBEGq/s8AQQNBCEEBEOgcIANBGGogAiAEELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiABKAIkIAEoAigQxSAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCLEGAgICAeEcEQCADQSxqIgRBrf7PAEEDQQhBAhDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCMCABKAI0EMUgIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEoAgAEQCABKQMIIQcgA0EsaiIEQbD+zwBBCkEHQQMQ6BwgA0EYaiACIAQQsBQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwCCyADQSxqIgQQhjAgBCACIAcQsRsgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCEARAIAEpAxghByADQSxqIgRBuv7PAEEOQQdBBBDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgBxCxGyADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwCCyACENMhCyABKAI4QYCAgIB4RwRAIANBLGoiBEHI/s8AQQlBCEEFEOgcIANBGGogAiAEELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiABKAI8IAEoAkAQxSAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCREGAgICAeEcEQCADQSxqIgRB0f7PAEEJQQhBBhDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCSCABKAJMEMUgIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEtAFAiBUECRwRAIANBLGoiBEHa/s8AQRJBAkEHEOgcIANBGGogAiAEELAUIAMoAhgiBkEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAGNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiAFQQFxEMYVIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEtAFEiBEECRwRAIANBLGoiAUHs/s8AQRJBAkEIEOgcIANBGGogAiABELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAEQhjAMAgsgA0EsaiIBEIYwIAEgAiAEQQFxEMYVIAMoAiwiAUEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACABNgIADAILIAIQ0yELIANBLGogAhCrKSADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwBCyAAIAIQ6igLIANBDGoQ3jsgA0FAayQAC7NBAhV/BX4jAEGQAWsiByQAAkACQAJAAkACQAJAAkACQAJAIAEtAAxBIUYEQAJAIAFBEGoiCygCBEECTwRAIAEoAgghBCABKAIEIQMgB0EANgIgIAcgAzYCGCAHIAMgBEEDdGo2AhwgB0HQAGohDSMAQdAAayIIJAACQCAHQRhqIgkoAgAiAyAJKAIEIgxHBEAgCSgCCCEKIAhBHGohDyAIQSBqIQIgCEE8aiEOA0AgCSADQQhqIgQ2AgACQAJAAkAgAygCACIGRQ0AIAhBOGogBiADKAIEIgMoAghBAWtBeHFqQQhqIAMoAjgRAAAgCCgCOCIGRQ0AIAIgDikCADcCACACQRBqIA5BEGooAgA2AgAgAkEIaiAOQQhqKQIANwIAIAggBjYCHCAIIAo6ABggCCgCMEUEQCAGIAYoAgAiA0EBazYCACADQQFGBEAgDxD7HgsgCSAJKAIIQQFqIgo2AgggCSgCBCEMIAkoAgAhAwwDCyAIQQhqIgwgAkEIaikCADcDACAIQRBqIg4gAkEQaigCADYCACAIIAIpAgA3AwAgCCgCGCEPIAkgCkEBajYCCCAIQRhqIgJBBEEAQQRBHBCgGCAIKAIcIQQgCCgCGEEBRg0BIAgoAiAiAyAIKQMANwIIIAMgBjYCBCADIA82AgAgCEFAayISQQE2AgAgA0EQaiAMKQMANwIAIANBGGogDigCADYCACAIIAM2AjwgCCAENgI4IAhBIGogCUEIaigCADYCACAIIAkpAgA3AxggCEE4aiEGIwBB0ABrIgMkAAJAIAIoAgAiBCACKAIEIg9GDQAgAigCCCEKIANBIGohEyADQSRqIQwgA0E8aiEQA0AgBCEJA0AgAiAJQQhqIgQ2AgACfwJAIAkoAgAiDkUNACADQThqIA4gCSgCBCIJKAIIQQFrQXhxakEIaiAJKAI4EQAAIAMoAjgiCUUNACAMIBApAgA3AgAgDEEQaiIOIBBBEGooAgA2AgAgDEEIaiIRIBBBCGopAgA3AgAgAyAJNgIgIAMgCjoAHCADKAI0RQRAIAkgCSgCACIEQQFrNgIAIARBAUYEQCATEPseCyACIAIoAghBAWoiCjYCCCACKAIEIQ8gAigCAAwCCyADQRBqIhQgESkCADcDACADQRhqIhUgDigCADYCACADIAwpAgA3AwggAygCHCEWIAIgCkEBaiIKNgIIIAYoAggiESAGKAIARgRAIAYgEUEBQQRBHBDeKAsgBigCBCARQRxsaiIOIAk2AgQgDiAWNgIAIA4gAykDCDcCCCAOQRBqIBQpAwA3AgAgDkEYaiAVKAIANgIAIAYgEUEBajYCCCAEIA9HDQMMBAsgAiAKQQFqIgo2AgggBAsiCSAPRw0ACwsLIANB0ABqJAAgDUEIaiASKAIANgIAIA0gCCkCODcCAAwFCyAJIApBAWoiCjYCCCAEIQMMAQsgBCAIKAIgQcj/hQEQ/S8ACyADIAxHDQALCyANQQA2AgggDUKAgICAwAA3AgALIAhB0ABqJAAgBygCWCIJRQ0EIAcoAlQiBEEUaiEGIAkhAwNAIAUgBkEEaigCACAGKAIARmohBSAGQRxqIQYgA0EBayIDDQALIAUgCygCBEYNASABKAIkRQ0GIAdBIGogB0HYAGooAgA2AgAgByAHKQJQNwMYIAdBBGogASAHQRhqEPsNDAcLIAEoAghBA3QhBSABKAIEIQYgB0HsAGohBCAHQRtqIQkgB0EvaiEIA0AgBUUNA0EAIQMCQCAGKAIAIgpFDQAgB0HQAGogCiAGQQRqKAIAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgBygCUEUNAAJAIAEQuiZFBEAgB0H4AGogB0HgAGopAgA3AwAgB0HwAGogB0HYAGopAgA3AwAgByAHKQJQNwNoDAELQRxBBBCtNiIDRQ0NIAkgBykCUDcAACAJQRBqIAdB4ABqKQIANwAAIAlBCGogB0HYAGopAgA3AAAgA0EAOgAAIAMgBykAGDcAASADQQlqIAdBIGopAAA3AAAgA0ERaiAHQShqKQAANwAAIANBGGogCCgAADYAACAHQQE2AowBIAcgAzYCiAEgB0EBNgKEASAHQRhqIgMgASAHQYQBahD7DSAHQegAaiADEOEnCyAHQUBrIARBCGopAgA3AwAgB0HIAGogBEEQaigCADYCACAHIAQpAgA3AzggBygCaCEDCyAGQQhqIQYgBUEIayEFIANFDQALIAAgAzYCACAAIAcpAzg3AgQgAEEMaiAHQUBrKQMANwIAIABBFGogB0HIAGooAgA2AgAMBwsgCUEcbCEGIARBGGshAyABKAIgIQEgBCEFAkADQCAGRQRAIAlBHGwhBiAEQRhrIQUDQCAGRQ0DIAZBHGshBiAFQRxqIQUgBCgCFCEDIARBHGohBCABIANPDQALIAAgBUEAIAEQsR8MBgsgBkEcayEGIANBHGohAyAFKAIUIQggBUEcaiEFIAEgCEcNAAsgAygCACIEIAQoAgAiBUEBajYCACAFQQBIDQkgACABNgIQIAAgBDYCACAAIANBFGooAgA2AhQgACADQQxqKAIANgIMIAAgA0EEaikCADcCBAwECyAAIAEQ5ToMAwtByIWGAUEoQfSIhgEQnykACyAAQQA2AgAMBAsgAEEANgIACyAHQdAAaiIAENsmIABBBEEcEOAeDAILIAsoAgQhAyALKAIEIQQgCygCBCEIIAdBgwI7ATQgB0GCAjsBLCAHQQE6ACQgByADQQFrNgIgIAdBgAI7ARxBACEGIAdBADYCGCAHIAggBWs2AjAgByAJNgIoIAcgBCAJRjoAJQNAIAZBIEYNAyAHQRhqIgQgBmogBkEIaiIDIQZBBWotAABBAUcNAAsgAyAEaiIGQQhrIQQCQCADQSBGBEAgBCEDDAELQSAgA2tBA3YhBSAEIQMDQCAGQQVqLQAAQQFGBEAgBiAEIAYoAgAgBCgCAEkiCRshBCAGIAMgCRshAwsgBkEIaiEGIAVBAWsiBQ0ACwsCQAJAAkACQCADLQAEQQFrDgMBAgMACyAHQfAAaiAHQdgAaigCADYCACAHIAcpAlA3A2ggB0EEaiABIAdB6ABqEPsNDAMLIAdB8ABqIAdB2ABqKAIANgIAIAcgBykCUDcDaCAHQQRqIRIjAEHgAGsiAiQAIAJBEGogB0HoAGoiDygCBCIDIAMgDygCCEEcbGoQwxsgAkEcaiACKAIUIgMgAyACKAIYQRhsahDCGyABKAIcIQggAiABKAIgIg5BA3YiAUH4////AXEiDDYCREHAACEEAkACQAJAAkACQAJAIAFBwP///wFxQUBrIAwgDkHAA3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIERQ0CCyAOQUBxIQogBCEFIA5BwABPBEAgCiEJIAghAwNAIAIoAiQiAUUNBCACKAIgIQYCfiABQRhsIgFBGEYEQEIAIRlCfwwBCyAGQRhqIRMgAUEYa0EYbiEUQQAhDUIAIRhCACEZA0AgEyANQRhsaiIBKAIUIhAgASgCEE8NByABKAIEIBBBA3RqIhUpAAAhGyABKAIMIhEEQCAVQQhqMQAAQQAgEWtBP3GthiAbIBFBP3GtiIQhGwsgASAQQQFqNgIUQgAhFyABLQAAIRAgAyEBQgAhGgNAIAEtAAAgEEatIBeGIBqEIRogAUEBaiEBIBdCAXwiF0LAAFINAAsgGCAahCEYIBogG4MgGYQhGSANQQFqIg0gFEcNAAsgGEJ/hQshGCAGKAIUIgEgBigCEE8NBiAGKAIEIAFBA3RqIhApAAAhFyAGKAIMIg0EQCAQQQhqMQAAQQAgDWtBP3GthiAXIA1BP3GtiIQhFwsgA0FAayEDIAYgAUEBajYCFCAFIBcgGIMgGYQ3AAAgBUEIaiEFIAlBQGoiCQ0ACwsgAiAFIARrIgE2AjggASAMRw0FIAIgDDYCNCACIAQ2AjAgAiALNgIsQcAAIQEgAkHAADYCKCAOQT9xIgUEQAJAIAIoAhgiEEUEQEIAIRgMAQsgCCAKaiEDIAIoAhQhCiAFrSEbQgAhGEEAIQkDQEIAIRkgCiAJQRhsaiIFKAIUIggEQCAFKAIEIAUoAhBBA3RqIgYxAAAgBSgCDCIBQT9xrYghFyABIAhqIg1BA3YgDUEHcUEAR2oiDUECTwRAQQggAWshASANQQFrIQ0gBkEBaiEGA0AgBjEAACABQT9xrYYgF4QhFyAGQQFqIQYgAUEIaiEBIA1BAWsiDQ0ACwsgF0J/IAhBP3GthkJ/hYMhGQtCACEXIAUtAAAhBSADIQFCACEaA0AgAS0AACAFRq0gF4YgGoQhGiABQQFqIQEgGyAXQgF8IhdSDQALIBkgGoMgGIQhGCAJQQFqIgkgEEcNAAsLIAsgDEEIaiIBSQR/IAJBKGogC0EBdCIDIAFBwP///wNxQUBrIAEgAUE4cRsiASABIANJGxDoGSACKAI0IQwgAigCMAUgBAsgDGogGDcAACACIAIoAjRBCGoiDDYCNCACKAIwIQQgAigCLCELIAIoAighAQsgAiALNgJYIAIgATYCVCACQQA2AlAgAiAMNgJMIAIgBDYCSCACQQhqIAJByABqENc7IAIoAgghA0EcQQQQrTYiAUUNDSABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAJB0ABqKQIANwIAIAFBGGogAkHYAGooAgA2AgAgAiAMNgJAIAIgAzYCPCACIAE2AjggEiACQThqQQAgDhDyFSACQRxqQQRBGBDgHiACQRBqQQRBGBDgHiAPENsmIA9BBEEcEOAeIAJB4ABqJAAMBgtBsP6FAUEpIAJByABqQdj/hQFB3P6FARDVHgALQcAAIAsQoz0AC0EBQQBBkIaGARCvOwALQbCGhgEQsjsAC0GghoYBELI7AAsgAkIANwJUIAJCgYCAgMAANwJMIAJBoP+FATYCSEEAIAJBOGogAkHEAGogAkHIAGpBqP+FARCvKwALDAILIAdB8ABqIAdB2ABqKAIANgIAIAcgBykCUDcDaCAHQQRqIRMjAEHgAGsiAiQAIAJBDGogB0HoAGoiDigCBCIDIAMgDigCCEEcbGoQwxsgAkEYaiACKAIQIgMgAyACKAIUQRhsahDCGyABKAIcIQggAiABKAIgIg1BA3YiA0H4////AXEiBjYCNEHAACEBAkACQAJAIANBwP///wFxQUBrIAYgDUHAA3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiIBRQ0CCyABIQMgDUHAAE8EQEEAIA1BQHFrIQsgCCEEA0AgAiACKAIcIgUgAigCIEEYbGo2AlQgAiAFNgJQIAIgBDYCWCACQThqIQ9CACEYQgAhGgJAAkAgAkHQAGoiBSgCACIQIAUoAgQiDEcEQCAFKAIIIQogDCAQa0EYbiEUQQAhDANAIBAgDEEYbGoiBSgCFCIRIAUoAhBPDQIgBSgCBCARQQN0aiIVKQAAIRkgBSgCDCISBEAgFUEIajEAAEEAIBJrQT9xrYYgGSASQT9xrYiEIRkLIAUgEUEBajYCFEIAIRsgBS0AACERIAohBUIAIRcDQCAFLQAAIBFGrSAbhiAXhCEXIAVBAWohBSAbQgF8IhtCwABSDQALIBcgGoQhGiAXIBmDIBiEIRggDEEBaiIMIBRHDQALCyAPIBg3AwggDyAaNwMADAELQYTmhAEQsjsACyADIAIpA0AgAikDOEJ/hYQ3AAAgA0EIaiEDIARBQGshBCALQUBrIgsNAAsLIAIgAyABayIDNgJQIAMgBkcNAiACIAY2AjAgAiABNgIsIAIgCTYCKEHAACEDIAJBwAA2AiQgDUE/cSIEBEAgAigCFCEFIAIoAhAhAyACIAQ2AlwgAiAIIA1BQHFqNgJYIAIgAzYCUCACIAMgBUEYbGo2AlRCACEaQgAhGUEAIQUgAkHQAGoiAygCACIKIAMoAgQiBEcEQCADKAIMIQsgAygCCCEQIAQgCmtBGG4hEQNAQgAhGEIAIRcgCiAFQRhsaiIEKAIUIgwEQCAEKAIEIAQoAhBBA3RqIggxAAAgBCgCDCIDQT9xrYghFyADIAxqIg9BA3YgD0EHcUEAR2oiD0ECTwRAQQggA2shAyAPQQFrIQ8gCEEBaiEIA0AgCDEAACADQT9xrYYgF4QhFyAIQQFqIQggA0EIaiEDIA9BAWsiDw0ACwsgF0J/IAxBP3GthkJ/hYMhFwsgCwRAQQAhAyAELQAAIQQDQCADIBBqLQAAIARGrSADQT9xrYYgGIQhGCALIANBAWoiA0cNAAsLIBggGYQhGSAXIBiDIBqEIRogBUEBaiIFIBFHDQALCyACQThqIgMgGjcDCCADIBk3AwAgAikDQCACKQM4Qn+FhCEXIAkgBkEIaiIDSQR/IAJBJGogCUEBdCIBIANBwP///wNxQUBrIAMgA0E4cRsiAyABIANLGxDoGSACKAIwIQYgAigCLAUgAQsgBmogFzcAACACIAIoAjBBCGoiBjYCMCACKAIoIQkgAigCJCEDIAIoAiwhAQsgAiAJNgJIIAIgAzYCRCACQQA2AkAgAiAGNgI8IAIgATYCOCACIAJBOGoQ1zsgAigCACEDQRxBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgASACKQI4NwIIIAFBEGogAkFAaykCADcCACABQRhqIAJByABqKAIANgIAIAIgBjYCWCACIAM2AlQgAiABNgJQIBMgAkHQAGpBACANEPIVIAJBGGpBBEEYEOAeIAJBDGpBBEEYEOAeIA4Q2yYgDkEEQRwQ4B4gAkHgAGokAAwDC0Gw/oUBQSkgAkE4akHY/4UBQdz+hQEQ1R4AC0HAACAJEKM9AAsgAkIANwJEIAJCgYCAgMAANwI8IAJBoP+FATYCOEEAIAJB0ABqIAJBNGogAkE4akGo/4UBEK8rAAsMAQsgB0HwAGogB0HYAGooAgA2AgAgByAHKQJQNwNoIAdBBGohESAHQegAaiEJIwBB0AFrIgIkAAJAAkACQAJAAkACQCABLQAMQSFGBEAgAkEIaiABQRBqELAuIAIoAgwhCyACKAIIIQQgAkEwaiIMQYSAhgEQpSsgAkH4AGoiA0Go/oUBKQMAIhc3AwAgAkGIAWoiCCACKQM4NwMAIAJBgAFqIgogAikDMDcDACACQaD+hQEpAwAiGDcDcCMAQRBrIg0kACALIARrQQN2IgZBAWpBAXYgBiACQfAAaiIFKAIMGyIOIAUoAghLBEAgDUEIaiAFIA4gBUEQahCWBAsgBCALRwRAA0AgBSAELQAAEPUMIARBCGohBCAGQQFrIgYNAAsLIA1BEGokACACQShqIAgpAwA3AwAgAkEgaiAKKQMANwMAIAJBGGogAykDADcDACACIAIpA3A3AxAgCUEIaiINKAIAIQYgCSgCBCEEIAxBhICGARClKyADIBc3AwAgCCACKQM4NwMAIAogAikDMDcDACACIBg3A3AjAEEQayILJAAgBCAGQRxsaiIOIARrQRxuIgZBAWpBAXYgBiAFKAIMGyIPIAUoAghLBEAgC0EIaiAFIA8gBUEQahCWBAsgBCAORwRAA0AgBSAELQAAEPUMIARBHGohBCAGQQFrIgYNAAsLIAtBEGokACACQcgAaiAIKQMANwMAIAJBQGsgCikDADcDACACQThqIAMpAwA3AwAgAiACKQNwNwMwIAIoAhAiAykDACEXIAIoAhQhBCACIAIoAhw2AogBIAIgAzYCgAEgAiADIARqQQFqNgJ8IAIgA0EIajYCeCACIBdCf4VCgIGChIiQoMCAf4M3A3AgAiAMNgKQASACQdQAaiEIIwBBQGoiAyQAIANBCGogBRCNEgJAAkACQCADLQAIBEAgAy0ACSEGIANBGGoiCkEIQQBBAUEBEKAYIAMoAhwhBCADKAIYQQFGDQIgAygCICILIAY6AAAgA0EUaiIMQQE2AgAgAyALNgIQIAMgBDYCDCAKIAVBKPwKAAAjAEEQayIEJAAgBEEIaiAKEI0SIAQtAAgEQCADQQxqIQUgBC0ACSEGA0AgBSgCCCILIAUoAgBGBEAgBUEBEIEuCyAFKAIEIAtqIAY6AAAgBSALQQFqNgIIIAQgChCNEiAELQABIQYgBC0AAA0ACwsgBEEQaiQAIAhBCGogDCgCADYCACAIIAMpAgw3AgAMAQsgCEEANgIIIAhCgICAgBA3AgALIANBQGskAAwBCyAEIAMoAiBByP+FARD9LwALIwBBEGsiAyQAIAkoAggiCARAIAlBADYCCCADIAg2AgwgA0IANwIEIAMgCTYCAAJAIAMoAgQiBSAIRg0AIAMoAgAoAgQgBUEcbGpBFGohBANAIARBBGooAgAgBCgCAE8EQCADIAVBAWo2AgQgAyADKAIIQQFqNgIIIARBEGsiBCgCACIFIAUoAgAiBUEBazYCACAFQQFHDQIgBBD7HgwCCyAEQRxqIQQgCCAFQQFqIgVHDQALIAMgBTYCBAsgCCADKAIEIgRHBEADQAJAIAMoAgAoAgQiCiAEQRxsaiIFKAIYIAUoAhRPBEAgAyAEQQFqNgIEIAMgAygCCEEBajYCCCAFKAIEIgQgBCgCACIEQQFrNgIAIARBAUcNASAFQQRqEPseDAELIAMgBEEBajYCBCAKIAQgAygCCGtBHGxqIgQgBSkCADcCACAEQQhqIAVBCGopAgA3AgAgBEEQaiAFQRBqKQIANwIAIARBGGogBUEYaigCADYCAAsgAygCBCIEIAhHDQALCyADKAIMIQQgAygCACEFAkAgAygCCCIIRQ0AIAQgAygCBCIKa0EcbCIGRQ0AIAUoAgQiCyAKIAhrQRxsaiALIApBHGxqIAb8CgAACyAFIAQgCGs2AggLIANBEGokACACQegAaiANKAIAIgM2AgAgAiAJKQIANwNgIAJBmAFqIAIoAmQiBCAEIANBHGxqEMMbIAJBpAFqIAIoApwBIgMgAyACKAKgAUEYbGoQwhsgASgCHCEIIAIgASgCICINQQN2IgFB+P///wFxIgs2AswBQcAAIQkgAUHA////AXFBQGsgCyANQcADcRsiDEHAABDRNEUNASAMBEAgDEHAABCtNiIJRQ0DCyANQUBxIQogCSEFIA1BwABPBEAgAigCXCEOIAIoAlghEiAKIQQgCCEDA0BCACEaQgAhGSACKAKsASITBEAgAigCqAEhFEEAIQYDQCAUIAZBGGxqIgEoAhQiDyABKAIQTw0HIAEoAgQgD0EDdGoiFSkAACEbIAEoAgwiEARAIBVBCGoxAABBACAQa0E/ca2GIBsgEEE/ca2IhCEbCyABIA9BAWo2AhQgG1BFBEBCACEXIAEtAAAhDyADIQFCACEYA0AgAS0AACAPRq0gF4YgGIQhGCABQQFqIQEgF0IBfCIXQsAAUg0ACyAYIBuDIBmEIRkLIAZBAWoiBiATRw0ACwsgDgRAQQAhBgNAIAYgEmotAAAhDyADIQFCACEXQgAhGANAIAEtAAAgD0atIBeGIBiEIRggAUEBaiEBIBdCAXwiF0LAAFINAAsgGCAahCEaIAZBAWoiBiAORw0ACwsgA0FAayEDIAUgGSAahDcAACAFQQhqIQUgBEFAaiIEDQALCyACIAUgCWsiATYCwAEgASALRw0EIAIgCzYCvAEgAiAJNgK4ASACIAw2ArQBQcAAIQEgAkHAADYCsAEgDUE/cSIOBEAgCCAKaiEEQgAhGkIAIRkgAigCoAEiCgRAIAIoApwBIQ8gDq0hG0EAIQUDQCAPIAVBGGxqIgMtAAAhCCAEIQFCACEXQgAhGANAIAEtAAAgCEatIBeGIBiEIRggAUEBaiEBIBsgF0IBfCIXUg0ACyADKAIUIggEfiADKAIEIAMoAhBBA3RqIgYxAAAgAygCDCIBQT9xrYghFyABIAhqIgNBA3YgA0EHcUEAR2oiA0ECTwRAQQggAWshASADQQFrIQMgBkEBaiEGA0AgBjEAACABQT9xrYYgF4QhFyAGQQFqIQYgAUEIaiEBIANBAWsiAw0ACwsgF0J/IAhBP3GthkJ/hYMFQgALIBiDIBmEIRkgBUEBaiIFIApHDQALCyACKAJcIgUEQCACKAJYIQhBACEDA0AgAyAIai0AACEKQQAhAUIAIRcDQCABIARqLQAAIApGrSABQT9xrYYgF4QhFyAOIAFBAWoiAUcNAAsgFyAahCEaIANBAWoiAyAFRw0ACwsgDCALQQhqIgFJBH8gAkGwAWogDEEBdCIDIAFBwP///wNxQUBrIAEgAUE4cRsiASABIANJGxDoGSACKAK8ASELIAIoArgBBSAJCyALaiAZIBqENwAAIAIgAigCvAFBCGoiCzYCvAEgAigCuAEhCSACKAK0ASEMIAIoArABIQELIAIgDDYCgAEgAiABNgJ8IAJBADYCeCACIAs2AnQgAiAJNgJwIAIgAkHwAGoQ1zsgAigCACEDQRxBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgASACKQJwNwIIIAFBEGogAkH4AGopAgA3AgAgAUEYaiACQYABaigCADYCACACIAs2AsgBIAIgAzYCxAEgAiABNgLAASARIAJBwAFqQQAgDRDyFSACQaQBakEEQRgQ4B4gAkGYAWpBBEEYEOAeIAJB4ABqIgEQ2yYgAUEEQRwQ4B4gAkHUAGoQ3jsgAkEwakEBQQgQ2ScgAkEQakEBQQgQ2ScgAkHQAWokAAwGCyACQQA2AoABIAJBATYCdCACQaCFhgE2AnAgAkIENwJ4IAJB8ABqQfCFhgEQ7ywAC0Gw/oUBQSkgAkHwAGpB2P+FAUHc/oUBENUeAAtBwAAgDBCjPQALQYCGhgEQsjsACyACQgA3AnwgAkKBgICAwAA3AnQgAkGg/4UBNgJwQQAgAkHAAWogAkHMAWogAkHwAGpBqP+FARCvKwALQQRBHBCjPQALCyAHQRhqIgEgB0EEahDhJyAHKAIsRQRAIABBADYCACAHKAIYIgAgACgCACIAQQFrNgIAIABBAUcNASABEPseDAELIAAgBykCGDcCACAAQRBqIAdBKGopAgA3AgAgAEEIaiAHQSBqKQIANwIACyAHQZABaiQADwtB5IiGARCyOwsAC0EEQRwQoz0AC44OAwp/BH4BbyMAQbADayICJAACQCAAAn8CQAJAAkACQAJAAn8CQAJAAkACQAJAIAAtALgGQQFrDgMCDAEACyAAQZgDaiAAQZgD/AoAAAsgAEGYA2ohCAJAAkACQAJAIAAtAKwGQQFrDgMCDgABCyAAQZAGaiEGAkAgAC0AkAZBAWsOAwMOCAALIAAoAogGIQMgACgCmANBAXFFDQUgACgCnAMhBAwECyAAQaAGaiAAKAKYBhCFIyAAQQA6AJAGIAAgACgCoAYiAzYCiAYgACAAKAKcBiIENgKcAyAAIARBAEc2ApgDIABBkAZqIQYgBA0DDAQLQZzcwgAQ6CsAC0G83MIAEOgrAAtB3MjCABDoKwALIAJB6ABqIAQQxwcCQCACKAJoIgRBAmsOAgQBAAsgAigCbCEFIAJBEGoiByACQfAAakEw/AoAACAAIAU2AqQDIAAgBDYCoAMgAEGoA2ogB0Ew/AoAACAAQaADagwBCyAAQYCAgIB4NgLAAyAAQQA2AqADIABBgICAgHg2AswDIABBADYCsAMgAEEANgKoAyAAQQA2ArgDIABBoANqCyEEIAICfiADKAIAQQFGBEAgAkGYA2ogA0EQahDdICADKAIcIgUgBSgCACIHQQFqNgIAIAdBAEgNCCACQagCaiACQaADaigCADYCACACIAIpApgDNwOgAiACIAU2AqwCIAIgAykDCDcDmAJCAQwBCyACIAMoAhAQ9Do2AqACIAIgAykDGDcDqAIgAiADKQMINwOYAkIACzcDkAIgAkHoAGoiBSACQZACaiADQSBqIAQQ8BMgAkHIAGoiAyACQfgAaikDADcDACACIAIpA3A3A0ACQAJAIAIpA2giDEICUQRAIAJB8ABqIAMpAwA3AwAgAiACKQNANwNoIAUQ0xkhAQwBCyACQZACaiIDIAJBgAFqIglB4AD8CgAAIAAgDDcD2AMgACACKQNANwPgAyAAQegDaiACQcgAaikDADcDACAAQfADaiADQeAA/AoAACAAKAK8BCIFIAUoAgAiB0EBajYCACAHQQBIDQggAEGMBmoiByAFNgIAIAMgAEHYA2pB+AD8CgAAIAJB6ABqIgUgAxDKBSACQdgAaiIDIAJB+ABqIgopAwA3AwAgAkHgAGoiCyAJKQMANwMAIAIgAikDcDcDUCACKQNoIgxCA1INASAKIAspAwA3AwAgAkHwAGogAykDADcDACACIAIpA1A3A2ggBRDSGSEBIAcoAgAiAyADKAIAIgNBAWs2AgAgA0EBRw0AIAcQ+CMLIAQQgSoMAwsgAkGQAmoiAyACQYgBakGIAfwKAAAgAkGoA2ogAkHgAGopAwAiDTcDACACQaADaiACQdgAaikDACIONwMAIAIgAikDUCIPNwOYAyAAIAw3A9AEIAAgDzcD2AQgAEHgBGogDjcDACAAQegEaiANNwMAIABB8ARqIANBiAH8CgAAIABBADYCgAYgAEKAgICAwAA3A/gFCyACQegAaiAAQdAEaiIFIAEQ5BEgAigCaCIDQQlGBEAgBkEDOgAAQQIhA0EDDAULIAIpA3ghDCACKAJ0IQYgAigCcCEBIAIoAmwhBCAFEMIKIANBCEYNAiACIAw3A3ggAiAGNgJ0IAIgATYCcCACIAQ2AmwgAiADNgJoQcTKwgBBKyACQegAakGAy8IAQczcwgAQ1R4ACyACKAJsEIAYIQELQQEhAyAGQQE6AAAgCBDIIwwBCyAAKAKMBiEFIABBoANqEIEqQQEhAyAAQQE6AJAGIARBgYCAgHhGBEBBAiEDQQMMAgsgCBDIIyAEQYCAgIB4Rg0AIAIgBTYCdCACIAY2AnAgAiABNgJsIAIgBDYCaEEAIQMjAEEgayIEJAAgBEEYaiACQegAaiIBQQhqKQIANwIAIARBADYCDCAEIAEpAgA3AhAgBEEMahCeJ0EIahAKIRAQ3xIiASAQJgEgBEEgaiQACyAAQaAGahDkKkEBCzoArAZBAyEEAkAgA0ECRiIGDQAgCBCcLwJAIANBAXEEQCACIAE2ApACIAJBgAE2AmggAiAAQbQGaiACQegAaiACQZACahDCIyACKAIAIAIoAgQQ1i8iAUGEAU8EQCABEPIfCyACKAJoIgFBhAFPBEAgARDyHwsgAigCkAIiAUGEAUkNASABEPIfDAELIAIgATYCkAIgAkGAATYCaCACQQhqIABBsAZqIAJB6ABqIAJBkAJqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoAmgiAUGEAU8EQCABEPIfCyACKAKQAiIBQYQBSQ0AIAEQ8h8LIAAoArAGIgFBhAFPBEAgARDyHwtBASEEIAAoArQGIgFBhAFJDQAgARDyHwsgACAEOgC4BiACQbADaiQAIAYPCwAL1hMCEX8BfiMAQYADayICJAAgASkCiAIhEyABQoCAgIAQNwOIAiACQfAAaiABQZACaiIDKAIANgIAIANBADYCACACIBM3A2ggAkHIAWohCCMAQTBrIgYkAEHAACEEIAJB6ABqIgkoAgQhBSAJKAIAIQoCQAJAIAkoAggiB0EDdiAHQQdxQQBHaiIDQcD///8BcUFAayADIANBP3EbIgNBwAAQ0TQEQCADBEAgA0HAABCtNiIERQ0CCyAGQgA3AhggBiAENgIUIAYgAzYCECAGQcAANgIMIAYgBSAHajYCLCAGIAo2AiggBiAFNgIkIAYgBTYCICAGQQxqIQcjAEEQayIKJAAgBkEgaiILKAIEIgMgCygCDCIQRwRAA0AgCyADQQFqIgQ2AgQgAy0AACAHKAIQIg1BAWoiDkEDdiAOQQdxQQBHaiIFIAcoAgwiA0sEQCAFIANrIQ8gBygCBCIMIAVJBEACQCAFIgNBP3EiEkUNACADIAMgEmtBQGsiA00NAEHcgs4AQSNBgIPOABDLJAALIAcgDEEBdCIMIAMgAyAMSRsQ6BkgBygCDCEDCyAPBEAgBygCCCADakEAIA/8CwALIAcgBTYCDAsgByAONgIQQQFxBEAgBygCCCANQQN2aiIDIAMtAABBASANQQdxdHI6AAALIAQiAyAQRw0ACwsgCiALKAIANgIMIAogCygCCDYCCCAKQQhqEN47IApBEGokACAIIAcQ/BMgBxDPLyAGQTBqJAAMAgtBtKzNAEEpIAZBDGpBmLPNAEHgrM0AENUeAAtBwAAgAxCjPQALIAJBCGogAkHQAWooAgA2AgAgAiACKQLIATcDACACQQA7AaACIAJBADYCnAIgAkEANgKEAiACQQA2AvgBIAJBAToA6AEgAkIENwLgASACQgA3AtgBIAJCgICAgMAANwLQASACQQA2AsgBIAIgASgCpAI2AvQBIAkgCCACEPojIAggARDWGCACQQxqIgMgCSAIEK4WIAggAxDNHCAJIAgQ0RACQAJAAkACQAJAQTRBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAlBLPwKAAAgAkG02c0ANgKoAiACIAM2AqQCAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQdACaiIDLQAAIgVBAmsOBgECDw8DBAALAkACQCAFQSJrDgUBEAwNDgALIAVBD0YNBQwPCyABKALYAi0AAEEjaw4EBQYHCAkLQci8zQBB3OLNABC4CEUNDUHo4s0AELI7AAtByLzNAEHc4s0AELgIRQ0MQdDjzQAQsjsAC0HIvM0AQdzizQAQuAhFDQtBuOTNABCyOwALQci8zQBB3OLNABC4CEUNCkGg5c0AELI7AAtByLzNAEHc4s0AELgIRQ0JIAJByAFqIAJBpAJqQbTIzQBBiObNABDpIyACKALQASEFIAIoAswBIQQgAigCyAEiBkGTgICAeEcEQCACIAIpAtQBNwK4AiACIAU2ArQCIAIgBDYCsAIgAiAGNgKsAiAAIAJBrAJqEKYlDAwLIAIgBTYCbCACIAQ2AmggAkHIAWogAkHoAGoiBEG0yM0AIAMQ6SMgAigC0AEhAyACKALMASEFIAIoAsgBIgZBk4CAgHhHBEAgAiACKQLUATcCzAIgAiADNgLIAiACIAU2AsQCIAIgBjYCwAIgACACQcACahCmJSACKAJoIgAgACgCACIAQQFrNgIAIABBAUcNDCAEELsjDAwLIAIoAmgiBCAEKAIAIgRBAWs2AgAgBEEBRw0KIAJB6ABqELsjDAoLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAoLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAkLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAgLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAcLIAJByAFqIAJBpAJqQbTIzQAgAxDpIyACKALQASEDIAIoAswBIQUgAigCyAEiBEGTgICAeEYNBSACIAIpAtQBNwLkAiACIAM2AuACIAIgBTYC3AIgAiAENgLYAiAAIAJB2AJqEKYlDAYLQci8zQBB3OLNABC4CEUNAyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwFCyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwECyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwDC0EEQTQQoz0ACyACQcgBaiACQaQCakG0yM0AIAMQ6SMgAigC0AEhAyACKALMASEFIAIoAsgBIgRBk4CAgHhGDQAgAiACKQLUATcC+AIgAiADNgL0AiACIAU2AvACIAIgBDYC7AIgACACQewCahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIRMgAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgEzcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIRMgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASATNwPIAiABIAQ2AsQCIAFCADcCpAIgACADNgIIIAAgBTYCBCAAQQg2AgAgAigCpAIiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkGkAmoQuyMLIAJBgANqJAAL53gCN38CfiMAQbABayIJJAAgCUHQAGogARDcOyAJKAJUIQIgCSgCUCAJQdsANgKAASACIAlBgAFqIilBARD0LiEDIAlByABqIAEQ3DsgCSgCTCECIAkoAkghCgJAAkACQAJ/AkACfwJAAkACQAJAAkACQAJAIANFBEAgCUHcAGohCCMAQSBrIgQkACAEIAIgCmoiAjYCECAEIAo2AgwCQAJAAkADQCAEKAIMIgMgBCgCECIFRg0BA0AgAy0AAEElRwRAIAUgA0EBaiIDRw0BDAMLCyAEIANBAWo2AgwgBEEIaiAEQQxqEKoZIAQtAAhFDQALIAQoAgwiDCACIAprIgMgBCgCECIOa2pBA2siBSADTQRAIAQtAAkhIiAEQRRqIQYjAEEQayICJAAgAkEEaiAFQQBBAUEBEKAYIAIoAgghFAJAIAIoAgRBAUcEQCACKAIMIQsgBQRAIAsgCiAF/AoAAAsgBiAFNgIIIAYgCzYCBCAGIBQ2AgAgAkEQaiQADAELIBQgAigCDEGgscwAEP0vAAsgBCgCHCICIAQoAhRGBEAgBkHQt8wAEKkZCyAEKAIYIAJqICI6AAAgBCACQQFqNgIcIwBBIGsiBiQAIAYgDjYCHCAGIAw2AhggBkEQaiAGQRhqEJchIAYtABAEQCAGLQARIRQgBEEUaiILKAIIIQIDQCALKAIAIAJGBEAgCyACIAYoAhwgBigCGGtBAmpBA25BAWoQxigLIAsgAkEBaiIFNgIIIAsoAgQgAmogFDoAACAGQQhqIAZBGGoQlyEgBi0ACSEUIAUhAiAGLQAIDQALCyAGQSBqJAAgBCgCFCICQYCAgIB4Rg0CIAggBCkCGDcCBCAIIAI2AgAMAwsgBSADQcC3zAAQsDsACyACIAprIQMLIAggAzYCCCAIIAo2AgQgCEGAgICAeDYCAAsgBEEgaiQAIAEoAgAhNCAJIAggASAJKAJcIgJBgICAgHhHIjUbKQIENwKEASAJIAIgNCA1GzYCgAEjAEEwayI2JAAgNkEMaiICQZCszAA2AhAgAkHBADoADiACQcEAOwEMIAJB0MvIADYCCCACQcieyAA2AgQgAkGggswANgIAIAJBpI3IADYCICACQZDNxgA2AhwgAkGc1scANgIYIAJBqPnFADYCFCAJQfQAaiEsIwBBIGsiGSQAIBlBADYCDCAZQoCAgIAQNwIEICkoAgQhJCApKAIIIRwgGUEEaiESQQAhBUEAIQsjAEHwCGsiDSQAIA1BADYCACANQQA2AvgHIA1BADYC/AcgDUEANgLgCAJAAkACQCAcRQ0AIBwgJGohAyAkIQQDQAJAIAUgJGoiBi0AACIKQeEAa0H/AXFBGk8EQCAKQS5HDQEgBkEBaiEECyAcIAVBAWoiBUcNAQwCCwsgDUHkCGohEyACIR0gBCEiIwBB0AhrIgckACAHQv////+HgICAkH83A4gBIAdC/////5+FoIBUNwOAASAHQQA6AJMBIA1B/AdqIhhBBGohFCAYQeQAaiElIA1BBGohCiANQfgHaiEaIBwgAyAEayImayEqIAdB1AZqITcgB0HAAmohLiAHQbQBaiEnQQEhBAJAA0AgIiECAkACQANAAkACQAJAICYEQEEAIQUCfwJAA0AgAiAFaiIGLQAAIgNBLkYNASAmIAVBAWoiBUcNAAsgJiEFIAIMAQsgBUF/cyAmaiEmIAZBAWoLISIgA0EuRyEyIARBAXENAQwCC0EBITJBACEmIAIhIkEAIQUgBEEBcUUNASAqIAtBAXFqISoMBQsCQAJAAkAgBUEDTQRAIAUNAQwCCyACLQACQS1HDQAgAi0AA0EtRg0CCyACLQAAQeEAa0H/AXFBGUsNASAFQQFHBEAgBUEBayEEIAJBAWohBgNAIAYtAAAiCEHhAGtB/wFxQRpJIAhBLUZyRSAIQTBrQf8BcUEJS3ENAyAGQQFqIQYgBEEBayIEDQALCyACIAVqQQFrIgRFDQAgBC0AAEEtRg0BC0EBIQQgKiALQQFxaiAFaiEqQQEhCyAiIQIgA0EuRg0DDAULICogC0EBcWohKgwBCyALQQFxRQ0AAn8gGigCACIEQf4BSQRAIAQhAyAKIQhB/QEhBCAaDAELIA0oAgQhAyANKAIIIQggCgshBiADIARGBH8gDRD5HyANKAIIIQggCiEGIA0oAgQFIAMLQQJ0IAhqQS42AgAgBiAGKAIAQQFqNgIACyAaKAIAIiBB/gFPBEAgCigCACEgCwJAAn8CQAJAAkACQAJAAkACQAJ/AkACQCAFBEBBACAFayEGIAIgBWohCEF/IQMCQANAIAIgA2oiEEEBaiwAACIEQQBIDQEgBiADQQFqIgNqQX9HDQALIAVBBE8NAkEBIRAgBSEDQQAMBAsgA0F/Rw0CQQEhFSACIRAgBSERQQEhCwwJCwJ/ICUoAgAiBkEJSQRAIAYhAyAUIQRBCCEGICUMAQsgGCgCBCEDIBgoAgghBCAUCyEFIAMgBkYEfyAYEPofIBgoAgghBCAUIQUgGCgCBAUgAwtBDGwgBGoiA0EANgIIIAMgAjYCBCADQQA2AgAgBSAFKAIAQQFqNgIADAkLQQEhECACKAAAQd+/f3FB2Jy16QJGDQJBACEVIAUhA0EBIQ9BACERDAMLIAUgA2sLIREgBEEfdiEVIARBAE4hDyADDQFBASELDAQLAkAgCEEBayIEBEAgBUEEayIDQdAPSw0BIAQtAABBLUYNAQwECyAFQQRrIgNB0Q9JDQMLDAELIAIhBANAIAdB4ABqIAcpA4ABIAcpA4gBIAQtAAAiBkH/AHEQxyMCQCAHKAJgQQFxRQ0AIAZBwQBrQf8BcUEZTQRAIAZBIHIhBgwBCyATQYACOwEEIBNBADYCAAwNCwJ/IBooAgAiDEH+AUkEQCAMIQggCiEOQf0BIQwgGgwBCyANKAIEIQggDSgCCCEOIAoLIQsgBEEBaiEEIAggDEYEfyANEPkfIA0oAgghDiAKIQsgDSgCBAUgCAtBAnQgDmogBjYCACALIAsoAgBBAWo2AgAgA0EBayIDDQALQQAhCwwCCyATQYACOwEEIBNBADYCAAwKCyAHQQA2AswGIAdBADYC8AJBACELQQAhFSMAQRBrIiEkACAHQfACaiIXQdwDaiIfIQwgFygC3AMiBEE8TwR/IBdBBGohDCAXKAIEBSAECwRAIAxBADYCAAsgB0GUAWohFiACQQRqIgggA2ohKEEAIQQgCCEMAkACQAJAAkACfwNAIAggAyAERg0BGiAEQQFqIQQgDEEBayIMIANqIgYtAABBLUcNAAsgCCEMIAMgBEYNASADIARrIhVBAWoiDCADSw0CIARBAWshAyAGQQFqCyEMIANFDQIgAyAMaiEoCyAXQQRqIQZByAAhG0GAASEOIBUhEQNAIA4hEEEAIBtrIS8gG0EaaiEzQSQhBEEBIQ4gCyEDAkADQAJAAkAgDC0AACIjQTBrQf8BcUEKTwRAICNBwQBrIg9B/wFxQRpJDQIgI0HhAGsiD0H/AXFBGUsNAQwCCyAjQRZrIQ8MAQsgFkEANgIADAYLIA6tIjkgD0H/AXEiDq1+IjpCIIhQRQRAIBZBADYCAAwGCyADIDqnIANqIg9LBEAgFkEANgIADAYLAkAgDkEBQRogBCAvaiAEIDNPGyAEIBtNGyIDTwRAIDlBJCADa61+IjlCIIhQDQEgFkEANgIADAcLAkACQCARQQFqIhEEQEEAISMgDyALa0ECQbwFIAsbbiIDIBFuIANqIgRByANPDQEgBCEODAILQaiexAAQ4isACwNAICNBJGohIyAEQdf8AEsgBEEjbiIOIQQNAAsLIA5BJGxB/P8DcSAOQSZqQf//A3FuIS8gDyARbiILIBBqIg4gEE8NAiAWQQA2AgAMBgsgOachDiAEQSRqIQQgDyEDIAxBAWoiDCAoRw0ACyAWQQA2AgAMBAsgDkGAgMQARiAOQYCwA3NBgIDEAGtBgJC8f0lyRQRAIB8oAgAiAyEbIAYhBCADQTxPBEAgFygCBCEbIBcoAgghBAsgDyALIBFsayEQAn8gGwRAIBtBA3QhAwNAIBAgBCgCACILTQRAIAQgC0EBajYCAAsgBEEIaiEEIANBCGsiAw0ACyAfKAIAIQMLIANBPEkEQCADIQQgBiELQTshAyAfDAELIBcoAgQhBCAXKAIIIQsgBgshDyAjIC9qIRsgAyAERgR/IBcQ+x8gFygCCCELIAYhDyAXKAIEBSAEC0EDdCALaiIDIA42AgQgAyAQNgIAIA8gDygCAEEBajYCACAQQQFqIQsgDEEBaiIMIChHDQEMAwsLIBZBADYCAAwCCyAMIANBuJ7EABCvOwALIB8oAgAiBEE7TQR/IBdBBGoFIBcoAgQhBCAXKAIICyEGICEgIUEPajYCCAJAIARBAkkNACAEQRVPBEAgIUEIaiELIwBBgCBrIgMkAAJAQcCEPSAEIARBwIQ9TxsiDCAEIARBAXZrIg4gDCAOSxsiDEGBBE8EQCADIAwQ3SMgBiAEIAMoAgQgAygCCCIGQQN0aiADKAIAIAZrIARBwQBJIAsQ+QkgA0EEQQgQ4B4MAQsgBiAEIANBgAQgBEHBAEkgCxD5CQsgA0GAIGokAAwBCyAGIAQQ1RYLIAggFWohAyAfKAIAIgRBO00EfyAXQQRqBSAXKAIEIQQgFygCCAshBiAWQgA3AhAgFiAENgIMIBYgBjYCCCAWIAM2AgQgFiAINgIAIBYgBCAVajYCGAsgIUEQaiQAAkACQCAHKAKUAQRAIAdBADYC0AYgB0EANgLACCMAQdAAayIRJAAgEUEgaiAWQRBqKQIANwMAIBFBGGogFkEIaikCADcDACARQShqIBZBGGooAgAiAzYCACARIBYpAgA3AxAgEUEIaiAHQdAGaiIPIAMgESgCJGsQnhggESgCCCARKAIMEIAtIA9B8AFqIQtBOyEEAkACQAJ/IA8oAvABIgNBO00EQCAPQQRqIQ4gCyEGIAMMAQsgD0EEaiEGIA8oAgghDiADIQQgDygCBAsiCCAESQRAIA4gCEECdGohDANAIBFBEGoQnhkiA0GAgMQARg0CIAwgAzYCACAMQQRqIQwgBCAIQQFqIghHDQALIAQhCAsgBiAINgIAIBFByABqIBFBKGooAgA2AgAgEUFAayARQSBqKQMANwMAIBFBOGogEUEYaikDADcDACARIBEpAxA3AzAgEUEwahCeGSIEQYCAxABGDQEgD0EEaiEDA0ACfyALKAIAIg5BPEkEQCAOIQwgAyEGQTshDiALDAELIA8oAgQhDCAPKAIIIQYgAwshCCAMIA5GBH8gDxD4HyAPKAIIIQYgAyEIIA8oAgQFIAwLQQJ0IAZqIAQ2AgAgCCAIKAIAQQFqNgIAIBFBMGoQnhkiBEGAgMQARw0ACwwBCyAGIAg2AgALIBFB0ABqJAACQCAdIA0gICAHKALACCIGQTxPBH8gBygC1AYhBiAHKALYBgUgNwsgBiAHQZMBahCnAw0AIAdB+ABqIA0gIEG8/cUAENYkIB0gBygCeCAHKAJ8QQFBARCxCw0AIAcoAsAIIgNBPEkNAyAHIAcpAtQGQiCJNwK0ASAHIAM2ArABIAdBsAFqQQRBBBDgHgwDCyATQYACOwEEIBNBADYCACAHKALACCICQTxJDQEgByAHKQLUBkIgiTcCtAEgByACNgKwASAHQbABakEEQQQQ4B4MAQsgE0GAAjsBBCATQQA2AgALIAcoAswGIgJBPEkNCiAHIAcpAvQCQiCJNwLUBiAHIAI2AtAGIAdB0AZqQQRBCBDgHgwKCyAHKALMBiIDQTxPBEAgByAHKQL0AkIgiTcC1AYgByADNgLQBiAHQdAGakEEQQgQ4B4LAn8gJSgCACIEQQlJBEAgBCEDIBQhCEEIIQQgJQwBCyAYKAIEIQMgGCgCCCEIIBQLIQYgAyAERgR/IBgQ+h8gGCgCCCEIIBQhBiAYKAIEBSADC0EMbCAIaiIDIAU2AgggAyACNgIEQQEhCyADQQE2AgAgBiAGKAIAQQFqNgIAQQAMAwsgDw0FCwJ/ICUoAgAiBkEJSQRAIAYhAyAUIQJBCCEGICUMAQsgGCgCBCEDIBgoAgghAiAUCyEFIAMgBkYEfyAYEPofIBgoAgghAiAUIQUgGCgCBAUgAwtBDGwgAmpBAjYCACAFIAUoAgBBAWo2AgAgB0HwAmohBSAdKAIAIQwgHSgCBCEEIB0oAgghAyAdLQAOIQ5BACEGQQAhCCMAQZABayICJAAgBCgCECEPIAQoAgwhFyAEKAIEIRYgBCgCACEbAn8gA0UEQEEBIQRBAQwBCyADKAIQIQYgAygCDCEEIAMoAgQhCCADKAIACyEDIAIgETYCXCACIBA2AlggAkEANgKEASACQQA2AkwgAkEANgIEIAJBAToAjAEgAiAGNgKAASACIAQ2AnwgAiAINgJ4IAIgAzYCdCACIA82AnAgAiAXNgJsIAIgFjYCaCACIBs2AmQgAiAMNgJgIAJC//8DNwJQIAIgDjYCiAEgAkEEaiIDKAJIIgRBEU0EfyADQQRqBSADKAIEIQQgAygCCAshBgJAIAQgAygCgAEiCEsEQCAGIAhBAnRqEN07IAMgAygCgAFBAWoiBDYCgAEgAygCSCIGQRJPBH8gAygCBAUgBgsgBEcNASADEKYpIANBADYCgAEMAQsgAygCTCEEIANBgIDEADYCTCAEQYCAxABGDQAgAyAEIAMoAlAQ1QcaCyAFIANBjAH8CgAAIAJBkAFqJAAgBUGQAWogHSgCEBDkICAFQYCAxAA2AowBIAUgHS8BDDYCnAEgB0GwAWogBUGgAfwKAAAgByAHQYABajYC0AIDQAJAQQAhBEEAIQZBACEFAkACQAJAAkACQAJAAkACQAJAIAcoArwCQYCAxABHDQAgJyEFAkAgBygC+AEiAkESTwR/IAcoArgBIQUgBygCtAEFIAILIAcoArACIgJNDQAgB0HQAGogBSACQQJ0ahCkLyAHKAJQIgVBgIDEAEYNACAHLQBUIAcgBygCsAJBAWoiAzYCsAIgBygC+AEiBkESTwR/IAcoArQBBSAGCyADRgRAIAdBsAFqEKYpIAdBADYCsAILDQIgByAFNgK8AkEAIQZBACEFDAELIAcoAvwBIQVBgIDEACEGIAdBgIDEADYC/AEgBUGAgMQARg0CIAcoAswCIAVNQQAgBygCgAIiBkGAgICABHEbDQAgB0HIAGogB0GwAWoQhQogBygCSCICQYCAxABGDQEgBygCTCEDIAcoAswCIAJNBEAgByACNgL8ASAHIAM2AoACIANBAEgNAQwCCyAHIAM2AoACIAcgAjYC/AEMAQtBACECAn8DQCAHKAK8AiEDIAdBgIDEADYCvAICQCADQYCAxABHDQAgB0GwAWogBSAGENUHIQUgAkEBcUUEQCAFIQMMAQsgB0HwAmogLhCmMAJAIAVB4SJrIgJBngFNBEAgAkEVTwRAIAVBqCNrQRtPDQIgBEGA2AJrIgJBHHAgAkGj1wBLcg0CIAQgBWpBpyNrIQMMAwsgBEGAImsiA0ETTw0BIANBzARsIAJBHGxqQYDYAmohAwwCCyAHQfACaiAEIAUQjiMiA0GAgMQARw0BCyAHIAU2ArwCIAQMAgsCQANAICchBgJAAkAgBygC+AEiAkESTwR/IAcoArgBIQYgBygCtAEFIAILIAcoArACIgJLBEAgB0FAayAGIAJBAnRqEKQvIAcoAkAiBUGAgMQARw0BCyAHQbABahCmKSAHQQA2ArACDAELIActAEQhAiAHQfACaiAuEKYwAkACQCAFQeEiayIEQZ4BTQRAIARBFU8EQCAFQagja0EbTw0CIANBgNgCayIEQRxwIARBo9cAS3INAiADIAVqQacjayEFDAMLIANBgCJrIgVBE08NASAFQcwEbCAEQRxsakGA2AJqIQUMAgsgB0HwAmogAyAFEI4jIgVBgIDEAEcNAQsgB0HwAmoiBSAHQbABaiAHKAKwAhCVFyAFEOUUIAdBADYCsAIgAkH/AXFFDQNBASEFA0AgJyEEIAcoAvgBIgZBEk8EfyAHKAK4ASEEIAcoArQBBSAGCyAFTQ0CIAdBOGogBCAFQQJ0ahCkLyAHKAI4IgRBgIDEAEYNAiAHLQA8IggiBkUNBAJAAkAgAkH/AXEgBkYEQCACIQgMAQsgB0HwAmoiBiAuEKYwIAYgAyAEEI4jIgRBgIDEAEcNAQsgBUEBaiEFIAghAgwBCyAHQbABaiAFENkaIAQhAwwACwALIAcgBygCsAJBAWo2ArACIAUhAwwBCwsgBygC+AEiAkESTwR/IAcoArQBBSACCw0AIAcoAvwBIgVBgIDEAEYNACAFIAcoAswCSQ0AIAcoAoACIgZBAE4NACAHQYCAxAA2AvwBQQEhAiADIQQMAQsLIAMLIQVBgIDEACEGIAVBgIDEAEYNAQsgBUH/AE0EQCAHQSBqIAcoAtACIgIpAwAgAikDCCAFEMcjIAcoAiBBAXENAgsgBUGAgMQARgRAIAUhBgwBCyAFQf3/A0YNASAFIQYgBUEuRw0DCyAHQRhqIA0gIEGs/MUAENYkIAcoAhxBBEkNBEG8/MUAIAcoAhhBEBCZJw0EIAdBEGogDSAgQQRqIgRBzPzFABDWJCAHLQCTASECIAcoAhQiBUUNAyAHKAIQIQMgBUECdCEFA0AgAygCAEGAAU8NAiADQQRqIQMgBUEEayIFDQALDAMLIBNBgAI7AQQgE0EANgIADAkLIBNBgAI7AQQgE0EANgIADAgLAn8gGigCACICQf4BSQRAIAIhBiAKIQRB/QEhAiAaDAELIA0oAgQhBiANKAIIIQQgCgshAyACIAZGBEAgDRD5HyANKAIEIQYgDSgCCCEEIAohAwsgBCAGQQJ0aiAFNgIADAILIAcgAjoAkwEgGigCACIDIQUgCiECIANB/gFJIghFBEAgDSgCBCEFIA0oAgghAgsCQAJAAkACQAJAIAVFDQAgAiAFQQJ0akEEayICRQ0AIAIoAgBBLUcNAQwCC0Gh+8UAQShBnP3FABCfKQALIAgEfyADBSAKKAIACyAga0HVD2tBr3BJDQEgB0EANgLMBiAHQQA2AvACIAdBCGogDSAEQez8xQAQ1iQgBygCCCELIAcoAgwhCEEAIQRBACEMIwBBEGsiKCQAIAdB8AJqIhVB3ANqIiEhAiAVKALcAyIDQTxPBH8gFUEEaiECIBUoAgQFIAMLBEAgAkEANgIACyAHQdQCaiEQIAsgCEECdCIFaiEXQQAhAgJAAkACQAJAAkACQAJ/A0AgCyAFRQ0BGiACQQFqIQIgBUEEayIFIAtqIgMoAgBBLUcNAAsgCyEPIAIgCEYNASAIIAJrIgxBAWoiBSAISw0CIAJBAWshCCADQQRqCyEPIAhFDQQgDyAIQQJ0aiEXCyAVQQRqIQNByAAhFkGAASEfIAwhEQNAIA8oAgAiAkHhAGshBSACQTBrQQpJIghFIAVBGUtxDQIgAkEWayAFIAgbIRtBACAWayEjIA9BBGohDyAWQRpqIS9BJCEFQQEhCCAEIQICQANAIAitIjkgG61+IjpCIIhQRQRAIBBBADYCAAwICyACIDqnIAJqIg5LBEAgEEEANgIADAgLAkBBAUEaIAUgI2ogBSAvTxsgBSAWTRsiAiAbTQRAIDlBJCACa61+IjlCIIhQDQEgEEEANgIADAkLAkACQCARQQFqIhEEQEEAIRsgDiAEa0ECQbwFIAQbbiICIBFuIAJqIgVByANPDQEgBSEIDAILQaiexAAQ4isACwNAIBtBJGohGyAFQdf8AEsgBUEjbiIIIQUNAAsLIAhBJGxB/P8DcSAIQSZqQf//A3FuISMgHyAOIBFuIgQgH2oiH00NAiAQQQA2AgAMCAsgDyAXRwRAIDmnIQggDygCACICQRZrIAJB4QBrIjMgAkEwa0EKSSI4GyEbIA9BBGohDyAFQSRqIQUgDiECIDgNASAzQRlLDQUMAQsLIBBBADYCAAwGCyAfQYCAxABGIB9BgLADc0GAgMQAa0GAkLx/SXINAyAhKAIAIgIhFiADIQUgAkE8TwRAIBUoAgQhFiAVKAIIIQULIA4gBCARbGshDgJ/IBYEQCAWQQN0IQIDQCAOIAUoAgAiBE0EQCAFIARBAWo2AgALIAVBCGohBSACQQhrIgINAAsgISgCACECCyACQTxJBEAgAiEFIAMhBEE7IQIgIQwBCyAVKAIEIQUgFSgCCCEEIAMLIQggGyAjaiEWIAIgBUYEfyAVEPsfIBUoAgghBCADIQggFSgCBAUgBQtBA3QgBGoiAiAfNgIEIAIgDjYCACAIIAgoAgBBAWo2AgAgDkEBaiEEIA8gF0cNAAsMAwsgBSAIQbiexAAQrzsACyAQQQA2AgAMAgsgEEEANgIADAELICEoAgAiBUE7TQR/IBVBBGoFIBUoAgQhBSAVKAIICyEDICggKEEPajYCCAJAIAVBAkkNACAFQRVPBEAgKEEIaiEEIwBBgCBrIgIkAAJAQcCEPSAFIAVBwIQ9TxsiCCAFIAVBAXZrIg4gCCAOSxsiCEGBBE8EQCACIAgQ3SMgAyAFIAIoAgQgAigCCCIDQQN0aiACKAIAIANrIAVBwQBJIAQQ+AkgAkEEQQgQ4B4MAQsgAyAFIAJBgAQgBUHBAEkgBBD4CQsgAkGAIGokAAwBCyADIAUQ1RYLIAsgDEECdGohAiAhKAIAIgVBO00EfyAVQQRqBSAVKAIEIQUgFSgCCAshAyAQQgA3AhAgECAFNgIMIBAgAzYCCCAQIAI2AgQgECALNgIAIBAgBSAMajYCGAsgKEEQaiQAIAcoAtQCIiEEQCAHQQA2AtAGIAdBADYCwAgjAEEQayIVJAAgECgCECEXIBAoAgwhGyAQKAIIIR8gECgCBCEWIBAoAgAhAyAVQQhqIAdB0AZqIg8gECgCGCAQKAIUIhBrEJ4YIBUoAgggFSgCDBCALSAPQfABaiEMQTshBQJAAkACQAJ/IA8oAvABIgJBO00EQCAPQQRqIQggDCEOIAIMAQsgD0EEaiEOIA8oAgghCCACIQUgDygCBAsiCyAFSQRAIAggC0ECdGohESAFIBBqIAtrA0ACQAJAAkAgFyAbSQRAIBAgHyAXQQN0aiICKAIARg0CIAMgFkcNAQNADAALAAsgAyAWRg0FCyADIQggA0EEaiICIQMMAQsgAkEEaiEIIBdBAWohFyADIQILIBEgCCgCADYCACARQQRqIREgEEEBaiEQIAUgC0EBaiILRw0ACyAFIQshECACIQMLIA4gCzYCACAPQQRqIQQMAQsgDiALNgIADAELA0ACQAJAIBcgG0kEQCAfIBdBA3RqIgUoAgAgEEcEQCADIBZHDQIDQAwACwALIBdBAWohFyADIQIgBUEEaiEDDAILIAMgFkYNAwsgA0EEaiECCwJ/IAwoAgAiCEE8SQRAIAghESAEIQVBOyEIIAwMAQsgDygCBCERIA8oAgghBSAECyELIAMoAgAhAyAIIBFGBEAgDxD4HyAPKAIEIREgBCELIA8oAgghBQsgBSARQQJ0aiADNgIAIAsgCygCAEEBajYCACAQQQFqIRAgAiEDDAALAAsgFUEQaiQAIBoiAigCACIDQf4BTwR/IAoiAigCAAUgAwsgIEsEQCACICA2AgALIB0gDSAgIAcoAsAIIgJBPE8EfyAHKALUBiECIAcoAtgGBSA3CyACIAdBkwFqEKcDRQRAIAcoAsAIIgJBPE8EQCAHIAcpAtQGQiCJNwLICCAHIAI2AsQIIAdBxAhqQQRBBBDgHgsgBygCzAYiAkE8TwRAIAcgBykC9AJCIIk3AtQGIAcgAjYC0AYgB0HQBmpBBEEIEOAeCyAhQQBHIhUhCwwFCyATQYACOwEEIBNBADYCACAHKALACCICQTxJDQMgByAHKQLUBkIgiTcCyAggByACNgLECCAHQcQIakEEQQQQ4B4MAwsgE0GAAjsBBCATQQA2AgAMAgsgE0GAAjsBBCATQQA2AgAMCAsgE0GAAjsBBCATQQA2AgAMBwsgBygCzAYiAkE8SQ0GIAcgBykC9AJCIIk3AtQGIAcgAjYC0AYgB0HQBmpBBEEIEOAeDAYLIAcgDSAgQYz9xQAQ1iQCfwJAIB0gBygCACAHKAIEIAtBAXEgFRCxC0UEQCAGQYCAxABGDQQgGigCACIGQf4BTw0BIAYhAyAKIQJB/QEhBiAaDAILIBNBgAI7AQQgE0EANgIADAcLIA0oAgQhAyANKAIIIQIgCgshBSADIAZGBH8gDRD5HyANKAIIIQIgCiEFIA0oAgQFIAMLQQJ0IAJqQS42AgAgBSAFKAIAQQFqNgIAIBooAgAiIEH+AU8EQCAKKAIAISALAn8gJSgCACIGQQlJBEAgBiEFIBQhAkEIIQYgJQwBCyAYKAIEIQUgGCgCCCECIBQLIQMgBSAGRgR/IBgQ+h8gGCgCCCECIBQhAyAYKAIEBSAFC0EMbCACakECNgIAQQEhFUEBIQsLIAMgAygCAEEBajYCAAwBCwsgB0GwAWoQxCggLhDaKQtBASELQQALIQQgIiECIDJFDQEMAwsLIAdBsAFqEMQoIC4Q2ikMAwsCfyAlKAIAIgRBCE0EQCAEIQMgFCELQQghBCAlDAELIBgoAgQhAyAYKAIIIQsgFAshBkECQQAgBy0AkwEiCBshDCAwIAUgCBshMCAxIAIgCBshMSADIARGBH8gGBD6HyAYKAIIIQsgFCEGIBgoAgQFIAMLQQxsIAtqIgIgMDYCCCACIDE2AgQgAiAMNgIAQQEhCyAGIAYoAgBBAWo2AgBBACEEIDJFDQELCyAKIQVBACECIBooAgAiA0H+AU8EQCANKAIIIQUgDSgCBCEDCwJAIANFDQAgA0ECdCEGIB0oAhwhCANAAkAgBSgCACIDQZALSSADQYASa0Gd5ANJciADQYDgB2tBgKAISSADQYD+A2tBgBJJcnIgA0GAoARrQYCwA0lyRQRAIAggAxDrGRCxPUGiwABxDQELIAVBBGohBSAGQQRrIgYNAQwCCwsgGigCACILQf4BTwRAIA0oAgQhCyANKAIIIQoLIActAJMBIQwCQCALRQ0AIAogC0ECdGohAgNAIAshBEEBIQUgCiIGIQMCQAJAA0AgAygCACIOQS5GIiINASAFQQFqIQVBBCEKIANBBGoiAyACRw0AC0EAIQsMAQsgBCAFayELIANBBGohCiAFQQFrIQQLAkACQAJAAkAgBEUNACAIIAYoAgAQ6xkiAxCxPUGDwABxRQRAIBNBgAI7AQQgE0EANgIADAgLIARBAnQhBQNAIAUhAiAEQQFrIgRFDQEgAkEEayEFIAggAiAGakEEaygCABDrGSIRQf8BcSIUQRFGDQALAkACQCARELE9QabAAEEFIANB/wFxIgMbcQRAIANFDQEgBUEERg0FQQAhBEEIIQUDQAJ/AkACQAJAAkAgCCAFIAZqQQRrKAIAEOsZIgMQsT1B/sgYcQRAIARB/wFxQQFrDgICAwELIBNBgAI7AQQgE0EANgIADBALIANB/wFxIgNBAkYNAiADQQVGQQF0DAMLIANB/wFxQQVHDQEgE0GAAjsBBCATQQA2AgAMDgtBAiADQf8BcUECRw0BGiATQYACOwEEIBNBADYCAAwNC0EBCyEEIAIgBUEEaiIFRw0ACwJAIARB/wFxQQFrDgIAAwQLIBRBBUcNAwwECyATQYACOwEEIBNBADYCAAwJCyAFQQRGDQFBCCEFA0AgCCAFIAZqQQRrKAIAEOsZELE9Qd2IGHEEQCAFQQRqIgUgAkcNAQwDCwsgE0GAAjsBBCATQQA2AgAMCAsgFEECRg0BCyAOQS5HDQQMAgsgE0GAAjsBBCATQQA2AgAMBQsgIkUNAgsgCiALQQJ0aiECIAsNAAsLIAcgDDoAkwFBASECCyATIActAJMBOgAFIBMgAjoABCATICo2AgALIAdB0AhqJAAgDSgC5AgiCCAcRg0CIA0tAOkIIi1BAXEEQEEBIS0MAwsCQAJ/IA0oAvgHIhRB/QFNBEAgDUEEaiEKIBQMAQsgDSgCCCEKIA0oAgQLIgIEQCAKIAJBAWsiBUECdGooAgBBLkYNAQsgFEH9AU0EQCANQQRqIQogFCEFDAELIA0oAgQhBSANKAIIIQoLIAVBAnQhBSAKQQRrIQIDQCAFBEAgAiAFaiAFQQRrIQUoAgBBLkcNAQsLIA0oAuAIIgVBCE0EfyANQYAIagUgDSgCgAghBSANKAKECAshECAFQQxsIBRB/QFNBH8gDUEEagUgDSgCBCEUIA0oAggLIQsgEGohEwNAIAshBUEAIQJBASEmAn9BACAURQ0AGiAUQQJ0IQJBACEKQQEhBgJAA0AgBSAKaiIDKAIAQS5GDQEgBkEBaiEGIAIgCkEEaiIKRw0ACyAFIQsgFCICDAELIAZBAWshAiADQQRqIQtBACEmIBQgBmsLIRQCQAJAIBAgE0cEQCAQKAIIIQQgECgCBCEDIBAoAgAhDCArRQ0CIB4NASAIQQFqIgggHEYNBAwCC0Hc+8UAELI7AAsgEigCCCEGIBJBARDYLSASKAIEIBIoAghqQS46AAAgEiAGQQFqNgIICwJAAkACQAJAAkACQAJAAkACQCAMRQRAIAQEQEEAIQYgBCEKA0AgAyAGaiIFLQAAQcEAa0H/AXFBGkkNAyAKQQFrIQogBCAGQQFqIgZHDQALCyAeDQJBACEeIAQgCGoiCCAcRw0JDAwLIAJBAnQhCiAFIQYDQCAKRQ0DIApBBGshCiAGKAIAIAZBBGohBkGAAUkNAAsMBAsCQCAeBEAgBiEEIAghAgwBCyAkIQMgBiAIaiIEIQIgBCAcSw0DCyASIAMgAyAEahCBJiASKAIIIQMDQCASQQFBAiAFLAAAIgRBAE4iCBsiDBDYLSAEIARBwQBrQf8BcUEaSUEFdHIhBiAFQQFqIQUgEigCBCASKAIIaiIOIAgEfyAGBSAOIAZBvwFxOgABIARBwAFxQQZ2QUByCzoAACASIAMgDGoiAzYCCCAKQQFrIgoNAAtBASEeIAIhCAwHCyASIAMgAyAEahCBJgwDCwJAIB5FBEAgCCAcSw0BIBIgJCAIICRqEIEmCyACRQ0DIAJBAnQhAiASKAIIIQMDQCASAn9BASAFKAIAIgRBgAFJIgoNABpBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiDBDYLSASKAIEIBIoAghqIQYCQAJAIApFBEAgBEGAEEkNASAEQYCABE8EQCAGIARBP3FBgAFyOgADIAYgBEESdkHwAXI6AAAgBiAEQQZ2QT9xQYABcjoAAiAGIARBDHZBP3FBgAFyOgABDAMLIAYgBEE/cUGAAXI6AAIgBiAEQQx2QeABcjoAACAGIARBBnZBP3FBgAFyOgABDAILIAYgBDoAAAwBCyAGIARBP3FBgAFyOgABIAYgBEEGdkHAAXI6AAALIAVBBGohBSASIAMgDGoiAzYCCCACQQRrIgINAAsMAwsgCCAcQZz8xQAQsDsACyAGIAhqIBxB7PvFABCwOwALIAxBAUYEQAJAAkAgBARAQQAhBiAEIQoDQCADIAZqIgUtAABBwQBrQf8BcUEaSQ0CIApBAWshCiAEIAZBAWoiBkcNAAsLIB4NAUEAIR4gBCAIaiIIIBxGDQkMBgsCQCAeBEAgBiEEIAghAgwBCyAkIQMgBiAIaiIEIQIgBCAcSw0ECyASIAMgAyAEahCBJiASKAIIIQMDQCASQQFBAiAFLAAAIgRBAE4iCBsiDBDYLSAEIARBwQBrQf8BcUEaSUEFdHIhBiAFQQFqIQUgEigCBCASKAIIaiIOIAgEfyAGBSAOIAZBvwFxOgABIARBwAFxQQZ2QUByCzoAACASIAMgDGoiAzYCCCAKQQFrIgoNAAtBASEeIAIhCAwFCyASIAMgAyAEahCBJgwBCyAeRQRAIAggHEsNAyASICQgCCAkahCBJgsgEkGw+sUAQbT6xQAQgSZBACEEQQAhDEEAIQ4CQAJAIAUgAkECdGoiHSAFRg0AQQEhCiAFIQYDQCAKQQJGDQIgBigCACICQf8ATQRAIBIoAgghAyASQQEQ2C0gEigCBCASKAIIaiACOgAAIBIgA0EBajYCCCAOQQFqIQ4LIApBAWshCiAGQQRqIgYgHUcNAAtBACAKayIHQY0eSw0BAkAgDkUEQEEAIQ4MAQsgEigCCCECIBJBARDYLSASKAIEIBIoAghqQS06AAAgEiACQQFqNgIICyAHIA5JDQAgBUEEaiEiIB0gBWtBBGshEUHIACEaQYABIRUgDiEEAkADQCAiIQIgESEDIAUhCgNAIAMhJyACIQYgCiAdRg0CIAJBBGohAiADQQRrIQMgCigCACEPIApBBGohCiAPIBVJDQALIAogHUcEQCAnQQJ2IQIDQCAPIAYoAgAiAyAPIAMgD0kbIAMgFUkbIQ8gBkEEaiEGIAJBAWsiAg0ACwsgBEEBaiAPIBVrbCAMaiEMIAUhKwJAA0AgDCArKAIAIgIgD0lqIQwgAiAPRgRAAkBBAUEaQSQgGmsgGkEaaiInQSRNGyAaQSRPGyIKIAwiAksNAEEAIBprIRVByAAhBgJAA0AgCkEkRwRAIAIgCmsiAiACQSQgCmsiA24iAiADbGsgCmoiA0EaSQR/QeEABSADQSRPDQNBFgshCiASKAIIIRggEkEBQQIgAyAKaiIDQYABSSIKGyIXENgtIBIoAgQgEigCCGoiFiAKBH8gAwUgFiADQT9xQYABcjoAAUHCAQs6AAAgEiAXIBhqNgIIIAYgJ0khAyAGIBVqIQogBiAaSyEYIAZBJGohBiACIApBGiADG0EBIBgbIgpPDQEMAwsLQdiexAAQ5ysAC0HonsQAQQ5B+J7EABCfKQALIAJBGkkEf0HhAAUgAkEkTw0DQRYLIQMgEigCCCEGIBJBAUECIAIgA2oiAkGAAUkiAxsiChDYLSASKAIEIBIoAghqIicgAwR/IAIFICcgAkE/cUGAAXI6AAFBwgELOgAAIBIgBiAKajYCCAJAAkAgBEEBaiICBEAgDEG8BUECIAQgDkYbbiEDQQAhDCADIAMgAm5qIgpByANPDQFBACEGIAohAwwCC0GonsQAEOIrAAtBACEGA0AgBkEkaiEGIApB1/wASyAKQSNuIgMhCg0ACwsgBiADQSRsQfz/A3EgA0EmakH//wNxbmohGiACIQQLICtBBGoiKyAdRw0ACyAPQQFqIRUgDEEBaiEMIAQgB0sNAwwBCwtB6J7EAEEOQfiexAAQnykAC0HInsQAELI7AAtBAiEECyAEQf8BcUECRwRAIwBBIGsiACQAIABBATYCBCAAQYj6xQA2AgAgAEIBNwIMIABCiPvFgKAmNwMYIAAgAEEYajYCCCAAQZD7xQAQ7ywACwtBASEeDAILIAYgCGogHEH8+8UAELA7AAsgCCAcQYz8xQAQsDsACyAQQQxqIRBBASErICZFDQALIC1Bf3NBAXEhHgwCC0EAIR4LQQAhLQsgDSgC4AgiAkEJTwRAIA0gDSkCgAhCIIk3AugIIA0gAjYC5AggDUHkCGpBBEEMEOAeCyANKAL4ByICQf4BTwRAIA0gDSkCBEIgiTcCgAggDSACNgL8ByANQfwHakEEQQQQ4B4LIBkgHjoAASAZIC1BAXE6AAAgDUHwCGokACAZLQABIQICQAJ/AkAgGS0AAARAIAJBAXFFDQFBofvFAEEoQcz7xQAQnykACwJAIAJBAXEEQCAZQRhqIgIgGUEMaigCADYCACAZIBkpAgQ3AxAgLCAZKQMQNwIAICxBCGogAigCADYCAAwBCwJAICkoAgAiAkGAgICAeEcEQCAZQRhqIClBCGooAgA2AgAgGSApKQIANwMQDAELIBkgHDYCGCAZICQ2AhQgGUGAgICAeDYCEAsgLCAZKQMQNwIAICxBCGogGUEYaigCADYCACACQYCAgIB4RwwCC0EAIQUMAgsgLEGBgICAeDYCAEEACyEFIBlBBGoQ3jsLAkAgBQ0AICkoAgBBgICAgHhGDQAgKRDeOwsgGUEgaiQAIDZBMGokACA1IDRBgICAgHhGciELIAkoAnQiAkGBgICAeEcNASAAQYMCOwEADAkLIAlB3QA2AoABIAIEQCAJQYABakEBIAIgCmpBAWtBARDBLg0CCyAAQYMIOwEAQQAMCQsgCSAJKQJ4NwJsIAkgAjYCaCAJQUBrIAlB6ABqIgIQ3DtBACAJKAJERQ0GGiAJQThqIAIQ3DsgCSgCOCEDIAkoAjwhAiAJQQE7AaQBIAkgAjYCoAEgCUEANgKcASAJQQE6AJgBIAlBLjYClAEgCSACNgKQASAJQQA2AowBIAkgAjYCiAEgCSADNgKEASAJQS42AoABIAlBMGogCUGAAWoiAhD8DSAJKAIwIgVFDQECQAJAAkACQCAJKAI0IgMNACAJQShqIAIQ/A0gCSgCKCIFRQ0CIAkoAiwiAw0AQQAhAwwBC0EAIQIDQCACIANGDQMgAiAFaiACQQFqIQItAABBMGtB/wFxQQpJDQALCyAJQSBqIAUgAxDjCCAJKAIgQQJHDQELIAlBiwFqIAlB8ABqKAIANgAAIABBADoAACAJIAkpAmg3AIMBIAAgCSkAgAE3AAEgAEEIaiAJQYcBaikAADcAAAwKCyAJQRhqIAlB6ABqENw7IAkoAhghAyAJKAIcIQIgCUEBOwGkASAJIAI2AqABIAlBADYCnAEgCUEBOgCYASAJQS42ApQBIAkgAjYCkAEgCUEANgKMASAJIAI2AogBIAkgAzYChAEgCUEuNgKAASAJQfQAaiEGIwBBQGoiAiQAIAIgCUGAAWoiBBDkCwJAAkACQCACKAIAIggEQCACKAIEIRQgAkEYaiIKQQRBAEEEQQgQoBggAigCHCEDIAIoAhhBAUYNAiACKAIgIgUgFDYCBCAFIAg2AgAgAkEUaiIMQQE2AgAgAiAFNgIQIAIgAzYCDCAKIARBKPwKAAAjAEEQayIFJAAgBUEIaiAKEOQLIAUoAggiFARAIAJBDGohBCAFKAIMIQMDQCAEKAIIIgggBCgCAEYEQCAEIAhBAUEEQQgQxSgLIAQoAgQgCEEDdGoiDiADNgIEIA4gFDYCACAEIAhBAWo2AgggBSAKEOQLIAUoAgQhAyAFKAIAIhQNAAsLIAVBEGokACAGQQhqIAwoAgA2AgAgBiACKQIMNwIADAELIAZBADYCCCAGQoCAgIDAADcCAAsgAkFAayQADAELIAMgAigCIEHwl8QAEP0vAAsgCSgCeCEDAkAgCSgCfCICRQ0AIAMgAkEDdGoiBUEIayIERQ0AIAQoAgAgBUEEaygCAEEBQQAQwS5FDQAgCSACQQFrIgI2AnwLIAJBBE0EQCAJQQA2AogBIAlCgICAgMAANwKAASAJKAJ0IQUCQCACBEAgAyACQQN0aiEGIAMhAgNAIAlBEGogAigCACACQQRqKAIAEOMIIAkoAhAiBEECRiAEQQFxRXINAiAJKAIUIQogCSgCiAEiBCAJKAKAAUYEQCAJQYABakG8mcQAEJcoCyAJKAKEASAEQQJ0aiAKNgIAIAkgBEEBajYCiAEgAkEIaiICIAZHDQALCyAJIAM2AqwBIAkgBTYCqAEgCUGoAWpBBEEIEOAeIAkoAogBIgZFDQQgCSAGQQFrIgo2AogBIAkoAoQBIgMgCkECdGooAgAiBEF/IApBA3R2Sw0GIAZBAnRBBGshAiADIQUDQCACRQRAIAoEQCAGQQJ0QQRrIQVBGCECA0AgAygCACACQRhxdCAEaiEEIAJBCGshAiADQQRqIQMgBUEEayIFDQALCyAJQYABakEEQQQQ4B4gAEEBOgAAIAAgBEEYdCAEQYD+A3FBCHRyIARBCHZBgP4DcSAEQRh2cnI2AAEgCUHoAGoQhjAMDQsgAkEEayECIAUoAgAgBUEEaiEFQf8BTQ0ACwwGCyAJIAM2AqwBIAkgBTYCqAEgCUGoAWpBBEEIEOAeDAULIAlB9ABqQQRBCBDgHgwFCyAJQQhqIAEQ3DsgCSgCDCECIAkoAgghAyAJIAEQ3DsgCSgCBCIEQQFrIgVFDQICQCACQQFNBEAgAkEBRg0BDAQLIAMsAAFBQEgNAwsCQCACIAVNBEAgAiAFRw0EDAELIAMgBWosAABBv39MDQMLIAlBgAFqIANBAWogBEECaxCxBiAAAn8gCS0AgAFBAUYEQCAAIAktAIEBOgABQQMMAQsgACAJQYEBaiICKQAANwABIABBCWogAkEIaikAADcAAEECCzoAAEEADAcLQdyYxAAQsjsAC0GQmcQAQRtBrJnEABDLJAALIAMgAkEBIAVBkJjEABCjNgALIAlBgAFqQQRBBBDgHgtBAwshAiAAQQM6AAAgACACOgABIAlB6ABqEIYwCyALQQFzCw0CIAEoAgBBgICAgHhGDQIMAQsgCyABKAIAQYCAgIB4R3FFDQELIAEQ3jsLIAlBsAFqJAALwQwCCn8DfiMAQdABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBBHQiCSEGAkAgCUEwcSIFBEAgCSAFa0FAayIGIAlJDQELQcAAIQUgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiBUUNAQsgBEEANgJIIAQgBTYCQCAEIAY2AjwgBEHAADYCOCAJBEAgCQRAIAVBACAJ/AsACyAEKAJIIQ0gBCgCQCEFCyAEIAk2AkQgBCAIIA1qNgJIAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQYDQCAEQfAAaiACIAEpAwAgASkDCCABQRBqKQMAIAFBGGopAwAQoQoCQAJAIAQoAnBBAXFFDQAgBCkDgAEiDiAEKQOIASIPIAkQ/yBFDQAgBSAONwMAIAUgDzcDCAwBCyAEQQhqIARBJGoQhj0gBkEDdiIDIAQoAgwiCk8NAyAEKAIIIANqIgMgAy0AAEF+IAZBB3F3cToAACAHQQFqIQcLIAVBEGohBSABQSBqIQEgCCAGQQFqIgZHDQALDAcLIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBkAFqIQggAy0AACEGIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwO4AQwBCyAEKAKQAUUNASAEQbABaiAIELYqIAQpA7ABIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQwgBEIANwNwIAQpA3gMAQsgBCkDuAELIQ8gDqdBAXFFDQogBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIARBsAFqIAIgCSAQpyAOp2oiAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBChCgJAIAQoArABQQFxRQ0AIAQpA8ABIg4gBCkDyAEiDyAGEP8gRQ0AIAUgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiIDIAQoAhQiCkkEQCAEKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAMgCkGIi/8AEMMhAAtBxIr/ABCyOwALIAMgCkGIi/8AEMMhAAtBwAAgBhCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArgBIAQgBTYCtAEgBCABNgKwASAEQeQAaiIBIARBsAFqEOIZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDLHSAEQThqEM8vIAYQzy8gBEHQAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC7kXAhZ/D34jAEHABWsiBCQAIAQgATYCCCAEIAJBCGoiCCABQQhqIhEQzxAgBCgCBCEMIAQoAgAhDSAEQQE6AA8gBEGQBGogDSAMIARBD2oQxw0CQCAEKAKQBEEIRgRAIAQoApgEIRIgBCgClAQhEyAEQdgBaiEFIwBBkANrIgEkAAJAIAggBEEIaigCAEEIaiIKEOcRRQRAIAFBgICAgHg2AgAMAQsgAUGIAmpB0PLNAEHw8s0AEIU1IgYoAgAgBigCBCgCDBEEABDaASABQYACakGYms8AKQIANwMAIAFCBDcD8AEgAUIANwPoASABQoCAgIAQNwPgASABQZCazwApAgA3A/gBIAEgAUHgAWpByAD8CgAAIAFBADYCWCABQoCAgICAATcDUCABQgA3A0gLIAggChDbEiEGQQEhDiABQQZBACAILQCVAUEBcRsgBkH/AXEiBiAGQQlGGyILOgCHA0KAgICAECEaQYCAgIB4IQ9BgICAgHghBwJAAkACQAJAAkACQAJAAkAgCw4HAgMDAwMAAQMLIAFB4AFqIgcQmShB4ABBCBCtNiIJRQ0FIAkgB0HgAPwKAABBgYCAgHghBwwBCyABQeABaiIHEJkoQeAAQQgQrTYiBkUNBCAGIAdB4AD8CgAAIAcQmShB4ABBCBCtNiIQRQ0EIBAgB0HgAPwKAABCASEaQQAhDkEBIQlBACEHCyABQbwBaiILQQA2AgAgAUHEAWoiFEEANgIAIAFB2AFqIhVBADYCACABQagBaiIWIBA2AgAgASAJNgLAASABQZgBaiIJIAspAgA3AwAgASAGNgLIASABQaABaiIGIBQpAgA3AwAgAUGIAWogFSkDADcDACABIBo3A5ABIAFCADcDgAEgAUH8AGogFigCADYCACABQfQAaiAGKQMANwIAIAFB7ABqIAkpAwA3AgAgASABKQOQATcCZCABIAc2AmACQCAIIAoQ0REiBkUNACABQeABaiAGKQMIIAYrAwAQ0hECQAJAIAEoAuABIglBCGsOAgECAAsgAUHgAGpBBHIhBiABKALkASEKIAEpA+gBIRogASkD8AEhGyAFQQI2ArABIAUgGzcDECAFIBo3AwggBSAKNgIEIAUgCTYCAAJAAkACQCAHQYCAgIB4c0ECIA4bDgIBAgALIAFB4ABqEN47IAFB7ABqEN47IAFB+ABqEN0pIAFB/ABqEN0pDAULIAYQ3jsMBAsgBhDeOyABQfAAahDdKQwDCyABKQPoASEaIAEoAuQBIQ8LIAggChCCEiEGIAFBwAJqIAFB4ABqQTD8CgAAIAFB4AFqIgcgAUHgAPwKAAAgBSAHQZAB/AoAACAFQQA2ApwBIAUgGjcClAEgBSAPNgKQASAFQQA2ArABIAUgBjoAxAEgBSABKQPwAiIaNwOgASAFQagBaiABQfgCaikDACIbNwMAIAUgGjcCtAEgBUG8AWogGzcCAAwCCyABQQI2AuQBIAFB8PXNADYC4AEgAUIBNwLsASABQa4DNgKMAyABIAFBiANqNgLoASABIAFBhwNqNgKIAyABQbwBaiABQeABahCZDiABQZwBaiABQcABaikDACIaNwIAIAFBpAFqIAFByAFqKQMAIhs3AgAgAUEANgK4ASABIAEpA7gBIhw3ApQBIAVBEGogGzcCACAFQQhqIBo3AgAgBSAcNwIAIAVBAjYCsAELIAEoAgBBgICAgHhGDQAgARCCKwsgAUGQA2okAAwBC0EIQeAAEKM9AAsgBCgCiANBAkYNASAEQRBqIAVByAH8CgAAIAggERCCEiEFQQAhASAEQQA2AqwDIARBADYCpAMgBEGkA2pBAhDpHiAEQdgDakEAQTT8CwACfyAFQf8BcSIFRQRAQYCAgIB4IQZBgICAgHghB0GAgICAeCEKQYCAgIB4DAELIARCADcD+AEgBEGAgICAeDYC7AEgBEGAgICAeDYC4AEgBEIANwPYASAEQeABaiEBAkAgBCgCCC4BGiIGQQBMBEAgBEGAgICAeDYCkAQMAQsgBEGQBGogBkEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAEQZgEaigCADYCACABIAQpApAENwIAIARBkARqIARB2AFqQSj8CgAAAkAgBCgCCC4BGCIBQQBMBEAgBEGAgICAeDYC2AEMAQsgBEHYAWogAUEBakH//wNxQaD5zwAQthULIARBpARqEIUwIARBrARqIARB4AFqKAIANgIAIAQgBCkC2AEiGjcCpAQgBCkDkAQhHSAEKAKYBCEGIAQpApwEIR4gBCgCsAQhFyAEKAK0BCEYIAQpA6gEIR8gBEIANwOIAiAEQgA3A/gBIARCADcD6AEgBEIANwPYASAEQZACaiAEQdADakE8/AoAACAEQYCAgIB4NgL8AiAEQYCAgIB4NgLwAiAEQQA2AtwCIARB8AJqIQECQCAEKAIILgEaIgdBAEwEQCAEQYCAgIB4NgKQBAwBCyAEQZAEaiAHQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIARBmARqKAIANgIAIAEgBCkCkAQ3AgAgBEGQBGogBEHYAWpBsAH8CgAAAkAgBCgCCC4BGCIBQQBMBEAgBEGAgICAeDYC2AEMAQsgBEHYAWogAUEBakH//wNxQaD5zwAQthULIARBtAVqEIUwIARBvAVqIARB4AFqKAIANgIAIAQgBCkC2AE3ArQFIAQpA5AEISAgBCkDmAQhISAEKQOgBCEiIAQpA6gEISMgBCkDsAQhJCAEKQO4BCElIAQpA8AEISYgBEHQA2ogBEHIBGpBPPwKAAAgGqchByAEQcgDaiAEQYwFaikCADcDACAEQbgDaiAEQaAFaikDADcDACAEIAQpAoQFNwPAAyAEIAQpA5gFNwOwAyAFQQJGIQEgBCgClAUhGSAEKAKoBSEKIAQpAqwFIScgBCkDuAUhKCAEKAK0BQshCSAIEPUVIQggACAFOgCuBSAAIAI2ApwFIABBuO3PADYCxAQgACADNgLABCAAIBI2AswEIAAgEzYCyAQgACAMNgL8AiAAIA02AvgCIABBqAVqIARBrANqKAIANgIAIAAgBCkCpAM3AqAFIAAgBCgCCDYCmAUgAEGwAWogBEEQakHIAfwKAAAgACAYNgKEBCAAIBc2AoAEIAAgHzcD+AMgACAHNgL0AyAAIB43AuwDIAAgBjYC6AMgACAdNwPgAyAAICY3AzAgACAlNwMoIAAgJDcDICAAICM3AxggACAiNwMQIAAgITcDCCAAICA3AwAgAEE4aiAEQdADakE8/AoAACAAIBk2AoQBIABBADYClAUgAEKAgICAIDcCjAUgAEICNwKEBSAAQgA3AvwEIABCgICAgMAANwL0BCAAICg3A6gBIAAgCTYCpAEgACAnNwKcASAAIAo2ApgBIABB/ABqIARByANqKQMANwIAIAAgBCkDwAM3AnQgACAEKQOwAzcDiAEgAEGQAWogBEG4A2opAwA3AwAgAEGBAjsBrAUgAEGAgICAeDYCtAQgAEIINwKsBCAAQgA3AqQEIABCgICAgMAANwKcBCAAQgg3ApQEIABBgICAgHhBACAIGzYCkAQgAEIANwOIBCAAIAE6ANwDIABBADYC2AMgAEGAgICAeDYCzAMgAEGAgICAeDYCwAMgAEIINwO4AyAAQgA3A7ADIABCgICAgMAANwOoAyAAQgQ3A6ADIABCADcDmAMgAEKAgICAEDcDkAMgAEIANwOIAyAAQoCAgICAATcDgAMgAEEANgLQBCAEQcAFaiQADwsgBEHoAWogBEGgBGopAwA3AwAgBEHgAWogBEGYBGopAwA3AwAgBCAEKQOQBDcD2AFBxO/OAEErIARB2AFqQbTvzgBBqP3OABDVHgALIARBoARqIARB6AFqKQMANwMAIARBmARqIARB4AFqKQMANwMAIAQgBCkD2AE3A5AEQcTvzgBBKyAEQZAEakG0784AQbj9zgAQ1R4AC6kMAgp/BH4jAEHAAWsiBCQAIAFBDGoQ2zwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBA3QiCSEFAkAgCUE4cSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhAyACKQMAIQ4gASgCECEFIARB8ABqQQRyIQlBACEHQQAhAQNAAkACQAJAIA5QBEAgBEKBgICA8ICAgIB/NwNwIAkQiBEMAQsgBTQCACAOfyIPIAMQxSlFDQAgBiAPNwMADAELIARBCGogBEEkahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEIaiEGIAVBBGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBqAFqQQRyIQggBEGQAWohBSADLQAAIQMgAikDACEQIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIRhoU3A5gBIBGnIA6naiEBAkAgEFAEQCAEQoGAgIDwgICAgH83A6gBIAgQiBEMAQsgCSABQQJ0ajQCACAQfyIOIAMQxSlFDQAgBiABQQN0aiAONwMADAELIARBEGogBEEkahCGPSABQQN2IgIgBCgCFCIKSQRAIAQoAhAgAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEHQAGogBEEkaiIGEIIUIARB8ABqIgIQlykgBEFAayIBKAIAIQUgBCgCRCEDIAEgBEH4AGoiCCkCADcDACAEKQM4IQ4gBCAEKQJwNwM4IARBADYCSCAEIA43AnwgBEEANgJ4IAQgAzYCdCAEIAU2AnAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogCCkCADcCACABQRhqIARBgAFqIgkoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDkGSAJIARB4ABqKAIANgIAIAggBEHYAGopAgA3AwAgBCAEKQJQNwNwIAQgBzYChAEgACABIAIQxh0gBEE4ahDPLyAGEM8vIARBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAupDAIKfwR+IwBBwAFrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQRhqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAIcIQwgBCgCGCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCMCAEIAY2AiwgBCAFNgIoIARBwAA2AiQgBEEkaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwIwIAQgBjYCLCAEIAc2AiggBEHAADYCJCAEQSRqIAgQ3hBBACEHCyAIQQN0IgkhBQJAIAlBOHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCSCAEIAY2AkAgBCAFNgI8IARBwAA2AjggCQRAIAkEQCAGQQAgCfwLAAsgBCgCSCENIAQoAkAhBgsgBCAJNgJEIAQgCCANajYCSCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyADLQAAIQMgAikDACEOIAEoAhAhBSAEQfAAakEEciEJQQAhB0EAIQEDQAJAAkACQCAOUARAIARCgYCAgPCAgICAfzcDcCAJEIgRDAELIAUyAQAgDn8iDyADEMUpRQ0AIAYgDzcDAAwBCyAEQQhqIARBJGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBCGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAkgAUEBdGoyAQAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALqwwCCn8DfiMAQdABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBMGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAjQhDCAEKAIwIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJIIAQgBjYCRCAEIAU2AkAgBEHAADYCPCAEQTxqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AkggBCAGNgJEIAQgBzYCQCAEQcAANgI8IARBPGogCBDeEEEAIQcLIAhBAnQiCSEGAkAgCUE8cSIFBEAgCSAFa0FAayIGIAlJDQELQcAAIQUgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiBUUNAQsgBEEANgJgIAQgBTYCWCAEIAY2AlQgBEHAADYCUCAJBEAgCQRAIAVBACAJ/AsACyAEKAJgIQ0gBCgCWCEFCyAEIAk2AlwgBCAIIA1qNgJgAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQYDQCAEQRhqIAIgASkDACABKQMIIAFBEGopAwAgAUEYaikDABC8CQJAAkAgBCgCGEEBcUUNACAEKAIcIgMgCRDEKUUNACAFIAM2AgAMAQsgBEEQaiAEQTxqEIY9IAZBA3YiAyAEKAIUIgpPDQMgBCgCECADaiIDIAMtAABBfiAGQQdxd3E6AAAgB0EBaiEHCyAFQQRqIQUgAUEgaiEBIAggBkEBaiIGRw0ACwwHCyALBEAgBEGIAWogCyAMIAogCBC/FCAEQagBaiEIIAMtAAAhBiABKAIQIQkDQAJAIAQpA7ABIg9QRQRAIAQpA7gBIQ4MAQsDQAJ+AkAgBCkDmAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDmAEgDqdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogCBC2KiAEKQPAASEOCyAOQgBSDQILIARCAzcDmAELIAQpA4gBIg5CAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyEPIA6nQQFxRQ0KIAQgBCkDuAFCQH0iDjcDuAEgBCAPNwOwASAPUA0ACwsgBCAPQgEgD3oiEIaFNwOwASAEQShqIAIgCSAQpyAOp2oiAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBC8CQJAIAQoAihBAXFFDQAgBCgCLCIDIAYQxClFDQAgBSABQQJ0aiADNgIADAELIARBIGogBEE8ahCGPSABQQN2IgMgBCgCJCIKSQRAIAQoAiAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAyAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAGEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB6ABqIARBPGoiBhCCFCAEQYgBaiICEJcpIARB2ABqIgEoAgAhBSAEKAJcIQMgASAEQZABaiIIKQIANwMAIAQpA1AhDiAEIAQpAogBNwNQIARBADYCYCAEIA43ApQBIARBADYCkAEgBCADNgKMASAEIAU2AogBIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGYAWoiCSgCADYCACAEIAM2AsgBIAQgBTYCxAEgBCABNgLAASAEQfwAaiIBIARBwAFqEOUZIAkgBEH4AGooAgA2AgAgCCAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBzYCnAEgACABIAIQyh0gBEHQAGoQzy8gBhDPLyAEQdABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALqQwCCn8EfiMAQcABayIEJAAgAUEMahDZPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIJIQUCQCAJQThxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgBTYCPCAEQcAANgI4IAkEQCAJBEAgBkEAIAn8CwALIAQoAkghDSAEKAJAIQYLIAQgCTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyAFMwEAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGoAWpBBHIhCCAEQZABaiEFIAMtAAAhAyACKQMAIRAgASgCECEJA0ACQCAEKQOYASIPUEUEQCAEKQOgASEODAELA0ACfgJAIAQpA4ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A4ABIA6nQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhDgsgDkIAUg0CCyAEQgM3A4ABCyAEKQNwIg5CAlENBiAEQgA3A3AgBCkDeAwBCyAEKQOwAQshDyAOp0EBcUUNBCAEIAQpA6ABQkB9Ig43A6ABIAQgDzcDmAEgD1ANAAsLIAQgD0IBIA96IhGGhTcDmAEgEacgDqdqIQECQCAQUARAIARCgYCAgPCAgICAfzcDqAEgCBCIEQwBCyAJIAFBAXRqMwEAIBB/Ig4gAxDFKUUNACAGIAFBA3RqIA43AwAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAiAEKAIUIgpJBEAgBCgCECACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOQZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDGHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC6kMAgp/BH4jAEHAAWsiBCQAIAFBDGoQ2zwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBA3QiCSEFAkAgCUE4cSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhAyACKQMAIQ4gASgCECEFIARB8ABqQQRyIQlBACEHQQAhAQNAAkACQAJAIA5QBEAgBEKBgICA8ICAgIB/NwNwIAkQiBEMAQsgBTUCACAOfyIPIAMQxSlFDQAgBiAPNwMADAELIARBCGogBEEkahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEIaiEGIAVBBGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBqAFqQQRyIQggBEGQAWohBSADLQAAIQMgAikDACEQIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIRhoU3A5gBIBGnIA6naiEBAkAgEFAEQCAEQoGAgIDwgICAgH83A6gBIAgQiBEMAQsgCSABQQJ0ajUCACAQfyIOIAMQxSlFDQAgBiABQQN0aiAONwMADAELIARBEGogBEEkahCGPSABQQN2IgIgBCgCFCIKSQRAIAQoAhAgAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEHQAGogBEEkaiIGEIIUIARB8ABqIgIQlykgBEFAayIBKAIAIQUgBCgCRCEDIAEgBEH4AGoiCCkCADcDACAEKQM4IQ4gBCAEKQJwNwM4IARBADYCSCAEIA43AnwgBEEANgJ4IAQgAzYCdCAEIAU2AnAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogCCkCADcCACABQRhqIARBgAFqIgkoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDkGSAJIARB4ABqKAIANgIAIAggBEHYAGopAgA3AwAgBCAEKQJQNwNwIAQgBzYChAEgACABIAIQxh0gBEE4ahDPLyAGEM8vIARBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAuwDgIDfwF+IwBB0AFrIgMkACADQZQBaiABIAIQkw4gAygCmAEhBAJAIAMoApQBIgVBioCAgHhHBEAgA0EsaiADQbQBaigCADYCACADQSRqIANBrAFqKQIANwIAIANBHGogA0GkAWopAgA3AgAgAyADKQKcATcCFCADIAQ2AhAgAyAFNgIMDAELIANBlAFqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBoAFqKQIANwMAIAMgAykCmAE3AzAgAygClAEiBEGKgICAeEcEQCADQShqIANBsAFqKQIANwIAIANBGGogASkDADcCACADIAMpAqgBNwIgIAMgAykDMDcCECADIAQ2AgwMAQsgA0HIAGogASkDADcDACADIAMpAzA3A0AgA0GUAWogA0FAa0EEEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJAIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EJNgLIASADQaLn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAyADKQNINwJYIAMgAykDQDcCUCADQZQBaiADQdAAakEGEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJQIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EFNgLIASADQbTn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAyADKQJYNwJoIAMgAykCUDcCYCADQZQBaiADQeAAakEIEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJgIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EINgLIASADQZHn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAygCYCIBIAEoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0ENNgKkASADQe7o/gA2AqABIANBgICAgHg2ApwBIAMgAjYCmAEgA0ECNgKUASAAIANBDGogA0GUAWoQgRQgA0HQAWokAAumDAIKfwN+IwBBwAFrIgQkACABQQxqENw8IQgCQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEgaiAFENw7IAUoAhQhByAFKAIMIQogBCgCJCEMIAQoAiAhCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjggBCAGNgI0IAQgBTYCMCAEQcAANgIsIARBLGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0EIAcEQCAHQcAAEK02IgZFDQILIARCADcCOCAEIAY2AjQgBCAHNgIwIARBwAA2AiwgBEEsaiAIEN4QQQAhBwsgCEEDdCIJIQYCQCAJQThxIgUEQCAJIAVrQUBrIgYgCUkNAQtBwAAhBSAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIFRQ0BCyAEQQA2AlAgBCAFNgJIIAQgBjYCRCAEQcAANgJAIAkEQCAJBEAgBUEAIAn8CwALIAQoAlAhDSAEKAJIIQULIAQgCTYCTCAEIAggDWo2AlACQAJAIAcEQCAHIAhHDQEgCCEHDAgLIAhFBEBBACEHDAgLIAMtAAAhCSABKAIQIQFBACEHQQAhBgNAIARB+ABqIAIgASkDACABKQMIIAFBEGopAwAgAUEYaikDABCgCgJAAkAgBCgCeEEBRw0AIAQpA4ABIg4gCRDFKUUNACAFIA43AwAMAQsgBEEQaiAEQSxqEIY9IAZBA3YiAyAEKAIUIgpPDQMgBCgCECADaiIDIAMtAABBfiAGQQdxd3E6AAAgB0EBaiEHCyAFQQhqIQUgAUEgaiEBIAggBkEBaiIGRw0ACwwHCyALBEAgBEH4AGogCyAMIAogCBC/FCAEQZgBaiEIIAMtAAAhBiABKAIQIQkDQAJAIAQpA6ABIg9QRQRAIAQpA6gBIQ4MAQsDQAJ+AkAgBCkDiAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDiAEgDqdBAXFFDQAgBCAEKQOQATcDuAEMAQsgBCgCmAFFDQEgBEGwAWogCBC2KiAEKQOwASEOCyAOQgBSDQILIARCAzcDiAELIAQpA3giDkICUQ0MIARCADcDeCAEKQOAAQwBCyAEKQO4AQshDyAOp0EBcUUNCiAEIAQpA6gBQkB9Ig43A6gBIAQgDzcDoAEgD1ANAAsLIAQgD0IBIA96IhCGhTcDoAEgBEGwAWogAiAJIBCnIA6naiIBQQV0aiIDKQMAIAMpAwggAykDECADKQMYEKAKAkAgBCgCsAFBAUcNACAEKQO4ASIOIAYQxSlFDQAgBSABQQN0aiAONwMADAELIARBGGogBEEsahCGPSABQQN2IgMgBCgCHCIKSQRAIAQoAhggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAyAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAGEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB2ABqIARBLGoiBhCCFCAEQfgAaiICEJcpIARByABqIgEoAgAhBSAEKAJMIQMgASAEQYABaiIIKQIANwMAIAQpA0AhDiAEIAQpAng3A0AgBEEANgJQIAQgDjcChAEgBEEANgKAASAEIAM2AnwgBCAFNgJ4IARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCeDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYgBaiIJKAIANgIAIAQgAzYCuAEgBCAFNgK0ASAEIAE2ArABIARB7ABqIgEgBEGwAWoQ5BkgCSAEQegAaigCADYCACAIIARB4ABqKQIANwMAIAQgBCkCWDcDeCAEIAc2AowBIAAgASACEMYdIARBQGsQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB+ABqQeyP/wBBiIz/ABDVHgALuw0CCH8EfiMAQaACayIDJAAgAUEMahDcPCEHIANBIGogARCSNhDuJSAHQQJ0IgUhBgJAAn8CQAJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgYgBUkNAQtBwAAhBCAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIERQ0BCyADIAQ2AkAgAyAGNgI8IANBwAA2AjggBQRAIARBACAF/AsACyADIAc2AkggAyAFNgJEIAMoAiBFDQMgAygCNCADKAIwRg0EIANB2ABqIANBIGoQyDQgA0H4AGohBiACKAIIIQcgAigCACEIIAEoAhAhCQNAAkAgAykDgAEiDFBFBEAgAykDiAEhCwwBCwNAAn4CQCADKQNoIgtCA1IEQAJAAkACQCALQgJRDQAgAyALUK1CAYY3A2ggC6dBAXFFDQAgAyADKQNwNwOIAgwBCyADKAJ4RQ0BIANBgAJqIAYQtiogAykDgAIhCwsgC0IAUg0CCyADQgM3A2gLIAMpA1giC0ICUQ0JIANCADcDWCADKQNgDAELIAMpA4gCCyEMIAunQQFxRQ0HIAMgAykDiAFCQH0iCzcDiAEgAyAMNwOAASAMUA0ACwsgAyAMQgEgDHoiDYaFNwOAASADQRhqIAggCSANpyALp2oiCkEFdGoiASkDACILIAEpAwgiDCABKQMQIg0gASkDGCIOELwJIAMoAhhBAXFFBEAgAigCBCEBIAMgDjcDyAEgAyANNwPAASADIAw3A7gBIAMgCzcDsAEgA0HMkf8ANgLYASADQgQ3AuQBIANBgww2ApwCIANB9As2ApQCIAMgAUEBajYCkAIgA0G7BzYCjAIgAyABNgKIAiADQcwBNgKEAiADQfiR/wA2AoACIAMgA0GAAmo2AuABIAMgA0GwAWo2ApgCIANBBDYC3AEgA0GgAWogA0HYAWoQmQ4gA0GYAWogA0GsAWooAgA2AgAgAyADKQKkATcDkAEgAygCoAEhBEGCgICAeCEFDAcLIANBgAJqIAMoAhwiASAHLQAAEOoPIAMoAoACIgVBk4CAgHhHBEAgA0GYAWogA0GQAmooAgA2AgAgAyADKQKIAjcDkAEgAygChAIhBAwHBSAEIApBAnRqIAE2AgAMAQsACwALQcAAIAYQoz0AC0Hci/8AQSkgA0HYAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEBQQAhBgNAIANBEGogCSABKQMAIgsgASkDCCIMIAFBEGopAwAiDSABQRhqKQMAIg4QvAkgAygCEEEBcUUEQCACKAIEIQEgAyAONwOYAiADIA03A5ACIAMgDDcDiAIgAyALNwOAAiADQcyR/wA2ArABIANCBDcCvAEgA0GDDDYCdCADQfQLNgJsIAMgAUEBajYCaCADQbsHNgJkIAMgATYCYCADQcwBNgJcIANB+JH/ADYCWCADIANB2ABqNgK4ASADIANBgAJqNgJwIANBBDYCtAEgA0HcAWogA0GwAWoQmQ4gA0H4AWogA0HoAWooAgA2AgAgAyADKQLgATcD8AEgAygC3AEhBEGCgICAeCEFIANB8AFqDAQLIANB2ABqIAMoAhQiCiAILQAAEOoPIAMoAlgiBUGTgICAeEcEQCADQfgBaiADQegAaigCADYCACADIAMpAmA3A/ABIAMoAlwhBCADQfABagwECyAEIAo2AgAgBEEEaiEEIAFBIGohASAHIAZBAWoiBkcNAAsLIANB2ABqIgIQlykgA0FAayIBKAIAIQUgAygCRCEEIAEgA0HgAGoiBikCADcDACADKQM4IQsgAyADKQJYNwM4IANBADYCSCADIAs3AmQgA0EANgJgIAMgBDYCXCADIAU2AlggA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJYNwIIIAFBEGogBikCADcCACABQRhqIANB6ABqIgcoAgA2AgAgAyAENgKIAiADIAU2AoQCIAMgATYCgAIgA0HMAGoiASADQYACahDlGSAHIANBMGopAgA3AwAgBiADQShqKQIANwMAIAMgAykCIDcDWCAAIAEgAhDKHSADQThqEM8vDAMLQQRBHBCjPQALIANBkAFqCyEBIAAgBDYCCCAAIAU2AgQgAEEpOgAAIAAgASkCADcCDCAAQRRqIAFBCGooAgA2AgAgA0E4ahDPLyADKAIgIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBIGoQ+x4LIANBoAJqJAALogwCCn8EfiMAQcABayIEJAAgAUEMaigCCCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIFIQkCQCAFQThxIgYEQCAFIAZrQUBrIgkgBUkNAQtBwAAhBiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgCTYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghDSAEKAJAIQYLIAQgBTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyABIAVqMQAAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgCRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAEgCWoxAAAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALogwCCn8EfiMAQcABayIEJAAgAUEMaigCCCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIFIQkCQCAFQThxIgYEQCAFIAZrQUBrIgkgBUkNAQtBwAAhBiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgCTYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghDSAEKAJAIQYLIAQgBTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyABIAVqMAAAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgCRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAEgCWowAAAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALmhABDn8jAEGQAmsiBiQAIAZC/////4eAgICQfzcDSCAGQv////+fhbCAVDcDQCAGQdQAaiELIAMgBEECdGohDiAAKAIAIQ0gACgCBCEKIAAoAgghCCAALQAOIQ8jAEGQAWsiByQAIAooAhAhECAKKAIMIREgCigCBCESIAooAgAhEwJ/IAhFBEBBASEKQQEMAQsgCCgCECEJIAgoAgwhCiAIKAIEIQwgCCgCAAshCCAHIA42AlwgByADNgJYIAdBADYChAEgB0EANgJMIAdBADYCBCAHQQI6AIwBIAcgCTYCgAEgByAKNgJ8IAcgDDYCeCAHIAg2AnQgByAQNgJwIAcgETYCbCAHIBI2AmggByATNgJkIAcgDTYCYCAHQv//AzcCUCAHIA82AogBIAdBBGoiCCgCSCIKQRFNBH8gCEEEagUgCCgCBCEKIAgoAggLIQkCQCAKIAgoAoABIgxLBEAgCSAMQQJ0ahDdOyAIIAgoAoABQQFqIgo2AoABIAgoAkgiCUESTwR/IAgoAgQFIAkLIApHDQEgCBCmKSAIQQA2AoABDAELIAgoAkwhCiAIQYCAxAA2AkwgCkGAgMQARg0AIAggCiAIKAJQENQHGgsgCyAIQYwB/AoAACAHQZABaiQAIAtBkAFqIAAoAhAQ5CAgC0GAgMQANgKMASALIAAvAQw2ApwBIAFBBGohDCABQfgHaiEOIAYgBkFAazYC9AEgBkHkAWohDSAGQdgAaiELAn8DQAJAQQAhCEEAIQkCQAJAAkACQAJAIAYoAuABQYCAxABHDQAgCyEJAkAgBigCnAEiAEESTwR/IAYoAlwhCSAGKAJYBSAACyAGKALUASIATQ0AIAZBOGogCSAAQQJ0ahCkLyAGKAI4IglBgIDEAEYNACAGLQA8IAYgBigC1AFBAWoiBzYC1AEgBigCnAEiCEESTwR/IAYoAlgFIAgLIAdGBEAgBkHUAGoQpikgBkEANgLUAQsNAiAGIAk2AuABQQAhCEEAIQkMAQsgBigCoAEhCSAGQYCAxAA2AqABIAlBgIDEAEYNAiAGKALwASAJTUEAIAYoAqQBIghBgICAgARxGw0AIAZBMGogBkHUAGoQ9hIgBigCMCIAQYCAxABGDQEgBigCNCEHIAYoAvABIABNBEAgBiAANgKgASAGIAc2AqQBIAdBAEgNAQwCCyAGIAc2AqQBIAYgADYCoAEMAQtBACEHQQAhCgJ/A0AgBigC4AEhACAGQYCAxAA2AuABAkAgAEGAgMQARw0AIAZB1ABqIAkgCBDUByEIIApBAXFFBEAgCCEADAELIAZB+AFqIA0QpjACQCAIQeEiayIAQZ4BTQRAIABBFU8EQCAIQagja0EbTw0CIAdBgNgCayIAQRxwIABBo9cAS3INAiAHIAhqQacjayEADAMLIAdBgCJrIgpBE08NASAKQcwEbCAAQRxsakGA2AJqIQAMAgsgBkH4AWogByAIEI4jIgBBgIDEAEcNAQsgBiAINgLgASAHDAILAkADQCALIQgCQAJAIAYoApwBIgdBEk8EfyAGKAJcIQggBigCWAUgBwsgBigC1AEiB0sEQCAGQShqIAggB0ECdGoQpC8gBigCKCIHQYCAxABHDQELIAZB1ABqEKYpIAZBADYC1AEMAQsgBi0ALCEKIAZB+AFqIA0QpjACQAJAIAdB4SJrIghBngFNBEAgCEEVTwRAIAdBqCNrQRtPDQIgAEGA2AJrIghBHHAgCEGj1wBLcg0CIAAgB2pBpyNrIQkMAwsgAEGAImsiB0ETTw0BIAdBzARsIAhBHGxqQYDYAmohCQwCCyAGQfgBaiAAIAcQjiMiCUGAgMQARw0BCyAGQfgBaiIHIAZB1ABqIAYoAtQBEJUXIAcQ5RQgBkEANgLUASAKQf8BcUUNA0EBIQkDQCALIQcgBigCnAEiCEESTwRAIAYoAlghCCAGKAJcIQcLIAggCU0NAiAGQSBqIAcgCUECdGoQpC8gBigCICIIQYCAxABGDQIgBi0AJCIHRQ0EAkACQCAKQf8BcSAHRgRAIAohBwwBCyAGQfgBaiIPIA0QpjAgDyAAIAgQjiMiCEGAgMQARw0BCyAJQQFqIQkgByEKDAELIAZB1ABqIAkQ2RogCCEADAALAAsgBiAGKALUAUEBajYC1AEgCSEADAELCyAGKAKcASIHQRJPBH8gBigCWAUgBwsNACAGKAKgASIJQYCAxABGDQAgCSAGKALwAUkNACAGKAKkASIIQQBODQAgBkGAgMQANgKgAUEBIQogACEHDAELCyAACyIJQYCAxABGDQELIAlB/wBLDQEgBkEQaiAGKAL0ASIAKQMAIAApAwggCRDHIyAGKQMQQgGDUA0CDAMLIAZB1ABqEMQoIA0Q2ikgBkEIaiABIAJBzP3FABDWJAJAIAQgBigCDCIAIAAgBEsbIgFFDQAgBigCCCEAQQAhCQNAIAAoAgAgAygCAEYEQCAAQQRqIQAgA0EEaiEDIAlBAWoiCSABRw0BDAILCyAAQf3/AzYCACABIAlLQQENBRogBUEBOgAAC0EADAQLIAlB/f8DRw0ADAELAn8gDigCACIKQf4BSQRAIAohACAOIQhB/QEhCiAMDAELIAEoAgQhACAMIQggASgCCAshByAAIApGBH8gARD5HyABKAIIIQcgDCEIIAEoAgQFIAALQQJ0IAdqIAk2AgAgCCAIKAIAQQFqNgIADAELCyAGQdQAahDEKCANENopQQELIAZBkAJqJAALjgwCB38CfiMAQeAAayIDJAACQCACLQAMIgRBAUYEQCAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIAIAJBBEEEEOAeDAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAAwiBkEBaw4CAAIBCyAAIAIpAgA3AgAgAEECIARrOgAMIAAgAi8ADTsADSAAQQhqIAJBCGooAgA2AgAgAEEPaiACQQ9qLQAAOgAADAcLIARFDQEMAgsgBEUNAQsCfyABKAIIIgQgAigCCCIFRwRAIAQgBUsgBCAFSWsMAQsgBEECdCEEIAEoAgRBBGshCCACKAIEQQRrIQkCQANAIARFDQEgBCAJaiEHIAQgCGogBEEEayEEKAIAIgUgBygCACIHRg0ACyAFIAdLIAUgB0lrDAELQX9BACAEGwtB/wFxDgICAwELIANBOGogAUEIaiIEKAIANgIAIAMgASkCACIKNwMwIANByABqIAJBCGoiBSgCADYCACADIAIpAgAiCzcDQAJ/IAqnIAunSQRAIANB2ABqIAUoAgA2AgAgAyACKQIANwNQIANBJGogA0HQAGogA0EwaiIBEO0IIAEMAQsgA0HYAGogBCgCADYCACADIAEpAgA3A1AgA0EkaiADQdAAaiADQUBrIgEQ7QggAQsiBEEEQQQQ4B4gBkEBRwRAIAZBASADKAIsGyEEDAoLIANBADYCLCADQSRqQQRBBBCeJCADKAIsIgFFDQggAygCKCICIAFBAnQiBWpBBGsiBEUNCCAEKAIADQggBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0JCyADIAQ2AiwgBCEBDAgLIANB2ABqIgQgAkEIaigCADYCACADIAIpAgA3A1AgA0HQAGogARDvFCADQcgAaiAEKAIANgIAIAMgAykDUDcDQCABQQRBBBDgHiAGQQFxRQRAQQIgBmtBASADKAJIGyEEDAcLIANBADYCSCADQUBrQQRBBBCeJCADKAJIIgFFDQUgAygCRCICIAFBAnQiBWpBBGsiBEUNBSAEKAIADQUgBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0GCyADIAQ2AkggBCEBDAULIABBCGpBlIqIASkCADcCACAAQYyKiAEpAgA3AgAgAkEEQQQQ4B4MAQsgA0HYAGoiBCABQQhqKAIANgIAIAMgASkCADcDUCADQdAAaiACEO8UIANByABqIAQoAgA2AgAgAyADKQNQNwNAIAJBBEEEEOAeIAZBAUcEQCAGQQEgAygCSBshBAwDCyADQQA2AkggA0FAa0EEQQQQniQgAygCSCIBRQ0BIAMoAkQiAiABQQJ0IgVqQQRrIgRFDQEgBCgCAA0BIAUhBCACQQRrIQYgAUH/////A3EhAgJAA0AgBEUEQEEAIQQMAgsgAkEBayECIAQgBmogBEEEayEEKAIARQ0ACyACQQFqIgQgAUsNAgsgAyAENgJIIAQhAQwBCyABQQRBBBDgHgwGC0EBIQQgASADKAJAQQJ2Tw0AIANBEGogA0FAayABQQRBBBD0FCADKAIQIgFBgYCAgHhGDQAgASADKAIUQcyNiAEQ/S8ACyAAIAMpA0A3AgAgACAEOgAMIABBCGogA0HIAGooAgA2AgAMBAtBASEEIAEgAygCQEECdk8NACADQQhqIANBQGsgAUEEQQQQ9BQgAygCCCIBQYGAgIB4Rg0AIAEgAygCDEHMjYgBEP0vAAsgACADKQNANwIAIAAgBDoADCAAQQhqIANByABqKAIANgIADAILQQEhBCABIAMoAiRBAnZPDQAgA0EYaiADQSRqIAFBBEEEEPQUIAMoAhgiAUGBgICAeEYNACABIAMoAhxBzI2IARD9LwALIAAgAykCJDcCACAAIAQ6AAwgAEEIaiADQSxqKAIANgIACyADQeAAaiQAC5ALAgp/AX4gBEUEQCAAQQA2AjwgACADNgI4IAAgAjYCNCAAIAE2AjAgAEEAOgAOIABBgQI7AQwgACACNgIIIABCADcDAA8LQQEhDEEBIQkCQAJAAkACQAJAAkACQAJAAkAgBEEBRwRAQQEhBUEBIQcDQCAGIAtqIgkgBE8NAiAHIQgCQCADIAVqLQAAIgUgAyAJai0AACIJSQRAIAYgB2pBAWoiByALayEMQQAhBgwBCyAFIAlHBEBBASEMIAhBAWohB0EAIQYgCCELDAELQQAgBkEBaiIHIAcgDEYiBRshBiAHQQAgBRsgCGohBwsgBiAHaiIFIARJDQALQQEhBUEBIQdBACEGQQEhCQNAIAYgCmoiDSAETw0DIAchCAJAIAMgBWotAAAiBSADIA1qLQAAIg1LBEAgBiAHakEBaiIHIAprIQlBACEGDAELIAUgDUcEQEEBIQkgCEEBaiEHQQAhBiAIIQoMAQtBACAGQQFqIgcgByAJRiIFGyEGIAdBACAFGyAIaiEHCyAGIAdqIgUgBEkNAAsLIAQgCyAKIAogC0kiBxsiDUkNAiAMIAkgBxsiByANaiIFIAdJDQMgBCAFSQ0EAn8gAyADIAdqIA0QmScEQCAEQQNxIQgCQCAEQQFrQQNJBEBBACEHDAELIARBfHEhDEEAIQcDQEIBIAMgB2oiBUEDajEAAIZCASAFMQAAhiAPhEIBIAVBAWoxAACGhEIBIAVBAmoxAACGhIQhDyAMIAdBBGoiB0cNAAsLIAgEQCADIAdqIQYDQEIBIAYxAACGIA+EIQ8gBkEBaiEGIAhBAWsiCA0ACwsgBCANayIHIA0gByANSxtBAWohB0F/IQogDSEMQX8MAQtBASELQQAhBkEBIQVBACEMA0AgBCAFIgggBmoiCksEQCAEIAZrIAVBf3NqIgUgBE8NCCAEIAZBf3NqIAxrIgkgBE8NCQJAIAMgBWotAAAiBSADIAlqLQAAIglJBEAgCkEBaiIFIAxrIQtBACEGDAELIAUgCUcEQCAIQQFqIQVBACEGQQEhCyAIIQwMAQtBACAGQQFqIgUgBSALRiIJGyEGIAVBACAJGyAIaiEFCyAHIAtHDQELC0EBIQtBACEGQQEhBUEAIQkDQCAEIAUiCCAGaiIOSwRAIAQgBmsgBUF/c2oiBSAETw0KIAQgBkF/c2ogCWsiCiAETw0LAkAgAyAFai0AACIFIAMgCmotAAAiCksEQCAOQQFqIgUgCWshC0EAIQYMAQsgBSAKRwRAIAhBAWohBUEAIQZBASELIAghCQwBC0EAIAZBAWoiBSAFIAtGIgobIQYgBUEAIAobIAhqIQULIAcgC0cNAQsLIAQgCSAMIAkgDEsbayEMAkAgB0UEQEEAIQdBACEKDAELIAdBA3EhBUEAIQoCQCAHQQRJBEBBACEIDAELIAdBfHEhC0EAIQgDQEIBIAMgCGoiBkEDajEAAIZCASAGMQAAhiAPhEIBIAZBAWoxAACGhEIBIAZBAmoxAACGhIQhDyALIAhBBGoiCEcNAAsLIAVFDQAgAyAIaiEGA0BCASAGMQAAhiAPhCEPIAZBAWohBiAFQQFrIgUNAAsLIAQLIQYgACAENgI8IAAgAzYCOCAAIAI2AjQgACABNgIwIAAgBjYCKCAAIAo2AiQgACACNgIgIABBADYCHCAAIAc2AhggACAMNgIUIAAgDTYCECAAIA83AwggAEEBNgIADwsgCSAEQbT8iQEQwyEACyANIARBtPyJARDDIQALIA0gBEGU/IkBELA7AAsgByAFQaT8iQEQsTsACyAFIARBpPyJARCwOwALIAUgBEHE/IkBEMMhAAsgCSAEQdT8iQEQwyEACyAFIARBxPyJARDDIQALIAogBEHU/IkBEMMhAAuRDAIKfwN+IwBBwAFrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQRhqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAIcIQwgBCgCGCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCMCAEIAY2AiwgBCAFNgIoIARBwAA2AiQgBEEkaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwIwIAQgBjYCLCAEIAc2AiggBEHAADYCJCAEQSRqIAgQ3hBBACEHCyAIQQJ0IgkhBQJAIAlBPHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCSCAEIAY2AkAgBCAFNgI8IARBwAA2AjggCQRAIAkEQCAGQQAgCfwLAAsgBCgCSCENIAQoAkAhBgsgBCAJNgJEIAQgCCANajYCSCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyADLQAAIQkgAigCACECIAEoAhAhBUEAIQdBACEBA0ACQAJAAkAgAkUEQCAEQYeAgIB4NgJwIARB8ABqEIgRDAELIAUvAQAgAm0iAyAJEMQpRQ0AIAYgAzYCAAwBCyAEQQhqIARBJGoQhj0gAUEDdiIDIAQoAgwiCk8NASAEKAIIIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAMgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQZABaiEIIAMtAAAhBSACKAIAIQIgASgCECEJA0ACQCAEKQOYASIPUEUEQCAEKQOgASEODAELA0ACfgJAIAQpA4ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A4ABIA6nQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAgQtiogBCkDqAEhDgsgDkIAUg0CCyAEQgM3A4ABCyAEKQNwIg5CAlENBiAEQgA3A3AgBCkDeAwBCyAEKQOwAQshDyAOp0EBcUUNBCAEIAQpA6ABQkB9Ig43A6ABIAQgDzcDmAEgD1ANAAsLIAQgD0IBIA96IhCGhTcDmAEgEKcgDqdqIQECQCACRQRAIARBh4CAgHg2AqgBIARBqAFqEIgRDAELIAkgAUEBdGovAQAgAm0iAyAFEMQpRQ0AIAYgAUECdGogAzYCAAwBCyAEQRBqIARBJGoQhj0gAUEDdiIDIAQoAhQiCkkEQCAEKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAMgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5RkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEModIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALkQwCCn8DfiMAQcABayIEJAAgAUEMahDZPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEECdCIJIQUCQCAJQTxxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgBTYCPCAEQcAANgI4IAkEQCAJBEAgBkEAIAn8CwALIAQoAkghDSAEKAJAIQYLIAQgCTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEJIAIoAgAhAiABKAIQIQVBACEHQQAhAQNAAkACQAJAIAJFBEAgBEGHgICAeDYCcCAEQfAAahCIEQwBCyAFLgEAIAJtIgMgCRDEKUUNACAGIAM2AgAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAyAEKAIMIgpPDQEgBCgCCCADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQRqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyAJIAFBAXRqLgEAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC5sLARl/IwBBEGsiECQAIAIoAgQhDCACKAIAIQ8gAEEANgLcASADIARqIg1BCGshByANQRBrIR1BBEEGIAAoAsQBIgQgBEEGTxsiBCAEQQRNGyEWQQRBBiAAKALIASIEIARBBk8bIgQgBEEETRshFyAAKAIQIAAoAgghFCADIAAoAgQiESAAKAIMIhVqIhhGIQQgACgCuAEhCiAFQQJHIh5FBEAgACARIBcgACgCHCAdEKAaCyAdIAcgBUECRhshGiAUaiEfIBQgFWohGyADIARqIQQgFUEBayEcQQEgCnQhEgNAAkACQCAEIBpJBEAgBEEBaiEKQQAhCQJAIBwgBCARayITQQFqIgggD2siC2tBA0kNACAPIAggACgCECIHIAggEmsgByAIIAdrIBJLGyAAKAIYG2tLDQAgCigAACALIBQgESALIBVJIgsbaiIHKAAARw0AIARBBWogB0EEaiANIBsgDSALGyAYEM0oQQRqIQkgBg0AQQEhBwwDCyAQQf+T69wDNgIMIAAgBCANIBBBDGogFyAWIAVBARC3BiIHIAkgByAJSyIHGyIJQQNNBEAgACAEIANrIgpB/xFLNgLcASAEIApBCHZqQQFqIQQMBAsgBCAKIAcbIQogECgCDEEBIAcbIQcCQCAGRQ0AA0AgBCAaTw0BIBNBAWohGSAEQQFqIQsCQCAHRQRAQQAhBwwBCyAcIBkgD2siDmtBA0kNACAPIBkgACgCECIIIBkgEmsgCCAZIAhrIBJLGyAAKAIYG2tLDQAgCygAACAOIBQgESAOIBVJIg4baiIIKAAARw0AIARBBWogCEEEaiANIBsgDSAOGyAYEM0oIghBe0sNACAHZyAJQQNsakEeayAIQQRqIghBA2xODQBBASEHIAshCiAIIQkLIBBB/5Pr3AM2AggCQCAAIAsgDSAQQQhqIBcgFiAFQQEQtwYiDkEESQ0AIBAoAggiCGcgDkECdGpBH2sgB2cgCUECdGpBG2tMDQAgGSETIAghByAOIQkgCyIKIQQMAQsgBkECRyALIBpPcg0BIBNBAmohEyAEQQJqIQsCQCAHRQRAQQAhBwwBCyAcIBMgD2siDmtBA0kNACAPIBMgACgCECIIIBMgEmsgCCATIAhrIBJLGyAAKAIYG2tLDQAgCygAACAOIBQgESAOIBVJIg4baiIIKAAARw0AIARBBmogCEEEaiANIBsgDSAOGyAYEM0oIgRBe0sNACAHZyAJQQJ0akEeayAEQQRqIgRBAnRODQBBASEHIAshCiAEIQkLIBBB/5Pr3AM2AgQgACALIA0gEEEEaiAXIBYgBUEBELcGIghBBEkNASAQKAIEIgRnIAhBAnRqQR9rIAdnIAlBAnRqQRhrTA0BIAQhByAIIQkgCyIKIQQMAAsACyAHQQRJDQIgFCARIAogByARamtBA2oiBCAVSSIMGyAEaiEEIB8gGCAMGyEIIAdBA2shCwNAIAQgCE0gAyAKT3INAiAKQQFrIgwtAAAgBEEBayIELQAARw0CIAlBAWohCSAMIQoMAAsACyACIAw2AgQgAiAPNgIAIBBBEGokACANIANrDwsgDyEMIAshDwsgASAKIANrIAMgDSAHIAkQhRIgACgC3AEEQCAeRQRAIAAgESAXIAAoAhwgHRCgGgsgAEEANgLcAQsgCSAKaiEDA0ACQCAMIQQgAyAaSw0AIBQgESADIBFrIgcgBGsiDCAVSSIKGyAMaiEJIBwgDGtBA0kgByAAKAIQIgwgByASayAMIAcgDGsgEksbIAAoAhgbayAESXINACADKAAAIAkoAABHDQAgAUEAIAMgDUEBIANBBGogCUEEaiANIBsgDSAKGyAYEM0oQQRqIgoQhRIgAyAKaiEDIA8hDCAEIQ8MAQsLIAQhDCADIQQMAAsAC4oMAgp/BH4jAEHgAWsiAyQAIAFBDGoQ2DwhBwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBSADQUBrIAQQ3DsgBCgCFCEGIAQoAgwhCSADKAJEIQsgAygCQCEKIAdBA3YgB0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgVFDQQLIANCADcCWCADIAU2AlQgAyAENgJQIANBwAA2AkwgA0HMAGogCSAHIAlqIAogCxC/GAwBC0HAACEFIAdBA3YgB0EHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIANCADcCWCADIAU2AlQgAyAGNgJQIANBwAA2AkwgA0HMAGogBxDeEEEAIQYLIAdBA3QiBSEEAkAgBUE4cSIIBEAgBSAIa0FAayIEIAVJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQsgA0EANgJwIAMgCDYCaCADIAQ2AmQgA0HAADYCYCAFBEAgBQRAIAhBACAF/AsACyADKAJwIQwgAygCaCEICyADIAU2AmwgAyAHIAxqNgJwAkACQCAGBEAgBiAHRw0BIAchBgwICyAHRQRAQQAhBgwICyACKQMAIQ0gASgCECEFQQAhBkEAIQQDQCADQRBqIAUpAwAiDiAOQj+HIA0gDUI/hxCoHgJAIAMpAxggAykDECIOQj+HUQRAIAggDjcDAAwBCyADQQhqIANBzABqEIY9IARBA3YiASADKAIMIgJPDQMgAygCCCABaiIBIAEtAABBfiAEQQdxd3E6AAAgBkEBaiEGCyAIQQhqIQggBUEIaiEFIAcgBEEBaiIERw0ACwwHCyAKBEAgA0GYAWogCiALIAkgBxC/FCADQbgBaiEHIAIpAwAhDyABKAIQIQQDQAJAIAMpA8ABIg5QRQRAIAMpA8gBIQ0MAQsDQAJ+AkAgAykDqAEiDUIDUgRAAkACQAJAIA1CAlENACADIA1QrUIBhjcDqAEgDadBAXFFDQAgAyADKQOwATcD2AEMAQsgAygCuAFFDQEgA0HQAWogBxC2KiADKQPQASENCyANQgBSDQILIANCAzcDqAELIAMpA5gBIg1CAlENDCADQgA3A5gBIAMpA6ABDAELIAMpA9gBCyEOIA2nQQFxRQ0KIAMgAykDyAFCQH0iDTcDyAEgAyAONwPAASAOUA0ACwsgAyAOQgEgDnoiEIaFNwPAASADQTBqIAQgEKcgDadqIgFBA3QiAmopAwAiDSANQj+HIA8gD0I/hxCoHiADKQM4IAMpAzAiDUI/h1EEQCACIAhqIA03AwAMAQsgA0EoaiADQcwAahCGPSABQQN2IgIgAygCLCIFSQRAIAMoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgAiAFQYiL/wAQwyEAC0HEiv8AELI7AAsgASACQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgBBCjPQALIANB+ABqIANBzABqIgUQghQgA0GYAWoiAhCXKSADQegAaiIBKAIAIQggAygCbCEHIAEgA0GgAWoiBCkCADcDACADKQNgIQ0gAyADKQKYATcDYCADQQA2AnAgAyANNwKkASADQQA2AqABIAMgBzYCnAEgAyAINgKYASADIAIQ1zsgAygCACEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAMpApgBNwIIIAFBEGogBCkCADcCACABQRhqIANBqAFqIgkoAgA2AgAgAyAHNgLYASADIAg2AtQBIAMgATYC0AEgA0GMAWoiASADQdABahDkGSAJIANBiAFqKAIANgIAIAQgA0GAAWopAgA3AwAgAyADKQJ4NwOYASADIAY2AqwBIAAgASACENYdIANB4ABqEM8vIAUQzy8gA0HgAWokAA8LQQRBHBCjPQALQdyL/wBBKSADQZgBakHsj/8AQYiM/wAQ1R4AC4oMAgp/A34jAEHAAWsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBAnQiBSEJAkAgBUE8cSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAk2AjwgBEHAADYCOCAFBEAgBQRAIAZBACAF/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAU2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhBSACKAIAIQIgASgCECEJQQAhB0EAIQEDQAJAAkACQCACRQRAIARBh4CAgHg2AnAgBEHwAGoQiBEMAQsgASAJai0AACACbSIDIAUQxClFDQAgBiADNgIADAELIARBCGogBEEkahCGPSABQQN2IgMgBCgCDCIKTw0BIAQoAgggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEEaiEGIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyABIAlqLQAAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC4oMAgp/A34jAEHAAWsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBAnQiBSEJAkAgBUE8cSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAk2AjwgBEHAADYCOCAFBEAgBQRAIAZBACAF/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAU2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhBSACKAIAIQIgASgCECEJQQAhB0EAIQEDQAJAAkACQCACRQRAIARBh4CAgHg2AnAgBEHwAGoQiBEMAQsgASAJaiwAACACbSIDIAUQxClFDQAgBiADNgIADAELIARBCGogBEEkahCGPSABQQN2IgMgBCgCDCIKTw0BIAQoAgggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEEaiEGIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyABIAlqLAAAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC6MNAgZ/An4jAEGwAmsiAiQAIAJB2AFqIgNBADYCACACQoCAgICAATcC0AEgAkHQAWpBARCHLSACQagBaiADKAIAIgM2AgAgAiACKQLQASIINwOgASACQTBqIAFBsAJqIgQpAgA3AwAgAkE4aiABQbgCaiIFKQIANwMAIAEpAqgCIQkgASAINwKoAiAEIAM2AgAgBUIBNwMAIAFBADYCtAIgAiAJNwMoIAJBxABqIAEQ2BgCf0GAgICAeCABKALAAiIDQYGAgIB4Rg0AGkGAgICAeCADQYCAgIB4Rg0AGiABKQLEAiEIIAFBADYCyAIgAUKAgICAIDcDwAIgAwshAyABQYgDahC0MCABIAg3AowDIAEgAzYCiAMgASgC6AIiA0GAgICAeEcEQCABKQLsAiEIIAFBADYC8AIgAUKAgICAIDcD6AILIAFBlANqELQwIAEgCDcDmAMgASADNgKUAyABQgA3A/gCAkACQAJAAkACQAJAAkACQAJAAkACQCABLQCgA0Elaw4CAQIACyACQdABaiIDIAFBoANqEMEGIAIgAkEoaiACQcQAaiADEKMLIAIoAgQhAyACKAIAIQEMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEQaiACQShqIAJBxABqIAJB0AFqIgEQowsgAiACKQMQNwKAASACQQhqIAJBgAFqIgYQuSYgASACKAIIIgMgAigCDCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI8dIAJBoAFqIAEgBSAEEKETIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAYQuyMMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEgaiACQShqIAJBxABqIAJB0AFqIgEQowsgAiACKQMgNwKAASACQRhqIAJBgAFqIgYQuSYgASACKAIYIgMgAigCHCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI4dIAJBoAFqIAEgBSAEEKMTIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAYQuyMMBwsgAkGXAWoiASACQbABaikAADcAACACQZABaiIEIAJBqQFqKQAANwMAIAJB2ABqIgUgAkHAAWopAgA3AwAgAkHgAGoiBiACQcgBaikCADcDACACQfAAaiIHIAQpAwA3AwAgAkH3AGoiBCABKQAANwAAIAIgAikCuAE3A1AgAiACKQChATcDaEE4QQQQrTYiAUUNAyABIAM6AAggAUKBgICAEDcCACABIAIpA2g3AAkgASACKQNQNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQayKzQAhAwwFCyACQZcBaiIBIAJBsAFqKQAANwAAIAJBkAFqIgQgAkGpAWopAAA3AwAgAkGIAmoiBSACQcABaikCADcDACACQZACaiIGIAJByAFqKQIANwMAIAJBoAJqIgcgBCkDADcDACACQacCaiIEIAEpAAA3AAAgAiACKQK4ATcDgAIgAiACKQChATcDmAJBOEEEEK02IgFFDQMgASADOgAIIAFCgYCAgBA3AgAgASACKQOYAjcACSABIAIpA4ACNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQZSLzQAhAwwEC0Gcis0AELI7AAtBhIvNABCyOwALQQRBOBCjPQALQQRBOBCjPQALIAAgAzYCCCAAIAE2AgQgAEEINgIACyACQbACaiQAC6MNAgZ/An4jAEGwAmsiAiQAIAJB2AFqIgNBADYCACACQoCAgIDAADcC0AEgAkHQAWpBARCGLSACQagBaiADKAIAIgM2AgAgAiACKQLQASIINwOgASACQTBqIAFBsAJqIgQpAgA3AwAgAkE4aiABQbgCaiIFKQIANwMAIAEpAqgCIQkgASAINwKoAiAEIAM2AgAgBUIBNwMAIAFBADYCtAIgAiAJNwMoIAJBxABqIAEQ2BgCf0GAgICAeCABKALAAiIDQYGAgIB4Rg0AGkGAgICAeCADQYCAgIB4Rg0AGiABKQLEAiEIIAFBADYCyAIgAUKAgICAIDcDwAIgAwshAyABQYgDahC0MCABIAg3AowDIAEgAzYCiAMgASgC6AIiA0GAgICAeEcEQCABKQLsAiEIIAFBADYC8AIgAUKAgICAIDcD6AILIAFBlANqELQwIAEgCDcDmAMgASADNgKUAyABQgA3A/gCAkACQAJAAkACQAJAAkACQAJAAkACQCABLQCgA0Elaw4CAQIACyACQdABaiIDIAFBoANqEMEGIAIgAkEoaiACQcQAaiADEKILIAIoAgQhAyACKAIAIQEMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEQaiACQShqIAJBxABqIAJB0AFqIgEQogsgAiACKQMQNwKAASACQQhqIAJBgAFqIgYQuSYgASACKAIIIgMgAigCDCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI8dIAJBoAFqIAEgBSAEEKETIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAYQuyMMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEgaiACQShqIAJBxABqIAJB0AFqIgEQogsgAiACKQMgNwKAASACQRhqIAJBgAFqIgYQuSYgASACKAIYIgMgAigCHCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI4dIAJBoAFqIAEgBSAEEKMTIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAYQuyMMBwsgAkGXAWoiASACQbABaikAADcAACACQZABaiIEIAJBqQFqKQAANwMAIAJB2ABqIgUgAkHAAWopAgA3AwAgAkHgAGoiBiACQcgBaikCADcDACACQfAAaiIHIAQpAwA3AwAgAkH3AGoiBCABKQAANwAAIAIgAikCuAE3A1AgAiACKQChATcDaEE4QQQQrTYiAUUNAyABIAM6AAggAUKBgICAEDcCACABIAIpA2g3AAkgASACKQNQNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQayKzQAhAwwFCyACQZcBaiIBIAJBsAFqKQAANwAAIAJBkAFqIgQgAkGpAWopAAA3AwAgAkGIAmoiBSACQcABaikCADcDACACQZACaiIGIAJByAFqKQIANwMAIAJBoAJqIgcgBCkDADcDACACQacCaiIEIAEpAAA3AAAgAiACKQK4ATcDgAIgAiACKQChATcDmAJBOEEEEK02IgFFDQMgASADOgAIIAFCgYCAgBA3AgAgASACKQOYAjcACSABIAIpA4ACNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQZSLzQAhAwwEC0Gcis0AELI7AAtBhIvNABCyOwALQQRBOBCjPQALQQRBOBCjPQALIAAgAzYCCCAAIAE2AgQgAEEINgIACyACQbACaiQAC8gLAhB/An4jAEFAaiIGJAACQCABKAIMIg4gAmoiAiAOTwRAAkACQCABKAIEIgggCEEBaiIMQQN2IgRBB2wgCEEISRsiEEEBdiACSQRAIAZBMGoCfyAQQQFqIgUgAiACIAVJGyICQQ9PBEAgAkH/////AUsNBEF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsiAkEYQQggAhCdFCAGKAI0IQkgBigCMCIFRQRAIAYoAjghAgwFCyAGKQI4IRQgCUEJaiICBEAgBUH/ASAC/AsACyAGIBRCIIg+AiwgBiAUpyIPNgIoIAYgCTYCJCAGIAU2AiAgBkEINgIcQQAhAiAOBEAgBUEYayEKIAVBCGohCyABKAIAIgRBGGshDCAEKQMAQn+FQoCBgoSIkKDAgH+DIRQDQCAUUARAA0AgAkEIaiECIARBCGoiBCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgBSAJIAMgDCAUeqdBA3YgAmoiEEFobGoQ+AunIhFxIgdqKQAAQoCBgoSIkKDAgH+DIhVQBEBBCCEIA0AgByAIaiEHIAhBCGohCCAFIAcgCXEiB2opAABCgIGChIiQoMCAf4MiFVANAAsLIBRCAX0gFIMhFCAFIBV6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAFIAdqIBFBGXYiCDoAACALIAdBCGsgCXFqIAg6AAAgCiAHQWhsaiIHQRBqIAwgEEFobGoiCEEQaikAADcAACAHQQhqIAhBCGopAAA3AAAgByAIKQAANwAAIA5BAWsiDg0ACyABKAIMIQILIAYgAjYCLCAGIA8gAms2AigDQCABIA1qIgIoAgAhAyACIAYgDWpBIGoiAigCADYCACACIAM2AgAgDUEEaiINQRBHDQALIAYoAiQiAkUNASACIAJBGGxBH2pBeHEiAWpBCWoiAkUNASAGKAIgIAFrIAJBCBD4OgwBCyABKAIAIQUgBCAMQQdxQQBHaiIEBEAgBSECA0AgAiACKQMAIhRCf4VCB4hCgYKEiJCgwIABgyAUQv/+/fv379+//wCEfDcDACACQQhqIQIgBEEBayIEDQALCwJAAkAgDEEITwRAIAUgDGogBSkAADcAAAwBCyAMBEAgBUEIaiAFIAz8CgAACyAMRQ0BCyAFQQhqIQ8gBUEYayERQQEhBCAFIQlBACECA0AgAiEHIAQhAgJAIAUgB2oiEy0AAEGAAUcNACARIAdBaGxqIQ0CQANAIAggAyANEPgLpyIScSIKIQQgBSAKaikAAEKAgYKEiJCgwIB/gyIUUARAQQghCwNAIAQgC2ohBCALQQhqIQsgBSAEIAhxIgRqKQAAQoCBgoSIkKDAgH+DIhRQDQALCyAFIBR6p0EDdiAEaiAIcSIEaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEECyAEIAprIAcgCmtzIAhxQQhPBEAgBCAFaiIKLQAAIAogEkEZdiIKOgAAIA8gBEEIayAIcWogCjoAACAEQWhsIQRB/wFGDQIgBCAFaiEKQWghBANAIAQgCWoiCygAACESIAsgBCAKaiILKAAANgAAIAsgEjYAACAEQQRqIgQNAAsMAQsLIBMgEkEZdiIEOgAAIA8gB0EIayAIcWogBDoAAAwBCyATQf8BOgAAIA8gB0EIayAIcWpB/wE6AAAgBCARaiIEQRBqIA1BEGopAAA3AAAgBEEIaiANQQhqKQAANwAAIAQgDSkAADcAAAsgCUEYayEJIAIgAiAMSSIHaiEEIAcNAAsLIAEgECAOazYCCAtBgYCAgHghCQwCCxDjJyAGKAIMIQIgBigCCCEJDAELEOMnIAYoAgQhAiAGKAIAIQkLIAAgCTYCACAAIAI2AgQgBkFAayQAC7UMAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiBigCACIFLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkwgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwNYIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEHYAGogAxCeJSECDAwLIARB2ABqIAMQuRwhAgwLCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQsgACgCECACQQN0aikDACEHIAUoAgQiAEUNAiAEIAVBBGo2AhQgBEEYaiAAQQhqIAUoAggQihggBCgCGEGTgICAeEYNAyAEQcwAaiAHEP0XIAQoAkxFDQQgBEE4aiAEQdQAaigCADYCACAEIAQpAkw3AzAgBEEDNgJsIARBlJyEATYCaCAEQgI3AnQgBEH5FzYCZCAEQZMMNgJcIAQgBEHYAGo2AnAgBCAEQRRqNgJgIAQgBEEwajYCWCADKAIAIAMoAgQgBEHoAGoQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQogBCAAKAIQIAJBA3RqKQMAIgc3AwAgBEHoAGoiACAHEP0XIAQoAmgiAUUNBSAEIAE2AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGSDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCMAQSBrIgAkACAAQRBqQbCthgEoAgA2AgAgAEGorYYBKQIANwMIIABBFGogBxD9FyAEQdgAaiIBIAAoAhQEfyABIAApAhg3AgRBAQVBAAs2AgAgAEEIahDJDCAAQSBqJAAgBCgCWEUNBSAEIAQpAlw3AjAgBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQTBqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIARB2ABqIAcQ/RcgBCgCWARAIARBIGogBEHgAGooAgA2AgAgBCAEKQJYNwMYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkww2AjQgBCAEQTBqNgJwIAQgBEEYajYCMCADKAIAIAMoAgQgBEHoAGoQywohAgwICyADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEEwaiAHIAQoAhwQzyUgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAENgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBEEIajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMAwsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYCyAEQegAakHIl4QBEO8sAAu1DAIDfwF+IwBBgAFrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgYoAgAiBS0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgJMIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDWCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARB2ABqIAMQniUhAgwMCyAEQdgAaiADELkcIQIMCwsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0LIAAoAhAgAkEDdGopAwAhByAFKAIEIgBFDQIgBCAFQQRqNgIUIARBGGogAEEIaiAFKAIIEIoYIAQoAhhBk4CAgHhGDQMgBEHMAGogBxCBFSAEKAJMRQ0EIARBOGogBEHUAGooAgA2AgAgBCAEKQJMNwMwIARBAzYCbCAEQZSchAE2AmggBEICNwJ0IARB+Rc2AmQgBEGTDDYCXCAEIARB2ABqNgJwIAQgBEEUajYCYCAEIARBMGo2AlggAygCACADKAIEIARB6ABqEMsKIQIMCQsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0KIAQgACgCECACQQN0aikDACIHNwMAIARB6ABqIgAgBxCBFSAEKAJoIgFFDQUgBCABNgJYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkgw2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AhggAygCACADKAIEIAAQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQkgBCAAKAIQIAJBA3RqKQMAIgc3AwgjAEEgayIAJAAgAEEQakG4rIYBKAIANgIAIABBsKyGASkCADcDCCAAQRRqIAcQgRUgBEHYAGoiASAAKAIUBH8gASAAKQIYNwIEQQEFQQALNgIAIABBCGoQyQwgAEEgaiQAIAQoAlhFDQUgBCAEKQJcNwIwIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBlAw2AhwgBCAEQRhqNgJwIAQgBEEwajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwICyAEQdgAaiAHEIEVIAQoAlgEQCAEQSBqIARB4ABqKAIANgIAIAQgBCkCWDcDGCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZMMNgI0IAQgBEEwajYCcCAEIARBGGo2AjAgAygCACADKAIEIARB6ABqEMsKIQIMCAsgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBMGogByAEKAIcEMwlIAQoAjAEQCAEQeAAaiAEQThqKQIANwMAIAQgBCkCMDcDWCAEQcwAaiIAIARB2ABqEK4HIARB+hc2AkggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBCAANgJEIAQgBEHEAGo2AnAgAygCACADKAIEIARB6ABqEMsKIQIgABDeOwwGCyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAULIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBAsgBEHYAGogAxC4HCECDAQLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBDYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwDCyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIARBCGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMAgsgBCAANgIwIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEEwajYCICAEIARBzABqNgIYDAMLIARBGGoQ5RALIARBgAFqJAAgAg8LIAQgATYCWCAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARB2ABqNgIgIAQgBEEwajYCGAsgBEHoAGpByJeEARDvLAALtQwCA38BfiMAQYABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCTCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3A1ggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQdgAaiADEJ4lIQIMDAsgBEHYAGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQ1hUgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCiAEIAAoAhAgAkEDdGopAwAiBzcDACAEQegAaiIAIAcQ1hUgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCQsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0JIAQgACgCECACQQN0aikDACIHNwMIIwBBIGsiACQAIABBEGpB1K2GASgCADYCACAAQcythgEpAgA3AwggAEEUaiAHENYVIARB2ABqIgEgACgCFAR/IAEgACkCGDcCBEEBBUEACzYCACAAQQhqEMkMIABBIGokACAEKAJYRQ0FIAQgBCkCXDcCMCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZQMNgIcIAQgBEEYajYCcCAEIARBMGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMCAsgBEHYAGogBxDWFSAEKAJYBEAgBEEgaiAEQeAAaigCADYCACAEIAQpAlg3AxggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGTDDYCNCAEIARBMGo2AnAgBCAEQRhqNgIwIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQTBqIAcgBCgCHBDOJSAEKAIwBEAgBEHgAGogBEE4aikCADcDACAEIAQpAjA3A1ggBEHMAGoiACAEQdgAahCuByAEQfoXNgJIIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IAQgADYCRCAEIARBxABqNgJwIAMoAgAgAygCBCAEQegAahDLCiECIAAQ3jsMBgsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwFCyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAQLIARB2ABqIAMQuBwhAgwECyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIAQ2AhggAygCACADKAIEIARB6ABqEMsKIQIMAwsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAEQQhqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAILIAQgADYCMCAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARBMGo2AiAgBCAEQcwAajYCGAwDCyAEQRhqEOUQCyAEQYABaiQAIAIPCyAEIAE2AlggBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQdgAajYCICAEIARBMGo2AhgLIARB6ABqQciXhAEQ7ywAC7UMAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiBigCACIFLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkwgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwNYIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEHYAGogAxCeJSECDAwLIARB2ABqIAMQuRwhAgwLCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQsgACgCECACQQN0aikDACEHIAUoAgQiAEUNAiAEIAVBBGo2AhQgBEEYaiAAQQhqIAUoAggQihggBCgCGEGTgICAeEYNAyAEQcwAaiAHEP0VIAQoAkxFDQQgBEE4aiAEQdQAaigCADYCACAEIAQpAkw3AzAgBEEDNgJsIARBlJyEATYCaCAEQgI3AnQgBEH5FzYCZCAEQZMMNgJcIAQgBEHYAGo2AnAgBCAEQRRqNgJgIAQgBEEwajYCWCADKAIAIAMoAgQgBEHoAGoQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQogBCAAKAIQIAJBA3RqKQMAIgc3AwAgBEHoAGoiACAHEP0VIAQoAmgiAUUNBSAEIAE2AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGSDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCMAQSBrIgAkACAAQRBqQYythgEoAgA2AgAgAEGErYYBKQIANwMIIABBFGogBxD9FSAEQdgAaiIBIAAoAhQEfyABIAApAhg3AgRBAQVBAAs2AgAgAEEIahDJDCAAQSBqJAAgBCgCWEUNBSAEIAQpAlw3AjAgBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQTBqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIARB2ABqIAcQ/RUgBCgCWARAIARBIGogBEHgAGooAgA2AgAgBCAEKQJYNwMYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkww2AjQgBCAEQTBqNgJwIAQgBEEYajYCMCADKAIAIAMoAgQgBEHoAGoQywohAgwICyADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEEwaiAHIAQoAhwQzSUgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAENgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBEEIajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMAwsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYCyAEQegAakHIl4QBEO8sAAvEDAERfyMAQbABayICJAAgAkEANgIsIAJCgICAgIABNwIkIAJBADYCMCACQaABaiABQQYgAkEwahC8FAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCoAEiCARAIAIoAqgBIgMgAigCpAEiBUsNASABKAIAIQkgAyAIaiIPKAAAIhBFBEAgASgCCCIGQQRqIQcgASgCBCEEDAwLIANBBGohAyAJIAEoAggiBmohESAGQQRqIQcgASgCBCEEA0AgCyAPKAAATw0DIANBe0sNBCADQQRqIgEgBUsNBSADIAMgCGooAAAiDGoiCkF7Sw0GIApBBGogBUsNByACQTBqIg0gCCAFIAMgDCAIIApqKAAAa2oQ9jQCQAJAIA1BCBDMICISQf//A3EiDkUNACADIAwgDmpqIg4gBUsNCiAIIA5qLQAAQQdHDQAgBkF7Sw0LIAQgB0kNDCANIAkgBCAGIBEoAABrEPY0IA1BBBDMIEH//wNxIgNFDQAgAyAGaiIDIARLDQ0gAyAJai8AAEEBRg0BCyACIAo2AqgBIAIgBTYCpAEgAiAINgKgASACQTBqIAJBoAFqEPADIAIoAiwiAyACKAIkRgRAIAJBJGpBhLr+ABC3KAsgAigCKCADQcgAbGogAkEwakHIAPwKAAAgAiADQQFqNgIsIAEhAyAQIAtBAWoiC0YNDQwBCwsgAkEANgJAIAJBATYCNCACQey5/gA2AjAgAkIENwI4IAJBMGpB9Ln+ABDvLAALQaC5/gAQsjsACyADIAVB9LX+ABCvOwALQYS2/gBBIkGotv4AEJ8pAAsgAyADQQRqQYC5/gAQsTsACyADQQRqIAVBgLn+ABCwOwALIAogCkEEakGQuf4AELE7AAsgCkEEaiAFQZC5/gAQsDsACyAMIBJB//8DcWogA2ogBUH0tf4AEK87AAsgBiAHQZC5/gAQsTsACyAHIARBkLn+ABCwOwALIAMgBEH0tf4AEK87AAsgAkGgAWoiAUHQuP4AEKUrIAJBOGpB+Lj+ACkDADcDACACQfC4/gApAwA3AzAgAiACKQOoATcDSCACIAIpA6ABNwNAIAZBe00EQCAEIAdPBEAgASAJIAQgBiAGIAlqKAAAaxD2NAJAAkACQAJAIAFBCBDMIEH//wNxIgFFDQAgASAGaiIBQQRqIQMgAUF7Sw0DIAMgBEsNAiABIAlqKAAAIAFqIgEgBEsNASABIAlqIgooAAAiDEUNACABQQRqIQtBACEGA0AgCyEBAkACQAJAAkACQCAKKAAAIAZLBEAgAUF7Sw0BIAFBBGoiCyAESw0CIAIgBDYCgAEgAiAJNgJ8IAIgASABIAlqKAAAajYChAEgAkEYaiACQfwAaiIDQQQQvRQgAigCHCEBIAIoAhghBSACQRBqIANBBhC9FCAFRQ0FIAIoAhAiDUUNBSACKAIUIQMgAkGgAWogAUEAQQFBARCgGCACKAKkASEHIAIoAqABQQFGDQMgAigCqAEhCCABBEAgCCAFIAH8CgAACyACIAE2ApwBIAIgCDYCmAEgAiAHNgKUASACQaABaiADQQBBAUEBEKAYIAIoAqQBIQEgAigCoAFBAUYNBCACKAKoASEFIAMEQCAFIA0gA/wKAAALIAIgAzYCqAEgAiAFNgKkASACIAE2AqABIAJBiAFqIgEgAkEwaiACQZQBaiACQaABahDOCSACKAKIAUGAgICAeEYNBSABEN47DAULQYS2/gBBIkGotv4AEJ8pAAsgASABQQRqQYC5/gAQsTsACyABQQRqIARBgLn+ABCwOwALIAcgAigCqAFB1Lj+ABD9LwALIAEgAigCqAFB1Lj+ABD9LwALIAwgBkEBaiIGRw0ACwsgACACKQMwNwMIIAJBqAFqIAJBLGooAgA2AgAgAEEQaiACQThqKQMANwMAIABBGGogAkFAaykDADcDACAAQSBqIAJByABqKQMANwMAIAIgAikCJDcDoAEgAkEIaiACQaABahD+IyACKAIIIQEgACACKAIMNgIEIAAgATYCACACQbABaiQADwsgASAEQfS1/gAQrzsACyADIARBgLn+ABCwOwALIAEgA0GAuf4AELE7AAsgByAEQZC5/gAQsDsACyAGIAdBkLn+ABCxOwALxhQDD38BfgFvIwBBsA1rIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A6AVBAWsOAwgCAQALIABB8AJqIABB8AL8CgAACyAAQfACaiEMAkACQAJAAkAgAC0A2AVBAWsOAwkEAQALIAAoAtAFIQICQCAAKALUBSIEBEAgA0EgaiAEEJUaDAELIANCAjcDIAsgA0G4AWoiBCADQSBqQZgB/AoAACAMIARB2AL8CgAAIABBADoAzAUgACACNgLIBSAAQcwFaiELDAELIABBzAVqIQsCQCAALQDMBUEBaw4DBQMCAAsgACgCyAUhAgsgACkD8AIhESADQZAEaiIHIABB+AJqQZAB/AoAACADQZgIaiEEIwBBEGsiBSQAIAUgAjYCDCMAQRBrIgYkACAFQQxqKAIAJQEQBCESEN8SIgogEiYBIAZBCGoQzi1BASEIIAUCfyAGKAIIQQFxBEAgBigCDAwBC0EAIQggCgs2AgQgBSAINgIAIAZBEGokACAFKAIEIQgCQCAFKAIAQQFxRQRAIAJBhAFPBEAgAhDyHwsgBEEBOgAMIARBADYCCCAEIAg2AgQgBEEBNgIADAELIAQgAjYCCCAEIAg2AgQgBEECNgIACyAFQRBqJAAgAygCmAhBAkYNBCADQagFaiADQaAIaiICKQIANwMAIAMgAykCmAg3A6AFAkAgEUICUgRAIAMgETcDmAggAiAHQZAB/AoAAAwBCyADQZgIahCiEgsgA0HQBmogA0GoBWopAwA3AwAgAyADKQOgBTcDyAYgA0GwBWoiAiADQZgIakGYAfwKAAAgAEGIBGoiCCACQbwB/AoAACAAQQA6AMQFIABBxAVqIQoMCAsgAEGIBGohCCAAQcQFaiEKIAAtAMQFQQFrDgMEAAEHCwALIAAoAsAFIQQMBgtBnN3CABDoKwALQcnGwgBBGhCXPQALQczbwgAQ6CsAC0Gs3cIAEOgrAAtB3MjCABDoKwALIABBADoAxQUgAEEBOgDHBSADQfgGaiINIABBqAVqKQIANwMAIAMgACkCoAU3A/AGIANBgAdqIg4gCEGYAfwKAAAgAEEBOgDGBSMAQRBrIgUkABApIRIQ3xIiAiASJgEgBUEIahDOLUEBIQQgA0EYaiIGAn8gBSgCCEEBcQRAIAUoAgwMAQtBACEEIAILNgIEIAYgBDYCACAFQRBqJAAgAygCGCECIAAgAygCHCIENgK0BSAAIAI2ArAFIAJBAXENASAAIAQ2ArgFIABBuAVqIg8oAgAlARAoIRIQ3xIiBiASJgEjAEEgayIFJAAgBUEMaiECIwBBEGsiBCQAIAQgBjYCDCMAQRBrIgckACAEQQxqKAIAJQEQISESEN8SIgkgEiYBIAkhECAHQQhqEM4tQQEhCSAEAn8gBygCCEEBcQRAIAcoAgwMAQtBACEJIBALNgIEIAQgCTYCACAHQRBqJAAgBCgCBCEHAkAgBCgCAEEBcUUEQCAGQYQBTwRAIAYQ8h8LIAJBADYCECACQgA3AgggAiAHNgIEIAJBATYCAAwBCyACIAY2AgggAiAHNgIEIAJBAjYCAAsgBEEQaiQAIAUoAgwiBEECRgRAQY3ZwwBBGhCXPQALIAUpAhAhESADQZgNaiICIAUpAhg3AgwgAiARNwIEIAIgBDYCACAFQSBqJAAgDygCACUBECchEhDfEiICIBImASAAIAI2ArwFIABBAToAxQUgA0EQaiEEAkBBOEEEEK02IgIEQCACQQA6ADQgAkEAOgAwIAJBADYCKCACQQA6ACQgAkEANgIcIAJBADoAGCACQQc2AgggAkKCgICAEDcCACAEIAI2AgQgBCACNgIADAELQQRBOBCjPQALIAMoAhQhBCADKAIQIQUgAEEAOwHGBSADQbgJaiANKQMANwMAIAMgAykD8AY3A7AJIANBmAhqIgYgDkGYAfwKAABBiApBCBCtNiICRQ0FIAIgBkGUBfwKAAAgAkEAOgCwBSACIAU2ApQFIAJBlMfCABDUGiAAIAQ2AsAFCyADQZgIaiEFIwBBEGsiBiQAAkACQCAEQQhqIgItACwNACAGQQhqIAEoAgAiASgCBCABKAIAKAIAEQAAIAItABwgBigCDCEBIAYoAgghByACQQE6ABxFBEAgAigCFCIJBEAgAigCGCAJKAIMEQMACyACQQA6ABwgAiABNgIYIAIgBzYCFCACLQAsDQEgBUEINgIADAILIAEgBygCDBEDAAsgAi0AECACQQE6ABBFBEAgAigCACEBIAJBBzYCACABQQdHBEAgBSABNgIAIAJBADoAECAFIAIpAgQ3AgQgBUEMaiACQQxqKAIANgIADAILIAJBADoAEAsgBUEHNgIACyAGQRBqJAAgAygCmAgiAUEIRg0CIAMpAqAIIREgAygCnAghBCAAQcAFahCtLCABQQdGDQUgAUEGRw0BIAAoArwFIQQMBgsgA0GYCGpBIEEAQQFBARCgGCADKAKcCCEEIAMoApgIQQFGDQIgAygCoAgiAUEYakHE28IAKQAANwAAIAFBEGpBvNvCACkAADcAACABQQhqQbTbwgApAAA3AAAgAUGs28IAKQAANwAAIAGtQoCAgICABIQhEUEEIQEMBgsgAC0AxQVBAXFFDQQgACgCvAUiAkGEAUkNBCACEPIfDAQLIAtBAzoAACAKQQM6AABBAiECDAULIAQgAygCoAhB/NnCABD9LwALQQhBiAoQoz0AC0HEysIAQSsgA0GYCGpBtMrCAEHc28IAENUeAAsgAEEAOgDFBSAAKAK4BSICQYQBSQ0AIAIQ8h8LAkAgACgCsAVFDQAgACgCtAUiAkGEAUkNACACEPIfCwJAIAAtAMYFQQFHDQAgAykDgAdCAlENACADQYAHahCgKQtBACECIABBADoAxgUgAC0AxwUEQCADQfAGahD5JQsgAEEAOgDHBSAAQQE6AMQFIAgQ1R8gAUEGRwRAIAMgETcCoAggAyAENgKcCCADIAE2ApgIIANBmAhqENMZIQRBASECCyALQQE6AAALAkAgAkECRgRAQQMhASAAQQM6ANgFDAELIAwQyikgAEEBOgDYBQJAIAJBAXEEQCADIAQ2ArgBIANBgAE2ApgIIAMgAEHkBWogA0GYCGogA0G4AWoQwiMgAygCACADKAIEENYvIgFBhAFPBEAgARDyHwsgAygCmAgiAUGEAU8EQCABEPIfCyADKAK4ASIBQYQBSQ0BIAEQ8h8MAQsgAyAENgK4ASADQYABNgKYCCADQQhqIABB4AVqIANBmAhqIANBuAFqEMIjIAMoAgggAygCDBDWLyIBQYQBTwRAIAEQ8h8LIAMoApgIIgFBhAFPBEAgARDyHwsgAygCuAEiAUGEAUkNACABEPIfCyAAKALgBSIBQYQBTwRAIAEQ8h8LQQEhASAAKALkBSIEQYQBSQ0AIAQQ8h8LIAAgAToA6AUgA0GwDWokACACQQJGC9ULAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwAAgL9eRSAPQwAAgEddRXJFBEAgByAP/AE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwAAgL9eRSAPQwAAgEddRXJFBEAgByABQQF0aiAP/AE7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvjCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQJ0IgQhAwJAIARBPHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAAAAAAADwv2RFIA9EAAAAAAAA8EFjRXJFBEAgByAPqzYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBBY0VyRQRAIAcgAUECdGogD6s2AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQxx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvjCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQJ0IgQhAwJAIARBPHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAACAAAADgwWRFIA9EAAAAAAAA4EFjRXJFBEAgByAPqjYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKwMAIg9EAAAgAAAA4MFkRSAPRAAAAAAAAOBBY0VyRQRAIAcgAUECdGogD6o2AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQvx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvlCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQF0IgQhAwJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAAAAAAADwv2RFIA9EAAAAAAAA8EBjRXJFBEAgByAP/AM7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEIaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQN0aisDACIPRAAAAAAAAPC/ZEUgD0QAAAAAAADwQGNFckUEQCAHIAFBAXRqIA/8AzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRDNHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9MLAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBA3QiBCEDAkAgBEE4cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwAAAN9gRSAPQwAAAF9dRXJFBEAgByAPrjcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAEQQRqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBAnRqKgIAIg9DAAAA32BFIA9DAAAAX11FckUEQCAHIAFBA3RqIA+uNwMADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENYdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL5QsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEBdCIEIQMCQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKwMAIg9EAAAAACAA4MBkRSAPRAAAAAAAAOBAY0VyRQRAIAcgD/wCOwEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGorAwAiD0QAAAAAIADgwGRFIA9EAAAAAAAA4EBjRXJFBEAgByABQQF0aiAP/AI7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvTCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQN0IgQhAwJAIARBOHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQqAgAiD0MAAIC/XkUgD0MAAIBfXUVyRQRAIAcgD683AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwAAgL9eRSAPQwAAgF9dRXJFBEAgByABQQN0aiAPrzcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9ULAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwABAMdeRSAPQwAAAEddRXJFBEAgByAP/AA7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwABAMdeRSAPQwAAAEddRXJFBEAgByABQQF0aiAP/AA7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvSCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUqAgAiD0MAAADPYEUgD0MAAABPXUVyRQRAIAcgD6g2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0IgRqKgIAIg9DAAAAz2BFIA9DAAAAT11FckUEQCAEIAdqIA+oNgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEL8dIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEDdCIFIQMCQCAFQThxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBDY0VyRQRAIAcgD7E3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEIaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQN0IgRqKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBDY0VyRQRAIAQgB2ogD7E3AwAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDkGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQ2R0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvSCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUqAgAiD0MAAIC/XkUgD0MAAIBPXUVyRQRAIAcgD6k2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0IgRqKgIAIg9DAACAv15FIA9DAACAT11FckUEQCAEIAdqIA+pNgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEDdCIFIQMCQCAFQThxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKwMAIg9EAAAAAAAA4MNmRSAPRAAAAAAAAOBDY0VyRQRAIAcgD7A3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEIaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQN0IgRqKwMAIg9EAAAAAAAA4MNmRSAPRAAAAAAAAOBDY0VyRQRAIAQgB2ogD7A3AwAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDkGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQ1h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvCCwIMfwF+IwBB0ABrIgQkACABKQMAIRACQAJAAkACQAJAAkACQCACKAIAQYCAgIB4RgRAIBBCBFENAQwHCyAQQgRRDQYgAS8BSCACLwEgRw0CIAIoAgghCCAEQSBqIAEgAiADEJkQIAQoAighBSAEKAIkIQYgBCgCICIBQQhHBEAgACAEKQIsNwIMIABBFGogBEE0aigCADYCACAAIAU2AgggACAGNgIEIAAgATYCAAwGCyACQQxqIQsCQCACKAIcIAVqIgEgAigCECIDQQN0TQ0AIAFBA3YgAUEHcUEAR2oiASADTQ0AIAsgA0EBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiASABIANJGxDoGQsgCCACKAIIIgFLDQEgASAIRwRAIAFBAXQgCEEBdCIBayEIIAIoAgQgAWohAQNAIAIvASAgAS8BACACKAIcIgxBAWoiDUEDdiANQQdxQQBHaiIDIAIoAhgiB0sEQCADIAdrIQkgAigCECIKIANJBEAgCyAKQQF0IgcgA0HA////A3FBQGsgAyADQT9xGyIKIAcgCksbEOgZIAIoAhghBwsgCQRAIAIoAhQgB2pBACAJ/AsACyACIAM2AhgLIAIgDTYCHEYEQCACKAIUIAxBA3ZqIgMgAy0AAEEBIAxBB3F0cjoAAAsgAUECaiEBIAhBAmsiCA0ACwsgACAFNgIIIAAgBjYCBCAAQQg2AgAMBQsgAS8BSEEBRw0CIAJBBGohCyACKAIUIQ4gA0UEQAwECyABQQhqIQ8DQAJAAkACQAJAAkAgASgCHCIGRQRAIAEoAiAiBSABKAIkIgZHDQEgASgCGCABKAIQRg0KIARBIGogDxD7CiAEKAIgIgVBCEYNBSAAIAQpAyg3AwggAEEQaiAEQTBqKQMANwMAIAAgBCgCJDYCBCAAIAU2AgAMCwsgAigCFCIJIAMgCGsiBSAGIAUgBkkbIg1qIgxBA3YgDEEHcSIHQQBHaiEFIAEtAChFBEAgAigCECIHIAVJBEAgBSAHayEJIAIoAggiCiAFSQRAIAsgCkEBdCIHIAVBwP///wNxQUBrIAUgBUE/cRsiCiAHIApLGxDoGSACKAIQIQcLIAkEQCACKAIMIAdqQQAgCfwLAAsgAiAFNgIQCyACIAw2AhQMBAsgCUEHcSIJRQ0CIARBGGogCxCGPSAEKAIcIgZFDQEgBCgCGCAGakEBayIGRQ0BIAYgBi0AAEF/IAl0cjoAAAwCCyALIAEoAhgiDEEDdCAGaiINIA0gAyAIayIHIAUgBmsiCSAHIAlJGyIHaiABKAIMIAEoAhAQvxggASAGIAdqIgY2AiQgByAIaiEIIAUgBkcNAyABIAwgBUEDdmo2AhgMAwtB0J/QABCyOwALAkAgBSACKAIQIgZNDQAgBSAGayEJIAIoAggiCiAFSQRAIAsgCkEBdCIGIAVBwP///wNxQUBrIAUgBUE/cRsiCiAGIApLGxDoGSACKAIQIQYLIAlFDQAgAigCDCAGakH/ASAJ/AsACyACIAU2AhACQCAHRQ0AIARBEGogCxCGPQJAIAQoAhQiBUUNACAEKAIQIAVqQQFrIgVFDQAgBSAFLQAAQX8gB3RBf3NxOgAADAELQeCf0AAQsjsACyACIAw2AhQgASgCHCEGCyABIAYgDWs2AhwgCCANaiEICyADIAhHDQALIAMhCAwDCyAIIAFB9M3QABCvOwALIARBADYCICABQcgAaiACQSBqIARBIGpB5M3QABCHKwALIARBADYCICABQcgAakG4zNAAIARBIGpBhM7QABCHKwALIARBCGogCxCGPSAEQSBqIgEgBCgCCCAEKAIMIA4gCBDQCCABENcjIQEgACAINgIIIAAgATYCBCAAQQg2AgALIARB0ABqJAAPCyAEQQA2AjAgBEEBNgIkIARB1M7QADYCICAEQgQ3AiggBEEgakHcztAAEO8sAAvDCwMJfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKwMAIg5EAAAAAAAgYMBkRSAORAAAAAAAAGBAY0VyRQRAIAMgCGogDvwCOgAADAELIAJBGGogAkEsahCGPSADQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gA0EHcXdxOgAAIAVBAWohBQsgAUEIaiEBIAQgA0EBaiIDRw0ACwwECyAJBEAgAkH4AGogCSAKIAcgBBC/FCACQZgBaiEDIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0JIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNByACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEDdGorAwAiDkQAAAAAACBgwGRFIA5EAAAAAAAAYEBjRXJFBEAgASAIaiAO/AI6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALswsDCX8DfgF9IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASoCACIOQwAAgL9eRSAOQwAAgENdRXJFBEAgAyAIaiAO/AE6AAAMAQsgAkEYaiACQSxqEIY9IANBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiADQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgBCADQQFqIgNHDQALDAQLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aioCACIOQwAAgL9eRSAOQwAAgENdRXJFBEAgASAIaiAO/AE6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALswsDCX8DfgF9IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASoCACIOQwAAAcNeRSAOQwAAAENdRXJFBEAgAyAIaiAO/AA6AAAMAQsgAkEYaiACQSxqEIY9IANBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiADQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgBCADQQFqIgNHDQALDAQLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aioCACIOQwAAAcNeRSAOQwAAAENdRXJFBEAgASAIaiAO/AA6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALwwsDCX8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASsDACIORAAAAAAAAPC/ZEUgDkQAAAAAAABwQGNFckUEQCADIAhqIA78AzoAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKwMAIg5EAAAAAAAA8L9kRSAORAAAAAAAAHBAY0VyRQRAIAEgCGogDvwDOgAADAELIAJBEGogAkEsahCGPSABQQN2IgQgAigCFCIGSQRAIAIoAhAgBGoiBCAELQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgBCAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEACwwDC0HUiv8AQSNB+Ir/ABDLJAALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhByACKAJMIQMgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAM2AnwgAiAHNgJ4IAJBCGogBBDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASAEEMEdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+oUAgp/BH4jAEHQAmsiByQAAkACQAJAAkACQAJAAkACQCACEPMtLQAAQSJGBEAgB0EcaiIIIAIQwy0gB0EQaiAIEO88IAcoAhRFDQEgBygCECEPIAdBCGogCBDvPCAHKAIMRQ0DIAdBuAJqIAcoAggiCEEYahDFBiAIKAIoIQogCCgCJCELIAdBxAJqIAgQvhUgB0GgAmogCEEMahCACyAIKAIsIgkEQCAJIAkoAgAiDEEBajYCACAMQQBIDQMgCCgCQCEMIAgoAjwhDSAIKAI4IQ4gCCgCNCEQIAgoAjAhCAsgB0HgAWogB0HAAmooAgA2AgAgB0HIAWogB0HMAmooAgA2AgAgB0HUAWogB0GoAmooAgA2AgAgByAHKQK4AjcD2AEgByAKNgLoASAHIAs2AuQBIAcgBykCxAI3A8ABIAcgBykCoAI3AswBIAcgDDYCgAIgByANNgL8ASAHIA42AvgBIAcgEDYC9AEgByAINgLwASAHIAk2AuwBIAcgB0HAAWoiCRCgASAHIAcoAgQ2AmQgByAHKAIAIgg2AmAgCSAHQeAAaiADIAQgBSAGEPcCIAcoAsABIglBk4CAgHhHBEAgACAHKQLEATcCBCAAQQxqIAdBzAFqKQIANwIAIAAgCTYCAAwICyAGKAIEIgggBigCDEYEQCAHQQE2AsQBIAdB1Mz+ADYCwAEgB0IBNwLMASAHQYQBNgLIAiAHIAFBNGo2ArgCIAcgB0HEAmo2AsgBIAcgB0G4Amo2AsQCIAdBpAJqIAdBwAFqEJkOIAcpAqQCIREgACAHKQKsAjcCDCAAIBE3AgQgAEGMgICAeDYCACAHKAJgIQgMCAsgBiAIQQhqNgIEIAdBwAFqIQYgCCkDACERIAUtAAUhDEEAIQkjAEGwAmsiASQAIAEgETcDGCABQSBqIgggAhDDLSABQRBqIAgQ7zwCQAJAAkAgASgCFARAIAQoAgxFDQEgASgCECEIIAQoAgAiCkHQAGshDSAEKAIEIgsgBEEQaiABQRhqEI0OIhKncSECIBJCGYhC/wCDQoGChIiQoMCAAX4hFANAIAIgCmopAAAiEyAUhSISQn+FIBJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiElBFBEADQCARIA1BACASeqdBA3YgAmogC3FrIg5B0ABsaikDAFENBSASQgF9IBKDIhJQRQ0ACwsgEyATQgGGg0KAgYKEiJCgwIB/g1BFDQIgAiAJQQhqIglqIAtxIQIMAAsAC0EAQQBB8ND+ABDDIQALIAFB7AFqIgIgAUEgakHEAPwKAAAgAUGoAWoiCCAEIBEgAhCmCyABKAKoAUGAgICAeEcEQCAIEP4mCyAGQYGAgIB4NgIADAELIAFBCGogCiAOQdAAbGpByABrEO88AkAgASgCDARAQYCAgIB4IQICQCABKAIIIgkgCBCiEQ0AAn8CQAJAIAkoAiQiCiAIKAIkIgtHBEAgCiALSw0BIAFB7AFqIgIgCEEAIAoQ1gggAiAJEI0+IAIQ/iZFDQEgDEUNAiABQeQAaiAIIAkoAiQiCSAIKAIkIAlrENYIIAIgAUEgakHEAPwKAAAgAUGoAWoiCCAEIBEgAhCmCyABKAKoAUGAgICAeEcEQCAIEP4mCyAGIAFB5ABqQcQA/AoAAAwHCyAJIAgQjT4NAwsgBC0ALEUEQCABQewBaiICIAFBIGpBxAD8CgAAIAFBqAFqIgggBCARIAIQpgsgASgCqAFBgICAgHhHBEAgCBD+JgsgBkGCgICAeDYCAAwGC0GUASECIAFB7AFqQZQBQQBBAUEBEKAYIAEoAvABIQQgASgC7AFBAUYNBCABKAL0ASIIQdzP/gBBlAH8CgAAIAYgCDYCDCAGIAQ2AgggBkGNgICAeDYCBEEQDAELIAQtACxFBEAgAUHsAWoiAiABQSBqQcQA/AoAACABQagBaiIIIAQgESACEKYLIAEoAqgBQYCAgIB4RwRAIAgQ/iYLIAZBgoCAgHg2AgAMBQsgBkEIaiEEIwBBEGsiAiQAIAJBBGpBlAFBAEEBQQEQoBggAigCCCEIAkAgAigCBEEBRwRAIAIoAgwiCUHcz/4AQZQB/AoAACAEQZQBNgIIIAQgCTYCBCAEIAg2AgAgAkEQaiQADAELIAggAigCDEGoyf4AEP0vAAtBjYCAgHghAkEECyAGaiACNgIAQYOAgIB4IQILIAYgAjYCACABQSBqEP4mDAILQQBBAEGA0f4AEMMhAAsgBCABKAL0AUGoyf4AEP0vAAsgAUGwAmokACAHQcQBaiEBAkACQCAHKALAASICQYOAgIB4RgRAIAdB+ABqIAFBEGooAgAiAjYCACAHQfAAaiABQQhqKQIAIhE3AwAgByABKQIAIhI3A2ggAEEQaiACNgIAIABBCGogETcCACAAIBI3AgAgBygCYCIAIAAoAgAiAEEBazYCACAAQQFGDQEMCQsgB0HoAGogAUHAAPwKAAACQAJAAkBBAyACQYCAgIB4cyACQQBOG0EBaw4DAQEACQsgByACNgLAASAHQcQBaiAHQegAakHAAPwKAAAgB0GgAmogESAHQcABaiIBIAVBARCDAyAHQZACaiICIAdBrAJqKQIANwMAIAdBmAJqIgQgB0G0AmooAgA2AgAgByAHKQKkAjcDiAIgBygCoAIiBUGAgICAeEcNAyAAIAcpA4gCNwIAIABBEGogBCgCADYCACAAQQhqIAIpAwA3AgAgARD+JgwBCyAHQcABaiARIA8gBUEAEIMDIAdBsAFqIgEgB0HMAWopAgA3AwAgB0G4AWoiAiAHQdQBaigCADYCACAHIAcpAsQBNwOoASAHKALAASIEQYCAgIB4RwRAIAMoAggiAiADKAIARgRAIANBnMz+ABCRKAsgAygCBCACQRhsaiIBIAcpA6gBNwIEIAEgBDYCACABQQxqIAdBsAFqKQMANwIAIAFBFGogB0G4AWooAgA2AgAgAyACQQFqNgIIDAgLIAAgBykDqAE3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAsgBygCYCIAIAAoAgAiAEEBazYCACAAQQFHDQgLIAdB4ABqELsjDAcLIAMoAggiAiADKAIARgRAIANBrMz+ABCRKAsgAygCBCACQRhsaiIBIAcpA4gCNwIEIAEgBTYCACABQQxqIAdBkAJqKQMANwIAIAFBFGogB0GYAmooAgA2AgAgAyACQQFqNgIIIAdBwAFqEP4mDAQLIAdBwAFqIAIgAyAEIAUgBhD3AiAHKALAASIBQZOAgIB4Rg0EIAAgBykCxAE3AgQgAEEMaiAHQcwBaikCADcCACAAIAE2AgAMBwtBAEEAQfzL/gAQwyELAAtBAEEAQYzM/gAQwyEACyAHKAJgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAHQeAAahC7IwsgB0EcahD+JgsgAEGTgICAeDYCAAwCCyAHQRxqEP4mDAELIAggCCgCACIAQQFrNgIAIABBAUYEQCAHQeAAahC7IwsgB0EcahD+JgsgB0HQAmokAAu/CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEBdCIEIQMCQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxCgIACfEL//wNYBEAgByAMPQEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEKAgAJ8Qv//A1gEQCAHIAFBAXRqIAw9AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvHCwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxCgICAgAh8Qv////8PWARAIAcgDD4CAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKQMAIgxCgICAgAh8Qv////8PWARAIAcgAUECdGogDD4CAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRC/HSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC78LAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUGAgAJqQf//A00EQCAHIAE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQYCAAmpB//8DTQRAIAcgAUEBdGogBDsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7MLAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAcgAa03AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQQBOBEAgByABQQN0aiAErTcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC64OAQR/IwBBoAFrIgYkACAGIAI2AiggBiABNgIkIAYgBTYCLCAGQRhqIAZBJGoQwzQCQAJAAkACQAJAIAYoAhwiASADKAIIIgJGBEACQAJAIAQoAgAEQCAEKAIQIgIgBUcNAQsgBkEIaiAGQSRqEMM0IAMoAgQhBSAGKAIMIQcgBiAGKAIIIgI2AogBIAYgAiAHQQJ0ajYCjAEgASAGQYgBahCeNiIHIAEgB0kbIgFFDQUMAQsgBiACNgIwIAZBAjYCjAEgBkHY84UBNgKIASAGQgI3ApQBIAZBOzYCVCAGQTs2AkwgBiAGQcgAajYCkAEgBiAGQTBqNgJQIAYgBkEsajYCSCAAQQhqIAZBiAFqEJkOIABCgICAgNiBgICAfzcCAAwFCwNAIAIoAgBBMGogBSgCACAFQQRqIgcoAgAiCCgCCEEBa0F4cWpBCGogCCgCHBEEABDGCEUNAyAFKAIAIAcoAgAiCCgCCEEBa0F4cWpBCGogCCgCJBEEACAGKAIsRw0CAkAgAigCAC0ASA0AIAZBMGogBSgCACAHKAIAIgcoAghBAWtBeHFqQQhqIAcoAjgRAAAgBigCMEUNACAGQdgAaiAGQUBrKQIANwMAIAZB0ABqIAZBOGopAgA3AwAgBiAGKQIwNwNIAkACQCAEKAIABEAgBCAGQcgAahDiCA0CIAYoAlwNAQwCCyAGKAJcRQ0BCyACKAIAIQEgBkHKBDYCaCAGQaD0hQE2AogBIAZCATcClAEgBiABQTxqNgJsIAYgBkHsAGo2AmQgBiAGQeQAajYCkAEgBkEBNgKMASAAQQhqIQUjAEEQayIBJAAgBkGIAWoiAigCDCEHAkACQAJAAkACQAJAAkAgAigCBA4CAAECCyAHDQFBASEHQQAhAgwCCyAHDQAgAigCACIHKAIEIQIgBygCACEHDAELIAUgAhCZDgwBCyABQQRqIAJBAEEBQQEQoBggASgCCCEIIAEoAgRBAUYNASABKAIMIQkgAgRAIAkgByAC/AoAAAsgBSACNgIIIAUgCTYCBCAFIAg2AgALIAFBEGokAAwBCyAIIAEoAgxBpO6FARD9LwALIABCgICAgNiBgICAfzcCACAGKAJIIgAgACgCACIAQQFrNgIAIABBAUcNByAGQcgAahD7HgwHCyAGKAJIIgcgBygCACIHQQFrNgIAIAdBAUcNACAGQcgAahD7HgsgAkEEaiECIAVBCGohBSABQQFrIgENAAsMAwsgBkEQaiAGQSRqEMM0IAYgBigCFDYCZCAGIAI2AjAgBkECNgKMASAGQfj1hQE2AogBIAZCAjcClAEgBkE7NgJUIAZBOzYCTCAGIAZByABqNgKQASAGIAZBMGo2AlAgBiAGQeQAajYCSCAAQQhqIAZBiAFqEJkOIABCgICAgNiBgICAfzcCAAwDCyAGIAIoAgBBPGo2AmQgBiAFKAIAIAVBBGooAgAiASgCCEEBa0F4cWpBCGogASgCJBEEADYCMCAGQQM2AkwgBkHg9IUBNgJIIAZCAzcCVCAGQTs2ApwBIAZBOzYClAEgBkHKBDYCjAEgBiAGQYgBajYCUCAGIAZBMGo2ApgBIAYgBkEsajYCkAEgBiAGQeQAajYCiAEgAEEIaiAGQcgAahCZDiAAQoCAgIDYgYCAgH83AgAMAgsgBiACKAIAIgFBPGo2AmwgBiABQTBqNgJkIAYgBSgCACAFQQRqKAIAIgEoAghBAWtBeHFqQQhqIAEoAhwRBAA2AjAgBkEDNgJMIAZBpPWFATYCSCAGQgM3AlQgBkGnBDYCnAEgBkGnBDYClAEgBkHKBDYCjAEgBiAGQYgBajYCUCAGIAZBMGo2ApgBIAYgBkHkAGo2ApABIAYgBkHsAGo2AogBIABBCGogBkHIAGoQmQ4gAEKAgICA2IGAgIB/NwIADAELIAYoAighAiAGKAIkIQcCQCAEKAIAIgVFBEBBACEFDAELIAZBlAFqIARBBGoiAUEIaiIEKQIANwIAIAZBnAFqIAFBEGoiCCgCACIJNgIAIAYgBTYCiAEgBiABKQIANwKMASAJRQRAIAUgBSgCACIBQQFrNgIAQQAhBSABQQFHDQEgBkGIAWoQ+x4MAQsgBkGAAWogCCgCADYCACAGQfgAaiAEKQIANwMAIAYgASkCADcDcAsgACAFNgIcIAAgBigCLDYCGCAAIAI2AhQgACAHNgIQIABBIDoADCAAIAYpA3A3AiAgACADKQIANwIAIABBCGogA0EIaigCADYCACAAQShqIAZB+ABqKQMANwIAIABBMGogBkGAAWooAgA2AgAMAQsCQCAEKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAQQ+x4LIAMQwycgA0EEQQgQ4B4gBigCJCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEkahCFHQsgBkGgAWokAAuWrAIDIH8DfgF8IwBBkAVrIg4kACAOQQA2AgwgDkKAgICAEDcCBCMAQfADayIFJAAgBUGwAWoQzzUCQCADKQMAQgJSBEAgBUHYAmogA0GYAfwKAAAMAQsgBUHYAmoQshILIAVBCGoiCSAFQbABaiAFQdgCahDrHyMAQfADayIDJAAgAyACNgIEIANBCGogCUGYAfwKAAAgAyADLQCfAToArAEgA0EMNgKoASADQciBwwA2AqQBIAkoApgBQYCAgIB4RwRAIAMgCSkCnAE3AqQBCyAOQQRqIQggDkHoA2ohBiAJQZgBaiEUIANB0AFqIANBpAFqIAJBCGoiDRDQCgJAAkACQAJAAkACQCADKALQAUEBRgRAIANB/AJqIANB6AFqKQMAIiQ3AgAgA0H0AmogA0HgAWopAwAiJTcCACADIAMpA9gBIiY3AuwCIAZBGGogJDcCACAGQRBqICU3AgAgBiAmNwIIIAZBgICAgHg2AgAgA0EIahDMLAwBCyADQbgBaiADQdwBaikCADcDACADQcABaiADQeQBaikCADcDACADQcgBaiADQewBaigCADYCACADIAMpAtQBNwOwASAJLQCkAUUEQCANIANBCGoQ3g4LIAMoApgBIRMgA0HQAWoiDSADQQhqQZgB/AoAAEGgAUEIEK02IgRFDQMgBEKBgICAEDcDACAEQQhqIA1BmAH8CgAAIAMgBDYCzAEgA0GwAWoQ2i0hCiAEIAQoAgAiCUEBajYCACAJQQBIDQQjAEHgAGsiCSQAIAkgBDYCECAJIAo2AgwjAEEQayIHJAAgB0EEakGAwABBAEEBQQEQoBggBygCCCESIAcoAgRBAUYEQCASIAcoAgxB0IbDABD9LwALIAcoAgwhFSAJQRRqIhEgCDYCECARQQA6AAwgEUEANgIIIBEgFTYCBCARIBI2AgAgB0EQaiQAIAlBADYCKCAKIAooAgAiB0EBajYCAAJAAkAgB0EATgRAIAlBLGoiFSAKEKUSIAlByABqIRIjAEEQayIHJAAgB0EIaiIPIBFBxL7DAEEEEKgaAkACQCAHLQAIQQRGDQAgBykDCCIkQv8Bg0IEUQ0AIAcgJDcDCCASIA8QgSsMAQsgEkEINgIACyAHQRBqJAACQCAJKAJIIgdBCEcEQCANIAkpAkw3AgwgDUEcaiAJQdwAaigCADYCACANQRRqIAlB1ABqKQIANwIAIA1BgICAgHg2AgAgDSAHNgIIIBUQ/iggERDUKSAREN47IAQgBCgCACINQQFrNgIAIA1BAUYEQCAJQRBqEK4gCyAJKAIMIg0gDSgCACINQQFrNgIAIA1BAUcNASAJQQxqEIMgDAELIAlB2ABqIgcgCUEkaikCADcDACAJQdAAaiISIAlBHGopAgA3AwAgCSAJKQIUNwNIQSRBBBCtNiIRRQ0CIBFCgYCAgBA3AgAgESAJKQIsNwIIIA0gCSkDSDcCACARQRBqIAlBNGopAgA3AgAgEUEYaiAJQTxqKQIANwIAIBFBIGogCUHEAGooAgA2AgAgDUEIaiASKQMANwIAIA1BEGogBykDADcCACANQQA6AGQgDUEANgJgIA0gBDYCXCANIBE2AlggDSAKNgJUIA1BADYCUCANQoCAgIDAADcDSCANQgQ3A0AgDUIANwM4IA1CgICAgMAANwMwIA1CBDcDKCANQgA3AyAgDUKAgICAgAE3AxgLIAlB4ABqJAAMAgsAC0EEQSQQoz0ACyADKALQASIJQYCAgIB4Rw0BIANB5ANqIANB6AFqKQMAIiQ3AgAgA0HcA2ogA0HgAWopAwAiJTcCACADIAMpA9gBIiY3AtQDIAZBGGogJDcCACAGQRBqICU3AgAgBiAmNwIIIAZBgICAgHg2AgAgBCAEKAIAIgJBAWs2AgAgAkEBRgRAIANBzAFqEK4gCyADQbABahD+KCADKAIEIQILIBQQhjAgAiACKAIAIgJBAWs2AgAgAkEBRw0BIANBBGoQ+CMMAQsgA0HoA2oiDSADQewBaigCADYCACADQeADaiIRIANB5AFqKQIANwMAIANB2ANqIgcgA0HcAWopAgA3AwAgAyADKQLUATcD0AMgA0HoAmoiCiADQfABakHIAPwKAAAgA0G4A2oiEiAHKQMANwMAIANBwANqIgcgESkDADcDACADQcgDaiIRIA0oAgA2AgAgAyADKQPQAzcDsAMgAiACKAIAIg1BAWo2AgAgDUEASA0CIAYgAykDsAE3AmggBiADKQOwAzcCBCAGQYABaiADQcgBaigCADYCACAGQfgAaiADQcABaikDADcCACAGQfAAaiADQbgBaikDADcCACAGQQxqIBIpAwA3AgAgBkEUaiAHKQMANwIAIAZBHGogESgCADYCACAGQSBqIApByAD8CgAAIAYgEzYCpAEgBiACNgKgASAGQYCAgIB4NgKMASAGIAQ2AogBIAYgAjYChAEgBiAJNgIAIBQQhjALIANB8ANqJAAMAgtBCEGgARCjPQsACyAFQfADaiQAAkAgDigC6AMiAkGAgICAeEYEQCAOQeQCaiAOQYAEaikDACIkNwIAIA5B3AJqIA5B+ANqIgIpAwAiJTcCACAOIA4pA/ADIiY3AtQCIAIgJDcDACAOQfADaiAlNwMAIA4gJjcD6AMgACAGEMgmIAgQ3jsgARDlIAwBCyAOQegCaiIDIA5BhARqKAIANgIAIA5B4AJqIgkgDkH8A2opAgA3AwAgDkHYAmoiBiAOQfQDaikCADcDACAOIA4pAuwDNwPQAiAOQbgBaiINIA5BiARqQYgB/AoAACAOQRxqIAYpAwA3AgAgDkEkaiAJKQMANwIAIA5BLGogAygCADYCACAOIAI2AhAgDiAOKQPQAjcCFCAOQTBqIA1BiAH8CgAAIA5ByAJqIAFBCGopAgA3AwAgDiABKQIANwPAAgJAAkAgDigCxAIiASAOKALMAkYNACAOQdQCaiECIA5B0ANqIQMDQCADIAFBDGopAgA3AwAgDiABQRRqNgLEAiAOIAEpAgQ3A8gDIAEoAgAiAUGAgICAeEYNASACIA4pA8gDNwIAIAJBCGogAykDADcCACAOIAE2AtACIA5BuAFqIA5BEGoiASAOQdACaiIJEPcJIA4oArgBIgZBCEcEQCAOQfwDaiAOQcwBaigCADYCACAOQfQDaiAOQcQBaikCADcCACAOIA4pArwBNwLsAyAOIAY2AugDIAAgDkHoA2oQyCYgCRDpKyAOQcACahDlICABENQpIAEQ3jsgDigCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgDkHkAGoQgyALIA4oAmgiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5B6ABqEIYfCyAOKAJsIgAgACgCACIAQQFrNgIAIABBAUYEQCAOQewAahCuIAsgDkEoaiIAENwYIAAQ7DsgDkE0aiIAELErIABBBEEMEOAeIA5BQGsiABC6KiAAQQRBDBDgHiAOQcwAaiIAELsqIABBBEEMEOAeIA5B2ABqIgAQ4CkgABDyOwJAIA4oApwBQYCAgIB4Rg0AIA5BnAFqIgAQqwEgABD0OyAOKAKoASIAIAAoAgAiAEEBazYCACAAQQFHDQAgDkGoAWoQ+CMLIA4oArABIgAgACgCACIAQQFrNgIAIABBAUYEQCAOQbABahD4IwsgDigCkAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5BkAFqEIMgCyAOQfgAaiIAEKMnIAAQ6TsgDkGEAWoQ6TsgDigClAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5BlAFqEPgjCyAOKAKYASIAIAAoAgAiAEEBazYCACAAQQFHDQMgDkGYAWoQriAMAwsgDkHQAmoQ6SsgDigCxAIiASAOKALMAkcNAAsLIA5BwAJqEOUgIA5B6ANqIhQgDkEQakGoAfwKAAAgDkG4AWohHSMAQSBrIiEkACAhQQhqIBQQ/gYCQCAhKAIIIgFBCEcEQCAdICEpAgw3AgwgHUEcaiAhQRxqKAIANgIAIB1BFGogIUEUaikCADcCACAdQQM2AgAgHSABNgIIDAELQgAhJCMAQZACayIVJAACQAJAAkACQAJAIBQtAGRFBEAgFCgCYCAUKAIgRg0CQSghASAVQZgBakEoQQBBAUEBEKAYIBUoApwBIQMgFSgCmAFBAUYNBCAVKAKgASICQZTBwwBBKPwKAAAMAQtBJSEBIBVBmAFqQSVBAEEBQQEQoBggFSgCnAEhAyAVKAKYAUEBRg0DIBUoAqABIgJBvMHDAEEl/AoAAAsgHSABNgIUIB0gAjYCECAdIAM2AgwgHUEANgIIIB1BAzYCAAwBCyAVQZgBaiEbIwBBsAFrIhIkACAUQQE6AGQCQAJAAkAgFCgCICIBBEAgFCgCHCECIAFBBnQhAwNAIBJB6ABqIBQgFCgCKCAUKAIsIAIQgAcgEigCaCIBQQhHBEAgGyASKQJsNwIMIBtBHGogEkH8AGooAgA2AgAgG0EUaiASQfQAaikCADcCACAbQQM2AgAgGyABNgIIDAMLIAJBQGshAiADQUBqIgMNAAsLAn8gFCgCXEEIahDVNCIBBEAgASgCCCECIBQoAlAhAyABKAIEIQEgEiAUKAJMIgk2AnAgEiABNgJoIBIgCSADQRhsajYCdCASIAEgAkEYbGo2AmwgEkEIaiASQegAahCpFSASKQIMISQgEigCCAwBC0GAgICAeCAUKAJQRQ0AGiASQegAaiAUQcgAahDEECASKQJsISQgEigCaAshAiASQRRqIBQoAhwiASABIBQoAiBBBnRqEKQbIBIgFCgCXEEIahDlOyASKAIAIQYgEkHoAGogEigCBCIBQQBBAUEBEKAYIBIoAmwhAyASKAJoQQFGDQEgEigCcCEJIAEEQCAJIAYgAfwKAAALIBJBKGogEkEcaigCADYCACASQQA2AlggEkEANgJQIBIgATYCQCASIAk2AjwgEiADNgI4IBIgEikCFDcDICASIBQ2AkQgEiAUQdgAajYCTCASIBRB1ABqNgJIIBJBAkEBIBQoAlwtAJ0BGzYCYCASQYCAgIB4NgIsIAJBgICAgHhHBEAgEkHoAGoiASASQSBqIgNBxAD8CgAAIBJB9ABqEIcwIBIgJDcCeCASIAI2AnQgAyABQcQA/AoAAAsgEiAUKQI0NwNQIBIgFCkCQDcDWEEAIQVCACEkIwBBkAJrIg0kACASQSBqIhooAggiAgRAIBooAgRBKGohHANAIBwpAwAgJHwhJCAcQdAAaiEcIAJBAWsiAg0ACwsCQAJAAkACQCAaKAIwIh9FDQAgDUHIAGohDyAaKAI0IRkjAEEgayIKJAACQAJAIBooAggiAUUNACAaKAIEIhEgAUHQAGxqISAgGkEkaiEWAkADQAJAIBEoAjgiAQRAIAUgGU8NAyABQegDbCEIIBEoAjRBrANqIRwgHyAFQQxsaiIYKAIIIRBBACEHQX8hEwNAIBAgE0EBaiITRg0CIBgoAgQgB2oiBCgCAEGAgICAeEcEQCAWKAIAKAIUIQsgCkEIaiEMIwBB0ABrIgMkACADIBY2AiAgA0KAgICAkICAgIB/NwIIIANCgICAgCA3AgAgA0EAOwEkIANBKGohAiMAQUBqIgEkACABQQxqQf26wgBBCxCAICABQSxqIAMQ5ycCQCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyABQSxqIglBiLvCAEEKQQ1BARDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAELIAFBLGoiCRCGMCAJIANBAiAEKAIIIgYQqxQgASgCLCIJQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIAk2AgAMAQsgBgRAIAQoAgQhCQNAIAFBLGogAyAJLQAAENAZIAEoAiwiHkEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAeNgIADAMLIAlBAWohCSAGQQFrIgYNAAsLIAMQxiEgAUEsaiIJQZK7wgBBCkENQQIQ6BwgAUEYaiADIAkQrhQgASgCGCIGQQRHBEAgAiABKQIcNwIEIAJBDGogAUEkaikCADcCACACIAY2AgAgCRCGMAwBCyABQSxqIgkQhjAgCSADQQggBCgCFCIGEKsUIAEoAiwiCUEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAJNgIADAELIAYEQCAEKAIQQQhqIQkgBkEMbCEGA0AgAUEsaiADIAlBBGsoAgAgCSgCABCnGyABKAIsIh5BBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgHjYCAAwDCyAJQQxqIQkgBkEMayIGDQALCyADEMYhIAFBLGoiCUGcu8IAQQpBDUEDEOgcIAFBGGogAyAJEK4UIAEoAhgiBkEERwRAIAIgASkCHDcCBCACQQxqIAFBJGopAgA3AgAgAiAGNgIAIAkQhjAMAQsgAUEsaiIJEIYwIAkgA0EIIAQoAiAiBhCrFCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyAGBEAgBCgCHEEIaiEJIAZBDGwhBgNAIAFBLGogAyAJQQRrKAIAIAkoAgAQpxsgASgCLCIeQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIB42AgAMAwsgCUEMaiEJIAZBDGsiBg0ACwsgAxDGISABQSxqIglBprvCAEEOQQZBBBDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAELIAFBLGoiCRCGMCAJIAMgBCgCSBCrGyABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyADEMYhIAQoAiRBgICAgHhHBEAgAUEsaiIJQbS7wgBBC0ENQQUQ6BwgAUEYaiADIAkQrhQgASgCGCIGQQRHBEAgAiABKQIcNwIEIAJBDGogAUEkaikCADcCACACIAY2AgAgCRCGMAwCCyABQSxqIgkQhjAgCSADQQcgBCgCLCIGEKsUIAEoAiwiCUEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAJNgIADAILIAYEQCAEKAIoIQkgBkEDdCEGA0AgAUEsaiADIAkpAwAQrBsgASgCLCIeQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIB42AgAMBAsgCUEIaiEJIAZBCGsiBg0ACwsgAxDGIQsgBCgCMEGAgICAeEcEQCABQSxqIglBv7vCAEEbQQ1BBhDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAILIAFBLGoiCRCGMCAJIANBByAEKAI4IgYQqxQgASgCLCIJQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIAk2AgAMAgsgBgRAIAQoAjQhCSAGQQN0IQYDQCABQSxqIAMgCSkDABCsGyABKAIsIh5BBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgHjYCAAwECyAJQQhqIQkgBkEIayIGDQALCyADEMYhCyAEKAI8QYCAgIB4RwRAIAFBLGoiCUHau8IAQRtBDUEHEOgcIAFBGGogAyAJEK4UIAEoAhgiBkEERwRAIAIgASkCHDcCBCACQQxqIAFBJGopAgA3AgAgAiAGNgIAIAkQhjAMAgsgAUEsaiIJEIYwIAkgA0EHIAQoAkQiBhCrFCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwCCyAGBEAgBCgCQCEJIAZBA3QhBgNAIAFBLGogAyAJKQMAEKwbIAEoAiwiBEEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAENgIADAQLIAlBCGohCSAGQQhrIgYNAAsLIAMQxiELIAFBLGogAxCBNiABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyACIAMQ5SgLIAFBDGoQ3jsgAUFAayQAAkAgAygCKCIBQQRHBEAgA0HIAGogA0E0aikCADcCACADIAMpAiw3AkAgAyABNgI8IAwgA0E8ahClJQwBCyAMQQg2AgALIAMQui4gA0HQAGokACAKKAIIIgJBCEcEQCAPIAopAgw3AgQgD0EUaiAKQRxqKAIANgIAIA9BDGogCkEUaikCADcCAAwICyAWKAIAKAIUIQEgHEEEa0EBNgIAIBxBlANrIAutNwMAIBxBnANrQgE3AwAgHCABIAtrNgIACyAcQegDaiEcIAdBzABqIQcgCEHoA2siCA0ACwsgBUEBaiEFICAgEUHQAGoiEUcNAQwDCwsgECAQQeCdwwAQwyEACyAFIBlB0J3DABDDIQALQQghAgsgDyACNgIAIApBIGokACANKAJIIhxBCEYNAAwBCwJAIBooAjgiHkUNACANQcgAaiEQIBooAjwhDCMAQSBrIgokAAJAAkAgGigCCCIBRQ0AIBooAgQiESABQdAAbGohIiAaQSRqIRlBACEFAkADQAJAIBEoAjgiAQRAIAUgDE8NAyARKAI0IRwgAUHoA2whCCAeIAVBDGxqIiMoAgghC0EAIQdBfyETA0AgCyATQQFqIhNGDQIgIygCBCAHaiIPKAIAQYCAgIB4RwRAIBkoAgAoAhQhHyAKQQhqISAjAEHQAGsiAyQAIAMgGTYCICADQoCAgICQgICAgH83AgggA0KAgICAIDcCACADQQA7ASQgA0EoaiEJIwBBQGoiAiQAIAJBDGpBpr3CAEELEIAgIAJBLGogAxDnJwJAIAIoAiwiAUEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSABNgIADAELIAJBLGoiAUGxvcIAQQ5BDUEBEOgcIAJBGGogAyABEK4UIAIoAhgiBkEERwRAIAkgAikCHDcCBCAJQQxqIAJBJGopAgA3AgAgCSAGNgIAIAEQhjAMAQsgAkEsaiIBEIYwIAEgA0EKIA8oAggiARCrFCACKAIsIgZBBEcEQCAJIAIpAjA3AgQgCUEMaiACQThqKQIANwIAIAkgBjYCAAwBCyABBEAgDygCBCEEIAFBGGwhFgNAIAJBLGohBiMAQUBqIgEkACABQQxqQaC/wgBBDBCAICABQSxqIAMQ5ycCQCABKAIsIhhBBEcEQCAGIAEpAjA3AgQgBkEMaiABQThqKQIANwIAIAYgGDYCAAwBCyABQSxqIhhBrL/CAEEGQQdBARDoHCABQRhqIAMgGBCuFCABKAIYIhdBBEcEQCAGIAEpAhw3AgQgBkEMaiABQSRqKQIANwIAIAYgFzYCACAYEIYwDAELIAFBLGoiGBCGMCAYIAMgBCkDABCsGyABKAIsIhhBBEcEQCAGIAEpAjA3AgQgBkEMaiABQThqKQIANwIAIAYgGDYCAAwBCyADEMYhIAFBLGoiGEGyv8IAQRRBBkECEOgcIAFBGGogAyAYEK4UIAEoAhgiF0EERwRAIAYgASkCHDcCBCAGQQxqIAFBJGopAgA3AgAgBiAXNgIAIBgQhjAMAQsgAUEsaiIYEIYwIBggAyAEKAIQEKsbIAEoAiwiGEEERwRAIAYgASkCMDcCBCAGQQxqIAFBOGopAgA3AgAgBiAYNgIADAELIAMQxiEgAUEsaiIYQca/wgBBD0EHQQMQ6BwgAUEYaiADIBgQrhQgASgCGCIXQQRHBEAgBiABKQIcNwIEIAZBDGogAUEkaikCADcCACAGIBc2AgAgGBCGMAwBCyABQSxqIhgQhjAgGCADIAQpAwgQrBsgASgCLCIYQQRHBEAgBiABKQIwNwIEIAZBDGogAUE4aikCADcCACAGIBg2AgAMAQsgAxDGISABQSxqIAMQgTYgASgCLCIYQQRHBEAgBiABKQIwNwIEIAZBDGogAUE4aikCADcCACAGIBg2AgAMAQsgBiADEOUoCyABQQxqEN47IAFBQGskACACKAIsIgFBBEcEQCAJIAIpAjA3AgQgCUEMaiACQThqKQIANwIAIAkgATYCAAwDCyAEQRhqIQQgFkEYayIWDQALCyADEMYhIA8oAgxBgICAgHhHBEAgAkEsaiIBQb+9wgBBH0ENQQIQ6BwgAkEYaiADIAEQrhQgAigCGCIGQQRHBEAgCSACKQIcNwIEIAlBDGogAkEkaikCADcCACAJIAY2AgAgARCGMAwCCyACQSxqIgEQhjAgASADQQcgDygCFCIBEKsUIAIoAiwiBkEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSAGNgIADAILIAEEQCAPKAIQIQQgAUEDdCEWA0AgAkEsaiADIAQpAwAQrBsgAigCLCIBQQRHBEAgCSACKQIwNwIEIAlBDGogAkE4aikCADcCACAJIAE2AgAMBAsgBEEIaiEEIBZBCGsiFg0ACwsgAxDGIQsgAkEsaiADEIE2IAIoAiwiAUEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSABNgIADAELIAkgAxDlKAsgAkEMahDeOyACQUBrJAACQCADKAIoIgFBBEcEQCADQcgAaiADQTRqKQIANwIAIAMgAykCLDcCQCADIAE2AjwgICADQTxqEKUlDAELICBBCDYCAAsgAxC6LiADQdAAaiQAIAooAggiAkEIRwRAIBAgCikCDDcCBCAQQRRqIApBHGooAgA2AgAgEEEMaiAKQRRqKQIANwIADAgLIBkoAgAoAhQhASAcQaADakEBNgIAIBxBCGogH603AwAgHEIBNwMAIBxBpANqIAEgH2s2AgALIAdBGGohByAcQegDaiEcIAhB6ANrIggNAAsLIAVBAWohBSAiIBFB0ABqIhFHDQEMAwsLIAsgC0GAnsMAEMMhAAsgBSAMQfCdwwAQwyEAC0EIIQILIBAgAjYCACAKQSBqJAAgDSgCSCIcQQhGDQAMAQsgDUEEaiAaKAIsKAIAQQhqKAIIEPQfIBooAgAhASAaKQIEISUgDUGAgICAeDYCECANQQI2AhwgDUGAgICAeDYCPCANICU3AsQBIA0gATYCwAEgGkEMaiEYAkAgGigCDEGAgICAeEcEQCANQcwBaiAYEMQQDAELIA1BgICAgHg2AswBCyAaKAJAIQEgDUHoAWoiAiAaKAIoKAIAQQhqEK4VIA1B4AFqIgMgDUH0AWooAgA2AgAgDSANKQLsATcD2AECQCANKALoASIJQQhGBEAgGkEYaiEcAkAgGigCGEGAgICAeEcEQCACIBwQ3SAMAQsgDUGAgICAeDYC6AELIA1BqAFqIA1BDGooAgA2AgAgDUHQAGogDUEkaikCADcDACANQdgAaiANQSxqKQIANwMAIA1B4ABqIA1BNGopAgA3AwAgDUG0AWogDUHEAGooAgA2AgAgDSANKQIENwOgASANIA0pAhw3A0ggDSANKQI8NwKsASANIAE2ArgBIA1B+ABqIA1B4AFqKAIANgIAIA1BhAFqIA1ByAFqKAIANgIAIA1BkAFqIA1B1AFqKAIANgIAIA1BnAFqIA1B8AFqKAIANgIAIA0gJDcDaCANIA0pA9gBNwNwIA0gDSkCwAE3AnwgDSANKQLMATcDiAEgDSANKQLoATcClAEgGigCJCgCFCEjIA1B6AFqIR4jAEHQAGsiASQAIAEgGkEkaiIiNgIgIAFCgICAgJCAgICAfzcCCCABQoCAgIAgNwIAIAFBADsBJCABQShqIREgDUHIAGohGSMAQUBqIgkkACAJQQxqQf69wgBBDBCAICAJQSxqIAEQ5ycCQCAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwBCyAJQSxqIgJBir7CAEEHQQZBARDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAELIAlBLGoiAhCGMCACIAEgGSgCcBCrGyAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwBCyABEMYhIAlBLGoiAkGRvsIAQQZBDUECEOgcIAlBGGogASACEK4UIAkoAhgiA0EERwRAIBEgCSkCHDcCBCARQQxqIAlBJGopAgA3AgAgESADNgIAIAIQhjAMAQsgCUEsaiICEIYwIAIgAUEKIBkoAjAiAhCrFCAJKAIsIgNBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAzYCAAwBCyACBEAgGSgCLCETIAJB4ABsIR8DQCAJQSxqIQQjAEFAaiIGJAAgBkEMakH3v8IAQQ0QgCAgBkEsaiABEOcnAkAgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgEygCAEEBRgRAIAZBLGoiAkGEwMIAQQRBBkEBEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASATKAIEEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAggEQCATKAIMIQMgBkEsaiICQYjAwgBBC0EGQQIQ6BwgBkEYaiABIAIQrhQgBigCGCIFQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAU2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIAMQqxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAgsgARDGIQsgEygCEARAIAZBLGoiAkGTwMIAQQ9BBkEDEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASATKAIUEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIAZBLGoiAkGiwMIAQQRBCEEEEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgASATKAJYIBMoAlwQpxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgARDGISATKAIYQQFGBEAgEygCHCEDIAZBLGoiAkGmwMIAQQxBBkEFEOgcIAZBGGogASACEK4UIAYoAhgiBUEERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASADEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAiAEQCAGQSxqIgJBssDCAEEOQQZBBhDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAEIAYpAhw3AgQgBEEMaiAGQSRqKQIANwIAIAQgAzYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgEygCJBCrGyAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyATKAIoBEAgEygCLCEDIAZBLGoiAkGVvMIAQQVBBkEHEOgcIAZBGGogASACEK4UIAYoAhgiBUEERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASADEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAjAEQCATKAI0IQMgBkEsaiICQZq8wgBBCUEGQQgQ6BwgBkEYaiABIAIQrhQgBigCGCIFQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAU2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIAMQqxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAgsgARDGIQsgEygCOARAIBMoAjwhAyAGQSxqIgJBwMDCAEEIQQZBCRDoHCAGQRhqIAEgAhCuFCAGKAIYIgVBBEcEQCAEIAYpAhw3AgQgBEEMaiAGQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyATKAJAQRJHBEAgBkEsaiICQcjAwgBBC0EKQQoQ6BwgBkEYaiABIAIQrhQgBigCGCIDQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAM2AgAgAhCGMAwCCyAGQSxqIgMQhjAgE0FAayEKIwBBQGoiAiQAIAJBDGpBrrzCAEELEIAgIAJBLGogARDnJwJAIAIoAiwiBUEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRAgCigCACIFQQJrIAVBAU0bQQFrDhABAgMEBQYHCAkKCwwNDg8QAAsgAkEsaiIFQbm8wgBBBkEKQQEQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwSCyACQSxqIgcQhjAjAEEgayIFJAAgBUGsucIAQQoQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDRAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMEQsgAkEsaiIFQb+8wgBBA0EKQQIQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwRCyACQSxqIgcQhjAjAEEgayIFJAAgBUG9tsIAQQcQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ8gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMEAsgAkEsaiIFQcK8wgBBBEEKQQMQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwQCyACQSxqIgcQhjAjAEEgayIFJAAgBUGmt8IAQQgQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ4gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMDwsgAkEsaiIFQca8wgBBBEEKQQQQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwPCyACQSxqIgcQhjAjAEEgayIFJAAgBUGGt8IAQQgQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ0gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMDgsgAkEsaiIFQcq8wgBBB0EKQQUQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwOCyACQSxqIgcQhjAgCkEEaiEKIwBBQGoiBSQAIAVBDGpBirzCAEELEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAVBLGoiCEGVvMIAQQVBBkEBEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggASAKKAIAEKsbIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAEQxiEgBUEsaiIIQZq8wgBBCUEGQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAooAgQQqxsgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgARDGISAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNDCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwNCyACQSxqIgVB0bzCAEEEQQpBBhDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDA0LIAJBLGoiBxCGMCMAQSBrIgUkACAFQf62wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNCyADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwMCyACQSxqIgVB1bzCAEEEQQpBBxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAwLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakGSuMIAQQgQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgBUEsaiIIQZq4wgBBD0ECQQEQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAotAAAQ0BkgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgARDGISAFQSxqIghBqbjCAEEEQQpBAhDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAELIAVBLGoiCBCGMCAIIApBAWogARCmCSAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyABEMYhIAVBLGogARCBNiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyAHIAEQ5SgLIAVBDGoQ3jsgBUFAayQAIAIoAiwiBUEERg0KIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAsLIAJBLGoiBUHZvMIAQQlBCkEIEOgcIAJBGGogASAFEK4UIAIoAhgiB0EERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAHNgIAIAUQhjAMCwsgAkEsaiIHEIYwIApBBGohCiMAQUBqIgUkACAFQQxqQf/AwgBBDRCAICAFQSxqIAEQ5ycCQCAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwBCyAFQSxqIghBmrjCAEEPQQJBARDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAELIAVBLGoiCBCGMCAIIAEgCi0AABDQGSAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwBCyABEMYhIAVBLGoiCEGpuMIAQQRBCkECEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggCkEBaiABEKYJIAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAEQxiEgBUEsaiABEIE2IAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBUEMahDeOyAFQUBrJAAgAigCLCIFQQRGDQkgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMCgsgAkEsaiIFQeK8wgBBB0EKQQoQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwKCyACQSxqIgcQhjAgCkEEaiEKIwBBQGoiBSQAIAVBDGpBprbCAEEHEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAVBLGoiCEGttsIAQQhBA0EBEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggASAKLQABEIgaIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAEQxiEgBUEsaiIIQbW2wgBBCEECQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAotAAAQ0BkgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgARDGISAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNCCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwJCyACQSxqIgVB6bzCAEEHQQpBCxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAkLIAJBLGoiBxCGMCMAQSBrIgUkACAFQa63wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNByADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwICyACQSxqIgVB8LzCAEEEQQpBDBDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAgLIAJBLGoiBxCGMCMAQSBrIgUkACAFQY63wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBiADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwHCyACQSxqIgVB9LzCAEEEQQpBDRDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAcLIAJBLGoiBxCGMCMAQSBrIgUkACAFQfa2wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBSADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwGCyACQSxqIgVB+LzCAEEEQQpBDhDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAYLIAJBLGoiBxCGMCMAQSBrIgUkACAFQca4wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwFCyACQSxqIgVB/LzCAEEHQQpBDxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAULIAJBLGoiBxCGMCMAQSBrIgUkACAFQaO8wgBBCxCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNAyADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwECyACQSxqIgVBg73CAEEHQQpBEBDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAQLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakHevcIAQQsQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgCi0AAEEBRgRAIAotAAEhCCAFQSxqIgpB6b3CAEEVQQNBARDoHCAFQRhqIAEgChCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAKEIYwDAILIAVBLGoiChCGMCAKIAEgCBCIGiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwCCyABEMYhCyAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNAiADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwDCyACQSxqIgVBir3CAEEIQQpBERDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAMLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakH5vsIAQQwQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgCigCAEGAgICAeEcEQCAFQSxqIghBhb/CAEEDQQhBARDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAILIAVBLGoiCBCGMCAIIAEgCigCBCAKKAIIEKcbIAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAILIAEQxiELIAVBLGogARCBNiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyAHIAEQ5SgLIAVBDGoQ3jsgBUFAayQAIAIoAiwiBUEERg0BIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAILIAJBLGoiBUGSvcIAQQlBCkESEOgcIAJBGGogASAFEK4UIAIoAhgiB0EERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAHNgIAIAUQhjAMAgsgAkEsaiIHEIYwIwBBQGoiBSQAIAVBDGpB4b/CAEENEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAooAghBgICAgHhHBEAgBUEsaiIIQYW/wgBBA0EIQQEQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwCCyAFQSxqIggQhjAgCCABIAooAgwgCigCEBCnGyAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwCCyABEMYhCyAKKAIABEAgBUEsaiIIQe6/wgBBCUEGQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwCCyAFQSxqIggQhjAgCCABIAooAgQQqxsgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAgsgARDGIQsgBUEsaiABEIE2IAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBUEMahDeOyAFQUBrJAAgAigCLCIFQQRGDQAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMAQsgARDGISACQSxqIAEQgTYgAigCLCIFQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyAGQSxqIAEQgTYgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgBCABEOUoCyAGQQxqEN47IAZBQGskACAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwDCyATQeAAaiETIB9B4ABrIh8NAAsLIAEQxiEgCUEsaiICQdS3wgBBCEEHQQMQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwBCyAJQSxqIgIQhjAgAiABIBkpAyAQrBsgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAQsgARDGISAJQSxqIgJBl77CAEEKQQ1BBBDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAELIAlBLGoiAhCGMCACIAFBCiAZKAI8IgIQqxQgCSgCLCIDQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAM2AgAMAQsgAgRAIBkoAjghEyACQdAAbCEfA0AgCUEsaiEKIwBBQGoiBSQAIAVBDGpBtrfCAEEIEIAgIAVBLGogARDnJwJAIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAELIAVBLGoiAkG+t8IAQQdBDUEBEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAQsgBUEsaiICEIYwIAIgAUEKIBMoAjgiAhCrFCAFKAIsIgNBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAzYCAAwBCyACBEAgEygCNCEWIAJB6ANsISADQCAFQSxqIQcjAEFAaiIGJAAgBkEMakHsucIAQQsQgCAgBkEsaiABEOcnAkAgBigCLCICQQRHBEAgByAGKQIwNwIEIAdBDGogBkE4aikCADcCACAHIAI2AgAMAQsgFigC0ANBgICAgHhHBEAgBkEsaiICQfe5wgBBCUEIQQEQ6BwgBkEYaiABIAIQrhQgBigCGCIDQQRHBEAgByAGKQIcNwIEIAdBDGogBkEkaikCADcCACAHIAM2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIBYoAtQDIBYoAtgDEKcbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIAZBLGoiAkHrt8IAQQtBB0ECEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgASAWKQPIAxCsGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwBCyABEMYhIBYpAyBCAlIEQCAGQSxqIgJBgLrCAEEJQQpBAxDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiAxCGMCAWQSBqIQ8jAEFAaiICJAAgAkEMakGMwcIAQQ4QgCAgAkEsaiABEOcnAkAgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAQsgAkEsaiIEQYTAwgBBBEEGQQEQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABIA8oAvgCEKsbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAELIAEQxiEgAkEsaiIEQZrBwgBBCUENQQIQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABQQYgDygC0AIiBBCrFCACKAIsIghBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgCDYCAAwBCyAEBEAgDygCzAIhECAEQQJ0IQsDQCACQSxqIAEgECgCABCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwDCyAQQQRqIRAgC0EEayILDQALCyABEMYhIAJBLGoiBEGjwcIAQQ5BDUEDEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAUEIIA8oAtwCIgQQqxQgAigCLCIIQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAg2AgAMAQsgBARAIA8oAtgCQQhqIRAgBEEMbCELA0AgAkEsaiABIBBBBGsoAgAgECgCABCnGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwDCyAQQQxqIRAgC0EMayILDQALCyABEMYhIAJBLGoiBEGxwcIAQQVBBkEEEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKAL8AhCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEG2wcIAQQpBB0EFEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQOoAhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEHAwcIAQRdBB0EGEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQOwAhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEH2t8IAQRVBB0EHEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQO4AhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIA8oAuACQYCAgIB4RwRAIAJBLGoiBEGhvsIAQRJBDUEIEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgAUEKIA8oAugCIgQQqxQgAigCLCIIQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAg2AgAMAgsgBARAIA8oAuQCIRAgBEEYbCELA0AgAkEsaiAQIAEQ9wogAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMBAsgEEEYaiEQIAtBGGsiCw0ACwsgARDGIQsgAkEsaiIEQdfBwgBBEEEHQQkQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABIA8pA8ACEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAELIAEQxiEgDygCAEEBRgRAIA8pAwghJCACQSxqIgRB58HCAEERQQdBChDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAEgJBCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKAIQBEAgDykDGCEkIAJBLGoiBEH4wcIAQRZBB0ELEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgASAkEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAILIAEQxiELIA8pAzBCAlIEQCACQSxqIgRBjsLCAEEKQQpBDBDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiCBCGMCAPQTBqIRAjAEFAaiIEJAAgBEEMakHOuMIAQQoQgCAgBEEsaiABEOcnAkAgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAQsgECgCIEGAgICAeEcEQCAEQSxqIgtB2LjCAEEDQQhBARDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgECgCJCAQKAIoEKcbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAixBgICAgHhHBEAgBEEsaiILQdu4wgBBA0EIQQIQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABIBAoAjAgECgCNBCnGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQKAIABEAgECkDCCEkIARBLGoiC0HeuMIAQQpBB0EDEOgcIARBGGogASALEK4UIAQoAhgiDEEERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAMNgIAIAsQhjAMAgsgBEEsaiILEIYwIAsgASAkEKwbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAhAEQCAQKQMYISQgBEEsaiILQei4wgBBDkEHQQQQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABICQQrBsgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAgsgARDGIQsgECgCOEGAgICAeEcEQCAEQSxqIgtB9rjCAEEJQQhBBRDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgECgCPCAQKAJAEKcbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAkRBgICAgHhHBEAgBEEsaiILQf+4wgBBCUEIQQYQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABIBAoAkggECgCTBCnGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQLQBQIgxBAkcEQCAEQSxqIgtBiLnCAEESQQJBBxDoHCAEQRhqIAEgCxCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACALEIYwDAILIARBLGoiCxCGMCALIAEgDEEBcRDQGSAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQLQBRIgtBAkcEQCAEQSxqIhBBmrnCAEESQQJBCBDoHCAEQRhqIAEgEBCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACAQEIYwDAILIARBLGoiEBCGMCAQIAEgC0EBcRDQGSAEKAIsIhBBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggEDYCAAwCCyABEMYhCyAEQSxqIAEQgTYgBCgCLCIQQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIBA2AgAMAQsgCCABEOUoCyAEQQxqEN47IARBQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKALsAkGAgICAeEcEQCACQSxqIgRBmMLCAEEOQQ1BDRDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAFBCiAPKAL0AiIEEKsUIAIoAiwiCEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAINgIADAILIAQEQCAPKALwAiEQIARBDGwhCwNAIAJBLGohCCMAQUBqIgQkACAEQQxqQf/DwgBBERCAICAEQSxqIAEQ5ycCQCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyAEQSxqIgxBkMTCAEEJQQZBARDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgECgCABCrGyAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIARBLGoiDEGZxMIAQQhBBkECEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAQsgBEEsaiIMEIYwIAwgASAQKAIEEKsbIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAEQxiEgBEEsaiIMQaHEwgBBBUEGQQMQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwBCyAEQSxqIgwQhjAgDCABIBAoAggQqxsgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgARDGISAEQSxqIAEQgTYgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgCCABEOUoCyAEQQxqEN47IARBQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwECyAQQQxqIRAgC0EMayILDQALCyABEMYhCyAPKAIgBEAgDykDKCEkIAJBLGoiBEGmwsIAQRNBB0EOEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgASAkEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAILIAEQxiELIA8oAqACBEAgDygCpAIhCCACQSxqIgRBucLCAEETQQZBDxDoHCACQRhqIAEgBBCuFCACKAIYIhBBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgEDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAEgCBCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKQOIAUICUgRAIAJBLGoiBEHMwsIAQQ9BCkEQEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIIEIYwIA9BiAFqIRAjAEFAaiIEJAAgBEEMakHwwsIAQQ4QgCAgBEEsaiABEOcnAkAgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAQsgECgCAEEBRgRAIBApAwghJCAEQSxqIgtBv73CAEEfQQdBARDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgJBCsGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQKAIQQYCAgIB4RwRAIARBLGoiC0H+wsIAQRpBDUECEOgcIARBGGogASALEK4UIAQoAhgiDEEERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAMNgIAIAsQhjAMAgsgBEEsaiILEIYwIAsgAUEHIBAoAhgiDBCrFCAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyAMBEAgECgCFCELIAxBA3QhDANAIARBLGogASALKQMAEKwbIAQoAiwiF0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAXNgIADAQLIAtBCGohCyAMQQhrIgwNAAsLIAEQxiELIBAoAhxBgICAgHhHBEAgBEEsaiILQZjDwgBBGkENQQMQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABQQcgECgCJCILEKsUIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAILIAsEQCAQKAIgIQwgC0EDdCELA0AgBEEsaiABIAwpAwAQrBsgBCgCLCIQQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIBA2AgAMBAsgDEEIaiEMIAtBCGsiCw0ACwsgARDGIQsgBEEsaiABEIE2IAQoAiwiEEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAQNgIADAELIAggARDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAgsgARDGIQsgDykDsAFCA1IEQCACQSxqIgRB28LCAEEVQQpBERDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiEBCGMCAPQbABaiELIwBBQGoiDyQAIA9BDGpBxcXCAEEUEIAgIA9BLGogARDnJwJAIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAELIAspAwBCAlIEQCAPQSxqIgRB2cXCAEEEQQpBARDoHCAPQRhqIAEgBBCuFCAPKAIYIghBBEcEQCAQIA8pAhw3AgQgEEEMaiAPQSRqKQIANwIAIBAgCDYCACAEEIYwDAILIA9BLGoiCBCGMCMAQUBqIgQkACAEQQxqQcG5wgBBCxCAICAEQSxqIAEQ5ycCQCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyAEQSxqIgxBzLnCAEEEQQRBARDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgCysDQBDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIARBLGoiDEHQucIAQQRBBEECEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAQsgBEEsaiIMEIYwIAwgASALKwNIEM4kIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAEQxiEgBEEsaiIMQdS5wgBBBEEEQQMQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwBCyAEQSxqIgwQhjAgDCABIAsrA1AQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgARDGISAEQSxqIgxB2LnCAEEEQQRBBBDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgCysDWBDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIAsoAgBBAUYEQCALKwMIIScgBEEsaiIMQdy5wgBBBEEEQQUQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwCCyAEQSxqIgwQhjAgDCABICcQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAgsgARDGIQsgCygCEARAIAsrAxghJyAEQSxqIgxB4LnCAEEEQQRBBhDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAILIARBLGoiDBCGMCAMIAEgJxDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwCCyABEMYhCyALKAIgBEAgCysDKCEnIARBLGoiDEHkucIAQQRBBEEHEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAgsgBEEsaiIMEIYwIAwgASAnEM4kIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAILIAEQxiELIAsoAjAEQCALKwM4IScgBEEsaiIMQei5wgBBBEEEQQgQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwCCyAEQSxqIgwQhjAgDCABICcQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAgsgARDGIQsgBEEsaiABEIE2IAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAggARDlKAsgBEEMahDeOyAEQUBrJAAgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAgsgARDGIQsgCygCYEGAgICAeEcEQCAPQSxqIgRB3cXCAEEQQQ1BAhDoHCAPQRhqIAEgBBCuFCAPKAIYIghBBEcEQCAQIA8pAhw3AgQgEEEMaiAPQSRqKQIANwIAIBAgCDYCACAEEIYwDAILIA9BLGoiBBCGMCAEIAFBBiALKAJoIggQqxQgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAgsgCARAIAsoAmQhBCAIQQJ0IQwDQCAPQSxqIAEgBCgCABCrGyAPKAIsIghBBEcEQCAQIA8pAjA3AgQgEEEMaiAPQThqKQIANwIAIBAgCDYCAAwECyAEQQRqIQQgDEEEayIMDQALCyABEMYhCyAPQSxqIAEQgTYgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAQsgECABEOUoCyAPQQxqEN47IA9BQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyACQSxqIAEQgTYgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAIABEAgFikDCCEkIAZBLGoiAkGJusIAQRNBB0EEEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASAkEKwbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIBYoAqADBEAgFigCpAMhAyAGQSxqIgJBnLrCAEETQQZBBRDoHCAGQRhqIAEgAhCuFCAGKAIYIgRBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgBDYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAIQBEAgFikDGCEkIAZBLGoiAkGvusIAQRNBB0EGEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASAkEKwbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIBYoAqgDBEAgFigCrAMhAyAGQSxqIgJBwrrCAEETQQZBBxDoHCAGQRhqIAEgAhCuFCAGKAIYIgRBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgBDYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAKwA0GBgICAeEcEQCAGQSxqIgJB1brCAEEPQQpBCBDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiCBCGMCAWQbADaiEPIwBBQGoiAyQAIANBDGpB/cTCAEEUEIAgIANBLGogARDnJwJAIAMoAiwiAkEERwRAIAggAykCMDcCBCAIQQxqIANBOGopAgA3AgAgCCACNgIADAELAkACQCAPKAIAQYCAgIB4RwRAIANBLGoiAkGrxcIAQRpBCkECEOgcIANBGGogASACEK4UIAMoAhgiBEEERg0BIAggAykCHDcCBCAIQQxqIANBJGopAgA3AgAgCCAENgIAIAIQhjAMAwsgA0EsaiICQZHFwgBBGkEKQQEQ6BwgA0EYaiABIAIQrhQgAygCGCIEQQRHBEAgCCADKQIcNwIEIAhBDGogA0EkaikCADcCACAIIAQ2AgAgAhCGMAwDCyADQSxqIgQQhjAjAEEgayICJAAgAkGyxsIAQRcQgCAgAkEMaiABEOcnAkAgAigCDCIPQQRHBEAgBCACKQIQNwIEIARBDGogAkEYaikCADcCACAEIA82AgAMAQsgAkEMaiABEIE2IAIoAgwiD0EERwRAIAQgAikCEDcCBCAEQQxqIAJBGGopAgA3AgAgBCAPNgIADAELIAQgARDlKAsgAhDeOyACQSBqJAAgAygCLCICQQRGDQEgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAgsgA0EsaiIEEIYwIwBBQGoiAiQAIAJBDGpBj8bCAEEXEIAgIAJBLGogARDnJwJAIAIoAiwiEEEERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAQNgIADAELIAJBLGoiEEGjwcIAQQ5BDUEBEOgcIAJBGGogASAQEK4UIAIoAhgiC0EERwRAIAQgAikCHDcCBCAEQQxqIAJBJGopAgA3AgAgBCALNgIAIBAQhjAMAQsgAkEsaiIQEIYwIBAgAUEIIA8oAggiCxCrFCACKAIsIhBBBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgEDYCAAwBCyALBEAgDygCBEEIaiEQIAtBDGwhCwNAIAJBLGogASAQQQRrKAIAIBAoAgAQpxsgAigCLCIMQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIAw2AgAMAwsgEEEMaiEQIAtBDGsiCw0ACwsgARDGISAPKAIMQYCAgIB4RwRAIAJBLGoiEEGmxsIAQQxBCEECEOgcIAJBGGogASAQEK4UIAIoAhgiC0EERwRAIAQgAikCHDcCBCAEQQxqIAJBJGopAgA3AgAgBCALNgIAIBAQhjAMAgsgAkEsaiIQEIYwIBAgASAPKAIQIA8oAhQQpxsgAigCLCIPQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIA82AgAMAgsgARDGIQsgAkEsaiABEIE2IAIoAiwiD0EERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAPNgIADAELIAQgARDlKAsgAkEMahDeOyACQUBrJAAgAygCLCICQQRGDQAgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAQsgARDGISADQSxqIAEQgTYgAygCLCICQQRHBEAgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAQsgCCABEOUoCyADQQxqEN47IANBQGskACAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKALcA0GAgICAeEcEQCAGQSxqIgJB5LrCAEEZQQhBCRDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgFigC4AMgFigC5AMQpxsgBigCLCICQQRHBEAgByAGKQIwNwIEIAdBDGogBkE4aikCADcCACAHIAI2AgAMAgsgARDGIQsgBkEsaiABEIE2IAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAELIAcgARDlKAsgBkEMahDeOyAGQUBrJAAgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAwsgFkHoA2ohFiAgQegDayIgDQALCyABEMYhIAVBLGoiAkHFt8IAQQ9BB0ECEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAQsgBUEsaiICEIYwIAIgASATKQMgEKwbIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAELIAEQxiEgBUEsaiICQdS3wgBBCEEHQQMQ6BwgBUEYaiABIAIQrhQgBSgCGCIDQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAM2AgAgAhCGMAwBCyAFQSxqIgIQhjAgAiABIBMpAygQrBsgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgARDGISATKAI8QYCAgIB4RwRAIAVBLGoiAkHct8IAQQ9BDUEEEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAgsgBUEsaiICEIYwIAIgAUEKIBMoAkQiAhCrFCAFKAIsIgNBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAzYCAAwCCyACBEAgEygCQCEWIAJBA3QhIANAIAVBLGohAyMAQUBqIgIkACACQQxqQdPAwgBBDRCAICACQSxqIAEQ5ycCQCACKAIsIgZBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBjYCAAwBCyACQSxqIgZB4MDCAEEKQQZBARDoHCACQRhqIAEgBhCuFCACKAIYIgRBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBDYCACAGEIYwDAELIAJBLGoiBhCGMCAGIAEgFigCABCrGyACKAIsIgZBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBjYCAAwBCyABEMYhIAJBLGoiBkHqwMIAQQpBAkECEOgcIAJBGGogASAGEK4UIAIoAhgiBEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAENgIAIAYQhjAMAQsgAkEsaiIGEIYwIAYgASAWLQAEENAZIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAEQxiEgAkEsaiIGQfTAwgBBC0ECQQMQ6BwgAkEYaiABIAYQrhQgAigCGCIEQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAQ2AgAgBhCGMAwBCyACQSxqIgYQhjAgBiABIBYtAAUQ0BkgAigCLCIGQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAY2AgAMAQsgARDGISACQSxqIAEQgTYgAigCLCIGQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAY2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwECyAWQQhqIRYgIEEIayIgDQALCyABEMYhCyATKAIABEAgEykDCCEkIAVBLGoiAkHrt8IAQQtBB0EFEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAgsgBUEsaiICEIYwIAIgASAkEKwbIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAILIAEQxiELIBMoAhAEQCATKQMYISQgBUEsaiICQfa3wgBBFUEHQQYQ6BwgBUEYaiABIAIQrhQgBSgCGCIDQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAM2AgAgAhCGMAwCCyAFQSxqIgIQhjAgAiABICQQrBsgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAgsgARDGIQsgEy8BSARAIBMvAUohAyAFQSxqIgJBi7jCAEEHQQVBBxDoHCAFQRhqIAEgAhCuFCAFKAIYIgZBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBjYCACACEIYwDAILIAVBLGoiAhCGMCACIAEgAxCpGyAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwCCyABEMYhCyAFQSxqIAEQgTYgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgCiABEOUoCyAFQQxqEN47IAVBQGskACAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwDCyATQdAAaiETIB9B0ABrIh8NAAsLIAEQxiEgGSgCQEGAgICAeEcEQCAJQSxqIgJBob7CAEESQQ1BBRDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAILIAlBLGoiAhCGMCACIAFBCiAZKAJIIgIQqxQgCSgCLCIDQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAM2AgAMAgsgAgRAIBkoAkQhEyACQRhsIR8DQCAJQSxqIBMgARD3CiAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwECyATQRhqIRMgH0EYayIfDQALCyABEMYhCyAZKAJMQYCAgIB4RwRAIAlBLGoiAkGzvsIAQQpBCEEGEOgcIAlBGGogASACEK4UIAkoAhgiA0EERwRAIBEgCSkCHDcCBCARQQxqIAlBJGopAgA3AgAgESADNgIAIAIQhjAMAgsgCUEsaiICEIYwIAIgASAZKAJQIBkoAlQQpxsgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAgsgARDGIQsgGSgCWEGAgICAeEcEQCAJQSxqIgJBvb7CAEENQQ1BBxDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAILIAlBLGoiAhCGMCACIAFBCiAZKAJgIhMQqxQgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAgsgEwRAA0AgCUEsaiEDIwBBQGoiAiQAIAJBDGpB9bvCAEELEIAgIAJBLGogARDnJwJAIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAJBLGoiBkGAvMIAQQpBCkEBEOgcIAJBGGogASAGEK4UIAIoAhgiBEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAENgIAIAYQhjAMAQsgAkEsaiIEEIYwIwBBIGsiBiQAIAZBx8PCAEEQEIAgIAZBDGogARDnJwJAIAYoAgwiBUEERwRAIAQgBikCEDcCBCAEQQxqIAZBGGopAgA3AgAgBCAFNgIADAELIAZBDGogARCBNiAGKAIMIgVBBEcEQCAEIAYpAhA3AgQgBEEMaiAGQRhqKQIANwIAIAQgBTYCAAwBCyAEIAEQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAEQxiEgAkEsaiABEIE2IAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAMgARDlKAsgAkEMahDeOyACQUBrJAAgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMBAsgE0EBayITDQALCyABEMYhCyAZKAIAQQJHBEAgCUEsaiICQcq+wgBBFEEKQQgQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwCCyAJQSxqIgQQhjAjAEFAaiIDJAAgA0EMakGmxMIAQRMQgCAgA0EsaiABEOcnAkAgAygCLCICQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAI2AgAMAQsCQAJAIBkoAgBBAUYEQCADQSxqIgJBw8TCAEEOQQpBAhDoHCADQRhqIAEgAhCuFCADKAIYIgZBBEYNASAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgBjYCACACEIYwDAMLIANBLGoiAkG5xMIAQQpBCkEBEOgcIANBGGogASACEK4UIAMoAhgiBkEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAGNgIAIAIQhjAMAwsgA0EsaiIGEIYwIBlBBGohBSMAQUBqIgIkACACQQxqQcS2wgBBCBCAICACQSxqIAEQ5ycCQCACKAIsIgdBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBzYCAAwBCyAFKAIAQYCAgIB4RwRAIAJBLGoiB0HMtsIAQQpBCEEBEOgcIAJBGGogASAHEK4UIAIoAhgiCkEERwRAIAYgAikCHDcCBCAGQQxqIAJBJGopAgA3AgAgBiAKNgIAIAcQhjAMAgsgAkEsaiIHEIYwIAcgASAFKAIEIAUoAggQpxsgAigCLCIHQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAc2AgAMAgsgARDGIQsgBSgCDEGAgICAeEcEQCACQSxqIgdB1rbCAEEPQQhBAhDoHCACQRhqIAEgBxCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAHEIYwDAILIAJBLGoiBxCGMCAHIAEgBSgCECAFKAIUEKcbIAIoAiwiB0EERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAHNgIADAILIAEQxiELIAUtABgiB0ECRwRAIAJBLGoiBUHltsIAQRFBAkEDEOgcIAJBGGogASAFEK4UIAIoAhgiCkEERwRAIAYgAikCHDcCBCAGQQxqIAJBJGopAgA3AgAgBiAKNgIAIAUQhjAMAgsgAkEsaiIFEIYwIAUgASAHQQFxENAZIAIoAiwiBUEERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAFNgIADAILIAEQxiELIAJBLGogARCBNiACKAIsIgVBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBTYCAAwBCyAGIAEQ5SgLIAJBDGoQ3jsgAkFAayQAIAMoAiwiAkEERg0BIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCACNgIADAILIANBLGoiBhCGMCAZQQRqIQUjAEFAaiICJAAgAkEMakG2ucIAQQsQgCAgAkEsaiABEOcnAkAgAigCLCIHQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAc2AgAMAQsgBSgCAEGAgICAeEcEQCACQSxqIgdBzLbCAEEKQQhBARDoHCACQRhqIAEgBxCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAHEIYwDAILIAJBLGoiBxCGMCAHIAEgBSgCBCAFKAIIEKcbIAIoAiwiB0EERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAHNgIADAILIAEQxiELIAUoAgxBgICAgHhHBEAgAkEsaiIHQda2wgBBD0EIQQIQ6BwgAkEYaiABIAcQrhQgAigCGCIKQQRHBEAgBiACKQIcNwIEIAZBDGogAkEkaikCADcCACAGIAo2AgAgBxCGMAwCCyACQSxqIgcQhjAgByABIAUoAhAgBSgCFBCnGyACKAIsIgdBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBzYCAAwCCyABEMYhCyAFLQAYIgdBAkcEQCACQSxqIgVB5bbCAEERQQJBAxDoHCACQRhqIAEgBRCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAFEIYwDAILIAJBLGoiBRCGMCAFIAEgB0EBcRDQGSACKAIsIgVBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBTYCAAwCCyABEMYhCyACQSxqIAEQgTYgAigCLCIFQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAU2AgAMAQsgBiABEOUoCyACQQxqEN47IAJBQGskACADKAIsIgJBBEYNACAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgAjYCAAwBCyABEMYhIANBLGogARCBNiADKAIsIgJBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgAjYCAAwBCyAEIAEQ5SgLIANBDGoQ3jsgA0FAayQAIAkoAiwiAkEERwRAIBEgCSkCMDcCBCARQQxqIAlBOGopAgA3AgAgESACNgIADAILIAEQxiELIBkoAmRBgICAgHhHBEAgCUEsaiICQd6+wgBBG0EIQQkQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwCCyAJQSxqIgIQhjAgAiABIBkoAmggGSgCbBCnGyAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwCCyABEMYhCyAJQSxqIAEQgTYgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAQsgESABEOUoCyAJQQxqEN47IAlBQGskAAJAIAEoAigiAkEERwRAIAFByABqIAFBNGopAgA3AgAgASABKQIsNwJAIAEgAjYCPCAeIAFBPGoQpSUMAQsgHkEINgIACyABELouIAFB0ABqJAAgDSgC6AEiAUEIRwRAIBsgDSkC7AE3AgwgG0EcaiANQfwBaigCADYCACAbQRRqIA1B9AFqKQIANwIAIBtBAzYCACAbIAE2AggMAgsgDSAiKAIAIgEoAhQgI2s2AswBIA1B6AFqIgIgASANQcwBakEEEKgaAkAgDS0A6AFBBEYNACANKQPoASIkQv8Bg0IEUQ0AIA0gJDcD6AEgG0EIaiACEIErIBtBAzYCAAwCCyANQegBaiIBICIoAgBBgPbPAEEEEKgaAkAgDS0A6AFBBEYNACANKQPoASIkQv8Bg0IEUQ0AIA0gJDcD6AEgG0EIaiABEIErIBtBAzYCAAwCCyANKAIQQYCAgIB4RwRAIA1BiAJqIgIgDUEYaigCADYCACANIA0pAhA3A4ACIA1B/ABqIgEQ9BsgARDvOyABQQhqIAIoAgA2AgAgASANKQOAAjcCAAsgGyANQcgAakH4APwKAAAgGBCHMAwECyANKQP4ASEkIBsgDSkD2AE3AgwgGyAkNwMYIBsgCTYCCCAbQQM2AgAgG0EUaiADKAIANgIAIA1BzAFqEIcwIA1BwAFqIgEQ9BsgARDvOyANQTxqEIYwIA1BHGoQuy4gDUEQahCSMCANQQRqEJEwDAILIA1ByABqEJIoIA1BEGoQkjAMAQsgGyANKQJMNwIMIBtBHGogDUHcAGooAgA2AgAgG0EUaiANQdQAaikCADcCACAbQQM2AgAgGyAcNgIIIBoQ9BsgGhDvOwsgGkEMahCHMCAaQRhqIRwLIBwQhjAgDUGQAmokAAsgEkGwAWokAAwBCyADIBIoAnBB8MXDABD9LwALIBUoApgBIgFBA0YEQCAVQYwBaiAVQbABaikDACIkNwIAIBVBhAFqIBVBqAFqKQMAIiU3AgAgFSAVKQOgASImNwJ8IB1BGGogJDcCACAdQRBqICU3AgAgHSAmNwIIIB1BAzYCAAwBCyAVQZABaiICIBVBtAFqKAIANgIAIBVBiAFqIgMgFUGsAWopAgA3AwAgFUGAAWoiCSAVQaQBaikCADcDACAVIBUpApwBNwN4IBVBIGogFUG4AWpB2AD8CgAAIBVBDGogCSkDADcCACAVQRRqIAMpAwA3AgAgFUEcaiACKAIANgIAIBUgATYCACAVIBUpA3g3AgQgFUGYAWoiASAUEMMZAkAgFS0AmAFBBEYNACAVKQOYASIkQv8Bg0IEUQ0AIBUgJDcDmAEgHUEIaiABEIErIB1BAzYCACAVENgcDAELIB0gFUH4APwKAAALIBVBkAJqJAAMAQsgAyAVKAKgAUHwxcMAEP0vAAsLICFBIGokACAUENQpIBQQ3jsgFCgCVCIBIAEoAgAiAUEBazYCACABQQFGBEAgFEHUAGoQgyALIBQoAlgiASABKAIAIgFBAWs2AgAgAUEBRgRAIBRB2ABqEIYfCyAUKAJcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAUQdwAahCuIAsgFEEYaiIBENwYIAEQ7DsgFEEkaiIBELErIAFBBEEMEOAeIBRBMGoiARC6KiABQQRBDBDgHiAUQTxqIgEQuyogAUEEQQwQ4B4gFEHIAGoiARDgKSABEPI7IBQoAowBQYCAgIB4RwRAIBRBjAFqEO8rCyAUKAKgASIBIAEoAgAiAUEBazYCACABQQFGBEAgFEGgAWoQ+CMLIBRB6ABqEP4oIBQoAoQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAUQYQBahD4IwsgFCgCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIBRBiAFqEK4gCyAOKAK4ASIBQQNGBEAgDkHcA2ogDkHQAWopAwAiJDcCACAOQdQDaiAOQcgBaikDACIlNwIAIA4gDikDwAEiJjcCzAMgDkH4A2ogJDcDACAOQfADaiAlNwMAIA4gJjcD6AMgACAUEMgmDAELIA5B4ANqIgIgDkHUAWooAgA2AgAgDkHYA2oiAyAOQcwBaikCADcDACAOQdADaiIJIA5BxAFqKQIANwMAIA4gDikCvAE3A8gDIA5B8AJqIA5B2AFqQdgA/AoAACAOQdwCaiAJKQMANwIAIA5B5AJqIAMpAwA3AgAgDkHsAmogAigCADYCACAOIAE2AtACIA4gDikDyAM3AtQCIA5B0AJqEJIoIABBDGogDkEMaigCADYCACAAIA4pAgQ3AgQgAEEGNgIADAELIA5BBGoQ3jsLIA5BkAVqJAALwQsCCX8DfiMAQcABayICJAAgAUEMahDZPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABLwEAIgZBgAFqQf//A3FB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUECaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEBdGovAQAiA0GAAWpB//8DcUH/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu5CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxC/////w9YBEAgByAMPgIADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0EEaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL/////D1gEQCAHIAFBAnRqIAw+AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQxx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu1CwIKfwN+IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEBdCIFIQMCQCAFQT5xIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKAIAIgFB//8BTQRAIAcgATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBAmohByAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnRqKAIAIgRB//8BTQRAIAcgAUEBdGogBDsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ULAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQF0IgQhAwJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQpAwAiDEL//wFYBEAgByAMPQEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL//wFYBEAgByABQQF0aiAMPQEADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4RkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENodIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALtQsCCn8DfiMAQcABayICJAAgAUEMahDYPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCkDACIMQv//A1gEQCAHIAw9AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEIaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQN0aikDACIMQv//A1gEQCAHIAFBAXRqIAw9AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu5CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxC/////wdYBEAgByAMPgIADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0EEaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL/////B1gEQCAHIAFBAnRqIAw+AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQvx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuxCwIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEDdCIEIQMCQCAEQThxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEMgEAIgxCAFkEQCAHIAw3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBEECaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQF0ajIBACIMQgBZBEAgByABQQN0aiAMNwMADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENkdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALtQsCCn8DfiMAQcABayICJAAgAUEMahDbPCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAXQiBSEDAkAgBUE+cSIHBEAgBSAHa0FAayIDIAVJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAFBEAgBQRAIAdBACAF/AsACyACKAJQIQsgAigCSCEHCyACIAU2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQVBACEGQQAhAwNAAkAgBSgCACIBQf//A00EQCAHIAE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQf//A00EQCAHIAFBAXRqIAQ7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuxCwIKfwN+IwBBwAFrIgIkACABQQxqENk8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEECdCIFIQMCQCAFQTxxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFLgEAIgFBAE4EQCAHIAE2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUECaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQF0ai4BACIEQQBOBEAgByABQQJ0aiAENgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALxAwCCH8EfiMAQfABayIDJAAgAUEMahDcPCEHIANBCGogARCSNhDuJSAHQQR0IgQhBQJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEFIAIoAgghBCACKAIAIQcgASgCECEIA0ACQCADKQNoIgxQRQRAIAMpA3AhCwwBCwNAAn4CQCADKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgAyALUK1CAYY3A1AgC6dBAXFFDQAgAyADKQNYNwPYAQwBCyADKAJgRQ0BIANB0AFqIAUQtiogAykD0AEhCwsgC0IAUg0CCyADQgM3A1ALIAMpA0AiC0ICUQ0JIANCADcDQCADKQNIDAELIAMpA9gBCyEMIAunQQFxRQ0HIAMgAykDcEJAfSILNwNwIAMgDDcDaCAMUA0ACwsgAyAMQgEgDHoiDYaFNwNoIANB0AFqIgkgByAIIA2nIAunaiIKQQV0aiIBKQMAIgsgASkDCCIMIAEpAxAiDSABKQMYIg4QoQogAygC0AFBAXFFBEAgAigCBCEBIAMgDjcDqAEgAyANNwOgASADIAw3A5gBIAMgCzcDkAEgA0HMkf8ANgK4ASADQgQ3AsQBIANBgww2AuwBIANB9As2AuQBIAMgAUEBajYC4AEgA0G7BzYC3AEgAyABNgLYASADQcwBNgLUASADQaCR/wA2AtABIAMgCTYCwAEgAyADQZABajYC6AEgA0EENgK8ASADQYABaiADQbgBahCZDiADKQKAASELIAMpAogBIQwMBwsgA0HQAWogAykD4AEiCyADKQPoASIMIAQtAAAQrQ4gAygC0AEiAUGTgICAeEcEQCADKQLcASEMIAMpAtQBIQsMCAUgBiAKQQR0aiIBIAw3AwggASALNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEEQQAhBQNAIANBQGsiCiAJIAQpAwAiCyAEKQMIIgwgBEEQaikDACINIARBGGopAwAiDhChCiADKAJAQQFxRQRAIAIoAgQhASADIA43A+gBIAMgDTcD4AEgAyAMNwPYASADIAs3A9ABIANBzJH/ADYCkAEgA0IENwKcASADQYMMNgJcIANB9As2AlQgAyABQQFqNgJQIANBuwc2AkwgAyABNgJIIANBzAE2AkQgA0Ggkf8ANgJAIAMgCjYCmAEgAyADQdABajYCWCADQQQ2ApQBIANBvAFqIANBkAFqEJkOIAMpArwBIQsgAykCxAEhDAwDCyADQUBrIAMpA1AiCyADKQNYIgwgCC0AABCtDiADKAJAIgFBk4CAgHhHBEAgAykCTCEMIAMpAkQhCwwECyAGIAs3AwAgBiAMNwMIIAZBEGohBiAEQSBqIQQgByAFQQFqIgVHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQQgAygCLCEFIAEgA0HIAGoiBikCADcDACADKQMgIQsgAyADKQJANwMgIANBADYCMCADIAs3AkwgA0EANgJIIAMgBTYCRCADIAQ2AkAgAyACENc7IAMoAgAhBEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBikCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAFNgLYASADIAQ2AtQBIAMgATYC0AEgA0E0aiIBIANB0AFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNAIAAgASACEMsdIANBIGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghAQsgACAMNwIQIAAgCzcCCCAAIAE2AgQgAEEpOgAAIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQfABaiQAC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAggATYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBBGohCCAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnQiBGooAgAiB0EATgRAIAQgCGogBzYCAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBC/HSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUuAQAiAUEATgRAIAggATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBAmohCCAFQQJqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAXQiBGouAQAiB0EATgRAIAQgCGogBzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDNHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUuAQAiAUEATgRAIAggATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBAmohCCAFQQJqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAXQiBGouAQAiB0EATgRAIAQgCGogBzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAggATYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBBGohCCAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnQiBGooAgAiB0EATgRAIAQgCGogBzYCAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDHHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUpAwAiDEIAWQRAIAcgDDcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAFQQhqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBA3QiBGopAwAiDEIAWQRAIAQgB2ogDDcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDWHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUpAwAiDEIAWQRAIAcgDDcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAFQQhqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBA3QiBGopAwAiDEIAWQRAIAQgB2ogDDcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC5kLAgl/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKQMAIgtCgAF8Qv8BWARAIAMgCGogCzwAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKQMAIgtCgAF8Qv8BWARAIAEgCGogCzwAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIEIAIoAhQiBkkEQCACKAIQIARqIgQgBC0AAEF+IAFBB3F3cToAACAFQQFqIQUMAQsLIAQgBkGIi/8AEMMhAAtBxIr/ABCyOwALIAYgB0GIi/8AEMMhAAsMAwtB1Ir/AEEjQfiK/wAQyyQACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBikCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAGKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgBiACQeAAaikCADcDACACIAIpAlg3A3ggAiAFNgKMASAAIAEgBBDYHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu3CwIJfwN+IwBBwAFrIgIkACABQQxqENs8IQMCQAJAAkACQAJAIAEQkjYiBARAQcAAIQUgAkEgaiAEENw7IAQoAhQhBiAEKAIMIQcgAigCJCEKIAIoAiAhCSADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgBDYCMCACQcAANgIsIAJBLGogByADIAdqIAkgChC/GAwBC0HAACEGIANBA3YgA0EHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0EIAUEQCAFQcAAEK02IgZFDQILIAJCADcCOCACIAY2AjQgAiAFNgIwIAJBwAA2AiwgAkEsaiADEN4QQQAhBgsgAyEEAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQtBACEFIAJBADYCUCACIAg2AkggAiAENgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAGDQEMCgsgAwRAIAhBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghCCAGRQ0BCyADIAZHDQEgAyEFDAgLIAEoAhAhAUEAIQQDQAJAIAEoAgAiBkGAAWpB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUEEaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUECdGooAgAiA0GAAWpB/wFNBEAgASAIaiADOgAADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIGSQRAIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgAyAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAFEKM9AAtBwAAgBBCjPQALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIDEJcpIAJByABqIgEoAgAhByACKAJMIQQgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAHNgJ4IAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBDYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASADENgdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAXQiAyEHAkAgA0E+cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHaiwAACIDQQBOBEAgBSADOwEADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUECaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBaiwAACIEQQBOBEAgBSABQQF0aiAEOwEADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4RkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEM0dIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAnQiAyEHAkAgA0E8cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHaiwAACIDQQBOBEAgBSADNgIADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUEEaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBaiwAACIEQQBOBEAgBSABQQJ0aiAENgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBA3QiAyEHAkAgA0E4cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHajAAACIMQgBZBEAgBSAMNwMADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUEIaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBajAAACIMQgBZBEAgBSABQQN0aiAMNwMADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEENkdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALhgwCEX8EfSMAQcAiayIHJAAgACAAKAIUIg8gACgCJCIIIAggD0kbIgw2AiQCQAJAAkACQAJAAkACQCAAKAIcIghFBEAgASgCDEUNASABKAIIIAw2AgAgASgCBEUNAiABKAIAQQA6AAAgA0UNAyAHQQhqIAJBoAQgACgCEBCBESAHKgIIIRcgBygCDCEJQQEhBiAAQQE2AhwgASABKAIQQQFqNgIQIAAgACgCKEEBaiIINgIoIAAgCbMiGCAXIBcgGF0bIhc4AgwgACAXOAIIIAQoAgAgCEsEQCADIAhNDQUgAiAIQYgRbGoiAkEAQYQR/AsAIAJBo+D/+wc2AoQRCyAAQQA2AiQMBwsgDA0EDAULQQBBAEG87cwAEMMhAAtBAEEAQcztzAAQwyEAC0EAQQBB3O3MABDDIQALIAggA0Hs7cwAEMMhAAsCQAJAAkACQAJAAkACQAJAAkACQAJAIAMgACgCKCIQSwRAIAdBGGogAiAQQYgRbGoiC0GgBCAAKAIQIhQQgREgByoCGCEXIAcoAhxBAEUEQCAHQSBqIAtBiBH8CgAACyAHQagRaiEKIAZFBEAgCiALQYgR/AoAAAsgB0EANgK0IiAHQQA2ArAiIAdBADYCvCIgB0EANgK4IrMiGCAXIBcgGF0bIRcgAEEIaiERIAdBvCJqIRIgB0G0ImohEyAHQSBqIQlBASENAkADQCAAIAZBAnQiDmooAgAiBiADTw0BIAkgAiAGQYgRbGoiFSgCgBEgCSgCgBFqNgKAEUEAIQYDQCAGIAlqIhYgBiAVaigCACAWKAIAajYCACAGQQRqIgZBgBFHDQALIAdBEGogCUGgBCAUEIERIBMgBygCFLMiGCAHKgIQIhkgGCAZXhsiGDgCACASIBggF5MgDiARaioCAJM4AgBBASEGIA0gB0G4ImohEiAHQbAiaiETQQAhDSAKIQkNAAsgByoCvCIhGCAHKgK4IiEZAkACQCABKAIQIglB/wFLDQAgGCAAKgIYIhpeRQ0AIBkgGl4NAQsgASgCDCEGIBkgGEMAAKDBkl1FBEAgCEEBayIKIAZPDQQgASgCCCAKQQJ0aiIGIAYoAgAgDGo2AgAgACgCACIGIANPDQUgAiAGQYgRbGogB0EgakGIEfwKAAAgESAHKgK0IiIXOAIAIAlBAUYEQCAAIBc4AgwLIABBADYCJCALQQBBhBH8CwAgC0Gj4P/7BzYChBEgACAAKAIsQQFqIgI2AiwgAkECSQ0PIAAgACgCICAPajYCIAwPCyAGIAhNDQcgASgCCCAIQQJ0aiAMNgIAIAhBAmsiCSABKAIEIgZPDQggBiAITQ0FIAEoAgAhDSAAKAIAIQ4gACAAKAIEIgY2AgAgACAONgIEIAggDWogCSANai0AADoAACADIAZNDQYgAiAGQYgRbGogCkGIEfwKAAAgAEEANgIkIAAgCEEBaiIGNgIcIAAgACoCCDgCDCAAIAcqArAiOAIIIAtBAEGEEfwLACAAQQA2AiwgC0Gj4P/7BzYChBEMDQsgCCABKAIMIgZPDQggASgCCCAIQQJ0aiAMNgIAIAggASgCBCIGTw0JIAAoAgAhBiAAIAk2AgAgACAGNgIEIAAqAgghGCAAIBc4AgggACAYOAIMIAAgCEEBaiIGNgIcIAEgCUEBajYCECAAIBBBAWoiCjYCKCABKAIAIAhqIAk6AAAgCiAEKAIATw0LIAMgCksNCiAKIANBjO/MABDDIQALIAYgA0Gc78wAEMMhAAsgECADQfztzAAQwyEACyAKIAZBjO7MABDDIQALIAYgA0Gc7swAEMMhAAsgCCAGQczuzAAQwyEACyAGIANB3O7MABDDIQALIAggBkGs7swAEMMhAAsgCSAGQbzuzAAQwyEACyAIIAZB7O7MABDDIQALIAggBkH87swAEMMhAAsgAiAKQYgRbGoiAkEAQYQR/AsAIAJBo+D/+wc2AoQRCyAAQQA2AiwgAEEANgIkCyAAIA82AiAMAQsgCCEGCyAFBEAgASAGNgIUIAQgASgCEDYCAAsgB0HAImokAAuGDAIRfwR9IwBBwBBrIgckACAAIAAoAhQiDyAAKAIkIgggCCAPSRsiDDYCJAJAAkACQAJAAkACQAJAIAAoAhwiCEUEQCABKAIMRQ0BIAEoAgggDDYCACABKAIERQ0CIAEoAgBBADoAACADRQ0DIAdBCGogAkGAAiAAKAIQEIERIAcqAgghFyAHKAIMIQlBASEGIABBATYCHCABIAEoAhBBAWo2AhAgACAAKAIoQQFqIgg2AiggACAJsyIYIBcgFyAYXRsiFzgCDCAAIBc4AgggBCgCACAISwRAIAMgCE0NBSACIAhBiAhsaiICQQBBhAj8CwAgAkGj4P/7BzYChAgLIABBADYCJAwHCyAMDQQMBQtBAEEAQbztzAAQwyEAC0EAQQBBzO3MABDDIQALQQBBAEHc7cwAEMMhAAsgCCADQeztzAAQwyEACwJAAkACQAJAAkACQAJAAkACQAJAAkAgAyAAKAIoIhBLBEAgB0EYaiACIBBBiAhsaiILQYACIAAoAhAiFBCBESAHKgIYIRcgBygCHEEARQRAIAdBIGogC0GICPwKAAALIAdBqAhqIQogBkUEQCAKIAtBiAj8CgAACyAHQQA2ArQQIAdBADYCsBAgB0EANgK8ECAHQQA2ArgQsyIYIBcgFyAYXRshFyAAQQhqIREgB0G8EGohEiAHQbQQaiETIAdBIGohCUEBIQ0CQANAIAAgBkECdCIOaigCACIGIANPDQEgCSACIAZBiAhsaiIVKAKACCAJKAKACGo2AoAIQQAhBgNAIAYgCWoiFiAGIBVqKAIAIBYoAgBqNgIAIAZBBGoiBkGACEcNAAsgB0EQaiAJQYACIBQQgREgEyAHKAIUsyIYIAcqAhAiGSAYIBleGyIYOAIAIBIgGCAXkyAOIBFqKgIAkzgCAEEBIQYgDSAHQbgQaiESIAdBsBBqIRNBACENIAohCQ0ACyAHKgK8ECEYIAcqArgQIRkCQAJAIAEoAhAiCUH/AUsNACAYIAAqAhgiGl5FDQAgGSAaXg0BCyABKAIMIQYgGSAYQwAAoMGSXUUEQCAIQQFrIgogBk8NBCABKAIIIApBAnRqIgYgBigCACAMajYCACAAKAIAIgYgA08NBSACIAZBiAhsaiAHQSBqQYgI/AoAACARIAcqArQQIhc4AgAgCUEBRgRAIAAgFzgCDAsgAEEANgIkIAtBAEGECPwLACALQaPg//sHNgKECCAAIAAoAixBAWoiAjYCLCACQQJJDQ8gACAAKAIgIA9qNgIgDA8LIAYgCE0NByABKAIIIAhBAnRqIAw2AgAgCEECayIJIAEoAgQiBk8NCCAGIAhNDQUgASgCACENIAAoAgAhDiAAIAAoAgQiBjYCACAAIA42AgQgCCANaiAJIA1qLQAAOgAAIAMgBk0NBiACIAZBiAhsaiAKQYgI/AoAACAAQQA2AiQgACAIQQFqIgY2AhwgACAAKgIIOAIMIAAgByoCsBA4AgggC0EAQYQI/AsAIABBADYCLCALQaPg//sHNgKECAwNCyAIIAEoAgwiBk8NCCABKAIIIAhBAnRqIAw2AgAgCCABKAIEIgZPDQkgACgCACEGIAAgCTYCACAAIAY2AgQgACoCCCEYIAAgFzgCCCAAIBg4AgwgACAIQQFqIgY2AhwgASAJQQFqNgIQIAAgEEEBaiIKNgIoIAEoAgAgCGogCToAACAKIAQoAgBPDQsgAyAKSw0KIAogA0GM78wAEMMhAAsgBiADQZzvzAAQwyEACyAQIANB/O3MABDDIQALIAogBkGM7swAEMMhAAsgBiADQZzuzAAQwyEACyAIIAZBzO7MABDDIQALIAYgA0Hc7swAEMMhAAsgCCAGQazuzAAQwyEACyAJIAZBvO7MABDDIQALIAggBkHs7swAEMMhAAsgCCAGQfzuzAAQwyEACyACIApBiAhsaiICQQBBhAj8CwAgAkGj4P/7BzYChAgLIABBADYCLCAAQQA2AiQLIAAgDzYCIAwBCyAIIQYLIAUEQCABIAY2AhQgBCABKAIQNgIACyAHQcAQaiQAC4YMAhF/BH0jAEHALGsiByQAIAAgACgCFCIPIAAoAiQiCCAIIA9JGyIMNgIkAkACQAJAAkACQAJAAkAgACgCHCIIRQRAIAEoAgxFDQEgASgCCCAMNgIAIAEoAgRFDQIgASgCAEEAOgAAIANFDQMgB0EIaiACQcAFIAAoAhAQgREgByoCCCEXIAcoAgwhCUEBIQYgAEEBNgIcIAEgASgCEEEBajYCECAAIAAoAihBAWoiCDYCKCAAIAmzIhggFyAXIBhdGyIXOAIMIAAgFzgCCCAEKAIAIAhLBEAgAyAITQ0FIAIgCEGIFmxqIgJBAEGEFvwLACACQaPg//sHNgKEFgsgAEEANgIkDAcLIAwNBAwFC0EAQQBBvO3MABDDIQALQQBBAEHM7cwAEMMhAAtBAEEAQdztzAAQwyEACyAIIANB7O3MABDDIQALAkACQAJAAkACQAJAAkACQAJAAkACQCADIAAoAigiEEsEQCAHQRhqIAIgEEGIFmxqIgtBwAUgACgCECIUEIERIAcqAhghFyAHKAIcQQBFBEAgB0EgaiALQYgW/AoAAAsgB0GoFmohCiAGRQRAIAogC0GIFvwKAAALIAdBADYCtCwgB0EANgKwLCAHQQA2ArwsIAdBADYCuCyzIhggFyAXIBhdGyEXIABBCGohESAHQbwsaiESIAdBtCxqIRMgB0EgaiEJQQEhDQJAA0AgACAGQQJ0Ig5qKAIAIgYgA08NASAJIAIgBkGIFmxqIhUoAoAWIAkoAoAWajYCgBZBACEGA0AgBiAJaiIWIAYgFWooAgAgFigCAGo2AgAgBkEEaiIGQYAWRw0ACyAHQRBqIAlBwAUgFBCBESATIAcoAhSzIhggByoCECIZIBggGV4bIhg4AgAgEiAYIBeTIA4gEWoqAgCTOAIAQQEhBiANIAdBuCxqIRIgB0GwLGohE0EAIQ0gCiEJDQALIAcqArwsIRggByoCuCwhGQJAAkAgASgCECIJQf8BSw0AIBggACoCGCIaXkUNACAZIBpeDQELIAEoAgwhBiAZIBhDAACgwZJdRQRAIAhBAWsiCiAGTw0EIAEoAgggCkECdGoiBiAGKAIAIAxqNgIAIAAoAgAiBiADTw0FIAIgBkGIFmxqIAdBIGpBiBb8CgAAIBEgByoCtCwiFzgCACAJQQFGBEAgACAXOAIMCyAAQQA2AiQgC0EAQYQW/AsAIAtBo+D/+wc2AoQWIAAgACgCLEEBaiICNgIsIAJBAkkNDyAAIAAoAiAgD2o2AiAMDwsgBiAITQ0HIAEoAgggCEECdGogDDYCACAIQQJrIgkgASgCBCIGTw0IIAYgCE0NBSABKAIAIQ0gACgCACEOIAAgACgCBCIGNgIAIAAgDjYCBCAIIA1qIAkgDWotAAA6AAAgAyAGTQ0GIAIgBkGIFmxqIApBiBb8CgAAIABBADYCJCAAIAhBAWoiBjYCHCAAIAAqAgg4AgwgACAHKgKwLDgCCCALQQBBhBb8CwAgAEEANgIsIAtBo+D/+wc2AoQWDA0LIAggASgCDCIGTw0IIAEoAgggCEECdGogDDYCACAIIAEoAgQiBk8NCSAAKAIAIQYgACAJNgIAIAAgBjYCBCAAKgIIIRggACAXOAIIIAAgGDgCDCAAIAhBAWoiBjYCHCABIAlBAWo2AhAgACAQQQFqIgo2AiggASgCACAIaiAJOgAAIAogBCgCAE8NCyADIApLDQogCiADQYzvzAAQwyEACyAGIANBnO/MABDDIQALIBAgA0H87cwAEMMhAAsgCiAGQYzuzAAQwyEACyAGIANBnO7MABDDIQALIAggBkHM7swAEMMhAAsgBiADQdzuzAAQwyEACyAIIAZBrO7MABDDIQALIAkgBkG87swAEMMhAAsgCCAGQezuzAAQwyEACyAIIAZB/O7MABDDIQALIAIgCkGIFmxqIgJBAEGEFvwLACACQaPg//sHNgKEFgsgAEEANgIsIABBADYCJAsgACAPNgIgDAELIAghBgsgBQRAIAEgBjYCFCAEIAEoAhA2AgALIAdBwCxqJAALrwsCCX8DfiMAQcABayICJAAgAUEMahDZPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABLwEAIgZB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUECaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEBdGovAQAiA0H/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuRCwIJfwN+IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASkDACILQv8BWARAIAMgCGogCzwAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKQMAIgtC/wFYBEAgASAIaiALPAAADAELIAJBEGogAkEsahCGPSABQQN2IgQgAigCFCIGSQRAIAIoAhAgBGoiBCAELQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgBCAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEACwwDC0HUiv8AQSNB+Ir/ABDLJAALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhByACKAJMIQMgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAM2AnwgAiAHNgJ4IAJBCGogBBDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASAEEMEdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC5ELAgl/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKQMAIgtC/wBYBEAgAyAIaiALPAAADAELIAJBGGogAkEsahCGPSADQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gA0EHcXdxOgAAIAVBAWohBQsgAUEIaiEBIAQgA0EBaiIDRw0ACwwECyAJBEAgAkH4AGogCSAKIAcgBBC/FCACQZgBaiEDIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0JIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNByACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEDdGopAwAiC0L/AFgEQCABIAhqIAs8AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALrwsCCX8DfiMAQcABayICJAAgAUEMahDbPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABKAIAIgZB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUEEaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUECdGooAgAiA0H/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuvCwIJfwN+IwBBwAFrIgIkACABQQxqENs8IQMCQAJAAkACQAJAIAEQkjYiBARAQcAAIQUgAkEgaiAEENw7IAQoAhQhBiAEKAIMIQcgAigCJCEKIAIoAiAhCSADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgBDYCMCACQcAANgIsIAJBLGogByADIAdqIAkgChC/GAwBC0HAACEGIANBA3YgA0EHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0EIAUEQCAFQcAAEK02IgZFDQILIAJCADcCOCACIAY2AjQgAiAFNgIwIAJBwAA2AiwgAkEsaiADEN4QQQAhBgsgAyEEAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQtBACEFIAJBADYCUCACIAg2AkggAiAENgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAGDQEMCgsgAwRAIAhBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghCCAGRQ0BCyADIAZHDQEgAyEFDAgLIAEoAhAhAUEAIQQDQAJAIAEoAgAiBkH/AE0EQCAEIAhqIAY6AAAMAQsgAkEYaiACQSxqEIY9IARBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiAEQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgAyAEQQFqIgRHDQALDAcLIAkEQCACQfgAaiAJIAogByADEL8UIAJBmAFqIQQgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiAEELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0KIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aigCACIDQf8ATQRAIAEgCGogAzoAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIDIAIoAhQiBkkEQCACKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAFQQFqIQUMAQsLIAMgBkGIi/8AEMMhAAtBxIr/ABCyOwALIAYgB0GIi/8AEMMhAAtBwAAgBBCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAQQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiAxCXKSACQcgAaiIBKAIAIQcgAigCTCEEIAEgAkGAAWoiBikCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiAENgJ8IAIgBzYCeCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAGKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAQ2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgBiACQeAAaikCADcDACACIAIpAlg3A3ggAiAFNgKMASAAIAEgAxDYHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC68LAgl/A34jAEHAAWsiAiQAIAFBDGoQ2TwhAwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBSACQSBqIAQQ3DsgBCgCFCEGIAQoAgwhByACKAIkIQogAigCICEJIANBA3YgA0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiAENgIwIAJBwAA2AiwgAkEsaiAHIAMgB2ogCSAKEL8YDAELQcAAIQYgA0EDdiADQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQQgBQRAIAVBwAAQrTYiBkUNAgsgAkIANwI4IAIgBjYCNCACIAU2AjAgAkHAADYCLCACQSxqIAMQ3hBBACEGCyADIQQCQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhCCAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIIRQ0BC0EAIQUgAkEANgJQIAIgCDYCSCACIAQ2AkQgAkHAADYCQAJAAkACQAJAIANFBEAgAkEANgJMIAYNAQwKCyADBEAgCEEAIAP8CwALIAIgAzYCTCACIAIoAlAgA2o2AlAgAigCSCEIIAZFDQELIAMgBkcNASADIQUMCAsgASgCECEBQQAhBANAAkAgAS8BACIGQf8ATQRAIAQgCGogBjoAAAwBCyACQRhqIAJBLGoQhj0gBEEDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IARBB3F3cToAACAFQQFqIQULIAFBAmohASADIARBAWoiBEcNAAsMBwsgCQRAIAJB+ABqIAkgCiAHIAMQvxQgAkGYAWohBCABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAQQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQogAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBAXRqLwEAIgNB/wBNBEAgASAIaiADOgAADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIGSQRAIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgAyAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAFEKM9AAtBwAAgBBCjPQALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIDEJcpIAJByABqIgEoAgAhByACKAJMIQQgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAHNgJ4IAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBDYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASADENgdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4AsBEn8jAEGQAmsiAyQAIANB2AFqIAEgAhDdECADKALgASEJIAMoAtwBIQICQCADKALYASIEQYqAgIB4RwRAIAAgAykC5AE3AgwgAEEcaiADQfQBaikCADcCACAAQRRqIANB7AFqKQIANwIAIAAgCTYCCCAAIAI2AgQgACAENgIADAELIAJBAXEEQCADQdgBaiABKAIAIgwgCRCTDiADKALcASECAkAgAygC2AEiBEGKgICAeEcEQCADQcQBaiADQfgBaigCADYCACADQbwBaiADQfABaikCADcCACADQbQBaiADQegBaikCADcCACADIAMpAuABNwKsASADIAI2AqgBIAMgBDYCpAEMAQsgA0HYAWogDEF/IAIgCWoiBCACIARLGxCHDiADKALgASEEIAMoAtwBIQIgAygC2AEiBkGKgICAeEcEQCADQcABaiADQfQBaikCADcCACADQbgBaiADQewBaikCADcCACADIAMpAuQBNwKwASADIAQ2AqwBIAMgAjYCqAEgAyAGNgKkAQwBCyAEIAJrIgZBACAEIAZPGyIEQQJ2IARBA3FBAEdqIgQEQCACQX9zIQpBACAEayEUIANBgAFqIQ4gA0H0AGohDyADQbgBaiEQIANBqAFqIREgA0HcAGohBCADQewBaiESIANB3AFqIRMgA0HMAGohCyADQdAAaiEGIANB4AFqIQgDQCADQdgBaiAMIAIQkw4gAygC3AEhBQJAIAMoAtgBIgdBioCAgHhHBEAgBiAIKQIANwIAIAZBGGogCEEYaigCADYCACAGQRBqIAhBEGopAgA3AgAgBkEIaiAIQQhqKQIANwIAIAMgBTYCTCADIAc2AkgMAQsgA0HYAWogDCAFIAogBSAKSRsgAmoQtAYgA0HQAWoiBSATQQhqKQIANwMAIAMgEykCADcDyAEgAygC2AEiB0GKgICAeEcEQCAEIBIpAgA3AgAgBEEIaiASQQhqKQIANwIAIAtBCGogBSkDADcCACALIAMpA8gBNwIAIAMgBzYCSAwBCyADQYgCaiAFKQMANwMAIAMgAykDyAE3A4ACIANBpAFqIANBgAJqQcXn/gBBA0EEEK0IIANBmAFqIgUgEUEIaikCADcDACADIBEpAgA3A5ABIAMoAqQBIgdBioCAgHhHBEAgBCAQKQIANwIAIARBCGogEEEIaikCADcCACALQQhqIAUpAwA3AgAgCyADKQOQATcCACADIAc2AkgMAQsgCCAFKQMANwMAIAMgAykDkAE3A9gBIANB7ABqIANB2AFqQcjn/gBBBUEGEK0IIAMoAnAhBSADKAJsIgdBioCAgHhHBEAgBiAPKQIANwIAIAQgDikCADcCACAGQQhqIA9BCGooAgA2AgAgBEEIaiAOQQhqKQIANwIAIAMgBTYCTCADIAc2AkgMAQsgBSAFKAIMQQFrNgIMIANBioCAgHg2AkgLIAMgAjYC4AEgAyANNgLcASADQQA2AtgBIANBJGogA0HIAGogA0HYAWoQgRQgAygCJCIFQYqAgIB4RwRAIANBwAFqIANBQGspAgA3AgAgA0G4AWogA0E4aikCADcCACADQbABaiADQTBqKQIANwIAIAMgAykCKDcCqAEgAyAFNgKkAQwDCyACQQRqIQIgCkEEayEKIBQgDUEBaiINag0ACwsgA0GKgICAeDYCpAELIANBDzYC6AEgA0GZ6P4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgAEEEaiECIAMgA0GkAWogA0HYAWoQgRQCQCADKAIAIgRBioCAgHhHBEAgAiADKQIENwIAIAJBGGogA0EcaikCADcCACACQRBqIANBFGopAgA3AgAgAkEIaiADQQxqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgBDYCAAwBCyAAQYqAgIB4NgIAIAAgASkCADcCBCAAQQxqIAFBCGopAgA3AgALIANBkAJqJAALoQsCCn8BfiMAQZACayICJAAgASgCCCIGQQRqIQUCQCAGQXtNBEAgASgCBCIEIAVPBEAgAkGoAWoiCCABKAIAIgUgBCAGIAUgBmoiCSgAAGsQ9jQCQAJAAkACQAJAAkACQAJAIAhBDBDMIEH//wNxIgMEQCADIAZqIgNBBGohByADQXtLDQggBCAHSQ0HIAMgBWooAAAhByACQSBqIAFBBBC+FCACKAIgIgpFDQYgAigCJCELIAJB8AFqIAFBARCMASAIIAUgBCAGIAkoAABrEPY0IAhBBhDMIEH//wNxIgEEfyABIAZqIgEgBEsNDCABIAVqLQAAQQBHBUEACyEIIAMgB2oiAUEEaiEDIAFBe0sNBSADIARLDQQgAkGoAWoiAyAFIAQgASABIAVqIgcoAABrEPY0IANBBBDMIEH//wNxIgMEfiABIANqIgMgBEsNBCADIAVqKQAABUIACyEMIAJBqAFqIgMgBSAEIAEgBygAAGsQ9jQgAkEoaiAKIAsgAkHwAWogCCAMIANBCBDMICIDQf//A3EEfyABIANB//8DcWoiASAESw0MIAEgBWotAABBAEcFQQALELkWDAELIAJBGGogAUEEEL4UIAIoAhgiA0UNASACKAIcIQggAkHwAWoiByABQQEQjAEgAkGoAWoiASAFIAQgBiAJKAAAaxD2NCACQShqIAMgCCAHIAFBBhDMIEH//wNxIgEEfyABIAZqIgEgBEsNCyABIAVqLQAAQQBHBUEACxCbFAsgAkGoAWoiAUGk9v4AEKUrIAJB+ABqQbj2/gApAwA3AwAgAkGw9v4AKQMANwNwIAIgAikDsAE3A4gBIAIgAikDqAE3A4ABIAEgBSAEIAYgCSgAAGsQ9jQCQAJAAkAgAUEQEMwgQf//A3EiAUUNACABIAZqIgFBBGohBiABQXtLDQIgBCAGSQ0BIAEgBWooAAAgAWoiASAESw0MIAEgBWooAAAiCEUNACABQQRqIQYDQAJAAkACQAJAIAYiAUF7TQRAIAFBBGoiBiAESw0BIAIgASABIAVqKAAAajYCmAEgAiAENgKUASACIAU2ApABIAJBEGogAkGQAWoiA0EEEL4UIAIoAhQhASACKAIQIQkgAkEIaiADQQYQvhQgCUUNBCACKAIIIgtFDQQgAigCDCEDIAJBqAFqIAFBAEEBQQEQoBggAigCrAEhByACKAKoAUEBRg0CIAIoArABIQogAQRAIAogCSAB/AoAAAsgAiABNgL4ASACIAo2AvQBIAIgBzYC8AEgAkGoAWogA0EAQQFBARCgGCACKAKsASEBIAIoAqgBQQFGDQMgAigCsAEhCSADBEAgCSALIAP8CgAACyACIAM2ArABIAIgCTYCrAEgAiABNgKoASACQZwBaiIBIAJB8ABqIAJB8AFqIAJBqAFqEM4JIAIoApwBQYCAgIB4Rg0EIAEQ3jsMBAsgASABQQRqQfD2/gAQsTsACyABQQRqIARB8Pb+ABCwOwALIAcgAigCsAFB4Pb+ABD9LwALIAEgAigCsAFB4Pb+ABD9LwALIAhBAWsiCA0ACwsgAkGoAWoiASACQShqQcgA/AoAACACQYgCaiACQYgBaikDADcDACACQYACaiACQYABaikDADcDACACQfgBaiACQfgAaikDADcDACACIAIpA3A3A/ABIAAgASACQfABahCcJSACQZACaiQADwsgBiAEQfD2/gAQsDsACyABIAZB8Pb+ABCxOwALQaD3/gAQsjsACyADIARB9PT+ABCvOwALIAMgBEGA9/4AELA7AAsgASADQYD3/gAQsTsAC0GQ9/4AELI7AAsgByAEQfD2/gAQsDsACyADIAdB8Pb+ABCxOwALIAUgBEGA9/4AELA7AAsgBiAFQYD3/gAQsTsACyABIARB9PT+ABCvOwALnQgCBn8BfiMAQTBrIgUkAAJAAkACQCACBEAgBK0gAkEMbCIGQQxrIghBDG6tfiILQiCIUARAIAunIQogASEHA0AgBkUNAyAGQQxrIQYgCiAHKAIIIApqIgpLIAdBDGohB0UNAAsLQfTehwFBNUGs34cBEMskAAsgAEEANgIIIABCgICAgBA3AgAMAQsgBUEYaiAKQQBBAUEBEKAYIAUoAhwhBwJAIAUoAhhBAUcEQCAFQQA2AhQgBSAFKAIgNgIQIAUgBzYCDCAFQQxqIAEoAgQiByAHIAEoAghqELwmIAogBSgCFCIHayEGIAUoAhAgB2ohBwJAAkACQAJAAkACQCAEDgUEAwIBAAULIAJBAUYNBiABQRRqIQEDQCAGQQNNDQkgAUEEaygCACEJIAEoAgAhAiAHIAMoAAA2AAAgBkEEayIGIAJJDQkgB0EEaiEEIAIEQCAEIAkgAvwKAAALIAFBDGohASAGIAJrIQYgAiAEaiEHIAhBDGsiCA0ACwwGCyACQQFGDQUgAUEUaiEBA0AgBkECTQ0IIAFBBGsoAgAhCSABKAIAIQIgByADLwAAOwAAIAdBAmogA0ECai0AADoAACAGQQNrIgYgAkkNCCAHQQNqIQQgAgRAIAQgCSAC/AoAAAsgAUEMaiEBIAYgAmshBiACIARqIQcgCEEMayIIDQALDAULIAJBAUYNBCABQRRqIQEDQCAGQQFNDQcgAUEEaygCACEJIAEoAgAhAiAHIAMvAAA7AAAgBkECayIGIAJJDQcgB0ECaiEEIAIEQCAEIAkgAvwKAAALIAFBDGohASAGIAJrIQYgAiAEaiEHIAhBDGsiCA0ACwwECyACQQFGDQMgAUEUaiEBA0AgBkUNBiABQQRrKAIAIQkgASgCACECIAcgAy0AADoAACAGQQFrIgYgAkkNBiAHQQFqIQQgAgRAIAQgCSAC/AoAAAsgAUEMaiEBIAYgAmshBiACIARqIQcgCEEMayIIDQALDAMLIAJBAUYNAiABQRBqIQEDQCAGIAFBBGooAgAiAkkNBSACBEAgByABKAIAIAL8CgAACyABQQxqIQEgBiACayEGIAIgB2ohByAIQQxrIggNAAsMAgsgAkEBRg0BIAFBFGohAQNAIAQgBksNBCABQQRrKAIAIQkgASgCACECIAQEQCAHIAMgBPwKAAALIAYgBGsiBiACSQ0EIAQgB2ohByACBEAgByAJIAL8CgAACyABQQxqIQEgBiACayEGIAIgB2ohByAIQQxrIggNAAsMAQsgByAFKAIgQbzfhwEQ/S8ACyAAIAUpAgw3AgAgAEEIaiAKIAZrNgIACyAFQTBqJAAPCyAFQQA2AiggBUEBNgIcIAVB6N+HATYCGCAFQgQ3AiAgBUEYakHw34cBEO8sAAupDAIHfwN+IwBB4AFrIgQkACABQQxqENg8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohByADLQAAIQMgASgCECEIIAIoAgAiAUF/RyEJA0ACQCAEKQNwIgxQRQRAIAQpA3ghCwwBCwNAAn4CQCAEKQNYIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1ggC6dBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAcQtiogBCkDqAEhCwsgC0IAUg0CCyAEQgM3A1gLIAQpA0giC0ICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyEMIAunQQFxRQ0HIAQgBCkDeEJAfSILNwN4IAQgDDcDcCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNwIAggDacgC6dqIgpBA3RqKAIAIQUgBCABNgLcASAEIAU2ApABAkACQCABRQRAQYeAgIB4IQIMAQsgCSAFQYCAgIB4R3JFBEAgBEECNgKsASAEQZiQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAEgBCgCmAEhBUGIgICAeCECDAELIARBqAFqIAUgAW0iBSADEOoPIAQoAqgBIgJBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAEhBQsgBEGAAWohBgwHCyAGIApBAnRqIAU2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQkgASgCECEBQQAhAyACKAIAIgdBf0chCgNAIAEoAgAhBSAEIAc2AsABIAQgBTYC3AECQCAHBH8gCiAFQYCAgIB4R3INASAEQQI2AkwgBEGYkP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQVBiICAgHgFQYeAgIB4CyECIARB0AFqIQYMAwsgBEHIAGogBSAHbSIFIAkQ6g8gBCgCSCICQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiAFNgIAIAZBBGohBiABQQhqIQEgCCADQQFqIgNHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCELIAQgBCkCSDcDKCAEQQA2AjggBCALNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAI2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAALogsCCX8DfiMAQcABayICJAAgAUEMaigCCCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEGIAJBIGogBBDcOyAEKAIUIQcgBCgCDCEIIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBkUNBAsgAkIANwI4IAIgBjYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAggAyAIaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBCAEBEAgBEHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBDYCMCACQcAANgIsIAJBLGogAxDeEAsgAyEFAkAgA0E/cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQtBACEEIAJBADYCUCACIAY2AkggAiAFNgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAHDQEMCgsgAwRAIAZBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghBiAHRQ0BCyADIAdHDQEgAyEEDAgLIAEoAhAhB0EAIQUDQAJAIAUgB2osAAAiAUEATgRAIAUgBmogAToAAAwBCyACQRhqIAJBLGoQhj0gBUEDdiIBIAIoAhwiCE8NAyACKAIYIAFqIgEgAS0AAEF+IAVBB3F3cToAACAEQQFqIQQLIAMgBUEBaiIFRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggAxC/FCACQZgBaiEFIAEoAhAhCCAHIQQDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBRC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgCCANpyALp2oiAWosAAAiA0EATgRAIAEgBmogAzoAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIDIAIoAhQiB0kEQCACKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAEQQFqIQQMAQsLIAMgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgBRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBBCjPQALQcAAIAQQoz0ACyACQdgAaiACQSxqIgYQghQgAkH4AGoiAxCXKSACQcgAaiIBKAIAIQggAigCTCEFIAEgAkGAAWoiBykCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiAFNgJ8IAIgCDYCeCACQQhqIAMQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAHKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAU2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgByACQeAAaikCADcDACACIAIpAlg3A3ggAiAENgKMASAAIAEgAxDBHSACQUBrEM8vIAYQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC6ILAgl/A34jAEHAAWsiAiQAIAFBDGooAgghAwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBiACQSBqIAQQ3DsgBCgCFCEHIAQoAgwhCCACKAIkIQogAigCICEJIANBA3YgA0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgZFDQQLIAJCADcCOCACIAY2AjQgAiAENgIwIAJBwAA2AiwgAkEsaiAIIAMgCGogCSAKEL8YDAELQcAAIQYgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQQgBARAIARBwAAQrTYiBkUNAgsgAkIANwI4IAIgBjYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAMQ3hALIAMhBQJAIANBP3EiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELQQAhBCACQQA2AlAgAiAGNgJIIAIgBTYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBw0BDAoLIAMEQCAGQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQYgB0UNAQsgAyAHRw0BIAMhBAwICyABKAIQIQdBACEFA0ACQCAFIAdqLAAAIgFBAE4EQCAFIAZqIAE6AAAMAQsgAkEYaiACQSxqEIY9IAVBA3YiASACKAIcIghPDQMgAigCGCABaiIBIAEtAABBfiAFQQdxd3E6AAAgBEEBaiEECyADIAVBAWoiBUcNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAMQvxQgAkGYAWohBSABKAIQIQggByEEA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAUQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQogAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAggDacgC6dqIgFqLAAAIgNBAE4EQCABIAZqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgdJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBEEBaiEEDAELCyADIAdBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAUQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAQQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIGEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEIIAIoAkwhBSABIAJBgAFqIgcpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBTYCfCACIAg2AnggAkEIaiADENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBykCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAFNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAcgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBDYCjAEgACABIAMQ2B0gAkFAaxDPLyAGEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAumDAIHfwN+IwBB4AFrIgQkACABQQxqENs8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohByADLQAAIQMgASgCECEIIAIoAgAiAUF/RyEJA0ACQCAEKQNwIgxQRQRAIAQpA3ghCwwBCwNAAn4CQCAEKQNYIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1ggC6dBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAcQtiogBCkDqAEhCwsgC0IAUg0CCyAEQgM3A1gLIAQpA0giC0ICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyEMIAunQQFxRQ0HIAQgBCkDeEJAfSILNwN4IAQgDDcDcCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNwIAggDacgC6dqQQJ0IgpqKAIAIQUgBCABNgLcASAEIAU2ApABAkACQCABRQRAQYeAgIB4IQIMAQsgCSAFQYCAgIB4R3JFBEAgBEECNgKsASAEQZiQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAEgBCgCmAEhBUGIgICAeCECDAELIARBqAFqIAUgAW0iBSADEOoPIAQoAqgBIgJBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAEhBQsgBEGAAWohBgwHCyAGIApqIAU2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQkgASgCECEBQQAhAyACKAIAIgdBf0chCgNAIAEoAgAhBSAEIAc2AsABIAQgBTYC3AECQCAHBH8gCiAFQYCAgIB4R3INASAEQQI2AkwgBEGYkP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQVBiICAgHgFQYeAgIB4CyECIARB0AFqIQYMAwsgBEHIAGogBSAHbSIFIAkQ6g8gBCgCSCICQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiAFNgIAIAZBBGohBiABQQRqIQEgCCADQQFqIgNHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCELIAQgBCkCSDcDKCAEQQA2AjggBCALNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAI2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAAL7AsCCH8BfiMAQSBrIgQkACABQQxqIQggAUEYaiEJIAFBLmohBSABQSxqIQYgAS0ALCEDA0ACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQf8BcUEBaw4GAAEGBQIKAwsgAS0AOEEEcUUNCCABLQAtIgNBAU0NBwwRCyABKAIAQYCAgIB4RiIKRQRAIAEoAggiByABLwEuIgNLDQYMDwtB1MXQABCyOwALIAEoAjBFDQogAS0ALSIDQQFNDQEMCQsgAS0ALSIDQQlLDQcDQCAEQQhqIAIgBSADQf8BcSIDakEKIANrEIsZAkAgBC0ACEEERgRAIAQoAgwhAwwBCyAEKQMIIgtC/wGDQgRRBEAgC0IgiKchAwwBCyAAIAs3AgAMDQsgASABLQAtIANqIgM6AC0gA0H/AXFBCkkNAAsMBwsDQCAEQQhqIAIgBSADQf8BcSIDakECIANrEIsZAkAgBC0ACEEERgRAIAQoAgwhAwwBCyAEKQMIIgtC/wGDQgRRBEAgC0IgiKchAwwBCyAAIAs3AgAMDAsgASABLQAtIANqIgM6AC0gA0H/AXFBAkkNAAsMBwsCQCABLQA4QRBxRQ0AIAkoAgBBgICAgHhGBEAgCRCGMCABQQA2AiAgAUKAgICAEDcCGAsgBEEIaiACIAkQzxUCQCAELQAIQQRGDQAgBCkDCCILQv8Bg0IEUQ0AIAAgCzcCAAwLCyABKAIwIgNFDQAgAyABKAIcIAEoAiAQgzEgASgCMEHMtMIAQQEQgzELIAEoAjAhAyABQQA2AjAgBhDdLSABIAM2AjBBBSEDIAFBBTYCLAwNCwJAIAEtADhBCHFFDQAgCCgCAEGAgICAeEYEQCAIEIYwIAFBADYCFCABQoCAgIAQNwIMCyAEQQhqIAIgCBDPFQJAIAQtAAhBBEYNACAEKQMIIgtC/wGDQgRRDQAgACALNwIADAoLIAEoAjAiA0UNACADIAEoAhAgASgCFBCDMSABKAIwQcy0wgBBARCDMQsgASgCMCEDIAFBADYCMCAGEN0tIAEgAzYCMEEEIQMgAUEEOgAsDAwLA0AgBEEIaiACIAEoAgQgA2ogByADaxCLGQJAIAQtAAhBBEYEQCAEKAIMIQMMAQsgBCkDCCILQv8Bg0IEUQRAIAtCIIinIQMMAQsgACALNwIADAkLIAEgAS8BLiADaiIDOwEuIAEoAggiByADQf//A3EiA0sNAAsMCAsDQAJAIARBCGogAiAFIANB/wFxIgNqQQIgA2sQixkgAQJ/IAQtAAhBBEYEQCAEKAIMDAELIAQpAwgiC0L/AYNCBFINASALQiCIpwsgAS0ALWoiAzoALSADQf8BcUECSQ0BDAsLCyAAIAs3AgAMBgsgASgCMAwHCyAAQQQ6AAAMBAsCQCABLQAuQR9HDQAgAS0AL0GLAUcNACABLQAwQQhHDQAgASABLQAxIgc6ADggB0EgTw0AIAEgASgBMjYCJCABIAEtADc6AChBACEDAkAgB0ECcQRAIARBCGoQjytBGEEIEK02IgNFDQEgAyAEKQMINwMAIANBEGogBEEYaikDADcDACADQQhqIARBEGopAwA3AwAgAyAFQQoQgzELIAYQ3S0gASADNgIwQQEhAyABQQE2AiwMCQtBCEEYEKM9AAsgAEGgvvsAQRMQyxoMAwsgBS8AACABKAIwEIU7Qf//A3FHDQELIAYQ3S1BBiEDIAZBBjoAAAwFCyAAEIc7CyAEQSBqJAAPCyABKAIwIgMEfyADQQAgASAKGygCBCAHEIMxIAEoAjAFQQALCyEDIAFBADYCMCAGEN0tIAEgAzYCMEEDIQMgAUEDOgAsDAELIAEoAjAiAwRAIAMgBUECEIMxCyAEQQhqIAUvAABBxMXQABDOGCABEIYwIAFBCGogBEEQaigCADYCACABIAQpAgg3AgAgASgCMCEDIAFBADYCMCAGEN0tIAEgAzYCMCABQQA7AS5BAiEDIAFBAjoALAwACwALxgoBCX8jAEEwayIKJAACQCABKAIAQQFHDQAgASgCBCEEAkACQAJAAkACQCABKAIIQQFGBEAgBCABKAIUIgNPDQYgASgCECIGIARBAXRqLwAAIAJB//8DcUcNAyABKAIMIQUgAUEBNgIAIAEgBEEBaiICNgIEIAUNASABQQA2AgggAiADTw0GQQEhCSAGIAJBAXRqLwAAQcAASQ0GIApBCGogASACEK4PIAooAgwhBSAKKAIIIQkMBgsgBCABKAIUIgdPDQUgBEEBaiEGIAEoAhAiCCAEQQF0ai8AACIEQTBJDQEgBEE/cSIFQTBJIQsCQANAIARB//8DcSIDQcAASQ0BIATBQQBIDQQCQCADQcCAAUkNACADQcD/AU8EQCAGQQJqIQYMAQsgBkEBaiEGCyAFIQQgC0UNAAsMAgsgBiAHTw0FIAggBkEBdGovAAAgAkH//wNxRw0CIAZBAWohAiAEQf//A3FBMEYEQCABIAI2AgQgAUEBNgIAIAFBADYCCCACIAdPDQZBASEJIAggAkEBdGovAABBwABJDQYgCkEoaiABIAIQrg8gCigCLCEFIAooAighCQwGC0EBIQkgAUEBNgIIIAEgAjYCBCABQQE2AgAgASAEQf//A3FBMWs2AgwMBQtBASEJIAFBATYCCCABIAVBAWs2AgwMBAsgBAR/IAYFIAYgB08NBCAIIAZBAXRqLwAAIQQgBkEBagshAyAEQf//A3EiBUEBaiEEIAVBBU8EQCACQf//A3EhCwNAIAMgB08NBSADQQFqIQUCfyAIIANBAXRqLwAAIAtNBEAgBSAHTw0HQQJBBEEDIAggBUEBdGovAAAiBUH//wNGGyAFQYD4A0kbIANqIQMgBCAEQQF2awwBCyAFIAdPDQYCfyAIIAVBAXRqLwAAIgVBgPgDTwRAIANBAmohBiAFQf//A0cEQCAGIAdPDQkgCCAGQQF0ai8AACAFQRB0IANqakGDgIAgagwCCyAGIAdPDQggA0EDaiIFIAdPDQggCCAFQQF0ai8AACADIAggBkEBdGovAABBEHRqakEEagwBCyADIAVqQQJqCyEDIARBAXYLIgRBBUsNAAsLIAJB//8DcSELA0AgAyAHTw0EIANBAWohBiALIAggA0EBdGovAABGDQMgBiAHTw0EAn8gA0ECaiAIIAZBAXRqLwAAQf//AXEiBUGAgAFJDQAaIANBBGogBUH//wFGDQAaIANBA2oLIQMgBEEBayIEQQFLDQALIAMgB08NAyAIIANBAXRqLwAAIAJB//8DcUYNAQsgAUEANgIADAILIAFBATYCACABIANBAWoiAjYCBCACIAdPDQFBASEJIAggAkEBdGovAABBwABJDQEgCkEgaiABIAIQrg8gCigCJCEFIAooAiAhCQwBCyAGIAdPDQACQCAHAn8CQCAIIAZBAXRqLgAAIgRBAE4EQCADQQJqIQIgBEGAgAFJDQEgBEH//wFGBEAgAiAHTw0FIANBA2oiBCAHTw0FIAMgCCAEQQF0ai8AACAIIAJBAXRqLwAAQRB0cmpBBGoMAwsgAiAHTw0DIAggAkEBdGovAAAgBEEQdCADampB/f///wNrDAILIAEgBjYCBCABQQE2AgAgCkEYaiABIAYQrg8gCigCHCEFIAooAhghCQwDCyACIARB//8DcWoLIgNNDQAgASADNgIEQQEhCSABQQE2AgAgCCADQQF0ai8AAEHAAEkNASAKQRBqIAEgAxCuDyAKKAIUIQUgCigCECEJDAELCyAAIAU2AgQgACAJNgIAIApBMGokAAuGDAIGfwN+IwBB4AFrIgQkACABQQxqENk8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQcgAigCACECIAEoAhAhCANAAkAgBCkDcCILUEUEQCAEKQN4IQoMAQsDQAJ+AkAgBCkDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAQgClCtQgGGNwNYIAqnQQFxRQ0AIAQgBCkDYDcDsAEMAQsgBCgCaEUNASAEQagBaiAFELYqIAQpA6gBIQoLIApCAFINAgsgBEIDNwNYCyAEKQNIIgpCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOwAQshCyAKp0EBcUUNByAEIAQpA3hCQH0iCjcDeCAEIAs3A3AgC1ANAAsLIAQgC0IBIAt6IgyGhTcDcCAEIAggDKcgCqdqIglBAXRqLwEAIgE2ApABIAQgAjYC3AECQAJ/IAKsIAGtfiIKQiCIpyAKpyIBQR91RwRAIARBAjYCrAEgBEGskP8ANgKoASAEQgI3ArQBIARBggw2AswBIARBggw2AsQBIAQgBEHAAWo2ArABIAQgBEHcAWo2AsgBIAQgBEGQAWo2AsABIARBmAFqIARBqAFqEJkOIARBiAFqIARBpAFqKAIANgIAIAQgBCkCnAE3A4ABQYiAgIB4IQMgBCgCmAEMAQsgBEGoAWogASAHEOoPIAQoAqgBIgNBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAELIQUgBEGAAWohBgwHCyAGIAlBAnRqIAE2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgASgCECEFQQAhASACKAIAIgmsIQoDQCAEIAUvAQAiAjYC3AEgBCAJNgLAASACrSAKfiILQiCIpyALpyICQR91RwRAIARBAjYCTCAEQayQ/wA2AkggBEICNwJUIARBggw2AqABIARBggw2ApgBIAQgBEGUAWo2AlAgBCAEQcABajYCnAEgBCAEQdwBajYClAEgBEGsAWogBEHIAGoQmQ4gBEHYAWogBEG4AWooAgA2AgAgBCAEKQKwATcD0AEgBCgCrAEhBSAEQdABaiEGQYiAgIB4IQMMAwsgBEHIAGogAiAHEOoPIAQoAkgiA0GTgICAeEcEQCAEQdgBaiAEQdgAaigCADYCACAEIAQpAlA3A9ABIAQoAkwhBSAEQdABaiEGDAMLIAYgAjYCACAGQQRqIQYgBUECaiEFIAggAUEBaiIBRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBSAEKAI0IQMgASAEQdAAaiIGKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBTYCSCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAGKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAYgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAU2AgggACADNgIEIABBKToAACAAIAYpAgA3AgwgAEEUaiAGQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC4YMAgZ/A34jAEHgAWsiBCQAIAFBDGoQ2DwhCCAEQRBqIAEQkjYQ7iUgCEECdCIFIQcCQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiByAFSQ0BC0HAACEGIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgZFDQELIAQgBjYCMCAEIAc2AiwgBEHAADYCKCAFBEAgBkEAIAX8CwALIAQgCDYCOCAEIAU2AjQgBCgCEEUNAyAEKAIkIAQoAiBGDQQgBEHIAGogBEEQahDINCAEQegAaiEFIAMtAAAhByACKAIAIQIgASgCECEIA0ACQCAEKQNwIgtQRQRAIAQpA3ghCgwBCwNAAn4CQCAEKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgBCAKUK1CAYY3A1ggCqdBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAUQtiogBCkDqAEhCgsgCkIAUg0CCyAEQgM3A1gLIAQpA0giCkICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyELIAqnQQFxRQ0HIAQgBCkDeEJAfSIKNwN4IAQgCzcDcCALUA0ACwsgBCALQgEgC3oiDIaFNwNwIAQgCCAMpyAKp2oiCUEDdGooAgAiATYCkAEgBCACNgLcAQJAAn8gAawgAqx+IgpCIIinIAqnIgFBH3VHBEAgBEECNgKsASAEQayQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAFBiICAgHghAyAEKAKYAQwBCyAEQagBaiABIAcQ6g8gBCgCqAEiA0GTgICAeEYNASAEQYgBaiAEQbgBaigCADYCACAEIAQpArABNwOAASAEKAKsAQshBSAEQYABaiEGDAcLIAYgCUECdGogATYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhByABKAIQIQVBACEBIAIoAgAiCawhCgNAIAQgBSgCACICNgLcASAEIAk2AsABIAKsIAp+IgtCIIinIAunIgJBH3VHBEAgBEECNgJMIARBrJD/ADYCSCAEQgI3AlQgBEGCDDYCoAEgBEGCDDYCmAEgBCAEQZQBajYCUCAEIARBwAFqNgKcASAEIARB3AFqNgKUASAEQawBaiAEQcgAahCZDiAEQdgBaiAEQbgBaigCADYCACAEIAQpArABNwPQASAEKAKsASEFIARB0AFqIQZBiICAgHghAwwDCyAEQcgAaiACIAcQ6g8gBCgCSCIDQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiACNgIAIAZBBGohBiAFQQhqIQUgCCABQQFqIgFHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCEKIAQgBCkCSDcDKCAEQQA2AjggBCAKNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAM2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAALhgwCBn8DfiMAQeABayIEJAAgAUEMahDZPCEIIARBEGogARCSNhDuJSAIQQJ0IgUhBwJAAkACQAJAAkAgBUE8cSIGBEAgBSAGa0FAayIHIAVJDQELQcAAIQYgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBkUNAQsgBCAGNgIwIAQgBzYCLCAEQcAANgIoIAUEQCAGQQAgBfwLAAsgBCAINgI4IAQgBTYCNCAEKAIQRQ0DIAQoAiQgBCgCIEYNBCAEQcgAaiAEQRBqEMg0IARB6ABqIQUgAy0AACEHIAIoAgAhAiABKAIQIQgDQAJAIAQpA3AiC1BFBEAgBCkDeCEKDAELA0ACfgJAIAQpA1giCkIDUgRAAkACQAJAIApCAlENACAEIApQrUIBhjcDWCAKp0EBcUUNACAEIAQpA2A3A7ABDAELIAQoAmhFDQEgBEGoAWogBRC2KiAEKQOoASEKCyAKQgBSDQILIARCAzcDWAsgBCkDSCIKQgJRDQkgBEIANwNIIAQpA1AMAQsgBCkDsAELIQsgCqdBAXFFDQcgBCAEKQN4QkB9Igo3A3ggBCALNwNwIAtQDQALCyAEIAtCASALeiIMhoU3A3AgBCAIIAynIAqnaiIJQQF0ai4BACIBNgKQASAEIAI2AtwBAkACfyABrCACrH4iCkIgiKcgCqciAUEfdUcEQCAEQQI2AqwBIARBrJD/ADYCqAEgBEICNwK0ASAEQYIMNgLMASAEQYIMNgLEASAEIARBwAFqNgKwASAEIARB3AFqNgLIASAEIARBkAFqNgLAASAEQZgBaiAEQagBahCZDiAEQYgBaiAEQaQBaigCADYCACAEIAQpApwBNwOAAUGIgICAeCEDIAQoApgBDAELIARBqAFqIAEgBxDqDyAEKAKoASIDQZOAgIB4Rg0BIARBiAFqIARBuAFqKAIANgIAIAQgBCkCsAE3A4ABIAQoAqwBCyEFIARBgAFqIQYMBwsgBiAJQQJ0aiABNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEHIAEoAhAhBUEAIQEgAigCACIJrCEKA0AgBCAFLgEAIgI2AtwBIAQgCTYCwAEgAqwgCn4iC0IgiKcgC6ciAkEfdUcEQCAEQQI2AkwgBEGskP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQUgBEHQAWohBkGIgICAeCEDDAMLIARByABqIAIgBxDqDyAEKAJIIgNBk4CAgHhHBEAgBEHYAWogBEHYAGooAgA2AgAgBCAEKQJQNwPQASAEKAJMIQUgBEHQAWohBgwDCyAGIAI2AgAgBkEEaiEGIAVBAmohBSAIIAFBAWoiAUcNAAsLIARByABqIgIQlykgBEEwaiIBKAIAIQUgBCgCNCEDIAEgBEHQAGoiBikCADcDACAEKQMoIQogBCAEKQJINwMoIARBADYCOCAEIAo3AlQgBEEANgJQIAQgAzYCTCAEIAU2AkggBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJINwIIIAFBEGogBikCADcCACABQRhqIARB2ABqIgcoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEE8aiIBIARBqAFqEOUZIAcgBEEgaikCADcDACAGIARBGGopAgA3AwAgBCAEKQIQNwNIIAAgASACEModIARBKGoQzy8MAgtBBEEcEKM9AAsgACAFNgIIIAAgAzYCBCAAQSk6AAAgACAGKQIANwIMIABBFGogBkEIaigCADYCACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHgAWokAAufDAIIfwR+IwBB8AFrIgMkACABQQxqENw8IQcgA0EIaiABEJI2EO4lIAdBA3QiBCEFAkACQAJAAkACQAJAIARBOHEiBgRAIAQgBmtBQGsiBSAESQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAMgBjYCKCADIAU2AiQgA0HAADYCICAEBEAgBkEAIAT8CwALIAMgBzYCMCADIAQ2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEEIAIoAgAhByABKAIQIQgDQAJAIAMpA2giDFBFBEAgAykDcCELDAELA0ACfgJAIAMpA1AiC0IDUgRAAkACQAJAIAtCAlENACADIAtQrUIBhjcDUCALp0EBcUUNACADIAMpA1g3A9gBDAELIAMoAmBFDQEgA0HQAWogBRC2KiADKQPQASELCyALQgBSDQILIANCAzcDUAsgAykDQCILQgJRDQkgA0IANwNAIAMpA0gMAQsgAykD2AELIQwgC6dBAXFFDQcgAyADKQNwQkB9Igs3A3AgAyAMNwNoIAxQDQALCyADIAxCASAMeiINhoU3A2ggA0HQAWoiCSAHIAggDacgC6dqIgpBBXRqIgEpAwAiCyABKQMIIgwgASkDECINIAEpAxgiDhCgCiADKALQAUUEQCACKAIEIQEgAyAONwOoASADIA03A6ABIAMgDDcDmAEgAyALNwOQASADQcyR/wA2ArgBIANCBDcCxAEgA0GDDDYC7AEgA0H0CzYC5AEgAyABQQFqNgLgASADQbsHNgLcASADIAE2AtgBIANBzAE2AtQBIANBoJL/ADYC0AEgAyAJNgLAASADIANBkAFqNgLoASADQQQ2ArwBIANBgAFqIANBuAFqEJkOIAMpAoABIQsgAykCiAEhDAwHCyADQdABaiADKQPYASILIAQtAAAQjRAgAygC0AEiAUGTgICAeEcEQCADKQLcASEMIAMpAtQBIQsMCAUgBiAKQQN0aiALNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEEQQAhBQNAIANBQGsiCiAJIAQpAwAiCyAEKQMIIgwgBEEQaikDACINIARBGGopAwAiDhCgCiADKAJARQRAIAIoAgQhASADIA43A+gBIAMgDTcD4AEgAyAMNwPYASADIAs3A9ABIANBzJH/ADYCkAEgA0IENwKcASADQYMMNgJcIANB9As2AlQgAyABQQFqNgJQIANBuwc2AkwgAyABNgJIIANBzAE2AkQgA0Ggkv8ANgJAIAMgCjYCmAEgAyADQdABajYCWCADQQQ2ApQBIANBvAFqIANBkAFqEJkOIAMpArwBIQsgAykCxAEhDAwDCyADQUBrIAMpA0giCyAILQAAEI0QIAMoAkAiAUGTgICAeEcEQCADKQJMIQwgAykCRCELDAQLIAYgCzcDACAGQQhqIQYgBEEgaiEEIAcgBUEBaiIFRw0ACwsgA0FAayICEJcpIANBKGoiASgCACEEIAMoAiwhBSABIANByABqIgYpAgA3AwAgAykDICELIAMgAykCQDcDICADQQA2AjAgAyALNwJMIANBADYCSCADIAU2AkQgAyAENgJAIAMgAhDXOyADKAIAIQRBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBTYC2AEgAyAENgLUASADIAE2AtABIANBNGoiASADQdABahDkGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDGHSADQSBqEM8vDAMLQQRBHBCjPQALQYKAgIB4IQELIAAgDDcCECAAIAs3AgggACABNgIEIABBKToAACADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0HwAWokAAuDDAIGfwN+IwBB4AFrIgQkACABQQxqENs8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQcgAigCACECIAEoAhAhCANAAkAgBCkDcCILUEUEQCAEKQN4IQoMAQsDQAJ+AkAgBCkDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAQgClCtQgGGNwNYIAqnQQFxRQ0AIAQgBCkDYDcDsAEMAQsgBCgCaEUNASAEQagBaiAFELYqIAQpA6gBIQoLIApCAFINAgsgBEIDNwNYCyAEKQNIIgpCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOwAQshCyAKp0EBcUUNByAEIAQpA3hCQH0iCjcDeCAEIAs3A3AgC1ANAAsLIAQgC0IBIAt6IgyGhTcDcCAEIAggDKcgCqdqQQJ0IglqKAIAIgE2ApABIAQgAjYC3AECQAJ/IAGsIAKsfiIKQiCIpyAKpyIBQR91RwRAIARBAjYCrAEgBEGskP8ANgKoASAEQgI3ArQBIARBggw2AswBIARBggw2AsQBIAQgBEHAAWo2ArABIAQgBEHcAWo2AsgBIAQgBEGQAWo2AsABIARBmAFqIARBqAFqEJkOIARBiAFqIARBpAFqKAIANgIAIAQgBCkCnAE3A4ABQYiAgIB4IQMgBCgCmAEMAQsgBEGoAWogASAHEOoPIAQoAqgBIgNBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAELIQUgBEGAAWohBgwHCyAGIAlqIAE2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgASgCECEFQQAhASACKAIAIgmsIQoDQCAEIAUoAgAiAjYC3AEgBCAJNgLAASACrCAKfiILQiCIpyALpyICQR91RwRAIARBAjYCTCAEQayQ/wA2AkggBEICNwJUIARBggw2AqABIARBggw2ApgBIAQgBEGUAWo2AlAgBCAEQcABajYCnAEgBCAEQdwBajYClAEgBEGsAWogBEHIAGoQmQ4gBEHYAWogBEG4AWooAgA2AgAgBCAEKQKwATcD0AEgBCgCrAEhBSAEQdABaiEGQYiAgIB4IQMMAwsgBEHIAGogAiAHEOoPIAQoAkgiA0GTgICAeEcEQCAEQdgBaiAEQdgAaigCADYCACAEIAQpAlA3A9ABIAQoAkwhBSAEQdABaiEGDAMLIAYgAjYCACAGQQRqIQYgBUEEaiEFIAggAUEBaiIBRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBSAEKAI0IQMgASAEQdAAaiIGKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBTYCSCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAGKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAYgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAU2AgggACADNgIEIABBKToAACAAIAYpAgA3AgwgAEEUaiAGQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC98LAgZ/BH4jAEGgAWsiAyQAIAFBDGoQ2DwhByADQQhqIAEQkjYQ7iUgB0EFdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBIHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEHIAIoAgAhBCABKAIQIQgCQANAAkAgAykDaCIKUEUEQCADKQNwIQkMAQsDQAJ+AkAgAykDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAMgCVCtQgGGNwNQIAmnQQFxRQ0AIAMgAykDWDcDiAEMAQsgAygCYEUNASADQYABaiAFELYqIAMpA4ABIQkLIAlCAFINAgsgA0IDNwNQCyADKQNAIglCAlENCiADQgA3A0AgAykDSAwBCyADKQOIAQshCiAJp0EBcUUNCCADIAMpA3BCQH0iCTcDcCADIAo3A2ggClANAAsLIAMgCkIBIAp6IguGhTcDaEKAgICAgICAgIB/IQwCQAJ+AkACQCAIIAunIAmnaiIBQQN0aikDACILQoCAgICAgICAgH9SIAQoAgApAwAiCUJ/UnJFBEBCACEKDAELIAlQDQMgCyALIAl/IgwgCX59QgAgCUJ/UhshCiALQgBZDQELIAwgCiAEKAIIKQMAV619DAELIAwgCiAEKAIEKQMAWa18CyEJIANBgAFqIgIgCSAJQj+HELIuIAIgAykDgAEiCSADKQOIASIKIAMpA5ABIgwgAykDmAEiCyAHLQAAENAOIAMoAoABIgJBk4CAgHhHDQIgBiABQQV0aiIBIAs3AxggASAMNwMQIAEgCjcDCCABIAk3AwAMAQsLQbyP/wAQ4isACyADKQKEASEJIAAgAykCjAE3AhAMBgtBwAAgBBCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQggAigCACEFIAEoAhAhBEEAIQEDQEKAgICAgICAgIB/IQwgBSgCACkDACEJAn4CQAJAIAQpAwAiCkKAgICAgICAgIB/UQRAQgAhCyAJQn9RDQELIAlQDQggCiAKIAl/IgwgCX59QgAgCUJ/UhshCyAKQgBZDQELIAwgCyAFKAIIKQMAV619DAELIAwgCyAFKAIEKQMAWa18CyEJIANBQGsiAiAJIAlCP4cQsi4gAiADKQNAIgkgAykDSCIKIAMpA1AiDCADKQNYIgsgCC0AABDQDiADKAJAIgJBk4CAgHhHDQIgBiAJNwMAIAZBGGogCzcDACAGQRBqIAw3AwAgBiAKNwMIIARBCGohBCAGQSBqIQYgByABQQFqIgFHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEEIAEgA0HIAGoiBikCADcDACADKQMgIQkgAyADKQJANwMgIANBADYCMCADIAk3AkwgA0EANgJIIAMgBDYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBDYCiAEgAyAFNgKEASADIAE2AoABIANBNGoiASADQYABahDiGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDOHSADQSBqEM8vDAILIAMpAkQhCSAAIAMpAkw3AhALIAAgCTcCCCAAQSk6AAAgACACNgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQaABaiQADwtBvI//ABDiKwALQQRBHBCjPQAL/wsCBn8DfiMAQeABayIEJAAgAUEMaigCCCEIIARBEGogARCSNhDuJSAIQQJ0IgYhBwJAAkACQAJAAkAgBkE8cSIFBEAgBiAFa0FAayIHIAZJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgBCAFNgIwIAQgBzYCLCAEQcAANgIoIAYEQCAFQQAgBvwLAAsgBCAINgI4IAQgBjYCNCAEKAIQRQ0DIAQoAiQgBCgCIEYNBCAEQcgAaiAEQRBqEMg0IARB6ABqIQYgAy0AACEHIAIoAgAhAiABKAIQIQgDQAJAIAQpA3AiC1BFBEAgBCkDeCEKDAELA0ACfgJAIAQpA1giCkIDUgRAAkACQAJAIApCAlENACAEIApQrUIBhjcDWCAKp0EBcUUNACAEIAQpA2A3A7ABDAELIAQoAmhFDQEgBEGoAWogBhC2KiAEKQOoASEKCyAKQgBSDQILIARCAzcDWAsgBCkDSCIKQgJRDQkgBEIANwNIIAQpA1AMAQsgBCkDsAELIQsgCqdBAXFFDQcgBCAEKQN4QkB9Igo3A3ggBCALNwNwIAtQDQALCyAEIAtCASALeiIMhoU3A3AgBCAIIAynIAqnaiIJai0AACIBNgKQASAEIAI2AtwBAkACfyACrCABrX4iCkIgiKcgCqciA0EfdUcEQCAEQQI2AqwBIARBrJD/ADYCqAEgBEICNwK0ASAEQYIMNgLMASAEQYIMNgLEASAEIARBwAFqNgKwASAEIARB3AFqNgLIASAEIARBkAFqNgLAASAEQZgBaiAEQagBahCZDiAEQYgBaiAEQaQBaigCADYCACAEIAQpApwBNwOAAUGIgICAeCEBIAQoApgBDAELIARBqAFqIAMgBxDqDyAEKAKoASIBQZOAgIB4Rg0BIARBiAFqIARBuAFqKAIANgIAIAQgBCkCsAE3A4ABIAQoAqwBCyEDIARBgAFqIQUMBwsgBSAJQQJ0aiADNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEGIAEoAhAhB0EAIQMgAigCACIJrCEKA0AgBCADIAdqLQAAIgE2AtwBIAQgCTYCwAEgAa0gCn4iC0IgiKcgC6ciAkEfdUcEQCAEQQI2AkwgBEGskP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQMgBEHQAWohBUGIgICAeCEBDAMLIARByABqIAIgBhDqDyAEKAJIIgFBk4CAgHhHBEAgBEHYAWogBEHYAGooAgA2AgAgBCAEKQJQNwPQASAEKAJMIQMgBEHQAWohBQwDCyAFIAI2AgAgBUEEaiEFIAggA0EBaiIDRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBiAEKAI0IQMgASAEQdAAaiIFKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBjYCSCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBjYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAUgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAM2AgggACABNgIEIABBKToAACAAIAUpAgA3AgwgAEEUaiAFQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC/8LAgZ/A34jAEHgAWsiBCQAIAFBDGooAgghCCAEQRBqIAEQkjYQ7iUgCEECdCIGIQcCQAJAAkACQAJAIAZBPHEiBQRAIAYgBWtBQGsiByAGSQ0BC0HAACEFIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgVFDQELIAQgBTYCMCAEIAc2AiwgBEHAADYCKCAGBEAgBUEAIAb8CwALIAQgCDYCOCAEIAY2AjQgBCgCEEUNAyAEKAIkIAQoAiBGDQQgBEHIAGogBEEQahDINCAEQegAaiEGIAMtAAAhByACKAIAIQIgASgCECEIA0ACQCAEKQNwIgtQRQRAIAQpA3ghCgwBCwNAAn4CQCAEKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgBCAKUK1CAYY3A1ggCqdBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAYQtiogBCkDqAEhCgsgCkIAUg0CCyAEQgM3A1gLIAQpA0giCkICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyELIAqnQQFxRQ0HIAQgBCkDeEJAfSIKNwN4IAQgCzcDcCALUA0ACwsgBCALQgEgC3oiDIaFNwNwIAQgCCAMpyAKp2oiCWosAAAiATYCkAEgBCACNgLcAQJAAn8gAawgAqx+IgpCIIinIAqnIgNBH3VHBEAgBEECNgKsASAEQayQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAFBiICAgHghASAEKAKYAQwBCyAEQagBaiADIAcQ6g8gBCgCqAEiAUGTgICAeEYNASAEQYgBaiAEQbgBaigCADYCACAEIAQpArABNwOAASAEKAKsAQshAyAEQYABaiEFDAcLIAUgCUECdGogAzYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhBiABKAIQIQdBACEDIAIoAgAiCawhCgNAIAQgAyAHaiwAACIBNgLcASAEIAk2AsABIAGsIAp+IgtCIIinIAunIgJBH3VHBEAgBEECNgJMIARBrJD/ADYCSCAEQgI3AlQgBEGCDDYCoAEgBEGCDDYCmAEgBCAEQZQBajYCUCAEIARBwAFqNgKcASAEIARB3AFqNgKUASAEQawBaiAEQcgAahCZDiAEQdgBaiAEQbgBaigCADYCACAEIAQpArABNwPQASAEKAKsASEDIARB0AFqIQVBiICAgHghAQwDCyAEQcgAaiACIAYQ6g8gBCgCSCIBQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEDIARB0AFqIQUMAwsgBSACNgIAIAVBBGohBSAIIANBAWoiA0cNAAsLIARByABqIgIQlykgBEEwaiIBKAIAIQYgBCgCNCEDIAEgBEHQAGoiBSkCADcDACAEKQMoIQogBCAEKQJINwMoIARBADYCOCAEIAo3AlQgBEEANgJQIAQgAzYCTCAEIAY2AkggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJINwIIIAFBEGogBSkCADcCACABQRhqIARB2ABqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEE8aiIBIARBqAFqEOUZIAcgBEEgaikCADcDACAFIARBGGopAgA3AwAgBCAEKQIQNwNIIAAgASACEModIARBKGoQzy8MAgtBBEEcEKM9AAsgACADNgIIIAAgATYCBCAAQSk6AAAgACAFKQIANwIMIABBFGogBUEIaigCADYCACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHgAWokAAvJCwIJfwR+IwBBoAFrIgMkACABQQxqENs8IQcgA0EIaiABEJI2EO4lIAdBBXQiBCEFAkACQAJAAkACQAJAAkACQCAEQSBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEIIAIoAgghCSACKAIAIQUgASgCECEKAkADQAJAIAMpA2giDVBFBEAgAykDcCEMDAELA0ACfgJAIAMpA1AiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDUCAMp0EBcUUNACADIAMpA1g3A4gBDAELIAMoAmBFDQEgA0GAAWogCBC2KiADKQOAASEMCyAMQgBSDQILIANCAzcDUAsgAykDQCIMQgJRDQogA0IANwNAIAMpA0gMAQsgAykDiAELIQ0gDKdBAXFFDQggAyADKQNwQkB9Igw3A3AgAyANNwNoIA1QDQALCyADIA1CASANeiIOhoU3A2hBgICAgHghAQJAAn8CQAJAIAogDqcgDKdqIgtBAnRqKAIAIgdBgICAgHhHIAUoAgAoAgAiAkF/R3JFBEBBACEEDAELIAJFDQMgByAHIAJtIgEgAmxrQQAgAkF/RxshBCAHQQBODQELIAEgBCAFKAIIKAIATGsMAQsgASAEIAUoAgQoAgBOagshASADQYABaiICIAGsIgwgDEI/hxCyLiACIAMpA4ABIgwgAykDiAEiDSADKQOQASIOIAMpA5gBIg8gCS0AABDQDiADKAKAASIEQZOAgIB4Rw0CIAYgC0EFdGoiASAPNwMYIAEgDjcDECABIA03AwggASAMNwMADAELC0Gsj/8AEOIrAAsgAykChAEhDCAAIAMpAowBNwIQDAYLQcAAIAUQoz0AC0Hci/8AQSkgA0FAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEKIAIoAgAhBSABKAIQIQIDQEGAgICAeCEBIAUoAgAoAgAhBAJ/AkACQCACKAIAIghBgICAgHhGBEBBACEJIARBf0YNAQsgBEUNCCAIIAggBG0iASAEbGtBACAEQX9HGyEJIAhBAE4NAQsgASAJIAUoAggoAgBMawwBCyABIAkgBSgCBCgCAE5qCyEBIANBQGsiBCABrCIMIAxCP4cQsi4gBCADKQNAIgwgAykDSCINIAMpA1AiDiADKQNYIg8gCi0AABDQDiADKAJAIgRBk4CAgHhHDQIgBiAMNwMAIAZBGGogDzcDACAGQRBqIA43AwAgBiANNwMIIAJBBGohAiAGQSBqIQYgByALQQFqIgtHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEGIAEgA0HIAGoiBCkCADcDACADKQMgIQwgAyADKQJANwMgIANBADYCMCADIAw3AkwgA0EANgJIIAMgBjYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAQpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBjYCiAEgAyAFNgKEASADIAE2AoABIANBNGoiASADQYABahDiGSAHIANBGGopAgA3AwAgBCADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDOHSADQSBqEM8vDAILIAMpAkQhDCAAIAMpAkw3AhALIAAgDDcCCCAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQaABaiQADwtBrI//ABDiKwALQQRBHBCjPQAL9woCCH8BfiMAQUBqIgQkACAEIAI2AgggBCABNgIEAn8CQCACQQRJDQACQAJAIAEgAkEDayIFaiIGLQAAQSBHDQACQAJAIAYtAAEiA0HgAE0EQCADQcEARg0BIANB0ABHDQMgBi0AAkEgckHtAEYNAgwECyADQeEARg0AIANB8ABHDQIgBi0AAkEgckHtAEcNAwwBCyAGLQACQSByQe0ARw0CQQEhCQtBASEHIAUiAkEETw0BDAILCyAEQSRqQbDgADsBACAEQbDgwIEDNgIgIAQCfyABLQABIgVBOkcEQCABLQACQTpHDQIgBCAFOgAhIAQgAS0AADoAICACQQNrIgNBAkkNAiABQQNqDAELIAQgAS0AADoAISACQQJrIQMgAUECagsiCC8AADsBIkEAIQICf0EAIANBAkYNABogA0EFSQ0BIAgtAAJBOkcNASAEIAgvAAM7ASRBACADQQVGDQAaIAgtAAVBLkcNAUEGIQEgCEEGaiEFIANBBmshBgNAIAEgA0cEQCABIAhqIAFBAWohAS0AAEE6a0H/AXFB9gFPDQEMAwsLAkACQAJAAkACQAJAAkACQAJAIANBBmsOCQoBAgMEBQYHCAALAn9BACEBIAZBCU8EQEEAIQYDQCABQQpsIAUgBmotAABBMGtB/wFxaiEBIAZBAWoiBkEJRw0ACyABDAELQQkgBkHAw4ABELA7AAsMCAsgBS0AAEEwa0H/AXFBgMLXL2wMBwtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQJHDQALIANBgK3iBGwMBgtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQNHDQALIANBwIQ9bAwFC0EAIQNBACEBA0AgA0EKbCABIAVqLQAAQTBrQf8BcWohAyABQQFqIgFBBEcNAAsgA0GgjQZsDAQLQQAhA0EAIQEDQCADQQpsIAEgBWotAABBMGtB/wFxaiEDIAFBAWoiAUEFRw0ACyADQZDOAGwMAwtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQZHDQALIANB6AdsDAILQQAhA0EAIQEDQCADQQpsIAEgBWotAABBMGtB/wFxaiEDIAFBAWoiAUEHRw0ACyADQeQAbAwBC0EAIQNBACEBA0AgA0EKbCABIAVqLQAAQTBrQf8BcWohAyABQQFqIgFBCEcNAAsgA0EKbAshAQNAIARBIGogAmoiBSAFLQAAQTBrOgAAIAJBAWoiAkEGRw0AC0EAIQIDQCACQQZHBEAgBEEgaiACaiACQQFqIQItAABBCU0NAQwCCwsCQCAELQAhIAQtACBBCmxqIgJB/wFxQQxGBEBBAEEMIAcbQQwgCRshAgwBCyACQQFrQf8BcUELTwRAIAcNAgwBCyAHRQ0AIAIgAkEMaiAJGyECC0E7IAQtACUgBC0AJEEKbGoiBSAFQf8BcUE8RiIGGyIFQf8BcUE7SyACQf8BcUEXS3INACAELQAjIAQtACJBCmxqIgNB/wFxQTtLDQAgAUGAlOvcA2ogASAGGyIBQYCU69wDTyAFQf8BcUE7RyABQf+n1rkHS3JxDQAgAa0gAq1C/wGDQpAcfiAFrUL/AYN8IAOtQv8Bg0I8fnxCgJTr3AN+fCELQQAhAkEIDAELIARBAjYCJCAEQbzFgAE2AiAgBEIBNwIsIARBzAE2AjwgBCAEQThqNgIoIAQgBEEEajYCOCAEQRBqIARBIGoQmQ4gBCkCGCELIAAgBCkCEDcDCCAAQYSAgIB4NgIEQQEhAkEQCyAAaiALNwMAIAAgAjYCACAEQUBrJAALkAsCA38BfiMAQYABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AkwgAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQcwAaiADEMwkIQIMCwsgBEHMAGogAxDTHCECDAoLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBAnYiAU8NCyAAKAIQIAJBAnRqNAIAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQ1xsgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBAnYiAU8NCiAEIAAoAhAgAkECdGo0AgAiBzcDCCAEQegAaiIAIAcQ1xsgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCAsgACgCBCgCFCEAIAQgAjYCMCACIABBAnYiAEkNBQwICyAEQdgAaiAHENcbIAQoAlgEQCAEQSBqIARB4ABqKAIANgIAIAQgBCkCWDcDGCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZMMNgI0IAQgBEEwajYCcCAEIARBGGo2AjAgAygCACADKAIEIARB6ABqEMsKIQIMBwsgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAYLIARBMGohASAEKAIcIQIjAEEgayIAJAAgAEEUaiAHENcbAkAgACgCFCIFRQRAIAFBADYCAAwBCyAAIAApAhg3AgwgACAFNgIIIAEgAEEIahDKLyABIAI2AgwLIABBIGokACAEKAIwBEAgBEHgAGogBEE4aikCADcDACAEIAQpAjA3A1ggBEHMAGoiACAEQdgAahCuByAEQfoXNgJIIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IAQgADYCRCAEIARBxABqNgJwIAMoAgAgAygCBCAEQegAahDLCiECIAAQ3jsMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAMLIARBzABqIAMQ0hwhAgwDCyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIARBCGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMAgsgBEHwAGpBjpy48AA2AgAgBEKOnLjw4MGDhw43A2ggBEHoAGoiABDJDCAEQgA3AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAELIARBGGoQ5RALIARBgAFqJAAgAg8LIAQgADYCWAwBCyAEIAE2AlgLIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYIARB6ABqQciXhAEQ7ywAC98LAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCTCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3A1ggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQdgAaiADEJ4lIQIMDAsgBEHYAGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQoBUgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCiAEIAAoAhAgAkEDdGopAwAiBzcDCCAEQegAaiIAIAcQoBUgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCQsgACgCBCgCFCEAIAQgAjYCMCACIABBA3YiAEkNBSAEIAA2AlgMCgsgBEHYAGogBxCgFSAEKAJYBEAgBEEgaiAEQeAAaigCADYCACAEIAQpAlg3AxggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGTDDYCNCAEIARBMGo2AnAgBCAEQRhqNgIwIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQTBqIQEgBCgCHCECIwBBIGsiACQAIABBFGogBxCgFQJAIAAoAhQiBUUEQCABQQA2AgAMAQsgACAAKQIYNwIMIAAgBTYCCCABIABBCGoQyi8gASACNgIMCyAAQSBqJAAgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAEQQhqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARB8ABqQY+evPgANgIAIARCj568+PDhw4cPNwNoIARB6ABqIgAQyQwgBEIANwJYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBlAw2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AhggAygCACADKAIEIAAQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMBAsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYCyAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARB2ABqNgIgIAQgBEEwajYCGAsgBEHoAGpByJeEARDvLAALrgoCDn8CfgJAIAIEQCABIAJqIglBEyACIAJBE08bayELIAMoAgAiCiADKAIEIgJBImsiBUEAIAIgBU8baiEMIAMoAgQgCmohDSADKAIIIAMoAgBqIg8hBQNAAkAgAS0AACICQQ9xIghBD0YgAkHvAUtyIAFBAWoiBCALSyAFIAxPcnINAANAIAUgBCkAADcAACAFQQhqIARBCGopAAA3AAAgBSACQQR2QQ9xIgFqIgIgCEEEaiIGaiEFAkAgBiACIAprIgcgASAEaiIELwAAIgEgASAHSxsiAU0EQCACIAFrIgFBCGopAAAhEiABKQAAIRMgAkEQaiABQRBqLwAAOwAAIAJBCGogEjcAACACIBM3AAAMAQtBACABayEGIAJBADoAAANAIAIgAiAGaiIBLQAAOgAAIAJBAWogAUEBai0AADoAACACQQNqIQcgAkECaiIBIQIgBSAHSw0ACyABIAVPBEAgASEFDAELIAFBAWohBSABIAEgBmotAAA6AAALIAQtAAIiAkEPcSIIQQ9GIAJB7wFLciAEQQNqIgQgC0tyDQEgBSAMSQ0ACwsCQAJ/AkACQAJAAkACQAJAAkAgAkEQSQR/IAUFAkAgAkEEdiIBQQ9HBEAgBCEGDAELQQAhAgNAIAQgCU8NAyACIAQtAAAiAWohAiAEQQFqIgYhBCABQf8BRg0ACyACQQ9qIQEgAiEQCyABIAkgBmtLDQIgASANIAVrSw0DAkACQAJAIAFBBE8EQCABQQhJDQEgAUERSQ0CIAUgAUFwcWohByAFIQIgBiEEA0AgAiAEKQAANwAAIAJBCGogBEEIaikAADcAACAEQRBqIQQgAkEQaiICIAdJDQALIAUgAUEQayICaiIEIAIgBmoiAikAADcAACAEQQhqIAJBCGopAAA3AAAMAwsgBSAGLQAAOgAAIAFBAkkNAiAFIAYvAAA7AAAgBSABQQJrIgJqIAIgBmovAAA7AAAMAgsgBSAGKAAANgAAIAUgAUEEayICaiACIAZqKAAANgAADAELIAUgBikAADcAACAFIAFBCGsiAmogAiAGaikAADcAAAsgASAGaiEEIAEgBWoLIQIgBCAJTw0DAkACQCAJIARrQQJPBEAgBEECaiEFIAQvAAAhByAIQQRqIgZBE0YNASAFIQEMAgsMDQtBACEEA0AgBSAJTw0GIAQgBS0AACIGaiEEIAVBAWoiASEFIAZB/wFGDQALIARBE2ohBiAEIRELIAIgCmsiBSAHSQ0FIA0gAmsiBCAGSQRAIABBADYCACAAIAMoAgQ2AgggACAFIAZqNgIEDwtBACAHayEIIAZBD2oiBSAHSyAEIAVJckUEQCACIAZqIQUDQCACIAIgCGoiBCkAADcAACACQQhqIARBCGopAAA3AAAgAkEQaiICIAVJDQALDAkLIAJBADoAACACIAZqIQ4gBkECSQ0GIAIhBANAIAQgBCAIaiICLQAAOgAAIARBAWogAkEBai0AADoAACAEQQNqIARBAmoiAiEEIA5JDQALIAIgCGohBCACQQFqDAcLIAAgEDYCBAwKCyAAQQE2AgAPCyAAQQA2AgAgACADKAIENgIIIAAgBSAKayABajYCBA8LIABBBDYCACAAIAIgD2s2AgQgAyACIAprNgIIDwsgACARNgIEDAYLIABBAzYCAA8LIAIgB2shBCACQQFqCyEFIAIgDk8EQCACIQUMAQsgAiAELQAAOgAACyABIAlJDQALDAELIABBAjYCAA8LIABBAjYCAAvTCgIQfwJ+IwBBEGsiCiQAIApBADYCDCAKQQA2AghBVCEHAkAgBEHUC0kNAAJAIANB1AlqIgYgAyAKQQhqIApBDGogASACIANB6ABqEPEMIhRBiH9LDQAgCigCCCEPQQogACgCACIMQf8BcSIQIBBBCk8bQQFqIgEgCigCDCIITwRAAkAgASAITQ0AIAEgCGshCyAPIQUgBiEEA0AgBQRAIAQgC0EAIAQtAAAiAhsgAmo6AAAgBUEBayEFIARBAWohBAwBBUEKIAxB/wFxIgIgAkEKTxtBAnQgA2pBBGohBSADIAhBAnRqIQIgASEEA0AgBCALTQRAQQogDEH/AXEiAiACQQpPGyICQX9zIAhqIQQgAkECdCAIQQJ0ayADakEEaiEFA0AgBEUNBSAFQQA2AgAgBEEBaiEEIAVBBGshBQwACwAFIAUgAigCADYCACACQQRrIQIgBUEEayEFIARBAWshBAwBCwALAAsACwALIAEhCAsgCCAQQQFqSw0BIAAgDEH/gYB4cSAIQRB0QYCA/AdxcjYCACADQTRqIQtBACECIAMhBCAIQQFqIgwhBQNAIAUEQCAEQTRqIAI2AgAgBUEBayEFIAQoAgAgAmohAiAEQQRqIQQMAQsLIANB1AdqIRIgD0EDayEHQQAhAgNAIAIgB04EQANAIAIgD0gEQCALIAIgA2pB1AlqLQAAQQJ0aiIBIAEoAgAiAUEBajYCACABIBJqIAI6AAAgAkEBaiECDAELCwVBACEEA0AgBEEERwRAIAsgBCAGai0AAEECdGoiASABKAIAIgFBAWo2AgAgASASaiACIARqOgAAIARBAWohBAwBCwsgBkEEaiEGIAJBBGohAgwBCwsgA0HUB2ohESAAQQVqIRAgAEEEaiELIABBDGohDyADKAIAIQhBASENA0AgDCANRg0BIAwgDWshBSADIA1BAnRqKAIAIQkCQAJAAkACQAJAAkBBASANdEEBdSITQQFrDggAAQQCBAQEAwQLIAlBACAJQQBKGyEGIAggEWohByAQIA5BAXRqIQQDQCAGRQ0FIAQgBy0AADoAACAEQQFrIAU6AAAgB0EBaiEHIAZBAWshBiAEQQJqIQQMAAsACyAJQQAgCUEAShshBiAIIBFqIQcgACAOQQF0aiEEA0AgBkUNBCAEQQdqIActAAAiAToAACAEQQZqIAU6AAAgBEEFaiABOgAAIARBBGoiBCAFOgAAIAdBAWohByAGQQFrIQYMAAsACyAJQQAgCUEAShshBCAIIBFqIQYgCyAOQQF0aiEHIAVB/wFxrSEWA0AgBEUNAyAHIAYxAABCCIYgFoRCgYCEgJCAwAB+NwAAIAZBAWohBiAEQQFrIQQgB0EIaiEHDAALAAsgCUEAIAlBAEobIQYgCCARaiEHIA8gDkEBdGohBCAFQf8Bca0hFQNAIAZFDQIgBCAHMQAAQgiGIBWEQoGAhICQgMAAfiIWNwAAIARBCGsgFjcAACAHQQFqIQcgBkEBayEGIARBEGohBAwACwALQQAhBiAJQQAgCUEAShshAiATQQF0IQEgACAOQQF0aiEHIAVB/wFxrSEWA0AgAiAGRg0BIBIgBiAIamoxAABCCIYgFoRCgYCEgJCAwAB+IRVBACEFIAchBANAIAUgE0gEQCAEQRxqIBU3AAAgBEEUaiAVNwAAIARBDGogFTcAACAEQQRqIBU3AAAgBEEgaiEEIAVBEGohBQwBCwsgASAHaiEHIAZBAWohBgwACwALIA1BAWohDSAIIAlqIQggCSATbCAOaiEODAALAAsgFCEHCyAKQRBqJAAgBwugDAIFfwV+IwBBoAJrIgQkACABQQxqENk8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghDCACKQMAIQsgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAXRqMgEAIQkgBCAMNwOIAiAEIAs3A4ACIAQgCUI/hyIKNwPIASAEIAk3A8ABIARBADYCTCAEQTBqIAkgCiALIAwgBEHMAGoQ9gwgBCgCTARAIARBAjYC7AEgBEGskP8ANgLoASAEQgI3AvQBIARBhAw2ApwCIARBhAw2ApQCIAQgBEGQAmo2AvABIAQgBEGAAmo2ApgCIAQgBEHAAWo2ApACIARB2AFqIARB6AFqEJkOIAQpAtgBIQkgBCkC4AEhCkGIgICAeCEBDAcLIARB6AFqIAQpAzAiCSAEKQM4IgogAhCtDiAEKALoASIBQZOAgIB4RwRAIAQpAvQBIQogBCkC7AEhCQwHBSAGIAdBBHRqIgEgCjcDCCABIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCiACKQMAIQwgAy0AACEDIAEoAhAhAkEAIQUDQCACMgEAIQkgBCAKNwOYAiAEIAw3A5ACIAQgCUI/hyILNwOIAiAEIAk3A4ACIARBADYCLCAEQRBqIAkgCyAMIAogBEEsahD2DCAEKAIsBEAgBEECNgKMASAEQayQ/wA2AogBIARCAjcClAEgBEGEDDYC4AEgBEGEDDYC2AEgBCAEQdQBajYCkAEgBCAEQZACajYC3AEgBCAEQYACajYC1AEgBEHsAWogBEGIAWoQmQ4gBCkC7AEhCSAEKQL0ASEKQYiAgIB4IQEMAwsgBEGIAWogBCkDECIJIAQpAxgiCyADEK0OIAQoAogBIgFBk4CAgHhHBEAgBCkClAEhCiAEKQKMASEJDAMLIAYgCTcDACAGIAs3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBiAFqIgIQlykgBEHwAGoiASgCACEGIAQoAnQhAyABIARBkAFqIgUpAgA3AwAgBCkDaCEJIAQgBCkCiAE3A2ggBEEANgJ4IAQgCTcClAEgBEEANgKQASAEIAM2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQZgBaiIHKAIANgIAIAQgAzYC8AEgBCAGNgLsASAEIAE2AugBIARB/ABqIgEgBEHoAWoQ4hkgByAEQeAAaikCADcDACAFIARB2ABqKQIANwMAIAQgBCkCUDcDiAEgACABIAIQyx0gBEHoAGoQzy8MAgtBBEEcEKM9AAsgACAKNwIQIAAgCTcCCCAAIAE2AgQgAEEpOgAAIARB6ABqEM8vIAQoAlAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEHQAGoQ+x4LIARBoAJqJAALoAwCBX8FfiMAQaACayIEJAAgAUEMahDbPCEIIARB0ABqIAEQkjYQ7iUgCEEEdCIHIQUCQAJAAkACQAJAIAdBMHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCcCAEIAU2AmwgBEHAADYCaCAHBEAgBkEAIAf8CwALIAQgCDYCeCAEIAc2AnQgBCgCUEUNAyAEKAJkIAQoAmBGDQQgBEGIAWogBEHQAGoQyDQgBEGoAWohBSACKQMIIQwgAikDACELIAMtAAAhAiABKAIQIQMDQAJAIAQpA7ABIgpQRQRAIAQpA7gBIQkMAQsDQAJ+AkAgBCkDmAEiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDmAEgCadBAXFFDQAgBCAEKQOgATcD8AEMAQsgBCgCqAFFDQEgBEHoAWogBRC2KiAEKQPoASEJCyAJQgBSDQILIARCAzcDmAELIAQpA4gBIglCAlENCSAEQgA3A4gBIAQpA5ABDAELIAQpA/ABCyEKIAmnQQFxRQ0HIAQgBCkDuAFCQH0iCTcDuAEgBCAKNwOwASAKUA0ACwsgBCAKQgEgCnoiDYaFNwOwASADIA2nIAmnaiIHQQJ0ajQCACEJIAQgDDcDiAIgBCALNwOAAiAEIAlCP4ciCjcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJIAogCyAMIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQogAikDACEMIAMtAAAhAyABKAIQIQJBACEFA0AgAjQCACEJIAQgCjcDmAIgBCAMNwOQAiAEIAlCP4ciCzcDiAIgBCAJNwOAAiAEQQA2AiwgBEEQaiAJIAsgDCAKIARBLGoQ9gwgBCgCLARAIARBAjYCjAEgBEGskP8ANgKIASAEQgI3ApQBIARBhAw2AuABIARBhAw2AtgBIAQgBEHUAWo2ApABIAQgBEGQAmo2AtwBIAQgBEGAAmo2AtQBIARB7AFqIARBiAFqEJkOIAQpAuwBIQkgBCkC9AEhCkGIgICAeCEBDAMLIARBiAFqIAQpAxAiCSAEKQMYIgsgAxCtDiAEKAKIASIBQZOAgIB4RwRAIAQpApQBIQogBCkCjAEhCQwDCyAGIAk3AwAgBiALNwMIIAZBEGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQYgBaiICEJcpIARB8ABqIgEoAgAhBiAEKAJ0IQMgASAEQZABaiIFKQIANwMAIAQpA2ghCSAEIAQpAogBNwNoIARBADYCeCAEIAk3ApQBIARBADYCkAEgBCADNgKMASAEIAY2AogBIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAFKQIANwIAIAFBGGogBEGYAWoiBygCADYCACAEIAM2AvABIAQgBjYC7AEgBCABNgLoASAEQfwAaiIBIARB6AFqEOIZIAcgBEHgAGopAgA3AwAgBSAEQdgAaikCADcDACAEIAQpAlA3A4gBIAAgASACEMsdIARB6ABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQegAahDPLyAEKAJQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARB0ABqEPseCyAEQaACaiQAC6AMAgV/BX4jAEGgAmsiBCQAIAFBDGoQ2DwhCCAEQdAAaiABEJI2EO4lIAhBBHQiByEFAkACQAJAAkACQCAHQTBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AnAgBCAFNgJsIARBwAA2AmggBwRAIAZBACAH/AsACyAEIAg2AnggBCAHNgJ0IAQoAlBFDQMgBCgCZCAEKAJgRg0EIARBiAFqIARB0ABqEMg0IARBqAFqIQUgAikDCCEMIAIpAwAhCyADLQAAIQIgASgCECEDA0ACQCAEKQOwASIKUEUEQCAEKQO4ASEJDAELA0ACfgJAIAQpA5gBIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A5gBIAmnQQFxRQ0AIAQgBCkDoAE3A/ABDAELIAQoAqgBRQ0BIARB6AFqIAUQtiogBCkD6AEhCQsgCUIAUg0CCyAEQgM3A5gBCyAEKQOIASIJQgJRDQkgBEIANwOIASAEKQOQAQwBCyAEKQPwAQshCiAJp0EBcUUNByAEIAQpA7gBQkB9Igk3A7gBIAQgCjcDsAEgClANAAsLIAQgCkIBIAp6Ig2GhTcDsAEgAyANpyAJp2oiB0EDdGopAwAhCSAEIAw3A4gCIAQgCzcDgAIgBCAJQj+HIgo3A8gBIAQgCTcDwAEgBEEANgJMIARBMGogCSAKIAsgDCAEQcwAahD2DCAEKAJMBEAgBEECNgLsASAEQayQ/wA2AugBIARCAjcC9AEgBEGEDDYCnAIgBEGEDDYClAIgBCAEQZACajYC8AEgBCAEQYACajYCmAIgBCAEQcABajYCkAIgBEHYAWogBEHoAWoQmQ4gBCkC2AEhCSAEKQLgASEKQYiAgIB4IQEMBwsgBEHoAWogBCkDMCIJIAQpAzgiCiACEK0OIAQoAugBIgFBk4CAgHhHBEAgBCkC9AEhCiAEKQLsASEJDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQYgBakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEKIAIpAwAhDCADLQAAIQMgASgCECECQQAhBQNAIAIpAwAhCSAEIAo3A5gCIAQgDDcDkAIgBCAJQj+HIgs3A4gCIAQgCTcDgAIgBEEANgIsIARBEGogCSALIAwgCiAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgkgBCkDGCILIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiAJNwMAIAYgCzcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuZDAIFfwV+IwBBoAJrIgQkACABQQxqKAIIIQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEHIAIpAwghDCACKQMAIQsgAy0AACECIAEoAhAhAQNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAHELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAEgDacgCadqIgNqMAAAIQkgBCAMNwOIAiAEIAs3A4ACIAQgCUI/hyIKNwPIASAEIAk3A8ABIARBADYCTCAEQTBqIAkgCiALIAwgBEHMAGoQ9gwgBCgCTARAIARBAjYC7AEgBEGskP8ANgLoASAEQgI3AvQBIARBhAw2ApwCIARBhAw2ApQCIAQgBEGQAmo2AvABIAQgBEGAAmo2ApgCIAQgBEHAAWo2ApACIARB2AFqIARB6AFqEJkOIAQpAtgBIQkgBCkC4AEhCkGIgICAeCEFDAcLIARB6AFqIAQpAzAiCSAEKQM4IgogAhCtDiAEKALoASIFQZOAgIB4RwRAIAQpAvQBIQogBCkC7AEhCQwHBSAGIANBBHRqIgMgCjcDCCADIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCiACKQMAIQwgAy0AACECIAEoAhAhA0EAIQEDQCABIANqMAAAIQkgBCAKNwOYAiAEIAw3A5ACIAQgCUI/hyILNwOIAiAEIAk3A4ACIARBADYCLCAEQRBqIAkgCyAMIAogBEEsahD2DCAEKAIsBEAgBEECNgKMASAEQayQ/wA2AogBIARCAjcClAEgBEGEDDYC4AEgBEGEDDYC2AEgBCAEQdQBajYCkAEgBCAEQZACajYC3AEgBCAEQYACajYC1AEgBEHsAWogBEGIAWoQmQ4gBCkC7AEhCSAEKQL0ASEKQYiAgIB4IQUMAwsgBEGIAWogBCkDECIJIAQpAxgiCyACEK0OIAQoAogBIgVBk4CAgHhHBEAgBCkClAEhCiAEKQKMASEJDAMLIAYgCTcDACAGIAs3AwggBkEQaiEGIAggAUEBaiIBRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgBTYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENs8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAnRqNQIAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAjUCACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENg8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBA3RqKQMAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAikDACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENk8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAXRqMwEAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAjMBACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkECaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuJFwIQfwJ+IwBBsAFrIgIkACACQSxqIAFBGGoiDhDmCwJAAkACQAJAAkACQCACLQA4IgdFBEAgASgCBCIFIAEoAggiCUEMbGohCyMAQSBrIgQkACAEQRRqIAsgBWtBDG4iDEEAQQRBDBCgGCAEKAIYIQMgBCgCFEEBRg0GIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAM2AggjAEEQayIIJAAgBEEIaiIGKAIAIAYoAggiA2sgDEkEQCAGIAMgDEEEQQwQ3iggBigCCCEDCyAIIAYoAgQ2AgwgCCADNgIIIAggBkEIajYCBCAFIAsgCEEEahDeGSAIQRBqJAAgAkE8aiIDQQhqIAooAgA2AgAgAyAEKQIINwIADAELAkAgASgCLCIFRQRAIAJBADYCSAwBCwJAIAEoAigiBCABKAI4IgNHBEAgAUEsaiEFIAQNASACQcgAaiAFEKA2DAILIAUgBSgCACIEQQFqNgIAIARBAEgNAyACIAU2AkggAiABKQIwNwJMDAELIAJBoAFqIgcgASgCPCIIIARqEPcvIAJBIGogBxCGPSACKAIkIQcgAigCICACQRhqIAUQ3DsgByACKAIYIAIoAhwgBCADIAgQhAkaIAIoAqgBIQcgAigCrAEhBSACIAIpAqABNwJsIAJBADYCaCACIAU2AmQgAiAHNgJgIAJBEGogAkHgAGoQ1zsgAigCECEEQRxBBBCtNiIHRQ0DIAdCgYCAgBA3AgAgByACKQJgNwIIIAdBEGogAkHoAGopAgA3AgAgB0EYaiACQfAAaigCADYCACACIAU2AlAgAiAENgJMIAIgBzYCSCACLQA4IQcLIAEoAgghCSABKAIEIQUgAkHsAGogAkHQAGooAgA2AgAgAkEBNgJgIAIgAikCSDcCZCACIAU2AnAgAiAFIAlBDGxqNgJ0IwBBIGsiBCQAIAJB4ABqIggoAhAhBgJAIAgoAgAiA0ECRwRAIAZFDQEgCCgCFCAGa0EMbiADaiEDDAELIAZFBEBBACEDDAELIAgoAhQgBmtBDG4hAwsgBEEUaiADQQBBBEEMEKAYIAQoAhghAyAEKAIUQQFGDQUgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIQMjAEEQayILJAAgCCgCECEKAkACQCAIKAIAIgZBAkcEQCAKRQ0BIAgoAhQgCmtBDG4gBmohBgwBCyAKRQRAIANBCGohCgwCCyAIKAIUIAprQQxuIQYLIANBCGohCiAGIAMoAgAgAygCCCINa00NACADIA0gBkEEQQwQ3igLIAsgAykCBEIgiTcCCCALIAo2AgQgC0EEaiEDIAgoAgAiBkECRiAGQQFxRXJFBEAgAyADKAIEIgZBAWo2AgQgAygCCCAGQQxsaiIGIAgpAgQ3AgAgBkEIaiAIQQxqKAIANgIACyACQTxqIQYCQCAIKAIQIgoEQCAKIAgoAhQgAxDeGQwBCyADKAIAIAMoAgQ2AgALIAtBEGokACAGQQhqIAwoAgA2AgAgBiAEKQIINwIACyAEQSBqJAAgAkE4aiEGIAIoAjQgB0H/AXFqrSESIAItADlFBEAgAigCRCEHDAQLQQAhBCACQQA2AlwgAkKAgICAgAE3AlQgEkIBfCESIAUgCUEMbGohCEEBIQdBACEJQQEhAwNAAkAgCUEBcQRAIAUgCEcNAQwFCyADIAggBWtBDG5PDQQgBSADQQxsaiEFCyAFNQIIIRMgAigCVCAHQQFrRgRAIAJB1ABqQZSdhwEQsygLIAVBDGohBSACKAJYIARqIBM3AwAgEkIBfCESIARBCGohBCACIAc2AlxBASEJIAdBAWohB0EAIQMMAAsACwALQQRBHBCjPQALIAJB6ABqIAJB3ABqKAIANgIAIAIgAikCVDcDYCACQaABaiACQeAAahC9GCACKAJEIgcgAigCPEYEQCACQTxqQfSchwEQkCgLIAIoAkAgB0EMbGoiBSACKQKgATcCACAFQQhqIAJBqAFqKAIANgIAIAIgB0EBaiIHNgJECyACKAJAIQUgAiAGNgJ4IAIgBSAHQQxsajYCdCACIAU2AnAgAkECNgJoIAJBAjYCYCACQaABaiEIIwBBMGsiBCQAIAJB4ABqIgMoAhghCSADKAIUIQYgAygCECEFAkACQAJAAkACfwNAIAVFIAUgBkZyDQIgAyAFQQxqIgc2AhAgBSgCAARAIAVBBGooAgAMAgsgByEFIAktAABBAUcNAAtBAAshBSAEQRBqIglBBEEAQQRBBBCgGCAEKAIUIQcgBCgCEEEBRg0CIAQoAhgiBiAFNgIAIARBDGoiC0EBNgIAIAQgBjYCCCAEIAc2AgQgBEEoaiADQRhqKAIANgIAIARBIGogA0EQaikCADcDACAEQRhqIANBCGopAgA3AwAgBCADKQIANwMQIARBBGohAyAJKAIQIQcgCSgCGCEKIAkoAhQhDANAIAciBUUgBSAMRnJFBEAgCSAFQQxqIgc2AhACfyAFKAIABEAgBUEEaigCAAwBCyAKLQAAQQFHDQJBAAshDSADKAIIIgYgAygCAEYEQCADIAZBAUEEQQQQ3igLIAVBDGohByADKAIEIAZBAnRqIA02AgAgAyAGQQFqNgIIDAELCyAIQQhqIAsoAgA2AgAgCCAEKQIENwIADAELIAhBADYCCCAIQoCAgIDAADcCAAsgBEEwaiQADAELIAcgBCgCGEHUnIcBEP0vAAsgAkEIaiAIQeSchwEQmCEgAigCDCENIAIoAgghDEEAIQcgAkEANgKoASACQoCAgIDAADcCoAECQAJAAn8gDi0AACIPQSJGBEAgASgCFEUEQEEAQQBBhJ2HARDDIQALIAJB4ABqIgUgASgCEBCNBEHAAEEIEK02IgdFDQIgByAFQcAA/AoAAEEAIQlBBAwBCyABKAIUIQkgASgCEAshBSMAQSBrIgQkACAEQRRqIAUgCUHEAGxqIgYgBWtBxABuQQBBBEEEEKAYIAQoAhghAyAEKAIUQQFGBEAMAwsgBEEQaiIQQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCMAQRBrIggkACAGIAVrQcQAbiILIARBCGoiCSgCACAJKAIIIgNrSwRAIAkgAyALQQRBBBDeKCAJKAIIIQMLIAJB4ABqIQsgCCAJKAIENgIMIAggAzYCCCAIIAlBCGo2AgQjAEFAaiIJJAAgCEEEaiIKKAIEIQMgCigCACERAkACQCAFIAZHBEAgCigCCCADQQJ0aiEKIAYgBWtBxABuIQYDQCAJIAUQjQRBwABBCBCtNiIORQ0CIA4gCUHAAPwKAAAgCiAONgIAIAVBxABqIQUgCkEEaiEKIANBAWohAyAGQQFrIgYNAAsLIBEgAzYCACAJQUBrJAAMAQtBCEHAABCjPQALIAhBEGokACALQQhqIBAoAgA2AgAgCyAEKQIINwIAIARBIGokACACIAtB5JyHARCYIQJ/IA9FBEAgASgCJAwBCyABKAJAQQAgASgCLBsLIQggAigCBCEEIAIoAgAhAyACQegAaiIJIAJBxABqKAIANgIAIAIgAikCPDcDYEEgQQQQrTYiBUUNASAFIAIpA2A3AgAgBSAHNgIcIAUgAzYCFCAFIAw2AgwgBSAENgIYIAUgDTYCECAFQQhqIAkoAgA2AgAgACAFNgI4IABBxBw2AjQgACAHNgIwIAAgAzYCLCAAIAw2AiggACAErTcDICAAIBI3AxggACAIrTcDCCAAIAE1Aig3AxAgACABNQIkNwMAIAIoAqgBIgAEQCACKAKkASEBA0AgARClHiABQcQAaiEBIABBAWsiAA0ACwsgAkGgAWpBBEHEABDgHiACQSxqQQRBDBDgHiACQbABaiQADwtBCEHAABCjPQALQQRBIBCjPQALIAMgBCgCHEHUnIcBEP0vAAuPDAIFfwV+IwBBoAJrIgQkACABQQxqKAIIIQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEHIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAQNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAHELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAEgDacgCadqIgNqMQAAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghBQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiBUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiADQQR0aiIDIAo3AwggAyAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAiABKAIQIQNBACEBA0AgASADajEAACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghBQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAIQrQ4gBCgCiAEiBUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgCCABQQFqIgFHDQALCyAEQYgBaiICEJcpIARB8ABqIgEoAgAhBiAEKAJ0IQMgASAEQZABaiIFKQIANwMAIAQpA2ghCSAEIAQpAogBNwNoIARBADYCeCAEIAk3ApQBIARBADYCkAEgBCADNgKMASAEIAY2AogBIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAFKQIANwIAIAFBGGogBEGYAWoiBygCADYCACAEIAM2AvABIAQgBjYC7AEgBCABNgLoASAEQfwAaiIBIARB6AFqEOIZIAcgBEHgAGopAgA3AwAgBSAEQdgAaikCADcDACAEIAQpAlA3A4gBIAAgASACEMsdIARB6ABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACAFNgIEIABBKToAACAEQegAahDPLyAEKAJQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARB0ABqEPseCyAEQaACaiQAC8sKAhR/B34jAEEwayIGJAAgA0EBayEFAkAgAwRAIANBAmshBAJAIANBAUcEQCACIAVBAnRqKAIAIRIgAiAEQQJ0ajUCACEcIAZBGGogASgCCCIIIANrIhVBAWoiCkH0o4gBEL8VIAYoAiAhCSAGKAIcIQ4gBigCGCETIAoNASABKAIAIQUMAwsgBEEBQeSjiAEQwyEACyABKAIEIg8gCEECdCADQQJ0IhZraiEQQgAgEq0iGkIghiIdfSEeAkACQAJAA0ACQAJAIAhFDQAgDyAIQQJ0aiIUQQRrIgRFDQAgCEECayEFIAhBAUsEQCAEKAIAIQQgDyAFQQJ0ajUCACEbIAetIRgCfyAHIBJPBEAgBK0gGHwhGUF/DAELIAStIBhCIIaEIhggGCAagCIYIBp+fSEZIBinCyELIBlC/////w9WDQIgHiAZQiCGfCAbfCEYA0AgGCAdfCIYIAutIBx+Wg0DIAtBAWshCyAZIBp8IhlCgICAgBBUDQALDAILIAVBAUGkpIgBEMMhAAtBlKSIARCyOwALIAggCkEBayIKSQ0BIAYgFDYCHCAGIA8gCkECdCIXaiIMNgIYAkAgBkEYahCeNiIERQ0AIAMgBCADIARJGyENIAutIRtC/////w8hGSAQIQUgAiEEA0AgBSAZIAU1AgB8IBsgBDUCAH59Qv////8ffSIYPgIAIBhCIIghGSAFQQRqIQUgBEEEaiEEIA1BAWsiDQ0ACyAHIBmnQX9zTw0AIAMgCCAKa0sNAyALQQFrIQsgBiAMNgIYIAYgDCAWaiIRNgIcIAZBGGoQnjYiBEUNACADIAQgAyAESRshDUEAIQVBACEHA0AgBSAQaiIEIAcgBCgCACIHIAIgBWooAgBqIgxqIgQ2AgAgBCAMSSAHIAxLciIEIQcgBUEEaiEFIA1BAWsiDQ0ACyAEIBEgFEdxRQ0AIBEgESgCAEEBajYCAAsgCSAVTQ0DIA4gF2ogCzYCACABIAhBAWsiCDYCCCAQQQRrIRAgDyAIQQJ0aigCACEHIAoNAAsgASgCACEFDAQLIAogCEG0pIgBEK87AAsgBkEANgIoIAZBATYCHCAGQdyiiAE2AhggBkIENwIgIAZBGGpB5KKIARDvLAALIAogCUHEpIgBEMMhAAsgBUEAQdSjiAEQwyEACyAFIAhGBEAgAUGEpIgBEJ0oCyAIQQJ0IgUgASgCBGogBzYCACABIAhBAWoiBzYCCAJAIAEoAgQiAyAHQQJ0akEEayICRQ0AIAIoAgANACAIQQJqIQQCQANAIAVBfEYEQEEAIQQMAgsgBEEBayEEIAMgBWogBUEEayEFKAIARQ0ACyAEIAdLDQELIAEgBDYCCCAEIQcLAkACQCABKAIAQQJ2IAdLBEAgBkEQaiABIAdBBEEEEPQUIAYoAhAiAkGBgICAeEcNAQsgBiAJNgIgIAYgEzYCGCAGIA42AhwgCUUNASAOIAlBAnQiBWpBBGsiAkUNASACKAIADQEgDkEEayEDIAlB/////wNxIQQCQANAIAVFBEBBACEFDAILIARBAWshBCADIAVqIAVBBGshBSgCAEUNAAsgBEEBaiIFIAlLDQILIAYgBTYCICAFIQkMAQsgAiAGKAIUQfSkiAEQ/S8ACwJAIAkgE0ECdk8NACAGQQhqIAZBGGogCUEEQQQQ9BQgBigCCCICQYGAgIB4Rg0AIAIgBigCDEH0pIgBEP0vAAsgACAGKQIYNwIAIABBCGogBkEgaigCADYCACAAQRRqIAFBCGooAgA2AgAgACABKQIANwIMIAZBMGokAAuH6wUCDH8HfiMAQZACayIIJAACQCADQcEASQRAIAIhCyAAKAIIIAAoAhhrQQN0IAAoAhwiBGsiByACIANsTw0BIAMEQCAHIANuIQsMAgtBmLfOABDiKwALQci2zgBBMEGIt84AEJ8pAAsCQAJAAkACQAJAAkACQAJAIARFIAtFcg0AIAEhBwNAIAhBiAFqIAAgAxDfDSAIKAKIAUUNAyACIAVGDQIgByAIKQOQATcDACAFQQFqIgUgC08NASAHQQhqIQcgACgCHA0ACwsgCyAFayIMQcAASQRAIAUhBwwGCyADQQN0IQ0gACgCCCIOIAAoAhgiCWshBiABIAVBA3RqIQQgACgCBCEPA0AgBUG/f0sNAyAFQUBrIgcgAksNBCAJIA5LDQUgCSAPaiEFIwBBMGsiCiQAIAogAzYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMOQQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQQsgBEEAQYAE/AsADEELIAZBB00EQAxJCyAEIAUpAAAiEEI/iDcD+AMgBCAQQgGDNwMAIAQgEEI+iEIBgzcD8AMgBCAQQj2IQgGDNwPoAyAEIBBCPIhCAYM3A+ADIAQgEEI7iEIBgzcD2AMgBCAQQjqIQgGDNwPQAyAEIBBCOYhCAYM3A8gDIAQgEEI4iEIBgzcDwAMgBCAQQjeIQgGDNwO4AyAEIBBCNohCAYM3A7ADIAQgEEI1iEIBgzcDqAMgBCAQQjSIQgGDNwOgAyAEIBBCM4hCAYM3A5gDIAQgEEIyiEIBgzcDkAMgBCAQQjGIQgGDNwOIAyAEIBBCMIhCAYM3A4ADIAQgEEIviEIBgzcD+AIgBCAQQi6IQgGDNwPwAiAEIBBCLYhCAYM3A+gCIAQgEEIsiEIBgzcD4AIgBCAQQiuIQgGDNwPYAiAEIBBCKohCAYM3A9ACIAQgEEIpiEIBgzcDyAIgBCAQQiiIQgGDNwPAAiAEIBBCJ4hCAYM3A7gCIAQgEEImiEIBgzcDsAIgBCAQQiWIQgGDNwOoAiAEIBBCJIhCAYM3A6ACIAQgEEIjiEIBgzcDmAIgBCAQQiKIQgGDNwOQAiAEIBBCIYhCAYM3A4gCIAQgEEIgiEIBgzcDgAIgBCAQQh+IQgGDNwP4ASAEIBBCHohCAYM3A/ABIAQgEEIdiEIBgzcD6AEgBCAQQhyIQgGDNwPgASAEIBBCG4hCAYM3A9gBIAQgEEIaiEIBgzcD0AEgBCAQQhmIQgGDNwPIASAEIBBCGIhCAYM3A8ABIAQgEEIXiEIBgzcDuAEgBCAQQhaIQgGDNwOwASAEIBBCFYhCAYM3A6gBIAQgEEIUiEIBgzcDoAEgBCAQQhOIQgGDNwOYASAEIBBCEohCAYM3A5ABIAQgEEIRiEIBgzcDiAEgBCAQQhCIQgGDNwOAASAEIBBCD4hCAYM3A3ggBCAQQg6IQgGDNwNwIAQgEEINiEIBgzcDaCAEIBBCDIhCAYM3A2AgBCAQQguIQgGDNwNYIAQgEEIKiEIBgzcDUCAEIBBCCYhCAYM3A0ggBCAQQgiIQgGDNwNAIAQgEEIHiEIBgzcDOCAEIBBCBohCAYM3AzAgBCAQQgWIQgGDNwMoIAQgEEIEiEIBgzcDICAEIBBCA4hCAYM3AxggBCAQQgKIQgGDNwMQIAQgEEIBiEIBgzcDCAxACyAGQQ9NBEAMSAsgBCAFKQAAIhBCPog3A/gBIAQgEEIDgzcDACAEIBBCPIhCA4M3A/ABIAQgEEI6iEIDgzcD6AEgBCAQQjiIQgODNwPgASAEIBBCNohCA4M3A9gBIAQgEEI0iEIDgzcD0AEgBCAQQjKIQgODNwPIASAEIBBCMIhCA4M3A8ABIAQgEEIuiEIDgzcDuAEgBCAQQiyIQgODNwOwASAEIBBCKohCA4M3A6gBIAQgEEIoiEIDgzcDoAEgBCAQQiaIQgODNwOYASAEIBBCJIhCA4M3A5ABIAQgEEIiiEIDgzcDiAEgBCAQQiCIQgODNwOAASAEIBBCHohCA4M3A3ggBCAQQhyIQgODNwNwIAQgEEIaiEIDgzcDaCAEIBBCGIhCA4M3A2AgBCAQQhaIQgODNwNYIAQgEEIUiEIDgzcDUCAEIBBCEohCA4M3A0ggBCAQQhCIQgODNwNAIAQgEEIOiEIDgzcDOCAEIBBCDIhCA4M3AzAgBCAQQgqIQgODNwMoIAQgEEIIiEIDgzcDICAEIBBCBohCA4M3AxggBCAQQgSIQgODNwMQIAQgEEICiEIDgzcDCCAEIAUpAAgiEEI+iDcD+AMgBCAQQgODNwOAAiAEIBBCPIhCA4M3A/ADIAQgEEI6iEIDgzcD6AMgBCAQQjiIQgODNwPgAyAEIBBCNohCA4M3A9gDIAQgEEI0iEIDgzcD0AMgBCAQQjKIQgODNwPIAyAEIBBCMIhCA4M3A8ADIAQgEEIuiEIDgzcDuAMgBCAQQiyIQgODNwOwAyAEIBBCKohCA4M3A6gDIAQgEEIoiEIDgzcDoAMgBCAQQiaIQgODNwOYAyAEIBBCJIhCA4M3A5ADIAQgEEIiiEIDgzcDiAMgBCAQQiCIQgODNwOAAyAEIBBCHohCA4M3A/gCIAQgEEIciEIDgzcD8AIgBCAQQhqIQgODNwPoAiAEIBBCGIhCA4M3A+ACIAQgEEIWiEIDgzcD2AIgBCAQQhSIQgODNwPQAiAEIBBCEohCA4M3A8gCIAQgEEIQiEIDgzcDwAIgBCAQQg6IQgODNwO4AiAEIBBCDIhCA4M3A7ACIAQgEEIKiEIDgzcDqAIgBCAQQgiIQgODNwOgAiAEIBBCBohCA4M3A5gCIAQgEEIEiEIDgzcDkAIgBCAQQgKIQgODNwOIAgw/CyAGQRdNBEAMRwsgBCAFKQAAIhBCB4M3AwAgBCAQQjyIQgeDNwOgASAEIBBCOYhCB4M3A5gBIAQgEEI2iEIHgzcDkAEgBCAQQjOIQgeDNwOIASAEIBBCMIhCB4M3A4ABIAQgEEItiEIHgzcDeCAEIBBCKohCB4M3A3AgBCAQQieIQgeDNwNoIAQgEEIkiEIHgzcDYCAEIBBCIYhCB4M3A1ggBCAQQh6IQgeDNwNQIAQgEEIbiEIHgzcDSCAEIBBCGIhCB4M3A0AgBCAQQhWIQgeDNwM4IAQgEEISiEIHgzcDMCAEIBBCD4hCB4M3AyggBCAQQgyIQgeDNwMgIAQgEEIJiEIHgzcDGCAEIBBCBohCB4M3AxAgBCAQQgOIQgeDNwMIIAQgBSkACCIRQjuIQgeDNwPIAiAEIBFCOIhCB4M3A8ACIAQgEUI1iEIHgzcDuAIgBCARQjKIQgeDNwOwAiAEIBFCL4hCB4M3A6gCIAQgEUIsiEIHgzcDoAIgBCARQimIQgeDNwOYAiAEIBFCJohCB4M3A5ACIAQgEUIjiEIHgzcDiAIgBCARQiCIQgeDNwOAAiAEIBFCHYhCB4M3A/gBIAQgEUIaiEIHgzcD8AEgBCARQheIQgeDNwPoASAEIBFCFIhCB4M3A+ABIAQgEUIRiEIHgzcD2AEgBCARQg6IQgeDNwPQASAEIBFCC4hCB4M3A8gBIAQgEUIIiEIHgzcDwAEgBCARQgWIQgeDNwO4ASAEIBFCAohCB4M3A7ABIAQgEUIBhkIGgyAQQj+IhDcDqAEgBCAFKQAQIhBCPYg3A/gDIAQgEEI6iEIHgzcD8AMgBCAQQjeIQgeDNwPoAyAEIBBCNIhCB4M3A+ADIAQgEEIxiEIHgzcD2AMgBCAQQi6IQgeDNwPQAyAEIBBCK4hCB4M3A8gDIAQgEEIoiEIHgzcDwAMgBCAQQiWIQgeDNwO4AyAEIBBCIohCB4M3A7ADIAQgEEIfiEIHgzcDqAMgBCAQQhyIQgeDNwOgAyAEIBBCGYhCB4M3A5gDIAQgEEIWiEIHgzcDkAMgBCAQQhOIQgeDNwOIAyAEIBBCEIhCB4M3A4ADIAQgEEINiEIHgzcD+AIgBCAQQgqIQgeDNwPwAiAEIBBCB4hCB4M3A+gCIAQgEEIEiEIHgzcD4AIgBCAQQgGIQgeDNwPYAiAEIBBCAoZCBIMgEUI+iIQ3A9ACDD4LIAZBH00EQAxGCyAEIAUpAAAiEEI8iDcDeCAEIBBCD4M3AwAgBCAFKQAIIhFCPIg3A/gBIAQgEUIPgzcDgAEgBCAQQjiIQg+DNwNwIAQgEEI0iEIPgzcDaCAEIBBCMIhCD4M3A2AgBCAQQiyIQg+DNwNYIAQgEEIoiEIPgzcDUCAEIBBCJIhCD4M3A0ggBCAQQiCIQg+DNwNAIAQgEEIciEIPgzcDOCAEIBBCGIhCD4M3AzAgBCAQQhSIQg+DNwMoIAQgEEIQiEIPgzcDICAEIBBCDIhCD4M3AxggBCAQQgiIQg+DNwMQIAQgEEIEiEIPgzcDCCAEIBFCOIhCD4M3A/ABIAQgEUI0iEIPgzcD6AEgBCARQjCIQg+DNwPgASAEIBFCLIhCD4M3A9gBIAQgEUIoiEIPgzcD0AEgBCARQiSIQg+DNwPIASAEIBFCIIhCD4M3A8ABIAQgEUIciEIPgzcDuAEgBCARQhiIQg+DNwOwASAEIBFCFIhCD4M3A6gBIAQgEUIQiEIPgzcDoAEgBCARQgyIQg+DNwOYASAEIBFCCIhCD4M3A5ABIAQgEUIEiEIPgzcDiAEgBCAFKQAQIhBCPIg3A/gCIAQgEEIPgzcDgAIgBCAFKQAYIhFCPIg3A/gDIAQgEUIPgzcDgAMgBCAQQjiIQg+DNwPwAiAEIBBCNIhCD4M3A+gCIAQgEEIwiEIPgzcD4AIgBCAQQiyIQg+DNwPYAiAEIBBCKIhCD4M3A9ACIAQgEEIkiEIPgzcDyAIgBCAQQiCIQg+DNwPAAiAEIBBCHIhCD4M3A7gCIAQgEEIYiEIPgzcDsAIgBCAQQhSIQg+DNwOoAiAEIBBCEIhCD4M3A6ACIAQgEEIMiEIPgzcDmAIgBCAQQgiIQg+DNwOQAiAEIBBCBIhCD4M3A4gCIAQgEUI4iEIPgzcD8AMgBCARQjSIQg+DNwPoAyAEIBFCMIhCD4M3A+ADIAQgEUIsiEIPgzcD2AMgBCARQiiIQg+DNwPQAyAEIBFCJIhCD4M3A8gDIAQgEUIgiEIPgzcDwAMgBCARQhyIQg+DNwO4AyAEIBFCGIhCD4M3A7ADIAQgEUIUiEIPgzcDqAMgBCARQhCIQg+DNwOgAyAEIBFCDIhCD4M3A5gDIAQgEUIIiEIPgzcDkAMgBCARQgSIQg+DNwOIAww9CyAGQSdNBEAMRQsgBCAFKQAAIhFCH4M3AwAgBCARQjeIQh+DNwNYIAQgEUIyiEIfgzcDUCAEIBFCLYhCH4M3A0ggBCARQiiIQh+DNwNAIAQgEUIjiEIfgzcDOCAEIBFCHohCH4M3AzAgBCARQhmIQh+DNwMoIAQgEUIUiEIfgzcDICAEIBFCD4hCH4M3AxggBCARQgqIQh+DNwMQIAQgEUIFiEIfgzcDCCAEIAUpAAgiEEI4iEIfgzcDwAEgBCAQQjOIQh+DNwO4ASAEIBBCLohCH4M3A7ABIAQgEEIpiEIfgzcDqAEgBCAQQiSIQh+DNwOgASAEIBBCH4hCH4M3A5gBIAQgEEIaiEIfgzcDkAEgBCAQQhWIQh+DNwOIASAEIBBCEIhCH4M3A4ABIAQgEEILiEIfgzcDeCAEIBBCBohCH4M3A3AgBCAQQgGIQh+DNwNoIAQgEEIEhkIQgyARQjyIhDcDYCAEIAUpABAiEUI5iEIfgzcDqAIgBCARQjSIQh+DNwOgAiAEIBFCL4hCH4M3A5gCIAQgEUIqiEIfgzcDkAIgBCARQiWIQh+DNwOIAiAEIBFCIIhCH4M3A4ACIAQgEUIbiEIfgzcD+AEgBCARQhaIQh+DNwPwASAEIBFCEYhCH4M3A+gBIAQgEUIMiEIfgzcD4AEgBCARQgeIQh+DNwPYASAEIBFCAohCH4M3A9ABIAQgBSkAGCISQjqIQh+DNwOQAyAEIBJCNYhCH4M3A4gDIAQgEkIwiEIfgzcDgAMgBCASQiuIQh+DNwP4AiAEIBJCJohCH4M3A/ACIAQgEkIhiEIfgzcD6AIgBCASQhyIQh+DNwPgAiAEIBJCF4hCH4M3A9gCIAQgEkISiEIfgzcD0AIgBCASQg2IQh+DNwPIAiAEIBJCCIhCH4M3A8ACIAQgEkIDiEIfgzcDuAIgBCARQgOGQhiDIBBCPYiENwPIASAEIBJCAoZCHIMgEUI+iIQ3A7ACIAQgBSkAICIQQjuINwP4AyAEIBBCNohCH4M3A/ADIAQgEEIxiEIfgzcD6AMgBCAQQiyIQh+DNwPgAyAEIBBCJ4hCH4M3A9gDIAQgEEIiiEIfgzcD0AMgBCAQQh2IQh+DNwPIAyAEIBBCGIhCH4M3A8ADIAQgEEITiEIfgzcDuAMgBCAQQg6IQh+DNwOwAyAEIBBCCYhCH4M3A6gDIAQgEEIEiEIfgzcDoAMgBCAQQgGGQh6DIBJCP4iENwOYAww8CyAGQS9NBEAMRAsgBCAFKQAAIhFCP4M3AwAgBCARQjaIQj+DNwNIIAQgEUIwiEI/gzcDQCAEIBFCKohCP4M3AzggBCARQiSIQj+DNwMwIAQgEUIeiEI/gzcDKCAEIBFCGIhCP4M3AyAgBCARQhKIQj+DNwMYIAQgEUIMiEI/gzcDECAEIBFCBohCP4M3AwggBCAFKQAIIhBCOIhCP4M3A6ABIAQgEEIyiEI/gzcDmAEgBCAQQiyIQj+DNwOQASAEIBBCJohCP4M3A4gBIAQgEEIgiEI/gzcDgAEgBCAQQhqIQj+DNwN4IAQgEEIUiEI/gzcDcCAEIBBCDohCP4M3A2ggBCAQQgiIQj+DNwNgIAQgEEICiEI/gzcDWCAEIBBCBIZCMIMgEUI8iIQ3A1AgBCAFKQAQIhFCOog3A/gBIAQgBSkAGCISQj+DNwOAAiAEIBFCNIhCP4M3A/ABIAQgEUIuiEI/gzcD6AEgBCARQiiIQj+DNwPgASAEIBFCIohCP4M3A9gBIAQgEUIciEI/gzcD0AEgBCARQhaIQj+DNwPIASAEIBFCEIhCP4M3A8ABIAQgEUIKiEI/gzcDuAEgBCARQgSIQj+DNwOwASAEIBJCNohCP4M3A8gCIAQgEkIwiEI/gzcDwAIgBCASQiqIQj+DNwO4AiAEIBJCJIhCP4M3A7ACIAQgEkIeiEI/gzcDqAIgBCASQhiIQj+DNwOgAiAEIBJCEohCP4M3A5gCIAQgEkIMiEI/gzcDkAIgBCASQgaIQj+DNwOIAiAEIBFCAoZCPIMgEEI+iIQ3A6gBIAQgBSkAICIQQjiIQj+DNwOgAyAEIBBCMohCP4M3A5gDIAQgEEIsiEI/gzcDkAMgBCAQQiaIQj+DNwOIAyAEIBBCIIhCP4M3A4ADIAQgEEIaiEI/gzcD+AIgBCAQQhSIQj+DNwPwAiAEIBBCDohCP4M3A+gCIAQgEEIIiEI/gzcD4AIgBCAQQgKIQj+DNwPYAiAEIBBCBIZCMIMgEkI8iIQ3A9ACIAQgBSkAKCIRQjqINwP4AyAEIBFCNIhCP4M3A/ADIAQgEUIuiEI/gzcD6AMgBCARQiiIQj+DNwPgAyAEIBFCIohCP4M3A9gDIAQgEUIciEI/gzcD0AMgBCARQhaIQj+DNwPIAyAEIBFCEIhCP4M3A8ADIAQgEUIKiEI/gzcDuAMgBCARQgSIQj+DNwOwAyAEIBFCAoZCPIMgEEI+iIQ3A6gDDDsLIAZBN00EQAxDCyAEIAUpAAAiEEL/AIM3AwAgBCAQQjiIQv8AgzcDQCAEIBBCMYhC/wCDNwM4IAQgEEIqiEL/AIM3AzAgBCAQQiOIQv8AgzcDKCAEIBBCHIhC/wCDNwMgIAQgEEIViEL/AIM3AxggBCAQQg6IQv8AgzcDECAEIBBCB4hC/wCDNwMIIAQgBSkACCIRQjeIQv8AgzcDiAEgBCARQjCIQv8AgzcDgAEgBCARQimIQv8AgzcDeCAEIBFCIohC/wCDNwNwIAQgEUIbiEL/AIM3A2ggBCARQhSIQv8AgzcDYCAEIBFCDYhC/wCDNwNYIAQgEUIGiEL/AIM3A1AgBCARQgGGQv4AgyAQQj+IhDcDSCAEIAUpABAiEEI2iEL/AIM3A9ABIAQgEEIviEL/AIM3A8gBIAQgEEIoiEL/AIM3A8ABIAQgEEIhiEL/AIM3A7gBIAQgEEIaiEL/AIM3A7ABIAQgEEITiEL/AIM3A6gBIAQgEEIMiEL/AIM3A6ABIAQgEEIFiEL/AIM3A5gBIAQgBSkAGCISQjWIQv8AgzcDmAIgBCASQi6IQv8AgzcDkAIgBCASQieIQv8AgzcDiAIgBCASQiCIQv8AgzcDgAIgBCASQhmIQv8AgzcD+AEgBCASQhKIQv8AgzcD8AEgBCASQguIQv8AgzcD6AEgBCASQgSIQv8AgzcD4AEgBCAQQgKGQvwAgyARQj6IhDcDkAEgBCASQgOGQvgAgyAQQj2IhDcD2AEgBCAFKQAgIhBCNIhC/wCDNwPgAiAEIBBCLYhC/wCDNwPYAiAEIBBCJohC/wCDNwPQAiAEIBBCH4hC/wCDNwPIAiAEIBBCGIhC/wCDNwPAAiAEIBBCEYhC/wCDNwO4AiAEIBBCCohC/wCDNwOwAiAEIBBCA4hC/wCDNwOoAiAEIBBCBIZC8ACDIBJCPIiENwOgAiAEIAUpACgiEUIziEL/AIM3A6gDIAQgEUIsiEL/AIM3A6ADIAQgEUIliEL/AIM3A5gDIAQgEUIeiEL/AIM3A5ADIAQgEUIXiEL/AIM3A4gDIAQgEUIQiEL/AIM3A4ADIAQgEUIJiEL/AIM3A/gCIAQgEUICiEL/AIM3A/ACIAQgEUIFhkLgAIMgEEI7iIQ3A+gCIAQgBSkAMCIQQjmINwP4AyAEIBBCMohC/wCDNwPwAyAEIBBCK4hC/wCDNwPoAyAEIBBCJIhC/wCDNwPgAyAEIBBCHYhC/wCDNwPYAyAEIBBCFohC/wCDNwPQAyAEIBBCD4hC/wCDNwPIAyAEIBBCCIhC/wCDNwPAAyAEIBBCAYhC/wCDNwO4AyAEIBBCBoZCwACDIBFCOoiENwOwAww6CyAGQT9NBEAMQgsgBCAFKQAAIhBCOIg3AzggBCAQQv8BgzcDACAEIAUpAAgiEUI4iDcDeCAEIBFC/wGDNwNAIAQgEEIwiEL/AYM3AzAgBCAQQiiIQv8BgzcDKCAEIBBCIIhC/wGDNwMgIAQgEEIYiEL/AYM3AxggBCAQQhCIQv8BgzcDECAEIBBCCIhC/wGDNwMIIAQgEUIwiEL/AYM3A3AgBCARQiiIQv8BgzcDaCAEIBFCIIhC/wGDNwNgIAQgEUIYiEL/AYM3A1ggBCARQhCIQv8BgzcDUCAEIBFCCIhC/wGDNwNIIAQgBSkAECIQQjiINwO4ASAEIBBCMIhC/wGDNwOwASAEIBBCKIhC/wGDNwOoASAEIBBCIIhC/wGDNwOgASAEIBBCGIhC/wGDNwOYASAEIBBCEIhC/wGDNwOQASAEIBBCCIhC/wGDNwOIASAEIBBC/wGDNwOAASAEIAUpABgiEEI4iDcD+AEgBCAQQv8BgzcDwAEgBCAQQjCIQv8BgzcD8AEgBCAQQiiIQv8BgzcD6AEgBCAQQiCIQv8BgzcD4AEgBCAQQhiIQv8BgzcD2AEgBCAQQhCIQv8BgzcD0AEgBCAQQgiIQv8BgzcDyAEgBCAFKQAgIhBCOIg3A7gCIAQgEEIwiEL/AYM3A7ACIAQgEEIoiEL/AYM3A6gCIAQgEEIgiEL/AYM3A6ACIAQgEEIYiEL/AYM3A5gCIAQgEEIQiEL/AYM3A5ACIAQgEEIIiEL/AYM3A4gCIAQgEEL/AYM3A4ACIAQgBSkAKCIQQjiINwP4AiAEIBBC/wGDNwPAAiAEIBBCMIhC/wGDNwPwAiAEIBBCKIhC/wGDNwPoAiAEIBBCIIhC/wGDNwPgAiAEIBBCGIhC/wGDNwPYAiAEIBBCEIhC/wGDNwPQAiAEIBBCCIhC/wGDNwPIAiAEIAUpADAiEEI4iDcDuAMgBCAQQv8BgzcDgAMgBCAQQjCIQv8BgzcDsAMgBCAQQiiIQv8BgzcDqAMgBCAQQiCIQv8BgzcDoAMgBCAQQhiIQv8BgzcDmAMgBCAQQhCIQv8BgzcDkAMgBCAQQgiIQv8BgzcDiAMgBCAFKQA4IhBCOIg3A/gDIAQgEEL/AYM3A8ADIAQgEEIwiEL/AYM3A/ADIAQgEEIoiEL/AYM3A+gDIAQgEEIgiEL/AYM3A+ADIAQgEEIYiEL/AYM3A9gDIAQgEEIQiEL/AYM3A9ADIAQgEEIIiEL/AYM3A8gDDDkLIAZBxwBNBEAMQQsgBCAFKQAAIhBC/wODNwMAIAQgEEI2iEL/A4M3AzAgBCAQQi2IQv8DgzcDKCAEIBBCJIhC/wODNwMgIAQgEEIbiEL/A4M3AxggBCAQQhKIQv8DgzcDECAEIBBCCYhC/wODNwMIIAQgBSkACCIRQjWIQv8DgzcDaCAEIBFCLIhC/wODNwNgIAQgEUIjiEL/A4M3A1ggBCARQhqIQv8DgzcDUCAEIBFCEYhC/wODNwNIIAQgEUIIiEL/A4M3A0AgBCAFKQAQIhJCNIhC/wODNwOgASAEIBJCK4hC/wODNwOYASAEIBJCIohC/wODNwOQASAEIBJCGYhC/wODNwOIASAEIBJCEIhC/wODNwOAASAEIBJCB4hC/wODNwN4IAQgEUIBhkL+A4MgEEI/iIQ3AzggBCASQgKGQvwDgyARQj6IhDcDcCAEIAUpABgiEEIziEL/A4M3A9gBIAQgEEIqiEL/A4M3A9ABIAQgEEIhiEL/A4M3A8gBIAQgEEIYiEL/A4M3A8ABIAQgEEIPiEL/A4M3A7gBIAQgEEIGiEL/A4M3A7ABIAQgBSkAICIRQjKIQv8DgzcDkAIgBCARQimIQv8DgzcDiAIgBCARQiCIQv8DgzcDgAIgBCARQheIQv8DgzcD+AEgBCARQg6IQv8DgzcD8AEgBCARQgWIQv8DgzcD6AEgBCAFKQAoIhNCMYhC/wODNwPIAiAEIBNCKIhC/wODNwPAAiAEIBNCH4hC/wODNwO4AiAEIBNCFohC/wODNwOwAiAEIBNCDYhC/wODNwOoAiAEIBNCBIhC/wODNwOgAiAEIBBCA4ZC+AODIBJCPYiENwOoASAEIBFCBIZC8AODIBBCPIiENwPgASAEIBNCBYZC4AODIBFCO4iENwOYAiAEIAUpADAiEEIwiEL/A4M3A4ADIAQgEEIniEL/A4M3A/gCIAQgEEIeiEL/A4M3A/ACIAQgEEIViEL/A4M3A+gCIAQgEEIMiEL/A4M3A+ACIAQgEEIDiEL/A4M3A9gCIAQgEEIGhkLAA4MgE0I6iIQ3A9ACIAQgBSkAOCIRQi+IQv8DgzcDuAMgBCARQiaIQv8DgzcDsAMgBCARQh2IQv8DgzcDqAMgBCARQhSIQv8DgzcDoAMgBCARQguIQv8DgzcDmAMgBCARQgKIQv8DgzcDkAMgBCARQgeGQoADgyAQQjmIhDcDiAMgBCAFKQBAIhBCN4g3A/gDIAQgEEIuiEL/A4M3A/ADIAQgEEIliEL/A4M3A+gDIAQgEEIciEL/A4M3A+ADIAQgEEITiEL/A4M3A9gDIAQgEEIKiEL/A4M3A9ADIAQgEEIBiEL/A4M3A8gDIAQgEEIIhkKAAoMgEUI4iIQ3A8ADDDgLIAZBzwBNBEAMQAsgBCAFKQAAIhFC/weDNwMAIAQgEUIyiEL/B4M3AyggBCARQiiIQv8HgzcDICAEIBFCHohC/weDNwMYIAQgEUIUiEL/B4M3AxAgBCARQgqIQv8HgzcDCCAEIAUpAAgiEkIuiEL/B4M3A1ggBCASQiSIQv8HgzcDUCAEIBJCGohC/weDNwNIIAQgEkIQiEL/B4M3A0AgBCASQgaIQv8HgzcDOCAEIAUpABAiEEI0iEL/B4M3A5ABIAQgEEIqiEL/B4M3A4gBIAQgEEIgiEL/B4M3A4ABIAQgEEIWiEL/B4M3A3ggBCAQQgyIQv8HgzcDcCAEIBBCAohC/weDNwNoIAQgEkIEhkLwB4MgEUI8iIQ3AzAgBCAQQgiGQoAGgyASQjiIhDcDYCAEIAUpACAiEUI2iDcD+AEgBCAFKQAoIhJC/weDNwOAAiAEIAUpABgiE0IwiEL/B4M3A8ABIAQgE0ImiEL/B4M3A7gBIAQgE0IciEL/B4M3A7ABIAQgE0ISiEL/B4M3A6gBIAQgE0IIiEL/B4M3A6ABIAQgEUIsiEL/B4M3A/ABIAQgEUIiiEL/B4M3A+gBIAQgEUIYiEL/B4M3A+ABIAQgEUIOiEL/B4M3A9gBIAQgEUIEiEL/B4M3A9ABIAQgEkIyiEL/B4M3A6gCIAQgEkIoiEL/B4M3A6ACIAQgEkIeiEL/B4M3A5gCIAQgEkIUiEL/B4M3A5ACIAQgEkIKiEL/B4M3A4gCIAQgE0IChkL8B4MgEEI+iIQ3A5gBIAQgEUIGhkLAB4MgE0I6iIQ3A8gBIAQgBSkAMCIRQi6IQv8HgzcD2AIgBCARQiSIQv8HgzcD0AIgBCARQhqIQv8HgzcDyAIgBCARQhCIQv8HgzcDwAIgBCARQgaIQv8HgzcDuAIgBCARQgSGQvAHgyASQjyIhDcDsAIgBCAFKQA4IhBCNIhC/weDNwOQAyAEIBBCKohC/weDNwOIAyAEIBBCIIhC/weDNwOAAyAEIBBCFohC/weDNwP4AiAEIBBCDIhC/weDNwPwAiAEIBBCAohC/weDNwPoAiAEIBBCCIZCgAaDIBFCOIiENwPgAiAEIAUpAEAiEUIwiEL/B4M3A8ADIAQgEUImiEL/B4M3A7gDIAQgEUIciEL/B4M3A7ADIAQgEUISiEL/B4M3A6gDIAQgEUIIiEL/B4M3A6ADIAQgEUIChkL8B4MgEEI+iIQ3A5gDIAQgBSkASCIQQjaINwP4AyAEIBBCLIhC/weDNwPwAyAEIBBCIohC/weDNwPoAyAEIBBCGIhC/weDNwPgAyAEIBBCDohC/weDNwPYAyAEIBBCBIhC/weDNwPQAyAEIBBCBoZCwAeDIBFCOoiENwPIAww3CyAGQdcATQRADD8LIAQgBSkAACISQv8PgzcDACAEIBJCLIhC/w+DNwMgIAQgEkIhiEL/D4M3AxggBCASQhaIQv8PgzcDECAEIBJCC4hC/w+DNwMIIAQgBSkACCIQQi6IQv8PgzcDUCAEIBBCI4hC/w+DNwNIIAQgEEIYiEL/D4M3A0AgBCAQQg2IQv8PgzcDOCAEIBBCAohC/w+DNwMwIAQgBSkAECIRQjCIQv8PgzcDgAEgBCARQiWIQv8PgzcDeCAEIBFCGohC/w+DNwNwIAQgEUIPiEL/D4M3A2ggBCARQgSIQv8PgzcDYCAEIBBCCYZCgAyDIBJCN4iENwMoIAQgEUIHhkKAD4MgEEI5iIQ3A1ggBCAFKQAYIhBCMohC/w+DNwOwASAEIBBCJ4hC/w+DNwOoASAEIBBCHIhC/w+DNwOgASAEIBBCEYhC/w+DNwOYASAEIBBCBohC/w+DNwOQASAEIAUpACAiEkI0iEL/D4M3A+ABIAQgEkIpiEL/D4M3A9gBIAQgEkIeiEL/D4M3A9ABIAQgEkITiEL/D4M3A8gBIAQgEkIIiEL/D4M3A8ABIAQgBSkAKCITQiuIQv8PgzcDiAIgBCATQiCIQv8PgzcDgAIgBCATQhWIQv8PgzcD+AEgBCATQgqIQv8PgzcD8AEgBCAQQgWGQuAPgyARQjuIhDcDiAEgBCASQgOGQvgPgyAQQj2IhDcDuAEgBCATQgGGQv4PgyASQj+IhDcD6AEgBCAFKQAwIhBCLYhC/w+DNwO4AiAEIBBCIohC/w+DNwOwAiAEIBBCF4hC/w+DNwOoAiAEIBBCDIhC/w+DNwOgAiAEIBBCAYhC/w+DNwOYAiAEIBBCCoZCgAiDIBNCNoiENwOQAiAEIAUpADgiEUIviEL/D4M3A+gCIAQgEUIkiEL/D4M3A+ACIAQgEUIZiEL/D4M3A9gCIAQgEUIOiEL/D4M3A9ACIAQgEUIDiEL/D4M3A8gCIAQgEUIIhkKADoMgEEI4iIQ3A8ACIAQgBSkAQCIQQjGIQv8PgzcDmAMgBCAQQiaIQv8PgzcDkAMgBCAQQhuIQv8PgzcDiAMgBCAQQhCIQv8PgzcDgAMgBCAQQgWIQv8PgzcD+AIgBCAQQgaGQsAPgyARQjqIhDcD8AIgBCAFKQBIIhFCM4hC/w+DNwPIAyAEIBFCKIhC/w+DNwPAAyAEIBFCHYhC/w+DNwO4AyAEIBFCEohC/w+DNwOwAyAEIBFCB4hC/w+DNwOoAyAEIBFCBIZC8A+DIBBCPIiENwOgAyAEIAUpAFAiEEI1iDcD+AMgBCAQQiqIQv8PgzcD8AMgBCAQQh+IQv8PgzcD6AMgBCAQQhSIQv8PgzcD4AMgBCAQQgmIQv8PgzcD2AMgBCAQQgKGQvwPgyARQj6IhDcD0AMMNgsgBkHfAE0EQAw+CyAEIAUpAAAiEEL/H4M3AwAgBCAFKQAQIhFCNIg3A3ggBCAQQjCIQv8fgzcDICAEIBBCJIhC/x+DNwMYIAQgEEIYiEL/H4M3AxAgBCAQQgyIQv8fgzcDCCAEIAUpAAgiEkIsiEL/H4M3A0ggBCASQiCIQv8fgzcDQCAEIBJCFIhC/x+DNwM4IAQgEkIIiEL/H4M3AzAgBCARQiiIQv8fgzcDcCAEIBFCHIhC/x+DNwNoIAQgEUIQiEL/H4M3A2AgBCARQgSIQv8fgzcDWCAEIBJCBIZC8B+DIBBCPIiENwMoIAQgEUIIhkKAHoMgEkI4iIQ3A1AgBCAFKQAYIhBC/x+DNwOAASAEIAUpACgiEUI0iDcD+AEgBCAQQjCIQv8fgzcDoAEgBCAQQiSIQv8fgzcDmAEgBCAQQhiIQv8fgzcDkAEgBCAQQgyIQv8fgzcDiAEgBCAFKQAgIhJCLIhC/x+DNwPIASAEIBJCIIhC/x+DNwPAASAEIBJCFIhC/x+DNwO4ASAEIBJCCIhC/x+DNwOwASAEIBFCKIhC/x+DNwPwASAEIBFCHIhC/x+DNwPoASAEIBFCEIhC/x+DNwPgASAEIBFCBIhC/x+DNwPYASAEIBJCBIZC8B+DIBBCPIiENwOoASAEIBFCCIZCgB6DIBJCOIiENwPQASAEIAUpADAiEEL/H4M3A4ACIAQgEEIwiEL/H4M3A6ACIAQgEEIkiEL/H4M3A5gCIAQgEEIYiEL/H4M3A5ACIAQgEEIMiEL/H4M3A4gCIAQgBSkAOCIRQiyIQv8fgzcDyAIgBCARQiCIQv8fgzcDwAIgBCARQhSIQv8fgzcDuAIgBCARQgiIQv8fgzcDsAIgBCARQgSGQvAfgyAQQjyIhDcDqAIgBCAFKQBAIhBCNIg3A/gCIAQgEEIoiEL/H4M3A/ACIAQgEEIciEL/H4M3A+gCIAQgEEIQiEL/H4M3A+ACIAQgEEIEiEL/H4M3A9gCIAQgEEIIhkKAHoMgEUI4iIQ3A9ACIAQgBSkASCIQQv8fgzcDgAMgBCAQQjCIQv8fgzcDoAMgBCAQQiSIQv8fgzcDmAMgBCAQQhiIQv8fgzcDkAMgBCAQQgyIQv8fgzcDiAMgBCAFKQBQIhFCLIhC/x+DNwPIAyAEIBFCIIhC/x+DNwPAAyAEIBFCFIhC/x+DNwO4AyAEIBFCCIhC/x+DNwOwAyAEIBFCBIZC8B+DIBBCPIiENwOoAyAEIAUpAFgiEEI0iDcD+AMgBCAQQiiIQv8fgzcD8AMgBCAQQhyIQv8fgzcD6AMgBCAQQhCIQv8fgzcD4AMgBCAQQgSIQv8fgzcD2AMgBCAQQgiGQoAegyARQjiIhDcD0AMMNQsgBkHnAE0EQAw9CyAEIAUpAAAiE0L/P4M3AwAgBCATQieIQv8/gzcDGCAEIBNCGohC/z+DNwMQIAQgE0INiEL/P4M3AwggBCAFKQAIIhBCKIhC/z+DNwNAIAQgEEIbiEL/P4M3AzggBCAQQg6IQv8/gzcDMCAEIBBCAYhC/z+DNwMoIAQgBSkAECIRQimIQv8/gzcDaCAEIBFCHIhC/z+DNwNgIAQgEUIPiEL/P4M3A1ggBCARQgKIQv8/gzcDUCAEIAUpABgiEkIqiEL/P4M3A5ABIAQgEkIdiEL/P4M3A4gBIAQgEkIQiEL/P4M3A4ABIAQgEkIDiEL/P4M3A3ggBCAQQgyGQoAggyATQjSIhDcDICAEIBFCC4ZCgDCDIBBCNYiENwNIIAQgEkIKhkKAOIMgEUI2iIQ3A3AgBCAFKQAgIhBCK4hC/z+DNwO4ASAEIBBCHohC/z+DNwOwASAEIBBCEYhC/z+DNwOoASAEIBBCBIhC/z+DNwOgASAEIAUpACgiEUIsiEL/P4M3A+ABIAQgEUIfiEL/P4M3A9gBIAQgEUISiEL/P4M3A9ABIAQgEUIFiEL/P4M3A8gBIAQgBSkAMCITQi2IQv8/gzcDiAIgBCATQiCIQv8/gzcDgAIgBCATQhOIQv8/gzcD+AEgBCATQgaIQv8/gzcD8AEgBCAQQgmGQoA8gyASQjeIhDcDmAEgBCARQgiGQoA+gyAQQjiIhDcDwAEgBCATQgeGQoA/gyARQjmIhDcD6AEgBCAFKQA4IhBCLohC/z+DNwOwAiAEIBBCIYhC/z+DNwOoAiAEIBBCFIhC/z+DNwOgAiAEIBBCB4hC/z+DNwOYAiAEIBBCBoZCwD+DIBNCOoiENwOQAiAEIAUpAEAiEUIviEL/P4M3A9gCIAQgEUIiiEL/P4M3A9ACIAQgEUIViEL/P4M3A8gCIAQgEUIIiEL/P4M3A8ACIAQgEUIFhkLgP4MgEEI7iIQ3A7gCIAQgBSkASCIQQjCIQv8/gzcDgAMgBCAQQiOIQv8/gzcD+AIgBCAQQhaIQv8/gzcD8AIgBCAQQgmIQv8/gzcD6AIgBCAQQgSGQvA/gyARQjyIhDcD4AIgBCAFKQBQIhFCMYhC/z+DNwOoAyAEIBFCJIhC/z+DNwOgAyAEIBFCF4hC/z+DNwOYAyAEIBFCCohC/z+DNwOQAyAEIBFCA4ZC+D+DIBBCPYiENwOIAyAEIAUpAFgiEEIyiEL/P4M3A9ADIAQgEEIliEL/P4M3A8gDIAQgEEIYiEL/P4M3A8ADIAQgEEILiEL/P4M3A7gDIAQgEEIChkL8P4MgEUI+iIQ3A7ADIAQgBSkAYCIRQjOINwP4AyAEIBFCJohC/z+DNwPwAyAEIBFCGYhC/z+DNwPoAyAEIBFCDIhC/z+DNwPgAyAEIBFCAYZC/j+DIBBCP4iENwPYAww0CyAGQe8ATQRADDwLIAQgBSkAACISQv//AIM3AwAgBCASQiqIQv//AIM3AxggBCASQhyIQv//AIM3AxAgBCASQg6IQv//AIM3AwggBCAFKQAIIhBCMIhC//8AgzcDQCAEIBBCIohC//8AgzcDOCAEIBBCFIhC//8AgzcDMCAEIBBCBohC//8AgzcDKCAEIAUpABAiE0IoiEL//wCDNwNgIAQgE0IaiEL//wCDNwNYIAQgE0IMiEL//wCDNwNQIAQgBSkAGCIRQi6IQv//AIM3A4gBIAQgEUIgiEL//wCDNwOAASAEIBFCEohC//8AgzcDeCAEIBFCBIhC//8AgzcDcCAEIBBCCIZCgP4AgyASQjiIhDcDICAEIBNCAoZC/P8AgyAQQj6IhDcDSCAEIBFCCoZCgPgAgyATQjaIhDcDaCAEIAUpADAiEkIyiDcD+AEgBCAFKQAgIhNCJohC//8AgzcDqAEgBCATQhiIQv//AIM3A6ABIAQgE0IKiEL//wCDNwOYASAEIAUpACgiEEIsiEL//wCDNwPQASAEIBBCHohC//8AgzcDyAEgBCAQQhCIQv//AIM3A8ABIAQgEEICiEL//wCDNwO4ASAEIBJCJIhC//8AgzcD8AEgBCASQhaIQv//AIM3A+gBIAQgEkIIiEL//wCDNwPgASAEIBNCBIZC8P8AgyARQjyIhDcDkAEgBCAQQgyGQoDgAIMgE0I0iIQ3A7ABIAQgEkIGhkLA/wCDIBBCOoiENwPYASAEIAUpADgiEUIqiEL//wCDNwOYAiAEIBFCHIhC//8AgzcDkAIgBCARQg6IQv//AIM3A4gCIAQgEUL//wCDNwOAAiAEIAUpAEAiEEIwiEL//wCDNwPAAiAEIBBCIohC//8AgzcDuAIgBCAQQhSIQv//AIM3A7ACIAQgEEIGiEL//wCDNwOoAiAEIBBCCIZCgP4AgyARQjiIhDcDoAIgBCAFKQBIIhFCKIhC//8AgzcD4AIgBCARQhqIQv//AIM3A9gCIAQgEUIMiEL//wCDNwPQAiAEIBFCAoZC/P8AgyAQQj6IhDcDyAIgBCAFKQBQIhBCLohC//8AgzcDiAMgBCAQQiCIQv//AIM3A4ADIAQgEEISiEL//wCDNwP4AiAEIBBCBIhC//8AgzcD8AIgBCAQQgqGQoD4AIMgEUI2iIQ3A+gCIAQgBSkAWCIRQiaIQv//AIM3A6gDIAQgEUIYiEL//wCDNwOgAyAEIBFCCohC//8AgzcDmAMgBCARQgSGQvD/AIMgEEI8iIQ3A5ADIAQgBSkAYCIQQiyIQv//AIM3A9ADIAQgEEIeiEL//wCDNwPIAyAEIBBCEIhC//8AgzcDwAMgBCAQQgKIQv//AIM3A7gDIAQgEEIMhkKA4ACDIBFCNIiENwOwAyAEIAUpAGgiEUIyiDcD+AMgBCARQiSIQv//AIM3A/ADIAQgEUIWiEL//wCDNwPoAyAEIBFCCIhC//8AgzcD4AMgBCARQgaGQsD/AIMgEEI6iIQ3A9gDDDMLIAZB9wBNBEAMOwsgBCAFKQAAIhFC//8BgzcDACAEIBFCLYhC//8BgzcDGCAEIBFCHohC//8BgzcDECAEIBFCD4hC//8BgzcDCCAEIAUpAAgiEkIpiEL//wGDNwM4IAQgEkIaiEL//wGDNwMwIAQgEkILiEL//wGDNwMoIAQgBSkAECITQiWIQv//AYM3A1ggBCATQhaIQv//AYM3A1AgBCATQgeIQv//AYM3A0ggBCAFKQAYIhBCMIhC//8BgzcDgAEgBCAQQiGIQv//AYM3A3ggBCAQQhKIQv//AYM3A3AgBCAQQgOIQv//AYM3A2ggBCASQgSGQvD/AYMgEUI8iIQ3AyAgBCATQgiGQoD+AYMgEkI4iIQ3A0AgBCAQQgyGQoDgAYMgE0I0iIQ3A2AgBCAFKQAgIhJCLIhC//8BgzcDoAEgBCASQh2IQv//AYM3A5gBIAQgEkIOiEL//wGDNwOQASAEIAUpACgiE0IoiEL//wGDNwPAASAEIBNCGYhC//8BgzcDuAEgBCATQgqIQv//AYM3A7ABIAQgBSkAMCIUQiSIQv//AYM3A+ABIAQgFEIViEL//wGDNwPYASAEIBRCBohC//8BgzcD0AEgBCAFKQA4IhFCL4hC//8BgzcDiAIgBCARQiCIQv//AYM3A4ACIAQgEUIRiEL//wGDNwP4ASAEIBFCAohC//8BgzcD8AEgBCASQgGGQv7/AYMgEEI/iIQ3A4gBIAQgE0IFhkLg/wGDIBJCO4iENwOoASAEIBRCCYZCgPwBgyATQjeIhDcDyAEgBCARQg2GQoDAAYMgFEIziIQ3A+gBIAQgBSkAQCIQQiuIQv//AYM3A6gCIAQgEEIciEL//wGDNwOgAiAEIBBCDYhC//8BgzcDmAIgBCAQQgKGQvz/AYMgEUI+iIQ3A5ACIAQgBSkASCIRQieIQv//AYM3A8gCIAQgEUIYiEL//wGDNwPAAiAEIBFCCYhC//8BgzcDuAIgBCARQgaGQsD/AYMgEEI6iIQ3A7ACIAQgBSkAUCISQiOIQv//AYM3A+gCIAQgEkIUiEL//wGDNwPgAiAEIBJCBYhC//8BgzcD2AIgBCASQgqGQoD4AYMgEUI2iIQ3A9ACIAQgBSkAWCIQQi6IQv//AYM3A5ADIAQgEEIfiEL//wGDNwOIAyAEIBBCEIhC//8BgzcDgAMgBCAQQgGIQv//AYM3A/gCIAQgEEIOhkKAgAGDIBJCMoiENwPwAiAEIAUpAGAiEUIqiEL//wGDNwOwAyAEIBFCG4hC//8BgzcDqAMgBCARQgyIQv//AYM3A6ADIAQgEUIDhkL4/wGDIBBCPYiENwOYAyAEIAUpAGgiEEImiEL//wGDNwPQAyAEIBBCF4hC//8BgzcDyAMgBCAQQgiIQv//AYM3A8ADIAQgEEIHhkKA/wGDIBFCOYiENwO4AyAEIAUpAHAiEUIxiDcD+AMgBCARQiKIQv//AYM3A/ADIAQgEUITiEL//wGDNwPoAyAEIBFCBIhC//8BgzcD4AMgBCARQguGQoDwAYMgEEI1iIQ3A9gDDDILIAZB/wBNBEAMOgsgBCAFKQAAIhBCMIg3AxggBCAQQv//A4M3AwAgBCAFKQAIIhFCMIg3AzggBCARQv//A4M3AyAgBCAFKQAQIhJCMIg3A1ggBCASQv//A4M3A0AgBCAFKQAYIhNCMIg3A3ggBCATQv//A4M3A2AgBCAQQiCIQv//A4M3AxAgBCAQQhCIQv//A4M3AwggBCARQiCIQv//A4M3AzAgBCARQhCIQv//A4M3AyggBCASQiCIQv//A4M3A1AgBCASQhCIQv//A4M3A0ggBCATQiCIQv//A4M3A3AgBCATQhCIQv//A4M3A2ggBCAFKQAgIhBCMIg3A5gBIAQgEEL//wODNwOAASAEIAUpACgiEUIwiDcDuAEgBCARQv//A4M3A6ABIAQgBSkAMCISQjCINwPYASAEIBJC//8DgzcDwAEgBCAFKQA4IhNCMIg3A/gBIAQgE0L//wODNwPgASAEIBBCIIhC//8DgzcDkAEgBCAQQhCIQv//A4M3A4gBIAQgEUIgiEL//wODNwOwASAEIBFCEIhC//8DgzcDqAEgBCASQiCIQv//A4M3A9ABIAQgEkIQiEL//wODNwPIASAEIBNCIIhC//8DgzcD8AEgBCATQhCIQv//A4M3A+gBIAQgBSkAQCIQQjCINwOYAiAEIBBC//8DgzcDgAIgBCAQQiCIQv//A4M3A5ACIAQgEEIQiEL//wODNwOIAiAEIAUpAEgiEEIwiDcDuAIgBCAQQv//A4M3A6ACIAQgEEIgiEL//wODNwOwAiAEIBBCEIhC//8DgzcDqAIgBCAFKQBQIhBCMIg3A9gCIAQgEEL//wODNwPAAiAEIBBCIIhC//8DgzcD0AIgBCAQQhCIQv//A4M3A8gCIAQgBSkAWCIQQjCINwP4AiAEIBBC//8DgzcD4AIgBCAQQiCIQv//A4M3A/ACIAQgEEIQiEL//wODNwPoAiAEIAUpAGAiEEIwiDcDmAMgBCAQQv//A4M3A4ADIAQgEEIgiEL//wODNwOQAyAEIBBCEIhC//8DgzcDiAMgBCAFKQBoIhBCMIg3A7gDIAQgEEL//wODNwOgAyAEIBBCIIhC//8DgzcDsAMgBCAQQhCIQv//A4M3A6gDIAQgBSkAcCIQQjCINwPYAyAEIBBC//8DgzcDwAMgBCAQQiCIQv//A4M3A9ADIAQgEEIQiEL//wODNwPIAyAEIAUpAHgiEEIwiDcD+AMgBCAQQv//A4M3A+ADIAQgEEIgiEL//wODNwPwAyAEIBBCEIhC//8DgzcD6AMMMQsgBkGHAU0EQAw5CyAEIAUpAAAiE0L//weDNwMAIAQgE0IiiEL//weDNwMQIAQgE0IRiEL//weDNwMIIAQgBSkACCIQQiaIQv//B4M3AzAgBCAQQhWIQv//B4M3AyggBCAQQgSIQv//B4M3AyAgBCAFKQAQIhFCKohC//8HgzcDUCAEIBFCGYhC//8HgzcDSCAEIBFCCIhC//8HgzcDQCAEIAUpABgiEkIuiEL//weDNwNwIAQgEkIdiEL//weDNwNoIAQgEkIMiEL//weDNwNgIAQgEEINhkKAwAeDIBNCM4iENwMYIAQgEUIJhkKA/AeDIBBCN4iENwM4IAQgEkIFhkLg/weDIBFCO4iENwNYIAQgBSkAICIUQiGIQv//B4M3A4gBIAQgFEIQiEL//weDNwOAASAEIAUpACgiEEIliEL//weDNwOoASAEIBBCFIhC//8HgzcDoAEgBCAQQgOIQv//B4M3A5gBIAQgBSkAMCIRQimIQv//B4M3A8gBIAQgEUIYiEL//weDNwPAASAEIBFCB4hC//8HgzcDuAEgBCAFKQA4IhNCLYhC//8HgzcD6AEgBCATQhyIQv//B4M3A+ABIAQgE0ILiEL//weDNwPYASAEIBRCAYZC/v8HgyASQj+IhDcDeCAEIBBCDoZCgIAHgyAUQjKIhDcDkAEgBCARQgqGQoD4B4MgEEI2iIQ3A7ABIAQgE0IGhkLA/weDIBFCOoiENwPQASAEIAUpAEAiEUIgiEL//weDNwOAAiAEIBFCD4hC//8HgzcD+AEgBCARQgKGQvz/B4MgE0I+iIQ3A/ABIAQgBSkASCIQQiSIQv//B4M3A6ACIAQgEEITiEL//weDNwOYAiAEIBBCAohC//8HgzcDkAIgBCAQQg+GQoCABoMgEUIxiIQ3A4gCIAQgBSkAUCIRQiiIQv//B4M3A8ACIAQgEUIXiEL//weDNwO4AiAEIBFCBohC//8HgzcDsAIgBCARQguGQoDwB4MgEEI1iIQ3A6gCIAQgBSkAWCIQQiyIQv//B4M3A+ACIAQgEEIbiEL//weDNwPYAiAEIBBCCohC//8HgzcD0AIgBCAQQgeGQoD/B4MgEUI5iIQ3A8gCIAQgBSkAYCIRQh+IQv//B4M3A/gCIAQgEUIOiEL//weDNwPwAiAEIBFCA4ZC+P8HgyAQQj2IhDcD6AIgBCAFKQBoIhBCI4hC//8HgzcDmAMgBCAQQhKIQv//B4M3A5ADIAQgEEIBiEL//weDNwOIAyAEIBBCEIZCgIAEgyARQjCIhDcDgAMgBCAFKQBwIhFCJ4hC//8HgzcDuAMgBCARQhaIQv//B4M3A7ADIAQgEUIFiEL//weDNwOoAyAEIBFCDIZCgOAHgyAQQjSIhDcDoAMgBCAFKQB4IhBCK4hC//8HgzcD2AMgBCAQQhqIQv//B4M3A9ADIAQgEEIJiEL//weDNwPIAyAEIBBCCIZCgP4HgyARQjiIhDcDwAMgBCAFKQCAASIRQi+INwP4AyAEIBFCHohC//8HgzcD8AMgBCARQg2IQv//B4M3A+gDIAQgEUIEhkLw/weDIBBCPIiENwPgAwwwCyAGQY8BTQRADDgLIAQgBSkAACISQv//D4M3AwAgBCASQiSIQv//D4M3AxAgBCASQhKIQv//D4M3AwggBCAFKQAIIhBCLIhC//8PgzcDMCAEIBBCGohC//8PgzcDKCAEIBBCCIhC//8PgzcDICAEIAUpABAiE0IiiEL//w+DNwNIIAQgE0IQiEL//w+DNwNAIAQgBSkAGCIRQiqIQv//D4M3A2ggBCARQhiIQv//D4M3A2AgBCARQgaIQv//D4M3A1ggBCAQQgqGQoD4D4MgEkI2iIQ3AxggBCATQgKGQvz/D4MgEEI+iIQ3AzggBCARQgyGQoDgD4MgE0I0iIQ3A1AgBCAFKQAgIhJCIIhC//8PgzcDgAEgBCASQg6IQv//D4M3A3ggBCASQgSGQvD/D4MgEUI8iIQ3A3AgBCAFKQAoIhBCKIhC//8PgzcDoAEgBCAQQhaIQv//D4M3A5gBIAQgEEIEiEL//w+DNwOQASAEIAUpADAiE0IeiEL//w+DNwO4ASAEIBNCDIhC//8PgzcDsAEgBCAFKQA4IhFCJohC//8PgzcD2AEgBCARQhSIQv//D4M3A9ABIAQgEUICiEL//w+DNwPIASAEIBBCDoZCgIAPgyASQjKIhDcDiAEgBCATQgaGQsD/D4MgEEI6iIQ3A6gBIAQgEUIQhkKAgAyDIBNCMIiENwPAASAEIAUpAEAiEEIuiDcD+AEgBCAQQhyIQv//D4M3A/ABIAQgEEIKiEL//w+DNwPoASAEIBBCCIZCgP4PgyARQjiIhDcD4AEgBCAFKQBIIhFC//8PgzcDgAIgBCARQiSIQv//D4M3A5ACIAQgEUISiEL//w+DNwOIAiAEIAUpAFAiEEIsiEL//w+DNwOwAiAEIBBCGohC//8PgzcDqAIgBCAQQgiIQv//D4M3A6ACIAQgEEIKhkKA+A+DIBFCNoiENwOYAiAEIAUpAFgiEUIiiEL//w+DNwPIAiAEIBFCEIhC//8PgzcDwAIgBCARQgKGQvz/D4MgEEI+iIQ3A7gCIAQgBSkAYCIQQiqIQv//D4M3A+gCIAQgEEIYiEL//w+DNwPgAiAEIBBCBohC//8PgzcD2AIgBCAQQgyGQoDgD4MgEUI0iIQ3A9ACIAQgBSkAaCIRQiCIQv//D4M3A4ADIAQgEUIOiEL//w+DNwP4AiAEIBFCBIZC8P8PgyAQQjyIhDcD8AIgBCAFKQBwIhBCKIhC//8PgzcDoAMgBCAQQhaIQv//D4M3A5gDIAQgEEIEiEL//w+DNwOQAyAEIBBCDoZCgIAPgyARQjKIhDcDiAMgBCAFKQB4IhFCHohC//8PgzcDuAMgBCARQgyIQv//D4M3A7ADIAQgEUIGhkLA/w+DIBBCOoiENwOoAyAEIAUpAIABIhBCJohC//8PgzcD2AMgBCAQQhSIQv//D4M3A9ADIAQgEEICiEL//w+DNwPIAyAEIBBCEIZCgIAMgyARQjCIhDcDwAMgBCAFKQCIASIRQi6INwP4AyAEIBFCHIhC//8PgzcD8AMgBCARQgqIQv//D4M3A+gDIAQgEUIIhkKA/g+DIBBCOIiENwPgAwwvCyAGQZcBTQRADDcLIAQgBSkAACIRQv//H4M3AwAgBCARQiaIQv//H4M3AxAgBCARQhOIQv//H4M3AwggBCAFKQAIIhJCH4hC//8fgzcDKCAEIBJCDIhC//8fgzcDICAEIAUpABAiEEIriEL//x+DNwNIIAQgEEIYiEL//x+DNwNAIAQgEEIFiEL//x+DNwM4IAQgBSkAGCITQiSIQv//H4M3A2AgBCATQhGIQv//H4M3A1ggBCAFKQAgIhRCHYhC//8fgzcDeCAEIBRCCohC//8fgzcDcCAEIBJCB4ZCgP8fgyARQjmIhDcDGCAEIBBCDoZCgIAfgyASQjKIhDcDMCAEIBNCAoZC/P8fgyAQQj6IhDcDUCAEIBRCCYZCgPwfgyATQjeIhDcDaCAEIAUpACgiEEIpiEL//x+DNwOYASAEIBBCFohC//8fgzcDkAEgBCAQQgOIQv//H4M3A4gBIAQgBSkAMCISQiKIQv//H4M3A7ABIAQgEkIPiEL//x+DNwOoASAEIAUpADgiE0IbiEL//x+DNwPIASAEIBNCCIhC//8fgzcDwAEgBCAFKQBAIhFCJ4hC//8fgzcD6AEgBCARQhSIQv//H4M3A+ABIAQgEUIBiEL//x+DNwPYASAEIBBCEIZCgIAcgyAUQjCIhDcDgAEgBCASQgSGQvD/H4MgEEI8iIQ3A6ABIAQgE0ILhkKA8B+DIBJCNYiENwO4ASAEIBFCEoZCgIAQgyATQi6IhDcD0AEgBCAFKQBIIhJCIIhC//8fgzcDgAIgBCASQg2IQv//H4M3A/gBIAQgEkIGhkLA/x+DIBFCOoiENwPwASAEIAUpAFAiEEIsiEL//x+DNwOgAiAEIBBCGYhC//8fgzcDmAIgBCAQQgaIQv//H4M3A5ACIAQgEEINhkKAwB+DIBJCM4iENwOIAiAEIAUpAFgiEUIliEL//x+DNwO4AiAEIBFCEohC//8fgzcDsAIgBCARQgGGQv7/H4MgEEI/iIQ3A6gCIAQgBSkAYCISQh6IQv//H4M3A9ACIAQgEkILiEL//x+DNwPIAiAEIBJCCIZCgP4fgyARQjiIhDcDwAIgBCAFKQBoIhBCKohC//8fgzcD8AIgBCAQQheIQv//H4M3A+gCIAQgEEIEiEL//x+DNwPgAiAEIBBCD4ZCgIAegyASQjGIhDcD2AIgBCAFKQBwIhFCI4hC//8fgzcDiAMgBCARQhCIQv//H4M3A4ADIAQgEUIDhkL4/x+DIBBCPYiENwP4AiAEIAUpAHgiEkIciEL//x+DNwOgAyAEIBJCCYhC//8fgzcDmAMgBCASQgqGQoD4H4MgEUI2iIQ3A5ADIAQgBSkAgAEiEEIoiEL//x+DNwPAAyAEIBBCFYhC//8fgzcDuAMgBCAQQgKIQv//H4M3A7ADIAQgEEIRhkKAgBiDIBJCL4iENwOoAyAEIAUpAIgBIhFCIYhC//8fgzcD2AMgBCARQg6IQv//H4M3A9ADIAQgEUIFhkLg/x+DIBBCO4iENwPIAyAEIAUpAJABIhBCLYg3A/gDIAQgEEIaiEL//x+DNwPwAyAEIBBCB4hC//8fgzcD6AMgBCAQQgyGQoDgH4MgEUI0iIQ3A+ADDC4LIAZBnwFNBEAMNgsgBCAFKQAAIhBC//8/gzcDACAEIAUpACAiEUIsiDcDeCAEIBBCKIhC//8/gzcDECAEIBBCFIhC//8/gzcDCCAEIAUpAAgiEkIkiEL//z+DNwMoIAQgEkIQiEL//z+DNwMgIAQgBSkAECITQiCIQv//P4M3A0AgBCATQgyIQv//P4M3AzggBCAFKQAYIhRCHIhC//8/gzcDWCAEIBRCCIhC//8/gzcDUCAEIBFCGIhC//8/gzcDcCAEIBFCBIhC//8/gzcDaCAEIBJCBIZC8P8/gyAQQjyIhDcDGCAEIBNCCIZCgP4/gyASQjiIhDcDMCAEIBRCDIZCgOA/gyATQjSIhDcDSCAEIBFCEIZCgIA8gyAUQjCIhDcDYCAEIAUpACgiEEL//z+DNwOAASAEIAUpAEgiEUIsiDcD+AEgBCAQQiiIQv//P4M3A5ABIAQgEEIUiEL//z+DNwOIASAEIAUpADAiEkIkiEL//z+DNwOoASAEIBJCEIhC//8/gzcDoAEgBCAFKQA4IhNCIIhC//8/gzcDwAEgBCATQgyIQv//P4M3A7gBIAQgBSkAQCIUQhyIQv//P4M3A9gBIAQgFEIIiEL//z+DNwPQASAEIBFCGIhC//8/gzcD8AEgBCARQgSIQv//P4M3A+gBIAQgEkIEhkLw/z+DIBBCPIiENwOYASAEIBNCCIZCgP4/gyASQjiIhDcDsAEgBCAUQgyGQoDgP4MgE0I0iIQ3A8gBIAQgEUIQhkKAgDyDIBRCMIiENwPgASAEIAUpAFAiEEL//z+DNwOAAiAEIBBCKIhC//8/gzcDkAIgBCAQQhSIQv//P4M3A4gCIAQgBSkAWCIRQiSIQv//P4M3A6gCIAQgEUIQiEL//z+DNwOgAiAEIBFCBIZC8P8/gyAQQjyIhDcDmAIgBCAFKQBgIhBCIIhC//8/gzcDwAIgBCAQQgyIQv//P4M3A7gCIAQgEEIIhkKA/j+DIBFCOIiENwOwAiAEIAUpAGgiEUIciEL//z+DNwPYAiAEIBFCCIhC//8/gzcD0AIgBCARQgyGQoDgP4MgEEI0iIQ3A8gCIAQgBSkAcCIQQiyINwP4AiAEIBBCGIhC//8/gzcD8AIgBCAQQgSIQv//P4M3A+gCIAQgEEIQhkKAgDyDIBFCMIiENwPgAiAEIAUpAHgiEEL//z+DNwOAAyAEIBBCKIhC//8/gzcDkAMgBCAQQhSIQv//P4M3A4gDIAQgBSkAgAEiEUIkiEL//z+DNwOoAyAEIBFCEIhC//8/gzcDoAMgBCARQgSGQvD/P4MgEEI8iIQ3A5gDIAQgBSkAiAEiEEIgiEL//z+DNwPAAyAEIBBCDIhC//8/gzcDuAMgBCAQQgiGQoD+P4MgEUI4iIQ3A7ADIAQgBSkAkAEiEUIciEL//z+DNwPYAyAEIBFCCIhC//8/gzcD0AMgBCARQgyGQoDgP4MgEEI0iIQ3A8gDIAQgBSkAmAEiEEIsiDcD+AMgBCAQQhiIQv//P4M3A/ADIAQgEEIEiEL//z+DNwPoAyAEIBBCEIZCgIA8gyARQjCIhDcD4AMMLQsgBkGnAU0EQAw1CyAEIAUpAAAiEEL///8AgzcDACAEIBBCKohC////AIM3AxAgBCAQQhWIQv///wCDNwMIIAQgBSkACCIRQimIQv///wCDNwMoIAQgEUIUiEL///8AgzcDICAEIAUpABAiEkIoiEL///8AgzcDQCAEIBJCE4hC////AIM3AzggBCAFKQAYIhNCJ4hC////AIM3A1ggBCATQhKIQv///wCDNwNQIAQgBSkAICIUQiaIQv///wCDNwNwIAQgFEIRiEL///8AgzcDaCAEIBFCAYZC/v//AIMgEEI/iIQ3AxggBCASQgKGQvz//wCDIBFCPoiENwMwIAQgE0IDhkL4//8AgyASQj2IhDcDSCAEIBRCBIZC8P//AIMgE0I8iIQ3A2AgBCAFKQAoIhBCJYhC////AIM3A4gBIAQgEEIQiEL///8AgzcDgAEgBCAFKQAwIhFCJIhC////AIM3A6ABIAQgEUIPiEL///8AgzcDmAEgBCAFKQA4IhJCI4hC////AIM3A7gBIAQgEkIOiEL///8AgzcDsAEgBCAFKQBAIhNCIohC////AIM3A9ABIAQgE0INiEL///8AgzcDyAEgBCAFKQBIIhVCIYhC////AIM3A+gBIAQgFUIMiEL///8AgzcD4AEgBCAQQgWGQuD//wCDIBRCO4iENwN4IAQgEUIGhkLA//8AgyAQQjqIhDcDkAEgBCASQgeGQoD//wCDIBFCOYiENwOoASAEIBNCCIZCgP7/AIMgEkI4iIQ3A8ABIAQgFUIJhkKA/P8AgyATQjeIhDcD2AEgBCAFKQBQIhBCIIhC////AIM3A4ACIAQgEEILiEL///8AgzcD+AEgBCAQQgqGQoD4/wCDIBVCNoiENwPwASAEIAUpAFgiEUIfiEL///8AgzcDmAIgBCARQgqIQv///wCDNwOQAiAEIBFCC4ZCgPD/AIMgEEI1iIQ3A4gCIAQgBSkAYCIQQh6IQv///wCDNwOwAiAEIBBCCYhC////AIM3A6gCIAQgEEIMhkKA4P8AgyARQjSIhDcDoAIgBCAFKQBoIhFCHYhC////AIM3A8gCIAQgEUIIiEL///8AgzcDwAIgBCARQg2GQoDA/wCDIBBCM4iENwO4AiAEIAUpAHAiEEIciEL///8AgzcD4AIgBCAQQgeIQv///wCDNwPYAiAEIBBCDoZCgID/AIMgEUIyiIQ3A9ACIAQgBSkAeCIRQhuIQv///wCDNwP4AiAEIBFCBohC////AIM3A/ACIAQgEUIPhkKAgP4AgyAQQjGIhDcD6AIgBCAFKQCAASIQQhqIQv///wCDNwOQAyAEIBBCBYhC////AIM3A4gDIAQgEEIQhkKAgPwAgyARQjCIhDcDgAMgBCAFKQCIASIRQhmIQv///wCDNwOoAyAEIBFCBIhC////AIM3A6ADIAQgEUIRhkKAgPgAgyAQQi+IhDcDmAMgBCAFKQCQASIQQhiIQv///wCDNwPAAyAEIBBCA4hC////AIM3A7gDIAQgEEIShkKAgPAAgyARQi6IhDcDsAMgBCAFKQCYASIRQheIQv///wCDNwPYAyAEIBFCAohC////AIM3A9ADIAQgEUIThkKAgOAAgyAQQi2IhDcDyAMgBCAFKQCgASIQQiuINwP4AyAEIBBCFohC////AIM3A/ADIAQgEEIBiEL///8AgzcD6AMgBCAQQhSGQoCAwACDIBFCLIiENwPgAwwsCyAGQa8BTQRADDQLIAQgBSkAACIUQv///wGDNwMAIAQgFEIWiEL///8BgzcDCCAEIAUpAAgiEEIYiEL///8BgzcDICAEIBBCAohC////AYM3AxggBCAFKQAQIhFCGohC////AYM3AzggBCARQgSIQv///wGDNwMwIAQgBSkAGCISQhyIQv///wGDNwNQIAQgEkIGiEL///8BgzcDSCAEIAUpACAiE0IeiEL///8BgzcDaCAEIBNCCIhC////AYM3A2AgBCAQQhSGQoCAwAGDIBRCLIiENwMQIAQgEUIShkKAgPABgyAQQi6IhDcDKCAEIBJCEIZCgID8AYMgEUIwiIQ3A0AgBCATQg6GQoCA/wGDIBJCMoiENwNYIAQgBSkAKCIQQiCIQv///wGDNwOAASAEIBBCCohC////AYM3A3ggBCAFKQAwIhFCIohC////AYM3A5gBIAQgEUIMiEL///8BgzcDkAEgBCAFKQA4IhJCJIhC////AYM3A7ABIAQgEkIOiEL///8BgzcDqAEgBCAFKQBAIhRCJohC////AYM3A8gBIAQgFEIQiEL///8BgzcDwAEgBCAFKQBIIhVCKIhC////AYM3A+ABIAQgFUISiEL///8BgzcD2AEgBCAQQgyGQoDg/wGDIBNCNIiENwNwIAQgEUIKhkKA+P8BgyAQQjaIhDcDiAEgBCASQgiGQoD+/wGDIBFCOIiENwOgASAEIBRCBoZCwP//AYMgEkI6iIQ3A7gBIAQgFUIEhkLw//8BgyAUQjyIhDcD0AEgBCAFKQBQIhBCKog3A/gBIAQgEEIUiEL///8BgzcD8AEgBCAQQgKGQvz//wGDIBVCPoiENwPoASAEIAUpAFgiEUL///8BgzcDgAIgBCARQhaIQv///wGDNwOIAiAEIAUpAGAiEEIYiEL///8BgzcDoAIgBCAQQgKIQv///wGDNwOYAiAEIBBCFIZCgIDAAYMgEUIsiIQ3A5ACIAQgBSkAaCIRQhqIQv///wGDNwO4AiAEIBFCBIhC////AYM3A7ACIAQgEUIShkKAgPABgyAQQi6IhDcDqAIgBCAFKQBwIhBCHIhC////AYM3A9ACIAQgEEIGiEL///8BgzcDyAIgBCAQQhCGQoCA/AGDIBFCMIiENwPAAiAEIAUpAHgiEUIeiEL///8BgzcD6AIgBCARQgiIQv///wGDNwPgAiAEIBFCDoZCgID/AYMgEEIyiIQ3A9gCIAQgBSkAgAEiEEIgiEL///8BgzcDgAMgBCAQQgqIQv///wGDNwP4AiAEIBBCDIZCgOD/AYMgEUI0iIQ3A/ACIAQgBSkAiAEiEUIiiEL///8BgzcDmAMgBCARQgyIQv///wGDNwOQAyAEIBFCCoZCgPj/AYMgEEI2iIQ3A4gDIAQgBSkAkAEiEEIkiEL///8BgzcDsAMgBCAQQg6IQv///wGDNwOoAyAEIBBCCIZCgP7/AYMgEUI4iIQ3A6ADIAQgBSkAmAEiEUImiEL///8BgzcDyAMgBCARQhCIQv///wGDNwPAAyAEIBFCBoZCwP//AYMgEEI6iIQ3A7gDIAQgBSkAoAEiEEIoiEL///8BgzcD4AMgBCAQQhKIQv///wGDNwPYAyAEIBBCBIZC8P//AYMgEUI8iIQ3A9ADIAQgBSkAqAEiEUIqiDcD+AMgBCARQhSIQv///wGDNwPwAyAEIBFCAoZC/P//AYMgEEI+iIQ3A+gDDCsLIAZBtwFNBEAMMwsgBCAFKQAAIhNC////A4M3AwAgBCATQheIQv///wODNwMIIAQgBSkACCIQQhyIQv///wODNwMgIAQgEEIFiEL///8DgzcDGCAEIAUpABAiEUIhiEL///8DgzcDOCAEIBFCCohC////A4M3AzAgBCAFKQAYIhJCJohC////A4M3A1AgBCASQg+IQv///wODNwNIIAQgBSkAICIUQhSIQv///wODNwNgIAQgEEIShkKAgPADgyATQi6IhDcDECAEIBFCDYZCgMD/A4MgEEIziIQ3AyggBCASQgiGQoD+/wODIBFCOIiENwNAIAQgFEIDhkL4//8DgyASQj2IhDcDWCAEIAUpACgiEEIZiEL///8DgzcDeCAEIBBCAohC////A4M3A3AgBCAQQhWGQoCAgAODIBRCK4iENwNoIAQgBSkAMCIRQh6IQv///wODNwOQASAEIBFCB4hC////A4M3A4gBIAQgBSkAOCISQiOIQv///wODNwOoASAEIBJCDIhC////A4M3A6ABIAQgBSkAQCITQiiIQv///wODNwPAASAEIBNCEYhC////A4M3A7gBIAQgBSkASCIUQhaIQv///wODNwPQASAEIBFCEIZCgID8A4MgEEIwiIQ3A4ABIAQgEkILhkKA8P8DgyARQjWIhDcDmAEgBCATQgaGQsD//wODIBJCOoiENwOwASAEIBRCAYZC/v//A4MgE0I/iIQ3A8gBIAQgBSkAUCIQQhuIQv///wODNwPoASAEIBBCBIhC////A4M3A+ABIAQgEEIThkKAgOADgyAUQi2IhDcD2AEgBCAFKQBYIhFCIIhC////A4M3A4ACIAQgEUIJiEL///8DgzcD+AEgBCARQg6GQoCA/wODIBBCMoiENwPwASAEIAUpAGAiEEIliEL///8DgzcDmAIgBCAQQg6IQv///wODNwOQAiAEIBBCCYZCgPz/A4MgEUI3iIQ3A4gCIAQgBSkAaCIRQhOIQv///wODNwOoAiAEIBFCBIZC8P//A4MgEEI8iIQ3A6ACIAQgBSkAcCIQQhiIQv///wODNwPAAiAEIBBCAYhC////A4M3A7gCIAQgEEIWhkKAgIACgyARQiqIhDcDsAIgBCAFKQB4IhFCHYhC////A4M3A9gCIAQgEUIGiEL///8DgzcD0AIgBCARQhGGQoCA+AODIBBCL4iENwPIAiAEIAUpAIABIhBCIohC////A4M3A/ACIAQgEEILiEL///8DgzcD6AIgBCAQQgyGQoDg/wODIBFCNIiENwPgAiAEIAUpAIgBIhFCJ4hC////A4M3A4gDIAQgEUIQiEL///8DgzcDgAMgBCARQgeGQoD//wODIBBCOYiENwP4AiAEIAUpAJABIhJCFYhC////A4M3A5gDIAQgEkIChkL8//8DgyARQj6IhDcDkAMgBCAFKQCYASIQQhqIQv///wODNwOwAyAEIBBCA4hC////A4M3A6gDIAQgEEIUhkKAgMADgyASQiyIhDcDoAMgBCAFKQCgASIRQh+IQv///wODNwPIAyAEIBFCCIhC////A4M3A8ADIAQgEUIPhkKAgP4DgyAQQjGIhDcDuAMgBCAFKQCoASIQQiSIQv///wODNwPgAyAEIBBCDYhC////A4M3A9gDIAQgEEIKhkKA+P8DgyARQjaIhDcD0AMgBCAFKQCwASIRQimINwP4AyAEIBFCEohC////A4M3A/ADIAQgEUIFhkLg//8DgyAQQjuIhDcD6AMMKgsgBkG/AU0EQAwyCyAEIAUpAAAiEkL///8HgzcDACAEIAUpABAiE0IoiDcDOCAEIAUpABgiFEL///8HgzcDQCAEIBJCGIhC////B4M3AwggBCAFKQAIIhBCIIhC////B4M3AyAgBCAQQgiIQv///weDNwMYIAQgE0IQiEL///8HgzcDMCAEIBRCGIhC////B4M3A0ggBCAFKQAgIhFCIIhC////B4M3A2AgBCARQgiIQv///weDNwNYIAQgEEIQhkKAgPwHgyASQjCIhDcDECAEIBNCCIZCgP7/B4MgEEI4iIQ3AyggBCARQhCGQoCA/AeDIBRCMIiENwNQIAQgBSkAKCIQQiiINwN4IAQgEEIQiEL///8HgzcDcCAEIBBCCIZCgP7/B4MgEUI4iIQ3A2ggBCAFKQAwIhFC////B4M3A4ABIAQgBSkAQCISQiiINwO4ASAEIAUpAEgiE0L///8HgzcDwAEgBCARQhiIQv///weDNwOIASAEIAUpADgiEEIgiEL///8HgzcDoAEgBCAQQgiIQv///weDNwOYASAEIBJCEIhC////B4M3A7ABIAQgE0IYiEL///8HgzcDyAEgBCAQQhCGQoCA/AeDIBFCMIiENwOQASAEIBJCCIZCgP7/B4MgEEI4iIQ3A6gBIAQgBSkAUCIQQiCIQv///weDNwPgASAEIBBCCIhC////B4M3A9gBIAQgEEIQhkKAgPwHgyATQjCIhDcD0AEgBCAFKQBYIhFCKIg3A/gBIAQgEUIQiEL///8HgzcD8AEgBCARQgiGQoD+/weDIBBCOIiENwPoASAEIAUpAGAiEUL///8HgzcDgAIgBCARQhiIQv///weDNwOIAiAEIAUpAGgiEEIgiEL///8HgzcDoAIgBCAQQgiIQv///weDNwOYAiAEIBBCEIZCgID8B4MgEUIwiIQ3A5ACIAQgBSkAcCIRQiiINwO4AiAEIBFCEIhC////B4M3A7ACIAQgEUIIhkKA/v8HgyAQQjiIhDcDqAIgBCAFKQB4IhFC////B4M3A8ACIAQgEUIYiEL///8HgzcDyAIgBCAFKQCAASIQQiCIQv///weDNwPgAiAEIBBCCIhC////B4M3A9gCIAQgEEIQhkKAgPwHgyARQjCIhDcD0AIgBCAFKQCIASIRQiiINwP4AiAEIBFCEIhC////B4M3A/ACIAQgEUIIhkKA/v8HgyAQQjiIhDcD6AIgBCAFKQCQASIRQv///weDNwOAAyAEIBFCGIhC////B4M3A4gDIAQgBSkAmAEiEEIgiEL///8HgzcDoAMgBCAQQgiIQv///weDNwOYAyAEIBBCEIZCgID8B4MgEUIwiIQ3A5ADIAQgBSkAoAEiEUIoiDcDuAMgBCARQhCIQv///weDNwOwAyAEIBFCCIZCgP7/B4MgEEI4iIQ3A6gDIAQgBSkAqAEiEUL///8HgzcDwAMgBCARQhiIQv///weDNwPIAyAEIAUpALABIhBCIIhC////B4M3A+ADIAQgEEIIiEL///8HgzcD2AMgBCAQQhCGQoCA/AeDIBFCMIiENwPQAyAEIAUpALgBIhFCKIg3A/gDIAQgEUIQiEL///8HgzcD8AMgBCARQgiGQoD+/weDIBBCOIiENwPoAwwpCyAGQccBTQRADDELIAQgBSkAACITQv///w+DNwMAIAQgE0IZiEL///8PgzcDCCAEIAUpAAgiEEIkiEL///8PgzcDICAEIBBCC4hC////D4M3AxggBCAFKQAQIhRCFohC////D4M3AzAgBCAFKQAYIhFCIYhC////D4M3A0ggBCARQgiIQv///w+DNwNAIAQgBSkAICIVQhOIQv///w+DNwNYIAQgBSkAKCISQh6IQv///w+DNwNwIAQgEkIFiEL///8PgzcDaCAEIBBCDoZCgID/D4MgE0IyiIQ3AxAgBCAUQgOGQvj//w+DIBBCPYiENwMoIAQgEUIRhkKAgPgPgyAUQi+IhDcDOCAEIBVCBoZCwP//D4MgEUI6iIQ3A1AgBCASQhSGQoCAwA+DIBVCLIiENwNgIAQgBSkAMCIUQhCIQv///w+DNwOAASAEIAUpADgiEEIbiEL///8PgzcDmAEgBCAQQgKIQv///w+DNwOQASAEIAUpAEAiEUImiEL///8PgzcDsAEgBCARQg2IQv///w+DNwOoASAEIAUpAEgiFUIYiEL///8PgzcDwAEgBCAFKQBQIhNCI4hC////D4M3A9gBIAQgE0IKiEL///8PgzcD0AEgBCAUQgmGQoD8/w+DIBJCN4iENwN4IAQgEEIXhkKAgIAMgyAUQimIhDcDiAEgBCARQgyGQoDg/w+DIBBCNIiENwOgASAEIBVCAYZC/v//D4MgEUI/iIQ3A7gBIAQgE0IPhkKAgP4PgyAVQjGIhDcDyAEgBCAFKQBYIhFCFYhC////D4M3A+gBIAQgEUIEhkLw//8PgyATQjyIhDcD4AEgBCAFKQBgIhBCIIhC////D4M3A4ACIAQgEEIHiEL///8PgzcD+AEgBCAQQhKGQoCA8A+DIBFCLoiENwPwASAEIAUpAGgiEUISiEL///8PgzcDkAIgBCARQgeGQoD//w+DIBBCOYiENwOIAiAEIAUpAHAiEEIdiEL///8PgzcDqAIgBCAQQgSIQv///w+DNwOgAiAEIBBCFYZCgICAD4MgEUIriIQ3A5gCIAQgBSkAeCIRQg+IQv///w+DNwO4AiAEIBFCCoZCgPj/D4MgEEI2iIQ3A7ACIAQgBSkAgAEiEEIaiEL///8PgzcD0AIgBCAQQgGIQv///w+DNwPIAiAEIBBCGIZCgICACIMgEUIoiIQ3A8ACIAQgBSkAiAEiEUIliEL///8PgzcD6AIgBCARQgyIQv///w+DNwPgAiAEIBFCDYZCgMD/D4MgEEIziIQ3A9gCIAQgBSkAkAEiEkIXiEL///8PgzcD+AIgBCASQgKGQvz//w+DIBFCPoiENwPwAiAEIAUpAJgBIhBCIohC////D4M3A5ADIAQgEEIJiEL///8PgzcDiAMgBCAQQhCGQoCA/A+DIBJCMIiENwOAAyAEIAUpAKABIhFCFIhC////D4M3A6ADIAQgEUIFhkLg//8PgyAQQjuIhDcDmAMgBCAFKQCoASIQQh+IQv///w+DNwO4AyAEIBBCBohC////D4M3A7ADIAQgEEIThkKAgOAPgyARQi2IhDcDqAMgBCAFKQCwASIRQhGIQv///w+DNwPIAyAEIBFCCIZCgP7/D4MgEEI4iIQ3A8ADIAQgBSkAuAEiEEIciEL///8PgzcD4AMgBCAQQgOIQv///w+DNwPYAyAEIBBCFoZCgICADoMgEUIqiIQ3A9ADIAQgBSkAwAEiEUIniDcD+AMgBCARQg6IQv///w+DNwPwAyAEIBFCC4ZCgPD/D4MgEEI1iIQ3A+gDDCgLIAZBzwFNBEAMMAsgBCAFKQAAIhJC////H4M3AwAgBCASQhqIQv///x+DNwMIIAQgBSkACCITQg6IQv///x+DNwMYIAQgBSkAECIQQhyIQv///x+DNwMwIAQgEEICiEL///8fgzcDKCAEIAUpABgiFEIQiEL///8fgzcDQCAEIAUpACAiEUIeiEL///8fgzcDWCAEIBFCBIhC////H4M3A1AgBCAFKQAoIhVCEohC////H4M3A2ggBCATQgyGQoDg/x+DIBJCNIiENwMQIAQgEEIYhkKAgIAYgyATQiiIhDcDICAEIBRCCoZCgPj/H4MgEEI2iIQ3AzggBCARQhaGQoCAgB6DIBRCKoiENwNIIAQgFUIIhkKA/v8fgyARQjiIhDcDYCAEIAUpADAiEEIgiEL///8fgzcDgAEgBCAQQgaIQv///x+DNwN4IAQgBSkAOCITQhSIQv///x+DNwOQASAEIAUpAEAiEUIiiEL///8fgzcDqAEgBCARQgiIQv///x+DNwOgASAEIAUpAEgiFEIWiEL///8fgzcDuAEgBCAFKQBQIhJCJIhC////H4M3A9ABIAQgEkIKiEL///8fgzcDyAEgBCAQQhSGQoCAwB+DIBVCLIiENwNwIAQgE0IGhkLA//8fgyAQQjqIhDcDiAEgBCARQhKGQoCA8B+DIBNCLoiENwOYASAEIBRCBIZC8P//H4MgEUI8iIQ3A7ABIAQgEkIQhkKAgPwfgyAUQjCIhDcDwAEgBCAFKQBYIhBCGIhC////H4M3A+ABIAQgEEIChkL8//8fgyASQj6IhDcD2AEgBCAFKQBgIhFCJog3A/gBIAQgEUIMiEL///8fgzcD8AEgBCARQg6GQoCA/x+DIBBCMoiENwPoASAEIAUpAGgiEEL///8fgzcDgAIgBCAQQhqIQv///x+DNwOIAiAEIAUpAHAiEUIOiEL///8fgzcDmAIgBCARQgyGQoDg/x+DIBBCNIiENwOQAiAEIAUpAHgiEEIciEL///8fgzcDsAIgBCAQQgKIQv///x+DNwOoAiAEIBBCGIZCgICAGIMgEUIoiIQ3A6ACIAQgBSkAgAEiEUIQiEL///8fgzcDwAIgBCARQgqGQoD4/x+DIBBCNoiENwO4AiAEIAUpAIgBIhBCHohC////H4M3A9gCIAQgEEIEiEL///8fgzcD0AIgBCAQQhaGQoCAgB6DIBFCKoiENwPIAiAEIAUpAJABIhFCEohC////H4M3A+gCIAQgEUIIhkKA/v8fgyAQQjiIhDcD4AIgBCAFKQCYASIQQiCIQv///x+DNwOAAyAEIBBCBohC////H4M3A/gCIAQgEEIUhkKAgMAfgyARQiyIhDcD8AIgBCAFKQCgASIRQhSIQv///x+DNwOQAyAEIBFCBoZCwP//H4MgEEI6iIQ3A4gDIAQgBSkAqAEiEEIiiEL///8fgzcDqAMgBCAQQgiIQv///x+DNwOgAyAEIBBCEoZCgIDwH4MgEUIuiIQ3A5gDIAQgBSkAsAEiEUIWiEL///8fgzcDuAMgBCARQgSGQvD//x+DIBBCPIiENwOwAyAEIAUpALgBIhBCJIhC////H4M3A9ADIAQgEEIKiEL///8fgzcDyAMgBCAQQhCGQoCA/B+DIBFCMIiENwPAAyAEIAUpAMABIhFCGIhC////H4M3A+ADIAQgEUIChkL8//8fgyAQQj6IhDcD2AMgBCAFKQDIASIQQiaINwP4AyAEIBBCDIhC////H4M3A/ADIAQgEEIOhkKAgP8fgyARQjKIhDcD6AMMJwsgBkHXAU0EQAwvCyAEIAUpAAAiEkL///8/gzcDACAEIBJCG4hC////P4M3AwggBCAFKQAIIhNCEYhC////P4M3AxggBCAFKQAQIhBCIohC////P4M3AzAgBCAQQgeIQv///z+DNwMoIAQgBSkAGCIUQhiIQv///z+DNwNAIAQgBSkAICIVQg6IQv///z+DNwNQIAQgBSkAKCIRQh+IQv///z+DNwNoIAQgEUIEiEL///8/gzcDYCAEIBNCCoZCgPj/P4MgEkI2iIQ3AxAgBCAQQhSGQoCAwD+DIBNCLIiENwMgIAQgFEIDhkL4//8/gyAQQj2IhDcDOCAEIBVCDYZCgMD/P4MgFEIziIQ3A0ggBCARQheGQoCAgDyDIBVCKYiENwNYIAQgBSkAMCITQhWIQv///z+DNwN4IAQgBSkAOCIUQguIQv///z+DNwOIASAEIAUpAEAiEEIciEL///8/gzcDoAEgBCAQQgGIQv///z+DNwOYASAEIAUpAEgiFUISiEL///8/gzcDsAEgBCAFKQBQIhJCI4hC////P4M3A8gBIAQgEkIIiEL///8/gzcDwAEgBCATQgaGQsD//z+DIBFCOoiENwNwIAQgFEIQhkKAgPw/gyATQjCIhDcDgAEgBCAQQhqGQoCAgCCDIBRCJoiENwOQASAEIBVCCYZCgPz/P4MgEEI3iIQ3A6gBIAQgEkIThkKAgOA/gyAVQi2IhDcDuAEgBCAFKQBYIhBCGYhC////P4M3A9gBIAQgEEIChkL8//8/gyASQj6IhDcD0AEgBCAFKQBgIhFCD4hC////P4M3A+gBIAQgEUIMhkKA4P8/gyAQQjSIhDcD4AEgBCAFKQBoIhBCIIhC////P4M3A4ACIAQgEEIFiEL///8/gzcD+AEgBCAQQhaGQoCAgD6DIBFCKoiENwPwASAEIAUpAHAiEUIWiEL///8/gzcDkAIgBCARQgWGQuD//z+DIBBCO4iENwOIAiAEIAUpAHgiEkIMiEL///8/gzcDoAIgBCASQg+GQoCA/j+DIBFCMYiENwOYAiAEIAUpAIABIhBCHYhC////P4M3A7gCIAQgEEICiEL///8/gzcDsAIgBCAQQhmGQoCAgDCDIBJCJ4iENwOoAiAEIAUpAIgBIhFCE4hC////P4M3A8gCIAQgEUIIhkKA/v8/gyAQQjiIhDcDwAIgBCAFKQCQASIQQiSIQv///z+DNwPgAiAEIBBCCYhC////P4M3A9gCIAQgEEIShkKAgPA/gyARQi6IhDcD0AIgBCAFKQCYASIRQhqIQv///z+DNwPwAiAEIBFCAYZC/v//P4MgEEI/iIQ3A+gCIAQgBSkAoAEiEkIQiEL///8/gzcDgAMgBCASQguGQoDw/z+DIBFCNYiENwP4AiAEIAUpAKgBIhBCIYhC////P4M3A5gDIAQgEEIGiEL///8/gzcDkAMgBCAQQhWGQoCAgD+DIBJCK4iENwOIAyAEIAUpALABIhFCF4hC////P4M3A6gDIAQgEUIEhkLw//8/gyAQQjyIhDcDoAMgBCAFKQC4ASISQg2IQv///z+DNwO4AyAEIBJCDoZCgID/P4MgEUIyiIQ3A7ADIAQgBSkAwAEiEEIeiEL///8/gzcD0AMgBCAQQgOIQv///z+DNwPIAyAEIBBCGIZCgICAOIMgEkIoiIQ3A8ADIAQgBSkAyAEiEUIUiEL///8/gzcD4AMgBCARQgeGQoD//z+DIBBCOYiENwPYAyAEIAUpANABIhBCJYg3A/gDIAQgEEIKiEL///8/gzcD8AMgBCAQQhGGQoCA+D+DIBFCL4iENwPoAwwmCyAGQd8BTQRADC4LIAQgBSkAACIRQv////8AgzcDACAEIBFCHIhC/////wCDNwMIIAQgBSkACCISQhSIQv////8AgzcDGCAEIAUpABAiE0IMiEL/////AIM3AyggBCAFKQAYIhBCIIhC/////wCDNwNAIAQgEEIEiEL/////AIM3AzggBCAFKQAgIhRCGIhC/////wCDNwNQIAQgBSkAKCIVQhCIQv////8AgzcDYCAEIBJCCIZCgP7//wCDIBFCOIiENwMQIAQgE0IQhkKAgPz/AIMgEkIwiIQ3AyAgBCAQQhiGQoCAgPgAgyATQiiIhDcDMCAEIBRCBIZC8P///wCDIBBCPIiENwNIIAQgFUIMhkKA4P//AIMgFEI0iIQ3A1ggBCAFKQAwIhFCJIg3A3ggBCAFKQA4IhJC/////wCDNwOAASAEIBFCCIhC/////wCDNwNwIAQgEkIciEL/////AIM3A4gBIAQgBSkAQCITQhSIQv////8AgzcDmAEgBCAFKQBIIhRCDIhC/////wCDNwOoASAEIAUpAFAiEEIgiEL/////AIM3A8ABIAQgEEIEiEL/////AIM3A7gBIAQgEUIUhkKAgMD/AIMgFUIsiIQ3A2ggBCATQgiGQoD+//8AgyASQjiIhDcDkAEgBCAUQhCGQoCA/P8AgyATQjCIhDcDoAEgBCAQQhiGQoCAgPgAgyAUQiiIhDcDsAEgBCAFKQBYIhFCGIhC/////wCDNwPQASAEIBFCBIZC8P///wCDIBBCPIiENwPIASAEIAUpAGAiEEIQiEL/////AIM3A+ABIAQgEEIMhkKA4P//AIMgEUI0iIQ3A9gBIAQgBSkAaCIRQiSINwP4ASAEIBFCCIhC/////wCDNwPwASAEIBFCFIZCgIDA/wCDIBBCLIiENwPoASAEIAUpAHAiEEL/////AIM3A4ACIAQgEEIciEL/////AIM3A4gCIAQgBSkAeCIRQhSIQv////8AgzcDmAIgBCARQgiGQoD+//8AgyAQQjiIhDcDkAIgBCAFKQCAASISQgyIQv////8AgzcDqAIgBCASQhCGQoCA/P8AgyARQjCIhDcDoAIgBCAFKQCIASIQQiCIQv////8AgzcDwAIgBCAQQgSIQv////8AgzcDuAIgBCAQQhiGQoCAgPgAgyASQiiIhDcDsAIgBCAFKQCQASIRQhiIQv////8AgzcD0AIgBCARQgSGQvD///8AgyAQQjyIhDcDyAIgBCAFKQCYASIQQhCIQv////8AgzcD4AIgBCAQQgyGQoDg//8AgyARQjSIhDcD2AIgBCAFKQCgASIRQiSINwP4AiAEIBFCCIhC/////wCDNwPwAiAEIBFCFIZCgIDA/wCDIBBCLIiENwPoAiAEIAUpAKgBIhBC/////wCDNwOAAyAEIBBCHIhC/////wCDNwOIAyAEIAUpALABIhFCFIhC/////wCDNwOYAyAEIBFCCIZCgP7//wCDIBBCOIiENwOQAyAEIAUpALgBIhJCDIhC/////wCDNwOoAyAEIBJCEIZCgID8/wCDIBFCMIiENwOgAyAEIAUpAMABIhBCIIhC/////wCDNwPAAyAEIBBCBIhC/////wCDNwO4AyAEIBBCGIZCgICA+ACDIBJCKIiENwOwAyAEIAUpAMgBIhFCGIhC/////wCDNwPQAyAEIBFCBIZC8P///wCDIBBCPIiENwPIAyAEIAUpANABIhBCEIhC/////wCDNwPgAyAEIBBCDIZCgOD//wCDIBFCNIiENwPYAyAEIAUpANgBIhFCJIg3A/gDIAQgEUIIiEL/////AIM3A/ADIAQgEUIUhkKAgMD/AIMgEEIsiIQ3A+gDDCULIAZB5wFNBEAMLQsgBCAFKQAAIhFC/////wGDNwMAIAQgEUIdiEL/////AYM3AwggBCAFKQAIIhJCF4hC/////wGDNwMYIAQgBSkAECITQhGIQv////8BgzcDKCAEIAUpABgiFEILiEL/////AYM3AzggBCAFKQAgIhBCIohC/////wGDNwNQIAQgEEIFiEL/////AYM3A0ggBCAFKQAoIhVCHIhC/////wGDNwNgIAQgEkIGhkLA////AYMgEUI6iIQ3AxAgBCATQgyGQoDg//8BgyASQjSIhDcDICAEIBRCEoZCgIDw/wGDIBNCLoiENwMwIAQgEEIYhkKAgID4AYMgFEIoiIQ3A0AgBCAVQgGGQv7///8BgyAQQj+IhDcDWCAEIAUpADAiEUIWiEL/////AYM3A3AgBCAFKQA4IhJCEIhC/////wGDNwOAASAEIAUpAEAiE0IKiEL/////AYM3A5ABIAQgBSkASCIQQiGIQv////8BgzcDqAEgBCAQQgSIQv////8BgzcDoAEgBCAFKQBQIhRCG4hC/////wGDNwO4ASAEIAUpAFgiFkIViEL/////AYM3A8gBIAQgEUIHhkKA////AYMgFUI5iIQ3A2ggBCASQg2GQoDA//8BgyARQjOIhDcDeCAEIBNCE4ZCgIDg/wGDIBJCLYiENwOIASAEIBBCGYZCgICA8AGDIBNCJ4iENwOYASAEIBRCAoZC/P///wGDIBBCPoiENwOwASAEIBZCCIZCgP7//wGDIBRCOIiENwPAASAEIAUpAGAiEEIPiEL/////AYM3A9gBIAQgEEIOhkKAgP//AYMgFkIyiIQ3A9ABIAQgBSkAaCIRQgmIQv////8BgzcD6AEgBCARQhSGQoCAwP8BgyAQQiyIhDcD4AEgBCAFKQBwIhBCIIhC/////wGDNwOAAiAEIBBCA4hC/////wGDNwP4ASAEIBBCGoZCgICA4AGDIBFCJoiENwPwASAEIAUpAHgiEUIaiEL/////AYM3A5ACIAQgEUIDhkL4////AYMgEEI9iIQ3A4gCIAQgBSkAgAEiEEIUiEL/////AYM3A6ACIAQgEEIJhkKA/P//AYMgEUI3iIQ3A5gCIAQgBSkAiAEiEUIOiEL/////AYM3A7ACIAQgEUIPhkKAgP7/AYMgEEIxiIQ3A6gCIAQgBSkAkAEiEkIIiEL/////AYM3A8ACIAQgEkIVhkKAgID/AYMgEUIriIQ3A7gCIAQgBSkAmAEiEEIfiEL/////AYM3A9gCIAQgEEICiEL/////AYM3A9ACIAQgEEIbhkKAgIDAAYMgEkIliIQ3A8gCIAQgBSkAoAEiEUIZiEL/////AYM3A+gCIAQgEUIEhkLw////AYMgEEI8iIQ3A+ACIAQgBSkAqAEiEEITiEL/////AYM3A/gCIAQgEEIKhkKA+P//AYMgEUI2iIQ3A/ACIAQgBSkAsAEiEUINiEL/////AYM3A4gDIAQgEUIQhkKAgPz/AYMgEEIwiIQ3A4ADIAQgBSkAuAEiEkIHiEL/////AYM3A5gDIAQgEkIWhkKAgID+AYMgEUIqiIQ3A5ADIAQgBSkAwAEiEEIeiEL/////AYM3A7ADIAQgEEIBiEL/////AYM3A6gDIAQgEEIchkKAgICAAYMgEkIkiIQ3A6ADIAQgBSkAyAEiEUIYiEL/////AYM3A8ADIAQgEUIFhkLg////AYMgEEI7iIQ3A7gDIAQgBSkA0AEiEEISiEL/////AYM3A9ADIAQgEEILhkKA8P//AYMgEUI1iIQ3A8gDIAQgBSkA2AEiEUIMiEL/////AYM3A+ADIAQgEUIRhkKAgPj/AYMgEEIviIQ3A9gDIAQgBSkA4AEiEEIjiDcD+AMgBCAQQgaIQv////8BgzcD8AMgBCAQQheGQoCAgPwBgyARQimIhDcD6AMMJAsgBkHvAU0EQAwsCyAEIAUpAAAiEEL/////A4M3AwAgBCAQQh6IQv////8DgzcDCCAEIAUpAAgiEUIaiEL/////A4M3AxggBCAFKQAQIhJCFohC/////wODNwMoIAQgBSkAGCITQhKIQv////8DgzcDOCAEIAUpACAiFEIOiEL/////A4M3A0ggBCAFKQAoIhVCCohC/////wODNwNYIAQgEUIEhkLw////A4MgEEI8iIQ3AxAgBCASQgiGQoD+//8DgyARQjiIhDcDICAEIBNCDIZCgOD//wODIBJCNIiENwMwIAQgFEIQhkKAgPz/A4MgE0IwiIQ3A0AgBCAVQhSGQoCAwP8DgyAUQiyIhDcDUCAEIAUpADAiEUIGiEL/////A4M3A2ggBCARQhiGQoCAgPgDgyAVQiiIhDcDYCAEIAUpADgiEEIgiEL/////A4M3A4ABIAQgEEICiEL/////A4M3A3ggBCAFKQBAIhJCHIhC/////wODNwOQASAEIAUpAEgiE0IYiEL/////A4M3A6ABIAQgBSkAUCIUQhSIQv////8DgzcDsAEgBCAFKQBYIhVCEIhC/////wODNwPAASAEIBBCHIZCgICAgAODIBFCJIiENwNwIAQgEkIChkL8////A4MgEEI+iIQ3A4gBIAQgE0IGhkLA////A4MgEkI6iIQ3A5gBIAQgFEIKhkKA+P//A4MgE0I2iIQ3A6gBIAQgFUIOhkKAgP//A4MgFEIyiIQ3A7gBIAQgBSkAYCIQQgyIQv////8DgzcD0AEgBCAQQhKGQoCA8P8DgyAVQi6IhDcDyAEgBCAFKQBoIhFCCIhC/////wODNwPgASAEIBFCFoZCgICA/gODIBBCKoiENwPYASAEIAUpAHAiEEIiiDcD+AEgBCAQQgSIQv////8DgzcD8AEgBCAQQhqGQoCAgOADgyARQiaIhDcD6AEgBCAFKQB4IhBC/////wODNwOAAiAEIBBCHohC/////wODNwOIAiAEIAUpAIABIhFCGohC/////wODNwOYAiAEIBFCBIZC8P///wODIBBCPIiENwOQAiAEIAUpAIgBIhBCFohC/////wODNwOoAiAEIBBCCIZCgP7//wODIBFCOIiENwOgAiAEIAUpAJABIhFCEohC/////wODNwO4AiAEIBFCDIZCgOD//wODIBBCNIiENwOwAiAEIAUpAJgBIhBCDohC/////wODNwPIAiAEIBBCEIZCgID8/wODIBFCMIiENwPAAiAEIAUpAKABIhFCCohC/////wODNwPYAiAEIBFCFIZCgIDA/wODIBBCLIiENwPQAiAEIAUpAKgBIhJCBohC/////wODNwPoAiAEIBJCGIZCgICA+AODIBFCKIiENwPgAiAEIAUpALABIhBCIIhC/////wODNwOAAyAEIBBCAohC/////wODNwP4AiAEIBBCHIZCgICAgAODIBJCJIiENwPwAiAEIAUpALgBIhFCHIhC/////wODNwOQAyAEIBFCAoZC/P///wODIBBCPoiENwOIAyAEIAUpAMABIhBCGIhC/////wODNwOgAyAEIBBCBoZCwP///wODIBFCOoiENwOYAyAEIAUpAMgBIhFCFIhC/////wODNwOwAyAEIBFCCoZCgPj//wODIBBCNoiENwOoAyAEIAUpANABIhBCEIhC/////wODNwPAAyAEIBBCDoZCgID//wODIBFCMoiENwO4AyAEIAUpANgBIhFCDIhC/////wODNwPQAyAEIBFCEoZCgIDw/wODIBBCLoiENwPIAyAEIAUpAOABIhBCCIhC/////wODNwPgAyAEIBBCFoZCgICA/gODIBFCKoiENwPYAyAEIAUpAOgBIhFCIog3A/gDIAQgEUIEiEL/////A4M3A/ADIAQgEUIahkKAgIDgA4MgEEImiIQ3A+gDDCMLIAZB9wFNBEAMKwsgBCAFKQAAIhBC/////weDNwMAIAQgEEIfiEL/////B4M3AwggBCAFKQAIIhFCHYhC/////weDNwMYIAQgBSkAECISQhuIQv////8HgzcDKCAEIAUpABgiE0IZiEL/////B4M3AzggBCAFKQAgIhRCF4hC/////weDNwNIIAQgBSkAKCIVQhWIQv////8HgzcDWCAEIBFCAoZC/P///weDIBBCPoiENwMQIAQgEkIEhkLw////B4MgEUI8iIQ3AyAgBCATQgaGQsD///8HgyASQjqIhDcDMCAEIBRCCIZCgP7//weDIBNCOIiENwNAIAQgFUIKhkKA+P//B4MgFEI2iIQ3A1AgBCAFKQAwIhBCE4hC/////weDNwNoIAQgEEIMhkKA4P//B4MgFUI0iIQ3A2AgBCAFKQA4IhFCEYhC/////weDNwN4IAQgBSkAQCISQg+IQv////8HgzcDiAEgBCAFKQBIIhNCDYhC/////weDNwOYASAEIAUpAFAiFEILiEL/////B4M3A6gBIAQgBSkAWCIVQgmIQv////8HgzcDuAEgBCARQg6GQoCA//8HgyAQQjKIhDcDcCAEIBJCEIZCgID8/weDIBFCMIiENwOAASAEIBNCEoZCgIDw/weDIBJCLoiENwOQASAEIBRCFIZCgIDA/weDIBNCLIiENwOgASAEIBVCFoZCgICA/geDIBRCKoiENwOwASAEIAUpAGAiEEIHiEL/////B4M3A8gBIAQgEEIYhkKAgID4B4MgFUIoiIQ3A8ABIAQgBSkAaCIRQgWIQv////8HgzcD2AEgBCARQhqGQoCAgOAHgyAQQiaIhDcD0AEgBCAFKQBwIhJCA4hC/////weDNwPoASAEIBJCHIZCgICAgAeDIBFCJIiENwPgASAEIAUpAHgiEEIgiEL/////B4M3A4ACIAQgEEIBiEL/////B4M3A/gBIAQgEEIehkKAgICABIMgEkIiiIQ3A/ABIAQgBSkAgAEiEUIeiEL/////B4M3A5ACIAQgEUIBhkL+////B4MgEEI/iIQ3A4gCIAQgBSkAiAEiEEIciEL/////B4M3A6ACIAQgEEIDhkL4////B4MgEUI9iIQ3A5gCIAQgBSkAkAEiEUIaiEL/////B4M3A7ACIAQgEUIFhkLg////B4MgEEI7iIQ3A6gCIAQgBSkAmAEiEEIYiEL/////B4M3A8ACIAQgEEIHhkKA////B4MgEUI5iIQ3A7gCIAQgBSkAoAEiEUIWiEL/////B4M3A9ACIAQgEUIJhkKA/P//B4MgEEI3iIQ3A8gCIAQgBSkAqAEiEEIUiEL/////B4M3A+ACIAQgEEILhkKA8P//B4MgEUI1iIQ3A9gCIAQgBSkAsAEiEUISiEL/////B4M3A/ACIAQgEUINhkKAwP//B4MgEEIziIQ3A+gCIAQgBSkAuAEiEEIQiEL/////B4M3A4ADIAQgEEIPhkKAgP7/B4MgEUIxiIQ3A/gCIAQgBSkAwAEiEUIOiEL/////B4M3A5ADIAQgEUIRhkKAgPj/B4MgEEIviIQ3A4gDIAQgBSkAyAEiEEIMiEL/////B4M3A6ADIAQgEEIThkKAgOD/B4MgEUItiIQ3A5gDIAQgBSkA0AEiEUIKiEL/////B4M3A7ADIAQgEUIVhkKAgID/B4MgEEIriIQ3A6gDIAQgBSkA2AEiEEIIiEL/////B4M3A8ADIAQgEEIXhkKAgID8B4MgEUIpiIQ3A7gDIAQgBSkA4AEiEUIGiEL/////B4M3A9ADIAQgEUIZhkKAgIDwB4MgEEIniIQ3A8gDIAQgBSkA6AEiEEIEiEL/////B4M3A+ADIAQgEEIbhkKAgIDAB4MgEUIliIQ3A9gDIAQgBSkA8AEiEUIhiDcD+AMgBCARQgKIQv////8HgzcD8AMgBCARQh2GQoCAgIAGgyAQQiOIhDcD6AMMIgsgBkH/AU0EQAwqCyAEIAUpAAAiEEIgiDcDCCAEIBBC/////w+DNwMAIAQgBSkACCIQQiCINwMYIAQgEEL/////D4M3AxAgBCAFKQAQIhBCIIg3AyggBCAQQv////8PgzcDICAEIAUpABgiEEIgiDcDOCAEIBBC/////w+DNwMwIAQgBSkAICIQQiCINwNIIAQgEEL/////D4M3A0AgBCAFKQAoIhBCIIg3A1ggBCAQQv////8PgzcDUCAEIAUpADAiEEIgiDcDaCAEIBBC/////w+DNwNgIAQgBSkAOCIQQiCINwN4IAQgEEL/////D4M3A3AgBCAFKQBAIhBCIIg3A4gBIAQgEEL/////D4M3A4ABIAQgBSkASCIQQiCINwOYASAEIBBC/////w+DNwOQASAEIAUpAFAiEEIgiDcDqAEgBCAQQv////8PgzcDoAEgBCAFKQBYIhBC/////w+DNwOwASAEIBBCIIg3A7gBIAQgBSkAYCIQQiCINwPIASAEIBBC/////w+DNwPAASAEIAUpAGgiEEIgiDcD2AEgBCAQQv////8PgzcD0AEgBCAFKQBwIhBCIIg3A+gBIAQgEEL/////D4M3A+ABIAQgBSkAeCIQQiCINwP4ASAEIBBC/////w+DNwPwASAEIAUpAIABIhBCIIg3A4gCIAQgEEL/////D4M3A4ACIAQgBSkAiAEiEEIgiDcDmAIgBCAQQv////8PgzcDkAIgBCAFKQCQASIQQiCINwOoAiAEIBBC/////w+DNwOgAiAEIAUpAJgBIhBCIIg3A7gCIAQgEEL/////D4M3A7ACIAQgBSkAoAEiEEIgiDcDyAIgBCAQQv////8PgzcDwAIgBCAFKQCoASIQQiCINwPYAiAEIBBC/////w+DNwPQAiAEIAUpALABIhBCIIg3A+gCIAQgEEL/////D4M3A+ACIAQgBSkAuAEiEEIgiDcD+AIgBCAQQv////8PgzcD8AIgBCAFKQDAASIQQiCINwOIAyAEIBBC/////w+DNwOAAyAEIAUpAMgBIhBCIIg3A5gDIAQgEEL/////D4M3A5ADIAQgBSkA0AEiEEIgiDcDqAMgBCAQQv////8PgzcDoAMgBCAFKQDYASIQQiCINwO4AyAEIBBC/////w+DNwOwAyAEIAUpAOABIhBCIIg3A8gDIAQgEEL/////D4M3A8ADIAQgBSkA6AEiEEIgiDcD2AMgBCAQQv////8PgzcD0AMgBCAFKQDwASIQQiCINwPoAyAEIBBC/////w+DNwPgAyAEIAUpAPgBIhBCIIg3A/gDIAQgEEL/////D4M3A/ADDCELIAZBhwJNBEAMKQsgBCAFKQAAIhZC/////x+DNwMAIAQgBSkACCIQQgKIQv////8fgzcDECAEIAUpABAiEUIEiEL/////H4M3AyAgBCAFKQAYIhJCBohC/////x+DNwMwIAQgBSkAICITQgiIQv////8fgzcDQCAEIAUpACgiFEIKiEL/////H4M3A1AgBCAFKQAwIhVCDIhC/////x+DNwNgIAQgEEIfhkKAgICAGIMgFkIhiIQ3AwggBCARQh2GQoCAgIAegyAQQiOIhDcDGCAEIBJCG4ZCgICAwB+DIBFCJYiENwMoIAQgE0IZhkKAgIDwH4MgEkIniIQ3AzggBCAUQheGQoCAgPwfgyATQimIhDcDSCAEIBVCFYZCgICA/x+DIBRCK4iENwNYIAQgBSkAOCIQQg6IQv////8fgzcDcCAEIAUpAEAiEUIQiEL/////H4M3A4ABIAQgBSkASCISQhKIQv////8fgzcDkAEgBCAFKQBQIhNCFIhC/////x+DNwOgASAEIAUpAFgiFEIWiEL/////H4M3A7ABIAQgBSkAYCIWQhiIQv////8fgzcDwAEgBCAQQhOGQoCA4P8fgyAVQi2IhDcDaCAEIBFCEYZCgID4/x+DIBBCL4iENwN4IAQgEkIPhkKAgP7/H4MgEUIxiIQ3A4gBIAQgE0INhkKAwP//H4MgEkIziIQ3A5gBIAQgFEILhkKA8P//H4MgE0I1iIQ3A6gBIAQgFkIJhkKA/P//H4MgFEI3iIQ3A7gBIAQgBSkAaCIQQhqIQv////8fgzcD0AEgBCAQQgeGQoD///8fgyAWQjmIhDcDyAEgBCAFKQBwIhFCHIhC/////x+DNwPgASAEIBFCBYZC4P///x+DIBBCO4iENwPYASAEIAUpAHgiEEIeiEL/////H4M3A/ABIAQgEEIDhkL4////H4MgEUI9iIQ3A+gBIAQgBSkAgAEiEUIBhkL+////H4MgEEI/iIQ3A/gBIAQgBSkAiAEiEEIBiEL/////H4M3A4gCIAQgEEIghkKAgICAEIMgEUIgiIQ3A4ACIAQgBSkAkAEiEUIDiEL/////H4M3A5gCIAQgEUIehkKAgICAHIMgEEIiiIQ3A5ACIAQgBSkAmAEiEEIFiEL/////H4M3A6gCIAQgEEIchkKAgICAH4MgEUIkiIQ3A6ACIAQgBSkAoAEiEUIHiEL/////H4M3A7gCIAQgEUIahkKAgIDgH4MgEEImiIQ3A7ACIAQgBSkAqAEiEEIJiEL/////H4M3A8gCIAQgEEIYhkKAgID4H4MgEUIoiIQ3A8ACIAQgBSkAsAEiEUILiEL/////H4M3A9gCIAQgEUIWhkKAgID+H4MgEEIqiIQ3A9ACIAQgBSkAuAEiEEINiEL/////H4M3A+gCIAQgEEIUhkKAgMD/H4MgEUIsiIQ3A+ACIAQgBSkAwAEiEUIPiEL/////H4M3A/gCIAQgEUIShkKAgPD/H4MgEEIuiIQ3A/ACIAQgBSkAyAEiEEIRiEL/////H4M3A4gDIAQgEEIQhkKAgPz/H4MgEUIwiIQ3A4ADIAQgBSkA0AEiEUITiEL/////H4M3A5gDIAQgEUIOhkKAgP//H4MgEEIyiIQ3A5ADIAQgBSkA2AEiEEIViEL/////H4M3A6gDIAQgEEIMhkKA4P//H4MgEUI0iIQ3A6ADIAQgBSkA4AEiEUIXiEL/////H4M3A7gDIAQgEUIKhkKA+P//H4MgEEI2iIQ3A7ADIAQgBSkA6AEiEEIZiEL/////H4M3A8gDIAQgEEIIhkKA/v//H4MgEUI4iIQ3A8ADIAQgBSkA8AEiEUIbiEL/////H4M3A9gDIAQgEUIGhkLA////H4MgEEI6iIQ3A9ADIAQgBSkA+AEiEEIdiEL/////H4M3A+gDIAQgEEIEhkLw////H4MgEUI8iIQ3A+ADIAQgBSkAgAIiEUIfiDcD+AMgBCARQgKGQvz///8fgyAQQj6IhDcD8AMMIAsgBkGPAk0EQAwoCyAEIAUpAAAiFkL/////P4M3AwAgBCAFKQAIIhBCBIhC/////z+DNwMQIAQgBSkAECIRQgiIQv////8/gzcDICAEIAUpABgiEkIMiEL/////P4M3AzAgBCAFKQAgIhNCEIhC/////z+DNwNAIAQgBSkAKCIUQhSIQv////8/gzcDUCAEIAUpADAiFUIYiEL/////P4M3A2AgBCAQQh6GQoCAgIA8gyAWQiKIhDcDCCAEIBFCGoZCgICA4D+DIBBCJoiENwMYIAQgEkIWhkKAgID+P4MgEUIqiIQ3AyggBCATQhKGQoCA8P8/gyASQi6IhDcDOCAEIBRCDoZCgID//z+DIBNCMoiENwNIIAQgFUIKhkKA+P//P4MgFEI2iIQ3A1ggBCAFKQA4IhBCHIhC/////z+DNwNwIAQgBSkASCIRQgKIQv////8/gzcDiAEgBCAFKQBQIhJCBohC/////z+DNwOYASAEIAUpAFgiE0IKiEL/////P4M3A6gBIAQgBSkAYCIUQg6IQv////8/gzcDuAEgBCAQQgaGQsD///8/gyAVQjqIhDcDaCAEIAUpAEAiFUIChkL8////P4MgEEI+iIQ3A3ggBCARQiCGQoCAgIAwgyAVQiCIhDcDgAEgBCASQhyGQoCAgIA/gyARQiSIhDcDkAEgBCATQhiGQoCAgPg/gyASQiiIhDcDoAEgBCAUQhSGQoCAwP8/gyATQiyIhDcDsAEgBCAFKQBoIhBCEohC/////z+DNwPIASAEIBBCEIZCgID8/z+DIBRCMIiENwPAASAEIAUpAHAiEUIWiEL/////P4M3A9gBIAQgEUIMhkKA4P//P4MgEEI0iIQ3A9ABIAQgBSkAeCIQQhqIQv////8/gzcD6AEgBCAQQgiGQoD+//8/gyARQjiIhDcD4AEgBCAFKQCAASIRQh6INwP4ASAEIBFCBIZC8P///z+DIBBCPIiENwPwASAEIAUpAIgBIhFC/////z+DNwOAAiAEIAUpAJABIhBCBIhC/////z+DNwOQAiAEIBBCHoZCgICAgDyDIBFCIoiENwOIAiAEIAUpAJgBIhFCCIhC/////z+DNwOgAiAEIBFCGoZCgICA4D+DIBBCJoiENwOYAiAEIAUpAKABIhBCDIhC/////z+DNwOwAiAEIBBCFoZCgICA/j+DIBFCKoiENwOoAiAEIAUpAKgBIhFCEIhC/////z+DNwPAAiAEIBFCEoZCgIDw/z+DIBBCLoiENwO4AiAEIAUpALABIhBCFIhC/////z+DNwPQAiAEIBBCDoZCgID//z+DIBFCMoiENwPIAiAEIAUpALgBIhFCGIhC/////z+DNwPgAiAEIBFCCoZCgPj//z+DIBBCNoiENwPYAiAEIAUpAMABIhBCHIhC/////z+DNwPwAiAEIBBCBoZCwP///z+DIBFCOoiENwPoAiAEIAUpAMgBIhFCAoZC/P///z+DIBBCPoiENwP4AiAEIAUpANABIhBCAohC/////z+DNwOIAyAEIBBCIIZCgICAgDCDIBFCIIiENwOAAyAEIAUpANgBIhFCBohC/////z+DNwOYAyAEIBFCHIZCgICAgD+DIBBCJIiENwOQAyAEIAUpAOABIhBCCohC/////z+DNwOoAyAEIBBCGIZCgICA+D+DIBFCKIiENwOgAyAEIAUpAOgBIhFCDohC/////z+DNwO4AyAEIBFCFIZCgIDA/z+DIBBCLIiENwOwAyAEIAUpAPABIhBCEohC/////z+DNwPIAyAEIBBCEIZCgID8/z+DIBFCMIiENwPAAyAEIAUpAPgBIhFCFohC/////z+DNwPYAyAEIBFCDIZCgOD//z+DIBBCNIiENwPQAyAEIAUpAIACIhBCGohC/////z+DNwPoAyAEIBBCCIZCgP7//z+DIBFCOIiENwPgAyAEIAUpAIgCIhFCHog3A/gDIAQgEUIEhkLw////P4MgEEI8iIQ3A/ADDB8LIAZBlwJNBEAMJwsgBCAFKQAAIhVC//////8AgzcDACAEIAUpAAgiEEIGiEL//////wCDNwMQIAQgBSkAECIRQgyIQv//////AIM3AyAgBCAFKQAYIhJCEohC//////8AgzcDMCAEIAUpACAiE0IYiEL//////wCDNwNAIAQgBSkAMCIUQgGIQv//////AIM3A1ggBCAQQh2GQoCAgID+AIMgFUIjiIQ3AwggBCARQheGQoCAgPz/AIMgEEIpiIQ3AxggBCASQhGGQoCA+P//AIMgEUIviIQ3AyggBCATQguGQoDw////AIMgEkI1iIQ3AzggBCAFKQAoIhBCBYZC4P////8AgyATQjuIhDcDSCAEIBRCIoZCgICAgMAAgyAQQh6IhDcDUCAEIAUpADgiEEIHiEL//////wCDNwNoIAQgBSkAQCIRQg2IQv//////AIM3A3ggBCAFKQBIIhJCE4hC//////8AgzcDiAEgBCAFKQBQIhNCGYhC//////8AgzcDmAEgBCAFKQBgIhVCAohC//////8AgzcDsAEgBCAQQhyGQoCAgID/AIMgFEIkiIQ3A2AgBCARQhaGQoCAgP7/AIMgEEIqiIQ3A3AgBCASQhCGQoCA/P//AIMgEUIwiIQ3A4ABIAQgE0IKhkKA+P///wCDIBJCNoiENwOQASAEIAUpAFgiEEIEhkLw/////wCDIBNCPIiENwOgASAEIBVCIYZCgICAgOAAgyAQQh+IhDcDqAEgBCAFKQBoIhBCCIhC//////8AgzcDwAEgBCAQQhuGQoCAgMD/AIMgFUIliIQ3A7gBIAQgBSkAcCIRQg6IQv//////AIM3A9ABIAQgEUIVhkKAgID//wCDIBBCK4iENwPIASAEIAUpAHgiEEIUiEL//////wCDNwPgASAEIBBCD4ZCgID+//8AgyARQjGIhDcD2AEgBCAFKQCAASIRQhqIQv//////AIM3A/ABIAQgEUIJhkKA/P///wCDIBBCN4iENwPoASAEIAUpAIgBIhJCA4ZC+P////8AgyARQj2IhDcD+AEgBCAFKQCQASIQQgOIQv//////AIM3A4gCIAQgEEIghkKAgICA8ACDIBJCIIiENwOAAiAEIAUpAJgBIhFCCYhC//////8AgzcDmAIgBCARQhqGQoCAgOD/AIMgEEImiIQ3A5ACIAQgBSkAoAEiEEIPiEL//////wCDNwOoAiAEIBBCFIZCgIDA//8AgyARQiyIhDcDoAIgBCAFKQCoASIRQhWIQv//////AIM3A7gCIAQgEUIOhkKAgP///wCDIBBCMoiENwOwAiAEIAUpALABIhBCG4hC//////8AgzcDyAIgBCAQQgiGQoD+////AIMgEUI4iIQ3A8ACIAQgBSkAuAEiEUIChkL8/////wCDIBBCPoiENwPQAiAEIAUpAMABIhBCBIhC//////8AgzcD4AIgBCAQQh+GQoCAgID4AIMgEUIhiIQ3A9gCIAQgBSkAyAEiEUIKiEL//////wCDNwPwAiAEIBFCGYZCgICA8P8AgyAQQieIhDcD6AIgBCAFKQDQASIQQhCIQv//////AIM3A4ADIAQgEEIThkKAgOD//wCDIBFCLYiENwP4AiAEIAUpANgBIhFCFohC//////8AgzcDkAMgBCARQg2GQoDA////AIMgEEIziIQ3A4gDIAQgBSkA4AEiEEIciEL//////wCDNwOgAyAEIBBCB4ZCgP////8AgyARQjmIhDcDmAMgBCAFKQDoASIRQgGGQv7/////AIMgEEI/iIQ3A6gDIAQgBSkA8AEiEEIFiEL//////wCDNwO4AyAEIBBCHoZCgICAgPwAgyARQiKIhDcDsAMgBCAFKQD4ASIRQguIQv//////AIM3A8gDIAQgEUIYhkKAgID4/wCDIBBCKIiENwPAAyAEIAUpAIACIhBCEYhC//////8AgzcD2AMgBCAQQhKGQoCA8P//AIMgEUIuiIQ3A9ADIAQgBSkAiAIiEUIXiEL//////wCDNwPoAyAEIBFCDIZCgOD///8AgyAQQjSIhDcD4AMgBCAFKQCQAiIQQh2INwP4AyAEIBBCBoZCwP////8AgyARQjqIhDcD8AMMHgsgBkGfAk0EQAwmCyAEIAUpAAAiFUL//////wGDNwMAIAQgBSkACCIQQgiIQv//////AYM3AxAgBCAFKQAQIhFCEIhC//////8BgzcDICAEIAUpABgiEkIYiEL//////wGDNwMwIAQgBSkAKCITQgSIQv//////AYM3A0ggBCAFKQAwIhRCDIhC//////8BgzcDWCAEIBBCHIZCgICAgP8BgyAVQiSIhDcDCCAEIBFCFIZCgIDA//8BgyAQQiyIhDcDGCAEIBJCDIZCgOD///8BgyARQjSIhDcDKCAEIAUpACAiEEIEhkLw/////wGDIBJCPIiENwM4IAQgE0IghkKAgICA8AGDIBBCIIiENwNAIAQgFEIYhkKAgID4/wGDIBNCKIiENwNQIAQgBSkAQCIVQhyINwN4IAQgBSkASCIWQv//////AYM3A4ABIAQgBSkAOCIQQhSIQv//////AYM3A2ggBCAFKQBQIhFCCIhC//////8BgzcDkAEgBCAFKQBYIhJCEIhC//////8BgzcDoAEgBCAFKQBgIhNCGIhC//////8BgzcDsAEgBCAQQhCGQoCA/P//AYMgFEIwiIQ3A2AgBCAVQgiGQoD+////AYMgEEI4iIQ3A3AgBCARQhyGQoCAgID/AYMgFkIkiIQ3A4gBIAQgEkIUhkKAgMD//wGDIBFCLIiENwOYASAEIBNCDIZCgOD///8BgyASQjSIhDcDqAEgBCAFKQBoIhFCBIZC8P////8BgyATQjyIhDcDuAEgBCAFKQBwIhBCBIhC//////8BgzcDyAEgBCAQQiCGQoCAgIDwAYMgEUIgiIQ3A8ABIAQgBSkAeCIRQgyIQv//////AYM3A9gBIAQgEUIYhkKAgID4/wGDIBBCKIiENwPQASAEIAUpAIABIhBCFIhC//////8BgzcD6AEgBCAQQhCGQoCA/P//AYMgEUIwiIQ3A+ABIAQgBSkAiAEiEUIciDcD+AEgBCARQgiGQoD+////AYMgEEI4iIQ3A/ABIAQgBSkAkAEiEUL//////wGDNwOAAiAEIAUpAJgBIhBCCIhC//////8BgzcDkAIgBCAQQhyGQoCAgID/AYMgEUIkiIQ3A4gCIAQgBSkAoAEiEUIQiEL//////wGDNwOgAiAEIBFCFIZCgIDA//8BgyAQQiyIhDcDmAIgBCAFKQCoASIQQhiIQv//////AYM3A7ACIAQgEEIMhkKA4P///wGDIBFCNIiENwOoAiAEIAUpALABIhFCBIZC8P////8BgyAQQjyIhDcDuAIgBCAFKQC4ASIQQgSIQv//////AYM3A8gCIAQgEEIghkKAgICA8AGDIBFCIIiENwPAAiAEIAUpAMABIhFCDIhC//////8BgzcD2AIgBCARQhiGQoCAgPj/AYMgEEIoiIQ3A9ACIAQgBSkAyAEiEEIUiEL//////wGDNwPoAiAEIBBCEIZCgID8//8BgyARQjCIhDcD4AIgBCAFKQDQASIRQhyINwP4AiAEIBFCCIZCgP7///8BgyAQQjiIhDcD8AIgBCAFKQDYASIRQv//////AYM3A4ADIAQgBSkA4AEiEEIIiEL//////wGDNwOQAyAEIBBCHIZCgICAgP8BgyARQiSIhDcDiAMgBCAFKQDoASIRQhCIQv//////AYM3A6ADIAQgEUIUhkKAgMD//wGDIBBCLIiENwOYAyAEIAUpAPABIhBCGIhC//////8BgzcDsAMgBCAQQgyGQoDg////AYMgEUI0iIQ3A6gDIAQgBSkA+AEiEUIEhkLw/////wGDIBBCPIiENwO4AyAEIAUpAIACIhBCBIhC//////8BgzcDyAMgBCAQQiCGQoCAgIDwAYMgEUIgiIQ3A8ADIAQgBSkAiAIiEUIMiEL//////wGDNwPYAyAEIBFCGIZCgICA+P8BgyAQQiiIhDcD0AMgBCAFKQCQAiIQQhSIQv//////AYM3A+gDIAQgEEIQhkKAgPz//wGDIBFCMIiENwPgAyAEIAUpAJgCIhFCHIg3A/gDIAQgEUIIhkKA/v///wGDIBBCOIiENwPwAwwdCyAGQacCTQRADCULIAQgBSkAACIVQv//////A4M3AwAgBCAFKQAIIhBCCohC//////8DgzcDECAEIAUpABAiEUIUiEL//////wODNwMgIAQgBSkAICISQgOIQv//////A4M3AzggBCAFKQAoIhNCDYhC//////8DgzcDSCAEIAUpADAiFEIXiEL//////wODNwNYIAQgEEIbhkKAgIDA/wODIBVCJYiENwMIIAQgEUIRhkKAgPj//wODIBBCL4iENwMYIAQgBSkAGCIQQgeGQoD/////A4MgEUI5iIQ3AyggBCASQiKGQoCAgIDAA4MgEEIeiIQ3AzAgBCATQhiGQoCAgPj/A4MgEkIoiIQ3A0AgBCAUQg6GQoCA////A4MgE0IyiIQ3A1AgBCAFKQBAIhBCBohC//////8DgzcDcCAEIAUpAEgiEUIQiEL//////wODNwOAASAEIAUpAFAiEkIaiEL//////wODNwOQASAEIAUpAGAiE0IJiEL//////wODNwOoASAEIAUpAGgiFUITiEL//////wODNwO4ASAEIAUpADgiFkIEhkLw/////wODIBRCPIiENwNgIAQgEEIfhkKAgICA+AODIBZCIYiENwNoIAQgEUIVhkKAgID//wODIBBCK4iENwN4IAQgEkILhkKA8P///wODIBFCNYiENwOIASAEIAUpAFgiEEIBhkL+/////wODIBJCP4iENwOYASAEIBNCHIZCgICAgP8DgyAQQiSIhDcDoAEgBCAVQhKGQoCA8P//A4MgE0IuiIQ3A7ABIAQgBSkAcCIRQgiGQoD+////A4MgFUI4iIQ3A8ABIAQgBSkAeCIQQgKIQv//////A4M3A9ABIAQgEEIjhkKAgICAgAODIBFCHYiENwPIASAEIAUpAIABIhFCDIhC//////8DgzcD4AEgBCARQhmGQoCAgPD/A4MgEEIniIQ3A9gBIAQgBSkAiAEiEEIWiEL//////wODNwPwASAEIBBCD4ZCgID+//8DgyARQjGIhDcD6AEgBCAFKQCQASIRQgWGQuD/////A4MgEEI7iIQ3A/gBIAQgBSkAmAEiEEIFiEL//////wODNwOIAiAEIBBCIIZCgICAgPADgyARQiCIhDcDgAIgBCAFKQCgASIRQg+IQv//////A4M3A5gCIAQgEUIWhkKAgID+/wODIBBCKoiENwOQAiAEIAUpAKgBIhBCGYhC//////8DgzcDqAIgBCAQQgyGQoDg////A4MgEUI0iIQ3A6ACIAQgBSkAsAEiEUIChkL8/////wODIBBCPoiENwOwAiAEIAUpALgBIhBCCIhC//////8DgzcDwAIgBCAQQh2GQoCAgID+A4MgEUIjiIQ3A7gCIAQgBSkAwAEiEUISiEL//////wODNwPQAiAEIBFCE4ZCgIDg//8DgyAQQi2IhDcDyAIgBCAFKQDIASISQgmGQoD8////A4MgEUI3iIQ3A9gCIAQgBSkA0AEiEEIBiEL//////wODNwPoAiAEIBBCJIZCgICAgIACgyASQhyIhDcD4AIgBCAFKQDYASIRQguIQv//////A4M3A/gCIAQgEUIahkKAgIDg/wODIBBCJoiENwPwAiAEIAUpAOABIhBCFYhC//////8DgzcDiAMgBCAQQhCGQoCA/P//A4MgEUIwiIQ3A4ADIAQgBSkA6AEiEUIGhkLA/////wODIBBCOoiENwOQAyAEIAUpAPABIhBCBIhC//////8DgzcDoAMgBCAQQiGGQoCAgIDgA4MgEUIfiIQ3A5gDIAQgBSkA+AEiEUIOiEL//////wODNwOwAyAEIBFCF4ZCgICA/P8DgyAQQimIhDcDqAMgBCAFKQCAAiIQQhiIQv//////A4M3A8ADIAQgEEINhkKAwP///wODIBFCM4iENwO4AyAEIAUpAIgCIhFCA4ZC+P////8DgyAQQj2IhDcDyAMgBCAFKQCQAiIQQgeIQv//////A4M3A9gDIAQgEEIehkKAgICA/AODIBFCIoiENwPQAyAEIAUpAJgCIhFCEYhC//////8DgzcD6AMgBCARQhSGQoCAwP//A4MgEEIsiIQ3A+ADIAQgBSkAoAIiEEIbiDcD+AMgBCAQQgqGQoD4////A4MgEUI2iIQ3A/ADDBwLIAZBrwJNBEAMJAsgBCAFKQAAIhRC//////8HgzcDACAEIAUpAAgiEEIMiEL//////weDNwMQIAQgBSkAECIRQhiIQv//////B4M3AyAgBCAFKQAgIhJCCohC//////8HgzcDOCAEIAUpACgiE0IWiEL//////weDNwNIIAQgEEIahkKAgIDg/weDIBRCJoiENwMIIAQgEUIOhkKAgP///weDIBBCMoiENwMYIAQgBSkAGCIQQgKGQvz/////B4MgEUI+iIQ3AyggBCASQhyGQoCAgID/B4MgEEIkiIQ3AzAgBCATQhCGQoCA/P//B4MgEkIwiIQ3A0AgBCAFKQAwIhFCBIZC8P////8HgyATQjyIhDcDUCAEIAUpADgiEEIIiEL//////weDNwNgIAQgEEIehkKAgICA/AeDIBFCIoiENwNYIAQgBSkAQCIRQhSIQv//////B4M3A3AgBCAFKQBQIhJCBohC//////8HgzcDiAEgBCAFKQBYIhNCEohC//////8HgzcDmAEgBCAFKQBoIhRCBIhC//////8HgzcDsAEgBCARQhKGQoCA8P//B4MgEEIuiIQ3A2ggBCAFKQBIIhBCBoZCwP////8HgyARQjqIhDcDeCAEIBJCIIZCgICAgPAHgyAQQiCIhDcDgAEgBCATQhSGQoCAwP//B4MgEkIsiIQ3A5ABIAQgBSkAYCIQQgiGQoD+////B4MgE0I4iIQ3A6ABIAQgFEIihkKAgICAwAeDIBBCHoiENwOoASAEIAUpAHAiEEIQiEL//////weDNwPAASAEIBBCFoZCgICA/v8HgyAUQiqIhDcDuAEgBCAFKQB4IhFCCoZCgPj///8HgyAQQjaIhDcDyAEgBCAFKQCAASIQQgKIQv//////B4M3A9gBIAQgEEIkhkKAgICAgAaDIBFCHIiENwPQASAEIAUpAIgBIhFCDohC//////8HgzcD6AEgBCARQhiGQoCAgPj/B4MgEEIoiIQ3A+ABIAQgBSkAkAEiEEIaiDcD+AEgBCAQQgyGQoDg////B4MgEUI0iIQ3A/ABIAQgBSkAmAEiEUL//////weDNwOAAiAEIAUpAKABIhBCDIhC//////8HgzcDkAIgBCAQQhqGQoCAgOD/B4MgEUImiIQ3A4gCIAQgBSkAqAEiEUIYiEL//////weDNwOgAiAEIBFCDoZCgID///8HgyAQQjKIhDcDmAIgBCAFKQCwASISQgKGQvz/////B4MgEUI+iIQ3A6gCIAQgBSkAuAEiEEIKiEL//////weDNwO4AiAEIBBCHIZCgICAgP8HgyASQiSIhDcDsAIgBCAFKQDAASIRQhaIQv//////B4M3A8gCIAQgEUIQhkKAgPz//weDIBBCMIiENwPAAiAEIAUpAMgBIhJCBIZC8P////8HgyARQjyIhDcD0AIgBCAFKQDQASIQQgiIQv//////B4M3A+ACIAQgEEIehkKAgICA/AeDIBJCIoiENwPYAiAEIAUpANgBIhFCFIhC//////8HgzcD8AIgBCARQhKGQoCA8P//B4MgEEIuiIQ3A+gCIAQgBSkA4AEiEkIGhkLA/////weDIBFCOoiENwP4AiAEIAUpAOgBIhBCBohC//////8HgzcDiAMgBCAQQiCGQoCAgIDwB4MgEkIgiIQ3A4ADIAQgBSkA8AEiEUISiEL//////weDNwOYAyAEIBFCFIZCgIDA//8HgyAQQiyIhDcDkAMgBCAFKQD4ASISQgiGQoD+////B4MgEUI4iIQ3A6ADIAQgBSkAgAIiEEIEiEL//////weDNwOwAyAEIBBCIoZCgICAgMAHgyASQh6IhDcDqAMgBCAFKQCIAiIRQhCIQv//////B4M3A8ADIAQgEUIWhkKAgID+/weDIBBCKoiENwO4AyAEIAUpAJACIhJCCoZCgPj///8HgyARQjaIhDcDyAMgBCAFKQCYAiIQQgKIQv//////B4M3A9gDIAQgEEIkhkKAgICAgAaDIBJCHIiENwPQAyAEIAUpAKACIhFCDohC//////8HgzcD6AMgBCARQhiGQoCAgPj/B4MgEEIoiIQ3A+ADIAQgBSkAqAIiEEIaiDcD+AMgBCAQQgyGQoDg////B4MgEUI0iIQ3A/ADDBsLIAZBtwJNBEAMIwsgBCAFKQAAIhRC//////8PgzcDACAEIAUpAAgiEEIOiEL//////w+DNwMQIAQgBSkAGCIRQgOIQv//////D4M3AyggBCAFKQAgIhJCEYhC//////8PgzcDOCAEIAUpADAiE0IGiEL//////w+DNwNQIAQgEEIZhkKAgIDw/w+DIBRCJ4iENwMIIAQgBSkAECIUQguGQoDw////D4MgEEI1iIQ3AxggBCARQiSGQoCAgICADoMgFEIciIQ3AyAgBCASQhaGQoCAgP7/D4MgEUIqiIQ3AzAgBCAFKQAoIhBCCIZCgP7///8PgyASQjiIhDcDQCAEIBNCIYZCgICAgOAPgyAQQh+IhDcDSCAEIAUpADgiEEIUiEL//////w+DNwNgIAQgEEIThkKAgOD//w+DIBNCLYiENwNYIAQgBSkASCIRQgmIQv//////D4M3A3ggBCAFKQBQIhJCF4hC//////8PgzcDiAEgBCAFKQBgIhNCDIhC//////8PgzcDoAEgBCAFKQBAIhRCBYZC4P////8PgyAQQjuIhDcDaCAEIBFCHoZCgICAgPwPgyAUQiKIhDcDcCAEIBJCEIZCgID8//8PgyARQjCIhDcDgAEgBCAFKQBYIhBCAoZC/P////8PgyASQj6IhDcDkAEgBCATQhuGQoCAgMD/D4MgEEIliIQ3A5gBIAQgBSkAaCIRQg2GQoDA////D4MgE0IziIQ3A6gBIAQgBSkAcCIQQgGIQv//////D4M3A7gBIAQgEEImhkKAgICAgAiDIBFCGoiENwOwASAEIAUpAHgiEUIPiEL//////w+DNwPIASAEIBFCGIZCgICA+P8PgyAQQiiIhDcDwAEgBCAFKQCAASISQgqGQoD4////D4MgEUI2iIQ3A9ABIAQgBSkAiAEiEEIEiEL//////w+DNwPgASAEIBBCI4ZCgICAgIAPgyASQh2IhDcD2AEgBCAFKQCQASIRQhKIQv//////D4M3A/ABIAQgEUIVhkKAgID//w+DIBBCK4iENwPoASAEIAUpAJgBIhJCB4ZCgP////8PgyARQjmIhDcD+AEgBCAFKQCgASIQQgeIQv//////D4M3A4gCIAQgEEIghkKAgICA8A+DIBJCIIiENwOAAiAEIAUpAKgBIhFCFYhC//////8PgzcDmAIgBCARQhKGQoCA8P//D4MgEEIuiIQ3A5ACIAQgBSkAsAEiEkIEhkLw/////w+DIBFCPIiENwOgAiAEIAUpALgBIhBCCohC//////8PgzcDsAIgBCAQQh2GQoCAgID+D4MgEkIjiIQ3A6gCIAQgBSkAwAEiEUIYiEL//////w+DNwPAAiAEIBFCD4ZCgID+//8PgyAQQjGIhDcDuAIgBCAFKQDIASISQgGGQv7/////D4MgEUI/iIQ3A8gCIAQgBSkA0AEiEEINiEL//////w+DNwPYAiAEIBBCGoZCgICA4P8PgyASQiaIhDcD0AIgBCAFKQDYASIRQgyGQoDg////D4MgEEI0iIQ3A+ACIAQgBSkA4AEiEEICiEL//////w+DNwPwAiAEIBBCJYZCgICAgIAMgyARQhuIhDcD6AIgBCAFKQDoASIRQhCIQv//////D4M3A4ADIAQgEUIXhkKAgID8/w+DIBBCKYiENwP4AiAEIAUpAPABIhJCCYZCgPz///8PgyARQjeIhDcDiAMgBCAFKQD4ASIQQgWIQv//////D4M3A5gDIAQgEEIihkKAgICAwA+DIBJCHoiENwOQAyAEIAUpAIACIhFCE4hC//////8PgzcDqAMgBCARQhSGQoCAwP//D4MgEEIsiIQ3A6ADIAQgBSkAiAIiEkIGhkLA/////w+DIBFCOoiENwOwAyAEIAUpAJACIhBCCIhC//////8PgzcDwAMgBCAQQh+GQoCAgID4D4MgEkIhiIQ3A7gDIAQgBSkAmAIiEUIWiEL//////w+DNwPQAyAEIBFCEYZCgID4//8PgyAQQi+IhDcDyAMgBCAFKQCgAiISQgOGQvj/////D4MgEUI9iIQ3A9gDIAQgBSkAqAIiEEILiEL//////w+DNwPoAyAEIBBCHIZCgICAgP8PgyASQiSIhDcD4AMgBCAFKQCwAiIRQhmINwP4AyAEIBFCDoZCgID///8PgyAQQjKIhDcD8AMMGgsgBkG/Ak0EQAwiCyAEIAUpAAAiE0L//////x+DNwMAIAQgBSkAICIUQhiINwM4IAQgBSkAKCIVQv//////H4M3A0AgBCAFKQAIIhBCEIhC//////8fgzcDECAEIAUpABgiEUIIiEL//////x+DNwMoIAQgBSkAMCISQhCIQv//////H4M3A1AgBCAQQhiGQoCAgPj/H4MgE0IoiIQ3AwggBCAFKQAQIhNCCIZCgP7///8fgyAQQjiIhDcDGCAEIBFCIIZCgICAgPAfgyATQiCIhDcDICAEIBRCEIZCgID8//8fgyARQjCIhDcDMCAEIBJCGIZCgICA+P8fgyAVQiiIhDcDSCAEIAUpADgiE0IIhkKA/v///x+DIBJCOIiENwNYIAQgBSkASCIUQhiINwN4IAQgBSkAUCIVQv//////H4M3A4ABIAQgBSkAcCIWQhiINwO4ASAEIAUpAEAiEEIIiEL//////x+DNwNoIAQgBSkAWCIRQhCIQv//////H4M3A5ABIAQgBSkAaCISQgiIQv//////H4M3A6gBIAQgEEIghkKAgICA8B+DIBNCIIiENwNgIAQgFEIQhkKAgPz//x+DIBBCMIiENwNwIAQgEUIYhkKAgID4/x+DIBVCKIiENwOIASAEIAUpAGAiEEIIhkKA/v///x+DIBFCOIiENwOYASAEIBJCIIZCgICAgPAfgyAQQiCIhDcDoAEgBCAWQhCGQoCA/P//H4MgEkIwiIQ3A7ABIAQgBSkAeCIRQv//////H4M3A8ABIAQgBSkAgAEiEEIQiEL//////x+DNwPQASAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAEgBCAFKQCIASIRQgiGQoD+////H4MgEEI4iIQ3A9gBIAQgBSkAkAEiEEIIiEL//////x+DNwPoASAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AEgBCAFKQCYASIRQhiINwP4ASAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AEgBCAFKQCgASIRQv//////H4M3A4ACIAQgBSkAqAEiEEIQiEL//////x+DNwOQAiAEIBBCGIZCgICA+P8fgyARQiiIhDcDiAIgBCAFKQCwASIRQgiGQoD+////H4MgEEI4iIQ3A5gCIAQgBSkAuAEiEEIIiEL//////x+DNwOoAiAEIBBCIIZCgICAgPAfgyARQiCIhDcDoAIgBCAFKQDAASIRQhiINwO4AiAEIBFCEIZCgID8//8fgyAQQjCIhDcDsAIgBCAFKQDIASIRQv//////H4M3A8ACIAQgBSkA0AEiEEIQiEL//////x+DNwPQAiAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAIgBCAFKQDYASIRQgiGQoD+////H4MgEEI4iIQ3A9gCIAQgBSkA4AEiEEIIiEL//////x+DNwPoAiAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AIgBCAFKQDoASIRQhiINwP4AiAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AIgBCAFKQDwASIRQv//////H4M3A4ADIAQgBSkA+AEiEEIQiEL//////x+DNwOQAyAEIBBCGIZCgICA+P8fgyARQiiIhDcDiAMgBCAFKQCAAiIRQgiGQoD+////H4MgEEI4iIQ3A5gDIAQgBSkAiAIiEEIIiEL//////x+DNwOoAyAEIBBCIIZCgICAgPAfgyARQiCIhDcDoAMgBCAFKQCQAiIRQhiINwO4AyAEIBFCEIZCgID8//8fgyAQQjCIhDcDsAMgBCAFKQCYAiIRQv//////H4M3A8ADIAQgBSkAoAIiEEIQiEL//////x+DNwPQAyAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAMgBCAFKQCoAiIRQgiGQoD+////H4MgEEI4iIQ3A9gDIAQgBSkAsAIiEEIIiEL//////x+DNwPoAyAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AMgBCAFKQC4AiIRQhiINwP4AyAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AMMGQsgBkHHAk0EQAwhCyAEIAUpAAAiFEL//////z+DNwMAIAQgBSkACCIQQhKIQv//////P4M3AxAgBCAFKQAYIhFCDYhC//////8/gzcDKCAEIAUpACgiEkIIiEL//////z+DNwNAIAQgBSkAOCITQgOIQv//////P4M3A1ggBCAQQheGQoCAgPz/P4MgFEIpiIQ3AwggBCAFKQAQIhRCBYZC4P////8/gyAQQjuIhDcDGCAEIBFCHIZCgICAgP8/gyAUQiSIhDcDICAEIAUpACAiEEIKhkKA+P///z+DIBFCNoiENwMwIAQgEkIhhkKAgICA4D+DIBBCH4iENwM4IAQgBSkAMCIQQg+GQoCA/v//P4MgEkIxiIQ3A0ggBCATQiaGQoCAgICAOIMgEEIaiIQ3A1AgBCAFKQBAIhBCFYhC//////8/gzcDaCAEIAUpAFAiEUIQiEL//////z+DNwOAASAEIAUpAGAiEkILiEL//////z+DNwOYASAEIAUpAHAiFEIGiEL//////z+DNwOwASAEIBBCFIZCgIDA//8/gyATQiyIhDcDYCAEIAUpAEgiE0IChkL8/////z+DIBBCPoiENwNwIAQgEUIZhkKAgIDw/z+DIBNCJ4iENwN4IAQgBSkAWCIQQgeGQoD/////P4MgEUI5iIQ3A4gBIAQgEkIehkKAgICA/D+DIBBCIoiENwOQASAEIAUpAGgiEEIMhkKA4P///z+DIBJCNIiENwOgASAEIBRCI4ZCgICAgIA/gyAQQh2IhDcDqAEgBCAFKQB4IhFCEYZCgID4//8/gyAUQi+IhDcDuAEgBCAFKQCAASIQQgGIQv//////P4M3A8gBIAQgEEIohkKAgICAgCCDIBFCGIiENwPAASAEIAUpAIgBIhFCE4hC//////8/gzcD2AEgBCARQhaGQoCAgP7/P4MgEEIqiIQ3A9ABIAQgBSkAkAEiEkIEhkLw/////z+DIBFCPIiENwPgASAEIAUpAJgBIhBCDohC//////8/gzcD8AEgBCAQQhuGQoCAgMD/P4MgEkIliIQ3A+gBIAQgBSkAoAEiEUIJhkKA/P///z+DIBBCN4iENwP4ASAEIAUpAKgBIhBCCYhC//////8/gzcDiAIgBCAQQiCGQoCAgIDwP4MgEUIgiIQ3A4ACIAQgBSkAsAEiEUIOhkKAgP///z+DIBBCMoiENwOQAiAEIAUpALgBIhBCBIhC//////8/gzcDoAIgBCAQQiWGQoCAgICAPIMgEUIbiIQ3A5gCIAQgBSkAwAEiEUIWiEL//////z+DNwOwAiAEIBFCE4ZCgIDg//8/gyAQQi2IhDcDqAIgBCAFKQDIASISQgGGQv7/////P4MgEUI/iIQ3A7gCIAQgBSkA0AEiEEIRiEL//////z+DNwPIAiAEIBBCGIZCgICA+P8/gyASQiiIhDcDwAIgBCAFKQDYASIRQgaGQsD/////P4MgEEI6iIQ3A9ACIAQgBSkA4AEiEEIMiEL//////z+DNwPgAiAEIBBCHYZCgICAgP4/gyARQiOIhDcD2AIgBCAFKQDoASIRQguGQoDw////P4MgEEI1iIQ3A+gCIAQgBSkA8AEiEEIHiEL//////z+DNwP4AiAEIBBCIoZCgICAgMA/gyARQh6IhDcD8AIgBCAFKQD4ASIRQhCGQoCA/P//P4MgEEIwiIQ3A4ADIAQgBSkAgAIiEEICiEL//////z+DNwOQAyAEIBBCJ4ZCgICAgIAwgyARQhmIhDcDiAMgBCAFKQCIAiIRQhSIQv//////P4M3A6ADIAQgEUIVhkKAgID//z+DIBBCK4iENwOYAyAEIAUpAJACIhJCA4ZC+P////8/gyARQj2IhDcDqAMgBCAFKQCYAiIQQg+IQv//////P4M3A7gDIAQgEEIahkKAgIDg/z+DIBJCJoiENwOwAyAEIAUpAKACIhFCCIZCgP7///8/gyAQQjiIhDcDwAMgBCAFKQCoAiIQQgqIQv//////P4M3A9ADIAQgEEIfhkKAgICA+D+DIBFCIYiENwPIAyAEIAUpALACIhFCDYZCgMD///8/gyAQQjOIhDcD2AMgBCAFKQC4AiIQQgWIQv//////P4M3A+gDIAQgEEIkhkKAgICAgD6DIBFCHIiENwPgAyAEIAUpAMACIhFCF4g3A/gDIAQgEUIShkKAgPD//z+DIBBCLoiENwPwAwwYCyAGQc8CTQRADCALIAQgBSkAACIUQv///////wCDNwMAIAQgBSkACCIQQhSIQv///////wCDNwMQIAQgBSkAGCIRQhKIQv///////wCDNwMoIAQgBSkAKCISQhCIQv///////wCDNwNAIAQgBSkAOCITQg6IQv///////wCDNwNYIAQgEEIWhkKAgID+//8AgyAUQiqIhDcDCCAEIAUpABAiFEIChkL8//////8AgyAQQj6IhDcDGCAEIBFCGIZCgICA+P//AIMgFEIoiIQ3AyAgBCAFKQAgIhBCBIZC8P//////AIMgEUI8iIQ3AzAgBCASQhqGQoCAgOD//wCDIBBCJoiENwM4IAQgBSkAMCIQQgaGQsD//////wCDIBJCOoiENwNIIAQgE0IchkKAgICA//8AgyAQQiSIhDcDUCAEIAUpAEgiEEIMiEL///////8AgzcDcCAEIAUpAFgiEUIKiEL///////8AgzcDiAEgBCAFKQBoIhJCCIhC////////AIM3A6ABIAQgBSkAeCIUQgaIQv///////wCDNwO4ASAEIAUpAEAiFUIIhkKA/v////8AgyATQjiIhDcDYCAEIBBCHoZCgICAgPz/AIMgFUIiiIQ3A2ggBCAFKQBQIhNCCoZCgPj/////AIMgEEI2iIQ3A3ggBCARQiCGQoCAgIDw/wCDIBNCIIiENwOAASAEIAUpAGAiEEIMhkKA4P////8AgyARQjSIhDcDkAEgBCASQiKGQoCAgIDA/wCDIBBCHoiENwOYASAEIAUpAHAiEEIOhkKAgP////8AgyASQjKIhDcDqAEgBCAUQiSGQoCAgICA/gCDIBBCHIiENwOwASAEIAUpAIABIhFCEIZCgID8////AIMgFEIwiIQ3A8ABIAQgBSkAiAEiEEIEiEL///////8AgzcD0AEgBCAQQiaGQoCAgICA+ACDIBFCGoiENwPIASAEIAUpAJABIhFCEoZCgIDw////AIMgEEIuiIQ3A9gBIAQgBSkAmAEiEEICiEL///////8AgzcD6AEgBCAQQiiGQoCAgICA4ACDIBFCGIiENwPgASAEIAUpAKABIhFCFog3A/gBIAQgEUIUhkKAgMD///8AgyAQQiyIhDcD8AEgBCAFKQCoASIRQv///////wCDNwOAAiAEIAUpALABIhBCFIhC////////AIM3A5ACIAQgEEIWhkKAgID+//8AgyARQiqIhDcDiAIgBCAFKQC4ASIRQgKGQvz//////wCDIBBCPoiENwOYAiAEIAUpAMABIhBCEohC////////AIM3A6gCIAQgEEIYhkKAgID4//8AgyARQiiIhDcDoAIgBCAFKQDIASIRQgSGQvD//////wCDIBBCPIiENwOwAiAEIAUpANABIhBCEIhC////////AIM3A8ACIAQgEEIahkKAgIDg//8AgyARQiaIhDcDuAIgBCAFKQDYASIRQgaGQsD//////wCDIBBCOoiENwPIAiAEIAUpAOABIhBCDohC////////AIM3A9gCIAQgEEIchkKAgICA//8AgyARQiSIhDcD0AIgBCAFKQDoASIRQgiGQoD+/////wCDIBBCOIiENwPgAiAEIAUpAPABIhBCDIhC////////AIM3A/ACIAQgEEIehkKAgICA/P8AgyARQiKIhDcD6AIgBCAFKQD4ASIRQgqGQoD4/////wCDIBBCNoiENwP4AiAEIAUpAIACIhBCCohC////////AIM3A4gDIAQgEEIghkKAgICA8P8AgyARQiCIhDcDgAMgBCAFKQCIAiIRQgyGQoDg/////wCDIBBCNIiENwOQAyAEIAUpAJACIhBCCIhC////////AIM3A6ADIAQgEEIihkKAgICAwP8AgyARQh6IhDcDmAMgBCAFKQCYAiIRQg6GQoCA/////wCDIBBCMoiENwOoAyAEIAUpAKACIhBCBohC////////AIM3A7gDIAQgEEIkhkKAgICAgP4AgyARQhyIhDcDsAMgBCAFKQCoAiIRQhCGQoCA/P///wCDIBBCMIiENwPAAyAEIAUpALACIhBCBIhC////////AIM3A9ADIAQgEEImhkKAgICAgPgAgyARQhqIhDcDyAMgBCAFKQC4AiIRQhKGQoCA8P///wCDIBBCLoiENwPYAyAEIAUpAMACIhBCAohC////////AIM3A+gDIAQgEEIohkKAgICAgOAAgyARQhiIhDcD4AMgBCAFKQDIAiIRQhaINwP4AyAEIBFCFIZCgIDA////AIMgEEIsiIQ3A/ADDBcLIAZB1wJNBEAMHwsgBCAFKQAAIhNC////////AYM3AwAgBCAFKQAQIhBCAYhC////////AYM3AxggBCAFKQAgIhFCAohC////////AYM3AzAgBCAFKQAwIhJCA4hC////////AYM3A0ggBCAFKQAIIhRCFYZCgICA////AYMgE0IriIQ3AwggBCAQQiqGQoCAgICAgAGDIBRCFoiENwMQIAQgBSkAGCITQhSGQoCAwP///wGDIBBCLIiENwMgIAQgEUIphkKAgICAgMABgyATQheIhDcDKCAEIAUpACgiEEIThkKAgOD///8BgyARQi2IhDcDOCAEIBJCKIZCgICAgIDgAYMgEEIYiIQ3A0AgBCAFKQA4IhRCEoZCgIDw////AYMgEkIuiIQ3A1AgBCAFKQBAIhBCBIhC////////AYM3A2AgBCAFKQBQIhFCBYhC////////AYM3A3ggBCAFKQBgIhJCBohC////////AYM3A5ABIAQgBSkAcCITQgeIQv///////wGDNwOoASAEIBBCJ4ZCgICAgIDwAYMgFEIZiIQ3A1ggBCAFKQBIIhRCEYZCgID4////AYMgEEIviIQ3A2ggBCARQiaGQoCAgICA+AGDIBRCGoiENwNwIAQgBSkAWCIQQhCGQoCA/P///wGDIBFCMIiENwOAASAEIBJCJYZCgICAgID8AYMgEEIbiIQ3A4gBIAQgBSkAaCIQQg+GQoCA/v///wGDIBJCMYiENwOYASAEIBNCJIZCgICAgID+AYMgEEIciIQ3A6ABIAQgBSkAeCIRQg6GQoCA/////wGDIBNCMoiENwOwASAEIAUpAIABIhBCCIhC////////AYM3A8ABIAQgEEIjhkKAgICAgP8BgyARQh2IhDcDuAEgBCAFKQCIASIRQg2GQoDA/////wGDIBBCM4iENwPIASAEIAUpAJABIhBCCYhC////////AYM3A9gBIAQgEEIihkKAgICAwP8BgyARQh6IhDcD0AEgBCAFKQCYASIRQgyGQoDg/////wGDIBBCNIiENwPgASAEIAUpAKABIhBCCohC////////AYM3A/ABIAQgEEIhhkKAgICA4P8BgyARQh+IhDcD6AEgBCAFKQCoASIRQguGQoDw/////wGDIBBCNYiENwP4ASAEIAUpALABIhBCC4hC////////AYM3A4gCIAQgEEIghkKAgICA8P8BgyARQiCIhDcDgAIgBCAFKQC4ASIRQgqGQoD4/////wGDIBBCNoiENwOQAiAEIAUpAMABIhBCDIhC////////AYM3A6ACIAQgEEIfhkKAgICA+P8BgyARQiGIhDcDmAIgBCAFKQDIASIRQgmGQoD8/////wGDIBBCN4iENwOoAiAEIAUpANABIhBCDYhC////////AYM3A7gCIAQgEEIehkKAgICA/P8BgyARQiKIhDcDsAIgBCAFKQDYASIRQgiGQoD+/////wGDIBBCOIiENwPAAiAEIAUpAOABIhBCDohC////////AYM3A9ACIAQgEEIdhkKAgICA/v8BgyARQiOIhDcDyAIgBCAFKQDoASIRQgeGQoD//////wGDIBBCOYiENwPYAiAEIAUpAPABIhBCD4hC////////AYM3A+gCIAQgEEIchkKAgICA//8BgyARQiSIhDcD4AIgBCAFKQD4ASIRQgaGQsD//////wGDIBBCOoiENwPwAiAEIAUpAIACIhBCEIhC////////AYM3A4ADIAQgEEIbhkKAgIDA//8BgyARQiWIhDcD+AIgBCAFKQCIAiIRQgWGQuD//////wGDIBBCO4iENwOIAyAEIAUpAJACIhBCEYhC////////AYM3A5gDIAQgEEIahkKAgIDg//8BgyARQiaIhDcDkAMgBCAFKQCYAiIRQgSGQvD//////wGDIBBCPIiENwOgAyAEIAUpAKACIhBCEohC////////AYM3A7ADIAQgEEIZhkKAgIDw//8BgyARQieIhDcDqAMgBCAFKQCoAiIRQgOGQvj//////wGDIBBCPYiENwO4AyAEIAUpALACIhBCE4hC////////AYM3A8gDIAQgEEIYhkKAgID4//8BgyARQiiIhDcDwAMgBCAFKQC4AiIRQgKGQvz//////wGDIBBCPoiENwPQAyAEIAUpAMACIhBCFIhC////////AYM3A+ADIAQgEEIXhkKAgID8//8BgyARQimIhDcD2AMgBCAFKQDIAiIRQgGGQv7//////wGDIBBCP4iENwPoAyAEIAUpANACIhBCFYg3A/gDIAQgEEIWhkKAgID+//8BgyARQiqIhDcD8AMMFgsgBkHfAk0EQAweCyAEIAUpAAAiE0L///////8DgzcDACAEIAUpABAiEEIEiEL///////8DgzcDGCAEIAUpACAiEUIIiEL///////8DgzcDMCAEIAUpADAiEkIMiEL///////8DgzcDSCAEIAUpAAgiFEIUhkKAgMD///8DgyATQiyIhDcDCCAEIBBCKIZCgICAgIDgA4MgFEIYiIQ3AxAgBCAFKQAYIhNCEIZCgID8////A4MgEEIwiIQ3AyAgBCARQiSGQoCAgICA/gODIBNCHIiENwMoIAQgBSkAKCIQQgyGQoDg/////wODIBFCNIiENwM4IAQgEkIghkKAgICA8P8DgyAQQiCIhDcDQCAEIAUpADgiE0IIhkKA/v////8DgyASQjiIhDcDUCAEIAUpAFAiEkIUiDcDeCAEIAUpAFgiFEL///////8DgzcDgAEgBCAFKQBAIhBCEIhC////////A4M3A2AgBCAFKQBoIhFCBIhC////////A4M3A5gBIAQgEEIchkKAgICA//8DgyATQiSIhDcDWCAEIAUpAEgiE0IEhkLw//////8DgyAQQjyIhDcDaCAEIBJCGIZCgICA+P//A4MgE0IoiIQ3A3AgBCAFKQBgIhBCFIZCgIDA////A4MgFEIsiIQ3A4gBIAQgEUIohkKAgICAgOADgyAQQhiIhDcDkAEgBCAFKQBwIhJCEIZCgID8////A4MgEUIwiIQ3A6ABIAQgBSkAeCIQQgiIQv///////wODNwOwASAEIBBCJIZCgICAgID+A4MgEkIciIQ3A6gBIAQgBSkAgAEiEUIMhkKA4P////8DgyAQQjSIhDcDuAEgBCAFKQCIASIQQgyIQv///////wODNwPIASAEIBBCIIZCgICAgPD/A4MgEUIgiIQ3A8ABIAQgBSkAkAEiEUIIhkKA/v////8DgyAQQjiIhDcD0AEgBCAFKQCYASIQQhCIQv///////wODNwPgASAEIBBCHIZCgICAgP//A4MgEUIkiIQ3A9gBIAQgBSkAoAEiEUIEhkLw//////8DgyAQQjyIhDcD6AEgBCAFKQCoASIQQhSINwP4ASAEIBBCGIZCgICA+P//A4MgEUIoiIQ3A/ABIAQgBSkAsAEiEEL///////8DgzcDgAIgBCAFKQC4ASIRQhSGQoCAwP///wODIBBCLIiENwOIAiAEIAUpAMABIhBCBIhC////////A4M3A5gCIAQgEEIohkKAgICAgOADgyARQhiIhDcDkAIgBCAFKQDIASIRQhCGQoCA/P///wODIBBCMIiENwOgAiAEIAUpANABIhBCCIhC////////A4M3A7ACIAQgEEIkhkKAgICAgP4DgyARQhyIhDcDqAIgBCAFKQDYASIRQgyGQoDg/////wODIBBCNIiENwO4AiAEIAUpAOABIhBCDIhC////////A4M3A8gCIAQgEEIghkKAgICA8P8DgyARQiCIhDcDwAIgBCAFKQDoASIRQgiGQoD+/////wODIBBCOIiENwPQAiAEIAUpAPABIhBCEIhC////////A4M3A+ACIAQgEEIchkKAgICA//8DgyARQiSIhDcD2AIgBCAFKQD4ASIRQgSGQvD//////wODIBBCPIiENwPoAiAEIAUpAIACIhBCFIg3A/gCIAQgEEIYhkKAgID4//8DgyARQiiIhDcD8AIgBCAFKQCIAiIQQv///////wODNwOAAyAEIAUpAJACIhFCFIZCgIDA////A4MgEEIsiIQ3A4gDIAQgBSkAmAIiEEIEiEL///////8DgzcDmAMgBCAQQiiGQoCAgICA4AODIBFCGIiENwOQAyAEIAUpAKACIhFCEIZCgID8////A4MgEEIwiIQ3A6ADIAQgBSkAqAIiEEIIiEL///////8DgzcDsAMgBCAQQiSGQoCAgICA/gODIBFCHIiENwOoAyAEIAUpALACIhFCDIZCgOD/////A4MgEEI0iIQ3A7gDIAQgBSkAuAIiEEIMiEL///////8DgzcDyAMgBCAQQiCGQoCAgIDw/wODIBFCIIiENwPAAyAEIAUpAMACIhFCCIZCgP7/////A4MgEEI4iIQ3A9ADIAQgBSkAyAIiEEIQiEL///////8DgzcD4AMgBCAQQhyGQoCAgID//wODIBFCJIiENwPYAyAEIAUpANACIhFCBIZC8P//////A4MgEEI8iIQ3A+gDIAQgBSkA2AIiEEIUiDcD+AMgBCAQQhiGQoCAgPj//wODIBFCKIiENwPwAwwVCyAGQecCTQRADB0LIAQgBSkAACITQv///////weDNwMAIAQgBSkAECIQQgeIQv///////weDNwMYIAQgBSkAICIRQg6IQv///////weDNwMwIAQgBSkAOCISQgKIQv///////weDNwNQIAQgBSkACCIUQhOGQoCA4P///weDIBNCLYiENwMIIAQgEEImhkKAgICAgPgHgyAUQhqIhDcDECAEIAUpABgiE0IMhkKA4P////8HgyAQQjSIhDcDICAEIBFCH4ZCgICAgPj/B4MgE0IhiIQ3AyggBCAFKQAoIhBCBYZC4P//////B4MgEUI7iIQ3AzggBCAFKQAwIhFCGIZCgICA+P//B4MgEEIoiIQ3A0AgBCASQiuGQoCAgICAgAaDIBFCFYiENwNIIAQgBSkASCIQQgmIQv///////weDNwNoIAQgBSkAWCIRQhCIQv///////weDNwOAASAEIAUpAHAiE0IEiEL///////8HgzcDoAEgBCAFKQBAIhRCEYZCgID4////B4MgEkIviIQ3A1ggBCAQQiSGQoCAgICA/geDIBRCHIiENwNgIAQgBSkAUCISQgqGQoD4/////weDIBBCNoiENwNwIAQgEUIdhkKAgICA/v8HgyASQiOIhDcDeCAEIAUpAGAiEEIDhkL4//////8HgyARQj2IhDcDiAEgBCAFKQBoIhFCFoZCgICA/v//B4MgEEIqiIQ3A5ABIAQgE0IphkKAgICAgMAHgyARQheIhDcDmAEgBCAFKQB4IhFCD4ZCgID+////B4MgE0IxiIQ3A6gBIAQgBSkAgAEiEEILiEL///////8HgzcDuAEgBCAQQiKGQoCAgIDA/weDIBFCHoiENwOwASAEIAUpAIgBIhFCCIZCgP7/////B4MgEEI4iIQ3A8ABIAQgBSkAkAEiEEISiEL///////8HgzcD0AEgBCAQQhuGQoCAgMD//weDIBFCJYiENwPIASAEIAUpAJgBIhFCAYZC/v//////B4MgEEI/iIQ3A9gBIAQgBSkAoAEiEkIUhkKAgMD///8HgyARQiyIhDcD4AEgBCAFKQCoASIQQgaIQv///////weDNwPwASAEIBBCJ4ZCgICAgIDwB4MgEkIZiIQ3A+gBIAQgBSkAsAEiEUINhkKAwP////8HgyAQQjOIhDcD+AEgBCAFKQC4ASIQQg2IQv///////weDNwOIAiAEIBBCIIZCgICAgPD/B4MgEUIgiIQ3A4ACIAQgBSkAwAEiEUIGhkLA//////8HgyAQQjqIhDcDkAIgBCAFKQDIASISQhmGQoCAgPD//weDIBFCJ4iENwOYAiAEIAUpANABIhBCAYhC////////B4M3A6gCIAQgEEIshkKAgICAgIAEgyASQhSIhDcDoAIgBCAFKQDYASIRQhKGQoCA8P///weDIBBCLoiENwOwAiAEIAUpAOABIhBCCIhC////////B4M3A8ACIAQgEEIlhkKAgICAgPwHgyARQhuIhDcDuAIgBCAFKQDoASIRQguGQoDw/////weDIBBCNYiENwPIAiAEIAUpAPABIhBCD4hC////////B4M3A9gCIAQgEEIehkKAgICA/P8HgyARQiKIhDcD0AIgBCAFKQD4ASIRQgSGQvD//////weDIBBCPIiENwPgAiAEIAUpAIACIhJCF4ZCgICA/P//B4MgEUIpiIQ3A+gCIAQgBSkAiAIiEEIDiEL///////8HgzcD+AIgBCAQQiqGQoCAgICAgAeDIBJCFoiENwPwAiAEIAUpAJACIhFCEIZCgID8////B4MgEEIwiIQ3A4ADIAQgBSkAmAIiEEIKiEL///////8HgzcDkAMgBCAQQiOGQoCAgICA/weDIBFCHYiENwOIAyAEIAUpAKACIhFCCYZCgPz/////B4MgEEI3iIQ3A5gDIAQgBSkAqAIiEEIRiEL///////8HgzcDqAMgBCAQQhyGQoCAgID//weDIBFCJIiENwOgAyAEIAUpALACIhFCAoZC/P//////B4MgEEI+iIQ3A7ADIAQgBSkAuAIiEkIVhkKAgID///8HgyARQiuIhDcDuAMgBCAFKQDAAiIQQgWIQv///////weDNwPIAyAEIBBCKIZCgICAgIDgB4MgEkIYiIQ3A8ADIAQgBSkAyAIiEUIOhkKAgP////8HgyAQQjKIhDcD0AMgBCAFKQDQAiIQQgyIQv///////weDNwPgAyAEIBBCIYZCgICAgOD/B4MgEUIfiIQ3A9gDIAQgBSkA2AIiEUIHhkKA//////8HgyAQQjmIhDcD6AMgBCAFKQDgAiIQQhOINwP4AyAEIBBCGoZCgICA4P//B4MgEUImiIQ3A/ADDBQLIAZB7wJNBEAMHAsgBCAFKQAAIhNC////////D4M3AwAgBCAFKQAQIhBCCohC////////D4M3AxggBCAFKQAoIhFCAohC////////D4M3AzggBCAFKQA4IhJCDIhC////////D4M3A1AgBCAFKQAIIhRCEoZCgIDw////D4MgE0IuiIQ3AwggBCAQQiSGQoCAgICA/g+DIBRCHIiENwMQIAQgBSkAGCITQgiGQoD+/////w+DIBBCOIiENwMgIAQgBSkAICIQQhqGQoCAgOD//w+DIBNCJoiENwMoIAQgEUIshkKAgICAgIAMgyAQQhSIhDcDMCAEIAUpADAiEEIQhkKAgPz///8PgyARQjCIhDcDQCAEIBJCIoZCgICAgMD/D4MgEEIeiIQ3A0ggBCAFKQBQIhBCBIhC////////D4M3A3AgBCAFKQBgIhFCDohC////////D4M3A4gBIAQgBSkAeCITQgaIQv///////w+DNwOoASAEIAUpAEAiFEIGhkLA//////8PgyASQjqIhDcDWCAEIAUpAEgiEkIYhkKAgID4//8PgyAUQiiIhDcDYCAEIBBCKoZCgICAgICAD4MgEkIWiIQ3A2ggBCAFKQBYIhJCDoZCgID/////D4MgEEIyiIQ3A3ggBCARQiCGQoCAgIDw/w+DIBJCIIiENwOAASAEIAUpAGgiEEIEhkLw//////8PgyARQjyIhDcDkAEgBCAFKQBwIhFCFoZCgICA/v//D4MgEEIqiIQ3A5gBIAQgE0IohkKAgICAgOAPgyARQhiIhDcDoAEgBCAFKQCAASIRQgyGQoDg/////w+DIBNCNIiENwOwASAEIAUpAIgBIhBCEIhC////////D4M3A8ABIAQgEEIehkKAgICA/P8PgyARQiKIhDcDuAEgBCAFKQCQASIRQgKGQvz//////w+DIBBCPoiENwPIASAEIAUpAJgBIhJCFIZCgIDA////D4MgEUIsiIQ3A9ABIAQgBSkAoAEiEEIIiEL///////8PgzcD4AEgBCAQQiaGQoCAgICA+A+DIBJCGoiENwPYASAEIAUpAKgBIhFCCoZCgPj/////D4MgEEI2iIQ3A+gBIAQgBSkAsAEiEEISiDcD+AEgBCAQQhyGQoCAgID//w+DIBFCJIiENwPwASAEIAUpALgBIhBC////////D4M3A4ACIAQgBSkAwAEiEUIShkKAgPD///8PgyAQQi6IhDcDiAIgBCAFKQDIASIQQgqIQv///////w+DNwOYAiAEIBBCJIZCgICAgID+D4MgEUIciIQ3A5ACIAQgBSkA0AEiEUIIhkKA/v////8PgyAQQjiIhDcDoAIgBCAFKQDYASISQhqGQoCAgOD//w+DIBFCJoiENwOoAiAEIAUpAOABIhBCAohC////////D4M3A7gCIAQgEEIshkKAgICAgIAMgyASQhSIhDcDsAIgBCAFKQDoASIRQhCGQoCA/P///w+DIBBCMIiENwPAAiAEIAUpAPABIhBCDIhC////////D4M3A9ACIAQgEEIihkKAgICAwP8PgyARQh6IhDcDyAIgBCAFKQD4ASIRQgaGQsD//////w+DIBBCOoiENwPYAiAEIAUpAIACIhJCGIZCgICA+P//D4MgEUIoiIQ3A+ACIAQgBSkAiAIiEEIEiEL///////8PgzcD8AIgBCAQQiqGQoCAgICAgA+DIBJCFoiENwPoAiAEIAUpAJACIhFCDoZCgID/////D4MgEEIyiIQ3A/gCIAQgBSkAmAIiEEIOiEL///////8PgzcDiAMgBCAQQiCGQoCAgIDw/w+DIBFCIIiENwOAAyAEIAUpAKACIhFCBIZC8P//////D4MgEEI8iIQ3A5ADIAQgBSkAqAIiEkIWhkKAgID+//8PgyARQiqIhDcDmAMgBCAFKQCwAiIQQgaIQv///////w+DNwOoAyAEIBBCKIZCgICAgIDgD4MgEkIYiIQ3A6ADIAQgBSkAuAIiEUIMhkKA4P////8PgyAQQjSIhDcDsAMgBCAFKQDAAiIQQhCIQv///////w+DNwPAAyAEIBBCHoZCgICAgPz/D4MgEUIiiIQ3A7gDIAQgBSkAyAIiEUIChkL8//////8PgyAQQj6IhDcDyAMgBCAFKQDQAiISQhSGQoCAwP///w+DIBFCLIiENwPQAyAEIAUpANgCIhBCCIhC////////D4M3A+ADIAQgEEImhkKAgICAgPgPgyASQhqIhDcD2AMgBCAFKQDgAiIRQgqGQoD4/////w+DIBBCNoiENwPoAyAEIAUpAOgCIhBCEog3A/gDIAQgEEIchkKAgICA//8PgyARQiSIhDcD8AMMEwsgBkH3Ak0EQAwbCyAEIAUpAAAiEkL///////8fgzcDACAEIAUpABAiEEINiEL///////8fgzcDGCAEIAUpACgiEUIJiEL///////8fgzcDOCAEIAUpAAgiE0IRhkKAgPj///8fgyASQi+IhDcDCCAEIBBCIoZCgICAgMD/H4MgE0IeiIQ3AxAgBCAFKQAYIhJCBIZC8P//////H4MgEEI8iIQ3AyAgBCAFKQAgIhBCFYZCgICA////H4MgEkIriIQ3AyggBCARQiaGQoCAgICA+B+DIBBCGoiENwMwIAQgBSkAMCIQQgiGQoD+/////x+DIBFCOIiENwNAIAQgBSkAOCIRQhmGQoCAgPD//x+DIBBCJ4iENwNIIAQgBSkAQCIQQgWIQv///////x+DNwNYIAQgEEIqhkKAgICAgIAfgyARQhaIhDcDUCAEIAUpAFgiEUIBiEL///////8fgzcDeCAEIAUpAGgiEkIOiEL///////8fgzcDkAEgBCAFKQBIIhNCDIZCgOD/////H4MgEEI0iIQ3A2AgBCAFKQBQIhBCHYZCgICAgP7/H4MgE0IjiIQ3A2ggBCARQi6GQoCAgICAgBCDIBBCEoiENwNwIAQgBSkAYCIQQhCGQoCA/P///x+DIBFCMIiENwOAASAEIBJCIYZCgICAgOD/H4MgEEIfiIQ3A4gBIAQgBSkAcCIQQgOGQvj//////x+DIBJCPYiENwOYASAEIAUpAHgiEUIUhkKAgMD///8fgyAQQiyIhDcDoAEgBCAFKQCAASIQQgqIQv///////x+DNwOwASAEIBBCJYZCgICAgID8H4MgEUIbiIQ3A6gBIAQgBSkAiAEiEUIHhkKA//////8fgyAQQjmIhDcDuAEgBCAFKQCQASISQhiGQoCAgPj//x+DIBFCKIiENwPAASAEIAUpAJgBIhBCBohC////////H4M3A9ABIAQgEEIphkKAgICAgMAfgyASQheIhDcDyAEgBCAFKQCgASIRQguGQoDw/////x+DIBBCNYiENwPYASAEIAUpAKgBIhJCHIZCgICAgP//H4MgEUIkiIQ3A+ABIAQgBSkAsAEiEEICiEL///////8fgzcD8AEgBCAQQi2GQoCAgICAgBiDIBJCE4iENwPoASAEIAUpALgBIhFCD4ZCgID+////H4MgEEIxiIQ3A/gBIAQgBSkAwAEiEEIPiEL///////8fgzcDiAIgBCAQQiCGQoCAgIDw/x+DIBFCIIiENwOAAiAEIAUpAMgBIhFCAoZC/P//////H4MgEEI+iIQ3A5ACIAQgBSkA0AEiEkIThkKAgOD///8fgyARQi2IhDcDmAIgBCAFKQDYASIQQguIQv///////x+DNwOoAiAEIBBCJIZCgICAgID+H4MgEkIciIQ3A6ACIAQgBSkA4AEiEUIGhkLA//////8fgyAQQjqIhDcDsAIgBCAFKQDoASISQheGQoCAgPz//x+DIBFCKYiENwO4AiAEIAUpAPABIhBCB4hC////////H4M3A8gCIAQgEEIohkKAgICAgOAfgyASQhiIhDcDwAIgBCAFKQD4ASIRQgqGQoD4/////x+DIBBCNoiENwPQAiAEIAUpAIACIhJCG4ZCgICAwP//H4MgEUIliIQ3A9gCIAQgBSkAiAIiEEIDiEL///////8fgzcD6AIgBCAQQiyGQoCAgICAgByDIBJCFIiENwPgAiAEIAUpAJACIhFCDoZCgID/////H4MgEEIyiIQ3A/ACIAQgBSkAmAIiEEIQiEL///////8fgzcDgAMgBCAQQh+GQoCAgID4/x+DIBFCIYiENwP4AiAEIAUpAKACIhFCAYZC/v//////H4MgEEI/iIQ3A4gDIAQgBSkAqAIiEkIShkKAgPD///8fgyARQi6IhDcDkAMgBCAFKQCwAiIQQgyIQv///////x+DNwOgAyAEIBBCI4ZCgICAgID/H4MgEkIdiIQ3A5gDIAQgBSkAuAIiEUIFhkLg//////8fgyAQQjuIhDcDqAMgBCAFKQDAAiISQhaGQoCAgP7//x+DIBFCKoiENwOwAyAEIAUpAMgCIhBCCIhC////////H4M3A8ADIAQgEEInhkKAgICAgPAfgyASQhmIhDcDuAMgBCAFKQDQAiIRQgmGQoD8/////x+DIBBCN4iENwPIAyAEIAUpANgCIhJCGoZCgICA4P//H4MgEUImiIQ3A9ADIAQgBSkA4AIiEEIEiEL///////8fgzcD4AMgBCAQQiuGQoCAgICAgB6DIBJCFYiENwPYAyAEIAUpAOgCIhFCDYZCgMD/////H4MgEEIziIQ3A+gDIAQgBSkA8AIiEEIRiDcD+AMgBCAQQh6GQoCAgID8/x+DIBFCIoiENwPwAwwSCyAGQf8CTQRADBoLIAQgBSkAACIQQv///////z+DNwMAIAQgBSkAECIRQhCINwMYIAQgBSkAGCISQv///////z+DNwMgIAQgBSkAKCITQhCINwM4IAQgBSkAMCIUQv///////z+DNwNAIAQgBSkACCIVQhCGQoCA/P///z+DIBBCMIiENwMIIAQgEUIghkKAgICA8P8/gyAVQiCIhDcDECAEIAUpACAiEEIQhkKAgPz///8/gyASQjCIhDcDKCAEIBNCIIZCgICAgPD/P4MgEEIgiIQ3AzAgBCAFKQA4IhBCEIZCgID8////P4MgFEIwiIQ3A0ggBCAFKQBAIhFCEIg3A1ggBCARQiCGQoCAgIDw/z+DIBBCIIiENwNQIAQgBSkASCIQQv///////z+DNwNgIAQgBSkAWCIRQhCINwN4IAQgBSkAYCISQv///////z+DNwOAASAEIAUpAHAiE0IQiDcDmAEgBCAFKQB4IhRC////////P4M3A6ABIAQgBSkAUCIVQhCGQoCA/P///z+DIBBCMIiENwNoIAQgEUIghkKAgICA8P8/gyAVQiCIhDcDcCAEIAUpAGgiEEIQhkKAgPz///8/gyASQjCIhDcDiAEgBCATQiCGQoCAgIDw/z+DIBBCIIiENwOQASAEIAUpAIABIhBCEIZCgID8////P4MgFEIwiIQ3A6gBIAQgBSkAiAEiEUIQiDcDuAEgBCARQiCGQoCAgIDw/z+DIBBCIIiENwOwASAEIAUpAJABIhBC////////P4M3A8ABIAQgBSkAmAEiEUIQhkKAgPz///8/gyAQQjCIhDcDyAEgBCAFKQCgASIQQhCINwPYASAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A9ABIAQgBSkAqAEiEEL///////8/gzcD4AEgBCAFKQCwASIRQhCGQoCA/P///z+DIBBCMIiENwPoASAEIAUpALgBIhBCEIg3A/gBIAQgEEIghkKAgICA8P8/gyARQiCIhDcD8AEgBCAFKQDAASIQQv///////z+DNwOAAiAEIAUpAMgBIhFCEIZCgID8////P4MgEEIwiIQ3A4gCIAQgBSkA0AEiEEIQiDcDmAIgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwOQAiAEIAUpANgBIhBC////////P4M3A6ACIAQgBSkA4AEiEUIQhkKAgPz///8/gyAQQjCIhDcDqAIgBCAFKQDoASIQQhCINwO4AiAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A7ACIAQgBSkA8AEiEEL///////8/gzcDwAIgBCAFKQD4ASIRQhCGQoCA/P///z+DIBBCMIiENwPIAiAEIAUpAIACIhBCEIg3A9gCIAQgEEIghkKAgICA8P8/gyARQiCIhDcD0AIgBCAFKQCIAiIQQv///////z+DNwPgAiAEIAUpAJACIhFCEIZCgID8////P4MgEEIwiIQ3A+gCIAQgBSkAmAIiEEIQiDcD+AIgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwPwAiAEIAUpAKACIhBC////////P4M3A4ADIAQgBSkAqAIiEUIQhkKAgPz///8/gyAQQjCIhDcDiAMgBCAFKQCwAiIQQhCINwOYAyAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A5ADIAQgBSkAuAIiEEL///////8/gzcDoAMgBCAFKQDAAiIRQhCGQoCA/P///z+DIBBCMIiENwOoAyAEIAUpAMgCIhBCEIg3A7gDIAQgEEIghkKAgICA8P8/gyARQiCIhDcDsAMgBCAFKQDQAiIQQv///////z+DNwPAAyAEIAUpANgCIhFCEIZCgID8////P4MgEEIwiIQ3A8gDIAQgBSkA4AIiEEIQiDcD2AMgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwPQAyAEIAUpAOgCIhBC////////P4M3A+ADIAQgBSkA8AIiEUIQhkKAgPz///8/gyAQQjCIhDcD6AMgBCAFKQD4AiIQQhCINwP4AyAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A/ADDBELIAZBhwNNBEAMGQsgBCAFKQAAIhJC/////////wCDNwMAIAQgBSkAGCIQQgSIQv////////8AgzcDICAEIAUpADAiEUIIiEL/////////AIM3A0AgBCAFKQAIIhNCD4ZCgID+/////wCDIBJCMYiENwMIIAQgBSkAECISQh6GQoCAgID8//8AgyATQiKIhDcDECAEIBBCLYZCgICAgICA+ACDIBJCE4iENwMYIAQgBSkAICISQguGQoDw//////8AgyAQQjWIhDcDKCAEIAUpACgiEEIahkKAgIDg////AIMgEkImiIQ3AzAgBCARQimGQoCAgICAwP8AgyAQQheIhDcDOCAEIAUpADgiEEIHhkKA////////AIMgEUI5iIQ3A0ggBCAFKQBAIhNCFoZCgICA/v///wCDIBBCKoiENwNQIAQgBSkASCIQQgyIQv////////8AgzcDYCAEIAUpAGgiEUIBiEL/////////AIM3A4gBIAQgBSkAgAEiEkIFiEL/////////AIM3A6gBIAQgEEIlhkKAgICAgPz/AIMgE0IbiIQ3A1ggBCAFKQBQIhNCA4ZC+P///////wCDIBBCPYiENwNoIAQgBSkAWCIQQhKGQoCA8P////8AgyATQi6IhDcDcCAEIAUpAGAiE0IhhkKAgICA4P//AIMgEEIfiIQ3A3ggBCARQjCGQoCAgICAgMAAgyATQhCIhDcDgAEgBCAFKQBwIhBCDoZCgID//////wCDIBFCMoiENwOQASAEIAUpAHgiEUIdhkKAgICA/v//AIMgEEIjiIQ3A5gBIAQgEkIshkKAgICAgID8AIMgEUIUiIQ3A6ABIAQgBSkAiAEiEEIKhkKA+P//////AIMgEkI2iIQ3A7ABIAQgBSkAkAEiEUIZhkKAgIDw////AIMgEEIniIQ3A7gBIAQgBSkAmAEiEEIJiEL/////////AIM3A8gBIAQgEEIohkKAgICAgOD/AIMgEUIYiIQ3A8ABIAQgBSkAoAEiEUIGhkLA////////AIMgEEI6iIQ3A9ABIAQgBSkAqAEiEkIVhkKAgID/////AIMgEUIriIQ3A9gBIAQgBSkAsAEiEEINiEL/////////AIM3A+gBIAQgEEIkhkKAgICAgP7/AIMgEkIciIQ3A+ABIAQgBSkAuAEiEUIChkL8////////AIMgEEI+iIQ3A/ABIAQgBSkAwAEiEEIRhkKAgPj/////AIMgEUIviIQ3A/gBIAQgBSkAyAEiEUIghkKAgICA8P//AIMgEEIgiIQ3A4ACIAQgBSkA0AEiEEICiEL/////////AIM3A5ACIAQgEEIvhkKAgICAgIDgAIMgEUIRiIQ3A4gCIAQgBSkA2AEiEUINhkKAwP//////AIMgEEIziIQ3A5gCIAQgBSkA4AEiEkIchkKAgICA////AIMgEUIkiIQ3A6ACIAQgBSkA6AEiEEIGiEL/////////AIM3A7ACIAQgEEIrhkKAgICAgID+AIMgEkIViIQ3A6gCIAQgBSkA8AEiEUIJhkKA/P//////AIMgEEI3iIQ3A7gCIAQgBSkA+AEiEkIYhkKAgID4////AIMgEUIoiIQ3A8ACIAQgBSkAgAIiEEIKiEL/////////AIM3A9ACIAQgEEInhkKAgICAgPD/AIMgEkIZiIQ3A8gCIAQgBSkAiAIiEUIFhkLg////////AIMgEEI7iIQ3A9gCIAQgBSkAkAIiEkIUhkKAgMD/////AIMgEUIsiIQ3A+ACIAQgBSkAmAIiEEIOiEL/////////AIM3A/ACIAQgEEIjhkKAgICAgP//AIMgEkIdiIQ3A+gCIAQgBSkAoAIiEUIBhkL+////////AIMgEEI/iIQ3A/gCIAQgBSkAqAIiEEIQhkKAgPz/////AIMgEUIwiIQ3A4ADIAQgBSkAsAIiEUIfhkKAgICA+P//AIMgEEIhiIQ3A4gDIAQgBSkAuAIiEEIDiEL/////////AIM3A5gDIAQgEEIuhkKAgICAgIDwAIMgEUISiIQ3A5ADIAQgBSkAwAIiEUIMhkKA4P//////AIMgEEI0iIQ3A6ADIAQgBSkAyAIiEkIbhkKAgIDA////AIMgEUIliIQ3A6gDIAQgBSkA0AIiEEIHiEL/////////AIM3A7gDIAQgEEIqhkKAgICAgID/AIMgEkIWiIQ3A7ADIAQgBSkA2AIiEUIIhkKA/v//////AIMgEEI4iIQ3A8ADIAQgBSkA4AIiEkIXhkKAgID8////AIMgEUIpiIQ3A8gDIAQgBSkA6AIiEEILiEL/////////AIM3A9gDIAQgEEImhkKAgICAgPj/AIMgEkIaiIQ3A9ADIAQgBSkA8AIiEUIEhkLw////////AIMgEEI8iIQ3A+ADIAQgBSkA+AIiEEIThkKAgOD/////AIMgEUItiIQ3A+gDIAQgBSkAgAMiEUIPiDcD+AMgBCARQiKGQoCAgIDA//8AgyAQQh6IhDcD8AMMEAsgBkGPA00EQAwYCyAEIAUpAAAiEkL/////////AYM3AwAgBCAFKQAYIhBCCIhC/////////wGDNwMgIAQgBSkAOCIRQgKIQv////////8BgzcDSCAEIAUpAAgiE0IOhkKAgP//////AYMgEkIyiIQ3AwggBCAFKQAQIhJCHIZCgICAgP///wGDIBNCJIiENwMQIAQgEEIqhkKAgICAgID/AYMgEkIWiIQ3AxggBCAFKQAgIhJCBoZCwP///////wGDIBBCOoiENwMoIAQgBSkAKCIQQhSGQoCAwP////8BgyASQiyIhDcDMCAEIAUpADAiEkIihkKAgICAwP//AYMgEEIeiIQ3AzggBCARQjCGQoCAgICAgMABgyASQhCIhDcDQCAEIAUpAEAiEkIMhkKA4P//////AYMgEUI0iIQ3A1AgBCAFKQBQIhBCCohC/////////wGDNwNoIAQgBSkAcCIRQgSIQv////////8BgzcDkAEgBCAFKQBIIhNCGoZCgICA4P///wGDIBJCJoiENwNYIAQgEEIohkKAgICAgOD/AYMgE0IYiIQ3A2AgBCAFKQBYIhJCBIZC8P///////wGDIBBCPIiENwNwIAQgBSkAYCIQQhKGQoCA8P////8BgyASQi6IhDcDeCAEIAUpAGgiEkIghkKAgICA8P//AYMgEEIgiIQ3A4ABIAQgEUIuhkKAgICAgIDwAYMgEkISiIQ3A4gBIAQgBSkAeCIQQgqGQoD4//////8BgyARQjaIhDcDmAEgBCAFKQCAASIRQhiGQoCAgPj///8BgyAQQiiIhDcDoAEgBCAFKQCIASIQQgyIQv////////8BgzcDsAEgBCAQQiaGQoCAgICA+P8BgyARQhqIhDcDqAEgBCAFKQCQASIRQgKGQvz///////8BgyAQQj6IhDcDuAEgBCAFKQCYASIQQhCGQoCA/P////8BgyARQjCIhDcDwAEgBCAFKQCgASIRQh6GQoCAgID8//8BgyAQQiKIhDcDyAEgBCAFKQCoASIQQgaIQv////////8BgzcD2AEgBCAQQiyGQoCAgICAgPwBgyARQhSIhDcD0AEgBCAFKQCwASIRQgiGQoD+//////8BgyAQQjiIhDcD4AEgBCAFKQC4ASIQQhaGQoCAgP7///8BgyARQiqIhDcD6AEgBCAFKQDAASIRQg6INwP4ASAEIBFCJIZCgICAgID+/wGDIBBCHIiENwPwASAEIAUpAMgBIhBC/////////wGDNwOAAiAEIAUpANABIhFCDoZCgID//////wGDIBBCMoiENwOIAiAEIAUpANgBIhJCHIZCgICAgP///wGDIBFCJIiENwOQAiAEIAUpAOABIhBCCIhC/////////wGDNwOgAiAEIBBCKoZCgICAgICA/wGDIBJCFoiENwOYAiAEIAUpAOgBIhFCBoZCwP///////wGDIBBCOoiENwOoAiAEIAUpAPABIhBCFIZCgIDA/////wGDIBFCLIiENwOwAiAEIAUpAPgBIhFCIoZCgICAgMD//wGDIBBCHoiENwO4AiAEIAUpAIACIhBCAohC/////////wGDNwPIAiAEIBBCMIZCgICAgICAwAGDIBFCEIiENwPAAiAEIAUpAIgCIhFCDIZCgOD//////wGDIBBCNIiENwPQAiAEIAUpAJACIhJCGoZCgICA4P///wGDIBFCJoiENwPYAiAEIAUpAJgCIhBCCohC/////////wGDNwPoAiAEIBBCKIZCgICAgIDg/wGDIBJCGIiENwPgAiAEIAUpAKACIhFCBIZC8P///////wGDIBBCPIiENwPwAiAEIAUpAKgCIhBCEoZCgIDw/////wGDIBFCLoiENwP4AiAEIAUpALACIhFCIIZCgICAgPD//wGDIBBCIIiENwOAAyAEIAUpALgCIhBCBIhC/////////wGDNwOQAyAEIBBCLoZCgICAgICA8AGDIBFCEoiENwOIAyAEIAUpAMACIhFCCoZCgPj//////wGDIBBCNoiENwOYAyAEIAUpAMgCIhJCGIZCgICA+P///wGDIBFCKIiENwOgAyAEIAUpANACIhBCDIhC/////////wGDNwOwAyAEIBBCJoZCgICAgID4/wGDIBJCGoiENwOoAyAEIAUpANgCIhFCAoZC/P///////wGDIBBCPoiENwO4AyAEIAUpAOACIhBCEIZCgID8/////wGDIBFCMIiENwPAAyAEIAUpAOgCIhFCHoZCgICAgPz//wGDIBBCIoiENwPIAyAEIAUpAPACIhBCBohC/////////wGDNwPYAyAEIBBCLIZCgICAgICA/AGDIBFCFIiENwPQAyAEIAUpAPgCIhFCCIZCgP7//////wGDIBBCOIiENwPgAyAEIAUpAIADIhBCFoZCgICA/v///wGDIBFCKoiENwPoAyAEIAUpAIgDIhFCDog3A/gDIAQgEUIkhkKAgICAgP7/AYMgEEIciIQ3A/ADDA8LIAZBlwNNBEAMFwsgBCAFKQAAIhJC/////////wODNwMAIAQgBSkAGCIQQgyIQv////////8DgzcDICAEIAUpADgiEUILiEL/////////A4M3A0ggBCAFKQAIIhNCDYZCgMD//////wODIBJCM4iENwMIIAQgBSkAECISQhqGQoCAgOD///8DgyATQiaIhDcDECAEIBBCJ4ZCgICAgIDw/wODIBJCGYiENwMYIAQgBSkAICISQgGGQv7///////8DgyAQQj+IhDcDKCAEIAUpACgiEEIOhkKAgP//////A4MgEkIyiIQ3AzAgBCAFKQAwIhJCG4ZCgICAwP///wODIBBCJYiENwM4IAQgEUIohkKAgICAgOD/A4MgEkIYiIQ3A0AgBCAFKQBAIhJCAoZC/P///////wODIBFCPoiENwNQIAQgBSkAWCIQQgqIQv////////8DgzcDcCAEIAUpAHgiEUIJiEL/////////A4M3A5gBIAQgBSkASCITQg+GQoCA/v////8DgyASQjGIhDcDWCAEIAUpAFAiEkIchkKAgICA////A4MgE0IkiIQ3A2AgBCAQQimGQoCAgICAwP8DgyASQheIhDcDaCAEIAUpAGAiEkIDhkL4////////A4MgEEI9iIQ3A3ggBCAFKQBoIhBCEIZCgID8/////wODIBJCMIiENwOAASAEIAUpAHAiEkIdhkKAgICA/v//A4MgEEIjiIQ3A4gBIAQgEUIqhkKAgICAgID/A4MgEkIWiIQ3A5ABIAQgBSkAgAEiEEIEhkLw////////A4MgEUI8iIQ3A6ABIAQgBSkAiAEiEUIRhkKAgPj/////A4MgEEIviIQ3A6gBIAQgBSkAkAEiEkIehkKAgICA/P//A4MgEUIiiIQ3A7ABIAQgBSkAmAEiEEIIiEL/////////A4M3A8ABIAQgEEIrhkKAgICAgID+A4MgEkIViIQ3A7gBIAQgBSkAoAEiEUIFhkLg////////A4MgEEI7iIQ3A8gBIAQgBSkAqAEiEEIShkKAgPD/////A4MgEUIuiIQ3A9ABIAQgBSkAsAEiEUIfhkKAgICA+P//A4MgEEIhiIQ3A9gBIAQgBSkAuAEiEEIHiEL/////////A4M3A+gBIAQgEEIshkKAgICAgID8A4MgEUIUiIQ3A+ABIAQgBSkAwAEiEUIGhkLA////////A4MgEEI6iIQ3A/ABIAQgBSkAyAEiEEIThkKAgOD/////A4MgEUItiIQ3A/gBIAQgBSkA0AEiEUIghkKAgICA8P//A4MgEEIgiIQ3A4ACIAQgBSkA2AEiEEIGiEL/////////A4M3A5ACIAQgEEIthkKAgICAgID4A4MgEUITiIQ3A4gCIAQgBSkA4AEiEUIHhkKA////////A4MgEEI5iIQ3A5gCIAQgBSkA6AEiEEIUhkKAgMD/////A4MgEUIsiIQ3A6ACIAQgBSkA8AEiEUIhhkKAgICA4P//A4MgEEIfiIQ3A6gCIAQgBSkA+AEiEEIFiEL/////////A4M3A7gCIAQgEEIuhkKAgICAgIDwA4MgEUISiIQ3A7ACIAQgBSkAgAIiEUIIhkKA/v//////A4MgEEI4iIQ3A8ACIAQgBSkAiAIiEEIVhkKAgID/////A4MgEUIriIQ3A8gCIAQgBSkAkAIiEUIihkKAgICAwP//A4MgEEIeiIQ3A9ACIAQgBSkAmAIiEEIEiEL/////////A4M3A+ACIAQgEEIvhkKAgICAgIDgA4MgEUIRiIQ3A9gCIAQgBSkAoAIiEUIJhkKA/P//////A4MgEEI3iIQ3A+gCIAQgBSkAqAIiEEIWhkKAgID+////A4MgEUIqiIQ3A/ACIAQgBSkAsAIiEUIjhkKAgICAgP//A4MgEEIdiIQ3A/gCIAQgBSkAuAIiEEIDiEL/////////A4M3A4gDIAQgEEIwhkKAgICAgIDAA4MgEUIQiIQ3A4ADIAQgBSkAwAIiEUIKhkKA+P//////A4MgEEI2iIQ3A5ADIAQgBSkAyAIiEEIXhkKAgID8////A4MgEUIpiIQ3A5gDIAQgBSkA0AIiEUIkhkKAgICAgP7/A4MgEEIciIQ3A6ADIAQgBSkA2AIiEEICiEL/////////A4M3A7ADIAQgEEIxhkKAgICAgICAA4MgEUIPiIQ3A6gDIAQgBSkA4AIiEUILhkKA8P//////A4MgEEI1iIQ3A7gDIAQgBSkA6AIiEEIYhkKAgID4////A4MgEUIoiIQ3A8ADIAQgBSkA8AIiEUIlhkKAgICAgPz/A4MgEEIbiIQ3A8gDIAQgBSkA+AIiEEIBiEL/////////A4M3A9gDIAQgEEIyhkKAgICAgICAAoMgEUIOiIQ3A9ADIAQgBSkAgAMiEUIMhkKA4P//////A4MgEEI0iIQ3A+ADIAQgBSkAiAMiEEIZhkKAgIDw////A4MgEUIniIQ3A+gDIAQgBSkAkAMiEUINiDcD+AMgBCARQiaGQoCAgICA+P8DgyAQQhqIhDcD8AMMDgsgBkGfA00EQAwWCyAEIAUpAAAiEkL/////////B4M3AwAgBCAFKQAgIhBCBIhC/////////weDNwMoIAQgBSkAQCIRQgiIQv////////8HgzcDUCAEIAUpAAgiE0IMhkKA4P//////B4MgEkI0iIQ3AwggBCAFKQAQIhJCGIZCgICA+P///weDIBNCKIiENwMQIAQgBSkAGCITQiSGQoCAgICA/v8HgyASQhyIhDcDGCAEIBBCMIZCgICAgICAwAeDIBNCEIiENwMgIAQgBSkAKCISQgiGQoD+//////8HgyAQQjiIhDcDMCAEIAUpADAiEEIUhkKAgMD/////B4MgEkIsiIQ3AzggBCAFKQA4IhJCIIZCgICAgPD//weDIBBCIIiENwNAIAQgEUIshkKAgICAgID8B4MgEkIUiIQ3A0ggBCAFKQBgIhJCDIg3A3ggBCAFKQBoIhNC/////////weDNwOAASAEIAUpAIgBIhBCBIhC/////////weDNwOoASAEIAUpAEgiFEIEhkLw////////B4MgEUI8iIQ3A1ggBCAFKQBQIhFCEIZCgID8/////weDIBRCMIiENwNgIAQgBSkAWCIUQhyGQoCAgID///8HgyARQiSIhDcDaCAEIBJCKIZCgICAgIDg/weDIBRCGIiENwNwIAQgBSkAcCIRQgyGQoDg//////8HgyATQjSIhDcDiAEgBCAFKQB4IhJCGIZCgICA+P///weDIBFCKIiENwOQASAEIAUpAIABIhFCJIZCgICAgID+/weDIBJCHIiENwOYASAEIBBCMIZCgICAgICAwAeDIBFCEIiENwOgASAEIAUpAJABIhFCCIZCgP7//////weDIBBCOIiENwOwASAEIAUpAJgBIhBCFIZCgIDA/////weDIBFCLIiENwO4ASAEIAUpAKABIhFCIIZCgICAgPD//weDIBBCIIiENwPAASAEIAUpAKgBIhBCCIhC/////////weDNwPQASAEIBBCLIZCgICAgICA/AeDIBFCFIiENwPIASAEIAUpALABIhFCBIZC8P///////weDIBBCPIiENwPYASAEIAUpALgBIhBCEIZCgID8/////weDIBFCMIiENwPgASAEIAUpAMABIhFCHIZCgICAgP///weDIBBCJIiENwPoASAEIAUpAMgBIhBCDIg3A/gBIAQgEEIohkKAgICAgOD/B4MgEUIYiIQ3A/ABIAQgBSkA0AEiEEL/////////B4M3A4ACIAQgBSkA2AEiEUIMhkKA4P//////B4MgEEI0iIQ3A4gCIAQgBSkA4AEiEEIYhkKAgID4////B4MgEUIoiIQ3A5ACIAQgBSkA6AEiEUIkhkKAgICAgP7/B4MgEEIciIQ3A5gCIAQgBSkA8AEiEEIEiEL/////////B4M3A6gCIAQgEEIwhkKAgICAgIDAB4MgEUIQiIQ3A6ACIAQgBSkA+AEiEUIIhkKA/v//////B4MgEEI4iIQ3A7ACIAQgBSkAgAIiEEIUhkKAgMD/////B4MgEUIsiIQ3A7gCIAQgBSkAiAIiEUIghkKAgICA8P//B4MgEEIgiIQ3A8ACIAQgBSkAkAIiEEIIiEL/////////B4M3A9ACIAQgEEIshkKAgICAgID8B4MgEUIUiIQ3A8gCIAQgBSkAmAIiEUIEhkLw////////B4MgEEI8iIQ3A9gCIAQgBSkAoAIiEEIQhkKAgPz/////B4MgEUIwiIQ3A+ACIAQgBSkAqAIiEUIchkKAgICA////B4MgEEIkiIQ3A+gCIAQgBSkAsAIiEEIMiDcD+AIgBCAQQiiGQoCAgICA4P8HgyARQhiIhDcD8AIgBCAFKQC4AiIQQv////////8HgzcDgAMgBCAFKQDAAiIRQgyGQoDg//////8HgyAQQjSIhDcDiAMgBCAFKQDIAiIQQhiGQoCAgPj///8HgyARQiiIhDcDkAMgBCAFKQDQAiIRQiSGQoCAgICA/v8HgyAQQhyIhDcDmAMgBCAFKQDYAiIQQgSIQv////////8HgzcDqAMgBCAQQjCGQoCAgICAgMAHgyARQhCIhDcDoAMgBCAFKQDgAiIRQgiGQoD+//////8HgyAQQjiIhDcDsAMgBCAFKQDoAiIQQhSGQoCAwP////8HgyARQiyIhDcDuAMgBCAFKQDwAiIRQiCGQoCAgIDw//8HgyAQQiCIhDcDwAMgBCAFKQD4AiIQQgiIQv////////8HgzcD0AMgBCAQQiyGQoCAgICAgPwHgyARQhSIhDcDyAMgBCAFKQCAAyIRQgSGQvD///////8HgyAQQjyIhDcD2AMgBCAFKQCIAyIQQhCGQoCA/P////8HgyARQjCIhDcD4AMgBCAFKQCQAyIRQhyGQoCAgID///8HgyAQQiSIhDcD6AMgBCAFKQCYAyIQQgyINwP4AyAEIBBCKIZCgICAgIDg/weDIBFCGIiENwPwAwwNCyAGQacDTQRADBULIAQgBSkAACIRQv////////8PgzcDACAEIAUpACAiEEIJiEL/////////D4M3AyggBCAFKQAIIhJCC4ZCgPD//////w+DIBFCNYiENwMIIAQgBSkAECIRQhaGQoCAgP7///8PgyASQiqIhDcDECAEIAUpABgiEkIhhkKAgICA4P//D4MgEUIfiIQ3AxggBCAQQiyGQoCAgICAgPwPgyASQhSIhDcDICAEIAUpACgiEUIChkL8////////D4MgEEI+iIQ3AzAgBCAFKQAwIhBCDYZCgMD//////w+DIBFCM4iENwM4IAQgBSkAOCIRQhiGQoCAgPj///8PgyAQQiiIhDcDQCAEIAUpAEAiEkIjhkKAgICAgP//D4MgEUIdiIQ3A0ggBCAFKQBIIhBCB4hC/////////w+DNwNYIAQgBSkAcCIRQgWIQv////////8PgzcDiAEgBCAQQi6GQoCAgICAgPAPgyASQhKIhDcDUCAEIAUpAFAiEkIEhkLw////////D4MgEEI8iIQ3A2AgBCAFKQBYIhBCD4ZCgID+/////w+DIBJCMYiENwNoIAQgBSkAYCISQhqGQoCAgOD///8PgyAQQiaIhDcDcCAEIAUpAGgiEEIlhkKAgICAgPz/D4MgEkIbiIQ3A3ggBCARQjCGQoCAgICAgMAPgyAQQhCIhDcDgAEgBCAFKQB4IhBCBoZCwP///////w+DIBFCOoiENwOQASAEIAUpAIABIhFCEYZCgID4/////w+DIBBCL4iENwOYASAEIAUpAIgBIhBCHIZCgICAgP///w+DIBFCJIiENwOgASAEIAUpAJABIhFCJ4ZCgICAgIDw/w+DIBBCGYiENwOoASAEIAUpAJgBIhBCA4hC/////////w+DNwO4ASAEIBBCMoZCgICAgICAgA6DIBFCDoiENwOwASAEIAUpAKABIhFCCIZCgP7//////w+DIBBCOIiENwPAASAEIAUpAKgBIhBCE4ZCgIDg/////w+DIBFCLYiENwPIASAEIAUpALABIhFCHoZCgICAgPz//w+DIBBCIoiENwPQASAEIAUpALgBIhJCKYZCgICAgIDA/w+DIBFCF4iENwPYASAEIAUpAMABIhBCAYhC/////////w+DNwPoASAEIBBCNIZCgICAgICAgAiDIBJCDIiENwPgASAEIAUpAMgBIhFCCoZCgPj//////w+DIBBCNoiENwPwASAEIAUpANABIhBCFYZCgICA/////w+DIBFCK4iENwP4ASAEIAUpANgBIhFCIIZCgICAgPD//w+DIBBCIIiENwOAAiAEIAUpAOABIhBCCohC/////////w+DNwOQAiAEIBBCK4ZCgICAgICA/g+DIBFCFYiENwOIAiAEIAUpAOgBIhFCAYZC/v///////w+DIBBCP4iENwOYAiAEIAUpAPABIhBCDIZCgOD//////w+DIBFCNIiENwOgAiAEIAUpAPgBIhFCF4ZCgICA/P///w+DIBBCKYiENwOoAiAEIAUpAIACIhJCIoZCgICAgMD//w+DIBFCHoiENwOwAiAEIAUpAIgCIhBCCIhC/////////w+DNwPAAiAEIBBCLYZCgICAgICA+A+DIBJCE4iENwO4AiAEIAUpAJACIhFCA4ZC+P///////w+DIBBCPYiENwPIAiAEIAUpAJgCIhBCDoZCgID//////w+DIBFCMoiENwPQAiAEIAUpAKACIhFCGYZCgICA8P///w+DIBBCJ4iENwPYAiAEIAUpAKgCIhJCJIZCgICAgID+/w+DIBFCHIiENwPgAiAEIAUpALACIhBCBohC/////////w+DNwPwAiAEIBBCL4ZCgICAgICA4A+DIBJCEYiENwPoAiAEIAUpALgCIhFCBYZC4P///////w+DIBBCO4iENwP4AiAEIAUpAMACIhBCEIZCgID8/////w+DIBFCMIiENwOAAyAEIAUpAMgCIhFCG4ZCgICAwP///w+DIBBCJYiENwOIAyAEIAUpANACIhJCJoZCgICAgID4/w+DIBFCGoiENwOQAyAEIAUpANgCIhBCBIhC/////////w+DNwOgAyAEIBBCMYZCgICAgICAgA+DIBJCD4iENwOYAyAEIAUpAOACIhFCB4ZCgP///////w+DIBBCOYiENwOoAyAEIAUpAOgCIhBCEoZCgIDw/////w+DIBFCLoiENwOwAyAEIAUpAPACIhFCHYZCgICAgP7//w+DIBBCI4iENwO4AyAEIAUpAPgCIhJCKIZCgICAgIDg/w+DIBFCGIiENwPAAyAEIAUpAIADIhBCAohC/////////w+DNwPQAyAEIBBCM4ZCgICAgICAgAyDIBJCDYiENwPIAyAEIAUpAIgDIhFCCYZCgPz//////w+DIBBCN4iENwPYAyAEIAUpAJADIhBCFIZCgIDA/////w+DIBFCLIiENwPgAyAEIAUpAJgDIhFCH4ZCgICAgPj//w+DIBBCIYiENwPoAyAEIAUpAKADIhBCC4g3A/gDIAQgEEIqhkKAgICAgID/D4MgEUIWiIQ3A/ADDAwLIAZBrwNNBEAMFAsgBCAFKQAAIhFC/////////x+DNwMAIAQgBSkAKCIQQgSIQv////////8fgzcDMCAEIAUpAAgiEkIKhkKA+P//////H4MgEUI2iIQ3AwggBCAFKQAQIhFCFIZCgIDA/////x+DIBJCLIiENwMQIAQgBSkAGCISQh6GQoCAgID8//8fgyARQiKIhDcDGCAEIAUpACAiEUIohkKAgICAgOD/H4MgEkIYiIQ3AyAgBCAQQjKGQoCAgICAgIAegyARQg6IhDcDKCAEIAUpADAiEUIGhkLA////////H4MgEEI6iIQ3AzggBCAFKQA4IhBCEIZCgID8/////x+DIBFCMIiENwNAIAQgBSkAQCISQhqGQoCAgOD///8fgyAQQiaIhDcDSCAEIAUpAFAiEEIIiEL/////////H4M3A2AgBCAFKQCAASIRQgKIQv////////8fgzcDmAEgBCAFKQBIIhNCJIZCgICAgID+/x+DIBJCHIiENwNQIAQgEEIuhkKAgICAgIDwH4MgE0ISiIQ3A1ggBCAFKQBYIhJCAoZC/P///////x+DIBBCPoiENwNoIAQgBSkAYCIQQgyGQoDg//////8fgyASQjSIhDcDcCAEIAUpAGgiEkIWhkKAgID+////H4MgEEIqiIQ3A3ggBCAFKQBwIhBCIIZCgICAgPD//x+DIBJCIIiENwOAASAEIAUpAHgiEkIqhkKAgICAgID/H4MgEEIWiIQ3A4gBIAQgEUI0hkKAgICAgICAGIMgEkIMiIQ3A5ABIAQgBSkAiAEiEEIIhkKA/v//////H4MgEUI4iIQ3A6ABIAQgBSkAkAEiEUIShkKAgPD/////H4MgEEIuiIQ3A6gBIAQgBSkAmAEiEEIchkKAgICA////H4MgEUIkiIQ3A7ABIAQgBSkAoAEiEUImhkKAgICAgPj/H4MgEEIaiIQ3A7gBIAQgBSkAqAEiEEIGiEL/////////H4M3A8gBIAQgEEIwhkKAgICAgIDAH4MgEUIQiIQ3A8ABIAQgBSkAsAEiEUIEhkLw////////H4MgEEI8iIQ3A9ABIAQgBSkAuAEiEEIOhkKAgP//////H4MgEUIyiIQ3A9gBIAQgBSkAwAEiEUIYhkKAgID4////H4MgEEIoiIQ3A+ABIAQgBSkAyAEiEEIihkKAgICAwP//H4MgEUIeiIQ3A+gBIAQgBSkA0AEiEUIKiDcD+AEgBCARQiyGQoCAgICAgPwfgyAQQhSIhDcD8AEgBCAFKQDYASIQQv////////8fgzcDgAIgBCAFKQDgASIRQgqGQoD4//////8fgyAQQjaIhDcDiAIgBCAFKQDoASIQQhSGQoCAwP////8fgyARQiyIhDcDkAIgBCAFKQDwASIRQh6GQoCAgID8//8fgyAQQiKIhDcDmAIgBCAFKQD4ASISQiiGQoCAgICA4P8fgyARQhiIhDcDoAIgBCAFKQCAAiIQQgSIQv////////8fgzcDsAIgBCAQQjKGQoCAgICAgIAegyASQg6IhDcDqAIgBCAFKQCIAiIRQgaGQsD///////8fgyAQQjqIhDcDuAIgBCAFKQCQAiIQQhCGQoCA/P////8fgyARQjCIhDcDwAIgBCAFKQCYAiIRQhqGQoCAgOD///8fgyAQQiaIhDcDyAIgBCAFKQCgAiISQiSGQoCAgICA/v8fgyARQhyIhDcD0AIgBCAFKQCoAiIQQgiIQv////////8fgzcD4AIgBCAQQi6GQoCAgICAgPAfgyASQhKIhDcD2AIgBCAFKQCwAiIRQgKGQvz///////8fgyAQQj6IhDcD6AIgBCAFKQC4AiIQQgyGQoDg//////8fgyARQjSIhDcD8AIgBCAFKQDAAiIRQhaGQoCAgP7///8fgyAQQiqIhDcD+AIgBCAFKQDIAiIQQiCGQoCAgIDw//8fgyARQiCIhDcDgAMgBCAFKQDQAiIRQiqGQoCAgICAgP8fgyAQQhaIhDcDiAMgBCAFKQDYAiIQQgKIQv////////8fgzcDmAMgBCAQQjSGQoCAgICAgIAYgyARQgyIhDcDkAMgBCAFKQDgAiIRQgiGQoD+//////8fgyAQQjiIhDcDoAMgBCAFKQDoAiIQQhKGQoCA8P////8fgyARQi6IhDcDqAMgBCAFKQDwAiIRQhyGQoCAgID///8fgyAQQiSIhDcDsAMgBCAFKQD4AiISQiaGQoCAgICA+P8fgyARQhqIhDcDuAMgBCAFKQCAAyIQQgaIQv////////8fgzcDyAMgBCAQQjCGQoCAgICAgMAfgyASQhCIhDcDwAMgBCAFKQCIAyIRQgSGQvD///////8fgyAQQjyIhDcD0AMgBCAFKQCQAyIQQg6GQoCA//////8fgyARQjKIhDcD2AMgBCAFKQCYAyIRQhiGQoCAgPj///8fgyAQQiiIhDcD4AMgBCAFKQCgAyIQQiKGQoCAgIDA//8fgyARQh6IhDcD6AMgBCAFKQCoAyIRQgqINwP4AyAEIBFCLIZCgICAgICA/B+DIBBCFIiENwPwAwwLCyAGQbcDTQRADBMLIAQgBSkAACIRQv////////8/gzcDACAEIAUpADAiEEIBiEL/////////P4M3AzggBCAFKQAIIhJCCYZCgPz//////z+DIBFCN4iENwMIIAQgBSkAECIRQhKGQoCA8P////8/gyASQi6IhDcDECAEIAUpABgiEkIbhkKAgIDA////P4MgEUIliIQ3AxggBCAFKQAgIhFCJIZCgICAgID+/z+DIBJCHIiENwMgIAQgBSkAKCISQi2GQoCAgICAgPg/gyARQhOIhDcDKCAEIBBCNoZCgICAgICAgCCDIBJCCoiENwMwIAQgBSkAOCIRQgiGQoD+//////8/gyAQQjiIhDcDQCAEIAUpAEAiEkIRhkKAgPj/////P4MgEUIviIQ3A0ggBCAFKQBgIhBCAohC/////////z+DNwNwIAQgBSkASCIRQhqGQoCAgOD///8/gyASQiaIhDcDUCAEIAUpAFAiEkIjhkKAgICAgP//P4MgEUIdiIQ3A1ggBCAFKQBYIhFCLIZCgICAgICA/D+DIBJCFIiENwNgIAQgEEI1hkKAgICAgICAMIMgEUILiIQ3A2ggBCAFKQBoIhFCB4ZCgP///////z+DIBBCOYiENwN4IAQgBSkAcCIQQhCGQoCA/P////8/gyARQjCIhDcDgAEgBCAFKQB4IhFCGYZCgICA8P///z+DIBBCJ4iENwOIASAEIAUpAIABIhBCIoZCgICAgMD//z+DIBFCHoiENwOQASAEIAUpAIgBIhFCK4ZCgICAgICA/j+DIBBCFYiENwOYASAEIAUpAJABIhBCA4hC/////////z+DNwOoASAEIBBCNIZCgICAgICAgDiDIBFCDIiENwOgASAEIAUpAJgBIhFCBoZCwP///////z+DIBBCOoiENwOwASAEIAUpAKABIhBCD4ZCgID+/////z+DIBFCMYiENwO4ASAEIAUpAKgBIhFCGIZCgICA+P///z+DIBBCKIiENwPAASAEIAUpALABIhBCIYZCgICAgOD//z+DIBFCH4iENwPIASAEIAUpALgBIhFCKoZCgICAgICA/z+DIBBCFoiENwPQASAEIAUpAMABIhBCBIhC/////////z+DNwPgASAEIBBCM4ZCgICAgICAgDyDIBFCDYiENwPYASAEIAUpAMgBIhFCBYZC4P///////z+DIBBCO4iENwPoASAEIAUpANABIhBCDoZCgID//////z+DIBFCMoiENwPwASAEIAUpANgBIhFCF4ZCgICA/P///z+DIBBCKYiENwP4ASAEIAUpAOABIhBCIIZCgICAgPD//z+DIBFCIIiENwOAAiAEIAUpAOgBIhFCKYZCgICAgIDA/z+DIBBCF4iENwOIAiAEIAUpAPABIhBCBYhC/////////z+DNwOYAiAEIBBCMoZCgICAgICAgD6DIBFCDoiENwOQAiAEIAUpAPgBIhFCBIZC8P///////z+DIBBCPIiENwOgAiAEIAUpAIACIhBCDYZCgMD//////z+DIBFCM4iENwOoAiAEIAUpAIgCIhFCFoZCgICA/v///z+DIBBCKoiENwOwAiAEIAUpAJACIhBCH4ZCgICAgPj//z+DIBFCIYiENwO4AiAEIAUpAJgCIhFCKIZCgICAgIDg/z+DIBBCGIiENwPAAiAEIAUpAKACIhBCBohC/////////z+DNwPQAiAEIBBCMYZCgICAgICAgD+DIBFCD4iENwPIAiAEIAUpAKgCIhFCA4ZC+P///////z+DIBBCPYiENwPYAiAEIAUpALACIhBCDIZCgOD//////z+DIBFCNIiENwPgAiAEIAUpALgCIhFCFYZCgICA/////z+DIBBCK4iENwPoAiAEIAUpAMACIhBCHoZCgICAgPz//z+DIBFCIoiENwPwAiAEIAUpAMgCIhFCJ4ZCgICAgIDw/z+DIBBCGYiENwP4AiAEIAUpANACIhBCB4hC/////////z+DNwOIAyAEIBBCMIZCgICAgICAwD+DIBFCEIiENwOAAyAEIAUpANgCIhFCAoZC/P///////z+DIBBCPoiENwOQAyAEIAUpAOACIhBCC4ZCgPD//////z+DIBFCNYiENwOYAyAEIAUpAOgCIhFCFIZCgIDA/////z+DIBBCLIiENwOgAyAEIAUpAPACIhBCHYZCgICAgP7//z+DIBFCI4iENwOoAyAEIAUpAPgCIhFCJoZCgICAgID4/z+DIBBCGoiENwOwAyAEIAUpAIADIhBCCIhC/////////z+DNwPAAyAEIBBCL4ZCgICAgICA4D+DIBFCEYiENwO4AyAEIAUpAIgDIhFCAYZC/v///////z+DIBBCP4iENwPIAyAEIAUpAJADIhBCCoZCgPj//////z+DIBFCNoiENwPQAyAEIAUpAJgDIhFCE4ZCgIDg/////z+DIBBCLYiENwPYAyAEIAUpAKADIhBCHIZCgICAgP///z+DIBFCJIiENwPgAyAEIAUpAKgDIhFCJYZCgICAgID8/z+DIBBCG4iENwPoAyAEIAUpALADIhBCCYg3A/gDIAQgEEIuhkKAgICAgIDwP4MgEUISiIQ3A/ADDAoLIAZBvwNNBEAMEgsgBCAFKQAAIhBC//////////8AgzcDACAEIAUpADAiEUIIiDcDOCAEIAUpADgiEkL//////////wCDNwNAIAQgBSkACCITQgiGQoD+////////AIMgEEI4iIQ3AwggBCAFKQAQIhBCEIZCgID8//////8AgyATQjCIhDcDECAEIAUpABgiE0IYhkKAgID4/////wCDIBBCKIiENwMYIAQgBSkAICIQQiCGQoCAgIDw////AIMgE0IgiIQ3AyAgBCAFKQAoIhNCKIZCgICAgIDg//8AgyAQQhiIhDcDKCAEIBFCMIZCgICAgICAwP8AgyATQhCIhDcDMCAEIAUpAEAiEEIIhkKA/v///////wCDIBJCOIiENwNIIAQgBSkAaCIRQgiINwN4IAQgBSkAcCISQv//////////AIM3A4ABIAQgBSkASCITQhCGQoCA/P//////AIMgEEIwiIQ3A1AgBCAFKQBQIhBCGIZCgICA+P////8AgyATQiiIhDcDWCAEIAUpAFgiE0IghkKAgICA8P///wCDIBBCIIiENwNgIAQgBSkAYCIQQiiGQoCAgICA4P//AIMgE0IYiIQ3A2ggBCARQjCGQoCAgICAgMD/AIMgEEIQiIQ3A3AgBCAFKQB4IhBCCIZCgP7///////8AgyASQjiIhDcDiAEgBCAFKQCAASIRQhCGQoCA/P//////AIMgEEIwiIQ3A5ABIAQgBSkAiAEiEEIYhkKAgID4/////wCDIBFCKIiENwOYASAEIAUpAJABIhFCIIZCgICAgPD///8AgyAQQiCIhDcDoAEgBCAFKQCYASIQQiiGQoCAgICA4P//AIMgEUIYiIQ3A6gBIAQgBSkAoAEiEUIIiDcDuAEgBCARQjCGQoCAgICAgMD/AIMgEEIQiIQ3A7ABIAQgBSkAqAEiEEL//////////wCDNwPAASAEIAUpALABIhFCCIZCgP7///////8AgyAQQjiIhDcDyAEgBCAFKQC4ASIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ABIAQgBSkAwAEiEUIYhkKAgID4/////wCDIBBCKIiENwPYASAEIAUpAMgBIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AEgBCAFKQDQASIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gBIAQgBSkA2AEiEEIIiDcD+AEgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ABIAQgBSkA4AEiEEL//////////wCDNwOAAiAEIAUpAOgBIhFCCIZCgP7///////8AgyAQQjiIhDcDiAIgBCAFKQDwASIQQhCGQoCA/P//////AIMgEUIwiIQ3A5ACIAQgBSkA+AEiEUIYhkKAgID4/////wCDIBBCKIiENwOYAiAEIAUpAIACIhBCIIZCgICAgPD///8AgyARQiCIhDcDoAIgBCAFKQCIAiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A6gCIAQgBSkAkAIiEEIIiDcDuAIgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A7ACIAQgBSkAmAIiEEL//////////wCDNwPAAiAEIAUpAKACIhFCCIZCgP7///////8AgyAQQjiIhDcDyAIgBCAFKQCoAiIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ACIAQgBSkAsAIiEUIYhkKAgID4/////wCDIBBCKIiENwPYAiAEIAUpALgCIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AIgBCAFKQDAAiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gCIAQgBSkAyAIiEEIIiDcD+AIgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ACIAQgBSkA0AIiEEL//////////wCDNwOAAyAEIAUpANgCIhFCCIZCgP7///////8AgyAQQjiIhDcDiAMgBCAFKQDgAiIQQhCGQoCA/P//////AIMgEUIwiIQ3A5ADIAQgBSkA6AIiEUIYhkKAgID4/////wCDIBBCKIiENwOYAyAEIAUpAPACIhBCIIZCgICAgPD///8AgyARQiCIhDcDoAMgBCAFKQD4AiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A6gDIAQgBSkAgAMiEEIIiDcDuAMgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A7ADIAQgBSkAiAMiEEL//////////wCDNwPAAyAEIAUpAJADIhFCCIZCgP7///////8AgyAQQjiIhDcDyAMgBCAFKQCYAyIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ADIAQgBSkAoAMiEUIYhkKAgID4/////wCDIBBCKIiENwPYAyAEIAUpAKgDIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AMgBCAFKQCwAyIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gDIAQgBSkAuAMiEEIIiDcD+AMgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ADDAkLIAZBxwNNBEAMEQsgBCAFKQAAIhFC//////////8BgzcDACAEIAUpAEAiEEIBiEL//////////wGDNwNIIAQgBSkACCISQgeGQoD/////////AYMgEUI5iIQ3AwggBCAFKQAQIhFCDoZCgID///////8BgyASQjKIhDcDECAEIAUpABgiEkIVhkKAgID//////wGDIBFCK4iENwMYIAQgBSkAICIRQhyGQoCAgID/////AYMgEkIkiIQ3AyAgBCAFKQAoIhJCI4ZCgICAgID///8BgyARQh2IhDcDKCAEIAUpADAiEUIqhkKAgICAgID//wGDIBJCFoiENwMwIAQgBSkAOCISQjGGQoCAgICAgID/AYMgEUIPiIQ3AzggBCAQQjiGQoCAgICAgICAAYMgEkIIiIQ3A0AgBCAFKQCAASIRQgKIQv//////////AYM3A5ABIAQgBSkASCISQgaGQsD/////////AYMgEEI6iIQ3A1AgBCAFKQBQIhBCDYZCgMD///////8BgyASQjOIhDcDWCAEIAUpAFgiEkIUhkKAgMD//////wGDIBBCLIiENwNgIAQgBSkAYCIQQhuGQoCAgMD/////AYMgEkIliIQ3A2ggBCAFKQBoIhJCIoZCgICAgMD///8BgyAQQh6IhDcDcCAEIAUpAHAiEEIphkKAgICAgMD//wGDIBJCF4iENwN4IAQgBSkAeCISQjCGQoCAgICAgMD/AYMgEEIQiIQ3A4ABIAQgEUI3hkKAgICAgICAwAGDIBJCCYiENwOIASAEIAUpAIgBIhBCBYZC4P////////8BgyARQjuIhDcDmAEgBCAFKQCQASIRQgyGQoDg////////AYMgEEI0iIQ3A6ABIAQgBSkAmAEiEEIThkKAgOD//////wGDIBFCLYiENwOoASAEIAUpAKABIhFCGoZCgICA4P////8BgyAQQiaIhDcDsAEgBCAFKQCoASIQQiGGQoCAgIDg////AYMgEUIfiIQ3A7gBIAQgBSkAsAEiEUIohkKAgICAgOD//wGDIBBCGIiENwPAASAEIAUpALgBIhJCL4ZCgICAgICA4P8BgyARQhGIhDcDyAEgBCAFKQDAASIQQgOIQv//////////AYM3A9gBIAQgEEI2hkKAgICAgICA4AGDIBJCCoiENwPQASAEIAUpAMgBIhFCBIZC8P////////8BgyAQQjyIhDcD4AEgBCAFKQDQASIQQguGQoDw////////AYMgEUI1iIQ3A+gBIAQgBSkA2AEiEUIShkKAgPD//////wGDIBBCLoiENwPwASAEIAUpAOABIhBCGYZCgICA8P////8BgyARQieIhDcD+AEgBCAFKQDoASIRQiCGQoCAgIDw////AYMgEEIgiIQ3A4ACIAQgBSkA8AEiEEInhkKAgICAgPD//wGDIBFCGYiENwOIAiAEIAUpAPgBIhFCLoZCgICAgICA8P8BgyAQQhKIhDcDkAIgBCAFKQCAAiIQQgSIQv//////////AYM3A6ACIAQgEEI1hkKAgICAgICA8AGDIBFCC4iENwOYAiAEIAUpAIgCIhFCA4ZC+P////////8BgyAQQj2IhDcDqAIgBCAFKQCQAiIQQgqGQoD4////////AYMgEUI2iIQ3A7ACIAQgBSkAmAIiEUIRhkKAgPj//////wGDIBBCL4iENwO4AiAEIAUpAKACIhBCGIZCgICA+P////8BgyARQiiIhDcDwAIgBCAFKQCoAiIRQh+GQoCAgID4////AYMgEEIhiIQ3A8gCIAQgBSkAsAIiEEImhkKAgICAgPj//wGDIBFCGoiENwPQAiAEIAUpALgCIhFCLYZCgICAgICA+P8BgyAQQhOIhDcD2AIgBCAFKQDAAiIQQgWIQv//////////AYM3A+gCIAQgEEI0hkKAgICAgICA+AGDIBFCDIiENwPgAiAEIAUpAMgCIhFCAoZC/P////////8BgyAQQj6IhDcD8AIgBCAFKQDQAiIQQgmGQoD8////////AYMgEUI3iIQ3A/gCIAQgBSkA2AIiEUIQhkKAgPz//////wGDIBBCMIiENwOAAyAEIAUpAOACIhBCF4ZCgICA/P////8BgyARQimIhDcDiAMgBCAFKQDoAiIRQh6GQoCAgID8////AYMgEEIiiIQ3A5ADIAQgBSkA8AIiEEIlhkKAgICAgPz//wGDIBFCG4iENwOYAyAEIAUpAPgCIhFCLIZCgICAgICA/P8BgyAQQhSIhDcDoAMgBCAFKQCAAyIQQgaIQv//////////AYM3A7ADIAQgEEIzhkKAgICAgICA/AGDIBFCDYiENwOoAyAEIAUpAIgDIhFCAYZC/v////////8BgyAQQj+IhDcDuAMgBCAFKQCQAyIQQgiGQoD+////////AYMgEUI4iIQ3A8ADIAQgBSkAmAMiEUIPhkKAgP7//////wGDIBBCMYiENwPIAyAEIAUpAKADIhBCFoZCgICA/v////8BgyARQiqIhDcD0AMgBCAFKQCoAyIRQh2GQoCAgID+////AYMgEEIjiIQ3A9gDIAQgBSkAsAMiEEIkhkKAgICAgP7//wGDIBFCHIiENwPgAyAEIAUpALgDIhFCK4ZCgICAgICA/v8BgyAQQhWIhDcD6AMgBCAFKQDAAyIQQgeINwP4AyAEIBBCMoZCgICAgICAgP4BgyARQg6IhDcD8AMMCAsgBkHPA00EQAwQCyAEIAUpAAAiEEL//////////wODNwMAIAQgBSkACCIRQgaGQsD/////////A4MgEEI6iIQ3AwggBCAFKQAQIhBCDIZCgOD///////8DgyARQjSIhDcDECAEIAUpABgiEUIShkKAgPD//////wODIBBCLoiENwMYIAQgBSkAICIQQhiGQoCAgPj/////A4MgEUIoiIQ3AyAgBCAFKQAoIhFCHoZCgICAgPz///8DgyAQQiKIhDcDKCAEIAUpADAiEEIkhkKAgICAgP7//wODIBFCHIiENwMwIAQgBSkAOCIRQiqGQoCAgICAgP//A4MgEEIWiIQ3AzggBCAFKQBAIhJCMIZCgICAgICAwP8DgyARQhCIhDcDQCAEIAUpAEgiEEIEiEL//////////wODNwNQIAQgEEI2hkKAgICAgICA4AODIBJCCoiENwNIIAQgBSkAUCIRQgKGQvz/////////A4MgEEI+iIQ3A1ggBCAFKQBYIhBCCIZCgP7///////8DgyARQjiIhDcDYCAEIAUpAGAiEUIOhkKAgP///////wODIBBCMoiENwNoIAQgBSkAaCIQQhSGQoCAwP//////A4MgEUIsiIQ3A3AgBCAFKQBwIhFCGoZCgICA4P////8DgyAQQiaIhDcDeCAEIAUpAHgiEEIghkKAgICA8P///wODIBFCIIiENwOAASAEIAUpAIABIhFCJoZCgICAgID4//8DgyAQQhqIhDcDiAEgBCAFKQCIASIQQiyGQoCAgICAgPz/A4MgEUIUiIQ3A5ABIAQgBSkAkAEiEUIyhkKAgICAgICA/gODIBBCDoiENwOYASAEIAUpAJgBIhBCAohC//////////8DgzcDqAEgBCAQQjiGQoCAgICAgICAA4MgEUIIiIQ3A6ABIAQgBSkAoAEiEUIEhkLw/////////wODIBBCPIiENwOwASAEIAUpAKgBIhBCCoZCgPj///////8DgyARQjaIhDcDuAEgBCAFKQCwASIRQhCGQoCA/P//////A4MgEEIwiIQ3A8ABIAQgBSkAuAEiEEIWhkKAgID+/////wODIBFCKoiENwPIASAEIAUpAMABIhFCHIZCgICAgP////8DgyAQQiSIhDcD0AEgBCAFKQDIASIQQiKGQoCAgIDA////A4MgEUIeiIQ3A9gBIAQgBSkA0AEiEUIohkKAgICAgOD//wODIBBCGIiENwPgASAEIAUpANgBIhBCLoZCgICAgICA8P8DgyARQhKIhDcD6AEgBCAFKQDgASIRQgaINwP4ASAEIBFCNIZCgICAgICAgPgDgyAQQgyIhDcD8AEgBCAFKQDoASIQQv//////////A4M3A4ACIAQgBSkA8AEiEUIGhkLA/////////wODIBBCOoiENwOIAiAEIAUpAPgBIhBCDIZCgOD///////8DgyARQjSIhDcDkAIgBCAFKQCAAiIRQhKGQoCA8P//////A4MgEEIuiIQ3A5gCIAQgBSkAiAIiEEIYhkKAgID4/////wODIBFCKIiENwOgAiAEIAUpAJACIhFCHoZCgICAgPz///8DgyAQQiKIhDcDqAIgBCAFKQCYAiIQQiSGQoCAgICA/v//A4MgEUIciIQ3A7ACIAQgBSkAoAIiEUIqhkKAgICAgID//wODIBBCFoiENwO4AiAEIAUpAKgCIhJCMIZCgICAgICAwP8DgyARQhCIhDcDwAIgBCAFKQCwAiIQQgSIQv//////////A4M3A9ACIAQgEEI2hkKAgICAgICA4AODIBJCCoiENwPIAiAEIAUpALgCIhFCAoZC/P////////8DgyAQQj6IhDcD2AIgBCAFKQDAAiIQQgiGQoD+////////A4MgEUI4iIQ3A+ACIAQgBSkAyAIiEUIOhkKAgP///////wODIBBCMoiENwPoAiAEIAUpANACIhBCFIZCgIDA//////8DgyARQiyIhDcD8AIgBCAFKQDYAiIRQhqGQoCAgOD/////A4MgEEImiIQ3A/gCIAQgBSkA4AIiEEIghkKAgICA8P///wODIBFCIIiENwOAAyAEIAUpAOgCIhFCJoZCgICAgID4//8DgyAQQhqIhDcDiAMgBCAFKQDwAiIQQiyGQoCAgICAgPz/A4MgEUIUiIQ3A5ADIAQgBSkA+AIiEUIyhkKAgICAgICA/gODIBBCDoiENwOYAyAEIAUpAIADIhBCAohC//////////8DgzcDqAMgBCAQQjiGQoCAgICAgICAA4MgEUIIiIQ3A6ADIAQgBSkAiAMiEUIEhkLw/////////wODIBBCPIiENwOwAyAEIAUpAJADIhBCCoZCgPj///////8DgyARQjaIhDcDuAMgBCAFKQCYAyIRQhCGQoCA/P//////A4MgEEIwiIQ3A8ADIAQgBSkAoAMiEEIWhkKAgID+/////wODIBFCKoiENwPIAyAEIAUpAKgDIhFCHIZCgICAgP////8DgyAQQiSIhDcD0AMgBCAFKQCwAyIQQiKGQoCAgIDA////A4MgEUIeiIQ3A9gDIAQgBSkAuAMiEUIohkKAgICAgOD//wODIBBCGIiENwPgAyAEIAUpAMADIhBCLoZCgICAgICA8P8DgyARQhKIhDcD6AMgBCAFKQDIAyIRQgaINwP4AyAEIBFCNIZCgICAgICAgPgDgyAQQgyIhDcD8AMMBwsgBkHXA00EQAwPCyAEIAUpAAAiEEL//////////weDNwMAIAQgBSkACCIRQgWGQuD/////////B4MgEEI7iIQ3AwggBCAFKQAQIhBCCoZCgPj///////8HgyARQjaIhDcDECAEIAUpABgiEUIPhkKAgP7//////weDIBBCMYiENwMYIAQgBSkAICIQQhSGQoCAwP//////B4MgEUIsiIQ3AyAgBCAFKQAoIhFCGYZCgICA8P////8HgyAQQieIhDcDKCAEIAUpADAiEEIehkKAgICA/P///weDIBFCIoiENwMwIAQgBSkAOCIRQiOGQoCAgICA////B4MgEEIdiIQ3AzggBCAFKQBAIhBCKIZCgICAgIDg//8HgyARQhiIhDcDQCAEIAUpAEgiEUIthkKAgICAgID4/weDIBBCE4iENwNIIAQgBSkAWCIQQgSIQv//////////B4M3A2AgBCAFKQBQIhJCMoZCgICAgICAgP4HgyARQg6IhDcDUCAEIBBCN4ZCgICAgICAgMAHgyASQgmIhDcDWCAEIAUpAGAiEUIBhkL+/////////weDIBBCP4iENwNoIAQgBSkAaCIQQgaGQsD/////////B4MgEUI6iIQ3A3AgBCAFKQBwIhFCC4ZCgPD///////8HgyAQQjWIhDcDeCAEIAUpAHgiEEIQhkKAgPz//////weDIBFCMIiENwOAASAEIAUpAIABIhFCFYZCgICA//////8HgyAQQiuIhDcDiAEgBCAFKQCIASIQQhqGQoCAgOD/////B4MgEUImiIQ3A5ABIAQgBSkAkAEiEUIfhkKAgICA+P///weDIBBCIYiENwOYASAEIAUpAJgBIhBCJIZCgICAgID+//8HgyARQhyIhDcDoAEgBCAFKQCgASIRQimGQoCAgICAwP//B4MgEEIXiIQ3A6gBIAQgBSkAqAEiEEIuhkKAgICAgIDw/weDIBFCEoiENwOwASAEIAUpALABIhFCM4ZCgICAgICAgPwHgyAQQg2IhDcDuAEgBCAFKQC4ASIQQgOIQv//////////B4M3A8gBIAQgEEI4hkKAgICAgICAgAeDIBFCCIiENwPAASAEIAUpAMABIhFCAoZC/P////////8HgyAQQj6IhDcD0AEgBCAFKQDIASIQQgeGQoD/////////B4MgEUI5iIQ3A9gBIAQgBSkA0AEiEUIMhkKA4P///////weDIBBCNIiENwPgASAEIAUpANgBIhBCEYZCgID4//////8HgyARQi+IhDcD6AEgBCAFKQDgASIRQhaGQoCAgP7/////B4MgEEIqiIQ3A/ABIAQgBSkA6AEiEEIbhkKAgIDA/////weDIBFCJYiENwP4ASAEIAUpAPABIhFCIIZCgICAgPD///8HgyAQQiCIhDcDgAIgBCAFKQD4ASIQQiWGQoCAgICA/P//B4MgEUIbiIQ3A4gCIAQgBSkAgAIiEUIqhkKAgICAgID//weDIBBCFoiENwOQAiAEIAUpAIgCIhBCL4ZCgICAgICA4P8HgyARQhGIhDcDmAIgBCAFKQCQAiIRQjSGQoCAgICAgID4B4MgEEIMiIQ3A6ACIAQgBSkAmAIiEEICiEL//////////weDNwOwAiAEIBBCOYZCgICAgICAgIAGgyARQgeIhDcDqAIgBCAFKQCgAiIRQgOGQvj/////////B4MgEEI9iIQ3A7gCIAQgBSkAqAIiEEIIhkKA/v///////weDIBFCOIiENwPAAiAEIAUpALACIhFCDYZCgMD///////8HgyAQQjOIhDcDyAIgBCAFKQC4AiIQQhKGQoCA8P//////B4MgEUIuiIQ3A9ACIAQgBSkAwAIiEUIXhkKAgID8/////weDIBBCKYiENwPYAiAEIAUpAMgCIhBCHIZCgICAgP////8HgyARQiSIhDcD4AIgBCAFKQDQAiIRQiGGQoCAgIDg////B4MgEEIfiIQ3A+gCIAQgBSkA2AIiEEImhkKAgICAgPj//weDIBFCGoiENwPwAiAEIAUpAOACIhFCK4ZCgICAgICA/v8HgyAQQhWIhDcD+AIgBCAFKQDoAiIQQjCGQoCAgICAgMD/B4MgEUIQiIQ3A4ADIAQgBSkA8AIiEUI1hkKAgICAgICA8AeDIBBCC4iENwOIAyAEIAUpAPgCIhBCAYhC//////////8HgzcDmAMgBCAQQjqGQoCAgICAgICABIMgEUIGiIQ3A5ADIAQgBSkAgAMiEUIEhkLw/////////weDIBBCPIiENwOgAyAEIAUpAIgDIhBCCYZCgPz///////8HgyARQjeIhDcDqAMgBCAFKQCQAyIRQg6GQoCA////////B4MgEEIyiIQ3A7ADIAQgBSkAmAMiEEIThkKAgOD//////weDIBFCLYiENwO4AyAEIAUpAKADIhFCGIZCgICA+P////8HgyAQQiiIhDcDwAMgBCAFKQCoAyIQQh2GQoCAgID+////B4MgEUIjiIQ3A8gDIAQgBSkAsAMiEUIihkKAgICAwP///weDIBBCHoiENwPQAyAEIAUpALgDIhBCJ4ZCgICAgIDw//8HgyARQhmIhDcD2AMgBCAFKQDAAyIRQiyGQoCAgICAgPz/B4MgEEIUiIQ3A+ADIAQgBSkAyAMiEEIxhkKAgICAgICA/weDIBFCD4iENwPoAyAEIAUpANADIhFCBYg3A/gDIAQgEUI2hkKAgICAgICA4AeDIBBCCoiENwPwAwwGCyAGQd8DTQRADA4LIAQgBSkAACIQQv//////////D4M3AwAgBCAFKQAIIhFCBIZC8P////////8PgyAQQjyIhDcDCCAEIAUpABAiEEIIhkKA/v///////w+DIBFCOIiENwMQIAQgBSkAGCIRQgyGQoDg////////D4MgEEI0iIQ3AxggBCAFKQAgIhBCEIZCgID8//////8PgyARQjCIhDcDICAEIAUpACgiEUIUhkKAgMD//////w+DIBBCLIiENwMoIAQgBSkAMCIQQhiGQoCAgPj/////D4MgEUIoiIQ3AzAgBCAFKQA4IhFCHIZCgICAgP////8PgyAQQiSIhDcDOCAEIAUpAEAiEEIghkKAgICA8P///w+DIBFCIIiENwNAIAQgBSkASCIRQiSGQoCAgICA/v//D4MgEEIciIQ3A0ggBCAFKQBwIhBCBIg3A3ggBCAFKQB4IhJC//////////8PgzcDgAEgBCAFKQBQIhNCKIZCgICAgIDg//8PgyARQhiIhDcDUCAEIAUpAFgiEUIshkKAgICAgID8/w+DIBNCFIiENwNYIAQgBSkAYCITQjCGQoCAgICAgMD/D4MgEUIQiIQ3A2AgBCAFKQBoIhFCNIZCgICAgICAgPgPgyATQgyIhDcDaCAEIBBCOIZCgICAgICAgIAPgyARQgiIhDcDcCAEIAUpAIABIhBCBIZC8P////////8PgyASQjyIhDcDiAEgBCAFKQCIASIRQgiGQoD+////////D4MgEEI4iIQ3A5ABIAQgBSkAkAEiEEIMhkKA4P///////w+DIBFCNIiENwOYASAEIAUpAJgBIhFCEIZCgID8//////8PgyAQQjCIhDcDoAEgBCAFKQCgASIQQhSGQoCAwP//////D4MgEUIsiIQ3A6gBIAQgBSkAqAEiEUIYhkKAgID4/////w+DIBBCKIiENwOwASAEIAUpALABIhBCHIZCgICAgP////8PgyARQiSIhDcDuAEgBCAFKQC4ASIRQiCGQoCAgIDw////D4MgEEIgiIQ3A8ABIAQgBSkAwAEiEEIkhkKAgICAgP7//w+DIBFCHIiENwPIASAEIAUpAMgBIhFCKIZCgICAgIDg//8PgyAQQhiIhDcD0AEgBCAFKQDQASIQQiyGQoCAgICAgPz/D4MgEUIUiIQ3A9gBIAQgBSkA2AEiEUIwhkKAgICAgIDA/w+DIBBCEIiENwPgASAEIAUpAOABIhBCNIZCgICAgICAgPgPgyARQgyIhDcD6AEgBCAFKQDoASIRQgSINwP4ASAEIBFCOIZCgICAgICAgIAPgyAQQgiIhDcD8AEgBCAFKQDwASIQQv//////////D4M3A4ACIAQgBSkA+AEiEUIEhkLw/////////w+DIBBCPIiENwOIAiAEIAUpAIACIhBCCIZCgP7///////8PgyARQjiIhDcDkAIgBCAFKQCIAiIRQgyGQoDg////////D4MgEEI0iIQ3A5gCIAQgBSkAkAIiEEIQhkKAgPz//////w+DIBFCMIiENwOgAiAEIAUpAJgCIhFCFIZCgIDA//////8PgyAQQiyIhDcDqAIgBCAFKQCgAiIQQhiGQoCAgPj/////D4MgEUIoiIQ3A7ACIAQgBSkAqAIiEUIchkKAgICA/////w+DIBBCJIiENwO4AiAEIAUpALACIhBCIIZCgICAgPD///8PgyARQiCIhDcDwAIgBCAFKQC4AiIRQiSGQoCAgICA/v//D4MgEEIciIQ3A8gCIAQgBSkAwAIiEEIohkKAgICAgOD//w+DIBFCGIiENwPQAiAEIAUpAMgCIhFCLIZCgICAgICA/P8PgyAQQhSIhDcD2AIgBCAFKQDQAiIQQjCGQoCAgICAgMD/D4MgEUIQiIQ3A+ACIAQgBSkA2AIiEUI0hkKAgICAgICA+A+DIBBCDIiENwPoAiAEIAUpAOACIhBCBIg3A/gCIAQgEEI4hkKAgICAgICAgA+DIBFCCIiENwPwAiAEIAUpAOgCIhBC//////////8PgzcDgAMgBCAFKQDwAiIRQgSGQvD/////////D4MgEEI8iIQ3A4gDIAQgBSkA+AIiEEIIhkKA/v///////w+DIBFCOIiENwOQAyAEIAUpAIADIhFCDIZCgOD///////8PgyAQQjSIhDcDmAMgBCAFKQCIAyIQQhCGQoCA/P//////D4MgEUIwiIQ3A6ADIAQgBSkAkAMiEUIUhkKAgMD//////w+DIBBCLIiENwOoAyAEIAUpAJgDIhBCGIZCgICA+P////8PgyARQiiIhDcDsAMgBCAFKQCgAyIRQhyGQoCAgID/////D4MgEEIkiIQ3A7gDIAQgBSkAqAMiEEIghkKAgICA8P///w+DIBFCIIiENwPAAyAEIAUpALADIhFCJIZCgICAgID+//8PgyAQQhyIhDcDyAMgBCAFKQC4AyIQQiiGQoCAgICA4P//D4MgEUIYiIQ3A9ADIAQgBSkAwAMiEUIshkKAgICAgID8/w+DIBBCFIiENwPYAyAEIAUpAMgDIhBCMIZCgICAgICAwP8PgyARQhCIhDcD4AMgBCAFKQDQAyIRQjSGQoCAgICAgID4D4MgEEIMiIQ3A+gDIAQgBSkA2AMiEEIEiDcD+AMgBCAQQjiGQoCAgICAgICAD4MgEUIIiIQ3A/ADDAULIAZB5wNNBEAMDQsgBCAFKQAAIhBC//////////8fgzcDACAEIAUpAAgiEUIDhkL4/////////x+DIBBCPYiENwMIIAQgBSkAECIQQgaGQsD/////////H4MgEUI6iIQ3AxAgBCAFKQAYIhFCCYZCgPz///////8fgyAQQjeIhDcDGCAEIAUpACAiEEIMhkKA4P///////x+DIBFCNIiENwMgIAQgBSkAKCIRQg+GQoCA/v//////H4MgEEIxiIQ3AyggBCAFKQAwIhBCEoZCgIDw//////8fgyARQi6IhDcDMCAEIAUpADgiEUIVhkKAgID//////x+DIBBCK4iENwM4IAQgBSkAQCIQQhiGQoCAgPj/////H4MgEUIoiIQ3A0AgBCAFKQBIIhFCG4ZCgICAwP////8fgyAQQiWIhDcDSCAEIAUpAFAiEEIehkKAgICA/P///x+DIBFCIoiENwNQIAQgBSkAWCIRQiGGQoCAgIDg////H4MgEEIfiIQ3A1ggBCAFKQBgIhBCJIZCgICAgID+//8fgyARQhyIhDcDYCAEIAUpAGgiEUInhkKAgICAgPD//x+DIBBCGYiENwNoIAQgBSkAcCIQQiqGQoCAgICAgP//H4MgEUIWiIQ3A3AgBCAFKQB4IhFCLYZCgICAgICA+P8fgyAQQhOIhDcDeCAEIAUpAIABIhBCMIZCgICAgICAwP8fgyARQhCIhDcDgAEgBCAFKQCIASIRQjOGQoCAgICAgID8H4MgEEINiIQ3A4gBIAQgBSkAkAEiEEI2hkKAgICAgICA4B+DIBFCCoiENwOQASAEIAUpAJgBIhFCOYZCgICAgICAgIAegyAQQgeIhDcDmAEgBCAFKQCgASIQQgGIQv//////////H4M3A6gBIAQgEEI8hkKAgICAgICAgBCDIBFCBIiENwOgASAEIAUpAKgBIhFCAoZC/P////////8fgyAQQj6IhDcDsAEgBCAFKQCwASIQQgWGQuD/////////H4MgEUI7iIQ3A7gBIAQgBSkAuAEiEUIIhkKA/v///////x+DIBBCOIiENwPAASAEIAUpAMABIhBCC4ZCgPD///////8fgyARQjWIhDcDyAEgBCAFKQDIASIRQg6GQoCA////////H4MgEEIyiIQ3A9ABIAQgBSkA0AEiEEIRhkKAgPj//////x+DIBFCL4iENwPYASAEIAUpANgBIhFCFIZCgIDA//////8fgyAQQiyIhDcD4AEgBCAFKQDgASIQQheGQoCAgPz/////H4MgEUIpiIQ3A+gBIAQgBSkA6AEiEUIahkKAgIDg/////x+DIBBCJoiENwPwASAEIAUpAPABIhBCHYZCgICAgP7///8fgyARQiOIhDcD+AEgBCAFKQD4ASIRQiCGQoCAgIDw////H4MgEEIgiIQ3A4ACIAQgBSkAgAIiEEIjhkKAgICAgP///x+DIBFCHYiENwOIAiAEIAUpAIgCIhFCJoZCgICAgID4//8fgyAQQhqIhDcDkAIgBCAFKQCQAiIQQimGQoCAgICAwP//H4MgEUIXiIQ3A5gCIAQgBSkAmAIiEUIshkKAgICAgID8/x+DIBBCFIiENwOgAiAEIAUpAKACIhBCL4ZCgICAgICA4P8fgyARQhGIhDcDqAIgBCAFKQCoAiIRQjKGQoCAgICAgID+H4MgEEIOiIQ3A7ACIAQgBSkAsAIiEEI1hkKAgICAgICA8B+DIBFCC4iENwO4AiAEIAUpALgCIhFCOIZCgICAgICAgIAfgyAQQgiIhDcDwAIgBCAFKQDAAiIQQgKIQv//////////H4M3A9ACIAQgEEI7hkKAgICAgICAgBiDIBFCBYiENwPIAiAEIAUpAMgCIhFCAYZC/v////////8fgyAQQj+IhDcD2AIgBCAFKQDQAiIQQgSGQvD/////////H4MgEUI8iIQ3A+ACIAQgBSkA2AIiEUIHhkKA/////////x+DIBBCOYiENwPoAiAEIAUpAOACIhBCCoZCgPj///////8fgyARQjaIhDcD8AIgBCAFKQDoAiIRQg2GQoDA////////H4MgEEIziIQ3A/gCIAQgBSkA8AIiEEIQhkKAgPz//////x+DIBFCMIiENwOAAyAEIAUpAPgCIhFCE4ZCgIDg//////8fgyAQQi2IhDcDiAMgBCAFKQCAAyIQQhaGQoCAgP7/////H4MgEUIqiIQ3A5ADIAQgBSkAiAMiEUIZhkKAgIDw/////x+DIBBCJ4iENwOYAyAEIAUpAJADIhBCHIZCgICAgP////8fgyARQiSIhDcDoAMgBCAFKQCYAyIRQh+GQoCAgID4////H4MgEEIhiIQ3A6gDIAQgBSkAoAMiEEIihkKAgICAwP///x+DIBFCHoiENwOwAyAEIAUpAKgDIhFCJYZCgICAgID8//8fgyAQQhuIhDcDuAMgBCAFKQCwAyIQQiiGQoCAgICA4P//H4MgEUIYiIQ3A8ADIAQgBSkAuAMiEUIrhkKAgICAgID+/x+DIBBCFYiENwPIAyAEIAUpAMADIhBCLoZCgICAgICA8P8fgyARQhKIhDcD0AMgBCAFKQDIAyIRQjGGQoCAgICAgID/H4MgEEIPiIQ3A9gDIAQgBSkA0AMiEEI0hkKAgICAgICA+B+DIBFCDIiENwPgAyAEIAUpANgDIhFCN4ZCgICAgICAgMAfgyAQQgmIhDcD6AMgBCAFKQDgAyIQQgOINwP4AyAEIBBCOoZCgICAgICAgIAcgyARQgaIhDcD8AMMBAsgBkHvA00EQAwMCyAEIAUpAAAiEEL//////////z+DNwMAIAQgBSkACCIRQgKGQvz/////////P4MgEEI+iIQ3AwggBCAFKQAQIhBCBIZC8P////////8/gyARQjyIhDcDECAEIAUpABgiEUIGhkLA/////////z+DIBBCOoiENwMYIAQgBSkAICIQQgiGQoD+////////P4MgEUI4iIQ3AyAgBCAFKQAoIhFCCoZCgPj///////8/gyAQQjaIhDcDKCAEIAUpADAiEEIMhkKA4P///////z+DIBFCNIiENwMwIAQgBSkAOCIRQg6GQoCA////////P4MgEEIyiIQ3AzggBCAFKQBAIhBCEIZCgID8//////8/gyARQjCIhDcDQCAEIAUpAEgiEUIShkKAgPD//////z+DIBBCLoiENwNIIAQgBSkAUCIQQhSGQoCAwP//////P4MgEUIsiIQ3A1AgBCAFKQBYIhFCFoZCgICA/v////8/gyAQQiqIhDcDWCAEIAUpAGAiEEIYhkKAgID4/////z+DIBFCKIiENwNgIAQgBSkAaCIRQhqGQoCAgOD/////P4MgEEImiIQ3A2ggBCAFKQBwIhBCHIZCgICAgP////8/gyARQiSIhDcDcCAEIAUpAHgiEUIehkKAgICA/P///z+DIBBCIoiENwN4IAQgBSkAgAEiEEIghkKAgICA8P///z+DIBFCIIiENwOAASAEIAUpAIgBIhFCIoZCgICAgMD///8/gyAQQh6IhDcDiAEgBCAFKQCQASIQQiSGQoCAgICA/v//P4MgEUIciIQ3A5ABIAQgBSkAmAEiEUImhkKAgICAgPj//z+DIBBCGoiENwOYASAEIAUpAKABIhBCKIZCgICAgIDg//8/gyARQhiIhDcDoAEgBCAFKQCoASIRQiqGQoCAgICAgP//P4MgEEIWiIQ3A6gBIAQgBSkAsAEiEEIshkKAgICAgID8/z+DIBFCFIiENwOwASAEIAUpALgBIhFCLoZCgICAgICA8P8/gyAQQhKIhDcDuAEgBCAFKQDAASIQQjCGQoCAgICAgMD/P4MgEUIQiIQ3A8ABIAQgBSkAyAEiEUIyhkKAgICAgICA/j+DIBBCDoiENwPIASAEIAUpANABIhBCNIZCgICAgICAgPg/gyARQgyIhDcD0AEgBCAFKQDYASIRQjaGQoCAgICAgIDgP4MgEEIKiIQ3A9gBIAQgBSkA4AEiEEI4hkKAgICAgICAgD+DIBFCCIiENwPgASAEIAUpAOgBIhFCOoZCgICAgICAgIA8gyAQQgaIhDcD6AEgBCAFKQDwASIQQgKINwP4ASAEIBBCPIZCgICAgICAgIAwgyARQgSIhDcD8AEgBCAFKQD4ASIQQv//////////P4M3A4ACIAQgBSkAgAIiEUIChkL8/////////z+DIBBCPoiENwOIAiAEIAUpAIgCIhBCBIZC8P////////8/gyARQjyIhDcDkAIgBCAFKQCQAiIRQgaGQsD/////////P4MgEEI6iIQ3A5gCIAQgBSkAmAIiEEIIhkKA/v///////z+DIBFCOIiENwOgAiAEIAUpAKACIhFCCoZCgPj///////8/gyAQQjaIhDcDqAIgBCAFKQCoAiIQQgyGQoDg////////P4MgEUI0iIQ3A7ACIAQgBSkAsAIiEUIOhkKAgP///////z+DIBBCMoiENwO4AiAEIAUpALgCIhBCEIZCgID8//////8/gyARQjCIhDcDwAIgBCAFKQDAAiIRQhKGQoCA8P//////P4MgEEIuiIQ3A8gCIAQgBSkAyAIiEEIUhkKAgMD//////z+DIBFCLIiENwPQAiAEIAUpANACIhFCFoZCgICA/v////8/gyAQQiqIhDcD2AIgBCAFKQDYAiIQQhiGQoCAgPj/////P4MgEUIoiIQ3A+ACIAQgBSkA4AIiEUIahkKAgIDg/////z+DIBBCJoiENwPoAiAEIAUpAOgCIhBCHIZCgICAgP////8/gyARQiSIhDcD8AIgBCAFKQDwAiIRQh6GQoCAgID8////P4MgEEIiiIQ3A/gCIAQgBSkA+AIiEEIghkKAgICA8P///z+DIBFCIIiENwOAAyAEIAUpAIADIhFCIoZCgICAgMD///8/gyAQQh6IhDcDiAMgBCAFKQCIAyIQQiSGQoCAgICA/v//P4MgEUIciIQ3A5ADIAQgBSkAkAMiEUImhkKAgICAgPj//z+DIBBCGoiENwOYAyAEIAUpAJgDIhBCKIZCgICAgIDg//8/gyARQhiIhDcDoAMgBCAFKQCgAyIRQiqGQoCAgICAgP//P4MgEEIWiIQ3A6gDIAQgBSkAqAMiEEIshkKAgICAgID8/z+DIBFCFIiENwOwAyAEIAUpALADIhFCLoZCgICAgICA8P8/gyAQQhKIhDcDuAMgBCAFKQC4AyIQQjCGQoCAgICAgMD/P4MgEUIQiIQ3A8ADIAQgBSkAwAMiEUIyhkKAgICAgICA/j+DIBBCDoiENwPIAyAEIAUpAMgDIhBCNIZCgICAgICAgPg/gyARQgyIhDcD0AMgBCAFKQDQAyIRQjaGQoCAgICAgIDgP4MgEEIKiIQ3A9gDIAQgBSkA2AMiEEI4hkKAgICAgICAgD+DIBFCCIiENwPgAyAEIAUpAOADIhFCOoZCgICAgICAgIA8gyAQQgaIhDcD6AMgBCAFKQDoAyIQQgKINwP4AyAEIBBCPIZCgICAgICAgIAwgyARQgSIhDcD8AMMAwsgBkH3A00EQAwLCyAEIAUpAAAiEEL///////////8AgzcDACAEIAUpAAgiEUIBhkL+//////////8AgyAQQj+IhDcDCCAEIAUpABAiEEIChkL8//////////8AgyARQj6IhDcDECAEIAUpABgiEUIDhkL4//////////8AgyAQQj2IhDcDGCAEIAUpACAiEEIEhkLw//////////8AgyARQjyIhDcDICAEIAUpACgiEUIFhkLg//////////8AgyAQQjuIhDcDKCAEIAUpADAiEEIGhkLA//////////8AgyARQjqIhDcDMCAEIAUpADgiEUIHhkKA//////////8AgyAQQjmIhDcDOCAEIAUpAEAiEEIIhkKA/v////////8AgyARQjiIhDcDQCAEIAUpAEgiEUIJhkKA/P////////8AgyAQQjeIhDcDSCAEIAUpAFAiEEIKhkKA+P////////8AgyARQjaIhDcDUCAEIAUpAFgiEUILhkKA8P////////8AgyAQQjWIhDcDWCAEIAUpAGAiEEIMhkKA4P////////8AgyARQjSIhDcDYCAEIAUpAGgiEUINhkKAwP////////8AgyAQQjOIhDcDaCAEIAUpAHAiEEIOhkKAgP////////8AgyARQjKIhDcDcCAEIAUpAHgiEUIPhkKAgP7///////8AgyAQQjGIhDcDeCAEIAUpAIABIhBCEIZCgID8////////AIMgEUIwiIQ3A4ABIAQgBSkAiAEiEUIRhkKAgPj///////8AgyAQQi+IhDcDiAEgBCAFKQCQASIQQhKGQoCA8P///////wCDIBFCLoiENwOQASAEIAUpAJgBIhFCE4ZCgIDg////////AIMgEEItiIQ3A5gBIAQgBSkAoAEiEEIUhkKAgMD///////8AgyARQiyIhDcDoAEgBCAFKQCoASIRQhWGQoCAgP///////wCDIBBCK4iENwOoASAEIAUpALABIhBCFoZCgICA/v//////AIMgEUIqiIQ3A7ABIAQgBSkAuAEiEUIXhkKAgID8//////8AgyAQQimIhDcDuAEgBCAFKQDAASIQQhiGQoCAgPj//////wCDIBFCKIiENwPAASAEIAUpAMgBIhFCGYZCgICA8P//////AIMgEEIniIQ3A8gBIAQgBSkA0AEiEEIahkKAgIDg//////8AgyARQiaIhDcD0AEgBCAFKQDYASIRQhuGQoCAgMD//////wCDIBBCJYiENwPYASAEIAUpAOABIhBCHIZCgICAgP//////AIMgEUIkiIQ3A+ABIAQgBSkA6AEiEUIdhkKAgICA/v////8AgyAQQiOIhDcD6AEgBCAFKQDwASIQQh6GQoCAgID8/////wCDIBFCIoiENwPwASAEIAUpAPgBIhFCH4ZCgICAgPj/////AIMgEEIhiIQ3A/gBIAQgBSkAgAIiEEIghkKAgICA8P////8AgyARQiCIhDcDgAIgBCAFKQCIAiIRQiGGQoCAgIDg/////wCDIBBCH4iENwOIAiAEIAUpAJACIhBCIoZCgICAgMD/////AIMgEUIeiIQ3A5ACIAQgBSkAmAIiEUIjhkKAgICAgP////8AgyAQQh2IhDcDmAIgBCAFKQCgAiIQQiSGQoCAgICA/v///wCDIBFCHIiENwOgAiAEIAUpAKgCIhFCJYZCgICAgID8////AIMgEEIbiIQ3A6gCIAQgBSkAsAIiEEImhkKAgICAgPj///8AgyARQhqIhDcDsAIgBCAFKQC4AiIRQieGQoCAgICA8P///wCDIBBCGYiENwO4AiAEIAUpAMACIhBCKIZCgICAgIDg////AIMgEUIYiIQ3A8ACIAQgBSkAyAIiEUIphkKAgICAgMD///8AgyAQQheIhDcDyAIgBCAFKQDQAiIQQiqGQoCAgICAgP///wCDIBFCFoiENwPQAiAEIAUpANgCIhFCK4ZCgICAgICA/v//AIMgEEIViIQ3A9gCIAQgBSkA4AIiEEIshkKAgICAgID8//8AgyARQhSIhDcD4AIgBCAFKQDoAiIRQi2GQoCAgICAgPj//wCDIBBCE4iENwPoAiAEIAUpAPACIhBCLoZCgICAgICA8P//AIMgEUISiIQ3A/ACIAQgBSkA+AIiEUIvhkKAgICAgIDg//8AgyAQQhGIhDcD+AIgBCAFKQCAAyIQQjCGQoCAgICAgMD//wCDIBFCEIiENwOAAyAEIAUpAIgDIhFCMYZCgICAgICAgP//AIMgEEIPiIQ3A4gDIAQgBSkAkAMiEEIyhkKAgICAgICA/v8AgyARQg6IhDcDkAMgBCAFKQCYAyIRQjOGQoCAgICAgID8/wCDIBBCDYiENwOYAyAEIAUpAKADIhBCNIZCgICAgICAgPj/AIMgEUIMiIQ3A6ADIAQgBSkAqAMiEUI1hkKAgICAgICA8P8AgyAQQguIhDcDqAMgBCAFKQCwAyIQQjaGQoCAgICAgIDg/wCDIBFCCoiENwOwAyAEIAUpALgDIhFCN4ZCgICAgICAgMD/AIMgEEIJiIQ3A7gDIAQgBSkAwAMiEEI4hkKAgICAgICAgP8AgyARQgiIhDcDwAMgBCAFKQDIAyIRQjmGQoCAgICAgICA/gCDIBBCB4iENwPIAyAEIAUpANADIhBCOoZCgICAgICAgID8AIMgEUIGiIQ3A9ADIAQgBSkA2AMiEUI7hkKAgICAgICAgPgAgyAQQgWIhDcD2AMgBCAFKQDgAyIQQjyGQoCAgICAgICA8ACDIBFCBIiENwPgAyAEIAUpAOgDIhFCPYZCgICAgICAgIDgAIMgEEIDiIQ3A+gDIAQgBSkA8AMiEEIBiDcD+AMgBCAQQj6GQoCAgICAgICAwACDIBFCAoiENwPwAwwCCyAGQf8DTQRADAoLIAQgBSkAADcDACAEIAUpAAg3AwggBCAFKQAQNwMQIAQgBSkAGDcDGCAEIAUpACA3AyAgBCAFKQAoNwMoIAQgBSkAMDcDMCAEIAUpADg3AzggBCAFKQBANwNAIAQgBSkASDcDSCAEIAUpAFA3A1AgBCAFKQBYNwNYIAQgBSkAYDcDYCAEIAUpAGg3A2ggBCAFKQBwNwNwIAQgBSkAeDcDeCAEIAUpAIABNwOAASAEIAUpAIgBNwOIASAEIAUpAJABNwOQASAEIAUpAJgBNwOYASAEIAUpAKABNwOgASAEIAUpAKgBNwOoASAEIAUpALABNwOwASAEIAUpALgBNwO4ASAEIAUpAMABNwPAASAEIAUpAMgBNwPIASAEIAUpANABNwPQASAEIAUpANgBNwPYASAEIAUpAOABNwPgASAEIAUpAOgBNwPoASAEIAUpAPABNwPwASAEIAUpAPgBNwP4ASAEIAUpAIACNwOAAiAEIAUpAIgCNwOIAiAEIAUpAJACNwOQAiAEIAUpAJgCNwOYAiAEIAUpAKACNwOgAiAEIAUpAKgCNwOoAiAEIAUpALACNwOwAiAEIAUpALgCNwO4AiAEIAUpAMACNwPAAiAEIAUpAMgCNwPIAiAEIAUpANACNwPQAiAEIAUpANgCNwPYAiAEIAUpAOACNwPgAiAEIAUpAOgCNwPoAiAEIAUpAPACNwPwAiAEIAUpAPgCNwP4AiAEIAUpAIADNwOAAyAEIAUpAIgDNwOIAyAEIAUpAJADNwOQAyAEIAUpAJgDNwOYAyAEIAUpAKADNwOgAyAEIAUpAKgDNwOoAyAEIAUpALADNwOwAyAEIAUpALgDNwO4AyAEIAUpAMADNwPAAyAEIAUpAMgDNwPIAyAEIAUpANADNwPQAyAEIAUpANgDNwPYAyAEIAUpAOADNwPgAyAEIAUpAOgDNwPoAyAEIAUpAPADNwPwAyAEIAUpAPgDNwP4AwwBCyAKQQE2AhQgCkH8ic8ANgIQIApCATcCHCAKQTs2AiwgCiAKQShqNgIYIAogCkEMajYCKCAKQRBqQbSKzwAQ7ywACyAKQTBqJAAgACAJIA1qIgk2AhggBiANayEGIARBgARqIQQgByEFIAxBQGoiDEE/Sw0ACwwFCyACIAJBmLrOABDDIQALQfy4zgBBGkGIus4AEMskAAsgBSAFQUBrQei5zgAQsTsACyAFQUBrIAJB6LnOABCwOwALIAkgDkH4uc4AEK87AAsCQCAMQR9NIANBIEtyDQAgCEEIaiIGQQBBgAH8CwAgACgCCCIFIAAoAhgiBE8EQCAAKAIEIARqIAUgBGsgBiADENgLIAAgBCADQQJ0ajYCGEEIIQUgCEGQAWogBkGAAfwKAAAgCEEgNgKMASAHIAIgAiAHSRshBCABIAdBA3RqIQkCQANAIAQgB0YNASAJIAhBiAFqIAVqNQIANwMAIAlBCGohCSAHQQFqIQcgBUEEaiIFQYgBRw0ACyAIQSA2AogBDAILIAQgAkHYuc4AEMMhAAsgBCAFQcy4zgAQrzsACwJAIAsgB2siDEEPTSADQRBLcg0AIAhBIGoiBkIANwMAIAhBGGoiCUIANwMAIAhBEGoiCkIANwMAIAhCADcDCCAAKAIIIgUgACgCGCIETwRAIAAoAgQgBGogBSAEayAIQQhqIAMQyBAgACAEIANBAXRqNgIYIAhBqAFqIAYpAwA3AgAgCEGgAWogCSkDADcCACAIQZgBaiAKKQMANwIAIAggCCkDCDcCkAEgASAHQQN0aiEJIAcgByACIAIgB0kbIgRrIQogCEGQAWohBkEAIQUCQANAIAUgCmpFDQEgCSAGMwEANwMAIAlBCGohCSAGQQJqIQYgBUEBaiIFQRBHDQALIAUgB2ohByAMIAVrIQwMAgsgBCACQci5zgAQwyEACyAEIAVB3LjOABCvOwALAkAgDEEHTSADQQhLcg0AIAhCADcDCCAAKAIIIgUgACgCGCIETwRAIAAoAgQgBGogBSAEayAIQQhqIAMQtBYgACADIARqNgIYIAggCCkDCDcCkAEgASAHQQN0aiEJIAcgByACIAIgB0kbIgRrIQYgCEEINgKMAUEAIQUCQANAIAUgBmpFDQEgCSAFIAhqQZABajEAADcDACAJQQhqIQkgBUEBaiIFQQhHDQALIAhBCDYCiAEgBSAHaiEHDAILIAQgAkG4uc4AEMMhAAsgBCAFQey4zgAQrzsACwJAAkAgByALSQRAIAsgB2shBiABIAdBA3RqIQkgByACIAIgB0kbIgEgB2shBQNAIAhBiAFqIAAgAxDfDSAIKAKIAUUNAyAFRQ0CIAkgCCkDkAE3AwAgBUEBayEFIAlBCGohCSAGQQFrIgYNAAsLIAhBkAJqJAAgCw8LIAEgAkGouc4AEMMhAAtB/LjOAEEaQZi5zgAQyyQAC0HU7s4AQS1BxO7OABCfKQAL7AoBB38jAEFAaiIGJAAgBiACNgIcIAYgATYCGAJAAkACQAJAAkACQCAGQRhqKAIEIgggBSgCCEYEQCAEKAIAIgpFDQIgAygCCCAEKAIIQQJ2Rw0BDAMLIAZBLGpBMkEAQQFBARCgGCAGKAIwIQEgBigCLEEBRg0FIAYoAjQiAkGcgoYBQTL8CgAAIABBMjYCECAAIAI2AgwgACABNgIIIABCgICAgNiBgICAfzcCACAEKAIAIQoMAwsgBkEsakEnQQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQQgBigCNCICQZiAhgFBJ/wKAAAgAEEnNgIQIAAgAjYCDCAAIAE2AgggAEKAgICA2IGAgIB/NwIADAILIAhBA3QhASAFKAIEIQIDQCABRQ0BIAFBCGshASACKAIEIQcgAigCACACQQhqIQIgBygCCEEBa0F4cWpBCGogBygCJBEEACADKAIIRg0ACyAGQSxqQcwAQQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQMgBigCNCICQdCBhgFBzAD8CgAAIABBzAA2AhAgACACNgIMIAAgATYCCCAAQoCAgIDYgYCAgH83AgBBACEKDAELIAZBEGogBkEYahCwLiAGQSBqQYCAgIB4IAYoAhAiAiAGKAIUIgdGBH9BAQUgAi0AACEBIAcgAkEIaiICRwRAIAcgAmtBA3YhBwNAIAIsAAAiCSABwCIBIAEgCUgbIQEgAkEIaiECIAdBAWsiBw0ACwsgAcBBAWoLQcCAhgEQsxUgBSgCBCECIAZBCGogBkEYahCwLgJAAkACQAJAIAYoAgwgBigCCCIBa0EDdiIHIAggByAISRsiCUUEQCAGKAIkIQsgBigCKCEHDAELIAYoAighBwNAIAEsAAAhCCACKAIAIAJBBGooAgAiCygCCEEBa0F4cWpBCGogCygCJBEEACEMIAcgCE0NAiAGKAIkIgsgCEECdGogDDYCACACQQhqIQIgAUEIaiEBIAlBAWsiCQ0ACwsgAygCBCIBIAMoAggiCGohCUEAIQICQAJAAkADQCACIAhGDQEgASACaiwAACIMIAdJBEAgAkEBaiECIAsgDEECdGooAgBBgICAgHhHDQELC0E0IQcgBkEsakE0QQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQUgBigCNCICQYuBhgFBNPwKAAAMAQsgCkUNASAEKAIIIQcgBiAEKAIEIgI2AiwgBiAJNgI8IAYgATYCOCAGIAIgB0F8cWo2AjAgBkE4ahCDOyEBIAZBLGoQnjYiByABIAEgB0sbIQEgBigCOCEHIAYoAiQhCyAGKAIoIQgDQCABRQ0CIAIoAgAiDEEATgRAIAggBywAACIJTQ0FIAFBAWshASAHQQFqIQcgAkEEaiECIAwgCyAJQQJ0aigCAEgNAQsLQTshByAGQSxqQTtBAEEBQQEQoBggBigCMCEBIAYoAixBAUYNByAGKAI0IgJB0ICGAUE7/AoAAAsgACAHNgIQIAAgAjYCDCAAIAE2AgggAEKAgICA2IGAgIB/NwIAIAZBIGpBBEEEEOAeDAQLIAAgBigCGCAGKAIcIAMgBCAFEI4QIAZBIGpBBEEEEOAeDAQLIAggB0HAgYYBEMMhAAsgCSAIQdCChgEQwyEACwwCCyAFEMMnIAVBBEEIEOAeAkAgCkUNACAKIAooAgAiAEEBazYCACAAQQFHDQAgBBD7HgsgAygCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgAxD7HgsgBigCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEYahCGHQsgBkFAayQADwsgASAGKAI0QYiAhgEQ/S8AC6cgAhF/AX4gASgCCCABKAIESwRAQbp/DwsgAigCBCIEIAIoAggiCUkEQEG4fw8LIANBAksEQEFWDwsCQCAAKALkEkUEQCAAKAL4EiIGIAQgCWtqIQ8CQCADDQAgACgCfEEBRyAPQf//B0tyDQAgBgRAQU4hBiACKAIAIAAoAuwSRw0DIAkgACgC8BJHDQMLIAJBCGogBDYCACACKQIAIRUgACAPNgL4EiAAQfQSaiAENgIAIAAgFTcC7BJBAkEGIAAoAgwbDwsjAEHgAWsiCiQAIApBNGogAEEMaiIFQawB/AoAACAAKAKgEyEMIAAoApwTIQkgACgCmBMhCwJAAkAgACgChBMiBEUNACAAKAKQEw0AIAAoAowTIQYgACgCiBMgCkEQaiAAQcAFaigCADYCACAKIAApArgFNwMIIAQhDSEEIwBBsANrIgckACAHQdgBaiAFQawB/AoAAAJAIApBCGoiECgCACIORSAQKAIEIhNFcw0AAkAgBygCxAIiCARAIAdBuAFqIAcoAoQCQgAgBEECEIARIAcoAtABQQNrQQJNBEAgByAHKALAAUECajYCwAELIAdBuAFqIAdB3AFqEMQcDAELIAdBuAFqIAVCfyAEQQIQ9xULAkACQCAHKALQAUEDa0ECSw0AIAcoArwBIgUgBygCwAFPDQAgBUEZSQ0BC0EAIQggB0EANgLEAiAHQbgBaiAHQdgBakJ/IARBAhD3FQsgB0H0AWogB0HQAWooAgA2AgAgB0HsAWogB0HIAWopAwA3AgAgB0HkAWogB0HAAWopAwA3AgAgByAHKQO4ATcC3AECQCAHKALcAiIFDQBBAiEFIAcoAtABQQZrQX1JDQBBAUECIAcoArgBQRFLGyEFCyAHIAU2AtwCIBAoAgghECAHQbgBaiAFIAhBABD4FUGw6gBqIQgCQAJ/IA4EQCAQIAggDhECAAwBCyAIEIYvCyIRRQRAQQAhCAwBCyAHQYQDaiIUIBEgCBDLKCAHIAcoAowDIghBsCZqIhE2ApQDIAcgETYCkAMgByARNgKMAyAIQRBqIBRBLPwKAAAgCCAFNgKoJiAIQQA2AqQmIAggEDYCnCYgCCATNgKYJiAIIA42ApQmCyAHQQxqIgUgB0HYAWpBrAH8CgAAIAggBSkCBDcC+AEgCCAFKAJsNgKsASAIQZACaiAFQRxqKAIANgIAIAhBiAJqIAVBFGopAgA3AgAgCEGAAmogBUEMaikCADcCACAIIA02AgAgCCAGNgIIIAggBDYCBCAIQRBqIg1BgMQAENcnIQQgCEKEgICAgAE3AowmIAggBDYCDCAIQoCAgIAQNwKEJiAIQgA3AvwlIAhBADYCpAoCQCAIQUBrIg4gDSAFQQRqIAUoAoQBQQBBAUEAEPAIIgRBiH9LDQAgBUEBNgIgIAVBAzYCLCAIQaACaiAOQQAgDSAFIAgoAgAgCCgCBCAGQQFBASAIKAIMENsVIgRBiH9LDQAgCCAENgKgJkEAIQQLIARBiX9JDQAgCBCXE0EAIQgLIAdBsANqJAAgACAIIgQ2ApATIARFBEBBQCEEDAILIAAgBDYClBMLIABBmBNqIgRCADcDACAEQQhqQQA2AgACQCAAKAKUEyIGRQ0AIAAoApATDQAgCiAGKAKkJjYCYAsgA0ECRgRAIAAgD0EBaq03A8gECwJ/An8CQCALRQRAIAYNASAAKQPIBEIBfSEVQQAhBEEADAMLIAApA8gEQgF9IRUgCSAGDQEaIAkhBEEADAILIAApA8gEQgF9IRUgBigCBAshBCAGIApBNGogFRDmJAshBSAKQRhqIApBNGogFSAEIAUQ9xUgCkHQAGogCkEwaigCADYCACAKQcgAaiAKQShqKQIANwIAIApBQGsgCkEgaikCADcCACAKIAopAhg3AjgCQCAKKAK0ASIEDQBBAiEEIAooAlBBB0kNAEEBQQIgCigCOEEQSxshBAsgCiAENgK0AQJAIAooAogBIgQNAEECIQQgCigCUEEHSQ0AQQFBAiAKKAI4QRpLGyEECyAKIAQ2AogBAkAgCigCuAEiBA0AQQIhBCAKKAJQQQZrQX1JDQBBAUECIAooAjhBEUsbIQQLIAogBDYCuAEgCiAKKALYASIEQYCACCAEGzYC2AEgCiAKKALcASIEQQJBASAKKAJgQQpIGyAEGzYC3AEgCkE0aiENIwBB8AFrIgUkACAJIQcCQAJAIAYiBEUNACAEKAIEIgdFBEBBACEHDAELIBVCf1EgFUKAgAhUciAVIAetQgZ+VHJFBEAgBCgCpCYNAQsgDSgCPEEDRg0AIAQgDSAVEOYkBEAgBUFAayIJIA1BrAH8CgAAIAVBOGoiBiAEQZACaigCADYCACAFQTBqIgsgBEGIAmopAgA3AwAgBUEoaiIMIARBgAJqKQIANwMAIAUgBCkC+AE3AyAgCUEEciAFKAJEIQ0CQCAEKAKsAUUNACAFKAI4QQNrQQJLDQAgBUEGIAUoAihBAmsiCCAIQQZNGzYCKAsgBUEIaiAMKQMANwMAIAVBEGogCykDADcDACAFQRhqIAYoAgA2AgAgBSAFKQMgNwMAIAUgFSAHQQEgBSgCxAEQ6gsgBSANNgJEIAUgBCgCqCY2AsQBIAAgBUFAayAVQQBBABDUBSIGQYh/Sw0CIAQoAkAgBCgCRGsiCSAEKAJMRwRAIAAgBEFAazYCjBIgACAJIAAoAuQQIgtLBH8gACAJNgLoECAAIAk2AuQQIAAgACgC3BAgCWo2AtgQIAkFIAsLNgLwEAsgACAEKAKgJjYCkAQgACAEKAIENgKUBCAAKALQECAEQaACakH0I/wKAAAMAgsgBUFAayIJIA1BrAH8CgAAIAVBzABqIARBgAJqKQIANwIAIAVB1ABqIARBiAJqKQIANwIAIAVB3ABqIARBkAJqKAIANgIAIAUoAkQhBiAFIAQpAvgBNwJEIAUgBCgCqCY2AsQBIAUgBjYCREEAIQcgACAJIBVBAEEBENQFIgZBiH9LDQEgBEH4AWohCSAAIAAoAqAENgKoBAJAIAQoApACIgtBAUYNACALQQNrQQJNBEAgBCgCqCZBAUYNAQtBASAEKAL8AXQhBwsgACgCtBEgBCgCnAFBASAEKAKAAnQiCyAJEKUkAkAgACgC1AEiDEEBRg0AIAxBA2tBAk0EQCAAKAK8AkEBRg0BCyAAKAK8ESAEKAKkASAHIAkQpSQLAkAgBCgCkAJBBmtBfUkNACAEKAKoJkEBRw0AIAsEQCAAKAKAESAEKAJoIAv8CgAACyAAIAQpA5ABNwOoEQtBBCAAKAL4ECIJdEEAIAkbIgkEQCAAKAK4EUEAIAn8CwALIAAoAqQEIgkgACgCqARLBEAgACAJNgKoBAsgAEHYEGoiCSAEQUBrIgspAwA3AwAgCUEQaiALQRBqKQMANwMAIAlBCGogC0EIaikDADcDACAAIAQoAlw2AvQQIAAgBCgCWDYC8BAgACAEKAKgJjYCkAQgACAEKAIENgKUBCAAKALQECAEQaACakH0I/wKAAAMAQsgACANIBUgB0EAENQFIgZBiH9LDQAgAEG4AWohBiAAQZgEaiENIABBkAZqIQggAEHYEGohDyAAKALQECEOAn8gBARAIA4gDyAIIA0gBiAEKAIAIAQoAgQgBCgCCEEAQQAgACgCuBIQ2xUMAQsgDiAPIAggDSAGIAsgCSAMQQBBACAAKAK4EhDbFQsiBkGIf0sNACAAIAc2ApQEIAAgBjYCkARBACEGCyAFQfABaiQAIAYiBEGIf0sNACAAQgA3A8gSIAAgACgCqAIEf0EABSAAKALEBCIEIBUgBK1Rags2AtASIABCATcC5BIgAEIANwLcEkEAIQQLIApB4AFqJAAgBCIGQYh/Sw0BIAAgASACEMwoCyAAKAKoAiIFQQFGBEBBTiEGIAAoAuwSIAIoAgBHDQEgACgC9BIgAigCCEcNAQsCQCAAKAKsAkEBRw0AIAAoAvwSIAEoAgQgASgCCGtGDQBBTg8LQQAhCUEAIQQgAigCACINBEAgDSACKAIEaiEJIA0gAigCCGohBAsgASgCACIKBH8gCiABKAIEaiESIAogASgCCGoFQQALIQsgBUEBRgRAIAAoAvgSIQYgAEEANgL4EiACIAIoAgggBms2AgggBCAGayEECyADQQJHIQ8DQEEAIQUDQAJ/An8CfwJAIAVFBEBBQiEGQQAhBQJAAkAgACgC5BIOAwkBAAcLIAAoAtwSIQYgACgC4BIMBQsCQAJAAkACQAJAAkAgDw0AIAkgBGsiBhDnKSASIAtrIgVLBEAgACgCrAJBAUcNAQsgACgCzBINACAAIAsgBSAEIAYQnhMiBkGIf0sNDSAAQoCAgIAQNwLkEiAAQgA3A8gEIAYgC2ohCwwBCyAAKAKoAkUEQCAAIAAoAtASIAAoAswSIgVrIgYgCSAEayIMIAYgDEkbIgYEfyAGBEAgACgCwBIgBWogBCAG/AoAAAsgACgCzBIFIAULIAZqIgw2AswSIAQgBmpBACAEGyEEAkAgAw4CBQAGC0EBIQUgDCAAKALIEkYNCwwFCwJAIAMOAgACAwsgCSAEayIGIAAoAsQETw0EIAAgBjYC+BILQQEhBSAJIQQMCQtBASEFIAQgCUYNCAsgEiALayEGDAMLQQEhBSAMIAAoAtASSQ0GCyASIAtrIQYgACgCqAINAUEBIQwgACgCzBIgACgCyBJrDAILIAEgCyAKazYCCCACIAQgDWs2AgggACgC6BJFBEAgABCMKyIGQYh/Sw0HCyAAIAEgAhDMKCAAKALcEiAAKALgEmshBgwGC0EAIQwgCSAEayIFIAAoAsQEIgcgBSAHSRsLIgUQ5ykgBk0EQCALDAELIAsgACgCrAJBAUYNABogACgC2BIhBiAAKALUEgshBwJAIAwEQCAAKALAEiAAKALIEmohCAJ/IANBAkYgBCAJRnEiDARAIAAgByAGIAggBRCeEwwBCyAAIAcgBiAIIAUQ1DULIgZBiH9LDQUgACAMNgLoEiAAIAAoAsQEIgUgACgCzBIiCGoiDjYC0BIgACAAKALEEiAOSQR/IAAgBTYC0BIgAEEANgLMEkEABSAICzYCyBIMAQsCfyADQQJGIAQgBWoiCCAJRnEiDARAIAAgByAGIAQgBRCeEwwBCyAAIAcgBiAEIAUQ1DULIgZBiH9LDQQgACAMNgLoEiAIQQAgBBshBAsgByALRgRAIAYgC2ohC0EAIQUgDEUNAiAAQgA3A8gEIABBADYC5BJBASEFDAILIABCgICAgCA3A+ASIAAgBjYC3BJBAAshBSAAIBIgC2siDCAGIAVrIgcgByAMSxsiBgR/IAYEQCALIAAoAtQSIAVqIAb8CgAACyAAKALgEgUgBQsgBmo2AuASIAYgC2ohC0EBIQUgByAMSw0AIABCADcC3BIgACgC6BIEQCAAQgA3A8gEIABBADYC5BIMAQsLIABBATYC5BIMAAsACyAGC7kKAgh/A34jAEGQAWsiAiQAIAFBDGoQ2zwhCCACQRBqIAEQkjYQ7iUgCEEBdCIDIQQCQAJAAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCAGQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohByABKAIQIQggAikDcCELA0ACQCALUEUEQCACKQN4IQoMAQsDQAJ+AkAgAikDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAIgClCtQgGGNwNYIAqnQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiAHELYqIAIpA4ABIQoLIApCAFINAgsgAkIDNwNYCyACKQNIIgpCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCyAKp0EBcUUNByACIAIpA3hCQH0iCjcDeCACIAs3A3AgC1ANAAsLIAJCASALeiIMhiALhSILNwNwIAggDKcgCqdqIglBAnRqKAIAsrwiA0H///8DcSEFIANBgICAgHhxIQQCQCADQYCAgPwHcSIBQYCAgPwHRgRAIAVBDXYgBEEQdnIgBUEAR0EJdHJBgPgBciEEDAELIARBEHYhBCABQYCAgLgETQRAIAFBgICAxANPBEAgA0EMdiADQf/fAHFBAEdxIAFBDXYgBUENdmpBgIABaiAEcmohBAwCCyABQYCAgJgDSQ0BIAVBgICABHIiA0EeIAFBF3YiBWt2IQEgA0EdIAVrIgV2QQFxBH8gAUEDIAV0QQFrIANxQQBHagUgAQsgBHIhBAwBCyAEQYD4AXIhBAsgBiAJQQF0aiAEOwEADAALAAtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgASgCECEEA0AgBCgCALK8IgVB////A3EhByAFQYCAgIB4cSEBAkAgBUGAgID8B3EiA0GAgID8B0YEQCAHQQ12IAFBEHZyIAdBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgA0GAgIC4BE0EQCADQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSADQQ12IAdBDXZqQYCAAWogAXJqIQEMAgsgA0GAgICYA0kNASAHQYCAgARyIgVBHiADQRd2IgdrdiEDIAVBHSAHayIHdkEBcQR/IANBAyAHdEEBayAFcUEAR2oFIAMLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgBEEEaiEEIAggCUEBaiIJRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBSACKAI0IQYgASACQdAAaiIDKQIANwMAIAIpAyghCiACIAIpAkg3AyggAkEANgI4IAIgCjcCVCACQQA2AlAgAiAGNgJMIAIgBTYCSCACQQhqIAQQ1zsgAigCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiADKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAY2AogBIAIgBTYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgByACQSBqKQIANwMAIAMgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAu5CgIIfwN+IwBBkAFrIgIkACABQQxqENg8IQggAkEQaiABEJI2EO4lIAhBAXQiAyEEAkACQAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgBkEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEIIAIpA3AhCwNAAkAgC1BFBEAgAikDeCEKDAELA0ACfgJAIAIpA1giCkIDUgRAAkACQAJAIApCAlENACACIApQrUIBhjcDWCAKp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEKCyAKQgBSDQILIAJCAzcDWAsgAikDSCIKQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQsgCqdBAXFFDQcgAiACKQN4QkB9Igo3A3ggAiALNwNwIAtQDQALCyACQgEgC3oiDIYgC4UiCzcDcCAIIAynIAqnaiIJQQN0aikDALS8IgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCUEBdGogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQpAwC0vCIFQf///wNxIQcgBUGAgICAeHEhAQJAIAVBgICA/AdxIgNBgICA/AdGBEAgB0ENdiABQRB2ciAHQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIANBgICAuARNBEAgA0GAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgA0ENdiAHQQ12akGAgAFqIAFyaiEBDAILIANBgICAmANJDQEgB0GAgIAEciIFQR4gA0EXdiIHa3YhAyAFQR0gB2siB3ZBAXEEfyADQQMgB3RBAWsgBXFBAEdqBSADCyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIARBCGohBCAIIAlBAWoiCUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiAykCADcDACACKQMoIQogAiACKQJINwMoIAJBADYCOCACIAo3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiAEENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEM8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALuQoCCH8DfiMAQZABayICJAAgAUEMahDYPCEIIAJBEGogARCSNhDuJSAIQQF0IgMhBAJAAkACQCADQT5xIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAZBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEHIAEoAhAhCCACKQNwIQsDQAJAIAtQRQRAIAIpA3ghCgwBCwNAAn4CQCACKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgAiAKUK1CAYY3A1ggCqdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAcQtiogAikDgAEhCgsgCkIAUg0CCyACQgM3A1gLIAIpA0giCkICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyELIAqnQQFxRQ0HIAIgAikDeEJAfSIKNwN4IAIgCzcDcCALUA0ACwsgAkIBIAt6IgyGIAuFIgs3A3AgCCAMpyAKp2oiCUEDdGorAwC2vCIDQf///wNxIQUgA0GAgICAeHEhBAJAIANBgICA/AdxIgFBgICA/AdGBEAgBUENdiAEQRB2ciAFQQBHQQl0ckGA+AFyIQQMAQsgBEEQdiEEIAFBgICAuARNBEAgAUGAgIDEA08EQCADQQx2IANB/98AcUEAR3EgAUENdiAFQQ12akGAgAFqIARyaiEEDAILIAFBgICAmANJDQEgBUGAgIAEciIDQR4gAUEXdiIFa3YhASADQR0gBWsiBXZBAXEEfyABQQMgBXRBAWsgA3FBAEdqBSABCyAEciEEDAELIARBgPgBciEECyAGIAlBAXRqIAQ7AQAMAAsAC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACABKAIQIQQDQCAEKwMAtrwiBUH///8DcSEHIAVBgICAgHhxIQECQCAFQYCAgPwHcSIDQYCAgPwHRgRAIAdBDXYgAUEQdnIgB0EAR0EJdHJBgPgBciEBDAELIAFBEHYhASADQYCAgLgETQRAIANBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIANBDXYgB0ENdmpBgIABaiABcmohAQwCCyADQYCAgJgDSQ0BIAdBgICABHIiBUEeIANBF3YiB2t2IQMgBUEdIAdrIgd2QQFxBH8gA0EDIAd0QQFrIAVxQQBHagUgAwsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiAEQQhqIQQgCCAJQQFqIglHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC8kKAhB/An4jAEFAaiIFJAACQAJAIAEoAgwiDSACaiICIA1PBEACQCABKAIEIgkgCUEBaiILQQN2IgZBB2wgCUEISRsiD0EBdiACSQRAAn8gD0EBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBCEEQIAJBCEkbCyECIAVBMGogAUEQaiIHQQFBCCACEJ0UIAUoAjQhBiAFKAIwIgRFBEAgBSgCOCECDAULIAUpAjghFCAGQQlqIgIEQCAEQf8BIAL8CwALIAUgFEIgiD4CLCAFIBSnIgs2AiggBSAGNgIkIAUgBDYCICAFQoGAgICAATcCGCAFIAc2AhQgBUEgaiEOIAUgDQR/IARBCGohCiABKAIAIggpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQIDQCAUUARAA0AgAkEIaiECIAhBCGoiCCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgBCAGIAMgFHqnQQN2IAJqQX9zIgwgASgCAGoQwxCnIg9xIgdqKQAAQoCBgoSIkKDAgH+DIhVQBEBBCCEJA0AgByAJaiEHIAlBCGohCSAEIAYgB3EiB2opAABCgIGChIiQoMCAf4MiFVANAAsLIBRCAX0gFIMhFCAEIBV6p0EDdiAHaiAGcSIHaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAEIAdqIA9BGXYiCToAACAKIAdBCGsgBnFqIAk6AAAgBCAHQX9zaiABKAIAIAxqLQAAOgAAIA1BAWsiDQ0ACyABKAIMBUEACyICNgIsIAUgCyACazYCKCABIA5BBBD6KiAFKAIkIgJFDQEgAiAFKAIcIgEgBSgCGCACQQFqbGpBAWtBACABa3EiA2pBCWoiAkUNASAFKAIgIANrIAIgARD4OgwBCyABKAIAIQQgBiALQQdxQQBHaiIIBEAgBCECA0AgAiACKQMAIhRCf4VCB4hCgYKEiJCgwIABgyAUQv/+/fv379+//wCEfDcDACACQQhqIQIgCEEBayIIDQALCwJAAkAgC0EITwRAIAQgC2ogBCkAADcAAAwBCyALBEAgBEEIaiAEIAv8CgAACyALRQ0BCyAEQQhqIQ4gBEEBayESQQEhBkEAIQIDQCACIQcgBiECAkAgBCAHaiIQLQAAQYABRw0AIBIgB2shEyAEIAdBf3NqIQYDQCAJIAMgExDDEKciEXEiCiEIIAQgCmopAABCgIGChIiQoMCAf4MiFFAEQEEIIQwDQCAIIAxqIQggDEEIaiEMIAQgCCAJcSIIaikAAEKAgYKEiJCgwIB/gyIUUA0ACwsgBCAUeqdBA3YgCGogCXEiCGosAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhCAsgCCAKayAHIAprcyAJcUEITwRAIAQgCGoiCi0AACAKIBFBGXYiCjoAACAOIAhBCGsgCXFqIAo6AAAgBCAIQX9zaiEIQf8BRgRAIBBB/wE6AAAgDiAHQQhrIAlxakH/AToAACAIIAYtAAA6AAAMAwsgBi0AACEKIAYgCC0AADoAACAIIAo6AAAMAQsLIBAgEUEZdiIGOgAAIA4gB0EIayAJcWogBjoAAAsgAiACIAtJIgdqIQYgBw0ACwsgASAPIA1rNgIIC0GBgICAeCEGDAILEOMnIAUoAgQhAiAFKAIAIQYMAQsQ4ycgBSgCDCECIAUoAgghBgsgACAGNgIAIAAgAjYCBCAFQUBrJAALqwoBB38jAEFAaiIEJAACQCACLQAMIgNBAUYEQCABLQAMIQIgACABEOkdIAAgAjoADAwBCwJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAMIgZBAWsOAgsBAAsgA0UNAQwCCyADRQ0BCwJ/IAEoAggiAyACKAIIIgVHBEAgAyAFSyADIAVJawwBCyADQQJ0IQMgASgCBEEEayEIIAIoAgRBBGshCQJAA0AgA0UNASADIAlqIQcgAyAIaiADQQRrIQMoAgAiBSAHKAIAIgdGDQALIAUgB0sgBSAHSWsMAQtBf0EAIAMbCyIDQf8BcQ4CAgMBCwJAIAEoAgggAigCCEkEQCAEQSBqIgUgAhDpHSAEQTBqIAUgARDtCAwBCyAEQSBqIgUgARDpHSAEQTBqIAUgAhDtCAsgBkEBRwRAIAZBASAEKAI4GyEDDAcLIARBADYCOCAEQTBqQQRBBBCeJCAEKAI4IgJFDQUgBCgCNCIBIAJBAnQiBWpBBGsiA0UNBSADKAIADQUgBSEDIAFBBGshBiACQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAyAGaiADQQRrIQMoAgBFDQALIAFBAWoiAyACSw0GCyAEIAM2AjggAyECDAULIARBIGoiBSACEOkdIAUgARDvFCAEQThqIARBKGooAgA2AgAgBCAEKQIgNwMwIAZBAXFFBEBBAiAGa0EBIAQoAjgbIQMMBAsgBEEANgI4IARBMGpBBEEEEJ4kIAQoAjgiAkUNAiAEKAI0IgEgAkECdCIFakEEayIDRQ0CIAMoAgANAiAFIQMgAUEEayEGIAJB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAZqIANBBGshAygCAEUNAAsgAUEBaiIDIAJLDQMLIAQgAzYCOCADIQIMAgsgAEEIakGUiogBKQIANwIAIABBjIqIASkCADcCAAwGCyAEQSBqIgUgARDpHSAFIAIQ7xQgBEE4aiAEQShqKAIANgIAIAQgBCkCIDcDMAJAIAZBAUcEQCAGQQEgBCgCOBshAwwBCyAEQQA2AjggBEEwakEEQQQQniQCQCAEKAI4IgJFDQAgBCgCNCIBIAJBAnQiBWpBBGsiA0UNACADKAIADQAgBSEDIAFBBGshBiACQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAyAGaiADQQRrIQMoAgBFDQALIAFBAWoiAyACSw0BCyAEIAM2AjggAyECC0EBIQMgAiAEKAIwQQJ2Tw0AIARBEGogBEEwaiACQQRBBBD0FCAEKAIQIgFBgYCAgHhGDQAgASAEKAIUQcyNiAEQ/S8ACyAAIAQpAzA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwFC0EBIQMgAiAEKAIwQQJ2Tw0AIARBCGogBEEwaiACQQRBBBD0FCAEKAIIIgFBgYCAgHhGDQAgASAEKAIMQcyNiAEQ/S8ACyAAIAQpAzA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwDC0EBIQMgAiAEKAIwQQJ2Tw0AIARBGGogBEEwaiACQQRBBBD0FCAEKAIYIgFBgYCAgHhGDQAgASAEKAIcQcyNiAEQ/S8ACyAAIAQpAjA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwBCyAEQSBqIAIQ6R0gACAEKQIgNwIAIARBAiADazoALCAAQQhqIARBKGopAgA3AgALIARBQGskAAu2CgIIfwN+IwBBkAFrIgIkACABQQxqENk8IQggAkEQaiABEJI2EO4lIAhBAXQiAyEEAkACQAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgBkEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEIIAIpA3AhCwNAAkAgC1BFBEAgAikDeCEKDAELA0ACfgJAIAIpA1giCkIDUgRAAkACQAJAIApCAlENACACIApQrUIBhjcDWCAKp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEKCyAKQgBSDQILIAJCAzcDWAsgAikDSCIKQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQsgCqdBAXFFDQcgAiACKQN4QkB9Igo3A3ggAiALNwNwIAtQDQALCyACQgEgC3oiDIYgC4UiCzcDcCAIIAynIAqnakEBdCIJai4BALK8IgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCWogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQuAQCyvCIFQf///wNxIQcgBUGAgICAeHEhAQJAIAVBgICA/AdxIgNBgICA/AdGBEAgB0ENdiABQRB2ciAHQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIANBgICAuARNBEAgA0GAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgA0ENdiAHQQ12akGAgAFqIAFyaiEBDAILIANBgICAmANJDQEgB0GAgIAEciIFQR4gA0EXdiIHa3YhAyAFQR0gB2siB3ZBAXEEfyADQQMgB3RBAWsgBXFBAEdqBSADCyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIARBAmohBCAIIAlBAWoiCUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiAykCADcDACACKQMoIQogAiACKQJINwMoIAJBADYCOCACIAo3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiAEENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEM8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALtgoCCH8DfiMAQZABayICJAAgAUEMaigCCCEIIAJBEGogARCSNhDuJSAIQQF0IgMhBAJAAkACQCADQT5xIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAZBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEHIAEoAhAhCCACKQNwIQsDQAJAIAtQRQRAIAIpA3ghCgwBCwNAAn4CQCACKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgAiAKUK1CAYY3A1ggCqdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAcQtiogAikDgAEhCgsgCkIAUg0CCyACQgM3A1gLIAIpA0giCkICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyELIAqnQQFxRQ0HIAIgAikDeEJAfSIKNwN4IAIgCzcDcCALUA0ACwsgAkIBIAt6IgyGIAuFIgs3A3AgCCAMpyAKp2oiCWosAACyvCIDQf///wNxIQUgA0GAgICAeHEhBAJAIANBgICA/AdxIgFBgICA/AdGBEAgBUENdiAEQRB2ciAFQQBHQQl0ckGA+AFyIQQMAQsgBEEQdiEEIAFBgICAuARNBEAgAUGAgIDEA08EQCADQQx2IANB/98AcUEAR3EgAUENdiAFQQ12akGAgAFqIARyaiEEDAILIAFBgICAmANJDQEgBUGAgIAEciIDQR4gAUEXdiIFa3YhASADQR0gBWsiBXZBAXEEfyABQQMgBXRBAWsgA3FBAEdqBSABCyAEciEEDAELIARBgPgBciEECyAGIAlBAXRqIAQ7AQAMAAsAC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACABKAIQIQlBACEEA0AgBCAJaiwAALK8IgVB////A3EhByAFQYCAgIB4cSEBAkAgBUGAgID8B3EiA0GAgID8B0YEQCAHQQ12IAFBEHZyIAdBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgA0GAgIC4BE0EQCADQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSADQQ12IAdBDXZqQYCAAWogAXJqIQEMAgsgA0GAgICYA0kNASAHQYCAgARyIgVBHiADQRd2IgdrdiEDIAVBHSAHayIHdkEBcQR/IANBAyAHdEEBayAFcUEAR2oFIAMLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgCCAEQQFqIgRHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC7UKAgh/A34jAEGQAWsiAiQAIAFBDGoQ2zwhCCACQRBqIAEQkjYQ7iUgCEEBdCIDIQQCQAJAAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCAGQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohByABKAIQIQggAikDcCELA0ACQCALUEUEQCACKQN4IQoMAQsDQAJ+AkAgAikDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAIgClCtQgGGNwNYIAqnQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiAHELYqIAIpA4ABIQoLIApCAFINAgsgAkIDNwNYCyACKQNIIgpCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCyAKp0EBcUUNByACIAIpA3hCQH0iCjcDeCACIAs3A3AgC1ANAAsLIAJCASALeiIMhiALhSILNwNwIAggDKcgCqdqIglBAnRqKAIAIgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCUEBdGogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQoAgAiBUH///8DcSEHIAVBgICAgHhxIQECQCAFQYCAgPwHcSIDQYCAgPwHRgRAIAdBDXYgAUEQdnIgB0EAR0EJdHJBgPgBciEBDAELIAFBEHYhASADQYCAgLgETQRAIANBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIANBDXYgB0ENdmpBgIABaiABcmohAQwCCyADQYCAgJgDSQ0BIAdBgICABHIiBUEeIANBF3YiB2t2IQMgBUEdIAdrIgd2QQFxBH8gA0EDIAd0QQFrIAVxQQBHagUgAwsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiAEQQRqIQQgCCAJQQFqIglHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC7ALAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2zwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2oiB0ECdGo0AgAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAI0AgAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC7ALAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2TwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2oiB0EBdGoyAQAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAIyAQAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkECaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC60LAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2DwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2pBA3QiB2opAwAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAIpAwAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC+4KAgZ/BH4jAEGQAWsiAyQAIAFBDGoQ2DwhByADQQhqIAEQkjYQ7iUgB0EEdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBMHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEHIAIoAgAhBCABKAIQIQECQANAAkAgAykDaCIKUEUEQCADKQNwIQkMAQsDQAJ+AkAgAykDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAMgCVCtQgGGNwNQIAmnQQFxRQ0AIAMgAykDWDcDgAEMAQsgAygCYEUNASADQfgAaiAFELYqIAMpA3ghCQsgCUIAUg0CCyADQgM3A1ALIAMpA0AiCUICUQ0KIANCADcDQCADKQNIDAELIAMpA4ABCyEKIAmnQQFxRQ0IIAMgAykDcEJAfSIJNwNwIAMgCjcDaCAKUA0ACwsgAyAKQgEgCnoiC4aFNwNoQoCAgICAgICAgH8hDAJAIANB+ABqAn4CQAJAIAEgC6cgCadqIghBA3RqKQMAIgtCgICAgICAgICAf1IgBCgCACkDACIJQn9SckUEQEIAIQoMAQsgCVANAyALIAsgCX8iDCAJfn1CACAJQn9SGyEKIAtCAFkNAQsgDCAKIAQoAggpAwBXrX0MAQsgDCAKIAQoAgQpAwBZrXwLIgkgCUI/hyIKIActAAAQrQ4gAygCeCICQZOAgIB4Rw0CIAYgCEEEdGoiAiAKNwMIIAIgCTcDAAwBCwtBvI//ABDiKwALIAMpAnwhCSAAIAMpAoQBNwIQDAYLQcAAIAQQoz0AC0Hci/8AQSkgA0FAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACEBA0BCgICAgICAgICAfyEMIAUoAgApAwAhCSADQUBrAn4CQAJAIAQpAwAiCkKAgICAgICAgIB/UQRAQgAhCyAJQn9RDQELIAlQDQggCiAKIAl/IgwgCX59QgAgCUJ/UhshCyAKQgBZDQELIAwgCyAFKAIIKQMAV619DAELIAwgCyAFKAIEKQMAWa18CyIJIAlCP4ciCiAILQAAEK0OIAMoAkAiAkGTgICAeEcNAiAGIAk3AwAgBiAKNwMIIARBCGohBCAGQRBqIQYgByABQQFqIgFHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEEIAEgA0HIAGoiBikCADcDACADKQMgIQkgAyADKQJANwMgIANBADYCMCADIAk3AkwgA0EANgJIIAMgBDYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBDYCgAEgAyAFNgJ8IAMgATYCeCADQTRqIgEgA0H4AGoQ4hkgByADQRhqKQIANwMAIAYgA0EQaikCADcDACADIAMpAgg3A0AgACABIAIQyx0gA0EgahDPLwwCCyADKQJEIQkgACADKQJMNwIQCyAAIAk3AgggAEEpOgAAIAAgAjYCBCADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0GQAWokAA8LQbyP/wAQ4isAC0EEQRwQoz0AC/gLAQJ/IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCCCACQQE2AhQgAkGs7ocBNgIQIAJCATcCHCACQZgdNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAiACQQhqNgIMIAEoAgAgASgCBCACQRBqEMsKDBILIAIgAEEEajYCCCACQQE2AhQgAkHE7ocBNgIQIAJCATcCHCACQZkdNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAiACQQhqNgIMIAEoAgAgASgCBCACQRBqEMsKDBELIAIgAEEEajYCDCACQQE2AhQgAkHY7ocBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMEAsgAiAAQQRqNgIMIAJBATYCFCACQfDuhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwPCyACIABBBGo2AgwgAkEBNgIUIAJBiO+HATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDA4LIAIgAEEEajYCDCACQQE2AhQgAkGg74cBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMDQsgAiAAQQRqNgIMIAJBATYCFCACQbjvhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwMCyABKAIAQcDvhwFBFCABKAIEKAIMEQYADAsLIAIgAEEEajYCDCACQQE2AhQgAkHs74cBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMCgsgAiAAQQRqNgIMIAJBATYCFCACQYDwhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwJCyACIABBBGo2AgwgAkEBNgIUIAJBlPCHATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAgLIAIgADYCDCACQQE2AhQgAkGo8IcBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMBwsgAiAAQQRqNgIMIAJBATYCFCACQbzwhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwGCyACIABBBGo2AgwgAkEBNgIUIAJB3PCHATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAULIAIgAEEEajYCDCACQQE2AhQgAkH88IcBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMBAsgAiAAQQRqNgIMIAJBATYCFCACQZzxhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwDCyABKAIAQaTxhwFBJyABKAIEKAIMEQYADAILIAEoAgBBy/GHAUEqIAEoAgQoAgwRBgAMAQsgAiAAQQRqNgIMIAJBATYCFCACQYzyhwE2AhAgAkIBNwIcIAJB/Rw2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgsgAkEwaiQAC6YLAgN/BH4jAEHgAGsiAiQAAn8CfgJAAkACQAJAAkACQAJAAkAgASgCAEEBaw4HAQIDBAUGBwALIAAgAS0ALDoALCAAIAEoAig2AiggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxAgACABKQMINwMIIAEtAC0hA0EtDAgLIAAgAS0AOjoAOiAAIAEvATg7ATggACABKQMwNwMwIAAgASkDKDcDKCAAIAEpAyA3AyAgACABKQMYNwMYIAAgASkDEDcDECAAIAEpAwg3AwggAS0AOyEDQgEhBUE7DAcLIAAgAS0ASjoASiAAIAEvAUg7AUggACABKQNANwNAIAAgASkDODcDOCAAIAEpAzA3AzAgACABKQMoNwMoIAAgASkDIDcDICAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCABLQBLIQNCAiEFQcsADAYLIAEoAihBAUYEQCACQQhqIAFBNGooAgA2AgAgAiABKQIsNwMAQQEhBAsgASgCOEEBRgRAIAJBGGogAUHEAGooAgA2AgAgAiABKQI8NwMQQQEhAwsgACAENgIoIAAgAikDADcCLCAAIAM2AjggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxAgACABKQMINwMIIABBNGogAkEIaigCADYCACABLQBLIQMgAS0ASiEEIAAgAS8BSDsBSCAAIAQ6AEogAEHEAGogAkEYaigCADYCACAAIAIpAxA3AjxCAyEFQcsADAULIAAgAS0AOjoAOiAAIAEvATg7ATggACABKgI0OAI0IAAgASgCMDYCMCAAIAEqAiw4AiwgACABKAIoNgIoIAAgASkDIDcDICAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCABLQA7IQNCBCEFQTsMBAsgACABLQBKOgBKIAAgAS8BSDsBSCAAIAEpA0A3A0AgACABKQM4NwM4IAAgASkDMDcDMCAAIAEpAyg3AyggACABKwMgOQMgIAAgASkDGDcDGCAAIAErAxA5AxAgACABKQMINwMIIAEtAEshA0IFIQVBywAMAwsgASgCKEEBRgRAAkAgASgCLCIEBEAgAkEgaiABQThqIAEoAjAgASgCNCAEKAIAEQUADAELIAJBADYCIAtBASEECyABKAI8QQFGBEACQCABKAJAIgMEQCACQTBqIAFBzABqIAEoAkQgASgCSCADKAIAEQUADAELIAJBADYCMAtBASEDCyABKAIIQQFGBEAgASkDECEHQgEhBgsgASgCGEEBRgRAIAEpAyAhCEIBIQULIAAgBDYCKCAAIAg3AyAgACAFNwMYIAAgBzcDECAAIAY3AwggACACKQIgNwIsIAAgAzYCPCAAIAIpAzA3A0AgAEE0aiACQShqKQIANwIAIABByABqIAJBOGopAwA3AwAgAS0AUyEDIAEvAVAhBCAAIAEtAFI6AFIgACAEOwFQQgYMAQsgASgCKEEBRgRAAkAgASgCLCIEBEAgAkFAayABQThqIAEoAjAgASgCNCAEKAIAEQUADAELIAJBADYCQAtBASEECyABKAI8QQFGBEACQCABKAJAIgMEQCACQdAAaiABQcwAaiABKAJEIAEoAkggAygCABEFAAwBCyACQQA2AlALQQEhAwsgASgCCEEBRgRAIAEpAxAhB0IBIQYLIAEoAhhBAUYEQCABKQMgIQhCASEFCyAAIAQ2AiggACAINwMgIAAgBTcDGCAAIAc3AxAgACAGNwMIIAAgAikCQDcCLCAAIAM2AjwgACACKQNQNwNAIABBNGogAkHIAGopAgA3AgAgAEHIAGogAkHYAGopAwA3AwAgAS0AUyEDIAEvAVAhBCAAIAEtAFI6AFIgACAEOwFQQgcLIQVB0wALIABqIAM6AAAgACAFNwMAIAJB4ABqJAALqgsCBX8EfiMAQfABayIEJAAgAUEMahDbPCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAUQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASACIAynIAmnaiIHQQJ0ajUCACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAlCACALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQEMBwsgBEHAAWogCSADEI0QIAQoAsABIgFBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgAjUCACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIApCACAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghAQwDCyAEQegAaiAKIAMQjRAgBCgCaCIBQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQegAaiICEJcpIARB0ABqIgEoAgAhBiAEKAJUIQMgASAEQfAAaiIFKQIANwMAIAQpA0ghCSAEIAQpAmg3A0ggBEEANgJYIAQgCTcCdCAEQQA2AnAgBCADNgJsIAQgBjYCaCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogBEH4AGoiBygCADYCACAEIAM2AsgBIAQgBjYCxAEgBCABNgLAASAEQdwAaiIBIARBwAFqEOQZIAcgBEFAaykCADcDACAFIARBOGopAgA3AwAgBCAEKQIwNwNoIAAgASACEMYdIARByABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQcgAahDPLyAEKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBMGoQ+x4LIARB8AFqJAALqgsCBX8EfiMAQfABayIEJAAgAUEMahDZPCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAUQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASACIAynIAmnaiIHQQF0ajMBACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAlCACALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQEMBwsgBEHAAWogCSADEI0QIAQoAsABIgFBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgAjMBACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIApCACAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghAQwDCyAEQegAaiAKIAMQjRAgBCgCaCIBQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiACQQJqIQIgCCAFQQFqIgVHDQALCyAEQegAaiICEJcpIARB0ABqIgEoAgAhBiAEKAJUIQMgASAEQfAAaiIFKQIANwMAIAQpA0ghCSAEIAQpAmg3A0ggBEEANgJYIAQgCTcCdCAEQQA2AnAgBCADNgJsIAQgBjYCaCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogBEH4AGoiBygCADYCACAEIAM2AsgBIAQgBjYCxAEgBCABNgLAASAEQdwAaiIBIARBwAFqEOQZIAcgBEFAaykCADcDACAFIARBOGopAgA3AwAgBCAEKQIwNwNoIAAgASACEMYdIARByABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQcgAahDPLyAEKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBMGoQ+x4LIARB8AFqJAALqQsCBX8EfiMAQfABayIEJAAgAUEMaigCCCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQcgAy0AACEDIAIpAwAhCyABKAIQIQEDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAcQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASABIAynIAmnaiICajAAACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAkgCUI/hyALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQUMBwsgBEHAAWogCSADEI0QIAQoAsABIgVBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgAkEDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEBA0AgASACajAAACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIAogCkI/hyAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghBQwDCyAEQegAaiAKIAMQjRAgBCgCaCIFQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiAIIAFBAWoiAUcNAAsLIARB6ABqIgIQlykgBEHQAGoiASgCACEGIAQoAlQhAyABIARB8ABqIgUpAgA3AwAgBCkDSCEJIAQgBCkCaDcDSCAEQQA2AlggBCAJNwJ0IARBADYCcCAEIAM2AmwgBCAGNgJoIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQfgAaiIHKAIANgIAIAQgAzYCyAEgBCAGNgLEASAEIAE2AsABIARB3ABqIgEgBEHAAWoQ5BkgByAEQUBrKQIANwMAIAUgBEE4aikCADcDACAEIAQpAjA3A2ggACABIAIQxh0gBEHIAGoQzy8MAgtBBEEcEKM9AAsgACAKNwIQIAAgCTcCCCAAIAU2AgQgAEEpOgAAIARByABqEM8vIAQoAjAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEwahD7HgsgBEHwAWokAAvUCgIJfwN+IwBBkAFrIgMkACABQQxqENs8IQcgA0EIaiABEJI2EO4lIAdBBHQiBCEFAkACQAJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEIIAIoAgghCSACKAIAIQUgASgCECEKAkADQAJAIAMpA2giDVBFBEAgAykDcCEMDAELA0ACfgJAIAMpA1AiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDUCAMp0EBcUUNACADIAMpA1g3A4ABDAELIAMoAmBFDQEgA0H4AGogCBC2KiADKQN4IQwLIAxCAFINAgsgA0IDNwNQCyADKQNAIgxCAlENCiADQgA3A0AgAykDSAwBCyADKQOAAQshDSAMp0EBcUUNCCADIAMpA3BCQH0iDDcDcCADIA03A2ggDVANAAsLIAMgDUIBIA16Ig6GhTcDaEGAgICAeCEBAkAgA0H4AGoCfwJAAkAgCiAOpyAMp2oiC0ECdGooAgAiB0GAgICAeEcgBSgCACgCACICQX9HckUEQEEAIQQMAQsgAkUNAyAHIAcgAm0iASACbGtBACACQX9HGyEEIAdBAE4NAQsgASAEIAUoAggoAgBMawwBCyABIAQgBSgCBCgCAE5qC6wiDCAMQj+HIg0gCS0AABCtDiADKAJ4IgRBk4CAgHhHDQIgBiALQQR0aiIBIA03AwggASAMNwMADAELC0Gsj/8AEOIrAAsgAykCfCEMIAAgAykChAE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQogAigCACEFIAEoAhAhAgNAQYCAgIB4IQEgBSgCACgCACEEIANBQGsCfwJAAkAgAigCACIIQYCAgIB4RgRAQQAhCSAEQX9GDQELIARFDQggCCAIIARtIgEgBGxrQQAgBEF/RxshCSAIQQBODQELIAEgCSAFKAIIKAIATGsMAQsgASAJIAUoAgQoAgBOagusIgwgDEI/hyINIAotAAAQrQ4gAygCQCIEQZOAgIB4Rw0CIAYgDDcDACAGIA03AwggAkEEaiECIAZBEGohBiAHIAtBAWoiC0cNAAsLIANBQGsiAhCXKSADQShqIgEoAgAhBSADKAIsIQYgASADQcgAaiIEKQIANwMAIAMpAyAhDCADIAMpAkA3AyAgA0EANgIwIAMgDDcCTCADQQA2AkggAyAGNgJEIAMgBTYCQCADIAIQ1zsgAygCACEFQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBCkCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAGNgKAASADIAU2AnwgAyABNgJ4IANBNGoiASADQfgAahDiGSAHIANBGGopAgA3AwAgBCADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDLHSADQSBqEM8vDAILIAMpAkQhDCAAIAMpAkw3AhALIAAgDDcCCCAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBrI//ABDiKwALQQRBHBCjPQALwAsCCH8BfiMAQZAEayIDJAAgA0EoaiIEIAEgAigCFBEAACADIANBQGsiBjYCeCADQYACakGWrNiwATYCACADQpas2LDhwoWLFjcD+AEgAyADQfgBaiIFNgL4AwJAAkACQAJAAkACQAJAIAYgBRC7CARAIAUQpwwgA0EgaiAEENw7IAMoAiQiBUECSQ0CIAMoAiAiBSgCDCIHIAcoAgAiBkEBajYCACAGQQBIDQEgAyAHNgJsIAMgBSkCEDcCcCADQRhqIAQQ3DsCQAJAIAMoAhwEQCADQRBqIAMoAhgQxRsgAygCECEJIAMoAhQiCEECdCIEQTxxIgUEQCAEIAQgBWtBQGsiBEsNBwtBwAAhBSAEQcAAENE0RQ0HIAQEQCAEQcAAEK02IgVFDQkLIANCADcChAEgAyAFNgKAASADIAQ2AnxBwAAhCiADQcAANgJ4QQAhBiAIBEAgCEEDdCEEA0AgCSkDACILQoCAgIAIfEL/////D1YNAyAJQQhqIQkgBkEEaiIFIAMoAnwiCEsEQCADQfgAaiAIQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAnwhCCADKAKEASIGQQRqIQULIAUgCEsEfyADQfgAaiAIQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAoQBBSAGCyADKAKAAWogCz4AACADIAMoAoQBQQRqIgY2AoQBIAMgAygCiAFBAWo2AogBIARBCGsiBA0ACyADKAKAASEFIAMoAnghCiADKAJ8IQQLIANB2AJqIgcQlykgA0GAAWogA0HgAmoiCCkCADcDACADIAMpAtgCNwN4IANBADYCiAEgAyAENgLoAiADIAo2AuQCIANBADYC4AIgAyAGNgLcAiADIAU2AtgCIANBCGogBxDXOyADKAIIIQVBHEEEEK02IgRFDQkgBEKBgICAEDcCACAEIAMpAtgCNwIIIARBEGogCCkCADcCACAEQRhqIANB6AJqKAIANgIAIAMgBjYCmAEgAyAFNgKUASADIAQ2ApABIAEgAigCMBEEACEEIAEgAigCJBEEACEBIANBgANqQZSo0KABNgIAIANClKjQoMGChYoUNwL4AiADQgQ3AvACIANCADcC6AIgA0KAgICAwAA3AuACIANBADYC2AIgA0EAOwGwAyADIAQ2AqwDIANBADYClAMgA0EANgKIAyADIAE2AoQDIANB+AFqIgEgByADQZABahD6IyADQYAEaiADQfQAaigCADYCACADIAMpAmw3A/gDIAcgASADQfgDahD6IyABIANB1ABqQQAgAygCVBsQ7iUgA0GcAWoiAiAHIAEQwhkgA0G0A2oiASACEM0cIAcgARCNDEHEAEEEEK02IgFFDQogAUKBgICAEDcCACABQQhqIAdBPPwKAAAgAEGg4f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB+ABqEM8vDAILQQBBAEG46/8AEMMhAAsgA0EFNgL8ASADQcTt/wA2AvgBIANCBDcChAIgA0HMATYC9AIgA0H07f8ANgLwAiADQcwBNgLsAiADQfjs/wA2AugCIANBzAE2AuQCIANB9O3/ADYC4AIgA0HMATYC3AIgA0GY7f8ANgLYAiADIANB2AJqNgKAAiADQfwDaiADQfgBahCZDiAAIAMpAoAENwIIIABBEGogA0GIBGooAgA2AgAgACADKAL8AzYCBCAAQYaAgIB4NgIAIANB+ABqEM8vIAcgBygCACIAQQFrNgIAIABBAUcNACADQewAahD7HgsgA0EoahCAJyADQZAEaiQADwsgA0EANgLYAiADQfgAaiADQfgDaiADQdgCakGY6/8AEKMrCwALQQEgBUGo6/8AEMMhAAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgA0HYAmpBxMj/AEHYwf8AENUeAAtBwAAgBBCjPQALQQRBHBCjPQALQQRBxAAQoz0AC8ALAgh/AX4jAEGQBGsiAyQAIANBKGoiBCABIAIoAhQRAAAgAyADQUBrIgY2AnggA0GAAmpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A/gBIAMgA0H4AWoiBTYC+AMCQAJAAkACQAJAAkACQCAGIAUQuwgEQCAFEKcMIANBIGogBBDcOyADKAIkIgVBAkkNAiADKAIgIgUoAgwiByAHKAIAIgZBAWo2AgAgBkEASA0BIAMgBzYCbCADIAUpAhA3AnAgA0EYaiAEENw7AkACQCADKAIcBEAgA0EQaiADKAIYEMUbIAMoAhAhCSADKAIUIghBAnQiBEE8cSIFBEAgBCAEIAVrQUBrIgRLDQcLQcAAIQUgBEHAABDRNEUNByAEBEAgBEHAABCtNiIFRQ0JCyADQgA3AoQBIAMgBTYCgAEgAyAENgJ8QcAAIQogA0HAADYCeEEAIQYgCARAIAhBA3QhBANAIAkpAwAiC0KAgICACHxC/////w9WDQMgCUEIaiEJIAZBBGoiBSADKAJ8IghLBEAgA0H4AGogCEEBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJ8IQggAygChAEiBkEEaiEFCyAFIAhLBH8gA0H4AGogCEEBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAKEAQUgBgsgAygCgAFqIAs+AAAgAyADKAKEAUEEaiIGNgKEASADIAMoAogBQQFqNgKIASAEQQhrIgQNAAsgAygCgAEhBSADKAJ4IQogAygCfCEECyADQdgCaiIHEJcpIANBgAFqIANB4AJqIggpAgA3AwAgAyADKQLYAjcDeCADQQA2AogBIAMgBDYC6AIgAyAKNgLkAiADQQA2AuACIAMgBjYC3AIgAyAFNgLYAiADQQhqIAcQ1zsgAygCCCEFQRxBBBCtNiIERQ0JIARCgYCAgBA3AgAgBCADKQLYAjcCCCAEQRBqIAgpAgA3AgAgBEEYaiADQegCaigCADYCACADIAY2ApgBIAMgBTYClAEgAyAENgKQASABIAIoAjARBAAhBCABIAIoAiQRBAAhASADQYADakGYsODAATYCACADQpiw4MCBg4aMGDcC+AIgA0IENwLwAiADQgA3AugCIANCgICAgMAANwLgAiADQQA2AtgCIANBADsBsAMgAyAENgKsAyADQQA2ApQDIANBADYCiAMgAyABNgKEAyADQfgBaiIBIAcgA0GQAWoQ+iMgA0GABGogA0H0AGooAgA2AgAgAyADKQJsNwP4AyAHIAEgA0H4A2oQ+iMgASADQdQAakEAIAMoAlQbEO4lIANBnAFqIgIgByABEMIZIANBtANqIgEgAhDNHCAHIAEQjgxBxABBBBCtNiIBRQ0KIAFCgYCAgBA3AgAgAUEIaiAHQTz8CgAAIABByOv/ADYCCCAAIAE2AgQgAEGTgICAeDYCACADQfgAahDPLwwCC0EAQQBBuOv/ABDDIQALIANBBTYC/AEgA0HE7f8ANgL4ASADQgQ3AoQCIANBzAE2AvQCIANBiO3/ADYC8AIgA0HMATYC7AIgA0H47P8ANgLoAiADQcwBNgLkAiADQYjt/wA2AuACIANBzAE2AtwCIANBmO3/ADYC2AIgAyADQdgCajYCgAIgA0H8A2ogA0H4AWoQmQ4gACADKQKABDcCCCAAQRBqIANBiARqKAIANgIAIAAgAygC/AM2AgQgAEGGgICAeDYCACADQfgAahDPLyAHIAcoAgAiAEEBazYCACAAQQFHDQAgA0HsAGoQ+x4LIANBKGoQgCcgA0GQBGokAA8LIANBADYC2AIgA0H4AGogA0H4A2ogA0HYAmpBmOv/ABCjKwsAC0EBIAVBqOv/ABDDIQALQcjA/wBBI0HswP8AEMskAAtBrMH/AEEpIANB2AJqQcTI/wBB2MH/ABDVHgALQcAAIAQQoz0AC0EEQRwQoz0AC0EEQcQAEKM9AAujCwIFfwR+IwBB8AFrIgQkACABQQxqKAIIIQggBEEwaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AlAgBCAFNgJMIARBwAA2AkggBwRAIAZBACAH/AsACyAEIAg2AlggBCAHNgJUIAQoAjBFDQMgBCgCRCAEKAJARg0EIARB6ABqIARBMGoQyDQgBEGIAWohByADLQAAIQMgAikDACELIAEoAhAhAQNAAkAgBCkDkAEiClBFBEAgBCkDmAEhCQwBCwNAAn4CQCAEKQN4IglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A3ggCadBAXFFDQAgBCAEKQOAATcDyAEMAQsgBCgCiAFFDQEgBEHAAWogBxC2KiAEKQPAASEJCyAJQgBSDQILIARCAzcDeAsgBCkDaCIJQgJRDQkgBEIANwNoIAQpA3AMAQsgBCkDyAELIQogCadBAXFFDQcgBCAEKQOYAUJAfSIJNwOYASAEIAo3A5ABIApQDQALCyAEIApCASAKeiIMhoU3A5ABIAEgDKcgCadqIgJqMQAAIQkgBCALNwPoASAEIAk3A6ABIARBIGogCUIAIAsgC0I/hxCoHiAEKQMoIAQpAyAiCUI/h1IEQCAEQQI2AsQBIARBrJD/ADYCwAEgBEICNwLMASAEQYYMNgLkASAEQYYMNgLcASAEIARB2AFqNgLIASAEIARB6AFqNgLgASAEIARBoAFqNgLYASAEQbABaiAEQcABahCZDiAEKQKwASEJIAQpArgBIQpBiICAgHghBQwHCyAEQcABaiAJIAMQjRAgBCgCwAEiBUGTgICAeEcEQCAEKQLMASEKIAQpAsQBIQkMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB6ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQMgAikDACEJIAEoAhAhAkEAIQEDQCABIAJqMQAAIQogBCAJNwPYASAEIAo3A+gBIARBEGogCkIAIAkgCUI/hxCoHiAEKQMYIAQpAxAiCkI/h1IEQCAEQQI2AmwgBEGskP8ANgJoIARCAjcCdCAEQYYMNgK4ASAEQYYMNgKwASAEIARBrAFqNgJwIAQgBEHYAWo2ArQBIAQgBEHoAWo2AqwBIARBxAFqIARB6ABqEJkOIAQpAsQBIQkgBCkCzAEhCkGIgICAeCEFDAMLIARB6ABqIAogAxCNECAEKAJoIgVBk4CAgHhHBEAgBCkCdCEKIAQpAmwhCQwDCyAGIAo3AwAgBkEIaiEGIAggAUEBaiIBRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgBTYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC+MJASF/IwBB0ABrIgUkAEFsIQcCQCADQQpJDQACQCABQQZJDQAgAyACLwAEIgsgAi8AACIIIAIvAAIiCmpqQQZqIglJDQAgACABQQNqQQJ2IgxqIhYgDGoiFyAMaiIOIAAgAWoiGEsNACAEKAIAIAVBPGogAkEGaiICIAgQ3RMiB0GIf0sNASAFQShqIAIgCGoiAiAKEN0TIgdBiH9LDQEgBUEUaiACIApqIgIgCxDdEyIHQYh/Sw0BIAUgAiALaiADIAlrEN0TIgdBiH9LDQEgBEEEaiEIQRB2IR0CfyAYIA5rQQRJBEAgFyEEIBYhAiAODAELIBhBA2shHiAMQQF0IR8gDEEDbCEgQQAgHWtBH3EhCiAFKAIIIQ0gBSgCHCEPIAUoAjAhECAFKAJEIREgBSgCBCEEIAUoAhghAyAFKAIsIQcgBSgCQCELIAUoAhAhISAFKAIkISIgBSgCOCEjIAUoAkwhJCAFKAIAIRIgBSgCFCETIAUoAighFCAFKAI8IRVBACEJA0ACQCAAIAxqIQIgCUEBcQ0AIAAgIGoiCSAeTw0AIAggFSALdCAKdkEBdGoiBi0AACEZIAAgBi0AAToAACAIIBQgB3QgCnZBAXRqIgYtAAAhGiACIAYtAAE6AAAgCCATIAN0IAp2QQF0aiIGLQAAIRsgACAfaiIcIAYtAAE6AAAgCCASIAR0IAp2QQF0aiIGLQAAISUgCSAGLQABOgAAIAggFSALIBlqIgt0IAp2QQF0aiIGLQAAIRkgAEEBaiAGLQABOgAAIAggFCAHIBpqIgd0IAp2QQF0aiIGLQAAIRogAkEBaiAGLQABOgAAIAggEyADIBtqIgN0IAp2QQF0aiICLQAAIQYgHEEBaiACLQABOgAAIAggEiAEICVqIht0IAp2QQF0aiICLQAAIRwgCUEBaiACLQABOgAAIAsgGWohAkEDIQQCfyARICRJBEBBAyEJIAIMAQsgESACQQN2ayIRKAAAIRVBACEJIAJBB3ELIQsgByAaaiECIBAgI0kEfyACBSAQIAJBA3ZrIhAoAAAhFEEAIQQgAkEHcQshByADIAZqIQIgBCAJciEGQQMhCQJ/IA8gIkkEQEEDIQQgAgwBCyAPIAJBA3ZrIg8oAAAhE0EAIQQgAkEHcQshAyAbIBxqIQIgBCAGciANICFJBH8gAgUgDSACQQN2ayINKAAAIRJBACEJIAJBB3ELIQQgAEECaiEAIAlyQQBHIQkMAQsLIAUgBzYCLCAFIAs2AkAgBSADNgIYIAUgBDYCBCAFIBE2AkQgBSAQNgIwIAUgDzYCHCAFIA02AgggBSAVNgI8IAUgFDYCKCAFIBM2AhQgBSASNgIAIAAgDEEBdGohBCAAIAxBA2xqCyAAIBZLIAIgF0tyDQBBbCEHIAQgDksNASAAIAVBPGogFiAIIB1B/wFxIgAQ4BggAiAFQShqIBcgCCAAEOAYIAQgBUEUaiAOIAggABDgGCAFIBggCCAAEOAYQWxBbEFsQWxBbEFsQWxBbCABIAUoAgRBIEcbIAUoAgggBSgCDEcbIAUoAhhBIEcbIAUoAhwgBSgCIEcbIAUoAixBIEcbIAUoAjAgBSgCNEcbIAUoAkBBIEcbIAUoAkQgBSgCSEcbIQcMAQtBbCEHCyAFQdAAaiQAIAcL0wkBCX8CQAJAAkAgAEUNAAJAIABBAWsgAkkEQCAAIQUgASEEA0AgByAEKAIAQQBHaiEHIARBBGohBCAFQQFrIgUNAAsgB0EQSQ0CIABBAWohCCAAQQJ0IAFqQQRrIQQDQCAIQQFGDQMgCEEBayEIIAQoAgAgBEEEayEERQ0AC0GAgICABCEEIAghBiABIQVBACEAA0AgBCAFKAIAIgkgBCAJSRsgBCAJGyEEIAVBBGohBSAAIgogCUEARyIJaiEAIAZBAWsiBg0ACyAAQQVJDQIgCEEBa0ECSSAEQQNLciAIIAkgCmprQQVLckUEQCAIQQJrIQpBACEHIAEhBANAAkACQCACIAdHBEAgBCgCAEUNAiAEQQRqIgUoAgBFDQEMAgsgByACQbCT0gAQwyEACyAEQQhqKAIARQ0AIAVBATYCAAsgBEEEaiEEIAogB0EBaiIHRw0ACwsgAEEcSQ0CIANBAEHABfwLAEEAIQcgASgCACIGIQBBACEFA0ACQAJAIAUgCEYiCg0AIAIgBUsEQCABIAVBAnRqKAIAIABHDQEgB0EBaiEHDAILIAUgAkGAk9IAEMMhAAsCQCAARSAHQQVPcUUgAEUgB0EHSXJxRQRAIAVBAWshBANAIARBwAVPDQIgAyAEakEBOgAAIARBAWshBCAHQQFrIgcNAAsLQQEhByAKDQEgAiAFSwRAIAEgBUECdGooAgAhAAwCCyAFIAJBkJPSABDDIQALIARBwAVBoJPSABDDIQALIAUgCE8NAiAFIAUgCElqIgUgCE0NAAsMAQsgAiACQcCT0gAQwyEACyACQQFGDQIgAkECTQ0BIAFBBGshDCAIQQJrIQkgASgCCCABKAIEIAZqakEIdEEDbkGkA2ohB0EAIQVBACEEQQAhBgNAIAYgCEkhCwJAAkAgBiAIRiIKDQACQCAGQcAFSQRAIAMgBmoiAC0AAA0CIAZFDQEgAEEBay0AAEUNAQwCCyAGQcAFQZCS0gAQwyEACyACIAZLBEAgASAGQQJ0aigCACIAQQh0IAdrQdgJakGwE08NASAAIARqIQQgBUEBaiIFQQNNDQIgBEEIdCAFQQF2aiAFbiIAQfgAaiAAIAVBBEYbIQcMAgsgBiACQaCS0gAQwyEACwJAIAVBA01BACAFQQNHIARyGw0AQQEgBCAFQQF2aiAFbiIAIABBAU0bQQAgBBshACAGQQFrIQQgDCAGQQJ0aiEHA0AgAiAESwRAIAcgADYCACAHQQRrIQcgBEEBayEEIAVBAWsiBQ0BDAILCyAEIAJB8JLSABDDIQALAn8gBiAJTwRAQQAgC0UNARogASAGQQJ0aigCAEEIdAwBCwJAAkAgAiAGSwRAIAZBAWoiBSACTw0BIAZBAmoiACACSQ0CIAAgAkHQktIAEMMhAAsgBiACQbCS0gAQwyEACyAFIAJBwJLSABDDIQALIAEgAEECdGooAgAgASAFQQJ0aigCACABIAZBAnRqKAIAampBCHRBA25BpANqCyEHQQAhBEEBIQUgCg0AIAIgBksEQCABIAZBAnRqKAIAIQQMAQsgBiACQeCS0gAQwyEACyAGIAhPDQEgBiALaiIGIAhNDQALCw8LQQJBAkGAktIAEMMhAAtBAUEBQfCR0gAQwyEAC9IKAgl/A34jAEGQAWsiAyQAIAFBDGoQ2zwhByADQQhqIAEQkjYQ7iUgB0ECdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQcgAigCCCEIIAIoAgAhBSABKAIQIQkCQANAAkAgAykDaCINUEUEQCADKQNwIQwMAQsDQAJ+AkAgAykDUCIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwNQIAynQQFxRQ0AIAMgAykDWDcDgAEMAQsgAygCYEUNASADQfgAaiAHELYqIAMpA3ghDAsgDEIAUg0CCyADQgM3A1ALIAMpA0AiDEICUQ0KIANCADcDQCADKQNIDAELIAMpA4ABCyENIAynQQFxRQ0IIAMgAykDcEJAfSIMNwNwIAMgDTcDaCANUA0ACwsgAyANQgEgDXoiDoaFNwNoQYCAgIB4IQECQCADQfgAagJ/AkACQCAJIA6nIAynakECdCIKaigCACIEQYCAgIB4RyAFKAIAKAIAIgJBf0dyRQRAQQAhAgwBCyACRQ0DIAQgBCACbSIBIAJsa0EAIAJBf0cbIQIgBEEATg0BCyABIAIgBSgCCCgCAExrDAELIAEgAiAFKAIEKAIATmoLIgEgCC0AABDqDyADKAJ4IgRBk4CAgHhHDQIgBiAKaiABNgIADAELC0Gsj/8AEOIrAAsgACADKQKAATcCDCAAQRRqIANBiAFqKAIANgIAIAAgAygCfDYCCAwGC0HAACAEEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCiACKAIAIQUgASgCECECA0BBgICAgHghASAFKAIAKAIAIQQgA0FAawJ/AkACQCACKAIAIghBgICAgHhGBEBBACEJIARBf0YNAQsgBEUNCCAIIAggBG0iASAEbGtBACAEQX9HGyEJIAhBAE4NAQsgASAJIAUoAggoAgBMawwBCyABIAkgBSgCBCgCAE5qCyIBIAotAAAQ6g8gAygCQCIEQZOAgIB4Rw0CIAYgATYCACACQQRqIQIgBkEEaiEGIAcgC0EBaiILRw0ACwsgA0FAayICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANByABqIgYpAgA3AwAgAykDICEMIAMgAykCQDcDICADQQA2AjAgAyAMNwJMIANBADYCSCADIAQ2AkQgAyAFNgJAIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAMpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HQAGoiBygCADYCACADIAQ2AoABIAMgBTYCfCADIAE2AnggA0E0aiIBIANB+ABqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNAIAAgASACEModIANBIGoQzy8MAgsgACADKQJINwIMIABBFGogA0HQAGooAgA2AgAgACADKAJENgIICyAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBrI//ABDiKwALQQRBHBCjPQALhgsCBX8IfiMAQdABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAXRqLwEAELUuIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACLwEAELUuIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDYPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBA3RqKQMAELMuIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKQMAELMuIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAXRqLwEAEJMtIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACLwEAEJMtIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDbPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAnRqKAIAEJQvIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKAIAEJQvIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDYPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBA3RqKQMAEM4vIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKQMAEM4vIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDbPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAnRqKAIAEMktIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKAIAEMktIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALjwsBB38jAEGwAmsiAiQAIAJBADYCmAIgAkKAgICAEDcCkAIgAkH4AGoiBCACQZACaiIDEOcVIAJBIGpCADcDACACQShqQgA3AwAgAkHEAGpCADcCACACQcwAakIANwIAIAJB1ABqQgA3AgAgAkEYaiACQYABaikDADcDACACQQA6AGAgAkIANwI8IAJBADYCMCACQgE3AjQgAkEANgIIIAJBADYCXCACIAIpA3g3AxAgAyABQQxqIgcgASgCBCABKAIIIAEoAgAoAgARBQAgBCACQQhqIAMQuAQCQAJAAkACQAJAIAIoAngiA0EIRwRAIAAgAikCfDcCDCAAQRxqIAJBjAFqKAIANgIAIABBFGogAkGEAWopAgA3AgAgAEEBNgIAIAAgAzYCCAwBCyACIAIoAkAiBDYCaCACQewAakEAIARB7ITNABCzFSACQfgAaiACQQhqIAIoAnAgAigCdCIGEOgJIAIoAnwhAwJAIAIoAngiBUEIRwRAIAAgAikDgAE3AxAgAEEYaiACQYgBaikDADcDACAAIAM2AgwgACAFNgIIIABBATYCAAwBCyACIAM2ApACIAMgBEcNAiACQQA2AoACIAJCgICAgBA3AvgBIAJBkAJqIgQgAkH4AWoiAxDnFSACQZABakIANwMAIAJBmAFqQgA3AwAgAkG0AWpCADcCACACQbwBakIANwIAIAJBxAFqQgA3AgAgAkGIAWogAkGYAmopAwA3AwAgAkEAOgDQASACQgA3AqwBIAJBADYCoAEgAkIBNwKkASACQQA2AnggAkEANgLMASACIAIpA5ACNwOAASADIAEgAkEIahDeHBDqFCAEIAJB+ABqIAMQuAQCQCACKAKQAiIDQQhHBEAgACACKQKUAjcCDCAAQRxqIAJBpAJqKAIANgIAIABBFGogAkGcAmopAgA3AgAgAEEBNgIAIAAgAzYCCAwBCyACIAIoArABIgM2AtwBIAJB4AFqQQAgA0GMhc0AELMVIAJBkAJqIAJB+ABqIAIoAuQBIAIoAugBIgUQ6AkgAigClAIhBAJAIAIoApACIghBCEcEQCAAIAIpA5gCNwMQIABBGGogAkGgAmopAwA3AwAgACAENgIMIAAgCDYCCCAAQQE2AgAMAQsgAiAENgL4ASADIARHDQUgAyACKAJoRgRAIAIgBjYCiAIgAiAFNgKMAiAFIAZHDQcgACABKQIANwIoIAJBmAJqIgMgAkH0AGooAgA2AgAgAkGkAmogAkHoAWooAgA2AgAgAEEwaiABQQhqKQIANwIAIAIgAikCbDcDkAIgAiACKQLgATcCnAIgAkEIaiIBEN4cIQQgAkH4AGoiBhDeHCEFIABBADYCOCAAQQA2AiQgAEKAgICAEDcCHCAAQQA2AgAgAEEUaiACQaACaikDADcCACAAQQxqIAMpAwA3AgAgACACKQOQAjcCBCAAIAQgBWo2AjwgBhCCLSABEIItDAgLIAJBAjYClAIgAkH8hc0ANgKQAiACQgI3ApwCIAJBOzYChAIgAkE7NgL8ASACIAJB+AFqNgKYAiACIAJB3AFqNgKAAiACIAJB6ABqNgL4ASACQewBaiIDIAJBkAJqEJkOIABBDGogAxDdICAAQQE2AgAgAEEANgIIIAMQ3jsLIAJB4AFqEOk7CyACQfgAahCCLQsgAkHsAGoQ6TsLIAJBCGoQgi0gByABKAIEIAEoAgggASgCACgCEBEBAAwDCyACQQA2AnhBACACQZACaiACQegAaiACQfgAakH8hM0AEK8rAAsgAkEANgKQAkEAIAJB+AFqIAJB3AFqIAJBkAJqQZyFzQAQrysACyACQQA2ApACQQAgAkGIAmogAkGMAmogAkGQAmpBrIXNABCvKwALIAJBsAJqJAALmgsCBX8EfiMAQdABayIEJAAgAUEMahDYPCEIIARBEGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AjAgBCAFNgIsIARBwAA2AiggBwRAIAZBACAH/AsACyAEIAg2AjggBCAHNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQMgAikDACELIAEoAhAhAgNAAkAgBCkDcCIKUEUEQCAEKQN4IQkMAQsDQAJ+AkAgBCkDWCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNYIAmnQQFxRQ0AIAQgBCkDYDcDqAEMAQsgBCgCaEUNASAEQaABaiAFELYqIAQpA6ABIQkLIAlCAFINAgsgBEIDNwNYCyAEKQNIIglCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOoAQshCiAJp0EBcUUNByAEIAQpA3hCQH0iCTcDeCAEIAo3A3AgClANAAsLIARCASAKeiIMhiAKhTcDcCAEIAIgDKcgCadqQQN0IgdqKQMAIgk3A4ABIAQgCzcDyAEgC1ANBiALQn9SIAlCgICAgICAgICAf1JyRQRAIARBAjYCpAEgBEGYkP8ANgKgASAEQgI3AqwBIARBhgw2AsQBIARBhgw2ArwBIAQgBEG4AWo2AqgBIAQgBEHIAWo2AsABIAQgBEGAAWo2ArgBIARBkAFqIARBoAFqEJkOIAQpApABIQkgBCkCmAEhCkGIgICAeCEBDAgLIARBoAFqIAkgC38iCSADEI0QIAQoAqABIgFBk4CAgHhHBEAgBCkCrAEhCiAEKQKkASEJDAgFIAYgB2ogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgBCACKQMAIgo3A8gBIAQgCTcDuAEgCVANAiAJQn9SIApCgICAgICAgICAf1JyRQRAIARBAjYCTCAEQZiQ/wA2AkggBEICNwJUIARBhgw2ApgBIARBhgw2ApABIAQgBEGMAWo2AlAgBCAEQbgBajYClAEgBCAEQcgBajYCjAEgBEGkAWogBEHIAGoQmQ4gBCkCpAEhCSAEKQKsASEKQYiAgIB4IQEMBAsgBEHIAGogCiAJfyIKIAMQjRAgBCgCSCIBQZOAgIB4RwRAIAQpAlQhCiAEKQJMIQkMBAsgBiAKNwMAIAZBCGohBiACQQhqIQIgCCAFQQFqIgVHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEGIAQoAjQhAyABIARB0ABqIgUpAgA3AwAgBCkDKCEJIAQgBCkCSDcDKCAEQQA2AjggBCAJNwJUIARBADYCUCAEIAM2AkwgBCAGNgJIIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCqAEgBCAGNgKkASAEIAE2AqABIARBPGoiASAEQaABahDkGSAHIARBIGopAgA3AwAgBSAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDGHSAEQShqEM8vDAMLQQRBHBCjPQALQYeAgIB4IQELIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHQAWokAAv/CgIFfwh+IwBB0AFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBBXQiByEFAkACQAJAAkACQCAHQSBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAIpAxghDCACKQMQIQ0gAikDCCEOIAIpAwAhDyADLQAAIQIgASgCECEDA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOIAQwBCyAEKAJgRQ0BIARBgAFqIAcQtiogBCkDgAEhCQsgCUIAUg0CCyAEQgM3A1ALIAQpA0AiCUICUQ0JIARCADcDQCAEKQNIDAELIAQpA4gBCyEKIAmnQQFxRQ0HIAQgBCkDcEJAfSIJNwNwIAQgCjcDaCAKUA0ACwsgBCAKQgEgCnoiC4aFNwNoIARBsAFqIgEgAyALpyAJp2oiCGotAAAQki0gBEGAAWogBCkDsAEgBCkDuAEgBCkDwAEgBCkDyAEgDyAOIA0gDBCcBiAEKAKAAUUEQCABIAQpA5ABIgkgBCkDmAEiCiAEKQOgASILIAQpA6gBIhAgAhDQDiAEKAKwASIFQZOAgIB4RwRAIAQpArwBIQkgBCkCtAEhCgwICyAGIAhBBXRqIgEgEDcDGCABIAs3AxAgASAKNwMIIAEgCTcDAAwBCyAEKAKEASIFQZOAgIB4Rg0ACyAEKQOQASEJIAQpA4gBIQoMBQtBwAAgBRCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMYIQkgAikDECEKIAIpAwghDCACKQMAIQ0gAy0AACECIAEoAhAhA0EAIQEDQCAEQYABaiIFIAEgA2otAAAQki0gBEFAayAEKQOAASAEKQOIASAEKQOQASAEKQOYASANIAwgCiAJEJwGAkACQCAEKAJARQRAIAUgBCkDUCIOIAQpA1giDyAEKQNgIgsgBCkDaCIQIAIQ0A4gBCgCgAEiBUGTgICAeEYNASAEKQKMASEJIAQpAoQBIQoMBQsgBCgCRCIFQZOAgIB4Rg0BIAQpA1AhCSAEKQNIIQoMBAsgBkEYaiAQNwMAIAZBEGogCzcDACAGIA83AwggBiAONwMACyAGQSBqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKIASAEIAY2AoQBIAQgATYCgAEgBEE0aiIBIARBgAFqEOIZIAcgBEEYaikCADcDACAFIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEM4dIARBIGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAU2AgQgAEEpOgAAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQdABaiQAC/8KAgV/CH4jAEHQAWsiBCQAIAFBDGooAgghCCAEQQhqIAEQkjYQ7iUgCEEFdCIHIQUCQAJAAkACQAJAIAdBIHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCKCAEIAU2AiQgBEHAADYCICAHBEAgBkEAIAf8CwALIAQgCDYCMCAEIAc2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQcgAikDGCEMIAIpAxAhDSACKQMIIQ4gAikDACEPIAMtAAAhAiABKAIQIQMDQAJAIAQpA2giClBFBEAgBCkDcCEJDAELA0ACfgJAIAQpA1AiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDUCAJp0EBcUUNACAEIAQpA1g3A4gBDAELIAQoAmBFDQEgBEGAAWogBxC2KiAEKQOAASEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDiAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEIApCASAKeiILhoU3A2ggBEGwAWoiASADIAunIAmnaiIIai0AABC0LiAEQYABaiAEKQOwASAEKQO4ASAEKQPAASAEKQPIASAPIA4gDSAMEJwGIAQoAoABRQRAIAEgBCkDkAEiCSAEKQOYASIKIAQpA6ABIgsgBCkDqAEiECACENAOIAQoArABIgVBk4CAgHhHBEAgBCkCvAEhCSAEKQK0ASEKDAgLIAYgCEEFdGoiASAQNwMYIAEgCzcDECABIAo3AwggASAJNwMADAELIAQoAoQBIgVBk4CAgHhGDQALIAQpA5ABIQkgBCkDiAEhCgwFC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAxghCSACKQMQIQogAikDCCEMIAIpAwAhDSADLQAAIQIgASgCECEDQQAhAQNAIARBgAFqIgUgASADai0AABC0LiAEQUBrIAQpA4ABIAQpA4gBIAQpA5ABIAQpA5gBIA0gDCAKIAkQnAYCQAJAIAQoAkBFBEAgBSAEKQNQIg4gBCkDWCIPIAQpA2AiCyAEKQNoIhAgAhDQDiAEKAKAASIFQZOAgIB4Rg0BIAQpAowBIQkgBCkChAEhCgwFCyAEKAJEIgVBk4CAgHhGDQEgBCkDUCEJIAQpA0ghCgwECyAGQRhqIBA3AwAgBkEQaiALNwMAIAYgDzcDCCAGIA43AwALIAZBIGohBiAIIAFBAWoiAUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBiAEKAIsIQMgASAEQcgAaiIFKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBjYCQCAEIAIQ1zsgBCgCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBjYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgBTYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALzQoCBn8EfiMAQZABayIDJAAgAUEMahDYPCEHIANBCGogARCSNhDuJSAHQQN0IgUhBAJAAkACQAJAAkACQAJAAkAgBUE4cSIGBEAgBSAGa0FAayIEIAVJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAyAGNgIoIAMgBDYCJCADQcAANgIgIAUEQCAGQQAgBfwLAAsgAyAHNgIwIAMgBTYCLCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQUBrIANBCGoQyDQgA0HgAGohBSACKAIIIQcgAigCACEEIAEoAhAhAQJAA0ACQCADKQNoIgpQRQRAIAMpA3AhCQwBCwNAAn4CQCADKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAyAJUK1CAYY3A1AgCadBAXFFDQAgAyADKQNYNwOAAQwBCyADKAJgRQ0BIANB+ABqIAUQtiogAykDeCEJCyAJQgBSDQILIANCAzcDUAsgAykDQCIJQgJRDQogA0IANwNAIAMpA0gMAQsgAykDgAELIQogCadBAXFFDQggAyADKQNwQkB9Igk3A3AgAyAKNwNoIApQDQALCyADIApCASAKeiILhoU3A2hCgICAgICAgICAfyEMAkAgA0H4AGoCfgJAAkAgASALpyAJp2pBA3QiCGopAwAiC0KAgICAgICAgIB/UiAEKAIAKQMAIglCf1JyRQRAQgAhCgwBCyAJUA0DIAsgCyAJfyIMIAl+fUIAIAlCf1IbIQogC0IAWQ0BCyAMIAogBCgCCCkDAFetfQwBCyAMIAogBCgCBCkDAFmtfAsiCSAHLQAAEI0QIAMoAngiAkGTgICAeEcNAiAGIAhqIAk3AwAMAQsLQbyP/wAQ4isACyADKQJ8IQkgACADKQKEATcCEAwGC0HAACAEEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQUgASgCECEEQQAhAQNAQoCAgICAgICAgH8hDCAFKAIAKQMAIQkgA0FAawJ+AkACQCAEKQMAIgpCgICAgICAgICAf1EEQEIAIQsgCUJ/UQ0BCyAJUA0IIAogCiAJfyIMIAl+fUIAIAlCf1IbIQsgCkIAWQ0BCyAMIAsgBSgCCCkDAFetfQwBCyAMIAsgBSgCBCkDAFmtfAsiCSAILQAAEI0QIAMoAkAiAkGTgICAeEcNAiAGIAk3AwAgBEEIaiEEIAZBCGohBiAHIAFBAWoiAUcNAAsLIANBQGsiAhCXKSADQShqIgEoAgAhBSADKAIsIQQgASADQcgAaiIGKQIANwMAIAMpAyAhCSADIAMpAkA3AyAgA0EANgIwIAMgCTcCTCADQQA2AkggAyAENgJEIAMgBTYCQCADIAIQ1zsgAygCACEFQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBikCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAENgKAASADIAU2AnwgAyABNgJ4IANBNGoiASADQfgAahDkGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDGHSADQSBqEM8vDAILIAMpAkQhCSAAIAMpAkw3AhALIAAgCTcCCCAAQSk6AAAgACACNgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBvI//ABDiKwALQQRBHBCjPQALtgoCCX8DfiMAQZABayIDJAAgAUEMahDbPCEHIANBCGogARCSNhDuJSAHQQN0IgQhBQJAAkACQAJAAkACQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIFIARJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgAyAGNgIoIAMgBTYCJCADQcAANgIgIAQEQCAGQQAgBPwLAAsgAyAHNgIwIAMgBDYCLCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQUBrIANBCGoQyDQgA0HgAGohCCACKAIIIQkgAigCACEFIAEoAhAhCgJAA0ACQCADKQNoIg1QRQRAIAMpA3AhDAwBCwNAAn4CQCADKQNQIgxCA1IEQAJAAkACQCAMQgJRDQAgAyAMUK1CAYY3A1AgDKdBAXFFDQAgAyADKQNYNwOAAQwBCyADKAJgRQ0BIANB+ABqIAgQtiogAykDeCEMCyAMQgBSDQILIANCAzcDUAsgAykDQCIMQgJRDQogA0IANwNAIAMpA0gMAQsgAykDgAELIQ0gDKdBAXFFDQggAyADKQNwQkB9Igw3A3AgAyANNwNoIA1QDQALCyADIA1CASANeiIOhoU3A2hBgICAgHghAQJAIANB+ABqAn8CQAJAIAogDqcgDKdqIgtBAnRqKAIAIgdBgICAgHhHIAUoAgAoAgAiAkF/R3JFBEBBACEEDAELIAJFDQMgByAHIAJtIgEgAmxrQQAgAkF/RxshBCAHQQBODQELIAEgBCAFKAIIKAIATGsMAQsgASAEIAUoAgQoAgBOagusIgwgCS0AABCNECADKAJ4IgRBk4CAgHhHDQIgBiALQQN0aiAMNwMADAELC0Gsj/8AEOIrAAsgAykCfCEMIAAgAykChAE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQogAigCACEFIAEoAhAhAgNAQYCAgIB4IQEgBSgCACgCACEEIANBQGsCfwJAAkAgAigCACIIQYCAgIB4RgRAQQAhCSAEQX9GDQELIARFDQggCCAIIARtIgEgBGxrQQAgBEF/RxshCSAIQQBODQELIAEgCSAFKAIIKAIATGsMAQsgASAJIAUoAgQoAgBOagusIgwgCi0AABCNECADKAJAIgRBk4CAgHhHDQIgBiAMNwMAIAJBBGohAiAGQQhqIQYgByALQQFqIgtHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEGIAEgA0HIAGoiBCkCADcDACADKQMgIQwgAyADKQJANwMgIANBADYCMCADIAw3AkwgA0EANgJIIAMgBjYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAQpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBjYCgAEgAyAFNgJ8IAMgATYCeCADQTRqIgEgA0H4AGoQ5BkgByADQRhqKQIANwMAIAQgA0EQaikCADcDACADIAMpAgg3A0AgACABIAIQxh0gA0EgahDPLwwCCyADKQJEIQwgACADKQJMNwIQCyAAIAw3AgggAEEpOgAAIAAgBDYCBCADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0GQAWokAA8LQayP/wAQ4isAC0EEQRwQoz0AC/YMAhJ/AX4jAEHAAWsiAiQAIAFBGGohDwJAAkACQAJAIAEtABhBIUYEQAJAIAEtABkEQCACQShqIAEQ3DsgAigCLA0BQQBBAEHghoYBEMMhAAsgAkEwaiABENw7IAIoAjRFDQIgAigCMCIEKAIAIgYgBigCACIDQQFqNgIAIANBAEgNBCACIAY2AkggAiAEKQIENwJMIAJBkAFqIAJByABqIAEoAiggASgCJBDdJgwDCyACKAIoIgQoAgAiBiAGKAIAIgNBAWo2AgAgA0EASA0DIAIgBjYCSCACIAQpAgQ3AkwgAkGoAWogAkHIAGoiBiABKAIoIAEoAiQQ3SYgAkEgaiABENw7IAIoAiQiA0EBSwRAIAIoAiAiBCgCDCIOIA4oAgAiA0EBajYCACADQQBIDQQgAiAONgJIIAIgBCkCEDcCTCACQbQBaiAGIAEoAiggASgCJBCAHSACQZgBaiACQbABaigCADYCACACIAIpAqgBNwOQASACKAK0ASEOIAIpArgBIRQMAwtBASADQfCGhgEQwyEACyACIA82AqgBIAJBATYCTCACQdSHhgE2AkggAkIBNwJUIAJBpwQ2ArgBIAIgAkG0AWo2AlAgAiACQagBajYCtAEgAkHIAGpB3IeGARDvLAwCC0EAQQBB0IaGARDDIQALIAJBGGogAUEcaiINELAuIAIoAhgiBCACKAIcIgNGBH9BAQUgBC0AACEGIAMgBEEIaiIFRwRAIAMgBWtBA3YhDANAIAUsAAAiBCAGwCIDIAMgBEgbIQYgBUEIaiEFIAxBAWsiDA0ACwsgBsBBAWoLIQMjAEEgayIHJAAgB0EUaiADQQBBBEEIEKAYIAcoAhghCSAHKAIUQQFGBEAgCSAHKAIcQYCHhgEQ/S8ACyACQTxqIQYgB0EQaiIEQQA2AgAgByAHKAIcNgIMIAcgCTYCCCMAQRBrIgkkACAJIAI2AgwgCUEANgIIIAdBCGoiCigCACAKKAIIIghrIANJBEAgCiAIIANBBEEIEN4oIAooAgghCAsgCigCBCAIQQN0aiELAkACQCADQQJPBEAgA0EBayIDIAhqIQgDQCALQQA2AgAgC0EEaiACNgIAIAtBCGohCyADQQFrIgMNAAsMAQsgAw0AIAogCDYCCAwBCyALIAI2AgQgC0EANgIAIAogCEEBajYCCAsgCUEQaiQAIAZBCGogBCgCADYCACAGIAcpAgg3AgAgB0EgaiQAIAJBEGogARDvPCACKAIQIQUgAigCFCEEIAJBCGogDRCwLiACKAIMIAIoAgghDCACIAUgBEHEAGxqNgJMIAIgBTYCSCAMa0EDdiIEIAJByABqIgMoAgQgAygCAGtBxABuIgMgAyAESxsiCgRAIAJB1ABqIQsgAkHgAGohCQNAIAwsAAAhByACQZwBaiAFQRhqENcGIAVBKGooAgAhBiAFQSRqKAIAIQQgAkGoAWogBRC+FSACQbQBaiAFQQxqEIALIAVBLGooAgAiCARAIAggCCgCACIDQQFqNgIAIANBAEgNAyAFQTxqKAIAIRAgBUE4aigCACERIAVBNGooAgAhEyAFQUBrKAIAIQ0gBUEwaigCACESCyAJIAIpApwBNwIAIAsgAikCtAE3AgAgCUEIaiACQaQBaigCADYCACACQdAAaiACQbABaigCADYCACALQQhqIAJBvAFqKAIANgIAIAIgBjYCcCACIAQ2AmwgAiACKQKoATcDSCACIA02AogBIAIgEDYChAEgAiARNgKAASACIBM2AnwgAiASNgJ4IAIgCDYCdCACIAJByABqEKABIAIoAkQiAyAHTQ0DIAIoAgQhDSACKAIAIRACQCACKAJAIAdBA3RqIgQoAgAiA0UNACADIAMoAgAiEUEBazYCACARQQFHDQAgBBC7IwsgBCANNgIEIAQgEDYCACAFQcQAaiEFIAxBCGohDCAKQQFrIgoNAAsLIABBDGogDxDXBiAAIBQ3AiggACAONgIkIABBCGogAkHEAGooAgA2AgAgACACKQI8NwIAIAAgAikDkAE3AhggAEEgaiACQZgBaigCADYCACAPEMYMIAEQxScgARDoOyABQQxqIgAQpCwgABD1PAJAIAEoAiwiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEsahD7HgsgAkHAAWokAA8LAAsgByADQZCHhgEQwyEAC70NAgR/An4jAEEwayIDJAAgA0EQaiIEQgA3AwAgA0EYaiIFQgA3AwAgA0EIaiIGIAJBCGopAgA3AwAgAyACKQIANwMAIAFBFGogASgCDCABQRBqIgIoAgAgASgCCCgCEBEBACABQSBqIAUpAwA3AwAgAUEYaiAEKQMANwMAIAIgBikDADcDACABIAMpAwA3AwggAUEBOgBYIAMgAUEIaiICEKUYAkACQAJAIAMoAgBFBEAgA0EmQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQIgAygCCCICQZSlzQBBJvwKAAAgACACrUKAgICA4ASENwMIIAAgATYCBCAAQQI2AgAMAQsgAygCDARAIANBFEEAQQFBARCgGCADKAIEIQIgAygCAEEBRg0DIAMoAggiAUEQakHKpc0AKAAANgAAIAFBCGpBwqXNACkAADcAACABQbqlzQApAAA3AAAgAEEUNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAELIAEgAygCCDYCNCADIAIQpRggAygCAEUEQCADQTFBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBzqXNAEEx/AoAACAAIAKtQoCAgICQBoQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EfQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQRdqQZamzQApAAA3AAAgAUEQakGPps0AKQAANwAAIAFBCGpBh6bNACkAADcAACABQf+lzQApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAELIAEgAygCCDYCPCADIAIQpRggAygCAEUEQCADQSdBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBnqbNAEEn/AoAACAAIAKtQoCAgIDwBIQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EVQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQQ1qQdKmzQApAAA3AAAgAUEIakHNps0AKQAANwAAIAFBxabNACkAADcAACAAQRU2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI4IANBIGogAhCFJiADKQMgIQcgAykDKCEIIwBBEGsiAiQAAkACQAJAIAenQQFxBEAgA0EINgIAIAMgCDcDCAwBCyACQQRqQSdBAEEBQQEQoBggAigCCCEEIAIoAgRBAUYNASACKAIMIgVB2qbNAEEn/AoAACADQSc2AgwgAyAFNgIIIAMgBDYCBCADQQI2AgALIAJBEGokAAwBCyAEIAIoAgxB1P3MABD9LwALIAMoAgAiAkEIRwRAIAMoAgQhASADKQMIIQcgACADKQMQNwMQIAAgBzcDCCAAIAE2AgQgACACNgIADAELIAMpAwgiB0KAgICACHxCgICAgBBUIQQgB6chBSMAQRBrIgIkAAJAAkACQCAEBEAgA0EINgIAIAMgBTYCBAwBCyACQQRqQRVBAEEBQQEQoBggAigCCCEFIAIoAgRBAUYNASACKAIMIgRBDWpBjqfNACkAADcAACAEQQhqQYmnzQApAAA3AAAgBEGBp80AKQAANwAAIANBFTYCDCADIAQ2AgggAyAFNgIEIANBADYCAAsgAkEQaiQADAELIAUgAigCDEHU/cwAEP0vAAsgAygCBCECIAMoAgAiBEEIRwRAIAAgAykDCDcDCCAAQRBqIANBEGopAwA3AwAgACACNgIEIAAgBDYCAAwBCyABQTRqIQQgASACNgIEIAFBATYCAAJAIAEoAjQiAkH/AHFFBEAgAUE8aiIGKAIAIgVFDQEgAiAFIAIgBW4iBWxHBEAgA0ECNgIEIANB0KTNADYCACADQgI3AgwgA0E7NgIsIAMgBjYCKCADQTs2AiQgAyAENgIgIAMgA0EgajYCCCAAQQRqIAMQoRggAEEANgIADAMLIAEgBTYCQCABQgA3AkwgAUEANgIwIAVBH3FFBEAgAEEINgIADAMLIANBATYCBCADQYSkzQA2AgAgA0IBNwIMIANBOzYCJCADIAFBQGs2AiAgAyADQSBqNgIIIABBBGogAxChGCAAQQA2AgAMAgsgA0EBNgIEIANBjKXNADYCACADQgE3AgwgA0E7NgIkIAMgBDYCICADIANBIGo2AgggAEEEaiADEKEYIABBADYCAAwBC0G8o80AEOcrAAsgA0EwaiQADwsgASADKAIIQdT9zAAQ/S8ACyACIAMoAghB1P3MABD9LwALqwwCA38BfiMAQTBrIgMkACADQRBqIgRCADcDACADQRhqIgVCADcDACADQQhqIgYgAkEIaikCADcDACADIAIpAgA3AwAgAUEUaiABKAIMIAFBEGoiAigCACABKAIIKAIQEQEAIAFBIGogBSkDADcDACABQRhqIAQpAwA3AwAgAiAGKQMANwMAIAEgAykDADcDCCABQQE6AFggAyABQQhqIgIQpRgCQAJAAkAgAygCAEUEQCADQSZBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBsMHOAEEm/AoAACAAIAKtQoCAgIDgBIQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EUQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQRBqQebBzgAoAAA2AAAgAUEIakHewc4AKQAANwAAIAFB1sHOACkAADcAACAAQRQ2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI0IAMgAhClGCADKAIARQRAIANBMUEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkHqwc4AQTH8CgAAIAAgAq1CgICAgJAGhDcDCCAAIAE2AgQgAEECNgIADAELIAMoAgwEQCADQR9BAEEBQQEQoBggAygCBCECIAMoAgBBAUYNAyADKAIIIgFBF2pBssLOACkAADcAACABQRBqQavCzgApAAA3AAAgAUEIakGjws4AKQAANwAAIAFBm8LOACkAADcAACAAQR82AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI8IAMgAhClGCADKAIARQRAIANBJ0EAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkG6ws4AQSf8CgAAIAAgAq1CgICAgPAEhDcDCCAAIAE2AgQgAEECNgIADAELIAMoAgwEQCADQRVBAEEBQQEQoBggAygCBCECIAMoAgBBAUYNAyADKAIIIgFBDWpB7sLOACkAADcAACABQQhqQenCzgApAAA3AAAgAUHhws4AKQAANwAAIABBFTYCDCAAIAE2AgggACACNgIEIABBADYCAAwBCyABIAMoAgg2AjggA0EgaiACEIUmIAMgAykDICADKQMoEKwaIAMoAgAiAkEIRwRAIAMoAgQhASADKQMIIQcgACADKQMQNwMQIAAgBzcDCCAAIAE2AgQgACACNgIADAELIAMpAwgiB0KAgICACHxCgICAgBBUIQQgB6chBSMAQRBrIgIkAAJAAkACQCAEBEAgA0EINgIAIAMgBTYCBAwBCyACQQRqQRVBAEEBQQEQoBggAigCCCEFIAIoAgRBAUYNASACKAIMIgRBDWpBqsPOACkAADcAACAEQQhqQaXDzgApAAA3AAAgBEGdw84AKQAANwAAIANBFTYCDCADIAQ2AgggAyAFNgIEIANBADYCAAsgAkEQaiQADAELIAUgAigCDEHYp84AEP0vAAsgAygCBCECIAMoAgAiBEEIRwRAIAAgAykDCDcDCCAAQRBqIANBEGopAwA3AwAgACACNgIEIAAgBDYCAAwBCyABQTRqIQQgASACNgIEIAFBATYCAAJAIAEoAjQiAkH/AHFFBEAgAUE8aiIGKAIAIgVFDQEgAiAFIAIgBW4iBWxHBEAgA0ECNgIEIANB7MDOADYCACADQgI3AgwgA0E7NgIsIAMgBjYCKCADQTs2AiQgAyAENgIgIAMgA0EgajYCCCAAQQRqIAMQoxggAEEANgIADAMLIAEgBTYCQCABQgA3AkwgAUEANgIwIAVBH3FFBEAgAEEINgIADAMLIANBATYCBCADQaDAzgA2AgAgA0IBNwIMIANBOzYCJCADIAFBQGs2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAgsgA0EBNgIEIANBqMHOADYCACADQgE3AgwgA0E7NgIkIAMgBDYCICADIANBIGo2AgggAEEEaiADEKMYIABBADYCAAwBC0HYv84AEOcrAAsgA0EwaiQADwsgASADKAIIQdinzgAQ/S8ACyACIAMoAghB2KfOABD9LwAL+BECEX8CfiMAQeAAayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4NAQIDBAUGBwgJCgsNDAALIAIgACkDCDcDICACIAApAxA3A1AgAkEDNgI0IAJBgJT+ADYCMCACQgI3AjwgAkE8NgIMIAJBPDYCBCACIAI2AjggAiACQdAAajYCCCACIAJBIGo2AgAgASgCACABKAIEIAJBMGoQywohAAwNCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQdyU/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMDAsgASgCAEH0lP4AQR0gASgCBCgCDBEGACEADAsLIAEoAgBBkZX+AEEmIAEoAgQoAgwRBgAhAAwKCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQYSW/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMCQsgAiAAKQMINwMYIAIgACkDEDcDICACIAApAxg3A1AgAkEENgIEIAJB+Jb+ADYCACACQgM3AgwgAkE8NgJEIAJBPDYCPCACQTw2AjQgAiACQTBqNgIIIAIgAkHQAGo2AkAgAiACQSBqNgI4IAIgAkEYajYCMCABKAIAIAEoAgQgAhDLCiEADAgLIAIgACkDCDcDICACIAApAxA3A1AgAkEDNgI0IAJBzJf+ADYCMCACQgI3AjwgAkE8NgIMIAJBPDYCBCACIAI2AjggAiACQdAAajYCCCACIAJBIGo2AgAgASgCACABKAIEIAJBMGoQywohAAwHCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQZyY/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMBgsgAiAAKQMINwMgIAIgACkDEDcDUCACQQM2AjQgAkGAmf4ANgIwIAJCAjcCPCACQTw2AgwgAkE8NgIEIAIgAjYCOCACIAJB0ABqNgIIIAIgAkEgajYCACABKAIAIAEoAgQgAkEwahDLCiEADAULIAIgAC0AAToAUCACQQI2AjQgAkHsmf4ANgIwIAJCATcCPCACQbsHNgIEIAIgAjYCOCACIAJB0ABqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMBAsgAiAAKAIIIgMgACgCDGo2AkwgAiADNgJIIAJBADYCPCACQQA2AjAgAkHYAGoiDkEANgIAIAJCgICAgBA3AlAjAEEgayIAJAAgAkEwaiIDKAIcIQUgAygCGCEHIAMvARYhBiADKAIQIQggAy8BCiEJIAMoAgQhCiADLQAVIgsgAy0AFCIMa0H/AXFBACADKAIMIg1BAXEbIAMtAAkiDyADLQAIIhBrQf8BcUEAIAMoAgAiA0EBcRtqIhEgAkHQAGoiBCgCACAEKAIIIhJrSwRAIAQgEiARQQFBARDQKAsgACAFNgIcIAAgBzYCGCAAIAY7ARYgACALOgAVIAAgDDoAFCAAIAg2AhAgACANNgIMIAAgCTsBCiAAIA86AAkgACAQOgAIIAAgCjYCBCAAIAM2AgAjAEEgayIDJAAgACgCHCEFIAAoAhghByAAKQIQIRMgACgCDCEKIAApAgQhFCAAKAIAIQYgAyAENgIMAkAgBkEBcUUNACADIBQ3AxAgAyADQQxqNgIcIBRCIIinQf8BcSIEIBRCKIinQf8BcSIGTw0AA0AgA0EcaiADQRBqIARqLQAAEKQdIARBAWoiBEH/AXEgBkcNAAsLIAcEQEEAIQYjAEEQayIEJAAgBSAHRwRAIANBDGohCyAFIAdrIQwDQCAGIAdqLQAAIghBjYqKAWosAAAiDUH/AHEhBSAEQQRqIgkCf0EBIA1BAE4NABogBUUEQCAIQfABcUEEdkGu7YkBai0AAEEQdCAIQQ9xQa7tiQFqLQAAQRh0ckHc8AFyIQVBBAwBCyAFQQh0QdwAciEFQQILOgAFIAlBADoABCAJIAU2AgAgBCALNgIMIAQtAAgiBSAELQAJIghJBEADQCAEQQxqIARBBGogBWotAAAQpB0gCCAFQQFqIgVHDQALCyAGQQFqIgYgDEcNAAsLIARBEGokAAsCQCAKQQFxRQ0AIAMgEzcDECADIANBDGo2AhwgE0IgiKdB/wFxIgQgE0IoiKdB/wFxIgVPDQADQCADQRxqIANBEGogBGotAAAQpB0gBEEBaiIEQf8BcSAFRw0ACwsgA0EgaiQAIABBIGokACACQShqIA4oAgA2AgAgAiACKQJQNwMgIAJBqgs2AhwgAkECNgIEIAJBvJr+ADYCACACQgE3AgwgAiACQSBqIgM2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKIQAgA0EBQQEQ4B4MAwsgAiAALQABOgBQIAJBAjYCNCACQfya/gA2AjAgAkIBNwI8IAJBuwc2AgQgAiACNgI4IAIgAkHQAGo2AgAgASgCACABKAIEIAJBMGoQywohAAwCCyACIAAoAgQ2AiAgAiAAKAIINgJQIAJBAzYCNCACQdCc/gA2AjAgAkICNwI8IAJBOzYCDCACQTs2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMAQsgAC0AAUUEQCACIAApAwg3A1AgAkECNgI0IAJBwJv+ADYCMCACQgE3AjwgAkE8NgIEIAIgAjYCOCACIAJB0ABqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMAQsgAiAAKQMINwNQIAJBAjYCNCACQYic/gA2AjAgAkIBNwI8IAJBPDYCBCACIAI2AjggAiACQdAAajYCACABKAIAIAEoAgQgAkEwahDLCiEACyACQeAAaiQAIAAL2woCD38CfiMAQSBrIgwkACALQQA2AgwgAiAEIAdxIhBqIRQgAyAQayEVIAAoAjQhFyALKQMAIRwgCygCCCESA0AgAiAQIBJqIg9qIRYgDiENAkACQAJAAkACQAJAA0AgDUGEys4Aai0AACIOQRBJBEACQCAGIA5BAnRqKAIAIA1BpMrOAGosAABqIhMgCUsNACAEIA9JIAcgE2siDiAHT3INACAEIA5xIg4gEmoiESAESw0AIAMgD00NAyADIBFNDQQgFi0AACACIBFqLQAARw0AIAMgDkkNBSADIBBJDQYgAiAOaiADIA5rIBQgFSAIELIgIg9BAk0gD0ECRyANQQFLcnENByAcAn4gDyAOIAUQoS4hDiANQQ9NBEAgDUECdEGomtIAajUCACAXrSAOrX58QgKIDAELIA1BEEHomtIAEMMhAAsiG1oNByALIBM2AhAgCyAONgIIIAsgGzcDAEEBIRggDiESIBshHAwHCyANQQFqIg1BEEcNAQwHCwsgDkEQQZTKzgAQwyEACyAPIANBtMrOABDDIQALIBEgA0HEys4AEMMhAAsgDiADQdTKzgAQrzsACyAQIANB5MrOABCvOwALIA1BAWohDiANQQ9JDQELCwJAAn8CQCAIQQNNDQAgECASaiIGIARLDQAgAyAQTwRAIAxBADYCBCAVQQNLBEAgDEEEakEEIBRBBEG02c4AENUsIAAoAgwiDyAMKAIEQb3P1vEBbEERdiINQQh0Ig5PBEAgDyAOa0H/AUsEQCAAKAIEIg8gDUsEQCADIAZLBEAgACgCCCAOQQJ0aiERAkAgACgCACANQQF0aiIPLwEAIg5BgAJrQQAgDkGAAksbIhYgDk8NACACIAZqLQAAIRkDQCAHIBEgDkEBayIGQf8BcUECdGooAgAiDWsiGiAJSw0BAkACQAJAAkACQCAEIA1xIg0gEmoiEyAESw0AIAMgE00NAiAZIAIgE2otAABHDQAgAyANSQ0DIAIgDWogAyANayAUIBUgCBCyICIGQQNNDQQgHCAXrSAGIA0gBRChLiIGrX4gGmdBIGpBP3NB+ABsrX1CgDx8QgKIIhtaDQQgCyAaNgIQIAsgBjYCCCALIBs3AwAgBiAQaiINIARLDQEgAyANSwRAIAIgDWotAAAhGUEBIRggBiESIBshHAwFCyANIANB5MnOABDDIQALIAYiDiAWSw0EDAULIBEgDy0AAEECdGogBzYCAEEBIQ0gDyAPLwEAQQFqOwEADA0LIBMgA0HEyc4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB1MnOABDvLAALIA5BAWsiDiAWSw0ACwsgESAPLQAAQQJ0aiAHNgIAIA8gDy8BAEEBajsBAEEBDAcLIAYgA0G0yc4AEMMhAAsgDSAPQaTJzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakGUyc4AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBhMnOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQaTZzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakH0yM4AEO8sAAtBAQshDSAYDQAgAUUEQEEAIQ0MAQsgAyAQTwRAIAEgACAUIBUgCCAJIAogCxDoFCENDAELIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQfTJzgAQ7ywACyAMQSBqJAAgDQv/CQIHfwN+IwBBkAFrIgIkACABQQxqENs8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIQQJ0aigCALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABKAIAs7wiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUEEaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAv/CQIHfwN+IwBBkAFrIgIkACABQQxqENg8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIQQN0aikDALW8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABKQMAtbwiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUEIaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAulCgERfyMAQYACayIFJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAggEQCAFQSBqIAAoAgQQ3DsgBSgCJCIGIAAoAihBAnQiB08EQCABKAIIRQ0DIAUoAiAhDiAFQRhqIAEoAgQQ3DsgBSgCHCIIIAEoAihBAnQiC0kNAiAHIA5qIQkgBiAHayEMIAUoAhgiDSALaiEKIAggC2shCCAAKAIsRQ0QIAVBEGogAEEsaiIGENw7IAVB6ABqIg8gBSgCECAFKAIUIAAoAjggAmoiECAEEPoTIAVB9AFqIA8Q1QkCQCAFKAL0AUEBRgRAIAUoAvgBDQEgBSgC/AEgBEcNAQwSCyAERQ0RCyAAKAJAuCAAKAIkuKNEmpmZmZmZ2T9mRQRAIAVBCGogBhDcOyAFQShqIgAgBSgCCCAFKAIMIBAgBBD6EyABKAIsRQ0FIAUgAUEsahDcOyAFQagBaiILIAUoAgAgBSgCBCABKAI4IANqIAQQ+hMgBUHoAGogAEHAAPwKAAAgBUIANwPoAQNAIAVB9AFqIgQgBUHoAGoQ1QkCQCAFKAL0AUEBRgRAIAUoAvwBIQAgBSgC+AEhASAEIAsQ1QkgBSgC9AENAQtBASEEDBQLQQAhBCABIAUoAvgBRw0TIAAgBSgC/AFHDRMgACABa0ECdCIAIAEgAmpBAnQiB2oiBiAASQ0HIAYgDEsNCCAAIAEgA2pBAnQiBmoiASAASQ0JIAEgCEsNCiAHIAlqIAAgBiAKaiAAEJ87DQALDBILIAEoAixFDQkCQCAERQRAQQAhAAwBC0EAIQYgASgCPCIJIANrIgpBACAJIApPGyEPIAAoAjwiCSACayIKQQAgCSAKTxshESACQQJ0IglBfHMhEiADQQJ0IgpBfHMhEyABKAI4IANqIRQgDiAHIAlqaiEHIA0gCiALamohCyABKAIwIQEgACgCMCEOQQAhAANAIAAgEUYNDCAAIA9GDQ0CQAJAIA4gACAQaiINQQN2ai0AAEEBIA1BB3F0cSINRQ0AIAEgACAUaiIVQQN2ai0AAEEBIBVBB3F0cUUNACAGIBJGDRAgBiAJakEEaiAMSw0RIAYgE0YNEiAGIApqQQRqIAhLDRMgBiAHakEEIAYgC2pBBBCfOw0BDAMLIA0NAgsgBkEEaiEGIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBAwRCyAHIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgCyAIQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAHIAZB+L2HARCxOwALIAYgDEH4vYcBELA7AAsgBiABQYi+hwEQsTsACyABIAhBiL6HARCwOwALQei9hwEQsjsAC0HovIcBQSBBiL2HARCfKQALQei8hwFBIEGIvYcBEJ8pAAtBfCACQQJ0IAZqQQRqQfi9hwEQsTsACyACQQJ0IAZqQQRqIAxB+L2HARCwOwALQXwgA0ECdCAGakEEakGIvocBELE7AAsgA0ECdCAGakEEaiAIQYi+hwEQsDsACyAEQQJ0IgAgAkECdCICaiIBIABJDQEgASAMSw0CIAAgA0ECdCIDaiIBIABJDQMgASAISw0EIAIgCWogACADIApqIAAQnzshBAsgBUGAAmokACAEDwsgAiABQfi9hwEQsTsACyABIAxB+L2HARCwOwALIAMgAUGIvocBELE7AAsgASAIQYi+hwEQsDsAC6UKARF/IwBBgAJrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIAVBIGogACgCBBDcOyAFKAIkIgYgACgCKEEDdCIHTwRAIAEoAghFDQMgBSgCICEOIAVBGGogASgCBBDcOyAFKAIcIgggASgCKEEDdCILSQ0CIAcgDmohCSAGIAdrIQwgBSgCGCINIAtqIQogCCALayEIIAAoAixFDRAgBUEQaiAAQSxqIgYQ3DsgBUHoAGoiDyAFKAIQIAUoAhQgACgCOCACaiIQIAQQ+hMgBUH0AWogDxDVCQJAIAUoAvQBQQFGBEAgBSgC+AENASAFKAL8ASAERw0BDBILIARFDRELIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgBUEIaiAGENw7IAVBKGoiACAFKAIIIAUoAgwgECAEEPoTIAEoAixFDQUgBSABQSxqENw7IAVBqAFqIgsgBSgCACAFKAIEIAEoAjggA2ogBBD6EyAFQegAaiAAQcAA/AoAACAFQgA3A+gBA0AgBUH0AWoiBCAFQegAahDVCQJAIAUoAvQBQQFGBEAgBSgC/AEhACAFKAL4ASEBIAQgCxDVCSAFKAL0AQ0BC0EBIQQMFAtBACEEIAEgBSgC+AFHDRMgACAFKAL8AUcNEyAAIAFrQQN0IgAgASACakEDdCIHaiIGIABJDQcgBiAMSw0IIAAgASADakEDdCIGaiIBIABJDQkgASAISw0KIAcgCWogACAGIApqIAAQnzsNAAsMEgsgASgCLEUNCQJAIARFBEBBACEADAELQQAhBiABKAI8IgkgA2siCkEAIAkgCk8bIQ8gACgCPCIJIAJrIgpBACAJIApPGyERIAJBA3QiCUF4cyESIANBA3QiCkF4cyETIAEoAjggA2ohFCAOIAcgCWpqIQcgDSAKIAtqaiELIAEoAjAhASAAKAIwIQ5BACEAA0AgACARRg0MIAAgD0YNDQJAAkAgDiAAIBBqIg1BA3ZqLQAAQQEgDUEHcXRxIg1FDQAgASAAIBRqIhVBA3ZqLQAAQQEgFUEHcXRxRQ0AIAYgEkYNECAGIAlqQQhqIAxLDREgBiATRg0SIAYgCmpBCGogCEsNEyAGIAdqQQggBiALakEIEJ87DQEMAwsgDQ0CCyAGQQhqIQYgBCAAQQFqIgBHDQALIAQhAAsgACAETyEEDBELIAcgBkGovYcBEK87AAtBAEEAQZi9hwEQwyEACyALIAhByL2HARCvOwALQQBBAEG4vYcBEMMhAAtB2L2HARCyOwALIAcgBkH4vYcBELE7AAsgBiAMQfi9hwEQsDsACyAGIAFBiL6HARCxOwALIAEgCEGIvocBELA7AAtB6L2HARCyOwALQei8hwFBIEGIvYcBEJ8pAAtB6LyHAUEgQYi9hwEQnykAC0F4IAJBA3QgBmpBCGpB+L2HARCxOwALIAJBA3QgBmpBCGogDEH4vYcBELA7AAtBeCADQQN0IAZqQQhqQYi+hwEQsTsACyADQQN0IAZqQQhqIAhBiL6HARCwOwALIARBA3QiACACQQN0IgJqIgEgAEkNASABIAxLDQIgACADQQN0IgNqIgEgAEkNAyABIAhLDQQgAiAJaiAAIAMgCmogABCfOyEECyAFQYACaiQAIAQPCyACIAFB+L2HARCxOwALIAEgDEH4vYcBELA7AAsgAyABQYi+hwEQsTsACyABIAhBiL6HARCwOwALpQoBEX8jAEGAAmsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIIBEAgBUEgaiAAKAIEENw7IAUoAiQiBiAAKAIoQQF0IgdPBEAgASgCCEUNAyAFKAIgIQ4gBUEYaiABKAIEENw7IAUoAhwiCCABKAIoQQF0IgtJDQIgByAOaiEJIAYgB2shDCAFKAIYIg0gC2ohCiAIIAtrIQggACgCLEUNECAFQRBqIABBLGoiBhDcOyAFQegAaiIPIAUoAhAgBSgCFCAAKAI4IAJqIhAgBBD6EyAFQfQBaiAPENUJAkAgBSgC9AFBAUYEQCAFKAL4AQ0BIAUoAvwBIARHDQEMEgsgBEUNEQsgACgCQLggACgCJLijRJqZmZmZmdk/ZkUEQCAFQQhqIAYQ3DsgBUEoaiIAIAUoAgggBSgCDCAQIAQQ+hMgASgCLEUNBSAFIAFBLGoQ3DsgBUGoAWoiCyAFKAIAIAUoAgQgASgCOCADaiAEEPoTIAVB6ABqIABBwAD8CgAAIAVCADcD6AEDQCAFQfQBaiIEIAVB6ABqENUJAkAgBSgC9AFBAUYEQCAFKAL8ASEAIAUoAvgBIQEgBCALENUJIAUoAvQBDQELQQEhBAwUC0EAIQQgASAFKAL4AUcNEyAAIAUoAvwBRw0TIAAgAWtBAXQiACABIAJqQQF0IgdqIgYgAEkNByAGIAxLDQggACABIANqQQF0IgZqIgEgAEkNCSABIAhLDQogByAJaiAAIAYgCmogABCfOw0ACwwSCyABKAIsRQ0JAkAgBEUEQEEAIQAMAQtBACEGIAEoAjwiCSADayIKQQAgCSAKTxshDyAAKAI8IgkgAmsiCkEAIAkgCk8bIREgAkEBdCIJQX5zIRIgA0EBdCIKQX5zIRMgASgCOCADaiEUIA4gByAJamohByANIAogC2pqIQsgASgCMCEBIAAoAjAhDkEAIQADQCAAIBFGDQwgACAPRg0NAkACQCAOIAAgEGoiDUEDdmotAABBASANQQdxdHEiDUUNACABIAAgFGoiFUEDdmotAABBASAVQQdxdHFFDQAgBiASRg0QIAYgCWpBAmogDEsNESAGIBNGDRIgBiAKakECaiAISw0TIAYgB2pBAiAGIAtqQQIQnzsNAQwDCyANDQILIAZBAmohBiAEIABBAWoiAEcNAAsgBCEACyAAIARPIQQMEQsgByAGQai9hwEQrzsAC0EAQQBBmL2HARDDIQALIAsgCEHIvYcBEK87AAtBAEEAQbi9hwEQwyEAC0HYvYcBELI7AAsgByAGQfi9hwEQsTsACyAGIAxB+L2HARCwOwALIAYgAUGIvocBELE7AAsgASAIQYi+hwEQsDsAC0HovYcBELI7AAtB6LyHAUEgQYi9hwEQnykAC0HovIcBQSBBiL2HARCfKQALQX4gAkEBdCAGakECakH4vYcBELE7AAsgAkEBdCAGakECaiAMQfi9hwEQsDsAC0F+IANBAXQgBmpBAmpBiL6HARCxOwALIANBAXQgBmpBAmogCEGIvocBELA7AAsgBEEBdCIAIAJBAXQiAmoiASAASQ0BIAEgDEsNAiAAIANBAXQiA2oiASAASQ0DIAEgCEsNBCACIAlqIAAgAyAKaiAAEJ87IQQLIAVBgAJqJAAgBA8LIAIgAUH4vYcBELE7AAsgASAMQfi9hwEQsDsACyADIAFBiL6HARCxOwALIAEgCEGIvocBELA7AAv8CQIHfwN+IwBBkAFrIgIkACABQQxqENk8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnakEBdCIIai8BALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABLwEAs7wiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUECaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6AsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6AsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ/g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ/g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ5g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ5g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQnA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQnA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ5w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ5w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6hEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6hEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6xEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6xEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ0A0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ0A0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQpw4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQpw4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+A0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+A0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQng4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQng4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ1w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ1w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQvQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQvQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQxA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQxA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7BEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7BEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7REMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7REgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7hEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7hEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQixIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQixIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjBEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjBEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQhw8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQhw8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQoREMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQoREgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ/w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ/w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQuAsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQuAsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3xAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3xAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8g0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8g0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQtQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQtQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqwsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqwsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqRIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqRIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+Q0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+Q0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQiw0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQiw0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7xEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7xEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQuQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQuQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+QwMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+QwgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrAsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrAsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjREMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjREgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ4BAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ4BAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ1wsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ1wsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrxEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrxEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQtA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQtA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3wwMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3wwgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlw4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlw4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8BEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8BEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8hAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8hAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQwBEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQwBEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjBIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjBIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAuECQIXfwF+IwBBgAJrIhAkACABIAAoAgQiGGsiDkEBIAAoArgBdCIHayAOIAAoAhAiCWsgB0shDSAAKAIYIRFBASAGdCEZIAAoAgwhEiAAKAIIIRwgACgCxAEiByAGSSEaIAAoArQBIQggACkDUCEeIAAoAiQhCiAAKAIoIQsgACgCXCEPAkACQAJ/IAVBA0YEQEEBIAcgBmt0QQAgBiAHSRshEyABIAgoAsABQQJrIAQQox1BAnQhFEEADAELIAVBAkYNAUEACyEWDAELIAgoAlwgCCgCKCABIAgoAiRBCGogBBCjHSIdQQh2IAZ0IhRBAnQhFyAUaiEbIBdqIRdBACEUQQEhFkEAIRMLIAkgDRshDSAHIAYgGhshByAZQQFrIQwCQCAAKALcAUUEQCAAIAEgBCAGIAxBARCwICAAQSxqIBggDiAKIAQgHhCnKCEEDAELIAEgCkEIaiAEIB4Q5iMhBCAAIA42AhwLIAkgDSARGyERIBIgHGohGiASIBhqIQ1BASAHdCEJIAAgACgCWCAEajYCWCAPIARBCHYgBnQiB0ECdGohCkEAIQYgByALaiIHIARB/wFxIAwgBy0AACILcSIPIBkQmBchHgNAAkAgCUUgHlByDQAgHqciFWggHkIgiKdoQSBqIBUbIA9qIAxxIhUEQCAKIBVBAnRqKAIAIhUgEUkNASAQIAZBAnRqIBU2AgAgCUEBayEJIAZBAWohBgsgHkIBfSAegyEeDAELCyAHQQAgDCALQT9qIAxxIgsbIAtqIgs6AAAgByALaiAEOgAAIAAgACgCHCIAQQFqNgIcIAogC0ECdGogADYCAEEDIQAgDkEDaiEPIAFBBGohCyABQQNrIREgECEEA0ACQCAGRQRAIAAhBwwBCwJAAn8gBUEBRiAEKAIAIgogEklxRQRAIAogGGoiByAAakEDaygAACAAIBFqKAAARw0CIAEgByACEIAUDAELIAogHGoiBygAACABKAAARw0BIAsgB0EEaiACIBogDRDNKEEEagsiByAATQ0AIAMgDyAKazYCACAHIgAgAWogAkYNAQsgBEEEaiEEIAZBAWshBgwBCwsCQCAFQQNGBEAgAyAHIAkgE2ogCCABIAIgDSAOIBIgFBCgDSEADAELAkAgFkUNACAIKAIAIQUgCCgCBCEKIAgoAgwhAEEAIQYgGyAdQf8BcSAMIBstAABxIgQgGRCYFyEeA0ACQCAJRSAeUHINACAepyIIaCAeQiCIp2hBIGogCBsgBGogDHEiCARAIBcgCEECdGooAgAiCCAASQ0BIBAgBkECdGogCDYCACAJQQFrIQkgBkEBaiEGCyAeQgF9IB6DIR4MAQsLIAogEmohCCAFIA5qQQNqIQwgECEEA0AgBkUNAQJAIAogBCgCACIJaiIAKAAAIAEoAABHDQAgCyAAQQRqIAIgBSANEM0oQQRqIgAgB00NACADIAwgCCAJams2AgAgACIHIAFqIAJGDQMLIARBBGohBCAGQQFrIQYMAAsACyAHIQALIBBBgAJqJAAgAAv8CQIHfwN+IwBBkAFrIgIkACABQQxqKAIIIQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIai0AALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQhBACEBA0AgASAIai0AALO8IgNB////A3EhBAJAIANBgICA/AdxIgZBgICA/AdGBEAgBEEAR0EJdCAEQQ12ckGA+AFyIQMMAQsgBkGAgIC4BEsEQEGA+AEhAwwBCyADQYCAgMQDTwRAIAZBDXYgBEENdmogA0EMdiADQf/fAHFBAEdxakGAgAFqIQMMAQsgA0GAgICYA0kEQEEAIQMMAQsgBEGAgIAEciIEQR4gA0EXdiIGa3YhAyAEQR0gBmsiBnZBAXFFDQAgA0EDIAZ0QQFrIARxQQBHaiEDCyAFIAM7AQAgBUECaiEFIAcgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvfCQIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiAyEEAkACQAJAIANBOHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEGIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAGIAqnIAinaiIEQQF0ai8BACIBrSEIIAUgBEEDdGoCfiAIQjCGIAFB//8BcUUNABogAUH/B3EhBCAIQv8HgyEKIAhCgIACgyEIIAFBgPgBcSIBQYD4AUYEQCAIQjCGIghCgICAgICAgPj/AIQgBEUNARogCCAKQiqGhEKAgICAgICA/P8AhAwBCyAIQjCGIgggAUEKdkHwB2qtQjSGIApCKoaEhCABDQAaIAogBGciAUEQa0H//wNxQSVqrYZC/////////weDQYYIIAFrrUI0hoQgCIQLNwMADAALAAtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAUCfiAELwEAIgOtIglCMIYgA0H//wFxRQ0AGiADQf8HcSEHIAlC/weDIQggCUKAgAKDIQkgA0GA+AFxIgNBgPgBRgRAIAlCMIYiCUKAgICAgICA+P8AhCAHRQ0BGiAJIAhCKoaEQoCAgICAgID8/wCEDAELIAlCMIYiCSADQQp2QfAHaq1CNIYgCEIqhoSEIAMNABogCCAHZyIDQRBrQf//A3FBJWqthkL/////////B4NBhgggA2utQjSGhCAJhAs3AwAgBUEIaiEFIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEFIAEgAkHQAGoiAykCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBTYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAFNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALtw0BCn8jAEHAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIgA0EQaiIFKAIQTwRAAkACQAJAAkACQAJAIAMoAgBBAWsOBQECAwUFAAsgBEH4AGoiBiADKAI8QQBBAkECEKAYIAQoAnwhAyAEKAJ4QQFGDQYgBEEANgIsIAQgBCgCgAE2AiggBCADNgIkIAYgBRDJNCAEQewAaiAGENUJIAQoAmxBAUYEQANAIAQoAnQiAyAEKAJwIgVJDRAgAiADSQ0RIARBJGogAyAFayIDEO0tIANBAXQiBgRAIAQoAiggBCgCLEEBdGogASAFQQF0aiAG/AoAAAsgBCAEKAIsIANqNgIsIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAAgBEH4AGoQthgMAwsgBEH4AGoiBiAFIAMoAjwQsSYgBEEwaiAGQTj8CgAAIAQoArQBIQMgBCAEKAKwASIIQQF0IgU2AiQgBSEGIAVBPnEiBwRAIAUgB2tBQGsiBiAFSQ0HC0HAACEHIAZBwAAQ0TRFDQcgBgRAIAZBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCEFA0AgBSAEKAK8ASIBTw0LIAMgBCgCuAEgBUEBdGovAQA7AAAgA0ECaiEDIARBEGogBEH4AGoQ1hAgBCgCFCEFIAQoAhBBAXENAAsgBCgCJCEFCyAEIAMgB2siATYCbCABIAVHDQogBCAGNgKIASAEQoCAgICACDcCgAEgBCAFNgJ8IAQgBzYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNCyABQoGAgIAQNwIAIAEgBCkCeDcCCCAAIAU2AgggACACNgIEIAAgATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEFIAMoAgwhAyAEIAI2AoQBIAQgATYCgAEgBCAFIANBAnRqNgJ8IAQgBTYCeCMAQSBrIgIkACACQRRqIARB+ABqIgEoAgQgASgCAGtBAnZBAEECQQIQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBoIKDARD9LwALIARB7ABqIQcgAkEQaiILQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgUgASgCBCABKAIAa0ECdhDtLSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIANBBGoiCCgCBCEFIAgoAgAhDAJAAkAgASgCACIGIAEoAgQiCkcEQCABKAIMIQkgASgCCCENIAgoAgggBUEBdGohASAKIAZrQQJ2IQgDQCAGKAIAIgogCU8NAiABIA0gCkEBdGovAQA7AQAgBkEEaiEGIAFBAmohASAFQQFqIQUgCEEBayIIDQALCyAMIAU2AgAMAQsgCiAJQby0ggEQwyEACyADQRBqJAAgB0EIaiALKAIANgIAIAcgAikCCDcCACACQSBqJAAgACAHELYYDAELIARB+ABqIAMoAjxBAEECQQIQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7S0gBUEBdCIIBEAgBCgCcCAEKAJ0QQF0aiABIAZBAXRqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahC2GAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAGEKM9AAsgBSABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAucDAEGfyMAQcABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiADQRBqIgUoAhBPBEACQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDBQUACyAEQfgAaiIGIAMoAjxBAEEEQQQQoBggBCgCfCEDIAQoAnhBAUYNBiAEQQA2AiwgBCAEKAKAATYCKCAEIAM2AiQgBiAFEMk0IARB7ABqIAYQ1QkgBCgCbEEBRgRAA0AgBCgCdCIDIAQoAnAiBUkNECACIANJDREgBEEkaiADIAVrIgMQ7i0gA0ECdCIGBEAgBCgCKCAEKAIsQQJ0aiABIAVBAnRqIAb8CgAACyAEIAQoAiwgA2o2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggACAEQfgAahDxGAwDCyAEQfgAaiIGIAUgAygCPBCxJiAEQTBqIAZBOPwKAAAgBCgCtAEhAyAEIAQoArABIghBAnQiBTYCJCAFIQYgBUE8cSIHBEAgBSAHa0FAayIGIAVJDQcLQcAAIQcgBkHAABDRNEUNByAGBEAgBkHAABCtNiIHRQ0JCyAEQfgAaiIJIARBMGpBOPwKAAAgBCACNgK8ASAEIAE2ArgBIAQgAzYCtAEgBCAINgKwASAEQRhqIAkQ1hAgByEDIAQoAhhBAXEEQCAEKAIcIQUDQCAFIAQoArwBIgFPDQsgAyAEKAK4ASAFQQJ0aigCADYAACADQQRqIQMgBEEQaiAEQfgAahDWECAEKAIUIQUgBCgCEEEBcQ0ACyAEKAIkIQULIAQgAyAHayIBNgJsIAEgBUcNCiAEIAY2AogBIARCgICAgIAINwKAASAEIAU2AnwgBCAHNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAAgBTYCCCAAIAI2AgQgACABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQUgAygCDCEDIAQgAjYChAEgBCABNgKAASAEIAUgA0ECdGo2AnwgBCAFNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBBBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEGggoMBEP0vAAsgAUEQaiIGQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgMkACABQQhqIgUgAigCBCACKAIAa0ECdhDuLSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIAIgA0EEahDbGSADQRBqJAAgBEHsAGoiAkEIaiAGKAIANgIAIAIgASkCCDcCACABQSBqJAAgACACEPEYDAELIARB+ABqIAMoAjxBAEEEQQQQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7i0gBUECdCIIBEAgBCgCcCAEKAJ0QQJ0aiABIAZBAnRqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahDxGAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAGEKM9AAsgBSABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAuKCgIGfwN+IwBB8AFrIgIkACABKAIMIgEgASgCACIDQQFqNgIAAkACQAJAAkAgA0EATgRAIAIgATYCRCACQQA2AuwBIAJBKToA4AEgAkGAgICAeDYC0AEgAkEANgLcASACQcgAaiACQdABaiACQcQAaiACQeABahDSAQJAIAIoAkgiA0GCgICAeEcEQCACQcgBaiIEIAJB5ABqKAIANgIAIAJBwAFqIgUgAkHcAGopAgA3AwAgAkG4AWoiBiACQdQAaikCADcDACACIAIpAkw3A7ABIANBgYCAgHhHDQFBrNnPABCyOwALIAJBxAFqIAJB4ABqKQMAIgg3AgAgAkG8AWogAkHYAGopAwAiCTcCACACQZwBaiIBIAk3AgAgAkGkAWoiAyAINwIAIAIgAikDUCIINwK0ASACIAg3ApQBIAJB0AFqEIYwIAJBNGogASkCACIINwIAIAJBPGogAykCACIJNwIAIAIgAikClAEiCjcCLCAAQRBqIAk3AgAgAEEIaiAINwIAIAAgCjcCACAAQYCAgIB4NgI0IAIoAkQiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAJBxABqEIMgDAULIAJBqAFqIgcgBCgCADYCACACQaABaiIEIAUpAwA3AwAgAkGYAWoiBSAGKQMANwMAIAIgAikDsAE3A5ABIAJB0AFqEIYwIAJBQGsgBygCACIGNgIAIAJBOGogBCkDACIINwMAIAJBMGogBSkDACIJNwMAIAJBFGogCTcCACACQRxqIAg3AgAgAkEkaiAGNgIAIAIgAikDkAEiCDcDKCACIAM2AgggAiAINwIMIAIoAkQiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBxABqEIMgCyACQcgAaiABQQhqIgMgASgCCEECRkECdGoiBCgCDCAEKAIQIAJBFGogAi0AJBCbFCABKAIIIQEgAkGwAWoiBEGons8AEKUrIAIpA7gBIQkgAikDsAEhCiAEIAJBKGpBGEEIQQQQnRQgAyABQQJGQQJ0aiEBIAIoArQBIQMCQCACKAKwASIERQRAIAI1ArgBIQgMAQsgAikCuAEhCCADQQlqIgVFDQAgBEH/ASAF/AsACyACIAk3A6gBIAIgCjcDoAEgAiADNgKUASACIAQ2ApABIAIgCDcDmAEgASgCAEUEQCAIQiCIpyEBDAQLIAJBsAFqIgNBEEEAQQFBARCgGCACKAK0ASEEIAIoArABQQFGDQEgAigCuAEiBUEIakGk2c8AKQAANwAAIAVBnNnPACkAADcAACACQRA2AjAgAiAFNgIsIAIgBDYCKCABKAIARQ0CIAIgASgCBDYC0AEgAyACQdABahCkEiACQeABaiIBIAJBkAFqIAJBKGogAxDOCSABEIYwIAIoApwBIQEMAwsACyAEIAIoArgBQeSjzwAQ/S8AC0Hcus8AQSNBgLvPABCfKQALAkAgAQRAIAJByAFqIgEgAkGoAWopAwA3AwAgAkHAAWoiAyACQaABaikDADcDACACQbgBaiIEIAJBmAFqKQMANwMAIAIgAikDkAE3A7ABIAJByABqIgUQkycgAkHgAGogASkDADcDACACQdgAaiADKQMANwMAIAJB0ABqIAQpAwA3AwAgAiACKQOwATcDSCAAIAVByAD8CgAADAELIAAgAkHIAGpByAD8CgAAIAJBkAFqEJMnCyACQQhqEMkoCyACQfABaiQAC+oJAgl/A34jAEHAAWsiAyQAIAMgAjYCECABQQxqENg8IQUCQAJAAkACQAJAAkAgARCSNiIEBEBBwAAhAiADQQhqIAQQ3DsgBCgCFCEHIAQoAgwhCCADKAIMIQogAygCCCEJIAVBA3YgBUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0GIAQEQCAEQcAAEK02IgJFDQQLIANCADcCICADIAI2AhwgAyAENgIYIANBwAA2AhQgA0EUaiAIIAUgCGogCSAKEL8YDAELQcAAIQIgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiAkUNAgsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAUQ3hALIAVBA3QiBCECAkAgBEE4cSIGBEAgBCAGa0FAayICIARJDQELQcAAIQYgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBkUNAQsgA0EANgI4IAMgBjYCMCADIAI2AiwgA0HAADYCKCAEBEAgBARAIAZBACAE/AsACyADKAI4IQsgAygCMCEGCyADIAQ2AjQgAyAFIAtqIgI2AjggAyAHNgI8IAMgAjYCTCADIAY2AkggAyABNgJEIAMgA0EUajYCVCADIANBPGo2AlAgAyADQRBqNgJAIAdFDQUgBSAHRg0GIAkEQCADQfgAaiAJIAogCCAFEL8UIANBmAFqIQEDQAJAIAMpA6ABIg1QRQRAIAMpA6gBIQwMAQsDQAJ+AkAgAykDiAEiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDiAEgDKdBAXFFDQAgAyADKQOQATcDuAEMAQsgAygCmAFFDQEgA0GwAWogARC2KiADKQOwASEMCyAMQgBSDQILIANCAzcDiAELIAMpA3giDEICUQ0MIANCADcDeCADKQOAAQwBCyADKQO4AQshDSAMp0EBcUUNCiADIAMpA6gBQkB9Igw3A6gBIAMgDTcDoAEgDVANAAsLIAMgDUIBIA16Ig6GhTcDoAEgA0FAayAOpyAMp2oQkxAMAAsAC0HEiv8AELI7AAtBwAAgAhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBBCjPQALQcAAIAQQoz0ACyAFRQ0AQQAhAgNAIANBQGsgAhCTECAFIAJBAWoiAkcNAAsLIANB2ABqIANBFGoiBxCCFCADQfgAaiICEJcpIANBMGogA0GAAWoiBSkCADcDACADKQMoIQwgAyADKQJ4NwMoIANBADYCOCADIAw3AoQBIANBADYCgAEgAyAENgJ8IAMgBjYCeCADIAIQ1zsgAygCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiAFKQIANwIAIAFBGGogA0GIAWoiCCgCADYCACADIAQ2AkggAyAGNgJEIAMgATYCQCADQewAaiIBIANBQGsQ5BkgAygCPCEEIAggA0HoAGooAgA2AgAgBSADQeAAaikCADcDACADIAMpAlg3A3ggAyAENgKMASAAIAEgAhDWHSADQShqEM8vIAcQzy8gA0HAAWokAA8LQQRBHBCjPQALQdyL/wBBKSADQfgAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBAXRqLgEAsjgCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBC4BALI4AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGooAgC3OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAtzkDACAGQQhqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBA3QiBCEDAkACQAJAIARBOHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUEDdGogASAFQQF0ai4BALc5AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQuAQC3OQMAIAZBCGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENsdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAnRqKgIAuzkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCoCALs5AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGooAgC4OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAuDkDACAGQQhqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUECdGogASAFQQF0ai8BALM4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQvAQCzOAIAIAZBBGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAXRqLwEAuDkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBC8BALg5AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL6gkCCX8DfiMAQcABayIDJAAgAyACNgIQIAFBDGoQ2DwhBQJAAkACQAJAAkACQCABEJI2IgQEQEHAACECIANBCGogBBDcOyAEKAIUIQcgBCgCDCEIIAMoAgwhCiADKAIIIQkgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQYgBARAIARBwAAQrTYiAkUNBAsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhAiAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiICRQ0CCyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogBRDeEAsgBUEDdCIEIQICQCAEQThxIgYEQCAEIAZrQUBrIgIgBEkNAQtBwAAhBiACQcAAENE0BEACQCACBEAgAkHAABCtNiIGRQ0BCyADQQA2AjggAyAGNgIwIAMgAjYCLCADQcAANgIoIAQEQCAEBEAgBkEAIAT8CwALIAMoAjghCyADKAIwIQYLIAMgBDYCNCADIAUgC2oiAjYCOCADIAc2AjwgAyACNgJMIAMgBjYCSCADIAE2AkQgAyADQRRqNgJUIAMgA0E8ajYCUCADIANBEGo2AkAgB0UNBSAFIAdGDQYgCQRAIANB+ABqIAkgCiAIIAUQvxQgA0GYAWohAQNAAkAgAykDoAEiDVBFBEAgAykDqAEhDAwBCwNAAn4CQCADKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwOIASAMp0EBcUUNACADIAMpA5ABNwO4AQwBCyADKAKYAUUNASADQbABaiABELYqIAMpA7ABIQwLIAxCAFINAgsgA0IDNwOIAQsgAykDeCIMQgJRDQwgA0IANwN4IAMpA4ABDAELIAMpA7gBCyENIAynQQFxRQ0KIAMgAykDqAFCQH0iDDcDqAEgAyANNwOgASANUA0ACwsgAyANQgEgDXoiDoaFNwOgASADQUBrIA6nIAynahCUEAwACwALQcSK/wAQsjsAC0HAACACEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAEEKM9AAtBwAAgBBCjPQALIAVFDQBBACECA0AgA0FAayACEJQQIAUgAkEBaiICRw0ACwsgA0HYAGogA0EUaiIHEIIUIANB+ABqIgIQlykgA0EwaiADQYABaiIFKQIANwMAIAMpAyghDCADIAMpAng3AyggA0EANgI4IAMgDDcChAEgA0EANgKAASADIAQ2AnwgAyAGNgJ4IAMgAhDXOyADKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiADQYgBaiIIKAIANgIAIAMgBDYCSCADIAY2AkQgAyABNgJAIANB7ABqIgEgA0FAaxDkGSADKAI8IQQgCCADQegAaigCADYCACAFIANB4ABqKQIANwMAIAMgAykCWDcDeCADIAQ2AowBIAAgASACENYdIANBKGoQzy8gBxDPLyADQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIANB+ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEDdGopAwC1OAIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKQMAtTgCACAGQQRqIQYgBEEIaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvqCQIJfwN+IwBBwAFrIgMkACADIAI2AhAgAUEMahDYPCEFAkACQAJAAkACQAJAIAEQkjYiBARAQcAAIQIgA0EIaiAEENw7IAQoAhQhByAEKAIMIQggAygCDCEKIAMoAgghCSAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBiAEBEAgBEHAABCtNiICRQ0ECyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogCCAFIAhqIAkgChC/GAwBC0HAACECIAVBA3YgBUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgJFDQILIANCADcCICADIAI2AhwgAyAENgIYIANBwAA2AhQgA0EUaiAFEN4QCyAFQQN0IgQhAgJAIARBOHEiBgRAIAQgBmtBQGsiAiAESQ0BC0HAACEGIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgZFDQELIANBADYCOCADIAY2AjAgAyACNgIsIANBwAA2AiggBARAIAQEQCAGQQAgBPwLAAsgAygCOCELIAMoAjAhBgsgAyAENgI0IAMgBSALaiICNgI4IAMgBzYCPCADIAI2AkwgAyAGNgJIIAMgATYCRCADIANBFGo2AlQgAyADQTxqNgJQIAMgA0EQajYCQCAHRQ0FIAUgB0YNBiAJBEAgA0H4AGogCSAKIAggBRC/FCADQZgBaiEBA0ACQCADKQOgASINUEUEQCADKQOoASEMDAELA0ACfgJAIAMpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAyAMUK1CAYY3A4gBIAynQQFxRQ0AIAMgAykDkAE3A7gBDAELIAMoApgBRQ0BIANBsAFqIAEQtiogAykDsAEhDAsgDEIAUg0CCyADQgM3A4gBCyADKQN4IgxCAlENDCADQgA3A3ggAykDgAEMAQsgAykDuAELIQ0gDKdBAXFFDQogAyADKQOoAUJAfSIMNwOoASADIA03A6ABIA1QDQALCyADIA1CASANeiIOhoU3A6ABIANBQGsgDqcgDKdqEJUQDAALAAtBxIr/ABCyOwALQcAAIAIQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAQQoz0AC0HAACAEEKM9AAsgBUUNAEEAIQIDQCADQUBrIAIQlRAgBSACQQFqIgJHDQALCyADQdgAaiADQRRqIgcQghQgA0H4AGoiAhCXKSADQTBqIANBgAFqIgUpAgA3AwAgAykDKCEMIAMgAykCeDcDKCADQQA2AjggAyAMNwKEASADQQA2AoABIAMgBDYCfCADIAY2AnggAyACENc7IAMoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIANBiAFqIggoAgA2AgAgAyAENgJIIAMgBjYCRCADIAE2AkAgA0HsAGoiASADQUBrEOQZIAMoAjwhBCAIIANB6ABqKAIANgIAIAUgA0HgAGopAgA3AwAgAyADKQJYNwN4IAMgBDYCjAEgACABIAIQ1h0gA0EoahDPLyAHEM8vIANBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgA0H4AGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENg8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUECdGogASAFQQN0aisDALY4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQrAwC2OAIAIAZBBGohBiAEQQhqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBA3RqKQMAtDgCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCkDALQ4AgAgBkEEaiEGIARBCGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL6gkCCX8DfiMAQcABayIDJAAgAyACNgIQIAFBDGoQ2DwhBQJAAkACQAJAAkACQCABEJI2IgQEQEHAACECIANBCGogBBDcOyAEKAIUIQcgBCgCDCEIIAMoAgwhCiADKAIIIQkgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQYgBARAIARBwAAQrTYiAkUNBAsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhAiAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiICRQ0CCyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogBRDeEAsgBUEDdCIEIQICQCAEQThxIgYEQCAEIAZrQUBrIgIgBEkNAQtBwAAhBiACQcAAENE0BEACQCACBEAgAkHAABCtNiIGRQ0BCyADQQA2AjggAyAGNgIwIAMgAjYCLCADQcAANgIoIAQEQCAEBEAgBkEAIAT8CwALIAMoAjghCyADKAIwIQYLIAMgBDYCNCADIAUgC2oiAjYCOCADIAc2AjwgAyACNgJMIAMgBjYCSCADIAE2AkQgAyADQRRqNgJUIAMgA0E8ajYCUCADIANBEGo2AkAgB0UNBSAFIAdGDQYgCQRAIANB+ABqIAkgCiAIIAUQvxQgA0GYAWohAQNAAkAgAykDoAEiDVBFBEAgAykDqAEhDAwBCwNAAn4CQCADKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwOIASAMp0EBcUUNACADIAMpA5ABNwO4AQwBCyADKAKYAUUNASADQbABaiABELYqIAMpA7ABIQwLIAxCAFINAgsgA0IDNwOIAQsgAykDeCIMQgJRDQwgA0IANwN4IAMpA4ABDAELIAMpA7gBCyENIAynQQFxRQ0KIAMgAykDqAFCQH0iDDcDqAEgAyANNwOgASANUA0ACwsgAyANQgEgDXoiDoaFNwOgASADQUBrIA6nIAynahCWEAwACwALQcSK/wAQsjsAC0HAACACEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAEEKM9AAtBwAAgBBCjPQALIAVFDQBBACECA0AgA0FAayACEJYQIAUgAkEBaiICRw0ACwsgA0HYAGogA0EUaiIHEIIUIANB+ABqIgIQlykgA0EwaiADQYABaiIFKQIANwMAIAMpAyghDCADIAMpAng3AyggA0EANgI4IAMgDDcChAEgA0EANgKAASADIAQ2AnwgAyAGNgJ4IAMgAhDXOyADKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiADQYgBaiIIKAIANgIAIAMgBDYCSCADIAY2AkQgAyABNgJAIANB7ABqIgEgA0FAaxDkGSADKAI8IQQgCCADQegAaigCADYCACAFIANB4ABqKQIANwMAIAMgAykCWDcDeCADIAQ2AowBIAAgASACENYdIANBKGoQzy8gBxDPLyADQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIANB+ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEBdGovAQA2AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQvAQA2AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEBdGouAQA2AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQuAQA2AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGo0AgA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQ0AgA3AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUEBdGoyAQA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQyAQA3AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUEBdGozAQA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQzAQA3AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGo1AgA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQ1AgA3AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxQkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqQQJ0IgVqIAEgBWooAgCyOAIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAsjgCACAGQQRqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvFCQIKfwN+IwBBsAFrIgIkACABQQxqENs8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2pBAnQiBWogASAFaigCALM4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQoAgCzOAIAIAZBBGohBiAEQQRqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAXRqMwEANwMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEMwEANwMAIAZBCGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAnRqNQIANwMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAENQIANwMAIAZBCGohBiAEQQRqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBAXRqLwEANgIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAELwEANgIAIAZBBGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEMcdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8UJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynakEDdCIFaiABIAVqKQMAujkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCkDALo5AwAgBkEIaiEGIARBCGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxQkCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqQQN0IgVqIAEgBWopAwC5OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKQMAuTkDACAGQQhqIQYgBEEIaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvNCgEGfyMAQcABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiADQRBqIgUoAhBPBEACQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDBQUACyAEQfgAaiIGIAMoAjxBAEEIQQgQoBggBCgCfCEDIAQoAnhBAUYNBiAEQQA2AiwgBCAEKAKAATYCKCAEIAM2AiQgBiAFEMk0IARB7ABqIAYQ1QkgBCgCbEEBRgRAA0AgBCgCdCIDIAQoAnAiBUkNECACIANJDREgBEEkaiADIAVrIgMQ7C0gA0EDdCIGBEAgBCgCKCAEKAIsQQN0aiABIAVBA3RqIAb8CgAACyAEIAQoAiwgA2o2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggACAEQfgAahDzGAwDCyAEQfgAaiIGIAUgAygCPBCxJiAEQTBqIAZBOPwKAAAgBCgCtAEhAyAEIAQoArABIghBA3QiBjYCJCAGIgVBOHEiBwRAIAUgBSAHa0FAayIFSw0HC0HAACEHIAVBwAAQ0TRFDQcgBQRAIAVBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCECA0AgAiAEKAK8ASIBTw0LIAMgBCgCuAEgAkEDdGopAwA3AAAgA0EIaiEDIARBEGogBEH4AGoQ1hAgBCgCFCECIAQoAhBBAXENAAsLIAQgAyAHayIBNgJsIAEgBkcNCiAEIAU2AogBIARCgICAgIAINwKAASAEIAY2AnwgBCAHNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAAgBjYCCCAAIAI2AgQgACABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQUgAygCDCEDIAQgAjYChAEgBCABNgKAASAEIAUgA0ECdGo2AnwgBCAFNgJ4IARB7ABqIgEgBEH4AGoQ/RogACABEPMYDAELIARB+ABqIAMoAjxBAEEIQQgQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7C0gBUEDdCIIBEAgBCgCcCAEKAJ0QQN0aiABIAZBA3RqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahDzGAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgAiABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAvaCQEJfyMAQUBqIgQkACABKAIAIQgCQAJAAkAgAkUEQCABKAIEIQYCQCAIQYCAgIB4RwRAIAQgASgCCDYCICAEIAY2AhwgBCAINgIYDAELIARBGGogBhDpHQsgA0H/AXENASAEQThqIARBIGooAgAiBjYCACAEIAQpAxg3AzACQCAGRQ0AIAQoAjQiASAGQQJ0IgVqQQRrIgJFDQAgAigCAA0AIAFBBGshASAGQf////8DcSEDAkADQCAFRQRAQQAhBQwCCyADQQFrIQMgASAFaiAFQQRrIQUoAgBFDQALIANBAWoiBSAGSw0BCyAEIAU2AjggBSEGCwJAIAQoAjBBAnYgBksEQCAEIARBMGogBkEEQQQQ9BQgBCgCACIBQYGAgIB4Rw0BCyAAIAQpAzA3AgAgAEEIaiAEQThqKAIANgIADAQLIAEgBCgCBEHUpYgBEP0vAAsgBEEwakF/IAEoAgQgASAIQYCAgIB4RhsiBigCCCACakEBaiIFIAIgBUsbQQBBBEEEEKAYIAQoAjQhBQJAIAQoAjBBAUcEQCAEQSxqIgdBADYCACAEIAQoAjg2AiggBCAFNgIkIARBJGoiBSACENMaIAUgBigCBCIFIAUgBigCCEECdGoQniQgBEEgaiIGIAcoAgA2AgAgBCAEKQIkNwMYIANB/wFxDQIgBEE4aiAGKAIAIgY2AgAgBCAEKQMYNwMwAkAgBkUNACAEKAI0IgIgBkECdCIFakEEayIDRQ0AIAMoAgANACACQQRrIQIgBkH/////A3EhAwJAA0AgBUUEQEEAIQUMAgsgA0EBayEDIAIgBWogBUEEayEFKAIARQ0ACyADQQFqIgUgBksNAQsgBCAFNgI4IAUhBgsgBCgCMEECdiAGSwRAIARBEGogBEEwaiAGQQRBBBD0FCAEKAIQIgJBgYCAgHhHDQILIAAgBCkDMDcCACAAQQhqIARBOGooAgA2AgAgCEGAgICAeEYNBAwDCyAFIAQoAjhBlKWIARD9LwALIAIgBCgCFEHUpYgBEP0vAAsCQCAEKAIgIgcgAk8EQAJAIAIgB0YNACAEKAIcIQYgB0ECdCEJIAJBAnQhBSADQR9xIQpBACADa0EfcSELQQAhAwNAIAUgBmoiDCADIAwoAgAiAyAKdHI2AgAgAyALdiEDIAkgBUEEaiIFRw0ACyADRQ0AIAQoAhggB0YEfyAEQRhqQbSliAEQnSggBCgCHAUgBgsgB0ECdGogAzYCACAEIAdBAWo2AiALIARBOGogBEEgaigCACIGNgIAIAQgBCkDGDcDMCAGRQ0BIAQoAjQiAyAGQQJ0IgdqQQRrIgVFDQEgBSgCAA0BIAchBSADQQRrIQcgBkH/////A3EhAwJAA0AgBUUEQEEAIQUMAgsgA0EBayEDIAUgB2ogBUEEayEFKAIARQ0ACyADQQFqIgUgBksNAgsgBCAFNgI4IAUhBgwBCyACIAdBpKWIARCvOwALAkAgBiAEKAIwQQJ2Tw0AIARBCGogBEEwaiAGQQRBBBD0FCAEKAIIIgNBgYCAgHhGDQAgAyAEKAIMQdSliAEQ/S8ACyAAIAQpAzA3AgAgAEEIaiAEQThqKAIANgIAIAJFIAhBgICAgHhGcg0BCyABQQRBBBDgHgsgBEFAayQAC4gLAgR/AX4jAEHQAWsiAyQAIANBrAFqIAEgAhCTDiADKAKwASEEAkAgAygCrAEiBUGKgICAeEcEQCADQSxqIANBzAFqKAIANgIAIANBJGogA0HEAWopAgA3AgAgA0EcaiADQbwBaikCADcCACADIAMpArQBNwIUIAMgBDYCECADIAU2AgwMAQsgA0GsAWogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0G4AWopAgA3AwAgAyADKQKwATcDMCADKAKsASIEQYqAgIB4RwRAIANBKGogA0HIAWopAgA3AgAgA0EYaiABKQMANwIAIAMgAykCwAE3AiAgAyADKQMwNwIQIAMgBDYCDAwBCyADQcgAaiABKQMANwMAIAMgAykDMDcDQCADQawBaiADQUBrQQQQ3RAgAygCtAEhASADKAKwASEEAkACfiADKAKsASIFQYqAgIB4RwRAIANB6ABqIANByAFqKQIANwMAIAMgAykCwAE3A2AgAykCuAEMAQsgBEEBcUUNAQJAIAFBAXEEQCADIAE2AsgBIANBAzYCxAEgA0G55P4ANgLAASADQYCAgIB4NgK8ASADQgQ3ArQBIANChICAgAg3AqwBDAELQX8gAUECaiIEIAEgBEsbIgUgAygCQCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKsAQwCCyADQYiAgIB4NgKsAQwBCyADQawBaiABIAUQvy8LIANBBDYCcCADQYbn/gA2AmwgA0GAgICAeDYCaCADIAE2AmQgA0EBNgJgIANBiAFqIANBrAFqIANB4ABqEIEUIAMoAogBIgVBioCAgHhGDQEgA0HoAGogA0GkAWopAgA3AwAgAyADKQKcATcDYCADKAKQASEBIAMoAowBIQQgAykClAELIQcgA0EoaiADQegAaikDADcCACADIAc3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQNgNwIgDAELIAMgAykDSDcCWCADIAMpA0A3AlAgA0GsAWogA0HQAGpBBhDdECADKAK0ASEBIAMoArABIQQCQAJ+IAMoAqwBIgVBioCAgHhHBEAgA0GQAWogA0HIAWopAgA3AwAgAyADKQLAATcDiAEgAykCuAEMAQsgBEEBcUUNASADQawBaiADKAJQIgUgARCTDiADKAKwASEEAkAgAygCrAEiBkGKgICAeEcEQCADQagBaiADQcwBaigCADYCACADQaABaiADQcQBaikCADcCACADQZgBaiADQbwBaikCADcCACADIAMpArQBNwKQASADIAQ2AowBIAMgBjYCiAEMAQsgA0GsAWogBUF/IAEgBGoiBSAEIAVLGxCIDiADKAKsASIEQYqAgIB4RwRAIANBnAFqIANBwAFqKQIANwIAIANBpAFqIANByAFqKQIANwIAIAMgAykCuAE3ApQBIAMgAykCsAE3AowBCyADIAQ2AogBCyADQQc2ArwBIANBiuf+ADYCuAEgA0GAgICAeDYCtAEgAyABNgKwASADQQE2AqwBIANB4ABqIANBiAFqIANBrAFqEIEUIAMoAmAiBUGKgICAeEYNASADQZABaiADQfwAaikCADcDACADIAMpAnQ3A4gBIAMoAmghASADKAJkIQQgAykCbAshByADQShqIANBkAFqKQMANwIAIAMgBzcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA4gBNwIgDAELIAMoAlAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBCzYCvAEgA0HD6f4ANgK4ASADQYCAgIB4NgK0ASADIAI2ArABIANBAjYCrAEgACADQQxqIANBrAFqEIEUIANB0AFqJAAL4gkCCn8DfiMAQcABayICJAAgAUEMahDZPCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEIaiADENw7IAMoAhQhByADKAIMIQggAigCDCEKIAIoAgghCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAFEN4QCyAFQQJ0IgMhBAJAIANBPHEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAJBADYCOCACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAMEQCAGQQAgA/wLAAsgAigCOCELIAIoAjAhBgsgAiADNgI0IAIgBSALaiIENgI4IAIgBzYCPCACIAQ2AkwgAiAGNgJIIAIgATYCRCACIAJBFGo2AlQgAiACQTxqNgJQIAIgAkH4AGoiATYCQCAHRQ0FIAUgB0YNBiAJBEAgASAJIAogCCAFEL8UIAJBmAFqIQEDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogARC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgAkFAayAOpyAMp2oQrw8MAAsAC0HEiv8AELI7AAtBwAAgBBCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AQQAhBANAIAJBQGsgBBCvDyAFIARBAWoiBEcNAAsLIAJB2ABqIAJBFGoiBxCCFCACQfgAaiIEEJcpIAJBMGogAkGAAWoiBSkCADcDACACKQMoIQwgAiACKQJ4NwMoIAJBADYCOCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBjYCeCACIAQQ1zsgAigCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCCgCADYCACACIAM2AkggAiAGNgJEIAIgATYCQCACQewAaiIBIAJBQGsQ5RkgAigCPCEDIAggAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiADNgKMASAAIAEgBBC/HSACQShqEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+IJAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBCGogAxDcOyADKAIUIQcgAygCDCEIIAIoAgwhCiACKAIIIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogBRDeEAsgBUEDdCIDIQQCQCADQThxIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACQQA2AjggAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCADBEAgBkEAIAP8CwALIAIoAjghCyACKAIwIQYLIAIgAzYCNCACIAUgC2oiBDYCOCACIAc2AjwgAiAENgJMIAIgBjYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgB0UNBSAFIAdGDQYgCQRAIAEgCSAKIAggBRC/FCACQZgBaiEBA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAJBQGsgDqcgDKdqELAPDAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNAEEAIQQDQCACQUBrIAQQsA8gBSAEQQFqIgRHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiBBCXKSACQTBqIAJBgAFqIgUpAgA3AwAgAikDKCEMIAIgAikCeDcDKCACQQA2AjggAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAY2AnggAiAEENc7IAIoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiADNgJIIAIgBjYCRCACIAE2AkAgAkHsAGoiASACQUBrEOQZIAIoAjwhAyAIIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgAzYCjAEgACABIAQQ1h0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAviCQIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQQhqIAMQ3DsgAygCFCEHIAMoAgwhCCACKAIMIQogAigCCCEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAUQ3hALIAVBA3QiAyEEAkAgA0E4cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAkEANgI4IAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgAwRAIAZBACAD/AsACyACKAI4IQsgAigCMCEGCyACIAM2AjQgAiAFIAtqIgQ2AjggAiAHNgI8IAIgBDYCTCACIAY2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAdFDQUgBSAHRg0GIAkEQCABIAkgCiAIIAUQvxQgAkGYAWohAQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASACQUBrIA6nIAynahCxDwwACwALQcSK/wAQsjsAC0HAACAEEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQBBACEEA0AgAkFAayAEELEPIAUgBEEBaiIERw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgQQlykgAkEwaiACQYABaiIFKQIANwMAIAIpAyghDCACIAIpAng3AyggAkEANgI4IAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAGNgJ4IAIgBBDXOyACKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgAzYCSCACIAY2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDkGSACKAI8IQMgCCACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAM2AowBIAAgASAEENkdIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gkCCn8DfiMAQcABayICJAAgAUEMahDZPCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEIaiADENw7IAMoAhQhByADKAIMIQggAigCDCEKIAIoAgghCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAFEN4QCyAFQQF0IgMhBAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAJBADYCOCACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAMEQCAGQQAgA/wLAAsgAigCOCELIAIoAjAhBgsgAiADNgI0IAIgBSALaiIENgI4IAIgBzYCPCACIAQ2AkwgAiAGNgJIIAIgATYCRCACIAJBFGo2AlQgAiACQTxqNgJQIAIgAkH4AGoiATYCQCAHRQ0FIAUgB0YNBiAJBEAgASAJIAogCCAFEL8UIAJBmAFqIQEDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogARC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgAkFAayAOpyAMp2oQsg8MAAsAC0HEiv8AELI7AAtBwAAgBBCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AQQAhBANAIAJBQGsgBBCyDyAFIARBAWoiBEcNAAsLIAJB2ABqIAJBFGoiBxCCFCACQfgAaiIEEJcpIAJBMGogAkGAAWoiBSkCADcDACACKQMoIQwgAiACKQJ4NwMoIAJBADYCOCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBjYCeCACIAQQ1zsgAigCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCCgCADYCACACIAM2AkggAiAGNgJEIAIgATYCQCACQewAaiIBIAJBQGsQ4RkgAigCPCEDIAggAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiADNgKMASAAIAEgBBDNHSACQShqEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+IJAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBCGogAxDcOyADKAIUIQcgAygCDCEIIAIoAgwhCiACKAIIIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogBRDeEAsgBUECdCIDIQQCQCADQTxxIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACQQA2AjggAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCADBEAgBkEAIAP8CwALIAIoAjghCyACKAIwIQYLIAIgAzYCNCACIAUgC2oiBDYCOCACIAc2AjwgAiAENgJMIAIgBjYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgB0UNBSAFIAdGDQYgCQRAIAEgCSAKIAggBRC/FCACQZgBaiEBA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAJBQGsgDqcgDKdqELMPDAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNAEEAIQQDQCACQUBrIAQQsw8gBSAEQQFqIgRHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiBBCXKSACQTBqIAJBgAFqIgUpAgA3AwAgAikDKCEMIAIgAikCeDcDKCACQQA2AjggAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAY2AnggAiAEENc7IAIoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiADNgJIIAIgBjYCRCACIAE2AkAgAkHsAGoiASACQUBrEOUZIAIoAjwhAyAIIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgAzYCjAEgACABIAQQxx0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAviCQIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQQhqIAMQ3DsgAygCFCEHIAMoAgwhCCACKAIMIQogAigCCCEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAUQ3hALIAVBAXQiAyEEAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAkEANgI4IAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgAwRAIAZBACAD/AsACyACKAI4IQsgAigCMCEGCyACIAM2AjQgAiAFIAtqIgQ2AjggAiAHNgI8IAIgBDYCTCACIAY2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAdFDQUgBSAHRg0GIAkEQCABIAkgCiAIIAUQvxQgAkGYAWohAQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASACQUBrIA6nIAynahC1DwwACwALQcSK/wAQsjsAC0HAACAEEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQBBACEEA0AgAkFAayAEELUPIAUgBEEBaiIERw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgQQlykgAkEwaiACQYABaiIFKQIANwMAIAIpAyghDCACIAIpAng3AyggAkEANgI4IAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAGNgJ4IAIgBBDXOyACKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgAzYCSCACIAY2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDhGSACKAI8IQMgCCACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAM2AowBIAAgASAEENodIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL2QkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhBgJAIARBPHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQJ0aiABIARqLQAAszgCAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AALM4AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9kJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQYCQCAEQTxxIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEECdGogASAEaiwAALI4AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGosAACyOAIAIANBBGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvZCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBA3QiBCEGAkAgBEE4cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBA3RqIAEgBGotAAC4OQMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqLQAAuDkDACADQQhqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENsdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL2QkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqLAAAtzkDAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEaiwAALc5AwAgA0EIaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9QKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAEgCqcgCKdqIgVBAnRqKgIAIgs4AoABIAtDAAEAx15FIAtDAAAAR11FckUEQCAEIAVBAXRqIAv8ADsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAEAx15FIAtDAAAAR11Fcg0CIAQgC/wAOwEAIARBAmohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2h0gAkEoahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYUMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAvUCgMGfwN+AX0jAEHQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPnEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBjYCOCACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinaiIFQQJ0aioCACILOAKAASALQwAAgL9eRSALQwAAgEddRXJFBEAgBCAFQQF0aiAL/AE7AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASoCACILOAKwASALQwAAgL9eRSALQwAAgEddRXINAiAEIAv8ATsBACAEQQJqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEM0dIAJBKGoQzy8MAgsgAkHIAWpBh46cODYCACACQoeOnLjw4MGDBzcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqMQAANwMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqMQAANwMAIANBCGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEGAkAgBEE8cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAnRqIAEgBGotAAA2AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGotAAA2AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRC/HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQYCQCAEQT5xIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEBdGogASAEai0AADsBAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AADsBACADQQJqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFEM0dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhBgJAIARBPHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQJ0aiABIARqLAAANgIADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqLAAANgIAIANBBGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEGAkAgBEE8cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAnRqIAEgBGotAAA2AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGotAAA2AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDHHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQYCQCAEQThxIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEDdGogASAEajAAADcDAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEajAAADcDACADQQhqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqMQAANwMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqMQAANwMAIANBCGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEGAkAgBEE+cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAXRqIAEgBGosAAA7AQAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGosAAA7AQAgA0ECaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDaHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8MJAgl/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBCGogAxDcOyADKAIUIQYgAygCDCEHIAIoAgwhCSACKAIIIQggBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwIgIAIgBTYCHCACIAM2AhggAkHAADYCFCACQRRqIAcgBCAHaiAIIAkQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AiAgAiAFNgIcIAIgAzYCGCACQcAANgIUIAJBFGogBBDeEAsCQAJAAkAgBCIDQT9xIgUEQCADIAMgBWtBQGsiA0sNAQtBwAAhBSADQcAAENE0BEAgAwRAIANBwAAQrTYiBUUNBQsgAkEANgI4IAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBARAIAVBACAE/AsACyACKAI4IQogAigCMCEFCyACIAQ2AjQgAiAEIApqIgM2AjggAiAGNgI8IAIgAzYCTCACIAU2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAZFDQIgBCAGRg0DIAgEQCABIAggCSAHIAQQvxQgAkGYAWohAQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASACQUBrIA2nIAunahDQDwwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIARFDQBBACEDA0AgAkFAayADENAPIAQgA0EBaiIDRw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgMQlykgAkEwaiACQYABaiIGKQIANwMAIAIpAyghCyACIAIpAng3AyggAkEANgI4IAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAFNgJ4IAIgAxDXOyACKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgBDYCSCACIAU2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDjGSACKAI8IQQgCCACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAQ2AowBIAAgASADEMEdIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQYCQCAEQT5xIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEBdGogASAEai0AADsBAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AADsBACADQQJqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENodIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALwwkCCX8DfiMAQcABayICJAAgAUEMahDZPCEEAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEIaiADENw7IAMoAhQhBiADKAIMIQcgAigCDCEJIAIoAgghCCAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIFRQ0DCyACQgA3AiAgAiAFNgIcIAIgAzYCGCACQcAANgIUIAJBFGogByAEIAdqIAggCRC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgVFDQILIAJCADcCICACIAU2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAEEN4QCwJAAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEFIANBwAAQ0TQEQCADBEAgA0HAABCtNiIFRQ0FCyACQQA2AjggAiAFNgIwIAIgAzYCLCACQcAANgIoIAQEQCAEBEAgBUEAIAT8CwALIAIoAjghCiACKAIwIQULIAIgBDYCNCACIAQgCmoiAzYCOCACIAY2AjwgAiADNgJMIAIgBTYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgBkUNAiAEIAZGDQMgCARAIAEgCCAJIAcgBBC/FCACQZgBaiEBA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAJBQGsgDacgC6dqENEPDAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBEUNAEEAIQMDQCACQUBrIAMQ0Q8gBCADQQFqIgNHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiAxCXKSACQTBqIAJBgAFqIgYpAgA3AwAgAikDKCELIAIgAikCeDcDKCACQQA2AjggAiALNwKEASACQQA2AoABIAIgBDYCfCACIAU2AnggAiADENc7IAIoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiAENgJIIAIgBTYCRCACIAE2AkAgAkHsAGoiASACQUBrEOMZIAIoAjwhBCAIIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBDYCjAEgACABIAMQ2B0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL1goCDX8CfiMAQeAAayICJAAgAkEQaiABQRhqKQIANwMAIAIgASkCECIPNwMIIAEoAgwhByABKAIIIQwgASgCBCEGIAEoAgAhBCABKAIgIQgCQCAPp0GAgICAeEYNACACKAIQQQN0IQEgAigCDCEDA0AgAQRAIAFBCGshASADLQAEIANBCGohAw0BDAILCyACQoSAgIDAADcCUCACQoCAgIDAADcCWCACQUBrIAJB0ABqEOcMIAIoAghBgICAgHhHBEAgAkEIakEEQQgQ4B4LIAJBEGogAkHIAGooAgA2AgAgAiACKQJANwMICwJAAkACQCAEBEACQCAGIAhNBEACQAJAIAIoAggiBUGAgICAeEYNACACKQIMIQ8gAiAFNgI0IAIgDzcCOCAGBEACQAJAIA9CgICAgBBaBEAgD6ciASAPQiCIpyINQQN0IgRqIQ5BACEDA0AgASgCACEJAkAgAUEEai0AAEEBRgRAIAkgCmohCgwBCyAJIAtqIgsgBksNAwsgAUEIaiEBIANBAWohAyAEQQhrIgQNAAsLIAJBADYCPCACKQI4IQ8MAQsgAkHQAGogDSADa0EBakEAQQRBCBCgGCACKAJUIQQgAigCUEEBRg0HIAJBADYCSCACIAIoAlgiAzYCRCACIAQ2AkAgBEUEQCACQUBrQeyCzQAQmyggAigCRCEDCyADQQE6AAQgAyAGIApqNgIAIAJBATYCSCACKAJAQQFGBEAgAkFAa0H8gs0AEJsoCyACKAJEIgMgCyAGazYCCCADQQA6AAwgAkECNgJIIA4gAUEIaiIJayIEQQN2IgUgAkFAayIBKAIAIAEoAggiA2tLBEAgASADIAVBBEEIENAoIAEoAgghAwsgBARAIAEoAgQgA0EDdGogCSAE/AoAAAsgASABKAIIIAVqNgIIIAIpAkQhDyACKAJAIQUgAkE0akEEQQgQ4B4LIAVBgICAgHhGDQELIAIgDzcCICACIAU2AhwMAQtBEEEEEK02IgFFDQUgAUEAOgAMIAEgCCAGazYCCCABQQE6AAQgASAGNgIAIAJBAjYCWCACIAE2AlAgAiABQRBqNgJcIAIgATYCVCACQRxqIAJB0ABqEOcMCyACQcgAaiACQSRqKAIANgIAIAIgAikCHDcDQAwBCyACQoSAgIDAADcCUCACQoCAgIDAADcCWCACQRxqIAJB0ABqEOcMIAJByABqIAJBJGooAgA2AgAgAiACKQIcNwNAIAIoAghBgICAgHhGDQAgAkEIakEEQQgQ4B4LIAJBEGogAkHIAGooAgA2AgAgAiACKQNANwMICyAMBEACQCACKAIIIgZBgICAgHhHBEAgAikCDCEQAkAgB0UEQCAQQv////8PgyEQDAELIBBCgICAgBBUDQAgEEIgiKciCEEDdCEEIBCnIgGtQoCAgIAQhCEPQQAhAwNAAkAgAUEEai0AAEUEQCAHIAEoAgAiBU0NASAHIAVrIQcLIAFBCGohASADQQFqIQMgD0KAgICAEHwhDyAEQQhrIgQNAQwCCwsgASAHNgIAIAMgCE8NACAPIRALIAIgEDcCLCACIAY2AigMAQtBCEEEEK02IgFFDQQgAUEAOgAEIAEgCCAHIAcgCEsbNgIAIAJBATYCWCACIAE2AlAgAiABQQhqNgJcIAIgATYCVCACQShqIAJB0ABqEOcMCyACQRBqIAJBMGooAgA2AgAgAiACKQIoNwMICyAAIAIpAwg3AgAgAEEIaiACQRBqKQMANwIAIAJB4ABqJAAPCyAEIAIoAlhB3ILNABD9LwALQQRBEBCjPQALQQRBCBCjPQAL3AoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQMgAkEQaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoAkAgA0UEQCACQgA3AjQgAigCEA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgI4IAIgAzYCNCACKAIQRQ0ECyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinaiIEQQJ0aioCACILOAKAASALQwAAgL9eRSALQwAAgENdRXJFBEAgBCAFaiAL/AE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQqAgAiCzgCsAEgC0MAAIC/XkUgC0MAAIBDXUVyDQIgASAFaiAL/AE6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL3AoDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAXQiBSEDAkACQCAAAn8CQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aisDACILOQN4IAtEAAAAAAAA8L9kRSALRAAAAAAAAPBAY0VyRQRAIAQgBUEBdGogC/wDOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYkMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQGNFcg0CIAQgC/wDOwEAIARBAmohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDhGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDNHSACQSBqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL2goDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQCAAAn8CQAJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aisDACILOQN4IAtEAAAgAAAA4MFkRSALRAAAAAAAAOBBY0VyRQRAIAQgBUECdGogC6o2AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKwMAIgs5A7ABIAtEAAAgAAAA4MFkRSALRAAAAAAAAOBBY0VyDQIgBCALqjYCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQvx0gAkEgahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGorAwAiCzkDeCALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQWNFckUEQCAEIAVBAnRqIAurNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGJDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAErAwAiCzkDsAEgC0QAAAAAAADwv2RFIAtEAAAAAAAA8EFjRXINAiAEIAurNgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDHHSACQSBqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGorAwAiCzkDeCALRAAAAAAgAODAZEUgC0QAAAAAAADgQGNFckUEQCAEIAVBAXRqIAv8AjsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGJDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAErAwAiCzkDsAEgC0QAAAAAIADgwGRFIAtEAAAAAAAA4EBjRXINAiAEIAv8AjsBACAEQQJqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ2h0gAkEgahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgASAKpyAIp2oiBEECdGoqAgAiCzgCgAEgC0MAAAHDXkUgC0MAAABDXUVyRQRAIAQgBWogC/wAOgAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYUMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKgIAIgs4ArABIAtDAAABw15FIAtDAAAAQ11Fcg0CIAEgBWogC/wAOgAAIARBBGohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9EKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAEgCqcgCKdqQQJ0IgVqKgIAIgs4AoABIAtDAACAv15FIAtDAACAT11FckUEQCAEIAVqIAupNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAACAv15FIAtDAACAT11Fcg0CIAQgC6k2AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDHHSACQShqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYUMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAvPCgMGfwN+AX0jAEHQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBjYCOCACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinakECdCIFaioCACILOAKAASALQwAAAM9gRSALQwAAAE9dRXJFBEAgBCAFaiALqDYCAAwBCwsgAkG4AWpBhIiQIDYCACACQoSIkKDAgIGCBDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAAAz2BFIAtDAAAAT11Fcg0CIAQgC6g2AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC/HSACQShqEM8vDAILIAJByAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC4sNAhV/AX4jAEGQAWsiAiQAIAJBGGogASgCYCIIQQhqIgMQhDwgAiACKAIcIgY2AiQgAUHgAGohBAJAAn8CQCABKAIwQYCAgIB4RwRAIAJB4ABqIAFBMGoiA0EIaigCACIKNgIAIAIgAykCADcDWCAKQQJ0IQVBACEDIAIoAlwhCQNAIAMgBUYNAiADIAlqIANBBGohAygCACAGSQ0ACyACIAMgCWpBBGs2AiggAkECNgJsIAJB4NbDADYCaCACQgI3AnQgAkE7NgJEIAJB3AE2AjwgAiACQThqNgJwIAIgAkEkajYCQCACIAJBKGo2AjggAEEMaiACQegAahCZDiAAQgM3AwAgAEEANgIIIAJB2ABqEOk7IAEQ+yUgASgCYCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBBCXFQsgASgCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUHkAGoQ+CMLAkAgASgCaCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQegAahDbHgsgAUE8ahCGMCABQcgAahCeLyABQdQAahCOMCABKAJwIgBFDQMgACAAKAIAIgBBAWs2AgAgAEEBRw0DIAFB8ABqEIEsDAMLIAJBEGogAxCEPCACQegAaiACKAIUQZDQwwAQijsgAigCcCEKIAIoAmwhCSAEKAIAIQggAigCaAwBCyACKAJYCyEOIAgoAgghDCABKAJsIQ0gAkGAAWoiAyABQRhqKQMANwMAIAJB+ABqIgQgAUEQaikDADcDACACQfAAaiIGIAFBCGopAwA3AwAgAiABKQMANwNoIAJB4ABqIgUgAUHQAGooAgA2AgAgASkCSCEXIAggCCgCACIHQQFqNgIAIAIgFzcDWAJAIAdBAE4EQCACQUBrIAYpAwA3AwAgAkHIAGogBCkDADcDACACQdAAaiADKQMANwMAIAJBMGogBSgCADYCACACIAIpA2g3AzggAiACKQNYNwMoIAEoAnQhDyABKAJwIRAgASgCLCERIAEoAighEiABKAIkIRMgASgCICEUAkACfyABKAJoIgcEQCAHLQAUQSBHDQIjAEEwayIEJAAgBCABQTxqNgIAIARBBGohBiMAQUBqIgMkACADIAQ2AgwgA0EANgIQIAdBGGoiBSgCBCELIAUoAgAhBSADIANBEGo2AhggAyADQQxqNgIUIAMgBUEIaiIFNgIwIAMgBSALQQJ0ajYCNCADIANBFGo2AjggA0EcaiADQTBqEIoXIANBIGohBQJAIAMoAhwiC0GTgICAeEcEQCAGIAMoAiw2AhAgBiAFKQIANwIEIAZBDGogBUEIaigCADYCAAwBCyADQThqIAVBCGooAgAiFTYCACADIAUpAgA3AzAgAyADKAI0IhYgFiAVQQJ0ahCbGCADKQMAIRcgBRD4JSADQTBqQQRBBBDgHiAGIBc3AgQLIAYgCzYCACADQUBrJAAgBCgCBEGTgICAeEcEQCAEQShqIARBFGooAgA2AgAgBEEgaiAEQQxqKQIANwMAIAQgBCkCBDcDGEGw0MMAQSsgBEEYakGg0MMAQdjPwwAQ1R4ACyACQQhqIAQpAgg3AwAgBEEwaiQAIAIoAgghAyACKAIMDAELIAIQwSwgAigCACEDIAIoAgQLIQQgAkHoAGoiBiADIAQQzhxBMEEIEK02IgNFDQIgA0KBgICAEDcDACADQQhqIAZBKPwKAAAgACACKQM4NwMAIABBCGogAkFAaykDADcDACAAQRBqIAJByABqKQMANwMAIABBGGogAkHQAGopAwA3AwAgAEE4aiACQTBqKAIANgIAIAAgAikDKDcDMCAAIAEpAjw3AoABIABBiAFqIAFBxABqKAIANgIAIAAgASkCVDcCjAEgAEGUAWogAUHcAGooAgA2AgAgASgCYCEEIAAgDCANIAwgDUkbNgKgASAAIAM2ApwBIAAgBDYCmAEgAEGBgICAeDYCYCAAIAo2AlwgAEEANgJYIAAgCTYCVCAAIA42AlAgACAPNgJIIAAgEDYCRCAAIAc2AkAgACAINgI8IAAgETYCLCAAIBI2AiggACATNgIkIAAgFDYCICABKAJkIgAgACgCACIAQQFrNgIAIABBAUcNAyABQeQAahD4IwwDCyACQQA2AnggAkEBNgJsIAJBuNfDADYCaCACQgQ3AnAgAkHoAGpBwNfDABDvLAsAC0EIQTAQoz0ACyACQZABaiQAC+QKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEDIAJBCGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCKCACIAQ2AiQgAkHAADYCIAJAIANFBEAgAkIANwIsIAIoAggNAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCMCACIAM2AiwgAigCCEUNBAsgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIEQQN0aisDACILOQN4IAtEAAAAAAAA8L9kRSALRAAAAAAAAHBAY0VyRQRAIAQgBWogC/wDOgAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYkMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQrAwAiCzkDsAEgC0QAAAAAAADwv2RFIAtEAAAAAAAAcEBjRXINAiABIAVqIAv8AzoAACAEQQhqIQQgAyABQQFqIgFHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDjGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDBHSACQSBqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL5AoDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKwMAIgs5A3ggC0QAAAAAACBgwGRFIAtEAAAAAAAAYEBjRXJFBEAgBCAFaiAL/AI6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCsDACILOQOwASALRAAAAAAAIGDAZEUgC0QAAAAAAABgQGNFcg0CIAEgBWogC/wCOgAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGJDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuICgIEfwZ+IwBB0ABrIgIkACACQUBrQgA3AwAgAkIANwM4IAIgACkDCCIGNwMwIAIgACkDACIHNwMoIAIgBkLzytHLp4zZsvQAhTcDICACIAZC7d6R85bM3LfkAIU3AxggAiAHQuHklfPW7Nm87ACFNwMQIAIgB0L1ys2D16zbt/MAhTcDCCACIAEoAgAiAC0AACIBNgJMIAJBCGogAkHMAGpBBBC7CQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQQ1rDhwAFBQBAgMEFAUUFBQUFAYHCAkKCwwNDg8QERITFAsgAiAALQABNgJMIAJBCGoiAyACQcwAaiIEQQQQuwkgAiAAKAIEIgFBAEc2AkwgAyAEQQQQuwkgAUUNEyADIAFBCGogACgCCBC7CSACQf8BOgBMIAMgBEEBELsJDBMLIAIgAC0AATYCTCACQQhqIAJBzABqQQQQuwkMEgsgAiAALQABNgJMIAJBCGogAkHMAGpBBBC7CQwRCyACIAAtAAE2AkwgAkEIaiACQcwAakEEELsJDBALIAIgAC0AATYCTCACQQhqIAJBzABqQQQQuwkMDwsgAiAAKAIENgJMIAJBCGogAkHMAGpBBBC7CQwOCyAAKAIEQQhqIAJBCGoQ2QoMDQsgACgCBEEIaiACQQhqENkKDAwLIAAoAghBCGogAkEIaiIBENkKIAIgACgCBDYCTCABIAJBzABqQQQQuwkMCwsgACgCBEEIaiACQQhqENkKDAoLIAAoAgRBCGogAkEIahDZCgwJCyAAQQRqIAJBCGoQ2iAMCAsgACgCBCACIAAoAggiBDYCTCACQQhqIgMgAkHMAGoiBUEEELsJQQhqIAQgAxDQIyACIAAtAAE2AkwgAyAFQQQQuwkMBwsgACgCBCACQQhqIgEQkwkgACgCCCABEJMJDAYLIAIgAC0AAToATCACQQhqIgEgAkHMAGoiA0EBELsJIAIgAC0AAjoATCABIANBARC7CQwFCyACIAAtAAE6AEwgAkEIaiIBIAJBzABqIgNBARC7CSACIAAtAAI6AEwgASADQQEQuwkMBAsgAiAALQABOgBMIAJBCGoiASACQcwAaiIDQQEQuwkgAiAALQACOgBMIAEgA0EBELsJDAMLIAIgAC0AAToATCACQQhqIgEgAkHMAGoiA0EBELsJIAIgAC0AAjoATCABIANBARC7CQwCCyAAKAIEQQhqIAJBCGoiARDZCiACIAAtAAE6AEwgASACQcwAakEBELsJDAELIAAoAgRBCGogAkEIaiIBENkKIAAoAghBCGogARDZCgsgAikDCCEHIAIpAxghBiACNQJAIQogAikDOCEIIAIpAyAgAikDECELIAJB0ABqJAAgCCAKQjiGhCIKhSIIQhCJIAggC3wiCIUiCUIViSAJIAYgB3wiB0IgiXwiCYUiC0IQiSALIAggBkINiSAHhSIGfCIHQiCJQv8BhXwiCIUiC0IViSALIAcgBkIRiYUiBiAJIAqFfCIHQiCJfCIKhSIJQhCJIAkgByAGQg2JhSIGIAh8IgdCIIl8IgiFIglCFYkgCSAHIAZCEYmFIgYgCnwiB0IgiXwiCoUiCUIQiSAJIAZCDYkgB4UiBiAIfCIHQiCJfCIIhUIViSAGQhGJIAeFIgZCDYkgBiAKfIUiBkIRiYUgBiAIfCIGQiCJhSAGhQu3CgIFfwR+IwBB8AFrIgMkACABQQxqENg8IQcgA0EwaiABEJI2EO4lIAdBA3QiBiEEAkACQAJ+AkACQAJAAkAgBkE4cSIFBEAgBiAFa0FAayIEIAZJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAyAFNgJQIAMgBDYCTCADQcAANgJIIAYEQCAFQQAgBvwLAAsgAyAHNgJYIAMgBjYCVCADKAIwRQ0DIAMoAkQgAygCQEYNBCADQegAaiADQTBqEMg0IANBiAFqIQQgAikDACEKIAEoAhAhASADKQOQASEJA0ACQCAJUEUEQCADKQOYASEIDAELA0ACfgJAIAMpA3giCEIDUgRAAkACQAJAIAhCAlENACADIAhQrUIBhjcDeCAIp0EBcUUNACADIAMpA4ABNwPIAQwBCyADKAKIAUUNASADQcABaiAEELYqIAMpA8ABIQgLIAhCAFINAgsgA0IDNwN4CyADKQNoIghCAlENCSADQgA3A2ggAykDcAwBCyADKQPIAQshCSAIp0EBcUUNByADIAMpA5gBQkB9Igg3A5gBIAMgCTcDkAEgCVANAAsLIANCASAJeiILhiAJhSIJNwOQASABIAunIAinakEDdCICaikDACEIIAMgCjcD6AEgAyAINwOgASADQSBqIAggCEI/hyAKIApCP4cQqB4gAykDKCADKQMgIghCP4dRBEAgAiAFaiAINwMADAELCyADQQI2AsQBIANBrJD/ADYCwAEgA0ICNwLMASADQYYMNgLkASADQYYMNgLcASADIANB2AFqNgLIASADIANB6AFqNgLgASADIANBoAFqNgLYASADQbABaiADQcABahCZDiADKQK4ASEJIAMpArABDAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIpAwAhCSABKAIQIQFBACEEA0AgASkDACEIIAMgCTcD2AEgAyAINwPoASADQRBqIAggCEI/hyAJIAlCP4cQqB4gAykDGCADKQMQIghCP4dSDQIgBSAINwMAIAVBCGohBSABQQhqIQEgByAEQQFqIgRHDQALCyADQegAaiICEJcpIANB0ABqIgEoAgAhBiADKAJUIQQgASADQfAAaiIFKQIANwMAIAMpA0ghCSADIAMpAmg3A0ggA0EANgJYIAMgCTcCdCADQQA2AnAgAyAENgJsIAMgBjYCaCADQQhqIAIQ1zsgAygCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASADKQJoNwIIIAFBEGogBSkCADcCACABQRhqIANB+ABqIgcoAgA2AgAgAyAENgLIASADIAY2AsQBIAMgATYCwAEgA0HcAGoiASADQcABahDkGSAHIANBQGspAgA3AwAgBSADQThqKQIANwMAIAMgAykCMDcDaCAAIAEgAhDWHSADQcgAahDPLwwCCyADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYYMNgK4ASADQYYMNgKwASADIANBrAFqNgJwIAMgA0HYAWo2ArQBIAMgA0HoAWo2AqwBIANBxAFqIANB6ABqEJkOIAMpAswBIQkgAykCxAELIQggACAJNwIQIAAgCDcCCCAAQYiAgIB4NgIEIABBKToAACADQcgAahDPLyADKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBMGoQ+x4LIANB8AFqJAAPC0EEQRwQoz0AC54LAhN/A34jAEEgayIMJAAgCygCCCEPIAtCADcDCAJAIAQgB3EiFyADTQRAIAspAwAhICAAKAJEIRogAyAXayESIAIgF2ohFAJAIAAoAiAiE0UNAANAQRAgDSANQRBNGyEVIA8gFGohGCAGIA1BAnRqIRAgDyAXaiAESyEZA0ACQAJAIA0gFUcEQCAQKAIAIhYgCUsNAiAHIBZrIg4gB08gGXINAiAEIA5xIg4gD2oiESAETQ0BDAILIBVBEEG81c4AEMMhAAsCQAJAAkACQAJAIA8gEkkEQCADIBFNDQEgGC0AACACIBFqLQAARw0GIAMgDkkNAiACIA5qIAMgDmsgFCASIAgQsiAiEEECTSAQQQJHIA1BAUtycQ0FICAgECAOIAUQoS4iDiAaEPI0Ih9aDQUgDQ0DDAQLIA8gEkHM1c4AEMMhAAsgESADQdzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHs1c4AEO8sAAsgHyANEP8wfSEfCyAfICBYDQAgCyAWNgIQIAsgDjYCCCALIB83AwBBASEbIA4hDyAfISALIA1BAWoiDSATSQ0CDAMLIBBBBGohECANQQFqIg0gE0kNAAsLCyAANQI0IR8gFCASEO8gISECQAJAIAAoAgQiDiAhIB+IpyIGSwRAIAAoAgwiDSAGIAAoAkAiEHQiDkkNAkEBIBB0IhAgDSAOa0sNASAAKAI8IhUgEEkEQCAAKAIIIA5BAnRqIRggACgCACAGQQF0aiIZLwEAIgZFBEBBACEGDAYLIAYgEGsiDkEAIA5BAEobIRwgBiEOA0AgDyAUaiEdIA8gF2ogBEshHiAOIQ0CQAJAAkACQANAIA0gHE0NCyAQIA1BAWsiDiAVcSIRSwRAIAcgGCARQQJ0aigCACITayERAkAgHg0AIAQgE3EiEyAPaiIWIARLDQAgDyASTw0DIAMgFk0NBCAdLQAAIAIgFmotAABHDQAgCSARSQ0NIAMgE0kNBSACIBNqIAMgE2sgFCASIAgQ9AEiDUUNBiAgIA0gEyAFEKEuIg0gESAaEIwtIh9aDQYgCyARNgIQIAsgDTYCCCALIB83AwBBASEbIA0hDyAfISAMBgsgDUEBayENIAkgEUkNDAwBCwsgESAQQezUzgAQwyEACyAPIBJB/NTOABDDIQALIBYgA0GM1c4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBnNXOABDvLAALIAAoAjwhFQwACwALQZDUzgBBygBB3NTOABCfKQALIAYgDkHg084AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQfDTzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHQ084AEO8sAAsCfwJAIBAgBiAVcSICSwRAIBggAkECdGogBzYCACAZIBkvAQBBAWo7AQBBASAbDQIaIAENAUEADAILIAIgEEGs1c4AEMMhAAsgASECQQAhAUEAIQcgACgCMCIPIAAoAiwiA0EHdk8EQCAAKAJEIQ5BgIACIBQgEhDKICIGQQF0IgRrIgVBACAFQYCAAk0bIQ0gA0EBaiEFIAZBAnRBmJvSAGohBgNAAkAgDSABIgNHBEAgACAFNgIsIAYvAQAiAUUNASACIAEgFCASIAggCSAKIA4gCxDEEkUNAUEBIQcgACAPQQFqIg82AjAMAQsgBEGAgAJBhOLOABDDIQALQQEhASAFQQFqIQUgBkECaiEGIARBAWohBCADQQFxRQ0ACwsgBwsgDEEgaiQAC80KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAXRqLwEAIgE7AYIBIAFBgAFqQf//A3FB/wFNBEAgBSAGaiABOgAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAELwEAIgY7AbABIAZBgAFqQf//A3FB/wFLDQIgASAFaiAGOgAAIARBAmohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBigw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9UJAgh/An4jAEHQAGsiAyQAAkAgAi0ADCIFQQFGBEAgACABKQIANwIAIABBCGogAUEIaikCADcCACACQQRBBBDgHgwBCwJAAkACQAJAAkACQAJAAkACQAJAIAEtAAwiBkEBaw4CAAIBCyAAIAIpAgA3AgAgAEEIaiACQQhqKQIANwIADAQLIAVFDQEMAgsgBUUNAQsgA0EoaiABQQhqIgQoAgA2AgAgAyABKQIAIgs3AyAgA0E4aiACQQhqIgUoAgA2AgAgAyACKQIAIgw3AzACfyALpyAMp0kEQCADQcgAaiAFKAIANgIAIAMgAikCADcDQCADQRRqIANBQGsgA0EgaiIBEO0IIAEMAQsgA0HIAGogBCgCADYCACADIAEpAgA3A0AgA0EUaiADQUBrIANBMGoiARDtCCABCyIEQQRBBBDgHiAGQQFHBEAgBkEBIAMoAhwbIQQMBgsgA0EANgIcIANBFGpBBEEEEJ4kIAMoAhwiAUUNBCADKAIYIgIgAUECdCIFakEEayIERQ0EIAQoAgANBCAFIQQgAkEEayEGIAFB/////wNxIQICQANAIARFBEBBACEEDAILIAJBAWshAiAEIAZqIARBBGshBCgCAEUNAAsgAkEBaiIEIAFLDQULIAMgBDYCHCAEIQEMBAsCQAJAAkACfyABKAIIIgQgAigCCCIHRwRAIAQgB0sgBCAHSWsMAQsgBEECdCEEIAEoAgRBBGshCSACKAIEQQRrIQoCQANAIARFDQEgBCAKaiEIIAQgCWogBEEEayEEKAIAIgcgCCgCACIIRg0ACyAHIAhLIAcgCElrDAELQX9BACAEGwtB/wFxDgIBAgALIANByABqIgQgAkEIaigCADYCACADIAIpAgA3A0AgA0FAayABEO8UIAQoAgAhAiADKQNAIQsgAUEEQQQQ4B4gACAFQQEgAhs6AAwgACACNgIIIAAgCzcCAAwHCyAAQQhqQZSKiAEpAgA3AgAgAEGMiogBKQIANwIAIAJBBEEEEOAeDAELIANByABqIgQgAUEIaigCADYCACADIAEpAgA3A0AgA0FAayACEO8UIANBOGogBCgCADYCACADIAMpA0A3AzAgAkEEQQQQ4B4gBkEBRwRAIAZBASADKAI4GyEEDAMLIANBADYCOCADQTBqQQRBBBCeJCADKAI4IgFFDQEgAygCNCICIAFBAnQiBWpBBGsiBEUNASAEKAIADQEgBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0CCyADIAQ2AjggBCEBDAELIAFBBEEEEOAeDAQLQQEhBCABIAMoAjBBAnZPDQAgA0EIaiADQTBqIAFBBEEEEPQUIAMoAggiAUGBgICAeEYNACABIAMoAgxBzI2IARD9LwALIAAgAykDMDcCACAAIAQ6AAwgAEEIaiADQThqKAIANgIADAILQQEhBCABIAMoAhRBAnZPDQAgAyADQRRqIAFBBEEEEPQUIAMoAgAiAUGBgICAeEYNACABIAMoAgRBzI2IARD9LwALIAAgAykCFDcCACAAIAQ6AAwgAEEIaiADQRxqKAIANgIACyADQdAAaiQAC70KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIDIQQCQAJAIAACfwJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiAEIAqnIAinaiIGQQF0ai4BACIBOwGCASABQQBOBEAgBSAGQQJ0aiABQf//A3E2AgAMAQsLIAJBuAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQKMATcCDCAAQRRqIAJBlAFqKAIANgIAIAIoAogBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMuAQAiBDsBsAEgBEEASA0CIAUgBEH//wNxNgIAIAVBBGohBSADQQJqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQxx0gAkEoahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALvwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E+cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFBgIACakH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEGAgAJqQf//A0sNAiAFIAQ7AQAgBUECaiEFIANBBGohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDaHSACQShqEM8vDAILIAJByAFqQYOGjBg2AgAgAkKDhoyYsODAgQM3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBggw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7UOAhJ/AX4jAEFAaiIHJAAgAEEBNgLcBSAAQbgBaiABQawB/AoAACAAQYwCaiEBIAAoAowCQQFGBEAgASAAQbwBaigCACIGNgIUIAEoAgxFBEAgAUHAADYCDAsgASgCBCIFRQRAIAFBBiAGQQdrIgUgBUEGTRsiBTYCBAsgASgCCCEIIAEoAhBFBEAgASAGIAVrIgtBACAGIAtPGzYCEAsgASAIQQMgCBsiBiAFIAUgBksbNgIIC0EBIQkgACgC3AIiBkIBIAA1ArwBhiIXIAIgAiAXVhunIgVBASAFGyIFIAUgBksbIghBA0EDQQQgACgC2AIbIAAoAswBQQNGG24hCyAAKAKsAkUEQCAIEOcpQQFqIQ0LQQAgBSAIaiAAKAKoAhshDyAAQbwBaiEGIAdBKGogAUEQaikCADcDACAHQSBqIAFBCGopAgA3AwAgByABKQIANwMYIAdBGGogCBDaLiEQAkAgA0H/////BUsNACAAKADYECAAKADcEGtBgICA+HlLDQAgACgC4AVFIQkLIAAoAsgFQQBHIREgACgCvAIhCiAAKALYAiEOIAAoAtwCIQUjAEEwayIDJAAgBigCECESIAY1AgAhFyAGIApBAEEBEPgVIRMgA0EoaiABQRBqIhQpAgA3AwAgA0EgaiABQQhqIhUpAgA3AwAgAyABKQIANwMYQQEgA0EYaiIKKAIEIgwgCigCCGsiFkEAIAwgFk8bdEEIIAx0akEAIAooAgBBAUYbIQogA0EQaiAUKQIANwMAIANBCGogFSkCADcDACADIAEpAgA3AwAgAyAFQYCACCAFGyIFQQFCASAXhiIXIAIgAiAXVhunIAJQGyIMIAUgDEkbIgUQ2i4hDCABKAIAIQEgA0EwaiQAAkAgCiATIA9BiKsBQcCNASARG2ogDWogBUEDQQNBBCASQQNGGyAOG24iA0EDbGpqaiADQQN0QT9qQUBxaiAFaiAMQQxsQT9qQUBxQQAgAUEBRhtqIAVBA25BBHRBzwBqQUBxQQAgDhtqQSBqIgNBiH9LBEAgAyEBDAELIAAoAsgFIg5FBEAgACAAKAK4BEEBajYCuAQLIABBmARqIQUgACgCrAQgACgCpARrIANBA2xPBH8gACgCuARBgAFKBUEAC0UgAyAAKAKcBCAAKAKYBCIKa01xRQRAQUAhASAODQEgB0E4aiIJIABBwAVqKAAANgIAIAcgACkAuAU3AzAgBUEAQSz8CwAgB0EQaiAJKAIANgIAIAcgBykDMDcDCCAKIAdBCGoQiy0CfyAAKAC4BSIJBEAgACgAwAUgAyAJEQIADAELIAMQhi8LIglFDQEgBSAJIAMQyyggACAFQfQjENcnIgM2AtAQIANFDQEgACAFQfQjENcnIgM2AtQQIANFDQEgACAFQdjFABDXJyIDNgK4EkEBIQkgA0UNAQsgBRCELCAAQgA3A9AEIAAgAkIBfCICNwPIBCAAQdgEakIANwMAIABBqBJqIAZBGGooAgA2AgAgAEGgEmogBkEQaikCADcCACAAQZgSaiAGQQhqKQIANwIAIAAgBikCADcCkBIgACAAKALQAkEBRjYCsBIgAlAEQCAAQQA2AtgBCyAAIAg2AsQEIABB4ARqQQBB2AD8CwAgAEIANwOQBCAAQQE2AgAgAEL56tDQ58mh5OEANwOABSAAQs/W077Sx6vZQjcD8AQgAELW64Lu6v2J9eAANwPoBCAAKALQECIBQQg2AvAjIAFCgYCAgMAANwLoIyABQQA2AuQjIAFCADcC3CMgAUEANgKECCAAQdgQaiAFIAYgACgCvAIgBCAJQQEQ8AgiAUGIf0sNACAAIAUgC0EDdBDVNTYC5AUgACgCjAJBAUYEQCAAIAVBCCAAKAKQAnQiARDVNSIDNgKoBiABBEAgA0EAIAH8CwALIAUgEEEMbBDVNSEBIAAgEDYCuBAgACABNgK0ECAAQoKAgIAgNwKcBiAAQcu0wgA2ApgGIABBy7TCADYClAYgAEEANgKsBiAAQQA2AqQGIABBzbTCADYCkAYLIAAoAtgCBEAgACAIQQNuQQFqIgE2AsAdIAAgBSABQQR0ENU1NgK8HQsgBSAIQSBqEJA8IQEgACAPNgLEEiAAQQE2ArwSIAAgCDYChAYgACABNgLsBSAFIA8QkDwhASAAIA02AtgSIAAgATYCwBIgACAFIA0QkDw2AtQSAkAgACgCjAJBAUcNACAAIAVBASAAKAKQAiAAKAKUAmt0IgEQkDwiAzYCsAYgAUUNACADQQAgAfwLAAtBACEBAkAgACgCAEEBRw0AIAAoAowCQQFGDQAgAEEANgLMECAAQQA2AsgQIABBADYCvBAgAEIANwLAEAsgACALNgKABiAAIAUgCxCQPDYC9AUgACAFIAsQkDw2AvgFIAUgCxCQPCEDIABBATYC4AUgACADNgL8BQsgB0FAayQAIAELtwoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQoCAAnxC//8DWARAIAQgBUEBdGogCD0BAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGGDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEKAgAJ8Qv//A1YNAiAEIAg9AQAgBEECaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOEZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENodIAJBIGoQzy8MAgsgAkHIAWpBg4aMGDYCACACQoOGjJiw4MCBAzcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAvBCQIHfwN+IwBBkAFrIgIkACABQQxqENk8IQcgAkEQaiABEJI2EO4lIAdBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgZFDQELIAIgBjYCMCACIAM2AiwgAkHAADYCKCAEBEAgBkEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQUgASgCECEHIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBRC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcAJ/IAcgC6cgCadqIghBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQEgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQiA0GAgID8B3IgAUUNARogAyABQQ10ckGAgID+B3IMAQsgBEEQdCIEIANBDXRBgICA/ABxIAFBDXRyQYCAgMADanIgAw0AGiABIAFnQRBrIgFB//8DcUEIanRB////A3EgBEGAgIDYA3IgAUEXdGtyCyEBIAYgCEECdGogATYCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAEoAhAhA0EAIQEDQCAGAn8gAy8BACIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSEEIAVBgIACcSEIIAVBgPgBcSIFQYD4AUYEQCAIQRB0IgVBgICA/AdyIARFDQEaIAUgBEENdHJBgICA/gdyDAELIAhBEHQiCCAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAUNABogBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIARBF3Rrcgs2AgAgBkEEaiEGIANBAmohAyAHIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiBCkCADcDACACKQMoIQkgAiACKQJINwMoIAJBADYCOCACIAk3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiADENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALvwoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQoCAgIAIfEL/////D1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhgw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhCgICAgAh8Qv////8PVg0CIAQgCD4CACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQvx0gAkEgahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC8MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2zwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFBgAFqQf8BTQRAIAUgBmogAToAAAwBCwsgAkG4AWpBgoSIEDYCACACQoKEiJCgwICBAjcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGCDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikAiQE3AAkgAEEQaiACQZABaikAADcAACACLQCIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCgCACIGNgKwASAGQYABakH/AUsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGCDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALtAoCBn8DfiMAQdABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZBAnRqIAFB/wFxNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGBDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgwFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQRBACEBA0AgAiABIARqLAAAIgM6ALABIANBAEgNAiAFIANB/wFxNgIAIAVBBGohBSAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDHHSACQShqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYEMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wNLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQzR0gAkEoahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYIMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYwMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wNLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQzR0gAkEoahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wFNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYwMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wFLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQ2h0gAkEoahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu7CgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKQMAIgg3A3ggCEKAAXxC/wFYBEAgBCAFaiAIPAAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQpAwAiCDcDsAEgCEKAAXxC/wFWDQIgASAFaiAIPAAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAv5CAIFfwN+AkACQAJAIAFBCE8EQCABQQdxIgJFDQEgACgCoAEiA0EpTw0CIANFBEAgAEEANgKgAQwCCyADQQFrQf////8DcSIFQQFqIgRBA3EhBiACQQJ0QbjpiQFqKAIAIAJ2rSEJAkAgBUEDSQRAIAAhAgwBCyAEQfz///8HcSEFIAAhAgNAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgAgCX4gB0IgiHwiBz4CACACQQxqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAdCIIghCCACQRBqIQIgBUEEayIFDQALCyAGBEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEIIAZBAWsiBg0ACwsgACAHQoCAgIAQWgR/IANBKEYNBCAAIANBAnRqIAg+AgAgA0EBagUgAws2AqABDAELIAAoAqABIgNBKU8NASADRQRAIABBADYCoAEPCyABQQJ0QbjpiQFqNQIAIQkgA0EBa0H/////A3EiAUEBaiICQQNxIQYCQCABQQNJBEAgACECDAELIAJB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIBIAE1AgAgCX4gB0IgiHwiBz4CACACQQhqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBDGoiASABNQIAIAl+IAdCIIh8Igc+AgAgB0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAHQiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0DIAAgA0ECdGogCD4CACADQQFqBSADCzYCoAEPCwJAIAFBCHEEQCAAKAKgASIDQSlPDQICQCADRQRAQQAhAwwBCyADQQFrQf////8DcSICQQFqIgVBA3EhBgJAIAJBA0kEQEIAIQcgACECDAELIAVB/P///wdxIQVCACEHIAAhAgNAIAIgAjUCAELh6xd+IAd8Igc+AgAgAkEEaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBCGoiBCAENQIAQuHrF34gB0IgiHwiBz4CACACQQxqIgQgBDUCAELh6xd+IAdCIIh8Igg+AgAgCEIgiCEHIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCAELh6xd+IAd8Igg+AgAgAkEEaiECIAhCIIghByAGQQFrIgYNAAsLIAhCgICAgBBUDQAgA0EoRg0CIAAgA0ECdGogBz4CACADQQFqIQMLIAAgAzYCoAELIAFBEHEEQCAAQYzXiQFBAhC2CAsgAUEgcQRAIABBlNeJAUEDELYICyABQcAAcQRAIABBoNeJAUEFELYICyABQYABcQRAIABBtNeJAUEKELYICyABQYACcQRAIABB3NeJAUETELYICyAAIAEQtgYaDwsMAQsgA0EoQZCMigEQsDsAC0EoQShBkIyKARDDIQALtQoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJ+AkACQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAEgCqcgCadqIgVBAnRqKgIAIgs4AoABIAtDAAAA32BFIAtDAAAAX11FckUEQCAEIAVBA3RqIAuuNwMADAELCyACQbgBakGFipQoNgIAIAJChYqUqNCgwYIFNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYUMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAAA32BFIAtDAAAAX11Fcg0CIAQgC643AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDWHSACQShqEM8vDAILIAJByAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAIpAqQBIQggAikCnAELIQkgACAINwIQIAAgCTcCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALtwoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJ+AkACQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAEgCqcgCadqIgVBAnRqKgIAIgs4AoABIAtDAACAv15FIAtDAACAX11FckUEQCAEIAVBA3RqIAuvNwMADAELCyACQbgBakGJkqTIADYCACACQomSpMiQocKECTcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAIpApABIQggAikCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASoCACILOAKwASALQwAAgL9eRSALQwAAgF9dRXINAiAEIAuvNwMAIARBCGohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2R0gAkEoahDPLwwCCyACQcgBakGJkqTIADYCACACQomSpMiQocKECTcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu7CwIHfwF+IwBBkAVrIgIkAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgAC0AuAFBAWsOAwcCAQALIABB2ABqIABB2AD8CgAACyAAQdgAaiEEAkACQCAALQCoAUEBaw4DBAIBAAsgAkEoaiAAKAKgASAAKAKkARD6KCACQegAaiACKAIoIAIoAiwQjzUgBCACQTBqQcQA/AoAACAAQQA6AJwBDAcLAkAgAC0AnAFBAWsOAwUBAAcLIABB8ABqIQcgAEGMAWohBQJAIAAtAIwBQQFrDgMEAQACCyAAKAKIASEGIAAoAoQBIQMMCAsACyAAKQNwIQkgACgCeAwFC0Gc3MIAEOgrAAtB9NbCABDoKwALQYzcwgAQ6CsAC0HcyMIAEOgrAAsgAkGwAWoiAyAAQZgBaigCADYCACACIAApApABNwOoASAAEOgmNgJsIABBADoAjAEgACAENgJ4IABCADcDcCAAQoCAwAA3A1ggAEHoAGogAygCADYCACAAIAIpA6gBNwJgIABBjAFqIQUgAEHwAGohByAECyEDIAAgCTcCfCACQQA6AIwFIAIgAzYCiAUgAkEgaiEDIAJBoAJqIQgCQEHwAkEIEK02IgYEQCAGIAhB8AL8CgAAIANB3N3CADYCBCADIAY2AgAMAQtBCEHwAhCjPQALIAIoAiAhAyAAIAIoAiQiBjYCiAEgACADNgKEAQsgAkGgAmogAyABIAYoAgwRAQACQAJAIAIoAqACIgFBCUYEQCAFQQM6AAAMAQsgAkGAAmoiBiACQbACaikDADcDACACIAIpA6gCNwP4ASACKAKkAiEDIABBhAFqELwqAkAgAUEIRwRAIAJBmAJqIAYpAwA3AwAgAiACKQP4ATcDkAIgAiADNgKMAiACIAE2AogCIAAoAnwiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEH8AGoQ+CMMAQsgAiAAKQJ8NwOgAiACQYgCaiADIAJBoAJqEO0BCyACQcABaiIDIAJBlAJqKAIANgIAIAIgAikCjAI3A7gBIAIpA5gCIQkgAigCiAIhASAFQQE6AAAgAUEJRg0AIAJB0AFqIgUgAygCADYCACACIAIpA7gBNwPIASAHEN8gAn4gAUEIRwRAIAJBrAJqIAUoAgA2AgAgAiACKQPIATcCpAIgAiAJNwOwAiACIAE2AqACIAJBoAJqENIZIQEgBBC9KkICDAELIAJB4AFqIABB5ABqKQIANwMAIAJB6AFqIABB7ABqKAIANgIAIAJB9AFqIAJB0AFqKAIANgIAIAIgAikDyAE3AuwBIAIgACkCXDcD2AEgACgCWCEBQgELIQlBASEDIABBAToAnAEgAkGMAWogAkHgAWopAwA3AgAgAkGUAWogAkHoAWopAwA3AgAgAkGcAWogAkHwAWopAwA3AgAgAiABNgKAASACIAk3A3ggAiACKQPYATcChAEgBBCrLCACQRhqIAJB+ABqEPUfIAIoAhwhBCACKAIYIQUgAEEBOgCoAUEDIQEgBUECRg0BAkAgBUEBcQRAIAIgBDYCMCACQYABNgKgAiACQQhqIABBtAFqIAJBoAJqIAJBMGoQwiMgAigCCCACKAIMENYvIgFBhAFPBEAgARDyHwsgAigCoAIiAUGEAU8EQCABEPIfCyACKAIwIgFBhAFJDQEgARDyHwwBCyACIAQ2AjAgAkGAATYCoAIgAkEQaiAAQbABaiACQaACaiACQTBqEMIjIAIoAhAgAigCFBDWLyIBQYQBTwRAIAEQ8h8LIAIoAqACIgFBhAFPBEAgARDyHwsgAigCMCIBQYQBSQ0AIAEQ8h8LIAAoArABIgFBhAFPBEAgARDyHwtBASEBQQAhAyAAKAK0ASIEQYQBSQ0BIAQQ8h8MAQtBAyEBIABBAzoAnAEgAEEDOgCoAUEBIQMLIAAgAToAuAEgAkGQBWokACADC7MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL/////D1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQKMATcCDCAAQRRqIAJBlAFqKAIANgIAIAIoAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQv////8PVg0CIAQgCD4CACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQxx0gAkEgahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuuCgIGfwN+IwBB0AFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2pBAXQiBmouAQAiATsBggEgAUEATgRAIAUgBmogATsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGIDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBggFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgAiADLgEAIgQ7AbABIARBAEgNAiAFIAQ7AQAgBUECaiEFIANBAmohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDaHSACQShqEM8vDAILIAJByAFqQYOGjBg2AgAgAkKDhoyYsODAgQM3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBiAw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC64KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQQCQAJAIAACfwJAAkACQAJAIANBPnEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiAEIAqnIAinakEBdCIGai4BACIBOwGCASABQQBOBEAgBSAGaiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMuAQAiBDsBsAEgBEEASA0CIAUgBDsBACAFQQJqIQUgA0ECaiEDIAYgAUEBaiIBRw0ACwsgAkHIAGoiBRCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIEKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAUQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOEZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAFEM0dIAJBKGoQzy8MAgsgAkHIAWpBh46cODYCACACQoeOnLjw4MGDBzcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALswoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQv////8PWARAIAQgBUECdGogCD4CAAwBCwsgAkG4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC/////w9WDQIgBCAIPgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDHHSACQSBqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYsMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7sKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2zwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFB/wFNBEAgBSAGaiABOgAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKAIAIgY2ArABIAZB/wFLDQIgASAFaiAGOgAAIARBBGohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDBHSACQShqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBggw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7EKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL/////B1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC/////wdWDQIgBCAIPgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxC/HSACQSBqEM8vDAILIAJByAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBigw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AUsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALrQoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQv//A1gEQCAEIAVBAXRqIAg9AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhgw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC//8DVg0CIAQgCD0BACAEQQJqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQzR0gAkEgahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC60KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPnEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL//wFYBEAgBCAFQQF0aiAIPQEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYsMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQv//AVYNAiAEIAg9AQAgBEECaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOEZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENodIAJBIGoQzy8MAgsgAkHIAWpBg4aMGDYCACACQoOGjJiw4MCBAzcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGLDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAutCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAXQiBSEDAkACQCAAAn8CQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aikDACIINwN4IAhC//8DWARAIAQgBUEBdGogCD0BAAwBCwsgAkG4AWpBh46cODYCACACQoeOnLjw4MGDBzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGLDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEL//wNWDQIgBCAIPQEAIARBAmohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDhGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDNHSACQSBqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQoAgAiBjYCsAEgBkH/AUsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGMDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH/AE0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQoAgAiBjYCsAEgBkH/AEsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGMDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AUsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGIDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALrgoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqQQJ0IgZqKAIAIgE2AoABIAFBAE4EQCAFIAZqIAE2AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAIgAygCACIENgKwASAEQQBIDQIgBSAENgIAIAVBBGohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQvx0gAkEoahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAuwCgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAnQiAyEEAkACQCAAAn8CQAJAAkACQCADQTxxIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2pBAnQiBmooAgAiATYCgAEgAUEATgRAIAUgBmogATYCAAwBCwsgAkG4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBggw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAIgAygCACIENgKwASAEQQBIDQIgBSAENgIAIAVBBGohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQxx0gAkEoahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGCDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AE0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AEsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGIDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALqQoCA38BfiMAQTBrIgMkACADQRBqIgRCADcDACADQRhqIgVCADcDACADQQhqIgYgAkEIaikCADcDACADIAIpAgA3AwAgAUEcaiABKAIUIAFBGGoiAigCACABKAIQKAIQEQEAIAFBKGogBSkDADcDACABQSBqIAQpAwA3AwAgAiAGKQMANwMAIAEgAykDADcDECABQQE6AGggAyABQRBqIgIQpRgCQAJAAkACQAJAIAMoAgBFBEAgA0EmQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQQgAygCCCICQbDBzgBBJvwKAAAgACACrUKAgICA4ASENwMIIAAgATYCBCAAQQI2AgAMAwsgAygCDARAIANBFEEAQQFBARCgGCADKAIEIQIgAygCAEEBRg0FIAMoAggiAUEQakHmwc4AKAAANgAAIAFBCGpB3sHOACkAADcAACABQdbBzgApAAA3AAAgAEEUNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAMLIAEgAygCCDYCTCADIAIQpRggAygCAEUEQCADQTFBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNBCADKAIIIgJB6sHOAEEx/AoAACAAIAKtQoCAgICQBoQ3AwggACABNgIEIABBAjYCAAwDCyADKAIMBEAgA0EfQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQUgAygCCCIBQRdqQbLCzgApAAA3AAAgAUEQakGrws4AKQAANwAAIAFBCGpBo8LOACkAADcAACABQZvCzgApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAMLIAEgAygCCDYCVCADIAIQpRggAygCAEUEQCADQSdBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNBCADKAIIIgJBusLOAEEn/AoAACAAIAKtQoCAgIDwBIQ3AwggACABNgIEIABBAjYCAAwDCyADKAIMBEAgA0EVQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQUgAygCCCIBQQ1qQe7CzgApAAA3AAAgAUEIakHpws4AKQAANwAAIAFB4cLOACkAADcAACAAQRU2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAwsgASADKAIINgJQIANBIGogAhCFJiADIAMpAyAgAykDKBCsGiADKAIAIgJBCEcEQCADKAIEIQEgAykDCCEHIAAgAykDEDcDECAAIAc3AwggACABNgIEIAAgAjYCAAwDCyABQcwAaiECIAEgAykDCDcDCCABQgE3AwAgASgCTCIEQf8AcQ0AIAFB1ABqIgYoAgAiBUUNASAEIAQgBW4iBCAFbEcEQCADQQI2AgQgA0HswM4ANgIAIANCAjcCDCADQTs2AiwgAyAGNgIoIANBOzYCJCADIAI2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAwsgASAENgJYIAFCADcDYCABQQA2AkggBEEfcUUEQCAAQQg2AgAMAwsgA0EBNgIEIANBoMDOADYCACADQgE3AgwgA0E7NgIkIAMgAUHYAGo2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAgsgA0EBNgIEIANBqMHOADYCACADQgE3AgwgA0E7NgIkIAMgAjYCICADIANBIGo2AgggAEEEaiADEKMYIABBADYCAAwBC0HYv84AEOcrAAsgA0EwaiQADwsgASADKAIIQdinzgAQ/S8ACyACIAMoAghB2KfOABD9LwALiQsCE38CfiMAQSBrIgwkACALKAIIIQ8gC0IANwMIAkAgBCAHcSIXIANNBEAgCykDACEgIAAoAkwhGiADIBdrIRIgAiAXaiEUAkAgACgCOCITRQ0AA0BBECANIA1BEE0bIRUgDyAUaiEYIAYgDUECdGohECAPIBdqIARLIRkDQAJAAkAgDSAVRwRAIBAoAgAiFiAJSw0CIAcgFmsiDiAHTyAZcg0CIAQgDnEiDiAPaiIRIARNDQEMAgsgFUEQQbzVzgAQwyEACwJAAkACQAJAAkAgDyASSQRAIAMgEU0NASAYLQAAIAIgEWotAABHDQYgAyAOSQ0CIAIgDmogAyAOayAUIBIgCBCyICIQQQJNIBBBAkcgDUEBS3JxDQUgICAQIA4gBRChLiIOIBoQ8jQiH1oNBSANDQMMBAsgDyASQczVzgAQwyEACyARIANB3NXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQezVzgAQ7ywACyAfIA0Q/zB9IR8LIB8gIFgNACALIBY2AhAgCyAONgIIIAsgHzcDAEEBIRsgDiEPIB8hIAsgDUEBaiINIBNJDQIMAwsgEEEEaiEQIA1BAWoiDSATSQ0ACwsLAkACQAJAAkACQCAAIBQgEhCXHSIGIAAoAgQiDkkEQAJAIAAoAgwiDSAGIAAoAiQiEHQiDk8EQEEBIBB0IhAgDSAOa0sNASAQIAAoAiAiFk0NAyAAKAIIIA5BAnRqIRggACgCACAGQQF0aiIZLwEAIgZFBEBBACEGDAoLIAYgEGsiDkEAIA5BAEobIRwgBiEOA0AgDyAUaiEdIA8gF2ogBEshHgNAIA4hDQNAIA0gHE0NDCANQQFrIg4gFnEiESAQTw0HIAcgGCARQQJ0aigCACITayERAkAgHg0AIAQgE3EiEyAPaiIVIARLDQAgDyASTw0JIAMgFU0NCiAdLQAAIAIgFWotAABHDQAgCSARSQ0NIAMgE0kNCyACIBNqIAMgE2sgFCASIAgQ9AEiDUUNAiAgIA0gEyAFEKEuIg0gESAaEIwtIh9aDQIgCyARNgIQIAsgDTYCCCALIB83AwBBASEbIA0hDyAfISAMAwsgDUEBayENIAkgEU8NAAsLCwwJCyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHw084AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAYgDkHg084AEMMhAAtBkNTOAEHKAEHc1M4AEJ8pAAsgESAQQezUzgAQwyEACyAPIBJB/NTOABDDIQALIBUgA0GM1c4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBnNXOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQdDTzgAQ7ywACwJ/AkAgECAGIBZxIgJLBEAgGCACQQJ0aiAHNgIAIBkgGS8BAEEBajsBAEEBIBsNAhogAQ0BQQAMAgsgAiAQQazVzgAQwyEACyABIQJBACEBQQAhByAAKAJIIg8gACgCRCIDQQd2TwRAIAAoAkwhDkGAgAIgFCASEMogIgZBAXQiBGsiBUEAIAVBgIACTRshDSADQQFqIQUgBkECdEGYm9IAaiEGA0ACQCANIAEiA0cEQCAAIAU2AkQgBi8BACIBRQ0BIAIgASAUIBIgCCAJIAogDiALEMQSRQ0BQQEhByAAIA9BAWoiDzYCSAwBCyAEQYCAAkGE4s4AEMMhAAtBASEBIAVBAWohBSAGQQJqIQYgBEEBaiEEIANBAXFFDQALCyAHCyAMQSBqJAALqgoCBn8DfiMAQdABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E+cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZBAXRqIAE7AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBgQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAIgASAEaiwAACIDOgCwASADQQBIDQIgBSADOwEAIAVBAmohBSAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDNHSACQShqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhAyACQQhqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiACQCADRQRAIAJCADcCLCACKAIIDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIoAghFDQQLIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBEEDdGopAwAiCDcDeCAIQv8AWARAIAQgBWogCDwAAAwBCwsgAkG4AWpBgoSIEDYCACACQoKEiJCgwICBAjcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGLDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikAiQE3AAkgAEEQaiACQZABaikAADcAACACLQCIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKQMAIgg3A7ABIAhC/wBWDQIgASAFaiAIPAAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGLDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuzCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKQMAIgg3A3ggCEL/AVgEQCAEIAVqIAg8AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCkDACIINwOwASAIQv8BVg0CIAEgBWogCDwAACAEQQhqIQQgAyABQQFqIgFHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDjGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDBHSACQSBqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALswoCBn8DfiMAQdABayICJAAgAUEMahDYPCEDIAJBCGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCKCACIAQ2AiQgAkHAADYCIAJAIANFBEAgAkIANwIsIAIoAggNAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCMCACIAM2AiwgAigCCEUNBAsgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIEQQN0aikDACIINwN4IAhC/wFYBEAgBCAFaiAIPAAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQpAwAiCDcDsAEgCEL/AVYNAiABIAVqIAg8AAAgBEEIaiEEIAMgAUEBaiIBRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQwR0gAkEgahDPLwwCCyACQcgBakGGjJgwNgIAIAJChoyYsODAgYMGNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACfgJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCANAAkAgCFBFBEAgAikDcCEJDAELA0ACfgJAIAIpA1AiCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDUCAJp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDUAsgAikDQCIJQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQNwQkB9Igk3A3AgAiAINwNoIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDaCACIAEgCqcgCadqQQN0IgVqKwMAIgs5A3ggC0QAAAAAAADwv2RFIAtEAAAAAAAA8ENjRXJFBEAgBCAFaiALsTcDAAwBCwsgAkG4AWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQ2NFcg0CIAQgC7E3AwAgBEEIaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOQZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENkdIAJBIGoQzy8MAgsgAkHIAWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAu6CgMGfwN+AXwjAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaisDACILOQN4IAtEAAAAAAAA4MNmRSALRAAAAAAAAOBDY0VyRQRAIAQgBWogC7A3AwAMAQsLIAJBuAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAODDZkUgC0QAAAAAAADgQ2NFcg0CIAQgC7A3AwAgBEEIaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOQZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENYdIAJBIGoQzy8MAgsgAkHIAWpBhYqUKDYCACACQoWKlKjQoMGCBTcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGJDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7IKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBCACQRBqIAEQkjYQ7iUgBCEDAkACQCAAAn8CQAJAAkACQCAEQT9xIgUEQCAEIAVrQUBrIgMgBEkNAQtBwAAhBSADQcAAENE0BEACQCADBEAgA0HAABCtNiIFRQ0BCyACIAU2AjAgAiADNgIsIAJBwAA2AigCQCAERQRAIAJCADcCNCACKAIQDQEMBgsgBARAIAVBACAE/AsACyACIAQ2AjggAiAENgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBgQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBkEAIQMDQCACIAMgBmosAAAiAToAsAEgAUEASA0CIAMgBWogAToAACAEIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDBHSACQShqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7IKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBCACQRBqIAEQkjYQ7iUgBCEDAkACQCAAAn8CQAJAAkACQCAEQT9xIgUEQCAEIAVrQUBrIgMgBEkNAQtBwAAhBSADQcAAENE0BEACQCADBEAgA0HAABCtNiIFRQ0BCyACIAU2AjAgAiADNgIsIAJBwAA2AigCQCAERQRAIAJCADcCNCACKAIQDQEMBgsgBARAIAVBACAE/AsACyACIAQ2AjggAiAENgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBkEAIQMDQCACIAMgBmosAAAiAToAsAEgAUEASA0CIAMgBWogAToAACAEIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBjQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC88JAg1/A34jAEHQBGsiAiQAAkACQCABKQMAIg9CAlYNAAJAAkAgD6dBAWsOAgIAAQsgASkDECIPUEUEQCABQRhqIQYgASgCQEEIaiELIAJBwAJqQQRyIQogASkDCCEQIAJBDGohByACQUBrIQwgAkEoaiEDIAJB6AJqIQ0gAkHQAmohBCABKAIYIghFIQUDQAJAAkACQCAFRQRAIAJBwAJqIgUgCBDgFCACKALAAkEIRg0BIAYQny8gBkEANgIAIAIoAsACQQhHBEAgBRDJIwtBACEIDAMLIAJBwAJqIAsgEBD0DyADIApBCGopAgA3AwAgAiAKKQIANwMgIAIoAsACIgVBCEcEQCACQRhqIAJBKGopAwAiDzcDACACIAIpAyAiEDcDECACKALUAiEBIABBDGogDzcCACAAIBA3AgQgACABNgIUIAAgBTYCAAwICyACQQhqIAMpAwA3AwAgAiACKQMgNwMAIAJBwAJqIAIQ8hMCQAJAIAIpA8gCIhFCBFEEQCACQbgCaiAEQRBqKQMAIg83AwAgAkGwAmogBEEIaikDACIQNwMAIAIgBCkDACIRNwOoAiAAQRBqIA83AwAgAEEIaiAQNwMAIAAgETcDAAwBCyACQbACaiIJIARBCGopAwA3AwAgAkG4AmoiDiAEQRBqKQMANwMAIAIgBCkDADcDqAIgAigCwAIhBSAMIA1B6AH8CgAAIANBEGogDikDADcDACADQQhqIAkpAwA3AwAgAyACKQOoAjcDACACIBE3AyAgAkHAAmogBSAPEI4aIAIoAsACIglBCEYNASAAIAIpAsQCNwIEIABBFGogAkHUAmooAgA2AgAgAEEMaiACQcwCaikCADcCACAAIAk2AgAgAkEgahD8LAsgByACKAIEIAIoAgggAigCACgCEBEBAAwICyABIA8gBa0iEX0iDzcDECABIBAgEXwiEDcDCCACQcACaiIFIAJBIGoiCRDgFCACKALAAkEIRgRAIAJBuAJqIgQgAkHUAmooAgA2AgAgAkGwAmoiAyACQcwCaikCADcDACACIAIpAsQCNwOoAiAFIAlBiAL8CgAAQYgCQQgQrTYiAUUNAiABIAVBiAL8CgAAIAYQny8gAEEINgIAIAYgATYCACAAIAIpA6gCNwIEIABBDGogAykDADcCACAAQRRqIAQoAgA2AgAgByACKAIEIAIoAgggAigCACgCEBEBAAwICyACQcACahDJIyACQSBqEPwsIAcgAigCBCACKAIIIAIoAgAoAhARAQAMAgsgACACKQLEAjcCBCAAQQg2AgAgAEEUaiACQdQCaigCADYCACAAQQxqIAJBzAJqKQIANwIADAYLQQhBiAIQoz0AC0EBIQUgD1BFDQALCyAAQoiAgIAgNwMADAILIAEoAiwiBwRAIAEoAigiAyABKAIgIgRBACADIARPG2shCiABKAIkIQYgB0EBRiIHRQRAIAYgA0EBaiIDIARBACADIARPG2tBGGxqKAIIIQgLIABBADoAFCAAQQA2AgwgAEKIgICAEDcDACAAIAEoAjAgCCAHGyAGIApBGGxqKAIIazYCCAwCCyAAQoiAgIAgNwMADAELIABBAToAFCAAQQA2AgwgAEIINwMACyACQdAEaiQAC5gKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQQCQAJAIAACfwJAAkACQAJAIAVBPHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAIgAzYCKCACIAQ2AiQgAkHAADYCICAFBEAgA0EAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQQgASgCECEBA0ACQCACKQNoIglQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOoAQwBCyACKAJgRQ0BIAJBoAFqIAQQtiogAikDoAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6gBCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAiAJQgEgCXoiCoaFNwNoIAJB+ABqIAEgCqcgCKdqIgVBA3RqKQMAIggQ/RcgAigCeCIGBEAgAyAFQQJ0aiAGEMUkNgIADAELCyACIAg3A5gBIAJBJzYCzAEgAkGDj/8ANgLIASACQQM2AqQBIAJBxJL/ADYCoAEgAkICNwKsASACQe4GNgLEASACQcwBNgK8ASACIAJBuAFqNgKoASACIAJBmAFqNgLAASACIAJByAFqNgK4ASACQYgBaiACQaABahCZDiACKAKIASEDIAIpAowBIQggAigClAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEEA0AgAkG4AWogASkDACIIEP0XIAIoArgBIgVFDQIgAyAFEMUkNgIAIANBBGohAyABQQhqIQEgBiAEQQFqIgRHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJBNGoiASACQaABahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDSHSACQSBqEM8vDAILIAIgCDcDyAEgAkEnNgJ8IAJBg4//ADYCeCACQQM2AkQgAkHEkv8ANgJAIAJCAjcCTCACQe4GNgKQASACQcwBNgKIASACIAJBhAFqNgJIIAIgAkHIAWo2AowBIAIgAkH4AGo2AoQBIAJBpAFqIAJBQGsQmQ4gAigCpAEhAyACKQKoASEIIAIoArABCzYCFCAAIAg3AgwgACADNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuYCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEEAkACQCAAAn8CQAJAAkACQCAFQTxxIgMEQCAFIANrQUBrIgQgBUkNAQtBwAAhAyAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIDRQ0BCyACIAM2AiggAiAENgIkIAJBwAA2AiAgBQRAIANBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEEIAEoAhAhAQNAAkAgAikDaCIJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDqAEMAQsgAigCYEUNASACQaABaiAEELYqIAIpA6ABIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOoAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAIgCUIBIAl6IgqGhTcDaCACQfgAaiABIAqnIAinaiIFQQN0aikDACIIEIEVIAIoAngiBgRAIAMgBUECdGogBhDFJDYCAAwBCwsgAiAINwOYASACQSw2AswBIAJBgI7/ADYCyAEgAkEDNgKkASACQcSS/wA2AqABIAJCAjcCrAEgAkHuBjYCxAEgAkHMATYCvAEgAiACQbgBajYCqAEgAiACQZgBajYCwAEgAiACQcgBajYCuAEgAkGIAWogAkGgAWoQmQ4gAigCiAEhAyACKQKMASEIIAIoApQBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhBANAIAJBuAFqIAEpAwAiCBCBFSACKAK4ASIFRQ0CIAMgBRDFJDYCACADQQRqIQMgAUEIaiEBIAYgBEEBaiIERw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqgBIAIgBjYCpAEgAiABNgKgASACQTRqIgEgAkGgAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ0h0gAkEgahDPLwwCCyACIAg3A8gBIAJBLDYCfCACQYCO/wA2AnggAkEDNgJEIAJBxJL/ADYCQCACQgI3AkwgAkHuBjYCkAEgAkHMATYCiAEgAiACQYQBajYCSCACIAJByAFqNgKMASACIAJB+ABqNgKEASACQaQBaiACQUBrEJkOIAIoAqQBIQMgAikCqAEhCCACKAKwAQs2AhQgACAINwIMIAAgAzYCCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALmAoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhBAJAAkAgAAJ/AkACQAJAAkAgBUE8cSIDBEAgBSADa0FAayIEIAVJDQELQcAAIQMgBEHAABDRNARAAkAgBARAIARBwAAQrTYiA0UNAQsgAiADNgIoIAIgBDYCJCACQcAANgIgIAUEQCADQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohBCABKAIQIQEDQAJAIAIpA2giCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6gBDAELIAIoAmBFDQEgAkGgAWogBBC2KiACKQOgASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDqAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACIAlCASAJeiIKhoU3A2ggAkH4AGogASAKpyAIp2oiBUEDdGopAwAiCBD9FSACKAJ4IgYEQCADIAVBAnRqIAYQxSQ2AgAMAQsLIAIgCDcDmAEgAkErNgLMASACQdiO/wA2AsgBIAJBAzYCpAEgAkHEkv8ANgKgASACQgI3AqwBIAJB7gY2AsQBIAJBzAE2ArwBIAIgAkG4AWo2AqgBIAIgAkGYAWo2AsABIAIgAkHIAWo2ArgBIAJBiAFqIAJBoAFqEJkOIAIoAogBIQMgAikCjAEhCCACKAKUAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQQDQCACQbgBaiABKQMAIggQ/RUgAigCuAEiBUUNAiADIAUQxSQ2AgAgA0EEaiEDIAFBCGohASAGIARBAWoiBEcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKoASACIAY2AqQBIAIgATYCoAEgAkE0aiIBIAJBoAFqEOUZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENIdIAJBIGoQzy8MAgsgAiAINwPIASACQSs2AnwgAkHYjv8ANgJ4IAJBAzYCRCACQcSS/wA2AkAgAkICNwJMIAJB7gY2ApABIAJBzAE2AogBIAIgAkGEAWo2AkggAiACQcgBajYCjAEgAiACQfgAajYChAEgAkGkAWogAkFAaxCZDiACKAKkASEDIAIpAqgBIQggAigCsAELNgIUIAAgCDcCDCAAIAM2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC5gKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQQCQAJAIAACfwJAAkACQAJAIAVBPHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAIgAzYCKCACIAQ2AiQgAkHAADYCICAFBEAgA0EAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQQgASgCECEBA0ACQCACKQNoIglQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOoAQwBCyACKAJgRQ0BIAJBoAFqIAQQtiogAikDoAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6gBCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAiAJQgEgCXoiCoaFNwNoIAJB+ABqIAEgCqcgCKdqIgVBA3RqKQMAIggQ1hUgAigCeCIGBEAgAyAFQQJ0aiAGEMUkNgIADAELCyACIAg3A5gBIAJBLDYCzAEgAkGsjv8ANgLIASACQQM2AqQBIAJBxJL/ADYCoAEgAkICNwKsASACQe4GNgLEASACQcwBNgK8ASACIAJBuAFqNgKoASACIAJBmAFqNgLAASACIAJByAFqNgK4ASACQYgBaiACQaABahCZDiACKAKIASEDIAIpAowBIQggAigClAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEEA0AgAkG4AWogASkDACIIENYVIAIoArgBIgVFDQIgAyAFEMUkNgIAIANBBGohAyABQQhqIQEgBiAEQQFqIgRHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJBNGoiASACQaABahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDSHSACQSBqEM8vDAILIAIgCDcDyAEgAkEsNgJ8IAJBrI7/ADYCeCACQQM2AkQgAkHEkv8ANgJAIAJCAjcCTCACQe4GNgKQASACQcwBNgKIASACIAJBhAFqNgJIIAIgAkHIAWo2AowBIAIgAkH4AGo2AoQBIAJBpAFqIAJBQGsQmQ4gAigCpAEhAyACKQKoASEIIAIoArABCzYCFCAAIAg3AgwgACADNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuiCgIGfwN+IwBB0AFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiAyEEAkACQAJ+AkACQAJAAkAgA0E4cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAQgCqcgCadqIgZBAXRqLgEAIgE7AYIBIAFBAE4EQCAFIAZBA3RqIAGtQv//A4M3AwAMAQsLIAJBuAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgAiADLgEAIgQ7AbABIARBAEgNAiAFIAStQv//A4M3AwAgBUEIaiEFIANBAmohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDZHSACQShqEM8vDAILIAJByAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYoMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC+0IAgR/DH4jAEHAAWsiBCQAAkACQCACQSdPBEBBWiEFQgEhESABIAJBJmsiBmotAABBMGtB/wFxQQlLDQEgASACaiECA0AgBQRAIARBADYCjAEgBEHwAGogDiAPQgpCACAEQYwBahD2DCACIAVqLQAAQTBrIgdBCUsNBCAEKAKMAQ0EIAVBAWohBSAEKQN4IghCf4UgCCAIIAQpA3AiCiAHrXwiDiAKVK18Ig+Fg0IAWQ0BDAQLCyAEQZABaiABIAYgAxCCBiAEKAKQAUEBcQ0BAn4gBCkDsAEiCyAEKQOgASIIhCAEKQO4ASIKIAQpA6gBIgmEhFAEQEIAIQpCACELQgAMAQsgBEHgAGogCCAKQj+HIgiFIgwgCH0iEEIAQoCAgICAyIjFCUIAEKgeIARBQGsgCCAJhSISIAh9IAggDFYiAa19IgxCAEKAgICAgMiIxQlCABCoHiAEQdAAaiAQQgBC+oib1IWV053LAEIAEKgeIARBMGogDEIAQvqIm9SFldOdywBCABCoHiAEQRBqIAggC4UiDCAKQj+IfCILIAxUrSAIIAqFfCALIAEgCCASViAJUButIglUrX0iDEIAQoCAgICAyIjFCUIAEKgeIAQgCyAJfSIJQgBC+oib1IWV053LAEIAEKgeIARBIGogCUIAQoCAgICAyIjFCUIAEKgeIAQpAwggDCAEKQMYhIRCAFIgBCkDKCIJIAQpAxAgBCkDAHx8IhAgCVRyDQMgBCkDSCAEKQNoIgsgBCkDQHwiCSALVK18IhIgBCkDMHwiCyAEKQNYIAkgCSAEKQNQfCIJVq18fCIMIAQpAyB8IhMgDFQiASABrSALIAxWrSAEKQM4IAsgElStfHwiCyAQfHwiDCALVCALIAxRGw0DIAogCCAMhSAIfSAIIBOFIgogCFStfSAKIAh9IgsgBCkDYEKAgICAgHiDIAiFIgwgCFQiASAIIAmFIhAgCFQgCVAbrSIJVK19IgqFQgBTDQMgCyAJfSENIAwgCH0hCyAQIAh9IAGtfQshCSAKQgAgDyAOQgBSrXx9IA8gAxsiD0I/hyIMfCAMIA18IgggDVStfCAIIAtCACAOfSAOIAMbfCIQIAtUIgEgAa0gCSAPfHwiDyAJVCAJIA9RIgEbIgKtfCIOIAhUrXwhCAJAIAxCAFMEQCACIA0gDlYgCCAKUyAIIApRGyANIA6FIAggCoWEUBtFDQMMAQsgCyAQWCAJIA9YIAEbIA0gDlggCCAKWSAIIApRGyANIA6FIAggCoWEUBtBAUcNAgsgACAONwMgIAAgEDcDECAAIAg3AyggACAPNwMYQgAhEQwBCyAEQZABaiABIAIQ+gggBC0AkAFFBEAgBCkDqAEhDSAEKQOgASEIIABCACADrX0iCjcDKCAAIAo3AyAgAEIAIAh9IAggAxs3AxAgAEIAIA0gCEIAUq18fSANIAMbNwMYDAELQgEhEQwBC0IAIQ0LIAAgETcDACAAIA03AwggBEHAAWokAAuMCQEHfwJAAkAgAAJ/AkACQCABKAIgIgJBC3ZB/wFxIgRBP0cEQCAEQdsBRw0EIAEtAA1BCkcNBCABLQAQQQpHDQQgAS0AEiABLQARQQpsaiEGIAEtAA8gAS0ADkEKbGohBCABLQAMIAEtAAtBCmxqIQUgAS0AE0H+AUYNAiAFQf8BcSIDQRdLIARB/wFxIghBO0tyIQEgBkH/AXEiB0E8Rw0BQQAhAiABDQUgA0GQHGwgCEE8bGpBO2ohAkGAlOvcAyEBQRMMAwsgAS0ADCABLQALQQpsaiIEQf8BcUEXSyABLQAOIAEtAA1BCmxqIgVB/wFxQTtLciEGIAEtABAgAS0AD0EKbGoiAUH/AXFBPEYEQEEAIQIgBg0FIARB/wFxQZAcbCAFQf8BcUE8bGpBO2ohAkGAlOvcAyEBQREMAwtBACECIAYgAUH/AXEiAUE7S3INBCAFQf8BcUE8bCAEQf8BcUGQHGxqIAFqIQJBACEBQREMAgtBACECIAEgB0E7S3INAyAEQf8BcUE8bCAFQf8BcUGQHGxqIAZB/wFxaiECQQAhAUETDAELIAJBFHZBf3NoIgchAgJAAkACQAJAAkACQAJAAkACQAJAIAcOCQwBAgMEBQYHCAALIAFBFGohA0EAIQFBACECA0AgAiADai0AACABQQpsaiEBIAJBAWoiAkEJRw0ACwwICyABLQAUQYDC1y9sIQEMBwsgAUEUaiEDQQAhAkEAIQEDQCABIANqLQAAIAJBCmxqIQIgAUEBaiIBQQJHDQALIAJBgK3iBGwhAQwGCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBA0cNAAsgAkHAhD1sIQEMBQsgAUEUaiEDQQAhAkEAIQEDQCABIANqLQAAIAJBCmxqIQIgAUEBaiIBQQRHDQALIAJBoI0GbCEBDAQLIAFBFGohA0EAIQJBACEBA0AgASADai0AACACQQpsaiECIAFBAWoiAUEFRw0ACyACQZDOAGwhAQwDCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBBkcNAAsgAkHoB2whAQwCCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBB0cNAAsgAkHkAGwhAQwBCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBCEcNAAsgAkEKbCEBCwJ/IAZB/wFxIgNBPEYEQCAFQf8BcSIDQRdLIARB/wFxIgRBO0tyDQNBACECIAFBgJTr3ANrQYDYqcZ4SQ0EIAFBgJTr3ANqIQEgA0GQHGwgBEE8bGpBO2oMAQsgBUH/AXEiBUEXSyAEQf8BcUE7S3IgBkH/AXEiAkE7S3INAiABQYCU69wDTwRAIAJBO0cNA0EAIQIgAUH/p9a5B0sNBAsgBEH/AXFBPGwgBUGQHGxqIANqCyECIAdBFGoLNgIMIAAgATYCCCAAIAI2AgRBASECDAELQQAhAgsgACACNgIAC5kKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEDdCIDIQQCQAJAAn4CQAJAAkACQCADQThxIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEIA0ACQCAIUEUEQCACKQN4IQkMAQsDQAJ+AkAgAikDWCIJQgNSBEACQAJAAkAgCUICUQ0AIAIgCVCtQgGGNwNYIAmnQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQkLIAlCAFINAgsgAkIDNwNYCyACKQNIIglCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCCAJp0EBcUUNByACIAIpA3hCQH0iCTcDeCACIAg3A3AgCFANAAsLIAJCASAIeiIKhiAIhSIINwNwIAIgBCAKpyAJp2oiBmosAAAiAToAgwEgAUEATgRAIAUgBkEDdGogAa1C/wGDNwMADAELCyACQbgBakGJkqTIADYCACACQomSpMiQocKECTcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGBDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgwFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAIpApABIQggAikCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAIgASAEaiwAACIDOgCwASADQQBIDQIgBSADrUL/AYM3AwAgBUEIaiEFIAYgAUEBaiIBRw0ACwsgAkHIAGoiBRCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIEKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAUQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOQZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAFENkdIAJBKGoQzy8MAgsgAkHIAWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAIpAqQBIQggAikCnAELIQkgACAINwIQIAAgCTcCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALmAoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBAJAAkACfgJAAkACQAJAIANBOHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQgDQAJAIAhQRQRAIAIpA3ghCQwBCwNAAn4CQCACKQNYIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1ggCadBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1gLIAIpA0giCUICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDeEJAfSIJNwN4IAIgCDcDcCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A3AgAiAEIAqnIAmnaiIGQQJ0aigCACIBNgKAASABQQBOBEAgBSAGQQN0aiABrTcDAAwBCwsgAkG4AWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBggw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEEASA0CIAUgBK03AwAgBUEIaiEFIANBBGohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDZHSACQShqEM8vDAILIAJByAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYIMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC/sLAgZ/AX4jAEHAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIgA0EQaiIFKAIQTwRAAkACQAJAAkACQAJAIAMoAgBBAWsOBQECAwUFAAsgBEH4AGoiBiADKAI8QQBBEEEQEKAYIAQoAnwhAyAEKAJ4QQFGDQYgBEEANgIsIAQgBCgCgAE2AiggBCADNgIkIAYgBRDJNCAEQewAaiAGENUJIAQoAmxBAUYEQANAIAQoAnQiAyAEKAJwIgVJDRAgAiADSQ0RIARBJGogASAFQQR0aiABIANBBHRqEOsjIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAAgBEH4AGoQ7xgMAwsgBEH4AGoiBiAFIAMoAjwQsSYgBEEwaiAGQTj8CgAAIAQoArQBIQMgBCAEKAKwASIIQQR0IgU2AiQgBSEGIAVBMHEiBwRAIAUgB2tBQGsiBiAFSQ0HC0HAACEHIAZBwAAQ0TRFDQcgBgRAIAZBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCEBA0AgASAEKAK8ASICTw0LIAQoArgBIAFBBHRqIgEpAwAhCiADIAEpAwg3AAggAyAKNwAAIANBEGohAyAEQRBqIARB+ABqENYQIAQoAhQhASAEKAIQQQFxDQALCyAEIAMgB2siATYCbCABIAVHDQogBCAGNgKIASAEQoCAgICACDcCgAEgBCAFNgJ8IAQgBzYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNCyABQoGAgIAQNwIAIAEgBCkCeDcCCCAAIAU2AgggACACNgIEIAAgATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEFIAMoAgwhAyAEIAI2AoQBIAQgATYCgAEgBCAFIANBAnRqNgJ8IAQgBTYCeCMAQSBrIgIkACACQRRqIARB+ABqIgEoAgQgASgCAGtBAnZBAEEQQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBoIKDARD9LwALIARB7ABqIQYgAkEQaiIIQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACABKAIEIAEoAgBrQQJ2IgkgAkEIaiIFKAIAIAUoAggiB2tLBEAgBSAHIAlBEEEQEN4oIAUoAgghBwsgAyAFKAIENgIMIAMgBzYCCCADIAVBCGo2AgQgASADQQRqEJEZIANBEGokACAGQQhqIAgoAgA2AgAgBiACKQIINwIAIAJBIGokACAAIAYQ7xgMAQsgBEH4AGogAygCPEEAQRBBEBCgGCAEKAJ8IQUgBCgCeEEBRg0KIARBADYCdCAEIAQoAoABNgJwIAQgBTYCbCADKAIMIgUEQCADKAIIIgMgBUEDdGohBwNAIANBBGooAgAiBSADKAIAIgZJDQ8gAiAFSQ0QIARB7ABqIAEgBkEEdGogASAFQQR0ahDrIyADQQhqIgMgB0cNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAAIARB+ABqEO8YCyAEQcABaiQADwtB/K2DAUEoQdyvgwEQnykAC0G0roMBQThB7K6DARCfKQALIAMgBCgCgAFB/K6DARD9LwALQfT5ggFBI0GY+oIBEMskAAtBuPqCAUEpIARB+ABqQbCCgwFB5PqCARDVHgALQcAAIAYQoz0ACyABIAJB7K+DARDDIQALIARCADcChAEgBEKBgICAwAA3AnwgBEGo+4IBNgJ4QQAgBEHsAGogBEEkaiAEQfgAakGw+4IBEK8rAAtBBEEcEKM9AAsgBSAEKAKAAUGsr4MBEP0vAAsgBSADQYyvgwEQsTsACyADIAJBjK+DARCwOwALIAYgBUG8r4MBELE7AAsgBSACQbyvgwEQsDsAC/4RAgt/An4jAEHgAGsiAiQAIAEoAhAhBwJAAkACfwJAAkACQAJAAkAgASgCAEGAgICAeEYiA0UEQCAHRQ0CQQAgASADGyEDDAELIAJByABqIAEoAhQgByABKAIYKAIUEQEAIAIoAkgiA0EIRg0BIAJBMGogAkHYAGopAwA3AwAgAiACKQNQNwMoIAIgAigCTDYCJCACIAM2AiAMAwsCQANAIAEoAgxFDQIDQAJAIAMoAgwiBUUEQEECIQQMAQsgAyAFQQFrNgIMIAMgAygCCCIEQQFqIgUgAygCACIGQQAgBSAGTxtrNgIIIAMoAgQgBEEDdGoiBS0ABCEEIAUoAgAhBQsgAiAEOgAEIAIgBTYCACACLQAEIgVBAkYNAiACIAIoAgAiBDYCQCACIAVBAXEiBToARAJAAkAgBUUEQCAERQ0BAkAgBCAHIAprIgVJDQAgBCAFayILRQ0AIAMgAygCDCIEIAMoAgAiBkYEfyADKAIAIQQgA0GYqs8AEJsoAkAgAygCCCIIIAQgAygCDCIJa00NACAEIAhrIgYgCSAGayIJSyADKAIAIgwgBGsgCU9xRQRAIAwgBmshBCAGQQN0IgYEQCADKAIEIgkgBEEDdGogCSAIQQN0aiAG/AoAAAsgAyAENgIIDAELIAlBA3QiBkUNACADKAIEIgggBEEDdGogCCAG/AoAAAsgAygCACEGIAMoAgwFIAQLQQFqNgIMIAMgBiADKAIIQQFrIgRqIgYgBCAEIAZLGyIENgIIIAMoAgQgBEEDdGoiBEEAOgAEIAQgCzYCACAFIQQLIAJByABqIAEoAhQgBCABKAIYKAIUEQEAIAIoAkwhBCACKAJIIgVBCEcEQCACQTBqIAJB2ABqKQMANwMAIAIgAikDUDcDKCACIAQ2AiQgAiAFNgIgDAgLIARFDQYgBCAKaiIKIAdPDQYMBAsgAkHIAGogASgCFCAEIAEoAhgoAhwRAQAgAigCTCEFIAIoAkgiBkEIRwRAIAJBMGogAkHYAGopAwA3AwAgAiACKQNQNwMoIAIgBTYCJCACIAY2AiAMBwsgAiAFNgI8IAQgBUcNAQsgASgCDA0BDAQLCwsgAkECNgJMIAJBzKrPADYCSCACQgI3AlQgAkE7NgIUIAJBOzYCDCACIAJBCGo2AlAgAiACQTxqNgIQIAIgAkFAazYCCCACQSBqQQRyIAJByABqEJkOIAJBADYCIAwCC0GIqs8AELI7AAsgAkHIAGogASgCFCABKAIYKAIYEQAAIAIoAlAhAyACKAJMIQEgAigCSCIEQQhHBEAgAkE0aiACQdwAaigCADYCACACIAIpAlQ3AiwgAiADNgIoIAIgATYCJCACIAQ2AiAMAQsgAiADNgJEIAIgATYCQCMAQSBrIgMkACADQQhqIAJBQGsiBCgCACAEKAIEIgUoAghBAWtBeHFqQQhqIAUoAhARAAAgA0EQaiADKAIIIgUgAygCDCgCDBEAACADKQMYIQ0gAykDECEOIANBIGokACAFQQAgDkK+uaqJmdKNmuAAhSANQsWRgbqRwsPNNIWEUBsiB0UEQCACQcgAaiIDQS5BAEEBQQEQoBggAigCTCEBIAIoAkhBAUYNBiACKAJQIgVB3KrPAEEu/AoAACACQS42AlQgAiAFNgJQIAIgATYCTCACQY6AgIB4NgJIIAJBIGogAxCmJSACKAJAIgEgASgCACIBQQFrNgIAIAFBAUcNASAEELsjDAELIAcoAhgEfyACQcgAaiEFQQAhCkEAIQZBACEJQQAhBEEAIQEjAEFAaiIDJAAgBygCGCELIANBNGogB0EMahDTBgJAAkAgBygCHCIIBEAgCCAIKAIAIgFBAWo2AgAgAUEASA0BIAcoAiwhBiAHKAIoIQkgBygCJCEEIAcoAjAhCiAHKAIgIQELIAMgBxC8FSADQRRqIANBPGooAgA2AgAgAyALNgIYIAMgCjYCMCADIAY2AiwgAyAJNgIoIAMgBDYCJCADIAE2AiAgAyAINgIcIAMgAykCNDcCDCAFIQEjAEEwayIEJAACQAJAIAMtAAxBIEYEQCADKAIYIQogAygCFCEGIAMoAhAhCAJAIAMoAhwiBQRAIARBFGogA0EoaikCADcCACAEQRxqIANBMGooAgAiBzYCACAEIAU2AgggBCADKQIgNwIMIAUgBSgCACIFQQFrNgIAIAVBAUYEQCAEQQhqEPseCyAEIAc2AgQgBw0BCyAEQQhqIgcgCCAGEM4cQTBBCBCtNiIFRQ0CIAVCgYCAgBA3AwAgBUEIaiAHQSj8CgAAIAEgBTYCDCABIAo2AhAgASADKQIANwIAIAFBCGogA0EIaigCADYCACAEQTBqJAAMAwsgBEIANwIUIARCgYCAgMAANwIMIARBiIGFATYCCEEAIARBBGpBsICFASAEQQhqQZCBhQEQrysAC0H49oUBQShBoPeFARCfKQALQQhBMBCjPQALIANBQGskAAwBCwALIAJBEGogAkHUAGopAgA3AwAgAiACKQJMNwMIIAIoAkAhASACKAJIBUGAgICAeAshAyACQQg2AiAgAkEwaiACQRBqKQMANwMAIAIgAzYCJCACIAIpAwg3AyggASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBQGsQuyMLIAIoAiBBCEYNAQsgAkHYAGogAkEwaikDADcDACACQdAAaiACQShqKQMANwMAIAIgAikDIDcDSCMAQSBrIgMkACADQQE2AgQgA0HE9c0ANgIAIANCATcCDCADQTU2AhwgAyACQcgAaiIENgIYIAMgA0EYajYCCCACQQxqIgFBBGogAxCZDiABQY6AgIB4NgIAIAQQySMgA0EgaiQAQQEMAQsgAkEcaiACQTRqKAIANgIAIAJBFGogAkEsaikCADcCACACIAIpAiQiDTcCDEECIQQgDadBgICAgHhGDQEgAkEMaiEBQQALIQQgACABKQIANwIEIABBFGogAUEQaigCADYCACAAQQxqIAFBCGopAgA3AgALIAAgBDYCACACQeAAaiQADwsgASACKAJQQeSjzwAQ/S8AC4sKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaikDACIJNwN4IAlCAFkEQCAEIAVqIAk3AwAMAQsLIAJBuAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEIAUw0CIAQgCDcDACAEQQhqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5BkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ2R0gAkEgahDPLwwCCyACQcgBakGJkqTIADYCACACQomSpMiQocKECTcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC4kKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaikDACIJNwN4IAlCAFkEQCAEIAVqIAk3AwAMAQsLIAJBuAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQgBTDQIgBCAINwMAIARBCGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDkGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDWHSACQSBqEM8vDAILIAJByAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAusCwMHfwF+AXwjAEHABGsiAiQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQCAALQCYAUEBaw4DCwIBAAsgAEHIAGogAEHIAPwKAAALIABByABqIQUCQAJAAkACQCAALQCMAUEBaw4DCAQAAQsCQCAALQCEAUEBaw4DDAQDAAsgACgCgAEhAwwBCyAAQQA6AIQBIAAgACgCiAEiAzYCgAELIAIgAzYCuAEjAEEQayIEJAAgBCACQbgBaigCACUBEB45AwggBEEIaisDACEKIARBEGokACAAQQA6AHwgACAFNgJoIABCADcDYCAAQoAINwNYIAAgAzYCUCAAIAr8BzcDSCAAQfwAaiEEIABB4ABqIQcgBQwDCyAAQeAAaiEHIABB/ABqIQQCQCAALQB8QQFrDgMIAQACCyAAKAJ4IQYgACgCdCEDDAMLAAsgACkDYCEJIAAoAmgLIQMgACAJNwJsIAMpAwAhCSACQQA6ALwEIAIgCTcDuAEgAiADNgK4BCACQRhqIQMgAkG4AWohCAJAQYgDQQgQrTYiBgRAIAYgCEGIA/wKAAAgA0GM3sIANgIEIAMgBjYCAAwBC0EIQYgDEKM9AAsgAigCGCEDIAAgAigCHCIGNgJ4IAAgAzYCdAsgAkG4AWogAyABIAYoAgwRAQAgAigCuAEiAUEJRgRAIARBAzoAAAwHCyACQZgBaiIGIAJByAFqKQMANwMAIAIgAikDwAE3A5ABIAIoArwBIQMgAEH0AGoQvCoCQCABQQhHBEAgAkGwAWogBikDADcDACACIAIpA5ABNwOoASACIAM2AqQBIAIgATYCoAEgACgCbCIBRQ0BIAEgASgCACIBQQFrNgIAIAFBAUcNASAAQewAahD4IwwBCyACIAApAmw3A7gBIAJBoAFqIAMgAkG4AWoQ7QELIAJB2ABqIgMgAkGsAWooAgA2AgAgAiACKQKkATcDUCACKQOwASEJIAIoAqABIQEgBEEBOgAAIAFBCUYNBiACQegAaiIEIAMoAgA2AgAgAiACKQNQNwNgIAcQ3yAgAUEIRg0BIAJBxAFqIAQoAgA2AgAgAiACKQNgNwK8ASACIAk3A8gBIAIgATYCuAEgAkG4AWoQ0hkhA0ICIQkgACgCUCIBQYQBSQ0CIAEQ8h8MAgtBnNzCABDoKwALIAJB+ABqIABB1ABqKQIANwMAIAJBgAFqIABB3ABqKAIANgIAIAJBjAFqIAJB6ABqKAIANgIAIAIgAikDYDcChAEgAiAAKQJMNwNwIAAoAkghA0IAIQkLQQEhASAAQQE6AIQBIAJBNGogAkH4AGopAwA3AgAgAkE8aiACQYABaikDADcCACACQcQAaiACQYgBaikDADcCACACIAM2AiggAiAJNwMgIAIgAikDcDcCLCAFEIAqIAJBEGogAkEgaiIHEPUfIAIoAhQhBSACKAIQIQQgAEEBOgCMAUEDIQMgBEECRg0EAkAgBEEBcQRAIAIgBTYCICACQYABNgK4ASACIABBlAFqIAJBuAFqIAcQwiMgAigCACACKAIEENYvIgFBhAFPBEAgARDyHwsgAigCuAEiAUGEAU8EQCABEPIfCyACKAIgIgFBhAFJDQEgARDyHwwBCyACIAU2AiAgAkGAATYCuAEgAkEIaiAAQZABaiACQbgBaiACQSBqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoArgBIgFBhAFPBEAgARDyHwsgAigCICIBQYQBSQ0AIAEQ8h8LIAAoApABIgFBhAFPBEAgARDyHwtBASEDQQAhASAAKAKUASIFQYQBSQ0EIAUQ8h8MBAtB9NbCABDoKwALQazcwgAQ6CsAC0HcyMIAEOgrAAtBAyEDIABBAzoAhAEgAEEDOgCMAUEBIQELIAAgAzoAmAEgAkHABGokACABC6cJAgN/AX4jAEHgAGsiBCQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkAgAiAAQQR2IgBPDQkgBCABKAIQIAJBBHRqIgApAwg3AzggBCAAKQMANwMwIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEwaiADENQfIQIMDAsgBEEwaiADEI8WIQIMCwsgACgCBCIAKAIUIQEgBCACNgJEIAIgAUEEdiIBTw0LIAAoAhAgAkEEdGoiACkDCCAAKQMAIgdCgICAgICAgICAf30gB1StfFBFDQkgBigCBCIARQ0CIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQMgBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQA2AlggBEEBNgJMIARB7JuEATYCSCAEQgQ3AlAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCRCACIAFBBHYiAU8NCiAAKAIQIAJBBHRqIgApAwggACkDACIHQoCAgICAgICAgH99IAdUrXxQDQVBrJyEARCyOwALIAAoAgQiACgCFCEBIAQgAjYCRCACIAFBBHYiAU8NCSAAKAIQIAJBBHRqIgApAwggACkDACIHQoCAgICAgICAgH99IAdUrXxQDQVB/JyEARCyOwALIARB0ABqQfSshgEoAgA2AgAgBEHsrIYBKQIANwNIIARByABqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQdAAakH0rIYBKAIANgIAIARB7KyGASkCADcDSCAEQcgAaiIAEMkMIARBADYCWCAEQQE2AkwgBEHsm4QBNgJIIARCBDcCUCADIAAQ0TkLIQIgBEEcahDlEAwFCyAEQTBqIAMQjhYhAgwECyAEIAc3AwggBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQI2AkwgBEHsnIQBNgJIIARCAjcCVCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCUCAEIARBCGo2AhwgAygCACADKAIEIAAQywohAgwDCyAEIAc3AxAgBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQI2AkwgBEHsnIQBNgJIIARCAjcCVCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCUCAEIARBEGo2AhwgAygCACADKAIEIAAQywohAgwCCyAEIAA2AkQgBEECNgJMIARBuJeEATYCSCAEQgI3AlQgBEE7NgIoIARBOzYCICAEIARBHGo2AlAgBCAEQcQAajYCJCAEIARBQGs2AhwMAwtB2JuEARCyOwALIARB4ABqJAAgAg8LIAQgATYCMCAEQQI2AkwgBEG4l4QBNgJIIARCAjcCVCAEQTs2AiggBEE7NgIgIAQgBEEcajYCUCAEIARBMGo2AiQgBCAEQcQAajYCHAsgBEHIAGpByJeEARDvLAAL3wgBC38jAEHgAGsiAiQAAkACQAJ/QQEgASgCBCIEKAIEIAQoAgggACgCACgCACIFKAIAIAUoAgQQwS4NABpBACAEKAIEIAQoAgggBSgCACAFKAIEEK07RQ0AGiACIAQoAgQgBCgCCCAFKAIAIAUoAgQQqQMCQAJAIAIoAgBBAUYEQCACQQhqIQAgAigCPCEBIAIoAjghAyACKAI0IQYgAigCMCEHIAIoAiRBf0YNASACQUBrIAAgByAGIAMgAUEAEPkLDAILAkAgAi0ADg0AIAItAAwhByACKAI0IQAgAigCMCEIIAIoAgQhAQJAA0ACQCABRQ0AIAAgAU0EQCAAIAFGDQEMCQsgASAIaiwAAEFASA0ICyAAIAFHBEACfyABIAhqIgYsAAAiA0EATgRAIANB/wFxDAELIAYtAAFBP3EhCSADQR9xIQogCkEGdCAJciADQV9NDQAaIAYtAAJBP3EgCUEGdHIhCSAJIApBDHRyIANBcEkNABogCkESdEGAgPAAcSAGLQADQT9xIAlBBnRycgshAyAHQQFxBEAgASEADAMLQQEhBwJ/QQEgA0GAAUkNABpBAiADQYAQSQ0AGkEDQQQgA0GAgARJGwsgAWohAQwBCwsgB0EBcUUNAQsgAiAANgJEQQEhCwsgAiALNgJADAELIAJBQGsgACAHIAYgAyABQQEQ+QsLAkAgAigCQARAIAQoAgQiAyAEKAIIIgdqIQQgBSgCBCACKAJEaiIGQSBJDQFBACEFAkAgBkEgRiAHQSBJcg0AIAMgB0FgcWohDCACQQhqIQggAkHYAGohCyACQdAAaiEJIAMhAANAIAtCADcDACAJQgA3AwAgAkHIAGpCADcDACACQgA3A0BBACEBA0AgAkFAayABaiAAIAFqLAAAQb9/SjoAACABQQFqIgFBIEcNAAsgCCACKQNANwAAIAhBGGogCykDADcAACAIQRBqIAkpAwA3AABBCCEBIAhBCGogAkHIAGopAwA3AABBACEKA0AgASACai0AACAKaiEKIAFBAWoiAUEoRw0ACyAFQSBqIQUgBiAKQf8BcWsiBkEhSQ0BIABBIGoiACAMRw0ACwsgAyAFaiEDIAUgB0YNASAHIAVrIQEDQCADLAAAQb9/Sg0CIANBAWohAyABQQFrIgENAAsgBCEDDAELQZzKwwAQsjsACyAGBEADQCADIARGDQMgAyADLQAAQbTHwwBqLQAAaiEDIAZBAWsiBg0ACwsgAyAERg0BAkAgAywAACIAQQBOBEAgAEH/AXEhAQwBCyADLQABQT9xIQQgAEEfcSEBIABBX00EQCABQQZ0IARyIQEMAQsgAy0AAkE/cSAEQQZ0ciEEIABBcEkEQCAEIAFBDHRyIQEMAQsgAUESdEGAgPAAcSADLQADQT9xIARBBnRyciIBQYCAxABGDQILIAFBLkYLIAJB4ABqJAAPC0GsysMAELI7AAsgCCAAIAEgAEGkx8MAEKM2AAuBCgMOfwN9AX4jAEEgayIVJAAgFUEANgIMAkACQCAKRQ0AIAZBBGohEQNAAkAgECIOQQFqIhAgCk8NAAJAIAcgDksEQCAGIA5BAnRqIRIgESEPIBAhDgwBCyAOIAdB3ObMABDDIQALA0AgByAORwRAIAAgASACIAMgEigCACAPKAIAIA0gCCAJIBVBDGoQ0QggD0EEaiEPIA5BAWoiDiAKRw0BDAILCyAHIAdB7ObMABDDIQALIBFBBGohESAKIBBHDQALQQEhESAKQQFGDQAgCUUNASAKIRFBASEKA0AgEUEBayIZIRcDQCAdIAgqAgxfBEBDmXaWfiEdIBEgDCIKTQ0DDAILIAgoAgAiEiEOAkAgCCgCBCIWIg8gAUkEQCABIA5LBEAgACAOQYgWbGoiECAQKAKAFiAAIA9BiBZsaiIPKAKAFmo2AoAWQQAhDgNAIA4gEGoiEyAOIA9qKAIAIBMoAgBqNgIAIA5BBGoiDkGAFkcNAAsMAgsgDiABQezqzAAQwyEACyAPIAFB3OrMABDDIQALAkAgASASSwRAIAAgEkGIFmxqIAgqAgg4AoQWIAMgFksEQCADIBJLBEAgAiASQQJ0aiIOIA4oAgAgAiAWQQJ0aigCAGo2AgAgCwRAQQAhDyAEIQ4DQAJAAkAgBSAPRwRAIA4oAgAgFkYNAQwCCyAFIAVBzObMABDDIQALIA4gEjYCAAsgDkEEaiEOIAsgD0EBaiIPRw0ACwtBACEOIAYhDwJAAkACQAJAA0AgByAORwRAIAYgDkECdGooAgAgFkYNAiAPQQRqIQ8gDkEBaiIOIBFHDQEMAwsLIAcgB0Hs5cwAEMMhAAsgESAOQX9zaiITRQ0AQQAhEANAIA4gEGoiFEEBaiAHTw0CIA8gD0EEaiIPKAIANgIAIBBBAWoiECATSQ0ACwsgFSgCDCIbDQFBACEQDAULIBRBAWogB0G85swAEMMhAAtBACEQIAghDkEAIQ8DQAJAAkACQAJAAkACQCAJIA9HBEAgDigCACITIBJGDQUgDkEEaigCACIUIBZGIBMgFkZyIBIgFEZyDQUgDkEIaigCACEaIAgqAgwiHiAOQQxqKgIAIhxbDQEgHCAeXUUNAgwDCyAJIAlBjObMABDDIQALIAgoAgQgCCgCAGsgFCATa0sNAQsgCSAQSwRAIAggEEEEdGoiGCAcOAIMIBggGjYCCCAYIBQ2AgQgGCATNgIADAILIBAgCUGc5swAEMMhAAsgCCkCACEfIAggFDYCBCAIIBM2AgAgFUEYaiITIAhBCGoiFCkCADcDACAIIBw4AgwgFCAaNgIAIBUgHzcDECAJIBBNDQIgCCAQQQR0aiIUIBUpAxA3AgAgFEEIaiATKQMANwIACyAQQQFqIRALIA5BEGohDiAPQQFqIg8gG0cNAQwFCwsgECAJQazmzAAQwyEACyASIANB3OXMABDDIQALIBYgA0HM5cwAEMMhAAsgEiABQbzlzAAQwyEACyAVIBA2AgwCQCARQQFrIhFFDQBBACEOIAYhDwNAIAcgDkcEQCAAIAEgAiADIBIgDygCACANIAggCSAVQQxqENEIIA9BBGohDyAOQQFqIg4gF0cNAQwCCwsgByAHQfzlzAAQwyEACyAXQQFrIRcgCiARSQ0ACwsgCiAZIAogGUkbIRELIBVBIGokACARDwtBAEEAQazlzAAQwyEAC4EKAw5/A30BfiMAQSBrIhUkACAVQQA2AgwCQAJAIApFDQAgBkEEaiERA0ACQCAQIg5BAWoiECAKTw0AAkAgByAOSwRAIAYgDkECdGohEiARIQ8gECEODAELIA4gB0Hc5swAEMMhAAsDQCAHIA5HBEAgACABIAIgAyASKAIAIA8oAgAgDSAIIAkgFUEMahDTCCAPQQRqIQ8gDkEBaiIOIApHDQEMAgsLIAcgB0Hs5swAEMMhAAsgEUEEaiERIAogEEcNAAtBASERIApBAUYNACAJRQ0BIAohEUEBIQoDQCARQQFrIhkhFwNAIB0gCCoCDF8EQEOZdpZ+IR0gESAMIgpNDQMMAgsgCCgCACISIQ4CQCAIKAIEIhYiDyABSQRAIAEgDksEQCAAIA5BiBFsaiIQIBAoAoARIAAgD0GIEWxqIg8oAoARajYCgBFBACEOA0AgDiAQaiITIA4gD2ooAgAgEygCAGo2AgAgDkEEaiIOQYARRw0ACwwCCyAOIAFB7OrMABDDIQALIA8gAUHc6swAEMMhAAsCQCABIBJLBEAgACASQYgRbGogCCoCCDgChBEgAyAWSwRAIAMgEksEQCACIBJBAnRqIg4gDigCACACIBZBAnRqKAIAajYCACALBEBBACEPIAQhDgNAAkACQCAFIA9HBEAgDigCACAWRg0BDAILIAUgBUHM5swAEMMhAAsgDiASNgIACyAOQQRqIQ4gCyAPQQFqIg9HDQALC0EAIQ4gBiEPAkACQAJAAkADQCAHIA5HBEAgBiAOQQJ0aigCACAWRg0CIA9BBGohDyAOQQFqIg4gEUcNAQwDCwsgByAHQezlzAAQwyEACyARIA5Bf3NqIhNFDQBBACEQA0AgDiAQaiIUQQFqIAdPDQIgDyAPQQRqIg8oAgA2AgAgEEEBaiIQIBNJDQALCyAVKAIMIhsNAUEAIRAMBQsgFEEBaiAHQbzmzAAQwyEAC0EAIRAgCCEOQQAhDwNAAkACQAJAAkACQAJAIAkgD0cEQCAOKAIAIhMgEkYNBSAOQQRqKAIAIhQgFkYgEyAWRnIgEiAURnINBSAOQQhqKAIAIRogCCoCDCIeIA5BDGoqAgAiHFsNASAcIB5dRQ0CDAMLIAkgCUGM5swAEMMhAAsgCCgCBCAIKAIAayAUIBNrSw0BCyAJIBBLBEAgCCAQQQR0aiIYIBw4AgwgGCAaNgIIIBggFDYCBCAYIBM2AgAMAgsgECAJQZzmzAAQwyEACyAIKQIAIR8gCCAUNgIEIAggEzYCACAVQRhqIhMgCEEIaiIUKQIANwMAIAggHDgCDCAUIBo2AgAgFSAfNwMQIAkgEE0NAiAIIBBBBHRqIhQgFSkDEDcCACAUQQhqIBMpAwA3AgALIBBBAWohEAsgDkEQaiEOIA9BAWoiDyAbRw0BDAULCyAQIAlBrObMABDDIQALIBIgA0Hc5cwAEMMhAAsgFiADQczlzAAQwyEACyASIAFBvOXMABDDIQALIBUgEDYCDAJAIBFBAWsiEUUNAEEAIQ4gBiEPA0AgByAORwRAIAAgASACIAMgEiAPKAIAIA0gCCAJIBVBDGoQ0wggD0EEaiEPIA5BAWoiDiAXRw0BDAILCyAHIAdB/OXMABDDIQALIBdBAWshFyAKIBFJDQALCyAKIBkgCiAZSRshEQsgFUEgaiQAIBEPC0EAQQBBrOXMABDDIQALgQoDDn8DfQF+IwBBIGsiFSQAIBVBADYCDAJAAkAgCkUNACAGQQRqIREDQAJAIBAiDkEBaiIQIApPDQACQCAHIA5LBEAgBiAOQQJ0aiESIBEhDyAQIQ4MAQsgDiAHQdzmzAAQwyEACwNAIAcgDkcEQCAAIAEgAiADIBIoAgAgDygCACANIAggCSAVQQxqENIIIA9BBGohDyAOQQFqIg4gCkcNAQwCCwsgByAHQezmzAAQwyEACyARQQRqIREgCiAQRw0AC0EBIREgCkEBRg0AIAlFDQEgCiERQQEhCgNAIBFBAWsiGSEXA0AgHSAIKgIMXwRAQ5l2ln4hHSARIAwiCk0NAwwCCyAIKAIAIhIhDgJAIAgoAgQiFiIPIAFJBEAgASAOSwRAIAAgDkGICGxqIhAgECgCgAggACAPQYgIbGoiDygCgAhqNgKACEEAIQ4DQCAOIBBqIhMgDiAPaigCACATKAIAajYCACAOQQRqIg5BgAhHDQALDAILIA4gAUHs6swAEMMhAAsgDyABQdzqzAAQwyEACwJAIAEgEksEQCAAIBJBiAhsaiAIKgIIOAKECCADIBZLBEAgAyASSwRAIAIgEkECdGoiDiAOKAIAIAIgFkECdGooAgBqNgIAIAsEQEEAIQ8gBCEOA0ACQAJAIAUgD0cEQCAOKAIAIBZGDQEMAgsgBSAFQczmzAAQwyEACyAOIBI2AgALIA5BBGohDiALIA9BAWoiD0cNAAsLQQAhDiAGIQ8CQAJAAkACQANAIAcgDkcEQCAGIA5BAnRqKAIAIBZGDQIgD0EEaiEPIA5BAWoiDiARRw0BDAMLCyAHIAdB7OXMABDDIQALIBEgDkF/c2oiE0UNAEEAIRADQCAOIBBqIhRBAWogB08NAiAPIA9BBGoiDygCADYCACAQQQFqIhAgE0kNAAsLIBUoAgwiGw0BQQAhEAwFCyAUQQFqIAdBvObMABDDIQALQQAhECAIIQ5BACEPA0ACQAJAAkACQAJAAkAgCSAPRwRAIA4oAgAiEyASRg0FIA5BBGooAgAiFCAWRiATIBZGciASIBRGcg0FIA5BCGooAgAhGiAIKgIMIh4gDkEMaioCACIcWw0BIBwgHl1FDQIMAwsgCSAJQYzmzAAQwyEACyAIKAIEIAgoAgBrIBQgE2tLDQELIAkgEEsEQCAIIBBBBHRqIhggHDgCDCAYIBo2AgggGCAUNgIEIBggEzYCAAwCCyAQIAlBnObMABDDIQALIAgpAgAhHyAIIBQ2AgQgCCATNgIAIBVBGGoiEyAIQQhqIhQpAgA3AwAgCCAcOAIMIBQgGjYCACAVIB83AxAgCSAQTQ0CIAggEEEEdGoiFCAVKQMQNwIAIBRBCGogEykDADcCAAsgEEEBaiEQCyAOQRBqIQ4gD0EBaiIPIBtHDQEMBQsLIBAgCUGs5swAEMMhAAsgEiADQdzlzAAQwyEACyAWIANBzOXMABDDIQALIBIgAUG85cwAEMMhAAsgFSAQNgIMAkAgEUEBayIRRQ0AQQAhDiAGIQ8DQCAHIA5HBEAgACABIAIgAyASIA8oAgAgDSAIIAkgFUEMahDSCCAPQQRqIQ8gDkEBaiIOIBdHDQEMAgsLIAcgB0H85cwAEMMhAAsgF0EBayEXIAogEUkNAAsLIAogGSAKIBlJGyERCyAVQSBqJAAgEQ8LQQBBAEGs5cwAEMMhAAvQCQIFfwV+IwBBwAFrIgQkACABQQxqENk8IQggBEE4aiABEJI2EO4lIAhBBHQiByEFAkACQAJAAkACQCAHQTBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AlggBCAFNgJUIARBwAA2AlAgBwRAIAZBACAH/AsACyAEIAg2AmAgBCAHNgJcIAQoAjhFDQMgBCgCTCAEKAJIRg0EIARB8ABqIARBOGoQyDQgBEGQAWohBSACKQMIIQsgAikDACEMIAMtAAAhAiABKAIQIQMDQAJAIAQpA5gBIgpQRQRAIAQpA6ABIQkMAQsDQAJ+AkAgBCkDgAEiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDgAEgCadBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEJCyAJQgBSDQILIARCAzcDgAELIAQpA3AiCUICUQ0JIARCADcDcCAEKQN4DAELIAQpA7ABCyEKIAmnQQFxRQ0HIAQgBCkDoAFCQH0iCTcDoAEgBCAKNwOYASAKUA0ACwsgBEIBIAp6Ig2GIAqFNwOYASALIAyEUARAQYeAgIB4IQEMBwsgBEEgaiADIA2nIAmnaiIHQQF0ajIBACIJIAlCP4cgDCALEIMZIARBqAFqIAQpAyAiCSAEKQMoIgogAhCtDiAEKAKoASIBQZOAgIB4RwRAIAQpArQBIQkgBCkCrAEhCgwHBSAGIAdBBHRqIgEgCjcDCCABIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCSACKQMAIQogAy0AACEDIAEoAhAhAkEAIQUDQCAJIAqEUARAQYeAgIB4IQEMAwsgBEEQaiACMgEAIgsgC0I/hyAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAAL0AkCBX8FfiMAQcABayIEJAAgAUEMahDbPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0ECdGo0AgAiCSAJQj+HIAwgCxCDGSAEQagBaiAEKQMgIgkgBCkDKCIKIAIQrQ4gBCgCqAEiAUGTgICAeEcEQCAEKQK0ASEJIAQpAqwBIQoMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgCSAKhFAEQEGHgICAeCEBDAMLIARBEGogAjQCACILIAtCP4cgCiAJEIMZIARB8ABqIAQpAxAiCyAEKQMYIgwgAxCtDiAEKAJwIgFBk4CAgHhHBEAgBCkCfCEJIAQpAnQhCgwDCyAGIAs3AwAgBiAMNwMIIAZBEGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQfAAaiICEJcpIARB2ABqIgEoAgAhBiAEKAJcIQMgASAEQfgAaiIFKQIANwMAIAQpA1AhCSAEIAQpAnA3A1AgBEEANgJgIAQgCTcCfCAEQQA2AnggBCADNgJ0IAQgBjYCcCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAFKQIANwIAIAFBGGogBEGAAWoiBygCADYCACAEIAM2ArABIAQgBjYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOIZIAcgBEHIAGopAgA3AwAgBSAEQUBrKQIANwMAIAQgBCkCODcDcCAAIAEgAhDLHSAEQdAAahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEHQAGoQzy8gBCgCOCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQThqEPseCyAEQcABaiQAC9AJAgV/BX4jAEHAAWsiBCQAIAFBDGoQ2DwhCCAEQThqIAEQkjYQ7iUgCEEEdCIHIQUCQAJAAkACQAJAIAdBMHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCWCAEIAU2AlQgBEHAADYCUCAHBEAgBkEAIAf8CwALIAQgCDYCYCAEIAc2AlwgBCgCOEUNAyAEKAJMIAQoAkhGDQQgBEHwAGogBEE4ahDINCAEQZABaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDmAEiClBFBEAgBCkDoAEhCQwBCwNAAn4CQCAEKQOAASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOAASAJp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQkLIAlCAFINAgsgBEIDNwOAAQsgBCkDcCIJQgJRDQkgBEIANwNwIAQpA3gMAQsgBCkDsAELIQogCadBAXFFDQcgBCAEKQOgAUJAfSIJNwOgASAEIAo3A5gBIApQDQALCyAEQgEgCnoiDYYgCoU3A5gBIAsgDIRQBEBBh4CAgHghAQwHCyAEQSBqIAMgDacgCadqIgdBA3RqKQMAIgkgCUI/hyAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIpAwAiCyALQj+HIAogCRCDGSAEQfAAaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCcCIBQZOAgIB4RwRAIAQpAnwhCSAEKQJ0IQoMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEHwAGoiAhCXKSAEQdgAaiIBKAIAIQYgBCgCXCEDIAEgBEH4AGoiBSkCADcDACAEKQNQIQkgBCAEKQJwNwNQIARBADYCYCAEIAk3AnwgBEEANgJ4IAQgAzYCdCAEIAY2AnAgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogBSkCADcCACABQRhqIARBgAFqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDiGSAHIARByABqKQIANwMAIAUgBEFAaykCADcDACAEIAQpAjg3A3AgACABIAIQyx0gBEHQAGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAE2AgQgAEEpOgAAIARB0ABqEM8vIAQoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEE4ahD7HgsgBEHAAWokAAubCQIDfwJ+IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQZithgEoAgA2AgAgBEGQrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFPDQkgBCAAKAIQIAJBA3RqKQMAIgc3AwggBEFAa0GYrYYBKAIANgIAIARBkK2GASkCADcDOCAHIAdCgJTr3AN/IgdCgJTr3AN+fSIIQgBTDQUgB6ciAEH/ogVLDQUgBEE4aiIBEMkMIAQgCD4CLCAEIAA2AiggBEEBNgI8IARB9JuEATYCOCAEQgE3AkQgBEGUDDYCGCAEIARBFGo2AkAgBCAEQShqNgIUIAMoAgAgAygCBCABEMsKIQIMCAsgBEFAa0GYrYYBKAIANgIAIARBkK2GASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQZithgEoAgA2AgAgBEGQrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBmK2GASgCADYCACAEQZCthgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC5kJAgN/An4jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtB6KyGASgCADYCACAEQeCshgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCAEQUBrQeishgEoAgA2AgAgBEHgrIYBKQIANwM4IARBOGoiAhDJDCAHQsCEPX8iCKciAEH/ogVLDQUgByAIQsCEPX59p0HoB2wiAUH/p9a5B0sNBSAEIAE2AiwgBCAANgIoIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AhggBCAEQRRqNgJAIAQgBEEoajYCFCADKAIAIAMoAgQgAhDLCiECDAgLIARBQGtB6KyGASgCADYCACAEQeCshgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEFAa0HorIYBKAIANgIAIARB4KyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRRqEOUQDAULIARBKGogAxC4HCECDAQLIAQgACgCECACQQN0aikDADcDACAEQUBrQeishgEoAgA2AgAgBEHgrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIARBOGoQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC8UKAgN/AX4jAEHAAWsiAyQAIANBhAFqIAEgAhCTDiADKAKIASEEAkAgAygChAEiBUGKgICAeEcEQCADQSxqIANBpAFqKAIANgIAIANBJGogA0GcAWopAgA3AgAgA0EcaiADQZQBaikCADcCACADIAMpAowBNwIUIAMgBDYCECADIAU2AgwMAQsgA0GEAWogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0GQAWopAgA3AwAgAyADKQKIATcDMCADKAKEASIEQYqAgIB4RwRAIANBKGogA0GgAWopAgA3AgAgA0EYaiABKQMANwIAIAMgAykCmAE3AiAgAyADKQMwNwIQIAMgBDYCDAwBCyADQcgAaiABKQMANwMAIAMgAykDMDcDQCADQYQBaiADQUBrQQQQ3RAgAygCjAEhASADKAKIASEEAkACfiADKAKEASIFQYqAgIB4RwRAIANBsAFqIANBoAFqKQIANwMAIAMgAykCmAE3A6gBIAMpApABDAELIARBAXFFDQECQCABQQFxBEAgAyABNgKgASADQQM2ApwBIANBueT+ADYCmAEgA0GAgICAeDYClAEgA0IENwKMASADQoSAgIAINwKEAQwBC0F/IAFBAmoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBAmoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYChAEMAgsgA0GIgICAeDYChAEMAQsgA0GEAWogASAFEL8vCyADQQQ2ArgBIANBuef+ADYCtAEgA0GAgICAeDYCsAEgAyABNgKsASADQQE2AqgBIANB4ABqIANBhAFqIANBqAFqEIEUIAMoAmAiBUGKgICAeEYNASADQbABaiADQfwAaikCADcDACADIAMpAnQ3A6gBIAMoAmghASADKAJkIQQgAykCbAshBiADQShqIANBsAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA6gBNwIgDAELIAMgAykDSDcCWCADIAMpA0A3AlAgA0GEAWogA0HQAGpBBhDdECADKAKMASEBIAMoAogBIQQCQAJ+IAMoAoQBIgVBioCAgHhHBEAgA0GwAWogA0GgAWopAgA3AwAgAyADKQKYATcDqAEgAykCkAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2AqABIANBAzYCnAEgA0G85P4ANgKYASADQYCAgIB4NgKUASADQgQ3AowBIANChICAgAg3AoQBDAELQX8gAUEEaiIEIAEgBEsbIgUgAygCUCIEKAIETQRAIAQgBCgCFEEEaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKEAQwCCyADQYiAgIB4NgKEAQwBCyADQYQBaiABIAUQvy8LIANBCDYCuAEgA0GR5/4ANgK0ASADQYCAgIB4NgKwASADIAE2AqwBIANBATYCqAEgA0HgAGogA0GEAWogA0GoAWoQgRQgAygCYCIFQYqAgIB4Rg0BIANBsAFqIANB/ABqKQIANwMAIAMgAykCdDcDqAEgAygCaCEBIAMoAmQhBCADKQJsCyEGIANBKGogA0GwAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDqAE3AiAMAQsgAygCUCIBIAEoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0EKNgKUASADQYXp/gA2ApABIANBgICAgHg2AowBIAMgAjYCiAEgA0ECNgKEASAAIANBDGogA0GEAWoQgRQgA0HAAWokAAvACAEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjQgAiAAQQJ2IgBPDQsgBCABKAIQIAJBAnRqKAIANgIwIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEwaiADEMwkIQIMCgsgBEEwaiADENMcIQIMCQsgACgCBCgCFCEAIAQgAjYCNCACIABBAnYiAE8NCiAGKAIEIgBFDQIgBEEcaiAAQQhqIAYoAggQihggBCgCHEGTgICAeEcNAyAEQUBrQeCthgEoAgA2AgAgBEHYrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBAnYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQJ2IgFPDQcgBCAAKAIQIAJBAnRqKAIAIgCsNwMIIARBQGtB4K2GASgCADYCACAEQdithgEpAgA3AzggBEE4aiICEMkMIABB6AdtIgFB/6IFSw0FIAAgAUHoB2xrQcCEPWwiAEH/p9a5B0sNBSAEIAA2AhggBCABNgIUIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AiAgBCAEQRxqNgJAIAQgBEEUajYCHCADKAIAIAMoAgQgAhDLCiECDAYLIARBQGtB4K2GASgCADYCACAEQdithgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEFAa0HgrYYBKAIANgIAIARB2K2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRxqEOUQDAMLIARBMGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQUBrQeCthgEoAgA2AgAgBEHYrYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIAQ2AhwgAygCACADKAIEIAAQywohAgwBCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIARBCGo2AhwgAygCACADKAIEIARBOGoQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AhQMAQsgBCAANgIUCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiggBEE7NgIgIAQgBEEcajYCQCAEIARBFGo2AiQgBCAEQTRqNgIcIARBOGpByJeEARDvLAALyQkCBX8FfiMAQcABayIEJAAgAUEMaigCCCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQcgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEBA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAcQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEFDAcLIARBIGogASANpyAJp2oiA2owAAAiCSAJQj+HIAwgCxCDGSAEQagBaiAEKQMgIgkgBCkDKCIKIAIQrQ4gBCgCqAEiBUGTgICAeEcEQCAEKQK0ASEJIAQpAqwBIQoMBwUgBiADQQR0aiIDIAo3AwggAyAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAiABKAIQIQNBACEBA0AgCSAKhFAEQEGHgICAeCEFDAMLIARBEGogASADajAAACILIAtCP4cgCiAJEIMZIARB8ABqIAQpAxAiCyAEKQMYIgwgAhCtDiAEKAJwIgVBk4CAgHhHBEAgBCkCfCEJIAQpAnQhCgwDCyAGIAs3AwAgBiAMNwMIIAZBEGohBiAIIAFBAWoiAUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDYPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0EDdGopAwBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIpAwBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDbPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0ECdGo1AgBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAI1AgBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDZPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0EBdGozAQBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIzAQBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALvAgBA38jAEHgAGsiBCQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgJYIAIgAEEFdiIATw0IIAQgASgCECACQQV0aiIAKQMYNwNIIAQgACkDEDcDQCAEIAApAwg3AzggBCAAKQMANwMwIARBMGogAxD/IyECDAoLIAAoAgQiACgCFCEBIAQgAjYCWCACIAFBBXYiAU8NCiAEQTBqIgEgACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjBFDQggBigCBCIARQ0EIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQIgBEE4akHErIYBKAIANgIAIARBvKyGASkCADcDMCABEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAEQ0TkMAwsgACgCBCIAKAIUIQEgBCACNgJYIAIgAUEFdiIBTw0JIARBMGogACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjANBEGsnIQBELI7AAsgACgCBCIAKAIUIQEgBCACNgJYIAIgAUEFdiIBTw0IIARBMGogACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjANBEH8nIQBELI7AAsgBEE4akHErIYBKAIANgIAIARBvKyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRxqEOUQDAULIARBOGpBxKyGASgCADYCACAEQbyshgEpAgA3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBAsgBCAEKQM4NwMIIARBOGpBxKyGASgCADYCACAEQbyshgEpAgA3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiggBCAFNgIkIARB7gY2AiAgBCAEQRxqNgI4IAQgBEEIajYCHCADKAIAIAMoAgQgABDLCiECDAMLIAQgBCkDODcDECAEQThqQcSshgEoAgA2AgAgBEG8rIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCOCAEIARBEGo2AhwgAygCACADKAIEIAAQywohAgwCCyAEIAA2AlwMAwtB2JuEARCyOwALIARB4ABqJAAgAg8LIAQgATYCXAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIoIARBOzYCICAEIARBHGo2AjggBCAEQdwAajYCJCAEIARB2ABqNgIcIARBMGpByJeEARDvLAALtQgCA38IfiMAQaACayIJJAAgCSAENwO4ASAJIAM3A7ABIAkgAjcDqAEgCSABNwOgASAJIAg3A9gBIAkgBzcD0AEgCSAGNwPIASAJIAU3A8ABIAACfwJAAn4gASADhCACIASEhFAEQEIADAELQgAgBSAHhCAGIAiEhFANABogByAIQj+HIgeFIg0gCEI/iHwiDCAFIAeFIg4gB1QiCiAGIAeFIg8gB1QgBlAbrSIGfSEFIAwgDVStIAcgCIV8IAYgDFatfSEGIAMgBEI/hyIDhSIQIARCP4h8IgwgASADhSIRIANUIgsgAiADhSISIANUIAJQG60iAX0iDSAMIBBUrSADIASFfCABIAxWrX0iDIRQRSAFIAaEQgBScQ0BIAlBkAFqIA4gB30iAUIAIBEgA30iAkIAEKgeIAlB8ABqIAFCACASIAN9IAutfSIDQgAQqB4gCUGAAWogDyAHfSAKrX0iB0IAIAJCABCoHiAJQeAAaiAHQgAgA0IAEKgeIAlBMGogDEIAIAFCABCoHiAJQUBrIAdCACANQgAQqB4gCUHQAGogDUIAIAFCABCoHiAMQgBSIAdCAFJxIAkpAzhCAFJyIAkpA0hCAFJyIAkpA1giASAJKQMwIAkpA0B8fCIHIAFUcg0BIAkpA3AhDCAJKQOYASEBIAkpA3ggCSkDYCEOIAkpA2ghDyAJKQOAASEQIAkpA4gBIREgCSkDUCESIAkpA5ABIRMgCSADQgAgBUIAEKgeIAlBEGogBkIAIAJCABCoHiAJQSBqIAJCACAFQgAQqB4gA0IAUiAGQgBScSAJKQMIQgBSciAJKQMYQgBSciAJKQMoIgIgCSkDACAJKQMQfHwiBiACVHINASABIAEgDHwiAVatfCIMIA58IgIgESABIBB8IgMgAVStfHwiASASfCIFIAFUIgogCq0gASACVK0gDyACIAxUrXx8IgIgB3x8IgEgAlQgASACURsNASAFIAUgCSkDIHwiBVYiCiAKrSABIAZ8fCICIAFUIAEgAlEbDQEgAiAEIAiFIgRCP4ciAYUgAX0gASAFhSICIAFUrX0gAiABfSICIAEgE4UiBSABVCIKIAEgA4UiBiABVCADUButIgNUrX0iDiAEhUIAUw0BIAIgA30hDyAGIAF9IAqtfSENIAUgAX0LIQwgACAPNwMgIAAgDDcDECAAIA43AyggACANNwMYQQAMAQsgCUECNgL8ASAJQayQ/wA2AvgBIAlCAjcChAIgCUGDDDYCnAIgCUGDDDYClAIgCSAJQZACajYCgAIgCSAJQcABajYCmAIgCSAJQaABajYCkAIgCUHoAWogCUH4AWoQmQ4gCUGIgICAeDYC5AEgACAJKQLkATcCBCAAQQxqIAlB7AFqKQIANwIAIABBFGogCUH0AWooAgA2AgBBAQs2AgAgCUGgAmokAAvICQILfwN+IwBBwARrIgIkAAJAAkAgASkDACINQgJWDQACQAJAIA2nQQFrDgICAAELIAEpAxBQRQRAIAFBGGohBSACQQxqIQggAkEwaiEKIAJBGGohBCACQdgCaiELIAJBwAJqIQMgAkGwAmpBBHIhCQNAAkACQAJAIAUoAgAiBgRAIAJBsAJqIgcgBhDgFCACKAKwAkEIRg0BIAUQny8gBUEANgIAIAIoArACQQhGDQMgBxDJIwwDCyACQbACaiABKAJAQQhqIAEpAwgQ4TAgBCAJQQhqKQIANwMAIAIgCSkCADcDECACKAKwAiIGQQhHBEAgAigCxAIhASAAIAIpAxA3AgQgACABNgIUIAAgBjYCACAAQQxqIAJBGGopAwA3AgAMCAsgAkEIaiAEKQMANwMAIAIgAikDEDcDACACQbACaiACIAEoAhwgAS0AIBDxEwJAAkAgAikDuAIiDUIEUQRAIAJBqAJqIANBEGopAwAiDTcDACACQaACaiADQQhqKQMAIg43AwAgAiADKQMAIg83A5gCIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAELIAJBoAJqIgcgA0EIaikDADcDACACQagCaiIMIANBEGopAwA3AwAgAiADKQMANwOYAiACKAKwAiEGIAogC0HoAfwKAAAgBEEQaiAMKQMANwMAIARBCGogBykDADcDACAEIAIpA5gCNwMAIAIgDTcDECACQbACaiAGIAEpAxAQjhogAigCsAIiB0EIRg0BIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBzYCACACQRBqEPwsCyAIIAIoAgQgAigCCCACKAIAKAIQEQEADAgLIAEgBq0iDSABKQMIfDcDCCABIAEpAxAgDX03AxAgAkGwAmoiBiACQRBqIgcQ4BQgAigCsAJBCEYEQCACQagCaiIDIAJBxAJqKAIANgIAIAJBoAJqIgQgAkG8AmopAgA3AwAgAiACKQK0AjcDmAIgBiAHQYgC/AoAAEGIAkEIEK02IgFFDQIgASAGQYgC/AoAACAFEJ8vIABBCDYCACAFIAE2AgAgACACKQOYAjcCBCAAQQxqIAQpAwA3AgAgAEEUaiADKAIANgIAIAggAigCBCACKAIIIAIoAgAoAhARAQAMCAsgAkGwAmoQySMgAkEQahD8LCAIIAIoAgQgAigCCCACKAIAKAIQEQEADAILIAAgAikCtAI3AgQgAEEINgIAIABBFGogAkHEAmooAgA2AgAgAEEMaiACQbwCaikCADcCAAwGC0EIQYgCEKM9AAsgASkDEFBFDQALCyAAQoiAgIAgNwMADAILIAFBIGoiAygCDAR/IAMoAgQgAygCCCIFIAMoAgAiA0EAIAMgBU0ba0EYbGoFQQALIgMEQCABKAIsIgVBAk8EQCABKAIkIAEoAihBAWoiBCABKAIgIghBACAEIAhPG2tBGGxqKAIIIQQLIABBADoAFCAAQQA2AgwgAEKIgICAEDcDACAAIAQgASgCMCAFQQFLGyADKAIIazYCCAwCCyAAQoiAgIAgNwMADAELIABBAToAFCAAQQA2AgwgAEIINwMACyACQcAEaiQAC9gOAwd/A34BbyMAQZABayICJAAgAiABNgIIIAJBMGogAkEIahDHEiACKAIwIQECQAJAAkACQAJAAkACQCACLQA0IgNBAmsOAgIAAQsgAEEANgIAIAAgATYCBCACKAIIIgBBgwFLDQMMBAsgAiADOgAYIAIgATYCFCACQQA2AgwgAkHQAGpBwMbMABClKyACQgA3AzggAkEANgI0IAJB+MbMADYCMCACIAIpA1g3A0ggAiACKQNQNwNAAkADQAJAIAJB+ABqIQMjAEEgayIBJAAgAUEIaiACQQxqIgRBCGoQ/CkCQAJAIAEoAggiBkECRwRAIAEoAgwhBSAGQQFxBEAgA0GBgICAeDYCACADIAU2AgQMAwsgASAFEKQlIAEoAgQhBSABKAIAIQYCQCAEKAIARQ0AIAQoAgQiB0GEAUkNACAHEPIfCyAEIAU2AgQgBEEBNgIAIAFBFGogBhDdGyABKAIUIgRBgICAgHhHDQEgASgCGCEEIANBgYCAgHg2AgAgAyAENgIEDAILIANBgICAgHg2AgAMAQsgAyABKQIYNwIEIAMgBDYCAAsgAUEgaiQAAkACQAJAAkAgAigCeCIBQYCAgIB4aw4CBAABCyACKAJ8IQEMAQsgAiACKQJ8Igk3AogBIAIgATYChAEgAigCDCACQQA2AgxFDQkgAkHQAGogAigCEBDdGyACKAJQQYCAgIB4Rw0BIAIoAlQhASACQYQBahDeOwsgAEEANgIAIAAgATYCBCACQTBqEJMnDAMLIAJB8ABqIAJB2ABqKAIANgIAIAIgAikCUDcDaCACIAk3AiggAiABNgIkIAJB0ABqIgEgAkEwaiACQSRqIAJB6ABqEM4JIAEQhjAMAQsLIAAgAikDMDcDACAAQRhqIAJByABqKQMANwMAIABBEGogAkFAaykDADcDACAAQQhqIAJBOGopAwA3AwALIAIoAhQiAEGEAU8EQCAAEPIfCyACKAIMRQ0BIAIoAhAiAEGEAUkNASAAEPIfDAELIAJBCGoiARCqOwR/IAEoAgAlARBMIQwQ3xIiASAMJgFBAQVBAAshAyACIAE2AgQgAiADNgIAIAIoAgBBAXEEQCACIAIoAgQ2AiQgAkEUaiACQSRqENEvQQAhAyACQQA2AiAgAkEANgIMQQAhASACKAIUBEAgAigCHCIBIAIoAhhrIgRBACABIARPGyEBCyACQdAAakHAxswAEKUrIAIpA1ghCiACKQNQIQsCQCABRQRAQfjGzAAhAQwBCyACQdAAaiACQYQBakEYQQggAUEPTwR/QX9BqtUCIAEgAUGq1QJPG0EDdEEHbkEBa2d2QQFqBUEEQQhBECABQQhJGyABQQRJGwsQnRQgAigCVCEDIAIoAlAiAUUEQCACNQJYIQlBACEBDAELIAIpAlghCSADQQlqIgRFDQAgAUH/ASAE/AsACyACIAo3A0ggAiALNwNAIAIgCTcDOCACIAM2AjQgAiABNgIwIAJB3ABqIQYCQAJAA0ACQCACQdAAaiEDIwBBQGoiASQAIAFBBGohB0EAIQgjAEEQayIEJAACQCACQQxqIgUoAghFDQAgBEEIaiAFQQhqELsoIAQoAghBAXFFDQAgBCAEKAIMEKQlIAcgBCkDADcCBCAFIAUoAhRBAWo2AhRBASEICyAHIAg2AgAgBEEQaiQAAkAgASgCBEEBRgRAIAEoAgwhBCABQRxqIAEoAggQ3RsgASgCHEGAgICAeEYEQCADIAEoAiA2AgQgA0GBgICAeDYCACAEQYQBSQ0CIAQQ8h8MAgsgAUEYaiIFIAFBJGoiBygCADYCACABIAEpAhw3AxAgAUEcaiAEEN0bIAEoAhxBgICAgHhGBEAgAyABKAIgNgIEIANBgYCAgHg2AgAgAUEQahDeOwwCCyABQTxqIAcoAgA2AgAgAUEwaiIEIAUoAgA2AgAgASABKQIcNwI0IAMgASkDECIJNwIAIANBCGogBCkDADcCACADQRBqIAFBOGopAwA3AgAgASAJNwMoDAELIANBgICAgHg2AgALIAFBQGskAAJAAkAgAigCUCIBQYCAgIB4aw4CAgABCyAAIAIoAlQ2AgQgAEEANgIAIAJBMGoQkycgAigCDEUNBCACKAIQIgBBgwFLDQMMBAsgAkGAAWogBkEIaigCADYCACACIAIpAlQ3AmwgAiABNgJoIAIgBikCADcDeCACQYQBaiIBIAJBMGogAkHoAGogAkH4AGoQzgkgARCGMAwBCwsgACACKQMwNwMAIABBGGogAkHIAGopAwA3AwAgAEEQaiACQUBrKQMANwMAIABBCGogAkE4aikDADcDACACKAIMRQ0BIAIoAhAiAEGEAUkNAQsgABDyHwsgAigCJCIAQYQBSQ0BIAAQ8h8MAQsgAkEIaiACQYQBakGAxcwAENELIQEgAEEANgIAIAAgATYCBAsgAigCCCIAQYQBSQ0BCyAAEPIfCyACQZABaiQADwtBsMfMAEExEJc9AAvKJAIbfwV+IwBB4ABrIgYkAAJAAkACQCABKAJgIgVBgICAgHhHBEAgAS0AcUUNAiABKAJkIRAgBkEYaiIIIAEoAmgiCUEAQQRBDBCgGCAGKAIcIQQgBigCGEEBRwRAIAFBEGpBACAFQYCAgIB4RxshDyAGQQA2AgggBiAGKAIgNgIEIAYgBDYCACAJRQ0CIBAgCUEGdGohHCAIQQRyIRUDQCAGQRhqIBAoAihBAEEEQRgQoBggBigCHCEJAkACQAJAAkACQCAGKAIYQQFHBEAgBkEANgIUIAYgBigCIDYCECAGIAk2AgwgECgCKCIJRQ0FIAlBwAJsIRkgECgCJEHEAWohEQNAAkACQCARQZQBaygCAEEBRw0AIBFBjAFrKQMAIh9CAFMNACARQQRrKAIAQQFHDQAgESgCACIEQQBIDQAgHyADfSIfQv////8PWA0BIAZBATYCPCAGQay+zQA2AjggBkIBNwJEIAZBpgQ2AlggBiAGQdQAajYCQCAGIAZB3wBqNgJUIABBBGogBkE4ahCZDiAAQQA2AgAMBwsgBkE4akEUQQBBAUEBEKAYIAYoAjwhCSAGKAI4QQFGDQMgBigCQCECIAZBADYCICACQRBqQdj1zwAoAAA2AAAgAkEIakHQ9c8AKQAANwAAIAJByPXPACkAADcAACAGQRQ2AiwgBiACNgIoIAYgCTYCJCAGQQE2AhgMBQsgHyAErXwiIEKAgICAEFoEQCAGQQE2AjwgBkGsvs0ANgI4IAZCATcCRCAGQaYENgJYIAYgBkHUAGo2AkAgBiAGQd8AajYCVCAAQQRqIAZBOGoQmQ4gAEEANgIADAYLIAIoAggiCSAgpyIFSQ0DIAZBGGohEiACKAIEIB+naiEFIwBBQGoiCSQAIAkgBSAEEJ0fIAlBKGohCCMAQaABayIEJAAgBEHoAGogCRDwJyAEQdAAaiIFIARB9ABqIgcoAgA2AgAgBCAEKQJsNwNIAkAgBCgCaCILQQRHBEAgBCgCeCEHIAggBCkDSDcCCCAIIAc2AhQgCCALNgIEIAhBgICAgHg2AgAgCEEQaiAFKAIANgIADAELIARBMGogBSgCADYCACAEIAQpA0g3AyggBEEoahCGMCAEQYCAgIB4NgIIIARBgICAgHg2AhggBEHoAGogCRDTCSAFIAcpAgA3AwAgBEHYAGoiFiAEQfwAaigCADYCACAEIAQpAmw3A0gCQAJAIAQoAmhFBEAgBEHMAGohFCAEQfAAaiEXIARB7ABqIRgDQCAEQThqIBYoAgAiBTYCACAEQTBqIARB0ABqIhopAwA3AwAgBCAEKQNINwMoAkACQAJAAkACQCAFQf8BcQRAIARB6ABqIARBKGoQ/BcgBC8BbCEFIAQoAmgiB0EERwRAIAggBCkBbjcBCiAIQRBqIARB9ABqKQEANwEAIAggBTsBCCAIIAc2AgQgCEGAgICAeDYCAAwJCwJAAkACQCAFQQFrDgIAAQILIARB6ABqIAkQyQ8gBCgCbCELIAQoAmgiBUEERwRAIAggBCkAcTcADSAIQRRqIARB+ABqKAAANgAAIAggBC0AcDoADCAIIAs2AgggCCAFNgIEIAhBgICAgHg2AgAMCwsgBEHoAGogC0EAQQhBGBCgGCAEKAJsIQUgBCgCaEEBRg0DIARBADYCRCAEIAQoAnA2AkAgBCAFNgI8IAtBAEwNBgNAIARB6ABqIQdCACEfQQAhDEEAIRtCACEiQgAhIEIAISEjAEHwAGsiBSQAIAVB2ABqIAkQ8CcgBUHIAGoiDSAFQeQAaiIKKAIANgIAIAUgBSkCXDcDQAJAIAUoAlgiE0EERwRAIAUoAmghDCAHIAUpA0A3AgggByAMNgIUIAcgEzYCBCAHQQE2AgAgB0EQaiANKAIANgIADAELIAVBMGogDSgCADYCACAFIAUpA0A3AyggBUEoahCGMCAFQdgAaiAJENMJIA0gCikCADcDACAFQdAAaiIKIAVB7ABqKAIANgIAIAUgBSkCXDcDQAJAAkAgBSgCWEUEQCAFQdwAaiETQQAhDQNAIAVBOGogCigCACIONgIAIAVBMGogBUHIAGoiHSkDADcDACAFIAUpA0A3AygCQCAOQf8BcQRAIAVB2ABqIAVBKGoQ/BcgBS8BXCEOIAUoAlgiHkEERwRAIAcgBSkBXjcBCiAHQRBqIAVB5ABqKQEANwEAIAcgDjsBCCAHIB42AgQMBgsCQAJAAkACQCAOQQFrDgMBAAIDCyAFQdgAaiAJEMAcIAUoAlhFBEAgBSgCYCEMQQEhDQwFCyAFKQNgIiOnIQxBASENIAUoAlwiDkEERg0EIAcgBSkDaDcDECAHIAw2AgggByAONgIEIAcgI0IgiD4CDAwICyAFQdgAaiAJEMAcIAUoAlhFBEAgBSkDYCEgQgEhHwwECyAFKAJcIQwgBSkDYCEfIAcgBSkDaDcDECAHIB83AwggByAMNgIEDAcLIAVB2ABqIAkQwBwgBSgCWA0FIAUpA2AhIUEBIRtCASEiDAILIAVB2ABqIAkgBS0AOEHAABDJAiAFKAJYIg5BBEYNASAHIAUpAlw3AgggB0EQaiAFQeQAaikCADcCACAHIA42AgQMBQsgBSAhNwMgIAUgIjcDGCAFIAw2AhQgBSANNgIQIAUgIDcDCCAFIB83AwAgBUEoahCGMCAFQdgAaiAJEKgpIAUoAlgiCkEERwRAIAcgBSkCXDcCCCAHQRBqIAVB5ABqKQIANwIAIAdBATYCACAHIAo2AgQMBgsgBUHYAGpB8pXQAEETIAUQ5h4gBSgCWCIKQQRHBEAgByAFKQJcNwIIIAdBEGogBUHkAGopAgA3AgAgB0EBNgIAIAcgCjYCBAwGCyAFQdgAakGFltAAQSEgBUEQahDmHiAFKAJYIgpBBEcEQCAHIAUpAlw3AgggB0EQaiAFQeQAaikCADcCACAHQQE2AgAgByAKNgIEDAYLIAVB2ABqQaaW0ABBHCAFQRhqEOYeIAUoAlgiCkEERwRAIAcgBSkCXDcCCCAHQRBqIAVB5ABqKQIANwIAIAdBATYCACAHIAo2AgQMBgsCQAJAIB9QRQRAIA1FDQEgG0UNAiAHIAw2AhggByAhNwMQIAcgIDcDCCAHQQA2AgAMCAtB+PzPAEHHAEHEltAAEMskAAtB+PzPAEHHAEHUltAAEMskAAtB+PzPAEHHAEHkltAAEMskAAsgBUEoahCGMCAFQdgAaiAJENMJIB0gE0EIaikCADcDACAKIBNBEGooAgA2AgAgBSATKQIANwNAIAUoAlhFDQALCyAHIAUpA0A3AgQgB0EBNgIAIAdBFGogCigCADYCACAHQQxqIAVByABqKQMANwIADAILIAUoAlwhDCAFKQNgIR8gByAFKQNoNwMQIAcgHzcDCCAHIAw2AgQLIAdBATYCACAFQShqEIYwCyAFQfAAaiQAIAQoAmgEQCAEQdgAaiAEQfwAaigCACIFNgIAIARB0ABqIARB9ABqKQIAIh83AwAgBCAEKQJsIiA3A0ggCEEUaiAFNgIAIAhBDGogHzcCACAIICA3AgQgCEGAgICAeDYCACAEQTxqQQhBGBDgHgwMCyAUIBcpAgA3AgAgFEEQaiIFIBdBEGopAgA3AgAgFEEIaiIHIBdBCGopAgA3AgAgBEGQAWoiDCAHKQIANwMAIARBmAFqIg0gBSkCADcDACAEIBQpAgA3A4gBIAQoAkQiByAEKAI8RgRAIwBBEGsiBSQAIAVBCGogBEE8aiIKIAooAgBBAUEIQRgQtxEgBSgCCCIKQYGAgIB4RwRAIAogBSgCDEGEl9AAEP0vAAsgBUEQaiQACyAEKAJAIAdBGGxqIgUgBCkDiAE3AwAgBUEIaiAMKQMANwMAIAVBEGogDSkDADcDACAEIAdBAWo2AkQgC0EBayILDQALDAYLIARB6ABqIAkQyQ8gBCgCbCELIAQoAmgiBUEERwRAIAggBCkAcTcADSAIQRRqIARB+ABqKAAANgAAIAggBC0AcDoADCAIIAs2AgggCCAFNgIEIAhBgICAgHg2AgAMCgsgBEHoAGogC0EAQQhBCBCgGCAEKAJsIQUgBCgCaEEBRg0DIARBADYCUCAEIAQoAnA2AkwgBCAFNgJIIAtBAEoEQANAIARB6ABqIAkQwBwgBCgCaARAIAQoAmwhBSAEKQNwIR8gCCAEKQN4NwIQIAggHzcCCCAIIAU2AgQgCEGAgICAeDYCACAEQcgAahDjPAwMCyAEKQNwIR8gBCgCUCIFIAQoAkhGBEAgBEHIAGpBpJfQABCzKAsgBCgCTCAFQQN0aiAfNwMAIAQgBUEBajYCUCALQQFrIgsNAAsLIARB8ABqIgUgGigCADYCACAEIAQpAkg3A2ggBEEYahCFMCAEQSBqIAUoAgA2AgAgBCAEKQNoNwMYDAYLIARB6ABqIAkgBC0AOEHAABDJAiAEKAJoIgVBBEYNBSAIIAQpAmw3AgggCEEQaiAEQfQAaikCADcCACAIQYCAgIB4NgIAIAggBTYCBAwICyAEQShqEIYwIARB6ABqIAkQqCkgBCgCaCIFQQRHBEAgCCAEKQJsNwIIIAhBEGogBEH0AGopAgA3AgAgCEGAgICAeDYCACAIIAU2AgQMCQsgBEHoAGpBtJfQAEEaIARBCGoQ9R0gBCgCaCIFQQRHBEAgCCAEKQJsNwIIIAhBEGogBEH0AGopAgA3AgAgCEGAgICAeDYCACAIIAU2AgQMCQsgBCgCCCIFQYCAgIB4Rg0CIAggBCkDGDcCDCAIIAQpAgw3AgQgCCAFNgIAIAhBFGogBEEgaigCADYCAAwJCyAFIAQoAnBB9JbQABD9LwALIAUgBCgCcEGUl9AAEP0vAAtB+PzPAEHHAEHQl9AAEMskAAsgBEHwAGoiBSAEQcQAaigCADYCACAEIAQpAjw3A2ggBCgCCEGAgICAeEcEQCAEQQhqQQhBGBDgHgsgBEEQaiAFKAIANgIAIAQgBCkDaDcDCAsgBEEoahCGMCAEQegAaiAJENMJIBogGEEIaikCADcDACAWIBhBEGooAgA2AgAgBCAYKQIANwNIIAQoAmhFDQALCyAIIAQpA0g3AgQgCEGAgICAeDYCACAIQRRqIBYoAgA2AgAgCEEMaiAEQdAAaikDADcCAAwBCyAEQShqEIYwCyAEQRhqEIUwIAQoAghBgICAgHhGDQAgBEEIakEIQRgQ4B4LIARBoAFqJAAgCUEgaiIEIAlBPGooAgA2AgAgCSAJKQI0NwMYIAkpAiwhHwJ/IAkoAigiBUGAgICAeEYEQCAJQThqIAQoAgA2AgAgCSAJKQMYNwMwIAkgHzcDKCASQQhqIAgQpSVBAQwBCyASIAkpAxg3AhAgEkEYaiAEKAIANgIAIBIgHzcDCCASIAU2AgRBAAshBCAJEJ08IBIgBDYCACAJQUBrJAAgBigCGA0EIAYoAhQiCSAGKAIMRgRAIAZBDGpB7PXPABCRKAsgBigCECAJQRhsaiIEIBUpAgA3AgAgBEEIaiAVQQhqKQIANwIAIARBEGogFUEQaikCADcCACAGIAlBAWo2AhQgEUHAAmohESAZQcACayIZDQALDAULIAkgBigCIEGo9c8AEP0vAAsgCSAGKAJAQbDozwAQ/S8ACyAFIAlB3PXPABCwOwALIAZByABqIAZBMGopAwA3AwAgBkFAayAGQShqKQMANwMAIAYgBikDIDcDOCABLQBxQQJHBEAgD0E4ahC4LyAPQYCAgIB4NgI4IA9BxABqELkvIABBCDYCACAPQYCAgIB4NgJEIAZBOGoQySMMAQsgACAGQSBqIgEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDAAsgBkEMaiIAEOQpIABBBEEYEOAeIAYQxyogBkEEQQwQ4B4MBgsgBkEgaiIEIAZBFGooAgA2AgAgBiAGKQIMNwMYIAYoAggiCSAGKAIARgRAIAZBuPXPABCQKAsgBigCBCAJQQxsaiIFIAYpAxg3AgAgBUEIaiAEKAIANgIAIAYgCUEBajYCCCAQQUBrIhAgHEcNAAsMAgsgBCAGKAIgQZj1zwAQ/S8AC0GI9c8AELI7AAsgBkEgaiIBIAZBCGooAgA2AgAgBiAGKQIANwMYIA9BxABqELkvIA9BzABqIAEoAgA2AgAgDyAGKQMYNwJECyAAQQg2AgALIAZB4ABqJAALvwkCBX8FfiMAQcABayIEJAAgAUEMaigCCCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQcgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEBA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAcQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEFDAcLIARBIGogASANpyAJp2oiA2oxAABCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgVBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgA0EEdGoiAyAKNwMIIAMgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQIgASgCECEDQQAhAQNAIAkgCoRQBEBBh4CAgHghBQwDCyAEQRBqIAEgA2oxAABCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCACEK0OIAQoAnAiBUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAggAUEBaiIBRw0ACwsgBEHwAGoiAhCXKSAEQdgAaiIBKAIAIQYgBCgCXCEDIAEgBEH4AGoiBSkCADcDACAEKQNQIQkgBCAEKQJwNwNQIARBADYCYCAEIAk3AnwgBEEANgJ4IAQgAzYCdCAEIAY2AnAgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogBSkCADcCACABQRhqIARBgAFqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDiGSAHIARByABqKQIANwMAIAUgBEFAaykCADcDACAEIAQpAjg3A3AgACABIAIQyx0gBEHQAGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAU2AgQgAEEpOgAAIARB0ABqEM8vIAQoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEE4ahD7HgsgBEHAAWokAAuuCQIHfwN+IwBBsAFrIgQkACABQQxqENk8IQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQMgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCADRQRAQYeAgIB4IQIMAQsgBEGIAWogASANpyALp2oiCEEBdGovAQAgA20iCSAHEOoPIAQoAogBIgJBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiEDDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEJIAIoAgAhByABKAIQIQVBACEBA0AgBEGgAWohAyAHRQRAQYeAgIB4IQIMAwsgBEFAayAFLwEAIAdtIgogCRDqDyAEKAJAIgJBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQUgBCgCLCEDIAEgBEHIAGoiBikCADcDACAEKQMgIQsgBCAEKQJANwMgIARBADYCMCAEIAs3AkwgBEEANgJIIAQgAzYCRCAEIAU2AkAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBikCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKQASAEIAU2AowBIAQgATYCiAEgBEE0aiIBIARBiAFqEOUZIAcgBEEYaikCADcDACAGIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEModIARBIGoQzy8MAgtBBEEcEKM9AAsgACAGNgIIIAAgAjYCBCAAQSk6AAAgACADKQIANwIMIABBFGogA0EIaigCADYCACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGwAWokAAuuCQIHfwN+IwBBsAFrIgQkACABQQxqENk8IQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQMgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCADRQRAQYeAgIB4IQIMAQsgBEGIAWogASANpyALp2oiCEEBdGouAQAgA20iCSAHEOoPIAQoAogBIgJBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiEDDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEJIAIoAgAhByABKAIQIQVBACEBA0AgBEGgAWohAyAHRQRAQYeAgIB4IQIMAwsgBEFAayAFLgEAIAdtIgogCRDqDyAEKAJAIgJBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQUgBCgCLCEDIAEgBEHIAGoiBikCADcDACAEKQMgIQsgBCAEKQJANwMgIARBADYCMCAEIAs3AkwgBEEANgJIIAQgAzYCRCAEIAU2AkAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBikCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKQASAEIAU2AowBIAQgATYCiAEgBEE0aiIBIARBiAFqEOUZIAcgBEEYaikCADcDACAGIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEModIARBIGoQzy8MAgtBBEEcEKM9AAsgACAGNgIIIAAgAjYCBCAAQSk6AAAgACADKQIANwIMIABBFGogA0EIaigCADYCACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGwAWokAAvyDQIIfwR+IwBB8ABrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUQAAAAAAAAAAGZFBEAgAkEwaiABmhDxCCACKAIwIgRBgICAgHhGDQIgAiACKQI0Igo3AhQgAiAENgIQIApC/////w9YBEAgAkEQahDpO0EBIQZCBCEKQQAhBAsMAQsgAkHgAGogARDxCCACKAJgIgRBgICAgHhGDQEgAkE4aiACQegAaigCACIDNgIAIAIgAikCYDcDMAJ/IAMEQCACKQJkIQpBAgwBCyACQTBqEOk7QQAhBEIEIQpBAQshBgsgAkEOaiIDQQA6AAAgAkEAOwEMIAJBH2ogAy0AADoAACACIAY6ABwgAiAENgIQIAIgAi8BDDsAHSACIAo3AhQCQCAKQoCAgIAQWgRAQgAhCiMAQSBrIgMkAAJAAkAgAkEQaiIGKAIIIgUEQCAGKAIEIAVBAnRqQQRrIgRFDQEgBa1CBYYgBCgCAGetfSEKCyADQRRqQX8gCkIDiCILIAogC0IDhlKtfCIKpyAKQoCAgIAQWhtBAEEBQQEQoBggAygCGCEHIAMoAhRBAUcEQCAFQQFrIQQgA0EANgIQIAMgAygCHDYCDCADIAc2AgggBQRAIAYoAgQiBiAEQQJ0aiEHQQAhBSAERQ0DA0AgBigCACEEQQAhCANAIAMoAgggBUYEQCADQQhqQcCPiAEQqRkLIAMoAgwgBWogBDoAACADIAVBAWoiBTYCECAEQQh2IQQgCEEBaiIIQf8BcUEESQ0ACyAHIAZBBGoiBkcNAAsMAwsgBEEAQaCPiAEQsDsACyAHIAMoAhxBkI+IARD9LwALQfChiAEQsjsACyAHKAIAIgQEQANAIAMoAgggBUYEQCADQQhqQbCPiAEQqRkLIAMoAgwgBWogBDoAACADIAVBAWoiBTYCECAEQQh2IgQNAAsLIAJB4ABqIgUgAykCCDcCACAFQQhqIANBEGooAgA2AgAgA0EgaiQAIAIoAmghBiACKAJkIQQMAQtBASEGQQFBARCtNiIERQ0CIARBADoAACACQQE2AmggAiAENgJkIAJBATYCYAsgAkEIaiIFIAQgBmpBAWsiB0EAIAYbIgMEfyADLQAABUEACzoAASAFIANBAEc6AAAgAi0ACUEAIAItAAgbwCIDQQBODQMgA0GAf0cNAiACQQA2AjggAiAENgIwIAIgByAEIAYbNgI0IAYEQCACQTBqIgUoAgRBAWshAyAFKAIAIQcDQCAHIANBAWoiCEcEQCAFIAM2AgQgAy0AACADQQFrIQNFDQELCyAHIAhHDQMLIAItABwNAgwECyAAQgA3AwggAEIANwMADAULQQFBARCjPQALIAIoAmAgBkYEfyACQeAAakHQ8ocBEKkZIAIoAmQFIAQLIAZqQQA6AAAgAiAGQQFqIgY2AmgLIAItABwNASACKAJkIQQLIAZFDQBBASEDA0AgBCAELQAAIgdBf3M6AAAgA0EAIQMEQCAEQQAgB2s6AAAgB0UhAwsgBEEBaiEEIAZBAWsiBg0ACwsgAkEoaiIFIAJB6ABqIgQoAgAiAzYCACACIAIpAmA3AyACQAJ/AkACQAJAIANBIEsgA0EgSWtB/wFxDgIAAQILIAQgBSgCADYCACACIAIpAyA3A2AgAkEwaiIDAn8gAkHgAGoiBSgCCEEgRwRAIAMgBSkCADcCBCADQQxqIAVBCGooAgA2AgBBAQwBCyAFQQA2AgggAyAFKAIEIgQpAAA3AAEgA0EJaiAEQQhqKQAANwAAIANBEWogBEEQaikAADcAACADQRlqIARBGGopAAA3AAAgBRDeO0EACzoAACACLQAwQQFGDQUgAkE5aikAACEKIAIpAEkhCyACKQBBIQwgAikAMSENQQAhBAwDCyADQR9NDQUgAigCJCIDKQAYIQsgAykAECEMIAMpAAghCiADKQAAIQ1BAQwBCwJAIAItABwEQCACQcgAakIANwMAIAJBQGtCADcDACACQgA3AzggAkIANwMwDAELIAJByABqQn83AwAgAkFAa0J/NwMAIAJCfzcDOCACQn83AzALIANBIU8NBSADBEAgAkEwaiACKAIkIAP8CgAACyACKQNIIQsgAikDQCEMIAIpAzghCiACKQMwIQ1BAAshBCACQSBqEN47CyACQRBqEOk7IAAgBAR+QgAFIAAgDDcDICAAIA03AxAgACALNwMoIAAgCjcDGEIBCzcDACAAQgA3AwgLIAJB8ABqJAAPCyACQegAaiACQTxqKAIANgIAIAIgAikCNDcDYEGM84cBQSsgAkHgAGpBuPOHAUGA9IcBENUeAAtBICADQZD0hwEQsDsACyADQSBB8POHARCwOwAL9AgBB38jAEEwayIDJAACQCACLQAMIgRBAUYEQCAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIADAELAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAMIgZBAWsOAgACAQsgA0EQaiACEOkdIAAgAykCEDcCACADQQIgBGs6ABwgAEEIaiADQRhqKQIANwIADAkLIARFDQEMAgsgBEUNAQsCfyABKAIIIgQgAigCCCIFRwRAIAQgBUsgBCAFSWsMAQsgBEECdCEEIAEoAgRBBGshCCACKAIEQQRrIQkCQANAIARFDQEgBCAJaiEHIAQgCGogBEEEayEEKAIAIgUgBygCACIHRg0ACyAFIAdLIAUgB0lrDAELQX9BACAEGwtB/wFxDgICAwELIANBGGogAUEIaigCADYCACADIAEpAgA3AxAgA0EgaiADQRBqIAIQ7QggACADKQIgNwIAIABBCGogA0EoaigCACIBNgIAIAAgBkEBIAEbOgAMDAYLQQIhBAJAAkACQCAGQQFrDgICAAELQQAhBAsgA0EYaiABQQhqKAIANgIAIAMgASkCADcDECADQSBqIAIgA0EQahDyCiAEQQEgAygCKBshBAwECyADQRhqIAFBCGooAgA2AgAgAyABKQIANwMQIANBIGoiASACIANBEGoQ8gogA0EANgIoIAFBBEEEEJ4kIAMoAigiAkUNAiADKAIkIgEgAkECdCIFakEEayIERQ0CIAQoAgANAiAFIQQgAUEEayEGIAJB/////wNxIQECQANAIARFBEBBACEEDAILIAFBAWshASAEIAZqIARBBGshBCgCAEUNAAsgAUEBaiIEIAJLDQMLIAMgBDYCKCAEIQIMAgsgAEEIakGUiogBKQIANwIAIABBjIqIASkCADcCAAwDCyADQRhqIgQgAUEIaigCADYCACADIAEpAgA3AxAgA0EQaiACEO8UIANBKGogBCgCADYCACADIAMpAxA3AyACQCAGQQFHBEAgBkEBIAMoAigbIQQMAQsgA0EANgIoIANBIGpBBEEEEJ4kAkAgAygCKCICRQ0AIAMoAiQiASACQQJ0IgVqQQRrIgRFDQAgBCgCAA0AIAUhBCABQQRrIQYgAkH/////A3EhAQJAA0AgBEUEQEEAIQQMAgsgAUEBayEBIAQgBmogBEEEayEEKAIARQ0ACyABQQFqIgQgAksNAQsgAyAENgIoIAQhAgtBASEEIAIgAygCIEECdk8NACADQQhqIANBIGogAkEEQQQQ9BQgAygCCCIBQYGAgIB4Rg0AIAEgAygCDEHMjYgBEP0vAAsgACADKQMgNwIAIAAgBDoADCAAQQhqIANBKGooAgA2AgAMAwtBASEEIAIgAygCIEECdk8NACADIANBIGogAkEEQQQQ9BQgAygCACIBQYGAgIB4Rg0AIAEgAygCBEHMjYgBEP0vAAsgACADKQIgNwIAIAAgBDoADCAAQQhqIANBKGooAgA2AgAMAQsgAUEEQQQQ4B4LIANBMGokAAvhCQIHfwF+IwBBgAFrIgIkACACQdAAaiABEPAnIAJBQGsiBCACQdwAaiIFKAIANgIAIAIgAikCVDcDOAJAIAIoAlAiBkEERwRAIAIoAmAhASAAIAIpAzg3AgggACABNgIUIAAgBjYCBCAAQYGAgIB4NgIAIABBEGogBCgCADYCAAwBCyACQShqIAQoAgA2AgAgAiACKQM4NwMgIAJBIGoQhjAgAkGAgICAeDYCACACQYCAgIB4NgIQIAJB0ABqIAEQ0wkgBCAFKQIANwMAIAJByABqIgYgAkHkAGooAgA2AgAgAiACKQJUNwM4AkACQCACKAJQRQRAIAJB1ABqIQRBAiEHA0AgAkEwaiAGKAIAIgM2AgAgAkEoaiACQUBrIgUpAwA3AwAgAiACKQM4NwMgAkACQCADQf8BcQRAIAJB0ABqIAJBIGoQ/BcgAi8BVCEDIAIoAlAiCEEERwRAIAAgAikBVjcBCiAAQRBqIAJB3ABqKQEANwEAIAAgAzsBCCAAIAg2AgQgAEGBgICAeDYCAAwGCwJAAkACQAJAIANBAWsOAwABAgMLIAJB0ABqIAEQpREgBSAEQQhqKAIANgIAIAIgBCkCADcDOCACKAJQIgNBBEYNBCACKAJgIQEgACACKQM4NwIIIAAgATYCFCAAIAM2AgQgAEGBgICAeDYCACAAQRBqIAJBQGsoAgA2AgAMCAsgAkHQAGogARClESAFIARBCGooAgA2AgAgAiAEKQIANwM4IAIoAlAiA0EERwRAIAIoAmAhASAAIAIpAzg3AgggACABNgIUIAAgAzYCBCAAQYGAgIB4NgIAIABBEGogAkFAaygCADYCAAwICyACQdgAaiIDIAUoAgA2AgAgAiACKQM4NwNQIAJBEGoQhjAgAkEYaiADKAIANgIAIAIgAikDUDcDEAwECyACQdAAaiABENoQIAItAFQhByACKAJQIgNBBEYNAyAAIAIpAFU3AAkgAEEQaiACQdwAaikAADcAACAAIAc6AAggACADNgIEIABBgYCAgHg2AgAMBgsgAkHQAGogASACLQAwQcAAEMkCIAIoAlAiA0EERg0CIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIAIABBgYCAgHg2AgAgACADNgIEDAULIAJBIGoQhjAgAkHQAGogARCoKSACKAJQIgFBBEcEQCAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCACAAQYGAgIB4NgIAIAAgATYCBAwGCyACQfAAaiIBIAJBCGooAgA2AgAgAkH8AGogAkEYaigCADYCACAAIAIpAwAiCTcCACAAIAc6ABggAiACKQMQNwJ0IABBCGogASkDADcCACAAQRBqIAJB+ABqKQMANwIAIAIgCTcDaAwGCyACQdgAaiIDIAUoAgA2AgAgAiACKQM4NwNQIAIQhjAgAkEIaiADKAIANgIAIAIgAikDUDcDAAsgAkEgahCGMCACQdAAaiABENMJIAUgBEEIaikCADcDACAGIARBEGooAgA2AgAgAiAEKQIANwM4IAIoAlBFDQALCyAAIAIpAzg3AgQgAEGBgICAeDYCACAAQRRqIAYoAgA2AgAgAEEMaiACQUBrKQMANwIADAELIAJBIGoQhjALIAJBEGoQhjAgAhCGMAsgAkGAAWokAAuBDAIQfwJ+IwBBgARrIgEkAAJAAn8CQAJAAkACQCAALQBYQQFrDgMCBQEACyAAQTBqIABBKPwKAAALAkACQAJAAkACQAJAAkACQCAALQBUQQFrDgMHCwABCyAALQBQQQFxDQUgACgCTCECIAAoAkRBAXFFDQIgACgCSCEDDAELIABBOGogACgCMBCFIyAAQQA6AFAgACAAKAI4IgI2AkwgACAAKAI0IgM2AkggACADQQBHNgJEIANFDQELIAFByABqIAMQxwcCQCABKAJIIgNBAmsOAgcBAAsgASgCTCEEIAFBGGogAUHQAGoiBUEw/AoAACABIAQ2AhQgASADNgIQQQEgASgCLCIDIANBAU0bQQEgASgCKEEBcRshCSABKAIwQYCAgIB4Rg0BIAFByABqIAFBMGoQiR0gASgCSEGAgICAeEYNASABQYgBaiAFKAIANgIAIAEgASkCSDcDgAEMAgsgAUGAgICAeDYCMCABQQA2AhAgAUGAgICAeDYCPCABQQA2AiAgAUEANgIYIAFBADYCKEEBIQkLIAFBgAFqIAIoAiBBCGooAlhB3MnCABCKOwsCfiACKAIAQQFGBEAgAUHIAGogAkEQahDdICACKAIcIgMgAygCACIEQQFqNgIAIARBAEgNByABKAJQIQogASgCTCEOIAEoAkghC0IBIRIgAikDCAwBCyACKAIQEPQ6IQsgAigCHCEDIAIoAhghCiACKQMICyETIAIoAiAiDCAMKAIAIgRBAWo2AgAgBEEASA0FIAIoAiQiDSANKAIAIgRBAWo2AgAgBEEASA0FIAIoAigiBgRAIAYgBigCACICQQFqNgIAIAJBAEgNBgsgASgCgAEhDyABKAKEASEHIAEoAogBIRAgAUGgAmohCCMAQRBrIgUkAAJAAkBB4AFBCBCtNiICBEAgAkIANwPIASACQgM3AwggAkKBgICAEDcDACACQQE7AdwBIAJBfzYC2AEgAkHQAWpCADcDACAFQQRqEOs6QSBBBBCtNiIERQ0BIAQgAjYCCCAEQoGAgIAQNwIAIAQgBSkCBDcCDCAEIAJBCGoiAjYCHCAEIAI2AhggBEEUaiAFQQxqKAIANgIAIAhBADoACCAIQQA2AgQgCCAENgIAIAVBEGokAAwCC0EIQeABEKM9AAtBBEEgEKM9AAsgAUGYAmpCADcDACABQQA2ArQCIAFCgICAgIABNwKsAiABQgA3A5ACIAEgAzYCrAEgASAKNgKoASABIA42AqQBIAEgCzYCoAEgASATNwOYASABIBI3A5ABIAFBsAFqIAFBEGpBOPwKAAAgASAJNgK4AiABQQA6AIgCIAEgByAQQQJ0ajYChAIgASAPNgKAAiABIAc2AvwBIAEgBzYC+AEgASAGNgLwASABIA02AuwBIAEgDDYC6AEgAUHAAmoiBCABQZABakGwAfwKAAAgAUEANgLwAwJ/IwBBEGsiAiQAQcABQQgQrTYiAwRAIAMgBEHAAfwKAAAgAkEIaiADQejPwwAQgCkgAigCCCACKAIMEM0sEIEpIAJBEGokAAwBC0EIQcABEKM9AAsMBAtB3NzCABDoKwALQZzcwgAQ6CsAC0HcyMIAEOgrAAtBASERIAEoAkwQgBgLIQIgAEEBOgBQIABBOGoQ5CogAEEBOgBUIABBMGoQ/ykCQCARBEAgASACNgKQASABQYABNgLAAiABIABBLGogAUHAAmogAUGQAWoQwiMgASgCACABKAIEENYvIgJBhAFPBEAgAhDyHwsgASgCwAIiAkGEAU8EQCACEPIfCyABKAKQASICQYQBSQ0BIAIQ8h8MAQsgASACNgKQASABQYABNgLAAiABQQhqIABBKGogAUHAAmogAUGQAWoQwiMgASgCCCABKAIMENYvIgJBhAFPBEAgAhDyHwsgASgCwAIiAkGEAU8EQCACEPIfCyABKAKQASICQYQBSQ0AIAIQ8h8LIAAoAigiAkGEAU8EQCACEPIfCyAAKAIsIgJBhAFPBEAgAhDyHwsgAEEBOgBYIAFBgARqJABBAA8LAAv0BwIEfwV+IwBBsAFrIgUkAAJAAkACQAJAIAR5IAN5QkB9IARCAFIbpyIHIAJ5IAF5QkB9IAJCAFIbpyIGSwRAIAZBP0sNASAHQd8ASw0CIAcgBmtBIEkNAyAFQaABaiADIARB4AAgB2siCBDHIyAFNQKgAUIBfCEMAkACQAJAAkADQCAFQZABaiABIAJBwAAgBmsiBhDHIyAFKQOQASEJIAYgCEkEQCAFQdAAaiADIAQgBhDHIyAFKQNQIgxQRQRAIAkgDIAhCQsgBUFAayADIAQgCUIAEKgeIAEgBSkDQCIMVCIGIAIgBSkDSCINVCACIA1RG0UEQCACIA19IAatfSECIAEgDH0hASALIAkgCnwiCSAKVK18IQsMCwsgASABIAN8IgFWrSACIAR8fCANfSABIAxUrX0hAiABIAx9IQEgCyAJIAp8QgF9IgkgClStfCELDAoLIAVBgAFqIAkgDIAiCUIAIAYgCGsiBhDGIyAFQfAAaiADIAQgCUIAEKgeIAVB4ABqIAUpA3AgBSkDeCAGEMYjIAUpA4ABIgkgCnwiCiAJVK0gBSkDiAEgC3x8IQsgByACIAUpA2h9IAEgBSkDYCIJVK19IgJ5IAEgCX0iAXlCQH0gAkIAUhunIgZNDQEgBkE/TQ0ACyADUEUNAQwCCyABIANUIgYgAiAEVCACIARRG0UNAiAKIQkMBwsgASADgCECCyABIAOCIQEgCyACIAp8IgkgClStfCELQgAhAgwFCyACIAR9IAatfSECIAEgA30hASALIApCAXwiCVCtfCELDAQLIAIgBEIAIAEgA1ogAiAEWiACIARRGyIGG30gASADQgAgBhsiA1StfSECIAEgA30hASAGrSEJDAMLIAEgASADgCIJIAN+fSEBQgAhAgwCCyABQiCIIgkgAiACIANC/////w+DIgKAIgogA359QiCGhCACgCIEQiCGIAFC/////w+DIAkgAyAEfn1CIIaEIgEgAoAiA4QhCSABIAIgA359IQEgBEIgiCAKhCELQgAhAgwBCyAFQTBqIAMgBEHAACAGayIGEMcjIAVBIGogASACIAYQxyMgBUEQaiADQgAgBSkDICAFKQMwgCIJQgAQqB4gBSAEQgAgCUIAEKgeIAUpAxAhCgJAIAUpAwggBSkDGCINIAUpAwB8IgwgDVStfFAEQCABIApUIgYgAiAMVCACIAxRG0UNAQsgASADfCIBIANUrSACIAR8fCAMfSABIApUrX0hAiAJQgF9IQkgASAKfSEBDAELIAIgDH0gBq19IQIgASAKfSEBCyAAIAE3AxAgACAJNwMAIAAgAjcDGCAAIAs3AwggBUGwAWokAAunCQIHfwN+IwBBsAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQIgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCACRQRAQYeAgIB4IQMMAQsgBEGIAWogASANpyALp2oiCGotAAAgAm0iCSAHEOoPIAQoAogBIgNBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiECDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEHIAIoAgAhBSABKAIQIQlBACEBA0AgBEGgAWohAiAFRQRAQYeAgIB4IQMMAwsgBEFAayABIAlqLQAAIAVtIgogBxDqDyAEKAJAIgNBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAIIAFBAWoiAUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCyAEIAQpAkA3AyAgBEEANgIwIAQgCzcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2ApABIAQgBTYCjAEgBCABNgKIASAEQTRqIgEgBEGIAWoQ5RkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQyh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAY2AgggACADNgIEIABBKToAACAAIAIpAgA3AgwgAEEUaiACQQhqKAIANgIAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQbABaiQAC6cJAgd/A34jAEGwAWsiBCQAIAFBDGooAgghCCAEQQhqIAEQkjYQ7iUgCEECdCIFIQcCQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiByAFSQ0BC0HAACEGIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgZFDQELIAQgBjYCKCAEIAc2AiQgBEHAADYCICAFBEAgBkEAIAX8CwALIAQgCDYCMCAEIAU2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQUgAy0AACEHIAIoAgAhAiABKAIQIQEDQAJAIAQpA2giDFBFBEAgBCkDcCELDAELA0ACfgJAIAQpA1AiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDUCALp0EBcUUNACAEIAQpA1g3A5ABDAELIAQoAmBFDQEgBEGIAWogBRC2KiAEKQOIASELCyALQgBSDQILIARCAzcDUAsgBCkDQCILQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDkAELIQwgC6dBAXFFDQcgBCAEKQNwQkB9Igs3A3AgBCAMNwNoIAxQDQALCyAEIAxCASAMeiINhoU3A2gCQAJAIAJFBEBBh4CAgHghAwwBCyAEQYgBaiABIA2nIAunaiIIaiwAACACbSIJIAcQ6g8gBCgCiAEiA0GTgICAeEYNASAEQYABaiAEQZgBaigCADYCACAEIAQpApABNwN4IAQoAowBIQYLIARB+ABqIQIMBwsgBiAIQQJ0aiAJNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgAigCACEFIAEoAhAhCUEAIQEDQCAEQaABaiECIAVFBEBBh4CAgHghAwwDCyAEQUBrIAEgCWosAAAgBW0iCiAHEOoPIAQoAkAiA0GTgICAeEcEQCAEQagBaiAEQdAAaigCADYCACAEIAQpAkg3A6ABIAQoAkQhBgwDCyAGIAo2AgAgBkEEaiEGIAggAUEBaiIBRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEFIAQoAiwhAyABIARByABqIgYpAgA3AwAgBCkDICELIAQgBCkCQDcDICAEQQA2AjAgBCALNwJMIARBADYCSCAEIAM2AkQgBCAFNgJAIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCkAEgBCAFNgKMASAEIAE2AogBIARBNGoiASAEQYgBahDlGSAHIARBGGopAgA3AwAgBiAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDKHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgBjYCCCAAIAM2AgQgAEEpOgAAIAAgAikCADcCDCAAQRRqIAJBCGooAgA2AgAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBsAFqJAALoQgBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgI0IAIgAEECdiIATw0LIAQgASgCECACQQJ0aigCADYCMCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBMGogAxDMJCECDAoLIARBMGogAxDTHCECDAkLIAAoAgQoAhQhACAEIAI2AjQgAiAAQQJ2IgBPDQogBigCBCIARQ0CIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQMgBEFAa0HIrYYBKAIANgIAIARBwK2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUECdiIBTw0HIAQgACgCECACQQJ0aigCACIArDcDCCAEQUBrQcithgEoAgA2AgAgBEHArYYBKQIANwM4IARBOGoiARDJDCAAQf+iBUsNBSAEQQA2AhggBCAANgIUIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AiAgBCAEQRxqNgJAIAQgBEEUajYCHCADKAIAIAMoAgQgARDLCiECDAYLIARBQGtByK2GASgCADYCACAEQcCthgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEFAa0HIrYYBKAIANgIAIARBwK2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRxqEOUQDAMLIARBMGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQUBrQcithgEoAgA2AgAgBEHArYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIAQ2AhwgAygCACADKAIEIAAQywohAgwBCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIARBCGo2AhwgAygCACADKAIEIARBOGoQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AhQMAQsgBCAANgIUCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiggBEE7NgIgIAQgBEEcajYCQCAEIARBFGo2AiQgBCAEQTRqNgIcIARBOGpByJeEARDvLAAL3ggCEX8CfiMAQSBrIgwkACALKAIIIQ8gC0IANwMIAkAgBCAHcSIXIANNBEAgCykDACEeIAAoAjQhGiADIBdrIRIgAiAXaiETAkAgACgCICIURQ0AA0BBECANIA1BEE0bIRUgDyATaiEYIAYgDUECdGohECAPIBdqIARLIRkDQAJAAkAgDSAVRwRAIBAoAgAiFiAJSw0CIAcgFmsiDiAHTyAZcg0CIAQgDnEiDiAPaiIRIARNDQEMAgsgFUEQQbzVzgAQwyEACwJAAkACQAJAAkAgDyASSQRAIAMgEU0NASAYLQAAIAIgEWotAABHDQYgAyAOSQ0CIAIgDmogAyAOayATIBIgCBCyICIQQQJNIBBBAkcgDUEBS3JxDQUgHiAQIA4gBRChLiIOIBoQ8jQiHVoNBSANDQMMBAsgDyASQczVzgAQwyEACyARIANB3NXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQezVzgAQ7ywACyAdIA0Q/zB9IR0LIB0gHlgNACALIBY2AhAgCyAONgIIIAsgHTcDAEEBIRsgDiEPIB0hHgsgDUEBaiINIBRJDQIMAwsgEEEEaiEQIA1BAWoiDSAUSQ0ACwsLAkACQAJAAkACQCATIBIQxiAiBiAAKAIEIg1JBEAgACgCDCIOIAZBBnQiDUkNAiAOIA1rQT9LDQEgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAYgDUHg084AEMMhAAsgACgCCCANQQJ0aiEVIAAoAgAgBkEBdGoiFi8BACIORQ0FIA5BQGoiBkEAIAYgDk0bIRggDiEGA0AgDyATaiEZIA8gF2ogBEshHANAIAYhDQNAIA0gGE0NCCAHIBUgDUEBayIGQT9xQQJ0aigCACIRayEQAkAgHA0AIAQgEXEiESAPaiIUIARLDQAgDyASTw0FIAMgFE0NBiAZLQAAIAIgFGotAABHDQAgCSAQSQ0JIAMgEUkNByACIBFqIAMgEWsgEyASIAgQ9AEiDUUNAiAeIA0gESAFEKEuIg0gECAaEIwtIh1aDQIgCyAQNgIQIAsgDTYCCCALIB03AwBBASEbIA0hDyAdIR4MAwsgDUEBayENIAkgEE8NAAsLCwwFCyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHw084AEO8sAAsgDyASQfzUzgAQwyEACyAUIANBjNXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQZzVzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHQ084AEO8sAAsgFSAOQT9xQQJ0aiAHNgIAIBYgFi8BAEEBajsBAAJ/QQEgGw0AGkEAIAFFDQAaIAEgACATIBIgCCAJIAogCxDoFAsgDEEgaiQAC94IAhF/An4jAEEgayIMJAAgCygCCCEPIAtCADcDCAJAIAQgB3EiFyADTQRAIAspAwAhHiAAKAI0IRogAyAXayESIAIgF2ohEwJAIAAoAiAiFEUNAANAQRAgDSANQRBNGyEVIA8gE2ohGCAGIA1BAnRqIRAgDyAXaiAESyEZA0ACQAJAIA0gFUcEQCAQKAIAIhYgCUsNAiAHIBZrIg4gB08gGXINAiAEIA5xIg4gD2oiESAETQ0BDAILIBVBEEG81c4AEMMhAAsCQAJAAkACQAJAIA8gEkkEQCADIBFNDQEgGC0AACACIBFqLQAARw0GIAMgDkkNAiACIA5qIAMgDmsgEyASIAgQsiAiEEECTSAQQQJHIA1BAUtycQ0FIB4gECAOIAUQoS4iDiAaEPI0Ih1aDQUgDQ0DDAQLIA8gEkHM1c4AEMMhAAsgESADQdzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHs1c4AEO8sAAsgHSANEP8wfSEdCyAdIB5YDQAgCyAWNgIQIAsgDjYCCCALIB03AwBBASEbIA4hDyAdIR4LIA1BAWoiDSAUSQ0CDAMLIBBBBGohECANQQFqIg0gFEkNAAsLCwJAAkACQAJAAkAgEyASEMcgIgYgACgCBCINSQRAIAAoAgwiDiAGQQR0Ig1JDQIgDiANa0EPSw0BIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQYDUzgAQ7ywACyAGIA1B4NPOABDDIQALIAAoAgggDUECdGohFSAAKAIAIAZBAXRqIhYvAQAiDkUNBSAOQRBrIgZBACAGIA5NGyEYIA4hBgNAIA8gE2ohGSAPIBdqIARLIRwDQCAGIQ0DQCANIBhNDQggByAVIA1BAWsiBkEPcUECdGooAgAiEWshEAJAIBwNACAEIBFxIhEgD2oiFCAESw0AIA8gEk8NBSADIBRNDQYgGS0AACACIBRqLQAARw0AIAkgEEkNCSADIBFJDQcgAiARaiADIBFrIBMgEiAIEPQBIg1FDQIgHiANIBEgBRChLiINIBAgGhCMLSIdWg0CIAsgEDYCECALIA02AgggCyAdNwMAQQEhGyANIQ8gHSEeDAMLIA1BAWshDSAJIBBPDQALCwsMBQsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB8NPOABDvLAALIA8gEkH81M4AEMMhAAsgFCADQYzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakGc1c4AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB0NPOABDvLAALIBUgDkEPcUECdGogBzYCACAWIBYvAQBBAWo7AQACf0EBIBsNABpBACABRQ0AGiABIAAgEyASIAggCSAKIAsQ6BQLIAxBIGokAAvvFwIOfwJ+IwBB8AFrIgYkACABKAIMIQcCQCABKAIAQYCAgIB4RwRAIAZBxAFqIAEQoB0MAQsgBkGAgICAeDYCxAELIAZB8ABqIAZBzAFqKAIANgIAIAYgBzYCdCAGIAYpAsQBNwNoIAZBxAFqIgcgBkHoAGoQ7w4gBkEYaiIJIAIgAyAHEPkUIAZBADYCFCAGQoCAgIDAADcCDCAFKAIQIQwgBkE4aiAJEIcGAkACQCAGKAI4IglBAkYNACAGQYABaiEDIAZB7ABqIQUgBkHcAWohByAGQcgBaiEKIAZBPGohAgJAA0AgCUEBcQRAIAAgAhCmJQwCCyAGQdgAaiACQQhqKQIANwMAIAZB4ABqIAJBEGooAgAiCTYCACAGIAIpAgA3A1AgBiAJNgJkIAZBxAFqIAQgBkHQAGogDBEBACAGQaABaiILIApBCGopAgA3AwAgBkGoAWoiCCAKQRBqKAIANgIAIAYgCikCADcDmAEgBigCxAEiDUUEQCAAIAZBmAFqEKYlDAILIAMgBykCADcCACADQRBqIAdBEGooAgA2AgAgA0EIaiAHQQhqKQIANwIAIAVBEGogCCgCADYCACAFQQhqIAspAwA3AgAgBSAGKQOYATcCACAGIA02AmggCSAGQegAaiILKAIQRgRAAkAgCxDLOkUEQCAGQcQBaiALQSz8CgAAIAYoAhQiCSAGKAIMRgRAIAZBDGpB8P7MABCiKAsgBigCECAJQSxsaiAGQcQBakEs/AoAACAGIAlBAWo2AhQMAQsgBkHEAWogBkHoAGoQ2icgBigCFCIJIAYoAgxGBEAgBkEMakGA/8wAEKIoCyAGKAIQIAlBLGxqIAZBxAFqQSz8CgAAIAYgCUEBajYCFCAGQegAahDNJgsgBkE4aiAGQRhqEIcGIAYoAjgiCUECRw0BDAMLCyAGIAZB6ABqIgIoAhA2ArABIAZBAjYCyAEgBkHE/8wANgLEASAGQgI3AtABIAZBOzYCwAEgBkE7NgK4ASAGIAZBtAFqNgLMASAGIAZB5ABqNgK8ASAGIAZBsAFqNgK0ASAAQQRqIAZBxAFqEJkOIABBAzYCACACEM0mCyAGQRhqENEbIAZBDGoiABCFHyAAQQRBLBDgHiABKAIAQYCAgIB4Rg0BIAFBBEEIEOAeDAELIAZBGGoiBBDRGyAGKAIQIQIgBigCFCEDQQAhCSMAQbABayIKJAAgCkEANgIMIAMEQCACIQUgAyEHA0AgCSAFKAIQaiEJIAVBLGohBSAHQQFrIgcNAAsLIApCAzcDWCAKQgM3AxAgCiACNgKgASAKIAIgA0EsbGo2AqQBIAogCkEMajYCqAEjAEHgAmsiBSQAIApBEGoiBykDSCEUIAcpAwAhFQJAAkAgBygCkAEiAwRAIAVB+AFqIQIgFUIDUiAUQgNScg0CIAcoApQBIANGDQEMAgsgBUH4AWohAiAVQgNSIBRCA1JyDQELIAVBuAFqIQILQQAhAyACQQA2AgAgBUEYaiILQQBBAEEEQQgQoBggBSgCHCECAkAgBSgCGEEBRwRAIAVBADYCFCAFIAUoAiA2AhAgBSACNgIMIAsgB0GgAfwKAAAgBUHgAGohDSAFQSBqIQ4gBUGAAmohDwNAIAUpAxhCA1EhAgNAAkACQAJAAkACQAJAAkACfwJAIAJFBEAgBUH4AWogBUEYahDjPSAFKAL4AQ0BIAVCAzcDGEEBIQIMCgsCQCAFKAKoASICRQ0AIAIgBSgCrAFGDQAgBSACQSxqNgKoASAFKAKwASIHKAIAIQsgByACKAIQIAcoAgBqNgIAIAUgAhDLOiIHNgLEAiAHDQggBUH4AWogAhDJNCAFIAs2ArgCIAUpA/gBIRRBACICRQRAIAVBuAFqIA9BwAD8CgAACyAUQgNRDQAgBSAUNwMYIA4gBUG4AWpBwAD8CgAADAoLIAUpA2BCA1ENAiAFQfgBaiANEOM9IAUoAvgBQQFHDQIgBSgCoAEiByAFKAKAAmohAiAHIAUoAvwBagwBCyAFKAJYIgcgBSgCgAJqIQIgByAFKAL8AWoLIgcgAkYNCCACIAdrIQsgAyAHSSADIAdLa0H/AXEOAgIDAQsgAyAJRwRAIAUoAhQiAiAFKAIMRgRAIAVBDGpB+P/MABCbKAsgBSgCECACQQN0aiIHQQE6AAQgByAJIANrNgIAIAUgAkEBajYCFAsgBCAFKQIMNwIAIARBCGogBUEUaigCADYCACAFQeACaiQADAkLIAVBADYCiAIgBUEBNgL8ASAFQZSAzQA2AvgBIAVCBDcCgAIgBUH4AWpBnIDNABDvLAALIAUoAhQiA0EDdCEHIAUoAhAhDCADBEAgByAMakEIayIIDQILIAUoAgwgA0YEfyAFQQxqQayAzQAQmyggBSgCEAUgDAsgB2oiB0EAOgAEIAcgCzYCACAFIANBAWo2AhQgAiEDDAULIAUoAhQiDCAFKAIMRgRAIAVBDGpBzIDNABCbKAsgBSgCECAMQQN0aiIIQQE6AAQgCCAHIANrNgIAIAUgDEEBaiIDNgIUIAUoAgwgA0YEQCAFQQxqQdyAzQAQmygLIAUoAhAgA0EDdGoiA0EAOgAEIAMgCzYCACAFIAxBAmo2AhQgAiEDDAQLIAgoAgAiAyALaiIHIANJDQEgCCAHNgIAIAIhAwwDCyAFQQA2AsgCQQAgBUHEAmpB1P/MACAFQcgCakHY/8wAEK8rAAsLC0G8gM0AELI7AAsgAiAFKAIgQej/zAAQ/S8ACyAKQbABaiQAIAEoAgAhAiABQYCAgIB4NgIAAkAgAkGAgICAeEcEQCAGIAEpAgQ3AsgBIAYgAjYCxAEgBkHoAGohEEEAIQ1BACEKQQAhCSMAQTBrIggkACAIQQA2AhQgCEKAgICAwAA3AgwgBCgCBCIMIAQoAghBA3RqIRIgBkHEAWoiEyICKAIEIg4gAigCCEEDdGohEUEDIQJBAyEEAkACQAJAA0BBACEPAkADQAJAAkAgAkH/AXFBAmsOAgMAAQsgDCASRg0CIAwtAAQhAiAMKAIAIQkgDEEIaiEMCyACIQMgCSELAkACQCAEQf8BcUECaw4CBQABCyAOIBFGDQQgDi0ABCEEIA4oAgAhCiAOQQhqIQ4LIAQhBSAKIQdBACEJQQMhAiALRQ0AQQAhCkEDIQQgAyECIAshCSAHRQ0AAkACQCAFQQFxBEAgByEKDAELIAsgCyAHIAcgC0sbIgJrIQkgByACayEKIANBAXFFDQEgBSEEIAIhBwsgByAPaiEPIAMhAgwBCwsgCCgCDCEEIA8EfyAEIA1GBEAgCEEMakHcgc0AEJsoCyAIKAIQIA1BA3RqIgRBAToABCAEIA82AgAgCCANQQFqIg02AhQgCCgCDAUgBAsgDUYEQCAIQQxqQeyBzQAQmygLIAgoAhAgDUEDdGoiBEEAOgAEIAQgAjYCACAIIA1BAWoiDTYCFCADIQIgBSEEDAELCwNAAkACQCAEQf8BcUEDRwRAIAohAiAEIQwMAQsgDiARRg0BIA4tAAQhDCAOKAIAIQIgDkEIaiEOC0EDIQQgAkUNASAMQQFxRQ0DIAIgD2ohDwwBCwsgDwRAIAgoAgwgDUYEQCAIQQxqQfyBzQAQmygLIAgoAhAgDUEDdGoiAkEBOgAEIAIgDzYCACAIIA1BAWo2AhQLIBAgCCkCDDcCACAQQQhqIAhBFGooAgA2AgAgCEEwaiQADAILQZyBzQBBLUHMgc0AEMskAAsgCEEANgIoIAhBATYCHCAIQcSCzQA2AhggCEIENwIgIAhBGGpBzILNABDvLAALIBNBBEEIEOAeIAEoAgBBgICAgHhHBEAgAUEEQQgQ4B4LIAEgBikCaDcCACABQQhqIgIgBkHwAGooAgA2AgAgAEEMaiACKQIANwIAIAAgASkCADcCBCAGQRhqQQRBCBDgHgwBCyABIAYpAhg3AgAgAUEIaiICIAZBIGooAgA2AgAgAEEMaiACKQIANwIAIAAgASkCADcCBAsgAEEINgIAIAZBDGoiABCFHyAAQQRBLBDgHgsgBkHwAWokAAu1CQIKfwF+IwBB8ANrIgMkACADQSRqIgQgASACKAIUEQAAIAMgA0E8aiIGNgKgAyADQfABakGUqNCgATYCACADQpSo0KDBgoWKFDcD6AEgAyADQegBaiIFNgJoAkACQAJAAkACQAJAAkACQCAGIAUQuwgEQCAFEKcMIANBGGogBBDcOyADKAIcIgVBAkkNAiADKAIYIgUoAgwiCSAJKAIAIgZBAWo2AgAgBkEASA0BIAUoAhQhCyAFKAIQIQwgA0EQaiAEENw7IAMoAhRFDQYgA0EIaiADKAIQEMcbIAMoAgghCCADKAIMIgdBA3QiBEE4cSIFBEAgBCAEIAVrQUBrIgRLDQQLQcAAIQUgBEHAABDRNEUNBCAEBEAgBEHAABCtNiIFRQ0GCyADQgA3AnQgAyAFNgJwIAMgBDYCbEHAACEKIANBwAA2AmhBACEGIAcEQCAHQQJ0IQQDQCAINAIAIQ0gCEEEaiEIIAZBCGoiBSADKAJsIgdLBEAgA0HoAGogB0EBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJsIQcgAygCdCIGQQhqIQULIAUgB0sEfyADQegAaiAHQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAnQFIAYLIAMoAnBqIA03AAAgAyADKAJ0QQhqIgY2AnQgAyADKAJ4QQFqNgJ4IARBBGsiBA0ACyADKAJwIQUgAygCaCEKIAMoAmwhBAsgA0HEAmoiBxCXKSADQfAAaiADQcwCaiIIKQIANwMAIAMgAykCxAI3A2ggA0EANgJ4IAMgBDYC1AIgAyAKNgLQAiADQQA2AswCIAMgBjYCyAIgAyAFNgLEAiADIAcQ1zsgAygCACEFQRxBBBCtNiIERQ0HIARCgYCAgBA3AgAgBCADKQLEAjcCCCAEQRBqIAgpAgA3AgAgBEEYaiADQdQCaigCADYCACADIAY2AogBIAMgBTYChAEgAyAENgKAASABIAIoAjARBAAhBCABIAIoAiQRBAAhASADQewCakGWrNiwATYCACADQpas2LDhwoWLFjcC5AIgA0IENwLcAiADQgA3AtQCIANCgICAgMAANwLMAiADQQA2AsQCIANBADsBnAMgAyAENgKYAyADQQA2AoADIANBADYC9AIgAyABNgLwAiADQegBaiIBIAcgA0GAAWoQ+iMgAyALNgKoAyADIAw2AqQDIAMgCTYCoAMgByABIANBoANqEPojIAEgA0HQAGpBACADKAJQGxDuJSADQYwBaiICIAcgARDCGSADQawDaiIBIAIQzRwgByABEIsMQcQAQQQQrTYiAUUNCCABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HoAGoQzy8gA0EkahCAJyADQfADaiQADwsgA0EANgLEAiADQaADaiADQegAaiADQcQCakGY6/8AEKMrCwALQQEgBUGo6/8AEMMhAAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgA0HEAmpBxMj/AEHYwf8AENUeAAtBwAAgBBCjPQALQQBBAEG46/8AEMMhAAtBBEEcEKM9AAtBBEHEABCjPQALtQkCCn8BfiMAQfADayIDJAAgA0EkaiIEIAEgAigCFBEAACADIANBPGoiBjYCoAMgA0HwAWpBmLDgwAE2AgAgA0KYsODAgYOGjBg3A+gBIAMgA0HoAWoiBTYCaAJAAkACQAJAAkACQAJAAkAgBiAFELsIBEAgBRCnDCADQRhqIAQQ3DsgAygCHCIFQQJJDQIgAygCGCIFKAIMIgkgCSgCACIGQQFqNgIAIAZBAEgNASAFKAIUIQsgBSgCECEMIANBEGogBBDcOyADKAIURQ0GIANBCGogAygCEBDHGyADKAIIIQggAygCDCIHQQN0IgRBOHEiBQRAIAQgBCAFa0FAayIESw0EC0HAACEFIARBwAAQ0TRFDQQgBARAIARBwAAQrTYiBUUNBgsgA0IANwJ0IAMgBTYCcCADIAQ2AmxBwAAhCiADQcAANgJoQQAhBiAHBEAgB0ECdCEEA0AgCDQCACENIAhBBGohCCAGQQhqIgUgAygCbCIHSwRAIANB6ABqIAdBAXQiBiAFEM0qIgUgBSAGSRsQ6BkgAygCbCEHIAMoAnQiBkEIaiEFCyAFIAdLBH8gA0HoAGogB0EBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJ0BSAGCyADKAJwaiANNwAAIAMgAygCdEEIaiIGNgJ0IAMgAygCeEEBajYCeCAEQQRrIgQNAAsgAygCcCEFIAMoAmghCiADKAJsIQQLIANBxAJqIgcQlykgA0HwAGogA0HMAmoiCCkCADcDACADIAMpAsQCNwNoIANBADYCeCADIAQ2AtQCIAMgCjYC0AIgA0EANgLMAiADIAY2AsgCIAMgBTYCxAIgAyAHENc7IAMoAgAhBUEcQQQQrTYiBEUNByAEQoGAgIAQNwIAIAQgAykCxAI3AgggBEEQaiAIKQIANwIAIARBGGogA0HUAmooAgA2AgAgAyAGNgKIASADIAU2AoQBIAMgBDYCgAEgASACKAIwEQQAIQQgASACKAIkEQQAIQEgA0HsAmpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3AuQCIANCBDcC3AIgA0IANwLUAiADQoCAgIDAADcCzAIgA0EANgLEAiADQQA7AZwDIAMgBDYCmAMgA0EANgKAAyADQQA2AvQCIAMgATYC8AIgA0HoAWoiASAHIANBgAFqEPojIAMgCzYCqAMgAyAMNgKkAyADIAk2AqADIAcgASADQaADahD6IyABIANB0ABqQQAgAygCUBsQ7iUgA0GMAWoiAiAHIAEQwhkgA0GsA2oiASACEM0cIAcgARCMDEHEAEEEEK02IgFFDQggAUKBgICAEDcCACABQQhqIAdBPPwKAAAgAEGg7P8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB6ABqEM8vIANBJGoQgCcgA0HwA2okAA8LIANBADYCxAIgA0GgA2ogA0HoAGogA0HEAmpBmOv/ABCjKwsAC0EBIAVBqOv/ABDDIQALQcjA/wBBI0HswP8AEMskAAtBrMH/AEEpIANBxAJqQcTI/wBB2MH/ABDVHgALQcAAIAQQoz0AC0EAQQBBuOv/ABDDIQALQQRBHBCjPQALQQRBxAAQoz0AC5YJAQx/IwBBgAJrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIIBEAgBUEgaiAAKAIEENw7IAUoAiQiBiAAKAIoIgdPBEAgASgCCEUNAyAFKAIgIQwgBUEYaiABKAIEENw7IAUoAhwiCCABKAIoIglJDQIgByAMaiENIAYgB2shDiAFKAIYIgogCWohCyAIIAlrIQggACgCLEUNDiAFQRBqIABBLGoiBhDcOyAFQegAaiIPIAUoAhAgBSgCFCAAKAI4IAJqIhAgBBD6EyAFQfQBaiAPENUJAkAgBSgC9AFBAUYEQCAFKAL4AQ0BIAUoAvwBIARHDQEMEAsgBEUNDwsgACgCQLggACgCJLijRJqZmZmZmdk/ZkUEQCAFQQhqIAYQ3DsgBUEoaiIAIAUoAgggBSgCDCAQIAQQ+hMgASgCLEUNBSAFIAFBLGoQ3DsgBUGoAWoiDCAFKAIAIAUoAgQgASgCOCADaiAEEPoTIAVB6ABqIABBwAD8CgAAIAVCADcD6AEDQCAFQfQBaiIAIAVB6ABqENUJAkAgBSgC9AFBAUYEQCAFKAL8ASEBIAUoAvgBIQQgACAMENUJIAUoAvQBDQELQQEhAAwSC0EAIQAgBCAFKAL4AUcNESABIAUoAvwBRw0RIAEgAmoiBiACIARqIgdJDQcgBiAOSw0IIAEgA2oiBiADIARqIglJDQkgBiAISw0KIAcgDWogASAEayIBIAkgC2ogARCfOw0ACwwQCyABKAIsRQ0JAkAgBEUEQEEAIQYMAQtBACEGIAEoAjwiDSADayILQQAgCyANTRshDSAAKAI8IgsgAmsiD0EAIAsgD08bIQsgDCACIAdqaiEHIAEoAjggA2ohDCAKIAMgCWpqIQkgASgCMCEBIAAoAjAhAANAIAYgC0YNDCAGIA1GDQ0CQAJAIAAgBiAQaiIKQQN2ai0AAEEBIApBB3F0cSIKRQ0AIAEgBiAMaiIPQQN2ai0AAEEBIA9BB3F0cUUNACACIAZqIgogDk8NECADIAZqIgogCE8NESAGIAdqQQEgBiAJakEBEJ87DQEMAwsgCg0CCyAEIAZBAWoiBkcNAAsgBCEGCyAEIAZNIQAMDwsgByAGQai9hwEQrzsAC0EAQQBBmL2HARDDIQALIAkgCEHIvYcBEK87AAtBAEEAQbi9hwEQwyEAC0HYvYcBELI7AAsgByAGQfi9hwEQsTsACyAGIA5B+L2HARCwOwALIAkgBkGIvocBELE7AAsgBiAIQYi+hwEQsDsAC0HovYcBELI7AAtB6LyHAUEgQYi9hwEQnykAC0HovIcBQSBBiL2HARCfKQALIApBAWogDkH4vYcBELA7AAsgCkEBaiAIQYi+hwEQsDsACyACIARqIgAgBEkNASAAIA5LDQIgAyAEaiIAIARJDQMgACAISw0EIAIgDWogBCADIAtqIAQQnzshAAsgBUGAAmokACAADwsgAiAAQfi9hwEQsTsACyAAIA5B+L2HARCwOwALIAMgAEGIvocBELE7AAsgACAIQYi+hwEQsDsAC4wIAQp/IwBBEGsiBiQAIAZBCGpCADcDACAGQgA3AwAgAAJ/AkAgAkECSQ0AAkACQAJAAkACQAJAAn8gAS0AAEE6RwRAQQAMAQsgAS0AAUE6Rw0HQQEhCkECCyIDIAJPBEBBAiEDQQEhDCAKIQQMAQsgCiEEQQEhDANAQQggBCAEQQhNGyEJA0AgBEEIRg0IIAEgA2otAABBOkYEQCAKDQlBASEKIARBAWoiBCEMIANBAWoiAyACSQ0CDAMLQQAhByADIQUCQCADIANBBGoiCCACIAIgCEsbIghPDQADQCABIAVqLQAAIgtBwQBrQV9xQQpqIAtBMGsgC0E5SxsiC0EPSw0BIAdBBHQgC3IhByAIIAVBAWoiBUcNAAsgCCEFCwJAIAIgBU0EQCAFIQMMAQsgASAFai0AACIIQTpHBEAgCEEuRyACIANNciADIAVGIARBBktycg0KQQAhCQJAA0AgCUEASgRAIAlBBE8NDSABIANqLQAAQS5HDQ0gA0EBaiEDCyACIANNDQxBACEHAkADQAJAAkAgASADai0AAEEwayILQf8BcSIIQQlNBEAgB0EBcUUNASAFQf//A3FFDREgBUEKbCALQf8BcWoiBUH//wNxQf8BSw0RDAILIAdBAXFFDRAMAwsgCCEFC0EBIQcgAiADQQFqIgNHDQALIAIhAwsgBEEITw0BIAYgBEEBdGoiCCAILwEAQQh0IAVqOwEAAkACQCAJQQFrDgMAAQABCyAEQQFqIQQLIAlBAWohCSACIANLDQALIAlBBEcNCwwFCyAEQQhB7JnEABDDIQALIAVBAWoiAyACRg0JCyAEIAlGDQMgBiAEQQF0aiAHOwEAIARBAWohBCACIANLDQALCwsgAiADSw0FIApFDQEgBCAMRg0EIARBAXQhCCAEQQFrIQogDCAEayEDIAZBDmohBUEAIQcDQCAHQQdqQQdLDQMgByAKakEITw0EIAUvAQAhAiAFIAUgCGpBEGsiAS8BADsBACABIAI7AQAgBUECayEFIAMgB0EBayIHRw0ACwwECyAJQQhBzJnEABDDIQALIARBCEcNAwwCC0F/QQhB3JnEABDDIQALIAQgB2pBAWtBCEHcmcQAEMMhAAsgACAGLwEOIgFBCHQgAUEIdnI7AA8gACAGLwEMIgFBCHQgAUEIdnI7AA0gACAGLwEKIgFBCHQgAUEIdnI7AAsgACAGLwEIIgFBCHQgAUEIdnI7AAkgACAGLwEGIgFBCHQgAUEIdnI7AAcgACAGLwEEIgFBCHQgAUEIdnI7AAUgACAGLwECIgFBCHQgAUEIdnI7AAMgACAGLwEAIgFBCHQgAUEIdnI7AAFBAAwBCyAAQQQ6AAFBAQs6AAAgBkEQaiQAC8oJAQZ/IwBB8ABrIgIkACACQdgAaiABEPAnIAJByABqIgQgAkHkAGoiBSgCADYCACACIAIpAlw3A0ACQCACKAJYIgZBBEcEQCACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAY2AgQgAEGAgICAeDYCACAAQRBqIAQoAgA2AgAMAQsgAkEwaiAEKAIANgIAIAIgAikDQDcDKCACQShqEIYwIAJBgICAgHg2AgggAkGAgICAeDYCGCACQdgAaiABENMJIAQgBSkCADcDACACQdAAaiIGIAJB7ABqKAIANgIAIAIgAikCXDcDQAJAAkAgAigCWEUEQCACQdwAaiEEA0AgAkE4aiAGKAIAIgM2AgAgAkEwaiACQcgAaiIFKQMANwMAIAIgAikDQDcDKAJAAkACQCADQf8BcQRAIAJB2ABqIAJBKGoQ/BcgAi8BXCEDIAIoAlgiB0EERwRAIAAgAikBXjcBCiAAQRBqIAJB5ABqKQEANwEAIAAgAzsBCCAAIAc2AgQgAEGAgICAeDYCAAwHCwJAAkACQCADQQFrDgIAAQILIAJB2ABqIAEQwhUgBSAEQQhqKAIANgIAIAIgBCkCADcDQCACKAJYIgNBBEYNAyACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAM2AgQgAEGAgICAeDYCACAAQRBqIAJByABqKAIANgIADAgLIAJB2ABqIAEQwhUgBSAEQQhqKAIANgIAIAIgBCkCADcDQCACKAJYIgNBBEcEQCACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAM2AgQgAEGAgICAeDYCACAAQRBqIAJByABqKAIANgIADAgLIAJB4ABqIgMgBSgCADYCACACIAIpA0A3A1ggAkEYahCGMCACQSBqIAMoAgA2AgAgAiACKQNYNwMYDAQLIAJB2ABqIAEgAi0AOEHAABDJAiACKAJYIgNBBEYNAyAAIAIpAlw3AgggAEEQaiACQeQAaikCADcCACAAQYCAgIB4NgIAIAAgAzYCBAwGCyACQShqEIYwIAJB2ABqIAEQqCkgAigCWCIBQQRHBEAgACACKQJcNwIIIABBEGogAkHkAGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQMBwsgAkHYAGpB8YvQAEEMIAJBCGoQ9R0gAigCWCIBQQRHBEAgACACKQJcNwIIIABBEGogAkHkAGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQMBwsgAigCCCIBQYCAgIB4Rg0BIAAgAikDGDcCDCAAIAIpAgw3AgQgACABNgIAIABBFGogAkEgaigCADYCAAwHCyACQeAAaiIDIAUoAgA2AgAgAiACKQNANwNYIAJBCGoQhjAgAkEQaiADKAIANgIAIAIgAikDWDcDCAwBC0H4/M8AQccAQYCM0AAQyyQACyACQShqEIYwIAJB2ABqIAEQ0wkgBSAEQQhqKQIANwMAIAYgBEEQaigCADYCACACIAQpAgA3A0AgAigCWEUNAAsLIAAgAikDQDcCBCAAQYCAgIB4NgIAIABBFGogBigCADYCACAAQQxqIAJByABqKQMANwIADAELIAJBKGoQhjALIAJBGGoQhjAgAkEIahCGMAsgAkHwAGokAAuFCAEZf0ECIRMgBgRAQQEgACgCzAEiBiAGQQFNG0EBaiETCyAAKALAASEOIAAoAlwhC0EAIAIoAgAiFiAWIAMgAyAAKAIEIgogACgCDCIGIAMgCmsgBGoiCUEBIAAoArgBdCIIayAGIAkgBmsgCEsbIAAoAhgiBxsiGGoiG0ZqIgAgCmsiCSAGIAkgCGsgBiAJIAZrIAhLGyAHG2siBksiGRshCEEAIAIoAgQiGiAGIBpJIhwbIQkgCkECaiEdIAMgBGoiEUEIayEUA0ACQAJAIBQgACATaiISQQFqIg9LBEAgACAOIAUQox0hDCAAQQFqIg0gDiAFEKMdIRUgCyAMQQJ0aigCACEGQQAgCGshHiAAQYABaiEXIBMhBANAIA8hECASIgcgHmoiEigAACEfIAsgDEECdGogACAKayIPNgIAAn8CQAJAIAgEQCAHKAAAIB9GDQELAkACQAJAAkAgBiAYSQ0AIAAoAAAgBiAKaigAAEcNACANIQcgFSEMIAAhDQwBCyALIBVBAnRqIgAoAgAhBiAHIA4gBRCjHSEMIAAgDSAKayIPNgIAIAYgGEkNAiANKAAAIAYgCmooAABHDQIgBEEFTw0BCyALIAxBAnRqIAcgCms2AgALIA0gBiAKaiIGayIEQQNqIQxBACEAA0AgACAGaiIJIhAgG00gACANaiIHIANNcg0HIAdBAWstAAAgCUEBay0AAEcNByAAQQFrIQAMAAsACyALIAxBAnRqKAIAIQYgECAOIAUQox0hFSAEIAdqIhIgF08NASAEDAILIBJBAWstAAAhACAHQQFrLQAAIQQgCyAVQQJ0aiANIAprNgIAQQVBBCAAIARGIgQbIQAgEiAEayEQIAcgBGshB0EBIQwgCCEEIAkhCAwFCyAXQYABaiEXIARBAWoLIAQgEGohDyEEIBAhDSAHIQAgDyAUSQ0ACwsgAiAIIBZBACAZGyAIGzYCACACIAkgFiAaQQAgHBsiACAIGyAAIBkbIAkbNgIEIBEgA2sPC0EEIABrIQALIAghBiABIAcgA2sgAyARIAwgACAHaiAAIBBqIBEQgBQgAGoiABCFEiAEIQggBiEJIAAgB2oiACEDIAAgFEsNACALIA8gHWogDiAFEKMdQQJ0aiAPQQJqNgIAIAsgAEECayIDIA4gBRCjHUECdGogAyAKazYCAEEAIQkgACEDIAZFDQADQAJAIAQhCCAAIBRLDQAgACgAACAAIAZrKAAARw0AIABBBGoiAyADIAZrIBEQgBQhAyALIAAgDiAFEKMdQQJ0aiAAIAprNgIAIAFBACAAIBFBASADQQRqIgMQhRIgACADaiEAIAYhBCAIIQYMAQsLIAYhCSAAIQMMAAsAC6MJAQl/IwBBMGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkEDcQRAIAQgAjYCKCAEQQM2AiRBhICAgHghCUEEIQdBgICAgHghA0G85P4AIQJBACEBDAELQX8gAkEEaiIDIAIgA0sbIgMgASgCBCIGTQRAIAEgASgCFEEEaiIDNgIUIAMgASgCCCgCCE0NAkGIgICAeCEJDAELIARBDGogAiADEL8vIAQoAgwiCUGKgICAeEYNASAEKAIgIQIgBCgCHCEDIAQoAhghCiAEKAIUIQcgBCgCECEBCyAEQQhqIARBLGooAgA2AgAgBCAEKQIkNwMADAELIAIgBk8NAiACQQFyIgMgBk8NAyACQQJyIgUgBk8NBCACQQNyIgcgBk8NBQJ/IAEoAgAiCCADai0AAEEIdCACIAhqLQAAciAFIAhqLQAAQRB0ciAHIAhqLQAAQRh0ciIDQQBMBEAgAiADayIFIAJPDAELIAIgA2shBSACIANPC0GGgICAeCEJQQQhB0EAIAUgBkkbDQFBACEBCyAAIAI2AhQgACADNgIQIAAgCjYCDCAAIAc2AgggACABNgIEIAAgCTYCACAAIAQpAwA3AhggAEEgaiAEQQhqKAIANgIADAkLIAVBAXEEQCAEIAU2AiggBEEDNgIkIARBs+T+ADYCICAEQoCAgICAgICAgH83AhggBEKAgICAwAA3AhBBhICAgHghA0EAIQIMCAsCQCAGQX8gBUECaiIDIAMgBUkbIgNPBEAgASABKAIUQQJqIgM2AhQgAyABKAIIKAIITQ0BQYiAgIB4IQMMCQsgBEEMaiAFIAMQvy8gBCgCDCIDQYqAgIB4Rg0AIAQvARAhAgwICyAFQQFyIgMgBk8NBUF/IAUgBSAIai0AACADIAhqLQAAQQh0ciIIaiIDIAMgBUkbIgNBAXEEQCAAIAM2AhwgAEEDNgIYIABBs+T+ADYCFCAAQYCAgIB4NgIQIABCBDcCCCAAQoSAgIAINwIADAkLAkAgAyAGTQRAIAEgASgCFCAIaiIGNgIUQYiAgIB4IQMgBiABKAIIIgcoAghNDQEMCAsgBEEMaiAFIAMQvy8gBCgCDCIDQYqAgIB4Rw0HIAEoAgghBwsgASABKAIQQQFqIgM2AhAgAyAHKAIESw0EIAEgASgCDEEBaiIDNgIMIAcoAgAgA08EQCAAIAg2AhAgACAFNgIMIAAgAjYCCCAAIAE2AgQgAEGKgICAeDYCAAwJCyAAQYmAgIB4NgIADAgLIAIgBkGw4v4AEMMhAAsgAyAGQcDi/gAQwyEACyAFIAZB0OL+ABDDIQALIAcgBkHg4v4AEMMhAAsgAEGHgICAeDYCAAwDCyADIAZB8OL+ABDDIQALIAAgBCkCEDcCBCAAQRxqIARBKGopAgA3AgAgAEEUaiAEQSBqKQIANwIAIABBDGogBEEYaikCADcCACAAIAM2AgAMAQsgACAEKQESNwEGIABBHGogBEEoaikBADcBACAAQRZqIARBImopAQA3AQAgAEEOaiAEQRpqKQEANwEAIAAgAjsBBCAAIAM2AgALIARBMGokAAujCQEJfyMAQTBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAJBA3EEQCAEIAI2AiggBEEDNgIkQYSAgIB4IQlBBCEHQYCAgIB4IQNBzPb+ACECQQAhAQwBC0F/IAJBBGoiAyACIANLGyIDIAEoAgQiBk0EQCABIAEoAhRBBGoiAzYCFCADIAEoAggoAghNDQJBiICAgHghCQwBCyAEQQxqIAIgAxC/LyAEKAIMIglBioCAgHhGDQEgBCgCICECIAQoAhwhAyAEKAIYIQogBCgCFCEHIAQoAhAhAQsgBEEIaiAEQSxqKAIANgIAIAQgBCkCJDcDAAwBCyACIAZPDQIgAkEBciIDIAZPDQMgAkECciIFIAZPDQQgAkEDciIHIAZPDQUCfyABKAIAIgggA2otAABBCHQgAiAIai0AAHIgBSAIai0AAEEQdHIgByAIai0AAEEYdHIiA0EATARAIAIgA2siBSACTwwBCyACIANrIQUgAiADTwtBhoCAgHghCUEEIQdBACAFIAZJGw0BQQAhAQsgACACNgIUIAAgAzYCECAAIAo2AgwgACAHNgIIIAAgATYCBCAAIAk2AgAgACAEKQMANwIYIABBIGogBEEIaigCADYCAAwJCyAFQQFxBEAgBCAFNgIoIARBAzYCJCAEQcP2/gA2AiAgBEKAgICAgICAgIB/NwIYIARCgICAgMAANwIQQYSAgIB4IQNBACECDAgLAkAgBkF/IAVBAmoiAyADIAVJGyIDTwRAIAEgASgCFEECaiIDNgIUIAMgASgCCCgCCE0NAUGIgICAeCEDDAkLIARBDGogBSADEL8vIAQoAgwiA0GKgICAeEYNACAELwEQIQIMCAsgBUEBciIDIAZPDQVBfyAFIAUgCGotAAAgAyAIai0AAEEIdHIiCGoiAyADIAVJGyIDQQFxBEAgACADNgIcIABBAzYCGCAAQcP2/gA2AhQgAEGAgICAeDYCECAAQgQ3AgggAEKEgICACDcCAAwJCwJAIAMgBk0EQCABIAEoAhQgCGoiBjYCFEGIgICAeCEDIAYgASgCCCIHKAIITQ0BDAgLIARBDGogBSADEL8vIAQoAgwiA0GKgICAeEcNByABKAIIIQcLIAEgASgCEEEBaiIDNgIQIAMgBygCBEsNBCABIAEoAgxBAWoiAzYCDCAHKAIAIANPBEAgACAINgIQIAAgBTYCDCAAIAI2AgggACABNgIEIABBioCAgHg2AgAMCQsgAEGJgICAeDYCAAwICyACIAZBxPX+ABDDIQALIAMgBkHU9f4AEMMhAAsgBSAGQeT1/gAQwyEACyAHIAZB9PX+ABDDIQALIABBh4CAgHg2AgAMAwsgAyAGQYT2/gAQwyEACyAAIAQpAhA3AgQgAEEcaiAEQShqKQIANwIAIABBFGogBEEgaikCADcCACAAQQxqIARBGGopAgA3AgAgACADNgIADAELIAAgBCkBEjcBBiAAQRxqIARBKGopAQA3AQAgAEEWaiAEQSJqKQEANwEAIABBDmogBEEaaikBADcBACAAIAI7AQQgACADNgIACyAEQTBqJAAL0AgBCH8CQCABQYAKSQRAIAFBBXYhBwJAAkAgACgCoAEiBQRAIAVBAWshAyAFQQJ0IABqQQRrIQIgBSAHakECdCAAakEEayEGIAVBKUkhBQNAIAVFDQIgAyAHaiIEQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRrIQIgA0EBayIDQX9HDQALCyABQSBJDQMgAEEANgIAIAdBAWoiAkECRg0DIABBADYCBCACQQNGDQMgAEEANgIIIAJBBEYNAyAAQQA2AgwgAkEFRg0DIABBADYCECACQQZGDQMgAEEANgIUIAJBB0YNAyAAQQA2AhggAkEIRg0DIABBADYCHCACQQlGDQMgAEEANgIgIAJBCkYNAyAAQQA2AiQgAkELRg0DIABBADYCKCACQQxGDQMgAEEANgIsIAJBDUYNAyAAQQA2AjAgAkEORg0DIABBADYCNCACQQ9GDQMgAEEANgI4IAJBEEYNAyAAQQA2AjwgAkERRg0DIABBADYCQCACQRJGDQMgAEEANgJEIAJBE0YNAyAAQQA2AkggAkEURg0DIABBADYCTCACQRVGDQMgAEEANgJQIAJBFkYNAyAAQQA2AlQgAkEXRg0DIABBADYCWCACQRhGDQMgAEEANgJcIAJBGUYNAyAAQQA2AmAgAkEaRg0DIABBADYCZCACQRtGDQMgAEEANgJoIAJBHEYNAyAAQQA2AmwgAkEdRg0DIABBADYCcCACQR5GDQMgAEEANgJ0IAJBH0YNAyAAQQA2AnggAkEgRg0DIABBADYCfCACQSFGDQMgAEEANgKAASACQSJGDQMgAEEANgKEASACQSNGDQMgAEEANgKIASACQSRGDQMgAEEANgKMASACQSVGDQMgAEEANgKQASACQSZGDQMgAEEANgKUASACQSdGDQMgAEEANgKYASACQShGDQMgAEEANgKcASACQSlGDQNBKEEoQZCMigEQwyEACyADQShBkIyKARDDIQALIARBKEGQjIoBEMMhAAtBuoyKAUEdQZCMigEQnykACyAAKAKgASIDIAdqIQIgAUEfcSIGRQRAIAAgAjYCoAEgAA8LAkAgAkEBayIEQSdNBEAgAiEFIAAgBEECdGooAgBBACABayIBdiIERQ0BIAJBJ00EQCAAIAJBAnRqIAQ2AgAgAkEBaiEFDAILIAJBKEGQjIoBEMMhAAsgBEEoQZCMigEQwyEACwJAIAdBAWoiCCACTw0AIAFBH3EhASADQQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2AgALIANBAkYNACACQQJ0IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2AgAgBCAJIAZ0IAMoAgAgAXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIAIAZ0NgIAIAAgBTYCoAEgAAu0DAACQAJAAkACQCAHQQFrDgMBAgMACwJAAkACQCAGQQFrDgIBAgALAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQAQ9QgPCyAAIAEgAiADQQVBABD1CA8LIAAgASACIANBBkEAEPUIDwsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBABDqAg8LIAAgASACIANBBUEAEOoCDwsgACABIAIgA0EGQQAQ6gIPCwJAAkACQCAEQQVrDgIBAgALAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EEQQBBBBCGBQ8LIAAgASACIANBBEEAQQUQhgUPCyAAIAEgAiADQQRBAEEGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQVBAEEEEIYFDwsgACABIAIgA0EFQQBBBRCGBQ8LIAAgASACIANBBUEAQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBkEAQQQQhgUPCyAAIAEgAiADQQZBAEEFEIYFDwsgACABIAIgA0EGQQBBBhCGBQ8LAkACQAJAIAZBAWsOAgECAAsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBARD1CA8LIAAgASACIANBBUEBEPUIDwsgACABIAIgA0EGQQEQ9QgPCwJAAkACQCAEQQVrDgIBAgALIAAgASACIANBBEEBEOoCDwsgACABIAIgA0EFQQEQ6gIPCyAAIAEgAiADQQZBARDqAg8LAkACQAJAIARBBWsOAgECAAsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQRBAUEEEIYFDwsgACABIAIgA0EEQQFBBRCGBQ8LIAAgASACIANBBEEBQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBUEBQQQQhgUPCyAAIAEgAiADQQVBAUEFEIYFDwsgACABIAIgA0EFQQFBBhCGBQ8LAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EGQQFBBBCGBQ8LIAAgASACIANBBkEBQQUQhgUPCyAAIAEgAiADQQZBAUEGEIYFDwsCQAJAAkAgBkEBaw4CAQIACwJAAkACQCAEQQVrDgIBAgALIAAgASACIANBBEECEPUIDwsgACABIAIgA0EFQQIQ9QgPCyAAIAEgAiADQQZBAhD1CA8LAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQIQ6gIPCyAAIAEgAiADQQVBAhDqAg8LIAAgASACIANBBkECEOoCDwsCQAJAAkAgBEEFaw4CAQIACwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBEECQQQQhgUPCyAAIAEgAiADQQRBAkEFEIYFDwsgACABIAIgA0EEQQJBBhCGBQ8LAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EFQQJBBBCGBQ8LIAAgASACIANBBUECQQUQhgUPCyAAIAEgAiADQQVBAkEGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQZBAkEEEIYFDwsgACABIAIgA0EGQQJBBRCGBQ8LIAAgASACIANBBkECQQYQhgUPCwJAAkACQCAGQQFrDgIBAgALAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQMQ9QgPCyAAIAEgAiADQQVBAxD1CA8LIAAgASACIANBBkEDEPUIDwsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBAxDqAg8LIAAgASACIANBBUEDEOoCDwsgACABIAIgA0EGQQMQ6gIPCwJAAkACQCAEQQVrDgIBAgALAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EEQQNBBBCGBQ8LIAAgASACIANBBEEDQQUQhgUPCyAAIAEgAiADQQRBA0EGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQVBA0EEEIYFDwsgACABIAIgA0EFQQNBBRCGBQ8LIAAgASACIANBBUEDQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBkEDQQQQhgUPCyAAIAEgAiADQQZBA0EFEIYFDwsgACABIAIgA0EGQQNBBhCGBQvKCQEKfyMAQYADayICJAAgAUEYaiEGAkACQAJAAkACQAJAAkACQCABLQAYQSdGBEAgAkEwaiABENw7IAIoAjRBAUcNASACQShqIAEQ7zwgAigCLEEBRw0CIAJBGGogARDvPCACKAIcRQ0EIAJB6AJqIAIoAhgiA0EYahDUBiADKAIoIQcgAygCJCEIIAJB9AJqIAMQvhUgAkGwAWogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQQgAygCQCEFIAMoAjwhCSADKAI4IQogAygCNCELIAMoAjAhAwsgAkHYAGogAkHwAmooAgA2AgAgAkFAayACQfwCaigCADYCACACQcwAaiACQbgBaigCADYCACACIAIpAugCNwNQIAIgBzYCYCACIAg2AlwgAiACKQL0AjcDOCACIAIpArABNwJEIAIgBTYCeCACIAk2AnQgAiAKNgJwIAIgCzYCbCACIAM2AmggAiAENgJkIAItAFBBIEcNBSACQRBqIAJB1ABqIgMQwzQgAigCFEECRwRAIAJBCGogAxDDNCACQTs2AvgCIAJBAjYCtAEgAkGA34UBNgKwASACQgE3ArwBIAIgAigCDDYC6AIgAiACQegCajYC9AIgAiACQfQCajYCuAEMBwsgAkGwAWoiAyACQThqQcQA/AoAACACQfwAaiADEIYXIAJB+AFqIAEQshggAkG4AmogBhDUBgJAIAEoAiwiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNBSACIAM2AtACIAIgASgCQDYC5AIgAiABKQI4NwLcAiACIAEpAjA3AtQCDAELIAJBADYC0AILIAJBhAJqIgQgAkH8AGpBNPwKAAAgAkHMAmogAkGAAmooAgA2AgAgAiACKQL4ATcCxAIgAigChAIgARCJJ0GAgICAeEYNCCAAIARB5AD8CgAAIAJBgANqJAAPCyACQQE2ArQBIAJBnOGFATYCsAEgAkIBNwK8ASACQacENgI8IAIgBjYC9AIgAiACQThqNgK4ASACIAJB9AJqNgI4IAJBjAJqIAJBsAFqEJkOIAJBjYCAgHg2AogCDAYLIAJBATYCtAEgAkHg4IUBNgKwASACQgE3ArwBIAJBOzYCPCACIAEoAiQ2AvQCIAIgAkE4ajYCuAEgAiACQfQCajYCOCACQYwCaiACQbABahCZDiACQY2AgIB4NgKIAgwFCyACQSBqIAEQ7zwgAkE7NgI8IAJBATYCtAEgAkGQ4IUBNgKwASACQgE3ArwBIAIgAigCJDYC9AIgAiACQfQCajYCOCACIAJBOGo2ArgBIAJBjAJqIAJBsAFqEJkOIAJBjYCAgHg2AogCDAQLAAtBAEEAQazehQEQwyEACyACQQE2ArQBIAJBxN+FATYCsAEgAkIBNwK8ASACQa8DNgL4AiACIAJB0ABqNgLoAiACIAJB9AJqNgK4ASACIAJB6AJqNgL0AgsgAkGMAmogAkGwAWoQmQ4gAkGNgICAeDYCiAIgAkE4ahCJJwsgARCJJwsgAkHAAWogAkGYAmooAgA2AgAgAkG4AWogAkGQAmopAgA3AwAgAiACKQKIAjcDsAFB3N2FAUE+IAJBsAFqQZzPhQFBnN6FARDVHgALrQgBC38jAEHgAGsiBiQAAkAgA0EhSQRAIAIhCSAAKAIIIAAoAhhrQQN0IAAoAhwiBWsiBCACIANsTw0BIAMEQCAEIANuIQkMAgtBmLfOABDiKwALQci2zgBBMEGIt84AEJ8pAAtBACEEAkACQAJAAkACQAJAAkAgBUUgCUVyDQAgASEFA0AgBkEQaiAAIAMQjw0gBigCEEEBcUUNAyACIARGDQIgBSAGKAIUNgIAIARBAWoiBCAJTw0BIAVBBGohBSAAKAIcDQALCyAJIARrIgpBIEkEQCAEIQUMBgsgA0ECdCEMIAAoAggiDSAAKAIYIgdrIQggASAEQQJ0aiELIAAoAgQhDgNAIARBX0sNAyAEQSBqIgUgAksNBCAHIA1LDQUgByAOaiAIIAsgAxDYCyAAIAcgDGoiBzYCGCAIIAxrIQggC0GAAWohCyAFIQQgCkEgayIKQR9LDQALDAULIAIgAkGYus4AEMMhAAtB/LjOAEEaQYi6zgAQyyQACyAEIARBIGpBrLjOABCxOwALIARBIGogAkGsuM4AELA7AAsgByANQby4zgAQrzsACwJAIApBD00gA0EQS3INACAGQTBqIgpCADcDACAGQShqIgtCADcDAEEIIQQgBkEgaiIMQgA3AwAgBkIANwMYIAAoAggiCCAAKAIYIgdPBEAgACgCBCAHaiAIIAdrIAZBGGogAxDIECAAIAcgA0EBdGo2AhggBkHYAGogCikDADcCACAGQdAAaiALKQMANwIAIAZByABqIAwpAwA3AgAgBiAGKQMYNwJAIAUgAiACIAVJGyEIIAEgBUECdGohBwNAIAUgCEcEQCAHIAZBOGogBGovAQA2AgAgB0EEaiEHIAVBAWohBSAEQQJqIgRBKEcNAQwDCwsgCCACQci5zgAQwyEACyAHIAhB3LjOABCvOwALAkAgCSAFa0EHTSADQQhLcg0AIAZCADcDGCAAKAIIIgcgACgCGCIETwRAIAAoAgQgBGogByAEayAGQRhqIAMQtBYgACADIARqNgIYIAYgBikDGDcCQCABIAVBAnRqIQcgBSAFIAIgAiAFSRsiCGshCiAGQQg2AjxBACEEAkADQCAEIApqRQ0BIAcgBCAGakFAay0AADYCACAHQQRqIQcgBEEBaiIEQQhHDQALIAZBCDYCOCAEIAVqIQUMAgsgCCACQbi5zgAQwyEACyAEIAdB7LjOABCvOwALAkACQCAFIAlJBEAgCSAFayEIIAEgBUECdGohByAFIAIgAiAFSRsiASAFayEEA0AgBkEIaiAAIAMQjw0gBigCCEEBcUUNAyAERQ0CIAcgBigCDDYCACAEQQFrIQQgB0EEaiEHIAhBAWsiCA0ACwsgBkHgAGokACAJDwsgASACQai5zgAQwyEAC0H8uM4AQRpBmLnOABDLJAALuQ4BEX8jAEGgAWsiAyQAIAMgAjYCGCADQQA2AhwgA0EANgIgQcAAIQUCQAJAAkACQAJAAkAgASgCDCABKAIEayIHQQZ2IAdBOHFBAEdqIgRBwP//P3FBQGsgBCAEQT9xGyIEQcAAENE0BEAgBARAIARBwAAQrTYiBUUNAgsgA0EANgIwIAMgBTYCLCADIAQ2AiggA0HAADYCJCAHQQN2IAJsIgRBP3EiAgRAIAQgBCACa0FAayIESw0DCyAEQcAAENE0RQ0GQcAAIQIgBARAIARBwAAQrTYiAkUNBAsgA0EANgJAIAMgAjYCPCADIAQ2AjggA0HAADYCNCADIANBNGoiETYCmAEgAyADQRxqNgKUASADIANBGGo2ApABIAMgA0EkaiISNgKMASADIANBIGo2AogBIANB8ABqIQsgA0GIAWohBiMAQdAAayICJABBk4CAgHghDgJAIAEoAgQiBSABKAIMIghGDQAgBigCECEEIAYoAgwhDCAGKAIIIQ8gBigCBCEHIAYoAgAhEANAIAUoAgQhBiAFKAIAIQogASAFQQhqIg02AgQgECAQKAIAIgUEfyAFBSAHKAIMIgVBAWoiCSAHKAIEIhNLBH8gByATQQF0IgUgCRDVKiIJIAUgCUsbEOgZIAcoAgwFIAULIAcoAghqQQA6AAAgByAHKAIMQQFqNgIMQQgLQQFrNgIAIA8oAgAhBQJAAn8CQCAKBEAgBSAGRg0BIAIgBjYCPCACQQI2AiggAkHI94MBNgIkIAJCAjcCMCACQTs2AkwgAkGcAzYCRCACIA82AkAgAiACQUBrNgIsIAIgAkE8ajYCSCACQRRqIAJBJGoQmQ4gC0EMaiACQRxqKQIANwIAIAsgAikCFDcCBEGNgICAeCEODAULAkAgBCgCDCIGIAVqIgogBk0NACAEKAIEIgkgCkkEQCAEIAlBAXQiBiAKENUqIgkgBiAJSxsQ6BkgBCgCDCEGCyAFRQ0AIAQoAgggBmpBACAF/AsACyAEIAo2AgwgDQwBCyACQQhqIAcQhj0gDCgCACIIQQN2IgUgAigCDCINTw0BIAIoAgggBWoiBSAFLQAAQQEgCEEHcXRyOgAAIAQoAgwiBSAGaiIIIAQoAgQiDUsEQCAEIA1BAXQiBSAIENUqIgggBSAISxsQ6BkgBCgCDCEFCyAGBEAgBCgCCCAFaiAKIAb8CgAACyAEIAQoAgwgBmo2AgwgASgCDCEIIAEoAgQLIQUgDCAMKAIAQQFqNgIAIAUgCEcNAQwCCwsgBSANQYz4gwEQwyEACyALIA42AgAgAkHQAGokAAJAIAMoAnAiAkGTgICAeEcEQCAAIAMpAnQ3AgggAEEQaiADQfwAaikCADcCACAAQSk6AAAgACACNgIEIBEQzy8gEhDPLwwBCyADKAIsIQIgAygCMCEEIAMgAykCJDcClAEgA0EANgKQASADIAQ2AowBIAMgAjYCiAEgA0EQaiADQYgBaiIFENc7IAMoAhAhB0EcQQQQrTYiAkUNBSACQoGAgIAQNwIAIAIgAykCiAE3AgggAkEQaiADQZABaikCADcCACACQRhqIANBmAFqKAIANgIAIAMgBDYCeCADIAc2AnQgAyACNgJwIANBxABqIgIgA0HwAGpBACADKAIcEPIVIAUgAhDhJyADQfgAaiIHIANBlAFqIgYpAgA3AwAgA0GAAWoiCyADQZwBaiIMKAIANgIAIAMgAykCjAE3A3BBACEEAkAgAygCiAEiAkUNACAGIAcpAwA3AgAgDCALKAIAIgQ2AgAgAyACNgKIASADIAMpA3A3AowBIARFBEAgAiACKAIAIgJBAWs2AgBBACEEIAJBAUcNASAFEPseDAELIANB6ABqIANBgAFqKAIANgIAIANB4ABqIANB+ABqKQMANwMAIAMgAykDcDcDWCACIQQLIAMoAhghByADKAI8IQIgAygCQCEFIAMgAykCNDcClAEgA0EANgKQASADIAU2AowBIAMgAjYCiAEgA0EIaiADQYgBahDXOyADKAIIIQZBHEEEEK02IgJFDQYgAkKBgICAEDcCACACIAMpAogBNwIIIAJBEGogA0GQAWopAgA3AgAgAkEYaiADQZgBaigCADYCACAAIAMpA1g3AhwgAEEkaiADQeAAaikDADcCACAAQSxqIANB6ABqKAIANgIAIAAgAygCGDYCNCAAIAMoAhw2AjAgACAENgIYIAAgBTYCFCAAIAY2AhAgACACNgIMIAAgBzYCBCAAQRU6AAALIwBBEGsiACQAIAAgASgCADYCDCAAIAEoAgg2AgggAEEIakEEQQgQ4B4gAEEQaiQAIANBoAFqJAAPCwwFC0HAACAEEKM9AAtB/PyDAUEjQaD9gwEQyyQAC0HAACAEEKM9AAtBBEEcEKM9AAtBBEEcEKM9AAtBsP2DAUEpIANBiAFqQfz9gwFB3P2DARDVHgALg0YCHX8DfiMAQdAAayIPJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBUEBcQRAIAQgBCgCCCIZIAZqEI4tIAQoAggiDCAZSQ0BIAMiB0EISQ0HIAQoAgQgGWohEiACIQggByEKIAwgGWsiDiELA0AgCkEDTQ0DIApBB00NBCAHQQhrIg0gCCgABCIHQRh0IAdBgP4DcUEIdHIgB0EIdkGA/gNxIAdBGHZyciIMSQ0FAkACQCAIKAAAIgdBGHQgB0GA/gNxQQh0ciAHQQh2QYD+A3EgB0EYdnJyIgkgDk0EQCAKQQhrIgogDEkNCSAPQQA2AjggDyALNgI0IA8gEjYCMCAPQSRqIAhBCGoiCCAMIA9BMGoQhAQgDygCJEEERg0CQQxBBBCtNiIHDQFBBEEMEKM9AAsgD0EQakGM3NAAQSoQyhoMDAsgByAPKQIkNwIAIAdBCGogD0EsaigCADYCACAPQYza0AA2AjggDyAHNgI0IA9BBTYCMEEYQQgQrTYiB0UEQEEIQRgQoz0ACyAHIA9BMGoiCCkDADcDACAHQRBqIAhBEGopAwA3AwAgB0EIaiAIQQhqKQMANwMAIA9BCGoiCEGw880ANgIEIAggBzYCACAPQRBqQSggDygCCCAPKAIMEMkpDAsLAkAgCSAPKAIoRgRAIAkgEGohECANIAxrIgcgDEsNAQwKCyAPQRBqQfDb0ABBHBDKGgwLCyAJIAtLDQcgCSASaiESIAsgCWshCyAOIAlrIQ4gCiAMayEKIAggDGohCCAHQQdLDQALDAgLIA9BMGpBMkEAQQFBARCgGCAPKAI0IQIgDygCMEEBRg0LIA8oAjgiAUHX3NAAQTL8CgAAIABBMjYCDCAAIAE2AgggACACNgIEIABBADYCAAwKCyAZIAxBnN3QABCvOwALQQQgCkGU29AAELA7AAtBCCAKQaTb0AAQsDsACyAPQRBqQbbc0ABBIRDKGgwECyAMIApBtNvQABCwOwALIAkgC0Hg29AAEK87AAsgB0UNAgsgD0EQakHE29AAQRoQyhoLIA8tABBBBEYEQCAPKAIUIRAMAQsgAS0AAEUEQCAPIA8pAxA3AxggACAPQRhqEIErDAILIAQgGRD0NCAPQTBqISBBACEBIwBBkCFrIgkkACAJQShqENMmIAlB/ABqQgA3AgAgCUGEAWpBADYCACAJIAM2AiQgCSACNgIgIAlCADcCdCAJQQE2AnAgCUIANwNoIAlCgICAgBA3A2AgCUIANwNYIAlCAjcDACAJQYgBakEAQYAg/AsAAkACQAJAA0ACQCAJQYghaiEbIAlBiAFqISIjAEEQayIcJAACQANAAkACQAJAAkAgCSgChAEiCCAJKAKAASIHTQRAIBxBCGohEiMAQRBrIh0kAAJAAkAgCSkDAEICUg0AIB1BCGohFEEAIQ1CACEmQgAhJUEAIRojAEGgAWsiDCQAIAxBF2pBADYAACAMQRBqQgA3AwAgDEIANwMIQQQgCSgCJCIIIAhBBE8bIQsgCSgCICEOAkACQAJAAkACQAJAAkACQCAIQQFHBEAgCwRAIAxBCGogDiAL/AoAAAsgCSAIIAtrIgo2AiQgCSALIA5qIgc2AiACQAJAIAsOBQQAAAABAAsgCEEESQ0CQQQgC2siCARAIAxBCGogC2ogByAI/AoAAAsgCSAKIAhrIgo2AiQgCSAOQQRqIgc2AiALIAwoAghBgsKwwgFHDQQgCiEIDAcLIAwgDi0AADoACEEBIAtrIQoLQQAhCCAJQQA2AiQgCSALIA5qIApqIgc2AiBBqKHQACkDACIkQv8Bg0IEUg0BIAwoAghBgsKwwgFGDQUgDEEIakEEciEIQQAhEEEAIQoMAwsgFEEEOgAAIBRBADYCBAwFCyAUICQ3AgAMBAtBAyAKIApBA08bIRAgCkEBRwRAIAxBCGpBBHIhCAwBCyAJQQEgEGsiFzYCJCAJIAcgEGoiEzYCICAMIActAAA6AAxBASEKDAELIBAEQCAIIAcgEPwKAAALIAkgCiAQayIXNgIkIAkgByAQaiITNgIgIAoNACAUQQQ6AAAgFEEANgIEDAILIAcgEGohByAQQQNzIgsgF00EQCAMIBBqQQxqIQ4gFyALayEIIAcgC2ohBwJAIApBAkcEQCALRQ0BIA4gEyAL/AoAAAwBCyAOIBMtAAA6AAALIAkgCDYCJCAJIAc2AiAMAQtBACEIIAlBADYCJCAJIAcgF2oiBzYCIEGoodAAKQMAIiRC/wGDQgRRDQAgFCAkNwIADAELIAxBIGoiCgJ/IAoCf0EEIAxBCGoiCygAACIKQYLCsMIBRg0AGkEIIApBcHFB0NS0wgFGDQAaQQUgCkGExLTCAUcNARpBD0EHIAstAAQiCkEIcRsgCkECdEEEcWoLNgIEQQ8LOgAAIAwtACAiCkEPRwRAIAxBgAFqIAxBMGopAwA3AwAgDCAMLQAjOgBzIAwgDC8AITsAcSAMIAwpAyg3A3ggDCAMKAIkNgJ0IAwgCjoAcCAUIAxB8ABqEIspDAELAkACQCAMKAIkIhFBBGsOBAEAAAEACwJAIBFBB08EQCARQRNLDQEgEUEHayIKIAhNBEAgCCAKayEIIAcgCmohCwJAIApBAUcEQCAKRQ0BIAxBCGpBB3IgByAK/AoAAAwBCyAMIActAAA6AA8LIAkgCDYCJCAJIAs2AiAMAwsgCUEANgIkIAkgByAIajYCIEGoodAAKQMAIiRC/wGDQgRRDQIgFCAkNwIADAMLQQcgEUG0yNAAELE7AAsgEUETQbTI0AAQsDsACyAMQfAAaiEOIAxBCGohB0EAIRcjAEEwayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCARQQNNBEBBqMfRACkDACIkQv8Bg0IEUQ0BIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADA0LIAcoAAAiCkGCwrDCAUYNBSARQQRrIRAgB0EEaiEIIApBcHFB0NS0wgFGDQEgCkGExLTCAUYNAgsgDkICNwMAIA5BBToACAwLCyAQQQRJDQEgCCgAACEIDAILIBBBAU0EQEGox9EAKQMAIiRC/wGDQgRRDQQgCyAkNwMAIA5BCGogCxCHFiAOQgI3AwAMCgsgBy0ABCIYQcABcSINQcAARw0DIActAAUiCiAYQQJxckGPAXFFBEAgCkEEdkEHcSIeQQNNBEAgDiAeOgAJIA5BAzoACCAOQgI3AwAMCwsgEUEGayENAkACQAJAAn8CQAJAAkACQCAYQQhxBH8gDUEISQ0BIBFBDmshDSAHKQAGISZCASElIAdBDmoFIAdBBmoLIQcgGEEBcQ0BQQAMBAtBqMfRACkDACIkQv8Bg0IEUg0OQgEhJSAYQQFxDQFBfyETQQAhDQwGCyANQQNLDQFBqMfRACkDACEkCyAkQv8Bg0IEUg0CQX8hE0EBIRdBACENDAQLIA1BBGshDSAHKAAAIRogB0EEaiEHQQELIRcgDUUNAUEAIA1rIRMgBy0AACENDAILIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADAwLQQAhDUF/IRNBqMfRACkDACIkQv8Bg0IEUg0KCyALENMmIBEgE2oiB0EESQ0FIAcgEUsNBiAHQQRrIQogC0EcaiEfAkACQAJAIAsoAixFBEAgCiEHDAELIAsoAiwiB0ERTw0BIApBECAHayIQIAogEEkbIhAEQCAHIB9qIAggEPwKAAALIAsgCygCLCAQaiIHQQAgB0EQRyITGzYCLCAKIBBrIQcgCCAQaiEIIBMNACALIAsoAgAgCygCHEH3lK+veGxqQQ13QbHz3fF5bDYCACALIAsoAgQgCygCIEH3lK+veGxqQQ13QbHz3fF5bDYCBCALIAsoAgggCygCJEH3lK+veGxqQQ13QbHz3fF5bDYCCCALIAsoAgwgCygCKEH3lK+veGxqQQ13QbHz3fF5bDYCDAsgB0EQTwRAIAsoAgwhEyALKAIIIRAgCygCBCEWIAsoAgAhFQNAIAgoAABB95Svr3hsIBVqQQ13QbHz3fF5bCEVIAhBDGooAABB95Svr3hsIBNqQQ13QbHz3fF5bCETIAhBCGooAABB95Svr3hsIBBqQQ13QbHz3fF5bCEQIAhBBGooAABB95Svr3hsIBZqQQ13QbHz3fF5bCEWIAhBEGohCCAHQRBrIgdBD0sNAAsgCyATNgIMIAsgEDYCCCALIBY2AgQgCyAVNgIACyAHBEAgBwRAIB8gCCAH/AoAAAsgCyAHNgIsCyALIAspAxAgCq18NwMQDAELIAdBEEHgyNEAEK87AAsgDUH/AXECfiALKQMQISQgCygCGCEKIAtBHGohCCALKAIsIgdBEUkEQAJ/ICRCEFoEQCALKAIEQQd3IAsoAgBBAXdqIAsoAghBDHdqIAsoAgxBEndqDAELIApBsc/ZsgFqCyAkp2ohECAHQQRPBEADQCAIKAAAQb3cypV8bCAQakERd0Gv1tO+AmwhECAIQQRqIQggB0EEayIHQQNLDQALCyAHBEADQCAILQAAENQ9QbHP2bIBbCAQakELd0Gx893xeWwhECAIQQFqIQggB0EBayIHDQALCyAQQQ92IBBzQfeUr694bCIHQQ12IAdzQb3cypV8bCIHQRB2IAdzrQwBCyAHQRBB8MjRABCwOwALp0EIdkH/AXFGBEAgDiAeOgAcIA5BADoAGyAOIBo2AhQgDiAXNgIQIA4gJjcDCCAOICU3AwAgDiAYQQJ2QQFxOgAaIA4gGEEEdkEBcToAGSAOIBhBf3NBBXZBAXE6ABgMCwsgDkICNwMAIA5BCToACAwKCyAOQgI3AwAgDkEGOgAIDAkLQQAhCEGox9EAKQMAIiRC/wGDQgRSDQYLIA4gCDYCDCAOQQw6AAggDkICNwMADAcLIA5BCDoAHCAOQYCAgAg2AhggDkEANgIQIA5CADcDAAwGCyAOIA06AAkgDkEEOgAIIA5CAjcDAAwFC0EEIAdBmMzRABCxOwALIAcgEUGYzNEAELA7AAsgCyAkNwMAQejH0QBBKyALQZTI0QBBiMzRABDVHgALIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADAELIAsgJDcDACAOQQhqIAsQhxYgDkICNwMACyALQTBqJAAgDEHIAGoiByAMQYABaiIKKQMANwMAIAxB0ABqIgggDEGIAWopAwA3AwAgDCAMKQN4NwNAIAwpA3AiJEICUQRAIAogCCkDADcDACAMQfgAaiAHKQMANwMAIAwgDCkDQDcDcCAUIA4QiykMAQsgDEHoAGoiCiAIKQMAIiY3AwAgDEHgAGoiCCAHKQMAIiU3AwAgDEEwaiAlNwMAIAxBOGogJjcDACAMIAwpA0AiJjcDWCAMICQ3AyAgDCAmNwMoICWnRQRAIAxBPGoQ6CkhByAJQQA2AnQgCUEANgJoIAwtADghCyAJQeAAaiAHQcTI0AAQ5zUgCUHsAGogB0EBdEGAgARqIAcgCxtB1MjQABDnNSAJICQ3AwAgCSAMKQNYNwMIIAlBEGogCCkDADcDACAJQRhqIAopAwA3AwAgDEHwAGoiBxDTJiAJQShqIAdBMPwKAAAgCUEANgKEASAJQgA3AnwgCUIANwNYIBQgETYCBCAUQQQ6AAAMAQsgDEENOgBwIBQgDEHwAGoQiykLIAxBoAFqJAACQCAdLQAIQQRGBEAgHSgCDCEIDAELIB0pAwgiJEL/AYNCBFEEQCAkQiCIpyEIDAELIBIgJDcCAAwCCyAIDQAgEkEEOgAAIBJBADYCBAwBC0EAIQtBACEOIwBBQGoiDSQAAkACQCAJKQMAQgJSBEAgCUEcahDoKSEKIAktABhFBEAgCUIANwOAAQwDCyAJKAJsIAkoAoABIgggCmpJDQEgCCAJKAJ8IgdqIghBgIAETQ0CIAkgByAIQYCABGsiCCAHIAcgCEsbIgdrNgJ8IAkgCSgCeCAHajYCeAwCC0G0x9AAELI7AAsgCUEANgKEASAJQoCABDcCfCAJIAhBgIAEazYCeAsgDUEANgIMIAkoAiAhBwJAAkACQCAJKAIkIghBBE8EQCAJIAhBBGs2AiQgCSAHQQRqNgIgIA0gBygAADYCDAwBCyAJQQA2AiQgCSAHIAhqNgIgQaih0AApAwAiJEL/AYNCBFINAQsgDUEQaiEHIwBBEGsiDCQAAkAgDUEMaigAACIIRQRAIAdBDzoAACAHQQI2AgQMAQsgCEEATgRAIAcgCDYCCCAHQQA2AgQgB0EPOgAADAELIAdBATYCBCAHQQ86AAAgByAIQf////8HcTYCCAsgDEEQaiQAIA0tABAiB0EPRwRAIA1BPGogDUEkaigCADYCACANIA0tABM6ACsgDSANLwAROwApIA0gDSkCHDcCNCANIA0pAhQ3AiwgDSAHOgAoIBIgDUEoahCLKQwCCyANKAIYIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA0oAhRBAWsOAgECAAsCQAJAAkACQAJAIAcgCk0EQCAJKAJoIgggB0kEQCAJQeAAaiAHEI4tIAkoAmghCAsgByAISw0IIAkoAiAhCCAJKAIkIgwgB0kNASAJKAJkIREgDCAHayELIAcgCGohECAHQQFGDQIgB0UNAyARIAggB/wKAAAMAwsgDUEIOgAoIBIgDUEoahCLKQwZCyAJQQA2AiQgCSAIIAxqIgg2AiBBqKHQACkDACIkQv8Bg0IEUQ0CIBIgJDcCAAwYCyARIAgtAAA6AAALIAkgCzYCJCAJIBA2AiAgCS0AGQ0BDAwLIAktABlBAUcNCyAJIAg2AiAMCgsgC0EETwRAIAkgC0EEazYCJCAJIBBBBGo2AiAgECgAACELDAoLQQAhCyAJQQA2AiQgCSAIIAxqNgIgQaih0AApAwAiJEL/AYNCBFENCSASICQ3AgAMFAsCQAJAAkACQAJAIAcgCk0EQCAJQewAaiEMIAkoAoABIgsgB2oiCCAJKAJ0IgpLBEAgDCAIEI4tIAkoAnQhCgsgCCALSQ0IIAggCksNCSAJKAIgIQogCSgCJCIOIAdJDQEgCSgCcCALaiEQIA4gB2shCCAHIApqIQsgB0EBRg0CIAdFDQMgECAKIAf8CgAADAMLIA1BCDoAKCASIA1BKGoQiykMGAsgCUEANgIkIAkgCiAOaiIINgIgQaih0AApAwAiJEL/AYNCBFENAiASICQ3AgAMFwsgECAKLQAAOgAACyAJIAg2AiQgCSALNgIgIAktABlFDQwgCEEESQ0BIAkgCEEEazYCJCAJIAtBBGo2AiAgCygAACEIDAkLIAktABlBAUcNCyAJIAg2AiBBACEIDAgLQQAhCCAJQQA2AiQgCSAKIA5qNgIgQaih0AApAwAiJEL/AYNCBFENByASICQ3AgAMEwsgCSgCAARAIAkpA1giJCAJKQMIIiVSDQQLIAktABpFDQUgCSgCICEHIAkoAiQiCkEETwRAIAkgCkEEazYCJCAJIAdBBGo2AiAgBygAACEIDAULQQAhCCAJQQA2AiQgCSAHIApqNgIgQaih0AApAwAiJEL/AYNCBFENBCASICQ3AgAMEgsgByAIQfTI0AAQsDsACyALIAhB9MjQABCxOwALIAggCkH0yNAAELA7AAsgDSAkNwM4IA0gJTcDMCANQQ46ACggEiANQShqEIspDA4LIAggCUEoahC0EqdGDQAgDUELOgAoIBIgDUEoahCLKQwNCyASQQA2AgQgCUICNwMAIBJBBDoAAAwMCwJAAkAgCSgCgAEiCiILIAcgCmoiCk0EQCAKIAwoAggiDksNASAMKAIEIQwgDSAKIAtrNgIEIA0gCyAMajYCAAwCCyALIApBlMjQABCxOwALIAogDkGUyNAAELA7AAsgDUEoaiANKAIAIA0oAgQgCBCkJCANLQAoQQRGDQIgDSkDKCIkQv8Bg0IEUQ0CIBIgJDcCAAwLCyAJKAJoIgggB08EQCANQShqIAkoAmQgByALEKQkIA0tAChBBEYNASANKQMoIiRC/wGDQgRRDQEgEiAkNwIADAsLIAcgCEHEx9AAELA7AAsCQAJAIAktABgEQCAJKAJ8IhQNAQsgByAJKAJoIghLDQMgCSgCZCEOIAlB7ABqIgwgCSgCgAEiCCAKahCOLSAMKAIIIgsgCEkEQCAIIAtBxMbQABCwOwALIAwoAgQhDCANQShqIgogCDYCCCAKIAs2AgQgCiAMNgIAIA1BEGogDiAHIAoQhAQMAQsgCSgCdCIKIAkoAngiCEkNAyAUIAogCGsiCksNBCAHIAkoAmgiCksNBSAJKAKAASIKIAhLDQYgCSgCcCEMIAkoAmQhCyANIAo2AjAgDSAINgIsIA0gDDYCKCANQRBqIREgDUEoaiETIAggDGohHkEAIRACQAJAAkAgBwRAIAcgC2oiF0ETIAcgB0ETTxtrIR8gEygCACIYIBMoAgQiB0EzayIIQQAgByAITxtqISEgEygCBCAYaiEaIBMoAgggEygCAGoiIyEKDAELDAELA0ACQCALLQAAIghBD3EiFUEPRiAIQe8BS3IgHyALQQFqIgdJIAogIU9ycg0AA0AgCiAHKQAANwAAIApBCGogB0EIaikAADcAACAVQQRqIQwCQAJAIAogCEEEdkEPcSILaiIIIBhrIhUgFGoiCiAHIAtqIhYvAAAiByAHIApLGyIKIBVLBEAgFCAIIBRqIAogGGprIhVrIgsgDCALIAxJGyIHBEAgCCAVIB5qIAf8CgAACyAHIAhqIQggCyAMTw0BIAwgB2shDAsgCCAMaiELIAhBACAKayIVaiEHAn8CQCAKIAxJBEAgCEEAOgAAIAxBAkkNASAIIQcDQCAHIAcgFWoiCC0AADoAACAHQQFqIAhBAWotAAA6AAAgB0EDaiAHQQJqIgghByALSQ0ACyAIIBVqIQcgCEEBagwCCyAHQQhqKQAAISQgBykAACElIAhBEGogB0EQai8AADsAACAIQQhqICQ3AAAgCCAlNwAAIAshCgwDCyAIQQFqCyEKIAggC08NACAIIActAAA6AAAMAQsgCCEKCyAWLQACIghBD3EiFUEPRiAIQe8BS3IgHyAWQQNqIgdJcg0BIAogIUkNAAsLAkACfwJAAkACQAJAAkACQAJAIAhBEE8EQAJAIAhBBHYiC0EPRwRAIAchDAwBC0EAIQgDQCAHIBdPDQMgCCAHLQAAIgtqIQggB0EBaiIMIQcgC0H/AUYNAAsgCEEPaiELIAghEAsgCyAXIAxrSw0CIAsgGiAKa0sNAwJAAkACQCALQQRPBEAgC0EISQ0BIAtBEUkNAiAKIAtBcHFqIRYgCiEHIAwhCANAIAcgCCkAADcAACAHQQhqIAhBCGopAAA3AAAgCEEQaiEIIAdBEGoiByAWSQ0ACyAKIAtBEGsiB2oiCCAHIAxqIgcpAAA3AAAgCEEIaiAHQQhqKQAANwAADAMLIAogDC0AADoAACALQQJJDQIgCiAMLwAAOwAAIAogC0ECayIHaiAHIAxqLwAAOwAADAILIAogDCgAADYAACAKIAtBBGsiB2ogByAMaigAADYAAAwBCyAKIAwpAAA3AAAgCiALQQhrIgdqIAcgDGopAAA3AAALIAogC2ohCiALIAxqIQcLIAcgF08NAwJAAkAgFyAHa0ECTwRAIAdBAmohCCAHLwAAIRYgFUEEaiIMQRNGDQEgCCELDAILDAwLQQAhBwNAIAggF08NBiAHIAgtAAAiDGohByAIQQFqIgshCCAMQf8BRg0ACyAHQRNqIQwgByEOCyAKIBhrIgcgFGogFkkNBSAaIAprIgggDEkEQCARQQA2AgAgESATKAIENgIIIBEgByAMajYCBAwMCwJAIAcgFkkEQCAUIAogFGogFiAYamsiFWsiCCAMIAggDEkbIgcEQCAKIBUgHmogB/wKAAALIAcgCmohCiAIIAxPDQEgDCAHayEMIBogCmshCAsgCiEHQQAgFmshFSAMQQ9qIgogFksgCCAKSXJFBEAgByAMaiEKA0AgByAHIBVqIggpAAA3AAAgB0EIaiAIQQhqKQAANwAAIAdBEGoiByAKSQ0ACwwKCyAHQQA6AAAgByAMaiEWIAxBAkkNByAHIQgDQCAIIAggFWoiBy0AADoAACAIQQFqIAdBAWotAAA6AAAgCEEDaiAIQQJqIgchCCAWSQ0ACyAHQQFqIQogByAVagwICyALIBdJDQkMCgsgESAQNgIEDAkLIBFBATYCAAwJCyARQQA2AgAgESATKAIENgIIIBEgCiAYayALajYCBAwICyARQQQ2AgAgESAKICNrNgIEIBMgCiAYazYCCAwHCyARIA42AgQMBQsgEUEDNgIADAULIAdBAWohCiAHIBVqCyEIIAcgFk8EQCAHIQoMAQsgByAILQAAOgAACyALIBdJDQALIBFBAjYCAAwBCyARQQI2AgALCyANKAIQIgdBBEcEQCANIA0pAhQ3AzAgDSAHNgIsIA1BAToAKCASIA1BKGoQiykMCgsgDSgCFCEHCyAJIAkoAoQBIAdqIgg2AoQBIAkgCSkDWCAHrXw3A1ggCSgCgAEhByAJLQAaBEAgByAISw0GIAggCSgCdCIKSw0HIAlBKGogCSgCcCAHaiAIIAdrEN0LIAkoAoQBIQggCSgCgAEhBwsgEkEEOgAAIBIgCCAHazYCBAwICyAHIAhB1MfQABCwOwALIA1BADYCOCANQQE2AiwgDUH4oNAANgIoIA1CBDcCMCANQShqQeTH0AAQ7ywACyAUIApB9MfQABCwOwALIAcgCkGEyNAAELA7AAsgCiAIQcTG0AAQsDsACyAHIAhBpMjQABCxOwALIAggCkGkyNAAELA7AAsgDSAkNwMoICRCIIinIQcCQAJAAn8CQAJAICSnQf8BcUEBaw4DAAEBAwsgJEIIiKcMAQsgBy0ACAtB/wFxQSVGDQELIBIgJDcCAAwBCyASQQQ6AAAgEkEANgIEIA1BKGoQuS4LIA1BQGskAAsgHUEQaiQAIBwtAAhBBEYEQCAcKAIMIQgMBQsgHCkDCCIkQv8Bg0IEUg0BICRCIIinIQgMBAtBgCAgCCAHayIIIAhBgCBLGyIIIAdqIgogCEkNASAKIAkoAnQiDEsNAiAIBEAgIiAJKAJwIAdqIAj8CgAACyAbIAg2AgQgCSAKNgKAASAbQQQ6AAAMBQsgGyAkNwIADAQLIAcgCkGUxtAAELE7AAsgCiAMQZTG0AAQsDsACyAIDQALIBtBBDoAACAbQQA2AgQLIBxBEGokAAJ/IAktAIghQQRGBEAgCSgCjCEMAQsgCSkDiCEiJEL/AYNCBFINASAkQiCIpwsiB0UEQCAgQQg2AgAgICABNgIEDAMLIAdBgSBPDQMgBCAJQYgBaiAHEKE2IAEgB2ohAQwBCwsgCSAkNwOIISAgIAlBiCFqEIErCyAJQeAAahDeOyAJQewAahDeOyAJQZAhaiQADAELIAdBgCBBrILOABCwOwALAkAgDygCMCIBQQhGBEAgACAPKAI0NgIEIABBCDYCAAwBCyAEIBkQ9DQgACAPIAIgAyAEIAUgBhC/DQJAAkACQAJAAkAgAQ4GAAECAwUEBQsgD0EwakEEchDeOwwECyAPQTBqQQRyEN47DAMLIA9BMGpBBHIQ3jsMAgsgD0EwakEEchDeOwwBCyAPQTBqQQRyELwqCyAPQRBqELkuDAELIAYgEEYEQCAAQQg2AgAgACAGNgIEDAELIA9BMGpBNkEAQQFBARCgGCAPKAI0IQIgDygCMEEBRwRAIA8oAjgiAUGs3dAAQTb8CgAAIABBNjYCDCAAIAE2AgggACACNgIEIABBADYCAAwBCwwBCyAPQdAAaiQADwsgAiAPKAI4QaTG0AAQ/S8AC/s0Agx/AX4jAEHwBWsiByQAIAcgAkGIAfwKAAAgB0GoA2ohCyMAQfACayICJAAgAiAHKAKAASIGNgIIIAIgB0EBIAcpAwAiD6dBCWsgD0IIWBsiCEECdEGYls8AaigCAGooAggiAzYCDAJAIAZBAE4EQAJAAkACQAJAIANBAE4EQCAIQQFrDgICAwELIAJBATYCFCACQaSPzwA2AhAgAkIBNwIcIAJBOzYCnAIgAiACQZgCajYCGCACIAJBDGo2ApgCIAtBDGogAkEQahCZDiALQgQ3AwAgC0EANgIIDAULIAcoAnAhCCAHLQB0IAIgAzYCjAIgAiAGNgKIAiACQQA2AoQCIAJBADYC8AEgAkEAOgCQAiACQgM3AxAgAkEDOgCAAiACQgM3A3ggBy0AdSEGIActAHYhAyACQZgCaiAHQQhqQQAgBykDCEIIUhsQtwhBAnRBpJbPAGooAgAhBCADQQJ0QaSWzwBqKAIAIQMgBkECdEGkls8AaigCACEGIAIpAxBCA1IEQCACQRBqEPErCyACQRBqIAJBmAJqQdgA/AoAACACIAM2AnQgAiAGNgJwIAIgBDYCbCACIAg2AmgMAgsgBygCaCEIIActAH0gAiADNgKMAiACIAY2AogCIAJBAzYChAIgAkEANgLwASACQQA6AJACIAJCAzcDECACQQM6AIACIAJCAzcDeCAHKAJsIQMgBygCcCEKIAcoAnQhBSAHKAJ4IQkgBy0AfCENIAJBmAJqIAdBACAPQghSGxC3CEECdEGkls8AaigCACEEIAJB+ABqIQYgAikDeEIDUgRAIAYQ8SsLIAYgAkGYAmpB2AD8CgAAIAIgDToA6AEgAiAJNgLkASACIAU2AuABIAIgBDYC3AEgAiAKNgLYASACIAM2AtQBIAIgCDYC0AEMAQsgBy0AHCEIIAcoAhghBCACIAM2AowCIAIgBjYCiAIgAkEANgLwASACQQA6AJACIAJCAzcDECACQgM3A3ggAiAENgL4ASACIActAB06AIACIAJBAjYChAIgAiAIQQJ0QaSWzwBqKAIANgL8AQsgCyACQRBqQYgC/AoAAAwBCyACQQE2AhQgAkHQj88ANgIQIAJCATcCHCACQTs2ApwCIAIgAkGYAmo2AhggAiACQQhqNgKYAiALQQxqIAJBEGoQmQ4gC0IENwMAIAtBADYCCAsgAkHwAmokACAHQZgDaiICIAdBuANqKQMANwMAIAdBoANqIgYgB0HAA2opAwA3AwAgByAHKQOwAzcDkAMgB0EIaiELAkACQAJAIAcpA6gDIg9CBFEEQCAAIAcpA5ADNwMAIABBBDoAHCAAQRBqIAYpAwA3AwAgAEEIaiACKQMANwMADAELIAdBqAFqIAdByANqQegB/AoAACAHQZgBaiAHQZgDaikDADcDACAHQaABaiAHQaADaikDADcDACAHIA83A4gBIAcgBykDkAM3A5ABIAdBqANqIgJBgAhBAEEBQQEQoBggBygCrAMhBiAHKAKoA0EBRg0BIAdBADYCyAUgByAHKAKwAzYCxAUgByAGNgLABSAHQoCAgICQgICAgH83ArADIAdCgICAgCA3AqgDIAdBADsBzAMgByAHQcAFaiINNgLIAyAHQcwFaiEIIAdBiAFqIg4hCiMAQUBqIgYkACAGQQxqQeyK0ABBChCAICAGQSxqIAIQ8icCQCAGKAIsIgNBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggAzYCAAwBCyAGQSxqIgNB9orQAEEEQQZBARDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC9AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAGQSxqIgNB+orQAEEWQQZBAhDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC+AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAGQSxqIgNBkIvQAEEUQQZBAxDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC/AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAKKALgAUEBRgRAIAooAuQBIQQgBkEsaiIDQaSL0ABBA0EGQQQQ6BwgBkEYaiACIAMQsBQgBigCGCIFQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAU2AgAgAxCGMAwCCyAGQSxqIgMQhjAgAyACIAQQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgCikDAEIDUgRAIAZBLGoiA0Gni9AAQRBBCkEFEOgcIAZBGGogAiADELAUIAYoAhgiBEEERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAENgIAIAMQhjAMAgsgBkEsaiIEEIYwIwBBQGoiAyQAIANBDGpB/ITQAEEOEIAgIANBLGogAhDyJwJAIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIANBLGoiBUGKhdAAQQpBBkEBEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJYELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQZSF0ABBCEEGQQIQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAlwQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISADQSxqIgVBnIXQAEEZQQZBAxDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCYBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUG1hdAAQRlBBkEEEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJkELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgCikDAEICUgRAIANBLGoiBUHOhdAAQQpBCkEFEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAgsgA0EsaiIFEIYwIAUgCiACEJYDIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAILIAIQ0yELIANBLGogAhCrKSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyAEIAIQ6igLIANBDGoQ3jsgA0FAayQAIAYoAiwiA0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCADNgIADAILIAIQ0yELIAotAIACBEAgBkEsaiIDQbeL0ABBEUEKQQYQ6BwgBkEYaiACIAMQsBQgBigCGCIEQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAQ2AgAgAxCGMAwCCyAGQSxqIgQQhjAjAEEgayIDJAAgA0HYhdAAQQ8QgCAgA0EMaiACEPInAkAgAygCDCIFQQRHBEAgBCADKQIQNwIEIARBDGogA0EYaikCADcCACAEIAU2AgAMAQsgA0EMaiACEKspIAMoAgwiBUEERwRAIAQgAykCEDcCBCAEQQxqIANBGGopAgA3AgAgBCAFNgIADAELIAQgAhDqKAsgAxDeOyADQSBqJAAgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgCi0A8AFBA0cEQCAGQSxqIgNByIvQAEEWQQpBBxDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAILIAZBLGoiBBCGMCAKQegBaiEFIwBBQGoiAyQAIANBDGpBxIbQAEEUEIAgIANBLGogAhDyJwJAIAMoAiwiCUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAJNgIADAELIANBLGoiCUGKhdAAQQpBBkEBEOgcIANBGGogAiAJELAUIAMoAhgiDEEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAMNgIAIAkQhjAMAQsgA0EsaiIJEIYwIAkgAiAFKAIAELAbIAMoAiwiCUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAJNgIADAELIAIQ0yEgA0EsaiIJQZSF0ABBCEEGQQIQ6BwgA0EYaiACIAkQsBQgAygCGCIMQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAw2AgAgCRCGMAwBCyADQSxqIgkQhjAgCSACIAUoAgQQsBsgAygCLCIJQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAk2AgAMAQsgAhDTISAFLQAIIglBAkcEQCADQSxqIgVB2IbQAEEJQQJBAxDoHCADQRhqIAIgBRCwFCADKAIYIgxBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgDDYCACAFEIYwDAILIANBLGoiBRCGMCAFIAIgCUEBcRDGFSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwCCyACENMhCyADQSxqIAIQqykgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgBCACEOooCyADQQxqEN47IANBQGskACAGKAIsIgNBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggAzYCAAwCCyACENMhCyAKKQNoQgNSBEAgBkEsaiIDQd6L0ABBE0EKQQgQ6BwgBkEYaiACIAMQsBQgBigCGCIEQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAQ2AgAgAxCGMAwCCyAGQSxqIgQQhjAgCkHoAGohCiMAQUBqIgMkACADQQxqQYSJ0ABBEBCAICADQSxqIAIQ8icCQCADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyADQSxqIgVBioXQAEEKQQZBARDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCWBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUGUidAAQQlBBkECEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJcELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQZ2J0ABBCEEGQQMQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAmAQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISADQSxqIgVBlIXQAEEIQQZBBBDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCZBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUGlidAAQR1BBkEFEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJoELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQcKJ0ABBHUEGQQYQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAmwQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISAKLQBwIglBAkcEQCADQSxqIgVB34nQAEENQQJBBxDoHCADQRhqIAIgBRCwFCADKAIYIgxBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgDDYCACAFEIYwDAILIANBLGoiBRCGMCAFIAIgCUEBcRDGFSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwCCyACENMhCyAKKQMAQgJSBEAgA0EsaiIFQc6F0ABBCkEKQQgQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwCCyADQSxqIgUQhjAgBSAKIAIQlgMgAygCLCIKQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAo2AgAMAgsgAhDTIQsgA0EsaiACEKspIAMoAiwiCkEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAKNgIADAELIAQgAhDqKAsgA0EMahDeOyADQUBrJAAgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgBkEsaiACEKspIAYoAiwiA0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCADNgIADAELIAggAhDqKAsgBkEMahDeOyAGQUBrJAAgBygCzAUiBkEERwRAIAdBnANqIAdB2AVqKQIANwIAIAcgBykC0AU3ApQDIAcgBjYCkAMgACAHQZADahClJSAAQQQ6ABwgAhC6LiANEN47IA4Q/CwMAQsgB0GoA2oiAhC6LiAHQbADaiAHQcgFaigCADYCACAHIAcpAsAFNwOoAyAHQbAFaiACEOcVIAEoAgAiBi0ACCAGQQE6AAhBAUYNAiAHQeAAaiECAkACQAJAQQEgBykDACIPp0EJayAPQghYG0EBaw4CAAECCyAHQdgAaiECDAELIAshAgsgB0HoAGohASAHQeAFaiACQQxqIAIoAgQgAigCCCACKAIAKAIAEQUAIAcoArgFIgogBygC6AVqIQJBAyEDAkACQAJAQQEgBykDACIPp0EJayAPQghYG0EBaw4CAgEACyAHQfAAaiEBQQAhAwwBCyAHQRhqIQFBAiEDCyABKAIAIQUgBygCgAEhCSAGIAYoAhgiDSACajYCGCAGQQxqIQggBigCFCIBIAYoAgxGBEAgCEG46c8AEJ4oCyAGKAIQIAFBBHRqIgQgBykCsAU3AgAgBEEIaiAHQbgFaikCADcCACAGIAFBAWoiBDYCFCAGKAIMIARGBEAgCEHI6c8AEJ4oCyAGKAIQIARBBHRqIgggBykC4AU3AgAgCEEIaiAHQegFaikCADcCACAAIAM6ABwgACAFNgIYIAAgAjYCFCAAIAkgCmo2AhAgACACrTcDCCAAIA2tNwMAIAYgAUECajYCFCAGQQA6AAggB0GIAWoQ/CwLAkACQAJAAkBBASAHKQMAIg+nQQlrIA9CCFgbDgIBAgALIAdBFGogBygCDCAHKAIQIAcoAggoAhARAQAMAgsgB0HsAGogBygCZCAHKAJoIAcoAmAoAhARAQAgCxDCGAwBCyAHQeQAaiAHKAJcIAcoAmAgBygCWCgCEBEBACAHEMIYCyAHQfAFaiQADwsgBiAHKAKwA0GY6c8AEP0vAAsgB0EANgKoA0HY5s8AQSsgB0GoA2pByObPAEGo6c8AENUeAAvGCAIDfwF+IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIwIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxDjKCECDAwLIARBKGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAQgBTDQkgBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEFAa0GJkqTIADYCACAEQomSpMiQocKECTcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFPDQogACgCECACQQN0aikDACIHQgBZDQVBrJyEARCyOwALIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCSAAKAIQIAJBA3RqKQMAIgdCAFkNBUH8nIQBELI7AAsgBEFAa0GJkqTIADYCACAEQomSpMiQocKECTcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQYmSpMgANgIAIARCiZKkyJChwoQJNwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAHNwMAIARBQGtBiZKkyAA2AgAgBEKJkqTIkKHChAk3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgBzcDCCAEQUBrQYmSpMgANgIAIARCiZKkyJChwoQJNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwDC0HYm4QBELI7AAsgBEHQAGokACACDwsgBCABNgIoIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALrAgBBn8jAEEgayIHJAACQCACRQ0AIAEgAkECdCIGakEEayIFRQ0AIAUoAgANACAGIQUgAUEEayEIIAJB/////wNxIQYDQCAFRQRAQQAhAgwCCyAGQQFrIQYgBSAIaiAFQQRrIQUoAgBFDQALIAIgBkEBaiIFTwRAIAUhAgwBCyAFIAJBkI2IARCwOwALAkAgAyAEQQJ0IgZqQQRrIgVFDQAgBSgCAA0AIAYhBSADQQRrIQggBCEGA0AgBUUEQEEAIQQMAgsgBkEBayEGIAUgCGogBUEEayEFKAIARQ0ACyAEIAZBAWoiBU8EQCAFIQQMAQsgBSAEQaCNiAEQsDsACwJAAkACQAJAAkACQAJAAn8gAiAESyACIARJayACIARHDQAaIAFBBGshCSADQQRrIQogAkECdCEFAkADQCAFRQ0BIAUgCmohCCAFIAlqIAVBBGshBSgCACIGIAgoAgAiCEYNAAsgBiAISyAGIAhJawwBC0F/QQAgBRsLQf8BcQ4CAQIACyAHQRRqIARBAEEEQQQQoBggBygCGCEIIAcoAhRBAUYNBSAHKAIcIQYgBEECdCIFBEAgBiADIAX8CgAACyAGIAQgASACEM0QIAcgBDYCHCAHIAY2AhggByAINgIUIARFDQMgBSAGakEEayIBRQ0DIAEoAgANAyAEQQJ0IQUgBkEEayEBIARB/////wNxIQYCQANAIAVFBEBBACEFDAILIAZBAWshBiABIAVqIAVBBGshBSgCAEUNAAsgBkEBaiIFIARLDQQLIAcgBTYCHCAFIQQMAwsgAEEBOgAAIABBsI2IASkCADcCBCAAQQxqQbiNiAEoAgA2AgAMAwsgB0EUaiACQQBBBEEEEKAYIAcoAhghCCAHKAIUQQFGDQMgBygCHCEGIAJBAnQiBQRAIAYgASAF/AoAAAsgBiACIAMgBBDNECAHIAI2AhwgByAGNgIYIAcgCDYCFCACRQ0AIAUgBmpBBGsiAUUNACABKAIADQAgAkECdCEFIAZBBGshASACQf////8DcSEGAkADQCAFRQRAQQAhBQwCCyAGQQFrIQYgASAFaiAFQQRrIQUoAgBFDQALIAZBAWoiBSACSw0BCyAHIAU2AhwgBSECDAALAkAgAiAIQQJ2Tw0AIAdBCGogB0EUaiACQQRBBBD0FCAHKAIIIgFBgYCAgHhGDQAgASAHKAIMQcyNiAEQ/S8ACyAAIAcpAhQ3AgQgAEEMaiAHQRxqKAIANgIAIABBAjoAAAwBCwJAIAQgCEECdk8NACAHIAdBFGogBEEEQQQQ9BQgBygCACIBQYGAgIB4Rg0AIAEgBygCBEHMjYgBEP0vAAsgACAHKQIUNwIEIABBDGogB0EcaigCADYCACAAQQA6AAALIAdBIGokAA8LIAggBygCHEH8iYgBEP0vAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQvwYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEL8GIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDABiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQwAYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMEGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDBBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQwgYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMIGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDDBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQwwYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMQGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDEBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQxQYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMUGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDGBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQxgYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMcGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDHBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQyAYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMgGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDJBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQyQYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMoGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDKBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQywYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMsGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDMBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQzAYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEM0GIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDNBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQzgYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEM4GIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDPBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQzwYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENAGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDQBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ0QYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENEGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDSBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ0gYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENMGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDTBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ1AYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENQGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDVBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ1QYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENYGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDWBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ1wYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENcGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDYBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ2AYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENkGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDZBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ2gYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENoGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDbBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ2wYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENwGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDcBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvYCAIFfwR+IwBBkAFrIgQkACABQQxqENs8IQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAUQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEBDAcLIARB+ABqIAIgDKcgCadqIgdBAnRqNQIAIAt/IgkgAxCNECAEKAJ4IgFBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiAHQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAlQBEBBh4CAgHghAQwDCyAEQUBrIAI1AgAgCX8iCiADEI0QIAQoAkAiAUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEGIAQoAiwhAyABIARByABqIgUpAgA3AwAgBCkDICEJIAQgBCkCQDcDICAEQQA2AjAgBCAJNwJMIARBADYCSCAEIAM2AkQgBCAGNgJAIAQgAhDXOyAEKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCgAEgBCAGNgJ8IAQgATYCeCAEQTRqIgEgBEH4AGoQ5BkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQxh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBkAFqJAAL2AgCBX8EfiMAQZABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSADLQAAIQMgAikDACELIAEoAhAhAgNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDgAEMAQsgBCgCYEUNASAEQfgAaiAFELYqIAQpA3ghCQsgCUIAUg0CCyAEQgM3A1ALIAQpA0AiCUICUQ0JIARCADcDQCAEKQNIDAELIAQpA4ABCyEKIAmnQQFxRQ0HIAQgBCkDcEJAfSIJNwNwIAQgCjcDaCAKUA0ACwsgBEIBIAp6IgyGIAqFNwNoIAtQBEBBh4CAgHghAQwHCyAEQfgAaiACIAynIAmnaiIHQQF0ajMBACALfyIJIAMQjRAgBCgCeCIBQZOAgIB4RwRAIAQpAoQBIQkgBCkCfCEKDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQMgAikDACEJIAEoAhAhAkEAIQUDQCAJUARAQYeAgIB4IQEMAwsgBEFAayACMwEAIAl/IgogAxCNECAEKAJAIgFBk4CAgHhHBEAgBCkCTCEJIAQpAkQhCgwDCyAGIAo3AwAgBkEIaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBiAEKAIsIQMgASAEQcgAaiIFKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBjYCQCAEIAIQ1zsgBCgCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AoABIAQgBjYCfCAEIAE2AnggBEE0aiIBIARB+ABqEOQZIAcgBEEYaikCADcDACAFIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEMYdIARBIGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAE2AgQgAEEpOgAAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQZABaiQAC9gIAgV/BH4jAEGQAWsiBCQAIAFBDGoQ2TwhCCAEQQhqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCKCAEIAU2AiQgBEHAADYCICAHBEAgBkEAIAf8CwALIAQgCDYCMCAEIAc2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA2giClBFBEAgBCkDcCEJDAELA0ACfgJAIAQpA1AiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDUCAJp0EBcUUNACAEIAQpA1g3A4ABDAELIAQoAmBFDQEgBEH4AGogBRC2KiAEKQN4IQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOAAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIARCASAKeiIMhiAKhTcDaCALUARAQYeAgIB4IQEMBwsgBEH4AGogAiAMpyAJp2oiB0EBdGoyAQAgC38iCSADEI0QIAQoAngiAUGTgICAeEcEQCAEKQKEASEJIAQpAnwhCgwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgCVAEQEGHgICAeCEBDAMLIARBQGsgAjIBACAJfyIKIAMQjRAgBCgCQCIBQZOAgIB4RwRAIAQpAkwhCSAEKQJEIQoMAwsgBiAKNwMAIAZBCGohBiACQQJqIQIgCCAFQQFqIgVHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAvYCAIFfwR+IwBBkAFrIgQkACABQQxqENs8IQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAUQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEBDAcLIARB+ABqIAIgDKcgCadqIgdBAnRqNAIAIAt/IgkgAxCNECAEKAJ4IgFBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiAHQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAlQBEBBh4CAgHghAQwDCyAEQUBrIAI0AgAgCX8iCiADEI0QIAQoAkAiAUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEGIAQoAiwhAyABIARByABqIgUpAgA3AwAgBCkDICEJIAQgBCkCQDcDICAEQQA2AjAgBCAJNwJMIARBADYCSCAEIAM2AkQgBCAGNgJAIAQgAhDXOyAEKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCgAEgBCAGNgJ8IAQgATYCeCAEQTRqIgEgBEH4AGoQ5BkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQxh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBkAFqJAAL9ggBBX8jAEHwAGsiBiQAIAYgAjYCCCAGIAE2AgQgBiAENgIQIAYgAzYCDAJAAkAgAkEASARAIAZBATYCXCAGQaCfhgE2AlggBkIBNwJkIAZBnAM2AhwgBiAGQRhqNgJgIAYgBkEIajYCGCAGQTRqIAZB2ABqEJkOIAAgBikCODcCDCAAQRRqIAZBQGsoAgA2AgAgACAGKAI0NgIIIABBjYCAgHg2AgQgAEEpOgAADAELAkAgAkUEQCAFKAIQQQAgBSgCABshCCAEKAIIQQFrQXhxIQcMAQsgBiADIAQoAghBAWtBeHEiB2pBCGogBCgCJBEEACACbiIINgIUIAUoAgBFDQAgBSgCECIJIAhGDQAgBiAJNgIYIAZBAjYCXCAGQaCkhgE2AlggBkICNwJkIAZBOzYCPCAGQTs2AjQgBiAGQTBqNgJgIAYgBkEYajYCOCAGIAZBFGo2AjAgAEEIaiAGQdgAahCZDiAAQSk6AAAgAEGNgICAeDYCBAwBCyABQTBqIgkgAyAHakEIaiIHIAQoAhwiChEEABDICARAIAZBGGogByAEKAI4EQAAIAYoAhgEQCAGQUBrIAZBKGopAgA3AwAgBkE4aiAGQSBqKQIANwMAIAYgBikCGDcDMAJAIAEtAEgNACAFKAIABH8gBkHYAGoiAyAFIAIQig4gAyAGQTBqEOIIIAYoAlgiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAMQ+x4LDQEgBSgCAEUFQQELBEAgBigCREUNAQsgBkHwpIYBNgJYIAZCATcCZCAGQcoENgJQIAYgBigCBEE8ajYCVCAGIAZBzABqNgJgIAYgBkHUAGo2AkwgBkEBNgJcIABBCGogBkHYAGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQgBigCMCIAIAAoAgAiAEEBazYCACAAQQFHDQMgBkEwahD7HgwDCyAGKAIwIgEgASgCACIBQQFrNgIAIAFBAUYEQCAGQTBqEPseCyAGKAIQIQQgBigCDCEDIAYoAgghAiAGKAIEIQELIAAgCDYCMCAAIAI2AiwgACAENgIQIAAgAzYCDCAAIAE2AgggACACNgIEIABBHToAACAAIAUpAgA3AhQgAEEkaiAFQRBqKQIANwIAIABBHGogBUEIaikCADcCAAwCCyAGIAk2AlQgBiAHIAoRBAA2AkwgBiABQTxqNgIYIAZBAzYCNCAGQaSlhgE2AjAgBkIDNwI8IAZBygQ2AmwgBkGnBDYCZCAGQacENgJcIAYgBkHYAGo2AjggBiAGQRhqNgJoIAYgBkHMAGo2AmAgBiAGQdQAajYCWCAAQQhqIAZBMGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQLAkAgBSgCACIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAFEPseCyAGKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQQxqELsjCyAGKAIEIgAgACgCACIAQQFrNgIAIABBAUcNACAGQQRqEPIlCyAGQfAAaiQAC8MJAgh/An4jAEGwAWsiBSQAAkAgAgRAIAJBBHQhCiAFQSBqQQRyIQwgBUEoaiELA0AgBSAINgIYIAUgASkDACIOpyICNgIcIAEpAwghDQJAAkACQCACQQ1PBEAgBSACNgIgIAUgDkIgiD4CJCAFIA2nIgY2AiggBSANQiCIpyIHNgIsIAQgBk0EQCAFIAQ2ApwBIAVBrMeHATYCWCAFQgM3AmQgBUE7NgKEASAFQTs2AnwgBSALNgJ4IAVBOzYCdCAFIAVB8ABqNgJgIAUgBUGcAWo2AoABIAUgBUEYajYCcCAFQQQ2AlwgBUHIAGogBUHYAGoQmQ4gACAFKQJMNwIIIABBEGogBUHUAGooAgA2AgAgACAFKAJINgIEIABBjYCAgHg2AgAMBwsgBSAHNgI8IAUgAiAHaiIJNgJAIAVBEGogAyAGQQxsaiIGENw7AkACQCAHIAlLDQAgCSAFKAIUSw0AIAUoAhAiCQ0BCyAFIAYoAgg2ApwBIAVBBTYCXCAFQYTIhwE2AlggBUIFNwJkIAVBOzYClAEgBUE7NgKMASAFIAs2AogBIAVBOzYChAEgBUE7NgJ8IAVBOzYCdCAFIAVB8ABqNgJgIAUgBUGcAWo2ApABIAUgBUFAazYCgAEgBSAFQTxqNgJ4IAUgBUEYajYCcCAFQcgAaiAFQdgAahCZDiAFKQJIIQ0gACAFKQJQNwIMIAAgDTcCBCAAQY2AgIB4NgIADAcLIAUgBSgCJDYCcCAHIAlqIgcgAiAFQfAAaiIGQQQQ9C5FBEAgBkEpQQBBAUEBEKAYIAUoAnQhASAFKAJwQQFGDQIgBSgCeCICQfjFhwFBKfwKAAAgAEEpNgIMIAAgAjYCCCAAIAE2AgQgAEGNgICAeDYCAAwHCyAFIAUoAhg2ApgBIAVBnAFqIAcgAhCdCSAFKAKcAUUNAyAFIAUpAqABNwOoASAFQQI2AnQgBUHoxYcBNgJwIAVCAjcCfCAFQbADNgJQIAVBOzYCSCAFIAVBxABqNgJ4IAUgBUGoAWo2AkwgBSAFQZgBajYCRCAFQdwAaiAFQfAAahCZDiAFKQJcIQ0gACAFKQJkNwIMIAAgDTcCBCAAQY2AgIB4NgIADAYLIAJBDEYNASAFIA4gDSACQQN0QSBqEMcjIAUpAwAgBSkDCIRQDQEgBUECNgJ0IAVB4MaHATYCcCAFQgI3AnwgBUE7NgJkIAVBOzYCXCAFIAVB2ABqNgJ4IAUgBUEcajYCYCAFIAVBGGo2AlggAEEEaiAFQfAAahCZDiAAQY2AgIB4NgIADAULIAEgBSgCeEGgxIcBEP0vAAsgBSAONwMgIAUgDTcDKCAFIAg2ApgBIAVBnAFqIAwgAhCdCSAFKAKcAUUNACAFIAUpAqABNwOoASAFQQI2AnQgBUHoxYcBNgJwIAVCAjcCfCAFQbADNgJQIAVBOzYCSCAFIAVBxABqNgJ4IAUgBUGoAWo2AkwgBSAFQZgBajYCRCAFQdwAaiAFQfAAahCZDiAFKQJcIQ0gACAFKQJkNwIMIAAgDTcCBCAAQY2AgIB4NgIADAMLIAFBEGohASAIQQFqIQggCkEQayIKDQALCyAAQZOAgIB4NgIACyAFQbABaiQAC8QIAQR/IwBB8AFrIgMkACABKAKABUEIahCqJUH/AXEhBgJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEEGaw4CAAEICyACKAIoRQ0HIAIoAjxFDQcgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAYLIAIoAihFDQYgAigCPEUNBiABEOcfRQ0GIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwECyADKAJsRQ0HIAMoAnAiAkUNBCADQbgBaiIFIAEgASgChAUiBCgCQCAEKAJEIAIgAygCdBCcDSADQQhqIANBwAFqKAIANgIAIAMgAykCuAE3AwAgAygCfEEBRw0BIAMoAoABRQ0HIAMoAoQBIgJFDQEgAy0AxAEhBCAFIAEgASgChAUiASgCQCABKAJEIAIgAygCiAEQmAwgA0EYaiADQcABaigCADYCACADIAMpArgBNwMQIAMtAMQBIQEgA0EgakEEciADEOcVIANBATYCICADQThqIANBEGoQ5xUgACAGRSICOgBTIAAgAjoAUiAAIARBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDIDcDKCAAQTBqIANBKGopAwA3AwAgAEE4aiADQTBqKAIANgIAIABBxABqIANBPGopAgA3AgAgAEHMAGogA0HEAGooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYCNCAAIAMpAjQ3AjwgAEIGNwMAIANByABqEKclDAYLIAMoAmxFDQYgAygCcCICRQ0CIANBuAFqIgUgASABKAKEBSIEKAJAIAQoAkQgAiADKAJ0EJwNIANBoAFqIANBwAFqKAIANgIAIAMgAykCuAE3A5gBIAMoAnxBAUcNASADKAKAAUUNBiADKAKEASICRQ0BIAMtAMQBIQQgBSABIAEoAoQFIgEoAkAgASgCRCACIAMoAogBEJgMIANBsAFqIANBwAFqKAIANgIAIAMgAykCuAE3A6gBIAMtAMQBIQEgA0HIAWpBBHIgA0GYAWoQ5xUgA0EBNgLIASADQeABaiADQagBahDnFSAAIAZFIgI6AFMgACACOgBSIAAgBEF/c0EBcToAUSAAIAFBAXM6AFAgACADKQPIATcDKCAAQTBqIANB0AFqKQMANwMAIABBOGogA0HYAWooAgA2AgAgAEHEAGogA0HkAWopAgA3AgAgAEHMAGogA0HsAWooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYC3AEgACADKQLcATcCPCAAQgc3AwAgA0HIAGoQpyUMBQtB+IHPABCyOwALQZiCzwAQsjsAC0GIgs8AELI7AAtB6IHPABCyOwALIAAgAkHYAPwKAAALIANB8AFqJAAPC0Hkh84AQSBBhIjOABDLJAALxAgBBH8jAEHwAWsiAyQAIAEoApgFQQhqEKolQf8BcSEGAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQZrDgIAAQgLIAIoAihFDQcgAigCPEUNByADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBgsgAigCKEUNBiACKAI8RQ0GIAEQ6R9FDQYgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAQLIAMoAmxFDQcgAygCcCICRQ0EIANBuAFqIgUgASABKAKcBSIEKAJAIAQoAkQgAiADKAJ0EJ4NIANBCGogA0HAAWooAgA2AgAgAyADKQK4ATcDACADKAJ8QQFHDQEgAygCgAFFDQcgAygChAEiAkUNASADLQDEASEEIAUgASABKAKcBSIBKAJAIAEoAkQgAiADKAKIARCaDCADQRhqIANBwAFqKAIANgIAIAMgAykCuAE3AxAgAy0AxAEhASADQSBqQQRyIAMQ5xUgA0EBNgIgIANBOGogA0EQahDnFSAAIAZFIgI6AFMgACACOgBSIAAgBEF/c0EBcToAUSAAIAFBAXM6AFAgACADKQMgNwMoIABBMGogA0EoaikDADcDACAAQThqIANBMGooAgA2AgAgAEHEAGogA0E8aikCADcCACAAQcwAaiADQcQAaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgI0IAAgAykCNDcCPCAAQgY3AwAgA0HIAGoQpyUMBgsgAygCbEUNBiADKAJwIgJFDQIgA0G4AWoiBSABIAEoApwFIgQoAkAgBCgCRCACIAMoAnQQng0gA0GgAWogA0HAAWooAgA2AgAgAyADKQK4ATcDmAEgAygCfEEBRw0BIAMoAoABRQ0GIAMoAoQBIgJFDQEgAy0AxAEhBCAFIAEgASgCnAUiASgCQCABKAJEIAIgAygCiAEQmgwgA0GwAWogA0HAAWooAgA2AgAgAyADKQK4ATcDqAEgAy0AxAEhASADQcgBakEEciADQZgBahDnFSADQQE2AsgBIANB4AFqIANBqAFqEOcVIAAgBkUiAjoAUyAAIAI6AFIgACAEQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpA8gBNwMoIABBMGogA0HQAWopAwA3AwAgAEE4aiADQdgBaigCADYCACAAQcQAaiADQeQBaikCADcCACAAQcwAaiADQewBaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgLcASAAIAMpAtwBNwI8IABCBzcDACADQcgAahCnJQwFC0H4gc8AELI7AAtBmILPABCyOwALQYiCzwAQsjsAC0Hogc8AELI7AAsgACACQdgA/AoAAAsgA0HwAWokAA8LQeSHzgBBIEGEiM4AEMskAAvRCAIFfwR+IwBBkAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAMtAAAhAyACKQMAIQsgASgCECEBA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAcQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEFDAcLIARB+ABqIAEgDKcgCadqIgJqMAAAIAt/IgkgAxCNECAEKAJ4IgVBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhAQNAIAlQBEBBh4CAgHghBQwDCyAEQUBrIAEgAmowAAAgCX8iCiADEI0QIAQoAkAiBUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAvRCAIFfwR+IwBBkAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAMtAAAhAyACKQMAIQsgASgCECEBA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAcQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEFDAcLIARB+ABqIAEgDKcgCadqIgJqMQAAIAt/IgkgAxCNECAEKAJ4IgVBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhAQNAIAlQBEBBh4CAgHghBQwDCyAEQUBrIAEgAmoxAAAgCX8iCiADEI0QIAQoAkAiBUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAu4CAEFfyMAQfABayIDJAAgASgCuARBCGoQqiVB/wFxIQcCQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAgBBBmsOAgABCAsgAigCKEUNByACKAI8RQ0HIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwGCyACKAIoRQ0GIAIoAjxFDQYgARDoH0UNBiADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBAsgAygCbEUNByADKAJwIgRFDQQgA0G4AWoiBSABIAEoArwEIgIoAkAgAigCRCAEIAMoAnQQnQ0gA0EIaiADQcABaigCADYCACADIAMpArgBNwMAIAMoAnxBAUcNASADKAKAAUUNByADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJkMIANBGGogA0HAAWooAgA2AgAgAyADKQK4ATcDECADLQDEASEBIANBIGpBBHIgAxDnFSADQQE2AiAgA0E4aiADQRBqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpAyA3AyggAEEwaiADQShqKQMANwMAIABBOGogA0EwaigCADYCACAAQcQAaiADQTxqKQIANwIAIABBzABqIANBxABqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AjQgACADKQI0NwI8IABCBjcDACADQcgAahCnJQwGCyADKAJsRQ0GIAMoAnAiBEUNAiADQbgBaiIFIAEgASgCvAQiAigCQCACKAJEIAQgAygCdBCdDSADQaABaiADQcABaigCADYCACADIAMpArgBNwOYASADKAJ8QQFHDQEgAygCgAFFDQYgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCZDCADQbABaiADQcABaigCADYCACADIAMpArgBNwOoASADLQDEASEBIANByAFqQQRyIANBmAFqEOcVIANBATYCyAEgA0HgAWogA0GoAWoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDyAE3AyggAEEwaiADQdABaikDADcDACAAQThqIANB2AFqKAIANgIAIABBxABqIANB5AFqKQIANwIAIABBzABqIANB7AFqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AtwBIAAgAykC3AE3AjwgAEIHNwMAIANByABqEKclDAULQfiBzwAQsjsAC0GYgs8AELI7AAtBiILPABCyOwALQeiBzwAQsjsACyAAIAJB2AD8CgAACyADQfABaiQADwtB5IfOAEEgQYSIzgAQyyQAC7gIAQV/IwBB8AFrIgMkACABKALkBEEIahCqJUH/AXEhBwJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEEGaw4CAAEICyACKAIoRQ0HIAIoAjxFDQcgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAYLIAIoAihFDQYgAigCPEUNBiABEOUfRQ0GIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwECyADKAJsRQ0HIAMoAnAiBEUNBCADQbgBaiIFIAEgASgC6AQiAigCQCACKAJEIAQgAygCdBCaDSADQQhqIANBwAFqKAIANgIAIAMgAykCuAE3AwAgAygCfEEBRw0BIAMoAoABRQ0HIAMoAoQBIgRFDQEgAy0AxAEhBiAFIAEgAigCQCACKAJEIAQgAygCiAEQlgwgA0EYaiADQcABaigCADYCACADIAMpArgBNwMQIAMtAMQBIQEgA0EgakEEciADEOcVIANBATYCICADQThqIANBEGoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDIDcDKCAAQTBqIANBKGopAwA3AwAgAEE4aiADQTBqKAIANgIAIABBxABqIANBPGopAgA3AgAgAEHMAGogA0HEAGooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYCNCAAIAMpAjQ3AjwgAEIGNwMAIANByABqEKclDAYLIAMoAmxFDQYgAygCcCIERQ0CIANBuAFqIgUgASABKALoBCICKAJAIAIoAkQgBCADKAJ0EJoNIANBoAFqIANBwAFqKAIANgIAIAMgAykCuAE3A5gBIAMoAnxBAUcNASADKAKAAUUNBiADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJYMIANBsAFqIANBwAFqKAIANgIAIAMgAykCuAE3A6gBIAMtAMQBIQEgA0HIAWpBBHIgA0GYAWoQ5xUgA0EBNgLIASADQeABaiADQagBahDnFSAAIAdFIgI6AFMgACACOgBSIAAgBkF/c0EBcToAUSAAIAFBAXM6AFAgACADKQPIATcDKCAAQTBqIANB0AFqKQMANwMAIABBOGogA0HYAWooAgA2AgAgAEHEAGogA0HkAWopAgA3AgAgAEHMAGogA0HsAWooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYC3AEgACADKQLcATcCPCAAQgc3AwAgA0HIAGoQpyUMBQtB+IHPABCyOwALQZiCzwAQsjsAC0GIgs8AELI7AAtB6IHPABCyOwALIAAgAkHYAPwKAAALIANB8AFqJAAPC0Hkh84AQSBBhIjOABDLJAALuAgBBX8jAEHwAWsiAyQAIAEoApQEQQhqEKolQf8BcSEHAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQZrDgIAAQgLIAIoAihFDQcgAigCPEUNByADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBgsgAigCKEUNBiACKAI8RQ0GIAEQ5h9FDQYgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAQLIAMoAmxFDQcgAygCcCIERQ0EIANBuAFqIgUgASABKAKYBCICKAJAIAIoAkQgBCADKAJ0EJsNIANBCGogA0HAAWooAgA2AgAgAyADKQK4ATcDACADKAJ8QQFHDQEgAygCgAFFDQcgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCXDCADQRhqIANBwAFqKAIANgIAIAMgAykCuAE3AxAgAy0AxAEhASADQSBqQQRyIAMQ5xUgA0EBNgIgIANBOGogA0EQahDnFSAAIAdFIgI6AFMgACACOgBSIAAgBkF/c0EBcToAUSAAIAFBAXM6AFAgACADKQMgNwMoIABBMGogA0EoaikDADcDACAAQThqIANBMGooAgA2AgAgAEHEAGogA0E8aikCADcCACAAQcwAaiADQcQAaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgI0IAAgAykCNDcCPCAAQgY3AwAgA0HIAGoQpyUMBgsgAygCbEUNBiADKAJwIgRFDQIgA0G4AWoiBSABIAEoApgEIgIoAkAgAigCRCAEIAMoAnQQmw0gA0GgAWogA0HAAWooAgA2AgAgAyADKQK4ATcDmAEgAygCfEEBRw0BIAMoAoABRQ0GIAMoAoQBIgRFDQEgAy0AxAEhBiAFIAEgAigCQCACKAJEIAQgAygCiAEQlwwgA0GwAWogA0HAAWooAgA2AgAgAyADKQK4ATcDqAEgAy0AxAEhASADQcgBakEEciADQZgBahDnFSADQQE2AsgBIANB4AFqIANBqAFqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpA8gBNwMoIABBMGogA0HQAWopAwA3AwAgAEE4aiADQdgBaigCADYCACAAQcQAaiADQeQBaikCADcCACAAQcwAaiADQewBaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgLcASAAIAMpAtwBNwI8IABCBzcDACADQcgAahCnJQwFC0H4gc8AELI7AAtBmILPABCyOwALQYiCzwAQsjsAC0Hogc8AELI7AAsgACACQdgA/AoAAAsgA0HwAWokAA8LQeSHzgBBIEGEiM4AEMskAAu4CAEFfyMAQfABayIDJAAgASgC6ARBCGoQqiVB/wFxIQcCQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAgBBBmsOAgABCAsgAigCKEUNByACKAI8RQ0HIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwGCyACKAIoRQ0GIAIoAjxFDQYgARDqH0UNBiADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBAsgAygCbEUNByADKAJwIgRFDQQgA0G4AWoiBSABIAEoAuwEIgIoAkAgAigCRCAEIAMoAnQQnw0gA0EIaiADQcABaigCADYCACADIAMpArgBNwMAIAMoAnxBAUcNASADKAKAAUUNByADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJsMIANBGGogA0HAAWooAgA2AgAgAyADKQK4ATcDECADLQDEASEBIANBIGpBBHIgAxDnFSADQQE2AiAgA0E4aiADQRBqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpAyA3AyggAEEwaiADQShqKQMANwMAIABBOGogA0EwaigCADYCACAAQcQAaiADQTxqKQIANwIAIABBzABqIANBxABqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AjQgACADKQI0NwI8IABCBjcDACADQcgAahCnJQwGCyADKAJsRQ0GIAMoAnAiBEUNAiADQbgBaiIFIAEgASgC7AQiAigCQCACKAJEIAQgAygCdBCfDSADQaABaiADQcABaigCADYCACADIAMpArgBNwOYASADKAJ8QQFHDQEgAygCgAFFDQYgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCbDCADQbABaiADQcABaigCADYCACADIAMpArgBNwOoASADLQDEASEBIANByAFqQQRyIANBmAFqEOcVIANBATYCyAEgA0HgAWogA0GoAWoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDyAE3AyggAEEwaiADQdABaikDADcDACAAQThqIANB2AFqKAIANgIAIABBxABqIANB5AFqKQIANwIAIABBzABqIANB7AFqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AtwBIAAgAykC3AE3AjwgAEIHNwMAIANByABqEKclDAULQfiBzwAQsjsAC0GYgs8AELI7AAtBiILPABCyOwALQeiBzwAQsjsACyAAIAJB2AD8CgAACyADQfABaiQADwtB5IfOAEEgQYSIzgAQyyQAC7sJAgd/AX4jAEGwAmsiBiQAAkACQAJAAkACQAJAAkACQAJAAkAgBQRAIAIpAAghDSACKAAAIQcgBCgCACICIAIoAgAiCEEBajYCACAIQQBIDQkgBiACNgLIASAGIAQpAgQ3AswBAkAgDUIAVwRAIAIgAigCACICQQFrNgIAIAZBADYCACACQQFHDQEgBkHIAWoQ+x4MAQsgBkEIaiAGQdABaigCADYCACAGIAYpAsgBNwMACyADLQAAIgJBAmsOJQgICAgICAgICAgIAwMDAwMDAwEDAQIBAQIDAwMDAwMDAwgICAgDC0EAQQBB1Nj+ABDDIQALIAZB6AFqIAMQxgYgBkEAOwGgAiAGQQA2ApwCIAZBADYChAIgBkEANgL4ASAGIAc2AvQBIAZCBDcC4AEgBkIANwLYASAGQoCAgIDAADcC0AEgBkEANgLIASAFQQJNDQIgBkHsAGpBAkEAQQRBDBCgGCAGKAJwIQUgBigCbEEBRg0DIAYoAnQhB0EAIQIgBSEDA0AgAkEYRwRAIAIgBGoiCkEMaigCACIIIAgoAgAiCUEBajYCACAJQQBIDQkgAiAHaiIJIAg2AgAgCUEEaiAKQRBqKQIANwIAIAJBDGohAiADQQFrIgMNAQsLIAZBAjYCrAIgBiAHNgKoAiAGIAU2AqQCIAZB7ABqIgIgBkHIAWogBkGkAmoQlikMCAsgBkHoAWogAxDGBiAGQQA7AaACIAZBADYCnAIgBkEANgKEAiAGQQA2AvgBIAYgBzYC9AEgBkIENwLgASAGQgA3AtgBIAZCgICAgMAANwLQASAGQQA2AsgBIAZB7ABqIAVBAWsiCkEAQQRBDBCgGCAGKAJwIQcgBigCbEEBRg0DIAYoAnQhCAJAIAdFDQAgBUEMbEEMayEJQQAhAiAHIQMDQCACIAlGDQEgAiAEaiIMQQxqKAIAIgUgBSgCACILQQFqNgIAIAtBAEgNCCACIAhqIgsgBTYCACALQQRqIAxBEGopAgA3AgAgAkEMaiECIANBAWsiAw0ACwsgBiAKNgKsAiAGIAg2AqgCIAYgBzYCpAIgBkHsAGoiAiAGQcgBaiAGQaQCahCWKQwHCyACQQ1rQQdPDQMMBAtBAyAFQeTY/gAQsDsACyAFIAYoAnRBjNX+ABD9LwALIAcgBigCdEGM1f4AEP0vAAsgAkEBRiACQRVGcg0AIAYgAzYCpAIgBkECNgLMASAGQczZ/gA2AsgBIAZCATcC1AEgBkGvAzYCcCAGIAZB7ABqNgLQASAGIAZBpAJqNgJsIAZByAFqQdzZ/gAQ7ywACyAGQegBaiADEMYGIAZBADsBoAIgBkEANgKcAiAGQQA2AoQCIAZBADYC+AEgBiAHNgL0ASAGQgQ3AuABIAZCADcC2AEgBkKAgICAwAA3AtABIAZBADYCyAEgBUEBRwRAIAQoAgwiAiACKAIAIgNBAWo2AgAgA0EASA0BIAYgAjYCpAIgBiAEKQIQNwKoAiAGQewAaiICIAZByAFqIAZBpAJqEPojDAILQQFBAUHs2f4AEMMhCwALIAZBEGogAiAGEK4WIAYgDT4CFCAGQQE2AhAgACABIAZBEGoQyxAgBkGwAmokAAvPCAEKfyMAQTBrIggkACAIIAM2AgwgAigCCCIGQQRqIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkF7TQRAIAogAigCBCIJSw0BIAhBEGoiByACKAIAIgogCSAGIAYgCmoiDSgAAGsQ9jQCQAJAIAdBCBDMIEH//wNxIgwEQCAGIAxqIgxBBGohCyAMQXtLDQUgCSALTw0BIAsgCUHM1f4AELA7AAsgCEEQakEqQQBBAUEBEKAYIAgoAhQhASAIKAIQQQFGDQ4gCCgCGCICQZDd/gBBKvwKAAAgAEEqNgIMIAAgAjYCCCAAIAE2AgQgAEGMgICAeDYCAAwBCyAKIAxqKAAAIQ4gCEEQaiIHIAogCSAGIA0oAABrEPY0AkAgB0EGEMwgQf//A3EiCwRAIAYgC2oiC0EEaiEHIAtBe0sNBiAHIAlNDQEgByAJQczV/gAQsDsACyAIQRBqQS5BAEEBQQEQoBggCCgCFCEBIAgoAhBBAUYNDiAIKAIYIgJBut3+AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYyAgIB4NgIADAELIAogC2ooAAAhDyAIQRBqIgcgCiAJIAYgDSgAAGsQ9jQCQAJAIAdBChDMIEH//wNxIgcEQCAGIAdqIgZBBGohByAGQXtLDQggByAJSw0JIAYgCmooAAAgBmoiBkEEaiEHIAZBe0sNCiAHIAlLDQsgCEEkaiIHIAogCSAGIAYgCmooAABrEPY0IAhBEGogB0EEEMwgQf//A3EiBwR/IAYgB2oiBiAJSw0NIAYgCmotAAAFQQALEOIbQQIhBgJAIAgoAhAiB0Ht////B2oOAgACAwsgCC0AFCEGDAELQQIhBgsgCyAPaiILIAlLDQsgDCAOaiIMIAlLDQwgBS8BACEFIAogC2ooAAAhByAAQQA2AiAgACAJNgIUIAAgCjYCECAAIAc2AgwgACAJNgIEIAAgCjYCACAAQQA7AEMgACAGOgBCIAAgBTsBQCAAIAE2AjwgACAENgI4IAAgAzYCNCAAIAxBBGo2AhggACALQQRqNgIIIAAgAikCADcCKCAAIAogDGooAAA2AhwgAEEwaiACQQhqKAIANgIADA0LIAAgCCkAFTcABSAAQQxqIAhBHGopAAA3AAAgACAILQAUOgAEIAAgBzYCAAsgAEECOgBEIAMgAygCACIAQQFrNgIAIABBAUcNCyAIQQxqEPgjDAsLIAYgCkHc1f4AELE7AAsgCiAJQdzV/gAQsDsACyAMIAtBzNX+ABCxOwALIAsgB0HM1f4AELE7AAsgBiAHQczV/gAQsTsACyAHIAlBzNX+ABCwOwALIAYgB0Hc1f4AELE7AAsgByAJQdzV/gAQsDsACyAGIAlBzNT+ABCvOwALIAsgCUHM1P4AEK87AAsgDCAJQczU/gAQrzsACyAIQTBqJAAPCyABIAgoAhhBnNX+ABD9LwALkggBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwJCyAEQUBrQaSthgEoAgA2AgAgBEGcrYYBKQIANwM4IARBOGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0GkrYYBKAIANgIAIARBnK2GASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAwsgBCAAKAIQIAJBA3RqKQMANwMIIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAILIAQgADYCNCAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBNGo2AhwgBCAEQTBqNgIUDAQLIAQgADYCKAwCCyAEQdAAaiQAIAIPCyAEIAE2AigLIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALkggBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwJCyAEQUBrQdCshgEoAgA2AgAgBEHIrIYBKQIANwM4IARBOGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0HQrIYBKAIANgIAIARByKyGASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAwsgBCAAKAIQIAJBA3RqKQMANwMIIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAILIAQgADYCNCAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBNGo2AhwgBCAEQTBqNgIUDAQLIAQgADYCKAwCCyAEQdAAaiQAIAIPCyAEIAE2AigLIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALwAcBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIsIAIgAEECdiIATw0LIAQgASgCECACQQJ0aigCADYCKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxDMJCECDAoLIARBKGogAxDTHCECDAkLIAAoAgQoAhQhACAEIAI2AiwgAiAAQQJ2IgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAcLIARBOGpB3KyGASgCADYCACAEQdSshgEpAgA3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBKGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQThqQdyshgEoAgA2AgAgBEHUrIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkECdGo0AgA3AwggBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAAsgBEHQAGokACACDwsgBCABNgJMDAELIAQgADYCTAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIgIARBOzYCGCAEIARBFGo2AjggBCAEQcwAajYCHCAEIARBLGo2AhQgBEEwakHIl4QBEO8sAAuSCAEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIwIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxCeJSECDAwLIARBKGogAxC5HCECDAsLIAAoAgQoAhQhACAEIAI2AjQgAiAAQQN2IgBPDQkgBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCgsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAkLIARBQGtBoKyGASgCADYCACAEQZishgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRRqEOUQDAULIARBKGogAxC4HCECDAQLIAQgACgCECACQQN0aikDADcDACAEQUBrQaCshgEoAgA2AgAgBEGYrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEIAAoAhAgAkEDdGopAwA3AwggBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAgsgBCAANgI0IARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEE0ajYCHCAEIARBMGo2AhQMBAsgBCAANgIoDAILIARB0ABqJAAgAg8LIAQgATYCKAsgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQShqNgIcIAQgBEE0ajYCFAsgBEE4akHIl4QBEO8sAAvABwEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AiwgAiAAQQJ2IgBPDQsgBCABKAIQIAJBAnRqKAIANgIoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEMwkIQIMCgsgBEEoaiADENMcIQIMCQsgACgCBCgCFCEAIAQgAjYCLCACIABBAnYiAE8NCiAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAnYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMBwsgBEE4akGArYYBKAIANgIAIARB+KyGASkCADcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5CyECIARBFGoQ5RAMAwsgBEEoaiADENIcIQIMAgsgBCAAKAIQIAJBAnRqNAIANwMAIARBOGpBgK2GASgCADYCACAEQfishgEpAgA3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACQQJ0ajQCADcDCCAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC5IIAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCQsgBEFAa0GsrIYBKAIANgIAIARBpKyGASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBrKyGASgCADYCACAEQaSshgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgACgCECACQQN0aikDADcDCCAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC5IIAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCQsgBEFAa0G8rYYBKAIANgIAIARBtK2GASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBvK2GASgCADYCACAEQbSthgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgACgCECACQQN0aikDADcDCCAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC8oHAgp/BX5BfyEHAkAgAUELIAEbIgpBBUkNACAKQQxLBEBBVA8LIApBICADZ2siAUEhIARnayIIIAEgCEkbSQ0AQX9BASAFGyEMIAMgCnYhDkKAgICAgICAgMAAIAOtgCERQT4gCmutIhBCFH0hEiAAIQUgAiEHQQAhAUEBIAp0Ig8hCQNAIAEgBE0EQCADIAcoAgAiCEYEQEEADwUCQCAIRQRAIAVBADsBAAwBCyAIIA5NBEAgBSAMOwEAIAlBAWshCQwBCyARIAitfiITIBCIIhSnIghB//8DcSINQQdNBEAgEyAUQv//A4MgEIZ9IA1BAnRBkPLQAGo1AgAgEoZWIAhqIQgLIAUgCDsBACAIQf//A3EiCCALQf//A3EiCyAIIAtLIg0bIQsgASAGIA0bIQYgCSAIayEJCyAFQQJqIQUgB0EEaiEHIAFBAWohAQwCCwALCwJAQQAgCWsgACAGQQF0aiIBLgEAIgVBAXVOBEAgA0EDbCAKQQFqdiELIARBAWohCEF/IQEgAiEHIAAhBUEAIQkDQAJAAkAgASAERwRAIAcoAgAiBkUEQCAFQQA7AQAMAwsgBiAOTQRAIAUgDDsBAAwCCyAGIAtNBEAgBUEBOwEADAILIAVB/v8DOwEADAILIA8gCWsiBkUNBCALIAMgBm5JBEAgA0EDbCAGQQF0biEGIAghByAAIQEgAiEFA0AgBwRAAkAgAS8BAEH+/wNHDQAgBSgCACIMIAZLDQAgAUEBOwEAIAMgDGshAyAJQQFqIQkLIAdBAWshByABQQJqIQEgBUEEaiEFDAELCyAPIAlrIQYLIAggCUYEQEEAIQVBACEHQQAhAQNAIAEgCEZFBEAgAigCACIDIAcgAyAHSyIDGyEHIAEgBSADGyEFIAJBBGohAiABQQFqIQEMAQsLIAAgBUEBdGoiACAALwEAIAZqOwEADAULIANFBEBBACEBA0AgBkUNBiAAIAFBAXRqIgIuAQAiA0EASgRAIAIgA0EBajsBACAGQQFrIQYLIAFBAWpBACABIARHGyEBDAALAAtCfyAQQgF9hkJ/hSIRIAatIBCGfCADrYAhEkEAIQEDQCABIARLDQUgAC8BAEH+/wNGBEAgESAQiCITIBIgAjUCAH4gEXwiESAQiCIUUQRAQX8PCyAAIBSnIBOnazsBAAsgAEECaiEAIAJBBGohAiABQQFqIQEMAAsACyADIAZrIQMgCUEBaiEJCyABQQFqIQEgB0EEaiEHIAVBAmohBQwACwALIAEgBSAJajsBAAsgCiEHCyAHC78HAgh/CH4jAEHwAGsiBSQAIAFBLGohCSABKAIsIQcCfwJAAkACQAJAAkACfgJAIAAoAiwEQCAAQSxqIQYgB0UNAyAFQRhqIAYQ3DsgBSgCHCEHIAUoAhghBiAFQRBqIAkQ3DsgASgCOCAFKAIUIQkgBSgCECEIIAVBMGogBiAHIAAoAjggAmogBBCHHSADaiEHIAUoAjwhCyAFKAI4IQYgBSgCMCEKIAUoAkAiAg0BQgAMAgtBASAHRQ0HGiAFIAkQ3DsgBUEwaiIAIAUoAgAgBSgCBCABKAI4IANqIAQQ+hMgBUEkaiAAENUJQQEhASAFKAIkQQFHDQMgBSgCKA0GIAUoAiwgBEchAQwGCyAKIAtBA3RqIgAxAAAgBkE/ca2IIQ0gAiAGaiIBQQN2IAFBB3FBAEdqIgNBAk8EQEEIIAZrIQEgA0EBayEDIABBAWohAANAIAAxAAAgAUE/ca2GIA2EIQ0gAEEBaiEAIAFBCGohASADQQFrIgMNAAsLIA1CfyACQT9xrYZCf4WDCyEQIAVBMGogCCAJIAcgBBCHHSAFKAI8IQwgBSgCOCEIIAUoAjAhAwJ+IAUoAkAiAkUEQCAIQT9xrSEPQgAMAQsgAyAMQQN0aiIAMQAAIAhBP3GtIg+IIQ0gAiAIaiIBQQN2IAFBB3FBAEdqIgRBAk8EQEEIIAhrIQEgBEEBayEEIABBAWohAANAIAAxAAAgAUE/ca2GIA2EIQ0gAEEBaiEAIAFBCGohASAEQQFrIgQNAAsLIA1CfyACQT9xrYZCf4WDCyERIAZBP3GtIRJBACEAQQAgCGtBP3GtIRNBACAGa0E/ca0hFEEBIQlBACEBQQEhAgNAAkAgCkUgASALT3JFBEAgCiABQQN0aiIEKQAAIQ0gBgRAIARBCGoxAAAgFIYgDSASiIQhDQsgAUEBaiEBDAELIAJBAXEhB0EAIQJBACEKIBAhDUEBIAdFDQcaCwJAIANFIAAgDE9yRQRAIAMgAEEDdGoiBCkAACEOIAgEQCAEQQhqMQAAIBOGIA4gD4iEIQ4LIABBAWohAAwBCyAJIQdBACEJQQAhAyARIQ5BASAHRQ0HGgsgDSAOUQ0AC0EADAULIAVBCGogBhDcOyAFQTBqIgEgBSgCCCAFKAIMIAAoAjggAmogBBD6EyAFQSRqIAEQ1QlBASEBIAUoAiRBAUcNASAFKAIoDQIgBSgCLCAERyEBDAILIARBAEchAQwCCyAEQQBHIQELIAFBAXMMAQsgAUEBcwsgBUHwAGokAAv6CQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgAtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyABQYHJhwFBBBD7NQwoCyABQYXJhwFBBxD7NQwnCyABQYzJhwFBBBD7NQwmCyABQZDJhwFBBRD7NQwlCyABQZXJhwFBBRD7NQwkCyABQZrJhwFBBRD7NQwjCyABQZ/JhwFBBRD7NQwiCyABQaTJhwFBBhD7NQwhCyABQarJhwFBBhD7NQwgCyABQbDJhwFBBhD7NQwfCyABQbbJhwFBBxD7NQweCyABQb3JhwFBBxD7NQwdCyABQcTJhwFBBxD7NQwcCyACIABBBGo2AgwgAUHsyYcBQQkgAEEBakHMyYcBIAJBDGpB3MmHARCDDwwbCyABQfXJhwFBBhD7NQwaCyABQfvJhwFBBhD7NQwZCyACIABBAWo2AgwgAUGUyocBQQYgAkEMakGEyocBENATDBgLIAIgAEEBajYCDCABQZrKhwFBBiACQQxqQYTKhwEQ0BMMFwsgAiAAQQFqNgIMIAFBoMqHAUEIIAJBDGpBhMqHARDQEwwWCyACIABBAWo2AgwgAUG4yocBQQggAkEMakGoyocBENATDBULIAFBwMqHAUEGEPs1DBQLIAIgAEEEajYCDCABQdjKhwFBDyACQQxqQcjKhwEQ0BMMEwsgAUHnyocBQQsQ+zUMEgsgAUHyyocBQQoQ+zUMEQsgAUH8yocBQQQQ+zUMEAsgAUGAy4cBQQkQ+zUMDwsgAUGJy4cBQQgQ+zUMDgsgAiAAQQRqNgIMIAFBpMuHAUEEIAJBDGpBlMuHARDQEwwNCyACIABBBGo2AgwgAUGoy4cBQQggAkEMakGUy4cBENATDAwLIAIgAEEEajYCDCABQcDLhwFBDSAAQQhqQbDLhwEgAkEMakHIyocBEIMPDAsLIAIgAEEEajYCDCABQc3LhwFBCSACQQxqQZTLhwEQ0BMMCgsgAiAAQQRqNgIMIAFB1suHAUENIAJBDGpBlMuHARDQEwwJCyACIABBBGo2AgwgAUH0y4cBQQYgAkEMakHky4cBENATDAgLIAIgAEEBajYCDCABQZzMhwFBBSAAQQRqQfzLhwEgAkEMakGMzIcBEIMPDAcLIAIgAEEIajYCDCABQcTMhwFBCiAAQQRqQaTMhwEgAkEMakG0zIcBEIMPDAYLIAIgAEECajYCDCABQfDMhwFBCSAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAULIAIgAEECajYCDCABQfnMhwFBCSAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAQLIAIgAEECajYCDCABQYLNhwFBCiAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAMLIAIgAEECajYCDCABQYzNhwFBCiAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAILIAIgAEEBajYCDCABQajNhwFBAyAAQQRqQbDLhwEgAkEMakGYzYcBEIMPDAELIAIgAEEIajYCDCABQavNhwFBDSAAQQRqQbDLhwEgAkEMakGUy4cBEIMPCyACQRBqJAAL+gkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIALQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAUHc54cBQQQQ+zUMKAsgAUHg54cBQQcQ+zUMJwsgAUHn54cBQQQQ+zUMJgsgAUHr54cBQQUQ+zUMJQsgAUHw54cBQQUQ+zUMJAsgAUH154cBQQUQ+zUMIwsgAUH654cBQQUQ+zUMIgsgAUH/54cBQQYQ+zUMIQsgAUGF6IcBQQYQ+zUMIAsgAUGL6IcBQQYQ+zUMHwsgAUGR6IcBQQcQ+zUMHgsgAUGY6IcBQQcQ+zUMHQsgAUGf6IcBQQcQ+zUMHAsgAiAAQQRqNgIMIAFByOiHAUEJIABBAWpBqOiHASACQQxqQbjohwEQgw8MGwsgAUHR6IcBQQYQ+zUMGgsgAUHX6IcBQQYQ+zUMGQsgAiAAQQFqNgIMIAFB8OiHAUEGIAJBDGpB4OiHARDQEwwYCyACIABBAWo2AgwgAUH26IcBQQYgAkEMakHg6IcBENATDBcLIAIgAEEBajYCDCABQfzohwFBCCACQQxqQeDohwEQ0BMMFgsgAiAAQQFqNgIMIAFBlOmHAUEIIAJBDGpBhOmHARDQEwwVCyABQZzphwFBBhD7NQwUCyACIABBBGo2AgwgAUG06YcBQQ8gAkEMakGk6YcBENATDBMLIAFBw+mHAUELEPs1DBILIAFBzumHAUEKEPs1DBELIAFB2OmHAUEEEPs1DBALIAFB3OmHAUEJEPs1DA8LIAFB5emHAUEIEPs1DA4LIAIgAEEEajYCDCABQYDqhwFBBCACQQxqQfDphwEQ0BMMDQsgAiAAQQRqNgIMIAFBhOqHAUEIIAJBDGpB8OmHARDQEwwMCyACIABBBGo2AgwgAUGc6ocBQQ0gAEEIakGM6ocBIAJBDGpBpOmHARCDDwwLCyACIABBBGo2AgwgAUGp6ocBQQkgAkEMakHw6YcBENATDAoLIAIgAEEEajYCDCABQbLqhwFBDSACQQxqQfDphwEQ0BMMCQsgAiAAQQRqNgIMIAFB0OqHAUEGIAJBDGpBwOqHARDQEwwICyACIABBAWo2AgwgAUH46ocBQQUgAEEEakHY6ocBIAJBDGpB6OqHARCDDwwHCyACIABBCGo2AgwgAUGg64cBQQogAEEEakGA64cBIAJBDGpBkOuHARCDDwwGCyACIABBAmo2AgwgAUHM64cBQQkgAEEBakGs64cBIAJBDGpBvOuHARCDDwwFCyACIABBAmo2AgwgAUHV64cBQQkgAEEBakGs64cBIAJBDGpBvOuHARCDDwwECyACIABBAmo2AgwgAUHe64cBQQogAEEBakGs64cBIAJBDGpBvOuHARCDDwwDCyACIABBAmo2AgwgAUHo64cBQQogAEEBakGs64cBIAJBDGpBvOuHARCDDwwCCyACIABBAWo2AgwgAUGE7IcBQQMgAEEEakGM6ocBIAJBDGpB9OuHARCDDwwBCyACIABBCGo2AgwgAUGH7IcBQQ0gAEEEakGM6ocBIAJBDGpB8OmHARCDDwsgAkEQaiQAC4wJAQN/IwBBkAFrIgMkACADQdQAaiABIAIQkw4gAygCWCEEAkAgAygCVCIFQYqAgIB4RwRAIAAgAykCXDcCCCAAQSBqIANB9ABqKAIANgIAIABBGGogA0HsAGopAgA3AgAgAEEQaiADQeQAaikCADcCACAAIAQ2AgQgACAFNgIADAELIANB1ABqIAFBfyACIARqIgEgASAESRsQtAYgA0EIaiIBIANB4ABqKQIANwMAIAMgAykCWDcDACADKAJUIgJBioCAgHhHBEAgACADKQJoNwIUIABBHGogA0HwAGopAgA3AgAgAEEMaiABKQMANwIAIAAgAykDADcCBCAAIAI2AgAMAQsgA0EYaiABKQMANwMAIAMgAykDADcDECADQdQAaiADQRBqQQQQ3RAgAygCXCECIAMoAlghAQJAIAACfiADKAJUIgRBioCAgHhHBEAgA0GAAWogA0HwAGopAgA3AwAgAyADKQJoNwN4IAMpAmAMAQsgAUEBcUUNAQJAIAJBA3EEQCADIAI2AnAgA0EDNgJsIANBvOT+ADYCaCADQYCAgIB4NgJkIANCBDcCXCADQoSAgIAINwJUDAELQX8gAkEEaiIBIAEgAkkbIgQgAygCECIBKAIETQRAIAEgASgCFEEEaiIENgIUIAEoAggoAgggBE8EQCADQYqAgIB4NgJUDAILIANBiICAgHg2AlQMAQsgA0HUAGogAiAEEL8vCyADQQg2AogBIANBkef+ADYChAEgA0GAgICAeDYCgAEgAyACNgJ8IANBATYCeCADQTBqIANB1ABqIANB+ABqEIEUIAMoAjAiBEGKgICAeEYNASADQYABaiADQcwAaikCADcDACADIAMpAkQ3A3ggAygCOCECIAMoAjQhASADKQI8CzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA3g3AhQgAEEcaiADQYABaikDADcCAAwBCyADIAMpAxg3AiggAyADKQMQNwIgIANB1ABqIANBIGpBBhDdECADKAJcIQIgAygCWCEBAkAgAAJ+IAMoAlQiBEGKgICAeEcEQCADQYABaiADQfAAaikCADcDACADIAMpAmg3A3ggAykCYAwBCyABQQFxRQ0BAkAgAkEBaiIBQX8gARsiBCADKAIgIgEoAgRNBEAgASABKAIUQQFqIgQ2AhQgASgCCCgCCCAETwRAIANBioCAgHg2AlQMAgsgA0GIgICAeDYCVAwBCyADQdQAaiACIAQQvy8LIANBCTYCiAEgA0GZ5/4ANgKEASADQYCAgIB4NgKAASADIAI2AnwgA0EBNgJ4IANBMGogA0HUAGogA0H4AGoQgRQgAygCMCIEQYqAgIB4Rg0BIANBgAFqIANBzABqKQIANwMAIAMgAykCRDcDeCADKAI4IQIgAygCNCEBIAMpAjwLNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAAgAykDeDcCFCAAQRxqIANBgAFqKQMANwIADAELIAMoAiAiASABKAIMQQFrNgIMIABBioCAgHg2AgALIANBkAFqJAAL9QkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIAFBgKmAAUEEEPs1DCgLIAFBhKmAAUEHEPs1DCcLIAFBi6mAAUEEEPs1DCYLIAFBj6mAAUEFEPs1DCULIAFBlKmAAUEFEPs1DCQLIAFBmamAAUEFEPs1DCMLIAFBnqmAAUEFEPs1DCILIAFBo6mAAUEGEPs1DCELIAFBqamAAUEGEPs1DCALIAFBr6mAAUEGEPs1DB8LIAFBtamAAUEHEPs1DB4LIAFBvKmAAUEHEPs1DB0LIAFBw6mAAUEHEPs1DBwLIAIgAEEEajYCDCABQeypgAFBCSAAQQFqQcypgAEgAkEMakHcqYABEIMPDBsLIAFB9amAAUEGEPs1DBoLIAFB+6mAAUEGEPs1DBkLIAIgAEEBajYCDCABQZSqgAFBBiACQQxqQYSqgAEQ0BMMGAsgAiAAQQFqNgIMIAFBmqqAAUEGIAJBDGpBhKqAARDQEwwXCyACIABBAWo2AgwgAUGgqoABQQggAkEMakGEqoABENATDBYLIAIgAEEBajYCDCABQbiqgAFBCCACQQxqQaiqgAEQ0BMMFQsgAUHAqoABQQYQ+zUMFAsgAiAAQQRqNgIMIAFB2KqAAUEPIAJBDGpByKqAARDQEwwTCyABQeeqgAFBCxD7NQwSCyABQfKqgAFBChD7NQwRCyABQfyqgAFBBBD7NQwQCyABQYCrgAFBCRD7NQwPCyABQYmrgAFBCBD7NQwOCyACIABBBGo2AgwgAUGkq4ABQQQgAkEMakGUq4ABENATDA0LIAIgAEEEajYCDCABQairgAFBCCACQQxqQZSrgAEQ0BMMDAsgAiAAQQRqNgIMIAFBwKuAAUENIABBCGpBsKuAASACQQxqQciqgAEQgw8MCwsgAiAAQQRqNgIMIAFBzauAAUEJIAJBDGpBlKuAARDQEwwKCyACIABBBGo2AgwgAUHWq4ABQQ0gAkEMakGUq4ABENATDAkLIAIgAEEEajYCDCABQfSrgAFBBiACQQxqQeSrgAEQ0BMMCAsgAiAAQQFqNgIMIAFBnKyAAUEFIABBBGpB/KuAASACQQxqQYysgAEQgw8MBwsgAiAAQQhqNgIMIAFBxKyAAUEKIABBBGpBpKyAASACQQxqQbSsgAEQgw8MBgsgAiAAQQJqNgIMIAFB8KyAAUEJIABBAWpB0KyAASACQQxqQeCsgAEQgw8MBQsgAiAAQQJqNgIMIAFB+ayAAUEJIABBAWpB0KyAASACQQxqQeCsgAEQgw8MBAsgAiAAQQJqNgIMIAFBgq2AAUEKIABBAWpB0KyAASACQQxqQeCsgAEQgw8MAwsgAiAAQQJqNgIMIAFBjK2AAUEKIABBAWpB0KyAASACQQxqQeCsgAEQgw8MAgsgAiAAQQFqNgIMIAFBqK2AAUEDIABBBGpBsKuAASACQQxqQZitgAEQgw8MAQsgAiAAQQhqNgIMIAFBq62AAUENIABBBGpBsKuAASACQQxqQZSrgAEQgw8LIAJBEGokAAv1CQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAUH/3YYBQQQQ+zUMKAsgAUGD3oYBQQcQ+zUMJwsgAUGK3oYBQQQQ+zUMJgsgAUGO3oYBQQUQ+zUMJQsgAUGT3oYBQQUQ+zUMJAsgAUGY3oYBQQUQ+zUMIwsgAUGd3oYBQQUQ+zUMIgsgAUGi3oYBQQYQ+zUMIQsgAUGo3oYBQQYQ+zUMIAsgAUGu3oYBQQYQ+zUMHwsgAUG03oYBQQcQ+zUMHgsgAUG73oYBQQcQ+zUMHQsgAUHC3oYBQQcQ+zUMHAsgAiAAQQRqNgIMIAFB7N6GAUEJIABBAWpBzN6GASACQQxqQdzehgEQgw8MGwsgAUH13oYBQQYQ+zUMGgsgAUH73oYBQQYQ+zUMGQsgAiAAQQFqNgIMIAFBlN+GAUEGIAJBDGpBhN+GARDQEwwYCyACIABBAWo2AgwgAUGa34YBQQYgAkEMakGE34YBENATDBcLIAIgAEEBajYCDCABQaDfhgFBCCACQQxqQYTfhgEQ0BMMFgsgAiAAQQFqNgIMIAFBuN+GAUEIIAJBDGpBqN+GARDQEwwVCyABQcDfhgFBBhD7NQwUCyACIABBBGo2AgwgAUHY34YBQQ8gAkEMakHI34YBENATDBMLIAFB59+GAUELEPs1DBILIAFB8t+GAUEKEPs1DBELIAFB/N+GAUEEEPs1DBALIAFBgOCGAUEJEPs1DA8LIAFBieCGAUEIEPs1DA4LIAIgAEEEajYCDCABQaTghgFBBCACQQxqQZTghgEQ0BMMDQsgAiAAQQRqNgIMIAFBqOCGAUEIIAJBDGpBlOCGARDQEwwMCyACIABBBGo2AgwgAUHA4IYBQQ0gAEEIakGw4IYBIAJBDGpByN+GARCDDwwLCyACIABBBGo2AgwgAUHN4IYBQQkgAkEMakGU4IYBENATDAoLIAIgAEEEajYCDCABQdbghgFBDSACQQxqQZTghgEQ0BMMCQsgAiAAQQRqNgIMIAFB9OCGAUEGIAJBDGpB5OCGARDQEwwICyACIABBAWo2AgwgAUGc4YYBQQUgAEEEakH84IYBIAJBDGpBjOGGARCDDwwHCyACIABBCGo2AgwgAUHE4YYBQQogAEEEakGk4YYBIAJBDGpBtOGGARCDDwwGCyACIABBAmo2AgwgAUHw4YYBQQkgAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwFCyACIABBAmo2AgwgAUH54YYBQQkgAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwECyACIABBAmo2AgwgAUGC4oYBQQogAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwDCyACIABBAmo2AgwgAUGM4oYBQQogAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwCCyACIABBAWo2AgwgAUGo4oYBQQMgAEEEakGw4IYBIAJBDGpBmOKGARCDDwwBCyACIABBCGo2AgwgAUGr4oYBQQ0gAEEEakGw4IYBIAJBDGpBlOCGARCDDwsgAkEQaiQAC/UJAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyABQYDPhwFBBBD7NQwoCyABQYTPhwFBBxD7NQwnCyABQYvPhwFBBBD7NQwmCyABQY/PhwFBBRD7NQwlCyABQZTPhwFBBRD7NQwkCyABQZnPhwFBBRD7NQwjCyABQZ7PhwFBBRD7NQwiCyABQaPPhwFBBhD7NQwhCyABQanPhwFBBhD7NQwgCyABQa/PhwFBBhD7NQwfCyABQbXPhwFBBxD7NQweCyABQbzPhwFBBxD7NQwdCyABQcPPhwFBBxD7NQwcCyACIABBBGo2AgwgAUHsz4cBQQkgAEEBakHMz4cBIAJBDGpB3M+HARCDDwwbCyABQfXPhwFBBhD7NQwaCyABQfvPhwFBBhD7NQwZCyACIABBAWo2AgwgAUGU0IcBQQYgAkEMakGE0IcBENATDBgLIAIgAEEBajYCDCABQZrQhwFBBiACQQxqQYTQhwEQ0BMMFwsgAiAAQQFqNgIMIAFBoNCHAUEIIAJBDGpBhNCHARDQEwwWCyACIABBAWo2AgwgAUG40IcBQQggAkEMakGo0IcBENATDBULIAFBwNCHAUEGEPs1DBQLIAIgAEEEajYCDCABQdjQhwFBDyACQQxqQcjQhwEQ0BMMEwsgAUHn0IcBQQsQ+zUMEgsgAUHy0IcBQQoQ+zUMEQsgAUH80IcBQQQQ+zUMEAsgAUGA0YcBQQkQ+zUMDwsgAUGJ0YcBQQgQ+zUMDgsgAiAAQQRqNgIMIAFBpNGHAUEEIAJBDGpBlNGHARDQEwwNCyACIABBBGo2AgwgAUGo0YcBQQggAkEMakGU0YcBENATDAwLIAIgAEEEajYCDCABQcDRhwFBDSAAQQhqQbDRhwEgAkEMakHI0IcBEIMPDAsLIAIgAEEEajYCDCABQc3RhwFBCSACQQxqQZTRhwEQ0BMMCgsgAiAAQQRqNgIMIAFB1tGHAUENIAJBDGpBlNGHARDQEwwJCyACIABBBGo2AgwgAUH00YcBQQYgAkEMakHk0YcBENATDAgLIAIgAEEBajYCDCABQZzShwFBBSAAQQRqQfzRhwEgAkEMakGM0ocBEIMPDAcLIAIgAEEIajYCDCABQcTShwFBCiAAQQRqQaTShwEgAkEMakG00ocBEIMPDAYLIAIgAEECajYCDCABQfDShwFBCSAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAULIAIgAEECajYCDCABQfnShwFBCSAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAQLIAIgAEECajYCDCABQYLThwFBCiAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAMLIAIgAEECajYCDCABQYzThwFBCiAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAILIAIgAEEBajYCDCABQajThwFBAyAAQQRqQbDRhwEgAkEMakGY04cBEIMPDAELIAIgAEEIajYCDCABQavThwFBDSAAQQRqQbDRhwEgAkEMakGU0YcBEIMPCyACQRBqJAAL9QkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIAFBn+GHAUEEEPs1DCgLIAFBo+GHAUEHEPs1DCcLIAFBquGHAUEEEPs1DCYLIAFBruGHAUEFEPs1DCULIAFBs+GHAUEFEPs1DCQLIAFBuOGHAUEFEPs1DCMLIAFBveGHAUEFEPs1DCILIAFBwuGHAUEGEPs1DCELIAFByOGHAUEGEPs1DCALIAFBzuGHAUEGEPs1DB8LIAFB1OGHAUEHEPs1DB4LIAFB2+GHAUEHEPs1DB0LIAFB4uGHAUEHEPs1DBwLIAIgAEEEajYCDCABQYzihwFBCSAAQQFqQezhhwEgAkEMakH84YcBEIMPDBsLIAFBleKHAUEGEPs1DBoLIAFBm+KHAUEGEPs1DBkLIAIgAEEBajYCDCABQbTihwFBBiACQQxqQaTihwEQ0BMMGAsgAiAAQQFqNgIMIAFBuuKHAUEGIAJBDGpBpOKHARDQEwwXCyACIABBAWo2AgwgAUHA4ocBQQggAkEMakGk4ocBENATDBYLIAIgAEEBajYCDCABQdjihwFBCCACQQxqQcjihwEQ0BMMFQsgAUHg4ocBQQYQ+zUMFAsgAiAAQQRqNgIMIAFB+OKHAUEPIAJBDGpB6OKHARDQEwwTCyABQYfjhwFBCxD7NQwSCyABQZLjhwFBChD7NQwRCyABQZzjhwFBBBD7NQwQCyABQaDjhwFBCRD7NQwPCyABQanjhwFBCBD7NQwOCyACIABBBGo2AgwgAUGx44cBQQQgAkEMakG44IcBENATDA0LIAIgAEEEajYCDCABQbXjhwFBCCACQQxqQbjghwEQ0BMMDAsgAiAAQQRqNgIMIAFB0OOHAUENIABBCGpBwOOHASACQQxqQejihwEQgw8MCwsgAiAAQQRqNgIMIAFB3eOHAUEJIAJBDGpBuOCHARDQEwwKCyACIABBBGo2AgwgAUHm44cBQQ0gAkEMakG44IcBENATDAkLIAIgAEEEajYCDCABQYTkhwFBBiACQQxqQfTjhwEQ0BMMCAsgAiAAQQFqNgIMIAFBrOSHAUEFIABBBGpBjOSHASACQQxqQZzkhwEQgw8MBwsgAiAAQQhqNgIMIAFB1OSHAUEKIABBBGpBtOSHASACQQxqQcTkhwEQgw8MBgsgAiAAQQJqNgIMIAFB8OSHAUEJIABBAWpB4OSHASACQQxqQajghwEQgw8MBQsgAiAAQQJqNgIMIAFB+eSHAUEJIABBAWpB4OSHASACQQxqQajghwEQgw8MBAsgAiAAQQJqNgIMIAFBguWHAUEKIABBAWpB4OSHASACQQxqQajghwEQgw8MAwsgAiAAQQJqNgIMIAFBjOWHAUEKIABBAWpB4OSHASACQQxqQajghwEQgw8MAgsgAiAAQQFqNgIMIAFBqOWHAUEDIABBBGpBwOOHASACQQxqQZjlhwEQgw8MAQsgAiAAQQhqNgIMIAFBq+WHAUENIABBBGpBwOOHASACQQxqQbjghwEQgw8LIAJBEGokAAuGCAEDfyMAQdAAayILJAAgCyAANgJIIAsgADYCRCALIAAgAWpBBGs2AkxBun8hAAJAIAFBBUkNACALQSxqIAIgAyAJQQFrIgBqIgwtAAAQhx8gC0EcaiAEIAAgBWoiAS0AABCHHyALQQxqIAYgACAHaiIELQAAEIcfIAggAEEDdGoiAi8BBCEAIAsgBC0AAEHwltEAai0AACIENgJAIAsgACAEQQJ0QeCX0QBqKAIAcTYCPCALQTxqIgAQiyYgCyALKAJAIgQgDC0AAEGgl9EAai0AACIGajYCQCALIAsoAjwgBkECdEHgl9EAaigCACACLwEGcSAEdHI2AjwgABCLJgJ/IAoEQEEYIQBBACEGAkAgAS0AACIBQRhJBEAgASEADAELIAFBGEYNACALIAsoAkAiBCABQRhrIgZqNgJAIAsgCygCPCAGQQJ0QeCX0QBqKAIAIAIoAgBxIAR0cjYCPCALQTxqEIsmCyACKAIAIAZ2DAELIAEtAAAhACACKAIACyEBIAsgCygCQCICIABqNgJAIAsgCygCPCAAQQJ0QeCX0QBqKAIAIAFxIAJ0cjYCPCAJQQJrIQAgCUEDdCAIakEQayEBIAtBPGoQiyYDQCAAIAlJBEAgACAHai0AACEGIAAgA2otAAAhDCALQTxqIgQgC0EcaiAAIAVqLQAAIgIQ4iUgBCALQSxqIAwQ4iUgBBCLJiAEIAtBDGogBhDiJSAGQfCW0QBqLQAAIQggBBCLJiALIAggCygCQCINaiIGNgJAIAsgCygCPCAIQQJ0QeCX0QBqKAIAIAFBBGovAQBxIA10ciINNgI8IAggDEGgl9EAai0AACIMakEZTwRAIAQQiyYgCygCPCENIAsoAkAhBgsgCyAGIAxqNgJAIAsgDEECdEHgl9EAaigCACABQQZqLwEAcSAGdCANcjYCPCALQTxqEIsmAn8gCgRAQQAhBgJAIAJBGEkEQCACIQgMAQtBGCEIIAJBGEYNACALIAsoAkAiBCACQRhrIgZqNgJAIAsgCygCPCAGQQJ0QeCX0QBqKAIAIAEoAgBxIAR0cjYCPCALQTxqEIsmCyABKAIAIAZ2DAELIAIhCCABKAIACyECIAsgCygCQCIEIAhqNgJAIAsgCygCPCAIQQJ0QeCX0QBqKAIAIAJxIAR0cjYCPCABQQhrIQEgAEEBayEAIAtBPGoQiyYMAQsLIAtBPGoiACALQSxqENY1IAAgC0EcahDWNSAAIAtBDGoQ1jUgCyALKAJAIgFBAWo2AkAgCyALKAI8QQEgAXRyNgI8IAAQiyYgCygCSCIAIAsoAkxJBEAgACALKAJEayALKAJAQQBHaiIADQELQbp/IQALIAtB0ABqJAAgAAv9JwIQfwx+IwBBgAZrIgUkACABKAKMASEDIAFBgICAgHg2AowBAkACQAJAIANBgICAgHhHBEAgBUEYaiABQZgBaikCADcCACAFIAM2AgwgBSABKQKQATcCECAFQYgFaiEDIwBB0ABrIgckAAJAAkACQAJAAkACQAJAAkAgAS0AZEUEQCABKAJgIgggASgCIEYNAkEoIQIgB0EoakEoQQBBAUEBEKAYIAcoAiwhASAHKAIoQQFGDQUgBygCMCIEQZTBwwBBKPwKAAAMAQtBJSECIAdBKGpBJUEAQQFBARCgGCAHKAIsIQEgBygCKEEBRg0DIAcoAjAiBEG8wcMAQSX8CgAACyADIAI2AhQgAyAENgIQIAMgATYCDCADQQA2AgggA0ICNwMADAELIAcgCDYCDCAIQYCAAk8EQCAHQQM2AiwgB0HswMMANgIoIAdCAjcCNCAHQTs2AkwgB0HNATYCRCAHQaTAwwA2AkAgByAHQUBrNgIwIAcgB0EMajYCSCAHQRBqQQRyIAdBKGoQmQ4gAyAHKQEWNwEOIANBFmogB0EeaikBADcBACADQR5qIAdBJmovAQA7AQAgAyAHLwEUOwEMIANBADYCCCADQgI3AwAMAQsgASAIQQFqNgJgIAEoAlwiCS0AnAEhAiABKAJYIgYgBigCACIEQQFqNgIAIARBAEgNAyAJIAkoAgAiBEEBajYCACAEQQBIDQNBFEEEEK02IgRFDQQgBCACOgAQIAQgAUEYajYCDCAEIAFBPGo2AgggBCABQTBqNgIEIAQgAUEkajYCACMAQRBrIgIkACABNQIUIRIgAkEEaiINIAZBCGooAggiCkEAQQhBwAIQoBggAigCCCELAkACQAJAAkAgAigCBEEBRwRAIAIoAgwhDyANIApBAEEEQQwQoBggAigCCCEOIAIoAgRBAUYNASACKAIMIRAgDSAKQQBBBEHMABCgGCACKAIIIQwgAigCBEEBRg0CIAIoAgwhESANIApBAEEEQRgQoBggAigCCCENIAIoAgRBAUYNAyACKAIMIQogAyABNgJoIAMgCTYCZCADIAY2AmAgA0IANwJsIANCADcDACADQgA3AxAgA0EYakIANwMAIAMgCDsBdCADQQA2AlwgAyAKNgJYIAMgDTYCVCADQQA2AlAgAyARNgJMIAMgDDYCSCADQQA2AkQgAyAQNgJAIAMgDjYCPCADQQA2AjggAyAPNgI0IAMgCzYCMCADQdS/wwA2AiwgAyAENgIoIAMgEjcDICACQRBqJAAMBAsgCyACKAIMQYDFwwAQ/S8ACyAOIAIoAgxBkMXDABD9LwALIAwgAigCDEGgxcMAEP0vAAsgDSACKAIMQbDFwwAQ/S8ACwsgB0HQAGokAAwECyABIAcoAjBB8MXDABD9LwALIAEgBygCMEHwxcMAEP0vCwALQQRBFBCjPQALIAVB+ARqIgEgBUGYBWopAwA3AwAgBUGABWoiAyAFQaAFaikDADcDACAFIAUpA5AFNwPwBCAFKQOIBSISQgJRBEAgACAFKQPwBDcDACAAQRBqIAMpAwA3AwAgAEEIaiABKQMANwMAIAVBDGoQ7ysMBAsgBUFAayAFQagFakHYAPwKAAAgBUEwaiAFQfgEaiIBKQMANwMAIAVBOGogBUGABWoiAykDADcDACAFIBI3AyAgBSAFKQPwBDcDKCADIAVBHGooAgA2AgAgASAFQRRqKQIANwMAIAUgBSkCDDcD8AQgBUGIBWogBUHwBGoQgiAgBSgClAUhAyAFKAKQBSEBIAUoAowFIQcgBSgCiAUiAkEIRwRAIAAgBSkDmAU3AxAgACADNgIMIAAgATYCCCAAIAc2AgQgACACNgIADAMLIAUgBzYC+AQgBSABNgLwBCAFIAEgA0HQA2xqIgc2AvwEIANFDQEgBUGgAWohDgNAAkAgASkDACISQgJSBEAgBSASNwOYASAOIAFBCGpByAP8CgAAIwBBwANrIgMkACADIAVBmAFqIgJBwAP8CgAAIAVBiAVqIQggAkHAA2oiDSEEQgAhEyMAQZAOayICJAACQAJAAkACQAJAIAVBIGoiCSgCbCAJKAI4RwRAIAJB0ApqQSVBAEEBQQEQoBggAigC1AohCSACKALQCkEBRg0EIAIoAtgKIgRB2cTDAEEl/AoAACAIQSU2AgwMAQsgCRDcHiIGRQRAIAJB0ApqQS1BAEEBQQEQoBggAigC1AohCSACKALQCkEBRg0EIAIoAtgKIgRBrMTDAEEt/AoAACAIQS02AgwMAQsgAiAGNgIMIAJBEGoiBiADQcAC/AoAACACIAYQhzw2ApAIIAIgAigCDEEIajYC0AoCQCACQZAIaiACQdAKaiIGEMwSRQRAIAkoAmg1AhQhHCACKQP4ASESIAYgBCACKQMoIAIpA4gCIhQgAikDICIVpxsiHRDiHCACKALQCgRAIAJBpAhqIAJB6ApqKQMAIhI3AgAgAkGcCGogAkHgCmopAwAiHDcCACACIAIpA9gKIhM3ApQIIAhBEGogEjcCACAIQQhqIBw3AgAgCCATNwIADAILIAJBkAhqIgQgAkHQCmoiBkEEckEk/AoAACACQeACaiAEQST8CgAAIAIgEjcD2AIgAiASNwPQAiACQdACaiEKIwBBoMAAayIEJAAgBEEANgKMQCAEQoDAADcChEAgBCAENgKAQCAJQegAaigCACEMA0ACQCAEQZDAAGogCiAEQYBAaxCvFAJAIAQtAJBAIgtBBEYNAANAAkACQAJAAkACQCALQQFrDgMAAgEECyAELQCRQEEjRw0DDAILIAQoApRALQAIQSNGDQEMAgsgBCgClEAtAAhBI0cNAQsgBCAEKQOQQDcDmEAgBEGYwABqELkuIARBkMAAaiAKIARBgEBrEK8UIAQtAJBAIgtBBEcNAQwCCwsgBiAEKQOQQDcCBCAGQQE2AgAMAQsgBCgCiEAiC0UEQCAGQQA2AgAgBiATNwMIDAELIARBmMAAaiAMIAQoAoBAIAsQqBogBC0AmEBBBEcEQCAEKQOYQCETIAZBATYCACAGIBM3AgQFIARBADYCiEAgEyALrXwhEwwCCwsLIARBoMAAaiQAAkAgAigC0ApBAUYEQCACIAIpAtQKNwPQCiAIIAYQgSsMAQsgAikD2AogElEEQCACQfgEaiIEIAJBEGoiBhDcLRCiHSACIAIpA+ABNwPIBiACQZAIaiIKIAJBkAJqENYeIAJB0ApqIAQgChCXKiACIAIpA/gBIhc3A7gMIAIpA9AKIRMgAikD2AohFiACQcgEaiACQfAKakEw/AoAACACQcgDaiACQbALakGAAfwKAAAgAkGIA2ogAkHQDGpBwAD8CgAAIBQgHX0gHHwhFCACKQNoIRggAikDYCEZIAIpA/ABIRogAikDgAIhGwJAIAYQ2jQiBEUEQCAcIRIMAQsgAiAcNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBClHSACQZAIaiACQdAKaiAMEIgrIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDbNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBClHSACQZAIaiACQdAKaiAMEIkrIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDYNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBCgBCACQZAIaiACQdAKaiAMEKAsIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDZNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBC1FiACQZAIaiACQdAKaiAMENUnIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgE0ICUQRAIAggEjcDECAIIBU3AwggCCAWNwMADAILIAMgEjcDGCADIBU3AxAgAyAWNwMIIAMgEzcDACADQSBqIAJByARqQTD8CgAAIAMgGDcDWCADIBk3A1AgA0HgAGogAkHIA2pBgAH8CgAAIAMgFDcD+AEgAyAbNwPwASADIBc3A+gBIAMgGjcD4AEgA0GAAmogAkGIA2pBwAD8CgAAAkAgAygCwAJBgICAgHhGDQAgAygCyAIiBkUNACADKALEAiEEIAZBGGwhBiAcIB19IRIDQCAEIBIgBCkDAHw3AwAgBEEYaiEEIAZBGGsiBg0ACwsgCSgCaCEKQRxBBBCtNiIERQRAQQRBHBCjPQALIAQgCTYCGCACQdAKaiIGQeTBwwA2AgggBiAENgIEIAYgCjYCACAEIAlB1ABqNgIUIAQgCUHIAGo2AhAgBCAJQTxqNgIMIAQgCUEwajYCCCAEIAlBGGo2AgQgBCAJQRBqNgIAIAIoAtgKIQQgAigC1AohCSAGIANBwAP8CgAAIAggCSAEIAYQ0ycgAkHQAmoQ9yogAkEQahDYEiACKAIMIgQgBCgCACIEQQFrNgIAIARBAUcNBiACQQxqENkhDAYLIAhBBGoQ9h8gCEEANgIACyACQdACahD3KgwBCyACIAJBEGoQhzw2ArgHIAJBAjYC1AogAkGcxMMANgLQCiACQgI3AtwKIAJBzgE2ApwIIAJBzwE2ApQIIAIgAkGQCGo2AtgKIAIgAkG4B2o2ApgIIAIgAkEMajYCkAggCEEEaiACQdAKahCZDiAIQQA2AgALIAJBEGoQ2BIgAigCDCIEIAQoAgAiBEEBazYCACAEQQFHDQEgAkEMahDZIQwBCyAIIAQ2AgggCCAJNgIEIAhBADYCACADENgSCyADQegCahCWMCADQfQCahDmJiADQcACahC9LgsgAkGQDmokAAwBCyAJIAIoAtgKQfDFwwAQ/S8ACyANENQnIA0Q7jsgA0HAA2okACAFKAKIBSIDQQhGDQEgACAFKQKMBTcCBCAAQQxqIAVBlAVqKQIANwIAIABBFGogBUGcBWooAgA2AgAgBSABQdADajYC9AQgACADNgIAIAVB8ARqEJoTDAULIAFB0ANqIQEMAwsgAUHQA2oiASAHRw0ACyAHIQEMAQsgAEEINgIADAILIAUgATYC9AQgBUHwBGoiARCaEyAFQYgFaiIDIAVBIGpB+AD8CgAAIAEgAxDKAiAFKAL0BCEBIAUoAvAEIgNBCEcEQCAAIAUpA/gENwMIIABBEGogBUGABWopAwA3AwAgACABNgIEIAAgAzYCAAwCCyAFIAE2AuwEIAEgASgCACIBQQFrNgIAIAFBAUYEQCAFQewEahDuHQsgAEEINgIADAELIAUoAoABIgAgACgCACIAQQFrNgIAIABBAUYEQCAFQYABahCGHwsgBSgChAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBhAFqEK4gCwJAIAUoApABIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBkAFqEO4dCyAFQdAAaiIAEJ8sIAAQ8zsgBUHcAGoiABCGKSAAEOg7IAVB6ABqIgAQ1x4gAEEEQcwAEOAeIAVB9ABqIgAQ5ScgAEEEQRgQ4B4gBSgCSCIARQ0AIAUoAkwiASgCACIDBEAgACADEQMACyABKAIEIgNFDQAgACADIAEoAggQ+DoLIAVBgAZqJAAL/icCEH8MfiMAQYAGayIFJAAgASgClAEhAyABQYCAgIB4NgKUAQJAAkACQCADQYCAgIB4RwRAIAVBGGogAUGgAWopAgA3AgAgBSADNgIMIAUgASkCmAE3AhAgBUGIBWohAyMAQdAAayIHJAACQAJAAkACQAJAAkACQAJAIAEtAGxFBEAgASgCaCIIIAEoAihGDQJBKCECIAdBKGpBKEEAQQFBARCgGCAHKAIsIQEgBygCKEEBRg0FIAcoAjAiBEGUwcMAQSj8CgAADAELQSUhAiAHQShqQSVBAEEBQQEQoBggBygCLCEBIAcoAihBAUYNAyAHKAIwIgRBvMHDAEEl/AoAAAsgAyACNgIUIAMgBDYCECADIAE2AgwgA0EANgIIIANCAjcDAAwBCyAHIAg2AgwgCEGAgAJPBEAgB0EDNgIsIAdB7MDDADYCKCAHQgI3AjQgB0E7NgJMIAdBzQE2AkQgB0GkwMMANgJAIAcgB0FAazYCMCAHIAdBDGo2AkggB0EQakEEciAHQShqEJkOIAMgBykBFjcBDiADQRZqIAdBHmopAQA3AQAgA0EeaiAHQSZqLwEAOwEAIAMgBy8BFDsBDCADQQA2AgggA0ICNwMADAELIAEgCEEBajYCaCABKAJkIgktAJwBIQIgASgCYCIGIAYoAgAiBEEBajYCACAEQQBIDQMgCSAJKAIAIgRBAWo2AgAgBEEASA0DQRRBBBCtNiIERQ0EIAQgAjoAECAEIAFBIGo2AgwgBCABQcQAajYCCCAEIAFBOGo2AgQgBCABQSxqNgIAIwBBEGsiAiQAIAE1AhwhEiACQQRqIg0gBkEIaigCCCIKQQBBCEHAAhCgGCACKAIIIQsCQAJAAkACQCACKAIEQQFHBEAgAigCDCEPIA0gCkEAQQRBDBCgGCACKAIIIQ4gAigCBEEBRg0BIAIoAgwhECANIApBAEEEQcwAEKAYIAIoAgghDCACKAIEQQFGDQIgAigCDCERIA0gCkEAQQRBGBCgGCACKAIIIQ0gAigCBEEBRg0DIAIoAgwhCiADIAE2AmggAyAJNgJkIAMgBjYCYCADQgA3AmwgA0IANwMAIANCADcDECADQRhqQgA3AwAgAyAIOwF0IANBADYCXCADIAo2AlggAyANNgJUIANBADYCUCADIBE2AkwgAyAMNgJIIANBADYCRCADIBA2AkAgAyAONgI8IANBADYCOCADIA82AjQgAyALNgIwIANBxL/DADYCLCADIAQ2AiggAyASNwMgIAJBEGokAAwECyALIAIoAgxBgMXDABD9LwALIA4gAigCDEGQxcMAEP0vAAsgDCACKAIMQaDFwwAQ/S8ACyANIAIoAgxBsMXDABD9LwALCyAHQdAAaiQADAQLIAEgBygCMEHwxcMAEP0vAAsgASAHKAIwQfDFwwAQ/S8LAAtBBEEUEKM9AAsgBUH4BGoiASAFQZgFaikDADcDACAFQYAFaiIDIAVBoAVqKQMANwMAIAUgBSkDkAU3A/AEIAUpA4gFIhJCAlEEQCAAIAUpA/AENwMAIABBEGogAykDADcDACAAQQhqIAEpAwA3AwAgBUEMahDvKwwECyAFQUBrIAVBqAVqQdgA/AoAACAFQTBqIAVB+ARqIgEpAwA3AwAgBUE4aiAFQYAFaiIDKQMANwMAIAUgEjcDICAFIAUpA/AENwMoIAMgBUEcaigCADYCACABIAVBFGopAgA3AwAgBSAFKQIMNwPwBCAFQYgFaiAFQfAEahCCICAFKAKUBSEDIAUoApAFIQEgBSgCjAUhByAFKAKIBSICQQhHBEAgACAFKQOYBTcDECAAIAM2AgwgACABNgIIIAAgBzYCBCAAIAI2AgAMAwsgBSAHNgL4BCAFIAE2AvAEIAUgASADQdADbGoiBzYC/AQgA0UNASAFQaABaiEOA0ACQCABKQMAIhJCAlIEQCAFIBI3A5gBIA4gAUEIakHIA/wKAAAjAEHAA2siAyQAIAMgBUGYAWoiAkHAA/wKAAAgBUGIBWohCCACQcADaiINIQRCACETIwBBkA5rIgIkAAJAAkACQAJAAkAgBUEgaiIJKAJsIAkoAjhHBEAgAkHQCmpBJUEAQQFBARCgGCACKALUCiEJIAIoAtAKQQFGDQQgAigC2AoiBEHZxMMAQSX8CgAAIAhBJTYCDAwBCyAJENweIgZFBEAgAkHQCmpBLUEAQQFBARCgGCACKALUCiEJIAIoAtAKQQFGDQQgAigC2AoiBEGsxMMAQS38CgAAIAhBLTYCDAwBCyACIAY2AgwgAkEQaiIGIANBwAL8CgAAIAIgBhCHPDYCkAggAiACKAIMQQhqNgLQCgJAIAJBkAhqIAJB0ApqIgYQzBJFBEAgCSgCaDUCHCEcIAIpA/gBIRIgBiAEIAIpAyggAikDiAIiFCACKQMgIhWnGyIdEOIcIAIoAtAKBEAgAkGkCGogAkHoCmopAwAiEjcCACACQZwIaiACQeAKaikDACIcNwIAIAIgAikD2AoiEzcClAggCEEQaiASNwIAIAhBCGogHDcCACAIIBM3AgAMAgsgAkGQCGoiBCACQdAKaiIGQQRyQST8CgAAIAJB4AJqIARBJPwKAAAgAiASNwPYAiACIBI3A9ACIAJB0AJqIQojAEGgwABrIgQkACAEQQA2AoxAIARCgMAANwKEQCAEIAQ2AoBAIAlB6ABqKAIAIQwDQAJAIARBkMAAaiAKIARBgEBrEK8UAkAgBC0AkEAiC0EERg0AA0ACQAJAAkACQAJAIAtBAWsOAwACAQQLIAQtAJFAQSNHDQMMAgsgBCgClEAtAAhBI0YNAQwCCyAEKAKUQC0ACEEjRw0BCyAEIAQpA5BANwOYQCAEQZjAAGoQuS4gBEGQwABqIAogBEGAQGsQrxQgBC0AkEAiC0EERw0BDAILCyAGIAQpA5BANwIEIAZBATYCAAwBCyAEKAKIQCILRQRAIAZBADYCACAGIBM3AwgMAQsgBEGYwABqIAwgBCgCgEAgCxCnGiAELQCYQEEERwRAIAQpA5hAIRMgBkEBNgIAIAYgEzcCBAUgBEEANgKIQCATIAutfCETDAILCwsgBEGgwABqJAACQCACKALQCkEBRgRAIAIgAikC1Ao3A9AKIAggBhCBKwwBCyACKQPYCiASUQRAIAJB+ARqIgQgAkEQaiIGENwtEKIdIAIgAikD4AE3A8gGIAJBkAhqIgogAkGQAmoQ1h4gAkHQCmogBCAKEJcqIAIgAikD+AEiFzcDuAwgAikD0AohEyACKQPYCiEWIAJByARqIAJB8ApqQTD8CgAAIAJByANqIAJBsAtqQYAB/AoAACACQYgDaiACQdAMakHAAPwKAAAgFCAdfSAcfCEUIAIpA2ghGCACKQNgIRkgAikD8AEhGiACKQOAAiEbAkAgBhDaNCIERQRAIBwhEgwBCyACIBw3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKUdIAJBkAhqIAJB0ApqIAwQiCsgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENs0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKUdIAJBkAhqIAJB0ApqIAwQiSsgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENg0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKAEIAJBkAhqIAJB0ApqIAwQoCwgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENk0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEELUWIAJBkAhqIAJB0ApqIAwQ1ScgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyATQgJRBEAgCCASNwMQIAggFTcDCCAIIBY3AwAMAgsgAyASNwMYIAMgFTcDECADIBY3AwggAyATNwMAIANBIGogAkHIBGpBMPwKAAAgAyAYNwNYIAMgGTcDUCADQeAAaiACQcgDakGAAfwKAAAgAyAUNwP4ASADIBs3A/ABIAMgFzcD6AEgAyAaNwPgASADQYACaiACQYgDakHAAPwKAAACQCADKALAAkGAgICAeEYNACADKALIAiIGRQ0AIAMoAsQCIQQgBkEYbCEGIBwgHX0hEgNAIAQgEiAEKQMAfDcDACAEQRhqIQQgBkEYayIGDQALCyAJKAJoIQpBHEEEEK02IgRFBEBBBEEcEKM9AAsgBCAJNgIYIAJB0ApqIgZB9MHDADYCCCAGIAQ2AgQgBiAKNgIAIAQgCUHUAGo2AhQgBCAJQcgAajYCECAEIAlBPGo2AgwgBCAJQTBqNgIIIAQgCUEYajYCBCAEIAlBEGo2AgAgAigC2AohBCACKALUCiEJIAYgA0HAA/wKAAAgCCAJIAQgBhDTJyACQdACahD3KiACQRBqENgSIAIoAgwiBCAEKAIAIgRBAWs2AgAgBEEBRw0GIAJBDGoQ2SEMBgsgCEEEahD2HyAIQQA2AgALIAJB0AJqEPcqDAELIAIgAkEQahCHPDYCuAcgAkECNgLUCiACQZzEwwA2AtAKIAJCAjcC3AogAkHOATYCnAggAkHPATYClAggAiACQZAIajYC2AogAiACQbgHajYCmAggAiACQQxqNgKQCCAIQQRqIAJB0ApqEJkOIAhBADYCAAsgAkEQahDYEiACKAIMIgQgBCgCACIEQQFrNgIAIARBAUcNASACQQxqENkhDAELIAggBDYCCCAIIAk2AgQgCEEANgIAIAMQ2BILIANB6AJqEJYwIANB9AJqEOYmIANBwAJqEL0uCyACQZAOaiQADAELIAkgAigC2ApB8MXDABD9LwALIA0Q1CcgDRDuOyADQcADaiQAIAUoAogFIgNBCEYNASAAIAUpAowFNwIEIABBDGogBUGUBWopAgA3AgAgAEEUaiAFQZwFaigCADYCACAFIAFB0ANqNgL0BCAAIAM2AgAgBUHwBGoQmhMMBQsgAUHQA2ohAQwDCyABQdADaiIBIAdHDQALIAchAQwBCyAAQQg2AgAMAgsgBSABNgL0BCAFQfAEaiIBEJoTIAVBiAVqIgMgBUEgakH4APwKAAAgASADEMoCIAUoAvQEIQEgBSgC8AQiA0EIRwRAIAAgBSkD+AQ3AwggAEEQaiAFQYAFaikDADcDACAAIAE2AgQgACADNgIADAILIAUgATYC7AQgASABKAIAIgFBAWs2AgAgAUEBRgRAIAVB7ARqEO4dCyAAQQg2AgAMAQsgBSgCgAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBgAFqEIYfCyAFKAKEASIAIAAoAgAiAEEBazYCACAAQQFGBEAgBUGEAWoQriALAkAgBSgCkAEiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBUGQAWoQ7h0LIAVB0ABqIgAQnywgABDzOyAFQdwAaiIAEIYpIAAQ6DsgBUHoAGoiABDXHiAAQQRBzAAQ4B4gBUH0AGoiABDlJyAAQQRBGBDgHiAFKAJIIgBFDQAgBSgCTCIBKAIAIgMEQCAAIAMRAwALIAEoAgQiA0UNACAAIAMgASgCCBD4OgsgBUGABmokAAvdHgIUfwN+IwBBkAprIgYkAAJAAkACQCAELwE4BEAgBC4BOiIHQQBIBEAgBkECNgKkBSAGQbS/wwA2AqAFIAZCATcCrAUgBkHNATYCtAEgBiAHOwEwIAYgBkGwAWo2AqgFIAYgBkEwajYCsAEgBkHgAmpBBHIgBkGgBWoQmQ4gACAGKQHmAjcBBiAAQQ5qIAZB7gJqKQEANwEAIABBFmogBkH2AmovAQA7AQAgACAGLwHkAjsBBCAAQQA2AgAMBAsgBiAEEIY8IAYoAgQiBEUNAiADIAdNDQEgBigCACEUIAZBoARqIRUgBkHoAmohDiAGQYADaiEWIARBwAJsIRcgAiAHQQxsaiIYKAIIIQ9BfyEQQQAhAgNAIBBBAWoiECAPRgRAIA8gD0GEv8MAEMMhAAsgGCgCBCARaiIDKAIAIQQgA0GAgICAeDYCAAJAIARBgICAgHhGDQAgBiADQQRqKQIANwIQIAYgBDYCDCABKAIUIRIgBkGgBWohDSMAQaABayIHJAAgByABNgIMIAdCgICAgJCAgICAfzcCGCAHQoCAgIAgNwIQIAdBADsBNCAHIAdBDGo2AjAgByAGQQxqIhMQ9js2AjggB0E8aiELIAdBOGohBSMAQUBqIggkACAIQQxqQdfDwgBBERCAICAIQSxqIAdBEGoiAxDnJwJAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAhBLGoiBEHow8IAQQhBBkEBEOgcIAhBGGogAyAEEK4UIAgoAhgiCUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAJNgIAIAQQhjAMAQsgCEEsaiIEEIYwIAQgAyAFKAIAEKsbIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiIEQe6/wgBBCUEKQQIQ6BwgCEEYaiADIAQQrhQgCCgCGCIFQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAU2AgAgBBCGMAwBCyAIQSxqIgkQhjAjAEFAaiIFJAAgBUEMakHkxMIAQRQQgCAgBUEsaiADEOcnAkAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgBUEsaiIEQfjEwgBBBUEKQQEQ6BwgBUEYaiADIAQQrhQgBSgCGCIKQQRHBEAgCSAFKQIcNwIEIAlBDGogBUEkaikCADcCACAJIAo2AgAgBBCGMAwBCyAFQSxqIgQQhjAjAEEgayIKJAAgCkHRxMIAQRMQgCAgCkEMaiADEOcnAkAgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgCkEMaiADEIE2IAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIAQgAxDlKAsgChDeOyAKQSBqJAAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgAxDGISAFQSxqIAMQgTYgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgCSADEOUoCyAFQQxqEN47IAVBQGskACAIKAIsIgRBBEcEQCALIAgpAjA3AgQgC0EMaiAIQThqKQIANwIAIAsgBDYCAAwBCyADEMYhIAhBLGoiBEHww8IAQQRBCkEDEOgcIAhBGGogAyAEEK4UIAgoAhgiBUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAFNgIAIAQQhjAMAQsgCEEsaiIJEIYwIwBBQGoiBSQAIAVBDGpBssPCAEEPEIAgIAVBLGogAxDnJwJAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAVBLGoiBEHBw8IAQQZBCkEBEOgcIAVBGGogAyAEEK4UIAUoAhgiCkEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAKNgIAIAQQhjAMAQsgBUEsaiIEEIYwIwBBIGsiCiQAIApBoLbCAEEGEIAgIApBDGogAxDnJwJAIAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIApBDGogAxCBNiAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAEIAMQ5SgLIAoQ3jsgCkEgaiQAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAMQxiEgBUEsaiADEIE2IAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIgRB9MPCAEELQQpBBBDoHCAIQRhqIAMgBBCuFCAIKAIYIgVBBEcEQCALIAgpAhw3AgQgC0EMaiAIQSRqKQIANwIAIAsgBTYCACAEEIYwDAELIAhBLGoiCRCGMCMAQUBqIgUkACAFQQxqQe3FwgBBFhCAICAFQSxqIAMQ5ycCQCAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAFQSxqIgRBg8bCAEEMQQpBARDoHCAFQRhqIAMgBBCuFCAFKAIYIgpBBEcEQCAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgCjYCACAEEIYwDAELIAVBLGoiBBCGMCMAQSBrIgokACAKQdW/wgBBDBCAICAKQQxqIAMQ5ycCQCAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAKQQxqIAMQgTYgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgBCADEOUoCyAKEN47IApBIGokACAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyADEMYhIAVBLGogAxCBNiAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAJIAMQ5SgLIAVBDGoQ3jsgBUFAayQAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiADEIE2IAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAsgAxDlKAsgCEEMahDeOyAIQUBrJAACQCAHKAI8QQRHBEAgB0H4AGogB0HMAGooAgA2AgAgB0HwAGogB0HEAGopAgA3AwAgByAHKQI8NwNoIAdBATYChAEgB0GYlMMANgKAASAHQgE3AowBIAdBhwE2ApwBIAcgB0GYAWo2AogBIAcgB0HoAGoiAzYCmAEgB0HQAGpBBHIgB0GAAWoQmQ4gAxDTLSANQRRqIAdB5ABqKAIANgIAIA1BDGogB0HcAGopAgA3AgAgDSAHKQJUNwIEIA1BADYCAAwBCyAHQdAAaiEEIwBBEGsiAyQAIANBCGoiCCAHQRBqKAIgKAIAEMMZAkACQCADLQAIQQRGDQAgAykDCCIZQv8Bg0IEUQ0AIAMgGTcDCCAEIAgQ0AkMAQsgBEEENgIACyADQRBqJAAgBygCUCIDQQRHBEAgB0GMAWogB0HcAGopAgA3AgAgByAHKQJUNwKEASAHIAM2AoABIA0gB0GAAWoQpSUMAQsjAEHQAGsiAyQAIANBCGogB0EMaigCACATKAIEIBMoAghBBXQQqBogB0GAAWoiBCADLQAIQQRHBH8gAyADKQMINwMoIANBATYCNCADQeiTwwA2AjAgA0IBNwI8IANBhgE2AkwgAyADQcgAajYCOCADIANBKGoiCDYCSCADQRBqQQRyIANBMGoQmQ4gCBC5LiAEQRRqIANBJGooAgA2AgAgBEEMaiADQRxqKQIANwIAIAQgAykCFDcCBEEABUEICzYCACADQdAAaiQAIAcoAoABIgNBCEcEQCANIAcpAoQBNwIEIA1BFGogB0GUAWooAgA2AgAgDUEMaiAHQYwBaikCADcCACANIAM2AgAMAQsgDUEINgIACyAHQRBqELouIAdBoAFqJAACQCAGKAKgBSIDQQhHBEAgACAGKQKkBTcCBCAAQRRqIAZBtAVqKAIANgIAIABBDGogBkGsBWopAgA3AgAgACADNgIADAELIAEoAhQhCCAGQaAFaiIEIAIgFGoiAxC0CCAGQeACaiAEENA1IAZB0AJqIgQgDkEIaikDADcDACAGQdgCaiIHIA5BEGopAwA3AwAgBiASrTcDiAMgBkIBNwOAAyAGIA4pAwA3A8gCIAYpA+ACIRkgBkGwAWogFkGYAfwKAAAgBkEwaiAVQYAB/AoAACAZQgJRBEAgBkEoaiAHKQMAIhk3AwAgBkEgaiAEKQMAIho3AwAgBiAGKQPIAiIbNwMYIABBEGogGTcDACAAQQhqIBo3AwAgACAbNwMADAELIAZBKGoiCyAHKQMANwMAIAZBIGoiByAEKQMANwMAIAYgBikDyAI3AxggBkHgCGoiBCAGQbABakGYAfwKAAAgBkHgB2oiBSAGQTBqQYAB/AoAACAGQYAKaiIJIAcpAwA3AwAgBkGICmoiByALKQMANwMAIAYgBikDGDcD+AkgAxDYEiADIBk3AwAgA0EIaiAGKQP4CTcDACADQRBqIAkpAwA3AwAgA0EYaiAHKQMANwMAIANBIGogBEGYAfwKAAAgA0G8AWogCCASazYCACADQbgBakEBNgIAIANBwAFqIAVBgAH8CgAAIAZBDGoQ8DsMAQsgBkEMahDwOwwFCyARQQxqIREgFyACQcACaiICRw0ACwwCC0HIvsMAQRlB5L7DABDLJAALIAcgA0H0vsMAEMMhAAsgAEEINgIACyAGQZAKaiQAC90eAhR/A34jAEGQCmsiBiQAAkACQAJAIAQvATgEQCAELgE6IgdBAEgEQCAGQQI2AqQFIAZBtL/DADYCoAUgBkIBNwKsBSAGQc0BNgK0ASAGIAc7ATAgBiAGQbABajYCqAUgBiAGQTBqNgKwASAGQeACakEEciAGQaAFahCZDiAAIAYpAeYCNwEGIABBDmogBkHuAmopAQA3AQAgAEEWaiAGQfYCai8BADsBACAAIAYvAeQCOwEEIABBADYCAAwECyAGIAQQhjwgBigCBCIERQ0CIAMgB00NASAGKAIAIRQgBkGgBGohFSAGQegCaiEOIAZBgANqIRYgBEHAAmwhFyACIAdBDGxqIhgoAgghD0F/IRBBACECA0AgEEEBaiIQIA9GBEAgDyAPQYS/wwAQwyEACyAYKAIEIBFqIgMoAgAhBCADQYCAgIB4NgIAAkAgBEGAgICAeEYNACAGIANBBGopAgA3AhAgBiAENgIMIAEoAhwhEiAGQaAFaiENIwBBoAFrIgckACAHIAE2AgwgB0KAgICAkICAgIB/NwIYIAdCgICAgCA3AhAgB0EAOwE0IAcgB0EMajYCMCAHIAZBDGoiExD2OzYCOCAHQTxqIQsgB0E4aiEFIwBBQGoiCCQAIAhBDGpB18PCAEEREIAgIAhBLGogB0EQaiIDEOcnAkAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgCEEsaiIEQejDwgBBCEEGQQEQ6BwgCEEYaiADIAQQrRQgCCgCGCIJQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAk2AgAgBBCGMAwBCyAIQSxqIgQQhjAgBCADIAUoAgAQqhsgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIgRB7r/CAEEJQQpBAhDoHCAIQRhqIAMgBBCtFCAIKAIYIgVBBEcEQCALIAgpAhw3AgQgC0EMaiAIQSRqKQIANwIAIAsgBTYCACAEEIYwDAELIAhBLGoiCRCGMCMAQUBqIgUkACAFQQxqQeTEwgBBFBCAICAFQSxqIAMQ5ycCQCAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAFQSxqIgRB+MTCAEEFQQpBARDoHCAFQRhqIAMgBBCtFCAFKAIYIgpBBEcEQCAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgCjYCACAEEIYwDAELIAVBLGoiBBCGMCMAQSBrIgokACAKQdHEwgBBExCAICAKQQxqIAMQ5ycCQCAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAKQQxqIAMQgDYgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgBCADEOUoCyAKEN47IApBIGokACAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyADEMYhIAVBLGogAxCANiAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAJIAMQ5SgLIAVBDGoQ3jsgBUFAayQAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiIEQfDDwgBBBEEKQQMQ6BwgCEEYaiADIAQQrRQgCCgCGCIFQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAU2AgAgBBCGMAwBCyAIQSxqIgkQhjAjAEFAaiIFJAAgBUEMakGyw8IAQQ8QgCAgBUEsaiADEOcnAkAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgBUEsaiIEQcHDwgBBBkEKQQEQ6BwgBUEYaiADIAQQrRQgBSgCGCIKQQRHBEAgCSAFKQIcNwIEIAlBDGogBUEkaikCADcCACAJIAo2AgAgBBCGMAwBCyAFQSxqIgQQhjAjAEEgayIKJAAgCkGgtsIAQQYQgCAgCkEMaiADEOcnAkAgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgCkEMaiADEIA2IAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIAQgAxDlKAsgChDeOyAKQSBqJAAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgAxDGISAFQSxqIAMQgDYgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgCSADEOUoCyAFQQxqEN47IAVBQGskACAIKAIsIgRBBEcEQCALIAgpAjA3AgQgC0EMaiAIQThqKQIANwIAIAsgBDYCAAwBCyADEMYhIAhBLGoiBEH0w8IAQQtBCkEEEOgcIAhBGGogAyAEEK0UIAgoAhgiBUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAFNgIAIAQQhjAMAQsgCEEsaiIJEIYwIwBBQGoiBSQAIAVBDGpB7cXCAEEWEIAgIAVBLGogAxDnJwJAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAVBLGoiBEGDxsIAQQxBCkEBEOgcIAVBGGogAyAEEK0UIAUoAhgiCkEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAKNgIAIAQQhjAMAQsgBUEsaiIEEIYwIwBBIGsiCiQAIApB1b/CAEEMEIAgIApBDGogAxDnJwJAIAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIApBDGogAxCANiAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAEIAMQ5SgLIAoQ3jsgCkEgaiQAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIAMQgDYgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgCyADEOUoCyAIQQxqEN47IAhBQGskAAJAIAcoAjxBBEcEQCAHQfgAaiAHQcwAaigCADYCACAHQfAAaiAHQcQAaikCADcDACAHIAcpAjw3A2ggB0EBNgKEASAHQZiUwwA2AoABIAdCATcCjAEgB0GHATYCnAEgByAHQZgBajYCiAEgByAHQegAaiIDNgKYASAHQdAAakEEciAHQYABahCZDiADENMtIA1BFGogB0HkAGooAgA2AgAgDUEMaiAHQdwAaikCADcCACANIAcpAlQ3AgQgDUEANgIADAELIAdB0ABqIQQjAEEQayIDJAAgA0EIaiIIIAdBEGooAiAoAgAQnRkCQAJAIAMtAAhBBEYNACADKQMIIhlC/wGDQgRRDQAgAyAZNwMIIAQgCBDQCQwBCyAEQQQ2AgALIANBEGokACAHKAJQIgNBBEcEQCAHQYwBaiAHQdwAaikCADcCACAHIAcpAlQ3AoQBIAcgAzYCgAEgDSAHQYABahClJQwBCyMAQdAAayIDJAAgA0EIaiAHQQxqKAIAIBMoAgQgEygCCEEFdBCnGiAHQYABaiIEIAMtAAhBBEcEfyADIAMpAwg3AyggA0EBNgI0IANB6JPDADYCMCADQgE3AjwgA0GGATYCTCADIANByABqNgI4IAMgA0EoaiIINgJIIANBEGpBBHIgA0EwahCZDiAIELkuIARBFGogA0EkaigCADYCACAEQQxqIANBHGopAgA3AgAgBCADKQIUNwIEQQAFQQgLNgIAIANB0ABqJAAgBygCgAEiA0EIRwRAIA0gBykChAE3AgQgDUEUaiAHQZQBaigCADYCACANQQxqIAdBjAFqKQIANwIAIA0gAzYCAAwBCyANQQg2AgALIAdBEGoQui4gB0GgAWokAAJAIAYoAqAFIgNBCEcEQCAAIAYpAqQFNwIEIABBFGogBkG0BWooAgA2AgAgAEEMaiAGQawFaikCADcCACAAIAM2AgAMAQsgASgCHCEIIAZBoAVqIgQgAiAUaiIDELQIIAZB4AJqIAQQ0DUgBkHQAmoiBCAOQQhqKQMANwMAIAZB2AJqIgcgDkEQaikDADcDACAGIBKtNwOIAyAGQgE3A4ADIAYgDikDADcDyAIgBikD4AIhGSAGQbABaiAWQZgB/AoAACAGQTBqIBVBgAH8CgAAIBlCAlEEQCAGQShqIAcpAwAiGTcDACAGQSBqIAQpAwAiGjcDACAGIAYpA8gCIhs3AxggAEEQaiAZNwMAIABBCGogGjcDACAAIBs3AwAMAQsgBkEoaiILIAcpAwA3AwAgBkEgaiIHIAQpAwA3AwAgBiAGKQPIAjcDGCAGQeAIaiIEIAZBsAFqQZgB/AoAACAGQeAHaiIFIAZBMGpBgAH8CgAAIAZBgApqIgkgBykDADcDACAGQYgKaiIHIAspAwA3AwAgBiAGKQMYNwP4CSADENgSIAMgGTcDACADQQhqIAYpA/gJNwMAIANBEGogCSkDADcDACADQRhqIAcpAwA3AwAgA0EgaiAEQZgB/AoAACADQbwBaiAIIBJrNgIAIANBuAFqQQE2AgAgA0HAAWogBUGAAfwKAAAgBkEMahDwOwwBCyAGQQxqEPA7DAULIBFBDGohESAXIAJBwAJqIgJHDQALDAILQci+wwBBGUHkvsMAEMskAAsgByADQfS+wwAQwyEACyAAQQg2AgALIAZBkApqJAAL/AcCCH8BfiMAQTBrIgQkAAJAIAItAAwiBUEBRgRAIAEtAAwhAiAAIAEQ6R0gACACOgAMDAELAkACQAJAAkACQAJAAkAgAS0ADCIGQQFrDgIGAQALIAVFDQEMAgsgBUUNAQsCQCABKAIIIAIoAghJBEAgBEEgaiIDIAIQ6R0gBEEQaiADIAEQ7QgMAQsgBEEgaiIDIAEQ6R0gBEEQaiADIAIQ7QgLIAZBAUcEQCAGQQEgBCgCGBshAwwDCyAEQQA2AhggBEEQakEEQQQQniQgBCgCGCICRQ0BIAQoAhQiASACQQJ0IgVqQQRrIgNFDQEgAygCAA0BIAUhAyABQQRrIQUgAkH/////A3EhAQJAA0AgA0UEQEEAIQMMAgsgAUEBayEBIAMgBWogA0EEayEDKAIARQ0ACyABQQFqIgMgAksNAgsgBCADNgIYIAMhAgwBCwJAAkACQAJ/IAEoAggiAyACKAIIIgdHBEAgAyAHSyADIAdJawwBCyADQQJ0IQMgASgCBEEEayEJIAIoAgRBBGshCgJAA0AgA0UNASADIApqIQggAyAJaiADQQRrIQMoAgAiByAIKAIAIghGDQALIAcgCEsgByAISWsMAQtBf0EAIAMbCyIDQf8BcQ4CAQIACyAEQSBqIgMgAhDpHSADIAEQ7xQgBCkDICELIAAgBUEBIAQoAigiARs6AAwgACABNgIIIAAgCzcCAAwFCyAAQQhqQZSKiAEpAgA3AgAgAEGMiogBKQIANwIADAQLIARBIGoiBSABEOkdIAUgAhDvFCAEQRhqIARBKGooAgA2AgAgBCAEKQIgNwMQAkAgBkEBRwRAIAZBASAEKAIYGyEDDAELIARBADYCGCAEQRBqQQRBBBCeJAJAIAQoAhgiAkUNACAEKAIUIgEgAkECdCIFakEEayIDRQ0AIAMoAgANACAFIQMgAUEEayEFIAJB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAVqIANBBGshAygCAEUNAAsgAUEBaiIDIAJLDQELIAQgAzYCGCADIQILQQEhAyACIAQoAhBBAnZPDQAgBEEIaiAEQRBqIAJBBEEEEPQUIAQoAggiAUGBgICAeEYNACABIAQoAgxBzI2IARD9LwALIAAgBCkDEDcCACAAIAM6AAwgAEEIaiAEQRhqKAIANgIADAMLQQEhAyACIAQoAhBBAnZPDQAgBCAEQRBqIAJBBEEEEPQUIAQoAgAiAUGBgICAeEYNACABIAQoAgRBzI2IARD9LwALIAAgBCkCEDcCACAAIAM6AAwgAEEIaiAEQRhqKAIANgIADAELIAAgAhDpHSAAIAU6AAwLIARBMGokAAv4BwEUfyMAQSBrIg8kACADIARxIhMgAk0EQCAPQQA2AgQgAiATa0EDSwRAIA9BBGpBBCABIBNqQQRBtNnOABDVLCAPKAIEQb3P1vEBbEEPdiILIAAoAgQiDUkEQCAAKAIQIhYgA3FBAXQhDSAAKAIAIAtBAnRqIgsoAgAhECAGQf8ASwRAIAsgAzYCAAsgACgCDCEMIAAoAgghESANQQFyIQ4CQAJAAkACQAJAIAMgEGsiGkEBayAHTw0AQYABIAYgBkGAAU8bIR4gCCgCACEbQUEhFyAGQf8ASyEcA0ACQAJAIBkgGCAYIBlLGyILIBNqIhQgAk0EQCACIAsgBCAQcSIdaiIVSQ0BIAogEkYgASAUaiACIBRrIAEgFWogAiAVayAGIAtrELIgIAtqIB0gBRChLiILIBtNcg0CIAggCzYCACAKIBJLBEAgCSASQQN0aiAarSALrUIlhoQ3AwAgEkEBaiESIAshGwwDCyASIApBpN/OABDDIQALIBQgAkGE384AEK87AAsgFSACQZTfzgAQrzsACwJ/AkACQCALIB5JBEACQAJAAkAgAiALIBNqIhRLBEAgCyAdaiIVIAJPDQEgASAUai0AACABIBVqLQAASw0DIBwNAgwGCyAUIAJBtN/OABDDIQALIBUgAkHE384AEMMhAAsgDCAOSwRAIBEgDkECdGogEDYCAAwECyAOIAxB1N/OABDDIQALIBxFDQEgDCANSwRAIBEgDUECdGogEDYCAAwCCyANIAxB9N/OABDDIQALIAZB/wBNDQcCQAJAAkAgDCAQIBZxQQF0IgBLBEAgDCANTQ0BIBEgDUECdGogESAAQQJ0aigCADYCACAAQQFyIgAgDE8NAiAMIA5NDQMgESAAQQJ0aigCACELDAoLIAAgDEGU4M4AEMMhAAsgDSAMQaTgzgAQwyEACyAAIAxBtODOABDDIQALIA4gDEHE4M4AEMMhAAsgDCAQIBZxQQF0QQFyIg1LBEAgCyEYIA0MAgsgDSAMQYTgzgAQwyEACyAQIBZxQQF0Ig4gDE8NAyALIRkgDgshCyAXRQ0BIBdBAWohFyADIBEgC0ECdGooAgAiEGsiGkEBayAHSQ0ACwsgBkH/AE0NAiAMIA1NDQMgESANQQJ0aiAAKAI8Igs2AgAgDCAOSw0BIA4gDEHk4M4AEMMhAAsgDiAMQeTfzgAQwyEACyARIA5BAnRqIAs2AgALIA9BIGokACASDwsgDSAMQdTgzgAQwyEACyALIA1B9N7OABDDIQALIA9BADYCGCAPQQE2AgwgD0GY184ANgIIIA9CBDcCECAPQQhqQaTZzgAQ7ywACyATIAJB5N7OABCvOwAL8QcCBn8DfiMAQdAEayICJAACQAJAAkACQAJAAkAgASkDACIIQgJWDQACQCAIp0EBaw4CAQACCyABKAIYIQMgAUEANgIYAkACQAJAIAMEQCACQcACaiADKAL8ASADKAL4ASABKQMQIggQhRkgAigCwAIiBEEIRwRAIAAgAikCxAI3AgQgAEEUaiACQdQCaigCADYCACAAQQxqIAJBzAJqKQIANwIAIAAgBDYCACADEPwsIANBiAJBCBD4OgwKCyABIAggAzQC/AEiCH03AxAgASAIIAEpAwh8NwMIIAMQ/CwgA0GIAkEIEPg6IAEtACBBAXENAiABKAIcIQMMAQsgAkHAAmogASgCQEEIaiABKQMIIgkQ9A8gAkEoaiIDIAJBzAJqKQIANwMAIAIgAikCxAI3AyAgAigCwAIiBEEIRwRAIAJBGGogAykDACIINwMAIAIgAikDICIJNwMQIAIoAtQCIQEgAEEMaiAINwIAIAAgCTcCBCAAIAE2AhQgACAENgIADAkLIAJBCGogAykDADcDACACIAIpAyA3AwAgAS0AICABKAIcIQMgAkHAAmogAhDyEyACKQPIAiIIQgRRBEAgAkG4AmogAkHgAmopAwAiCDcDACACQbACaiACQdgCaikDACIJNwMAIAIgAikD0AIiCjcDqAIgAEEQaiAINwMAIABBCGogCTcDACAAIAo3AwAMCAsgAkGwAmoiBSACQdgCaikDADcDACACQbgCaiIHIAJB4AJqKQMANwMAIAIgAikD0AI3A6gCIAIoAsACIQQgAkFAayACQegCakHoAfwKAAAgAkEwaiAFKQMANwMAIAJBOGogBykDADcDACACIAg3AyAgAiACKQOoAjcDKCACQcACaiAEIAEpAxAiCBCOGiACKALAAiIFQQhHBEAMBwsgAkHAAmogAigCnAIgAigCmAIgCBCFGSACKALAAiIFQQhHBEAMBwsgASAIIAI0ApwCIAStfCIIfTcDECABIAggCXw3AwggAkEgahD8LCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEAQQFxDQELIAEgA0EBajYCHAwBCyABQQA6ACALIABBCDYCAAwFCyABQgA3AwAMAQsgASgCLCIDRQ0AIAEgA0EBazYCLCABIAEoAjRBAWo2AjQgASABKAIoQQFqIgMgASgCICIBQQAgASADTRtrNgIoCyAAQQg2AgAMAgsgACACKQLEAjcCBCAAQRRqIAJB1AJqKAIANgIAIABBDGogAkHMAmopAgA3AgAgACAFNgIAIAJBIGoQ/CwLIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAJB0ARqJAALuwcBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIsIAIgAEEBdiIATw0LIAQgASgCECACQQF0ai8BADsBKiADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKmogAxC/ECECDAoLIARBKmogAxC3HCECDAkLIAAoAgQoAhQhACAEIAI2AiwgAiAAQQF2IgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akGDhowYNgIAIARCg4aMmLDgwIEDNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAXYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQF2IgFJDQUMBwsgBEE4akGDhowYNgIAIARCg4aMmLDgwIEDNwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBg4aMGDYCACAEQoOGjJiw4MCBAzcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBKmogAxC0HCECDAILIAQgACgCECACQQF0ajIBADcDACAEQThqQYOGjBg2AgAgBEKDhoyYsODAgQM3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACQQF0ajIBADcDCCAEQThqQYOGjBg2AgAgBEKDhoyYsODAgQM3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALjQgBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtBhYqUKDYCACAEQoWKlKjQoMGCBTcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCgsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAkLIARBQGtBhYqUKDYCACAEQoWKlKjQoMGCBTcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQYWKlCg2AgAgBEKFipSo0KDBggU3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0GFipQoNgIAIARChYqUqNCgwYIFNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEIAAoAhAgAkEDdGopAwA3AwggBEFAa0GFipQoNgIAIARChYqUqNCgwYIFNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC7sHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAXYiAE8NCyAEIAEoAhAgAkEBdGovAQA7ASogAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQSpqIAMQnBIhAgwKCyAEQSpqIAMQtxwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEEBdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBh46cODYCACAEQoeOnLjw4MGDBzcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQF2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUEBdiIBSQ0FDAcLIARBOGpBh46cODYCACAEQoeOnLjw4MGDBzcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYeOnDg2AgAgBEKHjpy48ODBgwc3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQSpqIAMQtBwhAgwCCyAEIAAoAhAgAkEBdGozAQA3AwAgBEE4akGHjpw4NgIAIARCh46cuPDgwYMHNwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkEBdGozAQA3AwggBEE4akGHjpw4NgIAIARCh46cuPDgwYMHNwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC7sHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AiggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQzCQhAgwKCyAEQShqIAMQ0xwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEECdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBhIiQIDYCACAEQoSIkKDAgIGCBDcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAcLIARBOGpBhIiQIDYCACAEQoSIkKDAgIGCBDcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYSIkCA2AgAgBEKEiJCgwICBggQ3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQShqIAMQ0hwhAgwCCyAEIAAoAhAgAkECdGo0AgA3AwAgBEE4akGEiJAgNgIAIARChIiQoMCAgYIENwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkECdGo0AgA3AwggBEE4akGEiJAgNgIAIARChIiQoMCAgYIENwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC8AHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AiggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQ/CghAgwKCyAEQShqIAMQ0xwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEECdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAgLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAnYiAUkNBQwHCyAEQThqQYiQoMAANgIAIARCiJCgwICBgoQINwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQShqIAMQ0hwhAgwCCyAEIAAoAhAgAkECdGo1AgA3AwAgBEE4akGIkKDAADYCACAEQoiQoMCAgYKECDcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAQsgBCAAKAIQIAJBAnRqNQIANwMIIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALpgwCB38DfiMAQdABayICJAAgAkHIAGohBCMAQYACayIDJAAgAUGwAWoiBSgCACEGIAVBgICAgHg2AgACQAJAIAZBgICAgHhHBEAgAyAGNgIAIANBBHIgBUEEakHcAPwKAAAgAygCWARAIANB+ABqQTBBAEEBQQEQoBggAygCfCEFIAMoAnhBAUYNAiADKAKAASIGQbj7zQBBMPwKAAAgBEEwNgIUIAQgBjYCECAEIAU2AgwgBEEANgIIIARBATYCACADEIIrDAMLIANB+ABqIANB4AD8CgAAIANB6AFqIANBEGopAwA3AwAgA0HgAWogA0EIaiIGKQMANwMAIAMgAykDADcD2AEgAygCHCIFBEAgAygCGCAFQQN0QQ9qQXhxIgdrIAUgB2pBCWpBCBD4OgsgA0H4AWogBigCADYCACADIAMpAwA3A/ABIANB4ABqIANB8AFqEOcVIANB8ABqIgUgAygC7AE2AgAgA0EAOgB0IANB5AFqQQRBCBDgHiADQcgBahDjPCAEQRRqIAUpAgA3AgAgBEEMaiADQegAaikCADcCACAEIAMpAmA3AgQgBEEANgIADAILIARBADYCACAEQQI6ABgMAQsgBSADKAKAAUG09c0AEP0vAAsgA0GAAmokAAJAIAIoAkhBAUYEQCACKQNQIQkgAikDWCEKIAAgAikDYDcDECAAIAo3AwggACAJNwMADAELAkACfwJAAkACQAJAIAIoAmAiBEH/AXFBAkYEQCACQcgAakEdQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQEgAigCUCIBQRVqQY2EzwApAAA3AAAgAUEQakGIhM8AKQAANwAAIAFBCGpBgITPACkAADcAACABQfiDzwApAAA3AAAgAEEdNgIMIAAgATYCCCAAIAM2AgQgAEEANgIADAcLIAIoAlwhBSACKAJYIQcgAigCVCEDIAIoAlAhBiACKAJMIQggAiAENgI8IAIgBTYCOCACIAc2AjQgAiADNgIwIAIgBjYCLCACIAg2AiggASgCyAQiBwRAIAJByABqIgggA0EAQQFBARCgGCACKAJMIQQgAigCSEEBRg0CIAJBNGohBSACQQA2AiQgAiACKAJQNgIgIAIgBDYCHCAIIAcgBiADIAJBHGoiBCABKALMBCgCDBEHACACKAJIIgZBCEcEQCAAIAIpAkw3AgQgAEEUaiACQdwAaigCADYCACAAQQxqIAJB1ABqKQIANwIAIAAgBjYCACAEEN47IAUgAigCLCACKAIwIAIoAigoAhARAQAMCAsgAkEQaiACQSRqKAIANgIAIAIgAikCHDcDCCACQcgAaiACQQhqEOcVIAUgAigCLCACQTBqIgQoAgAgAigCKCgCEBEBACAEIAJB0ABqKQIANwMAIAIgAikCSDcDKCACKAI4IQUgAi0APCEECyACQRBqIgcgAkEwaikDADcDACACIAIpAyg3AwggAUGgBWpBABDpHiABKAL8BCIGIAEoAvQERgRAIAFB9ARqQeiDzwAQmygLIAEoAvgEIAZBA3RqQoGAgICAwAA3AgAgASAGQQFqNgL8BCABKALABCEGIAEoAsQEIQggAkHYAGogBykDADcDACACQgs3A0ggAiACKQMINwNQIAIgAzYCyAEgAiAEOgBlIAJBADoAZCACIAU2AmAgAkEoaiAGIAJByABqIAgoAgwRAQAgAigCPCEDIAIoAjghBCACKQMwIQkgAikDKCEKIAItAEQiBUEERgRAIAAgAzYCFCAAIAQ2AhAgACAJNwMIIAAgCjcDAAwHCyACNQJAIQsgASABKQNQIAStfDcDUCABIAEpA1ggA618NwNYIAEgASkDQCAJfDcDQAJAAkAgBUEBaw4CBwABCyABKQMAUEUNAyABQgE3AwBBCAwFCyABIAEpA2AgC3w3A2AgASkDEFANAwwFCyADIAIoAlBBwPXOABD9LwALIAQgAigCUEHYg88AEP0vAAsgAkEANgJYIAJBATYCTCACQbiEzwA2AkggAkIENwJQIAJByABqQcCEzwAQ7ywACyABQgE3AxBBGAsgAWogCjcDAAsgAEEINgIACyACQdABaiQAC4cIAg5/A34jAEEwayIDJAACQCABKAJcIgYEQCABQdwAaiEKIAEoAkQhBSABKAJIIQRC////////////ACERAkACQAJAAkACQAJAAkACQANAIAIgBEYNASAFKQMAIhAgESAQIBFTGyERIAVBCGohBSAGIAJBAWoiAkcNAAsgAUEYaiARQgGGIBFCP4eFEKoSIAEoAlghBiABLQAsIQQgAyABKQMYNwMQIARBA3YgBEEHcUEAR2oiBEEJTw0BIAFBIGoiCyADQRBqIAQQoTYgAUEAOgAsIAFCADcDGCABKAIoIQ0gA0EIaiAGEPo3IAsgAygCCCADLQAMEI8pIAEoAlwhAiABKAJYIg5FDQcgDSEEQQAhBgNAIAIgASgCVCIHIAIgB0kbIgkEQCAGQQFqIAYgB2whAiABKAJEIAcgDGxqIQUgASgCSCEIQoCAgICAgICAgH8hECAJIQcDQCACIAhPDQYgBSkDACISIBAgECASUxshECAFQQhqIQUgAkEBaiECIAdBAWsiBw0ACyAGIA1qIgcgASgCKCICTw0GIAEoAiQgB2pBwAAgECARfUL/////D4N5p2siBzoAAEEAIQUDQCAFIAYgASgCVGxqIgIgASgCSCIITw0IIAEoAkQgAkEDdGopAwAhECABIAEtACwiCCAHaiICOgAsIAEgASkDGCAQIBF9Qv////8PgyISIAhBP3GthoQiEDcDGCACQf8BcUHAAE8EQCADIBA3AxAgCyADQRBqQQgQoTYgASACQUBqIgI6ACwgASASIAcgAmsiCK2IQgAgCEH/AXFBwABJGyIQNwMYCyAJIAVBAWoiBUcNAAsgCSABKAJUIgZJBEAgBiAJayEFA0AgASACIAdqIgI6ACwgAkH/AXFBwABPBEAgAyAQNwMQIAsgA0EQakEIEKE2IAFCADcDGCABIAJBQGoiAjoALEIAIRALIAVBAWsiBQ0ACwsgCiAKKAIAIAlrIgI2AgAgDEEIaiEMIARBAWohBCIGIA5HDQEMCQsLIAYgASgCWCIFTw0HIAEoAiQhCSABKAIoIQEDQCABIARNDQMgBCAJakEAOgAAIARBAWohBCAFQQFrIgUgBkcNAAsMBgsgBCAGQQFrIgAgACAESxsgBEHwns4AEMMhAAsgBEEIQeiOzgAQsDsACyAEIAFBiLbOABDDIQALIAIgCEHgns4AEMMhAAsgByACQYi2zgAQwyEACyACIAhB0J7OABDDIQALIAooAgAhAgsgAg0BCyAAQQg2AgAgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQbiezgA2AhAgA0E7NgIsIAMgCjYCKCADIANBKGo2AhhBACAKQciGzgAgA0EQakHAns4AEK8rAAv6DQIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJ4IQMgAUGAgICAeDYCeAJAAkAgA0GAgICAeEcEQCAEIAFBMGpByAD8CgAAIARB1ABqIAFBhAFqKAIANgIAIAQgAzYCSCAEIAEpAnw3AkwCQAJAIAEoAqABRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQoCAgIAQNwMgIAQoAjghByADQQA2AiggA0EgaiIGIAQoAjQgB0EDdBChNiADLQAcIQcgAyADKQMINwMwIAdBA3YgB0EHcUEAR2oiB0EJTwRAIAdBCEHojs4AELA7AAsgA0EQaiADQTBqIgkgBxChNiADQQA6ABwgA0IANwMIIAYgAygCFCADKAIYEKE2IANBADoAHCADQgA3AwggA0EANgIYIANBOGogBkEIaigCADYCACADIAYpAgA3AzAgA0EANgIoIANCgICAgBA3AyAgCEEEaiAJEOcVIAhBCDYCACADQQhqEMouIANBQGskACAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQggBSAEKQNYNwIMIAUgCDYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEENMsDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghCCACKAJUIQQgAigCUCEGIAIoAkwhByACIAM2AjwgAiAFNgI4IAIgCDYCNCACIAQ2AjAgAiAGNgIsIAIgBzYCKCABKAK4BCIIBEAgAkHIAGoiByAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAcgCCAGIAQgAkEcaiIDIAEoArwEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiCCACQTBqKQMANwMAIAIgAikDKDcDCCABQewEakEAEOkeIAEoAsgEIgYgASgCwARGBEAgAUHABGpB6IPPABCbKAsgASgCxAQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2AsgEIAEoArAEIQYgASgCtAQhByACQdgAaiAIKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogBygCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA5gCIAOtfDcDmAIgASABKQOgAiAErXw3A6ACIAEgASkDiAIgCnw3A4gCAkACQCAFQQFrDgIHAAELIAEpA6gBUEUNAyABQgE3A6gBQbABDAULIAEgASkDqAIgDHw3A6gCIAEpA7gBUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDuAFBwAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAvFDgIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJYIQMgAUGAgICAeDYCWAJAAkAgA0GAgICAeEcEQCAEIAFBEGpByAD8CgAAIARB1ABqIAFB5ABqKAIANgIAIAQgAzYCSCAEIAEpAlw3AkwCQAJAIAEoAqgBRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQQA2AiggA0KAgICAEDcDICADQSBqIQcCQAJAAkAgBCgCOCIJBEAgBCgCNCIGIAlBBHRqIQkDQCAGKAIARQ0CIAcgBkEEaigCACAGQQhqKAIAEKE2IAZBEGoiBiAJRw0ACwsgAy0AHCEGIAMgAykDCDcDMCAGQQN2IAZBB3FBAEdqIgZBCU8NASADQRBqIANBMGoiCSAGEKE2IANBADoAHCADQgA3AwggByADKAIUIAMoAhgQoTYgA0EAOgAcIANCADcDCCADQQA2AhggA0E4aiAHQQhqKAIANgIAIAMgBykCADcDMCADQQA2AiggA0KAgICAEDcDICAIQQRqIAkQ5xUgCEEINgIAIANBCGoQyi4gA0FAayQADAILQeSHzgBBIEGEiM4AEMskAAsgBkEIQeiOzgAQsDsACyAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQcgBSAEKQNYNwIMIAUgBzYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEEJ4sDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghByACKAJUIQQgAigCUCEGIAIoAkwhCCACIAM2AjwgAiAFNgI4IAIgBzYCNCACIAQ2AjAgAiAGNgIsIAIgCDYCKCABKAKwBCIHBEAgAkHIAGoiCCAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAggByAGIAQgAkEcaiIDIAEoArQEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiByACQTBqKQMANwMAIAIgAikDKDcDCCABQYgFakEAEOkeIAEoAuQEIgYgASgC3ARGBEAgAUHcBGpB6IPPABCbKAsgASgC4AQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2AuQEIAEoAqgEIQYgASgCrAQhCCACQdgAaiAHKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogCCgCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA4ACIAOtfDcDgAIgASABKQOIAiAErXw3A4gCIAEgASkD8AEgCnw3A/ABAkACQCAFQQFrDgIHAAELIAEpA7ABUEUNAyABQgE3A7ABQbgBDAULIAEgASkDkAIgDHw3A5ACIAEpA8ABUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDwAFByAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAv6DQIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJoIQMgAUGAgICAeDYCaAJAAkAgA0GAgICAeEcEQCAEIAFBIGpByAD8CgAAIARB1ABqIAFB9ABqKAIANgIAIAQgAzYCSCAEIAEpAmw3AkwCQAJAIAEoApABRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQoCAgIAQNwMgIAQoAjghByADQQA2AiggA0EgaiIGIAQoAjQgB0ECdBChNiADLQAcIQcgAyADKQMINwMwIAdBA3YgB0EHcUEAR2oiB0EJTwRAIAdBCEHojs4AELA7AAsgA0EQaiADQTBqIgkgBxChNiADQQA6ABwgA0IANwMIIAYgAygCFCADKAIYEKE2IANBADoAHCADQgA3AwggA0EANgIYIANBOGogBkEIaigCADYCACADIAYpAgA3AzAgA0EANgIoIANCgICAgBA3AyAgCEEEaiAJEOcVIAhBCDYCACADQQhqEMouIANBQGskACAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQggBSAEKQNYNwIMIAUgCDYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEENIsDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghCCACKAJUIQQgAigCUCEGIAIoAkwhByACIAM2AjwgAiAFNgI4IAIgCDYCNCACIAQ2AjAgAiAGNgIsIAIgBzYCKCABKAKABCIIBEAgAkHIAGoiByAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAcgCCAGIAQgAkEcaiIDIAEoAoQEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiCCACQTBqKQMANwMAIAIgAikDKDcDCCABQcAEakEAEOkeIAEoApwEIgYgASgClARGBEAgAUGUBGpB6IPPABCbKAsgASgCmAQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2ApwEIAEoAvgDIQYgASgC/AMhByACQdgAaiAIKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogBygCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA/gBIAOtfDcD+AEgASABKQOAAiAErXw3A4ACIAEgASkD6AEgCnw3A+gBAkACQCAFQQFrDgIHAAELIAEpA5gBUEUNAyABQgE3A5gBQaABDAULIAEgASkDiAIgDHw3A4gCIAEpA6gBUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDqAFBsAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAudDwIKfwN+IwBB0AFrIgIkACACQcgAaiEGIwBBgAFrIgUkACABKAJYIQQgAUGAgICAeDYCWAJAAkAgBEGAgICAeEcEQCAFIAFBEGpByAD8CgAAIAVB1ABqIAFB5ABqKAIANgIAIAUgBDYCSCAFIAEpAlw3AkwCQAJAIAEoAoABRQRAIAVB6ABqIQkjAEFAaiIDJAAgA0EIakGAAhDoICADQQA2AiggA0KAgICAEDcDIAJAIAUoAjgiCkUEQCADKQMIIQwgAy0AHCEEDAELIAUoAjQhCCADQRBqIQsgAykDCCEMIAMtABwhBANAIAMgBEEBaiIHOgAcIAMgCDEAACINIASthiAMhCIMNwMIIAdB/wFxQcAASUUEQCADIAw3AzAgCyADQTBqQQgQoTYgAyAEQT9rIgc6ABwgAyANQcAAIARrIgStiEIAIARB/wFxQcAASRsiDDcDCAsgByEEIAhBAWohCCAKQQFrIgoNAAsLIAMgDDcDMCAEQfgBcUEDdiAEQQdxQQBHaiIEQQlPBEAgBEEIQeiOzgAQsDsACyADQRBqIANBMGoiByAEEKE2IANBADoAHCADQgA3AwggA0EgaiIEIAMoAhQgAygCGBChNiADQQA6ABwgA0IANwMIIANBADYCGCADQThqIARBCGooAgA2AgAgAyAEKQIANwMwIANBADYCKCADQoCAgIAQNwMgIAlBBGogBxDnFSAJQQg2AgAgA0EIahDKLiADQUBrJAAgBUHgAGoiBCAFQfQAaikCADcDACAFIAUpAmw3A1ggBSgCaCIHQQhGDQEgBSgCfCEDIAYgBSkDWDcCDCAGIAM2AhwgBiAHNgIIIAZBATYCACAGQRRqIAQpAwA3AgAMAgsgBUHoAGpBMEEAQQFBARCgGCAFKAJsIQQgBSgCaEEBRg0DIAUoAnAiB0GYic4AQTD8CgAAIAZBMDYCFCAGIAc2AhAgBiAENgIMIAZBADYCCCAGQQE2AgAMAQsgBiAFKQNYNwIEIAZBDGogBCkDADcCACAGQQA6ABggBiAFKAI4NgIUIAZBADYCAAsgBRDRLAwCCyAGQQA2AgAgBkECOgAYDAELIAQgBSgCcEGch84AEP0vAAsgBUGAAWokAAJAIAIoAkhBAUYEQCACKQNQIQwgAikDWCENIAAgAikDYDcDECAAIA03AwggACAMNwMADAELAkACfwJAAkACQAJAIAIoAmAiBEH/AXFBAkYEQCACQcgAakEdQQBBAUEBEKAYIAIoAkwhBSACKAJIQQFGDQEgAigCUCIBQRVqQY2EzwApAAA3AAAgAUEQakGIhM8AKQAANwAAIAFBCGpBgITPACkAADcAACABQfiDzwApAAA3AAAgAEEdNgIMIAAgATYCCCAAIAU2AgQgAEEANgIADAcLIAIoAlwhByACKAJYIQYgAigCVCEFIAIoAlAhAyACKAJMIQggAiAENgI8IAIgBzYCOCACIAY2AjQgAiAFNgIwIAIgAzYCLCACIAg2AiggASgC6AMiBgRAIAJByABqIgggBUEAQQFBARCgGCACKAJMIQQgAigCSEEBRg0CIAJBNGohByACQQA2AiQgAiACKAJQNgIgIAIgBDYCHCAIIAYgAyAFIAJBHGoiBCABKALsAygCDBEHACACKAJIIgNBCEcEQCAAIAIpAkw3AgQgAEEUaiACQdwAaigCADYCACAAQQxqIAJB1ABqKQIANwIAIAAgAzYCACAEEN47IAcgAigCLCACKAIwIAIoAigoAhARAQAMCAsgAkEQaiACQSRqKAIANgIAIAIgAikCHDcDCCACQcgAaiACQQhqEOcVIAcgAigCLCACQTBqIgQoAgAgAigCKCgCEBEBACAEIAJB0ABqKQIANwMAIAIgAikCSDcDKCACKAI4IQcgAi0APCEECyACQRBqIgYgAkEwaikDADcDACACIAIpAyg3AwggAUGcBGpBABDpHiABKAL4AyIDIAEoAvADRgRAIAFB8ANqQeiDzwAQmygLIAEoAvQDIANBA3RqQoGAgICAwAA3AgAgASADQQFqNgL4AyABKALgAyEDIAEoAuQDIQggAkHYAGogBikDADcDACACQgs3A0ggAiACKQMINwNQIAIgBTYCyAEgAiAEOgBlIAJBADoAZCACIAc2AmAgAkEoaiADIAJByABqIAgoAgwRAQAgAigCPCEFIAIoAjghBCACKQMwIQwgAikDKCENIAItAEQiB0EERgRAIAAgBTYCFCAAIAQ2AhAgACAMNwMIIAAgDTcDAAwHCyACNQJAIQ4gASABKQPYASAErXw3A9gBIAEgASkD4AEgBa18NwPgASABIAEpA8gBIAx8NwPIAQJAAkAgB0EBaw4CBwABCyABKQOIAVBFDQMgAUIBNwOIAUGQAQwFCyABIAEpA+gBIA58NwPoASABKQOYAVANAwwFCyAFIAIoAlBBwPXOABD9LwALIAQgAigCUEHYg88AEP0vAAsgAkEANgJYIAJBATYCTCACQbiEzwA2AkggAkIENwJQIAJByABqQcCEzwAQ7ywACyABQgE3A5gBQaABCyABaiANNwMACyAAQQg2AgALIAJB0AFqJAALwRkCNX8BfiMAQSBrIhAkAAJAIAJBBk0EQCAAQbwQaiEBIAAoAtQBQQdPBEAgASACEIgfQQEhBAwCCyABIAIgACgCzAEQqBhBASEEDAELIABBADYCiAYgACAAKALsBTYC8AUgACAAKALkBTYC6AUgACAAKALQECIGNgKEEiAAIAAoAvgBNgKIEiABIAAoAtwQayIDIAAoAvQQIgVBgANqSwRAIAAgA0HAASADIAVrQYADayIDIANBwAFPG2s2AvQQCwJ/QQEgACgA6BAgACgA5BBJDQAaQQAgACgCjBIiA0UNABpBA0ECIAMoAmwbCyEFIABB2BBqIRkgAEHkBWohGiAGQegjaiEGIAAoAtQQQegjaiEDA0AgBEEMRwRAIAMgBGogBCAGaigCADYCACAEQQRqIQQMAQsLAn8gACgCwBAgACgCyBBJBEBBVyEEIAAoAtgCDQIgAEG8EGogGSAaIAMgACgCvAIgASACEMIJDAELIAAoAowCQQFGBEAgEEEUakEANgIAIBBCADcCDEFXIQQgACgC2AINAiAQIAAoArQQNgIIIBAgACgCuBA2AhggEEEIaiEKIwBBIGsiFSQAIAJBFHYgAkH//z9xQQBHaiEuIABBkAZqIgdBsAJqIRsgB0GkAmohLyAHQSRqIRMgASACaiEwQQEgAEGMAmoiESgCFHQhHANAAkAgIyAuRg0AIAooAgwiKiAKKAIQTw0AAn8gMCABICNBFHQiA2oiCUGAgEBrIAIgA2tBgIDAAEkbIh0gBygABCIWayIIQYCAgIB6TQRAIAcoAhwMAQsgByAJQQJrIgMgHGs2AgQgByAHKAIUQQFqNgIUIAcgAyAWIBxqayIEIAcoAghqNgIIIAdBAiAHKAIQIgMgBGsgAyAEQQJqIgVJGzYCECAHQQIgBygCDCIDIARrIAMgBUkbNgIMQQEgESgCBHQhCCAHKAIYIQMDQCAIBEAgAyADKAIAIgUgBGsiBkEAIAUgBk8bNgIAIAhBAWshCCADQQhqIQMMAQsLIAdBADYCHCAdIAcoAgQiFmshCEEACyEDAkAgAyAcaiAITwRAIAcoABAhAyAHKAAMIQUMAQsgBygCECIDIAggHGsiBEkEQCAHIAQ2AhAgBCEDCyADIAcoAgwiBUsEQCAHIAM2AgwgAyEFCyAHQQA2AhwLIBEoAgghBCARKAIEIQYgESgCDCEXQQAhHiAFIgsgA00iMUUEQCAHKAIIIR4gAyELCyAdIAlrIiQhAyAXICRNBEAgBSAWaiElIAUgHmohKyALIB5qISYgCSAkaiIfQQhrISwgFUEQaiAREPwnQQAgF2shMiAJIBdqIRRBfyAGIARrdEF/cyEzQQEgBHRBA3QhNANAIBQgLEkEQCAVQQA2AgwgFCAyaiEGIBVBEGogFCAsIBRrIBMgFUEMahD8CiEnIBUoAgwiNSEIIBMhBCAbIQMDQCAIBEAgBiAEKAIAaiIMIBcQ0z0hOCADQQxrIAw2AgAgA0EEayA4QiCIPgIAIANBCGsgOKcgM3EiDDYCACADIAcoAhggDCARKAAIdEEDdGo2AgAgCEEBayEIIARBBGohBCADQRBqIQMMAQUgFCAnaiE2QQAhIANAAkACQCAgIDVHBH8gLyAgQQR0aiIDKAIAIg4gFmshKCADKAIEISEgAygCCCEpIAkgDksNASADKAIMIgMgNGohN0EAIRhBACEGQQAhDEEAIRIDQCADIDdJBEACQCADQQRqKAIAIClHDQAgAygCACIEIAtNDQACQCAxRQRAIA4gHiAWIAQgBUkiCBsgBGoiDyAOICsgHyAIGyIiIA9raiIEIB8gBCAdSRsQgBQiBCAPaiAiRgRAIAQgDmogJSAfEIAUIARqIQQLIAQgF0kNAiAOIAkgDyAmICUgCBsiIhD8JiEIICIgJkYgDyAIayAiR3INASAOIAhrIAkgKyAmEPwmIAhqIQgMAQsgDiAEIBZqIgggHxCAFCIEIBdJDQEgDiAJIAggJRD8JiEICyAEIAhqIg8gGE0NACAPIRggAyEGIAghDCAEIRILIANBCGohAwwBCwsgBkUNASAKKAIMIgMgCigCEEYEQEG6fyENDAoLIAogA0EBajYCDCAKKAIAIANBDGxqIgMgDCASajYCCCADIA4gDGsgCWs2AgQgAyAoIAYoAgBrNgIAIAcoAhggISARKAAIIgN0QQN0aiAHKAIgICFqIgQtAAAiBkEDdGogKK0gKa1CIIaENwIAIAQgBkEBakF/IAN0QX9zcToAACAOIBJqIgkgNk0NAiAJICdrBSAUCyAnaiEUDAYLIAcoAhggISARKAAIIgN0QQN0aiAHKAIgICFqIgQtAAAiBkEDdGogKK0gKa1CIIaENwIAIAQgBkEBakF/IAN0QX9zcToAAAsgIEEBaiEgDAALAAsACwALCyAdIAlrIQMLIANBiH9LBH8gAwUCfyAKKAIMICpLBEAgCigCACAqQQxsaiIEIAQoAgQgLWo2AgQgAwwBCyAkIC1qCyEtICNBAWohIwwCCyENCwsgFUEgaiQAIA0iBEGJf08NAiAKIBkgGiAAKALUEEHoI2ogACgCvAIgASACEMIJDAELIAAoAtgCBEBBln8hBAJAAkAgACgCtB0gACgCvB0gACgCwB0gASACQQBBACAAKALkAUEBIAAoArwBdCAAKAK4HREzACIDQQFrIAAoAsAdIgtPDQAgACgCvB0gA0EEdGoiBkEQaygCACAGQQhrKAIAcgRAIAMgC0YNASAGQgA3AgAgBkEIakIANwIAIANBAWohAwsgA0GIf00NASADIQQLIAAoAtQCRQ0DIABBADYCrBIgGSAaIAAoAtQQQegjaiABIAIgBUEobCAAKALUASIDQQJ0akGw9NAAaiIEIAQgBUEMbCADQQNrIgNBAnRqQdD10ABqIAAoArwCQQFHGyADQQJLGygCABEJAAwCCyAQQRBqQQA2AgAgEEIANwMIIAAoArwdIgxBCGohBCADIQVBACEGA0AgBQRAIAVBAWshBSAEKAIAIA1qIQ0gBEEEaygCACAGaiEGIARBEGohBAwBCwtBlX8hBCAGIA1qIAJLDQIgASEEIAAoAuACIRgjAEEQayIFJAAgEEEIaiIIKAIAIQsCfyAAKAKUEyIBBEAgASgCBAwBC0EAIAAoApgTRQ0AGiAAKAKcEwshByACIARqIRsgBUEIaiAAKALQECIBQfAjaigCADYCACAFIAEpAugjNwMAIAsgAyADIAtJGyECIABB5AVqIQkgDCALQQR0aiEDIBhBAkchDiALIQECQAJAAkACQANAAkACQCABIAJHBEAgA0EIaigCACISDQEgAygCAA0BIAEhAgsgAiALRiAYQQJHcg0EIAJBAWsiASALQQJqIgNJDQEgBSAMIAJBBHRqIgNBMGsoAgA2AgggBSADQSBrKAIANgIEDAMLIANBBGooAgAhEwJAIA5FBEAgAygCAEEDaiENDAELIAUCfyADKAIAIQYCfyATRSIPIg1FBEBBASAGIAUoAgBGDQEaC0ECIA1rIAUoAgQgBkYNARogDUEDcyAFKAIIIAZGDQEaIAZBA2oiCiANRQ0AGkEDIAogBiAFKAIAQQFrRhsLCyINIA8Q5RwLIAAoArQCBEAgCCAIKAIIIBIgE2pqIg82AghBlX8hBiANQQEgACgCvAF0IgogByAPaiAKIA9JG0EDaksNBiASQQNBA0EEIAAoAswBQQNGGyAAKALYAhtJDQYLIAAoAoAGIAEgCCgCAGtNDQQgCSATIAQgGyANIBIQhRIgA0EQaiEDIAFBAWohASAEIBJqIBNqIQQMAQsLIAIgA0YEQCAFIAUoAgA2AgggBSAMIAJBBHRqQSBrKAIANgIEDAELIAUgBSkDADcCBAsgBSAMIAFBBHRqKAIANgIACyAAKALUECIBIAUpAwA3AugjIAFB8CNqIAVBCGooAgA2AgAgDCACQQR0aiIDKAIEIgEEfyABBEAgACgC8AUgBCAB/AoAAAsgACAAKALwBSABajYC8AUgCCADQQRqKAIAIgEgCCgCCGo2AgggASAEagUgBAsgG0cNACAIIAJBAWo2AgBBACEGDAELQZV/IQYLIAVBEGokACAGIgRBiH9LDQJBACEEIABBADYCrBIMAgsgAEEANgKsEiAZIBogAyABIAIgBUEobCAAKALUASIDQQJ0akGw9NAAaiIEIAQgBUEMbCADQQNrIgNBAnRqQdD10ABqIAAoArwCQQFHGyADQQJLGygCABEJAAsiAwRAIAAoAvAFIAEgAmogA2sgA/wKAAALIAAgACgC8AUgA2o2AvAFQQAhBAsgEEEgaiQAIAQL5ggCBn8BfiMAQYABayIEJAAgAC0AxAMhBQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAA1AuwDIgogACkDyANSBEAgBUEBcUUNByABRQ0EIAEoAiBFDQIgASgCNEUNAyABQSRqIQUgAUE4aiEIIAAoArgERQ0GIABBzARqIQYgAEG8BGohByAALQCUBQ0BDAULIAVBAXFFDQYgBEEANgJIIARCgICAgBA3AkAgBEEANgJYIARCgICAgBA3AlAgAEH4AmpBASAEQUBrIARB0ABqIAoQlRQMBgsgACgCgAVBCGogByAFEIkNRQRAIAAoAoAFQQhqIAYgCBCJDUUNBAsgAEEAOgCUBQwDC0HIgM8AELI7AAtB2IDPABCyOwALIABBADoAxAMMAgsgAC0AlQVFDQAgACgCgAVBCGogBSAHEIkNRQRAIAAoAoAFQQhqIAggBhCJDUUNAQsgAEEAOgCVBQsCQCAFKAIAIgUEQCAEQeAAaiABQTBqIAEoAiggASgCLCAFKAIAEQUADAELIARBADYCYAsgAEG4BGoCQCAIKAIAIggEQCAEQfAAaiABQcQAaiABKAI8IAEoAkAgCCgCABEFAAwBCyAEQQA2AnALIABB+AJqIQggBEEwaiIGIAQpAnA3AwAgBEEoaiIHIARB6ABqKQIANwMAIARBOGoiCSAEQfgAaikCADcDACAEIAQpAmA3AyAQ8SYgAEEBNgK4BCAAIAQpAyA3ArwEIABBxARqIAcpAwA3AgAgAEHMBGogBikDADcCACAAQdQEaiAJKQMANwIAIAAQ5x9FBEAgBEEYaiABEO4nIAQoAhgiCUUNAiAEQdAAaiAEKAIcIgVBAEEBQQEQoBggBCgCVCEGIAQoAlBBAUYNAyAEKAJYIQcgBQRAIAcgCSAF/AoAAAsgBCAFNgJIIAQgBzYCRCAEIAY2AkAgBEEQaiABEO8nIAQoAhAiB0UNBCAEQdAAaiAEKAIUIgFBAEEBQQEQoBggBCgCVCEFIAQoAlBBAUYNBSAEKAJYIQYgAQRAIAYgByAB/AoAAAsgBCABNgJYIAQgBjYCVCAEIAU2AlAgCEEAIARBQGsgBEHQAGogACkDyAMQlRQMAQsgACgChAUiBSgCPCEGIAUoAjghBSAEQQhqIAEQ7icgBCgCCCIHRQ0FIARBQGsiCSAAIAUgBiAHIAQoAgwQnA0gACgChAUiBSgCPCEGIAUoAjghBSAEIAEQ7ycgBCgCACIBRQ0GIARB0ABqIgcgACAFIAYgASAEKAIEEJgMIAhBACAJIAcgACkDyAMQlRQLIABB+AJqIABB0ANqIABB3ANqEJYTIAAoAvgDQYCAgIB4RwRAIABB8ANqIgEgADUC7AMQpicgASACIAMQ1xkLIARBgAFqJAAPC0HogM8AELI7AAsgBiAEKAJYQcD1zgAQ/S8AC0H4gM8AELI7AAsgBSAEKAJYQcD1zgAQ/S8AC0GIgc8AELI7AAtBmIHPABCyOwAL+QcCDn8DfiMAQTBrIgMkAAJAIAEoAlwiBgRAIAFB3ABqIQogASgCRCEFIAEoAkghBEL///////////8AIRECQAJAAkACQAJAAkACQAJAA0AgAiAERg0BIAUpAwAiECARIBAgEVMbIREgBUEIaiEFIAYgAkEBaiICRw0ACyABQRhqIBFCAYYgEUI/h4UQqhIgASgCWCEGIAEtACwhBCADIAEpAxg3AxAgBEEDdiAEQQdxQQBHaiIEQQlPDQEgAUEgaiILIANBEGogBBChNiABQQA6ACwgAUIANwMYIAEoAighDSADQQhqIAYQ+jcgCyADKAIIIAMtAAwQjykgASgCXCECIAEoAlgiDkUNByANIQRBACEGA0AgAiABKAJUIgcgAiAHSRsiCQRAIAZBAWogBiAHbCECIAEoAkQgByAMbGohBSABKAJIIQhCgICAgICAgICAfyEQIAkhBwNAIAIgCE8NBiAFKQMAIhIgECAQIBJTGyEQIAVBCGohBSACQQFqIQIgB0EBayIHDQALIAYgDWoiByABKAIoIgJPDQYgASgCJCAHakHAACAQIBF9eadrIgc6AABBACEFA0AgBSAGIAEoAlRsaiICIAEoAkgiCE8NCCABKAJEIAJBA3RqKQMAIRAgASABLQAsIgggB2oiAjoALCABIAEpAxggECARfSISIAhBP3GthoQiEDcDGCACQf8BcUHAAE8EQCADIBA3AxAgCyADQRBqQQgQoTYgASACQUBqIgI6ACwgASASIAcgAmsiCK2IQgAgCEH/AXFBwABJGyIQNwMYCyAJIAVBAWoiBUcNAAsgCSABKAJUIgZJBEAgBiAJayEFA0AgASACIAdqIgI6ACwgAkH/AXFBwABPBEAgAyAQNwMQIAsgA0EQakEIEKE2IAFCADcDGCABIAJBQGoiAjoALEIAIRALIAVBAWsiBQ0ACwsgCiAKKAIAIAlrIgI2AgAgDEEIaiEMIARBAWohBCIGIA5HDQEMCQsLIAYgASgCWCIFTw0HIAEoAiQhCSABKAIoIQEDQCABIARNDQMgBCAJakEAOgAAIARBAWohBCAFQQFrIgUgBkcNAAsMBgsgBCAGQQFrIgAgACAESxsgBEHwns4AEMMhAAsgBEEIQeiOzgAQsDsACyAEIAFBiLbOABDDIQALIAIgCEHgns4AEMMhAAsgByACQYi2zgAQwyEACyACIAhB0J7OABDDIQALIAooAgAhAgsgAg0BCyAAQQg2AgAgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQbiezgA2AhAgA0E7NgIsIAMgCjYCKCADIANBKGo2AhhBACAKQciGzgAgA0EQakHAns4AEK8rAAv3BwIYfwJ+IwBBIGsiBSQAIAEoAhgiCCABKAIQIgZPBEAgCEF/QXlBfSABLwE0IgNBAiADGyIDQQdLGyADQQNNGyADaiIJTwRAIAggBiAJaiIHTwRAIAEoAlAiC0GGAmsiCkEAIAogC00bIAZPBEAgASgCICIEQQFrIQ0gAS8BDCEKIAEoAiQhECAGIARrQYYCaiIEQQAgBCAGTRshDiABLwEKIRQgAS8BNiIEIARBAnYgAyABLwEISRshDCABKAIUIgQgBmoiD0ECaiEVIARBAmohFiAEIAlqIREgBCAHaiESIAQgC2pBAWshFyABKAIoIQsgASgCLCEHIAggBmsiE0ECa0H/AUshGCABLAAEQQVIIRkCQANAAkAgBiACQf//A3FNDQACQAJAAkACQAJAAkACQCADQQhPBEAgEikAACEbA0AgGyARIAJB//8DcSIBaikAAFEEQCABIARqKQAAIA8pAABRDQMLIAxBAWsiDEH//wNxRQ0JIAcgASANcSIBSwRAIAsgAUEBdGovAQAiAiAOQf//A3FLDQEMCgsLIAEgB0GA4vwAEMMhAAsgDykAACEbA0AgGyAEIAJB//8DcSIJaikAACIcUQ0BIBsgHIV6p0EDdiIBIANLDQIgDEEBayIMQf//A3FFDQggByAJIA1xIgFLBEAgCyABQQF0ai8BACICIA5B//8DcUsNAQwJCwsgASAHQZDi/AAQwyEACyATQQFNDQEgGEUNAiAWIAJB//8DcWohGkEAIQEDQAJAIAEgFWotAAAgASAaai0AAEcEQCABIQkMAQtBgAIhCSABQQFqIgFBgAJHDQELCyAJQQJqIQELIAEgD2ogF0sNAgJAIAEgA0sEQCABIBBNDQEgAiEKIBAhAwwHCyAZDQYMBQsgASAUTwRAIAIhCiABIQMMBgtBf0F5QX0gAUEHSxsgAUEDTRsgAWoiCiAGaiIDIAhLDQMgBCAKaiERIAMgBGohEiABIQMgAiEKDAQLQQIgE0Gg4vwAEK87AAtB2O/8ABCyOwALIAVBADYCGCAFQQE2AgwgBUG84vwANgIIIAVCBDcCECAFQQhqQcTi/AAQ7ywACyADIAhB1OL8ABCvOwALIAxBAWsiDEH//wNxRQ0AIAIgDXFB//8DcSIBIAdPDQIgCyABQQF0ai8BACICIA5B//8DcUsNAQsLIAAgCjsBBCAAIAM2AgAgBUEgaiQADwsgASAHQeTi/AAQwyEACyAFQQA2AhggBUEBNgIMIAVB6OH8ADYCCCAFQgQ3AhAgBUEIakHw4fwAEO8sAAsgByAIQcjh/AAQrzsACyAJIAhBuOH8ABCvOwALIAYgCEGo4fwAEK87AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGooAgghBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahCzDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxCzDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDbPCEGIARBGGogARCSNhDuJSAGQQV0IgMhAgJAAkACQAJAAkACQAJAIANBIHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEKENIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEKENIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ4hkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQzh0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBAnQiAyECAkACQAJAAkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQvBEgBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQvBEgBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDlGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDSHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGooAgghBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahC0DSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxC0DSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQJ0IgMhAgJAAkACQAJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEL0RIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEL0RIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ5RkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQ0h0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBBXQiAyECAkACQAJAAkACQAJAAkAgA0EgcSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQog0gBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQog0gBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDiGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDOHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGoQ2zwhBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahCjDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxCjDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQJ0IgMhAgJAAkACQAJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEL4RIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEL4RIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ5RkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQ0h0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENk8IQYgBEEYaiABEJI2EO4lIAZBBXQiAyECAkACQAJAAkACQAJAAkAgA0EgcSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQpA0gBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQpA0gBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDiGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDOHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGoQ2TwhBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahClDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxClDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQV0IgMhAgJAAkACQAJAAkACQAJAIANBIHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEKYNIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEKYNIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ4hkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQzh0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBAnQiAyECAkACQAJAAkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQvxEgBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQvxEgBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDlGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDSHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKAFiIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQcAFRw0ACyABQQFrDgQFBAMCAQsgAUEFQdjD0AAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgBZHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0HABU8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQcAFQZjE0AAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0HABUkEQCACKAIUIgFBwAVPBEAgAUHABUH4w9AAEMMhAAsgAigCGCIEQcAFSQ0BIARBwAVBiMTQABDDIQALIANBwAVB6MPQABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKACCIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQYACRw0ACyABQQFrDgQFBAMCAQsgAUEFQdjD0AAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgAhHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0GAAk8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQYACQZjE0AAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0GAAkkEQCACKAIUIgFBgAJPBEAgAUGAAkH4w9AAEMMhAAsgAigCGCIEQYACSQ0BIARBgAJBiMTQABDDIQALIANBgAJB6MPQABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKAESIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQaAERw0ACyABQQFrDgQFBAMCAQsgAUEFQcSX0gAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgBFHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0GgBE8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQaAEQYSY0gAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0GgBEkEQCACKAIUIgFBoARPBEAgAUGgBEHkl9IAEMMhAAsgAigCGCIEQaAESQ0BIARBoARB9JfSABDDIQALIANBoARB1JfSABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQufCAIFfwN+IwBBsAFrIgMkACADIAI2AhQgAUEMahDYPCEGIANBGGogARCSNhDuJSAGQQN0IgIhBAJAAkACQAJAAkACQAJAIAJBOHEiBQRAIAIgBWtBQGsiBCACSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAMgBTYCOCADIAQ2AjQgA0HAADYCMCACBEAgBUEAIAL8CwALIAMgBjYCQCADIAI2AjwgAyABNgJQIAMgBjYCSCADIAU2AkQgAyADQRRqNgJMIAMoAhhFDQMgAygCLCADKAIoRg0EIANB4ABqIANBGGoQyDQgA0GAAWohAQNAAkAgAykDiAEiCVBFBEAgAykDkAEhCAwBCwNAAn4CQCADKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A3AgCKdBAXFFDQAgAyADKQN4NwOgAQwBCyADKAKAAUUNASADQZgBaiABELYqIAMpA5gBIQgLIAhCAFINAgsgA0IDNwNwCyADKQNgIghCAlENCSADQgA3A2AgAykDaAwBCyADKQOgAQshCSAIp0EBcUUNByADIAMpA5ABQkB9Igg3A5ABIAMgCTcDiAEgCVANAAsLIAMgCUIBIAl6IgqGhTcDiAEgA0GYAWogA0HEAGogCqcgCKdqEMwPIAMoApgBIgRBk4CAgHhGDQALIAAgAykCnAE3AgggAEEQaiADQaQBaikCADcCAAwGC0HAACAEEKM9AAtB3Iv/AEEpIANB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQIDQCADQeAAaiADQcQAaiACEMwPIAMoAmAiBEGTgICAeEcNAiAGIAJBAWoiAkcNAAsLIANB4ABqIgIQlykgA0E4aiIBKAIAIQUgAygCPCEEIAEgA0HoAGoiBikCADcDACADKQMwIQggAyADKQJgNwMwIANBADYCQCADIAg3AmwgA0EANgJoIAMgBDYCZCADIAU2AmAgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQfAAaiIHKAIANgIAIAMgBDYCoAEgAyAFNgKcASADIAE2ApgBIANB1ABqIgEgA0GYAWoQ5BkgByADQShqKQIANwMAIAYgA0EgaikCADcDACADIAMpAhg3A2AgACABIAIQ1h0gA0EwahDPLwwCCyAAIAMpAmQ3AgggAEEQaiADQewAaikCADcCAAsgAEEpOgAAIAAgBDYCBCADQTBqEM8vIAMoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahD7HgsgA0GwAWokAA8LQQRBHBCjPQALnwgCBX8DfiMAQbABayIDJAAgAyACNgIUIAFBDGoQ2DwhBiADQRhqIAEQkjYQ7iUgBkEDdCICIQQCQAJAAkACQAJAAkACQCACQThxIgUEQCACIAVrQUBrIgQgAkkNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyADIAU2AjggAyAENgI0IANBwAA2AjAgAgRAIAVBACAC/AsACyADIAY2AkAgAyACNgI8IAMgATYCUCADIAY2AkggAyAFNgJEIAMgA0EUajYCTCADKAIYRQ0DIAMoAiwgAygCKEYNBCADQeAAaiADQRhqEMg0IANBgAFqIQEDQAJAIAMpA4gBIglQRQRAIAMpA5ABIQgMAQsDQAJ+AkAgAykDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAMgCFCtQgGGNwNwIAinQQFxRQ0AIAMgAykDeDcDoAEMAQsgAygCgAFFDQEgA0GYAWogARC2KiADKQOYASEICyAIQgBSDQILIANCAzcDcAsgAykDYCIIQgJRDQkgA0IANwNgIAMpA2gMAQsgAykDoAELIQkgCKdBAXFFDQcgAyADKQOQAUJAfSIINwOQASADIAk3A4gBIAlQDQALCyADIAlCASAJeiIKhoU3A4gBIANBmAFqIANBxABqIAqnIAinahDNDyADKAKYASIEQZOAgIB4Rg0ACyAAIAMpApwBNwIIIABBEGogA0GkAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSADQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACECA0AgA0HgAGogA0HEAGogAhDNDyADKAJgIgRBk4CAgHhHDQIgBiACQQFqIgJHDQALCyADQeAAaiICEJcpIANBOGoiASgCACEFIAMoAjwhBCABIANB6ABqIgYpAgA3AwAgAykDMCEIIAMgAykCYDcDMCADQQA2AkAgAyAINwJsIANBADYCaCADIAQ2AmQgAyAFNgJgIANBCGogAhDXOyADKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HwAGoiBygCADYCACADIAQ2AqABIAMgBTYCnAEgAyABNgKYASADQdQAaiIBIANBmAFqEOQZIAcgA0EoaikCADcDACAGIANBIGopAgA3AwAgAyADKQIYNwNgIAAgASACENYdIANBMGoQzy8MAgsgACADKQJkNwIIIABBEGogA0HsAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EwahDPLyADKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQ+x4LIANBsAFqJAAPC0EEQRwQoz0AC58IAgV/A34jAEGwAWsiAyQAIAMgAjYCFCABQQxqENg8IQYgA0EYaiABEJI2EO4lIAZBA3QiAiEEAkACQAJAAkACQAJAAkAgAkE4cSIFBEAgAiAFa0FAayIEIAJJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAyAFNgI4IAMgBDYCNCADQcAANgIwIAIEQCAFQQAgAvwLAAsgAyAGNgJAIAMgAjYCPCADIAE2AlAgAyAGNgJIIAMgBTYCRCADIANBFGo2AkwgAygCGEUNAyADKAIsIAMoAihGDQQgA0HgAGogA0EYahDINCADQYABaiEBA0ACQCADKQOIASIJUEUEQCADKQOQASEIDAELA0ACfgJAIAMpA3AiCEIDUgRAAkACQAJAIAhCAlENACADIAhQrUIBhjcDcCAIp0EBcUUNACADIAMpA3g3A6ABDAELIAMoAoABRQ0BIANBmAFqIAEQtiogAykDmAEhCAsgCEIAUg0CCyADQgM3A3ALIAMpA2AiCEICUQ0JIANCADcDYCADKQNoDAELIAMpA6ABCyEJIAinQQFxRQ0HIAMgAykDkAFCQH0iCDcDkAEgAyAJNwOIASAJUA0ACwsgAyAJQgEgCXoiCoaFNwOIASADQZgBaiADQcQAaiAKpyAIp2oQzg8gAygCmAEiBEGTgICAeEYNAAsgACADKQKcATcCCCAAQRBqIANBpAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAgNAIANB4ABqIANBxABqIAIQzg8gAygCYCIEQZOAgIB4Rw0CIAYgAkEBaiICRw0ACwsgA0HgAGoiAhCXKSADQThqIgEoAgAhBSADKAI8IQQgASADQegAaiIGKQIANwMAIAMpAzAhCCADIAMpAmA3AzAgA0EANgJAIAMgCDcCbCADQQA2AmggAyAENgJkIAMgBTYCYCADQQhqIAIQ1zsgAygCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASADKQJgNwIIIAFBEGogBikCADcCACABQRhqIANB8ABqIgcoAgA2AgAgAyAENgKgASADIAU2ApwBIAMgATYCmAEgA0HUAGoiASADQZgBahDkGSAHIANBKGopAgA3AwAgBiADQSBqKQIANwMAIAMgAykCGDcDYCAAIAEgAhDWHSADQTBqEM8vDAILIAAgAykCZDcCCCAAQRBqIANB7ABqKQIANwIACyAAQSk6AAAgACAENgIEIANBMGoQzy8gAygCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQRhqEPseCyADQbABaiQADwtBBEEcEKM9AAufCAIFfwN+IwBBsAFrIgMkACADIAI2AhQgAUEMahDYPCEGIANBGGogARCSNhDuJSAGQQN0IgIhBAJAAkACQAJAAkACQAJAIAJBOHEiBQRAIAIgBWtBQGsiBCACSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAMgBTYCOCADIAQ2AjQgA0HAADYCMCACBEAgBUEAIAL8CwALIAMgBjYCQCADIAI2AjwgAyABNgJQIAMgBjYCSCADIAU2AkQgAyADQRRqNgJMIAMoAhhFDQMgAygCLCADKAIoRg0EIANB4ABqIANBGGoQyDQgA0GAAWohAQNAAkAgAykDiAEiCVBFBEAgAykDkAEhCAwBCwNAAn4CQCADKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A3AgCKdBAXFFDQAgAyADKQN4NwOgAQwBCyADKAKAAUUNASADQZgBaiABELYqIAMpA5gBIQgLIAhCAFINAgsgA0IDNwNwCyADKQNgIghCAlENCSADQgA3A2AgAykDaAwBCyADKQOgAQshCSAIp0EBcUUNByADIAMpA5ABQkB9Igg3A5ABIAMgCTcDiAEgCVANAAsLIAMgCUIBIAl6IgqGhTcDiAEgA0GYAWogA0HEAGogCqcgCKdqEM8PIAMoApgBIgRBk4CAgHhGDQALIAAgAykCnAE3AgggAEEQaiADQaQBaikCADcCAAwGC0HAACAEEKM9AAtB3Iv/AEEpIANB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQIDQCADQeAAaiADQcQAaiACEM8PIAMoAmAiBEGTgICAeEcNAiAGIAJBAWoiAkcNAAsLIANB4ABqIgIQlykgA0E4aiIBKAIAIQUgAygCPCEEIAEgA0HoAGoiBikCADcDACADKQMwIQggAyADKQJgNwMwIANBADYCQCADIAg3AmwgA0EANgJoIAMgBDYCZCADIAU2AmAgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQfAAaiIHKAIANgIAIAMgBDYCoAEgAyAFNgKcASADIAE2ApgBIANB1ABqIgEgA0GYAWoQ5BkgByADQShqKQIANwMAIAYgA0EgaikCADcDACADIAMpAhg3A2AgACABIAIQ1h0gA0EwahDPLwwCCyAAIAMpAmQ3AgggAEEQaiADQewAaikCADcCAAsgAEEpOgAAIAAgBDYCBCADQTBqEM8vIAMoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahD7HgsgA0GwAWokAA8LQQRBHBCjPQALqXMCKH8GfiMAQfAAayIUJAAgAUEwaiEkIAFB/ABqISsgAUHMAGohFyABQcgAaiEYAkADQAJAAkACQAJAAkACQAJAAkBBgICAgHggGCgCACIFIAVBgICAgHhNG0H/////B3FBAWsOBAIDAQQACyAUQTBqIBggARD2AwJAIBQtADBBBEYNACAUKQMwIixC/wGDQgRRDQAgACAsNwIADAkLIBRBMGoiBSAYQTz8CgAAIAFBADoAgAEgAUEGOgB0IAFBADoAcCABQQA2AmwgAUGAgICAeDYCYCABQYCAgIB4NgJUIAFBgICAgHg2AkggFEEEaiIGIAUQkCsgGBCzGyABQYGAgIB4NgJIIBcgBkEs/AoAAAwHCyAXKQIAISwgF0KB0AA3AgAgGBCzGyAXQYGAgIB4NgIAIBhBhICAgHg2AgAgACAsNwIADAcLAkAgAwRAIBRBMGohJSMAQRBrIiIkACAiQQhqISMgAUEYaiEaIwBBEGsiGSQAIBlBBGogARDbFgJAAkAgGSgCBEUEQANAIBopAwghMCAaKQMAITEgGUEEaiEbIBkoAgghJyAZKAIMIighBSMAQTBrIhYkACAaKAIQIhFBADYCGCARIAM2AhAgESACNgIMIBEgBTYCBCARICc2AgAgKEVBAnQhBUF+IQYCQCARRQ0AIBEoAiBFDQAgESgCJEUNACARKAIcRQ0AAn9CgICIgMCggQMgBa1CA4aIp0EAIAVBB0kbISkjAEEwayIKJABBfiEFAkACQCARKAIMIglFDQAgESgCACIGQQEgESgCBCIIG0UNACARKAIcIgQtAAAiBUEMRgRAIARBDToAAEENIQULIAQgBjYCOCAEICk6AAQgBCAINgJwIARBADYCUCAEIAk2AkggBCAGIAhqNgI8IAQgESgCECIGNgJ0IAQgBjYCTCAEQQhqISogBEGE7ABqISYgBEGE5wBqIRwgBEGkAWohHSAEQfQqaiEeIARBxNQAaiEhIARByABqIQ4gBEHBAGohEAJAAkACQANAAkAgBSEHQRIhBUF8IQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgB0H/AXFBAWsOHiEgHw8ODQwLAiQcGwoaIwklGRgXCAcWFQABFBMSERALAkAgBCgCJCIFIAQoAhgiCEkEQEETIAUgBUETTRshDCAEKAI4IQkgBCkDMCEtIAQtAEAhBiAEKAI8IQsDQAJAIAZB/wFxQQJLBEAgLSEsIAYhBwwBCyAJIAtGBEBBACEGQRkhBwwoCyAEIAlBAWoiDTYCOCAEIAZBCHIiBzoAQCAEIAkxAAAgBq2GIC2EIiw3AzAgDSEJCyAFIAxGDQIgBCAHQQNrIgY6AEAgBCAsQgOIIi03AzAgBCAFQQFqIgc2AiQgHCAFQdiS/ABqLQAAQQF0aiAsp0EHcTsBACAHIgUgCEcNAAsgCCEFCyAFQRJLDQYDQCAcIAVB2JL8AGotAABBAXRqQQA7AQAgBUEBaiIFQRNHDQALDAULIAxBE0HskvwAEMMhAAsgBCgCJCIPIAQoAiAiDSAEKAIcIgxqIghPDQIDQEJ/IAQ1ApQBhkJ/hSEtIAQoAjghBSAELQBAIQYgBCgCPCESIAQpAzAhLCAELQCYASETIAQCfwJAAkACQAJAAkACQAJAAkACQANAICwgLYOnIQdBzP/7ACELQYAEIQkCQAJAAkACQCATQQFrDgMAAQIDC0G0CiEJIB0hCwwCC0G0CiEJIB4hCwwBC0HQBCEJICEhCwsgByAJTw0BIAsgB0ECdGooAQAiCUEYdiILIAZB/wFxSwRAIAUgEkYNDiAEIAVBAWoiCTYCOCAEIAZBCGoiBzoAQCAEIAUxAAAgBq2GICyEIiw3AzAgCSEFIAchBgwBCwsgCUH//wNxIgdBEE8EQCAGQf8BcSEJAkACQAJAAkACQAJAAkACQAJAAkAgB0EQaw4CAQIACwJAIAkgC0EHaiITTwRAIAYhCQwBCwNAIAUgEkYNGCAEIAVBAWoiBzYCOCAEIAZBCGoiCToAQCAEIAUxAAAgBq2GICyEIiw3AzAgByEFIBMgCSIGQf8BcUsNAAsLIAQgCSALa0EHazoAQCAEICwgC62IIixCB4g3AzAgCCAsp0H/AHEiBkELaiIFIA9qIglJDQggD0HBAk8NECAFQcACIA9rIghLDREgBkEBdEEWaiIFDQYMBwsCQCAJIAtBAmoiDU8EQCAGIQkMAQsDQCAFIBJGDRcgBCAFQQFqIgc2AjggBCAGQQhqIgk6AEAgBCAFMQAAIAathiAshCIsNwMwIAchBSANIAkiBkH/AXFLDQALCyAEIAkgC2siBjoAQCAEICwgC62IIiw3AzAgDw0BIARBGjYCiAEgBEHkgMAANgKEAQw0CwJAIAkgC0EDaiITTwRAIAYhCQwBCwNAIAUgEkYNFiAEIAVBAWoiBzYCOCAEIAZBCGoiCToAQCAEIAUxAAAgBq2GICyEIiw3AzAgByEFIBMgCSIGQf8BcUsNAAsLQX0hBiAEIAkgC2tBA2s6AEAgBCAsIAutiCIsQgOINwMwIAggLKdBB3EiCUEDaiIFIA9qIgdJDQMgD0HBAk8NDCAFQcACIA9rIgZLDQ0gCUEBdEEGaiIFDQEMAgsgD0EBayEFIA9BwAJLDQggHCAFQQF0ai8BACEHIAQgBkECazoAQCAEICxCAog3AzAgCCAsp0EDcSIFQQNqIgkgD2pJDQogCUHAAiAPayIGSw0JIAVBAXRBBmohBiAcIA9BAXRqIQUDQCAFIAc7AQAgBUECaiEFIAZBAmsiBg0ACyAEKAIgIQ0gBCgCHCEMIAQoAiQgCWoMEAsgHCAPQQF0akEAIAX8CwALIAcMDgsgBEEaNgKIASAEQeSAwAA2AoQBQR4hBwwxCyAcIA9BAXRqQQAgBfwLAAsgCQwLCyAEQRo2AogBIARB5IDAADYChAEMLAsgBCAGIAtrOgBAIAQgLCALrYg3AzAgD0HAAkkNCCAPQcACQeyT/AAQwyEACyAHIAlBzJD8ABDDIQALIAVBwAJBjJP8ABDDIQALIAkgBkGck/wAELA7AAsgBEEaNgKIASAEQeSAwAA2AoQBDCcLIA9BwAJBrJP8ABCvOwALIAUgBkG8k/wAELA7AAsgD0HAAkHMk/wAEK87AAsgBSAIQdyT/AAQsDsACyAcIA9BAXRqIAk7AQAgD0EBagsiDzYCJCAMIA1qIgggD0sNAAsMAgtBfiEGDCELQQAhBkEaIQcMIAsgBC8BhGtFBEAgBEElNgKIASAEQfWxwgA2AoQBDB4LIApBGGoiBkEBIBxBwAIgDCAeQbQKQQogJhDLAiAKKAIYRQRAIAooAiAhBSAEIAooAhw2ApQBIARBAjoAmAEgBCAFNgIoIAQoAhwiBUHBAkkEQCAGQQIgHCAFQQF0akHAAiAFayAEKAIgICFB0ARBCSAmEMsCIAooAhhFBEAgCigCICEFIAooAhwhBiAEQQM6AKABIAQgBjYCnAEgBCAFIAQoAihqNgIoQREhBSAELQAEQQZHDSNBACEGQREhBwwiCyAEQRY2AogBIARBzoDAADYChAEMHwsgBUHAAkH8kvwAEK87AAsgBEEcNgKIASAEQYCAwAA2AoQBDB0LIARBEzYCJAsgCkEYakEAIBxBwAJBEyAdQbQKQQcgJhDLAiAKKAIYRQRAIAooAhwhBSAKKAIgIQYgBEEBOgCYASAEIAY2AiggBCAFNgKUASAEQQA2AiRBGiEFDB8LIARBGTYCiAEgBEGcgMAANgKEAQwbC0EXIQUgBCgCYCINRQ0dIAQpAzAhLAJAIAQtAEAiByANTwRAIAchCQwBCyAEKAI4IQYgBCgCPCEMA0AgBiAMRgRAQQAhBkEWIQcMHwsgBCAGQQFqIgg2AjggBCAHQQhqIgk6AEAgBCAGMQAAIAethiAshCIsNwMwIAghBiAJIQcgDSAJQf8BcUsNAAsLIAQgCSANazoAQCAEICwgDa2INwMwIAQgBCgCZCANajYCZCAEIAQoAlwgLEJ/IA1BP3GthkJ/hYOnajYCXAwdCyAEIAQpAzBCfyAENQKcAYZCf4WDpxDcISEGAkAgBC0AQCIFIAZBGHYiB0kEQANAIAQoAjgiBiAEKAI8Rg0CIAQgBkEBajYCOCAEIAVBCGo6AEAgBCAEKQMwIAYxAAAgBa2GhCIsNwMwIAQgLEJ/IAQ1ApwBhkJ/hYOnENwhIQYgBC0AQCIFIAZBGHYiB0kNAAsLIAQpAzAhLAJAIAZBEHYiC0H/AXFBD0sEQCAHIQkMAQsgByAEIAZB//8DcSIIICxCfyAHIAtqQT9xrYZCf4UiLYOnIAd2ahDcISIGQRh2IglqQf8BcSAELQBAIgVLBEAgB0EfcSENA0AgBCgCOCIGIAQoAjxGDQMgBCAGQQFqNgI4IAQgBUEIajoAQCAEIAQpAzAgBjEAACAFrYaEIiw3AzAgByAEICwgLYOnIA12IAhqENwhIgZBGHYiCWpB/wFxIAQtAEAiBUsNAAsLIAQgBCgCZCAHajYCZCAFIAdrIQUgBkEQdiELIAQpAzAgB62IISwLIAQgBSAJazoAQCAEICwgCa2INwMwIAtBwABxRQRAIAQgC0EPcTYCYCAEIAZB//8DcTYCXEEWIQUMHgsgBEEWNgKIASAEQe+zwgA2AoQBDBoLQQAhBkEVIQcMGwtBCyEFIAQtAAMiCUUNGyAEMQBAIixCH1gEQCAEKAI4IQYgBCgCPCEHIAQpAzAhLQNAIAYgB0YEQEEAIQZBECEHDB0LIAQgBkEBaiIINgI4IAQgLEIIfCIuPABAIAQgBjEAACAshiAthCItNwMwICxCGFQgLiEsIAghBg0ACwsgBCAEKAJQIgYgBCgCVGo2AlQgBCgCeCEHAn8gCUEEcUUEQCAEKAJ8IQlBAQwBCwJAIAcEQCAEIAQoAoABIAQoAkggBhDdByIJNgKAAQwBCyAEKAJ8IAQoAkggBhDoByEJCyAEIAk2AnwgBCgCUCEGIAQoAnghByAELQADQQRxRQshCCAEIAQoAkwgBms2AnQCQCAIRQRAIAQoAjAiBiAGQRh0IAZBgP4DcUEIdHIgBkEIdkGA/gNxIAZBGHZyciAHGyAJRw0BCyAEQQA6AEAgBEIANwMwDBwLIARBFTYCiAEgBEHIssIANgKEAQwYCyAELQBAIgWtIS0gBC0AASIIQQFxBEAgBCAFQfgBcToAQCAEIAQpAzAgLUIHg4g3AzBBECEFDBsLIAQpAzAhLCAFQf8BcUECTQRAIAQoAjgiBiAEKAI8RgRAQQAhBkENIQcMGwsgBCAGQQFqNgI4IAYxAAAgLYYgLIQhLCAFQQhyIQULIAQgBUEBazoAQCAEICxCAYgiLTcDMCAEICynQQFxIAhyOgABAkACQAJAAkAgLadBA3FBAWsOAwECAwALIAQgBUEDazoAQCAEICxCA4g3AzBBDiEFDB0LQQAhBiAEQQA6AKABIARBBTYCnAEgBEEAOgCYASAEQQk2ApQBIAQgBUEDazoAQCAEICxCA4g3AzBBESEFQREhByAELQAEQQZHDRwMGwsgBCAFQQNrOgBAIAQgLEIDiDcDMEEYIQUMGwsgBEETNgKIASAEQcCzwgA2AoQBQX0hBiAEIAVBA2s6AEAgBCAsQgOINwMwQR4hBwwZCwJAIAQoAngiC0GABHFFDQAgBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCCAEKQMwIS0DQCAFIAhGBEBBACEGQQghBwwcCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLAkAgBC0AA0EEcQRAIAQvAXwgBCgCMEcNAQsgBEEAOgBAIARCADcDMAwBCyAEQRQ2AogBIARB+7LCADYChAEMFwsgBCgCjAEiBQRAIAUgC0EJdkEBcTYCLCAEKAKMAUEBNgIwIAQoAnghCwtBDCEFIAQtAANBBHFFIAtFcg0ZIARCADcCfAwZCwJAAkAgBCgCeCISQYAgcQRAQQchByAEKAJwRQ0TIAQoAjwiCCAEKAI4IgZHDQFBACELDAILQQghBSAEKAKMASIGRQ0aIAZBADYCJAwaCyAIIAZrIQtBACEFA0AgBSAGai0AAARAIAYgBUEBaiIFaiAIRw0BDAILCyAFQQFqIQsLAkAgBCgCjAEiBUUNACAFKAIkIglFDQAgBSgCKCIIIAQoAlgiBU8EQCAIIAVrIgggCyAIIAtJGyIIBEAgBSAJaiAGIAj8CgAACyAEIAQoAlggCGo2AlggBCgCeCESDAELQaSS/ABBEkG4kvwAEMskAAsCQCASQYAEcUUNACAELQADQQRxRQ0AIAQgBCgCfCAGIAsQ3Qc2AnwLAkACQCALBEAgBiALakEBayIFDQELIAQgBCgCPCIGIAQoAjggC2oiBSAFIAZLGyIJNgI4DAELIAUtAAAgBCAEKAI8IgYgBCgCOCALaiIFIAUgBksbIgk2AjhBCCEFRQ0ZC0EIIQUgBiAJRw0YDBALAkACQCAEKAJ4IhJBgBBxBEBBBiEHIAQoAnANAQwSCyAEKAKMASIFRQ0BIAVBADYCHAwBCwJAIAQoAjwiCCAEKAI4IgZGBEBBACELDAELIAggBmshC0EAIQUDQCAFIAZqLQAABEAgBiAFQQFqIgVqIAhHDQEMAgsLIAVBAWohCwsCQCAEKAKMASIFRQ0AIAUoAhwiCUUNACAFKAIgIgggBCgCWCIFTwRAIAggBWsiCCALIAggC0kbIggEQCAFIAlqIAYgCPwKAAALIAQgBCgCWCAIajYCWCAEKAJ4IRIMAQtBgJL8AEESQZSS/AAQyyQACwJAIBJBgARxRQ0AIAQtAANBBHFFDQAgBCAEKAJ8IAYgCxDdBzYCfAsCQAJAIAsEQCAGIAtqQQFrIgUNAQsgBCAEKAI8IgUgBCgCOCALaiIGIAUgBkkbIgY2AjgMAQsgBS0AACAEIAQoAjwiBSAEKAI4IAtqIgYgBSAGSRsiBjYCOEUNAQsgBSAGRg0QCyAEQQA2AlhBByEFDBcLAkAgBCgCeCIHQYAIcUUNACAEKAI8IAQoAjgiDWsiBiAEKAJYIgUgBSAGSxsiBgRAAkAgBCgCjAEiCEUNACAIKAIQIgxFDQAgBiAIKAIYIgkgCCgCFCAFayIFayIIQQAgCCAJTRsiCCAGIAhJGyIIBEAgDCAJIAUgBSAJSxtqIA0gCPwKAAALIAQoAnghBwsCQCAHQYAEcUUNACAELQADQQRxRQ0AIAQoAjwgBCgCOCIFayIIIAZPBEAgBCAEKAJ8IAUgBhDdBzYCfAwBCyAGIAhB8JH8ABCwOwALIAQgBCgCcCAGazYCcCAEIAQoAlggBmsiBTYCWCAEIAQoAjwiCCAEKAI4IAZqIgYgBiAISxs2AjgLIAVFDQBBACEGQQUhBwwWCyAEQQA2AlhBBiEFDBYLIAQoAngiCEGACHEEQCAEKQMwIS0gBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCQNAIAUgCUYEQEEAIQZBBCEHDBgLIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCCFQgLiEsIAYhBQ0ACwsgBCAtpyIFNgJYAkAgBCgCjAEiBgR/IAYgBTYCFCAEKAJ4BSAIC0GABHFFDQAgBC0AA0EEcUUNACAKIAQpAzA9ARggBCAEKAJ8IApBGGpBAhDdBzYCfAsgBEEAOgBAIARCADcDMEEFIQUMFgtBBSEFIAQoAowBIgZFDRUgBkEANgIQDBULQQ0hBSAELQADIghFDRQgBCkDMCEtIAQxAEAiLEIPWARAIAQoAjghBSAEKAI8IQkDQCAFIAlGBEBBACEHDA8LIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCCFQgLiEsIAYhBQ0ACwsCQCAIQQJxQQAgLUKflgJRG0UEQCAEKAKMASIFBH8gBUF/NgIwIAQtAAMFIAgLQQFxBEAgBCkDMCIsQgiGQoD+A4MgLEIIiHxCH4JQDQILIARBFzYCiAEgBEGassIANgKEAQwTCyAELQACRQRAIARBDzoAAgsgCkGflgI7ABggBEEAIApBGGpBAhDdBzYCfCAEQQA6AEAgBEIANwMwQQEhBQwVCyAsQg+DQghRBEAgBCAsQgSIIi03AzAgBCAELQBAQQRrOgBAIC2nQQ9xIgZBCGohBSAELQACIggEfyAIBSAEIAU6AAIgBQsgBUkgBkEHS3JFBEAgBEKAgICAEDcDeCAEQQA6AEAgBEIANwMwIARBASAFdDYCkAFBDEEbICxCgMAAg1AbIQUMFgsgBEEUNgKIASAEQY+zwgA2AoQBDBILIARBGzYCiAEgBEGFtMIANgKEAQwRCyAEQR02AogBIARBo7PCADYChAEMEAtB/JP8AEETQZCU/AAQnykAC0ECIQYgBC0AAUECcUUEQEEcIQcMEQsgBEEBNgJ8QQwhBQwRCyAEKQMwIS0gBDEAQCIsQh9YBEAgBCgCOCEFIAQoAjwhCANAIAUgCEYEQEEAIQZBGyEHDBILIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCGFQgLiEsIAYhBQ0ACwsgBEEAOgBAIARCADcDMCAEIC2nIgVBGHQgBUGA/gNxQQh0ciAFQQh2QYD+A3EgBUEYdnJyNgJ8QRwhBQwQCyAEKQMwIS0gBCAELQBAIgVBDU0EfyAFrSEsIAQoAjghBSAEKAI8IQgDQCAFIAhGBEBBACEGQRghBwwRCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQgZUIC4hLCAGIQUNAAsgLKcFIAULQQ5rOgBAIAQgLUIOiDcDMCAEIC2nIgVBH3EiBkGBAmo2AhwgBCAFQQV2QR9xIghBAWo2AiAgBCAFQQp2QQ9xQQRqNgIYIAZBHUsgCEEdS3JFBEAgBEEANgIkQRkhBQwQCyAEQSQ2AogBIARBmrHCADYChAEMDAsDQCAEKAJMIgYgBCgCUCIIRgRAQQAhBkEXIQcMDwsgBiAIayEGAkAgCCAEKAJcIglPBEAgDiAJIAYgBCgCWCIIIAYgCEkbIgYQhw0MAQsgCSAIayIIIAQoAhBNBEAgBCgCDCIHQUBqIglBQU8NFiAOICogCUEAIAcgCU8bIAggBCgCFCIJayIHayAJIAhrIAggCUsiCRsiDSANIAYgBCgCWCIMIAcgCCAJGyIIIAggDEsbIgggBiAISRsiBmoQ1BIMAQsgBC0AAUEEcQRAQR4hByAEQR42AogBIARB3bLCADYChAFBfSEGDBALIApBADYCKCAKQQE2AhwgCkHYkfwANgIYIApCBDcCICAKQRhqQciS/AAQ7ywACyAEIAQoAlgiCCAGazYCWCAGIAhHDQALDA4LAkAgBCgCYCIJRQRAIAQoAlghBQwBCyAEKQMwISwCQCAELQBAIgYgCU8EQCAGIQcMAQsgBCgCOCEFIAQoAjwhDQNAIAUgDUYEQEEAIQZBFCEHDBALIAQgBUEBaiIINgI4IAQgBkEIaiIHOgBAIAQgBTEAACAGrYYgLIQiLDcDMCAIIQUgCSAHIgZB/wFxSw0ACwsgBCAHIAlrOgBAIAQgLCAJrYg3AzAgBCAEKAJkIAlqNgJkIAQgBCgCWCAsQn8gCUE/ca2GQn+Fg6dqIgU2AlgLIAQgBTYCaEEVIQUMDQsgBCgCUCAEKAJMRgRAQQAhBkETIQcMDAsgBCgCWCEIAkAgDigCCCIGIA4oAgQiCUkEQCAOIAZBAWo2AgggDigCACAGaiAIOgAADAELIAYgCUG08fwAEMMhAAsMDAsgBEESOgAAAkAgBCgCPCIJIAQoAjgiCGtBD0kNACAEKAJMIAQoAlBrQYMCTQ0AIAQQrgIgBC0AACIFQRJHDQwgBCgCPCEJIAQoAjghCAsgCkEIaiAOQQhqKAIANgIAIARBADYCUCAOKQIAISwgBEIBNwNIIAogLDcDACAKIBAoAAA2AhAgCiAQQQNqKAAANgATQcz/+wAhD0GABCEgAkACQAJAAkAgBC0AmAFBAWsOAwABAgMLQbQKISAgHSEPDAILQbQKISAgHiEPDAELQdAEISAgISEPC0HMj/wAIRJBICELAkACQAJAAkAgBC0AoAFBAWsOAwABAgMLQbQKIQsgHSESDAILQbQKIQsgHiESDAELQdAEIQsgISESCyAELQBAIQ0gBCkDMCEsAkACQANAQRIhBwNAAkACQAJAIAQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgB0H/AXFBE2sOBQUBCQIMAAsgCSAIa0EPTwRAIAooAgQgCigCCGtBgwJLDQMLIARBADYCZCAIIQYgDSEFICAgLEJ/IAQ1ApQBhkJ/hSItg6ciB0sNAwwaCyAEKAJgIgdFBEAgBCgCWCEFDAcLIAghBSAHIA0iBkH/AXFLDQQgBSEMDAULQRchByAEKAJgIgxFDRUgCCEFIAwgDSIGQf8BcUsNByAFIRMMCAsgBEESOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBBCuAiAELQAAIQUMIwsDQCAPIAdBAnRqIgwtAAMiByAFQf8BcU0NEyAGIAlHBEAgBa0hLiAGMQAAIS8gBkEBaiEGIAVBCGohBSAgIC8gLoYgLIQiLCAtg6ciB00NGAwBCwtBEiEHIARBEjoAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADBoLIAooAggiBSAKKAIEIgZHBEAgBSAGTw0IIAooAgAgBWogBCgCWDoAACAKIAVBAWo2AggMFAtBEyEHIARBEzoAACAEIA06AEAgBCAJNgI8IAQgCDYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIADBkLA0AgBSAJRg0IIAUxAAAgBq2GICyEISwgBUEBaiIMIQUgByAGQQhqIgZB/wFxSw0ACwsgBCAEKAJkIAdqNgJkIAQgBCgCWCAsQn8gB0E/ca2GQn+Fg6dqIgU2AlggBiAHayENICwgB62IISwgDCEICyAEIAU2AmhBFSEHDA8LIAghBiANIQUgCyAsQn8gBDUCnAGGQn+FIi2DpyIHTQ0MA0AgEiAHQQJ0aiIMLQADIgcgBUH/AXFNDQogBiAJRwRAIAWtIS4gBjEAACEvIAZBAWohBiAFQQhqIQUgCyAvIC6GICyEIiwgLYOnIgdNDQ4MAQsLQRUhByAEQRU6AAAgBCAJNgI8IAQgCTYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAIAQgDSAJQQN0aiAIQQN0azoAQAwVCwNAIAUgCUYNBSAFMQAAIAathiAshCEsIAVBAWoiEyEFIAwgBkEIaiIGQf8BcUsNAAsLIAQgBCgCZCAMajYCZCAEIAQoAlwgLEJ/IAxBP3GthkJ/hYOnajYCXCAGIAxrIQ0gLCAMrYghLCATIQgMDAsgCigCBCIFIAooAggiBkYNAyAFIAZrIQUgBiAEKAJcIgdPBEAgCiAHIAUgBCgCWCIGIAUgBkkbIgUQhw0MBgsgByAGayIGIAQoAhBNBEAgBCgCDCIMQUBqIgdBQU8NICAKICogB0EAIAcgDE0bIAYgBCgCFCIHayIMayAHIAZrIAYgB0siBxsiEyATIAUgBCgCWCIfIAwgBiAHGyIGIAYgH0sbIgYgBSAGSRsiBWoQ1BIMBgsgBC0AAUEEcUUNBCAOIAopAwA3AgAgBCANOgBAIAQgCTYCPCAEIAg2AjggBCAsNwMwIBAgCigCEDYAACAEQR42AogBIARB3bLCADYChAEgEEEDaiAKKAATNgAAIA5BCGogCkEIaigCADYCAEEeDAcLIAUgBkG08fwAEMMhAAtBFCEHIARBFDoAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADBALQRYhByAEQRY6AAAgBCAJNgI8IAQgCTYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAIAQgDSAJQQN0aiAIQQN0azoAQAwPC0EXIQcgBEEXOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAMDgsgCkEANgIoIApBATYCHCAKQdiR/AA2AhggCkIENwIgIApBGGpB4JH8ABDvLAALIAQgBCgCWCIGIAVrNgJYQRJBFyAFIAZGGyEHDAULIAwvAQAhEwJAIAwtAAIiFUEPSwRAIAchDAwBCyAsQn8gByAVakE/ca2GQn+FIi2DpyAHdiATaiIMIAtPDQIgB0EfcSEVAkADQCASIAxBAnRqIh8tAAMiDCAHakH/AXEgBUH/AXFNDQEgBiAJRwRAIAWtIS4gBjEAACAGQQFqIQYgBUEIaiEFIC6GICyEIiwgLYOnIBV2IBNqIgwgC08NBQwBCwtBFSEHIARBFToAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADA0LIB8tAAIhFSAfLwEAIRMgBCAEKAJkIAdqNgJkIAUgB2shBSAsIAetiCEsCyAFIAxrIQ0gLCAMrYghLCAVQcAAcUUEQCAEIBVBD3E2AmAgBCATQf//A3E2AlxBFiEHIAYhCAwFCyAOIAopAwA3AgAgBCANOgBAIAQgCTYCPCAEIAY2AjggBCAsNwMwIBAgCigCEDYAACAEQRY2AogBIARB77PCADYChAEgEEEDaiAKKAATNgAAIA5BCGogCkEIaigCADYCAEEeCyIHOgAAQX0hBgwRCyAMIAtBnJH8ABDDIQALIAcgC0GMkfwAEMMhAAsgDC8BACETAkAgDC0AAiIVRQRAQQAhDCAGIQhBACEVDAELQQAhDCAVQQ9LBEAgBiEIDAELAkAgICAsQn8gByAVakE/ca2GQn+FIi2Dp0H//wNxIAdBD3EiFXYgE2pB//8DcSIMTQ0AAkADQCAPIAxBAnRqIgwtAAMiHyAHakH/AXEgBUH/AXFNDQEgBiAJRwRAIAWtIS4gBjEAACEvIAZBAWohBiAFQQhqIQUgICAvIC6GICyEIiwgLYOnQf//A3EgFXYgE2pB//8DcSIMTQ0DDAELC0ESIQcgBEESOgAAIAQgCTYCPCAEIAk2AjggBCAsNwMwIBAgCigCEDYAACAQQQNqIAooABM2AAAgDiAKKQMANwIAIA5BCGogCkEIaigCADYCACAEIA0gCUEDdGogCEEDdGs6AEAMCgsgBSAHayEFICwgB62IISwgDC0AAiEVIAwvAQAhEyAHIQwgBiEIIB8hBwwBCyAMICBB/JD8ABDDIQALIAQgE0H//wNxNgJYIAQgDCAHQf8BcWo2AmQgBSAHayENICwgB62IISxBEyEHIBVFDQAgFUEgcQ0CIBVBwABxRQRAIAQgFUEPcTYCYEEUIQcMAQsLC0EeIQcgBEEeOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgBEEcNgKIASAEQdOzwgA2AoQBIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAQX0hBgwMC0EMIQUgBEEMOgAAIARBfzYCZCAEIA06AEAgBCAJNgI8IAQgCDYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIADAwLIAcgIEHskPwAEMMhAAsgBCAELQBAIgVB+AFxOgBAIAQgBCkDMCAFQQdxrYgiLTcDMAJAAkAgBUEfTQRAIAWtQhiDISwgBCgCOCEFIAQoAjwhCANAIAUgCEYEQEEAIQYMAwsgBCAFQQFqIgY2AjggBTEAACEvIAQgLEIIfCIuPABAIAQgLyAshiAthCItNwMwICxCGFQgLiEsIAYhBQ0ACwsgLUIQiCAthUL//wODQv//A1INAUEAIQYgBEEAOgBAIARCADcDMCAEIC2nQf//A3E2AlhBDyEFIAQtAARBBkcNDAtBDiEHDAoLIARBHTYCiAEgBEG+scIANgKEAQwHC0ENIQUgBC0ABEEFa0H/AXFBAk8NCUEAIQZBDCEHDAgLQQEhBkELIQcgBC0AAyIJRQ0HIAQoAnhFDQcgBDEAQCIsQh9YBEAgBCgCOCEFIAQoAjwhDSAEKQMwIS0DQCAFIA1GDQIgBCAFQQFqIgg2AjggBCAsQgh8Ii48AEAgBCAFMQAAICyGIC2EIi03AzAgLEIYVCAuISwgCCEFDQALCyAJQQRxBEAgBCkDMCAENQJUUg0CCyAEQQA6AEAgBEIANwMwDAcLQQAhBgwGCyAEQRc2AogBIARBsbLCADYChAEMAwsgBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCCAEKQMwIS0DQCAFIAhGBEBBACEGQQMhBwwHCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLIAQoAowBIgUEQCAFIAQtADA2AgggBCgCjAEgBCkDMEIIiD4CDAsCQCAELQB5QQJxRQ0AIAQtAANBBHFFDQAgCiAEKQMwPQEYIAQgBCgCfCAKQRhqQQIQ3Qc2AnwLIARBADoAQCAEQgA3AzBBBCEFDAULIAQxAEAiLEIfWARAIAQoAjghBSAEKAI8IQggBCkDMCEtA0AgBSAIRgRAQQAhBkECIQcMBgsgBCAFQQFqIgY2AjggBCAsQgh8Ii48AEAgBCAFMQAAICyGIC2EIi03AzAgLEIYVCAuISwgBiEFDQALCyAEKAKMASIFBEAgBSAEKQMwPgIECwJAIAQtAHlBAnFFDQAgBC0AA0EEcUUNACAKIAQpAzA+AhggBCAEKAJ8IApBGGpBBBDdBzYCfAsgBEEAOgBAIARCADcDMEEDIQUMBAsgBCkDMCEtIAQxAEAiLEIPWARAIAQoAjghBSAEKAI8IQgDQCAFIAhGBEBBACEGQQEhBwwFCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLIAQgLaciBTYCeAJAAkAgBUH/AXFBCEYEQCAFQYDAA3ENASAEKAKMASIGBH8gBiAFQQh2QQFxNgIAIAQoAngFIAULQYAEcUUNAiAELQADQQRxRQ0CIAQoAnwhBSAKIAQpAzA9ABggBCAFIApBGGpBAhDdBzYCfAwCCyAEQRs2AogBIARBhbTCADYChAEMAgsgBEEZNgKIASAEQbWAwAA2AoQBDAELIARBADoAQCAEQgA3AzBBAiEFDAMLQX0hBkEeIQcMAQtBDCEFIAQoAlgiB0UNASAEKAI4IRIgBCgCPCELIAQoAlAhCQNAIAsgEmsiBiAEKAJMIgggCWsiDSAHIAcgDUsbIgcgBiAHSRsiBkUEQEEAIQZBDyEHDAILIAggCUkNAyAGBEAgBCgCSCAJaiASIAb8CgAACyAEIAQoAlAgBmoiCTYCUCAEIAQoAlggBmsiBzYCWCAEIAQoAjwiCyAEKAI4IAZqIgYgBiALSxsiEjYCOCAHDQALDAELCyAEIAc6AAAgESgCACEEIBEgESgCHCIFKAI4IiE2AgAgESAFKAI8ICFrNgIEIBEgBSgCTCIIIAUoAlAiB2s2AhAgESAHIAUoAkhqNgIMIBEgESgCCCAhIARrajYCCCAFIAUoAnQgByAIa2oiDSAFKAJUaiIINgJUIBEgCDYCFCARIAUoAnw2AjAgBSgCDCIIQUBqQUFPDQQCQCAIQcAATQRAIA1FDQQCQAJAAkAgBS0AACIIQQlrDggHBwECAgICAQALIAhBHkcNAQwGCyAFLQAEQQRGDQULAkBBASAFLQACdEFAayIJQQBIDQAgBS0AAyEIIBFBIGogCRCBGiIHRQ0AIAVCADcDECAFIAk2AgwgBSAHNgIIIAUoAlAhBwwCCyAFQQo6AABBfCEGDAQLIAUtAAMhCAsgByANSQ0BIAUoAkghDyAFKAJ4IRMgCEEEcUECdiEfIAVB/ABqIRIgBUGAAWohHQJAAkACQAJAAkACQAJAAkACQAJAIAVBCGoiCSgCBCIMQUBqIghBQUkEQCAIQQAgCCAMTRsiByANSwRAIA0gByAJKAIMIgtrIg4gDSAOSRshCCAJKAIAIR4CQCAfRQRAIAsgDEsNBCAIIAwgC2siEEsNBSAIRQ0BIAsgHmogDyAI/AoAAAwBCyALIAxLDQUgCCAMIAtrIhBLDQYgCyAeaiEQIBNFBEAgEiASKAIAIBAgCCAPIAgQzis2AgAMAQsgHSAQIAggDyAIEJ0qCyANIA5LBEAgDSAIayILIAxLDQcgCCAPaiEIIB9FBEAgC0UNDCAeIAggC/wKAAAMDAsgE0UNCiAdIB4gCyAIIAsQnSoMCwsgCSAIIAtqIgxBACAHIAxHGzYCDCAHIAkoAggiDEsEQCAJIAggDGo2AggLDAsLIA8gDSAHayILaiEIIB9FBEAgB0UNCCAJKAIAIAggB/wKAAAMCAsgE0UNBiAdIB0oAgAgDyALEN0HNgIAIB0gCSgCACAHIAggBxCdKgwHC0H47/wAQcoAQcTw/AAQnykACyALIAxB5PD8ABCvOwALIAggEEH08PwAELA7AAsgCyAMQYTx/AAQrzsACyAIIBBBlPH8ABCwOwALIAsgDEGk8fwAELA7AAsgEiASKAIAIA8gCxDoByAJKAIAIAwgCCAHEM4rNgIACyAJIAc2AgggCUEANgIMDAILIBIgEigCACAeIAsgCCALEM4rNgIACyAJIAc2AgggCSALNgIMCwwCCyAJIAhBuP/7ABCvOwALIA0gB0HMlfwAELA7AAsCQCAFKAKEASIIRQ0AIAUoAogBIQkgCkEANgIYAkAgCUUNACAKQRhqQQEgCCAJakEBa0EBEMEuRQ0AIBEgCDYCGAwBC0HclfwAQSVBhJb8ABCfKQALIBEgBS0AAEEMa0H/AXEiCEEFTQR/IAhBAnRBlJb8AGooAgAFQQALIAUtAEAgBS0AAUEGdEHAAHFycjYCLCAGQXsgBhsiBSAGIAUgDRsgBiAEICFGGyApQf8BcUEERhshBQsgCkEwaiQAIAUMAQtB+O/8AEHKAEHE8PwAEJ8pAAshBgsgESgCDCEFIBFCADcCDCARKAIAIQggEUIANwIAIBogGikDACAIICdrrXw3AwAgGiAaKQMIIAUgAmutfDcDCAJAAkACQAJAAkACQAJAIAZBBWoOCAMBAQEAAgQFAAsgFiAGNgIMIBZBATYCFCAWQei9+wA2AhAgFkIBNwIcIBZBnAM2AiwgFiAWQShqNgIYIBYgFkEMajYCKCAWQRBqQfC9+wAQ7ywACyAWIBoQpyQgGyAWKQMANwIEIBtBADYCAAwECyAbQQI2AgAgG0EAOgAEDAMLIBtBAjYCACAbQQE6AAQMAgsgG0ECNgIAIBtBAjoABAwBCyAbQQE2AgAgGyARKAIwNgIECyAWQTBqJAAgGS0ACCEFIBkoAgQgGikDCCEsIAEgASgCFCIIIAEoAhAgGikDACAxfadqIgkgCCAJSRs2AhBBAkcEQCAjQRRByPTNAEEWEM0aDAQLICwgMH2nIgYgKEUgA0VyciAFQQJGcg0CIBlBBGogARDbFiAZKAIERQ0ACwsgIyAZKQIINwIADAELICNBBDoAACAjIAY2AgQLIBlBEGokAAJAAkACQAJ/ICItAAhBBEYEQCAiKAIMDAELICIpAwgiLEL/AYNCBFINASAsQiCIpwsiBSADSw0BIAFBMGogAiAFEIMxICVBBDoAACAlIAU2AgQMAgsgJSAsNwIADAELIAUgA0G8mc8AELA7AAsgIkEQaiQAIBQtADBBBEYEQCAUKAI0IQUMBwsgFCkDMCIsQv8Bg0IEUg0BICxCIIinIQUMBgsgAEEEOgAAIABBADYCBAwHCyAAICw3AgAMBgsCQAJAIAEoAngiBUEITwRAIAEoAoABIQUgASgCfCAkEIU7RgRAIAUgASgCQEYNAgsgFEEwaiICIBdBLPwKAAAgAUEAOgB0IAFBADYCcCABQYCAgIB4NgJkIAFBgICAgHg2AlggAUGAgICAeDYCTCAYELMbIAFBhICAgHg2AkggFyACQSz8CgAAIAAQhzsMCAsgFEEwaiABIAUgK2pBCCAFaxCLGSAULQAwQQRGBEAgFCgCNCEFDAULIBQpAzAiLEL/AYNCBFINASAsQiCIpyEFDAQLIAEtAIQBRQRAIBRBMGoiBSAXQSz8CgAAIAFBADoAdCABQQA2AnAgAUGAgICAeDYCZCABQYCAgIB4NgJYIAFBgICAgHg2AkwgGBCzGyABQYSAgIB4NgJIIBcgBUEs/AoAAAwGCyAUQTBqIAEQ2xYCQCAUKAIwRQRAIBQoAjgNAQwECyAUKQI0IixC/wGDQgRSBEAgACAsNwIADAgLICxCgAKDQgBSDQMLICRBADYCECAkEIc3IwBBIGsiBSQAIAVBCGoQwB8gAUEoaiIGKAIAEJIrIAYQhjsgBiAFQRhqKQMANwMAIAFBIGogBUEQaikDADcDACABIAUpAwg3AxggBUEgaiQAIBRBMGoiBRDNKyAYELMbIBggBUE8/AoAAAwFCyAAICw3AgAMBQsgAEEEOgAAIABBADYCBAwECyAUQTBqIgUgF0Es/AoAACABQQA6AHQgAUEANgJwIAFBgICAgHg2AmQgAUGAgICAeDYCWCABQYCAgIB4NgJMIBgQsxsgAUGEgICAeDYCSCAXIAVBLPwKAAAMAgsgASABKAJ4IAVqNgJ4DAELIAVFBEAgFEEwaiIFIBdBLPwKAAAgAUEAOgB0IAFBADYCcCABQYCAgIB4NgJkIAFBgICAgHg2AlggAUGAgICAeDYCTCAYELMbIAFBgoCAgHg2AkggFyAFQSz8CgAAIAFCADcCfCABQQA2AngMAQsLIABBBDoAACAAIAU2AgQLIBRB8ABqJAALjggCBn8DfiMAQaABayICJAAgAUEMahDZPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACQAJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAiABNgJAIAIgBjYCOCACIAQ2AjQgAiACQdAAaiIBNgI8IAIoAghFDQMgAigCHCACKAIYRg0EIAEgAkEIahDINCACQfAAaiEBA0ACQCACKQN4IglQRQRAIAIpA4ABIQgMAQsDQAJ+AkAgAikDYCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNgIAinQQFxRQ0AIAIgAikDaDcDkAEMAQsgAigCcEUNASACQYgBaiABELYqIAIpA4gBIQgLIAhCAFINAgsgAkIDNwNgCyACKQNQIghCAlENCSACQgA3A1AgAikDWAwBCyACKQOQAQshCSAIp0EBcUUNByACIAIpA4ABQkB9Igg3A4ABIAIgCTcDeCAJUA0ACwsgAiAJQgEgCXoiCoaFNwN4IAJBiAFqIAJBNGogCqcgCKdqEPYNIAIoAogBIgNBk4CAgHhGDQALIAAgAikCjAE3AgggAEEQaiACQZQBaikCADcCAAwGC0HAACADEKM9AAtB3Iv/AEEpIAJB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQEDQCACQdAAaiACQTRqIAEQ9g0gAigCUCIDQZOAgIB4Rw0CIAYgAUEBaiIBRw0ACwsgAkHQAGoiAxCXKSACQShqIgEoAgAhBCACKAIsIQUgASACQdgAaiIGKQIANwMAIAIpAyAhCCACIAIpAlA3AyAgAkEANgIwIAIgCDcCXCACQQA2AlggAiAFNgJUIAIgBDYCUCACIAMQ1zsgAigCACEEQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJQNwIIIAFBEGogBikCADcCACABQRhqIAJB4ABqIgcoAgA2AgAgAiAFNgKQASACIAQ2AowBIAIgATYCiAEgAkHEAGoiASACQYgBahDkGSAHIAJBGGopAgA3AwAgBiACQRBqKQIANwMAIAIgAikCCDcDUCAAIAEgAxDZHSACQSBqEM8vDAILIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIACyAAQSk6AAAgACADNgIEIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQaABaiQADwtBBEEcEKM9AAuOCAIGfwN+IwBBoAFrIgIkACABQQxqENk8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAAkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACIAE2AkAgAiAGNgI4IAIgBDYCNCACIAJB0ABqIgE2AjwgAigCCEUNAyACKAIcIAIoAhhGDQQgASACQQhqEMg0IAJB8ABqIQEDQAJAIAIpA3giCVBFBEAgAikDgAEhCAwBCwNAAn4CQCACKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A2AgCKdBAXFFDQAgAiACKQNoNwOQAQwBCyACKAJwRQ0BIAJBiAFqIAEQtiogAikDiAEhCAsgCEIAUg0CCyACQgM3A2ALIAIpA1AiCEICUQ0JIAJCADcDUCACKQNYDAELIAIpA5ABCyEJIAinQQFxRQ0HIAIgAikDgAFCQH0iCDcDgAEgAiAJNwN4IAlQDQALCyACIAlCASAJeiIKhoU3A3ggAkGIAWogAkE0aiAKpyAIp2oQwA0gAigCiAEiA0GTgICAeEYNAAsgACACKQKMATcCCCAAQRBqIAJBlAFqKQIANwIADAYLQcAAIAMQoz0AC0Hci/8AQSkgAkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAQNAIAJB0ABqIAJBNGogARDADSACKAJQIgNBk4CAgHhHDQIgBiABQQFqIgFHDQALCyACQdAAaiIDEJcpIAJBKGoiASgCACEEIAIoAiwhBSABIAJB2ABqIgYpAgA3AwAgAikDICEIIAIgAikCUDcDICACQQA2AjAgAiAINwJcIAJBADYCWCACIAU2AlQgAiAENgJQIAIgAxDXOyACKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogAkHgAGoiBygCADYCACACIAU2ApABIAIgBDYCjAEgAiABNgKIASACQcQAaiIBIAJBiAFqEOUZIAcgAkEYaikCADcDACAGIAJBEGopAgA3AwAgAiACKQIINwNQIAAgASADEMcdIAJBIGoQzy8MAgsgACACKQJUNwIIIABBEGogAkHcAGopAgA3AgALIABBKToAACAAIAM2AgQgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJBoAFqJAAPC0EEQRwQoz0AC44IAgZ/A34jAEGgAWsiAiQAIAFBDGoQ2TwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAAkACQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIgATYCQCACIAY2AjggAiAENgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAQNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogARC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDBDSACKAKIASIDQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgAxCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEBA0AgAkHQAGogAkE0aiABEMENIAIoAlAiA0GTgICAeEcNAiAGIAFBAWoiAUcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQQgAigCLCEFIAEgAkHYAGoiBikCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBTYCVCACIAQ2AlAgAiADENc7IAIoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBTYCkAEgAiAENgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4RkgByACQRhqKQIANwMAIAYgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQ2h0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgAzYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALjggCBn8DfiMAQaABayICJAAgAUEMahDZPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACQAJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAiABNgJAIAIgBjYCOCACIAQ2AjQgAiACQdAAaiIBNgI8IAIoAghFDQMgAigCHCACKAIYRg0EIAEgAkEIahDINCACQfAAaiEBA0ACQCACKQN4IglQRQRAIAIpA4ABIQgMAQsDQAJ+AkAgAikDYCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNgIAinQQFxRQ0AIAIgAikDaDcDkAEMAQsgAigCcEUNASACQYgBaiABELYqIAIpA4gBIQgLIAhCAFINAgsgAkIDNwNgCyACKQNQIghCAlENCSACQgA3A1AgAikDWAwBCyACKQOQAQshCSAIp0EBcUUNByACIAIpA4ABQkB9Igg3A4ABIAIgCTcDeCAJUA0ACwsgAiAJQgEgCXoiCoaFNwN4IAJBiAFqIAJBNGogCqcgCKdqEPcNIAIoAogBIgNBk4CAgHhGDQALIAAgAikCjAE3AgggAEEQaiACQZQBaikCADcCAAwGC0HAACADEKM9AAtB3Iv/AEEpIAJB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQEDQCACQdAAaiACQTRqIAEQ9w0gAigCUCIDQZOAgIB4Rw0CIAYgAUEBaiIBRw0ACwsgAkHQAGoiAxCXKSACQShqIgEoAgAhBCACKAIsIQUgASACQdgAaiIGKQIANwMAIAIpAyAhCCACIAIpAlA3AyAgAkEANgIwIAIgCDcCXCACQQA2AlggAiAFNgJUIAIgBDYCUCACIAMQ1zsgAigCACEEQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJQNwIIIAFBEGogBikCADcCACABQRhqIAJB4ABqIgcoAgA2AgAgAiAFNgKQASACIAQ2AowBIAIgATYCiAEgAkHEAGoiASACQYgBahDkGSAHIAJBGGopAgA3AwAgBiACQRBqKQIANwMAIAIgAikCCDcDUCAAIAEgAxDWHSACQSBqEM8vDAILIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIACyAAQSk6AAAgACADNgIEIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQaABaiQADwtBBEEcEKM9AAuOCAIGfwN+IwBBoAFrIgIkACABQQxqENk8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAAkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACIAE2AkAgAiAGNgI4IAIgBDYCNCACIAJB0ABqIgE2AjwgAigCCEUNAyACKAIcIAIoAhhGDQQgASACQQhqEMg0IAJB8ABqIQEDQAJAIAIpA3giCVBFBEAgAikDgAEhCAwBCwNAAn4CQCACKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A2AgCKdBAXFFDQAgAiACKQNoNwOQAQwBCyACKAJwRQ0BIAJBiAFqIAEQtiogAikDiAEhCAsgCEIAUg0CCyACQgM3A2ALIAIpA1AiCEICUQ0JIAJCADcDUCACKQNYDAELIAIpA5ABCyEJIAinQQFxRQ0HIAIgAikDgAFCQH0iCDcDgAEgAiAJNwN4IAlQDQALCyACIAlCASAJeiIKhoU3A3ggAkGIAWogAkE0aiAKpyAIp2oQwg0gAigCiAEiA0GTgICAeEYNAAsgACACKQKMATcCCCAAQRBqIAJBlAFqKQIANwIADAYLQcAAIAMQoz0AC0Hci/8AQSkgAkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAQNAIAJB0ABqIAJBNGogARDCDSACKAJQIgNBk4CAgHhHDQIgBiABQQFqIgFHDQALCyACQdAAaiIDEJcpIAJBKGoiASgCACEEIAIoAiwhBSABIAJB2ABqIgYpAgA3AwAgAikDICEIIAIgAikCUDcDICACQQA2AjAgAiAINwJcIAJBADYCWCACIAU2AlQgAiAENgJQIAIgAxDXOyACKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogAkHgAGoiBygCADYCACACIAU2ApABIAIgBDYCjAEgAiABNgKIASACQcQAaiIBIAJBiAFqEOUZIAcgAkEYaikCADcDACAGIAJBEGopAgA3AwAgAiACKQIINwNQIAAgASADEL8dIAJBIGoQzy8MAgsgACACKQJUNwIIIABBEGogAkHcAGopAgA3AgALIABBKToAACAAIAM2AgQgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJBoAFqJAAPC0EEQRwQoz0AC44IAgZ/A34jAEGgAWsiAiQAIAFBDGoQ2TwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAAkACQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIgATYCQCACIAY2AjggAiAENgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAQNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogARC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDDDSACKAKIASIDQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgAxCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEBA0AgAkHQAGogAkE0aiABEMMNIAIoAlAiA0GTgICAeEcNAiAGIAFBAWoiAUcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQQgAigCLCEFIAEgAkHYAGoiBikCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBTYCVCACIAQ2AlAgAiADENc7IAIoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBTYCkAEgAiAENgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4RkgByACQRhqKQIANwMAIAYgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQzR0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgAzYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALkwgBB38jAEHQAGsiAiQAIAJBMGoiA0EgQQBBAUEBEKAYIAIoAjQhBAJAAkAgAigCMEEBRwRAIAJBADYCFCACIAIoAjg2AhAgAiAENgIMIAJBGGogASABKAIMIgcQtREgAiACKAIYIgRBDXUiATYCJAJAIAFBkM4ATwRAIAJBATYCRCACQezDhQE2AkAgAkEBNgI0IAJB5MOFATYCMCACQQE2AjwgAkGcAzYCTCACIAJByABqNgI4IAIgAkEkajYCSCACQQxqIAMQ7jxFDQEMBAsgAkEMaiIDIAFB//8DcUHkAG4iBRCLGA0DIAMgASAFQeQAbGsQixgNAwsgAigCFCEBIAJBDGoiA0EBEIQuIAIoAhAgAigCFGpBLToAACACIAFBAWo2AhQgBEEDdiIEQf8HcSIBQd0FTw0BIAMgASABQfS9hQFqLQAAIgVqQQZ2EIsYDQIgAigCFCEBIANBARCELiACKAIQIAIoAhRqQS06AAAgAiABQQFqNgIUIAMgBCAFakEBdkEfcRCLGA0CIAIoAhQhASADQQEQhC4gAigCECACKAIUakHUADoAACACIAFBAWo2AhQgAigCHCEEIAIgAigCICIBQYCU69wDayABIAFB/5Pr3ANLIgUbIgE2AiggAyAEQZAcbhCLGA0CIAIoAhQhBiADQQEQhC4gAigCECACKAIUakE6OgAAIAIgBkEBajYCFCADIARBPG4iBkE8cBCLGA0CIAIoAhQhCCADQQEQhC4gAigCECACKAIUakE6OgAAIAIgCEEBajYCFCADIAQgBkE8bGsgBWoQixgNAgJAIAFFDQAgASABQcCEPW4iBEHAhD1sRgRAIAJBATYCRCACQZDEhQE2AkAgAkEBNgI0IAJBiMSFATYCMCACQQE2AjwgAkE7NgJMIAIgBDYCLCACIAJByABqNgI4IAIgAkEsajYCSCADIAJBMGoQ7jwNBAwBCyABIAFB6AduIgRB6AdsRgRAIAJBATYCRCACQajEhQE2AkAgAkEBNgI0IAJBiMSFATYCMCACQQE2AjwgAkE7NgJMIAIgBDYCLCACIAJByABqNgI4IAIgAkEsajYCSCACQQxqIAJBMGoQ7jwNBAwBCyACQQE2AkQgAkHAxIUBNgJAIAJBATYCNCACQYjEhQE2AjAgAkEBNgI8IAJBOzYCTCACIAJByABqNgI4IAIgAkEoajYCSCACQQxqIAJBMGoQ7jwNAwsgAkGAgoQINgAwIAJBMGogAkEMaiAHEP4HDQIgACACKQIMNwIAIABBCGogAkEUaigCADYCACACQdAAaiQADwsgBCACKAI4Qay9hQEQ/S8ACyABQd0FQdTDhQEQwyEAC0HYxIUBQTQgAkEwakHEvIUBQYzFhQEQ1R4AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQzAsgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDMCyADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQnwogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCfCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ0QkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDRCSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ4gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDiDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxgkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDGCSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQygogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDKCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQigwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCKDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ2gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDaDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ4wwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDjDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQzQogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDNCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ7QwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDtDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQugkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARC6CSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQrQogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCtCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ9gogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARD2CiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ3QogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDdCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxAogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDECiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQyQ0gAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDJDSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ5AwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDkDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxwogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDHCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ7gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDuDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC54HAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgBCACNgIsIAIgASgCFCIATw0LIAQgASgCECACai0AADoAKyADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBK2ogAxDBGCECDAoLIARBK2ogAxC1HCECDAkLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akGGjJgwNgIAIARChoyYsODAgYMGNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgFJDQUMCAsgACgCBCEAIAQgAjYCLCACIAAoAhQiAUkNBQwHCyAEQThqQYaMmDA2AgAgBEKGjJiw4MCBgwY3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEE4akGGjJgwNgIAIARChoyYsODAgYMGNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5CyECIARBFGoQ5RAMAwsgBEEraiADELYcIQIMAgsgBCAAKAIQIAJqMQAANwMAIARBOGpBhoyYMDYCACAEQoaMmLDgwIGDBjcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAQsgBCAAKAIQIAJqMQAANwMIIARBOGpBhoyYMDYCACAEQoaMmLDgwIGDBjcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAAsgBEHQAGokACACDwsgBCABNgJMDAELIAQgADYCTAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIgIARBOzYCGCAEIARBFGo2AjggBCAEQcwAajYCHCAEIARBLGo2AhQgBEEwakHIl4QBEO8sAAueBwEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAQgAjYCLCACIAEoAhQiAE8NCyAEIAEoAhAgAmotAAA6ACsgAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQStqIAMQxRUhAgwKCyAEQStqIAMQtRwhAgwJCyAAKAIEIQAgBCACNgIsIAIgACgCFCIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBgoSIEDYCACAEQoKEiJCgwICBAjcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIQAgBCACNgIsIAIgACgCFCIBSQ0FDAgLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgFJDQUMBwsgBEE4akGChIgQNgIAIARCgoSIkKDAgIECNwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBgoSIEDYCACAEQoKEiJCgwICBAjcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBK2ogAxC2HCECDAILIAQgACgCECACajAAADcDACAEQThqQYKEiBA2AgAgBEKChIiQoMCAgQI3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACajAAADcDCCAEQThqQYKEiBA2AgAgBEKChIiQoMCAgQI3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALiQgCBn8DfiMAQaABayICJAAgAUEMahDZPCEDIAJBCGogARCSNhDuJSADIQQCQAJAAkACQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiAgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIgATYCQCACIAM2AjggAiAFNgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAwNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogAxC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDODSACKAKIASIBQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIANFDQBBACEEA0AgAkHQAGogAkE0aiAEEM4NIAIoAlAiAUGTgICAeEcNAiADIARBAWoiBEcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHYAGoiBSkCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBDYCVCACIAY2AlAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBDYCkAEgAiAGNgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQwR0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgATYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALiQgCBn8DfiMAQaABayICJAAgAUEMahDZPCEDIAJBCGogARCSNhDuJSADIQQCQAJAAkACQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiAgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIgATYCQCACIAM2AjggAiAFNgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAwNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogAxC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDPDSACKAKIASIBQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIANFDQBBACEEA0AgAkHQAGogAkE0aiAEEM8NIAIoAlAiAUGTgICAeEcNAiADIARBAWoiBEcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHYAGoiBSkCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBDYCVCACIAY2AlAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBDYCkAEgAiAGNgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQ2B0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgATYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQAL5xoCEX8BfiMAQdAAayICJAAgAiABNgIUAkAgAkEUaiIBEKo7RQRAIAEgAkEYakGQxsMAENELIQEgAEECNgIAIAAgATYCBCACKAIUIgBBhAFJDQEgABDyHwwBCyACKAIUIQEgAkEYaiIEQezKwwA2AgggBCABNgIQIARBADYCACAEQZzLwwA2AgwgAkGBgICAeDYCLCACQYGAgIB4NgI4IAJBxABqIAQQ9hACQAJAIAItAERFBEBBAiELQQIhDEECIQ1BAiEOA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0ARUEBaw4HAwQFBgcCAAELIAAgAikCPDcCMCAAIAIpAjA3AiQgACAPNgIcIAAgEDYCFCAAIBE2AgwgACASNgIEIABBgICAgHggAigCOCIBIAFBgYCAgHhGGzYCLCAAQYCAgIB4IAIoAiwiASABQYGAgIB4Rhs2AiAgACAOQQAgDkECRxs2AhggACANQQAgDUECRxs2AhAgACAMQQAgDEECRxs2AgggACALQQAgC0ECRxs2AgAMDgsgC0ECRg0IQbzKwwBBCRCOJCEBDAwLIAJBGGoiBCgCACAEQQA2AgAgBCgCBBClLyIBQYQBTwRAIAEQ8h8LIAJBCGpBADYCAAwICyACKAIsQYGAgIB4RwRAQcXKwwBBCRCOJCEBDAsLIAIoAhggAkEANgIYIAJBxABqIQggAigCHBClLyEEIwBBEGsiCiQAIAogBDYCAAJAIAoQzyxFBEAgCkEEaiEBIwBBIGsiCSQAIAkgBDYCDAJAIAlBDGoiBhDuOgRAIAlBEGoiBCAGENEvIAlBADYCHEEAIQMjAEEgayIHJAAgBCgCAARAIAQoAggiAyAEKAIEayIGQQAgAyAGTxshAwsgB0EUaiIGQYCAECADIANBgIAQTxtBAEEEQQQQoBggBygCGCEDAkAgBygCFEEBRwRAIAdBADYCECAHIAcoAhw2AgwgByADNgIIIAYgBBCXHwJAAkAgBygCFCIDQQJHBEADQCADQQFxRQ0CIAcoAhghBiAHKAIQIgMgBygCCEYEQCAHQQhqQbikwwAQlygLIAcoAgwgA0ECdGogBjYCACAHIANBAWo2AhAgB0EUaiAEEJcfIAcoAhQiA0ECRw0ACwsgASAHKAIYNgIEIAFBgICAgHg2AgAgB0EIahDpOwwBCyABIAcpAgg3AgAgAUEIaiAHQRBqKAIANgIACyAHQSBqJAAMAQsgAyAHKAIcQaikwwAQ/S8ACwwBCyAJQRBqIAlBDGoQxxIgCSgCECEGAkACQAJAIAktABQiBEECaw4CAQACCyABQYCAgIB4NgIAIAEgBjYCBAwCCyAJQQxqIAlBEGpBoMbDABDRCyEEIAFBgICAgHg2AgAgASAENgIEDAELIwBBIGsiAyQAIAMgBEEBcToABCADIAY2AgAgA0EUaiIEQQBBAEEEQQQQoBggAygCGCEGAkAgAygCFEEBRwRAIANBADYCECADIAMoAhw2AgwgAyAGNgIIIAQgAxDOGwJAAkACQCADKAIUIgRBAkcEQANAIARBAXFFDQIgAygCGCEEIAMoAhAiBiADKAIIRgRAIANBCGpBuKTDABCXKAsgAygCDCAGQQJ0aiAENgIAIAMgBkEBajYCECADQRRqIAMQzhsgAygCFCIEQQJHDQALCyABIAMoAhg2AgQgAUGAgICAeDYCACADQQhqEOk7IAMoAgAiBEGDAUsNAQwCCyABIAMpAgg3AgAgAUEIaiADQRBqKAIANgIAIAMoAgAiBEGEAUkNAQsgBBDyHwsgA0EgaiQADAELIAYgAygCHEGopMMAEP0vAAsLIAkoAgwiAUGDAUsEQCABEPIfCyAJQSBqJAAgCigCBEGAgICAeEYEQCAIIAooAgg2AgQgCEGBgICAeDYCAAwCCyAIIAopAgQ3AgAgCEEIaiAKQQxqKAIANgIADAELIAhBgICAgHg2AgAgBEGEAUkNACAEEPIfCyAKQRBqJAAgAigCSCEBIAIoAkQiBkGBgICAeEYNCiACKAJMIQQgAigCLEGBgICAeEcEQCACQSxqEJcwCyACIAQ2AjQgAiABNgIwIAIgBjYCLAwHCyAMQQJGDQRBzsrDAEEFEI4kIQEMCQsgDUECRg0CQdPKwwBBBhCOJCEBDAgLIAIoAjhBgYCAgHhHBEBB2crDAEEHEI4kIQEMCAsgAigCGCACQQA2AhggAkHEAGohCiACKAIcEKUvIQQjAEEQayIJJAAgCSAENgIAAkAgCRDPLEUEQCAJQQRqIQEjAEEgayIHJAAgByAENgIMAkAgB0EMaiIGEO46BEAgB0EQaiIEIAYQ0S8gB0EANgIcQQAhBiMAQSBrIgUkACAEKAIABEAgBCgCCCIDIAQoAgRrIgZBACADIAZPGyEGCyAFQRRqQdWqBSAGIAZB1aoFTxtBAEEEQQwQoBggBSgCGCEGAkAgBSgCFEEBRwRAIAVBADYCECAFIAUoAhw2AgwgBSAGNgIIAkADQAJAIAVBFGohAyMAQSBrIggkAAJAAkAgBCgCAEUNACAIQQhqIAQQuyggCCgCCEEBcUUNACAIKAIMIQYgBCAEKAIMQQFqNgIMIAhBFGogBhC0PSAIKAIUQYCAgIB4RgRAIAMgCCgCGDYCBCADQYGAgIB4NgIADAILIAMgCCkCFDcCACADQQhqIAhBHGooAgA2AgAMAQsgA0GAgICAeDYCAAsgCEEgaiQAAkACQCAFKAIUIgNBgICAgHhrDgICAAELIAEgBSgCGDYCBCABQYCAgIB4NgIAIAVBCGoiARDRKyABEOg7DAMLIAUpAhghEyAFKAIQIgggBSgCCEYEQCAFQQhqELwoCyAFKAIMIAhBDGxqIgYgEzcCBCAGIAM2AgAgBSAIQQFqNgIQDAELCyABIAUpAgg3AgAgAUEIaiAFQRBqKAIANgIACyAFQSBqJAAMAQsgBiAFKAIcQaikwwAQ/S8ACwwBCyAHQRBqIAdBDGoQxxIgBygCECEGAkACQAJAIActABQiBEECaw4CAQACCyABQYCAgIB4NgIAIAEgBjYCBAwCCyAHQQxqIAdBEGpBsMbDABDRCyEEIAFBgICAgHg2AgAgASAENgIEDAELIwBBIGsiBSQAIAUgBEEBcToABCAFIAY2AgAgBUEUakEAQQBBBEEMEKAYIAUoAhghBAJAIAUoAhRBAUcEQCAFQQA2AhAgBSAFKAIcNgIMIAUgBDYCCAJAAkADQAJAIAVBFGohAyMAQSBrIggkACAIQQhqIAUQ/CkCQAJAIAgoAggiBEECRwRAIAgoAgwhBiAEQQFxRQ0BIANBgYCAgHg2AgAgAyAGNgIEDAILIANBgICAgHg2AgAMAQsgCEEUaiAGELQ9IAgoAhQiBEGAgICAeEcEQCADIAgpAhg3AgQgAyAENgIADAELIAgoAhghBCADQYGAgIB4NgIAIAMgBDYCBAsgCEEgaiQAAkACQCAFKAIUIgZBgICAgHhrDgICAAELIAEgBSgCGDYCBCABQYCAgIB4NgIAIAVBCGoiARDRKyABEOg7IAUoAgAiAUGDAUsNAwwECyAFKQIYIRMgBSgCECIDIAUoAghGBEAgBUEIahC8KAsgBSgCDCADQQxsaiIEIBM3AgQgBCAGNgIAIAUgA0EBajYCEAwBCwsgASAFKQIINwIAIAFBCGogBUEQaigCADYCACAFKAIAIgFBhAFJDQELIAEQ8h8LIAVBIGokAAwBCyAEIAUoAhxBqKTDABD9LwALCyAHKAIMIgFBgwFLBEAgARDyHwsgB0EgaiQAIAkoAgRBgICAgHhGBEAgCiAJKAIINgIEIApBgYCAgHg2AgAMAgsgCiAJKQIENwIAIApBCGogCUEMaigCADYCAAwBCyAKQYCAgIB4NgIAIARBhAFJDQAgBBDyHwsgCUEQaiQAIAIoAkghASACKAJEIgZBgYCAgHhGDQcgAigCTCEEIAIoAjhBgYCAgHhHBEAgAkE4ahCYMAsgAiAENgJAIAIgATYCPCACIAY2AjgMBAsgDkECRwRAQeDKwwBBCxCOJCEBDAcLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiDyEBIAIoAkQiDkECRw0DDAYLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiECEBIAIoAkQiDUECRw0CDAULIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiESEBIAIoAkQiDEECRw0BDAQLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiEiEBIAIoAkQiC0ECRg0DCyACQcQAaiACQRhqEPYQIAItAERFDQALCyACKAJIIQELIABBAjYCACAAIAE2AgQgAigCOEGBgICAeEcEQCACQThqEJgwCyACKAIsQYGAgIB4Rg0AIAJBLGoQlzALIAIoAigiAEGEAU8EQCAAEPIfCyACKAIYRQ0AIAIoAhwiAEGEAUkNACAAEPIfCyACQdAAaiQAC5AHAg1/AX5BVCEHAkAgBa0gAkECaiIFrUIBIAOthnxCAYZCfINCCHxUDQBBASADdCIKQQN2IApBAXYiBmpBA2ohDiAGQQEgAxshECACQQFqIQsgAEEEaiERIAQgAkEBdGpBBGohDCAAIAI7AQIgACADOwEAIARBADsBAEEBIAUgBUEBTRtBAWshDyAEIQUgASEGIApBAWsiDSEJA0AgCCAPRkUEQCAFLwEAIQcCQCAGLwEAIhJB//8DRgRAIAVBAmogB0EBajsBACAJIAxqIAg6AAAgCUEBayEJDAELIAVBAmogByASajsBAAsgBUECaiEFIAZBAmohBiAIQQFqIQgMAQsLIAQgC0EBdGogCkEBajsBAAJAIAkgDUcEQEEAIQVBACEGA0AgBiALRg0CQQAhCCABIAZBAXRqLgEAIgJBACACQQBKGyECA0AgAiAIRkUEQCAFIAxqIAY6AAADQCAFIA5qIA1xIgUgCUsNAAsgCEEBaiEIDAELCyAGQQFqIQYMAAsACyAKIAxqIQggBCAKIAJBAXRqaiEJQQAhB0EAIQIDQCAHIAtGBEAgDkEBdCECQQAhB0EAIQYDQCAGIApPDQNBACEFIAchCQNAIAVBAkZFBEAgDCAJIA1xaiAFIAhqLQAAOgAAIAkgDmohCSAFQQFqIQUMAQsLIAhBAmohCCAGQQJqIQYgAiAHaiANcSEHDAALAAUgAiAIaiATNwAAIAIgCWohDyABIAdBAXRqLgEAIQZBCCEFA0AgBSAGTkUEQCAFIA9qQQRqIBM3AAAgBUEIaiEFDAELCyATQoGChIiQoMCAAXwhEyAHQQFqIQcgAiAGaiECDAELAAsAC0EAIQUDQCAFIApGBEAgA0EfayEEIBBBAnQgAGpBCGohBSADQRB0IAprIgNBgIAEaiEGQQAhB0EAIQADQCALRQ0DAkACQAJAAkACQCABLwEAIgIOAgACAQsgBSAGNgIADAMLIAJB//8DRw0BCyAFIAM2AgAgBUEEayAAQQFrNgIAIABBAWohAAwBCyAFQQRrIAAgAsEiAms2AgAgBSAEIAJBAWtnaiIJQRB0IAIgCXRrNgIAIAAgAmohAAsgAUECaiEBIAVBCGohBSALQQFrIQsMAAsABSAEIAUgDGotAABBAXRqIgIgAi8BACICQQFqOwEAIBEgAkEBdGogBSAKajsBACAFQQFqIQUMAQsACwALIAcLuwcCBH8DfiMAQcAEayICJAACQAJAAkACQAJAAkACQCABKQMAIgZCAlYNAAJAIAanQQFrDgIBAAILIAEoAhghAyABQQA2AhggAwRAIAJBsAJqIAMoAvwBIAMoAvgBIAEpAxAQhRkgAigCsAIiBEEIRwRAIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBDYCACADEPwsIANBiAJBCBD4OgwICyABIAEpAwggAzQC/AF8NwMIIAEgASkDECADNAL8AX03AxAgAxD8LCADQYgCQQgQ+DoMBgsgAkGwAmogASgCQEEIaiABKQMIEOEwIAJBGGoiAyACQbwCaikCADcDACACIAIpArQCNwMQIAIoArACIgRBCEcEQCACKALEAiEBIAAgAikDEDcCBCAAIAE2AhQgACAENgIAIABBDGogAykDADcCAAwHCyACQQhqIAMpAwA3AwAgAiACKQMQNwMAIAJBsAJqIAIgASgCHCABLQAgEPETIAIpA7gCIgZCBFEEQCACQagCaiACQdACaikDACIGNwMAIAJBoAJqIAJByAJqKQMAIgc3AwAgAiACKQPAAiIINwOYAiAAQRBqIAY3AwAgAEEIaiAHNwMAIAAgCDcDAAwFCyACQaACaiIEIAJByAJqKQMANwMAIAJBqAJqIgUgAkHQAmopAwA3AwAgAiACKQPAAjcDmAIgAigCsAIhAyACQTBqIAJB2AJqQegB/AoAACACQSBqIAQpAwA3AwAgAkEoaiAFKQMANwMAIAIgBjcDECACIAIpA5gCNwMYIAJBsAJqIAMgASkDEBCOGiACKAKwAiIEQQhHBEAMBAsgAkGwAmogAigCjAIgAigCiAIgASkDEBCFGSACKAKwAiIEQQhHBEAMBAsgASACNAKMAiADrXwiBiABKQMIfDcDCCABIAEpAxAgBn03AxAgAkEQahD8LCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAULIAFCADcDAAwBCyACQbACaiABQSBqEOEcIAIpA7ACUA0AIAEgASgCNEEBajYCNAsgAEEINgIADAMLIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBDYCACACQRBqEPwsCyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELAkAgAS0AIEUEQCABIAEoAhxBAWo2AhwMAQsgAUEAOgAgCyAAQQg2AgALIAJBwARqJAALhwgCBX8BfiMAQdAAayIEJAAgBEEsaiABIAIQ8RUCQCAEKAIsIgVBk4CAgHhHBEAgACAEKQI0NwIIIABBEGogBEE8aigCADYCACAAIAQoAjA2AgQgACAFNgIADAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAItACgiBUEUaw4VBAEEAgQEAgkBBgkBAwgBAQEBAQkKAAsgBUUNCgsgARDqKSABEOopDAkLIAJBKGohBSADKAIMIgIEQCADIAJBAWs2AgwgAyADKAIIIgZBAWoiByADKAIAIghBACAHIAhPG2s2AgggAygCBCAGQQN0aikDAEICfCEJCyAEQQI2AjAgBEHc1v4ANgIsIARCATcCOCAEQacENgJIIAQgBTYCTCAEIARBxABqNgI0IAQgBEHMAGo2AkQgBEEcaiAEQSxqEJkOIARBjICAgHg2AhggAg0CIAQpAhwhCSAAIAQpAiQ3AgwgACAJNwIEIABBjICAgHg2AgAMCQsgARDqKSAEQQhqIAJBLGoQry4gBCgCCCICIAQoAgwiBUYNBwwDC0EDIQIDQCABEOopIAJBAWsiAg0ACwwGCyAEQRhqEIgRIAlCAFcNBQNAIAEQ6ikgCUIBfSIJUEUNAAsMBQsgARDqKSAEQSxqIAEgAigCMEEIaiADEMoHIAQoAiwiAUGTgICAeEYNBCAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwFCwNAAkAgBEEsaiABIAIoAgBBCGogAxDKByAEKAIsIgZBk4CAgHhHDQAgBSACQQRqIgJHDQEMBQsLIAAgBCkCMDcCBCAAQQxqIARBOGopAgA3AgAgACAGNgIADAQLIAEQ6ikgAi0AKQRAIAEQ6ikLIARBEGogAkEsahCwLiAEKAIQIgIgBCgCFCIFRg0CA0AgBEEsaiABIAJBBGooAgBBCGogAxDKByAEKAIsIgZBk4CAgHhHBEAgACAEKQIwNwIEIABBDGogBEE4aikCADcCACAAIAY2AgAMBQsgBSACQQhqIgJHDQALDAILIAEQ6ikgARDqKSAEQSxqIAEgAigCLEEIaiADEMoHIAQoAiwiAUGTgICAeEYNASAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwCCyAEQSxqIAEgAigCLEEIaiADEMoHIAQoAiwiBUGTgICAeEcEQCAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgBTYCAAwCCyAEQSxqIAEgAigCMEEIaiADEMoHIAQoAiwiAUGTgICAeEYNACAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwBCyAAQZOAgIB4NgIACyAEQdAAaiQAC+4HAQ9/IwBBQGoiAyQAAkACQAJAIAAoAgAiC0ECRgRAIAAoAhAhAiAALQAkIQQgA0E0aiAAKAIUIgZBAEEBQQEQoBggAygCOCEIIAMoAjRFDQEgCCADKAI8QeSjzwAQ/S8ACyAAKAIkIQQgAC0AMCEMIAAoAiwhCCAAKAIoIQkCQAJAAkACQCAALQAgIgJBAWsOAwECAAMLQZ+6zwBBK0HMus8AEJ8pAAtBASECDAELQQIhAgsgACgCDCEFIANBNGogACgCECIGQQBBAUEBEKAYIAMoAjghByADKAI0QQFGDQEgAygCPCEKIAYEQCAKIAUgBvwKAAALIAAoAgQhDSAALQAhIANBNGoiDyAAEIkZQQJ0IgBBrOTPAGooAgAhDiAAQdDjzwBqKAIAIRACQCADLQA0QRFHBEAgA0EMaiAPEP0TDAELIANBEjYCDAsgASgCCCIFIAEoAgBGBEAgAUGgwc8AEJ8oCyABKAIEIAVB4ABsaiIAIA02AjwgACALQQBHNgI4IAAgCDYCNCAAIAhBf3NBH3Y2AjAgACAJNgIsIAAgCUF/c0EfdjYCKCAAIBA2AiQgACAONgIgIABBADYCGCAAIAI2AhQgAEEBNgIQIAAgBDYCDCAAIARBf3NBH3Y2AgggACAMNgIEIABBATYCACAAIAMpAgw3AkAgAEHIAGogA0EUaikCADcCACAAQdAAaiADQRxqKAIANgIAIAAgBjYCXCAAIAo2AlggACAHNgJUIAEgBUEBajYCCAwCCyAEQQJ0IgRBwOPPAGooAgAhCiAEQbDjzwBqKAIAIQUgAygCPCEJIAYEQCAJIAIgBvwKAAALIAAoAgghCyAAKAIEIQwgACgCMCEEIAAtACUgA0E0aiIHIABBBGoQiRlBAnQiAkGs5M8AaigCACENIAJB0OPPAGooAgAhDgJAIAMtADRBEUcEQCADQSBqIAcQ/RMMAQsgA0ESNgIgCyABKAIIIgcgASgCAEYEQCABQbDBzwAQnygLIAEoAgQgB0HgAGxqIgIgCzYCPCACIAw2AjggAkEANgIwIAJBADYCKCACIA42AiQgAiANNgIgIAIgBDYCHCACQQE2AhggAiAFNgIUIAIgCjYCECACQQA2AgggAkEANgIAIAIgAykCIDcCQCACIAY2AlwgAiAJNgJYIAIgCDYCVCACQcgAaiADQShqKQIANwIAIAJB0ABqIANBMGooAgA2AgAgASAHQQFqNgIIIARFDQEgACgCLCEAIARBAnQhAgNAIAAoAgBBCGogARDLByAAQQRqIQAgAkEEayICDQALDAELIAcgAygCPEHko88AEP0vAAsgA0FAayQAC4wHAgt/CX4jAEGAAWsiBiQAIAYgACgCCCIHNgIIIAYgASACaiIIQQFqIgI2AgwCQAJAAkACQAJAIAIgB0YEQCAAIAMgAUEBaiIJaiIHEIctIAA1AhQhFSAGQRBqIAQgBRDgHCAGQgA3A3ggBiABNgJwIAYgCDYCdCABIAhPDQEgBigCaCEMIAYpAzAhEyAGKAJkIQogBigCYCEFIAYpA1AhESAGKQNAIRQgBigCICENIAYpAxghEiAGKAI4IQ8gBigCKCEQIAYpA1ghGCAGKQNIIRkgBikDECEWAkACQAJAA0AgFqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIBJQRQ0BQgAhEkIAIRZBASECDAQLAn4CQCAUQgJ9IhdCAVgEQCAXp0EBaw0BDAULIBSnIBRQrUIBhiEUQQFxRQ0AIBkMAQsgEUIDUQRAQgMhEQwECyAFRSAFIApGckUEQCAKQQhrIgopAwAMAQtBACEFIBFCAlEEQEICIREMBAsgEadCACERQQFxRQ0DIBgLIRJCASEWIAxBQGoiDCENDAELIA0gEnmnQT9zIgJqIQNCASACrYYgEoUhEgwDC0EAIQIMAQsLIBAgE0IAUnFFDQYgDyATeadBP3MiAmohA0IBIAKthiAThSETCyAIQQFrIgQgA0sEQEGYy9AAQShBwMvQABCfKQALIAMgB0kEQCAIIAAoAggiAk8NAiACIAdJDQMgACgCBCILIARBA3RqKQMAIRUgCyADQQN0Ig5qQQhqIgIgCyAHQQN0IgdqRwRAIAsgCEEDdGopAwAhFyAHIA5rQQhrIQcDQCACIBc3AwAgAkEIaiECIAdBCGsiBw0ACwsgAyAERg0IIAMgACgCCCICTw0EIAAoAgQgDmogFTcDACADIQcgBCIIIAFNDQcMAQsLQdDL0ABBJkH4y9AAEJ8pAAsgCCACQYjM0AAQwyEACyAHIAJBmMzQABCwOwALIAMgAkGozNAAEMMhAAsgBkEANgIQQQAgBkEIaiAGQQxqIAZBEGpB6MrQABCvKwALIAchAwsgAyAJSQ0BIAMgACgCCCICSw0CIAMgCUYNACADQQN0IAFBA3RrQQhrIQcgACgCBCAJQQN0aiECA0AgAiAVNwMAIAJBCGohAiAHQQhrIgcNAAsLIAZBgAFqJAAPCyAJIANBiMvQABCxOwALIAMgAkGIy9AAELA7AAuMBwIMfwh+IwBBgAFrIgYkACAGIAAoAggiBzYCCCAGIAEgAmoiCEEBaiICNgIMAkACQAJAAkACQCACIAdGBEAgACADIAFBAWoiCWoiBxCGLSAAKAIUIQogBkEQaiAEIAUQ4BwgBkIANwN4IAYgATYCcCAGIAg2AnQgASAITw0BIAYoAmghDSAGKQMwIRQgBigCZCELIAYoAmAhBSAGKQNQIRIgBikDQCEVIAYoAiAhDiAGKQMYIRMgBigCOCEQIAYoAighESAGKQNYIRcgBikDSCEYIAYpAxAhFgJAAkACQANAIBanQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCATUEUNAUIAIRNCACEWQQEhAgwECwJ+AkAgFUICfSIZQgFYBEAgGadBAWsNAQwFCyAVpyAVUK1CAYYhFUEBcUUNACAYDAELIBJCA1EEQEIDIRIMBAsgBUUgBSALRnJFBEAgC0EIayILKQMADAELQQAhBSASQgJRBEBCAiESDAQLIBKnQgAhEkEBcUUNAyAXCyETQgEhFiANQUBqIg0hDgwBCyAOIBN5p0E/cyICaiEDQgEgAq2GIBOFIRMMAwtBACECDAELCyARIBRCAFJxRQ0GIBAgFHmnQT9zIgJqIQNCASACrYYgFIUhFAsgCEEBayIEIANLBEBBmMvQAEEoQcDL0AAQnykACyADIAdJBEAgCCAAKAIIIgJPDQIgAiAHSQ0DIAAoAgQiDCAEQQJ0aigCACEKIAwgA0ECdCIPakEEaiICIAwgB0ECdCIHakcEQCAMIAhBAnRqKAIAIQggByAPa0EEayEHA0AgAiAINgIAIAJBBGohAiAHQQRrIgcNAAsLIAMgBEYNCCADIAAoAggiAk8NBCAAKAIEIA9qIAo2AgAgAyEHIAQiCCABTQ0HDAELC0HQy9AAQSZB+MvQABCfKQALIAggAkGIzNAAEMMhAAsgByACQZjM0AAQsDsACyADIAJBqMzQABDDIQALIAZBADYCEEEAIAZBCGogBkEMaiAGQRBqQejK0AAQrysACyAHIQMLIAMgCUkNASADIAAoAggiAksNAiADIAlGDQAgA0ECdCABQQJ0a0EEayEHIAAoAgQgCUECdGohAgNAIAIgCjYCACACQQRqIQIgB0EEayIHDQALCyAGQYABaiQADwsgCSADQYjL0AAQsTsACyADIAJBiMvQABCwOwALlggBCH8jAEHQAGsiAiQAIAJBOGogARDwJyACQShqIgMgAkHEAGoiBSgCADYCACACIAIpAjw3AyACQCACKAI4IgZBBEcEQCACKAJIIQEgACACKQMgNwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADAELIAJBEGogAygCADYCACACIAIpAyA3AwggAkEIahCGMCACQThqIAEQ0wkgAyAFKQIANwMAIAJBMGoiBiACQcwAaigCADYCACACIAIpAjw3AyACQCACKAI4RQRAIAJBPGohB0EAIQVBAyEDA0AgAkEYaiAGKAIAIgQ2AgAgAkEQaiACQShqIggpAwA3AwAgAiACKQMgNwMIAkACQCAEQf8BcQRAIAJBOGogAkEIahD8FyACLwE8IQQgAigCOCIJQQRHBEAgACACKQE+NwEGIABBDGogAkHEAGopAQA3AQAgACAEOwEEIAAgCTYCAAwGCwJAAkACQAJAIARBAWsOAwABAgMLIAJBOGogARD6CiACKAI4IgRBBEYNBCAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAQ2AgAMCAsgAkE4aiABEPoKIAIoAjgiBEEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgBDYCAAwIC0EBIAMgA0H/AXFBA0YbIQMMBAsgAkE4aiABEPoKIAIoAjgiBEEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgBDYCAAwHC0ECIAMgA0H/AXFBA0YbIQMMAwsgAkE4aiABIAItABhBwAAQyQIgAigCOCIEQQRGDQIgACACKQI8NwIEIABBDGogAkHEAGopAgA3AgAgACAENgIADAULIAJBCGoQhjAgAkE4aiABEKgpIAIoAjgiAUEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgATYCAAwGCyAFRQRAIABBBGpBxP/PAEEpEKIfIABBATYCAAwGCyAFQQFMBEAjAEEgayIBJAACQCADQf8BcUEDRwRAIABBBDYCACAAIAM6AAQMAQsgAUEQakGkgNAAQSkQoh8gAEEIaiABQRRqKQIANwIAIABBEGogAUEcaigCADYCACABQQE2AgwgACABKQIMNwIACyABQSBqJAAMBgsgAEEEakHt/88AQTcQoh8gAEEBNgIADAULIANBACADQf8BcUEDRxshAwsgAkEIahCGMCACQThqIAEQ0wkgCCAHQQhqKQIANwMAIAYgB0EQaigCADYCACACIAcpAgA3AyAgBUEBaiEFIAIoAjhFDQALCyAAIAIpAyA3AgAgAEEQaiAGKAIANgIAIABBCGogAkEoaikDADcCAAwBCyACQQhqEIYwCyACQdAAaiQAC7cRAg5/AX4jAEHwAWsiBCQAIARBEGogASACKAIQEQAAIARBoAFqIgEgBCgCECIKIAQoAhQoAgwRAAACQAJAIApFDQAgBCkDoAFCkJ6z7tm0jZLpAIUgBCkDqAFCiPSrgeCxxeTCAIWEUEUNACABIAoQtBQjAEHwAGsiBSQAIAVByABqIgIgAUEUaigCADYCACAFQdQAaiIGIAFBIGooAgA2AgAgBUHgAGoiByABQSxqKQIANwMAIAVB6ABqIgggAUE0aikCADcDACAFIAEpAgw3A0AgBSABKQIYNwJMIAUgASkCJDcDWCABELMMIAVBEGogAigCADYCACAFQSBqIAYoAgA2AgAgBUEwaiAHKQMANwMAIAVBOGogCCkDADcDACAFIAUpA0A3AwggBSAFKQJMNwMYIAUgBSkDWDcDKCAEQRxqIQYgBUEoaiEIIwBB4ABrIgIkACACIAVBCGoiCSgCCEECdkEBayIQNgIAIAJBIGohByMAQeAAayIBJAAgAUEIaiAFQRhqIg0Q3DsgAUEUaiABKAIIIAEoAgwQnQkCQCABKAIUQQFGBEAgASABKQIYNwM4IAFBATYCRCABQYjSgAE2AkAgAUIBNwJMIAFBsAM2AlwgASABQdgAajYCSCABIAFBOGo2AlggAUEoaiABQUBrEJkOIAEpAighEiAHIAEpAjA3AgwgByASNwIEIAdBjYCAgHg2AgAMAQsgCSgCCCILQQRPBEAgASgCHCEMIAEoAhghESAJKAIEIQ4gC0F8cSEPA0AgASAOKAIAIgs2AiACQCALRQ0AIAsgDE8EQCALIAxGDQEgASAMNgIUIAFBAjYCRCABQbTRgAE2AkAgAUICNwJMIAFBOzYCMCABQTs2AiggASABQSRqNgJIIAEgAUEUajYCLCABIAFBIGo2AiQgB0EEaiABQUBrEJkOIAdBjYCAgHg2AgAMBAsgCyARaiwAAEG/f0oNACABQQE2AkQgAUHk0YABNgJAIAFCATcCTCABQTs2AiggASABQSRqNgJIIAEgAUEgajYCJCAHQQRqIAFBQGsQmQ4gB0GNgICAeDYCAAwDCyAOQQRqIQ4gD0EEayIPDQALCyAHQZOAgIB4NgIACyABQeAAaiQAAkACQAJAIAIoAiAiAUGTgICAeEYEQAJAIAgoAgAiAQRAIBAgCCgCECIHRw0BCyACQShqQZiw4MABNgIAIAJBNGogCUEIaigCADYCACACQUBrIA1BCGooAgA2AgAgAkHMAGogCEEIaikCADcCACACQdQAaiAIQRBqKQIANwIAIAJCmLDgwIGDhowYNwMgIAIgCSkCADcCLCACIA0pAgA3AzggAiAIKQIANwJEIAYgAkEgakE8/AoAAAwECyACIAc2AhwgAkEENgIIIAJBjPeAATYCBCACQgQ3AhAgAkE7NgI8IAJBOzYCNCACQcwBNgIsIAJByPaAATYCKCACQcwBNgIkIAJBrPeAATYCICACIAJBIGo2AgwgAiACQRxqNgI4IAIgAjYCMCAGQQhqIAJBBGoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMAQsgBiACKQIkNwIIIAZBEGogAkEsaikCADcCACAGQSk6AAAgBiABNgIEIAgoAgAiAUUNAQsgASABKAIAIgFBAWs2AgAgAUEBRw0AIAgQ+x4LIA0oAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIA0Q+x4LIAkoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0AIAkQ+x4LIAJB4ABqJAAgBUHwAGokAAJAAkAgBC0AHEEpRgRAIARB6ABqIARBMGooAgA2AgAgBEHgAGogBEEoaikCADcDACAEIAQpAiA3A1ggAy0ANA0BIAAgBEEgaiIBKQIANwIAIABBEGogAUEQaigCADYCACAAQQhqIAFBCGopAgA3AgAMBAtBxABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAEQRxqQTz8CgAAIABB0Pv/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyAKENM6IQEgBEEIaiAKEKwqIARB7ABqIAEgBCgCDBCmFCAKENM6IQUgBEGkAWoiDSAKEPk0IAQgBTYCwAEgBEEANgK8ASAEIAo2AqABIAQoAqQBIQMgBQRAIARB+ABqIQsgBEGEAWohB0EAIQIDQAJAAkACQAJAAkACQCADRQ0AIAIgBCgCtAFPDQIgBCgCqAEgBCgCsAEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAQgAkEBaiICNgK8AQwBCyAEIAJBAWoiATYCvAEgBCAKIAIQjywgBEHkAWogBCgCACAEKAIEEJ0JIAQoAuQBRQ0CIAEhAgsgBxDmOiAEKAKEAUUNAiAEKAKUAUEBaiIIQQN2IAhBB3FBAEdqIgEgBCgCkAEiBksEQCABIAZrIQkgBCgCiAEiDCABSQRAIAcgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAEKAKQASEGCyAJBEAgBCgCjAEgBmpBACAJ/AsACyAEIAE2ApABCyAEIAg2ApQBIAQoAnQhBiAEKAKAASIBIAQoAnhGBEAgC0HA9P8AEJ0oCyAEKAJ8IAFBAnRqIAY2AgAgBCABQQFqNgKAAQwDC0HM9v8AQSBB7Pb/ABCfKQALIARB7ABqIAQoAugBIAQoAuwBEL0SIAEhAgwBC0G49/8AELI7AAsgAiAFRw0ACwsCQCADRQ0AIAMgAygCACIBQQFrNgIAIAFBAUcNACANEPseCyAEQaABaiICIARB7ABqIgMQ7Q5BxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEHQ+/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuiwgBEHYAGoQiBEMAwtBBEHEABCjPQALQQRBxAAQoz0AC0GojoABELI7AAsgBEHwAWokAAu3EQIOfwF+IwBB8AFrIgQkACAEQRBqIAEgAigCEBEAACAEQaABaiIBIAQoAhAiCiAEKAIUKAIMEQAAAkACQCAKRQ0AIAQpA6ABQsKM9/bqy9zRhH+FIAQpA6gBQuWT9Jj5r/joqH+FhFBFDQAgASAKELIUIwBB8ABrIgUkACAFQcgAaiICIAFBFGooAgA2AgAgBUHUAGoiBiABQSBqKAIANgIAIAVB4ABqIgcgAUEsaikCADcDACAFQegAaiIIIAFBNGopAgA3AwAgBSABKQIMNwNAIAUgASkCGDcCTCAFIAEpAiQ3A1ggARCzDCAFQRBqIAIoAgA2AgAgBUEgaiAGKAIANgIAIAVBMGogBykDADcDACAFQThqIAgpAwA3AwAgBSAFKQNANwMIIAUgBSkCTDcDGCAFIAUpA1g3AyggBEEcaiEGIAVBKGohCCMAQeAAayICJAAgAiAFQQhqIgkoAghBA3ZBAWsiEDYCACACQSBqIQcjAEHgAGsiASQAIAFBCGogBUEYaiINENw7IAFBFGogASgCCCABKAIMEJ0JAkAgASgCFEEBRgRAIAEgASkCGDcDOCABQQE2AkQgAUGI0oABNgJAIAFCATcCTCABQbADNgJcIAEgAUHYAGo2AkggASABQThqNgJYIAFBKGogAUFAaxCZDiABKQIoIRIgByABKQIwNwIMIAcgEjcCBCAHQY2AgIB4NgIADAELIAkoAggiC0EITwRAIAEoAhwhDCABKAIYIREgCSgCBCEOIAtBeHEhDwNAIAEgDigCACILNgIgAkAgC0UNACALIAxPBEAgCyAMRg0BIAEgDDYCFCABQQI2AkQgAUG00YABNgJAIAFCAjcCTCABQTs2AjAgAUE7NgIoIAEgAUEkajYCSCABIAFBFGo2AiwgASABQSBqNgIkIAdBBGogAUFAaxCZDiAHQY2AgIB4NgIADAQLIAsgEWosAABBv39KDQAgAUEBNgJEIAFB5NGAATYCQCABQgE3AkwgAUE7NgIoIAEgAUEkajYCSCABIAFBIGo2AiQgB0EEaiABQUBrEJkOIAdBjYCAgHg2AgAMAwsgDkEIaiEOIA9BCGsiDw0ACwsgB0GTgICAeDYCAAsgAUHgAGokAAJAAkACQCACKAIgIgFBk4CAgHhGBEACQCAIKAIAIgEEQCAQIAgoAhAiB0cNAQsgAkEoakGZsuTIATYCACACQTRqIAlBCGooAgA2AgAgAkFAayANQQhqKAIANgIAIAJBzABqIAhBCGopAgA3AgAgAkHUAGogCEEQaikCADcCACACQpmy5MiRo8aMGTcDICACIAkpAgA3AiwgAiANKQIANwM4IAIgCCkCADcCRCAGIAJBIGpBPPwKAAAMBAsgAiAHNgIcIAJBBDYCCCACQYz3gAE2AgQgAkIENwIQIAJBOzYCPCACQTs2AjQgAkHMATYCLCACQcj2gAE2AiggAkHMATYCJCACQbj2gAE2AiAgAiACQSBqNgIMIAIgAkEcajYCOCACIAI2AjAgBkEIaiACQQRqEJkOIAZBKToAACAGQY2AgIB4NgIEDAELIAYgAikCJDcCCCAGQRBqIAJBLGopAgA3AgAgBkEpOgAAIAYgATYCBCAIKAIAIgFFDQELIAEgASgCACIBQQFrNgIAIAFBAUcNACAIEPseCyANKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCANEPseCyAJKAIAIgEgASgCACIBQQFrNgIAIAFBAUcNACAJEPseCyACQeAAaiQAIAVB8ABqJAACQAJAIAQtABxBKUYEQCAEQegAaiAEQTBqKAIANgIAIARB4ABqIARBKGopAgA3AwAgBCAEKQIgNwNYIAMtADQNASAAIARBIGoiASkCADcCACAAQRBqIAFBEGooAgA2AgAgAEEIaiABQQhqKQIANwIADAQLQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogBEEcakE8/AoAACAAQcD8/wA2AgggACABNgIEIABBk4CAgHg2AgAMAwsgChDUOiEBIARBCGogChCsKiAEQewAaiABIAQoAgwQpRQgChDUOiEFIARBpAFqIg0gChD5NCAEIAU2AsABIARBADYCvAEgBCAKNgKgASAEKAKkASEDIAUEQCAEQfgAaiELIARBhAFqIQdBACECA0ACQAJAAkACQAJAAkAgA0UNACACIAQoArQBTw0CIAQoAqgBIAQoArABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAEIAJBAWoiAjYCvAEMAQsgBCACQQFqIgE2ArwBIAQgCiACENorIARB5AFqIAQoAgAgBCgCBBCdCSAEKALkAUUNAiABIQILIAcQ5jogBCgChAFFDQIgBCgClAFBAWoiCEEDdiAIQQdxQQBHaiIBIAQoApABIgZLBEAgASAGayEJIAQoAogBIgwgAUkEQCAHIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBCgCkAEhBgsgCQRAIAQoAowBIAZqQQAgCfwLAAsgBCABNgKQAQsgBCAINgKUASAENQJ0IRIgBCgCgAEiASAEKAJ4RgRAIAtBwPT/ABCzKAsgBCgCfCABQQN0aiASNwMAIAQgAUEBajYCgAEMAwtBzPb/AEEgQez2/wAQnykACyAEQewAaiAEKALoASAEKALsARC8EiABIQIMAQtBuPf/ABCyOwALIAIgBUcNAAsLAkAgA0UNACADIAMoAgAiAUEBazYCACABQQFHDQAgDRD7HgsgBEGgAWoiAiAEQewAaiIDEO4OQcQAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABBwPz/ADYCCCAAIAE2AgQgAEGTgICAeDYCACADELssIARB2ABqEIgRDAMLQQRBxAAQoz0AC0EEQcQAEKM9AAtBqI6AARCyOwALIARB8AFqJAAL2g8CC38BfiMAQSBrIhQkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0EBaiAKRwRAIAogA0EDakcNBiABKAIIIQ0gASgCBCEOIAMgCksNCyADRQ0FIAMgDUkNASADIA1HDQsMBQsgASgCCCENIAEoAgQhDgJAIApFDQAgCiANTwRAIAogDUYNAQwFCyAKIA5qLAAAQb9/TA0ECyAKIA5qIA0gCmtBnIfEAEECEPQuIAEoAgghDQ0BDAILIAMgDmosAABBv39KDQMMCQsCQAJAIApFDQAgCiANTwRAIAogDUYNAQwCCyABKAIEIApqLAAAQb9/TA0BCyABQQIQ2C0gDSAKayIOBEAgASgCBCAKaiIPQQJqIA8gDvwKAAALIAEoAgQgCmpBr9wAOwAAIAEgDUECaiINNgIIIApBAmohCgwBC0H8hMQAQSxBiJLEABCfKQALIAEoAgQhDgJAAkAgA0UNACADIA1PBEAgAyANRg0BDAILIAMgDmosAABBv39MDQELIAMgDmogDSADa0GEkcQAQQMQ9C5FDQNBh5HEAEHPAEGoksQAEJ8pAAsgDiANIAMgDUGYksQAEKM2AAsgDiANIAogDUH4kcQAEKM2AAsCQCAKRQ0AIAogDU8EQCAKIA1HDQcMAQsgCiAOaiwAAEG/f0wNBgsgAyAOaiAKIANrQcyQxABBAxDBLkUNACAKIAEoAggiDU8NASABKAIEIg4gCmoiDy0AAEEvRw0CAkAgDSAKQQFqIg9LBEAgDiAPai0AAEEvRg0BCyMAQUBqIg4kACAOIAo2AhAgDiADNgIMIAEoAgghDSABKAIEIRACQCADRQ0AAkAgAyANTwRAIAMgDUcNAQwCCyADIBBqLAAAQb9/Sg0BC0GsmsQAQSpB5JDEABCfKQALAkAgCkUNAAJAIAogDU8EQCAKIA1HDQEMAgsgCiAQaiwAAEG/f0oNAQtBrJrEAEEqQeSQxAAQnykACyAOIA5BEGo2AjwgDkEBNgI4IA5BADYCMCAOIA5BDGo2AjQgDkEwaiISKAIEIQ8CQAJAAkAgEigCAEEBaw4CAQIACyAPKAIAIREMAQsgDygCACIPQX9HBEAgD0EBaiERDAELIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHo+IkBNgIIIABCBDcCECAAQQhqQeibxAAQ7ywACyASKAIMIRMgDSEPAkACQAJAIBIoAghBAWsOAgECAAsgEygCACIPQX9HBEAgD0EBaiEPDAILIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEGc+YkBNgIIIABCBDcCECAAQQhqQfibxAAQ7ywACyATKAIAIQ8LAkAgDyARTwRAIA0gD08NASAPIA1BqJzEABCwOwALIBEgD0GonMQAELE7AAsgDiAPNgIEIA4gETYCACAOKAIEIQ8gASAOKAIAIhE2AgggDiABNgIcIA4gDzYCICAOIA0gD2s2AiQgDkGoi8QANgIoIA5BqYvEADYCLCAOIA8gEGo2AhggDiAQIBFqNgIUIwBBEGsiESQAIA5BFGoiFiINQoGAgIAQNwIAAkAgDSgCEEUEQCANKAIIIA1BFGoQyyMMAQsgDSANQRRqIhAQjR1FDQAgDSgCGCIPIA0oAhQiEkcEQCANIA8gEmsQ3CMgDSAQEI0dRQ0BCyMAQSBrIg8kACAPQRRqIBAoAgQgECgCAGtBAEEBQQEQoBggDygCGCESIA8oAhRBAUYEQCASIA8oAhxBiJzEABD9LwALIA9BEGoiE0EANgIAIA8gDygCHDYCDCAPIBI2AgggD0EIaiAQEMsjIBFBBGoiEEEIaiATKAIANgIAIBAgDykCCDcCACAPQSBqJAAgESgCCCEPIBEoAgQhFwJAIBEoAgwiEEUNACANIBAQ3CMgDSgCDCITIA0oAggiEigCCCINRg0AIBMgDWshFSASKAIEIA1qIRMgDyENA0AgEEUNASATIA0tAAA6AAAgEiASKAIIQQFqNgIIIBBBAWshECANQQFqIQ0gE0EBaiETIBVBAWsiFQ0ACwsgESAPNgIIIBEgFzYCBCARQQRqEN47CyARQRBqJAAgFhCdGCAOQUBrJAAgCkECayEKIAEoAgghDSABKAIEIQ4LAkAgA0UNACADIA1PBEAgAyANRg0BDAYLIAMgDmosAABBv39MDQULIAMgDmogDSADa0GEkcQAQQMQ9C4NAwsgFEEIaiABIAIgAyALIAwQzhECQCAUKAIIIgJBAkYEQCAAIBQtAAw6AAQgARDeOwwBCyAUKQIMIRggFCgCFCELIAAgCjYCMCAAIAY2AiwgACAFNgIoIAAgBDYCJCAAIAM2AiAgACAJOwEeIAAgCDsBHCAAIAs2AgwgACAYNwIEIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgACAHKQAANwA0IABBPGogB0EIaikAADcAACAAQcQAaiAHQRBqLQAAOgAACyAAIAI2AgAgFEEgaiQADwsgCiANQdCQxAAQwyEACyAUQQA2AggjAEEQayIAJAAgAEHgkMQANgIMIAAgDzYCCEEAIABBCGpBmJzEACAAQQxqQZicxAAgFEEIakHokcQAEOYPAAtBh5HEAEHPAEHYkcQAEJ8pAAsgDiANIAMgDUH0kMQAEKM2AAsgDiANIAMgCkG8kMQAEKM2AAu7HgEQfyMAQfACayIZJAACQAJAIA0EQCAMIA1BAWtNDQEgDSEPIAshFQNAIBUoAgAgEmohEiAVQRBqIRUgD0EBayIPDQALCyAOQfgAaiEbIA5B2ABqIQ9BASEVAkAgCEEBRgRAIBlB2AFqIRYgDyEVIwBBsAhrIhEkAAJAAkACQCAOKAIEIhAgEkEJdkEBaiIUSQRAIA4oAgAhEiAQIBQgEBshDwNAIA8iE0EBdCEPIBMgFEkNAAsgEUEQaiAAIBMQuCkgESgCFCEPIBEoAhAhEyAQBH8gDyAQSQ0CIBMgECASIBBBvOzMABDVLCAOKAIAIRIgDigCBAVBAAshECAOIA82AgQgDiATNgIAIAAgEiAQEOA1CyAUIA4oAgwiEksEQCAOKAIIIRAgEiAUIBIbIQ8DQCAPIhNBAXQhDyATIBRJDQALIBFBCGogACATELkpIBIgESgCDCIPSw0CIBEoAgghEyASQQJ0IhIEQCATIBAgEvwKAAALIA4oAgwhEiAOIA82AgwgDigCCCAOIBM2AgggEhCAMQsgG0GBAiAUIBRBgQJPGyIPNgIAIA4gFDYCFCARQShqIhNBAEGECPwLACARQaPg//sHNgKsCCARQRxqIhQgEyAPEIEcIBEgFEHMgs4AEKIhIBEoAgAhDyAVKAIEIRMgFSARKAIEIhQ2AgQgFSgCACESIBUgDzYCACATBEAgEiATQYgIbEEEEPg6CyAUBEAgD0EAQYQI/AsAIA9Bo+D/+wc2AoQIIBZBCGpCADcCACAWQgA3AgAgFkEANgIsIBZCADcCJCAWQYAENgIgIBZBADYCHCAWQwAAyEM4AhggFkGABDYCFCAWQYACNgIQIBFBsAhqJAAMAwsMBgsgECAPQazszAAQsDsACyASIA9BzOzMABCwOwALQQAhFQwBCyAZQdgBaiEUIA8hEyMAQbAIayIWJAACQAJAAkACQCAIQQ5JBEAgCEUNAUGAAiAIQf//A3FuIRggDigCBCIQIBJBCXZBAWoiEkkEQCAOKAIAIRcgECASIBAbIQ8DQCAPIhFBAXQhDyARIBJJDQALIBZBEGogACARELgpIBYoAhQhDyAWKAIQIREgEAR/IA8gEEkNBCARIBAgFyAQQdjwzAAQ1SwgDigCACEXIA4oAgQFQQALIRAgDiAPNgIEIA4gETYCACAAIBcgEBDgNQsgDigCDCIQIBJPDQQgDigCCCEXIBAgEiAQGyEPA0AgDyIRQQF0IQ8gESASSQ0ACyAWQQhqIAAgERC5KSAWKAIMIQ8gFigCCCERIBAEfyAPIBBJDQQgEEECdCIQBEAgESAXIBD8CgAACyAOKAIIIRcgDigCDAVBAAshECAOIA82AgwgDiARNgIIIBcgEBCAMQwEC0Hs78wAQTxBqPDMABCfKQALQbjwzAAQ4isACyAQIA9ByPDMABCwOwALIBAgD0Ho8MwAELA7AAsgDiASNgIUIBsgGEEBaiIPIBIgDyASSRsgCGwiDzYCACAWQShqIhFBAEGECPwLACAWQaPg//sHNgKsCCAWQRxqIhIgESAPEIEcIBYgEkHMgs4AEKIhIBYoAgQhESAWKAIAIQ8gEygCBCISBEAgEygCACASQYgIbEEEEPg6CyATIBE2AgQgEyAPNgIAAkAgCCARTQRAIA8gCEGICGxqIRMDQCAPQQBBhAj8CwAgD0GECGpBo+D/+wc2AgAgD0GICGoiDyATRw0ACyAUQQBB8AD8CwAgFEEANgKUASAUQgA3AowBIBRBgAQ2AogBIBRBADYChAEgFEMAAMhDOAKAASAUQYAENgJ8IBQgGDYCeCAUIAg2AnQgFEGAAjYCcCAWQbAIaiQADAELIAggEUGs6swAELA7AAsLIBkgFTYCDCAZQRBqIhYgGUHYAWoiE0GYAfwKAAAgGUGoAWohEiAOQeAAaiEYIA5B/ABqIRwjAEGwFmsiESQAAkACQAJAIA5BGGoiHSIUKAIEIhcgDUEKdkEBaiIQSQRAIBQoAgAhGiAXIBAgFxshDwNAIA8iFUEBdCEPIBAgFUsNAAsgEUEQaiAAIBUQuCkgESgCFCEPIBEoAhAhFSAXBH8gDyAXSQ0CIBUgFyAaIBdBvOzMABDVLCAUKAIAIRogFCgCBAVBAAshFyAUIA82AgQgFCAVNgIAIAAgGiAXEOA1CyAQIBQoAgwiF0sEQCAUKAIIIRogFyAQIBcbIQ8DQCAPIhVBAXQhDyAQIBVLDQALIBFBCGogACAVELkpIBcgESgCDCIPSw0CIBEoAgghFSAXQQJ0IhcEQCAVIBogF/wKAAALIBQoAgwhFyAUIA82AgwgFCgCCCAUIBU2AgggFxCAMQsgHEGBAiAQIBBBgQJPGyIPNgIAIBQgEDYCFCARQShqIhVBAEGEFvwLACARQaPg//sHNgKsFiARQRxqIhQgFSAPEIQcIBEgFEHMgs4AEJwhIBEoAgAhDyAYKAIEIRUgGCARKAIEIhQ2AgQgGCgCACEQIBggDzYCACAVBEAgECAVQYgWbEEEEPg6CyAUBEAgD0EAQYQW/AsAIA9Bo+D/+wc2AoQWIBJBCGpCADcCACASQgA3AgAgEkEANgIsIBJCADcCJCASQYAINgIgIBJBADYCHCASQwAA+kM4AhggEkGACDYCFCASQcAFNgIQIBFBsBZqJAAMAwsMBAsgFyAPQazszAAQsDsACyAXIA9BzOzMABCwOwALIBMhFSAOQegAaiEXIA5BgAFqIRojAEGwEWsiESQAAkACQAJAIA5BMGoiFCgCBCIQIA1BCXZBAWoiEkkEQCAUKAIAIRggECASIBAbIQ8DQCAPIhNBAXQhDyASIBNLDQALIBFBEGogACATELgpIBEoAhQhDyARKAIQIRMgEAR/IA8gEEkNAiATIBAgGCAQQbzszAAQ1SwgFCgCACEYIBQoAgQFQQALIRAgFCAPNgIEIBQgEzYCACAAIBggEBDgNQsgEiAUKAIMIhBLBEAgFCgCCCEYIBAgEiAQGyEPA0AgDyITQQF0IQ8gEiATSw0ACyARQQhqIAAgExC5KSAQIBEoAgwiD0sNAiARKAIIIRMgEEECdCIQBEAgEyAYIBD8CgAACyAUKAIMIRAgFCAPNgIMIBQoAgggFCATNgIIIBAQgDELIBpBgQIgEiASQYECTxsiDzYCACAUIBI2AhQgEUEoaiITQQBBhBH8CwAgEUGj4P/7BzYCrBEgEUEcaiISIBMgDxCCHCARIBJBzILOABCgISARKAIAIQ8gFygCBCETIBcgESgCBCISNgIEIBcoAgAhECAXIA82AgAgEwRAIBAgE0GIEWxBBBD4OgsgEgRAIA9BAEGEEfwLACAPQaPg//sHNgKEESAVQQhqQgA3AgAgFUIANwIAIBVBADYCLCAVQgA3AiQgFUGABDYCICAVQQA2AhwgFUMAAMhCOAIYIBVBgAQ2AhQgFUHAADYCECARQbARaiQADAMLDAQLIBAgD0Gs7MwAELA7AAsgECAPQczszAAQsDsACwJAAkAgDQRAQQAhDyAHQf8BcSEQA0ACQAJAIAwgD0cEQCALIA9BBHRqIgcvAQ4hFyAHKAIEIRggBygCACESIA4oAmAhFSAHLwEMIR4CQCAZQagBaiIHKAIoIhMgDigCZCIRSQRAIBUgE0GIFmxqIB4QtykgByAHKAIkQQFqIhM2AiQgBygCICATRgRAIAcgHSAVIBEgHEEAEOgDCwwBCyATIBFBrO3MABDDIQALIBINAQwCCyAMIAxByPTMABDDIQALAkADQCADIARxIgcgAk8NASABIAdqLQAAIQcCQAJAIBkoAgxFBEAgDigCWCEGIBYoAigiFSAOKAJcIhNJBEAgBiAVQYgIbGogBxC2KSAWIBYoAiRBAWoiFTYCJCAWKAIgIBVGBEAgFiAOIAYgEyAbQQAQ5wMLDAILIBUgE0Gs7cwAEMMhAAsgCgJ/AkACQAJAAkAgEEEBaw4DAQIDAAsgBUE/cQwDCyAFQfwBcUECdgwCCyAGQf8BcUG0k+IAai0AACAFQf8BcUG0keIAai0AAHIMAQsgBkH/AXFBtJXiAGotAAAgBUH/AXFBtJXiAGotAABBA3RqC0H/AXEiBk0NASAOKAJYIRUCQCAJIAZBAnRqKAIAIBYoApABaiIGIA4oAlwiE0kEQCAVIAZBiAhsaiAHELYpIBYgFigCjAFBAWoiBjYCjAEgFigCiAEgBkYEQCAWIA4gFSATIBtBABDVAQsMAQsgBiATQfjwzAAQwyEACwsgA0EBaiEDIAUhBiAHIQUgEkEBayISRQ0DDAELCyAGIApBiPXMABDDIQALIAcgAkH49MwAEMMhAAsgAyAYQf///w9xIgdqIQMCQCAHRQ0AIANBAmsgBHEiBSACTw0DIANBAWsgBHEiByACTw0EIAEgBWotAAAhBiABIAdqLQAAIQUgHkH/AE0NACAOKAJoIRUgF0H/B3EhEgJAIBlB2AFqIgcoAigiEyAOKAJsIhFJBEAgFSATQYgRbGogEhC1KSAHIAcoAiRBAWoiEzYCJCAHKAIgIBNGBEAgByAUIBUgESAaQQAQ5gMLDAELIBMgEUGs7cwAEMMhAAsLIA9BAWoiDyANRw0ACwsgDigCXCEBIA4oAlghAgJAIBkoAgxBAUYEQCAWIA4gAiABIBtBARDVAQwBCyAWIA4gAiABIBtBARDnAwsgGUGoAWogHSAOKAJgIA4oAmQgHEEBEOgDIBlB2AFqIBQgDigCaCAOKAJsIBpBARDmAyAIQQFLBEBBACEGIwBBEGsiAyQAIA4gDigCECIHQQZ0IgE2AnAgA0EIaiAAIAEQuSkgDigCTCEBIAMoAgghACAOIAMoAgwiCzYCTCAOKAJIIA4gADYCSCABEIAxIAcEQEEAIQQDQCAEIAhsIQwgBEEBaiEEIAkhASAAIQJBACEFAkACQANAIAUgCkYNASALIAUgBmoiDUsEQCACIAEoAgAgDGo2AgAgAUEEaiEBIAJBBGohAiAFQQFqIgVBwABGDQMMAQsLIA0gC0H87MwAEMMhAAsgCiAKQezszAAQwyEACyAAQYACaiEAIAZBQGshBiAEIAdHDQALCyADQRBqJAALIBlB8AJqJAAPCyAFIAJB2PTMABDDIQALIAcgAkHo9MwAEMMhAAsgDCAMQZj1zAAQwyEAC0EAQQBB3OzMABDDIQALuAYCCn8BfiMAQTBrIgMkAEGAwAAhBgJAAkAgAigCACILIAIoAggiCWtBIE8EQCAJIQQMAQsgA0EQaiABIAIQkxMCQCADLQAQQQRGBEAgAygCFCEEDAELIAMpAxAiDUIgiKchBCANpyIFQf8BcUEERg0AIAAgBDYCBCAAIAU6AAAgAEEDaiAFQRh2OgAAIAAgBUEIdjsAAQwCCyAEBEAgAigCCCEEDAELIABBBDoAACAAQQA2AgQMAQsDQAJAIAQgAigCACIFRyAFIAtHcg0AIANBEGogASACEJMTAkAgAy0AEEEERgRAIAMoAhQhBQwBCyADKQMQIg1CIIinIQUgDaciBEH/AXFBBEYNACAAIAU2AgQgACAEOgAAIABBA2ogBEEYdjoAACAAIARBCHY7AAEMAwsgAigCCCEEIAUEQCACKAIAIQUMAQsgAEEEOgAAIAAgBCAJazYCBAwCCwJAAkACQAJAIAQgBUYEQCADQQhqIAIgBRC0ICADKAIIQYGAgIB4Rw0BIAIoAgAhBSACKAIIIQQLIAIoAgQhByADIAg2AhwgA0EANgIYIAMgBCAHajYCECADIAYgBSAEayIEIAQgBksbIgc2AhQgA0EgaiABIANBEGoQ5xQgAy0AICIEQQRHDQEMAgsgAEKBzAA3AgAMBAsDQEEAIQUCQAJAAkACQCAEQf8BcUEBaw4DAQIABgsgAygCJC0ACEEjRw0FDAILIAMtACFBI0YNAQwECyADKAIkLQAIQSNHDQMLIAMgAykDIDcDKCADQShqELkuIANBIGogASADQRBqEOcUIAMtACAiBEEERw0ACwtBASEFCyACIAMoAhgiCCACKAIIaiIENgIIIAMoAhwhCgJAIAUNACADKQMgIg2nIgVB/wFxQQRGDQAgACAFOgAAIABBB2ogDUI4iDwAACAAQQVqIA1CKIg9AAAgACANQgiIPgABDAILIAgEQCAHIAhHIAdBfyAGIAxBAWpBACAHIAhLGyIMQQFKGyAGIAcgCkcbIgZJckUEQEF/IAZBAXQgBkEASBshBgsgCiAIayEIDAEFIABBBDoAACAAIAQgCWs2AgQLCwsgA0EwaiQAC7kPAQl/IwBBkAFrIggkAAJAIAJB/////wNxIgNFDQACQAJAAkACQCACQeD/A3FBACACQYCA/P8DcSIEG0UEQCAERQ0EIAJBEHEhCSACQQ9xIQQgA0EQdkEBayIDIAAoAmQiAkkNASADIAAoAmwiASACaiIFSQ0CIAMgACgCdCICIAVqIgFJDQMgCEEgaiAAIAMgAWsgBEEBaiAJQQBHIAAoAnggACgCfBDGCyAIKAIkIQUgCCgCICEBDAULIAJBD3ZB//8BcRCyPSEJQREhAQJ/IAAoAkgiBEERTQRAIABBBGohByAEIQMgAEHIAGoMAQsgACgCBCEDIAAoAgghByAEIQEgAEEEagshBCABIANGBEAgABD8HyAAKAIEIQMgACgCCCEHIABBBGohBAsgAkH//wFxIQEgByADQQJ0aiAJNgIAIAQgBCgCAEEBajYCAAwECyAIQQhqIAAgAyAEQQJqIAlBAEcgACgCYCACEMYKIAgoAgwhBSAIKAIIIQEMAwsgCEEQaiAAIAMgAmsgBEEBaiAJQQBHIAAoAmggARDGCyAIKAIUIQUgCCgCECEBDAILIAhBGGogACADIAVrIARBAmogCUEARyAAKAJwIAIQxgogCCgCHCEFIAgoAhghAQwBCwJAIAFBgNgCayIEQaTXAE8EQCACQf//A3EiAUEBRw0BIAhB7gBqIgJB1I3IAEEi/AoAACAIQShqIgEgAhC9GiAAIAEQ7QtBtQwhAUERIQUMAgsgAEHIAGohAiAEQf//A3EiAUEccCEGIAQgAUHMBG4iCUHMBGxrQf//A3FBHG5B4SJqIQNBESEFAn8gACgCSCIBQRFNBEAgAEEEaiEHIAIhBCABDAELIABBBGohBCAAKAIIIQcgASEFIAAoAgQLIgEgBUYEfyAAEPwfIABBBGohBCAAKAIIIQcgACgCBAUgAQtBAnQgB2ogAzYCAEEBIQUgBCAEKAIAQQFqNgIAIAlBgCJyIQEgBkUNASAGQacjaiEJQREhBQJ/IAIoAgAiBEERTQRAIABBBGohAyAEDAELIABBBGohAiAAKAIIIQMgBCEFIAAoAgQLIQQgBCAFRgRAIAAQ/B8gACgCBCEEIAAoAgghAyAAQQRqIQILQQIhBSADIARBAnRqIAk2AgAgAiACKAIAQQFqNgIADAELQf3/AyABIAFBgLC/f3NBgJC8f0kbIQELIAUhCSMAQSBrIgokACAAIgZBBGohAiAAQcgAaiELA0ACQCAGKAJMIQMgBkGAgMQANgJMAkACQAJ/IANBgIDEAEcEQCAGKAJQDAELIApBEGogBhD2EiAKKAIQIgNBgIDEAEYNASAKKAIUCyIAQYD8//8DcUGAsANGDQEgBiAANgJQIAYgAzYCTAsgCkEIaiAGIAkQ1yQCQCAKKAIMIgNBAkkNACAGKAJcIQIgCigCCCEEIANBAnQhAEEAIQUDQCAEIAVqIAIQ2ykgACAFQQRqIgVHDQALIAogCkEfajYCGCADQRVPBEAgBCADIApBGGoQrxsMAQsgBCADEPYWCyAKQSBqJAAMAQsCfyAAQYCyA3FBgLIDRwRAIAMgABCjLwwBCwJ/AkACQAJAAkACQAJAAkACQAJAAkAgA0HyHkwEQCADQcAGaw4FAgUBAwQBCwJAIANB8x5rDgMGAQcACwJAIANBnv8Daw4CCQoACyADQYEfRg0HC0H9/wMQsj0MCQtBgAZB5gEQ/DoMCAtBkwZB5gEQ/DoMBwtBiAZB5gEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAC0GBBkHmARD8OgwFC0HxHkGBARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgBB8h5BggEQ/DoMBAtB8R5BgQEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAQfQeQYQBEPw6DAMLQfEeQYEBEPw6IQcCfyALKAIAIgRBEkkEQCAEIQMgAiEFQREhBCALDAELIAYoAgQhAyAGKAIIIQUgAgshACADIARGBEAgBhD8HyAGKAIEIQMgBigCCCEFIAIhAAsgBSADQQJ0aiAHNgIAIAAgACgCAEEBajYCAEGAH0GCARD8OgwCC0GZ4QBBCBD8OgwBC0Ga4QBBCBD8OgsLIQcCfyALKAIAIgRBEkkEQCAEIQAgAiEFQREhBCALDAELIAYoAgQhACAGKAIIIQUgAgshAyAAIARGBH8gBhD8HyAGKAIIIQUgAiEDIAYoAgQFIAALQQJ0IAVqIAc2AgAgAyADKAIAQQFqNgIADAELCyAIQZABaiQAIAELuQ8BCX8jAEGQAWsiCCQAAkAgAkH/////A3EiA0UNAAJAAkACQAJAIAJB4P8DcUEAIAJBgID8/wNxIgQbRQRAIARFDQQgAkEQcSEJIAJBD3EhBCADQRB2QQFrIgMgACgCZCICSQ0BIAMgACgCbCIBIAJqIgVJDQIgAyAAKAJ0IgIgBWoiAUkNAyAIQSBqIAAgAyABayAEQQFqIAlBAEcgACgCeCAAKAJ8EMYLIAgoAiQhBSAIKAIgIQEMBQsgAkEPdkH//wFxELI9IQlBESEBAn8gACgCSCIEQRFNBEAgAEEEaiEHIAQhAyAAQcgAagwBCyAAKAIEIQMgACgCCCEHIAQhASAAQQRqCyEEIAEgA0YEQCAAEPwfIAAoAgQhAyAAKAIIIQcgAEEEaiEECyACQf//AXEhASAHIANBAnRqIAk2AgAgBCAEKAIAQQFqNgIADAQLIAhBCGogACADIARBAmogCUEARyAAKAJgIAIQxgogCCgCDCEFIAgoAgghAQwDCyAIQRBqIAAgAyACayAEQQFqIAlBAEcgACgCaCABEMYLIAgoAhQhBSAIKAIQIQEMAgsgCEEYaiAAIAMgBWsgBEECaiAJQQBHIAAoAnAgAhDGCiAIKAIcIQUgCCgCGCEBDAELAkAgAUGA2AJrIgRBpNcATwRAIAJB//8DcSIBQQFHDQEgCEHuAGoiAkHUjcgAQSL8CgAAIAhBKGoiASACEL0aIAAgARDtC0G1DCEBQREhBQwCCyAAQcgAaiECIARB//8DcSIBQRxwIQYgBCABQcwEbiIJQcwEbGtB//8DcUEcbkHhImohA0ERIQUCfyAAKAJIIgFBEU0EQCAAQQRqIQcgAiEEIAEMAQsgAEEEaiEEIAAoAgghByABIQUgACgCBAsiASAFRgR/IAAQ/B8gAEEEaiEEIAAoAgghByAAKAIEBSABC0ECdCAHaiADNgIAQQEhBSAEIAQoAgBBAWo2AgAgCUGAInIhASAGRQ0BIAZBpyNqIQlBESEFAn8gAigCACIEQRFNBEAgAEEEaiEDIAQMAQsgAEEEaiECIAAoAgghAyAEIQUgACgCBAshBCAEIAVGBEAgABD8HyAAKAIEIQQgACgCCCEDIABBBGohAgtBAiEFIAMgBEECdGogCTYCACACIAIoAgBBAWo2AgAMAQtB/f8DIAEgAUGAsL9/c0GAkLx/SRshAQsgBSEJIwBBIGsiCiQAIAAiBkEEaiECIABByABqIQsDQAJAIAYoAkwhAyAGQYCAxAA2AkwCQAJAAn8gA0GAgMQARwRAIAYoAlAMAQsgCkEQaiAGEIUKIAooAhAiA0GAgMQARg0BIAooAhQLIgBBgPz//wNxQYCwA0YNASAGIAA2AlAgBiADNgJMCyAKQQhqIAYgCRDXJAJAIAooAgwiA0ECSQ0AIAYoAlwhAiAKKAIIIQQgA0ECdCEAQQAhBQNAIAQgBWogAhDbKSAAIAVBBGoiBUcNAAsgCiAKQR9qNgIYIANBFU8EQCAEIAMgCkEYahCvGwwBCyAEIAMQ9hYLIApBIGokAAwBCwJ/IABBgLIDcUGAsgNHBEAgAyAAEKMvDAELAn8CQAJAAkACQAJAAkACQAJAAkACQCADQfIeTARAIANBwAZrDgUCBQEDBAELAkAgA0HzHmsOAwYBBwALAkAgA0Ge/wNrDgIJCgALIANBgR9GDQcLQf3/AxCyPQwJC0GABkHmARD8OgwIC0GTBkHmARD8OgwHC0GIBkHmARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgALQYEGQeYBEPw6DAULQfEeQYEBEPw6IQcCfyALKAIAIgRBEkkEQCAEIQMgAiEFQREhBCALDAELIAYoAgQhAyAGKAIIIQUgAgshACADIARGBEAgBhD8HyAGKAIEIQMgBigCCCEFIAIhAAsgBSADQQJ0aiAHNgIAIAAgACgCAEEBajYCAEHyHkGCARD8OgwEC0HxHkGBARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgBB9B5BhAEQ/DoMAwtB8R5BgQEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAQYAfQYIBEPw6DAILQZnhAEEIEPw6DAELQZrhAEEIEPw6CwshBwJ/IAsoAgAiBEESSQRAIAQhACACIQVBESEEIAsMAQsgBigCBCEAIAYoAgghBSACCyEDIAAgBEYEfyAGEPwfIAYoAgghBSACIQMgBigCBAUgAAtBAnQgBWogBzYCACADIAMoAgBBAWo2AgAMAQsLIAhBkAFqJAAgAQvPBgEIfwJAAkAgASAAQQNqQXxxIgMgAGsiCEkNACABIAhrIgZBBEkNACAGQQNxIQdBACEBAkAgACADRiIJDQACQCAAIANrIgVBfEsEQEEAIQMMAQtBACEDA0AgASAAIANqIgIsAABBv39KaiACQQFqLAAAQb9/SmogAkECaiwAAEG/f0pqIAJBA2osAABBv39KaiEBIANBBGoiAw0ACwsgCQ0AIAAgA2ohAgNAIAEgAiwAAEG/f0pqIQEgAkEBaiECIAVBAWoiBQ0ACwsgACAIaiEAAkAgB0UNACAAIAZBfHFqIgMsAABBv39KIQQgB0EBRg0AIAQgAywAAUG/f0pqIQQgB0ECRg0AIAQgAywAAkG/f0pqIQQLIAZBAnYhBSABIARqIQQDQCAAIQMgBUUNAkHAASAFIAVBwAFPGyIGQQNxIQcgBkECdCEIQQAhAiAFQQRPBEAgACAIQfAHcWohCSAAIQEDQCABKAIAIgBBf3NBB3YgAEEGdnJBgYKECHEgAmogAUEEaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQhqKAIAIgBBf3NBB3YgAEEGdnJBgYKECHFqIAFBDGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWohAiABQRBqIgEgCUcNAAsLIAUgBmshBSADIAhqIQAgAkEIdkH/gfwHcSACQf+B/AdxakGBgARsQRB2IARqIQQgB0UNAAsCfyADIAZB/AFxQQJ0aiIAKAIAIgFBf3NBB3YgAUEGdnJBgYKECHEiASAHQQFGDQAaIAEgACgCBCIBQX9zQQd2IAFBBnZyQYGChAhxaiIBIAdBAkYNABogACgCCCIAQX9zQQd2IABBBnZyQYGChAhxIAFqCyIBQQh2Qf+BHHEgAUH/gfwHcWpBgYAEbEEQdiAEag8LIAFFBEBBAA8LIAFBA3EhAwJAIAFBBEkEQAwBCyABQXxxIQUDQCAEIAAgAmoiASwAAEG/f0pqIAFBAWosAABBv39KaiABQQJqLAAAQb9/SmogAUEDaiwAAEG/f0pqIQQgBSACQQRqIgJHDQALCyADRQ0AIAAgAmohAQNAIAQgASwAAEG/f0pqIQQgAUEBaiEBIANBAWsiAw0ACwsgBAv+DAIEfgh/IwBB4AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUHoAGpBK0EAQQFBARCgGCAFKAJsIQMgBSgCaEEBRg0BIAUoAnAiAUGYqs4AQSv8CgAAIABBKzYCDCAAIAE2AgggACADNgIEIABBADYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIARB/wFxQQdHBEAgBUEBNgJsIAVByKnOADYCaCAFQgE3AnQgBUGuAzYCFCAFIAVBEGo2AnAgBSAFQQ9qNgIQIABBBGogBUHoAGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAVB1AFqQgA3AgAgBUHIAWoiCyACQQxqKAIANgIAIAVCADcCzAEgBSACKQIENwPAASACKAIAIQQgBUEAOgBgIAVCgICAgBA3A1AgBUIANwNYIAVCAjcDEEHAAEEIEK02IgJFDQEgAiAENgIAIAIgBSkDwAE3AgQgAiAMNgI4IAJBADYCNCACIAM2AjAgAkEANgIgIAJBDGogCykDADcCACACQRRqIAVB0AFqKQMANwIAIAJBHGogBUHYAWooAgA2AgAgBUHoAGohCyMAQSBrIgokACAKQdCpzgA2AgQgCiACNgIAAkAgAkHoqc4AKAIAEQQAIgwgBUEQaiIEKAJIIgNNBEAgBCAMNgJIDAELIARBQGsgDCADaxCGHCAEKAJIIQwLIApBCGogAiAEKAJEIAxB4KnOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAmgiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCqCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQfSpzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFB9KnOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAmw3AgQgAEEUaiAFQfwAaigCADYCACAAQQxqIAVB9ABqKQIANwIAIAAgAjYCACAFQRBqEJouDAMLIAMgBSgCcEHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQeABaiQAC+QKAQ5/IwBB8ABrIgMkACMAQTBrIgIkACAAQQQgACgCNCIHIAdBBE0bNgI0IABBMGohBwJAQQAgACgCMCIFa0EDcSIEIAAoAgggBWtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAHIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAHQQQQjTcgAkEQaiAAENw7IAIoAhQhBCACKAIQIQUgAkEIaiAAKAIwEIw3IAIgBSAEIAIoAgggAigCDEHg/f4AENcmIAIoAgRBA00EQCACQQA2AiggAkEBNgIcIAJByP7+ADYCGCACQgQ3AiAgAkEYakHw/f4AEO8sAAsgAigCAEHw4cOHfzYAACAHKAIAIQcgAkEwaiQAIAAoAhQiBQR/IAAoAhAiAi8BBCEEIAVBAUcEQCACQQxqIQIgBUEBa0H/////AXEhBQNAIAIvAQAiBiAEQf//A3EiBCAEIAZJGyEEIAJBCGohAiAFQQFrIgUNAAsLIARB//8DcUECagVBBAsiBSAAKAIIIAAoAjBrIgJNIAIgBU9yRQRAA0AgABD7FiAAKAIIIAAoAjBrIAVJDQALCyAAQTBqIgogBRCNNyAAKAIwIQkgA0HYAGogABDcOyADQdAAaiADKAJYIAMoAlwgCSAJIAVrIgxBqPz+ABDXJgJAAkACQAJAAkAgAygCVCIGQQFLBEAgAygCUCIIIAU7AAAgBkEDTQ0BIAggByABazsAAiAAKAIUIgEEQCAAKAIQIQIgAUEDdCEEA0AgAkEEai8BACIBQQJqIgsgBksNBCABIAhqIAcgAigCAGs7AAAgAkEIaiECIARBCGsiBA0ACwsgA0HIAGogABDcOyADQUBrIAMoAkggAygCTCAJIAxBuPz+ABDXJiAAKAIcIQFBACECIAMoAkQhBiADKAJAIQgCQAJAAkACQAJAIAAoAiAiBA4CAgEACwNAIAAoAgghCyABIARBAXYiDSACaiIOQQJ0aigCACEPIANBOGogABDcOyADIAsgD2s2AmwgAyADKQM4NwJkIANBMGogA0HkAGoQ8CAgAiAOIAggBiADKAIwIAMoAjQQlCxB/wFxQQFGGyECIAQgDWsiBEEBSw0ACwsgACgCCCEEIAEgAkECdGooAgAhASADQShqIAAQ3DsgAyAEIAFrNgJsIAMgAykDKDcCZCADQSBqIANB5ABqEPAgIAggBiADKAIgIAMoAiQQlCxB/wFxIgFFDQEgAiABQf8BRmohBAsgCigCACEFAkAgBCAAQRhqIgIoAggiAU0EQCACKAIAIAFGBEAgAkHo/P4AEJ0oCyACKAIEIARBAnRqIQYCQCABIARNDQAgASAEa0ECdCIERQ0AIAZBBGogBiAE/AoAAAsgBiAFNgIAIAIgAUEBajYCCAwBCyAEIAFB6Pz+ABDCIQALDAELIANBGGogABDcOyADQRBqIAMoAhggAygCHCAJIAxByPz+ABDXJiADKAIUIgEEQCADKAIQQQAgAfwLAAsgCiAKKAIAIAVrNgIAIAIgACgCICIBTw0EIAAoAhwgAkECdGooAgAhBQsgACgCCCADQQhqIAAQ3DsgB2siAUEEaiECIAFBe0sNBCACIAMoAgwiBEsNBSADKAIIIAFqIAUgB2s2AAAgAEEANgIUIANB8ABqJAAgBw8LQQIgBkGY/P4AELA7AAtBBCAGQYj8/gAQsDsACyALIAZB+Pv+ABCwOwALIAIgAUHY/P4AEMMhAAsgASACQfj8/gAQsTsACyACIARB+Pz+ABCwOwALuSICHX8CfiMAQeABayIFJAAgBUEANgIMIAVCgICAgBA3AgQgASgCDCEGIAVBzAFqIgIQvS8gBUH4AGoiByAFQQRqIgMgBkEIaiACEKoVIAFBDGohEQJAIAUoAqABIgZBgICAgHhGBEAgBUHgAGogBUGIAWoiBigCACICNgIAIAVB2ABqIAVBgAFqIgQpAwAiHzcDACAFIAUpA3giIDcDUCAGIAI2AgAgBCAfNwMAIAUgIDcDeCAHENQZIQYgAEGAgICAeDYCACAAIAY2AgQgAxDeOyARKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAREPgjCyABEN4jIAFBBEEUEOAeDAELIAVB0ABqIgIgBUH4AGpBKPwKAAAgBUHMAGogBUG0AWooAgA2AgAgBUHEAGogBUGsAWopAgA3AgAgBSAFKQKkATcCPCAFQRBqIAJBKPwKAAAgBSAGNgI4IAEoAgghBiABKAIEIQ0gBSABKAIANgLEASAFIA02AsABIAUgDTYCvAEgBSANIAZBFGxqIhQ2AsgBIAVBOGohGAJAAkACQCAGBEAgBUHQAWoiGkEIaiEbA0ACQAJAIA0oAgAiAUGAgICAeEcEQCAFIAE2AswBIBogDUEEaikCADcCACAbIA1BDGopAgA3AgAgBUHQAGohDCAFQcwBaiIcIQYjAEHwAGsiByQAAkACQAJAIAVBEGoiAS0APEUEQCAHQSBqIQsgAUEIaiESQQAhBEEAIQhCACEfQQAhE0EAIRUjAEGgAmsiAiQAIAIgBhDxLSIWNgI4IAJBMGogFkEIaiIdEMM0IAIoAjQhAyACIAIoAjAiCTYC5AEgAkEANgLUASACQQA2AsQBIAIgCSADQQJ0ajYC6AEgAkHYAGohDyMAQUBqIgokAAJ/IAJBxAFqIgMoAgAEQCADKAIEIQggAygCDCEEQQAMAQtBAQshCQNAAkACQAJAAkACfwJAIAlFBEAgBCAIRw0BIAMQ3isgA0EANgIAQQEhCQwHCwJAIAMoAiAiBEUNACAEIAMoAiRGDQAgAyAEQQRqNgIgIApBGGogBCgCAEEIahCDFSAKKAIYIglBgICAgHhGDQAgCigCHCIIIAooAiBBAnRqIQQgAygCAARAIAMQ3isLIAMgBDYCDCADIAk2AgggAyAINgIEIAMgCDYCAAwFCwJAIAMoAhAEQCADKAIUIgQgAygCHCIIRw0BIANBEGoiBBDeKyAEQQA2AgALIA9BADYCCCAPQoCAgIDAADcCACADEOYtDAMLIAMgBEEEaiIONgIUIAMoAgwgAygCBGtBAnZBACADKAIAGyEJIAggDmtBAnYhDiAEKAIADAELIAMgCEEEaiIJNgIEIAMoAhwgAygCFGtBAnZBACADKAIQGyEOIAQgCWtBAnYhCSAIKAIACyEQIApBGGoiBEEDIAkgDmoiCCAIQQNNG0EBakEAQQRBBBCgGCAKKAIcIQggCigCGEEBRg0BIAooAiAiCSAQNgIAIApBFGoiHkEBNgIAIAogCTYCECAKIAg2AgwgBCADQSj8CgAAIApBDGohDkEAIQgjAEEQayIQJAAgBEEQaiEXA0ACQAJ/IAQoAgAEQCAEKAIEIQggBCgCDCETQQAMAQtBAQshCQNAAkACQAJAIAlFBEAgCCATRw0BIAQQ3isgBEEANgIAQQEhCQwECwJAIAQoAiAiCUUNACAJIAQoAiRGDQAgBCAJQQRqNgIgIBBBBGogCSgCAEEIahCDFSAQKAIEIglBgICAgHhGDQAgECgCCCIIIBAoAgxBAnRqIRMgBCgCAARAIAQQ3isLIAQgEzYCDCAEIAk2AgggBCAINgIEIAQgCDYCAAwCCwJAIBcoAgAEQCAEKAIUIgkgBCgCHEcNASAXEN4rIBdBADYCAAsgBBDmLSAQQRBqJAAMBQsgBCAJQQRqNgIUIAkoAgAhCQwCCyAEIAhBBGo2AgQgCCgCACEJDAELQQAhCQwBCwsgDigCCCIZIA4oAgBGBEAgDiAEKAIcIAQoAhRrQQJ2QQAgBCgCEBsgBCgCDCAEKAIEa0ECdkEBakEBIAQoAgAbahCALgsgDigCBCAZQQJ0aiAJNgIAIA4gGUEBajYCCAwBCwsgD0EIaiAeKAIANgIAIA8gCikCDDcCAAsgCkFAayQADAILIAggCigCIEHYyP4AEP0vAAtBACEJDAELCyADIAIoAmBBAEEEQRgQoBggAigCyAEhBAJAAkACQAJAIAIoAsQBQQFHBEAgAkEANgJEIAIgAigCzAE2AkAgAiAENgI8IA8Q6TsgAyASQSBqEKUdIAIgAigCxAE2AlAgAiACKALIASIDNgJIIAIgAzYCTCACIAMgAigCzAFBA3RqNgJUIAJBKGogHRDDNCACKAIsIgMEQCACKAIoIQQgA0ECdCEJQQAhAwNAIAYgAxCPLSEIIAJBxAFqIAQoAgBBCGogCCACQTxqIBIgASACQcgAahDKAyACKALEASIIQZOAgIB4RwRAIAsgAikCyAE3AgggC0EQaiACQdABaikCADcCACALIAg2AgQMBgsgBEEEaiEEIANBAWohAyAJQQRrIgkNAAsLIAJB2ABqEIYgIAJBADYCnAEgAkKAgICAEDcClAEgAkEANgKoASACQoCAgIAQNwKgASACQQA2ArQBIAJCgICAgBA3AqwBAkACQAJAAkAgAS0AACIJRQRAQQIhCAwBCyABLQABIQMgAiACKAKIASIINgLIASACIAJB2ABqIgo2AsQBIAJBAToAkAEgAkHEAWoiBBC7ESAEIAMQhxEgCiAIENgHIRIgAkEANgJsIAJBADoAkAEgBCADEOIbQQIhCAJAIAIoAsQBIgNB7f///wdqDgIAAQILIAItAMgBIQgLIAJBADYCwAEgAkKAgICAgAE3ArgBIAJBIGogBhDcOyACKAIkIgMEQCACKAIgIQQgA0EDdCEDA0AgAkHEAWoiCiAEEMMtIAJBiAJqIAogAkGgAWogAkGsAWogAkGUAWogHyAEEPQtIAQQ+C0gCCABEJgBIAIoAogCBEAgAikDkAIiH6ciBEEIdiEJIB9CIIinIQYgAikDmAIhHyACKAKMAiEDIAoQ/iYgAkG4AWoQ4zwMBAsgBEEIaiEEIAIpA5ACIR8gAkG4AWogAkHEAWoiChCpGCAKEP4mIANBCGsiAw0ACwsgAigCtAEiAyABLQAGQQFrQf8BcSIEaiAEQX9zcSADayIDQcEATw0EIAJBrAFqQfzM/gAgAxChNiACQdgAaiIDIAIoAqQBIAIoAqgBENUQIQggAyACKAKYASACKAKcARDVECEKIAIoAsABIgQEQCADIAIoArwBIAQQsg0hFQsgAkEBOgCQASACIAIoAogBIgM2AsgBIAIgAkHYAGoiDzYCxAEgD0EEIAY1AhAQyw4gAkHEAWoiBiAKEPEOIAYgCBDwDiAJBEAgBiASEPIOCyAEBEAgAkHEAWogFRDzDgsgAkHYAGoiBiADENgHIQQgAkEANgJsIAJBAToAkAEgAiACKAKIASIINgKMAiACIAY2AogCIAJBiAJqIgMgAS8BAhDEDiADQQMQnxIgBkEKIAI1ArQBEMsOIAMgBBDwDiAGIAgQ2AchAyACQQA2AmwgAkEAOgCQASAGIAMQpAwgAkEYaiAGENw7IAIoAhwhBiACKAIYIQMgAkEQaiACKAKIARCMNyACQQhqIAMgBiACKAIQIAIoAhRB5Mb+ABDXJiACKAIIIQYgAkHEAWogAigCDCIEQQBBAUEBEKAYIAIoAsgBIQggAigCxAFBAUYNBSACKALMASEDIAQEQCADIAYgBPwKAAALIARBCHYhCSACKQKwASEfIAIoAqwBIQYgAkG4AWoQ4zwMAgsgAi8AyQEgAkHLAWotAABBEHRyIQkgAikC0AEhHyACKALMASEGIAItAMgBIQQLIAJBrAFqEN47QYCAgIB4IQgLIAJBoAFqQQFBEBDgHiACQZQBakEBQRAQ4B4gBK1C/wGDIAmtQv///weDQgiGhCAGrUIghoQhICACQdgAahDMKiAIQYCAgIB4RgRAIAsgHzcCECALICA3AgggCyADNgIEDAQLIAsgAikCPDcCACALIB83AhwgCyAgNwIUIAsgAzYCECALIAg2AgwgC0EIaiACQcQAaigCADYCACACIAIoAkg2AsgBIAIgAigCUDYCxAEgAkHEAWoQ4zwMBAsgBCACKALMAUHczP4AEP0vAAsgA0HAAEG8zf4AELA7AAsgCCACKALMAUGoyf4AEP0vAAsgC0GAgICAeDYCACACIAIoAkg2AsgBIAIgAigCUDYCxAEgAkHEAWoQ4zwgAkE8aiIEIgYoAggiAwRAIAYoAgQhBgNAIAYQ3jsgBkEMahDeOyAGQRhqIQYgA0EBayIDDQALCyAEQQRBGBDgHgsgFiAWKAIAIgZBAWs2AgAgBkEBRgRAIAJBOGoQ+CMLIAJBoAJqJAACQAJAIAcoAiAiBEGAgICAeEcEQCAHKAIkIQYgBygCKCEDIAdBGGoiCCAHQTxqKQIANwMAIAdBEGogB0E0aikCADcDACAHIAcpAiw3AwggByAGIANBGGxqIgI2AmggByAENgJkIAcgBjYCYCAHIAY2AlwgA0UNAiABQThqIQQgB0HIAGoiA0EIaiEJIANBEGohCgNAAkAgBigCACILQYCAgIB4RwRAIAMgBkEEaikCADcCACAJIAZBDGopAgA3AgAgCiAGQRRqKAIANgIAIAcgCzYCRCAHQSBqIAQgB0HEAGogARDaCiAHKAIgIgtBk4CAgHhGDQEgByAGQRhqNgJgIAcpAiQhHyAMIAcpAiw3AgwgDCAfNwIEIAwgCzYCACAHQdwAahCAHyAHQQhqEN47IAdBFGoQ3jsMBwsgBkEYaiECDAMLIAZBGGoiBiACRw0ACwwBCyAHQRhqIAdBNGooAgA2AgAgB0EQaiAHQSxqKQIANwMAIAcgBykCJDcDCEG8vswAQcEAIAdBCGpB8LjMAEGAv8wAENUeAAsgByACNgJgCyAHQdwAaiIGEIAfIAdBMGogCCkDADcDACAHQShqIAdBEGopAwA3AwAgByAHKQMINwMgIAYgAUE4aiAHQSBqIAEQ2gogBygCXCIBQZOAgIB4RwRAIAcpAmAhHyAMIAcpAmg3AgwgDCAfNwIEIAwgATYCAAwCCyAMQZOAgIB4NgIADAELIAdBIGpBOkEAQQFBARCgGCAHKAIkIQEgBygCIEEBRg0BIAcoAigiBkGQv8wAQTr8CgAAIAxBOjYCDCAMIAY2AgggDCABNgIEIAxBjICAgHg2AgALIAdB8ABqJAAMAQsgASAHKAIoQey7zAAQ/S8ACyAFKAJQIgFBk4CAgHhGDQEgBSANQRRqNgLAASAFQYQBaiAFQdwAaikCADcCACAFIAUpAlQ3AnwgBSABNgJ4IAVB+ABqENQZIQEgAEGAgICAeDYCACAAIAE2AgQgHBDpKyAFQbwBahDlIAwFCyANQRRqIRQMAQsgBUHMAWoQ6SsgDUEUaiINIBRHDQELCyAFIBQ2AsABCyAFQbwBahDlICAFQdAAaiAFQRBqEKsVIAUoAlAiAUGTgICAeEYNASAFQYQBaiAFQdwAaikCADcCACAFIAUpAlQ3AnwgBSABNgJ4IAVB+ABqENQZIQEgAEGAgICAeDYCACAAIAE2AgQLIAVBGGoQ7SYgGBDjPCAFQQRqEN47IBEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAVBGGoQ7SYgGBDjPCAAQQhqIAVBDGooAgA2AgAgACAFKQIENwIAIBEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRw0BCyAREPgjCyAFQeABaiQAC/ENAgl/AX4jAEEQayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0ECTQRAIAEgA0ECdGooAhAhDSALQQA2AgQgDUECSQ0LIANBuAhsIQYgAEUEQCABKAIEIgkgBkkNAiABKAIAIAIpAwAhDyACKAIIIgdBME8EQCACKAIMIgBBCGohCiAAQXdLDQQgBSAKSQ0FIAIgAEEGajYCDCACIAIoAhBBBms2AhAgAiAAIARqIgA1AABCEIYgD0IwiIQgADEABEIwhoQgADEABUI4hoQiDzcDACAHQTBzIQcLIA8gB0E/ca2IpyIOQf8BcSIIIAkgBmsiCU8NBSAGQQJ0aiIMIAhBAnRqIgAvAQAhCiAALQACIgBBCEsEQCAAQQhrQf8BcSIAQSFPDQcgCCAKaiAAQQJ0Qfic8wBqKAIAIA5BCHZxaiIAIAlPDQggB0EIaiEHIAwgAEECdGoiCi0AAiEAIAovAQAhCgsgAiAHIABB/wFxajYCCCABKAIMIgAgBkkNCCABIANBAnRqAn8gASgCCCAGQQJ0aiEMIAAgBmshByACKQMAIQ8CQAJAAkACQAJAAkACQAJAAkAgAigCCCIAQTBPBEAgAigCDCIGQQhqIQggBkF3Sw0BIAUgCEkNGCACIAZBBmo2AgwgAiACKAIQQQZrNgIQIAIgBCAGaiIGNQAAQhCGIA9CMIiEIAYxAARCMIaEIAYxAAVCOIaEIg83AwAgAEEwcyEACyAPIABBP3GtiKciDkH/AXEiCCAHTw0BIAwgCEECdGoiCS8BACEGIAktAAIiCUEISwRAIAlBCGtB/wFxIglBIU8NAyAGIAhqIAlBAnRB+JzzAGooAgAgDkEIdnFqIgYgB08NBCAMIAZBAnRqIgYtAAIhCSAGLwEAIQYgAEEIaiEACyAGQRlNBEAgBkECdCIGQdCh8wBqLwEAIQwCfgJ/AkAgBkHSofMAai0AACIGQQlJIAAgCWoiAEE4T3FFBEAgBkERSSAAQTBPcQ0BIABBH0sEQCACKAIMIghBBGohByAIQXtLDQwgBSAHSQ0NIAIgBzYCDCACIAIoAhBBBGs2AhAgAiAEIAhqNQAAQiCGIA9CIIiEIg83AwAgAEEgcyEACyAGQSFPDQ0gDyAAQT9xrYgMAwsgAigCDCIHQQhqIQggB0F3Sw0IIAUgCEkNGyACIAdBB2o2AgwgAiACKAIQQQdrNgIQIAQgB2oiBDUAAEIIhiAPQjiIhCAEMQAEQiiGhCAEMQAFQjCGhCAEMQAGQjiGhCEPIABBOHMMAQsgAigCDCIHQQhqIQggB0F3Sw0IIAUgCEkNGiACIAdBBmo2AgwgAiACKAIQQQZrNgIQIAQgB2oiBDUAAEIQhiAPQjCIhCAEMQAEQjCGhCAEMQAFQjiGhCEPIABBMHMLIQAgAiAPNwMAIA8gAEE/ca2ICyEPIAIgACAGajYCCCAGQQJ0Qfic8wBqKAIAIA+ncSAMagwKCyAGQRpBwKHzABDDIQALIAYgCEGcnvMAELE7AAsgCCAHQaye8wAQwyEACyAJQSFB/J3zABDDIQALIAYgB0G8nvMAEMMhAAsgByAIQZye8wAQsTsACyAHIAhBnJ7zABCxOwALIAggB0GMnvMAELE7AAsgByAFQYye8wAQsDsACyAGQSFB/J3zABDDIQALNgIgIAohAgwLCyABKAIEIgAgBkkNCCACKAIQIQogAigCDCEIIAIoAgghCSACKQMAIQ8gASgCACAGQQJ0aiAAIAZrIAIgC0EEaiAEIAUQnxNFDQsgC0EANgIIIAEoAgwiACAGSQ0JAn8gAS0ARARAQQEhACABKAIcDAELIAEoAgggC0EANgIMIAZBAnRqIAAgBmsgAiALQQxqIAQgBRCfEyEAIAsoAgxBACAAGwshBiABIAIgC0EIaiAAIAYgBCAFENQbRQRAIAIgCjYCECACIAg2AgwgAiAJNgIIIAIgDzcDAEEAIQcgAUEAOgBEDAwLIAEgA0ECdGogCygCCDYCICALKAIEIQIMCgsgA0EDQYSk8wAQwyEACyAGIAlBlKTzABCvOwALIAAgCkGcnvMAELE7AAsgCiAFQZye8wAQsDsACyAIIAlBrJ7zABDDIQALIABBIUH8nfMAEMMhAAsgACAJQbye8wAQwyEACyAGIABBpKTzABCvOwALIAYgAEG0pPMAEK87AAsgBiAAQcSk8wAQrzsACyABIANBA3RqQSxqIQACfwJAAkACQCACDgICAAELIAAoAgRBAWoMAgsgAkECawwBCyAAKAIACyEBIAAgACgCBDYCACAAIAEgDUEAIAEgDU8bazYCBEEBIQcLIAtBEGokACAHDwsgCCAFQZye8wAQsDsAC5QIAgJ/AX4jAEEQayIGJAACQCAAIAQQqCggBEcEQEG4fyEFDAELIAAgASACEIopIAAgACkD8OkBIAStfDcD8OkBQX8hBQJAAkACQAJAAkACQAJAAkAgACgChOoBDggAAQIDAwQFBggLAkAgACgC7OoBIgENACADKAAAQXBxQdDUtMIBRw0AIAQEQCAAQaDsBWogAyAE/AoAAAsgAEEGNgKE6gEgAEEIIARrNgK86QFBACEFDAgLIAAgAyAEIAEQsSAiBTYC6OoBIAVBiH9LDQcgBARAIABBoOwFaiADIAT8CgAACyAAQQE2AoTqASAAIAUgBGs2ArzpAUEAIQUMBwsgAEGg7AVqIQEgACgC6OoBIQIgBARAIAEgAiAEa2ogAyAE/AoAAAsgACABIAIQkBciBUGIf0sNBiAAQQI2AoTqASAAQQM2ArzpAUEAIQUMBgsgA0EDIAZBBGoQlCMiAUGIf0sEQCABIQUMBgtBbCEFIAEgACgC0OkBSw0FIAAgATYCvOkBIAAgBigCBDYCgOoBIAAgBigCDDYCjOsBIAYoAgghAiAAAn9BBEEDIAIbIAENABogAgRAIAAoAuDpAQRAIABBBDYCvOkBQQUMAgsgAEEANgK86QFBAAwBCyAAQQM2ArzpAUECCzYChOoBQQAhBQwFC0FsIQUCQAJ/AkACQAJAIAAoAoDqAQ4DAQIACQsgACABIAIgAyAEQQEQqQIMAgsgAiAESQRAQbp/IQUMCAsCQCABRQRAIARFDQFBtn8hBQwJCyAEBEAgASADIAT8CgAACyAEQYh/TQ0AIAQhBQwICyAAIAAoArzpASAEayICNgK86QEgBCEFDAILQbp/IAIgACgCjOsBIgJJDQAaQbZ/QQAgAhsgAUUNABogAgRAIAEgAy0AACAC/AsACyACCyEFQQAhAiAAQQA2ArzpASAFQYh/Sw0FCyAFIgMgACgC0OkBSwRAQWwhBQwFCyAAIAApA/jpASADrXw3A/jpASAAKAL06gEEQCAAQZDqAWogASADEIkMIAAoArzpASECCyAAIAEgA2o2AqzpASACDQMgACgChOoBQQRGBEAgACkDwOkBIgdCf1IEQEFsIQUgACkD+OkBIAdSDQYLIAAoAuDpAQRAIABBBTYChOoBIABBBDYCvOkBDAULIABBADYChOoBIABBADYCvOkBDAQLIABBAzYCvOkBIABBAjYChOoBDAMLIAAoAvTqAUUNASADKAAAIABBkOoBahDuFqdGDQFBaiEFDAMLIAQEQCAAIARrQajsBWogAyAE/AoAAAsgAEEHNgKE6gEgACAAKACk7AU2ArzpAUEAIQUMAgtBACEFIABBADYChOoBIABBADYCvOkBDAELIAMhBQsgBkEQaiQAIAUL1QYBD38jAEEQayIJJABBASEMAkAgAigCACIKQSIgAigCBCIOKAIQIg8RAgANAAJAIAFFBEBBACECDAELQQAgAWshECAAIQggASEGA0AgBiAIaiERQQAhAgJAAkADQCACIAhqIgUtAAAiB0H/AGtB/wFxQaEBSSAHQSJGciAHQdwARnINASAGIAJBAWoiAkcNAAsgBCAGaiEEDAELIAVBAWohCCACIARqIQYCfwJAIAUsAAAiB0EATgRAIAdB/wFxIQUMAQsgCC0AAEE/cSELIAdBH3EhDSAFQQJqIQggB0FfTQRAIA1BBnQgC3IhBQwBCyAILQAAQT9xIAtBBnRyIQsgBUEDaiEIIAdBcEkEQCALIA1BDHRyIQUMAQsgCC0AACEHIAVBBGohCCANQRJ0QYCA8ABxIAdBP3EgC0EGdHJyIgVBgIDEAEcNACAGDAELIAkgBUGBgAQQjwkCQCAJLQANIAktAAxrQf8BcUEBRg0AAkACQAJAIAMgBksNAAJAIANFDQAgASADTQRAIAEgA0cNAgwBCyAAIANqLAAAQb9/TA0BCwJAIAZFDQAgASAGTQRAIAYgEGpFDQEMAgsgACAEaiACaiwAAEG/f0wNAQsgCiAAIANqIAQgA2sgAmogDigCDCIDEQYARQ0BDAILIAAgASADIAIgBGpBkPeJARCjNgALAkAgCS0ADSIGQYEBTwRAIAogCSgCACAPEQIADQIMAQsgCiAJIAktAAwiB2ogBiAHayADEQYADQELAn9BASAFQYABSQ0AGkECIAVBgBBJDQAaQQNBBCAFQYCABEkbCyAEaiACaiEDDAELDAULAn9BASAFQYABSQ0AGkECIAVBgBBJDQAaQQNBBCAFQYCABEkbCyAEaiACagshBCARIAhrIgYNAQsLAkAgAyAESw0AQQAhAgJAIANFDQAgASADTQRAIAMhAiABIANHDQIMAQsgAyECIAAgA2osAABBv39MDQELIARFBEBBACEEDAILIAEgBE0EQCABIARGDQIgAiEDDAELIAAgBGosAABBv39KDQEgAiEDCyAAIAEgAyAEQaD3iQEQozYACyAKIAAgAmogBCACayAOKAIMEQYADQAgCkEiIA8RAgAhDAsgCUEQaiQAIAwLzwYBC38jAEGwKGsiAyQAAkAgAUEDakF8cSABayIFIAJLBEBBASEKQQQhBwwBCyABIAVqIgcgAiAFayICQXxxaiEKIAJBA3EhCyACQQJ2IQQgBSECCyAAQX9zIQAgAgRAA0AgAS0AACAAc0H/AXFBAnRB0Nb8AGooAgAgAEEIdnMhACABQQFqIQEgAkEBayICDQALCyADQQxqQgA3AgAgA0IANwIEIAMgADYCAEEAIQUgBEEFbiIBQQFrIgJBACABIAJPGyEMIARBCk8EQCAHIQgDQCAEIAUgBCAFSRshAiAJQQFqIQlBACEBIAUhAAJAAkADQCACIARGDQEgA0EUaiABaiABIANqKAIAIAEgCGooAgBzNgIAIABBAWohACACQQFqIQIgAUEEaiIBQRRHDQALIANBwCBqIANBJGooAgA2AgAgA0G4IGogA0EcaikCADcDACADQQhqQgA3AwBBACEGIANBEGpBADYCACADIAMpAhQ3A7AgIANCADcDAANAIAZBCnRB0Lb8AGohAEEAIQEDQCADQbAgaiABaiICIAIoAgAiAkEIdjYCACABIANqIg0gDSgCACAAIAJB/wFxQQJ0aigCAHM2AgAgAUEEaiIBQRRHDQALIAZBAWoiBkEERw0ACwwBCyAAIARBwLb8ABDDIQALIAhBFGohCCAFQQVqIQUgCSAMSQ0ACyADKAIAIQALIANBADYCACAMQQVsIgEgBE0EQCABIARHBEAgBCABayEIIAcgAUECdGohByADQRxqIQQgA0GkIGohBUEAIQYDQCADIAAgByAGQQJ0IgBqKAIAc0GstvwAIAAgA2ogBkEFTxsoAgBzNgKkICADQoCAgIDAADcCnCAgBEGslvwAQYAg/AoAACADQgA3AqggQQAhAEEIIQIgBSEBA0AgAS0AACADQbAgaiIMIANBFGogAmpBgAj8CgAAIAFBAWohAUECdCAMaigCACAAcyEAIAJBgAhqIgJBiCBHDQALIAZBAWoiBiAIRw0ACwsgCwRAA0AgCi0AACAAc0H/AXFBAnRB0Nb8AGooAgAgAEEIdnMhACAKQQFqIQogC0EBayILDQALCyADQbAoaiQAIABBf3MPCyABIARBsLb8ABCvOwALk4wBAhV/CH4jAEEgayIZJABBASEFAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAYQQFrDigAAQIVFgMEBQYHCAkWFRYVFhYKCwwNDgsNDhgPEBEPEhMUFRYaFxgZJgsgAiEFIwBB8ABrIgwkAAJ/AkACQAJAAkACQCAAKAIIBEAgDEEYaiAAKAIEENw7IAEoAggEQCAMKAIcIREgDCgCGCEWIAxBEGogASgCBBDcOyAMKAIUIRggDCgCECETIAAoAixFDQIgDEEIaiAAQSxqIgcQ3DsgDEEgaiIGIAwoAgggDCgCDCAAKAI4IAVqIgIgBBD6EyAMQeAAaiAGENUJAkAgDCgCYEEBRgRAIAwoAmQNASAMKAJoIARHDQEMBAsgBEUNAwsgDCAHENw7IAxBIGogDCgCACAMKAIEIAIgBBC/FCABKAIoIANqIQQgACgCKCAFaiEDIAxBQGshAiAMKQNIIRsCQANAAkAgG1BFBEAgDCkDUCEaDAELA0ACfgJAIAwpAzAiGkIDUgRAAkACQAJAIBpCAlENACAMIBpQrUIBhjcDMCAap0EBcUUNACAMIAwpAzg3A2gMAQsgDCgCQEUNASAMQeAAaiACELYqIAwpA2AhGgsgGkIAUg0CCyAMQgM3AzALIAwpAyAiGkICUQ0JIAxCADcDICAMKQMoDAELIAwpA2gLIRtBASAap0EBcUUNCxogDCAMKQNQQkB9Iho3A1AgDCAbNwNIIBtQDQALCyAMQgEgG3oiHIYgG4UiGzcDSCARIAMgHKcgGqdqIgBqIgFBA3YiBksEQCAAIARqIgBBA3YiBSAYTw0CIAYgFmotAAAgAUEHcXZBAXEgBSATai0AACAAQQdxdkEBcUYNAQwJCwsgBiARQay6hwEQwyEACyAFIBhBrLqHARDDIQALQQBBAEGgu4cBEMMhAAtBAEEAQZC7hwEQwyEACyABKAIoIgdBB3EgAyAFckEHcSAAKAIoIgZBB3Fycg0BAkAgBEEHTQ0AAkAgESAGQQN2IAVBA3ZqIgIgBEEDdiILaiIATwRAIAdBA3YgA0EDdmoiASALaiIAIBhLDQEgAiAWaiALIAEgE2ogCxCfOw0CDAYLIAAgEUHIvIcBELA7AAsgACAYQdi8hwEQsDsACyAEQQdxIgBFDQAgBEF4cSIBIANqIQMgASAFaiEFDAILQQEMAwsgBCEACyAMQSBqIBYgESAFIAZqIAAQhx0gAyAHaiEDIAwoAiwhBiAMKAIoIQsgDCgCICEFIAwoAjAiBAR+IAUgBkEDdGoiAjEAACALQT9xrYghGiAEIAtqIgFBA3YgAUEHcUEAR2oiAUECTwRAQQggC2shFiABQQFrIREgAkEBaiEJA0AgCTEAACAWQT9xrYYgGoQhGiAJQQFqIQkgFkEIaiEWIBFBAWsiEQ0ACwsgGkJ/IARBP3GthkJ/hYMFQgALIR0gDEEgaiATIBggAyAAEIcdIAwoAiwhAyAMKAIoIQcgDCgCICEEAn4gDCgCMCICRQRAIAdBP3GtIR5CAAwBCyAEIANBA3RqIgExAAAgB0E/ca0iHoghGiACIAdqIgBBA3YgAEEHcUEAR2oiAEECTwRAQQggB2shFiAAQQFrIREgAUEBaiEJA0AgCTEAACAWQT9xrYYgGoQhGiAJQQFqIQkgFkEIaiEWIBFBAWsiEQ0ACwsgGkJ/IAJBP3GthkJ/hYMLIRwgC0E/ca0hH0EAIRFBACAHa0E/ca0hIEEAIAtrQT9xrSEhQQEhAkEAIQlBASEAA0ACQCAFRSAGIAlNckUEQCAFIAlBA3RqIgEpAAAhGiALBEAgAUEIajEAACAhhiAaIB+IhCEaCyAJQQFqIQkMAQsgACEBQQAhAEEAIQUgHSEaQQEgAUUNAxoLAkAgBEUgAyARTXJFBEAgBCARQQN0aiIBKQAAIRsgBwRAIAFBCGoxAAAgIIYgGyAeiIQhGwsgEUEBaiERDAELIAIhAUEAIQJBACEEIBwhG0EBIAFFDQMaCyAaIBtRDQALC0EACyAMQfAAaiQAIQUMJQsgACABIAIgAyAEELAGIQUMJAsgACABIAIgAyAEEMAEIQUMIwsgACABIAIgAyAEELAGIQUMIgsgACABIAIgAyAEEMAEIQUMIQsgACABIAIgAyAEEL4EIQUMIAsgACABIAIgAyAEEL8EIQUMHwsgACABIAIgAyAEEMAEIQUMHgsgACABIAIgAyAEEL4EIQUMHQsgACABIAIgAyAEEL8EIQUMHAsgAC0AGUEBaw4CCw8KCyMAQYABayIKJAAgCkEoaiAAQQAQ5x0gCigCLCENIAooAighFyAKQSBqIAFBABDnHQJ/AkACQCAAKAIIIgVBAk8EQCAKKAIkIQ8gCigCICEVIApBGGogACgCBEEMahDcOyABKAIIIgVBAU0NASAKKAIcIQggCigCGCEOIApBEGogASgCBEEMahDcOyAKKAIUIRAgCigCECEUIAAoAixFDQIgCkEIaiAAQSxqENw7IApBQGsiBSAKKAIIIAooAgwgACgCOCACaiIJIAQQ+hMgCkE0aiAFENUJAkACQCAKKAI0QQFGBEAgCigCOEUEQCAKKAI8IARGDQYLIAQNAUEAIQUMAgsgBEUNBAtBACEFIAAoAjwiByACayIGQQAgBiAHTRshESABKAI4IANqIRggASgCMCEWIAEoAjwhEyABKAIsIQsgACgCMCEHA0AgBSARRg0hIAMgBWohDCAHIAUgCWoiBkEDdmotAAAhAQJAIAsEfyAMIBNPDSMgFiAFIBhqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEgAUH/AXMgBkEHcXYiAEEBcXJFBEAgDiAIIBQgECAXIA0gFSAPIAIgBWogDEEBENgQDQEMAwsgAEEBcUUNAgsgBCAFQQFqIgVHDQALIAQhBQsgBCAFTQwDC0EBIAVBtK6HARDDIQALQQEgBUHErocBEMMhAAsgDiAIIBQgECAXIA0gFSAPIAIgAyAEENgQCyAKQYABaiQAIQUMGgsCfyMAQYACayIKJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAYQRVGBEAgACgCCEUNAiAAKAIcIQ0gCkEgaiAAKAIEENw7IAooAiQiBiANIAAoAigiE2wiB0kNASABKAIIRQ0EIAooAiAhCCAKQRhqIAEoAgQQ3DsgCigCHCIFIAEoAigiCyANbCIRSQ0DIAcgCGohGCAGIAdrIQ8gCigCGCIHIBFqIRYgBSARayEVIAAoAixFDREgCkEQaiAAQSxqIgYQ3DsgCkHoAGoiBSAKKAIQIAooAhQgACgCOCACaiIOIAQQ+hMgCkH0AWogBRDVCQJAIAooAvQBQQFGBEAgCigC+AENASAKKAL8ASAERw0BDBMLIARFDRILIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgCkEIaiAGENw7IApBKGoiACAKKAIIIAooAgwgDiAEEPoTIAEoAixFDQYgCiABQSxqENw7IApBqAFqIgUgCigCACAKKAIEIAEoAjggA2ogBBD6EyAKQegAaiAAQcAA/AoAACAKQgA3A+gBA0AgCkH0AWoiACAKQegAahDVCQJAIAooAvQBQQFGBEAgCigC/AEhASAKKAL4ASEEIAAgBRDVCSAKKAL0AQ0BC0EBIQYMFQtBACEGIAQgCigC+AFHDRQgASAKKAL8AUcNFCABIARrIA1sIgcgAiAEaiANbCIBaiIAIAdJDQggACAPSw0JIAcgAyAEaiANbCIAaiIEIAdJDQogBCAVSw0LIAEgGGogByAAIBZqIAcQnzsNAAsMEwsgASgCLEUNCgJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshECAAKAI8IgYgAmsiBUEAIAUgBk0bIRQgAiANbCEMIAMgDWwhCSANIAJBAWpsIREgDSADQQFqbCEYIAEoAjggA2ohFiAIIA0gAiATamxqIRMgByANIAMgC2psaiELIAEoAjAhByAAKAIwIQZBACEAA0AgACAURg0NIAAgEEYNDgJAAkAgBiAAIA5qIgFBA3ZqLQAAQQEgAUEHcXRxIgVFDQAgByAAIBZqIgFBA3ZqLQAAQQEgAUEHcXRxRQ0AIBEgF2oiBSAMIBdqIgFJDREgBSAPSw0SIBcgGGoiBSAJIBdqIgFJDRMgBSAVSw0UIBMgF2ogDSALIBdqIA0QnzsNAQwDCyAFDQILIA0gF2ohFyAEIABBAWoiAEcNAAsgBCEACyAAIARPIQYMEgtBkLyHAUEoQbi8hwEQnykACyAHIAZBwLuHARCvOwALQQBBAEGwu4cBEMMhAAsgESAFQeC7hwEQrzsAC0EAQQBB0LuHARDDIQALQfC7hwEQsjsACyABIABByLyHARCxOwALIAAgD0HIvIcBELA7AAsgACAEQdi8hwEQsTsACyAEIBVB2LyHARCwOwALQYC8hwEQsjsAC0G8uocBQSBB3LqHARCfKQALQby6hwFBIEHcuocBEJ8pAAsgASANIAJBAWpsIBdqQci8hwEQsTsACyANIAJBAWpsIBdqIA9ByLyHARCwOwALIAEgDSADQQFqbCAXakHYvIcBELE7AAsgDSADQQFqbCAXaiAVQdi8hwEQsDsACyAEIA1sIgQgAiANbCIBaiIAIARJDQEgACAPSw0CIAQgAyANbCIAaiICIARJDQMgAiAVSw0EIAEgGGogBCAAIBZqIAQQnzshBgsgCkGAAmokACAGDAQLIAEgAEHIvIcBELE7AAsgACAPQci8hwEQsDsACyAAIAJB2LyHARCxOwALIAIgFUHYvIcBELA7AAshBQwZCyMAQYABayIKJAAgCkEoaiAAEOMdIAooAiwhDSAKKAIoIRcgCkEgaiABEOMdAn8CQAJAIAAoAggiBUECTwRAIAooAiQhDyAKKAIgIRUgCkEYaiAAKAIEQQxqENw7IAEoAggiBUEBTQ0BIAooAhwhCCAKKAIYIQ4gCkEQaiABKAIEQQxqENw7IAooAhQhECAKKAIQIRQgACgCLEUNAiAKQQhqIABBLGoQ3DsgCkFAayIFIAooAgggCigCDCAAKAI4IAJqIgkgBBD6EyAKQTRqIAUQ1QkCQAJAIAooAjRBAUYEQCAKKAI4RQRAIAooAjwgBEYNBgsgBA0BQQAhBQwCCyAERQ0EC0EAIQUgACgCPCIHIAJrIgZBACAGIAdNGyERIAEoAjggA2ohGCABKAIwIRYgASgCPCETIAEoAiwhCyAAKAIwIQcDQCAFIBFGDR8gAyAFaiEMIAcgBSAJaiIGQQN2ai0AACEBAkAgCwR/IAwgE08NISAWIAUgGGoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcSABQf8BcyAGQQdxdiIAQQFxckUEQCAOIAggFCAQIBcgDSAVIA8gAiAFaiAMQQEQoxANAQwDCyAAQQFxRQ0CCyAEIAVBAWoiBUcNAAsgBCEFCyAEIAVNDAMLQQEgBUG0rocBEMMhAAtBASAFQcSuhwEQwyEACyAOIAggFCAQIBcgDSAVIA8gAiADIAQQoxALIApBgAFqJAAhBQwYCyMAQSBrIhUkACAVQRhqIAAQ5h0CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBCACIARqIgZNBEAgBiAVKAIcIgVLDQEgACgCCCILRQ0CIBUoAhggACgCBCEGIBVBEGogARDmHSADIARqIhMgBEkNAyATIBUoAhQiBUsNBCABKAIIIgVFDQUgBEUNCyACQQR0aiEIIAtBAWshCSAGQQxqIQsgBUEBayERIAEoAgRBDGohByAVKAIQIANBBHRqIQ4gACgCOCEGIAAoAjAhBSAAKAI8IQMgACgCLCECA0ACQCACBEAgAyAQTQ0pIAUgBiAQaiIAQQN2ai0AACAAQQdxdkEBcUUNAQsgCCkDACIdIA4pAwAiHFINDiAOKQMIIRogCCkDCCEbIB2nIhRBDU8EQCAJIBunIgBNDQkgGqciEyARSQRAIBVBCGogCyAAQQxsahDcOyAbQiCIpyIAIBRqIgEgAEEEaiIWSQ0LIAEgFSgCDCIASw0MIBUoAgggFSAHIBNBDGxqENw7IBpCIIinIgAgFGoiDCAAQQRqIhNJDQ0gDCAVKAIEIgBLDQ4gFmogFEEEayIAIBUoAgAgE2ogABDBLg0CDBALIBMgEUGAxYcBEMMhAAsgHCAdhSAaIBuFhFBFDQ4LIA5BEGohDiAIQRBqIQggEEEBaiIQIARHDQALDAsLIAIgBkGwxIcBELE7AAsgBiAFQbDEhwEQsDsAC0EBQQBBwMSHARCvOwALIAMgE0HQxIcBELE7AAsgEyAFQdDEhwEQsDsAC0EBQQBB4MSHARCvOwALIAAgCUHwxIcBEMMhAAsgFiABQZDFhwEQsTsACyABIABBkMWHARCwOwALIBMgDEGgxYcBELE7AAsgDCAAQaDFhwEQsDsAC0EBIRgLIBVBIGokACAYIQUMFwsgGUEANgIYIBlBATYCDCAZQdjChwE2AgggGUIENwIQIBlBCGpB4MKHARDvLAALIwBB4ABrIhAkAAJ/AkACQAJAAkACQAJAIAAtABhBHUYEQCAAKAIURQ0BIAEoAhRFDQIgACgCECEJIAAoAhwhFCABKAIQIREgACgCLEUNBiAQQQhqIABBLGoQ3DsgEEEgaiIFIBAoAgggECgCDCAAKAI4IAJqIhggBBD6EyAQQRRqIAUQ1QkCQCAQKAIUQQFGBEAgECgCGA0BIBAoAhwgBEcNAQwICyAERQ0HCyABKAIsRQ0DAkAgBEUEQEEAIQAMAQsgASgCPCIGIANrIgVBACAFIAZNGyEWIAAoAjwiBiACayIFQQAgBSAGTRshEyABKAI4IANqIQsgFCABKAIoIANqbCEHIBQgACgCKCACamwhBiABKAIwIQUgACgCMCEDQQAhAANAIAAgE0YNBiAAIBZGDQcCQAJAIAMgACAYaiIBQQN2ai0AAEEBIAFBB3F0cSICRQ0AIAUgACALaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAJIBEgBiAMaiAHIAxqIBQQ6ywNAQwDCyACDQILIAwgFGohDCAEIABBAWoiAEcNAAsgBCEACyAAIARPDAcLQcimhwFBKEHwpocBEJ8pAAtBAEEAQZimhwEQwyEAC0EAQQBBqKaHARDDIQALQbimhwEQsjsAC0HIpIcBQSBB6KSHARCfKQALQcikhwFBIEHopIcBEJ8pAAsgCSARIAAoAiggAmogFGwgASgCKCADaiAUbCAEIBRsEOssCyAQQeAAaiQAIQUMFQsjAEEQayIIJAAgCEEIaiAAIgUQ4x0gCCgCDCEXIAgoAgghACAIIAEQ4x1BASEPAkAgBEUNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBcgAiAEaiIRSwRAIAAgEUEDdGopAwAiGkKAgICAEFQEQCACIBdPDQMgACACQQN0aiIVKQMAIhtCgICAgBBaDQIgAyAEaiIYIAgoAgQiDU8NBSAIKAIAIgAgGEEDdGopAwAiHUKAgICAEFoNBAJAIAMgDUkEQCAAIANBA3RqIgApAwAiHEKAgICAEFoNCCAapyAbp2siEyAdpyAcp2siC0cgGiAbUnINAQwaCyADIA1BpKuHARDDIQALIAUoAhRFDQcCQAJAAkAgASgCFARAIAUoAhAhDiABKAIQIRACQCAEAn8gBSgCLCIHBEAgBCAFQSxqIAUoAjggAmogBBDTH2shFiABKAIsRQ0CIAFBLGoMAQsgASgCLEUNBCABQSxqCyABKAI4IANqIhQgBBDTHyIGayAWRg0CDBwLQQAhDyALIBNHIBZyDRwMAwtBAEEAQdSrhwEQwyEACyAEIAZGDQAgB0UNCkEAIQYgDSADayIHQQAgByANTRshDCAXIAJrIgdBACAHIBdNGyEJIAEoAjwiCyADayIHQQAgByALTRshESAFKAI8IgsgAmsiB0EAIAcgC00bIRggBSgCOCACaiEWIAEoAjAhEyAFKAIwIQsDQCAGIBhGIAYgEUZyDTFBACEPIAsgBiAWaiIBQQN2ai0AAEEBIAFBB3F0cSIFRSATIAYgFGoiAUEDdmotAAAgAUEHcXZBAXFFcw0bIAYgCUYNDSAVKQMAIhpCgICAgBBaDQwgAiAGaiIBQQFqIBdPDQ8gFUEIaiIVKQMAIhtCgICAgBBaDQ4gBiAMRg0RIAApAwAiHUKAgICAEFoNECADIAZqQQFqIA1PDRMgAEEIaiIAKQMAIhxCgICAgBBaDRIgBQRAIBunIBqnIgdrIgUgHKcgHaciAWtHDRwgDiAQIAcgASAFEOssRQ0cCyAEIAZBAWoiBkcNAAtBASEPDBoLIAsgE0cNGAsgAiARSw0RIAMgGEsNEiAVKQMAIhtQRQ0TQgAhHCAAKQMAQgBSDRNBACEPIBUgACAEQQN0EJknDRgMFAtB1KqHARCyOwALIBEgF0HEqocBEMMhAAtB9KqHARCyOwALIAIgF0HkqocBEMMhAAtBlKuHARCyOwALIBggDUGEq4cBEMMhAAtBtKuHARCyOwALQQBBAEHEq4cBEMMhAAtBpKyHARCyOwALQcSshwEQsjsACyACIAZqIBdBtKyHARDDIQALQeSshwEQsjsACyABQQFqIBdB1KyHARDDIQALQYSthwEQsjsACyADIAZqIA1B9KyHARDDIQALQaSthwEQsjsACyANIANBAWoiACAAIA1JGyANQZSthwEQwyEACyACIBFB5KuHARCxOwALIAMgGEH0q4cBELE7AAsgACEGA0AgBEEBayIEBEAgBikDACEdIBUpAwAhHCAVQQhqIgIhFSAGQQhqIgEhBiACKQMAIBx9IAEpAwAgHX1RDQEMBQsLIBtCgICAgBBaDQEgACkDACIcQoCAgIAQWg0CIBunIQ8LIA4gECAPIBynIBMQ6ywhDwwDC0GErIcBELI7AAtBlKyHARCyOwALQQAhDwsgCEEQaiQAIA8hBQwUCyMAQeAAayIJJAACQAJAAkAgACgCLEUNACAJQQhqIABBLGoQ3DsgCUEgaiIFIAkoAgggCSgCDCAAKAI4IhYgAmogBBD6EyAJQRRqIAUQ1QkgCSgCFEEBRgRAIAkoAhgNAiAJKAIcIARGDQEMAgsgBA0BCyAAIAEgAiADIAQQ8B8hBQwBCwJAIAEoAiwEQCAERQRAQQEhBQwDCyABKAI8IgYgA2siBUEAIAUgBk0bIREgACgCPCIGIAJrIgVBACAFIAZNGyEYIAEoAjghEyABKAIwIQsgACgCMCEHA0AgGEUgEUVyDRkCQCAHIAIgFmoiBUEDdmotAABBASAFQQdxdHEiBkUgCyADIBNqIgVBA3ZqLQAAQQEgBUEHcXRxIgVFckUEQCAAIAEgAiADQQEQ8B8NAQwECyAGRSAFRXMNAwsgGEEBayEYIBFBAWshEUEBIQUgA0EBaiEDIAJBAWohAiAEQQFrIgQNAAsMAgtBsMWHARCyOwALQQAhBQsgCUHgAGokAAwTCwJ/IwBB0ABrIg0kACANQTBqIAAiBRDSHiANKAI0IQYgDSgCMCEHIA1BKGogARDSHgJAAn8CQAJAAkACQAJAAkACQAJAIAQgAiAEaiITTQRAIAYgE0kNASADIARqIgsgBEkNAiALIA0oAiwiBksNAyAALQAYQSFHDQogAS0AGEEhRw0KIAIgB2ohCCANKAIoIANqIQ4gAS0AGSEGAkAgAC0AGUEBRgRAIAZBAXENAQwMCyAGQQFxDQsgCCAOIAQQmScNCQJAIAEoAhQiBiAFKAIUIgAgACAGSxsiAEUEQEEAIQEMAQsgASgCECEPIAUoAhAhFyABKAIoIANqIQMgBSgCKCACaiECQQAhAQNAIBcgDyACIAMgBBDrLEUNASAXQcQAaiEXIA9BxABqIQ8gACABQQFqIgFHDQALIAAhAQsgACABTQwKCyANQSBqIAVBARDnHSANKAIgIA0oAiQhACANQRhqIAFBARDnHSAAIBNJDQQgCyANKAIcIgBLDQUgDSgCGCEAIAggDiAEEJknDQggAkECdGohDCAFQRxqIQkgAUEcaiERIAAgA0ECdGohGCABKAIQIQMgASgCFCEQIAUoAhQhFCAFKAIQIQJBACEFA0ACQCAEIAUiAEYEQCAEIQAMAQsgDUEQaiAJELAuAkAgDSgCECIXIA0oAhQiB0cEQCAAQQFqIQUgGCAAQQJ0IgFqIRYgASAMaiETQQAhDyAAIAhqLQAAIQYgAiEBA0AgFy0AACAGRg0CIAFBxABqIQEgD0EBaiEPIBdBCGoiFyAHRw0ACwtByJ6HARCyOwALIA1BCGogERCwLgJAIA0oAggiFyANKAIMIgtHBEBBACEVIAAgDmotAAAhByADIQYDQCAXLQAAIAdGDQIgBkHEAGohBiAVQQFqIRUgF0EIaiIXIAtHDQALC0HYnocBELI7AAsgDyAUTw0IIBAgFU0NCSABIAYgEygCACAWKAIAQQEQ6ywNAQsLIAAgBE8MCQsgAiATQYifhwEQsTsACyATIAZBiJ+HARCwOwALIAMgC0GYn4cBELE7AAsgCyAGQZifhwEQsDsACyATIABBqJ+HARCwOwALIAsgAEG4n4cBELA7AAsgDyAUQeiehwEQwyEACyAVIBBB+J6HARDDIQALQQALIA1B0ABqJAAMAQsgDUEANgJIIA1BATYCPCANQaSghwE2AjggDUIENwJAIA1BOGpBrKCHARDvLAALIQUMEgsgACgCHC0AAEECaw4IBwgJCgsMDQ4GCyAAIAEgAiADIAQQvgQhBQwQCyAAIAEgAiADIAQQvwQhBQwPCwJ/IwBBgAJrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIBJBIGogACgCBBDcOyASKAIkIgYgACgCKEEFdCIPTwRAIAEoAghFDQMgEigCICEIIBJBGGogASgCBBDcOyASKAIcIgUgASgCKEEFdCIVSQ0CIAggD2ohEyAGIA9rIQ0gEigCGCIHIBVqIQsgBSAVayEXIAAoAixFDQwgEkEQaiAAQSxqIgYQ3DsgEkHoAGoiBSASKAIQIBIoAhQgACgCOCACaiIOIAQQ+hMgEkH0AWogBRDVCQJAIBIoAvQBQQFGBEAgEigC+AENASASKAL8ASAERw0BDA4LIARFDQ0LIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgEkEIaiAGENw7IBJBKGoiACASKAIIIBIoAgwgDiAEEPoTIAEoAixFDQUgEiABQSxqENw7IBJBqAFqIgUgEigCACASKAIEIAEoAjggA2ogBBD6EyASQegAaiAAQcAA/AoAACASQgA3A+gBA0AgEkH0AWoiACASQegAahDVCQJAIBIoAvQBQQFGBEAgEigC/AEhASASKAL4ASEEIAAgBRDVCSASKAL0AQ0BC0EBIQYMEAtBACEGIAQgEigC+AFHDQ8gASASKAL8AUcNDyABIARrQQV0IgcgAiAEakEFdCIBaiIAIAdJDSQgACANSw0lIAcgAyAEakEFdCIAaiIEIAdJDQcgBCAXSw0IIAEgE2ogByAAIAtqIAcQnzsNAAsMDgsgASgCLEUNBwJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshDCAAKAI8IgYgAmsiBUEAIAUgBk0bIQkgAkEFdCIQQWBzIREgA0EFdCIUQWBzIRggASgCOCADaiEWIAggDyAQamohEyAHIBQgFWpqIQsgASgCMCEHIAAoAjAhBkEAIQADQCAAIAlGIAAgDEZyDSYCQAJAIAYgACAOaiIBQQN2ai0AAEEBIAFBB3F0cSIFRQ0AIAcgACAWaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAKIBFGDQwgCiAQakEgaiANSw0NIAogGEYNDiAKIBRqQSBqIBdLDQ8gCiATakEgIAogC2pBIBCfOw0BDAMLIAUNAgsgCkEgaiEKIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBgwNCyAPIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgFSAFQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAAIARBiL6HARCxOwALIAQgF0GIvocBELA7AAtB6L2HARCyOwALQWAgAkEFdCAKakEgakH4vYcBELE7AAsgAkEFdCAKakEgaiANQfi9hwEQsDsAC0FgIANBBXQgCmpBIGpBiL6HARCxOwALIANBBXQgCmpBIGogF0GIvocBELA7AAsgBEEFdCIEIAJBBXQiAWoiACAESQ0VIAAgDUsNFiAEIANBBXQiAGoiAiAESQ0BIAIgF0sNAiABIBNqIAQgACALaiAEEJ87IQYLIBJBgAJqJAAgBgwCCyAAIAJBiL6HARCxOwALIAIgF0GIvocBELA7AAshBQwOCyMAQRBrIg8kACAPQQhqIAAiBUEAEOcdIA8oAgwhCiAPKAIIIQAgDyABQQAQ5x1BASENAkAgBEUNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAogAiAEaiIRSwRAIAAgEUECdGooAgAiE0EATgRAIAIgCk8NAyAAIAJBAnRqIhcoAgAiC0EASA0CIAMgBGoiGCAPKAIEIhJPDQUgDygCACIAIBhBAnRqKAIAIgdBAEgNBAJAIAMgEkkEQCAAIANBAnRqIgAoAgAiBkEASA0IIAsgE0cgEyALayIWIAcgBmsiE0dyDQEMGgsgAyASQaSrhwEQwyEACyAFKAIURQ0HAkACQAJAIAEoAhQEQCAFKAIQIRUgASgCECEIAkAgBAJ/IAUoAiwiCwRAIAQgBUEsaiAFKAI4IAJqIAQQ0x9rIQYgASgCLEUNAiABQSxqDAELIAEoAixFDQRBACEGIAFBLGoLIAEoAjggA2oiFCAEENMfIgdrIAZGDQIMHAtBACENIBMgFkcgBnINHAwDC0EAQQBB1KuHARDDIQALIAQgB0YNACALRQ0KQQAhBiASIANrIgdBACAHIBJNGyEMIAogAmsiB0EAIAcgCk0bIQkgASgCPCILIANrIgdBACAHIAtNGyERIAUoAjwiCyACayIHQQAgByALTRshGCAFKAI4IAJqIRYgASgCMCETIAUoAjAhCwNAIAYgGEYgBiARRnINKkEAIQ0gCyAGIBZqIgFBA3ZqLQAAQQEgAUEHcXRxIgdFIBMgBiAUaiIBQQN2ai0AACABQQdxdkEBcUVzDRsgBiAJRg0NIBcoAgAiDkEASA0MIAIgBmoiAUEBaiAKTw0PIBdBBGoiFygCACIBQQBIDQ4gBiAMRg0RIAAoAgAiEEEASA0QIAMgBmpBAWogEk8NEyAAQQRqIgAoAgAiBUEASA0SIAcEQCABIA5rIgEgBSAQa0cNHCAVIAggDiAQIAEQ6yxFDRwLIAQgBkEBaiIGRw0AC0EBIQ0MGgsgEyAWRw0YCyACIBFLDREgAyAYSw0SIBcoAgAiBw0TIAAoAgANE0EAIQ0gFyAAIARBAnQQmScNGAwUC0HUqocBELI7AAsgESAKQcSqhwEQwyEAC0H0qocBELI7AAsgAiAKQeSqhwEQwyEAC0GUq4cBELI7AAsgGCASQYSrhwEQwyEAC0G0q4cBELI7AAtBAEEAQcSrhwEQwyEAC0GkrIcBELI7AAtBxKyHARCyOwALIAIgBmogCkG0rIcBEMMhAAtB5KyHARCyOwALIAFBAWogCkHUrIcBEMMhAAtBhK2HARCyOwALIAMgBmogEkH0rIcBEMMhAAtBpK2HARCyOwALIBIgA0EBaiIAIAAgEkkbIBJBlK2HARDDIQALIAIgEUHkq4cBELE7AAsgAyAYQfSrhwEQsTsACyAAIQYDQCAEQQFrIgQEQCAGKAIAIQUgFygCACEDIBdBBGoiAiEXIAZBBGoiASEGIAIoAgAgA2sgASgCACAFa0YNAQwFCwsgB0EASA0BIAAoAgAiDUEASA0CCyAVIAggByANIBYQ6ywhDQwDC0GErIcBELI7AAtBlKyHARCyOwALQQAhDQsgD0EQaiQAIA0hBQwNCyACIANyDQogACgCJCIDIARGIAEoAiQiAiAERnJFDQogACgCKA0KIAEoAigNCkEAIQUgAiADRw0MAkACQAJAAkACQCAAKAIUDgIAAgELQQBBAEH4v4cBEMMhAAsgASgCFA4CAQ4CC0EBQQFBiMCHARDDIQALQQBBAEGYwIcBEMMhAAsgACgCECICKAIkIgAgASgCECIBKAIkRw0MIAIoAmggASgCaEcNDCACIAFBAEEAIAAQ6yxFDQwgAkHEAGogAUHEAGpBAEEAIAEoAmgQ6ywhBQwMCwJ/IwBBgAJrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIBJBIGogACgCBBDcOyASKAIkIgYgACgCKEEEdCIPTwRAIAEoAghFDQMgEigCICEIIBJBGGogASgCBBDcOyASKAIcIgUgASgCKEEEdCIVSQ0CIAggD2ohEyAGIA9rIQ0gEigCGCIHIBVqIQsgBSAVayEXIAAoAixFDQwgEkEQaiAAQSxqIgYQ3DsgEkHoAGoiBSASKAIQIBIoAhQgACgCOCACaiIOIAQQ+hMgEkH0AWogBRDVCQJAIBIoAvQBQQFGBEAgEigC+AENASASKAL8ASAERw0BDA4LIARFDQ0LIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgEkEIaiAGENw7IBJBKGoiACASKAIIIBIoAgwgDiAEEPoTIAEoAixFDQUgEiABQSxqENw7IBJBqAFqIgUgEigCACASKAIEIAEoAjggA2ogBBD6EyASQegAaiAAQcAA/AoAACASQgA3A+gBA0AgEkH0AWoiACASQegAahDVCQJAIBIoAvQBQQFGBEAgEigC/AEhASASKAL4ASEEIAAgBRDVCSASKAL0AQ0BC0EBIQYMEAtBACEGIAQgEigC+AFHDQ8gASASKAL8AUcNDyABIARrQQR0IgcgAiAEakEEdCIBaiIAIAdJDSEgACANSw0iIAcgAyAEakEEdCIAaiIEIAdJDQcgBCAXSw0IIAEgE2ogByAAIAtqIAcQnzsNAAsMDgsgASgCLEUNBwJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshDCAAKAI8IgYgAmsiBUEAIAUgBk0bIQkgAkEEdCIQQXBzIREgA0EEdCIUQXBzIRggASgCOCADaiEWIAggDyAQamohEyAHIBQgFWpqIQsgASgCMCEHIAAoAjAhBkEAIQADQCAAIAlGIAAgDEZyDSMCQAJAIAYgACAOaiIBQQN2ai0AAEEBIAFBB3F0cSIFRQ0AIAcgACAWaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAKIBFGDQwgCiAQakEQaiANSw0NIAogGEYNDiAKIBRqQRBqIBdLDQ8gCiATakEQIAogC2pBEBCfOw0BDAMLIAUNAgsgCkEQaiEKIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBgwNCyAPIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgFSAFQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAAIARBiL6HARCxOwALIAQgF0GIvocBELA7AAtB6L2HARCyOwALQXAgAkEEdCAKakEQakH4vYcBELE7AAsgAkEEdCAKakEQaiANQfi9hwEQsDsAC0FwIANBBHQgCmpBEGpBiL6HARCxOwALIANBBHQgCmpBEGogF0GIvocBELA7AAsgBEEEdCIEIAJBBHQiAWoiACAESQ0SIAAgDUsNEyAEIANBBHQiAGoiAiAESQ0BIAIgF0sNAiABIBNqIAQgACALaiAEEJ87IQYLIBJBgAJqJAAgBgwCCyAAIAJBiL6HARCxOwALIAIgF0GIvocBELA7AAshBQwLC0HwwocBQShBmMOHARCfKQALAn8jAEHwAGsiDyQAIA9BGGogABDSHiAPKAIcIRUgDygCGCEUIA9BEGogARDSHgJAAkACQAJAAkAgACgCFARAIAEoAhRFDRcgACgCECEMIA8oAhQhCCAPKAIQIQkgASgCECERIAAoAixFDQIgD0EIaiAAQSxqENw7IA9BMGoiBSAPKAIIIA8oAgwgACgCOCIYIAJqIAQQ+hMgD0EkaiAFENUJAkAgDygCJEEBRgRAIA8oAigNASAPKAIsIARHDQEMBAsgBEUNAwsgASgCLEUNGCAERQRAQQAhBQwFC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyABKAI4IQsgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINGgJAAkAgBiACIAVqIg4gGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAMgBWoiECALaiIAQQN2ai0AAEEBIABBB3F0cUUNACAOIBVPDQQgDiAUaiwAACIBQQBIDR0gCCAQSwRAIAkgEGosAAAiAEEASA0fIAwgESABIABBARDrLA0CDAgLIBAgCEHYv4cBEMMhAAsgAQ0GCyAFQQFqIgUgBEcNAAsMAwsMFQsgDiAVQbi/hwEQwyEAC0EAIARrIRYgAyAJaiETIAIgFGohCyAVIAIgAiAVSxsgFWshByAIIAMgAyAISxsgCGshBkF/IQUDQCAFIBZqQX9GDQEgBSAHakF/Rg0DIAUgC2pBAWosAAAiAUEASA0bAkAgBSAGakF/RwRAIAUgE2pBAWosAAAiAEEATg0BDBwLIAMgBWpBAWogCEGYv4cBEMMhAAsgBUEBaiEFIAwgESABIABBARDrLA0ACwwBCyAEIQULIA9B8ABqJAAgBCAFTQwBCyACIAVqQQFqIBVB+L6HARDDIQALIQUMCQsjAEHwAGsiCCQAIAhBGGogABDkHSAIKAIcIRAgCCgCGCELIAhBEGogARDkHQJAAkACQCAAKAIUBEAgASgCFEUNEyAAKAIQIQwgCCgCFCEUIAgoAhAhCSABKAIQIREgACgCLEUNASAIQQhqIABBLGoQ3DsgCEEwaiIFIAgoAgggCCgCDCAAKAI4IAJqIhggBBD6EyAIQSRqIAUQ1QkCQCAIKAIkQQFGBEAgCCgCKA0BIAgoAiwgBEcNAQwDCyAERQ0CCyABKAIsRQ0UIARFBEBBACEFDAQLQQAhBSABKAI8IgcgA2siBkEAIAYgB00bIRYgACgCPCIHIAJrIgZBACAGIAdNGyETIAsgAkEBdGohDiABKAI4IANqIQsgCSADQQF0aiEJIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRYCQAJAIAYgBSAYaiIAQQN2ai0AAEEBIABBB3F0cSIBRQ0AIAcgBSALaiIAQQN2ai0AAEEBIABBB3F0cUUNACACIAVqIgAgEE8NHiAOLgEAIgFBAEgNGSAUIAMgBWoiAEsEQCAJLgEAIgBBAEgNGyAMIBEgASAAQQEQ6ywNAgwHCwwdCyABDQULIA5BAmohDiAJQQJqIQkgBCAFQQFqIgVHDQALDAILDBELQQAhBSAUIANrIgBBACAAIBRNGyEHIBAgAmsiAEEAIAAgEE0bIQYgCSADQQF0aiEJIAsgAkEBdGohDgJAA0AgBCAFRg0CIAUgBkYNASAOLgEAIgFBAEgNGQJAIAUgB0cEQCAJLgEAIgBBAE4NAQwaCwwdCyAFQQFqIQUgCUECaiEJIA5BAmohDiAMIBEgASAAQQEQ6ywNAAsgBUEBayEFDAILDBsLIAQhBQsgCEHwAGokACAEIAVNIQUMCAsjAEHwAGsiCCQAIAhBGGogAEEAEOcdIAgoAhwhECAIKAIYIQsgCEEQaiABQQAQ5x0CQAJAAkAgACgCFARAIAEoAhRFDRIgACgCECEMIAgoAhQhFCAIKAIQIQkgASgCECERIAAoAixFDQEgCEEIaiAAQSxqENw7IAhBMGoiBSAIKAIIIAgoAgwgACgCOCACaiIYIAQQ+hMgCEEkaiAFENUJAkAgCCgCJEEBRgRAIAgoAigNASAIKAIsIARHDQEMAwsgBEUNAgsgASgCLEUNEyAERQRAQQAhBQwEC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyALIAJBAnRqIQ4gASgCOCADaiELIAkgA0ECdGohCSABKAIwIQcgACgCMCEGA0AgBSATRiAFIBZGcg0VAkACQCAGIAUgGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAUgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgAiAFaiIAIBBPDR0gDigCACIBQQBIDRggFCADIAVqIgBLBEAgCSgCACIAQQBIDRogDCARIAEgAEEBEOssDQIMBwsMHAsgAQ0FCyAOQQRqIQ4gCUEEaiEJIAQgBUEBaiIFRw0ACwwCCwwQC0EAIQUgFCADayIAQQAgACAUTRshByAQIAJrIgBBACAAIBBNGyEGIAkgA0ECdGohCSALIAJBAnRqIQ4CQANAIAQgBUYNAiAFIAZGDQEgDigCACIBQQBIDRgCQCAFIAdHBEAgCSgCACIAQQBODQEMGQsMHAsgBUEBaiEFIAlBBGohCSAOQQRqIQ4gDCARIAEgAEEBEOssDQALIAVBAWshBQwCCwwaCyAEIQULIAhB8ABqJAAgBCAFTSEFDAcLIwBB8ABrIggkACAIQRhqIAAQ4x0gCCgCHCEQIAgoAhghCyAIQRBqIAEQ4x0CQAJAAkAgACgCFARAIAEoAhRFDREgACgCECEMIAgoAhQhFCAIKAIQIQkgASgCECERIAAoAixFDQEgCEEIaiAAQSxqENw7IAhBMGoiBSAIKAIIIAgoAgwgACgCOCACaiIYIAQQ+hMgCEEkaiAFENUJAkAgCCgCJEEBRgRAIAgoAigNASAIKAIsIARHDQEMAwsgBEUNAgsgASgCLEUNEiAERQRAQQAhBQwEC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyALIAJBA3RqIQ4gASgCOCADaiELIAkgA0EDdGohCSABKAIwIQcgACgCMCEGA0AgBSATRiAFIBZGcg0UAkACQCAGIAUgGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAUgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgAiAFaiIAIBBPDRwgDikDACIdQoCAgIAQWg0XIBQgAyAFaiIASwRAIAkpAwAiHEKAgICAEFoNGSAMIBEgHacgHKdBARDrLA0CDAcLDBsLIAENBQsgDkEIaiEOIAlBCGohCSAEIAVBAWoiBUcNAAsMAgsMDwtBACEFIBQgA2siAEEAIAAgFE0bIQEgECACayIAQQAgACAQTRshACAJIANBA3RqIQkgCyACQQN0aiEOAkADQCAEIAVGDQIgACAFRg0BIA4pAwAiHUKAgICAEFoNFwJAIAEgBUcEQCAJKQMAIhxCgICAgBBUDQEMGAsMGwsgBUEBaiEFIAlBCGohCSAOQQhqIQ4gDCARIB2nIBynQQEQ6ywNAAsgBUEBayEFDAILDBkLIAQhBQsgCEHwAGokACAEIAVNIQUMBgsCfyMAQfAAayIPJAAgD0EYaiAAENIeIA8oAhwhFSAPKAIYIRQgD0EQaiABENIeAkACQAJAAkACQAJAIAAoAhQEQCABKAIURQ0UIAAoAhAhDCAPKAIUIQggDygCECEJIAEoAhAhESAAKAIsRQ0CIA9BCGogAEEsahDcOyAPQTBqIgUgDygCCCAPKAIMIAAoAjgiGCACaiAEEPoTIA9BJGogBRDVCQJAIA8oAiRBAUYEQCAPKAIoDQEgDygCLCAERw0BDAQLIARFDQMLIAEoAixFDRUgBEUEQEEAIQUMBQtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgASgCOCELIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRcCQAJAIAYgAiAFaiIOIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByADIAVqIhAgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgDiAVTw0EIAggEEsEQCAMIBEgDiAUai0AACAJIBBqLQAAQQEQ6ywNAgwICyAQIAhB2L+HARDDIQALIAENBgsgBUEBaiIFIARHDQALDAMLDBILIA4gFUG4v4cBEMMhAAtBACAEayEWIAMgCWohEyACIBRqIQsgFSACIAIgFUsbIBVrIQcgCCADIAMgCEsbIAhrIQZBfyEFA0AgBSAWakF/Rg0BIAUgB2pBf0YNAyAFIAZqQX9GDQQgBSATaiEBIAUgC2ohACAFQQFqIQUgDCARIABBAWotAAAgAUEBai0AAEEBEOssDQALDAELIAQhBQsgD0HwAGokACAEIAVNDAILIAIgBWpBAWogFUH4vocBEMMhAAsgAyAFakEBaiAIQZi/hwEQwyEACyEFDAULAn8jAEHwAGsiCCQAIAhBGGogABDkHSAIKAIcIRAgCCgCGCELIAhBEGogARDkHQJAAkACQAJAIAAoAhQEQCABKAIURQ0RIAAoAhAhDCAIKAIUIRQgCCgCECEJIAEoAhAhESAAKAIsRQ0BIAhBCGogAEEsahDcOyAIQTBqIgUgCCgCCCAIKAIMIAAoAjggAmoiGCAEEPoTIAhBJGogBRDVCQJAIAgoAiRBAUYEQCAIKAIoDQEgCCgCLCAERw0BDAMLIARFDQILIAEoAixFDRIgBEUEQEEAIQUMBAtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgCyACQQF0aiEOIAEoAjggA2ohCyAJIANBAXRqIQkgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINFAJAAkAgBiAFIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByAFIAtqIgBBA3ZqLQAAQQEgAEEHcXRxRQ0AIAIgBWoiACAQTw0cIBQgAyAFaiIASwRAIAwgESAOLwEAIAkvAQBBARDrLA0CDAcLDBsLIAENBQsgDkECaiEOIAlBAmohCSAEIAVBAWoiBUcNAAsMAgsMDwtBACEFIBQgA2siAEEAIAAgFE0bIQcgECACayIAQQAgACAQTRshBiAJIANBAXRqIQ4gCyACQQF0aiEJA0AgBCAFRg0BIAUgBkYNGiAFIAdGDQMgBUEBaiEFIA4vAQAhASAJLwEAIQAgDkECaiEOIAlBAmohCSAMIBEgACABQQEQ6ywNAAsgBUEBayEFDAELIAQhBQsgCEHwAGokACAEIAVNDAELDBULIQUMBAsCfyMAQfAAayIIJAAgCEEYaiAAQQAQ5x0gCCgCHCEQIAgoAhghCyAIQRBqIAFBABDnHQJAAkACQAJAIAAoAhQEQCABKAIURQ0QIAAoAhAhDCAIKAIUIRQgCCgCECEJIAEoAhAhESAAKAIsRQ0BIAhBCGogAEEsahDcOyAIQTBqIgUgCCgCCCAIKAIMIAAoAjggAmoiGCAEEPoTIAhBJGogBRDVCQJAIAgoAiRBAUYEQCAIKAIoDQEgCCgCLCAERw0BDAMLIARFDQILIAEoAixFDREgBEUEQEEAIQUMBAtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgCyACQQJ0aiEOIAEoAjggA2ohCyAJIANBAnRqIQkgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINEwJAAkAgBiAFIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByAFIAtqIgBBA3ZqLQAAQQEgAEEHcXRxRQ0AIAIgBWoiACAQTw0bIBQgAyAFaiIASwRAIAwgESAOKAIAIAkoAgBBARDrLA0CDAcLDBoLIAENBQsgDkEEaiEOIAlBBGohCSAEIAVBAWoiBUcNAAsMAgsMDgtBACEFIBQgA2siAEEAIAAgFE0bIQcgECACayIAQQAgACAQTRshBiAJIANBAnRqIQ4gCyACQQJ0aiEJA0AgBCAFRg0BIAUgBkYNGSAFIAdGDQMgBUEBaiEFIA4oAgAhASAJKAIAIQAgDkEEaiEOIAlBBGohCSAMIBEgACABQQEQ6ywNAAsgBUEBayEFDAELIAQhBQsgCEHwAGokACAEIAVNDAELDBQLIQUMAwsjAEHwAGsiCCQAIAhBGGogABDlHSAIKAIcIRAgCCgCGCELIAhBEGogARDlHQJAAkACQCAAKAIUBEAgASgCFEUNDSAAKAIQIQwgCCgCFCEUIAgoAhAhCSABKAIQIREgACgCLEUNASAIQQhqIABBLGoQ3DsgCEEwaiIFIAgoAgggCCgCDCAAKAI4IAJqIhggBBD6EyAIQSRqIAUQ1QkCQCAIKAIkQQFGBEAgCCgCKA0BIAgoAiwgBEcNAQwDCyAERQ0CCyABKAIsRQ0OIARFBEBBACEFDAQLQQAhBSABKAI8IgcgA2siBkEAIAYgB00bIRYgACgCPCIHIAJrIgZBACAGIAdNGyETIAsgAkEDdGohDiABKAI4IANqIQsgCSADQQN0aiEJIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRACQAJAIAYgBSAYaiIAQQN2ai0AAEEBIABBB3F0cSIBRQ0AIAcgBSALaiIAQQN2ai0AAEEBIABBB3F0cUUNACACIAVqIgAgEE8NGCAOKQMAIh1CgICAgBBaDRMgFCADIAVqIgBLBEAgCSkDACIcQoCAgIAQWg0VIAwgESAdpyAcp0EBEOssDQIMBwsMFwsgAQ0FCyAOQQhqIQ4gCUEIaiEJIAQgBUEBaiIFRw0ACwwCCwwLC0EAIQUgFCADayIAQQAgACAUTRshASAQIAJrIgBBACAAIBBNGyEAIAkgA0EDdGohCSALIAJBA3RqIQ4CQANAIAQgBUYNAiAAIAVGDQEgDikDACIdQoCAgIAQWg0TAkAgASAFRwRAIAkpAwAiHEKAgICAEFQNAQwUCwwXCyAFQQFqIQUgCUEIaiEJIA5BCGohDiAMIBEgHacgHKdBARDrLA0ACyAFQQFrIQUMAgsMFQsgBCEFCyAIQfAAaiQAIAQgBU0hBQwCCyAZQQA2AhggGUEBNgIMIBlB+MCHATYCCCAZQgQ3AhAgGUEIakGAwYcBEO8sAAtBAUEBQajAhwEQwyEACyAZQSBqJAAgBQ8LQZSqhwFBIEG0qocBEJ8pAAtBqMOHAUEgQcjDhwEQnykACyABIABB+L2HARCxOwALIAAgDUH4vYcBELA7AAtB6LyHAUEgQYi9hwEQnykAC0EAQQBByL6HARDDIQALQQBBAEHYvocBEMMhAAtB6L6HARCyOwALQZi+hwFBIEG4vocBEJ8pAAtByL+HARCyOwALQei/hwEQsjsAC0Gov4cBELI7AAtBiL+HARCyOwALIAAgFEHYv4cBEMMhAAsgACAQQbi/hwEQwyEACyADIAVqIBRBmL+HARDDIQALIAIgBWogEEH4vocBEMMhAAuvBwEGfyMAQfABayICJAAgAkEIaiABQShqKAIANgIAIAIgASkCIDcDACACIAEoAiwiBDYCECACIAEpAgA3AhQgAkGEAWogAUE4aigCADYCACACIAEpAjA3AnwgASgCPCEDIAIgASgCVCIFNgIcIAJBKGogAUEQaigCADYCACACIAEpAgg3AyAgAkE4aiABQRxqKAIANgIAIAIgASkCFDcDMCABLQBYIAEtAFkhByACIAJBFGo2AnggAiACQRBqNgJ0IAIgAkEcajYCcAJAAkACQCADBEAgAkHoAGogAUHQAGooAgA2AgAgAkHgAGogAUHIAGopAgA3AwAgAiABKQJANwNYIAIoAnwiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAkH8AGoQ+x4MAQsgAigCfCIBRQ0BIAIgAikCgAE3AtQBIAIgATYC0AEgAkHcAWogAkHQAWogBSAEEPIVAkAgAigCFEEBRgRAIAJBkAFqIAJB5AFqKQIANwMAIAJBmAFqIAJB7AFqKAIANgIAIAIgAikC3AE3A4gBIAIgAigCGDYCnAEMAQsgAkGIAWogAkHcAWoQ4ScLIAJB4ABqIAJBlAFqKQIANwMAIAJB6ABqIAJBnAFqKAIANgIAIAIgAikCjAE3A1ggAigCiAEiA0UNAQsgAkGUAWogAkHgAGoiASkDADcCACACQZwBaiACQegAaiIEKAIAIgU2AgAgAiADNgKIASACIAIpA1g3AowBIAVFBEAgAyADKAIAIgFBAWs2AgAgAUEBRw0BIAJBiAFqEPseDAELIAJB0ABqIAQoAgA2AgAgAkHIAGogASkDADcDACACIAIpA1g3A0AMAQtBACEDCyACQagBaiACQQhqKAIANgIAIAJBkAFqIAJBKGooAgA2AgAgAkGcAWogAkE4aigCADYCACACIAIpAwA3A6ABIAIgAigCEDYCrAEgAiACKAIcNgKwASACIAIpAyA3A4gBIAIgAikDMDcClAEgAiADNgK0ASACQcgBaiACQdAAaigCADYCACACQcABaiACQcgAaikDADcDACACIAIpA0A3A7gBQQFxBEAgAkGIAWoQvhALAkACQCAHQQFxDQAgAkHwAGogAkGIAWoiAxDnFiACKAJwIgFBk4CAgHhGDQAgACACKQJ0NwIIIABBEGogAkH8AGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQgAxCkHgwBCyAAIAJBiAFqQcQA/AoAAAsgAkHwAWokAAvLBwIBfwJ+IwBBkAFrIgMkACADIAI2AhAgAyABNgIMIANBIDsBFiADQfAAaiABIAIgA0EWahCVAwJAIAMoAnBBAUYEQCADQegAaiADQYQBaigCACIBNgIAIANB4ABqIANB/ABqKQIAIgQ3AwAgAyADKQJ0IgU3A1ggAEEQaiABNgIAIABBCGogBDcCACAAIAU3AgAMAQsgA0EgaiADQYABaikDACIENwMAIAMgAykDeDcDGCADQR42AogBIAMgBD4CPAJAIATEQh5+IgRCIIinIASnIgFBH3VHBEAgA0ECNgJ0IANB1MKAATYCcCADQgI3AnwgA0HFEDYCTCADQcUQNgJEIAMgA0FAazYCeCADIANBiAFqNgJIIAMgA0E8ajYCQCADQdwAaiADQfAAahCZDiADQThqIANB6ABqKAIANgIAIAMgAykCYDcCMCADQYiAgIB4NgIoIAMgAygCXDYCLAwBCyADIAMoAiQiAjYCiAEgAyABNgI8IAJBAEggASABIAJqIgFKRwRAIANBAjYCdCADQcDCgAE2AnAgA0ICNwJ8IANBxRA2AkwgA0HFEDYCRCADIANBQGs2AnggAyADQYgBajYCSCADIANBPGo2AkAgA0HcAGogA0HwAGoQmQ4gA0E4aiADQegAaigCADYCACADIAMpAmA3AjAgA0GIgICAeDYCKCADIAMoAlw2AiwMAQsgAykDGCIEIARCwIQ9fyIFQsCEPX5RBEAgBUKAgICACH1CgICAgHBUBEAgA0ECNgJ0IANBlMyAATYCcCADQgE3AnwgA0HuBjYCRCADIANBQGs2AnggAyADQRhqNgJAIANB3ABqIANB8ABqEJkOIANBOGogA0HoAGooAgA2AgAgAyADKQJgNwIwIANBjYCAgHg2AiggAyADKAJcNgIsDAILIAAgBT4CCCAAIAE2AgQgAEGTgICAeDYCAAwCCyADIAQ3A0AgA0ECNgJ0IANB0MuAATYCcCADQgE3AnwgA0HuBjYCXCADIANB2ABqNgJ4IAMgA0FAazYCWCADQSxqIANB8ABqEJkOIANBjYCAgHg2AigLIANB6ABqIANBOGooAgA2AgAgA0HgAGogA0EwaikCADcDACADIAMpAig3A1ggA0ECNgJ0IANBpMeAATYCcCADQgE3AnwgA0HMATYCjAEgAyADQYgBajYCeCADIANBDGo2AogBIANBxABqIANB8ABqEJkOIANB2ABqEIgRIAMpAkQhBCAAIAMpAkw3AgwgACAENwIEIABBgoCAgHg2AgALIANBkAFqJAALwBMCE38DfiMAQZAMayIJJAAgCUEMaiIPQQBBwAX8CwAgCUHMBWoiEEEAQcAF/AsAIAlBADYCjAsgCUGgC2pBADsBACAJQZgLakIANwMAIAlCADcDkAsgCUGkC2pBAEEk/AsAIAlByAtqQQBByAD8CwAgACEVIAEhDiAJQYwLaiETQQAhAQJAIAJFDQAgAEEBayEAIAJBAWsgDkkhDAJ/An8CQAJAAkADQCAMRQ0BIAAgAmotAAAEQCACIAFrIREgAkEySw0DQQAMBgsgAEEBayEAIAIgAUEBaiIBRw0ACyACQTJNDQUMAgsgAUF/cyACaiAOQeCV0gAQwyEACyABIAJGDQAgAiABayECIBVBAWohFkEBIQxBASEUA0ACQAJAIAggDkkEQEEBIQ0gCEEBaiARTw0CIAggFmohEiACIAhrIQ0gCEF/cyIAIA5qIRcgACACaiEaQQAhACAIIBVqLQAAIQEDQAJAIAAgF0cEQCAAIBJqLQAAIAFGDQEgAEEBaiENDAQLIA4gDkHgk9IAEMMhAAsgGiAAQQFqIgBHDQALDAELIAggDkHQk9IAEMMhAAsgAUUgDUECS3FFBEAgAUUgDUEESXINASAUQQFqIRQgCyANaiELDAELIAxBAWohDCAKIA1qIQoLIAggDWoiCCARSQ0ACyAUQQF0IQAgDEEBdAwBC0ECIQBBACERQQILIApJIRQgACALSQshFiARRQ0AIBMoAgAhAUEIIQxBACENAkACQANAAkACQAJAAkACQAJAAkACQAJ/An8CQAJAAkACQAJAAkACQCANIA5JBEAgDUEBaiEIIA0gFWoiCi0AACICBEBBASELIBYgCCARSXFFDQMMAgtBASELIBQgCCARSXENAQwQCyANIA5B8JXSABDDIQALIBEgDWshAAJAA0AgCyANaiAOTw0FIAogC2otAAAgAkcNASAAIAtBAWoiC0cNAAsgACELCyACRQ0BCyAMQf8BcSACRw0BIAEhCCALDAULAn8gC0ELRgRAIAFBwAVPDQQgASAPakEAOgAAIAFBwAVJBEAgASAQakEAOgAAIAFBAWohAUEHDAILIAFBwAVBkJXSABDDIQALIAtBA0kNDCALQQNrCyEKIAFBwAVJBH9BwAUgASABQcAFTRshCCABIQADQCAAIA9qQRE6AAACQCAAIAhHBEAgEyAAQQFqIgI2AgAgACAQaiAKQQdxOgAAIApBCE8NASAPIAEgAhDGHCAQIAEgAhDGHCACIQEMEQsgCEHABUGwldIAEMMhAAsgCkEDdkEBayEKIAIiAEHABUcNAAtBwAUFIAELQcAFQaCV0gAQwyEACyABQcAFTwRAIAFBwAVBgJTSABDDIQALIAEgD2ogAjoAACABQcAFSQ0CIAFBwAVBkJTSABDDIQALIA4gCCAIIA5JGyAOQYCW0gAQwyEACyABQcAFQYCV0gAQwyEACyATIAFBAWoiCDYCACABIBBqQQA6AAAgC0EBawsiAUEHRgRAIAhBwAVPDQIgCCAPaiACOgAAIAhBwAVJBEAgCCAQakEAOgAAIAhBAWohCEEDDAILIAhBwAVBsJTSABDDIQALIAFBA0kNAiABQQNrCyEKIAhBwAVJBH9BwAUgCCAIQcAFTRshDCAIIQADQCAAIA9qQRA6AAACQCAAIAxHBEAgEyAAQQFqIgE2AgAgACAQaiAKQQNxOgAAIApBBE8NASAPIAggARDGHCAQIAggARDGHAwGCyAMQcAFQdCU0gAQwyEACyAKQQJ2QQFrIQogASIAQcAFRw0AC0HABQUgCAtBwAVBwJTSABDDIQALIAhBwAVBoJTSABDDIQALIAFFBEAgCCEBDAELQQAhAEHABSAIayIMQQAgDEHABU0iEhshCiAMQQAgEhshDCAIIA9qIRIgCCAQaiEXA0AgACAMRg0DIAAgEmogAjoAACAAIApGDQIgACAXakEAOgAAIBMgACAIakEBajYCACAAQQFqIgAgAUcNAAsgACAIaiEBCyACIQwMBAsgACAIakHABUHwlNIAEMMhAAsgACAIakHABUHglNIAEMMhAAsgCw0AQQAhCwwBC0EAIQBBwAUgAWsiAkEAIAJBwAVNIgobIQggAkEAIAobIQIgASAPaiEKIAEgEGohEgNAIAAgAkYNBCAAIApqQQA6AAAgACAIRg0DIAAgEmpBADoAACATIAAgAWpBAWo2AgAgAEEBaiIAIAtHDQALIAAgAWohAQsgCyANaiINIBFJDQALDAILIAAgAWpBwAVB0JXSABDDIQALIAAgAWpBwAVBwJXSABDDIQALAkACQCAJKAKMCyIBBEBBACECA0AgAkHABUYNAyAJQQxqIAJqLQAAIgBBEk8NAiAJQcgLaiAAQQJ0aiIAIAAoAgBBAWo2AgAgASACQQFqIgJHDQALC0EAIQEgCUHIC2ohAgNAAkACQCACKAIARQRAIBghCCAZIQAMAQtBASEAIAEhCCAZRQ0AQQIhACAYIQgMAQsgAkEEaiECIAAhGSAIIRggAUEBaiIBQRJHDQELCyAJQcgLakESQRJBBSADIAQgCUGQC2oiAUESEOsIIAFBEkESIAlBpAtqQRIQswtCEiEcAkAgAEECSQ0AQhIhG0GN49EAIQIDQAJAIAItAAAiAUERTQRAIAlBkAtqIAFqLQAARQ0BIBshHAwDCyABQRJBvObRABDDIQALIAJBAWshAkIAIRwgG0IBfSIbQgBSDQALC0ECQgBCAkIDIAktAJMLGyAJLQCRCyAJLQCSC3IbIh0gBSAGIAcQ5RICQAJAAkACQAJAIBwgHVYEQCAcIB19IRsgHachAgNAIAJBEUsNAiACQfzi0QBqLQAAIgFBEk8NAyAJQZALaiABai0AACIBQQZPDQQgAUGU49EAai0AACABQY7j0QBqMQAAIAUgBiAHEOUSIAJBAWohAiAbQgF9IhtQRQ0ACwsgAEEBRgRAIAlBkAtqIAhqQQA6AAALIAkoAowLIgMEQEEAIQIDQCACQcAFRg0FIAlBDGogAmotAAAiAUESTw0GIAlBkAtqIAFqLQAAIAlBpAtqIAFBAXRqMwEAIAUgBiAHEOUSQQMhAAJAAkACQCABQRBrDgIAAQILQQIhAAsgACAJQcwFaiACajEAACAFIAYgBxDlEgsgAyACQQFqIgJHDQALCyAJQZAMaiQADwtBEkESQczm0QAQwyEACyABQRJB3ObRABDDIQALIAFBBkHs5tEAEMMhAAtBwAVBwAVB/ObRABDDIQALIAFBEkGM59EAEMMhAAsgAEESQazn0QAQwyEAC0HABUHABUGc59EAEMMhAAu+BQEGfyMAQdAOayIGJAAgBkEIaiIIQQBBiAj8CwAgBkGQCGoiB0EAQcAF/AsAIAZB0A1qIglBAEGAAfwLACAAQYABQcAAQQ8gCEGBASABQYABEOsIIABBgAJqQcAAQcAAQQ4gCEGBASABQUBrIghBwAAQ6wggB0EYIAFBGEHoiNIAENUsIAZBqAhqQQggAUEoakEIQeiI0gAQ1SwgBkGwCGpBCCABQRhqIgpBCEHoiNIAENUsIAZBuAhqQQggAUEwakEIQeiI0gAQ1SwgBkHACGpBCCABQSBqIgtBCEHoiNIAENUsIAZByAhqQQggAUE4aiIAQQhB6IjSABDVLCAHQcAFQcAAIAlBwAAQswsgAiAJQTD8CgAAIAIgBikBkA43ATAgAkE4aiAGQZgOaikBADcBACACIAYpAbAONwFAIAJByABqIAZBuA5qKQEANwEAIAIgBikBgA43AVAgAkHYAGogBkGIDmopAQA3AQAgAiAGKQGgDjcBYCACQegAaiAGQagOaikBADcBACACIAYpAcAONwFwIAJB+ABqIAZByA5qKQEANwEAIAhBwABBwAAgAkGAAWpBwAAQswtBACECIAdBAEHAAPwLACAHQQggAUEIQeiI0gAQ1SwgBkHQCGpBCCABQQhqQQhB6IjSABDVLCAGQZAJakEIIAFBEGpBCEHoiNIAENUsIAZB0AlqQQggCkEIQeiI0gAQ1SwgBkGQC2pBCCALQQhB6IjSABDVLCAAIQEDQCAGQZAIaiIHIAJqIgBBgAFqIAFBEGstAAA6AAAgAEGAAmogAUEIay0AADoAACAAQcADaiABLQAAOgAAIAFBAWohASACQQhqIgJBwABHDQALIAdBwAVBwAUgBkEIaiIAQYEBIAMgBCAFEOEHIAhBwABBwAAgAEGBASADIAQgBRDhByAGQdAOaiQAC+UHAgN/AX4jAEHQAWsiAyQAIANBlAFqIAEgAhCTDiADKAKYASEEAkAgAygClAEiBUGKgICAeEcEQCADQShqIANBtAFqKAIANgIAIANBIGogA0GsAWopAgA3AgAgA0EYaiADQaQBaikCADcCACADIAMpApwBNwIQIAMgBDYCDCADIAU2AggMAQsgA0GUAWogAUF/IAIgBGoiASABIARJGxC0BiADQdgAaiIBIANBoAFqKQIANwMAIAMgAykCmAE3A1AgAygClAEiBEGKgICAeEcEQCADQSRqIANBsAFqKQIANwIAIANBFGogASkDADcCACADIAMpAqgBNwIcIAMgAykDUDcCDCADIAQ2AggMAQsgA0HoAGogASkDADcDACADIAMpA1A3A2AgA0GUAWogA0HgAGpBBBDdECADKAKcASEBIAMoApgBIQQCQAJ+IAMoApQBIgVBioCAgHhHBEAgA0HAAWogA0GwAWopAgA3AwAgAyADKQKoATcDuAEgAykCoAEMAQsgBEEBcUUNAQJAIAFBAXEEQCADIAE2ArABIANBAzYCrAEgA0G55P4ANgKoASADQYCAgIB4NgKkASADQgQ3ApwBIANChICAgAg3ApQBDAELQX8gAUECaiIEIAEgBEsbIgUgAygCYCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKUAQwCCyADQYiAgIB4NgKUAQwBCyADQZQBaiABIAUQvy8LIANBBDYCyAEgA0G55/4ANgLEASADQYCAgIB4NgLAASADIAE2ArwBIANBATYCuAEgA0HwAGogA0GUAWogA0G4AWoQgRQgAygCcCIFQYqAgIB4Rg0BIANBwAFqIANBjAFqKQIANwMAIAMgAykChAE3A7gBIAMoAnghASADKAJ0IQQgAykCfAshBiADQSRqIANBwAFqKQMANwIAIAMgBjcCFCADIAE2AhAgAyAENgIMIAMgBTYCCCADIAMpA7gBNwIcDAELIAMgAykDaDcCnAEgAyADKQNgNwKUASADQSxqIANBlAFqQb3n/gBBCEEGEK0IIAMoAjAhASADKAIsIgRBioCAgHhHBEAgA0EYaiADQTxqKAIANgIAIANBJGogA0HIAGopAgA3AgAgAyADKQI0NwIQIAMgAykCQDcCHCADIAE2AgwgAyAENgIIDAELIAEgASgCDEEBazYCDCADQYqAgIB4NgIICyADQQ82AqQBIANBj+n+ADYCoAEgA0GAgICAeDYCnAEgAyACNgKYASADQQI2ApQBIAAgA0EIaiADQZQBahCBFCADQdABaiQAC+YHAQV/IwBB4ABrIgYkACAGIAQ2AhAgBiADNgIMIAYgATYCCCAGIAIoAggiB0ECdkEBayIJNgIUAkACQAJAAkACQCAHQQRJDQAgAigCBCAHQXxxakEEayIHRQ0AIAYgBygCACIINgIYAkACQCADIAQoAghBAWtBeHFqQQhqIgcgBCgCJCIKEQQAIAhPBEACQCAFKAIAIggEQCAJIAUoAhAiCUcNAQsgAS0ASEUEQCAHIAQoAkwRBAANAwsgAUEwaiIJIAcgBCgCHCIKEQQAEMUIRQ0DIAAgBDYCECAAIAM2AgwgACABNgIEIABBGzoAACAAIAUpAgA3AiAgACACKQIANwIUIABBMGogBUEQaikCADcCACAAQShqIAVBCGopAgA3AgAgAEEcaiACQQhqKAIANgIADAgLIAYgCTYCPCAGQQM2AiAgBkGs04UBNgIcIAZCAzcCKCAGQTs2AlQgBkE7NgJMIAZBxwI2AkQgBkHk0oUBNgJAIAYgBkFAazYCJCAGIAZBPGo2AlAgBiAGQRRqNgJIIABBCGogBkEcahCZDiAAQSk6AAAgAEGNgICAeDYCBAwFCyAGIAcgChEEADYCPCAGQQI2AkQgBkGA1YUBNgJAIAZCAjcCTCAGQTs2AiggBkE7NgIgIAYgBkEcajYCSCAGIAZBPGo2AiQgBiAGQRhqNgIcIABBCGogBkFAaxCZDiAAQSk6AAAgAEGNgICAeDYCBCAFKAIAIQgMAwsgBiABQTxqNgI8IAZBAzYCRCAGQfzThQE2AkAgBkICNwJMIAZBygQ2AiggBkHHAjYCICAGQeTShQE2AhwgBiAGQRxqNgJIIAYgBkE8ajYCJCAAQQhqIAZBQGsQmQ4gAEEpOgAAIABBjYCAgHg2AgQMAgsgBiAJNgI0IAYgByAKEQQANgI4IAYgAUE8ajYCPCAGQQQ2AiAgBkG41IUBNgIcIAZCBDcCKCAGQcoENgJcIAZBpwQ2AlQgBkGnBDYCTCAGQccCNgJEIAZB5NKFATYCQCAGIAZBQGs2AiQgBiAGQTxqNgJYIAYgBkE4ajYCUCAGIAZBNGo2AkggAEEIaiAGQRxqEJkOIABBKToAACAAQY2AgIB4NgIEDAELQdTShQEQsjsACyAIRQ0BCyAIIAgoAgAiAEEBazYCACAAQQFHDQAgBRD7HgsgBigCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkEMahC7IwsgAigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgAhD7HgsgBigCCCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEIahDyJQsgBkHgAGokAAvmBwEFfyMAQeAAayIGJAAgBiAENgIQIAYgAzYCDCAGIAE2AgggBiACKAIIIgdBA3ZBAWsiCTYCFAJAAkACQAJAAkAgB0EISQ0AIAIoAgQgB0F4cWpBCGsiB0UNACAGIAcoAgAiCDYCGAJAAkAgAyAEKAIIQQFrQXhxakEIaiIHIAQoAiQiChEEACAITwRAAkAgBSgCACIIBEAgCSAFKAIQIglHDQELIAEtAEhFBEAgByAEKAJMEQQADQMLIAFBMGoiCSAHIAQoAhwiChEEABDFCEUNAyAAIAQ2AhAgACADNgIMIAAgATYCBCAAQR46AAAgACAFKQIANwIgIAAgAikCADcCFCAAQTBqIAVBEGopAgA3AgAgAEEoaiAFQQhqKQIANwIAIABBHGogAkEIaigCADYCAAwICyAGIAk2AjwgBkEDNgIgIAZBrNOFATYCHCAGQgM3AiggBkE7NgJUIAZBOzYCTCAGQccCNgJEIAZBmNWFATYCQCAGIAZBQGs2AiQgBiAGQTxqNgJQIAYgBkEUajYCSCAAQQhqIAZBHGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQMBQsgBiAHIAoRBAA2AjwgBkECNgJEIAZBgNWFATYCQCAGQgI3AkwgBkE7NgIoIAZBOzYCICAGIAZBHGo2AkggBiAGQTxqNgIkIAYgBkEYajYCHCAAQQhqIAZBQGsQmQ4gAEEpOgAAIABBjYCAgHg2AgQgBSgCACEIDAMLIAYgAUE8ajYCPCAGQQM2AkQgBkH804UBNgJAIAZCAjcCTCAGQcoENgIoIAZBxwI2AiAgBkGY1YUBNgIcIAYgBkEcajYCSCAGIAZBPGo2AiQgAEEIaiAGQUBrEJkOIABBKToAACAAQY2AgIB4NgIEDAILIAYgCTYCNCAGIAcgChEEADYCOCAGIAFBPGo2AjwgBkEENgIgIAZBuNSFATYCHCAGQgQ3AiggBkHKBDYCXCAGQacENgJUIAZBpwQ2AkwgBkHHAjYCRCAGQZjVhQE2AkAgBiAGQUBrNgIkIAYgBkE8ajYCWCAGIAZBOGo2AlAgBiAGQTRqNgJIIABBCGogBkEcahCZDiAAQSk6AAAgAEGNgICAeDYCBAwBC0HU0oUBELI7AAsgCEUNAQsgCCAIKAIAIgBBAWs2AgAgAEEBRw0AIAUQ+x4LIAYoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAZBDGoQuyMLIAIoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAIQ+x4LIAYoAggiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAZBCGoQ8iULIAZB4ABqJAALqwcBCn8jAEFAaiIEJAACQAJAAkACQAJAAkACQAJAIAIoAhQiBUUNACACKAIQIAVBDGxqIgZBDEYNACAGQQhrKAIAIAEoAgRHDQAgBkEEaygCACABKAIIRg0BCyABKAIAIgUgBSgCACIGQQFqNgIAIAZBAEgNAiABKAIIIQcgASgCBCEIIAIoAhQiCiACKAIMRgRAIAJBDGpBjITNABCQKAsgAigCECAKQQxsaiIGIAc2AgggBiAINgIEIAYgBTYCACACIApBAWo2AhQMAQsgBUEBayEKCyABKAIQIQUgBCABENw7IAQoAgQhDSAEKAIAIQsgAiAFIAMgAyAFSxsiCBDrLSABKAIMIQMgCEUNASADIAEoAggiCU8NASAIQQFrIQwgAyEFA0ACQAJAAkAgCSADQQRqIgdPBEAgAyALaigAACIJIAdqIgYgDUsNASAJQYABSQ0DIAEtABRBAXENAgwDCyAEQSBqQRdBAEEBQQEQoBggBCgCJCECIAQoAiBBAUYNCCAEKAIoIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwHCyAEQSBqQRdBAEEBQQEQoBggBCgCJCECIAQoAiBBAUYNByAEKAIoIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwGCyAEQQxqIAUgC2ogAyAFaxCdCSAEKAIMQQFGBEAgBCAEKQIQNwMYIARBATYCJCAEQfCIzQA2AiAgBEIBNwIsIARBsAM2AjwgBCAEQThqNgIoIAQgBEEYajYCOCAAQQRqIARBIGoQmQ4gAEEANgIADAYLIAchBQwACyACIAogByAJEI0aIAEgBjYCDCAGIAEoAggiCU8NAyAMQQBHIAxBAWshDCAGIQMNAAsMAgsACyADIgUhBgsCQCABLQAURQ0AIARBDGogBSALaiAGIAVrEJ0JIAQoAgxBAUcNACAEIAQpAhA3AxggBEEBNgIkIARB8IjNADYCICAEQgE3AiwgBEGwAzYCPCAEIARBOGo2AiggBCAEQRhqNgI4IABBBGogBEEgahCZDiAAQQA2AgAMAQsgACAINgIEIABBCDYCACABIAEoAhAgCGs2AhALIARBQGskAA8LIAIgBCgCKEHU/cwAEP0vAAvGBwIHfwV+IwBB8AhrIgQkACABvSELAn9BAyABmUQAAAAAAADwf2ENABpBAiALQoCAgICAgID4/wCDIgxCgICAgICAgPj/AFENABogC0L/////////B4MiD0KAgICAgICACIQgC0IBhkL+////////D4MgC0I0iKdB/w9xIgUbIg1CAYMhDiAMUARAQQQgD1ANARogBUGzCGshBUIBIQwgDlAMAQtCgICAgICAgCAgDUIBhiANQoCAgICAgIAIUSIIGyENQgJCASAIGyEMQct3Qcx3IAgbIAVqIQUgDlALIQYgA0H//wNxIQggBCAFOwHoCCAEIAw3A+AIIARCATcD2AggBCANNwPQCCAEIAY6AOoIAn8CQAJAIAZB/wFxIgdBAU0EQEF0QQUgBcEiBUEASBsgBWwiBUHA/QBJDQFB/euJAUElQaTsiQEQnykACyAHQQJGDQFBASEFQe7riQFB7+uJASALQgBTIgcbQe7riQFBASAHGyACGyEHQQEgC0I/iKcgAhshAiAGQf8BcUEERwRAIARBAzYCmAggBEHz64kBNgKUCCAEQQI7AZAIIARBkAhqDAMLQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAMLIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAgtB7uuJAUEBIAtCAFMiBhshB0Hu64kBQe/riQEgBhsgC0I/iKchCSAEQZAIaiAEQdAIaiAEQRBqIAVBBHZBFWoiCkGAgH5BACADayADwUEASBsiBRCZCCAFwSEFAkAgBCgCkAgEQCAEQcgIaiAEQZgIaigCADYCACAEIAQpApAINwPACAwBCyAEQcAIaiAEQdAIaiAEQRBqIAogBRCaAQsgByACGyEHQQEgCSACGyECIAUgBC4ByAgiBkgEQCAEQQhqIAQoAsAIIAQoAsQIIAYgCCAEQZAIahDtDyAEKAIMIQUgBCgCCAwCC0ECIQUgBEECOwGQCCADQf//A3FFBEBBASEFIARBATYCmAggBEH264kBNgKUCCAEQZAIagwCCyAEIAg2AqAIIARBADsBnAggBEECNgKYCCAEQcXriQE2ApQIIARBkAhqDAELIARBAzYCmAggBEHw64kBNgKUCCAEQQI7AZAIQQEhB0EAIQJBASEFIARBkAhqCyEDIAQgBTYCzAggBCADNgLICCAEIAI2AsQIIAQgBzYCwAggACAEQcAIahC1CiAEQfAIaiQAC68GAQV/IABB//8DcSEEIABBEHYhAwJAAkACQCACDgICAAELIAQgAS0AAGoiACAAQfH/A2sgAEHx/wNJGyIAIANqQfH/A3BBEHQgAGoPCwJAAkAgAkEQTwRAIAIgAkGwK3AiB2siAkGwK0kNAiABIQUgAiEGDAELA0AgBCABLQAAaiIEIANqIQMgAUEBaiEBIAJBAWsiAg0ACyAEQfH/A3AgA0Hx/wNwQRB0cg8LA0BBACEAA0AgAyAEIAAgBWoiAy0AAGoiBGogBCADQQFqLQAAaiIEaiAEIANBAmotAABqIgRqIAQgA0EDai0AAGoiBGogBCADQQRqLQAAaiIEaiAEIANBBWotAABqIgRqIAQgA0EGai0AAGoiBGogBCADQQdqLQAAaiIEaiAEIANBCGotAABqIgRqIAQgA0EJai0AAGoiBGogBCADQQpqLQAAaiIEaiAEIANBC2otAABqIgRqIAQgA0EMai0AAGoiBGogBCADQQ1qLQAAaiIEaiAEIANBDmotAABqIgRqIAQgA0EPai0AAGoiBGohAyAAQRBqIgBBsCtHDQALIANB8f8DcCEDIARB8f8DcCEEIAVBsCtqIQUgBkGwK2siBkGwK08NAAsLIAEgAmohASAHQQ9xIQAgB0HwP3EiBgRAQQAgBmshBSABIQIDQCADIAQgAi0AAGoiA2ogAyACQQFqLQAAaiIDaiADIAJBAmotAABqIgNqIAMgAkEDai0AAGoiA2ogAyACQQRqLQAAaiIDaiADIAJBBWotAABqIgNqIAMgAkEGai0AAGoiA2ogAyACQQdqLQAAaiIDaiADIAJBCGotAABqIgNqIAMgAkEJai0AAGoiA2ogAyACQQpqLQAAaiIDaiADIAJBC2otAABqIgNqIAMgAkEMai0AAGoiA2ogAyACQQ1qLQAAaiIDaiADIAJBDmotAABqIgNqIAMgAkEPai0AAGoiBGohAyACQRBqIQIgBUEQaiIFDQALCyAABEAgASAGaiECA0AgBCACLQAAaiIEIANqIQMgAkEBaiECIABBAWsiAA0ACwsgBEHx/wNwIANB8f8DcEEQdHIhAAsgAAukBwIHfwN+IwBB8AhrIgQkACABvCEHAn9BAyABi0MAAIB/Ww0AGkECIAdBgICA/AdxIgVBgICA/AdGDQAaIAdB////A3EiCEGAgIAEciAHQQF0Qf7//wdxIAdBF3ZB/wFxIgYbIgmtIgtCAYMhDCAFRQRAQQQgCEUNARogBkGWAWshBkIBIQ0gDFAMAQtCgICAECALQgGGIAlBgICABEYiCBshC0ICQgEgCBshDUHofkHpfiAIGyAGaiEGIAxQCyEFIANB//8DcSEIIAQgBjsB6AggBCANNwPgCCAEQgE3A9gIIAQgCzcD0AggBCAFOgDqCAJ/AkACQCAFQf8BcUEBTQRAQXRBBSAGwSIFQQBIGyAFbCIFQcD9AEkNAUH964kBQSVBpOyJARCfKQALIAVB/wFxIglBAkYNAUEBIQVB7uuJAUHv64kBIAdBAEgiBhtB7uuJAUEBIAYbIAIbIQZBASAHQR92IAIbIQIgCUEERwRAIARBAzYCmAggBEHz64kBNgKUCCAEQQI7AZAIIARBkAhqDAMLQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAMLIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAgtB7uuJAUEBIAdBAEgiBhshCUHu64kBQe/riQEgBhsgB0EfdiEHIARBkAhqIARB0AhqIARBEGogBUEEdkEVaiIKQYCAfkEAIANrIAPBQQBIGyIFEJkIIAXBIQUCQCAEKAKQCARAIARByAhqIARBmAhqKAIANgIAIAQgBCkCkAg3A8AIDAELIARBwAhqIARB0AhqIARBEGogCiAFEJoBCyAJIAIbIQZBASAHIAIbIQIgBSAELgHICCIHSARAIARBCGogBCgCwAggBCgCxAggByAIIARBkAhqEO0PIAQoAgwhBSAEKAIIDAILQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAILIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAQsgBEEDNgKYCCAEQfDriQE2ApQIIARBAjsBkAhBASEGQQAhAkEBIQUgBEGQCGoLIQMgBCAFNgLMCCAEIAM2AsgIIAQgAjYCxAggBCAGNgLACCAAIARBwAhqELUKIARB8AhqJAALqgwCBH4IfyMAQdABayIFJAAgBUEHIAQgBEH/AXFBAkkbIgQ6AA8CQAJAAkACQAJAIAEoAgxFDQAgAUEQaiAFQQ9qEOwMIQYgASgCACIQQQxrIREgASgCBCIMIAancSELIAZCGYhC/wCDQoGChIiQoMCAAX4hCCAFLQAPIQQDQAJAIAsgEGopAAAiByAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIBEgBnqnQQN2IAtqIAxxQXRsai0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgByAHQgGGg0KAgYKEiJCgwIB/g1BFDQIgCyAKQQhqIgpqIAxxIQsMAQsLIAVB+ABqQStBAEEBQQEQoBggBSgCfCEDIAUoAnhBAUYNASAFKAKAASIBQZiqzgBBK/wKAAAgAEErNgIMIAAgATYCCCAAIAM2AgQgAEEANgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgBEH/AXFBB0cEQCAFQQE2AnwgBUHIqc4ANgJ4IAVCATcChAEgBUGuAzYCFCAFIAVBEGo2AoABIAUgBUEPajYCECAAQQRqIAVB+ABqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIAEoAiBBCGoQ3iUhESACKAIAIQogBUHwAGoiBCACQQxqKAIANgIAIAUgAikCBDcDaCAFQQA6AGAgBUKAgICAwAA3A1AgBUIANwNYIAVCAjcDEEHAAEEIEK02IgJFDQEgAiAKNgIgIAJBADYCACACIAUpA2g3AiQgAiARNgI4IAJBADYCNCACIAM2AjAgAkEsaiAEKAIANgIAIAVB+ABqIQQjAEEgayIKJAAgCiACNgIAIApBxKrOADYCBCAFQRBqIgNBQGsgAkHcqs4AKAIAEQQAEIYtIApBCGogAiADKAJEIAMoAkhB1KrOACgCABEFAAJAIAooAggiAkEIRwRAIAQgCikDEDcDCCAEQRBqIApBGGopAwA3AwAgBCAKKAIMNgIEDAELIANBAToAUAsgChC8KiAEIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiAEIANB2AD8CgAAQdgAQQgQrTYiA0UNAyADIARB2AD8CgAAQQAhC0EAIREjAEEQayIMJAAgDCACOgAPIAFBEGoiBCAMQQ9qEOwMIQYgASgCCEUEQCAMIAEgBBCnCCAMLQAPIQILIAEoAgQiECAGp3EhDSAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIQ4gAkH/AXEhBANAAkACfwJAAkACQCANIA5qKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAOIAZ6p0EDdiANaiAQcUF0bGoiCkEMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIAtFBEAgBlANAyAGeqdBA3YgDWogEHEhDwtBASAGIAlCAYaDUA0DGkEAIQ0gDiAPaiwAACILQQBOBEAgDiAOKQMAQoCBgoSIkKDAgH+DeqdBA3YiD2otAAAhCwsgDiAPaiAHp0H/AHEiBDoAACAOIA9BCGsgEHFqQQhqIAQ6AAAgASABKAIIIAtBAXFrNgIIIAEgASgCDEEBajYCDCAOIA9BdGxqIgRBCGsgAzYCACAEQQRrQeiqzgA2AgAgBEEMayACOgAADAELIApBBGsiASgCACEEIAFB6KrOADYCACAKQQhrIgEoAgAhDSABIAM2AgALIAUgBDYCBCAFIA02AgAgDEEQaiQADAILQQALIQsgDSARQQhqIhFqIBBxIQ0MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEJsuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAvMDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAIoAgAhCyAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgIDAADcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAs2AiAgAkEANgIAIAIgBSkDaDcCJCACIAw2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohCyMAQSBrIgokACAKQYyrzgA2AgQgCiACNgIAAkAgAkGkq84AKAIAEQQAIgwgBUEQaiIEKAJIIgNNBEAgBCAMNgJIDAELIARBQGsgDCADaxCEHyAEKAJIIQwLIApBCGogAiAEKAJEIAxBnKvOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCsCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQbCrzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFBsKvOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEJsuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAvhDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAIoAgAhCyAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgIDAADcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAs2AiAgAkEANgIAIAIgBSkDaDcCJCACIAw2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohCyMAQSBrIgokACAKQdSrzgA2AgQgCiACNgIAIAJB7KvOACgCABEEACEMIApBADYCECAKQgA3AggCQCAFQRBqIgQoAkgiAyAMTwRAIAQgDDYCSAwBCyAEQUBrIAwgA2sgCkEIahCEGCAEKAJIIQwLIApBCGogAiAEKAJEIAxB5KvOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCpCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQfirzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFB+KvOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEMwuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAuqDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIhBBDGshESABKAIEIgwgBqdxIQsgBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCyAQaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgESAGeqdBA3YgC2ogDHFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiALIApBCGoiCmogDHEhCwwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSERIAIoAgAhCiAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgICAATcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAo2AiAgAkEANgIAIAIgBSkDaDcCJCACIBE2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohBCMAQSBrIgokACAKIAI2AgAgCkGcrM4ANgIEIAVBEGoiA0FAayACQbSszgAoAgARBAAQhy0gCkEIaiACIAMoAkQgAygCSEGsrM4AKAIAEQUAAkAgCigCCCICQQhHBEAgBCAKKQMQNwMIIARBEGogCkEYaikDADcDACAEIAooAgw2AgQMAQsgA0EBOgBQCyAKELwqIAQgAjYCACAKQSBqJAAgBSgCeCICQQhGBEAgBS0ADyECIAQgA0HYAPwKAABB2ABBCBCtNiIDRQ0DIAMgBEHYAPwKAABBACELQQAhESMAQRBrIgwkACAMIAI6AA8gAUEQaiIEIAxBD2oQ7AwhBiABKAIIRQRAIAwgASAEEKgIIAwtAA8hAgsgASgCBCIQIAancSENIAZCGYgiB0L/AINCgYKEiJCgwIABfiEIIAEoAgAhDiACQf8BcSEEA0ACQAJ/AkACQAJAIA0gDmopAAAiCSAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIA4gBnqnQQN2IA1qIBBxQXRsaiIKQQxrLQAARg0CIAZCAX0gBoMiBlBFDQALCyAJQoCBgoSIkKDAgH+DIQYgC0UEQCAGUA0DIAZ6p0EDdiANaiAQcSEPC0EBIAYgCUIBhoNQDQMaQQAhDSAOIA9qLAAAIgtBAE4EQCAOIA4pAwBCgIGChIiQoMCAf4N6p0EDdiIPai0AACELCyAOIA9qIAenQf8AcSIEOgAAIA4gD0EIayAQcWpBCGogBDoAACABIAEoAgggC0EBcWs2AgggASABKAIMQQFqNgIMIA4gD0F0bGoiBEEIayADNgIAIARBBGtBwKzOADYCACAEQQxrIAI6AAAMAQsgCkEEayIBKAIAIQQgAUHArM4ANgIAIApBCGsiASgCACENIAEgAzYCAAsgBSAENgIEIAUgDTYCACAMQRBqJAAMAgtBAAshCyANIBFBCGoiEWogEHEhDQwBCwsCQCAFKAIAIgNFDQAgBSgCBCICKAIAIgEEQCADIAERAwALIAIoAgQiAUUNACADIAEgAigCCBD4OgsgAEEINgIADAQLIAAgBSkCfDcCBCAAQRRqIAVBjAFqKAIANgIAIABBDGogBUGEAWopAgA3AgAgACACNgIAIAVBEGoQmS4MAwsgAyAFKAKAAUHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQdABaiQAC8wMAgR+CH8jAEHQAWsiBSQAIAVBByAEIARB/wFxQQJJGyIEOgAPAkACQAJAAkACQCABKAIMRQ0AIAFBEGogBUEPahDsDCEGIAEoAgAiCkEMayEMIAEoAgQiDiAGp3EhDSAGQhmIQv8Ag0KBgoSIkKDAgAF+IQggBS0ADyEEA0ACQCAKIA1qKQAAIgcgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAMIAZ6p0EDdiANaiAOcUF0bGotAABGDQIgBkIBfSAGgyIGUEUNAAsLIAcgB0IBhoNCgIGChIiQoMCAf4NQRQ0CIA0gC0EIaiILaiAOcSENDAELCyAFQfgAakErQQBBAUEBEKAYIAUoAnwhAyAFKAJ4QQFGDQEgBSgCgAEiAUGYqs4AQSv8CgAAIABBKzYCDCAAIAE2AgggACADNgIEIABBADYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIARB/wFxQQdHBEAgBUEBNgJ8IAVByKnOADYCeCAFQgE3AoQBIAVBrgM2AhQgBSAFQRBqNgKAASAFIAVBD2o2AhAgAEEEaiAFQfgAahCZDiAAQQE2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyABKAIgQQhqEN4lIQwgAigCACELIAVB8ABqIgQgAkEMaigCADYCACAFIAIpAgQ3A2ggBUEAOgBgIAVCgICAgIABNwNQIAVCADcDWCAFQgI3AxBBwABBCBCtNiICRQ0BIAIgCzYCICACQQA2AgAgAiAFKQNoNwIkIAIgDDYCOCACQQA2AjQgAiADNgIwIAJBLGogBCgCADYCACAFQfgAaiELIwBBIGsiCiQAIApB5KzOADYCBCAKIAI2AgACQCACQfyszgAoAgARBAAiDCAFQRBqIgQoAkgiA00EQCAEIAw2AkgMAQsgBEFAayAMIANrEIMfIAQoAkghDAsgCkEIaiACIAQoAkQgDEH0rM4AKAIAEQUAAkAgCigCCCICQQhHBEAgCyAKKQMQNwMIIAtBEGogCkEYaikDADcDACALIAooAgw2AgQMAQsgBEEBOgBQCyAKELwqIAsgAjYCACAKQSBqJAAgBSgCeCICQQhGBEAgBS0ADyECIAsgBEHYAPwKAABB2ABBCBCtNiIDRQ0DIAMgC0HYAPwKAABBACENQQAhDCMAQRBrIg4kACAOIAI6AA8gAUEQaiIEIA5BD2oQ7AwhBiABKAIIRQRAIA4gASAEEKsIIA4tAA8hAgsgASgCBCIKIAancSEPIAZCGYgiB0L/AINCgYKEiJCgwIABfiEIIAEoAgAhECACQf8BcSEEA0ACQAJ/AkACQAJAIA8gEGopAAAiCSAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIBAgBnqnQQN2IA9qIApxQXRsaiILQQxrLQAARg0CIAZCAX0gBoMiBlBFDQALCyAJQoCBgoSIkKDAgH+DIQYgDUUEQCAGUA0DIAZ6p0EDdiAPaiAKcSERC0EBIAYgCUIBhoNQDQMaQQAhDyAQIBFqLAAAIg1BAE4EQCAQIBApAwBCgIGChIiQoMCAf4N6p0EDdiIRai0AACENCyAQIBFqIAenQf8AcSIEOgAAIBAgEUEIayAKcWpBCGogBDoAACABIAEoAgggDUEBcWs2AgggASABKAIMQQFqNgIMIBAgEUF0bGoiBEEIayADNgIAIARBBGtBiK3OADYCACAEQQxrIAI6AAAMAQsgC0EEayIBKAIAIQQgAUGIrc4ANgIAIAtBCGsiASgCACEPIAEgAzYCAAsgBSAENgIEIAUgDzYCACAOQRBqJAAMAgtBAAshDSAPIAxBCGoiDGogCnEhDwwBCwsCQCAFKAIAIgNFDQAgBSgCBCICKAIAIgEEQCADIAERAwALIAIoAgQiAUUNACADIAEgAigCCBD4OgsgAEEINgIADAQLIAAgBSkCfDcCBCAAQRRqIAVBjAFqKAIANgIAIABBDGogBUGEAWopAgA3AgAgACACNgIAIAVBEGoQmS4MAwsgAyAFKAKAAUHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQdABaiQAC/tIARh/IwBBwAFrIhkkACAJKAIUIQwDQCAZQRBqIBJqQf////8ANgIAIBJBBGoiEkGYAUcNAAsgBCAGcSEOQQEhDwJAIAZBAWsiECAGQcAAQRAgDEELRhtrIgxBACAGIAxPGyIXTQ0AIAMgDmshFSACIA5qIREgAiAOQQFqIhNqIRpBASESA0AgCCASSQ0BAkACQCADIA5LBEAgAyAEIBBxIgxNDQEgES0AACACIAxqIhYtAABHDQICQAJAIAMgE0sEQCAMQQFqIg0gA08NASAaLQAAIAIgDWotAABGDQIMBQsgEyADQbSz0AAQwyEACyANIANBxLPQABDDIQALIBYgAyAMayARIBUgBxCyICIMIA9NDQIgCyAYSwRAIAogGEEDdGogEq0gDK1CJYaENwMAIBhBAWohGCAMIQ8MAwsgGCALQdSz0AAQwyEACyAOIANBlLPQABDDIQALIAwgA0Gks9AAEMMhAAsgEEEBayIQIBdNDQEgEkEBaiESIA9BA0kNAAsLIBkgDzYCDAJAIAcgD0sEQCALIBhJDQEgACACIAMgBiAEIAUgByAIIBlBDGogCiAYQQN0aiALIBhrEIMHIBhqIRgLQQAhEgNAAkAgGUEQaiASQQJ0akH/////ADYCACASQSVGIgANAEElIBJBAWogABsiEkEmSQ0BCwsCQAJAAkAgAUUNACADIA5JDQICfyABIQQgAiAOaiERQQQgGSgCDEEBaiIAIABBBE0bIRIgGUEQaiEQQQAhASMAQSBrIgYkACAGQQA2AgQCQAJAAkACQAJAAkACQCADIA5rIg9BA0sEQCAGQQRqQQQgEUEEQdzR0QAQ1SwgBigCBEG9z9bxAWxBEHZB/v8DcUHQotYAai8BACITRQ0BQdn3ASATIBNB2fcBTRshFyAEKAIIIRUgBCgCBCEaIAQoAgAhFgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCATIBdHBEAgE0ECdEHQotoAaiIALQAAIhtBH3EiAkEZTw0BIAIgFmotAAAiFEEfcSEOIAAvAAEgAEEDai0AAEEQdHIiAEEIdiEMIABB/wFxIgNFDQIgBCAAQQh0IAJyIBEgDyAHENkLRQ0SIAJBJk8NUSAQIAJBAnRqIgFBCUEsIANBCkYiABsgDnQgDGpBBXQgAnIiAyABKAIAIgEgASADSxs2AgBBASEBIAJBAWoiBSAHTw0SIAIgD0sNDCACIA9GDQMgDyACayEDIAIgEWoiDS0AACIUQSBrDg8EEgUSEhISCAkSEhIHEgYKCyAXQdn3AUGc1dEAEMMhAAsgAkEZQazV0QAQwyEACyAaIAJBAnQiBWooAgAgAiAMbGoiAEGhvwdPDQggACAVakGgvwcgAGsgESAPIAcgAiACIAdLGxCyICIDIAJHDQ0gAkEmTw1OIAUgEGoiACAMQQV0IAJyIgEgACgCACIAIAAgAUsbNgIAQQEhAQwNC0EAQQBB7N7RABDDIQALIAVBJk8NTUEEQcQAIAAbDAwLIAVBJk8NTCAQIAVBAnRqIgVBwgBB1wAgABsgDnQgDGpBBXQgAnIiFCAFKAIAIgUgBSAUSxs2AgAgA0EBRg0HIA0tAAFBPkcNDCACQQJqIgVBJk8NTEHFAEHhACAAGwwLCyAFQSZPDUsgECAFQQJ0aiIFQc8AQeUAIAAbIA50IAxqQQV0IAJyIhQgBSgCACIFIAUgFEsbNgIAIANBAUYNByANLQABQSBHDQsgAkECaiIFQSZPDUtB2ABB8gAgABsMCgsgBUEmTw1KIBAgBUECdGoiBUHjAEHwACAAGyAOdCAMakEFdCACciIUIAUoAgAiBSAFIBRLGzYCACADQQFGDQcgDS0AAUEgRw0KIAJBAmoiBUEmTw1KQTpB6wAgABsMCQsgBUEmTw1JQcoAQd4AIAAbDAgLIAVBJk8NSEHOAEHxACAAGwwHCyAUQT1HDQcCQCADQQFHBEAgDS0AASIDQSJGDQEgA0EnRw0JIAJBAmoiBUEmTw1JQewAQfQAIAAbDAgLQQFBAUGs39EAEMMhAAsgAkECaiIFQSZPDUdB6ABB6QAgABsMBgsgBkEANgIYIAZBATYCDCAGQbjQ0QA2AgggBkIENwIQIAZBCGpBjNXRABDvLAALIAZBADYCGCAGQQE2AgwgBkG40NEANgIIIAZCBDcCECAGQQhqQdze0QAQ7ywAC0EBQQFB/N7RABDDIQALQQFBAUGM39EAEMMhAAtBAUEBQZzf0QAQwyEACwJAIAMgAkEBayIASQ0AAkACQAJAAkACQCAAQSZJBEAgECAAQQJ0aiIBQQwgDnQgDGpBBXQgAnIiBSABKAIAIgEgASAFSxs2AgBBASEBIAJBAmoiBSAHTw0GIAAgD08NASAAIBFqLQAAQekARw0GIAIgD08NAiACIBFqLQAAQe4ARw0GIAJBAWoiACAPTw0DIAAgEWotAABB5wBHDQYgBSAPTw0EIAUgEWotAABBIEcNBiACQQNqIgBBJk8NBSAQIABBAnRqIgBBMSAOdCAMakEFdCACciIFIAAoAgAiACAAIAVLGzYCAAwGCwxICyAAIA9BvNXRABDDIQALIAIgD0HM1dEAEMMhAAsgACAPQdzV0QAQwyEACyAFIA9B7NXRABDDIQALDEMLAkAgAkEJayIAIBIgACASSxsgEiACQQlLGyIFIAJBAmsiACADIAAgA0kbIgBLDQACQANAIAIgBWsiAUEKSQRAIAVBJk8NAiAQIAVBAnRqIg0gAUGi0NEAai0AACAOdCAMakEFdCACciIBIA0oAgAiDSABIA1JGzYCAEEBIQEgACAFTQ0DIAAgBSAAIAVLaiIFTw0BDAMLCyABQQpBzN7RABDDIQALDEILIAIgA0sNASACQQZqIgUgB08NASACIA9LDQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiAPRwRAIA8gAmshACACIBFqIgMtAAAiDUE5TQRAIA1BIGsODwISAxISEhIHCRISEgUSBAYLAkAgDUHhAGsODwsSEhIMDRISDhISDxISEAALAkAgDUE6aw4ECBISCgALIA1B3QBHDREgAkEBaiIFQSZPDVFBGAwQC0EAQQBBjNbRABDDIQALIAJBAWoiDUEmTw1RIBAgDUECdGoiDUEBIBR0IAxqQQV0IAJyIhQgDSgCACINIA0gFEsbNgIAAkACQAJAAkACQAJAAkACQCAAQQFHBEACQCADLQABIg1B4QBrDg8CAxkZGQUZGQQZGRkZBwYACyANQfQAaw4EBxgYCBgLQQFBAUGc1tEAEMMhAAsgAEEDSQ0ZAkACQAJAAkAgAy0AAiIFQe4Aaw4HAxoaGhoBAgALIAVBIEcNGUEcIAJBA2oiBUEmSQ0YGgxZCyAAQQNGDRwgAy0AA0EgRw0YQS4gAkEEaiIFQSZJDRcaDFgLIABBA0YNHCADLQADQSBHDRdBPCACQQRqIgVBJkkNFhoMVwsgAEEDRg0cIAMtAANB5ABHDRYgAEEFSQ0dIAMtAARBIEcNFkEKIAJBBWoiBUEmSQ0VGgxWCyAAQQNJDR0gAy0AAkH5AEcNFSAAQQNGDR4gAy0AA0EgRw0VQSYgAkEEaiIFQSZJDRQaDFULAkACQCAAQQNPBEAgAy0AAiIFQe4ARg0BIAVB8wBHDRcgAEEDRg0iIAMtAANBIEcNFyACQQRqIgVBJk8NAkEvDBYLQQJBAkGc19EAEMMhAAsgAEEDRg0fIAMtAANBIEcNFUEQIAJBBGoiBUEmSQ0UGgxVCwxUCwJAAkAgAEEDTwRAIAMtAAJB7wBrDgQBFhYCFgtBAkECQczX0QAQwyEACyAAQQNGDSAgAy0AA0HyAEcNFCAAQQVJDSEgAy0ABEEgRw0UQRkgAkEFaiIFQSZJDRMaDFQLIABBA0YNISADLQADQe8ARw0TIABBBUkNIiADLQAEQe0ARw0TIABBBUYNIyADLQAFQSBHDRNBJSAFQSZJDRIaDFMLAkACQCAAQQNPBEAgAy0AAiIFQeYARg0BIAVB7gBHDRUgAEEDRg0nIAMtAANBIEcNFSACQQRqIgVBJk8NAkEtDBQLQQJBAkGs2NEAEMMhAAsgAEEDRg0kIAMtAANBIEcNE0EIIAJBBGoiBUEmSQ0SGgxTCwxSCyAAQQNJDSQgAy0AAkHvAEcNESAAQQNGDSUgAy0AA0H0AEcNESAAQQVJDSYgAy0ABEEgRw0RQdAAIAJBBWoiBUEmSQ0QGgxRCwJAAkAgAEEDTwRAIAMtAAIiDUHoAEYNASANQe8ARw0TIABBA0YNLCADLQADQSBHDRMgAkEEaiIFQSZPDQJBEQwSC0ECQQJBjNnRABDDIQALAkACQCAAQQNHBEAgAy0AA0HhAGsOBQIUFBQBFAtBA0EDQZzZ0QAQwyEACyAAQQVJDSggAy0ABEEgRw0SQQUgAkEFaiIFQSZJDREaDFILIABBBUkNKCADLQAEQfQARw0RIABBBUYNKSADLQAFQSBHDRFBHSAFQSZJDRAaDFELDFALIABBA0kNKSADLQACQekARw0PIABBA0YNKiADLQADQfQARw0PIABBBUkNKyADLQAEQegARw0PIABBBUYNLCADLQAFQSBHDQ9BIyAFQSZJDQ4aDE8LIAJBAWoiBUEmTw1OIBAgBUECdGoiBUETIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNLCADLQABQT5HDQ5BFSACQQJqIgVBJkkNDRoMTgsgAkEBaiINQSZPDU8gECANQQJ0aiINQRQgDnQgDGpBBXQgAnIiFCANKAIAIg0gDSAUSxs2AgAgAEEBRg0sIAMtAAFBIEcNDSACQQJqIg1BJk8NTyAQIA1BAnRqIg1BHyAOdCAMakEFdCACciIUIA0oAgAiDSANIBRLGzYCACAAQQNJDS0gAy0AAkHUAEcNDSAAQQNGDS4gAy0AA0HoAEcNDQJAAkAgAEEFTwRAIAMtAARB5QBrDgUBEBAQAhALQQRBBEHs2tEAEMMhAAsgAEEFRg0wIAMtAAVBIEcNDkErIAVBJkkNDRoMTgsgAEEFRg0wIAMtAAVB8wBHDQ0gAEEHSQ0xIAMtAAZBIEcNDUHLACACQQdqIgVBJkkNDBoMTQsgAkEBaiIFQSZPDUwgECAFQQJ0aiIFQcwAIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNMSADLQABQSBHDQxBDiACQQJqIgVBJkkNCxoMTAsgDUEKRw0LIAJBAWoiBUEmTw1LIBAgBUECdGoiBUEWIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNMSADLQABQQlHDQtBMiACQQJqIgVBJkkNChoMSwtBJCACQQFqIgVBJkkNCRoMSgtBMyACQQFqIgVBJkkNCBoMSQtBOSACQQFqIgVBJkkNBxoMSAsCQAJAIABBAUcEQCADLQABIgBBIkYNASAAQSdHDQogAkECaiIFQSZPDQJB1gAMCQtBAUEBQczb0QAQwyEAC0HGACACQQJqIgVBJkkNBxoMSAsMRwsgAEEBRg0tIAMtAAFB7ABHDQYgAEEDSQ0uIAMtAAJBIEcNBkHUACACQQNqIgVBJkkNBRoMRgsgAEEBRg0uAkACQAJAIAMtAAEiBUHyAGsOAgECAAsgBUHkAEcNByAAQQNJDTEgAy0AAkEgRw0HQTUgAkEDaiIFQSZJDQYaDEcLIABBA0kNMSADLQACQSBHDQZB0gAgAkEDaiIFQSZJDQUaDEYLIABBA0kNMSADLQACQfQARw0FIABBA0YNMiADLQADQSBHDQVB3wAgAkEEaiIFQSZJDQQaDEULIABBAUYNMiADLQABQfUARw0EIABBA0kNMyADLQACQewARw0EIABBA0YNNCADLQADQSBHDQRB2gAgAkEEaiIFQSZJDQMaDEQLAkACQCAAQQFHBEAgAy0AAUH2AGsOBQEGBgYCBgtBAUEBQfzc0QAQwyEACyAAQQNJDTUgAy0AAkHlAEcNBCAAQQNGDTYgAy0AA0EgRw0EQdwAIAJBBGoiBUEmSQ0DGgxECyAAQQNJDTYgAy0AAkHlAEcNAyAAQQNGDTcgAy0AA0EgRw0DQeQAIAJBBGoiBUEmSQ0CGgxDCwJAAkAgAEEBRwRAIAMtAAEiBUHlAEYNASAFQfkARw0FIABBA0kNPSADLQACQSBHDQUgAkEDaiIFQSZPDQJBPQwEC0EBQQFBzN3RABDDIQALIABBA0kNOCADLQACQfMARw0DIABBA0YNOSADLQADQfMARw0DIABBBUkNOiADLQAEQSBHDQNB3QAgAkEFaiIFQSZJDQIaDEMLDEILIABBAUYNOiADLQABQfUARw0BIABBA0kNOyADLQACQfMARw0BIABBA0YNPCADLQADQSBHDQEgAkEEaiIFQSZPDT1B6gALIQAgECAFQQJ0aiIDIAAgDnQgDGpBBXQgAnIiACADKAIAIgIgACACSRs2AgALIBNBAWohEyAbwEEATg0BDD0LCyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakH81dEAEO8sAAtBAkECQazW0QAQwyEAC0EDQQNBvNbRABDDIQALQQNBA0HM1tEAEMMhAAtBA0EDQdzW0QAQwyEAC0EEQQRB7NbRABDDIQALQQJBAkH81tEAEMMhAAtBA0EDQYzX0QAQwyEAC0EDQQNBrNfRABDDIQALQQNBA0G819EAEMMhAAtBA0EDQdzX0QAQwyEAC0EEQQRB7NfRABDDIQALQQNBA0H819EAEMMhAAtBBEEEQYzY0QAQwyEAC0EFQQVBnNjRABDDIQALQQNBA0G82NEAEMMhAAtBA0EDQczY0QAQwyEAC0ECQQJB3NjRABDDIQALQQNBA0Hs2NEAEMMhAAtBBEEEQfzY0QAQwyEAC0EEQQRBrNnRABDDIQALQQRBBEG82dEAEMMhAAtBBUEFQczZ0QAQwyEAC0EDQQNB3NnRABDDIQALQQJBAkHs2dEAEMMhAAtBA0EDQfzZ0QAQwyEAC0EEQQRBjNrRABDDIQALQQVBBUGc2tEAEMMhAAtBAUEBQaza0QAQwyEAC0EBQQFBvNrRABDDIQALQQJBAkHM2tEAEMMhAAtBA0EDQdza0QAQwyEAC0EFQQVB/NrRABDDIQALQQVBBUGM29EAEMMhAAtBBkEGQZzb0QAQwyEAC0EBQQFBrNvRABDDIQALQQFBAUG829EAEMMhAAtBAUEBQdzb0QAQwyEAC0ECQQJB7NvRABDDIQALQQFBAUH829EAEMMhAAtBAkECQYzc0QAQwyEAC0ECQQJBnNzRABDDIQALQQJBAkGs3NEAEMMhAAtBA0EDQbzc0QAQwyEAC0EBQQFBzNzRABDDIQALQQJBAkHc3NEAEMMhAAtBA0EDQezc0QAQwyEAC0ECQQJBjN3RABDDIQALQQNBA0Gc3dEAEMMhAAtBAkECQazd0QAQwyEAC0EDQQNBvN3RABDDIQALQQJBAkHc3dEAEMMhAAtBA0EDQezd0QAQwyEAC0EEQQRB/N3RABDDIQALQQJBAkGM3tEAEMMhAAtBAUEBQZze0QAQwyEAC0ECQQJBrN7RABDDIQALQQNBA0G83tEAEMMhAAsMAwsMBQsCQAJAIAdBBE0NAAJAIBEtAAAiE0EuRyATQSBHcQ0AIAZBADYCBCAPQQRGDQcgBkEEakEEIBFBAWoiG0EEQdzR0QAQ1SwgBigCBEG9z9bxAWxBEHZB/v8DcUHQotYAai8BACIARQ0AIA9BAWshFEECQc0AIBNBIEYiGhshAkHZAEHDACAaGyEDQQZBICAaGyEgIAdBAWshHSAAQQJ0QdCi2gBqIQVB2fcBIAAgAEHZ9wFNGyIhIABrQQFqIR4gBCgCACEiA0ACQAJAAkACQAJAAkACQAJAAkACQCAeQQFrIh4EQCAFLQAAIiNBH3EiDkEZTw0BIAVBAWovAAAgBUEDai0AAEEQdHIiAEEIdiENIABBCHQgDnIhDCAOICJqLQAAQR9xIRcCQAJAAkACQAJAAkACQAJAAkACQAJAIABB/wFxIhxFBEAgBCAMIBsgFCAdENkLRQ0WIA5BAWoiAEEmTw0dIBAgAEECdGoiASAgIBd0IA1qQQV0IA5yIgwgASgCACIBIAEgDEsbNgIAQQEhASAOQQJqIgwgB08NFiAOIA9PDQ4gACAPRg0BIAAgEWoiFS0AACIWQSBGDQIgFkEoRw0DIAxBJk8NICADIQAMFQsgGkUNFSAEIAwgGyAUIB0Q2QtFDRUgDkEBaiIVQSZPDRAgECAVQQJ0aiIBQR5B1QAgHEEKRiIAGyAXdCANakEFdCAOciIMIAEoAgAiASABIAxLGzYCAEEBIQEgDkECaiIMIAdPDRUgDiAPTw0RIA8gFUYNBCAPIBVrIRYgESAVaiIVLQAAIh9BLGsOAwYVBwMLQQBBAEHs39EAEMMhAAsgDEEmSQRAIAIhAAwTCwwdCyATQSBHDRIgDyAAayEAAkACQAJAIBZBLGsOAwAVAQILIAxBJk8NHiAQIAxBAnRqIgxB5wAgF3QgDWpBBXQgDnIiFiAMKAIAIgwgDCAWSxs2AgAgAEEBRg0NIBUtAAFBIEcNFCAOQQNqIgxBJkkEQEEhIQAMFAsMHgsgDEEmTw0dIBAgDEECdGoiDEHHACAXdCANakEFdCAOciIWIAwoAgAiDCAMIBZLGzYCACAAQQFGDQ0gFS0AAUEgRw0TIA5BA2oiDEEmSQRAQTQhAAwTCwwdCyAWQT1HDRICQAJAIABBAUcEQCAVLQABIgBBIkYNASAAQSdHDRUgDkEDaiIMQSZPDQJB4gAhAAwUC0EBQQFBnODRABDDIQALIA5BA2oiDEEmSQRAQdEAIQAMEwsMHQsMHAsgH0EgRg0BIB9BPUcNESAWQQFGDQQgFS0AASIMQSJGDQUgDEEnRg0GDBELQQBBAEG84NEAEMMhAAsgDEEmTw0ZQQ9B0wAgABshAAwOCyAcQQpGBEAgDEEmTw0ZIBAgDEECdGoiDEHtACAXdCANakEFdCAOciIcIAwoAgAiDCAMIBxLGzYCAAsgFkEBRg0LIBUtAAFBIEcNDiAOQQNqIgxBJk8NGEHBAEHvACAAGyEADA0LIAxBJk8NFyAQIAxBAnRqIgxB4ABB8wAgABsgF3QgDWpBBXQgDnIiHCAMKAIAIgwgDCAcSxs2AgAgFkEBRg0LIBUtAAFBIEcNDSAOQQNqIgxBJk8NF0HbAEH1ACAAGyEADAwLQQFBAUHs4NEAEMMhAAsgDkEDaiIMQSZPDRVB9gBB7gAgABshAAwKCyAOQQNqIgxBJk8NFEH4AEH3ACAAGyEADAkLICFB2fcBQbzf0QAQwyEACyAOQRlBzN/RABDDIQALIAZBADYCGCAGQQE2AgwgBkG40NEANgIIIAZCBDcCECAGQQhqQdzf0QAQ7ywAC0EBQQFB/N/RABDDIQALQQFBAUGM4NEAEMMhAAsgFUEmQfzU0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakGs4NEAEO8sAAtBAUEBQczg0QAQwyEAC0EBQQFB3ODRABDDIQALIBAgDEECdGoiASAAIBd0IA1qQQV0IA5yIgAgASgCACIBIAAgAUkbNgIAQQEhAQsgBUEEaiEFICPAQQBODQALCyAHQQVGDQACQAJAIBEtAAEiDkEgRgRAIBNBLEYgE0HzAEZyDQEgE0HlAEcNAgwBCyATQcIBRw0BIA5BoAFGDQAMAQsgBkEANgIEIA9BAmsiF0EDTQ0HIAZBBGpBBCARQQJqIhVBBEHc0dEAENUsIAYoAgRBvc/W8QFsQRB2Qf7/A3FB0KLWAGovAQAiAEUNAEESQQdBDSATQfMARhsgE0HlAEYbIQIgB0ECayEaIABBAnRB0KLaAGohBUHZ9wEgACAAQdn3AU0bIhYgAGtBAWohACAEKAIAIRsgE0HCAUYhFANAAkACQAJAAkAgAEEBayIABEAgBS0AACIdQR9xIgNBGU8NASAFQQFqLwAAIAVBA2otAABBEHRyIg1B/wFxDQQgAyAbai0AACEeIAQgDUEIdCADciAVIBcgGhDZC0UNBCADQQJqIQwgFARAQeYAIQEgDEEmSQ0EDA8LIAcgDE0NBCAMIA9PDQIgDCARai0AAEEgRw0EIANBA2oiDEEmSQRAIAIhAQwECwwOCyAWQdn3AUH84NEAEMMhAAsgA0EZQYzh0QAQwyEACyAMIA9BnOHRABDDIQALIBAgDEECdGoiDCABIB50IA1BCHZqQQV0IANyIgEgDCgCACIDIAEgA0kbNgIAQQEhAQsgBUEEaiEFIB3AQQBODQALCyAHQQhNDQACQAJAIBNBIEYEQCAOQfQARw0DIBEtAAJB6ABHDQMgES0AA0HlAEcNAyAPQQRGDQEgES0ABEEgRw0DDAILIBNBLkcgDkHjAEdyDQIgES0AAkHvAEcNAiARLQADQe0ARw0CIA9BBEcEQCARLQAEQS9GDQIMAwtBBEEEQbzh0QAQwyEAC0EEQQRBrOHRABDDIQALIAZBADYCBCAPQQVrIhVBA00NASAGQQRqQQQgEUEFaiIaQQRB3NHRABDVLCAGKAIEQb3P1vEBbEEQdkH+/wNxQdCi1gBqLwEAIgBFDQBBKUHIACATQSBGGyEWIAdBBWshGyAAQQJ0QdCi2gBqIQVB2fcBIAAgAEHZ9wFNGyIUIABrQQFqIQAgBCgCACEdA0ACQAJAAkACQAJAAkACQAJAAkACQAJAIABBAWsiAARAIAUtAAAiHkEfcSIDQRlPDQEgBUEBai8AACAFQQNqLQAAQRB0ciIMQf8BcQ0LIAMgHWotAAAhDSAEIAxBCHQgA3IgGiAVIBsQ2QtFDQsgA0EFaiICQSZPDQ8gECACQQJ0aiIBIAxBCHYiDiAWIA1BH3EiF3RqQQV0IANyIgwgASgCACIBIAEgDEsbNgIAQQEhASACIAdPDQsgAiAPSw0CIBNBIEcgA0EIaiAHT3INCyACIA9GDQMgAiARaiIMLQAAQSBHDQsgDyACayICQQFGDQQgDC0AAUHvAEcNCyACQQNJDQUgDC0AAkHmAEcNCyACQQNGDQYgDC0AA0EgRw0LIANBCWoiDUEmTw0SIBAgDUECdGoiDUE+IBd0IA5qQQV0IANyIhwgDSgCACINIA0gHEsbNgIAIANBDGogB08NCyACQQVJDQcgDC0ABEH0AEcNCyACQQVGDQggDC0ABUHoAEcNCyACQQdJDQkgDC0ABkHlAEcNCyACQQdGDQogDC0AB0EgRw0LIANBDWoiAkEmTw0PIBAgAkECdGoiAkHJACAXdCAOakEFdCADciIDIAIoAgAiAiACIANLGzYCAAwLCyAUQdn3AUHM4dEAEMMhAAsgA0EZQdzh0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakHs4dEAEO8sAAtBAEEAQfzh0QAQwyEAC0EBQQFBjOLRABDDIQALQQJBAkGc4tEAEMMhAAtBA0EDQazi0QAQwyEAC0EEQQRBvOLRABDDIQALQQVBBUHM4tEAEMMhAAtBBkEGQdzi0QAQwyEAC0EHQQdB7OLRABDDIQALIAVBBGohBSAewEEATg0ACwsgBkEgaiQAIAEMBwsMBAsgAkEmQfzU0QAQwyEACyAFQSZB/NTRABDDIQALIABBJkH81NEAEMMhAAsgDUEmQfzU0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakHM0dEAEO8sAAsgDEEmQfzU0QAQwyEAC0UNACAJLQBVRQ0BIBJBJSAHIAdBJU8bIgBLDQAgCEEBaiECIAkoAhAhAwNAAkAgGUEQaiASQQJ0aigCACIBQf////8ATw0AIAIgAUEFdmoiBCADSw0AIAsgGEsEQCAKIBhBA3RqIAStIBJBBXQgAUEfcSIBQQAgASASRxtyrUIghoQ3AwAgGEEBaiEYDAELIBggC0G8tNAAEMMhAAsgACASTQ0BIBIgACASS2oiEiAATQ0ACwsgGUHAAWokACAYDwtBhLTQAEEnQay00AAQnykACyAOIANB9LPQABCvOwALIBlBADYCuAEgGUEBNgKsASAZQfig0AA2AqgBIBlCBDcCsAEgGUGoAWpB5LPQABDvLAALyQgBA38jAEHgAGsiBSQAAkAgAAJ/AkACQAJAAkAgAkH/AXFBAWsOAwECAwALIwBBgAJrIgYkACAGQbwBaiICIAEQqC4gBkHgAGoiByACEKEbIAZBBGoiASAHQYSD/wAQjBggByABEM0cIAVBMGoiAiAHEL8TIAZBgAJqJAAgBUEoaiIGIAVBxABqKAIANgIAIAVBEGoiByAFQdAAaikCADcDACAFQRhqIgEgBUHYAGopAgA3AwAgBSAFKQI8NwMgIAUgBSkCSDcDCCACEKUMQThBBBCtNiICRQ0EIAIgBDYCECACIAM2AgwgAkENOwEIIAJCgYCAgBA3AgAgAiAFKQMgNwIUIAIgBSkDCDcCICACQRxqIAYoAgA2AgAgAkEoaiAHKQMANwIAIAJBMGogASkDADcCAEGo2P8ADAMLIAVBMGoiAiABEPUkIAVBKGoiBiAFQcQAaigCADYCACAFQRBqIgcgBUHQAGopAgA3AwAgBUEYaiIBIAVB2ABqKQIANwMAIAUgBSkCPDcDICAFIAUpAkg3AwggAhClDEE4QQQQrTYiAkUNAyACIAQ2AhAgAiADNgIMIAJBjQI7AQggAkKBgICAEDcCACACIAUpAyA3AhQgAiAFKQMINwIgIAJBHGogBigCADYCACACQShqIAcpAwA3AgAgAkEwaiABKQMANwIAQYDZ/wAMAgsjAEGAAmsiBiQAIAZBvAFqIgIgARCoLiAGQeAAaiIHIAIQoRsgBkEEaiIBIAdBlIT/ABCMGCAHIAEQzRwgBUEwaiICIAcQqBMgBkGAAmokACAFQShqIgYgBUHEAGooAgA2AgAgBUEQaiIHIAVB0ABqKQIANwMAIAVBGGoiASAFQdgAaikCADcDACAFIAUpAjw3AyAgBSAFKQJINwMIIAIQpQxBOEEEEK02IgJFDQIgAiAENgIQIAIgAzYCDCACQY0EOwEIIAJCgYCAgBA3AgAgAiAFKQMgNwIUIAIgBSkDCDcCICACQRxqIAYoAgA2AgAgAkEoaiAHKQMANwIAIAJBMGogASkDADcCAEHY2f8ADAELIwBBgAJrIgYkACAGQbwBaiICIAEQqC4gBkHgAGoiByACEKEbIAZBBGoiASAHQayE/wAQjBggByABEM0cIAVBMGoiAiAHELQTIAZBgAJqJAAgBUEoaiIGIAVBxABqKAIANgIAIAVBEGoiByAFQdAAaikCADcDACAFQRhqIgEgBUHYAGopAgA3AwAgBSAFKQI8NwMgIAUgBSkCSDcDCCACEKUMQThBBBCtNiICRQ0BIAIgBDYCECACIAM2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgBSkDIDcCFCACIAUpAwg3AiAgAkEcaiAGKAIANgIAIAJBKGogBykDADcCACACQTBqIAEpAwA3AgBBsNr/AAs2AgQgACACNgIAIAVB4ABqJAAPC0EEQTgQoz0AC6EJAgt/A34jAEEwayIEJAAgASgCACECAkADQAJAAkACQAJAAkAgAgRAIAEoAgQiAiABKAIMRw0BIAEQvSsgAUEANgIACyABKAIgIgNFDQQgASgCMCICIAEoAjQiCE8NBCADIAJBAnRqIQUgASgCKCACQcACbGohBiABKAI4IQMgASgCPCEJA0ACQCABIAJBAWoiAjYCMCABIAUoAgAEfyADBSAJIAMQ8iYgASgCOCEHDQEgBwtBAWoiAzYCOCAFQQRqIQUgBkHAAmohBiACIAhHDQEMBgsLIAEgB0EBajYCOCAEQQA2AhAgBEKAgICAgAE3AgggBEEgaiAGEOwgIAMgASgCRCICTw0BIAEoAkAgA0EYbGoiAigCCEUNAyACKAIEKQMAIg0gBCkDICIOUg0CDAMLIABCATcDACABIAJBEGo2AgQgACACKQMINwMQIAAgAikDADcDCAwFCyADIAJBoLXCABDDIQALIARBCGpBsLXCABCVKCAEKAIMIgUgDTcDCCAFIA43AwAgBEEBNgIQCwJAAkACQCABKAJIKAIAIgVFBEAgAigCCCEFIAIoAgQhAgwBCyAFIAMQ8iYgAigCCCEFIAIoAgQhAg0BCyAEQRRqIAEoAlAgAiAFEPsIDAELIARBFGogASgCTCACIAUQ+wgLIAQgBCgCFDYCKCAEIAQoAhgiAjYCICAEIAI2AiQgBCACIAQoAhxBBHRqNgIsIARBIGoiBSgCDCAFKAIEIgZrIgdBBHYiCCAEQQhqIgIoAgAgAigCCCIDa0sEQCACIAMgCEEIQRAQ0CggAigCCCEDCyAHBEAgAigCBCADQQR0aiAGIAf8CgAACyAFIAY2AgwgAiACKAIIIAhqNgIIIAUQvSsgASgCVCEFIAQoAgwiAiAEKAIQQQR0aiEGIwBBIGsiAyQAIANBFGogBiACa0EEdkEAQQhBCBCgGCADKAIYIQcgAygCFEEBRgRAIAcgAygCHEHgtMIAEP0vAAsgBEEgaiEKIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAc2AgggA0EIaiIHIAYgAmtBBHYiCBDsLSAHKAIIIQkgByACIAZHBH8gCCAJaiAHKAIEIAlBA3RqIQYDQCAGIAIpAwA3AwAgAkEQaiECIAZBCGohBiAIQQFrIggNAAsFIAkLNgIIIApBCGogCygCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUoAggiAiAFKAIARgRAIAVBwLXCABCQKAsgBSgCBCACQQxsaiIDIAQpAiA3AgAgA0EIaiAEQShqKAIANgIAIAUgAkEBajYCCCAEKAIIIgNBgICAgHhGDQAgBCkCDCINpyICIA1CIIinQQR0aiEFIAEoAgAEQCABEL0rCyABIAU2AgwgASADNgIIIAEgAjYCBCABIAI2AgAMAQsLAn4CQCABKAIQBEAgASgCFCICIAEoAhxGDQEgASACQRBqNgIUIAIpAwghDSACKQMAIQ5CAQwCCyAAQgA3AwAMAgsgAUEQaiIBEL0rIAFBADYCAEIACyEPIAAgDTcDECAAIA43AwggACAPNwMACyAEQTBqJAALyAcBB38jAEEQayIIJAACQAJAAkAgAyADQQNrIgRBACADIARPGyIFSwRAIAMhBANAAkAgAiAETQRAIAIgBEYNBAwBCyABIARqLAAAQb9/TA0AIAQhAgwDCyAFIARBAWsiBEkNAAsLIANBBEkNAQJAIAIgBU0EQCACIAVHDQEMAgsgBSICIAFqLAAAQb9/Sg0BCyAAQYCAgIB4NgIADAILIAEgAmohBANAAn8CfwJAIARBAWsiAywAACIFQQBIBEAgBEECayIDLQAAIgbAIgdBQEgNASAGQR9xDAILQQEhBiADDAILIAdBP3ECfyAEQQNrIgMtAAAiBsAiB0G/f0oEQCAGQQ9xDAELIAdBP3EgBEEEayIDLQAAQQdxQQZ0cgtBBnRyCyEEIAVBP3EgBEEGdHIhBQJ/QQEgBEECSQ0AGkECIARBIEkNABpBA0EEIARBgAhJGwshBiADCyEEAkAgBUEBaiIDQYCwA3NBgIDEAGtBgJC8f08EQAJ/QQEgBUH/AEkNABpBAiAFQf8PSQ0AGkEDQQQgBUH//wNJGwsgBkYNAQsgASAERg0CDAELCwJAAkACQAJAIAIgBCABayIHIAZqIgRPBEAgCEEEaiAEQQBBAUEBEKAYIAgoAgghCSAIKAIEQQFGDQEgCCgCDCECIAQEQCACIAEgBPwKAAALIAQgB0kNAiACIAdqIQEgBUH/AE8EQEECQQNBBCAFQf//A0kbIAVB/w9JIgcbIgogBk0EQCAHDQUgBUH//wNPBEAgASADQT9xQYABcjoAAyABIANBEnZB8AFyOgAAIAEgA0EGdkE/cUGAAXI6AAIgASADQQx2QT9xQYABcjoAAQwHCyABIANBP3FBgAFyOgACIAEgA0EMdkHgAXI6AAAgASADQQZ2QT9xQYABcjoAAQwGCyMAQUBqIgAkACAAIAo2AgggACADNgIEIAAgBjYCDCAAQQM2AiQgAEHEjYoBNgIgIABBAzYCFCAAQayNigE2AhAgAEEDNgIcIAAgAEEMaq1CgICAgLAHhDcDOCAAIABBBGqtQoCAgICg5AOENwMwIAAgAEEIaq1CgICAgLAHhDcDKCAAIABBKGo2AhggAEEQakGE784AEO8sAAsgASADOgAADAQLIAQgAkGghc8AELA7AAsgCSAIKAIMQcD1zgAQ/S8ACyAHIARBsIXPABCvOwALIAEgA0E/cUGAAXI6AAEgASADQQZ2QcABcjoAAAsgACAENgIIIAAgAjYCBCAAIAk2AgAMAQsgAEGAgICAeDYCAAsgCEEQaiQAC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGouAQCyOAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgAS4BALI4AgAgBEEEaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQN0aisDALY4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKwMAtjgCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVBAXRqLwEAszgCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQCzOAIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC+HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGooAgC4OQMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALg5AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQN0aikDALU4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKQMAtTgCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAXRqLgEAtzkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEuAQC3OQMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2DwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEDdGopAwC0OAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASkDALQ4AgAgBEEEaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQJ0aioCALs5AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKgIAuzkDACAEQQhqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAXRqLwEAuDkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQC4OQMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGooAgC3OQMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALc5AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL0gUBDH8jAEEQayINJAACQCAEQQdNBEAgDUIANwMIIAQEQCANQQhqIAMgBPwKAAALQWwgACABIAIgDUEIakEIEP0HIgAgACAESxsgACAAQYl/SRshAgwBCyABKAIAQQFqIg9BAXQiBwRAIABBACAH/AsACyADKAAAIglBD3EiBkEKSwRAQVQhAgwBCyACIAZBBWo2AgAgAyAEaiICQQRrIQcgAkEHayEOIAZBBmohEEEEIQUgCUEEdiECQSAgBnQiC0EBciEMQQAhBkEBIQogAyEEA0ACQAJAIApBAXEEQCAGIQkMAQsDQCACQX9zQYCAgIB4cmgiCEEYSUUEQCAGQSRqIQYgBCAOTQR/IARBA2oFIAQgDmtBA3QgBWpBH3EhBSAHCyIEKAAAIAV2IQIMAQsLIAUgCEEecSIJakECaiEFIA8gCEEBdkEDbCIIIAIgCXYiAkEDcWogBmoiCU0EQCACQQNxIAhqIAZqIQYMAgsCfyAEIA5LIAVBA3YgBGoiAiAHS3FFBEAgBUEHcSEFIAIMAQsgBCAHa0EDdCAFakEfcSEFIAcLIgQoAAAgBXYhAgsgAiALQQFrcSIKIAtBAXRBAWsiCCAMayIGSQR/IBBBAWsFIAIgCHEiAiAGQQAgAiALThtrIQogEAsgACAJQQF0aiAKQQFrIgg7AQAgCUEBaiEGIAVqIQUgC0EBIAprIAggCkEAShsgDGoiDEoEQCAMQQJIDQFBICAMZyICayEQQQEgAkEfc3QhCwsgBiAPTw0AIAhBAEchCgJ/IAQgDksgBUEDdSAEaiICIAdLcUUEQCAFQQdxIQUgAgwBCyAFIAQgB2tBA3RqQR9xIQUgBwsiBCgAACAFdiECDAELC0FsIQIgDEEBRw0AIAYgD0sEQEFQIQIMAQsgBUEgSg0AIAEgBkEBazYCACAEIAVBB2pBA3VqIANrIQILIA1BEGokACACC5UGAQh/AkACQAJ/AkACQAJAAkAgAkUEQCAALQAAQQFxDQELIAIgAkEfdSIDcyADayEDQS1BKyACQQBIGyEHQQEgAC0AAyICdCIEQTRxDQEgBEEKcQ0CIAIhBiACIQQMBQsgASgCCCICIQAgAiABKAIARgR/IAEgAkEBENsoIAEoAggFIAALIAEoAgRqQdoAOgAAIAEgAkEBajYCCEEAIQAMBQsgA0E8bSIGQTxvIQQgAyAGQTxsayIGRSACQQJHcQ0BQQIhAkEBIQUMAwsgA0EeaiIDQTxtQTxvIgRBACACQQNHIARBAEdyIgIbDAELIARBACAEQQBHIAJBBUdyIgIbCyEEQQAhBgsgAC0AASEIAkAgA0GQHG0iCUH/AXFBCkkEQCABKAIIIQMgAC0AAiIKQQJGBEAgAyIAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAAsgASgCBGpBIDoAACABIANBAWoiAzYCCAsgAyIAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAAsgASgCBGogBzoAACABIANBAWoiADYCCCAKQQFGBEAgACABKAIARgR/IAEgAEEBENsoIAEoAggFIAALIAEoAgRqQTA6AAAgASADQQJqIgA2AggLIAAhAyAAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAwsgASgCBGogCUEwcjoAACABIABBAWo2AggMAQsgASgCCCIDIQAgAyABKAIARgR/IAEgA0EBENsoIAEoAggFIAALIAEoAgRqIAc6AABBASEAIAEgA0EBajYCCCABIAkQixgNAQsCQCACQQFrQQJPBEBBACEAIAVFDQIMAQsgCEEBRgRAIAEoAggiAiEAIAIgASgCAEYEfyABIAJBARDbKCABKAIIBSAACyABKAIEakE6OgAAIAEgAkEBajYCCAsgASAEEIsYIgAgBUVyDQELIAhBAUYEQCABKAIIIgIhACACIAEoAgBGBH8gASACQQEQ2yggASgCCAUgAAsgASgCBGpBOjoAACABIAJBAWo2AggLIAEgBhCLGA8LIAAL5gYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2pBAnQiBWogASAFaigCALM4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKAIAszgCACAEQQRqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvmBgIGfwN+IwBBkAFrIgIkACABQQxqENg8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinakEDdCIFaiABIAVqKQMAujkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEpAwC6OQMAIARBCGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGo1AgA3AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABNQIANwMAIARBCGohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDZHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGouAQA2AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABLgEANgIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC/HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGovAQA2AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABLwEANgIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDHHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUEBdGoyAQA3AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABMgEANwMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDWHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+YGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqQQJ0IgVqIAEgBWooAgCyOAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALI4AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQF0ajMBADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEzAQA3AwAgBEEIaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENYdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQF0ai8BADYCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQA2AgAgBEEEaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQJ0ajQCADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAE0AgA3AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENYdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQF0ajMBADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEzAQA3AwAgBEEIaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENkdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5gYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2pBA3QiBWogASAFaikDALk5AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKQMAuTkDACAEQQhqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvnBgIGfwN+IwBBkAFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAnRqNQIANwMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgATUCADcDACAEQQhqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ1h0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAviBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLAAAsjgCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2osAACyOAIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4gYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBQJAAkACQCADQThxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFaiwAALc5AwAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAAtzkDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+IGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEDdCIDIQUCQAJAAkAgA0E4cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBWotAAC4OQMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADai0AALg5AwAgBEEIaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAviBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLQAAszgCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAACzOAIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBQJAAkACQCADQT5xIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEBdGogASAFai0AADsBAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAAA7AQAgBEECaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQzR0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBA3QiAyEFAkACQAJAIANBOHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVqMQAANwMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADajEAADcDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDWHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQUCQAJAAkAgA0E+cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAXRqIAEgBWosAAA7AQAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAAOwEAIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENodIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBQJAAkACQCADQThxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFajAAADcDAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2owAAA3AwAgBEEIaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQ1h0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBA3QiAyEFAkACQAJAIANBOHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVqMQAANwMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADajEAADcDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDZHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQUCQAJAAkAgA0E+cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAXRqIAEgBWotAAA7AQAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLQAAOwEAIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENodIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBQJAAkACQCADQTxxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFai0AADYCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAAA2AgAgBEEEaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQxx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLQAANgIADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADai0AADYCACAEQQRqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBC/HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkECdCIDIQUCQAJAAkAgA0E8cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBWosAAA2AgAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAANgIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL2gYCCX8GfiMAQRBrIgokAAJAAkACfwJAAkACQAJAIAEpAwAiDlBFBEAgDkKAgICAgICAgCBaDQEgA0UNAkGgfyABLwEYIA55Ig+nayIFa8FB0ABsQbCnBWpBzhBtIgFB0QBPDQMgCiABQQR0IgFB0NyJAWopAwBCACAOIA+GQgAQqB4gCikDCCAKKQMAQj+IfCIQQUAgBSABQdjciQFqLwEAamsiCEE/ca0iDoinIQUgAUHa3IkBai8BACEBQgEgDoYiEUIBfSISIBCDIg9QBEAgA0EKSw0HIANBAnRBtOmJAWooAgAgBUsNBwsgBUGQzgBPBEAgBUHAhD1JDQUgBUGAwtcvTwRAQQhBCSAFQYCU69wDSSIGGyEHQYDC1y9BgJTr3AMgBhsMBwtBBkEHIAVBgK3iBEkiBhshB0HAhD1BgK3iBCAGGwwGCyAFQeQATwRAQQJBAyAFQegHSSIGGyEHQeQAQegHIAYbDAYLQQpBASAFQQlLIgcbDAULQajYiQFBHEHk6IkBEJ8pAAtB9OiJAUEkQZjpiQEQnykAC0HA6IkBQSFBqOmJARCfKQALIAFB0QBB4OaJARDDIQALQQRBBSAFQaCNBkkiBhshB0GQzgBBoI0GIAYbCyEGAkACQAJAAkAgByABa0EBasEiCSAEwSIBSgRAIAhB//8DcSEMIAkgBGvBIAMgCSABayADSRsiCEEBayENQQAhAQNAIAUgBm4hCyABIANGDQMgBSAGIAtsayEFIAEgAmogC0EwajoAACABIA1GDQQgASAHRg0CIAFBAWohASAGQQpJIAZBCm4hBkUNAAtB4OmJARDiKwALIAAgAiADQQAgCSAEIBBCCoAgBq0gDoYgERDMDQwFCyABQQFqIQEgDEEBa0E/ca0hE0IBIRADQCAQIBOIUEUEQCAAQQA2AgAMBgsgASADTw0DIAEgAmogD0IKfiIPIA6Ip0EwajoAACAQQgp+IRAgDyASgyEPIAggAUEBaiIBRw0ACyAAIAIgAyAIIAkgBCAPIBEgEBDMDQwECyADIANB8OmJARDDIQALIAAgAiADIAggCSAEIAWtIA6GIA98IAatIA6GIBEQzA0MAgsgASADQYDqiQEQwyEACyAAQQA2AgALIApBEGokAAuoFgIXfwJ+IwBBwAFrIgwkACAAAn8CQAJAAkACQCAFIAaEUARAIAcgCIRQRQ0BIABBADoAAUEBDAULIAUgB4MgBiAIg4NCf1IgASAChEIAUnINACADIARCgICAgICAgICAf4WEUA0BCyAMIAEgBEI/hyIghSIBICB9NwOAASAMIAIgIIUiISAgfSABICBUIgqtfTcDiAEgDCADICCFIgMgBEI/iHwiASAKICAgIVYgAlAbrSICfTcDkAEgDCABIANUrSAEICCFfCABIAJUrX03A5gBIAwgCEI/hyIBIAiFIAEgB4UiAyAIQj+IfCICIANUrXwgAiABIAWFIgMgAVQiCiABIAaFIgUgAVQgBlAbrSIGVK19NwO4ASAMIAIgBn03A7ABIAwgBSABfSAKrX03A6gBIAwgAyABfTcDoAEgDEFAayEOIAxBoAFqIRAjAEFAaiIPJAAgDEGAAWoiC0EYaiENQcB9IQoCfwNAQQAgCkFARg0BGiAKQUBrIQogDSkDACEBIA1BCGshDSABUA0AC0EAIAF5pyAKamsLIREgEEEYaiENQcB9IQoCQAJAA0AgCkFARgRAIA9BADYCDAwCCyAKQUBrIQogDSkDACEBIA1BCGshDSABUA0ACyAPQQAgAXmnayIJIAprIg02AgwgCSAKRg0AAkAgDSARTQRAIA1BwQBPBEAjAEHwAWsiCSQAIA1BBnYgDUE/cUEAR2oiCiITIBFBBnYgEUE/cUEAR2ogCmsiDWpBBUkEQCATQQFrIgpBA00EQCAJQagBaiAQIBAgCkEDdCIRaikDAHmnIhUQ1RIgCUHYAGogCUHAAWoiGykDADcDACAJQdAAaiAJQbgBaiIcKQMANwMAIAlByABqIAlBsAFqIh0pAwA3AwAgCSAJKQOoATcDQCAJQeAAaiIQIAsgFRDVEiATQQJrIgpBBEkEQCARIAlBQGsiC2opAwAhAyAKQQN0IAtqKQMAIQUgCUGgAWpCADcDACAJQZgBakIANwMAIAlBkAFqQgA3AwAgCUIANwOIAUEFIA1rIRQgE0EBaiEXIA1BA3QgEGohESANQQZJIR4gDSEKAkACQANAAkACQCAKIhAgE2oiCkEBayISQQRNBEBCfyECIAlB4ABqIgsgCkEDdGoiGCkDACIBIANaDQIgCkECayIKQQVPDQEgCUEwaiASQQN0IAtqKQMAIgYgASADEOMqIAlBIGogCSkDMCICIAkpAzggA0IAEKgeIAYgCSkDIH0hASAKQQN0IAtqKQMAIQYDQCAJQRBqIAJCACAFQgAQqB4CQCAJKQMYIgcgAVIEQCABIAdUDQEMBQsgBiAJKQMQWg0ECyACQgF9IQIgASABIAN8IgFYDQALDAILQX9BBUG894cBEMMhAAsgCkEFQcz3hwEQwyEACyAUIBcgFCAXSRshGSATIBQgEyAUSRshGiAQQQFrIQpCACEBIAlB6AFqIhJCADcDACAJQeABaiIWQgA3AwAgCUHYAWoiH0IANwMAIAlCADcD0AFBACELA0AgCSAJQUBrIAtqKQMAQgAgAkIAEKgeIAlB0AFqIAtqIAEgCSkDACIGfCIBNwMAIAkpAwggASAGVK18IQEgC0EIaiILQSBHDQALIBsgEikDADcDACAcIBYpAwA3AwAgHSAfKQMANwMAIAkgCSkD0AE3A6gBIAkgATcDyAEgHkUNAgJAIBBBBUYNAEIAIQEgCUGoAWohEiARIQsDQCALIAspAwAiBiABIBIpAwAiB3wiAX03AwAgASAHVCABIAZWciIWrSEBIAtBCGohCyASQQhqIRIgGUEBayIZDQALIBZFDQAgAkIBfSECIBggE0EFIBBrIgsgCyATSxsEfkIAIQFBACELA0AgCyARaiISIBIpAwAiBiABIAlBQGsgC2opAwAiB3wiAXwiIDcDACABIAdUIAYgIFZyIhKtIQEgC0EIaiELIBpBAWsiGg0ACyASrQVCAAsgGCkDAHw3AwALIA1BBE8NASAJQYgBaiAQQQN0aiACNwMAIBRBAWohFCARQQhrIREgEA0ACyAOQSBqIQogCUHgAGohC0EAIRACQCAVRQRAIAogCykDADcDACAKQRhqIAtBGGopAwA3AwAgCkEQaiALQRBqKQMANwMAIApBCGogC0EIaikDADcDAAwBCyMAQSBrIg1BEGpCADcDACANQQhqQgA3AwAgDUIANwMAIBVBP3GtIQFBACAVa0E/ca0hAgNAIA0gEGogCyAQaiIRQQhqKQMAIAKGIBEpAwAgAYiENwMAIBBBCGoiEEEYRw0ACyAKIA0pAwA3AwAgCkEIaiANQQhqKQMANwMAIApBEGogDUEQaikDADcDACAKQRhqIAspAxggAYg3AwALIA5BGGogCUGgAWopAwA3AwAgDkEQaiAJQZgBaikDADcDACAOQQhqIAlBkAFqKQMANwMAIA4gCSkDiAE3AwAgCUHwAWokAAwHCyANQQRB7PeHARDDIQALIA1BBUHc94cBEK87AAsgCkEEQaz3hwEQwyEACyAKQQRBnPeHARDDIQALQfD2hwFBHEGM94cBEJ8pAAsgDyAQKQMANwMQIA9CADcDGCAPQThqIhAgC0EYaikDADcDACAPQTBqIhEgC0EQaikDADcDACAPQShqIgkgC0EIaikDADcDACAPIAspAwA3AyAgD0EYaiENIA9BEGohEyMAQSBrIgokAAJAAkAgD0EgaiIUIA9BQGsiC0cEQCANKQMAIQIgEykDACEBA0AgAVANAiAKQRBqIAtBCGsiCykDACIDIAIgARDjKiAKIAopAxAiAiAKKQMYIAFCABCoHiALIAI3AwAgDSADIAopAwB9IgI3AwAgCyAURw0ACwsgCkEgaiQADAELQfz3hwEQ4isACyAOQThqQgA3AwAgDkEwakIANwMAIA5CADcDKCAOIA8pAyA3AwAgDkEIaiAJKQMANwMAIA5BEGogESkDADcDACAOQRhqIBApAwA3AwAgDiAPKQMYNwMgDAELIA5CADcDACAOQRhqQgA3AwAgDkEQakIANwMAIA5BCGpCADcDACAOIAspAwA3AyAgDkEoaiALQQhqKQMANwMAIA5BMGogC0EQaikDADcDACAOQThqIAtBGGopAwA3AwALIA9BQGskAAwBCyAPQgA3AiwgD0KBgICAwAA3AiQgD0HY9ocBNgIgQQEgD0EMakHE9ocBIA9BIGpB4PaHARCvKwALIAxBGGogDEHYAGopAwA3AwAgDEEQaiAMQdAAaikDADcDACAMQQhqIAxByABqKQMANwMAIAxBKGogDEHoAGopAwA3AwAgDEEwaiAMQfAAaikDADcDACAMQThqIAxB+ABqKQMANwMAIAwgDCkDQDcDACAMIAwpA2A3AyAgDiAMEIMuIAwpA1ghBiAMKQNQIQUgDCkDSCEgIAwpA0AhASAOIAxBIGoQgy4gBCAIhUIAUw0BIAEhAwwCCyAAQQE6AAFBAQwCC0IAIAF9IgNCAFJCACAgIAFCAFKtfH0iIEIAUiAgUBtBf3OtQgGDIgEgBUJ/hXwiBSABVK0gBkJ/hXwhBgsgDCkDWCEHIAwpA1AhAiAMKQNIIQggDCkDQCEBAkAgBEIAWQRAIAEhBAwBC0IAIAF9IgRCAFJCACAIIAFCAFKtfH0iCEIAUiAIUBtBf3OtQgGDIgEgAkJ/hXwiAiABVK0gB0J/hXwhBwsgACACNwNAIAAgBDcDMCAAIAU3AyAgACADNwMQIAAgBzcDSCAAIAg3AzggACAGNwMoIAAgIDcDGEEACzoAACAMQcABaiQAC7wHAgV/AX4jAEGQAmsiAiQAIAEpAqgCIQcgAUKAgICAgAI3A6gCIAJBIGogAUG4AmoiAykCADcDACACQRhqIAFBsAJqIgQpAgA3AwAgA0IENwMAIARCADcDACACIAc3AxAgAkEsaiABENgYAn9BgICAgHggASgCwAIiA0GBgICAeEYNABpBgICAgHggA0GAgICAeEYNABogASkCxAIhByABQQA2AsgCIAFCgICAgCA3A8ACIAMLIQMgAUGIA2oQtDAgASAHNwKMAyABIAM2AogDIAEoAugCIgNBgICAgHhHBEAgASkC7AIhByABQQA2AvACIAFCgICAgCA3A+gCCyABQZQDahC0MCABIAc3A5gDIAEgAzYClAMgAUIANwP4AiACIAFBoANqIgQ2AjggAigCGCEDIAJByABqIAJBEGoQ3SwgAiACKQJINwKwASACQQA2AqwBIAIgAigCVCIFNgKoASACIAIoAlA2AqQBIAJBCGogAkGkAWoQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAqQBNwIIIAFBEGogAkGsAWopAgA3AgAgAUEYaiACQbQBaigCADYCACACIAU2AkQgAiAGNgJAIAIgATYCPCACAn8CQAJAAkAgBC0AAEEXaw4EAQAAAgALIAJBATYCqAEgAkHUhM0ANgKkASACQgE3ArABIAJBrwM2AkwgAiACQcgAajYCrAEgAiACQThqNgJIIAJBpAFqQdyEzQAQ7ywACyACQQA7AfwBIAJBADYC+AEgAkEANgLgASACQQA2AtQBIAIgAzYC0AEgAkEXOgDEASACQgQ3ArwBIAJCADcCtAEgAkKAgICAwAA3AqwBIAJBADYCpAEgAkHIAGoiAyACQaQBaiIBIAJBPGoQ+iMgAkGIAmogAkEkaigCADYCACACIAIpAhw3A4ACIAEgAyACQYACahCYJCADIAEgAkEsahCuFiABIAMQzRwgAQwBCyACQQA7AfwBIAJBADYC+AEgAkEANgLgASACQQA2AtQBIAIgAzYC0AEgAkEaOgDEASACQgQ3ArwBIAJCADcCtAEgAkKAgICAwAA3AqwBIAJBADYCpAEgAkHIAGoiAyACQaQBaiIBIAJBPGoQ+iMgAkGIAmogAkEkaigCADYCACACIAIpAhw3A4ACIAEgAyACQYACahCYJCADIAEgAkEsahCuFiABIAMQzRwgAQsQoAEgACACKQMANwIEIABBCDYCACACQZACaiQADwtBBEEcEKM9AAuJCwMGfwd8An4jAEFAaiICJAACQAJAAkACQAJAIAEtACkiA0EHTUEAQQEgA3RBxgFxG0UEQCACQShqQcsAQQBBAUEBEKAYIAIoAiwhASACKAIoQQFGDQEgAigCMCIEQdS5zwBBywD8CgAAIABBywA2AgwgACAENgIIIAAgATYCBCAAQQA2AgAMBQsgAUEgaiEEIAEoAiAiBUEATA0BIAFBJGohBiABKAIkIgdBAEgNAgJAAkACQAJAIAUgB08EQCADQQFrDgcCAQgICAgECAsgAkEDNgIsIAJB+LjPADYCKCACQgI3AjQgAkGcAzYCHCACIAQ2AhggAkGcAzYCFCACIAY2AhAgAiACQRBqNgIwIABBBGogAkEoahCZDiAAQQA2AgAMCAsgBUESSw0BDAYLIAVBCU0NBSACQQE2AiwgAkHIts8ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEKcYIABBADYCAAwGCyACQQE2AiwgAkGEt88ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEKcYIABBADYCAAwFCyABKAIcIQMgAkECNgIsIAJBqLfPADYCKCACQgE3AjQgAkGcAzYCCCACIAFBHGoiBjYCBCACIAJBBGo2AjAgAkEQakEEciACQShqEJkOIAJBADYCECADQYCAgIABakGAgICAAk8EQCAAIAIpAxg3AwggAEEQaiACQSBqKQMANwMAIAAgAigCFDYCBCAAQQA2AgAMBQsCfAJAAkACf0QAAAAAAAAAQCADQQN0QQFrEN4gRAAAAAAAAPC/oCIIvSIPQoCAgICAgIAIWQRAIA9C//////////f/AFYNA0GBeCEBIA9CIIgiEEKAgMD/A1IEQCAQpwwCC0GAgMD/AyAPpw0BGkQAAAAAAAAAAAwEC0QAAAAAAADwvyAIIAiioyAIRAAAAAAAAAAAYQ0DGiAPQgBTDQFBy3chASAIRAAAAAAAAFBDor0iD0IgiKcLIQMgASADQeK+JWoiAUEUdmq3IgtEAGCfUBNE0z+iIgwgD0L/////D4MgAUH//z9xQZ7Bmv8Daq1CIIaEv0QAAAAAAADwv6AiCCAIIAhEAAAAAAAA4D+ioiIJob1CgICAgHCDvyIKRAAAIBV7y9s/oiINoCIOIA0gDCAOoaAgCCAKoSAJoSAIIAhEAAAAAAAAAECgoyIIIAkgCCAIoiIJIAmiIgggCCAIRJ/GeNAJmsM/okSveI4dxXHMP6CiRAT6l5mZmdk/oKIgCSAIIAggCEREUj7fEvHCP6JE3gPLlmRGxz+gokRZkyKUJEnSP6CiRJNVVVVVVeU/oKKgoKKgIghEAAAgFXvL2z+iIAtENivxEfP+WT2iIAggCqBE1a2ayjiUuz2ioKCgoAwCCyAIIAihRAAAAAAAAAAAoyEICyAICyEIIAJBEGoiARDwGyACIAic/AIiAzYCDCADIAVODQMgAkEDNgIUIAJBpLjPADYCECACQgM3AhwgAkGcAzYCPCACQZwDNgI0IAIgBDYCMCACQZwDNgIsIAIgBjYCKCACIAJBKGo2AhggAiACQQxqNgI4IABBBGogARCnGCAAQQA2AgAMBAsgASACKAIwQeSjzwAQ/S8ACyACQQE2AiwgAkHMuc8ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEJkOIABBADYCAAwCCyACQQE2AiwgAkGouc8ANgIoIAJCATcCNCACQZwDNgIUIAIgBjYCECACIAJBEGo2AjAgAEEEaiACQShqEJkOIABBADYCAAwBCyAAQQg2AgALIAJBQGskAAuVBwIJfwF+IwBBkAJrIgIkACACQRhqIAEQ3DsgAiACKAIcIgM2AiACQAJAAkACQCADQQFGBEAgAkEQaiABEO88IAIgAigCFCIDNgIkIANBAUcNASABLQAYQSJHDQIgAiABQRxqNgIoIAJB+AFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBzOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxC4EyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlQcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGChIgQNgIAIAJCgoSIkKDAgIECNwPwASACIAJB8AFqIgQ2AiwgAiABKAIcIgM2AjAgBCADEMMIRQ0DIAQQwAwgAkEIaiABEO88IAIoAgwEQCAEIAIoAggiA0EYahDSBiADKAIoIQYgAygCJCEHIAJBgAJqIAMQvhUgAkE0aiADQQxqEIALIAMoAiwiBARAIAQgBCgCACIFQQFqNgIAIAVBAEgNBiADKAJAIQUgAygCPCEIIAMoAjghCSADKAI0IQogAygCMCEDCyACQbABaiACQfgBaigCADYCACACQZgBaiACQYgCaigCADYCACACQaQBaiACQTxqKAIANgIAIAIgAikC8AE3A6gBIAIgBjYCuAEgAiAHNgK0ASACIAIpAoACNwOQASACIAIpAjQ3ApwBIAIgBTYC0AEgAiAINgLMASACIAk2AsgBIAIgCjYCxAEgAiADNgLAASACIAQ2ArwBIAIgAkGQAWoiBBCgASACKQMAIQsgACABQRhqENIGIAJBNGoiAyABQcQA/AoAACAEIAMQoRsgAyAEQdjphAEQjBggAkEANgKIAiACQoCAgIDAADcCgAIgBCADIAJBgAJqEPwiIAMgBBDNHCAAQQxqIAMQthMgAEEAOgBEIAAgCzcCPCACQZACaiQADwtBAEEAQdjqhAEQwyEACyACQgA3ApwBIAJCgYCAgMAANwKUASACQcjshAE2ApABQQAgAkEgakH86YQBIAJBkAFqQdDshAEQrysACyACQgA3ApwBIAJCgYCAgMAANwKUASACQfDrhAE2ApABQQAgAkEkakH86YQBIAJBkAFqQfjrhAEQrysACyACQQA2AqABIAJBATYClAEgAkGY64QBNgKQASACQgQ3ApgBIAJBkAFqQaDrhAEQ7ywACyACQYgCakGChIgQNgIAIAJCgoSIkKDAgIECNwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5UHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBh46cODYCACACQoeOnLjw4MGDBzcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEHk6YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEKoTIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBh46cODYCACACQoeOnLjw4MGDBzcDgAIgAkICNwKcASACQQI2ApQBIAJBuOqEATYCkAEgAkHFEzYCQCACQa0DNgI4IAIgAkE0ajYCmAEgAiACQShqNgI8IAIgAkGAAmo2AjQgAkEsaiACQTBqIAJBkAFqQcjqhAEQoysLAAuVBwIJfwF+IwBBkAJrIgIkACACQRhqIAEQ3DsgAiACKAIcIgM2AiACQAJAAkACQCADQQFGBEAgAkEQaiABEO88IAIgAigCFCIDNgIkIANBAUcNASABLQAYQSJHDQIgAiABQRxqNgIoIAJB+AFqQYWKlCg2AgAgAkKFipSo0KDBggU3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBwOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxCxEyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYWKlCg2AgAgAkKFipSo0KDBggU3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlwcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGJkqTIADYCACACQomSpMiQocKECTcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEG06YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEK4TIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlQcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPwASACIAJB8AFqIgQ2AiwgAiABKAIcIgM2AjAgBCADEMMIRQ0DIAQQwAwgAkEIaiABEO88IAIoAgwEQCAEIAIoAggiA0EYahDSBiADKAIoIQYgAygCJCEHIAJBgAJqIAMQvhUgAkE0aiADQQxqEIALIAMoAiwiBARAIAQgBCgCACIFQQFqNgIAIAVBAEgNBiADKAJAIQUgAygCPCEIIAMoAjghCSADKAI0IQogAygCMCEDCyACQbABaiACQfgBaigCADYCACACQZgBaiACQYgCaigCADYCACACQaQBaiACQTxqKAIANgIAIAIgAikC8AE3A6gBIAIgBjYCuAEgAiAHNgK0ASACIAIpAoACNwOQASACIAIpAjQ3ApwBIAIgBTYC0AEgAiAINgLMASACIAk2AsgBIAIgCjYCxAEgAiADNgLAASACIAQ2ArwBIAIgAkGQAWoiBBCgASACKQMAIQsgACABQRhqENIGIAJBNGoiAyABQcQA/AoAACAEIAMQoRsgAyAEQZzphAEQjBggAkEANgKIAiACQoCAgIDAADcCgAIgBCADIAJBgAJqEPwiIAMgBBDNHCAAQQxqIAMQrRMgAEEAOgBEIAAgCzcCPCACQZACaiQADwtBAEEAQdjqhAEQwyEACyACQgA3ApwBIAJCgYCAgMAANwKUASACQcjshAE2ApABQQAgAkEgakH86YQBIAJBkAFqQdDshAEQrysACyACQgA3ApwBIAJCgYCAgMAANwKUASACQfDrhAE2ApABQQAgAkEkakH86YQBIAJBkAFqQfjrhAEQrysACyACQQA2AqABIAJBATYClAEgAkGY64QBNgKQASACQgQ3ApgBIAJBkAFqQaDrhAEQ7ywACyACQYgCakGEiJAgNgIAIAJChIiQoMCAgYIENwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5cHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBqOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxC5EyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYiQoMAANgIAIAJCiJCgwICBgoQINwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5UHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEHw6YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEL0TIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBg4aMGDYCACACQoOGjJiw4MCBAzcDgAIgAkICNwKcASACQQI2ApQBIAJBuOqEATYCkAEgAkHFEzYCQCACQa0DNgI4IAIgAkE0ajYCmAEgAiACQShqNgI8IAIgAkGAAmo2AjQgAkEsaiACQTBqIAJBkAFqQcjqhAEQoysLAAumDAIJfwR+IwBBkAFrIgIkACACQcgAaiEEIwBBQGoiAyQAIAEpAwghDCABKAIEIQggA0EANgIEQQQhBSAIrSELIAEoAgAhCiABAn4CQCAIQv////8PIAwgDEL/////D1obp2siB0EAIAcgCE0bQQRPBEAgAyAKIAwgCyALIAxWG6dqKAAAIgc2AgQMAQtBACEHQbi4zAApAgAiDaciBUEIdiEJIA1CIIinIQYgCyANQv8Bg0IEUg0BGgsgDEIEfAsiDDcDCAJAAkACQAJAAkAgBUH/AXEiBUEERwRAAn8CQAJAIAVBAWsOAwABBAULIAkMAQsgBi0ACAtB/wFxQSVHDQIgBEKTgICACDcCAAwFCyADQQRqQfzPzAAQiDsEQEEEIQUCQAJAIAggDCALIAsgDFYbpyIGa0EETwRAIAMgBiAKaigAACIHNgIEQgAhDQwBC0G4uMwAKQIAIg5CCIghDSAOpyEFIA5C/wGDQgRSDQELIAxCBHwhCwsgASALNwMIIAVB/wFxQQRHDQQLIAMgBzYCCCAHRQRAIARCk4CAgAg3AgAMBQsgB0EASARAIANBATYCJCADQZzQzAA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgA0EIajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGEgICAeDYCAAwFCyAEIAc2AgggBEKTgICAGDcCAAwECyAGLQAIQSVGDQELIAMgBjYCJCADIAlBCHQgBXI2AiAgBCADQSBqEJAfDAILIARCk4CAgAg3AgAgBigCACEEIAYoAgQiBSgCACIHBEAgBCAHEQMACyAFKAIEIgcEQCAEIAcgBSgCCBD4OgsgBkEMQQQQ+DoMAQsgAyAFrUL/AYMgDUIIhoQ3AyAgBCADQSBqEJAfCyADQUBrJAAgAigCUCEDIAIoAkwhBAJAIAIoAkgiBkGTgICAeEcEQCAAIAIpAlQ3AhAgACADNgIMIAAgBDYCCCAAIAY2AgQgAEEBNgIADAELAkACQAJAIARBAXEEQAJAIAFBEGoiBCgCCCIGIANPBEAgBCADNgIIDAELIAQgAyAGaxCMHAsgAkHIAGoiAyABIAEoAhQgASgCGBCfGQJAIAItAEhBBEYNACACKQNIIgtC/wGDQgRRDQAgAiALNwNIIABBBGogAxCQHyAAQQE2AgAMBQsgAkEQaiIDIAEoAhQgASgCGBC3ASACKAIQQYqAgIB4RwRAIAJByABqIgEgA0Ek/AoAACACQfTPzAA2AnAgAkIBNwJ8IAJBmwM2AowBIAIgAkGIAWo2AnggAiABNgKIASACQQE2AnQgAkE4aiACQfAAahCZDgJAAn8CQAJAAkACQAJAAkACQEEBIAIoAkgiAUGAgICAeHMgAUEAThsOBwABAgMEBQYICyACQdgAahCGMCACQcwAagwGCyACQdQAahCGMCACQeAAahCGMCACQcgAagwFCyACQcwAagwECyACQcwAagwDCyACQdgAahCGMCACQcwAagwCCyACQcwAagwBCyACQcwAagsiARDVJiABEOA7CyACKQI4IQsgACACKQJANwIQIAAgCzcCCCAAQoGAgIDAgICAgH83AgAMBQsgAigCHCIDQQRqIQYgA0F7Sw0BIAYgAigCGCIESw0CIAJBEGoiBSACKAIUIgYgBCADIAMgBmooAABrEPY0IAVBChDMIEH//wNxIgUEfyADIAVqIgUgBEsNBCAFIAZqKAAABUEACyEHIAJByABqIgUgBxDSHyACQQhqIAUQhj0gAkEQaiIHIAEgAigCCCACKAIMEJ8ZAkAgAi0AEEEERg0AIAIpAxAiC0L/AYNCBFENACACIAs3AxAgAEEEaiAHEJAfIABBATYCACAFEM8vDAULIAAgAikCSDcCECAAIAM2AgwgACAENgIIIAAgBjYCBCAAQQA2AgAgAEEYaiACQdAAaikCADcCAAwECyAAQQA2AgAgAEEANgIQDAMLIAMgBkHQzMwAELE7AAsgBiAEQdDMzAAQsDsACyAFIARBjMnMABCvOwALIAJBkAFqJAALoQYBC38jAEEwayIHJAACQCADQRFJBEAgAiEJIAAoAgggACgCGGtBA3QgACgCHCIGayIEIAIgA2xPDQEgAwRAIAQgA24hCQwCC0GYt84AEOIrAAtByLbOAEEwQYi3zgAQnykAC0EAIQQCQAJAAkACQAJAAkACQCAGRSAJRXINACABIQUDQCAHQRBqIAAgAxCRDSAHLwEQQQFxRQ0DIAIgBEYNAiAFIAcvARI7AQAgBEEBaiIEIAlPDQEgBUECaiEFIAAoAhwNAAsLIAkgBGsiCkEQSQRAIAQhBgwGCyADQQF0IQwgACgCCCINIAAoAhgiBWshCCABIARBAXRqIQsgACgCBCEOA0AgBEFvSw0DIARBEGoiBiACSw0EIAUgDUsNBSAFIA5qIAggCyADEMgQIAAgBSAMaiIFNgIYIAggDGshCCALQSBqIQsgBiEEIApBEGsiCkEPSw0ACwwFCyACIAJBmLrOABDDIQALQfy4zgBBGkGIus4AEMskAAsgBCAEQRBqQYy4zgAQsTsACyAEQRBqIAJBjLjOABCwOwALIAUgDUGcuM4AEK87AAsCQCAKQQdNIANBCEtyDQAgB0IANwMYIAAoAggiBSAAKAIYIgRPBEAgACgCBCAEaiAFIARrIAdBGGogAxC0FiAAIAMgBGo2AhggByAHKQMYNwIoIAEgBkEBdGohBSAGIAYgAiACIAZJGyIKayELIAdBCDYCJCAHQShqIQxBACEEAkADQCAHIARBAWoiCDYCICAEIAxqLQAAIQ0gBCALakUNASAFIA07AQAgBUECaiEFIAgiBEEIRw0ACyAEIAZqIQYMAgsgCiACQbi5zgAQwyEACyAEIAVB7LjOABCvOwALAkACQCAGIAlJBEAgCSAGayEIIAEgBkEBdGohBSAGIAIgAiAGSRsiASAGayEEA0AgB0EIaiAAIAMQkQ0gBy8BCEEBcUUNAyAERQ0CIAUgBy8BCjsBACAEQQFrIQQgBUECaiEFIAhBAWsiCA0ACwsgB0EwaiQAIAkPCyABIAJBqLnOABDDIQALQfy4zgBBGkGYuc4AEMskAAu1BgIMfwJ+IwBB0ABrIgMkACADIAI2AhwgASgCDCEIIAMgA0EcajYCIAJAAkAgCCAIQQFqIgJNBEACQCABKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAJJBEACfyAEQQFqIgQgAiACIARJGyICQQ9PBEAgAkH/////AUsNBUF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwshAiADQUBrIAFBEGoiBUEMQQggAhCdFCADKAJEIQQgAygCQCIGRQRAIAMoAkghAgwFCyADKQJIIQ8gBEEJaiICBEAgBkH/ASAC/AsACyADIA9CIIg+AjwgAyAPpyIKNgI4IAMgBDYCNCADIAY2AjAgA0KMgICAgAE3AiggAyAFNgIkIANBMGohCyADIAgEfyAGQQhqIQwgASgCACIJKQMAQn+FQoCBgoSIkKDAgH+DIQ9BACECA0AgD1AEQANAIAJBCGohAiAJQQhqIgkpAwBCgIGChIiQoMCAf4MiD0KAgYKEiJCgwIB/UQ0ACyAPQoCBgoSIkKDAgH+FIQ8LIAYgBCADKAIcIAEoAgAgD3qnQQN2IAJqIg1BdGxqQQxrEOwMpyIOcSIFaikAAEKAgYKEiJCgwIB/gyIQUARAQQghBwNAIAUgB2ohBSAHQQhqIQcgBiAEIAVxIgVqKQAAQoCBgoSIkKDAgH+DIhBQDQALCyAPQgF9IA+DIQ8gBiAQeqdBA3YgBWogBHEiBWosAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhBQsgBSAGaiAOQRl2Igc6AAAgDCAFQQhrIARxaiAHOgAAIAYgBUF/c0EMbGoiBSABKAIAIA1Bf3NBDGxqIgcpAAA3AAAgBUEIaiAHQQhqKAAANgAAIAhBAWsiCA0ACyABKAIMBUEACyICNgI8IAMgCiACazYCOCABIAtBBBD6KiADQSRqENAmDAELIAEgA0EgakGUpM8AQQwQxQkLQYGAgIB4IQQMAgsQ4ycgAygCDCECIAMoAgghBAwBCxDjJyADKAIUIQIgAygCECEECyAAIAI2AgQgACAENgIAIANB0ABqJAALtQYCDH8CfiMAQdAAayIDJAAgAyACNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiICTQRAAkAgASgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiACSQRAAn8gBEEBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIQIgA0FAayABQRBqIgVBDEEIIAIQnRQgAygCRCEEIAMoAkAiBkUEQCADKAJIIQIMBQsgAykCSCEPIARBCWoiAgRAIAZB/wEgAvwLAAsgAyAPQiCIPgI8IAMgD6ciCjYCOCADIAQ2AjQgAyAGNgIwIANCjICAgIABNwIoIAMgBTYCJCADQTBqIQsgAyAIBH8gBkEIaiEMIAEoAgAiCSkDAEJ/hUKAgYKEiJCgwIB/gyEPQQAhAgNAIA9QBEADQCACQQhqIQIgCUEIaiIJKQMAQoCBgoSIkKDAgH+DIg9CgIGChIiQoMCAf1ENAAsgD0KAgYKEiJCgwIB/hSEPCyAGIAQgAygCHCABKAIAIA96p0EDdiACaiINQXRsakEMaxDsDKciDnEiBWopAABCgIGChIiQoMCAf4MiEFAEQEEIIQcDQCAFIAdqIQUgB0EIaiEHIAYgBCAFcSIFaikAAEKAgYKEiJCgwIB/gyIQUA0ACwsgD0IBfSAPgyEPIAYgEHqnQQN2IAVqIARxIgVqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQULIAUgBmogDkEZdiIHOgAAIAwgBUEIayAEcWogBzoAACAGIAVBf3NBDGxqIgUgASgCACANQX9zQQxsaiIHKQAANwAAIAVBCGogB0EIaigAADYAACAIQQFrIggNAAsgASgCDAVBAAsiAjYCPCADIAogAms2AjggASALQQQQ+iogA0EkahDQJgwBCyABIANBIGpBjKXPAEEMEMUJC0GBgICAeCEEDAILEOMnIAMoAgwhAiADKAIIIQQMAQsQ4ycgAygCFCECIAMoAhAhBAsgACACNgIEIAAgBDYCACADQdAAaiQAC7UGAgx/An4jAEHQAGsiAyQAIAMgAjYCHCABKAIMIQggAyADQRxqNgIgAkACQCAIIAhBAWoiAk0EQAJAIAEoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgAkkEQAJ/IARBAWoiBCACIAIgBEkbIgJBD08EQCACQf////8BSw0FQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCyECIANBQGsgAUEQaiIFQQxBCCACEJ0UIAMoAkQhBCADKAJAIgZFBEAgAygCSCECDAULIAMpAkghDyAEQQlqIgIEQCAGQf8BIAL8CwALIAMgD0IgiD4CPCADIA+nIgo2AjggAyAENgI0IAMgBjYCMCADQoyAgICAATcCKCADIAU2AiQgA0EwaiELIAMgCAR/IAZBCGohDCABKAIAIgkpAwBCf4VCgIGChIiQoMCAf4MhD0EAIQIDQCAPUARAA0AgAkEIaiECIAlBCGoiCSkDAEKAgYKEiJCgwIB/gyIPQoCBgoSIkKDAgH9RDQALIA9CgIGChIiQoMCAf4UhDwsgBiAEIAMoAhwgASgCACAPeqdBA3YgAmoiDUF0bGpBDGsQ7AynIg5xIgVqKQAAQoCBgoSIkKDAgH+DIhBQBEBBCCEHA0AgBSAHaiEFIAdBCGohByAGIAQgBXEiBWopAABCgIGChIiQoMCAf4MiEFANAAsLIA9CAX0gD4MhDyAGIBB6p0EDdiAFaiAEcSIFaiwAAEEATgRAIAYpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIAZqIA5BGXYiBzoAACAMIAVBCGsgBHFqIAc6AAAgBiAFQX9zQQxsaiIFIAEoAgAgDUF/c0EMbGoiBykAADcAACAFQQhqIAdBCGooAAA2AAAgCEEBayIIDQALIAEoAgwFQQALIgI2AjwgAyAKIAJrNgI4IAEgC0EEEPoqIANBJGoQ0CYMAQsgASADQSBqQZymzwBBDBDFCQtBgYCAgHghBAwCCxDjJyADKAIMIQIgAygCCCEEDAELEOMnIAMoAhQhAiADKAIQIQQLIAAgAjYCBCAAIAQ2AgAgA0HQAGokAAu1BgIMfwJ+IwBB0ABrIgMkACADIAI2AhwgASgCDCEIIAMgA0EcajYCIAJAAkAgCCAIQQFqIgJNBEACQCABKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAJJBEACfyAEQQFqIgQgAiACIARJGyICQQ9PBEAgAkH/////AUsNBUF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwshAiADQUBrIAFBEGoiBUEMQQggAhCdFCADKAJEIQQgAygCQCIGRQRAIAMoAkghAgwFCyADKQJIIQ8gBEEJaiICBEAgBkH/ASAC/AsACyADIA9CIIg+AjwgAyAPpyIKNgI4IAMgBDYCNCADIAY2AjAgA0KMgICAgAE3AiggAyAFNgIkIANBMGohCyADIAgEfyAGQQhqIQwgASgCACIJKQMAQn+FQoCBgoSIkKDAgH+DIQ9BACECA0AgD1AEQANAIAJBCGohAiAJQQhqIgkpAwBCgIGChIiQoMCAf4MiD0KAgYKEiJCgwIB/UQ0ACyAPQoCBgoSIkKDAgH+FIQ8LIAYgBCADKAIcIAEoAgAgD3qnQQN2IAJqIg1BdGxqQQxrEOwMpyIOcSIFaikAAEKAgYKEiJCgwIB/gyIQUARAQQghBwNAIAUgB2ohBSAHQQhqIQcgBiAEIAVxIgVqKQAAQoCBgoSIkKDAgH+DIhBQDQALCyAPQgF9IA+DIQ8gBiAQeqdBA3YgBWogBHEiBWosAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhBQsgBSAGaiAOQRl2Igc6AAAgDCAFQQhrIARxaiAHOgAAIAYgBUF/c0EMbGoiBSABKAIAIA1Bf3NBDGxqIgcpAAA3AAAgBUEIaiAHQQhqKAAANgAAIAhBAWsiCA0ACyABKAIMBUEACyICNgI8IAMgCiACazYCOCABIAtBBBD6KiADQSRqENAmDAELIAEgA0EgakGEps8AQQwQxQkLQYGAgIB4IQQMAgsQ4ycgAygCDCECIAMoAgghBAwBCxDjJyADKAIUIQIgAygCECEECyAAIAI2AgQgACAENgIAIANB0ABqJAALtQYCDH8CfiMAQdAAayIDJAAgAyACNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiICTQRAAkAgASgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiACSQRAAn8gBEEBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIQIgA0FAayABQRBqIgVBDEEIIAIQnRQgAygCRCEEIAMoAkAiBkUEQCADKAJIIQIMBQsgAykCSCEPIARBCWoiAgRAIAZB/wEgAvwLAAsgAyAPQiCIPgI8IAMgD6ciCjYCOCADIAQ2AjQgAyAGNgIwIANCjICAgIABNwIoIAMgBTYCJCADQTBqIQsgAyAIBH8gBkEIaiEMIAEoAgAiCSkDAEJ/hUKAgYKEiJCgwIB/gyEPQQAhAgNAIA9QBEADQCACQQhqIQIgCUEIaiIJKQMAQoCBgoSIkKDAgH+DIg9CgIGChIiQoMCAf1ENAAsgD0KAgYKEiJCgwIB/hSEPCyAGIAQgAygCHCABKAIAIA96p0EDdiACaiINQXRsakEMaxDsDKciDnEiBWopAABCgIGChIiQoMCAf4MiEFAEQEEIIQcDQCAFIAdqIQUgB0EIaiEHIAYgBCAFcSIFaikAAEKAgYKEiJCgwIB/gyIQUA0ACwsgD0IBfSAPgyEPIAYgEHqnQQN2IAVqIARxIgVqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQULIAUgBmogDkEZdiIHOgAAIAwgBUEIayAEcWogBzoAACAGIAVBf3NBDGxqIgUgASgCACANQX9zQQxsaiIHKQAANwAAIAVBCGogB0EIaigAADYAACAIQQFrIggNAAsgASgCDAVBAAsiAjYCPCADIAogAms2AjggASALQQQQ+iogA0EkahDQJgwBCyABIANBIGpBzKbPAEEMEMUJC0GBgICAeCEEDAILEOMnIAMoAgwhAiADKAIIIQQMAQsQ4ycgAygCFCECIAMoAhAhBAsgACACNgIEIAAgBDYCACADQdAAaiQAC7UGAgx/An4jAEHQAGsiAyQAIAMgAjYCHCABKAIMIQggAyADQRxqNgIgAkACQCAIIAhBAWoiAk0EQAJAIAEoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgAkkEQAJ/IARBAWoiBCACIAIgBEkbIgJBD08EQCACQf////8BSw0FQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCyECIANBQGsgAUEQaiIFQQxBCCACEJ0UIAMoAkQhBCADKAJAIgZFBEAgAygCSCECDAULIAMpAkghDyAEQQlqIgIEQCAGQf8BIAL8CwALIAMgD0IgiD4CPCADIA+nIgo2AjggAyAENgI0IAMgBjYCMCADQoyAgICAATcCKCADIAU2AiQgA0EwaiELIAMgCAR/IAZBCGohDCABKAIAIgkpAwBCf4VCgIGChIiQoMCAf4MhD0EAIQIDQCAPUARAA0AgAkEIaiECIAlBCGoiCSkDAEKAgYKEiJCgwIB/gyIPQoCBgoSIkKDAgH9RDQALIA9CgIGChIiQoMCAf4UhDwsgBiAEIAMoAhwgASgCACAPeqdBA3YgAmoiDUF0bGpBDGsQ7AynIg5xIgVqKQAAQoCBgoSIkKDAgH+DIhBQBEBBCCEHA0AgBSAHaiEFIAdBCGohByAGIAQgBXEiBWopAABCgIGChIiQoMCAf4MiEFANAAsLIA9CAX0gD4MhDyAGIBB6p0EDdiAFaiAEcSIFaiwAAEEATgRAIAYpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIAZqIA5BGXYiBzoAACAMIAVBCGsgBHFqIAc6AAAgBiAFQX9zQQxsaiIFIAEoAgAgDUF/c0EMbGoiBykAADcAACAFQQhqIAdBCGooAAA2AAAgCEEBayIIDQALIAEoAgwFQQALIgI2AjwgAyAKIAJrNgI4IAEgC0EEEPoqIANBJGoQ0CYMAQsgASADQSBqQdSlzwBBDBDFCQtBgYCAgHghBAwCCxDjJyADKAIMIQIgAygCCCEEDAELEOMnIAMoAhQhAiADKAIQIQQLIAAgAjYCBCAAIAQ2AgAgA0HQAGokAAvJBgEHfyMAQfAAayIFJAAgBUHMAGogASAEEN0QIAUoAlQhCSAFKAJQIQQCQCAFKAJMIgZBioCAgHhHBEAgACAFKQJYNwIMIABBHGogBUHoAGopAgA3AgAgAEEUaiAFQeAAaikCADcCACAAIAk2AgggACAENgIEIAAgBjYCAAwBCwJAAkAgBEEBcQRAIAVBzABqIAEoAgAiByAJEJMOIAUoAlAhBCAFKAJMIgZBioCAgHhHBEAgBUHIAGogBUHsAGooAgA2AgAgBUFAayAFQeQAaikCADcCACAFQThqIAVB3ABqKQIANwIAIAUgBSkCVDcCMCAFIAQ2AiwgBSAGNgIoDAMLIAVBzABqIAdBfyAEIAlqIgYgBCAGSxsQoRAgBSgCVCEEIAUoAlAhBiAFKAJMIghBioCAgHhHBEAgBUHEAGogBUHoAGopAgA3AgAgBUE8aiAFQeAAaikCADcCACAFIAUpAlg3AjQgBSAENgIwIAUgBjYCLCAFIAg2AigMAwsgBygCACEIIAcoAgQiCyAESwRAIAQgCGotAABFIQoLAkAgBCAGTwRAIAQgC0sNASAFQcwAaiAGIAhqIAQgBmsQnQkgBSgCTEEBRgRAIAVBxABqIQcgBUFAayEIIAUgBSkCUDcCOCAFQgQ3AjAgBUKCgICACDcCKAwECyAKIAcoAggtAAxyQQFxRQRAIAVBPGohByAFQThqIQggBUIENwIwIAVCg4CAgAg3AigMBAsgBUGKgICAeDYCKAwECyAGIARBjOX+ABCxOwALIAQgC0GM5f4AELA7AAsgAEGKgICAeDYCACAAIAEpAgA3AgQgAEEMaiABQQhqKQIANwIADAILIAcgBDYCACAIIAY2AgALIAUgAzYCXCAFIAI2AlggBUGAgICAeDYCVCAFIAk2AlAgBUEBNgJMIABBBGohAiAFQQRqIAVBKGogBUHMAGoQgRQCQCAFKAIEIgNBioCAgHhHBEAgAiAFKQIINwIAIAJBGGogBUEgaikCADcCACACQRBqIAVBGGopAgA3AgAgAkEIaiAFQRBqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgAzYCAAsgBUHwAGokAAvJBgEHfyMAQfAAayIFJAAgBUHMAGogASAEEN0QIAUoAlQhCSAFKAJQIQQCQCAFKAJMIgZBioCAgHhHBEAgACAFKQJYNwIMIABBHGogBUHoAGopAgA3AgAgAEEUaiAFQeAAaikCADcCACAAIAk2AgggACAENgIEIAAgBjYCAAwBCwJAAkAgBEEBcQRAIAVBzABqIAEoAgAiByAJEJQOIAUoAlAhBCAFKAJMIgZBioCAgHhHBEAgBUHIAGogBUHsAGooAgA2AgAgBUFAayAFQeQAaikCADcCACAFQThqIAVB3ABqKQIANwIAIAUgBSkCVDcCMCAFIAQ2AiwgBSAGNgIoDAMLIAVBzABqIAdBfyAEIAlqIgYgBCAGSxsQoRAgBSgCVCEEIAUoAlAhBiAFKAJMIghBioCAgHhHBEAgBUHEAGogBUHoAGopAgA3AgAgBUE8aiAFQeAAaikCADcCACAFIAUpAlg3AjQgBSAENgIwIAUgBjYCLCAFIAg2AigMAwsgBygCACEIIAcoAgQiCyAESwRAIAQgCGotAABFIQoLAkAgBCAGTwRAIAQgC0sNASAFQcwAaiAGIAhqIAQgBmsQnQkgBSgCTEEBRgRAIAVBxABqIQcgBUFAayEIIAUgBSkCUDcCOCAFQgQ3AjAgBUKCgICACDcCKAwECyAKIAcoAggtAAxyQQFxRQRAIAVBPGohByAFQThqIQggBUIENwIwIAVCg4CAgAg3AigMBAsgBUGKgICAeDYCKAwECyAGIARB0Pb+ABCxOwALIAQgC0HQ9v4AELA7AAsgAEGKgICAeDYCACAAIAEpAgA3AgQgAEEMaiABQQhqKQIANwIADAILIAcgBDYCACAIIAY2AgALIAUgAzYCXCAFIAI2AlggBUGAgICAeDYCVCAFIAk2AlAgBUEBNgJMIABBBGohAiAFQQRqIAVBKGogBUHMAGoQgRQCQCAFKAIEIgNBioCAgHhHBEAgAiAFKQIINwIAIAJBGGogBUEgaikCADcCACACQRBqIAVBGGopAgA3AgAgAkEIaiAFQRBqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgAzYCAAsgBUHwAGokAAu8BQEGfyMAQdAOayIGJAAgBkEIaiIIQQBBiAj8CwAgBkGQCGoiB0EAQcAF/AsAIAZB0A1qIglBAEGAAfwLACAAQYABQcAAQQ8gCEGBASABQYABEOsIIABBgAJqQcAAQcAAQQ4gCEGBASABQUBrIgBBwAAQ6wggB0EYIAFBGGoiCEEYQeiI0gAQ1SwgBkGoCGpBCCABQQhB6IjSABDVLCAGQbAIakEIIAFBMGoiCkEIQeiI0gAQ1SwgBkG4CGpBCCABQQhqQQhB6IjSABDVLCAGQcAIakEIIAFBOGoiC0EIQeiI0gAQ1SwgBkHICGpBCCABQRBqQQhB6IjSABDVLCAHQcAFQcAAIAlBwAAQswsgAiAGKQGADjcBACACIAYpAaAONwEQIAJBCGogBkGIDmopAQA3AQAgAkEYaiAGQagOaikBADcBACACIAYpAcAONwEgIAJBKGogBkHIDmopAQA3AQAgAkEwaiAJQeAA/AoAACACQegAaiAGQZgOaikBADcBACACIAYpAZAONwFgIAIgBikBsA43AXAgAkH4AGogBkG4DmopAQA3AQAgAEHAAEHAACACQYABakHAABCzC0EAIQIgB0EAQcAA/AsAIAdBCCAIQQhB6IjSABDVLCAGQdAIakEIIAFBIGpBCEHoiNIAENUsIAZBkAlqQQggAUEoakEIQeiI0gAQ1SwgBkHQCWpBCCAKQQhB6IjSABDVLCAGQZALakEIIAtBCEHoiNIAENUsA0AgBkGQCGoiCCACaiIHQYABaiABLQAAOgAAIAdBgAJqIAFBCGotAAA6AAAgB0HAA2ogAUEQai0AADoAACABQQFqIQEgAkEIaiICQcAARw0ACyAIQcAFQcAFIAZBCGoiAUGBASADIAQgBRDhByAAQcAAQcAAIAFBgQEgAyAEIAUQ4QcgBkHQDmokAAuHBgEIfyABKAIAQQJ0QQRqIQogA0UEQCAKBEAgAEEAIAr8CwALIAFBADYCAEEADwsgBUEAQYAg/AsAIAVBgBhqIQggBUGAEGohCSAFQYAIaiELIAIgA2oiDEEPayENIAIoAAAhAwN/IA0gAkEEaiIHTQR/A38gAiAMTwR/QQAhA0EAIQgDfyADQYAIRgR/IAVB/AdqIQJBgAIhAwNAIANBAWshAyACKAIAIAJBBGshAkUNAAsCfyAEBEBBUCADIAEoAgBLDQEaCyABIAM2AgAgCgRAIAAgBSAK/AoAAAsgCAsFIAMgBWoiAiACKAIAIAJBgBhqKAIAIAJBgBBqKAIAIAJBgAhqKAIAampqIgI2AgAgAiAIIAIgCEsbIQggA0EEaiEDDAELCwUgBSACLQAAQQJ0aiIDIAMoAgBBAWo2AgAgAkEBaiECDAELCwUgBygAACEHIAUgA0H/AXFBAnRqIgYgBigCAEEBajYCACALIANBBnZB/AdxaiIGIAYoAgBBAWo2AgAgCSADQQ52QfwHcWoiBiAGKAIAQQFqNgIAIAggA0EWdkH8B3FqIgMgAygCAEEBajYCACACQQhqKAAAIQMgBSAHQf8BcUECdGoiBiAGKAIAQQFqNgIAIAsgB0EGdkH8B3FqIgYgBigCAEEBajYCACAJIAdBDnZB/AdxaiIGIAYoAgBBAWo2AgAgCCAHQRZ2QfwHcWoiByAHKAIAQQFqNgIAIAJBDGooAAAhByAFIANB/wFxQQJ0aiIGIAYoAgBBAWo2AgAgCyADQQZ2QfwHcWoiBiAGKAIAQQFqNgIAIAkgA0EOdkH8B3FqIgYgBigCAEEBajYCACAIIANBFnZB/AdxaiIDIAMoAgBBAWo2AgAgAkEQaiICKAAAIQMgBSAHQf8BcUECdGoiBiAGKAIAQQFqNgIAIAsgB0EGdkH8B3FqIgYgBigCAEEBajYCACAJIAdBDnZB/AdxaiIGIAYoAgBBAWo2AgAgCCAHQRZ2QfwHcWoiByAHKAIAQQFqNgIADAELCwuYBgENfyMAQdAAayICJAAgAiABKAIYIgU2AgQgAkE4aiABKAIgIAEoAiQiBCgCCEEBa0F4cWpBCGogBCgCOBEAAAJAAkACQAJAAkAgAigCOCILRQRAIABBADYCAAwBCyACQRxqIAJBzABqKAIANgIAIAJBFGogAkHEAGopAgA3AgAgAiACKQI8NwIMIAIgCzYCCEHAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAJCADcCLCACIAQ2AiggAiADNgIkIAJBwAA2AiAgASgCECIMIAEoAhRBeHFqIQ4gASgCHCENQQAhBEEAIQFBACEDA0AgASEIIAZBAWshBiAMIQECQANAIAEgDkYNASAGQQFqIQYgASgCACEJIAFBCGoiDCEBIAkgDUkNAAsgBiACKAIYTw0FIAUgCSANayIJIAUgCUkbIQEgAigCDCACKAIUIAZqIgpBA3ZqLQAAIApBB3F2QQFxRQRAIAMgCEkEQCACQSBqIAggA2sQ6BAgAigCMCEHIAIoAiwhBAsgBCAHIAEgCGtqIgdBA3YgB0EHcUEAR2oiA0kEQCADIARrIQggAigCJCIKIANJBEAgAkEgaiAKQQF0IgQgA0HA////A3FBQGsgAyADQT9xGyIKIAQgCksbEOgZIAIoAiwhBAsgCARAIAIoAiggBGpBACAI/AsACyACIAM2AiwgAyEECyACIAc2AjAgASEDCyAGQQFqIQYgBSAJSw0BCwsgAyAFSQRAIAJBIGogBSADaxDoECACKAIwIQcLIAIgBzYCNCAFIAdHDQQgAkE4aiIBIAJBIGoiBBCIFCAAIAEQ4ScgBBDPLyALIAsoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAGokAA8LQfT0hAFBKSACQThqQdD2hAFBoPWEARDVHgALQcAAIAMQoz0AC0HE9IQBQSBB5PSEARCfKQALIAJBADYCOEEAIAJBNGogAkEEaiACQThqQYz7hAEQrysAC5gGAQ1/IwBB0ABrIgIkACACIAEoAhgiBTYCBCACQThqIAEoAiAgASgCJCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAI4IgtFBEAgAEEANgIADAELIAJBHGogAkHMAGooAgA2AgAgAkEUaiACQcQAaikCADcCACACIAIpAjw3AgwgAiALNgIIQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQEgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIsIAIgBDYCKCACIAM2AiQgAkHAADYCICABKAIQIgwgASgCFEF8cWohDiABKAIcIQ1BACEEQQAhAUEAIQMDQCABIQggBkEBayEGIAwhAQJAA0AgASAORg0BIAZBAWohBiABKAIAIQkgAUEEaiIMIQEgCSANSQ0ACyAGIAIoAhhPDQUgBSAJIA1rIgkgBSAJSRshASACKAIMIAIoAhQgBmoiCkEDdmotAAAgCkEHcXZBAXFFBEAgAyAISQRAIAJBIGogCCADaxDoECACKAIwIQcgAigCLCEECyAEIAcgASAIa2oiB0EDdiAHQQdxQQBHaiIDSQRAIAMgBGshCCACKAIkIgogA0kEQCACQSBqIApBAXQiBCADQcD///8DcUFAayADIANBP3EbIgogBCAKSxsQ6BkgAigCLCEECyAIBEAgAigCKCAEakEAIAj8CwALIAIgAzYCLCADIQQLIAIgBzYCMCABIQMLIAZBAWohBiAFIAlLDQELCyADIAVJBEAgAkEgaiAFIANrEOgQIAIoAjAhBwsgAiAHNgI0IAUgB0cNBCACQThqIgEgAkEgaiIEEIgUIAAgARDhJyAEEM8vIAsgCygCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdAAaiQADwtB9PSEAUEpIAJBOGpB0PaEAUGg9YQBENUeAAtBwAAgAxCjPQALQcT0hAFBIEHk9IQBEJ8pAAsgAkEANgI4QQAgAkE0aiACQQRqIAJBOGpBjPuEARCvKwALmAYBDX8jAEHQAGsiAiQAIAIgASgCGCIFNgIEIAJBOGogASgCICABKAIkIgQoAghBAWtBeHFqQQhqIAQoAjgRAAACQAJAAkACQAJAIAIoAjgiC0UEQCAAQQA2AgAMAQsgAkEcaiACQcwAaigCADYCACACQRRqIAJBxABqKQIANwIAIAIgAikCPDcCDCACIAs2AghBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNASADBEAgA0HAABCtNiIERQ0DCyACQgA3AiwgAiAENgIoIAIgAzYCJCACQcAANgIgIAEoAhAiDCABKAIUQX5xaiEOIAEoAhwhDUEAIQRBACEBQQAhAwNAIAEhCCAGQQFrIQYgDCEBAkADQCABIA5GDQEgBkEBaiEGIAEuAQAhCSABQQJqIgwhASAJIA1JDQALIAYgAigCGE8NBSAFIAkgDWsiCSAFIAlJGyEBIAIoAgwgAigCFCAGaiIKQQN2ai0AACAKQQdxdkEBcUUEQCADIAhJBEAgAkEgaiAIIANrEOgQIAIoAjAhByACKAIsIQQLIAQgByABIAhraiIHQQN2IAdBB3FBAEdqIgNJBEAgAyAEayEIIAIoAiQiCiADSQRAIAJBIGogCkEBdCIEIANBwP///wNxQUBrIAMgA0E/cRsiCiAEIApLGxDoGSACKAIsIQQLIAgEQCACKAIoIARqQQAgCPwLAAsgAiADNgIsIAMhBAsgAiAHNgIwIAEhAwsgBkEBaiEGIAUgCUsNAQsLIAMgBUkEQCACQSBqIAUgA2sQ6BAgAigCMCEHCyACIAc2AjQgBSAHRw0EIAJBOGoiASACQSBqIgQQiBQgACABEOEnIAQQzy8gCyALKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0ABqJAAPC0H09IQBQSkgAkE4akHQ9oQBQaD1hAEQ1R4AC0HAACADEKM9AAtBxPSEAUEgQeT0hAEQnykACyACQQA2AjhBACACQTRqIAJBBGogAkE4akGM+4QBEK8rAAv6BgIKfxF+IwBBoAFrIgIkACABKAK8AiIEIAQoAgAiA0EBajYCACADQQBOBEAgAkEIaiABQYACahDWHgJAIAEoAowCQYCAgIB4RwRAIAJBFGogAUGMAmoQ3SAMAQsgAkGAgICAeDYCFAsgASgCAEEBRgRAIAEpAwghEkIBIQ0LIAEoAhBBAUYEQCABKQMYIRNCASEMCyABKQP4ASEUIAEpA/ABIRUgASkD6AEhFiABKALUASEDIAEoAtABIQUgASkD4AEhFyABKQPYASEYAkAgASkDYEIIUgRAIAJBIGogAUHgAGoQoAQMAQsgAkIINwMgCwJAIAEoApgCQYCAgIB4RwRAIAJB/ABqIAFBmAJqELUWDAELIAJBgICAgHg2AnwLIAEoAiBBAUYEQCABKQMoIRlCASEPCyABKAIwQQFGBEAgASkDOCEaQgEhDgsgASgCQEEBRgRAIAEpA0ghG0IBIRELIAEoAlBBAUYEQCABKQNYIRxCASEQCyABKAK8ASEGIAEoArgBIQcgASgCxAEhCCABKALAASEJIAEoAswBIQogASgCyAEhCwJAIAEoAqQCQYCAgIB4RwRAIAJBiAFqIAFBpAJqEKUdDAELIAJBgICAgHg2AogBCwJAIAEoArACQYCAgIB4RwRAIAJBlAFqIAFBsAJqEKUdDAELIAJBgICAgHg2ApQBCyAAIAQ2ArwCIAAgAikCCDcCgAIgACACKQIUNwKMAiAAIBc3A+ABIAAgGDcD2AEgACAUNwP4ASAAIBU3A/ABIAAgFjcD6AEgACADNgLUASAAIAU2AtABIAAgEzcDGCAAIAw3AxAgACASNwMIIAAgDTcDACAAQYgCaiACQRBqKAIANgIAIABBlAJqIAJBHGooAgA2AgAgAEHgAGogAkEgakHYAPwKAAAgACAGNgK8ASAAIAc2ArgBIAAgGTcDKCAAIA83AyAgACAINgLEASAAIAk2AsABIAAgGjcDOCAAIA43AzAgACAKNgLMASAAIAs2AsgBIAAgGzcDSCAAIBE3A0AgACAcNwNYIAAgEDcDUCAAQaACaiACQYQBaigCADYCACAAIAIpAnw3ApgCIAAgAikCiAE3AqQCIABBrAJqIAJBkAFqKAIANgIAIABBuAJqIAJBnAFqKAIANgIAIAAgAikClAE3ArACIAJBoAFqJAAPCwALhwYCDn8CfiMAQSBrIg8kAAJAAkACQCAEIAdxIhAgA00EQCALKAIIIQwgACgCLCEYIAIgEGoiFSADIBBrIhYQth4hEiAMIBBqIg4gA08NASACIA5qLQAAIQ4gCykDACEaIAtBADYCDCAHIAYoAgAiEWsiBiAHTw0DAkAgAyAEIAZxIgYgDGoiDUsEQCAOIAIgDWotAABGDQEMBQsgDSADQdTLzgAQwyEACyADIAZJDQIgAiAGaiADIAZrIBUgFiAIEPQBIg1FDQMgDSAGIAUQoS4iDCAYEPI0IRogCyARNgIQIAsgDDYCCCALIBo3AwAgAyAMIBBqIgZLBEAgAiAGai0AACEOQQEhFwwECyAGIANB9MvOABDDIQALIBAgA0Gky84AEK87AAsgDiADQbTLzgAQwyEACyAGIANB5MvOABCvOwALAkACQAJAAkAgEiAAKAIEIg1NBEAgDSASayIGQQNNDQEgACgCACASQQJ0aiEZQQAhEQJAAkADQCARQRBHBEAgESAZaigCACITIARxIgYgDGoiFCADTw0CIBFBBGohESAHIBNrIhNBAWsgCU8NASAOIAIgFGotAABHDQEgAyAGSQ0HIAIgBmogAyAGayAVIBYgCBD0ASIURQ0BIBogFCAGIAUQoS4iBiATIBgQjC0iG1oNASALIBM2AhAgCyAGNgIIIAsgGzcDACAGIBBqIgwgA08NAyACIAxqLQAAIQ5BASEXIBshGiAGIQwMAQsLIBcgAUVyRQ0EIBcgAUEAR3IhBgwGCyAUIANB9MzOABDDIQALIAwgA0GUzc4AEMMhAAsgD0EANgIYIA9BATYCDCAPQZjXzgA2AgggD0IENwIQIA9BCGpBxMzOABDvLAALQQQgBkHUzM4AELA7AAsgASAAIBUgFiAIIAkgCiALEOkUIQYgACgCBCENDAELIAYgA0GEzc4AEK87AAsgDSASIAdBA3ZBA3FqIgFNBEAgASANQeTMzgAQwyEACyAAKAIAIAFBAnRqIAc2AgAgD0EgaiQAIAZBAXEL3AUCDH8DfiMAQaABayIJJAAgCUEAQaAB/AsAAkACQAJAIAIgACgCoAEiBU0EQCAFQSlPDQEgASACQQJ0aiEMAkACQCAFBEAgBUEBaiENIAVBAnQhCgNAIAkgBkECdGohAwNAIAYhAiADIQQgASAMRg0IIANBBGohAyACQQFqIQYgASgCACEHIAFBBGoiCyEBIAdFDQALIAetIRFCACEPIAohByACIQEgACEDA0AgAUEoTw0EIAQgDyAENQIAfCADNQIAIBF+fCIQPgIAIBBCIIghDyAEQQRqIQQgAUEBaiEBIANBBGohAyAHQQRrIgcNAAsgCCAQQoCAgIAQWgR/IAIgBWoiAUEoTw0DIAkgAUECdGogDz4CACANBSAFCyACaiIBIAEgCEkbIQggCyEBDAALAAsDQCABIAxGDQYgBEEBaiEEIAEoAgAgAUEEaiEBRQ0AIAggBEEBayICIAIgCEkbIQgMAAsACyABQShBkIyKARDDIQALIAFBKEGQjIoBEMMhAAsgBUEpTw0BIAJBAnQhDCACQQFqIQ0gACAFQQJ0aiEOIAAhAwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdBAWohByADKAIAIQogA0EEaiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIgBCAPIAQ1AgB8IAY1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsiCg0ACwJAIAggEEKAgICAEFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIAhJGyEIIAUhAwwBCwsgA0EoQZCMigEQwyEACyADQShBkIyKARDDIQALIAVBKEGQjIoBELA7AAsgBUEoQZCMigEQsDsACyAAIAlBoAH8CgAAIAAgCDYCoAEgCUGgAWokAAuWDQIKfwJ+IwBBkAFrIgIkAAJAIAFFBEAgAEICNwMADAELIAEgASgCAEECdCIDQeCkzgBqKAIAaigCACEEIAEgA0GApc4AaigCAGopAwAhDCABIANBoKTOAGooAgBqKAIAIQcgASADQcCkzgBqKAIAaikDACENQYCAgIB4IQkgAkGAgICAeDYCPCACQYCAgIB4NgIwIAJBggQ7AWAgAkGAgICAeDYCVCACQYCAgIB4NgJIIAIgDTcDKCACIAcgDUIAWXGtNwMgIAIgDDcDGCACIAQgDEIAWXGtNwMQIwBBEGsiAyQAIAJBCGoiBAJ/AkACQAJAAkACQAJAAkACQCABKAIAQQFrDgcBAgMEBQYHAAtBASEFIAFBLGpBACABLQAsQQJHGwwHC0EEIQUgAUEsakEAIAEoAigbDAYLQQghBSABQRBqQQAgASgCCBsMBQtBDCEFIAFBLGpBACABKAIoGwwEC0EEIQUgAUEsakEAIAEoAigbDAMLQQghBSABQRBqQQAgASgCCBsMAgsgAyABQQhqEO4nIAMoAgQhBSADKAIADAELIANBCGogAUEIahDuJyADKAIMIQUgAygCCAs2AgAgBCAFNgIEIANBEGokAAJAAkACQAJAAkAgAigCCCIGRQRAQYCAgIB4IQoMAQsgAkGEAWogAigCDCIHQQBBAUEBEKAYIAIoAogBIQogAigChAFBAUYNASACKAKMASEIIAdFDQAgCCAGIAf8CgAACyMAQRBrIgQkACACAn8CQAJAAkACQAJAAkACQAJAIAEoAgBBAWsOBwECAwQFBgcAC0EBIQMgAUEtakEAIAEtAC1BAkcbDAcLQQQhAyABQTRqQQAgASgCMBsMBgtBCCEDIAFBIGpBACABKAIYGwwFC0EMIQMgAUE8akEAIAEoAjgbDAQLQQQhAyABQTRqQQAgASgCMBsMAwtBCCEDIAFBIGpBACABKAIYGwwCCyAEIAFBCGoQ7ycgBCgCBCEDIAQoAgAMAQsgBEEIaiABQQhqEO8nIAQoAgwhAyAEKAIICzYCACACIAM2AgQgBEEQaiQAAkAgAigCACIERQ0AIAJBhAFqIAIoAgQiBkEAQQFBARCgGCACKAKIASEJIAIoAoQBQQFGDQIgAigCjAEhCyAGRQ0AIAsgBCAG/AoAAAsCfwJAAkACQAJAAkACQAJAAkACQAJAIAEoAgBBAWsOBwECAwQFBgcACyABLQApIAEtACxBAkdxDAkLIAEoAiggAS0AOXEMCAsgASgCCCABLQBJcQwHCyABKAIoIAEtAElxDAYLIAEoAiggAS0AOXEMBQsgASgCCCABLQBJcQwECyABKAIoDQEMAgsgASgCKEUNAQsgAS0AUQwBC0EAC0EBcSEFAn8CQAJAAkACQAJAAkACQAJAAkACQCABKAIAQQFrDgcBAgMEBQYHAAsgAS0AKCABLQAtQQJHcQwJCyABKAIwIAEtADhxDAgLIAEoAhggAS0ASHEMBwsgASgCOCABLQBIcQwGCyABKAIwIAEtADhxDAULIAEoAhggAS0ASHEMBAsgASgCPA0BDAILIAEoAjxFDQELIAEtAFAMAQtBAAtBAXEhAyACIAc2AnQgAiAINgJwIAIgCjYCbCACIAY2AoABIAIgCzYCfCACIAk2AnggASABKAIAQQJ0QYCkzgBqKAIAai0AAEUNA0GAgICAeCEHIApBgICAgHhHBEAgAkGEAWogAkHsAGoQ5x4gAigChAEhByACKQKIASEMCyACQTBqIQggAkE8ahCGMCACIAw3A0AgAiAHNgI8IAlBgICAgHhHIgQgAigCMEGAgICAeEdxDQJBgICAgHghBiAEBEAgAkGEAWogAkH4AGoQ5x4gAigChAEhBiACKQKIASEMCyAIEIYwIAIgDDcCNCACIAY2AjAMAwsgCiACKAKMAUGch84AEP0vAAsgCSACKAKMAUGch84AEP0vAAsgAkEANgI4IAggCyAGIAtqEL0mCyABIAEoAgBBAnRB4KPOAGooAgBqLQAARQRAIAJB1ABqIgEQhjAgAUEIaiACQfQAaigCADYCACABIAIpAmw3AgAgAkHIAGoiARCGMCABQQhqIAJBgAFqKAIANgIAIAEgAikCeDcCACACIAU6AGEgAiADOgBgIAAgAkEQakHYAPwKAAAMAQsgAiADOgBgIAIgBToAYSAAIAJBEGpB2AD8CgAAIAJB+ABqEIYwIAJB7ABqEIYwCyACQZABaiQAC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC4CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC5CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC6CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC7CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC8CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC9CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC4IGAg1/Bn4jAEEwayIDJABBwAAhCgJAAkAgAUEGdiIEIAFBP3EiCEEAR2oiBUEDdCIGQcD///8DcUFAayAGIAVBB3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIKRQ0CCyABQcAASQ0CIAStIRQgAigCCCENIAIoAgAhBiACKAIEIg+tIRUDQCASQgF8IRIgBiEEIAkhBUIAIRBCACERA0ACQCAVIBAgE3xWBEAgBCgCACIOIA0oAggiDEkNASAOIAxB+PWDARDDIQALIAUgD0Ho9YMBEMMhAAsgBEEEaiEMIARBCGohBCAFQQFqIQUgDSgCBCAOQQJ0aigCACAMKAIAEI87rSAQhiARhCERIBBCAXwiEELAAFINAAsgByAKaiARNwMAIBNCQH0hEyAGQYAEaiEGIAlBQGshCSAHQQhqIQcgEiAUUg0ACwwCC0Hw9IMBQSkgA0EcakGs9YMBQZz1gwEQ1R4AC0HAACALEKM9AAsgCARAIAIoAgQiBiABQUBxIgVrIgRBACAEIAZNG60hEiACKAIAIAFBA3RBgHxxaiEEIAitIRMgAigCCCECQgAhEEIAIREDQAJAIBAgElIEQCAEKAIAIgkgAigCCCIISQ0BIAkgCEH49YMBEMMhAAsgBSAGQej1gwEQwyEACyAEQQRqIQggBEEIaiEEIAVBAWohBSACKAIEIAlBAnRqKAIAIAgoAgAQjzutIBCGIBGEIREgEEIBfCIQIBNSDQALIAcgCmogETcAACAHQQhqIQcLIAMgCzYCLCADQoCAgICACDcCJCADIAo2AhwgAyABQQN2IAFBB3FBAEdqIgIgByACIAdJGyIENgIgIANBCGogA0EcahDXOyADKAIIIQVBHEEEEK02IgIEQCACQoGAgIAQNwIAIAIgAykCHDcCCCACQRBqIANBJGopAgA3AgAgAkEYaiADQSxqKAIANgIAIAMgBDYCGCADIAU2AhQgAyACNgIQIAAgA0EQakEAIAEQ8hUgA0EwaiQADwtBBEEcEKM9AAuCBgINfwZ+IwBBMGsiAyQAQcAAIQoCQAJAIAFBBnYiBCABQT9xIghBAEdqIgVBA3QiBkHA////A3FBQGsgBiAFQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiCkUNAgsgAUHAAEkNAiAErSEUIAIoAgghDSACKAIAIQYgAigCBCIPrSEVA0AgEkIBfCESIAYhBCAJIQVCACEQQgAhEQNAAkAgFSAQIBN8VgRAIAQoAgAiDiANKAIIIgxJDQEgDiAMQfj1gwEQwyEACyAFIA9B6PWDARDDIQALIARBBGohDCAEQQhqIQQgBUEBaiEFIA0oAgQgDkECdGooAgAgDCgCABCLO60gEIYgEYQhESAQQgF8IhBCwABSDQALIAcgCmogETcDACATQkB9IRMgBkGABGohBiAJQUBrIQkgB0EIaiEHIBIgFFINAAsMAgtB8PSDAUEpIANBHGpBrPWDAUGc9YMBENUeAAtBwAAgCxCjPQALIAgEQCACKAIEIgYgAUFAcSIFayIEQQAgBCAGTRutIRIgAigCACABQQN0QYB8cWohBCAIrSETIAIoAgghAkIAIRBCACERA0ACQCAQIBJSBEAgBCgCACIJIAIoAggiCEkNASAJIAhB+PWDARDDIQALIAUgBkHo9YMBEMMhAAsgBEEEaiEIIARBCGohBCAFQQFqIQUgAigCBCAJQQJ0aigCACAIKAIAEIs7rSAQhiARhCERIBBCAXwiECATUg0ACyAHIApqIBE3AAAgB0EIaiEHCyADIAs2AiwgA0KAgICAgAg3AiQgAyAKNgIcIAMgAUEDdiABQQdxQQBHaiICIAcgAiAHSRsiBDYCICADQQhqIANBHGoQ1zsgAygCCCEFQRxBBBCtNiICBEAgAkKBgICAEDcCACACIAMpAhw3AgggAkEQaiADQSRqKQIANwIAIAJBGGogA0EsaigCADYCACADIAQ2AhggAyAFNgIUIAMgAjYCECAAIANBEGpBACABEPIVIANBMGokAA8LQQRBHBCjPQALggYCDX8GfiMAQTBrIgMkAEHAACEKAkACQCABQQZ2IgQgAUE/cSIIQQBHaiIFQQN0IgZBwP///wNxQUBrIAYgBUEHcRsiC0HAABDRNARAIAsEQCALQcAAEK02IgpFDQILIAFBwABJDQIgBK0hFCACKAIIIQ0gAigCACEGIAIoAgQiD60hFQNAIBJCAXwhEiAGIQQgCSEFQgAhEEIAIREDQAJAIBUgECATfFYEQCAEKAIAIg4gDSgCCCIMSQ0BIA4gDEH49YMBEMMhAAsgBSAPQej1gwEQwyEACyAEQQRqIQwgBEEIaiEEIAVBAWohBSANKAIEIA5BAnRqKAIAIAwoAgAQlTutIBCGIBGEIREgEEIBfCIQQsAAUg0ACyAHIApqIBE3AwAgE0JAfSETIAZBgARqIQYgCUFAayEJIAdBCGohByASIBRSDQALDAILQfD0gwFBKSADQRxqQaz1gwFBnPWDARDVHgALQcAAIAsQoz0ACyAIBEAgAigCBCIGIAFBQHEiBWsiBEEAIAQgBk0brSESIAIoAgAgAUEDdEGAfHFqIQQgCK0hEyACKAIIIQJCACEQQgAhEQNAAkAgECASUgRAIAQoAgAiCSACKAIIIghJDQEgCSAIQfj1gwEQwyEACyAFIAZB6PWDARDDIQALIARBBGohCCAEQQhqIQQgBUEBaiEFIAIoAgQgCUECdGooAgAgCCgCABCVO60gEIYgEYQhESAQQgF8IhAgE1INAAsgByAKaiARNwAAIAdBCGohBwsgAyALNgIsIANCgICAgIAINwIkIAMgCjYCHCADIAFBA3YgAUEHcUEAR2oiAiAHIAIgB0kbIgQ2AiAgA0EIaiADQRxqENc7IAMoAgghBUEcQQQQrTYiAgRAIAJCgYCAgBA3AgAgAiADKQIcNwIIIAJBEGogA0EkaikCADcCACACQRhqIANBLGooAgA2AgAgAyAENgIYIAMgBTYCFCADIAI2AhAgACADQRBqQQAgARDyFSADQTBqJAAPC0EEQRwQoz0AC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDBCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDCCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDDCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDECEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDFCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDGCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDHCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDICEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDJCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDKCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDLCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDMCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEL8jIQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQsB9FDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDNCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEL8jIQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQsB9FDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC88GAgx/AX4jAEGQAWsiAiQAIAEoAgQhBiABKAIAIQwgAiABKAIIIgQ2AmQgAkHoAGogBEEHakEDdhDSH0HAACEFAkACQCAEQQR0IgtBwP///wdxQUBrIAsgBEEDcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAIoAnAhCSAFIQEgBEUNAiAEQRhsIQogBiEDA0AgAykDACIOQgJRDQMCQCAOp0EBcQRAIANBCGopAwAhDiABQQhqIANBEGopAwA3AwAgASAONwMAIAkgB0EDdmoiDSANLQAAQQEgB0EHcXRyOgAADAELIAFCADcDACABQQhqQgA3AwALIANBGGohAyAHQQFqIQcgAUEQaiEBIApBGGsiCg0ACwwCC0H89v8AQSkgAkH4AGpB+Pr/AEGo9/8AENUeAAtBwAAgCBCjPQALIAIgBjYCfCACIAw2AnggAkH4AGoiAxD1OyACIAEgBWtBBHUiATYCWAJAAkAgASAERgRAIAIoAnQhBiACIAIpAmg3AoQBIAJBADYCgAEgAiAGNgJ8IAIgCTYCeCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogAkGAAWoiCSkCADcCACABQRhqIAJBiAFqIgooAgA2AgAgAiAINgKIASACQoCAgICACDcCgAEgAiALNgJ8IAIgBTYCeCACIAMQ1zsgAigCACEFQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyACKQJ4NwIIIANBEGogCSkCADcCACADQRhqIAooAgA2AgAgAiAGNgJgIAIgBzYCXCACIAE2AlhBDEEEEK02IgFFDQIgASALNgIIIAEgBTYCBCABIAM2AgAgAkEBNgJwIAIgATYCbCACQQE2AmggAkEANgKAASACQoCAgIDAADcCeCACQRRqIgNB0PL/ACAEIAEgAkHYAGogAkHoAGogAkH4AGoQjBMgACADEL4TIAJBkAFqJAAPCyACQgA3AoQBIAJCgYCAgMAANwJ8IAJBlPL/ADYCeEEAIAJB2ABqIAJB5ABqIAJB+ABqQZzy/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC8sGAgl/An4jAEGQAWsiAyQAIAMgAiABa0EwbiIGNgJkIANB6ABqIAZBB2pBA3YQ0h9BwAAhBQJAAkAgBkEFdCIKQUBxQUBrIAogBkEBcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAnAhCSAFIQQgASACRg0CA0ACQCABKAIAQQFxBEAgAUEgaikDACEMIAQgAUEQaikDADcDACABQShqKQMAIQ0gBCABQRhqKQMANwMIIARBEGogDDcDACAEQRhqIA03AwAgCSAHQQN2aiILIAstAABBASAHQQdxdHI6AAAMAQsgBEIANwMAIARBGGpCADcDACAEQRBqQgA3AwAgBEEIakIANwMACyAHQQFqIQcgBEEgaiEEIAFBMGoiASACRw0ACwwCC0HklIABQSkgA0H4AGpByJeAAUGQlYABENUeAAtBwAAgCBCjPQALIAMgBCAFa0EFdSIBNgJYAkACQCABIAZGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAJNgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQdBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIJKQIANwIAIAFBGGogA0GIAWoiCygCADYCACADIAg2AogBIANCgICAgIAINwKAASADIAo2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAJKQIANwIAIAJBGGogCygCADYCACADIAQ2AmAgAyAHNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAo2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkHokYABIAYgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQxRMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQAL4wUCBX8EfiMAQRBrIgUkAAJ/IARFBEAgAEIINwMgIABCADcDACAAQgA3AyhBEAwBCwJAAn8CQCACIAQgA0EHcSIHaiIIQQN2IAhBB3FBAEdqIgYgA0EDdiIDaiIJTwRAIAEgA2ohA0J/IAethiELAkACQCAGQQlPBEAgBkERSQ0BIAYgA0EHakF4cSIBIANrIghrIglBA3YhBkEAIQIgByABIANHcg0CQgAhCwwECyAFQgA3AwggBgRAIAVBCGogAyAG/AoAAAsgBSkDCCEMIABBwAAgCEE/cSIBa0EAIAEbNgIsIAAgBzYCKCAAQgg3AyAgAEIBNwMAIAAgDEJ/IAGthkJ/hUJ/IAEbgyALgzcDCEEQDAYLIAMpAAAhCiAFQgA3AwggBkEIayIBBEAgBUEIaiADQQhqIAH8CgAACyAFKQMIIABBwAAgCEE/cSIBa0EAIAEbNgIsIAAgBzYCKCAAQgg3AyAgACAKIAuDNwMIIABCATcDACAAQgE3AxBCfyABrYZCf4VCfyABG4MhCgwECyABIANHBEAgBUIANwMIIAgEQCAFQQhqIAMgCPwKAAALIAUpAwggC4NBwAAgCEEDdGsiAkE4ca2GIQ1CASELDAILIAZBAWshBiABKQMAIAuDIQ1CASELIAFBCGoMAgsgCSACQbz5hwEQsDsACyABCyEDAkAgAiAHaiIHIARqQT9xIgJFBEAMAQtCfyACrYZCf4UhCiAJQQdxIgQEQCAFQgA3AwggBARAIAVBCGogASAJQfj///8DcWogBPwKAAALIAUpAwggCoMhCkIBIQwMAQsgBkEBayEBIAYEQCADIAFBA3RqKQMAIAqDIQpCASEMIAEhBgwBCyABQQBBzPmHARDDIQALIABBwAAgAmtBACACGzYCLCAAIAc2AiggACAGNgIkIAAgAzYCICAAIA03AwggACALNwMAIAAgDDcDEAtBGAsgAGogCjcDACAFQRBqJAALnAYCBn0CfyMAQZAWayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgWbGoiAioChBYiCpMgACAEQYgWbGoiACoChBYiC5MhDCACKAKAFkUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoAWIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgW/AoAACARIBEoAogWIANqNgKIFkEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGAFkcNAAsgAhCgByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkBZqJAALnAYCBn0CfyMAQZAIayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgIbGoiAioChAgiCpMgACAEQYgIbGoiACoChAgiC5MhDCACKAKACEUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoAIIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgI/AoAACARIBEoAogIIANqNgKICEEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGACEcNAAsgAhChByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkAhqJAALnAYCBn0CfyMAQZARayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgRbGoiAioChBEiCpMgACAEQYgRbGoiACoChBEiC5MhDCACKAKAEUUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoARIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgR/AoAACARIBEoAogRIANqNgKIEUEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGAEUcNAAsgAhCiByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkBFqJAALwgYCAX8CfiMAQcABayIHJAAgByACOgAPAkACQAJAAkACQAJ+AkACQAJAIAJB/wFxDgkAAQUFBQUEAQIFCyAHQcgAaiADQQhqKQIANwMAIAcgAykCADcDQEICDAILIAdBuAFqIANBCGopAgA3AwAgByADKQIANwOwASAHQdAAaiAHQbABaiAEIAUgBhCZDSAHQcgAaiAHQeAAaikDADcDACAHQShqIAdB/ABqKQIANwMAIAdBMGogB0GEAWopAgA3AwAgB0E4aiAHQYwBaikCADcDACAHQRhqIAdBnAFqKAIANgIAIAcgBykDWDcDQCAHIAcpAnQ3AyAgByAHKQKUATcDECAHKQNQIQggBygCaCEDIAcpAmwhCQwFCyAHQcgAaiADQQhqKQIANwMAIAcgAykCADcDQEIFCyEIQQAhAwwDCyAHQbgBaiADQQhqKQIANwMAIAcgAykCADcDsAEgB0HQAGogB0GwAWoQsQQgBygCUA0BIAdBqAFqIAdB3ABqKQIAIgg3AwAgB0EoaiAHQfgAaikDADcDACAHQTBqIAdBgAFqKQMANwMAIAdBOGogB0GIAWopAwA3AwAgB0HIAGogCDcDACAHIAcpA3A3AyAgByAHKQJUNwNAIAcoAmQhAyAHKQNoIQlCBCEIDAILIAdBATYCVCAHQYidzQA2AlAgB0IBNwJcIAdBrgM2ArQBIAcgB0GwAWo2AlggByAHQQ9qNgKwASAAQQRqIAdB0ABqEJkOIABBADYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAdBrAFqIAdB4ABqKAIAIgE2AgAgByAHKQNYIgg3AqQBIAcoAmQhAiAHKQNoIQkgAEEIaiABNgIAIAAgCDcCACAAIAk3AxAgACACNgIMDAELIAEQgh8gASAINwMAIAEgCTcCHCABIAM2AhggASAHKQNANwMIIAFBEGogB0HIAGopAwA3AwAgASAHKQMgNwIkIAFBLGogB0EoaikDADcCACABQTRqIAdBMGopAwA3AgAgAUE8aiAHQThqKQMANwIAIAEgBykDEDcCRCABQcwAaiAHQRhqKAIANgIAIABBCDYCAAsgB0HAAWokAAuKCQEPfyMAQSBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AaEEBaw4DCQIBAAsgAEE4aiAAQTD8CgAACyAAQThqIQgCQAJAIAAtAGRBAWsOAwgCAQALIAgoAgAiAigCCA0JIAJBfzYCCCAAIAJBCGo2AkQgACACQQxqIgI2AkAgAEEAOgBgIAAgAjYCSCAAIAAoAjwiBDYCTCAAQeAAaiEGIABByABqIQoMAwsgAEHIAGohCiAAQeAAaiEGIAAtAGBBAWsOAwUAAwELAAsgACgCTCEEIAAoAkghAgsgACACNgJQIAIoAgBFDQEgACACNgJcIAAgBDYCWCAAQQE2AlQLIANBEGohCyMAQRBrIgIkAAJAAkAgAEHUAGoiBygCAEUNACMAQRBrIgQkACAEQQhqIAcoAggiCSgCACABIAkoAgQoAgwRAQBBAiEFAkACQCACQQhqIg4Cf0EAIAQoAggiD0ECRg0AGkEBIQUgD0EBcQRAIAQoAgwMAQsgBygCACAHQQA2AgBFDQEgBCAJKAIAIAcoAgQgCSgCBCgCEBEBACAEKAIAQQFxIQUgBCgCBAs2AgQgDiAFNgIAIARBEGokAAwBC0GF3MMAQRxBpNzDABDLJAALQQIhBCACKAIIIgVBAkYNAUEBIQQgBUEBcUUNACACKAIMIQwMAQsgAiAHKAIIIgQoAgAgASAEKAIEKAIUEQEAQQIhBCACKAIAIgFBAkYNACACKAIEIQwgAUEBcSEECyALIAw2AgQgCyAENgIAIAJBEGokAAJAIAMoAhAiAkECRgRAIAZBAzoAAEECIQIMAQsgAygCFCEQAkAgBygCAEUNACAAKAJYIgFBhAFJDQAgARDyHwsCQCACQQFxRQRAQQAhAgwBCyAAKAJQIgEoAgAEfyABELwqIAAoAlAFIAELQQA2AgALIAZBAToAAAtBAyEEQQMhBkECIQEgAkECRwRAIAoQhipBASEGIAAoAkQiASABKAIAQQFqNgIAIAAoAjgiASABKAIAQQFrIgE2AgAgEEGAASACQQFxGyENIAFFBEAgCBDUIgsgAiEBCyAAIAY6AGQCQCABQQJGDQAgCBDeHwJAIAFBAXEEQCADIA02AhggA0GAATYCHCADIABBNGogA0EcaiADQRhqEMIjIAMoAgBBAXENBwJAIAMoAgQiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQEgAhDyHwwBCyADIA02AhggA0GAATYCHCADQQhqIABBMGogA0EcaiADQRhqEMIjIAMoAghBAXENBgJAIAMoAgwiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQAgAhDyHwsgACgCMCICQYQBTwRAIAIQ8h8LQQEhBCAAKAI0IgJBhAFJDQAgAhDyHwsgACAEOgBoIANBIGokACABQQJGDwtB5tnDAEExEJc9AAtB+N3DABDoKwALQajewwAQ6CsAC0Ho3cMAEOgrAAtB1NvDAEExEJc9AAuWCQEOfyMAQaABayIEJAAgBCADNgIMIAQgAjYCCAJAIAEoAiQgAiADak8EQCABQRhqIQUCQCABLQAYQSBGBEAgASgCKCENIARBiAFqIAUQ2gYgBEGUAWogARC+FSABKAIUIQMgBCABKAIQIgU2AiggBCAFIANBxABsajYCLCAEIARBDGo2AjQgBCAEQQhqNgIwIwBBIGsiBSQAIAVBFGogBEEoaiIDKAIEIAMoAgBrQcQAbkEAQQRBxAAQoBggBSgCGCEGIAUoAhRBAUYEQCAGIAUoAhxByNqGARD9LwALIARB8ABqIQsgBUEQaiIOQQA2AgAgBSAFKAIcNgIMIAUgBjYCCCMAQRBrIggkACADKAIEIAMoAgBrQcQAbiIKIAVBCGoiBygCACAHKAIIIgZrSwRAIAcgBiAKQQRBxAAQ3iggBygCCCEGCyAIIAcoAgQ2AgwgCCAGNgIIIAggB0EIajYCBCMAQdAAayIKJAAgCEEEaiIJKAIEIQcgCSgCACADKAIAIgYgAygCBCIMRwRAIAMoAgwhECADKAIIIREgCSgCCCAHQcQAbGohAyAHIAwgBmtBxABuIglqIQcDQCAKQQxqIgwgBiARKAIAIBAoAgAQ1gggAyAMQcQA/AoAACAGQcQAaiEGIANBxABqIQMgCUEBayIJDQALCyAHNgIAIApB0ABqJAAgCEEQaiQAIAtBCGogDigCADYCACALIAUpAgg3AgAgBUEgaiQAAkAgASgCLARAIARBEGogAUEsaiAEKAIIIAQoAgwQsR8MAQsgBEEANgIQCyAEQcgAaiAEQZABaigCADYCACAEQTBqIARBnAFqKAIANgIAIARBPGogBEH4AGooAgA2AgAgBCAEKQKIATcDQCAEIAQpApQBNwMoIAQgBCkCcDcCNCAEKAIMIQEgACAEQShqQST8CgAAIAAgAiANajYCKCAAIAE2AiQgACAEKQIQNwIsIABBNGogBEEYaikCADcCACAAQTxqIARBIGopAgA3AgAMAQsgBEGIAWogBRDaBiABKAIoIQYgBEGUAWogARC+FSAEQfAAaiABQQxqEIALIAEoAiwiBQRAIAUgBSgCACIIQQFqNgIAIAhBAEgNAyABKAI0IQcgASgCMCELIAEoAkAhCiABKAI8IQkgASgCOCEICyAEQcgAaiAEQZABaigCADYCACAEQTBqIARBnAFqKAIANgIAIARBPGogBEH4AGooAgA2AgAgBCAEKQKIATcDQCAEIAQpApQBNwMoIAQgBCkCcDcCNCAEIAo2AmggBCAJNgJkIAQgCDYCYCAEIAc2AlwgBCALNgJYIAQgBTYCVCAEIAM2AkwgBCACIAZqNgJQIARB1ABqIQYCQCAFRQRAIARBADYCcAwBCyAEQfAAaiABQSxqIAIgAxCxHyAFIAUoAgAiAUEBazYCACABQQFHDQAgBhD7HgsgBiAEKQJwNwIAIAZBEGogBEGAAWopAgA3AgAgBkEIaiAEQfgAaikCADcCACAAIARBKGpBxAD8CgAACyAEQaABaiQADwtB3OOGAUExQZDkhgEQnykLAAvoBQEIfyMAQTBrIgQkAAJAAkACQCABIAJHBEAgASEFA0ACfyAFLAAAIgNBAE4EQCADQf8BcSEDIAVBAWoMAQsgBS0AAUE/cSEJIANBH3EhByADQV9NBEAgB0EGdCAJciEDIAVBAmoMAQsgBS0AAkE/cSAJQQZ0ciEJIANBcEkEQCAJIAdBDHRyIQMgBUEDagwBCyAHQRJ0QYCA8ABxIAUtAANBP3EgCUEGdHJyIQMgBUEEagshBUEBIQcCQAJAAkACQAJAIANBDEwEQCADQQlrQQJJDQEMAwsgA0EiSg0BIANBDUcNAgtBASEKDAILIANBPkwEQCADQSNGIANBL0ZyDQMMAQsgA0E/RiADQYCAxABGciADQdwARnINAgsgCEEBaiEIIANBgAFJDQBBAiEHIANBgBBJDQBBA0EEIANBgIAESRshBwsgBiAHaiEGIAIgBUcNAQsLIAQgAjYCICAEIAE2AhwgCkUNASAEQSxqIgVBADYCACAEQoCAgIAQNwIkIARBJGogBEEcaiAIEJYoIARBGGogBSgCADYCACAEIAQpAiQ3AxAMAgsgBCACNgIgIAQgATYCHAsgAiABayEDIAhBAWohBQNAIAVBAWsiBQRAIARBHGoQ7hJBgIDEAEcNAQsLAkAgBkUNACADIAZNBEAgAyAGRg0BDAMLIAEgBmosAABBv39MDQILIAQgBjYCGCAEIAE2AhQgBEGAgICAeDYCEAsgBEEIaiAEQRBqENw7AkACQAJAIAQoAgxBAkcNACAEKAIIIgUtAABB3wFxQcEAa0H/AXFBGUsNACAFLQABIgVBOkYgBUH8AEZyDQELIAAgBCkDEDcCACAAIAQpAhw3AhAgAEEBOgAMIABBCGogBEEYaigCADYCAAwBCyAAIAI2AhQgACABNgIQIABBADoADCAAQQA2AgggAEKAgICAGDcCACAEQRBqEIYwCyAEQTBqJAAPCyABIANBACAGQYiMxAAQozYAC+IFAQV/IwBBEGsiDSQAIA0gBDYCDAJAIAhBACAHa0EDcSIOayIPQQAgCCAPTxtBhDZJBEBBvn8hDAwBCyABRSADRXINACADQYCACEsEQEG4fyEMDAELIAVBDEsEQEFUIQwMAQsgBEH/AUsEQEFSIQwMAQsgBEUEQCANQf8BNgIMQf8BIQQLIAAgAWohDwJAIApFIAtBBHFFciIQRQRAIAooAgBBAkYNAQsgByAOakEAIAggDk8bIQ4gC0EIcUUgA0GAwAJJckUEQCANIAQ2AgggDiANQQhqIAJBgCAQmBUiB0GIf0sEQCAHIQwMAwsgDSAENgIEIA4gDUEEaiACIANqQYAga0GAIBCYFSIEQYh/SwRAIAQhDAwDCyAEIAdqQcUASQ0CCyAOIA1BDGogAiADIA5BhBBqIgdBgCAQ4CUiBEGIf0sEQCAEIQwMAgsgAyAERgRAIAAgAi0AADoAAEEBIQwMAgsgBCADQQd2QQRqTQ0BAkAgCkUNAAJAIBAgCigCACIMQQFGBH8gCSAOIA0oAgwQkyMNASAKQQA2AgBBAAUgDAtFckUNAgwBCyAQRQ0BCyAFQQsgBRsgAyANKAIMIAdBgCYgDkGACGoiBCAOIAsQ2hUhBSAEIA4gDSgCDCAFIAdBgCYQ+AEiDEGIf0sNAUH8ByANKAIMIgVBAnQiCGsiCwRAIAQgCGpBCGpBACAL/AsACyAAIAEgBCAFIAwgB0HsBRCkCSIMQYh/Sw0BAkACQAJAIAoEQAJAIAooAgBFBEAgDEEMaiEIDAELIAkgDiANKAIMIgEQ5SMgBCAOIAEQ5SMgDGpNIAxBDGoiCCADT3INBQsgAyAISw0BDAMLIAxBDGogA08NAgwBCyAKQQA2AgALIAkEQCAJIARBhAj8CgAACyAAIAAgDGogDyACIAMgBiAEENshIQwMAgtBACEMDAELIAAgACAPIAIgAyAGIAkQ2yEhDAsgDUEQaiQAIAwLwQYBDH8jAEGQAWsiAiQAIAEoAgQhByABKAIAIQsgAiABKAIIIgU2AmQgAkHoAGogBUEHakEDdhDSH0HAACEEAn8CQAJAIAVBA3QiDEHA////B3FBQGsgDCAFQQdxGyIIQcAAENE0BEAgCARAIAhBwAAQrTYiBEUNAgsgAigCcCEJIAVFBEAgBCEDQQAMBAsgBUEMbCEKIAchASAEIQMDQCABKAIAIg1BAkYNAwJAIA1BAXEEQCADIAFBBGopAgA3AgAgCSAGQQN2aiINIA0tAABBASAGQQdxdHI6AAAMAQsgA0IANwIACyABQQxqIQEgBkEBaiEGIANBCGohAyAKQQxrIgoNAAsMAgtB/Pb/AEEpIAJB+ABqQfj6/wBBqPf/ABDVHgALQcAAIAgQoz0ACyACKAJkCyEBIAIgBzYCfCACIAs2AnggAkH4AGoiBxDoOyACIAMgBGtBA3UiAzYCWAJAAkAgASADRgRAIAIoAnQhBiACIAIpAmg3AoQBIAJBADYCgAEgAiAGNgJ8IAIgCTYCeCACQQhqIAcQ1zsgAigCCCEJQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogAkGAAWoiCikCADcCACABQRhqIAJBiAFqIgsoAgA2AgAgAiAINgKIASACQoCAgICACDcCgAEgAiAMNgJ8IAIgBDYCeCACIAcQ1zsgAigCACEEQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyACKQJ4NwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgAiAGNgJgIAIgCTYCXCACIAE2AlhBDEEEEK02IgFFDQIgASAMNgIIIAEgBDYCBCABIAM2AgAgAkEBNgJwIAIgATYCbCACQQE2AmggAkEANgKAASACQoCAgIDAADcCeCACQRRqIgFBhPT/ACAFIAIgAkHYAGogAkHoAGogAkH4AGoQjBMgACABEKwTIAJBkAFqJAAPCyACQgA3AoQBIAJCgYCAgMAANwJ8IAJBlPL/ADYCeEEAIAJB2ABqIAJB5ABqIAJB+ABqQZzy/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC/kFAQV/IwBBgBVrIgkkACAJQQBBgAL8CwAgCUGAAmpBAEGABPwLACAJQYAGakEAQYAI/AsAIAlBgA5qQQBBgAH8CwAgCUGAD2pBAEGAAvwLACAJQYARakEAQYAE/AsAAkACQAJAAkACQCACBEADQCABIApGDQIgCUGABmogACAKai0AAEECdGoiCyALKAIAQQFqNgIAIAIgCkEBaiIKRw0ACwsgCUGABmpBgAIgAkEIIAlBgAIgCUGAAmpBgAIgBiAHIAgQowIgBUUNA0EAIQogAyECA0AgBCAKRg0DIAItAAAiC0GAAU8NAiAJQYARaiIMIAtBAnRqIgsgCygCAEEBajYCACACQQRqIQIgBSAKQQFqIgpHDQALIAkgCSgC0BNBAWo2AtATIAkgCSgCgBNBAWo2AoATIAkgCSgCiBFBAWo2AogRIAkgCSgChBFBAWo2AoQRIAwgCUGADmogCUGAD2ogBiAHIAgQrwhBACEMA0ACQAJAAkACQAJAIAQgDEcEQCADIAxBAnRqKAIAIgpB/wFxIgJBgAFPDQEgCUGADmogAmotAAAgCUGAD2ogAkEBdGozAQAgBiAHIAgQ3xMgAkECdCILQZiJ0gBqKAIAIApBCHYiCq0gBiAHIAgQ3xMgAkEYTw0FIAEgC0GYjdIAaigCACAKaiILSQ0DIAAhCiALIgINAgwECyAEIARBuOXOABDDIQALIAJBgAFByOXOABDDIQALA0AgCSAKLQAAIg1qLQAAIAlBgAJqIA1BAXRqMwEAIAYgByAIEN8TIApBAWohCiACQQFrIgINAAsMAQsgCyABQdjlzgAQsDsACyAAIAtqIQAgASALayEBCyAMQQFqIgwgBUcNAAsMBAsgASABQYjmzgAQwyEACyALQYABQfjlzgAQwyEACyAEIARB6OXOABDDIQALIAlBATYC0BMgCUEBNgKAEyAJQoGAgIAQNwKEESAJQYARaiAJQYAOaiAJQYAPaiAGIAcgCBCvCAsgCUGAFWokAAuABgEEfyMAQeAAayIDJAAgAEEEIAAoAjQiBSAFQQRNGzYCNCAAQTBqIQUCQCACQX9zIAAoAjAiBmtBA3EiBCAAKAIIIAZrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBSAEEI03IABBASAAKAI0IgQgBEEBTRs2AjQgACgCCBogBUEAEI03IAAoAgggACgCMEciBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwRg0ACwsgBUEBEI03IANBQGsgABDcOyADKAJEIQQgAygCQCEGIANBOGogACgCMBCMNyADQTBqIAYgBCADKAI4IAMoAjxBhIH/ABDXJgJAAkACQCADKAI0BEAgAygCMEEAOgAAAkAgACgCCCAAKAIwayACTyIEDQAgAkGAgICAeEsNAiAEDQADQCAAEPsWIAAoAgggACgCMGsgAkkNAAsLIAUgAhCNNyAAKAIwIQQgA0EoaiAAENw7IANBIGogAygCKCADKAIsIAQgBCACa0HkgP8AENcmIAMoAiQiBCACRw0CIAIEQCADKAIgIAEgAvwKAAALIANBGGogABDcOyAAQQQgACgCNCIBIAFBBE0bNgI0AkBBACAAKAIwIgRrQQNxIgEgACgCCCAEa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAUgARCNNyAAKAIIIAAoAjBrQQNLIgEgAXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAVBBBCNNyADQRBqIAAQ3DsgAygCFCEBIAMoAhAhBCADQQhqIAAoAjAQjDcgAyAEIAEgAygCCCADKAIMQYSB/wAQ1yYgAygCBEEDTQ0DIAMoAgAgAjYAACAFKAIAIANB4ABqJAAPCwwCC0GsgP8AQSVB1ID/ABCfKQALIAQgAkH0gP8AELM7AAsgA0EANgJYIANBATYCTCADQbCB/wA2AkggA0IENwJQIANByABqQZSB/wAQ7ywAC+UMAh1/AnwjAEHgAGsiCyQAIAtBAEHAAPwLAEEBIQ0CQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQCAEKAIAIgpBAUYEQCAEKAIIIgcgBCgCBCIISQ0EIAdBD0sNBSAHIAhrIRsgACAIQQR0aiEVIAUoAgAiBg0BQQghEgwCC0EIIRUgBSgCACIGQQFGDQBBCCESQQAMAgsgBSgCCCIHIAUoAgQiCEkNBCAHQQ9LDQUgByAIayEcIAAgCEEEdGohEkEAIApFDQEaIAQoAgghByAEKAIEIQgLIAcgCEkNBSAHQQ9LDQYgAEHwAWogCGohDSAHIAhrCyEdQQAhBEEBIQggBgRAIAUoAggiByAFKAIEIgVJDQcgB0EPSw0IIAcgBWshHiAAQfABaiAFaiEICyALIQcgAiEFA0AgCyAcNgJMIAsgEjYCSCALIBs2AkQgCyAVNgJAIAsgHjYCXCALIAg2AlggCyAdNgJUIAsgDTYCUCALQUBrIR8gC0HQAGohIEEAIRNBACEUIwBBIGsiCiQAIAUoAgAiDiAFKAIEIhBBAnQiEWohFiAEQf8BcSEhA0AgHyAUQQN0IgxqIgYoAgAgBigCBCEGIAogDCAgaiIMKAIAIhcgDCgCBGo2AgwgCiAXNgIIIApBCGoQgzsiDCAGIAYgDEsbIRhBEGshIkEAIQwCQANAA0AgDCAYIAwgGEsbIQkgIiAMQQR0aiEGA0AgCSAMRg0DIAwgF2ogBkEQaiEGIAxBAWohDC0AACAhRw0ACyATBEAgBigCACIJIQ8gCSAGQQRqKAIAQQJ0aiEZIwBBEGsiCSQAIAkgFjYCDCAJIA42AgggCUEIahCeNiEaIApBCGoiBkEANgIQIAYgGTYCDCAGIA82AgggBiAWNgIEIAYgDjYCACAGIBkgD2tBAnYiBiAaIAYgGkkbNgIUIAlBEGokACAKKAIcIgkgCigCGCIGTQ0BIAkgBmshDyAGQQJ0IgkgCigCCGohBiAKKAIQIAlqIQkDQCAGIAYoAgAgCSgCAGo2AgAgBkEEaiEGIAlBBGohCSAPQQFrIg8NAAsMAQsLIAZBBGooAgAiCSAQRgRAIBEEQCAOIAYoAgAgEfwKAAALQQEhEwwBCwsgECAJQZTZzgAQszsACyAUQQFqIhRBAkcNAAsCQCATBEAgBSAOIBAQ/BI5AwgMAQsgBUIANwMIIBBFIBFFcg0AIA5BACAR/AsACyAKQSBqJAAgByAFQQhqKwMAOQMAIAVBEGohBSAHQQhqIQcgBEEBaiIEQQhHDQALIAEoAgAhBSABKAIEIQcgASgCDCEEIAEoAhAjAEEQayIIJAAgCEIANwMAIARqIQ0gBSAHaiEMIAhBAXIhDgJAA0ACfyAFRSAFIAxGckUEQCAFQQFqIQEgBAwBCyAEIA1GBEBBACEEA0AgAiAEaiIBQQhqIAEoAgAgAUEEaigCABD8EjkDACAEQRBqIgRBgAFHDQALIAhBEGokAAwDC0EAIQEgBCIFQQFqCyEHQQAhBiACIQQCQANAIAUtAAAgBiAIai0AAEEIdHIiCiAEQQRqKAIAIhBPDQEgBCgCACAKQQJ0aiIKIAooAgBBAWo2AgAgBEEQaiEEIAZBAWoiBkEIRw0ACyAIQQA2AAsgCEEANgIIIAhBCGoiBEEHIAhBB0H0184AENUsIA5BByAEQQdBhNjOABDVLCAIIAUtAAA6AAAgASEFIAchBAwBCwsgCiAQQZTYzgAQwyEACyACQRhqIQUgAisDCCALKwMAoSEjIAtBCGohBEEAIQ1BASEHA0AgBSsDACAEKwMAoSIkICMgIyAkZCIBGyEjIAcgDSABGyENIAVBEGohBSAEQQhqIQQgB0EBaiIHQQhHDQALIANBD08NCCAAIANBBHRqIgQoAgQiASACIA1BBHRqIgIoAgQiBUcNCSABQQJ0IgEEQCAEKAIAIAIoAgAgAfwKAAALIAAgA2ogDToA8AEgC0HgAGokAA8LIAggB0Gk2M4AELE7AAsgB0EPQaTYzgAQsDsACyAIIAdBtNjOABCxOwALIAdBD0G02M4AELA7AAsgCCAHQcTYzgAQsTsACyAHQQ9BxNjOABCwOwALIAUgB0HU2M4AELE7AAsgB0EPQdTYzgAQsDsACyADQQ9B5NjOABDDIQALIAEgBUGE2c4AELM7AAvOBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2ApABIANBAzYCjAEgA0G85P4ANgKIASADQYCAgIB4NgKEASADQgQ3AnwgA0KEgICACDcCdAwBC0F/IAFBBGoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBBGoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYCdAwCCyADQYiAgIB4NgJ0DAELIANB9ABqIAEgBRC/LwsgA0EINgKoASADQfTm/gA2AqQBIANBgICAgHg2AqABIAMgATYCnAEgA0EBNgKYASADQdAAaiADQfQAaiADQZgBahCBFCADKAJQIgVBioCAgHhGDQEgA0GgAWogA0HsAGopAgA3AwAgAyADKQJkNwOYASADKAJYIQEgAygCVCEEIAMpAlwLIQYgA0EoaiADQaABaikDADcCACADIAY3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQOYATcCIAwBCyADKAJAIgEgASgCDEEBazYCDCADQYqAgIB4NgIMCyADQRM2AoQBIANB4+n+ADYCgAEgA0GAgICAeDYCfCADIAI2AnggA0ECNgJ0IAAgA0EMaiADQfQAahCBFCADQbABaiQAC84GAgN/AX4jAEGwAWsiAyQAIANB9ABqIAEgAhCTDiADKAJ4IQQCQCADKAJ0IgVBioCAgHhHBEAgA0EsaiADQZQBaigCADYCACADQSRqIANBjAFqKQIANwIAIANBHGogA0GEAWopAgA3AgAgAyADKQJ8NwIUIAMgBDYCECADIAU2AgwMAQsgA0H0AGogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0GAAWopAgA3AwAgAyADKQJ4NwMwIAMoAnQiBEGKgICAeEcEQCADQShqIANBkAFqKQIANwIAIANBGGogASkDADcCACADIAMpAogBNwIgIAMgAykDMDcCECADIAQ2AgwMAQsgA0HIAGogASkDADcDACADIAMpAzA3A0AgA0H0AGogA0FAa0EEEN0QIAMoAnwhASADKAJ4IQQCQAJ+IAMoAnQiBUGKgICAeEcEQCADQaABaiADQZABaikCADcDACADIAMpAogBNwOYASADKQKAAQwBCyAEQQFxRQ0BAkAgAUEBcQRAIAMgATYCkAEgA0EDNgKMASADQbnk/gA2AogBIANBgICAgHg2AoQBIANCBDcCfCADQoSAgIAINwJ0DAELQX8gAUECaiIEIAEgBEsbIgUgAygCQCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgJ0DAILIANBiICAgHg2AnQMAQsgA0H0AGogASAFEL8vCyADQQk2AqgBIANBouf+ADYCpAEgA0GAgICAeDYCoAEgAyABNgKcASADQQE2ApgBIANB0ABqIANB9ABqIANBmAFqEIEUIAMoAlAiBUGKgICAeEYNASADQaABaiADQewAaikCADcDACADIAMpAmQ3A5gBIAMoAlghASADKAJUIQQgAykCXAshBiADQShqIANBoAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA5gBNwIgDAELIAMoAkAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBEzYChAEgA0G76P4ANgKAASADQYCAgIB4NgJ8IAMgAjYCeCADQQI2AnQgACADQQxqIANB9ABqEIEUIANBsAFqJAALywYCA38BfiMAQbABayIFJAAgBUH0AGogASAEEJMOIAUoAnghBgJAIAUoAnQiB0GKgICAeEcEQCAFQSxqIAVBlAFqKAIANgIAIAVBJGogBUGMAWopAgA3AgAgBUEcaiAFQYQBaikCADcCACAFIAUpAnw3AhQgBSAGNgIQIAUgBzYCDAwBCyAFQfQAaiABQX8gBCAGaiIBIAEgBkkbELQGIAVBOGoiASAFQYABaikCADcDACAFIAUpAng3AzAgBSgCdCIGQYqAgIB4RwRAIAVBKGogBUGQAWopAgA3AgAgBUEYaiABKQMANwIAIAUgBSkCiAE3AiAgBSAFKQMwNwIQIAUgBjYCDAwBCyAFQcgAaiABKQMANwMAIAUgBSkDMDcDQCAFQfQAaiAFQUBrQQQQ3RAgBSgCfCEBIAUoAnghBgJAAn4gBSgCdCIHQYqAgIB4RwRAIAVBoAFqIAVBkAFqKQIANwMAIAUgBSkCiAE3A5gBIAUpAoABDAELIAZBAXFFDQECQCABQQFxBEAgBSABNgKQASAFQQM2AowBIAVBueT+ADYCiAEgBUGAgICAeDYChAEgBUIENwJ8IAVChICAgAg3AnQMAQtBfyABQQJqIgYgASAGSxsiByAFKAJAIgYoAgRNBEAgBiAGKAIUQQJqIgc2AhQgBigCCCgCCCAHTwRAIAVBioCAgHg2AnQMAgsgBUGIgICAeDYCdAwBCyAFQfQAaiABIAcQvy8LIAVBBDYCqAEgBUG55/4ANgKkASAFQYCAgIB4NgKgASAFIAE2ApwBIAVBATYCmAEgBUHQAGogBUH0AGogBUGYAWoQgRQgBSgCUCIHQYqAgIB4Rg0BIAVBoAFqIAVB7ABqKQIANwMAIAUgBSkCZDcDmAEgBSgCWCEBIAUoAlQhBiAFKQJcCyEIIAVBKGogBUGgAWopAwA3AgAgBSAINwIYIAUgATYCFCAFIAY2AhAgBSAHNgIMIAUgBSkDmAE3AiAMAQsgBSgCQCIBIAEoAgxBAWs2AgwgBUGKgICAeDYCDAsgBSADNgKEASAFIAI2AoABIAVBgICAgHg2AnwgBSAENgJ4IAVBAjYCdCAAIAVBDGogBUH0AGoQgRQgBUGwAWokAAvOBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2ApABIANBAzYCjAEgA0G85P4ANgKIASADQYCAgIB4NgKEASADQgQ3AnwgA0KEgICACDcCdAwBC0F/IAFBBGoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBBGoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYCdAwCCyADQYiAgIB4NgJ0DAELIANB9ABqIAEgBRC/LwsgA0EJNgKoASADQavn/gA2AqQBIANBgICAgHg2AqABIAMgATYCnAEgA0EBNgKYASADQdAAaiADQfQAaiADQZgBahCBFCADKAJQIgVBioCAgHhGDQEgA0GgAWogA0HsAGopAgA3AwAgAyADKQJkNwOYASADKAJYIQEgAygCVCEEIAMpAlwLIQYgA0EoaiADQaABaikDADcCACADIAY3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQOYATcCIAwBCyADKAJAIgEgASgCDEEBazYCDCADQYqAgIB4NgIMCyADQRU2AoQBIANBzun+ADYCgAEgA0GAgICAeDYCfCADIAI2AnggA0ECNgJ0IAAgA0EMaiADQfQAahCBFCADQbABaiQAC7UGAQx/IwBBkAFrIgIkACABKAIEIQcgASgCACELIAIgASgCCCIFNgJkIAJB6ABqIAVBB2pBA3YQ0h9BwAAhBAJ/AkACQCAFQQJ0IgxBwP///wNxQUBrIAwgBUEPcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgRFDQILIAIoAnAhCSAFRQRAIAQhA0EADAQLIAVBA3QhCiAHIQEgBCEDA0ACQCABKAIABEAgAyABQQRqKAIANgIAIAkgBkEDdmoiDSANLQAAQQEgBkEHcXRyOgAADAELIANBADYCAAsgAUEIaiEBIAZBAWohBiADQQRqIQMgCkEIayIKDQALDAILQfz2/wBBKSACQfgAakH4+v8AQaj3/wAQ1R4AC0HAACAIEKM9AAsgAigCZAshASACIAc2AnwgAiALNgJ4IAJB+ABqIgcQ6jsgAiADIARrQQJ1IgM2AlgCQAJAIAEgA0YEQCACKAJ0IQYgAiACKQJoNwKEASACQQA2AoABIAIgBjYCfCACIAk2AnggAkEIaiAHENc7IAIoAgghCUEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAJBgAFqIgopAgA3AgAgAUEYaiACQYgBaiILKAIANgIAIAIgCDYCiAEgAkKAgICAgAg3AoABIAIgDDYCfCACIAQ2AnggAiAHENc7IAIoAgAhBEEcQQQQrTYiA0UEQEEEQRwQoz0ACyADQoGAgIAQNwIAIAMgAikCeDcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAIgBjYCYCACIAk2AlwgAiABNgJYQQxBBBCtNiIBRQ0CIAEgDDYCCCABIAQ2AgQgASADNgIAIAJBATYCcCACIAE2AmwgAkEBNgJoIAJBADYCgAEgAkKAgICAwAA3AnggAkEUaiIDQfjz/wAgBSABIAJB2ABqIAJB6ABqIAJB+ABqEIwTIAAgAxCvEyACQZABaiQADwsgAkIANwKEASACQoGAgIDAADcCfCACQZTy/wA2AnhBACACQdgAaiACQeQAaiACQfgAakGc8v8AEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAuhBQIIfgt/IwBBIGsiCyQAAn9BASABKAIURQ0AGiALQQxqIAAoAgQgACgCCCAAKAIMIAAoAhAQhx0gCygCGCETIAsoAhQhDiALKAIMIRIgCygCHCIMBH4gEiATQQN0aiIPMQAAIA5BP3GtiCECIAwgDmoiAEEDdiAAQQdxQQBHaiIRQQJPBEBBCCAOayEAIBFBAWshDSAPQQFqIQoDQCAKMQAAIABBP3GthiAChCECIApBAWohCiAAQQhqIQAgDUEBayINDQALCyACQn8gDEE/ca2GQn+FgwVCAAshBSALQQxqIAEoAgQgASgCCCABKAIMIAEoAhAQhx0gCygCGCEUIAsoAhQhECALKAIMIQ0CfiALKAIcIgxFBEAgEEE/ca0hBEIADAELIA0gFEEDdGoiDzEAACAQQT9xrSIEiCECIAwgEGoiAEEDdiAAQQdxQQBHaiIBQQJPBEBBCCAQayEAIAFBAWshASAPQQFqIQoDQCAKMQAAIABBP3GthiAChCECIApBAWohCiAAQQhqIQAgAUEBayIBDQALCyACQn8gDEE/ca2GQn+FgwshBiAOQT9xrSEHQQAhCkEAIBBrQT9xrSEIQQAgDmtBP3GtIQlBASEMQQAhAEEBIQ8DQAJAIBJFIAAgE09yRQRAIBIgAEEDdGoiASkAACECIA4EQCABQQhqMQAAIAmGIAIgB4iEIQILIABBAWohAAwBCyAPIRFBACEPQQAhEiAFIQJBASARRQ0CGgsCQCANRSAKIBRPckUEQCANIApBA3RqIgEpAAAhAyAQBEAgAUEIajEAACAIhiADIASIhCEDCyAKQQFqIQoMAQsgDCERQQAhDEEAIQ0gBiEDQQEgEUUNAhoLIAIgA0J/hYNQDQALQQALIAtBIGokAAvGBQIIfwJ+IwBBEGsiCSQAAkAgAkUEQEECIQUMAQsCQAJAAkACQAJAAkAgASACQeyYxABBAhD0Lg0AIAEgAkHumMQAQQIQ9C4NACACQQFGDQMgCUEwNgIMIAEgAiAJQQxqQQEQ9C5FDQMgASwAAUG/f0wNASACQQFrIgIhAyABQQFqIgEhBANAIANFBEBBCCEEDAcLIANBAWshAyAELQAAIQYgBEEBaiEEIAZB+AFxQTBGDQALDAQLIAJBAk0EQCACQQJHDQJBASEFDAYLIAEsAAJBv39MDQFBASEIIAJBAmsiAiEEIAFBAmoiASEDA0AgBEUEQEEQIQQMBgsgBEEBayEEIAMtAAAiB0FfcUHBAGshCkECIQUgA0EBaiEDIAdBMGtB/wFxQQpJIApB/wFxQQZJcg0ACwwFCyABIAJBASACQfCYxAAQozYACyABIAJBAiACQYCZxAAQozYAC0EKIQQDQCACIANGDQIgASADaiADQQFqIQMtAABBMGtB/wFxQQpJDQALC0ECIQVBACEGDAELQQEhAyABLQAAIQcCQAJAIAJBAUYEQEEAIQUgB0Eraw4DAwEDAQsgB0ErRgRAIAJBAWshAyABQQFqIQEgAkEKSQ0BDAILIAIhAyACQQlPDQELQQAhBgNAIAQgAS0AACICQcEAa0FfcUEKaiACQTBrIgUgAkE5SxsgBSAIGyICTQRAQQAhBQwDC0EBIQUgAUEBaiEBIAIgBCAGbGohBiADQQFrIgMNAAsMAQtBACEGIAStIQsDQCADRQRAQQEhBQwCC0EAIQUCQCAGrSALfiIMQiCIpw0AIAEtAAAiAkHBAGtBX3FBCmogAkEwayIGIAJBOUsbIAYgCBsiAiAETw0AIAFBAWohASADQQFrIQMgAiAMpyIHaiIGIAdPDQELCwsgACAGNgIEIAAgBTYCACAJQRBqJAALtQsCDX8EfiMAQZABayIDJAAgAkEMaiIFENg8IQgCQAJAIAIQkjYiBEUNACAEKAIURQ0AIANBEGoiBiAIEPcvIANBCGogBhCGPSADKAIMIQYgAygCCCEHIANBIGogBBDINCADQUBrIQsgASgCDCEJIAEoAgQhCiABKAIQIQwgAigCECENAkACQAJAAkADQAJAAkAgAykDSCIRUEUEQCADKQNQIRAMAQsDQAJ+AkAgAykDMCIQQgNSBEACQAJAAkAgEEICUQ0AIAMgEFCtQgGGNwMwIBCnQQFxRQ0AIAMgAykDODcDaAwBCyADKAJARQ0BIANB4ABqIAsQtiogAykDYCEQCyAQQgBSDQILIANCAzcDMAsgAykDICIQQgJRDQQgA0IANwMgIAMpAygMAQsgAykDaAshESAQp0EBcUUNAiADIAMpA1BCQH0iEDcDUCADIBE3A0ggEVANAAsLIAMgEUIBIBF6IhKGhTcDSCADIBKnIBCnaiIBNgJcIAUQ2DwgAU0NAiAMIA0gAUEDdGooAgAiBE0NAyAKIAQgCWoiBEEDdmotAAAgBEEHcXZBAXFFDQEgAUEDdiIEIAZPDQQgBCAHaiIEIAQtAABBASABQQdxdHI6AAAMAQsLIAMoAhghASADKAIcIQIgAyADKQIQNwIsIANBADYCKCADIAI2AiQgAyABNgIgIAMgA0EgahDXOyADKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAiA3AgggAUEQaiADQShqKQIANwIAIAFBGGogA0EwaigCADYCACADIAI2AmggAyAENgJkIAMgATYCYCAAIANB4ABqQQAgCBDyFQwFCyADIAIQ/Ts2AnwgA0ECNgJkIANBiPGBATYCYCADQgI3AmwgA0E7NgKMASADQTs2AoQBIAMgA0GAAWo2AmggAyADQfwAajYCiAEgAyADQdwAajYCgAEgA0HgAGpBmPGBARDvLAALQZD0gQFBIEGw9IEBEJ8pAAsgBCAGQfDzgQEQwyEAC0EEQRwQoz0ACyABIQYjAEEwayIFJABBwAAhCwJAAkACQAJAAkAgCEEGdiIBIAhBP3EiCkEAR2oiBEEDdCIJQcD///8DcUFAayAJIARBB3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiILRQ0CCyAIQcAATwRAIAGtIRMgBigCDCEMIAYoAgQhDSAGKAIQIQ8gAigCECEBA0AgEUIBfCERIAEhBEIAIRJCACEQA0AgDyAEKAIAIg5NDQYgDSAMIA5qIg5BA3ZqLQAAIA5BB3F2QQFxrSAShiAQhCEQIARBCGohBCASQgF8IhJCwABSDQALIAcgC2ogEDcDACABQYAEaiEBIAdBCGohByARIBNSDQALCyAKBEAgAigCECAIQQN0QYB8cWohBCAKrSERIAYoAgwhASAGKAIEIQIgBigCECEGQgAhEkIAIRADQCAGIAQoAgAiCk0NBCACIAEgCmoiCkEDdmotAAAgCkEHcXZBAXGtIBKGIBCEIRAgBEEIaiEEIBEgEkIBfCISUg0ACyAHIAtqIBA3AAAgB0EIaiEHCyAFIAk2AiwgBUKAgICAgAg3AiQgBSALNgIcIAUgCEEDdiAIQQdxQQBHaiIBIAcgASAHSRsiAjYCICAFQQhqIAVBHGoQ1zsgBSgCCCEEQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASAFKQIcNwIIIAFBEGogBUEkaikCADcCACABQRhqIAVBLGooAgA2AgAgBSACNgIYIAUgBDYCFCAFIAE2AhAgACAFQRBqQQAgCBDyFSAFQTBqJAAMBQtB8PSDAUEpIAVBHGpBrPWDAUGc9YMBENUeAAtBwAAgCRCjPQALQcD0gwFBIEHg9IMBEJ8pAAtBwPSDAUEgQeD0gwEQnykAC0EEQRwQoz0ACwsgA0GQAWokAAu1CwINfwR+IwBBkAFrIgMkACACQQxqIgUQ2zwhCAJAAkAgAhCSNiIERQ0AIAQoAhRFDQAgA0EQaiIGIAgQ9y8gA0EIaiAGEIY9IAMoAgwhBiADKAIIIQcgA0EgaiAEEMg0IANBQGshCyABKAIMIQkgASgCBCEKIAEoAhAhDCACKAIQIQ0CQAJAAkACQANAAkACQCADKQNIIhFQRQRAIAMpA1AhEAwBCwNAAn4CQCADKQMwIhBCA1IEQAJAAkACQCAQQgJRDQAgAyAQUK1CAYY3AzAgEKdBAXFFDQAgAyADKQM4NwNoDAELIAMoAkBFDQEgA0HgAGogCxC2KiADKQNgIRALIBBCAFINAgsgA0IDNwMwCyADKQMgIhBCAlENBCADQgA3AyAgAykDKAwBCyADKQNoCyERIBCnQQFxRQ0CIAMgAykDUEJAfSIQNwNQIAMgETcDSCARUA0ACwsgAyARQgEgEXoiEoaFNwNIIAMgEqcgEKdqIgE2AlwgBRDbPCABTQ0CIA0gAUECdGooAgAiBCAMTw0DIAogBCAJaiIEQQN2ai0AACAEQQdxdkEBcUUNASABQQN2IgQgBk8NBCAEIAdqIgQgBC0AAEEBIAFBB3F0cjoAAAwBCwsgAygCGCEBIAMoAhwhAiADIAMpAhA3AiwgA0EANgIoIAMgAjYCJCADIAE2AiAgAyADQSBqENc7IAMoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCIDcCCCABQRBqIANBKGopAgA3AgAgAUEYaiADQTBqKAIANgIAIAMgAjYCaCADIAQ2AmQgAyABNgJgIAAgA0HgAGpBACAIEPIVDAULIAMgAhD8OzYCfCADQQI2AmQgA0GI8YEBNgJgIANCAjcCbCADQTs2AowBIANBOzYChAEgAyADQYABajYCaCADIANB/ABqNgKIASADIANB3ABqNgKAASADQeAAakGY8YEBEO8sAAtBkPSBAUEgQbD0gQEQnykACyAEIAZB8POBARDDIQALQQRBHBCjPQALIAEhBiMAQTBrIgUkAEHAACELAkACQAJAAkACQCAIQQZ2IgEgCEE/cSIKQQBHaiIEQQN0IglBwP///wNxQUBrIAkgBEEHcRsiCUHAABDRNARAIAkEQCAJQcAAEK02IgtFDQILIAhBwABPBEAgAa0hEyAGKAIMIQwgBigCBCENIAYoAhAhDyACKAIQIQEDQCARQgF8IREgASEEQgAhEkIAIRADQCAEKAIAIg4gD08NBiANIAwgDmoiDkEDdmotAAAgDkEHcXZBAXGtIBKGIBCEIRAgBEEEaiEEIBJCAXwiEkLAAFINAAsgByALaiAQNwMAIAFBgAJqIQEgB0EIaiEHIBEgE1INAAsLIAoEQCACKAIQIAhBAnRBgH5xaiEEIAqtIREgBigCDCEBIAYoAgQhAiAGKAIQIQZCACESQgAhEANAIAQoAgAiCiAGTw0EIAIgASAKaiIKQQN2ai0AACAKQQdxdkEBca0gEoYgEIQhECAEQQRqIQQgESASQgF8IhJSDQALIAcgC2ogEDcAACAHQQhqIQcLIAUgCTYCLCAFQoCAgICACDcCJCAFIAs2AhwgBSAIQQN2IAhBB3FBAEdqIgEgByABIAdJGyICNgIgIAVBCGogBUEcahDXOyAFKAIIIQRBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAUpAhw3AgggAUEQaiAFQSRqKQIANwIAIAFBGGogBUEsaigCADYCACAFIAI2AhggBSAENgIUIAUgATYCECAAIAVBEGpBACAIEPIVIAVBMGokAAwFC0Hw9IMBQSkgBUEcakGs9YMBQZz1gwEQ1R4AC0HAACAJEKM9AAtBwPSDAUEgQeD0gwEQnykAC0HA9IMBQSBB4PSDARCfKQALQQRBHBCjPQALCyADQZABaiQAC8IFAgp/AX4gAkEBaiEOIABBCGohD0GAgAQgBUEBa3RBEHUhECABIQcgBiEIQQAhAkEBIQpBASAFdCIMQQFrIg0hCwNAIAIgDkcEQAJAIAcvAQAiCUH//wNGBEAgDyALQQN0akEEaiACNgIAIAtBAWshC0EBIQkMAQsgCkEAIBAgCcFKGyEKCyAIIAk7AQAgB0ECaiEHIAhBAmohCCACQQFqIQIMAQsLIAAgBTYCBCAAIAo2AgACQCALIA1GBEAgBkHqAGohCEEAIQlBACEKA0AgCSAORgRAIAxBA3YgDEEBdmpBA2oiAUEBdCELQQAhCkEAIQkDQCAJIAxPDQRBACECIAohBwNAIAJBAkcEQCAPIAcgDXFBA3RqQQRqIAIgCGotAAA2AgAgASAHaiEHIAJBAWohAgwBCwsgCEECaiEIIAlBAmohCSAKIAtqIA1xIQoMAAsABSAIIApqIBE3AAAgBiAKaiELIAEgCUEBdGouAQAhB0HyACECA0AgByACQeoAa0oEQCACIAtqIBE3AAAgAkEIaiECDAELCyARQoGChIiQoMCAAXwhESAJQQFqIQkgByAKaiEKDAELAAsACyAMQQN2IAxBAXZqQQNqIQpBACEIQQAhBwNAIAggDkYNAUEAIQIgASAIQQF0ai4BACIJQQAgCUEAShshCQNAIAIgCUcEQCAPIAdBA3RqQQRqIAg2AgADQCAHIApqIA1xIgcgC0sNAAsgAkEBaiECDAELCyAIQQFqIQgMAAsACyAAQQxqIQIgBUEfayEFIAwhBwNAIAcEQCAGIAIoAgAiAEEBdGoiASABLwEAIgFBAWo7AQAgAkEBayAFIAFnaiIIOgAAIAJBBGsgASAIdCAMazsBACACQQJrIAAgBGotAAA6AAAgAiADIABBAnRqKAIANgIAIAdBAWshByACQQhqIQIMAQsLC9sGAgV/An4jAEHQAGsiAyQAIAMgAjYCACADQThqIAEQkCcgAygCQCEEIAMoAjwhBQJAIAMoAjgiBkGTgICAeEcEQCAAIAMpAkQ3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgBEUEQCAAQZOAgIB4NgIADAELIAUpAwAiCEKAgICAEFoEQCADQQI2AjwgA0Gk74YBNgI4IANCAjcCRCADQa0DNgIYIAMgAUEYajYCFCADQe4GNgIQIAMgBTYCDCADIANBDGo2AkAgA0EkaiADQThqEJkOIAAgAykCKDcCCCAAQRBqIANBMGooAgA2AgAgACADKAIkNgIEIABBjYCAgHg2AgAMAQsgAyAIpyIHNgIEAkACQCAEIAEoAiQiBksEQCAFIAZBA3RqIgQpAwAiCUKAgICAEFoEQCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgAUEYajYCSCADQe4GNgJEIAMgBDYCQCADQTs2AjwgAyABQSRqNgI4IAMgA0E4ajYCKCADQRBqIANBIGoQmQ4gACADKQIUNwIIIABBEGogA0EcaigCADYCACAAIAMoAhA2AgQgAEGNgICAeDYCAAwECyADIAmnIgQ2AgggAiAHSQ0BIAIgBEkNAiAIIAlYBEAgAEGTgICAeDYCAAwECyADQQM2AiQgA0GE7oYBNgIgIANCAzcCLCADQTs2AkwgA0GtAzYCRCADIAFBGGo2AkAgA0E7NgI8IAMgA0E4ajYCKCADIANBCGo2AkggAyADQQRqNgI4IABBBGogA0EgahC7GCAAQY2AgIB4NgIADAMLIAYgBEHE7YYBEMMhAAsgA0EDNgIkIANB4O6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADNgJIIAMgA0EEajYCOCAAQQRqIANBIGoQmQ4gAEGNgICAeDYCAAwBCyADQQM2AiQgA0HI7oYBNgIgIANCAzcCLCADQTs2AkwgA0GtAzYCRCADIAFBGGo2AkAgA0E7NgI8IAMgA0E4ajYCKCADIAM2AkggAyADQQhqNgI4IABBBGogA0EgahC7GCAAQY2AgIB4NgIACyADQdAAaiQAC/kIAgt/AX4jAEHgAGsiAyQAIAIoAgAiBCkDACEOIAIoAgQhBSADIAIoAgw2AjAgAyAENgIoIAMgBCAFakEBajYCJCADIARBCGo2AiAgAyAOQn+FQoCBgoSIkKDAgH+DNwMYIwBBMGsiBCQAAkACQAJAIANBGGoiBSgCGARAIAUQ+hshByAFIAUoAhgiBkEBazYCGCAEQRBqIgJBBCAGQX8gBhsiBiAGQQRNG0EAQQRBCBCgGCAEKAIUIQYgBCgCEEEBRg0CIAQoAhgiCCAHQQxrNgIEIAggB0EYazYCACAEQQxqIgxBATYCACAEIAg2AgggBCAGNgIEIARBKGogBUEYaikDADcDACAEQSBqIAVBEGopAwA3AwAgBEEYaiAFQQhqKQMANwMAIAQgBSkDADcDECACKAIYBEAgBEEEaiIHKAIIIgZBA3QhCANAIAIQ+hshCSACIAIoAhhBAWsiCjYCGCAHKAIAIAZGBEAgByAGIApBAWoiC0F/IAsbQQRBCBDcKAsgByAGQQFqIgY2AgggBygCBCAIaiILIAlBGGs2AgAgC0EEaiAJQQxrNgIAIAhBCGohCCAKDQALCyADQQhqIAwoAgA2AgAgAyAEKQIENwIADAELIANBADYCCCADQoCAgIDAADcCAAsgBEEwaiQADAELIAYgBCgCGEG81YcBEP0vAAsCQAJ/IAMoAggiBwRAIANBADYCFCADQoCAgIAQNwIMIANCgICAgMAANwIYIAMgBzYCICADQQxqIAUQph4gAygCBCIEIAdBA3RqIQsgAygCACEGIAQhAgNAAkACQCACKAIAIggoAggiBUEASARAIAMgBTYCTCADQQM2AhwgA0Gc14cBNgIYDAELIAJBBGooAgAiCSgCCCIKQQBODQEgAyAKNgJMIANBAzYCHCADQdTXhwE2AhgLIANCAjcCJCADQTs2AlwgA0GcAzYCVCADQeDWhwE2AlAgAyADQdAAajYCICADIANBzABqNgJYIANBPGogA0EYaiICEJkOIAAgAykCQDcCDCAAQRRqIANByABqKAIANgIAIAAgAygCPDYCCCAAQoGAgIDwgYCAgH83AwAgAyAENgIcIAMgBjYCGCACQQRBCBDgHiADQQxqQQFBARDgHiABKAIoIgBFDQQgASAAEQMADAQLIAMgBTYCICADQoCAgIDAADcCGCADQQxqIgUgA0EYaiIMEKYeIAUgCCgCBCINIA0gCCgCCGoQvCYgAyAKNgIgIANCgICAgMAANwIYIAUgDBCmHiAFIAkoAgQiBSAFIAkoAghqELwmIAJBCGoiAiALRw0ACyADIAQ2AhwgAyAGNgIYIAxBBEEIEOAeIAEgAygCEDYCCCADKQIQIQ4gAygCDAwBCyABQQA2AghBgICAgHgLIQQgASgCLCICKAIAQYCAgIB4RwRAIAJBAUEBEOAeCyACIA43AgQgAiAENgIAIAEgAjYCLCAAQQhqIAFBMPwKAAAgAEEANgIAIAcNACADQQRBCBDgHgsgA0HgAGokAAvxBQILfwF+IwBBIGsiBCQAIAIoAhQhDCACIAEoAhQiByADIAMgB0sbIgYQ7i0CQAJAIAEoAggiCCABKAIQIgNGBEAgAEIINwMADAELAkACQAJAAkACQAJAIAJBDGogCCADa60gBq1+Ig9CIIhQBH8gB0UNASAPpyAHbgUgBQsQ5S0gAS0AGCEJIAZFIAMgCE9yDQMgASgCBCELIAZBAWshCiAJQQFxIQ0DQAJAAkAgCCADQQRqIgVPBEAgA0F8Tw0FIAMgC2ooAAAiDiAFaiIDIAhLDQEgAyAFSQ0GIARBCGogAiAFIAtqIA4gDRCfFCAEKAIIIgVBCEYNAiAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCACAAIAU2AgAMCgsgBEEIakEXQQBBAUEBEKAYIAQoAgwhAiAEKAIIQQFGDQogBCgCECIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMCQsgBEEIakEXQQBBAUEBEKAYIAQoAgwhAiAEKAIIQQFGDQkgBCgCECIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMCAsgASADNgIQIAMgCEkEQCAKQQBHIApBAWshCg0BCwsgASAHIAZrNgIUIAlBAXENBAwFC0HIjc0AEOIrAAsgAyAFQaiNzQAQsTsACyAFIANBuI3NABCxOwALIAEgByAGazYCFCAJQQFxRQ0BCyAEQQhqIAIgDBCuGSAEKAIIIgFBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCACAAIAE2AgAMAQsgAEEINgIAIAAgBjYCBAsgBEEgaiQADwsgAiAEKAIQQdT9zAAQ/S8AC/EFAgt/AX4jAEEgayIEJAAgAigCFCEMIAIgASgCFCIHIAMgAyAHSxsiBhDsLQJAAkAgASgCCCIIIAEoAhAiA0YEQCAAQgg3AwAMAQsCQAJAAkACQAJAAkAgAkEMaiAIIANrrSAGrX4iD0IgiFAEfyAHRQ0BIA+nIAduBSAFCxDlLSABLQAYIQkgBkUgAyAIT3INAyABKAIEIQsgBkEBayEKIAlBAXEhDQNAAkACQCAIIANBBGoiBU8EQCADQXxPDQUgAyALaigAACIOIAVqIgMgCEsNASADIAVJDQYgBEEIaiACIAUgC2ogDiANEJcUIAQoAggiBUEIRg0CIAAgBCkCDDcCBCAAQRRqIARBHGooAgA2AgAgAEEMaiAEQRRqKQIANwIAIAAgBTYCAAwKCyAEQQhqQRdBAEEBQQEQoBggBCgCDCECIAQoAghBAUYNCiAEKAIQIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwJCyAEQQhqQRdBAEEBQQEQoBggBCgCDCECIAQoAghBAUYNCSAEKAIQIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwICyABIAM2AhAgAyAISQRAIApBAEcgCkEBayEKDQELCyABIAcgBms2AhQgCUEBcQ0EDAULQciNzQAQ4isACyADIAVBqI3NABCxOwALIAUgA0G4jc0AELE7AAsgASAHIAZrNgIUIAlBAXFFDQELIARBCGogAiAMEK4ZIAQoAggiAUEIRg0AIAAgBCkCDDcCBCAAQRRqIARBHGooAgA2AgAgAEEMaiAEQRRqKQIANwIAIAAgATYCAAwBCyAAQQg2AgAgACAGNgIECyAEQSBqJAAPCyACIAQoAhBB1P3MABD9LwAL/AkCEH8BfiACQQFrIRYgAkECdCAAakEEayEXQQEhEAJAAkACQAJAAkACQAJAAkACQANAQQAhCgJAIAJFDQAgFyEAIBYhCwNAAkACQCABIBZLBEAgACgCACIIDQEMAgsgCyABQdCR0gAQwyEACyAFIApLBEAgBCAKQQN0aiAQIAggCCAQSRutIAutQjCGhEKAgICA8P8/hDcCACAKQQFqIQoMAQsgCiAFQeCR0gAQwyEACyAAQQRrIQAgC0EBayILQX9HDQALIApBAUcNACAFRQRAQQBBAEGgkNIAEMMhAAsgBC4BBiIAIAdJBEAgACAGakEBOgAADAULIAAgB0GwkNIAEMMhAAsCQCAKQQxNBEAgCkECSQ0BQQEgBSAFQQFNGyEMIAQhC0EBIQgDQAJAIAggDEcEQCAIQQFqIQkgBCAIQQN0aikCACIYpyENIBhCMIinwSEOIAshAANAIABBBmouAQAgDkggACgCACIPIA1LIA0gD0YbRQ0CIABBCGogACkCADcCACAAQQhrIQAgCEEBayIIDQALQQAhCAwBCyAMIAVB6I/SABDDIQALIAUgCEsEQCAEIAhBA3RqIBg3AgAgC0EIaiELIAkiCCAKRw0BDAMLCyAIIAVB+I/SABDDIQALIApBOUlBAXQhDgNAAkAgDkECdEGIkNIAaigCACIJIApPDQAgCSAFIAUgCUkbIQ9BACEMQQAgCUEDdCISayETIAQhCyAJIQACQANAAn8CQCAAIA9HBEAgAEEBaiENIAQgAEEDdGopAgAiGKchESAYQjCIp8EhFCALIQAgDCEIA0AgBSAITQ0FIABBBmouAQAgFEggACgCACIVIBFLIBEgFUYbRQ0CIAAgEmogACkCADcCACAAIBNqIQAgCCAJSSAIIAlrIQhFDQALIAggCWoMAgsgDyAFQbiP0gAQwyEACyAIIAlqCyIAIAVJBEAgBCAAQQN0aiAYNwIAIAtBCGohCyAMQQFqIQwgDSIAIApHDQEMAwsLIAAgBUHYj9IAEMMhAAsgCCAFQciP0gAQwyEACyAOQQFqIg5BBkcNAAsLIAUgCksEQCAEIApBA3RqIgtCfzcCACAKQQFqIgAgBU8NAiAEIABBA3RqQn83AgBBASEJIApBAUcEQEEBIQ4gCkEBdEEAIQkDQCAFIAlNDQcgACAFTw0IIAkgBCAJQQN0aigCACIIIAQgAEEDdGooAgAiDU1qIgwgBU8NCSAAIAggDUsiCGoiDSAFTw0KIAAgCSAIGyIAIAVPDQsgDSAMIAQgDEEDdGooAgAiCSAEIA1BA3RqKAIAIhFLIhIbIgggBU8NDCAEIAhBA3RqKAIAIRMgBCAAQQN0aigCACEUIAtBDmogCDsBACALQQxqIAA7AQAgC0EIaiIIIBMgFGo2AgAgCiAOakEBaiAFTw0FIAwgCSARTWohCSANIBJqIQAgC0EQakJ/NwIAIAghCyAKIA5BAWoiDkcNAAtBAWshCQsgEEEBdCEQIAkgBCAFIAYgByADEIkRRQ0BDAQLCyAKIAVBwJDSABDDIQALIAAgBUHQkNIAEMMhAAsgBSAFQcCR0gAQwyEACw8LIAkgBUHgkNIAEMMhAAsgACAFQfCQ0gAQwyEACyAMIAVBgJHSABDDIQALIA0gBUGQkdIAEMMhAAsgACAFQaCR0gAQwyEACyAIIAVBsJHSABDDIQALywYBBX8jAEHQAGsiAyQAIAMgAjYCACADQThqIAEQjycgAygCQCEEIAMoAjwhBQJAIAMoAjgiBkGTgICAeEcEQCAAIAMpAkQ3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgBEUEQCAAQZOAgIB4NgIADAELIAUoAgAiBkEASARAIANBAjYCPCADQaTvhgE2AjggA0ICNwJEIANBrQM2AhggAyABQRhqNgIUIANBnAM2AhAgAyAFNgIMIAMgA0EMajYCQCADQSRqIANBOGoQmQ4gACADKQIoNwIIIABBEGogA0EwaigCADYCACAAIAMoAiQ2AgQgAEGNgICAeDYCAAwBCyADIAY2AgQCQAJAIAQgASgCJCIHSwRAIAUgB0ECdGoiBSgCACIEQQBIBEAgA0EDNgIkIANB0O+GATYCICADQgM3AiwgA0GtAzYCTCADIAFBGGo2AkggA0GcAzYCRCADIAU2AkAgA0E7NgI8IAMgAUEkajYCOCADIANBOGo2AiggA0EQaiADQSBqEJkOIAAgAykCFDcCCCAAQRBqIANBHGooAgA2AgAgACADKAIQNgIEIABBjYCAgHg2AgAMBAsgAyAENgIIIAIgBkkNASACIARJDQIgBCAGTwRAIABBk4CAgHg2AgAMBAsgA0EDNgIkIANBhO6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADQQhqNgJIIAMgA0EEajYCOCAAQQRqIANBIGoQuxggAEGNgICAeDYCAAwDCyAHIARBxO2GARDDIQALIANBAzYCJCADQeDuhgE2AiAgA0IDNwIsIANBOzYCTCADQa0DNgJEIAMgAUEYajYCQCADQTs2AjwgAyADQThqNgIoIAMgAzYCSCADIANBBGo2AjggAEEEaiADQSBqEJkOIABBjYCAgHg2AgAMAQsgA0EDNgIkIANByO6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADNgJIIAMgA0EIajYCOCAAQQRqIANBIGoQmQ4gAEGNgICAeDYCAAsgA0HQAGokAAu/BQEKfyMAQSBrIgQkACACKAIEIQggASgCBCEDAkACQAJAAkAgASgCCCIGIAIoAggiCU8EQCAEIAM2AgggBCADIAlBAnRqIgc2AgwgCSAEQQhqEJ42IgIgAiAJSxsiBUUNAgNAIAMgCiADKAIAIgogCCgCAGoiAmoiCzYCACACIApJIAIgC0tyIgIhCiADQQRqIQMgCEEEaiEIIAVBAWsiBQ0ACyACRQ0CIAZBAnQgCUECdGshAwNAIANFDQIgByAHKAIAQQFqIgI2AgAgA0EEayEDIAdBBGohByACRQ0ACwwCCyAEIAM2AgggBCADIAZBAnQiCmo2AgxBACECIAYgBEEIahCeNiIFIAUgBksbIgcEQCAIIQUDQCADIAIgAygCACILIAUoAgBqIgJqIgw2AgAgAiALSSACIAxLciECIANBBGohAyAFQQRqIQUgB0EBayIHDQALCyABIAggCmogCCAJQQJ0ahCeJCAGIAEoAggiCEsNAiAGIAhGDQMgBCABKAIEIAZBAnRqIgM2AgggBCADQQRqIgc2AgwgBEEIahCeNiIJRQ0BQQAhBSAJQQBHIQoDQCADIAUgAygCACIJIAJqIgVqIgs2AgAgBSAJSSAFIAtLciEFIANBBGohAyAKQQFrIgoNAAsgBUUNASAIQQJ0IAZBAnRrQQRrIQMDQCADBEAgByAHKAIAQQFqIgI2AgAgA0EEayEDIAdBBGohByACRQ0BDAMLCyABKAIIIQYLIAEoAgAgBkYEQCABQaSJiAEQnSgLIAEoAgQgBkECdGpBATYCACABIAZBAWo2AggLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgBEEgaiQADwsgBiAIQZSJiAEQrzsACyAEQQA2AhggBEEBNgIMIARB/IiIATYCCCAEQgQ3AhAgBEEIakGEiYgBEO8sAAvNBQIOfwJ+IwBBIGsiDSQAAkACQAJAIAMgBnEiDiACTQRAIAkoAgghCiAAKAIsIRIgASAOaiITIAIgDmsiFBCWGiEQIAogDmoiDCACTw0BIAEgDGotAAAhDCAJKQMAIRggCUEANgIMIAYgBSgCACIPayIFIAZPDQMCQCACIAMgBXEiBSAKaiILSwRAIAwgASALai0AAEYNAQwFCyALIAJB1MvOABDDIQALIAIgBUkNAiABIAVqIAIgBWsgEyAUIAcQ9AEiC0UNAyALIAUgBBChLiIKIBIQ8jQhGCAJIA82AhAgCSAKNgIIIAkgGDcDACACIAogDmoiBUsEQCABIAVqLQAAIQxBASEVDAQLIAUgAkH0y84AEMMhAAsgDiACQaTLzgAQrzsACyAMIAJBtMvOABDDIQALIAUgAkHky84AEK87AAsCQAJAAkAgECAAKAIEIgtNBEAgCyAQayIFQQNNDQEgACgCACIWIBBBAnRqIRdBACEAAkACQANAIABBEEcEQCAAIBdqKAIAIhEgA3EiBSAKaiIPIAJPDQIgAEEEaiEAIAYgEWsiEUEBayAITw0BIAwgASAPai0AAEcNASACIAVJDQcgASAFaiACIAVrIBMgFCAHEPQBIg9FDQEgGCAPIAUgBBChLiIFIBEgEhCMLSIZWg0BIAkgETYCECAJIAU2AgggCSAZNwMAIAUgDmoiCiACTw0DIAEgCmotAAAhDEEBIRUgGSEYIAUhCgwBCwsgECAGQQN2QQNxaiIAIAtJDQQgACALQeTMzgAQwyEACyAPIAJB9MzOABDDIQALIAogAkGUzc4AEMMhAAsgDUEANgIYIA1BATYCDCANQZjXzgA2AgggDUIENwIQIA1BCGpBxMzOABDvLAALQQQgBUHUzM4AELA7AAsgFiAAQQJ0aiAGNgIAIA1BIGokACAVDwsgBSACQYTNzgAQrzsAC80FAg5/An4jAEEgayINJAACQAJAAkAgAyAGcSIOIAJNBEAgCSgCCCEKIAAoAiwhEiABIA5qIhMgAiAOayIUELceIRAgCiAOaiIMIAJPDQEgASAMai0AACEMIAkpAwAhGCAJQQA2AgwgBiAFKAIAIg9rIgUgBk8NAwJAIAIgAyAFcSIFIApqIgtLBEAgDCABIAtqLQAARg0BDAULIAsgAkHUy84AEMMhAAsgAiAFSQ0CIAEgBWogAiAFayATIBQgBxD0ASILRQ0DIAsgBSAEEKEuIgogEhDyNCEYIAkgDzYCECAJIAo2AgggCSAYNwMAIAIgCiAOaiIFSwRAIAEgBWotAAAhDEEBIRUMBAsgBSACQfTLzgAQwyEACyAOIAJBpMvOABCvOwALIAwgAkG0y84AEMMhAAsgBSACQeTLzgAQrzsACwJAAkACQCAQIAAoAgQiC00EQCALIBBrIgVBAU0NASAAKAIAIhYgEEECdGohF0EAIQACQAJAA0AgAEEIRwRAIAAgF2ooAgAiESADcSIFIApqIg8gAk8NAiAAQQRqIQAgBiARayIRQQFrIAhPDQEgDCABIA9qLQAARw0BIAIgBUkNByABIAVqIAIgBWsgEyAUIAcQ9AEiD0UNASAYIA8gBSAEEKEuIgUgESASEIwtIhlaDQEgCSARNgIQIAkgBTYCCCAJIBk3AwAgBSAOaiIKIAJPDQMgASAKai0AACEMQQEhFSAZIRggBSEKDAELCyAQIAZBA3ZBAXFqIgAgC0kNBCAAIAtB5MzOABDDIQALIA8gAkH0zM4AEMMhAAsgCiACQZTNzgAQwyEACyANQQA2AhggDUEBNgIMIA1BmNfOADYCCCANQgQ3AhAgDUEIakHEzM4AEO8sAAtBAiAFQdTMzgAQsDsACyAWIABBAnRqIAY2AgAgDUEgaiQAIBUPCyAFIAJBhM3OABCvOwALnAYBBX8gAigCGCEHAkACQCAGRQRAIAAoAmwNAQsgB0EBRg0BIANBAUcNACAHQQNrQQNJDQELQQQgAigCBHQhCAtBACEHAkAgBkUNACACKAIQQQNHDQBBESACKAIAIgcgB0ERTxshBwsgAigCCCEJAn8gBUUEQCABKAIIIQUgACgCACEKIAAoAgQMAQsgAEHLtMIANgIIIABBy7TCADYCBCAAQQA2AhRBzbTCACEKIABBzbTCADYCACABIAEoAggiBTYCEEHLtMIACyELIABBADYC3AEgACAHNgIgIABBADYCtAEgAEEANgKMASAAQQA2AhggASAFNgIMIAAgCiALayIFNgIQIAAgBTYCHCAAIAU2AgwgACABQQQgCXQQ+yc2AlwgACABIAgQ+yc2AmQgACABQQQgB3RBACAHGxD7JzYCYEFAIQcgAS0AHAR/IAcFAkAgBA0AIAEoAhAiBSABKAIMIgdJBH8gByAFayIEBEAgBUEAIAT8CwALIAEoAgwhByABKAIQBSAFCyAHTw0AIAEgBzYCEAsCQCADQQFHDQAgAigCGEEGa0F9SQ0AQQEgCXQhAwJAIAYEQAJAIAEgA0E/akFAcSIEQQEQpiQiA0UNACADIAEoAhgiBU8NACAFIANrIgUgBCAEIAVLGyIEBEAgA0EAIAT8CwALIAEgAzYCGAsgACADNgIoIAAgACkDUEIIEMgqIAA1AlhCBBDIKoU3A1AMAQsgACABIAMQ1TUiBDYCKCADBEAgBEEAIAP8CwALIABCADcDUAsgACACKAIIQQRBBiACKAIMIgMgA0EGTxsiAyADQQRNG2s2AiQLAkAgBkUNACACKAIYQQdJDQAgACABQYAIENU1NgJwIAAgAUGQARDVNTYCdCAAIAFB1AEQ1TU2AnggACABQYABENU1NgJ8IAAgAUGIgAIQ1TU2AoABIAAgAUGcgAcQ1TU2AoQBCyAAIAIpAgA3ArgBIABB0AFqIAJBGGooAgA2AgAgAEHIAWogAkEQaikCADcCACAAQcABaiACQQhqKQIANwIAQUBBACABLQAcGwsLtwYCBn8BfiMAQUBqIgIkAAJAIAG9Qv///////////wCDQoCAgICAgID4/wBaBEAgAEGAgICAeDYCAAwBCwJAIAGdIgFEAAAAAAAAAABiBEAgAkEIaiIEQQFBfyABvSIIQgBZGzoACiAEIAhCNIinQf8PcSIDQbMIazsBCCAEIAhC/////////weDQoCAgICAgIAIhCAIQgGGQv7///////8PgyADGzcDACACLQASQf8BRgRAIABBgICAgHg2AgAMAwsgAi4BECEEIAIpAwghCCACQRBqIgZB+PKHASgCADYCACACQfDyhwEpAgA3AwggCFBFBEBBASEDA0AgAigCCCADQQFrRgRAIAJBCGpB/PKHARCdKAsgAigCDCAFaiAIPgIAIAVBBGohBSACIAM2AhAgA0EBaiEDIAhC/////w9WIAhCIIghCA0ACwsgAkEgaiAGKAIANgIAIAIgAikDCDcDGAJAAkAgBEEASiAEQQBIa0H/AXEOAgMBAAsgAkEgaiIDKAIAIQUgA0H48ocBKAIANgIAIAJBMGoiAyAFNgIAIAIgAikDGDcDKCACQfDyhwEpAgA3AxgCQCACQShqIgUQ9TUoAggEQCACQTRqIAVBACAEayIEwUEFdiAEQR9xEJUJDAELIAJBEGogAygCADYCACACIAIpAyg3AwggAkE0aiACQQhqEKcrCyACQRhqEOk7IAJBIGogAkE8aigCADYCACACIAIpAjQ3AxgMAgsgAkEgaiIDKAIAIQUgA0H48ocBKAIANgIAIAJBMGoiAyAFNgIAIAIgAikDGDcDKCACQfDyhwEpAgA3AxgCQCACQShqEPU1KAIIBEAgAkEQaiADKAIANgIAIAIgAikDKDcDCCACQTRqIAJBCGogBEEFdiAEQR9xEKgFDAELIAJBEGogAygCADYCACACIAIpAyg3AwggAkE0aiACQQhqEKcrCyACQRhqEOk7IAJBIGogAkE8aigCADYCACACIAIpAjQ3AxgMAQsgAEEIakH48ocBKAIANgIAIABB8PKHASkCADcCAAwBCyAAIAIpAxg3AgAgAEEIaiACQSBqKAIANgIACyACQUBrJAAL1QUBBH8jAEEQayINJAAgDUEIakIANwMAIA1CADcDAAJAIAJFDQAgACEPA0ACQAJAIAEgEEcEQCAPKAIARQ0CIA5BBE8EQCAOQQRHDQUMAgsgDSAOQQJ0aiAQNgIADAELIAEgAUH86NEAEMMhAAsgDkEBaiEOCyAPQQRqIQ8gAiAQQQFqIhBHDQALC0EgIANBAWsiA2drQQAgAxshDwJAIA5BAk8EQCACIAdNBEAgAgRAIAZBACAC/AsACyAAIAEgAkEPIAQgBSAGIAcQ6wggBiAHIAIgCCAJELMLIA5BBU8EQCAGIAcgAiAEIAUgCiALIAwQ4QcMAwtBAkIBIAogCyAMEOUSQQIgDkEBayIJrSAKIAsgDBDlEiANQQRyIQhBACEDA0ACQCADIgBBAWoiAyAOTw0AIA0gAEECdGohBCAIIRAgCSEBAkADQCAHIBAoAgAiAEsEQCAEKAIAIgIgB08NAiAAIAZqLQAAIAIgBmotAABJBEAgECACNgIAIAQgADYCAAsgEEEEaiEQIAFBAWsiAQ0BDAMLCyAAIAdB3OjRABDDIQALIAIgB0Hs6NEAEMMhAAsgCEEEaiEIIAlBAWshCSADIA5HDQALIA8gDSgCACIArSAKIAsgDBDlEiAPIA01AgQgCiALIAwQ5RICQAJAIA5BAmsOAgQBAAsgDyANNQIIIAogCyAMEOUSIA8gDTUCDCAKIAsgDBDlEiAAIAdJBEBBASAAIAZqLQAAQQFGrSAKIAsgDBDlEgwECyAAIAdBzOjRABDDIQALIA8gDTUCCCAKIAsgDBDlEgwCCyACIAdBjOnRABCwOwALQQRCASAKIAsgDBDlEiAPIA0oAgAiAK0gCiALIAwQ5RIgACAHTwRAIAAgB0Gc6dEAEMMhAAsgACAGakEAOgAAIAAgCU8EQCAAIAlBrOnRABDDIQALIAggAEEBdGpBADsBAAsgDUEQaiQAC5MGAgl/AX4jAEGQAWsiAyQAIAMgAiABa0EYbiIGNgJkIANB6ABqIAZBB2pBA3YQ0h9BwAAhBQJAAkAgBkEEdCIKQUBxQUBrIAogBkEDcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAnAhCSAFIQQgASACRg0CA0ACQCABKAIABEAgAUEIaikDACEMIARBCGogAUEQaikDADcDACAEIAw3AwAgCSAHQQN2aiILIAstAABBASAHQQdxdHI6AAAMAQsgBEIANwMAIARBCGpCADcDAAsgB0EBaiEHIARBEGohBCABQRhqIgEgAkcNAAsMAgtBrMH/AEEpIANB+ABqQcTI/wBB2MH/ABDVHgALQcAAIAgQoz0ACyADIAQgBWtBBHUiATYCWAJAAkAgASAGRgRAIAMoAnQhBCADIAMpAmg3AoQBIANBADYCgAEgAyAENgJ8IAMgCTYCeCADQQhqIANB+ABqIgIQ1zsgAygCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASADKQJ4NwIIIAFBEGogA0GAAWoiCSkCADcCACABQRhqIANBiAFqIgsoAgA2AgAgAyAINgKIASADQoCAgICACDcCgAEgAyAKNgJ8IAMgBTYCeCADIAIQ1zsgAygCACEFQRxBBBCtNiICRQRAQQRBHBCjPQALIAJCgYCAgBA3AgAgAiADKQJ4NwIIIAJBEGogCSkCADcCACACQRhqIAsoAgA2AgAgAyAENgJgIAMgBzYCXCADIAE2AlhBDEEEEK02IgFFDQIgASAKNgIIIAEgBTYCBCABIAI2AgAgA0EBNgJwIAMgATYCbCADQQE2AmggA0EANgKAASADQoCAgIDAADcCeCADQRRqIgJB5Lv/ACAGIAEgA0HYAGogA0HoAGogA0H4AGoQjBMgACACEL4TIANBkAFqJAAPCyADQgA3AoQBIANCgYCAgMAANwJ8IANBwLv/ADYCeEEAIANB2ABqIANB5ABqIANB+ABqQci7/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC5MFAQZ/IAEgAmohBgJAAkAgAkUEQCABIQIMAQsgASECA0AgBCIIAn8gAiIELAAAIgVBAE4EQCAFQf8BcSEDIAJBAWoMAQsgBC0AAUE/cSEDIAVBH3EhAiAFQV9NBEAgAkEGdCADciEDIARBAmoMAQsgBC0AAkE/cSADQQZ0ciEDIAVBcEkEQCADIAJBDHRyIQMgBEEDagwBCyACQRJ0QYCA8ABxIAQtAANBP3EgA0EGdHJyIQMgBEEEagsiAiAEa2ohBAJAIANBIEYgA0EJa0EFSXINACADQYABSQ0CAkAgA0EIdiIFQR9NBEAgBUUNASAFQRZHIANBgC1Hcg0EDAILIAVBIEcEQCAFQTBHIANBgOAAR3INBAwCCyADQf8BcUH71IkBai0AAEECcUUNAwwBCyADQf8BcUH71IkBai0AAEEBcUUNAgsgAiAGRw0AC0EAIQhBACEEDAELIAIgBkYNAANAIAYiBUEBayIGLAAAIgNBAEgEQCADQT9xAn8gBUECayIGLQAAIgfAIgNBQE4EQCAHQR9xDAELIANBP3ECfyAFQQNrIgYtAAAiB8AiA0FATgRAIAdBD3EMAQsgA0E/cSAFQQRrIgYtAABBB3FBBnRyC0EGdHILQQZ0ciEDCwJAIANBIEYgA0EJa0EFSXINAAJAIANBgAFJDQACQAJAIANBCHYiB0EfTQRAIAdFDQEgB0EWRw0DIANBgC1GDQQMAwsgB0EgRg0BIAdBMEcNAiADQYDgAEYNAwwCCyADQf8BcUH71IkBai0AAEEBcUUNAQwCCyADQf8BcUH71IkBai0AAEECcQ0BCyAEIAJrIAVqIQQMAgsgAiAGRw0ACwsgACAEIAhrNgIEIAAgASAIajYCAAu5BQETfyABIAAoAgQiEWsiCkEBIAAoArwBdCISayIJIApLIQsgCkEBIAAoArgBdCIHayAAKAIQIgYgCiAGayAHSxshDCAAKAIYIQ0gACgCxAEhDiAAKAIMIQ8gACgCCCETQQMhByAAKAK0ASEIIAAoAmQhFCAFQQNGBEAgASAIKALAAUECayAEEKMdQQJ0IRALQQAgCSALGyEVIAYgDCANGyEMQQEgDnQhCSAPIBNqIQ0gDyARaiELIBJBAWshDiAKQQNqIRYgAUEEaiESIAFBA2shFyAAIABBuAFqIAEgBCAAKALcARC8GSEAIAVBAUchGAJAA0ACQCAJRSAAIAxJcg0AAkAgBwJ/IBhFIAAgD0lxRQRAIAAgEWoiBiAHakEDaygAACAHIBdqKAAARw0CIAEgBiACEIAUDAELIAAgE2oiBigAACABKAAARw0BIBIgBkEEaiACIA0gCxDNKEEEagsiBk8NACADIBYgAGs2AgAgBiIHIAFqIAJGDQMLIAAgFU0NACAJQQFrIQkgFCAAIA5xQQJ0aigCACEADAELCyAHIQYLAkAgBUEDRgRAIAMgBiAJIAggASACIAsgCiAPIBAQoA0hAAwBCwJAIAVBAkcNAEEAIQcgCCgCACIRIAgoAgQiE2siBUEBIAgoArwBdCIQayIAQQAgACAFTRshDCAIKAIMIQ0gCCgCZCEOIAgoAlwgASAIKALAASAEEKMdQQJ0aiEAIBBBAWshCCAFIApqQQNqIQUDQCAHIAlGDQEgACgCACIEIA1JDQECQCAEIBNqIgAoAAAgASgAAEcNACASIABBBGogAiARIAsQzShBBGoiACAGTQ0AIAMgBSAEIA9qazYCACAAIgYgAWogAkYNAwsgBCAMTQ0BIAdBAWohByAOIAQgCHFBAnRqIQAMAAsACyAGDwsgAAuRBgEJfyMAQZABayIDJAAgAyACIAFrIgRBBXYiCTYCZCADQegAaiAJQQdqQQN2ENIfQcAAIQUCQAJAIARBAXYiCkHA////B3FBQGsgCiAEQf4AcRsiB0HAABDRNARAIAcEQCAHQcAAEK02IgVFDQILIAMoAnAhCCAFIQQgASACRg0CA0ACQCABKAIAQQFxBEAgBCABQRBqKQMANwMAIAQgAUEYaikDADcDCCAIIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwggBEIANwMACyAGQQFqIQYgBEEQaiEEIAFBIGoiASACRw0ACwwCC0HklIABQSkgA0H4AGpByJeAAUGQlYABENUeAAtBwAAgBxCjPQALIAMgBCAFa0EEdSIBNgJYAkACQCABIAlGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAINgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIIKQIANwIAIAFBGGogA0GIAWoiCygCADYCACADIAc2AogBIANCgICAgIAINwKAASADIAo2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAIKQIANwIAIAJBGGogCygCADYCACADIAQ2AmAgAyAGNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAo2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkH0kYABIAkgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQsBMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALlisCG38BfiMAQRBrIh0kACAGQYABaiEZIAZB/A9qIRYgBkHwDWohGCAGQbQQaiEVIAZBgAJqIRQgAEH/D3EhGiAGLQCMESEAIAZB8hBqIhBBEGohGyAGQaANaiIXQRhqIR4DQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEH/AXFBAWsOBQMBBAUGAAtBAiEKIBhBAiAWIAcgCBDtHw0BDAkLQQMhAAJ/IwBBEGsiEyQAIAYoArQQIg5BAWoiEiAGKAL8DyINTwRAIBJB0AVNBEAgBkGAAmohEQJAAkACfyANIBJHBEBBICAaQQFrIglna0EAIAkbIQkgDkEBdCANQQF0IgprQQJqIQwgBkHwDWohDyAKIBFqIQsDQCATQQA2AgwgDyAJIBNBDGogByAIEO0fRQRAIAZBAjoAjBEgBiANNgL8D0ECDAMLQXwgASATKAIMIgpNDQIaIAsgCjsBACANQQFqIQ0gC0ECaiELIAxBAmsiDA0ACwsgDkHRBU8NAUEBIA5FDQAaIAYgDkEBdCIKakGAAmohHEEAIQ8gESEJA0AgDyASRg0DIAlBAmohDCARIA9BAWoiD0EBdGohDSAKIQsDQCALRQRAIApBAmshCiAMIgkgHEcNAkEBDAMLIAtBAmshCyANLwEAIA1BAmohDSAJLwEARw0ACwtBewsgE0EQaiQADAQLIA5B0AVBrJ/zABCwOwALIA5BAmogEkG8n/MAELE7AAsgEkHQBUGcn/MAELA7AAsgDSASQZyf8wAQsTsACyIKQQFHDQgMBwtBASEAIBYoAgBBAUYNBiAGQoCAgICABDcDuBAgF0IANwMAIBBCADcBACAXQQhqQQA2AgAgEEEIakIANwEAIBtBADsBAEEEIQAMBgsgGEECIBUgByAIEO0fRQRAIAZBAToAjBFBAiEKDAcLIBZBADYCAEECIQAMBQsgFSgCACIAQQNGBEAgHUEANgIMIBhBASAdQQxqIAcgCBDtH0UEQCAGQQM6AIwRQQIhCgwHCyAVIBUoAgAgHSgCDGoiADYCAAsgAyAESQ0CAn8gAiAEQQJ0aiECIAMgBGshB0EAIQkjAEEQayIIJAACQAJAAkACQAJAAkACQCAAQQVJBEACQAJAAkACQAJAIABBAWsOBAECAwQACyAHRQ0FIAJBADoAAiACIBQvAQA7AQBBASEEDAsLIAdFDQUgAkEBOgACIAdBAUYNBiACQQE6AAYgAiAULwECIgAgFC8BACIBIAAgAUsbOwEEIAIgACABIAAgAUkbOwEAQQIhBAwKCyAHRQ0GIAJBAToAAiACIBQvAQAiADsBACAHQQNJDQcgAiAAOwEIIAJBAToACgJAIBQvAQQiASAULwECIgBNBEAgAiABOwEEIAdBA0cNAUEDQQNBxOfzABDDIQALIAIgADsBBCABIQAgB0EDRg0JCyACQQI6AA4gAkECOgAGIAIgADsBDEEEIQQMCQsgCCAULwEGOwEOIAggFC8BBDsBDCAIIBQoAQA2AQhBAiEEA0AgCEEIaiAJQQF0aiIKLwEAIQEgBCEAA0AgCEEIaiAAaiILLwEAIgMgAUH//wNxSQRAIAsgATsBACAKIAM7AQAgAyEBCyAAQQJqIgBBCEcNAAsgBEECaiEEIAlBAWoiCUEDRw0ACyACQQJqIQFBACEAAkADQCAAIAdGDQEgAUECOgAAIAFBBGohASAAQQFqIgBBBEcNAAsgAiAILwEIOwEAIAIgCC8BCjsBCCACIAgvAQw7AQQgAiAILwEOOwEMQQQhBAwJCyAHIAdBlOjzABDDIQALIBQvAQAhBCAULwECIQMgFC8BBiIAIBQvAQQiASAAIAFLGyEJIAAgASAAIAFJGyEKQQAhACACIQECQANAIAAgB0YNASABIAQ7AQAgAUECaiAAQQFxQQFqOgAAIAFBBGohASAAQQFqIgBBB0cNAAsgAiADOwEUIAIgCjsBDCACIAM7AQRBCCEEIAdBCE8EQCACQQM6AB4gAkEDOgAOIAIgCTsBHAwJC0EHIAdB5OjzABDDIQALIAcgB0GU6fMAEMMhAAtBgObzAEEiQaTm8wAQnykAC0EAQQBBtObzABDDIQALQQBBAEHU5vMAEMMhAAtBAUEBQeTm8wAQwyEAC0EAQQBBhOfzABDDIQALQQIgB0Gk5/MAEMMhAAtBA0EDQdTn8wAQwyEACwJAAkAgBEGAAkcEQANAIAQEQEEAIQEgByAEayIAQQAgACAHTRshAyAEQQJ0IQkgAiEAA0AgASAHRg0EIAEgA0YNBSAAIAlqIgogAC8BADsBACAKQQJqIABBAmotAAA6AAAgAEEEaiEAIAQgAUEBaiIBRw0ACwsgBEEBdCIEQYACRw0ACwsgCEEQaiQAQYACDAILIAcgB0H06PMAEMMhAAsgASAEaiAHQYTp8wAQwyEACyEAIAUEQCAFIAA2AgALIAZBADoAjBFBASEKDAULAn8gBigC/A8iCUETSQRAIAYoArgQIREgBigCvBAhDQJAIAlBEkYNACAGQaANaiESIAZB8hBqIRMgBkHwDWohDANAIAkiAEEBaiEJIABBrKDzAGotAAAhDgJAAkADQCAGKAL4DSIKQcEAa0F8SQ0BIAwgByAIEMsgDQALQcAAIAYoAvgNIgprQQAhDyAKQcAARwRAIAwpAwAgCkE/ca2Ip0EPcSEPCyAPQdCg8wBqLQAAIgtPDQEgBkEEOgCMESAGIA02ArwQIAYgETYCuBAgBiAANgL8D0ECDAULIAwpAwAgCkE/ca2Ip0EPcSIPQdCg8wBqLQAAIQsLIAYgCiALajYC+A0CQAJAIA5BEU0EQCAOIBNqIA9B4KDzAGotAAAiADoAACAARQ0CIABBD0sNASASIABBAXRqIgogCi8BAEEBajsBACARQQFqIREgDUEgIAB2ayINQSFrQWBPDQIMBAsgDkESQfCg8wAQwyEACyAAQRBBgKHzABDDIQALIAlBEkcNAAsLQQFBekEBIA0bIBFBAUYbDAELIAlBEkHAoPMAELE7AAsiCkEBRw0EQQAhCSMAQeAAayILJAAgC0EAQcgA/AsAIAtB3ABqQQA2AgAgC0HUAGpCADcCACALQgA3AkxBfyEPIBdBAmohDiALQcwAaiEMAkACQAJAAkADQCAJQQ9GDQEgDCAPIA4vAQBqIg82AgAgDkECaiEOIAxBBGohDCAJQQFqIglBBUcNAAtBESEJIAtBETYCSEEAIQwCQAJAA0ACQAJAAkAgCUESSQRAIAkgEGotAAAiAEEGTw0BIAtByABqIABBAnRqIgAgACgCACIAQQFrNgIAIABBEk8NAyALIABBAnRqIAk2AgAgDEEBaiIMQQZHDQJBACEMIAkNAiALKAJIRQRAIAsoAgAhAEEAIQkDQCAGIAlqIgogADsBACAKQQJqQQA6AAAgCUEEaiIJQYABRw0ACwwJCyAGQYIBaiEcQYABIQxBASENQQAhAEEAIQpBAiEPAkADQCAXIA1BAXRqLwEAIhEEQEESIAAgAEESTRshEkEAIA9rIR8gHCAPQQJ0IglrISBBACAJayEhIAAhCQNAIAkgEkYNAyAKQYACTw0JIAlBAWohACALIAlBAnRqKAIAISIgHyAKQYDg8wBqLQAAIhNqISMgICATQQJ0aiEJQSAhDgNAIA4gI2pBIE8NCyAJIA06AAAgCUECayAiOwEAIAkgIWohCSAOIA9rIg5BAEoNAAsgCiAMaiEKIAAhCSARQQFrIhENAAsLIA1BBUYNCiAPQQF0IQ8gDEEBdiEMIA1BAWoiDUEQRw0ACwwKCyASQRJB0OLzABDDIQALIAlBEkHg4vMAEMMhAAsgAEEGQfDi8wAQwyEACyAJQQFrIQkMAQsLIABBEkGA4/MAEMMhAAsgCkGAAkGA4vMAEMMhAAsgEyAPayAOakEgQZDi8wAQwyEACyAJQQFqQRBBkOPzABDDIQALIAtB4ABqJAAMAQtBEEEQQcDi8wAQwyEACyAeQgA3AwAgF0EQakIANwMAIBdBCGpCADcDACAXQgA3AwBBcCEAQQAhCgJAA0AgCiAZaiAANgIAIAAgBigCwBBqIglB0AVPDQEgFCAJQQF0akH//wM7AQAgAEEBaiEAIApBBGoiCkHAAEcNAAsgBkIANwK0ECAGQYCAAjYCvBAgBkKAgICAgAE3ApwQQQUhAAwECyAJQdAFQaCh8wAQwyEAC0ECIQojAEEgayIQJAAgECAGKAK0ECIRNgIMIBAgBigCuBAiDzYCECAQIAYoArwQIgs2AhQgECAGKAKgECINNgIYIBAgBigCnBAiCTYCHCAGQfANaiEAAkAgBigC+A1BwABGBEBBAiEMIAAgByAIEMsgRQ0BC0EBIQwCQCALRSABIBFNcg0AIAYgBigCgA5BBE8EfyAGQYABaiENIAZBoA1qIQ8gBkGAAmohDgNAAkACQAJAIAAoAggiCUEgTwRAIAAgCUEgczYCCCAAKAIMIgtBBGohCSALQXtLDQEgCCAJSQ0CIAApAwAhJCAAIAk2AgwgACAAKAIQQQRrNgIQIAAgByALajUAAEIghiAkQiCIhDcDAAsMAgsgCyAJQZiq+wAQsTsACyAJIAhBmKr7ABCwOwALIAYgBigC+A0iCSAGIAYpA/ANIiQgCUE/ca2Ip0EfcUECdGoiCS0AAmoiCzYC+A0CQCAJLwEAIglBEE8EQCAGIAtBAkEDIAlBEEYbIhFqNgL4DSAJIBFBAnRB+JzzAGooAgAgJCALQT9xrYincSABIBBBDGogEEEQaiAQQRRqIBBBGGogEEEcaiAOIAYoAsAQIA8gDRCbEAwBCyAJIBBBDGogEEEQaiAQQRRqIBBBGGogDiAGKALAECAPIA0QlxgLIBAoAhQiC0UgECgCDCIRIAFPcg0CIAYoAoAOQQNLDQALIBAoAhwhCSAQKAIYIQ0gECgCEAUgDws2ArgQIAYgETYCtBAgBiANNgKgECAGIAk2ApwQQQIhDAsgBiALNgK8EAsgEEEgaiQAIAxBAkYEQEEBIRUCQCAGKAK0ECABTw0AIAYoArwQRQ0AIAZBvBBqIQkgBkG0EGohCyAGQYABaiENIAZBoA1qIQ8gBkGAAmohDiAGQZwQaiEYIAZBoBBqIRIgBkG4EGohEyAGQfANaiEWAkADQAJAAkACQEHAACAGKAL4DSIAayIZIAYgBikD8A0gAEE/ca2Ip0EAIABBwABHGyIaQR9xQQJ0aiIRLQACIhBPBEAgES8BACIRQRBPDQEgBiAAIBBqNgL4DSARIAsgEyAJIBIgDiAGKALAECAPIA0QlxgMAgsgFiAHIAgQyyANAQwECyARQQ5rIgxBIU8NASAZIAwgEGoiG08EQCAGIAAgG2o2AvgNIBEgDEECdEH4nPMAaigCACAaIBB2cSABIAsgEyAJIBIgGCAOIAYoAsAQIA8gDRCbEAwBCyAWIAcgCBDLIEUNAwsgCygCACABTw0DIAkoAgANAQwDCwsgDEEhQfyd8wAQwyEAC0ECIRULIBVBAUcNBAtBeSEKIAYoArwQDQMgAyAESQ0BAn8gAiAEQQJ0aiEQIAMgBGshDkEAIRICQCAGKALAECITQQFrIgBB0AVJBH8gE0EBdCAUakECayEAQQ8hEQNAIAAvAQBB//8DRw0CIABBAmshACATIBFBAWsiEWoiAUEQa0HQBUkNAAsgAUEQawUgAAtB0AVBgOXzABDDIQALQQEgEXRBgAIiBCARQQhIGyEIQQggESARQQhKGyEDQYABIQ9BASELQQIhDAJAAkACQAJAAkACQANAAkAgFyALQQF0ai8BACIKRQ0AIAggDGshB0EAIAxrIQkgC0EQayENQQAgDEECdGshFQJAA0AgDSATaiIAQdAFTwRAIABB0AVB8OXzABDDIQALIBJBgAJJBEAgFCAAQQF0ai8BACENIAkgEkGA4PMAai0AACICaiEWIBAgAiAHakECdGohACAIIQEDQCABIBZqIA5PDQMgACANOwEAIABBAmogCzoAACAAIBVqIQAgASAMayIBQQBKDQALIA8gEmohEiAKQQFrIgoNAQwDCwsgEkGAAkGA4vMAEMMhAAsgAiAMayABaiAOQZDi8wAQwyEACyADIAtBAWoiC0gEQCAIQYACRwRAA0AgCEEASgRAQQAhASAOIAhrIgBBACAAIA5NGyECIAhBAnQhAyAQIQADQCABIA5GDQcgASACRg0IIAAgA2oiByAALwEAOwEAIAdBAmogAEECai0AADoAACAAQQRqIQAgCCABQQFqIgFHDQALCyAIQQF0IghBgAJHDQALCyARQQhKDQJBgAIMCAsgDEEBdCEMIA9BAXYhDyALQRBHDQALQRBBEEGQ5fMAEMMhAAtBgAEhD0EJIQAgF0ESaiEJQQAhCEGAAiEWQQIhDEEIIQFBgAIhCgJAA0AgACICQRBPDQYgFyAAQQF0aiIYLwEAIhUEQEEBIABBCGsiC3QhA0EAIAxrIRkgAUEPayENQQAgDEECdGshGiAAQQ5KIRsDQAJAAkAgCkGAAkYEQCADIQAgCyEHIBtFBEAgCSEBIAIhACADIQcDQAJAAkAgAEEQRwRAIAcgAS8BAGsiB0EASg0BIAAhCgwCC0EQQRBBoOLzABDDIQALIAFBAmohASAHQQF0IQdBDyEKIABBAWoiAEEPRw0BCwtBASAKQQhrIgd0IQALIBJBgAJPDQkgDiASQYDg8wBqLQAAIgFLDQEgASAOQbDl8wAQwyEACyANIBNqIgFB0AVPDQUgCkGAAkkNASAKQYACQYDi8wAQwyEACyAQIAFBAnRqIgogBCAIaiIIIAFrOwEAIAogB0EIajoAAiANIBNqIgFB0AVPDQQgACAWaiEWIBJBAWohEkEAIQogACEECyAQIApBgODzAGotAAAiByAIIBlqaiIeIARqQQJ0aiEAIBQgAUEBdGovAQAhDSAEIQEDQCABIB5qIA5PDQggACANOwEAIABBAmogCzoAACAAIBpqIQAgASAMayIBQQBKDQALIBggFUEBayIVOwEAIAogD2ohCiAVQf//A3ENAAsLIAlBAmohCSAPQQF2IQ8gDEEBdCEMIAIiAUEBaiIAIBFMDQALIBYMBgsgAUHQBUHA5fMAEMMhAAsgDiAOQdDl8wAQwyEACyABIAhqIA5B4OXzABDDIQALIBJBgAJBgOLzABDDIQALIAggDGsgB2ogAWogDkGQ4vMAEMMhAAsgAkEQQaDl8wAQwyEACyEAIAUEQCAFIAA2AgALIAZBADoAjBFBASEKDAMLIAQgA0GQofMAEK87AAsgBCADQbCh8wAQrzsACyAGIAA6AIwRDAELCyAdQRBqJAAgCgvSBQEGfyMAQSBrIgMkACADIAE2AgACQAJAIAFBgAJGBEAgAkEPcSEEIAJB/wFxIgFBBHQhBiAAIAFBBXRqIQUDQCAEQQFqIQRBACEBIAYhAgNAIAJB/wFLDQMgASAFaiIHIAcvAQAgAUH089EAai8BAGo7AQAgAkEBaiECIAFBAmoiAUEgRw0ACyAFQSBqIQUgBkEQaiEGIARBEEcNAAtBACEFIAAhBkEAIQQDQCAEQQFqQXAhAiAGIQECQAJAA0ACQAJAIARFBEAgAS8BAA0BIANBADYCCCABIANBCGpBxPPRABCNKwALIAIgBWoiCEH/AUsNASABLwEAIAFBIGsvAQBGDQMLIAFBAmohASACQQFqIgINAQwDCwsgCEGAAkHU89EAEMMhAAsgA0EAOwEEIANBADYCCCADQQRqIANBCGpB5PPRABCNKwALIAZBIGohBiAFQRBqIQUiBEEQRw0AC0EAIQUgACEEDAILIANBADYCCEEAIANBvPHRACADQQhqQaT00QAQrysACyACQYACQZT00QAQwyEACwNAIAAgBUEBdCIBakHgA2ovAQAgAUGE89EAai8BAE8EQEFgIQIgBCEBA0AgASACQcTz0QBqLwEAIAEvAQBqIgYgBkH8/wNxQQJ2azsBACABQSBqIQEgAkECaiICDQALCyAEQQJqIQQgBUEBaiIFQRBHDQALQQAhBUEAIQQDQCAEQQFqQXAhAiAAIQECQAJAA0ACQAJAIARFBEAgAS8BAA0BIANBADYCCCABIANBCGpB1PLRABCNKwALIAIgBWoiB0H/AUsNASABLwEAIAFBIGsvAQBGDQMLIAFBAmohASACQQFqIgINAQwDCwsgB0GAAkHk8tEAEMMhAAsgA0EAOwEGIANBADYCCCADQQZqIANBCGpB9PLRABCNKwALIABBIGohACAFQRBqIQUiBEEQRw0ACyADQSBqJAALjQYBCX8jAEGQAWsiAyQAIAMgAiABayIEQQN2Igs2AmQgA0HoAGogC0EHakEDdhDSH0HAACEFAn8CQAJAIARBAXYiCUHA////B3FBQGsgCSAEQf4AcRsiB0HAABDRNARAIAcEQCAHQcAAEK02IgVFDQILIAMoAnAhCCABIAJGBEAgBSEEQQAMBAsgBSEEA0ACQCABKAIABEAgBCABQQRqKAIANgIAIAggBkEDdmoiCiAKLQAAQQEgBkEHcXRyOgAADAELIARBADYCAAsgBkEBaiEGIARBBGohBCACIAFBCGoiAUcNAAsMAgtB5JSAAUEpIANB+ABqQciXgAFBkJWAARDVHgALQcAAIAcQoz0ACyADKAJkCyEBIAMgBCAFa0ECdSICNgJYAkACQCABIAJGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAINgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIIKQIANwIAIAFBGGogA0GIAWoiCigCADYCACADIAc2AogBIANCgICAgIAINwKAASADIAk2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAIKQIANwIAIAJBGGogCigCADYCACADIAQ2AmAgAyAGNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAk2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkGAkoABIAsgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQwxMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALlQUCBH4CfyMAQeAAayIHJAAgAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIIQStrDgMCAQIBCyABLQAAIQgLAkACQAJAAkACQAJAAkACQAJAIAhB/wFxQStrDgMAAgECCyACQQFrIQggAUEBaiEBIAJBIUkNAiAIIQIMBgsgAkEBayEIIAFBAWohASACQSFPBEADQCAIRQ0IIAdBADYCXCAHQUBrIAQgA0IKQgAgB0HcAGoQ9gwgAS0AAEEwayICQQlLDQkgBygCXA0EIAFBAWohASAIQQFrIQggBykDQCIDIAKtIgZ9IQQgBykDSCIFIAUgBSADIAZUrX0iA4WDQgBZDQALIABBAzoAAUEBDAoLIAhFDQQDQCABLQAAQTBrIgJBCUsNCCAHQTBqIAQgA0IKQgAQqB4gAUEBaiEBIAcpAzAiAyACrSIFfSEEIAcpAzggAyAFVK19IQMgCEEBayIIDQALDAYLIAJBH0sNBAwCCyAIIgJFDQIMAQsgAEEDOgABQQEMBgsDQCABLQAAQTBrIghBCUsNBCAHIAQgA0IKQgAQqB4gAUEBaiEBIAcpAwggBykDACIDIAitfCIEIANUrXwhAyACQQFrIgINAAsMAgsMAQsDQCACRQ0BIAdBADYCLCAHQRBqIAQgA0IKQgAgB0EsahD2DCABLQAAQTBrIghBCUsNAiAHKAIsDQMgAUEBaiEBIAJBAWshAiAHKQMYIgVCf4UgBSAFIAcpAxAiAyAIrXwiBCADVK18IgOFg0IAWQ0ACyAAQQI6AAFBAQwDCyAAIAQ3AxAgACADNwMYQQAMAgsgAEEBOgABQQEMAQsgAEECOgABQQELOgAAIAdB4ABqJAALhwUCDH8CfiMAQSBrIgUkACAFQQA2AhQgBUKAgICAgAE3AgwCQCABKAIIIgZFDQAgBSABKAIEIgQtAAQiDDoAHCAFIAQoAgA2AhggA0UNACACIANBGGxqIQ0gBCAGQQN0aiEPIAJBGGohASAEQQhqIQkgBUEYaiEDQQAhBgNAAkACQAJAAkACQCADLQAEIgsgB0EBcXIEQAJAIAYEQCABIQQgCCEBDAELIAEgDUYEQEEBIQYMBQsgAUEYaiEEQQEhBgsgAQ0BIAQhAQwDCyACKQMAIhAgAjQCEHwhESAFKAIMIA5GBEAgBUEMakHsgM0AEJUoCyAFKAIQIA5BBHRqIgQgETcDCCAEIBA3AwAgBSAOQQFqIg42AhQCQCAGBEAgASEEIAghAQwBCyABIA1GBEBBASEGQQAhCEEBIQcMBQsgAUEYaiEEQQEhBgtBASEHIAFFDQELAn8CQCADKAIAIApqIgsgASIIKAIIIgpNBEAgCiALRg0BIAQMAgsgAyALIAprNgIAIAZBACEGBEAgBCEBQQAhByAIIQIMBgtBACAEIAQgDUYiARshAiAEQQBBGCABG2ohAUEAIQcMBQsgBkEAIQYEQEEAIQcgCCECIAQMAQtBACAEIAQgDUYiARshAkEAIQcgBEEAQRggARtqCyEBIAshCgwCC0EAIQggBCEBDAELIAtBAXMgB3IhB0EAIQgLAn8gCSAPRgRAQQIhDCAPDAELIAktAAQhDCAJKAIAIQMgCUEIagshCSAFIAw6ABwgBSADNgIYCyACRQ0BQQAgBUEYaiAMQQJGIgQbIQMgBEUNAAsLIAAgBSkCDDcCACAAQQhqIAVBFGooAgA2AgAgBUEgaiQAC9AGAgd/AX4jAEEwayICJAACfyMAQRBrIgMkAAJAIAEtAAwEf0EABSADAn4CQCABKAIIIgVFDQAgASgCBCEEIAVBAnQhBQNAIAQoAgBFBEAgCUIgfSEJIARBBGohBCAFQQRrIgUNAQwCCwsgAyAEKAIAaK0gCX03AwhCAQwBC0IACzcDACADKAIARQ0BIAMpAwhQCyADQRBqJAAMAQtB+KWIAUEcQZSmiAEQyyQACyEDAkAgASgCBCIEIAEgASgCAEGAgICAeEYiBRsoAggEQCACQRBqIAFBAEEBEJUJDAELIAVFBEAgAkEYaiABQQhqKAIANgIAIAIgASkCADcDEAwBCyACQRBqIAQQ6R0LAkAgA0UNACACKAIYIgZFBEAgAigCEEUEQCACQRBqQayKiAEQnSgLIAIoAhRBADYCACACQQE2AhhBASEGCyACIAIoAhQiA0EEaiIFNgIkIAIgAzYCICACQSBqEJ42IgRFDQAgBEEARyEEA0AgAyAHIAMoAgBBAWoiCGoiBzYCACAIRSAHIAhJciEHIANBBGohAyAEQQFrIgQNAAsgB0UNACAGQQJ0QQRrIQMDQCADBEAgBSAFKAIAQQFqIgQ2AgAgA0EEayEDIAVBBGohBSAERQ0BDAILCyACKAIYIgMgAigCEEYEQCACQRBqQbyKiAEQnSgLIAIoAhQgA0ECdGpBATYCACACIANBAWo2AhgLIAJBKGogAkEYaigCADYCACACIAIpAxA3AyACQCABLQAMIgFBAUcEQCABQQEgAigCKBshAwwBCyACQQA2AiggAkEgakEEQQQQniQCQCACKAIoIgRFDQAgAigCJCIBIARBAnQiA2pBBGsiBUUNACAFKAIADQAgAUEEayEFIARB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAVqIANBBGshAygCAEUNAAsgAUEBaiIDIARLDQELIAIgAzYCKCADIQQLQQEhAyAEIAIoAiBBAnZPDQAgAkEIaiACQSBqIARBBEEEEPQUIAIoAggiAUGBgICAeEYNACABIAIoAgxBzI2IARD9LwALIAAgAikDIDcCACAAIAM6AAwgAEEIaiACQShqKAIANgIAIAJBMGokAAvvBQIEfwV+IwBBgAFrIgQkACABvSEIAn9BAyABmUQAAAAAAADwf2ENABpBAiAIQoCAgICAgID4/wCDIglCgICAgICAgPj/AFENABogCEL/////////B4MiDEKAgICAgICACIQgCEIBhkL+////////D4MgCEI0iKdB/w9xIgUbIgpCAYMhCyAJUARAQQQgDFANARogBUGzCGshBUIBIQkgC1AMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIGGyEKQgJCASAGGyEJQct3Qcx3IAYbIAVqIQUgC1ALIQcgBCAFOwF4IAQgCTcDcCAEQgE3A2ggBCAKNwNgIAQgBzoAegJ/AkACQAJAAkACQCAHQf8BcSIGQQFNBEAgA0H//wNxIQcgBEEgaiAEQeAAaiAEQQ9qEP8CQe7riQFBASAIQgBTIgMbIQVB7uuJAUHv64kBIAMbIQYgCEI/iKchAyAEKAIgRQ0BIARB2ABqIARBKGooAgA2AgAgBCAEKQIgNwNQDAILIAZBAkYNA0EBIQVB7uuJAUHv64kBIAhCAFMiBhtB7uuJAUEBIAYbIAIbIQZBASAIQj+IpyACGyECIAdB/wFxQQRGDQIgBEEDNgIoIARB8+uJATYCJCAEQQI7ASAgBEEgagwFCyAEQdAAaiAEQeAAaiAEQQ9qEJQBCyAGIAUgAhshBkEBIAMgAhshAiAEIAQoAlAgBCgCVCAELwFYIAcgBEEgahDtDyAEKAIEIQUgBCgCAAwDC0ECIQUgBEECOwEgIANB//8DcUUNASAEQQE2AjAgBEEAOwEsIARBAjYCKCAEQcXriQE2AiQgBEEgagwCCyAEQQM2AiggBEHw64kBNgIkIARBAjsBIEEBIQZBACECQQEhBSAEQSBqDAELQQEhBSAEQQE2AiggBEH264kBNgIkIARBIGoLIQcgBCAFNgJcIAQgBzYCWCAEIAI2AlQgBCAGNgJQIAAgBEHQAGoQtQogBEGAAWokAAvRBQIOfwJ+IwBBgAFrIgIkACABKAIEIQsgAkHwAGogASgCCCIIQQBBCEHQABCgGCACKAJ0IQEgAigCcEEBRwRAIAIoAnghCQJAIAFFDQAgCEHQAGwhDCABIQoDQCAGIAxGDQFBACEEQQAhBSAGIAtqIgNBEGooAgBBAUYEQAJAIANBFGooAgAiBQRAIAJB4ABqIANBIGogA0EYaigCACADQRxqKAIAIAUoAgARBQAMAQsgAkEANgJgC0EBIQULIANBJGooAgBBAUYEQAJAIANBKGooAgAiBARAIAJB8ABqIANBNGogA0EsaigCACADQTBqKAIAIAQoAgARBQAMAQsgAkEANgJwC0EBIQQLQgAhECADKAIAQQFGBEAgA0EIaikDACERQgEhEAsCQCADQThqIgcoAgBBgICAgHhHBEAgAkHIAGogBxClHQwBCyACQYCAgIB4NgJICwJAIANBxABqIgMoAgBBgICAgHhHBEAgAkHUAGogAxClHQwBCyACQYCAgIB4NgJUCyACQUBrIgcgAkHoAGopAgA3AwAgAiACKQJgNwM4IAJBMGoiDSACQfgAaikCADcDACACIAIpAnA3AyggAkEgaiIOIAJB0ABqKAIANgIAIAIgAikCSDcDGCACQRBqIg8gAkHcAGooAgA2AgAgAiACKQJUNwMIIAYgCWoiA0EQaiAFNgIAIANBCGogETcDACADIBA3AwAgA0EkaiAENgIAIANBFGogAikDODcCACADQRxqIAcpAwA3AgAgA0EoaiACKQMoNwMAIANBMGogDSkDADcDACADQThqIAIpAxg3AwAgA0FAayAOKAIANgIAIANBxABqIAIpAwg3AgAgA0HMAGogDygCADYCACAGQdAAaiEGIApBAWsiCg0ACwsgACAINgIIIAAgCTYCBCAAIAE2AgAgAkGAAWokAA8LIAEgAigCeEHQtcIAEP0vAAv/BQEGfyMAQZABayIEJAACQAJAAkACQAJAAkACQAJAIAEoAgAiBSgCACIGIAUoAggiCGtBH00EQCAGIAEoAggiB0YgB0EfS3ENASABIAg2AgQgBUEgEOUtCyAEQQhqIgcgARDhICAEKAIQIgUgBCgCDCIGSw0BIARBIGogAiADIAcQmg4gBCAEKAAhNgIYIAQgBEEkaigAADYAGyAEKAIQIgMgBCgCDCICSw0CIAQtACAhAiADIAVrIQMMBwsgBEEANgJQIARCIDcCSCAEIARBIGo2AkQgBEHgAGogAiADIARBxABqEJoOIAQgBCgAYTYCGCAEIARB5ABqKAAANgAbIAQoAkwiAyAEKAJIIgJLDQIgBC0AYCECIAQoAkQhCSAEQQhqIAEQ4SAgBCgCDCIIIAQoAhAiBmsiByADSQRAIAUoAgAgBSgCCCIGa0EfTQRAIAEgBjYCBCAFQSAQ5S0LIARBCGogARDhICAEKAIMIgggBCgCECIGayEHCyADIAdLDQMgAyAGaiIFIAZJDQQgBSAISw0FIAMEQCAEKAIIIAZqIAkgA/wKAAALIAUgBCgCFEsEQCAEIAU2AhQLIAQgBTYCEAwGCyAFIAZB8M3DABCwOwALIAMgAkHwzcMAELA7AAsgAyACQfDNwwAQsDsACyAEIAM2AnggBCAHNgJ8IARBAjYCZCAEQdDOwwA2AmAgBEICNwJsIARBOzYCjAEgBEE7NgKEASAEIARBgAFqNgJoIAQgBEH8AGo2AogBIAQgBEH4AGo2AoABIARB4ABqQZjNwwAQ7ywACyAGIAVBmM3DABCxOwALIAUgCEGYzcMAELA7AAsgBEEoaiAEQRBqKQIANwMAIAQgBCkCCDcDICAEQdQAaiIHIARBIGoQ5iUgASAHENojAkACQAJAAkAgAkH/AXFBBGsOAgIAAQsgAEEFOgAADAILIAAgBCgCGDYAASAAIAI6AAAgAEEEaiAEKAAbNgAADAELIAAgAzYCBCAAQQQ6AAALIARBkAFqJAAL/wUBBn8jAEGQAWsiBCQAAkACQAJAAkACQAJAAkACQCABKAIAIgUoAgAiBiAFKAIIIghrQR9NBEAgBiABKAIIIgdGIAdBH0txDQEgASAINgIEIAVBIBDlLQsgBEEIaiIHIAEQ4SAgBCgCECIFIAQoAgwiBksNASAEQSBqIAIgAyAHEJEOIAQgBCgAITYCGCAEIARBJGooAAA2ABsgBCgCECIDIAQoAgwiAksNAiAELQAgIQIgAyAFayEDDAcLIARBADYCUCAEQiA3AkggBCAEQSBqNgJEIARB4ABqIAIgAyAEQcQAahCRDiAEIAQoAGE2AhggBCAEQeQAaigAADYAGyAEKAJMIgMgBCgCSCICSw0CIAQtAGAhAiAEKAJEIQkgBEEIaiABEOEgIAQoAgwiCCAEKAIQIgZrIgcgA0kEQCAFKAIAIAUoAggiBmtBH00EQCABIAY2AgQgBUEgEOUtCyAEQQhqIAEQ4SAgBCgCDCIIIAQoAhAiBmshBwsgAyAHSw0DIAMgBmoiBSAGSQ0EIAUgCEsNBSADBEAgBCgCCCAGaiAJIAP8CgAACyAFIAQoAhRLBEAgBCAFNgIUCyAEIAU2AhAMBgsgBSAGQfDNwwAQsDsACyADIAJB8M3DABCwOwALIAMgAkHwzcMAELA7AAsgBCADNgJ4IAQgBzYCfCAEQQI2AmQgBEHQzsMANgJgIARCAjcCbCAEQTs2AowBIARBOzYChAEgBCAEQYABajYCaCAEIARB/ABqNgKIASAEIARB+ABqNgKAASAEQeAAakGYzcMAEO8sAAsgBiAFQZjNwwAQsTsACyAFIAhBmM3DABCwOwALIARBKGogBEEQaikCADcDACAEIAQpAgg3AyAgBEHUAGoiByAEQSBqEOYlIAEgBxDaIwJAAkACQAJAIAJB/wFxQQRrDgICAAELIABBBToAAAwCCyAAIAQoAhg2AAEgACACOgAAIABBBGogBCgAGzYAAAwBCyAAIAM2AgQgAEEEOgAACyAEQZABaiQAC9sFAgd/AX4CfyABRQRAIAAoAgghB0EtIQsgBUEBagwBC0ErQYCAxAAgACgCCCIHQYCAgAFxIgEbIQsgAUEVdiAFagshCQJAIAdBgICABHFFBEBBACECDAELAkAgA0EQTwRAIAIgAxDWByEBDAELIANFBEBBACEBDAELIANBA3EhCgJAIANBBEkEQEEAIQEMAQsgA0EMcSEMQQAhAQNAIAEgAiAIaiIGLAAAQb9/SmogBkEBaiwAAEG/f0pqIAZBAmosAABBv39KaiAGQQNqLAAAQb9/SmohASAMIAhBBGoiCEcNAAsLIApFDQAgAiAIaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAlqIQkLAkAgAC8BDCIIIAlLBEACQAJAIAdBgICACHFFBEAgCCAJayEIQQAhAUEAIQkCQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgCCEJDAELIAhB/v8DcUEBdiEJCyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAJQf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBECAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQ4ioNA0EAIQEgCCAJa0H//wNxIQIDQCABQf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAgBFDQALDAMLQQEhBiAAIAcgCyACIAMQ4ioNAiAAIAQgBSAHKAIMEQYADQJBACEBIAggCWtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEBaiEBIAAgCiAHKAIQEQIARQ0ACwwCCyAHIAQgBSAKKAIMEQYADQEgACANNwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIgAxDiKg0AIAEgBCAFIAAoAgwRBgAhBgsgBguIBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBAWoiBEF/IAQbIgUgAygCQCIEKAIETQRAIAQgBCgCFEEBaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgJ0DAILIANBiICAgHg2AnQMAQsgA0H0AGogASAFEL8vCyADQQo2AqgBIANB/Ob+ADYCpAEgA0GAgICAeDYCoAEgAyABNgKcASADQQE2ApgBIANB0ABqIANB9ABqIANBmAFqEIEUIAMoAlAiBUGKgICAeEYNASADQaABaiADQewAaikCADcDACADIAMpAmQ3A5gBIAMoAlghASADKAJUIQQgAykCXAshBiADQShqIANBoAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA5gBNwIgDAELIAMoAkAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBCTYChAEgA0H26f4ANgKAASADQYCAgIB4NgJ8IAMgAjYCeCADQQI2AnQgACADQQxqIANB9ABqEIEUIANBsAFqJAAL+gUBCX8jAEGQAWsiAyQAIAMgAiABayIEQQR2Igk2AmQgA0HoAGogCUEHakEDdhDSH0HAACEFAkACQCAEQQF2IgpBwP///wdxQUBrIAogBEH+AHEbIgdBwAAQ0TQEQCAHBEAgB0HAABCtNiIFRQ0CCyADKAJwIQggBSEEIAEgAkYNAgNAAkAgASgCAARAIAQgAUEIaikDADcDACAIIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwALIAZBAWohBiAEQQhqIQQgAUEQaiIBIAJHDQALDAILQeSUgAFBKSADQfgAakHIl4ABQZCVgAEQ1R4AC0HAACAHEKM9AAsgAyAEIAVrQQN1IgE2AlgCQAJAIAEgCUYEQCADKAJ0IQQgAyADKQJoNwKEASADQQA2AoABIAMgBDYCfCADIAg2AnggA0EIaiADQfgAaiICENc7IAMoAgghBkEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIANBgAFqIggpAgA3AgAgAUEYaiADQYgBaiILKAIANgIAIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgCjYCfCADIAU2AnggAyACENc7IAMoAgAhBUEcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgAykCeDcCCCACQRBqIAgpAgA3AgAgAkEYaiALKAIANgIAIAMgBDYCYCADIAY2AlwgAyABNgJYQQxBBBCtNiIBRQ0CIAEgCjYCCCABIAU2AgQgASACNgIAIANBATYCcCADIAE2AmwgA0EBNgJoIANBADYCgAEgA0KAgICAwAA3AnggA0EUaiICQdyRgAEgCSABIANB2ABqIANB6ABqIANB+ABqEIwTIAAgAhC3EyADQZABaiQADwsgA0IANwKEASADQoGAgIDAADcCfCADQcSRgAE2AnhBACADQdgAaiADQeQAaiADQfgAakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAvqBAIHfwF+IwBBEGsiCSQAAkAgBCAGaiABQQN0TQRAIAUgBmogA0EDdE0EQCAGRQRADAMLA0AgBCALaiIDQQdxIQEgA0EDdiEIIAUgC2oiB0EHcSEDIAdBA3YhCgJ/IAYgC2siB0E/TQRAIAdBAUYEQEEBIQcgACAIaiIIIAgtAAAgAiAKai0AACADdkEBcSIDIAF0cjoAACADRQwCCyAJQgA3AwhBwAAgASADIAEgA0sbayIMIAcgByAMSxsiByADaiIMQQN2IAxBB3FBAEdqIgwEQCAJQQhqIAIgCmogDPwKAAALIAkgCSkDCCADrYhCf0EAIAdrQT9xrYiDIAGthiIONwMIIAEgB2oiAUEDdiABQQdxQQBHaiIBBEBBByABQQFrIgEgAUEHTxtBAWohCiAAIAhqIQEgCUEIaiEDA0AgASABLQAAIAMtAAByOgAAIANBAWohAyABQQFqIQEgCkEBayIKDQALCyAHIA57p2sMAQsgAiAKaikAACEOAkACQCADBEAgAQ0BIAAgCGogDiADrYhC//////////8AgyIONwAAQTghB0E4IA57p2sMAwsgAUUNASAAIAhqIgMgDiABrYYiDiADMQAAhDcAAEHAACABayIHIA57p2sMAgsgACAIaiIHIA4gA62IIAGthiIOIAcxAACENwAAQcAAIAEgAyABIANLG2siByAOe6drDAELIAAgCGogDjcAAEHAACEHIA5Cf4V7pwsgDWohDSAHIAtqIgsgBkkNAAsMAgtB2PiHAUE1QZD5hwEQnykAC0GM+IcBQTxByPiHARCfKQALIAlBEGokACANC/QFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB//8DTQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKMLIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL8wUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H/AU0EQCAFQThqIgRBADYCACAFQoCAgIDAADcCMCAFQTBqIgZBARCGLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOkIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENovDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCiCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/MFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB/wBNBEAgBUE4aiIEQQA2AgAgBUKAgICAwAA3AjAgBUEwaiIGQQEQhi0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDpCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDaLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAv0BQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQf//A00EQCAFQThqIgRBADYCACAFQoCAgIDAADcCMCAFQTBqIgZBARCGLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOkIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENovDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCiCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/QFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB//8BTQRAIAVBOGoiBEEANgIAIAVCgICAgMAANwIwIAVBMGoiBkEBEIYtIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6QggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2i8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKILIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL9AUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H//wFNBEAgBUE4aiIEQQA2AgAgBUKAgICAgAE3AjAgBUEwaiIGQQEQhy0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDqCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDbLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQowsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAvyBQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQQBOBEAgBUE4aiIEQQA2AgAgBUKAgICAwAA3AjAgBUEwaiIGQQEQhi0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDpCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDaLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAvzBQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQf8BTQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKMLIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL8wUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H/AE0EQCAFQThqIgRBADYCACAFQoCAgICAATcCMCAFQTBqIgZBARCHLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOoIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENsvDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCjCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/IFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANBAE4EQCAFQThqIgRBADYCACAFQoCAgICAATcCMCAFQTBqIgZBARCHLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOoIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENsvDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCjCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC7kKAQV/IwBBIGsiBCQAIAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAQ4oAgEBAQEBAQEBAwUBAQQBAQEBAQEBAQEBAQEBAQEBAQEBAQgBAQEBBwALIAFB3ABGDQULIAJBAXFFIAFB/wVNcg0HQRFBACABQa+wBE8bIgIgAkEIciIDIAFBC3QiAiADQQJ0QZiTigFqKAIAQQt0SRsiAyADQQRyIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQJyIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEGYk4oBaigCAEELdCACSxsiA0ECdEGYk4oBaigCAEELdCIGIAJGIAIgBktqIANqIgZBAnRBmJOKAWoiBygCAEEVdiECQe8FIQMCQCAGQSBNBEAgBygCBEEVdiEDIAZFDQELIAdBBGsoAgBB////AHEhBQsCQCADIAJBf3NqRQ0AIAEgBWshBSADQQFrIQZBACEDA0AgAyACQYzPiQFqLQAAaiIDIAVLDQEgBiACQQFqIgJHDQALCyACQQFxRQ0HIARBDmpBADoAACAEQQA7AQwgBCABQRR2Qa7tiQFqLQAAOgAPIAQgAUEEdkEPcUGu7YkBai0AADoAEyAEIAFBCHZBD3FBru2JAWotAAA6ABIgBCABQQx2QQ9xQa7tiQFqLQAAOgARIAQgAUEQdkEPcUGu7YkBai0AADoAECABQQFyZ0ECdiICIARBDGoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQRRqIgMgAUEPcUGu7YkBai0AADoAACAAIAQpAQw3AAAgBEH9ADoAFQwICyAAQgA3AQIgAEHc4AA7AQAMCgsgAEIANwECIABB3OgBOwEADAkLIABCADcBAiAAQdzkATsBAAwICyAAQgA3AQIgAEHc3AE7AQAMBwsgAEIANwECIABB3LgBOwEADAYLIAJBgAJxRQ0BIABCADcBAiAAQdzOADsBAAwFCyACQf///wdxQYCABE8NAwsCf0EAIAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSABQcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSABQdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQeT+iQFBLEG8/4kBQdABQYyBigFB5gMQixAMAQsgAUHyhIoBQShBwoWKAUGiAkHkh4oBQakCEIsQCw0BIARBGGpBADoAACAEQQA7ARYgBCABQRR2Qa7tiQFqLQAAOgAZIAQgAUEEdkEPcUGu7YkBai0AADoAHSAEIAFBCHZBD3FBru2JAWotAAA6ABwgBCABQQx2QQ9xQa7tiQFqLQAAOgAbIAQgAUEQdkEPcUGu7YkBai0AADoAGiABQQFyZ0ECdiICIARBFmoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQR5qIgMgAUEPcUGu7YkBai0AADoAACAAIAQpARY3AAAgBEH9ADoAHwsgAEEIaiADLwEAOwAAQQoMAwsgACABNgIAQYABIQJBgQEMAgsgAEIANwECIABB3MQAOwEAC0EAIQJBAgs6AA0gACACOgAMIARBIGokAAvNBQIGfwN+IwBBgAFrIgQkACABvCEGAn9BAyABi0MAAIB/Ww0AGkECIAZBgICA/AdxIgVBgICA/AdGDQAaIAZB////A3EiCEGAgIAEciAGQQF0Qf7//wdxIAZBF3ZB/wFxIgcbIgmtIgpCAYMhCyAFRQRAQQQgCEUNARogB0GWAWshB0IBIQwgC1AMAQtCgICAECAKQgGGIAlBgICABEYiCBshCkICQgEgCBshDEHofkHpfiAIGyAHaiEHIAtQCyEFIAQgBzsBeCAEIAw3A3AgBEIBNwNoIAQgCjcDYCAEIAU6AHoCfwJAAkACQAJAAkAgBUH/AXFBAU0EQCADQf//A3EhAyAEQSBqIARB4ABqIARBD2oQ/wJB7uuJAUEBIAZBAEgiBRshB0Hu64kBQe/riQEgBRshBSAGQR92IQYgBCgCIEUNASAEQdgAaiAEQShqKAIANgIAIAQgBCkCIDcDUAwCCyAFQf8BcSIIQQJGDQNBASEFQe7riQFB7+uJASAGQQBIIgcbQe7riQFBASAHGyACGyEHQQEgBkEfdiACGyEGIAhBBEYNAiAEQQM2AiggBEHz64kBNgIkIARBAjsBICAEQSBqDAULIARB0ABqIARB4ABqIARBD2oQlAELIAUgByACGyEHQQEgBiACGyEGIAQgBCgCUCAEKAJUIAQvAVggAyAEQSBqEO0PIAQoAgQhBSAEKAIADAMLQQIhBSAEQQI7ASAgA0H//wNxRQ0BIARBATYCMCAEQQA7ASwgBEECNgIoIARBxeuJATYCJCAEQSBqDAILIARBAzYCKCAEQfDriQE2AiQgBEECOwEgQQEhB0EAIQZBASEFIARBIGoMAQtBASEFIARBATYCKCAEQfbriQE2AiQgBEEgagshAiAEIAU2AlwgBCACNgJYIAQgBjYCVCAEIAc2AlAgACAEQdAAahC1CiAEQYABaiQAC+oFAgh/AX4jAEGQAWsiBCQAIARBDGpBgAhBgAgQphQgBEHUAGogASACIAMQ2wEgBCgCXCEFIAQoAlghBgJAAkAgBCgCVCIHQZOAgIB4RwRAIAAgBCkCYCIMPgIMIAAgBTYCCCAAIAY2AgQgACAMQiCIPgIQIAAgBzYCAAwBCyAEIAU2AkQgBCAGNgJAIAQgAy0AMDYCSCABIAIoAjQRBAAhAwJAIAEgAigCJBEEACIKRQ0AIARBGGohCyAEQSRqIQZBACECAkADQAJAAkACQAJAIAMEQCACIAMoAhBPDQQgAygCBCACIAMoAgxqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyAEIAI2AlAgBCAEQUBrIgE2AkwgBEHUAGogBEHMAGogBEEMakGo/P8AENMVIAQoAlQiBUGTgICAeEYNASAAIAQpAlg3AgQgAEEMaiAEQeAAaikCADcCACAAIAU2AgAgARC8KgwHCyAGEOY6IAQoAiRFDQQgBCgCNEEBaiIHQQN2IAdBB3FBAEdqIgEgBCgCMCIFSwRAIAEgBWshCSAEKAIoIgggAUkEQCAGIAhBAXQiBSABQcD///8DcUFAayABIAFBP3EbIgggBSAISxsQ6BkgBCgCMCEFCyAJBEAgBCgCLCAFakEAIAn8CwALIAQgATYCMAsgBCAHNgI0IAQoAhQhBSAEKAIgIgEgBCgCGEYEQCALQcD0/wAQnSgLIAQoAhwgAUECdGogBTYCACAEIAFBAWo2AiAMAQsgBEEMakEBQQAQvRILIAogAkEBaiICRw0BDAMLC0HM9v8AQSBB7Pb/ABCfKQALQbj3/wAQsjsACyAEQdQAaiICIARBDGoQ7Q5BxABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABB0Pv/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEQUBrELwqCyAEQQxqELosIARBkAFqJAAPC0EEQcQAEKM9AAvqBQIIfwF+IwBBkAFrIgQkACAEQQxqQYAIQYAIEKUUIARB1ABqIAEgAiADENsBIAQoAlwhBSAEKAJYIQYCQAJAIAQoAlQiB0GTgICAeEcEQCAAIAQpAmAiDD4CDCAAIAU2AgggACAGNgIEIAAgDEIgiD4CECAAIAc2AgAMAQsgBCAFNgJEIAQgBjYCQCAEIAMtADA2AkggASACKAI0EQQAIQMCQCABIAIoAiQRBAAiCkUNACAEQRhqIQsgBEEkaiEGQQAhAgJAA0ACQAJAAkACQCADBEAgAiADKAIQTw0EIAMoAgQgAiADKAIMaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgBCACNgJQIAQgBEFAayIBNgJMIARB1ABqIARBzABqIARBDGpBmP3/ABDTFSAEKAJUIgVBk4CAgHhGDQEgACAEKQJYNwIEIABBDGogBEHgAGopAgA3AgAgACAFNgIAIAEQvCoMBwsgBhDmOiAEKAIkRQ0EIAQoAjRBAWoiB0EDdiAHQQdxQQBHaiIBIAQoAjAiBUsEQCABIAVrIQkgBCgCKCIIIAFJBEAgBiAIQQF0IgUgAUHA////A3FBQGsgASABQT9xGyIIIAUgCEsbEOgZIAQoAjAhBQsgCQRAIAQoAiwgBWpBACAJ/AsACyAEIAE2AjALIAQgBzYCNCAENQIUIQwgBCgCICIBIAQoAhhGBEAgC0HA9P8AELMoCyAEKAIcIAFBA3RqIAw3AwAgBCABQQFqNgIgDAELIARBDGpBAUEAELwSCyAKIAJBAWoiAkcNAQwDCwtBzPb/AEEgQez2/wAQnykAC0G49/8AELI7AAsgBEHUAGoiAiAEQQxqEO4OQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQcD8/wA2AgggACABNgIEIABBk4CAgHg2AgAgBEFAaxC8KgsgBEEMahC7LCAEQZABaiQADwtBBEHEABCjPQALlQYBBH8jAEEQayICJAACQAJAAkACQAJAAkADQAJAIAIgAC0AACIDNgIMIAEgAkEMakEEELsJAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQQ1rDhwAFRUBAgMEFQUVFRUVFQYHCAkKCwwNDhAREhMUFQsgAiAALQABNgIMIAEgAkEMaiIEQQQQuwkgAiAAKAIEIgNBAEc2AgwgASAEQQQQuwkgA0UNFCABIAAoAgRBCGogACgCCBC7CSACQf8BOgAMIAEgBEEBELsJDBQLIAIgAC0AATYCDCABIAJBDGpBBBC7CQwTCyACIAAtAAE2AgwgASACQQxqQQQQuwkMEgsgAiAALQABNgIMIAEgAkEMakEEELsJDBELIAIgAC0AATYCDCABIAJBDGpBBBC7CQwQCyACIAAoAgQ2AgwgASACQQxqQQQQuwkMDwsgACgCBEEIaiABENkKDA4LIAAoAgRBCGogARDZCgwNCyAAKAIIQQhqIAEQ2QogAiAAKAIENgIMIAEgAkEMakEEELsJDAwLIAAoAgRBCGogARDZCgwLCyAAKAIEQQhqIAEQ2QoMCgsgAEEEaiABENogDAkLIAAoAgQgAiAAKAIIIgQ2AgwgASACQQxqIgVBBBC7CUEIaiAEIAEQ0CMgAiAALQABNgIMIAEgBUEEELsJDAgLIAAoAgQgARCTCSAAKAIIIQAMAQsLIAIgAC0AAToADCABIAJBDGoiA0EBELsJIAIgAC0AAjoADCABIANBARC7CQwFCyACIAAtAAE6AAwgASACQQxqIgNBARC7CSACIAAtAAI6AAwgASADQQEQuwkMBAsgAiAALQABOgAMIAEgAkEMaiIDQQEQuwkgAiAALQACOgAMIAEgA0EBELsJDAMLIAIgAC0AAToADCABIAJBDGoiA0EBELsJIAIgAC0AAjoADCABIANBARC7CQwCCyAAKAIEQQhqIAEQ2QogAiAALQABOgAMIAEgAkEMakEBELsJDAELIAAoAgRBCGogARDZCiAAKAIIQQhqIAEQ2QoLIAJBEGokAAv2BQEGfyMAQSBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAFBBAWsOAwsCAQALIABBLGogAEEk/AoAAAsgAEEsaiEGAkACQCAALQBMQQFrDgMHAgEACyAGKAIAIgQoAggNCyAEQX82AgggAEEAOgBIIAAgBEEMaiICNgI4IAAgBEEIajYCNCAAIAI2AjAgAEHIAGohBQwDCyAAQcgAaiEFAkAgAC0ASEEBaw4DBQEAAgsgACgCRCICKAIAIQQMAwsACyAAKAI4IQILIAIoAgAhBCACQQA2AgAgBEUNBSAAIAIoAgQ2AkAgACAENgI8IAAgAEE8aiICNgJECyADQRBqIAQgASACKAIEKAIYEQEAQQIhAiADKAIQIgRBAkcNAkEDIQEgBUEDOgAADAMLQYjewwAQ6CsAC0G43sMAEOgrAAsgAygCFCAAQTxqELwqQQEhASAAQQE6AEggACgCNCIFIAUoAgBBAWo2AgAgACgCLCIFIAUoAgBBAWsiBzYCAEGAASAEQQFxGyEFIAdFBEAgBhDUIgsgBCECCyAAIAE6AExBAyEEAkAgAkECRiIBDQAgBhDiIAJAIAJBAXEEQCADIAU2AhggA0GAATYCHCADIABBKGogA0EcaiADQRhqEMIjIAMoAgBBAXENBQJAIAMoAgQiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQEgAhDyHwwBCyADIAU2AhggA0GAATYCHCADQQhqIABBJGogA0EcaiADQRhqEMIjIAMoAghBAXENBAJAIAMoAgwiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQAgAhDyHwsgACgCJCICQYQBTwRAIAIQ8h8LQQEhBCAAKAIoIgJBhAFJDQAgAhDyHwsgACAEOgBQIANBIGokACABDwtB5tnDAEExEJc9AAtB6N3DABDoKwALQdTbwwBBMRCXPQALxQUBB38jAEEwayIEJAACQAJAAkACQAJAAkACQCABKAIEIgUgASABKAIAQYCAgIB4RiIGGygCCCACSwRAIAYNASAEQRBqIAFBCGooAgAiBTYCACAEIAEpAgA3AwggAiAFSw0DIARBADYCECAEIAQoAgwiATYCGCAEIAI2AiQgBCAFIAJrNgIoIAQgASACQQJ0ajYCHCAEIARBCGo2AiAgBEEYahD2FSAEKAIIIQcgBCgCDCEGIAQoAhAhBQwCCwJAIAZFBEAgBCABKQIANwMYDAELIARBGGogBRDpHQsgACAEKQMYNwIAIABBCGpBADYCAAwGCyAFKAIIIgEgAkkNAiAFKAIEIQggBEEYaiABIAJrIgVBAEEEQQQQoBggBCgCHCEHIAQoAhhBAUYNAyAEKAIgIQYgBUECdCIBRQ0AIAYgCCACQQJ0aiAB/AoAAAsgA0H/AXFFIAVFcg0DIAZBBGshCCAFQQJ0IQEgA0EfcSEJQQAhAkEAIANrQR9xIQMDQCABIAhqIgogAiAKKAIAIgIgCXZyNgIAIAIgA3QhAiABQQRrIgENAAsMAwsgAiAFQaCiiAEQsDsACyACIAFBxKWIARCvOwALIAcgBCgCIEGEpYgBEP0vAAsgBCAFNgIgIAQgBzYCGCAEIAY2AhwCQCAFRQ0AIAYgBUECdCICakEEayIBRQ0AIAEoAgANACACIQEgBkEEayEDIAVB/////wNxIQICQANAIAFFBEBBACEBDAILIAJBAWshAiABIANqIAFBBGshASgCAEUNAAsgAkEBaiIBIAVLDQELIAQgATYCICABIQULAkAgBSAHQQJ2Tw0AIAQgBEEYaiAFQQRBBBD0FCAEKAIAIgFBgYCAgHhGDQAgASAEKAIEQdSliAEQ/S8ACyAAIAQpAhg3AgAgAEEIaiAEQSBqKAIANgIACyAEQTBqJAALuAsCDH8EfiMAQTBrIggkACAIIAI6AAcCQAJAAn8CQCACQf8BcSIHQQdHBEAgB0EBRw0BIAhBBzoABwsCQAJAIAEoAgxFDQAgAUEQaiAIQQdqEOwMIRMgASgCACIHQQxrIQogASgCBCIJIBOncSECIBNCGYhC/wCDQoGChIiQoMCAAX4hFQNAIAIgB2opAAAiFCAVhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAKQQAgE3qnQQN2IAJqIAlxayILQQxsai0AAEEHRg0EIBNCAX0gE4MiE1BFDQALCyAUIBRCAYaDQoCBgoSIkKDAgH+DUEUNASACIAxBCGoiDGogCXEhAgwACwALQaytzgBBJUHUrc4AEMskAAsgByALQQxsagwBCyAIQQhqIQkjAEEQayIKJAAgCiACIgc6AA8gAUEQaiIOIApBD2oQ7AwhFCABKAIAIgxBDGshDyABKAIEIg0gFKdxIQsgFEIZiEL/AINCgYKEiJCgwIABfiEWIAdB/wFxIRACQAJAA0ACQCALIAxqKQAAIhUgFoUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgD0EAIBN6p0EDdiALaiANcWsiEUEMbGotAAAgEEYNAiATQgF9IBODIhNQRQ0ACwsgFSAVQgGGg0KAgYKEiJCgwIB/g1BFDQIgCyASQQhqIhJqIA1xIQsMAQsLIAkgATYCBCAJIAwgEUEMbGo2AgBBCSEHDAELIAEoAghFBEAgCiABIA4QqQggCi0ADyEHCyAJIAE2AgggCSAUNwMACyAJIAc6AAwgCkEQaiQAIAgoAggiDCAILQAUIg1BCUYNABogCCgCECAIKAIMIQ8gASgCICIKIAooAgAiB0EBajYCACAHQQBIDQIjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhBB9ABxDQMgEEGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAlBBGogB0EQahCZDiAJQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCUHUq84ANgIIIAkgAjYCBCAJQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCUE1NgIMIAkgCzYCCCAJIAI2AgQgCUEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAJQQRqIAdBEGoQmQ4gCUEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALIAgoAhAhAiAIKAIMIQcgCCgCCCIJQQhHBEAgACAIKQIUNwIMIABBFGogCEEcaigCADYCACAAIAI2AgggACAHNgIEIAAgCTYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAggAjYCECAIIAc2AgwgCCANOgAIIAytIA+tQiCGhCAIQQhqEPoSCyICQQhrKAIAIQcgAkEEaygCACECIAhBKGogA0EIaikCADcDACAIIAMpAgA3AyAgCEEIaiAHIAhBIGogBiAEIAVBAXEbIAIoAgwRBQAgCCgCCCICQQhHBEAgACAIKQIMNwIEIABBFGogCEEcaigCADYCACAAQQxqIAhBFGopAgA3AgAgACACNgIADAELIAEgCC0ABzoAJCAAQQg2AgALIAhBMGokAA8LAAuYDgIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgsgE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogC3FrIgpBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgDEEIaiIMaiALcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIApBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCzoADyABQRBqIg8gB0EPahDsDCEUIAEoAgAiDUEMayEQIAEoAgQiDiAUp3EhCiAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEQJAAkADQAJAIAogDWopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAQQQAgE3qnQQN2IApqIA5xayISQQxsai0AACARRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAKIAxBCGoiDGogDnEhCgwBCwsgCCABNgIEIAggDSASQQxsajYCAEEJIQsMAQsgASgCCEUEQCAHIAEgDxCoCCAHLQAPIQsLIAggATYCCCAIIBQ3AwALIAggCzoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgsgCygCACIHQQFqNgIAIAdBAEgNAiMAQeAAayIKJAAgCiALNgIEAkACQAJAAkAgCAJ/AkACQAJAIAJB/wFxQQRrDgUBAAAAAgALIwBBMGsiByQAIAcgAjoADiAHIAs2AggCQAJAAkACQAJAAkACQCACQf8BcSIMQQdNBEBBASAMdCIRQfQAcQ0DIBFBggFxDQIgDEUNAQsgByACOgAPIAdBAjYCFCAHQcy9zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EPajYCKCAIQQRqIAdBEGoQmQ4gCEEBNgIADAMLIAtBCGoQ3iUhDEHAAEEIEK02IgJFDQMgAiAMNgI4IAJCADcDMCACQQA2AiAgAkEANgIAIAhBnKzOADYCCCAIIAI2AgQgCEEINgIADAILIAdBEGpBNUEAQQFBARCgGCAHKAIUIQIgBygCEEEBRg0DIAcoAhgiDEGEvc4AQTX8CgAAIAhBNTYCDCAIIAw2AgggCCACNgIEIAhBADYCAAwBCyAHQQI2AhQgB0H0vM4ANgIQIAdCATcCHCAHQa4DNgIsIAcgB0EoajYCGCAHIAdBDmo2AiggCEEEaiAHQRBqEJkOIAhBADYCAAsgCyALKAIAIgJBAWs2AgAgAkEBRgRAIAdBCGoQ2SELIAdBMGokAAwCC0EIQcAAEKM9AAsgAiAHKAIYQdinzgAQ/S8ACwwDCyAKQQA2AlwgCkKAgICAEDcCVCAKQTBqIApB1ABqEOcVIApBIGpCADcDACAKQShqQgA3AwAgCkEYaiAKQThqKQMANwMAIAogCikDMDcDEEHwAEEIEK02IgJFDQMgAkIANwMAIAJBCGogCkEIakEo/AoAACACQThqQgA3AwAgAkIANwMwIAJBQGtCgICAgBA3AwAgAkHIAGpBAEEh/AsAQci+zgAMAQtBGEEEEK02IgJFDQMgAkIANwIIIAJBATYCBCACQYjTzAA2AgAgAkEQakIANwIAQey+zgALNgIIIAggAjYCBCAIQQg2AgAgCyALKAIAIgJBAWs2AgAgAkEBRw0AIApBBGoQ2SELIApB4ABqJAAMAgtBCEHwABCjPQALQQRBGBCjPQALIAkoAhAhAiAJKAIMIQggCSgCCCILQQhHBEAgACAJKQIUNwIMIABBFGogCUEcaigCADYCACAAIAI2AgggACAINgIEIAAgCzYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAkgAjYCECAJIAg2AgwgCSAOOgAIIA2tIBCtQiCGhCAJQQhqEPoSCyICQQhrKAIAIQggAkEEaygCACECIAlBKGogA0EIaikCADcDACAJIAMpAgA3AyAgCUEIaiAIIAlBIGogBiAEIAVBAXEbIAIoAgwRBQAgCSgCCCICQQhHBEAgACAJKQIMNwIEIABBFGogCUEcaigCADYCACAAQQxqIAlBFGopAgA3AgAgACACNgIADAELIAEgCS0ABzoAJCAAQQg2AgALIAlBMGokAA8LAAveDAIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgogE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogCnFrIgxBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgC0EIaiILaiAKcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIAxBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCjoADyABQRBqIg4gB0EPahDsDCEUIAEoAgAiC0EMayEPIAEoAgQiDSAUp3EhDCAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEAJAAkADQAJAIAsgDGopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAPQQAgE3qnQQN2IAxqIA1xayIRQQxsai0AACAQRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAMIBJBCGoiEmogDXEhDAwBCwsgCCABNgIEIAggCyARQQxsajYCAEEJIQoMAQsgASgCCEUEQCAHIAEgDhCqCCAHLQAPIQoLIAggATYCCCAIIBQ3AwALIAggCjoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgogCigCACIHQQFqNgIAIAdBAEgNAiMAQRBrIgwkACAMIAo2AgwCQAJAAkAgAkH/AXFBAkYEQEHIAEEIEK02IgJFDQIgAkEANgJAIAJBAToAPCACQQA2AjggAkIANwMwIAJBADYCECACQgA3AwAgCEHcvc4ANgIIIAggAjYCBCAIQQg2AgAgCiAKKAIAIgJBAWs2AgAgAkEBRw0BIAxBDGoQ2SEMAQsjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhFB9ABxDQMgEUGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEHQqc4ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCEE1NgIMIAggCzYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALCyAMQRBqJAAMAQtBCEHIABCjPQALIAkoAhAhAiAJKAIMIQggCSgCCCIKQQhHBEAgACAJKQIUNwIMIABBFGogCUEcaigCADYCACAAIAI2AgggACAINgIEIAAgCjYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAkgAjYCECAJIAg2AgwgCSAOOgAIIA2tIBCtQiCGhCAJQQhqEPoSCyICQQhrKAIAIQggAkEEaygCACECIAlBKGogA0EIaikCADcDACAJIAMpAgA3AyAgCUEIaiAIIAlBIGogBiAEIAVBAXEbIAIoAgwRBQAgCSgCCCICQQhHBEAgACAJKQIMNwIEIABBFGogCUEcaigCADYCACAAQQxqIAlBFGopAgA3AgAgACACNgIADAELIAEgCS0ABzoAJCAAQQg2AgALIAlBMGokAA8LAAvUDAIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgogE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogCnFrIgxBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgC0EIaiILaiAKcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIAxBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCjoADyABQRBqIg4gB0EPahDsDCEUIAEoAgAiC0EMayEPIAEoAgQiDSAUp3EhDCAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEAJAAkADQAJAIAsgDGopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAPQQAgE3qnQQN2IAxqIA1xayIRQQxsai0AACAQRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAMIBJBCGoiEmogDXEhDAwBCwsgCCABNgIEIAggCyARQQxsajYCAEEJIQoMAQsgASgCCEUEQCAHIAEgDhCsCCAHLQAPIQoLIAggATYCCCAIIBQ3AwALIAggCjoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgogCigCACIHQQFqNgIAIAdBAEgNAiMAQRBrIgwkACAMIAo2AgwCQAJAAkAgAkH/AXFBCEYEQEEYQQQQrTYiAkUNAiACQgA3AgggAkEBNgIEIAJBiNPMADYCACAIQZC/zgA2AgggCCACNgIEIAhBCDYCACACQRBqQgA3AgAgCiAKKAIAIgJBAWs2AgAgAkEBRw0BIAxBDGoQ2SEMAQsjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhFB9ABxDQMgEUGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEGMq84ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCEE1NgIMIAggCzYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALCyAMQRBqJAAMAQtBBEEYEKM9AAsgCSgCECECIAkoAgwhCCAJKAIIIgpBCEcEQCAAIAkpAhQ3AgwgAEEUaiAJQRxqKAIANgIAIAAgAjYCCCAAIAg2AgQgACAKNgIAIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgCSACNgIQIAkgCDYCDCAJIA46AAggDa0gEK1CIIaEIAlBCGoQ+hILIgJBCGsoAgAhCCACQQRrKAIAIQIgCUEoaiADQQhqKQIANwMAIAkgAykCADcDICAJQQhqIAggCUEgaiAGIAQgBUEBcRsgAigCDBEFACAJKAIIIgJBCEcEQCAAIAkpAgw3AgQgAEEUaiAJQRxqKAIANgIAIABBDGogCUEUaikCADcCACAAIAI2AgAMAQsgASAJLQAHOgAkIABBCDYCAAsgCUEwaiQADwsAC4MOAgx/BH4jAEEwayIJJAAgCSACOgAHAkACQAJ/AkAgAkH/AXEiCEEHRwRAIAhBAUcNASAJQQc6AAcLAkACQCABKAIMRQ0AIAFBEGogCUEHahDsDCETIAEoAgAiCEEMayEHIAEoAgQiCyATp3EhAiATQhmIQv8Ag0KBgoSIkKDAgAF+IRUDQCACIAhqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgB0EAIBN6p0EDdiACaiALcWsiCkEMbGotAABBB0YNBCATQgF9IBODIhNQRQ0ACwsgFCAUQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAMQQhqIgxqIAtxIQIMAAsAC0Gsrc4AQSVB1K3OABDLJAALIAggCkEMbGoMAQsgCUEIaiEIIwBBEGsiByQAIAcgAiILOgAPIAFBEGoiDyAHQQ9qEOwMIRQgASgCACINQQxrIRAgASgCBCIOIBSncSEKIBRCGYhC/wCDQoGChIiQoMCAAX4hFiACQf8BcSERAkACQANAAkAgCiANaikAACIVIBaFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIBBBACATeqdBA3YgCmogDnFrIhJBDGxqLQAAIBFGDQIgE0IBfSATgyITUEUNAAsLIBUgFUIBhoNCgIGChIiQoMCAf4NQRQ0CIAogDEEIaiIMaiAOcSEKDAELCyAIIAE2AgQgCCANIBJBDGxqNgIAQQkhCwwBCyABKAIIRQRAIAcgASAPEKcIIActAA8hCwsgCCABNgIIIAggFDcDAAsgCCALOgAMIAdBEGokACAJKAIIIg0gCS0AFCIOQQlGDQAaIAkoAhAgCSgCDCEQIAEoAiAiCyALKAIAIgdBAWo2AgAgB0EASA0CIwBB4ABrIgokACAKIAs2AggCQAJAAkACQCAIAn8CQAJAAkAgAkH/AXFBBGsOBQEAAAACAAsjAEEwayIHJAAgByACOgAOIAcgCzYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgxBB00EQEEBIAx0IhFB9ABxDQMgEUGCAXENAiAMRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgC0EIahDeJSEMQcAAQQgQrTYiAkUNAyACIAw2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEHEqs4ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCIMQYS9zgBBNfwKAAAgCEE1NgIMIAggDDYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyALIAsoAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALDAMLIApBADYCXCAKQoCAgIAQNwJUIApBMGogCkHUAGoQ5xUgCkEgakIANwIAIApBKGpCADcCACAKQRhqIApBOGopAwA3AgAgCiAKKQMwNwIQQeAAQQgQrTYiAkUNAyACQQA2AgAgAkEEaiAKQQxqQST8CgAAIAJCgICAgBA3AyggAkEwakEAQSn8CwBBgL7OAAwBC0EYQQQQrTYiAkUNAyACQgA3AgggAkEBNgIEIAJBiNPMADYCACACQRBqQgA3AgBBpL7OAAs2AgggCCACNgIEIAhBCDYCACALIAsoAgAiAkEBazYCACACQQFHDQAgCkEIahDZIQsgCkHgAGokAAwCC0EIQeAAEKM9AAtBBEEYEKM9AAsgCSgCECECIAkoAgwhCCAJKAIIIgtBCEcEQCAAIAkpAhQ3AgwgAEEUaiAJQRxqKAIANgIAIAAgAjYCCCAAIAg2AgQgACALNgIAIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgCSACNgIQIAkgCDYCDCAJIA46AAggDa0gEK1CIIaEIAlBCGoQ+hILIgJBCGsoAgAhCCACQQRrKAIAIQIgCUEoaiADQQhqKQIANwMAIAkgAykCADcDICAJQQhqIAggCUEgaiAGIAQgBUEBcRsgAigCDBEFACAJKAIIIgJBCEcEQCAAIAkpAgw3AgQgAEEUaiAJQRxqKAIANgIAIABBDGogCUEUaikCADcCACAAIAI2AgAMAQsgASAJLQAHOgAkIABBCDYCAAsgCUEwaiQADwsAC9QMAgx/BH4jAEEwayIJJAAgCSACOgAHAkACQAJ/AkAgAkH/AXEiCEEHRwRAIAhBAUcNASAJQQc6AAcLAkACQCABKAIMRQ0AIAFBEGogCUEHahDsDCETIAEoAgAiCEEMayEHIAEoAgQiCiATp3EhAiATQhmIQv8Ag0KBgoSIkKDAgAF+IRUDQCACIAhqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgB0EAIBN6p0EDdiACaiAKcWsiDEEMbGotAABBB0YNBCATQgF9IBODIhNQRQ0ACwsgFCAUQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiALQQhqIgtqIApxIQIMAAsAC0Gsrc4AQSVB1K3OABDLJAALIAggDEEMbGoMAQsgCUEIaiEIIwBBEGsiByQAIAcgAiIKOgAPIAFBEGoiDiAHQQ9qEOwMIRQgASgCACILQQxrIQ8gASgCBCINIBSncSEMIBRCGYhC/wCDQoGChIiQoMCAAX4hFiACQf8BcSEQAkACQANAAkAgCyAMaikAACIVIBaFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIA9BACATeqdBA3YgDGogDXFrIhFBDGxqLQAAIBBGDQIgE0IBfSATgyITUEUNAAsLIBUgFUIBhoNCgIGChIiQoMCAf4NQRQ0CIAwgEkEIaiISaiANcSEMDAELCyAIIAE2AgQgCCALIBFBDGxqNgIAQQkhCgwBCyABKAIIRQRAIAcgASAOEKsIIActAA8hCgsgCCABNgIIIAggFDcDAAsgCCAKOgAMIAdBEGokACAJKAIIIg0gCS0AFCIOQQlGDQAaIAkoAhAgCSgCDCEQIAEoAiAiCiAKKAIAIgdBAWo2AgAgB0EASA0CIwBBEGsiDCQAIAwgCjYCDAJAAkACQCACQf8BcUEIRgRAQRhBBBCtNiICRQ0CIAJCADcCCCACQQE2AgQgAkGI08wANgIAIAhBtL/OADYCCCAIIAI2AgQgCEEINgIAIAJBEGpCADcCACAKIAooAgAiAkEBazYCACACQQFHDQEgDEEMahDZIQwBCyMAQTBrIgckACAHIAI6AA4gByAKNgIIAkACQAJAAkACQAJAAkAgAkH/AXEiC0EHTQRAQQEgC3QiEUH0AHENAyARQYIBcQ0CIAtFDQELIAcgAjoADyAHQQI2AhQgB0HMvc4ANgIQIAdCATcCHCAHQa4DNgIsIAcgB0EoajYCGCAHIAdBD2o2AiggCEEEaiAHQRBqEJkOIAhBATYCAAwDCyAKQQhqEN4lIQtBwABBCBCtNiICRQ0DIAIgCzYCOCACQgA3AzAgAkEANgIgIAJBADYCACAIQeSszgA2AgggCCACNgIEIAhBCDYCAAwCCyAHQRBqQTVBAEEBQQEQoBggBygCFCECIAcoAhBBAUYNAyAHKAIYIgtBhL3OAEE1/AoAACAIQTU2AgwgCCALNgIIIAggAjYCBCAIQQA2AgAMAQsgB0ECNgIUIAdB9LzOADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ5qNgIoIAhBBGogB0EQahCZDiAIQQA2AgALIAogCigCACICQQFrNgIAIAJBAUYEQCAHQQhqENkhCyAHQTBqJAAMAgtBCEHAABCjPQALIAIgBygCGEHYp84AEP0vAAsLIAxBEGokAAwBC0EEQRgQoz0ACyAJKAIQIQIgCSgCDCEIIAkoAggiCkEIRwRAIAAgCSkCFDcCDCAAQRRqIAlBHGooAgA2AgAgACACNgIIIAAgCDYCBCAAIAo2AgAgA0EMaiADKAIEIAMoAgggAygCACgCEBEBAAwCCyAJIAI2AhAgCSAINgIMIAkgDjoACCANrSAQrUIghoQgCUEIahD6EgsiAkEIaygCACEIIAJBBGsoAgAhAiAJQShqIANBCGopAgA3AwAgCSADKQIANwMgIAlBCGogCCAJQSBqIAYgBCAFQQFxGyACKAIMEQUAIAkoAggiAkEIRwRAIAAgCSkCDDcCBCAAQRRqIAlBHGooAgA2AgAgAEEMaiAJQRRqKQIANwIAIAAgAjYCAAwBCyABIAktAAc6ACQgAEEINgIACyAJQTBqJAAPCwALiQYBAX8jAEEwayIFJAAgBSACNwMAAkACQAJAAkACQAJAAkACQAJAAkACQCAERQRAIANB/wFxQQFrDgICAwELIANB/wFxQQFrDgIEBQMLIAVBATYCHCAFQfSuhgE2AhggBUIBNwIkIAVB7gY2AgwgBSAFQQhqNgIgIAUgBTYCCAwJCyABQYCABE8NBCAFIAE7ARQgBUEANgIQIAVB7gY2AgwgBUEBNgIsIAVBjK+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBAjYCJCAFIAU2AgggBSAFQQhqNgIgDAgLIAFBgIAETw0EIAUgATsBFCAFQQA2AhAgBUHuBjYCDCAFQQE2AiwgBUG0r4YBNgIoIAVBATYCHCAFQfSuhgE2AhggBUECNgIkIAUgBTYCCCAFIAVBCGo2AiAMBwsgBUEBNgIsIAVBzK+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBATYCJCAFQe4GNgIMIAUgBUEIajYCICAFIAU2AggMBgsgAUEBaiIBQYCABE8NAyAFIAE7ARQgBUEANgIQIAVB7gY2AgwgBUEBNgIsIAVB9K+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBAjYCJCAFIAU2AgggBSAFQQhqNgIgDAULIAFBAWoiAUGAgARPDQMgBSABOwEUIAVBADYCECAFQe4GNgIMIAVBATYCLCAFQZywhgE2AiggBUEBNgIcIAVB9K6GATYCGCAFQQI2AiQgBSAFNgIIIAUgBUEIajYCIAwECyAFQQA2AiggBUEBNgIcIAVB3K6GATYCGCAFQgQ3AiAgBUEYakH8roYBEO8sAAsgBUEANgIoIAVBATYCHCAFQdyuhgE2AhggBUIENwIgIAVBGGpBpK+GARDvLAALIAVBADYCKCAFQQE2AhwgBUHcroYBNgIYIAVCBDcCICAFQRhqQeSvhgEQ7ywACyAFQQA2AiggBUEBNgIcIAVB3K6GATYCGCAFQgQ3AiAgBUEYakGMsIYBEO8sAAsgACAFQRhqEO48IAVBMGokAAvQBQIGfwJ+AkAgAkUNACACQQdrIgNBACACIANPGyEHIAFBA2pBfHEgAWshCEEAIQMDQAJAAkACQCABIANqLQAAIgXAIgZBAE4EQCAIIANrQQNxDQEgAyAHTw0CA0AgASADaiIEQQRqKAIAIAQoAgByQYCBgoR4cQ0DIANBCGoiAyAHSQ0ACwwCC0KAgICAgCAhCkKAgICAECEJAkACQAJ+AkACQAJAAkACQAJAAkACQAJAIAVBlPqJAWotAABBAmsOAwABAgoLIANBAWoiBCACSQ0CQgAhCkIAIQkMCQtCACEKIANBAWoiBCACSQ0CQgAhCQwIC0IAIQogA0EBaiIEIAJJDQJCACEJDAcLIAEgBGosAABBv39KDQYMBwsgASAEaiwAACEEAkACQCAFQeABayIFBEAgBUENRgRADAIFDAMLAAsgBEFgcUGgf0YNBAwDCyAEQZ9/Sg0CDAMLIAZBH2pB/wFxQQxPBEAgBkF+cUFuRw0CIARBQEgNAwwCCyAEQUBIDQIMAQsgASAEaiwAACEEAkACQAJAAkAgBUHwAWsOBQEAAAACAAsgBkEPakH/AXFBAksgBEFATnINAwwCCyAEQfAAakH/AXFBME8NAgwBCyAEQY9/Sg0BCyACIANBAmoiBE0EQEIAIQkMBQsgASAEaiwAAEG/f0oNAkIAIQkgA0EDaiIEIAJPDQQgASAEaiwAAEFASA0FQoCAgICA4AAMAwtCgICAgIAgDAILQgAhCSADQQJqIgQgAk8NAiABIARqLAAAQb9/TA0DC0KAgICAgMAACyEKQoCAgIAQIQkLIAAgCiADrYQgCYQ3AgQgAEEBNgIADwsgBEEBaiEDDAILIANBAWohAwwBCyACIANNDQADQCABIANqLAAAQQBIDQEgAiADQQFqIgNHDQALDAILIAIgA0sNAAsLIAAgAjYCCCAAIAE2AgQgAEEANgIAC+sFAgx/AX4jAEGgAWsiAiQAAkACQAJAAkAgAS0AGEEoRgRAIAJBGGogARDvPCACKAIcRQ0BIAIgAigCGCIDQRhqIgQ2AnggAkGYAWpBhIiQIDYCACACQoSIkKDAgIGCBDcDkAEgAiACQZABaiIFNgKEASAEIAUQxAhFDQIgBRDBDCACQRBqIAMQ3DsgAigCFEUNBCACKAIQIgQoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0DIAIgAzYCMCACIAQpAgQ3AjQgAkEkaiACQTBqEOUZIAEoAiQhBiABKAIoIQggAkEIaiABEO88IAIoAgwiA0EBSwRAIAJB+ABqIAIoAggiA0HcAGoQ0wYgAygCbCEJIAMoAmghCiACQYQBaiADQcQAahC+FSAFIANB0ABqEIALIAMoAnAiBARAIAQgBCgCACIHQQFqNgIAIAdBAEgNBSADKAKEASEHIAMoAoABIQsgAygCfCEMIAMoAnghDSADKAJ0IQMLIAJB0ABqIAJBgAFqKAIANgIAIAJBOGogAkGMAWooAgA2AgAgAkHEAGogAkGYAWooAgA2AgAgAiACKQJ4NwNIIAIgCTYCWCACIAo2AlQgAiACKQKEATcDMCACIAIpApABNwI8IAIgBzYCcCACIAs2AmwgAiAMNgJoIAIgDTYCZCACIAM2AmAgAiAENgJcIAIgAkEwahCgASACKQMAIQ4gACABQRhqENMGIAAgDjcCICAAIAg2AhwgACAGNgIYIABBFGogAkEsaigCADYCACAAIAIpAiQ3AgwgARCHJyACQaABaiQADwtBASADQdz3hAEQwyEACyACQQA2AkAgAkEBNgI0IAJBvPiEATYCMCACQgQ3AjggAkEwakHE+IQBEO8sAAtBAEEAQYz3hAEQwyEACyACQgA3AjwgAkKBgICAwAA3AjQgAkG094QBNgIwIAJB+ABqIAJBhAFqIAJBMGpBvPeEARCjKwsAC0EAQQBBzPeEARDDIQAL6wUCDH8BfiMAQaABayICJAACQAJAAkACQCABLQAYQShGBEAgAkEYaiABEO88IAIoAhxFDQEgAiACKAIYIgNBGGoiBDYCeCACQZgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOQASACIAJBkAFqIgU2AoQBIAQgBRDECEUNAiAFEMEMIAJBEGogAxDcOyACKAIURQ0EIAIoAhAiBCgCACIDIAMoAgAiBkEBajYCACAGQQBIDQMgAiADNgIwIAIgBCkCBDcCNCACQSRqIAJBMGoQ4RkgASgCJCEGIAEoAighCCACQQhqIAEQ7zwgAigCDCIDQQFLBEAgAkH4AGogAigCCCIDQdwAahDTBiADKAJsIQkgAygCaCEKIAJBhAFqIANBxABqEL4VIAUgA0HQAGoQgAsgAygCcCIEBEAgBCAEKAIAIgdBAWo2AgAgB0EASA0FIAMoAoQBIQcgAygCgAEhCyADKAJ8IQwgAygCeCENIAMoAnQhAwsgAkHQAGogAkGAAWooAgA2AgAgAkE4aiACQYwBaigCADYCACACQcQAaiACQZgBaigCADYCACACIAIpAng3A0ggAiAJNgJYIAIgCjYCVCACIAIpAoQBNwMwIAIgAikCkAE3AjwgAiAHNgJwIAIgCzYCbCACIAw2AmggAiANNgJkIAIgAzYCYCACIAQ2AlwgAiACQTBqEKABIAIpAwAhDiAAIAFBGGoQ0wYgACAONwIgIAAgCDYCHCAAIAY2AhggAEEUaiACQSxqKAIANgIAIAAgAikCJDcCDCABEIcnIAJBoAFqJAAPC0EBIANB3PeEARDDIQALIAJBADYCQCACQQE2AjQgAkG8+IQBNgIwIAJCBDcCOCACQTBqQcT4hAEQ7ywAC0EAQQBBjPeEARDDIQALIAJCADcCPCACQoGAgIDAADcCNCACQbT3hAE2AjAgAkH4AGogAkGEAWogAkEwakG894QBEKMrCwALQQBBAEHM94QBEMMhAAvrBQIMfwF+IwBBoAFrIgIkAAJAAkACQAJAIAEtABhBKEYEQCACQRhqIAEQ7zwgAigCHEUNASACIAIoAhgiA0EYaiIENgJ4IAJBmAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A5ABIAIgAkGQAWoiBTYChAEgBCAFEMQIRQ0CIAUQwQwgAkEQaiADENw7IAIoAhRFDQQgAigCECIEKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAyACIAM2AjAgAiAEKQIENwI0IAJBJGogAkEwahDkGSABKAIkIQYgASgCKCEIIAJBCGogARDvPCACKAIMIgNBAUsEQCACQfgAaiACKAIIIgNB3ABqENMGIAMoAmwhCSADKAJoIQogAkGEAWogA0HEAGoQvhUgBSADQdAAahCACyADKAJwIgQEQCAEIAQoAgAiB0EBajYCACAHQQBIDQUgAygChAEhByADKAKAASELIAMoAnwhDCADKAJ4IQ0gAygCdCEDCyACQdAAaiACQYABaigCADYCACACQThqIAJBjAFqKAIANgIAIAJBxABqIAJBmAFqKAIANgIAIAIgAikCeDcDSCACIAk2AlggAiAKNgJUIAIgAikChAE3AzAgAiACKQKQATcCPCACIAc2AnAgAiALNgJsIAIgDDYCaCACIA02AmQgAiADNgJgIAIgBDYCXCACIAJBMGoQoAEgAikDACEOIAAgAUEYahDTBiAAIA43AiAgACAINgIcIAAgBjYCGCAAQRRqIAJBLGooAgA2AgAgACACKQIkNwIMIAEQhycgAkGgAWokAA8LQQEgA0Hc94QBEMMhAAsgAkEANgJAIAJBATYCNCACQbz4hAE2AjAgAkIENwI4IAJBMGpBxPiEARDvLAALQQBBAEGM94QBEMMhAAsgAkIANwI8IAJCgYCAgMAANwI0IAJBtPeEATYCMCACQfgAaiACQYQBaiACQTBqQbz3hAEQoysLAAtBAEEAQcz3hAEQwyEAC7gFAgZ+An8jAEHQAGsiCCQAAkAgACkDAEICUQRAIAhBQGtCADcDACAIQgA3AzggCCAAKQMQIgI3AzAgCCAAKQMIIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAggASgCACIAQQBHNgJMIAhBCGoiCSAIQcwAakEEELsJAkAgAARAIAkgASgCBCABKAIIELsJDAELIAggAS0ABDYCTCAIQQhqIAhBzABqQQQQuwkLIAgpAzggCDUCQEI4hoQiAiAIKQMghSIDQhCJIAMgCCkDEHwiA4UiBUIViSAFIAgpAxgiBCAIKQMIfCIGQiCJfCIFhSIHQhCJIAcgAyAEQg2JIAaFIgR8IgNCIIlC/wGFfCIGhSIHQhWJIAcgAyAEQhGJhSIDIAIgBYV8IgJCIIl8IgWFIgRCEIkgBCACIANCDYmFIgIgBnwiA0IgiXwiBIUiBkIViSAGIAMgAkIRiYUiAiAFfCIDQiCJfCIFhSIGQhCGIAYgAkINiSADhSICIAR8IgNCIIl8IgSFQiuIIAJCEYkgA4UiAkINiSACIAV8hSICQi+IhSACIAR8IgJCIIiFIAKFIQIMAQtBACEAIAggASgCACIJQQBHNgIIQqXGiKHInKf5SyECA0AgAiAIQQhqIABqMQAAhUKzg4CAgCB+IQIgAEEBaiIAQQRHDQALIAkEQCABKAIIIglFDQEgASgCBCEAA0AgAiAAMQAAhUKzg4CAgCB+IQIgAEEBaiEAIAlBAWsiCQ0ACwwBCyAIIAEtAAQ2AghBACEAA0AgAiAIQQhqIABqMQAAhUKzg4CAgCB+IQIgAEEBaiIAQQRHDQALCyAIQdAAaiQAIAKnQf//AXELvAUBBX8CQAJAAkACQAJAAkACQAJAIAVB+ABNBEAgBUEDbEHk2fMAai0AACIHQdEBTw0CQdABIAdrIQggB0HQAUcNAQwICyAFQfkAQdDc8wAQwyEACwJAA0AgBiAHakHg3PMAai0AACIJRQRAIAMgBUEDbEHl2fMAai0AACIIQQtrQQAgCEEMTxsiByAEIAQgB0obIgdJDQQCQAJAIAQgCEEAIAhBCkkbIAdqayIEQQBKBEAgAiAHaiEJIAMgB2shAiAAIAZqIQdBACEDA0AgAiADRg0CIAMgBmoiCiABTw0DIAMgB2ogAyAJai0AADoAACAEIANBAWoiA0cNAAsgAyAGaiEGCyABIAYgBGsiAkkNByAAIAJqIQcgASACayECAkAgCEEKaw4CCQALCyAEQQBMDQpBACEDA0AgAiADSQ0KIAMgB2ogAiADaxDGGSIIIANqIQMgBCAIayIEQQBKDQALDAoLIAIgAkGw3/MAEMMhAAsgCiABQcDf8wAQwyEACyABIAZGDQEgACAGaiAJOgAAIAcgBkEBaiIGakHQAUcNAAsgCCEGDAcLIAEgAUHQ3/MAEMMhAAsgB0HQAUGw3vMAEK87AAsgByADQdDe8wAQrzsACyACIAFB4N7zABCvOwALIAcgAhDGGRoMAQsgAyACQfDe8wAQrzsACwJAAkAgBUEDbEHm2fMAai0AACIDQdEBSQRAQdABIANrIQIgA0HQAUYEQEEAIQYMAwsgBiABIAEgBksbIQQCQANAIANB4NzzAGotAAAiBUUNAyABIARGDQEgACAGaiAFOgAAIARBAWohBCAGQQFqIQYgA0EBaiIDQdABRw0ACyACIQYMAwsgBiABQaDf8wAQwyEACyADQdABQYDf8wAQrzsACyAGDwsgBiACQZDf8wAQwyEACyAGIAhBwN7zABDDIQAL5AkCC38DfiMAQbABayIDJAAgAyACNgIAAkACQAJAAkACQAJAAkAgASgCCCIGIAJLBEACQCABKAIEIAJBAnRqIgQoAgAEQAJAAkAgASgCECIFRQ0AIAEoAhQiBkUNACACIAZPDQUgA0EEaiAFIAJBGGxqEM4VDAELIANBgICAgHg2AgQLIAEoAhwiBiABKAIMIgUoAlgiB08NBCACIAUoAlQgBkEGdGoiBigCKCIFTw0FIAYoAiQhCSAEKAIAIgYgBigCACIEQQFqNgIAIARBAEgNBiABKAIYIQFBDEEEEK02IghFBEBBBEEMEKM9AAsgCEEBOwEIIAhCgYCAgBA3AgAgA0EoaiEEIANBBGohByMAQSBrIgUkACAFIAg2AgQgBSAGNgIAIAVBCGogCSACQcACbGoiAigC0AEgAigC1AEgCEEIahDHDSAFKAIQIQwgBSgCDCENAkAgBSgCCCIJQQhHBEAgBCAFKQIUNwIUIARBHGogBUEcaigCADYCACAEIAw2AhAgBCANNgIMIAQgCTYCCCAEQgM3AwAgCCAIKAIAIgFBAWs2AgAgAUEBRgRAIAVBBGoQgiwLIAcoAgBBgICAgHhHBEAgB0EIQRgQ4B4LIAUoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAUQ3xgMAQsgBUEIaiACEOwgIAUpAwghDgJAAn4CQCAHKAIAIghBgICAgHhHBEAgBygCBCEJIAcoAggiCw0BQgAMAgsgBSkDECEQIAItABAhCEICIQ8MAgtCACAJKQMAIg8gDlENABogDyAOfachCkIBCyEPIAhBCHYhBwsgAigCvAJBCGoQ3SUhAiAEQSNqIAdBEHY6AAAgBCAHOwAhIAQgBjYCQCAEIAw2AjwgBCANNgI4IARBADYCNCAEIAE2AjAgBCALNgIsIARBADYCKCAEIAk2AiQgBCAIOgAgIARBADYCHCAEIAo2AhggBCAQNwMQIAQgDjcDCCAEIA83AwAgBCACOgBEIAUoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQgiwLIAVBIGokACADQRhqIgEgA0E4aikDADcDACADQSBqIgIgA0FAaykDADcDACADIAMpAzA3AxAgAykDKCIOQgNSDQEgACADKQMQNwMAIABBEGogAikDADcDACAAQQhqIAEpAwA3AwAMCQsgA0ECNgIsIANBsOTQADYCKCADQgE3AjQgA0E7NgIUIAMgA0EQajYCMCADIAM2AhAgAEEEaiADQShqEJkOIABBADYCAAwICyADQfAAaiICIANByABqQSj8CgAAIANBoAFqIgYgA0EYaikDADcDACADQagBaiIEIANBIGopAwA3AwAgAyADKQMQNwOYAUHIAEEIEK02IgFFDQUgASAONwMAIAEgAykDmAE3AwggAUEQaiAGKQMANwMAIAFBGGogBCkDADcDACABQSBqIAJBKPwKAABBGEEIEK02IgJFDQYgAkHA5NAANgIIIAIgATYCBCACQQg2AgAgAEHs5NAANgIIIAAgAjYCBCAAQQg2AgAMBwsgAiAGQfDj0AAQwyEACyACIAZBiOXQABDDIQALIAYgB0Hk988AEMMhAAsgAiAFQfT3zwAQwyELAAtBCEHIABCjPQALQQhBGBCjPQALIANBsAFqJAAL/QgBCX8jAEEQayIKJAACQAJAIAZBACAFa0EDcSIHayIJQQAgBiAJTxtB7AVJDQAgA0H/AUsEQEFSIQQMAgsgAkEEaiECIAUgB2pBACAGIAdPGyIJQQA6AOADQQEgBEEBaiIFIAVBAU0bQQFrIQYgCUHhA2ohBSAJQeADaiEHA0AgBgRAIAUgBDoAACAFQQFqIQUgBEEBayEEIAZBAWshBgwBBSAJQe0DaiEGQQAhBANAIAMgBEcEQCAEIAZqIAcgAi0AAGotAAA6AAAgAkEEaiECIARBAWohBAwBCwtBun8hBCABRQ0DIApBDDYCDEEAIQRBACAJa0EDcSICDQIgAEEBaiEFAkAgA0ECSQ0AIAMgAiAJaiICQZADaiIHIApBDGogBiADEJgVIghGBEBBASEEDAELIAhBAUYNACACQcQDaiIIQQYgAyAKKAIMEIE7IgwgByADIAooAgxBABD0BiIEQYh/Sw0EIAUgAUEBayINIAggCigCDCAMEPsmIgdBiH9LBEAgByEEDAULIAIgCCAKKAIMIAwgAkHsAWpBpAEQyAciBEGIf0sNBCAFIAdqIg4hCCANIAdrIgQhByAEIAMgA0EHdmpBCGpPIQxBACENIwBBQGoiBCQAAkAgA0EDSQ0AIAQgCDYCOCAEIAg2AjQgBEIANwIsIAQgByAIakEEazYCPCAHQQVJDQAgAyAGaiIIQQJrIQcgCEEBay0AACELAkAgA0EBcQRAIARBHGoiDyACIAsQhx8gBEEMaiACIActAAAQhx8gBEEsaiAPIAhBA2siBy0AABDhJSAMBEAgBCgCOCIIIAQoAiwiCzYAACAEIAQoAjAiAkEHcTYCMCAEIAggAkEDdmo2AjggBCALIAJBeHF2NgIsDAILIARBLGoQiyYMAQsgBEEMaiACIAsQhx8gBEEcaiACIActAAAQhx8LA0AgBiAHSQRAIARBLGoiAiAEQQxqIAdBAWstAAAQ4SUgAiAEQRxqIAdBAmsiBy0AABDhJSAMBEAgBCgCOCIIIAQoAiwiCzYAACAEIAQoAjAiAkEHcTYCMCAEIAggAkEDdmo2AjggBCALIAJBeHF2NgIsBSAEQSxqEIsmCwwBCwsgBEEsaiICIARBDGoQ0zUgAiAEQRxqENM1IAQgBCgCMCIHQQFqNgIwIAQgBCgCLEEBIAd0cjYCLCACEIsmIAQoAjgiAiAEKAI8Tw0AIAIgBCgCNGsgBCgCMEEAR2ohDQsgBEFAayQAIA0iBEGIf0sNBCAERQRAQQAhBAwBCyAEIA5qIAVrIgRBiH9LDQQLIARBAkkgBCADQQF2T3JFBEAgACAEOgAAIARBAWohBAwECyADQYABSw0CQbp/IQQgASADQQFqQQF2IgJNDQMgAkEBaiEEIAAgA0H/AGo6AABBACECIAMgBmpBADoAAANAIAIgA08NBCAFIAIgCWoiAEHtA2otAABBBHQgAEHuA2otAABqOgAAIAVBAWohBSACQQJqIQIMAAsACwALAAtBfyEECyAKQRBqJAAgBAv9BAEYfyMAQRBrIg8kACABIAAoAgQiCWshDCAAKAIcIQYgBEEBRyEYA0AgBiAMT0UEQCAAKAJcIAYgCWoiFCAAKALAASADEKMdQQJ0aiIFKAIAIQEgACgCZCEVIAAoAgghECAAKAIMIQ0gACgCvAEhCCAAKALEASEKIAAoAhghESAAKAK4ASEHIAAoAhAhBCAFIAY2AgBBACESIAZBfyAIQQFrdEF/cyIWayIFQQAgBSAGTRshFyAEIAxBASAHdCIFayAEIAwgBGsgBUsbIBEbIRkgBkEJaiEHIAkgDWohGiANIBBqIRtBASAKdCETIBUgBiAWcUEDdGoiDkEEaiEIQQghC0EAIQoCQANAIBNFIAEgGUlyDQEgFCAKIBIgCiASSRsiBGohBQJ/IBhFIAEgBGogDUlxRQRAIAUgASAJaiAEaiACEIAUIARqIgQgAWohBSAJDAELIBAgCSAFIAEgEGogBGogAiAbIBoQzSggBGoiBCABaiIFIA1JGwshESAFIAcgBCAHIAFrSxsgByAEIAtLIgUbIQcgBCALIAUbIQsgBCAUaiIcIAJGDQEgFSABIBZxQQN0aiEFAkACQAJAIAEgEWogBGotAAAgHC0AAEkEQCAOIAE2AgAgASAXSw0BIA9BDGohDgwFCyAIIAE2AgAgASAXTQ0CIAQhEiAFIQgMAQsgBCEKIAVBBGoiDiEFCyATQQFrIRMgBSgCACEBDAELCyAPQQxqIQgLIAhBADYCACAOQQA2AgBBwAEgC0GAA2siASABQcABTxsiBCAHIAZrQQhrIgEgASAESRsgASALQYADSxsgBmohBgwBCwsgACAMNgIcIA9BEGokAAvRCAEDfyMAQUBqIgMkACADQQxqQa24wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCwJAAkACQAJAIAEtAABBAWsOAgECAAsgA0EsaiIBQbW4wgBBBkEKQQEQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwECyADQSxqIgQQhjAjAEEgayIBJAAgAUGUv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQIgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAwsgA0EsaiIBQbu4wgBBBkEKQQIQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwDCyADQSxqIgQQhjAjAEEgayIBJAAgAUGIv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQEgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAgsgA0EsaiIBQcG4wgBBBUEKQQMQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwCCyADQSxqIgQQhjAjAEEgayIBJAAgAUGbvcIAQQsQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgAhDGISADQSxqIAIQgTYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAvRCAEDfyMAQUBqIgMkACADQQxqQa24wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCwJAAkACQAJAIAEtAABBAWsOAgECAAsgA0EsaiIBQbW4wgBBBkEKQQEQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwECyADQSxqIgQQhjAjAEEgayIBJAAgAUGUv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQIgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAwsgA0EsaiIBQbu4wgBBBkEKQQIQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwDCyADQSxqIgQQhjAjAEEgayIBJAAgAUGIv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQEgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAgsgA0EsaiIBQcG4wgBBBUEKQQMQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwCCyADQSxqIgQQhjAjAEEgayIBJAAgAUGbvcIAQQsQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgAhDGISADQSxqIAIQgDYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAuOBQEDfyMAQeAAayIFJAAgBSACNgIEAkACQCACQYACRgRAIAVBIGogASAEQQ9xIgZBBXRqIgJBGGopAQA3AwAgBUEYaiACQRBqKQEANwMAIAVBEGogAkEIaikBADcDACAFIAIpAQA3AwggAyAGQQF0ai8BACEHIARB/wFxRQ0CIAZBAWsiBEEEdCICQYECTw0BIAVBQGsgASACQQF0aiICQRhqKQEANwMAIAVBOGogAkEQaikBADcDACAFQTBqIAJBCGopAQA3AwAgBSACKQEANwMoQQAhAgNAIAVBCGogAmoiBiAGLwEAIAVBKGogAmovAQBrOwEAIAJBAmoiAkEgRw0ACyAEQQ9NBEAgByADIARBAXRqLwEAayEHDAMLQX9BEEHQ8dEAEMMhAAsgBUEANgIoQQAgBUEEakG88dEAIAVBKGpBhPLRABCvKwALIAVBADYCOCAFQQE2AiwgBUGA8NEANgIoIAVCBDcCMCAFQShqQcDx0QAQ7ywACyAFQUBrIAFB+ANqKQEANwMAIAVBOGogAUHwA2opAQA3AwAgBUEwaiABQegDaikBADcDACAFIAEpAeADNwMoIAMvAR5BgMABbCEBIAdB//8DcUGAwAFsIQNBACECAkACQANAIAVBCGogAmoiBC8BACIHRQ0BIAVBKGogAmoiBC8BACIGRQ0CIAAgACoCACAHQQ10IANqQQ12Qfz/D3FBzIbjAGoqAgAgBkENdCABakENdkH8/w9xQcyG4wBqKgIAk5M4AgAgAEEEaiEAIAJBAmoiAkEgRw0ACyAFQeAAaiQADwsgBUEANgJIIAQgBUHIAGpB5PHRABCNKwALIAVBADYCSCAEIAVByABqQfTx0QAQjSsAC6kFAQd/IwBBMGsiBCQAIARBADYCCCAEQoCAgIDAADcCACAEQQA2AhQgBEKAgICAwAA3AgxBBCEGAkAgAwRAIAIgA0EEdGohCCABQdABaiEJA0ACQCACKAIABEAgAigCBCEGIAIoAggiByABKALYASIDIAMgB0sbIgVFBEBBACEDDAILIAEoAtQBIQpBACEDA0AgAyAKai0AACADIAZqLQAARw0CIAUgA0EBaiIDRw0ACyAFIQMMAQtB5IfOAEEgQYSIzgAQyyQACyAEKAIIIgUgBCgCAEYEQCAEQaShzgAQnSgLIAQoAgQgBUECdGogAzYCACAEIAVBAWo2AgggAigCAEUNAiAEQRhqIAIgAyACKAIIENIQIAQoAhQiAyAEKAIMRgRAIARBDGpBtKHOABCeKAsgBCgCECADQQR0aiIFIAQpAhg3AgAgBUEIaiAEQSBqKQIANwIAIAQgA0EBajYCFCABQQA2AtgBIAkgBiAHEKE2IAJBEGoiAiAIRw0ACyAEKAIEIQYgBCgCCCEFCyAEQRhqIAEgBiAFEM8RAkAgBCgCGCIDQQhHBEAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAMAQsgBEEYaiABQeAAaiAEKAIQIAQoAhQQoBAgBCgCGCIDQQhHBEAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAMAQtBCCEDCyAAIAM2AgAgBCgCFCIFBEAgBCgCECEDA0AgAygCACIABEAgA0EMaiADQQRqKAIAIANBCGooAgAgACgCEBEBAAsgA0EQaiEDIAVBAWsiBQ0ACwsgBEEMakEEQRAQ4B4gBBDpOyAEQTBqJAAPC0Gsh84AQSVB1IfOABCfKQALvQUCB38BfiMAQaABayIFJAACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCACKAIEIQYgBSACKAIIIgc2AgAgB0EBRw0BIAVB2ABqIAEgBiADEJ4BIAUoAmAhByAFKAJcIQMgBSgCWCIBQQhHBEAgACAFKQJkNwIMIABBFGogBUHsAGooAgA2AgAgACAHNgIIIAAgAzYCBCAAIAE2AgAMBwsgA0UEQEEAIQIMBgsgBUEEaiADIAcoAhARBAAQwwYCQAJAAkACQCACLQAMIglBG2sOBAEAAAIAC0GYxM8AQShB9MXPABCfKQALIAVBjAFqIAIoAhAiAUE8ahDdICAFQYABaiABQTBqEMMGIAEvAUghBiABKQMoIQwgBUHYAGoiCCABQQhqELEuIAUgDDcDeCAFIAY7AZgBIAVBEGoiBiAIIAVBBGoQpCtB0ABBCBCtNiIBRQ0EDAELIAVBjAFqIAIoAhAiAUE8ahDdICAFQYABaiABQTBqEMMGIAEvAUghBiABKQMoIQwgBUHYAGoiCCABQQhqELEuIAUgDDcDeCAFIAY7AZgBIAVBEGoiBiAIIAVBBGoQpCtB0ABBCBCtNiIBRQ0ECyABQoGAgIAQNwMAIAFBCGogBkHIAPwKAAAgAi0AHCEIIAIvARghCiACLwEaIQtBHEEEEK02IQIgBEUEQCACBEBBpMXPACEGDAYLQQRBHBCjPQALIAIEQEHMxc8AIQYMBQtBBEEcEKM9AAtBkMXPABCyOwALIAVBADYCWEEAIAVBoMXPACAFQdgAakGExs8AEK8rAAtBCEHQABCjPQALQQhB0AAQoz0ACyACIAg6ABggAiAKOwEWIAIgCzsBFCACIAc2AhAgAiADNgIMIAIgATYCBCACIAk6AAALIAAgBjYCCCAAIAI2AgQgAEEINgIACyAFQaABaiQAC7YFAgN/A34jAEGAAmsiBCQAIAEgASgCAEECRkECdGoiASgCECEFIAEoAgwhBiAEQQRqIAJBDGoQwwYgAi0AHCECAkACQAJAAkACQCADBEAgAy0AKEEiRgRAIAQtAARBIkYNAgsgBEEQaiAGIAUgBEEEaiACQQFxEJsUDAILIARB2ABqIAYgBSAEQQRqIAJBAXEQmxQgASgCAEUNAyAEQeABaiICQaiezwAQpSsgBCkD6AEhCCAEKQPgASEJIAIgBEHQAWpBGEEIQQQQnRQgBCgC5AEhAgJAIAQoAuABIgNFBEAgBDUC6AEhBwwBCyAEKQLoASEHIAJBCWoiBUUNACADQf8BIAX8CwALIAQgCDcDuAEgBCAJNwOwASAEIAc3A6gBIAQgAjYCpAEgBCADNgKgASAEQeABaiICQRBBAEEBQQEQoBggBCgC5AEhAyAEKALgAUEBRg0CIAQoAugBIgVBCGpBpNnPACkAADcAACAFQZzZzwApAAA3AAAgBCAFNgLUASAEIAM2AtABIARBEDYC2AEgBCABKAIENgLcASACIARB3AFqEKQSIARBxAFqIgEgBEGgAWogBEHQAWogAhDOCSABEIYwIARB+AFqIgEgBEG4AWopAwA3AwAgBEHwAWoiAiAEQbABaikDADcDACAEQegBaiIDIARBqAFqKQMANwMAIAQgBCkDoAE3A+ABIARB2ABqEJMnIARB8ABqIAEpAwA3AwAgBEHoAGogAikDADcDACAEQeAAaiADKQMANwMAIAQgBCkD4AE3A1gMAwsgBEEQaiAGIAUgBEEEaiACQQFxIAMpAyAgAy0AQRC5FgsgBEHYAGoiASADELEuIAAgBEEQaiABEJwlDAILIAMgBCgC6AFB5KPPABD9LwALIAAgBEHYAGpByAD8CgAACyAEQYACaiQAC5UFAQd/IwBBIGsiByQAIAMoAhwhCyAAKAIIIQYgACgCDCEIIAMQySshDCAHQf8BNgIIIAEoAoQIIQogAiABQYgI/AoAAAJAAkACQAJAAkAgDA0AIAggBmsiCEEGQT8gASgChAhBAkYbTQ0AIAUgB0EIaiAGIAggBUHYxQAQ4CUiBkGIf0sNAUEBIQkgBiAIRg0AQQAhCSAGIAhBB3ZBBGpNDQAgCkEBRgRAIAEgBSAHKAIIEJMjQQBHIQoLIAJBAEGECPwLAEELIAggBygCCCAFQYAIaiIJQdg9IAIgBSALQQdLQQF0ENoVIQYgAiAFIAcoAgggBiAJQdg9EPgBIgZBiH9LDQEgAiAFIAcoAggQ5SMhCyAEQQRqQYABIAIgBygCCCAGIAlB2D0QpAkhBgJAAkAgCkUNACABIAUgBygCCBDlIyIKIAhPDQBBAyEJIAogBiALak0gBkEMaiAIT3INAQtBACEJIAYgC2ogCEkNAwsgAiABQYgI/AoAAAsgBCAJNgIAIARBADYChAEMAgsgBCAGNgKEAQwCCyACQQE2AoQIIARBAjYCACAEIAY2AoQBIAZBiH9LDQELAkACfyAAKAIEIgYgACgCACIIRgRAIAJCADcC3CNBACEDIAJBADYC5CNBACECQQAhAEEAIQVBAAwBCyAHQQhqIAAgBiAIa0EDdSABQYgIaiACQYgIaiAEQZQBaiAEQZkCaiADKAIcIAUgBUHUAWoQ8wogBygCFCIAQYh/Sw0BIAcoAhghBSAHKAIQIQIgBygCCCEDIAcoAgwLIQEgBCAFNgKgAiAEIAI2ApABIAQgATYCjAEgBCADNgKIAQsgBCAANgKcAiAAQQAgAEGJf08bIQYLIAdBIGokACAGC6gFAQl/IwBBEGsiCiQAIApBCGogAkEIaigCADYCACAKIAIpAgA3AwACQCAJRQ0AIAEoAgQgASgCAGtBA3UiDiEMIAEoAiRBAUYEQCABKAIoIQwLA0AgDkUNASABKAIAIA9qIhFBBGovAQBFIAxBAEdxIRAgESgCACIJIQsCQCAJQQFrIg1BAksNAAJ/IA0gEGoiC0EDRgRAIAMoAgBBAWshDSACKAIAQQFrDAELIAMgC0ECdCILaigCACENIAIgC2ooAgALIRIgCSELIA0gEkYNACARIA1BA2oiCzYCAAsgDEEBayEMIAIgCyAQEOUcIAMgCSAQEOUcIA5BAWshDiAPQQhqIQ8MAAsAC0G6fyEJAkAgBUEDSQ0AIAEgACgC0BAgACgC1BAgAEG4AWogBEEDaiIDIAVBA2sgByAAKAK4EiAAKAIIEKsKIgFBiH9LBEAgASEJDAELAkAgAUEYSw0AIAAoAtwFDQBBASABIAYgBxC6DhshAQsgACgCzAUEQCAAEIoNIAAgACkD0BBCIIk3A9AQQQAhCQwBCwJAAkACQAJAAkAgAQ4CAAECCyAHQQNqIgEgBUsNBCAEIAdBDXY6AAIgBCAIIAdBA3RyOwAAIAcEQCADIAYgB/wKAAALIAFBiH9LDQMgAiAKKQMANwIAIAJBCGogCkEIaigCADYCAAwCCyAFQQNGDQMgBCAGLQAAOgADIAQgB0ENdjoAAiAEIAggB0EDdHJBAnI7AAAgAkEIaiAKQQhqKAIANgIAIAIgCikDADcCAEEEIQEMAQsgACAAKQPQEEIgiTcD0BAgBCABQQ12OgACIAQgAUEDdCAIckEEcjsAACABQQNqIQELIAAoAtAQIgAoAtwjQQJHDQAgAEEBNgLcIwsgASEJCyAKQRBqJAAgCQuMBQIFfwJ+IwBBEGsiBSQAAkACQAJAAkAgAC0AAEECTwRAIAINASAAKQMIIQggAC0AHCECDAILIABBCGohBAJAIAIEQCACQQF0IQIgAEEgaiEGA0AgACgCdCEDAkACQCABMgEAIgggACkDYFIEQCADQQdLBEAgBBC9DQsgACAINwNgIABBATYCdAwBCyAAIANBAWoiAzYCdCADQQhLDQELIAAoAnAiA0EHSw0DIAYgA0EDdGogCDcDACAAIAAoAnBBAWoiAzYCcCADQQhHDQAgBBDKJwsgAUECaiEBIAJBAmsiAg0ACwsgACgCdCICIAAoAngiA3IgACgCcCIBckUNBAJAIAMNACABIAJHBEAgAkUgAXINAQwFCyACDQQLIAFBAWtBB0kEQCAAQSBqIQIDQCACIAFBA3RqQgA3AwAgACAAKAJwQQFqIgE2AnAgAUEISQ0ACyAAKAJ4IQMLIAAgASADajYCeCAEQQEQ+gsgAEEANgJ0DAQLIANBCEGUi88AEMMhAAsgAC0AASEDIAJBAXQhBiAAQRBqIQcgACkDCCEIIAAtABwhAgNAIAAgAiADaiIEOgAcIAAgATIBACIJIAKthiAIhCIINwMIAkAgBEH/AXFBwABJBEAgBCECDAELIAUgCDcDCCAHIAVBCGpBCBChNiAAIARBQGoiAjoAHCAAIAkgAyACayIErYhCACAEQf8BcUHAAEkbIgg3AwgLIAFBAmohASAGQQJrIgYNAAsLIAUgCDcDCCACQfgBcUEDdiACQQdxQQBHaiIBQQlJBEAgAEEQaiAFQQhqIAEQoTYgAEEAOgAcIABCADcDCAwCCyABQQhBkInPABCwOwALIAQQvQ0LIAVBEGokAAu2HgQNfwN+AnwBfSMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiENIAdBlAFqIQ4jAEHwAWsiBSQAIAFBDGoQ2zwhBCAFQRBqIAEQkjYQ7iUgBEECdCIDIQkCQAJ/AkACQAJAAkAgA0E8cSICBEAgAyACa0FAayIJIANJDQELQcAAIQsgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiC0UNAQsgBSALNgIwIAUgCTYCLCAFQcAANgIoIAMEQCALQQAgA/wLAAsgBSAENgI4IAUgAzYCNCAFKAIQRQ0DIAUoAiQgBSgCIEYNBCAFQcgAaiAFQRBqEMg0IAVB6ABqIQggDigCBCEJIA4oAgAhBCABKAIQIQMDQAJAIAUpA3AiE1BFBEAgBSkDeCESDAELA0ACfgJAIAUpA1giEkIDUgRAAkACQAJAIBJCAlENACAFIBJQrUIBhjcDWCASp0EBcUUNACAFIAUpA2A3A8gBDAELIAUoAmhFDQEgBUHAAWogCBC2KiAFKQPAASESCyASQgBSDQILIAVCAzcDWAsgBSkDSCISQgJRDQkgBUIANwNIIAUpA1AMAQsgBSkDyAELIRMgEqdBAXFFDQcgBSAFKQN4QkB9IhI3A3ggBSATNwNwIBNQDQALCyAFIBNCASATeiIUhoU3A3AgBSADIBSnIBKnakECdCICaioCACIXOAKQASAEKwMAIBe7ohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgDigCCCEBIAVBzJH/ADYCqAEgBUIENwK0ASAFQYUMNgLcASAFQfQLNgLUASAFIAE2AtABIAVBuwc2AswBIAUgCTYCyAEgBUHMATYCxAEgBUH4kf8ANgLAASAFIAVBwAFqNgKwASAFIAVBkAFqNgLYASAFQQQ2AqwBIAVBmAFqIAVBqAFqEJkOIAVBiAFqIAVBpAFqKAIANgIAIAUgBSkCnAE3A4ABIAUoApgBIQhBgoCAgHghCgwHCyAFQcABaiAVqiIBIAktAAAQ6g8gBSgCwAEiCkGTgICAeEcEQCAFQYgBaiAFQdABaigCADYCACAFIAUpAsgBNwOAASAFKALEASEIDAcFIAIgC2ogATYCAAwBCwALAAtBwAAgCRCjPQALQdyL/wBBKSAFQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgDigCBCEDIA4oAgAhAiABKAIQIQhBACEJA0AgBSAIKgIAIhc4ApQBAkACfyACKwMAIBe7ohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgDigCCCEBIAVBzJH/ADYCwAEgBUIENwLMASAFQYUMNgJkIAVB9As2AlwgBSABNgJYIAVBuwc2AlQgBSADNgJQIAVBzAE2AkwgBUH4kf8ANgJIIAUgBUHIAGo2AsgBIAUgBUGUAWo2AmAgBUEENgLEASAFQawBaiAFQcABahCZDiAFQegBaiAFQbgBaigCADYCACAFIAUpArABNwPgAUGCgICAeCEKIAUoAqwBDAELIAVByABqIBWqIgEgAy0AABDqDyAFKAJIIgpBk4CAgHhGDQEgBUHoAWogBUHYAGooAgA2AgAgBSAFKQJQNwPgASAFKAJMCyEIIAVB4AFqDAQLIAsgATYCACALQQRqIQsgCEEEaiEIIAQgCUEBaiIJRw0ACwsgBUHIAGoiCBCXKSAFQTBqIgIoAgAhASAFKAI0IQQgAiAFQdAAaiIDKQIANwMAIAUpAyghFCAFIAUpAkg3AyggBUEANgI4IAUgFDcCVCAFQQA2AlAgBSAENgJMIAUgATYCSCAFQQhqIAgQ1zsgBSgCCCEBQRxBBBCtNiIJBEAgCUKBgICAEDcCACAJIAUpAkg3AgggCUEQaiADKQIANwIAIAlBGGogBUHYAGoiAigCADYCACAFIAQ2AsgBIAUgATYCxAEgBSAJNgLAASAFQTxqIgEgBUHAAWoQ5RkgAiAFQSBqKQIANwMAIAMgBUEYaikCADcDACAFIAUpAhA3A0ggDSABIAgQyh0gBUEoahDPLwwDC0EEQRwQoz0ACyAFQYABagshASANIAg2AgggDSAKNgIEIA1BKToAACANIAEpAgA3AgwgDUEUaiABQQhqKAIANgIAIAVBKGoQzy8gBSgCECIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQRBqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEOIAdBEGohCyAHQQ5qIQ0jAEHAAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCERIAYoAiQhCiAGKAIgIQUgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBEgBCARaiAFIAoQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBAnQiECEMAkAgEEE8cSIIBEAgECAIa0FAayIMIBBJDQELQcAAIQ8gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiD0UNAQsgBkEANgJQIAYgDzYCSCAGIAw2AkQgBkHAADYCQCAQBEAgEARAIA9BACAQ/AsACyAGKAJIIQ8gBigCUCEJCyAGIBA2AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyANLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCoCALuiEKEkIhZEAAAgAAAA4MFkRSAWRAAAAAAAAOBBY0VyDQAgFqoiASAIEMQpRQ0AIA8gATYCAAwBCyAGQRBqIAZBLGoQhj0gCkEDdiIJIAYoAhQiAU8NAyAGKAIQIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIA9BBGohDyAMQQRqIQwgBCAKQQFqIgpHDQALDAcLIAUEQCAGQfgAaiAFIAogESAEEL8UIAZBmAFqIQogDS0AACEJIAsrAwAhFSABKAIQIQgDQAJAIAYpA6ABIhNQRQRAIAYpA6gBIRIMAQsDQAJ+AkAgBikDiAEiEkIDUgRAAkACQAJAIBJCAlENACAGIBJQrUIBhjcDiAEgEqdBAXFFDQAgBiAGKQOQATcDuAEMAQsgBigCmAFFDQEgBkGwAWogChC2KiAGKQOwASESCyASQgBSDQILIAZCAzcDiAELIAYpA3giEkICUQ0MIAZCADcDeCAGKQOAAQwBCyAGKQO4AQshEyASp0EBcUUNCiAGIAYpA6gBQkB9IhI3A6gBIAYgEzcDoAEgE1ANAAsLIAYgE0IBIBN6IhSGhTcDoAECQCAVIAggFKcgEqdqIg1BAnQiBGoqAgC7ohChJCIWRAAAIAAAAODBZEUgFkQAAAAAAADgQWNFcg0AIBaqIgEgCRDEKUUNACAEIA9qIAE2AgAMAQsgBkEYaiAGQSxqEIY9IA1BA3YiBCAGKAIcIgFJBEAgBigCGCAEaiIBIAEtAABBfiANQQdxd3E6AAAgAkEBaiECDAELCyAEIAFBiIv/ABDDIQALQcSK/wAQsjsACyAJIAFBiIv/ABDDIQALQcAAIAwQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAIQoz0AC0HAACAIEKM9AAsgBkHYAGogBkEsaiIIEIIUIAZB+ABqIg0QlykgBkHIAGoiBCgCACEBIAYoAkwhCiAEIAZBgAFqIgkpAgA3AwAgBikDQCEUIAYgBikCeDcDQCAGQQA2AlAgBiAUNwKEASAGQQA2AoABIAYgCjYCfCAGIAE2AnggBkEIaiANENc7IAYoAgghAUEcQQQQrTYiCwRAIAtCgYCAgBA3AgAgCyAGKQJ4NwIIIAtBEGogCSkCADcCACALQRhqIAZBiAFqIgQoAgA2AgAgBiAKNgK4ASAGIAE2ArQBIAYgCzYCsAEgBkHsAGoiASAGQbABahDlGSAEIAZB6ABqKAIANgIAIAkgBkHgAGopAgA3AwAgBiAGKQJYNwN4IAYgAjYCjAEgDiABIA0Qyh0gBkFAaxDPLyAIEM8vIAZBwAFqJAAMAgtBBEEcEKM9AAtB3Iv/AEEpIAZB+ABqQeyP/wBBiIz/ABDVHgALIAdBGGogDiAHLQAOIAMQoBMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAILQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABB5JmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAwBCyAHQdcAaiICIAdB9ABqKQAANwAAIAdB0ABqIgEgB0HtAGopAAA3AwAgB0HAAWogB0GEAWopAgA3AgAgB0HIAWogB0GMAWopAgA3AgAgB0GpAWogASkDADcAACAHQbABaiACKQAANwAAIAcgBykAZSIUNwNIIAcgBykCfDcCuAEgByADOgCgASAHIBQ3AKEBIAdBGGogB0GgAWogBy0ADiAHLQAPEKATIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwBC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQeSZgAE2AgggACABNgIEIABBk4CAgHg2AgALIAdB0AFqJAAPC0EEQTgQoz0AC0EEQTgQoz0AC6oeAw1/A34CfCMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiEMIAdBlAFqIQojAEHwAWsiBSQAIAFBDGoQ2DwhBCAFQQhqIAEQkjYQ7iUgBEECdCIDIQkCQAJ/AkACQAJAAkAgA0E8cSICBEAgAyACa0FAayIJIANJDQELQcAAIQsgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiC0UNAQsgBSALNgIoIAUgCTYCJCAFQcAANgIgIAMEQCALQQAgA/wLAAsgBSAENgIwIAUgAzYCLCAFKAIIRQ0DIAUoAhwgBSgCGEYNBCAFQUBrIAVBCGoQyDQgBUHgAGohCCAKKAIEIQkgCigCACEEIAEoAhAhAwNAAkAgBSkDaCITUEUEQCAFKQNwIRIMAQsDQAJ+AkAgBSkDUCISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwNQIBKnQQFxRQ0AIAUgBSkDWDcDyAEMAQsgBSgCYEUNASAFQcABaiAIELYqIAUpA8ABIRILIBJCAFINAgsgBUIDNwNQCyAFKQNAIhJCAlENCSAFQgA3A0AgBSkDSAwBCyAFKQPIAQshEyASp0EBcUUNByAFIAUpA3BCQH0iEjcDcCAFIBM3A2ggE1ANAAsLIAUgE0IBIBN6IhSGhTcDaCAFIAMgFKcgEqdqIgJBA3RqKwMAIhU5A4gBIBUgBCsDAKIQoSQiFUQAACAAAADgwWQgFUQAAAAAAADgQWNxRQRAIAooAgghASAFQcyR/wA2AqgBIAVCBDcCtAEgBUGJDDYC3AEgBUH0CzYC1AEgBSABNgLQASAFQbsHNgLMASAFIAk2AsgBIAVBzAE2AsQBIAVB+JH/ADYCwAEgBSAFQcABajYCsAEgBSAFQYgBajYC2AEgBUEENgKsASAFQZQBaiAFQagBahCZDiAFQYABaiAFQaABaigCADYCACAFIAUpApgBNwN4IAUoApQBIQhBgoCAgHghDwwHCyAFQcABaiAVqiIBIAktAAAQ6g8gBSgCwAEiD0GTgICAeEcEQCAFQYABaiAFQdABaigCADYCACAFIAUpAsgBNwN4IAUoAsQBIQgMBwUgCyACQQJ0aiABNgIADAELAAsAC0HAACAJEKM9AAtB3Iv/AEEpIAVBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAERQ0AIAooAgQhAyAKKAIAIQIgASgCECEIQQAhCQNAIAUgCCsDACIVOQOQAQJAAn8gFSACKwMAohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgCigCCCEBIAVBzJH/ADYCwAEgBUIENwLMASAFQYkMNgJcIAVB9As2AlQgBSABNgJQIAVBuwc2AkwgBSADNgJIIAVBzAE2AkQgBUH4kf8ANgJAIAUgBUFAazYCyAEgBSAFQZABajYCWCAFQQQ2AsQBIAVBrAFqIAVBwAFqEJkOIAVB6AFqIAVBuAFqKAIANgIAIAUgBSkCsAE3A+ABQYKAgIB4IQ8gBSgCrAEMAQsgBUFAayAVqiIBIAMtAAAQ6g8gBSgCQCIPQZOAgIB4Rg0BIAVB6AFqIAVB0ABqKAIANgIAIAUgBSkCSDcD4AEgBSgCRAshCCAFQeABagwECyALIAE2AgAgC0EEaiELIAhBCGohCCAEIAlBAWoiCUcNAAsLIAVBQGsiCBCXKSAFQShqIgIoAgAhASAFKAIsIQQgAiAFQcgAaiIDKQIANwMAIAUpAyAhFCAFIAUpAkA3AyAgBUEANgIwIAUgFDcCTCAFQQA2AkggBSAENgJEIAUgATYCQCAFIAgQ1zsgBSgCACEBQRxBBBCtNiIJBEAgCUKBgICAEDcCACAJIAUpAkA3AgggCUEQaiADKQIANwIAIAlBGGogBUHQAGoiAigCADYCACAFIAQ2AsgBIAUgATYCxAEgBSAJNgLAASAFQTRqIgEgBUHAAWoQ5RkgAiAFQRhqKQIANwMAIAMgBUEQaikCADcDACAFIAUpAgg3A0AgDCABIAgQyh0gBUEgahDPLwwDC0EEQRwQoz0ACyAFQfgAagshASAMIAg2AgggDCAPNgIEIAxBKToAACAMIAEpAgA3AgwgDEEUaiABQQhqKAIANgIAIAVBIGoQzy8gBSgCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQhqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEPIAdBEGohDCAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACENIAZBIGogCBDcOyAIKAIUIQIgCCgCDCERIAYoAiQhCyAGKAIgIQUgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDUUNBAsgBkIANwI4IAYgDTYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBEgBCARaiAFIAsQvxgMAQtBwAAhDSAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiINRQ0CCyAGQgA3AjggBiANNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBAnQiECENAkAgEEE8cSIIBEAgECAIa0FAayINIBBJDQELQcAAIQ4gDUHAABDRNARAAkAgDQRAIA1BwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIA02AkQgBkHAADYCQCAQBEAgEARAIA5BACAQ/AsACyAGKAJIIQ4gBigCUCEJCyAGIBA2AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggDCsDACEVIAEoAhAhDUEAIQJBACEKA0ACQAJAIBUgDSsDAKIQoSQiFkQAACAAAADgwWRFIBZEAAAAAAAA4EFjRXINACAWqiIBIAgQxClFDQAgDiABNgIADAELIAZBEGogBkEsahCGPSAKQQN2IgkgBigCFCIBTw0DIAYoAhAgCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDkEEaiEOIA1BCGohDSAEIApBAWoiCkcNAAsMBwsgBQRAIAZB+ABqIAUgCyARIAQQvxQgBkGYAWohCSAKLQAAIQggDCsDACEVIAEoAhAhBANAAkAgBikDoAEiE1BFBEAgBikDqAEhEgwBCwNAAn4CQCAGKQOIASISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwOIASASp0EBcUUNACAGIAYpA5ABNwO4AQwBCyAGKAKYAUUNASAGQbABaiAJELYqIAYpA7ABIRILIBJCAFINAgsgBkIDNwOIAQsgBikDeCISQgJRDQwgBkIANwN4IAYpA4ABDAELIAYpA7gBCyETIBKnQQFxRQ0KIAYgBikDqAFCQH0iEjcDqAEgBiATNwOgASATUA0ACwsgBiATQgEgE3oiFIaFNwOgAQJAIBUgBCAUpyASp2oiDEEDdGorAwCiEKEkIhZEAAAgAAAA4MFkRSAWRAAAAAAAAOBBY0VyDQAgFqoiASAIEMQpRQ0AIA4gDEECdGogATYCAAwBCyAGQRhqIAZBLGoQhj0gDEEDdiIKIAYoAhwiAUkEQCAGKAIYIApqIgEgAS0AAEF+IAxBB3F3cToAACACQQFqIQIMAQsLIAogAUGIi/8AEMMhAAtBxIr/ABCyOwALIAkgAUGIi/8AEMMhAAtBwAAgDRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgAhCjPQALQcAAIAgQoz0ACyAGQdgAaiAGQSxqIggQghQgBkH4AGoiDBCXKSAGQcgAaiIEKAIAIQEgBigCTCEKIAQgBkGAAWoiCSkCADcDACAGKQNAIRQgBiAGKQJ4NwNAIAZBADYCUCAGIBQ3AoQBIAZBADYCgAEgBiAKNgJ8IAYgATYCeCAGQQhqIAwQ1zsgBigCCCEBQRxBBBCtNiILBEAgC0KBgICAEDcCACALIAYpAng3AgggC0EQaiAJKQIANwIAIAtBGGogBkGIAWoiBCgCADYCACAGIAo2ArgBIAYgATYCtAEgBiALNgKwASAGQewAaiIBIAZBsAFqEOUZIAQgBkHoAGooAgA2AgAgCSAGQeAAaikCADcDACAGIAYpAlg3A3ggBiACNgKMASAPIAEgDBDKHSAGQUBrEM8vIAgQzy8gBkHAAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkH4AGpB7I//AEGIjP8AENUeAAsgB0EYaiAPIActAA4gAxCgEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEHkmYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoBMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABB5JmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALuh4EDX8DfgJ8AX0jAEHQAWsiByQAIAcgAzoADyAHIAI6AA4gB0QAAAAAAAAkQCADwBDeIDkDEAJAAkACQAJAIAQtADRFBEAgByAHQQ9qNgKcASAHIAdBDmo2ApgBIAcgB0EQajYClAEgB0HkAGohDiAHQZQBaiEKIwBB8AFrIgUkACABQQxqENs8IQQgBUEwaiABEJI2EO4lIARBBHQiAyEIAkACQAJAAkACQAJAIANBMHEiAgRAIAMgAmtBQGsiCCADSQ0BC0HAACELIAhBwAAQ0TQEQAJAIAgEQCAIQcAAEK02IgtFDQELIAUgCzYCUCAFIAg2AkwgBUHAADYCSCADBEAgC0EAIAP8CwALIAUgBDYCWCAFIAM2AlQgBSgCMEUNAyAFKAJEIAUoAkBGDQQgBUHoAGogBUEwahDINCAFQYgBaiEEIAooAgQhCCAKKAIAIQMgASgCECECA0ACQCAFKQOQASISUEUEQCAFKQOYASETDAELA0ACfgJAIAUpA3giE0IDUgRAAkACQAJAIBNCAlENACAFIBNQrUIBhjcDeCATp0EBcUUNACAFIAUpA4ABNwPYAQwBCyAFKAKIAUUNASAFQdABaiAEELYqIAUpA9ABIRMLIBNCAFINAgsgBUIDNwN4CyAFKQNoIhNCAlENCSAFQgA3A2ggBSkDcAwBCyAFKQPYAQshEiATp0EBcUUNByAFIAUpA5gBQkB9IhM3A5gBIAUgEjcDkAEgElANAAsLIAUgEkIBIBJ6IhSGhTcDkAEgBSACIBSnIBOnaiIBQQJ0aioCACIXOAKgASADKwMAIBe7ohChJCIVRAAAAAAAAODHZiAVRAAAAAAAAOBHY3FFBEAgCigCCCEBIAVBzJH/ADYCuAEgBUIENwLEASAFQYUMNgLsASAFQfQLNgLkASAFIAE2AuABIAVBuwc2AtwBIAUgCDYC2AEgBUHMATYC1AEgBUGgkf8ANgLQASAFIAVB0AFqNgLAASAFIAVBoAFqNgLoASAFQQQ2ArwBIAVBqAFqIAVBuAFqEJkOIAUpAqgBIRMgBSkCsAEhEgwHCyAFQSBqIBUQ6RYgBUHQAWogBSkDICISIAUpAygiFCAILQAAEK0OIAUoAtABIglBk4CAgHhHBEAgBSkC3AEhEiAFKQLUASETDAgFIAsgAUEEdGoiASAUNwMIIAEgEjcDAAwBCwALAAtBwAAgCBCjPQALQdyL/wBBKSAFQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKgIAIhc4AqQBIAIrAwAgF7uiEKEkIhVEAAAAAAAA4MdmIBVEAAAAAAAA4EdjcUUEQCAKKAIIIQEgBUHMkf8ANgLQASAFQgQ3AtwBIAVBhQw2AoQBIAVB9As2AnwgBSABNgJ4IAVBuwc2AnQgBSADNgJwIAVBzAE2AmwgBUGgkf8ANgJoIAUgBUHoAGo2AtgBIAUgBUGkAWo2AoABIAVBBDYC1AEgBUG8AWogBUHQAWoQmQ4gBSkCvAEhEyAFKQLEASESDAMLIAVBEGogFRDpFiAFQegAaiAFKQMQIhIgBSkDGCIUIAMtAAAQrQ4gBSgCaCIJQZOAgIB4RwRAIAUpAnQhEiAFKQJsIRMMBAsgCyAUNwMIIAsgEjcDACALQRBqIQsgAUEEaiEBIAQgCEEBaiIIRw0ACwsgBUHoAGoiCBCXKSAFQdAAaiICKAIAIQEgBSgCVCEEIAIgBUHwAGoiAykCADcDACAFKQNIIRQgBSAFKQJoNwNIIAVBADYCWCAFIBQ3AnQgBUEANgJwIAUgBDYCbCAFIAE2AmggBUEIaiAIENc7IAUoAgghAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJoNwIIIAlBEGogAykCADcCACAJQRhqIAVB+ABqIgIoAgA2AgAgBSAENgLYASAFIAE2AtQBIAUgCTYC0AEgBUHcAGoiASAFQdABahDiGSACIAVBQGspAgA3AwAgAyAFQThqKQIANwMAIAUgBSkCMDcDaCAOIAEgCBDLHSAFQcgAahDPLwwDC0EEQRwQoz0AC0GCgICAeCEJCyAOIBI3AhAgDiATNwIIIA4gCTYCBCAOQSk6AAAgBUHIAGoQzy8gBSgCMCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQTBqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEjcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiASNwAAIAAgFDcAAAwCCyAHQeQAaiEOIAdBEGohCyAHQQ5qIQojAEHgAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBQGsgCBDcOyAIKAIUIQIgCCgCDCEQIAYoAkQhBSAGKAJAIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwJYIAYgDDYCVCAGIAg2AlAgBkHAADYCTCAGQcwAaiAQIAQgEGogESAFEL8YDAELQcAAIQwgBEEDdiAEQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDQQgAgRAIAJBwAAQrTYiDEUNAgsgBkIANwJYIAYgDDYCVCAGIAI2AlAgBkHAADYCTCAGQcwAaiAEEN4QQQAhAgsgBEEEdCIPIQ0CQCAPQTBxIggEQCAPIAhrQUBrIg0gD0kNAQtBwAAhDCANQcAAENE0BEACQCANBEAgDUHAABCtNiIMRQ0BCyAGQQA2AnAgBiAMNgJoIAYgDTYCZCAGQcAANgJgIA8EQCAPBEAgDEEAIA/8CwALIAYoAmghDCAGKAJwIQkLIAYgDzYCbCAGIAQgCWo2AnACQAJAIAIEQCACIARHDQEgBCECDAgLIARFBEBBACECDAgLIAotAAAhCCALKwMAIRUgASgCECENQQAhAkEAIQoDQAJAAkAgFSANKgIAu6IQoSQiFkQAAAAAAADgx2ZFIBZEAAAAAAAA4EdjRXINACAGQRBqIBYQ6RYgBikDECISIAYpAxgiFCAIEP8gRQ0AIAwgEjcDACAMIBQ3AwgMAQsgBkEIaiAGQcwAahCGPSAKQQN2IgkgBigCDCIBTw0DIAYoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDEEQaiEMIA1BBGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAZBmAFqIBEgBSAQIAQQvxQgBkG4AWohCSAKLQAAIQggCysDACEVIAEoAhAhBANAAkAgBikDwAEiElBFBEAgBikDyAEhEwwBCwNAAn4CQCAGKQOoASITQgNSBEACQAJAAkAgE0ICUQ0AIAYgE1CtQgGGNwOoASATp0EBcUUNACAGIAYpA7ABNwPYAQwBCyAGKAK4AUUNASAGQdABaiAJELYqIAYpA9ABIRMLIBNCAFINAgsgBkIDNwOoAQsgBikDmAEiE0ICUQ0MIAZCADcDmAEgBikDoAEMAQsgBikD2AELIRIgE6dBAXFFDQogBiAGKQPIAUJAfSITNwPIASAGIBI3A8ABIBJQDQALCyAGIBJCASASeiIUhoU3A8ABAkAgFSAEIBSnIBOnaiILQQJ0aioCALuiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEwaiAWEOkWIAYpAzAiEiAGKQM4IhQgCBD/IEUNACAMIAtBBHRqIgEgFDcDCCABIBI3AwAMAQsgBkEoaiAGQcwAahCGPSALQQN2IgogBigCLCIBSQRAIAYoAiggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB+ABqIAZBzABqIggQghQgBkGYAWoiCxCXKSAGQegAaiIEKAIAIQEgBigCbCEKIAQgBkGgAWoiCSkCADcDACAGKQNgIRQgBiAGKQKYATcDYCAGQQA2AnAgBiAUNwKkASAGQQA2AqABIAYgCjYCnAEgBiABNgKYASAGIAsQ1zsgBigCACEBQRxBBBCtNiIFBEAgBUKBgICAEDcCACAFIAYpApgBNwIIIAVBEGogCSkCADcCACAFQRhqIAZBqAFqIgQoAgA2AgAgBiAKNgLYASAGIAE2AtQBIAYgBTYC0AEgBkGMAWoiASAGQdABahDiGSAEIAZBiAFqKAIANgIAIAkgBkGAAWopAgA3AwAgBiAGKQJ4NwOYASAGIAI2AqwBIA4gASALEMsdIAZB4ABqEM8vIAgQzy8gBkHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkGYAWpB7I//AEGIjP8AENUeAAsgB0EYaiAOIActAA4gAxChEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG0mIABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoRMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBtJiAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALuh4DDX8DfgJ8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQ4gB0GUAWohCiMAQYACayIFJAAgAUEMahDYPCEEIAVBOGogARCSNhDuJSAEQQR0IgMhCAJAAkACQAJAAkACQCADQTBxIgIEQCADIAJrQUBrIgggA0kNAQtBwAAhCyAIQcAAENE0BEACQCAIBEAgCEHAABCtNiILRQ0BCyAFIAs2AlggBSAINgJUIAVBwAA2AlAgAwRAIAtBACAD/AsACyAFIAQ2AmAgBSADNgJcIAUoAjhFDQMgBSgCTCAFKAJIRg0EIAVB8ABqIAVBOGoQyDQgBUGQAWohBCAKKAIEIQggCigCACEDIAEoAhAhAgNAAkAgBSkDmAEiElBFBEAgBSkDoAEhEwwBCwNAAn4CQCAFKQOAASITQgNSBEACQAJAAkAgE0ICUQ0AIAUgE1CtQgGGNwOAASATp0EBcUUNACAFIAUpA4gBNwPoAQwBCyAFKAKQAUUNASAFQeABaiAEELYqIAUpA+ABIRMLIBNCAFINAgsgBUIDNwOAAQsgBSkDcCITQgJRDQkgBUIANwNwIAUpA3gMAQsgBSkD6AELIRIgE6dBAXFFDQcgBSAFKQOgAUJAfSITNwOgASAFIBI3A5gBIBJQDQALCyAFIBJCASASeiIUhoU3A5gBIAUgAiAUpyATp2oiAUEDdGorAwAiFTkDqAEgFSADKwMAohChJCIVRAAAAAAAAODHZiAVRAAAAAAAAOBHY3FFBEAgCigCCCEBIAVBzJH/ADYCyAEgBUIENwLUASAFQYkMNgL8ASAFQfQLNgL0ASAFIAE2AvABIAVBuwc2AuwBIAUgCDYC6AEgBUHMATYC5AEgBUGgkf8ANgLgASAFIAVB4AFqNgLQASAFIAVBqAFqNgL4ASAFQQQ2AswBIAVBtAFqIAVByAFqEJkOIAUpArQBIRMgBSkCvAEhEgwHCyAFQSBqIBUQ6RYgBUHgAWogBSkDICISIAUpAygiFCAILQAAEK0OIAUoAuABIglBk4CAgHhHBEAgBSkC7AEhEiAFKQLkASETDAgFIAsgAUEEdGoiASAUNwMIIAEgEjcDAAwBCwALAAtBwAAgCBCjPQALQdyL/wBBKSAFQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKwMAIhU5A7ABIBUgAisDAKIQoSQiFUQAAAAAAADgx2YgFUQAAAAAAADgR2NxRQRAIAooAgghASAFQcyR/wA2AuABIAVCBDcC7AEgBUGJDDYCjAEgBUH0CzYChAEgBSABNgKAASAFQbsHNgJ8IAUgAzYCeCAFQcwBNgJ0IAVBoJH/ADYCcCAFIAVB8ABqNgLoASAFIAVBsAFqNgKIASAFQQQ2AuQBIAVBzAFqIAVB4AFqEJkOIAUpAswBIRMgBSkC1AEhEgwDCyAFQRBqIBUQ6RYgBUHwAGogBSkDECISIAUpAxgiFCADLQAAEK0OIAUoAnAiCUGTgICAeEcEQCAFKQJ8IRIgBSkCdCETDAQLIAsgFDcDCCALIBI3AwAgC0EQaiELIAFBCGohASAEIAhBAWoiCEcNAAsLIAVB8ABqIggQlykgBUHYAGoiAigCACEBIAUoAlwhBCACIAVB+ABqIgMpAgA3AwAgBSkDUCEUIAUgBSkCcDcDUCAFQQA2AmAgBSAUNwJ8IAVBADYCeCAFIAQ2AnQgBSABNgJwIAVBCGogCBDXOyAFKAIIIQFBHEEEEK02IgkEQCAJQoGAgIAQNwIAIAkgBSkCcDcCCCAJQRBqIAMpAgA3AgAgCUEYaiAFQYABaiICKAIANgIAIAUgBDYC6AEgBSABNgLkASAFIAk2AuABIAVB5ABqIgEgBUHgAWoQ4hkgAiAFQcgAaikCADcDACADIAVBQGspAgA3AwAgBSAFKQI4NwNwIA4gASAIEMsdIAVB0ABqEM8vDAMLQQRBHBCjPQALQYKAgIB4IQkLIA4gEjcCECAOIBM3AgggDiAJNgIEIA5BKToAACAFQdAAahDPLyAFKAI4IgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBOGoQ+x4LIAVBgAJqJAAgBy0AZCIDQSlHDQEgB0HbAGogB0H4AGooAgAiATYAACAHQdMAaiAHQfAAaikCACISNwAAIAcgBykCaCIUNwBLIABBEGogATYAACAAQQhqIBI3AAAgACAUNwAADAILIAdB5ABqIQ4gB0EQaiELIAdBDmohCiMAQeABayIGJAAgAUEMahDYPCEEAkACQAJAAkACQAJAIAEQkjYiCARAQcAAIQwgBkFAayAIENw7IAgoAhQhAiAIKAIMIRAgBigCRCEFIAYoAkAhESAEQQN2IARBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiCEHAABDRNEUNBSAIBEAgCEHAABCtNiIMRQ0ECyAGQgA3AlggBiAMNgJUIAYgCDYCUCAGQcAANgJMIAZBzABqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AlggBiAMNgJUIAYgAjYCUCAGQcAANgJMIAZBzABqIAQQ3hBBACECCyAEQQR0Ig8hDQJAIA9BMHEiCARAIA8gCGtBQGsiDSAPSQ0BC0HAACEMIA1BwAAQ0TQEQAJAIA0EQCANQcAAEK02IgxFDQELIAZBADYCcCAGIAw2AmggBiANNgJkIAZBwAA2AmAgDwRAIA8EQCAMQQAgD/wLAAsgBigCaCEMIAYoAnAhCQsgBiAPNgJsIAYgBCAJajYCcAJAAkAgAgRAIAIgBEcNASAEIQIMCAsgBEUEQEEAIQIMCAsgCi0AACEIIAsrAwAhFSABKAIQIQ1BACECQQAhCgNAAkACQCAVIA0rAwCiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEQaiAWEOkWIAYpAxAiEiAGKQMYIhQgCBD/IEUNACAMIBI3AwAgDCAUNwMIDAELIAZBCGogBkHMAGoQhj0gCkEDdiIJIAYoAgwiAU8NAyAGKAIIIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIAxBEGohDCANQQhqIQ0gBCAKQQFqIgpHDQALDAcLIBEEQCAGQZgBaiARIAUgECAEEL8UIAZBuAFqIQkgCi0AACEIIAsrAwAhFSABKAIQIQQDQAJAIAYpA8ABIhJQRQRAIAYpA8gBIRMMAQsDQAJ+AkAgBikDqAEiE0IDUgRAAkACQAJAIBNCAlENACAGIBNQrUIBhjcDqAEgE6dBAXFFDQAgBiAGKQOwATcD2AEMAQsgBigCuAFFDQEgBkHQAWogCRC2KiAGKQPQASETCyATQgBSDQILIAZCAzcDqAELIAYpA5gBIhNCAlENDCAGQgA3A5gBIAYpA6ABDAELIAYpA9gBCyESIBOnQQFxRQ0KIAYgBikDyAFCQH0iEzcDyAEgBiASNwPAASASUA0ACwsgBiASQgEgEnoiFIaFNwPAAQJAIBUgBCAUpyATp2oiC0EDdGorAwCiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEwaiAWEOkWIAYpAzAiEiAGKQM4IhQgCBD/IEUNACAMIAtBBHRqIgEgFDcDCCABIBI3AwAMAQsgBkEoaiAGQcwAahCGPSALQQN2IgogBigCLCIBSQRAIAYoAiggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB+ABqIAZBzABqIggQghQgBkGYAWoiCxCXKSAGQegAaiIEKAIAIQEgBigCbCEKIAQgBkGgAWoiCSkCADcDACAGKQNgIRQgBiAGKQKYATcDYCAGQQA2AnAgBiAUNwKkASAGQQA2AqABIAYgCjYCnAEgBiABNgKYASAGIAsQ1zsgBigCACEBQRxBBBCtNiIFBEAgBUKBgICAEDcCACAFIAYpApgBNwIIIAVBEGogCSkCADcCACAFQRhqIAZBqAFqIgQoAgA2AgAgBiAKNgLYASAGIAE2AtQBIAYgBTYC0AEgBkGMAWoiASAGQdABahDiGSAEIAZBiAFqKAIANgIAIAkgBkGAAWopAgA3AwAgBiAGKQJ4NwOYASAGIAI2AqwBIA4gASALEMsdIAZB4ABqEM8vIAgQzy8gBkHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkGYAWpB7I//AEGIjP8AENUeAAsgB0EYaiAOIActAA4gAxChEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG0mIABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoRMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBtJiAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALrxoDDX8EfgF8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQwgB0GUAWohAyMAQaABayIGJAAgAUEMahDYPCEEIAZBCGogARCSNhDuJSAEQQV0IgghCQJAAkACQAJAAkACQAJAAkAgCEEgcSICBEAgCCACa0FAayIJIAhJDQELQcAAIQIgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiAkUNAQsgBiACNgIoIAYgCTYCJCAGQcAANgIgIAgEQCACQQAgCPwLAAsgBiAENgIwIAYgCDYCLCAGIAE2AkAgBiADNgI8IAYgBDYCOCAGIAI2AjQgBigCCEUNAyAGKAIcIAYoAhhGDQQgBkHQAGogBkEIahDINCAGQfAAaiEBA0ACQCAGKQN4IhNQRQRAIAYpA4ABIRIMAQsDQAJ+AkAgBikDYCISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwNgIBKnQQFxRQ0AIAYgBikDaDcDkAEMAQsgBigCcEUNASAGQYgBaiABELYqIAYpA4gBIRILIBJCAFINAgsgBkIDNwNgCyAGKQNQIhJCAlENCSAGQgA3A1AgBikDWAwBCyAGKQOQAQshEyASp0EBcUUNByAGIAYpA4ABQkB9IhI3A4ABIAYgEzcDeCATUA0ACwsgBiATQgEgE3oiFIaFNwN4IAZBiAFqIAZBNGogFKcgEqdqEIkOIAYoAogBIglBk4CAgHhGDQALIAwgBikCjAE3AgggDEEQaiAGQZQBaikCADcCAAwGC0HAACAJEKM9AAtB3Iv/AEEpIAZB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBEUNAEEAIQEDQCAGQdAAaiAGQTRqIAEQiQ4gBigCUCIJQZOAgIB4Rw0CIAQgAUEBaiIBRw0ACwsgBkHQAGoiCBCXKSAGQShqIgIoAgAhASAGKAIsIQQgAiAGQdgAaiIDKQIANwMAIAYpAyAhFCAGIAYpAlA3AyAgBkEANgIwIAYgFDcCXCAGQQA2AlggBiAENgJUIAYgATYCUCAGIAgQ1zsgBigCACEBQRxBBBCtNiIJRQ0DIAlCgYCAgBA3AgAgCSAGKQJQNwIIIAlBEGogAykCADcCACAJQRhqIAZB4ABqIgIoAgA2AgAgBiAENgKQASAGIAE2AowBIAYgCTYCiAEgBkHEAGoiASAGQYgBahDiGSACIAZBGGopAgA3AwAgAyAGQRBqKQIANwMAIAYgBikCCDcDUCAMIAEgCBDOHSAGQSBqEM8vDAILIAwgBikCVDcCCCAMQRBqIAZB3ABqKQIANwIACyAMQSk6AAAgDCAJNgIEIAZBIGoQzy8gBigCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQhqEPseCyAGQaABaiQADAELQQRBHBCjPQALIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEMIAdBEGohDiAHQQ5qIQYjAEHgAWsiBSQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEKIAVBGGogCBDcOyAIKAIUIQIgCCgCDCEQIAUoAhwhDyAFKAIYIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiCkUNBAsgBUIANwIwIAUgCjYCLCAFIAg2AiggBUHAADYCJCAFQSRqIBAgBCAQaiARIA8QvxgMAQtBwAAhCiAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIKRQ0CCyAFQgA3AjAgBSAKNgIsIAUgAjYCKCAFQcAANgIkIAVBJGogBBDeEEEAIQILIARBBXQiCiENAkAgCkEgcSIIBEAgCiAIa0FAayINIApJDQELQcAAIQsgDUHAABDRNARAAkAgDQRAIA1BwAAQrTYiC0UNAQsgBUEANgJIIAUgCzYCQCAFIA02AjwgBUHAADYCOCAKBEAgCgRAIAtBACAK/AsACyAFKAJAIQsgBSgCSCEJCyAFIAo2AkQgBSAEIAlqNgJIAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAGLQAAIQggDisDACEWIAEoAhAhDUEAIQJBACEKA0AgBUHwAGogFiANKwMAohChJBCjBgJAAkAgBSgCcEEBcUUNACAFKQOAASIVIAUpA4gBIhIgBSkDkAEiEyAFKQOYASIUIAgQ3B1FDQAgCyAVNwMAIAtBGGogFDcDACALQRBqIBM3AwAgCyASNwMIDAELIAVBCGogBUEkahCGPSAKQQN2IgkgBSgCDCIBTw0DIAUoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgC0EgaiELIA1BCGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAVB8ABqIBEgDyAQIAQQvxQgBUGQAWohCSAGLQAAIQggDisDACEWIAEoAhAhBANAAkAgBSkDmAEiE1BFBEAgBSkDoAEhEgwBCwNAAn4CQCAFKQOAASISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwOAASASp0EBcUUNACAFIAUpA4gBNwO4AQwBCyAFKAKQAUUNASAFQbABaiAJELYqIAUpA7ABIRILIBJCAFINAgsgBUIDNwOAAQsgBSkDcCISQgJRDQwgBUIANwNwIAUpA3gMAQsgBSkDuAELIRMgEqdBAXFFDQogBSAFKQOgAUJAfSISNwOgASAFIBM3A5gBIBNQDQALCyAFIBNCASATeiIUhoU3A5gBIAVBsAFqIBYgBCAUpyASp2oiDkEDdGorAwCiEKEkEKMGAkAgBSgCsAFBAXFFDQAgBSkDwAEiFSAFKQPIASISIAUpA9ABIhMgBSkD2AEiFCAIENwdRQ0AIAsgDkEFdGoiASAUNwMYIAEgEzcDECABIBI3AwggASAVNwMADAELIAVBEGogBUEkahCGPSAOQQN2IgYgBSgCFCIBSQRAIAUoAhAgBmoiASABLQAAQX4gDkEHcXdxOgAAIAJBAWohAgwBCwsgBiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAVB0ABqIAVBJGoiCBCCFCAFQfAAaiIOEJcpIAVBQGsiBCgCACEBIAUoAkQhBiAEIAVB+ABqIgkpAgA3AwAgBSkDOCEUIAUgBSkCcDcDOCAFQQA2AkggBSAUNwJ8IAVBADYCeCAFIAY2AnQgBSABNgJwIAUgDhDXOyAFKAIAIQFBHEEEEK02Ig8EQCAPQoGAgIAQNwIAIA8gBSkCcDcCCCAPQRBqIAkpAgA3AgAgD0EYaiAFQYABaiIEKAIANgIAIAUgBjYCuAEgBSABNgK0ASAFIA82ArABIAVB5ABqIgEgBUGwAWoQ4hkgBCAFQeAAaigCADYCACAJIAVB2ABqKQIANwMAIAUgBSkCUDcDcCAFIAI2AoQBIAwgASAOEM4dIAVBOGoQzy8gCBDPLyAFQeABaiQADAILQQRBHBCjPQALQdyL/wBBKSAFQfAAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIAwgBy0ADiADEKMTIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQYyZgAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiFDcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByAUNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCjEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEGMmYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAuxGgMNfwR+AXwjAEHQAWsiByQAIAcgAzoADyAHIAI6AA4gB0QAAAAAAAAkQCADwBDeIDkDEAJAAkACQAJAIAQtADRFBEAgByAHQQ9qNgKcASAHIAdBDmo2ApgBIAcgB0EQajYClAEgB0HkAGohDCAHQZQBaiEDIwBBoAFrIgYkACABQQxqENs8IQQgBkEIaiABEJI2EO4lIARBBXQiCCEJAkACQAJAAkACQAJAAkACQCAIQSBxIgIEQCAIIAJrQUBrIgkgCEkNAQtBwAAhAiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiICRQ0BCyAGIAI2AiggBiAJNgIkIAZBwAA2AiAgCARAIAJBACAI/AsACyAGIAQ2AjAgBiAINgIsIAYgATYCQCAGIAM2AjwgBiAENgI4IAYgAjYCNCAGKAIIRQ0DIAYoAhwgBigCGEYNBCAGQdAAaiAGQQhqEMg0IAZB8ABqIQEDQAJAIAYpA3giE1BFBEAgBikDgAEhEgwBCwNAAn4CQCAGKQNgIhJCA1IEQAJAAkACQCASQgJRDQAgBiASUK1CAYY3A2AgEqdBAXFFDQAgBiAGKQNoNwOQAQwBCyAGKAJwRQ0BIAZBiAFqIAEQtiogBikDiAEhEgsgEkIAUg0CCyAGQgM3A2ALIAYpA1AiEkICUQ0JIAZCADcDUCAGKQNYDAELIAYpA5ABCyETIBKnQQFxRQ0HIAYgBikDgAFCQH0iEjcDgAEgBiATNwN4IBNQDQALCyAGIBNCASATeiIUhoU3A3ggBkGIAWogBkE0aiAUpyASp2oQpg4gBigCiAEiCUGTgICAeEYNAAsgDCAGKQKMATcCCCAMQRBqIAZBlAFqKQIANwIADAYLQcAAIAkQoz0AC0Hci/8AQSkgBkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAERQ0AQQAhAQNAIAZB0ABqIAZBNGogARCmDiAGKAJQIglBk4CAgHhHDQIgBCABQQFqIgFHDQALCyAGQdAAaiIIEJcpIAZBKGoiAigCACEBIAYoAiwhBCACIAZB2ABqIgMpAgA3AwAgBikDICEUIAYgBikCUDcDICAGQQA2AjAgBiAUNwJcIAZBADYCWCAGIAQ2AlQgBiABNgJQIAYgCBDXOyAGKAIAIQFBHEEEEK02IglFDQMgCUKBgICAEDcCACAJIAYpAlA3AgggCUEQaiADKQIANwIAIAlBGGogBkHgAGoiAigCADYCACAGIAQ2ApABIAYgATYCjAEgBiAJNgKIASAGQcQAaiIBIAZBiAFqEOIZIAIgBkEYaikCADcDACADIAZBEGopAgA3AwAgBiAGKQIINwNQIAwgASAIEM4dIAZBIGoQzy8MAgsgDCAGKQJUNwIIIAxBEGogBkHcAGopAgA3AgALIAxBKToAACAMIAk2AgQgBkEgahDPLyAGKAIIIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBCGoQ+x4LIAZBoAFqJAAMAQtBBEEcEKM9AAsgBy0AZCIDQSlHDQEgB0HbAGogB0H4AGooAgAiATYAACAHQdMAaiAHQfAAaikCACITNwAAIAcgBykCaCIUNwBLIABBEGogATYAACAAQQhqIBM3AAAgACAUNwAADAILIAdB5ABqIQwgB0EQaiEOIAdBDmohBiMAQeABayIFJAAgAUEMahDbPCEEAkACQAJAAkACQAJAIAEQkjYiCARAQcAAIQogBUEYaiAIENw7IAgoAhQhAiAIKAIMIRAgBSgCHCEPIAUoAhghESAEQQN2IARBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiCEHAABDRNEUNBSAIBEAgCEHAABCtNiIKRQ0ECyAFQgA3AjAgBSAKNgIsIAUgCDYCKCAFQcAANgIkIAVBJGogECAEIBBqIBEgDxC/GAwBC0HAACEKIARBA3YgBEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0EIAIEQCACQcAAEK02IgpFDQILIAVCADcCMCAFIAo2AiwgBSACNgIoIAVBwAA2AiQgBUEkaiAEEN4QQQAhAgsgBEEFdCIKIQ0CQCAKQSBxIggEQCAKIAhrQUBrIg0gCkkNAQtBwAAhCyANQcAAENE0BEACQCANBEAgDUHAABCtNiILRQ0BCyAFQQA2AkggBSALNgJAIAUgDTYCPCAFQcAANgI4IAoEQCAKBEAgC0EAIAr8CwALIAUoAkAhCyAFKAJIIQkLIAUgCjYCRCAFIAQgCWo2AkgCQAJAIAIEQCACIARHDQEgBCECDAgLIARFBEBBACECDAgLIAYtAAAhCCAOKwMAIRYgASgCECENQQAhAkEAIQoDQCAFQfAAaiAWIA0qAgC7ohChJBCjBgJAAkAgBSgCcEEBcUUNACAFKQOAASIVIAUpA4gBIhIgBSkDkAEiEyAFKQOYASIUIAgQ3B1FDQAgCyAVNwMAIAtBGGogFDcDACALQRBqIBM3AwAgCyASNwMIDAELIAVBCGogBUEkahCGPSAKQQN2IgkgBSgCDCIBTw0DIAUoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgC0EgaiELIA1BBGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAVB8ABqIBEgDyAQIAQQvxQgBUGQAWohCSAGLQAAIQggDisDACEWIAEoAhAhBANAAkAgBSkDmAEiE1BFBEAgBSkDoAEhEgwBCwNAAn4CQCAFKQOAASISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwOAASASp0EBcUUNACAFIAUpA4gBNwO4AQwBCyAFKAKQAUUNASAFQbABaiAJELYqIAUpA7ABIRILIBJCAFINAgsgBUIDNwOAAQsgBSkDcCISQgJRDQwgBUIANwNwIAUpA3gMAQsgBSkDuAELIRMgEqdBAXFFDQogBSAFKQOgAUJAfSISNwOgASAFIBM3A5gBIBNQDQALCyAFIBNCASATeiIUhoU3A5gBIAVBsAFqIBYgBCAUpyASp2oiDkECdGoqAgC7ohChJBCjBgJAIAUoArABQQFxRQ0AIAUpA8ABIhUgBSkDyAEiEiAFKQPQASITIAUpA9gBIhQgCBDcHUUNACALIA5BBXRqIgEgFDcDGCABIBM3AxAgASASNwMIIAEgFTcDAAwBCyAFQRBqIAVBJGoQhj0gDkEDdiIGIAUoAhQiAUkEQCAFKAIQIAZqIgEgAS0AAEF+IA5BB3F3cToAACACQQFqIQIMAQsLIAYgAUGIi/8AEMMhAAtBxIr/ABCyOwALIAkgAUGIi/8AEMMhAAtBwAAgDRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgAhCjPQALQcAAIAgQoz0ACyAFQdAAaiAFQSRqIggQghQgBUHwAGoiDhCXKSAFQUBrIgQoAgAhASAFKAJEIQYgBCAFQfgAaiIJKQIANwMAIAUpAzghFCAFIAUpAnA3AzggBUEANgJIIAUgFDcCfCAFQQA2AnggBSAGNgJ0IAUgATYCcCAFIA4Q1zsgBSgCACEBQRxBBBCtNiIPBEAgD0KBgICAEDcCACAPIAUpAnA3AgggD0EQaiAJKQIANwIAIA9BGGogBUGAAWoiBCgCADYCACAFIAY2ArgBIAUgATYCtAEgBSAPNgKwASAFQeQAaiIBIAVBsAFqEOIZIAQgBUHgAGooAgA2AgAgCSAFQdgAaikCADcDACAFIAUpAlA3A3AgBSACNgKEASAMIAEgDhDOHSAFQThqEM8vIAgQzy8gBUHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBUHwAGpB7I//AEGIjP8AENUeAAsgB0EYaiAMIActAA4gAxCjEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEGMmYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoxMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBjJmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALox0DDX8DfgJ8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQ0gB0GUAWohCiMAQdABayIFJAAgAUEMahDYPCEEIAVBCGogARCSNhDuJSAEQQN0IgMhCAJAAkACQAJAAkACQCADQThxIgIEQCADIAJrQUBrIgggA0kNAQtBwAAhCyAIQcAAENE0BEACQCAIBEAgCEHAABCtNiILRQ0BCyAFIAs2AiggBSAINgIkIAVBwAA2AiAgAwRAIAtBACAD/AsACyAFIAQ2AjAgBSADNgIsIAUoAghFDQMgBSgCHCAFKAIYRg0EIAVBQGsgBUEIahDINCAFQeAAaiEEIAooAgQhCCAKKAIAIQMgASgCECECA0ACQCAFKQNoIhRQRQRAIAUpA3AhEgwBCwNAAn4CQCAFKQNQIhJCA1IEQAJAAkACQCASQgJRDQAgBSASUK1CAYY3A1AgEqdBAXFFDQAgBSAFKQNYNwO4AQwBCyAFKAJgRQ0BIAVBsAFqIAQQtiogBSkDsAEhEgsgEkIAUg0CCyAFQgM3A1ALIAUpA0AiEkICUQ0JIAVCADcDQCAFKQNIDAELIAUpA7gBCyEUIBKnQQFxRQ0HIAUgBSkDcEJAfSISNwNwIAUgFDcDaCAUUA0ACwsgBSAUQgEgFHoiE4aFNwNoIAUgAiATpyASp2pBA3QiAWorAwAiFTkDeCAVIAMrAwCiEKEkIhVEAAAAAAAA4MNmIBVEAAAAAAAA4ENjcUUEQCAKKAIIIQEgBUHMkf8ANgKYASAFQgQ3AqQBIAVBiQw2AswBIAVB9As2AsQBIAUgATYCwAEgBUG7BzYCvAEgBSAINgK4ASAFQcwBNgK0ASAFQaCS/wA2ArABIAUgBUGwAWo2AqABIAUgBUH4AGo2AsgBIAVBBDYCnAEgBUGEAWogBUGYAWoQmQ4gBSkChAEhEiAFKQKMASEUDAcLIAVBsAFqIBWwIhMgCC0AABCNECAFKAKwASIJQZOAgIB4RwRAIAUpArwBIRQgBSkCtAEhEgwIBSABIAtqIBM3AwAMAQsACwALQcAAIAgQoz0AC0Hci/8AQSkgBUFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKwMAIhU5A4ABIBUgAisDAKIQoSQiFUQAAAAAAADgw2YgFUQAAAAAAADgQ2NxRQRAIAooAgghASAFQcyR/wA2ArABIAVCBDcCvAEgBUGJDDYCXCAFQfQLNgJUIAUgATYCUCAFQbsHNgJMIAUgAzYCSCAFQcwBNgJEIAVBoJL/ADYCQCAFIAVBQGs2ArgBIAUgBUGAAWo2AlggBUEENgK0ASAFQZwBaiAFQbABahCZDiAFKQKcASESIAUpAqQBIRQMAwsgBUFAayAVsCITIAMtAAAQjRAgBSgCQCIJQZOAgIB4RwRAIAUpAkwhFCAFKQJEIRIMBAsgCyATNwMAIAtBCGohCyABQQhqIQEgBCAIQQFqIghHDQALCyAFQUBrIggQlykgBUEoaiICKAIAIQEgBSgCLCEEIAIgBUHIAGoiAykCADcDACAFKQMgIRMgBSAFKQJANwMgIAVBADYCMCAFIBM3AkwgBUEANgJIIAUgBDYCRCAFIAE2AkAgBSAIENc7IAUoAgAhAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJANwIIIAlBEGogAykCADcCACAJQRhqIAVB0ABqIgIoAgA2AgAgBSAENgK4ASAFIAE2ArQBIAUgCTYCsAEgBUE0aiIBIAVBsAFqEOQZIAIgBUEYaikCADcDACADIAVBEGopAgA3AwAgBSAFKQIINwNAIA0gASAIEMYdIAVBIGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghCQsgDSAUNwIQIA0gEjcCCCANIAk2AgQgDUEpOgAAIAVBIGoQzy8gBSgCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQhqEPseCyAFQdABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiFDcAACAHIAcpAmgiEzcASyAAQRBqIAE2AAAgAEEIaiAUNwAAIAAgEzcAAAwCCyAHQeQAaiENIAdBEGohCyAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCEQIAYoAiQhBSAGKAIgIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBA3QiDyEMAkAgD0E4cSIIBEAgDyAIa0FAayIMIA9JDQELQcAAIQ4gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIAw2AkQgBkHAADYCQCAPBEAgDwRAIA5BACAP/AsACyAGKAJIIQ4gBigCUCEJCyAGIA82AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCsDAKIQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgDiATNwMADAELIAZBEGogBkEsahCGPSAKQQN2IgkgBigCFCIBTw0DIAYoAhAgCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDkEIaiEOIAxBCGohDCAEIApBAWoiCkcNAAsMBwsgEQRAIAZB+ABqIBEgBSAQIAQQvxQgBkGYAWohCSAKLQAAIQggCysDACEVIAEoAhAhBANAAkAgBikDoAEiFFBFBEAgBikDqAEhEgwBCwNAAn4CQCAGKQOIASISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwOIASASp0EBcUUNACAGIAYpA5ABNwO4AQwBCyAGKAKYAUUNASAGQbABaiAJELYqIAYpA7ABIRILIBJCAFINAgsgBkIDNwOIAQsgBikDeCISQgJRDQwgBkIANwN4IAYpA4ABDAELIAYpA7gBCyEUIBKnQQFxRQ0KIAYgBikDqAFCQH0iEjcDqAEgBiAUNwOgASAUUA0ACwsgBiAUQgEgFHoiE4aFNwOgAQJAIBUgBCATpyASp2oiC0EDdCIBaisDAKIQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgASAOaiATNwMADAELIAZBGGogBkEsahCGPSALQQN2IgogBigCHCIBSQRAIAYoAhggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACAMEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB2ABqIAZBLGoiCBCCFCAGQfgAaiILEJcpIAZByABqIgQoAgAhASAGKAJMIQogBCAGQYABaiIJKQIANwMAIAYpA0AhEyAGIAYpAng3A0AgBkEANgJQIAYgEzcChAEgBkEANgKAASAGIAo2AnwgBiABNgJ4IAZBCGogCxDXOyAGKAIIIQFBHEEEEK02IgUEQCAFQoGAgIAQNwIAIAUgBikCeDcCCCAFQRBqIAkpAgA3AgAgBUEYaiAGQYgBaiIEKAIANgIAIAYgCjYCuAEgBiABNgK0ASAGIAU2ArABIAZB7ABqIgEgBkGwAWoQ5BkgBCAGQegAaigCADYCACAJIAZB4ABqKQIANwMAIAYgBikCWDcDeCAGIAI2AowBIA0gASALEMYdIAZBQGsQzy8gCBDPLyAGQcABaiQADAILQQRBHBCjPQALQdyL/wBBKSAGQfgAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIA0gBy0ADiADEKITIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQbyagAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiEzcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByATNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCiEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG8moABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAu2HQQNfwN+AnwBfSMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiENIAdBlAFqIQojAEHQAWsiBSQAIAFBDGoQ2zwhBCAFQRBqIAEQkjYQ7iUgBEEDdCIDIQgCQAJAAkACQAJAAkAgA0E4cSICBEAgAyACa0FAayIIIANJDQELQcAAIQsgCEHAABDRNARAAkAgCARAIAhBwAAQrTYiC0UNAQsgBSALNgIwIAUgCDYCLCAFQcAANgIoIAMEQCALQQAgA/wLAAsgBSAENgI4IAUgAzYCNCAFKAIQRQ0DIAUoAiQgBSgCIEYNBCAFQcgAaiAFQRBqEMg0IAVB6ABqIQQgCigCBCEIIAooAgAhAyABKAIQIQIDQAJAIAUpA3AiFFBFBEAgBSkDeCESDAELA0ACfgJAIAUpA1giEkIDUgRAAkACQAJAIBJCAlENACAFIBJQrUIBhjcDWCASp0EBcUUNACAFIAUpA2A3A7gBDAELIAUoAmhFDQEgBUGwAWogBBC2KiAFKQOwASESCyASQgBSDQILIAVCAzcDWAsgBSkDSCISQgJRDQkgBUIANwNIIAUpA1AMAQsgBSkDuAELIRQgEqdBAXFFDQcgBSAFKQN4QkB9IhI3A3ggBSAUNwNwIBRQDQALCyAFIBRCASAUeiIThoU3A3AgBSACIBOnIBKnaiIBQQJ0aioCACIXOAKAASADKwMAIBe7ohChJCIVRAAAAAAAAODDZiAVRAAAAAAAAOBDY3FFBEAgCigCCCEBIAVBzJH/ADYCmAEgBUIENwKkASAFQYUMNgLMASAFQfQLNgLEASAFIAE2AsABIAVBuwc2ArwBIAUgCDYCuAEgBUHMATYCtAEgBUGgkv8ANgKwASAFIAVBsAFqNgKgASAFIAVBgAFqNgLIASAFQQQ2ApwBIAVBiAFqIAVBmAFqEJkOIAUpAogBIRIgBSkCkAEhFAwHCyAFQbABaiAVsCITIAgtAAAQjRAgBSgCsAEiCUGTgICAeEcEQCAFKQK8ASEUIAUpArQBIRIMCAUgCyABQQN0aiATNwMADAELAAsAC0HAACAIEKM9AAtB3Iv/AEEpIAVByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBEUNACAKKAIEIQMgCigCACECIAEoAhAhAUEAIQgDQCAFIAEqAgAiFzgChAEgAisDACAXu6IQoSQiFUQAAAAAAADgw2YgFUQAAAAAAADgQ2NxRQRAIAooAgghASAFQcyR/wA2ArABIAVCBDcCvAEgBUGFDDYCZCAFQfQLNgJcIAUgATYCWCAFQbsHNgJUIAUgAzYCUCAFQcwBNgJMIAVBoJL/ADYCSCAFIAVByABqNgK4ASAFIAVBhAFqNgJgIAVBBDYCtAEgBUGcAWogBUGwAWoQmQ4gBSkCnAEhEiAFKQKkASEUDAMLIAVByABqIBWwIhMgAy0AABCNECAFKAJIIglBk4CAgHhHBEAgBSkCVCEUIAUpAkwhEgwECyALIBM3AwAgC0EIaiELIAFBBGohASAEIAhBAWoiCEcNAAsLIAVByABqIggQlykgBUEwaiICKAIAIQEgBSgCNCEEIAIgBUHQAGoiAykCADcDACAFKQMoIRMgBSAFKQJINwMoIAVBADYCOCAFIBM3AlQgBUEANgJQIAUgBDYCTCAFIAE2AkggBUEIaiAIENc7IAUoAgghAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJINwIIIAlBEGogAykCADcCACAJQRhqIAVB2ABqIgIoAgA2AgAgBSAENgK4ASAFIAE2ArQBIAUgCTYCsAEgBUE8aiIBIAVBsAFqEOQZIAIgBUEgaikCADcDACADIAVBGGopAgA3AwAgBSAFKQIQNwNIIA0gASAIEMYdIAVBKGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghCQsgDSAUNwIQIA0gEjcCCCANIAk2AgQgDUEpOgAAIAVBKGoQzy8gBSgCECIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQRBqEPseCyAFQdABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiFDcAACAHIAcpAmgiEzcASyAAQRBqIAE2AAAgAEEIaiAUNwAAIAAgEzcAAAwCCyAHQeQAaiENIAdBEGohCyAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCEQIAYoAiQhBSAGKAIgIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBA3QiDyEMAkAgD0E4cSIIBEAgDyAIa0FAayIMIA9JDQELQcAAIQ4gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIAw2AkQgBkHAADYCQCAPBEAgDwRAIA5BACAP/AsACyAGKAJIIQ4gBigCUCEJCyAGIA82AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCoCALuiEKEkIhZEAAAAAAAA4MNmRSAWRAAAAAAAAOBDY0VyDQAgFrAiEyAIEMUpRQ0AIA4gEzcDAAwBCyAGQRBqIAZBLGoQhj0gCkEDdiIJIAYoAhQiAU8NAyAGKAIQIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIA5BCGohDiAMQQRqIQwgBCAKQQFqIgpHDQALDAcLIBEEQCAGQfgAaiARIAUgECAEEL8UIAZBmAFqIQkgCi0AACEIIAsrAwAhFSABKAIQIQQDQAJAIAYpA6ABIhRQRQRAIAYpA6gBIRIMAQsDQAJ+AkAgBikDiAEiEkIDUgRAAkACQAJAIBJCAlENACAGIBJQrUIBhjcDiAEgEqdBAXFFDQAgBiAGKQOQATcDuAEMAQsgBigCmAFFDQEgBkGwAWogCRC2KiAGKQOwASESCyASQgBSDQILIAZCAzcDiAELIAYpA3giEkICUQ0MIAZCADcDeCAGKQOAAQwBCyAGKQO4AQshFCASp0EBcUUNCiAGIAYpA6gBQkB9IhI3A6gBIAYgFDcDoAEgFFANAAsLIAYgFEIBIBR6IhOGhTcDoAECQCAVIAQgE6cgEqdqIgtBAnRqKgIAu6IQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgDiALQQN0aiATNwMADAELIAZBGGogBkEsahCGPSALQQN2IgogBigCHCIBSQRAIAYoAhggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACAMEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB2ABqIAZBLGoiCBCCFCAGQfgAaiILEJcpIAZByABqIgQoAgAhASAGKAJMIQogBCAGQYABaiIJKQIANwMAIAYpA0AhEyAGIAYpAng3A0AgBkEANgJQIAYgEzcChAEgBkEANgKAASAGIAo2AnwgBiABNgJ4IAZBCGogCxDXOyAGKAIIIQFBHEEEEK02IgUEQCAFQoGAgIAQNwIAIAUgBikCeDcCCCAFQRBqIAkpAgA3AgAgBUEYaiAGQYgBaiIEKAIANgIAIAYgCjYCuAEgBiABNgK0ASAGIAU2ArABIAZB7ABqIgEgBkGwAWoQ5BkgBCAGQegAaigCADYCACAJIAZB4ABqKQIANwMAIAYgBikCWDcDeCAGIAI2AowBIA0gASALEMYdIAZBQGsQzy8gCBDPLyAGQcABaiQADAILQQRBHBCjPQALQdyL/wBBKSAGQfgAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIA0gBy0ADiADEKITIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQbyagAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiEzcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByATNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCiEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG8moABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAu7HAIgfwN+IwBBkAFrIgYkAAJAIAECfwJAAkACQAJAAkACQAJAAkACQCABLQCQAUEBaw4DBQEAAgsgAUH8AGohGgJAIAEtAHxBAWsOAwoBBAALIAEpAxAhIyABKAIMIQkgASgCCCEHIAEoAgQhAyABKAIAIQgMAgsACyABKAKAASIDKQMAISMgAUEAOgB8IAEgIzcDECABIANBFGoiCTYCDCABIANBCGoiBzYCCCABIAEoAowBIgM2AgQgASABKAKIASIINgIAIAFB/ABqIRoLIAEgAzYCHCABIAg2AhggAUHwAGogCCADICMQ4AkgASgCeCENIAEoAnQhCyAGQShqIQUjAEEQayIEJAACQAJAQfgAQQgQrTYiAwRAIANCADcDYCADQgA3AwggA0KBgICAEDcDACADQQE7AXQgA0F/NgJwIANB6ABqQgA3AwAgBEEEahDrOkEgQQQQrTYiCEUNASAIIAM2AgggCEKBgICAEDcCACAIIAQpAgQ3AgwgCCADQQhqIgM2AhwgCCADNgIYIAhBFGogBEEMaigCADYCACAFQQA6AAggBUEANgIEIAUgCDYCACAEQRBqJAAMAgtBCEH4ABCjPQALQQRBIBCjPQALIAZBIGpCADcDACAGQQA2AjwgBkKAgICAgAE3AjQgBkIANwMYIAZBCjYCVCAGQQA6AFAgBiAJNgJMIAYgBzYCSCAGIAs2AkAgBiALIA1BBHRqNgJEIAFBIGogBkEYakHAAPwKAAAgAUEANgJoIAFCgICAgMAANwNgCyAGQdgAaiEPIwBBMGsiCyQAIAFBIGoiCUFAayEXIAtBHGohGyALQSBqIRwCQANAAkAgC0EYaiERIwBBwAFrIg0kACAJQRBqIQcgCUEoaiEIIA1BEGohEANAAkAgCSgCPCAJKAIUIgMEfyAHKAIAKAIIQQhqIQQDQCADKAJYIARGDQALIAMoAmAFQQALIAkoAiRqTQ0AIA1BCGohDiMAQaABayIKJAACQCAILQAQRQRAIApB0ABqIQVCACEjQgAhJCMAQdAAayIEJAACQAJAIAgiAygCACIMIAMoAgRGBH5CAAUgAyAMQRBqNgIAIAwpAwAhIyAMKQMIISQgBEHEAGogAygCCBDdICADKAIMKAIAIgMgAygCACIMQQFqNgIAIAxBAEgNASAEQRhqIARBzABqKAIANgIAIAQgBCkCRDcDEEIBCyElIAUgJDcDECAFICM3AwggBSAlNwMAIAVBGGogBEEgakEk/AoAACAFIAM2AjwgBUEAOgBMIAUgBCkDEDcDQCAFQcgAaiAEQRhqKAIANgIAIAUgBC8ADTsATSAFQc8AaiAEQQ9qLQAAOgAAIARB0ABqJAAMAQsACyAKKQNQIiNCAlEEQCAOQgI3AwAMAgsgCkEIaiAKQdgAakHIAPwKAAAgI1AEQCAIQQE6ABALIA4gIzcDACAOQQhqIApBCGpByAD8CgAADAELIA5CADcDAAsgCkGgAWokACANKQMIIiNCAlEgI6dBAXFFcg0AIA1B8ABqIgQgEEHIAPwKAAAgCSAJKQMAIiNCAXw3AwAgDSAjNwO4ASAHKAIAKAIIIQUgBxCNJCEKAkBB+ABBCBCtNiIDBEAgA0IBNwMIIANCgYCAgBA3AwAgA0EQaiAEQdAA/AoAACADQQE7AXQgAyAKNgJwIANBADYCbCADQgA3AmQgAyAFQQhqNgJgIAdBADoACCAHKAIEIQQgByADQQhqIgU2AgQCQCAERQRAIANBADYCYCADQQE2AmgMAQsgBygCACgCCEEIaiEKA0AgBCgCWCAKRg0ACyAEKAJgIQogAyAENgJgIAMgCkEBajYCaCAEIAU2AlwLIANBADYCbCAHKAIAIgMoAhggAyAFNgIYIAU2AmQMAQtBCEH4ABCjPQALDAELCyANQdgAaiEOIwBB4ABrIgMkACAJQRxqIR0CQAJAIAkoAiQEQCAJKAIgKQMYIiMgCSkDCFENAQsgCUEQaiEIIANBIGpBBHIhFCADQQRyIRUDQEEAIRhBACEZQQAhHiMAQUBqIgckACAIKAIEIgQEQCAIKAIAKAIIQQhqIQUDQCAEKAJYIAVGDQALIAQoAmAhGAsgCCgCACIEQQxqIAIoAgAiFhCLFANAAkAgByAEQQhqEM0ZAkACQAJAAkACQCAHKAIAIgQEQCAEQQJrDQEgFigCBCAWKAIAKAIIEQMAIANBCjYCAAwDCyAHKAIEIgQoAgBFBEAgByAEQQhrIgQ2AgggBCAEKAIAIgRBAWs2AgAgBEEBRw0FIAdBCGoQtx8MBQsgCCAEEIsdIgotAHQgCkEAOgB0RQ0DIApBADoAdSAHIApBCGoiHzYCLCAHQeiAwwA2AiggB0EANgI4IAcgB0EoaiIFNgI0IAcgBTYCMCAHQQhqIRAgB0EwaiEgIwBBQGoiBSQAIARBCGoiBCkDSCEjAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQtAERBAWsOAwUBAAILAkACQCAELQAwQQFrDgMLAgABCyAEKAIsIRIMBAsgBCgCKCETDAILAAsgBUEYaiIMIARBQGsoAgA2AgAgBSAEKQI4NwMQIAQoAjQhEyAFQRxqIAQpAwAiJCAEKQMIICR9ENgfIARBADoAMCAEIBM2AiggBEEgaiAFQSBqKQMANwIAIARBGGogDCkDADcCACAEIAUpAxA3AhALIAVBMGoiISAEQRhqKAIANgIAIAVBPGogBEEkaigCADYCACAFIAQpAxA3AyggBSAEKQIcNwI0IAVBCGoQziIgBSgCDCESIAUoAgghIkGwB0EIEK02IgxFDQUgDCAFKQMoNwMAIAxBADoAICAMICI2AhwgDCATNgIYIAxBEGogBUE4aikDADcDACAMQQhqICEpAwA3AwAgDEHIpMMAENQaIAQgEjYCLAsgBUEoaiITIBJBCGogIBCoFCAFKAIoDQEgBSkCNCEkIAUoAjAhEiAFKAIsIQwgBEEsahCuLCAMDQJB4KbDAEErIBNBrKfDAEG8usMAENUeAAtB3LjDABDoKwALIARBAzoARCAEQQM6ADAgEEEJNgIADAELIARBAToARCAEQQE6ADAgECAjNwMYIBAgJDcCDCAQIBI2AgggECAMNgIEIBBBCDYCAAsgBUFAayQADAILQQhBsAcQoz0AC0GsusMAEOgrAAsgBygCCEEJRw0BIAgoAgQhBCAIIB82AgQgGSAKLQB1QQBHaiEZAkAgBEUEQCAKQQA2AmAgCkEBNgJoDAELIAgoAgAoAghBCGohBQNAIAQoAlggBUYNAAsgBCgCYCEFIAogBDYCYCAKIAVBAWo2AmggBCAfNgJcCyAZQQFNBEAgHkEBaiIeIBhHDQULIBYoAgQgFigCACgCCBEDACADQQo2AgAMAgsgCCgCBARAIANBCjYCAAwCCyADQQk2AgAgCEEBOgAIDAELIAMgBykDCDcDACADQRhqIAdBIGopAwA3AwAgA0EQaiAHQRhqKQMANwMAIANBCGogB0EQaikDADcDACAKEIgkCyAHQUBrJAAMAgtBm4DDAEEWQbSAwwAQnykACyAIKAIAIQQMAQsLAkACQAJAIAMoAgAiBEEJaw4CAQACCyAOQQo2AgAMBAsgDkEJNgIADAMLIBRBGGogFUEYaigCADYCACAUQRBqIBVBEGopAgA3AgAgFCAVKQIANwIAIBRBCGogFUEIaikCADcCACADIAQ2AiAgAykDOCIjIAkpAwhSBEAgHSADQSBqELkfDAELCyAOIAMpAyA3AwAgCSAjQgF8NwMIIA5BCGogA0EoaikDADcDACAOQRBqIANBMGopAwA3AwAMAQsgCSAjQgF8NwMIIANBQGsgHRCEFSAOQRBqIANB0ABqKQMANwMAIA5BCGogA0HIAGopAwA3AwAgDiADKQNANwMACyADQeAAaiQAAkACQAJAAkAgDSgCWEEJaw4CAgABCyARQQo2AgAMAgsgESANKQNYNwMAIBFBEGogDUHoAGopAwA3AwAgEUEIaiANQeAAaikDADcDAAwBCyARQQlBCiAJLQA4GzYCAAsgDUHAAWokACALKAIYIgNBCEcEQAJAAkAgA0EJaw4CAwEACyALQRBqIAtBLGooAgAiAjYCACALIAspAiQiIzcDCCALKQIcISQgD0EUaiACNgIAIA8gIzcCDCAPICQ3AgQgDyADNgIADAQLIA9BCTYCAAwDCyALQRBqIgMgHEEIaigCADYCACALIBwpAgA3AwggCygCHCIIRQ0AIBsgCykDCDcCACAbQQhqIAMoAgA2AgAgCyAINgIYIBcgC0EYahCFJAwBCwsgDyAXKQIANwIEIA9BDGogF0EIaigCADYCACAJQQA2AkggCUKAgICAwAA3A0AgD0EINgIACyALQTBqJAAgBigCWCICQQlGDQEgBkH4AGoiAyAGQeQAaigCADYCACAGIAYpAlw3A3AgBikDaCEjIAkQxCYgAkEIRg0CIAZBiAFqIAMoAgA2AgAgBiAGKQNwNwOAASABQfAAahDtOwwDC0G89MIAEOgrAAsgGkEDOgAAIABBCTYCAEEDDAILIAZBEGogAygCADYCACAGIAYpA3A3AwggASgCGCEDIAEoAhwhCCAGIAFB8ABqIgQ2AmAgBiADIAhBBHRqNgJcIAYgAzYCWCAGIAZBCGoiAzYCZCAGQYABaiAGQdgAahDVGiADENQnIAMQ7jsgBBDtOwsgAUEBOgB8IAEQoy0gAUGEAWoQ7TsgACACNgIAIAAgIzcDECAAIAYpA4ABNwIEIABBDGogBkGIAWooAgA2AgBBAQs6AJABIAZBkAFqJAAPC0Gs3sIAEOgrAAv7CwEKfyMAQTBrIgUkAAJAIAJFBEAgACABEKAdDAELIAVBADYCECAFQoCAgIDAADcCCAJAIAEoAggiBkUNACABKAIEIQEgBkEDdCEJA0AgAUEEai0AAEUEQCADIAEoAgAgCGoiCyACbiIGIAsgAiAGbEdqIAJsIgYgAyAGSRshDCAIIAggAnBrIQsgBSgCCCAHRgRAIAVBCGpBrIPNABCbKAsgBSgCDCAHQQN0aiIGIAw2AgQgBiALNgIAIAUgB0EBaiIHNgIQCyABKAIAIAhqIQggAUEIaiEBIAlBCGsiCQ0ACyAFKAIMIQwgBSAFQRRqNgIgIAdBAkkNACAHQRVPBEAgBUEgaiELIwBBgCBrIgEkAAJAQcCEPSAHIAdBwIQ9TxsiBiAHIAdBAXZrIgIgAiAGSRsiAkGBBE8EQCMAQRBrIgkkACAJQQRqIAJBAEEEQQgQoBggCSgCCCEGIAkoAgRBAUYEQCAGIAkoAgxBnJnPABD9LwALIAkoAgwhAiABQQA2AgggASACNgIEIAEgBjYCACAJQRBqJAAgDCAHIAEoAgQgASgCCCICQQN0aiABKAIAIAJrIAdBwQBJIAsQ+wkgAUEEQQgQ4B4MAQsgDCAHIAFBgAQgB0HBAEkgCxD7CQsgAUGAIGokAAwBCyAMIAcQ1RYLIAVBADYCHCAFQoCAgIDAADcCFCAFKAIMIQIgBSgCCCEMIAUoAhAiAQRAIAIgAUEDdGohCyACIQEDQCAFKAIcIgRBA3QhDSAFKAIYIQogAUEEaigCACEIIAEoAgAhBwJAAkACQCAERQ0AIAogDWoiBkEIRg0AIAcgBkEEayIGKAIAIglNDQEgBSgCFCAERgR/IAVBFGpBjIPNABCbKCAFKAIYBSAKCyANaiIGIAg2AgQgBiAHNgIAIAUgBEEBajYCHAwCCyAFKAIUIARGBH8gBUEUakGcg80AEJsoIAUoAhgFIAoLIA1qIgYgCDYCBCAGIAc2AgAgBSAEQQFqNgIcDAELIAYgCCAJIAggCUsbNgIACyABQQhqIgEgC0cNAAsLIAUgAjYCJCAFIAw2AiAgBUEgaiIBQQRBCBDgHiAFIAUoAhQ2AiggBSAFKAIYIgI2AiAgBSACNgIkIAUgAiAFKAIcQQN0ajYCLCAAIQIjAEEwayIEJAAgBEEYaiABKAIMIgkgASgCBCIIa0EDdkEAQQRBCBCgGCAEKAIcIQACQAJAIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgADYCDCABKAIIIQwgASgCACELQQAhAANAAkACQAJAAkACQCAIIAlHBEAgCEEEaiEBIAgoAgAhCiAIQQhqIQggCiABKAIAIgFGDQYgASAKayENIAAgCkkgACAKS2tB/wFxDgICAwELIAQgCzYCHCAEIAw2AhggBEEYakEEQQgQ4B4gACADRwRAIAQoAhQiBiAEKAIMRgRAIARBDGpB+P/MABCbKAsgBCgCECAGQQN0aiIBQQE6AAQgASADIABrNgIAIAQgBkEBajYCFAsgAiAEKQIMNwIAIAJBCGogBEEUaigCADYCACAEQTBqJAAMCAsgBEEANgIoIARBATYCHCAEQZSAzQA2AhggBEIENwIgIARBGGpBnIDNABDvLAALIAQoAhQiCkEDdCEGIAQoAhAhACAKBEAgACAGakEIayIHDQILIAQoAgwgCkYEfyAEQQxqQayAzQAQmyggBCgCEAUgAAsgBmoiAEEAOgAEIAAgDTYCACAEIApBAWo2AhQMAgsgBCgCFCIHIAQoAgxGBEAgBEEMakHMgM0AEJsoCyAEKAIQIAdBA3RqIgZBAToABCAGIAogAGs2AgAgBCAHQQFqIgA2AhQgBCgCDCAARgRAIARBDGpB3IDNABCbKAsgBCgCECAAQQN0aiIAQQA6AAQgACANNgIAIAQgB0ECajYCFAwBCyAHKAIAIgYgDWoiACAGSQ0DIAcgADYCAAsgASEADAALAAsgACAEKAIgQej/zAAQ/S8AC0G8gM0AELI7AAsLIAVBMGokAAvuBQEBfyMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIEIAJBATYCDCACQeS8zQA2AgggAkIBNwIUIAJBhAE2AiQgAiACQSBqNgIQIAIgAkEEajYCICABKAIAIAEoAgQgAkEIahDLCgwHCyACIABBBGo2AgQgAkEBNgIMIAJB9LzNADYCCCACQgE3AhQgAkGEATYCJCACIAJBIGo2AhAgAiACQQRqNgIgIAEoAgAgASgCBCACQQhqEMsKDAYLIAIgAEEEajYCBCACQQE2AgwgAkGEvc0ANgIIIAJCATcCFCACQYQBNgIkIAIgAkEgajYCECACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMBQsgAiAAQQRqNgIEIAJBATYCDCACQZS9zQA2AgggAkIBNwIUIAJBhAE2AiQgAiACQSBqNgIQIAIgAkEEajYCICABKAIAIAEoAgQgAkEIahDLCgwECyACIABBBGo2AgAgAiAAQQhqNgIEIAJBAjYCDCACQbS9zQA2AgggAkICNwIUIAJB3AE2AiwgAkHcATYCJCACIAJBIGo2AhAgAiACQQRqNgIoIAIgAjYCICABKAIAIAEoAgQgAkEIahDLCgwDCyACIABBBGo2AgQgAkEBNgIMIAJB0L3NADYCCCACQgE3AhQgAkGlBDYCJCACIAJBIGo2AhAgAiACQQRqNgIgIAEoAgAgASgCBCACQQhqEMsKDAILIAIgAEEEajYCBCACQQE2AgwgAkHovc0ANgIIIAJCATcCFCACQdwBNgIkIAIgAkEgajYCECACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMAQsgAkECNgIMIAJBiL7NADYCCCACQgI3AhQgAkE8NgIsIAIgAEEQajYCKCACQTw2AiQgAiAAQQhqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCgsgAkEwaiQAC78FAgR/CH4jAEGQAWsiAyQAQoCAgICAgICAgH8hDAJAAn4CQAJAIAEoAgwoAhAgAkEEdGoiBSkDACIKIAUpAwgiC0KAgICAgICAgIB/hYRCAFIgASgCCCIFKAIAIgQoAgAiBikDCCIHIAYpAwAiCINCf1JyRQRAQgAhBwwBCyAHIAiEUA0DIANBEGogCiALIAggBxCDGSADIAMpAxAiCSADKQMYIgwgCCAHEKgeQgAgCiADKQMAIg59IAcgCINCf1EiBhshDUIAIAsgAykDCH0gCiAOVK19IAYbIQcgC0IAWQ0BCyAJIA0gBCgCCCIEKQMAWCAHIAQpAwgiCFcgByAIURutIgh9IQcgDCAIIAlWrX0MAQsgDCAJIA0gBCgCBCIEKQMAWiAHIAQpAwgiCFkgByAIURutfCIHIAlUrXwLIQkCQAJAIAACfyAHQoCAgIAIfCIIQoCAgIAQVCAJIAcgCFatfFBxRQRAIAUoAgQhASADIAs3A0ggAyAKNwNAIANBzJH/ADYCWCADQgQ3AmQgA0GEDDYCjAEgA0H0CzYChAEgAyABQQFqNgKAASADQbsHNgJ8IAMgATYCeCADQcwBNgJ0IANB+JH/ADYCcCADIANB8ABqNgJgIAMgA0FAazYCiAEgA0EENgJcIANBMGogA0HYAGoQmQ4gA0EoaiADQTxqKAIANgIAIAMgAykCNDcDIEGCgICAeCEFIAMoAjAMAQsgA0HwAGogB6ciBCAFKAIILQAAEOoPIAMoAnAiBUGTgICAeEYNASADQShqIANBgAFqKAIANgIAIAMgAykCeDcDICADKAJ0CzYCBCAAIAU2AgAgACADKQMgNwIIIABBEGogA0EoaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkECdGogBDYCAAsgA0GQAWokAA8LQcyP/wAQ4isAC9QEAgZ+BH8gACAAKAI4IAJqNgI4AkACQCAAKAI8IgtFBEAMAQtBBCEJAn5BCCALayIKIAIgAiAKSxsiDEEESQRAQQAhCUIADAELIAE1AAALIQMgDCAJQQFySwRAIAEgCWozAAAgCUEDdK2GIAOEIQMgCUECciEJCyAAIAApAzAgCSAMSQR+IAEgCWoxAAAgCUEDdK2GIAOEBSADCyALQQN0QThxrYaEIgM3AzAgAiAKTwRAIAAgACkDGCADhSIEIAApAwh8IgYgACkDECIFQg2JIAUgACkDAHwiBYUiB3wiCCAHQhGJhTcDECAAIAhCIIk3AwggACAGIARCEImFIgRCFYkgBCAFQiCJfCIEhTcDGCAAIAMgBIU3AwAMAQsgAiALaiEJDAELIAIgCmsiAkEHcSEJIAJBeHEiAiAKSwRAIAApAwghBCAAKQMQIQMgACkDGCEGIAApAwAhBQNAIAQgASAKaikAACIHIAaFIgR8IgYgAyAFfCIFIANCDYmFIgN8IgggA0IRiYUhAyAGIARCEImFIgRCFYkgBCAFQiCJfCIFhSEGIAhCIIkhBCAFIAeFIQUgCkEIaiIKIAJJDQALIAAgAzcDECAAIAY3AxggACAENwMIIAAgBTcDAAtBBCECAn4gCUEESQRAQQAhAkIADAELIAEgCmo1AAALIQMgCSACQQFySwRAIAEgCmogAmozAAAgAkEDdK2GIAOEIQMgAkECciECCyAAIAIgCUkEfiABIAIgCmpqMQAAIAJBA3SthiADhAUgAws3AzALIAAgCTYCPAuqBQICfwR+IwBBkAFrIgYkACAGIAQ3AxAgBiAFNwMYIAYgAjcDACAGIAM3AwggBkFAayACIAMgBCAFIAEoAgAiBykDACAHKQMIIAcpAxAgBykDGBCaCAJ+IAYtAEBBAUYEQCAGLQBBBEBCgICAgICAgICAfyEIQgAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBvIv/ABDvLAALIAYpA2ghCCAGKQNgIQkgBikDWCEKIAYpA1ALIQsgBkFAayACIAMgBCAFIAcpAwAgBykDCCAHKQMQIAcpAxgQmggCQCAGLQBAQQFGBEAgBi0AQQRAIAZBOGpCADcDACAGQTBqQgA3AwAgBkIANwMoIAZCADcDIAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakHMi/8AEO8sAAsgBiAGKQOIATcDOCAGIAYpA4ABNwMwIAYgBikDeDcDKCAGIAYpA3A3AyALIAZB2ABqQgA3AwAgBkHQAGpCADcDACAGQgA3A0ggBkIANwNAAkACQAJAIAYgBkFAaxD7GyIHQf8BcUECRyAHwEEATnFFBEAgBkEgaiABKAIIEPsbwEEATA0BDAILIAZBIGogASgCBBD7GyIBQf8BcUECRiABwEEASHINASAIIAkgC0IBfCIEIAogBFCtfCIChFCtfCIFIAlUrXwhCAwCCyALQgF9IQQgCiALUK19IQIgCSAKIAuEUK0iA30hBSAIIAMgCVatfSEIDAELIAkhBSALIQQgCiECCyAGQUBrIAQgAiAFIAgQ1iMgBigCQCEBIAYpA1ghAyAAIAYpA1AiAj4CBCAAIAEgAkKAgICACHwiBEKAgICAEFQgAyACIARWrXxQcXE2AgAgBkGQAWokAAvMBQEFfyMAQeAAayIFJAAgBSABIAIQ9RICfyAFKAIAIghFBEBBASEJIAEhCCACDAELQeTGhQEhCUEBIQcgBSgCBAshBiAFIAk2AgggBSAINgIQIAUgBjYCFCAFIAc2AgwCQAJAIAYgAyADIAZLGyAHaiIDRQ0AIAIgA00EQCACIANGDQEMAgsgASADaiwAAEG/f0wNAQsgBSADNgIcIAUgATYCGAJAAkACQAJAIARB/wFxRQRAIAVByABqIANBAEEBQQEQoBggBSgCTCECIAUoAkhBAUYNASAFKAJQIQQgAwRAIAQgASAD/AoAAAsgACADNgIIIAAgBDYCBCAAIAI2AgAMBAsgBMBBAEgNASAEQf8BcSICIAZPBEAgBUECNgJEIAVBjMeFATYCQCAFQQI2AjQgBUH8xoUBNgIwIAVBAzYCPCAFIAI7AVwgBUEANgJYIAVBxwI2AlQgBUHHAjYCTCAFIAVByABqNgI4IAUgBUEQajYCUCAFIAVBCGo2AkggACAFQTBqEJkODAQLIAMgAmshBCACIANHBEAgAiADSw0DIAEgBGosAABBv39MDQMLIAUgBDYCJCAFIAE2AiAgBSACNgIsIAUgASAEajYCKCAFQQI2AkwgBUG8x4UBNgJIIAVCAjcCVCAFQccCNgI8IAVBxwI2AjQgBSAFQTBqNgJQIAUgBUEoajYCOCAFIAVBIGo2AjAgACAFQcgAahCZDgwDCyACIAUoAlBBnMWFARD9LwALIAVBATYCXCAFQczHhQE2AlggBUEBNgJMIAVB5MOFATYCSCAFQQI2AlQgBUHHAjYCNCAFQQA2AjggBSADQQAgBGtB/wFxajsBPCAFIAVBMGo2AlAgBSAFQRhqNgIwIAAgBUHIAGoQmQ4MAQsgASADQQAgBEGcvYUBEKM2AAsgBUHgAGokAA8LIAEgAkEAIANB6MaFARCjNgAL+gQCCX8BfgJAAkACQAJAAkACQCAEIAdxIgwgA00EQCALKAIIIQ8gACgCLCETIAIgDGoiESADIAxrIhIQtx4hDSAMIA9qIhAgA08NASACIBBqLQAAIRAgC0EANgIMIAcgBigCACIUayIGIAdPDQQCQCADIAQgBnEiBiAPaiIOSwRAIBAgAiAOai0AAEYNAQwGCyAOIANB1MvOABDDIQALIAMgBkkNAiACIAZqIAMgBmsgESASIAgQ9AEiDkUNBCAOIAYgBRChLiIBIBMQ8jQhFSALIBQ2AhAgCyABNgIIIAsgFTcDACABIAxqIgEgA08NAyAAKAIEIgEgDUsEQCAAKAIAIA1BAnRqIAc2AgAMBgsgDSABQYTMzgAQwyEACyAMIANBpMvOABCvOwALIBAgA0G0y84AEMMhAAsgBiADQeTLzgAQrzsACyABIANB9MvOABDDIQALIAAoAgQiBiANTQRAIA0gBkGUzM4AEMMhAAsgACgCACANQQJ0aiIOKAIAIQwgDiAHNgIAAkAgAyAEIAxxIgQgD2oiD0sEQEEAIQ4gByAMayIMQQFrIAlPDQMgECACIA9qLQAARw0DIAMgBEkNASACIARqIAMgBGsgESASIAgQ9AEiAgRAIAIgBCAFEKEuIQAgCyAMNgIQIAsgADYCCCALIAAgDCATEIwtNwMADAMLAkAgAUUEQEEAIQMMAQsgASAAIBEgEiAIIAkgCiALEOkUIQMgACgCBCEGCyAGIA1LBEAgACgCACANQQJ0aiAHNgIAIAMPCyANIAZB5MzOABDDIQALIA8gA0GkzM4AEMMhAAsgBCADQbTMzgAQrzsAC0EBIQ4LIA4LlgcBDX8jAEEQayIFJAACQAJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBG2sODgQABgECCAkKDw8PDwsDDwsgAS0AAEEcRw0ODAQLIAEtAABBHkcNDQwDCyABLQAAQR9HDQwMAgsgAS0AAEEoRg0IDAsLIAEtAABBG0cNCgsgACgCBCIALQBIIAEoAgQiAS0ASEYNAQwHCyABLQAAQR1HDQggACgCBCABKAIERw0JIAAoAggiAC0ASCABKAIIIgEtAEhHDQkgAUEwaiEBIABBMGohAAwHCyABQTBqIQEgAEEwaiEADAYLIAEtAABBIEcNBiAAKAIIIgIgASgCCEcNBCABKAIEQQhqIQEgACgCBEEIaiEAQQAhAwNAAkAgAyIEIAJGBEAgAiEEDAELIAAoAgAiBi0ASCABKAIAIgctAEhHDQAgAUEEaiEBIABBBGohACAEQQFqIQMgBkEwaiAHQTBqEL8JDQELCyACIARNIQQMBwsgAS0AAEEhRw0FIAAtAAEgAS0AAUcNBiAAKAIIIgIgASgCCEcNBiAFIAAoAgRBCGoiADYCCCAFIAAgAkEDdGo2AgwjAEEQayIDJAAgAUEEaiIAKAIAQQhqIgkgACgCBEEDdGohCiAFQQhqIgYoAgAhASAGKAIEIQcDQCAHIAEiAEcEQCAGIAFBCGoiATYCACAALQAAIQQgAyAAQQRqIgI2AgQgAyAEOgAAIAMgCjYCDCADIAk2AggCfyADQQhqIggoAgAiBCAIKAIEIgtHBEAgAigCACIMQTBqIQ0gAy0AACEOA0AgCCAEIgJBCGoiBDYCAAJAIA4gAi0AAEcNACAMLQBIIAJBBGooAgAiAi0ASEcNACANIAJBMGoQvwlFDQBBAQwDCyAEIAtHDQALC0EACw0BCwsgA0EQaiQAIAAgB0YhBAwGCyABLQAAQSJHDQQgACgCBCABKAIEEL8JRQ0CIAEoAgghASAAKAIIIQAMAwsgAS0AAEEnRw0DIAAoAgQiAi0ASCABKAIEIgMtAEhHDQQgAkEwaiADQTBqEL8JRQ0EIAAtAAEgAS0AAUYhBAwECyAAKAIEIgItAEggASgCBCIDLQBIRw0DIAJBMGogA0EwahC/CUUNAyAAKAIIIgAtAEggASgCCCIBLQBIRw0DIAFBMGohASAAQTBqIQAMAQsLDAELIAAgARDMCCEECyAFQRBqJAAgBAvjBQEOfyMAQYABayIEJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0EIIAIbIgVB/wFxIgZFBEAgBEE4ahD+JyAEKAI8IQIgBCgCOCEDDAELIARB+ABqIAFBgIAEELkpIAQoAnwhAiAEKAJ4IQMgBkEBRw0BCyAEQTBqEP4nIAQoAjQhBiAEKAIwIQoMAQsgBEHwAGogAUGAgAQQuSkgBCgCdCEGIAQoAnAhCiAFQf8BcSIHQQJLDQELIARBKGoQ/icgBCgCLCELIAQoAighDAwBCyAEQegAaiABQYCABBC5KSAEKAJsIQsgBCgCaCEMIAdBA0cNAQsgBEEgahD+JyAEKAIkIQcgBCgCICENDAELIARB4ABqIAFBgIAEELkpIAQoAmQhByAEKAJgIQ0gBUH/AXEiCEEESw0BCyAEQRhqEP4nIAQoAhwhDiAEKAIYIQ8MAQsgBEHYAGogAUGAgAQQuSkgBCgCXCEOIAQoAlghDyAIQQVHDQELIARBEGoQ/icgBCgCFCEIIAQoAhAhEAwBCyAEQdAAaiABQYCABBC5KSAEKAJUIQggBCgCUCEQIAVB/wFxIglBBksNAQsgBEEIahD+JyAEKAIMIQUgBCgCCCERDAELIARByABqIAFBgIAEELkpIAQoAkwhBSAEKAJIIREgCUEHRw0BCyAEEP4nIAQoAgAhCSAEKAIEDAELIARBQGsgAUGAgAQQuSkgBCgCQCEJIAQoAkQLIQEgAEIANwN4IAAgCTYCcCAAQgA3A2ggACAFNgJkIAAgETYCYCAAQgA3A1ggACAINgJUIAAgEDYCUCAAQgA3A0ggACAONgJEIAAgDzYCQCAAQgA3AzggACAHNgI0IAAgDTYCMCAAQgA3AyggACALNgIkIAAgDDYCICAAQgA3AxggACAGNgIUIAAgCjYCECAAQgA3AwggACACNgIEIAAgAzYCACAAIAE2AnQgBEGAAWokAAuXBQIIfwF+IwBBIGsiAiQAAkACQAJAAkAgASgCTEEBaiIDIAEoAjBPBEAgAkEQaiIEIAFBCGoiAxClGCACKAIQRQRAIARBJUEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0FIAIoAhgiA0GCo80AQSX8CgAAIAAgA61CgICAgNAEhDcDCCAAIAE2AgQgAEECNgIADAQLIAIpAxgiCkIBiEIAIApCAYN9hSIKQoCAgIAIfEKAgICAEFoEQCACQRBqQRVBAEEBQQEQoBggAigCFCEDIAIoAhBBAUYNAiACKAIYIgFBDWpBtKPNACkAADcAACABQQhqQa+jzQApAAA3AAAgAUGno80AKQAANwAAIABBFTYCDCAAIAE2AgggACADNgIEIABBADYCAAwECyABQQA2AjAgASAKPgJEIAMgAUEoaiIFIAEoAjwQ/h8gASgCOCEDIAEoAiAgASgCJCEEIAJBCGogBRD0LyAEQQN2aiAEQQdxQQBHaiEFIAIoAggiBCACKAIMIgdGDQIDQAJ/IAMEQCAELQAADAELIARBADoAAEEACyADIAEoAkAiCGsiCUEAIAMgCU8bIQMgCGxBA3YgBWohBSAEQQFqIgQgB0cNAAsMAgsgASADNgJMIABBCDYCACABIAEoAkA2AlAMAgsgAyACKAIYQdT9zAAQ/S8ACyABIAU2AkggASgCMCABKAI8RgRAIAFBADYCTCAAQQg2AgAgASABKAJANgJQDAELIAJBEGpBIkEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0BIAIoAhgiA0Hgos0AQSL8CgAAIABBIjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEgaiQADwsgASACKAIYQdT9zAAQ/S8AC78FAgh/AX4gASgCyAEhDCABKALQASEHAn9BASABKAAQIAEoAAxJDQAaQQAgASgCtAEiCUUNABpBA0ECIAkoAmwbCyIJQShsIAdBAnRqQbD00ABqIgggCCAJQQxsIAdBA2siB0ECdGpB0PXQAGogBEEBRxsgB0ECSxsoAgAhCiABKALQAUEGTQRAIAUgBmoiDUEgayEEIANBBGohDgNAIA0gBWshBgJAAkAgACgCBCIHIAAoAgxPIAUgDU9yDQAgACgCACAHQQxsaiIIKAIAIQkCQCAIKAIIIgsgCCgCBCIIaiAGTQRAIAAgB0EBajYCBAwBCyAAIAYgDBCoGCAGIAhNDQEgCUEAIAYgCGsiCyAMTxshCQsgCUUNACABIAUQsikgASAFENQsIAEgAiADIAUgCCAKEQkAIQcgAykCACEPIAMgCTYCACAOIA83AgAgBSAIaiIIIAdrIQUgAigCDCEGIAQgCE8EQCAFKQAAIQ8gBkEIaiAFQQhqKQAANwAAIAYgDzcAACAHQRFJDQIgAigCDEEQaiAFQRBqIAdBEGsQ2BkMAgsgBCAFTwRAIAYgBSAEIAVrIgUQ2BkgBSAGaiEGIAQhBQsDQCAFIAhPDQIgBiAFLQAAOgAAIAZBAWohBiAFQQFqIQUMAAsACyABIAUQsikgASAFENQsIAEgAiADIAUgBiAKEQkADwsgCUEDaiEGIAIgAigCDCAHajYCDAJAIAdB//8DTQRAIAIoAgQhBQwBCyACQQE2AiQgAiACKAIEIgUgAigCAGtBA3U2AigLIAUgBjYCACAFIAc7AQQgC0EDayIGQYCABE8EQCACQQI2AiQgAiAFIAIoAgBrQQN1NgIoCyAFIAY7AQYgAiAFQQhqNgIEIAggC2ohBQwACwALIAEgADYC1AEgASACIAMgBSAGIAoRCQAgACAGEIgfC4MGAgF/AXwjAEEwayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDhEBAgMEBQYHCAkKCwwNDg8QEQALIAIgAC0AAToACCACQQI2AhQgAkHYpYkBNgIQIAJCATcCHCACQcgLNgIsIAIgAkEoajYCGCACIAJBCGo2AiggASgCACABKAIEIAJBEGoQywoMEQsgAiAAKQMINwMIIAJBAjYCFCACQfSliQE2AhAgAkIBNwIcIAJBPDYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDBALIAIgACkDCDcDCCACQQI2AhQgAkH0pYkBNgIQIAJCATcCHCACQe4GNgIsIAIgAkEoajYCGCACIAJBCGo2AiggASgCACABKAIEIAJBEGoQywoMDwsgACsDCCEDIAJBAjYCFCACQZSmiQE2AhAgAkIBNwIcIAJB7B02AgwgAiADOQMoIAIgAkEIajYCGCACIAJBKGo2AgggASgCACABKAIEIAJBEGoQywoMDgsgAiAAKAIENgIIIAJBAjYCFCACQbCmiQE2AhAgAkIBNwIcIAJB7xs2AiwgAiACQShqNgIYIAIgAkEIajYCKCABKAIAIAEoAgQgAkEQahDLCgwNCyACIAApAgQ3AgggAkEBNgIUIAJByKaJATYCECACQgE3AhwgAkHEDTYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDAwLIAFBxKWJAUEKEPs1DAsLIAFB0KaJAUEKEPs1DAoLIAFB2qaJAUEMEPs1DAkLIAFB5qaJAUEOEPs1DAgLIAFB9KaJAUEIEPs1DAcLIAFB/KaJAUEDEPs1DAYLIAFB/6aJAUEEEPs1DAULIAFBg6eJAUEMEPs1DAQLIAFBj6eJAUEPEPs1DAMLIAFBnqeJAUENEPs1DAILIAFBq6eJAUEOEPs1DAELIAEgACgCBCAAKAIIEPs1CyACQTBqJAAL0wcCCH8BfiMAQdAAayIDJAACQAJAAkACQAJAAkACQAJAAkACQCABLQAUQQFrDgQEAAMBAgsACyABKAIkIQQMBAsgAUIANwMYIAEgASgCEDYCKCABIAEpAwA3AyALIANBEGohBSMAQRBrIgYkAAJAIAFBGGoiCCIEKQMAQgNSBEAgBiAEKAIQEN0eIAYoAgAiB0ECRgRAIAVBAjYCAAwCCyAHQQFxBEAgBSAGKQIENwIEIAVBATYCAAwCCyAEKQMAIQsgBCgCECIHIAQpAwg3AwggByALNwMAIARCAzcDACAFIAQoAhAQ3R4MAQsgBSAEKAIQEN0eCyAGQRBqJAAgAygCECIEQQJHDQEgAEEJNgIAQQMhAAwFC0HQ+sIAEOgrAAsgBEEBcQRAIAMgAykCFDcDECADQThqIANBEGoQgSsMAgsgASABKQMIIAEpAwB9Igs3AzggC0KAgICAEFoEQCADQThqENskDAILIANBEGogC6dBAEEBQQEQoBggAygCFCEEIAMoAhBBAUYNAiADKAIYIQUgAUEANgIgIAEgBTYCHCABIAQ2AhggAUEANgI0IAEgBDYCMCABQQA2AiwgASAINgIoIAEgAUFAayIENgIkIAEgASgCEDYCSCABIAEpAzg3A0ALIANBEGohBiMAQRBrIgUkACABQTRqIgcoAgAhCCAFQQhqIAFBKGoiCiAEIAIQ/wgCQCAFLQAIIglBBUcEQANAIAlBBEcEQCAGIAUpAwg3AgAMAwsgBSgCDCIJRQRAIAYgCDYCBCAGQQQ6AAAgB0EANgIADAMLIAcgCCAJaiIINgIAIAVBCGogCiAEIAIQ/wggBS0ACCIJQQVHDQALCyAGQQU6AAALIAVBEGokACADLQAQQQVGBEAgAEEJNgIAQQQhAAwDCwJAIAMpAxAiC0L/AYNCBFIEQCADIAs3AxAgA0E4aiADQRBqEIErDAELIAMgC0IgiCILPgIMIAsgASkDOFEEQCADQRhqIAFBIGooAgA2AgAgAyABKQIYNwMQIANBOGpBBHIgA0EQahDnFSADQQg2AjgMAgsgA0ECNgIUIANBkPvCADYCECADQgI3AhwgA0E7NgI0IANBPDYCLCADIAFBOGo2AiggAyADQShqNgIYIAMgA0EMajYCMCADQThqQQRyIANBEGoQmQ4gA0ECNgI4CyABQRhqEN47CyAAIAMpAzg3AwAgAEEQaiADQcgAaikDADcDACAAQQhqIANBQGspAwA3AwBBASEADAELIAQgAygCGEHg+sIAEP0vAAsgASAAOgAUIANB0ABqJAAL7AUCCn8BfiAAKAIAIQUgACgCBEEBaiIIQQN2IAhBB3FBAEdqIgkEQCAFIQQDQCAEIAQpAwAiDkJ/hUIHiEKBgoSIkKDAgAGDIA5C//79+/fv37//AIR8NwMAIARBCGohBCAJQQFrIgkNAAsLIAACfwJAIAhBCE8EQCAFIAhqIAUpAAA3AAAMAQsgCARAIAVBCGogBSAI/AoAAAsgCA0AQQAMAQsgAigCFCENQQEhAkEAIQkDQCAJIQUgAiEJAkAgBSAAKAIAIgJqLQAAQYABRw0AIAIgAyAFQX9zbGohCwNAIAEgACAFIA0RDQAhDiAAKAIEIgYgDqciDHEiByECIAAoAgAiBCAHaikAAEKAgYKEiJCgwIB/gyIOUARAQQghCgNAIAIgCmohAiAKQQhqIQogBCACIAZxIgJqKQAAQoCBgoSIkKDAgH+DIg5QDQALCyAEIA56p0EDdiACaiAGcSICaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiECCyACIAdrIAUgB2tzIAZxQQhPBEAgAiAEaiIHLQAAIAcgDEEZdiIHOgAAIAAoAgAgAkEIayAGcWpBCGogBzoAACAEIAMgAkF/c2xqIQJB/wFGBEAgACgCBCEEIAAoAgAgBWpB/wE6AAAgACgCACAEIAVBCGtxakEIakH/AToAACADRQ0DIAIgCyAD/AoAAAwDCyALIAIgA0ECdhD6KgJAIANBA3EiBkUNACACIANB/ABxIgRqIQIgBCALaiEEIAQgBkEBRgR/QQAFIAQvAAAhBiAEIAIvAAA7AAAgAiAGOwAAIANBAXFFDQFBAgsiBmoiBC0AACEHIAQgAiAGaiICLQAAOgAAIAIgBzoAAAsMAQsLIAQgBWogDEEZdiICOgAAIAAoAgAgBiAFQQhrcWpBCGogAjoAAAsgCSAIIAlLIgVqIQIgBQ0ACyAAKAIEIgEgAUEBakEDdkEHbCABQQhJGwsgACgCDGs2AggLwwUCBX8GfiMAQZABayIDJAAgASgCCCIFKAIAIQYgA0HwAGoiByABKAIMKAIQIAJBBXRqIgQpAwAiCiAEKQMIIgsgBCkDECIMIAQpAxgiDRDWIwJAAkAgAAJ/AkAgAygCcEEBcUUNACADKQOAASIIQoCAgIAIfCIJQv////8PViADKQOIASAIIAlWrXwiCUIAUiAJUBsNACADIAYoAgAoAgAiBDYCCCADIAg+AhgCQCAErCAIxH4iCEIgiKcgCKciBEEfdUcEQCADQQI2AnQgA0GskP8ANgJwIANCAjcCfCADQYIMNgIoIANBggw2AiAgAyADQRxqNgJ4IAMgA0EIajYCJCADIANBGGo2AhwgA0E0aiAHEJkOIANB4ABqIANBOGopAgA3AwAgA0HoAGogA0FAaygCADYCACADQYiAgIB4NgIwIAMgAykCMCIINwNYIAinQZOAgIB4Rw0BIAMoAlwhBAsgA0HwAGogBCAFKAIILQAAEOoPIAMoAnAiBUGTgICAeEYNAyADQRBqIANBgAFqKAIANgIAIAMgAykCeDcDCCADKAJ0DAILIANB2ABqEIgRCyAFKAIEIQEgAyANNwNIIAMgDDcDQCADIAs3AzggAyAKNwMwIANBzJH/ADYCWCADQgQ3AmQgA0GDDDYCjAEgA0H0CzYChAEgAyABQQFqNgKAASADQbsHNgJ8IAMgATYCeCADQcwBNgJ0IANB+JH/ADYCcCADIANB8ABqNgJgIAMgA0EwajYCiAEgA0EENgJcIANBIGogA0HYAGoQmQ4gA0EQaiADQSxqKAIANgIAIAMgAykCJDcDCEGCgICAeCEFIAMoAiALNgIEIAAgBTYCACAAIAMpAwg3AgggAEEQaiADQRBqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIACyADQZABaiQAC+sFAgp/AX4gACgCACEFIAAoAgRBAWoiCEEDdiAIQQdxQQBHaiIJBEAgBSEEA0AgBCAEKQMAIg5Cf4VCB4hCgYKEiJCgwIABgyAOQv/+/fv379+//wCEfDcDACAEQQhqIQQgCUEBayIJDQALCyAAAn8CQCAIQQhPBEAgBSAIaiAFKQAANwAADAELIAgEQCAFQQhqIAUgCPwKAAALIAgNAEEADAELIAIoAhQhDUEBIQJBACEJA0AgCSEFIAIhCQJAIAUgACgCACICai0AAEGAAUcNACACIAMgBUF/c2xqIQsDQCABIAAgBSANEQ0AIQ4gACgCBCIGIA6nIgxxIgchAiAAKAIAIgQgB2opAABCgIGChIiQoMCAf4MiDlAEQEEIIQoDQCACIApqIQIgCkEIaiEKIAQgAiAGcSICaikAAEKAgYKEiJCgwIB/gyIOUA0ACwsgBCAOeqdBA3YgAmogBnEiAmosAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhAgsgAiAHayAFIAdrcyAGcUEITwRAIAIgBGoiBy0AACAHIAxBGXYiBzoAACAAKAIAIAJBCGsgBnFqQQhqIAc6AAAgBCADIAJBf3NsaiECQf8BRgRAIAAoAgQhBCAAKAIAIAVqQf8BOgAAIAAoAgAgBCAFQQhrcWpBCGpB/wE6AAAgA0UNAyACIAsgA/wKAAAMAwsgCyACIANBAnYQ+ioCQCADQQNxIgZFDQAgAiADQTxxIgRqIQIgBCALaiEEIAQgBkEBRgR/QQAFIAQvAAAhBiAEIAIvAAA7AAAgAiAGOwAAIANBAXFFDQFBAgsiBmoiBC0AACEHIAQgAiAGaiICLQAAOgAAIAIgBzoAAAsMAQsLIAQgBWogDEEZdiICOgAAIAAoAgAgBiAFQQhrcWpBCGogAjoAAAsgCSAIIAlLIgVqIQIgBQ0ACyAAKAIEIgEgAUEBakEDdkEHbCABQQhJGwsgACgCDGs2AggLzAQCCH8IfiMAQfAAayIGJAACQCABIANqIgMgACgCCCIHTQRAIAAgAzYCCAwBCyAAIAMgB2sQix8LIAYgBCAFEOAcIAZCADcDaCAGIAE2AmAgBiABIAJqIgIiAzYCZAJAAkACQCABIANPDQAgAkEDdEEIayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQN0aiADIAVqKQMANwMAIAVBCGshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAvMBAIIfwh+IwBB8ABrIgYkAAJAIAEgA2oiAyAAKAIIIgdNBEAgACADNgIIDAELIAAgAyAHaxDMGgsgBiAEIAUQ4BwgBkIANwNoIAYgATYCYCAGIAEgAmoiAiIDNgJkAkACQAJAIAEgA08NACACQQF0QQJrIQUgBigCWCEKIAYpAyAhECAGKAJUIQggBigCUCEHIAYpA0AhDiAGKQMwIREgBigCECELIAYpAwghDyAGKAIoIQwgBigCGCENIAYpA0ghEyAGKQM4IRQgBikDACESA0AgEqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIA9QRQ0BQgAhD0IAIRJBASECDAQLAn4CQCARQgJ9IhVCAVgEQCAVp0EBaw0BDAULIBGnIBFQrUIBhiERQQFxRQ0AIBQMAQsgDkIDUQRAQgMhDgwECyAHRSAHIAhGckUEQCAIQQhrIggpAwAMAQtBACEHIA5CAlEEQEICIQ4MBAsgDqdCACEOQQFxRQ0DIBMLIQ9CASESIApBQGoiCiELDAELIAsgD3mnQT9zIgRqIQJCASAErYYgD4UhDwwDC0EAIQIMAQsLIA0gEEIAUnFFDQIgDCAQeadBP3MiBGohAkIBIASthiAQhSEQCyACIANBAWsiBE0NASAEIAAoAggiCU8NAiACIAlPDQMgACgCBCIDIAJBAXRqIAMgBWovAQA7AQAgBUECayEFIAQiAyABSw0ACwsgBkHwAGokAA8LIANBAWsgCUGwms8AEMMhAAsgAiAJQcCazwAQwyEAC88EAQp/IwBBMGsiASQAIAAoAiQhAyABIAAoAjwgACgCQCICKAIIQQFrQXhxakEIaiACKAI4EQAAIAEoAgAhAgJAAkACQCADBEAgAkUNASABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIDQQJPBEAgACgCHCEFIANBAXYhByAAKAIwIQMgACgCKCEGIAAoAjQhACABKAIkIQggASgCHCEJIAEoAighCgNAIABFDQVBASEEIAYgA0EDdmotAAAgA0EHcXZBAXEEQCAKIAUvAQAiBE0NBiAJIAQgCGoiBEEDdmotAABB/wFzIARBB3F2QQFxIQQLIAVBAmohBSAAQQFrIQAgA0EBaiEDIAIgBGohAiAHQQFrIgcNAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBGGoQ+x4MAgsgAkUEQEEAIQIMAgsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiBUECTwRAIAAoAhwhAyAFQQF2IQAgASgCJCEFIAEoAhwhByABKAIoIQQDQCAEIAMvAQAiBk0NBCACIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQIgA0ECaiEDIABBAWsiAA0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAKAI4IQIMAAsgAUEwaiQAIAIPC0Hk5oQBQSBBhOeEARCfKQALzwQBCn8jAEEwayIBJAAgACgCJCEDIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAIAMEQCACRQ0BIAFBKGogAUEQaikCADcDACABQSBqIAFBCGopAgA3AwAgASABKQIANwMYQQAhAiAAKAIgIgNBAk8EQCAAKAIcIQUgA0EBdiEHIAAoAjAhAyAAKAIoIQYgACgCNCEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgAEUNBUEBIQQgBiADQQN2ai0AACADQQdxdkEBcQRAIAogBS4BACIETQ0GIAkgBCAIaiIEQQN2ai0AAEH/AXMgBEEHcXZBAXEhBAsgBUECaiEFIABBAWshACADQQFqIQMgAiAEaiECIAdBAWsiBw0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgAUEYahD7HgwCCyACRQRAQQAhAgwCCyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIFQQJPBEAgACgCHCEDIAVBAXYhACABKAIkIQUgASgCHCEHIAEoAighBANAIAQgAy4BACIGTQ0EIAIgByAFIAZqIgZBA3ZqLQAAQf8BcyAGQQdxdkEBcWohAiADQQJqIQMgAEEBayIADQALCyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAoAjghAgwACyABQTBqJAAgAg8LQeTmhAFBIEGE54QBEJ8pAAvPBAEKfyMAQTBrIgEkACAAKAIkIQMgASAAKAI8IAAoAkAiAigCCEEBa0F4cWpBCGogAigCOBEAACABKAIAIQICQAJAAkAgAwRAIAJFDQEgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiA0EETwRAIAAoAhwhBSADQQJ2IQcgACgCMCEDIAAoAighBiAAKAI0IQAgASgCJCEIIAEoAhwhCSABKAIoIQoDQCAARQ0FQQEhBCAGIANBA3ZqLQAAIANBB3F2QQFxBEAgBSgCACIEIApPDQYgCSAEIAhqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcSEECyAFQQRqIQUgAEEBayEAIANBAWohAyACIARqIQIgB0EBayIHDQALCyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiABQRhqEPseDAILIAJFBEBBACECDAILIAFBKGogAUEQaikCADcDACABQSBqIAFBCGopAgA3AwAgASABKQIANwMYQQAhAiAAKAIgIgVBBE8EQCAAKAIcIQMgBUECdiEAIAEoAiQhBSABKAIcIQcgASgCKCEEA0AgAygCACIGIARPDQQgAiAHIAUgBmoiBkEDdmotAABB/wFzIAZBB3F2QQFxaiECIANBBGohAyAAQQFrIgANAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0BIAFBGGoQ+x4MAQsgACgCOCECDAALIAFBMGokACACDwtB5OaEAUEgQYTnhAEQnykAC88EAQp/IwBBMGsiASQAIAAoAiQhAyABIAAoAjwgACgCQCICKAIIQQFrQXhxakEIaiACKAI4EQAAIAEoAgAhAgJAAkACQCADBEAgAkUNASABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIDQQhPBEAgACgCHCEFIANBA3YhByAAKAIwIQMgACgCKCEGIAAoAjQhACABKAIkIQggASgCHCEJIAEoAighCgNAIABFDQVBASEEIAYgA0EDdmotAAAgA0EHcXZBAXEEQCAKIAUoAgAiBE0NBiAJIAQgCGoiBEEDdmotAABB/wFzIARBB3F2QQFxIQQLIAVBCGohBSAAQQFrIQAgA0EBaiEDIAIgBGohAiAHQQFrIgcNAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBGGoQ+x4MAgsgAkUEQEEAIQIMAgsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiBUEITwRAIAAoAhwhAyAFQQN2IQAgASgCJCEFIAEoAhwhByABKAIoIQQDQCAEIAMoAgAiBk0NBCACIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQIgA0EIaiEDIABBAWsiAA0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAKAI4IQIMAAsgAUEwaiQAIAIPC0Hk5oQBQSBBhOeEARCfKQAL/QQCBH4LfyMAQSBrIgokACABQRBqIgggAhD4CyEEIAEoAghFBEAgCiABQQEgCBCyAwsgASgCBCIJIASncSEIIARCGYgiBkL/AINCgYKEiJCgwIABfiEHIAIoAgghDyACKAIEIRAgASgCACEMA0ACfwJAAkACQCAIIAxqKQAAIgUgB4UiBEJ/hSAEQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgRQRQRAA0AgECAPIAEoAgBBACAEeqdBA3YgCGogCXFrIhFBGGxqIhJBFGsoAgAgEkEQaygCABDBLg0CIARCAX0gBIMiBFBFDQALCyAFQoCBgoSIkKDAgH+DIQQgDUUEQCAEUA0DIAR6p0EDdiAIaiAJcSELC0EBIAQgBUIBhoNQDQMaIAsgDGosAABBAE4EQCAMKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgASgCACIIIAtqIgktAAAhDCACQQhqKAIAIQ0gAikCACEEIAkgBqdB/wBxIgI6AAAgCCABKAIEIAtBCGtxakEIaiACOgAAIApBEGoiCSANNgIAIApBHGogA0EIaigCADYCACABIAEoAgxBAWo2AgwgCCALQWhsakEYayICIAQ3AgAgCiADKQIANwIUIAJBCGogCSkDADcCACACQRBqIApBGGopAwA3AgAgASABKAIIIAxBAXFrNgIIIABBgICAgHg2AgAMAQsgACABKAIAIBFBGGxqQQxrIgEpAgA3AgAgASADKQIANwIAIABBCGogAUEIaiIAKAIANgIAIAAgA0EIaigCADYCACACQQFBARDgHgsgCkEgaiQADwtBAAshDSAIIA5BCGoiDmogCXEhCAwACwALliICHH8DfiMAQRBrIhskACAAEPgOAkACQAJAIAAoAqwqIg1Bf0cEQCABQf8BcUEDRw0DIAIoAgAgDUYNAQwDCyABQf8BcUEDRw0BCyAAKAIoRQRAIABCgICAgAQgACkD6AEgACkD+AF9IicgJ0KAgICABFobPgIoCwJ/IwBBEGsiDyQAAkACQAJAAkACQAJAAkACQCACKAIAIg1BgICACEsNAAJAIAAoAugpIgFFBEAgAEEDNgLoKSAAIA02AqwqDAELIAFBA2tBAUsNAQsgAEHYKWohDANAIAAgBiAHIAggCSAKENsQDQAgACgCqCoiAUEARyELIAENASAAKQPoASAAKQPwAVEEQCAAKALoKUEDRgRAIABCATcDAEEAIRNCACEnIwBBEGsiASQAIAAoAqwqIREgASAAIAAoAsgBIAAoAswBIABB2ClqEOoeIAEoAgQhCyABKAIAIRIgASAALQC+KjYCDAJAIAsEQCASIAAtALgqOgAAAkACQAJAIAtBAUcEQCASIAAtALkqOgABIABBADoAviogAEEAOwG4KkEBQgAgAUEMaiIQIBIgCxDfE0ECQgMgECASIAsQ3xNBAUIAIBAgEiALEN8TIBEOAgEDAgtBAUEBQcjC0AAQwyEAC0ECQgAgAUEMaiASIAsQ3xMMAwsgEUEBayIRZ0EgakE4c0EIakEDdiETIBGtIScLQQIgE60gAUEMaiIRIBIgCxDfEyATQQN0ICcgESASIAsQ3xMMAQtBAEEAQbjC0AAQwyEACyABKAIMIAFBEGokAEEHakEDdiEBIABBBDYC6CkgACABNgKoKgwCCyAAKAKsKiIBRQRAIABBADYC6CkgAEF/NgKsKkEBIQsMAwsgBigCACITRQRAIABCATcDACAPIAAgACgCyAEgACgCzAEgDBDqHkEQIAEgAUEQTxsiASAPKAIEIg1LDQQgBSgCACINIAFqIgsgDUkNBSAEIAtJDQYgDygCACABIAMgDWogAUHYwNAAENUsIAAgATYCqCogBSAFKAIAIAFqNgIAIAIgAigCACABayINNgIAIAAgACgCrCogAWs2AqwqDAILIAkoAgAiESATIAEgASATSxsiAWoiCyARSQ0GIAggC0kNByAFKAIAIhAgAWoiEiAQSQ0IIAQgEkkNCSAHIBFqIAEgAyAQaiABQYjB0AAQ1SwgAiANIAFrIg02AgAgBSASNgIAIAkgCzYCACAGIBMgAWs2AgAgACAAKAKsKiABazYCrCoMAQsgD0EANgIMIABBAEEBIA9BDGoQvgEgACAPKAIMNgKoKg0ACwsgD0EQaiQAIAsMBwsgASANQbjA0AAQsDsACyANIAtByMDQABCxOwALIAsgBEHIwNAAELA7AAsgESALQejA0AAQsTsACyALIAhB6MDQABCwOwALIBAgEkH4wNAAELE7AAsgEiAEQfjA0AAQsDsACyESDAELIAAoAugpIg1BA2tBAkkNACANQQAgAigCACITGw0AAkAgACgCHEEBSw0AIAAtAFwNACMAQeAAayIMJAAgACgCICENIAIiESgCACEPIAxB0ABqEP4nIAwoAlQhAiAMKAJQIQsgDEHIAGoQ/ScgDCgCTCESIAwoAkghEAJAAkACQCAAKAIcIhlBAU0EQEEBIA10IRggGUEBRg0BIBAhDyACIQ0gCyETIBIhCwwCCyASBEAgECASQQEQ+DoLIAJFDQIgCyACQQJ0QQQQ+DoMAgsgACgC3AEiDSAYIA8gDyAYSxsiD0GAgAhJckUEQCAMQUBrIABBvipqIg1BgIAIELkpIAwoAkQhEyAMKAJAIRQgACgC3AEiDgRAIAAoAtgBIA5BAnRBBBD4OgsgACATNgLcASAAIBQ2AtgBIAxBOGogDUGAgAgQuCkgDCgCPCENIAwoAjghEyAAKALkASIUBEAgACgC4AEgFEEBEPg6CyAAIA02AuQBIAAgEzYC4AEgACgC3AEhDQsCQCANBEAgACgC2AEhEyAMQTBqEP4nIAwoAjAhDyAAIAwoAjQ2AtwBIAAgDzYC2AEgAgRAIAsgAkECdEEEEPg6CyAMQShqEP0nIAAoAuABIQ8gACAMKAIoNgLgASAAKALkASELIAAgDCgCLDYC5AEgEg0BDAILIAxBIGogAEG+KmoiFEGAgAggDyAPQYCACE8bIg8QuSkgDCgCJCENIAwoAiAhEyACBEAgCyACQQJ0QQQQ+DoLIAxBGGogFCAPELgpIAwoAhwhCyAMKAIYIQ8gEkUNAQsgECASQQEQ+DoLIABB0CVqISAgAEGkKmohISAAQdAjaiEiIABB0CJqISMgAEHQAWohJCAAQdACaiElIABBvipqIR0gAEHoKWohFSABQf8BcSIaQQFGIRIgGkECRiEQA0AgACAGIAcgCCAJIAoQ2xANAAJAAkACQAJAAkACQAJAAkACQAJAIAAoAqgqIAAoAugpckUEQCARKAIAIg4gGnINAQsgDUGAgAhGBEAgACgC3AFFDQILIBMgDRCAMSAdIA8gCxDgNSAVIAAoAqgqIAAQ3C4MCwsgDCAdLQAANgJYQQAhASAMQQA2AlxBACECAkAgDiAYSw0AQQEhFCAQIQEgEiECIBpBAUcNACAORQ0JCwJ/IA4gGCAOIBhJGyIWQQF0QfcDaiIeIAYoAgAiJksEQCAAIB4QyRogACgCyAEhFCAAKALMAQwBCyAIIAkoAgAiDkkNAiAHIA5qIRQgCCAOawsiF0UNAiAUIAAtALgqOgAAIBdBAUYNAyAUIAAtALkqOgABIAxBEGogJSAkIAAoAhwgFiAMQdwAahC8ECAFKAIAIQ4gDCgCFCEcIAwoAhAhHwJAIAAoAhxFBEAgBCAOSQ0GIAMgDmogBCAOayAWIAEgHyAcIAwoAlwgIyAiICEgICAMQdgAaiAUIBcQghcMAQsgBCAOSQ0GIAMgDmogBCAOayAWIAEgEyANIA8gCyAfIBwgDCgCXCAMQdgAaiAUIBcQ4QwLIAUgBSgCACAWajYCACARIBEoAgAgFms2AgAgDCgCWCIcQQN2IQ4gHiAmSwRAIAAgDjYCqCogAEIANwMADAgLIAkgCSgCACAOajYCACAGIAYoAgAgDms2AgAgACAAKQPQKSAOrXwiJzcD0CkgCigCAA0GDAcLIAxBCGoQ/icgDCgCDCEBIAwoAgggACgC3AEiAgRAIAAoAtgBIAJBAnRBBBD4OgsgAEGAgAg2AtwBIAAgEzYC2AEgDBD9JyAMKAIEIQIgDCgCACEEIAAoAuQBIgUEQCAAKALgASAFQQEQ+DoLIAAgCzYC5AEgACAPNgLgASAVIAAoAqgqIAAQ3C4gAgRAIAQgAkEBEPg6CyABRQ0JIAFBAnRBBBD4OgwJCyAOIAhByMHQABCvOwALQQBBAEHYwdAAEMMhAAtBAUEBQejB0AAQwyEACyAOIARB+MHQABCvOwALIA4gBEGIwtAAEK87AAsgCiAnPgIECwJAIA4gF0kEQCAXIA5BAWoiFksEQCAOIBRqLQAAIQ4gFCAWai0AACEUIAAgHEEHcToAviogACAOIBRBCHRyOwG4KiABIAJyDQIMBAsgFiAXQajC0AAQwyEACyAOIBdBmMLQABDDIQALQQJBASABGyEUCyAVIBQ2AgAMAAsACyAMQeAAaiQAIBlBAkkhEgwBCyAAQegpaiEaIAUoAgAhEiABQf8BcSEYA0AgE0UiASAYQQFGcSILIBhBAkYgAXEiDXIhD0ECQQEgDRshESATrSEnA0ACQCAAKQP4ASEoIAApA+gBISkgABD4DgJAQQEgACgCJHQiASApICh9Iiina0EAICggAa1UGyIBQQAgExtFBEAgACAGIAcgCCAJIAoQ2xANAyAAKAKoKiIQIBhFIAFBAEdxckUEQCAAKALoKUUNAgsgGiAQIAAQ3C5BASESDAULIAQgEkkNASAAEPgOIABBvipqIQsgAyASaiEUIAQgEmshDyATIAEgASATSxsiGSENAkACQAJAAkACQAJAAkAgAEHsKWoiASgCHCIWDQAgDSABKAIQTw0AIAEgDTYCHCALIA0gARCEDyABKAIgIgsgDWoiESALSQ0BIBEgASgCBCIQSw0CIA0gD0sNAyABKAIAIAtqIA0gFCANQcy40AAQ1SwMBgsgASgCFCIRIAEoAhhNBEAgASgCICERIAEoAgghFwwFCyALIBEgARCEDyABKAIIIhcgASgCICIRaiIMQQJrIhAgASgCBCILTwRAIBAgC0HcuNAAEMMhAAsgASgCACIOIBBqQQA6AAAgDEEBayIQIAtJDQMgECALQey40AAQwyEACyALIBFBrLjQABCxOwALIBEgEEGsuNAAELA7AAsgDSAPQby40AAQsDsACyAOIBBqQQA6AAAgASgCHCEWCyABKAIMIQ4CQAJAAkACQCABKAIQIgwgASgCDCABKAIccSILSwRAIAEoAiAgASgCCCALamoiECAMIAtrIgsgDSALIA1JGyILaiIMIBBJDQEgDCABKAIEIhVLDQIgCyAPSw0DIAEoAgAgEGogCyAUIAtB7LrQABDVLAsMAwsgECAMQcy60AAQsTsACyAMIBVBzLrQABCwOwALIAsgD0HcutAAELA7AAsgESAOIBZxIhVqIRACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBcgDSAVakkEQCABKAIUIBVrIgsgDSALIA1JGyIOIBBqIgwgDkkNAiAMIAEoAgQiC0sNAyAOIA9LDQQgECABKAIAIgxqIA4gFCAOQZy50AAQ1SwgDSAXIBVrIhBrIg4gEWoiFSAOSQ0FIAsgFUkNBiANIBBJDQcgDSAPSw0IIAwgEWogDiAQIBRqIA5BzLnQABDVLAwBCyANIBBqIgwgEEkNCCAMIAEoAgQiC0sNCSANIA9LDQogECABKAIAIgxqIA0gFCANQfy50AAQ1SwLIBEgF2oiFEECayIPIAtPDQogEUECayIQIAtPDQsgDCAQaiAMIA9qLQAAOgAAIBRBAWsiDyALTw0MAkAgCyARQQFrIhFLBEAgASANIBZqIg02AhwgDCARaiAMIA9qLQAAOgAAIA1BgICAgARLDQEMDwsgESALQby60AAQwyEACyABIA1B/////wNxQYCAgIAEcjYCHAwNCyAQIAxB/LjQABCxOwALIAwgC0H8uNAAELA7AAsgDiAPQYy50AAQsDsACyARIBVBrLnQABCxOwALIBUgC0GsudAAELA7AAsgECANQby50AAQsTsACyANIA9BvLnQABCwOwALIBAgDEHcudAAELE7AAsgDCALQdy50AAQsDsACyANIA9B7LnQABCwOwALIA8gC0GMutAAEMMhAAsgECALQZy60AAQwyEACyAPIAtBrLrQABDDIQALIAAgACkD6AEgGa18NwPoAQJAAkACQCAAKAKIKiIBIAAoAvgpTQRAIAAoAowqIAFqIgFBB2ohDSABQXhLDQEgDSAAKALwKSILSw0CIAAoAuwpIAFqIgFBADYAACABQQNqQQA2AAALDAILIAEgDUHYwtAAELE7AAsgDSALQdjC0AAQsDsACyACIBMgGWsiEzYCACAFIBIgGWoiEjYCAAwDCyAAKAIoRQRAIABBgICAgARBgICAgARCgICAgAQgACkD6AEgACkD+AF9IiggJ3wiKSApQoCAgIAEWhunIChCgICAgARaGyATQYCAgIAETxs2AigLIBtBADYCDCAAIA0gCyAbQQxqEL4BIAAgGygCDDYCqCpFBEBBACESDAQLIA9FDQEgGiARNgIADAELCwsgEiAEQajA0AAQrzsACyAbQRBqJAAgEguQBQECfyMAQSBrIgIkAAJAAkACQAJAAkACQAJ/AkACQAJAIAEtAABBAWsOAwABAgQLIAFBAWoMAgsgASgCBEEIagwBCyABKAIEQQhqCy0AACIDQQtNBEAgA0EHRyADQQJrQQJPcQ0BIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NBiAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIAQQEhAwwFCyADQQxGDQEgA0EWRg0CIANBJUYNAwtBACEDIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NBCAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIADAMLIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NAyAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIAQQIhAwwCCyACQQA2AgggAkKAgICAEDcCACACQfio/gA2AhAgAkKggICADjcCFCACIAI2AgwgASACQQxqENQODQIgACACKQIANwIEIABBDGogAkEIaigCADYCAEEDIQMMAQsgAkEANgIIIAJCgICAgBA3AgAgAkH4qP4ANgIQIAJCoICAgA43AhQgAiACNgIMIAEgAkEMahDUDg0BIAAgAikCADcCBCAAQQxqIAJBCGooAgA2AgBBBCEDCyAAQQA2AgAgACADOgAQIAEtAABBA0YEQCABKAIEIgAQvCogAEEMQQQQ+DoLIAJBIGokAA8LQaCp/gBBNyACQR9qQZCp/gBB2Kn+ABDVHgAL2wUCBX8IfiMAQcABayIDJAAgASgCCCIFKAIAIQYgA0GgAWoiByABKAIMKAIQIAJBBXRqIgQpAwAiCyAEKQMIIgwgBCkDECINIAQpAxgiDhDWIwJAAkACfgJAIAMoAqABQQFxBEAgAykDuAEhCCADKQOwASEJIAYoAgAiBCkDACEKIAMgBCkDCCIPNwM4IAMgCjcDMCADIAg3AyggAyAJNwMgIANBADYCHCADIAkgCCAKIA8gA0EcahD2DCADKAIcRQ0BIANBAjYCZCADQayQ/wA2AmAgA0ICNwJsIANBhAw2AlggA0GEDDYCUCADIANBzABqNgJoIAMgA0EwajYCVCADIANBIGo2AkwgA0GMAWogA0HgAGoQmQ4gA0G0AWogA0GYAWooAgA2AgAgA0GIgICAeDYCiAEgAyADQZABaikCADcCrAEgAyADKQKIATcCpAEgA0EBNgKgASAHQQRyEIgRCyAFKAIEIQEgAyAONwN4IAMgDTcDcCADIAw3A2ggAyALNwNgIANBzJH/ADYCiAEgA0IENwKUASADQYMMNgK8ASADQfQLNgK0ASADIAFBAWo2ArABIANBuwc2AqwBIAMgATYCqAEgA0HMATYCpAEgA0Ggkf8ANgKgASADIANBoAFqNgKQASADIANB4ABqNgK4ASADQQQ2AowBIANB0ABqIANBiAFqEJkOIANBOGogA0HUAGooAgA2AgAgA0GCgICAeDYCTCADIAMpAkw3AzAgAykCWAwBCyADQaABaiADKQMAIgggAykDCCIJIAUoAggtAAAQrQ4gAygCoAFBk4CAgHhGDQEgA0E4aiADQagBaigCADYCACADIAMpAqABNwMwIAMpAqwBCyEIIAAgAykDMDcCACAAIAg3AgwgAEEIaiADQThqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQR0aiIAIAk3AwggACAINwMACyADQcABaiQAC68FAgZ/An4jAEGAAWsiAyQAAkACQAJAAkACQAJAIAEtADRBAWsOAwIAAwELAAsgA0EwaiABKAIIQQBBBEEQEKAYIAMoAjQhBCADKAIwQQFGDQIgAygCOCEFIAFBADYCGCABIAU2AhQgASAENgIQIAEgASgCADYCJCABIAEoAgQiBDYCICABIAQ2AhwgASAEIAEoAghBBHRqIgY2AihBACEFDAMLQej9wgAQ6CsACyABKAIwIQggASgCLCEHQQEhBQwBCyAEIAMoAjhB2P3CABD9LwALA0ACQAJAAkACQAJAIAVFBEAgBCAGRg0BIAEgBEEQajYCICABKAIMIQUgBCkDACEJIAQpAwghCiADQQA6AEQgAyAKNwM4IAMgCTcDMCADIAU2AkAgA0EIaiADQTBqEM0pIAMoAgghByABIAMoAgwiCDYCMCABIAc2AiwMBAsgA0EwaiAHIAIgCCgCDBEBACADKAIwIgRBCUYEQCAAQQk2AgBBAyEEDAULIANBGGoiBiADQTxqKQIANwMAIAMgAykCNDcDECADKAJEIQUgAUEsahC8KiAEQQhHBEAgA0EoaiAGKQMANwMAIAMgAykDEDcDICABQRxqEL0rIAFBEGoiAhDUJyACEO47DAILIAEoAhgiBCABKAIQRgRAIAFBEGpB+P3CABCeKAsgASgCFCAEQQR0aiIFIAMpAxA3AgAgBUEIaiADQRhqKQMANwIAIAEgBEEBajYCGCABKAIgIQQgASgCKCEGDAILIAFBHGoQvStBCCEEIANBKGogAUEYaigCADYCACADIAEpAhA3AyALIAAgBDYCACAAIAMpAyA3AgQgACAFNgIUIABBDGogA0EoaikDADcCAEEBIQQMAgtBACEFDAILQQEhBQwBCwsgASAEOgA0IANBgAFqJAALnAUCBX8BfiMAQUBqIgIkACAAAn8CQAJAIAEoAhAiBEUEQCACQRhqELQeIAIoAhgiA0EERg0BIAAgAikCIDcCDCAAQRRqIAJBKGooAgA2AgAgAEELaiACKAIcIgFBGHY6AAAgACABQQh2OwAJIAAgAToACCAAIAM2AgRBAQwDCyABKAIMIQMgASAEQQFrNgIQIAEgA0EBajYCDCACIAMtAAAiBEEEdiIGOgADAkACQAJAIARBD3EiA0EBaw4CAQACC0EAIQMLIAEgAzoAFkECIQMMAgsgAkEYaiADEKMSIAItABwhAyACKAIYIgVBBEcEQCAAIAIpAB03AAkgAEEQaiACQSRqKQAANwAAIAAgAzoACCAAIAU2AgRBAQwDCyADDQEgAkGAgICAeDYCGCAAQQRqIAJBGGogAhCvLUEADAILQQFBAEHUs84AEK87AAsCQAJAIARBD00EQCACQRhqIAEQwBwgAigCGEUEQCACLwEgIQQMAgsgAikDICIHpyEEIAIoAhwiBUEERg0BIAAgAikDKDcCECAAIAQ7AQggACAFNgIEIABBDmogB0IwiD0BACAAIAdCEIg+AQpBAQwDCyABQRRqIQUgAS4BFCAGaiIEwSAERgRAIAUgBDsBAAwCCyACQQI2AhwgAkH4ss4ANgIYIAJCAjcCJCACQc0BNgI8IAIgBTYCOCACQbsHNgI0IAIgAkEwajYCICACIAJBA2o2AjAgAkEIaiACQRhqEJkOIAAgAikBCjcBCiACQQE6ABQgAEEQaiACQRBqKQEANwEAIAAgAi8BCDsBCCAAQQE2AgRBAQwCCyABIAQ7ARQLIAAgAzoAFCAAIAQ7ARIgAEEBOwEQIABBgICAgHg2AgRBAAs2AgAgAkFAayQAC+AEAgd/Bn4jAEEgayIIJABCB0KKASABLwECIgYbIQ9CBEIDIAYbIRBBfyEFAkACQANAIAYhCkJ1IQxCfyENAkADQCANIREgCyAEIAlJcg0BIAlBAWoiBiACTw0DIAxCAXwhDiAEIAlNIQsgCSAEIAlLaiEJIAEgBkECdGovAQIhBiAPIAxCDHxWBEAgDUIBfSENIA4hDCAKQf//A3EgBkYNAQsLAkAgECAOQgt8IgxWBEAgCkH//wNxIQcDQCAAIAcgA0EnEKshIBFCAXwiEVBFDQALDAELIA5CCnwhDSAKQf//A3EiB0UEQCANQgpaBEAgAEESIANBJxCrISAALQAYIgdBB2oiBUH/AXFBwABPBEAgACAOIAUQ8BAMAwsgACAFOgAYIAAgACkDECAOIAethoQ3AxAMAgsgAEERIANBJxCrISAOQgh8IQwgAC0AGCIHQQNqIgVB/wFxQcAATwRAIAAgDCAFEPAQDAILIAAgBToAGCAAIAApAxAgDCAHrYaENwMQDAELIAUgB0cEfiAAIAcgA0EnEKshIA0FIAwLQgN9IgxCBFoNBCAAQRAgA0EnEKshIAAtABgiB0ECaiIFQf8BcUHAAE8EQCAAIAwgBRDwEAwBCyAAIAU6ABggACAAKQMQIAwgB62GhDcDEAtCBkIHIAYgCkH//wNxIgVGIgobQooBIAYbIQ9CA0IEIAobQgMgBhshEAwBCwsgCEEgaiQADwsgBiACQYTv+wAQwyEACyAIQQA2AhggCEEBNgIMIAhBnO/7ADYCCCAIQgQ3AhAgCEEIakGk7/sAEO8sAAvuBAIIfgV/AkAgASgCOCIORQ0AAkAgASkDMCIDUEUEQCABKQMoIQYMAQsgASkDCCEHIAEoAiQhDSABKQMYIQggASkDKCEGIAEpAwAhBSABKAIgIQogASkDECECA0ACQAJAAkACQAJAIAJCAn0iA0IBWARAIAIhBCADp0EBaw0BDAQLIAEgAlCtQgGGIgQ3AxAgAqdBAXENAQsgCkUgCiANRnINASABIApBCGoiCzYCICAKKQMAIQMgCyEKIAQhAgwDCyACUA0AQgAhAiAIIQMMAgsgAUIDNwMQCyAFQgJRDQMgAUIANwMAIAWnQgMhAkIAIQUgByEDQQFxRQ0DCyABIAM3AzAgASAGQkB9IgY3AyggA1ANAAsLIAEgA0J/IAN6IgSGQn+FhCICNwMwIASnIQwgBiEFAkACQCACQn9RBEAgASkDCCEIIAEoAiQhDSABKQMYIQkgASkDACEEIAEoAiAhCiABKQMQIQMDQAJAAkACQAJAAkAgA0ICfSICQgFYBEAgAyEHIAKnQQFrDQEMBAsgASADUK1CAYYiBzcDECADp0EBcQ0BCyAKRSAKIA1Gcg0BIAEgCkEIaiILNgIgIAopAwAhAiALIQogByEDDAMLIANQDQBCACEDIAkhAgwCCyABQgM3AxALIARCAlENAyABQgA3AwAgBKdCAyEDQgAhBCAIIQJBAXFFDQMLIAEgAjcDMCABIAVCQH0iBTcDKCACQn9RDQALCyABIAJCfyACQn+FeiIChoM3AzAgAqcgBadqIQ4MAQsgAUEANgI4CyAAIA42AgggACAMIAanajYCBEEBIQwLIAAgDDYCAAvgBAEGfwJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkACQAJAIAdBgICAgAFxBEAgAC8BDiIDDQFBACECDAILIAJBEE8EQCABIAIQ1gchAwwECyACRQRAQQAhAgwECyACQQNxIQYCQCACQQRJBEAMAQsgAkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEECaiwAAEG/f0pqIARBA2osAABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNAyABIAVqIQQDQCADIAQsAABBv39KaiEDIARBAWohBCAGQQFrIgYNAAsMAwsgASACaiEIQQAhAiABIQQgAyEFA0AgBCIGIAhGDQICfyAGQQFqIAYsAAAiBEEATg0AGiAGQQJqIARBYEkNABogBkEDaiAEQXBJDQAaIAZBBGoLIgQgBmsgAmohAiAFQQFrIgUNAAsLQQAhBQsgAyAFayEDCyADIAAvAQwiBE8NACAEIANrIQZBACEDQQAhBQJAAkACQCAHQR12QQNxQQFrDgIAAQILIAYhBQwBCyAGQf7/A3FBAXYhBQsgB0H///8AcSEIIAAoAgQhByAAKAIAIQADQCADQf//A3EgBUH//wNxSQRAQQEhBCADQQFqIQMgACAIIAcoAhARAgBFDQEMAwsLQQEhBCAAIAEgAiAHKAIMEQYADQFBACEDIAYgBWtB//8DcSEBA0AgA0H//wNxIgIgAUkhBCABIAJNDQIgA0EBaiEDIAAgCCAHKAIQEQIARQ0ACwwBCyAAKAIAIAEgAiAAKAIEKAIMEQYAIQQLIAQL8xkCIH8EfiMAQZABayIGJAACQCABAn8CQAJAAkACQAJAAkACQAJAAkAgAS0AkAFBAWsOAwUBAAILIAFB+ABqIRsCQCABLQB4QQFrDgMKAQQACyABKQMIISMgASgCaCEFIAEoAgQhAyABKAIAIQkMAgsACyABKAKAASIFKQMQISMgAUEAOgB4IAEgBTYCaCABICM3AwggASABKAKMASIDNgIEIAEgASgCiAEiCTYCACABQfgAaiEbCyABIAM2AhQgASAJNgIQIAFB7ABqIAkgAyAjEOAJIAEoAnQhDCABKAJwIQQgBkE4aiEKIwBBEGsiCCQAAkACQEHYAEEIEK02IgMEQCADQgA3A0AgA0IANwMIIANCgYCAgBA3AwAgA0EBOwFUIANBfzYCUCADQcgAakIANwMAIAhBBGoQ6zpBIEEEEK02IglFDQEgCSADNgIIIAlCgYCAgBA3AgAgCSAIKQIENwIMIAkgA0EIaiIDNgIcIAkgAzYCGCAJQRRqIAhBDGooAgA2AgAgCkEAOgAIIApBADYCBCAKIAk2AgAgCEEQaiQADAILQQhB2AAQoz0AC0EEQSAQoz0ACyAGQTBqQgA3AwAgBkKAgICAgAE3AkQgBkIANwMoIAZCgICAgKABNwJMIAZBADoAJCAGIAU2AiAgBiAENgIYIAYgBCAMQQR0ajYCHCABQRhqIAZBGGpBwAD8CgAAIAFBADYCYCABQoCAgIDAADcDWAsgBkHYAGohECMAQTBrIgokACABQRhqIglBQGshFiAKQRxqIRwgCkEgaiEdAkADQAJAIApBGGohEiMAQYABayIMJAAgCUEgaiEIIAlBEGohDyAMQRBqIQ4DQAJAIAkoAjggCSgCJCIDBH8gCCgCACgCCEEIaiEFA0AgAygCOCAFRg0ACyADKAJABUEACyAJKAI0ak0NACAMQQhqIQcjAEHgAGsiBCQAAkAgCS0ADEUEQCAEQTBqIQVCACEjQgAhJEIAISUjAEEQayINJAAgCSIDKAIAIgsgAygCBEYEfkIABSADIAtBEGo2AgAgCykDACEjIAspAwghJCADKAIIIgsoAggQ9DohAyALKQMAISVCAQshJiAFQQA6ACwgBSAkNwMgIAUgIzcDGCAFIAM2AhAgBSAlNwMIIAUgJjcDACAFIA0vAA07AC0gBUEvaiANQQ9qLQAAOgAAIA1BEGokACAEKQMwIiNCAlEEQCAHQgI3AwAMAgsgBEEIaiAEQThqQSj8CgAAICNQBEAgCUEBOgAMCyAHICM3AwAgB0EIaiAEQQhqQSj8CgAADAELIAdCADcDAAsgBEHgAGokACAMKQMIIiNCAlEgI6dBAXFFcg0AIAxB0ABqIgUgDkEo/AoAACAPIA8pAwAiI0IBfDcDACAMICM3A3ggCCgCACgCCCEEIAgQjSQhBwJAQdgAQQgQrTYiAwRAIANCATcDCCADQoGAgIAQNwMAIANBEGogBUEw/AoAACADQQE7AVQgAyAHNgJQIANBADYCTCADQgA3AkQgAyAEQQhqNgJAIAhBADoACCAIKAIEIQUgCCADQQhqIgQ2AgQCQCAFRQRAIANBADYCQCADQQE2AkgMAQsgCCgCACgCCEEIaiEHA0AgBSgCOCAHRg0ACyAFKAJAIQcgAyAFNgJAIAMgB0EBajYCSCAFIAQ2AjwLIANBADYCTCAIKAIAIgMoAhggAyAENgIYIAQ2AkQMAQtBCEHYABCjPQALDAELCyAMQThqIQsjAEHgAGsiAyQAIA9BHGohHgJAAkAgDygCJARAIA8oAiApAxgiIyAPKQMIUQ0BCyAPQRBqIQggA0EgakEEciETIANBBHIhFANAQQAhF0EAIRhBACEfIwBBQGoiBSQAIAgoAgQiBARAIAgoAgAoAghBCGohBwNAIAQoAjggB0YNAAsgBCgCQCEXCyAIKAIAIgRBDGogAigCACIVEIsUA0ACQCAFIARBCGoQzhkCQAJAAkACQAJAIAUoAgAiBARAIARBAmsNASAVKAIEIBUoAgAoAggRAwAgA0EKNgIADAMLIAUoAgQiBygCAEUEQCAFIAdBCGsiBDYCCCAEIAQoAgAiBEEBazYCACAEQQFHDQUgBUEIahC4HwwFCyAIIAcQjB0iDS0AVCANQQA6AFRFDQMgDUEAOgBVIAUgDUEIaiIgNgIsIAVB+IDDADYCKCAFQQA2AjggBSAFQShqIgQ2AjQgBSAENgIwIAVBCGohESAFQTBqISEjAEEwayIEJAAgB0EIaiIHKQMoISMCQAJAAkACQAJAAkACQCAHLQAkQQFrDgMFAQACCyAHKAIgIRkMAgsACyAHKQMYISQgBykDECElIAcoAgghGiAHKQMAISYgBBDOIiAEKAIEIRkgBCgCACEiQcgAQQgQrTYiDkUNASAOQQA6AEQgDiAiNgJAIA4gJDcDGCAOICU3AxAgDiAaNgIIIA4gJjcDACAOQdikwwAQ1BogByAZNgIgCyAEQQxqIhogGUEIaiAhEKgUAkACQCAEKAIMRQRAIARBKGogBEEcaigCADYCACAEIAQpAhQ3AyAgBCgCECEOIAdBIGoQriwgDg0BQeCmwwBBKyAaQaynwwBB/LnDABDVHgALIAdBAzoAJCARQQk2AgAMAQsgESAEKQMgNwIIIBFBEGogBEEoaigCADYCACAHQQE6ACQgESAjNwMYIBEgDjYCBCARQQg2AgALIARBMGokAAwCC0EIQcgAEKM9AAtB7LnDABDoKwALIAUoAghBCUcNASAIKAIEIQQgCCAgNgIEIBggDS0AVUEAR2ohGAJAIARFBEAgDUEANgJAIA1BATYCSAwBCyAIKAIAKAIIQQhqIQcDQCAEKAI4IAdGDQALIAQoAkAhByANIAQ2AkAgDSAHQQFqNgJIIAQgIDYCPAsgGEEBTQRAIB9BAWoiHyAXRw0FCyAVKAIEIBUoAgAoAggRAwAgA0EKNgIADAILIAgoAgQEQCADQQo2AgAMAgsgA0EJNgIAIAhBAToACAwBCyADIAUpAwg3AwAgA0EYaiAFQSBqKQMANwMAIANBEGogBUEYaikDADcDACADQQhqIAVBEGopAwA3AwAgDRCJJAsgBUFAayQADAILQZuAwwBBFkG0gMMAEJ8pAAsgCCgCACEEDAELCwJAAkACQCADKAIAIgVBCWsOAgEAAgsgC0EKNgIADAQLIAtBCTYCAAwDCyATQRhqIBRBGGooAgA2AgAgE0EQaiAUQRBqKQIANwIAIBMgFCkCADcCACATQQhqIBRBCGopAgA3AgAgAyAFNgIgIAMpAzgiIyAPKQMIUgRAIB4gA0EgahC5HwwBCwsgCyADKQMgNwMAIA8gI0IBfDcDCCALQQhqIANBKGopAwA3AwAgC0EQaiADQTBqKQMANwMADAELIA8gI0IBfDcDCCADQUBrIB4QhBUgC0EQaiADQdAAaikDADcDACALQQhqIANByABqKQMANwMAIAsgAykDQDcDAAsgA0HgAGokAAJAAkACQAJAIAwoAjhBCWsOAgIAAQsgEkEKNgIADAILIBIgDCkDODcDACASQRBqIAxByABqKQMANwMAIBJBCGogDEFAaykDADcDAAwBCyASQQlBCiAJLQAMGzYCAAsgDEGAAWokACAKKAIYIgNBCEcEQAJAAkAgA0EJaw4CAwEACyAKQRBqIApBLGooAgAiAjYCACAKIAopAiQiIzcDCCAKKQIcISQgEEEUaiACNgIAIBAgIzcCDCAQICQ3AgQgECADNgIADAQLIBBBCTYCAAwDCyAKQRBqIgMgHUEIaigCADYCACAKIB0pAgA3AwggCigCHCIIRQ0AIBwgCikDCDcCACAcQQhqIAMoAgA2AgAgCiAINgIYIBYgCkEYahCFJAwBCwsgECAWKQIANwIEIBBBDGogFkEIaigCADYCACAJQQA2AkggCUKAgICAwAA3A0AgEEEINgIACyAKQTBqJAAgBigCWCICQQlGDQEgBkH4AGoiAyAGQeQAaigCADYCACAGIAYpAlw3A3AgBikDaCEjIAkQwyYgAkEIRg0CIAZBiAFqIAMoAgA2AgAgBiAGKQNwNwOAASABQewAahDtOwwDC0Gs9sIAEOgrAAsgG0EDOgAAIABBCTYCAEEDDAILIAZBEGogAygCADYCACAGIAYpA3A3AwggASgCECEDIAEoAhQhCSAGIAFB7ABqIgg2AmAgBiADIAlBBHRqNgJcIAYgAzYCWCAGIAZBCGoiAzYCZCAGQYABaiAGQdgAahDVGiADENQnIAMQ7jsgCBDtOwsgAUEBOgB4IAEQoi0gAUGEAWoQ7TsgACACNgIAIAAgIzcDECAAIAYpA4ABNwIEIABBDGogBkGIAWooAgA2AgBBAQs6AJABIAZBkAFqJAAPC0Gs3sIAEOgrAAv9BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdChoyYsODAgYMGNwIAIAdBCGpBhoyYMDYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KGjJiw4MCBgwY3AgAgA0EIakGGjJgwNgIAIAZBEGogBBDHBkEMQQQQrTYiBEUNASAEIAYpAhA3AgAgBEEIaiAGQRhqKAIANgIAIAYgBDYCOCAGIAM2AjQgBkEiOgAwIAAgASAHQQFrQXhxakEIaiACIAZBMGogBRCGASABIAEoAgAiAEEBazYCACAAQQFGBEAgBkEIahC7IwsgBigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgBkEwahCmDAsgBkFAayQADwtBBEEMEKM9AAv9BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdCgoSIkKDAgIECNwIAIAdBCGpBgoSIEDYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KChIiQoMCAgQI3AgAgA0EIakGChIgQNgIAIAZBEGogBBDHBkEMQQQQrTYiBEUNASAEIAYpAhA3AgAgBEEIaiAGQRhqKAIANgIAIAYgBDYCOCAGIAM2AjQgBkEiOgAwIAAgASAHQQFrQXhxakEIaiACIAZBMGogBRCGASABIAEoAgAiAEEBazYCACAAQQFGBEAgBkEIahC7IwsgBigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgBkEwahCmDAsgBkFAayQADwtBBEEMEKM9AAv/BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdCiZKkyJChwoQJNwIAIAdBCGpBiZKkyAA2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCiZKkyJChwoQJNwIAIANBCGpBiZKkyAA2AgAgBkEQaiAEEMcGQQxBBBCtNiIERQ0BIAQgBikCEDcCACAEQQhqIAZBGGooAgA2AgAgBiAENgI4IAYgAzYCNCAGQSI6ADAgACABIAdBAWtBeHFqQQhqIAIgBkEwaiAFEIYBIAEgASgCACIAQQFrNgIAIABBAUYEQCAGQQhqELsjCyAGKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAGELsjCyAGQTBqEKYMCyAGQUBrJAAPC0EEQQwQoz0AC/8EAQR/IwBBQGoiBiQAIAZBEGogASACIAMgBRCGASAGKAIYIQEgBigCFCECAkACQCAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgATYCCCAAIAI2AgQgACAHNgIAIAMQpgwMAQsgBiACNgIAIAYgATYCBCABKAIIIQhBDEEEEK02IgdFDQEgB0KIkKDAgIGChAg3AgAgB0EIakGIkKDAADYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KIkKDAgIGChAg3AgAgA0EIakGIkKDAADYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoSIkKDAgIGCBDcCACAHQQhqQYSIkCA2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoWKlKjQoMGCBTcCACAHQQhqQYWKlCg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANChYqUqNCgwYIFNwIAIANBCGpBhYqUKDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoeOnLjw4MGDBzcCACAHQQhqQYeOnDg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCh46cuPDgwYMHNwIAIANBCGpBh46cODYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoOGjJiw4MCBAzcCACAHQQhqQYOGjBg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQALvwgCB38CfiMAQTBrIgQkAAJAIAIEQCAEQSRqIAJBAEEIQRAQoBggBCgCKCEFIAQoAiRBAUcEQCACQQR0IQkgBCgCLCEIIAUhBgNAIAcgCUcEQCAHIAhqIgogASkDADcDACAKQQhqIAEpAwg3AwAgB0EQaiEHIAFBEGohASAGQQFrIgYNAQsLIAQgCDYCECAEIAU2AgwgBCACNgIUIAQgBEEYajYCJAJAIAJBAUYNACACQRVPBEAgCCEBIARBJGohBwJAIAJBAkkNAAJAAkACQCABKQMQIgsgASkDAFQiCUUEQEECIQUgAkECRg0BIAFBIGohBgNAIAsgBikDACILVg0CIAZBEGohBiACIAVBAWoiBUcNAAsMAgtBAiEFIAJBAkYNACABQSBqIQYDQCALIAYpAwAiC1gNASAGQRBqIQYgAiAFQQFqIgVHDQALDAELIAIgBUcNAQsgCUUNASACQQF2IQYgAkEEdCABakEQayEFA0AgASkDACELIAEgBSkDADcDACABQQhqIgcpAwAhDCAHIAVBCGoiBykDADcDACAFIAs3AwAgByAMNwMAIAVBEGshBSABQRBqIQEgBkEBayIGDQALDAELIAEgAkEAIAJBAXJnQQF0QT5zIAcQyA8LDAELAkAgAgRAIAJBAUcEQCAIIAJBBHRqIQkgCEEQIgVqIQYDQCAGKQMAIgsgBkEQaykDAFQEQCAGKQMIIQwgBSEBAn8DQCABIAhqIgcgB0EQayIKKQMANwMAIAdBCGogCkEIaikDADcDACAIIAFBEEYNARogAUEQayEBIAsgB0EgaykDAFQNAAsgASAIagsiASAMNwMIIAEgCzcDAAsgBUEQaiEFIAZBEGoiBiAJRw0ACwsMAQsACwtBACEFIARBJGogAkEAQQhBEBCgGCAEKAIoIQEgBCgCJEEBRwRAIARBADYCICAEIAQoAiw2AhwgBCABNgIYQQAhAUEBIQcDQAJ/AkACQCABIAJJBEAgCCABQQR0aiIJKQMIIQsgAiAHRg0CIAIgByACIAdLGyEGIAggB0EEdGohAQNAIAYgB0YNAiAHIAEpAwAiDCALVCAMIAt9IANYckUNBBogAUEIaikDACIMIAsgCyAMVBshCyABQRBqIQEgB0EBaiIHIAJHDQALDAILIAEgAkGk7sMAEMMhAAsgBiACQbTuwwAQwyEACyACCyEBIAkpAwAhDCAEKAIYIAVGBEAgBEEYakHE7sMAEJUoCyAEKAIcIAVBBHRqIgYgCzcDCCAGIAw3AwAgBCAFQQFqIgU2AiAgAUEBaiEHIAEgAkcNAAsgACAEKQIYNwIAIABBCGogBEEgaigCADYCACAEQQxqQQhBEBDgHgwDCyABIAQoAixBlO7DABD9LwALIAUgBCgCLEGE7sMAEP0vAAsgAEEANgIIIABCgICAgIABNwIACyAEQTBqJAAL8AQCBH8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBCE8EQCABQQxqIQcgASgCECEDIAJBeHEhBUEAIQIDQCADKQMAIghCAFkgBiAIp0txRQRAIAEgAhCLOw0DCyADQQhqIQMgAkEBaiECIAVBCGsiBQ0ACwsgBEHIAGogBEEYaigCADYCACAEIAQpAhA3A0AgBEHMAGogAUEw/AoAACAEKQIIIQggACAEQUBrQTz8CgAAIABBADoARCAAIAg3AjwMAQsgBCACNgIgIAQgAzYCJCAEQQM2AiwgBEGsgoQBNgIoIARCAzcCNCAEQTs2AlQgBEE7NgJMIARByBA2AkQgBCAEQUBrNgIwIAQgBEEcajYCUCAEIARBIGo2AkggBCAEQSRqNgJAIABBBGogBEEoahCZDiAAQQI6AEQgAEGNgICAeDYCACAEQRBqELwMIAQoAggiACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBCGoQuyMLIAEQvAwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBxD7HgsgASgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPseCyAEQYABaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvvBAIFfwF+IwBBgAFrIgQkACAEIAM2AgwgBCACNgIIIARBQGsiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAkA3AgAgAkEIaiAEQcgAaiIFKAIANgIAIAMgBEEIaiIGEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCQDcCACADQQhqIAUoAgA2AgAgBCADNgIYIAQgAjYCFCAEQSI6ABAgBCAGEPQtIgY2AhwCQAJAIAEoAhQiAkECTwRAIAFBDGohByABKAIQIQMgAkF+cSEFQQAhAgNAIAMuAQAiCEEATiAGIAhLcUUEQCABIAIQizsNAwsgA0ECaiEDIAJBAWohAiAFQQJrIgUNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEJIAAgBEFAa0E8/AoAACAAQQA6AEQgACAJNwI8DAELIAQgAjYCICAEIAM2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQfcXNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAcQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL7wQCBX8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBBE8EQCABQQxqIQcgASgCECEDIAJBfHEhBUEAIQIDQCADKAIAIghBAE4gBiAIS3FFBEAgASACEIs7DQMLIANBBGohAyACQQFqIQIgBUEEayIFDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCSAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCTcCPAwBCyAEIAI2AiAgBCADNgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEHtBjYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAHEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC94EAQl/IwBBEGsiBCQAAn8CQCACKAIEIgVFDQAgACACKAIAIAUgASgCDBEGAEUNAEEBDAELIAIoAgwiAwRAIAIoAggiBSADQQxsaiEJIARBDGohCgNAAkACQAJAAkAgBS8BAEEBaw4CAgEACwJAIAUoAgQiAkHBAE8EQCABQQxqKAIAIQMDQEEBIABBlPaJAUHAACADEQYADQgaIAJBQGoiAkHAAEsNAAsMAQsgAkUNAwsgAEGU9okBIAIgAUEMaigCABEGAEUNAkEBDAULIAAgBSgCBCAFKAIIIAFBDGooAgARBgBFDQFBAQwECyAFLwECIQIgCkEAOgAAIARBADYCCAJAIAJFBEBBASEHDAELIAJB9v8XaiACQZz/H2pxIAJBmPg3aiACQfCxH2pxcyIDQRF2QQFqIQcgA0GAgChJDQAgB0EFQdT2iQEQsDsACyAEQQhqIgggB2oiA0EBayIGIAIgAkEKbiILQQpsa0EwcjoAAAJAIAYgCEYNACADQQJrIgYgC0EKcEEwcjoAACAEQQhqIAZGDQAgA0EDayIGIAJB5ABuQQpwQTByOgAAIARBCGogBkYNACADQQRrIgYgAkHoB25BCnBBMHI6AAAgBEEIaiAGRg0AIANBBWsiBiACQZDOAG5BMHI6AAAgBEEIaiAGRg0AIANBBmsiAkEwOgAAIAIgCEYNACADQQdrIgJBMDoAACAEQQhqIAJGDQAgA0EIa0EwOgAACyAAIARBCGogByABQQxqKAIAEQYARQ0AQQEMAwsgBUEMaiIFIAlHDQALC0EACyAEQRBqJAAL0AQBCn8jAEEwayIBJAAgACgCJCEEIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAAkACQCAEBEAgAkUNAyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGCAAKAIgIgcNAUEAIQAMAgsgAkUEQEEAIQAMBAsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxgCQCAAKAIgIgRFBEBBACEADAELIAAoAhwhAkEAIQAgASgCJCEFIAEoAhwhByABKAIoIQMDQCADIAItAAAiBk0NBiAAIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQAgAkEBaiECIARBAWsiBA0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQMgAUEYahD7HgwDCyAAKAIcIQUgACgCMCECIAAoAighBiAAKAI0IQRBACEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgBEUNBEEBIQMgBiACQQN2ai0AACACQQdxdkEBcQRAIAogBS0AACIDTQ0FIAkgAyAIaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXEhAwsgBUEBaiEFIARBAWshBCACQQFqIQIgACADaiEAIAdBAWsiBw0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQEgAUEYahD7HgwBCyAAKAI4IQAMAAsgAUEwaiQAIAAPC0Hk5oQBQSBBhOeEARCfKQAL0AQBCn8jAEEwayIBJAAgACgCJCEEIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAAkACQCAEBEAgAkUNAyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGCAAKAIgIgcNAUEAIQAMAgsgAkUEQEEAIQAMBAsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxgCQCAAKAIgIgRFBEBBACEADAELIAAoAhwhAkEAIQAgASgCJCEFIAEoAhwhByABKAIoIQMDQCADIAIsAAAiBk0NBiAAIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQAgAkEBaiECIARBAWsiBA0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQMgAUEYahD7HgwDCyAAKAIcIQUgACgCMCECIAAoAighBiAAKAI0IQRBACEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgBEUNBEEBIQMgBiACQQN2ai0AACACQQdxdkEBcQRAIAogBSwAACIDTQ0FIAkgAyAIaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXEhAwsgBUEBaiEFIARBAWshBCACQQFqIQIgACADaiEAIAdBAWsiBw0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQEgAUEYahD7HgwBCyAAKAI4IQAMAAsgAUEwaiQAIAAPC0Hk5oQBQSBBhOeEARCfKQAL8QQCBH8CfiMAQRBrIgYkAAJAIAEgAkVyRQRAQX8hBAwBCwJAQQFBBSADGyIEIAJLBEAgAkUgA0EBRnINAiAGQajqvmk2AgwgAkUiAEUEQCAGQQxqIAEgAvwKAAALIAYoAgxBqOq+aUYNAiAGQdDUtMIBNgIMIABFBEAgBkEMaiABIAL8CgAACyAGKAIMQXBxQdDUtMIBRg0CDAELIABBAEEw/AsAAkAgA0EBRg0AIAEoAAAiBUGo6r5pRg0AIAVBcHFB0NS0wgFHDQFBCCEEIAJBCEkNAiABNQAEIQggAEEBNgIUIAAgCDcDAEEAIQQMAgsgAiABIAIgAxCxICICSQRAIAIhBAwCCyAAIAI2AhggASAEaiIFQQFrLQAAIgJBCHEEQEFyIQQMAgsgAkEgcSIDRQRAIAUtAAAiBUGnAUsEQEFwIQQMAwsgBUEHca1CASAFQQN2QQpqrYYiCEIDiH4gCHwhCSAEQQFqIQQLIAJBBnYhBSACQQJ2AkACQAJAAkAgAkEDcSICQQFrDgMAAQIDCyABIARqLQAAIQIgBEEBaiEEDAILIAEgBGovAAAhAiAEQQJqIQQMAQsgASAEaigAACECIARBBGohBAtBAXEhBwJ+AkACQAJAAkAgBUEBaw4DAQIDAAtCfyADRQ0DGiABIARqMQAADAMLIAEgBGozAABCgAJ8DAILIAEgBGo1AAAMAQsgASAEaikAAAshCCAAIAc2AiAgACACNgIcIAAgCDcDAEEAIQQgAEEANgIUIAAgCCAJIAMbIgg3AwggAEKAgAggCCAIQoCACFobPgIQDAELQXYhBAsgBkEQaiQAIAQL+AQBCX8jAEEwayIEJAACQAJAAkAgAS0AWARAIAMEQCABKAIAIAFBADYCACABKAI4IgcgAyADIAdLGyEJRQ0CIAIgASgCBCIGNgIAIAEgBjYCVCABIAdBAWs2AjhBASEGDAILIABBADYCBAwCCyAEQQA2AhggBEEBNgIMIARByKLNADYCCCAEQgQ3AhAgBEEIakGYp80AEO8sAAsCQAJAAkACQCAGIAlHBEAgAUEIaiELIAEoAlAhBQNAAkAgBQ0AIARBCGogARDBCSAEKAIIIgVBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwICyABKAJMIgcgASgCMCIFTw0CIAEoAiwgB2otAAAhBSAEIAkgBmsiByABKAJQIgggByAISRsiCDYCACAGIAhqIgcgCEkNAyADIAdJDQQgBCALIAIgBkECdGoiBiAIIAUQuQYiBTYCBCAFIAhHDQUgCARAIAhBAnQhCiABKAJUIQUgASgCRCEMA0AgBiAGKAIAIAUgDGpqIgU2AgAgBkEEaiEGIApBBGsiCg0ACyABIAU2AlQLIAEgASgCUCAIayIFNgJQIAEgASgCOCAIazYCOCAHIgYgCUcNAAsLIAAgCTYCBAwECyAHIAVBqKfNABDDIQALIAYgB0G4p80AELE7AAsgByADQbinzQAQsDsACyAEQQI2AgwgBEH0p80ANgIIIARCAjcCFCAEQTs2AiwgBEE7NgIkIAQgBEEgajYCECAEIARBBGo2AiggBCAENgIgIABBBGogBEEIahCZDkEAIQUMAQtBCCEFCyAAIAU2AgAgBEEwaiQAC/oEAgd/An4jAEEwayIEJAACQAJAAkAgAS0AaARAIAMEQCABKAIAIAFCADcDACABKAJQIgYgAyADIAZLGyEJRQ0CIAIgASkDCCILNwMAIAEgCzcDOCABIAZBAWs2AlBBASEHDAILIABBADYCBAwCCyAEQQA2AhggBEEBNgIMIARByKLNADYCCCAEQgQ3AhAgBEEIakGYp80AEO8sAAsCQAJAAkACQCAHIAlHBEAgAUEQaiEKIAEoAmQhBQNAAkAgBQ0AIARBCGogARCNCyAEKAIIIgVBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwICyABKAJgIgYgASgCSCIFTw0CIAEoAkQgBmotAAAhBSAEIAkgB2siBiABKAJkIgggBiAISRsiCDYCACAHIAhqIgYgCEkNAyADIAZJDQQgBCAKIAIgB0EDdGoiByAIIAUQkAQiBTYCBCAFIAhHDQUgCARAIAhBA3QhBSABKQM4IQsgASkDMCEMA0AgByAHKQMAIAsgDHx8Igs3AwAgB0EIaiEHIAVBCGsiBQ0ACyABIAs3AzgLIAEgASgCZCAIayIFNgJkIAEgASgCUCAIazYCUCAGIgcgCUcNAAsLIAAgCTYCBAwECyAGIAVBqKfNABDDIQALIAcgBkG4p80AELE7AAsgBiADQbinzQAQsDsACyAEQQI2AgwgBEH0p80ANgIIIARCAjcCFCAEQTs2AiwgBEE7NgIkIAQgBEEgajYCECAEIARBBGo2AiggBCAENgIgIABBBGogBEEIahCZDkEAIQUMAQtBCCEFCyAAIAU2AgAgBEEwaiQAC7oEAgZ/CH4jAEHwAGsiBiQAAkAgASADaiIDIAAoAggiCE0EQCAAIAM2AggMAQsgACADIAhrEMggCyAGIAQgBRDgHCAGQgA3A2ggBiABNgJgIAYgASACaiICNgJkAkACQAJAIAEgAk8NACACQQFrIQIgBigCWCEJIAYpAyAhDiAGKAJUIQggBigCUCEFIAYpA0AhDCAGKQMwIQ8gBigCECEDIAYpAwghDSAGKAIoIQogBigCGCELIAYpA0ghESAGKQM4IRIgBikDACEQA0AgEKdBAXEEf0EABUEBCyEEAkADQAJAAkACQCAERQRAIA1QRQ0BQgAhDUIAIRBBASEEDAQLAn4CQCAPQgJ9IhNCAVgEQCATp0EBaw0BDAULIA+nIA9QrUIBhiEPQQFxRQ0AIBIMAQsgDEIDUQRAQgMhDAwECyAFRSAFIAhGckUEQCAIQQhrIggpAwAMAQtBACEFIAxCAlEEQEICIQwMBAsgDKdCACEMQQFxRQ0DIBELIQ1CASEQIAlBQGoiCSEDDAELIAMgDXmnQT9zIgdqIQRCASAHrYYgDYUhDQwDC0EAIQQMAQsLIAsgDkIAUnFFDQIgCiAOeadBP3MiB2ohBEIBIAethiAOhSEOCyACIARPDQEgAiAAKAIIIgdPDQIgBCAHTw0DIAQgACgCBCIEaiACIARqLQAAOgAAIAEgAkkgAkEBayECDQALCyAGQfAAaiQADwsgAiAHQbCazwAQwyEACyAEIAdBwJrPABDDIQAL4QQCCX8BfiAAKAIAIQMgACgCBCIKQQFqIgZBA3YgBkEHcUEAR2oiBARAIAMhBQNAIAUgBSkDACIMQn+FQgeIQoGChIiQoMCAAYMgDEL//v379+/fv/8AhHw3AwAgBUEIaiEFIARBAWsiBA0ACwsgAAJ/AkAgBkEITwRAIAMgBmogAykAADcAAAwBCyAGBEAgA0EIaiADIAb8CgAACyAGDQBBAAwBCyACKAIUIQtBACEEA0ACQCAAKAIAIgIgBCIFai0AAEGAAUcNACACIAVBA3RrQQhrIQgCQANAIAEgACAFIAsRDQAhDCAAKAIEIgYgDKciCXEiAyECIAAoAgAiBCADaikAAEKAgYKEiJCgwIB/gyIMUARAQQghBwNAIAIgB2ohAiAHQQhqIQcgBCACIAZxIgJqKQAAQoCBgoSIkKDAgH+DIgxQDQALCyAEIAx6p0EDdiACaiAGcSICaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiECCyACIANrIAUgA2tzIAZxQQhJDQEgAiAEaiIDLQAAIAMgCUEZdiIDOgAAIAQgAkEIayAGcWpBCGogAzoAACAEIAJBA3RrQQhrIQJB/wFHBEAgCCACQQIQ+ioMAQsLIAAoAgAiAyAFakH/AToAACADIAAoAgQgBUEIa3FqQQhqQf8BOgAAIAIgCCkAADcAAAwBCyAEIAVqIAlBGXYiAjoAACAEIAYgBUEIa3FqQQhqIAI6AAALIAVBAWohBCAFIApHDQALIAAoAgQiASABQQFqQQN2QQdsIAFBCEkbCyAAKAIMazYCCAvnGgIMfwJ+IwBBkAFrIgQkACABIAEoAgwiDEEBajYCDAJAIAEgDBDyJkUEQCAAQYGAgIB4NgIAIAMtAABBKUYNASADEJ0MDAELIAMvAQ4hAQJ/AkACQAJAIAIoAgAiC0EIaiICIAsoAghBAkZBAnRqLQAgIgdBACAHQQNHGyINQQFrDgIAAgELQQEhDiABQQFqIQELIAMvAQwMAQsgAUEBaiEBIAMvAQxBAWoLIQ8gBEE4aiADQQhqKAIANgIAIAQgAykCADcDMCAEQRhqIQcgBEEwaiEKIwBBwAFrIgMkAAJAAkACQAJAAkAgAwJ/AkAgAwJ/AkACQAJAAkAgAigCAEECRwRAAkACQAJAAkACQAJAAkACQCACLQAwQQFrDgcAAQIDBAUGBwsgAigCLCEGIAIoAighCCADQfgAaiACEIkZIANB8ABqIANBgAFqIgkoAgA2AgAgAyADKQJ4NwNoIAMgAi0AISIFOgB0AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQB4QQRrDg4MDRABDg8BAQEBAQEBAAELIAUOEwEAAAAAAAIDBAAAAAUGBwAICQoACyADQZABaiAJKAIANgIAIAMgAykCeDcDiAEgAyAFOgCHASADQQI2ApwBIANB2OvNADYCmAEgA0ICNwKkASADQagENgK8ASADQakENgK0ASADIANBsAFqNgKgASADIANBhwFqNgK4ASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOIANBAzYCMAwhCyADQQg2AjAgA0EEOgA0DCALIANBMGogCCAGELEQDB8LIANBCDYCMCADQQ46ADQMHgsgA0EINgIwIANBkAI7ATQMHQsgA0EINgIwIANBBjoANAwcCyADQQg2AjAgA0EHOgA0DBsLIANBCDYCMCADQQg6ADQMGgsgA0EINgIwIANBAjoANAwZCyADQQg2AjAgA0EDOgA0DBgLIANBCDYCMCADQQQ6ADQMFwsgA0EwaiADKAJ8IAMoAoABELEQDBYLIANBCDYCMCADQQ46ADQMFQsgAy0AeSEFIAMtAHohBiADIANB6ABqNgKIASAFQQhGDQIgBUEQRg0DIAVBIEYNBCADQQE2ApwBIANBkOvNADYCmAEgA0IBNwKkASADQaoENgK0ASADIANBsAFqNgKgASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOQQMMEQsgA0EINgIwIANBADoANAwTCyADIAMtAHkiBToAiAEgBUUNECADQQE2ApwBIANBkOvNADYCmAEgA0IBNwKkASADQasENgK0ASADIANBsAFqNgKgASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOQQMMEQsgBkEBcUUEQCADQQY6ADQMDgsgA0ECOgA0DA0LIAZBAXFFBEAgA0EHOgA0DA0LIANBAzoANAwMCyAGQQFxRQRAIANBCDoANEEIDA0LIANBBDoANAwLCyACKAIsIQUgAigCKCEIIANBiAFqIAIQiRkgAi0AISEGAkACfwJAAkACQAJAAkACQAJAAkAgAy0AiAEiCUEEaw4FARMCAwkACyAJQRFHDRICQAJAAkACQAJAAkACQCAGQQZrDg4BGRkCAwQZGRkFGRkZBgALIAYNGCADQQg2AjAgA0EFOgA0DB0LIANBMGogCCAFELEQDBwLIANBCDYCMCADQZEEOwE0DBsLIANBCGpB6OvNAEEDEJQnIANBjQI7ATQgA0EINgIwIAMgAykDCDcDOAwaCyADQRBqQejrzQBBAxCUJyADQY0EOwE0IANBCDYCMCADIAMpAxA3AzgMGQsgA0EINgIwIANBCToANAwYCyADQQg2AjAgA0EFOgA0DBcLIANBMGogAygCjAEgAygCkAEQsRAMFgsgAy0AiQFBAWsOAgIDAQsgAy0AiQFBAWohBiADLQCKAQ0DQQAMBAsgA0GYAWpBKUEAQQFBARCgGCADKAKcASEFIAMoApgBQQFGDRYgAygCoAEiBkHr680AQSn8CgAAIANBKTYCPCADIAY2AjggAyAFNgI0IANBAzYCMAwTCyADQQg2AjAgA0GRBDsBNAwSCyADQQg2AjAgA0GRBjsBNAwRCyADQRhqQejrzQBBAxCUJyADKAIcIQUgAygCGAshCCADIAU2AjwgAyAINgI4IAMgBjoANSADQQ06ADQgA0EINgIwDA8LIAMtAIkBQcAARw0JIAMtAIoBRQRAIANBCDYCMCADQQk6ADQMDwsgA0EINgIwIANBBToANAwOCyADQQA2AjggA0GNBjsBNAwOCyADQQs6ADQMDQsgA0EMOgA0DAwLIAIoAighBiACKAIsIQggA0GIAWogAhCJGSACLQAhIQUCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQCIASIJDgwIAQEJCgEBAQEBCwwACyAJQRFHDQACQCAFDgcCAwEBAQQFAAsgBUEUaw4CBQYACyADQfAAaiADQZABaigCADYCACADIAMpAogBNwNoIAMgBToAeCADQQI2ApwBIANBiO3NADYCmAEgA0ICNwKkASADQagENgK8ASADQakENgK0ASADIANBsAFqNgKgASADIANB+ABqNgK4ASADIANB6ABqNgKwASADQTBqQQRyIANBmAFqEJkOIANBAzYCMAwVCyADQQg2AjAgA0EUOgA0DBQLIANBCDYCMCADQRg6ADQMEwsgA0EINgIwIANBFDoANAwSCyADQTBqIAYgCBDJLgwRCyADQQg2AjAgA0EYOgA0DBALIANBCDYCMCADQRQ6ADQMDwsgA0EINgIwIANBGDoANAwOCyADQQg2AjAgA0EUOgA0DA0LIANBMGogAygCjAEgAygCkAEQyS4MDAsgA0EINgIwIANBGDoANAwLCyADQQg2AjAgA0EUOgA0DAoLIAIoAiQhBSACKAIsIQYgAigCKCEIIANBsAFqIAIQiRkCQAJAAkAgAy0AsAEiCUENaw4FAgYGBgABCyACLQAhIglBBkcEQCAJQRZHDQYgA0EINgIwIANBkwI7ATQMDAsgBUERTgRAIANBMGogCCAGELIQDAwLIANBMGogCCAGELEQDAsLIAlBBEcNBCADKAK4ASEGIAMoArQBIQggBUERTgRAIANBMGogCCAGELIQDAsLIANBMGogCCAGELEQDAoLIAVBAkYNAiADQZgBakHCAEEAQQFBARCgGCADKAKcASEFIAMoApgBQQFGDQwgAygCoAEiBkGY7c0AQcIA/AoAACADQcIANgI8IAMgBjYCOCADIAU2AjQgA0EANgIwDAkLIANBAToANAwJC0HMwc0AQShBjOrNABCfKQALIANBCDYCMCADQQo6ADQMBgsgAyAFNgI4IANBFToANCADQQg2AjAMBQsgA0HwAGogA0GQAWooAgA2AgAgAyADKQKIATcDaCADIAY6AHggA0ECNgKcASADQcTszQA2ApgBIANCAjcCpAEgA0GoBDYCvAEgA0GpBDYCtAEgAyADQbABajYCoAEgAyADQfgAajYCuAEgAyADQegAajYCsAEgA0EwakEEciADQZgBahCZDiADQQM2AjAMBAtBCAs2AjAMAgsgA0GQAjsBNEEICzYCMAsgAygCMCIFQQhGDQAgA0EoaiADQTxqKAIAIgY2AgAgAyADKQI0IhA3AyAgAykDQCERIAdBDGogBjYCACAHIBA3AgQgByARNwMQIAcgBTYCACAKLQAAQSlGDQEgChCVDAwBCyADQdAAaiIFIANBPGooAgA2AgAgAyADKQI0NwNIAkAgCi0AAEEpRwRAIANB4ABqIApBCGooAgA2AgAgAyAKKQIANwNYIANBmAFqIANByABqIANB2ABqENEKDAELIANBoAFqIAUoAgA2AgAgAyADKQNINwOYAQsgByADKQOYATcCBCAHQQg2AgAgB0EMaiADQaABaigCADYCAAsgA0HAAWokAAwBCyAFIAMoAqABQfy7zQAQ/S8ACyAEQRBqIgMgBEEkaigCADYCACAEIAQpAhw3AwggBCgCGCIHQQhHBEAgBCkDKCEQIAAgBCkDCDcCDCAAIBA3AxggACAHNgIIIABBgoCAgHg2AgAgAEEUaiADKAIANgIADAELIARByABqIgcgAygCADYCACAEIAQpAwg3A0AgCyALKAIAIgNBAWo2AgAgA0EATgRAIARB5ABqIAcoAgA2AgAgBCAOOgBsIAQgATsBaiAEIA87AWggBCAEKQNANwJcIAQgDDYCWCAEIAs2AlQgBEGAgICAeDYCUAJAIA1BAkYEQCAEQfAAaiAEQdAAaiACIAIoAgBBAkZBAnRqIgEoAgwgASgCEBDaEwwBCyAEQYgBaiAEQegAaikCADcDACAEQYABaiAEQeAAaikCADcDACAEQfgAaiAEQdgAaikCADcDACAEIAQpAlA3A3ALIAAgBCkDcDcCACAAQRhqIARBiAFqKQMANwIAIABBEGogBEGAAWopAwA3AgAgAEEIaiAEQfgAaikDADcCAAwBCwALIARBkAFqJAALhQUCAn8EfiMAQZABayIGJAAgBiAENwMQIAYgBTcDGCAGIAI3AwAgBiADNwMIIAZBQGsgAiADIAQgBSABKAIAIgcpAwAgBykDCCAHKQMQIAcpAxgQmggCfiAGLQBAQQFGBEAgBi0AQQRAQoCAgICAgICAgH8hCEIADAILIAZBADYCMCAGQQE2AiQgBkG0i/8ANgIgIAZCBDcCKCAGQSBqQbyL/wAQ7ywACyAGKQNoIQggBikDYCEJIAYpA1ghCiAGKQNQCyELIAZBQGsgAiADIAQgBSAHKQMAIAcpAwggBykDECAHKQMYEJoIAkAgBi0AQEEBRgRAIAYtAEEEQCAGQThqQgA3AwAgBkEwakIANwMAIAZCADcDKCAGQgA3AyAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBzIv/ABDvLAALIAYgBikDiAE3AzggBiAGKQOAATcDMCAGIAYpA3g3AyggBiAGKQNwNwMgCyAGQdgAakIANwMAIAZB0ABqQgA3AwAgBkIANwNIIAZCADcDQAJAAkACQCAGIAZBQGsQ+xsiB0H/AXFBAkcgB8BBAE5xRQRAIAZBIGogASgCCBD7G8BBAEwNAQwCCyAGQSBqIAEoAgQQ+xsiAUH/AXFBAkYgAcBBAEhyDQEgCCAJIAtCAXwiBCAKIARQrXwiAoRQrXwiBSAJVK18IQgMAgsgC0IBfSEEIAogC1CtfSECIAkgCiALhFCtIgN9IQUgCCADIAlWrX0hCAwBCyAJIQUgCyEEIAohAgsgACAFNwMgIAAgBDcDECAAQgA3AwggAEIBNwMAIAAgCDcDKCAAIAI3AxggBkGQAWokAAvhBAIJfwF+IAAoAgAhAyAAKAIEIgpBAWoiBkEDdiAGQQdxQQBHaiIEBEAgAyEFA0AgBSAFKQMAIgxCf4VCB4hCgYKEiJCgwIABgyAMQv/+/fv379+//wCEfDcDACAFQQhqIQUgBEEBayIEDQALCyAAAn8CQCAGQQhPBEAgAyAGaiADKQAANwAADAELIAYEQCADQQhqIAMgBvwKAAALIAYNAEEADAELIAIoAhQhC0EAIQQDQAJAIAAoAgAiAiAEIgVqLQAAQYABRw0AIAIgBUECdGtBBGshCAJAA0AgASAAIAUgCxENACEMIAAoAgQiBiAMpyIJcSIDIQIgACgCACIEIANqKQAAQoCBgoSIkKDAgH+DIgxQBEBBCCEHA0AgAiAHaiECIAdBCGohByAEIAIgBnEiAmopAABCgIGChIiQoMCAf4MiDFANAAsLIAQgDHqnQQN2IAJqIAZxIgJqLAAAQQBOBEAgBCkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgA2sgBSADa3MgBnFBCEkNASACIARqIgMtAAAgAyAJQRl2IgM6AAAgBCACQQhrIAZxakEIaiADOgAAIAQgAkECdGtBBGshAkH/AUcEQCAIIAJBARD6KgwBCwsgACgCACIDIAVqQf8BOgAAIAMgACgCBCAFQQhrcWpBCGpB/wE6AAAgAiAIKAAANgAADAELIAQgBWogCUEZdiICOgAAIAQgBiAFQQhrcWpBCGogAjoAAAsgBUEBaiEEIAUgCkcNAAsgACgCBCIBIAFBAWpBA3ZBB2wgAUEISRsLIAAoAgxrNgIIC5ASAQx/IwBBIGsiESQAAkACQCABQSFJDQACQANAIARBAWshBANAIARBf0YEQCAAIAEgAiADQQEgBhCBCgwFCyAAIAFBA3YiB0EcbGohDyAAIAdBBHRqIQkgEQJ/IAFBwABPBEAgACAJIA8gByAGEMkRDAELIAAgACgCACIHKAIEIgggCSgCACILKAIEIgwgBygCCCIHIAsoAggiCyAHIAtJGxCZJyIKIAcgC2sgChsiCkEASiAKQQBIayIKIAggDygCACIIKAIEIg0gByAIKAIIIgggByAISRsQmSciDiAHIAhrIA4bIgdBAEogB0EASGtzQQBIDQAaIA8gCSAKIAwgDSALIAggCCALSxsQmSciByALIAhrIAcbIgdBAEogB0EASGtzQQBIGwsiCygCACIHNgIEIAsgAGtBAnYhCwJAAkAgBQRAIAUoAgAiCCgCBCAHKAIEIAgoAggiCCAHKAIIIgcgByAISxsQmSciDyAIIAdrIA8bQQBODQELAn9BACEJIAEgA0sgCyIHIAFPckUEQCACIAFBAnRqIQ8gACAHQQJ0aiEMIAAhCANAIAAgB0EDayIKQQAgByAKTxtBAnRqIhIgCEsEQANAIAlBAnQgAiAPQQRrIAgoAgAiCigCBCAMKAIAIg4oAgQgCigCCCINIA4oAggiDiANIA5JGxCZJyIQIA0gDmsgEBsiDUEASBtqIAo2AgAgDUEfdiAJaiIOQQJ0IAIgD0EIayAIQQRqKAIAIgkoAgQgDCgCACINKAIEIAkoAggiCiANKAIIIg0gCiANSRsQmSciECAKIA1rIBAbIgpBAEgbaiAJNgIAIApBH3YgDmoiDkECdCACIA9BDGsgCEEIaigCACIJKAIEIAwoAgAiDSgCBCAJKAIIIgogDSgCCCINIAogDUkbEJknIhAgCiANayAQGyIKQQBIG2ogCTYCACAKQR92IA5qIg5BAnQgAiAPQRBrIg8gCEEMaigCACIJKAIEIAwoAgAiDSgCBCAJKAIIIgogDSgCCCINIAogDUkbEJknIhAgCiANayAQGyIKQQBIG2ogCTYCACAKQR92IA5qIQkgCEEQaiIIIBJJDQALCyAAIAdBAnRqIhIgCEsEQANAIAlBAnQgAiAPQQRrIg8gCCgCACIKKAIEIAwoAgAiDigCBCAKKAIIIg0gDigCCCIOIA0gDkkbEJknIhAgDSAOayAQGyINQQBIG2ogCjYCACANQR92IAlqIQkgCEEEaiIIIBJJDQALCyABIAdHBEAgD0EEayIPIAlBAnRqIAgoAgA2AgAgCEEEaiEIIAEhBwwBCwsgCUECdCIHBEAgACACIAf8CgAACyABIAlHBEAgASAJayEHIAAgCUECdGohCCABQQJ0IAJqQQRrIQ8DQCAIIA8oAgA2AgAgD0EEayEPIAhBBGohCCAHQQFrIgcNAAsLIAkMAQsACyIHRQ0AIAEgB08NASARQQA2AhggEUEBNgIMIBFBzN6HATYCCCARQgQ3AhAgEUEIakHU3ocBEO8sAAsgAQJ/QQAhCCABIANLIAsiBSABT3JFBEAgAiABQQJ0aiELIAAgBUECdGohDyAAIQcDQCAAIAVBA2siCUEAIAUgCU8bQQJ0aiINIAdLBEADQCAIQQJ0IAIgC0EEayAPKAIAIgwoAgQgBygCACIJKAIEIAwoAggiDCAJKAIIIgogCiAMSxsQmSciDiAMIAprIA4bQQBOIgwbaiAJNgIAIAggDGoiCkECdCACIAtBCGsgDygCACIJKAIEIAdBBGooAgAiCCgCBCAJKAIIIgkgCCgCCCIMIAkgDEkbEJknIg4gCSAMayAOG0EATiIJG2ogCDYCACAJIApqIgpBAnQgAiALQQxrIA8oAgAiCSgCBCAHQQhqKAIAIggoAgQgCSgCCCIJIAgoAggiDCAJIAxJGxCZJyIOIAkgDGsgDhtBAE4iCRtqIAg2AgAgCSAKaiIKQQJ0IAIgC0EQayILIA8oAgAiCSgCBCAHQQxqKAIAIggoAgQgCSgCCCIJIAgoAggiDCAJIAxJGxCZJyIOIAkgDGsgDhtBAE4iCRtqIAg2AgAgCSAKaiEIIAdBEGoiByANSQ0ACwsgACAFQQJ0aiINIAdLBEADQCAIQQJ0IAIgC0EEayILIA8oAgAiDCgCBCAHKAIAIgkoAgQgDCgCCCIMIAkoAggiCiAKIAxLGxCZJyIOIAwgCmsgDhtBAE4iDBtqIAk2AgAgCCAMaiEIIAdBBGoiByANSQ0ACwsgASAFRwRAIAhBAnQgAiALQQRrIgtBARtqIAcoAgA2AgAgB0EEaiEHIAhBAWohCCABIQUMAQsLIAhBAnQiBQRAIAAgAiAF/AoAAAsgASAIRwRAIAEgCGshBSAAIAhBAnRqIQcgAUECdCACakEEayELA0AgByALKAIANgIAIAtBBGshCyAHQQRqIQcgBUEBayIFDQALCyAIDAELAAsiB0kNAyAAIAdBAnRqIQBBACEFIAEgB2siAUEhTw0CDAQLIAAgB0ECdGogASAHayACIAMgBCARQQRqIAYQ7wkgBEEBayEEIAciAUEhTw0ACwsMAQsgByABQeTehwEQrzsACyAAIQQjAEEQayIGJAAgAUECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEFIAFBD0sNASABQQdLBEAgACACEOUNIAAgBUECdCIDaiACIANqEOUNQQQMAwsgAiAEKAIANgIAIAIgBUECdCIAaiAAIARqKAIANgIAQQEMAgsACyAEIAIgAiABQQJ0aiIAEMgtIAQgBUECdCIDaiACIANqIABBIGoQyC1BCAshB0EAIQAgBkEANgIIQQAgB2shDyAEIAdBAnQiA2ohCSACIANqIQwgBiAFNgIMIAEgBWshCiAGQQhqIQ0DQCAAIAogBSANIABBAnRqKAIAIgAbIgsgB0sEQCACIABBAnQiAGohDiALIA9qIQggACAJaiELIAAgDGohAANAIAAgCygCADYCACAOIAAQ5xkgC0EEaiELIABBBGohACAIQQFrIggNAAsLQQEhAEEBcUUNAAsgAiABIAQQ4g4LIAZBEGokAAsgEUEgaiQAC9cFAQN/IAAQmj4iACAAKAIEQXhxIgEQmD4hAgJAAkACQAJAIAAoAgQiA0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQEgACADEJY+IgBB0POKASgCAEYEQCACKAIEQQNxQQNHDQFByPOKASABNgIAIAAgASACEIkuDwsgACADEIUPCwJAAkAgAigCBCIDQQJxRQRAIAJB1POKASgCAEYNAiACQdDzigEoAgBGDQUgAiADQXhxIgIQhQ8gACABIAJqIgEQ0DQgAEHQ84oBKAIARw0BQcjzigEgATYCAA8LIAAgASACEIkuCyABQYACSQ0CIAAgARDsEEEAIQBB6POKAUHo84oBKAIAQQFrIgE2AgAgAQ0BQbDxigEoAgAiAQRAA0AgAEEBaiEAIAEoAggiAQ0ACwtB6POKAUH/HyAAIABB/x9NGzYCAA8LQdTzigEgADYCAEHM84oBQczzigEoAgAgAWoiATYCACAAIAFBAXI2AgRB0POKASgCACAARgRAQcjzigFBADYCAEHQ84oBQQA2AgALIAFB4POKASgCAE0NAEHU84oBKAIAIgJFDQBBACEAAkBBzPOKASgCAEEpSQ0AQajxigEhAQNAIAIgASgCAE8EQCABEK47IAJLDQILIAEoAggiAQ0ACwtBsPGKASgCACIBBEADQCAAQQFqIQAgASgCCCIBDQALC0Ho84oBQf8fIAAgAEH/H00bNgIAQczzigEoAgBB4POKASgCAE0NAEHg84oBQX82AgALDwsCf0HA84oBKAIAIgJBASABQQN2dCIDcUUEQEHA84oBIAIgA3I2AgAgAUH4AXFBuPGKAWoiAQwBCyABQfgBcSICQbjxigFqIQEgAkHA8YoBaigCAAshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggPC0HQ84oBIAA2AgBByPOKAUHI84oBKAIAIAFqIgE2AgAgACABENA0C+YEAgR/AX4jAEGAAWsiBCQAIAQgAzYCDCAEIAI2AgggBEFAayIDIAEQzgYCQEEMQQQQrTYiAgRAIAIgBCkCQDcCACACQQhqIARByABqIgUoAgA2AgAgAyAEQQhqIgYQ8y0QzgZBDEEEEK02IgNFDQEgAyAEKQJANwIAIANBCGogBSgCADYCACAEIAM2AhggBCACNgIUIARBIjoAECAEIAYQ9C0iBjYCHAJAAkAgASgCFCICQQhPBEAgAUEMaiEHIAEoAhAhAyACQXhxIQVBACECA0AgAygCACAGTwRAIAEgAhCLOw0DCyADQQhqIQMgAkEBaiECIAVBCGsiBQ0ACwsgBEHIAGogBEEYaigCADYCACAEIAQpAhA3A0AgBEHMAGogAUEw/AoAACAEKQIIIQggACAEQUBrQTz8CgAAIABBADoARCAAIAg3AjwMAQsgBCACNgIgIAQgAzYCJCAEQQM2AiwgBEGsgoQBNgIoIARCAzcCNCAEQTs2AlQgBEE7NgJMIARBuhM2AkQgBCAEQUBrNgIwIAQgBEEcajYCUCAEIARBIGo2AkggBCAEQSRqNgJAIABBBGogBEEoahCZDiAAQQI6AEQgAEGNgICAeDYCACAEQRBqELwMIAQoAggiACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBCGoQuyMLIAEQvAwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBxD7HgsgASgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPseCyAEQYABaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvmBAIEfwF+IwBBgAFrIgQkACAEIAM2AgwgBCACNgIIIARBQGsiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAkA3AgAgAkEIaiAEQcgAaiIFKAIANgIAIAMgBEEIaiIGEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCQDcCACADQQhqIAUoAgA2AgAgBCADNgIYIAQgAjYCFCAEQSI6ABAgBCAGEPQtIgY2AhwCQAJAIAEoAhQiAkEETwRAIAFBDGohByABKAIQIQMgAkF8cSEFQQAhAgNAIAYgAygCAE0EQCABIAIQizsNAwsgA0EEaiEDIAJBAWohAiAFQQRrIgUNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEIIAAgBEFAa0E8/AoAACAAQQA6AEQgACAINwI8DAELIAQgAjYCICAEIAM2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQbsTNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAcQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL5gQCBH8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBAk8EQCABQQxqIQcgASgCECEDIAJBfnEhBUEAIQIDQCADLwEAIAZPBEAgASACEIs7DQMLIANBAmohAyACQQFqIQIgBUECayIFDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCCAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCDcCPAwBCyAEIAI2AiAgBCADNgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEH4FzYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAHEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC4EFAQl/IwBBQGoiAyQAIAMgAiABayIEQQR2Igc2AhAgA0EUaiAHQQdqQQN2ENIfQcAAIQUCQAJAIARBAXYiCkHA////B3FBQGsgCiAEQf4AcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAhwhCSAFIQQgASACRg0CA0ACQCABKAIABEAgBCABQQhqKQMANwMAIAkgBkEDdmoiCyALLQAAQQEgBkEHcXRyOgAADAELIARCADcDAAsgBkEBaiEGIARBCGohBCABQRBqIgEgAkcNAAsMAgtBrMH/AEEpIANBKGpBxMj/AEHYwf8AENUeAAtBwAAgCBCjPQALIAMgBCAFa0EDdSIBNgIkAkACQCABIAdGBEAgAygCICEEIAMgAykCFDcCNCADQQA2AjAgAyAENgIsIAMgCTYCKCADQQhqIANBKGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAig3AgggAUEQaiADQTBqIgcpAgA3AgAgAUEYaiADQThqIgkoAgA2AgAgAyAINgI4IANCgICAgIAINwIwIAMgCjYCLCADIAU2AiggAyACENc7IAMoAgAhBUEcQQQQrTYiAkUNAiACQoGAgIAQNwIAIAIgAykCKDcCCCACQRBqIAcpAgA3AgAgAkEYaiAJKAIANgIAIAAgCjYCFCAAIAU2AhAgACACNgIMIAAgBDYCCCAAIAY2AgQgACABNgIAIANBQGskAA8LIANCADcCNCADQoGAgIDAADcCLCADQcC7/wA2AihBACADQSRqIANBEGogA0EoakHIu/8AEK8rAAtBBEEcEKM9AAtBBEEcEKM9AAuBBQEJfyMAQUBqIgMkACADIAIgAWsiBEEEdiIHNgIQIANBFGogB0EHakEDdhDSH0HAACEFAkACQCAEQQF2IgpBwP///wdxQUBrIAogBEH+AHEbIghBwAAQ0TQEQCAIBEAgCEHAABCtNiIFRQ0CCyADKAIcIQkgBSEEIAEgAkYNAgNAAkAgASgCAARAIAQgAUEIaikDADcDACAJIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwALIAZBAWohBiAEQQhqIQQgAUEQaiIBIAJHDQALDAILQfz2/wBBKSADQShqQfj6/wBBqPf/ABDVHgALQcAAIAgQoz0ACyADIAQgBWtBA3UiATYCJAJAAkAgASAHRgRAIAMoAiAhBCADIAMpAhQ3AjQgA0EANgIwIAMgBDYCLCADIAk2AiggA0EIaiADQShqIgIQ1zsgAygCCCEGQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASADKQIoNwIIIAFBEGogA0EwaiIHKQIANwIAIAFBGGogA0E4aiIJKAIANgIAIAMgCDYCOCADQoCAgICACDcCMCADIAo2AiwgAyAFNgIoIAMgAhDXOyADKAIAIQVBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAMpAig3AgggAkEQaiAHKQIANwIAIAJBGGogCSgCADYCACAAIAo2AhQgACAFNgIQIAAgAjYCDCAAIAQ2AgggACAGNgIEIAAgATYCACADQUBrJAAPCyADQgA3AjQgA0KBgICAwAA3AiwgA0GU8v8ANgIoQQAgA0EkaiADQRBqIANBKGpBnPL/ABCvKwALQQRBHBCjPQALQQRBHBCjPQAL4gQBBn8jAEHgAGsiAyQAAkAgAigCECIIRQRAIABBCDYCAAwBCyABQZQBaiEEIAEoApQBQYCAgIB4RgRAIANByABqIAFB8ABqIAEoAigQuhQgA0EQaiIFIANB1ABqKQIANwMAIANBGGoiBiADQdwAaigCADYCACADIAMpAkw3AwggAygCSCIHQQhHBEAgACADKQMINwIEIAAgBzYCACAAQRRqIAYoAgA2AgAgAEEMaiAFKQMANwIADAILIAQoAgBBgICAgHhHBEAgBBDvKwsgBCADKQMINwIAIARBEGogA0EYaigCADYCACAEQQhqIANBEGopAwA3AgALIAEoAqwBIgUgASgCpAEiBiAIak8EQCADQcgAaiAEIAIQtwogAygCSCICQQhHBEAgACADKQJMNwIEIABBFGogA0HcAGooAgA2AgAgAEEMaiADQdQAaikCADcCACAAIAI2AgAMAgsCQCABKAKkASABKAKsAUkNACADQcgAaiABEP8GIAMoAkgiAUEIRg0AIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACABNgIADAILIABBCDYCAAwBCyADQSBqIgcgAkEAIAUgBmsiBBDOFiADQTRqIAIgBCAIIARrEM4WIANByABqIAEgBxD2CQJAIAMoAkgiAkEIRwRAIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACACNgIADAELIAAgASADQTRqEPYJCyADQTRqEOkrIANBIGoQ6SsLIANB4ABqJAAL4gQBBn8jAEHgAGsiAyQAAkAgAigCECIIRQRAIABBCDYCAAwBCyABQYwBaiEEIAEoAowBQYCAgIB4RgRAIANByABqIAFB6ABqIAEoAiAQuhQgA0EQaiIFIANB1ABqKQIANwMAIANBGGoiBiADQdwAaigCADYCACADIAMpAkw3AwggAygCSCIHQQhHBEAgACADKQMINwIEIAAgBzYCACAAQRRqIAYoAgA2AgAgAEEMaiAFKQMANwIADAILIAQoAgBBgICAgHhHBEAgBBDvKwsgBCADKQMINwIAIARBEGogA0EYaigCADYCACAEQQhqIANBEGopAwA3AgALIAEoAqQBIgUgASgCnAEiBiAIak8EQCADQcgAaiAEIAIQtwogAygCSCICQQhHBEAgACADKQJMNwIEIABBFGogA0HcAGooAgA2AgAgAEEMaiADQdQAaikCADcCACAAIAI2AgAMAgsCQCABKAKcASABKAKkAUkNACADQcgAaiABEP4GIAMoAkgiAUEIRg0AIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACABNgIADAILIABBCDYCAAwBCyADQSBqIgcgAkEAIAUgBmsiBBDOFiADQTRqIAIgBCAIIARrEM4WIANByABqIAEgBxD3CQJAIAMoAkgiAkEIRwRAIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACACNgIADAELIAAgASADQTRqEPcJCyADQTRqEOkrIANBIGoQ6SsLIANB4ABqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCXDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJcNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJcNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQlw0LIA5B0AJqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCWDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJYNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJYNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQlg0LIA5B0AJqJAALhQoCE38CfiMAQdACayISJAACQCABQQJJDQBCgICAgICAgIDAACABrSIZgCIaIBl+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEUIBp8IRkgEkGNAmohF0EBIQoDQEEBIQtBACEVIAEgD0sEQCAPrSIaAn8gACAPQQJ0aiEIAkAgASAPayILIBRJDQACQCALQQJJBEAgCyEGDAELAn8CQAJAIAgoAgRBGHYgCCgCAEEYdkkiCUUEQEECIQYgC0ECRg0EIAhBBGohBwNAIAdBB2otAAAgBy0AA0kNAyAHQQRqIQcgCyAGQQFqIgZHDQALDAELQQIhBkEBIAtBAkYNAhogCEEEaiEHA0AgB0EHai0AACAHLQADTw0CIAdBBGohByALIAZBAWoiBkcNAAsLIAshBgsgBiAUSQ0CIAlFDQEgBkECSQRAQQEhBgwCCyAGQQF2CyEHIAZBAnQgCGpBBGshCwNAIAgoAgAhCSAIIAsoAgA2AgAgCyAJNgIAIAtBBGshCyAIQQRqIQggB0EBayIHDQALCyAGQQF0QQFyDAELIAsgFCALIBRJG0EBdCAERQ0AGiAIQSAgCyALQSBPGyIGIAIgA0EAQQAgBRCFDSAGQQF0QQFyCyILQQF2IA9qrXwgGX4gDyAKQQF2a60gGnwgGX6FeachFQsCQAJAIBFBAkkNACASIBFBAnRqIRYDQCARIBdqLQAAIBVJDQECfyADIBYoAgAiCEEBdiIJIApBAXYiDmoiBk8gCCAKckEBcUVxRQRAIAAgDyAGa0ECdGohByAIQQFxRQRAIAcgCSACIAMgCUEBcmdBAXRBPnNBACAFEIUNCyAKQQFxRQRAIAcgCUECdGogDiACIAMgDkEBcmdBAXRBPnNBACAFEIUNCyAHIQogAiEHIwBBEGsiDiQAAkAgCUUgBiAJTXINACADIAYgCWsiECAJIAkgEEsiDBsiDUkNACAKIAlBAnRqIgggCiAMGyEMIA1BAnQiDQRAIAcgDCAN/AoAAAsgDiAMNgIMIA4gByANaiIMNgIIIA4gBzYCBAJAIAkgEEsEQCAGQQJ0IApqQQRrIQkDQCAJIAhBBGsiCCgCACIQIAxBBGsiDCgCACINIA1BGHYiDSAQQRh2IhBJIhMbNgIAIAwgE0ECdGohDCAIIA0gEE9BAnRqIgggCkYNAiAJQQRrIQkgByAMRw0ACwwBCyAOQQRqIQcCQCAKIAZBAnRqIgwgCEYNACAHKAIAIgogBygCBCIQRg0AIAcoAgghCQNAAkAgCSAIKAIAIg0gCigCACITIA1BGHYiDSATQRh2IhNJIhgbNgIAIAlBBGohCSAKIA0gE09BAnRqIgogEEYNACAIIBhBAnRqIgggDEcNAQsLIAcgCTYCCCAHIAo2AgALIA4oAgwhCCAOKAIEIQcgDigCCCEMCyAMIAdrIgpFDQAgCCAHIAr8CgAACyAOQRBqJAAgBkEBdEEBcgwBCyAGQQF0CyEKIBZBBGshFkEBIQYgEUEBayIRQQFLDQALDAELIBEhBgsgEkGOAmogBmogFToAACASQQRqIAZBAnRqIAo2AgAgASAPSwRAIAZBAWohESALQQF2IA9qIQ8gCyEKDAELCyAKQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQhQ0LIBJB0AJqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCYDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJgNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJgNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQmA0LIA5B0AJqJAALrgQCCH8IfiMAQfAAayIGJAAgACABIANqEIUtIAYgBCAFEOAcIAZCADcDaCAGIAEgAmoiAiIDNgJkIAYgATYCYAJAAkACQCABIANPDQAgAkEBdEECayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQF0aiADIAVqLwEAOwEAIAVBAmshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAuuBAIIfwh+IwBB8ABrIgYkACAAIAEgA2oQhi0gBiAEIAUQ4BwgBkIANwNoIAYgASACaiICIgM2AmQgBiABNgJgAkACQAJAIAEgA08NACACQQJ0QQRrIQUgBigCWCEKIAYpAyAhECAGKAJUIQggBigCUCEHIAYpA0AhDiAGKQMwIREgBigCECELIAYpAwghDyAGKAIoIQwgBigCGCENIAYpA0ghEyAGKQM4IRQgBikDACESA0AgEqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIA9QRQ0BQgAhD0IAIRJBASECDAQLAn4CQCARQgJ9IhVCAVgEQCAVp0EBaw0BDAULIBGnIBFQrUIBhiERQQFxRQ0AIBQMAQsgDkIDUQRAQgMhDgwECyAHRSAHIAhGckUEQCAIQQhrIggpAwAMAQtBACEHIA5CAlEEQEICIQ4MBAsgDqdCACEOQQFxRQ0DIBMLIQ9CASESIApBQGoiCiELDAELIAsgD3mnQT9zIgRqIQJCASAErYYgD4UhDwwDC0EAIQIMAQsLIA0gEEIAUnFFDQIgDCAQeadBP3MiBGohAkIBIASthiAQhSEQCyACIANBAWsiBE0NASAEIAAoAggiCU8NAiACIAlPDQMgACgCBCIDIAJBAnRqIAMgBWooAgA2AgAgBUEEayEFIAQiAyABSw0ACwsgBkHwAGokAA8LIANBAWsgCUGwms8AEMMhAAsgAiAJQcCazwAQwyEAC64EAgh/CH4jAEHwAGsiBiQAIAAgASADahCHLSAGIAQgBRDgHCAGQgA3A2ggBiABIAJqIgIiAzYCZCAGIAE2AmACQAJAAkAgASADTw0AIAJBA3RBCGshBSAGKAJYIQogBikDICEQIAYoAlQhCCAGKAJQIQcgBikDQCEOIAYpAzAhESAGKAIQIQsgBikDCCEPIAYoAighDCAGKAIYIQ0gBikDSCETIAYpAzghFCAGKQMAIRIDQCASp0EBcQR/QQAFQQELIQICQANAAkACQAJAIAJFBEAgD1BFDQFCACEPQgAhEkEBIQIMBAsCfgJAIBFCAn0iFUIBWARAIBWnQQFrDQEMBQsgEacgEVCtQgGGIRFBAXFFDQAgFAwBCyAOQgNRBEBCAyEODAQLIAdFIAcgCEZyRQRAIAhBCGsiCCkDAAwBC0EAIQcgDkICUQRAQgIhDgwECyAOp0IAIQ5BAXFFDQMgEwshD0IBIRIgCkFAaiIKIQsMAQsgCyAPeadBP3MiBGohAkIBIASthiAPhSEPDAMLQQAhAgwBCwsgDSAQQgBScUUNAiAMIBB5p0E/cyIEaiECQgEgBK2GIBCFIRALIAIgA0EBayIETQ0BIAQgACgCCCIJTw0CIAIgCU8NAyAAKAIEIgMgAkEDdGogAyAFaikDADcDACAFQQhrIQUgBCIDIAFLDQALCyAGQfAAaiQADwsgA0EBayAJQbCazwAQwyEACyACIAlBwJrPABDDIQALrgQCCH8IfiMAQfAAayIGJAAgACABIANqEJUtIAYgBCAFEOAcIAZCADcDaCAGIAEgAmoiAiIDNgJkIAYgATYCYAJAAkACQCABIANPDQAgAkECdEEEayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQJ0aiADIAVqKAIANgIAIAVBBGshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAuaCQITfwJ+IwBB0AJrIhIkAAJAIAFBAkkNAEKAgICAgICAgMAAIAGtIhmAIhogGX5CgICAgICAgIDAAFKtAn8gAUGBIE8EQCABEJYsDAELQcAAIAEgAUEBdmsiBiAGQcAATxsLIRUgGnwhGiASQY0CaiEYQQEhCQNAQQEhCkEAIRYgASAMSwRAIAytIhkCfyAAIAxBDGxqIQcCQCABIAxrIgYgFUkNAAJAIAZBAkkEQCAGIQoMAQsCfwJAAkAgBygCDCINIAcoAgBJIgtFBEBBAiEKIAZBAkYNBCAHQRhqIQgDQCANIAgoAgAiDUsNAyAIQQxqIQggBiAKQQFqIgpHDQALDAELQQIhCkEBIAZBAkYNAhogB0EYaiEIA0AgDSAIKAIAIg1NDQIgCEEMaiEIIAYgCkEBaiIKRw0ACwsgBiEKCyAKIBVJDQIgC0UNASAKQQJJBEBBASEKDAILIApBAXYLIQggCkEMbCAHakEMayEGA0AgByAGQQMQ+iogBkEMayEGIAdBDGohByAIQQFrIggNAAsLIApBAXRBAXIMAQsgBiAVIAYgFUkbQQF0IARFDQAaIAdBICAGIAZBIE8bIgYgAiADQQBBACAFEIMNIAZBAXRBAXILIgpBAXYgDGqtfCAafiAMIAlBAXZrrSAZfCAafoV5pyEWCwJAAkAgEUECSQ0AIBIgEUECdGohFwNAIBEgGGotAAAgFkkNAQJ/IAMgFygCACIIQQF2IgsgCUEBdiIHaiINTyAIIAlyQQFxRXFFBEAgACAMIA1rQQxsaiEGIAhBAXFFBEAgBiALIAIgAyALQQFyZ0EBdEE+c0EAIAUQgw0LIAlBAXFFBEAgBiALQQxsaiAHIAIgAyAHQQFyZ0EBdEE+c0EAIAUQgw0LIAIhCAJAIAtFIAsgDSIJT3INACADIAkgC2siDiALIAsgDksiExsiD0kNACAGIAtBDGxqIQcgD0EMbCIQBEAgCCAHIAYgExsgEPwKAAALIAggEGohFAJAAkAgCyAOSwRAIAlBDGwgBmpBDGshDgNAIA4gB0EMayIPIBRBDGsiECAQKAIAIhMgDygCACIHSSILGyIJKQIANwIAIA5BCGogCUEIaigCADYCACAQIAtBDGxqIRQgDyAHIBNNQQxsaiIHIAZGDQIgDkEMayEOIAggFEcNAAsMAQsgD0UNASAGIAlBDGxqIQ8DQCAGIAcgCCAHKAIAIhAgCCgCACITSSILGyIJKQIANwIAIAZBCGogCUEIaigCADYCACAGQQxqIQYgCCAQIBNPQQxsaiIIIBRGDQIgByALQQxsaiIHIA9HDQALDAELIAchBgsgFCAIayIJRQ0AIAYgCCAJ/AoAAAsgDUEBdEEBcgwBCyANQQF0CyEJIBdBBGshF0EBIQYgEUEBayIRQQFLDQALDAELIBEhBgsgEkGOAmogBmogFjoAACASQQRqIAZBAnRqIAk2AgAgASAMSwRAIAZBAWohESAKQQF2IAxqIQwgCiEJDAELCyAJQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQgw0LIBJB0AJqJAAL0wsCE38CfiMAQdACayIUJAACQCABQQJJDQBCgICAgICAgIDAACABrSIZgCIaIBl+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgogCkHAAE8bCyEVIBp8IRkgFEGNAmohF0EBIQsDQEEBIQpBACERIAEgEksEQCASrSIaAn8gACASQQJ0aiEPAkAgASASayIGIBVJDQACQCAGQQJJBEAgBiEJDAELAn8CQAJAIA8oAgQiBygCBCIKIA8oAgAiCSgCBCAHKAIIIgcgCSgCCCIJIAcgCUkbEJknIgggByAJayAIGyIOQQBOBEBBAiEJIAZBAkYNBCAPQQhqIQwDQCAMKAIAIhEoAgQiCCAKIBEoAggiCiAHIAcgCksbEJknIhEgCiAHayARG0EASA0DIAxBBGohDCAKIQcgCCEKIAYgCUEBaiIJRw0ACwwBC0ECIQlBASAGQQJGDQIaIA9BCGohDANAIAwoAgAiESgCBCIIIAogESgCCCIKIAcgByAKSxsQmSciESAKIAdrIBEbQQBODQIgDEEEaiEMIAohByAIIQogBiAJQQFqIglHDQALCyAGIQkLIAkgFUkNAiAOQQBODQEgCUECSQRAQQEhCQwCCyAJQQF2CyEGIAlBAnQgD2pBBGshBwNAIA8oAgAhCiAPIAcoAgA2AgAgByAKNgIAIAdBBGshByAPQQRqIQ8gBkEBayIGDQALCyAJQQF0QQFyDAELIAYgFSAGIBVJG0EBdCAERQ0AGiAPQSAgBiAGQSBPGyIKIAIgA0EAQQAgBRDvCSAKQQF0QQFyCyIKQQF2IBJqrXwgGX4gEiALQQF2a60gGnwgGX6FeachEQsCQAJAIBNBAkkNACAUIBNBAnRqIQ8DQCATIBdqLQAAIBFJDQECfyADIA8oAgAiBkEBdiIIIAtBAXYiDGoiCU8gBiALckEBcUVxRQRAIAAgEiAJa0ECdGohByAGQQFxRQRAIAcgCCACIAMgCEEBcmdBAXRBPnNBACAFEO8JCyALQQFxRQRAIAcgCEECdGogDCACIAMgDEEBcmdBAXRBPnNBACAFEO8JCyMAQRBrIgwkAAJAIAhFIAggCU9yDQAgAyAJIAhrIg4gCCAIIA5LIgYbIg1JDQAgByAIQQJ0aiILIAcgBhshBiANQQJ0Ig0EQCACIAYgDfwKAAALIAwgBjYCDCAMIAIgDWo2AgggDCACNgIEIAcgCUECdGohBgJAIAggDksEQCAGQQRrIQsgDEEEaiIIKAIEIQYgCCgCCCEOA0ACQCALIAZBBGsiBiAOQQRrIg4gBigCACINKAIEIA4oAgAiECgCBCANKAIIIg0gECgCCCIQIA0gEEkbEJknIhYgDSAQayAWGyINQQBOIhAbKAIANgIAIAYgDUEddkEEcWohBiAOIBBBAnRqIg4gB0YNACALQQRrIQsgAiAGRw0BCwsgCCAGNgIEIAggDjYCCAwBCyAMQQRqIQgCQCAGIAsiB0YNACAIKAIAIgsgCCgCBCIWRg0AIAgoAgghDgNAAkAgDiALIAcgBygCACINKAIEIAsoAgAiECgCBCANKAIIIg0gECgCCCIQIA0gEEkbEJknIhggDSAQayAYGyINQQBOIhAbKAIANgIAIA5BBGohDiALIBBBAnRqIgsgFkYNACAHIA1BHXZBBHFqIgcgBkcNAQsLIAggDjYCCCAIIAs2AgALCyAMKAIIIAwoAgQiB2siBkUNACAMKAIMIAcgBvwKAAALIAxBEGokACAJQQF0QQFyDAELIAlBAXQLIQsgD0EEayEPQQEhBiATQQFrIhNBAUsNAAsMAQsgEyEGCyAUQY4CaiAGaiAROgAAIBRBBGogBkECdGogCzYCACABIBJLBEAgBkEBaiETIApBAXYgEmohEiAKIQsMAQsLIAtBAXENACAAIAEgAiADIAFBAXJnQQF0QT5zQQAgBRDvCQsgFEHQAmokAAuJBgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDg0BAgMEBQYHCAkKCwwNAAsgAiAAQRBqNgIMIAFB9LPNAEEGQfqzzQBBBSAAQQhqQdSzzQBB/7PNAEEDIAJBDGpB5LPNABCOGAwNCyACIABBEGo2AgwgAUGCtM0AQQ5B+rPNAEEFIABBCGpB1LPNAEGQtM0AQQMgAkEMakHks80AEI4YDAwLIAFBk7TNAEEFEPs1DAsLIAFBmLTNAEEGEPs1DAoLIAIgAEEQajYCDCABQZ60zQBBDkGstM0AQQwgAEEIakHUs80AQbi0zQBBByACQQxqQeSzzQAQjhgMCQsgAiAAQRhqNgIMIAFBv7TNAEEHQca0zQBBAyAAQQhqQdSzzQBBybTNAEEHIABBEGpB1LPNAEHQtM0AQQcgAkEMakHks80AEIkXDAgLIAIgAEEQajYCDCABQde0zQBBCEHGtM0AQQMgAEEIakHUs80AQcm0zQBBByACQQxqQeSzzQAQjhgMBwsgAiAAQRBqNgIMIAFB37TNAEEJQca0zQBBAyAAQQhqQdSzzQBB0LTNAEEHIAJBDGpB5LPNABCOGAwGCyACIABBEGo2AgwgAUHotM0AQQZB7rTNAEEGIABBCGpB1LPNAEH0tM0AQQcgAkEMakHks80AEI4YDAULIAIgAEEBajYCDCABQYy1zQBBDEGYtc0AQQQgAkEMakH8tM0AEPYYDAQLIAIgAEEEajYCDCABQay1zQBBFEHAtc0AQQUgAkEMakGctc0AEPYYDAMLIAIgAEEBajYCDCABQcW1zQBBFEGYtc0AQQQgAkEMakH8tM0AEPYYDAILIAIgAEEBajYCDCABQey1zQBBFkHGtM0AQQMgAEEIakHUs80AQYK2zQBBBiACQQxqQdy1zQAQjhgMAQsgAiAAQQhqNgIMIAFBqLbNAEEIQbC2zQBBCCAAQQRqQYi2zQBBuLbNAEEDIAJBDGpBmLbNABCOGAsgAkEQaiQAC4kOAQt/IwBBkA9rIgwkACAMQQY2AhggDEEANgIcIAxBIGpBAEGQAvwLACAMQbACakEAQaAE/AsAIARBAWutIAcgCCAJEJUjIARBAUcEQCABIQogAiEOAn8gA0UEQCAMQQhqEP4nIAwoAgwhCyAMKAIIDAELIAxBEGogACADELkpIAwoAhQhCyAMKAIQCyEAIwBBgAJrIhAkACAQQQBBgAL8CwACQAJAAkACQAJAIAMEQAJAIA4EQCAKKAIAIQICQCADQQFHBEAgDkEBayADQQJrTQ0BIApBBGohASADQQFrIQ0DQCABKAIAIg8gAiACIA9JGyECIAFBBGohASANQQFrIg0NAAsLQQAhAQNAIAFBgAJJBEAgASAQaiABOgAAIAEgAk8NBCABIAEgAklqIgEgAk0NAQwECwsgAUGAAkGc69EAEMMhAAsgDiAOQazr0QAQwyEAC0EAQQBB7OrRABDDIQALIAJBAWohDSAQQQFqIRFBACECA0AgAiIPIA5GDQQgAkEBaiECQQAhASAKIA9BAnQiEmooAgBB/wFxIRMCQANAIAFBgAJGDQUgASAQai0AACATRg0BIA0gAUEBaiIBRw0ACyANIQELIAsgD0YNAiAAIBJqIAE2AgAgAUH/AUsNBSABIBBqLQAAIQ8gAQRAIBEgECAB/AoAAAsgECAPOgAAIAIgA0cNAAsLIBBBgAJqJAAMBAsgCyALQYzr0QAQwyEAC0GAAkGAAkHM6tEAEMMhAAsgDiAOQfzq0QAQwyEACyABQYACQdzq0QAQwyEACyAMQRxqIRAgDEEYaiEOQQAhCkEAIQECQCADRQ0AQQAgA2shDwJAA0AgAyAKQQFqIgIgAiADSRshESAKIAsgCiALSxshDSAAIApBAnRqIQICQAJ/AkAgAQJ/AkADQCAKIA1GDQcgAigCAEUNASACQQRqIQIgESAKQQFqIgpHDQALQQAMAQtBACADIApNDQIaIAogD2ohESAKIAogCyAKIAtLGyISayETQQAhDQNAIA0gE0YNBCACKAIADQIgAkEEaiECIBEgDUEBayINRw0ACyADIAprCyICIAEgAksbIQEMBQsgCiANayEKQQAgDWsLIQIgASACIAEgAksbIQEgAyAKSw0BDAMLCyASIAtBnOzRABDDIQALIA0gC0GM7NEAEMMhAAsgEEEANgIAIA4gDigCACICIAFnQR9zIg4gAiAOSRtBACABQQJPGyIPNgIAIAMEQCAAQQRqIRJBAiAPdCERQX8gD3RBf3NBCXQgD3IhE0EAIQFBACEKA0ACQAJAAkACfwJAAkAgASALSQRAIAAgAUECdCINaigCACICRQRAQQEhAiABQQFqIg4gA08NAyALIAFrIRQgAyABayEOIA0gEmohDQNAAkAgAiAURwRAIA0oAgBFDQEMBQsgCyALQczr0QAQwyEACyANQQRqIQ0gDiACQQFqIgJHDQALIA4hAgwCCyAKIAtJBEAgACAKQQJ0aiACIA9qNgIAIAFBAWoMBAsgCiALQfzr0QAQwyEACyABIAtBvOvRABDDIQALIAEgAmohDiACRQ0DCyAKIAsgCiALSxshASAAIApBAnRqIQ0CQANAIAIgEUkNASABIApHBEAgDSATNgIAIBAgCkEBaiIKNgIAIA1BBGohDSACIBFrQQFqIgJFDQUMAQsLIAEgC0Hc69EAEMMhAAsgCiALTw0BIA1BfyACZ0Efc0EAIAJBAUcbIgF0IAJqQQl0IAFyNgIAIA4LIQEgECAKQQFqIgo2AgAMAgsgCiALQezr0QAQwyEACyAOIQELIAEgA0kNAAsLIAxB0AZqQQBBwAj8CwACQAJAAkACQCAMKAIcIg4EQEEAIQMgACECA0AgAyALRg0CIAIoAgBB/wNxIgFBkAJPDQMgDEHQBmogAUECdGoiASABKAIAQQFqNgIAIAJBBGohAiAOIANBAWoiA0cNAAsLQQEgDCgCGCIBQQBHrSAHIAggCRDlEiABDQIMAwsgCyALQcil0AAQwyEACyABQZACQdil0AAQwyEAC0EEIAwoAhhBAWutIAcgCCAJEOUSCyAMQdAGakGQAiAMKAIYIARqIgEgASAFIAYgDEEgakGQAiAMQbACakGQAiAHIAggCRDyCCAMKAIcIgUEQEEAIQIgACEBA0AgAiALRgRAIAsgC0GopdAAEMMhAAsCQCABKAIAIgRB/wNxIgNBjwJNBEAgDEEgaiADai0AACAMQbACaiADQQF0ajMBACAHIAggCRDlEiAMKAIYIANBAWtNDQEgBCAEQQl2rSAHIAggCRDlEgwBCyADQZACQbil0AAQwyEACyABQQRqIQEgBSACQQFqIgJHDQALC0EBQgEgByAIIAkQ5RIgACALEIAxCyAMQZAPaiQAC98EAgZ/AX4jAEGAAWsiBCQAIAQgAzYCDCAEIAI2AgggBEFAayIDIAEQzgYCQEEMQQQQrTYiAgRAIAIgBCkCQDcCACACQQhqIARByABqIgUoAgA2AgAgAyAEQQhqIgYQ8y0QzgZBDEEEEK02IgNFDQEgAyAEKQJANwIAIANBCGogBSgCADYCACAEIAM2AhggBCACNgIUIARBIjoAECAEIAYQ9C0iAjYCHAJAAkAgASgCFCIFBEAgAUEMaiEGIAEoAhAhB0EAIQMDQCADIAdqIggsAAAiCUEATiACIAlLcUUEQCABIAMQizsNAwsgBSADQQFqIgNHDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCiAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCjcCPAwBCyAEIAM2AiAgBCAINgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEGRCjYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAGEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC/sHAQl/IAFB1ABqIQYCQAJAA0ACQAJ/AkAgASgCWCIIQQRJDQAgBigCACIFLAAAIgJB/wFxIQMgAkEATgRAIAEgCEEBazYCWCABIAVBAWo2AlQMAwsgBS0AASEEIAJBPmpB/wFxQR1NBEAgBMAiAkFATg0BIAEgCEECazYCWCABIAVBAmo2AlQgA0EGdEHAD3EgAkE/cXIhAwwDCyAFLQACIQcCQCACQW9NBEAgA0GAgMYAai0AACAEQYD/xQBqLQAAcSAHQQZ2ckECRg0BDAILIANBgIDGAGotAAAgBEGA/8UAai0AAHEgB0EGdnIgBS0AAyICQcABcUECdHJBggRHDQEgASAIQQRrNgJYIAEgBUEEajYCVCACQT9xIAdBBnRBwB9xIARBDHRBgOAPcSADQRJ0QYCA8ABxcnJyDAILIAEgCEEDazYCWCABIAVBA2o2AlQgB0E/cSAEQQZ0QcAfcSADQQx0QYDgA3FyciEDDAILAn9BgIDEACAGKAIEIglFDQAaIAYoAgAiCiwAACIHQf8BcSEEAkACQCAHQQBIBEAgCUEBRyAHQQtqQf8BcUHNAU9xRQRAIAYgCUEBazYCBCAGIApBAWo2AgAMAwsgCi0AASEDQYABIQJBvwEhBQJAAkACQAJAIARB8AFrDgUBAwMDAgALIARB7QFHBEAgBEHgAUcNA0GgASECDAMLQZ8BIQUMAgtBkAEhAgwBC0GPASEFCyADIAJrQf8BcSAFIAJrQf8BcUsEQCAGIApBAWo2AgAgBiAJQQFrNgIEDAMLIApBAmohAiAHQWBJDQEgCUECRgRAIAZBADYCBCAGIAI2AgAMAwsgAiwAACIFQUBOBEAgBiACNgIAIAYgCUECazYCBAwDCyAGIAlBA2s2AgQgBiAKQQNqNgIAIAdBb0sNAiAFQT9xIANBBnRBwB9xIARBDHRBgOADcXJyDAMLIAYgCUEBazYCBCAGIApBAWo2AgAgBAwCCyAGIAI2AgAgBiAJQQJrNgIEIARBBnRBwA9xIANBP3FyDAELQf3/AwsLIQNBgIDEACEFIANBgIDEAEYNAwsgASgChAEgA0sEQEEAIQgMAgsCf0H/H0H//wMgASgCXCIELQAsGyADTwRAIANBBnYiAiAEKAIISQRAIAQoAgQgAkEBdGovAAAgA0E/cWoMAgsgBCgCFEEBawwBCyAEIAMQwC4LIgcgBCgCFCICSQR/IAQoAhAgB0ECdGooAAAFIAULIAQoAgAgAiAHSxsiCEF/Rw0BIAEtAIgBIgJBAUYNAAtBfyEIIAMhBQJAAkAgAkEBaw4CAAEDCwALQf3/g4AEIQgLIAMhBQsgACAINgIEIAAgBTYCAAvvBgIIfgJ/IwBBIGsiCiQAIApCADcDECAKQvnq0NDnyaHk4QA3AxggCkLP1tO+0ser2UI3AwggCkLW64Lu6v2J9eAANwMAQsXP2bLx5brqJyECAkAgAUEgSQRAIAEhCwwBCyAKKQMYIQIgCikDECEDIAopAwghBCAKKQMAIQUgASELA0AgACkAAELP1tO+0ser2UJ+IAV8Qh+JIgZCh5Wvr5i23puef34hBSAAQRhqKQAAQs/W077Sx6vZQn4gAnxCH4kiB0KHla+vmLbem55/fiECIABBEGopAABCz9bTvtLHq9lCfiADfEIfiSIIQoeVr6+Ytt6bnn9+IQMgAEEIaikAAELP1tO+0ser2UJ+IAR8Qh+JIglCh5Wvr5i23puef34hBCAAQSBqIQAgC0EgayILQR9LDQALIAogBTcDACAKIAQ3AwggCiADNwMQIAogAjcDGCAEQgeJIAVCAYl8IANCDIl8IAJCEol8IAZCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCUKp2eX7kODW+V5+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAIQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAdCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0hAgsgAiABrXwhAgJAIAtBCEkEQCAAIQEMAQsDQCAAKQAAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef34gAoVCG4lCh5Wvr5i23puef35CnaO16oOxjYr6AH0hAiAAQQhqIgEhACALQQhrIgtBB0sNAAsLIAtBA00EfyABBSALQQRrIQsgATUAAEKHla+vmLbem55/fiAChUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqCyEAIAsEQANAIAAxAABC/wGDQsXP2bLx5brqJ34gAoVCC4lCh5Wvr5i23puef34hAiAAQQFqIQAgC0EBayILDQALCyAKQSBqJAAgAkIhiCAChULP1tO+0ser2UJ+IgJCHYggAoVC+fPd8Zn2masWfiICQiCIIAKFC5gSAQZ/IwBBoAFrIggkAAJAAkACQAJAIARBAXEEQCAIIAU2AgwgCEFAayIEIAMQyi8gCEEQaiIDIAhBDGogBBDwLSAGRQ0BIAhBADoAhAEgCEIENwJ8IAggBzYCeCAIIAY2AnQgCEGIAWogAyAIKAIcELURIAgoAogBIQkgCCAIKQKMATcCmAEgCEEBNgKUASMAQSBrIgUkACAFQQA2AgggBUKAgICAEDcCACAFQez3gAE2AhAgBUKggICADjcCFCAFIAU2AgwgBUEMaiEGIwBB0ABrIgMkACADQS1BKyAIQRxqIgooAgAiB0EASBs2AgggAyAHIAdBH3UiDHMgDGsiByAHQTxtIgdBPGxrIgxBH3UiC0E8cSAMaiIMNgIMIAMgByALaiIHIAdBPG0iB0E8bGsiC0EfdSINQTxxIAtqNgIQIAMgByANajYCFAJ/IAxFBEAgA0EDNgIsIANBkMOGATYCKCADQQM2AhwgA0H4woYBNgIYIANBAzYCJCADQZwDNgJEIANBnAM2AjwgA0HvGzYCNCADIANBMGo2AiAgAyADQRBqNgJAIAMgA0EUajYCOCADIANBCGo2AjAgBigCACAGKAIEIANBGGoQywoMAQsgA0EENgIsIANB+MOGATYCKCADQQQ2AhwgA0HYw4YBNgIYIANBBDYCJCADQZwDNgJMIANBnAM2AkQgA0GcAzYCPCADQe8bNgI0IAMgA0EwajYCICADIANBDGo2AkggAyADQRBqNgJAIAMgA0EUajYCOCADIANBCGo2AjAgBigCACAGKAIEIANBGGoQywoLIANB0ABqJAAEQEGU+IABQTcgBUEfakGE+IABQcz4gAEQ1R4ACyAEIAUpAgA3AgwgBEEUaiAFQQhqKAIANgIAIAQgCTYCMCAEIAhBlAFqIgMpAgA3AgAgBEEIaiADQQhqKAIANgIAIAQgCigCADYCGCAEIAhB9ABqIgMpAgA3AhwgBEEkaiADQQhqKQIANwIAIARBLGogA0EQaigCADYCACAFQSBqJAAgCEGRDDYCJCAIQQE2AiwgCEGs94ABNgIoIAhCATcCNCAIIAQ2AiAgCCAIQSBqNgIwIAEgCEEoaiACKAIUEQIARQ0CIABBk4CAgHg2AgAgBBCJLwwECwJAIAYEQCAIQgE3AjQgCEEBNgIsIAhBrPeAATYCKCAIQZEMNgJ4IAhBADoAbCAIQgQ3AmQgCCAHNgJgIAggBjYCXCAIQYCAgIB4NgJMIAhBATYCQCAIIAMoAgA2AnAgCCADKQIENwJEIAggCEH0AGo2AjAgCCAIQUBrIgM2AnQgASAIQShqIAIoAhQRAgBFDQEgAEGTgICAeDYCACADEIkvDAULIAhBATYCRCAIQaz3gAE2AkAgCEIBNwJMIAhBkww2AiwgCCADNgIoIAggCEEoajYCSCABIAhBQGsgAigCFBECAEUNAyAAQZOAgIB4NgIADAQLIAhBQGsQiS8MAgsgCEEoaiEGIAhBEGohBCMAQUBqIgMkACADQSBqIglBJkEAQQFBARCgGCADKAIkIQUCQAJAAkACQCADKAIgQQFHBEAgA0EANgIQIAMgAygCKDYCDCADIAU2AgggCSAEIAQoAgwiDBD3ESADKAIgIgpFDQEgAygCKCEFIAMoAiQhByADIApBDXUiBDYCFAJAIARBkM4ATwRAIANBATYCNCADQaC/gAE2AjAgA0EBNgIkIANBmL+AATYCICADQQE2AiwgA0GcAzYCPCADIANBOGo2AiggAyADQRRqNgI4IANBCGogCRDuPEUNAQwFCyADQQhqIgkgBEH//wNxQeQAbiILEIsYDQQgCSAEIAtB5ABsaxCLGA0ECyADKAIQIQkgA0EIaiIEQQEQhC4gAygCDCADKAIQakEtOgAAIAMgCUEBajYCECAKQQN2IgpB/wdxIglB3QVPDQIgBCAJIAlBqLmAAWotAAAiC2pBBnYQixgNAyADKAIQIQkgBEEBEIQuIAMoAgwgAygCEGpBLToAACADIAlBAWo2AhAgBCAKIAtqQQF2QR9xEIsYDQMgAygCECEJIARBARCELiADKAIMIAMoAhBqQdQAOgAAIAMgCUEBajYCECADIAVBgJTr3ANrIAUgBUH/k+vcA0siCRsiBTYCGCAEIAdBkBxuEIsYDQMgAygCECEKIARBARCELiADKAIMIAMoAhBqQTo6AAAgAyAKQQFqNgIQIAQgB0E8biIKQTxwEIsYDQMgAygCECELIARBARCELiADKAIMIAMoAhBqQTo6AAAgAyALQQFqNgIQIAQgByAKQTxsayAJahCLGA0DAkAgBUUNACAFIAVBwIQ9biIHQcCEPWxGBEAgA0EBNgI0IANBxL+AATYCMCADQQE2AiQgA0G8v4ABNgIgIANBATYCLCADQTs2AjwgAyAHNgIcIAMgA0E4ajYCKCADIANBHGo2AjggBCADQSBqEO48DQUMAQsgBSAFQegHbiIEQegHbEYEQCADQQE2AjQgA0Hcv4ABNgIwIANBATYCJCADQby/gAE2AiAgA0EBNgIsIANBOzYCPCADIAQ2AhwgAyADQThqNgIoIAMgA0EcajYCOCADQQhqIANBIGoQ7jwNBQwBCyADQQE2AjQgA0H0v4ABNgIwIANBATYCJCADQby/gAE2AiAgA0EBNgIsIANBOzYCPCADIANBOGo2AiggAyADQRhqNgI4IANBCGogA0EgahDuPA0ECyADQQE6ACEgA0GBAjsAIiADQQE6ACAgA0EgaiADQQhqIAwQ/gcNAyAGIAMpAgg3AgAgBkEIaiADQRBqKAIANgIAIANBQGskAAwECyAFIAMoAihBmLmAARD9LwALQcTAgAFBK0HwwIABEMskAAsgCUHdBUGIv4ABEMMhAAtBgMGAAUE0IANBIGpBsLiAAUG0wYABENUeAAsgCEGFETYCeCAIQQE2AkQgCEGs94ABNgJAIAhCATcCTCAIIAY2AnQgCCAIQfQAajYCSCABIAhBQGsgAigCFBECAARAIABBk4CAgHg2AgAgBhDeOwwDCyAIQShqEN47DAELIAhBQGsQiS8LIABBlICAgHg2AgALIAhBoAFqJAALuAQCDX8BfiAAIAEoAiggASgCJEEDdGoiAygCBCIJNgIEIAAgASgCGCABKAIUQQN0aiIEKAIEIgY2AgAgBC0AAiEHIAMtAAIhCCABKAIgIAEoAhxBA3RqIgUtAAMhCiADLQADIQsgBC0AAyEMIAUvAQAhDSADLwEAIQ4gBC8BACEPIAUoAgQhBAJAIAUtAAIiA0ECTwRAAn8gAkUgA0EZSXJFBEAgASADQQVrEKAuIAEQ/RgaIAEgASgCBCIDQQVqNgIEQQV0IARqIAEoAgAgA3RBG3ZqDAELIAEgAxCgLiABEP0YGiAEagshAiABKQIsIRAgASACNgIsIAEgEDcCMAwBCyAGRSECIANFBEAgAUEsaiIDIAZBAEdBAnRqKAIAIQQgASADIAJBAnRqKAIAIgI2AiwgASAENgIwDAELIAEgASgCBCIFQQFqNgIEIAFBLGohAwJAAkAgAiAEaiABKAIAIAV0QR92aiIEQQNGBEBBASADKAIAQQFrIgIgAkEBTRshAgwBC0EBIAMgBEECdGooAgAiAiACQQFNGyECIARBAUYNAQsgASABKAIwNgI0CyABIAEoAiw2AjAgASACNgIsCyAAIAI2AgggCARAIAAgASAIEKAuIAlqNgIECyAHIAhqQRRPBEAgARD9GBoLIAcEQCAAIAEgBxCgLiAGajYCAAsgARD9GBogAUEUaiABIA8gDBCPNiABQSRqIAEgDiALEI82IAEQ/RgaIAFBHGogASANIAoQjzYLzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBjNHDAEERIAJBDGpB/NDDABDQEwwSCyACIABBBGo2AgwgAUGw0cMAQQ0gAkEMakGg0cMAENATDBELIAIgAEEEajYCDCABQb3RwwBBCSACQQxqQfzQwwAQ0BMMEAsgAiAAQQRqNgIMIAFBxtHDAEELIAJBDGpB/NDDABDQEwwPCyACIABBBGo2AgwgAUHR0cMAQQogAkEMakH80MMAENATDA4LIAIgAEEEajYCDCABQdvRwwBBCyACQQxqQfzQwwAQ0BMMDQsgAiAAQQRqNgIMIAFB5tHDAEEMIAJBDGpB/NDDABDQEwwMCyABQfLRwwBBDBD7NQwLCyACIABBBGo2AgwgAUH+0cMAQRIgAkEMakH80MMAENATDAoLIAIgAEEEajYCDCABQZDSwwBBCCACQQxqQfzQwwAQ0BMMCQsgAiAAQQRqNgIMIAFBmNLDAEEJIAJBDGpB/NDDABDQEwwICyACIABBDGo2AgwgAUHE0sMAQQcgAEGk0sMAIAJBDGpBtNLDABCDDwwHCyACIABBBGo2AgwgAUHL0sMAQQggAkEMakH80MMAENATDAYLIAIgAEEEajYCDCABQdPSwwBBFCACQQxqQfzQwwAQ0BMMBQsgAiAAQQRqNgIMIAFB59LDAEEMIAJBDGpB/NDDABDQEwwECyACIABBBGo2AgwgAUHz0sMAQQ4gAkEMakH80MMAENATDAMLIAFBgdPDAEEaEPs1DAILIAFBm9PDAEEYEPs1DAELIAIgAEEEajYCDCABQcTTwwBBEyACQQxqQbTTwwAQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGQucwAQREgAkEMakGAucwAENATDBILIAIgAEEEajYCDCABQbS5zABBDSACQQxqQaS5zAAQ0BMMEQsgAiAAQQRqNgIMIAFBwbnMAEEJIAJBDGpBgLnMABDQEwwQCyACIABBBGo2AgwgAUHKucwAQQsgAkEMakGAucwAENATDA8LIAIgAEEEajYCDCABQdW5zABBCiACQQxqQYC5zAAQ0BMMDgsgAiAAQQRqNgIMIAFB37nMAEELIAJBDGpBgLnMABDQEwwNCyACIABBBGo2AgwgAUHqucwAQQwgAkEMakGAucwAENATDAwLIAFB9rnMAEEMEPs1DAsLIAIgAEEEajYCDCABQYK6zABBEiACQQxqQYC5zAAQ0BMMCgsgAiAAQQRqNgIMIAFBlLrMAEEIIAJBDGpBgLnMABDQEwwJCyACIABBBGo2AgwgAUGcuswAQQkgAkEMakGAucwAENATDAgLIAIgAEEMajYCDCABQci6zABBByAAQai6zAAgAkEMakG4uswAEIMPDAcLIAIgAEEEajYCDCABQc+6zABBCCACQQxqQYC5zAAQ0BMMBgsgAiAAQQRqNgIMIAFB17rMAEEUIAJBDGpBgLnMABDQEwwFCyACIABBBGo2AgwgAUHruswAQQwgAkEMakGAucwAENATDAQLIAIgAEEEajYCDCABQfe6zABBDiACQQxqQYC5zAAQ0BMMAwsgAUGFu8wAQRoQ+zUMAgsgAUGfu8wAQRgQ+zUMAQsgAiAAQQRqNgIMIAFByLvMAEETIAJBDGpBuLvMABDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQZS5zQBBESACQQxqQYS5zQAQ0BMMEgsgAiAAQQRqNgIMIAFBuLnNAEENIAJBDGpBqLnNABDQEwwRCyACIABBBGo2AgwgAUHFuc0AQQkgAkEMakGEuc0AENATDBALIAIgAEEEajYCDCABQc65zQBBCyACQQxqQYS5zQAQ0BMMDwsgAiAAQQRqNgIMIAFB2bnNAEEKIAJBDGpBhLnNABDQEwwOCyACIABBBGo2AgwgAUHjuc0AQQsgAkEMakGEuc0AENATDA0LIAIgAEEEajYCDCABQe65zQBBDCACQQxqQYS5zQAQ0BMMDAsgAUH6uc0AQQwQ+zUMCwsgAiAAQQRqNgIMIAFBhrrNAEESIAJBDGpBhLnNABDQEwwKCyACIABBBGo2AgwgAUGYus0AQQggAkEMakGEuc0AENATDAkLIAIgAEEEajYCDCABQaC6zQBBCSACQQxqQYS5zQAQ0BMMCAsgAiAAQQxqNgIMIAFBzLrNAEEHIABBrLrNACACQQxqQby6zQAQgw8MBwsgAiAAQQRqNgIMIAFB07rNAEEIIAJBDGpBhLnNABDQEwwGCyACIABBBGo2AgwgAUHbus0AQRQgAkEMakGEuc0AENATDAULIAIgAEEEajYCDCABQe+6zQBBDCACQQxqQYS5zQAQ0BMMBAsgAiAAQQRqNgIMIAFB+7rNAEEOIAJBDGpBhLnNABDQEwwDCyABQYm7zQBBGhD7NQwCCyABQaO7zQBBGBD7NQwBCyACIABBBGo2AgwgAUHMu80AQRMgAkEMakG8u80AENATCyACQRBqJAALgAUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHS0EBIAR0QYMBcUVyRQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhHBEAgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQowsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAILIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELQQRBEBCjPQALIAVBgAFqJAALgAUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHS0EBIAR0QYMBcUVyRQRAIAVBOGoiBEEANgIAIAVCgICAgMAANwIwIAVBMGoiBkEBEIYtIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6QggBSgCUCIDQQhHBEAgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2i8MAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAILIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELQQRBEBCjPQALIAVBgAFqJAAL0AcCDX8CfiMAQbABayIDJAAgASgCECECAkACQAJAIAEoAhQiBkEISQ0AIAIgBkF4cWpBCGsiBEUNACAEKAIAQX9GDQELIAMgARDUOiIINgIMIANBEGoiBSAIEMQbIAEoAhgiBCAEKAIAIgdBAWo2AgACQAJAIAdBAE4EQCADIAQ2AogBIAMgASkCHDcCjAEgBSADQYgBahDZICENIAZBEEkNAiAGQQN2IQcgA0HIAGohDiADQewAaiEKQQAhBANAIAJBCGoiBikDACEPIAIpAwAhEAJAIAEgBBCWJUUEQCADQRBqIA0gEKciAiAPpyACaxCJEAwBCyAKEOY6IAMoAmxFDQMgAygCfEEBaiILQQN2IAtBB3FBAEdqIgIgAygCeCIFSwRAIAIgBWshDCADKAJwIgkgAkkEQCAKIAlBAXQiBSACENAqIgkgBSAJSxsQ6BkgAygCeCEFCyAMBEAgAygCdCAFakEAIAz8CwALIAMgAjYCeAsgAyALNgJ8IAMoAlAiAiADKAJIRgRAIA5B/OmAARCxKAsgAygCTCACQQR0aiIFQgA3AwggBUIANwMAIAMgAkEBajYCUAsgBEEBaiEEIAYhAiAHQQFrIgdBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAIRgRAIAAgARDbDCABEOklDAILIANBADYCmAFBACADQZQBaiADQQxqIANBmAFqQezsgAEQrysACyABENQ6IQIgA0EUaiABEPk0IAMgAjYCMCADQQA2AiwgAyABNgIQIwBBsAFrIgEkACADQRBqIgIoAgAhBiABQaABaiACQRRqKQIANwIAIAFBmAFqIAJBDGopAgA3AgAgASACKQIENwKQASACKAIgIQUgAigCHCECIAYQ1DohBCAGENQ6GiABQRBqIAQgAmsQxBsgASAFNgKsASABIAI2AqgBIAEgBjYCjAEgASgCkAEhBAJAAkAgAiAFRwRAA0AgAUEQagJ/AkAgBARAIAIgASgCoAFPDQUgASgClAEgAiABKAKcAWoiB0EDdmotAABB/wFzIAdBB3F2QQFxDQELIAEgAkEBajYCqAEgAUEIaiAGIAIQ2isgASgCDCEIIAEoAggMAQsgASACQQFqNgKoAUEACyAIELsBIAUgAkEBaiICRw0ACwsCQCAERQ0AIAQgBCgCACICQQFrNgIAIAJBAUcNACABQZABahD7HgsgACABQRBqIgAQ2wwgABDpJSABQbABaiQADAELQazsgAFBIEHM7IABEJ8pAAsLIANBsAFqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBzPmAAUERIAJBDGpBvPmAARDQEwwSCyACIABBBGo2AgwgAUHw+YABQQ0gAkEMakHg+YABENATDBELIAIgAEEEajYCDCABQf35gAFBCSACQQxqQbz5gAEQ0BMMEAsgAiAAQQRqNgIMIAFBhvqAAUELIAJBDGpBvPmAARDQEwwPCyACIABBBGo2AgwgAUGR+oABQQogAkEMakG8+YABENATDA4LIAIgAEEEajYCDCABQZv6gAFBCyACQQxqQbz5gAEQ0BMMDQsgAiAAQQRqNgIMIAFBpvqAAUEMIAJBDGpBvPmAARDQEwwMCyABQbL6gAFBDBD7NQwLCyACIABBBGo2AgwgAUG++oABQRIgAkEMakG8+YABENATDAoLIAIgAEEEajYCDCABQdD6gAFBCCACQQxqQbz5gAEQ0BMMCQsgAiAAQQRqNgIMIAFB2PqAAUEJIAJBDGpBvPmAARDQEwwICyACIABBDGo2AgwgAUGE+4ABQQcgAEHk+oABIAJBDGpB9PqAARCDDwwHCyACIABBBGo2AgwgAUGL+4ABQQggAkEMakG8+YABENATDAYLIAIgAEEEajYCDCABQZP7gAFBFCACQQxqQbz5gAEQ0BMMBQsgAiAAQQRqNgIMIAFBp/uAAUEMIAJBDGpBvPmAARDQEwwECyACIABBBGo2AgwgAUGz+4ABQQ4gAkEMakG8+YABENATDAMLIAFBwfuAAUEaEPs1DAILIAFB2/uAAUEYEPs1DAELIAIgAEEEajYCDCABQYT8gAFBEyACQQxqQfT7gAEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUHY/oMBQREgAkEMakHI/oMBENATDBILIAIgAEEEajYCDCABQfz+gwFBDSACQQxqQez+gwEQ0BMMEQsgAiAAQQRqNgIMIAFBif+DAUEJIAJBDGpByP6DARDQEwwQCyACIABBBGo2AgwgAUGS/4MBQQsgAkEMakHI/oMBENATDA8LIAIgAEEEajYCDCABQZ3/gwFBCiACQQxqQcj+gwEQ0BMMDgsgAiAAQQRqNgIMIAFBp/+DAUELIAJBDGpByP6DARDQEwwNCyACIABBBGo2AgwgAUGy/4MBQQwgAkEMakHI/oMBENATDAwLIAFBvv+DAUEMEPs1DAsLIAIgAEEEajYCDCABQcr/gwFBEiACQQxqQcj+gwEQ0BMMCgsgAiAAQQRqNgIMIAFB3P+DAUEIIAJBDGpByP6DARDQEwwJCyACIABBBGo2AgwgAUHk/4MBQQkgAkEMakHI/oMBENATDAgLIAIgAEEMajYCDCABQZCAhAFBByAAQfD/gwEgAkEMakGAgIQBEIMPDAcLIAIgAEEEajYCDCABQZeAhAFBCCACQQxqQcj+gwEQ0BMMBgsgAiAAQQRqNgIMIAFBn4CEAUEUIAJBDGpByP6DARDQEwwFCyACIABBBGo2AgwgAUGzgIQBQQwgAkEMakHI/oMBENATDAQLIAIgAEEEajYCDCABQb+AhAFBDiACQQxqQcj+gwEQ0BMMAwsgAUHNgIQBQRoQ+zUMAgsgAUHngIQBQRgQ+zUMAQsgAiAAQQRqNgIMIAFBkIGEAUETIAJBDGpBgIGEARDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQfjPhQFBESACQQxqQejPhQEQ0BMMEgsgAiAAQQRqNgIMIAFBnNCFAUENIAJBDGpBjNCFARDQEwwRCyACIABBBGo2AgwgAUGp0IUBQQkgAkEMakHoz4UBENATDBALIAIgAEEEajYCDCABQbLQhQFBCyACQQxqQejPhQEQ0BMMDwsgAiAAQQRqNgIMIAFBvdCFAUEKIAJBDGpB6M+FARDQEwwOCyACIABBBGo2AgwgAUHH0IUBQQsgAkEMakHoz4UBENATDA0LIAIgAEEEajYCDCABQdLQhQFBDCACQQxqQejPhQEQ0BMMDAsgAUHe0IUBQQwQ+zUMCwsgAiAAQQRqNgIMIAFB6tCFAUESIAJBDGpB6M+FARDQEwwKCyACIABBBGo2AgwgAUH80IUBQQggAkEMakHoz4UBENATDAkLIAIgAEEEajYCDCABQYTRhQFBCSACQQxqQejPhQEQ0BMMCAsgAiAAQQxqNgIMIAFBsNGFAUEHIABBkNGFASACQQxqQaDRhQEQgw8MBwsgAiAAQQRqNgIMIAFBt9GFAUEIIAJBDGpB6M+FARDQEwwGCyACIABBBGo2AgwgAUG/0YUBQRQgAkEMakHoz4UBENATDAULIAIgAEEEajYCDCABQdPRhQFBDCACQQxqQejPhQEQ0BMMBAsgAiAAQQRqNgIMIAFB39GFAUEOIAJBDGpB6M+FARDQEwwDCyABQe3RhQFBGhD7NQwCCyABQYfShQFBGBD7NQwBCyACIABBBGo2AgwgAUGw0oUBQRMgAkEMakGg0oUBENATCyACQRBqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBvOuFAUERIAJBDGpBrOuFARDQEwwSCyACIABBBGo2AgwgAUHg64UBQQ0gAkEMakHQ64UBENATDBELIAIgAEEEajYCDCABQe3rhQFBCSACQQxqQazrhQEQ0BMMEAsgAiAAQQRqNgIMIAFB9uuFAUELIAJBDGpBrOuFARDQEwwPCyACIABBBGo2AgwgAUGB7IUBQQogAkEMakGs64UBENATDA4LIAIgAEEEajYCDCABQYvshQFBCyACQQxqQazrhQEQ0BMMDQsgAiAAQQRqNgIMIAFBluyFAUEMIAJBDGpBrOuFARDQEwwMCyABQaLshQFBDBD7NQwLCyACIABBBGo2AgwgAUGu7IUBQRIgAkEMakGs64UBENATDAoLIAIgAEEEajYCDCABQcDshQFBCCACQQxqQazrhQEQ0BMMCQsgAiAAQQRqNgIMIAFByOyFAUEJIAJBDGpBrOuFARDQEwwICyACIABBDGo2AgwgAUH07IUBQQcgAEHU7IUBIAJBDGpB5OyFARCDDwwHCyACIABBBGo2AgwgAUH77IUBQQggAkEMakGs64UBENATDAYLIAIgAEEEajYCDCABQYPthQFBFCACQQxqQazrhQEQ0BMMBQsgAiAAQQRqNgIMIAFBl+2FAUEMIAJBDGpBrOuFARDQEwwECyACIABBBGo2AgwgAUGj7YUBQQ4gAkEMakGs64UBENATDAMLIAFBse2FAUEaEPs1DAILIAFBy+2FAUEYEPs1DAELIAIgAEEEajYCDCABQfTthQFBEyACQQxqQeTthQEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGAjIYBQREgAkEMakHwi4YBENATDBILIAIgAEEEajYCDCABQaSMhgFBDSACQQxqQZSMhgEQ0BMMEQsgAiAAQQRqNgIMIAFBsYyGAUEJIAJBDGpB8IuGARDQEwwQCyACIABBBGo2AgwgAUG6jIYBQQsgAkEMakHwi4YBENATDA8LIAIgAEEEajYCDCABQcWMhgFBCiACQQxqQfCLhgEQ0BMMDgsgAiAAQQRqNgIMIAFBz4yGAUELIAJBDGpB8IuGARDQEwwNCyACIABBBGo2AgwgAUHajIYBQQwgAkEMakHwi4YBENATDAwLIAFB5oyGAUEMEPs1DAsLIAIgAEEEajYCDCABQfKMhgFBEiACQQxqQfCLhgEQ0BMMCgsgAiAAQQRqNgIMIAFBhI2GAUEIIAJBDGpB8IuGARDQEwwJCyACIABBBGo2AgwgAUGMjYYBQQkgAkEMakHwi4YBENATDAgLIAIgAEEMajYCDCABQbiNhgFBByAAQZiNhgEgAkEMakGojYYBEIMPDAcLIAIgAEEEajYCDCABQb+NhgFBCCACQQxqQfCLhgEQ0BMMBgsgAiAAQQRqNgIMIAFBx42GAUEUIAJBDGpB8IuGARDQEwwFCyACIABBBGo2AgwgAUHbjYYBQQwgAkEMakHwi4YBENATDAQLIAIgAEEEajYCDCABQeeNhgFBDiACQQxqQfCLhgEQ0BMMAwsgAUH1jYYBQRoQ+zUMAgsgAUGPjoYBQRgQ+zUMAQsgAiAAQQRqNgIMIAFBuI6GAUETIAJBDGpBqI6GARDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQbCchgFBESACQQxqQaCchgEQ0BMMEgsgAiAAQQRqNgIMIAFB1JyGAUENIAJBDGpBxJyGARDQEwwRCyACIABBBGo2AgwgAUHhnIYBQQkgAkEMakGgnIYBENATDBALIAIgAEEEajYCDCABQeqchgFBCyACQQxqQaCchgEQ0BMMDwsgAiAAQQRqNgIMIAFB9ZyGAUEKIAJBDGpBoJyGARDQEwwOCyACIABBBGo2AgwgAUH/nIYBQQsgAkEMakGgnIYBENATDA0LIAIgAEEEajYCDCABQYqdhgFBDCACQQxqQaCchgEQ0BMMDAsgAUGWnYYBQQwQ+zUMCwsgAiAAQQRqNgIMIAFBop2GAUESIAJBDGpBoJyGARDQEwwKCyACIABBBGo2AgwgAUG0nYYBQQggAkEMakGgnIYBENATDAkLIAIgAEEEajYCDCABQbydhgFBCSACQQxqQaCchgEQ0BMMCAsgAiAAQQxqNgIMIAFB6J2GAUEHIABByJ2GASACQQxqQdidhgEQgw8MBwsgAiAAQQRqNgIMIAFB752GAUEIIAJBDGpBoJyGARDQEwwGCyACIABBBGo2AgwgAUH3nYYBQRQgAkEMakGgnIYBENATDAULIAIgAEEEajYCDCABQYuehgFBDCACQQxqQaCchgEQ0BMMBAsgAiAAQQRqNgIMIAFBl56GAUEOIAJBDGpBoJyGARDQEwwDCyABQaWehgFBGhD7NQwCCyABQb+ehgFBGBD7NQwBCyACIABBBGo2AgwgAUHonoYBQRMgAkEMakHYnoYBENATCyACQRBqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBtNuGAUERIAJBDGpBpNuGARDQEwwSCyACIABBBGo2AgwgAUHY24YBQQ0gAkEMakHI24YBENATDBELIAIgAEEEajYCDCABQeXbhgFBCSACQQxqQaTbhgEQ0BMMEAsgAiAAQQRqNgIMIAFB7tuGAUELIAJBDGpBpNuGARDQEwwPCyACIABBBGo2AgwgAUH524YBQQogAkEMakGk24YBENATDA4LIAIgAEEEajYCDCABQYPchgFBCyACQQxqQaTbhgEQ0BMMDQsgAiAAQQRqNgIMIAFBjtyGAUEMIAJBDGpBpNuGARDQEwwMCyABQZrchgFBDBD7NQwLCyACIABBBGo2AgwgAUGm3IYBQRIgAkEMakGk24YBENATDAoLIAIgAEEEajYCDCABQbjchgFBCCACQQxqQaTbhgEQ0BMMCQsgAiAAQQRqNgIMIAFBwNyGAUEJIAJBDGpBpNuGARDQEwwICyACIABBDGo2AgwgAUHs3IYBQQcgAEHM3IYBIAJBDGpB3NyGARCDDwwHCyACIABBBGo2AgwgAUHz3IYBQQggAkEMakGk24YBENATDAYLIAIgAEEEajYCDCABQfvchgFBFCACQQxqQaTbhgEQ0BMMBQsgAiAAQQRqNgIMIAFBj92GAUEMIAJBDGpBpNuGARDQEwwECyACIABBBGo2AgwgAUGb3YYBQQ4gAkEMakGk24YBENATDAMLIAFBqd2GAUEaEPs1DAILIAFBw92GAUEYEPs1DAELIAIgAEEEajYCDCABQezdhgFBEyACQQxqQdzdhgEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGYjIcBQREgAkEMakGIjIcBENATDBILIAIgAEEEajYCDCABQbyMhwFBDSACQQxqQayMhwEQ0BMMEQsgAiAAQQRqNgIMIAFByYyHAUEJIAJBDGpBiIyHARDQEwwQCyACIABBBGo2AgwgAUHSjIcBQQsgAkEMakGIjIcBENATDA8LIAIgAEEEajYCDCABQd2MhwFBCiACQQxqQYiMhwEQ0BMMDgsgAiAAQQRqNgIMIAFB54yHAUELIAJBDGpBiIyHARDQEwwNCyACIABBBGo2AgwgAUHyjIcBQQwgAkEMakGIjIcBENATDAwLIAFB/oyHAUEMEPs1DAsLIAIgAEEEajYCDCABQYqNhwFBEiACQQxqQYiMhwEQ0BMMCgsgAiAAQQRqNgIMIAFBnI2HAUEIIAJBDGpBiIyHARDQEwwJCyACIABBBGo2AgwgAUGkjYcBQQkgAkEMakGIjIcBENATDAgLIAIgAEEMajYCDCABQdCNhwFBByAAQbCNhwEgAkEMakHAjYcBEIMPDAcLIAIgAEEEajYCDCABQdeNhwFBCCACQQxqQYiMhwEQ0BMMBgsgAiAAQQRqNgIMIAFB342HAUEUIAJBDGpBiIyHARDQEwwFCyACIABBBGo2AgwgAUHzjYcBQQwgAkEMakGIjIcBENATDAQLIAIgAEEEajYCDCABQf+NhwFBDiACQQxqQYiMhwEQ0BMMAwsgAUGNjocBQRoQ+zUMAgsgAUGnjocBQRgQ+zUMAQsgAiAAQQRqNgIMIAFB0I6HAUETIAJBDGpBwI6HARDQEwsgAkEQaiQAC+gKAhJ/AX4jAEEwayILJAAgCyAFNwMoIAsgBDcDICALIAM3AxggCyACNwMQIAFBEGoiCCALQRBqEK0MIQMgASgCCEUEQCALQQhqIRAjAEHQAGsiByQAIAcgCDYCHCABKAIMIQ4gByAHQRxqNgIgAkACQCAOIA5BAWoiCE0EQAJAIAEoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgCEkEQAJ/IAlBAWoiCSAIIAggCUkbIghBD08EQCAIQf////8BSw0FQX8gCEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAhBCEkbIAhBBEkbCyEIIAdBQGsgAUEQaiIMQTBBECAIEJ0UIAcoAkQhCSAHKAJAIgpFBEAgBygCSCEIDAULIAcpAkghAiAJQQlqIggEQCAKQf8BIAj8CwALIAcgAkIgiD4CPCAHIAKnIhI2AjggByAJNgI0IAcgCjYCMCAHQrCAgICAAjcCKCAHIAw2AiQgB0EwaiETIAcgDgR/IApBCGohFCABKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhAkEAIQgDQCACUARAA0AgCEEIaiEIIBFBCGoiESkDAEKAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhAgsgCiAJIAcoAhwgASgCACACeqdBA3YgCGoiFUFQbGpBMGsQrQynIhZxIgxqKQAAQoCBgoSIkKDAgH+DIgRQBEBBCCEPA0AgDCAPaiEMIA9BCGohDyAKIAkgDHEiDGopAABCgIGChIiQoMCAf4MiBFANAAsLIAogBHqnQQN2IAxqIAlxIgxqLAAAQQBOBEAgCikDAEKAgYKEiJCgwIB/g3qnQQN2IQwLIAogDGogFkEZdiIPOgAAIBQgDEEIayAJcWogDzoAACAKIAxBf3NBMGxqIAEoAgAgFUF/c0EwbGpBMPwKAAAgAkIBfSACgyECIA5BAWsiDg0ACyABKAIMBUEACyIINgI8IAcgEiAIazYCOCABIBNBBBD6KiAHQSRqENAmDAELIAEgB0EgakHQ3YABQTAQxwkLQYGAgIB4IQkMAgsQ4ycgBygCDCEIIAcoAgghCQwBCxDjJyAHKAIUIQggBygCECEJCyAQIAg2AgQgECAJNgIAIAdB0ABqJAALIAEoAgQiCCADp3EhByADQhmIIgRC/wCDQoGChIiQoMCAAX4hGSABKAIAIQkDQAJ/AkACQAJAIAcgCWopAAAiAyAZhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBVBFBEADQCALQRBqQSAgASgCAEEAIAV6p0EDdiAHaiAIcWsiCkEwbGpBMGtBIBCfOw0CIAVCAX0gBYMiBVBFDQALCyADQoCBgoSIkKDAgH+DIQIgF0UEQCACUA0DIAJ6p0EDdiAHaiAIcSENC0EBIAIgA0IBhoNQDQMaQQAhByAJIA1qLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQ0LIAEoAgAiCCANaiIJLQAAIQogCykDECECIAspAxghAyALKQMgIQUgCykDKCEZIAkgBKdB/wBxIgk6AAAgCCABKAIEIA1BCGtxakEIaiAJOgAAIAEgASgCDEEBajYCDCAIIA1BUGxqIghBIGsiCSAZNwMIIAkgBTcDACAIQTBrIgkgAzcDCCAJIAI3AwAgASABKAIIIApBAXFrNgIIIAhBEGsgBjYCAAwBCyABKAIAIApBMGxqQRBrIgcoAgAhASAHIAY2AgBBASEHCyAAIAE2AgQgACAHNgIAIAtBMGokAA8LQQALIRcgByAYQQhqIhhqIAhxIQcMAAsAC6EFAQZ/IwBB0ABrIgIkACACQRNBFCAAELomIgQbNgIQIAJBmImGAUGEiYYBIAQbNgIMIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBxwI2AhwgAiACQRhqIgU2AkAgAiACQQxqNgIYAkACQCABKAIAIgQgASgCBCIDIAJBOGoiBxDLCg0AIARBvImGAUETIAMoAgwiBhEGAA0AIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBrxs2AhwgAiAAQRhqNgIYIAIgBTYCQCAEIAMgBxDLCg0AIAAoAiQEQCACIABBJGo2AjQgBEHPiYYBQRMgBhEGAA0BIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBsBs2AhwgAiAFNgJAIAIgAkE0ajYCGCAEIAMgAkE4ahDLCg0BCyAALQAMQSFGBEAgAiAAQRBqELAuIAIoAgQhBiACKAIAIQQDQAJAIAQgBkcEQCACIAQtAAAiAzoAFyAAIAMQ2SghAyACIARBBGooAgAiBUE8ajYCMCACIAVBMGo2AjQgAkEENgIcIAJBgIqGATYCGCACQgM3AiQgAkGvAzYCTCACQYQBNgJEIAJB9As2AjwgAiACQThqNgIgIAIgAkE0ajYCSCACIAJBMGo2AkAgAiACQRdqNgI4IAEoAgAgASgCBCACQRhqEMsKDQQgAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAEgAygCDBECAEUNAQwECyACQQA2AkggAkEBNgI8IAJB5ImGATYCOCACQgQ3AkAgASACQThqENE5IQMMBAsgBEEIaiEEQQEhAyABKAIAQauJhgFBASABKAIEKAIMEQYARQ0ACwwCC0HIhYYBQShBoIqGARCfKQALQQEhAwsgAkHQAGokACADC9YEAQN/IwBBQGoiBCQAIARBKGoiBSACKAIMIgJBCGogAigCCEECRkECdGoQiRkCQAJAIAQtAChBDUcNAAJAAkACQCABKAIABEAgASgCCEECRw0BIAQgASgCBC8AADsBKCAFQdiJzgAQjShFDQQgA7wiBkH///8DcSEFIAZBgICAgHhxIQIgBkGAgID8B3EiAUGAgID8B0YEQCAFQQ12IAJBEHZyIAVBAEdBCXRyQYD4AXIhAgwECyACQRB2IQIgAUGAgIC4BEsNAiABQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogAnJqIQIMBAsgAUGAgICYA0kNAyAFQYCAgARyIgZBHiABQRd2IgVrdiEBIAZBHSAFayIFdkEBcQR/IAFBAyAFdEEBayAGcUEAR2oFIAELIAJyIQIMAwtB5IfOAEEgQYSIzgAQyyQAC0HQg84AQSsgBEEoakH8g84AQciJzgAQ1R4ACyACQYD4AXIhAgsgBCACOwEmIARBCGogBEEmakECEL8cIAQoAghBCEYEQCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIADAILIARBOGogBEEYaikDADcDACAEQTBqIARBEGopAwA3AwAgBCAEKQMINwMoQdCDzgBBKyAEQShqQcCDzgBB3InOABDVHgALAkAgASgCACICBEAgBEEoaiABQQxqIAEoAgQgASgCCCACKAIAEQUADAELIARBADYCKAsgACAEKQIoNwIAIABBCGogBEEwaikCADcCAAsgBEFAayQAC5EEAQN/AkACQAJAAkACQAJAIABBBk8EQCAAQYIBTwRAIABBwhBPBEAgAS0APSACMwF6IAQgBSAGEN8TQQwgAK1CwhB9IAQgBSAGEN8TIAMgAygC9AFBAWo2AvQBDwsgAEHCAGsiCGdBIGpBP3MiB0EyaiIAQYABTw0CIABBgAFPDQMgACABai0AACACIABBAXRqMwEAIAQgBSAGEN8TIAcgCK1CfyAHrYZ8IAQgBSAGEN8TIABBgAFJDQcgAEGAAUHElPMAEMMhAAsgAEECayIIIAhnQSBqQT9zQQFrIgd2IgkgB0EBdGpBKmoiAEGAAU8NAyAAQYABTwRAIABBgAFB5JTzABDDIQALIAAgAWotAAAgAiAAQQF0ajMBACAEIAUgBhDfEyAHIAitIAmtIAethn0gBCAFIAYQ3xMgAEGAAUkNBSAAQYABQfSU8wAQwyEACyAAQShyIgBBgAFPDQMgAEGAAU8EQCAAQYABQZSV8wAQwyEACyAAIAFqLQAAIAIgAEEBdGozAQAgBCAFIAYQ3xMgAEGAAUkNBSAAQYABQaSV8wAQwyEACyAAQYABQaSU8wAQwyEACyAAQYABQbSU8wAQwyEACyAAQYABQdSU8wAQwyEACyAAQYABQYSV8wAQwyEACyADIABBAnRqIgAgACgCAEEBajYCAA8LIAMgAEECdGoiACAAKAIAQQFqNgIAC6gEAgJ+An8jAEEgayIGJAAgAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIFQStrDgMCAQIBCyABLQAAIQULAkACQAJAAkACQAJAAkACQAJAIAVB/wFxQStrDgMAAgECCyACQQFrIQUgAUEBaiEBIAJBEUkNAiAFIQIMBgsgAkEBayEFIAFBAWohASACQRFPBEADQCAFRQ0IIAZBEGogAyADQj+HQgpCABCoHiABLQAAQTBrIgJBCUsNCSAGKQMYIAYpAxAiA0I/h1INBCABQQFqIQEgBUEBayEFIAKtIgRCAFIgAyADIAR9IgNVc0UNAAsgAEEDOgABQQEMCgsgBUUNBANAIAEtAABBMGsiAkEJSw0IIAFBAWohASADQgp+IAKtfSEDIAVBAWsiBQ0ACwwGCyACQQ9LDQQMAgsgBSICRQ0CDAELIABBAzoAAUEBDAYLA0AgAS0AAEEwayIFQQlLDQQgAUEBaiEBIAWtIANCCn58IQMgAkEBayICDQALDAILDAELA0AgAkUNASAGIAMgA0I/h0IKQgAQqB4gAS0AAEEwayIFQQlLDQIgBikDCCAGKQMAIgNCP4dSDQMgAUEBaiEBIAJBAWshAiAFrSIEQgBUIAMgAyAEfCIDVXNFDQALIABBAjoAAUEBDAMLIAAgAzcDCEEADAILIABBAToAAUEBDAELIABBAjoAAUEBCzoAACAGQSBqJAALygcBDX8jAEGwAWsiAyQAIAEoAhAhAgJAAkACQCABKAIUIgZBBEkNACACIAZBfHFqQQRrIgVFDQAgBSgCAEF/Rg0BCyADIAEQ0zoiCDYCDCADQRBqIgQgCBDEGyABKAIYIgUgBSgCACIHQQFqNgIAAkACQCAHQQBOBEAgAyAFNgKIASADIAEpAhw3AowBIAQgA0GIAWoQ2SAhDSAGQQhJDQIgBkECdiEHIANByABqIQ4gA0HsAGohCkEAIQUDQCACQQRqIgYoAgAhBCACKAIAIQICQCABIAUQliVFBEAgA0EQaiANIAIgBCACaxCJEAwBCyAKEOY6IAMoAmxFDQMgAygCfEEBaiILQQN2IAtBB3FBAEdqIgIgAygCeCIESwRAIAIgBGshDCADKAJwIgkgAkkEQCAKIAlBAXQiBCACENAqIgkgBCAJSxsQ6BkgAygCeCEECyAMBEAgAygCdCAEakEAIAz8CwALIAMgAjYCeAsgAyALNgJ8IAMoAlAiAiADKAJIRgRAIA5B/OmAARCxKAsgAygCTCACQQR0aiIEQgA3AwggBEIANwMAIAMgAkEBajYCUAsgBUEBaiEFIAYhAiAHQQFrIgdBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAIRgRAIAAgARDbDCABEOklDAILIANBADYCmAFBACADQZQBaiADQQxqIANBmAFqQezsgAEQrysACyABENM6IQIgA0EUaiABEPk0IAMgAjYCMCADQQA2AiwgAyABNgIQIwBBsAFrIgEkACADQRBqIgIoAgAhBiABQaABaiACQRRqKQIANwIAIAFBmAFqIAJBDGopAgA3AgAgASACKQIENwKQASACKAIgIQQgAigCHCECIAYQ0zohBSAGENM6GiABQRBqIAUgAmsQxBsgASAENgKsASABIAI2AqgBIAEgBjYCjAEgASgCkAEhBQJAAkAgAiAERwRAA0AgAUEQagJ/AkAgBQRAIAIgASgCoAFPDQUgASgClAEgAiABKAKcAWoiB0EDdmotAABB/wFzIAdBB3F2QQFxDQELIAEgAkEBajYCqAEgAUEIaiAGIAIQjywgASgCDCEIIAEoAggMAQsgASACQQFqNgKoAUEACyAIELsBIAQgAkEBaiICRw0ACwsCQCAFRQ0AIAUgBSgCACICQQFrNgIAIAJBAUcNACABQZABahD7HgsgACABQRBqIgAQ2wwgABDpJSABQbABaiQADAELQazsgAFBIEHM7IABEJ8pAAsLIANBsAFqJAAL1gQCBX8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSICNgIcAkACQCABKAIUIgUEQCABQQxqIQYgASgCECEHQQAhAwNAIAMgB2oiCC0AACACTwRAIAEgAxCLOw0DCyAFIANBAWoiA0cNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEJIAAgBEFAa0E8/AoAACAAQQA6AEQgACAJNwI8DAELIAQgAzYCICAEIAg2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQcMKNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL3gQBBH8jAEHQAGsiAyQAAkACfwJAAkACQAJAAkACQAJAAkAgACgCFCIFIAAoAhAiBkkEQAJAIAAoAgwgBWotAAAiBEHlAE0EQCAEQSJGDQYgBEEtRg0FIARB2wBHDQEgA0EKOgBAIANBQGsgASACENEcDAsLIARB8wBNBEAgBEHmAEYNBCAEQe4ARw0BIAAgBUEBajYCFCAAQfyxiAFBAxDJFSIEDQwgA0EHOgBAIANBQGsgASACENEcDAsLIARB9ABGDQcgBEH7AEYNAgsgBEEwa0H/AXFBCkkNBQsgA0EKNgJAIANBCGogAEEMaiAFQQFqIgEgBiABIAZJGxDqDCADQUBrIAMoAgggAygCDBD7KAwICyADQQs6AEAgA0FAayABIAIQ0RwMBwsgACAFQQFqNgIUIABBgrKIAUEEEMkVIgQNByADQQA7AUAgA0FAayABIAIQ0RwMBgsgACAFQQFqNgIUIANBEGoiBCAAQQAQxAsgAykDEEIDUQ0DIAQgASACENwgDAULIABBADYCCCAAIAVBAWo2AhQgA0E0aiAAQQxqIAAQvg8gAygCOCEEIAMoAjRBAkYNBSADIAMoAjw2AkggAyAENgJEIANBBToAQCADQUBrIAEgAhDRHAwECyADQSBqIABBARDECyADKQMgQgNRBEAgAygCKCEEDAULIANBIGogASACENwgDAMLIAAgBUEBajYCFCAAQf+xiAFBAxDJFSIERQ0BDAMLIAMoAhghBAwCCyADQYACOwFAIANBQGsgASACENEcCyAAEIcuIQQLIANB0ABqJAAgBAv/BAIEfwh+IwBBkAFrIgMkAEKAgICAgICAgIB/IQwCQAJ+AkACQCABKAIMKAIQIAJBBHRqIgQpAwAiCiAEKQMIIgtCgICAgICAgICAf4WEQgBSIAEoAggiBCgCACIFKAIAIgYpAwgiByAGKQMAIgiDQn9SckUEQEIAIQcMAQsgByAIhFANAyADQRBqIAogCyAIIAcQgxkgAyADKQMQIgkgAykDGCIMIAggBxCoHkIAIAogAykDACIOfSAHIAiDQn9RIgYbIQ1CACALIAMpAwh9IAogDlStfSAGGyEHIAtCAFkNAQsgCSANIAUoAggiBSkDAFggByAFKQMIIghXIAcgCFEbrSIIfSEHIAwgCCAJVq19DAELIAwgCSANIAUoAgQiBSkDAFogByAFKQMIIghZIAcgCFEbrXwiByAJVK18CyEJAkACQAJ+IAkgB0KAgICAgICAgIB/fSAHVK18UEUEQCAEKAIEIQEgAyALNwNIIAMgCjcDQCADQcyR/wA2AlggA0IENwJkIANBhAw2AowBIANB9As2AoQBIAMgAUEBajYCgAEgA0G7BzYCfCADIAE2AnggA0HMATYCdCADQaCS/wA2AnAgAyADQfAAajYCYCADIANBQGs2AogBIANBBDYCXCADQTBqIANB2ABqEJkOIAMpAjghCUGCgICAeCEEIAMpAjAMAQsgA0HwAGogByAEKAIILQAAEI0QIAMoAnAiBEGTgICAeEYNASADKQJ8IQkgAykCdAshByAAIAk3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0GQAWokAA8LQcyP/wAQ4isAC7EFAgJ/BH4jAEGQAWsiBiQAIAYgBDcDECAGIAU3AxggBiACNwMAIAYgAzcDCCAGQUBrIAIgAyAEIAUgASgCACIHKQMAIAcpAwggBykDECAHKQMYEJoIAn4gBi0AQEEBRgRAIAYtAEEEQEKAgICAgICAgIB/IQhCAAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakG8i/8AEO8sAAsgBikDaCEIIAYpA2AhCSAGKQNYIQsgBikDUAshCiAGQUBrIAIgAyAEIAUgBykDACAHKQMIIAcpAxAgBykDGBCaCAJAIAYtAEBBAUYEQCAGLQBBBEAgBkE4akIANwMAIAZBMGpCADcDACAGQgA3AyggBkIANwMgDAILIAZBADYCMCAGQQE2AiQgBkG0i/8ANgIgIAZCBDcCKCAGQSBqQcyL/wAQ7ywACyAGIAYpA4gBNwM4IAYgBikDgAE3AzAgBiAGKQN4NwMoIAYgBikDcDcDIAsgBkHYAGpCADcDACAGQdAAakIANwMAIAZCADcDSCAGQgA3A0ACQAJAAkAgBiAGQUBrEPsbIgdB/wFxQQJHIAfAQQBOcUUEQCAGQSBqIAEoAggQ+xvAQQBMDQEMAgsgBkEgaiABKAIEEPsbIgFB/wFxQQJGIAHAQQBIcg0BIAggCSAKQgF8IgQgCyAEUK18IgKEUK18IgUgCVStfCEIDAILIApCAX0hBCALIApQrX0hAiAJIAogC4RQrSIDfSEFIAggAyAJVq19IQgMAQsgCSEFIAohBCALIQILIwBBIGsiASQAIAEgBCACIAUgCBDWIyAAIAEoAgBBAXEEfiABKQMYIAAgASkDECICNwMIIAJCgICAgICAgICAf30gAlStfFCtBUIACzcDACABQSBqJAAgBkGQAWokAAvoBAICfwR+IwBBkAFrIgYkACAGIAQ3AxAgBiAFNwMYIAYgAjcDACAGIAM3AwggBkFAayACIAMgBCAFIAEoAgAiBykDACAHKQMIIAcpAxAgBykDGBCaCAJ+IAYtAEBBAUYEQCAGLQBBBEBCgICAgICAgICAfyEIQgAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBvIv/ABDvLAALIAYpA2ghCCAGKQNgIQkgBikDWCEKIAYpA1ALIQsgBkFAayACIAMgBCAFIAcpAwAgBykDCCAHKQMQIAcpAxgQmggCQCAGLQBAQQFGBEAgBi0AQQRAIAZBOGpCADcDACAGQTBqQgA3AwAgBkIANwMoIAZCADcDIAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakHMi/8AEO8sAAsgBiAGKQOIATcDOCAGIAYpA4ABNwMwIAYgBikDeDcDKCAGIAYpA3A3AyALIAZB2ABqQgA3AwAgBkHQAGpCADcDACAGQgA3A0ggBkIANwNAAkACQAJAIAYgBkFAaxD7GyIHQf8BcUECRyAHwEEATnFFBEAgBkEgaiABKAIIEPsbwEEATA0BDAILIAZBIGogASgCBBD7GyIBQf8BcUECRiABwEEASHINASAIIAkgC0IBfCIEIAogBFCtfCIChFCtfCIFIAlUrXwhCAwCCyALQgF9IQQgCiALUK19IQIgCSAKIAuEUK0iA30hBSAIIAMgCVatfSEIDAELIAkhBSALIQQgCiECCyAAIAQgAiAFIAgQ1iMgBkGQAWokAAuTAwEBfyMAQUBqIgQkAAJAAkACQAJAAkACQCAAKAIAKAIALQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AgwgAiAAQQR2IgBJDQMMBAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NA0HYm4QBELI7AAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NAkGsnIQBELI7AAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NAUH8nIQBELI7AAsgBEEYaiIAIAEoAhAgAkEEdGoiAUEIaikDADcDACAEIAEpAwA3AxAgBCAANgIwIANBwI6EAUEUQdSOhAFBBiAEQRBqIgBB8I2EAUGfjoQBQQQgAEEEckHwjYQBQdqOhAFBCyAEQTBqQbCOhAEQiRcgBEFAayQADwsgBCAANgIsIARBAjYCFCAEQbiXhAE2AhAgBEICNwIcIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIYIAQgBEEsajYCOCAEIARBDGo2AjAgBEEQakHIl4QBEO8sAAuPBAEGfyADIAMgAkEDakF8cSACayIIa0EHcUEAIAMgCE8bIgVrIQkCfwJAAkAgAyAFTwRAAkAgBUUNAAJ/IAVBAWsgAiADaiIGQQFrIgQtAAAgAUH/AXFGDQAaIAIgCWoiByAERg0BIAVBAmsgBkECayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUEDayAGQQNrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQRrIAZBBGsiBC0AACABQf8BcUYNABogBCAHRg0BIAVBBWsgBkEFayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUEGayAGQQZrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQdrIAZBB2siBC0AACABQf8BcUYNABogBCAHRg0BIAVBeHILIAlqIQQMAwsgCCADIAMgCEsbIQYgAUH/AXFBgYKECGwhBQNAIAYgCSIESQRAIARBCGshCUGAgoQIIAIgBGoiB0EIaygCACAFcyIIayAIckGAgoQIIAdBBGsoAgAgBXMiCGsgCHJxQYCBgoR4cUGAgYKEeEYNAQsLIAMgBEkNASACQQFrIQMgAUH/AXEhAgNAQQAgBEUNBBogAyAEaiEBIARBAWshBCACIAEtAABHDQALDAILIAkgA0Gw94kBEK87AAsgBCADQcD3iQEQsDsAC0EBCyEJIAAgBDYCBCAAIAk2AgALgwUCB38DfiMAQbABayIDJAAgAUHsBGogAkEBIAIpAwAiCqdBCWsgCkIIWBsiBEECdEG4js8AaiIJKAIAai0AABDpHiABKALEBCEGAkACQCABKALIBCIFRQ0AIAYgBUEDdGoiB0EIayIIRQ0AIAdBA2stAABBgIYIIARBA3RB+P//B3F2QQNxRw0AIAdBBGstAAAgAiAEQQJ0QbiOzwBqKAIAai0AAEcNACAIIAgoAgBBAWo2AgAMAQsgBEEDdEGgjs8AaikDACEKIAIgCSgCAGoxAAAhCyABQcAEaiIEKAIAIAVGBH8gBEHIg88AEJsoIAEoAsQEBSAGCyAFQQN0aiALQiCGIAqEQgGENwIAIAEgBUEBajYCyAQLIAEoArAEIQUgASgCtAQhBCADQShqIgYgAkGIAfwKAAAgA0EIaiAFIAYgBCgCDBEBACADKAIcIQIgAygCGCEFIAMpAxAhCyADKQMIIQoCQCADLQAkIgRBBEYEQCAAIAI2AhQgACAFNgIQIAAgCzcDCCAAIAo3AwAMAQsgAzUCICEMIAEoAoAEQYCAgIB4RwRAIAFB+ANqIAogAhCtIAsgASABKQOYAiAFrXw3A5gCIAEgASkDoAIgAq18NwOgAiABIAEpA4gCIAt8NwOIAgJAAn8CQAJAAkACQCAEQQFrDgIFAAELIAEpA6gBUEUNASABQgE3A6gBQbABDAMLIAEgASkDqAIgDHw3A6gCIAEpA7gBUA0BDAMLIANBADYCOCADQQE2AiwgA0G4hM8ANgIoIANCBDcCMCADQShqQcCEzwAQ7ywACyABQgE3A7gBQcABCyABaiAKNwMACyAAQQg2AgALIANBsAFqJAAL9QQCB38DfiMAQbABayIDJAAgAUGgBWogAkEBIAIpAwAiCqdBCWsgCkIIWBsiBEECdEG4js8AaiIJKAIAai0AABDpHiABKAL4BCEGAkACQCABKAL8BCIFRQ0AIAYgBUEDdGoiB0EIayIIRQ0AIAdBA2stAABBgIYIIARBA3RB+P//B3F2QQNxRw0AIAdBBGstAAAgAiAEQQJ0QbiOzwBqKAIAai0AAEcNACAIIAgoAgBBAWo2AgAMAQsgBEEDdEGgjs8AaikDACEKIAIgCSgCAGoxAAAhCyABQfQEaiIEKAIAIAVGBH8gBEHIg88AEJsoIAEoAvgEBSAGCyAFQQN0aiALQiCGIAqEQgGENwIAIAEgBUEBajYC/AQLIAEoAsAEIQUgASgCxAQhBCADQShqIgYgAkGIAfwKAAAgA0EIaiAFIAYgBCgCDBEBACADKAIcIQIgAygCGCEFIAMpAxAhCyADKQMIIQoCQCADLQAkIgRBBEYEQCAAIAI2AhQgACAFNgIQIAAgCzcDCCAAIAo3AwAMAQsgAzUCICEMIAEoApAEQYCAgIB4RwRAIAFBiARqIAogAhCtIAsgASABKQNQIAWtfDcDUCABIAEpA1ggAq18NwNYIAEgASkDQCALfDcDQAJAAn8CQAJAAkACQCAEQQFrDgIFAAELIAEpAwBQRQ0BIAFCATcDAEEIDAMLIAEgASkDYCAMfDcDYCABKQMQUA0BDAMLIANBADYCOCADQQE2AiwgA0G4hM8ANgIoIANCBDcCMCADQShqQcCEzwAQ7ywACyABQgE3AxBBGAsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBiAVqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgC4AQhBgJAAkAgASgC5AQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHcBGoiBCgCACAFRgR/IARByIPPABCbKCABKALgBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AuQECyABKAKoBCEFIAEoAqwEIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKAL4A0GAgICAeEcEQCABQfADaiAKIAIQrSALIAEgASkDgAIgBa18NwOAAiABIAEpA4gCIAKtfDcDiAIgASABKQPwASALfDcD8AECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOwAVBFDQEgAUIBNwOwAUG4AQwDCyABIAEpA5ACIAx8NwOQAiABKQPAAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwPAAUHIAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFB8ARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgCyAQhBgJAAkAgASgCzAQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHEBGoiBCgCACAFRgR/IARByIPPABCbKCABKALIBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AswECyABKAKYBCEFIAEoApwEIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKALoA0GAgICAeEcEQCABQeADaiAKIAIQrSALIAEgASkDmAIgBa18NwOYAiABIAEpA6ACIAKtfDcDoAIgASABKQOIAiALfDcDiAICQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOoAVBFDQEgAUIBNwOoAUGwAQwDCyABIAEpA6gCIAx8NwOoAiABKQO4AVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwO4AUHAAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBwARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgCmAQhBgJAAkAgASgCnAQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUGUBGoiBCgCACAFRgR/IARByIPPABCbKCABKAKYBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2ApwECyABKAL4AyEFIAEoAvwDIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKALIA0GAgICAeEcEQCABQcADaiAKIAIQrSALIAEgASkD+AEgBa18NwP4ASABIAEpA4ACIAKtfDcDgAIgASABKQPoASALfDcD6AECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOYAVBFDQEgAUIBNwOYAUGgAQwDCyABIAEpA4gCIAx8NwOIAiABKQOoAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwOoAUGwAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBnARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgC9AMhBgJAAkAgASgC+AMiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHwA2oiBCgCACAFRgR/IARByIPPABCbKCABKAL0AwUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AvgDCyABKALgAyEFIAEoAuQDIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKAKwA0GAgICAeEcEQCABQagDaiAKIAIQrSALIAEgASkD2AEgBa18NwPYASABIAEpA+ABIAKtfDcD4AEgASABKQPIASALfDcDyAECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOIAVBFDQEgAUIBNwOIAUGQAQwDCyABIAEpA+gBIAx8NwPoASABKQOYAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwOYAUGgAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC5wEAgZ/CH4jAEHwAGsiBiQAIAAgASADahCOLSAGIAQgBRDgHCAGQgA3A2ggBiABNgJgIAYgASACaiICNgJkAkACQAJAIAEgAk8NACACQQFrIQIgBigCWCEJIAYpAyAhDiAGKAJUIQggBigCUCEFIAYpA0AhDCAGKQMwIQ8gBigCECEDIAYpAwghDSAGKAIoIQogBigCGCELIAYpA0ghESAGKQM4IRIgBikDACEQA0AgEKdBAXEEf0EABUEBCyEEAkADQAJAAkACQCAERQRAIA1QRQ0BQgAhDUIAIRBBASEEDAQLAn4CQCAPQgJ9IhNCAVgEQCATp0EBaw0BDAULIA+nIA9QrUIBhiEPQQFxRQ0AIBIMAQsgDEIDUQRAQgMhDAwECyAFRSAFIAhGckUEQCAIQQhrIggpAwAMAQtBACEFIAxCAlEEQEICIQwMBAsgDKdCACEMQQFxRQ0DIBELIQ1CASEQIAlBQGoiCSEDDAELIAMgDXmnQT9zIgdqIQRCASAHrYYgDYUhDQwDC0EAIQQMAQsLIAsgDkIAUnFFDQIgCiAOeadBP3MiB2ohBEIBIAethiAOhSEOCyACIARPDQEgAiAAKAIIIgdPDQIgBCAHTw0DIAQgACgCBCIEaiACIARqLQAAOgAAIAEgAkkgAkEBayECDQALCyAGQfAAaiQADwsgAiAHQbCazwAQwyEACyAEIAdBwJrPABDDIQALpwgBE38jAEEgayINJAAgB0HUAWohFCAAKAIMIAAoAggiCmshCSAAKAIEIhUgACgCACITa0EDdSEMIAAoAhQhFiAAKAIQIRcgACgCGCEYIAMoAhwhDyATIBVGBH9BAQUgCSAMbkETSwshECADEMkrIQsjAEEQayIRJAAgAiABQYgI/AoAAAJ/AkAgCw0AIAlBBkEIQQNBCSAPayILIAtBA04bdCABKAKECCIOQQJGG0kNAEG6fyAFIAlB//8AS0EEQQMgCUH/B0sbaiILTQ0BGiARIA42AgwCQCAEIAtqIAUgC2sgCiAJQf8BQQsgFEGExAAgAiARQQxqIA9BB0siEkEBdCAPQQRJQQJ0QQAgCUGBCEkbciAQQQBHQQN0ciAIQQBHckHsCkHtCiAOQQJHIAtBA0dyIAlB/wFLcSIZGxEYACIIQQFrQYd/TQRAIAggCSAJIA9BByASG0EBa3ZrQQJrSQ0BCyACIAFBiAj8CgAADAELIBEoAgwhEgJAAkACQAJAAkAgCEEBRgRAIAlBB0sNASAJQQFrIQ4gCkEBaiEQIAotAAAhGgNAIA5FDQIgDkEBayEOIBAtAAAhGyAQQQFqIRAgGiAbRg0ACwsgEkUEQCACQQE2AoQIC0EDQQIgEhshCiALQQRrDgICAwELIAIgAUGICPwKAAAgBCAKIAkQ7iAMBQsgBCAJQQR0QQRBACAZG3IgCEEOdGoiCUEQdjoAAiAEIAkgCnI7AAAMAgsgBCAIQRJ0IAlBBHRqIApyQQhyNgAADAELIAQgCEEKdjoABCAEIAhBFnQgCUEEdGogCnJBDHI2AAALIAggC2oMAQsgBCAFIAogCRDmHAshCCARQRBqJAACQAJAAkAgCCIJQYh/Sw0AQbp/IQggBSAJa0EESA0AIAQgCWohCAJ/IAxB/wBNBEAgCCAMOgAAIAhBAWoMAQsgDEH//QFNBEAgCCAMOgABIAggDEEIdkGAAXI6AAAgCEECagwBCyAIQf8BOgAAIAggDEGA/gFrOwABIAhBA2oLIQkgAkGICGohCgJAIBMgFUYEQCAKIAFBiAhqQeAb/AoAAAwBCyANQQhqIAAgDCABQYgIaiAKIAlBAWoiASAEIAVqIgsgDyAHIBQQ8wogDSgCFCIIQYl/Tw0BIAkgDSgCDEEEdCANKAIIQQZ0aiANKAIQQQJ0ajoAACANKAIYIQAgASAIaiIBIAsgAWsgAkGMDmogFiAKIBggAkG4GWogFyATIAwgDSgCHBD9BiIIQYh/Sw0BIABBACAAIAhqQQRJGw0CIAEgCGohCQsgCSAEayIIRQ0BCyAIQbp/RiAFIAZPcQ0AIAhBiH9LDQEgCEEAIAggBiAGQQcgAygCHCIAIABBB00bQQFrdmtBAmtJGyEIDAELQQAhCAsgDUEgaiQAIAgL9AQCBH8CfiMAQTBrIgMkAAJAAkACQAJAIAEEQCAAKAIoIgJBAU0NASAAKAIkIgJBzAFqQQEQhxcCQAJAAkACQAJAIAAtADxBKEYEQCADIAAoAkAiAEEwajYCDCAALQAwQQNrDgMCAwQBCyADQQA2AiAgA0EBNgIUIANB0LCHATYCECADQgQ3AhggA0EQakHYsIcBEO8sAAsgA0EBNgIUIANBiLCHATYCECADQgE3AhwgA0GvAzYCLCADIANBKGo2AhggAyADQQxqNgIoIANBEGpBkLCHARDvLAALIAIQlBrBIAHBaiIAwSAARw0FIAIoAhgiAUECaiIEIAIoAhAiBUsEfyACQQxqIAVBAXQiASAEEOAqIgQgASAESxsQ6BkgAigCGAUgAQsgAigCFGogADsAACACIAIoAhhBAmo2AhgMAgsgAUEASCACEJIaIgAgAWoiASAASEcNBSACKAIYIgBBBGoiBCACKAIQIgVLBH8gAkEMaiAFQQF0IgAgBBDgKiIEIAAgBEsbEOgZIAIoAhgFIAALIAIoAhRqIAE2AAAgAiACKAIYQQRqNgIYDAELIAGtIgZCAFQgBiACEJMaIgZ8IgcgBlNHDQUgAigCGCIAQQhqIgEgAigCECIESwR/IAJBDGogBEEBdCIAIAEQ4CoiASAAIAFLGxDoGSACKAIYBSAACyACKAIUaiAHNwAAIAIgAigCGEEIajYCGAsgAiACKAJYQQFqNgJYCyADQTBqJAAPC0EBIAJBiK+HARDDIQALQaivhwFBEEGYr4cBEMskAAtBqK+HAUEQQbivhwEQyyQAC0Gor4cBQRBByK+HARDLJAALgAUCA38DfiMAQYABayIDJAAgASgCCCEFAkACQCAAAn8gASgCDCgCECACQQR0aiIEKQMAIgdCgICAgAh8IgZC/////w9WIAQpAwgiCCAGIAdUrXwiBkIAUiAGUBtFBEAgAyAFKAIAKAIAKAIAIgQ2AgggAyAHPgIUAkAgBKwgB8R+IgZCIIinIAanIgRBH3VHBEAgA0ECNgJkIANBrJD/ADYCYCADQgI3AmwgA0GCDDYCPCADQYIMNgI0IAMgA0EwajYCaCADIANBCGo2AjggAyADQRRqNgIwIANBzABqIANB4ABqEJkOIANBIGogA0HQAGopAgA3AwAgA0EoaiADQdgAaigCADYCACADQYiAgIB4NgJIIAMgAykCSCIGNwMYIAanQZOAgIB4Rw0BIAMoAhwhBAsgA0HgAGogBCAFKAIILQAAEOoPIAMoAmAiBUGTgICAeEYNAyADQRBqIANB8ABqKAIANgIAIAMgAykCaDcDCCADKAJkDAILIANBGGoQiBELIAUoAgQhASADIAg3AzggAyAHNwMwIANBzJH/ADYCSCADQgQ3AlQgA0GEDDYCfCADQfQLNgJ0IAMgAUEBajYCcCADQbsHNgJsIAMgATYCaCADQcwBNgJkIANB+JH/ADYCYCADIANB4ABqNgJQIAMgA0EwajYCeCADQQQ2AkwgA0EcaiADQcgAahCZDiADQRBqIANBKGooAgA2AgAgAyADKQIgNwMIQYKAgIB4IQUgAygCHAs2AgQgACAFNgIAIAAgAykDCDcCCCAAQRBqIANBEGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANBgAFqJAALrQQCA38DfiMAQYACayIFJAAgBCgCACEEAkACQAJAIAEoAgAiBy0AAEUNACAEKAJAIAQoAkQgAiADEMEuBEAgBy0AACEGDAELIAVBhAFqIARBPGoQ3SAgBUH4AGogBEEwahDDBiAELwFIIQYgBCkDKCEIIAVB0ABqIgEgBEEIahCxLiAFIAg3A3AgBSAGOwGQASAFQQhqIgQgASACIAMQshsgASAEIActAAAQlQEgBSgCUEUEQCAFQZgBaiICIAFBBHJBNPwKAABBPEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQQg2AgAgACABNgIEIAQQgy8MAwtBBEE8EKM9AAsgBUGsAWogBUHoAGopAwAiCDcCACAFQaQBaiAFQeAAaikDACIJNwIAIAUgBSkDWCIKNwKcASAAQRBqIAg3AgAgAEEIaiAJNwIAIAAgCjcCACAFQQhqEIMvDAELIAVB0ABqIARBCGogBkEBcRCVASAFKAJQBEAgBUHgAWogBUHoAGopAwAiCDcCACAFQdgBaiAFQeAAaikDACIJNwIAIAUgBSkDWCIKNwLQASAAQRBqIAg3AgAgAEEIaiAJNwIAIAAgCjcCAAwBCyAFQcwBaiICIAVB0ABqQQRyQTT8CgAAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAIABBCDYCACAAIAE2AgQLIAVBgAJqJAAPC0EEQTwQoz0AC48FAgJ/AX4jAEGAA2siCCQAIAggAzYCDCACKQAIIQogBCgCACIDIAMoAgAiCUEBajYCAAJAAkACQCAJQQBIDQAgCCADNgKkAiAIIAQpAgQ3AqgCAkAgCkIAVwRAIAMgAygCACIDQQFrNgIAIAhBADYCECADQQFHDQEgCEGkAmoQ+x4MAQsgCEEYaiAIQawCaigCADYCACAIIAgpAqQCNwMQCyACKAAAIQIgCEEcaiAGIAcQ0yMCQAJAAkACQCAIKAIMIgMtAAAiBkEbaw4EAQUCAQALIAZBJ0cNBAsgCEHEAmogAxDGBiAIQQA7AfwCIAhBADYC+AIgCEEANgLgAiAIQQA2AtQCIAggAjYC0AIgCEIENwK8AiAIQgA3ArQCIAhCgICAgMAANwKsAiAIQQA2AqQCIAVBAUsNAUEBQQFB/Nn+ABDDIQALIAhBxAJqIAMQxgYgCEEAOwH8AiAIQQA2AvgCIAhBADYC4AIgCEEANgLUAiAIIAI2AtACIAhCBDcCvAIgCEIANwK0AiAIQoCAgIDAADcCrAIgCEEANgKkAiAIQcgBaiICIAhBpAJqIAhBHGoQ7yUMAwsgBCgCDCICIAIoAgAiA0EBajYCACADQQBIDQAgCCACNgK8ASAIIAQpAhA3AsABIAhByAFqIgMgCEGkAmoiAiAIQbwBahD6IyACIAMgCEEcahDvJQwCCwALIAhBATYCqAIgCEHc2v4ANgKkAiAIQgE3ArACIAhBrwM2AswBIAggCEHIAWo2AqwCIAggCEEMajYCyAEgCEGkAmpB5Nr+ABDvLAALIAhB4ABqIAIgCEEQahCuFiAIIAo+AmQgCEEBNgJgIAAgASAIQeAAahDLECAIQYADaiQAC+gEAgN/An4jAEHgAGsiBCQAIARBQGsgAkEIaigCADYCACAEQQA2AkQgBCACKQIANwM4AkAgAwR/IAMoAgAiAiACKAIAIgVBAWo2AgAgBUEASA0BIAMoAgQhBUEgBUEpCyEDIAQgBTYCVCAEIAI2AlAgBCADOgBMIARBADYCWCABKAIYIgEgASgCACICQQFqNgIAIAJBAEgNACAEIAE2AlwgBEEYaiAEQThqIgEgBEHcAGoiAiAEQcwAahDSASABEIYwIAQoAlwiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQgyALIARBJWohASAELQAkIQICQCAEKAIYIgNBgoCAgHhGBEAgBEEWaiABQQJqLQAAIgM6AAAgBCABLwAAIgE7ARQgBCgCICEFIAQpAyghByAEKQMwIQggAEEPaiADOgAAIAAgATsADSAAIAg3AxggACAHNwMQIAAgAjoADCAAIAU2AgggAEGCgICAeDYCAAwBCyAEQRZqIgYgAUECai0AADoAACAEIAEvAAA7ARQgA0GBgICAeEcEQCACQSBGBEAgBCkCHCEHIAQoAiwhAiAEKQMwIQggBCgCKCIBIAEoAgAiBUEBajYCACAFQQBIDQMgACAELwEUOwANIAAgAjYCJCAAIAE2AiAgACAINwMYIAAgAjYCFCAAIAE2AhAgAEEgOgAMIAAgBzcCBCAAIAM2AgAgAEEPaiAGLQAAOgAADAILQZjEzwBBKEHo2c8AEJ8pAAsgBEEIahDBLCAEKAIIIQEgACAEKAIMNgIkIAAgATYCICAAQYGAgIB4NgIACyAEQeAAaiQADwsAC4wKAgh/AX4jAEGQAWsiAyQAIAMgAjYCBCADQegAaiABEI8nIAMoAnAhBCADKAJsIQECQCADKAJoIgVBk4CAgHhHBEAgACADKQJ0NwIMIAAgBDYCCCAAIAE2AgQgACAFNgIADAELIANCADcCGCADIAEgBEECdGo2AgwgAyADQQRqNgIUAkACQCAEBEAgA0EcaiEEIANBGGohBSADQQE2AhAgAyABQQRqNgIIIANBADYCSCADIAE2AkwCfyABKAIAIgFBAEgEQCADQQI2AmwgA0HE/oYBNgJoIANCAjcCdCADQTs2AowBIANBqQg2AoQBIAMgA0GAAWo2AnAgAyADQcgAajYCiAEgAyADQcwAajYCgAEgA0HUAGogA0HoAGoQmQ4gA0HEAGogA0HgAGooAgA2AgAgAyADKQJYNwI8IAMoAlQMAQsgASACTQ0CIANBAzYCVCADQeD9hgE2AlAgA0IDNwJcIANBOzYCfCADQakINgJ0IANBOzYCbCADIANB6ABqNgJYIAMgA0EEajYCeCADIANBzABqNgJwIAMgA0HIAGo2AmggA0E4aiADQdAAahCZDiADKAI4CyEBIAMgAykCQDcCLCADIAMoAjw2AiggAyABNgIkIANBjYCAgHg2AiAgA0EgahCIEQwCCyAAQZOAgIB4NgIADAILIAMgATYCGAsgAyAFNgJUIAMgBDYCUCADIANBNGo2AlggA0HoAGohBSADQdAAaiEGIwBB8ABrIgEkAAJAAn8CQCADQQhqIgQoAgAiAiAEKAIEIgpHBEAgBigCBCEIIAQoAgwhCSAEKAIIIQYDQCABIAY2AjggASACNgJUIAIoAgAiB0EASARAIAQgAkEEajYCACABQQI2AlwgAUGAh4cBNgJYIAFCAjcCZCABQTs2AiwgAUGpCDYCJCABIAFBIGo2AmAgASABQThqNgIoIAEgAUHUAGo2AiAgAUFAayABQdgAahCZDiABQRxqIAFBzABqKAIANgIAIAEgASkCRDcCFCABKAJAIQIMAwsgCSgCACAHSQRAIAQgAkEEajYCACABQQM2AkAgAUGchocBNgI8IAFCAzcCSCABQTs2AmwgASAJNgJoIAFBqQg2AmQgAUE7NgJcIAEgAUHYAGo2AkQgASABQdQAajYCYCABIAFBOGo2AlggAUEQaiABQTxqEJkOIAEoAhAhAgwDCyABIAg2AjQgByAIKAIASQRAIAQgAkEEajYCACABIAc2AjggASAGQQFrNgJUIAFBAzYCQCABQcyHhwE2AjwgAUIDNwJIIAFBOzYCbCABQf8bNgJkIAFBOzYCXCABIAFB2ABqNgJEIAEgAUE4ajYCaCABIAFBNGo2AmAgASABQdQAajYCWCABQSRqIAFBPGoQmQ4gASgCMCEHIAEoAighCCABKAIkIQIgASgCLAwECyAIIAc2AgAgBCAGQQFqIgY2AgggAkEEaiICIApHDQALIAQgAjYCAAsgBUGUgICAeDYCAAwCCyABKQIYIgtCIIinIQcgASgCFCEIIAunCyEJIAUgBzYCECAFIAk2AgwgBSAINgIIIAUgAjYCBCAFQY2AgIB4NgIAIAQgBkEBajYCCAsgAUHwAGokACADKAJoQZSAgIB4RwRAIAAgAykCaDcCACAAQRBqIANB+ABqKAIANgIAIABBCGogA0HwAGopAgA3AgAMAQsgAEGTgICAeDYCAAsgA0GQAWokAAuaCgIIfwF+IwBBkAFrIgMkACADIAI2AgQgA0HoAGogARCQJyADKAJwIQQgAygCbCEBAkAgAygCaCIFQZOAgIB4RwRAIAAgAykCdDcCDCAAIAQ2AgggACABNgIEIAAgBTYCAAwBCyADQgA3AhggAyABIARBA3RqNgIMIAMgA0EEajYCFAJAAkAgBARAIANBHGohBCADQRhqIQUgA0EBNgIQIAMgAUEIajYCCCADQQA2AkggAyABNgJMAn8gASkDACILQoCAgIAQWgRAIANBAjYCbCADQcT+hgE2AmggA0ICNwJ0IANBOzYCjAEgA0HHEDYChAEgAyADQYABajYCcCADIANByABqNgKIASADIANBzABqNgKAASADQdQAaiADQegAahCZDiADQcQAaiADQeAAaigCADYCACADIAMpAlg3AjwgAygCVAwBCyACIAunIgFPDQIgA0EDNgJUIANB4P2GATYCUCADQgM3AlwgA0E7NgJ8IANBxxA2AnQgA0E7NgJsIAMgA0HoAGo2AlggAyADQQRqNgJ4IAMgA0HMAGo2AnAgAyADQcgAajYCaCADQThqIANB0ABqEJkOIAMoAjgLIQEgAyADKQJANwIsIAMgAygCPDYCKCADIAE2AiQgA0GNgICAeDYCICADQSBqEIgRDAILIABBk4CAgHg2AgAMAgsgAyABNgIYCyADIAU2AlQgAyAENgJQIAMgA0E0ajYCWCADQegAaiEFIANB0ABqIQYjAEHwAGsiASQAAkACfwJAIANBCGoiBCgCACICIAQoAgQiCkcEQCAGKAIEIQcgBCgCDCEJIAQoAgghBgNAIAEgBjYCOCABIAI2AlQgAikDACILQoCAgIAQWgRAIAQgAkEIajYCACABQQI2AlwgAUGAh4cBNgJYIAFCAjcCZCABQTs2AiwgAUHHEDYCJCABIAFBIGo2AmAgASABQThqNgIoIAEgAUHUAGo2AiAgAUFAayABQdgAahCZDiABQRxqIAFBzABqKAIANgIAIAEgASkCRDcCFCABKAJAIQIMAwsgC6ciCCAJKAIASwRAIAQgAkEIajYCACABQQM2AkAgAUGchocBNgI8IAFCAzcCSCABQTs2AmwgASAJNgJoIAFBxxA2AmQgAUE7NgJcIAEgAUHYAGo2AkQgASABQdQAajYCYCABIAFBOGo2AlggAUEQaiABQTxqEJkOIAEoAhAhAgwDCyABIAc2AjQgCCAHKAIASQRAIAQgAkEIajYCACABIAg2AjggASAGQQFrNgJUIAFBAzYCQCABQcyHhwE2AjwgAUIDNwJIIAFBOzYCbCABQf8bNgJkIAFBOzYCXCABIAFB2ABqNgJEIAEgAUE4ajYCaCABIAFBNGo2AmAgASABQdQAajYCWCABQSRqIAFBPGoQmQ4gASgCMCEHIAEoAighCCABKAIkIQIgASgCLAwECyAHIAg2AgAgBCAGQQFqIgY2AgggAkEIaiICIApHDQALIAQgAjYCAAsgBUGUgICAeDYCAAwCCyABKQIYIgtCIIinIQcgASgCFCEIIAunCyEJIAUgBzYCECAFIAk2AgwgBSAINgIIIAUgAjYCBCAFQY2AgIB4NgIAIAQgBkEBajYCCAsgAUHwAGokACADKAJoQZSAgIB4RwRAIAAgAykCaDcCACAAQRBqIANB+ABqKAIANgIAIABBCGogA0HwAGopAgA3AgAMAQsgAEGTgICAeDYCAAsgA0GQAWokAAu9BAEHfyMAQUBqIgMkAAJAIAEoAjgiBCACIAIgBEsbIgdFBEAgAEIINwMADAELIAEoAgAgAUEANgIAQQFGBEAgASABKAIENgJUIAEgBEEBazYCOEEBIQYLIANBIDYCBCADQQhqQQBBIEGEqM0AELMVAkACQAJAAkAgBiAHSQRAIAFBCGohCSABKAJQIQIDQAJAIAINACADQRhqIAEQwQkgAygCGCICQQhGDQAgACADKQIcNwIEIABBFGogA0EsaigCADYCACAAQQxqIANBJGopAgA3AgAMBgsgASgCTCIFIAEoAjAiAk8NAiAHIAZrIgIgASgCUCIEIAIgBEkbIgQgAygCECICSw0DIAMgCSADKAIMIgIgBCABKAIsIAVqLQAAELkGIgU2AhQgBCAFRw0EIAQEQCAEQQJ0IQggASgCVCEFA0AgAiABKAJEIAIoAgAgBWpqIgU2AgAgASAFNgJUIAJBBGohAiAIQQRrIggNAAsLIAEgASgCUCAEayICNgJQIAEgASgCOCAEazYCOCAEIAZqIgYgB0kNAAsLIABBCDYCACAAIAc2AgQgA0EIahDpOwwECyAFIAJBlKjNABDDIQALIAQgAkGkqM0AELA7AAsgA0EDNgIcIANB5KjNADYCGCADQgI3AiQgA0E7NgI8IANBOzYCNCADIANBMGo2AiAgAyADQRRqNgI4IAMgA0EEajYCMCAAQQRqIANBGGoQmQ5BACECCyAAIAI2AgAgA0EIahDpOwsgA0FAayQAC78EAgZ/AX4jAEFAaiIDJAACQCABKAJQIgQgAiACIARLGyIHRQRAIABCCDcDAAwBCyABKAIAIAFCADcDAEEBRgRAIAEgASkDCDcDOCABIARBAWs2AlBBASEGCyADQcAANgIEIANBCGpBwABBhKjNABC2FQJAAkACQAJAIAYgB0kEQCABQRBqIQggASgCZCECA0ACQCACDQAgA0EYaiABEI0LIAMoAhgiAkEIRg0AIAAgAykCHDcCBCAAQRRqIANBLGooAgA2AgAgAEEMaiADQSRqKQIANwIADAYLIAEoAmAiBSABKAJIIgJPDQIgByAGayICIAEoAmQiBCACIARJGyIEIAMoAhAiAksNAyADIAggAygCDCICIAQgASgCRCAFai0AABCQBCIFNgIUIAQgBUcNBCAEBEAgBEEDdCEFIAEpAzghCQNAIAIgASkDMCACKQMAIAl8fCIJNwMAIAEgCTcDOCACQQhqIQIgBUEIayIFDQALCyABIAEoAmQgBGsiAjYCZCABIAEoAlAgBGs2AlAgBCAGaiIGIAdJDQALCyAAQQg2AgAgACAHNgIEIANBCGoQ4zwMBAsgBSACQZSozQAQwyEACyAEIAJBpKjNABCwOwALIANBAzYCHCADQeSozQA2AhggA0ICNwIkIANBOzYCPCADQTs2AjQgAyADQTBqNgIgIAMgA0EUajYCOCADIANBBGo2AjAgAEEEaiADQRhqEJkOQQAhAgsgACACNgIAIANBCGoQ4zwLIANBQGskAAvpBAIHfwF+IwBBEGsiAyQAAkAgAC8BDCICRQRAIAAoAgAgACgCBCABEOQJIQEMAQsgA0EIaiABQQhqKQIANwMAIAMgASkCADcDAAJAAn8gACkCCCIJpyIGQYCAgAhxRQRAIAMoAgQMAQsgACgCACADKAIAIAMoAgQiASAAKAIEKAIMEQYADQEgACAGQYCAgP95cUGwgICAAnIiBjYCCCADQgE3AwAgAiABQf//A3FrIgFBACABIAJNGyECQQALIQcCQCADKAIMIghFBEAMAQsgAygCCCEBA0ACfwJAAkACQAJAIAEvAQBBAWsOAgECAAsgAUEEaigCAAwDCyABQQJqLwEAIgUNAUEBDAILIAFBCGooAgAMAQsgBUH2/xdqIAVBnP8fanEgBUGY+DdqIAVB8LEfanFzQRF2QQFqCyEFIAFBDGohASAEIAVqIQQgCEEBayIIDQALCwJAIAQgB2oiASACQf//A3FJBEAgAiABayEEQQAhAUEAIQICQAJAAkAgBkEddkEDcUEBaw4DAAEAAgsgBCECDAELIARB/v8DcUEBdiECCyAGQf///wBxIQggACgCBCEFIAAoAgAhBwNAIAFB//8DcSACQf//A3FPDQIgAUEBaiEBIAcgCCAFKAIQEQIARQ0ACwwCCyAAKAIAIAAoAgQgAxDkCSEBIAAgCTcCCAwCCyAHIAUgAxDkCQ0AQQAhBiAEIAJrQf//A3EhAgNAAkAgBkH//wNxIgQgAkkhASACIARNDQAgBkEBaiEGIAcgCCAFKAIQEQIARQ0BCwsgACAJNwIIDAELQQEhAQsgA0EQaiQAIAELsAQBDn8jAEEgayIIJAACQCABQYCAAksiDQ0AIAAoAhwiBUECdCEGIAAoAhghCQJAIAVFDQAgAC8BOCEKIAYhAiAJIQMDQCADLwEAQf//A0cEQCAEIANBAmovAQAgCnFrIApxRQ0CCyADQQRqIQMgBEEBaiEEIAJBBGsiAg0AC0EAIQQLIAhBFGoiAyABQfjhwwAQsTYgCEEIaiADQYjiwwAQliEgCCgCCCELIAgoAgwhByAAIAFBAWsiDDsBOCAAIAc2AhwgACALNgIYAkACQCAEIAVNBEAgCSAEQQJ0aiEKIAQgBUYNAiAGIAlqIQYgCiEBA0AgAS8BACIOQf//A0cEQCAMIAEvAQIiD3EhAgNAIAIhA0EAIQIgAyAHTw0AIAsgA0ECdGoiAi8BAEH//wNHBEAgA0EBaiECDAELCyACIA87AQIgAiAOOwEACyAGIAFBBGoiAUcNAAsMAQsgBCAFQZjiwwAQrzsACyAAKAIcIQcLIAQEQCAAKAIYIQYgAC8BOCEEIAkhAQNAIAEvAQAiC0H//wNHBEAgBCABLwECIgxxIQIDQCACIQNBACECIAMgB08NACAGIANBAnRqIgIvAQBB//8DRwRAIANBAWohAgwBCwsgAiAMOwECIAIgCzsBAAsgAUEEaiIBIApHDQALCyAAQSBqIAAoAigiACAHIAAgB0ECdmprQQRBNEGo4sMAEMMoIAVFDQAgCSAFQQJ0QQIQ+DoLIAhBIGokACANC/uRAwMpfwN+AXwjAEHQAWsiGiQAIAEgASgCECACKAIQajYCECABKAIEISMgASgCCCEEIBpBEGogASgCDEEIahDDNCAaKAIQIQEgGigCFCEGIBpBCGogAhDcOyAaQfAAaiABIAEgBkECdGogGigCCCIBIAEgGigCDEEDdGoQySICQAJAAkAgGigCgAEiAiAaKAKEASImTw0AICMgBEG4BWxqIScgGigCeCEoIBooAnAhKSAaQfQAaiEqA0AgGkHwAGohCSApIAJBAnRqKAIAQQhqIQojAEEgayIEJAAgBEEIaiEGIwBB4AFrIgEkACABQZgBaiAKQQBBACAoIAJBA3RqIgoQtgECQCABKAKYASILQYSAgIB4RgRAIAFB5ABqIAFBsAFqKQMAIiw3AgAgAUHcAGogAUGoAWopAwAiLTcCACABIAEpA6ABIi43AlQgBkEQaiAsNwIAIAZBCGogLTcCACAGIC43AgAMAQsgAUHoAGoiECABQbQBaigCADYCACABQeAAaiITIAFBrAFqKQIANwMAIAFB2ABqIhEgAUGkAWopAgA3AwAgASABKQKcATcDUCABQfAAaiIDIAFBuAFqQSj8CgAAIAFBFGogESkDADcCACABQRxqIBMpAwA3AgAgAUEkaiAQKAIANgIAIAEgCzYCCCABIAEpA1A3AgwgAUEoaiADQSj8CgAAIAFBCGoiC0EAIAoQ9C0QmQIgAUGYAWoiCiALQcgA/AoAACAGQQRqIAoQygsgBkEINgIACyABQeABaiQAIAQoAhQhBiAEKAIQIQEgBCgCDCEKAkAgBCgCCCIDQQhHBEAgCSAEKQMYNwMQIAkgBjYCDCAJIAE2AgggCSAKNgIEDAELIAQgCjYCECAEIAE2AgwgBCABNgIIIAQgASAGQcgAbGo2AhQgBEEIaiIBKAIIIRcgASgCACIQIQogASgCBCIGIAEoAgwiC0cEQANAIAogBkHIAPwKAAAgCkHIAGohCiAGQcgAaiIGIAtHDQALIAEgBjYCBAsjAEEQayILJAAgAUEANgIIIAEoAgwhEyABKAIEIQYgAUEENgIAIAtCgICAgMAANwIIIAtBCGpBBEHIABDgHiABQQQ2AgwgAUEENgIEIBMgBmtByABuIREgBiATRwRAA0AgBhDCICAGQcgAaiEGIBFBAWsiEQ0ACwsgC0EQaiQAIAlBBGoiBiAQNgIEIAYgFzYCACAGIAogEGtByABuNgIIIAEQ5yALIAkgAzYCACAEQSBqJAAgGigCfCEEIBooAnghASAaKAJ0IQYgGigCcCIJQQhHBEAgACAaKQOAATcDECAAIAQ2AgwgACABNgIIIAAgBjYCBCAAIAk2AgAMAwsgGiAGNgIkIBogATYCICAaIAE2AhwgGiABIARByABsajYCKAJAAkAgBEUNAANAIBogAUHIAGo2AiAgASgCACEEIBpBLGoiBiABQQRqQcQA/AoAACAEQYCAgIB4Rg0BIBogBDYCcCAqIAZBxAD8CgAAICMgJ0YNAiAaQbgBaiEhIBpB8ABqIishC0EAIQlBACEDQgAhLEEAIREjAEHgAWsiByQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAICMiBikDAEICUQRAIAsoAiQgCygCKCIEKAIIQQFrQXhxakEIaiEKIAsoAgghBSALKAIEIQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAghBAWsOBwECAwQFBgcACyAKIAQQxS8hCiAHQdAAaiAFQQBBAUEBEKAYIAcoAlQhBCAHKAJQQQFGDS8gB0EANgK8ASAHIAcoAlg2ArgBIAcgBDYCtAEgBQRAIAVBAnQhCQNAIAogASgCABCEGiEQIAcoArwBIgQgBygCtAFGBEAgB0G0AWpB6PHPABCjKAsgAUEEaiEBIAcoArgBIARqIBA6AAAgByAEQQFqNgK8ASAJQQRrIgkNAAsLIAdB2ABqIAdBvAFqKAIAIhQ2AgAgByAHKQK0ATcDUCAHQThqIQwgBkEQaiEOIAcoAlQhFiALKAIQQQAgCygCDEGAgICAeEcbIRUgCygCFCEBIAsoAhxBACALKAIYQYCAgIB4RxshEiALKAIgIRcjAEEwayIIJAACQAJAIBVBACASG0UEQCAUIRAgFUUNASABIRAMAQsgFyABIhBGDQAgCCABNgIAIAggFzYCBCAIQQI2AhwgCEGI/s4ANgIYIAhCAjcCJCAIQTs2AhQgCEE7NgIMIAggCEEIajYCICAIIAhBBGo2AhAgCCAINgIIIAxBBGogCEEYahCZDiAMQQA2AgAMAQsgDigCgAFFBEAgDkIANwOwAQsgDkIANwOoAQJAAkACQCAQBEAgDigCmAQoApQBIRkDQAJAIBJFIAMgGWoiBCAQIAQgEEkbIhMgF09yDQAgEiATQQF0aiEEA0AgBC8BAEUNASAEQQJqIQQgFyATQQFqIhNHDQALIBchEwtBACEEQQAhCiAVBEAgAyATSw0DIAEgE0kNVCAVIANBAXRqIQoLIBIEQCADIBNLDQQgEyAXSw0FIBIgA0EBdGohBAsgCEEYaiEFIAohCSMAQUBqIg0kACATIANrIgshDwJAAkAgDigClAQiAy4BGCIGQQBKBH8gCUUEQCANQQE2AhwgDUH4/84ANgIYIA1CATcCJCANQc0BNgI4IA0gBjsBPiANIA1BNGo2AiAgDSANQT5qNgI0IA1BBHIgDUEYahCZDiAFIA0pAgw3AgwgBUEUaiANQRRqKAIANgIAIAUgDSkCBDcCBCAFQQA2AgAMAwtBACEPIAsEQCAGQf//A3EhAyAJIQYgCyEKA0AgDyAGLwEAIANGaiEPIAZBAmohBiAKQQFrIgoNAAsLIA4gDikDgAMgCyAPa618NwOAAyAOKAKUA0GAgICAeEcEQCAOQZQDaiAJIAsQ1yELIA5B/ANqIAkgCxD4KSAOKAKUBAUgAwsuARoiBkEATARAIA4gDigCpAMgC2o2AqQDDAELIAQEQCALBEAgBC8BAARAIA1BATYCHCANQZD/zgA2AhggDUIBNwIkIA1BzQE2AgQgDSAENgIAIA0gDTYCICAFQQRqIA1BGGoQmQ4gBUEANgIADAQLIAtBAXQhAyAOKAKkAyEKIAQhBgNAIAogBi8BAEVqIQogBkECaiEGIANBAmsiAw0ACyAOIAo2AqQDCyAOKAKIA0GAgICAeEcEQCAOQYgDaiAEIAsQ1yELIA5BiARqIAQgCxD4KQwBCyANQQE2AhwgDUHAgM8ANgIYIA1CATcCJCANQc0BNgI4IA0gBjsBPiANIA1BNGo2AiAgDSANQT5qNgI0IA1BBHIgDUEYahCZDiAFIA0pAgw3AgwgBUEUaiANQRRqKAIANgIAIAUgDSkCBDcCBCAFQQA2AgAMAQsgDUEYaiEGIwBB0ABrIgQkACAOIA4oAoABIA9qNgKAASAEIA82AgQCQCAPIA8gEWoiCU0gCSAUTXFFBEAgBCAUIBFrNgI8IARBAjYCKCAEQYiJzgA2AiQgBEICNwIwIARBOzYCTCAEQTs2AkQgBCAEQUBrNgIsIAQgBEE8ajYCSCAEIARBBGo2AkAgBEEIakEEciAEQSRqEJkOIAYgBCkCFDcCDCAGQRRqIARBHGooAgA2AgAgBiAEKQIMNwIEIAZBADYCAAwBCyAGIA4gESAWaiAPELgRCyAEQdAAaiQAIA0oAhgiBEEIRwRAIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCyAOIA4oAqADIAtqIgQ2AqADAkAgBEUNACAOKAKkAyAOKAKYBCIEKAKQAUkEQCAOELwcIAQoAowBSQ0BCyANQRhqIA4Q5gEgDSgCGCIEQQhGDQAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELAkAgDigCWEGAgICAeEYNACAOKAJMIA4oApgEQQhqIA4oApQEQQhqENARSQ0AIA1BGGohCSMAQcABayIGJAACQAJAIA4oAqADRQ0AIAZBIGogDhDmASAGKAIgIgRBCEYNACAJIAYpAiQ3AgQgCUEUaiAGQTRqKAIANgIAIAlBDGogBkEsaikCADcCACAJIAQ2AgAMAQsgBkEgaiAOEI8HIAYoAiAiBEEIRwRAIAkgBikCJDcCBCAJQRRqIAZBNGooAgA2AgAgCUEMaiAGQSxqKQIANwIAIAkgBDYCAAwBCwJAAkAgDigCoANFDQAgBkGoAWogDhDmASAGKAKoASIEQQhGDQAMAQsCQCAOKAKsAiIERQ0AIAZBKGohCgNAIA4gBEEBazYCrAIgDiAOKAKoAiIEQQFqIgsgDigCoAIiA0EAIAMgC00bazYCqAIgDigCpAIgBEGIAWxqIgQpAwAiLEIMUQ0BIAYgLDcDICAKIARBCGpBgAH8CgAAIAZBqAFqIA4gBkEgahCpCiAGKAKoASIEQQhHDQIgDigCrAIiBA0ACwsgCUEINgIADAELIAZBGGoiCiAGQbwBaigCADYCACAGQRBqIgsgBkG0AWopAgA3AwAgBiAGKQKsATcDCCAJIAQ2AgAgCSAGKQMINwIEIAlBDGogCykDADcCACAJQRRqIAooAgA2AgALIAZBwAFqJAAgDSgCGCIEQQhGDQAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELIAVBCDYCACAFIA82AgQLIA1BQGskACAIKAIcIQQgCCgCGCIGQQhHBEAgDCAIKQMgNwMIIAxBEGogCEEoaikDADcDACAMIAQ2AgQgDCAGNgIADAYLIAQgEWohESAQIBMiA0sNAAsLIAxBCDYCACAMIBE2AgQMAwsgAyATQZj+zgAQsTsACyADIBNBqP7OABCxOwALDFcLIAhBMGokACAHQdAAahDeOwxGCyAGQRBqIQECQCAKIAQoAhwRBAAiCS0AACIGQSJrDgUICQoLDAALIAZBCEYNBiAGQQ9GDQwgB0HQAGoiCSAKIARBsO7PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEYNEiAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDEULIAZBEGohAQJAIAogBCgCHBEEACIJLQAAIgZBImsOBRcUGBkaAAsgBkEFaw4FFBMTExUSCyAHQQA2AmAgB0EBNgJUIAdBqO/PADYCUCAHQgQ3AlggB0HQAGpBsO/PABDvLAALIAdBOGohFSAGQRBqIQ4gCiAEEO8hIgQoAhAhICAEKAIUQQJ2IRQgASEPIAsoAhBBACALKAIMQYCAgIB4RxshGyALKAIUIQEgCygCHEEAIAsoAhhBgICAgHhHGyEWIAsoAiAhFyMAQTBrIhIkAAJAAkAgG0EAIBYbRQRAIBQhECAbRQ0BIAEhEAwBCyAXIAEiEEYNACASIAE2AgAgEiAXNgIEIBJBAjYCHCASQYj+zgA2AhggEkICNwIkIBJBOzYCFCASQTs2AgwgEiASQQhqNgIgIBIgEkEEajYCECASIBI2AgggFUEEaiASQRhqEJkOIBVBADYCAAwBCyAOKAKQAUUEQCAOQgA3A8ABCyAOQgA3A7gBAkACQAJAIBAEQCAOKAK8BCgClAEhJANAAkAgFkUgCSAkaiIEIBAgBCAQSRsiEyAXT3INACAWIBNBAXRqIQoDQCAKLwEARQ0BIApBAmohCiAXIBNBAWoiE0cNAAsgFyETC0EAIQpBACERIBsEQCAJIBNLDQMgASATSQ1QIBsgCUEBdGohEQsgFgRAIAkgE0sNBCATIBdLDQUgFiAJQQF0aiEKCyASQRhqIQwjAEFAaiINJAAgEyAJayIGIQgCQAJAAkACQAJAIA4oArgEIgkuARgiBEEASgR/IBFFBEAgDUEBNgIcIA1B+P/OADYCGCANQgE3AiQgDUHNATYCOCANIAQ7AT4gDSANQTRqNgIgIA0gDUE+ajYCNCANQQRyIA1BGGoQmQ4gDCANKQIMNwIMIAxBFGogDUEUaigCADYCACAMIA0pAgQ3AgQgDEEANgIADAMLQQAhCCAGBEAgBEH//wNxIQkgESEEIAYhCwNAIAggBC8BACAJRmohCCAEQQJqIQQgC0EBayILDQALCyAOIA4pA5gDIAYgCGutfDcDmAMgDigCrANBgICAgHhHBEAgDkGsA2ogESAGENchCyAOQaAEaiARIAYQ+CkgDigCuAQFIAkLLgEaIgRBAEwEQCAOIA4oArwDIAZqNgK8AwwBCyAKBEAgBgRAIAovAQAEQCANQQE2AhwgDUGQ/84ANgIYIA1CATcCJCANQc0BNgIEIA0gCjYCACANIA02AiAgDEEEaiANQRhqEJkOIAxBADYCAAwECyAGQQF0IQkgDigCvAMhCyAKIQQDQCALIAQvAQBFaiELIARBAmohBCAJQQJrIgkNAAsgDiALNgK8AwsgDigCoANBgICAgHhHBEAgDkGgA2ogCiAGENchCyAOQawEaiAKIAYQ+CkMAQsgDUEBNgIcIA1BwIDPADYCGCANQgE3AiQgDUHNATYCOCANIAQ7AT4gDSANQTRqNgIgIA0gDUE+ajYCNCANQQRyIA1BGGoQmQ4gDCANKQIMNwIMIAxBFGogDUEUaigCADYCACAMIA0pAgQ3AgQgDEEANgIADAELAkAgDwRAIAMgCGoiBCAISQ0DIAQgBUsNBCMAQSBrIgskACAOIA4oApABIAhqNgKQASALIBQ2AhwgCyAgNgIYIAsgDyADQQJ0aiIENgIQIAsgBCAIQQJ0ajYCFCMAQSBrIgkkACAJQRRqIAtBEGoiESgCBCARKAIAa0ECdkEAQQRBBBCgGCAJKAIYIQQgCSgCFEEBRg1WIAtBBGohHiAJQRBqIiVBADYCACAJIAkoAhw2AgwgCSAENgIIIwBBEGsiHSQAIAlBCGoiBCARKAIEIBEoAgBrQQJ2EO4tIB0gBCkCBEIgiTcCCCAdIARBCGo2AgQgHUEEaiIZKAIEIQQgGSgCACEYAkACQCARKAIAIgogESgCBCIfRwRAIBEoAgwhIiARKAIIIRwgGSgCCCAEQQJ0aiERIB8gCmtBAnYhGQNAIAooAgAiHyAiTw0CIBEgHCAfQQJ0aioCADgCACAKQQRqIQogEUEEaiERIARBAWohBCAZQQFrIhkNAAsLIBggBDYCAAwBCyAfICJB3OXQABDDIQALIB1BEGokACAeQQhqICUoAgA2AgAgHiAJKQIINwIAIAlBIGokACANQRhqIA4gCygCCCALKAIMEPsQIB4Q6TsgC0EgaiQAIA0oAhgiBEEIRg0BIAwgDSkCHDcCBCAMQRRqIA1BLGooAgA2AgAgDEEMaiANQSRqKQIANwIAIAwgBDYCAAwCCyANQRhqIQkjAEHQAGsiBCQAIA4gDigCkAEgCGo2ApABIAQgCDYCBAJAIAggAyAIaiIKTSAKIBRNcUUEQCAEIBQgA2s2AjwgBEECNgIoIARBiInOADYCJCAEQgI3AjAgBEE7NgJMIARBOzYCRCAEIARBQGs2AiwgBCAEQTxqNgJIIAQgBEEEajYCQCAEQQhqQQRyIARBJGoQmQ4gCSAEKQIUNwIMIAlBFGogBEEcaigCADYCACAJIAQpAgw3AgQgCUEANgIADAELIAkgDiAgIANBAnRqIAgQ+xALIARB0ABqJAAgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELIA4gDigCuAMgBmoiBDYCuAMCQCAERQ0AIA4oArwDIA4oArwEIgQoApABSQRAIA4QvRwgBCgCjAFJDQELIA1BGGogDhDoASANKAIYIgRBCEYNACAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAQsCQCAOKAJoQYCAgIB4Rg0AIA4oAlwgDigCvARBCGogDigCuARBCGoQ0BFJDQAgDUEYaiEGIwBBwAFrIgQkAAJAAkAgDigCuANFDQAgBEEgaiAOEOgBIAQoAiAiCUEIRg0AIAYgBCkCJDcCBCAGQRRqIARBNGooAgA2AgAgBkEMaiAEQSxqKQIANwIAIAYgCTYCAAwBCyAEQSBqIA4QjgcgBCgCICIJQQhHBEAgBiAEKQIkNwIEIAZBFGogBEE0aigCADYCACAGQQxqIARBLGopAgA3AgAgBiAJNgIADAELAkACQCAOKAK4A0UNACAEQagBaiAOEOgBIAQoAqgBIgpBCEYNAAwBCwJAIA4oAsQCIgpFDQAgBEEoaiEJA0AgDiAKQQFrNgLEAiAOIA4oAsACIgpBAWoiCyAOKAK4AiIRQQAgCyARTxtrNgLAAiAOKAK8AiAKQYgBbGoiCikDACIsQgxRDQEgBCAsNwMgIAkgCkEIakGAAfwKAAAgBEGoAWogDiAEQSBqEKgKIAQoAqgBIgpBCEcNAiAOKALEAiIKDQALCyAGQQg2AgAMAQsgBEEYaiIJIARBvAFqKAIANgIAIARBEGoiCyAEQbQBaikCADcDACAEIAQpAqwBNwMIIAYgCjYCACAGIAQpAwg3AgQgBkEMaiALKQMANwIAIAZBFGogCSgCADYCAAsgBEHAAWokACANKAIYIgRBCEYNACAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAQsgDEEINgIAIAwgCDYCBAsgDUFAayQADAILIAMgBEGo/84AELE7AAsgBCAFQaj/zgAQsDsACyASKAIcIQQgEigCGCIGQQhHBEAgFSASKQMgNwMIIBVBEGogEkEoaikDADcDACAVIAQ2AgQgFSAGNgIADAYLIAMgBGohAyAQIBMiCUsNAAsLIBVBCDYCACAVIAM2AgQMAwsgCSATQZj+zgAQsTsACyAJIBNBqP7OABCxOwALDFMLIBJBMGokAAxCCyAHQThqIRUgBkEQaiEOIAogBBCCIiIEKAIQISAgBCgCFEEDdiEUIAEhDyALKAIQQQAgCygCDEGAgICAeEcbIRsgCygCFCEBIAsoAhxBACALKAIYQYCAgIB4RxshFiALKAIgIRcjAEEwayISJAACQAJAIBtBACAWG0UEQCAUIRAgG0UNASABIRAMAQsgFyABIhBGDQAgEiABNgIAIBIgFzYCBCASQQI2AhwgEkGI/s4ANgIYIBJCAjcCJCASQTs2AhQgEkE7NgIMIBIgEkEIajYCICASIBJBBGo2AhAgEiASNgIIIBVBBGogEkEYahCZDiAVQQA2AgAMAQsgDigCoAFFBEAgDkIANwPwAQsgDkIANwPoAQJAAkACQCAQBEAgDigC6AQoApQBISQDQAJAIBZFIAkgJGoiBCAQIAQgEEkbIhMgF09yDQAgFiATQQF0aiEKA0AgCi8BAEUNASAKQQJqIQogFyATQQFqIhNHDQALIBchEwtBACEKQQAhESAbBEAgCSATSw0DIAEgE0kNTyAbIAlBAXRqIRELIBYEQCAJIBNLDQQgEyAXSw0FIBYgCUEBdGohCgsgEkEYaiEMIwBBQGoiDSQAIBMgCWsiBiEIAkACQAJAAkACQCAOKALkBCIJLgEYIgRBAEoEfyARRQRAIA1BATYCHCANQfj/zgA2AhggDUIBNwIkIA1BzQE2AjggDSAEOwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAwgDSkCDDcCDCAMQRRqIA1BFGooAgA2AgAgDCANKQIENwIEIAxBADYCAAwDC0EAIQggBgRAIARB//8DcSEJIBEhBCAGIQsDQCAIIAQvAQAgCUZqIQggBEECaiEEIAtBAWsiCw0ACwsgDiAOKQPQAyAGIAhrrXw3A9ADIA4oAuQDQYCAgIB4RwRAIA5B5ANqIBEgBhDXIQsgDkHMBGogESAGEPgpIA4oAuQEBSAJCy4BGiIEQQBMBEAgDiAOKAL0AyAGajYC9AMMAQsgCgRAIAYEQCAKLwEABEAgDUEBNgIcIA1BkP/OADYCGCANQgE3AiQgDUHNATYCBCANIAo2AgAgDSANNgIgIAxBBGogDUEYahCZDiAMQQA2AgAMBAsgBkEBdCEJIA4oAvQDIQsgCiEEA0AgCyAELwEARWohCyAEQQJqIQQgCUECayIJDQALIA4gCzYC9AMLIA4oAtgDQYCAgIB4RwRAIA5B2ANqIAogBhDXIQsgDkHYBGogCiAGEPgpDAELIA1BATYCHCANQcCAzwA2AhggDUIBNwIkIA1BzQE2AjggDSAEOwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAwgDSkCDDcCDCAMQRRqIA1BFGooAgA2AgAgDCANKQIENwIEIAxBADYCAAwBCwJAIA8EQCADIAhqIgQgCEkNAyAEIAVLDQQjAEEgayILJAAgDiAOKAKgASAIajYCoAEgCyAUNgIcIAsgIDYCGCALIA8gA0ECdGoiBDYCECALIAQgCEECdGo2AhQjAEEgayIJJAAgCUEUaiALQRBqIhEoAgQgESgCAGtBAnZBAEEIQQgQoBggCSgCGCEEIAkoAhRBAUYNVSALQQRqIR4gCUEQaiIlQQA2AgAgCSAJKAIcNgIMIAkgBDYCCCMAQRBrIh0kACAJQQhqIgQgESgCBCARKAIAa0ECdhDsLSAdIAQpAgRCIIk3AgggHSAEQQhqNgIEIB1BBGoiGSgCBCEEIBkoAgAhGAJAAkAgESgCACIKIBEoAgQiH0cEQCARKAIMISIgESgCCCEcIBkoAgggBEEDdGohESAfIAprQQJ2IRkDQCAKKAIAIh8gIk8NAiARIBwgH0EDdGorAwA5AwAgCkEEaiEKIBFBCGohESAEQQFqIQQgGUEBayIZDQALCyAYIAQ2AgAMAQsgHyAiQdzl0AAQwyEACyAdQRBqJAAgHkEIaiAlKAIANgIAIB4gCSkCCDcCACAJQSBqJAAgDUEYaiAOIAsoAgggCygCDBD8ECAeEOM8IAtBIGokACANKAIYIgRBCEYNASAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAgsgDUEYaiEJIwBB0ABrIgQkACAOIA4oAqABIAhqNgKgASAEIAg2AgQCQCAIIAMgCGoiCk0gCiAUTXFFBEAgBCAUIANrNgI8IARBAjYCKCAEQYiJzgA2AiQgBEICNwIwIARBOzYCTCAEQTs2AkQgBCAEQUBrNgIsIAQgBEE8ajYCSCAEIARBBGo2AkAgBEEIakEEciAEQSRqEJkOIAkgBCkCFDcCDCAJQRRqIARBHGooAgA2AgAgCSAEKQIMNwIEIAlBADYCAAwBCyAJIA4gICADQQN0aiAIEPwQCyAEQdAAaiQAIA0oAhgiBEEIRg0AIAwgDSkCHDcCBCAMQRRqIA1BLGooAgA2AgAgDEEMaiANQSRqKQIANwIAIAwgBDYCAAwBCyAOIA4oAvADIAZqIgQ2AvADAkAgBEUNACAOKAL0AyAOKALoBCIEKAKQAUkEQCAOEL4cIAQoAowBSQ0BCyANQRhqIA4Q6gEgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELAkAgDigCeEGAgICAeEYNACAOKAJsIA4oAugEQQhqIA4oAuQEQQhqENARSQ0AIA1BGGohBiMAQcABayIEJAACQAJAIA4oAvADRQ0AIARBIGogDhDqASAEKAIgIglBCEYNACAGIAQpAiQ3AgQgBkEUaiAEQTRqKAIANgIAIAZBDGogBEEsaikCADcCACAGIAk2AgAMAQsgBEEgaiAOEIwHIAQoAiAiCUEIRwRAIAYgBCkCJDcCBCAGQRRqIARBNGooAgA2AgAgBkEMaiAEQSxqKQIANwIAIAYgCTYCAAwBCwJAAkAgDigC8ANFDQAgBEGoAWogDhDqASAEKAKoASIKQQhGDQAMAQsCQCAOKAL8AiIKRQ0AIARBKGohCQNAIA4gCkEBazYC/AIgDiAOKAL4AiIKQQFqIgsgDigC8AIiEUEAIAsgEU8bazYC+AIgDigC9AIgCkGIAWxqIgopAwAiLEIMUQ0BIAQgLDcDICAJIApBCGpBgAH8CgAAIARBqAFqIA4gBEEgahCkCiAEKAKoASIKQQhHDQIgDigC/AIiCg0ACwsgBkEINgIADAELIARBGGoiCSAEQbwBaigCADYCACAEQRBqIgsgBEG0AWopAgA3AwAgBCAEKQKsATcDCCAGIAo2AgAgBiAEKQMINwIEIAZBDGogCykDADcCACAGQRRqIAkoAgA2AgALIARBwAFqJAAgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELIAxBCDYCACAMIAg2AgQLIA1BQGskAAwCCyADIARBqP/OABCxOwALIAQgBUGo/84AELA7AAsgEigCHCEEIBIoAhgiBkEIRwRAIBUgEikDIDcDCCAVQRBqIBJBKGopAwA3AwAgFSAENgIEIBUgBjYCAAwGCyADIARqIQMgECATIglLDQALCyAVQQg2AgAgFSADNgIEDAMLIAkgE0GY/s4AELE7AAsgCSATQaj+zgAQsTsACwxSCyASQTBqJAAMQQsgB0EANgJgIAdBATYCVCAHQYTwzwA2AlAgB0IENwJYIAdB0ABqQYzwzwAQ7ywACwJAIAogBCgCHBEEACIJLQAAIhBBI2sOBCEiIyQACyAQQRNrDgMeHB8bCyAHIAogBBD1IUEMahDHGyAHQThqIAEgBygCACAHKAIEIAsQ9icMPgsgCSgCCCIGLQAAQSNrDgQFBgcICQsgB0HQAGoiBiAKIAQQ5CEQlyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMPAsgB0HQAGoiBiAKIAQQ6CEQnyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOwsgB0HQAGoiBiAKIAQQ/CEQmCAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOgsgB0HQAGoiBiAKIAQQ4yEQpSAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOQsgB0HQAGoiCSAKIARBzO3PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDkLIAcgBDYC1AEgByAGNgLQASAHQdAAaiIJIAdB0AFqIgpB2O3PAEGw7s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIQQZOAgIB4RwRAIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgEDYCUCAHQThqIAkQpiUgBygC0AEiASABKAIAIgFBAWs2AgAgAUEBRw05IAoQuyMMOQsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIMeIgQoAhAgBCgCFEECdiALEPYnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUYEQCABELsjCyAHKALQASIBIAEoAgAiAUEBazYCACABQQFHDTggB0HQAWoQuyMMOAsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDgLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQiB4QlyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw03IAYQuyMMNwsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDcLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQjR4QnyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw02IAYQuyMMNgsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDYLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQhh4QmCAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw01IAYQuyMMNQsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDULIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQgB4QpSAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw00IAYQuyMMNAsgB0HQAGoiCSAKIARBsO7PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDQLIAcgBDYCuAEgByAGNgK0ASAHQThqIAEgB0G0AWoiARCDHiIEKAIQIAQoAhRBAnYgCxD2JyAHKAK0ASIEIAQoAgAiBEEBazYCACAEQQFHDTMgARC7IwwzCyAHIAQ2ArgBIAcgBjYCtAEgB0E4aiABIAdBtAFqIgEQgx4iBCgCECAEKAIUQQJ2IAsQ9icgBygCtAEiBCAEKAIAIgRBAWs2AgAgBEEBRw0yIAEQuyMMMgsgBkEPRg0HCyAHQdAAaiIJIAogBEG87s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIKQZOAgIB4Rg0LIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgCjYCUCAHQThqIAkQpiUMMAsgB0E4aiABIAogBBDzISIBKAIQIAEoAhRBA3YgCxD3JwwvCyAHQQhqIAogBBDsIUEMahDFGyAHQThqIAEgBygCCCAHKAIMIAsQ9ycMLgsgCSgCCCIGLQAAQSRrDgMEBQYHCyAHQdAAaiIGIAogBBDoIRCdICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwsCyAHQdAAaiIGIAogBBD8IRCgICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwrCyAHQdAAaiIGIAogBBDjIRCmICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwqCyAHQdAAaiIJIAogBEG87s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIKQZOAgIB4RwRAIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgCjYCUCAHQThqIAkQpiUMKgsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIoeIgQoAhAgBCgCFEEDdiALEPcnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUcNKSABELsjDCkLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwpCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEI0eEJ0gIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNKCAGELsjDCgLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwoCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEIYeEKAgIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNJyAGELsjDCcLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwnCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEIAeEKYgIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNJiAGELsjDCYLIAdB0ABqIgkgCiAEQbzuzwAQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwmCyAHIAQ2ArgBIAcgBjYCtAEgB0E4aiABIAdBtAFqIgEQih4iBCgCECAEKAIUQQN2IAsQ9ycgBygCtAEiBCAEKAIAIgRBAWs2AgAgBEEBRw0lIAEQuyMMJQsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIoeIgQoAhAgBCgCFEEDdiALEPcnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUcNJCABELsjDCQLIBBBCkYNAQsgB0HQAGpBPUEAQQFBARCgGCAHKAJUIQEgBygCUEEBRg0MIAcoAlgiBEGY8c8AQT38CgAAIAdBPTYCRCAHIAQ2AkAgByABNgI8IAdBATYCOAwiCyAKIAQQ9CEhBCAHQdAAaiAFQQBBBEEQEKAYIAcoAlQhCSAHKAJQQQFGDQwgB0EANgKsASAHIAcoAlg2AqgBIAcgCTYCpAEgBQRAIAVBAnQhCSAEQQxqIRAgBCgCECETA0AgByABKAIAIgo2AswBIBAQ2TwgCk0NDyATIApBAXRqLwEAIQogB0HQAGoiEUECQQBBAUEBEKAYIAcoAlQhAyAHKAJQQQFGDScgBygCWCIXIAo7AAAgB0ECNgLYASAHIBc2AtQBIAcgAzYC0AEgESAHQdABahDnFSAHKAKsASIKIAcoAqQBRgRAIAdBpAFqQaj0zwAQnigLIAFBBGohASAHKAKoASAKQQR0aiIRIAcpAlA3AgAgEUEIaiAHQdgAaikCADcCACAHIApBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMIAsgByAJQQFqNgLQASAJLQABQQFrDgIGBwULIAdBKGogCiAEKAIQEQAAIAdB0ABqIgQgBygCKCIKIAcoAiwoAgwRAAAgCkUNDCAHKQNQQsDjtd7S/qWVLIUgBykDWEL1zqio0f7azKR/hYRQRQ0MIAQgBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0NIAdBADYC2AEgByAHKAJYNgLUASAHIAQ2AtABIAUEQCAFQQJ0IQkDQCAHQSBqIAogASgCABCgGyAHKAIgIRMgB0HQAGogBygCJCIEQQBBAUEBEKAYIAcoAlQhAyAHKAJQQQFGDSUgBygCWCEQIAQEQCAQIBMgBPwKAAALIAcgBDYCvAEgByAQNgK4ASAHIAM2ArQBIAdB0ABqIAdBtAFqEOcVIAcoAtgBIgQgBygC0AFGBEAgB0HQAWpByPTPABCeKAsgAUEEaiEBIAcoAtQBIARBBHRqIhAgBykCUDcCACAQQQhqIAdB2ABqKQIANwIAIAcgBEEBajYC2AEgCUEEayIJDQALCyAHQZABaiAHQdgBaigCADYCACAHIAcpAtABNwOIAQweCyAKIAQQ5CEhCiAHQdAAaiAFQQBBBEEQEKAYIAcoAlQhBCAHKAJQQQFGDQ0gB0EANgKsASAHIAcoAlg2AqgBIAcgBDYCpAFEAAAAAAAAJEAgChDNIEH/AXEQ3iBEAAAAAAAA8D+gEOcPIS8gBQRAIAVBAnQhCSAKQQxqIRNBBCAvRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMiBGsiESAHQbABamohFyAKKAIQIRQgBEEFSSEPA0AgByABKAIAIhA2AswBIBMQ2zwgEE0NECAHIBQgEEECdGooAgAiEEEYdCAQQYD+A3FBCHRyIBBBCHZBgP4DcSAQQRh2cnI2ArABIA9FDREgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0kIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AtgBIAcgEDYC1AEgByADNgLQASAHQdAAaiAHQdABahDnFSAHKAKsASIQIAcoAqQBRgRAIAdBpAFqQfjyzwAQnigLIAFBBGohASAHKAKoASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMHQsgCiAEEOghIQogB0HQAGogBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0PIAdBADYCrAEgByAHKAJYNgKoASAHIAQ2AqQBRAAAAAAAACRAIAoQ0CBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgCkEMaiETQQggL0QAAAAAAADwP6BEAAAAAAAAwD+im/wDIgRrIhEgB0GYAWpqIRcgCigCECEUIARBCUkhDwNAIAcgASgCACIQNgKwASATENg8IBBNDRIgByAUIBBBA3RqKQMAIixCOIYgLEKA/gODQiiGhCAsQoCA/AeDQhiGICxCgICA+A+DQgiGhIQgLEIIiEKAgID4D4MgLEIYiEKAgPwHg4QgLEIoiEKA/gODICxCOIiEhIQ3A5gBIA9FDRMgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0jIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AtgBIAcgEDYC1AEgByADNgLQASAHQdAAaiAHQdABahDnFSAHKAKsASIQIAcoAqQBRgRAIAdBpAFqQajzzwAQnigLIAFBBGohASAHKAKoASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMHAsgCiAEEPwhIQogB0HQAGogBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0RIAdBADYCoAEgByAHKAJYNgKcASAHIAQ2ApgBRAAAAAAAACRAIAoQziBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgCkEMaiETQRAgL0QAAAAAAADwP6BEAAAAAAAAwD+im/wDIgRrIhEgB0HQAWpqIRcgCigCECEUIARBEUkhDwNAIAcgASgCACIQNgKwASATENo8IBBNDRQgByAUIBBBBHRqIhApAwAiLEI4hiAsQoD+A4NCKIaEICxCgID8B4NCGIYgLEKAgID4D4NCCIaEhCAsQgiIQoCAgPgPgyAsQhiIQoCA/AeDhCAsQiiIQoD+A4MgLEI4iISEhDcD2AEgByAQKQMIIixCOIYgLEKA/gODQiiGhCAsQoCA/AeDQhiGICxCgICA+A+DQgiGhIQgLEIIiEKAgID4D4MgLEIYiEKAgPwHg4QgLEIoiEKA/gODICxCOIiEhIQ3A9ABIA9FDRUgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0iIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AqwBIAcgEDYCqAEgByADNgKkASAHQdAAaiAHQaQBahDnFSAHKAKgASIQIAcoApgBRgRAIAdBmAFqQdjzzwAQnigLIAFBBGohASAHKAKcASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqABIAlBBGsiCQ0ACwsgB0GQAWogB0GgAWooAgA2AgAgByAHKQKYATcDiAEMGwsgB0EwaiAKIAQoAhARAAAgB0HQAGoiECAHKAIwIgQgBygCNCgCDBEAACAERQ0TIAcpA1BC47Di8bKTqs3WAIUgBykDWEKw3+Dy+LaU9Id/hYRQRQ0TIBAgBUEAQQRBEBCgGCAHKAJUIQkgBygCUEEBRg0UIAdBADYCoAEgByAHKAJYNgKcASAHIAk2ApgBRAAAAAAAACRAIAQQzyBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgBEEMaiERIBBBICAvRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMiCmsiA2ohFyAEKAIQIRQgCkEhSSEPA0AgByABKAIAIhA2ArABIBEQ3DwgEE0NFyAHIBQgEEEFdGoiECkDACIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNoIAcgECkDCCIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNgIAcgECkDECIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNYIAcgECkDGCIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNQIA9FDRggB0G0AWogCkEAQQFBARCgGCAHKAK4ASEQIAcoArQBQQFGDRkgBygCvAEhEyAKBEAgEyAXIAr8CgAACyAHIAo2AqwBIAcgEzYCqAEgByAQNgKkASAHQbQBaiAHQaQBahDnFSAHKAKgASIQIAcoApgBRgRAIAdBmAFqQYj0zwAQnigLIAFBBGohASAHKAKcASAQQQR0aiITIAcpArQBNwIAIBNBCGogB0G8AWopAgA3AgAgByAQQQFqNgKgASAJQQRrIgkNAAsLIAdBkAFqIAdBoAFqKAIANgIAIAcgBykCmAE3A4gBDBoLIAdBEGogCiAEKAIQEQAAIAdB0ABqIAcoAhAiCiAHKAIUKAIMEQAAIApFDRcgBykDUELJ4PqEqc+Tli+FIAcpA1hCy92l0q6Ggoz8AIWEUEUNFyAHQYgBaiERIwBB0ABrIgkkACAJQShqIAVBAEEEQRAQoBggCSgCLCEEAkACQAJAIAkoAihBAUcEQCAJQQA2AgwgCSAJKAIwNgIIIAkgBDYCBCAFBEAgBUECdCEEIApBDGohAyAKKAIQIRcDQCAJIAEoAgAiEDYCECADENs8IBBNDQMgFyAQQQJ0aigCACEUIAlBKGpBBEEAQQFBARCgGCAJKAIsIRMgCSgCKEEBRg0EIAlBGGoiEEEENgIAIAkoAjAiDyAUNgAAIAkgDzYCFCAJIBM2AhAgCUEcakEIQYjyzwAQzhggCSgCICEUIAlBEGogCSgCJCITEOUtIBMEQCAJKAIUIBAoAgBqIBQgE/wKAAALIBAgECgCACATaiIQNgIAIAlBADYCJCAJQcgAaiAQNgIAIAkgCSkCEDcDQCAJQShqIAlBQGsQ5xUgCSgCDCIQIAkoAgRGBEAgCUEEakGo8s8AEJ4oCyABQQRqIQEgCSgCCCAQQQR0aiITIAkpAig3AgAgE0EIaiAJQTBqKQIANwIAIAkgEEEBajYCDCAJQRxqEN47IARBBGsiBA0ACwsgESAJKQIENwIAIBFBCGogCUEMaigCADYCACAJQdAAaiQADAMLIAQgCSgCMEH48c8AEP0vAAsgCSAKEPw7NgIcIAlBAjYCLCAJQdDlzwA2AiggCUICNwI0IAlBOzYCTCAJQTs2AkQgCSAJQUBrNgIwIAkgCUEcajYCSCAJIAlBEGo2AkAgCUEoakHg5c8AEO8sAAsgEyAJKAIwQbDozwAQ/S8ACwwZCyAHQRhqIAogBCgCEBEAACAHQdAAaiAHKAIYIgkgBygCHCgCDBEAACAJRQ0XIAcpA1BCtaiylsSn76ZMhSAHKQNYQvfzi+bVjoHNAoWEUEUNFyAHQYgBaiETIwBBQGoiBCQAIARBFGogBUEAQQRBEBCgGCAEKAIYIQoCQAJAAkAgBCgCFEEBRwRAIARBADYCDCAEIAQoAhw2AgggBCAKNgIEIAUEQCAFQQJ0IQogCUEMaiEDIAkoAhAhFwNAIAQgASgCACIQNgIQIAMQ2DwgEE0NAyAXIBBBA3RqIhAoAgQhFCAQKAIAIQ8gBEEUaiINQQxBAEEBQQEQoBggBCgCGCERIAQoAhRBAUYNBCAEKAIcIhAgFDYACCAQIA82AAQgEEEANgAAIARBDDYCOCAEIBA2AjQgBCARNgIwIA0gBEEwahDnFSAEKAIMIhAgBCgCBEYEQCAEQQRqQcjyzwAQnigLIAFBBGohASAEKAIIIBBBBHRqIhEgBCkCFDcCACARQQhqIARBHGopAgA3AgAgBCAQQQFqNgIMIApBBGsiCg0ACwsgEyAEKQIENwIAIBNBCGogBEEMaigCADYCACAEQUBrJAAMAwsgCiAEKAIcQbjyzwAQ/S8ACyAEIAkQ/Ts2AiwgBEECNgIYIARB0OXPADYCFCAEQgI3AiAgBEE7NgI8IARBOzYCNCAEIARBMGo2AhwgBCAEQSxqNgI4IAQgBEEQajYCMCAEQRRqQeDlzwAQ7ywACyARIAQoAhxBsOjPABD9LwALDBgLIAdBAjYCVCAHQejwzwA2AlAgB0IBNwJcIAdBzAk2ArgBIAcgB0G0AWo2AlggByAHQdABajYCtAEgB0E4akEEciEEIwBBEGsiASQAIAdB0ABqIgYoAgwhCQJAAkACQAJAAkACQAJAIAYoAgQOAgABAgsgCQ0BQQEhCUEAIRMMAgsgCQ0AIAYoAgAiBigCBCETIAYoAgAhCQwBCyAEIAYQmQ4MAQsgAUEEaiATQQBBAUEBEKAYIAEoAgghBiABKAIEQQFGDQEgASgCDCEKIBMEQCAKIAkgE/wKAAALIAQgEzYCCCAEIAo2AgQgBCAGNgIACyABQRBqJAAMAQsgBiABKAIMQbDozwAQ/S8ACyAHQQE2AjgMGAsgB0HQAGohHSAGIRQgCygCJCALKAIoIhUoAghBAWtBeHFqQQhqIRYgCygCBCEiIAsoAgghHyALKAIQQQAgCygCDEGAgICAeEcbISAgCygCFCEXIAsoAhxBACALKAIYQYCAgIB4RxshHiALKAIgIQ4jAEEwayIbJAACQAJAICBBACAeG0UEQCAXIRMgIA0BIBYgFSgCJBEEACETDAELIA4gFyITRg0AIBsgEzYCACAbIA42AgQgG0ECNgIcIBtBiP7OADYCGCAbQgI3AiQgG0E7NgIUIBtBOzYCDCAbIBtBCGo2AiAgGyAbQQRqNgIQIBsgGzYCCCAdQQRqIBtBGGoQmQ4gHUEANgIADAELAn8gFCgCsAFBgICAgHhHBEAgFCgCiAIMAQsgFCgCuAILRQRAIBRCADcDKAsgFEIANwMgAkAgE0UNACAUKAKcBSgClAEhJAJAAkACQANAAkAgHkUgCSAkaiIBIBMgASATSRsiECAOT3INACAeIBBBAXRqIQQDQCAELwEARQ0BIARBAmohBCAOIBBBAWoiEEcNAAsgDiEQC0EAIQRBACEDAkAgIARAIAkgEEsNASAQIBdLDQMgICAJQQF0aiEDCyAeBEAgCSAQSw0EIA4gEEkNBSAeIAlBAXRqIQQLIBtBGGohGSAEIQEjAEFAaiISJAAgECAJayINIQwCQAJAIBQoApgFIgYuARgiBEEASgR/IANFBEAgEkEBNgIcIBJB+P/OADYCGCASQgE3AiQgEkHNATYCOCASIAQ7AT4gEiASQTRqNgIgIBIgEkE+ajYCNCASQQRyIBJBGGoQmQ4gGSASKQIMNwIMIBlBFGogEkEUaigCADYCACAZIBIpAgQ3AgQgGUEANgIADAMLQQAhDCANBEAgBEH//wNxIQYgAyEEIA0hDwNAIAwgBC8BACAGRmohDCAEQQJqIQQgD0EBayIPDQALCyAUIBQpA+ADIA0gDGutfDcD4AMgFCgC9ANBgICAgHhHBEAgFEH0A2ogAyANENchCyAUQYAFaiADIA0Q+CkgFCgCmAUFIAYLLgEaIgRBAEwEQCAUIBQoAoQEIA1qNgKEBAwBCyABBEAgDQRAIAEvAQAEQCASQQE2AhwgEkGQ/84ANgIYIBJCATcCJCASQc0BNgIEIBIgATYCACASIBI2AiAgGUEEaiASQRhqEJkOIBlBADYCAAwECyANQQF0IQMgFCgChAQhDyABIQQDQCAPIAQvAQBFaiEPIARBAmohBCADQQJrIgMNAAsgFCAPNgKEBAsgFCgC6ANBgICAgHhHBEAgFEHoA2ogASANENchCyAUQYwFaiABIA0Q+CkMAQsgEkEBNgIcIBJBwIDPADYCGCASQgE3AiQgEkHNATYCOCASIAQ7AT4gEiASQTRqNgIgIBIgEkE+ajYCNCASQQRyIBJBGGoQmQ4gGSASKQIMNwIMIBlBFGogEkEUaigCADYCACAZIBIpAgQ3AgQgGUEANgIADAELICJFBEAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQdz5zQA2AgggAEIENwIQIABBCGpB5PnNABDvLAALAkACQAJAIAwgDCARaiIBTQRAIAEgH0sNASASQRhqISUgFEGwAWohCCAiIBFBAnRqIQsjAEHwCmsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgFiAVKAIcEQQAIgEtAABBFGsODwEAAgMEBQYAAAAAAAAABwALIAMgATYC4AogA0ECNgLECiADQaj7zQA2AsAKDA4LIANB6ABqIBYgFSgCEBEAACADQcAKaiIEIAMoAmgiASADKAJsKAIMEQAAIAFFDQ4gAykDwApCkJ6z7tm0jZLpAIUgAykDyApCiPSrgeCxxeTCAIWEUEUNDiADIAE2AvwJIAgtAMQBRQ0LIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANB4ABqIANBuApqEMMpIAMoAmBBAXFFDQsgA0HYAGogA0G0CmogAygCZBCpKiADKAJcIQEgAygCWCEJIAMgAykCuAo3AsAKIANB0ABqIAQQwykCQCADKAJQQQFxRQRAIAEhBiAJIQQMAQsgAygCVCEKIAkhBCABIQYDQCADQcgAaiADQbQKaiAKEKkqIAMoAkgiDyAJIA8gCSADKAJMIgogASABIApLGxCZJyIJIAogAWsgCRtBAEgiBRshCSAKIAEgBRshASAEIA8gDyAEIAogBiAGIApLGxCZJyIEIAogBmsgBBtBAEgiDxshBCAGIAogDxshBiADQUBrIANBwApqEMMpIAMoAkQhCiADKAJAQQFxDQALCyADQcAKaiABQQBBAUEBEKAYIAMoAsQKIQogAygCwApBAUYNDyADKALICiEPIAEEQCAPIAkgAfwKAAALIAMgATYCyAogAyAPNgLECiADIAo2AsAKIANB4ApqIANBwApqIgEQ5xUgASAGQQBBAUEBEKAYIAMoAsQKIQEgAygCwApBAUYNECADKALICiEJIAYEQCAJIAQgBvwKAAALIAMgBjYCqAogAyAJNgKkCiADIAE2AqAKIANB0ApqIgEgA0GgCmoiCRDnFSADQcgKaiIKIANB6ApqIgQpAgAiLDcDACADQYgKaiAsNwMAIANBkApqIgYgASkDADcDACADQZgKaiIBIANB2ApqKQMANwMAIAMgAykC4AoiLTcDwAogAyAtNwOACiADQagKaiIPICw3AwAgAyAtNwOgCiAEIAEpAwA3AwAgAyAGKQMANwPgCiAIQaABaiEEQQEhAQJAIAgoApwBIgZBAUYEQCAEKAIARQ0BQQEhBiADKAKgCgRAIAQgCRDGKSEGCyAGQf8BcUECRiAGwEEATHINASAIKAKcASEGCyAKIA8pAwA3AwAgAyADKQOgCjcDwAoCQCAGRQ0AIAQoAgAiAUUNACAIQawBaiAIKAKkASAIKAKoASABKAIQEQEACyAIQQE2ApwBIAQgAykDwAo3AgAgBEEIaiADQcgKaikDADcCAEEAIQELIAhBtAFqIQQCQCAIKAKwASIGQQFGBEAgAygC4AohBgJAIAQoAgAEQCAGRQ0DIAQgA0HgCmoQxinAQQBIDQEgAygC4AoiBEUNAyADQewKaiADKALkCiADKALoCiAEKAIQEQEADAMLIAZFDQILIAgoArABIQYLIANByApqIgkgA0HoCmopAwA3AwAgAyADKQPgCjcDwAoCQCAGRQ0AIAQoAgAiBkUNACAIQcABaiAIKAK4ASAIKAK8ASAGKAIQEQEACyAIQQE2ArABIAQgAykDwAo3AgAgBEEIaiAJKQMANwIACyABRQ0LIAMoAqAKIgFFDQsgA0GsCmogAygCpAogAygCqAogASgCEBEBAAwLCyADQdABaiAWIBUoAhARAAAgA0HACmoiBCADKALQASIBIAMoAtQBKAIMEQAAIAFFDQ0gAykDwApCwoz39urL3NGEf4UgAykDyApC5ZP0mPmv+Oiof4WEUEUNDSADIAE2AvwJIAgtAMQBRQ0JIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANByAFqIANBuApqEMMpIAMoAsgBQQFxRQ0JIANBwAFqIANBtApqIAMoAswBEKoqIAMoAsQBIQEgAygCwAEhCSADIAMpArgKNwLACiADQbgBaiAEEMMpAkAgAygCuAFBAXFFBEAgASEGIAkhBAwBCyADKAK8ASEKIAkhBCABIQYDQCADQbABaiADQbQKaiAKEKoqIAMoArABIg8gCSAPIAkgAygCtAEiCiABIAEgCksbEJknIgkgCiABayAJG0EASCIFGyEJIAogASAFGyEBIAQgDyAPIAQgCiAGIAYgCksbEJknIgQgCiAGayAEG0EASCIPGyEEIAYgCiAPGyEGIANBqAFqIANBwApqEMMpIAMoAqwBIQogAygCqAFBAXENAAsLIANBwApqIAFBAEEBQQEQoBggAygCxAohCiADKALACkEBRg0OIAMoAsgKIQ8gAQRAIA8gCSAB/AoAAAsgAyABNgLICiADIA82AsQKIAMgCjYCwAogA0HgCmogA0HACmoiARDnFSABIAZBAEEBQQEQoBggAygCxAohASADKALACkEBRg0PIAMoAsgKIQkgBgRAIAkgBCAG/AoAAAsgAyAGNgKoCiADIAk2AqQKIAMgATYCoAogA0HQCmoiASADQaAKaiIJEOcVIANByApqIgogA0HoCmoiBCkCACIsNwMAIANBiApqICw3AwAgA0GQCmoiBiABKQMANwMAIANBmApqIgEgA0HYCmopAwA3AwAgAyADKQLgCiItNwPACiADIC03A4AKIANBqApqIg8gLDcDACADIC03A6AKIAQgASkDADcDACADIAYpAwA3A+AKIAhBoAFqIQRBASEBAkAgCCgCnAEiBkEBRgRAIAQoAgBFDQFBASEGIAMoAqAKBEAgBCAJEMYpIQYLIAZB/wFxQQJGIAbAQQBMcg0BIAgoApwBIQYLIAogDykDADcDACADIAMpA6AKNwPACgJAIAZFDQAgBCgCACIBRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAEoAhARAQALIAhBATYCnAEgBCADKQPACjcCACAEQQhqIANByApqKQMANwIAQQAhAQsgCEG0AWohBAJAIAgoArABIgZBAUYEQCADKALgCiEGAkAgBCgCAARAIAZFDQMgBCADQeAKahDGKcBBAEgNASADKALgCiIERQ0DIANB7ApqIAMoAuQKIAMoAugKIAQoAhARAQAMAwsgBkUNAgsgCCgCsAEhBgsgA0HICmoiCSADQegKaikDADcDACADIAMpA+AKNwPACgJAIAZFDQAgBCgCACIGRQ0AIAhBwAFqIAgoArgBIAgoArwBIAYoAhARAQALIAhBATYCsAEgBCADKQPACjcCACAEQQhqIAkpAwA3AgALIAFFDQkgAygCoAoiAUUNCSADQawKaiADKAKkCiADKAKoCiABKAIQEQEADAkLIANBuAJqIBYgFSgCEBEAACADQcAKaiIEIAMoArgCIgEgAygCvAIoAgwRAAAgAUUNDCADKQPACkKv85DYlJzH+zOFIAMpA8gKQqClxfTN0NGkjX+FhFBFDQwgAyABNgL8CSAILQDEAUUNByADIAE2ArQKIAMgCzYCuAogAyALIAxBAnRqNgK8CiADQbACaiADQbgKahDDKSADKAKwAkEBcUUNByADQagCaiADQbQKaiADKAK0AhClKiADKAKsAiEBIAMoAqgCIQkgAyADKQK4CjcCwAogA0GgAmogBBDDKQJAIAMoAqACQQFxRQRAIAEhBiAJIQQMAQsgAygCpAIhCiAJIQQgASEGA0AgA0GYAmogA0G0CmogChClKiADKAKYAiIPIAkgDyAJIAMoApwCIgogASABIApLGxCZJyIJIAogAWsgCRtBAEgiBRshCSAKIAEgBRshASAEIA8gDyAEIAogBiAGIApLGxCZJyIEIAogBmsgBBtBAEgiDxshBCAGIAogDxshBiADQZACaiADQcAKahDDKSADKAKUAiEKIAMoApACQQFxDQALCyADQcAKaiABQQBBAUEBEKAYIAMoAsQKIQogAygCwApBAUYNDSADKALICiEPIAEEQCAPIAkgAfwKAAALIAMgATYCyAogAyAPNgLECiADIAo2AsAKIANB4ApqIANBwApqIgEQ5xUgASAGQQBBAUEBEKAYIAMoAsQKIQEgAygCwApBAUYNDiADKALICiEJIAYEQCAJIAQgBvwKAAALIAMgBjYCqAogAyAJNgKkCiADIAE2AqAKIANB0ApqIgEgA0GgCmoiCRDnFSADQcgKaiIKIANB6ApqIgQpAgAiLDcDACADQYgKaiAsNwMAIANBkApqIgYgASkDADcDACADQZgKaiIBIANB2ApqKQMANwMAIAMgAykC4AoiLTcDwAogAyAtNwOACiADQagKaiIPICw3AwAgAyAtNwOgCiAEIAEpAwA3AwAgAyAGKQMANwPgCiAIQaABaiEEQQEhAQJAIAgoApwBIgZBAUYEQCAEKAIARQ0BQQEhBiADKAKgCgRAIAQgCRDGKSEGCyAGQf8BcUECRiAGwEEATHINASAIKAKcASEGCyAKIA8pAwA3AwAgAyADKQOgCjcDwAoCQCAGRQ0AIAQoAgAiAUUNACAIQawBaiAIKAKkASAIKAKoASABKAIQEQEACyAIQQE2ApwBIAQgAykDwAo3AgAgBEEIaiADQcgKaikDADcCAEEAIQELIAhBtAFqIQQCQCAIKAKwASIGQQFGBEAgAygC4AohBgJAIAQoAgAEQCAGRQ0DIAQgA0HgCmoQxinAQQBIDQEgAygC4AoiBEUNAyADQewKaiADKALkCiADKALoCiAEKAIQEQEADAMLIAZFDQILIAgoArABIQYLIANByApqIgkgA0HoCmopAwA3AwAgAyADKQPgCjcDwAoCQCAGRQ0AIAQoAgAiBkUNACAIQcABaiAIKAK4ASAIKAK8ASAGKAIQEQEACyAIQQE2ArABIAQgAykDwAo3AgAgBEEIaiAJKQMANwIACyABRQ0HIAMoAqAKIgFFDQcgA0GsCmogAygCpAogAygCqAogASgCEBEBAAwHCyADQaADaiAWIBUoAhARAAAgA0HACmoiBCADKAKgAyIBIAMoAqQDKAIMEQAAIAFFDQsgAykDwApCx9n0597Etpx3hSADKQPICkKNss6UjMqS5qd/hYRQRQ0LIAMgATYC/AkgCC0AxAFFDQUgAyABNgK0CiADIAs2ArgKIAMgCyAMQQJ0ajYCvAogA0GYA2ogA0G4CmoQwykgAygCmANBAXFFDQUgA0GQA2ogA0G0CmogAygCnAMQqCogAygClAMhASADKAKQAyEJIAMgAykCuAo3AsAKIANBiANqIAQQwykCQCADKAKIA0EBcUUEQCABIQYgCSEEDAELIAMoAowDIQogCSEEIAEhBgNAIANBgANqIANBtApqIAoQqCogAygCgAMiDyAJIA8gCSADKAKEAyIKIAEgASAKSxsQmSciCSAKIAFrIAkbQQBIIgUbIQkgCiABIAUbIQEgBCAPIA8gBCAKIAYgBiAKSxsQmSciBCAKIAZrIAQbQQBIIg8bIQQgBiAKIA8bIQYgA0H4AmogA0HACmoQwykgAygC/AIhCiADKAL4AkEBcQ0ACwsgA0HACmogAUEAQQFBARCgGCADKALECiEKIAMoAsAKQQFGDQwgAygCyAohDyABBEAgDyAJIAH8CgAACyADIAE2AsgKIAMgDzYCxAogAyAKNgLACiADQeAKaiADQcAKaiIBEOcVIAEgBkEAQQFBARCgGCADKALECiEBIAMoAsAKQQFGDQ0gAygCyAohCSAGBEAgCSAEIAb8CgAACyADIAY2AqgKIAMgCTYCpAogAyABNgKgCiADQdAKaiIBIANBoApqIgkQ5xUgA0HICmoiCiADQegKaiIEKQIAIiw3AwAgA0GICmogLDcDACADQZAKaiIGIAEpAwA3AwAgA0GYCmoiASADQdgKaikDADcDACADIAMpAuAKIi03A8AKIAMgLTcDgAogA0GoCmoiDyAsNwMAIAMgLTcDoAogBCABKQMANwMAIAMgBikDADcD4AogCEGgAWohBEEBIQECQCAIKAKcASIGQQFGBEAgBCgCAEUNAUEBIQYgAygCoAoEQCAEIAkQxikhBgsgBkH/AXFBAkYgBsBBAExyDQEgCCgCnAEhBgsgCiAPKQMANwMAIAMgAykDoAo3A8AKAkAgBkUNACAEKAIAIgFFDQAgCEGsAWogCCgCpAEgCCgCqAEgASgCEBEBAAsgCEEBNgKcASAEIAMpA8AKNwIAIARBCGogA0HICmopAwA3AgBBACEBCyAIQbQBaiEEAkAgCCgCsAEiBkEBRgRAIAMoAuAKIQYCQCAEKAIABEAgBkUNAyAEIANB4ApqEMYpwEEASA0BIAMoAuAKIgRFDQMgA0HsCmogAygC5AogAygC6AogBCgCEBEBAAwDCyAGRQ0CCyAIKAKwASEGCyADQcgKaiIJIANB6ApqKQMANwMAIAMgAykD4Ao3A8AKAkAgBkUNACAEKAIAIgZFDQAgCEHAAWogCCgCuAEgCCgCvAEgBigCEBEBAAsgCEEBNgKwASAEIAMpA8AKNwIAIARBCGogCSkDADcCAAsgAUUNBSADKAKgCiIBRQ0FIANBrApqIAMoAqQKIAMoAqgKIAEoAhARAQAMBQsgA0GIBGogFiAVKAIQEQAAIANBwApqIgQgAygCiAQiASADKAKMBCgCDBEAACABRQ0KIAMpA8AKQtPY0/j95vaSSIUgAykDyApCotieiOGg6unMAIWEUEUNCiADIAE2AvwJIAgtAMQBRQ0DIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANBgARqIANBuApqEMMpIAMoAoAEQQFxRQ0DIANB+ANqIANBtApqIAMoAoQEEKsqIAMoAvwDIQEgAygC+AMhCSADIAMpArgKNwLACiADQfADaiAEEMMpAkAgAygC8ANBAXFFBEAgASEGIAkhBAwBCyADKAL0AyEKIAkhBCABIQYDQCADQegDaiADQbQKaiAKEKsqIAMoAugDIg8gCSAPIAkgAygC7AMiCiABIAEgCksbEJknIgkgCiABayAJG0EASCIFGyEJIAogASAFGyEBIAQgDyAPIAQgCiAGIAYgCksbEJknIgQgCiAGayAEG0EASCIPGyEEIAYgCiAPGyEGIANB4ANqIANBwApqEMMpIAMoAuQDIQogAygC4ANBAXENAAsLIANBwApqIAFBAEEBQQEQoBggAygCxAohCiADKALACkEBRg0LIAMoAsgKIQ8gAQRAIA8gCSAB/AoAAAsgAyABNgLICiADIA82AsQKIAMgCjYCwAogA0HgCmogA0HACmoiARDnFSABIAZBAEEBQQEQoBggAygCxAohASADKALACkEBRg0MIAMoAsgKIQkgBgRAIAkgBCAG/AoAAAsgAyAGNgKoCiADIAk2AqQKIAMgATYCoAogA0HQCmoiASADQaAKaiIJEOcVIANByApqIgogA0HoCmoiBCkCACIsNwMAIANBiApqICw3AwAgA0GQCmoiBiABKQMANwMAIANBmApqIgEgA0HYCmopAwA3AwAgAyADKQLgCiItNwPACiADIC03A4AKIANBqApqIg8gLDcDACADIC03A6AKIAQgASkDADcDACADIAYpAwA3A+AKIAhBoAFqIQRBASEBAkAgCCgCnAEiBkEBRgRAIAQoAgBFDQFBASEGIAMoAqAKBEAgBCAJEMYpIQYLIAZB/wFxQQJGIAbAQQBMcg0BIAgoApwBIQYLIAogDykDADcDACADIAMpA6AKNwPACgJAIAZFDQAgBCgCACIBRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAEoAhARAQALIAhBATYCnAEgBCADKQPACjcCACAEQQhqIANByApqKQMANwIAQQAhAQsgCEG0AWohBAJAIAgoArABIgZBAUYEQCADKALgCiEGAkAgBCgCAARAIAZFDQMgBCADQeAKahDGKcBBAEgNASADKALgCiIERQ0DIANB7ApqIAMoAuQKIAMoAugKIAQoAhARAQAMAwsgBkUNAgsgCCgCsAEhBgsgA0HICmoiCSADQegKaikDADcDACADIAMpA+AKNwPACgJAIAZFDQAgBCgCACIGRQ0AIAhBwAFqIAgoArgBIAgoArwBIAYoAhARAQALIAhBATYCsAEgBCADKQPACjcCACAEQQhqIAkpAwA3AgALIAFFDQMgAygCoAoiAUUNAyADQawKaiADKAKkCiADKAKoCiABKAIQEQEADAMLIANB8ARqIBYgFSgCEBEAACADQcAKaiIEIAMoAvAEIgEgAygC9AQoAgwRAAAgAUUNCSADKQPACkKrmJHxlfrV/IB/hSADKQPICkKWlPir8LHps+EAhYRQRQ0JIAMgATYC/AkgCC0AxAFFDQEgAyABNgK0CiADIAs2ArgKIAMgCyAMQQJ0ajYCvAogA0HoBGogA0G4CmoQwykgAygC6ARBAXFFDQEgA0HgBGogA0G0CmogAygC7AQQpCogAygC5AQhASADKALgBCEJIAMgAykCuAo3AsAKIANB2ARqIAQQwykCQCADKALYBEEBcUUEQCABIQYgCSEEDAELIAMoAtwEIQogCSEEIAEhBgNAIANB0ARqIANBtApqIAoQpCogAygC0AQiDyAJIA8gCSADKALUBCIKIAEgASAKSxsQmSciCSAKIAFrIAkbQQBIIgUbIQkgCiABIAUbIQEgBCAPIA8gBCAKIAYgBiAKSxsQmSciBCAKIAZrIAQbQQBIIg8bIQQgBiAKIA8bIQYgA0HIBGogA0HACmoQwykgAygCzAQhCiADKALIBEEBcQ0ACwsgA0HACmogAUEAQQFBARCgGCADKALECiEKIAMoAsAKQQFGDQogAygCyAohDyABBEAgDyAJIAH8CgAACyADIAE2AsgKIAMgDzYCxAogAyAKNgLACiADQeAKaiADQcAKaiIBEOcVIAEgBkEAQQFBARCgGCADKALECiEBIAMoAsAKQQFGDQsgAygCyAohCSAGBEAgCSAEIAb8CgAACyADIAY2AqgKIAMgCTYCpAogAyABNgKgCiADQdAKaiIBIANBoApqIgkQ5xUgA0HICmoiCiADQegKaiIEKQIAIiw3AwAgA0GICmogLDcDACADQZAKaiIGIAEpAwA3AwAgA0GYCmoiASADQdgKaikDADcDACADIAMpAuAKIi03A8AKIAMgLTcDgAogA0GoCmoiDyAsNwMAIAMgLTcDoAogBCABKQMANwMAIAMgBikDADcD4AogCEGgAWohBEEBIQECQCAIKAKcASIGQQFGBEAgBCgCAEUNAUEBIQYgAygCoAoEQCAEIAkQxikhBgsgBkH/AXFBAkYgBsBBAExyDQEgCCgCnAEhBgsgCiAPKQMANwMAIAMgAykDoAo3A8AKAkAgBkUNACAEKAIAIgFFDQAgCEGsAWogCCgCpAEgCCgCqAEgASgCEBEBAAsgCEEBNgKcASAEIAMpA8AKNwIAIARBCGogA0HICmopAwA3AgBBACEBCyAIQbQBaiEEAkAgCCgCsAEiBkEBRgRAIAMoAuAKIQYCQCAEKAIABEAgBkUNAyAEIANB4ApqEMYpwEEASA0BIAMoAuAKIgRFDQMgA0HsCmogAygC5AogAygC6AogBCgCEBEBAAwDCyAGRQ0CCyAIKAKwASEGCyADQcgKaiIJIANB6ApqKQMANwMAIAMgAykD4Ao3A8AKAkAgBkUNACAEKAIAIgZFDQAgCEHAAWogCCgCuAEgCCgCvAEgBigCEBEBAAsgCEEBNgKwASAEIAMpA8AKNwIAIARBCGogCSkDADcCAAsgAUUNASADKAKgCiIBRQ0BIANBrApqIAMoAqQKIAMoAqgKIAEoAhARAQAMAQsCQAJAAkACQAJAAkAgASgCCCIELQAAQRRrDgYEAwIFAQAFCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcYCyADQYAJaiAWIBUoAhARAAAgA0HACmogAygCgAkiASADKAKECSgCDBEAACABRQ0UIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRQgA0H4CGogARDWISADKAL4CCIBRQ0UIAEgAygC/AggCyAMIAgQ/QEMEgsgA0GQCWogFiAVKAIQEQAAIANBwApqIAMoApAJIgEgAygClAkoAgwRAAAgAUUNEyADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNEyADQYgJaiABENYhIAMoAogJIgFFDRMgASADKAKMCSALIAwgCBD+AQwRCyADQaAJaiAWIBUoAhARAAAgA0HACmogAygCoAkiASADKAKkCSgCDBEAACABRQ0SIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNEiADQZgJaiABENYhIAMoApgJIgFFDRIgASADKAKcCSALIAwgCBD/AQwQCyADQbAJaiAWIBUoAhARAAAgA0HACmogAygCsAkiASADKAK0CSgCDBEAACABRQ0RIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNESADQagJaiABENYhIAMoAqgJIgFFDREgASADKAKsCSALIAwgCBCAAgwPCyADQcAJaiAWIBUoAhARAAAgA0HACmogAygCwAkiASADKALECSgCDBEAACABRQ0QIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNECADQbgJaiABENYhIAMoArgJIgFFDRAgASADKAK8CSALIAwgCBCBAgwOCyADQdAJaiAWIBUoAhARAAAgA0HACmogAygC0AkiASADKALUCSgCDBEAACABRQ0PIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0PIANByAlqIAEQ1iEgAygCyAkiAUUNDyABIAMoAswJIAsgDCAIEIICDA0LIANB4AlqIBYgFSgCEBEAACADQcAKaiADKALgCSIBIAMoAuQJKAIMEQAAIAFFDQ4gAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0OIANB2AlqIAEQ1iEgAygC2AkiAUUNDiABIAMoAtwJIAsgDCAIEP8BDAwLIANB8AlqIBYgFSgCEBEAACADQcAKaiADKALwCSIBIAMoAvQJKAIMEQAAIAFFDQ0gAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQ0gA0HoCWogARDWISADKALoCSIBBEAgASADKALsCSALIAwgCBCAAgwMCwwNCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcXCyADQYAIaiAWIBUoAhARAAAgA0HACmogAygCgAgiASADKAKECCgCDBEAACABRQ0TIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRMgA0H4B2ogARDhISADKAL4ByIBRQ0TIAEgAygC/AcgCyAMIAgQgwIMEQsgA0GQCGogFiAVKAIQEQAAIANBwApqIAMoApAIIgEgAygClAgoAgwRAAAgAUUNEiADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNEiADQYgIaiABEOEhIAMoAogIIgFFDRIgASADKAKMCCALIAwgCBCEAgwQCyADQaAIaiAWIBUoAhARAAAgA0HACmogAygCoAgiASADKAKkCCgCDBEAACABRQ0RIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNESADQZgIaiABEOEhIAMoApgIIgFFDREgASADKAKcCCALIAwgCBCFAgwPCyADQbAIaiAWIBUoAhARAAAgA0HACmogAygCsAgiASADKAK0CCgCDBEAACABRQ0QIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNECADQagIaiABEOEhIAMoAqgIIgFFDRAgASADKAKsCCALIAwgCBCGAgwOCyADQcAIaiAWIBUoAhARAAAgA0HACmogAygCwAgiASADKALECCgCDBEAACABRQ0PIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDyADQbgIaiABEOEhIAMoArgIIgFFDQ8gASADKAK8CCALIAwgCBCHAgwNCyADQdAIaiAWIBUoAhARAAAgA0HACmogAygC0AgiASADKALUCCgCDBEAACABRQ0OIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0OIANByAhqIAEQ4SEgAygCyAgiAUUNDiABIAMoAswIIAsgDCAIEIgCDAwLIANB4AhqIBYgFSgCEBEAACADQcAKaiADKALgCCIBIAMoAuQIKAIMEQAAIAFFDQ0gAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0NIANB2AhqIAEQ4SEgAygC2AgiAUUNDSABIAMoAtwIIAsgDCAIEIUCDAsLIANB8AhqIBYgFSgCEBEAACADQcAKaiADKALwCCIBIAMoAvQIKAIMEQAAIAFFDQwgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQwgA0HoCGogARDhISADKALoCCIBBEAgASADKALsCCALIAwgCBCGAgwLCwwMCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcWCyADQYAHaiAWIBUoAhARAAAgA0HACmogAygCgAciASADKAKEBygCDBEAACABRQ0SIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRIgA0H4BmogARDVISADKAL4BiIBRQ0SIAEgAygC/AYgCyAMIAgQ/QEMEAsgA0GQB2ogFiAVKAIQEQAAIANBwApqIAMoApAHIgEgAygClAcoAgwRAAAgAUUNESADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNESADQYgHaiABENUhIAMoAogHIgFFDREgASADKAKMByALIAwgCBD+AQwPCyADQaAHaiAWIBUoAhARAAAgA0HACmogAygCoAciASADKAKkBygCDBEAACABRQ0QIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNECADQZgHaiABENUhIAMoApgHIgFFDRAgASADKAKcByALIAwgCBD/AQwOCyADQbAHaiAWIBUoAhARAAAgA0HACmogAygCsAciASADKAK0BygCDBEAACABRQ0PIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDyADQagHaiABENUhIAMoAqgHIgFFDQ8gASADKAKsByALIAwgCBCAAgwNCyADQcAHaiAWIBUoAhARAAAgA0HACmogAygCwAciASADKALEBygCDBEAACABRQ0OIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDiADQbgHaiABENUhIAMoArgHIgFFDQ4gASADKAK8ByALIAwgCBCBAgwMCyADQdAHaiAWIBUoAhARAAAgA0HACmogAygC0AciASADKALUBygCDBEAACABRQ0NIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0NIANByAdqIAEQ1SEgAygCyAciAUUNDSABIAMoAswHIAsgDCAIEIICDAsLIANB4AdqIBYgFSgCEBEAACADQcAKaiADKALgByIBIAMoAuQHKAIMEQAAIAFFDQwgAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0MIANB2AdqIAEQ1SEgAygC2AciAUUNDCABIAMoAtwHIAsgDCAIEP8BDAoLIANB8AdqIBYgFSgCEBEAACADQcAKaiADKALwByIBIAMoAvQHKAIMEQAAIAFFDQsgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQsgA0HoB2ogARDVISADKALoByIBBEAgASADKALsByALIAwgCBCAAgwKCwwLCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcVCyADQYAGaiAWIBUoAhARAAAgA0HACmogAygCgAYiASADKAKEBigCDBEAACABRQ0RIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDREgA0H4BWogARDUISADKAL4BSIBRQ0RIAMoAvwFIQYgCyEEIwBB4AFrIgUkACAFIAY2AmwgBSABNgJoAkAgCC0AxAFFDQAgBSAGNgKkASAFIAE2AqABIAUgBDYCqAEgBSAEIAxBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ/hkgBSgCXCEKIAUoAlghASAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgCiELIAEhBgwBCyAFKAJUIQkgASEGIAohCwNAIAVByABqIAVBoAFqIAkQ/hkgBSgCSCIPIAEgDyABIAUoAkwiCSAKIAkgCkkbEJknIgEgCSAKayABG0EASCIYGyEBIAkgCiAYGyEKIAYgDyAPIAYgCSALIAkgC0kbEJknIgYgCSALayAGG0EASCIPGyEGIAsgCSAPGyELIAVBQGsgBUGwAWoQwykgBSgCRCEJIAUoAkBBAXENAAsLIAVBsAFqIApBAEEBQQEQoBggBSgCtAEhDwJAIAUoArABQQFHBEAgBSgCuAEhCSAKBEAgCSABIAr8CgAACyAFIAo2ArgBIAUgCTYCtAEgBSAPNgKwASAFQdABaiAFQbABaiIBEOcVIAEgC0EAQQFBARCgGCAFKAK0ASEKIAUoArABQQFGDQEgBSgCuAEhASALBEAgASAGIAv8CgAACyAFIAs2ApgBIAUgATYClAEgBSAKNgKQASAFQcABaiIBIAVBkAFqIgYQ5xUgBUG4AWoiCSAFQdgBaiIKKQIAIiw3AwAgBUH4AGogLDcDACAFQYABaiILIAEpAwA3AwAgBUGIAWoiASAFQcgBaikDADcDACAFIAUpAtABIi03A7ABIAUgLTcDcCAFQZgBaiIPICw3AwAgBSAtNwOQASAKIAEpAwA3AwAgBSALKQMANwPQASAIQaABaiEBQQEhCgJAIAgoApwBIgtBAUYEQCABKAIARQ0BQQEhCyAFKAKQAQRAIAEgBhDGKSELCyALQf8BcUECRiALwEEATHINASAIKAKcASELCyAJIA8pAwA3AwAgBSAFKQOQATcDsAECQCALRQ0AIAEoAgAiBkUNACAIQawBaiAIKAKkASAIKAKoASAGKAIQEQEACyAIQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQoLIAhBtAFqIQECQCAIKAKwASILQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAgoArABIQsLIAVBuAFqIgYgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCALRQ0AIAEoAgAiCUUNACAIQcABaiAIKAK4ASAIKAK8ASAJKAIQEQEACyAIQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAGKQMANwIACyAKRQ0CIAUoApABIgFFDQIgBUGcAWogBSgClAEgBSgCmAEgASgCEBEBAAwCCwwbCwwbCwJAIAgoApABQYCAgIB4Rg0AIAUgBDYCsAEgBSAEIAxBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgCEGQAWohASAFKAI8IQkDQCAFQTBqIAVB6ABqIAkQ/hkgASAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQkgBSgCKEEBcQ0ACwsCQCAIKAIAQYCAgIB4RwRAIAUgBSkCaDcCsAEgCEHQAGoiBiAMEOwtIAxFDQEgDEECdCEKA0AgBUEgaiAFQbABaiAEKAIAEP4ZIAggBSgCICAFKAIkIgkQ9RshLCAIKAJYIgEgCCgCUEYEQCAGQfD4zQAQsygLIARBBGohBCAIKAJUIAFBA3RqICw3AwAgCCABQQFqNgJYIAggCCkDSCAJrXw3A0ggCkEEayIKDQALDAELIAUpAmghLCAIIAgoAogBIAxqNgKIASAFICw3AtABAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0CIAhB5ABqIQEgDEECdCELA0AgBUEIaiAFQdABaiAEKAIAEP4ZIAUoAgghCSAFIAUoAgwiBjYCsAEgASAFQbABakEEEKE2IAEgCSAGEKE2IAggCCkDgAEgBq18NwOAASAEQQRqIQQgC0EEayILDQALDAILIAxFDQEgCEHkAGohBiAMQQJ0IQoDQCAFQRBqIAVB0AFqIAQoAgAQ/hkgBSgCECEJIAgoAnAhCyAFIAUoAhQiATYCkAEgBUHwAGogCyAFQZABakEBEM8RIAUoAnBBCEcNHiAGIAkgARChNiAIIAgpA4ABIAGtfDcDgAEgBEEEaiEEIApBBGsiCg0ACwwBCyAMRQ0AIAhB4ABqIQsgBCAMQQJ0aiEPIAhB7ABqIRgDQCAFQRhqIAVB0AFqIAQoAgAQ/hkgBSgCGCEGQQAhCQJAIAgoAnQiASAFKAIcIgogASAKSRsiAUUNACAIKAJwIRwDQCAJIBxqLQAAIAYgCWotAABHDQEgASAJQQFqIglHDQALIAEhCQsgCEEANgJ0IBggBiAKEKE2IAkgCksNHiALIAYgCWogCiAJayIBEKE2IAgoAnghBiAFIAk2ApABIAVB8ABqIgkgBiAFQZABaiIGQQEQzxEgBSgCcEEIRw0fIAgoAnwhHCAFIAE2ApABIAkgHCAGQQEQzxEgBSgCcEEIRw0gIAggCCkDgAEgCq18NwOAASAEQQRqIgQgD0cNAAsLIAVB4AFqJAAMDwsgA0GQBmogFiAVKAIQEQAAIANBwApqIAMoApAGIgEgAygClAYoAgwRAAAgAUUNECADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNECADQYgGaiABENQhIAMoAogGIgFFDRAgAygCjAYhBiALIQQjAEHgAWsiBSQAIAUgBjYCbCAFIAE2AmgCQCAILQDEAUUNACAFIAY2AqQBIAUgATYCoAEgBSAENgKoASAFIAQgDEECdGo2AqwBIAVB4ABqIAVBqAFqEMMpIAUoAmBBAXFFDQAgBUHYAGogBUGgAWogBSgCZBDzGSAFKAJcIQogBSgCWCEBIAUgBSkCqAE3ArABIAVB0ABqIAVBsAFqEMMpAkAgBSgCUEEBcUUEQCAKIQsgASEGDAELIAUoAlQhCSABIQYgCiELA0AgBUHIAGogBUGgAWogCRDzGSAFKAJIIg8gASAPIAEgBSgCTCIJIAogCSAKSRsQmSciASAJIAprIAEbQQBIIhgbIQEgCSAKIBgbIQogBiAPIA8gBiAJIAsgCSALSRsQmSciBiAJIAtrIAYbQQBIIg8bIQYgCyAJIA8bIQsgBUFAayAFQbABahDDKSAFKAJEIQkgBSgCQEEBcQ0ACwsgBUGwAWogCkEAQQFBARCgGCAFKAK0ASEPAkAgBSgCsAFBAUcEQCAFKAK4ASEJIAoEQCAJIAEgCvwKAAALIAUgCjYCuAEgBSAJNgK0ASAFIA82ArABIAVB0AFqIAVBsAFqIgEQ5xUgASALQQBBAUEBEKAYIAUoArQBIQogBSgCsAFBAUYNASAFKAK4ASEBIAsEQCABIAYgC/wKAAALIAUgCzYCmAEgBSABNgKUASAFIAo2ApABIAVBwAFqIgEgBUGQAWoiBhDnFSAFQbgBaiIJIAVB2AFqIgopAgAiLDcDACAFQfgAaiAsNwMAIAVBgAFqIgsgASkDADcDACAFQYgBaiIBIAVByAFqKQMANwMAIAUgBSkC0AEiLTcDsAEgBSAtNwNwIAVBmAFqIg8gLDcDACAFIC03A5ABIAogASkDADcDACAFIAspAwA3A9ABIAhBoAFqIQFBASEKAkAgCCgCnAEiC0EBRgRAIAEoAgBFDQFBASELIAUoApABBEAgASAGEMYpIQsLIAtB/wFxQQJGIAvAQQBMcg0BIAgoApwBIQsLIAkgDykDADcDACAFIAUpA5ABNwOwAQJAIAtFDQAgASgCACIGRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAYoAhARAQALIAhBATYCnAEgASAFKQOwATcCACABQQhqIAVBuAFqKQMANwIAQQAhCgsgCEG0AWohAQJAIAgoArABIgtBAUYEQCAFKALQASEGAkAgASgCAARAIAZFDQMgASAFQdABahDGKcBBAEgNASAFKALQASIBRQ0DIAVB3AFqIAUoAtQBIAUoAtgBIAEoAhARAQAMAwsgBkUNAgsgCCgCsAEhCwsgBUG4AWoiBiAFQdgBaikDADcDACAFIAUpA9ABNwOwAQJAIAtFDQAgASgCACIJRQ0AIAhBwAFqIAgoArgBIAgoArwBIAkoAhARAQALIAhBATYCsAEgASAFKQOwATcCACABQQhqIAYpAwA3AgALIApFDQIgBSgCkAEiAUUNAiAFQZwBaiAFKAKUASAFKAKYASABKAIQEQEADAILDBoLDBoLAkAgCCgCkAFBgICAgHhGDQAgBSAENgKwASAFIAQgDEECdGo2ArQBIAVBOGogBUGwAWoQwykgBSgCOEEBcUUNACAIQZABaiEBIAUoAjwhCQNAIAVBMGogBUHoAGogCRDzGSABIAUoAjAgBSgCNBCGChCiFSAFQShqIAVBsAFqEMMpIAUoAiwhCSAFKAIoQQFxDQALCwJAIAgoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAIQdAAaiIGIAwQ7C0gDEUNASAMQQJ0IQoDQCAFQSBqIAVBsAFqIAQoAgAQ8xkgCCAFKAIgIAUoAiQiCRD1GyEsIAgoAlgiASAIKAJQRgRAIAZB8PjNABCzKAsgBEEEaiEEIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAmtfDcDSCAKQQRrIgoNAAsMAQsgBSkCaCEsIAggCCgCiAEgDGo2AogBIAUgLDcC0AECQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQsDQCAFQQhqIAVB0AFqIAQoAgAQ8xkgBSgCCCEJIAUgBSgCDCIGNgKwASABIAVBsAFqQQQQoTYgASAJIAYQoTYgCCAIKQOAASAGrXw3A4ABIARBBGohBCALQQRrIgsNAAsMAgsgDEUNASAIQeQAaiEGIAxBAnQhCgNAIAVBEGogBUHQAWogBCgCABDzGSAFKAIQIQkgCCgCcCELIAUgBSgCFCIBNgKQASAFQfAAaiALIAVBkAFqQQEQzxEgBSgCcEEIRw0dIAYgCSABEKE2IAggCCkDgAEgAa18NwOAASAEQQRqIQQgCkEEayIKDQALDAELIAxFDQAgCEHgAGohCyAEIAxBAnRqIQ8gCEHsAGohGANAIAVBGGogBUHQAWogBCgCABDzGSAFKAIYIQZBACEJAkAgCCgCdCIBIAUoAhwiCiABIApJGyIBRQ0AIAgoAnAhHANAIAkgHGotAAAgBiAJai0AAEcNASABIAlBAWoiCUcNAAsgASEJCyAIQQA2AnQgGCAGIAoQoTYgCSAKSw0dIAsgBiAJaiAKIAlrIgEQoTYgCCgCeCEGIAUgCTYCkAEgBUHwAGoiCSAGIAVBkAFqIgZBARDPESAFKAJwQQhHDR4gCCgCfCEcIAUgATYCkAEgCSAcIAZBARDPESAFKAJwQQhHDR8gCCAIKQOAASAKrXw3A4ABIARBBGoiBCAPRw0ACwsgBUHgAWokAAwOCyADQaAGaiAWIBUoAhARAAAgA0HACmogAygCoAYiASADKAKkBigCDBEAACABRQ0PIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNDyADQZgGaiABENQhIAMoApgGIgFFDQ8gASADKAKcBiALIAwgCBCJAgwNCyADQbAGaiAWIBUoAhARAAAgA0HACmogAygCsAYiASADKAK0BigCDBEAACABRQ0OIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDiADQagGaiABENQhIAMoAqgGIgFFDQ4gASADKAKsBiALIAwgCBCKAgwMCyADQcAGaiAWIBUoAhARAAAgA0HACmogAygCwAYiASADKALEBigCDBEAACABRQ0NIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDSADQbgGaiABENQhIAMoArgGIgFFDQ0gAygCvAYhBiALIQQjAEHgAWsiBSQAIAUgBjYCbCAFIAE2AmgCQCAILQDEAUUNACAFIAY2AqQBIAUgATYCoAEgBSAENgKoASAFIAQgDEECdGo2AqwBIAVB4ABqIAVBqAFqEMMpIAUoAmBBAXFFDQAgBUHYAGogBUGgAWogBSgCZBD9GSAFKAJcIQogBSgCWCEBIAUgBSkCqAE3ArABIAVB0ABqIAVBsAFqEMMpAkAgBSgCUEEBcUUEQCAKIQsgASEGDAELIAUoAlQhCSABIQYgCiELA0AgBUHIAGogBUGgAWogCRD9GSAFKAJIIg8gASAPIAEgBSgCTCIJIAogCSAKSRsQmSciASAJIAprIAEbQQBIIhgbIQEgCSAKIBgbIQogBiAPIA8gBiAJIAsgCSALSRsQmSciBiAJIAtrIAYbQQBIIg8bIQYgCyAJIA8bIQsgBUFAayAFQbABahDDKSAFKAJEIQkgBSgCQEEBcQ0ACwsgBUGwAWogCkEAQQFBARCgGCAFKAK0ASEPAkAgBSgCsAFBAUcEQCAFKAK4ASEJIAoEQCAJIAEgCvwKAAALIAUgCjYCuAEgBSAJNgK0ASAFIA82ArABIAVB0AFqIAVBsAFqIgEQ5xUgASALQQBBAUEBEKAYIAUoArQBIQogBSgCsAFBAUYNASAFKAK4ASEBIAsEQCABIAYgC/wKAAALIAUgCzYCmAEgBSABNgKUASAFIAo2ApABIAVBwAFqIgEgBUGQAWoiBhDnFSAFQbgBaiIJIAVB2AFqIgopAgAiLDcDACAFQfgAaiAsNwMAIAVBgAFqIgsgASkDADcDACAFQYgBaiIBIAVByAFqKQMANwMAIAUgBSkC0AEiLTcDsAEgBSAtNwNwIAVBmAFqIg8gLDcDACAFIC03A5ABIAogASkDADcDACAFIAspAwA3A9ABIAhBoAFqIQFBASEKAkAgCCgCnAEiC0EBRgRAIAEoAgBFDQFBASELIAUoApABBEAgASAGEMYpIQsLIAtB/wFxQQJGIAvAQQBMcg0BIAgoApwBIQsLIAkgDykDADcDACAFIAUpA5ABNwOwAQJAIAtFDQAgASgCACIGRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAYoAhARAQALIAhBATYCnAEgASAFKQOwATcCACABQQhqIAVBuAFqKQMANwIAQQAhCgsgCEG0AWohAQJAIAgoArABIgtBAUYEQCAFKALQASEGAkAgASgCAARAIAZFDQMgASAFQdABahDGKcBBAEgNASAFKALQASIBRQ0DIAVB3AFqIAUoAtQBIAUoAtgBIAEoAhARAQAMAwsgBkUNAgsgCCgCsAEhCwsgBUG4AWoiBiAFQdgBaikDADcDACAFIAUpA9ABNwOwAQJAIAtFDQAgASgCACIJRQ0AIAhBwAFqIAgoArgBIAgoArwBIAkoAhARAQALIAhBATYCsAEgASAFKQOwATcCACABQQhqIAYpAwA3AgALIApFDQIgBSgCkAEiAUUNAiAFQZwBaiAFKAKUASAFKAKYASABKAIQEQEADAILDBcLDBcLAkAgCCgCkAFBgICAgHhGDQAgBSAENgKwASAFIAQgDEECdGo2ArQBIAVBOGogBUGwAWoQwykgBSgCOEEBcUUNACAIQZABaiEBIAUoAjwhCQNAIAVBMGogBUHoAGogCRD9GSABIAUoAjAgBSgCNBCGChCiFSAFQShqIAVBsAFqEMMpIAUoAiwhCSAFKAIoQQFxDQALCwJAIAgoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAIQdAAaiIGIAwQ7C0gDEUNASAMQQJ0IQoDQCAFQSBqIAVBsAFqIAQoAgAQ/RkgCCAFKAIgIAUoAiQiCRD1GyEsIAgoAlgiASAIKAJQRgRAIAZB8PjNABCzKAsgBEEEaiEEIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAmtfDcDSCAKQQRrIgoNAAsMAQsgBSkCaCEsIAggCCgCiAEgDGo2AogBIAUgLDcC0AECQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQsDQCAFQQhqIAVB0AFqIAQoAgAQ/RkgBSgCCCEJIAUgBSgCDCIGNgKwASABIAVBsAFqQQQQoTYgASAJIAYQoTYgCCAIKQOAASAGrXw3A4ABIARBBGohBCALQQRrIgsNAAsMAgsgDEUNASAIQeQAaiEGIAxBAnQhCgNAIAVBEGogBUHQAWogBCgCABD9GSAFKAIQIQkgCCgCcCELIAUgBSgCFCIBNgKQASAFQfAAaiALIAVBkAFqQQEQzxEgBSgCcEEIRw0aIAYgCSABEKE2IAggCCkDgAEgAa18NwOAASAEQQRqIQQgCkEEayIKDQALDAELIAxFDQAgCEHgAGohCyAEIAxBAnRqIQ8gCEHsAGohGANAIAVBGGogBUHQAWogBCgCABD9GSAFKAIYIQZBACEJAkAgCCgCdCIBIAUoAhwiCiABIApJGyIBRQ0AIAgoAnAhHANAIAkgHGotAAAgBiAJai0AAEcNASABIAlBAWoiCUcNAAsgASEJCyAIQQA2AnQgGCAGIAoQoTYgCSAKSw0aIAsgBiAJaiAKIAlrIgEQoTYgCCgCeCEGIAUgCTYCkAEgBUHwAGoiCSAGIAVBkAFqIgZBARDPESAFKAJwQQhHDRsgCCgCfCEcIAUgATYCkAEgCSAcIAZBARDPESAFKAJwQQhHDRwgCCAIKQOAASAKrXw3A4ABIARBBGoiBCAPRw0ACwsgBUHgAWokAAwLCyADQdAGaiAWIBUoAhARAAAgA0HACmogAygC0AYiASADKALUBigCDBEAACABRQ0MIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0MIANByAZqIAEQ1CEgAygCyAYiAUUNDCADKALMBiEGIAshBCMAQeABayIFJAAgBSAGNgJsIAUgATYCaAJAIAgtAMQBRQ0AIAUgBjYCpAEgBSABNgKgASAFIAQ2AqgBIAUgBCAMQQJ0ajYCrAEgBUHgAGogBUGoAWoQwykgBSgCYEEBcUUNACAFQdgAaiAFQaABaiAFKAJkEPoZIAUoAlwhCiAFKAJYIQEgBSAFKQKoATcCsAEgBUHQAGogBUGwAWoQwykCQCAFKAJQQQFxRQRAIAohCyABIQYMAQsgBSgCVCEJIAEhBiAKIQsDQCAFQcgAaiAFQaABaiAJEPoZIAUoAkgiDyABIA8gASAFKAJMIgkgCiAJIApJGxCZJyIBIAkgCmsgARtBAEgiGBshASAJIAogGBshCiAGIA8gDyAGIAkgCyAJIAtJGxCZJyIGIAkgC2sgBhtBAEgiDxshBiALIAkgDxshCyAFQUBrIAVBsAFqEMMpIAUoAkQhCSAFKAJAQQFxDQALCyAFQbABaiAKQQBBAUEBEKAYIAUoArQBIQ8CQCAFKAKwAUEBRwRAIAUoArgBIQkgCgRAIAkgASAK/AoAAAsgBSAKNgK4ASAFIAk2ArQBIAUgDzYCsAEgBUHQAWogBUGwAWoiARDnFSABIAtBAEEBQQEQoBggBSgCtAEhCiAFKAKwAUEBRg0BIAUoArgBIQEgCwRAIAEgBiAL/AoAAAsgBSALNgKYASAFIAE2ApQBIAUgCjYCkAEgBUHAAWoiASAFQZABaiIGEOcVIAVBuAFqIgkgBUHYAWoiCikCACIsNwMAIAVB+ABqICw3AwAgBUGAAWoiCyABKQMANwMAIAVBiAFqIgEgBUHIAWopAwA3AwAgBSAFKQLQASItNwOwASAFIC03A3AgBUGYAWoiDyAsNwMAIAUgLTcDkAEgCiABKQMANwMAIAUgCykDADcD0AEgCEGgAWohAUEBIQoCQCAIKAKcASILQQFGBEAgASgCAEUNAUEBIQsgBSgCkAEEQCABIAYQxikhCwsgC0H/AXFBAkYgC8BBAExyDQEgCCgCnAEhCwsgCSAPKQMANwMAIAUgBSkDkAE3A7ABAkAgC0UNACABKAIAIgZFDQAgCEGsAWogCCgCpAEgCCgCqAEgBigCEBEBAAsgCEEBNgKcASABIAUpA7ABNwIAIAFBCGogBUG4AWopAwA3AgBBACEKCyAIQbQBaiEBAkAgCCgCsAEiC0EBRgRAIAUoAtABIQYCQCABKAIABEAgBkUNAyABIAVB0AFqEMYpwEEASA0BIAUoAtABIgFFDQMgBUHcAWogBSgC1AEgBSgC2AEgASgCEBEBAAwDCyAGRQ0CCyAIKAKwASELCyAFQbgBaiIGIAVB2AFqKQMANwMAIAUgBSkD0AE3A7ABAkAgC0UNACABKAIAIglFDQAgCEHAAWogCCgCuAEgCCgCvAEgCSgCEBEBAAsgCEEBNgKwASABIAUpA7ABNwIAIAFBCGogBikDADcCAAsgCkUNAiAFKAKQASIBRQ0CIAVBnAFqIAUoApQBIAUoApgBIAEoAhARAQAMAgsMFgsMFgsCQCAIKAKQAUGAgICAeEYNACAFIAQ2ArABIAUgBCAMQQJ0ajYCtAEgBUE4aiAFQbABahDDKSAFKAI4QQFxRQ0AIAhBkAFqIQEgBSgCPCEJA0AgBUEwaiAFQegAaiAJEPoZIAEgBSgCMCAFKAI0EIYKEKIVIAVBKGogBUGwAWoQwykgBSgCLCEJIAUoAihBAXENAAsLAkAgCCgCAEGAgICAeEcEQCAFIAUpAmg3ArABIAhB0ABqIgYgDBDsLSAMRQ0BIAxBAnQhCgNAIAVBIGogBUGwAWogBCgCABD6GSAIIAUoAiAgBSgCJCIJEPUbISwgCCgCWCIBIAgoAlBGBEAgBkHw+M0AELMoCyAEQQRqIQQgCCgCVCABQQN0aiAsNwMAIAggAUEBajYCWCAIIAgpA0ggCa18NwNIIApBBGsiCg0ACwwBCyAFKQJoISwgCCAIKAKIASAMajYCiAEgBSAsNwLQAQJAAkACQEECIAgoAmAiAUGAgICAeHMgAUEAThtBAWsOAgECAAsgDEUNAiAIQeQAaiEBIAxBAnQhCwNAIAVBCGogBUHQAWogBCgCABD6GSAFKAIIIQkgBSAFKAIMIgY2ArABIAEgBUGwAWpBBBChNiABIAkgBhChNiAIIAgpA4ABIAatfDcDgAEgBEEEaiEEIAtBBGsiCw0ACwwCCyAMRQ0BIAhB5ABqIQYgDEECdCEKA0AgBUEQaiAFQdABaiAEKAIAEPoZIAUoAhAhCSAIKAJwIQsgBSAFKAIUIgE2ApABIAVB8ABqIAsgBUGQAWpBARDPESAFKAJwQQhHDRkgBiAJIAEQoTYgCCAIKQOAASABrXw3A4ABIARBBGohBCAKQQRrIgoNAAsMAQsgDEUNACAIQeAAaiELIAQgDEECdGohDyAIQewAaiEYA0AgBUEYaiAFQdABaiAEKAIAEPoZIAUoAhghBkEAIQkCQCAIKAJ0IgEgBSgCHCIKIAEgCkkbIgFFDQAgCCgCcCEcA0AgCSAcai0AACAGIAlqLQAARw0BIAEgCUEBaiIJRw0ACyABIQkLIAhBADYCdCAYIAYgChChNiAJIApLDRkgCyAGIAlqIAogCWsiARChNiAIKAJ4IQYgBSAJNgKQASAFQfAAaiIJIAYgBUGQAWoiBkEBEM8RIAUoAnBBCEcNGiAIKAJ8IRwgBSABNgKQASAJIBwgBkEBEM8RIAUoAnBBCEcNGyAIIAgpA4ABIAqtfDcDgAEgBEEEaiIEIA9HDQALCyAFQeABaiQADAoLIANB4AZqIBYgFSgCEBEAACADQcAKaiADKALgBiIBIAMoAuQGKAIMEQAAIAFFDQsgAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0LIANB2AZqIAEQ1CEgAygC2AYiAUUNCyABIAMoAtwGIAsgDCAIEIkCDAkLIANB8AZqIBYgFSgCEBEAACADQcAKaiADKALwBiIBIAMoAvQGKAIMEQAAIAFFDQogAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQogA0HoBmogARDUISADKALoBiIBBEAgASADKALsBiALIAwgCBCKAgwJCwwKCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcUCyADQYAFaiAWIBUoAhARAAAgA0HACmogAygCgAUiASADKAKEBSgCDBEAACABRQ0QIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRAgA0H4BGogARDgISADKAL4BCIBRQ0QIAEgAygC/AQgCyAMIAgQgwIMDgsgA0GQBWogFiAVKAIQEQAAIANBwApqIAMoApAFIgEgAygClAUoAgwRAAAgAUUNDyADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNDyADQYgFaiABEOAhIAMoAogFIgFFDQ8gASADKAKMBSALIAwgCBCEAgwNCyADQaAFaiAWIBUoAhARAAAgA0HACmogAygCoAUiASADKAKkBSgCDBEAACABRQ0OIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNDiADQZgFaiABEOAhIAMoApgFIgFFDQ4gASADKAKcBSALIAwgCBCFAgwMCyADQbAFaiAWIBUoAhARAAAgA0HACmogAygCsAUiASADKAK0BSgCDBEAACABRQ0NIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDSADQagFaiABEOAhIAMoAqgFIgFFDQ0gASADKAKsBSALIAwgCBCGAgwLCyADQcAFaiAWIBUoAhARAAAgA0HACmogAygCwAUiASADKALEBSgCDBEAACABRQ0MIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDCADQbgFaiABEOAhIAMoArgFIgFFDQwgASADKAK8BSALIAwgCBCHAgwKCyADQdAFaiAWIBUoAhARAAAgA0HACmogAygC0AUiASADKALUBSgCDBEAACABRQ0LIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0LIANByAVqIAEQ4CEgAygCyAUiAUUNCyABIAMoAswFIAsgDCAIEIgCDAkLIANB4AVqIBYgFSgCEBEAACADQcAKaiADKALgBSIBIAMoAuQFKAIMEQAAIAFFDQogAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0KIANB2AVqIAEQ4CEgAygC2AUiAUUNCiABIAMoAtwFIAsgDCAIEIUCDAgLIANB8AVqIBYgFSgCEBEAACADQcAKaiADKALwBSIBIAMoAvQFKAIMEQAAIAFFDQkgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQkgA0HoBWogARDgISADKALoBSIBBEAgASADKALsBSALIAwgCBCGAgwICwwJCyADIAQ2AuAKIANBAjYCxAogA0GI+80ANgLACgwHCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQcAEaiADQcAKahDDKSADKALABEEBcUUNACAIQZABaiEBIAMoAsQEIQoDQCADQbgEaiADQfwJaiAKEKQqIAEgAygCuAQgAygCvAQQhgoQohUgA0GwBGogA0HACmoQwykgAygCtAQhCiADKAKwBEEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBiAMQQJ0IQUDQCADQagEaiADQcAKaiALKAIAEKQqIAggAygCqAQgAygCrAQiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBgsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0HIAhB5ABqIQEgDEECdCEFA0AgA0GQBGogA0GgCmogCygCABCkKiADKAKQBCEGIAMgAygClAQiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAcLIAxFDQYgCEHkAGohBCAMQQJ0IQUDQCADQZgEaiADQaAKaiALKAIAEKQqIAMoApgEIQYgCCgCcCEJIAMgAygCnAQiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQ0gBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBgsgDEUNBSAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQaAEaiADQaAKaiALKAIAEKQqIAMoAqAEIQRBACEKAkAgCCgCdCIBIAMoAqQEIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDiAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDyAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwGCwwOCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQdgDaiADQcAKahDDKSADKALYA0EBcUUNACAIQZABaiEBIAMoAtwDIQoDQCADQdADaiADQfwJaiAKEKsqIAEgAygC0AMgAygC1AMQhgoQohUgA0HIA2ogA0HACmoQwykgAygCzAMhCiADKALIA0EBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBSAMQQJ0IQUDQCADQcADaiADQcAKaiALKAIAEKsqIAggAygCwAMgAygCxAMiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBQsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0GIAhB5ABqIQEgDEECdCEFA0AgA0GoA2ogA0GgCmogCygCABCrKiADKAKoAyEGIAMgAygCrAMiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAYLIAxFDQUgCEHkAGohBCAMQQJ0IQUDQCADQbADaiADQaAKaiALKAIAEKsqIAMoArADIQYgCCgCcCEJIAMgAygCtAMiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQwgBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBQsgDEUNBCAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQbgDaiADQaAKaiALKAIAEKsqIAMoArgDIQRBACEKAkAgCCgCdCIBIAMoArwDIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDSAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDiAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwFCwwNCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQfACaiADQcAKahDDKSADKALwAkEBcUUNACAIQZABaiEBIAMoAvQCIQoDQCADQegCaiADQfwJaiAKEKgqIAEgAygC6AIgAygC7AIQhgoQohUgA0HgAmogA0HACmoQwykgAygC5AIhCiADKALgAkEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBCAMQQJ0IQUDQCADQdgCaiADQcAKaiALKAIAEKgqIAggAygC2AIgAygC3AIiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBAsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0FIAhB5ABqIQEgDEECdCEFA0AgA0HAAmogA0GgCmogCygCABCoKiADKALAAiEGIAMgAygCxAIiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAULIAxFDQQgCEHkAGohBCAMQQJ0IQUDQCADQcgCaiADQaAKaiALKAIAEKgqIAMoAsgCIQYgCCgCcCEJIAMgAygCzAIiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQsgBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBAsgDEUNAyAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQdACaiADQaAKaiALKAIAEKgqIAMoAtACIQRBACEKAkAgCCgCdCIBIAMoAtQCIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDCAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDSAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwECwwMCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQYgCaiADQcAKahDDKSADKAKIAkEBcUUNACAIQZABaiEBIAMoAowCIQoDQCADQYACaiADQfwJaiAKEKUqIAEgAygCgAIgAygChAIQhgoQohUgA0H4AWogA0HACmoQwykgAygC/AEhCiADKAL4AUEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNAyAMQQJ0IQUDQCADQfABaiADQcAKaiALKAIAEKUqIAggAygC8AEgAygC9AEiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMAwsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0EIAhB5ABqIQEgDEECdCEFA0AgA0HYAWogA0GgCmogCygCABClKiADKALYASEGIAMgAygC3AEiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAQLIAxFDQMgCEHkAGohBCAMQQJ0IQUDQCADQeABaiADQaAKaiALKAIAEKUqIAMoAuABIQYgCCgCcCEJIAMgAygC5AEiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQogBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMAwsgDEUNAiAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQegBaiADQaAKaiALKAIAEKUqIAMoAugBIQRBACEKAkAgCCgCdCIBIAMoAuwBIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNCyAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDCAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwDCwwLCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQaABaiADQcAKahDDKSADKAKgAUEBcUUNACAIQZABaiEBIAMoAqQBIQoDQCADQZgBaiADQfwJaiAKEKoqIAEgAygCmAEgAygCnAEQhgoQohUgA0GQAWogA0HACmoQwykgAygClAEhCiADKAKQAUEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNAiAMQQJ0IQUDQCADQYgBaiADQcAKaiALKAIAEKoqIAggAygCiAEgAygCjAEiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMAgsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0DIAhB5ABqIQEgDEECdCEFA0AgA0HwAGogA0GgCmogCygCABCqKiADKAJwIQYgAyADKAJ0IgQ2AsAKIAEgA0HACmpBBBChNiABIAYgBBChNiAIIAgpA4ABIAStfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwDCyAMRQ0CIAhB5ABqIQQgDEECdCEFA0AgA0H4AGogA0GgCmogCygCABCqKiADKAJ4IQYgCCgCcCEJIAMgAygCfCIBNgLgCiADQYAKaiAJIANB4ApqQQEQzxEgAygCgApBCEcNCSAEIAYgARChNiAIIAgpA4ABIAGtfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwCCyAMRQ0BIAhB4ABqIQYgCyAMQQJ0aiEJIAhB7ABqIQ8CQANAIANBgAFqIANBoApqIAsoAgAQqiogAygCgAEhBEEAIQoCQCAIKAJ0IgEgAygChAEiBSABIAVJGyIBRQ0AIAgoAnAhGANAIAogGGotAAAgBCAKai0AAEcNASABIApBAWoiCkcNAAsgASEKCyAIQQA2AnQgDyAEIAUQoTYgBSAKSQ0KIAYgBCAKaiAFIAprIgEQoTYgCCgCeCEEIAMgCjYC4AogA0GACmoiCiAEIANB4ApqIgRBARDPESADKAKACkEIRw0LIAgoAnwhGCADIAE2AuAKIAogGCAEQQEQzxEgAygCgApBCEcNASAIIAgpA4ABIAWtfDcDgAEgC0EEaiILIAlHDQALDAILDAoLAkAgCCgCkAFBgICAgHhGDQAgAyALNgLACiADIAsgDEECdGo2AsQKIANBOGogA0HACmoQwykgAygCOEEBcUUNACAIQZABaiEBIAMoAjwhCgNAIANBMGogA0H8CWogChCpKiABIAMoAjAgAygCNBCGChCiFSADQShqIANBwApqEMMpIAMoAiwhCiADKAIoQQFxDQALCyAIKAIAQYCAgIB4RwRAIAMgAygC/Ak2AsAKIAhB0ABqIgQgDBDsLSAMRQ0BIAxBAnQhBQNAIANBIGogA0HACmogCygCABCpKiAIIAMoAiAgAygCJCIGEPUbISwgCCgCWCIBIAgoAlBGBEAgBEHw+M0AELMoCyALQQRqIQsgCCgCVCABQQN0aiAsNwMAIAggAUEBajYCWCAIIAgpA0ggBq18NwNIIAVBBGsiBQ0ACwwBCyADKAL8CSEBIAggCCgCiAEgDGo2AogBIAMgATYCoAoCQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQUDQCADQQhqIANBoApqIAsoAgAQqSogAygCCCEGIAMgAygCDCIENgLACiABIANBwApqQQQQoTYgASAGIAQQoTYgCCAIKQOAASAErXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMAgsgDEUNASAIQeQAaiEEIAxBAnQhBQNAIANBEGogA0GgCmogCygCABCpKiADKAIQIQYgCCgCcCEJIAMgAygCFCIBNgLgCiADQYAKaiAJIANB4ApqQQEQzxEgAygCgApBCEcNCCAEIAYgARChNiAIIAgpA4ABIAGtfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwBCyAMRQ0AIAhB4ABqIQYgCyAMQQJ0aiEJIAhB7ABqIQ8DQCADQRhqIANBoApqIAsoAgAQqSogAygCGCEEQQAhCgJAIAgoAnQiASADKAIcIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNCCAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNCSAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQogCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwsgJUEINgIAIANB8ApqJAAMDwsgA0IBNwLMCiADQacENgKECiADIANBgApqNgLICiADIANB4ApqNgKACiADQcAKakH0+c0AEO8sAAtB9PnNABCyOwALIAogAygCyApBtPXNABD9LwALIAEgAygCyApBtPXNABD9LwALQYT6zQBBKEH0+c0AEJ8pAAsgA0HQCmogA0GQCmopAwA3AwAgA0HICmogA0GICmopAwA3AwAgAyADKQOACjcDwApByPHNAEErIANBwApqQbjxzQBBoPbNABDVHgALIAogBUHQ9s0AEK87AAsgA0HQCmogA0GQCmopAwA3AwAgA0HICmogA0GICmopAwA3AwAgAyADKQOACjcDwApByPHNAEErIANBwApqQbjxzQBB8PbNABDVHgALIANB0ApqIANBkApqKQMANwMAIANByApqIANBiApqKQMANwMAIAMgAykDgAo3A8AKQcjxzQBBKyADQcAKakG48c0AQYD3zQAQ1R4ACyAPIAUoArgBQbT1zQAQ/S8ACyAKIAUoArgBQbT1zQAQ/S8ACyAFQcABaiAFQYABaikDADcDACAFQbgBaiAFQfgAaikDADcDACAFIAUpA3A3A7ABQcjxzQBBKyAFQbABakG48c0AQaD2zQAQ1R4ACyAJIApB0PbNABCvOwALIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBB8PbNABDVHgALIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBgPfNABDVHgALIBIoAhgiAUEIRwRAIBkgEikCHDcCBCAZQRRqIBJBLGooAgA2AgAgGUEMaiASQSRqKQIANwIAIBkgATYCAAwFCyAUIBQoAoAEIA1qIgE2AoAEIAENAgwDCyARIAFBqP/OABCxOwALIAEgH0Go/84AELA7AAsgFCgChAQgFCgCnAUoApABSQRAAn8gCCgCAEGAgICAeEcEQCAIKAJYIgFBA3YgAUEHcUEAR2oiAUEgIAgoAhQiBEEBayIGQQAgBCAGTxtnIgRrIgZBA3YgBkEHcUEAR2pBAWpsIgYgAUEhIARrbCIBIAEgBkkbQQFqDAELAn8CQAJAAkBBAiAIQeAAaiIBKAIAIgRBgICAgHhzIARBAE4bQQFrDgIBAgALIAEoAgwMAgsgASgCECIEKAIoIAEoAgxqIAQtACwiAUEDdiABQQdxQQBHamoMAQsgASgCHCIEKAIoIAEoAhgiBigCKCABKAIIamogBi0ALCIBQQN2IAFBB3FBAEdqaiAELQAsIgFBA3YgAUEHcUEAR2pqCwsgFCgCnAUoAowBSQ0BCyASQRhqIBQQzAEgEigCGCIBQQhGDQAgGSASKQIcNwIEIBlBFGogEkEsaigCADYCACAZQQxqIBJBJGopAgA3AgAgGSABNgIADAELAkAgCCgCAEGAgICAeEYNACAUKAK4ASAUKAKcBUEIaiAUKAKYBUEIahDQEUkNACASQRhqIQQjAEHAAWsiASQAAkACQCAUKAKABEUNACABQSBqIBQQzAEgASgCICIGQQhGDQAgBCABKQIkNwIEIARBFGogAUE0aigCADYCACAEQQxqIAFBLGopAgA3AgAgBCAGNgIADAELIAFBIGogFBCKByABKAIgIgZBCEcEQCAEIAEpAiQ3AgQgBEEUaiABQTRqKAIANgIAIARBDGogAUEsaikCADcCACAEIAY2AgAMAQsCQAJAIBQoAoAERQ0AIAFBqAFqIBQQzAEgASgCqAEiCUEIRg0ADAELAkAgFCgCjAMiCUUNACABQShqIQYDQCAUIAlBAWs2AowDIBQgFCgCiAMiCUEBaiIKIBQoAoADIgtBACAKIAtPG2s2AogDIBQoAoQDIAlBiAFsaiIJKQMAIixCDFENASABICw3AyAgBiAJQQhqQYAB/AoAACABQagBaiAUIAFBIGoQpQogASgCqAEiCUEIRw0CIBQoAowDIgkNAAsLIARBCDYCAAwBCyABQRhqIgYgAUG8AWooAgA2AgAgAUEQaiIKIAFBtAFqKQIANwMAIAEgASkCrAE3AwggBCAJNgIAIAQgASkDCDcCBCAEQQxqIAopAwA3AgAgBEEUaiAGKAIANgIACyABQcABaiQAIBIoAhgiAUEIRg0AIBkgEikCHDcCBCAZQRRqIBJBLGooAgA2AgAgGUEMaiASQSRqKQIANwIAIBkgATYCAAwBCyAZQQg2AgAgGSAMNgIECyASQUBrJAAgGygCHCEBIBsoAhgiBEEIRwRAIB0gGykDIDcDCCAdQRBqIBtBKGopAwA3AwAgHSABNgIEIB0gBDYCAAwHCyABIBFqIREgEyAQIglNDQUMAQsLIAkgEEGY/s4AELE7AAsgECAXQZj+zgAQsDsACyAJIBBBqP7OABCxOwALIBAgDkGo/s4AELA7AAsgHUEINgIAIB0gETYCBAsgG0EwaiQAIAcoAlAiAUEIRg0YICEgBykDWDcDCCAhQRBqIAdB4ABqKQMANwMAICEgBygCVDYCBCAhIAE2AgAMGQsgBCAHKAJYQdjxzwAQ/S8ACyABIAcoAlhBsOjPABD9LwALIAkgBygCWEGY9M8AEP0vAAsgByAEEP47NgKYAQwWC0H48M8AELI7AAsgBCAHKAJYQbj0zwAQ/S8ACyAEIAcoAlhB2PLPABD9LwALIAcgChD8OzYCmAEMEgsgEUEEQejyzwAQrzsACyAEIAcoAlhBiPPPABD9LwALIAcgChD9OzYCzAEMEQsgEUEIQZjzzwAQrzsACyAEIAcoAlhBuPPPABD9LwALIAcgChD/OzYCzAEMDgsgEUEQQcjzzwAQrzsAC0GI8c8AELI7AAsgCSAHKAJYQejzzwAQ/S8ACyAHIAQQgDw2AswBIAdBAjYCuAEgB0HQ5c8ANgK0ASAHQgI3AsABIAdBOzYC3AEgB0E7NgLUASAHIAdB0AFqNgK8ASAHIAdBzAFqNgLYASAHIAdBsAFqNgLQASAHQbQBakHg5c8AEO8sAAsgA0EgQfjzzwAQrzsACyAQIAcoArwBQbDozwAQ/S8AC0Gc8M8AELI7AAtBrPDPABCyOwALIAdBOGohDCAGQRBqIQ4gBygCjAEhASAHKAKQASEQIAsoAhBBACALKAIMQYCAgIB4RxshFSALKAIUIRcgCygCHEEAIAsoAhhBgICAgHhHGyESIAsoAiAhFEEAIQZBACEKIwBBMGsiCCQAAkACQCAVQQAgEhtFBEAgECETIBVFDQEgFyETDAELIBQgFyITRg0AIAggEzYCACAIIBQ2AgQgCEECNgIcIAhBiP7OADYCGCAIQgI3AiQgCEE7NgIUIAhBOzYCDCAIIAhBCGo2AiAgCCAIQQRqNgIQIAggCDYCCCAMQQRqIAhBGGoQmQ4gDEEANgIADAELIA4oAqgBRQRAIA4gLDcD2AELIA5CADcD0AECQAJAAkACQCATBEAgDigChAUoApQBIRYDQAJAIBJFIAYgFmoiBCATIAQgE0kbIgkgFE9yDQAgEiAJQQF0aiEEA0AgBC8BAEUNASAEQQJqIQQgFCAJQQFqIglHDQALIBQhCQtBACEEQQAhAyAVBEAgBiAJSw0DIAkgF0sNBCAVIAZBAXRqIQMLIBIEQCAGIAlLDQUgCSAUSw0GIBIgBkEBdGohBAsgCEEYaiEFIwBBQGoiDSQAIAkgBmsiBiELAkACQCAOKAKABSIPLgEYIhFBAEoEfyADRQRAIA1BATYCHCANQfj/zgA2AhggDUIBNwIkIA1BzQE2AjggDSAROwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAUgDSkCDDcCDCAFQRRqIA1BFGooAgA2AgAgBSANKQIENwIEIAVBADYCAAwDC0EAIQsgBgRAIBFB//8DcSEZIAMhESAGIQ8DQCALIBEvAQAgGUZqIQsgEUECaiERIA9BAWsiDw0ACwsgDiAOKQPIAyAGIAtrrXw3A8gDIA4oAtwDQYCAgIB4RwRAIA5B3ANqIAMgBhDXIQsgDkHoBGogAyAGEPgpIA4oAoAFBSAPCy4BGiIRQQBMBEAgDiAOKALsAyAGajYC7AMMAQsgBARAIAYEQCAELwEABEAgDUEBNgIcIA1BkP/OADYCGCANQgE3AiQgDUHNATYCBCANIAQ2AgAgDSANNgIgIAVBBGogDUEYahCZDiAFQQA2AgAMBAsgBkEBdCEDIA4oAuwDIQ8gBCERA0AgDyARLwEARWohDyARQQJqIREgA0ECayIDDQALIA4gDzYC7AMLIA4oAtADQYCAgIB4RwRAIA5B0ANqIAQgBhDXIQsgDkH0BGogBCAGEPgpDAELIA1BATYCHCANQcCAzwA2AhggDUIBNwIkIA1BzQE2AjggDSAROwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAUgDSkCDDcCDCAFQRRqIA1BFGooAgA2AgAgBSANKQIENwIEIAVBADYCAAwBCyANQRhqIREjAEHQAGsiBCQAIA4gDigCqAEgC2o2AqgBIAQgCzYCBAJAIAsgCiALaiIDTSADIBBNcUUEQCAEIBAgCms2AjwgBEECNgIoIARBiInOADYCJCAEQgI3AjAgBEE7NgJMIARBOzYCRCAEIARBQGs2AiwgBCAEQTxqNgJIIAQgBEEEajYCQCAEQQhqQQRyIARBJGoQmQ4gESAEKQIUNwIMIBFBFGogBEEcaigCADYCACARIAQpAgw3AgQgEUEANgIADAELIBEgDiABIApBBHRqIAsQhA4LIARB0ABqJAAgDSgCGCIEQQhHBEAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELIA4gDigC6AMgBmoiBDYC6AMCQCAERQ0AIA4oAuwDIA4oAoQFKAKQAUkEQCAOELwcIA4oAoQFKAKMAUkNAQsgDUEYaiAOEMoBIA0oAhgiBEEIRg0AIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCwJAIA4oAlhBgICAgHhGDQAgDigCTCAOKAKEBUEIaiAOKAKABUEIahDQEUkNACANQRhqIREjAEHAAWsiBCQAAkACQCAOKALoA0UNACAEQSBqIA4QygEgBCgCICIGQQhGDQAgESAEKQIkNwIEIBFBFGogBEE0aigCADYCACARQQxqIARBLGopAgA3AgAgESAGNgIADAELIARBIGogDhCNByAEKAIgIgZBCEcEQCARIAQpAiQ3AgQgEUEUaiAEQTRqKAIANgIAIBFBDGogBEEsaikCADcCACARIAY2AgAMAQsCQAJAIA4oAugDRQ0AIARBqAFqIA4QygEgBCgCqAEiBkEIRg0ADAELAkAgDigC9AIiBkUNACAEQShqIQMDQCAOIAZBAWs2AvQCIA4gDigC8AIiBkEBaiIPIA4oAugCIhlBACAPIBlPG2s2AvACIA4oAuwCIAZBiAFsaiIGKQMAIixCDFENASAEICw3AyAgAyAGQQhqQYAB/AoAACAEQagBaiAOIARBIGoQpgogBCgCqAEiBkEIRw0CIA4oAvQCIgYNAAsLIBFBCDYCAAwBCyAEQRhqIgMgBEG8AWooAgA2AgAgBEEQaiIPIARBtAFqKQIANwMAIAQgBCkCrAE3AwggESAGNgIAIBEgBCkDCDcCBCARQQxqIA8pAwA3AgAgEUEUaiADKAIANgIACyAEQcABaiQAIA0oAhgiBEEIRg0AIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCyAFQQg2AgAgBSALNgIECyANQUBrJAAgCCgCHCEEIAgoAhgiBkEIRwRAIAwgCCkDIDcDCCAMQRBqIAhBKGopAwA3AwAgDCAENgIEIAwgBjYCAAwHCyAEIApqIQogEyAJIgZLDQALCyAMQQg2AgAgDCAKNgIEDAQLIAYgCUGY/s4AELE7AAsgCSAXQZj+zgAQsDsACyAGIAlBqP7OABCxOwALIAkgFEGo/s4AELA7AAsgCEEwaiQAIBAEQANAIAEoAgAiBARAIAFBDGogAUEEaigCACABQQhqKAIAIAQoAhARAQALIAFBEGohASAQQQFrIhANAAsLIAdBiAFqQQRBEBDgHgsgBygCOCIBQQhGDQAgISAHKQNANwMIICFBEGogB0HIAGopAwA3AwAgISAHKAI8NgIEICEgATYCAAwBCyAhQQg2AgALIAdB4AFqJAAMBgsgB0ECNgJUIAdB0OXPADYCUCAHQgI3AlwgB0E7NgLAASAHQTs2ArgBIAcgB0G0AWo2AlggByAHQZgBajYCvAEgByAHQcwBajYCtAEMAgsgAyAHKAJYQbDozwAQ/S8ACyAHQQI2AlQgB0HQ5c8ANgJQIAdCAjcCXCAHQTs2AsABIAdBOzYCuAEgByAHQbQBajYCWCAHIAdBzAFqNgK8ASAHIAdBsAFqNgK0AQsgB0HQAGpB4OXPABDvLAALIBMgAUGY/s4AELA7AAsgBCAJKAIcQaCDzgAQ/S8ACyAaKAK4ASIBQQhHBEAgACAaKQK8ATcCBCAAQRRqIBpBzAFqKAIANgIAIABBDGogGkHEAWopAgA3AgAgACABNgIAICsQwiAgGkEcahDnIAwGCyAjQbgFaiEjIBpB8ABqEMIgIBooAiAiASAaKAIoRw0ACwsgGkEcahDnICACQQFqIgIgJkcNAQwCCwtB6OnPABCyOwALIABBCDYCAAsgGkHQAWokAA8LIBMgF0Go/s4AELA7AAurBAECfyMAQeAAayIEJAAgBCACNgIEAkACQCACQYACRgRAIARBIGogASADQQR0QfABcSIFQQF0aiICQRhqKQEANwMAIARBGGogAkEQaikBADcDACAEQRBqIAJBCGopAQA3AwAgBCACKQEANwMIIANB/wFxRQ0CIAVBEGsiAkGBAk8NASAEQUBrIAEgAkEBdGoiAkEYaikBADcDACAEQThqIAJBEGopAQA3AwAgBEEwaiACQQhqKQEANwMAIAQgAikBADcDKEEAIQIDQCAEQQhqIAJqIgMgAy8BACAEQShqIAJqLwEAazsBACACQQJqIgJBIEcNAAsMAgsgBEEANgIoQQAgBEEEakG88dEAIARBKGpBxPLRABCvKwALIARBADYCOCAEQQE2AiwgBEGA8NEANgIoIARCBDcCMCAEQShqQZTy0QAQ7ywACyAEQUBrIAFB+ANqKQEANwMAIARBOGogAUHwA2opAQA3AwAgBEEwaiABQegDaikBADcDACAEIAEpAeADNwMoQQAhAgJAAkADQCAEQQhqIAJqIgEvAQAiA0UNASAEQShqIAJqIgEvAQAiBUUNAiAAIAAqAgAgA0ECdEHMhuMAaioCACAFQQJ0QcyG4wBqKgIAk5M4AgAgAEEEaiEAIAJBAmoiAkEgRw0ACyAEQeAAaiQADwsgBEEANgJIIAEgBEHIAGpBpPLRABCNKwALIARBADYCSCABIARByABqQbTy0QAQjSsAC/8PAQV/IwBBEGsiBSQAAkACQAJAAkACQAJAAkACQCACQQFrDggCAwEEAQEBBQALIAJBEEYNBQtB4PHQAEEbQfzx0AAQnykACyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINBCABQRVPBEAgBUEMaiEDAkAgAg0AAkACQAJAIABBAWogACADKAIAIgQoAgAoAgARAgAiBkEATgRAQQIhAiABQQJGDQEgBCgCACEEA0AgACACaiIHIAdBAWsgBCgCABECAEEASA0CIAEgAkEBaiICRw0ACwwCC0ECIQIgAUECRg0AIAQoAgAhBANAIAAgAmoiByAHQQFrIAQoAgARAgBBAE4NASABIAJBAWoiAkcNAAsMAQsgASACRw0BCyAGQQBODQEgAUEBdiEDIAAgAWpBAWshAgNAIAAtAAAhASAAIAItAAA6AAAgAiABOgAAIAJBAWshAiAAQQFqIQAgA0EBayIDDQALDAELIAAgAUEAIAFBAXJnQQF0QT5zIAMQ5Q4LDAULQQEhAgNAIAAgACACaiAFQQxqEMAeIAEgAkEBaiICRw0ACwwECyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINAyABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBAmoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQJqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBAmohAiADKAIAIQgDQCACQQJqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELIAdBAE4NASABQQF2IQIgAUEBdCAAakECayEEA0AgAC8AACEBIAAgBC8AADsAACAEIAE7AAAgBEECayEEIABBAmohACACQQFrIgINAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC2DgsMBAsgAUEBdCEBQQIhAgNAIAAgACACaiAFQQxqEL8eIAEgAkECaiICRw0ACwwDCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINAiABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBBGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQRqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBBGohAiADKAIAIQgDQCACQQRqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELIAdBAE4NASABQQF2IQIgAUECdCAAakEEayEEA0AgACgAACEBIAAgBCgAADYAACAEIAE2AAAgBEEEayEEIABBBGohACACQQFrIgINAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC5DgsMAwsgAUECdCEBQQQhAgNAIAAgACACaiAFQQxqEL4eIAEgAkEEaiICRw0ACwwCCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINASABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBCGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQhqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBCGohAiADKAIAIQgDQCACQQhqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELQQAhAiAHQQBODQEgAUEBdiEDIAFBA3QgAGpBCGshAQNAQQAhBANAIAAgBGoiBigAACEHIAYgASAEaiIGKAAANgAAIAYgBzYAACAEQQRqIgRBCEcNAAsgAEEIaiEAIAFBCGshASACQQFqIgIgA0cNAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC4DgsMAgsgAUEDdCEBQQghAgNAIAAgACACaiAFQQxqEMEeIAEgAkEIaiICRw0ACwwBCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINACABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBEGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQRBqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBEGohAiADKAIAIQgDQCACQRBqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELQQAhAiAHQQBODQEgAUEBdiEDIAFBBHQgAGpBEGshAQNAQQAhBANAIAAgBGoiBigAACEHIAYgASAEaiIGKAAANgAAIAYgBzYAACAEQQRqIgRBEEcNAAsgAEEQaiEAIAFBEGshASACQQFqIgIgA0cNAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC3DgsMAQsgAUEEdCEBQRAhAgNAIAAgACACaiAFQQxqEIwZIAEgAkEQaiICRw0ACwsgBUEQaiQAC5sFAQN/IwBBMGsiAiQAAkAgACABRwRAA0BBASEEAkACQAJAAkACQCAAKAIAIgMtADBBF2sOCgcEBAcABAECBAMECwJAAkACQAJAIAMoAjQiAy0AMEEXaw4KCgcHCgAHAQIHAwcLIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQYMCQsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNBQwICyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0EDAcLIAIgA0E0ahDDNCACKAIAIgMgAyACKAIEQQJ0ahC6CkUNAwwGCwJAAkACQAJAIAMoAjgiAy0AMEEXaw4KCQYGCQAGAQIGAwYLIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQUMCAsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNBAwHCyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0DDAYLIAJBCGogA0E0ahDDNCACKAIIIgMgAyACKAIMQQJ0ahC6CkUNAgwFCwJAAkACQAJAIAMoAjQiAy0AMEEXaw4KCAUFCAAFAQIFAwULIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQQMBwsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNAwwGCyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0CDAULIAJBEGogA0E0ahDDNCACKAIQIgMgAyACKAIUQQJ0ahC6CkUNAQwECyACQRhqIANBNGoQwzQgAigCGCIDIAMgAigCHEECdGoQugoNAwsgAEEEaiIAIAFHDQALC0EAIQQLIAJBMGokACAEC7YWAQJ/AkAgACkDAEICUgRAIAAoApgFIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZgFahDZIQsgACgCnAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAVqEK4gCyAAQcAEahC8KiAAQcgEahDXKSAAQbABaiEBAkACQAJAAkBBAiAAKAKQAiICQYCAgIB4cyACQQBOGw4CAQIACyAAQZACahDeOyAAQZwCahDeOyAAKAKoAiICEJ0sIAJB4ABBCBD4OiAAKAKsAiICEJ0sIAJB4ABBCBD4OgwCCyAAQZQCahDeOwwBCyAAQZQCahDeOyAAKAKgAiICEJ0sIAJB4ABBCBD4OgsgASgCAEGAgICAeEcEQCAAQcgBakEIEO4oIAEQ3jsgAEG8AWpBBEEIEOAeIABBgAJqEOM8CwJAIAAoAswCRQ0AIAAoAtACIgFFDQAgAEHcAmogACgC1AIgACgC2AIgASgCEBEBAAsCQCAAKALgAkUNACAAKALkAiIBRQ0AIABB8AJqIAAoAugCIAAoAuwCIAEoAhARAQALIAAoAsACQYCAgIB4RwRAIABBwAJqQQRBIBDgHgsgAEHoA2oQhTAgAEH0A2oQhTAgABDSISAAQaAFahDDHCAAQfQEakEEQQgQ4B4gAEGABWoQnTwgAEGMBWoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxyggAEHQBGoQ8SYMAQsCQAJAAkACQAJAAkACQCAAQQhqIgEoAgBBAWsOBwQFAgQFAwABCyABKAKIBSICIAIoAgAiAkEBazYCACACQQFGBEAgAUGIBWoQ2SELIAEoAowFIgIgAigCACICQQFrNgIAIAJBAUYEQCABQYwFahCuIAsgAUGwBGoQvCogAUG4BGoQ1ykgAUHwAGoQvCogASgCYEGAgICAeEcEQCABQRhqEJ4sCyABKAKsASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGsAWoQ2SELAkAgASgCeEUNACABKAJ8IgJFDQAgAUGIAWogASgCgAEgASgChAEgAigCEBEBAAsCQCABKAKMAUUNACABKAKQASICRQ0AIAFBnAFqIAEoApQBIAEoApgBIAIoAhARAQALIAEoAqABQYCAgIB4RwRAIAFBoAFqQQRBIBDgHgsgAUHYA2oQhTAgAUHkA2oQhTACQCABKAKoAkUNACABKAKsAiICRQ0AIAFBuAJqIAEoArACIAEoArQCIAIoAhARAQALAkAgASgCvAJFDQAgASgCwAIiAkUNACABQcwCaiABKALEAiABKALIAiACKAIQEQEACyABQdACahCFMCABQdwCahCFMCABQZAFahDDHCABQeQEakEEQQgQ4B4gAUHwBGoQnTwgAUH8BGoQnTwgAUHwAmoiAhCHGSACQQhBiAEQ4B4gAUGAA2oQ7ScgAUH4A2oQxyggASgCwARFDQUgASgCxAQiAgRAIAFB0ARqIAEoAsgEIAEoAswEIAIoAhARAQALIAEoAtQEIgJFDQUgAUHgBGogASgC2AQgASgC3AQgAigCEBEBAAwFCyABKAKcBCICIAIoAgAiAkEBazYCACACQQFGBEAgAUGcBGoQ2SELIAEoAqAEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQaAEahCuIAsgAUHoA2oQvCogAUHwA2oQ1ykgAUHwAGoQvCogASgCYEGAgICAeEcEQCABQRhqENEsCyABKAKEASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGEAWoQ2SELIAEoAnhBgICAgHhHBEAgAUH4AGpBBEEgEOAeCyABQZADahCFMCABQZwDahCFMCABQYACahCFMCABQYwCahCFMCABQaQEahDDHCABQfgDakEEQQgQ4B4gAUGEBGoQnTwgAUGQBGoQnTwgAUGoAmoiAhCHGSACQQhBiAEQ4B4gAUG4AmoQ7ScgAUGwA2oQxygMBAsgASgC8AQiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB8ARqENkhCyABKAL0BCICIAIoAgAiAkEBazYCACACQQFGBEAgAUH0BGoQriALIAFBoARqELwqIAFBqARqENcpIAFBkAFqELwqIAEoAoABQYCAgIB4RwRAIAFBOGoQgy0LIAEoAqQBIgIgAigCACICQQFrNgIAIAJBAUYEQCABQaQBahDZIQsgASgCmAFBgICAgHhHBEAgAUGYAWpBBEEgEOAeCyABQcgDahCFMCABQdQDahCFMCABQcACahCFMCABQcwCahCFMCABQfgEahDDHCABQcwEakEEQQgQ4B4gAUHYBGoQnTwgAUHkBGoQnTwgAUHgAmoiAhCHGSACQQhBiAEQ4B4gAUHwAmoQ7ScgAUHoA2oQxygMAwsgASgCiAUiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBiAVqENkhCyABKAKMBSICIAIoAgAiAkEBazYCACACQQFGBEAgAUGMBWoQriALIAFBsARqELwqIAFBuARqENcpIAFB8ABqELwqIAEoAmBBgICAgHhHBEAgAUEYahCeLAsgASgCrAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBrAFqENkhCwJAIAEoAnhFDQAgASgCfCICRQ0AIAFBiAFqIAEoAoABIAEoAoQBIAIoAhARAQALAkAgASgCjAFFDQAgASgCkAEiAkUNACABQZwBaiABKAKUASABKAKYASACKAIQEQEACyABKAKgAUGAgICAeEcEQCABQaABakEEQSAQ4B4LIAFB2ANqEIUwIAFB5ANqEIUwIAFBuAFqENIhIAFBkAVqEMMcIAFB5ARqQQRBCBDgHiABQfAEahCdPCABQfwEahCdPCABQfACaiICEIcZIAJBCEGIARDgHiABQYADahDtJyABQfgDahDHKCABQcAEahDxJgwCCyABKALABCICIAIoAgAiAkEBazYCACACQQFGBEAgAUHABGoQ2SELIAEoAsQEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQcQEahCuIAsgAUGABGoQvCogAUGIBGoQ1ykgAUGAAWoQvCogASgCcEGAgICAeEcEQCABQShqENIsCyABKAKUASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGUAWoQ2SELIAEoAogBQYCAgIB4RwRAIAFBiAFqQQRBIBDgHgsgAUGoA2oQhTAgAUG0A2oQhTAgAUGgAmoQhTAgAUGsAmoQhTAgAUHIBGoQwxwgAUGcBGpBBEEIEOAeIAFBqARqEJ08IAFBtARqEJ08IAFBwAJqIgIQhxkgAkEIQYgBEOAeIAFB0AJqEO0nIAFByANqEMcoDAELIAEoAuwEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQewEahDZIQsgASgC8AQiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB8ARqEK4gCyABQbgEahC8KiABQcAEahDXKSABQZABahC8KiABKAKAAUGAgICAeEcEQCABQThqENMsCyABKAKkASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGkAWoQ2SELIAEoApgBQYCAgIB4RwRAIAFBmAFqQQRBIBDgHgsgAUHgA2oQhTAgAUHsA2oQhTAgAUHAAmoQhTAgAUHMAmoQhTAgAUH0BGoQwxwgAUHIBGpBBEEIEOAeIAFB1ARqEJ08IAFB4ARqEJ08IAFB+AJqIgIQhxkgAkEIQYgBEOAeIAFBiANqEO0nIAFBgARqEMcoCwsgACgCsAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBsAVqEIgcCwu2BAIGfwF+IwBBkAJrIgIkACACQZgBaiABKAJQIgZBA3YgBkEHcUEAR2oiBEHAACABKAI4IgVBAWsiA0EAIAMgBU0brXmnayIFQf8BcSIDQQN2IAVBB3FBAEdqQQFqbCIHIANBAWogBGwiBCAEIAdJG0EAQQFBARCgGCACKAKcASEEIAIoApgBQQFHBEAgAkEANgIMIAIgAigCoAEiAzYCCCACIAQ2AgQgBAR/IAMFIAJBBGpBxJDOABCpGSACKAIICyAFOgAAIAJBDGpBATYCACACQSBqQQE2AgAgAiACKQIENwMYIAJBKGoiBEEAQcAA/AsAIAJBADYCeCACQQA6ACQgAkIANwMQIAIgBToAhAEgAkIANwJ8IAJCADcDaCACQn83A3ACQCAGBEAgASgCTCEFIAZBA3QhBgNAIAIoAnwhAwJAAkAgBSkDACIIIAIpA2hSBEAgA0EHSwRAIAJBEGoQvQ0LIAIgCDcDaCACQQE2AnwMAQsgAiADQQFqIgM2AnwgA0EISw0BCyACKAJ4IgNBB0sNAyAEIANBA3RqIAg3AwAgAiACKAJ4QQFqIgM2AnggA0EIRw0AIAJBEGoQyicLIAVBCGohBSAGQQhrIgYNAAsLIAFBADYCUCACQZgBaiIBIAJBEGpB+AD8CgAAIAJBjAFqIgMgARD9ECAAQQRqIAMQ5xUgAEEINgIAIAJBkAJqJAAPCyADQQhB6KLOABDDIQALIAQgAigCoAFBtJDOABD9LwALswQBBX8jAEHgAGsiAiQAIAJBCGogASgCPCABKAJAIgMoAghBAWtBeHFqQQhqIAMoAjgRAAACQAJAAkACQAJAIAIoAggEQCACQTBqIAJBGGopAgA3AwAgAkEoaiACQRBqKQIANwMAIAIgAikCCDcDIEHAACEEIAEoAiAiBUEEdiAFQQ5xQQBHaiIDQcD///8BcUFAayADIANBP3EbIgNBwAAQ0TRFDQQgAwRAIANBwAAQrTYiBEUNBAsgBUEBdiEGIAJCADcCRCACIAQ2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAGEOcQCyAFQQJPBEAgASgCHCEBIAZBAXQhBUEAIQMDQAJAIAEuAQAiBCACKAIwTw0AIAIoAiQgAigCLCAEaiIEQQN2ai0AACAEQQdxdkEBcQ0AIAIgAkE4ahCGPSADQQN2IgQgAigCBCIGSQRAIAIoAgAgBGoiBCAELQAAQX4gA0EHcXdxOgAADAELIAQgBkHU5oQBEMMhAAsgAUECaiEBIANBAWohAyAFQQJrIgUNAAsLIAJBzABqIgEgAkE4aiIDEIcUIAAgARDhJyADEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC7MEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIDKAIIQQFrQXhxakEIaiADKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBCABKAIgIgVBBXYgBUEccUEAR2oiA0HA////AHFBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgRFDQQLIAVBAnYhBiACQgA3AkQgAiAENgJAIAIgAzYCPCACQcAANgI4IAEoAiRFDQEgAkE4aiABQSRqEJUvDAILIAAgAUEkakEAIAEoAiQbEO4lDAQLIAJBOGogBhDnEAsgBUEETwRAIAEoAhwhASAGQQJ0IQVBACEDA0ACQCABKAIAIgQgAigCME8NACACKAIkIAIoAiwgBGoiBEEDdmotAAAgBEEHcXZBAXENACACIAJBOGoQhj0gA0EDdiIEIAIoAgQiBkkEQCACKAIAIARqIgQgBC0AAEF+IANBB3F3cToAAAwBCyAEIAZB1OaEARDDIQALIAFBBGohASADQQFqIQMgBUEEayIFDQALCyACQcwAaiIBIAJBOGoiAxCHFCAAIAEQ4ScgAxDPLyACKAIgIgAgACgCACIAQQFrNgIAIABBAUcNAiACQSBqEPseDAILQcAAIAMQoz0AC0GU54QBQSkgAkHMAGpB8OiEAUHA54QBENUeAAsgAkHgAGokAAuzBAEFfyMAQeAAayICJAAgAkEIaiABKAI8IAEoAkAiAygCCEEBa0F4cWpBCGogAygCOBEAAAJAAkACQAJAAkAgAigCCARAIAJBMGogAkEYaikCADcDACACQShqIAJBEGopAgA3AwAgAiACKQIINwMgQcAAIQQgASgCICIFQQR2IAVBDnFBAEdqIgNBwP///wFxQUBrIAMgA0E/cRsiA0HAABDRNEUNBCADBEAgA0HAABCtNiIERQ0ECyAFQQF2IQYgAkIANwJEIAIgBDYCQCACIAM2AjwgAkHAADYCOCABKAIkRQ0BIAJBOGogAUEkahCVLwwCCyAAIAFBJGpBACABKAIkGxDuJQwECyACQThqIAYQ5xALIAVBAk8EQCABKAIcIQEgBkEBdCEFQQAhAwNAAkAgAS8BACIEIAIoAjBPDQAgAigCJCACKAIsIARqIgRBA3ZqLQAAIARBB3F2QQFxDQAgAiACQThqEIY9IANBA3YiBCACKAIEIgZJBEAgAigCACAEaiIEIAQtAABBfiADQQdxd3E6AAAMAQsgBCAGQdTmhAEQwyEACyABQQJqIQEgA0EBaiEDIAVBAmsiBQ0ACwsgAkHMAGoiASACQThqIgMQhxQgACABEOEnIAMQzy8gAigCICIAIAAoAgAiAEEBazYCACAAQQFHDQIgAkEgahD7HgwCC0HAACADEKM9AAtBlOeEAUEpIAJBzABqQfDohAFBwOeEARDVHgALIAJB4ABqJAALsgQBBX8jAEHgAGsiAiQAIAJBCGogASgCPCABKAJAIgMoAghBAWtBeHFqQQhqIAMoAjgRAAACQAJAAkACQAJAIAIoAggEQCACQTBqIAJBGGopAgA3AwAgAkEoaiACQRBqKQIANwMAIAIgAikCCDcDIEHAACEEIAEoAiAiBUEGdiAFQThxQQBHaiIDQcD//z9xQUBrIAMgA0E/cRsiA0HAABDRNEUNBCADBEAgA0HAABCtNiIERQ0ECyAFQQN2IQYgAkIANwJEIAIgBDYCQCACIAM2AjwgAkHAADYCOCABKAIkRQ0BIAJBOGogAUEkahCVLwwCCyAAIAFBJGpBACABKAIkGxDuJQwECyACQThqIAYQ5xALIAVBCE8EQCABKAIcIQEgBkEDdCEFQQAhAwNAAkAgASgCACIEIAIoAjBPDQAgAigCJCACKAIsIARqIgRBA3ZqLQAAIARBB3F2QQFxDQAgAiACQThqEIY9IANBA3YiBCACKAIEIgZJBEAgAigCACAEaiIEIAQtAABBfiADQQdxd3E6AAAMAQsgBCAGQdTmhAEQwyEACyABQQhqIQEgA0EBaiEDIAVBCGsiBQ0ACwsgAkHMAGoiASACQThqIgMQhxQgACABEOEnIAMQzy8gAigCICIAIAAoAgAiAEEBazYCACAAQQFHDQIgAkEgahD7HgwCC0HAACADEKM9AAtBlOeEAUEpIAJBzABqQfDohAFBwOeEARDVHgALIAJB4ABqJAALhhEBCH8jAEEQayIIJAAgCEEEaiEFIwBBEGsiAyQAAkAgACgCCCIGIAAoAgRJBEAgBUEAOgAAIAAgBkEBajYCCCAFIAAoAgAgBmotAAA6AAEMAQsgA0EENgIEIAUgACADQQRqEJ0pCyADQRBqJAACfyAILQAEQQFGBEAgCCgCCAwBCwJAAkACQAJAAkACQAJAAkACQAJAIAgtAAUiBUHtAE0EQCAFQeEATQRAIAVBIkYNAiAFQS9GDQQgBUHcAEYNAwwLCyAFQeIAaw4FBAoKCgUKCyAFQe4Aaw4IBQkJCQYJBwgJCyACKAIIIgAgAigCAEYEQCACQejGiAEQqRkLIAIoAgQgAGpBIjoAACACIABBAWo2AghBAAwJCyACKAIIIgAgAigCAEYEQCACQfjGiAEQqRkLIAIoAgQgAGpB3AA6AAAgAiAAQQFqNgIIQQAMCAsgAigCCCIAIAIoAgBGBEAgAkGIx4gBEKkZCyACKAIEIABqQS86AAAgAiAAQQFqNgIIQQAMBwsgAigCCCIAIAIoAgBGBEAgAkGYx4gBEKkZCyACKAIEIABqQQg6AAAgAiAAQQFqNgIIQQAMBgsgAigCCCIAIAIoAgBGBEAgAkGox4gBEKkZCyACKAIEIABqQQw6AAAgAiAAQQFqNgIIQQAMBQsgAigCCCIAIAIoAgBGBEAgAkG4x4gBEKkZCyACKAIEIABqQQo6AAAgAiAAQQFqNgIIQQAMBAsgAigCCCIAIAIoAgBGBEAgAkHIx4gBEKkZCyACKAIEIABqQQ06AAAgAiAAQQFqNgIIQQAMAwsgAigCCCIAIAIoAgBGBEAgAkHYx4gBEKkZCyACKAIEIABqQQk6AAAgAiAAQQFqNgIIQQAMAgsgASEJIAIhAyMAQSBrIgQkAAJ/AkACQAJAIAAiBigCBCICIAAoAggiAE8EQAJAIAIgAGtBA00EQCAGIAI2AgggBEEENgIUIARBDGogBiAEQRRqEJwpIAIhBQwBCyAGIABBBGoiBTYCCCAGKAIAIABqIgAtAAFBAXRB+MeIAWovAQAgAC0AAEEBdEH4y4gBai8BAHLBQQh0IAAtAAJBAXRB+MuIAWouAQByIAAtAANBAXRB+MeIAWouAQByIgBBAE4EQCAEQQA7AQwgBCAAOwEODAELIARBDDYCFCAEQQxqIAYgBEEUahCcKQsgBC8BDEEBRg0DAn8CQAJAAkACQAJAAkACQAJAIAlBACAELwEOIgBBgPgDcUGAuANGG0UEQCAAQYDIAGpB//8DcUGA+ANPDQEgACEBDAILIARBFDYCFCAGIARBFGoQrCsMDQsgBigCACEKA0AgBEEUaiIHIAYQviYgBC0AFEEBRg0LIAQtABVB3ABHDQUgBiAFQQFqNgIIIAcgBhC+JiAELQAUDQsgBC0AFUH1AEcNBCACIAVBAmoiAUkNCgJAIAIgAWtBA00EQCAGIAI2AgggBEEENgIUIARBDGogBiAHEJwpIAIhBQwBCyAGIAVBBmoiBTYCCCABIApqIgEtAAFBAXRB+MeIAWovAQAgAS0AAEEBdEH4y4gBai8BAHLBQQh0IAEtAAJBAXRB+MuIAWouAQByIAEtAANBAXRB+MeIAWouAQByIgFBAE4EQCAEQQA7AQwgBCABOwEODAELIARBDDYCFCAEQQxqIAYgBEEUahCcKQsgBC8BDA0MIAQvAQ4iAUGAQGtB//8DcUH/9wNLDQIgCQ0DIAMoAgAgAygCCCIHa0EDTQR/IAMgB0EEEOAoIAMoAggFIAcLIAMoAgRqIgdB7QE6AAAgB0ECaiAAQT9xQYABcjoAACAHIABBBnZBL3FBgAFyOgABIAMgAygCCEEDajYCCCABIgBBgMgAakH//wNxQYD4A08NAAsLIAFB//8DcUGAAUkNBCADKAIAIAMoAggiAGtBA00EfyADIABBBBDgKCADKAIIBSAACyADKAIEaiECIAFB//8DcUGAEE8NBSABQQZ2QUByIQBBAgwGCyABQYDIAGpB//8DcSAAQYDQAGpB//8DcUEKdHIiBUGAgARqIQIgAygCACADKAIIIgBrQQNNBH8gAyAAQQQQ4CggAygCCAUgAAsgAygCBGoiACACQRJ2QfABcjoAACAAQQNqIAFBP3FBgAFyOgAAIAAgBUEGdkE/cUGAAXI6AAIgACACQQx2QT9xQYABcjoAASADIAMoAghBBGo2AghBAAwKCyAEQRQ2AhQgBiAEQRRqEKwrDAkLIAlFBEAgAygCACADKAIIIgFrQQNNBH8gAyABQQQQ4CggAygCCAUgAQsgAygCBGoiAUHtAToAACABQQJqIABBP3FBgAFyOgAAIAEgAEEGdkEvcUGAAXI6AAEgAyADKAIIQQNqNgIIIAZBACADEMEKDAkLIAYgBUECajYCCCAEQRc2AhQgBiAEQRRqEKwrDAgLIAlFBEAgAygCACADKAIIIgFrQQNNBH8gAyABQQQQ4CggAygCCAUgAQsgAygCBGoiAUHtAToAACABQQJqIABBP3FBgAFyOgAAIAEgAEEGdkEvcUGAAXI6AAEgAyADKAIIQQNqNgIIQQAMCAsgBiAFQQFqNgIIIARBFzYCFCAGIARBFGoQrCsMBwsgAygCCCIAIAMoAgBGBEAgA0Hox4gBEKkZCyADKAIEIABqIAE6AAAgAyAAQQFqNgIIQQAMBgsgAiABQQZ2QT9xQYABcjoAASABQYDgA3FBDHZBYHIhAEEDCyEFIAIgADoAACACIAVqQQFrIAFBP3FBgAFyOgAAIAMgAygCCCAFajYCCEEADAQLIAAgAkHYxogBEK87AAsgASACQdjGiAEQrzsACyAEKAIYDAELIAQoAhALIARBIGokAAwBCyAIQQw2AgQgACAIQQRqEKwrCyAIQRBqJAAL3gQBBH8jAEEQayIEJAAgACgCmAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAFqEJcVCyAAKAKcASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGcAWoQ+CMLIAQgAEHQAGoiASAAKAJcEPgYIAEQ6TsgACgCgAFBgICAgHhHBEAgAEGAAWoQ3jsLIAAoAowBQYCAgIB4RwRAIABBjAFqEOo7CwJAIAApAwBCAlENACAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEJcVCwJAIAAoAkAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEFAaxDbHgsCQCAAKAIARQRAIAAoAhAiAUGEAUkNASABEPIfDAELIABBCGoQvSoLIAAoAjBBgICAgHhHBEAgAEEwaiIBEIEjIAFBBEEIEOAeCyAAKAJEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBxABqEIEsCwJAAkACQEEBIAAoAmAiAUH/////B2ogAUGAgICAeE0bQQFrDgIAAQILIAAoAnQhASAAKAJ4IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAnwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB/ABqEPgjCyAAQeAAaiIBKAIAQYCAgIB4Rg0BIAEQ0C4gARDqOwwBCyAAKAJkIQEgACgCaCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAkUNACABIAIgAygCCBD4OgsgAEGoAWoiABDeIyAAEOA7IARBEGokAAu8BAEOfyMAQRBrIgokAAJAAkAgBCADIARqIgdNBEAgByAAKAIEIgtLDQEgACgCACEMIAEoAgwiBSAEaiIGIAEoAgQiCEsEQCABIAhBAXQiCCAGEN8qIgYgBiAISRsQ6BkgASgCDCEFCyAEBEAgASgCCCAFaiADIAxqIAT8CgAACyABIAEoAgwgBGo2AgwgAyAHSQRAIAFBEGohDyAAKAIMIRAgACgCCCERIAAoAhAiDSADIAMgDUkbIQ4DQAJAIAMgC0cEQCADIAxqLQAAIQYgCkEIaiARELAuIAooAggiBCAKKAIMIglHBEAgA0EBaiEIQQAhAEEAIQUDQCAELQAAIAZGDQMgAEHMAWohACAFQQFqIQUgBEEIaiIEIAlHDQALC0HYqIcBQRVB8KiHARDLJAALIAsgC0HIqIcBEMMhAAsCQCADIA5HBEAgBSABKAIoIgRPDQYgECADQQJ0aigCACEDIAEoAiQgAGpB2ABqKAIAIQYgASgCHCIEQQRqIgkgASgCFCISSwR/IA8gEkEBdCIEIAkQ3yoiCSAEIAlLGxDoGSABKAIcBSAECyABKAIYaiAGNgAAIAEgASgCHEEEajYCHCAFIAEoAigiBEkNASAFIARBoKmHARDDIQALIA4gDUGAqYcBEMMhAAsgASgCJCAAaiACIAMgA0EBahDYGyAIIgMgB0cNAAsLIApBEGokAA8LIAMgB0G4qIcBELE7AAsgByALQbiohwEQsDsACyAFIARBkKmHARDDIQALiQUCBn8EfiMAQbABayIDJAAgASgCDCgCECACQQR0aiIEKQMAIQkgBCkDCCEKIAEoAggiBCgCACgCACIFKQMAIQsgAyAFKQMIIgw3AzggAyALNwMwIAMgCjcDKCADIAk3AyAgA0EANgIcIAMgCSAKIAsgDCADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AnwgA0GskP8ANgJ4IANCAjcChAEgA0GEDDYCbCADQYQMNgJkIAMgA0HgAGoiBjYCgAEgAyADQTBqNgJoIAMgA0EgajYCYCADQdAAaiICIANB+ABqIgcQmQ4gA0GkAWogA0HcAGooAgA2AgAgA0GIgICAeDYCTCADIANB1ABqIgUpAgA3ApwBIAMgAykCTDcClAEgA0EBNgKQASADQZABaiIIQQRyEIgRIAQoAgQhASADIAo3A2ggAyAJNwNgIANBBDYCfCADQcyR/wA2AnggA0IENwKEASADQYQMNgKsASADQfQLNgKkASADIAFBAWo2AqABIANBuwc2ApwBIAMgATYCmAEgA0HMATYClAEgA0Ggkf8ANgKQASADIAg2AoABIAMgBjYCqAEgAiAHEJkOIANBOGogBSgCADYCACADQYKAgIB4NgJMIAMgAykCTDcDMCADKQJYDAELIANBkAFqIAMpAwAiCSADKQMIIgogBCgCCC0AABCtDiADKAKQAUGTgICAeEYNASADQThqIANBmAFqKAIANgIAIAMgAykCkAE3AzAgAykCnAELIQkgACADKQMwNwIAIAAgCTcCDCAAQQhqIANBOGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCjcDCCAAIAk3AwALIANBsAFqJAAL5gQCBX8BfiMAQdAAayICJAAgAkEQaiABKAIEIgNBCGoiBRDDNAJAAkACQCACKAIQIgQgBCACKAIUQQJ0ahC6CkUEQCABKAIAIgUgBSgCACIEQQFqNgIAIARBAEgNAiADIAMoAgAiBEEBajYCACAEQQBIDQIgASgCCCIBBEAgASABKAIAIgRBAWo2AgAgBEEASA0DCyAAIAE2AgwgACADNgIIIAAgBTYCBCAAQQY2AgAMAQsgAkEIaiAFEMM0IAJBIGoiBCACKAIIIgUgBSACKAIMQQJ0ahClGyACQTBqIgUgA0EQahCxLiACIAQQthkgAigCBCEEIAIoAgAhBkEwQQgQrTYiA0UNAiADIAY2AgggA0KBgICAEDcDACADIAIpAzA3AxAgAyAENgIMIANBGGogAkE4aikDADcDACADQSBqIAJBQGspAwA3AwAgA0EoaiACQcgAaikDADcDACACQQA2AjAgAkEAOwE0IAJBGGoiBCADNgIAIARBAToABSAEIAUtAAQ6AAQCQCAFKAIAIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAUQ+CMLIAEoAgAiASABKAIAIgNBAWo2AgAgA0EASA0BIAUgASAEEO0BIAJBKGoiASACQTxqIgMoAgA2AgAgAiACKQI0NwMgIAIoAjAiBEEIRwRAIAIpA0AhByADIAEoAgA2AgAgAiACKQMgNwI0IAIgBzcDQCACIAQ2AjAgACAFEMgmDAELIAAgAikDIDcCBCAAQQY2AgAgAEEMaiACQShqKAIANgIACyACQdAAaiQADwsAC0EIQTAQoz0AC54IAQd/IwBBIGsiCCQAQf3/AyELAn8CQCADRQ0AIAIgA2oiCSADSQ0AQQEgBiAJSQ0BGkH9/wMgBSACQQF0aiICLwAAIgUgBUGAsL9/c0GAkLx/SRshCyADQQFrIQcgAkECagwBC0EBCyECIAIgB0EBdGohAwJAIARFBEAgCCADNgIcIAggAjYCGCAIQRBqIAhBGGoQpSlBACEGIAgvARBBAXFFDQEgAUEEaiEJIAFByABqIQogCC8BEiEDQQEhAgNAQf3/AyADQf//A3EiAyADQYCwv39zQYCQvH9JGyIFAn8gASgCXCIDLQAsQQFGIAVB/x9LcUUEQCAFQQZ2IgcgAygCCEkEQCADKAIEIAdBAXRqLwAAIAVBP3FqDAILIAMoAhRBAWsMAQsgAyAFEMAuCyIFIAMoAhQiB0kEfyADKAIQIAVBAnRqKAAABSAECyADKAIAIAUgB0kbIgwQoy8hDQJ/IAooAgAiB0ESSQRAIAchAyAKIQVBESEHIAkMAQsgASgCBCEDIAkhBSABKAIICyEEIAMgB0YEfyABEPwfIAEoAgghBCAJIQUgASgCBAUgAwtBAnQgBGogDTYCACAFIAUoAgBBAWo2AgAgBiACIAwQ+zobIQYgAkEBaiECIAhBCGogCEEYahClKSAILwEKIQMgCC8BCEEBcQ0ACwwBCyMAQUBqIgckACAHIAM2AjAgByACNgIsIAdBNGoiAkEBNgIEIAIgB0EsaiIDKAIEIAMoAgBrQQF2IgM2AgggAiADNgIAIAdBIGogASIEIAcoAjQQnxggBygCICAHKAIkEIAtIAFByABqIQlBESEBAkACQAJ/IAQoAkgiAkERTQRAIARBBGohBiAJIQMgAgwBCyAEQQRqIQMgBCgCCCEGIAIhASAEKAIECyICIAFJBEAgBiACQQJ0aiEFA0AgB0EYaiAHQSxqEKUpIAcvARhBAXFFDQIgBUH9/wMgBy8BGiIGIAZBgLC/f3NBgJC8f0kbELI9NgIAIAVBBGohBSABIAJBAWoiAkcNAAsgASECCyADIAI2AgAgByAHKQIsNwI0IAdBEGogB0E0ahClKSAHLwEQQQFxRQ0BIARBBGohAyAHLwESIQUDQEH9/wMgBUH//wNxIgEgAUGAsL9/c0GAkLx/SRsQsj0hCgJ/IAkoAgAiBkESSQRAIAYhBSADIQFBESEGIAkMAQsgBCgCBCEFIAQoAgghASADCyECIAUgBkYEQCAEEPwfIAQoAgQhBSADIQIgBCgCCCEBCyABIAVBAnRqIAo2AgAgAiACKAIAQQFqNgIAIAdBCGogB0E0ahClKSAHLwEKIQUgBy8BCEEBcQ0ACwwBCyADIAI2AgALIAdBQGskAEEAIQYLIAAgBjYCBCAAIAs2AgAgCEEgaiQAC/8EAgd/BH4jAEGgAWsiAyQAIAEoAgwoAhAgAkECdGooAgAhBSABKAIIIgYoAgAoAgAiBCkDACEKIAMgBCkDCCIMNwM4IAMgCjcDMCADIAWsIgtCP4ciDTcDKCADIAs3AyAgA0EANgIcIAMgCyANIAogDCADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYQMNgJMIANBhAw2AkQgAyADQUBrNgJwIAMgA0EwaiIHNgJIIAMgA0EgajYCQCADQdgAaiICIANB6ABqIggQmQ4gA0GUAWogA0HkAGooAgA2AgAgA0GIgICAeDYCVCADIANB3ABqIgQpAgA3AowBIAMgAykCVDcChAEgA0EBNgKAASADQYABaiIJQQRyEIgRIAYoAgQhASADIAU2AjAgA0EENgJsIANBzJH/ADYCaCADQgQ3AnQgA0GCDDYCnAEgA0H0CzYClAEgAyABQQFqNgKQASADQbsHNgKMASADIAE2AogBIANBzAE2AoQBIANBoJH/ADYCgAEgAyAJNgJwIAMgBzYCmAEgAiAIEJkOIANByABqIAQoAgA2AgAgA0GCgICAeDYCVCADIAMpAlQ3A0AgAykCYAwBCyADQYABaiADKQMAIgogAykDCCILIAYoAggtAAAQrQ4gAygCgAFBk4CAgHhGDQEgA0HIAGogA0GIAWooAgA2AgAgAyADKQKAATcDQCADKQKMAQshCiAAIAMpA0A3AgAgACAKNwIMIABBCGogA0HIAGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCzcDCCAAIAo3AwALIANBoAFqJAALqGsBDH8jAEGgAWsiBCQAIARB9ABqIQcgBEEEaiEDIwBBEGsiCiQAQQMhBgJAIAJFDQACQCACQcAATQRAA0AgAyAFaiABIAVqLQAAQbzvwwBqLQAAOgAAIAIgBUEBaiIFRw0ACwJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkECaw4iHQoUCwAMFhUPGA0DAQIRDhcQGRsIEhocHgYFBwkeBB4eEx4LAkACQAJAAkACQAJAAkAgAy0AACIBQeEAaw4FASQCJAMACyABQe8Aaw4FAwQjIwUjCyADLQABQeMARw0iIAMtAAJB4wBHDSIgAy0AA0HlAEcNIiADLQAEQfAARw0iIAMtAAVB9ABHDSJBAAwjCyADLQABQe8ARw0hIAMtAAJB7wBHDSEgAy0AA0HrAEcNISADLQAEQekARw0hIAMtAAVB5QBHDSFBHgwiCyADLQABQfgARw0gIAMtAAJB8ABHDSAgAy0AA0HlAEcNICADLQAEQeMARw0gIAMtAAVB9ABHDSBBIgwhCyADLQABQfIARw0fIAMtAAJB6QBHDR8gAy0AA0HnAEcNHyADLQAEQekARw0fIAMtAAVB7gBHDR9BMAwgCyADLQABQfIARw0eIAMtAAJB4QBHDR4gAy0AA0HnAEcNHiADLQAEQe0ARw0eIAMtAAVB4QBHDR5BMQwfCyADLQABQeUARw0dIAMtAAJB8gBHDR0gAy0AA0H2AEcNHSADLQAEQeUARw0dIAMtAAVB8gBHDR1BwAAMHgsCQAJAIAMtAABB4QBrDgMAHgEeCyADLQABQeMARw0dIAMtAAJB4wBHDR0gAy0AA0HlAEcNHSADLQAEQfAARw0dIAMtAAVB9ABHDR0gAy0ABkEtRw0dIAMtAAdB4wBHDR0gAy0ACEHoAEcNHSADLQAJQeEARw0dIAMtAApB8gBHDR0gAy0AC0HzAEcNHSADLQAMQeUARw0dIAMtAA1B9ABHDR1BAQweCyADLQABQe8ARw0cIAMtAAJB7gBHDRwgAy0AA0H0AEcNHCADLQAEQeUARw0cIAMtAAVB7gBHDRwgAy0ABkH0AEcNHCADLQAHQS1HDRwgAy0ACEHsAEcNHCADLQAJQeUARw0cIAMtAApB7gBHDRwgAy0AC0HnAEcNHCADLQAMQfQARw0cIAMtAA1B6ABHDRxBGAwdCwJAAkACQAJAIAMtAAAiAUHwAGsOAwEfAgALIAFB+ABGDQIgAUHhAEcNHiADLQABQeMARw0eIAMtAAJB4wBHDR4gAy0AA0HlAEcNHiADLQAEQfAARw0eIAMtAAVB9ABHDR4gAy0ABkEtRw0eIAMtAAciAUHsAEcEQCABQeUARw0fIAMtAAhB7gBHDR8gAy0ACUHjAEcNHyADLQAKQe8ARw0fIAMtAAtB5ABHDR8gAy0ADEHpAEcNHyADLQANQe4ARw0fIAMtAA5B5wBHDR9BAgwgCyADLQAIQeEARw0eIAMtAAlB7gBHDR4gAy0ACkHnAEcNHiADLQALQfUARw0eIAMtAAxB4QBHDR4gAy0ADUHnAEcNHiADLQAOQeUARw0eQQMMHwsgAy0AAUH1AEcNHSADLQACQeIARw0dIAMtAANB7ABHDR0gAy0ABEHpAEcNHSADLQAFQeMARw0dIAMtAAZBLUcNHSADLQAHQesARw0dIAMtAAhB5QBHDR0gAy0ACUH5AEcNHSADLQAKQS1HDR0gAy0AC0HwAEcNHSADLQAMQekARw0dIAMtAA1B7gBHDR0gAy0ADkHzAEcNHUE0DB4LIAMtAAFB5QBHDRwgAy0AAkHmAEcNHCADLQADQeUARw0cIAMtAARB8gBHDRwgAy0ABUHyAEcNHCADLQAGQeUARw0cIAMtAAdB8gBHDRwgAy0ACEEtRw0cIAMtAAlB8ABHDRwgAy0ACkHvAEcNHCADLQALQewARw0cIAMtAAxB6QBHDRwgAy0ADUHjAEcNHCADLQAOQfkARw0cQTgMHQsgAy0AAUEtRw0bIAMtAAJB5gBHDRsgAy0AA0HyAEcNGyADLQAEQeEARw0bIAMtAAVB7QBHDRsgAy0ABkHlAEcNGyADLQAHQS1HDRsgAy0ACEHvAEcNGyADLQAJQfAARw0bIAMtAApB9ABHDRsgAy0AC0HpAEcNGyADLQAMQe8ARw0bIAMtAA1B7gBHDRsgAy0ADkHzAEcNG0HPAAwcCwJAAkACQAJAAkACQAJAIAMtAAAiAUHhAGsOAwEhAgALIAFB6QBrDgQEICAFIAsgAy0AASIBQeMARg0BIAFB9QBHDR8gAy0AAkH0AEcNHyADLQADQegARw0fIAMtAARB7wBHDR8gAy0ABUHyAEcNHyADLQAGQekARw0fIAMtAAdB+gBHDR8gAy0ACEHhAEcNHyADLQAJQfQARw0fIAMtAApB6QBHDR8gAy0AC0HvAEcNHyADLQAMQe4ARw0fQRAMIAsgAy0AASIBQeEARg0BIAFB7wBHDR4gAy0AAkHuAEcNHiADLQADQfQARw0eIAMtAARB5QBHDR4gAy0ABUHuAEcNHiADLQAGQfQARw0eIAMtAAdBLUcNHiADLQAIQfIARw0eIAMtAAlB4QBHDR4gAy0ACkHuAEcNHiADLQALQecARw0eIAMtAAxB5QBHDR5BGgwfCyADLQACQeMARw0dIAMtAANB5QBHDR0gAy0ABEHwAEcNHSADLQAFQfQARw0dIAMtAAZBLUcNHSADLQAHQfIARw0dIAMtAAhB4QBHDR0gAy0ACUHuAEcNHSADLQAKQecARw0dIAMtAAtB5QBHDR0gAy0ADEHzAEcNHUEEDB4LIAMtAAJB4wBHDRwgAy0AA0HoAEcNHCADLQAEQeUARw0cIAMtAAVBLUcNHCADLQAGQeMARw0cIAMtAAdB7wBHDRwgAy0ACEHuAEcNHCADLQAJQfQARw0cIAMtAApB8gBHDRwgAy0AC0HvAEcNHCADLQAMQewARw0cQREMHQsgAy0AAUHmAEcNGyADLQACQS1HDRsgAy0AA0HuAEcNGyADLQAEQe8ARw0bIAMtAAVB7gBHDRsgAy0ABkHlAEcNGyADLQAHQS1HDRsgAy0ACEHtAEcNGyADLQAJQeEARw0bIAMtAApB9ABHDRsgAy0AC0HjAEcNGyADLQAMQegARw0bQSkMHAsgAy0AAUHhAEcNGiADLQACQfMARw0aIAMtAANB9ABHDRogAy0ABEEtRw0aIAMtAAVB7QBHDRogAy0ABkHvAEcNGiADLQAHQeQARw0aIAMtAAhB6QBHDRogAy0ACUHmAEcNGiADLQAKQekARw0aIAMtAAtB5QBHDRogAy0ADEHkAEcNGkEsDBsLIAMtAABB4QBHDRkgAy0AAUHjAEcNGSADLQACQeMARw0ZIAMtAANB5QBHDRkgAy0ABEHzAEcNGSADLQAFQfMARw0ZIAMtAAZBLUcNGSADLQAHQeMARw0ZIAMtAAhB7wBHDRkgAy0ACUHuAEcNGSADLQAKQfQARw0ZIAMtAAtB8gBHDRkgAy0ADEHvAEcNGSADLQANQewARw0ZIAMtAA5BLUcNGSADLQAPQeEARw0ZIAMtABBB7ABHDRkgAy0AEUHsAEcNGSADLQASQe8ARw0ZIAMtABNB9wBHDRkgAy0AFEEtRw0ZIAMtABVB4wBHDRkgAy0AFkHyAEcNGSADLQAXQeUARw0ZIAMtABhB5ABHDRkgAy0AGUHlAEcNGSADLQAaQe4ARw0ZIAMtABtB9ABHDRkgAy0AHEHpAEcNGSADLQAdQeEARw0ZIAMtAB5B7ABHDRkgAy0AH0HzAEcNGUEFDBoLIAMtAABB4QBHDRggAy0AAUHjAEcNGCADLQACQeMARw0YIAMtAANB5QBHDRggAy0ABEHzAEcNGCADLQAFQfMARw0YIAMtAAZBLUcNGCADLQAHQeMARw0YIAMtAAhB7wBHDRggAy0ACUHuAEcNGCADLQAKQfQARw0YIAMtAAtB8gBHDRggAy0ADEHvAEcNGCADLQANQewARw0YIAMtAA5BLUcNGCADLQAPQeEARw0YIAMtABBB7ABHDRggAy0AEUHsAEcNGCADLQASQe8ARw0YIAMtABNB9wBHDRggAy0AFEEtRw0YIAMtABUiAUHtAEcEQCABQegARw0ZIAMtABZB5QBHDRkgAy0AF0HhAEcNGSADLQAYQeQARw0ZIAMtABlB5QBHDRkgAy0AGkHyAEcNGSADLQAbQfMARw0ZQQYMGgsgAy0AFkHlAEcNGCADLQAXQfQARw0YIAMtABhB6ABHDRggAy0AGUHvAEcNGCADLQAaQeQARw0YIAMtABtB8wBHDRhBBwwZCyADLQAAIgFB8ABHBEAgAUHhAEcNGCADLQABQeMARw0YIAMtAAJB4wBHDRggAy0AA0HlAEcNGCADLQAEQfMARw0YIAMtAAVB8wBHDRggAy0ABkEtRw0YIAMtAAdB4wBHDRggAy0ACEHvAEcNGCADLQAJQe4ARw0YIAMtAApB9ABHDRggAy0AC0HyAEcNGCADLQAMQe8ARw0YIAMtAA1B7ABHDRggAy0ADkEtRw0YIAMtAA9B4QBHDRggAy0AEEHsAEcNGCADLQARQewARw0YIAMtABJB7wBHDRggAy0AE0H3AEcNGCADLQAUQS1HDRggAy0AFUHvAEcNGCADLQAWQfIARw0YIAMtABdB6QBHDRggAy0AGEHnAEcNGCADLQAZQekARw0YIAMtABpB7gBHDRhBCAwZCyADLQABQfUARw0XIAMtAAJB4gBHDRcgAy0AA0HsAEcNFyADLQAEQekARw0XIAMtAAVB4wBHDRcgAy0ABkEtRw0XIAMtAAdB6wBHDRcgAy0ACEHlAEcNFyADLQAJQfkARw0XIAMtAApBLUcNFyADLQALQfAARw0XIAMtAAxB6QBHDRcgAy0ADUHuAEcNFyADLQAOQfMARw0XIAMtAA9BLUcNFyADLQAQQfIARw0XIAMtABFB5QBHDRcgAy0AEkHwAEcNFyADLQATQe8ARw0XIAMtABRB8gBHDRcgAy0AFUH0AEcNFyADLQAWQS1HDRcgAy0AF0HvAEcNFyADLQAYQe4ARw0XIAMtABlB7ABHDRcgAy0AGkH5AEcNF0E1DBgLIAMtAABB4QBHDRYgAy0AAUHjAEcNFiADLQACQeMARw0WIAMtAANB5QBHDRYgAy0ABEHzAEcNFiADLQAFQfMARw0WIAMtAAZBLUcNFiADLQAHQeMARw0WIAMtAAhB7wBHDRYgAy0ACUHuAEcNFiADLQAKQfQARw0WIAMtAAtB8gBHDRYgAy0ADEHvAEcNFiADLQANQewARw0WIAMtAA5BLUcNFiADLQAPIgFB8gBHBEAgAUHlAEcNFyADLQAQQfgARw0XIAMtABFB8ABHDRcgAy0AEkHvAEcNFyADLQATQfMARw0XIAMtABRB5QBHDRcgAy0AFUEtRw0XIAMtABZB6ABHDRcgAy0AF0HlAEcNFyADLQAYQeEARw0XIAMtABlB5ABHDRcgAy0AGkHlAEcNFyADLQAbQfIARw0XIAMtABxB8wBHDRdBCQwYCyADLQAQQeUARw0WIAMtABFB8QBHDRYgAy0AEkH1AEcNFiADLQATQeUARw0WIAMtABRB8wBHDRYgAy0AFUH0AEcNFiADLQAWQS1HDRYgAy0AF0HtAEcNFiADLQAYQeUARw0WIAMtABlB9ABHDRYgAy0AGkHoAEcNFiADLQAbQe8ARw0WIAMtABxB5ABHDRZBDAwXCyADLQAAIgFB+ABHBEAgAUHzAEcEQCABQeEARw0XIAMtAAFB4wBHDRcgAy0AAkHjAEcNFyADLQADQeUARw0XIAMtAARB8wBHDRcgAy0ABUHzAEcNFyADLQAGQS1HDRcgAy0AB0HjAEcNFyADLQAIQe8ARw0XIAMtAAlB7gBHDRcgAy0ACkH0AEcNFyADLQALQfIARw0XIAMtAAxB7wBHDRcgAy0ADUHsAEcNFyADLQAOQS1HDRcgAy0AD0HtAEcNFyADLQAQQeEARw0XIAMtABFB+ABHDRcgAy0AEkEtRw0XIAMtABNB4QBHDRcgAy0AFEHnAEcNFyADLQAVQeUARw0XQQoMGAsgAy0AAUHlAEcNFiADLQACQeMARw0WIAMtAANBLUcNFiADLQAEQfcARw0WIAMtAAVB5QBHDRYgAy0ABkHiAEcNFiADLQAHQfMARw0WIAMtAAhB7wBHDRYgAy0ACUHjAEcNFiADLQAKQesARw0WIAMtAAtB5QBHDRYgAy0ADEH0AEcNFiADLQANQS1HDRYgAy0ADkHwAEcNFiADLQAPQfIARw0WIAMtABBB7wBHDRYgAy0AEUH0AEcNFiADLQASQe8ARw0WIAMtABNB4wBHDRYgAy0AFEHvAEcNFiADLQAVQewARw0WQT4MFwsgAy0AAUEtRw0VAkACQCADLQACQeMAaw4CAAEXCyADLQADQe8ARw0WIAMtAARB7gBHDRYgAy0ABUH0AEcNFiADLQAGQeUARw0WIAMtAAdB7gBHDRYgAy0ACEH0AEcNFiADLQAJQS1HDRYgAy0ACkH0AEcNFiADLQALQfkARw0WIAMtAAxB8ABHDRYgAy0ADUHlAEcNFiADLQAOQS1HDRYgAy0AD0HvAEcNFiADLQAQQfAARw0WIAMtABFB9ABHDRYgAy0AEkHpAEcNFiADLQATQe8ARw0WIAMtABRB7gBHDRYgAy0AFUHzAEcNFkHNAAwXCyADLQADQe4ARw0VIAMtAARB8wBHDRUgAy0ABUEtRw0VIAMtAAZB8ABHDRUgAy0AB0HyAEcNFSADLQAIQeUARw0VIAMtAAlB5gBHDRUgAy0ACkHlAEcNFSADLQALQfQARw0VIAMtAAxB4wBHDRUgAy0ADUHoAEcNFSADLQAOQS1HDRUgAy0AD0HjAEcNFSADLQAQQe8ARw0VIAMtABFB7gBHDRUgAy0AEkH0AEcNFSADLQATQfIARw0VIAMtABRB7wBHDRUgAy0AFUHsAEcNFUHOAAwWCyADLQAAQeEARw0UIAMtAAFB4wBHDRQgAy0AAkHjAEcNFCADLQADQeUARw0UIAMtAARB8wBHDRQgAy0ABUHzAEcNFCADLQAGQS1HDRQgAy0AB0HjAEcNFCADLQAIQe8ARw0UIAMtAAlB7gBHDRQgAy0ACkH0AEcNFCADLQALQfIARw0UIAMtAAxB7wBHDRQgAy0ADUHsAEcNFCADLQAOQS1HDRQgAy0AD0HyAEcNFCADLQAQQeUARw0UIAMtABFB8QBHDRQgAy0AEkH1AEcNFCADLQATQeUARw0UIAMtABRB8wBHDRQgAy0AFUH0AEcNFCADLQAWQS1HDRQgAy0AF0HoAEcNFCADLQAYQeUARw0UIAMtABlB4QBHDRQgAy0AGkHkAEcNFCADLQAbQeUARw0UIAMtABxB8gBHDRQgAy0AHUHzAEcNFEELDBULAkACQAJAIAMtAAAiAUHhAGsOBAEWFgIACyABQfYARw0VIAMtAAFB6QBHDRUgAy0AAkHhAEcNFUHKAAwWCyADLQABQecARw0UIAMtAAJB5QBHDRRBDQwVCyADLQABQe4ARw0TIAMtAAJB9ABHDRNBHwwUCyADLQAAIgFB8gBHBEAgAUHhAEcNEyADLQABQewARw0TIAMtAAJB7ABHDRMgAy0AA0HvAEcNEyADLQAEQfcARw0TQQ4MFAsgAy0AAUHhAEcNEiADLQACQe4ARw0SIAMtAANB5wBHDRIgAy0ABEHlAEcNEkE2DBMLAkACQAJAAkACQCADLQAAIgFB8gBrDgYBFgIDFgQACwJAAkAgAUHhAGsOBQAXFxcBFwsgAy0AAUHsAEcNFiADLQACQfQARw0WIAMtAANBLUcNFiADLQAEQfMARw0WIAMtAAVB9gBHDRYgAy0ABkHjAEcNFkEPDBcLIAMtAAFB+ABHDRUgAy0AAkHwAEcNFSADLQADQekARw0VIAMtAARB8gBHDRUgAy0ABUHlAEcNFSADLQAGQfMARw0VQSMMFgsgAy0AAUHlAEcNFCADLQACQeYARw0UIAMtAAMiAUHyAEcEQCABQeUARw0VIAMtAARB8gBHDRUgAy0ABUHlAEcNFSADLQAGQfIARw0VQTcMFgsgAy0ABEHlAEcNFCADLQAFQfMARw0UIAMtAAZB6ABHDRRBOQwVCyADLQABQfIARw0TIAMtAAJB4QBHDRMgAy0AA0HpAEcNEyADLQAEQewARw0TIAMtAAVB5QBHDRMgAy0ABkHyAEcNE0HEAAwUCyADLQABQfAARw0SIAMtAAJB5wBHDRIgAy0AA0HyAEcNEiADLQAEQeEARw0SIAMtAAVB5ABHDRIgAy0ABkHlAEcNEkHHAAwTCyADLQABQeEARw0RIAMtAAJB8gBHDREgAy0AA0HuAEcNESADLQAEQekARw0RIAMtAAVB7gBHDREgAy0ABkHnAEcNEUHLAAwSCyADLQAAIgFB7QBHBEAgAUHjAEcNESADLQABIgFB4QBHBEAgAUHvAEcNEiADLQACQe4ARw0SIAMtAANB9ABHDRIgAy0ABEHlAEcNEiADLQAFQe4ARw0SIAMtAAZB9ABHDRIgAy0AB0EtRw0SIAMtAAhB9ABHDRIgAy0ACUH5AEcNEiADLQAKQfAARw0SIAMtAAtB5QBHDRJBHQwTCyADLQACQeMARw0RIAMtAANB6ABHDREgAy0ABEHlAEcNESADLQAFQS1HDREgAy0ABkHzAEcNESADLQAHQfQARw0RIAMtAAhB4QBHDREgAy0ACUH0AEcNESADLQAKQfUARw0RIAMtAAtB8wBHDRFBEgwSCyADLQABQeEARw0QIAMtAAJB+ABHDRAgAy0AA0EtRw0QIAMtAARB5gBHDRAgAy0ABUHvAEcNECADLQAGQfIARw0QIAMtAAdB9wBHDRAgAy0ACEHhAEcNECADLQAJQfIARw0QIAMtAApB5ABHDRAgAy0AC0HzAEcNEEEvDBELAkACQAJAIAMtAAAiAUHzAGsOAgECAAsgAUHpAEcEQCABQeMARw0SIAMtAAFB5ABHDRIgAy0AAkHuAEcNEiADLQADQS1HDRIgAy0ABEHjAEcNEiADLQAFQeEARw0SIAMtAAZB4wBHDRIgAy0AB0HoAEcNEiADLQAIQeUARw0SIAMtAAlBLUcNEiADLQAKQeMARw0SIAMtAAtB7wBHDRIgAy0ADEHuAEcNEiADLQANQfQARw0SIAMtAA5B8gBHDRIgAy0AD0HvAEcNEiADLQAQQewARw0SQRMMEwsgAy0AAUHmAEcNESADLQACQS1HDREgAy0AA0HtAEcNESADLQAEQe8ARw0RIAMtAAVB5ABHDREgAy0ABkHpAEcNESADLQAHQeYARw0RIAMtAAhB6QBHDREgAy0ACUHlAEcNESADLQAKQeQARw0RIAMtAAtBLUcNESADLQAMQfMARw0RIAMtAA1B6QBHDREgAy0ADkHuAEcNESADLQAPQeMARw0RIAMtABBB5QBHDRFBKAwSCyADLQABQeUARw0QIAMtAAJB4wBHDRAgAy0AA0EtRw0QIAMtAARB9wBHDRAgAy0ABUHlAEcNECADLQAGQeIARw0QIAMtAAdB8wBHDRAgAy0ACEHvAEcNECADLQAJQeMARw0QIAMtAApB6wBHDRAgAy0AC0HlAEcNECADLQAMQfQARw0QIAMtAA1BLUcNECADLQAOQesARw0QIAMtAA9B5QBHDRAgAy0AEEH5AEcNEEE9DBELIAMtAAFB8gBHDQ8gAy0AAkHhAEcNDyADLQADQe4ARw0PIAMtAARB8wBHDQ8gAy0ABUHmAEcNDyADLQAGQeUARw0PIAMtAAdB8gBHDQ8gAy0ACEEtRw0PIAMtAAlB5QBHDQ8gAy0ACkHuAEcNDyADLQALQeMARw0PIAMtAAxB7wBHDQ8gAy0ADUHkAEcNDyADLQAOQekARw0PIAMtAA9B7gBHDQ8gAy0AEEHnAEcND0HFAAwQCwJAAkACQCADLQAAIgFB8wBrDgMBEQIACyABQeMARw0QIAMtAAFB7wBHDRAgAy0AAkHuAEcNECADLQADQe4ARw0QIAMtAARB5QBHDRAgAy0ABUHjAEcNECADLQAGQfQARw0QIAMtAAdB6QBHDRAgAy0ACEHvAEcNECADLQAJQe4ARw0QQRQMEQsgAy0AAUHlAEcNDyADLQACQfQARw0PIAMtAANBLUcNDyADLQAEQeMARw0PIAMtAAVB7wBHDQ8gAy0ABkHvAEcNDyADLQAHQesARw0PIAMtAAhB6QBHDQ8gAy0ACUHlAEcND0HBAAwQCyADLQABQfMARw0OIAMtAAJB5QBHDQ4gAy0AA0HyAEcNDiADLQAEQS1HDQ4gAy0ABUHhAEcNDiADLQAGQecARw0OIAMtAAdB5QBHDQ4gAy0ACEHuAEcNDiADLQAJQfQARw0OQcYADA8LIAMtAAAiAUHwAEcEQCABQekARwRAIAFB4wBHDQ8gAy0AAUHvAEcNDyADLQACQe4ARw0PIAMtAANB9ABHDQ8gAy0ABEHlAEcNDyADLQAFQe4ARw0PIAMtAAZB9ABHDQ8gAy0AB0EtRw0PIAMtAAhB5ABHDQ8gAy0ACUHpAEcNDyADLQAKQfMARw0PIAMtAAtB8ABHDQ8gAy0ADEHvAEcNDyADLQANQfMARw0PIAMtAA5B6QBHDQ8gAy0AD0H0AEcNDyADLQAQQekARw0PIAMtABFB7wBHDQ8gAy0AEkHuAEcND0EVDBALIAMtAAFB5gBHDQ4gAy0AAkEtRw0OIAMtAANB9QBHDQ4gAy0ABEHuAEcNDiADLQAFQe0ARw0OIAMtAAZB7wBHDQ4gAy0AB0HkAEcNDiADLQAIQekARw0OIAMtAAlB5gBHDQ4gAy0ACkHpAEcNDiADLQALQeUARw0OIAMtAAxB5ABHDQ4gAy0ADUEtRw0OIAMtAA5B8wBHDQ4gAy0AD0HpAEcNDiADLQAQQe4ARw0OIAMtABFB4wBHDQ4gAy0AEkHlAEcNDkErDA8LIAMtAAFB8gBHDQ0gAy0AAkHvAEcNDSADLQADQfgARw0NIAMtAARB+QBHDQ0gAy0ABUEtRw0NIAMtAAZB4QBHDQ0gAy0AB0H1AEcNDSADLQAIQfQARw0NIAMtAAlB6ABHDQ0gAy0ACkHvAEcNDSADLQALQfIARw0NIAMtAAxB6QBHDQ0gAy0ADUH6AEcNDSADLQAOQeEARw0NIAMtAA9B9ABHDQ0gAy0AEEHpAEcNDSADLQARQe8ARw0NIAMtABJB7gBHDQ1BMwwOCwJAAkACQAJAIAMtAAAiAUH3AGsOAgEDAAsgAUHjAEcNDyADLQABQe8ARw0PIAMtAAJB7gBHDQ8gAy0AA0H0AEcNDyADLQAEQeUARw0PIAMtAAVB7gBHDQ8gAy0ABkH0AEcNDyADLQAHQS1HDQ8gAy0ACCIBQewARg0BIAFB5QBHDQ8gAy0ACUHuAEcNDyADLQAKQeMARw0PIAMtAAtB7wBHDQ8gAy0ADEHkAEcNDyADLQANQekARw0PIAMtAA5B7gBHDQ8gAy0AD0HnAEcND0EWDBALIAMtAAFB9wBHDQ4gAy0AAkH3AEcNDiADLQADQS1HDQ4gAy0ABEHhAEcNDiADLQAFQfUARw0OIAMtAAZB9ABHDQ4gAy0AB0HoAEcNDiADLQAIQeUARw0OIAMtAAlB7gBHDQ4gAy0ACkH0AEcNDiADLQALQekARw0OIAMtAAxB4wBHDQ4gAy0ADUHhAEcNDiADLQAOQfQARw0OIAMtAA9B5QBHDQ5BzAAMDwsgAy0ACSIBQeEARwRAIAFB7wBHDQ4gAy0ACkHjAEcNDiADLQALQeEARw0OIAMtAAxB9ABHDQ4gAy0ADUHpAEcNDiADLQAOQe8ARw0OIAMtAA9B7gBHDQ5BGQwPCyADLQAKQe4ARw0NIAMtAAtB5wBHDQ0gAy0ADEH1AEcNDSADLQANQeEARw0NIAMtAA5B5wBHDQ0gAy0AD0HlAEcNDUEXDA4LIAMtAAFBLUcNDCADLQACQfgARw0MIAMtAANB8wBHDQwgAy0ABEHzAEcNDCADLQAFQS1HDQwgAy0ABkHwAEcNDCADLQAHQfIARw0MIAMtAAhB7wBHDQwgAy0ACUH0AEcNDCADLQAKQeUARw0MIAMtAAtB4wBHDQwgAy0ADEH0AEcNDCADLQANQekARw0MIAMtAA5B7wBHDQwgAy0AD0HuAEcNDEHQAAwNCyADLQAAQeMARw0LIAMtAAFB7wBHDQsgAy0AAkHuAEcNCyADLQADQfQARw0LIAMtAARB5QBHDQsgAy0ABUHuAEcNCyADLQAGQfQARw0LIAMtAAdBLUcNCyADLQAIQfMARw0LIAMtAAlB5QBHDQsgAy0ACkHjAEcNCyADLQALQfUARw0LIAMtAAxB8gBHDQsgAy0ADUHpAEcNCyADLQAOQfQARw0LIAMtAA9B+QBHDQsgAy0AEEEtRw0LIAMtABFB8ABHDQsgAy0AEkHvAEcNCyADLQATQewARw0LIAMtABRB6QBHDQsgAy0AFUHjAEcNCyADLQAWQfkARw0LQRsMDAsgAy0AAEHjAEcNCiADLQABQe8ARw0KIAMtAAJB7gBHDQogAy0AA0H0AEcNCiADLQAEQeUARw0KIAMtAAVB7gBHDQogAy0ABkH0AEcNCiADLQAHQS1HDQogAy0ACEHzAEcNCiADLQAJQeUARw0KIAMtAApB4wBHDQogAy0AC0H1AEcNCiADLQAMQfIARw0KIAMtAA1B6QBHDQogAy0ADkH0AEcNCiADLQAPQfkARw0KIAMtABBBLUcNCiADLQARQfAARw0KIAMtABJB7wBHDQogAy0AE0HsAEcNCiADLQAUQekARw0KIAMtABVB4wBHDQogAy0AFkH5AEcNCiADLQAXQS1HDQogAy0AGEHyAEcNCiADLQAZQeUARw0KIAMtABpB8ABHDQogAy0AG0HvAEcNCiADLQAcQfIARw0KIAMtAB1B9ABHDQogAy0AHkEtRw0KIAMtAB9B7wBHDQogAy0AIEHuAEcNCiADLQAhQewARw0KIAMtACJB+QBHDQpBHAwLCwJAAkACQAJAAkACQCADLQAAIgFB5ABrDgkBAgMPBA8PDwUACyABQfYARw0OIAMtAAFB4QBHDQ4gAy0AAkHyAEcNDiADLQADQfkARw0OQckADA8LIAMtAAFB4QBHDQ0gAy0AAkH0AEcNDSADLQADQeUARw0NQSAMDgsgAy0AAUH0AEcNDCADLQACQeEARw0MIAMtAANB5wBHDQxBIQwNCyADLQABQfIARw0LIAMtAAJB7wBHDQsgAy0AA0HtAEcNC0ElDAwLIAMtAAFB7wBHDQogAy0AAkHzAEcNCiADLQADQfQARw0KQSYMCwsgAy0AAUHpAEcNCSADLQACQe4ARw0JIAMtAANB6wBHDQlBLQwKCyADLQAAQeYARw0IIAMtAAFB7wBHDQggAy0AAkHyAEcNCCADLQADQfcARw0IIAMtAARB4QBHDQggAy0ABUHyAEcNCCADLQAGQeQARw0IIAMtAAdB5QBHDQggAy0ACEHkAEcNCEEkDAkLAkACQCADLQAAQekAaw4EAAkJAQkLIAMtAAFB5gBHDQggAy0AAkEtRw0IIAMtAAMiAUHyAEcEQCABQe0ARw0JIAMtAARB4QBHDQkgAy0ABUH0AEcNCSADLQAGQeMARw0JIAMtAAdB6ABHDQlBJwwKCyADLQAEQeEARw0IIAMtAAVB7gBHDQggAy0ABkHnAEcNCCADLQAHQeUARw0IQSoMCQsgAy0AAUHvAEcNByADLQACQeMARw0HIAMtAANB4QBHDQcgAy0ABEH0AEcNByADLQAFQekARw0HIAMtAAZB7wBHDQcgAy0AB0HuAEcNB0EuDAgLIAMtAABB8ABHDQYgAy0AAUHyAEcNBiADLQACQe8ARw0GIAMtAANB+ABHDQYgAy0ABEH5AEcNBiADLQAFQS1HDQYgAy0ABkHhAEcNBiADLQAHQfUARw0GIAMtAAhB9ABHDQYgAy0ACUHoAEcNBiADLQAKQeUARw0GIAMtAAtB7gBHDQYgAy0ADEH0AEcNBiADLQANQekARw0GIAMtAA5B4wBHDQYgAy0AD0HhAEcNBiADLQAQQfQARw0GIAMtABFB5QBHDQZBMgwHCyADLQAAQfIARw0FIAMtAAFB5QBHDQUgAy0AAkH0AEcNBSADLQADQfIARw0FIAMtAARB+QBHDQUgAy0ABUEtRw0FIAMtAAZB4QBHDQUgAy0AB0HmAEcNBSADLQAIQfQARw0FIAMtAAlB5QBHDQUgAy0ACkHyAEcNBUE6DAYLIAMtAABB8wBHDQQgAy0AAUHlAEcNBCADLQACQeMARw0EIAMtAANBLUcNBCADLQAEQfcARw0EIAMtAAVB5QBHDQQgAy0ABkHiAEcNBCADLQAHQfMARw0EIAMtAAhB7wBHDQQgAy0ACUHjAEcNBCADLQAKQesARw0EIAMtAAtB5QBHDQQgAy0ADEH0AEcNBCADLQANQS1HDQQgAy0ADkHhAEcNBCADLQAPQeMARw0EIAMtABBB4wBHDQQgAy0AEUHlAEcNBCADLQASQfAARw0EIAMtABNB9ABHDQRBOwwFCyADLQAAQfMARw0DIAMtAAFB5QBHDQMgAy0AAkHjAEcNAyADLQADQS1HDQMgAy0ABEH3AEcNAyADLQAFQeUARw0DIAMtAAZB4gBHDQMgAy0AB0HzAEcNAyADLQAIQe8ARw0DIAMtAAlB4wBHDQMgAy0ACkHrAEcNAyADLQALQeUARw0DIAMtAAxB9ABHDQMgAy0ADUEtRw0DIAMtAA5B5QBHDQMgAy0AD0H4AEcNAyADLQAQQfQARw0DIAMtABFB5QBHDQMgAy0AEkHuAEcNAyADLQATQfMARw0DIAMtABRB6QBHDQMgAy0AFUHvAEcNAyADLQAWQe4ARw0DIAMtABdB8wBHDQNBPAwECyADLQAAQfMARw0CIAMtAAFB5QBHDQIgAy0AAkHjAEcNAiADLQADQS1HDQIgAy0ABEH3AEcNAiADLQAFQeUARw0CIAMtAAZB4gBHDQIgAy0AB0HzAEcNAiADLQAIQe8ARw0CIAMtAAlB4wBHDQIgAy0ACkHrAEcNAiADLQALQeUARw0CIAMtAAxB9ABHDQIgAy0ADUEtRw0CIAMtAA5B9gBHDQIgAy0AD0HlAEcNAiADLQAQQfIARw0CIAMtABFB8wBHDQIgAy0AEkHpAEcNAiADLQATQe8ARw0CIAMtABRB7gBHDQJBPwwDCwJAAkACQCADLQAAQfMAaw4DAQQABAsgAy0AAUHwAEYNAQwDCyADLQABQfQARw0CIAMtAAJB8gBHDQIgAy0AA0HpAEcNAiADLQAEQeMARw0CIAMtAAVB9ABHDQIgAy0ABkEtRw0CIAMtAAdB9ABHDQIgAy0ACEHyAEcNAiADLQAJQeEARw0CIAMtAApB7gBHDQIgAy0AC0HzAEcNAiADLQAMQfAARw0CIAMtAA1B7wBHDQIgAy0ADkHyAEcNAiADLQAPQfQARw0CIAMtABBBLUcNAiADLQARQfMARw0CIAMtABJB5QBHDQIgAy0AE0HjAEcNAiADLQAUQfUARw0CIAMtABVB8gBHDQIgAy0AFkHpAEcNAiADLQAXQfQARw0CIAMtABhB+QBHDQJBwgAMAwsgAy0AAkHnAEcNASADLQADQfIARw0BIAMtAARB4QBHDQEgAy0ABUHkAEcNASADLQAGQeUARw0BIAMtAAdBLUcNASADLQAIQekARw0BIAMtAAlB7gBHDQEgAy0ACkHzAEcNASADLQALQeUARw0BIAMtAAxB4wBHDQEgAy0ADUH1AEcNASADLQAOQfIARw0BIAMtAA9B5QBHDQEgAy0AEEEtRw0BIAMtABFB8gBHDQEgAy0AEkHlAEcNASADLQATQfEARw0BIAMtABRB9QBHDQEgAy0AFUHlAEcNASADLQAWQfMARw0BIAMtABdB9ABHDQEgAy0AGEHzAEcNAUHIAAwCCyADLQAAQfQARw0AIAMtAAFB5QBHDQBBwwAMAQtB0QALQf8BcSIBQdEARg0BIAcgAToAAEECIQYMAgsgAkH//wNLDQEgByACNgIEIAcgATYCAEEAIQYMAQsCQCACQQdNBEAgAyEFIAIhAQNAIAUtAABFDQMgBUEBaiEFIAFBAWsiAQ0ACwwBCyAKQQhqQQAgAyACEJ0SIAooAghBAUYNAQsgByACNgIEIAcgAzYCAEEBIQYLIAcgBjoACCAKQRBqJAACQCAELQB8IgNBA0YEQCAAQQE2AgAMAQsgBCgCdCECAkACQAJAIANBAkcEQCAEKAJ4IQEgA0EBcQ0CIARB9ABqIAFBAEEBQQEQoBggBCgCeCEDIAQoAnRBAUYNASAEQQA2AkggBCAEKAJ8IgU2AkQgBCADNgJMIARBB0EgIANBCnZnayIHIAdBB08bQQJ0QQFyIgc2AlAgAQRAA0AgAi0AAEG878MAai0AACIDRQRAIABBATYCACMAQRBrIgAkAAJAIARBxABqIgEoAgwiAkEBcQRAIAAgAkEFdiICIAEoAgRqNgIMIAAgASgCACACazYCCCAAIAEoAgggAmo2AgQgAEEEakEBQQEQ4B4MAQsgAhDDLAsgAEEQaiQADAcLIAQgAzoAdCMAQRBrIgokACAEQcQAaiIDKAIIIAMoAgQiCGsiBUUEQCMAQSBrIgUkACADKAIEIQgCQAJAAkACQAJAAkAgAygCDCIHQQFxRQRAIAhBAWoiBiAISQ0BIAcoAhBBAUYNAiAFQRRqQQEgBygCDCIIQQlqdCIJIAYgBiAJSRsgBiAIG0EAQQFBARCgGCAFKAIYIQYgBSgCFEEBRg0EIAVBADYCECAFIAUoAhw2AgwgBSAGNgIIIAVBCGogAygCACIGIAYgAygCBGoQvSYgBxDDLCADIAhBAnRBAXI2AgwgAyAFKAIMNgIAIAMgBSgCCDYCCAwGCyADKAIIIgsgB0EFdiIGaiIJIAhHIAYgCE9xDQIgBSAJNgIUIAUgBiAIaiIMNgIcIAUgAygCACAGayIHNgIYIAMgCCALRgR/IAVBFGogDEEBQQFBARDeKCAFKAIYIQcgBSgCFAUgCQsgBms2AgggAyAGIAdqNgIADAULQaSIiAFBCEGsiIgBEJ8pAAsgBygCACIJIAMoAgAiDiAHKAIEIgtrIgwgBmoiDUkNAiADIAY2AggMAwsgAygCACILIAZrIQYgCARAIAYgCyAI/AoAAAsgAyAHQR9xNgIMIAMgBjYCACADIAk2AggMAgsgBiAFKAIcQbyIiAEQ/S8ACwJAIAYgCU0gCCAMTXFFBEAgBiANSw0BIAcgCCAMaiIINgIIIAMgDSAJQQF0IgYgBiANSRsgCGsiBiAJIAhrSwR/IAcgCCAGQQFBARDeKCAHKAIEIQsgBygCAAUgCQsgDGs2AgggAyALIAxqNgIADAILIAgEQCALIA4gCPwKAAALIAMgCzYCACADIAcoAgA2AggMAQtBpIiIAUEIQcyIiAEQyyQACyAFQSBqJAAgAygCCCADKAIEIghrIQULIAMoAgAgCGogBEH0AGotAAA6AAAgBUUEQCAKIAU2AgwgCkEBNgIIIApBCGoQ8yUACyADIAhBAWo2AgQgCkEQaiQAIAJBAWohAiABQQFrIgENAAsgBCgCSCEIIAQoAkQhBSAEKAJQIQcgBCgCTCEDCyAHQQFxBH8gBEHUAGoiAiAHQQV2IgEgCGo2AgggAiAFIAFrNgIEIAIgASADajYCACAEQeAAaiACEOcVIAQgATYCcCAEKAJoIgIgAUkNBCAEKAJkIAFqIQUgAiABayEIIAQoAmwhByAEKAJgBUHciIgBCyEBIAAgBzYCECAAIAg2AgwgACAFNgIIIAAgATYCBCAAQQA2AgAMBAsgACACOgAIIABCADcCAAwDCyADIAQoAnxB5O7DABD9LwALIABBBGogAiABEPweIABBADYCAAwBCyAEIAI2AowBIARBAjYCeCAEQZzvwwA2AnQgBEICNwKAASAEQcUCNgKcASAEQcUCNgKUASAEIARBkAFqNgJ8IAQgBEGMAWo2ApgBIAQgBEHwAGo2ApABIARB9ABqQazvwwAQ7ywACyAEQaABaiQAC/YDAhB/AX4jAEEQayIFJAAgAUECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEGIAFBD0sNASABQQdLBEAgACACENQWIAAgBkEDdCIDaiACIANqENQWQQQMAwsgAiAAKQIANwIAIAIgBkEDdCIDaiAAIANqKQIANwIAQQEMAgsACyAAIAIgAiABQQN0aiIDEKgtIAAgBkEDdCIEaiACIARqIANBQGsQqC1BCAshCSAFQgI3AgQgCUEDdCELIAlBAWohDiAFIAY2AgwgASAGayEPIAVBCGohEEEAIQNBAiEHA0AgBSADQQFqIgQ2AgAgA0ECdCEIIAQhAyAPIAYgCCAQaigCACIEGyIRIAlLBEAgACAEQQN0IgNqIRJBCCEIIAIgA2oiDSEMIA4hAyAJIQQDQCADIQcgDSAEQQN0IgNqIgQgAyASaikCACIUNwIAIBSnIhMgBEEIaygCAEkEQCAIIQQgDCEDAn8DQCADIAtqIgogCkEIaykCADcCACANIAQgC0YNARogBEEIaiEEIANBCGshAyAKQRBrKAIAIBNLDQALIAMgC2oLIBQ3AgALIAhBCGshCCAMQQhqIQwgByAHIBFJIgpqIQMgByEEIAoNAAsgBSgCBCEHIAUoAgAhAwsgAyAHRw0ACyACIAEgABD/EQsgBUEQaiQAC/wEAgZ/BH4jAEGgAWsiAyQAIAEoAgwoAhAgAkEDdGopAwAhCSABKAIIIgUoAgAoAgAiBCkDACEKIAMgBCkDCCILNwM4IAMgCjcDMCADIAlCP4ciDDcDKCADIAk3AyAgA0EANgIcIAMgCSAMIAogCyADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYQMNgJMIANBhAw2AkQgAyADQUBrNgJwIAMgA0EwaiIGNgJIIAMgA0EgajYCQCADQdgAaiICIANB6ABqIgcQmQ4gA0GUAWogA0HkAGooAgA2AgAgA0GIgICAeDYCVCADIANB3ABqIgQpAgA3AowBIAMgAykCVDcChAEgA0EBNgKAASADQYABaiIIQQRyEIgRIAUoAgQhASADIAk3AzAgA0EENgJsIANBzJH/ADYCaCADQgQ3AnQgA0GGDDYCnAEgA0H0CzYClAEgAyABQQFqNgKQASADQbsHNgKMASADIAE2AogBIANBzAE2AoQBIANBoJH/ADYCgAEgAyAINgJwIAMgBjYCmAEgAiAHEJkOIANByABqIAQoAgA2AgAgA0GCgICAeDYCVCADIAMpAlQ3A0AgAykCYAwBCyADQYABaiADKQMAIgkgAykDCCIKIAUoAggtAAAQrQ4gAygCgAFBk4CAgHhGDQEgA0HIAGogA0GIAWooAgA2AgAgAyADKQKAATcDQCADKQKMAQshCSAAIAMpA0A3AgAgACAJNwIMIABBCGogA0HIAGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCjcDCCAAIAk3AwALIANBoAFqJAALugQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAAQQN0aiEEIABBAWtB/////wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIAIAUgAygCBCgCDBEGAEUNAEEBDAULQQEgASgCACADIAFBBGooAgARAgANBBogAEEIaiEAIAQgAUEIaiIBRw0ACwwCCyAAQRhsIQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRqKAIAIgFFDQAgAygCACAAKAIAIAEgAygCBCgCDBEGAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJaiIBQQhqLwEAQQFrDgIBAgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJAIAEvAQBBAWsOAgECAAsgAUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMgCDsBDCADIAFBFGooAgA2AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABKAIEEQIADQMaIABBCGohACAFQRhqIgUgCkcNAAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAoAgQgAygCBCgCDBEGAEUNAEEBDAELQQALIANBEGokAAuVBAEMfyABQQFrIQ4gACgCBCEKIAAoAgAhCyAAKAIIIQwCQANAIAUNAQJ/AkAgAiADSQ0AA0AgASADaiEFAkACQAJAIAIgA2siB0EHTQRAIAIgA0cNASACIQMMBQsCQCAFQQNqQXxxIgYgBWsiBARAQQAhAANAIAAgBWotAABBCkYNBSAEIABBAWoiAEcNAAsgBCAHQQhrIgBNDQEMAwsgB0EIayEACwNAQYCChAggBigCACIJQYqUqNAAc2sgCXJBgIKECCAGQQRqKAIAIglBipSo0ABzayAJcnFBgIGChHhxQYCBgoR4Rw0CIAZBCGohBiAEQQhqIgQgAE0NAAsMAQtBACEAA0AgACAFai0AAEEKRg0CIAcgAEEBaiIARw0ACyACIQMMAwsgBCAHRgRAIAIhAwwDCwNAIAQgBWotAABBCkYEQCAEIQAMAgsgByAEQQFqIgRHDQALIAIhAwwCCyAAIANqIgZBAWohAwJAIAIgBk0NACAAIAVqLQAAQQpHDQBBACEFIAMhBiADDAMLIAIgA08NAAsLIAIgCEYNAkEBIQUgCCEGIAILIQACQCAMLQAABEAgC0HI8YkBQQQgCigCDBEGAA0BC0EAIQQgACAIRwRAIAAgDmotAABBCkYhBAsgACAIayEAIAEgCGohByAMIAQ6AAAgBiEIIAsgByAAIAooAgwRBgBFDQELC0EBIQ0LIA0LkAUCBX8GfiMAQaABayIDJAAgASgCCCIFKAIAIQYgA0GAAWoiByABKAIMKAIQIAJBBXRqIgQpAwAiCiAEKQMIIgsgBCkDECIMIAQpAxgiDRDWIwJAAkACfgJAAkAgAygCgAFBAXFFDQAgAykDmAEgAykDkAEiCEKAgICAgICAgIB/fSAIVK18QgBSDQAgAyAGKAIAKQMAIgk3AyAgAyAINwMYIAMgCCAIQj+HIAkgCUI/hxCoHiADKQMIIAMpAwAiCEI/h1ENASADQQI2AoQBIANBrJD/ADYCgAEgA0ICNwKMASADQYYMNgI4IANBhgw2AjAgAyADQSxqNgKIASADIANBIGo2AjQgAyADQRhqNgIsIANB7ABqIAcQmQ4gA0HMAGogA0HwAGopAgA3AgAgA0HUAGogA0H4AGooAgA2AgAgA0GIgICAeDYCaCADIAMpAmg3AkQgA0EBNgJAIANBQGtBBHIQiBELIAUoAgQhASADIA03A1ggAyAMNwNQIAMgCzcDSCADIAo3A0AgA0HMkf8ANgJoIANCBDcCdCADQYMMNgKcASADQfQLNgKUASADIAFBAWo2ApABIANBuwc2AowBIAMgATYCiAEgA0HMATYChAEgA0Ggkv8ANgKAASADIANBgAFqNgJwIAMgA0FAazYCmAEgA0EENgJsIANBMGogA0HoAGoQmQ4gAykCOCEJQYKAgIB4IQQgAykCMAwBCyADQYABaiAIIAUoAggtAAAQjRAgAygCgAEiBEGTgICAeEYNASADKQKMASEJIAMpAoQBCyEIIAAgCTcCDCAAIAg3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQN0aiAINwMACyADQaABaiQAC7kLAg9/A34jAEGACGsiDCQAAkACQCABQYcBTwRAIAxBEGohDwNAIAxBDGohDSAALwH0AyEEQgAhESMAQfALayIFJAAgBUH4B2oiAkH87IABQSj8CgAAIAVBCjsB7AsgBUEIaiIDIAJB+AP8CgAAAkACQCAERQ0AAkACQAJAIAUvAfwDIgJFDQAgAkECdCECIAA1AgAhEwNAIAMgAzUCACATfiARfCISPgIAIANBBGohAyASQiCIIREgAkEEayICDQALIBJCgICAgBBUDQAgBS8B/AMiAkH8AEsNASAFQQhqIAJBAnRqIBE+AgAgBSAFLwH8A0EBajsB/AMLIARBAUcNAQwCCyANQQA2AgAMAgtBAiAEIARBAk0bIRBBASEEA0ACQCAAIARBAnRqKAIAIgNFDQAgBUH4B2oiAkH87IABQSj8CgAAIAVBCjsB7AsgBUGABGogAkH4A/wKAAACQAJAIAUvAfQHIgJFBEBBACEDDAELIAJBAnQhAiADrSETIAVBgARqIQNCACERA0AgAyADNQIAIBN+IBF8IhI+AgAgA0EEaiEDIBJCIIghESACQQRrIgINAAsgBS8B9AchAyASQoCAgIAQVA0AIANB/ABLDQEgBUGABGogA0ECdGogET4CACAFIAUvAfQHQQFqIgM7AfQHCwJ/IAVBgARqIQpBACECAkACQAJAIANB//8DcSIDIAVBCGoiCC8B9AMiCSAEayIGQQAgBiAJTRtLBEAgAyAEaiIGQf0ASw0CAkAgBiAJTQ0AIAYgCWtBAnQiAkUNACAIIAlBAnRqQQAgAvwLAAsgCCAGOwH0AwwBCyADRQ0CCyAIIARBAnRqIQdBACEGIAMhAiAEIQkDQCAILwH0AyILIAlNBEAgCSALQdyYgQEQwyEACyAHIAcoAgAiCyAKKAIAaiIONgIAIAsgDkshCyAGQQFxBH8gByAOQQFqIgY2AgAgCyAGRXIFIAsLIQYgB0EEaiEHIAlBAWohCSAKQQRqIQogAkEBayICDQALIAZFDQEgAyAEaiICQQFrIQogCCACQQJ0aiEHA0AgCkEBaiIKIAgvAfQDIgJPBEBBACACQfwASw0EGiAIIAJBAnRqQQE2AgAgCCAILwH0A0EBajsB9ANBAQwEC0EBIQIgByAHKAIAQQFqIgM2AgAgB0EEaiEHIANFDQALCyACDAELQQELDQELIA1BADYCAAwDCyAEQQFqIgQgEEcNAAsLAkAgBS8B/AMiA0UNACAFQQRqIgQgA0ECdGoiAkUNAANAIAIoAgANASAFIANBAWsiAzsB/AMgA0H//wNxIgJFDQEgBCACQQJ0aiICDQALCyANQQRqIAVBCGpB+AP8CgAAIA1BATYCAAsgBUHwC2okACAMKAIMRQ0CIAxBiARqIgIgD0H4A/wKAAAgACACQfgD/AoAACABQYcBayIBQYcBTw0ACwtBASEDQQUhBEENIQIDQAJAIAJBAXEEQCADIARsIQMgAkEBRg0BCyACQQF2IQIgBCAEbCEEDAELCyABQQ1PBEAgA60hEwNAAkAgAC8B9AMiAkUNACACQQJ0IQRCACERIAAhAgNAIAIgAjUCACATfiARfCISPgIAIAJBBGohAiASQiCIIREgBEEEayIEDQALIBJCgICAgBBUDQAgAC8B9AMiAkH8AEsNAyAAIAJBAnRqIBE+AgAgACAALwH0A0EBajsB9AMLIAFBDWsiAUENTw0ACwtBASEDIAFFDQEgAC8B9AMiAkUNASACQQJ0IQQgAUEDdEHg7YABajUCACETQgAhESAAIQIDQCACIBMgAjUCAH4gEXwiEj4CACACQQRqIQIgEkIgiCERIARBBGsiBA0ACyASQoCAgIAQVA0BIAAvAfQDIgFB/ABLDQAgACABQQJ0aiARPgIAIAAgAC8B9ANBAWo7AfQDDAELQQAhAwsgDEGACGokACADC4sEAgJ/AX4gAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIDQStrDgMCAQIBCyABLQAAIQMLAkACQAJAAkACQAJAAkACQAJAIANB/wFxQStrDgMAAgECCyACQQFrIQMgAUEBaiEBIAJBCUkNAiADIQIMBgsgAkEBayEEIAFBAWohASACQQlPBEBBACEDA0AgBEUNCCABLQAAQTBrIgJBCUsNCSADrEIKfiIFQiCIpyAFpyIDQR91Rw0EIAFBAWohASAEQQFrIQQgAkEASiADIAMgAmsiA0pzRQ0ACyAAQQM6AAFBAQwKCyAERQ0EQQAhAwNAIAEtAABBMGsiAkEJSw0IIAFBAWohASADQQpsIAJrIQMgBEEBayIEDQALDAYLIAJBB0sNBAwCCyADIgJFDQIMAQsgAEEDOgABQQEMBgtBACEDA0AgAS0AAEEwayIEQQlLDQQgAUEBaiEBIAQgA0EKbGohAyACQQFrIgINAAsMAgtBACEDDAELQQAhAwNAIAJFDQEgAS0AAEEwayIEQQlLDQIgA6xCCn4iBUIgiKcgBaciA0EfdUcNAyABQQFqIQEgAkEBayECIARBAEggAyADIARqIgNKc0UNAAsgAEECOgABQQEMAwsgACADNgIEQQAMAgsgAEEBOgABQQEMAQsgAEECOgABQQELOgAAC/kIAgp/A34jAEGQAmsiAyQAIANBCGogAhDDNCADKAIMIQQgAygCCCECIAMgATYCHCADIAI2AhQgAyACIARBAnRqNgIYIANByABqIQcjAEFAaiIEJAAgBEEINgIIIARBOGogA0EUaiICQQhqKAIANgIAIAQgAikCADcDMCAEIARBCGo2AjwgBEEkaiEIIwBBMGsiAiQAIAJBCGogBEEwaiIFIAJBIGoiCSAFKAIMEOMSAkACQAJAAkAgAigCCEEBcUUNACACKAIMIgpFDQAgCUEEQQBBBEEEEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCILIAo2AgAgAkEcaiIMQQE2AgAgAiALNgIYIAIgBjYCFCACQShqIAVBCGopAgA3AwAgAiAFKQIANwMgIAJBFGohBiMAQSBrIgUkACAFQRBqIAkgBUEfaiAJKAIMEOMSAkAgBSgCEEEBcUUNACAFKAIUIgtFDQADQCAGKAIIIgogBigCAEYEQCAGIApBAUEEQQQQ0CgLIAYoAgQgCkECdGogCzYCACAGIApBAWo2AgggBUEIaiAJIAVBH2ogCSgCDBDjEiAFKAIIQQFxRQ0BIAUoAgwiCw0ACwsgBUEgaiQAIAhBCGogDCgCADYCACAIIAIpAhQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyACQTBqJAAMAQsgBiACKAIoQciXzwAQ/S8ACwJAIAQoAghBCEcEQCAHIAQpAwg3AwAgB0EQaiAEQRhqKQMANwMAIAdBCGogBEEQaikDADcDACAIEKInIAhBBEEEEOAeDAELIAcgBCkCJDcCBCAHQQg2AgAgB0EMaiAEQSxqKAIANgIACyAEQUBrJAAgA0G4AWoiAiADQdQAaigCADYCACADIAMpAkw3A7ABAkACQCADKAJIIgRBCEcEQCADKQNYIQ0gACADKQOwATcCDCAAIA03AxggACAENgIIIABBATYCACAAQRRqIAIoAgA2AgAMAQsgA0GUAWogAigCADYCACADIAMpA7ABNwKMASADQQM7AawBIANBAzsB2AEgA0EROgDEASADQQA2AsABIANCgICAgMAANwK4ASADQQA2ArABIAMgASgCBCIENgLUASADIAEoAgAiATYC0AEgAyABNgKkASADIAQ2AqgBIANBoAFqIANBzAFqKAIANgIAIAMgAykCxAE3ApgBIANBADYChAEgAhCiJyACQQRBBBDgHiADQcgAaiADQYQBahDCDiADKAJIQQFGBEAgA0EoaiADQeAAaikDACINNwIAIANBIGogA0HYAGopAwAiDjcCACADIAMpA1AiDzcCGCAAQRhqIA03AgAgAEEQaiAONwIAIAAgDzcCCCAAQQE2AgAMAQsgA0EUaiIBIANByABqQQRyQTT8CgAAIANB3AFqIgIgAUE0/AoAAEE8QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQQRqIAEQpRIgAEEANgIACyADQZACaiQADwtBBEE8EKM9AAvvBAECfyMAQTBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0AAEENaw4aABIBEAIDBBISBQYHCAkSEhISEhISDwoLEgwSCyABLQAAIgRBBGtBAkkNECAEQQ1HDREgAigCBA0MIAItAAEhBAwNCyABLQAAIgRBBUYNDyAEQQ5HDRAMDwsgAS0AAEEFRw0PDA4LIAEtAABBBUcNDgwNCyABLQAAQRNHDQ0MDAsgAS0AAEEURw0MDAsLIAEtAABBFEcNCwwKCyABLQAAQRRHDQoMCQsgAS0AAEEUaw4FCAkJCQgJCyABLQAAQRRrDgUHCAgIBwgLIAEtAABBJUcNBwwGCyABLQAAQSVHDQYMBQsgAS0AAEElRg0EDAULIAItAAEiBCABLQABRg0DCwJAAkACQCAEQQFrDgMBAgYACyABLQABQQNHDQUgASgCBA0FDAQLIAEtAAFBA0cNBCABKAIEDQQMAwsgAS0AAUEDRw0DIAEoAgQNAwwCCyADQSBqIAFBCGooAgA2AgAgAyABKQIANwMYIANBJGoiASACKAIIEMIGIANBDGoiBCADQRhqIAEQ0QogBCACKAIIELgIRQRAIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgAhCVDAwECyAAIAIpAgA3AgAgAEEIaiACQQhqKAIANgIAIANBDGoQlQwMAwsgAS0AAEEERw0BCyAAIAIpAgA3AgAgAEEIaiACQQhqKAIANgIAIAEQlQwMAQsgACABKQIANwIAIABBCGogAUEIaigCADYCACACEJUMCyADQTBqJAAL0yMCK38CfiMAQTBrIgokACABQRxqISpBASEGAkACQANAAkACQAJAAkACQCABLQAgIgQEQCAEQQJHBEACf0EAIAEtACINABogCkEgakElQeDnzwBBEBDNGiAKLQAgQQRGBEAgCigCJAwBCyAKKQMgIi9C/wGDQgRSDQMgL0IgiKcLRQRAIAFBAjoAIAsgAEEEOgAAIABBADYCBAwICyAAQQQ6AAAgAEEANgIEDAcLQQEhB0EAIQwgBkUEQCABKAIAIQkgASgCCCIHIAEoAgwiDE8EQCABKAIQIQggASgCFCEHIAEoAhgiBiABKAIEIgQgBCAGSxsiDARAIAkgByAM/AoAAAsgASAGIAxrNgIYIAEgByAMajYCFCABIAw2AgwgAUEANgIIIAEgDCAIIAggDEkbNgIQQQAhBwsgCkEgaiIEQQA2AgAgBCAMIAdrNgIIIAQgByAJajYCBCAKKAIgQQFGBEAgACAKKQIkNwIADAgLIAooAigiDEUNAiAKKAIkIQcLIApBADYCFCAKIAw2AhAgCiAHNgIMIApBADYCKCAKIAM2AiQgCiACNgIgIAxFDQIgAS0AIkEBcUUNAiAKQRhqIQYjAEEQayIHJAAgKigCACIEQQA2AuDrASAEQQA2ArTrAUEAENI9IQQgB0EANgIEIAcgBEEARzYCAAJAAkAgBygCAEEBcUUNACAHQQhqIAcoAgQQ4hogBy0ACEEERg0AIAcpAwgiL0L/AYNCBFENACAGIC83AgAMAQsgBkEEOgAACyAHQRBqJAAgCi0AGEEERwRAIAopAxgiL0L/AYNCBFINBAsgAUEAOgAiDAILIAAgLzcCAAwFCyABQQE6ACBBACEGDAMLIwBBEGsiICQAIwBBMGsiESQAIApBIGoiBigCACEEIBEgBigCBDYCGCARIAQ2AhQgESAGNgIQIBEgBigCCDYCHCARQSBqIi0gCkEMahDfLyAqKAIAIQVBACEIIwBBIGsiDiQAIBFBJGoiEygCCCEhIBMoAgQhIiATKAIAIQcgEUEUaiIXKAIEISMgDiAXKAIAIgQgFygCCCInaiIuNgIcAkAgISAiSwRAQbh/IQYMAQsCQCAjICdJDQACQCAFKALk6wFBAUcNACAFKAK06wFFDQBBmH8hBiAFKALo6wEgBEcNAiAFKALw6wEgJ0cNAiAFKALs6wEgI0cNAgsgBCAjaiEbIAcgImohGCAFQejrAWohJCAFQfzqAWohKCAiICFrIQwgBUGg7AVqIRwgBUHA6QFqIR0gBUHQ6wFqISkgByAhaiIWIQQDQAJAIAQhBwJ/AkAgCEEBcUUEQEF/IQYCQAJAAkAgHSAcAn8CQAJAIAUoArTrAQ4FAQADBAUMCyAFKALY6wEMAQsgBUEANgLA6wEgBUEBNgK06wEgKUIANwMAIClBCGpCADcDACAkIBcpAgA3AgAgJEEIaiAXQQhqKAIANgIAQQALIAUoAuzqARDnCSEEAkAgBSgCrOsBRQ0AIAUoAqjrAUUNACAFEMUcCyAEQYh/SwRAIAQhBgwKCyAEBEAgBCAFKALY6wEiBmsiCSAYIAdrIghLBEAgByAYRwRAIAgEQCAGIBxqIAcgCPwKAAALIAUgBiAIaiIGNgLY6wELIBMgEygCBDYCCCAdIBwgBiAFKALs6gEQ5wkiBkGIf0sNC0ECQQYgBSgC7OoBGyIGIAQgBCAGSRsgBSgC2OsBa0EDaiEGDAsLIAkEQCAGIBxqIAcgCfwKAAALIAUgBDYC2OsBIAcgCWohBEEAIQgMCAsCQCAdKQMAIi9Cf1ENACAFKALU6QFBAUYNACAvIBsgDigCHCIQayIlrVYNACMAQRBrIgskAEEAIQ0jAEFAaiIJJAACQAJAIAxBCEkNACAWKAAAQXBxQdDUtMIBRw0AIAtCADcDCCALQQA2AgAgC0FyQbh/IBYoAAQiBkEIaiIEIAQgDEsbIAZBd0sbNgIEDAELIAlBEGogFiAMQQAQ5wkiBEGJf08EQCALQn43AwggCyAENgIEDAELIAQEQCALQn43AwggC0G4fzYCBAwBCyAMIAkoAigiBGshCCAEIBZqIQYDQAJAIAYgCCAJQQRqEJQjIhJBiH9NBEAgCCASQQNqIgRPDQFBuH8hEgsgC0J+NwMIIAsgEjYCBAwCCyANQQFqIQ0gCCAEayEIIAQgBmohBiAJKAIIRQ0ACyAJKAIwBEAgCEEDTQRAIAtCfjcDCCALQbh/NgIEDAILIAZBBGohBgsgCyANNgIAIAsgBiAWazYCBCALIAk1AiAgDa1+IAkpAxAiLyAvQn9RGzcDCAsgCUFAayQAIAsoAgQhDyALQRBqJAAgDCAPSQ0AIBYhEiAPIQkgBRCtLSEeQQAhFEEAIRlBACErIwBBEGsiHyQAIB4EQCAeKAIEIRQgHigCCCEZCyAFQZDqAWohLCAQIQYDQEEBQQUgBSgC7OoBGyEHAkACQAJAAkACQANAIAcgCUsNAQJAIAlBBEkNACASKAAAQXBxQdDUtMIBRw0AQbh/IQggCUEISQ0GIBIoAAQiC0F3SwRAQXIhCAwHCyAJIAtBCGoiBEkNBiALQYB/SwRAIAQhCAwHCyAJIARrIQkgBCASaiESDAELCwJAIB4EQCAFIB4Q8igMAQsgBRDhGwJ/QQAgFEUgGUVyDQAaAn8gFCAZQQhJDQAaIBQgFCgAAEG3yMLhfkcNABogBSAUKAAENgKc6wFBYiAFQRBqIBQgGRD3CyIEQYh/Sw0BGiAFQoGAgIAQNwOI6gEgBCAUagshCCAFIAUoAqzpASIHNgK46QEgBSgCsOkBIQQgBSAINgKw6QEgBSAUIBlqNgKs6QEgBSAIIAQgB2tqNgK06QFBAAsiCEGIf0sNBQsgBSAGICUQiilBuH8hCCAJQQVBCSAFKALs6gEiBBtJDQIgEkEBQQUgBBsgBBCxICIEQYh/Sw0DIAkgBEEDakkNAiAFIBIgBBCQFyIHQYh/SwRAIAchBAwECyAGICVqISYgCSAEayELIAQgEmohFSAGIQ0DQCAVIAsgH0EEahCUIyIHQYh/SwRAIAchBAwFCyALQQNrIgsgB0kNAyAVQQNqIhogJiAaICZJGyAmIA0gGk0bIRVBbCEEAkACQAJAAkACQAJAAkACQCAfKAIEDgMBAgAMCyAFIA0gFSANayAaIAdBABCpAiEEDAQLIAcgJiANa0sNCCANRQRAIAcNAgwFCyAHIgRFDQUgDSAaIAT8CgAADAULIB8oAgwiBCAVIA1rSw0HIA0NASAERQ0DC0G2fyEEDAgLIARFDQAgDSAaLQAAIAT8CwALIARBiH9LDQYMAQtBACEECyAFKAL06gEEQCAsIA0gBBCJDAsgCyAHayELIAcgGmohFSAEIA1qIQ0gHygCCEUNAAsgBSkDwOkBIi9Cf1IEQEFsIQQgLyANIAZrrFINBAsCfyAFKALg6QFFBEAgCyEJIBUMAQtBaiEEIAtBBEkNBCAFKALw6gFFBEAgFSgAACAsEO4Wp0cNBQsgC0EEayEJIBVBBGoLIRIgDSAGayEEDAMLIAkEQEG4fyEIDAQLIAYgEGshCAwDC0G6fyEEDAELQbh/IQQLICtBACAEa0EAIARBiX9PG0EKRnENACAEQYh/SwRAIAQhCAwBCyAlIARrISUgBCAGaiEGQQEhKwwBCwsgH0EQaiQAIAgiBkGIf0sNCiAFQQA2ArTrASAFQQA2ArzpASAOIAYgEGpBACAQGzYCHCAPIBZqIQRBASEIDAgLAkAgBSgC5OsBQQFHDQAgBSgC1OkBQQFGDQAgHSkDACIvQn9RDQAgLyAbIA4oAhxrrVYNCQsgBSAFEK0tEPIoIAUCfyAFKACg7AVBcHFB0NS0wgFGBEAgBSgApOwFIQhBBwwBCyAFIBwgBSgC2OsBEJAXIgZBiH9LDQpBAyEIQQILNgKE6gEgBSAINgK86QEgBUKACCAFKQPI6QEiLyAvQoAIWBsiLzcDyOkBIAU1AsTrASAvVARAQXAhBgwKC0EEIAUoAtDpASIEIARBBE0bIRBBACEGQQAhBCAFKALk6wFFBEBBcCAdKQMAIjAgL0KAgAggLyAvQoCACFobfELAgAh8Ii8gLyAwVhsiL6cgL0KAgICAEFobIQQLIAUoAszrASIJIAUoArzrASIIaiAEIBBqIg9BA2xPBEAgBSgCtOwFQQFqIQYLIAUgBjYCtOwFIAggEEkgBCAJS3JFIAZBgAFJcUUEQAJAAkAgBSgCkOsBIgYEQCAPIAZBuOwFa00NAQwKCyAFKAK46wEgDkEYaiAoQQhqIgYoAgA2AgAgDiAoKQIANwMQIA5BEGoQiy0gBUEANgLM6wEgBUEANgK86wEgDkEIaiAGKAIANgIAIA4gKCkCADcDACAFIA8gDhDZLiIGNgK46wEgBkUNCQwBCyAFKAK46wEhBgsgBSAENgLM6wEgBSAQNgK86wEgBSAGIBBqNgLI6wELIAVBAjYCtOsBCyAFIBggB2siBBCoKCIGRQRAIAVBADYCtOsBQQEhCCAHIQQMBwsgBCAGTwRAIAYgB2ohBEEAIQggBSAOQRxqIBsgByAGEJkXIgZBiX9JDQcMCQtBASEIIAcgGCIERg0GIAVBAzYCtOsBCyAFKAK86QEiCSAFKALA6wEiCGshDwJAIAUoAoTqAUEHRwRAIAUoArzrASAIayAPSQRAQWwhBgwKCyAPIBggB2siBCAEIA9LGyIGRQ0EIAYEQCAFKAK46wEgCGogByAG/AoAAAsgBSgCwOsBIQgMAQsgDyAYIAdrIgQgBCAPSxsiBkUNAwsgBSAGIAhqNgLA6wEgBiAHagwDCyApIBsgDigCHCIIayIPIAUoAtTrASAFKALQ6wEiBGsiBiAGIA9LGyIQBH8gEARAIAggBSgCyOsBIARqIBD8CgAACyAFKALQ6wEFIAQLIBBqIgk2AgAgDiAIIBBqQQAgCBs2AhxBASEIIAchBCAGIA9LDQQgBUECNgK06wFBACEIIAUpA8DpASAFKALM6wEiBq1YDQQgBSgC0OkBIAlqIAZNDQQgBUIANwPQ6wEMBAsgEyAHIBMoAgBrNgIIIBdBCGogDigCHCIGIBcoAgBrIgQ2AgAgJEEIaiAENgIAICQgFykCADcCAAJAIAcgFkcgBiAuR3JFBEAgBSAFKALg6wEiBEEBajYC4OsBIARBD0gNASAjICdGBEBBsH8hBgwICyAhICJHDQFBrn8hBgwHCyAFQQA2AuDrAQsgBSgCvOkBIgRFBEAgBSgC3OsBIQQCQAJAIAUoAtTrASAFKALQ6wFGBEBBACEGIARFDQkgEygCCCIEIBMoAgRPBEAgBUECNgK06wEMAgsgEyAEQQFqNgIIDAkLIARFDQELQQEhBgwHC0EBIQYgBUEBNgLc6wEgEyATKAIIQQFrNgIIDAYLIAQgBSgCwOsBa0EDQQAgBSgChOoBQQJrIgRBBU0EfyAEQQJ0QeC10QBqKAIABUEAC0ECRhtqIQYMBQtBACEGIAcLIQRBASEIIAYgD0kNAUEAIQggBUEANgLA6wEgBSAOQRxqIBsgBSgCuOsBIAkQmRciBkGJf0kNAQwDCwtBQCEGDAELQbp/IQYLIA5BIGokACARQQhqIAYQ3i8gESgCDCEIIBEoAgghByAtEIotIBEoAhwiBiARKAIQIgQoAgRLBEBB/OLQAEEsQajj0AAQnykACyAKQRhqIQkgBCAGNgIIICBBCGoiBCAINgIEIAQgBzYCACARQTBqJAAgICgCDCEEAkAgICgCCEEBcQRAIAkgBBDiGgwBCyAJQQQ6AAAgCSAENgIECyAgQRBqJAAgCi0AGEEERgRAIAooAhwhDAwCCyAKKQMYIi9C/wGDQgRSDQAgL0IgiKchDAwBCyAAIC83AgAMAgsCQCAMDQAgAUEBOgAiIAEtACFFDQAgAUECOgAgCyAKKAIoIgcgCigCJEsNAiABIAEoAgwiBiABKAIIIAooAhRqIgQgBCAGSxs2AghBACEGIAdFDQALIABBBDoAACAAIAc2AgQLIApBMGokAA8LQbji0ABBMUHs4tAAEJ8pAAvhBgELfyMAQSBrIggkAAJAAkAgACgCACIJQQhqIgAgCSgCCEECRkECdGoiBy0AIEEDRwRAIAcoAhAhCiAHKAIMIQwgBigCCCIHIAYoAgBGBEAgBkHwvc8AEJsoCyAGKAIEIAdBA3RqIgsgCjYCBCALIAw2AgAgBiAHQQFqIgc2AggCQAJAAkACQCAAIAAoAgAiCkECRkECdGotACBBAWsOAwIBAAMLQZ+6zwBBK0HMus8AEJ8pAAsgAkEBaiECCyADQQFqIQMLAkAgCkECRgRAIAkoAjgiB0UNASAJKAI0IQAgB0ECdCEJA0AgACABIAIgAyAEIAUgBhDTCiAGKAIIIgcEQCAGIAdBAWs2AggLIABBBGohACAJQQRrIgkNAAsMAQsgCEEANgIMIAhCgICAgMAANwIEIAYoAgQhACMAQRBrIgokACAIQQRqIgYgACAHQQN0aiILIABrQQN2EIIuIAogBikCBEIgiTcCCCAKIAZBCGo2AgQjAEEQayIGJAAgCkEEaiIHKAIEIQwgBygCACEQAkACQCAAIAtHBEAgBygCCCAMQQxsaiEHIAsgAGtBA3YhDQNAIAAoAgAhESAGQQRqIABBBGooAgAiC0EAQQFBARCgGCAGKAIIIQ4gBigCBEEBRg0CIAYoAgwhDyALBEAgDyARIAv8CgAACyAHQQhqIAs2AgAgB0EEaiAPNgIAIAcgDjYCACAAQQhqIQAgB0EMaiEHIAxBAWohDCANQQFrIg0NAAsLIBAgDDYCACAGQRBqJAAMAQsgDiAGKAIMQfSOzwAQ/S8ACyAKQRBqJAAgCSAJKAIAIgBBAWo2AgAgAEEASA0CIAhBGGoiBiAIQQxqKAIANgIAIAggCCkCBDcDEEEcQQQQrTYiAEUNAyAAQoGAgIAQNwIAIAAgCCkDEDcCCCAAIAI7ARogACADOwEYIAAgCTYCFCAAQRBqIAYoAgA2AgAgBCgCCCICIAQoAgBGBEAgBEGQvs8AEJ0oCyAEKAIEIAJBAnRqIAA2AgAgBCACQQFqNgIIIAUoAggiACAFKAIARgRAIAVBoL7PABCdKAsgBSgCBCAAQQJ0aiABNgIAIAUgAEEBajYCCAsgCEEgaiQADwtBqL3PAEE2QeC9zwAQnykLAAtBBEEcEKM9AAvtCgISfwN+IwBBIGsiCyQAIAsgAzcDGCALIAI3AxAgAUEQaiIGIAtBEGoQsAwhAyABKAIIRQRAIAtBCGohDiMAQdAAayIFJAAgBSAGNgIcIAEoAgwhDSAFIAVBHGo2AiACQAJAIA0gDUEBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAn8gB0EBaiIHIAYgBiAHSRsiBkEPTwRAIAZB/////wFLDQVBfyAGQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBkEISRsgBkEESRsLIQYgBUFAayABQRBqIghBIEEQIAYQnRQgBSgCRCEHIAUoAkAiCUUEQCAFKAJIIQYMBQsgBSkCSCECIAdBCWoiBgRAIAlB/wEgBvwLAAsgBSACQiCIPgI8IAUgAqciEDYCOCAFIAc2AjQgBSAJNgIwIAVCoICAgIACNwIoIAUgCDYCJCAFQTBqIREgBSANBH8gCUEIaiESIAEoAgAiDykDAEJ/hUKAgYKEiJCgwIB/gyECQQAhBgNAIAJQBEADQCAGQQhqIQYgD0EIaiIPKQMAQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAJIAcgBSgCHCABKAIAIAJ6p0EDdiAGaiITQQV0a0EgaxCwDKciFHEiCGopAABCgIGChIiQoMCAf4MiF1AEQEEIIQoDQCAIIApqIQggCkEIaiEKIAkgByAIcSIIaikAAEKAgYKEiJCgwIB/gyIXUA0ACwsgAkIBfSACgyECIAkgF3qnQQN2IAhqIAdxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogFEEZdiIKOgAAIBIgCEEIayAHcWogCjoAACAJIAhBf3NBBXRqIgggASgCACATQX9zQQV0aiIKKQAANwAAIAhBGGogCkEYaikAADcAACAIQRBqIApBEGopAAA3AAAgCEEIaiAKQQhqKQAANwAAIA1BAWsiDQ0ACyABKAIMBUEACyIGNgI8IAUgECAGazYCOCABIBFBBBD6KiAFQSRqENAmDAELIAEgBUEgakGg2oABQSAQxwkLQYGAgIB4IQcMAgsQ4ycgBSgCDCEGIAUoAgghBwwBCxDjJyAFKAIUIQYgBSgCECEHCyAOIAY2AgQgDiAHNgIAIAVB0ABqJAALIAEoAgQiBiADp3EhBSADQhmIIhhC/wCDQoGChIiQoMCAAX4hGSABKAIAIQcDQAJ/AkACQAJAIAUgB2opAAAiFyAZhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiA1BFBEADQCALQRBqQRAgASgCACADeqdBA3YgBWogBnEiCUEFdGtBIGtBEBCfOw0CIANCAX0gA4MiA1BFDQALCyAXQoCBgoSIkKDAgH+DIQIgFUUEQCACUA0DIAJ6p0EDdiAFaiAGcSEMC0EBIAIgF0IBhoNQDQMaQQAhBSAHIAxqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQwLIAEoAgAiBiAMaiIHLQAAIQkgCykDECECIAspAxghAyAHIBinQf8AcSIHOgAAIAYgASgCBCAMQQhrcWpBCGogBzoAACABIAEoAgxBAWo2AgwgBiAMQQV0ayIGQSBrIgcgAzcDCCAHIAI3AwAgASABKAIIIAlBAXFrNgIIIAZBEGsgBDYCAAwBCyABKAIAQQAgCWtBBXRqQRBrIgUoAgAhASAFIAQ2AgBBASEFCyAAIAE2AgQgACAFNgIAIAtBIGokAA8LQQALIRUgBSAWQQhqIhZqIAZxIQUMAAsAC9MEAQh/IwBBEGsiBCQAAkACQAJAAkACQAJAAkAgASgCIARAAkAgASgCMCIHIAMgAyAHSxsiB0EMbCIIIAEoAiggASgCNCIFa00EQCAEIAFBIGogBSAFIAhqENIQIAEgASgCNCAIajYCNCAEKAIIIQYgBCgCBCEJAkAgB0UNACADQQxsIQpBACEDIAchCANAIAMgCkYNASADQXxGDQYgA0EEaiIFIAZLDQcgBSADQQhqIgVLDQggBSAGSw0JIAUgA0EMaiIFSw0KIAUgBksNCyADIAlqIgMoAAAhCyACIANBBGooAAA2AgQgAiALNgIAIAIgA0EIaigAADYCCCAFIQMgAkEMaiECIAhBAWsiCA0ACwsgASABKAIwIAdrNgIwIAAgBzYCBCAAQQg2AgAgBEEMaiAJIAYgBCgCACgCEBEBAAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNAiAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGU/swAEMskAAsgAiAEKAIIQdT9zAAQ/S8AC0F8QQBBpP7MABCxOwALIANBBGogBkGk/swAELA7AAsgA0EEaiADQQhqQbT+zAAQsTsACyADQQhqIAZBtP7MABCwOwALIANBCGogA0EMakHE/swAELE7AAsgA0EMaiAGQcT+zAAQsDsAC9MEAQh/IwBBEGsiBCQAAkACQAJAAkACQAJAAkAgASgCIARAAkAgASgCMCIHIAMgAyAHSxsiB0EMbCIIIAEoAiggASgCNCIFa00EQCAEIAFBIGogBSAFIAhqENIQIAEgASgCNCAIajYCNCAEKAIIIQYgBCgCBCEJAkAgB0UNACADQQxsIQpBACEDIAchCANAIAMgCkYNASADQXxGDQYgA0EEaiIFIAZLDQcgBSADQQhqIgVLDQggBSAGSw0JIAUgA0EMaiIFSw0KIAUgBksNCyADIAlqIgMoAAAhCyACIANBBGooAAA2AgQgAiALNgIAIAIgA0EIaigAADYCCCAFIQMgAkEMaiECIAhBAWsiCA0ACwsgASABKAIwIAdrNgIwIAAgBzYCBCAAQQg2AgAgBEEMaiAJIAYgBCgCACgCEBEBAAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNAiAEKAIIIgFBGGpB8KjOAC8AADsAACABQRBqQeiozgApAAA3AAAgAUEIakHgqM4AKQAANwAAIAFB2KjOACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQfinzgBBIEGYqM4AEMskAAsgAiAEKAIIQdinzgAQ/S8AC0F8QQBBqKjOABCxOwALIANBBGogBkGoqM4AELA7AAsgA0EEaiADQQhqQbiozgAQsTsACyADQQhqIAZBuKjOABCwOwALIANBCGogA0EMakHIqM4AELE7AAsgA0EMaiAGQciozgAQsDsAC+QDAQZ/IAEgBE0gASADS3JFBEAgAiABQQN0aiEGIAAgBEEDdGohCCAAIQMDQCAAIARBA2siCUEAIAQgCU8bQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayADKAIAIAgoAgBJIgcbaiADKQIANwIAIAUgB2oiBUEDdCACIAZBEGsgA0EIaiIHKAIAIAgoAgBJIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBGGsgA0EQaiIHKAIAIAgoAgBJIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBIGsiBiADQRhqIgcoAgAgCCgCAEkiChtqIAcpAgA3AgAgBSAKaiEFIANBIGoiAyAJSQ0ACwsgACAEQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayIGIAMoAgAgCCgCAEkiBxtqIAMpAgA3AgAgBSAHaiEFIANBCGoiAyAJSQ0ACwsgASAERwRAIAZBCGsiBiAFQQN0aiADKQIANwIAIANBCGohAyABIQQMAQsLIAVBA3QiAwRAIAAgAiAD/AoAAAsgASAFRwRAIAEgBWshBCAAIAVBA3RqIQMgAUEDdCACakEIayEGA0AgAyAGKQIANwIAIAZBCGshBiADQQhqIQMgBEEBayIEDQALCyAFDwsAC/ADAQZ/IAEgBE0gASADS3JFBEAgAiABQQN0aiEGIAAgBEEDdGohCCAAIQMDQCAAIARBA2siCUEAIAQgCU8bQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayAIKAIAIAMoAgBPIgcbaiADKQIANwIAIAUgB2oiBUEDdCACIAZBEGsgCCgCACADQQhqIgcoAgBPIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBGGsgCCgCACADQRBqIgcoAgBPIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBIGsiBiAIKAIAIANBGGoiBygCAE8iChtqIAcpAgA3AgAgBSAKaiEFIANBIGoiAyAJSQ0ACwsgACAEQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayIGIAgoAgAgAygCAE8iBxtqIAMpAgA3AgAgBSAHaiEFIANBCGoiAyAJSQ0ACwsgASAERwRAIAVBA3QgAiAGQQhrIgZBARtqIAMpAgA3AgAgA0EIaiEDIAVBAWohBSABIQQMAQsLIAVBA3QiAwRAIAAgAiAD/AoAAAsgASAFRwRAIAEgBWshBCAAIAVBA3RqIQMgAUEDdCACakEIayEGA0AgAyAGKQIANwIAIAZBCGshBiADQQhqIQMgBEEBayIEDQALCyAFDwsAC7IEAgt/A34jAEFAaiICJAAgASAAKAI4IAAoAjwQuwkgAkH/AToAGCABIAJBGGoiBUEBELsJIABBKGogARCTCSACIAAtAEA6ABggASAFQQEQuwkgBSAAEPgoIAJBDGogBUHUgoQBEMoSIAIoAhAhAwJAIAIoAhQiBEECSQ0AIARBFU8EQCADIAQgBRDJGwwBCyADIAQQlScLIAIgAigCDDYCICACIAM2AhwgAiADNgIYIAIgAyAEQQJ0aiIINgIkIAQEQCAAQRBqIQkgACgCACIGQRhrIQogACgCBCEEIAAoAgwhCwNAIAIgA0EEaiIANgIcIAEgAygCACIFKAIEIAUoAggQuwkgAkH/AToAPyABIAJBP2pBARC7CQJAAkAgC0UNACAEIAkgBRD4CyINp3EhAyANQhmIQv8Ag0KBgoSIkKDAgAF+IQ9BACEHA0AgAyAGaikAACIOIA+FIg1Cf4UgDUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyINUEUEQANAIAUgCiANeqdBA3YgA2ogBHFBaGwiDGoQjDUNBCANQgF9IA2DIg1QRQ0ACwsgDiAOQgGGg0KAgYKEiJCgwIB/g1BFDQEgAyAHQQhqIgdqIARxIQMMAAsAC0HkgoQBQQlB8IKEARDLJAALIAEgBiAMaiIDQQhrKAIAIANBBGsoAgAQuwkgAkH/AToAPyABIAJBP2pBARC7CSAAIgMgCEcNAAsLIAJBGGoQ3isgAkFAayQAC8YHAQt/IwBBMGsiBSQAIAUgATYCDAJAAkACQAJAAkAgAy0ABiIKBEACQCACKAIUIg0gCnBFBEAgBUEYaiACQQhqKAIAIgc2AgAgBSACKQIANwMQIAVBHGohCyAFQQxqIQYgB0EEQQggAy0ABBsiBGoiDiAKQQFrQf8BcSIIaiAIQX9zcSIIIARrIQwjAEEwayIEJAACQAJAAkACQAJAIAMvAQIiCQ4FAQEBAgMACyAEIAk7AQ4gBEEBNgIUIARBpL7MADYCECAEQgE3AhwgBEH4AjYCLCAEIARBKGo2AhggBCAEQQ5qNgIoIARBEGpBrL7MABDvLAALIARBADYCICAEQQE2AhQgBEHkvcwANgIQIARCBDcCGCAEQRBqQey9zAAQ7ywACyAGKAIAIQlBCCEGIAMtAARFBEAgCSgCAEH8vcwAQQQQoTZBBCEGCyAEIAw2AhAgCSgCACAEQRBqQQQQoTYMAQsgBigCACIDKAIAQfy9zABBBBChNiAEIAw2AhAgAygCACAEQRBqQQQQoTZBCCEGCyALQZOAgIB4NgIAIAsgBjYCBCAEQTBqJAAgBSgCHCIEQZOAgIB4Rg0BIAAgBSkCJDcCCCAAQRBqIAVBLGooAgA2AgAgBSgCICEDDAULIAVBHGpBFkEAQQFBARCgGCAFKAIgIQMgBSgCHEEBRg0CIAUoAiQiAUEOakHqvMwAKQAANwAAIAFBCGpB5LzMACkAADcAACABQdy8zAApAAA3AAAgAEEWNgIMIAAgATYCCCAAIAM2AgQgAEGDgICAeDYCACACEN47DAYLIAggDmshAyAHRQ0CIAEoAgAgBSgCFCAHEKE2DAILQfy7zAAQ5ysACyADIAUoAiRB7LvMABD9LwALIANBwQBPBEAgA0HAAEHMvMwAELA7AAsgASgCAEGMvMwAIAMQoTYgDUUEQEEAIQMMAgsgBUEcaiEDIAVBDGooAgAiBygCACACKAIQIAIoAhQiARChNgJAAkAgASABIApBAWtB/wFxIgRqIARBf3NxIgRHBEAgBCABayIBQcEATw0BIAcoAgBBjLzMACABEKE2CyADQZOAgIB4NgIAIAMgBDYCBAwBCyABQcAAQfS8zAAQsDsACyAFKAIgIQMgBSgCHCIEQZOAgIB4Rg0BIAAgBSkCJDcCCCAAQRBqIAVBLGooAgA2AgALIAAgAzYCBCAAIAQ2AgAgBUEQahDeOwwBCyAAIAM2AgggACAINgIEIABBk4CAgHg2AgAgBUEQahDeOwsgAkEMahDeOyAFQTBqJAALugQCCX8BfiMAQSBrIgYkAAJAIANFBEAMAQsgAUEQaiEJA0AgAyAEayEKIAIgBEEDdGohCwJAAkAgASgCNCIMDQAgASgCOCEHAkACQAJAAkADQCAHRQRAIAkoAgBFDQIgBiAJEKUYIAYoAgBBAUcNCSAGKQMIIg1QDQkgDUIBg1BFBEAgASANp0ECdEF4cTYCOAwICyABIA1CAYg+AjQgBkEQaiAJIAEtADwiBUEDdiAFQQdxQQBHahDBHCAGKQMQIQ0gASAGKQMYNwMIIAEgDTcDACANpw0HQcD6zABBLkHw+swAEJ8pAAsgCSgCAEUNAiAHIAogByAKSRsiBSAEaiIIIAVJDQMgAyAISQ0EIAkgCyAFIAEtADwQkAQiBUUEQEEAIQcgAUEANgI4IAEoAjQiDEUNAQwGCwsgASABKAI4IAVrNgI4IAQgBWohBAwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBCAIQcT4zAAQsTsACyAIIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgDCAKIAogDEsbIgggBGoiBSAITwRAIAMgBUkNASADIARHBEAgASkDCCENIAhBA3QhBwNAIAsgDTcDACALQQhqIQsgB0EIayIHDQALCyABIAwgCGs2AjQgBSEEDAILIAQgBUHk+MwAELE7AAsgBSADQeT4zAAQsDsACyADIARLDQALCyAAQQg2AgAgACAENgIEIAZBIGokAAu6BAIJfwF+IwBBIGsiBiQAAkAgA0UEQAwBCyABQRBqIQkDQCADIARrIQogAiAEQQJ0aiELAkACQCABKAI0IgwNACABKAI4IQcCQAJAAkACQANAIAdFBEAgCSgCAEUNAiAGIAkQpRggBigCAEEBRw0JIAYpAwgiDVANCSANQgGDUEUEQCABIA2nQQJ0QXhxNgI4DAgLIAEgDUIBiD4CNCAGQRBqIAkgAS0APCIFQQN2IAVBB3FBAEdqEMEcIAYpAxAhDSABIAYpAxg3AwggASANNwMAIA2nDQdBwPrMAEEuQfD6zAAQnykACyAJKAIARQ0CIAcgCiAHIApJGyIFIARqIgggBUkNAyADIAhJDQQgCSALIAUgAS0APBC5BiIFRQRAQQAhByABQQA2AjggASgCNCIMRQ0BDAYLCyABIAEoAjggBWs2AjggBCAFaiEEDAULQZz4zABBGEGw+swAEMskAAtBnPjMAEEYQbT4zAAQyyQACyAEIAhBxPjMABCxOwALIAggA0HE+MwAELA7AAsgASgCAEUEQEHU+MwAELI7AAsCQCAMIAogCiAMSxsiCCAEaiIFIAhPBEAgAyAFSQ0BIAMgBEcEQCABKAIIIQQgCEECdCEHA0AgCyAENgIAIAtBBGohCyAHQQRrIgcNAAsLIAEgDCAIazYCNCAFIQQMAgsgBCAFQeT4zAAQsTsACyAFIANB5PjMABCwOwALIAMgBEsNAAsLIABBCDYCACAAIAQ2AgQgBkEgaiQAC9kEAgN/An4jAEHwAGsiAyQAIAEoAgghBAJAAkAgAAJ/IAEoAgwoAhAgAkEDdGopAwAiBkKAgICACHxC/////w9YBEAgAyAEKAIAKAIAKAIAIgU2AjAgAyAGPgIEAkAgBiAFrH4iB0IgiKcgB6ciBUEfdUcEQCADQQI2AlQgA0GskP8ANgJQIANCAjcCXCADQYIMNgIUIANBggw2AgwgAyADQQhqNgJYIAMgA0EwajYCECADIANBBGo2AgggA0E8aiADQdAAahCZDiADQSBqIANBQGspAgA3AwAgA0EoaiADQcgAaigCADYCACADQYiAgIB4NgI4IAMgAykCOCIHNwMYIAenQZOAgIB4Rw0BIAMoAhwhBQsgA0HQAGogBSAEKAIILQAAEOoPIAMoAlAiBEGTgICAeEYNAyADQRBqIANB4ABqKAIANgIAIAMgAykCWDcDCCADKAJUDAILIANBGGoQiBELIAQoAgQhASADIAY3AzAgA0HMkf8ANgI4IANCBDcCRCADQYYMNgJsIANB9As2AmQgAyABQQFqNgJgIANBuwc2AlwgAyABNgJYIANBzAE2AlQgA0H4kf8ANgJQIAMgA0HQAGo2AkAgAyADQTBqNgJoIANBBDYCPCADQRxqIANBOGoQmQ4gA0EQaiADQShqKAIANgIAIAMgAykCIDcDCEGCgICAeCEEIAMoAhwLNgIEIAAgBDYCACAAIAMpAwg3AgggAEEQaiADQRBqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQJ0aiAFNgIACyADQfAAaiQAC7MEAQR/IwBBsAFrIgckACAHIAI2AmAgB0EIaiADQcAA/AoAACAHQewAaiAGQQhqKAIANgIAIAdB0ABqIARBCGoiCSgCADYCACAHQdwAaiAFQQhqKAIANgIAIAcgBikCADcCZCAHIAQpAgA3A0ggByAFKQIANwJUIAEoAgAiAygCCCIIIAMoAgBGBEAgA0Hkv8MAEJAoCyADKAIEIAhBDGxqIgogBCkCADcCACAKQQhqIAkoAgA2AgAgAyAIQQFqNgIIIAEoAgQiBCgCCCIIIAQoAgBGBEAgBEH0v8MAEJAoCyAEKAIEIAhBDGxqIgkgBSkCADcCACAJQQhqIAVBCGooAgA2AgAgBCAIQQFqNgIIIAEoAggiBCgCCCIFIAQoAgBGBEAgBEGEwMMAEJAoCyAEKAIEIAVBDGxqIgggBikCADcCACAIQQhqIAZBCGooAgA2AgAgBCAFQQFqNgIIAkACQCABLQAQQQFGDQAgB0HwAGogAiADKAIEIAMoAgggB0EIaiIDEIAHIAcoAnAiAkEIRg0AIAAgBykCdDcCBCAAQRRqIAdBhAFqKAIANgIAIABBDGogB0H8AGopAgA3AgAgACACNgIAIAMQ/yUMAQsgASgCDCEBIAdB8ABqIAdBCGpBwAD8CgAAIAEoAggiAiABKAIARgRAIAFBlMDDABCcKAsgASgCBCACQQZ0aiAHQfAAakHAAPwKAAAgASACQQFqNgIIIABBCDYCAAsgB0GwAWokAAuzBAEEfyMAQbABayIHJAAgByACNgJgIAdBCGogA0HAAPwKAAAgB0HsAGogBkEIaigCADYCACAHQdAAaiAEQQhqIgkoAgA2AgAgB0HcAGogBUEIaigCADYCACAHIAYpAgA3AmQgByAEKQIANwNIIAcgBSkCADcCVCABKAIAIgMoAggiCCADKAIARgRAIANB5L/DABCQKAsgAygCBCAIQQxsaiIKIAQpAgA3AgAgCkEIaiAJKAIANgIAIAMgCEEBajYCCCABKAIEIgQoAggiCCAEKAIARgRAIARB9L/DABCQKAsgBCgCBCAIQQxsaiIJIAUpAgA3AgAgCUEIaiAFQQhqKAIANgIAIAQgCEEBajYCCCABKAIIIgQoAggiBSAEKAIARgRAIARBhMDDABCQKAsgBCgCBCAFQQxsaiIIIAYpAgA3AgAgCEEIaiAGQQhqKAIANgIAIAQgBUEBajYCCAJAAkAgAS0AEEEBRg0AIAdB8ABqIAIgAygCBCADKAIIIAdBCGoiAxCBByAHKAJwIgJBCEYNACAAIAcpAnQ3AgQgAEEUaiAHQYQBaigCADYCACAAQQxqIAdB/ABqKQIANwIAIAAgAjYCACADEP8lDAELIAEoAgwhASAHQfAAaiAHQQhqQcAA/AoAACABKAIIIgIgASgCAEYEQCABQZTAwwAQnCgLIAEoAgQgAkEGdGogB0HwAGpBwAD8CgAAIAEgAkEBajYCCCAAQQg2AgALIAdBsAFqJAALqgQBBX8gACgCACAAKAIIakFwIAIgA2siBEEEdCAEQQ9PGzoAACAAIAAoAghBAWo2AgggBEEOSwRAIARBD2siBUH8B08EQCAAKAIAIQcgBUH8B24iCEECdCIGBEAgByAAKAIIakH/ASAG/AsACyAAIAAoAgggBmo2AgggBSAIQfwHbGshBQsgACgCACAAKAIIakF/NgAAIAAgBUH//wNxQf8BbiIGIAAoAghqQQFqNgIIIAAoAgAgACgCCGpBAWsgBSAGajoAAAsCQAJAIAIgA08EQCAAKAIIIgYgBGoiBSAGSQ0BIAUgACgCBCIHSw0CAkAgAiADRg0AIAEgA2ohASAAKAIAIAZqIQICQAJAAkAgBEEETwRAIARBCEkNASAEQRFJDQIgBEEhSQ0DIARFDQQgAiABIAT8CgAADAQLIAIgAS0AADoAACAEQQFGDQMgAiABLwAAOwAAIAIgBEECayIDaiABIANqLwAAOwAADAMLIAIgASgAADYAACACIARBBGsiA2ogASADaigAADYAAAwCCyACIAEpAAA3AAAgAiAEQQhrIgNqIAEgA2opAAA3AAAMAQsgAiABKQAANwAAIAJBCGogAUEIaikAADcAACACIARBEGsiA2oiAiABIANqIgEpAAA3AAAgAkEIaiABQQhqKQAANwAACyAAIAU2AggPCyADIAJBxPbOABCvOwALIAYgBUGM8s4AELE7AAsgBSAHQYzyzgAQsDsAC5sEAQh/IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCqDgwDCyAAIAFBA3YiBUEcbGohByAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggByAFIAQQphMMAQsgACgCACIGIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAcoAgAiCyAFTw0DIAAgByAIIAwoAgAiBSAGQQJ0aigCACIHIAUgCUECdGooAgAiCEkiBiAIIAUgC0ECdGooAgAiBUlzGyAGIAUgB0tzGwsgAGsiBkECdiEHIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgBmooAgAiBiAFTw0EIAkoAgAiBSAIQQJ0aigCACAFIAZBAnRqKAIASQ0GIAogBDYCDCAAIAEgByAKQQxqEKUfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgBiAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAGIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgByAEEKsfIgUgAiADIAQQ4QogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQghMLIApBEGokAAudBAIIfwN+IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCrDgwDCyAAIAFBA3YiBUEcbGohBiAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggBiAFIAQQpxMMAQsgACgCACIHIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAYoAgAiCyAFTw0DIAAgBiAIIAwoAgAiBSAHQQN0aikDACINIAUgCUEDdGopAwAiDlQiBiAOIAUgC0EDdGopAwAiD1RzGyAGIA0gD1RzGwsgAGsiB0ECdiEGIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgB2ooAgAiByAFTw0EIAkoAgAiBSAIQQN0aikDACAFIAdBA3RqKQMAVA0GIAogBDYCDCAAIAEgBiAKQQxqEKYfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgByAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAHIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgBiAEEKofIgUgAiADIAQQ4gogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQgRMLIApBEGokAAubBAEIfyMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQqg4MAwsgACABQQN2IgVBHGxqIQcgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAcgBSAEEKYTDAELIAAoAgAiBiAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAHKAIAIgsgBU8NAyAAIAcgCCAMKAIAIgUgBkECdGooAgAiByAFIAlBAnRqKAIAIghJIgYgCCAFIAtBAnRqKAIAIgVJcxsgBiAFIAdLcxsLIABrIgZBAnYhByACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAZqKAIAIgYgBU8NBCAJKAIAIgUgCEECdGooAgAgBSAGQQJ0aigCAEkNBiAKIAQ2AgwgACABIAcgCkEMahClHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAYgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgBiAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAcgBBCrHyIFIAIgAyAEEOMKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIITCyAKQRBqJAALmwQBCH8jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKkODAMLIAAgAUEDdiIFQRxsaiEHIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAHIAUgBBClEwwBCyAAKAIAIgYgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBygCACILIAVPDQMgACAHIAggDCgCACIFIAZBAnRqKAIAIgcgBSAJQQJ0aigCACIISCIGIAggBSALQQJ0aigCACIFSHMbIAYgBSAHSnMbCyAAayIGQQJ2IQcgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAGaigCACIGIAVPDQQgCSgCACIFIAhBAnRqKAIAIAUgBkECdGooAgBIDQYgCiAENgIMIAAgASAHIApBDGoQqR8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAGIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAYgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAHIAQQpx8iBSACIAMgBBDkCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBD/EgsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKwODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCkEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOUyIGIA4gBSALQQN0aikDACIPU3MbIAYgDSAPU3MbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBTDQYgCiAENgIMIAAgASAGIApBDGoQqB8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQpB8iBSACIAMgBBDlCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCAEwsgCkEQaiQAC5sEAQh/IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCpDgwDCyAAIAFBA3YiBUEcbGohByAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggByAFIAQQpRMMAQsgACgCACIGIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAcoAgAiCyAFTw0DIAAgByAIIAwoAgAiBSAGQQJ0aigCACIHIAUgCUECdGooAgAiCEgiBiAIIAUgC0ECdGooAgAiBUhzGyAGIAUgB0pzGwsgAGsiBkECdiEHIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgBmooAgAiBiAFTw0EIAkoAgAiBSAIQQJ0aigCACAFIAZBAnRqKAIASA0GIAogBDYCDCAAIAEgByAKQQxqEKkfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgBiAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAGIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgByAEEKcfIgUgAiADIAQQ5gogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQ/xILIApBEGokAAubBAEIfyMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQqg4MAwsgACABQQN2IgVBHGxqIQcgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAcgBSAEEKYTDAELIAAoAgAiBiAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAHKAIAIgsgBU8NAyAAIAcgCCAMKAIAIgUgBkECdGooAgAiByAFIAlBAnRqKAIAIghJIgYgCCAFIAtBAnRqKAIAIgVJcxsgBiAFIAdLcxsLIABrIgZBAnYhByACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAZqKAIAIgYgBU8NBCAJKAIAIgUgCEECdGooAgAgBSAGQQJ0aigCAEkNBiAKIAQ2AgwgACABIAcgCkEMahClHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAYgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgBiAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAcgBBCrHyIFIAIgAyAEEOcKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIITCyAKQRBqJAALnQQCCH8DfiMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQrA4MAwsgACABQQN2IgVBHGxqIQYgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAYgBSAEEKQTDAELIAAoAgAiByAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAGKAIAIgsgBU8NAyAAIAYgCCAMKAIAIgUgB0EDdGopAwAiDSAFIAlBA3RqKQMAIg5TIgYgDiAFIAtBA3RqKQMAIg9TcxsgBiANIA9TcxsLIABrIgdBAnYhBiACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAdqKAIAIgcgBU8NBCAJKAIAIgUgCEEDdGopAwAgBSAHQQN0aikDAFMNBiAKIAQ2AgwgACABIAYgCkEMahCoHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAcgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgByAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAYgBBCkHyIFIAIgAyAEEOgKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIATCyAKQRBqJAALmwQBCH8jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKkODAMLIAAgAUEDdiIFQRxsaiEHIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAHIAUgBBClEwwBCyAAKAIAIgYgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBygCACILIAVPDQMgACAHIAggDCgCACIFIAZBAnRqKAIAIgcgBSAJQQJ0aigCACIISCIGIAggBSALQQJ0aigCACIFSHMbIAYgBSAHSnMbCyAAayIGQQJ2IQcgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAGaigCACIGIAVPDQQgCSgCACIFIAhBAnRqKAIAIAUgBkECdGooAgBIDQYgCiAENgIMIAAgASAHIApBDGoQqR8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAGIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAYgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAHIAQQpx8iBSACIAMgBBDpCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBD/EgsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKsODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCnEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOVCIGIA4gBSALQQN0aikDACIPVHMbIAYgDSAPVHMbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBUDQYgCiAENgIMIAAgASAGIApBDGoQph8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQqh8iBSACIAMgBBDqCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCBEwsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKwODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCkEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOUyIGIA4gBSALQQN0aikDACIPU3MbIAYgDSAPU3MbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBTDQYgCiAENgIMIAAgASAGIApBDGoQqB8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQpB8iBSACIAMgBBDrCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCAEwsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKsODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCnEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOVCIGIA4gBSALQQN0aikDACIPVHMbIAYgDSAPVHMbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBUDQYgCiAENgIMIAAgASAGIApBDGoQph8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQqh8iBSACIAMgBBDsCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCBEwsgCkEQaiQAC+wCAQF/IwBBMGsiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCACACIABBA3YiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkEDdGopAgA3AgQgBCAEQQhqNgIgIANBkI6EAUEPQZ+OhAFBBCAEQQRqQfCNhAFBo46EAUEMIARBIGpBgI6EARCOGCAEQTBqJAAPCyAEIAA2AhwgBEECNgIIIARBuJeEATYCBCAEQgI3AhAgBEE7NgIsIARBOzYCJCAEIARBIGo2AgwgBCAEQRxqNgIoIAQgBDYCICAEQQRqQciXhAEQ7ywAC5oEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBSABKAIgIgRBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgVFDQQLIAJCADcCRCACIAU2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAEEOcQCyAEBEAgASgCHCEFQQAhAQNAAkAgASAFaiwAACIDIAIoAjBPDQAgAigCJCACKAIsIANqIgNBA3ZqLQAAIANBB3F2QQFxDQAgAiACQThqEIY9IAFBA3YiAyACKAIEIgZJBEAgAigCACADaiIDIAMtAABBfiABQQdxd3E6AAAMAQsgAyAGQdTmhAEQwyEACyAEIAFBAWoiAUcNAAsLIAJBzABqIgEgAkE4aiIEEIcUIAAgARDhJyAEEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC5oEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBSABKAIgIgRBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgVFDQQLIAJCADcCRCACIAU2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAEEOcQCyAEBEAgASgCHCEFQQAhAQNAAkAgASAFai0AACIDIAIoAjBPDQAgAigCJCACKAIsIANqIgNBA3ZqLQAAIANBB3F2QQFxDQAgAiACQThqEIY9IAFBA3YiAyACKAIEIgZJBEAgAigCACADaiIDIAMtAABBfiABQQdxd3E6AAAMAQsgAyAGQdTmhAEQwyEACyAEIAFBAWoiAUcNAAsLIAJBzABqIgEgAkE4aiIEEIcUIAAgARDhJyAEEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC9sEAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg4NAQIDBAUGBwgJCgsMDQALIAAgA60gBK1CIIaENwMIIAAgAq0gATUAAEIghoQ3AwAPCyAAQgA3AwAgAEEIakIANwMADwsgAEIANwAFIABBATYCACAAQQxqQQA2AAAgACABLQAAOgAEDwsgAEIANwEGIABBAjYCACAAQQ5qQQA7AQAgACABLwAAOwEEDwsgAEIANwAHIABBAzYCACAAQQ9qQQA6AAAgACABLwAAOwAEIABBBmogAUECai0AADoAAA8LIABCADcDCCAAQQQ2AgAgACABKAAANgIEDwsgAEEANgAJIABBBTYCACAAQQxqQQA2AAAgACABKAAANgAEIABBCGogAUEEai0AADoAAA8LIABBADYBCiAAQQY2AgAgAEEOakEAOwEAIAAgASgAADYABCAAQQhqIAFBBGovAAA7AAAPCyAAQQA2AAsgAEEHNgIAIABBD2pBADoAACAAIAEoAAA2AAQgAEEHaiABQQNqKAAANgAADwsgAEEANgIMIABBCDYCACAAIAEpAAA3AgQPCyAAQQA7AA0gAEEJNgIAIABBD2pBADoAACAAIAEpAAA3AAQgAEEMaiABQQhqLQAAOgAADwsgAEEAOwEOIABBCjYCACAAIAEpAAA3AAQgAEEMaiABQQhqLwAAOwAADwsgAEEAOgAPIABBCzYCACAAIAEpAAA3AAQgAEELaiABQQdqKAAANgAADwsgAEEMNgIAIAAgASkAADcABCAAQQxqIAFBCGooAAA2AAALsAQCBH4QfwJAAkAgACgCOCAAKAI8IAEoAjggASgCPBDBLkUNACAAQShqIAFBKGoQwQ5FDQAgAC0AQSABLQBBRw0AIAAtAEBFBEAgAS0AQA0BCyAAQRBqIQ4gACgCACIMQRhrIQ8gASgCACIHQQhqIQogBykDAEJ/hUKAgYKEiJCgwIB/gyECIAAoAgQhCyAAKAIMIRAgASgCDCEBA0AgAUUhACABRQ0CIAJQBEADQCAHQcABayEHIAopAwAgCkEIaiEKQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAQRQ0CIAFBAWshASACQgF9IAKDIAcgAnqnQQN2QWhsaiIIQRBrIREgCEEUayESIAsgDiAIQRhrEPgLIgKncSEJIAJCGYhC/wCDQoGChIiQoMCAAX4hBUEAIQ0DQAJAIAkgDGopAAAiAyAFhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEAgESgCACEGIBIoAgAhEwNAIBMgBiAPIAJ6p0EDdiAJaiALcUFobCIUaiIVKAIEIBUoAggQwS4NAiACQgF9IAKDIgJQRQ0ACwtBACEGIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0DIAkgDUEIaiINaiALcSEJDAELCyECIAAhBiAIQQhrKAIAIAhBBGsoAgAgDCAUaiIAQQhrKAIAIABBBGsoAgAQwS4NAAsLIAYPCyAAC5gGAQx/IwBBIGsiBSQAIAIoAgQhAyABKAIEIQcCQCACKAIIIgYgASgCCCIJTwRAIwBBIGsiASQAIAEgAzYCCCABIAMgBiAJIAYgCUkbIghBAnRqIgo2AgwCQAJAAkACQCABQQhqEJ42IgQgCCAEIAhJGyILBEBBACEEA0AgAyAHKAIAIgwgAygCACINayIOIARrNgIAIAwgDUkgBCAOS3IhBCAHQQRqIQcgA0EEaiEDIAtBAWsiCw0ACyAGIAlJDQEgBA0DDAILIAYgCU8NAQtBkKeIAUEhQbSniAEQnykACyAGQQJ0IAhBAnRrIQMDQCADRQ0CIANBBGshAyAKKAIAIApBBGohCkUNAAsLIAFBADYCGCABQQE2AgwgAUH4pogBNgIIIAFCBDcCECABQQhqQcSniAEQ7ywACyABQSBqJAAMAQsgBSADNgIQIAUgAyAGQQJ0IgFqNgIUIAEgB2ohCgJAIAVBEGoQnjYiASAGIAEgBkkbIgQEQEEAIQEgByEIA0AgAyAIKAIAIgsgAygCACIMayINIAFrNgIAIAsgDEkgASANS3IhASAIQQRqIQggA0EEaiEDIARBAWsiBA0ACyACIAogByAJQQJ0ahCeJCABRQ0CIAIoAggiASAGSQ0BIAIoAgQgBkECdGogASAGa0HEiYgBQQEQzRAMAgsgAiAKIAcgCUECdGoQniQMAQsgBiABQbSJiAEQrzsACyAFQRhqIAJBCGooAgAiBDYCACAFIAIpAgA3AxACQCAERQ0AIAUoAhQiASAEQQJ0IgNqQQRrIgJFDQAgAigCAA0AIAFBBGshAiAEQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAiADaiADQQRrIQMoAgBFDQALIAFBAWoiAyAESw0BCyAFIAM2AhggAyEECwJAIAQgBSgCEEECdk8NACAFQQhqIAVBEGogBEEEQQQQ9BQgBSgCCCIBQYGAgIB4Rg0AIAEgBSgCDEHYiYgBEP0vAAsgACAFKQMQNwIAIABBCGogBUEYaigCADYCACAFQSBqJAALzQYBD38jAEEQayILJAAgAEEANgIQIAEoAhQhEiABKAIYIRMgASgCECEUIAEoAgQgASgCACIKa0EDdSENIAEoAhghDiABKAIUIhchDyABKAIQIhghEANAIA0EQEEfIAooAgBnayEVIApBBmovAQAhESAQAn8gCkEEai8BACIWQcAATwRAQTIgFmdrDAELIBZBgPbQAGotAAALOgAAIA4gFToAACAPIBFBgAFPBH9BwwAgEWdrBSARQcD20ABqLQAACzoAAEEBIAwgFUEYSxshDCAPQQFqIQ8gDkEBaiEOIBBBAWohECAKQQhqIQogDUEBayENDAELCyABKAIkIgpBAUYEfyAYIAEoAihqQSM6AAAgASgCJAUgCgtBAkYEQCAXIAEoAihqQTQ6AAALIAAgDDYCFCALQSM2AgwgCCALQQxqIBQgAiAJQYTEABD5JyEBIAQgAygC3Bs2AtwbIAAgBEHcG2ogCCALKAIMIAEgAkEJIANBsBFqIgFBwPfQAEEGQQEgBxCMDiIKNgIAAkACQAJAIAUgBiAFayAEQbARakEJIAogCCALKAIMIBQgAkHA99AAQQZBIyABQaQKIAkQ3BMiAUGIf00EQCAKQQJGBEAgACABNgIQCyALQR82AgggCCALQQhqIBMgAiAJQYTEABD5JyEKIAQgAygC1Bs2AtQbIAAgBEHUG2ogCCALKAIIIgwgCiACQQggA0GQ+NAAQQUgDEEdSSAHEIwOIgo2AgQgASAFaiIMIAYgDGsgBEEIIAogCCALKAIIIBMgAkGQ+NAAQQVBHCADQYQGIAkQ3BMiAUGIf0sNASAKQQJGBEAgACABNgIQCyALQTQ2AgQgCCALQQRqIBIgAiAJQYTEABD5JyEKIAQgAygC2Bs2AtgbIAAgBEHYG2ogCCALKAIEIAogAkEJIANBhAZqIgpB0PjQAEEGQQEgBxCMDiIDNgIIIAEgDGoiByAGIAdrIARBhAZqQQkgAyAIIAsoAgQgEiACQdD40ABBBkE0IApBrAsgCRDcEyIBQYh/Sw0CIANBAkYEQCAAIAE2AhALIAAgASAHaiAFazYCDAwDCyAAIAE2AgwMAgsgACABNgIMDAELIAAgATYCDAsgC0EQaiQAC4oEAQp/IwBB8AhrIg0kACANQQBBiAj8CwAgDUGICGpBAEHoAPwLAAJAAkACQCAEBEBBASEQA0AgECETAkACQCABIA5HBEAgACAOai0AACEQIA4NAQwCCyABIAFB7OnRABDDIQALIA1BASAQQQJqQQAgDCAQRxsgE0EBaiAQRhtBAnRqIgwgDCgCAEEBajYCAAsgAyAORg0CQRRBDiACIA5BAnRqKAIAIhFB8AVLG0EHQQAgEUEoSxsgEUGwAUsbIg9BAWshDCAPQQN0QeTj0QBqIRIgDUGICGogD0ECdGohFAJAA0AgFCEPIAxBGEYNASAPQQRqIRQgDEEBaiEMIBIoAgAhFSASQQhqIRIgESAVTw0ACyAMQRpPDQQLIA8gDygCAEEBajYCACATIQwgDkEBaiIOIARHDQALCyAFQQFrrSAJIAogCxCVIwJAIAVBAUsEQCANQYICIAVBAmoiBCAEIAYgByAIQcAEakGCAiAIQQhqQYICIAkgCiALEPIIIA1BiAhqQRpBGkEaIAYgByAIQcIGakEaIAhBjARqQRogCSAKIAsQ8gggA0UNBCABRQ0BIAggAigCACAALQAAQQEgCSAKIAsQnhILIA1B8AhqJAAPC0EAQQBB3OnRABDDIQALIAMgA0H86dEAEMMhAAsgDEEaQYzq0QAQwyEAC0EAQQBBzOnRABDDIQAL0wQCBH8CfiMAQfACayIFJAAgASgCoAIiBiAGKAIAIgRBAWo2AgACQCAEQQBIDQAgBUHgAmpBoKXOABClKyAFKQPoAiEIIAUpA+ACIQlBACEEAkACQAJAAkAgBi8BGCIHDgIAAQILIAVCBTcDCAwCCyAGLwEaDQAgBigCFCIEQQhqIAQoAghBAkZBAnRqLQAgIgRBA0cgBEEAR3EhBAsgBUEIaiAHIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDWAwBCyAFQdgAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBIDQAgBUHoAmpBADoAACAFQgA3A+ACQQAiBEUEQCAFQYACaiAFQQhqQdAA/AoAAAsgBEUEQCAFQbABaiAFQdgAakHQAPwKAAALIAVB2AJqQbilzgApAwA3AwAgBUGwpc4AKQMANwPQAiABKQMAQgVSBEAgASgC0AEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAFB0AFqENkhCyABQcgBahC8KiABQdAAahCTKiABEP0uIAEoAsABIgQgBCgCACIEQQFrNgIAIARBAUYEQCABQcABahDZIQsgAUGgAWoQ9iYLIAEgBUGwAWpBsAH8CgAAIAEgBjYC0AEgASADNgLMASABIAI2AsgBIAFBCToAxAEgASAGNgLAASABIAg3A7gBIAEgCTcDsAEgASAFKQPgAjcC1AEgAUHcAWogBUHoAmotAAA6AAAgASAFLwCtATsA3QEgAUHfAWogBUGvAWotAAA6AAAgAEEINgIAIAVB8AJqJAAPCwALxAQCBH8BfiMAQfAAayIDJAAgASgCDCgCECACQQJ0aigCACEFIAMgASgCCCIGKAIAKAIAKAIAIgQ2AjQgAyAFNgIMAkAgAAJ/AkAgBawgBKx+IgdCIIinIAenIgRBH3VHBEAgA0ECNgJUIANBrJD/ADYCUCADQgI3AlwgA0GCDDYCHCADQYIMNgIUIAMgA0EQajYCWCADIANBNGo2AhggAyADQQxqNgIQIANBPGogA0HQAGoQmQ4gA0EoaiADQUBrKQIANwMAIANBMGoiBCADQcgAaigCADYCACADQYiAgIB4NgI4IAMgAykCOCIHNwMgIAenQZOAgIB4Rw0BIAMoAiQhBAsgA0HQAGogBCAGKAIILQAAEOoPIAMoAlAiBUGTgICAeEcEQCADQRhqIANB4ABqKAIANgIAIAMgAykCWDcDECADKAJUDAILIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIADAILIANBIGoQiBEgBigCBCEBIAMgBTYCNCADQcyR/wA2AjggA0IENwJEIANBggw2AmwgA0H0CzYCZCADIAFBAWo2AmAgA0G7BzYCXCADIAE2AlggA0HMATYCVCADQfiR/wA2AlAgAyADQdAAajYCQCADIANBNGo2AmggA0EENgI8IANBJGogA0E4ahCZDiADQRhqIAQoAgA2AgAgAyADKQIoNwMQQYKAgIB4IQUgAygCJAs2AgQgACAFNgIAIAAgAykDEDcCCCAAQRBqIANBGGooAgA2AgALIANB8ABqJAALhAQBA38jAEFAaiIDJAAgA0EMakGWt8IAQQgQgCAgA0EsaiACEOcnAkAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAQsgA0EsaiIEQZ63wgBBA0EIQQEQ6BwgA0EYaiACIAQQrhQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwBCyADQSxqIgQQhjAgBCACIAEoAgQgASgCCBCnGyADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyACEMYhIAEoAgxBgICAgHhHBEAgA0EsaiIEQaG3wgBBBUEIQQIQ6BwgA0EYaiACIAQQrhQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwCCyADQSxqIgQQhjAgBCACIAEoAhAgASgCFBCnGyADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwCCyACEMYhCyADQSxqIAIQgTYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAuEBAEDfyMAQUBqIgMkACADQQxqQZa3wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyADQSxqIgRBnrfCAEEDQQhBARDoHCADQRhqIAIgBBCtFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAELIANBLGoiBBCGMCAEIAIgASgCBCABKAIIEKYbIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAELIAIQxiEgASgCDEGAgICAeEcEQCADQSxqIgRBobfCAEEFQQhBAhDoHCADQRhqIAIgBBCtFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCECABKAIUEKYbIAMoAiwiAUEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACABNgIADAILIAIQxiELIANBLGogAhCANiADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwBCyAAIAIQ5SgLIANBDGoQ3jsgA0FAayQAC6wKAhB/BH4jAEEQayIKJAAgCiACNgIMIAFBEGoiBSAKQQxqEOsMIRYgASgCCEUEQCMAQdAAayICJAAgAiAFNgIcIAEoAgwhDCACIAJBHGo2AiACQAJAIAwgDEEBaiIFTQRAAkAgASgCBCIGIAZBAWpBA3ZBB2wgBkEISRsiBkEBdiAFSQRAAn8gBkEBaiIGIAUgBSAGSRsiBUEPTwRAIAVB/////wFLDQVBfyAFQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBUEISRsgBUEESRsLIQUgAkFAayABQRBqIgdBDEEIIAUQnRQgAigCRCEGIAIoAkAiCEUEQCACKAJIIQUMBQsgAikCSCEVIAZBCWoiBQRAIAhB/wEgBfwLAAsgAiAVQiCIPgI8IAIgFaciDzYCOCACIAY2AjQgAiAINgIwIAJCjICAgIABNwIoIAIgBzYCJCACQTBqIRAgAiAMBH8gCEEIaiERIAEoAgAiDikDAEJ/hUKAgYKEiJCgwIB/gyEVQQAhBQNAIBVQBEADQCAFQQhqIQUgDkEIaiIOKQMAQoCBgoSIkKDAgH+DIhVCgIGChIiQoMCAf1ENAAsgFUKAgYKEiJCgwIB/hSEVCyAIIAYgAigCHCABKAIAIBV6p0EDdiAFaiISQXRsakEMaxDrDKciE3EiB2opAABCgIGChIiQoMCAf4MiF1AEQEEIIQkDQCAHIAlqIQcgCUEIaiEJIAggBiAHcSIHaikAAEKAgYKEiJCgwIB/gyIXUA0ACwsgFUIBfSAVgyEVIAggF3qnQQN2IAdqIAZxIgdqLAAAQQBOBEAgCCkDAEKAgYKEiJCgwIB/g3qnQQN2IQcLIAcgCGogE0EZdiIJOgAAIBEgB0EIayAGcWogCToAACAIIAdBf3NBDGxqIgcgASgCACASQX9zQQxsaiIJKQAANwAAIAdBCGogCUEIaigAADYAACAMQQFrIgwNAAsgASgCDAVBAAsiBTYCPCACIA8gBWs2AjggASAQQQQQ+iogAkEkahDQJgwBCyABIAJBIGpB/KbPAEEMEMUJC0GBgICAeCEGDAILEOMnIAIoAgwhBSACKAIIIQYMAQsQ4ycgAigCFCEFIAIoAhAhBgsgCiAFNgIEIAogBjYCACACQdAAaiQAIAooAgwhAgsgASgCBCIIIBancSEFIBZCGYgiF0L/AINCgYKEiJCgwIABfiEYIAEoAgAhBgNAAn8CQAJAAkAgBSAGaikAACIWIBiFIhVCf4UgFUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIVUEUEQANAIAIgBiAVeqdBA3YgBWogCHFBdGxqIgdBDGsoAgBGDQIgFUIBfSAVgyIVUEUNAAsLIBZCgIGChIiQoMCAf4MhFSANRQRAIBVQDQMgFXqnQQN2IAVqIAhxIQsLQQEgFSAWQgGGg1ANAxpBACEFIAYgC2osAAAiDUEATgRAIAYgBikDAEKAgYKEiJCgwIB/g3qnQQN2IgtqLQAAIQ0LIAYgC2ogF6dB/wBxIgc6AAAgBiALQQhrIAhxakEIaiAHOgAAIAEgASgCCCANQQFxazYCCCABIAEoAgxBAWo2AgwgBiALQXRsaiIBQQxrIAI2AgAgAUEIayADNgIAIAFBBGsgBDYCAAwBCyAHQQRrIgIoAgAhASACIAQ2AgAgB0EIayICKAIAIQUgAiADNgIACyAAIAE2AgQgACAFNgIAIApBEGokAA8LQQALIQ0gBSAUQQhqIhRqIAhxIQUMAAsAC5EEAQZ/IwBB0ABrIgIkACACQThqIAEQ8CcgAkEoaiIDIAJBxABqIgUoAgA2AgAgAiACKQI8NwMgAkAgAigCOCIEQQRHBEAgAigCSCEBIAAgAikDIDcCBCAAIAE2AhAgACAENgIAIABBDGogAygCADYCAAwBCyACQRBqIAMoAgA2AgAgAiACKQMgNwMIIAJBCGoQhjAgAkE4aiABENMJIAMgBSkCADcDACACQTBqIgMgAkHMAGooAgA2AgAgAiACKQI8NwMgAkACQCACKAI4RQRAIAJBPGohBQNAIAJBGGogAygCACIENgIAIAJBEGogAkEoaiIGKQMANwMAIAIgAikDIDcDCCAEQf8BcUUNAyACQThqIgcgASAEQcAAEMkCIAIoAjgiBEEERw0CIAJBCGoQhjAgByABENMJIAYgBUEIaikCADcDACADIAVBEGooAgA2AgAgAiAFKQIANwMgIAIoAjhFDQALCyAAIAIpAyA3AgAgAEEQaiADKAIANgIAIABBCGogAkEoaikDADcCAAwCCyAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAQ2AgAgAkEIahCGMAwBCyACQQhqEIYwIAJBOGogARCoKSACKAI4IgFBBEcEQCAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAE2AgAMAQsgAEEENgIACyACQdAAaiQAC4wEAgV/BH4jAEEQayICJAAgASgCBCEEIAEoAggiBa0hCiABKAIQIgOtIQkCQAJAAkACQANAAkACfiAHQsYAUQRAQQAhBCACQQRqQRZBAEEBQQEQoBggAigCCCEBIAIoAgRBAUYNByACKAIMIgNBDmpBvM/QACkAADcAACADQQhqQbbP0AApAAA3AAAgA0Guz9AAKQAANwAAQoCAgIDgAgwBCyAEQQAgCSAKVBsNASACQQRqQcMAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQYgAigCDCIDQcTP0ABBwwD8CgAAQQIhBEKAgICAsAgLIQcgACABNgIEIAAgBDYCACAAIAcgA62ENwMIDAQLIAlCAXwhCSADIARqLAAAIgZB/wBxrSAHhiAIhCEIIAdCB3whByADQQFqIQMgBkEASA0ACyABIAM2AhAgCEIBg1BFBEAgAUEANgIcIAEgCKdBAnRBeHE2AhgMAgsgASAIQgGIPgIUIAMgBUkNACACQQRqQcIAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQMgAigCDCIDQezO0ABBwgD8CgAAIABBwgA2AgwgACADNgIIIAAgATYCBCAAQQI2AgAMAgsgASADQQFqNgIQIAEgAyAEai0AAEEARzoAIAwACyAAQQg2AgALIAJBEGokAA8LIAEgAigCDEGkxtAAEP0vAAv5AwIFfwJ+IAApAwghCyAAKQMAIQoCQAJAAkACQAJAA0AgAiAHIgVBA2oiB00EQANAIAIgBU0NByAFQQFqIQcgASAFai0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDUARAIAQgBCgCACIIQQFqIgY2AgAgAyAIQQJ0aiAHNgIAIAZBwABGDQcLIAchBQwACwALIAEgBWoiCC0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDUARAIAQgBCgCACIGQQFqIgk2AgAgAyAGQQJ0aiAFQQFqNgIAIAlBwABGDQMLIAhBAWotAABBA3RB0JvRAGopAwAgCkIBhnwiCiALg1AEQCAEIAQoAgAiBkEBaiIJNgIAIAMgBkECdGogBUECajYCACAJQcAARg0ECyAIQQJqLQAAQQN0QdCb0QBqKQMAIApCAYZ8IgogC4NQBEAgBCAEKAIAIgZBAWoiCTYCACADIAZBAnRqIAc2AgAgCUHAAEYNAgsgBUEEaiIFIQcgCEEDai0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDQgBSDQAgBCAEKAIAIghBAWoiBjYCACADIAhBAnRqIAc2AgAgBkHAAEcNAAsMBAsgBUEDaiEFDAMLIAVBAWohBQwCCyAFQQJqIQUMAQsgBUEBaiEFCyAAIAo3AwAgBQufCAITfwN+IwBB0ABrIgMkACADQTBqIgIgARD4KCADQRhqIAJB0Lf+ABDKEiADKAIcIQUCQCADKAIgIgRBAkkNACAEQRVPBEAgBSAEIAIQyRsMAQsgBSAEEJUnCyADKAIYIQIgAyAANgJEIAMgATYCQCADIAUgBEECdGo2AjwgAyACNgI4IAMgBTYCNCADIAU2AjAgA0EkaiEGIwBBEGsiCCQAIANBMGoiBCgCDCIBIAQoAgQiC2tBAnYhDCAEKAIIIRAgBCgCACENIAEgC0cEQCAEKAIQIgpBEGohESAEKAIUIQJBACEBA0ACQAJAIAooAgxFDQAgAUEBaiEFIA0gAUECdCIBaiESIBEgASALaigCACIHEPgLIRUgCigCACIJQRhrIRMgCigCBCIOIBWncSEBIBVCGYhC/wCDQoGChIiQoMCAAX4hF0EAIQ8DQCABIAlqKQAAIhYgF4UiFUJ/hSAVQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhVQRQRAA0AgByATIBV6p0EDdiABaiAOcUFobCIUahCMNQ0EIBVCAX0gFYMiFVBFDQALCyAWIBZCAYaDQoCBgoSIkKDAgH+DUEUNASABIA9BCGoiD2ogDnEhAQwACwALQbiB/wAQsjsACyACIAcoAgQgBygCCBDbCCEBIAIgCSAUaiIHQQhrKAIAIAdBBGsoAgAQ2wghByACQQE6ADggAigCMCEJIAJBBCABEP0OIAJBBiAHEP0OIAIgCRDYByEBIAJBADYCFCACQQA6ADggEiABNgIAIAUiASAMRw0ACwsgBEEANgIIIARBBDYCACAIQoCAgIDAADcCCCAIQQhqEOk7IARBBDYCDCAEQQQ2AgQgBiAMNgIIIAYgDTYCBCAGIBA2AgAgBBDeKyAIQRBqJAAgAEEEIAAoAjQiASABQQRNGzYCNCADKAIoIQUgAEEwaiEGIAMoAiwiBEECdCECAkBBACAAKAIwIghrQQNxIgEgACgCCCAIa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAYgARCNNwJAAkAgAkEEaiIBIAAoAgggACgCMGsiB00NACABQYCAgIB4Sw0BIAEgB00NAANAIAAQ+xYgACgCCCAAKAIwayABSQ0ACwsgBiACEI03IAAoAjAhASADQRBqIAAQ3DsgA0EIaiADKAIQIAMoAhQgACgCMCIGIAYgAmtByLb+ABDXJiADKAIMQQJ2IgIgBCACIARJGyIGBEAgAygCCCECA0AgAiABIAUoAgBrNgAAIAVBBGohBSACQQRqIQIgAUEEayEBIAZBAWsiBg0ACwsgACAEEKkRIANBJGpBBEEEEOAeIANB0ABqJAAPC0HYtv4AQSVBgLf+ABCfKQALvQQCA38BfiMAQZABayICJAACQAJ/QQMgASgCHCIEIAEoAiBGDQAaAkAgASgCBEUNACAEIAEoAhRPDQIgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEIaiABKAIAIAQQ2isgASgCKCEEIAEoAiQhBSACKAIIIQEgAiACKAIMIgY2AhQgAiABNgIQIAJBGGogASAGIAUsAAAQxwECfyACKAIYQZOAgIB4RwRAIAJB0ABqIAJBKGooAgA2AgAgAkHIAGogAkEgaikCADcDACACIAIpAhg3A0AgAkH4AGpB/K6AASgCADYCACACQfSugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEQajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAigCNCEFIAIpAjghB0GCgICAeCEEIAIoAjAMAQsgAkHYAGogAigCHCIBIAQtAAAQ6g9BASACKAJYIgRBk4CAgHhGDQEaIAIpAmQhByACKAJgIQUgAigCXAshASADKAIAQZOAgIB4RwRAIAMQiBELIAMgBzcCDCADIAU2AgggAyABNgIEIAMgBDYCAEECCyEEIAAgATYCBCAAIAQ2AgAgAkGQAWokAA8LQfSngAFBIEGUqIABEJ8pAAu9BAIDfwF+IwBBkAFrIgIkAAJAAn9BAyABKAIcIgQgASgCIEYNABoCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCABKAIoIQQgASgCJCEFIAIoAgghASACIAIoAgwiBjYCFCACIAE2AhAgAkEYaiABIAYgBSwAABDHAQJ/IAIoAhhBk4CAgHhHBEAgAkHQAGogAkEoaigCADYCACACQcgAaiACQSBqKQIANwMAIAIgAikCGDcDQCACQfgAakH8roABKAIANgIAIAJB9K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQRBqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKAI0IQUgAikCOCEHQYKAgIB4IQQgAigCMAwBCyACQdgAaiACKAIcIgEgBC0AABDqD0EBIAIoAlgiBEGTgICAeEYNARogAikCZCEHIAIoAmAhBSACKAJcCyEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAHNwIMIAMgBTYCCCADIAE2AgQgAyAENgIAQQILIQQgACABNgIEIAAgBDYCACACQZABaiQADwtB9KeAAUEgQZSogAEQnykAC/oDARN/IwBB0ABrIgIkACABKAIEIQcgAkHEAGogASgCCCIIQQBBBEHEABCgGCACKAJIIQQCQCACKAJEQQFHBEAgAigCTCEJAkAgBEUNACAIQcQAbCEOIAJBFGohCiACQSBqIQsgByEBIAQhDANAIAUgDkYNASACQSxqIAFBGGoQ2wYgASgCKCEPIAEoAiQhECACQThqIAEQvhUgAkHEAGogAUEMahCACyABKAIsIgYEQCAGIAYoAgAiA0EBajYCACADQQBIDQQgBSAHaiIDQUBrKAIAIREgA0E0aigCACESIANBMGooAgAhEyADQTxqKAIAIRQgA0E4aigCACENCyALIAIpAiw3AgAgCiACKQJENwIAIAtBCGogAkE0aigCADYCACACQRBqIAJBQGsoAgA2AgAgCkEIaiACQcwAaigCADYCACACIAIpAjg3AwggBSAJaiIDIAJBCGpBJPwKAAAgAUHEAGohASADQUBrIBE2AgAgA0E8aiAUNgIAIANBOGogDTYCACADQTRqIBI2AgAgA0EwaiATNgIAIANBLGogBjYCACADQShqIA82AgAgA0EkaiAQNgIAIAVBxABqIQUgDEEBayIMDQALCyAAIAg2AgggACAJNgIEIAAgBDYCACACQdAAaiQADwsgBCACKAJMQciKhwEQ/S8LAAu6BAIDfwF+IwBBkAFrIgIkAAJAAn9BAyABKAIcIgQgASgCIEYNABoCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiABKAIoIQQgASgCJCEFIAIoAgghASACIAIoAgwiBjYCFCACIAE2AhAgAkEYaiABIAYgBSwAABDHAQJ/IAIoAhhBk4CAgHhHBEAgAkHQAGogAkEoaigCADYCACACQcgAaiACQSBqKQIANwMAIAIgAikCGDcDQCACQfgAakH8roABKAIANgIAIAJB9K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQRBqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKAI0IQUgAikCOCEHQYKAgIB4IQQgAigCMAwBCyACQdgAaiACKAIcIgEgBC0AABDqD0EBIAIoAlgiBEGTgICAeEYNARogAikCZCEHIAIoAmAhBSACKAJcCyEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAHNwIMIAMgBTYCCCADIAE2AgQgAyAENgIAQQILIQQgACABNgIEIAAgBDYCACACQZABaiQADwtB9KeAAUEgQZSogAEQnykAC5sKAhB/BH4jAEEQayIIJAAgCCACOwEOIAFBEGoiBCAIQQ5qEK4MIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCuDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQZjegAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBDmpBAiABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0ECEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAILwEOIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY7AQAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAubCgIQfwR+IwBBEGsiCCQAIAggAjsBDiABQRBqIgQgCEEOahCuDCEVIAEoAghFBEAjAEHQAGsiAiQAIAIgBDYCHCABKAIMIQogAiACQRxqNgIgAkACQCAKIApBAWoiBE0EQAJAIAEoAgQiBSAFQQFqQQN2QQdsIAVBCEkbIgVBAXYgBEkEQAJ/IAVBAWoiBSAEIAQgBUkbIgRBD08EQCAEQf////8BSw0FQX8gBEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIARBCEkbIARBBEkbCyEEIAJBQGsgAUEQaiIGQQhBCCAEEJ0UIAIoAkQhBSACKAJAIgdFBEAgAigCSCEEDAULIAIpAkghFCAFQQlqIgQEQCAHQf8BIAT8CwALIAIgFEIgiD4CPCACIBSnIg02AjggAiAFNgI0IAIgBzYCMCACQoiAgICAATcCKCACIAY2AiQgAkEwaiEOIAIgCgR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQQDQCAUUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgByAFIAIoAhwgASgCACAUeqdBA3YgBGoiEEEDdGtBCGsQrgynIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCELA0AgBiALaiEGIAtBCGohCyAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiFlANAAsLIBRCAX0gFIMhFCAHIBZ6p0EDdiAGaiAFcSIGaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAdqIBFBGXYiCzoAACAPIAZBCGsgBXFqIAs6AAAgByAGQX9zQQN0aiABKAIAIBBBf3NBA3RqKQAANwAAIApBAWsiCg0ACyABKAIMBUEACyIENgI8IAIgDSAEazYCOCABIA5BBBD6KiACQSRqENAmDAELIAEgAkEgakGo34ABQQgQxwkLQYGAgIB4IQUMAgsQ4ycgAigCDCEEIAIoAgghBQwBCxDjJyACKAIUIQQgAigCECEFCyAIIAQ2AgQgCCAFNgIAIAJB0ABqJAALIAEoAgQiBCAVp3EhAiAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQUDQAJ/AkACQAJAIAIgBWopAAAiFSAXhSIUQn+FIBRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFFBFBEADQCAIQQ5qQQIgASgCACAUeqdBA3YgAmogBHEiB0EDdGtBCGtBAhCfOw0CIBRCAX0gFIMiFFBFDQALCyAVQoCBgoSIkKDAgH+DIRQgEkUEQCAUUA0DIBR6p0EDdiACaiAEcSEJC0EBIBQgFUIBhoNQDQMaQQAhAiAFIAlqLAAAQQBOBEAgBSkDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAEoAgAiBCAJaiIFLQAAIQcgCC8BDiEGIAUgFqdB/wBxIgU6AAAgBCABKAIEIAlBCGtxakEIaiAFOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBCAJQQN0ayIBQQRrIAM2AgAgAUEIayAGOwEADAELIAEoAgBBACAHa0EDdGpBBGsiAigCACEBIAIgAzYCAEEBIQILIAAgATYCBCAAIAI2AgAgCEEQaiQADwtBAAshEiACIBNBCGoiE2ogBHEhAgwACwALrwoCEX8EfiMAQRBrIgkkACAJIAI5AwggAUEQaiIFIAlBCGoQrAwhFiABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCEMIAQgBEEcajYCIAJAAkAgDCAMQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiB0EQQQggBRCdFCAEKAJEIQYgBCgCQCIIRQRAIAQoAkghBQwFCyAEKQJIIRUgBkEJaiIFBEAgCEH/ASAF/AsACyAEIBVCIIg+AjwgBCAVpyIONgI4IAQgBjYCNCAEIAg2AjAgBEKQgICAgAE3AiggBCAHNgIkIARBMGohDyAEIAwEfyAIQQhqIRAgASgCACINKQMAQn+FQoCBgoSIkKDAgH+DIRVBACEFA0AgFVAEQANAIAVBCGohBSANQQhqIg0pAwBCgIGChIiQoMCAf4MiFUKAgYKEiJCgwIB/UQ0ACyAVQoCBgoSIkKDAgH+FIRULIAggBiAEKAIcIAEoAgAgFXqnQQN2IAVqIhFBBHRrQRBrEKwMpyIScSIHaikAAEKAgYKEiJCgwIB/gyIXUARAQQghCgNAIAcgCmohByAKQQhqIQogCCAGIAdxIgdqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyAVQgF9IBWDIRUgCCAXeqdBA3YgB2ogBnEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiASQRl2Igo6AAAgECAHQQhrIAZxaiAKOgAAIAggB0F/c0EEdGoiByABKAIAIBFBf3NBBHRqIgopAAA3AAAgB0EIaiAKQQhqKQAANwAAIAxBAWsiDA0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakGI2oABQRAQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAWp3EhBCAWQhmIIhdC/wCDQoGChIiQoMCAAX4hGCABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFiAYhSIVQn+FIBVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFVBFBEADQCAJQQhqQQggASgCACAVeqdBA3YgBGogBXEiCEEEdGtBEGtBCBCfOw0CIBVCAX0gFYMiFVBFDQALCyAWQoCBgoSIkKDAgH+DIRUgE0UEQCAVUA0DIBV6p0EDdiAEaiAFcSELC0EBIBUgFkIBhoNQDQMaQQAhBCAGIAtqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQsLIAEoAgAiBSALaiIGLQAAIQggCSsDCCECIAYgF6dB/wBxIgY6AAAgBSABKAIEIAtBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggCEEBcWs2AgggBSALQQR0ayIBQQhrIAM2AgAgAUEQayACOQMADAELIAEoAgBBACAIa0EEdGpBCGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALrwoCEX8DfiMAQRBrIgkkACAJIAI3AwggAUEQaiIFIAlBCGoQrAwhFSABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCEMIAQgBEEcajYCIAJAAkAgDCAMQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiB0EQQQggBRCdFCAEKAJEIQYgBCgCQCIIRQRAIAQoAkghBQwFCyAEKQJIIQIgBkEJaiIFBEAgCEH/ASAF/AsACyAEIAJCIIg+AjwgBCACpyIONgI4IAQgBjYCNCAEIAg2AjAgBEKQgICAgAE3AiggBCAHNgIkIARBMGohDyAEIAwEfyAIQQhqIRAgASgCACINKQMAQn+FQoCBgoSIkKDAgH+DIQJBACEFA0AgAlAEQANAIAVBCGohBSANQQhqIg0pAwBCgIGChIiQoMCAf4MiAkKAgYKEiJCgwIB/UQ0ACyACQoCBgoSIkKDAgH+FIQILIAggBiAEKAIcIAEoAgAgAnqnQQN2IAVqIhFBBHRrQRBrEKwMpyIScSIHaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCgNAIAcgCmohByAKQQhqIQogCCAGIAdxIgdqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyACQgF9IAKDIQIgCCAWeqdBA3YgB2ogBnEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiASQRl2Igo6AAAgECAHQQhrIAZxaiAKOgAAIAggB0F/c0EEdGoiByABKAIAIBFBf3NBBHRqIgopAAA3AAAgB0EIaiAKQQhqKQAANwAAIAxBAWsiDA0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakGg4IABQRAQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAVp3EhBCAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFSAXhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAJQQhqQQggASgCACACeqdBA3YgBGogBXEiCEEEdGtBEGtBCBCfOw0CIAJCAX0gAoMiAlBFDQALCyAVQoCBgoSIkKDAgH+DIQIgE0UEQCACUA0DIAJ6p0EDdiAEaiAFcSELC0EBIAIgFUIBhoNQDQMaQQAhBCAGIAtqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQsLIAEoAgAiBSALaiIGLQAAIQggCSkDCCECIAYgFqdB/wBxIgY6AAAgBSABKAIEIAtBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggCEEBcWs2AgggBSALQQR0ayIBQQhrIAM2AgAgAUEQayACNwMADAELIAEoAgBBACAIa0EEdGpBCGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALmwoCEH8EfiMAQRBrIggkACAIIAI7AQ4gAUEQaiIEIAhBDmoQrgwhFSABKAIIRQRAIwBB0ABrIgIkACACIAQ2AhwgASgCDCEKIAIgAkEcajYCIAJAAkAgCiAKQQFqIgRNBEACQCABKAIEIgUgBUEBakEDdkEHbCAFQQhJGyIFQQF2IARJBEACfyAFQQFqIgUgBCAEIAVJGyIEQQ9PBEAgBEH/////AUsNBUF/IARBA3RBB25BAWtndkEBagwBC0EEQQhBECAEQQhJGyAEQQRJGwshBCACQUBrIAFBEGoiBkEIQQggBBCdFCACKAJEIQUgAigCQCIHRQRAIAIoAkghBAwFCyACKQJIIRQgBUEJaiIEBEAgB0H/ASAE/AsACyACIBRCIIg+AjwgAiAUpyINNgI4IAIgBTYCNCACIAc2AjAgAkKIgICAgAE3AiggAiAGNgIkIAJBMGohDiACIAoEfyAHQQhqIQ8gASgCACIMKQMAQn+FQoCBgoSIkKDAgH+DIRRBACEEA0AgFFAEQANAIARBCGohBCAMQQhqIgwpAwBCgIGChIiQoMCAf4MiFEKAgYKEiJCgwIB/UQ0ACyAUQoCBgoSIkKDAgH+FIRQLIAcgBSACKAIcIAEoAgAgFHqnQQN2IARqIhBBA3RrQQhrEK4MpyIRcSIGaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCwNAIAYgC2ohBiALQQhqIQsgByAFIAZxIgZqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyAUQgF9IBSDIRQgByAWeqdBA3YgBmogBXEiBmosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhBgsgBiAHaiARQRl2Igs6AAAgDyAGQQhrIAVxaiALOgAAIAcgBkF/c0EDdGogASgCACAQQX9zQQN0aikAADcAACAKQQFrIgoNAAsgASgCDAVBAAsiBDYCPCACIA0gBGs2AjggASAOQQQQ+iogAkEkahDQJgwBCyABIAJBIGpBmOGAAUEIEMcJC0GBgICAeCEFDAILEOMnIAIoAgwhBCACKAIIIQUMAQsQ4ycgAigCFCEEIAIoAhAhBQsgCCAENgIEIAggBTYCACACQdAAaiQACyABKAIEIgQgFadxIQIgFUIZiCIWQv8Ag0KBgoSIkKDAgAF+IRcgASgCACEFA0ACfwJAAkACQCACIAVqKQAAIhUgF4UiFEJ/hSAUQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhRQRQRAA0AgCEEOakECIAEoAgAgFHqnQQN2IAJqIARxIgdBA3RrQQhrQQIQnzsNAiAUQgF9IBSDIhRQRQ0ACwsgFUKAgYKEiJCgwIB/gyEUIBJFBEAgFFANAyAUeqdBA3YgAmogBHEhCQtBASAUIBVCAYaDUA0DGkEAIQIgBSAJaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyABKAIAIgQgCWoiBS0AACEHIAgvAQ4hBiAFIBanQf8AcSIFOgAAIAQgASgCBCAJQQhrcWpBCGogBToAACABIAEoAgxBAWo2AgwgASABKAIIIAdBAXFrNgIIIAQgCUEDdGsiAUEEayADNgIAIAFBCGsgBjsBAAwBCyABKAIAQQAgB2tBA3RqQQRrIgIoAgAhASACIAM2AgBBASECCyAAIAE2AgQgACACNgIAIAhBEGokAA8LQQALIRIgAiATQQhqIhNqIARxIQIMAAsAC5sKAhB/BH4jAEEQayIIJAAgCCACOgAPIAFBEGoiBCAIQQ9qEK8MIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCvDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQcjYgAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBD2pBASABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0EBEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAILQAPIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY6AAAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAubCgIQfwR+IwBBEGsiCCQAIAggAjYCDCABQRBqIgQgCEEMahCrDCEVIAEoAghFBEAjAEHQAGsiAiQAIAIgBDYCHCABKAIMIQogAiACQRxqNgIgAkACQCAKIApBAWoiBE0EQAJAIAEoAgQiBSAFQQFqQQN2QQdsIAVBCEkbIgVBAXYgBEkEQAJ/IAVBAWoiBSAEIAQgBUkbIgRBD08EQCAEQf////8BSw0FQX8gBEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIARBCEkbIARBBEkbCyEEIAJBQGsgAUEQaiIGQQhBCCAEEJ0UIAIoAkQhBSACKAJAIgdFBEAgAigCSCEEDAULIAIpAkghFCAFQQlqIgQEQCAHQf8BIAT8CwALIAIgFEIgiD4CPCACIBSnIg02AjggAiAFNgI0IAIgBzYCMCACQoiAgICAATcCKCACIAY2AiQgAkEwaiEOIAIgCgR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQQDQCAUUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgByAFIAIoAhwgASgCACAUeqdBA3YgBGoiEEEDdGtBCGsQqwynIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCELA0AgBiALaiEGIAtBCGohCyAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiFlANAAsLIBRCAX0gFIMhFCAHIBZ6p0EDdiAGaiAFcSIGaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAdqIBFBGXYiCzoAACAPIAZBCGsgBXFqIAs6AAAgByAGQX9zQQN0aiABKAIAIBBBf3NBA3RqKQAANwAAIApBAWsiCg0ACyABKAIMBUEACyIENgI8IAIgDSAEazYCOCABIA5BBBD6KiACQSRqENAmDAELIAEgAkEgakHY3IABQQgQxwkLQYGAgIB4IQUMAgsQ4ycgAigCDCEEIAIoAgghBQwBCxDjJyACKAIUIQQgAigCECEFCyAIIAQ2AgQgCCAFNgIAIAJB0ABqJAALIAEoAgQiBCAVp3EhAiAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQUDQAJ/AkACQAJAIAIgBWopAAAiFSAXhSIUQn+FIBRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFFBFBEADQCAIQQxqQQQgASgCACAUeqdBA3YgAmogBHEiB0EDdGtBCGtBBBCfOw0CIBRCAX0gFIMiFFBFDQALCyAVQoCBgoSIkKDAgH+DIRQgEkUEQCAUUA0DIBR6p0EDdiACaiAEcSEJC0EBIBQgFUIBhoNQDQMaQQAhAiAFIAlqLAAAQQBOBEAgBSkDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAEoAgAiBCAJaiIFLQAAIQcgCCgCDCEGIAUgFqdB/wBxIgU6AAAgBCABKAIEIAlBCGtxakEIaiAFOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBCAJQQN0ayIBQQRrIAM2AgAgAUEIayAGNgIADAELIAEoAgBBACAHa0EDdGpBBGsiAigCACEBIAIgAzYCAEEBIQILIAAgATYCBCAAIAI2AgAgCEEQaiQADwtBAAshEiACIBNBCGoiE2ogBHEhAgwACwALmwoCEH8EfiMAQRBrIggkACAIIAI6AA8gAUEQaiIEIAhBD2oQrwwhFSABKAIIRQRAIwBB0ABrIgIkACACIAQ2AhwgASgCDCEKIAIgAkEcajYCIAJAAkAgCiAKQQFqIgRNBEACQCABKAIEIgUgBUEBakEDdkEHbCAFQQhJGyIFQQF2IARJBEACfyAFQQFqIgUgBCAEIAVJGyIEQQ9PBEAgBEH/////AUsNBUF/IARBA3RBB25BAWtndkEBagwBC0EEQQhBECAEQQhJGyAEQQRJGwshBCACQUBrIAFBEGoiBkEIQQggBBCdFCACKAJEIQUgAigCQCIHRQRAIAIoAkghBAwFCyACKQJIIRQgBUEJaiIEBEAgB0H/ASAE/AsACyACIBRCIIg+AjwgAiAUpyINNgI4IAIgBTYCNCACIAc2AjAgAkKIgICAgAE3AiggAiAGNgIkIAJBMGohDiACIAoEfyAHQQhqIQ8gASgCACIMKQMAQn+FQoCBgoSIkKDAgH+DIRRBACEEA0AgFFAEQANAIARBCGohBCAMQQhqIgwpAwBCgIGChIiQoMCAf4MiFEKAgYKEiJCgwIB/UQ0ACyAUQoCBgoSIkKDAgH+FIRQLIAcgBSACKAIcIAEoAgAgFHqnQQN2IARqIhBBA3RrQQhrEK8MpyIRcSIGaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCwNAIAYgC2ohBiALQQhqIQsgByAFIAZxIgZqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyAUQgF9IBSDIRQgByAWeqdBA3YgBmogBXEiBmosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhBgsgBiAHaiARQRl2Igs6AAAgDyAGQQhrIAVxaiALOgAAIAcgBkF/c0EDdGogASgCACAQQX9zQQN0aikAADcAACAKQQFrIgoNAAsgASgCDAVBAAsiBDYCPCACIA0gBGs2AjggASAOQQQQ+iogAkEkahDQJgwBCyABIAJBIGpBuNqAAUEIEMcJC0GBgICAeCEFDAILEOMnIAIoAgwhBCACKAIIIQUMAQsQ4ycgAigCFCEEIAIoAhAhBQsgCCAENgIEIAggBTYCACACQdAAaiQACyABKAIEIgQgFadxIQIgFUIZiCIWQv8Ag0KBgoSIkKDAgAF+IRcgASgCACEFA0ACfwJAAkACQCACIAVqKQAAIhUgF4UiFEJ/hSAUQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhRQRQRAA0AgCEEPakEBIAEoAgAgFHqnQQN2IAJqIARxIgdBA3RrQQhrQQEQnzsNAiAUQgF9IBSDIhRQRQ0ACwsgFUKAgYKEiJCgwIB/gyEUIBJFBEAgFFANAyAUeqdBA3YgAmogBHEhCQtBASAUIBVCAYaDUA0DGkEAIQIgBSAJaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyABKAIAIgQgCWoiBS0AACEHIAgtAA8hBiAFIBanQf8AcSIFOgAAIAQgASgCBCAJQQhrcWpBCGogBToAACABIAEoAgxBAWo2AgwgASABKAIIIAdBAXFrNgIIIAQgCUEDdGsiAUEEayADNgIAIAFBCGsgBjoAAAwBCyABKAIAQQAgB2tBA3RqQQRrIgIoAgAhASACIAM2AgBBASECCyAAIAE2AgQgACACNgIAIAhBEGokAA8LQQALIRIgAiATQQhqIhNqIARxIQIMAAsAC5sKAhB/BH4jAEEQayIIJAAgCCACNgIMIAFBEGoiBCAIQQxqEKsMIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCrDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQajZgAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBDGpBBCABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0EEEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAIKAIMIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY2AgAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAuvCgIRfwN+IwBBEGsiCSQAIAkgAjcDCCABQRBqIgUgCUEIahCsDCEVIAEoAghFBEAjAEHQAGsiBCQAIAQgBTYCHCABKAIMIQwgBCAEQRxqNgIgAkACQCAMIAxBAWoiBU0EQAJAIAEoAgQiBiAGQQFqQQN2QQdsIAZBCEkbIgZBAXYgBUkEQAJ/IAZBAWoiBiAFIAUgBkkbIgVBD08EQCAFQf////8BSw0FQX8gBUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAVBCEkbIAVBBEkbCyEFIARBQGsgAUEQaiIHQRBBCCAFEJ0UIAQoAkQhBiAEKAJAIghFBEAgBCgCSCEFDAULIAQpAkghAiAGQQlqIgUEQCAIQf8BIAX8CwALIAQgAkIgiD4CPCAEIAKnIg42AjggBCAGNgI0IAQgCDYCMCAEQpCAgICAATcCKCAEIAc2AiQgBEEwaiEPIAQgDAR/IAhBCGohECABKAIAIg0pAwBCf4VCgIGChIiQoMCAf4MhAkEAIQUDQCACUARAA0AgBUEIaiEFIA1BCGoiDSkDAEKAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhAgsgCCAGIAQoAhwgASgCACACeqdBA3YgBWoiEUEEdGtBEGsQrAynIhJxIgdqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCEKA0AgByAKaiEHIApBCGohCiAIIAYgB3EiB2opAABCgIGChIiQoMCAf4MiFlANAAsLIAJCAX0gAoMhAiAIIBZ6p0EDdiAHaiAGcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqIBJBGXYiCjoAACAQIAdBCGsgBnFqIAo6AAAgCCAHQX9zQQR0aiIHIAEoAgAgEUF/c0EEdGoiCikAADcAACAHQQhqIApBCGopAAA3AAAgDEEBayIMDQALIAEoAgwFQQALIgU2AjwgBCAOIAVrNgI4IAEgD0EEEPoqIARBJGoQ0CYMAQsgASAEQSBqQZjbgAFBEBDHCQtBgYCAgHghBgwCCxDjJyAEKAIMIQUgBCgCCCEGDAELEOMnIAQoAhQhBSAEKAIQIQYLIAkgBTYCBCAJIAY2AgAgBEHQAGokAAsgASgCBCIFIBWncSEEIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBgNAAn8CQAJAAkAgBCAGaikAACIVIBeFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAlBCGpBCCABKAIAIAJ6p0EDdiAEaiAFcSIIQQR0a0EQa0EIEJ87DQIgAkIBfSACgyICUEUNAAsLIBVCgIGChIiQoMCAf4MhAiATRQRAIAJQDQMgAnqnQQN2IARqIAVxIQsLQQEgAiAVQgGGg1ANAxpBACEEIAYgC2osAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgASgCACIFIAtqIgYtAAAhCCAJKQMIIQIgBiAWp0H/AHEiBjoAACAFIAEoAgQgC0EIa3FqQQhqIAY6AAAgASABKAIMQQFqNgIMIAEgASgCCCAIQQFxazYCCCAFIAtBBHRrIgFBCGsgAzYCACABQRBrIAI3AwAMAQsgASgCAEEAIAhrQQR0akEIayIEKAIAIQEgBCADNgIAQQEhBAsgACABNgIEIAAgBDYCACAJQRBqJAAPC0EACyETIAQgFEEIaiIUaiAFcSEEDAALAAubCgIRfwR+IwBBEGsiCSQAIAkgAjgCDCABQRBqIgUgCUEMahCrDCEWIAEoAghFBEAjAEHQAGsiBCQAIAQgBTYCHCABKAIMIQsgBCAEQRxqNgIgAkACQCALIAtBAWoiBU0EQAJAIAEoAgQiBiAGQQFqQQN2QQdsIAZBCEkbIgZBAXYgBUkEQAJ/IAZBAWoiBiAFIAUgBkkbIgVBD08EQCAFQf////8BSw0FQX8gBUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAVBCEkbIAVBBEkbCyEFIARBQGsgAUEQaiIIQQhBCCAFEJ0UIAQoAkQhBiAEKAJAIgdFBEAgBCgCSCEFDAULIAQpAkghFSAGQQlqIgUEQCAHQf8BIAX8CwALIAQgFUIgiD4CPCAEIBWnIg42AjggBCAGNgI0IAQgBzYCMCAEQoiAgICAATcCKCAEIAg2AiQgBEEwaiEPIAQgCwR/IAdBCGohECABKAIAIg0pAwBCf4VCgIGChIiQoMCAf4MhFUEAIQUDQCAVUARAA0AgBUEIaiEFIA1BCGoiDSkDAEKAgYKEiJCgwIB/gyIVQoCBgoSIkKDAgH9RDQALIBVCgIGChIiQoMCAf4UhFQsgByAGIAQoAhwgASgCACAVeqdBA3YgBWoiEUEDdGtBCGsQqwynIhJxIghqKQAAQoCBgoSIkKDAgH+DIhdQBEBBCCEMA0AgCCAMaiEIIAxBCGohDCAHIAYgCHEiCGopAABCgIGChIiQoMCAf4MiF1ANAAsLIBVCAX0gFYMhFSAHIBd6p0EDdiAIaiAGcSIIaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEICyAHIAhqIBJBGXYiDDoAACAQIAhBCGsgBnFqIAw6AAAgByAIQX9zQQN0aiABKAIAIBFBf3NBA3RqKQAANwAAIAtBAWsiCw0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakHg3oABQQgQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAWp3EhBCAWQhmIIhdC/wCDQoGChIiQoMCAAX4hGCABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFiAYhSIVQn+FIBVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFVBFBEADQCAJQQxqQQQgASgCACAVeqdBA3YgBGogBXEiB0EDdGtBCGtBBBCfOw0CIBVCAX0gFYMiFVBFDQALCyAWQoCBgoSIkKDAgH+DIRUgE0UEQCAVUA0DIBV6p0EDdiAEaiAFcSEKC0EBIBUgFkIBhoNQDQMaQQAhBCAGIApqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQoLIAEoAgAiBSAKaiIGLQAAIQcgCSoCDCECIAYgF6dB/wBxIgY6AAAgBSABKAIEIApBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBSAKQQN0ayIBQQRrIAM2AgAgAUEIayACOAIADAELIAEoAgBBACAHa0EDdGpBBGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALgAQCCH8BfiMAQSBrIgIkAAJAAkACQCABKAJgQQFqIgMgASgCSE8EQCACQRBqIgQgAUEQaiIDEKUYIAIoAhBFBEAgBEElQQBBAUEBEKAYIAIoAhQhASACKAIQQQFGDQQgAigCGCIDQYKjzQBBJfwKAAAgACADrUKAgICA0ASENwMIIAAgATYCBCAAQQI2AgAMAwsgAikDGCEKIAFBADYCSCABQgAgCkIBg30gCkIBiIU3AzAgAyABQUBrIgUgASgCVBD+HyABKAJQIQMgASgCKCABKAIsIQQgAkEIaiAFEPQvIARBA3ZqIARBB3FBAEdqIQUgAigCCCIEIAIoAgwiB0YNAQNAAn8gAwRAIAQtAAAMAQsgBEEAOgAAQQALIAMgASgCWCIIayIJQQAgAyAJTxshAyAIbEEDdiAFaiEFIARBAWoiBCAHRw0ACwwBCyABIAM2AmAgAEEINgIAIAEgASgCWDYCZAwBCyABIAU2AlwgASgCSCABKAJURgRAIAFBADYCYCAAQQg2AgAgASABKAJYNgJkDAELIAJBEGpBIkEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0BIAIoAhgiA0Hgos0AQSL8CgAAIABBIjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEgaiQADwsgASACKAIYQdT9zAAQ/S8AC5QEAgR/CH4jAEHQAGsiAiQAQoCAgICAgICAgH8hCQJAAkACfgJAAkAgACgCBCgCECABQQR0aiIDKQMAIgsgAykDCCIMQoCAgICAgICAgH+FhEIAUiAAKAIAIgUoAgAiAygCACIEKQMIIgYgBCkDACIHg0J/UnJFBEBCACEGDAELIAYgB4RQDQMgAkEgaiALIAwgByAGEIMZIAJBEGogAikDICIIIAIpAygiCSAHIAYQqB5CACALIAIpAxAiDX0gBiAHg0J/USIEGyEKQgAgDCACKQMYfSALIA1UrX0gBBshBiAMQgBZDQELIAggCiADKAIIIgMpAwBYIAYgAykDCCIHVyAGIAdRG60iB30hBiAJIAcgCFatfQwBCyAJIAggCiADKAIEIgMpAwBaIAYgAykDCCIHWSAGIAdRG618IgYgCFStfAshCCACQTBqIAYgCBCyLgJAIAIpAzAiBiACKQM4IgggAikDQCIHIAIpA0giCSAFKAIELQAAENwdBEAgACgCCCABQQV0aiIAIAk3AxggACAHNwMQIAAgCDcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQIgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB0ABqJAAPC0HMj/8AEOIrAAsgACADQYiL/wAQwyEAC48EAQx/IwBBMGsiAyQAAkAgACgCCCIEIAJNDQAgACgCBCEFAkAgAgRAIAIgBWosAABBv39MDQELIANBADYCICADQQE6ACwgA0EvNgIUIANBLzYCKCADIAQgAmsiCjYCJCADIAo2AhwgAyACIAVqIgs2AhggA0EnaiEMIANBKGohDSAKIQYDQAJAIANBCGogDCADLQAsai0AACAHIAtqIAYgB2sQowogAygCCEEBcUUNAAJAIAMoAiAiByADKAIMaiIGIAMtACwiCEEBayIJSQ0AIAYgCWsiCSAIaiIOIAlJIAogDklyDQACQAJAIAhBBUkEQCAJIAtqIAggDSAIEMEuRQRAIAMoAiAhBwwECyACIAlqQQFqIQICQCABQf8BcQ0AAkAgAkUNACACIARPBEAgAiAERg0BDAULIAIgBWosAABBv39MDQQLIAQgAmtBAkcNACACIAVqIgEtAABB3wFxQcEAa0H/AXFBGUsNACABLQABQTpGDQgLIAIgBEsNByACRSACIARPckUEQCACIAVqLAAAQb9/TA0CCyAAIAI2AggMBwsgCEEEQZSGxAAQsDsAC0GohcQAQTBBnJDEABCfKQALIAUgBCACIARBjJDEABCjNgALIAMgBjYCJCAGIApLDQAgBiAHTw0BCwtB/I/EABCyOwALIAUgBCACIARB7I/EABCjNgALIANBMGokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhCRECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDLJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ7w8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQ0CcgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgICAATcCNCACQTRqIgVBARCHLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDFGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGELYQIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDbLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIctCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEM4nIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhDwDyACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDRJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgMAANwI0IAJBNGoiBUEBEIYtIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMcbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ8Q8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENovDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhi0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzScgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgIDAADcCNCACQTRqIgVBARCGLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDHGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEO4PIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDaLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIYtCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEM8nIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAgAE3AjQgAkE0aiIFQQEQhy0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxRsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhDKECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2y8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCHLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDMJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQkhAgAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzCcgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgICAATcCNCACQTRqIgVBARCHLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDFGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEPIPIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDbLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIctCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABENInIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhC3ECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDNJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ8w8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzicgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgIDAADcCNCACQTRqIgVBARCGLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDHGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEMkQIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDaLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIYtCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEMsnIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuVBAEJfyMAQRBrIgckAAJAIANBCUkEQCACIQggACgCCCAAKAIYa0EDdCAAKAIcIgprIgUgAiADbE8NASADBEAgBSADbiEIDAILQZi3zgAQ4isAC0HIts4AQTBBiLfOABCfKQALAkACQAJAAkACQAJAAkAgCkUgCEVyDQADQCAHQQhqIAAgAxCQDSAHLQAIRQ0DIAIgBEYNAiABIARqIActAAk6AAAgBEEBaiIEIAhPDQEgACgCHA0ACwsgCCAEayILQQhJBEAgBCEFDAYLIAAoAggiDCAAKAIYIgZrIQkgACgCBCEKA0AgBEF3Sw0DIARBCGoiBSACSw0EIAYgDEsNBSAGIApqIAkgASAEaiADELQWIAAgAyAGaiIGNgIYIAkgA2shCSAFIQQgC0EIayILQQdLDQALDAULIAIgAkGYus4AEMMhAAtB/LjOAEEaQYi6zgAQyyQACyAEIARBCGpB7LfOABCxOwALIARBCGogAkHst84AELA7AAsgBiAMQfy3zgAQrzsACwJAAkAgBSAISQRAIAggBWshCSABIAVqIQYgBSACIAIgBUkbIgEgBWshBANAIAcgACADEJANIActAABFDQMgBEUNAiAGIActAAE6AAAgBEEBayEEIAZBAWohBiAJQQFrIgkNAAsLIAdBEGokACAIDwsgASACQai5zgAQwyEAC0H8uM4AQRpBmLnOABDLJAAL+kgCJn8BfiMAQRBrIhQkACAUQQA2AgQgFCADNgIIIBQgASgCuBMgASgCtBNrNgIMIAFBGGohBCABQbATaiEgIAFBtBNqIRsCQAJAAkADQAJAIBRBDGohGiABKAIAIRYgASgCBCESIBRBCGohHSAUQQRqIR5BACEFIwBB0ABrIgwkACAMIAQpA4gONwMoAkAgBCgC7BBBAEgNAAJAAkACQAJAAkACQCASIBsoAgAiFSAaKAIAIhhqTwRAIB0oAgAgHigCAGogA0sNASAEQYgOaiEiIAQoAtQPIghFBEAgBCAYNgKADkEBIQcgFSEFIBIhCSAWIQ0MBwtBCCEJQQIhByAMQShqIQ0gGEEIIAhrIgYgBiAYSxsiBkUNBiAGIAhqIgkgBkkNAiAJQQhLDQMgBiAVaiIJIAZJDQQgCSASSw0FIBUgFmohCSAGRSIKRQRAIAggDWogCSAG/AoAAAsgCkUEQCAIICJqIAkgBvwKAAALQQghCQwGCyAEQWw2AuwQDAYLIARBbDYC7BAMBQsgCCAJQcTX8wAQsTsACyAJQQhBxNfzABCwOwALIBUgCUHU1/MAELE7AAsgCSASQdTX8wAQsDsACyAEIAU2AvwNIARBqA9qISUgBEHgEGohHCAEQY4RaiEmIARB8A1qIRAgBEGID2ohJCAEQZgPaiEhIARBwA5qIScgBEGoDmohKCAEQZAOaiEpIARBkBNqISMDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQQFrDgIAAgELIAQtAIoRIQUDQEEBIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkADQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAVB/wFxQQFrDhgBAgMMBAUODg4ODxASERISFBUGBwgXGBkACyAEKAL4DUHAAEcNCCAQIA0gCRDLIA0IDDALIBBBBiAcIA0gCRDtH0UNLyAcKAIAQR9rQWtPDQhBcyEHDDALIARBASAEKALgEHRBEGsiBTYC3A8gBCAFIAQoAtwQazYC4A8gDEE0aiIFQagZEPcbIAxBCGogBUHUqPsAEJYhIAwoAgwhBSAMKAIIIQYgBCgCjA8iCARAICQoAgAgCEECdEECEPg6CyAEIAU2AowPIAQgBjYCiA8gBQ0IQWIhBwwvCyMAQTBrIgUkACAEQYCAgAg2ArAPIARCgICAiICAgIABNwOoDyAEQQA2AogQIARCATcCxA8gBEIBNwK8DyAEQgE3ArQPIARBATYCoA8gBEKBgICAEDcDmA8gBUEANgIsIAVCgICAgBA3AiQgBUEYaiAFQSRqQfSo+wAQkCEgBCgC/A4hBiAEKAL4DiEIIAQgBSkDGDcD+A4gBgRAIAggBkEBEPg6CyAFQQA2AiwgBUKAgICAEDcCJCAFQRBqIAVBJGpB9Kj7ABCQISAEKAKEDyEGIAQoAoAPIQggBCAFKQMQNwOADyAGBEAgCCAGQQEQ+DoLIAVBADYCLCAFQoCAgIAQNwIkIAVBCGogBUEkakH0qPsAEJAhIAQoAuQOIQYgBCgC4A4hCCAEIAUpAwg3A+AOIAYEQCAIIAZBARD4OgsgBEIANwL0DyAEQQA7AYQRIARBxKv7ADYC6BAgBEGQDmogBEGEEWoiBhCAGiAEQagOaiAGEIAaIARBwA5qIAYQgBogBUEwaiQAQQQhBSAEQQQ6AIoRDA8LIAxBADYCTCAQQQYgDEHMAGogDSAJEO0fRQ0sIAQgDCgCTCIGQQNxIgU2AowQIAQgBkECdiAFdEEQajYCkBAgBCAFQQJ0Qfic8wBqKAIANgKUECAMQTRqIgUgBCgCmA9BxKj7ABDOGCAMQRBqIAVB1Kj7ABCQISAMKAIUIQUgDCgCECEGIAQoAoQPIggEQCAEKAKADyAIQQEQ+DoLIAQgBTYChA8gBCAGNgKADyAFDQhBayEHDC0LIwBBEGsiByQAAkACQCAEKAKYDyIFIAQoAtAPIgtPBEAgBSAEKAKEDyIGSw0BQQEhBiAFIAtGDQIgBCgCgA8hCCAEQfANaiEKA0AgB0EANgIMIApBAiAHQQxqIA0gCRDtH0UEQCAEIAs2AtAPQQIhBgwECyAIIAtqIAcoAgw6AAAgBSALQQFqIgtHDQALDAILIAsgBUG0p/MAELE7AAsgBSAGQbSn8wAQsDsACyAHQRBqJAAgBkEBRw0rQRUhBQwfCyAEKALQDyEHIAxBADYCPCAMQoCAgIAgNwI0IAxBIGogDEE0akH0qPsAEJYhIAQoApQPIQUgBCgCkA8hBiAEIAwpAyA3A5APQRpBGiAGIAUgB0G4CGxBACAEIA0gCRD3CCEHIAQoApQPIQggBCAFNgKUDyAEKAKQDyEFIAQgBjYCkA8gCARAIAUgCEECdEECEPg6CyAHQQFHDStBFCEFDB4LIAQoAtAPIQUgDEEANgJMIAQoApQPIgYgBUG4CGwiBUkNEgJ/IAQtAMwPBEBBASEFIAQoAqQPDAELIAQoApAPIAxBADYCNCAFQQJ0aiAGIAVrIBAgDEE0aiANIAkQnxMhBSAMKAI0QQAgBRsLIQYgJCAQIAxBzABqIAUgBiANIAkQ1BsEfyAEKALQDyIFQQNPDQ8gJSAFQQJ0aiAMKAJMNgIAIARBEToAihEgBCAEKALQD0EBajYC0A8gBwVBAgshBwwqCyAEKAKYD0EGdEEAIAQgDSAJEKEMIgdBAUcNKUEAIQggBEIANwPADSAEQdgNakIANwMAIARB0A1qQgA3AwAgBEHIDWpCADcDAAJAAkACQAJAAkACQAJAIAQoApgPIgoEQCAEQcANaiEfA0AgCEEGdCIPIAQoAvwOIgVPDQcgBCgC+A4iByAPai0AACEOQQAhEUF8IQsDQCALQQRqIgsgD3IiBiAFTw0DIAZBAXIiEyAFTw0EIAZBAnIiFyAFTw0FIAZBA3IiGSAFTw0GIBEgByATai0AACAOcyAGIAdqLQAAIA5zciAHIBdqLQAAIA5zciAHIBlqLQAAIA5zcnIhESALQTxJDQALIBFFBEAgCEEFdiEFIAhB/wFLDQcgHyAFQQJ0aiIFIAUoAgBBASAIdHI2AgAgBCgCmA8hCgsgCEEBaiIIIApJDQALCwwGCyAGIAVB9KTzABDDIQALIBMgBUGEpfMAEMMhAAsgFyAFQZSl8wAQwyEACyAZIAVBpKXzABDDIQALIAVBCEHkpPMAEMMhAAsgDyAFQdSk8wAQwyEAC0EWIQUMHAsCfyAjLQAAIQYgI0EAOgAAQQEhDiAQIBAoAggiBUEBaiIHNgIIAkAgECkDACIqIAVBP3GtiKdBAXFFBEAgHEEQNgIADAELIBAgBUEEaiIINgIIICogB0E/ca2Ip0EHcSIHBEAgHCAHQRFqNgIAQQEMAgsgECAFQQdqIgc2AggCQAJAAkAgKiAIQT9xrYinQQdxIggOAgEAAgtBcyEOIAZBAXFFDQIgECAFQQhqNgIIICogB0E/ca2Ip0EBcQ0CICNBAToAAEEBDAMLIBxBETYCAEEBDAILIBwgCEEIcjYCAEEBDAELIA4LIgdBAUcNKEEBIQcgBEEBQQIgBC0AkBMbIgU6AIoRDAkLQQIhBSAEQQI6AIoRDAgLIAxBNGoiBUGoGRD3GyAMIAVB1Kj7ABCWISAMKAIEIQYgDCgCACEIIAQoApQPIgUEQCAEKAKQDyAFQQJ0QQIQ+DoLQQMhBSAEQQM6AIoRIAQgBjYClA8gBCAINgKQDwwHCyMAQRBrIgUkACAFQQA2AgwgBEHwDWohByAELQCLESELAn8DQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgC0H/AXFBAWsOBwELAgcDBQQACyAHQQEgBUEMaiANIAkQ7R8NCQwMCyAHQQEgBUEMaiANIAkQ7R9FDQsgBSgCDA0HQQIhCwwKCyAEKALQDyIKIAQtAIkRSA0FQQQhCwwJCyAHQQEgBUEMaiANIAkQ7R9FDQkgBSgCDEUNAkF+DAsLQQQhCyAEKALQDyIKIAQtAIkRTg0HIApBA3QhBgNAIAdBCCAFQQxqIA0gCRDtH0UEQCAEIAo2AtAPDAoLQX0gBSgCDCIOIAQtAIkRIghBAkkgCCAKQQFqIgpHcnJFDQsaIAQgBCgCiBAgDiAGQRhxdHI2AogQIAZBCGohBiAIIApKDQALDAcLQQIgB0ECIAVBDGogDSAJEO0fRQ0JGiAFKAIMIgZFBEAgBEEAOgCLEUEBDAoLIAQgBjoAiRFBByELDAYLQQYhCwwFCyAELQCGESAELQCIEXJFBEAgB0EBIAVBDGogDSAJEO0fRQ0GIAQgBSgCDDoAhxELIARBADoAixEgBCAEKAKIEEEBajYCiBBBAQwHCyAKQQJ0IQYDQCAHQQQgBUEMaiANIAkQ7R9FBEAgBCAKNgLQDwwGC0F/IAUoAgwiDiAELQCJESIIQQVJIAggCkEBaiIKR3JyRQ0HGiAEIAQoAogQIA4gBkEccXRyNgKIEEEEIQsgBkEEaiEGIAggCkoNAAsMAwsgBEEAOgCLEUEBDAULIAQgBS0ADCIGOgCGESAEQQA7AIcRIARBADYCiBBBAUECIAYbIQsMAQtBAiAHQQIgBUEMaiANIAkQ7R9FDQMaIARBADYC0A8gBCAFKAIMIgZBBGo6AIkRQQMhCyAGQQNHDQAgBEEBOgCIEUEFIQsLIAQgCzoAixEMAQsLQQILIQcgBUEQaiQAIAdBAUcNJSAELQCIESIIIAQtAIcRIgpyBEBBACAEKAL4DSIFa0EHcSIGBEAgBCAFIAZqNgL4DUFxIQcgBkECdEGEqfsAaigCACAEKQPwDSAFQT9xrYincQ0nCyAIDQ8LIAQoAogQRQ0XIAQoAtwOBH8gCgVBZSEHAn8jAEEgayIPJAAgBEEBIAQoAuAQdCIGNgLoDyAELQCGESEKIAQtAIcRBEBBASAKAn8gBCgCiBAhBUHAACAEQfANaiIIKAIIIg5rIgtBB3FFBEACQAJ/IAtBA3YiCyAFTQRAQX8gBSALayIFIAgoAhBPDQEaIAgoAgwgBWoiBSAJTw0CIAUgDWotAAAMBAsgCCkDACAOQT9xrYggBUEDdEE4ca2Ip0H/AXELDAILIAUgCUHIqvsAEMMhAAtB2Kr7AEErQYSr+wAQnykACyIFQQNxQQNGGyAKIAVBf0cbIQoLIAQoAvQOIQgCQAJAAkACQAJAAkACQAJAIAQoAtwQIg4gBkEQayIFTQRAIAggDkkNAiAEKALwDiELDAELIAggDkkNAiAEIAU2AtwQIAQoAvAOIA4gBWtqIQsgBSEOCwJAIApB/wFxRSAGQSFIcg0AIAYgBCgCiBAgDmpBAXRBIGoiCkgNACAGIQUDQAJAIAVBAXYhCCAFQcIASQ0AIAgiBSAKTg0BCwsgBCAIIAYgBiAIShsiBjYC6A8LIAQgBkEBayIINgLsDyAPQRRqIgUgBkHCAGpBxKj7ABDOGCAPQQhqIAVB1Kj7ABCQISAPKAIMIQUgDygCCCEGIAQoAtwOIgoEQCAEKALYDiAKQQEQ+DoLIAQgBTYC3A4gBCAGNgLYDgJAIAVFDQAgBSAITQ0DIAYgCGpBADoAACAEKALoD0ECayIIIAQoAtwOIgZPDQQgCCAEKALYDiITakEAOgAAAkAgDkUNACAEKALsD0EAIAQoAtwQIghrcSIKIAhqIhEgCkkNBiAGIBFJDQcgCCAORw0IIA5FDQAgCiATaiALIA78CgAACyAEKAL0DiIGRQ0AIA9BADYCHCAPQoCAgIAQNwIUIA8gD0EUakH0qPsAEJAhIAQoAvAOIAQgDykDADcD8A4gBkEBEPg6CyAPQSBqJAAgBUEARwwHCyAOIAhB1KbzABCwOwALIA4gCEHkpvMAELA7AAsgCCAFQfSm8wAQwyEACyAIIAZBhKfzABDDIQALIAogEUGUp/MAELE7AAsgESAGQZSn8wAQsDsACyAIIA5BpKfzABCzOwALRQ0mIAQtAIcRC0H/AXFFBEAgBEEROgCKESAEQQA2AtAPQQEhBwwmCyAEQQs6AIoRQQEhBwwlC0EGIQUgBEEGOgCKESAEQQA2AtAPDAULQQAgBCANIAkQqgEiB0ECRw0jQQEgBCANIAkQqgEhBwwjCwJ/IwBBEGsiEyQAIARB8A1qIREgBC0AlBMhCwJAAkADQAJAAkAgC0EBcQRAIBNBBGogHSACIAMgHiAgQQAgBBCSDiATKAIEIgtBAUcNBEEAIQsgBCgC6A9BASAEKALgEHRHDQEgBCAEKALcDzYC5A8MAQsgBCgC3A4iBSAEKALYDyIGSQ0EIAQoAtgOIAZqIRkgBSAGayELQQAhBUEAIQcCQCAEKALoDyIIIAZrIAQoAoAOQcAAIAQoAvgNa0EDdmoiCiAEKAKIECIOIAogDkgbIgogBiAKaiAIShsiFyIIRQ0AIBEoAggiBkHBAGtBd0sNACAIQQFrIQ4gESkDACEqAkADQCAHIAtHBEAgESAGQQhqIgo2AgggByAZaiAqIAZBP3GtiDwAACAHQQFqIQUgBkE5a0F3Sw0CIAcgDkcgBSEHIAohBg0BDAILCyALIAtBtKv7ABDDIQALIAggBWshCAsgESgCDCEOAkACQAJAIAgEQCAOIAkgCSAOSxshByAFIAsgBSALSRshBiAIIQ8gDiEKA0AgByAJRg0DIAYgC0YNAiAFIBlqIAogDWotAAA6AAAgCkEBaiEKIAdBAWohByAGQQFqIQYgBUEBaiEFIA9BAWsiDw0ACwsgESAIIA5qNgIMIBEgESgCECAIazYCEAwCCyAFIAtBpKv7ABDDIQALIAogCUGUq/sAEMMhAAsgBCAXIAQoAtgPaiIFNgLYDyAEIAQoAogQIgYgF2s2AogQQQEhCyAFQQEgBCgC4BB0SA0BCyAEIAs6AJQTDAELC0EBQQIgBiAXRhshCwsgE0EQaiQAIAsMAQsgBiAFQcSm8wAQrzsACyIHQQFHDSIMFAsgBCgCiBBBAEwNEgNAIAxBADYCNCAQQQggDEE0aiANIAkQ7R9FDSEgBCAEKAKIEEEBayIFNgKIECAFQQBKDQALDBILIAQQyhMgBC0AhhFFDRACQEEAIAQoAvgNIgZrQQdxIghFBEAgBiEFDAELIAQgBiAIaiIFNgL4DUFxIAcgCEECdEGEqfsAaigCACAEKQPwDSAGQT9xrYincRshBwsgBCgC1A9FBEAgBEHAACAFayIGQQN2IgggBCgCgA5qIhg2AoAOIAQgBCgC/A0gCGsiFTYC/A0gBCAFIAZBeHEiCGo2AvgNIBogGDYCACAbIBU2AgAgBCAEKQPwDSAGQThxrYZCACAIQcAARxs3A/ANC0EYIQUgBEEYOgCKEQwBCwsgDEE0aiAdIAIgAyAeICBBACAEEJIOIAwoAjQiB0EBRw0eIwBBIGsiBSQAAkACQAJAAkAgBC0AkRMEQCAEKALcDiIIIAQoAugPIgZJDQEgBCgC2A8iByAGSw0CIAcgCCAGa0sNAyAHBEAgBCgC2A4iCCAGIAhqIAf8CgAACyAEQQA6AJETCyAFQSBqJAAMAwsgBUEANgIYIAVBATYCDCAFQfCc8wA2AgggBUIENwIQIAVBCGpBlKbzABDvLAALIAVBADYCGCAFQQE2AgwgBUHwnPMANgIIIAVCBDcCECAFQQhqQaSm8wAQ7ywACyAFQQA2AhggBUEBNgIMIAVB8JzzADYCCCAFQgQ3AhAgBUEIakG0pvMAEO8sAAsgBCgC6A9BASAEKALgEHRGBEAgBCAEKALcDzYC5A8LAkACQAJAIAQtAIoRQQ9rDgIAAQILQQEhByAEQQ5BByAEKAKIEEEATBs6AIoRDCALIARBCjoAihFBASEHDB8LIAQoAtAPRQ0NIARBCDoAihFBASEHDB4LIAQoAtAPIgVBAkoNByAFQQNPDQhBAiEHICYgECAhIAVBAnRqIA0gCRDuE0EBRw0dIAQoAtAPIgVBAksNCSAhIAVBAnRqIgUgBSgCAEEBajYCACAEKALQDyIFQQNPDQogISAFQQJ0aigCAEECTwRAQRIhBQwRC0EBIQcgBCAFQQFqNgLQDwwdCyAEKALQDyEIIAxBADYCPCAMQoCAgIAgNwI0IAxBGGogDEE0akH0qPsAEJYhIAQoAowPIQUgBCgCiA8hBiAEIAwpAxg3A4gPIAQoAtAPIgdBA0kNCiAHQQNBlNjzABDDIQALIAVBA0G02PMAEMMhAAsgBCgCkBAiBkE+QRggBC0AkBMiCBsgBCgCjBAiB0EBanRqIgohBSAIBEAgBkEQayEFIwBBIGsiBiQAIAZCjICAgMADNwIIIAZCgICAgMAANwIAIAZC5IGAgIA1NwIYIAZCyYCAgOAPNwIQAkAgB0EDTQRAQQEgB3QhCCAGIAdBAnQiB2ooAgAiDiAFTQRAIAZBEGogB2ooAgAhByAIIA5qIgggBU8EQCAHIAhqIQUMAwsgBSAHaiEFDAILIAZBEGogB2ooAgAgBSAIamohBQwBCyAHQQRBtNfzABDDIQALIAZBIGokAAsgBCgCoA9BAnRBASAEIA0gCRChDCIHQQFHDRogKUGAAkGAAiAEKALkEBDeFiAoQcAFQcAFIAQoApwPEN4WICcgCiAFIAQoApgQEN4WAkACQCAEKAKcDkUNACAEKAK0DkUNACAEKALMDg0BCyAEQWE2AuwQQQAhBQwcC0EXIQUgBEEXOgCKESAEQQA2AtAPDA4LAn8gBCgC0A8hGUEAIQgjAEFAaiIHJAACQAJAAkACQAJAIBlBAk0EQCAHQQA2AjwgB0KAgICAIDcCNCAHQShqIAdBNGoiBkH0qPsAEJYhIAQgGUEYbGoiBSgCnA4hESAFKAKYDiETIAUgBykDKDcDmA4gB0EANgI8IAdCgICAgMAANwI0IAdBIGogBkH0qPsAEJghIAUoApQOIQogBSgCkA4hFyAFIAcpAyA3A5AOIAUvAaIOIR8gBS8BpA4hBiAFLwGgDiEFIAQtAJMTRQ0CIAQoAsQQIgggBksNAQwDC0FhIQ8gBEFhNgLsEAwDCyAIIAZB6KLzABCxOwALIARBAToAkxMgBEIANwLEEAsgBiAKSw0BQQEhDwJAIAYgCEYNACAGQQJ0IAhBAnQiBmshCCAGIBdqIQ4gBCgCyBAhCwNAIAdBADYCNCAFIB8gEyARIAsgB0E0aiAEIA0gCRD3CCIPQQFHDQEgDiAEKALIECIGNgIAIAQgBiAHKAI0aiILNgLIEEEBIQ8gBCAEKALEEEEBajYCxBAgDkEEaiEOIAhBBGsiCA0ACwsgB0EANgI8IAdCgICAgCA3AjQgB0EYaiAHQTRqQfSo+wAQliEgBygCHCEOIAcoAhgCQAJAAkACQAJAIBkOAgABAgsgBCgCnA4hBSAEIBE2ApwOIAQoApgOIQYgBCATNgKYDiAFBEAgBiAFQQJ0QQIQ+DoLIAdBADYCPCAHQoCAgIDAADcCNCAHQQhqIAdBNGpB9Kj7ABCYISAHKAIMIQsgBygCCCEGIAQoApQOIQggBCAKNgKUDiAEKAKQDiEFIAQgFzYCkA4gCA0CDAMLIAQoArQOIQUgBCARNgK0DiAEKAKwDiEGIAQgEzYCsA4gBQRAIAYgBUECdEECEPg6CyAHQQA2AjwgB0KAgICAwAA3AjQgB0EQaiAHQTRqQfSo+wAQmCEgBygCFCELIAcoAhAhBiAEKAKsDiEIIAQgCjYCrA4gBCgCqA4hBSAEIBc2AqgOIAgNAQwCCyAEKALMDiEFIAQgETYCzA4gBCgCyA4hBiAEIBM2AsgOIAUEQCAGIAVBAnRBAhD4OgsgB0EANgI8IAdCgICAgMAANwI0IAcgB0E0akH0qPsAEJghIAcoAgQhCyAHKAIAIQYgBCgCxA4hCCAEIAo2AsQOIAQoAsAOIQUgBCAXNgLADiAIRQ0BCyAFIAhBAnRBBBD4OgsgD0EBRgRAIARBADoAkxMLIAsEQCAGIAtBAnRBBBD4OgsgDkUNACAOQQJ0QQIQ+DoLIAdBQGskACAPDAELIAYgCkHoovMAELA7AAsiB0EBRw0ZQQEhByAEIAQoAtAPQQFqIgU2AtAPIAVBA0gNGSAEELEZIARBBzoAihEgBEEAOwHwECAEQQA2AvgPDBkLAkAgBCgC3A4EQCAMQTRqIB0gAiADIB4gIEEBIAQQkg4gDCgCNCIHQQFHDRogBEEBNgLsEAwBCyAEIAc2AuwQQQAhBSAHQQFHDRoLQQEhBQwZCyAFIAZBpNjzABCvOwALIARBDDoAihFBASEHDBYLIARBBToAihEMFQsgBUEDQeTX8wAQwyEACyAFQQNB9NfzABDDIQALIAVBA0GE2PMAEMMhAAsgISAHQQJ0aigCAEECaiIHIAcgBiAFIAhBuAhsQQAgBCANIAkQ9wghByAEKAKMDyEIIAQgBTYCjA8gBCgCiA8hBSAEIAY2AogPIAgEQCAFIAhBAnRBAhD4OgsgB0EBRw0RQRMhBQwEC0EBIQcgBEEOQQkgBCgCiBBBAEwbOgCKEQwQCyAEQQM6AIoRDA8LIAdBAUcNDgsgBEEOOgCKEUEBIQcMDQsgBCAFOgCKEQwACwALIAQoAtQPBEAgBEEANgLUDwwCCyAQQcAAIBAoAggiCWsiBUEDdiINIBAoAhBqNgIQIBAgECgCDCANazYCDCAQIAkgBUF4cSINajYCCCAQIBApAwAgBUE4ca2GQgAgDUHAAEcbNwMAIBogBCgCgA42AgAgGyAEKAL8DTYCAAwBCyAEKALcDgRAIAxBNGogHSACIAMgHiAgQQEgBBCSDiAMKAI0IgdBAEgNAQsgBCgC1A8iBUUEQCAbIAQoAvwNIg02AgACQCAEKAKADiIGBEAgDSASIA0gEksbIQhBACEHIAYhCSANIQUDQCAFIAhGDQUgB0EITw0CIAcgImogBSAWai0AADoAACAbIAVBAWoiBTYCACAEIAQoAtQPQQFqIgc2AtQPIAlBAWsiCQ0ACwsgGkEANgIADAkLIBogCTYCACAHQQhB1NjzABDDIQALIAQoAoAORQ0GIBhFDQcgEiAVTQ0CIAwgFSAWai0AACIGOgAzIAVBCE8NAyAFICJqIAY6AAAgBCgC1A8iBUEITw0EIAYgDEEoaiAFaiIHLQAARw0FQQEhByAEIAVBAWoiBTYCgA4gBCAFNgLUDyAbIBVBAWoiFTYCACAaIBhBAWsiGDYCAAwJCyAEIAc2AuwQQQNBACAHQQNGGyEFDAkLIBogBiANaiAIazYCACAIIBJBxNjzABDDIQALIBUgEkHk2PMAEMMhAAsgBUEIQfTY8wAQwyEACyAFQQhBhNnzABDDIQALIAxBADYCNCMAQRBrIgAkACAAIAxBM2o2AgwgACAHNgIIQQAgAEEIakHkqPsAIABBDGpB5Kj7ACAMQTRqQZTZ8wAQ5g8ACyAEIBg2AoAOIARBADYC1A8gBCAVNgL8DUEBIQcgEiEJIBYhDQwCC0ECIQUgBEECNgLsEAwCC0ECIQcMAAsACyAMQdAAaiQAIAVBAkcEQAJAAkACQCAFQQFrDgMCAAQBCwALIAEpAxAhKiABQQQ6ABAgAEIEICogKkL+AYNCBFEbNwIADAYLIBQoAgQiAkUNAwwECyMAQSBrIgUkAAJAAkACQCABKAIEIhIgASgCtBMiCUcEQCAJQYACaiASTSABKAK4EyAJayINIAlPcg0DIAkgEksNASABKAIAIRYgASANNgK4EyANIBIgCWsiEksNAiAWIA0gCSAWaiANQayg0AAQ1SwgAUEANgK0EwwDCyABQgA3ArQTDAILIAVBADYCGCAFQQE2AgwgBUH4oNAANgIIIAVCBDcCECAFQQhqQYyg0AAQ7ywACyANIBJBnKDQABCwOwALIAVBIGokACAUKAIEIgUEQCAAQQQ6AAAgACAFNgIEDAULAkAgASgCBCISIAEoArgTIgVPBEAgASgCACAFaiEWIAEoAgghCSABKAIMIg0gEiAFayIFIAUgDUsbIgVBAUYEQCAWIAktAAA6AAAgASANQQFrNgIMIAEgCUEBajYCCAwCCyAFBEAgFiAJIAX8CgAACyABIA0gBWs2AgwgASAFIAlqNgIIIAUNASABKQMQISogAUEEOgAQIABCBCAqICpC/gGDQgRRGzcCAAwGCyAFIBJB8J/QABCvOwALIAEgASgCuBMgBWoiBTYCuBMgFCAFIAEoArQTazYCDCAUKAIIIANGDQELCyAAIBQoAgQ2AgQgAEEEOgAADAILIAEtALwTRQRAIAFBAToAvBMMAQsgASgCuBMgASgCtBNGDQAgASkDECEqIAFBBDoAECAAQgQgKiAqQv4Bg0IEURs3AgAMAQsgAEEEOgAAIAAgAjYCBAsgFEEQaiQAC8ECAQF/IwBBQGoiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCDCACIABBA3YiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkEDdGorAwA5AxAgBEEQaiADEJAgIARBQGskAA8LIAQgADYCLCAEQQI2AhQgBEG4l4QBNgIQIARCAjcCHCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCGCAEIARBLGo2AjggBCAEQQxqNgIwIARBEGpByJeEARDvLAAL/wMBCX8CQCABKAIEIgggASgCACIGRgRAQQIhBwwBCyAIIAZrIQQgAUEIaiEKIAYhAgJAA0AgASACQQFqIgU2AgACQCACLQAAIgPAQQBODQAgASACQQJqIgU2AgAgAi0AAUE/cSEJIANBH3EhByADQd8BTQRAIAdBBnQgCXIhAwwBCyABIAJBA2oiBTYCACACLQACQT9xIAlBBnRyIQkgA0HwAUkEQCAJIAdBDHRyIQMMAQsgASACQQRqIgU2AgAgB0ESdEGAgPAAcSACLQADQT9xIAlBBnRyciEDC0EAIQcCQAJAAkACQCADQSJMBEAgA0ENRyADQQlrQQJPcQ0DIAUgCEF/c2oiAiAEaiIBDQEMBAsgA0EjRg0BIANBgIDEAEYNBQwCCwJAIAEgBE8EQCACRQ0EDAELIAEgBmosAABBv39KDQMLIAYgBEEAIAFBzJPEABCjNgALIAEtABBBAUcNAEEBIQcCQCAFIAhBf3NqIgIgBGoiAUUNAAJAIAEgBE8EQCACRQ0CDAELIAEgBmosAABBv39KDQELIAYgBEEAIAFB3JPEABCjNgALIAEhBAwDCyAKKAIABEAgCkHsk8QAIAMgARCQDCABKAIEIQggASgCACEFCyAFIgIgCEcNAQwCCwsgASEECyAAIAQ2AgQgACAGNgIACyAAIAc6AAgLowQCCH8BfiMAQSBrIgckAAJAIANFBEAMAQsgAUEQaiEIA0AgAiAFaiELIAMgBWshCQJAAkAgASgCNCIKDQAgASgCOCEEAkACQAJAAkADQCAERQRAIAgoAgBFDQIgByAIEKUYIAcoAgBBAUcNCSAHKQMIIgxQDQkgDEIBg1BFBEAgASAMp0ECdEF4cTYCOAwICyABIAxCAYg+AjQgB0EQaiAIIAEtADwiBEEDdiAEQQdxQQBHahDBHCAHKQMQIQwgASAHKQMYNwMIIAEgDDcDACAMpw0HQcD6zABBLkHw+swAEJ8pAAsgCCgCAEUNAiAEIAkgBCAJSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAggCyAEIAEtADwQoQsiBEUEQEEAIQQgAUEANgI4IAEoAjQiCkUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgCiAJIAkgCksbIgYgBWoiBCAGTwRAIAMgBEkNASAGRSADIAVGckUEQCALIAEtAAhBAEcgBvwLAAsgASAKIAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAALmAQBCH8CQCADQQlJBEAgAiEHIAAoAgggACgCGGtBA3QgACgCHCIJayIFIAIgA2xPDQEgAwRAIAUgA24hBwwCC0GYt84AEOIrAAtByLbOAEEwQYi3zgAQnykACwJAAkACQAJAAkACQAJAAkAgCUUgB0VyDQADQCAAIAMQ0w1B/wFxIgVBAkYNAyACIARGDQIgASAEaiAFOgAAIARBAWoiBCAHTw0BIAAoAhwNAAsLIANBAUsNAiAHIARrIgpBCEkEQCAEIQUMBwsgACgCCCILIAAoAhgiBmshCCAAKAIEIQkDQCAEQXdLDQQgBEEIaiIFIAJLDQUgBiALSw0GIAYgCWogCCABIARqIAMQtBYgACADIAZqIgY2AhggCCADayEIIAUhBCAKQQhrIgpBB0sNAAsMBgsgAiACQZi6zgAQwyEAC0H8uM4AQRpBiLrOABDLJAALQay3zgBBLUHct84AEJ8pAAsgBCAEQQhqQey3zgAQsTsACyAEQQhqIAJB7LfOABCwOwALIAYgC0H8t84AEK87AAsCQAJAIAUgB0kEQCAHIAVrIQggASAFaiEGIAUgAiACIAVJGyIJIAVrIQQDQCAAIAMQ0w1B/wFxIgFBAkYNAyAERQ0CIAYgAToAACAEQQFrIQQgBkEBaiEGIAhBAWsiCA0ACwsgBw8LIAkgAkGouc4AEMMhAAtB/LjOAEEaQZi5zgAQyyQAC8EEAQV/IwBBkANrIgQkACAEQfwBaiADQQhqKAIANgIAIARCBDcC7AEgBEIANwLkASAEQoCAgIDAADcC3AEgBEEANgLUASAEQQA7AawCIARBADYCqAIgBEEANgKQAiAEQQA2AoQCIAQgAykCADcC9AEgBCABKAIIQQFrNgKAAiAEQYADaiIFIAEQ4CwgBCAEKQKAAzcChAEgBEEANgKAASAEIAQoAowDIgY2AnwgBCAEKAKIAzYCeCAEQRBqIARB+ABqIggQ1zsgBCgCECEHAkBBHEEEEK02IgMEQCADQoGAgIAQNwIAIAMgBCkCeDcCCCADQRBqIARBgAFqKQIANwIAIANBGGogBEGIAWooAgA2AgAgBCAGNgK4AiAEIAc2ArQCIAQgAzYCsAIgCCAEQdQBaiIDIARBsAJqIgYQ+iMgBSABQQxqEPIvIAQgBCkCgAM3AuABIARBADYC3AEgBCAEKAKMAyIFNgLYASAEIAQoAogDNgLUASAEQQhqIAMQ1zsgBCgCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAEKQLUATcCCCABQRBqIARB3AFqKQIANwIAIAFBGGogBEHkAWooAgA2AgAgBCAFNgK4AiAEIAc2ArQCIAQgATYCsAIgAyAIIAYQ+iMgBEEcaiIBIAMgAhCuFiAEQbwCaiICIAEQzRwgBCACEKABIAQoAgQhASAAIAQoAgA2AgAgACABNgIEIARBkANqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC8EEAQV/IwBBkANrIgQkACAEQfwBaiADQQhqKAIANgIAIARCBDcC7AEgBEIANwLkASAEQoCAgIDAADcC3AEgBEEANgLUASAEQQA7AawCIARBADYCqAIgBEEANgKQAiAEQQA2AoQCIAQgAykCADcC9AEgBCABKAIIQQFrNgKAAiAEQYADaiIFIAEQ3iwgBCAEKQKAAzcChAEgBEEANgKAASAEIAQoAowDIgY2AnwgBCAEKAKIAzYCeCAEQRBqIARB+ABqIggQ1zsgBCgCECEHAkBBHEEEEK02IgMEQCADQoGAgIAQNwIAIAMgBCkCeDcCCCADQRBqIARBgAFqKQIANwIAIANBGGogBEGIAWooAgA2AgAgBCAGNgK4AiAEIAc2ArQCIAQgAzYCsAIgCCAEQdQBaiIDIARBsAJqIgYQ+iMgBSABQQxqEPIvIAQgBCkCgAM3AuABIARBADYC3AEgBCAEKAKMAyIFNgLYASAEIAQoAogDNgLUASAEQQhqIAMQ1zsgBCgCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAEKQLUATcCCCABQRBqIARB3AFqKQIANwIAIAFBGGogBEHkAWooAgA2AgAgBCAFNgK4AiAEIAc2ArQCIAQgATYCsAIgAyAIIAYQ+iMgBEEcaiIBIAMgAhCuFiAEQbwCaiICIAEQzRwgBCACEKABIAQoAgQhASAAIAQoAgA2AgAgACABNgIEIARBkANqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC6wEAQp/IwBBMGsiBSQAAkACQAJAAkACQAJAIAEoAggiBCABKAI0IgNrIgYgAiACIAZLGyIGIANqIgIgBk8EQCACIARLDQEgAiABKAIUIgRLDQIgBUEMaiADQQJ0IgMgASgCBGoiBCAEIAZBAnQiB2ogASgCECADaiIDIAMgB2oQiygCQCAFKAIgIgQgBSgCHCIDSwRAIAEoAiwhCSABKAIoIQwgBCADayEKIAFBGGohCyADQQJ0IgMgBSgCFGohAiAFKAIMIANqIQMgASgCOCEEA0AgASgCLCAEIAIoAgAiBGpJDQIgCyADKAIAEPQ0IAEoAjgiByAEaiIIIAdJDQYgCCAJSw0HIAsgByAMaiAEEKE2IAEgASgCOCAEaiIENgI4IAJBBGohAiADQQRqIQMgCkEBayIKDQALIAEoAjQgBmohAgsgACAGNgIEIAEgAjYCNCAAQQg2AgAMBwsgBUEkakEXQQBBAUEBEKAYIAUoAighAiAFKAIkQQFGDQUgBSgCLCIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMBgsgAyACQeSGzQAQsTsACyACIARB5IbNABCwOwALIAIgBEH0hs0AELA7AAsgByAIQYSHzQAQsTsACyAIIAlBhIfNABCwOwALIAIgBSgCLEHU/cwAEP0vAAsgBUEwaiQAC6UKAhF/BH4jAEEQayIMJAAgDCACNwMIIAFBEGoiBiAMQQhqEI0OIRcgASgCCEUEQCMAQdAAayIFJAAgBSAGNgIcIAEoAgwhDSAFIAVBHGo2AiACQAJAIA0gDUEBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAn8gB0EBaiIHIAYgBiAHSRsiBkEPTwRAIAZB/////wFLDQVBfyAGQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBkEISRsgBkEESRsLIQYgBUFAayABQRBqIghBEEEIIAYQnRQgBSgCRCEHIAUoAkAiCUUEQCAFKAJIIQYMBQsgBSkCSCEWIAdBCWoiBgRAIAlB/wEgBvwLAAsgBSAWQiCIPgI8IAUgFqciEDYCOCAFIAc2AjQgBSAJNgIwIAVCkICAgIABNwIoIAUgCDYCJCAFQTBqIREgBSANBH8gCUEIaiESIAEoAgAiDykDAEJ/hUKAgYKEiJCgwIB/gyEWQQAhBgNAIBZQBEADQCAGQQhqIQYgD0EIaiIPKQMAQoCBgoSIkKDAgH+DIhZCgIGChIiQoMCAf1ENAAsgFkKAgYKEiJCgwIB/hSEWCyAJIAcgBSgCHCABKAIAIBZ6p0EDdiAGaiITQQR0a0EQaxCNDqciFHEiCGopAABCgIGChIiQoMCAf4MiGFAEQEEIIQoDQCAIIApqIQggCkEIaiEKIAkgByAIcSIIaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgFkIBfSAWgyEWIAkgGHqnQQN2IAhqIAdxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogFEEZdiIKOgAAIBIgCEEIayAHcWogCjoAACAJIAhBf3NBBHRqIgggASgCACATQX9zQQR0aiIKKQAANwAAIAhBCGogCkEIaikAADcAACANQQFrIg0NAAsgASgCDAVBAAsiBjYCPCAFIBAgBms2AjggASARQQQQ+iogBUEkahDQJgwBCyABIAVBIGpBpPT+AEEQEMUJC0GBgICAeCEHDAILEOMnIAUoAgwhBiAFKAIIIQcMAQsQ4ycgBSgCFCEGIAUoAhAhBwsgDCAGNgIEIAwgBzYCACAFQdAAaiQACyABKAIEIgcgF6dxIQUgF0IZiCIYQv8Ag0KBgoSIkKDAgAF+IRkgASgCACEGA0ACfwJAAkACQCAFIAZqKQAAIhcgGYUiFkJ/hSAWQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhZQRQRAA0AgAiAGIBZ6p0EDdiAFaiAHcUEEdGsiCUEQaykDAFENAiAWQgF9IBaDIhZQRQ0ACwsgF0KAgYKEiJCgwIB/gyEWIA5FBEAgFlANAyAWeqdBA3YgBWogB3EhCwtBASAWIBdCAYaDUA0DGkEAIQUgBiALaiwAACIOQQBOBEAgBiAGKQMAQoCBgoSIkKDAgH+DeqdBA3YiC2otAAAhDgsgBiALaiAYp0H/AHEiCToAACAGIAtBCGsgB3FqQQhqIAk6AAAgASABKAIIIA5BAXFrNgIIIAEgASgCDEEBajYCDCAGIAtBBHRrIgFBEGsgAjcDACABQQhrIAM2AgAgAUEEayAENgIADAELIAlBBGsiBSgCACEBIAUgBDYCACAJQQhrIgQoAgAhBSAEIAM2AgALIAAgATYCBCAAIAU2AgAgDEEQaiQADwtBAAshDiAFIBVBCGoiFWogB3EhBQwACwALiAoCEX8EfiMAQRBrIgokACAKIAI3AwggAUEQaiIFIApBCGoQjQ4hFiABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCELIAQgBEEcajYCIAJAAkAgCyALQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiCEHQAEEIIAUQnRQgBCgCRCEGIAQoAkAiB0UEQCAEKAJIIQUMBQsgBCkCSCEVIAZBCWoiBQRAIAdB/wEgBfwLAAsgBCAVQiCIPgI8IAQgFaciDjYCOCAEIAY2AjQgBCAHNgIwIARC0ICAgIABNwIoIAQgCDYCJCAEQTBqIQ8gBCALBH8gB0EIaiEQIAEoAgAiDSkDAEJ/hUKAgYKEiJCgwIB/gyEVQQAhBQNAIBVQBEADQCAFQQhqIQUgDUEIaiINKQMAQoCBgoSIkKDAgH+DIhVCgIGChIiQoMCAf1ENAAsgFUKAgYKEiJCgwIB/hSEVCyAHIAYgBCgCHCABKAIAIBV6p0EDdiAFaiIRQbB/bGpB0ABrEI0OpyIScSIIaikAAEKAgYKEiJCgwIB/gyIXUARAQQghDANAIAggDGohCCAMQQhqIQwgByAGIAhxIghqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyAHIBd6p0EDdiAIaiAGcSIIaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEICyAHIAhqIBJBGXYiDDoAACAQIAhBCGsgBnFqIAw6AAAgByAIQX9zQdAAbGogASgCACARQX9zQdAAbGpB0AD8CgAAIBVCAX0gFYMhFSALQQFrIgsNAAsgASgCDAVBAAsiBTYCPCAEIA4gBWs2AjggASAPQQQQ+iogBEEkahDQJgwBCyABIARBIGpBvPT+AEHQABDFCQtBgYCAgHghBgwCCxDjJyAEKAIMIQUgBCgCCCEGDAELEOMnIAQoAhQhBSAEKAIQIQYLIAogBTYCBCAKIAY2AgAgBEHQAGokAAsgASgCBCIGIBancSEEIBZCGYgiF0L/AINCgYKEiJCgwIABfiEYIAEoAgAhBQNAAn8CQAJAAkAgBCAFaikAACIWIBiFIhVCf4UgFUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIVUEUEQANAIAIgBSAVeqdBA3YgBGogBnFBsH9saiIHQdAAaykDAFENAiAVQgF9IBWDIhVQRQ0ACwsgFkKAgYKEiJCgwIB/gyEVIBNFBEAgFVANAyAVeqdBA3YgBGogBnEhCQtBASAVIBZCAYaDUA0DGiAFIAlqLAAAIgRBAE4EQCAFIAUpAwBCgIGChIiQoMCAf4N6p0EDdiIJai0AACEECyAFIAlqIBenQf8AcSIHOgAAIAUgCUEIayAGcWpBCGogBzoAACABIAEoAgggBEEBcWs2AgggASABKAIMQQFqNgIMIAUgCUGwf2xqIgFB0ABrIAI3AwAgAUHIAGsgA0HEAPwKAAAgAEGAgICAeDYCAAwBCyAHQcgAayEBIAAgAUHEAPwKAAAgASADQcQA/AoAAAsgCkEQaiQADwtBAAshEyAEIBRBCGoiFGogBnEhBAwACwAL0AQCAX8EfiMAQfAAayICJAAgAiAAKQMANwIIIAIgACkDCCIEQoDA4oXj6AB/IgM3AxAgAiAEQoCwncLfAX8iBSADQkR+fCIGNwMYIARCgJTr3AN/IQMCfwJAAkAgBEL/v+KF4+gAfEL+/8SLxtEBVgRAIAJBAzYCVCACQciTgQE2AlAgAkICNwJcIAJB7gY2AjQgAkHMATYCLCACIAJBKGo2AlggAiACQRBqNgIwIAIgAkEIajYCKCABKAIAIAEoAgQgAkHQAGoQywoNASACQQE2AgwgAkHgk4EBNgIICyAGUA0BIAJBAzYCVCACQeiTgQE2AlAgAkICNwJcIAJB7gY2AjQgAkHMATYCLCACIAJBKGo2AlggAiACQRhqNgIwIAIgAkEIajYCKCABKAIAIAEoAgQgAkHQAGoQywoNACACQQE2AgwgAkHgk4EBNgIIDAELQQEMAQtBACAFQkR+IAN8IgUgBCADQoCU69wDfn0iBIQiA1ANABogAiADQj+IPgIkIAJBgJSBAUEBIANCAFMbNgIgIAIgBSAFQj+HIgOFIAN9NwNAIAIgBCAEQj+HIgOFIAN9NwNIIAJBBDYCPCACQbCUgQE2AjggAkEFNgIsIAJBiJSBATYCKCACQQQ2AjQgAkHuBjYCbCACQe4GNgJkIAJBzAE2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkHIAGo2AmggAiACQUBrNgJgIAIgAkEgajYCWCACIAJBCGo2AlAgASgCACABKAIEIAJBKGoQywoLIAJB8ABqJAALoAQCCH8BfiMAQSBrIgckAAJAIANFBEAMAQsgAUEQaiEIA0AgAiAFaiELIAMgBWshCQJAAkAgASgCNCIKDQAgASgCOCEEAkACQAJAAkADQCAERQRAIAgoAgBFDQIgByAIEKUYIAcoAgBBAUcNCSAHKQMIIgxQDQkgDEIBg1BFBEAgASAMp0ECdEF4cTYCOAwICyABIAxCAYg+AjQgB0EQaiAIIAEtADwiBEEDdiAEQQdxQQBHahDBHCAHKQMQIQwgASAHKQMYNwMIIAEgDDcDACAMpw0HQcD6zABBLkHw+swAEJ8pAAsgCCgCAEUNAiAEIAkgBCAJSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAggCyAEIAEtADwQnAsiBEUEQEEAIQQgAUEANgI4IAEoAjQiCkUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgCiAJIAkgCksbIgYgBWoiBCAGTwRAIAMgBEkNASAGRSADIAVGckUEQCALIAEtAAggBvwLAAsgASAKIAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQN0aikDABDOLyACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQJ0aigCABDJLSACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQJ0aigCABCULyACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQN0aikDABCzLiACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQF0ai8BABC1LiACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQF0ai8BABCTLSACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL6AMBB38CQCABLQAdBEAMAQsgASgCCCEHIAEoAhAiAyABKAIUIghHBEAgASgCGCECA0AgAiIGAn8gAyICLAAAIgRBAE4EQCAEQf8BcSEEIAJBAWoMAQsgAi0AAUE/cSEDIARBH3EhBSAEQV9NBEAgBUEGdCADciEEIAJBAmoMAQsgAi0AAkE/cSADQQZ0ciEDIARBcEkEQCADIAVBDHRyIQQgAkEDagwBCyAFQRJ0QYCA8ABxIAItAANBP3EgA0EGdHJyIQQgAkEEagsiAyACa2ohAgJAAkAgBEEJayIFQRdNQQBBASAFdEGfgIAEcRsNACAEQYABSQ0BAkACQCAEQQh2IgVBH00EQCAFRQ0BIAVBFkcgBEGALUdyDQQMAwsgBUEgRg0BIAVBMEcgBEGA4ABHcg0DDAILIARB/wFxQfvUiQFqLQAAQQFxDQEMAgsgBEH/AXFB+9SJAWotAABBAnFFDQELIAEgAjYCGCABIAM2AhAgASgCACEFIAEgAjYCACAFIAdqIQMgBiAFayEBDAMLIAMgCEcNAAsgASACNgIYIAEgAzYCEAsgAUEBOgAdIAcgASgCACICaiIGIAZBACABKAIEIgYgAkcbIAEtABwbIQMgBiACayEBCyAAIAE2AgQgACADNgIAC7gEAQR/IwBB4ABrIgIkACACIAApAgA3AgggAiAAKAIIIgBBgN3bAW0iAzYCECACIABB4NQDbSIEIANBRGxqIgU2AhQgAEHoB20hAwJ/AkACQCAAQf/c2wFqQf65twNLBEAgAkEDNgJEIAJByJOBATYCQCACQgI3AkwgAkGcAzYCLCACQcwBNgIkIAIgAkEgajYCSCACIAJBEGo2AiggAiACQQhqNgIgIAEoAgAgASgCBCACQUBrEMsKDQEgAkEBNgIMIAJB4JOBATYCCAsgBUUNASACQQM2AkQgAkHok4EBNgJAIAJCAjcCTCACQZwDNgIsIAJBzAE2AiQgAiACQSBqNgJIIAIgAkEUajYCKCACIAJBCGo2AiAgASgCACABKAIEIAJBQGsQywoNACACQQE2AgwgAkHgk4EBNgIIDAELQQEMAQtBACAEQURsIANqIgQgACADQegHbGsiAHIiA0UNABogAiADQR92NgIcIAJBgJSBAUEBIANBAEgbNgIYIAIgBCAEQR91IgNzIANrNgI4IAIgACAAQR91IgNzIANrNgI8IAJBBDYCNCACQZCVgQE2AjAgAkEFNgIkIAJBiJSBATYCICACQQQ2AiwgAkGcAzYCXCACQZwDNgJUIAJBzAE2AkwgAkHMATYCRCACIAJBQGs2AiggAiACQTxqNgJYIAIgAkE4ajYCUCACIAJBGGo2AkggAiACQQhqNgJAIAEoAgAgASgCBCACQSBqEMsKCyACQeAAaiQAC8EFAQl/AkACQCACRSADRXINAEEBIQZBAQJ/An8gASgCACIFQf8fQf//AyAAKAIYIgMtACgbTQRAIAVBBnYiByADKAIESQRAIAMoAgAgB0EBdGovAAAgBUE/cWoMAgsgAygCEEEBawwBCyADKAIYIAVLBEAgAyAFEMAPDAELIAMoAhBBAmsLIgUgAygCEEkEQCADKAIMIAVqLQAADAELIAMtACwLdEHAA3FFDQAMAQsgAkUgBEVyRQRAIAFBBGohAyABQQRrIQogAEEUaiELIAJBAnRBBGshBCAAKAIgIQlBACEGA0ACQCABIAhBAnRqIgAoAgAiDEH+//8AcUGMwABHDQACQCAIRQ0AIABBBGsiAEUNAEEAIQcCfwJAIAAoAgAiBUH/H0H//wMgCygCACIALQAsG0sEQCAFQYCAxABJDQEgACgCFEEBawwCCyAFQQZ2IgcgACgCCEkEQCAAKAIEIAdBAXRqLwAAIAVBP3FqDAILIAAoAhRBAWsMAQsgACgCHCAFSwRAIAAgBRDBDwwBCyAAKAIUQQJrCyIFIAAoAhQiDUkEfyAAKAIQIAVBAnRqKAAABSAHCyAAKAIAIAUgDUkbIgBBACAAQYD8//8DcUGAsANGG0H/AXFBCUYNASAGIQAgDEGNwABGDQADQCAARQ0BIAkgACAKaigCABDrGSIFELE9QQxxRQRAIABBBGshACAFQf8BcUEFRw0CDAELCyADIQUgBCEAA0AgAEUNASAJIAUoAgAQ6xkiBxCxPUEUcQ0CIAVBBGohBSAAQQRrIQAgB0H/AXFBBUYNAAsLQQEPCyADQQRqIQMgBEEEayEEIAZBBGohBiAIQQFqIgggAkcNAAsLIAJBAnQhCCABIQADQEEAIQYgCEUNASAIQQRrIQggACgCACAAQQRqIQBBgAFJDQALIAJB6AdLIQYLIAYLlQQBA38jAEEwayIHJAACQCADIARPBEAgBEUEQCAHQRhqIAEgAiABKAJAIgIgAyACIANJGxCgCyAHKAIcIQICQCAHKAIYIgNBCEcEQCAAIAcpAyA3AwggAEEQaiAHQShqKQMANwMADAELIAEgASgCQCACazYCQAsgACADNgIAIAAgAjYCBAwCCyAHIAMgBGsiBDYCACAHQRhqIAEgAiABKAJAIgggAyADIAhLGxCgCyAHKAIcIQggBygCGCIJQQhHBEAgACAHKQMgNwMIIABBEGogB0EoaikDADcDACAAIAg2AgQgACAJNgIADAILIAcgCDYCBCABIAEoAkAgCGs2AkAgBCAIRgRAIANBAWshAQNAAkACQCAGIAFBA3YiCEsEQCABQQdxQfzEzgBqLQAAIAUgCGotAABxRQ0CIARBAWsiBCADTw0BIAEgAmoiCC0AACEJIAggAiAEaiIILQAAOgAAIAggCToAAAwCCyAIIAZBxIjNABDDIQALIAQgA0GkoM0AEMMhAAsgAUEBayIBQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIcIAdB6KDNADYCGCAHQgI3AiQgB0E7NgIUIAdBOzYCDCAHIAdBCGo2AiAgByAHNgIQIAcgB0EEajYCCCAAQQRqIAdBGGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC+ADAQZ/IwBBQGoiBiQAIAZBGGpCADcDACAGQRBqQgA3AwAgBkEIakIANwMAIAZCADcDACAGQThqQgA3AwAgBkEwakIANwMAIAZBKGpCADcDACAGQgA3AyACQAJAIAIEQANAIAEgBUYNAyAAIAVqLQAAIgdBEE8NAiAGIAdBAXRqIgcgBy8BAEEBajsBACACIAVBAWoiBUcNAAsLQQAhBSAGQQA7AQADQCAFIAZqQSJqIAggBSAGai8BAGpBAXQiCDsBACAFQQJqIgVBHkcNAAsgAgRAQQAhBwNAAkACQCABIAdHBEAgACAHai0AACIJRQ0CIAlBD0sNASAGQSBqIAlBAXRqIgUgBS8BACIFQQFqOwEAIAVBD3FBAnRBkJbSAGooAgAhCCAJQQVPBEBBBCEKA0AgBUECdkE8cUGQltIAaigCACAIQQR0ciEIIAVBBHZB/x9xIQUgCkEEaiIKIAlJDQALCyAEIAdLBEAgAyAHQQF0aiAIQQAgCWtBA3F2OwEADAMLIAcgBEHwltIAEMMhAAsgASABQdCW0gAQwyEACyAJQRBB4JbSABDDIQALIAdBAWoiByACRw0ACwsgBkFAayQADwsgB0EQQZCX0gAQwyEACyABIAFBgJfSABDDIQALmwQBBH8jAEHQAGsiAyQAIABBBCAAKAI0IgQgBEEETRs2AjQgAEEwaiEEAkAgAkF/cyAAKAIwIgZrQQNxIgUgACgCCCAGa00NACAAKAIIIAAoAjBrIAVPDQADQCAAEPsWIAAoAgggACgCMGsgBUkNAAsLIAQgBRCNNyAAQQEgACgCNCIFIAVBAU0bNgI0IAAoAggaIARBABCNNyAAKAIIIAAoAjBHIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIARBARCNNyADQTBqIAAQ3DsgAygCNCEFIAMoAjAhBiADQShqIAAoAjAQjDcgA0EgaiAGIAUgAygCKCADKAIsQbC3/gAQ1yYCQAJAIAMoAiQEQCADKAIgQQA6AAACQCAAKAIIIAAoAjBrIAJPIgUNACACQYCAgIB4Sw0CIAUNAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAjAhBCADQRhqIAAQ3DsgA0EQaiADKAIYIAMoAhwgBCAEIAJrQZC3/gAQ1yYgAygCFCIEIAJHDQIgAgRAIAMoAhAgASAC/AoAAAsgA0EIaiAAENw7IAAgAhCpERogACgCMCADQdAAaiQADwsgA0EANgJIIANBATYCPCADQey3/gA2AjggA0IENwJAIANBOGpBwLf+ABDvLAALQdi2/gBBJUGAt/4AEJ8pAAsgBCACQaC3/gAQszsAC4EEAgh+BH8jAEEwayILJABCgICAgICAgICAfyEFAkACQAJ+AkACQCAAKAIEKAIQIAFBBHRqIgopAwAiByAKKQMIIghCgICAgICAgICAf4WEQgBSIAAoAgAiDSgCACIKKAIAIgwpAwgiAiAMKQMAIgODQn9SckUEQEIAIQIMAQsgAiADhFANAyALQSBqIAcgCCADIAIQgxkgC0EQaiALKQMgIgQgCykDKCIFIAMgAhCoHkIAIAcgCykDECIJfSACIAODQn9RIgwbIQZCACAIIAspAxh9IAcgCVStfSAMGyECIAhCAFkNAQsgBCAGIAooAggiCikDAFggAiAKKQMIIgNXIAIgA1EbrSIDfSECIAUgAyAEVq19DAELIAUgBCAGIAooAgQiCikDAFogAiAKKQMIIgNZIAIgA1EbrXwiAiAEVK18CyEEAkACQCACQoCAgIAIfCIDQv////8PViAEIAIgA1atfCIEQgBSIARQGw0AIAKnIgogDSgCBC0AABDEKUUNACAAKAIIIAFBAnRqIAo2AgAMAQsgACgCECIKIAooAgBBAWo2AgAgC0EIaiAAKAIUEIY9IAFBA3YiACALKAIMIgpPDQIgCygCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAtBMGokAA8LQcyP/wAQ4isACyAAIApBiIv/ABDDIQALnAQBAn8jAEHgAGsiBSQAIAUgBDoADwJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgIsIAVBoIzNADYCKCAFQgE3AjQgBUGuAzYCTCAFIAVByABqNgIwIAUgBUEPajYCSCAAQQRqIAVBKGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMAQsgBUEwaiIEQQA2AgAgBUKAgICAwAA3AiggBUEoaiIGQQEQhi0gBUEYaiIHIAQoAgA2AgAgBUEANgIkIAVCgICAgBA3AhwgBSAFKQIoNwMQIAQgAkEIaikCADcDACAFQQA2AjggBSADNgI8IAUgAikCADcDKCAFIAEtAGg6AEAgBUHIAGogBiAFQRBqIgNBfxDpCCAFKAJIIgJBCEcEQCAAIAUpA1A3AwggAEEQaiAFQdgAaikDADcDACAAIAUoAkw2AgQgACACNgIAIAVBNGogBSgCLCAFKAIwIAUoAigoAhARAQAgAxDaLwwBCyAFQdgAaiIDIAVBIGopAwA3AwAgBUHQAGogBykDADcDACAFIAUpAxA3A0ggAUHQAGohAiABKAJQQYCAgIB4RwRAIAIQ2i8LIAIgBSkDSDcCACACQRBqIAMpAwA3AgAgAkEIaiAFQdAAaikDADcCACAAQQg2AgAgBUE0aiAFKAIsIAUoAjAgBSgCKCgCEBEBAAsgBUHgAGokAAucBAECfyMAQeAAayIFJAAgBSAEOgAPAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AiwgBUGgjM0ANgIoIAVCATcCNCAFQa4DNgJMIAUgBUHIAGo2AjAgBSAFQQ9qNgJIIABBBGogBUEoahCZDiAAQQE2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwBCyAFQTBqIgRBADYCACAFQoCAgICAATcCKCAFQShqIgZBARCHLSAFQRhqIgcgBCgCADYCACAFQQA2AiQgBUKAgICAEDcCHCAFIAUpAig3AxAgBCACQQhqKQIANwMAIAVBADYCOCAFIAM2AjwgBSACKQIANwMoIAUgAS0AaDoAQCAFQcgAaiAGIAVBEGoiA0F/EOoIIAUoAkgiAkEIRwRAIAAgBSkDUDcDCCAAQRBqIAVB2ABqKQMANwMAIAAgBSgCTDYCBCAAIAI2AgAgBUE0aiAFKAIsIAUoAjAgBSgCKCgCEBEBACADENsvDAELIAVB2ABqIgMgBUEgaikDADcDACAFQdAAaiAHKQMANwMAIAUgBSkDEDcDSCABQdAAaiECIAEoAlBBgICAgHhHBEAgAhDbLwsgAiAFKQNINwIAIAJBEGogAykDADcCACACQQhqIAVB0ABqKQMANwIAIABBCDYCACAFQTRqIAUoAiwgBSgCMCAFKAIoKAIQEQEACyAFQeAAaiQAC9AEAgR/CH4jAEGAAmsiAiQAIAAoAgAhBCACQYABaiIFIAAoAgQoAhAgAWotAAAQtC4gAikDgAEhCSACKQOIASEKIAIpA5ABIQsgAikDmAEhDCAEKAIAIgMpAwAhBiADKQMIIQcgAykDECEIIAIgAykDGCINNwN4IAIgCDcDcCACIAc3A2ggAiAGNwNgIAIgDDcDWCACIAs3A1AgAiAKNwNIIAIgCTcDQAJAAkACQAJAAkAgBiAIhCAHIA2EhFBFBEAgBSAJIAogCyAMIAYgByAIIA0QmgggAi0AgAFBAUcNAiACQQI2AoQBIAJBmJD/ADYCgAEgAkICNwKMASACQYMMNgL8ASACQYMMNgL0ASACIAJB8AFqNgKIASACIAJB4ABqNgL4ASACIAJBQGs2AvABIAJB4AFqIAUQmQ4gAkEkaiACQewBaigCADYCACACQYiAgIB4NgLcASACIAJB5AFqKQIANwIcIAIgAikC3AE3AhQMAQsgAkGHgICAeDYCFAsgAkEBNgIQIAJBEGpBBHIQiBEMAQsgAikDkAEiBiACKQOYASIHIAIpA6ABIgggAikDqAEiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQYACaiQADwsgACADQYiL/wAQwyEAC9AEAgR/CH4jAEGAAmsiAiQAIAAoAgAhBCACQYABaiIFIAAoAgQoAhAgAWotAAAQki0gAikDgAEhCSACKQOIASEKIAIpA5ABIQsgAikDmAEhDCAEKAIAIgMpAwAhBiADKQMIIQcgAykDECEIIAIgAykDGCINNwN4IAIgCDcDcCACIAc3A2ggAiAGNwNgIAIgDDcDWCACIAs3A1AgAiAKNwNIIAIgCTcDQAJAAkACQAJAAkAgBiAIhCAHIA2EhFBFBEAgBSAJIAogCyAMIAYgByAIIA0QmgggAi0AgAFBAUcNAiACQQI2AoQBIAJBmJD/ADYCgAEgAkICNwKMASACQYMMNgL8ASACQYMMNgL0ASACIAJB8AFqNgKIASACIAJB4ABqNgL4ASACIAJBQGs2AvABIAJB4AFqIAUQmQ4gAkEkaiACQewBaigCADYCACACQYiAgIB4NgLcASACIAJB5AFqKQIANwIcIAIgAikC3AE3AhQMAQsgAkGHgICAeDYCFAsgAkEBNgIQIAJBEGpBBHIQiBEMAQsgAikDkAEiBiACKQOYASIHIAIpA6ABIgggAikDqAEiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQYACaiQADwsgACADQYiL/wAQwyEAC4sEAQJ/IwBB0ABrIgUkACAFIAQ6AAcCQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCPCAFQaCMzQA2AjggBUIBNwJEIAVBrgM2AiQgBSAFQSBqNgJAIAUgBUEHajYCICAAQQRqIAVBOGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMAQsgBUIENwIYIAVCADcCECAFQoCAgICAAjcCCCAFQUBrIgQgAkEIaikCADcDACAFIAIpAgA3AzggAS0AaCECIAVBIGoiBiAFQThqIgcQ/BsgBSACOgA0IAVBADYCLCAFIAM2AjAgByAGIAVBCGpBfxDmByAFKAI4IgJBCEcEQCAAIAUpA0A3AwggAEEQaiAFQcgAaikDADcDACAAIAUoAjw2AgQgACACNgIAIAUoAiAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAVBCGoQ2S8MAQsgBUHIAGoiAyAFQRhqKQIANwMAIAQgBUEQaikCADcDACAFIAUpAgg3AzggAUHQAGohAiABKAJQQYCAgIB4RwRAIAIQ2S8LIAIgBSkDODcCACACQRBqIAMpAwA3AgAgAkEIaiAFQUBrKQMANwIAIABBCDYCACAFKAIgIgAgACgCACIAQQFrNgIAIABBAUcNACAFQSBqEPseCyAFQdAAaiQAC7cEAgd/AX4jAEEgayIIJAACQCADRQ0AIAFBEGohCgNAIAMgBWshByACIAVBAnRqIQkCQAJAIAEoAjQiBA0AIAEoAjghBgJAAkACQAJAA0AgBkUEQCAKKAIARQ0CIAggChClGCAIKAIAQQFHDQkgCCkDCCILUA0JIAtCAYNQRQRAIAEgC6dBAnRBeHE2AjgMCAsgASALQgGIPgI0IAhBEGogCiABLQA8IglBA3YgCUEHcUEAR2oQwRwgCCkDECELIAEgCCkDGDcDCCABIAs3AwAgC6cNB0HA+swAQS5B8PrMABCfKQALIAooAgBFDQIgBiAHIAYgB0kbIgQgBWoiBiAESQ0DIAMgBkkNBCAKIAkgBCABLQA8ELkGIgRFBEBBACEGIAFBADYCOCABKAI0IgRFDQEMBgsLIAEgASgCOCAEazYCOCAEIAVqIQUMBQtBnPjMAEEYQbD6zAAQyyQAC0Gc+MwAQRhBtPjMABDLJAALIAUgBkHE+MwAELE7AAsgBiADQcT4zAAQsDsACyABKAIARQRAQdT4zAAQsjsACwJAIAQgByAEIAdJGyIHIAVqIgQgB08EQCADIARJDQEgASgCCCEFIAcEQCAHQQJ0IQYDQCAJIAU2AgAgCUEEaiEJIAZBBGsiBg0ACwsgASABKAI0IAdrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAIQSBqJAALtwQCB38BfiMAQSBrIggkAAJAIANFDQAgAUEQaiEKA0AgAyAFayEHIAIgBUEBdGohCQJAAkAgASgCNCIEDQAgASgCOCEGAkACQAJAAkADQCAGRQRAIAooAgBFDQIgCCAKEKUYIAgoAgBBAUcNCSAIKQMIIgtQDQkgC0IBg1BFBEAgASALp0ECdEF4cTYCOAwICyABIAtCAYg+AjQgCEEQaiAKIAEtADwiCUEDdiAJQQdxQQBHahDBHCAIKQMQIQsgASAIKQMYNwMIIAEgCzcDACALpw0HQcD6zABBLkHw+swAEJ8pAAsgCigCAEUNAiAGIAcgBiAHSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAogCSAEIAEtADwQpggiBEUEQEEAIQYgAUEANgI4IAEoAjQiBEUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgBCAHIAQgB0kbIgcgBWoiBCAHTwRAIAMgBEkNASABLwEIIQUgBwRAIAdBAXQhBgNAIAkgBTsBACAJQQJqIQkgBkECayIGDQALCyABIAEoAjQgB2s2AjQgBCEFDAILIAUgBEHk+MwAELE7AAsgBCADQeT4zAAQsDsACyADIAVLDQALCyAAQQg2AgAgACAFNgIEIAhBIGokAAufBAEGfyMAQeACayIFJAAgASgC7AIiBigCFCIEQQhqIAQoAghBAkZBAnRqIgctACEhCEEAIQQCQAJAAkACQCAGLwEYIgkOAgABAgsgBUIFNwMIDAILIAYvARoNACAHLQAgIgRBA0cgBEEAR3EhBAsgBUEIaiAJIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDWAwBCyAFQdgAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBOBEAgBUG4AWpBADoAACAFQgA3A7ABQQAiBEUEQCAFQZACaiAFQQhqQdAA/AoAAAsgBEUEQCAFQcABaiAFQdgAakHQAPwKAAALIAEpAwBCBVIEQCABKAKQAiIEIAQoAgAiBEEBazYCACAEQQFGBEAgAUGQAmoQ2SELIAFBiAJqELwqIAFB0ABqEJMqIAEQ/S4CQCABKALwASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQfABahC7IwsgAUGgAWoQmywgAUH4AWoQlAwLIAEgBUHAAWpBoAH8CgAAIAEgBjYCkAIgASADNgKMAiABIAI2AogCIAFBADYC8AEgAUIHNwOgASABIAhBAUYiAjoAhAIgASAFKQOwATcClAIgAUGcAmogBUG4AWotAAA6AAAgASAFLwCtATsAnQIgAUGfAmogBUGvAWotAAA6AAAgAUEZQRYgAhs6APgBIABBCDYCACAFQeACaiQADwsAC58EAQZ/IwBB4AJrIgUkACABKALsAiIGKAIUIgRBCGogBCgCCEECRkECdGoiBy0AISEIQQAhBAJAAkACQAJAIAYvARgiCQ4CAAECCyAFQgU3AwgMAgsgBi8BGg0AIActACAiBEEDRyAEQQBHcSEECyAFQQhqIAkgBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNYDAELIAVB2ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQCAFQbgBakEAOgAAIAVCADcDsAFBACIERQRAIAVBkAJqIAVBCGpB0AD8CgAACyAERQRAIAVBwAFqIAVB2ABqQdAA/AoAAAsgASkDAEIFUgRAIAEoApACIgQgBCgCACIEQQFrNgIAIARBAUYEQCABQZACahDZIQsgAUGIAmoQvCogAUHQAGoQkyogARD9LgJAIAEoAvABIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFB8AFqELsjCyABQaABahCbLCABQfgBahCUDAsgASAFQcABakGgAfwKAAAgASAGNgKQAiABIAM2AowCIAEgAjYCiAIgAUEANgLwASABQgc3A6ABIAEgCEEBRiICOgCEAiABIAUpA7ABNwKUAiABQZwCaiAFQbgBai0AADoAACABIAUvAK0BOwCdAiABQZ8CaiAFQa8Bai0AADoAACABQRhBFCACGzoA+AEgAEEINgIAIAVB4AJqJAAPCwAL6QMBCX8gBAR9AkACQAJAA0ACQAJAAn8CQAJAIAIgCGogA3EiBSABTQRAIAEgBUYNAUEBIAAgBWoiBi0AACIKwCIHQQBKDQMaQQEhCyAEIAhrIgxBAU0NBCABIAVrIQUgB0FgcUFARw0CIAVBAUcEQCAHQR5xRQ0DIAYsAAFBQE4NA0ECDAQLQQFBAUH8ndYAEMMhAAsgBSABQdye1gAQrzsAC0EAQQBB7J3WABDDIQALIAxBAkYNAQJAIAdBcHFBYEcNAAJAIAVBAUcEQCAGLAABIg1BQE4NAiAFQQNJDQEgDUH/AXFBBnRBgBBxIApBDHRBgOADcXJFIAYsAAJBQE5yDQJBAwwDC0EBQQFBjJ7WABDDIQALQQJBAkGcntYAEMMhAAsgB0H4AXFB8AFHIAxBBElyDQEgBUEBRg0CIAYsAAEiB0FATg0BIAVBA0kNBCAGLAACQUBODQEgBUEDRg0FIApBEnRBgIDwAHEgB0H/AXFBDHRBgIAMcXJBgIAEa0H//z9LIAYsAANBQE5yDQFBBAsiCyAJaiEJCyAEIAggC2oiCEsNAQwECwtBAUEBQaye1gAQwyEAC0ECQQJBvJ7WABDDIQALQQNBA0HMntYAEMMhAAsgCbMFQwAAAAALIASzQwAAQD+UXgvYAwIDfgV/IwBBIGsiByQAAkAgAlAgAUK/f1NyDQBB/wEhCCABQiZVDQAgB0EQaiABpyIGQQR0IglB0MOBAWopAwBCACACIAJ5IgOGIgVCABCoHiAHKQMQIQQgBykDGCICQv//////B4NC//////8HUQRAIAcgCUHYw4EBaikDAEIAIAVCABCoHiACIAcpAwgiAiAEfCIEIAJUrXwhAgsgA6chCSACQj+IIgOnIQogBEJ/USABQht8QtIAVnFFBEAgAiADQiaEIgWIIQMCQAJAIAZB6qQNbEEQdSAJayAKakE/aiIGQYJ/TgRAQYABQf8AIANC/P//H4MgAyADIAWGIAJRGyADIANCA4NCAVEbIAMgAUIRfEIcVBsgAyAEQgJUGyIBQgGDIAF8IgFC////D1YiCRsgBmoiBkH+AU0NAUIAIQQMBAsgBkHDfk8NAUIAIQRBACEIDAMLQgAgAUIBiEL///8bgyAJGyEEIAYhCAwCCyADQQIgBmtBP3GtiCIBQgGDIgIgAXxC////B1YhCCACpyABp2pBAXatIQQMAQsgBkHqpA1sQRB1IApFIgYgCWprQen+AWshCCACIAathiEECyAAIAg2AgggACAENwMAIAdBIGokAAu+AgEBfyMAQTBrIgQkAAJAAkACQAJAAkACQCAAKAIAKAIALQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AgAgAiAAQQF2IgBJDQMMBAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NA0HYm4QBELI7AAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NAkGsnIQBELI7AAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NAUH8nIQBELI7AAsgBCABKAIQIAJBAXRqLwEAOwEEIARBBGogAxDiFCAEQTBqJAAPCyAEIAA2AhwgBEECNgIIIARBuJeEATYCBCAEQgI3AhAgBEE7NgIsIARBOzYCJCAEIARBIGo2AgwgBCAEQRxqNgIoIAQgBDYCICAEQQRqQciXhAEQ7ywAC74CAQF/IwBBMGsiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCACACIABBAnYiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkECdGoqAgA4AgQgBEEEaiADEI8gIARBMGokAA8LIAQgADYCHCAEQQI2AgggBEG4l4QBNgIEIARCAjcCECAEQTs2AiwgBEE7NgIkIAQgBEEgajYCDCAEIARBHGo2AiggBCAENgIgIARBBGpByJeEARDvLAALjAQBCH8jAEEgayIFJAAgBUEYaiAAKAIcIgNB2ABqEOQlIAUoAhwhCAJAAkACQAJ/AkAgAygCXCIEIAMoAmAiCSADKAJkIgpqIgZrIgcgAk8NAAJAAkACQANAIAQgCSAKaiIGSQ0BIAcgBCAGayIESw0CIAcEQCADKAJYIAZqIAEgB/wKAAALIAMgAygCZCAHajYCZCAAKAIwIQYgBUEQaiADQdgAahDkJSAFKAIUIgQgCEkNAyAAIAYgBSgCECAIaiAEIAhrEN0HNgIwIAMgAygCjAEgB2o2AowBIAAQ4hggBUEIaiAAKAIcIgNB2ABqEOQlIAUoAgxFBEAgASAHaiEBQQAhCCACIAdrIgIgAygCXCIEIAMoAmAiCSADKAJkIgpqIgZrIgdNDQUMAQsLIANB/wE6AAFBAAwECyAGIARBkPr7ABCvOwALIAcgBEGQ+vsAELA7AAsgCCAEQaD6+wAQrzsACyAEIAZJDQEgAiAEIAZrIgdLDQIgAgRAIAMoAlggBmogASAC/AoAAAsgAyADKAJkIAJqNgJkIAAoAjAgBSADQdgAahDkJSAFKAIEIgEgCEkNAyAFKAIAIAhqIAEgCGsQ3QchASADQQA2AowBIAAgATYCMEEDCyAFQSBqJAAPCyAGIARB8Pn7ABCvOwALIAIgB0Hw+fsAELA7AAsgCCABQYD6+wAQrzsAC6wFAgd/AX4jAEEwayIDJAACQAJAIAEoAhQiBiABKAIQIgdJBEAgASAGQQFqIgQ2AhQgAUEMaiEFIAEoAgwiCCAGai0AACIJQTBGBEACQCAEIAdJBEAgBCAIai0AAEEwa0H/AXFBCkkNAQsgACABIAJCABDIFAwECyADQQ02AiAgA0EIaiAFIAZBAmoiASAHIAEgB0kbEOoMIANBIGogAygCCCADKAIMEPsoIQEgAEIDNwMAIAAgATYCCAwDCyAJQTFrQf8BcUEJTwRAIANBDTYCICADQRBqIAUgBBDqDCADQSBqIAMoAhAgAygCFBD7KCEBIABCAzcDACAAIAE2AggMAwsgCUEwa61C/wGDIQoCQCAEIAdPDQADQCAEIAhqLQAAQTBrIgZB/wFxIgVBCk8NASAFQQVLIApCmbPmzJmz5swZUnIgCkKZs+bMmbPmzBlacQ0DIAEgBEEBaiIENgIUIApCCn4gBq1C/wGDfCEKIAQgB0cNAAsLIAAgASACIAoQyBQMAgsgA0EFNgIgIANBGGogAUEMaiAGEOoMIANBIGogAygCGCADKAIcEPsoIQEgAEIDNwMAIAAgATYCCAwBCyADQSBqIQYgAiEEQQAhAgJAAkACQCABKAIQIgcgASgCFCIFTQ0AIAVBAWohCCAHIAVrIQcgASgCDCAFaiEJA0AgAiAJai0AACIFQTBrQf8BcUEKTwRAIAVBLkYNAyAFQcUARyAFQeUAR3ENAiAGIAEgBCAKIAIQ6QwMBAsgASACIAhqNgIUIAcgAkEBaiICRw0ACyAHIQILIAYgASAEIAogAhCwEgwBCyAGIAEgBCAKIAIQ1A0LIAACfiADKAIgQQFGBEAgACADKAIkNgIIQgMMAQsgACADKwMoOQMIQgALNwMACyADQTBqJAALuwYCCH8BfiMAQTBrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkAgAS0ACEEBaw4EBAEDAAILIAEoAhghBAwFCwALIAFCATcDECABIAEoAgA2AiAgAUIAIAE1AgR9NwMYCyADQQhqIQUjAEEQayIGJAACQCABQRBqIgQpAwBCA1IEQCAGIAQoAhAoAgAQ3R4gBigCACIHQQJGBEAgBUECNgIADAILIAdBAXEEQCAFIAYpAgQ3AgQgBUEBNgIADAILIAQpAwAhCyAEKAIQKAIAIgcgBCkDCDcDCCAHIAs3AwAgBEIDNwMAIAUgBCgCECgCABDdHgwBCyAFIAQoAhAoAgAQ3R4LIAZBEGokACADKAIIIgRBAkcNASAAQQk2AgBBAwwFC0HM/8IAEOgrAAsgBEEBcQRAIAMgAykCDDcDCCADQRhqIANBCGoQgSsMAwsgA0EIaiABKAIEQQBBAUEBEKAYIAMoAgwhBCADKAIIQQFGDQEgAygCECEFIAFBADYCFCABIAU2AhAgASAENgIMIAFBADYCKCABIAQ2AiQgAUEANgIgIAEgAUEMajYCHCABIAFBMGoiBDYCGCABIAEoAgA2AjggASABNQIENwMwCyADQQhqIQYjAEEQayIFJAAgAUEoaiIJKAIAIQcgBUEIaiABQRxqIgogBCACEIAJAkAgBS0ACCIIQQVHBEADQCAIQQRHBEAgBiAFKQMINwIADAMLIAUoAgwiCEUEQCAGIAc2AgQgBkEEOgAAIAlBADYCAAwDCyAJIAcgCGoiBzYCACAFQQhqIAogBCACEIAJIAUtAAgiCEEFRw0ACwsgBkEFOgAACyAFQRBqJAAgAy0ACEEFRgRAIABBCTYCAEEEDAMLIAMpAwgiC0L/AYNCBFIEQCADIAs3AwggA0EYaiADQQhqEIErIAFBDGoQ3jsMAgsgA0EQaiABQRRqKAIANgIAIAMgASkCDDcDCCADQRhqQQRyIANBCGoQ5xUgA0EINgIYDAELIAQgAygCEEHc/8IAEP0vAAsgACADKQMYNwMAIABBEGogA0EoaikDADcDACAAQQhqIANBIGopAwA3AwBBAQs6AAggA0EwaiQAC/YGAQd/IwBBEGsiCyQAQf3/AyENQQEhBwJAIANFDQAgAiADaiIIIANJIAYgCElyDQAgBSACQQNsaiIFLwAAIAVBAmotAABBEHRyIgJBgIDEAEYNACAFQQNqIQcgA0EBayEJIAIhDQsgByAJQQNsaiEIAkAgBEUEQCALIAg2AgwgCyAHNgIIQQAhBiALQQhqENclIgdBgIDEAEYNASABQQRqIQUgAUHIAGohCEEBIQkDQCAHAn9B/x9B//8DIAEoAlwiAi0ALBsgB08EQCAHQQZ2IgMgAigCCEkEQCACKAIEIANBAXRqLwAAIAdBP3FqDAILIAIoAhRBAWsMAQsgAiAHEMAuCyIDIAIoAhQiB0kEfyACKAIQIANBAnRqKAAABSAECyACKAIAIAMgB0kbIgoQoy8hDAJ/IAgoAgAiAkESSQRAIAIhAyAIIQdBESECIAUMAQsgASgCBCEDIAUhByABKAIICyEEIAIgA0YEfyABEPwfIAEoAgghBCAFIQcgASgCBAUgAwtBAnQgBGogDDYCACAHIAcoAgBBAWo2AgAgBiAJIAoQ+zobIQYgCUEBaiEJIAtBCGoQ1yUiB0GAgMQARw0ACwwBCyMAQRBrIgokACAKQQhqIAEiAyAIIAdrQQNuEJ8YIAooAgggCigCDBCALSADQcgAaiEJQREhAgJ/IAMoAkgiBEERTQRAIANBBGohBiAJIQEgBAwBCyADQQRqIQEgAygCCCEGIAQhAiADKAIECyEEAkACQCABIAIgBEsEfyAGIARBAnRqIQUDQCAHIAhGDQIgBy8AACAHQQJqLQAAQRB0ciIGQYCAxABGDQIgBSAGQYCAgHhyNgIAIAVBBGohBSAHQQNqIQcgAiAEQQFqIgRHDQALIAIFIAQLNgIAIAcgCEYNASADQQRqIQIDQCAHLwAAIAdBAmotAABBEHRyIgxBgIDEAEYNAgJ/IAkoAgAiBkESSQRAIAYhBSACIQFBESEGIAkMAQsgAygCBCEFIAMoAgghASACCyEEIAUgBkYEQCADEPwfIAMoAgQhBSACIQQgAygCCCEBCyABIAVBAnRqIAxBgICAeHI2AgAgBCAEKAIAQQFqNgIAIAdBA2oiByAIRw0ACwwBCyABIAQ2AgALIApBEGokAEEAIQYLIAAgBjYCBCAAIA02AgAgC0EQaiQAC5YEAgd/AX4jAEEgayIHJAACQCADRQRADAELIAFBEGohCANAIAIgBWohCiADIAVrIQkCQAJAIAEoAjQiBA0AIAEoAjghBgJAAkACQAJAA0AgBkUEQCAIKAIARQ0CIAcgCBClGCAHKAIAQQFHDQkgBykDCCILUA0JIAtCAYNQRQRAIAEgC6dBAnRBeHE2AjgMCAsgASALQgGIPgI0IAdBEGogCCABLQA8IgRBA3YgBEEHcUEAR2oQwRwgBykDECELIAEgBykDGDcDCCABIAs3AwAgC6cNB0HA+swAQS5B8PrMABCfKQALIAgoAgBFDQIgBiAJIAYgCUkbIgQgBWoiBiAESQ0DIAMgBkkNBCAIIAogBCABLQA8EJwLIgRFBEBBACEGIAFBADYCOCABKAI0IgRFDQEMBgsLIAEgASgCOCAEazYCOCAEIAVqIQUMBQtBnPjMAEEYQbD6zAAQyyQAC0Gc+MwAQRhBtPjMABDLJAALIAUgBkHE+MwAELE7AAsgBiADQcT4zAAQsDsACyABKAIARQRAQdT4zAAQsjsACwJAIAQgCSAEIAlJGyIGIAVqIgQgBk8EQCADIARJDQEgCiAGIAEtAAgQ7S8gASABKAI0IAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAALlAkCCX8CfiMAQUBqIgQkAAJAAkACQCAAKAJYRQRAIAAoAkwhAgwBCyAAKQJQIQsgAEKAgICAEDcDUCAEQRBqIABB2ABqIgIoAgA2AgAgAkEANgIAIAQgCzcDCCAEQRhqIARBCGoQ8i8gBCAEKQIYNwI0IARBADYCMCAEIAQoAiQiAzYCLCAEIAQoAiA2AiggBCAEQShqENc7IAQoAgAhBkEcQQQQrTYiAkUNASACQoGAgIAQNwIAIAIgBCkCKDcCCCACQRBqIARBMGopAgA3AgAgAkEYaiAEQThqKAIANgIAIANBf0YNAiAAKAJMIgUgACgCREYEQCAAQcQAakGAhYQBEJAoCyAAKAJIIAVBDGxqIgcgAzYCCCAHIAY2AgQgByACNgIAIAAgBUEBaiICNgJMCyABKAIIIQcgBCACNgIYIAEoAgQhBSMAQRBrIgMkACAAQcQAaiIGIAUgB0EMbGoiCCAFa0EMbhD9LSADIAYpAgRCIIk3AgggAyAGQQhqNgIEIAUgCCADQQRqEN4ZIANBEGokACAAQThqIQMgASgCHCIFIAEoAiBBcHFqIQYCQCACRSAHRXJFBEAgBCAGNgIsIAQgBTYCKCAEIARBGGo2AjAjAEEQayICJAAgBEEoaiIFKAIEIAUoAgBrQQR2IgYgAygCACADKAIIIgdrSwRAIAMgByAGQRBBEBDeKCADKAIIIQcLIAIgAygCBDYCDCACIAc2AgggAiADQQhqNgIEIAJBBGoiBigCBCEHIAYoAgAgBSgCACIDIAUoAgQiCEcEQCAFKAIIIQogBigCCCAHQQR0aiEFIAcgCCADa0EEdiIIaiEHA0AgAykDCCILpyEGIAMpAwAiDKdBDU8EQCAKKAIAIAZqIQYLIAUgDDcDACAFIAatIAtCgICAgHCDhDcDCCADQRBqIQMgBUEQaiEFIAhBAWsiCA0ACwsgBzYCACACQRBqJAAMAQsgAyAFIAYQ6yMLIABB3ABqIQACQCABEJM2IgIEQCAAIAIQ4SYMAQsgARDSPCECIwBBEGsiASQAAkACQAJAIAAoAgAEQCAAKAIQIgVBB3EiB0UNAiABQQhqIAAQhj0gASgCDCIDRQ0BIAEoAgggA2pBAWsiA0UNASADIAMtAABBfyAHdHI6AAAMAgsgACAAKAIUIAJqNgIUDAILQZCGhAEQsjsACwJAIAIgBWoiBUEDdiAFQQdxIgdBAEdqIgMgACgCDCICTQ0AIAMgAmshBiAAKAIEIgggA0kEQCAAIAhBAXQiAiADQcD///8DcUFAayADIANBP3EbIgggAiAISxsQ6BkgACgCDCECCyAGRQ0AIAAoAgggAmpB/wEgBvwLAAsgACADNgIMIAcEQCABIAAQhj0CQCABKAIEIgIEQCABKAIAIAJqQQFrIgINAQtBoIaEARCyOwALIAIgAi0AAEF/IAd0QX9zcToAAAsgACAFNgIQCyABQRBqJAALIARBQGskAA8LQQRBHBCjPQALIARBADYCOCAEQQE2AiwgBEHohIQBNgIoIARCBDcCMCAEQShqQfCEhAEQ7ywAC+gEAgV/AX4jAEHwA2siBCQAIAQgAkHAA/wKAAAgASgCACIDIAMpAwAgBCkD2AJ8NwMAIAEoAgQiAyADKQMAIAQpA/ABfDcDACABKAIIIgMoAggiBSADKAIARgRAIANBhMLDABChKAsgAygCBCAFQcACbGogAkHAAvwKAAAgAyAFQQFqNgIIIAEoAgwiAygCCCIFIAMoAgBGBEAgA0GUwsMAEJAoCyADKAIEIAVBDGxqIgYgAikC6AI3AgAgBkEIaiACQfACaigCADYCACADIAVBAWo2AgggASgCECIDKAIIIgYgAygCAEYEQCMAQRBrIgUkACAFQQhqIAMgAygCAEEBQQRBzAAQtxEgBSgCCCIHQYGAgIB4RwRAIAcgBSgCDEGkwsMAEP0vAAsgBUEQaiQACyADKAIEIAZBzABsaiACQfQCakHMAPwKAAAgAyAGQQFqNgIIIAEoAhQiAygCCCIFIAMoAgBGBEAgA0G0wsMAEJEoCyADKAIEIAVBGGxqIgYgAikCwAI3AgAgBkEQaiACQdACaikCADcCAEEIIQcgBkEIaiACQcgCaikCADcCACADIAVBAWo2AggCQCABKAIYIgEoAgBBAUYEQCAEIAEpAwgiCDcDwAMgCCAEKQPgAlENASAEQQM2AswDIARB8MLDADYCyAMgBEICNwLUAyAEQTw2AuwDIAQgBEHgAmo2AugDIARBPDYC5AMgBCAEQeADajYC0AMgBCAEQcADajYC4AMgAEEEaiAEQcgDahCZDkEAIQcMAQsgASAEKQPgAjcDCCABQgE3AwALIAAgBzYCACAEQfADaiQAC9gIAQp/IwBBkAFrIgYkAAJAAkACQAJAAkACQAJAAkACQCABKAIAIgJBH3UgAkH/////B2txIgJBAWsOBAEBAQIACyAGIAFByAD8CgAAQcgAQQQQrTYiAUUNBiABIAZByAD8CgAAIABBATYCCCAAIAE2AgQgAEEBNgIADAcLIAZByABqIgQgASgCBCIDQcgA/AoAACAAIAQQygsgA0HIAEEEEPg6IAJBAmsOAgIDAQsgASgCDCEEIAEoAgghAiABKAIEIQMgBkEANgJoIAZBADYCWCAGIAM2AlAgBiACNgJMIAYgAjYCSCAGIAIgBEHIAGxqNgJUQQAhAiMAQZABayIEJAAgBEEUaiAGQcgAaiIDEIINAkACQAJAIAQoAhRBgICAgHhHBEAgAygCEARAIAMoAhwgAygCFGtByABuIQILIAMoAiAEfyADKAIsIAMoAiRrQcgAbgVBAAsgAmohBQJ/AkAgAygCAEUNACADKAIMIAMoAgRGDQAgBEHgAGohAkEADAELIARB3ABqIQIgBQshByACIAc2AgAgBEHgAGoiAkEDIAUgBUEDTRtBAWpBAEEEQcgAEKAYIAQoAmQhBSAEKAJgQQFGDQIgBCgCaCIHIARBFGpByAD8CgAAIARBEGoiCkEBNgIAIAQgBzYCDCAEIAU2AgggAiADQTD8CgAAIARBCGohBSMAQdAAayIDJAAgAyACEIINIAMoAgBBgICAgHhHBEADQCAFKAIIIgcgBSgCAEYEQEEAIQggAigCEARAIAIoAhwgAigCFGtByABuIQgLIAIoAiAEfyACKAIsIAIoAiRrQcgAbgVBAAsgCGohCAJ/AkAgAigCAEUNACACKAIMIAIoAgRGDQAgA0HMAGohCUEADAELIANByABqIQkgCAshCyAJIAs2AgAgBSAHIAhBAWpBBEHIABDQKAsgBSgCBCAHQcgAbGogA0HIAPwKAAAgBSAHQQFqNgIIIAMgAhCCDSADKAIAQYCAgIB4Rw0ACwsgAhDDKiADQdAAaiQAIABBCGogCigCADYCACAAIAQpAgg3AgAMAQsgAEEANgIIIABCgICAgMAANwIAIAMQwyoLIARBkAFqJAAMAQsgBSAEKAJoQZCyzQAQ/S8ACyABKAIUIgANAwwFCyABKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCABQQhqEPseCyABKAIYIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAFBGGoQ+x4MBAsgASgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEIahD7HgsgASgCGCIARQ0DIAAgACgCACIAQQFrNgIAIABBAUcNAyABQRhqEPseDAMLIAEoAhAiAEUNAiAAIAAoAgAiAEEBazYCACAAQQFHDQIgAUEQahD7HgwCCyAAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEUahD7HgwBC0EEQcgAEKM9AAsgBkGQAWokAAvuAwILfwF+IAAoArwBIQcgACgCZCEMIAAoAsgBIQ0gACgCwAEhBCAAKAJcIQgCQCADQQFGBEAgAUEIayEJIAdBCGohCiAAKAIcIgFBCHQhBiAAKAIEIgsgAWohAUE4IARrrSEPA0AgAUECaiAJSw0CIAFBA2ogASALa0EIdCEOQQAhACAGIQMDQCAAQQNHBEAgACABaiIFKQAAQuPIlb3Lm++NT34gD4inIQQCQAJAIABFBEAgDCAFIAogDRCjHSIFQQZ2Qfz//x9xaiAFQf8BcSAOcjYCACAEQQh2IQUMAQsgCCAEQQh2IgVBAnRqKAIADQELIAggBUECdGogAyAEQf8BcWo2AgALIANBgAJqIQMgAEEBaiEAIAINAQsLIAZBgAZqIQYhAQwACwALIAFBCGshBSAAKAIEIgYgACgCHCIBaiEAQcAAIARrrSEPA0AgAEECaiAFSw0BIABBA2ogASAGaiEJIAAgBmshCkEAIQADQCAAQQNHBEAgACAJaiILKQAAQuPIlb3Lm++NT34gD4inIQQCQAJAIABFBEAgDCALIAcgDRCjHUECdGogCjYCAAwBCyAIIARBAnRqKAIADQELIAggBEECdGogACABajYCAAsgAEEBaiEAIAINAQsLIAFBA2ohASEADAALAAsLwAQCA38DfiMAQZABayIDJAAgASgCCCEEAkACQAJ+AkAgASgCDCgCECACQQR0aiIFKQMIIgggBSkDACIHQoCAgICAgICAgH99IAdUrXxQBEAgAyAEKAIAKAIAKQMAIgY3AyAgAyAHNwMYIAMgByAHQj+HIAYgBkI/hxCoHiADKQMIIAMpAwAiBkI/h1ENASADQQI2AnQgA0GskP8ANgJwIANCAjcCfCADQYYMNgJMIANBhgw2AkQgAyADQUBrNgJ4IAMgA0EgajYCSCADIANBGGo2AkAgA0EwaiADQfAAahCZDiADQeQAaiADQTRqKQIANwIAIANB7ABqIANBPGooAgA2AgAgA0GIgICAeDYCLCADIAMpAiw3AlwgA0EBNgJYIANB2ABqQQRyEIgRCyAEKAIEIQEgAyAINwNIIAMgBzcDQCADQcyR/wA2AlggA0IENwJkIANBhAw2AowBIANB9As2AoQBIAMgAUEBajYCgAEgA0G7BzYCfCADIAE2AnggA0HMATYCdCADQaCS/wA2AnAgAyADQfAAajYCYCADIANBQGs2AogBIANBBDYCXCADQTBqIANB2ABqEJkOIAMpAjghBkGCgICAeCEEIAMpAjAMAQsgA0HwAGogBiAEKAIILQAAEI0QIAMoAnAiBEGTgICAeEYNASADKQJ8IQYgAykCdAshByAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBjcDAAsgA0GQAWokAAv8AwIHfwJ+IwBB4ABrIgMkACADQRhqIgUgAhDnOkEAQQRBDBCgGCADKAIcIQQgAygCGEEBRwRAIANBADYCFCADIAMoAiA2AhAgAyAENgIMIAUgAhDINCABKAIUQQN2IQQgA0E4aiEHIAEoAhAhCAJAA0ACQCADKQNAIgtQRQRAIAMpA0ghCgwBCwNAAn4CQCADKQMoIgpCA1IEQAJAAkACQCAKQgJRDQAgAyAKUK1CAYY3AyggCqdBAXFFDQAgAyADKQMwNwNYDAELIAMoAjhFDQEgA0HQAGogBxC2KiADKQNQIQoLIApCAFINAgsgA0IDNwMoCyADKQMYIgpCAlENBSADQgA3AxggAykDIAwBCyADKQNYCyELIAqnQQFxRQ0DIAMgAykDSEJAfSIKNwNIIAMgCzcDQCALUA0ACwsgAyALQgEgC3oiC4aFNwNAIAEgC6cgCqdqIgIQizshCSACIARJBEAgAygCFCIFIAMoAgxGBEAgA0EMakH4tIMBEJAoCyADKAIQIAVBDGxqIgZBCDYCCCAGIAggAkEDdGpBACAJGzYCBCAGIAI2AgAgAyAFQQFqNgIUDAELCyACIARB6LSDARDDIQALIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgA0HgAGokAA8LIAQgAygCIEHYtIMBEP0vAAv8AwIHfwJ+IwBB4ABrIgMkACADQRhqIgUgAhDnOkEAQQRBDBCgGCADKAIcIQQgAygCGEEBRwRAIANBADYCFCADIAMoAiA2AhAgAyAENgIMIAUgAhDINCABKAIUQQJ2IQQgA0E4aiEHIAEoAhAhCAJAA0ACQCADKQNAIgtQRQRAIAMpA0ghCgwBCwNAAn4CQCADKQMoIgpCA1IEQAJAAkACQCAKQgJRDQAgAyAKUK1CAYY3AyggCqdBAXFFDQAgAyADKQMwNwNYDAELIAMoAjhFDQEgA0HQAGogBxC2KiADKQNQIQoLIApCAFINAgsgA0IDNwMoCyADKQMYIgpCAlENBSADQgA3AxggAykDIAwBCyADKQNYCyELIAqnQQFxRQ0DIAMgAykDSEJAfSIKNwNIIAMgCzcDQCALUA0ACwsgAyALQgEgC3oiC4aFNwNAIAEgC6cgCqdqIgIQizshCSACIARJBEAgAygCFCIFIAMoAgxGBEAgA0EMakH4tIMBEJAoCyADKAIQIAVBDGxqIgZBBDYCCCAGIAggAkECdGpBACAJGzYCBCAGIAI2AgAgAyAFQQFqNgIUDAELCyACIARB6LSDARDDIQALIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgA0HgAGokAA8LIAQgAygCIEHYtIMBEP0vAAupBAEOfyMAQRBrIgMkACABKAIEIQwgAyABKAIIIglBAEEEQRAQoBggAygCBCEHIAMoAgBBAUcEQCADKAIIIQoCQCAHRQ0AIAlBBHQhDUEAIQEgByELA0AgASANRg0BAkACQAJAAkACQAJAAkBBAiABIAxqIgIoAgAiBUH/////B2ogBUGAgICAeE0bQQFrDgQBAgMEAAsgAkEIaigCACEEIAJBBGooAgAhBiACQQxqKAIAIQhBgYCAgHghBQwFCyACQQRqKAIAIQZBgoCAgHghBSACQQhqKAIAIgJFDQMQzC8hBCADIAIQ1xAgBEEIaiADQQhqKQIANwIAIAQgAykCADcCAAwECyACQQxqKAIAIQggBUGAgICAeEYEQCAOIQQgDyEGQYCAgIB4IQUMBAsgAyACEM8LIAMoAgAhBSADKAIEIg8hBiADKAIIIgQhDgwDCyACQQRqKAIAIQZBhICAgHghBSACQQhqKAIAIgJFDQEQzC8hBCADIAIQ1xAgBEEIaiADQQhqKQIANwIAIAQgAykCADcCAAwCCyACQQxqKAIAIQggAkEIaigCACEEIAJBBGooAgAhBgwBC0EAIQQLIAEgCmoiAiAFNgIAIAJBDGogCDYCACACQQhqIAQ2AgAgAkEEaiAGNgIAIAFBEGohASALQQFrIgsNAAsLIAAgCTYCCCAAIAo2AgQgACAHNgIAIANBEGokAA8LIAcgAygCCEHIiocBEP0vAAvDBAEJfyMAQbABayICJAAgAkHYAGogASgCDEEIahD0FSACKAJcIQcCQAJAAkAgAigCWCIDQYGAgIB4RwRAIAAgAigCYDYCDCAAIAc2AgggACADNgIEIABBgICAgHg2AgAMAQsgAkHYAGogASgCCCIDQQBBCEHAABCgGCACKAJcIQUgAigCWEEBRg0BIAJBADYCFCACIAIoAmA2AhAgAiAFNgIMIAMEQCABKAIEIQEgA0EUbCEFIAJBhAFqIQkgAkHkAGohCCACQfAAaiEKA0AgAUEMaigCACIDIAMoAgAiBEEBajYCACAEQQBIDQQgAkGcAWoiBCABELwVIAIgAzYCqAEgAiABQRBqKAIANgKsASACQRhqIgMgBBCfDiACQdgAaiIEIAMQ+D0gAyAEEI0EIAIoAhQiBCACKAIMRgRAIwBBEGsiAyQAIANBCGogAkEMaiIGIAYoAgBBAUEIQcAAELESIAMoAggiBkGBgICAeEcEQCAGIAMoAgxB/MPMABD9LwALIANBEGokAAsgAigCECAEQQZ0aiACQRhqQcAA/AoAACACIARBAWo2AhQgChCSDCACQdgAaiIDEMUnIAMQ6DsgCBCkLCAIEPU8AkAgAigChAEiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgCRD7HgsgAUEUaiEBIAVBFGsiBQ0ACwsgACACKQIMNwIAIAAgBzYCDCAAQQhqIAJBFGooAgA2AgALIAJBsAFqJAAPCyAFIAIoAmBB7MPMABD9LwsAC6wFAgd/AX4jAEHwAGsiAyQAIANBgQE2AlACQAJAAkAgACADQdAAahCiNkUEQEECIAAoAgAlARBxIgRBAEcgBEH///8HRhtB/wFxIghBAkYNAQwCCyADQQc6AFAgA0HQAGogASACENciIQAMAgsjAEEQayIEJAAgBCAAKAIAJQEQcCADQShqIgUgBCgCAAR+IAUgBCsDCDkDCEIBBUIACzcDACAEQRBqJAAgAygCKEUEQCADQThqIAAQkh8CfyADKAI4QYCAgIB4RwRAIANBEGogA0FAaygCACIENgIAIAMgAykCODcDCEEFIQVBASEGIAMoAgwMAQsgA0HEAGohBSMAQRBrIgQkAAJAIAAoAgAlARBbBEAgBEEEaiAAEI8hIAVBCGogBEEMaigCADYCACAFIAQpAgQ3AgAMAQsgACgCACUBEEUEQCAEIAAQlD0iBjYCACAEQQRqIAQQjyEgBUEIaiAEQQxqKAIANgIAIAUgBCkCBDcCACAGQYQBSQ0BIAYQ8h8MAQsgBUGAgICAeDYCAAsgBEEQaiQAAn8gAygCRCIGQYCAgIB4RyIJRQRAIANBEGohBCADQQxqIQcgA0EBNgJUIANBiNLMADYCUCADQgE3AlwgA0HaADYCbCADIAA2AmggAyADQegAajYCWCADQQhqIANB0ABqEJkOQREMAQsgA0EgaiIAIQQgA0EcaiEHIAAgA0HMAGooAgA2AgAgAyADKQJENwMYQQYLIQUgBkGAgICAeEYhBiAEKAIAIQQgBygCAAshACAErSEKDAELQQMhBSADKQMwIQoLIAMgCjcDWCADIAA2AlQgAyAIOgBRIAMgBToAUCADQdAAaiABIAIQ1yIhACAJBEAgA0EYahDeOwsgBkUNACADQQhqEN47CyADQfAAaiQAIAAL3gMCA34FfyMAQSBrIgckAAJAIAJQIAFCqn1Tcg0AQf8PIQggAUK0AlUNACAHQRBqIAGnIgZBBHQiCUHQw4EBaikDAEIAIAIgAnkiA4YiBUIAEKgeIAcpAxAhBCAHKQMYIgJC/wODQv8DUQRAIAcgCUHYw4EBaikDAEIAIAVCABCoHiACIAcpAwgiAiAEfCIEIAJUrXwhAgsgA6chCSACQj+IIgOnIQogBEJ/USABQht8QtIAVnFFBEAgAiADQgl8IgWIIQMCQAJAIAZB6qQNbEEQdSAJayAKakE/aiIGQYJ4TgRAQYAIQf8HIANC/P////////8AgyADIAMgBYYgAlEbIAMgA0IDg0IBURsgAyABQgR8QhxUGyADIARCAlQbIgFCAYMgAXwiAUL/////////H1YiCRsgBmoiBkH+D00NAUIAIQQMBAsgBkHDd08NAUIAIQRBACEIDAMLQgAgAUIBiEL/////////9/8AgyAJGyEEIAYhCAwCCyADQQIgBmtBP3GtiCIBQgGDIAF8IgFC/////////w9WIQggAUIBiCEEDAELIAZB6qQNbEEQdSAKRSIGIAlqa0HM9wFrIQggAiAGrYYhBAsgACAINgIIIAAgBDcDACAHQSBqJAAL8AMBA34gACgCACgCACIAKQMIIgMgASgCACACQQJ0a0EEazUCAIUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAAKQMAIgRCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgAyAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoUgA4kL2AMCBX8BfiMAQfAOayIHJAAgAEEBayIKrSAEIAUgBhCVIwJAAkACQCAAQQFLBEAgB0EEakEAQbwI/AsAIAdBwAhqQQBBkAL8CwAgB0HQCmpBAEGgBPwLAEEBQgEgBCAFIAYQ5RJBBCABQQJrrSAEIAUgBhDlEiABQQFrIghBjwJLDQEgByAIQQJ0aiAANgIAIAdBATYCACAAIAhqIgsgAUsEQCABQZACayEJIAcgAUECdGohAQNAIAlFDQUgAUEBNgIAIAlBAWohCSABQQRqIQEgCkEBayIKDQALCyAHQZACIAsgCyACIAMgB0HACGoiAUGQAiAHQdAKaiICQZACIAQgBSAGEPIIIAhBAXQgAmohAkF/IAh0QX9zrSEMIAEgCGohA0EAIQkDQEEAIQEgCQRAIAggCWoiAUGQAk8NBAsgB0HACGogAWotAAAgB0HQCmogAUEBdGozAQAgBCAFIAYQ5RIgAy0AACACMwEAIAQgBSAGEOUSIAggDCAEIAUgBhDlEiAAIAlBAWoiCUcNAAtBAUIBIAQgBSAGEOUSCyAHQfAOaiQADwsgCEGQAkGc6tEAEMMhAAsgCCAJakGQAkGs6tEAEMMhAAtBkAJBkAJBvOrRABDDIQALuwQCBH8CfiMAQUBqIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AIEEBaw4DAwACAQsACyAAKQMAIgZCgICAgAhaDQQgACkDCCIHQoCAgIAIWg0FIAJBCGogAEEUaiAGpyAHpxCBJCACKAIMIQMgAigCCEEBcQ0GIAAgAzYCGCAAIABBGGoQkT0Q+w42AhwLIAIgAEEcaiIDIAEQxxggAigCACIBQQJHDQFBAyEDDAILQbz1wgAQ6CsACyACKAIEIQQgAygCACIFIAUoAgBBAWsiBTYCACAFRQRAIAMQshoLIAFBAXENBCACIAQ2AhQgAiACQRRqEKg7IgM2AjAgAkEYaiACQTBqEI8hIANBhAFPBEAgAxDyHwsgAkEkaiAAKAIQIAJBGGoQxSYgAigCJEGAgICAeEcNBSACKAIUIgNBhAFPBEAgAxDyHwsgACgCGCIDQYQBTwRAIAMQ8h8LQQEhAyAAKAIUIgRBhAFJDQAgBBDyHwsgACADOgAgIAJBQGskACABQQJGDwtBnODCAEErIAJBMGpB/N/CAEGM9cIAENUeAAtBnODCAEErIAJBMGpB/N/CAEGc9cIAENUeAAsgAiADNgIwQZzgwgBBKyACQTBqQdjgwgBBrPXCABDVHgALIAIgBDYCMEGc4MIAQSsgAkEwakHY4MIAQcz1wgAQ1R4ACyACQThqIAJBLGooAgA2AgAgAiACKQIkNwMwQZzgwgBBKyACQTBqQYjhwgBB3PXCABDVHgALuwQCBH8CfiMAQUBqIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AIEEBaw4DAwACAQsACyAAKQMAIgZCgICAgAhaDQQgACkDCCIHQoCAgIAIWg0FIAJBCGogAEEUaiAGpyAHpxCBJCACKAIMIQMgAigCCEEBcQ0GIAAgAzYCGCAAIABBGGoQkT0Q+w42AhwLIAIgAEEcaiIDIAEQxxggAigCACIBQQJHDQFBAyEDDAILQby5wwAQ6CsACyACKAIEIQQgAygCACIFIAUoAgBBAWsiBTYCACAFRQRAIAMQshoLIAFBAXENBCACIAQ2AhQgAiACQRRqEKg7IgM2AjAgAkEYaiACQTBqEI8hIANBhAFPBEAgAxDyHwsgAkEkaiAAKAIQIAJBGGoQxSYgAigCJEGAgICAeEcNBSACKAIUIgNBhAFPBEAgAxDyHwsgACgCGCIDQYQBTwRAIAMQ8h8LQQEhAyAAKAIUIgRBhAFJDQAgBBDyHwsgACADOgAgIAJBQGskACABQQJGDwtB4KbDAEErIAJBMGpBvKfDAEGMucMAENUeAAtB4KbDAEErIAJBMGpBvKfDAEGcucMAENUeAAsgAiADNgIwQeCmwwBBKyACQTBqQZynwwBBrLnDABDVHgALIAIgBDYCMEHgpsMAQSsgAkEwakGcp8MAQcy5wwAQ1R4ACyACQThqIAJBLGooAgA2AgAgAiACKQIkNwMwQeCmwwBBKyACQTBqQcynwwBB3LnDABDVHgAL8QMCCH4EfyMAQTBrIgskAEKAgICAgICAgIB/IQUCQAJAAn4CQAJAIAAoAgQoAhAgAUEEdGoiCikDACIHIAopAwgiCEKAgICAgICAgIB/hYRCAFIgACgCACINKAIAIgooAgAiDCkDCCICIAwpAwAiA4NCf1JyRQRAQgAhAgwBCyACIAOEUA0DIAtBIGogByAIIAMgAhCDGSALQRBqIAspAyAiBCALKQMoIgUgAyACEKgeQgAgByALKQMQIgl9IAIgA4NCf1EiDBshBkIAIAggCykDGH0gByAJVK19IAwbIQIgCEIAWQ0BCyAEIAYgCigCCCIKKQMAWCACIAopAwgiA1cgAiADURutIgN9IQIgBSADIARWrX0MAQsgBSAEIAYgCigCBCIKKQMAWiACIAopAwgiA1kgAiADURutfCICIARUrXwLIQQCQAJAIAQgAkKAgICAgICAgIB/fSACVK18UEUNACACIA0oAgQtAAAQxSlFDQAgACgCCCABQQN0aiACNwMADAELIAAoAhAiCiAKKAIAQQFqNgIAIAtBCGogACgCFBCGPSABQQN2IgAgCygCDCIKTw0CIAsoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyALQTBqJAAPC0HMj/8AEOIrAAsgACAKQYiL/wAQwyEAC+ebAQEGfyMAQTBrIggkACAIIAM2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAw4hAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gIQsgAkEAQYAB/AsADCELIAFBA00EQAwiCyACIAAoAAAiAEEfdjYCfCACIABBAXE2AgAgAiAAQR52QQFxNgJ4IAIgAEEddkEBcTYCdCACIABBHHZBAXE2AnAgAiAAQRt2QQFxNgJsIAIgAEEadkEBcTYCaCACIABBGXZBAXE2AmQgAiAAQRh2QQFxNgJgIAIgAEEXdkEBcTYCXCACIABBFnZBAXE2AlggAiAAQRV2QQFxNgJUIAIgAEEUdkEBcTYCUCACIABBE3ZBAXE2AkwgAiAAQRJ2QQFxNgJIIAIgAEERdkEBcTYCRCACIABBEHZBAXE2AkAgAiAAQQ92QQFxNgI8IAIgAEEOdkEBcTYCOCACIABBDXZBAXE2AjQgAiAAQQx2QQFxNgIwIAIgAEELdkEBcTYCLCACIABBCnZBAXE2AiggAiAAQQl2QQFxNgIkIAIgAEEIdkEBcTYCICACIABBB3ZBAXE2AhwgAiAAQQZ2QQFxNgIYIAIgAEEFdkEBcTYCFCACIABBBHZBAXE2AhAgAiAAQQN2QQFxNgIMIAIgAEECdkEBcTYCCCACIABBAXZBAXE2AgQMIAsgAUEHTQRADCELIAIgACgAACIBQR52NgI8IAIgAUEDcTYCACACIAAoAAQiAEEedjYCfCACIABBA3E2AkAgAiABQRx2QQNxNgI4IAIgAUEadkEDcTYCNCACIAFBGHZBA3E2AjAgAiABQRZ2QQNxNgIsIAIgAUEUdkEDcTYCKCACIAFBEnZBA3E2AiQgAiABQRB2QQNxNgIgIAIgAUEOdkEDcTYCHCACIAFBDHZBA3E2AhggAiABQQp2QQNxNgIUIAIgAUEIdkEDcTYCECACIAFBBnZBA3E2AgwgAiABQQR2QQNxNgIIIAIgAUECdkEDcTYCBCACIABBHHZBA3E2AnggAiAAQRp2QQNxNgJ0IAIgAEEYdkEDcTYCcCACIABBFnZBA3E2AmwgAiAAQRR2QQNxNgJoIAIgAEESdkEDcTYCZCACIABBEHZBA3E2AmAgAiAAQQ52QQNxNgJcIAIgAEEMdkEDcTYCWCACIABBCnZBA3E2AlQgAiAAQQh2QQNxNgJQIAIgAEEGdkEDcTYCTCACIABBBHZBA3E2AkggAiAAQQJ2QQNxNgJEDB8LIAFBC00EQAwgCyACIAAoAAAiA0EHcTYCACACIANBG3ZBB3E2AiQgAiADQRh2QQdxNgIgIAIgA0EVdkEHcTYCHCACIANBEnZBB3E2AhggAiADQQ92QQdxNgIUIAIgA0EMdkEHcTYCECACIANBCXZBB3E2AgwgAiADQQZ2QQdxNgIIIAIgA0EDdkEHcTYCBCACIAAoAAQiAUEcdkEHcTYCUCACIAFBGXZBB3E2AkwgAiABQRZ2QQdxNgJIIAIgAUETdkEHcTYCRCACIAFBEHZBB3E2AkAgAiABQQ12QQdxNgI8IAIgAUEKdkEHcTYCOCACIAFBB3ZBB3E2AjQgAiABQQR2QQdxNgIwIAIgAUEBdkEHcTYCLCACIAFBAnRBBHEgA0EednI2AiggAiAAKAAIIgBBHXY2AnwgAiAAQRp2QQdxNgJ4IAIgAEEXdkEHcTYCdCACIABBFHZBB3E2AnAgAiAAQRF2QQdxNgJsIAIgAEEOdkEHcTYCaCACIABBC3ZBB3E2AmQgAiAAQQh2QQdxNgJgIAIgAEEFdkEHcTYCXCACIABBAnZBB3E2AlggAiAAQQF0QQZxIAFBH3ZyNgJUDB4LIAFBD00EQAwfCyACIAAoAAAiAUEcdjYCHCACIAFBD3E2AgAgAiAAKAAEIgNBHHY2AjwgAiADQQ9xNgIgIAIgAUEYdkEPcTYCGCACIAFBFHZBD3E2AhQgAiABQRB2QQ9xNgIQIAIgAUEMdkEPcTYCDCACIAFBCHZBD3E2AgggAiABQQR2QQ9xNgIEIAIgA0EYdkEPcTYCOCACIANBFHZBD3E2AjQgAiADQRB2QQ9xNgIwIAIgA0EMdkEPcTYCLCACIANBCHZBD3E2AiggAiADQQR2QQ9xNgIkIAIgACgACCIBQRx2NgJcIAIgAUEYdkEPcTYCWCACIAFBFHZBD3E2AlQgAiABQRB2QQ9xNgJQIAIgAUEMdkEPcTYCTCACIAFBCHZBD3E2AkggAiABQQR2QQ9xNgJEIAIgAUEPcTYCQCACIAAoAAwiAEEcdjYCfCACIABBD3E2AmAgAiAAQRh2QQ9xNgJ4IAIgAEEUdkEPcTYCdCACIABBEHZBD3E2AnAgAiAAQQx2QQ9xNgJsIAIgAEEIdkEPcTYCaCACIABBBHZBD3E2AmQMHQsgAUETTQRADB4LIAIgACgAACIDQR9xNgIAIAIgA0EZdkEfcTYCFCACIANBFHZBH3E2AhAgAiADQQ92QR9xNgIMIAIgA0EKdkEfcTYCCCACIANBBXZBH3E2AgQgAiAAKAAEIgRBF3ZBH3E2AiwgAiAEQRJ2QR9xNgIoIAIgBEENdkEfcTYCJCACIARBCHZBH3E2AiAgAiAEQQN2QR9xNgIcIAIgACgACCIBQRp2QR9xNgJIIAIgAUEVdkEfcTYCRCACIAFBEHZBH3E2AkAgAiABQQt2QR9xNgI8IAIgAUEGdkEfcTYCOCACIAFBAXZBH3E2AjQgAiAEQQJ0QRxxIANBHnZyNgIYIAIgAUEEdEEQcSAEQRx2cjYCMCACIAAoABAiA0EbdjYCfCACIAAoAAwiAEEYdkEfcTYCYCACIABBE3ZBH3E2AlwgAiAAQQ52QR9xNgJYIAIgAEEJdkEfcTYCVCACIABBBHZBH3E2AlAgAiADQRZ2QR9xNgJ4IAIgA0ERdkEfcTYCdCACIANBDHZBH3E2AnAgAiADQQd2QR9xNgJsIAIgA0ECdkEfcTYCaCACIABBAXRBHnEgAUEfdnI2AkwgAiADQQN0QRhxIABBHXZyNgJkDBwLIAFBF00EQAwdCyACIAAoAAAiAUE/cTYCACACIAAoAAgiA0EadjYCPCACIAFBGHZBP3E2AhAgAiABQRJ2QT9xNgIMIAIgAUEMdkE/cTYCCCACIAFBBnZBP3E2AgQgAiAAKAAEIgRBFnZBP3E2AiQgAiAEQRB2QT9xNgIgIAIgBEEKdkE/cTYCHCACIARBBHZBP3E2AhggAiADQRR2QT9xNgI4IAIgA0EOdkE/cTYCNCACIANBCHZBP3E2AjAgAiADQQJ2QT9xNgIsIAIgBEECdEE8cSABQR52cjYCFCACIANBBHRBMHEgBEEcdnI2AiggAiAAKAAMIgFBP3E2AkAgAiAAKAAUIgNBGnY2AnwgAiABQRh2QT9xNgJQIAIgAUESdkE/cTYCTCACIAFBDHZBP3E2AkggAiABQQZ2QT9xNgJEIAIgACgAECIAQRZ2QT9xNgJkIAIgAEEQdkE/cTYCYCACIABBCnZBP3E2AlwgAiAAQQR2QT9xNgJYIAIgA0EUdkE/cTYCeCACIANBDnZBP3E2AnQgAiADQQh2QT9xNgJwIAIgA0ECdkE/cTYCbCACIABBAnRBPHEgAUEednI2AlQgAiADQQR0QTBxIABBHHZyNgJoDBsLIAFBG00EQAwcCyACIAAoAAAiBEH/AHE2AgAgAiAEQRV2Qf8AcTYCDCACIARBDnZB/wBxNgIIIAIgBEEHdkH/AHE2AgQgAiAAKAAEIgFBGHZB/wBxNgIgIAIgAUERdkH/AHE2AhwgAiABQQp2Qf8AcTYCGCACIAFBA3ZB/wBxNgIUIAIgACgACCIFQRR2Qf8AcTYCMCACIAVBDXZB/wBxNgIsIAIgBUEGdkH/AHE2AiggAiAAKAAMIgNBF3ZB/wBxNgJEIAIgA0EQdkH/AHE2AkAgAiADQQl2Qf8AcTYCPCACIANBAnZB/wBxNgI4IAIgAUEEdEHwAHEgBEEcdnI2AhAgAiAFQQF0Qf4AcSABQR92cjYCJCACIANBBXRB4ABxIAVBG3ZyNgI0IAIgACgAGCIBQRl2NgJ8IAIgACgAECIEQRN2Qf8AcTYCVCACIARBDHZB/wBxNgJQIAIgBEEFdkH/AHE2AkwgAiAAKAAUIgBBFnZB/wBxNgJoIAIgAEEPdkH/AHE2AmQgAiAAQQh2Qf8AcTYCYCACIABBAXZB/wBxNgJcIAIgAUESdkH/AHE2AnggAiABQQt2Qf8AcTYCdCACIAFBBHZB/wBxNgJwIAIgBEECdEH8AHEgA0EednI2AkggAiAAQQZ0QcAAcSAEQRp2cjYCWCACIAFBA3RB+ABxIABBHXZyNgJsDBoLIAFBH00EQAwbCyACIAAoAAAiAUEYdjYCDCACIAFB/wFxNgIAIAIgACgABCIDQRh2NgIcIAIgA0H/AXE2AhAgAiAAKAAIIgRBGHY2AiwgAiAEQf8BcTYCICACIAAoAAwiBUEYdjYCPCACIAVB/wFxNgIwIAIgAUEQdkH/AXE2AgggAiABQQh2Qf8BcTYCBCACIANBEHZB/wFxNgIYIAIgA0EIdkH/AXE2AhQgAiAEQRB2Qf8BcTYCKCACIARBCHZB/wFxNgIkIAIgBUEQdkH/AXE2AjggAiAFQQh2Qf8BcTYCNCACIAAoABAiAUEYdjYCTCACIAFB/wFxNgJAIAIgACgAFCIDQRh2NgJcIAIgA0H/AXE2AlAgAiAAKAAYIgRBGHY2AmwgAiAEQf8BcTYCYCACIAAoABwiAEEYdjYCfCACIABB/wFxNgJwIAIgAUEQdkH/AXE2AkggAiABQQh2Qf8BcTYCRCACIANBEHZB/wFxNgJYIAIgA0EIdkH/AXE2AlQgAiAEQRB2Qf8BcTYCaCACIARBCHZB/wFxNgJkIAIgAEEQdkH/AXE2AnggAiAAQQh2Qf8BcTYCdAwZCyABQSNNBEAMGgsgAiAAKAAAIgRB/wNxNgIAIAIgBEESdkH/A3E2AgggAiAEQQl2Qf8DcTYCBCACIAAoAAQiAUEWdkH/A3E2AhggAiABQQ12Qf8DcTYCFCACIAFBBHZB/wNxNgIQIAIgACgACCIFQRF2Qf8DcTYCJCACIAVBCHZB/wNxNgIgIAIgACgADCIDQRV2Qf8DcTYCNCACIANBDHZB/wNxNgIwIAIgA0EDdkH/A3E2AiwgAiABQQV0QeADcSAEQRt2cjYCDCACIAVBAXRB/gNxIAFBH3ZyNgIcIAIgA0EGdEHAA3EgBUEadnI2AiggAiAAKAAQIgRBEHZB/wNxNgJAIAIgBEEHdkH/A3E2AjwgAiAEQQJ0QfwDcSADQR52cjYCOCACIAAoABQiAUEUdkH/A3E2AlAgAiABQQt2Qf8DcTYCTCACIAFBAnZB/wNxNgJIIAIgACgAGCIFQQ92Qf8DcTYCXCACIAVBBnZB/wNxNgJYIAIgACgAHCIDQRN2Qf8DcTYCbCACIANBCnZB/wNxNgJoIAIgA0EBdkH/A3E2AmQgAiABQQd0QYADcSAEQRl2cjYCRCACIAVBA3RB+ANxIAFBHXZyNgJUIAIgA0EIdEGAAnEgBUEYdnI2AmAgAiAAKAAgIgBBF3Y2AnwgAiAAQQ52Qf8DcTYCeCACIABBBXZB/wNxNgJ0IAIgAEEEdEHwA3EgA0EcdnI2AnAMGAsgAUEnTQRADBkLIAIgACgAACIBQf8HcTYCACACIAAoABAiA0EWdjYCPCACIAFBFHZB/wdxNgIIIAIgAUEKdkH/B3E2AgQgAiAAKAAEIgRBEnZB/wdxNgIUIAIgBEEIdkH/B3E2AhAgAiAAKAAIIgVBEHZB/wdxNgIgIAIgBUEGdkH/B3E2AhwgAiAAKAAMIgZBDnZB/wdxNgIsIAIgBkEEdkH/B3E2AiggAiADQQx2Qf8HcTYCOCACIANBAnZB/wdxNgI0IAIgBEECdEH8B3EgAUEednI2AgwgAiAFQQR0QfAHcSAEQRx2cjYCGCACIAZBBnRBwAdxIAVBGnZyNgIkIAIgA0EIdEGABnEgBkEYdnI2AjAgAiAAKAAUIgFB/wdxNgJAIAIgACgAJCIDQRZ2NgJ8IAIgAUEUdkH/B3E2AkggAiABQQp2Qf8HcTYCRCACIAAoABgiBEESdkH/B3E2AlQgAiAEQQh2Qf8HcTYCUCACIAAoABwiBUEQdkH/B3E2AmAgAiAFQQZ2Qf8HcTYCXCACIAAoACAiAEEOdkH/B3E2AmwgAiAAQQR2Qf8HcTYCaCACIANBDHZB/wdxNgJ4IAIgA0ECdkH/B3E2AnQgAiAEQQJ0QfwHcSABQR52cjYCTCACIAVBBHRB8AdxIARBHHZyNgJYIAIgAEEGdEHAB3EgBUEadnI2AmQgAiADQQh0QYAGcSAAQRh2cjYCcAwXCyABQStNBEAMGAsgAiAAKAAAIgZB/w9xNgIAIAIgBkELdkH/D3E2AgQgAiAAKAAEIgFBDHZB/w9xNgIQIAIgAUEBdkH/D3E2AgwgAiAAKAAIIgNBDXZB/w9xNgIcIAIgA0ECdkH/D3E2AhggAiAAKAAMIgRBDnZB/w9xNgIoIAIgBEEDdkH/D3E2AiQgAiAAKAAQIgVBD3ZB/w9xNgI0IAIgBUEEdkH/D3E2AjAgAiABQQp0QYAIcSAGQRZ2cjYCCCACIANBCXRBgAxxIAFBF3ZyNgIUIAIgBEEIdEGADnEgA0EYdnI2AiAgAiAFQQd0QYAPcSAEQRl2cjYCLCACIAAoABQiAUEQdkH/D3E2AkAgAiABQQV2Qf8PcTYCPCACIAAoABgiA0ERdkH/D3E2AkwgAiADQQZ2Qf8PcTYCSCACIAAoABwiBEESdkH/D3E2AlggAiAEQQd2Qf8PcTYCVCACIAAoACAiBkETdkH/D3E2AmQgAiAGQQh2Qf8PcTYCYCACIAAoACQiB0EUdkH/D3E2AnAgAiAHQQl2Qf8PcTYCbCACIAFBBnRBwA9xIAVBGnZyNgI4IAIgA0EFdEHgD3EgAUEbdnI2AkQgAiAEQQR0QfAPcSADQRx2cjYCUCACIAZBA3RB+A9xIARBHXZyNgJcIAIgB0ECdEH8D3EgBkEednI2AmggAiAAKAAoIgBBFXY2AnwgAiAAQQp2Qf8PcTYCeCACIABBAXRB/g9xIAdBH3ZyNgJ0DBYLIAFBL00EQAwXCyACIAAoAAAiBEH/H3E2AgAgAiAAKAAIIgVBFHY2AhwgAiAAKAAMIgZB/x9xNgIgIAIgBEEMdkH/H3E2AgQgAiAAKAAEIgFBEHZB/x9xNgIQIAIgAUEEdkH/H3E2AgwgAiAFQQh2Qf8fcTYCGCACIAZBDHZB/x9xNgIkIAIgACgAECIDQRB2Qf8fcTYCMCACIANBBHZB/x9xNgIsIAIgAUEIdEGAHnEgBEEYdnI2AgggAiAFQQR0QfAfcSABQRx2cjYCFCACIANBCHRBgB5xIAZBGHZyNgIoIAIgACgAFCIBQRR2NgI8IAIgAUEIdkH/H3E2AjggAiABQQR0QfAfcSADQRx2cjYCNCACIAAoABgiA0H/H3E2AkAgAiAAKAAgIgRBFHY2AlwgAiAAKAAkIgVB/x9xNgJgIAIgA0EMdkH/H3E2AkQgAiAAKAAcIgFBEHZB/x9xNgJQIAIgAUEEdkH/H3E2AkwgAiAEQQh2Qf8fcTYCWCACIAVBDHZB/x9xNgJkIAIgAUEIdEGAHnEgA0EYdnI2AkggAiAEQQR0QfAfcSABQRx2cjYCVCACIAAoACgiAUEQdkH/H3E2AnAgAiABQQR2Qf8fcTYCbCACIAFBCHRBgB5xIAVBGHZyNgJoIAIgACgALCIAQRR2NgJ8IAIgAEEIdkH/H3E2AnggAiAAQQR0QfAfcSABQRx2cjYCdAwVCyABQTNNBEAMFgsgAiAAKAAAIgRB/z9xNgIAIAIgBEENdkH/P3E2AgQgAiAAKAAEIgVBB3ZB/z9xNgIMIAIgACgACCIBQQ52Qf8/cTYCGCACIAFBAXZB/z9xNgIUIAIgACgADCIGQQh2Qf8/cTYCICACIAAoABAiA0EPdkH/P3E2AiwgAiADQQJ2Qf8/cTYCKCACIAAoABQiB0EJdkH/P3E2AjQgAiAFQQZ0QcA/cSAEQRp2cjYCCCACIAFBDHRBgCBxIAVBFHZyNgIQIAIgBkEFdEHgP3EgAUEbdnI2AhwgAiADQQt0QYAwcSAGQRV2cjYCJCACIAdBBHRB8D9xIANBHHZyNgIwIAIgACgAGCIBQRB2Qf8/cTYCQCACIAFBA3ZB/z9xNgI8IAIgACgAHCIFQQp2Qf8/cTYCSCACIAAoACAiA0ERdkH/P3E2AlQgAiADQQR2Qf8/cTYCUCACIAAoACQiBkELdkH/P3E2AlwgAiAAKAAoIgRBEnZB/z9xNgJoIAIgBEEFdkH/P3E2AmQgAiABQQp0QYA4cSAHQRZ2cjYCOCACIAVBA3RB+D9xIAFBHXZyNgJEIAIgA0EJdEGAPHEgBUEXdnI2AkwgAiAGQQJ0Qfw/cSADQR52cjYCWCACIARBCHRBgD5xIAZBGHZyNgJgIAIgACgALCIBQQx2Qf8/cTYCcCACIAFBAXRB/j9xIARBH3ZyNgJsIAIgACgAMCIAQRN2NgJ8IAIgAEEGdkH/P3E2AnggAiAAQQd0QYA/cSABQRl2cjYCdAwUCyABQTdNBEAMFQsgAiAAKAAAIgNB//8AcTYCACACIANBDnZB//8AcTYCBCACIAAoAAQiBEEKdkH//wBxNgIMIAIgACgACCIFQQZ2Qf//AHE2AhQgAiAAKAAMIgFBEHZB//8AcTYCICACIAFBAnZB//8AcTYCHCACIAAoABAiBkEMdkH//wBxNgIoIAIgACgAFCIHQQh2Qf//AHE2AjAgAiAEQQR0QfD/AHEgA0EcdnI2AgggAiAFQQh0QYD+AHEgBEEYdnI2AhAgAiABQQx0QYDgAHEgBUEUdnI2AhggAiAGQQJ0Qfz/AHEgAUEednI2AiQgAiAHQQZ0QcD/AHEgBkEadnI2AiwgAiAAKAAYIgNBEnY2AjwgAiAAKAAcIgRB//8AcTYCQCACIANBBHZB//8AcTYCOCACIARBDnZB//8AcTYCRCACIAAoACAiBUEKdkH//wBxNgJMIAIgACgAJCIGQQZ2Qf//AHE2AlQgAiAAKAAoIgFBEHZB//8AcTYCYCACIAFBAnZB//8AcTYCXCACIANBCnRBgPgAcSAHQRZ2cjYCNCACIAVBBHRB8P8AcSAEQRx2cjYCSCACIAZBCHRBgP4AcSAFQRh2cjYCUCACIAFBDHRBgOAAcSAGQRR2cjYCWCACIAAoACwiA0EMdkH//wBxNgJoIAIgA0ECdEH8/wBxIAFBHnZyNgJkIAIgACgAMCIBQQh2Qf//AHE2AnAgAiABQQZ0QcD/AHEgA0EadnI2AmwgAiAAKAA0IgBBEnY2AnwgAiAAQQR2Qf//AHE2AnggAiAAQQp0QYD4AHEgAUEWdnI2AnQMEwsgAUE7TQRADBQLIAIgACgAACIBQf//AXE2AgAgAiABQQ92Qf//AXE2AgQgAiAAKAAEIgNBDXZB//8BcTYCDCACIAAoAAgiBEELdkH//wFxNgIUIAIgACgADCIFQQl2Qf//AXE2AhwgAiAAKAAQIgZBB3ZB//8BcTYCJCACIAAoABQiB0EFdkH//wFxNgIsIAIgA0ECdEH8/wFxIAFBHnZyNgIIIAIgBEEEdEHw/wFxIANBHHZyNgIQIAIgBUEGdEHA/wFxIARBGnZyNgIYIAIgBkEIdEGA/gFxIAVBGHZyNgIgIAIgB0EKdEGA+AFxIAZBFnZyNgIoIAIgACgAGCIDQQN2Qf//AXE2AjQgAiADQQx0QYDgAXEgB0EUdnI2AjAgAiAAKAAcIgFBEHZB//8BcTYCQCACIAFBAXZB//8BcTYCPCACIAAoACAiBEEOdkH//wFxNgJIIAIgACgAJCIFQQx2Qf//AXE2AlAgAiAAKAAoIgZBCnZB//8BcTYCWCACIAAoACwiB0EIdkH//wFxNgJgIAIgAUEOdEGAgAFxIANBEnZyNgI4IAIgBEEBdEH+/wFxIAFBH3ZyNgJEIAIgBUEDdEH4/wFxIARBHXZyNgJMIAIgBkEFdEHg/wFxIAVBG3ZyNgJUIAIgB0EHdEGA/wFxIAZBGXZyNgJcIAIgACgAMCIBQQZ2Qf//AXE2AmggAiABQQl0QYD8AXEgB0EXdnI2AmQgAiAAKAA0IgNBBHZB//8BcTYCcCACIANBC3RBgPABcSABQRV2cjYCbCACIAAoADgiAEERdjYCfCACIABBAnZB//8BcTYCeCACIABBDXRBgMABcSADQRN2cjYCdAwSCyABQT9NBEAMEwsgAiAAKAAAIgFBEHY2AgQgAiABQf//A3E2AgAgAiAAKAAEIgFBEHY2AgwgAiABQf//A3E2AgggAiAAKAAIIgFBEHY2AhQgAiABQf//A3E2AhAgAiAAKAAMIgFBEHY2AhwgAiABQf//A3E2AhggAiAAKAAQIgFBEHY2AiQgAiABQf//A3E2AiAgAiAAKAAUIgFBEHY2AiwgAiABQf//A3E2AiggAiAAKAAYIgFBEHY2AjQgAiABQf//A3E2AjAgAiAAKAAcIgFBEHY2AjwgAiABQf//A3E2AjggAiAAKAAgIgFBEHY2AkQgAiABQf//A3E2AkAgAiAAKAAkIgFBEHY2AkwgAiABQf//A3E2AkggAiAAKAAoIgFBEHY2AlQgAiABQf//A3E2AlAgAiAAKAAsIgFB//8DcTYCWCACIAFBEHY2AlwgAiAAKAAwIgFBEHY2AmQgAiABQf//A3E2AmAgAiAAKAA0IgFBEHY2AmwgAiABQf//A3E2AmggAiAAKAA4IgFBEHY2AnQgAiABQf//A3E2AnAgAiAAKAA8IgBBEHY2AnwgAiAAQf//A3E2AngMEQsgAUHDAE0EQAwSCyACIAAoAAAiCUH//wdxNgIAIAIgACgABCIBQQJ2Qf//B3E2AgggAiAAKAAIIgNBBHZB//8HcTYCECACIAAoAAwiBEEGdkH//wdxNgIYIAIgACgAECIFQQh2Qf//B3E2AiAgAiAAKAAUIgZBCnZB//8HcTYCKCACIAAoABgiB0EMdkH//wdxNgIwIAIgAUEPdEGAgAZxIAlBEXZyNgIEIAIgA0ENdEGAwAdxIAFBE3ZyNgIMIAIgBEELdEGA8AdxIANBFXZyNgIUIAIgBUEJdEGA/AdxIARBF3ZyNgIcIAIgBkEHdEGA/wdxIAVBGXZyNgIkIAIgB0EFdEHg/wdxIAZBG3ZyNgIsIAIgACgAHCIBQQ52Qf//B3E2AjggAiAAKAAkIgNBAXZB//8HcTYCRCACIAAoACgiBEEDdkH//wdxNgJMIAIgACgALCIFQQV2Qf//B3E2AlQgAiAAKAAwIgZBB3ZB//8HcTYCXCACIAFBA3RB+P8HcSAHQR12cjYCNCACIAAoACAiB0EBdEH+/wdxIAFBH3ZyNgI8IAIgA0EQdEGAgARxIAdBEHZyNgJAIAIgBEEOdEGAgAdxIANBEnZyNgJIIAIgBUEMdEGA4AdxIARBFHZyNgJQIAIgBkEKdEGA+AdxIAVBFnZyNgJYIAIgACgANCIBQQl2Qf//B3E2AmQgAiABQQh0QYD+B3EgBkEYdnI2AmAgAiAAKAA4IgNBC3ZB//8HcTYCbCACIANBBnRBwP8HcSABQRp2cjYCaCACIAAoADwiAUENdkH//wdxNgJ0IAIgAUEEdEHw/wdxIANBHHZyNgJwIAIgACgAQCIAQQ92NgJ8IAIgAEECdEH8/wdxIAFBHnZyNgJ4DBALIAFBxwBNBEAMEQsgAiAAKAAAIgdB//8PcTYCACACIAAoAAQiAUEEdkH//w9xNgIIIAIgACgACCIDQQh2Qf//D3E2AhAgAiAAKAAMIgRBDHZB//8PcTYCGCACIAAoABQiBUECdkH//w9xNgIkIAIgACgAGCIGQQZ2Qf//D3E2AiwgAiABQQ50QYCAD3EgB0ESdnI2AgQgAiADQQp0QYD4D3EgAUEWdnI2AgwgAiAEQQZ0QcD/D3EgA0EadnI2AhQgAiAAKAAQIgFBAnRB/P8PcSAEQR52cjYCHCACIAVBEHRBgIAMcSABQRB2cjYCICACIAZBDHRBgOAPcSAFQRR2cjYCKCACIAAoACAiB0EOdjYCPCACIAAoACQiCUH//w9xNgJAIAIgACgAHCIBQQp2Qf//D3E2AjQgAiAAKAAoIgNBBHZB//8PcTYCSCACIAAoACwiBEEIdkH//w9xNgJQIAIgACgAMCIFQQx2Qf//D3E2AlggAiABQQh0QYD+D3EgBkEYdnI2AjAgAiAHQQR0QfD/D3EgAUEcdnI2AjggAiADQQ50QYCAD3EgCUESdnI2AkQgAiAEQQp0QYD4D3EgA0EWdnI2AkwgAiAFQQZ0QcD/D3EgBEEadnI2AlQgAiAAKAA0IgNBAnRB/P8PcSAFQR52cjYCXCACIAAoADgiAUECdkH//w9xNgJkIAIgAUEQdEGAgAxxIANBEHZyNgJgIAIgACgAPCIDQQZ2Qf//D3E2AmwgAiADQQx0QYDgD3EgAUEUdnI2AmggAiAAKABAIgFBCnZB//8PcTYCdCACIAFBCHRBgP4PcSADQRh2cjYCcCACIAAoAEQiAEEOdjYCfCACIABBBHRB8P8PcSABQRx2cjYCeAwPCyABQcsATQRADBALIAIgACgAACIGQf//H3E2AgAgAiAAKAAEIgFBBnZB//8fcTYCCCACIAAoAAgiA0EMdkH//x9xNgIQIAIgACgAECIEQQV2Qf//H3E2AhwgAiAAKAAUIgVBC3ZB//8fcTYCJCACIAFBDXRBgMAfcSAGQRN2cjYCBCACIANBB3RBgP8fcSABQRl2cjYCDCACIAAoAAwiAUEBdEH+/x9xIANBH3ZyNgIUIAIgBEEOdEGAgB9xIAFBEnZyNgIYIAIgBUEIdEGA/h9xIARBGHZyNgIgIAIgACgAGCIDQQJ0Qfz/H3EgBUEednI2AiggAiAAKAAcIgFBBHZB//8fcTYCMCACIAFBD3RBgIAecSADQRF2cjYCLCACIAAoACAiA0EKdkH//x9xNgI4IAIgACgAKCIEQQN2Qf//H3E2AkQgAiAAKAAsIgVBCXZB//8fcTYCTCACIAAoADQiBkECdkH//x9xNgJYIAIgA0EJdEGA/B9xIAFBF3ZyNgI0IAIgACgAJCIBQQN0Qfj/H3EgA0EddnI2AjwgAiAEQRB0QYCAHHEgAUEQdnI2AkAgAiAFQQp0QYD4H3EgBEEWdnI2AkggAiAAKAAwIgFBBHRB8P8fcSAFQRx2cjYCUCACIAZBEXRBgIAYcSABQQ92cjYCVCACIAAoADgiAUEIdkH//x9xNgJgIAIgAUELdEGA8B9xIAZBFXZyNgJcIAIgACgAPCIDQQV0QeD/H3EgAUEbdnI2AmQgAiAAKABAIgFBAXZB//8fcTYCbCACIAFBEnRBgIAQcSADQQ52cjYCaCACIAAoAEQiA0EHdkH//x9xNgJ0IAIgA0EMdEGA4B9xIAFBFHZyNgJwIAIgACgASCIAQQ12NgJ8IAIgAEEGdEHA/x9xIANBGnZyNgJ4DA4LIAFBzwBNBEAMDwsgAiAAKAAAIgVB//8/cTYCACACIAAoABAiBkEMdjYCHCACIAAoABQiB0H//z9xNgIgIAIgACgABCIBQQh2Qf//P3E2AgggAiAAKAAMIgNBBHZB//8/cTYCFCACIAAoABgiBEEIdkH//z9xNgIoIAIgAUEMdEGA4D9xIAVBFHZyNgIEIAIgACgACCIFQQR0QfD/P3EgAUEcdnI2AgwgAiADQRB0QYCAPHEgBUEQdnI2AhAgAiAGQQh0QYD+P3EgA0EYdnI2AhggAiAEQQx0QYDgP3EgB0EUdnI2AiQgAiAAKAAcIgVBBHRB8P8/cSAEQRx2cjYCLCACIAAoACQiBkEMdjYCPCACIAAoACgiB0H//z9xNgJAIAIgACgAOCIJQQx2NgJcIAIgACgAICIBQQR2Qf//P3E2AjQgAiAAKAAsIgNBCHZB//8/cTYCSCACIAAoADQiBEEEdkH//z9xNgJUIAIgAUEQdEGAgDxxIAVBEHZyNgIwIAIgBkEIdEGA/j9xIAFBGHZyNgI4IAIgA0EMdEGA4D9xIAdBFHZyNgJEIAIgACgAMCIBQQR0QfD/P3EgA0EcdnI2AkwgAiAEQRB0QYCAPHEgAUEQdnI2AlAgAiAJQQh0QYD+P3EgBEEYdnI2AlggAiAAKAA8IgNB//8/cTYCYCACIAAoAEAiAUEIdkH//z9xNgJoIAIgAUEMdEGA4D9xIANBFHZyNgJkIAIgACgARCIDQQR0QfD/P3EgAUEcdnI2AmwgAiAAKABIIgFBBHZB//8/cTYCdCACIAFBEHRBgIA8cSADQRB2cjYCcCACIAAoAEwiAEEMdjYCfCACIABBCHRBgP4/cSABQRh2cjYCeAwNCyABQdMATQRADA4LIAIgACgAACIGQf///wBxNgIAIAIgACgABCIBQQp2Qf///wBxNgIIIAIgACgADCIDQQl2Qf///wBxNgIUIAIgACgAFCIEQQh2Qf///wBxNgIgIAIgACgAHCIFQQd2Qf///wBxNgIsIAIgAUELdEGA8P8AcSAGQRV2cjYCBCACIAAoAAgiBkEBdEH+//8AcSABQR92cjYCDCACIANBDHRBgOD/AHEgBkEUdnI2AhAgAiAAKAAQIgFBAnRB/P//AHEgA0EednI2AhggAiAEQQ10QYDA/wBxIAFBE3ZyNgIcIAIgACgAGCIBQQN0Qfj//wBxIARBHXZyNgIkIAIgBUEOdEGAgP8AcSABQRJ2cjYCKCACIAAoACQiAUEGdkH///8AcTYCOCACIAAoACwiA0EFdkH///8AcTYCRCACIAAoADQiBEEEdkH///8AcTYCUCACIAAoADwiBkEDdkH///8AcTYCXCACIAAoACAiB0EEdEHw//8AcSAFQRx2cjYCMCACIAFBD3RBgID+AHEgB0ERdnI2AjQgAiAAKAAoIgVBBXRB4P//AHEgAUEbdnI2AjwgAiADQRB0QYCA/ABxIAVBEHZyNgJAIAIgACgAMCIBQQZ0QcD//wBxIANBGnZyNgJIIAIgBEERdEGAgPgAcSABQQ92cjYCTCACIAAoADgiAUEHdEGA//8AcSAEQRl2cjYCVCACIAZBEnRBgIDwAHEgAUEOdnI2AlggAiAAKABAIgNBCHRBgP7/AHEgBkEYdnI2AmAgAiAAKABEIgFBAnZB////AHE2AmggAiABQRN0QYCA4ABxIANBDXZyNgJkIAIgACgASCIDQQl0QYD8/wBxIAFBF3ZyNgJsIAIgACgATCIBQQF2Qf///wBxNgJ0IAIgAUEUdEGAgMAAcSADQQx2cjYCcCACIAAoAFAiAEELdjYCfCACIABBCnRBgPj/AHEgAUEWdnI2AngMDAsgAUHXAE0EQAwNCyACIAAoAAAiBUH///8BcTYCACACIAAoAAgiAUECdkH///8BcTYCDCACIAAoABAiA0EEdkH///8BcTYCGCACIAAoABgiBEEGdkH///8BcTYCJCACIAAoAAQiBkEKdEGA+P8BcSAFQRZ2cjYCBCACIAFBFHRBgIDAAXEgBkEMdnI2AgggAiAAKAAMIgVBCHRBgP7/AXEgAUEYdnI2AhAgAiADQRJ0QYCA8AFxIAVBDnZyNgIUIAIgACgAFCIBQQZ0QcD//wFxIANBGnZyNgIcIAIgBEEQdEGAgPwBcSABQRB2cjYCICACIAAoABwiBUEEdEHw//8BcSAEQRx2cjYCKCACIAAoACgiBEEKdjYCPCACIAAoACwiBkH///8BcTYCQCACIAAoACAiAUEIdkH///8BcTYCMCACIAAoADQiA0ECdkH///8BcTYCTCACIAFBDnRBgID/AXEgBUESdnI2AiwgAiAAKAAkIgVBAnRB/P//AXEgAUEednI2AjQgAiAEQQx0QYDg/wFxIAVBFHZyNgI4IAIgACgAMCIBQQp0QYD4/wFxIAZBFnZyNgJEIAIgA0EUdEGAgMABcSABQQx2cjYCSCACIAAoADgiBEEIdEGA/v8BcSADQRh2cjYCUCACIAAoADwiAUEEdkH///8BcTYCWCACIAFBEnRBgIDwAXEgBEEOdnI2AlQgAiAAKABAIgNBBnRBwP//AXEgAUEadnI2AlwgAiAAKABEIgFBBnZB////AXE2AmQgAiABQRB0QYCA/AFxIANBEHZyNgJgIAIgACgASCIDQQR0QfD//wFxIAFBHHZyNgJoIAIgACgATCIBQQh2Qf///wFxNgJwIAIgAUEOdEGAgP8BcSADQRJ2cjYCbCACIAAoAFAiA0ECdEH8//8BcSABQR52cjYCdCACIAAoAFQiAEEKdjYCfCACIABBDHRBgOD/AXEgA0EUdnI2AngMCwsgAUHbAE0EQAwMCyACIAAoAAAiBUH///8DcTYCACACIAAoAAgiAUEFdkH///8DcTYCDCACIAAoABQiA0EBdkH///8DcTYCHCACIAAoABwiBEEGdkH///8DcTYCKCACIAAoAAQiBkEJdEGA/P8DcSAFQRd2cjYCBCACIAFBEnRBgIDwA3EgBkEOdnI2AgggAiAAKAAMIgVBBHRB8P//A3EgAUEcdnI2AhAgAiAAKAAQIgFBDXRBgMD/A3EgBUETdnI2AhQgAiADQRZ0QYCAgAJxIAFBCnZyNgIYIAIgACgAGCIBQQh0QYD+/wNxIANBGHZyNgIgIAIgBEERdEGAgPgDcSABQQ92cjYCJCACIAAoACgiAUECdkH///8DcTYCOCACIAAoADAiA0EHdkH///8DcTYCRCACIAAoADwiBUEDdkH///8DcTYCVCACIAAoACAiBkEDdEH4//8DcSAEQR12cjYCLCACIAAoACQiBEEMdEGA4P8DcSAGQRR2cjYCMCACIAFBFXRBgICAA3EgBEELdnI2AjQgAiAAKAAsIgRBB3RBgP//A3EgAUEZdnI2AjwgAiADQRB0QYCA/ANxIARBEHZyNgJAIAIgACgANCIBQQJ0Qfz//wNxIANBHnZyNgJIIAIgACgAOCIDQQt0QYDw/wNxIAFBFXZyNgJMIAIgBUEUdEGAgMADcSADQQx2cjYCUCACIAAoAEAiA0EGdEHA//8DcSAFQRp2cjYCWCACIAAoAEQiAUEIdkH///8DcTYCYCACIAFBD3RBgID+A3EgA0ERdnI2AlwgAiAAKABIIgNBAXRB/v//A3EgAUEfdnI2AmQgAiAAKABMIgRBCnRBgPj/A3EgA0EWdnI2AmggAiAAKABQIgFBBHZB////A3E2AnAgAiABQRN0QYCA4ANxIARBDXZyNgJsIAIgACgAVCIDQQV0QeD//wNxIAFBG3ZyNgJ0IAIgACgAWCIAQQl2NgJ8IAIgAEEOdEGAgP8DcSADQRJ2cjYCeAwKCyABQd8ATQRADAsLIAIgACgAACIBQf///wdxNgIAIAIgACgACCIDQQh2NgIMIAIgACgADCIEQf///wdxNgIQIAIgACgAFCIFQQh2NgIcIAIgACgAGCIGQf///wdxNgIgIAIgACgABCIHQQh0QYD+/wdxIAFBGHZyNgIEIAIgA0EQdEGAgPwHcSAHQRB2cjYCCCACIAAoABAiAUEIdEGA/v8HcSAEQRh2cjYCFCACIAVBEHRBgID8B3EgAUEQdnI2AhggAiAAKAAcIgFBCHRBgP7/B3EgBkEYdnI2AiQgAiAAKAAgIgNBCHY2AiwgAiADQRB0QYCA/AdxIAFBEHZyNgIoIAIgACgAJCIBQf///wdxNgIwIAIgACgALCIDQQh2NgI8IAIgACgAMCIEQf///wdxNgJAIAIgACgAOCIFQQh2NgJMIAIgACgAPCIGQf///wdxNgJQIAIgACgAKCIHQQh0QYD+/wdxIAFBGHZyNgI0IAIgA0EQdEGAgPwHcSAHQRB2cjYCOCACIAAoADQiAUEIdEGA/v8HcSAEQRh2cjYCRCACIAVBEHRBgID8B3EgAUEQdnI2AkggAiAAKABAIgFBCHRBgP7/B3EgBkEYdnI2AlQgAiAAKABEIgNBCHY2AlwgAiADQRB0QYCA/AdxIAFBEHZyNgJYIAIgACgASCIBQf///wdxNgJgIAIgACgATCIDQQh0QYD+/wdxIAFBGHZyNgJkIAIgACgAUCIBQQh2NgJsIAIgAUEQdEGAgPwHcSADQRB2cjYCaCACIAAoAFQiAUH///8HcTYCcCACIAAoAFgiA0EIdEGA/v8HcSABQRh2cjYCdCACIAAoAFwiAEEIdjYCfCACIABBEHRBgID8B3EgA0EQdnI2AngMCQsgAUHjAE0EQAwKCyACIAAoAAAiBEH///8PcTYCACACIAAoAAwiAUEEdkH///8PcTYCECACIAAoABwiA0EBdkH///8PcTYCJCACIAAoAAQiBUEHdEGA//8PcSAEQRl2cjYCBCACIAAoAAgiBEEOdEGAgP8PcSAFQRJ2cjYCCCACIAFBFXRBgICAD3EgBEELdnI2AgwgAiAAKAAQIgRBA3RB+P//D3EgAUEddnI2AhQgAiAAKAAUIgFBCnRBgPj/D3EgBEEWdnI2AhggAiAAKAAYIgRBEXRBgID4D3EgAUEPdnI2AhwgAiADQRh0QYCAgAhxIARBCHZyNgIgIAIgACgAICIEQQZ0QcD//w9xIANBGnZyNgIoIAIgACgAKCIBQQV2Qf///w9xNgI0IAIgACgAOCIDQQJ2Qf///w9xNgJIIAIgACgAJCIFQQ10QYDA/w9xIARBE3ZyNgIsIAIgAUEUdEGAgMAPcSAFQQx2cjYCMCACIAAoACwiBEECdEH8//8PcSABQR52cjYCOCACIAAoADAiAUEJdEGA/P8PcSAEQRd2cjYCPCACIAAoADQiBEEQdEGAgPwPcSABQRB2cjYCQCACIANBF3RBgICADHEgBEEJdnI2AkQgAiAAKAA8IgFBBXRB4P//D3EgA0EbdnI2AkwgAiAAKABAIgNBDHRBgOD/D3EgAUEUdnI2AlAgAiAAKABEIgFBBnZB////D3E2AlggAiABQRN0QYCA4A9xIANBDXZyNgJUIAIgACgASCIDQQF0Qf7//w9xIAFBH3ZyNgJcIAIgACgATCIBQQh0QYD+/w9xIANBGHZyNgJgIAIgACgAUCIDQQ90QYCA/g9xIAFBEXZyNgJkIAIgACgAVCIBQQN2Qf///w9xNgJsIAIgAUEWdEGAgIAOcSADQQp2cjYCaCACIAAoAFgiA0EEdEHw//8PcSABQRx2cjYCcCACIAAoAFwiAUELdEGA8P8PcSADQRV2cjYCdCACIAAoAGAiAEEHdjYCfCACIABBEnRBgIDwD3EgAUEOdnI2AngMCAsgAUHnAE0EQAwJCyACIAAoAAAiBEH///8fcTYCACACIAAoABAiAUECdkH///8fcTYCFCACIAAoACAiA0EEdkH///8fcTYCKCACIAAoAAQiBUEGdEHA//8fcSAEQRp2cjYCBCACIAAoAAgiBEEMdEGA4P8fcSAFQRR2cjYCCCACIAAoAAwiBUESdEGAgPAfcSAEQQ52cjYCDCACIAFBGHRBgICAGHEgBUEIdnI2AhAgAiAAKAAUIgRBBHRB8P//H3EgAUEcdnI2AhggAiAAKAAYIgFBCnRBgPj/H3EgBEEWdnI2AhwgAiAAKAAcIgRBEHRBgID8H3EgAUEQdnI2AiAgAiADQRZ0QYCAgB5xIARBCnZyNgIkIAIgACgAMCIEQQZ2NgI8IAIgACgANCIFQf///x9xNgJAIAIgACgARCIBQQJ2Qf///x9xNgJUIAIgACgAJCIGQQJ0Qfz//x9xIANBHnZyNgIsIAIgACgAKCIDQQh0QYD+/x9xIAZBGHZyNgIwIAIgACgALCIGQQ50QYCA/x9xIANBEnZyNgI0IAIgBEEUdEGAgMAfcSAGQQx2cjYCOCACIAAoADgiA0EGdEHA//8fcSAFQRp2cjYCRCACIAAoADwiBEEMdEGA4P8fcSADQRR2cjYCSCACIAAoAEAiA0ESdEGAgPAfcSAEQQ52cjYCTCACIAFBGHRBgICAGHEgA0EIdnI2AlAgAiAAKABIIgNBBHRB8P//H3EgAUEcdnI2AlggAiAAKABMIgFBCnRBgPj/H3EgA0EWdnI2AlwgAiAAKABQIgNBEHRBgID8H3EgAUEQdnI2AmAgAiAAKABUIgFBBHZB////H3E2AmggAiABQRZ0QYCAgB5xIANBCnZyNgJkIAIgACgAWCIDQQJ0Qfz//x9xIAFBHnZyNgJsIAIgACgAXCIBQQh0QYD+/x9xIANBGHZyNgJwIAIgACgAYCIDQQ50QYCA/x9xIAFBEnZyNgJ0IAIgACgAZCIAQQZ2NgJ8IAIgAEEUdEGAgMAfcSADQQx2cjYCeAwHCyABQesATQRADAgLIAIgACgAACIDQf///z9xNgIAIAIgACgAFCIBQQJ2Qf///z9xNgIYIAIgACgABCIEQQV0QeD//z9xIANBG3ZyNgIEIAIgACgACCIDQQp0QYD4/z9xIARBFnZyNgIIIAIgACgADCIEQQ90QYCA/j9xIANBEXZyNgIMIAIgACgAECIDQRR0QYCAwD9xIARBDHZyNgIQIAIgAUEZdEGAgIAwcSADQQd2cjYCFCACIAAoABgiA0EDdEH4//8/cSABQR12cjYCHCACIAAoABwiAUEIdEGA/v8/cSADQRh2cjYCICACIAAoACAiBEENdEGAwP8/cSABQRN2cjYCJCACIAAoACgiAUEEdkH///8/cTYCMCACIAAoAEAiA0EBdkH///8/cTYCTCACIAAoACQiBUESdEGAgPA/cSAEQQ52cjYCKCACIAFBF3RBgICAPHEgBUEJdnI2AiwgAiAAKAAsIgRBAXRB/v//P3EgAUEfdnI2AjQgAiAAKAAwIgFBBnRBwP//P3EgBEEadnI2AjggAiAAKAA0IgRBC3RBgPD/P3EgAUEVdnI2AjwgAiAAKAA4IgFBEHRBgID8P3EgBEEQdnI2AkAgAiAAKAA8IgRBFXRBgICAP3EgAUELdnI2AkQgAiADQRp0QYCAgCBxIARBBnZyNgJIIAIgACgARCIBQQR0QfD//z9xIANBHHZyNgJQIAIgACgASCIDQQl0QYD8/z9xIAFBF3ZyNgJUIAIgACgATCIBQQ50QYCA/z9xIANBEnZyNgJYIAIgACgAUCIDQRN0QYCA4D9xIAFBDXZyNgJcIAIgACgAVCIBQQN2Qf///z9xNgJkIAIgAUEYdEGAgIA4cSADQQh2cjYCYCACIAAoAFgiA0ECdEH8//8/cSABQR52cjYCaCACIAAoAFwiAUEHdEGA//8/cSADQRl2cjYCbCACIAAoAGAiA0EMdEGA4P8/cSABQRR2cjYCcCACIAAoAGQiAUERdEGAgPg/cSADQQ92cjYCdCACIAAoAGgiAEEFdjYCfCACIABBFnRBgICAPnEgAUEKdnI2AngMBgsgAUHvAE0EQAwHCyACIAAoAAAiAUH/////AHE2AgAgAiAAKAAYIgNBBHY2AhwgAiAAKAAcIgRB/////wBxNgIgIAIgACgABCIFQQR0QfD///8AcSABQRx2cjYCBCACIAAoAAgiAUEIdEGA/v//AHEgBUEYdnI2AgggAiAAKAAMIgVBDHRBgOD//wBxIAFBFHZyNgIMIAIgACgAECIBQRB0QYCA/P8AcSAFQRB2cjYCECACIAAoABQiBUEUdEGAgMD/AHEgAUEMdnI2AhQgAiADQRh0QYCAgPgAcSAFQQh2cjYCGCACIAAoACAiAUEEdEHw////AHEgBEEcdnI2AiQgAiAAKAA0IgNBBHY2AjwgAiAAKAA4IgRB/////wBxNgJAIAIgACgAJCIFQQh0QYD+//8AcSABQRh2cjYCKCACIAAoACgiAUEMdEGA4P//AHEgBUEUdnI2AiwgAiAAKAAsIgVBEHRBgID8/wBxIAFBEHZyNgIwIAIgACgAMCIBQRR0QYCAwP8AcSAFQQx2cjYCNCACIANBGHRBgICA+ABxIAFBCHZyNgI4IAIgACgAPCIBQQR0QfD///8AcSAEQRx2cjYCRCACIAAoAEAiA0EIdEGA/v//AHEgAUEYdnI2AkggAiAAKABEIgFBDHRBgOD//wBxIANBFHZyNgJMIAIgACgASCIDQRB0QYCA/P8AcSABQRB2cjYCUCACIAAoAEwiAUEUdEGAgMD/AHEgA0EMdnI2AlQgAiAAKABQIgNBBHY2AlwgAiADQRh0QYCAgPgAcSABQQh2cjYCWCACIAAoAFQiAUH/////AHE2AmAgAiAAKABYIgNBBHRB8P///wBxIAFBHHZyNgJkIAIgACgAXCIBQQh0QYD+//8AcSADQRh2cjYCaCACIAAoAGAiA0EMdEGA4P//AHEgAUEUdnI2AmwgAiAAKABkIgFBEHRBgID8/wBxIANBEHZyNgJwIAIgACgAaCIDQRR0QYCAwP8AcSABQQx2cjYCdCACIAAoAGwiAEEEdjYCfCACIABBGHRBgICA+ABxIANBCHZyNgJ4DAULIAFB8wBNBEAMBgsgAiAAKAAAIgFB/////wFxNgIAIAIgACgABCIDQQN0Qfj///8BcSABQR12cjYCBCACIAAoAAgiAUEGdEHA////AXEgA0EadnI2AgggAiAAKAAMIgNBCXRBgPz//wFxIAFBF3ZyNgIMIAIgACgAECIBQQx0QYDg//8BcSADQRR2cjYCECACIAAoABQiA0EPdEGAgP7/AXEgAUERdnI2AhQgAiAAKAAYIgFBEnRBgIDw/wFxIANBDnZyNgIYIAIgACgAHCIDQRV0QYCAgP8BcSABQQt2cjYCHCACIAAoACAiBEEYdEGAgID4AXEgA0EIdnI2AiAgAiAAKAAkIgFBAnZB/////wFxNgIoIAIgAUEbdEGAgIDAAXEgBEEFdnI2AiQgAiAAKAAoIgNBAXRB/v///wFxIAFBH3ZyNgIsIAIgACgALCIBQQR0QfD///8BcSADQRx2cjYCMCACIAAoADAiA0EHdEGA////AXEgAUEZdnI2AjQgAiAAKAA0IgFBCnRBgPj//wFxIANBFnZyNgI4IAIgACgAOCIDQQ10QYDA//8BcSABQRN2cjYCPCACIAAoADwiAUEQdEGAgPz/AXEgA0EQdnI2AkAgAiAAKABAIgNBE3RBgIDg/wFxIAFBDXZyNgJEIAIgACgARCIBQRZ0QYCAgP4BcSADQQp2cjYCSCACIAAoAEgiA0EZdEGAgIDwAXEgAUEHdnI2AkwgAiAAKABMIgFBAXZB/////wFxNgJUIAIgAUEcdEGAgICAAXEgA0EEdnI2AlAgAiAAKABQIgNBAnRB/P///wFxIAFBHnZyNgJYIAIgACgAVCIBQQV0QeD///8BcSADQRt2cjYCXCACIAAoAFgiA0EIdEGA/v//AXEgAUEYdnI2AmAgAiAAKABcIgFBC3RBgPD//wFxIANBFXZyNgJkIAIgACgAYCIDQQ50QYCA//8BcSABQRJ2cjYCaCACIAAoAGQiAUERdEGAgPj/AXEgA0EPdnI2AmwgAiAAKABoIgNBFHRBgIDA/wFxIAFBDHZyNgJwIAIgACgAbCIBQRd0QYCAgPwBcSADQQl2cjYCdCACIAAoAHAiAEEDdjYCfCACIABBGnRBgICA4AFxIAFBBnZyNgJ4DAQLIAFB9wBNBEAMBQsgAiAAKAAAIgFB/////wNxNgIAIAIgACgABCIDQQJ0Qfz///8DcSABQR52cjYCBCACIAAoAAgiAUEEdEHw////A3EgA0EcdnI2AgggAiAAKAAMIgNBBnRBwP///wNxIAFBGnZyNgIMIAIgACgAECIBQQh0QYD+//8DcSADQRh2cjYCECACIAAoABQiA0EKdEGA+P//A3EgAUEWdnI2AhQgAiAAKAAYIgFBDHRBgOD//wNxIANBFHZyNgIYIAIgACgAHCIDQQ50QYCA//8DcSABQRJ2cjYCHCACIAAoACAiAUEQdEGAgPz/A3EgA0EQdnI2AiAgAiAAKAAkIgNBEnRBgIDw/wNxIAFBDnZyNgIkIAIgACgAOCIBQQJ2NgI8IAIgACgAPCIEQf////8DcTYCQCACIAAoACgiBUEUdEGAgMD/A3EgA0EMdnI2AiggAiAAKAAsIgNBFnRBgICA/gNxIAVBCnZyNgIsIAIgACgAMCIFQRh0QYCAgPgDcSADQQh2cjYCMCACIAAoADQiA0EadEGAgIDgA3EgBUEGdnI2AjQgAiABQRx0QYCAgIADcSADQQR2cjYCOCACIAAoAEAiAUECdEH8////A3EgBEEednI2AkQgAiAAKABEIgNBBHRB8P///wNxIAFBHHZyNgJIIAIgACgASCIBQQZ0QcD///8DcSADQRp2cjYCTCACIAAoAEwiA0EIdEGA/v//A3EgAUEYdnI2AlAgAiAAKABQIgFBCnRBgPj//wNxIANBFnZyNgJUIAIgACgAVCIDQQx0QYDg//8DcSABQRR2cjYCWCACIAAoAFgiAUEOdEGAgP//A3EgA0ESdnI2AlwgAiAAKABcIgNBEHRBgID8/wNxIAFBEHZyNgJgIAIgACgAYCIBQRJ0QYCA8P8DcSADQQ52cjYCZCACIAAoAGQiA0EUdEGAgMD/A3EgAUEMdnI2AmggAiAAKABoIgFBFnRBgICA/gNxIANBCnZyNgJsIAIgACgAbCIDQRh0QYCAgPgDcSABQQh2cjYCcCACIAAoAHAiAUEadEGAgIDgA3EgA0EGdnI2AnQgAiAAKAB0IgBBAnY2AnwgAiAAQRx0QYCAgIADcSABQQR2cjYCeAwDCyABQfsATQRADAQLIAIgACgAACIBQf////8HcTYCACACIAAoAAQiA0EBdEH+////B3EgAUEfdnI2AgQgAiAAKAAIIgFBAnRB/P///wdxIANBHnZyNgIIIAIgACgADCIDQQN0Qfj///8HcSABQR12cjYCDCACIAAoABAiAUEEdEHw////B3EgA0EcdnI2AhAgAiAAKAAUIgNBBXRB4P///wdxIAFBG3ZyNgIUIAIgACgAGCIBQQZ0QcD///8HcSADQRp2cjYCGCACIAAoABwiA0EHdEGA////B3EgAUEZdnI2AhwgAiAAKAAgIgFBCHRBgP7//wdxIANBGHZyNgIgIAIgACgAJCIDQQl0QYD8//8HcSABQRd2cjYCJCACIAAoACgiAUEKdEGA+P//B3EgA0EWdnI2AiggAiAAKAAsIgNBC3RBgPD//wdxIAFBFXZyNgIsIAIgACgAMCIBQQx0QYDg//8HcSADQRR2cjYCMCACIAAoADQiA0ENdEGAwP//B3EgAUETdnI2AjQgAiAAKAA4IgFBDnRBgID//wdxIANBEnZyNgI4IAIgACgAPCIDQQ90QYCA/v8HcSABQRF2cjYCPCACIAAoAEAiAUEQdEGAgPz/B3EgA0EQdnI2AkAgAiAAKABEIgNBEXRBgID4/wdxIAFBD3ZyNgJEIAIgACgASCIBQRJ0QYCA8P8HcSADQQ52cjYCSCACIAAoAEwiA0ETdEGAgOD/B3EgAUENdnI2AkwgAiAAKABQIgFBFHRBgIDA/wdxIANBDHZyNgJQIAIgACgAVCIDQRV0QYCAgP8HcSABQQt2cjYCVCACIAAoAFgiAUEWdEGAgID+B3EgA0EKdnI2AlggAiAAKABcIgNBF3RBgICA/AdxIAFBCXZyNgJcIAIgACgAYCIBQRh0QYCAgPgHcSADQQh2cjYCYCACIAAoAGQiA0EZdEGAgIDwB3EgAUEHdnI2AmQgAiAAKABoIgFBGnRBgICA4AdxIANBBnZyNgJoIAIgACgAbCIDQRt0QYCAgMAHcSABQQV2cjYCbCACIAAoAHAiAUEcdEGAgICAB3EgA0EEdnI2AnAgAiAAKAB0IgNBHXRBgICAgAZxIAFBA3ZyNgJ0IAIgACgAeCIAQQF2NgJ8IAIgAEEedEGAgICABHEgA0ECdnI2AngMAgsgAUH/AE0EQAwDCyACIAAoAAA2AgAgAiAAKQAENwIEIAIgACkADDcCDCACIAApABQ3AhQgAiAAKQAcNwIcIAIgACkAJDcCJCACIAApACw3AiwgAiAAKQA0NwI0IAIgACgAPDYCPCACIAAoAEA2AkAgAiAAKQBENwJEIAIgACkATDcCTCACIAApAFQ3AlQgAiAAKQBcNwJcIAIgACkAZDcCZCACIAApAGw3AmwgAiAAKQB0NwJ0IAIgACgAfDYCfAwBCyAIQQE2AhQgCEH8ic8ANgIQIAhCATcCHCAIQTs2AiwgCCAIQShqNgIYIAggCEEMajYCKCAIQRBqQaSKzwAQ7ywACyAIQTBqJAAPC0GU7s4AQS1BhO7OABCfKQAL7gMBBH8jAEEgayIGJAACQCAEIAFB/wFxIgRJDQACQAJAAkACQAJAAkACQAJAAkAgBEEYTQRAIAAoAgQgBEECdGooAgAgBCABQRB2bGoiB0GhvwdPDQRBoL8HIAdrIQggACgCCCAHaiEAIAFBCHZB/wFxIgFFDQMgAUEKRg0BIAQNAgwJCyAEQRlBjNTRABDDIQALIAdBoL8HRg0DIAAtAAAiAUHhAGtB/wFxQRpPDQggA0UNBCACLQAAIAFzQSBHDQggAEEBakGfvwcgB2sgAkEBaiADQQFrIARBAWsiABCyICAARiEFDAgLQQAhAQNAIAEgCEYNBQJAAkAgACABai0AACIFQeEAa0H/AXFBGk8EQCABIANJBEAgBSABIAJqLQAARg0CDAoLIAEgA0Hc1NEAEMMhAAsgASADTw0BIAEgAmotAAAgBXNBIEcNCAsgBCABQQFqIgFGDQgMAQsLIAEgA0Hs1NEAEMMhAAsgACAIIAIgAyAEELIgIARGIQUMBgsgBkEANgIYIAZBATYCDCAGQbjQ0QA2AgggBkIENwIQIAZBCGpBnNTRABDvLAALQQBBAEGs1NEAEMMhAAtBAEEAQbzU0QAQwyEACyAIIAhBzNTRABDDIQALQQAhBQwBC0EBIQULIAZBIGokACAFC9kDAQd/IABBDGohBQJAIAGnQQFxBEACQCAFKAIABEAgACgCHCIGQQFqIgdBA3YgB0EHcUEAR2oiAyAAKAIYIgRLBEAgAyAEayEIIAAoAhAiCSADSQRAIAUgCUEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSAAKAIYIQQLIAgEQCAAKAIUIARqQQAgCPwLAAsgACADNgIYCyAAIAc2AhwgACgCFCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgMgACgCAEYEQCAAQYSTgAEQsygLIAAoAgQgA0EDdGogAjcDAAwBCyAFEOY6IAUoAgAEQCAAKAIcQQFqIgZBA3YgBkEHcUEAR2oiAyAAKAIYIgRLBEAgAyAEayEHIAAoAhAiCCADSQRAIAUgCEEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACADNgIYCyAAIAY2AhwgACgCCCIDIAAoAgBGBEAgAEH0koABELMoCyAAKAIEIANBA3RqQgA3AwAMAQtBoJWAARCyOwALIAAgA0EBajYCCAuTBAIFfwF+IwBBQGoiAiQAAkACfyABKAJYQYCAgIB4RwRAIAJBGGogAUEQahC8CiACQRBqIgMgAkEkaikCADcDACACIAIpAhw3AwggAigCGCIEQQhHBEAgAigCLCEBIAAgAikDCDcCDCAAIAE2AhwgACAENgIIIABCAjcDACAAQRRqIAMpAwA3AgAMAwsgAkE4aiADKQMANwMAIAIgAikDCDcDMEEHDAELIAJBGGogASgCaCIEIAEoAmwiBSgCHBEAACACQRBqIgMgAkEkaikCADcDACACIAIpAhw3AwggAigCGCIGQQhHBEAgAigCLCEBIAAgAikDCDcCDCAAIAE2AhwgACAGNgIIIABCAjcDACAAQRRqIAMpAwA3AgAMAgsgAkE4aiADKQMANwMAIAIgAikDCDcDMCAEIAUoAhARBAALIQMgASgCqAEhBCABQQA2AqgBIAEpA3AhByABQQA2AnAgACAHNwMgIAEpAoQBIQcgAUEANgKEASAAIAc3AjQgASkDACEHIAFCADcDACAAQShqIAFB+ABqKQMANwMAIABBMGogAUGAAWooAgA2AgAgAEE8aiABQYwBaikCADcCACAAQcQAaiABQZQBaigCADYCACAAIAEpAwg3AwggACAHNwMAIABBGGogAkE4aikDADcDACAAIAIpAzA3AxAgACADOgBMIAAgBDYCSAsgAkFAayQAC80DAgZ/Cn4gASgCYEGAgICAeEYEQCAAQgA3AwAPCyABKAJkIgMgASgCaEEGdGohBCABLQBwIQUgAS0AcSEGQQAhAQNAIAkhCiANIQsgCCEMA0ACQAJAAkACQCABRSABIAdGckUEQCABIQIMAQsDQCADIARGDQIgA0EoaiADQUBrIQMoAgAiAUUNAAsgA0EcaygCACICIAFBwAJsaiEHCyAFRQ0CQgAhCAJAIAIoAkBBAUcNACACKQNIIglCAFMNACACKALIAUEBRw0AIAIoAswBIgFBAEgNACAJIAGtfCEOQgEhCCAJIQ8LIAynQQFxDQEgDiEKIA8hCyAIIQwMAgsgACAKNwMQIAAgCzcDCCAAIAw3AwAPCyAIUA0AIA4gCiAKIA5UGyEKIA8gCyALIA9WGyELQgEhDAsgAkHAAmohASAGRQ0AC0IAIQgCQCACKAIwQQFHDQAgAikDOCIJQgBTDQAgAigCwAFBAUcNACACKALEASICQQBIDQAgCSACrXwhEEIBIQggCSERCyAQIQkgESENIAynQQFxRQ0AIAhQIAohCSALIQ0gDCEIDQAgECAKIAogEFQbIQkgESALIAsgEVYbIQ1CASEIDAALAAv+AwEGfyAAQRxqIQgCQAJAIAAoAixFBEAgAiEDDAELIAAoAiwiA0ERTw0BIAJBECADayIEIAIgBEkbIgQEQCADIAhqIAEgBPwKAAALIAAgACgCLCAEaiIDQQAgA0EQRyIFGzYCLCACIARrIQMgASAEaiEBIAUNACAAIAAoAgAgACgCHEH3lK+veGxqQQ13QbHz3fF5bDYCACAAIAAoAgQgACgCIEH3lK+veGxqQQ13QbHz3fF5bDYCBCAAIAAoAgggACgCJEH3lK+veGxqQQ13QbHz3fF5bDYCCCAAIAAoAgwgACgCKEH3lK+veGxqQQ13QbHz3fF5bDYCDAsgA0EQTwRAIAAoAgwhBCAAKAIIIQUgACgCBCEGIAAoAgAhBwNAIAEoAABB95Svr3hsIAdqQQ13QbHz3fF5bCEHIAFBDGooAABB95Svr3hsIARqQQ13QbHz3fF5bCEEIAFBCGooAABB95Svr3hsIAVqQQ13QbHz3fF5bCEFIAFBBGooAABB95Svr3hsIAZqQQ13QbHz3fF5bCEGIAFBEGohASADQRBrIgNBD0sNAAsgACAENgIMIAAgBTYCCCAAIAY2AgQgACAHNgIACyADBEAgAwRAIAggASAD/AoAAAsgACADNgIsCyAAIAApAxAgAq18NwMQDwsgA0EQQZTJ0AAQrzsAC9gDAQZ/IABBDGohAwJAIAFBAXEEQAJAIAMoAgAEQCAAKAIcIgVBAWoiBkEDdiAGQQdxQQBHaiIBIAAoAhgiBEsEQCABIARrIQcgACgCECIIIAFJBEAgAyAIQQF0IgMgAUHA////A3FBQGsgASABQT9xGyIEIAMgBEsbEOgZIAAoAhghBAsgBwRAIAAoAhQgBGpBACAH/AsACyAAIAE2AhgLIAAgBjYCHCAAKAIUIAVBA3ZqIgEgAS0AAEEBIAVBB3F0cjoAAAwBCyAAIAAoAiBBAWo2AiALIAAoAggiASAAKAIARgRAIABBhJOAARCtKAsgACgCBCABQQF0aiACOwEADAELIAMQ5jogAygCAARAIAAoAhxBAWoiBEEDdiAEQQdxQQBHaiIBIAAoAhgiAksEQCABIAJrIQUgACgCECIGIAFJBEAgAyAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAhghAgsgBQRAIAAoAhQgAmpBACAF/AsACyAAIAE2AhgLIAAgBDYCHCAAKAIIIgEgACgCAEYEQCAAQfSSgAEQrSgLIAAoAgQgAUEBdGpBADsBAAwBC0GglYABELI7AAsgACABQQFqNgIIC9gDAQZ/IABBDGohAwJAIAFBAXEEQAJAIAMoAgAEQCAAKAIcIgVBAWoiBkEDdiAGQQdxQQBHaiIBIAAoAhgiBEsEQCABIARrIQcgACgCECIIIAFJBEAgAyAIQQF0IgMgAUHA////A3FBQGsgASABQT9xGyIEIAMgBEsbEOgZIAAoAhghBAsgBwRAIAAoAhQgBGpBACAH/AsACyAAIAE2AhgLIAAgBjYCHCAAKAIUIAVBA3ZqIgEgAS0AAEEBIAVBB3F0cjoAAAwBCyAAIAAoAiBBAWo2AiALIAAoAggiASAAKAIARgRAIABBhJOAARCdKAsgACgCBCABQQJ0aiACNgIADAELIAMQ5jogAygCAARAIAAoAhxBAWoiBEEDdiAEQQdxQQBHaiIBIAAoAhgiAksEQCABIAJrIQUgACgCECIGIAFJBEAgAyAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAhghAgsgBQRAIAAoAhQgAmpBACAF/AsACyAAIAE2AhgLIAAgBDYCHCAAKAIIIgEgACgCAEYEQCAAQfSSgAEQnSgLIAAoAgQgAUECdGpBADYCAAwBC0GglYABELI7AAsgACABQQFqNgIIC9wDAgt/AX4CfyADIAEoAhgiCiAFayIISwRAIAEoAgwiCSAFIAUgCUkbIQ8gASgCICEMIAEoAhAhECABKQMAIRIDQAJAAkAgEiACIAhqIhExAACIQgGDUARAIAEgCDYCGCAFIQcgCCEKIAYNAgwBCyAJIAwgCSAJIAxLGyAGG0EBayINIQcCQAJAAkACQANAIAdBf0YEQCAFIAwgBhsiByAJIAcgCUsbIQ0gCSEHA0AgByANRgRAIAEgCDYCGCAGRQRAIAEgBTYCIAsgACAKNgIIIAAgCDYCBEEBDAwLIAcgD0YNAyAHIAhqIANPDQQgByARaiELIAQgB2ogB0EBaiEHLQAAIAstAABGDQALIAogEGshCiAQIQcgBkUNBgwHCyAFIA1NDQQgByAIaiILIANPDQMgByARaiELIAQgB2ogB0EBayEHLQAAIAstAABGDQALIAogCWsgB2pBAWohCiAFIQcgBkUNBAwFCyAPIAVBmK+IARDDIQALIAMgCCAJaiIAIAAgA0kbIANBqK+IARDDIQALIAsgA0HIr4gBEMMhAAsgByAFQbiviAEQwyEACyABIAc2AiAgByEMCyAKIAVrIgggA0kNAAsLIAFBADYCGEEACyEHIAAgBzYCAAvhFwEVfyMAIgEhGSABQYABa0FAcSIHJAAgBCAEKAIIIhAgA0HuAGxB5ABuakEUahCOLQJAAkAgECAEKAIIIgVNBEAgBCgCBCEBIAdBADYCPCAHIAUgEGs2AjggByABIBBqNgI0AkAgA0H//wNPBEAgB0FAayIFQYAgQdTG0AAQvxUgB0EoaiAFQeTG0AAQmCEgBygCLCINQYAgRiIBQQEgBygCKCIIG0UNAyAHIAggDSABGzYCQCAHQSBqIREgAiEKQQAhASADIg1B7gBsQeQAbkEUaiAHQTRqIgYoAgQgBigCCCIVa0sEf0EBBQJAIA1BDUkNACAFKAIAIAooAABBsfPd8XlsQRJ2Qfz/AHFqQQA2AgBBASICIA1BDGsiEksNACAKQQRqIRYgCkEBayETIApBAmshFyAFKAIAIRQDQCABIQMgAkEBaiEBQSEhBQNAIAIhCSAFIQggASECIBQgCSAKaigAACILQbHz3fF5bEESdkH8/wBxaiIBKAIAIQUgASAJNgIAAkAgCSAFayIYQYCABE8NACALIAUgCmooAABHDQACfyAFRSADIAlPckUEQCAJIBNqIQ8gBSEBIAUgE2ohC0EAIQIDQCABIAJqIQUgAiAJaiIIIAIgD2otAAAgAiALai0AAEcNAhogAkEBayECIAVBAUcgCEEBayADS3ENAAsgASACaiEFIAIgCWoMAQsgCQsiDiADayEMIAogBUEEaiIBaiEFAkACfyAOQQRqIgsgDSABayICIA0gDmtBCmsiAUEAIAEgDU0bIgEgASACSxtqIg8gDkEIakkEQCALDAELIA4gFmohCUEAIQICQANAIAIgCWooAAAiCCACIAVqKAAAIgFGBEAgDyAOIAJBBGoiAmoiAUEIak8NAQwCCwsgDiABIAhzaEEDdmogAmpBBGohAQwCCyACIAVqIQUgAUEEagshAQJAIA8gAWtBAU0NACABIApqLwAAIAUvAABHDQAgBUECaiEFIAFBAmohAQsgASAPTw0AIAEgASAKai0AACAFLQAARmohAQsgFCABIBdqKAAAQbHz3fF5bEESdkH8/wBxaiABQQJrNgIAIAYoAgAgBigCCGpBcCAMQQR0IAxBD08bQQ8gASALayILIAtBD08bcjoAACAGIAYoAghBAWo2AggCQAJAIAxBDk0EQCADIApqIQUgDEEJTw0BIAYoAgAgBigCCGogBSkAADcAAAwCCyAMQQ9rIgVB/AdPBEAgBigCACEIIAVB/AduIgJBAnQiCQRAIAggBigCCGpB/wEgCfwLAAsgBiAGKAIIIAlqNgIIIAUgAkH8B2xrIQULIAYoAgAgBigCCGpBfzYAACAGIAVB//8DcUH/AW4iAiAGKAIIakEBajYCCCAGKAIAIAYoAghqQQFrIAIgBWo6AAAgAyAKaiEFIAxBEUkNACAGKAIAIAYoAghqIQIgDEEZTwRAIAxFDQIgAiAFIAz8CgAADAILIAIgBSkAADcAACACQRBqIAVBEGopAAA3AAAgAkEIaiAFQQhqKQAANwAADAELIAYoAgAgBigCCGoiAiAFKQAANwAAIAJBCGogBUEIaikAADcAAAsgBiAGKAIIIAxqNgIIIAYoAgAgBigCCGogGDsAACAGIAYoAghBAmo2AgggC0EOSwRAIAtBD2siAkH8B08EQCAGKAIAIQUgAkH8B24iA0ECdCIIBEAgBSAGKAIIakH/ASAI/AsACyAGIAYoAgggCGo2AgggAiADQfwHbGshAgsgBigCACAGKAIIakF/NgAAIAYgAkH//wNxQf8BbiIDIAYoAghqQQFqNgIIIAYoAgAgBigCCGpBAWsgAiADajoAAAsgASICIBJNDQIMAwsgCEEBaiEFIAhBBXYgAmohASACIBJNDQALCyADIQELIAYgCiANIAEQ4AogBigCCCAVayEBQQALIQIgESABNgIEIBEgAjYCACAHKAIkIQIgBygCICEDIAcoAkBBgIABQQQQ+DoMAQsgB0FAayIFQYAgQYTH0AAQmRUgB0EYaiAFQZTH0AAQqiEgBygCHCINQYAgRiIBQQEgBygCGCIIG0UNAyAHIAggDSABGzYCQCAHQRBqIREgAiEKQQAhASADIg1B7gBsQeQAbkEUaiAHQTRqIgYoAgQgBigCCCIVa0sEf0EBBQJAIA1BDUkNACAFKAIAIAooAABBsfPd8XlsQRN2Qf4/cWpBADsBAEEBIgIgDUEMayISSw0AIApBBGohFiAKQQFrIRMgCkECayEXIAUoAgAhFANAIAEhAyACQQFqIQFBISEFA0AgAiEJIAUhCCABIQIgFCAJIApqKAAAIgtBsfPd8XlsQRN2Qf4/cWoiAS8BACEFIAEgCTsBAAJAIAkgBWsiGEGAgARPDQAgCyAFIApqKAAARw0AAn8gBUUgAyAJT3JFBEAgCSATaiEPIAUhASAFIBNqIQtBACECA0AgASACaiEFIAIgCWoiCCACIA9qLQAAIAIgC2otAABHDQIaIAJBAWshAiAFQQFHIAhBAWsgA0txDQALIAEgAmohBSACIAlqDAELIAkLIg4gA2shDCAKIAVBBGoiAWohBQJAAn8gDkEEaiILIA0gAWsiAiANIA5rQQprIgFBACABIA1NGyIBIAEgAksbaiIPIA5BCGpJBEAgCwwBCyAOIBZqIQlBACECAkADQCACIAlqKAAAIgggAiAFaigAACIBRgRAIA8gDiACQQRqIgJqIgFBCGpPDQEMAgsLIA4gASAIc2hBA3ZqIAJqQQRqIQEMAgsgAiAFaiEFIAFBBGoLIQECQCAPIAFrQQFNDQAgASAKai8AACAFLwAARw0AIAVBAmohBSABQQJqIQELIAEgD08NACABIAEgCmotAAAgBS0AAEZqIQELIBQgASAXaigAAEGx893xeWxBE3ZB/j9xaiABQf7/A2o7AQAgBigCACAGKAIIakFwIAxBBHQgDEEPTxtBDyABIAtrIgsgC0EPTxtyOgAAIAYgBigCCEEBajYCCAJAAkAgDEEOTQRAIAMgCmohBSAMQQlPDQEgBigCACAGKAIIaiAFKQAANwAADAILIAxBD2siBUH8B08EQCAGKAIAIQggBUH8B24iAkECdCIJBEAgCCAGKAIIakH/ASAJ/AsACyAGIAYoAgggCWo2AgggBSACQfwHbGshBQsgBigCACAGKAIIakF/NgAAIAYgBUH//wNxQf8BbiICIAYoAghqQQFqNgIIIAYoAgAgBigCCGpBAWsgAiAFajoAACADIApqIQUgDEERSQ0AIAYoAgAgBigCCGohAiAMQRlPBEAgDEUNAiACIAUgDPwKAAAMAgsgAiAFKQAANwAAIAJBEGogBUEQaikAADcAACACQQhqIAVBCGopAAA3AAAMAQsgBigCACAGKAIIaiICIAUpAAA3AAAgAkEIaiAFQQhqKQAANwAACyAGIAYoAgggDGo2AgggBigCACAGKAIIaiAYOwAAIAYgBigCCEECajYCCCALQQ5LBEAgC0EPayICQfwHTwRAIAYoAgAhBSACQfwHbiIDQQJ0IggEQCAFIAYoAghqQf8BIAj8CwALIAYgBigCCCAIajYCCCACIANB/AdsayECCyAGKAIAIAYoAghqQX82AAAgBiACQf//A3FB/wFuIgMgBigCCGpBAWo2AgggBigCACAGKAIIakEBayACIANqOgAACyABIgIgEk0NAgwDCyAIQQFqIQUgCEEFdiACaiEBIAIgEk0NAAsLIAMhAQsgBiAKIA0gARDgCiAGKAIIIBVrIQFBAAshAiARIAE2AgQgESACNgIAIAcoAhQhAiAHKAIQIQMgBygCQEGAwABBAhD4OgsgAAJ/IANBAXEEQCAAQeja0AA2AgggAEEBNgIEQQUMAQsgBCACIBBqEPQ0QQgLNgIAIBkkAA8LIBAgBUHI2tAAEK87AAsgByANNgJEIAcgCDYCQEH0otAAQSsgB0FAa0Ggo9AAQfTG0AAQ1R4ACyAHIA02AkQgByAINgJAQfSi0ABBKyAHQUBrQeSi0ABBpMfQABDVHgAL7wMBAn8CQAJ/AkACQAJAAkACQCAAKAIAIgFBH3UgAUH/////B2txDgQBAgMEAAsgACgCDCICBEAgACgCCCEBA0AgARDiCyABQcgAaiEBIAJBAWsiAg0ACwsgAEEEakEEQcgAEOAeIAAoAhQiAUUNBSABIAEoAgAiAUEBazYCACABQQFHDQUgAEEUagwECyAAQQxqELQwIABBGGoQtDAgABDpOyAAKAIkIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSRqELsjCyAAKAIsIgFFDQQgASABKAIAIgFBAWs2AgAgAUEBRw0EIABBLGoMAwsgACgCBBDiCyAAKAIEQcgAQQQQ+DogACgCCCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEIahD7HgsgACgCGCIBRQ0DIAEgASgCACIBQQFrNgIAIAFBAUcNAyAAQRhqDAILIAAoAgQQ4gsgACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNAiABIAEoAgAiAUEBazYCACABQQFHDQIgAEEYagwBCyAAKAIEEOILIAAoAgRByABBBBD4OiAAKAIQIgFFDQEgASABKAIAIgFBAWs2AgAgAUEBRw0BIABBEGoLEPseCwuWBAIEfwF+IwBB4ABrIgIkACAAKAIIIQNBASEEIAApAwAiBkIAWQR/QQEFQn9CACADGyAGfSEGQYCU69wDIANrQQAgAxshA0EBIQVBgMWGAQshACACIAM2AgggAiAGNwMAIAIgBTYCGCACIAA2AhQgAkECNgJMIAJBhMWGATYCSCACQgE3AlQgAkHHAjYCJCACIAJBIGo2AlAgAiACQRRqNgIgAkAgASgCACIAIAEoAgQiBSACQcgAahDLCg0AIAMgBkIAUnJFBEAgAUGUxYYBQQIQ+zUhBAwBCyACQQE2AkwgAkGYxYYBNgJIIAJCATcCVCACQe4GNgIkIAIgAkEgajYCUCACIAI2AiAgACAFIAJByABqEMsKDQAgAigCCCIDQQBKBEACQCADQQpwRQRAQQkhAANAIABBAWshACADQQpuIgNBCnBFDQALIAIgAzYCHCAAQYCABEkNASACQQA2AlggAkEBNgJMIAJB+MSGATYCSCACQgQ3AlAgAkHIAGpBoMWGARDvLAALIAIgAzYCHEEJIQALIAIgADsBRCACQQA2AkAgAkGcAzYCPCACQQE2AjQgAkG8xYYBNgIwIAJBATYCJCACQbTFhgE2AiAgAkECNgIsIAIgAkEcajYCOCACIAJBOGo2AiggASgCACABKAIEIAJBIGoQywoNAQsgAUHUxYYBQQEQ+zUhBAsgAkHgAGokACAEC+EDAQ1/IwBBEGsiByQAAkAgAS0AJQ0AAkAgASgCECIEIAEoAgwiAkkNACAEIAEoAggiCEsNACABKAIEIQwgAUETaiENIAFBFGohDgNAIAEoAgQgAmohCiANIAEtABgiBmotAAAhBQJAAkACQCAEIAJrIgtBB00EQCACIARGDQFBACEDA0AgAyAKai0AACAFRg0EIAsgA0EBaiIDRw0ACwwBCyAHQQhqIAUgCiALEJ0SIAcoAghBAXENASABKAIQIQQLIAEgBDYCDAwDCyAHKAIMIQMgAS0AGCEGIAEoAgghCCABKAIMIQILIAEgAiADakEBaiICNgIMAkAgAiAGSSACIAhLcg0AIAZBBUkEQCACIAZrIgQgASgCBGogBiAOIAYQwS4hAyABKAIMIQIgA0UEQCABKAIIIQgMAgsgASgCHCEFIAEgAjYCHCAFIAxqIQkgBCAFayEDDAQLIAZBBEG4nMQAELA7AAsgASgCECIEIAJJDQEgBCAITQ0ACwsgAS0AJQ0AIAFBAToAJQJAIAEtACRBAUYEQCABKAIgIQIgASgCHCEFDAELIAEoAiAiAiABKAIcIgVGDQELIAIgBWshAyABKAIEIAVqIQkLIAAgAzYCBCAAIAk2AgAgB0EQaiQAC+EDAQ1/IwBBEGsiByQAAkAgAS0AJQ0AAkAgASgCECIEIAEoAgwiAkkNACAEIAEoAggiCEsNACABKAIEIQwgAUETaiENIAFBFGohDgNAIAEoAgQgAmohCiANIAEtABgiBmotAAAhBQJAAkACQCAEIAJrIgtBB00EQCACIARGDQFBACEDA0AgAyAKai0AACAFRg0EIAsgA0EBaiIDRw0ACwwBCyAHQQhqIAUgCiALEJ0SIAcoAghBAXENASABKAIQIQQLIAEgBDYCDAwDCyAHKAIMIQMgAS0AGCEGIAEoAgghCCABKAIMIQILIAEgAiADakEBaiICNgIMAkAgAiAGSSACIAhLcg0AIAZBBUkEQCACIAZrIgQgASgCBGogBiAOIAYQwS4hAyABKAIMIQIgA0UEQCABKAIIIQgMAgsgASgCHCEFIAEgAjYCHCAFIAxqIQkgBCAFayEDDAQLIAZBBEHstIABELA7AAsgASgCECIEIAJJDQEgBCAITQ0ACwsgAS0AJQ0AIAFBAToAJQJAIAEtACRBAUYEQCABKAIgIQIgASgCHCEFDAELIAEoAiAiAiABKAIcIgVGDQELIAIgBWshAyABKAIEIAVqIQkLIAAgAzYCBCAAIAk2AgAgB0EQaiQAC+oKAQJ/IwBBEGsiAyQAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkADQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMTDgIDEw4DEw4OEw4TDg4EBwUIBgcIBhMJCg4LDBYNEw4QERMSAAsgAEEAOwEMIABBADYCCCAAQoCAgIDAADcCAAwZC0EMQQQQrTYiAUUNGSAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAgAUECNgIADBgLQQxBBBCtNiIBRQ0YIAFBATYCCCABQoCAgIAQNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwXC0EMQQQQrTYiAUUNFyABQQI2AgggAUKAgICAIDcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMFgsgAS0AAUEBaw4CDxAOCyABKAIEIgJBAEgNEUEMQQQQrTYiAUUNFSABQQE2AgggASACNgIEIAFBADYCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMFAtBDEEEEK02IgFFDRQgAUEQNgIIIAFCgICAgIACNwIAIABBgQI7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMEwtBGEEEEK02IgFFDRQgAUKEgICAEDcCCCABQoCAgIDAADcCACAAQQE7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEgtBGEEEEK02IgFFDRMgAUKIgICAEDcCCCABQoCAgICAATcCACAAQQE7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEQtBGEEEEK02IgFFDRIgAUKEgICAwAA3AhAgAUIENwIIIAFCgICAgMAANwIAIABBgQI7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEAsgAEEBOwEMIABBADYCCCAAQoCAgIDAADcCAAwPC0EYQQQQrTYiAUUNECABQoiAgICAATcCECABQgg3AgggAUKAgICAgAE3AgAgAEGBAjsBDCAAQQI2AgggACABNgIEIABBAjYCAAwOCyAAQQE7AQwgAEEANgIIIABCgICAgMAANwIADA0LIAEoAgQhAQwBCwtBDEEEEK02IgFFDQsgAUEINgIIIAFCgICAgIABNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwKC0EMQQQQrTYiAUUNCiABQRA2AgggAUKAgICAgAI3AgAgAEEBOwEMIABBATYCCCAAIAE2AgQgAEEBNgIADAkLQQxBBBCtNiIBRQ0JIAFBEDYCCCABQoCAgICABDcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMCAsgAEEAOwEMIABBADYCCCAAQoCAgIDAADcCAAwHC0EMQQQQrTYiAUUNByABQQQ2AgggAUKAgICAwAA3AgAgAEEBOwEMIABBATYCCCAAIAE2AgQgAEEBNgIADAYLQQxBBBCtNiIBRQ0GIAFBBDYCCCABQoCAgICAATcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMBQtBDEEEEK02IgFFDQUgAUEINgIIIAFCgICAgIACNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwECyABLQABDQFBDBDLLyIBQQE2AgggAUKAgICAEDcCAEEBDAILQejahgFBKyADQQ9qQdjahgFBjISHARDVHgALQRgQyy8iAUKEgICAwAA3AhAgAUIBNwIIIAFCgICAgBA3AgBBAgshAiAAQQA7AQwgACACNgIIIAAgATYCBCAAIAI2AgALIANBEGokAA8LQQRBDBCjPQALQQRBGBCjPQAL1wMCBn4DfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIIAEoAgA2AkwgCEEIaiIAIAhBzABqIgpBBBC7CSAIIAEoAgQ2AkwgACAKQQQQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvgAwIIfgR/IwBBMGsiCyQAQoCAgICAgICAgH8hBQJAAkACfgJAAkAgACgCBCgCECABQQR0aiIKKQMAIgcgCikDCCIIQoCAgICAgICAgH+FhEIAUiAAKAIAIg0oAgAiCigCACIMKQMIIgIgDCkDACIDg0J/UnJFBEBCACECDAELIAIgA4RQDQMgC0EgaiAHIAggAyACEIMZIAtBEGogCykDICIEIAspAygiBSADIAIQqB5CACAHIAspAxAiCX0gAiADg0J/USIMGyEGQgAgCCALKQMYfSAHIAlUrX0gDBshAiAIQgBZDQELIAQgBiAKKAIIIgopAwBYIAIgCikDCCIDVyACIANRG60iA30hAiAFIAMgBFatfQwBCyAFIAQgBiAKKAIEIgopAwBaIAIgCikDCCIDWSACIANRG618IgIgBFStfAshBAJAIAIgBCANKAIELQAAEP8gBEAgACgCCCABQQR0aiIAIAQ3AwggACACNwMADAELIAAoAhAiCiAKKAIAQQFqNgIAIAtBCGogACgCFBCGPSABQQN2IgAgCygCDCIKTw0CIAsoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyALQTBqJAAPC0HMj/8AEOIrAAsgACAKQYiL/wAQwyEAC9gJAQx/IwBB0ABrIgIkAEEBIQMCQCABKAIAIgpBjPqFAUEMIAEoAgQoAgwiCxEGAA0AIApBmPqFAUENIAsRBgANACAKQaX6hQFBAiALEQYADQAjAEEwayIGJAACQAJAIAAoAhgiB0UNAEEKIAcgB0EKTxshDCABKAIEIQ0gASgCACEEAkADQCAAIAgQlCUhCSANKAIMIQUCQCAJRQRAQQEhCSAEQfDDhAFBAiAFEQYADQUgBEGcnYQBQQUgBREGAA0FIARB8sOEAUECIAURBgANBQwBCyAEQfTDhAFBCCAFEQYADQILIAwgCEEBaiIIRw0ACyAHQQtJDQEgB0EVTwRAIAZBAjYCECAGQeDDhAE2AgwgBkIBNwIYIAZBOzYCKCAGIAdBFGs2AiwgBiAGQSRqNgIUIAYgBkEsajYCJCAEIA0gBkEMahDLCg0BCyAHQQprIgggDCAIIAxLGyIIIAdPDQEDQAJAIAAgCBCUJUUEQEEBIQkgBEHww4QBQQIgBREGAA0FIARBnJ2EAUEFIAURBgANBSAEQfLDhAFBAiAFEQYADQUMAQsgBEH0w4QBQQggBREGAA0CCyAIQQFqIgggB0cNAAsMAQtBASEJDAELQQAhCQsgBkEwaiQAIAkNACAKQaf6hQFBBCALEQYADQAgAkEIaiEGIwBBIGsiBCQAAkAgAC0ADEEgRgRAIAQgAEEQahDDNCAEKAIAIgMhByADIAQoAgRBAnRqIQUjAEEgayIDJAAgA0EUaiAFIAdrQQJ2QQBBBEEIEKAYIAMoAhghCCADKAIUQQFGBEAgCCADKAIcQdDqhQEQ/S8ACyADQRBqIgtBADYCACADIAMoAhw2AgwgAyAINgIIIANBCGoiCCAFIAdrQQJ2IgkQ/y0gCCgCCCEKIAggBSAHRwR/IAkgCmogCCgCBCAKQQN0aiEFA0AgBSAHKAIAKQJANwIAIAdBBGohByAFQQhqIQUgCUEBayIJDQALBSAKCzYCCCAGQQhqIAsoAgA2AgAgBiADKQIINwIAIANBIGokACAEQSBqJAAMAQsgBEEANgIYIARBATYCDCAEQZT4hQE2AgggBEIENwIQIARBCGpBnPiFARDvLAALAkACQCACKAIQIgMEQCACKAIMIQYgA0EDdCEHIAAoAgQhAyAAKAIIIQRBACEAA0AgAiAANgIUIAIgBjYCGCAAIARGDQMgAiADKAIAIANBBGoiBSgCACIIKAIIQQFrQXhxakEIaiAIKAIcEQQANgI0IAJBBDYCICACQbz6hQE2AhwgAkIDNwIoIAJBrwM2AkwgAkGDETYCRCACQTs2AjwgAiACQThqNgIkIAIgAkE0ajYCSCACIAJBGGo2AkAgAiACQRRqNgI4IAEoAgAgASgCBCACQRxqEMsKDQIgAygCACAFKAIAIgUoAghBAWtBeHFqQQhqIAEgBSgCDBECAA0CIAEoAgBB3PqFAUEBIAEoAgQoAgwRBgANAiAGQQhqIQYgAEEBaiEAIANBCGohAyAHQQhrIgcNAAsLIAJBCGoQ6jsgAkEANgJIIAJBATYCPCACQcTuhQE2AjggAkIENwJAIAEgAkE4ahDROSEDDAILIAJBCGoQ6jtBASEDDAELIAQgBEGw94UBEMMhAAsgAkHQAGokACADC8wDAgN/An4CQAJAAkAgBEEBaw4CAQACC0KBBCACIAMbIAIgAkJ/URshAgwBC0EAIQMLAkACQCADQYCAgIACSyACQoCAgIACVnJFBEAgASgCACIGQQZBICADIAKnaiIHQQFrZ2sgB0HAAEkbIgcgBiAHSRshBgwBCyABKAIAIQYgAkJ/UQ0BCyABIAEoAggiCAJ/IAYgA0UNABogBkIBIAathiIJIAIgA60iCnxaDQAaQR4gCSAKfCICQv////8DVg0AGkEgIAKnQQFrZ2sLIgdBAWoiAyADIAhLGzYCCCABKAIEIAEoAhhBBUsiA2sgB00NACABIAdBf0EAIAMbazYCBAsgAUEKIAYgBkEKTRs2AgAgBEECRyABKAIYIgRBA2tBfklyRQRAIAFBGCABKAIIIgMgA0EYTxs2AgggAUEYIAEoAgQiAyADQRhPGzYCBAsgBEEGa0F9SSAFQQFLckUEQCABIAEoAggiBEEEQQYgASgCDCIDIANBBk8bIgMgA0EETRtBGHIiAyADIARLGzYCCAsgACABKQIANwIAIABBGGogAUEYaigCADYCACAAQRBqIAFBEGopAgA3AgAgAEEIaiABQQhqKQIANwIAC/UDAQN/IwBBgAJrIgMkACADQRBqIgQgASACKAIUEQAAIANB1ABqIgEgBBDRDSABENI8IQVBACEBIAMoAnQiBEEQTwRAIAMoAnAhAiAEQQR2IQQDQCABIAIoAgBqIQEgAkEQaiECIARBAWsiBA0ACwsgA0GQAWogBSABEKYUIANBxAFqIANB1ABqENgqAkACQAJAIAMoAuABIgIgAygC5AEiAUYEQCADKALIASEEDAELIAMoAsgBIQQDQAJAAkAgBARAIAIgAygC2AFPDQUgAygCzAEgAiADKALUAWoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAMgAkEBajYC4AEgA0EIaiADKALEASACEKwfIANBkAFqIAMoAgggAygCDBD9EgwBCyADIAJBAWo2AuABIANBkAFqEKYVCyABIAJBAWoiAkcNAAsLAkAgBEUNACAEIAQoAgAiAUEBazYCACABQQFHDQAgA0HIAWoQ+x4LIANBxAFqIgIgA0GQAWoiBBDrDkHEAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEGg4f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQuiwgA0HUAGoQ3iIgA0GAAmokAA8LQfzA/wBBIEGcwf8AEJ8pAAtBBEHEABCjPQAL9QMBA38jAEGAAmsiAyQAIANBEGoiBCABIAIoAhQRAAAgA0HUAGoiASAEENENIAEQ0jwhBUEAIQEgAygCdCIEQRBPBEAgAygCcCECIARBBHYhBANAIAEgAigCAGohASACQRBqIQIgBEEBayIEDQALCyADQZABaiAFIAEQpRQgA0HEAWogA0HUAGoQ2CoCQAJAAkAgAygC4AEiAiADKALkASIBRgRAIAMoAsgBIQQMAQsgAygCyAEhBANAAkACQCAEBEAgAiADKALYAU8NBSADKALMASACIAMoAtQBaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgAyACQQFqNgLgASADQQhqIAMoAsQBIAIQrB8gA0GQAWogAygCCCADKAIMEP4SDAELIAMgAkEBajYC4AEgA0GQAWoQpxULIAEgAkEBaiICRw0ACwsCQCAERQ0AIAQgBCgCACIBQQFrNgIAIAFBAUcNACADQcgBahD7HgsgA0HEAWoiAiADQZABaiIEEOwOQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBC7LCADQdQAahDeIiADQYACaiQADwtB/MD/AEEgQZzB/wAQnykAC0EEQcQAEKM9AAvRAwEIfyMAQaABayICJAAgAkEQaiABQcQA/AoAACACQoCAgICQAjcCCEERIQUgAiAAQREQnxggAigCACACKAIEEIAtIABByABqIQgCfyAAKAJIIgFBEU0EQCABIQQgCCEGIABBBGoMAQsgAEEEaiEGIAAoAgQhBCABIQUgACgCCAshAwJAAkAgBCAFTwRAIAQhBQwBCyAEIAVrQQFqIQkgAyAEQQJ0aiEHQQAhA0EIIQECQANAIAEgB2pBCGsgAkEIaiABaigCADYCACADIAlqRQ0BIAFBBGohASADQQFqIgNBEUcNAAsgBiADIARqNgIADAILIAIgA0EBajYCCAsgBiAFNgIAIAJB1ABqIAJBCGpBzAD8CgAAIAIoAlQiASACKAJYRg0AIABBBGohBCACQdwAaiEJA0AgAiABQQFqNgJUIAkgAUECdGoCfyAIKAIAIgVBEkkEQCAFIQEgBCEGQREhBSAIDAELIAAoAgQhASAAKAIIIQYgBAshAygCACEHIAEgBUYEfyAAEPwfIAAoAgghBiAEIQMgACgCBAUgAQtBAnQgBmogBzYCACADIAMoAgBBAWo2AgAgAigCVCIBIAIoAlhHDQALCyACQaABaiQAC6cEAgZ+BX8jAEHQAGsiCCQAIAhBQGsiC0IANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggASgCBCEMIAggASgCCCIBNgJMIAhBCGoiACAIQcwAakEEELsJIwBBEGsiCSQAIAEEQCABQQxsIQogDEEIaiEBA0AgACABQQRrKAIAIAEoAgAQuwkgCUH/AToADyAAIAlBD2pBARC7CSABQQxqIQEgCkEMayIKDQALCyAJQRBqJAAgCCkDCCEDIAgpAxghAiALNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvDAwEMfwJAIAIgA0EBaiIESwRAIAEvAQIhBSABIARBAnRqQf//AzsBAkEEQQMgBRshCkEHQYoBIAUbIQQgAEEEaiELQX8hBgwBCyAEIAJBjPj7ABDDIQALA0AgBiEJIAUhCCAEQf//A3EhBkEAIQQCQAJAAkACQANAIAQhDSAMIAMgB0lyDQEgB0EBaiIFIAJPDQIgAyAHTSEMIAcgAyAHS2ohByABIAVBAnRqLwECIgUgCEH//wNxIg9GIAYgBEEBaiIEQf//A3EiDktxDQALIA8hBiAKQf//A3EgDk0EQAJAIAYiBEUEQCANQf//A3FBCkkNASAAIAAvAUxBAWo7AUwMBgsCQCAGIAlHBEAgBEEnTw0BIAsgBkECdGoiBCAELwEAQQFqOwEACyAAIAAvAURBAWo7AUQMBgsgBkEnQaz4+wAQwyEACyAAIAAvAUhBAWo7AUgMBAsgCEH//wNxQSdJDQIgBkEnQbz4+wAQwyEACw8LIAUgAkGc+PsAEMMhAAsgCyAGQQJ0aiIJIAkvAQAgBGo7AQALQQZBByAIQf//A3EgBUYiCBtBigEgBRshBEEDQQQgCBtBAyAFGyEKDAALAAvPAwEGfyAAQQxqIQMCQCABBEACQCADKAIABEAgACgCHCIFQQFqIgZBA3YgBkEHcUEAR2oiASAAKAIYIgRLBEAgASAEayEHIAAoAhAiCCABSQRAIAMgCEEBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACABNgIYCyAAIAY2AhwgACgCFCAFQQN2aiIBIAEtAABBASAFQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgEgACgCAEYEQCAAQYSTgAEQqRkLIAAoAgQgAWogAjoAAAwBCyADEOY6IAMoAgAEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIYIgJLBEAgASACayEFIAAoAhAiBiABSQRAIAMgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIYIQILIAUEQCAAKAIUIAJqQQAgBfwLAAsgACABNgIYCyAAIAQ2AhwgACgCCCIBIAAoAgBGBEAgAEH0koABEKkZCyAAKAIEIAFqQQA6AAAMAQtBoJWAARCyOwALIAAgAUEBajYCCAvPAwEGfyAAQQxqIQMCQCABBEACQCADKAIABEAgACgCHCIFQQFqIgZBA3YgBkEHcUEAR2oiASAAKAIYIgRLBEAgASAEayEHIAAoAhAiCCABSQRAIAMgCEEBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACABNgIYCyAAIAY2AhwgACgCFCAFQQN2aiIBIAEtAABBASAFQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgEgACgCAEYEQCAAQYSTgAEQoygLIAAoAgQgAWogAjoAAAwBCyADEOY6IAMoAgAEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIYIgJLBEAgASACayEFIAAoAhAiBiABSQRAIAMgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIYIQILIAUEQCAAKAIUIAJqQQAgBfwLAAsgACABNgIYCyAAIAQ2AhwgACgCCCIBIAAoAgBGBEAgAEH0koABEKMoCyAAKAIEIAFqQQA6AAAMAQtBoJWAARCyOwALIAAgAUEBajYCCAuhBAEDfyMAQRBrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0ASEEBaw4DBwIBAAsgACAAKQIANwIoIABBQGsgAEEYaikCADcCACAAQThqIABBEGopAgA3AgAgAEEwaiAAQQhqKQIANwIACyAAQShqIQMgAC0AREEBaw4DBAACAQsACyADKAIAIgIoAggNBCACQX82AgggACACQQhqNgI0IAAgAkEMaiICNgIwIABBADoAQCAAIAI2AjggACAAKAIsIgQ2AjwMAQsgAC0AQEEBcQ0EIAAoAjwhBCAAKAI4IQILIAIoAgAEQCACELwqCyACQQA2AgAgBEGEAU8EQCAEEPIfCyAAQQE6AEAgACgCNCICIAIoAgBBAWo2AgAgACgCKCICIAIoAgBBAWsiAjYCACACRQRAIAMQ1CILIABBAToARCADENocIAFBgAE2AgggAUGAATYCDCABIABBIGoiAiABQQxqIAFBCGoQwiMgASgCAEEBcQ0EAkAgASgCBCIDQYQBSQ0AIAMQ8h8gASgCDCIDQYQBSQ0AIAMQ8h8LIAEoAggiA0GEAU8EQCADEPIfCyACKAIAIgJBhAFPBEAgAhDyHwsgACgCJCICQYQBTwRAIAIQ8h8LIABBAToASCABQRBqJABBAA8LQcjewwAQ6CsAC0Ho3cMAEOgrAAtB1NvDAEExEJc9AAtBmN7DABDoKwALQdTbwwBBMRCXPQAL3AYBCX8jAEEwayIDJAACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCADQRBqIAJBCGooAgAiBDYCACADIAIpAgA3AwggASgCACIFKAIAIgFFDQIgA0EkaiABQQBBBEEMEKAYIAQgAW4hAiADKAIoIQEgAygCJEEBRg0BIANBADYCICADIAMoAiw2AhwgAyABNgIYIAUoAgAiBwRAIAJBA3QhCCADKAIMIQtBACEBA0AgASACbCIFIAJqIgYgBUkNBSAEIAZJDQYgA0EkaiACQQBBCEEIEKAYIAMoAighBiADKAIkQQFGDQcgAygCLCEJIAgEQCAJIAsgBUEDdGogCPwKAAALIAMoAiAiBSADKAIYRgRAIANBGGpB7MrNABCQKAsgAygCHCAFQQxsaiIKIAI2AgggCiAJNgIEIAogBjYCACADIAVBAWo2AiAgAUEBaiEBIAdBAWsiBw0ACwsgACADKQIYNwIAIABBCGogA0EgaigCADYCACADQQhqEOM8DAYLIANBgICAgHg2AiQgASgCACgCACEBIwBBIGsiAiQAIAJBFGogAUEAQQRBDBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEH8ys0AEP0vAAsgAkEQaiIKQQA2AgAgAiACKAIcNgIMIAIgBDYCCCADQSRqIQcjAEEQayIIJAAgAkEIaiIFKAIAIAUoAggiBGsgAUkEQCAFIAQgAUEEQQwQ0CggBSgCCCEECyAFKAIEIARBDGxqIQYCQAJAIAFBAk8EQCABQQFrIQkDQAJAIAcoAgBBgICAgHhHBEAgCEEEaiAHEKUdDAELIAhBgICAgHg2AgQLIAYgCCkCBDcCACAGQQhqIAhBDGooAgA2AgAgBkEMaiEGIAlBAWsiCQ0ACyABIARqQQFrIQQMAQsgAQ0AIAUgBDYCCCAHEIUwDAELIAYgBykCADcCACAGQQhqIAdBCGooAgA2AgAgBSAEQQFqNgIICyAIQRBqJAAgAEEIaiAKKAIANgIAIAAgAikCCDcCACACQSBqJAAMBQsgASADKAIsQczKzQAQ/S8AC0G8ys0AEOIrAAsgBSAGQdzKzQAQsTsACyAGIARB3MrNABCwOwALIAYgAygCLEH8u80AEP0vAAsgA0EwaiQAC8EGAgV/A34jAEHgAWsiByQAAkACQAJAIAJB/wFxIghBAUYgCEEHRnJFBEAgB0HYAWogA0EIaikCADcDACAHIAMpAgA3A9ABIAdBgAFqIAIgB0HQAWogBCAFIAYgAS0AZBD8AiAHQYgBaiECIAcpA4ABIgxCBlINASAHQdAAaiACQRBqKQMAIgw3AwAgB0HIAGogAkEIaikDACINNwMAIAcgAikDACIONwNAIABBEGogDDcDACAAQQhqIA03AwAgACAONwMADAMLIAMoAghFDQEgAygCBC0AACECIAdBADYCuAEgB0IANwOwASAHQQA2ApABIAcgAjoAvAEgB0IANwOAASAHQUBrIgIgA0EBEOoUIwBBQGoiCCQAIAdBgAFqIglBEGohCgJAIAkoAhAiCwRAIAlBHGogCSgCFCAJKAIYIAsoAhARAQAgCUIANwMgIAlBKGpCADcDACAKQQhqIAJBCGopAgA3AgAgCiACKQIANwIADAELIAhBEGpCADcDACAIQRhqQgA3AwAgCiACKQIAIgw3AwAgCkEQakIANwMAIApBGGpCADcDACAIQQhqIAJBCGopAgAiDTcDACAKQQhqIA03AwAgCCAMNwMACwJAAkAgCigCAARAIAhBIGogChClGAJAIAgoAiBBAUcNACAIKQMoIgxQDQAgDEIBg1BFBEAgCSAMp0ECdEF4cTYCOAwBCyAJIAxCAYg+AjQgCEEwaiAKIAktADwiAkEDdiACQQdxQQBHahDBHCAIKQMwIQwgCSAIKQM4NwMIIAkgDDcDACAMp0UNAgsgCEFAayQADAILQdrtzQBBGEH07c0AEMskAAtBhO7NAEEuQbTuzQAQnykACyAHIAlBwAD8CgAAIAEQ2RUgAUIGNwMAIAFBCGogB0HAAPwKAAAgAEEINgIAIAEgBiAEIAVBAXEbNgJIIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgB0FAayACQcAA/AoAACAHKQPIASENIAcgB0FAa0HAAPwKAAAgARDZFSABIAw3AwAgAUEIaiAHQcAA/AoAACAAQQg2AgAgASANNwNIDAELQQBBAEHE1M0AEMMhAAsgB0HgAWokAAvEAwEDfyMAQYAIayIJJAAgCUEAQYAI/AsAAkAgAkGAgAJPBEADQCABIAhNBEAgCCABQaTezgAQwyEACyAJIAAgCGotAABBAnRqIgogCigCAEEBajYCACAIQR1qIgggAkkNAAsgAkEcakEdbiECQQAhCANAIAggCWoiAEELIAAoAgAiACAAQQtPG0EBdEEBciIBIABqNgIAIAEgAmohAiAIQQRqIghBgAhHDQALDAELIAIEQANAIAEgCEYEQCABIAFB1N7OABDDIQALIAkgACAIai0AAEECdGoiCiAKKAIAQQFqNgIAIAIgCEEBaiIIRw0ACwtBACEIA0AgCCAJaiIAQQsgACgCACIAIABBC08bQQF0IgEgAGo2AgAgASACaiECIAhBBGoiCEGACEcNAAsLIAlBgAIgAkEIIANBgAIgBEGAAiAFIAYgBxCjAkEAIQAgCSEBQQAhCAJAAkADQCABKAIAIgQEQCAIQYACTw0CIAQgAyAIai0AAGwgAGohAAsgAUEEaiEBIAhBAWoiCEGAAkcNAAsgAkUNASAJQYAIaiQAIABB/QBsIAJuDwsgCEGAAkHE3s4AEMMhAAtBtN7OABDiKwAL1wMCBX8BfiMAQeAAayICJAAgAkEANgIUIAJCgICAgBA3AgwgAkHIAGogARCNDSACQUBrIgMgAkHUAGoiBCkCADcDACACIAIpAkw3AzgCQAJAIAIoAkgiBUEIRwRAIAIoAlwhASAAIAIpAzg3AgQgACABNgIUIAAgBTYCACAAQQxqIAMpAwA3AgAMAQsgAkEgaiADKQMAIgc3AwAgAiACKQM4NwMYIAJBDGogAigCHCIFIAenIgYQoTYgAkHIAGogAUHgAGoQ/wwgAyAEKQIANwMAIAIgAikCTDcDOCACKAJIIgNBCEcEQCACKAJcIQEgACACKQM4NwIEIAAgATYCFCAAIAM2AgAgAEEMaiACQUBrKQMANwIAIAJBJGogBSAGIAIoAhgoAhARAQAMAQsgAkEwaiACQUBrKQMAIgc3AwAgAiACKQM4NwMoIAJBDGogAigCLCIDIAenIgQQoTYgAUEANgLYASACQdAAaiACQRRqKAIANgIAIAIgAikCDDcDSCAAQQRqIAJByABqEOcVIABBCDYCACACQTRqIAMgBCACKAIoKAIQEQEAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQAMAQsgAkEMahDeOwsgAkHgAGokAAvLAwEKfyMAQYABayIDJABBYiEKAkAgAkEJSQ0AIABBmNAAaiABQQhqIgUgAkEIayAAQZjQABCFBCILQYh/Sw0AIANBHzYCfCADIANB/ABqIgcgA0H4AGoiCCAFIAtqIgUgASACaiICIAVrEII3IgxBiH9LDQAgAygCfCIBQR9LDQAgAygCeCIGQQlPDQAgAEGIIGogAyABQcCw0QBBwLHRACAGIABBqNABaiIGEOYIIANBNDYCfCADIAcgCCAFIAxqIgEgAiABaxCCNyIFQYh/Sw0AIAMoAnwiBEE0Sw0AIAMoAngiCUEKTw0AIABBkDBqIAMgBEHgsdEAQcCz0QAgCSAGEOYIIANBIzYCfCADIAcgCCABIAVqIgQgAiAEaxCCNyIJQYh/Sw0AIAMoAnwiB0EjSw0AIAMoAngiCEEKTw0AQQAhASAAIAMgB0GAtNEAQZC10QAgCCAGEOYIIAQgCWoiBkEMaiIEIAJLDQAgAEGc0AFqIQAgAiAEayECA0AgAUEMRwRAIAEgBmooAAAiBEEBayACTw0CIAAgAWogBDYCACABQQRqIQEMAQsLIAsgDGogBWogCWogAWpBCGohCgsgA0GAAWokACAKC88DAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEEIaiIAIAEoAgQgASgCCBC7CSAIQf8BOgBPIAAgCEHPAGpBARC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8oDAgx/AX4CfyADIAEoAhQiCCAFQQFrIg1qIgdLBEAgBSABKAIQIg5rIQ8gASgCHCELIAEoAgghCiABKQMAIRMDQAJAAkAgEyACIAdqMQAAiEIBg1AEQCABIAUgCGoiCDYCFEEAIQcgBg0CDAELIAogCyAKIAogC0kbIAYbIgkgBSAFIAlJGyEMIAIgCGohECAJIQcCQAJAAkADQCAHIAxGBEBBACALIAYbIQwgCiEHA0AgByAMTQRAIAEgBSAIaiICNgIUIAZFBEAgAUEANgIcCyAAIAI2AgggACAINgIEQQEMCwsgB0EBayIHIAVPDQUgByAIaiIJIANPDQMgBCAHai0AACACIAlqLQAARg0ACyABIAggDmoiCDYCFCAPIQcgBkUNBQwGCyAHIAhqIANPDQIgByAQaiERIAQgB2ogB0EBaiEHLQAAIBEtAABGDQALIAggCmsgB2ohCCAGDQRBACEHDAMLIAkgA0HQxsMAEMMhAAsgAyAIIAlqIgAgACADSRsgA0HgxsMAEMMhAAsgByAFQcDGwwAQwyEACyABIAc2AhwgByELCyAIIA1qIgcgA0kNAAsLIAEgAzYCFEEACyEHIAAgBzYCAAvSAwIHfwJ+IwBBEGsiBCQAAkACQAJAAkAgACkDYEIAUwRAIAAtABQhAiAEIAApAwA3AwggAkEDdiACQQdxQQBHaiICQQlPDQEgAEEIaiIDIARBCGogAhChNiAAQQA6ABQgAEIANwMAIAA1AhAhCSAEQQEQ+jcgAyAEKAIAIAQtAAQQjykgACAJNwNgCyAAKAJoIgJBCU8NASACBEAgAkEDdCEGIABBCGohByAAKQMAIQkgAC0AFCECA0AgACAALQB0IgggAmoiAzoAFCAAIAAgBWpBGGopAwAiCiACrYYgCYQiCTcDAAJAIANB/wFxQcAASQRAIAMhAgwBCyAEIAk3AwggByAEQQhqQQgQoTYgACADQUBqIgI6ABQgACAKIAggAmsiA62IQgAgA0H/AXFBwABJGyIJNwMACyAGIAVBCGoiBUcNAAsLIABBADYCaCABBEAgACgCYCICQQFqIgFFDQMgASAAKAIQIgNLDQQgACgCDCACaiAAKAJwQQJ2QQFyOgAAIABBADYCcCAAQn83A2ALIARBEGokAA8LIAJBCEG49cwAELA7AAsgAkEIQYz4zAAQsDsAC0F/IAFBiPbMABCxOwALIAEgA0GI9swAELA7AAv4DQIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0hCyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBigCACALSXEhCSAGQQRqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDpOyAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDgLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNAyAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCiCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALiQ4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgICAATcCOCAFQThqIgNBARCHLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0EASA0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGKAIAIAtJcSEJIAZBBGohBiAIQQFrIggNAAsgCQ0AIAJBMGoiBBD0LSEGIAJBOzYCmAEgAiAGNgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAEELsjCyACQSBqEOk7IAcoAgAiA0UNByADIAMoAgAiA0EBazYCACADQQFHDQcgBxD7HgwHCwJAIAooAggiBi0AACILQRVGBEAgBigCBCEGIAJBFToA3AIgAiAGNgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBSACKAKcASEIIAIoApgBIQYgCRCVDAwBCyACKAI0IQggAigCMCEGCyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAEQQRqEOAsIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIERQ0EIARCgYCAgBA3AgAgBCACKQKUATcCCCAEQRBqIAJBnAFqKQIANwIAIARBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBDYC0AIgCSACQfABaiIEIAJB0AJqEPojIAogBiAIENMjIAQgCSAKEO8lIAJBOGoiBiAEIAcQrhYgAkGgA2oiByAGEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0GIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0GIAJBMGoQuyMMBgsgAkHkA2oiBiAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBCACQfABaiAGEKMLIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhBCACKAKYASEGIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAQ2AgggAyAGNgIEIANBCDYCAAwFC0HIyc0AQcIAQYzKzQAQnykAC0Hsx80AELI7AAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALkA4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgICAATcCOCAFQThqIgNBARCHLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0GAgARPDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYvAQAgC0H//wNxSXEhCSAGQQJqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahCdPCAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDfLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5AOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAwAA3AjggBUE4aiIDQQEQhi0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgIAETw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLwEAIAtB//8DcUlxIQkgBkECaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQnTwgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ3ywgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuUDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYABTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLQAAwCIMQQBOcSAMIAvASHEhCSAGQQFqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDeOyAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDyLyACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5UOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAgAE3AjggBUE4aiIDQQEQhy0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgIACTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLwEAwSIMQQBOcSAMIAvBSHEhCSAGQQJqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahCdPCAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDfLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC/kNAgx/An4jAEHgAGsiBiQAAkAgASgC8AJFBEAgBkEIaiABQZgDahCUKSAGKAIIIQEgACAGKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBkFAayIHQQA2AgAgBkKAgICAgAE3AjggBkE4aiIDQQEQhy0gBkHYAGogBygCACIHNgIAIAYgBikCOCIONwNQIAZBGGogAUGoAmoiAikCADcDACAGQSBqIAFBsAJqIgUpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAFQgE3AwAgAUEANgKsAiAGIA83AxAgBkEsaiIHIAEQ1xggBkEQaiEFIwBB8ANrIgIkAAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAFKAIAQYCAgIB4RgRAIAJBKGogBUEMaigCADYCACACIAUpAgQ3AyAgAiAFKQIQNwIwAkAgAkEwaiIEEPUtDQAgBBD0LSACKAIoIghFDQCtIQ8gAigCJCEEQQEhCQNAIAkgBCkDACAPVHEhCSAEQQhqIQQgCEEBayIIDQALIAkNACACQTBqIgUQ9C0hBCACQTs2ApgBIAIgBDYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBRC7IwsgAkEgahDjPCAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgQtAAAiC0EVRgRAIAQoAgQhBCACQRU6ANwCIAIgBDYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEEIAkQlQwMAQsgAigCNCEIIAIoAjAhBAsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBUEEahDeLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBUUNAyAFQoGAgIAQNwIAIAUgAikClAE3AgggBUEQaiACQZwBaikCADcCACAFQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAU2AtACIAkgAkHwAWoiBSACQdACahD6IyAKIAQgCBDTIyAFIAkgChDvJSACQThqIgQgBSAHEK4WIAJBoANqIgcgBBDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgQgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAUgAkHwAWogBBCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQUgAigCmAEhBCACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAFNgIIIAMgBDYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBigCQCEDIAYoAjwhByAGKAI4IgJBCEcEQCAAIAYpAkQ3AgwgAEEUaiAGQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAZB4ABqJAAL+Q0CDH8CfiMAQeAAayIGJAACQCABKALwAkUEQCAGQQhqIAFBmANqEJQpIAYoAgghASAAIAYoAgw2AgggACABNgIEIABBCDYCAAwBCyAGQUBrIgdBADYCACAGQoCAgIDAADcCOCAGQThqIgNBARCGLSAGQdgAaiAHKAIAIgc2AgAgBiAGKQI4Ig43A1AgBkEYaiABQagCaiICKQIANwMAIAZBIGogAUGwAmoiBSkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIAVCATcDACABQQA2AqwCIAYgDzcDECAGQSxqIgcgARDXGCAGQRBqIQUjAEHwA2siAiQAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAUoAgBBgICAgHhGBEAgAkEoaiAFQQxqKAIANgIAIAIgBSkCBDcDICACIAUpAhA3AjACQCACQTBqIgQQ9S0NACAEEPQtIAIoAigiCEUNAK0hDyACKAIkIQRBASEJA0AgCSAEKQMAIA9UcSEJIARBCGohBCAIQQFrIggNAAsgCQ0AIAJBMGoiBRD0LSEEIAJBOzYCmAEgAiAENgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAFELsjCyACQSBqEOM8IAcoAgAiA0UNBiADIAMoAgAiA0EBazYCACADQQFHDQYgBxD7HgwGCwJAIAooAggiBC0AACILQRVGBEAgBCgCBCEEIAJBFToA3AIgAiAENgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBCACKAKcASEIIAIoApgBIQQgCRCVDAwBCyACKAI0IQggAigCMCEECyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAFQQRqEN4sIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIFRQ0DIAVCgYCAgBA3AgAgBSACKQKUATcCCCAFQRBqIAJBnAFqKQIANwIAIAVBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBTYC0AIgCSACQfABaiIFIAJB0AJqEPojIAogBCAIENMjIAUgCSAKEO8lIAJBOGoiBCAFIAcQrhYgAkGgA2oiByAEEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0FIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0FIAJBMGoQuyMMBQsgAkHkA2oiBCAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBSACQfABaiAEEKILIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQMgAigCnAEhBSACKAKYASEEIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAU2AgggAyAENgIEIANBCDYCAAwEC0HIyc0AQcIAQYzKzQAQnykACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAGKAJAIQMgBigCPCEHIAYoAjgiAkEIRwRAIAAgBikCRDcCDCAAQRRqIAZBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBkHgAGokAAuVDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYCAAk8NAyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBi8BAMEiDEEATnEgDCALwUhxIQkgBkECaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQnTwgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ3ywgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuJDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQQBIDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYoAgAgC0lxIQkgBkEEaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQ6TsgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ4CwgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAv4DQIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0hCyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBigCACALSXEhCSAGQQRqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDpOyAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDgLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNAyAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALjg4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgIDAADcCOCAFQThqIgNBARCGLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0GAAk8NAyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBi0AACALQf8BcUlxIQkgBkEBaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQ3jsgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ8i8gAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuODgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYACTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLQAAIAtB/wFxSXEhCSAGQQFqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDeOyAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDyLyACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5QOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAwAA3AjggBUE4aiIDQQEQhi0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgAFPDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYtAADAIgxBAE5xIAwgC8BIcSEJIAZBAWohBiAIQQFrIggNAAsgCQ0AIAJBMGoiBBD0LSEGIAJBOzYCmAEgAiAGNgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAEELsjCyACQSBqEN47IAcoAgAiA0UNByADIAMoAgAiA0EBazYCACADQQFHDQcgBxD7HgwHCwJAIAooAggiBi0AACILQRVGBEAgBigCBCEGIAJBFToA3AIgAiAGNgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBSACKAKcASEIIAIoApgBIQYgCRCVDAwBCyACKAI0IQggAigCMCEGCyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAEQQRqEPIvIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIERQ0EIARCgYCAgBA3AgAgBCACKQKUATcCCCAEQRBqIAJBnAFqKQIANwIAIARBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBDYC0AIgCSACQfABaiIEIAJB0AJqEPojIAogBiAIENMjIAQgCSAKEO8lIAJBOGoiBiAEIAcQrhYgAkGgA2oiByAGEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0GIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0GIAJBMGoQuyMMBgsgAkHkA2oiBiAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBCACQfABaiAGEKILIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhBCACKAKYASEGIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAQ2AgggAyAGNgIEIANBCDYCAAwFC0HIyc0AQcIAQYzKzQAQnykAC0Hsx80AELI7AAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALxQQCAn8EfgJAIAFFDQAgACAAKQMAIAKtfDcDAAJAIAAoAkgiAyACakEfTQRAIAIEQCAAIANqQShqIAEgAvwKAAALIAAoAkggAmohAgwBCyABIAJqIQIgAwRAQSAgA2siBARAIABBKGogA2ogASAE/AoAAAsgACgCSCEDIABBADYCSCAAIAApAwggACkAKELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDCCAAIAApAxAgACkAMELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDECAAIAApAxggACkAOELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDGCAAIAApAyAgACkAQELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDICABIANrQSBqIQELIAIgAUEgak8EQCACQSBrIQMgACkDICEFIAApAxghBiAAKQMQIQcgACkDCCEIA0AgACABKQAAQs/W077Sx6vZQn4gCHxCH4lCh5Wvr5i23puef34iCDcDCCAAIAFBCGopAABCz9bTvtLHq9lCfiAHfEIfiUKHla+vmLbem55/fiIHNwMQIAAgAUEQaikAAELP1tO+0ser2UJ+IAZ8Qh+JQoeVr6+Ytt6bnn9+IgY3AxggACABQRhqKQAAQs/W077Sx6vZQn4gBXxCH4lCh5Wvr5i23puef34iBTcDICABQSBqIgEgA00NAAsLIAEgAk8NASACIAFrIgJFDQAgAEEoaiABIAL8CgAACyAAIAI2AkgLC44EAgN/A34jAEHgAGsiAyQAQoCAgICAgICAgH8hCAJAAkACQCAAAn8CfgJAAkAgASgCDCgCECACQQN0aikDACIHQoCAgICAgICAgH9SIAEoAggiBCgCACIFKAIAKQMAIgZCf1JyRQRAQgAhBgwBCyAGUA0GIAcgByAGfyIIIAZ+fUIAIAZCf1IbIQYgB0IAWQ0BCyAIIAYgBSgCCCkDAFetfQwBCyAIIAYgBSgCBCkDAFmtfAsiBkKAgICACHxCgICAgBBaBEAgBCgCBCEBIAMgBzcDICADQcyR/wA2AiggA0IENwI0IANBhgw2AlwgA0H0CzYCVCADIAFBAWo2AlAgA0G7BzYCTCADIAE2AkggA0HMATYCRCADQfiR/wA2AkAgAyADQUBrNgIwIAMgA0EgajYCWCADQQQ2AiwgA0EQaiADQShqEJkOIANBCGogA0EcaigCADYCACADIAMpAhQ3AwBBgoCAgHghBCADKAIQDAELIANBQGsgBqciBSAEKAIILQAAEOoPIAMoAkAiBEGTgICAeEYNASADQQhqIANB0ABqKAIANgIAIAMgAykCSDcDACADKAJECzYCBCAAIAQ2AgAgACADKQMANwIIIABBEGogA0EIaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkECdGogBTYCAAsgA0HgAGokAA8LQbyP/wAQ4isAC6gEAgR/AX4jAEGAAWsiAiQAIAIgAUEYaiIDNgIYIAJBKGpBlqzYsAE2AgAgAkKWrNiw4cKFixY3AyAgAiACQSBqIgQ2AhwCQAJAIAMgBBDHCARAIAQQxwwgAkEQaiABENw7IAIgAigCFCIDNgJYIANBAkcNASACQfQAaiABELEYIAJBCGogARDcOyACKAIMIgNBAUsEQCACKAIIIgQoAgwiAyADKAIAIgVBAWo2AgAgBUEASA0DIAQpAhAhBiAAQSRqIAFBLGpBACABKAIsGxDuJSAAQQhqQZas2LABNgIAIABClqzYsOHChYsWNwIAIAAgBjcCHCAAIAM2AhggACACKQJ0NwIMIABBFGogAkH8AGooAgA2AgAgARCLJyACQYABaiQADwtBASADQfyThgEQwyEACyACQdAAakGWrNiwATYCACACQpas2LDhwoWLFjcDSCACQgM3AjwgAkEDNgI0IAJB0JOGATYCMCACQa0DNgJwIAJBxwI2AmggAkHsj4YBNgJkIAJBxwI2AmAgAkHcj4YBNgJcIAIgAkHcAGo2AjggAiACQcgAajYCbCACQRhqIAJBHGogAkEwakHok4YBEKMrAAsgAkICNwJoIAJBAzYCYCACQcyUhgE2AlwgAkHHAjYCPCACQeyPhgE2AjggAkHHAjYCNCACQdyPhgE2AjAgAiACQTBqNgJkQQAgAkHYAGpB+JOGASACQdwAakHklIYBEK8rCwALqAQCBH8BfiMAQYABayICJAAgAiABQRhqIgM2AhggAkEoakGZsuTIATYCACACQpmy5MiRo8aMGTcDICACIAJBIGoiBDYCHAJAAkAgAyAEEMcIBEAgBBDHDCACQRBqIAEQ3DsgAiACKAIUIgM2AlggA0ECRw0BIAJB9ABqIAEQsRggAkEIaiABENw7IAIoAgwiA0EBSwRAIAIoAggiBCgCDCIDIAMoAgAiBUEBajYCACAFQQBIDQMgBCkCECEGIABBJGogAUEsakEAIAEoAiwbEO4lIABBCGpBmbLkyAE2AgAgAEKZsuTIkaPGjBk3AgAgACAGNwIcIAAgAzYCGCAAIAIpAnQ3AgwgAEEUaiACQfwAaigCADYCACABEIsnIAJBgAFqJAAPC0EBIANB/JOGARDDIQALIAJB0ABqQZmy5MgBNgIAIAJCmbLkyJGjxowZNwNIIAJCAzcCPCACQQM2AjQgAkHQk4YBNgIwIAJBrQM2AnAgAkHHAjYCaCACQdyOhgE2AmQgAkHHAjYCYCACQdyPhgE2AlwgAiACQdwAajYCOCACIAJByABqNgJsIAJBGGogAkEcaiACQTBqQeiThgEQoysACyACQgI3AmggAkEDNgJgIAJBzJSGATYCXCACQccCNgI8IAJB3I6GATYCOCACQccCNgI0IAJB3I+GATYCMCACIAJBMGo2AmRBACACQdgAakH4k4YBIAJB3ABqQeSUhgEQrysLAAuoBAIEfwF+IwBBgAFrIgIkACACIAFBGGoiAzYCGCACQShqQZSo0KABNgIAIAJClKjQoMGChYoUNwMgIAIgAkEgaiIENgIcAkACQCADIAQQxwgEQCAEEMcMIAJBEGogARDcOyACIAIoAhQiAzYCWCADQQJHDQEgAkH0AGogARCyGCACQQhqIAEQ3DsgAigCDCIDQQFLBEAgAigCCCIEKAIMIgMgAygCACIFQQFqNgIAIAVBAEgNAyAEKQIQIQYgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEIakGUqNCgATYCACAAQpSo0KDBgoWKFDcCACAAIAY3AhwgACADNgIYIAAgAikCdDcCDCAAQRRqIAJB/ABqKAIANgIAIAEQiycgAkGAAWokAA8LQQEgA0H8k4YBEMMhAAsgAkHQAGpBlKjQoAE2AgAgAkKUqNCgwYKFihQ3A0ggAkIDNwI8IAJBAzYCNCACQdCThgE2AjAgAkGtAzYCcCACQccCNgJoIAJB7I+GATYCZCACQccCNgJgIAJBzI6GATYCXCACIAJB3ABqNgI4IAIgAkHIAGo2AmwgAkEYaiACQRxqIAJBMGpB6JOGARCjKwALIAJCAjcCaCACQQM2AmAgAkHMlIYBNgJcIAJBxwI2AjwgAkHsj4YBNgI4IAJBxwI2AjQgAkHMjoYBNgIwIAIgAkEwajYCZEEAIAJB2ABqQfiThgEgAkHcAGpB5JSGARCvKwsAC6gEAgR/AX4jAEGAAWsiAiQAIAIgAUEYaiIDNgIYIAJBKGpBmLDgwAE2AgAgAkKYsODAgYOGjBg3AyAgAiACQSBqIgQ2AhwCQAJAIAMgBBDHCARAIAQQxwwgAkEQaiABENw7IAIgAigCFCIDNgJYIANBAkcNASACQfQAaiABELIYIAJBCGogARDcOyACKAIMIgNBAUsEQCACKAIIIgQoAgwiAyADKAIAIgVBAWo2AgAgBUEASA0DIAQpAhAhBiAAQSRqIAFBLGpBACABKAIsGxDuJSAAQQhqQZiw4MABNgIAIABCmLDgwIGDhowYNwIAIAAgBjcCHCAAIAM2AhggACACKQJ0NwIMIABBFGogAkH8AGooAgA2AgAgARCLJyACQYABaiQADwtBASADQfyThgEQwyEACyACQdAAakGYsODAATYCACACQpiw4MCBg4aMGDcDSCACQgM3AjwgAkEDNgI0IAJB0JOGATYCMCACQa0DNgJwIAJBxwI2AmggAkHcjoYBNgJkIAJBxwI2AmAgAkHMjoYBNgJcIAIgAkHcAGo2AjggAiACQcgAajYCbCACQRhqIAJBHGogAkEwakHok4YBEKMrAAsgAkICNwJoIAJBAzYCYCACQcyUhgE2AlwgAkHHAjYCPCACQdyOhgE2AjggAkHHAjYCNCACQcyOhgE2AjAgAiACQTBqNgJkQQAgAkHYAGpB+JOGASACQdwAakHklIYBEK8rCwALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEI8MIAAoAgRBDEEEEPg6IAAoAggQjwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iUL6wMBAX8jAEEQayIEJAACQAJAAkACQAJAIAJBJUYEQCAEIAMpAgA3AgggBEEIahDuEiECIARBCGoQ7hIhAyACQYCAxABGDQQgA0GAgMQARw0BDAQLIAJB3///AHFBwQBrQRpJIAJBMGtBCklyDQQgAkEhayIDQR9NDQEMAgsgAkHf//8AcUHBAGtBBUsgAkEwa0EKT3ENAiADQTBrQQpJDQMgA0Hf//8AcUHBAGtBBUsNAgwDC0EBIAN0Qen/gbB9cQ0CCyACQd8ARiACQf4ARnIgAkGgAWtB4K4DSSACQYDAA2tB0DtJcnIgAkHw+wNrQY4ESSACQYCABGtB/v8DSXIgAkGAgAhrQf7/A0kgAkGAgAxrQf7/A0lycnINASACQYCAEGtB/v8DSSACQYCAFGtB/v8DSXIgAkGAgBhrQf7/A0kgAkGAgBxrQf7/A0lyciACQYCAIGtB/v8DSSACQYCAJGtB/v8DSXIgAkGAgChrQf7/A0kgAkGAgCxrQf7/A0lycnINASACQYCAMGtB/v8DSSACQYCANGtB/v8DSXIgAkGAoDhrQf7fA0kgAkGAgDxrQf7/A0lyciACQYCAQGpB/v8DSXINASAAQQYgASgCFBEAAAwBCyAAQQggASgCFBEAAAsgBEEQaiQAC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCRDCAAKAIEQQxBBBD4OiAAKAIIEJEMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCSDCAAKAIEQQxBBBD4OiAAKAIIEJIMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCTDCAAKAIEQQxBBBD4OiAAKAIIEJMMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCUDCAAKAIEQQxBBBD4OiAAKAIIEJQMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCVDCAAKAIEQQxBBBD4OiAAKAIIEJUMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN8kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOAkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN0kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN4kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABENwkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOEkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCcDCAAKAIEQQxBBBD4OiAAKAIIEJwMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCdDCAAKAIEQQxBBBD4OiAAKAIIEJ0MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCeDCAAKAIEQQxBBBD4OiAAKAIIEJ4MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCfDCAAKAIEQQxBBBD4OiAAKAIIEJ8MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC/kDAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUGWAWsOFgECAwQFBgcICQoLDA0WDg8QFRESFhMACwJAAkACQAJAAkACQCABDgcAAQIDGQQFGwsgACACQQAgAkEBa0EGSRs2AgAMGgsgACACNgIUDBkLIAAgAjYCGAwYCyAAIAI2AhwMFwsgACACNgIgDBYLIAAgAkEARzoAUgwVCyAAIAJBAEc6AFAMFAsgACACQQBHOgBRDBMLIAAgAjoAWQwSCyAAIAI6AFoMEQsgACACNgI8DBALIAAgAjoAWwwPCyAAIAI6AFwMDgsgACACOwFEIAAvAUAgAC8BQnINDSAAIAI7AUAPCyAAIAI7AUYgAC8BQg0MIAAgAjsBQg8LIAAgAjsBTCAALwFIIAAvAUpyDQsgACACOwFIDwsgACACOwFOIAAvAUoNCiAAIAI7AUoPCyAAIAI7AUAMCQsgACACOwFCDAgLIAAgAjsBSAwHCyAAIAI7AUoMBgsgACACQQBHOgBTDAULIAAgAkEARzoAVgwECyAAIAJBAEc6AFcMAwsgACACQQBHOgBYDAILIAJBAk8NASAAIAI2AiQMAQsgACACQQBHIgE6AFQgAC0AVkUEQCAAIAE6AFYLIAAgAkU6AFULC74OAQ1/IwBBQGoiBSQAIAUgAToAGwJAAkACQAJAAkACQCACLQCKEUEVaw4CAQIAC0HMo/MAQShB9KPzABCfKQALIAENAUH8DiEBQfgOIQZB5BAhCQwDCyABRQ0BQeQOIQFB4A4hBkGYECEJDAILIAVBADYCHCAFQRtqQcy0wgAgBUEcakGoo/MAEK0rAAsgBUEANgIcIAVBG2pBuKPzACAFQRxqQbyj8wAQrSsACyACIAlqKAIAIQkgBUEANgIkIAVCgICAgBA3AhwgBUEQaiAFQRxqIhBB9Kj7ABCQISAFKAIUIQcgAiAGaiIGKAIAIQggASACaiIBKAIAIQogBiAFKAIQNgIAIAEgBzYCACAFIAk2AjQgBSAKNgI8IAUgCDYCOCAFQTRqIQ4gBUE4aiEJIwBBMGsiBiQAIAJBjhFqIREgAkHwDWohCwJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQCNEUEBaw4EAQIDBAALIBEgCyAOIAMgBBDuE0EBRg0EDAsLA0AgAigC+A0iAUHBAGtBe0kNBSALIAMgBBDLIA0ACwwKCyAGQQA2AiwgBkKAgICAIDcCJCAGQRhqIAZBJGoiB0H0qPsAEJYhIAIoAuwOIQggAigC6A4hCiACIAYpAxg3A+gOIAIoAtAQIA4oAgBqIgEgASAKIAhBAEEAIAIgAyAEEPcIIQEgBkEANgIsIAZCgICAgCA3AiQgBkEQaiAHQfSo+wAQliEgBigCFCEHIAYoAhAhDCACKALsDiENIAIgCDYC7A4gAigC6A4hCCACIAo2AugOIA0EQCAIIA1BAnRBAhD4OgsgAUEBRw0EIAJBAzoAjREgAkH//wM2AtQQIAdFDQogDCAHQQJ0QQIQ+DoMCgsgCSgCBCEIIAkoAgAhDCACKALQECENIAIoAswQIQEgBiACKALUECIKNgIgIApB//8DRyIHIAAgAUtyDQQMBwtBACEHIAZBADYCJEEBIQEgC0EBIAZBJGogAyAEEO0fDQRBAiEBQQQhBwwFCyACQQA2AswQIA4gDigCAEEBaiIBNgIAIAZBJGoiByAAQcSo+wAQzhggBkEIaiAHQdSo+wAQkCEgBigCDCEHIAYoAgghCCAJKAIEIgoEQCAJKAIAIApBARD4OgsgCSAHNgIEIAkgCDYCACAAIAdLBEBBZyEBDAkLIAFBAk8EQCACQQE6AI0RDAgLQQEhASAHRQ0IIAhBACAH/AsADAgLIAJBAjoAjREgAiABQQVBASACKQPwDSABQT9xrYinIgdBAXEiCBtqNgL4DSACIAdBAXZBD3FBAWpBACAIa3E2AtAQDAYLIAdFDQYgDCAHQQJ0QQIQ+DoMBgsDQAJAAkACQAJAAkACQCAHQQFxRQRAAkAgAigC6A4gAigC7A4gCyAGQSBqIAMgBBCfEwRAIAYoAiAiCg0BIAEgCE8NAyABIAxqQQA6AAAMBQsgAiABNgLMECACQf//AzYC1BAMDAsgCiANSw0CCyAGQQA2AiQgCyAKIAZBJGogAyAEEO0fDQQgAiABNgLMECACIAo2AtQQDAoLIAEgCEH4ovMAEMMhAAsgASAITw0BIAEgDGogCiANazoAAAsgAUEBaiEBDAILIAEgCEGIo/MAEMMhAAsgACAGKAIkQQEgCnRqIgcgAWpJBEBBeCEBDAgLIAEgCCABIAhLGyEPA0AgASAPRwRAIAEgDGpBADoAACABQQFqIQEgB0EBayIHDQEMAgsLIA8gCEGYo/MAEMMhAAtBACEHIAAgAUsNAAsMAgsgBigCJEUNAEFhIQEgAi0AjxENBCAJKAIAIQQgCSgCBCEIIAJBkBFqIQNBACEBAkACQCACQdgQaiIKKAIAQQFqIglBgQJJBEAgCQRAA0AgASADaiABOgAAIAkgAUEBaiIBRw0ACwsgACAISw0BIABFBEBBACEBDAMLIANBAWohCEEAIQEDQCAEIAMgBC0AACIJai0AACILOgAAIAkEQCAIIAMgCfwKAAALIARBAWohBCABIAlyIQEgAyALOgAAIABBAWsiAA0ACwwCCyAJQYACQcii8wAQsDsACyAAIAhB2KLzABCwOwALIAogATYCAEEBIQELIAIgBzoAjREMAwsgAkEEOgCNEQwBCwtBAiEBCyAGQTBqJAAgASAFKAI0IQACQCAFLQAbRQRAIAIgADYC5BAgBUEANgIkIAVCgICAgBA3AhwgBUEIaiAQQfSo+wAQkCEgBSgCDCEBIAUoAgghAyACKAL8DiEAIAIoAvgOIAIgBSkCODcD+A4gAEUNASAAQQEQ+DoMAQsgAiAANgKYECAFQQA2AiQgBUKAgICAEDcCHCAFIAVBHGpB9Kj7ABCQISAFKAIEIQEgBSgCACEDIAIoAuQOIQAgAigC4A4gAiAFKQI4NwPgDiAARQ0AIABBARD4OgsgAQRAIAMgAUEBEPg6CyAFQUBrJAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKIMIAAoAgRBDEEEEPg6IAAoAggQogwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKMMIAAoAgRBDEEEEPg6IAAoAggQowwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULtAMBBH8jAEEwayIDJAAgAEEANgIgAkACQAJAIAAoAjRBAWtBfCAAKAIwIgRrcSICIAAoAgggBGtNDQAgAkGAgICAeEsNASAAKAIIIAAoAjBrIAJPDQADQCAAEPsWIAAoAgggACgCMGsgAkkNAAsLIABBMGoiBCACEI03IABBBCAAKAI0IgIgAkEETRs2AjQCQEEAIAAoAjAiBWtBA3EiAiAAKAIIIAVrTQ0AIAAoAgggACgCMGsgAk8NAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAgggACgCMGtBA0siAiACckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IANBEGogABDcOyADKAIUIQIgAygCECEEIANBCGogACgCMBCMNyADIAQgAiADKAIIIAMoAgxB4P3+ABDXJiADKAIEIgJBA00NASADKAIAIAIgAWs2AAAgAEEBOgA5IANBMGokAA8LQYj9/gBBJUGw/f4AEJ8pAAsgA0EANgIoIANBATYCHCADQcj+/gA2AhggA0IENwIgIANBGGpB8P3+ABDvLAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKUMIAAoAgRBDEEEEPg6IAAoAggQpQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKYMIAAoAgRBDEEEEPg6IAAoAggQpgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKcMIAAoAgRBDEEEEPg6IAAoAggQpwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKgMIAAoAgRBDEEEEPg6IAAoAggQqAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKkMIAAoAgRBDEEEEPg6IAAoAggQqQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQqgwgAUEMQQQQ+DogACgCCCIAEKoMIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC8gDAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEEENgJMIAhBCGoiACAIQcwAakEEELsJIAAgAUEEELsJIAgpAwghAyAIKQMYIQIgCTUCACEGIAgpAzghBCAIKQMgIAgpAxAhByAIQdAAaiQAIAQgBkI4hoQiBoUiBEIQiSAEIAd8IgSFIgVCFYkgBSACIAN8IgNCIIl8IgWFIgdCEIkgByAEIAJCDYkgA4UiAnwiA0IgiUL/AYV8IgSFIgdCFYkgByADIAJCEYmFIgIgBSAGhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULyAMCBn4CfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIQQg2AkwgCEEIaiIAIAhBzABqQQQQuwkgACABQQgQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvIAwIGfgJ/IwBB0ABrIggkACAIQUBrIglCADcDACAIQgA3AzggCCAAKQMIIgI3AzAgCCAAKQMAIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAhBIDYCTCAIQQhqIgAgCEHMAGpBBBC7CSAAIAFBIBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8gDAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEECNgJMIAhBCGoiACAIQcwAakEEELsJIAAgAUECELsJIAgpAwghAyAIKQMYIQIgCTUCACEGIAgpAzghBCAIKQMgIAgpAxAhByAIQdAAaiQAIAQgBkI4hoQiBoUiBEIQiSAEIAd8IgSFIgVCFYkgBSACIAN8IgNCIIl8IgWFIgdCEIkgByAEIAJCDYkgA4UiAnwiA0IgiUL/AYV8IgSFIgdCFYkgByADIAJCEYmFIgIgBSAGhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULyAMCBn4CfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIQQE2AkwgCEEIaiIAIAhBzABqQQQQuwkgACABQQEQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvIAwIGfgJ/IwBB0ABrIggkACAIQUBrIglCADcDACAIQgA3AzggCCAAKQMIIgI3AzAgCCAAKQMAIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAhBEDYCTCAIQQhqIgAgCEHMAGpBBBC7CSAAIAFBEBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC+ADAgF/An4jAEGAAWsiAyQAIAMgAjYCCCADIAE2AgQgA0EEOwEOIANB4ABqIAEgAiADQQ5qEJUDAkAgAygCYEEBRgRAIANB2ABqIANB9ABqKAIAIgE2AgAgA0HQAGogA0HsAGopAgAiBDcDACADIAMpAmQiBTcDSCAAQRBqIAE2AgAgAEEIaiAENwIAIAAgBTcCAAwBCyADQRhqIANB8ABqKQMANwMAIAMgAykDaCIENwMQIAMgA0EQajYCNCADKAIcRSAEUHFFBEAgA0EBNgJkIANBpMuAATYCYCADQgE3AmwgA0HEEDYCTCADIANByABqIgE2AmggAyADQTRqNgJIIANBJGogA0HgAGoiAhCZDiADQY2AgIB4NgIgIANB2ABqIANBMGooAgA2AgAgA0HQAGogA0EoaikCADcDACADIAMpAiA3A0ggA0ECNgJkIANByMaAATYCYCADQgE3AmwgA0HMATYCfCADIANB+ABqNgJoIAMgA0EEajYCeCADQThqIAIQmQ4gARCIESAAIAMpAjw3AgggAEEQaiADQcQAaigCADYCACAAIAMoAjg2AgQgAEGCgICAeDYCAAwBCyADKAIYIQEgAEGTgICAeDYCACAAIAE2AgQLIANBgAFqJAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELIMIAAoAgRBDEEEEPg6IAAoAggQsgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELMMIAAoAgRBDEEEEPg6IAAoAggQswwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELQMIAAoAgRBDEEEEPg6IAAoAggQtAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELUMIAAoAgRBDEEEEPg6IAAoAggQtQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELYMIAAoAgRBDEEEEPg6IAAoAggQtgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELcMIAAoAgRBDEEEEPg6IAAoAggQtwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELgMIAAoAgRBDEEEEPg6IAAoAggQuAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELkMIAAoAgRBDEEEEPg6IAAoAggQuQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULkg4CFX8EfiMAQRBrIgkkACAJIAE2AgwgAEEQaiIMIAlBDGoQzQUhGCAAKAIIRQRAIwBBQGoiBSQAAkACQCAAKAIMIg1BAWoiASANTwRAAkAgACgCBCIHIAdBAWoiCEEDdiIDQQdsIAdBCEkbIg9BAXYgAUkEQAJ/IA9BAWoiAiABIAEgAkkbIgFBD08EQCABQf////8BSw0FQX8gAUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAFBCEkbIAFBBEkbCyEBIAVBMGogAEEQaiIEQQRBCCABEJ0UIAUoAjQhAyAFKAIwIgJFBEAgBSgCOCEBDAULIAUpAjghFyADQQlqIgEEQCACQf8BIAH8CwALIAUgF0IgiD4CLCAFIBenIgg2AiggBSADNgIkIAUgAjYCICAFQoSAgICAATcCGCAFIAQ2AhQgBUEgaiEOIAUgDQR/IAJBCGohCiAAKAIAIgYpAwBCf4VCgIGChIiQoMCAf4MhF0EAIQEDQCAXUARAA0AgAUEIaiEBIAZBCGoiBikDAEKAgYKEiJCgwIB/gyIXQoCBgoSIkKDAgH9RDQALIBdCgIGChIiQoMCAf4UhFwsgAiADIAwgACgCACAXeqdBA3YgAWpBAnQiD2tBBGsQzQWnIhBxIgRqKQAAQoCBgoSIkKDAgH+DIhlQBEBBCCEHA0AgBCAHaiEEIAdBCGohByACIAMgBHEiBGopAABCgIGChIiQoMCAf4MiGVANAAsLIBdCAX0gF4MhFyACIBl6p0EDdiAEaiADcSIEaiwAAEEATgRAIAIpAwBCgIGChIiQoMCAf4N6p0EDdiEECyACIARqIBBBGXYiBzoAACAKIARBCGsgA3FqIAc6AAAgAiAEQQJ0a0EEayAAKAIAIA9rQQRrKAAANgAAIA1BAWsiDQ0ACyAAKAIMBUEACyIBNgIsIAUgCCABazYCKCAAIA5BBBD6KiAFKAIkIgFFDQEgASAFKAIcIgIgBSgCGCABQQFqbGpBAWtBACACa3EiA2pBCWoiAUUNASAFKAIgIANrIAEgAhD4OgwBCyAAKAIAIQIgAyAIQQdxQQBHaiIGBEAgAiEBA0AgASABKQMAIhdCf4VCB4hCgYKEiJCgwIABgyAXQv/+/fv379+//wCEfDcDACABQQhqIQEgBkEBayIGDQALCwJAAkAgCEEITwRAIAIgCGogAikAADcAAAwBCyAIBEAgAkEIaiACIAj8CgAACyAIRQ0BCyACQQhqIQ4gAkEEayETQQEhA0EAIQEDQCABIQQgAyEBAkAgAiAEaiIQLQAAQYABRw0AIBMgBEECdCIDayEUIAIgA2tBBGshEQNAIAcgDCAUEM0FpyIScSIDIQYgAiADaikAAEKAgYKEiJCgwIB/gyIXUARAQQghCgNAIAYgCmohBiAKQQhqIQogAiAGIAdxIgZqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyACIBd6p0EDdiAGaiAHcSIGaiwAAEEATgRAIAIpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIANrIAQgA2tzIAdxQQhPBEAgAiAGaiIDLQAAIAMgEkEZdiIDOgAAIA4gBkEIayAHcWogAzoAACACIAZBAnRrQQRrIQNB/wFGBEAgEEH/AToAACAOIARBCGsgB3FqQf8BOgAAIAMgESgAADYAAAwDCyARIANBARD6KgwBCwsgECASQRl2IgM6AAAgDiAEQQhrIAdxaiADOgAACyABIAEgCEkiBGohAyAEDQALCyAAIA8gDWs2AggLQYGAgIB4IQMMAgsQ4ycgBSgCBCEBIAUoAgAhAwwBCxDjJyAFKAIMIQEgBSgCCCEDCyAJIAM2AgAgCSABNgIEIAVBQGskACAJKAIMIQELIAAoAgQiAyAYp3EhAiAYQhmIIhlC/wCDQoGChIiQoMCAAX4hGiAAKAIAIQQDQAJ/AkACQCACIARqKQAAIhggGoUiF0J/hSAXQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhdQRQRAA0BBASEMIAEgACgCACAXeqdBA3YgAmogA3FBAnRrQQRrKAIAEMEIDQIgF0IBfSAXgyIXUEUNAAsLIBhCgIGChIiQoMCAf4MhFyAVRQRAIBdQDQIgF3qnQQN2IAJqIANxIQsLQQEgFyAYQgGGg1ANAhpBACEMIAQgC2osAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgACgCACIBIAtqIgItAAAhAyAJKAIMIQQgAiAZp0H/AHEiAjoAACABIAAoAgQgC0EIa3FqQQhqIAI6AAAgACAAKAIMQQFqNgIMIAAgACgCCCADQQFxazYCCCABIAtBAnRrQQRrIAQ2AgALIAlBEGokACAMDwtBAAshFSACIBZBCGoiFmogA3EhAgwACwALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELsMIAAoAgRBDEEEEPg6IAAoAggQuwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELwMIAAoAgRBDEEEEPg6IAAoAggQvAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL0MIAAoAgRBDEEEEPg6IAAoAggQvQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL4MIAAoAgRBDEEEEPg6IAAoAggQvgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL8MIAAoAgRBDEEEEPg6IAAoAggQvwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMAMIAAoAgRBDEEEEPg6IAAoAggQwAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMEMIAAoAgRBDEEEEPg6IAAoAggQwQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMIMIAAoAgRBDEEEEPg6IAAoAggQwgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMMMIAAoAgRBDEEEEPg6IAAoAggQwwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMQMIAAoAgRBDEEEEPg6IAAoAggQxAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMUMIAAoAgRBDEEEEPg6IAAoAggQxQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMYMIAAoAgRBDEEEEPg6IAAoAggQxgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMcMIAAoAgRBDEEEEPg6IAAoAggQxwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMgMIAAoAgRBDEEEEPg6IAAoAggQyAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMkMIAAoAgRBDEEEEPg6IAAoAggQyQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQygwgAUEMQQQQ+DogACgCCCIAEMoMIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBDLDCAAKAIEQQxBBBD4OiAAKAIIEMsMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4AEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBCIBEMwMIAFBDEEEEPg6IAAoAggiABDMDCAAQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuCBAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQQzQwgACgCBEEMQQQQ+DogACgCCBDNDCAAKAIIQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuABAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQiARDODCABQQxBBBD4OiAAKAIIIgAQzgwgAEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQzwwgAUEMQQQQ+DogACgCCCIAEM8MIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBDQDCAAKAIEQQxBBBD4OiAAKAIIENAMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC8kDAgZ+An8jAEHQAGsiCSQAIAlBQGsiCkIANwMAIAlCADcDOCAJIAApAwgiAzcDMCAJIAApAwAiBDcDKCAJIANC88rRy6eM2bL0AIU3AyAgCSADQu3ekfOWzNy35ACFNwMYIAkgBELh5JXz1uzZvOwAhTcDECAJIARC9crNg9es27fzAIU3AwggCUEIaiIAIAEgAhC7CSAJQf8BOgBPIAAgCUHPAGpBARC7CSAJKQMIIQQgCSkDGCEDIAo1AgAhByAJKQM4IQUgCSkDICAJKQMQIQggCUHQAGokACAFIAdCOIaEIgeFIgVCEIkgBSAIfCIFhSIGQhWJIAYgAyAEfCIEQiCJfCIGhSIIQhCJIAggBSADQg2JIASFIgN8IgRCIIlC/wGFfCIFhSIIQhWJIAggBCADQhGJhSIDIAYgB4V8IgRCIIl8IgeFIgZCEIkgBiAEIANCDYmFIgMgBXwiBEIgiXwiBYUiBkIViSAGIAQgA0IRiYUiAyAHfCIEQiCJfCIHhSIGQhCJIAYgA0INiSAEhSIDIAV8IgRCIIl8IgWFQhWJIANCEYkgBIUiA0INiSADIAd8hSIDQhGJhSADIAV8IgNCIImFIAOFC4AEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBCIBENIMIAFBDEEEEPg6IAAoAggiABDSDCAAQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuCBAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQQ0wwgACgCBEEMQQQQ+DogACgCCBDTDCAAKAIIQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQvpAwEBfyAAQShqIgEQ0ykgARDeOyAAQThqEN47IAAoAoQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQYQBahCDIAsgACgCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBiAFqEIYfCyAAKAKMASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGMAWoQriALIABByABqIgEQ3BggARDsOyAAQdQAaiIBELErIAFBBEEMEOAeIABB4ABqIgEQuiogAUEEQQwQ4B4gAEHsAGoiARC7KiABQQRBDBDgHiAAQfgAaiIBEOApIAEQ8jsCQCAAKAK8AUGAgICAeEYNACAAQbwBaiIBEKsBIAEQ9DsgACgCyAEiASABKAIAIgFBAWs2AgAgAUEBRw0AIABByAFqEPgjCyAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ+CMLIAAoArABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbABahCDIAsgAEGYAWoiARCjJyABEOk7IABBpAFqEOk7IAAoArQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbQBahD4IwsgACgCuAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBuAFqEK4gCyAAQRBqEIcaC6AEAgZ/An4jAEHQAGsiAiQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAIAAtAERBAWsOAwUBAAILIABBOGohBQJAAkAgAC0AOEEBaw4DCwIAAQsgACgCNCEEDAQLIAApAyghCCAAKQMgIQkgACgCMAwCCwALIABBADoAOCAAIAApAxgiCDcDKCAAIAApAxAiCTcDICAAIAA2AjAgAEE4aiEFIAALIAJBCGoQzyIgAigCDCEEIAIoAgghBigCCBD0OiEHQShBCBCtNiIDRQ0FIANBADoAICADIAc2AhQgAyAGNgIQIAMgCDcDCCADIAk3AwAgA0HM3sIAENQaIAAgBDYCNAsgAkFAayIDIARBCGogARDeFCACKAJAIgFBgYCAgHhGDQEgAikCRCEIIABBNGoQsCwgAUGAgICAeEcNAkGc4MIAQSsgA0H44MIAQfz0wgAQ1R4AC0GM9sIAEOgrAAtBAyEEIAVBAzoAAAwBC0EBIQQgAEEBOgA4IAIgCDcCKCACIAE2AiQgAkEUaiIDIAJBJGoQ5xUgAkEwaiAAKAJAIAMQxiYgAigCMA0DIAAoAggiA0GEAUkNACADEPIfCyAAIAQ6AEQgAkHQAGokACABQYGAgIB4Rg8LQQhBKBCjPQALQez0wgAQ6CsACyACQcgAaiACQThqKQIANwMAIAIgAikCMDcDQEGc4MIAQSsgAkFAa0GM4MIAQZz2wgAQ1R4AC6AEAgZ/An4jAEHQAGsiAiQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAIAAtAERBAWsOAwUBAAILIABBOGohBQJAAkAgAC0AOEEBaw4DCwIAAQsgACgCNCEEDAQLIAApAyghCCAAKQMgIQkgACgCMAwCCwALIABBADoAOCAAIAApAxgiCDcDKCAAIAApAxAiCTcDICAAIAA2AjAgAEE4aiEFIAALIAJBCGoQzyIgAigCDCEEIAIoAgghBigCCBD0OiEHQShBCBCtNiIDRQ0FIANBADoAICADIAc2AhQgAyAGNgIQIAMgCDcDCCADIAk3AwAgA0HopMMAENQaIAAgBDYCNAsgAkFAayIDIARBCGogARDeFCACKAJAIgFBgYCAgHhGDQEgAikCRCEIIABBNGoQsCwgAUGAgICAeEcNAkHgpsMAQSsgA0Gsp8MAQfy4wwAQ1R4AC0GMusMAEOgrAAtBAyEEIAVBAzoAAAwBC0EBIQQgAEEBOgA4IAIgCDcCKCACIAE2AiQgAkEUaiIDIAJBJGoQ5xUgAkEwaiAAKAJAIAMQxiYgAigCMA0DIAAoAggiA0GEAUkNACADEPIfCyAAIAQ6AEQgAkHQAGokACABQYGAgIB4Rg8LQQhBKBCjPQALQey4wwAQ6CsACyACQcgAaiACQThqKQIANwMAIAIgAikCMDcDQEHgpsMAQSsgAkFAa0HQpsMAQZy6wwAQ1R4AC9kEAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQEEBIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOCQECAwQFBgcICQALIAIgAEEEajYCDCABQZjKzABBFEGsyswAQQggAEEQakH4ycwAQbTKzABBCyACQQxqQYjKzAAQjhgMCQsgAiAANgIMIAFBv8rMAEERQdDKzABBBSAAQQxqQfjJzABB1crMAEEKIABBGGpB+MnMAEG0yswAQQsgAkEMakGIyswAEIkXDAgLIAIgAEEEajYCDCABQdjJzABBCUGAy8wAQQUgAEEQakHgyswAQYXLzABBBSAAQRhqQfDKzABBtMrMAEELIAJBDGpBiMrMABCJFwwHCyACIABBBGo2AgwgAUGKy8wAQRVBhcvMAEEFIABBEGpB8MrMAEG0yswAQQsgAkEMakGIyswAEI4YDAYLIAIgAEEEajYCDCABQZ/LzABBCUGoy8wAQQggAEEcakG4ycwAQbDLzABBDiAAQRBqQfjJzABBtMrMAEELIAJBDGpBiMrMABCJFwwFCyACIABBBGo2AgwgAUG+y8wAQRBBhcvMAEEFIABBEGpB8MrMAEG0yswAQQsgAkEMakGIyswAEI4YDAQLIAIgAEEEajYCDCABQeDLzABBF0H3y8wAQQcgAEEQakHQy8wAQajLzABBCCAAQRRqQbjJzABBtMrMAEELIAJBDGpBiMrMABCJFwwDCyABQf7LzABBDRD7NQwCCyABQYvMzABBFBD7NQwBCyABQZ/MzABBERD7NQsgAkEQaiQAC9kEAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQEEBIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOCQECAwQFBgcICQALIAIgAEEEajYCDCABQbyhzwBBFEHQoc8AQQggAEEQakGcoc8AQdihzwBBCyACQQxqQayhzwAQjhgMCQsgAiAANgIMIAFB46HPAEERQfShzwBBBSAAQQxqQZyhzwBB+aHPAEEKIABBGGpBnKHPAEHYoc8AQQsgAkEMakGsoc8AEIkXDAgLIAIgAEEEajYCDCABQdCgzwBBCUGkos8AQQUgAEEQakGEos8AQamizwBBBSAAQRhqQZSizwBB2KHPAEELIAJBDGpBrKHPABCJFwwHCyACIABBBGo2AgwgAUGuos8AQRVBqaLPAEEFIABBEGpBlKLPAEHYoc8AQQsgAkEMakGsoc8AEI4YDAYLIAIgAEEEajYCDCABQcOizwBBCUHMos8AQQggAEEcakHYn88AQdSizwBBDiAAQRBqQZyhzwBB2KHPAEELIAJBDGpBrKHPABCJFwwFCyACIABBBGo2AgwgAUHios8AQRBBqaLPAEEFIABBEGpBlKLPAEHYoc8AQQsgAkEMakGsoc8AEI4YDAQLIAIgAEEEajYCDCABQYSjzwBBF0Gbo88AQQcgAEEQakH0os8AQcyizwBBCCAAQRRqQdifzwBB2KHPAEELIAJBDGpBrKHPABCJFwwDCyABQaKjzwBBDRD7NQwCCyABQa+jzwBBFBD7NQwBCyABQcOjzwBBERD7NQsgAkEQaiQAC4QMAhF/AX4gAygCVCEMIAAgBCAFaiIJQYKAgHhBgoCAgAYgB0EARyADKAIcQQFrQQJJcSIIG2ogBCAFQf7//wdB/v///3kgCBsiCEsbIgQgBSAIIAUgCEkbIgVBABCDFxogAUUgDEEBR3JFBEAgASAEIAVBABCDFxogASADKAIwBH9BAAUgCSABKAIEaws2AhwjAEEgayIKJAAgASIMKAIEIREgA0HUAGoiCygCCCEIIAsoAgQhDSALKAIMIQ8gCkEQaiALEPwnIAFBJGohDkEAIA9rIRAgDyAEIgFqIRJBfyANIAhrdEF/cyETA0AgASAJSQRAIApBADYCDCAKQRBqIAEgCSABayAOIApBDGoQ/AohFiAKKAIMIQ0gDiEIA0AgDQRAIBIgASAIKAIAaiIUTQRAIAwoAhggECAUaiIUIA8Q0z0iGacgE3EiFSALKAAIIhd0QQN0aiAMKAIgIBVqIhUtAAAiGEEDdGogFCARa60gGUKAgICAcIOENwIAIBUgGEEBakF/IBd0QX9zcToAAAsgCEEEaiEIIA1BAWshDQwBCwsgASAWaiEBDAELCyAKQSBqJAALAkAgAygCHEEHSwRAIAUhAQwBCyAFQQhBHCADKAIMIgEgAygCCCIIIAEgCEsbIgEgAUEcTxt0IgggBSAISRshASAJIAhrIAQgBSAISxshBAsgACADKAKIATYCaCAAIAQgACgCBCIFazYCHCAAQQAgCSAFayADKAIwGzYCGCABQQlPBEAgACACIAMgBCAJEJsOAkACQAJAAkACQCADKAIcQQFrDgkAAQICAgMDAwMECyAAIAkgBiAHEPENDAMLIAAgCSAGIAcQywsMAgsgACgCbARAIAAoAlwiB0EBIAAoAsABQQJrIg90IgxBAnQiAyAAKAIcIgFBAnRqIAlBCGsgACgCBCINayIIQQMgD3QiAmsgASACIAhJGyIOQQJ0a2ohBiABIAggASAISxshBSAIQQEgACgCvAF0IgprIQtBASAAKALEAXRBA2shAiAIIAFrIRAgAyAHaiERIAAoAmQhEiABIQMDQCADIAVGBEBB/wEgAiACQf8BTxshBSALIAEgCiAQSRshEEEAIQFBACEKA38gCiAMRgR/IAcgDEEEdGoFQQAhBkEAIQsgByAKQQJ0aiITIQMDQCADKAIAIgMgDkkgBkECS3JFBEAgBkEBaiEGIAsgAyAQSWohCyARIAMgDmtBAnRqIQMMAQsLQQAhBAJAIAZBA0cNACASIAFBAnRqIQYgASECAkADQCAEIAVGBEAgBSEEIAIhAQwDCyADIBBJBEAgA0UNAiALQQFqIgtBA0sNAgsgBiADNgIAIAJBAWohAiADIA5PBEAgBEEBaiEEIAZBBGohBiARIAMgDmtBAnRqKAIAIQMMAQsLIARBAWohBCACIQEMAQsgASAEaiEBCyATIAEgBGtBCHQgBGpBACAEGzYCACAKQQFqIQoMAQsLIQYDQAJAIAwEQCAHIAxBAWsiDEECdCIBaigCACECQXAhAwNAIANBfEYNAiADIAZqQQA2AgAgA0EEaiEDDAALAAsgACgCHCIDIAggAyAISxshAgNAIAIgA0cEQCAHIAMgDWogDyAAKALIARCjHUEEdGoiASkCACEZIAEgAzYCACABQQRqIBk3AgAgA0EBaiEDDAELCyAAIAg2AhwMBgsgByABQQJ0akEMaiACNgIAIAZBEGshBgwACwALIAMgDWogDyAAKALIARCjHSEEIAMgDk8EQCAGIAcgBEECdGooAgA2AgALIAcgBEECdGogAzYCACAGQQRqIQYgA0EBaiEDDAALAAsgAygChAFBAUYEQEEBIAMoAgx0IgEEQCAAKAIoQQAgAfwLAAsgACAJQQhrQQYgACgCyAEiASABQQZPG0EEQQYgACgCxAEiASABQQZPGyIBIAFBBE0bIgFBfyABdEF/c0EAELAgDAILIAAgAEG4AWogCUEIayAAKALIAUEAELwZGgwBCyAAIAlBCGsgCSAAKALIAUEAEKUJCyAAIAkgACgCBGs2AhwLC4oEAgV/BH4jAEGQAWsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBBHRqIgcpAwAiCCAHKQMIIgkQsi4gBiADKQMQIAMpAxggAykDICADKQMoIAQoAgAiBCkDACAEKQMIIAQpAxAgBCkDGBCcBgJAAkACfiADKAIQIgRBAUYEQCAEBEAgBkEEchCIEQsgBSgCBCEBIAMgCTcDaCADIAg3A2AgA0HMkf8ANgJ4IANCBDcChAEgA0GEDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AoABIAMgA0HgAGo2AiggA0EENgJ8IANB0ABqIANB+ABqEJkOIANBCGogA0HUAGooAgA2AgAgA0GCgICAeDYCTCADIAMpAkw3AwAgAykCWAwBCyADQRBqIAMpAyAiCCADKQMoIgkgAykDMCIKIAMpAzgiCyAFKAIILQAAENAOIAMoAhBBk4CAgHhGDQEgA0EIaiADQRhqKAIANgIAIAMgAykCEDcDACADKQIcCyEIIAAgAykDADcCACAAIAg3AgwgAEEIaiADQQhqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAs3AxggACAKNwMQIAAgCTcDCCAAIAg3AwALIANBkAFqJAALhwQCBn8BfiMAQdAAayICJAACQCABKAJYIgQEQCABQQA2AlggASgCVCEDIAEoAlAhBSABQoCAgIAQNwNQIAIgBTYCTCACQoCAgIAQNwJEIAIgBDYCQCACIAM2AjwgAiACQTxqENc7IAIoAgAhB0EcQQQQrTYiA0UNASADQoGAgIAQNwIAIAMgAikCPDcCCCADQRBqIAJBxABqKQIANwIAIANBGGogAkHMAGooAgA2AgAgASgCTCIFIAEoAkRGBEAgAUHEAGpBlMaFARCQKAsgASgCSCAFQQxsaiIGIAQ2AgggBiAHNgIEIAYgAzYCACABIAVBAWo2AkwLIAEpAkQhCCABQoCAgIDAADcCRCACQRBqIgMgAUHMAGoiBCgCADYCACAEQQA2AgAgAiAINwMIIAJBGGogAUHcAGoQ9BICQCABKAIIRQ0AIAEoAhRFDQAgAUEIahCJIAsgASkCOCEIIAFCgICAgIACNwM4IAJBOGogAUFAayIBKAIANgIAIAFBADYCACACIAg3AzAgAEEYaiACQTBqELoYIABBFGpBmrTo0AE2AgAgAEKatOjQocOGjRo3AgwgACACKQMINwIAIABBCGogAygCADYCACAAIAIpAhg3AiQgAEEsaiACQSBqKQIANwIAIABBNGogAkEoaikCADcCACACQdAAaiQADwtBBEEcEKM9AAuHBAIGfwF+IwBB0ABrIgIkAAJAIAEoAlgiBARAIAFBADYCWCABKAJUIQMgASgCUCEFIAFCgICAgBA3A1AgAiAFNgJMIAJCgICAgBA3AkQgAiAENgJAIAIgAzYCPCACIAJBPGoQ1zsgAigCACEHQRxBBBCtNiIDRQ0BIANCgYCAgBA3AgAgAyACKQI8NwIIIANBEGogAkHEAGopAgA3AgAgA0EYaiACQcwAaigCADYCACABKAJMIgUgASgCREYEQCABQcQAakGUxoUBEJAoCyABKAJIIAVBDGxqIgYgBDYCCCAGIAc2AgQgBiADNgIAIAEgBUEBajYCTAsgASkCRCEIIAFCgICAgMAANwJEIAJBEGoiAyABQcwAaiIEKAIANgIAIARBADYCACACIAg3AwggAkEYaiABQdwAahD0EgJAIAEoAghFDQAgASgCFEUNACABQQhqEIkgCyABKQI4IQggAUKAgICAgAI3AzggAkE4aiABQUBrIgEoAgA2AgAgAUEANgIAIAIgCDcDMCAAQRhqIAJBMGoQuhggAEEUakGXrty4ATYCACAAQpeu3Ljx4sWLFzcCDCAAIAIpAwg3AgAgAEEIaiADKAIANgIAIAAgAikCGDcCJCAAQSxqIAJBIGopAgA3AgAgAEE0aiACQShqKQIANwIAIAJB0ABqJAAPC0EEQRwQoz0AC+QDAgR/AX4jAEEwayIHJAACQAJAIAMgBE8EQCAERQRAIAEoAgQgASgCCCIEIAIgASgCECABKAIUIgJrIgUgAyADIAVLGyIDQQN0IARBA3YgAhCBFiAAIAM2AgQgASACIANqNgIUIABBCDYCAAwDCyAHIAMgBGsiCTYCACABKAIEIAEoAggiCiACIAEoAhAgASgCFCIIayIEIAMgAyAESxsiBEEDdCAKQQN2IAgQgRYgASAEIAhqNgIUIAcgBDYCBCAEIAlHDQEgA0EBayEBIANBA3QgAmpBCGshBANAAkACQCAGIAFBA3YiCEsEQCABQQdxQfzEzgBqLQAAIAUgCGotAABxRQ0CIAlBAWsiCSADTw0BIAQpAwAhCyAEIAIgCUEDdGoiCCkDADcDACAIIAs3AwAMAgsgCCAGQaj1zAAQwyEACyAJIANBhPfMABDDIQALIARBCGshBCABQQFrIgFBf0cNAAsgAEEINgIAIAAgAzYCBAwCC0HI9swAQSxB9PbMABCfKQALIAdBAjYCDCAHQcj3zAA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAsgB0EwaiQAC+IDAQR/IwBBMGsiByQAAkACQCADIARPBEAgBEUEQCABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0ECdCAEQQJ2IAIQghYgACADNgIEIAEgAiADajYCFCAAQQg2AgAMAwsgByADIARrIgk2AgAgASgCBCABKAIIIgogAiABKAIQIAEoAhQiCGsiBCADIAMgBEsbIgRBAnQgCkECdiAIEIIWIAEgBCAIajYCFCAHIAQ2AgQgBCAJRw0BIANBAWshASADQQJ0IAJqQQRrIQQDQAJAAkAgBiABQQN2IghLBEAgAUEHcUH8xM4Aai0AACAFIAhqLQAAcUUNAiAJQQFrIgkgA08NASAEKAIAIQggBCACIAlBAnRqIgooAgA2AgAgCiAINgIADAILIAggBkGo9cwAEMMhAAsgCSADQYT3zAAQwyEACyAEQQRrIQQgAUEBayIBQX9HDQALIABBCDYCACAAIAM2AgQMAgtByPbMAEEsQfT2zAAQnykACyAHQQI2AgwgB0HI98wANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgALIAdBMGokAAviAwIFfwJ+IwBB8ABrIgIkACAAKAIAIgQoAgAhBSACQdAAaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAJQQQFxRQ0AIAIpA2AiB0KAgICACHwiCEL/////D1YgAikDaCAHIAhWrXwiCEIAUiAIUBsNACACIAUoAgAoAgAiAzYCKCACIAc+AiQCQCADrCAHxH4iB0IgiKcgB6ciA0EfdUcEQCACQQI2AlQgAkGskP8ANgJQIAJCAjcCXCACQYIMNgJMIAJBggw2AkQgAiACQUBrNgJYIAIgAkEoajYCSCACIAJBJGo2AkAgAkEwaiAGEJkOIAJBGGogAkE0aikCADcDACACQSBqIAJBPGooAgA2AgAgAkGIgICAeDYCLCACIAIpAiwiBzcDECAHp0GTgICAeEcNASACKAIUIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEQahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB8ABqJAAPCyAAIANBiIv/ABDDIQALrgMBAX8gAEEEaiEBAkACQAJAAkACQAJAIAAoAgAOBQECBAMEAAsgASgCACIAQYQBSQ0EIAAQ8h8PCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgASgCACIAKAIAIgFBgICAgHhzIAFBAE4bDhAAAQIDBAUGDwcICQoLDA0ODwsgAEEEahDeOwwOCyAAQQRqELwqDA0LIABBBGoQ3jsMDAsgAEEEahDeOwwLCyAAQQRqEN47DAoLIABBBGoQ3jsMCQsgAEEEahDeOwwICyAAQQRqEN47DAcLIABBBGoQ3jsMBgsgAEEEahDeOwwFCyAAEN47IAAtAAxBA0cNBCAAKAIQIgEQvCogAUEMQQQQ+DoMBAsgAEEEahDeOwwDCyAAQQRqEN47DAILIABBBGoQ3jsMAQsgAEEEahDeOwsgAEEUQQQQ+DoPCyABKAIAIgAQySMgAEEYQQgQ+DoPCyABKAIAIgEoAgAiACgCTARAIABBzABqELwqCyAAKAIAQQJHBEAgAEEQahDeOwsgAEHUAEEEEPg6IAFBBEEEEPg6DwsgARDeOwsL0xUBBn8gCygCACETAkACQAJAAkACQAJAAkACQAJAAkACQAJAIApnQSBqQT9zQQhrDgoAAQIDBAUGBwgJCgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEIQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQ0CQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMCQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEJQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQwCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMCAsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEKQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQsCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBwsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUELQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQoCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEMQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQkCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUENQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQgCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBAsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEOQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQcCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAwsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEPQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQYCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEQQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQUCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUERQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQQCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsLIAJBA3RBH2ogCygCACATa0kEQAJAIA0gE0EDdiIESwRAIAsgEzYCACAEIAxqIgQgBC0AAEF/IBNBB3F0QX9zcToAAAwBCyAEIA1BiI7SABDDIQALIAAgASACIAsgDCANEKkhCyADBEBBAUIBIAsgDCANEN8TQQFCASALIAwgDRDfEyALIAsoAgBBB2pBeHE2AgALDwsgDyABQZjmzgAQrzsAC4AEAgV/BH4jAEHwAGsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBAnRqKAIAIgesIgggCEI/hxCyLiAGIAMpAxAgAykDGCADKQMgIAMpAyggBCgCACIEKQMAIAQpAwggBCkDECAEKQMYEJwGAkACQAJ+IAMoAhAiBEEBRgRAIAQEQCAGQQRyEIgRCyAFKAIEIQEgAyAHNgJUIANBzJH/ADYCWCADQgQ3AmQgA0GCDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AmAgAyADQdQAajYCKCADQQQ2AlwgA0HEAGogA0HYAGoQmQ4gA0EIaiADQcgAaigCADYCACADQYKAgIB4NgJAIAMgAykCQDcDACADKQJMDAELIANBEGogAykDICIIIAMpAygiCSADKQMwIgogAykDOCILIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQggACADKQMANwIAIAAgCDcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCzcDGCAAIAo3AxAgACAJNwMIIAAgCDcDAAsgA0HwAGokAAuRBAIGfwJ+IwBBgAFrIgMkACABKAIMKAIQIAJBAnRqKAIAIQQgAyABKAIIIgUoAgAoAgApAwAiCTcDGCADIASsIgo3AxAgAyAKIApCP4cgCSAJQj+HEKgeAkACQAJ+IAMpAwggAykDACIJQj+HUgRAIANBAjYCZCADQayQ/wA2AmAgA0ICNwJsIANBhgw2AjAgA0GGDDYCKCADIANBJGoiBjYCaCADIANBGGo2AiwgAyADQRBqNgIkIANBOGoiAiADQeAAaiIHEJkOIANB1ABqIANBPGopAgA3AgAgA0HcAGogA0HEAGooAgA2AgAgA0GIgICAeDYCNCADIAMpAjQ3AkwgA0EBNgJIIANByABqIghBBHIQiBEgBSgCBCEBIAMgBDYCJCADQQQ2AkwgA0HMkf8ANgJIIANCBDcCVCADQYIMNgJ8IANB9As2AnQgAyABQQFqNgJwIANBuwc2AmwgAyABNgJoIANBzAE2AmQgA0Ggkv8ANgJgIAMgBzYCUCADIAY2AnggAiAIEJkOIAMpAkAhCkGCgICAeCEEIAMpAjgMAQsgA0HgAGogCSAFKAIILQAAEI0QIAMoAmAiBEGTgICAeEYNASADKQJsIQogAykCZAshCSAAIAo3AgwgACAJNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogCTcDAAsgA0GAAWokAAuLBAIEfwR+IwBBoAFrIgMkACADQRBqIgYgASgCDCgCECACQQV0aiIEKQMAIgcgBCkDCCIIIAQpAxAiCSAEKQMYIgogASgCCCIFKAIAKAIAIgQpAwAgBCkDCCAEKQMQIAQpAxgQnAYCQAJAAn4gAygCECIEQQFGBEAgBARAIAZBBHIQiBELIAUoAgQhASADIAo3A3ggAyAJNwNwIAMgCDcDaCADIAc3A2AgA0HMkf8ANgKIASADQgQ3ApQBIANBgww2AiwgA0H0CzYCJCADIAFBAWo2AiAgA0G7BzYCHCADIAE2AhggA0HMATYCFCADQYyS/wA2AhAgAyADQRBqNgKQASADIANB4ABqNgIoIANBBDYCjAEgA0HQAGogA0GIAWoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIHIAMpAygiCCADKQMwIgkgAykDOCIKIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQcgACADKQMANwIAIAAgBzcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCjcDGCAAIAk3AxAgACAINwMIIAAgBzcDAAsgA0GgAWokAAvdAwIEfg9/AkAgACgCDCIGIAEoAgxHDQAgAUEQaiENIAEoAgAiC0EYayEOIAAoAgAiB0EIaiEAIAcpAwBCf4VCgIGChIiQoMCAf4MhAiABKAIEIQoDQAJAIAZFIQ8gBkUNACAGQQFrIQYgAlAEQANAIAdBwAFrIQcgACkDACAAQQhqIQBCgIGChIiQoMCAf4MiA0KAgYKEiJCgwIB/UQ0ACyADQoCBgoSIkKDAgH+FIQILIAJCAX0gAoNBACEMIAcgAnqnQQN2QWhsaiIIQRBrIRAgCEEUayERIAogDSAIQRhrEPgLIgKncSEJIAJCGYhC/wCDQoGChIiQoMCAAX4hBQNAAkAgCSALaikAACIEIAWFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQCAQKAIAIRIgESgCACETA0AgEyASIA4gAnqnQQN2IAlqIApxQWhsIhRqIgEoAgQgASgCCBDBLg0CIAJCAX0gAoMiAlBFDQALCyAEIARCAYaDQoCBgoSIkKDAgH+DUEUNBCAJIAxBCGoiDGogCnEhCQwBCwshAiAIQQhrKAIAIAhBBGsoAgAgCyAUaiIBQQhrKAIAIAFBBGsoAgAQwS4NAQsLIA8PC0EAC5EEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IIABBBGoQ8iUMCAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcgAEEEahDyJQwHCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FIABBBGoQ8iUMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQgAEEEahDyJQwECyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDAMLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0MAgsgAEEEahDmDCAAQQhqEOYMDAELIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULIABBDEEEEPg6C9UDAQt/IwBBIGsiAiQAIAEoAgghCSABKAIAIQogAkEUaiABKAIMIgcgASgCBCIBa0EDdkEAQQRBCBCgGCACKAIYIQMCQAJAAkAgAigCFEEBRwRAIAJBADYCECACIAIoAhwiBDYCDCACIAM2AggCQANAIAEgB0YNASABKAIAIQUgAUEIaiEBIAVFDQALIAFBBGstAAAhBiADRQRAIAJBCGpBzIPNABCbKCACKAIMIQQLIAQgBjoABCAEIAU2AgAgAkEBNgIQCwNAIAEiAyAHRg0CIAFBCGohASADKAIAIgVFDQAgAigCECIERQ0DIAIoAgwiBiAEQQN0IgtqIgxBCGsiCEUNAyADQQRqLQAAIgMgDEEEay0AAEcEQCACKAIIIARGBH8gAkEIakHsg80AEJsoIAIoAgwFIAYLIAtqIgYgAzoABCAGIAU2AgAgAiAEQQFqNgIQDAELIAgoAgAiAyAFaiIEIANJDQQgCCAENgIADAALAAsgAyACKAIcQbyDzQAQ/S8ACyACIAo2AhggAiAJNgIUIAJBFGpBBEEIEOAeIABBCGogAkEQaigCADYCACAAIAIpAgg3AgAgAkEgaiQADwtB3IPNABCyOwALQfyDzQAQsjsAC8MEAgl/An4jAEGQAmsiAiQAIAEtAEEhBiABLQAoIQcgAS0AQCEIIAJB+ABqIAFBKGoQsQECQCACKAJ4QQFGBEAgAkHQAGogAkGMAWooAgAiATYCACACQcgAaiACQYQBaikCACILNwMAIAIgAikCfCIMNwNAIABBFGogATYCACAAQQxqIAs3AgAgACAMNwIEIABBATYCAAwBCyACQcQAaiIDIAJBgAFqQTD8CgAAIAJBsAFqIgQgA0Ew/AoAACACQQhqIQUgASgCOCEJIAEoAjwhCiMAQSBrIgMkACADIAkgChC/DwJAIAMoAgBBgICAgHhGBEAgBCADKAIENgIEIAVBCGogBEEw/AoAACAFQQA2AgAgA0EgaiQADAELIANBGGogA0EIaikCADcDACADIAMpAgA3AxBBzNWHAUErIANBEGpB+NWHAUHQ1ocBENUeAAsgAigCCEEBRgRAIAJBiAFqIAJBHGooAgAiATYCACACQYABaiACQRRqKQIAIgs3AwAgAiACKQIMIgw3A3ggAEEUaiABNgIAIABBDGogCzcCACAAIAw3AgQgAEEBNgIADAELIAJBhAFqIAJBGGopAwAiCzcCACACQYACaiACQTBqKQMANwMAIAJBiAJqIAJBOGopAwA3AwAgAkHoAWogCzcDACACIAIpAxAiCzcCfCACIAIpAyg3A/gBIAIgCzcD4AEgAiAGQQAgB0EiRhutQv8Bg0ICQgAgCBuENwPwASAAIAJB4AFqIAEQ6AgLIAJBkAJqJAAL9QQBB38jAEEgayIGJABBASEIIAEgASgCFCIHQQFqIgU2AhQCQCAFIAEoAhAiCU8NAAJAAkAgASgCDCAFai0AAEEraw4DAQIAAgtBACEICyABIAdBAmoiBTYCFAsCQAJAIAUgCUkEQCABIAVBAWoiBzYCFCABKAIMIgsgBWotAABBMGtB/wFxIgVBCk8EQCAGQQ02AhQgBiABQQxqIAcQ6gwgBkEUaiAGKAIAIAYoAgQQ+yghASAAQQE2AgAgACABNgIEDAMLIAcgCU8NAQNAIAcgC2otAABBMGtB/wFxIgpBCk8NAiABIAdBAWoiBzYCFCAFQcyZs+YARyAKQQdLciAFQcuZs+YASnFFBEAgBUEKbCAKaiEFIAcgCUcNAQwDCwsjAEEgayIEJAAgAAJ/AkAgA0IAIAgbUARAIAEoAhQiBSABKAIQIgdPDQEgASgCDCEIA0AgBSAIai0AAEEwa0H/AXFBCk8NAiABIAVBAWoiBTYCFCAFIAdHDQALDAELIARBDjYCFCAEQQhqIAFBDGogASgCFBDqDCAAIARBFGogBCgCCCAEKAIMEPsoNgIEQQEMAQsgAEQAAAAAAAAAAEQAAAAAAAAAgCACGzkDCEEACzYCACAEQSBqJAAMAgsgBkEFNgIUIAZBCGogAUEMaiAFEOoMIAZBFGogBigCCCAGKAIMEPsoIQEgAEEBNgIAIAAgATYCBAwBCyAAIAEgAiADAn8gCEUEQCAEIAVrIgBBH3VBgICAgHhzIAAgACAESCAFQQBKcxsMAQsgBCAFaiIAQR91QYCAgIB4cyAAIAVBAEggACAESHMbCxCwEgsgBkEgaiQAC94DAQV/AkACQAJAAkACQCABKAIEIgcgAk8EQCABKAIAIQEgAkUNBCABIAJqIgMgARCWPiIGQQNNBEADQCABIANPDQYgA0EBayIDLQAAQQpHDQAMBQsAC0GAgoQIIANBBGsoAAAiBEGKlKjQAHNrIARyQYCBgoR4cUGAgYKEeEcEQANAIAEgA08NBiADQQFrIgMtAABBCkcNAAwFCwALIAIgA0EDcWshBCAGQQlJDQEDQCAEIgNBCEgNA0GAgoQIIAEgA2oiBkEIaygCACIEQYqUqNAAc2sgBHJBgIGChHhxQYCBgoR4Rw0DIANBCGshBEGAgoQIIAZBBGsoAgAiBkGKlKjQAHNrIAZyQYCBgoR4cUGAgYKEeEYNAAsMAgsgAiAHQejFiAEQsDsACyABIARqIQMDQCABIANPDQMgA0EBayIDLQAAQQpHDQALDAELIAEgA2ohAwNAIAEgA08NAiADQQFrIgMtAABBCkcNAAsLIAMgARCWPkEBaiIFIAdLDQELQQEhAyAAIAEgBWogAUsEf0EAIQMgBSEEA0AgAyABLQAAQQpGaiEDIAFBAWohASAEQQFrIgQNAAsgA0EBagUgAws2AgAgACACIAVrNgIEDwsgBSAHQfjFiAEQsDsAC8ADAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCCABKAIANgJMIAhBCGogCEHMAGpBBBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8ADAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCCABLQAANgJMIAhBCGogCEHMAGpBBBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC44EAgV/An4jAEGAAWsiAyQAIAEoAgwoAhAgAkEDdGopAwAhCSADIAEoAggiBCgCACgCACkDACIINwMYIAMgCTcDECADIAkgCUI/hyAIIAhCP4cQqB4CQAJAAn4gAykDCCADKQMAIghCP4dSBEAgA0ECNgJkIANBrJD/ADYCYCADQgI3AmwgA0GGDDYCLCADQYYMNgIkIAMgA0EgaiIFNgJoIAMgA0EYajYCKCADIANBEGo2AiAgA0E4aiICIANB4ABqIgYQmQ4gA0HUAGogA0E8aikCADcCACADQdwAaiADQcQAaigCADYCACADQYiAgIB4NgI0IAMgAykCNDcCTCADQQE2AkggA0HIAGoiB0EEchCIESAEKAIEIQEgAyAJNwMgIANBBDYCTCADQcyR/wA2AkggA0IENwJUIANBhgw2AnwgA0H0CzYCdCADIAFBAWo2AnAgA0G7BzYCbCADIAE2AmggA0HMATYCZCADQaCS/wA2AmAgAyAGNgJQIAMgBTYCeCACIAcQmQ4gAykCQCEIQYKAgIB4IQQgAykCOAwBCyADQeAAaiAIIAQoAggtAAAQjRAgAygCYCIEQZOAgIB4Rg0BIAMpAmwhCCADKQJkCyEJIAAgCDcCDCAAIAk3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQN0aiAINwMACyADQYABaiQAC/0DAgR/BH4jAEGAAWsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBA3RqKQMAIgcgB0I/hxCyLiAGIAMpAxAgAykDGCADKQMgIAMpAyggBCgCACIEKQMAIAQpAwggBCkDECAEKQMYEJwGAkACQAJ+IAMoAhAiBEEBRgRAIAQEQCAGQQRyEIgRCyAFKAIEIQEgAyAHNwNgIANBzJH/ADYCaCADQgQ3AnQgA0GGDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AnAgAyADQeAAajYCKCADQQQ2AmwgA0HQAGogA0HoAGoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIHIAMpAygiCCADKQMwIgkgAykDOCIKIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQcgACADKQMANwIAIAAgBzcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCjcDGCAAIAk3AxAgACAINwMIIAAgBzcDAAsgA0GAAWokAAv0AwIEfwJ+IwBBkAFrIgIkAAJAIAEtAHxFBEAgAkHgAGoiBCABENQBIAItAGAiA0EERwRAIARBAXIhBANAQQBFBEAgAiAEQS/8CgAACyAFRQRAIAJBMWogAkEv/AoAAAsCQAJAAkACQCADQQNHBEAgAiADOgBgIAVFBEAgBCACQTFqQS/8CgAACyADQQJGDQQgA0EBaw0BDAILIAFBAToAfCAAQoCAgICAgICAgH83AgAMBwsgAkErQQBBAUEBEKAYIAIoAgQhASACKAIAQQFHDQEgASACKAIIQbDMzAAQ/S8ACyAAIAIpADQ3AAQgAEEANgIAIABBFGogAkHEAGooAAA2AAAgAEEMaiACQTxqKQAANwAADAULIAIoAggiA0HgzMwAQSv8CgAAIABBKzYCECAAIAM2AgwgACABNgIIIABCgYCAgMCBgICAfzcCACACLQBgQQFGDQQgAkHgAGoQmx8MBAsgAkHgAGoiAxCbHyADIAEQ1AEgAi0AYCIDQQRHDQALCyACQRNqIAJB9ABqKAIAIgE2AAAgAkELaiACQewAaikCACIGNwAAIAIgAikCZCIHNwADIABBFGogATYAACAAQQxqIAY3AAAgACAHNwAEIABBATYCAAwBCyAAQoCAgICAgICAgH83AgALIAJBkAFqJAAL7wMBB38gAyACIAIgA0kbIQggAEH8EWohCSABIANBAnRqIQcgACgC9BEhBAJAAkACQAJAAkACQAJAA0AgBEG9BE8NASAAIARBAnRqKAIAIQUgACAEQQFrNgL0ESAAKAIEIQQgACAFNgIEIAAgASACQQEQ/w0gACAAKAL4EUEBayIGNgL4ESAGQbwESw0CIAAoAgQhBSAAIAZBAnRqIAQ2AgAgACAAKAL4EUEBayIGNgL4ESAGQb0ETw0DIAAgBkECdGogBTYCACACIARNDQQgAiAFTQ0FIAMgCEYNBiAHIAEgBUECdGoiBi8BACABIARBAnRqIgovAQBqOwEAIAogAzsBAiAAIANqQfwRaiAFIAlqLQAAIgUgBCAJai0AACIEIAQgBUkbQQFqOgAAIAYgAzsBAiAAIAM2AgQgACABIAJBARD/DSAHQQRqIQcgA0EBaiEDIAAoAvQRIgRBAk8NAAsgACAAKAL4EUEBayIBNgL4ESABQbwETQ0GIAFBvQRBqP/7ABDDIQALIARBvQRByP77ABDDIQALIAZBvQRB2P77ABDDIQALIAZBvQRB6P77ABDDIQALIAQgAkH4/vsAEMMhAAsgBSACQYj/+wAQwyEACyAIIAJBmP/7ABDDIQALIAAgAUECdGogACgCBDYCAAuLEAISfwJ+Qbh/IQgCQAJAIAVFDQAgBCwAACILQf8BcSENAkAgC0EASARAIA1B/gBrQQF2IgYgBU8NAiANQf8AayILQYACTw0DIARBAWohCEEAIQUDQCAFIAtPBEAgBiENDAMFIAAgBWoiBCAILQAAQQR2OgAAIARBAWogCC0AAEEPcToAACAIQQFqIQggBUECaiEFDAELAAsACyAFIA1NDQEjAEEwayIHJAAgB0H/ATYCBAJAIAYgB0EEaiAHQQhqIARBAWoiFiANEP0HIgVBiH9LBEAgBSEEDAELQVQhBCAHKAIIIg9BBksNACAHKAIEIhNBAXRBAmqtQgEgD62GIhpBASAPdCIOrEIChnx8QhN8QnyDQoQEfELsBlYNAAJ/IAZBgARqIREgBkEEIA90IgRqQYgEaiELQeQCIARrIQRBUiEJAkAgE0H/AUsNACAErSAaIBNBAWoiF0EBdK18Qgh8VA0AQVQgD0EMSw0BGiARQQRqIRggCyATQQF0akECaiEUQYCAAiAPdEEQdiEQIAYhCCALIQRBACEJQQEhEiAOQQFrIhUhDANAIAkgF0cEQAJAIAgvAQAiCkH//wNGBEAgGCAMQQJ0akECaiAJOgAAIAxBAWshDEEBIQoMAQsgEkEAIBAgCsFKGyESCyAEIAo7AQAgCEECaiEIIARBAmohBCAJQQFqIQkMAQsLIBEgEjsBAiARIA87AQACQCAMIBVGBEAgCyATQQF0aiEQIA5BA3ZBA2ohDEEAIQRBACEKA0AgBCAXRgRAIAwgDkEBdmoiEEEBdCEIQQAhCkEAIQQDQCAEIA5PDQRBACEJIAohDANAIAlBAkcEQCAYIAwgFXFBAnRqQQJqIAkgFGotAAA6AAAgDCAQaiEMIAlBAWohCQwBCwsgFEECaiEUIARBAmohBCAIIApqIBVxIQoMAAsABSAKIBRqIBk3AAAgCiAQaiEIIAYgBEEBdGouAQAhEkEIIQkDQCAJIBJIBEAgCCAJakECaiAZNwAAIAlBCGohCQwBCwsgGUKBgoSIkKDAgAF8IRkgBEEBaiEEIAogEmohCgwBCwALAAsgDkEDdiAOQQF2akEDaiEQQQAhBEEAIQkDQCAEIBdHBEBBACEIIAYgBEEBdGouAQAiCkEAIApBAEobIQoDQCAIIApHBEAgGCAJQQJ0akECaiAEOgAAA0AgCSAQaiAVcSIJIAxLDQALIAhBAWohCAwBCwsgBEEBaiEEDAELCyAJRQ0AQX8MAgsgEUEHaiEJIA9BH2shDCAOIQQDfyAEBH8gCyAJQQFrLQAAQQF0aiIIIAgvAQAiCkEBajsBACAJIAwgCmdqIgg6AAAgCUEDayAKIAh0IA5rOwEAIAlBBGohCSAEQQFrIQQMAQVBAAsLIQkLIAkLIgRBiH9LDQAgDSAFayIERQRAQbh/IQQMAQsgBi8BggQhCCAHIAUgFmoiBjYCKCAHIAZBBGo2AiwCQAJAIARBBE8EQCAHIA0gFmpBBGsiBTYCJCAHIAUoAAAiBTYCHCAFQYCAgAhPDQFBfyEEDAMLIAcgBjYCJCAHIAYtAAAiBTYCHAJAAkACQCAEQQJrDgIBAAILIAYtAAJBEHQgBXIhBQsgByAGLQABQQh0IAVqNgIcCyANIBZqQQFrLQAAIgVFBEBBbCEEDAMLIAcgBWcgBEEDdGtBCWo2AiAMAQsgB0EIIAVBGHZnQR9zazYCICAEQYh/Sw0BCyAAQf8BaiILQQNrIQYgB0EUaiAHQRxqIgQgERDYLiAHQQxqIAQgERDYLiAAIQUCQANAIAdBHGoiBBD9GCAFIAZPcg0BIAVBAWoCfyAIBEAgBSAHQRRqIAQQ+ic6AAAgB0EMaiAEEPonDAELIAUgB0EUaiAHQRxqIgQQtCw6AAAgB0EMaiAEELQsCzoAACAHQRxqIgQQ/RhFBEAgBUEDagJ/IAgEQCAFQQJqIAdBFGogBBD6JzoAACAHQQxqIAQQ+icMAQsgBUECaiAHQRRqIAdBHGoiBBC0LDoAACAHQQxqIAQQtCwLOgAAIAVBBGohBQwBCwsgBUECaiEFCyALQQJrIQsCfwNAQbp/IQQgBSALSw0CIAUCfyAIBEAgB0EUaiAHQRxqEPonDAELIAdBFGogB0EcahC0LAs6AAAgB0EcaiIGEP0YQQNGBEAgBUEBagJ/IAgEQCAHQQxqIAYQ+icMAQsgB0EMaiAHQRxqELQsCzoAACAFQQJqDAILIAVBAWoiBiALSw0CIAYCfyAIBEAgB0EMaiAHQRxqEPonDAELIAdBDGogB0EcahC0LAs6AAAgBUECaiEFIAdBHGoiBBD9GEEDRw0ACyAFAn8gCARAIAdBFGogBBD6JwwBCyAHQRRqIAdBHGoQtCwLOgAAIAVBAWoLIABrIQQLIAdBMGokACAEIgshCCAEQYh/Sw0BC0EAIQQgAUEAQTT8CwAgCyEIIAAhBQNAIAgEQCAFLQAAIgZBDEsNAyABIAZBAnRqIgYgBigCAEEBajYCACAIQQFrIQhBASAFLQAAdEEBdSAEaiEEIAVBAWohBQwBCwtBbCEIIARFDQAgBGciBUEcc0ELSw0AIANBICAFayIDNgIAQYCAgIB4QQEgA3QgBGsiBGciA3YgBEcNACAAIAtqQSAgA2siADoAACABIABBAnRqIgAgACgCAEEBajYCACABKAIEIgBBAkkgAEEBcXINACACIAtBAWo2AgAgDUEBaiEICyAIDwtBbAu0AwEHfyACIARvIgdBAEoEQCABQQFrIQgDQCAHQQBMRQRAIAAgAiAIai0AACADQQBBABD7MCAHQQFrIQcgAkEBayECDAELCyAAIAUQrSULIAIgBEEBdCIKbwRAIARBAWshByABIAJqQQFrIQgDQCAHBEAgACAILQAAIANBAEEBEPswIAhBAWshCCAHQQFrIQcMAQsLIAAgASACIARrIgJqLQAAIANBACAGEPswIAAgBRCtJQtBACAEayEJIAEgAmohCEEAIARBAXRrIQsDQCACQQBMRQRAQX8hBwNAIAQgB2oEQCAAIAcgCGotAAAgA0EAQQEQ+zAgB0EBayEHDAELCyAAIAEgAiAEayIMai0AACADQQAgBhD7MCAAIAUQrSUgAEEANgIMIABBADYCBCAIIAlqIQ1BfyEHA0AgByAJRkUEQCAAIAcgDWotAAAgA0EBQQEQ+zAgB0EBayEHDAELCyAAIAEgDCAEa2otAAAgA0EBIAYQ+zAgACAAKAIMIgcgACgCCGo2AgggACAAKAIEIAAoAgAgB3ZyNgIAIAAgBRCtJSAIIAtqIQggAiAKayECDAELCwvXAwIHfwF+IwBBQGoiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCRHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJEdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0EMbCACakEMayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgAiAIQQxsaiIJQQhqIgooAgAhCyABKQIAIQ4gASAJKQIANwIAIAFBCGoiDCgCACENIAwgCzYCACAKIA02AgAgCSAONwIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQxrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0FAayQAC9cDAgd/AX4jAEFAaiIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADENUKDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ1QogBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQxsIAJqQQxrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASACIAhBDGxqIglBCGoiCigCACELIAEpAgAhDiABIAkpAgA3AgAgAUEIaiIMKAIAIQ0gDCALNgIAIAogDTYCACAJIA43AgAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBDGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQUBrJAALsAMCBH4JfyMAQRBrIgkkACAJIAE6AA8gAEEQaiIGIAlBD2oQwxAhAiAAKAIIRQRAIAkgAEEBIAYQlgQLIAAoAgAiB0EBayELIAAoAgQiCiACp3EhBiACQhmIIgRC/wCDQoGChIiQoMCAAX4hBSABQf8BcSEMA0ACfwJAAkAgBiAHaikAACIDIAWFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAwgCyACeqdBA3YgBmogCnFrLQAARg0CIAJCAX0gAoMiAlBFDQALCyADQoCBgoSIkKDAgH+DIQIgDUUEQCACUA0CIAJ6p0EDdiAGaiAKcSEIC0EBIAIgA0IBhoNQDQIaIAcgCGosAAAiBkEATgRAIAcgBykDAEKAgYKEiJCgwIB/g3qnQQN2IghqLQAAIQYLIAcgCGogBKdB/wBxIgs6AAAgByAIQQhrIApxakEIaiALOgAAIAAgACgCCCAGQQFxazYCCCAAIAAoAgxBAWo2AgwgCEF/cyAHaiABOgAACyAJQRBqJAAPC0EACyENIAYgDkEIaiIOaiAKcSEGDAALAAucAwIDfwJ+IwBB4ABrIgYkAAJAIAEgAoRQIAMgBIRQcg0AQgAgA30gAyAEQgBTIgcbIQlCACABfSABIAJCAFMiCBshCkIAIAQgA0IAUq18fSAEIAcbIQMgAiAEhSEEQgACfkIAIAIgAUIAUq18fSACIAgbIgFQRQRAIANQRQRAIAZB0ABqIAkgAyAKIAEQqB5BASEHIAYpA1ghASAGKQNQDAILIAZBQGsgCSADIApCABCoHiAGQTBqIAkgAyABQgAQqB4gBikDOEIAUiAGKQNIIgIgBikDMHwiASACVHIhByAGKQNADAELIANQRQRAIAZBIGogCUIAIAogARCoHiAGQRBqIANCACAKIAEQqB4gBikDGEIAUiAGKQMoIgIgBikDEHwiASACVHIhByAGKQMgDAELIAYgCSADIAogARCoHkEAIQcgBikDCCEBIAYpAwALIgJ9IAIgBEIAUyIIGyEKQgAgASACQgBSrXx9IAEgCBsiCSAEhUIAWQ0AQQEhBwsgACAKNwMAIAUgBzYCACAAIAk3AwggBkHgAGokAAuKBAIHfwJ+IwBBMGsiAyQAAkACQCABAn8CQAJAAkACQAJAAkACQAJAIAEtADhBAWsOAwUBAAILIAFBHGohBgJAAkAgAS0AHEEBaw4DCwIAAQsgASgCGCEFDAQLIAEoAhQhByABKQMAIQoMAgsACyADQRBqIAFBLGoQ3SAgAUEAOgAcIAEgASkDICIKNwMAIAEgAykDEDcDCCABQRBqIANBGGooAgA2AgAgASABKAIoIgc2AhQgAUEcaiEGCyADQShqIgggAUEQaigCADYCACADIAEpAwg3AyAgA0EIahDPIiADKAIMIQUgAygCCCEJQcgHQQgQrTYiBEUNBSAEIAk2ArQHIAQgBzYCsAcgBCAKNwMAIAQgAykDIDcDuAcgBEEAOgDEByAEQcAHaiAIKAIANgIAIARBoIbDABDUGiABIAU2AhgLIANBIGoiBCAFQQhqIAIQ3hQgAygCICICQYGAgIB4Rg0BIAMpAiQhCiABQRhqELAsIAJBgICAgHhHDQJBoIjDAEErIARBkIjDAEHIl8MAENUeAAtB0JjDABDoKwALIAZBAzoAACAAQYGAgIB4NgIIQQMMAQsgAUEBOgAcIAEQ+ywgASkDICELIAFBLGoQ3jsgACAKNwIMIAAgAjYCCCAAIAs3AwBBAQs6ADggA0EwaiQADwtBCEHIBxCjPQALQbiXwwAQ6CsAC+YDAQd/IwBBIGsiBCQAIABB2ABqIgZBACADEIwmIAYQ8BUCQAJAAkACQAJAAkACQAJAIAEgAk0EQCACIAAoAhgiA0sNASAAKAJcIgMgACgCYCIJIAAoAmQiB2oiBWsiCEEBTQ0CIAMgBUkNAyAAKAIUIQogBigCACIGIAVqIAIgAWsiAjsAACAIQX5xQQJGDQQgAyAFQQJqIgVJDQUgAyAFayIIQQFNDQYgACAHQQRqIgc2AmQgBSAGaiACQX9zOwAAIAJB//8DcQRAIAMgByAJaiIFayACSQ0IIAMgBUkNCSACBEAgBSAGaiABIApqIAL8CgAACyAAIAIgB2o2AmQLIARBIGokAA8LIAEgAkHs9PsAELE7AAsgAiADQez0+wAQsDsACyAEQQA2AhggBEEBNgIMIARBrML7ADYCCCAEQgQ3AhAgBEEIakH89PsAEO8sAAsgBSADQfz0+wAQrzsACyAEQQA2AhggBEEBNgIMIARBrML7ADYCCCAEQgQ3AhAgBEEIakGM9fsAEO8sAAsgBSADQYz1+wAQrzsAC0ECIAhBjPX7ABCwOwALIARBADYCGCAEQQE2AgwgBEGswvsANgIIIARCBDcCECAEQQhqQZz1+wAQ7ywACyAFIANBnPX7ABCvOwAL+QMCBX8EfiMAQbABayICJAAgACgCACIEKAIAIQUgAkEwaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAIwQQFxRQ0AIAIpA0ghByACKQNAIQggBSgCACIDKQMAIQkgAiADKQMIIgo3A2ggAiAJNwNgIAIgBzcDWCACIAg3A1AgAkEANgIsIAJBEGogCCAHIAkgCiACQSxqEPYMIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCAGQQRyEIgRDAELIAIpAxAiByACKQMYIgggBCgCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgCDcDCCAAIAc3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALhAQBCH8jAEHwAmsiAiQAIAEoAhwhBCABKAIYIQUgAkGwAmoiBkGFipQoNgIAIAJChYqUqNCgwYIFNwKoAiACQgQ3AqACIAJCADcCmAIgAkKAgICAwAA3ApACIAJBADYCiAIgAkEAOwHgAiACQQA2AtwCIAJBADYCxAIgAkEANgK4AiACIAEoAhRBA3Y2ArQCAkBBDEEEEK02IgMEQCADIAEpAgw3AgAgA0EIaiABQRRqKAIANgIAIAJBATYC7AIgAiADNgLoAiACQQE2AuQCIAJBDGoiAyACQYgCaiIHIAJB5AJqIggQlikgAkHoAGoiCSADEM0cIAYgAUEIaigCADYCACACQQA2AuACIAIgBDYC3AIgAkEANgLEAiACQQA2ArgCIAIgBTYCtAIgAkIENwKgAiACQgA3ApgCIAJCgICAgMAANwKQAiACQQA2AogCIAIgASkCADcCqAJBiAFBBBCtNiIDRQ0BIANBxABqIAEoAiAiBCABKAIkIgUoAghBAWtBeHFqQQhqIAUoAhQRAAAgAyAJQcQA/AoAACACQQI2AuwCIAIgAzYC6AIgAkECNgLkAiACQawBaiIDIAcgCBD8IiAAIAMQzRwgBCAEKAIAIgBBAWs2AgAgAEEBRgRAIAFBIGoQuyMLIAJB8AJqJAAPC0EEQQwQoz0AC0EEQYgBEKM9AAuEBAEIfyMAQfACayICJAAgASgCHCEEIAEoAhghBSACQbACaiIGQYOGjBg2AgAgAkKDhoyYsODAgQM3AqgCIAJCBDcCoAIgAkIANwKYAiACQoCAgIDAADcCkAIgAkEANgKIAiACQQA7AeACIAJBADYC3AIgAkEANgLEAiACQQA2ArgCIAIgASgCFEEBdjYCtAICQEEMQQQQrTYiAwRAIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLsAiACIAM2AugCIAJBATYC5AIgAkEMaiIDIAJBiAJqIgcgAkHkAmoiCBCWKSACQegAaiIJIAMQzRwgBiABQQhqKAIANgIAIAJBADYC4AIgAiAENgLcAiACQQA2AsQCIAJBADYCuAIgAiAFNgK0AiACQgQ3AqACIAJCADcCmAIgAkKAgICAwAA3ApACIAJBADYCiAIgAiABKQIANwKoAkGIAUEEEK02IgNFDQEgA0HEAGogASgCICIEIAEoAiQiBSgCCEEBa0F4cWpBCGogBSgCFBEAACADIAlBxAD8CgAAIAJBAjYC7AIgAiADNgLoAiACQQI2AuQCIAJBrAFqIgMgByAIEPwiIAAgAxDNHCAEIAQoAgAiAEEBazYCACAAQQFGBEAgAUEgahC7IwsgAkHwAmokAA8LQQRBDBCjPQALQQRBiAEQoz0AC4QEAQh/IwBB8AJrIgIkACABKAIcIQQgASgCGCEFIAJBsAJqIgZBhIiQIDYCACACQoSIkKDAgIGCBDcCqAIgAkIENwKgAiACQgA3ApgCIAJCgICAgMAANwKQAiACQQA2AogCIAJBADsB4AIgAkEANgLcAiACQQA2AsQCIAJBADYCuAIgAiABKAIUQQJ2NgK0AgJAQQxBBBCtNiIDBEAgAyABKQIMNwIAIANBCGogAUEUaigCADYCACACQQE2AuwCIAIgAzYC6AIgAkEBNgLkAiACQQxqIgMgAkGIAmoiByACQeQCaiIIEJYpIAJB6ABqIgkgAxDNHCAGIAFBCGooAgA2AgAgAkEANgLgAiACIAQ2AtwCIAJBADYCxAIgAkEANgK4AiACIAU2ArQCIAJCBDcCoAIgAkIANwKYAiACQoCAgIDAADcCkAIgAkEANgKIAiACIAEpAgA3AqgCQYgBQQQQrTYiA0UNASADQcQAaiABKAIgIgQgASgCJCIFKAIIQQFrQXhxakEIaiAFKAIUEQAAIAMgCUHEAPwKAAAgAkECNgLsAiACIAM2AugCIAJBAjYC5AIgAkGsAWoiAyAHIAgQ/CIgACADEM0cIAQgBCgCACIAQQFrNgIAIABBAUYEQCABQSBqELsjCyACQfACaiQADwtBBEEMEKM9AAtBBEGIARCjPQALxAMBAn8CfyABQYABTwRAQQBBzQVBACABQdI9TxsiAiACQeYCaiICIAJBA3RBsJSKAWooAgAgAUsbIgIgAkGzAWoiAiACQQN0QbCUigFqKAIAIAFLGyICIAJB2gBqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQS1qIgIgAkEDdEGwlIoBaigCACABSxsiAiACQRZqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQtqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQZqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQNqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQFqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQFqIgIgAkEDdEGwlIoBaigCACABSxsiAkEDdEGwlIoBaigCACIDIAFHDQEaIAIgASADS2oiAUGZC00EQEHpACABQQN0QbSUigFqKAIAIgEgAUGAsANzQYCAxABrQYCQvH9JIgIbIQFBhwZBACACGwwCC0GaC0GaC0GglIoBEMMhAAsgAUHBAGtBGklBBXQgAXIhAUEACyECIABBADYCCCAAIAI2AgQgACABNgIAC8sDAgR/AX4jAEHgAGsiBCQAAkAgASgCCEGAgICAeEYEQCAEQQRqIgdBgAhBAEEBQQEQoBggBCgCCCEFIAQoAgRBAUYNASAEQdwAaiIGQQA2AgAgBCAEKAIMNgJYIAQgBTYCVCAEQdQAakHIhs4AQQQQoTYgBEHQAGoiBSAGKAIANgIAIAQgBCkCVDcDSCAEQQdqQQBBwAD8CwAgARCBLyABQgA3AwAgAUEAOgAUIAFBCGoiBiAEKQNINwMAIAZBCGogBSgCADYCACABQRVqIAdBwwD8CgAAIAFBAToAdCABQQA2AnAgAUIANwNoIAFCfzcDYCABQgA3A1gLAkAgAwRAIAFBGGohBgNAIAEoAmwhBQJAAkAgAjEAACIIIAEpA1hSBEAgBUEHSwRAIAEQvQ0LIAEgCDcDWCABQQE2AmwMAQsgASAFQQFqIgU2AmwgBUEISw0BCyABKAJoIgVBB0sNAyAGIAVBA3RqIAg3AwAgASABKAJoQQFqIgU2AmggBUEIRw0AIAEQyicLIAJBAWohAiADQQFrIgMNAAsLIABBCDYCACAEQeAAaiQADwsgBUEIQeiizgAQwyEACyAFIAQoAgxB6JzOABD9LwALwAMCBn8BfiMAQdAAayICJAAgAkEANgIUIAJCgICAgBA3AgwgAkE4aiABEI0NIAJBMGoiAyACQcQAaikCADcDACACIAIpAjw3AygCQAJAIAIoAjgiBEEIRwRAIAIoAkwhASAAIAIpAyg3AgQgACABNgIUIAAgBDYCACAAQQxqIAMpAwA3AgAgAkEMahDeOwwBCyACQSBqIAMpAwAiCDcDACACIAIpAyg3AxggAkEMaiACKAIcIgUgCKciBhChNgJAIAEoAmgiBEUNACABKAJkIgMgBEEEdGohBANAIAMoAgBFDQMgAkEMaiADQQRqKAIAIANBCGooAgAQoTYgA0EQaiIDIARHDQALIAEoAmghBCABQQA2AmggBEUNACABKAJkIQMDQCADKAIAIgcEQCADQQxqIANBBGooAgAgA0EIaigCACAHKAIQEQEACyADQRBqIQMgBEEBayIEDQALCyABQQA2AmwgAkFAayACQRRqKAIANgIAIAIgAikCDDcDOCAAQQRqIAJBOGoQ5xUgAEEINgIAIAJBJGogBSAGIAIoAhgoAhARAQALIAJB0ABqJAAPC0Hkh84AQSBBhIjOABDLJAALhAMAIAAgAjYCACAAIAQgA2tBGXQgA3I2AgQgBSABKAIEIAE1AgAgAEEOaiAAQQhqEJYYIAAvAQ4CfwJAAkAgAkEGTwRAIAJBggFJDQEgAkHCEEkNAkEVIAJBwjBJDQMaQRZBFyACQcKwAUkbDAMLIAIMAgsgAkECayICZ0EgakE/c0EBayIDQQF0IAIgA3ZqQQJqDAELIAJBwgBrZ0EgakE/c0EKagshA0H/B3EhBQJ/AkAgBEEKTwRAIARBhgFJDQFBFyAEQcYQTw0CGiAEQcYAa2dBIGpBP3NBDGoMAgsgBEECawwBCyAEQQZrIgFnQSBqQT9zQQFrIgJBAXQgASACdmpBBGoLIgJBB3EgA0EDdEE4cXIhASAAAn8gBSADQf//A3FBB0tyRSACQf//A3FBEElxRQRAIAEgA0H4/wNxQQN2QQNsIAJB+P8DcUEDdmoiAUEGdEHAmsgCIAFBAXR2QcABcWpyQUBrDAELIAEgAUHAAHIgAkH//wNxQQhJGws7AQwLkgQCCH8BfiMAQeAAayICJAAgAiAAKQMYIgo3A0ggAiAAKQMQNwNAIAIgACkDCDcDOCACIAApAwA3AzACQCAKQgBZBEAgAkEIaiACQTBqQSAQgg8gAkEoaiACQRBqKAIAIgA2AgAgAiACKQIINwMgIAJBAkEBIAAbOgAsDAELIAJB1ABqIQMgAkEwaiEEIwBBEGsiACQAIABBBGpBIEEAQQFBARCgGCAAKAIIIQUCQCAAKAIEQQFHBEAgACgCDCIGIARBIPwKAAAgA0EgNgIIIAMgBjYCBCADIAU2AgAgAEEQaiQADAELIAUgACgCDEGwoogBEP0vAAsCQAJAIAIoAlwiBARAIApCAFlBAXQhBiACKAJYIQdBACEAQQEhAwNAIAAgB2oiCCAILQAAIglBf3M6AAAgA0EAIQMEQCAIQQAgCWs6AAAgCUUhAwsgBCAAQQFqIgBHDQALIAJBCGogByAEEIIPIAIoAhANAgwBCyACQRBqQfjyhwEoAgA2AgAgAkHw8ocBKQIANwMIC0EBIQYLIAJBKGogAkEQaigCADYCACACIAIpAwg3AyAgAiAGOgAsIAJB1ABqEN47CyACQaEdNgJYIAJBATYCDCACQcjzhwE2AgggAkIBNwIUIAIgAkEgaiIANgJUIAIgAkHUAGo2AhAgASgCACABKAIEIAJBCGoQywogABDpOyACQeAAaiQAC8sDAQZ/IwBB4ABrIgQkACABQRBqIQUgBEEcaiEHAn8gASgCEARAIAEoAhQhAiABKAIcIQZBAAwBC0EBCyEDA0ACQAJAAkACQCADRQRAIAIgBkcEQCABIAJByABqNgIUIAIoAgAiA0GAgICAeEcNAgsgBRDnICAFQQA2AgBBASEDDAULIAEoAgBFDQEgASgCBCICIAEoAgxGDQEgASACQcgAajYCBCACKAIAIgNBhICAgHhGDQEgByACQQRqQcQA/AoAACAEIAM2AhggBEEMaiAEQRhqEMoLIAQoAgwiAkGAgICAeEYNASABIAI2AhggASAEKAIQIgI2AhQgASACNgIQIAEgAiAEKAIUQcgAbGoiBjYCHAwCCyAAQQRqIAJBBGpBxAD8CgAAIAAgAzYCAAwCCyABKAIgBEACQCABKAIkIgMgASgCLEcEQCABIANByABqNgIkIAMoAgAhAiAEQRhqIANBBGpBxAD8CgAAIAJBgICAgHhHDQELIAFBIGoiARDnICABQQA2AgBBgICAgHghAgsgACACNgIAIABBBGogBEEYakHEAPwKAAAMAgsgAEGAgICAeDYCAAwBC0EAIQMMAQsLIARB4ABqJAALixECEH8BfiMAQTBrIhAkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQgAoMBQsgACABQQN2IghB1ABsaiEHIAAgCEEwbGohCiAQQRBqAn8gAUHAAE8EQCAAIAogByAIIAYQoRoMAQsgACAHIAogACgCACIIIAooAgAiCkkiCyAKIAcoAgAiB0lzGyALIAcgCEtzGwsiB0EIaigCADYCACAQIAcpAgA3AwggByAAa0EMbiEKAkACQCAFBEAgBSgCACAHKAIATw0BCwJ/QQAhCSABIANLIAoiByABT3JFBEAgAiABQQxsaiELIAAgB0EMbGohDCAAIQgDQCAAIAdBA2siDkEAIAcgDk8bQQxsaiIOIAhLBEADQCAJQQxsIAIgC0EMayAIKAIAIAwoAgBJIg0baiIPIAgpAgA3AgAgD0EIaiAIQQhqKAIANgIAIAkgDWoiCUEMbCACIAtBGGsgCEEMaiINKAIAIAwoAgBJIg8baiIRIA0pAgA3AgAgEUEIaiAIQRRqKAIANgIAIAkgD2oiCUEMbCACIAtBJGsgCEEYaiINKAIAIAwoAgBJIg8baiIRIA0pAgA3AgAgEUEIaiAIQSBqKAIANgIAIAkgD2oiCUEMbCACIAtBMGsiCyAIQSRqIg0oAgAgDCgCAEkiDxtqIhEgDSkCADcCACARQQhqIAhBLGooAgA2AgAgCSAPaiEJIAhBMGoiCCAOSQ0ACwsgACAHQQxsaiIOIAhLBEADQCAJQQxsIAIgC0EMayILIAgoAgAgDCgCAEkiDRtqIg8gCCkCADcCACAPQQhqIAhBCGooAgA2AgAgCSANaiEJIAhBDGoiCCAOSQ0ACwsgASAHRwRAIAtBDGsiCyAJQQxsaiIHIAgpAgA3AgAgB0EIaiAIQQhqKAIANgIAIAhBDGohCCABIQcMAQsLIAlBDGwiBwRAIAAgAiAH/AoAAAsgASAJRwRAIAEgCWshByAAIAlBDGxqIQggAUEMbCACakEMayELA0AgCCALKQIANwIAIAhBCGogC0EIaigCADYCACALQQxrIQsgCEEMaiEIIAdBAWsiBw0ACwsgCQwBCwALIgdFDQAgASAHTw0BIBBBADYCKCAQQQE2AhwgEEHs8/4ANgIYIBBCBDcCICAQQRhqQfTz/gAQ7ywACyABAn9BACEIIAEgA0sgCiIFIAFPckUEQCACIAFBDGxqIQogACAFQQxsaiELIAAhBwNAIAAgBUEDayIJQQAgBSAJTxtBDGxqIgkgB0sEQANAIAhBDGwgAiAKQQxrIAsoAgAgBygCAE8iDBtqIg4gBykCADcCACAOQQhqIAdBCGooAgA2AgAgCCAMaiIIQQxsIAIgCkEYayALKAIAIAdBDGoiDCgCAE8iDhtqIg0gDCkCADcCACANQQhqIAdBFGooAgA2AgAgCCAOaiIIQQxsIAIgCkEkayALKAIAIAdBGGoiDCgCAE8iDhtqIg0gDCkCADcCACANQQhqIAdBIGooAgA2AgAgCCAOaiIIQQxsIAIgCkEwayIKIAsoAgAgB0EkaiIMKAIATyIOG2oiDSAMKQIANwIAIA1BCGogB0EsaigCADYCACAIIA5qIQggB0EwaiIHIAlJDQALCyAAIAVBDGxqIgkgB0sEQANAIAhBDGwgAiAKQQxrIgogCygCACAHKAIATyIMG2oiDiAHKQIANwIAIA5BCGogB0EIaigCADYCACAIIAxqIQggB0EMaiIHIAlJDQALCyABIAVHBEAgCEEMbCACIApBDGsiCkEBG2oiBSAHKQIANwIAIAVBCGogB0EIaigCADYCACAHQQxqIQcgCEEBaiEIIAEhBQwBCwsgCEEMbCIFBEAgACACIAX8CgAACyABIAhHBEAgASAIayEFIAAgCEEMbGohByABQQxsIAJqQQxrIQoDQCAHIAopAgA3AgAgB0EIaiAKQQhqKAIANgIAIApBDGshCiAHQQxqIQcgBUEBayIFDQALCyAIDAELAAsiB0kNAyAAIAdBDGxqIQBBACEFIAEgB2siAUEhTw0CDAQLIAAgB0EMbGogASAHayACIAMgBCAQQQhqIAYQgw0gBEEBayEEIAciAUEhTw0ACwsMAQsgByABQYT0/gAQrzsACyAAIQUgAiEEIwBBEGsiCSQAIAEiBkECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEMIAFBD0sNASACIAxBDGwiB2ohAyAAIAdqIQcgAUEHSwRAIAAgAhDxEiAHIAMQ8RJBBAwDCyAEIAUpAgA3AgAgBEEIaiAFQQhqKAIANgIAIAMgBykCADcCACADQQhqIAdBCGooAgA2AgBBAQwCCwALIAUgBCAEIAZBDGxqIgAQsC0gBSAMQQxsIgFqIAEgBGogAEHgAGoQsC1BCAshAyAJQgI3AgQgA0EMbCEOIANBAWohCCAJIAw2AgwgBiAMayESIAlBCGohE0EAIQADQCAAIBIgDCATIABBAnRqKAIAIgAbIhQgA0sEQCAFIABBDGwiAGohFUEMIQcgACAEaiIPIQogCCEAIAMhAQNAIAAhAiAPIAFBDGwiAWoiACABIBVqIgEpAgAiFzcCACAAQQhqIAFBCGooAgA2AgAgF6ciESAAQQxrKAIASQRAIAApAgQhFyAHIQAgCiEBAn8DQCABIA5qIg0gDUEMayIWKQIANwIAIA1BCGogFkEIaigCADYCACAPIAAgDkYNARogAEEMaiEAIAFBDGshASARIA1BGGsoAgBJDQALIAEgDmoLIgAgFzcCBCAAIBE2AgALIAdBDGshByAKQQxqIQogAiACIBRJIg1qIQAgAiEBIA0NAAsLQQEhAEEBcUUNAAsgCUECNgIAIAQgBiAFEIgQCyAJQRBqJAALIBBBMGokAAu4AwEHfyMAQSBrIgIkAAJAAkACQCAAKAIARQRAQcAAIQQgACgCGCIBIAAoAhQiBSABIAVLGyIBQQN2IAFBB3FBAEdqIgFBwP///wNxQUBrIAEgAUE/cRsiA0HAABDRNEUNASADBEAgA0HAABCtNiIERQ0DCyACQgA3AhQgAiAENgIQIAIgAzYCDCACQcAANgIIAkAgBUEDdiAFQQdxIgZBAEdqIgFFDQAgASADSwRAIAJBCGogA0EBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSACKAIUIQcgAigCECEECyABRQ0AIAQgB2pB/wEgAfwLAAsgAiABNgIUIAYEQCABRQ0EIAEgBGpBAWsiAUUNBCABIAEtAABBfyAGdEF/c3E6AAALIAIgBTYCGAJAIAAoAgAiAUUNACAAKAIEIgNFDQAgACgCCCADIAEQ+DoLIAAgAikCCDcCACAAQRBqIAJBGGooAgA2AgAgAEEIaiACQRBqKQIANwIACyACQSBqJAAPC0HY/ocBQSkgAkEfakHM/IcBQYT/hwEQ1R4AC0HAACADEKM9AAtBlP+HARCyOwALmg4BDn8jAEEgayIQJAACQAJAIAFBIUkNAAJAA0AgBEEBayEEA0AgBEF/RgRAIAAgASACIANBASAGEPoJDAULIAAgAUEDdiIHQRxsaiEIIAAgB0EEdGohCyAQAn8gAUHAAE8EQCAAIAsgCCAHIAYQuRkMAQsgACAAKAIAQRh2IgcgCygCAEEYdiIKSSIJIAcgCCgCAEEYdiIMSXMNABogCCALIAkgCiAMSXMbCyIIKAIAIgc2AgQgCCAAa0ECdiELAkACQCAFBEAgBS0AAyAHQRh2Tw0BCwJ/QQAhCSABIANLIAsiCCABT3JFBEAgAiABQQJ0aiEKIAAgCEECdGohDCAAIQcDQCAAIAhBA2siDUEAIAggDU8bQQJ0aiINIAdLBEADQCAJQQJ0IAIgCkEEayAMLQADIAcoAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEIayAMLQADIAdBBGooAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEMayAMLQADIAdBCGooAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEQayIKIAwtAAMgB0EMaigCACIOQRh2SyIPG2ogDjYCACAJIA9qIQkgB0EQaiIHIA1JDQALCyAAIAhBAnRqIg0gB0sEQANAIAlBAnQgAiAKQQRrIgogDC0AAyAHKAIAIg5BGHZLIg8baiAONgIAIAkgD2ohCSAHQQRqIgcgDUkNAAsLIAEgCEcEQCAKQQRrIgogCUECdGogBygCADYCACAHQQRqIQcgASEIDAELCyAJQQJ0IggEQCAAIAIgCPwKAAALIAEgCUcEQCABIAlrIQggACAJQQJ0aiEHIAFBAnQgAmpBBGshCgNAIAcgCigCADYCACAKQQRrIQogB0EEaiEHIAhBAWsiCA0ACwsgCQwBCwALIghFDQAgASAITw0BIBBBADYCGCAQQQE2AgwgEEGorMwANgIIIBBCBDcCECAQQQhqQbCszAAQ7ywACyABAn9BACEHIAEgA0sgCyIFIAFPckUEQCACIAFBAnRqIQsgACAFQQJ0aiEKIAAhCANAIAAgBUEDayIJQQAgBSAJTxtBAnRqIgkgCEsEQANAIAdBAnQgAiALQQRrIAotAAMgCCgCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQQhrIAotAAMgCEEEaigCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQQxrIAotAAMgCEEIaigCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQRBrIgsgCi0AAyAIQQxqKAIAIgxBGHZPIg0baiAMNgIAIAcgDWohByAIQRBqIgggCUkNAAsLIAAgBUECdGoiCSAISwRAA0AgB0ECdCACIAtBBGsiCyAKLQADIAgoAgAiDEEYdk8iDRtqIAw2AgAgByANaiEHIAhBBGoiCCAJSQ0ACwsgASAFRwRAIAdBAnQgAiALQQRrIgtBARtqIAgoAgA2AgAgCEEEaiEIIAdBAWohByABIQUMAQsLIAdBAnQiBQRAIAAgAiAF/AoAAAsgASAHRwRAIAEgB2shBSAAIAdBAnRqIQggAUECdCACakEEayELA0AgCCALKAIANgIAIAtBBGshCyAIQQRqIQggBUEBayIFDQALCyAHDAELAAsiCEkNAyAAIAhBAnRqIQBBACEFIAEgCGsiAUEhTw0CDAQLIAAgCEECdGogASAIayACIAMgBCAQQQRqIAYQhQ0gBEEBayEEIAgiAUEhTw0ACwsMAQsgCCABQcCszAAQrzsACyAAIQQjAEEQayIKJAAgASIFQQJPBEACfwJAIAFBEGogA00EQCABQQF2IQcgAUEPSw0BIAFBB0sEQCAAIAIQwRUgACAHQQJ0IgFqIAEgAmoQwRVBBAwDCyACIAQoAgA2AgAgAiAHQQJ0IgBqIAAgBGooAgA2AgBBAQwCCwALIAQgAiACIAVBAnRqIgAQqS0gBCAHQQJ0IgFqIAEgAmogAEEgahCpLUEICyEDIApCAjcCBCADQQJ0IQggCiAHNgIMIAUgB2shDiAKQQhqIQ9BACEAA0AgACAOIAcgDyAAQQJ0aigCACIAGyIRIANLBEAgAiAAQQJ0IgBqIQkgACAEaiESIAghASADIQYDQCAJIAZBAnQiAGoiDSAAIBJqKAIAIgw2AgAgDEEYdiITIA1BBGsoAgAiDUEYdkkEQCABIQACfwNAIAAgCWoiFCANNgIAIAkgAEEERg0BGiAAQQRrIQAgEyAUQQhrKAIAIg1BGHZJDQALIAAgCWoLIAw2AgALIAFBBGohASAGQQFqIgYgEUcNAAsLQQEhAEEBcUUNAAsgCkECNgIAIAIgBSAEEPcQCyAKQRBqJAALIBBBIGokAAv4BAIJfwF+IwBBIGsiCiQAIAMoAgAhDiACKAIEIQggCiAAIAIoAgAiDGoiCSACKAIIIgtrIg82AhgCQAJAAkAgDCAOaiIQIARLDQAgACAIIAxqIg1qIAFBIGtLDQAgDUEgaiABIABrTQ0BCyAKQRBqIAJBCGooAgA2AgAgCiACKQIANwMIQbp/IQICQCAKQQhqIgsoAgQiCSALKAIAIgxqIg8gASAAa0sNAEFsIQIgDCAEIAMoAgAiDWtLDQAgACAMaiIIIAsoAggiC2shBCAAIAFBIGsiDiANIAxBABCxFCADIAwgDWo2AgACQAJAIAggBWsgC08EQCAEIQUMAQsgCyAIIAZrSw0CIAcgByAEIAVrIgBqIgEgCWpPBEAgCUUNAiAIIAEgCfwKAAAMAgtBACAAayICBEAgCCABIAL8CgAACyAAIAlqIQkgCCAAayEICyAIIA4gBSAJQQEQsRQLIA8hAgsgAiENDAELIA4pAAAhESAAQQhqIA5BCGopAAA3AAAgACARNwAAIAxBEU8EQCAAQRBqIAMoAgBBEGogDEEQa0EAENEVCyADIBA2AgAgCiAJNgIcAkAgCSAFayALTwRAIA8hBQwBCyAJIAZrIAtJBEBBbCENDAILIAcgByAPIAVrIgBqIgEgCGpPBEAgCEUNAiAJIAEgCPwKAAAMAgtBACAAayICBEAgCSABIAL8CgAACyAKIAU2AhggCiAJIABrIgk2AhwgACAIaiEICyALQRBPBEAgCSAFIAhBABDRFQwBCyAKQRxqIApBGGogCxDFGSAIQQlJDQAgCigCHCAKKAIYIAhBCGtBARDRFQsgCkEgaiQAIA0LoAQBBX8gACAAKAIIIgMgAmoiBDYCCCAAKAIEIgcgBEEIaiIEIAQgB0sbIQUgACgCACEGAkACQAJAAkACQAJAIAEgAk8EQCABIANLDQEgAyABayEAIAQgB08EQCMAQSBrIgQkACAEIAAgACACaiAFQeDy/AAQhyogBSAEKAIEIAQoAgAiAGsiAWsgA08EQCABBEAgAyAGaiAAIAZqIAH8CgAACyAEQSBqJAAMCAsgBEEANgIYIARBATYCDCAEQbCA/QA2AgggBEIENwIQIARBCGpB4PL8ABDvLAALIAMgBmoiBCAAIAZqIgApAAA3AAAgAkEJSQ0GIAAgAmohAEEAIAFrIQEgBEEIaiEDA0AgAyABIANqKQAANwAAIANBCGoiAyABaiAASQ0ACwwGCyABQQFHBEAgBSADayIAQQAgACAFTRshACAGIAFrIQdBACABayEEA0AgAyAEaiAFTw0FIABFDQYgAyAGaiADIAdqLQAAOgAAIANBAWohAyAAQQFrIQAgAkEBayICDQALDAYLIAUgA0EBayIBSwRAIAMgBUsNAiACIAUgA2siAEsNAyACRQ0GIAMgBmogASAGai0AACAC/AsADwsgASAFQfTx/AAQwyEAC0HE8vwAQQlB0PL8ABDLJAALIAMgBUGE8vwAEK87AAsgAiAAQZTy/AAQsDsACyADIAFrIAVBpPL8ABDDIQALIAMgBUG08vwAEMMhAAsLuAMBCX8gASgCBCIIIAEoAgAiBGshBQJAAkAgBCAIRg0AIAFBCGohCSAEIQIDQCABIAJBAWoiBzYCAAJAIAItAAAiA8BBAE4NACABIAJBAmoiBzYCACACLQABQT9xIQYgA0EfcSEKIANB3wFNBEAgCkEGdCAGciEDDAELIAEgAkEDaiIHNgIAIAItAAJBP3EgBkEGdHIhBiADQfABSQRAIAYgCkEMdHIhAwwBCyABIAJBBGoiBzYCACAKQRJ0QYCA8ABxIAItAANBP3EgBkEGdHJyIQMLAkACQAJAAkAgA0EITARAIANFDQEMAwsgA0ENRiADQQlrQQJJckUEQCADQYCAxABHDQMMBgsgByAIQX9zaiICIAVqIgFFBEBBACEFDAcLAkAgASAFTwRAIAINAQwDCyABIARqLAAAQb9/Sg0CCyAEIAVBACABQdSUxAAQozYACyAJKAIAIgJFDQIgAkEHIAEoAgwoAhQRAAAMAgsgASEFDAQLIAkoAgBFDQAgCUHsk8QAIAMgARCQDAsgASgCACICIAEoAgQiCEcNAAsLIARBACAFGyEECyAAIAU2AgQgACAENgIAC+4DAQJ/IwBBEGsiAyQAIAMgACgCDCIAQQhqIAAoAghBAkZBAnRqIgAQiRkCQAJAAkACfwJAIAMtAABBBEcEQCAALQAhQQZHDQEgASgCAEUNBSACKAIARQ0FIAEoAgQgASgCCCACKAIEIAIoAggQlBIMAgsgASgCAEUNBCACKAIARQ0EIAEoAgQgASgCCCACKAIEIAIoAggQlBIMAQsgAyAAEIkZIAMtAABBDUcEQCACKAIAIQACfwJAIAEoAgAEQCAADQFBAQwCC0F/QQAgABsMAQsgASACEMYpCyIAQf8BcUECRyAAwEEASnEMAQsgASgCAEUNAyACKAIARQ0DIAEoAghBAkcNASACKAIIIAIoAgQhAiADIAEoAgQvAAA7AQxBAkcNAiADIAIvAAA7AQ4CfyADQQ5qIQFBACECAkACQCADQQxqLwEAIgBB//8BcUGA+AFLDQAgAS8BACIBQf//AXEiBEGA+AFLDQAgAMFBAEgNASAAIAFLIAHBQQBODQIaIAAgBHJBAEchAgsgAgwBCyABwUEASCAAIAFJcQsLIANBEGokAA8LQcTvzgBBKyADQQ5qQfDvzgBB8ITPABDVHgALQcTvzgBBKyADQQ5qQfDvzgBBgIXPABDVHgALQeSHzgBBIEGEiM4AEMskAAurAwERfyMAQRBrIgMkACAAKALsBSELIAAoAvAFIQwgACgC6AUgACgC5AUhBCAAKALQBSEGIAAoAtQFIQogA0EIaiAAKALQECIBQfAjaigCADYCACADIAEpAugjNwMAIARrQQN1IQggBiAKQQR0aiINIQUDQCAHIAhGRQRAIAVBDGoiDkEANgIAIAVBBGoiDyAEQQRqLwEAIgI2AgAgBUEIaiIQIARBBmovAQAiEUEDajYCACAEKAIAIQEgAiEGAkAgByAAKAKMBkcNAAJAAkAgACgCiAZBAWsOAgABAgsgDyACQYCABHIiBjYCAAwBCyAQIBFBg4AEajYCAAsgBQJ/IAFBA2sgAUEDSw0AGiAOIAE2AgAgBgRAIAFBAnQgA2pBBGsoAgAMAQsgAUEDRgRAIAMoAgBBAWsMAQsgAyABQQJ0aigCAAs2AgAgAyABIAJFEOUcIAVBEGohBSAEQQhqIQQgB0EBaiEHIAYgCWohCQwBCwsgDSAIQQR0aiICIAwgCSALams2AgQgAkIANwIIIAJBADYCACAAIAggCmpBAWo2AtQFIANBEGokAAvgAwIFfwJ+IwBBkAFrIgIkACAAKAIAIgQoAgAhBSACQfAAaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAJwQQFxRQ0AIAIpA4gBIAIpA4ABIgdCgICAgICAgICAf30gB1StfEIAUg0AIAIgBSgCACkDACIINwNAIAIgBzcDOCACQRBqIAcgB0I/hyAIIAhCP4cQqB4gAikDGCACKQMQIgdCP4dSBEAgAkECNgJ0IAJBrJD/ADYCcCACQgI3AnwgAkGGDDYCbCACQYYMNgJkIAIgAkHgAGo2AnggAiACQUBrNgJoIAIgAkE4ajYCYCACQdAAaiAGEJkOIAJBLGogAkHUAGopAgA3AgAgAkE0aiACQdwAaigCADYCACACQYiAgIB4NgJMIAIgAikCTDcCJCACQQE2AiAgAkEgakEEchCIEQwBCyAHIAQoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAHNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC7UDAQR/IwBBMGsiAiQAIAJBCGogARCSBwJAAkACQCACKAIIIgNBCEcEQCAAIAIpAgw3AgQgAEEUaiACQRxqKAIANgIAIABBDGogAkEUaikCADcCACAAIAM2AgAMAQsgARDAKyACQoCAgIAQNwIkIAJBADYCLCABLQAUIQMgAiABKQMANwMIIANBA3YgA0EHcUEAR2oiA0EJTw0BIAFBCGogAkEIaiIEIAMQoTYgAUEAOgAUIAFCADcDACACQSRqIgUgASgCDCABKAIQEKE2IAEtACwhAyACIAEpAxg3AwggA0EDdiADQQdxQQBHaiIDQQlPDQIgAUEgaiAEIAMQoTYgAUEAOgAsIAFCADcDGCAFIAEoAiQgASgCKBChNiABQQA2AiggAUEAOgAUIAFCADcDACABQQA2AhAgAUEANgJcIAFBADYCTCABQQA6ACwgAUIANwMYIAFCADcDMCABQThqQgA3AwAgAkEQaiACQSxqKAIANgIAIAIgAikCJDcDCCAAQQRqIAQQ5xUgAEEINgIACyACQTBqJAAPCyADQQhB6I7OABCwOwALIANBCEHojs4AELA7AAu1AwEEfyMAQTBrIgIkACACQQhqIAEQiwcCQAJAAkAgAigCCCIDQQhHBEAgACACKQIMNwIEIABBFGogAkEcaigCADYCACAAQQxqIAJBFGopAgA3AgAgACADNgIADAELIAEQwCsgAkKAgICAEDcCJCACQQA2AiwgAS0AFCEDIAIgASkDADcDCCADQQN2IANBB3FBAEdqIgNBCU8NASABQQhqIAJBCGoiBCADEKE2IAFBADoAFCABQgA3AwAgAkEkaiIFIAEoAgwgASgCEBChNiABLQAsIQMgAiABKQMYNwMIIANBA3YgA0EHcUEAR2oiA0EJTw0CIAFBIGogBCADEKE2IAFBADoALCABQgA3AxggBSABKAIkIAEoAigQoTYgAUEANgIoIAFBADoAFCABQgA3AwAgAUEANgIQIAFBADYCXCABQQA2AkwgAUEAOgAsIAFCADcDGCABQgA3AzAgAUE4akIANwMAIAJBEGogAkEsaigCADYCACACIAIpAiQ3AwggAEEEaiAEEOcVIABBCDYCAAsgAkEwaiQADwsgA0EIQeiOzgAQsDsACyADQQhB6I7OABCwOwALpQMBBH8jAEFAaiIEJAAgBEEeakIANwEAIARBGGpCADcDACAEQRBqQgA3AwAgBEIANwMIA0AgBCAGakEKaiADIAZqLwEAIAVqQQF0IgU7AQAgBkECaiIGQRxHDQALIAQgAy8BHCAFakEBdCIGOwEmAkACQCADLwEeIAZqQf//A3FBgIACRgRAQQAhBgNAIAEgBk0NAiAAIAZBAnRqIgcvAQIiAwRAIANBEE8NBCAEQQhqIANBAXRqIgUgBS8BACIFQQFqOwEAIAcgBUEIdCAFQQh2ciIFQQR2QY8ecSAFQY8ecUEEdHIiBUECdkGz5gBxIAVBs+YAcUECdHIiBUEBdkHVqgFxIAVB1aoBcUEBdHJBACADa0EPcXY7AQALIAIgBksiAwRAIAMgBmoiBiACTQ0BCwsgBEFAayQADwsgBEEANgI4IARBATYCLCAEQfT3+wA2AiggBEIENwIwIARBKGpB/Pf7ABDvLAALIAYgAUGc9/sAEMMhAAsgBEEANgI4IARBATYCLCAEQcT3+wA2AiggBEIENwIwIARBKGpBzPf7ABDvLAALrQMCBX8CfiMAQSBrIgUkAAJAAkACQAJAAkAgAkHBAEkEQCACQSFPDQEgASgCHCIGIAJqIgIgASgCGCIDQQN0aiABKAIIIgRBA3RLBEBBACEBDAYLAkAgBgRAIAEpAxAhCAwBCyADIARLDQMgAUEIIAQgA2siByAHQQhPGyABKAIEIANqIAcQ2SIiCDcDEAsgASACNgIcIAUgCEJ/Qn8gAq2GQn+FIAJBP0sbgyAGQT9xrYgiCDcDACACQcAASQ0EIAEgAkFAaiICNgIcIAEgA0EIaiIDNgIYIAJFDQQgAyAESw0DIAFBCCAEIANrIgQgBEEITxsgASgCBCADaiAEENkiIgk3AxAgBSAJQn9CfyACrYZCf4UgAkE/SxuDQQAgBmtBP3GthiAIhDcDAAwEC0GYts4AQSBBuLbOABCfKQALQci2zgBBMEH4ts4AEJ8pAAsgAyAEQcS7zgAQrzsACyADIARBxLvOABCvOwALIAVBCGogBUEIEKQYIAUoAghBCEYiAQRAIAUoAgwhAgwBCyAFQQhqEMkjCyAAIAI2AgQgACABNgIAIAVBIGokAAvJAwIFfwJ+IwBBIGsiBSQAAkACQAJAAkACQCACQcEASQRAIAJBCU8NASABKAIcIgYgAmoiAiABKAIYIgRBA3RqIAEoAggiA0EDdEsEQEEAIQEMBgsCQCAGBEAgASkDECEIDAELIAMgBEkNAyABQQggAyAEayIHIAdBCE8bIAEoAgQgBGogBxDZIiIINwMQCyABIAI2AhwgBSAIQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIINwMAIAJBwABJDQQgASACQUBqIgI2AhwgASAEQQhqIgQ2AhggAkUNBCADIARJDQMgAUEIIAMgBGsiAyADQQhPGyABKAIEIARqIAMQ2SIiCTcDECAFIAlCf0J/IAKthkJ/hSACQT9LG4NBACAGa0E/ca2GIAiENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAEIANBxLvOABCvOwALIAQgA0HEu84AEK87AAsjAEHQAGsiASQAIAVBCGoiAyAFLQAAOgAEIANBCDYCACABQdAAaiQAIAUoAghBCEYiAQRAIAUtAAwhAgwBCyAFQQhqEMkjCyAAIAI6AAEgACABOgAAIAVBIGokAAvJAwIFfwJ+IwBBIGsiBSQAAkACQAJAAkACQCACQcEASQRAIAJBEU8NASABKAIcIgYgAmoiAiABKAIYIgRBA3RqIAEoAggiA0EDdEsEQEEAIQEMBgsCQCAGBEAgASkDECEIDAELIAMgBEkNAyABQQggAyAEayIHIAdBCE8bIAEoAgQgBGogBxDZIiIINwMQCyABIAI2AhwgBSAIQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIINwMAIAJBwABJDQQgASACQUBqIgI2AhwgASAEQQhqIgQ2AhggAkUNBCADIARJDQMgAUEIIAMgBGsiAyADQQhPGyABKAIEIARqIAMQ2SIiCTcDECAFIAlCf0J/IAKthkJ/hSACQT9LG4NBACAGa0E/ca2GIAiENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAEIANBxLvOABCvOwALIAQgA0HEu84AEK87AAsjAEHQAGsiASQAIAVBCGoiAyAFLwAAOwEEIANBCDYCACABQdAAaiQAIAUoAghBCEYiAQRAIAUvAQwhAgwBCyAFQQhqEMkjCyAAIAI7AQIgACABOwEAIAVBIGokAAuQAwEEfyAAKAIEIgVBGHZBgAFxIAVBGXZywCAFQf///w9xaiEGAn8CQAJAIAAoAgAiBUEGTwRAIAVBggFJDQEgBUHCEEkNAkEVIAVBwjBJDQMaQRZBFyAFQcKwAUkbDAMLIAUMAgsgBUECayIAZ0EgakE/c0EBayIEQQF0IAAgBHZqQQJqDAELIAVBwgBrZ0EgakE/c0EKagshAAJAAkACfwJAIAZBCk8EQCAGQYYBSQ0BIAZBxgBrZ0EgakE/c0EMaiAGQcYQSQ0CGkEXIQQgAEH//wNxIgBBGE8NBAwDCyAGQQJrDAELIAZBBmsiBCAEZ0EgakE/c0EBayIEdiAEQQF0akEEagsgAEH//wNxIgBBGE8NAUH//wNxIgRBGEkNACAEQRhBvOzRABDDIQALIABBAnQiAEGIn+IAaigCACIHIARBAnQiBEHIoOIAaigCAGogBSAAQaie4gBqKAIAa60gBiAEQeif4gBqKAIAa60gB0E/ca2GhCABIAIgAxDlEg8LIABBGEGs7NEAEMMhAAu3AwMCfwF+A30CfQJAIAJFBEAMAQsgAkEBayABSQRAIAIhByAAIQYDQCAIIAY1AgB8IQggBkEEaiEGIAdBAWsiBw0ACyAIQoACVA0BIAi1EOoSDAILIAEgAUHwoNYAEMMhAAsgCKdBAnRBwIfzAGoqAgALIQoCQCACRSADckUEQCABIAJBAWtNDQEgAiEHIAAhBgNAIAggBigCAEWtfCEIIAZBBGohBiAHQQFrIgcNAAsLAn0gCEKAAloEQCAItRDqEgwBCyAIp0ECdEHAh/MAaioCAAshCSACBEAgCUMAAABAkiELQQAhBgNAAkACQAJAIAEgBkcEQCAAKAIAIgNFBEAgBSAGTQ0CIAQgCzgCAAwECwJ9IANBgAJPBEAgA7MQ6hIMAQsgA0ECdEHAh/MAaioCAAshCSAFIAZNDQIgBCAKIAmTIgk4AgAgCUMAAIA/XUUNAyAEQYCAgPwDNgIADAMLIAEgAUHAoNYAEMMhAAsgBiAFQdCg1gAQwyEACyAGIAVB4KDWABDDIQALIABBBGohACAEQQRqIQQgAiAGQQFqIgZHDQALCw8LIAEgAUGwoNYAEMMhAAu9AwEFfyMAQUBqIgAkAAJAAkBB3O6KAS0AAEECRgRAQeDuigEoAgAhAUHg7ooBQQA2AgAgAUUNASAAQShqIAERAwAgAEEgaiICIABBOGooAgA2AgAgAEEYaiIDIABBMGopAgA3AwAgAEEOaiIEIABBP2otAAA6AAAgACAAKQIoNwMQIAAgAC8APTsBDCAALQA8IQECQEHc7ooBLQAAQQJGBEBByO6KASAAKQMQNwIAQdzuigEgAToAAEHd7ooBIAAvAQw7AABB2O6KASACKAIANgIAQdDuigEgAykDADcCAEHf7ooBIAQtAAA6AAAMAQsgAUECRw0DCyAAQQI6ADwgAEEoahD1JQsgAEFAayQADwsgAEEANgI4IABBATYCLCAAQYiqiAE2AiggAEIENwIwIABBKGpBkKqIARDvLAALIABBP2ogAEEOai0AADoAACAAQTBqIABBGGopAwA3AwAgAEE4aiAAQSBqKAIANgIAIAAgAC8BDDsAPSAAIAApAxA3AyggACABOgA8IABBKGoiARD1JSAAQQA2AjggAEEBNgIsIABBsKqIATYCKCAAQgQ3AjAgAUG4qogBEO8sAAv7AgELfwJAIAQEQAJAIAMoAgBBAUcNACADKAIEIg1Bf0cNACAGKAIAIQ4MAgsgB0EEaiESIAYoAgAhDiAKKAIAIRBBACEHA0ACQAJAIAQgDSAPaiILSwRAQQAhDSADIAtBFGxqIgsoAgBBAUYEQCALKAIEIQ0LIAcgCUYNASAIIBIgCygCECIMQf///z9xIhNBACAOIAcbaiIUIAsoAggiFUH///8PcSIRIBEgFUEZdmtBCWogCygCDCILQQ9qIAxBG3ZBAWsgDEGAgIDAAEkbIgwQgA0gDEUgCyACIA8gE2oiDyABaiIMIAIgDEkbS3INAiAFIAUoAgg2AgwgBSAFKQIANwIEIAUgCzYCAAwCCyALIARBkJ/WABDDIQALIAkgCUGgn9YAEMMhAAsgDkEAIAcbIQ4gCiAQIBRqIhA2AgAgCEEQaiEIIAdBAWohByAPIBFqIQ8gDUF/Rw0ACwwBC0EAQQBBgJ/WABDDIQALIAYgACAOaiAPazYCAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+QkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCcGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEGkn8QANgIIIAhCBDcCECAIQQhqQayfxAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCWDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFBvJ/EABCvOwALIAAgASACIAMQyQoLIAhBIGokAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+AkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCcGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEGkn8QANgIIIAhCBDcCECAIQQhqQayfxAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCXDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFBvJ/EABCvOwALIAAgASACIAMQyQoLIAhBIGokAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+wkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCdGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEHg0swANgIIIAhCBDcCECAIQQhqQejSzAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCYDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFB+NLMABCvOwALIAAgASACIAMQyQoLIAhBIGokAAu5AwICfwF+IwBBgAFrIgUkAAJAAkACQCABKAIIBEAgBUEANgI4IAVCADcDMCAFQgA3AwAgBSABKAIELQAAOgA8IAVBQGsgAUEBEOoUIAVB2ABqQgA3AwAgBUHQAGpCADcDACAFQSBqQgA3AwAgBUEoakIANwMAIAVBGGogBUHIAGopAwA3AwAgBSAFKQNAIgc3AxAgB6dFDQEgBUHgAGogBUEQaiIGEKUYAkAgBSgCYEEBRw0AIAUpA2giB1ANACAHQgGDUEUEQCAFIAenQQJ0QXhxNgI4DAELIAUgB0IBiD4CNCAFQfAAaiAGIAUtADwiBkEDdiAGQQdxQQBHahDBHCAFIAUpA3g3AwggBSAFKQNwIgc3AwAgB6dFDQMLQYAgQQQQrTYiBkUNAyAGQQBBgCD8CwAgACAFQcAA/AoAACAAIAQgAiADQQFxGzYCTCAAQgA3AkQgACAGNgJAIAFBDGogASgCBCABKAIIIAEoAgAoAhARAQAgBUGAAWokAA8LQQBBAEG8iM4AEMMhAAtB+KLOAEEYQZCjzgAQyyQAC0Ggo84AQS5B0KPOABCfKQALQQRBgCAQoz0AC7wDAQF/IwBBMGsiBiQAAkACQAJAAkAgAAJ/AkAgAkEBcUUgAyAFT3INAAJAIAEQ3yRFBEAgAyAFSw0EIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEMaiAGKAIcIAYoAiAgAxCSFCAGKAIMIQILIAJBgICAgHhGDQAgACAGKQIQNwIEIAAgAjYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVBqIHPABCwOwALIAMgBUG4gc8AELA7AAsgASAGKAIsQcD1zgAQ/S8ACyACIAYoAixBwPXOABD9LwALvAMBAX8jAEEwayIGJAACQAJAAkACQCAAAn8CQCACQQFxRSADIAVPcg0AAkAgARDgJEUEQCADIAVLDQQgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEYaiAEIAUQnQkgBigCGEEBRgRAIAMgBUsNBSAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQQxqIAYoAhwgBigCICADEJIUIAYoAgwhAgsgAkGAgICAeEYNACAAIAYpAhA3AgQgACACNgIAQQEMAQsgBkEkaiAFQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQMgBigCLCECIAUEQCACIAQgBfwKAAALIAAgBTYCCCAAIAI2AgQgACABNgIAQQALOgAMIAZBMGokAA8LIAMgBUGogc8AELA7AAsgAyAFQbiBzwAQsDsACyABIAYoAixBwPXOABD9LwALIAIgBigCLEHA9c4AEP0vAAu8AwEBfyMAQTBrIgYkAAJAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN0kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQRhqIAQgBRCdCSAGKAIYQQFGBEAgAyAFSw0FIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBDGogBigCHCAGKAIgIAMQkhQgBigCDCECCyACQYCAgIB4Rg0AIAAgBikCEDcCBCAAIAI2AgBBAQwBCyAGQSRqIAVBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNAyAGKAIsIQIgBQRAIAIgBCAF/AoAAAsgACAFNgIIIAAgAjYCBCAAIAE2AgBBAAs6AAwgBkEwaiQADwsgAyAFQaiBzwAQsDsACyADIAVBuIHPABCwOwALIAEgBigCLEHA9c4AEP0vAAsgAiAGKAIsQcD1zgAQ/S8AC7wDAQF/IwBBMGsiBiQAAkACQAJAAkAgAAJ/AkAgAkEBcUUgAyAFT3INAAJAIAEQ3iRFBEAgAyAFSw0EIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEMaiAGKAIcIAYoAiAgAxCSFCAGKAIMIQILIAJBgICAgHhGDQAgACAGKQIQNwIEIAAgAjYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVBqIHPABCwOwALIAMgBUG4gc8AELA7AAsgASAGKAIsQcD1zgAQ/S8ACyACIAYoAixBwPXOABD9LwALvAMBAX8jAEEwayIGJAACQAJAAkACQCAAAn8CQCACQQFxRSADIAVPcg0AAkAgARDcJEUEQCADIAVLDQQgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEYaiAEIAUQnQkgBigCGEEBRgRAIAMgBUsNBSAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQQxqIAYoAhwgBigCICADEJIUIAYoAgwhAgsgAkGAgICAeEYNACAAIAYpAhA3AgQgACACNgIAQQEMAQsgBkEkaiAFQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQMgBigCLCECIAUEQCACIAQgBfwKAAALIAAgBTYCCCAAIAI2AgQgACABNgIAQQALOgAMIAZBMGokAA8LIAMgBUGogc8AELA7AAsgAyAFQbiBzwAQsDsACyABIAYoAixBwPXOABD9LwALIAIgBigCLEHA9c4AEP0vAAu8AwEBfyMAQTBrIgYkAAJAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOEkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQRhqIAQgBRCdCSAGKAIYQQFGBEAgAyAFSw0FIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBDGogBigCHCAGKAIgIAMQkhQgBigCDCECCyACQYCAgIB4Rg0AIAAgBikCEDcCBCAAIAI2AgBBAQwBCyAGQSRqIAVBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNAyAGKAIsIQIgBQRAIAIgBCAF/AoAAAsgACAFNgIIIAAgAjYCBCAAIAE2AgBBAAs6AAwgBkEwaiQADwsgAyAFQaiBzwAQsDsACyADIAVBuIHPABCwOwALIAEgBigCLEHA9c4AEP0vAAsgAiAGKAIsQcD1zgAQ/S8AC5oDAQh/IAMoAlwgCUECdGohCiADKAIAIgsgCCADKAIEIgxqayEIQQAhCQNAIAlBDEZFBEAgCUEEaiEJDAELC0EDIAIgAkEDTxshCSAEQQRqIQ0gByAIakEDaiEOIAMoAmQiDyAKQQxqKAIAIhBBCHYiEUECdGohCAJAAkADQCAJBEAgCigCACIDRQ0CAkAgAyAMaiIHKAAAIAQoAABHDQAgDSAHQQRqIAUgCyAGEM0oQQRqIgcgAU0NACAAIA4gA2s2AgAgByEBIAQgB2ogBUYNBAsgCkEEaiEKIAlBAWshCSACQQFrIQIMAQsLIAIgEEH/AXEiAyACIANJIgcbIQkDQCAJBEAgCEEEaiEIIAlBAWshCQwBBSACIAMgBxshCSAPIBFBAnRqIQoDQCAJRQ0DAkAgDCAKKAIAIgJqIgMoAAAgBCgAAEcNACANIANBBGogBSALIAYQzShBBGoiByABTQ0AIAAgDiACazYCACAHIQEgBCAHaiAFRg0FCyAJQQFrIQkgCkEEaiEKDAALAAsACwALIAEhBwsgBwvyAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJBAnRqKAIAEJQvIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC/IDAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAkEDdGopAwAQsy4gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAAL8gMCA38IfiMAQcABayIDJAAgASgCCCEFIANBQGsgASgCDCgCECACQQJ0aigCABDJLSADKQNAIQkgAykDSCEKIAMpA1AhCyADKQNYIQwgBSgCACIEKQMAIQYgBCkDCCEHIAQpAxAhCCADIAQpAxgiDTcDOCADIAg3AzAgAyAHNwMoIAMgBjcDICADIAw3AxggAyALNwMQIAMgCjcDCCADIAk3AwACQAJAAkAgBiAIhCAHIA2EhFAEQEGHgICAeCEEDAELIANBQGsiBCAJIAogCyAMIAYgByAIIA0QmgggAy0AQEEBRgRAIANBAjYCRCADQZiQ/wA2AkAgA0ICNwJMIANBgww2ArwBIANBgww2ArQBIAMgA0GwAWo2AkggAyADQSBqNgK4ASADIAM2ArABIANBoAFqIAQQmQ4gAykCoAEhByADKQKoASEGQYiAgIB4IQQMAQsgA0FAayADKQNQIgYgAykDWCIHIAMpA2AiCCADKQNoIgkgBSgCBC0AABDQDiADKAJAIgRBk4CAgHhGDQEgAykCTCEGIAMpAkQhBwsgACAGNwIMIAAgBzcCBCAAIAQ2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvyAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJBAXRqLwEAELUuIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC/IDAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAkEBdGovAQAQky0gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAAL8gMCA38IfiMAQcABayIDJAAgASgCCCEFIANBQGsgASgCDCgCECACQQN0aikDABDOLyADKQNAIQkgAykDSCEKIAMpA1AhCyADKQNYIQwgBSgCACIEKQMAIQYgBCkDCCEHIAQpAxAhCCADIAQpAxgiDTcDOCADIAg3AzAgAyAHNwMoIAMgBjcDICADIAw3AxggAyALNwMQIAMgCjcDCCADIAk3AwACQAJAAkAgBiAIhCAHIA2EhFAEQEGHgICAeCEEDAELIANBQGsiBCAJIAogCyAMIAYgByAIIA0QmgggAy0AQEEBRgRAIANBAjYCRCADQZiQ/wA2AkAgA0ICNwJMIANBgww2ArwBIANBgww2ArQBIAMgA0GwAWo2AkggAyADQSBqNgK4ASADIAM2ArABIANBoAFqIAQQmQ4gAykCoAEhByADKQKoASEGQYiAgIB4IQQMAQsgA0FAayADKQNQIgYgAykDWCIHIAMpA2AiCCADKQNoIgkgBSgCBC0AABDQDiADKAJAIgRBk4CAgHhGDQEgAykCTCEGIAMpAkQhBwsgACAGNwIMIAAgBzcCBCAAIAQ2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEI8cIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQZSvgAEoAgA2AgAgAkGMr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEI8cIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQZSvgAEoAgA2AgAgAkGMr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvmAQEEfyMAQTBrIgMkACADQQI6ABcgA0EYaiIEIAJBA3YgAkEHcUEAR2oiAkHAACABrcN5p2siAUH/AXEiBUEDdiABQQdxQQBHakEBamwiBiAFQQFqIAJsIgIgAiAGSRtBAEEBQQEQoBggAygCHCECIAMoAhhBAUcEQCADQQA2AhAgAyADKAIgNgIMIAMgAjYCCCADQQhqQai3zgBBBBChNiADQSBqIANBEGooAgA2AgAgAyADKQIINwMYIABBCGogASAEEJwfIABBADoAACADQTBqJAAPCyACIAMoAiBB5MPOABD9LwAL0wMCAn8BfSMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfQJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQwAAAAAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAkE4aiABIAQQwQEgAigCOEExRw0BIAIqAjwLIQZBAQwBCyACQdgAakGLlqzYADYCACACQouWrNiw4cKFCzcDUCACQQM2AjwgAkHEroABNgI4IAJCAjcCRCACQa4QNgJsIAJBzAE2AmQgAiACQeAAajYCQCACIAJB0ABqIgE2AmggAiACQRxqNgJgIAJBKGogAkE4ahCZDiABEKoMIAJBGGoiASACQTRqKAIANgIAIAIgAikCLDcDECACKgIoIQYgAygCAEGTgICAeEcEQCADEIgRCyADIAY4AgQgA0GCgICAeDYCACADIAIpAxA3AgggA0EQaiABKAIANgIAQQALIQEgACAGOAIEIAAgATYCACACQfAAaiQADwtB9KeAAUEgQZSogAEQnykAC88DAQJ/IwBB8ABrIgIkAAJAAkAgASgCHCIEIAEoAiBGBEBBAiEBDAELAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQjxwgAigCAEEBcUUNASACKAIECyEEQQEhAQwBC0EAIQEgAkHYAGpBlK+AASgCADYCACACQYyvgAEpAgA3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIENgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gBBCqDCACQRhqIgQgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEFIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAFNgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogBCgCADYCAAsgACAENgIEIAAgATYCACACQfAAaiQADwtB9KeAAUEgQZSogAEQnykAC9MDAgJ/AX0jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn0CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEMAAAAADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAJBOGogASAEEMEBIAIoAjhBMUcNASACKgI8CyEGQQEMAQsgAkHYAGpBi5as2AA2AgAgAkKLlqzYsOHChQs3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAioCKCEGIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAGOAIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBjgCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvPAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAuFBAIHfwJ+IwBBwAFrIgQkAEIDIQsgAS0ACSEGIAEtAAghBQJAIAEpAwAiDEIDUQ0AIAQgBjoASSAEIAU6AEggBCAMNwNAIARBygBqIgggAUEKakE+/AoAACAEIAIoAgQgAigCCBDICgJAIAQoAgBBAUYEQEEEIQUMAQsgBEGQAWoiCSAEQQxqKQIANwMAIAQgBCkCBDcDiAEgAygCBCECIAMoAgghA0EAIQECQANAIAEgA0cEQCABIAJqLQAAIgVBH0sgBUH/AEdxIQogAUEBaiEBQQIhByAFQQlGIApyDQEMAgsLIAQgAiADEPweQQAhBwsgBCAHOgAQIAQtABAiAUECRgRAQQUhBSAEKAKIASIBRQ0BIARBlAFqIAQoAowBIAQoApABIAEoAhARAQAMAQsgBEG0AWogBEEIaiIGKQEANwEAIARBvwFqIARBE2otAAA6AAAgBCAEKQECNwGuASAEIAQvABE7AL0BIAQgAToAvAEgBCAELwEAOwGsASAGIAkpAwA3AwAgBCAEKQOIATcDAEEGIQUgBEFAayAEIARBrAFqEJIDQf8BcUECRg0AIAQtAEkhBiAELQBIIQUgBCkDQCELIAQgCEE+/AoAAAwBCyAEQUBrELwuCyAAIAY6AAkgACAFOgAIIAAgCzcDACAAQQpqIARBPvwKAAAgBEHAAWokAAuRAwIGfwF+IAYEQANAAkACQAJAAkAgBSAURwRAIAQgFEEEdGoiEi8BDCITQcAFTw0BIBNBwAVPDQIgEi8BDiEWIBI1AgghGCASKAIEIRcgEigCACEVIAkgE2otAAAgCiATQQF0ajMBACAPIBAgERDlEiASIA8gECAREJINIBVFDQQDQCACIANxIhIgAU8NBCAAIBJqLQAAIRIgByASai0AACAIIBJBAXRqMwEAIA8gECAREOUSIAJBAWohAiAVQQFrIhUNAAsMBAsgBSAFQfzs0QAQwyEACyATQcAFQYzt0QAQwyEACyATQcAFQZzt0QAQwyEACyASIAFBzO3RABDDIQALAkAgF0H///8PcSISRSATQf8ATXINACAWQf8HcSITIAxJBEAgDiATSwRAIAsgE2otAAAgDSATQQF0ajMBACAPIBAgERDlEiAWQYD4A3FBCnYgGCAPIBAgERDlEgwCCyATIA5BvO3RABDDIQALIBMgDEGs7dEAEMMhAAsgAiASaiECIBRBAWoiFCAGRw0ACwsLtAQBB38jAEHQAGsiBSQAIABBCCAAKAI0IgMgA0EITRs2AjQgAEEwaiEGIAJBA3QhAwJAQQAgACgCMCIHa0EHcSIEIAAoAgggB2tNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAGIAQQjTcgA0EEciIEIAAoAgggACgCMGsiB00gBCAHTXJFBEADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAYgAxCNNyAFQRBqIAAQ3DsgBUEIaiAFKAIQIAUoAhQgACgCMCIEIAQgA2tB1Mb+ABDXJiAFKAIMIQMgBSgCCCEEIAVBCDYCTCAFIAQ2AkQgBSADQQdxNgJAIAUgA0F4cSIDNgJIIAUgAyAEajYCPCAFQRhqIQMjAEEQayIEJAAgBCABIAJBA3RqIgg2AgwgBCABNgIIIARBCGoQmDYhByAFQTxqIgYoAhAiCUUEQEHk9P4AEOIrAAsgA0EANgIcIAMgCDYCBCADIAE2AgAgAyAGKQIANwIIIANBEGogBkEIaikCADcCACADQRhqIAZBEGooAgA2AgAgAyAGKAIMIAluIgEgByABIAdJGzYCICAEQRBqJAAgBSgCOCIBIAUoAjQiA0sEQCABIANrIQEgBSgCGCADQQN0aiEEIAUoAiggAyAFKAIwIgZsaiEDA0AgAyAEKQMANwAAIARBCGohBCADIAZqIQMgAUEBayIBDQALCyAAIAIQqhEgBUHQAGokAAvvAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJqLQAAELQuIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC+8DAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAmotAAAQki0gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAALywMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEENorIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvQAwICfwF9IwBB8ABrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ9AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxDAAAAAAwBCyABIARBAWo2AhwgAkEIaiABIAQQrSogAigCCCEBIAIgAigCDCIENgIgIAIgATYCHCACQThqIAEgBBDBASACKAI4QTFHDQEgAioCPAshBkEBDAELIAJB2ABqQYuWrNgANgIAIAJCi5as2LDhwoULNwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiATYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAEQqgwgAkEYaiIBIAJBNGooAgA2AgAgAiACKQIsNwMQIAIqAighBiADKAIAQZOAgIB4RwRAIAMQiBELIAMgBjgCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAEoAgA2AgBBAAshASAAIAY4AgQgACABNgIAIAJB8ABqJAAPC0H0p4ABQSBBlKiAARCfKQALzAMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEENgmIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQY6cuPAANgIAIAJCjpy48ODBg4cONwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiATYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAEQqgwgAkEYaiIBIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBCADKAIAQZOAgIB4RwRAIAMQiBELIAMgBDYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAEoAgA2AgBBAAshASAAIAQ2AgQgACABNgIAIAJB8ABqJAAPC0H0p4ABQSBBlKiAARCfKQALywMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ2CYgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBjpy48AA2AgAgAkKOnLjw4MGDhw43A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvXAwIFfwF+IwBBIGsiBiQAAkACQAJAAkACQAJAAn8gASgCCEGAgICAeEYEQCABKAIAIQUgASgCBAwBCyABKAIwIQUgASkDICIKpyIHIAEoAgAiCE8EQCAEIAdqIAEoAhAiCSAIak0NAgsgBiABKAIYIApC/////w+DIAQgBSAEIAVLGyABKAIcKAIUESUAIAYoAgQhByAGKAIAIQhBCEEEEK02IgVFDQMgBSAINgIAIAUgBzYCBCABELcuIAFBgICAgHg2AgggAUH4qogBNgIEIAEgBTYCAEH4qogBCyEHIAZBCGogBSACIAcoAgwRAQAgBigCECIFQYGAgIB4Rw0BIABBBToAAAwFCyAHIAhrIgIgBGoiBSACSQ0CIAUgCUsNAyAEBEAgAyABKAIMIAJqIAT8CgAACyAAIAQ2AgQgAEEEOgAAIAEgCiAErXw3AyAMBAsgBikDCCEKIAVBgICAgHhGBEAgACAKNwIADAQLIAEQty4gASAFNgIIIAEgCjcDACABIAYpAhQ3AgwgAUEUaiAGQRxqKAIANgIAIAAgASACIAMgBBC8DQwDC0EEQQgQoz0ACyACIAVBiKuIARCxOwALIAUgCUGIq4gBELA7AAsgBkEgaiQAC5gDAgV/AX4jAEEQayIDJAAgACgCbEEBdCIBrSEGAkAgAUGAAUkNACAAQQhqIQEDQAJAIAMgBqdBgAFyOgAAIAAtABQhAiADIAApAwA3AwggAkEDdiACQQdxQQBHaiICQQlPDQAgASADQQhqIAIQoTYgAEEAOgAUIABCADcDACABIANBARChNiAGQoCAAVQgBkIHiCEGRQ0BDAILCyACQQhBuPXMABCwOwALIAMgBjwAACAALQAUIQEgAyAAKQMANwMIIAFBA3YgAUEHcUEAR2oiAkEJTwRAIAJBCEG49cwAELA7AAsgAEEIaiIBIANBCGoiBSACEKE2IABBADoAFCAAQgA3AwAgASADQQEQoTYgAC0AdCECIAMgACkDWDcDACAALQAUIQQgAyAAKQMANwMIIARBA3YgBEEHcUEAR2oiBEEJSQRAIAEgBSAEEKE2IABBADoAFCAAQgA3AwAgASADQQggAkEDdiACQQdxQQBHaiIBIAFBCE8bEKE2IABCADcDaCADQRBqJAAPCyAEQQhBuPXMABCwOwALxQMBA38jAEEwayIHJAACQAJAIAMgBE8EQAJAIARFBEAgASgCAEUNASAAIAEgAiABKAIwIgIgAyACIANJG0EBEKELIgI2AgQgAEEINgIAIAEgASgCMCACazYCMAwECyAHIAMgBGsiBDYCACABKAIABEAgASACIAEoAjAiCCADIAMgCEsbQQEQoQshCCABIAEoAjAgCGs2AjAgByAINgIEIAQgCEcNAyADQQFrIQEDQAJAAkAgBiABQQN2IghLBEAgAUEHcUH8xM4Aai0AACAFIAhqLQAAcUUNAiAEQQFrIgQgA08NASABIAJqIggtAAAhCSAIIAIgBGoiCC0AADoAACAIIAk6AAAMAgsgCCAGQcSIzQAQwyEACyAEIANBpKDNABDDIQALIAFBAWsiAUF/Rw0ACyAAQQg2AgAgACADNgIEDAQLQYT+zAAQsjsAC0GE/swAELI7AAtB6J/NAEEsQZSgzQAQnykACyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgALIAdBMGokAAumAwEBfyMAQSBrIgEkAAJAAkACQAJAAkAgBUEBcQRAIAQgBCgCCCIFIAZqEI4tIAQoAggiByAFSQ0CIAQoAgQhBCABQQA2AhwgASAHIAVrNgIYIAEgBCAFajYCFCABQQhqIAIgAyABQRRqEIQEIAEoAghBBEYNAUEMQQQQrTYiAkUNAyACIAEpAgg3AgAgAEGM2tAANgIIIAAgAjYCBCAAQQU2AgAgAkEIaiABQRBqKAIANgIADAQLIAFBFGpBL0EAQQFBARCgGCABKAIYIQIgASgCFEEBRg0EIAEoAhwiA0H42NAAQS/8CgAAIABBLzYCDCAAIAM2AgggACACNgIEIABBADYCAAwDCyAGIAEoAgxGBEAgAEEINgIAIAAgBjYCBAwDCyABQRRqQTNBAEEBQQEQoBggASgCGCECIAEoAhRBAUYNAyABKAIcIgNByNnQAEEz/AoAACAAQTM2AgwgACADNgIIIAAgAjYCBCAAQQA2AgAMAgsgBSAHQbjZ0AAQrzsAC0EEQQwQoz0ACyABQSBqJAAPCyACIAEoAhxBpMbQABD9LwALtQMCBH8BfSMAQdAAayIDJAAgAyABKAIMKAIQIAJBAXRqLwEAIgQ7AQIgAAJ/An8gBEEQdCAEQf//AXFFDQAaIARB/wdxIQUgBEGAgAJxIQYgBEGA+AFxIgRBgPgBRgRAIAZBEHQhBCAEQYCAgPwHciAFRQ0BGiAEIAVBDXRyQYCAgP4HcgwBCyAGQRB0IQYgBEENdEGAgID8AHEgBUENdHJBgICAwANqIAZyIAQNABogBSAFZ0EQayIEQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIARBF3Rrcgu+IgdDAACAv14gB0MAAIBPXXFFBEAgA0E4akGIkKDAADYCACADQoiQoMCAgYKECDcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAgw3AgggAEEQaiADQRRqKAIANgIAIAAgAygCCDYCBEGCgICAeAwBCyABKAIAIAJBAnRqIAepNgIAQZOAgIB4CzYCACADQdAAaiQAC7UDAgR/AX0jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwABAMdeIAdDAAAAR11xRQRAIANBOGpBg4aMGDYCACADQoOGjJiw4MCBAzcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAQo3AQYgAEEMaiADQRBqKQEANwEAIAAgAy8BCDsBBEGCgICAeAwBCyABKAIAIAJBAXRqIAf8ADsBAEGTgICAeAs2AgAgA0HQAGokAAu0AwIEfwF9IwBB0ABrIgMkACADIAEoAgwoAhAgAkEBdGovAQAiBDsBAiAAAn8CfyAEQRB0IARB//8BcUUNABogBEH/B3EhBSAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCEEIARBgICA/AdyIAVFDQEaIAQgBUENdHJBgICA/gdyDAELIAZBEHQhBiAEQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogBnIgBA0AGiAFIAVnQRBrIgRB//8DcUEIanRB////A3EgBkGAgIDYA3IgBEEXdGtyC74iB0MAAADPYCAHQwAAAE9dcUUEQCADQThqQYSIkCA2AgAgA0KEiJCgwICBggQ3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgACADKQIMNwIIIABBEGogA0EUaigCADYCACAAIAMoAgg2AgRBgoCAgHgMAQsgASgCACACQQJ0aiAHqDYCAEGTgICAeAs2AgAgA0HQAGokAAu1AwIEfwF9IwBB0ABrIgMkACADIAEoAgwoAhAgAkEBdGovAQAiBDsBAiAAAn8CfyAEQRB0IARB//8BcUUNABogBEH/B3EhBSAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCEEIARBgICA/AdyIAVFDQEaIAQgBUENdHJBgICA/gdyDAELIAZBEHQhBiAEQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogBnIgBA0AGiAFIAVnQRBrIgRB//8DcUEIanRB////A3EgBkGAgIDYA3IgBEEXdGtyC74iB0MAAIC/XiAHQwAAgEddcUUEQCADQThqQYeOnDg2AgAgA0KHjpy48ODBgwc3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgACADKQEKNwEGIABBDGogA0EQaikBADcBACAAIAMvAQg7AQRBgoCAgHgMAQsgASgCACACQQF0aiAH/AE7AQBBk4CAgHgLNgIAIANB0ABqJAALyAMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvJAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ2CYgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBjpy48AA2AgAgAkKOnLjw4MGDhw43A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvJAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvWAwEBfyMAQaAQayIEJAAgBCACNgIIIAQgATYCBAJAAkACQCAAAn8CQAJAAkACQAJAAkACQAJAIAFBAWsOBwECBwMEBQYACyAAQQA2AgRBCAwHCyAEQQxqIgIiAUEMakEAQYAQ/AsAIAFBADYCCCABQoCAgIAgNwIAQYwQQQQQrTYiAUUNByABIAJBjBD8CgAAIABBoOjQADYCCCAAIAE2AgRBCAwGC0EEQQQQrTYiAUUNCCAAQbTo0AA2AgggACABNgIEIAEgAjYCAEEIDAULQQRBBBCtNiIBRQ0HIABByOjQADYCCCAAIAE2AgQgASACNgIAQQgMBAsgAy0AACECQQFBARCtNiIBRQ0FIABB3OjQADYCCCAAIAE2AgQgASACOgAAQQgMAwtBBEEEEK02IgFFDQUgAEHw6NAANgIIIAAgATYCBCABIAI2AgBBCAwCCyAAQYTp0AA2AgggAEEBNgIEQQgMAQsgBEECNgIQIARBvOnQADYCDCAEQgE3AhggBEGQCjYCnBAgBCAEQZgQajYCFCAEIARBBGo2ApgQIABBBGogBEEMahCZDkEBCzYCACAEQaAQaiQADwtBBEGMEBCjPQALQQFBARCjPQALQQRBBBCjPQALlQMCBn8BfgJAIAIgAWsiA0EISARAIANBACADQQBKG0EBaiEGIAAgAUEDdGoiASEAQQEhAwNAIAMgBkYNAiABIANBA3RqIgIoAgQhByACKAIAIQIgACEFIAMhBANAAkAgBEEATARAQQAhBAwBCyAFKAIAIAJPDQAgBUEIaiAFKQIANwIAIARBAWshBCAFQQhrIQUMAQsLIAEgBEEDdGoiBCAHNgIEIAQgAjYCACAAQQhqIQAgA0EBaiEDDAALAAsDQCAAIAJBA3RqIQYDQCABIAJODQIgAUEBayEDIAAgAUEDdGohBSAGKAIAIQcgAiEEA0AgASAERwRAIAcgBSgCAEkEQCAAIANBAWoiA0EDdGoiCCkCACEJIAggBSkCADcCACAFIAk3AgALIARBAWshBCAFQQhqIQUMAQsLIAAgA0EBaiIEQQN0aiIFKQIAIQkgBSAGKQIANwIAIAYgCTcCACAEIAFrIAIgBGtIBEAgACABIAMQyA0gA0ECaiEBDAELCyAAIANBAmogAhDIDSADIQIMAAsACwvtAwIDfwR+IwBBwAFrIgMkACADQRBqIAEoAggiBSgCACABKAIMKAIQIAJBBXRqIgQpAwAiBiAEKQMIIgcgBCkDECIIIAQpAxgiCRDtCQJAAkACfiADKAIQQQFxRQRAIAUoAgQhASADIAk3A3ggAyAINwNwIAMgBzcDaCADIAY3A2AgA0HMkf8ANgKIASADQgQ3ApQBIANBgww2ArwBIANB9As2ArQBIANBuwc2AqwBIANBzAE2AqQBIANBjJL/ADYCoAEgAyABNgKoASADIAFBAWo2ArABIAMgA0GgAWo2ApABIAMgA0HgAGo2ArgBIANBBDYCjAEgA0HQAGogA0GIAWoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIGIAMpAygiByADKQMwIgggAykDOCIJIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQYgACADKQMANwIAIAAgBjcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvZAwIHfwF+IwBBoANrIgIkACABKAIQIQMgAkEUaiIFIAFBFGoQ9BIgAkEAOwG8AiACQQA2ArgCIAJBADYCoAIgAkEANgKUAiACIAM2ApACIAJBAToAhAIgAkIENwL8ASACQgA3AvQBIAJCgICAgMAANwLsASACQQA2AuQBAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhCSABQsAANwIAIAEoAhAhBiABKAIMIQQgAUIANwIMIAIgCTcClAEgAkEANgKQASACIAQ2AowBIAIgAzYCiAEgAkEIaiACQYgBaiIDENc7IAIoAgghB0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCiAE3AgggAUEQaiACQZABaiIIKQIANwIAIAFBGGogAkGYAWooAgA2AgAgAiAENgKcAyACIAc2ApgDIAIgATYClAMgAyACQZQDakEAIAYQ8hUgAkHIAmogCCgCADYCACACIAIpAogBNwPAAiADIAJB5AFqIAJBwAJqEPojIAJBLGoiASADIAUQwhkgAkHQAmoiAyABEM0cIAAgAxDRECACQaADaiQADwtB9OmFAUEpIAJBiAFqQeDqhQFBoOqFARDVHgALQQRBHBCjPQALzQUBCn8jAEEwayICJAACfyAAKAIAIgEEQCAAKAIEIQMgACgCDCEGQQAMAQtBAQshBANAAkACQAJAIARFBEAgAyAGRw0BIAIgATYCICACIAAoAgg2AhwgAkEcakEEQQQQ4B4gAEEANgIAQQEhBAwECwJAIAAoAiAiAUUNACABIAAoAiRGDQAgACABQQRqNgIgIAEoAgAhAyACIAAoAigpAwA3AxAgAkEcaiIBIANBCGoQgxUgAigCHCEEIAIgAigCICIDIAIoAiRBAnRqNgIoIAIgBDYCJCACIAM2AiAgAiADNgIcIAIgAkEQajYCLCMAQRBrIgMkACABKAIIIQkgASgCACIGIQQgAUEQaiEHIAEoAgwaIAEoAgQiBSABKAIMIghHBEAgBygCACEKA0AgBSgCACEHIAEgBUEEaiIFNgIEAkAgBykDICAKKQMAUg0AIActAChBIkcNACAEIAc2AgAgBEEEaiEEIAEoAgQhBSABKAIMIQgLIAUgCEcNAAsLIAMgBDYCBCADIAY2AgAgAygCBCEEIAFBADYCCCABQQQ2AgAgA0KAgICAwAA3AgggA0EIaiIFQQRBBBDgHiABQQQ2AgwgAUEENgIEIAJBBGoiASAEIAZrQQJ2NgIIIAEgBjYCBCABIAk2AgAgA0KAgICAwAA3AgggBUEEQQQQ4B4gA0EQaiQAIAIoAgQiAUGAgICAeEYNACAAIAE2AgggACACKAIIIgE2AgQgACABNgIAIAAgASACKAIMQQJ0aiIGNgIMIAEhAwwCCyAAKAIQIgNFBEBBACEBDAMLIAAoAhQiASAAKAIcRwRAIAAgAUEEajYCFCABKAIAIQEMAwsgAiADNgIgIAIgACgCGDYCHCACQRxqQQRBBBDgHkEAIQEgAEEANgIQDAILIAAgA0EEajYCBCADKAIAIQEMAQtBACEEDAELCyACQTBqJAAgAQuVAwEDfwJAAkACQAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9IAhCAYZacUUEQCAGIAhWDQEMCAsgAiADSQ0DDAYLIAcgBiAIfSIGfSAGVg0GIAIgA0kNAyABIANqIQsCQAJAA0AgAyAJakUNASAJQQFrIgkgC2oiCi0AAEE5Rg0ACyAKIAotAABBAWo6AAAgAyAJakEBaiIFIANNDQEgBSADQcDqiQEQrzsACwJAIANFBEBBMSEJDAELIAFBMToAAEEwIQkgA0EBayIKRSAKRXINACABQQFqQTAgCvwLAAsgBEEBasEiBCAFwUwgAiADTXINBSALIAk6AAAgA0EBaiEDDAULIAlBf0YNBCAJQX9zIgVFDQQgCkEBakEwIAX8CwAMBAsgAEEANgIADwsgAEEANgIADwsgAyACQbDqiQEQsDsACyADIAJBkOqJARCwOwALIAIgA08NACADIAJBoOqJARCwOwALIAAgBDsBCCAAIAM2AgQgACABNgIADwsgAEEANgIAC7ADAQd/IwBBIGsiBiQAIAEoAgghCCAGIAU2AhwgBiAENgIYIAZBGGoQ7hIhBwJAAkACQCACQf8BcUECRgRAIAdBPkwEQCAHQSNGDQQgB0EvRg0DDAILIAdBP0YNAyAHQYCAxABHDQEMAgsgBigCHCELIAYoAhghDAJ/IAggB0HcAEcNABogCCABKAIYIgpFDQAaIApBACABKAIcKAIUEQAAIAEoAggLIQkgASgCBCEKIAZBLzYCGAJAAkAgCQR/IAZBGGpBASAJIApqQQFrQQEQwS4NASABKAIIBUEACyEJIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQFqNgIIIAdBL0YgB0HcAEZyDQELIAZBCGogASACIAMgCCAEIAUQvwEgBigCDCEFIAYoAgghBAwDCyAGQRBqIAEgAiADIAggDCALEL8BIAYoAhQhBSAGKAIQIQQMAgsgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIAhBAWo2AggLIAYgAUECIAMgCCAEIAUQvwEgBigCBCEFIAYoAgAhBAsgACAENgIAIAAgBTYCBCAGQSBqJAALsgMCBH8BfSMAQdAAayIDJAAgAyABKAIMKAIQIAJBAXRqLwEAIgQ7AQIgAAJ/An8gBEEQdCAEQf//AXFFDQAaIARB/wdxIQUgBEGAgAJxIQYgBEGA+AFxIgRBgPgBRgRAIAZBEHQhBCAEQYCAgPwHciAFRQ0BGiAEIAVBDXRyQYCAgP4HcgwBCyAGQRB0IQYgBEENdEGAgID8AHEgBUENdHJBgICAwANqIAZyIAQNABogBSAFZ0EQayIEQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIARBF3Rrcgu+IgdDAACAv14gB0MAAIBDXXFFBEAgA0E4akGGjJgwNgIAIANChoyYsODAgYMGNwMwIANBAjYCHCADQfiS/wA2AhggA0ICNwIkIANBrQM2AkwgA0GHDDYCRCADIANBQGs2AiAgAyADQTBqIgE2AkggAyADQQJqNgJAIANBCGogA0EYahCZDiABEKUMIAAgAykACTcABSAAQQxqIANBEGopAAA3AAAgACADLQAIOgAEQYKAgIB4DAELIAEoAgAgAmogB/wBOgAAQZOAgIB4CzYCACADQdAAaiQAC7IDAgR/AX0jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAAcNeIAdDAAAAQ11xRQRAIANBOGpBgoSIEDYCACADQoKEiJCgwICBAjcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAAk3AAUgAEEMaiADQRBqKQAANwAAIAAgAy0ACDoABEGCgICAeAwBCyABKAIAIAJqIAf8ADoAAEGTgICAeAs2AgAgA0HQAGokAAu1AwIDfwJ+IwBB4ABrIgIkAAJAAkACQCAAKAIEKAIQIAFBBHRqIgMpAwAiBUKAgICACHwiBkL/////D1YgAykDCCAFIAZWrXwiBkIAUiAGUBsNACACIAAoAgAiBCgCACgCACgCACIDNgIgIAIgBT4CHAJAIAOsIAXEfiIFQiCIpyAFpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBTcDCCAFp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwwMBC38jAEFAaiICJAAgAkEQaiABENw7AkACQAJAIAIoAhQEQCACKAIQIgMoAgAiBCAEKAIAIgVBAWo2AgAgBUEASA0BIAIgBDYCHCACIAMpAgQ3AiAgAkEoaiACQRxqIAEoAiggASgCJBD9HCACQQhqIAEQ3DsgAigCDCIDRQ0CIAIoAgghCSACQTRqIANBAWsiCkEAQQRBDBCgGCACKAI4IQQgAigCNEEBRg0DIAIoAjwhBwJAIARFDQAgA0EMbEEMayELQQAhBSAEIQMDQCAFIAtGDQEgBSAJaiIMQQxqKAIAIgggCCgCACIGQQFqNgIAIAZBAEgNAyAFIAdqIgZBBGogDEEQaikCADcCACAGIAg2AgAgBUEMaiEFIANBAWsiAw0ACwsgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEUakGXrty4ATYCACAAQpeu3Ljx4sWLFzcCDCAAIAo2AgggACAHNgIEIAAgBDYCACAAIAIpAig3AhggAEEgaiACQTBqKAIANgIAIAEQiCcgAkFAayQADwtBAEEAQYzNhQEQwyELAAtBAUEAQZzNhQEQrzsACyAEIAIoAjxB0MmFARD9LwALwwMBC38jAEFAaiICJAAgAkEQaiABENw7AkACQAJAIAIoAhQEQCACKAIQIgMoAgAiBCAEKAIAIgVBAWo2AgAgBUEASA0BIAIgBDYCHCACIAMpAgQ3AiAgAkEoaiACQRxqIAEoAiggASgCJBD9HCACQQhqIAEQ3DsgAigCDCIDRQ0CIAIoAgghCSACQTRqIANBAWsiCkEAQQRBDBCgGCACKAI4IQQgAigCNEEBRg0DIAIoAjwhBwJAIARFDQAgA0EMbEEMayELQQAhBSAEIQMDQCAFIAtGDQEgBSAJaiIMQQxqKAIAIgggCCgCACIGQQFqNgIAIAZBAEgNAyAFIAdqIgZBBGogDEEQaikCADcCACAGIAg2AgAgBUEMaiEFIANBAWsiAw0ACwsgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEUakGatOjQATYCACAAQpq06NChw4aNGjcCDCAAIAo2AgggACAHNgIEIAAgBDYCACAAIAIpAig3AhggAEEgaiACQTBqKAIANgIAIAEQiCcgAkFAayQADwtBAEEAQYzNhQEQwyELAAtBAUEAQZzNhQEQrzsACyAEIAIoAjxB0MmFARD9LwALmQMCBX8CfiMAQSBrIgMkAAJ/AkACQAJAAkAgAUHBAEkEQCABQQlPDQFBAiAAKAIcIgYgAWoiAiAAKAIYIgVBA3RqIAAoAggiAUEDdEsNBRoCQCAGBEAgACkDECEHDAELIAEgBUkNAyAAQQggASAFayIEIARBCE8bIAAoAgQgBWogBBDZIiIHNwMQCyAAIAI2AhwgAyAHQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIHNwMAIAJBwABJDQQgACACQUBqIgQ2AhwgACAFQQhqIgI2AhggBEUNBCABIAJJDQMgAEEIIAEgAmsiASABQQhPGyAAKAIEIAJqIAEQ2SIiCDcDECADIAhCf0J/IASthkJ/hSAEQT9LG4NBACAGa0E/ca2GIAeENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAFIAFBxLvOABCvOwALIAIgAUHEu84AEK87AAsgA0EIaiADQQgQ2BYgAygCCEEIRgRAIAMtAAwMAQsgA0EIahDJI0ECCyADQSBqJAALjgQBDH8jAEEgayIGJAAgASABKAIUIghBAWoiCTYCFAJAIAEoAhAiByAJSwRAIAhBAmohCiABQQxqIQsgASgCDCAJaiEMIAhBf3MgB2ohDQJAAkADQCAFIAxqLQAAIg5BMGsiD0H/AXEiEEEKTwRAIAVFBEAgBkENNgIUIAYgCyAFIAhqQQJqIgEgByABIAdJGxDqDCAGQRRqIAYoAgAgBigCBBD7KCEBIABBATYCACAAIAE2AgQMBgsgBCAFayEFIA5BIHJB5QBHDQMgACABIAIgAyAFEOkMDAULIBBBBUsgA0KZs+bMmbPmzBlSciADQpiz5syZs+bMGVZxDQEgASAFIApqNgIUIANCCn4gD61C/wGDfCEDIA0gBUEBaiIFRw0ACyAEIAlqIAdrIQUMAQsgBCAFayEFAkACQAJAIAEoAhQiBCABKAIQIgdPDQAgASgCDCEIA0AgBCAIai0AACIJQTBrQf8BcUEJTQRAIAEgBEEBaiIENgIUIAQgB0cNAQwCCwsgCUEgckHlAEYNAQsgACABIAIgAyAFELASDAELIAAgASACIAMgBRDpDAsMAgsgACABIAIgAyAFELASDAELIAZBBTYCFCAGQQhqIAFBDGogCEECaiIBIAcgASAHSRsQ6gwgBkEUaiAGKAIIIAYoAgwQ+yghASAAQQE2AgAgACABNgIECyAGQSBqJAALrwMBBH8jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEOgJDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ6AkgBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQJ0IAJqQQRrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKAIAIQkgASACIAhBAnRqIgooAgA2AgAgCiAJNgIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQRrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC7EDAgN/AX4jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEP8PDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ/w8gBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQN0IAJqQQhrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKQMAIQogASACIAhBA3RqIgkpAwA3AwAgCSAKNwMADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQhrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC68DAQR/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCQHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJAdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0ECdCACakEEayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASgCACEJIAEgAiAIQQJ0aiIKKAIANgIAIAogCTYCAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEEayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuvAwEEfyMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQkh0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCSHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBAnQgAmpBBGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEoAgAhCSABIAIgCEECdGoiCigCADYCACAKIAk2AgAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBBGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQkx0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCTHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQgBAMAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCAECAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQlR0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCVHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALrwMBBH8jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEIEQDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQgRAgBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQJ0IAJqQQRrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKAIAIQkgASACIAhBAnRqIgooAgA2AgAgCiAJNgIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQRrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC68DAQR/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCCEAwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEIIQIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0ECdCACakEEayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASgCACEJIAEgAiAIQQJ0aiIKKAIANgIAIAogCTYCAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEEayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuxAwIDfwF+IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxDpCQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEOkJIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0EDdCACakEIayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASkDACEKIAEgAiAIQQN0aiIJKQMANwMAIAkgCjcDAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEIayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuVAwIFfwJ+IwBBIGsiBCQAAkACQAJAAkAgAkHBAEkEQCABKAIcIgcgAmoiAyABKAIYIgZBA3RqIAEoAggiAkEDdE0EQAJAIAcEQCABKQMQIQgMAQsgAiAGSQ0DIAFBCCACIAZrIgUgBUEITxsgASgCBCAGaiAFENkiIgg3AxALIAEgAzYCHCAEIAhCf0J/IAOthkJ/hSADQT9LG4MgB0E/ca2IIgg3AwAgA0HAAEkNBCABIANBQGoiBTYCHCABIAZBCGoiAzYCGCAFRQ0EIAIgA0kNAyABQQggAiADayICIAJBCE8bIAEoAgQgA2ogAhDZIiIJNwMQIAQgCUJ/Qn8gBa2GQn+FIAVBP0sbg0EAIAdrQT9xrYYgCIQ3AwAMBAsgAEIANwMADAQLQZi2zgBBIEG4ts4AEJ8pAAsgBiACQcS7zgAQrzsACyADIAJBxLvOABCvOwALIARBCGogBEEIEMQYIAACfiAEKAIIQQhGBEAgACAEKQMQNwMIQgEMAQsgBEEIahDJI0IACzcDAAsgBEEgaiQAC8oDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQ2isgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDsHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGHjpw4NgIAIAJCh46cuPDgwYMHNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvKAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEEI8sIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQ7BwgAi8BCEEBcUUNASACLwEKCyEEQQEMAQsgAkHoAGpBh46cODYCACACQoeOnLjw4MGDBzcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpATo3AxggAiACQUBrKQEANwEeIAIvATghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgATsBBCADQYKAgIB4NgIAIAMgAikDGDcBBiADQQxqIAIpAR43AQBBAAshASAAIAQ7AQIgACABOwEAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQALygMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEoAgAgBBDaKyACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEEO4cIAIvAQhBAXFFDQEgAi8BCgshBEEBDAELIAJB6ABqQYOGjBg2AgAgAkKDhoyYsODAgQM3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQE6NwMYIAIgAkFAaykBADcBHiACLwE4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE7AQQgA0GCgICAeDYCACADIAIpAxg3AQYgA0EMaiACKQEeNwEAQQALIQEgACAEOwECIAAgATsBACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8oDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQjywgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDuHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGDhowYNgIAIAJCg4aMmLDgwIEDNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAuyAwIPfwF+IwBBsAFrIgIkACACQfAAaiABQTRqENQGAkAgASgCTCIFBEAgBSAFKAIAIgNBAWo2AgAgA0EASA0BIAEoAlwhCCABKAJYIQkgASgCVCEKIAEoAlAhCyABKAJgIQcLIAEoAhghBiACQQxqIAFBDGoQ1AYgASgCHCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiwhDCABKAIoIQ0gASgCJCEOIAEoAiAhDyABKAIwIQQLIAJB/ABqIhAgARC8FSACQZABaiACQRRqKAIANgIAIAIgBjYClAEgAiAENgKsASACIAw2AqgBIAIgDTYCpAEgAiAONgKgASACIA82ApwBIAIgAzYCmAEgAiACKQIMNwKIASABKAJAIgMgAygCACIGQQFqNgIAIAZBAEgNACACQcgAaiACQfgAaigCADYCACACIAIpAnA3AkAgAiAHNgJsIAIgCDYCaCACIAk2AmQgAiAKNgJgIAIgCzYCXCACIAU2AlggASkCRCERIAJBDGoiASAQQTT8CgAAIAIgETcCUCACIAM2AkwgACABEPYRIAJBsAFqJAAPCwALoAMBCn8gACgCBCIFKAIEIAAoAgAiBCgCBCAFKAIIIgcgBCgCCCIEIAQgB0sbEJknIQIgAEEMQQggACgCDCIFKAIEIAAoAggiBigCBCAFKAIIIgUgBigCCCIGIAUgBkkbEJknIgMgBSAGayADG0EASCIGG2ohBSAAQQhBDCAGG2oiBiAAIAIgByAEayACGyIEQX9zQR12QQRxaiIHIAUgBSgCACICKAIEIAAgBEEddkEEcWoiACgCACIDKAIEIAIoAggiBCADKAIIIgIgAiAESxsQmSciAyAEIAJrIAMbQQBIIgQbIAYoAgAiAigCBCAHKAIAIgMoAgQgAigCCCICIAMoAggiAyACIANJGxCZJyIIIAIgA2sgCBtBAEgiAhsiAygCACIJKAIEIAAgBSAHIAIbIAQbIggoAgAiCigCBCAJKAIIIgkgCigCCCIKIAkgCkkbEJknIQsgASAFIAAgBBsoAgA2AgAgASADIAggCyAJIAprIAsbQQBIIgAbKAIANgIEIAEgCCADIAAbKAIANgIIIAEgByAGIAIbKAIANgIMC8UJAg5+A38jAEGAAWsiESQAQQEhEgJAIAEoAgBBAUYEQCAAIAEpAgQ3AgQgAEEUaiABQRRqKAIANgIAIABBDGogAUEMaikCADcCAAwBCyABKQMoIQ4gASkDICEPIAEpAxghCiABKQMQIQsgEUHgAGoiAUIKQgAQsi4gESkDYCEDIBEpA2ghBSARKQNwIQggESkDeCEJIAIoAgAhEiMAQaACayICJAACQCASRQRAIAFCAUIAELIuDAELIAJBgAJqQgFCABCyLiACKQOYAiEMIAIpA5ACIQ0gAikDiAIhBiACKQOAAiEEIBJBAUcEQANAIBJBAXEEQCACQfABaiAEQgAgA0IAEKgeIAJB4AFqIAZCACADQgAQqB4gAkHQAWogBEIAIAVCABCoHiACQcABaiAGQgAgBUIAEKgeIAJBsAFqIAMgBSANIAwQqB4gAkGgAWogBCAGIAggCRCoHiACKQPIASACKQOgASIEIAIpA7ABfCIGIARUrSACKQOoASACKQO4AXx8fCAGIAYgAikDwAF8IgRWrXwgBCAEIAIpA+gBIAIpA/gBIgcgAikD4AF8IgYgB1StfHwiBFatfCAEIAIpA9gBIAYgBiACKQPQAXwiBlatfHwiDSAEVK18IQwgAikD8AEhBAsgAkGQAWogA0IAIgcgAyAHEKgeIAJBgAFqIAMgByAFIAcQqB4gAkHwAGogBSAHIAUgBxCoHiACQeAAaiADIAUgCCAJEKgeIAIpA3ggAikDaEIBhiACKQNgIgNCP4iEfCACKQNwIgUgA0IBhnwiAyAFVK18IAMgAyACKQOIASIJIAIpA5gBIgUgAikDgAEiEHwiByAFVK18fCIIVq18IAggCCAJIAcgByAQfCIFVq18fCIIVq18IQkgAikDkAFCfYMhAyASQQNLIBJBAXYhEg0ACwsgAkHQAGogA0IAIARCABCoHiACQUBrIANCACAGQgAQqB4gAkEwaiAFQgAgBEIAEKgeIAJBIGogBUIAIAZCABCoHiACQRBqIAMgBSANIAwQqB4gAiAIIAkgBCAGEKgeIAEgAikDUDcDACABIAIpA1giBCACKQNAfCIDIAIpAzB8Igc3AwggASACKQMQIgggAikDAHwiBSACKQMgfCIGIAIpA0ggAyAEVK18fCIEIAIpAzggAyAHVq18fCIDNwMQIAEgAyAEVK0gBCAGVK0gBSAGVq0gAikDKCAFIAhUrSACKQMYIAIpAwh8fHx8fHw3AxgLIAJBoAJqJAAgEUHQAGogESkDYCIDQgAgC0IAEKgeIBFBQGsgA0IAIApCABCoHiARQTBqIBEpA2giBUIAIAtCABCoHiARQSBqIAVCACAKQgAQqB4gEUEQaiADIAUgDyAOEKgeIBEgESkDcCARKQN4IAsgChCoHiAAIBEpA1A3AxAgACARKQNYIgQgESkDQHwiAyARKQMwfCIHNwMYIAAgESkDICIIIBEpAxB8IgUgESkDAHwiBiARKQNIIAMgBFStfHwiBCARKQM4IAMgB1atfHwiAzcDICAAIAMgBFStIAQgBlStIAUgBlatIBEpAwggBSAIVK0gESkDKCARKQMYfHx8fHx8NwMoQQAhEgsgACASNgIAIBFBgAFqJAALxwMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEgBBCtKiACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEEOwcIAIvAQhBAXFFDQEgAi8BCgshBEEBDAELIAJB6ABqQYeOnDg2AgAgAkKHjpy48ODBgwc3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQE6NwMYIAIgAkFAaykBADcBHiACLwE4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE7AQQgA0GCgICAeDYCACADIAIpAxg3AQYgA0EMaiACKQEeNwEAQQALIQEgACAEOwECIAAgATsBACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8cDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABIAQQrSogAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDuHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGDhowYNgIAIAJCg4aMmLDgwIEDNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvHAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEENorIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQuh0gAi0ACEUNASACLQAJCyEEQQEMAQsgAkHoAGpBhoyYMDYCACACQoaMmLDgwIGDBjcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpADk3AxggAiACQUBrKQAANwAfIAItADghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgAToABCADQYKAgIB4NgIAIAMgAikDGDcABSADQQxqIAIpAB83AABBAAshASAAIAQ6AAEgACABOgAAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQALxwMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEoAgAgBBCPLCACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEELsdIAItAAhFDQEgAi0ACQshBEEBDAELIAJB6ABqQYKEiBA2AgAgAkKChIiQoMCAgQI3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQA5NwMYIAIgAkFAaykAADcAHyACLQA4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE6AAQgA0GCgICAeDYCACADIAIpAxg3AAUgA0EMaiACKQAfNwAAQQALIQEgACAEOgABIAAgAToAACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8cDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQjywgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBC6HSACLQAIRQ0BIAItAAkLIQRBAQwBCyACQegAakGGjJgwNgIAIAJChoyYsODAgYMGNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikAOTcDGCACIAJBQGspAAA3AB8gAi0AOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOgAEIANBgoCAgHg2AgAgAyACKQMYNwAFIANBDGogAikAHzcAAEEACyEBIAAgBDoAASAAIAE6AAAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvHAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEENorIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQux0gAi0ACEUNASACLQAJCyEEQQEMAQsgAkHoAGpBgoSIEDYCACACQoKEiJCgwICBAjcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpADk3AxggAiACQUBrKQAANwAfIAItADghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgAToABCADQYKAgIB4NgIAIAMgAikDGDcABSADQQxqIAIpAB83AABBAAshASAAIAQ6AAEgACABOgAAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQAL8wYCE38BfiMAQcACayICJAACQAJAIAEtAAxBIUYEQCABKAIgIRECfyABKAIkBEBBGEEEEK02IgVFDQMgBSABKQIYNwIAIAUgAUEkaiIDKQIANwIMIAVBCGogAUEgaigCADYCACAFQRRqIANBCGooAgA2AgBBAgwBC0EMQQQQrTYiBUUNAyAFIAEpAhg3AgAgBUEIaiABQSBqKAIANgIAQQELIQ4gAkEIaiABQRBqELAuIAIpAwghFSACIAE2AuABIAIgFTcC2AEjAEEgayIDJAAgA0EUaiACQdgBaiIIKAIEIAgoAgBrQQN2QQBBBEHEABCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEGMz4UBEP0vAAsgAkEUaiELIANBEGoiEkEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEQayIEJAAgA0EIaiIGIAgoAgQiCSAIKAIAIgprQQN2EP4tIAQgBikCBEIgiTcCBCAEIAZBCGo2AgAgBCAIKAIINgIMIwBB0ABrIg8kACAEKAIEIQYgBCgCACETAkACQAJAIAkgCkcEQCAEKAIMIRAgBCgCCCAGQcQAbGohDCAJIAprQQN2IQkDQCAQKAIIIg0gCiwAACIHTQ0CIBAoAgQgB0EDdGoiBygCACINRQ0DIA9BDGoiFCANIAcoAgQiBygCCEEBa0F4cWpBCGogBygCFBEAACAMIBRBxAD8CgAAIApBCGohCiAMQcQAaiEMIAZBAWohBiAJQQFrIgkNAAsLIBMgBjYCACAPQdAAaiQADAILIAcgDUGU5oQBEMMhAAtBpOaEARCyOwALIARBEGokACALQQhqIBIoAgA2AgAgCyADKQIINwIAIANBIGokACACQYACaiABQQxqIgNBCGooAgA2AgAgAkEAOwGwAiACQQA2AqwCIAJBADYClAIgAkEANgKIAiACIBE2AoQCIAJCBDcC8AEgAkIANwLoASACQoCAgIDAADcC4AEgAkEANgLYASACIAMpAgA3AvgBIAIgDjYCvAIgAiAFNgK4AiACIA42ArQCIAJB/ABqIgMgCCACQbQCahCWKSACQSBqIgUgAyALEPwiIAAgBRDNHCABELMmIAFBBEEIEOAeIAJBwAJqJAAPC0GU3YUBQShB9OKFARCfKQALQQRBGBCjPQALQQRBDBCjPQALgAMBAX8gAEEEaiEBAkACQAJAAkACQAJAIAAoAgAOBQECBAMEAAsgASgCACIAQYQBSQ0EIAAQ8h8PCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgASgCACIAKAIAIgFBgICAgHhzIAFBAE4bDhAAAQIDBAUGDwcICQoLDA0ODwsgAEEEahDeOwwOCyAAQQRqELwqDA0LIABBBGoQ3jsMDAsgAEEEahDeOwwLCyAAQQRqEN47DAoLIABBBGoQ3jsMCQsgAEEEahDeOwwICyAAQQRqEN47DAcLIABBBGoQ3jsMBgsgAEEEahDeOwwFCyAAEN47IAAtAAxBA0cNBCAAKAIQIgEQvCogAUEMQQQQ+DoMBAsgAEEEahDeOwwDCyAAQQRqEN47DAILIABBBGoQ3jsMAQsgAEEEahDeOwsgAEEUQQQQ+DoPCyABKAIAIgAQySMgAEEYQQgQ+DoPCyABKAIAIgAQoSkgAEEEQQQQ+DoPCyABEN47CwvwBAIDfwN+IwBB8AFrIgUkACAFIAI2AhAgBSABNgIMIAUgAzYCFAJAAkAgBC0AAEEpRwRAIAVBIGogBEEIaigCADYCACAFIAQpAgA3AxgMAQsgBUGoAWogA0EIahCLBSAFKALcASIEQYCAgIB4RgRAIAVBgAFqIAVBuAFqKQMAIgg3AwAgBUH4AGogBUGwAWopAwAiCTcDACAFIAUpA6gBIgo3A3AgAEEYaiAINwMAIABBEGogCTcDACAAIAo3AwggAEIGNwMAIAMgAygCACIAQQFrNgIAIABBAUYEQCAFQRRqENkhCyAFQQxqELwqDAILIAVB8ABqIgYgBUGoAWpBNPwKAAAgBUHoAGogBUHoAWopAwA3AwAgBSAFKQPgATcDYCAFQShqIgcgBkE0/AoAACAFIAQ2AlwgBUEYaiAFQdAAahDCBiAHEIAvC0EAIQYjAEEwayIEJAAgBCADNgIEAkAgAy4BGCIHQQBMBEAgBEGBgICAeDYCCAwBCwJAIAdBAUcNACADLwEaDQAgAygCFCIGQQhqIAYoAghBAkZBAnRqLQAgIgZBA0cgBkEAR3EhBgsgBEEIaiAEQQRqIAYQlRILIAAgAzYCoAIgAEEANgKQAiAAQoCAgICAATcDiAIgAy4BGiEDIABB4AFqIARBCGpBKPwKAAAgAEICNwOYAiAAQgA3AqQCIABCBTcDACAAIANBAExBH3Q2ApQCIARBMGokACAAQYCAgIB4NgLEAiAAQYCAgIB4NgK4AiAAIAI2ArQCIAAgATYCsAIgACAFKQMYNwPQAiAAQdgCaiAFQSBqKAIANgIACyAFQfABaiQAC64DAgJ/A34jAEHwAWsiBSQAIAUgAjYCECAFIAE2AgwgBSADNgIUAkACQCAELQAAQSlHBEAgBUEgaiAEQQhqKAIANgIAIAUgBCkCADcDGAwBCyAFQagBaiADQQhqEIsFIAUoAtwBIgRBgICAgHhGBEAgBUGAAWogBUG4AWopAwAiBzcDACAFQfgAaiAFQbABaikDACIINwMAIAUgBSkDqAEiCTcDcCAAQRhqIAc3AwAgAEEQaiAINwMAIAAgCTcDCCAAQgY3AwAgAyADKAIAIgBBAWs2AgAgAEEBRgRAIAVBFGoQ2SELIAVBDGoQvCoMAgtBAEUEQCAFQfAAaiAFQagBakE0/AoAAAsgBUHoAGogBUHoAWopAwA3AwAgBSAFKQPgATcDYCAGRQRAIAVBKGogBUHwAGpBNPwKAAALIAUgBDYCXCAFQRhqIAVB0ABqEMIGIAVBKGoQgC8LIAAgAxDKFSAAQYCAgIB4NgLEAiAAQYCAgIB4NgK4AiAAIAI2ArQCIAAgATYCsAIgACAFKQMYNwPQAiAAQdgCaiAFQSBqKAIANgIACyAFQfABaiQAC5sDAQl/IAAoAsABIQUgACgCXCEHAkAgA0EBRgRAIAFBBmshCSAFQQhqIQYgACgCBCIKIAAoAhwiA2ohASADQQh0QYACaiEEIAAoAsgBIQgDQCABQQNqIgUgCU8NAiAHIAEgBiAIEKMdIgBBBnZB/P//H3FqIABB/wFxIAEgCmtBCHRyNgIAAkAgAkUNAEEBIQMgBCEAA0AgA0EDRg0BIAcgASADaiAGIAgQox0iC0EGdkH8//8fcWoiDCgCAEUEQCAMIAAgC0H/AXFqNgIACyAAQYACaiEAIANBAWohAwwACwALIARBgAZqIQQgBSEBDAALAAsgAUEGayEIIAAoAhwiA0EBaiEBIAAoAgQiBCADaiEDIAAoAsgBIQYDQCADQQNqIgAgCE8NASAHIAMgBSAGEKMdQQJ0aiADIARrNgIAAkAgAkUNACABIARqIQlBACEDA0AgA0ECRg0BIAcgAyAJaiAFIAYQox1BAnRqIgooAgBFBEAgCiABIANqNgIACyADQQFqIQMMAAsACyABQQNqIQEgACEDDAALAAsLzwMCA38EfiMAQbABayICJAAgACgCBCgCECABQQR0aiIDKQMAIQUgAykDCCEGIAAoAgAiAygCACgCACIEKQMAIQcgAiAEKQMIIgg3A2ggAiAHNwNgIAIgBjcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAGIAcgCCACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALxAMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEgBBCtKiACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEELodIAItAAhFDQEgAi0ACQshBEEBDAELIAJB6ABqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQA5NwMYIAIgAkFAaykAADcAHyACLQA4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE6AAQgA0GCgICAeDYCACADIAIpAxg3AAUgA0EMaiACKQAfNwAAQQALIQEgACAEOgABIAAgAToAACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8QDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABIAQQrSogAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBC7HSACLQAIRQ0BIAItAAkLIQRBAQwBCyACQegAakGChIgQNgIAIAJCgoSIkKDAgIECNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikAOTcDGCACIAJBQGspAAA3AB8gAi0AOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOgAEIANBgoCAgHg2AgAgAyACKQMYNwAFIANBDGogAikAHzcAAEEACyEBIAAgBDoAASAAIAE6AAAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAuXAQEBfwJAIAFBBEwNACAAIAAoAgAiAkEBazYCECAAIAJBAWo2AhQgACACQQJrNgIYIAAgAkECajYCHCAAIAJBA2s2AiAgACACQQNqNgIkIAFBCk0NACAAIAAoAgQiAUEBazYCKCAAIAFBAWo2AiwgACABQQJrNgIwIAAgAUECajYCNCAAIAFBA2s2AjggACABQQNqNgI8CwurAwMEfwF9AX4jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAgL9eIAdDAACAX11xRQRAIANBOGpBiZKkyAA2AgAgA0KJkqTIkKHChAk3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgAykCCCEIIAAgAykCEDcCDCAAIAg3AgRBgoCAgHgMAQsgASgCACACQQN0aiAHrzcDAEGTgICAeAs2AgAgA0HQAGokAAuqAwMEfwF9AX4jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAAN9gIAdDAAAAX11xRQRAIANBOGpBhYqUKDYCACADQoWKlKjQoMGCBTcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCADKQIIIQggACADKQIQNwIMIAAgCDcCBEGCgICAeAwBCyABKAIAIAJBA3RqIAeuNwMAQZOAgIB4CzYCACADQdAAaiQAC8sDAgN/BH4jAEGwAWsiAiQAIAAoAgQoAhAgAUECdGo0AgAhBSAAKAIAIgMoAgAoAgAiBCkDACEGIAIgBCkDCCIHNwNoIAIgBjcDYCACIAVCP4ciCDcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAIIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALywMCA38EfiMAQbABayICJAAgACgCBCgCECABQQN0aikDACEFIAAoAgAiAygCACgCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAvDDQIRfwR+IwBBEGsiCiQAIAEoAghFBEAgCkEIaiEOIwBB4ABrIgYkACAGIAU2AhwgASgCDCEHIAYgBkEcajYCIAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgggBSAFIAhJGyIHQQ9PBEAgB0H/////AUsNAUF/IAdBA3RBB25BAWtndkEBaiEIDAILQQRBCEEQIAdBCEkbIAdBBEkbIQgMAQsQ3ScgBigCFCEIIAYoAhAiBUGBgICAeEcNBAsgBkHQAGogB0EEIAgQ+xQgBigCWCEIIAYoAlQhBSAGKAJQIgdFDQMgBiAGKAJcNgJMIAYgCDYCSCAGIAU2AkQgBiAHNgJAIAZBCGogBkFAaxDBNCAGKAIMIgUEQCAGKAIIQf8BIAX8CwALIAYoAkghCCAGKAJEIQUgBigCQCIHRQ0DIAYgBigCTDYCPCAGIAg2AjggBiAFNgI0IAYgBzYCMCAGQoSAgICAATcCKCAGIAFBEGo2AiQgBkEwaiERIAYgASgCDCIPBH8gB0EIaiESIAEoAgAiECkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIAxBCGohDCAQQQhqIhApAwBCgIGChIiQoMCAf4MiF0KAgYKEiJCgwIB/UQ0ACyAXQoCBgoSIkKDAgH+FIRoLIAcgBSAGKAIgKAIAIgkpAwgiFyABKAIAIBp6p0EDdiAMakECdCITa0EEazUCAIUiGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhELSgaqbq/qC16d/fiIXQjiGIBdCgP4Dg0IohoQgF0KAgPwHg0IYhiAXQoCAgPgPg0IIhoSEIBdCCIhCgICA+A+DIBdCGIhCgID8B4OEIBdCKIhCgP4DgyAXQjiIhISEIBhC2KLR78Kp5b8tfoUiF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAJKQMAIhhCf4V+IhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIQgFyAYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEfoUgF4mnIhRxIglqKQAAQoCBgoSIkKDAgH+DIhdQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiF1ANAAsLIBpCAX0gGoMhGiAHIBd6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBRBGXYiCzoAACASIAlBCGsgBXFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBNrQQRrKAAANgAAIA9BAWsiDw0ACyABKAIMBUEACyIFNgI8IAYgCCAFazYCOCABIBFBBBD6KiAGQSRqEPUnDAELIAEgBkEgakHYyIUBEO4JC0GBgICAeCEFDAELEN0nIAYoAgQhCCAGKAIAIQULIA4gCDYCBCAOIAU2AgAgBkHgAGokAAsgASgCBCIGIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hGSAEKAIEIQggBCgCACEHIAEoAgAhBANAIAQgBWopAAAiGCAZhSIXQn+FIBdCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhFwJ/AkAgAAJ+AkADQCAXUA0BIAogAyABKAIAIBd6p0EDdiAFaiAGcSIJQQJ0a0EEaygCABD4EiAXQgF9IBeDIRcgByAIIAooAgAgCigCBBCfO0UNAAsgACACNwMIIAAgASgCAEEAIAlrQQJ0ajYCEEIADAELIBhCgIGChIiQoMCAf4MhFyAVRQRAIBdQDQIgF3qnQQN2IAVqIAZxIQ0LQQEgFyAYQgGGg1ANAhogACAEIA1qLAAAQQBOBH8gBCkDAEKAgYKEiJCgwIB/g3qnQQN2BSANCzYCECAAIAI3AwhCAQs3AwAgACABNgIUIApBEGokAA8LQQALIRUgBSAWQQhqIhZqIAZxIQUMAAsAC/MPAhB/BH4jAEHQEGsiBiQAIAZBARDlOiAGQRhqIQMjAEEgayIHJAACQAJAAkACQAJAQcAAQcAAENE0BEBBwABBwAAQrTYiBEUNASAHQgA3AgwgByAENgIIIAdBwAA2AgQgB0HAADYCACAEQf8BOgAAIAdBATYCDCAERQ0CIAQgBC0AAEEBcToAAEEAQcAAENE0RQ0DIAcoAgAhCCAHKAIEIQQgBygCCCESIAcoAgwhDEEcQQQQrTYiDUUNBSANIAQ2AhggDSAINgIUIA1BADYCECANIAw2AgwgDSASNgIIIA1CgYCAgBA3AgAgByAMNgIcIAcgEjYCGCAHIA02AhQgAyAHQRRqQQBBARDyFSAHQSBqJAAMBAsMAgtBwABBwAAQoz0AC0GQgogBELI7AAtB8/+HAUEpIAdBFGpB2P+HAUGcgIgBENUeAAsgA0EANgIUA0AgBkEwaiAJaiIEIAZBGGo2AgAgBEEEakEANgIAIAlBCGoiCUGAEEcNAAsgAigCCCIEBEAgAigCBCEJIARBHGwhAwNAIAZBMGogCS0AAEEDdGoiCEF/QQAgCUEYaigCACAJQRRqKAIARyIEGzYCBCAIIAlBBGogBiAEGzYCACAJQRxqIQkgA0EcayIDDQALCyABKAIgIQQCQAJAIAEoAiQEQCAGIAEoAixBAnYiCDYCtBAgBiAENgKwECAEIAhGDQEgBkEANgK4EEEAIAZBsBBqIAZBtBBqIAZBuBBqQcCGhgEQrysACyAGQTBqIQcjAEEwayIFJABBwAAhDgJAAkAgBCIIQQZ2IgwgBEE/cSIJQQBHaiIDQQN0IgRBwP///wNxQUBrIAQgA0EHcRsiD0HAABDRNARAIA8EQCAPQcAAEK02Ig5FDQILIAhBwABPBEAgDK0hFSABKAIcIQ1BACEEA0AgBCEDQgAhE0IAIRQDQCAHIAMgDWotAABBA3RqIhIoAgAiDCgCBCAMKAIMIBIoAgQgA3FqIgxBA3ZqLQAAIAxBB3F2QQFxrSAThiAUhCEUIANBAWohAyATQgF8IhNCwABSDQALIAogDmogFDcDACAEQUBrIQQgCkEIaiEKIBZCAXwiFiAVUg0ACwsgCQRAIAhBQHEhAyAJrSEVIAEoAhwhDEIAIRNCACEUA0AgByADIAxqLQAAQQN0aiIEKAIAIgEoAgQgASgCDCAEKAIEIANxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCADQQFqIQMgFSATQgF8IhNSDQALIAogDmogFDcAACAKQQhqIQoLIAUgDzYCLCAFQoCAgICACDcCJCAFIA42AhwgBSAIQQN2IAhBB3FBAEdqIgEgCiABIApJGyIENgIgIAVBCGogBUEcahDXOyAFKAIIIQFBHEEEEK02IgNFDQUgA0KBgICAEDcCACADIAUpAhw3AgggA0EQaiAFQSRqKQIANwIAIANBGGogBUEsaigCADYCACAFIAQ2AhggBSABNgIUIAUgAzYCECAAIAVBEGpBACAIEPIVIAVBMGokAAwCC0H09IQBQSkgBUEcakHQ9oQBQaD1hAEQ1R4AC0HAACAPEKM9AAsMAQsgBiABQSRqNgK8ECAGIAE2ArgQIAYgBkEwajYCwBAgBkG4EGohCkEAIQdBACEJIwBBMGsiCyQAQcAAIQ4CQAJAIARBBnYiAyAEQT9xIg1BAEdqIghBA3QiAUHA////A3FBQGsgASAIQQdxGyIPQcAAENE0BEAgDwRAIA9BwAAQrTYiDkUNAgsgBEHAAE8EQCADrSEVIAooAgghEiAKKAIEIQwgCigCACEDA0AgAygCHCAHaiERIAwoAgQgCWohBUIAIRNCACEUA0AgEiARLQAAQQN0aiIIKAIAIgEoAgQgASgCDCAIKAIEIAUoAgBxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCARQQFqIREgBUEEaiEFIBNCAXwiE0LAAFINAAsgDiAQaiAUNwMAIAdBQGshByAJQYACaiEJIBBBCGohECAWQgF8IhYgFVINAAsLIA0EQCAKKAIAKAIcIAStQgaIpyIBQQZ0aiERIAooAgQoAgQgAUEIdGohBSANrSEVIAooAgghA0IAIRNCACEUA0AgAyARLQAAQQN0aiIIKAIAIgEoAgQgASgCDCAIKAIEIAUoAgBxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCARQQFqIREgBUEEaiEFIBUgE0IBfCITUg0ACyAOIBBqIBQ3AAAgEEEIaiEQCyALIA82AiwgC0KAgICAgAg3AiQgCyAONgIcIAsgBEEDdiAEQQdxQQBHaiIBIBAgASAQSRsiCDYCICALQQhqIAtBHGoQ1zsgCygCCCEBQRxBBBCtNiIDRQ0EIANCgYCAgBA3AgAgAyALKQIcNwIIIANBEGogC0EkaikCADcCACADQRhqIAtBLGooAgA2AgAgCyAINgIYIAsgATYCFCALIAM2AhAgACALQRBqQQAgBBDyFSALQTBqJAAMAgtB9PSEAUEpIAtBHGpB0PaEAUGg9YQBENUeAAtBwAAgDxCjPQALCyAGKAIYIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQRhqEPseCyAGKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAGEPseCyACENsmIAJBBEEcEOAeIAZB0BBqJAAPC0EEQRwQoz0AC48DAQp/IwBBEGsiBCQAAkAgAS0AJQ0AIAEtACRFBEAgAUEBOgAkIARBCGogARD8DSAEKAIIIgIEQCAEKAIMIgMNAgtBACECIAEtACVBAUYNAQsgASgCBCEHAn8CQCABKAIQIgIgASgCDCIDSQ0AIAIgASgCCCIISw0AIAFBE2ohCSABQRRqIQoDQCAEIAkgAS0AGGotAAAgAyAHaiACIANrEKMKAkACQCAEKAIAQQFxBEAgASgCDCIDIAQoAgRqIgIgAS0AGCIGQQFrIgVJDQIgAiAFayIFIAZqIgsgBUkgCCALSXINAiAGQQVPDQEgBSAHaiAGIAogBhDBLkUEQCABKAIMIQMMAwsgASAFNgIQIAEoAiAgASAFNgIgIAUgAS0AGGoiAWsMBQsgASABKAIMNgIQDAMLIAZBBEGAmMQAELA7AAsgASACNgIQIAIgCEsNASACIANPDQALCyABQQE6ACUgASgCICABKAIcIgFrCyEDIAEgB2ohAgsgACADNgIEIAAgAjYCACAEQRBqJAALhgQBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIALQAAQQFrDhABAgMEBQYHCAkKCwwNDg8QAAsgAUHdhs8AQQYQ+zUMEAsgAUHjhs8AQQMQ+zUMDwsgAUHmhs8AQQQQ+zUMDgsgAUHqhs8AQQQQ+zUMDQsgAiAAQQhqNgIMIAFBkIfPAEEHQZeHzwBBBSAAQQRqQfCGzwBBnIfPAEEJIAJBDGpBgIfPABCOGAwMCyABQaWHzwBBBBD7NQwLCyACIABBAWo2AgwgAUHMh88AQQRB0IfPAEEUIABBAmpBrIfPAEHkh88AQQQgAkEMakG8h88AEI4YDAoLIAIgAEEBajYCDCABQeiHzwBBCUHQh88AQRQgAEECakGsh88AQeSHzwBBBCACQQxqQbyHzwAQjhgMCQsgAiAAQQJqNgIMIAFBlIjPAEEHQZuIzwBBCSAAQQFqQfSHzwBBpIjPAEEJIAJBDGpBhIjPABCOGAwICyABQa2IzwBBBxD7NQwHCyABQbSIzwBBBBD7NQwGCyABQbiIzwBBBBD7NQwFCyABQbyIzwBBBBD7NQwECyABQcCIzwBBBxD7NQwDCyABQceIzwBBBxD7NQwCCyABQc6IzwBBCBD7NQwBCyABQdaIzwBBCRD7NQsgAkEQaiQAC9sRBBB/AXwEfQN+AkAgACgCDCIRBEAgACgCBCESIAAoAgAhEyABIQwgACgCmBYhCyAAKAIIIhRBBGoiASEPIBFBAWshECMAQZAYayIJJAACQAJAAkACQAJAAkACQAJAAkACQCACIgogAyAMIAQgCxC/C0UEQCAJQQBBgAj8CwAgC0UNASAMIQVB0A8gCyALQdAPTxsiAiEHA0AgAyAEIAVxIgZNBEAgBiADQbyd1gAQwyEACyAJIAYgCmotAABBAnRqIgYgBigCAEEBajYCACAFQQFqIQUgB0EBayIHDQALQQAhBQJAAkACQANAIAVBzw9LBEAgBSAMakHQD2sgBHEiByADTw0CIAkgByAKai0AAEECdGoiByAHKAIAQQFrNgIAIAJBAWshAgsgCyAFQdAPaiIGSwRAIAUgDGpB0A9qIARxIgcgA08NAyAJIAcgCmotAABBAnRqIgcgBygCAEEBajYCACACQQFqIQILIAUgDGogBHEiBSADTw0DIAkgBSAKai0AAEECdGooAgAiBUEBSyEHAn0gAkGAAk8EQCACsxDqEgwBCyACQQJ0QcCH8wBqKgIACyEWIAVBASAHGyEHAn0gBUGAAk8EQCAHsxDqEgwBCyAHQQJ0QcCH8wBqKgIACyEYIBAgBkHQD2siBUcEQCAPIBa7IBi7oUQZBFYOLbKdP6AiFUQAAAAAAADgP6JEAAAAAAAA4D+gIBUgFUQAAAAAAADwP2MbtjgCACAPQQRqIQ8gBUEBaiIFIAtGDQYMAQsLIBAgEEGsndYAEMMhAAsgByADQfyc1gAQwyEACyAHIANBjJ3WABDDIQALIAUgA0GcndYAEMMhAAsgCUEIakEANgIAIAlCADcDACALRQ0AA0ACfwJAIAMgBSAMaiAEcSICSwRAQQAgAiAKaiwAACICQQBODQIaIAJBv39NDQFBAQwCCyACIANBvJvWABDDIQALIAdB3wFLQQF0CyEGIAJB/wFxIQcgCSAGQQJ0aiICIAIoAgBBAWo2AgAgCyAFQQFqIgVHDQALIAkoAgQgCSgCCCAJQQBBgBj8CwAgCUGIGGpBADYCACAJQgA3A4AYQe8DIAsgC0HvA08bIQhqQRhLIQ4gDCECQQAhB0EAIQUDQCADIAIgBHEiDU0EQCANIANB7JzWABDDIQALIAchBiAJQYAYaiAFQQJ0aiIHIAcoAgBBAWo2AgAgCSAFQQp0aiAKIA1qLAAAIgVB/wFxIgdBAnRqIg0gDSgCAEEBajYCAAJ/QQAgBUEATg0AGiAOIAVBv39LDQAaIA4gBkHgAU9xCyEFIAJBAWohAiAIQQFrIggNAAtB0A8hB0EAIQUDQCAFQe8DTwRAQQAhAgJAIAVB7wNGDQAgBSAMaiINQfADayAEcSICIANPDQUgAiAKai0AACEGQQAhAkEAIQggBUHxA08EQCANQfEDayAEcSIIIANPDQcgDiAIIApqLQAAQeABT3EhCAsgBsBBAE4NACAOIAggBkG/AUsbIQILIAUgDGpB7wNrIARxIgYgA08NBiAJQYAYaiACQQJ0ciIIIAgoAgBBAWs2AgAgCSACQQp0aiAGIApqLQAAQQJ0aiICIAIoAgBBAWs2AgALAkACQAJAAkAgCyAFQe8DaksEQCAFIAxqIgJB7gNqIARxIgYgA08NASACQe0DaiAEcSIIIANPDQIgAkHvA2ohDQJ/QQAgBiAKaiwAACICQQBODQAaIA4gAkG/f0sNABogDiAIIApqLQAAQeABT3ELIQIgBCANcSIGIANPDQsgCUGAGGogAkECdHIiCCAIKAIAQQFqNgIAIAkgAkEKdGogBiAKai0AAEECdGoiAiACKAIAQQFqNgIACyAFDQJBACECDAMLIAYgA0H8m9YAEMMhAAsgCCADQYyc1gAQwyEACyAFIAxqIg1BAWsgBHEiAiADTw0IIAIgCmotAAAhBkEAIQJBACEIIAVBAUcEQCANQQJrIARxIgggA08NCiAOIAggCmotAABB4AFPcSEICyAGwEEATg0AIA4gCCAGQb8BSxshAgsgBSAMaiAEcSIGIANPDQkgCSACQQp0aiAGIApqLQAAQQJ0aigCACIGQQFLIQggBkEBIAgbIQgCfSAJQYAYaiACQQJ0cigCACICQYACTwRAIAKzEOoSDAELIAJBAnRBwIfzAGoqAgALuwJ9IAZBgAJPBEAgCLMQ6hIMAQsgCEECdEHAh/MAaioCAAu7oUQ6kst/SL+dP6AiFUQAAAAAAADgP6JEAAAAAAAA4D+gIBUgFUQAAAAAAADwP2MbIRUgBUHPD00EQCAHuEQAAAAAAECfwKNEZmZmZmZm1j+iRGZmZmZmZuY/oCAVoCEVCyAFIBBGDQIgDyAVtjgCACAHQQFrIQcgD0EEaiEPIAsgBUEBaiIFRw0ACwsgCUGQGGokAAwICyAQIBBB3JzWABDDIQALIAIgA0HMm9YAEMMhAAsgCCADQdyb1gAQwyEACyAGIANB7JvWABDDIQALIAYgA0GcnNYAEMMhAAsgAiADQayc1gAQwyEACyAIIANBvJzWABDDIQALIAYgA0HMnNYAEMMhAAtBACEEIBRBADYCAAJAIAsEQEEAIAtrIQNBASECA0AgAiARRg0CIAEgFyAZIAEqAgCSIhiSIhY4AgAgGCAWIBeTkyEZIAFBBGohASAWIRcgAyACQQFqIgJqQQFHDQALC0EsIQEDQCAAIAFqQRxrAn0gBEH1AU8EQCAEQQtqsxDqEgwBCyABQcCH8wBqKgIACzgCACABQQRqIQEgBEEBaiIEQcAFRw0ACwwCCyACIBFB/LbQABDDIQALQQFBAEHcttAAEK87AAsCQCAAKAKQFiIBBEAgAa0hGyASrSEcQQAhBANAAn0gGkLsAVoEQCAaQhR8tRDqEgwBCyAEQZCI8wBqKgIACyEXIBogHFENAiAEIBNqIBc4AgAgBEEEaiEEIBsgGkIBfCIaUg0ACwsgAEHsh/MAKgIAOAKUFg8LIBIgEkHsttAAEMMhAAuXAwEIfwJAAkAgA0G8BE0EQAJAIAIgACADQQJ0aigCACIHSwRAIANBAXQiBiAAKAL0ESIFTQ0BDAMLIAcgAkH4/fsAEMMhAAsgAEH8EWoiCCAHai0AACABIAdBAnRqLwEAQQh0ciELA0ACQAJAAkACQCADQZ4CTQRAIAAgBkECdGooAgAiBCACTw0BIAQgCGotAAAgASAEQQJ0ai8BAEEIdHIhBCAFIAZNBEAgBCEFIAYhBAwFCyAGQQFyIglBvQRPDQIgACAJQQJ0aigCACIFIAJPDQMgBSAIai0AACABIAVBAnRqLwEAQQh0ciIKIAQgBCAKSxshBSAGIAkgBCAKSRshBAwECyAGQb0EQYj++wAQwyEACyAEIAJBmP77ABDDIQALQb0EQb0EQaj++wAQwyEACyAFIAJBuP77ABDDIQALIAUgC08NAiAAIANBAnRqIAAgBEECdGooAgA2AgAgBCIDQQF0IgYgACgC9BEiBU0NAAsMAgsgA0G9BEHo/fsAEMMhAAsgAyEECyAAIARBAnRqIAc2AgALyAMCA38EfiMAQbABayICJAAgACgCBCgCECABQQF0ajIBACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAvIAwIDfwR+IwBBsAFrIgIkACAAKAIEKAIQIAFBAnRqNAIAIQUgACgCACIDKAIAIgQpAwAhBiACIAQpAwgiBzcDaCACIAY3A2AgAiAFQj+HIgg3A1ggAiAFNwNQIAJBADYCLCACQRBqIAUgCCAGIAcgAkEsahD2DAJAAkACQCACKAIsBEAgAkECNgKMASACQayQ/wA2AogBIAJCAjcClAEgAkGEDDYCrAEgAkGEDDYCpAEgAiACQaABajYCkAEgAiACQeAAajYCqAEgAiACQdAAajYCoAEgAkH4AGogAkGIAWoQmQ4gAkHEAGogAkGEAWooAgA2AgAgAkGIgICAeDYCdCACIAJB/ABqKQIANwI8IAIgAikCdDcCNCACQQE2AjAgAkEwakEEchCIEQwBCyACKQMQIgUgAikDGCIGIAMoAgQtAAAQ/yBFDQAgACgCCCABQQR0aiIAIAY3AwggACAFNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQbABaiQADwsgACADQYiL/wAQwyEAC8gDAgN/BH4jAEGwAWsiAiQAIAAoAgQoAhAgAUEDdGopAwAhBSAAKAIAIgMoAgAiBCkDACEGIAIgBCkDCCIHNwNoIAIgBjcDYCACIAVCP4ciCDcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAIIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALtQMCA38BfiMAQdAAayIDJAACQAJAIAECfwJAAkACQAJAIAEtACxBAWsOAwIFAQALIAMgASgCBDYCLCADQZiXwwA2AjAgA0IBNwI8IANBOzYCTCADIANByABqNgI4IAMgA0EsajYCSCADQQE2AjQgA0EEaiADQTBqIgQQmQ4gBCABKAIAKAIAQQhqEN0gIAEoAgAoAgAoAhQiBCAEKAIAIgVBAWo2AgAgBUEASA0EIANBGGoiBSADQThqKAIANgIAIANBJGogA0EMaigCADYCACADIAMpAjAiBjcDECADIAMpAgQ3AhwgAUEYaiADQSBqKQMANwIAIAFBEGogBSkDADcCACABIAY3AgggAUEAOgAoIAEgBDYCIAsgA0EwaiABQQhqIgUgAhCxDiADKAIwRQ0BIABBCTYCAEEDDAILQezzwgAQ6CsACyADKQI8IQYgAygCOCECIAMoAjQhBCAFEKAlIARFDQIgACAGNwIMIAAgAjYCCCAAIAQ2AgQgAEEINgIAQQELOgAsIANB0ABqJAAPCwALIAMgAjYCMEGc4MIAQSsgA0EwakHY4MIAQfzzwgAQ1R4AC7YWAhZ/BH4jAEHQAGsiCyQAAkACQCABLQCsAUUNACABKAKkASIFKAIUIgdBCGogBygCCEECRkECdGotACFBFkYNACALQQxqIQogAiIHIANBBHRqIQ4jAEEwayIGJAAgBUEIaiIJKAIMQQhqIQwCQANAIA4gByIFRgRAIApBADYCAAwCCyAGQRBqIAwgDCgCAEECRkECdGoQiRkgBi0AEEENRgRAIAUoAgBFDQQCQAJAAkAgBUEIaigCAA4CAAECC0EAQQBB7InOABDDIQALQQFBAUH8ic4AEMMhAAsgBUEQaiEHIAVBBGooAgAiBC0AAUEIdEGA/gFxIAQtAAByQYD4AUsNAQsLIAVBEGohCCAFIQQDQAJAAkAgDiAIIgdHBEAgBkEQaiAMIAwoAgBBAkZBAnRqEIkZIAYtABBBDUcNAiAHKAIARQ0GAkACQCAHQQhqKAIADgIAAQMLQQBBAEHsic4AEMMhAAtBAUEBQfyJzgAQwyEACyAGIAUgCUMAAACAEJkKIAZBIGoiBSAEIAlDAAAAABCZCiAKQQE2AgAgCiAGKQIANwIEIApBDGogBkEIaikCADcCACAKQRRqIAUpAwA3AgAgCkEcaiAGQShqKQMANwIADAMLIAdBEGohCCAHQQRqKAIAIg8tAAFBCHRBgP4BcSAPLQAAckGA+AFLDQELIAcgBSAJIAUgBxCJDRshBSAHIAQgCSAHIAQQiQ0bIQQgB0EQaiEIDAALAAsgBkEwaiQAIAsoAgxBAUcNACALQThqIAtBGGopAgA3AwAgCyALKQIQNwMwIAtByABqIAtBKGopAgA3AwAgCyALKQIgNwNAIAEoAqQBQQhqIgUgC0EwaiIHIAFB8ABqIAUgBxCmESABKAKkAUEIaiIFIAtBQGsiByABQYQBaiAFIAcQpxEgCygCQCIFBEAgC0HMAGogCygCRCALKAJIIAUoAhARAQALIAsoAjAiBUUNACALQTxqIAsoAjQgCygCOCAFKAIQEQEACyADRSABKAKYAUGAgICAeEZyRQRAIAFBmAFqIQcgA0EEdCEEIAIhBQNAIAUoAgBFDQIgByAFKAIEIAUoAggQhgoQohUgBUEQaiEFIARBEGsiBA0ACwsCQCABKAJYQYCAgIB4RwRAIAFBEGoiBUHIAGogAxDsLSADBEAgA0EEdCEBA0AjAEEwayIMJAAgAigCAEUEQAwFCyAMQRhqIQcgBUEQaiIGIAIoAgQgAigCCBDNAiEbIAVBMGohA0EAIQhBACEOQQAhD0EAIRFBACESIwBBEGsiEyQAAkAgBSgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCADNgIcIAQgBjYCGCAFKAIMIQogBCAEQRhqNgIgAkACQAJAAkACQAJAIAogCkEBaiIGTQRAIAUoAgQiCiAKQQFqQQN2QQdsIApBCEkbIgpBAXYgBkkEQCAKQQFqIgggBiAGIAhJGyIIQQ9JDQIgCEH/////AU0EQEF/IAhBA3RBB25BAWtndkEBaiEIDAQLEN0nIAQoAhQhCCAEKAIQIgZBgYCAgHhHDQUMAwsgBSAEQSBqQcSkzwAQ6wkMAwsQ3ScgBCgCBCEIIAQoAgAhBgwDC0EEQQhBECAIQQhJGyAIQQRJGyEICyAEQdAAaiAFQRBqIglBCCAIEPsUIAQoAlghCCAEKAJUIQYgBCgCUCIKRQ0BIAQgBCgCXDYCTCAEIAg2AkggBCAGNgJEIAQgCjYCQCAEQQhqIARBQGsQwTQgBCgCDCIIBEAgBCgCCEH/ASAI/AsACyAEKAJIIQggBCgCRCEGIAQoAkAiCkUNASAEIAQoAkw2AjwgBCAINgI4IAQgBjYCNCAEIAo2AjAgBEKIgICAgAE3AiggBCAJNgIkIAQgBSgCDCIVBH8gCkEIaiEXIAUoAgAiFikDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA5BCGohDiAWQQhqIhYpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAiAiDSgCBCIQKAIIIhggBSgCACAaeqdBA3YgDmpBA3QiGWtBCGsoAgAiCU0NBCAQKAIEIAlBBHRqIgkoAgBFDQUgCiAGIA0oAgAgCSgCBCAJKAIIEM0CpyIQcSIJaikAAEKAgYKEiJCgwIB/gyIcUARAQQghDQNAIAkgDWohCSANQQhqIQ0gCiAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhxQDQALCyAaQgF9IBqDIRogCiAceqdBA3YgCWogBnEiCWosAABBAE4EQCAKKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgCSAKaiAQQRl2Ig06AAAgFyAJQQhrIAZxaiANOgAAIAogCUEDdGtBCGsgBSgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgBSgCDAVBAAsiBjYCPCAEIAggBms2AjggBSAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBgsgFCAINgIEIBQgBjYCACAEQeAAaiQADAILIAkgGEGUkM4AEMMhAAsMBwsLIAUoAgQiCCAbp3EhBCAbQhmIQv8Ag0KBgoSIkKDAgAF+IR0gAygCBCEOIAMoAgghCiAFKAIAIQYDQCAEIAZqKQAAIhwgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAAkAgBwJ+AkADQCAaUA0BIAIoAgBFDQwgCiAFKAIAQQAgGnqnQQN2IARqIAhxayINQQN0akEIaygCACIJTQ0DIA4gCUEEdGoiCSgCAEUNDCAaQgF9IBqDIRogAigCBCACKAIIIAkoAgQgCSgCCBCfO0UNAAsgByAbNwMIIAcgBSgCACANQQN0ajYCEEIADAELIBxCgIGChIiQoMCAf4MhGiARRQRAIBpQDQMgGnqnQQN2IARqIAhxIQ8LQQEgGiAcQgGGg1ANAxogByAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAHIBs3AwhCAQs3AwAgByAFNgIUIBNBEGokAAwECyAJIApBlJDOABDDIQALQQALIREgBCASQQhqIhJqIAhxIQQMAAsACyAMQQhqIQQCQCAHKAIAQQFGBEAgBykDCCEaIAcoAhAhCiAHKAIUIQcCfiMAQRBrIggkACACKAIAIgkEQCADIAMoAgwgAygCEGo2AgwgAygCCCEGIAggAkEMaiACKAIEIAIoAgggCSgCABEFACADKAIAIAZGBEAgA0GkkM4AEJ4oCyADKAIEIAZBBHRqIgkgCCkCADcCACAJQQhqIAhBCGopAgA3AgAgAyAGQQFqNgIIIAhBEGokACAGrQwBC0Gsh84AQSVB1IfOABCfKQALIRsgCiAHKAIAIgNqIggtAAAhBiAIIBqnQRl2Igg6AAAgAyAHKAIEIApBCGtxakEIaiAIOgAAIAQgBzYCDCAEIBo3AwAgByAHKAIMQQFqNgIMIAQgAyAKQQN0ayIDNgIIIAcgBygCCCAGQQFxazYCCCADQQhrIBs3AwAMAQsgBCAHQQhqIgMpAwA3AwAgBEEIaiADQQhqKQMANwMACyAMKAIQQQhrKQMAIRogDEEwaiQAIAUoAlAiAyAFKAJIRgRAIAVByABqQdSQzgAQsygLIAUoAkwgA0EDdGogGjcDACAFIANBAWo2AlAgAkEQaiECIAFBEGsiAQ0ACwsgAEEINgIADAELIAAgASgCaCACIAMgASgCbCgCDBEFAAsgC0HQAGokAA8LQeSHzgBBIEGEiM4AEMskAAuKHAILfwZ+IwBBkCtrIgYkACABKAIAIQwgBkEIaiAGQYgraiILQYAgELgpIAYoAgghDSAGKAIMIQ4jAEEQayIKJAAgCkEVQefzzQBBDBDNGiAKQQhqIg9BF0Hz880AQRIQzRogBkEQaiEHIwBB8CprIggkACMAQUBqIgUkACAIQQhqIgFBCGoiCUIANwJAIAlCgICAgIAINwIIIAlBADoAUCAJQvz//5+wATcCECAJQgA3AgAgCUEANgBZIAlCEDcCOCAJQoiAgIDQADcCMCAJQoaAgIDwATcCKCAJQgA3AiAgCUIWNwIYIAlCgICAgBA3AFEgCUHIAGpCADcCACAFQShqEP0nIAUpAyghECAFQQA2AjwgBUKAgICAwAA3AjQgBUEgaiAFQTRqIglBjIfOABCYISAFKQMgIREgBUEYahD+JyAFKQMYIRIgBUEQahD9JyAFKQMQIRMgBUEIahD9JyAFKQMIIRQgBUEANgI8IAVCgICAgMAANwI0IAUgCUGMh84AEJ0hIAUpAwAhFSABQgA3AvQpIAEgFDcC7CkgAUIANwPoASABQQA2AmggAUH8KWpCADcCACABQYQqakIANwIAIAFBjCpqQgA3AgAgAUEANgKcKiABQgA3ApQqIAEgFTcDwAEgAUIANwPwASABQfgBakIANwMAIAFCj4CAgIACNwOIAiABQoSAgICwATcDgAIgAUGQAmpBAEEw/AsAIAFBADoAwCogAUEAOwG+KiABQQA7AbgqIAFCj4CAgIACNwPIAiABQoSAgICwATcDwAIgAUEANgKgKiABIBA3A8gBIAFB0AJqQQBBgCD8CwAgAUEANgKkKiABIBE3A9ABIAFB0CJqQQBBgAf8CwAgASATNwPgASABIBI3A9gBIAFCADcDqCogAUECNgIAIAFCADcD0CkgAUHYKWpCADcDACABQeApakIANwMAIAFB6ClqQQA2AgAgAUEANgG6KiABQQA2ArQqIAFBADYCsCogBUFAayQAIAggDjYC5CogCCANNgLgKiAIIAQ2AugqIAhCATcDACAIIA8pAgA3A9gqIAggCikCADcD0CoCQAJAIAgtAMMqIgFFBEAgCEEQakEBIAwQoAwgCC0AwypBAXFFDQEMAgsgAQ0BCyAIQRBqQQJBFhCgDAsgByAIQfAq/AoAACAIQfAqaiQAIApBEGokACMAQRBrIgQkAAJAAkAgAwRAA0AgBEEIaiEFIwBBIGsiASQAIAEgAzYCDCABQQA2AhACQAJAAkACQAJAIAMEQCAHQQhqIQkDQCABQQA2AhQgASAHKALkKiIINgIYIAlBACABQQxqIAIgAyABQRBqIAFBGGogBygC4CogCCABQRRqIAcQzwkgASgCFCIIBEAgBygC6CoiDEUNBSAIIAcoAuQqIg1LDQYgDCAHKALgKiIMIAggDGoQvSYLRQRAIAcpA9AqIRAgB0EEOgDQKiAQQv8Bg0IEUg0DQfTuzQAQsjsACyABKAIMDQALCyAFQQQ6AAAgBSADNgIEDAELIAUgEDcCAAsgAUEgaiQADAILQdTuzQAQsjsACyAIIA1B5O7NABCwOwALAkACQAJAAkACQCAELQAIIgFBBEcEQAJAIAFBAWsOAwAEAgkLIAQtAAlBI0cNCAwECyAEKAIMIgFFBEBByPDNACEFDAgLIAEgA00NASABIANB0PDNABCvOwALIAQoAgwtAAhBI0YNAgwGCyABIAJqIQIgAyABayEDDAILIAQoAgwtAAhBI0cNBAsgBEEIahC5LgsgAw0ACwsgC0EEOgAADAELIAsgBSkCADcCAAsgBEEQaiQAAkACQCAGLQCIK0EERg0AIAYpA4grIhBC/wGDQgRRDQAgBiAQNwOIKyAAIAsQgSsMAQsgBkGAK2ohAiMAQRBrIgEkACABQQhqIAZBEGoiA0EBEJESAkACQAJAIAEtAAhBBEcEQCACIAEpAwg3AgAMAQsgAygC6CpFDQEgAkEEOgAACyABQRBqJAAMAQtBxO7NABCyOwALIAYtAIArQQRHBEAgBiAGKQOAKzcDiCsgACAGQYgrahCBKwwBCyAAQQg2AgALIwBBEGsiCCQAAkAgBkEQaiIAKALoKkUNACAIQQhqIgEgAEECEJESIAgtAAhBBEYNACABELkuCyMAQUBqIgIkACACQShqEP0nIABBCGoiAygCyAEhACADIAIoAig2AsgBIAMoAswBIQEgAyACKAIsNgLMASADQb4qaiIJIAAgARDgNSACQQA2AjwgAkKAgICAwAA3AjQgAkEgaiACQTRqQYyHzgAQnSEgAygCxAEhACADKALAASEBIAMgAikDIDcDwAEgAARAIAEgAEEEdEEEEPg6CyACQRhqEP0nIAMoAvApIQAgAigCGCEBIAMgAigCHDYC8CkgAygC7CkhBCADIAE2AuwpIAkgBCAAEOA1IwBB0AFrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQegAaiIAKAIAQQFrDgoAAQIDBAUGBwgJCwsgAUEIahD+JyAAKAIIIQQgASgCCCEFIAAgASgCDDYCCCAAKAIEIAAgBTYCBCAEEIAxDAkLIAFBEGoQ/icgACgCCCEEIAEoAhAhBSAAIAEoAhQ2AgggACgCBCAAIAU2AgQgBBCAMQwICyABQRhqEP4nIAAoAgghBCABKAIYIQUgACABKAIcNgIIIAAoAgQgACAFNgIEIAQQgDEMBwsgAUEgahD+JyAAKAIIIQQgASgCICEFIAAgASgCJDYCCCAAKAIEIAAgBTYCBCAEEIAxDAYLIAFBADYChAEgAUKAgICAIDcCfCABQTBqIAFB/ABqQYyHzgAQqiEgACgCCCEEIAAoAgQhBSAAIAEpAzA3AgQgBARAIAUgBEEBdEECEPg6CyABQShqEP4nIAAoAhAhBCABKAIoIQUgACABKAIsNgIQIAAoAgwgACAFNgIMIAQQgDEMBQsgAUEANgKEASABQoCAgIAgNwJ8IAFBQGsgAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDQDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFBOGoQ/icgACgCECEEIAEoAjghBSAAIAEoAjw2AhAgACgCDCAAIAU2AgwgBBCAMQwECyABQQA2AoQBIAFCgICAgCA3AnwgAUHQAGogAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDUDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFByABqEP4nIAAoAhAhBCABKAJIIQUgACABKAJMNgIQIAAoAgwgACAFNgIMIAQQgDEMAwsgAUEANgKEASABQoCAgIAgNwJ8IAFB4ABqIAFB/ABqQYyHzgAQqiEgACgCDCEEIAAoAgghBSAAIAEpA2A3AwggBARAIAUgBEEBdEECEPg6CyABQdgAahD+JyAAKAIQIAAgASgCWDYCECAAKAIUIAAgASgCXDYCFBCAMQwCCyABQQA2AoQBIAFCgICAgCA3AnwgAUHwAGogAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDcDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFB6ABqEP4nIAAoAhAhBCABKAJoIQUgACABKAJsNgIQIAAoAgwgACAFNgIMIAQQgDEMAQsjAEEQayIEJAAgBEEIahD+JyAAQQRqIgUoAgwhByAEKAIIIQogBSAEKAIMNgIMIAUoAgggBSAKNgIIIAcQgDEgBBD+JyAFKAIEIQcgBCgCACEKIAUgBCgCBDYCBCAFKAIAIAUgCjYCACAHEIAxIARBEGokAAsCfwJAAkACQAJAAkACQAJAAkAgACgCAA4KCQUFBQUEAwIBAAYLIAAoAggiBEUNBiAAKAIEIARBAXRBAhD4OgwGCyAAKAIMIgQEQCAAKAIIIARBAXRBAhD4OgsgACgCFCIERQ0HQRAMBgsgACgCCCIERQ0EIAAoAgQgBEEBdEECEPg6DAQLIAAoAggiBEUNAyAAKAIEIARBAXRBAhD4OgwDCyAAKAIIIgRFDQIgACgCBCAEQQF0QQIQ+DoMAgsgACgCCCIERQ0DQQQMAgsgACgCCCIERQ0AIAAoAgQgBEECdEEEEPg6CyAAKAIQIgRFDQFBDAsgAGooAgAgBEECdEEEEPg6CyAAQQA2AgAgAEEEaiABQfwAakHUAPwKAAAgAUHQAWokACACQQA2AjwgAkKAgICAwAA3AjQgAkEQaiACQTRqQYyHzgAQmCEgAygC1AEhACADKALQASEBIAMgAikDEDcD0AEgAARAIAEgAEECdEEEEPg6CyACQQhqEP4nIAMoAtgBIAMgAigCCDYC2AEgAygC3AEgAyACKAIMNgLcARCAMSACEP0nIAMoAuABIQAgAyACKAIANgLgASADKALkASEBIAMgAigCBDYC5AEgCSAAIAEQ4DUgAkFAayQAIAhBEGokACAGKAL0KiIABEAgBigC8CogAEEBEPg6CyAGLQDgKkEERwRAIAZB4CpqELkuCyAGQYABahDzEyAGKAKIKiIABEAgBigChCogAEEBEPg6CyAGKALcASIABEAgBigC2AEgAEEEdEEEEPg6CyAGKALkASIABEAgBigC4AEgAEEBEPg6CyAGKALsASIABEAgBigC6AEgAEECdEEEEPg6CyAGKAL0ASIABEAgBigC8AEgAEECdEEEEPg6CyAGKAL8ASIABEAgBigC+AEgAEEBEPg6CyAGLQDoKkEERwRAIAZB6CpqELkuCyAGQZAraiQAC6IDAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBC0F/IAJBBGoiBSACIAVLGyICQQdxBEAgACACNgIcIABBAzYCGCAAQbDk/gA2AhQgAEGAgICAeDYCECAAQgQ3AgggAEKEgICACDcCAAwBCwJAAkBBfyACQX8gBEEDdCAEQf////8BSxsiBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC6MDAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBC0F/IAJBBGoiBSACIAVLGyICQQNxBEAgACACNgIcIABBygA2AhggAEHm4/4ANgIUIABBgICAgHg2AhAgAEIENwIIIABChICAgAg3AgAMAQsCQAJAQX8gAkF/IARBAnQgBEH/////A0sbIgVqIgQgAiAESxsiBCABKAIETQRAIAEgASgCFCAFaiIGNgIUQYiAgIB4IQUgBiABKAIIKAIISw0BDAILIANBDGogAiAEEL8vIAMoAgwiBUGKgICAeEYNAQsgACADKQIQNwIEIABBHGogA0EoaikCADcCACAAQRRqIANBIGopAgA3AgAgAEEMaiADQRhqKQIANwIAIAAgBTYCAAwBCyAAIAQ2AgggACACNgIEIABBioCAgHg2AgALIANBMGokAAuiAwEEfyMAQTBrIgMkACADQQxqIAEgAhCTDiADKAIQIQQCQCADKAIMIgVBioCAgHhHBEAgACADKQIUNwIIIABBIGogA0EsaigCADYCACAAQRhqIANBJGopAgA3AgAgAEEQaiADQRxqKQIANwIAIAAgBDYCBCAAIAU2AgAMAQtBfyACQQRqIgUgAiAFSxsiAkEDcQRAIAAgAjYCHCAAQQM2AhggAEG85P4ANgIUIABBgICAgHg2AhAgAEIENwIIIABChICAgAg3AgAMAQsCQAJAQX8gAkF/IARBAnQgBEH/////A0sbIgVqIgQgAiAESxsiBCABKAIETQRAIAEgASgCFCAFaiIGNgIUQYiAgIB4IQUgBiABKAIIKAIISw0BDAILIANBDGogAiAEEL8vIAMoAgwiBUGKgICAeEYNAQsgACADKQIQNwIEIABBHGogA0EoaikCADcCACAAQRRqIANBIGopAgA3AgAgAEEMaiADQRhqKQIANwIAIAAgBTYCAAwBCyAAIAQ2AgggACACNgIEIABBioCAgHg2AgALIANBMGokAAvIAwMDfwR+AXwjAEGgAWsiAyQAIAEoAgghBCADIAEoAgwoAhAgAkEDdGorAwAiCjkDGCADQSBqIAogBCgCACsDAKIQoSQQowYgBCgCBCEFAkACQAJ+IAMoAiBBAXFFBEAgBCgCCCEBIANBzJH/ADYCaCADQgQ3AnQgA0GJDDYCnAEgA0H0CzYClAEgAyABNgKQASADQbsHNgKMASADIAU2AogBIANBzAE2AoQBIANBjJL/ADYCgAEgAyADQYABajYCcCADIANBGGo2ApgBIANBBDYCbCADQdgAaiADQegAahCZDiADQRBqIANB3ABqKAIANgIAIANBgoCAgHg2AlQgAyADKQJUNwMIIAMpAmAMAQsgA0EgaiADKQMwIgYgAykDOCIHIAMpA0AiCCADKQNIIgkgBS0AABDQDiADKAIgQZOAgIB4Rg0BIANBEGogA0EoaigCADYCACADIAMpAiA3AwggAykCLAshBiAAIAMpAwg3AgAgACAGNwIMIABBCGogA0EQaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQaABaiQAC4wDAgx/AX4jAEEgayIDJAAgASgCECIKrSACrX4iD0IgiFAEQCADQQRqIA+nIgtBA3YgC0EHcUEAR2oQ0h8CQCAKRQRAIAMoAhAhBiADKAIMIQcMAQsgASgCDCENIAEoAgQhDiADKAIQIQYgAygCDCEHA0ACQCACRQ0AIAghBCACIQkgDiAMIA1qIgVBA3ZqLQAAQQEgBUEHcXRxRQ0AA0AgBiAEQQN2IgVLBEAgBSAHaiIFIAUtAABBASAEQQdxdHI6AAAgBEEBaiEEIAlBAWsiCQ0BDAILCyAFIAZByPqHARDDIQALIAIgCGohCCAMQQFqIgwgCkcNAAsLIAMoAgQhCCADKAIIIQlBHEEEEK02IgQEQCAEIAk2AhggBCAINgIUIARBADYCECAEIAY2AgwgBCAHNgIIIARCgYCAgBA3AgAgAyAGNgIcIAMgBzYCGCADIAQ2AhQgACADQRRqQQAgCxDyFSAAIAEoAhQgAmw2AhQgA0EgaiQADwtBBEEcEKM9AAtBuPqHARCyOwALtAQBBn8jAEGAAWsiBCQAAkACQCABKQMAQgNRDQAgBEEMaiACQQUQyAogBCgCDEEBRgRAQQQgBBD5OiECIAEQ+C4gASACNgIIIAFCAzcDAAwBCyAEQShqIARBGGopAgA3AwAgBCAEKQIQNwMgIARB0ABqIANBCGooAgA2AgAgBCADKQIANwNIIARB8ABqIgIgBEHIAGoQ5xUgBEE0aiEDIAIoAgghBiACKAIEIQcCQAJAA0AgBSAGRg0BIAUgB2otAAAiCEEfSyAIQf8AR3EhCSAFQQFqIQUgCEEJRiAJcg0ACyADQQI6ABAgAkEMaiAHIAYgAigCACgCEBEBAAwBCyADQQA6ABAgAyACKQIANwIAIANBCGogAkEIaikCADcCAAsCQCAELQBEQQJGBEBBBSAEEPk6IQIgBCgCICIDRQ0BIARBLGogBCgCJCAEKAIoIAMoAhARAQAMAQsgBEHoAGogBEHEAGooAgA2AgAgBEHgAGogBEE8aikCADcDACAEIAQpAjQ3A1ggBEH4AGogBEEQaiICQQhqKQIANwMAIAQgAikCADcDcCMAQRBrIgIkACABIARB8ABqIARB2ABqEJIDQf8BcUECRgRAQdyowwBBFyACQQ9qQcCmwwBB9KjDABDVHgALIAJBEGokACAAIAFB2AH8CgAADAILIAEQ+C4gASACNgIIIAFCAzcDACAAIAFB2AH8CgAADAELIAAgAUHYAfwKAAAgAxDeOwsgBEGAAWokAAv2AgECfyMAQfAEayILJAACQCADIARGBEAgAEEANgIAIAlFIANBAktyIQEMAQsCQAJAIApBA00EQCAJRQ0BIARB5wdNBEBBAyEBIAAoAgBBAkYNBAsgBEEKIAprIAh0QQN2SQ0CIAMgBCAIQQFrdk8NAQwCC0F/IQpBfyEMIAkEQCAHIAggASACEIQgIQwLIAAoAgAEQCAGIAEgAhDuFSEKCyALIAUgBCACEIE7IgMgASAEIAIgBEH/D0sQ9AYiBUGIf00EQCALQfAAakGABCALIAIgAxD7JiEFCyACQQFqIQNBACEJA0AgAwRAQQEgASgCACICQQh0IgYgBG4iByAEIAZLGyAHIAIbQQJ0QfCO0QBqKAIAIAJsIAlqIQkgA0EBayEDIAFBBGohAQwBCwtBAyEBIAogDE8gBUEDdCAJQQh2aiICIAxPcQ0BIAIgCk8NAgsgAEEBNgIAQQIhAQwBC0EAIQEgAEEANgIACyALQfAEaiQAIAEL/gIBBn4gACkDCCICIAEpAwAiA4VC88rRy6eM2bL0AIUiBCAAKQMAIgZC4eSV89bs2bzsAIV8IgUgBEIQiYUiBCACQu3ekfOWzNy35ACFIgIgBkL1ys2D16zbt/MAhXwiBkIgiXwiByAEQhWJhUKAgICAgICAgAiFIgRCEIkgBCAFIAYgAkINiYUiAnwiBkIgiXwiBIUiBUIViSAFIAYgAkIRiYUiAiADIAeFfCIDQiCJfCIGhSIFQhCJIAUgBCADIAJCDYmFIgJ8IgNCIIlC/wGFfCIEhSIFQhWJIAUgAyACQhGJhSICIAZCgICAgICAgIAIhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULxQMCA38EfiMAQbABayICJAAgACgCBCgCECABajAAACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAubAwIPfwF+IwBB0ABrIgIkACACQQRqIAFBNGoQygYCQCABKAJMIgUEQCAFIAUoAgAiA0EBajYCACADQQBIDQEgASgCXCEIIAEoAlghCSABKAJUIQogASgCUCELIAEoAmAhBwsgASgCGCEGIAJBxABqIAFBDGoQygYgASgCHCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiwhDCABKAIoIQ0gASgCJCEOIAEoAiAhDyABKAIwIQQLIAJBEGoiECABELwVIAJBJGogAkHMAGooAgA2AgAgAiAGNgIoIAIgBDYCQCACIAw2AjwgAiANNgI4IAIgDjYCNCACIA82AjAgAiADNgIsIAIgAikCRDcCHCABKAJAIgMgAygCACIGQQFqNgIAIAZBAEgNACAAIAIpAgQ3AjQgACAHNgJgIAAgCDYCXCAAIAk2AlggACAKNgJUIAAgCzYCUCAAIAU2AkwgAEE8aiACQQxqKAIANgIAIAEpAkQhESAAIBBBNPwKAAAgACARNwJEIAAgAzYCQCACQdAAaiQADwsAC78DAQZ/IwBBMGsiAiQAIAIgACgCBCIDQYCU69wDayADIANB/5Pr3ANLIgUbIgM2AgggACgCACIEQTxuIgZBPHAhB0EBIQACQCABIARBkBxuELUoDQAgAUE6EIM2DQAgASAHELUoDQAgAUE6EIM2DQAgASAEIAZBPGxrIAVqELUoDQAgA0UEQEEAIQAMAQsgAyADQcCEPW4iAEHAhD1sRgRAIAJBATYCJCACQdjFhgE2AiAgAkEBNgIUIAJBtMWGATYCECACQQE2AhwgAkE7NgIsIAIgADYCDCACIAJBKGo2AhggAiACQQxqNgIoIAEgAkEQahDROSEADAELIAMgA0HoB24iAEHoB2xGBEAgAkEBNgIkIAJB8MWGATYCICACQQE2AhQgAkG0xYYBNgIQIAJBATYCHCACQTs2AiwgAiAANgIMIAIgAkEoajYCGCACIAJBDGo2AiggASACQRBqENE5IQAMAQsgAkEBNgIkIAJBiMaGATYCICACQQE2AhQgAkG0xYYBNgIQIAJBATYCHCACQTs2AiwgAiACQShqNgIYIAIgAkEIajYCKCABIAJBEGoQ0TkhAAsgAkEwaiQAIAALsgMCBX8CfiMAQTBrIgQkAAJAAkACQAJAAkACQCABKQMAIglQBEAgAEEEOgAADAELIAMoAgQiBSADKAIIIgZJDQEgBEIANwIIIAQgAygCACAGaiIINgIAIAQgCDYCECAEQv////8PIAkgCUL/////D1obpyIHIAUgBmsiBSAFIAdLGzYCBCAEQRhqIAEoAggoAgAgAiAEEM0SIAQtABhBBUYEQCAAQQU6AAAMAQsgBCkDGCIKQv8Bg0IEUgRAIAAgCjcCAAwBCyAEKAIIIgcgBCgCBCICSw0CIAQgBCgCACICNgIUIAIgCEcNAyAGIAdqIgIgAygCDCIFSwRAIAMgAjYCDCACIQULIAIgBkkNBCACIAVLDQUgAyACNgIIIABBBDoAACABIAkgB619NwMACyAEQTBqJAAPCyAGIAVBpKHDABCvOwALIAcgAkG0ocMAELA7AAsgBEEANgIYIARBFGogBEEQaiAEQRhqQYijwwAQ9SoAC0HEocMAQQ9BmKPDABDLJAALIARBADYCKCAEQQE2AhwgBEGcocMANgIYIARCBDcCICAEQRhqQZijwwAQ7ywAC7kDAQt/AkACQAJAAkACQAJAIAcoAogQQQBOBEAgBygCsBAiDiAHKALsD3EiCCABKAIAIg8gBygCrBAiECAHKALoDyILbCAHKALYDyINIAsgCyANSiIRG2ogDmsiCSAJIA9LIhIbIglqIgogCEkNAiAKIAcoAtwOIgxLDQMgBygC2A4gCGohCiAEKAIAIgwgCWohCAJAIAJFDQAgCCAMSQ0FIAMgCEkNBiAJRQ0AIAIgDGogCiAJ/AoAAAsgBCAINgIAIAEgDyAJazYCACAHIAkgDmoiATYCsBAgBSABNgIAQQEgBygC4BB0IQECQCASRQRAIBENCCABIAtGDQEMCAsgBiABIAtGcg0CIAAgCTYCCCAAIAo2AgQgAEEBNgIADwsgByALIA1HOgCREyAHIBBBAWo2AqwQIAcgDSALazYC2A8MBgsgAEEANgIIIABC9////x83AgAPCyAAQQA2AgggAEKDgICAEDcCAA8LIAggCkH0pfMAELE7AAsgCiAMQfSl8wAQsDsACyAMIAhBhKbzABCxOwALIAggA0GEpvMAELA7AAsgACAJNgIIIAAgCjYCBCAAQQE2AgALrgMBBX8jAEEwayIDJAACQAJAAkACQAJAAkACQCACQQNxBEAgAyACNgIoIANBAzYCJCADQbbk/gA2AiAgA0KAgICAgICAgIB/NwIYIANCgICAgMAANwIQQYSAgIB4IQUMAQtBfyACQQRqIgQgAiAESxsiBSABKAIEIgRNBEAgASABKAIUQQRqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAUQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAMAQsgAiAETw0BIAJBAXIiBSAETw0CIAJBAnIiBiAETw0DIAJBA3IiByAETw0EIAAgASgCACIBIAVqLQAAQQh0IAEgAmotAAByIAEgBmotAABBEHRyIAEgB2otAABBGHRyNgIEQYqAgIB4IQULIAAgBTYCACADQTBqJAAPCyACIARB8OH+ABDDIQALIAUgBEGA4v4AEMMhAAsgBiAEQZDi/gAQwyEACyAHIARBoOL+ABDDIQALrgMBBX8jAEEwayIDJAACQAJAAkACQAJAAkACQCACQQNxBEAgAyACNgIoIANBAzYCJCADQcb2/gA2AiAgA0KAgICAgICAgIB/NwIYIANCgICAgMAANwIQQYSAgIB4IQUMAQtBfyACQQRqIgQgAiAESxsiBSABKAIEIgRNBEAgASABKAIUQQRqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAUQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAMAQsgAiAETw0BIAJBAXIiBSAETw0CIAJBAnIiBiAETw0DIAJBA3IiByAETw0EIAAgASgCACIBIAVqLQAAQQh0IAEgAmotAAByIAEgBmotAABBEHRyIAEgB2otAABBGHRyNgIEQYqAgIB4IQULIAAgBTYCACADQTBqJAAPCyACIARBhPX+ABDDIQALIAUgBEGU9f4AEMMhAAsgBiAEQaT1/gAQwyEACyAHIARBtPX+ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQJ0ajUCACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQN0aikDACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQF0ajMBACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALmwMBBX8jAEEgayIDJAAgA0EUaiACQQBBBEEEEKAYIAMoAhghBgJAIAMoAhRBAUcEQCADKAIcIQQgAkECdCIFBEAgBCABIAX8CgAACyADIAI2AhwgAyAENgIYIAMgBjYCFCACRQ0BIAQgBWpBBGsiAUUNASABKAIADQEgAkECdCEBIARBBGshBSACQf////8DcSEEAkADQCABRQRAQQAhAQwCCyAEQQFrIQQgASAFaiABQQRrIQEoAgBFDQALIARBAWoiASACSw0CCyADIAE2AhwgASECDAELIAYgAygCHEH8iYgBEP0vAAsCQCACIAZBAnZPDQAgAyADQRRqIAJBBEEEEPQUIAMoAgAiAUGBgICAeEYNACABIAMoAgRBzI2IARD9LwALIANBEGoiASADQRxqKAIAIgI2AgAgAyADKQIUNwMIAkAgAgRAIAAgAykDCDcCACAAQQI6AAwgAEEIaiABKAIANgIADAELIABBCGpBlIqIASkCADcCACAAQYyKiAEpAgA3AgAgA0EIakEEQQQQ4B4LIANBIGokAAuIAwEHfyMAQRBrIgQkAAJAAkACQAJAIAEoAgQiAgRAIAEoAgAhBiACQQNxIQUCQCACQQRJBEBBACECDAELIAZBHGohAyACQXxxIQhBACECA0AgAygCACADQQhrKAIAIANBEGsoAgAgA0EYaygCACACampqaiECIANBIGohAyAIIAdBBGoiB0cNAAsLIAUEQCAHQQN0IAZqQQRqIQMDQCADKAIAIAJqIQIgA0EIaiEDIAVBAWsiBQ0ACwsgASgCDEUNAiACQQ9LDQEgBigCBA0BDAMLQQAhAiABKAIMRQ0CCyACQQAgAkEAShtBAXQhAgtBACEDIAJBAE4EQCACRQ0BQQEhAyACQQEQrTYiBQ0CCyADIAJBuMGJARD9LwALQQEhBUEAIQILIARBADYCCCAEIAU2AgQgBCACNgIAIARB9MCJASABEMsKRQRAIAAgBCkCADcCACAAQQhqIARBCGooAgA2AgAgBEEQaiQADwtBmMKJAUHWACAEQQ9qQYjCiQFB8MKJARDVHgALrwMCBX8CfiMAQTBrIgQkAAJAAkACQAJAAkACQCABKQMAIglQBEAgAEEEOgAADAELIAMoAgQiBSADKAIIIgZJDQEgBEIANwIIIAQgAygCACAGaiIINgIAIAQgCDYCECAEQv////8PIAkgCUL/////D1obpyIHIAUgBmsiBSAFIAdLGzYCBCAEQRhqIAEoAgggAiAEEM0SIAQtABhBBUYEQCAAQQU6AAAMAQsgBCkDGCIKQv8Bg0IEUgRAIAAgCjcCAAwBCyAEKAIIIgcgBCgCBCICSw0CIAQgBCgCACICNgIUIAIgCEcNAyAGIAdqIgIgAygCDCIFSwRAIAMgAjYCDCACIQULIAIgBkkNBCACIAVLDQUgAyACNgIIIABBBDoAACABIAkgB619NwMACyAEQTBqJAAPCyAGIAVBpKHDABCvOwALIAcgAkG0ocMAELA7AAsgBEEANgIYIARBFGogBEEQaiAEQRhqQYijwwAQ9SoAC0HEocMAQQ9BmKPDABDLJAALIARBADYCKCAEQQE2AhwgBEGcocMANgIYIARCBDcCICAEQRhqQZijwwAQ7ywAC40DAQJ/IAQgACgABCIFa0GBgICAek8EQCABIAEoAgg2AhAgACAAKAIUQQFqNgIUIAAgA0EBIAIoAgR0IgZBASACKAIIIAIoAhxBBUtrdCIEIAQgBkkbIAMgBWsiAyAEQQFrcSIFakECIAQgBEECTRtBACAFQQJJG2oiBGs2AgQgACADIARrIgMgACgCCGo2AgggAEECIAAoAhAiBCADayAEIANBAmoiBUkbNgIQIABBAiAAKAIMIgQgA2sgBCAFSRs2AgwgACgCXEEBIAIoAgx0IAMQgjsgAigCHCEEAkACQCAAKAJsDQAgBEEBRg0BIARBA2tBAksNACACKAKEAUEBRg0BC0EBIAIoAgh0IQIgACgCZCEFIARBBkYEQCAFIAIgA0EBELQbDAELIAUgAiADEII7CyAAKAIgIgIEQCAAKAJgQQEgAnQgAxCCOwsgASgCDCICIAEoAhBLBEAgASACNgIQCyAAQQA2ArQBIABBADYCGCAAIAAoAhwiACADayIBQQAgACABTxs2AhwLC7gDAgJ/An4jAEGQAWsiAiQAAkACQAJAIAAoAgQoAhAgAUEEdGoiAykDCCADKQMAIgRCgICAgICAgICAf30gBFStfFBFDQAgAiAAKAIAIgMoAgAoAgApAwAiBTcDSCACIAQ3A0AgAkEQaiAEIARCP4cgBSAFQj+HEKgeIAIpAxggAikDECIEQj+HUgRAIAJBAjYCbCACQayQ/wA2AmggAkICNwJ0IAJBhgw2AowBIAJBhgw2AoQBIAIgAkGAAWo2AnAgAiACQcgAajYCiAEgAiACQUBrNgKAASACQdgAaiACQegAahCZDiACQTRqIAJB3ABqKQIANwIAIAJBPGogAkHkAGooAgA2AgAgAkGIgICAeDYCVCACIAIpAlQ3AiwgAkEBNgIoIAJBKGpBBHIQiBEMAQsgBCADKAIELQAAEMUpRQ0AIAAoAgggAUEDdGogBDcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGQAWokAA8LIAAgA0GIi/8AEMMhAAvlCQIVfwF9IwBBIGsiByQAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAmggAS0ACmo2AmgMAwsgACAAKAJoIAEoAghqNgJoDAILIAEtAAEhBCABLQACIQEjAEEgayIFJAAgACABOgB5IAAgBDoAeCAAIAAoAmxBAWoiATYCbAJAAkACQCAAKAJkIgQgAUEDdEEHcksNACAAKAJgIQYgBUEIaiIBIARBAXQQoxUgBSABQcyCzgAQmCEgBCAFKAIEIgJLDQEgBSgCACEIIAQEQEEAIQEDQCABIAhqIAEgBmoqAgA4AgAgAUEEaiEBIARBAWsiBA0ACyAAKAJkIQEgACACNgJkIAAoAmAgACAINgJgIAFFDQEgAUECdEEEEPg6DAELIAAgAjYCZCAAIAg2AmALIAVBIGokAAwBCyAFQQA2AhggBUEBNgIMIAVB4NLMADYCCCAFQgQ3AhAgBUEIakGk0swAEO8sAAsMAQsgB0IANwMQQQchCQNAIAwgACgCaCIFSQRAIAdBEGogCWogACAFIAlqQQhrQbTSzAAQqSgtAAA6AAALIAxBAWohDCAJQQFrIglBf0cNAAsgASgCCCIFBEAgASgCBCEJQQAhDCAFIQEDQCAHQRBqIgggDEEGakEHcXItAAAhBiAAKAIcIgQoAgQhAyAHQQhqIAggDEEBa0EHcSICci0AACAGIAQoAgAgAyAEKAIQBH8gBCgCDC0AAAVBAAsgAC0AeBC1GyAHLQAMGiAHKAIIIQQgByAHKQMQNwMYIAktAAAhCCMAQRBrIgYkACAGIAdBGGoiAyACai0AADoACCAGIAMgAkEBakEHcWotAAA6AA8gBiADIAJBAmpBB3FqLQAAOgAOIAYgAyACQQNqQQdxai0AADoADSAGIAMgAkEEc2otAAA6AAwgBiADIAJBBWpBB3FqLQAAOgALIAYgAyACQQZqQQdxai0AADoACiAGIAMgAkEBa0EHcWotAAA6AAkgBkEIaiESIwBBIGsiAyQAIAAoAmQiDiAAKAJsIg1BA3QiE2siAkEAIAIgDk0bIRQgAEEkaiEKIAhB8AFxQQR2IQ8gACgCYCIQIA1BBXRqIQsgAC8BdiERIAAvAXQhFUEAIQICQAJAA0AgA0EQaiAKQQRrKAIAIAooAgAgAiASai0AACAEQQAgAxDvFSADIAMpAxA3AhggA0EYaiIWIA8Q+hYhFyACIBRGDQEgCyAXIAsqAgCSOAIAIBYgDyAVIBEQuBYgCkEIaiEKIAtBBGohCyACQQFqIgJBCEcNAAsgAEEkaiEKIAhBD3EhCCAQIA1BBXRqIQsgAC8BciENIAAvAXAhEEEAIQICQANAIANBCGogCkEEaygCACAKKAIAIAIgEmotAAAgBEEBIA8Q7xUgAyADKQMINwIYIANBGGoiESAIEPoWIRcgAiAURg0BIAsgFyALKgIAkjgCACARIAggECANELgWIApBCGohCiALQQRqIQsgAkEBaiICQQhHDQALIANBIGokAAwCCyACIBNqIA5B/NTMABDDIQALIAIgE2ogDkGM1cwAEMMhAAsgBkEQaiQAIAdBEGogDGogCS0AADoAACAMQQFqQQdxIQwgCUEBaiEJIAFBAWsiAQ0ACwsgACAAKAJoIAVqNgJoCyAHQSBqJAALwAMCA38DfiMAQbABayICJAAgACgCBCgCECABajEAACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALnwMBDn8jAEEQayIDJAAgASgCECENIAEoAgwiBCAEKAIAIgJBAWo2AgACQAJAIAJBAEgNACADIAQ2AgAgBCgCCCIIIAgoAgAiAkEBajYCACACQQBIDQAgASgCBCEFIAQoAgwhDiADQQRqIAEoAggiCUEAQQRBCBCgGCADKAIIIQIgAygCBEEBRg0BIAMoAgwhCgJAIAJFDQAgCUEDdCEHIAohBiACIQsDQCAHRQ0BIAUoAgAiDCAMKAIAIg9BAWo2AgAgD0EASA0CIAZBBGogBSgCBDYCACAGIAw2AgAgBkEIaiEGIAdBCGshByAFQQhqIQUgC0EBayILDQALCyAAQQA2AhwgACAONgIUIAAgCDYCECAAQSA6AAwgACANNgIYIAAgCTYCCCAAIAo2AgQgACACNgIAIAQgBCgCACIAQQFrNgIAIABBAUYEQCADEPgjCyABQQxqIgAoAgAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAAQ+CMLIAEQwycgAUEEQQgQ4B4gA0EQaiQADwsACyACIAMoAgxBlO6FARD9LwALhQMBCn8jAEEQayIDJAACQAJAAkAgASgCCCIEBEAgASgCBCEJIARBA3QhBQNAIAYgCWoiCygCACAIaiIIIAJLDQIgB0EBaiEHIAUgBkEIaiIGRw0ACwsgACABKQIANwIAIAFCgICAgMAANwIAIABBCGogAUEIaiIAKAIANgIAIABBADYCAAwBCyADQQRqIAQgB2siDEEAQQRBCBCgGCADKAIIIQogAygCBEEBRg0BIAMoAgwhBSABIAc2AgggBEEDdCAGayIEBEAgBSALIAT8CgAACyADIAw2AgwgAyAFNgIIIAMgCjYCBCAFKAIAIgQgCCACayICRwRAIAUtAAQhCCAHIAEoAgBGBH8gAUGMgc0AEJsoIAEoAgQFIAkLIAZqIgYgBCACazYCACAGQQRqIAg6AAAgASAHQQFqNgIICyAFIAI2AgAgA0EEaiABQQMQ+iogAEEIaiADQQxqKAIANgIAIAAgAykCBDcCAAsgA0EQaiQADwsgCiADKAIMQfyAzQAQ/S8AC50DAQN/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCUHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJQdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQDQAJAAkAgBiAEQQN2IgFLBEAgBEEHcUH8xM4Aai0AACABIAVqLQAAcUUNAiAIQQFrIgggA08NASACIARqIgEtAAAhCSABIAIgCGoiAS0AADoAACABIAk6AAAMAgsgASAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuBAwEFfyACKAIgIgcEQCADQv8BViADQv+BBFZqIANC/v///w9WaiEGC0G6fyEFAkAgAUESSQ0AQQAgBEEARyAEQf8BS2ogBEH//wNLaiACKAIoGyIIIAIoAiRBAEpBAnRqQSBBACAHQQBHIANBASACKAIEIgl0rVhxIgcbciAGQQZ0ciEFQQAhASACKAIARQRAIABBqOq+aTYAAEEEIQELIAAgAWogBToAACABQQFyIQUgB0UEQCAAIAVqIAlBA3RB0ABrOgAAIAFBAnIhBQsCQAJAAkACQCAIQQFrDgMAAQIDCyAAIAVqIAQ6AAAgBUEBaiEFDAILIAAgBWogBDsAACAFQQJqIQUMAQsgACAFaiAENgAAIAVBBGohBQsCQAJAAkACQCAGQQFrDgMBAgMACyAHRQ0DIAAgBWogAzwAACAFQQFqDwsgACAFaiADp0GAAms7AAAgBUECag8LIAAgBWogAz4AACAFQQRqDwsgACAFaiADNwAAIAVBCGohBQsgBQupAwELfyMAQRBrIgUkACAAIAEoAtAQIAEoAtQQIAFBuAFqIAFBkBtqIAEoArgSEKwJIgJBiH9NBEAgASgCuBIhAiABKALUECEGIAAoAhQhCCAAKAIQIQkgACgCGCEKIAAoAgAhAyAAKAIEIAEoApAbIQcgACgCDCAAKAIIIQQgBUH/ATYCDCAEayEAIANrQQN1IQMCQAJAAkACQCAHDgQDAAEBAgtBASEADAILIAIgBUEMaiAEIAAgAkHYxQAQ4CVBiH9LDQEgBiACIAUoAgwQ5SMhBCAHQQJGBEAgASgClBwgBGohBAsgAEH//wBLQQRBAyAAQf8HSxtqIAQgBEEGaiAAQYACSRtqIQAMAQtBACEACyABKAKcHCAKIANBHyAGQYgIakEAQZD40ABBBSACELcWQQRBAyADQf/9AUsbQQNBAiADQf8ASxtqIABqaiABKAKYHCAJIANBIyAGQbgZakHA+dAAQcD30ABBBiACELcWaiABKAKgHCAIIANBNCAGQYwOakHw+dAAQdD40ABBBiACELcWaiABKAKsHWohAgsgBUEQaiQAIAILiQMBA38CQAJAIABBBk8EQCAAQYIBTwRAIABBwhBPBEAgAEHCME8EQCABKAIEIQIgAEHCsAFPBEAgAgRAIAEoAgAiAyAAQQh0QemD4QJrNgIADAcLQQBBAEHI/9EAEMMhAAsgAgRAIAEoAgAiAyAAQQh0QeqD4QBrNgIADAYLQQBBAEHY/9EAEMMhAAsgASgCBCICBEAgASgCACIDIABBCHRB64MhazYCAAwFC0EAQQBB6P/RABDDIQALIAEoAgQiAgRAIAEoAgAiAyAAQcIAayIAZ0EgakE/cyIEQX8gBHQgAGpBCHRyQQpqNgIADAQLQQBBAEH4/9EAEMMhAAsgASgCBCICRQ0BIAEoAgAiAyAAQQJrIgAgACAAZ0EgakE/c0EBayIAdiIEIAB0a0EIdCAEIABBAXRqQQJqcjYCAAwCCyABKAIEIgIEQCABKAIAIgMgADYCAAwCC0EAQQBBmIDSABDDIQALQQBBAEGIgNIAEMMhAAsgASACQQFrNgIEIAEgA0EEajYCAAuwAwEEfyMAQUBqIgIkAAJAAkACQAJAAkACQCABKAIkBEAgAkEYaiABENw7IAIoAhxFDQEgAkEsaiACKAIYIAEQrxIgAkEoaiIDIAJBNGooAgA2AgAgAiACKQIsNwMgIAIoAjghBCACKAI8IQUgAkEQaiABEO88IAIoAhRFDQIgAEEMaiACKAIQIAQgBRDWCCAAQQhqIAMoAgA2AgAgACACKQMgNwIADAYLQQBBwAAQ0TRFDQMgAkEANgI8IAJCgICAgIAINwI0IAJCwAA3AiwgAkEIaiACQSxqENc7IAIoAgghBEEcQQQQrTYiA0UNBCADQoGAgIAQNwIAIAMgAikCLDcCCCADQRBqIAJBNGopAgA3AgAgA0EYaiACQTxqKAIANgIAIAIgARDvPCACKAIERQ0CIABBDGogAigCAEEAQQAQ1gggAEEANgIIIAAgBDYCBCAAIAM2AgAMBQtBAEEAQeDR/gAQwyEAC0EAQQBB8NH+ABDDIQALQQBBAEGA0v4AEMMhAAtBgMj+AEEpIAJBLGpB/Mj+AEGsyP4AENUeAAtBBEEcEKM9AAsgAkFAayQAC8UDAwN/BH4BfSMAQZABayIDJAAgASgCCCEEIAMgASgCDCgCECACQQJ0aioCACIKOAIMIANBEGogBCgCACsDACAKu6IQoSQQowYgBCgCBCEFAkACQAJ+IAMoAhBBAXFFBEAgBCgCCCEBIANBzJH/ADYCWCADQgQ3AmQgA0GFDDYCjAEgA0H0CzYChAEgAyABNgKAASADQbsHNgJ8IAMgBTYCeCADQcwBNgJ0IANBjJL/ADYCcCADIANB8ABqNgJgIAMgA0EMajYCiAEgA0EENgJcIANByABqIANB2ABqEJkOIANBCGogA0HMAGooAgA2AgAgA0GCgICAeDYCRCADIAMpAkQ3AwAgAykCUAwBCyADQRBqIAMpAyAiBiADKQMoIgcgAykDMCIIIAMpAzgiCSAFLQAAENAOIAMoAhBBk4CAgHhGDQEgA0EIaiADQRhqKAIANgIAIAMgAykCEDcDACADKQIcCyEGIAAgAykDADcCACAAIAY3AgwgAEEIaiADQQhqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBkAFqJAALowMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQJ0aigCACEDIAIgACgCACIFKAIAKAIAIgQ2AiAgAiADNgIcAkACQAJAAkACQCAEBEAgA0GAgICAeEYgBEF/RnFFBEAgAyAEbSEDDAMLIAJBAjYCPCACQZiQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMMAgsgAkGHgICAeDYCCAsgAkEIahCIEQwBCyADIAUoAgQtAAAQxClFDQAgACgCCCABQQJ0aiADNgIADAELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC6MDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAUEDdGooAgAhAyACIAAoAgAiBSgCACgCACIENgIgIAIgAzYCHAJAAkACQAJAAkAgBARAIANBgICAgHhGIARBf0ZxRQRAIAMgBG0hAwwDCyACQQI2AjwgAkGYkP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDDAILIAJBh4CAgHg2AggLIAJBCGoQiBEMAQsgAyAFKAIELQAAEMQpRQ0AIAAoAgggAUECdGogAzYCAAwBCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAv3AgEIfwJAAkACQAJAIAFBAXYgAWoiBQRAIAIoAgAhCANAAkACfyABIAVBAWsiBU0EQCAFIAFrDAELIAAoAgAhAiAAIAAgBUECdGoiBigCADYCACAGIAI2AgBBAAsiBkEBdCIEQQFyIgIgASAFIAEgBUkbIgpPDQADQCAIKAIEIQMgBEECaiIHIApJBEAgACACQQJ0aigCACIEIANPDQUgACAHQQJ0aigCACIHIANPDQYgAiAIKAIAIgkgBEECdGooAgAgCSAHQQJ0aigCAEhqIQILIAAgBkECdGoiBygCACIGIANPDQYgACACQQJ0aiIJKAIAIgQgA08NByAIKAIAIgMgBkECdGooAgAgAyAEQQJ0aigCAE4NASAHIAlBARD6KiACIQYgAkEBdCIEQQFyIgIgCkkNAAsLIAUNAAsLDwsgBCADQfD2gwEQwyEACyAHIANBgPeDARDDIQALIAYgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEAC/cCAQh/AkACQAJAAkAgAUEBdiABaiIFBEAgAigCACEIA0ACQAJ/IAEgBUEBayIFTQRAIAUgAWsMAQsgACgCACECIAAgACAFQQJ0aiIGKAIANgIAIAYgAjYCAEEACyIGQQF0IgRBAXIiAiABIAUgASAFSRsiCk8NAANAIAgoAgQhAyAEQQJqIgcgCkkEQCAAIAJBAnRqKAIAIgQgA08NBSAAIAdBAnRqKAIAIgcgA08NBiACIAgoAgAiCSAEQQJ0aigCACAJIAdBAnRqKAIASWohAgsgACAGQQJ0aiIHKAIAIgYgA08NBiAAIAJBAnRqIgkoAgAiBCADTw0HIAgoAgAiAyAGQQJ0aigCACADIARBAnRqKAIATw0BIAcgCUEBEPoqIAIhBiACQQF0IgRBAXIiAiAKSQ0ACwsgBQ0ACwsPCyAEIANB8PaDARDDIQALIAcgA0GA94MBEMMhAAsgBiADQfD2gwEQwyEACyAEIANBgPeDARDDIQAL9wIBCH8CQAJAAkACQCABQQF2IAFqIgUEQCACKAIAIQgDQAJAAn8gASAFQQFrIgVNBEAgBSABawwBCyAAKAIAIQIgACAAIAVBAnRqIgYoAgA2AgAgBiACNgIAQQALIgZBAXQiBEEBciICIAEgBSABIAVJGyIKTw0AA0AgCCgCBCEDIARBAmoiByAKSQRAIAAgAkECdGooAgAiBCADTw0FIAAgB0ECdGooAgAiByADTw0GIAIgCCgCACIJIARBA3RqKQMAIAkgB0EDdGopAwBUaiECCyAAIAZBAnRqIgcoAgAiBiADTw0GIAAgAkECdGoiCSgCACIEIANPDQcgCCgCACIDIAZBA3RqKQMAIAMgBEEDdGopAwBaDQEgByAJQQEQ+iogAiEGIAJBAXQiBEEBciICIApJDQALCyAFDQALCw8LIAQgA0Hw9oMBEMMhAAsgByADQYD3gwEQwyEACyAGIANB8PaDARDDIQALIAQgA0GA94MBEMMhAAv3AgEIfwJAAkACQAJAIAFBAXYgAWoiBQRAIAIoAgAhCANAAkACfyABIAVBAWsiBU0EQCAFIAFrDAELIAAoAgAhAiAAIAAgBUECdGoiBigCADYCACAGIAI2AgBBAAsiBkEBdCIEQQFyIgIgASAFIAEgBUkbIgpPDQADQCAIKAIEIQMgBEECaiIHIApJBEAgACACQQJ0aigCACIEIANPDQUgACAHQQJ0aigCACIHIANPDQYgAiAIKAIAIgkgBEEDdGopAwAgCSAHQQN0aikDAFNqIQILIAAgBkECdGoiBygCACIGIANPDQYgACACQQJ0aiIJKAIAIgQgA08NByAIKAIAIgMgBkEDdGopAwAgAyAEQQN0aikDAFkNASAHIAlBARD6KiACIQYgAkEBdCIEQQFyIgIgCkkNAAsLIAUNAAsLDwsgBCADQfD2gwEQwyEACyAHIANBgPeDARDDIQALIAYgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEAC78DAgJ/AX4jAEHQAGsiBCQAIAQgAzoAHyAEIAI3AwggBCABNwMAIAACfwJAIANB/wFxIgNBJ08EQCAEQQI2AjwgBEHsjYUBNgI4IARCAjcCRCAEQbsHNgIsIARBuwc2AiQgBEHAjYUBNgIgIAQgBEEgajYCQCAEIARBH2o2AiggAEEEaiAEQThqEJkODAELIAEgA0EEdCIFQbCChQFqIgMpAwBYIAIgBUG4goUBaikDACIGVyACIAZRG0UEQCAEQQM2AiQgBEGojYUBNgIgIARCAzcCLCAEQfoaNgJMIAQgAzYCSCAEQbsHNgJEIARB+ho2AjwgBCAEQThqNgIoIAQgBEEfajYCQCAEIAQ2AjggAEEEaiAEQSBqEJkODAELQZOAgIB4IAEgBUGgh4UBaiIDKQMAWiACIAVBqIeFAWopAwAiAVkgASACURsNARogBEEDNgIkIARB0IyFATYCICAEQgM3AiwgBEH6GjYCTCAEIAM2AkggBEG7BzYCRCAEQfoaNgI8IAQgBEE4ajYCKCAEIARBH2o2AkAgBCAENgI4IABBBGogBEEgahCZDgtBjYCAgHgLNgIAIARB0ABqJAAL0AMBAn8gACABEJg+IQICQAJAIAAoAgQiA0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQEgACADEJY+IgBB0POKASgCAEYEQCACKAIEQQNxQQNHDQFByPOKASABNgIAIAAgASACEIkuDAILIAAgAxCFDwsCQAJAAkAgAigCBCIDQQJxRQRAIAJB1POKASgCAEYNAiACQdDzigEoAgBGDQMgAiADQXhxIgIQhQ8gACABIAJqIgEQ0DQgAEHQ84oBKAIARw0BQcjzigEgATYCAA8LIAAgASACEIkuCyABQYACTwRAIAAgARDsEA8LAn9BwPOKASgCACICQQEgAUEDdnQiA3FFBEBBwPOKASACIANyNgIAIAFB+AFxQbjxigFqIgEMAQsgAUH4AXEiAkG48YoBaiEBIAJBwPGKAWooAgALIQIgASAANgIIIAIgADYCDCAAIAE2AgwgACACNgIIDwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBCAAQdDzigEoAgBHDQFByPOKAUEANgIAQdDzigFBADYCAA8LQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLC+MCAQZ/AkAgAkUEQAwBCyABIAJqIQggASEEA0ACfyAEIgUsAAAiA0EATgRAIANB/wFxIQMgBUEBagwBCyAFLQABQT9xIQQgA0EfcSEGIANBX00EQCAGQQZ0IARyIQMgBUECagwBCyAFLQACQT9xIARBBnRyIQQgA0FwSQRAIAQgBkEMdHIhAyAFQQNqDAELIAZBEnRBgIDwAHEgBS0AA0E/cSAEQQZ0cnIhAyAFQQRqCyEEAkAgA0EgRiADQQlrQQVJcg0AIANBgAFJDQICQCADQQh2IgZBH00EQCAGRQ0BIAZBFkcNBCADQYAtRg0CDAQLIAZBIEcEQCAGQTBHDQQgA0GA4ABGDQIMBAsgA0H/AXFB+9SJAWotAABBAnENAQwDCyADQf8BcUH71IkBai0AAEEBcUUNAgsgByAFayAEaiEHIAQgCEcNAAsgAiEHCyAAIAIgB2s2AgQgACABIAdqNgIAC7kCAQZ/QR8gAGdrIQAgAigCOEEBRgRAIAFBAmsiAmchAQJ/IAMEQEEfIAFrIgFBCHQgAkEIdCABdmoMAQtBgD4gAUEIdGsLIABBCHRqQYAgag8LIAFBA2shASACKAIMIABBAnRqKAIAQQFqIgVnIQQgAwR/IARBCHQgBUEIdEEfIARrdmtBgD5rBSAEQQh0QYA+awshBCACKAI0IQYgA0ECSSAAQRNLcSEFIABBCXQhByABQYABTwR/QcMAIAFnawUgAUHAr9EAai0AAAsiAUGAr9EAai0AACEIIAIoAgggAUECdGooAgBBAWoiCWchASACKAIwIQIgAwR/IAFBCHQgCUEIdEEfIAFrdmtBgD5rBSABQQh0QYA+awsgB0HNywBrQTMgBRsgBmogBGogAmogACAIakEIdGpqC50DAQZ/IwBBMGsiAyQAAkACQCABAn8CQAJAAkACQAJAAkAgAS0AIEEBaw4DBAEAAgsgASgCHCEFDAILAAsgA0EQaiIGIAFBCGooAgA2AgAgA0EcaiABQRRqKAIANgIAIAMgASkCADcDCCADIAEpAgw3AhQgASgCGCEHIAMQziIgAygCBCEFIAMoAgAhCEGwB0EIEK02IgRFDQQgBCADKQMINwMAIARBADoAICAEIAg2AhwgBCAHNgIYIARBEGogA0EYaikDADcDACAEQQhqIAYpAwA3AwAgBEG83sIAENQaIAEgBTYCHAsgA0EIaiAFQQhqIAIQqBQgAygCCEUNAUEBIQVBAwwCC0HM9sIAEOgrAAsgA0EoaiIEIANBGGooAgA2AgAgAyADKQIQNwMgIAMoAgwhAiABQRxqEK4sIAJFDQIgACADKQMgNwIIIABBEGogBCgCADYCACAAIAI2AgRBACEFQQELOgAgIAAgBTYCACADQTBqJAAPC0EIQbAHEKM9AAtBnODCAEErIANBCGpB+ODCAEHc9sIAENUeAAuLAwEEfyMAQSBrIgIkACACQQxqIAEQmxMgAi0AECEEIAACfyACKAIMIgNBBEcEQCAAIAIpABE3AAkgAEEQaiACQRhqKQAANwAAIAAgBDoACCAAIAM2AgRBAQwBCwJAAkACQAJAIARBD3EiA0EBaw4CAQACC0EAIQMLIAEgAzoAEkECIQMMAQsgAkEMaiADEKgSIAItABAhAyACKAIMIgVBBEcEQCAAIAIpABE3AAkgAEEQaiACQRhqKQAANwAAIAAgAzoACCAAIAU2AgRBAQwCCyADDQAgAkGAgICAeDYCDCAAQQRqIAJBDGogAhCvLUEADAELIAECfyAEQQ9NBEAgAkEMaiABEIYmIAIvARAiBCACKAIMIgVBBEYNARogACACKQESNwEKIABBEGogAkEYaikBADcBACAAIAQ7AQggACAFNgIEQQEMAgsgAS8BECAEQfABcUEEdmoLIgQ7ARAgACADOgAUIAAgBDsBEiAAQQE7ARAgAEGAgICAeDYCBEEACzYCACACQSBqJAALiwMBBH8jAEEgayICJAAgAkEMaiABEMQZIAItABAhBCAAAn8gAigCDCIDQQRHBEAgACACKQARNwAJIABBEGogAkEYaikAADcAACAAIAQ6AAggACADNgIEQQEMAQsCQAJAAkACQCAEQQ9xIgNBAWsOAgEAAgtBACEDCyABIAM6ABJBAiEDDAELIAJBDGogAxCoEiACLQAQIQMgAigCDCIFQQRHBEAgACACKQARNwAJIABBEGogAkEYaikAADcAACAAIAM6AAggACAFNgIEQQEMAgsgAw0AIAJBgICAgHg2AgwgAEEEaiACQQxqIAIQry1BAAwBCyABAn8gBEEPTQRAIAJBDGogARCHJiACLwEQIgQgAigCDCIFQQRGDQEaIAAgAikBEjcBCiAAQRBqIAJBGGopAQA3AQAgACAEOwEIIAAgBTYCBEEBDAILIAEvARAgBEHwAXFBBHZqCyIEOwEQIAAgAzoAFCAAIAQ7ARIgAEEBOwEQIABBgICAgHg2AgRBAAs2AgAgAkEgaiQAC9QIARB/IwBBIGsiBSQAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAkAgAS0ACmo2AkAMAwsgACAAKAJAIAEoAghqNgJADAILIAAgAS8AATsBzAYMAQsgBUIANwMQQQchBgNAIAggACgCQCINSQRAIAVBEGogBmogACAGIA1qQQhrQaDOzgAQqSgtAAA6AAALIAhBAWohCCAGQQFrIgZBf0cNAAsgASgCCCINBEAgASgCBCEGQQAhCCANIQEDQCAFQRBqIgMgCEEGakEHcXItAAAhAiAFQQhqIAMgCEEHaiIHQQdxci0AACACIAAoAhggACgCHCAAKAIoBH8gACgCJC0AAAVBAAsgAC0AzAYQtRsgBSgCCCELIAUgBSkDEDcDGCAFQRhqIAcgAC0AzQZrQQdxci0AACEJIAYtAAAhAiMAQfAAayIDJAAgA0EoaiAAKAIwIAAoAjQgCxCvGiAAQYwEaiADKAIoIgwgAygCLCIEIAJB8AFxQQR2IgcQuAogA0EwaiIPIAwgBBCnEiADQSBqIAAoAjAgACgCNCALIAcQrxkgAEHMA2ogAygCICIEIAMoAiQiCiACQQ9xIgwQuAogA0HQAGoiECAEIAoQpxIgA0EYaiEEIAAoAjghESAAKAI8IQojAEEgayICJAACQAJAIAlB/wFxQRF0IAtBCXRyIg4gCk0EQCAKIA5rQf8BTQ0BIARBgAI2AgQgBCARIA5BAXRqNgIAIAJBIGokAAwCCyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGo8NEAEO8sAAsgAkEANgIYIAJBATYCDCACQYDw0QA2AgggAkIENwIQIAJBCGpBuPDRABDvLAALIABBjAZqIAMoAhgiAiADKAIcIgQgDyAHEKgJIABBjAVqIAIgBCAHELgKIAIgBCAHEPgIIANBEGohBCAAKAI4IQ4gACgCPCEKIwBBIGsiAiQAAkACQCALQQl0IAlBD3FBEXRyIAdB/wFxQRV0ckGAAnIiCSAKTQRAIAogCWtB/wFNDQEgBEGAAjYCBCAEIA4gCUEBdGo2AgAgAkEgaiQADAILIAJBADYCGCACQQE2AgwgAkGA8NEANgIIIAJCBDcCECACQQhqQYjw0QAQ7ywACyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGY8NEAEO8sAAsgAEHMBWogAygCECICIAMoAhQiCSAQIAwQqAkgAEHMBGogAiAJIAwQuAogAiAJIAwQ+AggA0EIaiAAKAIwIAAoAjQgCxCvGiADKAIIIAMoAgwgBxD4CCADIAAoAjAgACgCNCALIAcQrxkgAygCACADKAIEIAwQ+AggA0HwAGokACAFQRBqIAhqIAYtAAA6AAAgCEEBakEHcSEIIAZBAWohBiABQQFrIgENAAsLIAAgACgCQCANajYCQAsgBUEgaiQAC+UEAQR/IwBB4ABrIg0kACANQRRqIAIgAyAEIAcgBRDvFiANKAIgIQMgDSgCHCEOIA0oAhQhDyANKAIYIQQjAEEQayICJAAgAkIANwMAIAJBADYCCCACQQA2AgxBAUIAIAkgCiALEOUSIAcgAiACQQhqIAJBDGoQvRlBAiACNQIMIAkgCiALEOUSIAIoAgggAikDACAJIAogCxDlEkEBQgEgCSAKIAsQ5RIgAkEQaiQAIAkgCiALELQpAkACQAJAAkACQCAEIAkoAgBBA3YiAmoiBSACTwRAIAUgC0sNASACIApqIAQgDyAEQbSt0AAQ1SwgCSAJKAIAIARBA3RqIgI2AgAgAkEDdiICIANqIgUgAkkNAiAFIAtLDQMgAiAKaiADIA4gA0HUrdAAENUsIAkgCSgCACADQQN0aiIFNgIAIwBBIGsiAiQAIAIgBUEHcSIQNgIEAkAgEEUEQCAFQQN2IgUgC0kNASAFIAtBnObRABDDIQALIAJBADYCCEEAIAJBBGpBmObRACACQQhqQazm0QAQrysACyAFIApqQQA6AAAgAkEgaiQAIAwNBSAGLQBRQQFxDQQMBQsgAiAFQaSt0AAQsTsACyAFIAtBpK3QABCwOwALIAIgBUHErdAAELE7AAsgBSALQcSt0AAQsDsACyANQRBqQQA2AgAgDUIANwIIIA0gBzYCBCANQRRqIgIQ8yggACANQQRqQQEgDyAEIA4gA0HkrdAAIAggAiAGQQQQpQELIAEEQEEBQgEgCSAKIAsQ5RJBAUIBIAkgCiALEOUSIAkgCiALELQpCyANQeAAaiQAC+IwARR/IwBBEGsiFyQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCABIgIgAkEBdmoiBgRAIAQoAgAhBwNAAkACfyACIAZBAWsiBk0EQCAGIAJrDAELIAAvAAAhASAAIAAgBkEBdGoiAy8AADsAACADIAE7AABBAAsiA0EBdCIEQQFyIgEgAiAGIAIgBkkbIg5PDQADQCAEQQJqIgQgDkkEQCAAIAFBAXRqIAAgBEEBdGogBygCACgCABECAEEfdiABaiEBCyAAIANBAXRqIgMgACABQQF0IgRqIgUgBygCACgCABECAEEATg0BIAMvAAAhCSADIAUvAAA7AAAgBSAJOwAAIAEhAyAEQQFyIgEgDkkNAAsLIAYNAAsLDAMLIAAgAUF4cWohBiAAIAFBA3YiDkEObGohBwJ/IAFBwABPBEAgACAGIAcgDiAEEMkYDAELIAAgACAGIAQoAgAiDigCACgCABECACIFIAAgByAOKAIAKAIAEQIAc0EASA0AGiAHIAYgBiAHIA4oAgAoAgARAgAgBXNBAEgbCyAAayIHQQF2IQYCQAJAIAJFDQAgAiAAIAdqIAQoAgAoAgAoAgARAgBBAEgNACAXIAQ2AgwCf0EAIAFFDQAaIBdBDGohAgJAIAEgBk0NACAALwAAIQcgACAAIAZBAXRqIgYvAAA7AAAgBiAHOwAAIABBAmohByMAQRBrIgUkACABQQFrIgwEfyAFIAcvAAA7AQ4gAigCACEJQQAhDiAHIgZBAmoiAiAGIAxBAXRqIgxBAmsiEEkEQCAGIQIDQCAAIAJBAmoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIA5BAXRqIgYvAAA7AAAgBiAKLwAAOwAAIAAgAkEEaiIGIAkoAgAoAgAoAgARAgAhFSAKIAcgDiASQX9zQR92aiIOQQF0aiIKLwAAOwAAIAogBi8AADsAACAOIBVBf3NBH3ZqIQ4gAkEGaiAGIQIgEEkNAAsgBkECaiECCyACIAxHBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAOQQF0aiIGLwAAOwAAIAYgAi8AADsAACAOIApBf3NBH3ZqIQ4gAiIGQQJqIgIgDEcNAAsgAkECayEGCyAAIAVBDmogCSgCACgCACgCABECACECIAYgByAOQQF0aiIGLwAAOwAAIAYgBS8BDjsAACAOIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgAC8AACEGIAAgACACQQF0aiIHLwAAOwAAIAcgBjsAACACDAELAAsiBkEBaiECIAEgBksEQCABIAJrIQEgACACQQF0aiEAQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAvAAAhByAAIAAgBkEBdGoiBi8AADsAACAGIAc7AAAgAEECaiEOIwBBEGsiCSQAIAFBAWsiCgR/IAkgDi8AADsBDiAEKAIAIQxBACEFIA4iB0ECaiIGIAcgCkEBdGoiCkECayISSQRAIAchBgNAIAZBAmoiECAAIAwoAgAoAgARAgAhFSAGIA4gBUEBdGoiBy8AADsAACAHIBAvAAA7AAAgBkEEaiIHIAAgDCgCACgCABECACAQIA4gFUEfdiAFaiIFQQF0aiIQLwAAOwAAIBAgBy8AADsAAEEfdiAFaiEFIAZBBmogByEGIBJJDQALIAZBAmohBgsgBiAKRwRAA0AgBiAAIAwoAgAoAgARAgAgByAOIAVBAXRqIgcvAAA7AAAgByAGLwAAOwAAQR92IAVqIQUgBiEHIAZBAmoiBiAKRw0ACyAGQQJrIQcLIAlBDmogACAMKAIAKAIAEQIAIAcgDiAFQQF0aiIHLwAAOwAAIAcgCS8BDjsAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAvAAAhByAAIAAgBkEBdGoiDi8AADsAACAOIAc7AAAgBgwBCwALIgYgAiADIAQQtg4gASAGQX9zaiEBIAAgBkEBdGoiAkECaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBQGoiBiQAAkACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgcgAUESSSIYGyECIAEgB2shByAAIAFBfnFqIQ4DQAJ/IAJBDE0EQEEBIAJBCE0NARoCQCACQQlPBEAgACAAQQZqIgkgACAEKAIAIgUoAgAoAgARAgAiDEEfdUEGcWovAAAhCiAAIABBBkEAIAxBAE4bai8AADsABiAAIAo7AAAgAEEOQQIgAEEOaiISIABBAmoiFSAFKAIAKAIAEQIAQQBIIgwbai8AACEKIAAgAEECQQ4gDBtqLwAAOwAOIAAgCjsAAiAAQQpBBCAAQQpqIgwgAEEEaiIQIAUoAgAoAgARAgBBAEgiChtqLwAAIQ0gACAAQQRBCiAKG2ovAAA7AAogACANOwAEIABBEEEIIABBEGoiEyAAQQhqIgogBSgCACgCABECAEEASCING2ovAAAhCyAAIABBCEEQIA0bai8AADsAECAAIAs7AAggACASIAAgBSgCACgCABECACINQR91QQ5xai8AACELIAAgAEEOQQAgDUEAThtqLwAAOwAOIAAgCzsAACAAQQhBBCAKIBAgBSgCACgCABECAEEASCING2ovAAAhCyAAIABBBEEIIA0bai8AADsACCAAIAs7AAQgAEEQQQYgEyAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIQsgACAAQQZBECANG2ovAAA7ABAgACALOwAGIABBDEEKIABBDGoiDSAMIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQpBDCALG2ovAAA7AAwgACAPOwAKIAAgECAAIAUoAgAoAgARAgAiC0EddkEEcWovAAAhDyAAIAAgC0F/c0EddkEEcWovAAA7AAQgACAPOwAAIABBBkECIAkgFSAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEECQQYgCxtqLwAAOwAGIAAgDzsAAiAAQQpBCCAMIAogBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBCEEKIAsbai8AADsACiAAIA87AAggAEEQQQ4gEyASIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQ5BECALG2ovAAA7ABAgACAPOwAOIABBCEECIAogFSAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEECQQggCxtqLwAAOwAIIAAgDzsAAiAAQQxBBiANIAkgBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBBkEMIAsbai8AADsADCAAIA87AAYgAEEOQQogEiAMIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQpBDiALG2ovAAA7AA4gACAPOwAKIAAgFSAAIAUoAgAoAgARAgAiC0EedkECcWovAAAhDyAAIAAgC0F/c0EedkECcWovAAA7AAIgACAPOwAAIABBCEEEIAogECAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEEEQQggCxtqLwAAOwAIIAAgDzsABCAAQQpBBiAMIAkgBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBBkEKIAsbai8AADsACiAAIA87AAYgAEEQQQwgEyANIAUoAgAoAgARAgBBAEgiExtqLwAAIQsgACAAQQxBECATG2ovAAA7ABAgACALOwAMIABBBkEEIAkgECAFKAIAKAIAEQIAQQBIIhMbai8AACELIAAgAEEEQQYgExtqLwAAOwAGIAAgCzsABCAAQQpBCCAMIAogBSgCACgCABECAEEASCITG2ovAAAhCyAAIABBCEEKIBMbai8AADsACiAAIAs7AAggAEEOQQwgEiANIAUoAgAoAgARAgBBAEgiEhtqLwAAIRMgACAAQQxBDiASG2ovAAA7AA4gACATOwAMIABBBEECIBAgFSAFKAIAKAIAEQIAQQBIIhAbai8AACESIAAgAEECQQQgEBtqLwAAOwAEIAAgEjsAAiAAQQhBBiAKIAkgBSgCACgCABECAEEASCIJG2ovAAAhCiAAIABBBkEIIAkbai8AADsACCAAIAo7AAYgAEEMQQogDSAMIAUoAgAoAgARAgBBAEgiBRtqLwAAIQkgACAAQQpBDCAFG2ovAAA7AAwgACAJOwAKDAELAAtBCQwBCwJAIAJBDU8EQCAAIABBGGoiESAAIAQoAgAiBSgCACgCABECACIJQR91QRhxai8AACEMIAAgAEEYQQAgCUEAThtqLwAAOwAYIAAgDDsAACAAQRRBAiAAQRRqIg0gAEECaiIPIAUoAgAoAgARAgBBAEgiCRtqLwAAIQwgACAAQQJBFCAJG2ovAAA7ABQgACAMOwACIABBEkEEIABBEmoiDCAAQQRqIhMgBSgCACgCABECAEEASCIJG2ovAAAhCiAAIABBBEESIAkbai8AADsAEiAAIAo7AAQgAEEOQQYgAEEOaiILIABBBmoiCiAFKAIAKAIAEQIAQQBIIgkbai8AACEQIAAgAEEGQQ4gCRtqLwAAOwAOIAAgEDsABiAAQRZBCiAAQRZqIhYgAEEKaiIQIAUoAgAoAgARAgBBAEgiCRtqLwAAIRIgACAAQQpBFiAJG2ovAAA7ABYgACASOwAKIABBEEEMIABBEGoiEiAAQQxqIgkgBSgCACgCABECAEEASCIVG2ovAAAhCCAAIABBDEEQIBUbai8AADsAECAAIAg7AAwgAEEMQQIgCSAPIAUoAgAoAgARAgBBAEgiFRtqLwAAIQggACAAQQJBDCAVG2ovAAA7AAwgACAIOwACIABBBkEEIAogEyAFKAIAKAIAEQIAQQBIIhUbai8AACEIIAAgAEEEQQYgFRtqLwAAOwAGIAAgCDsABCAAQRZBCCAWIABBCGoiFSAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEEIQRYgCBtqLwAAOwAWIAAgFDsACCAAQRJBDiAMIAsgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBDkESIAgbai8AADsAEiAAIBQ7AA4gAEEUQRAgDSASIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQRBBFCAIG2ovAAA7ABQgACAUOwAQIAAgFSAAIAUoAgAoAgARAgAiCEEcdkEIcWovAAAhFCAAIAAgCEF/c0EcdkEIcWovAAA7AAggACAUOwAAIABBBEECIBMgDyAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEECQQQgCBtqLwAAOwAEIAAgFDsAAiAAQQxBBiAJIAogBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBBkEMIAgbai8AADsADCAAIBQ7AAYgAEEQQQ4gEiALIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQQ5BECAIG2ovAAA7ABAgACAUOwAOIABBFEESIA0gDCAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEESQRQgCBtqLwAAOwAUIAAgFDsAEiAAQRhBFiARIBYgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBFkEYIAgbai8AADsAGCAAIBQ7ABYgAEEMQQggCSAVIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQQhBDCAIG2ovAAA7AAwgACAUOwAIIABBEkEKIAwgECAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEEKQRIgCBtqLwAAOwASIAAgFDsACiAAQRZBECAWIBIgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBEEEWIAgbai8AADsAFiAAIBQ7ABAgAEEYQRQgESANIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQRRBGCARG2ovAAA7ABggACAIOwAUIAAgECAAIAUoAgAoAgARAgAiEUEfdUEKcWovAAAhCCAAIABBCkEAIBFBAE4bai8AADsACiAAIAg7AAAgAEEQQQYgEiAKIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQQZBECARG2ovAAA7ABAgACAIOwAGIABBDkEIIAsgFSAFKAIAKAIAEQIAQQBIIhEbai8AACEIIAAgAEEIQQ4gERtqLwAAOwAOIAAgCDsACCAAQRZBDCAWIAkgBSgCACgCABECAEEASCIRG2ovAAAhCCAAIABBDEEWIBEbai8AADsAFiAAIAg7AAwgAEEUQRIgDSAMIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQRJBFCARG2ovAAA7ABQgACAIOwASIAAgDyAAIAUoAgAoAgARAgAiEUEedkECcWovAAAhCCAAIAAgEUF/c0EedkECcWovAAA7AAIgACAIOwAAIABBCkEEIBAgEyAFKAIAKAIAEQIAQQBIIhEbai8AACEIIAAgAEEEQQogERtqLwAAOwAKIAAgCDsABCAAQRJBDCAMIAkgBSgCACgCABECAEEASCIRG2ovAAAhCCAAIABBDEESIBEbai8AADsAEiAAIAg7AAwgAEEQQQ4gEiALIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQQ5BECARG2ovAAA7ABAgACAIOwAOIABBFkEUIBYgDSAFKAIAKAIAEQIAQQBIIhYbai8AACERIAAgAEEUQRYgFhtqLwAAOwAWIAAgETsAFCAAQQZBAiAKIA8gBSgCACgCABECAEEASCIWG2ovAAAhESAAIABBAkEGIBYbai8AADsABiAAIBE7AAIgAEEIQQQgFSATIAUoAgAoAgARAgBBAEgiFhtqLwAAIREgACAAQQRBCCAWG2ovAAA7AAggACAROwAEIABBDEEKIAkgECAFKAIAKAIAEQIAQQBIIhYbai8AACERIAAgAEEKQQwgFhtqLwAAOwAMIAAgETsACiAAQRRBEiANIAwgBSgCACgCABECAEEASCING2ovAAAhFiAAIABBEkEUIA0bai8AADsAFCAAIBY7ABIgAEEEQQIgEyAPIAUoAgAoAgARAgBBAEgiDRtqLwAAIQ8gACAAQQJBBCANG2ovAAA7AAQgACAPOwACIABBCEEGIBUgCiAFKAIAKAIAEQIAQQBIIg0bai8AACEPIAAgAEEGQQggDRtqLwAAOwAIIAAgDzsABiAAQQ5BCiALIBAgBSgCACgCABECAEEASCING2ovAAAhDyAAIABBCkEOIA0bai8AADsADiAAIA87AAogAEEQQQwgEiAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIQ8gACAAQQxBECANG2ovAAA7ABAgACAPOwAMIABBBkEEIAogEyAFKAIAKAIAEQIAQQBIIg0bai8AACETIAAgAEEEQQYgDRtqLwAAOwAGIAAgEzsABCAAQQpBCCAQIBUgBSgCACgCABECAEEASCING2ovAAAhEyAAIABBCEEKIA0bai8AADsACiAAIBM7AAggAEEOQQwgCyAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIRMgACAAQQxBDiANG2ovAAA7AA4gACATOwAMIABBEkEQIAwgEiAFKAIAKAIAEQIAQQBIIgwbai8AACESIAAgAEEQQRIgDBtqLwAAOwASIAAgEjsAECAAQQhBBiAVIAogBSgCACgCABECAEEASCIMG2ovAAAhCiAAIABBBkEIIAwbai8AADsACCAAIAo7AAYgAEEMQQogCSAQIAUoAgAoAgARAgBBAEgiBRtqLwAAIQkgACAAQQpBDCAFG2ovAAA7AAwgACAJOwAKDAELAAtBDQsiBUEBayACTw0CIAIgBUcEQCAFQQF0IQUgAkEBdCECA0AgACAAIAVqIAQQvx4gAiAFQQJqIgVHDQALCyAYDQEgACADRiAHIQIgDiEADQALIAFBAXYhDCABQQF0QQJrIgcgBiICaiEJIAcgAyIAaiEOIAAgAUF+cWoiB0ECayEFIAQoAgAhBANAIAIgACAHIAcgACAEKAIAKAIAEQIAIgpBAE4iEBsvAAA7AAAgCSAOIAUgDiAFIAQoAgAoAgARAgAiEkEAThsvAAA7AAAgACAQQQF0aiEAIAcgCkEedkECcWohByAFIBJBH3UiCkEBdGohBSAOIApBf3NBAXRqIQ4gCUECayEJIAJBAmohAiAMQQFrIgwNAAsgBUECaiEEIAFBAXEEfyACIAAgByAAIARJIgIbLwAAOwAAIAcgACAET0EBdGohByAAIAJBAXRqBSAACyAERyAHIA5BAmpHcgRAEOQrAAsgAUEBdCIARQ0AIAMgBiAA/AoAAAsgBkFAayQADAELAAsLIBdBEGokAAvjEwIPfwN+IwBBgAZrIgwkAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAjAEEQayIIJAAgASIDIAFBAXZqIgUEQCAAIQIgBCgCACEEA0ACQAJ/IAMgBUEBayIFTQRAIAUgA2sMAQsgAiAFQQR0aiIAQQhqIgEpAAAhFCACKQAAIRUgAiAAKQAANwAAIAJBCGoiBikAACEWIAYgFDcAACABIBY3AAAgACAVNwAAQQALIgBBAXQiBkEBciIBIAMgBSADIAVJGyIHTw0AA0AgAiAAQQR0aiIJIAIgByAGQQJqIgBNBH8gAQUgAiABQQR0aiACIABBBHRqIAQoAgAoAgARAgBBH3YgAWoLIgBBBHRqIgYgBCgCACgCABECAEEATg0BQQAhAQNAIAEgCWoiCigAACENIAogASAGaiIKKAAANgAAIAogDTYAACABQQRqIgFBEEcNAAsgAEEBdCIGQQFyIgEgB0kNAAsLIAUNAAsLIAhBEGokAAwDCyAAIAFBA3YiB0HwAGxqIQUgACAHQQZ0aiEGAn8gAUHAAE8EQCAAIAYgBSAHIAQQzRgMAQsgACAAIAYgBCgCACIHKAIAKAIAEQIAIgggACAFIAcoAgAoAgARAgBzQQBIDQAaIAUgBiAGIAUgBygCACgCABECACAIc0EASBsLIABrIgZBBHYhBQJ/AkAgAkUNACACIAAgBmogBCgCACgCACgCABECAEEASA0AIAwgBDYCACMAQSBrIg4kAAJAIAFFBEBBACECDAELAkAgASAFTQ0AIAAgBUEEdGoiAkEIaiIFKQAAIRQgACkAACEVIAAgAikAADcAACAAQQhqIgopAAAhFiAKIBQ3AAAgBSAWNwAAIAIgFTcAACAAQRBqIQZBACEHIwBBEGsiCCQAIAFBAWsiDQR/IAhBCGogBkEIaikAADcDACAIIAYpAAA3AwAgDCgCACEJIAYiBUEQaiICIAUgDUEEdGoiDUEQayIRSQRAIAUhAgNAIAAgAkEQaiILIAkoAgAoAgAoAgARAgAhDyAGIAdBBHRqIgUpAAAhFCACQQhqIAVBCGoiECkAADcAACACIBQ3AAAgECACQRhqIhApAAA3AAAgBSALKQAANwAAIAAgAkEgaiIFIAkoAgAoAgAoAgARAgAhEiAGIAcgD0F/c0EfdmoiD0EEdGoiBykAACEUIBAgB0EIaiIQKQAANwAAIAsgFDcAACAQIAJBKGopAAA3AAAgByAFKQAANwAAIA8gEkF/c0EfdmohByACQTBqIAUhAiARSQ0ACyAFQRBqIQILIAIgDUcEQANAIAAgAiAJKAIAKAIAKAIAEQIAIREgBiAHQQR0aiILKQAAIRQgBUEIaiALQQhqIg8pAAA3AAAgBSAUNwAAIA8gAkEIaikAADcAACALIAIpAAA3AAAgByARQX9zQR92aiEHIAIiBUEQaiICIA1HDQALIAJBEGshBQsgACAIIAkoAgAoAgAoAgARAgAhCSAGIAdBBHRqIgIpAAAhFCAFQQhqIAJBCGoiBikAADcAACAFIBQ3AAAgBiAIQQhqKQMANwAAIAIgCCkDADcAACAHIAlBf3NBH3ZqBUEACyECIAhBEGokACABIAJNDQAgACACQQR0aiIFQQhqIgYpAAAhFCAAKQAAIRUgACAFKQAANwAAIAopAAAhFiAKIBQ3AAAgBiAWNwAAIAUgFTcAAAwBCwALIA5BIGokACACQQFqIQUgASACSwRAIAEgBWshAUEAIQIgACAFQQR0agwCCyAFIAFB0PHQABCvOwALIwBBIGsiESQAAkAgAUUEQEEAIQUMAQsCQCABIAVNDQAgACAFQQR0aiIFQQhqIgYpAAAhFCAAKQAAIRUgACAFKQAANwAAIABBCGoiDSkAACEWIA0gFDcAACAGIBY3AAAgBSAVNwAAIABBEGohB0EAIQgjAEEQayIJJAAgAUEBayILBH8gCUEIaiAHQQhqKQAANwMAIAkgBykAADcDACAEKAIAIQogByIGQRBqIgUgBiALQQR0aiILQRBrIg9JBEAgBiEFA0AgBUEQaiIOIAAgCigCACgCABECACEQIAcgCEEEdGoiBikAACEUIAVBCGogBkEIaiISKQAANwAAIAUgFDcAACASIAVBGGoiEikAADcAACAGIA4pAAA3AAAgBUEgaiIGIAAgCigCACgCABECACAHIBBBH3YgCGoiEEEEdGoiCCkAACEUIBIgCEEIaiISKQAANwAAIA4gFDcAACASIAVBKGopAAA3AAAgCCAGKQAANwAAQR92IBBqIQggBUEwaiAGIQUgD0kNAAsgBUEQaiEFCyAFIAtHBEADQCAFIAAgCigCACgCABECACAHIAhBBHRqIg4pAAAhFCAGQQhqIA5BCGoiECkAADcAACAGIBQ3AAAgECAFQQhqKQAANwAAIA4gBSkAADcAAEEfdiAIaiEIIAUhBiAFQRBqIgUgC0cNAAsgBUEQayEGCyAJIAAgCigCACgCABECACAHIAhBBHRqIgUpAAAhFCAGQQhqIAVBCGoiBykAADcAACAGIBQ3AAAgByAJQQhqKQMANwAAIAUgCSkDADcAAEEfdiAIagVBAAshBSAJQRBqJAAgASAFTQ0AIAAgBUEEdGoiBkEIaiIHKQAAIRQgACkAACEVIAAgBikAADcAACANKQAAIRYgDSAUNwAAIAcgFjcAACAGIBU3AAAMAQsACyARQSBqJAAgACAFIAIgAyAEELcOIAEgBUF/c2ohASAAIAVBBHRqIgJBEGoLIQAgA0EBayEDIAFBIU8NAAsLIwBBEGsiByQAIAFBAk8EQCAAIQICQAJAIAFBEGpBME0EQCABQQF2IQUgAUEPSw0BQQQhBiAMIAVBBHQiCGohAyAAIAhqIQggAUEHSwRAIAAgDCAEENwQIAggAyAEENwQDAMLIAwgAikAADcAACAMQQhqIAJBCGopAAA3AAAgAyAIKQAANwAAIANBCGogCEEIaikAADcAAEEBIQYMAgsACyACIAwgDCABQQR0aiIAIAQQrC0gAiAFQQR0IgNqIAMgDGogAEGAAWogBBCsLUEIIQYLQQAhACAHQQA2AghBACAGayEKIAIgBkEEdCIDaiENIAMgDGohCyAHIAU2AgwgASAFayEOIAdBCGohEQNAIAAgDiAFIBEgAEECdGooAgAiABsiCCAGSwRAIAwgAEEEdCIAaiEPIAggCmohCSAAIA1qIQggACALaiEAA0AgACAIKQAANwAAIABBCGogCEEIaikAADcAACAPIAAgBBCMGSAIQRBqIQggAEEQaiEAIAlBAWsiCQ0ACwtBASEAQQFxRQ0ACyAMIAEgAiAEEKwPCyAHQRBqJAALIAxBgAZqJAAL0TECAX4TfyMAQRBrIhckAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgASIDIAFBAXZqIgcEQCAAIQIgBCgCACEEA0ACQAJ/IAMgB0EBayIHTQRAIAcgA2sMAQsgAikAACEFIAIgAiAHQQN0aiIAKQAANwAAIAAgBTcAAEEACyIAQQF0IghBAXIiASADIAcgAyAHSRsiCk8NAANAIAIgAEEDdGoiBiACIAogCEECaiIATQR/IAEFIAIgAUEDdGogAiAAQQN0aiAEKAIAKAIAEQIAQR92IAFqCyIAQQN0aiIIIAQoAgAoAgARAgBBAE4NAUEAIQEDQCABIAZqIgkoAAAhCyAJIAEgCGoiCSgAADYAACAJIAs2AAAgAUEEaiIBQQhHDQALIABBAXQiCEEBciIBIApJDQALCyAHDQALCwwDCyAAIAFBA3YiCkE4bGohByAAIApBBXRqIQgCfyABQcAATwRAIAAgCCAHIAogBBDMGAwBCyAAIAAgCCAEKAIAIgooAgAoAgARAgAiBiAAIAcgCigCACgCABECAHNBAEgNABogByAIIAggByAKKAIAKAIAEQIAIAZzQQBIGwsgAGsiCEEDdiEHAkACQCACRQ0AIAIgACAIaiAEKAIAKAIAKAIAEQIAQQBIDQAgFyAENgIMAn9BACABRQ0AGiAXQQxqIQICQCABIAdNDQAgACkAACEFIAAgACAHQQN0aiIHKQAANwAAIAcgBTcAACAAQQhqIQgjAEEQayIGJAAgAUEBayILBH8gBiAIKQAANwMIIAIoAgAhCUEAIQogCCIHQQhqIgIgByALQQN0aiILQQhrIg5JBEAgByECA0AgACACQQhqIg0gCSgCACgCACgCABECACETIAIgCCAKQQN0aiIHKQAANwAAIAcgDSkAADcAACAAIAJBEGoiByAJKAIAKAIAKAIAEQIAIREgDSAIIAogE0F/c0EfdmoiCkEDdGoiDSkAADcAACANIAcpAAA3AAAgCiARQX9zQR92aiEKIAJBGGogByECIA5JDQALIAdBCGohAgsgAiALRwRAA0AgACACIAkoAgAoAgAoAgARAgAhDSAHIAggCkEDdGoiBykAADcAACAHIAIpAAA3AAAgCiANQX9zQR92aiEKIAIiB0EIaiICIAtHDQALIAJBCGshBwsgACAGQQhqIAkoAgAoAgAoAgARAgAhAiAHIAggCkEDdGoiBykAADcAACAHIAYpAwg3AAAgCiACQX9zQR92agVBAAshAiAGQRBqJAAgASACTQ0AIAApAAAhBSAAIAAgAkEDdGoiBykAADcAACAHIAU3AAAgAgwBCwALIgdBAWohAiABIAdLBEAgASACayEBIAAgAkEDdGohAEEAIQIMAgsgAiABQdDx0AAQrzsACyAAAn9BACABRQ0AGgJAIAEgB00NACAAKQAAIQUgACAAIAdBA3RqIgcpAAA3AAAgByAFNwAAIABBCGohCiMAQRBrIgkkACABQQFrIg0EfyAJIAopAAA3AwggBCgCACELQQAhBiAKIghBCGoiByAIIA1BA3RqIg1BCGsiE0kEQCAIIQcDQCAHQQhqIg4gACALKAIAKAIAEQIAIREgByAKIAZBA3RqIggpAAA3AAAgCCAOKQAANwAAIAdBEGoiCCAAIAsoAgAoAgARAgAgDiAKIBFBH3YgBmoiBkEDdGoiDikAADcAACAOIAgpAAA3AABBH3YgBmohBiAHQRhqIAghByATSQ0ACyAHQQhqIQcLIAcgDUcEQANAIAcgACALKAIAKAIAEQIAIAggCiAGQQN0aiIIKQAANwAAIAggBykAADcAAEEfdiAGaiEGIAchCCAHQQhqIgcgDUcNAAsgB0EIayEICyAJQQhqIAAgCygCACgCABECACAIIAogBkEDdGoiCCkAADcAACAIIAkpAwg3AABBH3YgBmoFQQALIQcgCUEQaiQAIAEgB00NACAAKQAAIQUgACAAIAdBA3RqIggpAAA3AAAgCCAFNwAAIAcMAQsACyIHIAIgAyAEELgOIAEgB0F/c2ohASAAIAdBA3RqIgJBCGohAAsgA0EBayEDIAFBIU8NAAsLIAAhAyMAQYACayIHJAACQAJAAkAgAUECSQ0AIAFBIEsNASABIAFBAXYiCiABQRJJIhgbIQIgASAKayEIIAAgCkEDdGohCgNAAn8gAkEMTQRAQQEgAkEITQ0BGgJAIAJBCU8EQCAAIABBGGoiCSAAIAQoAgAiBigCACgCABECACILQR91QRhxaikAACEFIAAgAEEYQQAgC0EAThtqKQAANwAYIAAgBTcAACAAQThBCCAAQThqIhMgAEEIaiIRIAYoAgAoAgARAgBBAEgiCxtqKQAAIQUgACAAQQhBOCALG2opAAA3ADggACAFNwAIIABBKEEQIABBKGoiCyAAQRBqIg4gBigCACgCABECAEEASCING2opAAAhBSAAIABBEEEoIA0baikAADcAKCAAIAU3ABAgAEHAAEEgIABBQGsiFCAAQSBqIg0gBigCACgCABECAEEASCIMG2opAAAhBSAAIABBIEHAACAMG2opAAA3AEAgACAFNwAgIAAgEyAAIAYoAgAoAgARAgAiDEEfdUE4cWopAAAhBSAAIABBOEEAIAxBAE4baikAADcAOCAAIAU3AAAgAEEgQRAgDSAOIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQRBBICAMG2opAAA3ACAgACAFNwAQIABBwABBGCAUIAkgBigCACgCABECAEEASCIMG2opAAAhBSAAIABBGEHAACAMG2opAAA3AEAgACAFNwAYIABBMEEoIABBMGoiDCALIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQShBMCAPG2opAAA3ADAgACAFNwAoIAAgDiAAIAYoAgAoAgARAgAiD0EbdkEQcWopAAAhBSAAIAAgD0F/c0EbdkEQcWopAAA3ABAgACAFNwAAIABBGEEIIAkgESAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEIQRggDxtqKQAANwAYIAAgBTcACCAAQShBICALIA0gBigCACgCABECAEEASCIPG2opAAAhBSAAIABBIEEoIA8baikAADcAKCAAIAU3ACAgAEHAAEE4IBQgEyAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEE4QcAAIA8baikAADcAQCAAIAU3ADggAEEgQQggDSARIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQQhBICAPG2opAAA3ACAgACAFNwAIIABBMEEYIAwgCSAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEYQTAgDxtqKQAANwAwIAAgBTcAGCAAQThBKCATIAsgBigCACgCABECAEEASCIPG2opAAAhBSAAIABBKEE4IA8baikAADcAOCAAIAU3ACggACARIAAgBigCACgCABECACIPQRx2QQhxaikAACEFIAAgACAPQX9zQRx2QQhxaikAADcACCAAIAU3AAAgAEEgQRAgDSAOIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQRBBICAPG2opAAA3ACAgACAFNwAQIABBKEEYIAsgCSAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEYQSggDxtqKQAANwAoIAAgBTcAGCAAQcAAQTAgFCAMIAYoAgAoAgARAgBBAEgiFBtqKQAAIQUgACAAQTBBwAAgFBtqKQAANwBAIAAgBTcAMCAAQRhBECAJIA4gBigCACgCABECAEEASCIUG2opAAAhBSAAIABBEEEYIBQbaikAADcAGCAAIAU3ABAgAEEoQSAgCyANIAYoAgAoAgARAgBBAEgiFBtqKQAAIQUgACAAQSBBKCAUG2opAAA3ACggACAFNwAgIABBOEEwIBMgDCAGKAIAKAIAEQIAQQBIIhMbaikAACEFIAAgAEEwQTggExtqKQAANwA4IAAgBTcAMCAAQRBBCCAOIBEgBigCACgCABECAEEASCIOG2opAAAhBSAAIABBCEEQIA4baikAADcAECAAIAU3AAggAEEgQRggDSAJIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQRhBICAJG2opAAA3ACAgACAFNwAYIABBMEEoIAwgCyAGKAIAKAIAEQIAQQBIIgYbaikAACEFIAAgAEEoQTAgBhtqKQAANwAwIAAgBTcAKAwBCwALQQkMAQsCQCACQQ1PBEAgACAAQeAAaiISIAAgBCgCACIGKAIAKAIAEQIAIglBH3VB4ABxaikAACEFIAAgAEHgAEEAIAlBAE4baikAADcAYCAAIAU3AAAgAEHQAEEIIABB0ABqIgwgAEEIaiIWIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQQhB0AAgCRtqKQAANwBQIAAgBTcACCAAQcgAQRAgAEHIAGoiCyAAQRBqIhQgBigCACgCABECAEEASCIJG2opAAAhBSAAIABBEEHIACAJG2opAAA3AEggACAFNwAQIABBOEEYIABBOGoiDyAAQRhqIg0gBigCACgCABECAEEASCIJG2opAAAhBSAAIABBGEE4IAkbaikAADcAOCAAIAU3ABggAEHYAEEoIABB2ABqIhUgAEEoaiIOIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQShB2AAgCRtqKQAANwBYIAAgBTcAKCAAQcAAQTAgAEFAayITIABBMGoiCSAGKAIAKAIAEQIAQQBIIhEbaikAACEFIAAgAEEwQcAAIBEbaikAADcAQCAAIAU3ADAgAEEwQQggCSAWIAYoAgAoAgARAgBBAEgiERtqKQAAIQUgACAAQQhBMCARG2opAAA3ADAgACAFNwAIIABBGEEQIA0gFCAGKAIAKAIAEQIAQQBIIhEbaikAACEFIAAgAEEQQRggERtqKQAANwAYIAAgBTcAECAAQdgAQSAgFSAAQSBqIhEgBigCACgCABECAEEASCIQG2opAAAhBSAAIABBIEHYACAQG2opAAA3AFggACAFNwAgIABByABBOCALIA8gBigCACgCABECAEEASCIQG2opAAAhBSAAIABBOEHIACAQG2opAAA3AEggACAFNwA4IABB0ABBwAAgDCATIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQcAAQdAAIBAbaikAADcAUCAAIAU3AEAgACARIAAgBigCACgCABECACIQQRp2QSBxaikAACEFIAAgACAQQX9zQRp2QSBxaikAADcAICAAIAU3AAAgAEEQQQggFCAWIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQQhBECAQG2opAAA3ABAgACAFNwAIIABBMEEYIAkgDSAGKAIAKAIAEQIAQQBIIhAbaikAACEFIAAgAEEYQTAgEBtqKQAANwAwIAAgBTcAGCAAQcAAQTggEyAPIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQThBwAAgEBtqKQAANwBAIAAgBTcAOCAAQdAAQcgAIAwgCyAGKAIAKAIAEQIAQQBIIhAbaikAACEFIAAgAEHIAEHQACAQG2opAAA3AFAgACAFNwBIIABB4ABB2AAgEiAVIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQdgAQeAAIBAbaikAADcAYCAAIAU3AFggAEEwQSAgCSARIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQSBBMCAQG2opAAA3ADAgACAFNwAgIABByABBKCALIA4gBigCACgCABECAEEASCIQG2opAAAhBSAAIABBKEHIACAQG2opAAA3AEggACAFNwAoIABB2ABBwAAgFSATIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQcAAQdgAIBAbaikAADcAWCAAIAU3AEAgAEHgAEHQACASIAwgBigCACgCABECAEEASCISG2opAAAhBSAAIABB0ABB4AAgEhtqKQAANwBgIAAgBTcAUCAAIA4gACAGKAIAKAIAEQIAIhJBH3VBKHFqKQAAIQUgACAAQShBACASQQBOG2opAAA3ACggACAFNwAAIABBwABBGCATIA0gBigCACgCABECAEEASCISG2opAAAhBSAAIABBGEHAACASG2opAAA3AEAgACAFNwAYIABBOEEgIA8gESAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEEgQTggEhtqKQAANwA4IAAgBTcAICAAQdgAQTAgFSAJIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQTBB2AAgEhtqKQAANwBYIAAgBTcAMCAAQdAAQcgAIAwgCyAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEHIAEHQACASG2opAAA3AFAgACAFNwBIIAAgFiAAIAYoAgAoAgARAgAiEkEcdkEIcWopAAAhBSAAIAAgEkF/c0EcdkEIcWopAAA3AAggACAFNwAAIABBKEEQIA4gFCAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEEQQSggEhtqKQAANwAoIAAgBTcAECAAQcgAQTAgCyAJIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQTBByAAgEhtqKQAANwBIIAAgBTcAMCAAQcAAQTggEyAPIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQThBwAAgEhtqKQAANwBAIAAgBTcAOCAAQdgAQdAAIBUgDCAGKAIAKAIAEQIAQQBIIhUbaikAACEFIAAgAEHQAEHYACAVG2opAAA3AFggACAFNwBQIABBGEEIIA0gFiAGKAIAKAIAEQIAQQBIIhUbaikAACEFIAAgAEEIQRggFRtqKQAANwAYIAAgBTcACCAAQSBBECARIBQgBigCACgCABECAEEASCIVG2opAAAhBSAAIABBEEEgIBUbaikAADcAICAAIAU3ABAgAEEwQSggCSAOIAYoAgAoAgARAgBBAEgiFRtqKQAAIQUgACAAQShBMCAVG2opAAA3ADAgACAFNwAoIABB0ABByAAgDCALIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQcgAQdAAIAwbaikAADcAUCAAIAU3AEggAEEQQQggFCAWIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQQhBECAMG2opAAA3ABAgACAFNwAIIABBIEEYIBEgDSAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEYQSAgDBtqKQAANwAgIAAgBTcAGCAAQThBKCAPIA4gBigCACgCABECAEEASCIMG2opAAAhBSAAIABBKEE4IAwbaikAADcAOCAAIAU3ACggAEHAAEEwIBMgCSAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEwQcAAIAwbaikAADcAQCAAIAU3ADAgAEEYQRAgDSAUIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQRBBGCAMG2opAAA3ABggACAFNwAQIABBKEEgIA4gESAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEgQSggDBtqKQAANwAoIAAgBTcAICAAQThBMCAPIAkgBigCACgCABECAEEASCIMG2opAAAhBSAAIABBMEE4IAwbaikAADcAOCAAIAU3ADAgAEHIAEHAACALIBMgBigCACgCABECAEEASCILG2opAAAhBSAAIABBwABByAAgCxtqKQAANwBIIAAgBTcAQCAAQSBBGCARIA0gBigCACgCABECAEEASCILG2opAAAhBSAAIABBGEEgIAsbaikAADcAICAAIAU3ABggAEEwQSggCSAOIAYoAgAoAgARAgBBAEgiBhtqKQAAIQUgACAAQShBMCAGG2opAAA3ADAgACAFNwAoDAELAAtBDQsiBkEBayACTw0CIAIgBkcEQCAGQQN0IQYgAkEDdCECA0AgACAAIAZqIAQQwR4gAiAGQQhqIgZHDQALCyAYDQEgACADRiAIIQIgCiEADQALIAFBA3RBCGsiCCAHIgJqIQkgCCADIgBqIQogACABQQF2IgtBA3RqIghBCGshBiAEKAIAIQQDQCACIAAgCCAIIAAgBCgCACgCABECACINQQBOIg4bKQAANwAAIAkgCiAGIAogBiAEKAIAKAIAEQIAIhNBAE4bKQAANwAAIAAgDkEDdGohACAIIA1BHHZBCHFqIQggBiATQR91Ig1BA3RqIQYgCiANQX9zQQN0aiEKIAlBCGshCSACQQhqIQIgC0EBayILDQALIAZBCGohBCABQQFxBH8gAiAAIAggACAESSICGykAADcAACAIIAAgBE9BA3RqIQggACACQQN0agUgAAsgBEcgCCAKQQhqR3IEQBDkKwALIAFBA3QiAEUNACADIAcgAPwKAAALIAdBgAJqJAAMAQsACwsgF0EQaiQAC+UwARR/IwBBEGsiFyQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCABIgIgAkEBdmoiBgRAIAQoAgAhBANAAkACfyACIAZBAWsiBk0EQCAGIAJrDAELIAAoAAAhASAAIAAgBkECdGoiAygAADYAACADIAE2AABBAAsiA0EBdCIHQQFyIgEgAiAGIAIgBkkbIgxPDQADQCAHQQJqIgcgDEkEQCAAIAFBAnRqIAAgB0ECdGogBCgCACgCABECAEEfdiABaiEBCyAAIANBAnRqIgMgACABQQJ0aiIHIAQoAgAoAgARAgBBAE4NASADKAAAIQUgAyAHKAAANgAAIAcgBTYAACABIQMgAUEBdCIHQQFyIgEgDEkNAAsLIAYNAAsLDAMLIAAgAUEDdiIMQRxsaiEGIAAgDEEEdGohBwJ/IAFBwABPBEAgACAHIAYgDCAEEMoYDAELIAAgACAHIAQoAgAiDCgCACgCABECACIFIAAgBiAMKAIAKAIAEQIAc0EASA0AGiAGIAcgByAGIAwoAgAoAgARAgAgBXNBAEgbCyAAayIHQQJ2IQYCQAJAIAJFDQAgAiAAIAdqIAQoAgAoAgAoAgARAgBBAEgNACAXIAQ2AgwCf0EAIAFFDQAaIBdBDGohAgJAIAEgBk0NACAAKAAAIQcgACAAIAZBAnRqIgYoAAA2AAAgBiAHNgAAIABBBGohByMAQRBrIgUkACABQQFrIg0EfyAFIAcoAAA2AgwgAigCACEJQQAhDCAHIgZBBGoiAiAGIA1BAnRqIg1BBGsiEEkEQCAGIQIDQCAAIAJBBGoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIAxBAnRqIgYoAAA2AAAgBiAKKAAANgAAIAAgAkEIaiIGIAkoAgAoAgAoAgARAgAhFSAKIAcgDCASQX9zQR92aiIMQQJ0aiIKKAAANgAAIAogBigAADYAACAMIBVBf3NBH3ZqIQwgAkEMaiAGIQIgEEkNAAsgBkEEaiECCyACIA1HBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAMQQJ0aiIGKAAANgAAIAYgAigAADYAACAMIApBf3NBH3ZqIQwgAiIGQQRqIgIgDUcNAAsgAkEEayEGCyAAIAVBDGogCSgCACgCACgCABECACECIAYgByAMQQJ0aiIGKAAANgAAIAYgBSgCDDYAACAMIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgACgAACEGIAAgACACQQJ0aiIHKAAANgAAIAcgBjYAACACDAELAAsiBkEBaiECIAEgBksEQCABIAJrIQEgACACQQJ0aiEAQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAoAAAhByAAIAAgBkECdGoiBigAADYAACAGIAc2AAAgAEEEaiEMIwBBEGsiCSQAIAFBAWsiCgR/IAkgDCgAADYCDCAEKAIAIQ1BACEFIAwiB0EEaiIGIAcgCkECdGoiCkEEayISSQRAIAchBgNAIAZBBGoiECAAIA0oAgAoAgARAgAhFSAGIAwgBUECdGoiBygAADYAACAHIBAoAAA2AAAgBkEIaiIHIAAgDSgCACgCABECACAQIAwgFUEfdiAFaiIFQQJ0aiIQKAAANgAAIBAgBygAADYAAEEfdiAFaiEFIAZBDGogByEGIBJJDQALIAZBBGohBgsgBiAKRwRAA0AgBiAAIA0oAgAoAgARAgAgByAMIAVBAnRqIgcoAAA2AAAgByAGKAAANgAAQR92IAVqIQUgBiEHIAZBBGoiBiAKRw0ACyAGQQRrIQcLIAlBDGogACANKAIAKAIAEQIAIAcgDCAFQQJ0aiIHKAAANgAAIAcgCSgCDDYAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAoAAAhByAAIAAgBkECdGoiDCgAADYAACAMIAc2AAAgBgwBCwALIgYgAiADIAQQuQ4gASAGQX9zaiEBIAAgBkECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBgAFrIgYkAAJAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIMIAFBEkkiGBshAiABIAxrIQcgACAMQQJ0aiEMA0ACfyACQQxNBEBBASACQQhNDQEaAkAgAkEJTwRAIAAgAEEMaiIJIAAgBCgCACIFKAIAKAIAEQIAIg1BH3VBDHFqKAAAIQogACAAQQxBACANQQBOG2ooAAA2AAwgACAKNgAAIABBHEEEIABBHGoiEiAAQQRqIhUgBSgCACgCABECAEEASCING2ooAAAhCiAAIABBBEEcIA0baigAADYAHCAAIAo2AAQgAEEUQQggAEEUaiINIABBCGoiECAFKAIAKAIAEQIAQQBIIgobaigAACEOIAAgAEEIQRQgChtqKAAANgAUIAAgDjYACCAAQSBBECAAQSBqIhMgAEEQaiIKIAUoAgAoAgARAgBBAEgiDhtqKAAAIQsgACAAQRBBICAOG2ooAAA2ACAgACALNgAQIAAgEiAAIAUoAgAoAgARAgAiDkEfdUEccWooAAAhCyAAIABBHEEAIA5BAE4baigAADYAHCAAIAs2AAAgAEEQQQggCiAQIAUoAgAoAgARAgBBAEgiDhtqKAAAIQsgACAAQQhBECAOG2ooAAA2ABAgACALNgAIIABBIEEMIBMgCSAFKAIAKAIAEQIAQQBIIg4baigAACELIAAgAEEMQSAgDhtqKAAANgAgIAAgCzYADCAAQRhBFCAAQRhqIg4gDSAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEUQRggCxtqKAAANgAYIAAgDzYAFCAAIBAgACAFKAIAKAIAEQIAIgtBHHZBCHFqKAAAIQ8gACAAIAtBf3NBHHZBCHFqKAAANgAIIAAgDzYAACAAQQxBBCAJIBUgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBBEEMIAsbaigAADYADCAAIA82AAQgAEEUQRAgDSAKIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQRBBFCALG2ooAAA2ABQgACAPNgAQIABBIEEcIBMgEiAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEcQSAgCxtqKAAANgAgIAAgDzYAHCAAQRBBBCAKIBUgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBBEEQIAsbaigAADYAECAAIA82AAQgAEEYQQwgDiAJIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQQxBGCALG2ooAAA2ABggACAPNgAMIABBHEEUIBIgDSAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEUQRwgCxtqKAAANgAcIAAgDzYAFCAAIBUgACAFKAIAKAIAEQIAIgtBHXZBBHFqKAAAIQ8gACAAIAtBf3NBHXZBBHFqKAAANgAEIAAgDzYAACAAQRBBCCAKIBAgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBCEEQIAsbaigAADYAECAAIA82AAggAEEUQQwgDSAJIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQQxBFCALG2ooAAA2ABQgACAPNgAMIABBIEEYIBMgDiAFKAIAKAIAEQIAQQBIIhMbaigAACELIAAgAEEYQSAgExtqKAAANgAgIAAgCzYAGCAAQQxBCCAJIBAgBSgCACgCABECAEEASCITG2ooAAAhCyAAIABBCEEMIBMbaigAADYADCAAIAs2AAggAEEUQRAgDSAKIAUoAgAoAgARAgBBAEgiExtqKAAAIQsgACAAQRBBFCATG2ooAAA2ABQgACALNgAQIABBHEEYIBIgDiAFKAIAKAIAEQIAQQBIIhIbaigAACETIAAgAEEYQRwgEhtqKAAANgAcIAAgEzYAGCAAQQhBBCAQIBUgBSgCACgCABECAEEASCIQG2ooAAAhEiAAIABBBEEIIBAbaigAADYACCAAIBI2AAQgAEEQQQwgCiAJIAUoAgAoAgARAgBBAEgiCRtqKAAAIQogACAAQQxBECAJG2ooAAA2ABAgACAKNgAMIABBGEEUIA4gDSAFKAIAKAIAEQIAQQBIIgUbaigAACEJIAAgAEEUQRggBRtqKAAANgAYIAAgCTYAFAwBCwALQQkMAQsCQCACQQ1PBEAgACAAQTBqIhEgACAEKAIAIgUoAgAoAgARAgAiCUEfdUEwcWooAAAhDSAAIABBMEEAIAlBAE4baigAADYAMCAAIA02AAAgAEEoQQQgAEEoaiIOIABBBGoiDyAFKAIAKAIAEQIAQQBIIgkbaigAACENIAAgAEEEQSggCRtqKAAANgAoIAAgDTYABCAAQSRBCCAAQSRqIg0gAEEIaiITIAUoAgAoAgARAgBBAEgiCRtqKAAAIQogACAAQQhBJCAJG2ooAAA2ACQgACAKNgAIIABBHEEMIABBHGoiCyAAQQxqIgogBSgCACgCABECAEEASCIJG2ooAAAhECAAIABBDEEcIAkbaigAADYAHCAAIBA2AAwgAEEsQRQgAEEsaiIWIABBFGoiECAFKAIAKAIAEQIAQQBIIgkbaigAACESIAAgAEEUQSwgCRtqKAAANgAsIAAgEjYAFCAAQSBBGCAAQSBqIhIgAEEYaiIJIAUoAgAoAgARAgBBAEgiFRtqKAAAIQggACAAQRhBICAVG2ooAAA2ACAgACAINgAYIABBGEEEIAkgDyAFKAIAKAIAEQIAQQBIIhUbaigAACEIIAAgAEEEQRggFRtqKAAANgAYIAAgCDYABCAAQQxBCCAKIBMgBSgCACgCABECAEEASCIVG2ooAAAhCCAAIABBCEEMIBUbaigAADYADCAAIAg2AAggAEEsQRAgFiAAQRBqIhUgBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBEEEsIAgbaigAADYALCAAIBQ2ABAgAEEkQRwgDSALIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQRxBJCAIG2ooAAA2ACQgACAUNgAcIABBKEEgIA4gEiAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEgQSggCBtqKAAANgAoIAAgFDYAICAAIBUgACAFKAIAKAIAEQIAIghBG3ZBEHFqKAAAIRQgACAAIAhBf3NBG3ZBEHFqKAAANgAQIAAgFDYAACAAQQhBBCATIA8gBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBBEEIIAgbaigAADYACCAAIBQ2AAQgAEEYQQwgCSAKIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQQxBGCAIG2ooAAA2ABggACAUNgAMIABBIEEcIBIgCyAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEcQSAgCBtqKAAANgAgIAAgFDYAHCAAQShBJCAOIA0gBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBJEEoIAgbaigAADYAKCAAIBQ2ACQgAEEwQSwgESAWIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQSxBMCAIG2ooAAA2ADAgACAUNgAsIABBGEEQIAkgFSAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEQQRggCBtqKAAANgAYIAAgFDYAECAAQSRBFCANIBAgBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBFEEkIAgbaigAADYAJCAAIBQ2ABQgAEEsQSAgFiASIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQSBBLCAIG2ooAAA2ACwgACAUNgAgIABBMEEoIBEgDiAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEoQTAgERtqKAAANgAwIAAgCDYAKCAAIBAgACAFKAIAKAIAEQIAIhFBH3VBFHFqKAAAIQggACAAQRRBACARQQBOG2ooAAA2ABQgACAINgAAIABBIEEMIBIgCiAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEMQSAgERtqKAAANgAgIAAgCDYADCAAQRxBECALIBUgBSgCACgCABECAEEASCIRG2ooAAAhCCAAIABBEEEcIBEbaigAADYAHCAAIAg2ABAgAEEsQRggFiAJIAUoAgAoAgARAgBBAEgiERtqKAAAIQggACAAQRhBLCARG2ooAAA2ACwgACAINgAYIABBKEEkIA4gDSAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEkQSggERtqKAAANgAoIAAgCDYAJCAAIA8gACAFKAIAKAIAEQIAIhFBHXZBBHFqKAAAIQggACAAIBFBf3NBHXZBBHFqKAAANgAEIAAgCDYAACAAQRRBCCAQIBMgBSgCACgCABECAEEASCIRG2ooAAAhCCAAIABBCEEUIBEbaigAADYAFCAAIAg2AAggAEEkQRggDSAJIAUoAgAoAgARAgBBAEgiERtqKAAAIQggACAAQRhBJCARG2ooAAA2ACQgACAINgAYIABBIEEcIBIgCyAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEcQSAgERtqKAAANgAgIAAgCDYAHCAAQSxBKCAWIA4gBSgCACgCABECAEEASCIWG2ooAAAhESAAIABBKEEsIBYbaigAADYALCAAIBE2ACggAEEMQQQgCiAPIAUoAgAoAgARAgBBAEgiFhtqKAAAIREgACAAQQRBDCAWG2ooAAA2AAwgACARNgAEIABBEEEIIBUgEyAFKAIAKAIAEQIAQQBIIhYbaigAACERIAAgAEEIQRAgFhtqKAAANgAQIAAgETYACCAAQRhBFCAJIBAgBSgCACgCABECAEEASCIWG2ooAAAhESAAIABBFEEYIBYbaigAADYAGCAAIBE2ABQgAEEoQSQgDiANIAUoAgAoAgARAgBBAEgiDhtqKAAAIRYgACAAQSRBKCAOG2ooAAA2ACggACAWNgAkIABBCEEEIBMgDyAFKAIAKAIAEQIAQQBIIg4baigAACEPIAAgAEEEQQggDhtqKAAANgAIIAAgDzYABCAAQRBBDCAVIAogBSgCACgCABECAEEASCIOG2ooAAAhDyAAIABBDEEQIA4baigAADYAECAAIA82AAwgAEEcQRQgCyAQIAUoAgAoAgARAgBBAEgiDhtqKAAAIQ8gACAAQRRBHCAOG2ooAAA2ABwgACAPNgAUIABBIEEYIBIgCSAFKAIAKAIAEQIAQQBIIg4baigAACEPIAAgAEEYQSAgDhtqKAAANgAgIAAgDzYAGCAAQQxBCCAKIBMgBSgCACgCABECAEEASCIOG2ooAAAhEyAAIABBCEEMIA4baigAADYADCAAIBM2AAggAEEUQRAgECAVIAUoAgAoAgARAgBBAEgiDhtqKAAAIRMgACAAQRBBFCAOG2ooAAA2ABQgACATNgAQIABBHEEYIAsgCSAFKAIAKAIAEQIAQQBIIg4baigAACETIAAgAEEYQRwgDhtqKAAANgAcIAAgEzYAGCAAQSRBICANIBIgBSgCACgCABECAEEASCING2ooAAAhEiAAIABBIEEkIA0baigAADYAJCAAIBI2ACAgAEEQQQwgFSAKIAUoAgAoAgARAgBBAEgiDRtqKAAAIQogACAAQQxBECANG2ooAAA2ABAgACAKNgAMIABBGEEUIAkgECAFKAIAKAIAEQIAQQBIIgUbaigAACEJIAAgAEEUQRggBRtqKAAANgAYIAAgCTYAFAwBCwALQQ0LIgVBAWsgAk8NAiACIAVHBEAgBUECdCEFIAJBAnQhAgNAIAAgACAFaiAEEL4eIAIgBUEEaiIFRw0ACwsgGA0BIAAgA0YgByECIAwhAA0ACyABQQJ0QQRrIgcgBiICaiEJIAcgAyIAaiEMIAAgAUEBdiINQQJ0aiIHQQRrIQUgBCgCACEEA0AgAiAAIAcgByAAIAQoAgAoAgARAgAiCkEATiIQGygAADYAACAJIAwgBSAMIAUgBCgCACgCABECACISQQBOGygAADYAACAAIBBBAnRqIQAgByAKQR12QQRxaiEHIAUgEkEfdSIKQQJ0aiEFIAwgCkF/c0ECdGohDCAJQQRrIQkgAkEEaiECIA1BAWsiDQ0ACyAFQQRqIQQgAUEBcQR/IAIgACAHIAAgBEkiAhsoAAA2AAAgByAAIARPQQJ0aiEHIAAgAkECdGoFIAALIARHIAcgDEEEakdyBEAQ5CsACyABQQJ0IgBFDQAgAyAGIAD8CgAACyAGQYABaiQADAELAAsLIBdBEGokAAviAgEJf0EBIQcCQCABQQFGDQAgAC0AACEIAkAgAUEPcSIEBEAgACAEaiEFIAAiAkEBaiIJIQMCfwJAIARBBU8EQCACKAAAIgIgACgAASIDRw0BIAVBA2shCkEAIQMCQANAIAAgA2oiAkEFaiIGIApPDQEgA0EEaiEDIAJBBGooAAAiAiAGKAAAIgZGDQALIAIgBnNoQQN2IANqDAMLIAJBBWohAyACQQRqIQILAkAgAyAFQQFrTw0AIAIvAAAgAy8AAEcNACACQQJqIQIgA0ECaiEDCyADIAVJBH8gAyACLQAAIAMtAABGagUgAwsgCWsMAQsgAiADc2hBA3YLIARBAWtHDQELIAhBgYKECGwhAyAAIARqIQIDQCABIARGDQJBACEAA0AgAEEPTQRAIAAgAmohBSAAQQRqIQAgAyAFKAAARg0BDAMLCyACQRBqIQIgBEEQaiEEDAALAAtBACEHCyAHC5YDAQN/IwBBMGsiAyQAAkACQCABQf//A3EgAkH//wNxRgRAIAAtADpBAUcNAQsgAEECIAAoAjQiAiACQQJNGzYCNCAAQTBqIQQCQCAAKAIwIgVBAXEiAiAAKAIIIAVrTQ0AIAAoAgggACgCMGsgAk8NAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAgggACgCMGtBAUsiAiACckUEQANAIAAQ+xYgACgCCCAAKAIwa0ECSQ0ACwsgBEECEI03IANBEGogABDcOyADKAIUIQIgAygCECEEIANBCGogACgCMBCMNyADIAQgAiADKAIIIAMoAgxBsLf+ABDXJiADKAIEQQFNDQEgAygCACABOwAAIAAoAjAhAiAAKAIUIgEgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgAUEDdGoiBEEEOwEEIAQgAjYCACAAIAFBAWo2AhQLIANBMGokAA8LIANBADYCKCADQQE2AhwgA0Hst/4ANgIYIANCBDcCICADQRhqQcC3/gAQ7ywAC5UDAQR/IwBBMGsiAiQAIAAoAgAhAAJAAkAgAUH//wNxBEAgAC0AOkEBRw0BCyAAQQIgACgCNCIDIANBAk0bNgI0IABBMGohBAJAIAAoAjAiBUEBcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EBSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQJJDQALCyAEQQIQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGwt/4AENcmIAIoAgRBAU0NASACKAIAIAE7AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQey3/gA2AhggAkIENwIgIAJBGGpBwLf+ABDvLAALmwMCA38BfiMAQeAAayICJAACQAJAAkAgACgCBCgCECABQQN0aikDACIFQoCAgIAIfEL/////D1YNACACIAAoAgAiBCgCACgCACgCACIDNgIgIAIgBT4CHAJAIAUgA6x+IgVCIIinIAWnIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIFNwMIIAWnQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuBBgELfyMAQSBrIgckAAJAAkACQAJAAkACQAJAAkAgAy0AAEEUaw4KAQACAAMEAAAABQALIAIEQANAIAEoAgAgAUEEaigCACgCJBEEACAEaiEEIAFBCGohASACQQFrIgINAAsLIABBhYCAgHg2AgAgACAENgIEDAULIAAgASACEK8YDAQLIAAgASACEK4YDAMLIAAgASACELAYDAILIAAgASACEK0YDAELIAIEQCABIQQgAiEGA0AgBCgCACAEQQRqKAIAKAIkEQQAIAhqIQggBEEIaiEEIAZBAWsiBg0ACwsgAygCCCIMLQAwIgNBHU1BAEEBIAN0QYCAwJoCcRtFBEAgAEGFgICAeDYCACAAIAg2AgQMAQsjAEEgayIDJAAgA0EUaiABIAJBA3RqIgIgAWtBA3ZBAEEEQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxB0MiCARD9LwALIAdBBGohCSADQRBqIg1BADYCACADIAMoAhw2AgwgAyAENgIIIwBBEGsiBiQAIAIgAWtBA3YiCiADQQhqIgUoAgAgBSgCCCIEa0sEQCAFIAQgCkEEQQgQ3iggBSgCCCEECyAGIAUoAgQ2AgwgBiAENgIIIAYgBUEIajYCBCAGQQRqIgQoAgQhBSAEKAIAIAEgAkcEQCAEKAIIIAVBA3RqIQQgBSACIAFrQQN2IgJqIQUDQCABKAIAIAFBBGooAgAQxi8iCygCDCEOIARBBGogCygCECILNgIAIAQgDiALKAIIQQFrQXhxakEIajYCACABQQhqIQEgBEEIaiEEIAJBAWsiAg0ACwsgBTYCACAGQRBqJAAgCUEIaiANKAIANgIAIAkgAykCCDcCACADQSBqJAAgB0EQaiAHKAIIIAcoAgwgDEEwahC+DkEQQQQQrTYiAUUNASABIAcpAhA3AgAgAUEIaiAHQRhqKQIANwIAIAAgATYCCCAAIAg2AgQgAEGCgICAeDYCACAJQQRBCBDgHgsgB0EgaiQADwtBBEEQEKM9AAuKAwEFfyMAQRBrIgckACAHQQhqIAEQhj0gBygCDCEIIAcoAggiCUEIEPgvIQUCQAJAAkACQAJAIAMgAyAEaiIGQQFqIgRNBEAgBCAAKAIEIgJLDQEgAUEIIAUgCWogBSAISyIJG0EAIAggBWtBA3YgCRtBA3RqQQhrKQMAIAAoAgAiBSADQQN0aiIIIAQgA2sQ+BMgAiADTQ0CIAIgBk0NBSAFIAZBA3RqKAIAIgIgCCgCACIDSQ0DIAAoAgwiBCACSQ0EIAAoAgghBCABKAIcIgAgAiADayICaiIFIAEoAhQiBksEQCABQRBqIAZBAXQiACAFEN4qIgUgACAFSxsQ6BkgASgCHCEACyACBEAgASgCGCAAaiADIARqIAL8CgAACyABIAEoAhwgAmo2AhwgB0EQaiQADwsgAyAEQfSjhwEQsTsACyAEIAJB9KOHARCwOwALIAMgAkGEo4cBEMMhAAsgAyACQaSjhwEQsTsACyACIARBpKOHARCwOwALIAYgAkGUo4cBEMMhAAuKAwEFfyMAQRBrIgckACAHQQhqIAEQhj0gBygCDCEIIAcoAggiCUEEEPgvIQUCQAJAAkACQAJAIAMgAyAEaiIGQQFqIgRNBEAgBCAAKAIEIgJLDQEgAUEEIAUgCWogBSAISyIJG0EAIAggBWtBAnYgCRtBAnRqQQRrKAIAIAAoAgAiBSADQQJ0aiIIIAQgA2sQ+RMgAiADTQ0CIAIgBk0NBSAFIAZBAnRqKAIAIgIgCCgCACIDSQ0DIAIgACgCDCIESw0EIAAoAgghBCABKAIcIgAgAiADayICaiIFIAEoAhQiBksEQCABQRBqIAZBAXQiACAFEN4qIgUgACAFSxsQ6BkgASgCHCEACyACBEAgASgCGCAAaiADIARqIAL8CgAACyABIAEoAhwgAmo2AhwgB0EQaiQADwsgAyAEQfSjhwEQsTsACyAEIAJB9KOHARCwOwALIAMgAkGEo4cBEMMhAAsgAyACQaSjhwEQsTsACyACIARBpKOHARCwOwALIAYgAkGUo4cBEMMhAAu8BAEKfyMAQRBrIgMkAAJ/AkACQANAAkAgAC0AACICQSJHBEACQAJAAkACQAJAAkACQAJAAkAgAkEbaw4NBAAGAQIHCA0NDQ0NAw0LIAEtAABBHEcNDAwECyABLQAAQR5HDQsMAwsgAS0AAEEfRw0KDAILIAEtAABBJ0YNBgwJCyABLQAAQRtHDQgLIAAoAgRBCGogASgCBEEIahDxCgwICyABLQAAQR1HDQYgACgCBCABKAIERw0FIAAoAghBCGogASgCCEEIahDxCgwHCyABLQAAQSBHDQUgAEEEaiABQQRqEM8cDAYLIAEtAABBIUcNBCAALQABIAEtAAFHDQMgACgCCCECIAMgACgCBEEIaiIANgIIIAMgACACQQN0ajYCDAJ/IAFBBGohAUEAIANBCGoiBCgCACIAIAQoAgQiB0YNABogASgCAEEMaiECIAEoAgQiBUEDdCEIIAVFIQYDQAJAIAQgAEEIaiIJNgIAIAVFDQAgACgCBEEIaiEKIAAtAAAhCyAIIQEgAiEAAkADQCAAQQRrLQAAIAtGBEAgCiAAKAIAQQhqEPEKDQILIABBCGohACABQQhrIgENAAtBASEGDAELIAkiACAHRw0BCwsgBgtBAXMMBQsgAS0AAEEiRw0DIAAoAgQgASgCBBDBDkUNAiABKAIIIQEgACgCCCEADAELCyAALQABIAEtAAFHDQAgACgCBEEIaiABKAIEQQhqEPEKDAILQQAMAQsgACABEMwICyADQRBqJAALjAMBC38jAEEgayICJAAgASgCICEDIAJBBGogASgCJCIEQQBBAUEBEKAYIAIoAgghBQJAAkACQCACKAIEQQFHBEAgAigCDCEGIAQEQCAGIAMgBPwKAAALIAEtACkhAyABLQAoIQwCQCABLQAUIgdBEUcEQCAHQQRrDgUDBAEBAwQLIAEoAgQhCCABKAIAIQkMBAsgAS0AFSEKIAEtABYhCwwCCyAFIAIoAgxB5KPPABD9LwALIAJBGGogAUEfai0AADoAACACIAEpABc3AxAgAS0AFiELIAEtABUhCgsgASgCBCEIIAEoAgAhCSADDQAgAUEUahCaEEH/AXEhAwsgACALOgAeIAAgCjoAHSAAIAc6ABwgACAENgIYIAAgBjYCFCAAIAU2AhAgACAINgIMIAAgCTYCCCAAQQI2AgQgACACKQMQNwAfIAAgASkCCDcCLCAAQTRqIAFBEGooAgA2AgAgAEEnaiACQRhqLQAAOgAAIAAgAzoAKSAAIAw6ACggAEEANgIAIAJBIGokAAvCBAEKfyMAQTBrIgckAAJAIAEpAwBCBFIEQCMAQTBrIgMkACADQQA2AhQgA0KAgICAIDcCDAJAAkAgAkUNAANAIANBDGoiBEGACCACIAhrIgUgBUGACE8bIgUQhS0gA0EYaiABIAQgBRCZECADKAIgIQQgAygCHCEFIAMoAhgiCUEIRwRAIAAgAykCJDcCDCAAQRRqIANBLGooAgA2AgAgACAENgIIIAAgBTYCBCAAIAk2AgAMAwsgBEUNASAFIAZqIQYgBCAIaiIIIAJJDQALCyAAIAg2AgggACAGNgIEIABBCDYCAAsgA0EMahCdPCADQTBqJAAMAQtBCCEIAkACQCACRQ0AIAFBCGohCwNAAkAgASgCHCIERQRAIAEoAiAiBCABKAIkIgZGBEAgASgCGCABKAIQRg0EIAcgCxD7CiAHKAIAIgRBCEYNAiAAIAcpAgQ3AgQgAEEUaiAHQRRqKAIANgIAIABBDGogB0EMaikCADcCACAEIQgMBQsgByABKAIMIAEoAhAgASgCGCIMQQN0IAZqIAIgA2siCSAEIAZrIgogCSAKSRsiCRDQCCAHENcjIQogASAGIAlqIgY2AiQgBCAGRgRAIAEgDCAEQQN2ajYCGAsgAyAJaiEDIAUgCmohBQwBCyABIAQgAiADayIGIAQgBCAGSxsiBGs2AhwgAyAEaiEDIARBACABLQAoGyAFaiEFCyACIANHDQALIAIhAwsgACADNgIIIAAgBTYCBAsgACAINgIACyAHQTBqJAALlgMBBH8jAEEwayICJAAgACgCACEAAkACQCABQf//A3FFBEAgAC0AOkEBRw0BCyAAQQIgACgCNCIDIANBAk0bNgI0IABBMGohBAJAIAAoAjAiBUEBcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EBSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQJJDQALCyAEQQIQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGsx/4AENcmIAIoAgRBAU0NASACKAIAIAE7AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALrwMBAn8jAEHQAGsiBCQAIAQgAzYCAAJAIAEoAhQiBSACTQRAIAQgAkEBajYCMCAEIAU2AjQgBEEDNgIcIARBuPmGATYCGCAEQgM3AiQgBEE7NgJMIARBOzYCRCAEQa0DNgI8IAQgAUEYajYCOCAEIARBOGo2AiAgBCAEQTRqNgJIIAQgBEEwajYCQCAEQQhqIARBGGoQmQ4gACAEKQIMNwIIIABBEGogBEEUaigCADYCACAAIAQoAgg2AgQgAEGNgICAeDYCAAwBCyADIAEoAhAgAkHEAGxqIgJBGGoiAxDJCARAIARBOGogAhC5ASAEKAI4IgFBk4CAgHhHBEAgAEEEaiICIAQpAjw3AgAgAkEIaiAEQcQAaikCADcCACAAIAE2AgAMAgsgAEGTgICAeDYCACAAIAI2AgQMAQsgBEEDNgIcIARB3PiGATYCGCAEQgM3AiQgBEGtAzYCTCAEIAM2AkggBEGnBDYCRCAEQa0DNgI8IAQgAUEYajYCOCAEIARBOGo2AiAgBCAENgJAIABBBGogBEEYahCZDiAAQY2AgIB4NgIACyAEQdAAaiQAC9UDAgV/AX4jAEHgAGsiAyQAAkAgAQJ/AkACQAJAAkACQAJAIAEtAAxBAWsOAwQBAAILIAEoAgghBSABKAIEIQQMAgsACyABKAIAIgQpAjghCCAEQoCAgIAQNwM4IANBGGogBEFAayIFKAIANgIAIAVBADYCACADIAg3AxAgA0E8aiADQRBqEOcVIANBADoAWCADIAQ2AjggA0EIaiEEIANBOGohBgJAQSRBBBCtNiIFBEAgBSAGQST8CgAAIARBjKTDADYCBCAEIAU2AgAMAQtBBEEkEKM9AAsgAygCCCEEIAEgAygCDCIFNgIIIAEgBDYCBAsgA0E4aiAEIAIgBSgCDBEBACADKAI4IgJBCUcNASAAQQk2AgBBAwwCC0G018IAEOgrAAsgA0EwaiIGIANBzABqKAIANgIAQQghBSADQShqIgcgA0HEAGopAgA3AwAgAyADKQI8NwMgIAFBBGoQvCogAkEIRwRAQRhBCBCtNiIERQ0CIAQgAjYCACAEIAMpAyA3AgQgBEEMaiAHKQMANwIAIARBFGogBigCADYCAEEFIQULIABB1NfCADYCCCAAIAQ2AgQgACAFNgIAQQELOgAMIANB4ABqJAAPC0EIQRgQoz0AC+gUAg5/AW8jAEEgayIIJAACQAJAAkACQAJAIAAtAJABQQFrDgMDAAIBCwALIABBzABqIABBxAD8CgAACyAIQRBqIQ4jAEEQayIKJAACQAJAIABBzABqIgMoAgAEQCABIQtBACEBIwBB4ABrIgQkAAJAAkACQCADKAIALQAUBEBBAiEHDAELIANBBGohDwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAEBBAWsOAwYCAQALIA8oAgAiASgCCA0WIAFBfzYCCCADIAFBCGo2AhAgAyABQQxqIgE2AgwgA0EAOgA8IAMgATYCFCADIAMoAggiBzYCGCADQTxqIQYMAwsgA0E8aiEGAkAgAy0APEEBaw4DCAEAAgsgAygCMCEBIAMoAjghByADKAI0IQIMAwsACyADKAIYIQcgAygCFCEBCyADIAc2AiAgAyABNgIcIAEoAgxFDQwgBEEgaiICIANBIGooAgAlARA3IgU2AgQgAiAFQQBHNgIAIAQoAiBBAXFFDQwgAyAEKAIkNgIkIARBGGoiAiADQSRqKAIAJQEQFSIFNgIEIAIgBUEARzYCACAEKAIYQQFxRQ0MIAMgBCgCHDYCKCADIANBKGooAgAlARBgIgc2AiwgAygCHCIMKAIIIgIgB0kEQCAMIAcgAmsiAhCILiAMKAIEIgUgDCgCCCIHaiEJAkACQCACQQJPBEAgAkEBayICBEAgCUEAIAL8CwALIAUgAiAHaiIHaiEJDAELIAJFDQELIAlBADoAACAHQQFqIQcLIAwgBzYCCCADKAIsIQcgAygCHCIMKAIIIQILIAIgB0kNAyAMKAIEIQIgAyAHNgI4IAMgAjYCNCADIAFBDGoiATYCMAsgBEHQAGogASgCACALIAIgByABKAIEKAIMEQcAIAQtAFAiBUEFRg0BIARBLmoiASAELQBTOgAAIAQgBC8AUTsBLCAEKAJUIQkCQAJAIAVBBEcEQCAEIAU6ADAgBCAELwEsOwAxIAQgCTYCNCAEIAEtAAA6ADMCQCADKAIcIgYoAgwiAkUNACAGKAIQIgUoAgAiAQRAIAIgAREDAAsgBSgCBCIBRQ0AIAIgASAFKAIIEPg6CyAGQQA2AgwgBhDeOyAGQQA2AgggBkKAgICAEDcCACAEQQA2AkwgBEKAgICAEDcCRCAEQdjewwA2AlQgBEKggICADjcCWCAEIARBxABqNgJQIARBMGogBEHQAGoQ1A4NByAEQUBrIARBzABqKAIAIgE2AgAgBCAEKQJENwM4IAQoAjwgARBGIRAQ3xIiASAQJgEgBEE4ahDeOyAELQAwQQNHDQEgBCgCNCIJKAIAIQYgCSgCBCICKAIAIgUEQCAGIAURAwALIAIoAgQiBQRAIAYgBSACKAIIEPg6CyAJQQxBBBD4OgwBCwJAIAlFBEACQCADKAIcIgYoAgwiAkUNACAGKAIQIgUoAgAiAQRAIAIgAREDAAsgBSgCBCIBRQ0AIAIgASAFKAIIEPg6CyAGQQA2AgwgBhDeOyAGQQA2AgggBkKAgICAEDcCACMAQRBrIgIkACADQSBqKAIAJQEQOCACQQhqEM4tIAIoAgwhBSAEQQhqIgEgAigCCEEBcTYCACABIAU2AgQgAkEQaiQAIAQoAghBAXFFDQEgBCgCDCEBDAILIANBKGoiASgCACUBEF8hEBDfEiIFIBAmASAEIAU2AlAgASgCACUBEGEhASAEQdAAaigCACUBIAEgCRBeIRAQ3xIiASAQJgEgBCABNgJEIAVBhAFPBEAgBRDyHwsgCSADKAIcIgUoAggiAUsNCCAFKAIEIQUjAEEgayIGJAAgBEHEAGooAgAiARCcPiECIAYgCTYCBCAGIAI2AgAgAiAJRwRAIAZBADYCCEEAIAYgBkEEaiAGQQhqQeSriAEQrysACyABJQEgBSAJEFkgBkEgaiQAIARBEGogA0EkaiAJEJopIAQoAhBBAXFFDQIgBCgCFCEBIAQoAkQiBUGEAUkNASAFEPIfDAELIAQgA0EkakEAEJopIAQoAgBBAXFFDQggBCgCBCEBCyADKAIoIgVBhAFPBEAgBRDyHwsgAygCJCIFQYQBTwRAIAUQ8h8LQQEhByADKAIgIgJBgwFLDQgMCQsgBCgCRCIBQYQBSQ0GIAEQ8h8MBgtBwODDABDoKwALQQMhAiAGQQM6AABBAiEHDAcLIAcgAkGA4MMAELA7AAtBkODDABDoKwALQYDfwwBBNyAEQThqQfDewwBBuN/DABDVHgALIAkgAUGg4MMAELA7AAsgAygCKCIBQYQBTwRAIAEQ8h8LIAMoAiQiAUGEAU8EQCABEPIfC0GAASEBQQAhByADKAIgIgJBgwFNDQELIAIQ8h8LQQEhAiADQQE6ADwgAygCECIFIAUoAgBBAWo2AgAgAygCBCIFIAUoAgBBAWsiBTYCACAFDQAgDxDfHwsgAyACOgBAIAdBAkcNACADKAIAQQhqIAsoAgAQixRBAkEDIAMoAgAtABQbIQcLIAogATYCBCAKIAc2AgAgBEHgAGokAAwBC0Hm2cMAQTEQlz0ACyAKKAIAIgVBA0YEf0ECBSADKAIARQ0CIAooAgQhCyAKIAM2AgwgCkEMaigCACICQQRqIQ0CQAJAAkAgAi0AQA4EAAICAQILIA0oAgAiASABKAIAQQFrIgE2AgAgAUUEQCANEN8fCyACKAIIIgFBhAFJDQEgARDyHwwBCwJAAkACQAJAIAItADwOBAADAwEDCyACKAIYIgFBgwFNDQIMAQsgAigCKCIBQYQBTwRAIAEQ8h8LIAIoAiQiAUGEAU8EQCABEPIfCyACKAIgIgFBgwFNDQELIAEQ8h8LIAIoAhAiASABKAIAQQFqNgIAIAIoAgQiASABKAIAQQFrIgE2AgAgAQ0AIA0Q3x8LIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQ6ScLIANBADYCAEGAASALIAVBAkYiARshDUEAIAUgARsLIQEgDiANNgIEIA4gATYCACAKQRBqJAAMAgtBqNjDAEE2QeDYwwAQnykAC0Hw18MAQShBmNjDABCfKQALQQMhAQJAAkAgCCgCECILQQJGIgoNACAIKAIUIQEgAxDfFAJAIAtBAXEEQCAIIAE2AhggCEGAATYCHCAIIABByABqIAhBHGogCEEYahDCIyAIKAIAQQFxDQUCQCAIKAIEIgFBhAFJDQAgARDyHyAIKAIcIgFBhAFJDQAgARDyHwsgCCgCGCIBQYQBSQ0BIAEQ8h8MAQsgCCABNgIYIAhBgAE2AhwgCEEIaiAAQcQAaiAIQRxqIAhBGGoQwiMgCCgCCEEBcQ0CAkAgCCgCDCIBQYQBSQ0AIAEQ8h8gCCgCHCIBQYQBSQ0AIAEQ8h8LIAgoAhgiAUGEAUkNACABEPIfCyAAKAJEIgFBhAFPBEAgARDyHwtBASEBIAAoAkgiC0GEAUkNACALEPIfCyAAIAE6AJABIAhBIGokACAKDwsMAQtB6N3DABDoKwALQdTbwwBBMRCXPQALlwwBC38jAEEgayIFJAACQAJAAkACQAJAIAAtAGhBAWsOAwMAAgELAAsgAEE4aiAAQTD8CgAACyAFQRBqIQsjAEEQayIJJAACQAJAIABBOGoiAigCAARAIwBBIGsiCCQAAkAgAigCAC0AFARAQQIhBwwBCyACQQRqIQwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAsQQFrDgMNAgEACyAMKAIAIgQoAggNFyAEQX82AgggAiAEQQhqNgIQIAIgBEEMaiIHNgIMIAJBADoAKCACIAc2AhQgAiACKAIIIgY2AhggAkEoaiEEDAMLIAJBKGohBAJAIAItAChBAWsOAwUBAAILIAIoAiQhBwwDCwALIAIoAhghBiACKAIUIQcLIAIgBjYCICACIAc2AhwgBygCAEUNCiACIAc2AiQLIAhBEGogBygCACABIAcoAgQoAgwRAQAgCCgCECIDQQJrDgICCAELQbDgwwAQ6CsACyAIKAIUIQQgA0EBcQ0DIAggBDYCHCMAQRBrIgMkACACQSBqKAIAJQEgCEEcaigCACUBEDogA0EIahDOLSADKAIMIQYgCCADKAIIQQFxNgIAIAggBjYCBCADQRBqJAAgCCgCAEEBcUUNASAIKAIEIQYgBEGEAUkNBCAEEPIfDAQLIAIoAhwQ1ykgAigCHEEANgIAIwBBEGsiAyQAIAJBIGooAgAlARA5IANBCGoQzi0gAygCDCEGIAhBCGoiBCADKAIIQQFxNgIAIAQgBjYCBCADQRBqJAAgCCgCCEEBcUUNASAIKAIMIQYMAwsgBEGEAUkNACAEEPIfC0GAASEGQQAhByACKAIgIgNBhAFJDQYMBQsgAigCHBDXKSACKAIcQQA2AgAgBCEGC0EBIQcgAigCICIDQYMBSw0DDAQLQdDgwwAQ6CsAC0EDIQMgBEEDOgAAQQIhBwwDC0Hm2cMAQTEQlz0ACyADEPIfC0EBIQMgAkEBOgAoIAIoAhAiBCAEKAIAQQFqNgIAIAIoAgQiBCAEKAIAQQFrIgQ2AgAgBA0AIAwQ1CILIAIgAzoALCAHQQJHDQAgAigCAEEIaiABKAIAEIsUQQJBAyACKAIALQAUGyEHCyAJIAY2AgQgCSAHNgIAIAhBIGokACAJKAIAIgZBA0YEf0ECBSACKAIARQ0CIAkoAgQhBCAJIAI2AgwgCUEMaigCACIDQQRqIQoCQAJAAkAgAy0ALA4EAAICAQILIAooAgAiASABKAIAQQFrIgE2AgAgAUUEQCAKENQiCyADKAIIIgFBhAFJDQEgARDyHwwBCwJAAkACQAJAIAMtACgOBAADAwEDCyADKAIYIgFBgwFNDQIMAQsgAygCICIBQYMBTQ0BCyABEPIfCyADKAIQIgEgASgCAEEBajYCACADKAIEIgEgASgCAEEBayIBNgIAIAENACAKENQiCyADKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCADEOknCyACQQA2AgBBgAEgBCAGQQJGIgEbIQpBACAGIAEbCyEBIAsgCjYCBCALIAE2AgAgCUEQaiQADAILQajYwwBBNkHg2MMAEJ8pAAtB8NfDAEEoQZjYwwAQnykAC0EDIQECQAJAIAUoAhAiCUECRiIEDQAgBSgCFCEBIAIQ0xYCQCAJQQFxBEAgBSABNgIYIAVBgAE2AhwgBSAAQTRqIAVBHGogBUEYahDCIyAFKAIAQQFxDQUCQCAFKAIEIgFBhAFJDQAgARDyHyAFKAIcIgFBhAFJDQAgARDyHwsgBSgCGCIBQYQBSQ0BIAEQ8h8MAQsgBSABNgIYIAVBgAE2AhwgBUEIaiAAQTBqIAVBHGogBUEYahDCIyAFKAIIQQFxDQICQCAFKAIMIgFBhAFJDQAgARDyHyAFKAIcIgFBhAFJDQAgARDyHwsgBSgCGCIBQYQBSQ0AIAEQ8h8LIAAoAjAiAUGEAU8EQCABEPIfC0EBIQEgACgCNCIJQYQBSQ0AIAkQ8h8LIAAgAToAaCAFQSBqJAAgBA8LDAELQejdwwAQ6CsAC0HU28MAQTEQlz0AC5gDAQJ/AkACQAJAAkACQAJAIAAoAgAiAUEfdSABQf////8Ha3EOBAECAwQACyAAKAIMIgIEQCAAKAIIIQEDQCABEOILIAFByABqIQEgAkEBayICDQALCyAAQQRqQQRByAAQ4B4gACgCFCIBRQ0EIAEgASgCACIBQQFrNgIAIAFBAUcNBCAAQRRqEPseDwsgABDCIA8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNAiABIAEoAgAiAUEBazYCACABQQFHDQIgAEEYahD7Hg8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEEYahD7Hg8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahD7HgsLjwMBA38jAEEwayIEJAACQAJAIAIgA0YEQCAALQA6QQFHDQELIABBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEFAkBBACAAKAIwIgZrQQNxIgMgACgCCCAGa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAUgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAVBBBCNNyAEQRBqIAAQ3DsgBCgCFCEDIAQoAhAhBSAEQQhqIAAoAjAQjDcgBCAFIAMgBCgCCCAEKAIMQbC3/gAQ1yYgBCgCBEEDTQ0BIAQoAgAgAjYAACAAKAIwIQMgACgCFCICIAAoAgxGBEAgAEEMakG4tv4AEJsoCyAAKAIQIAJBA3RqIgUgATsBBCAFIAM2AgAgACACQQFqNgIUCyAEQTBqJAAPCyAEQQA2AiggBEEBNgIcIARB7Lf+ADYCGCAEQgQ3AiAgBEEYakHAt/4AEO8sAAuNAwEEfyMAQTBrIgMkAAJAAkAgAlAEQCAALQA6QQFHDQELIABBCCAAKAI0IgQgBEEITRs2AjQgAEEwaiEFAkBBACAAKAIwIgZrQQdxIgQgACgCCCAGa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAUgBBCNNyAAKAIIIAAoAjBrQQdLIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMGtBCEkNAAsLIAVBCBCNNyADQRBqIAAQ3DsgAygCFCEEIAMoAhAhBSADQQhqIAAoAjAQjDcgAyAFIAQgAygCCCADKAIMQazH/gAQ1yYgAygCBEEHTQ0BIAMoAgAgAjcAACAAKAIwIQUgACgCFCIEIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIARBA3RqIgYgATsBBCAGIAU2AgAgACAEQQFqNgIUCyADQTBqJAAPCyADQQA2AiggA0EBNgIcIANB9Mj+ADYCGCADQgQ3AiAgA0EYakG8x/4AEO8sAAuJAwECfyMAQTBrIgMkACADIAI6AAcgAyABOgAGIAACfwJAIAFB/wFxIgRFBEAgA0ECNgIMIANBwNKAATYCCCADQgE3AhQgA0G7BzYCJCADQZDSgAE2AiAgAyADQSBqNgIQDAELAkAgBEEmTQRAIALAIgRBJkoNAUGTgICAeCAEQQBMIAJB/wFxIAFB/wFxTXINAxogA0ECNgIMIANB9NKAATYCCCADQgI3AhQgA0G7BzYCLCADQfQLNgIkIAMgA0EgajYCECADIANBBmo2AiggAyADQQdqNgIgDAILIANBAjYCDCADQbjTgAE2AgggA0ICNwIUIANBuwc2AiwgA0GQ0oABNgIoIANBuwc2AiQgAyADQSBqNgIQIAMgA0EGajYCIAwBCyADQQI2AgwgA0Gc04ABNgIIIANCAjcCFCADQfQLNgIsIANBkNKAATYCKCADQfQLNgIkIAMgA0EgajYCECADIANBB2o2AiALIABBBGogA0EIahCZDkGNgICAeAs2AgAgA0EwaiQAC4kDAQJ/IwBBMGsiAyQAIAMgAjoAByADIAE6AAYgAAJ/AkAgAUH/AXEiBEUEQCADQQI2AgwgA0HA0oABNgIIIANCATcCFCADQbsHNgIkIANByNOAATYCICADIANBIGo2AhAMAQsCQCAEQRJNBEAgAsAiBEESSg0BQZOAgIB4IARBAEwgAkH/AXEgAUH/AXFNcg0DGiADQQI2AgwgA0H00oABNgIIIANCAjcCFCADQbsHNgIsIANB9As2AiQgAyADQSBqNgIQIAMgA0EGajYCKCADIANBB2o2AiAMAgsgA0ECNgIMIANBuNOAATYCCCADQgI3AhQgA0G7BzYCLCADQcjTgAE2AiggA0G7BzYCJCADIANBIGo2AhAgAyADQQZqNgIgDAELIANBAjYCDCADQZzTgAE2AgggA0ICNwIUIANB9As2AiwgA0HI04ABNgIoIANB9As2AiQgAyADQSBqNgIQIAMgA0EHajYCIAsgAEEEaiADQQhqEJkOQY2AgIB4CzYCACADQTBqJAALiQMBAn8jAEEwayIDJAAgAyACOgAHIAMgAToABiAAAn8CQCABQf8BcSIERQRAIANBAjYCDCADQcDSgAE2AgggA0IBNwIUIANBuwc2AiQgA0HJ04ABNgIgIAMgA0EgajYCEAwBCwJAIARBCU0EQCACwCIEQQlKDQFBk4CAgHggBEEATCACQf8BcSABQf8BcU1yDQMaIANBAjYCDCADQfTSgAE2AgggA0ICNwIUIANBuwc2AiwgA0H0CzYCJCADIANBIGo2AhAgAyADQQZqNgIoIAMgA0EHajYCIAwCCyADQQI2AgwgA0G404ABNgIIIANCAjcCFCADQbsHNgIsIANBydOAATYCKCADQbsHNgIkIAMgA0EgajYCECADIANBBmo2AiAMAQsgA0ECNgIMIANBnNOAATYCCCADQgI3AhQgA0H0CzYCLCADQcnTgAE2AiggA0H0CzYCJCADIANBIGo2AhAgAyADQQdqNgIgCyAAQQRqIANBCGoQmQ5BjYCAgHgLNgIAIANBMGokAAuLAwECfyMAQTBrIgMkACADIAI6AAcgAyABOgAGIAACfwJAIAFB/wFxIgRFBEAgA0ECNgIMIANBwNKAATYCCCADQgE3AhQgA0G7BzYCJCADQcrTgAE2AiAgAyADQSBqNgIQDAELAkAgBEHMAE0EQCACwCIEQcwASg0BQZOAgIB4IARBAEwgAkH/AXEgAUH/AXFNcg0DGiADQQI2AgwgA0H00oABNgIIIANCAjcCFCADQbsHNgIsIANB9As2AiQgAyADQSBqNgIQIAMgA0EGajYCKCADIANBB2o2AiAMAgsgA0ECNgIMIANBuNOAATYCCCADQgI3AhQgA0G7BzYCLCADQcrTgAE2AiggA0G7BzYCJCADIANBIGo2AhAgAyADQQZqNgIgDAELIANBAjYCDCADQZzTgAE2AgggA0ICNwIUIANB9As2AiwgA0HK04ABNgIoIANB9As2AiQgAyADQSBqNgIQIAMgA0EHajYCIAsgAEEEaiADQQhqEJkOQY2AgIB4CzYCACADQTBqJAALtQMBA38jAEHgAGsiBiQAIAYgBToALyAGIAQ3AxggBiADNwMQIAYgAjcDCCAGIAE3AwAgAAJ/AkAgBUH/AXEiBUHMAE0EQCAGIAVBBXQiB0GglIUBaiIFEPsbIghB/wFxQQJGIAjAQQBMckUEQCAGQQM2AjQgBkHgu4UBNgIwIAZCAzcCPCAGQYMMNgJcIAYgBTYCWCAGQbsHNgJUIAZBgww2AkwgBiAGQcgAajYCOCAGIAZBL2o2AlAgBiAGNgJIIABBBGogBkEwahCZDgwCC0GTgICAeCAGIAdBwKeFAWoiBxD7G8BBAE4NAhogBkEDNgI0IAZBlLuFATYCMCAGQgM3AjwgBkGDDDYCXCAGIAc2AlggBkG7BzYCVCAGQYMMNgJMIAYgBkHIAGo2AjggBiAGQS9qNgJQIAYgBjYCSCAAQQRqIAZBMGoQmQ4MAQsgBkECNgJMIAZBnLyFATYCSCAGQgI3AlQgBkG7BzYCPCAGQbsHNgI0IAZB+LuFATYCMCAGIAZBMGo2AlAgBiAGQS9qNgI4IABBBGogBkHIAGoQmQ4LQY2AgIB4CzYCACAGQeAAaiQAC9UVAg1/BX4jAEGgA2siBiQAIAZB+ABqIgoQuy8gBiAKIAItAAQQliojAEEgayILJAAgATUCCCEQIwBBoAFrIggkACAIIBA3AwggCEEQaiEDIwBB0ABrIgQkAAJAIAE1AggiEUIIWgRAIARCADcDCCAEQThqIAEgEUIIfRDhMCAEQTBqIgUgBEHEAGopAgA3AwAgBCAEKQI8NwMoIAQoAjgiCUEIRwRAIAQoAkwhByADIAQpAyg3AgQgA0GAgICAeDYCUCADIAc2AhQgAyAJNgIAIANBDGogBSkDADcCAAwCCyAEQSBqIAUpAwA3AwAgBCAEKQMoNwMYIARBEGohDCAEQRhqIQ4gBEEIaiENQQghCSMAQRBrIgUkAAJAAkADQCAOIA0gCSAOKAIIIgcgByAJSxsiBxCXGiAFQQhqIg9BBDoAACAPIAc2AgQCQAJAAkACQCAFLQAIIgdBBEcEQAJAIAdBAWsOAwADAgcLIAUtAAlBI0cNBgwDCwJAIAUoAgwiBwRAIAcgCU0NASAHIAlBiM3DABCvOwALIAxBgM3DACkDADcCAAwHCyAHIA1qIQ0gCSAHayEJDAMLIAUoAgwtAAhBI0YNAQwECyAFKAIMLQAIQSNHDQMLIAVBCGoQuS4LIAkNAAsgDEEEOgAADAELIAwgBSkDCDcCAAsgBUEQaiQAAkAgBC0AEEEERg0AIAQpAxAiEkL/AYNCBFENACAEIBI3AzggAyAEQThqEIErIANBgICAgHg2AlAgBEEkaiAEKAIcIAQoAiAgBCgCGCgCEBEBAAwCCyAEQSRqIAQoAhwgBCgCICAEKAIYKAIQEQEAIARBOGogBEEIahCKGSAELQBAIQkgBCgCPCEFAkAgBCgCOCIHQQhHBEAgAyAEKQBBNwAJIANBEGogBEHIAGopAAA3AAAgAyAJOgAIIAMgBTYCBCADIAc2AgAMAQsgBkEBNgIIIAQgBTYCECAGIAVBCGoiBzYCDCAEIAk6ABQgB60iEiARWARAIARBOGogASARIBJ9IAUQzy4gBEEwaiIFIARBxABqKQIANwMAIAQgBCkCPDcDKCAEKAI4IglBCEcEQCAEKAJMIQcgAyAEKQMoNwIEIANBgICAgHg2AlAgAyAHNgIUIAMgCTYCACADQQxqIAUpAwA3AgAMBAsgBEEgaiAFKQMAIhE3AwAgBCAEKQMoNwMYIAMgBiAEKAIcIgMgEaciBSAEQRBqEP8ZIARBJGogAyAFIAQoAhgoAhARAQAMAwsgAyAHNgIEIANBBjYCAAsgA0GAgICAeDYCUAwBCyADQYCAgIB4NgJQIANChoCAgIABNwMACyAEQdAAaiQAAkAgC0EIaiIEAn8CQAJAIAgoAmBBgICAgHhGBEAgCCgCEEEGRw0BIAggCCgCFCIDNgJ0IBAgATUCCFEgECADrVRyDQIgBCADNgIEQQYMAwsgBkEQaiIDENIWIAMgCEEQakHgAPwKAAAgBi0AcCAGLQBxcgRAIwBB0ABrIgMkACADIBA3AwACQAJAAkACQAJAAkACQAJAIAYoAmBBgICAgHhHBEAgA0E4aiAGENwLIAMoAjhFDQEgAyADKQNIIhI3AxAgAyADKQNAIhE3AwggATUCCCETAkAgECARWA0AIBEgECATfSITQgAgECATWhsiE1QgECASWHINACASIBNaDQULIBAgElQNAiAQIBF9IhBC/////w9YDQMMBwsgA0E4akE7QQBBAUEBEKAYIAMoAjwhASADKAI4QQFGDQQgAygCQCIFQcTVwwBBO/wKAAAgBEE7NgIMIAQgBTYCCCAEIAE2AgQgBEEANgIADAcLIARBCDYCAAwGCyADQQI2AjwgA0Hc1MMANgI4IANCAjcCRCADQTw2AjQgA0HbATYCLCADIANBKGo2AkAgAyADNgIwIAMgA0EIajYCKCAEQQRqIANBOGoQmQ4gBEECNgIADAULIAQgED4CBCAEQQY2AgAMBAsgBigCCEUNASAGNQIMIRQgAyAQNwMgIAMgECAUfSIUQgAgECAUWhsiEDcDGCAQIBJaDQEgA0ECNgI8IANBtNXDADYCOCADQgI3AkQgA0HbATYCNCADQdsBNgIsIAMgA0EoajYCQCADIANBGGo2AjAgAyADQQhqNgIoIARBBGohCSMAQRBrIgUkACADQThqIgEoAgwhBwJAAkACQAJAAkACQAJAIAEoAgQOAgABAgsgBw0BQQEhB0EAIQEMAgsgBw0AIAEoAgAiBygCBCEBIAcoAgAhBwwBCyAJIAEQmQ4MAQsgBUEEaiABQQBBAUEBEKAYIAUoAgghDCAFKAIEQQFGDQEgBSgCDCENIAEEQCANIAcgAfwKAAALIAkgATYCCCAJIA02AgQgCSAMNgIACyAFQRBqJAAMAQsgDCAFKAIMQdDXwwAQ/S8ACyAEQQI2AgAMAwsgASADKAJAQdDXwwAQ/S8ACyASIBF9IhBC/////w9WDQAgA0E4aiABIBEgE30gEKcQzy4gA0EwaiIBIANBxABqKQIANwMAIAMgAykCPDcDKCADKAI4IgVBCEcEQCADKAJMIQkgBCADKQMoNwIEIAQgCTYCFCAEIAU2AgAgBEEMaiABKQMANwIADAILIANBIGogASkDADcDACADIAMpAyg3AxggA0E4aiIFIAYgA0EYaiIJIBEQphICQCADKAI4IgFBCEcNACAFIAYgCSAREJ8GIAMoAjgiAUEIRw0AIARBCDYCACADQSRqIAMoAhwgAygCICADKAIYKAIQEQEADAILIAQgAykCPDcCBCAEQRRqIANBzABqKAIANgIAIARBDGogA0HEAGopAgA3AgAgBCABNgIAIANBJGogAygCHCADKAIgIAMoAhgoAhARAQAMAQsgBBDbJAsgA0HQAGokAAwECyAEQQg2AgAMAwsgBCAIKQMQNwMAIARBEGogCEEgaikDADcDACAEQQhqIAhBGGopAwA3AwAMAgsgCEECNgJ8IAhBlNTDADYCeCAIQgI3AoQBIAhBOzYCnAEgCEE8NgKUASAIIAhBkAFqNgKAASAIIAhB9ABqNgKYASAIIAhBCGo2ApABIARBBGogCEH4AGoQmQ5BAgs2AgAgCEEQahDJIwsgCEGgAWokAAJAIAsoAggiAUEIRwRAIAogCykCDDcCBCAKQRRqIAtBHGooAgA2AgAgCkEMaiALQRRqKQIANwIAIApBgICAgHg2AlAgCiABNgIADAELIAogBhD+FAsgBkEQahDSFiALQSBqJAACQAJAIAYoAsgBIgRBgICAgHhGBEAgBkGAAmogBkGIAWopAwAiEDcDACAGQfgBaiAGQYABaikDACIRNwMAIAYgBikDeCISNwPwASAAQRBqIBA3AwAgAEEIaiARNwMAIAAgEjcDACACKAIAIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAIQ+CMMAQsgBkHwAWoiASAGQfgAaiIDQdAA/AoAACAGQcgCaiIIIAZB1AFqKAIANgIAIAYgBikCzAE3A8ACIAZB0AJqIgUgAUHQAPwKAABB6ABBCBCtNiIBRQ0BIAFCgYCAgBA3AwAgAUEIaiAFQdAA/AoAACABIAQ2AlggASAGKQPAAjcCXCABQeQAaiAIKAIANgIAIAYgAikCADcDeCAAIAEgAxDtAQsgBkGgA2okAA8LQQhB6AAQoz0AC/YcAhB/B34jAEGAAWsiAiQAIAEoAgghDiABKAIAIQ8gAiABKAIMIgwgASgCBCIBa0EDdhDEGwJAIAEgDEcEQCACQThqIRAgAkHcAGohDQNAAkAgASgCACIFBEAgAUEEaigCACEGIwBB0AFrIgQkACAEIAY2AgwgBCAFNgIIAkACQAJAAkAgBkENTwRAIAIoAgghAyACQQA2AgggAw0BDAILIARBADYCGCAEQgA3AxAgBgRAIARBEGogBSAG/AoAAAsgBDUCGCESIAQpAxAhFCACKAJAIgMgAigCOEYEQCACQThqQYzOhQEQsSgLIAIoAjwgA0EEdGoiBSASPgIMIAUgFDcCBCAFIAY2AgAgAiADQQFqNgJAIAIoAlwEQCACKAJsIgZBAWoiB0EDdiAHQQdxQQBHaiIFIAIoAmgiA0sEQCAFIANrIQkgAigCYCIIIAVJBEAgAkHcAGogCEEBdCIDIAVBwP///wNxQUBrIAUgBUE/cRsiCCADIAhLGxDoGSACKAJoIQMLIAkEQCACKAJkIANqQQAgCfwLAAsgAiAFNgJoCyACIAc2AmwgAigCZCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAwsgAiACKAJwQQFqNgJwDAILIARBNGogAkEUaigCADYCACAEQUBrIAJBIGopAwAiEjcDACAEQcgAaiACQShqKQMAIhc3AwAgBEHQAGogAkEwaikDACIWNwMAIAQgAzYCKCAEIAIpAgw3AiwgBCACKQMYIhQ3AzggEiAGrSIVhSITQjiGIBNCgP4Dg0IohoQgE0KAgPwHg0IYhiATQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEQtKBqpur+oLXp39+IhJCOIYgEkKA/gODQiiGhCASQoCA/AeDQhiGIBJCgICA+A+DQgiGhIQgEkIIiEKAgID4D4MgEkIYiEKAgPwHg4QgEkIoiEKA/gODIBJCOIiEhIQgE0LYotHvwqnlvy1+hSAVfEKt/tXk1IX9qNgAfiESAkAgBkEQTQRAIBIgFHwgBSkAACAXhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIAUgBmpBCGspAAAgFoUiE0J/hX4iFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhIUgE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhCASfoVCF4khEgwBCyASIBR8IBcgBSAGakEQayIDKQAAhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIBYgAykACIUiE0J/hX4iFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhIUgE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhCASfoVCF4khEiAWQn+FIRUgBSEDIAYhBwNAIBIgFHwgFyADKQAAhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIAMpAAgiGCAVhX4iE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhIUgEiAWIBiFIhNCOIYgE0KA/gODQiiGhCATQoCA/AeDQhiGIBNCgICA+A+DQgiGhIQgE0IIiEKAgID4D4MgE0IYiEKAgPwHg4QgE0IoiEKA/gODIBNCOIiEhIR+hUIXiSESIANBEGohAyAHQRBrIgdBEEsNAAsLIAJBCGohByAEQdgAaiAEQShqIBIgFEI4hiAUQoD+A4NCKIaEIBRCgID8B4NCGIYgFEKAgID4D4NCCIaEhCAUQgiIQoCAgPgPgyAUQhiIQoCA/AeDhCAUQiiIQoD+A4MgFEI4iISEhH4gEkI4hiASQoD+A4NCKIaEIBJCgID8B4NCGIYgEkKAgID4D4NCCIaEhCASQgiIQoCAgPgPgyASQhiIQoCA/AeDhCASQiiIQoD+A4MgEkI4iISEhCAUQn+FfiIUQjiGIBRCgP4Dg0IohoQgFEKAgPwHg0IYhiAUQoCAgPgPg0IIhoSEIBRCCIhCgICA+A+DIBRCGIhCgID8B4OEIBRCKIhCgP4DgyAUQjiIhISEhSASiSACIARBCGogBEE4ahD6DSAEKAJYQQFGBEAgBCgCbCIDKAIAIgkgBCgCaCIIaiIKLQAAIQsgAigCQCERIAogBCgCYEEZdiIKOgAAIAkgAygCBCAIQQhrcWpBCGogCjoAACADIAMoAgxBAWo2AgwgAyADKAIIIAtBAXFrNgIIIAkgCEECdGtBBGsgETYCACAEQagBaiAEQTBqKQIANwMAIAQgBCkCKDcDoAEgBEHIAWogBEHQAGopAwA3AwAgBEHAAWogBEHIAGopAwA3AwAgBEG4AWogBEFAaykDADcDACAEIAQpAzg3A7ABIAIoAggEQCAHQQQQ7igLIAcgBEGgAWpBMPwKAAAMAQsgBCgCaEEEaygCACIFIAIoAkAiA0kEQCACKAI8IgYgBUEEdGoiBSkDCCESIAUpAwAhFCACKAI4IANGBH8gAkE4akHMzYUBELEoIAIoAjwFIAYLIANBBHRqIgUgEjcDCCAFIBQ3AwAgAiADQQFqNgJAAkAgAigCXARAIAIoAmwiBkEBaiIJQQN2IAlBB3FBAEdqIgMgAigCaCIFSwRAIAMgBWshCCACKAJgIgogA0kEQCACQdwAaiAKQQF0IgUgA0HA////A3FBQGsgAyADQT9xGyIKIAUgCksbEOgZIAIoAmghBQsgCARAIAIoAmQgBWpBACAI/AsACyACIAM2AmgLIAIgCTYCbCACKAJkIAZBA3ZqIgMgAy0AAEEBIAZBB3F0cjoAAAwBCyACIAIoAnBBAWo2AnALIARB+ABqIARBMGopAgA3AwAgBEGIAWogBEFAaykDADcDACAEQZABaiAEQcgAaikDADcDACAEQZgBaiAEQdAAaikDADcDACAEIAQpAig3A3AgBCAEKQM4NwOAASAHKAIABEAgB0EEEO4oCyAHIARB8ABqQTD8CgAADAILIAUgA0G8zYUBEMMhAAsgAkHQAGohCSACKAJQIgcgAigCWCIDIAZqSQRAIAMEQCACQQA2AlggAigCVCEIIAJCgICAgBA3A1AgBCAHNgJoIARCgICAgBA3AmAgBCADNgJcIAQgCDYCWCAEIARB2ABqENc7IAQoAgAhC0EcQQQQrTYiB0UNAyAHQoGAgIAQNwIAIAcgBCkCWDcCCCAHQRBqIARB4ABqKQIANwIAIAdBGGogBEHoAGooAgA2AgAgAigCTCIIIAIoAkRGBEAgAkHEAGpBrM2FARCQKAsgAigCSCAIQQxsaiIKIAM2AgggCiALNgIEIAogBzYCACACIAhBAWo2AkwLIAIoAgQhBwJAIAIoAgBBAUcEQCAHIQMMAQtBgICAASEDIAdB////AEsNACACIAdBAXQiAzYCBAsgCSADIAYgAyAGSxsQhC4gAigCWCEDCyAJIAUgBhChNiACNQJMIAOtQiCGhCESIAatIAU1AABCIIaEIRQgAigCQCIDIAIoAjhGBEAgAkE4akH8zYUBELEoCyACKAI8IANBBHRqIgUgEjcDCCAFIBQ3AwAgAiADQQFqNgJAIAIoAlwEQCACKAJsIgZBAWoiB0EDdiAHQQdxQQBHaiIFIAIoAmgiA0sEQCAFIANrIQkgAigCYCIIIAVJBEAgAkHcAGogCEEBdCIDIAVBwP///wNxQUBrIAUgBUE/cRsiCCADIAhLGxDoGSACKAJoIQMLIAkEQCACKAJkIANqQQAgCfwLAAsgAiAFNgJoCyACIAc2AmwgAigCZCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAQsgAiACKAJwQQFqNgJwCyAEQdABaiQADAILQQRBHBCjPQALIA0Q5jogAigCXEUNAyACKAJsQQFqIgZBA3YgBkEHcUEAR2oiAyACKAJoIgVLBEAgAyAFayEHIAIoAmAiBCADSQRAIA0gBEEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSACKAJoIQULIAcEQCACKAJkIAVqQQAgB/wLAAsgAiADNgJoCyACIAY2AmwgAigCQCIDIAIoAjhGBEAgEEGczoUBELEoCyACKAI8IANBBHRqIgVCADcDCCAFQgA3AwAgAiADQQFqNgJACyABQQhqIgEgDEcNAAsLIAIgDzYCfCACIA42AnggAkH4AGpBBEEIEOAeIAAgAhDcDCACQThqQRBBEBDgHiACKAJcBEAgAkHcAGoQzy8LIAJBxABqIgAQxScgABDoOyACQdAAahDeOyACKAIIBEAgAkEIakEEEO4oCyACQYABaiQADwtBoMmFARCyOwALjAMCBn4DfyMAQTBrIggkACABKQMYIQIgASkDECEDAkACQCABKQMAIgVCAVYgASkDCCIGQgBSIAZQGw0AAkACQCAFp0EBRgRAIAIgA4RQDQEMAwsgAyACQoCAgICAgICAgH+FhFANASACIAOEUEUNAiAAQgA3AwggAEIBNwMADAMLIABCgICAgICAgPg/NwMIIABCATcDAAwCCyAAQgE3AwAgAEKAgICAgICA8E83AwgMAQsgAkI/hyIEIAaFIgd5IAQgBYV5QkB9IAdCAFIbp0GAf3MgAiAEhSIHeSADIASFIgR5QkB9IAdCAFIbpyAEIAeEUBsiCUEBayIKwCEBAkAgCkH/AXFFDQAgAUEASARAIAhBIGogBSAGIAFB/wBxEMYjIAgpAyghAgwBCyAIQRBqIAMgAiABQf8BcRDGIyAIIAUgBkEBIAlrQf8AcRDHIyAIKQMIIAgpAxiEIQILIABCATcDACAARAAAAAAAAABAQcABIAFB/wFxaxDeICACuaI5AwgLIAhBMGokAAu6AwEBfyMAQUBqIgIkAAJAAkACQAJAAkACQCAALQAAQQFrDgMBAgMACyACIAAoAgQ2AgRBFEEBEK02IgBFDQQgAEEQakH0uokBKAAANgAAIABBCGpB7LqJASkAADcAACAAQeS6iQEpAAA3AAAgAkEUNgIQIAIgADYCDCACQRQ2AgggAkEDNgIsIAJByLKJATYCKCACQgI3AjQgAiACQQRqrUKAgICAwDOENwMgIAIgAkEIaq1CgICAgJDeA4Q3AxggAiACQRhqNgIwIAEoAgAgASgCBCACQShqEMsKIQAgAigCCCIBRQ0DIAIoAgwgAUEBEPg6DAMLIAAtAAEhACACQQE2AiwgAkHQq4kBNgIoIAJCATcCNCACIAJBGGqtQoCAgICg3gOENwMIIAIgAEECdCIAQfy6iQFqKAIANgIcIAIgAEGkvIkBaigCADYCGCACIAJBCGo2AjAgASgCACABKAIEIAJBKGoQywohAAwCCyAAKAIEIgAoAgAgACgCBCABEKk9IQAMAQsgACgCBCIAKAIAIAEgACgCBCgCEBECACEACyACQUBrJAAgAA8LQQFBFEH4qIkBEP0vAAvYhAECOX8gfSMAQSBrIjEkAAJAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAoABIAEtAApqNgKAAQwDCyAAIAAoAoABIAEoAghqNgKAAQwCCyAAIAEvAAE7AZwBDAELIDFCADcDEEEHITIDQCAzIAAoAoABIhVJBEAgMUEQaiAyaiAAIBUgMmpBCGtBhMbOABCpKC0AADoAAAsgM0EBaiEzIDJBAWsiMkF/Rw0ACyABKAIIIjoEQCABKAIEITJBACEzIDohAQNAIDFBEGoiFSAzQQZqQQdxci0AACECIDFBCGogFSAzQQFrQQdxIghyLQAAIAIgACgCGCAAKAIcIAAoAigEfyAAKAIkLQAABUEACyAALQCcARC1GyAxLQAMGiAxKAIIIRUgMSAxKQMQNwMYIDFBGGohGSAyLQAAIS4jAEEgayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgFUERbCIXIAAoAjwiFEkEQCAZIAggAC0AnQFrQQdxai0AACE0IAAoAjgiJyAXQQV0aiIEIC5B8AFxQQR2IhpBAXRqLwEAIQcgLkEQTwRAIBpBAWsiA0EQTw0CIAcgBCADQQF0ai8BAGshBwsgFSAaQQh0akGAIGohNiA0QQR0QYAecSAVaiE3IAdB//8DcUECdEHMhuMAaioCACE7IAQvAR4iEEECdEHMhuMAaioCACE8IAQvARwhAyAELwEaIQYgBC8BGCEJIAQvARYhCyAELwEUIQwgBC8BEiENIAQvARAhDyAELwEOIQogBC8BDCERIAQvAQohEiAELwEIIS8gBC8BBiEqIAQvAQQhKyAELwECIRggBC8BACEpIAAuAZIBIAAvAZABIQ5BACEHA0AgAiAHaiAOOwEAIAdBAmoiB0EgRw0ACyACLwEeIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRYgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQcDQCACIAdqIBo7AQAgB0ECaiIHQSBHDQALQQAgAi4BHEEPSBsgA2ohByAFQQAgAi4BGkEOSBsgBmohBSATQQAgAi4BGEENSBsgCWohAyAWQQAgAi4BFkEMSBsgC2ohFiAdQQAgAi4BFEELSBsgDGohDiAeQQAgAi4BEkEKSBsgDWohEyAfQQAgAi4BEEEJSBsgD2ohDyAgQQAgAi4BDkEISBsgCmohBiAhQQAgAi4BDEEHSBsgEWohCyAiQQAgAi4BCkEGSBsgEmohDCAjQQAgAi4BCEEFSBsgL2ohCiAkQQAgAi4BBkEESBsgKmohCSAlQQAgAi4BBEEDSBsgK2ohDSAmQQAgAi4BAkECSBsgGGohESAoQQAgAi4BAEEATBsgKWohEkEAIAIuAR5BEEgbIBBqwSIQTARAIBBBEGoiECAQwUECdWshECAHQQ9qIgcgB8FBAnVrIQcgBUEOaiIFIAXBQQJ1ayEFIBZBDGoiFiAWwUECdWshFiAOQQtqIg4gDsFBAnVrIQ4gE0EKaiITIBPBQQJ1ayETIA9BCWoiDyAPwUECdWshDyAGQQhqIgYgBsFBAnVrIQYgC0EHaiILIAvBQQJ1ayELIAxBBmoiDCAMwUECdWshDCAKQQVqIgogCsFBAnVrIQogCUEEaiIJIAnBQQJ1ayEJIA1BA2oiDSANwUECdWshDSARQQJqIhEgEcFBAnVrIREgEkEBaiISIBLBQQJ1ayESIANBDWoiAyADwUECdWshAwsgBCAQOwEeIAQgBzsBHCAEIAU7ARogBCADOwEYIAQgFjsBFiAEIA47ARQgBCATOwESIAQgDzsBECAEIAY7AQ4gBCALOwEMIAQgDDsBCiAEIAo7AQggBCAJOwEGIAQgDTsBBCAEIBE7AQIgBCASOwEAIBcgGmpBAWoiFiAUTw0CICcgFkEFdGoiAyAuQQ9xIidBAXRqIgcvAQAhBiAnBH8gBiAHQQJrLwEAawUgBgtB//8DcUECdEHMhuMAaioCACE9IAMvAR4iBUECdEHMhuMAaioCACE+IAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhDiADLwEOIREgAy8BDCESIAMvAQohECADLwEIIRQgAy8BBiErIAMvAQQhGCADLwECISkgAy8BACEbIAAuAY4BIS8gAC8BjAEhKkEAIQQDQCACIARqICo7AQAgBEECaiIEQSBHDQALIAIvAR4hHCACLwEcIAIvARohCiACLwEYIR0gAi8BFiEeIAIvARQhHyACLwESISAgAi8BECEhIAIvAQ4hIiACLwEMISMgAi8BCiEkIAIvAQghJSACLwEGISYgAi8BBCEoIAIvAQIhLCACLwEAIS1BACEEA0AgAiAEaiAnOwEAIARBAmoiBEEgRw0AC0EAIAIuARxBD0gbIAZqIQQgCkEAIAIuARpBDkgbIAdqIRMgHUEAIAIuARhBDUgbIAlqIQ8gHkEAIAIuARZBDEgbIAtqIQYgH0EAIAIuARRBC0gbIAxqIQsgIEEAIAIuARJBCkgbIA1qIQwgIUEAIAIuARBBCUgbIA5qIQogIkEAIAIuAQ5BCEgbIBFqIQkgI0EAIAIuAQxBB0gbIBJqIQ0gJEEAIAIuAQpBBkgbIBBqIREgJUEAIAIuAQhBBUgbIBRqIRIgJkEAIAIuAQZBBEgbICtqIRAgKEEAIAIuAQRBA0gbIBhqIQcgLEEAIAIuAQJBAkgbIClqIQ4gLUEAIAIuAQBBAEwbIBtqIRQgLyAcQQAgAi4BHkEQSBsgBWrBIgVMBEAgBUEQaiIFIAXBQQJ1ayEFIARBD2oiBCAEwUECdWshBCATQQ5qIhMgE8FBAnVrIRMgD0ENaiIPIA/BQQJ1ayEPIAtBC2oiCyALwUECdWshCyAMQQpqIgwgDMFBAnVrIQwgCkEJaiIKIArBQQJ1ayEKIAlBCGoiCSAJwUECdWshCSANQQdqIg0gDcFBAnVrIQ0gEUEGaiIRIBHBQQJ1ayERIBJBBWoiEiASwUECdWshEiAQQQRqIhAgEMFBAnVrIRAgB0EDaiIHIAfBQQJ1ayEHIA5BAmoiDiAOwUECdWshDiAUQQFqIhQgFMFBAnVrIRQgBkEMaiIGIAbBQQJ1ayEGCyADIAU7AR4gAyAEOwEcIAMgEzsBGiADIA87ARggAyAGOwEWIAMgCzsBFCADIAw7ARIgAyAKOwEQIAMgCTsBDiADIA07AQwgAyAROwEKIAMgEjsBCCADIBA7AQYgAyAHOwEEIAMgDjsBAiADIBQ7AQAgFyAAKAJEIgRPDQMgACgCQCIrIBdBBXRqIgUgGkEBdGovAQAhAyAuQRBPBH8gGkEBayIGQRBPDRQgAyAFIAZBAXRqLwEAawUgAwtB//8DcUECdEHMhuMAaiAFLwEeIhRBAnRBzIbjAGohKSAFLwEcIQMgBS8BGiEXIAUvARghEyAFLwEWIQ8gBS8BFCEGIAUvARIhCyAFLwEQIQwgBS8BDiEKIAUvAQwhCSAFLwEKIQ0gBS8BCCERIAUvAQYhEiAFLwEEIRAgBS8BAiEHIAUvAQAhDiAUwSIUQYAITgRAIBRBEGoiFCAUwUECdWshFCAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyAGQQtqIgYgBsFBAnVrIQYgC0EKaiILIAvBQQJ1ayELIAxBCWoiDCAMwUECdWshDCAKQQhqIgogCsFBAnVrIQogCUEHaiIJIAnBQQJ1ayEJIA1BBmoiDSANwUECdWshDSARQQVqIhEgEcFBAnVrIREgEkEEaiISIBLBQQJ1ayESIBBBA2oiECAQwUECdWshECAHQQJqIgcgB8FBAnVrIQcgDkEBaiIOIA7BQQJ1ayEOIANBD2oiAyADwUECdWshAwsqAgAhPyApKgIAIUAgBSAUOwEeIAUgAzsBHCAFIBc7ARogBSATOwEYIAUgDzsBFiAFIAY7ARQgBSALOwESIAUgDDsBECAFIAo7AQ4gBSAJOwEMIAUgDTsBCiAFIBE7AQggBSASOwEGIAUgEDsBBCAFIAc7AQIgBSAOOwEAIAQgFk0NBCArIBZBBXRqIgUgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqIAUvAR4iDkECdEHMhuMAaiEUIAUvARwhAyAFLwEaIRcgBS8BGCEWIAUvARYhEyAFLwEUIQ8gBS8BEiEGIAUvARAhCyAFLwEOIQwgBS8BDCEKIAUvAQohCSAFLwEIIQ0gBS8BBiERIAUvAQQhEiAFLwECIRAgBS8BACEHIA7BIg5BgAhOBEAgDkEQaiIOIA7BQQJ1ayEOIBdBDmoiFyAXwUECdWshFyAWQQ1qIhYgFsFBAnVrIRYgE0EMaiITIBPBQQJ1ayETIA9BC2oiDyAPwUECdWshDyAGQQpqIgYgBsFBAnVrIQYgC0EJaiILIAvBQQJ1ayELIAxBCGoiDCAMwUECdWshDCAKQQdqIgogCsFBAnVrIQogCUEGaiIJIAnBQQJ1ayEJIA1BBWoiDSANwUECdWshDSARQQRqIhEgEcFBAnVrIREgEkEDaiISIBLBQQJ1ayESIBBBAmoiECAQwUECdWshECAHQQFqIgcgB8FBAnVrIQcgA0EPaiIDIAPBQQJ1ayEDCyoCACFBIBQqAgAhQiAFIA47AR4gBSADOwEcIAUgFzsBGiAFIBY7ARggBSATOwEWIAUgDzsBFCAFIAY7ARIgBSALOwEQIAUgDDsBDiAFIAo7AQwgBSAJOwEKIAUgDTsBCCAFIBE7AQYgBSASOwEEIAUgEDsBAiAFIAc7AQAgFUEBdCIWQQFyIgMgACgCTCIGTw0FIAAoAkgiBSADQQV0aiIDIBpBAXRqLwEAIQcgLkEQTwR/IBpBAWsiBkEQTw0UIAcgAyAGQQF0ai8BAGsFIAcLQf//A3FBAnRBzIbjAGoqAgAhQyADLwEeIhRBAnRBzIbjAGoqAgAhRCADLwEcIQYgAy8BGiEHIAMvARghCSADLwEWIQsgAy8BFCEMIAMvARIhDSADLwEQIQ4gAy8BDiEKIAMvAQwhESADLwEKIRIgAy8BCCEQIAMvAQYhKyADLwEEIRggAy8BAiEpIAMvAQAhG0EAIQQDQCACIARqICo7AQAgBEECaiIEQSBHDQALIAIvAR4hHCACLwEcIAIvARohEyACLwEYIR0gAi8BFiEeIAIvARQhHyACLwESISAgAi8BECEhIAIvAQ4hIiACLwEMISMgAi8BCiEkIAIvAQghJSACLwEGISYgAi8BBCEoIAIvAQIhLCACLwEAIS1BACEEA0AgAiAEaiAaOwEAIARBAmoiBEEgRw0AC0EAIAIuARxBD0gbIAZqIQQgE0EAIAIuARpBDkgbIAdqIRcgHUEAIAIuARhBDUgbIAlqIRMgHkEAIAIuARZBDEgbIAtqIQ8gH0EAIAIuARRBC0gbIAxqIQYgIEEAIAIuARJBCkgbIA1qIQsgIUEAIAIuARBBCUgbIA5qIQwgIkEAIAIuAQ5BCEgbIApqIQogI0EAIAIuAQxBB0gbIBFqIQkgJEEAIAIuAQpBBkgbIBJqIQ0gJUEAIAIuAQhBBUgbIBBqIREgJkEAIAIuAQZBBEgbICtqIRIgKEEAIAIuAQRBA0gbIBhqIRAgLEEAIAIuAQJBAkgbIClqIQcgLUEAIAIuAQBBAEwbIBtqIQ4gLyAcQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIARBD2oiBCAEwUECdWshBCAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyALQQpqIgsgC8FBAnVrIQsgDEEJaiIMIAzBQQJ1ayEMIApBCGoiCiAKwUECdWshCiAJQQdqIgkgCcFBAnVrIQkgDUEGaiINIA3BQQJ1ayENIBFBBWoiESARwUECdWshESASQQRqIhIgEsFBAnVrIRIgEEEDaiIQIBDBQQJ1ayEQIAdBAmoiByAHwUECdWshByAOQQFqIg4gDsFBAnVrIQ4gBkELaiIGIAbBQQJ1ayEGCyADIBQ7AR4gAyAEOwEcIAMgFzsBGiADIBM7ARggAyAPOwEWIAMgBjsBFCADIAs7ARIgAyAMOwEQIAMgCjsBDiADIAk7AQwgAyANOwEKIAMgETsBCCADIBI7AQYgAyAQOwEEIAMgBzsBAiADIA47AQAgBSAWQQV0aiIDICdBAXRqIgcvAQAhBiAnBH8gBiAHQQJrLwEAawUgBgtB//8DcUECdEHMhuMAaioCACFFIAMvAR4iDkECdEHMhuMAaioCACFGIAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhCiADLwEOIREgAy8BDCESIAMvAQohECADLwEIIRQgAy8BBiErIAMvAQQhGCADLwECISkgAy8BACEbQQAhBANAIAIgBGogKjsBACAEQQJqIgRBIEcNAAsgAi8BHiEqIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRwgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQQDQCACIARqICc7AQAgBEECaiIEQSBHDQALQQAgAi4BHEEPSBsgBmohBCAFQQAgAi4BGkEOSBsgB2ohBSATQQAgAi4BGEENSBsgCWohFyAcQQAgAi4BFkEMSBsgC2ohEyAdQQAgAi4BFEELSBsgDGohDyAeQQAgAi4BEkEKSBsgDWohBiAfQQAgAi4BEEEJSBsgCmohCyAgQQAgAi4BDkEISBsgEWohDCAhQQAgAi4BDEEHSBsgEmohCiAiQQAgAi4BCkEGSBsgEGohCSAjQQAgAi4BCEEFSBsgFGohDSAkQQAgAi4BBkEESBsgK2ohESAlQQAgAi4BBEEDSBsgGGohEiAmQQAgAi4BAkECSBsgKWohECAoQQAgAi4BAEEATBsgG2ohByAvICpBACACLgEeQRBIGyAOasEiDkwEQCAOQRBqIg4gDsFBAnVrIQ4gBEEPaiIEIATBQQJ1ayEEIAVBDmoiBSAFwUECdWshBSAXQQ1qIhQgFMFBAnVrIRcgE0EMaiITIBPBQQJ1ayETIA9BC2oiDyAPwUECdWshDyALQQlqIgsgC8FBAnVrIQsgDEEIaiIMIAzBQQJ1ayEMIApBB2oiCiAKwUECdWshCiAJQQZqIgkgCcFBAnVrIQkgDUEFaiINIA3BQQJ1ayENIBFBBGoiESARwUECdWshESASQQNqIhIgEsFBAnVrIRIgEEECaiIQIBDBQQJ1ayEQIAdBAWoiByAHwUECdWshByAGQQpqIgYgBsFBAnVrIQYLIAMgDjsBHiADIAQ7ARwgAyAFOwEaIAMgFzsBGCADIBM7ARYgAyAPOwEUIAMgBjsBEiADIAs7ARAgAyAMOwEOIAMgCjsBDCADIAk7AQogAyANOwEIIAMgETsBBiADIBI7AQQgAyAQOwECIAMgBzsBACAZIAhBB3FqLQAAIitBCXQgFnIiAyAAKAJUIgRPDQYgACgCUCIYIANBBXRqIgMgGkEBdGovAQAhByAuQRBPBH8gGkEBayIGQRBPDRQgByADIAZBAXRqLwEAawUgBwtB//8DcUECdEHMhuMAaioCACFHIAMvAR4iFEECdEHMhuMAaioCACFIIAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhDiADLwEOIQogAy8BDCERIAMvAQohEiADLwEIIRAgAy8BBiEpIAMvAQQhGyADLwECIRwgAy8BACEdIAAuAZoBIS8gAC8BmAEhKkEAIQUDQCACIAVqICo7AQAgBUECaiIFQSBHDQALIAIvAR4hHiACLwEcIAIvARohEyACLwEYIR8gAi8BFiEgIAIvARQhISACLwESISIgAi8BECEjIAIvAQ4hJCACLwEMISUgAi8BCiEmIAIvAQghKCACLwEGISwgAi8BBCEtIAIvAQIhMCACLwEAITVBACEFA0AgAiAFaiAaOwEAIAVBAmoiBUEgRw0AC0EAIAIuARxBD0gbIAZqIQUgE0EAIAIuARpBDkgbIAdqIRcgH0EAIAIuARhBDUgbIAlqIRMgIEEAIAIuARZBDEgbIAtqIQ8gIUEAIAIuARRBC0gbIAxqIQYgIkEAIAIuARJBCkgbIA1qIQsgI0EAIAIuARBBCUgbIA5qIQwgJEEAIAIuAQ5BCEgbIApqIQogJUEAIAIuAQxBB0gbIBFqIQkgJkEAIAIuAQpBBkgbIBJqIQ0gKEEAIAIuAQhBBUgbIBBqIREgLEEAIAIuAQZBBEgbIClqIRIgLUEAIAIuAQRBA0gbIBtqIRAgMEEAIAIuAQJBAkgbIBxqIQcgNUEAIAIuAQBBAEwbIB1qIQ4gLyAeQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIAVBD2oiBSAFwUECdWshBSAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyALQQpqIgsgC8FBAnVrIQsgDEEJaiIMIAzBQQJ1ayEMIApBCGoiCiAKwUECdWshCiAJQQdqIgkgCcFBAnVrIQkgDUEGaiINIA3BQQJ1ayENIBFBBWoiESARwUECdWshESASQQRqIhIgEsFBAnVrIRIgEEEDaiIQIBDBQQJ1ayEQIAdBAmoiByAHwUECdWshByAOQQFqIg4gDsFBAnVrIQ4gBkELaiIGIAbBQQJ1ayEGCyADIBQ7AR4gAyAFOwEcIAMgFzsBGiADIBM7ARggAyAPOwEWIAMgBjsBFCADIAs7ARIgAyAMOwEQIAMgCjsBDiADIAk7AQwgAyANOwEKIAMgETsBCCADIBI7AQYgAyAQOwEEIAMgBzsBAiADIA47AQAgGkEMdCIpICtBD3FBCHRyIBVyQQF0QQFyIgMgBE8NByAYIANBBXRqIgQgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIUkgBC8BHiITQQJ0QcyG4wBqKgIAIUogBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEYIAQvAQIhGyAELwEAIRwgAC4BlgEhKyAALwGUASEXQQAhAwNAIAIgA2ogFzsBACADQQJqIgNBIEcNAAsgAi8BHiEdIAIvARwgAi8BGiEKIAIvARghHiACLwEWIR8gAi8BFCEgIAIvARIhISACLwEQISIgAi8BDiEjIAIvAQwhJCACLwEKISUgAi8BCCEmIAIvAQYhKCACLwEEISwgAi8BAiEtIAIvAQAhMEEAIQMDQCACIANqICc7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyAKQQAgAi4BGkEOSBsgB2ohBiAeQQAgAi4BGEENSBsgCWohCyAfQQAgAi4BFkEMSBsgDGohDCAgQQAgAi4BFEELSBsgDWohCiAhQQAgAi4BEkEKSBsgDmohCSAiQQAgAi4BEEEJSBsgD2ohDSAjQQAgAi4BDkEISBsgEWohESAkQQAgAi4BDEEHSBsgEmohEiAlQQAgAi4BCkEGSBsgEGohECAmQQAgAi4BCEEFSBsgBWohByAoQQAgAi4BBkEESBsgFGohDiAsQQAgAi4BBEEDSBsgGGohFCAtQQAgAi4BAkECSBsgG2ohBSAwQQAgAi4BAEEATBsgHGohDyArIB1BACACLgEeQRBIGyATasEiE0wEQCATQRBqIhMgE8FBAnVrIRMgBkEOaiIGIAbBQQJ1ayEGIAtBDWoiCyALwUECdWshCyAMQQxqIgwgDMFBAnVrIQwgCkELaiIKIArBQQJ1ayEKIAlBCmoiCSAJwUECdWshCSANQQlqIg0gDcFBAnVrIQ0gEUEIaiIRIBHBQQJ1ayERIBJBB2oiEiASwUECdWshEiAQQQZqIhAgEMFBAnVrIRAgB0EFaiIHIAfBQQJ1ayEHIA5BBGoiDiAOwUECdWshDiAUQQNqIhQgFMFBAnVrIRQgBUECaiIFIAXBQQJ1ayEFIA9BAWoiDyAPwUECdWshDyADQQ9qIgMgA8FBAnVrIQMLIAQgEzsBHiAEIAM7ARwgBCAGOwEaIAQgCzsBGCAEIAw7ARYgBCAKOwEUIAQgCTsBEiAEIA07ARAgBCAROwEOIAQgEjsBDCAEIBA7AQogBCAHOwEIIAQgDjsBBiAEIBQ7AQQgBCAFOwECIAQgDzsBACAZIAhBAWtBB3FqLQAAIhtBCXQgFnIiAyAAKAJcIhhPDQ4gACgCWCIcIANBBXRqIgQgGkEBdGovAQAhAyAuQRBPBH8gGkEBayIGQRBPDRQgAyAEIAZBAXRqLwEAawUgAwtB//8DcUECdEHMhuMAaioCACFLIAQvAR4iE0ECdEHMhuMAaioCACFMIAQvARwhBiAELwEaIQcgBC8BGCEJIAQvARYhDCAELwEUIQ0gBC8BEiEOIAQvARAhDyAELwEOIREgBC8BDCESIAQvAQohECAELwEIIQUgBC8BBiEUIAQvAQQhHSAELwECIR4gBC8BACEfQQAhAwNAIAIgA2ogKjsBACADQQJqIgNBIEcNAAsgAi8BHiEgIAIvARwgAi8BGiEKIAIvARghISACLwEWISIgAi8BFCEjIAIvARIhJCACLwEQISUgAi8BDiEmIAIvAQwhKCACLwEKISwgAi8BCCEtIAIvAQYhMCACLwEEITUgAi8BAiE4IAIvAQAhOUEAIQMDQCACIANqIBo7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyAKQQAgAi4BGkEOSBsgB2ohBiAhQQAgAi4BGEENSBsgCWohCyAiQQAgAi4BFkEMSBsgDGohDCAjQQAgAi4BFEELSBsgDWohCiAkQQAgAi4BEkEKSBsgDmohCSAlQQAgAi4BEEEJSBsgD2ohDSAmQQAgAi4BDkEISBsgEWohESAoQQAgAi4BDEEHSBsgEmohEiAsQQAgAi4BCkEGSBsgEGohECAtQQAgAi4BCEEFSBsgBWohByAwQQAgAi4BBkEESBsgFGohDiA1QQAgAi4BBEEDSBsgHWohFCA4QQAgAi4BAkECSBsgHmohBSA5QQAgAi4BAEEATBsgH2ohDyAvICBBACACLgEeQRBIGyATasEiE0wEQCATQRBqIhMgE8FBAnVrIRMgBkEOaiIGIAbBQQJ1ayEGIAtBDWoiCyALwUECdWshCyAMQQxqIgwgDMFBAnVrIQwgCkELaiIKIArBQQJ1ayEKIAlBCmoiCSAJwUECdWshCSANQQlqIg0gDcFBAnVrIQ0gEUEIaiIRIBHBQQJ1ayERIBJBB2oiEiASwUECdWshEiAQQQZqIhAgEMFBAnVrIRAgB0EFaiIHIAfBQQJ1ayEHIA5BBGoiDiAOwUECdWshDiAUQQNqIhQgFMFBAnVrIRQgBUECaiIFIAXBQQJ1ayEFIA9BAWoiDyAPwUECdWshDyADQQ9qIgMgA8FBAnVrIQMLIAQgEzsBHiAEIAM7ARwgBCAGOwEaIAQgCzsBGCAEIAw7ARYgBCAKOwEUIAQgCTsBEiAEIA07ARAgBCAROwEOIAQgEjsBDCAEIBA7AQogBCAHOwEIIAQgDjsBBiAEIBQ7AQQgBCAFOwECIAQgDzsBACAbQQ9xQQh0IClyIBVyQQF0QQFyIgMgGE8NDiAcIANBBXRqIgQgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIU0gBC8BHiITQQJ0QcyG4wBqKgIAIU4gBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEYIAQvAQIhGyAELwEAIRxBACEDA0AgAiADaiAXOwEAIANBAmoiA0EgRw0ACyACLwEeIR0gAi8BHCACLwEaIQogAi8BGCEeIAIvARYhHyACLwEUISAgAi8BEiEhIAIvARAhIiACLwEOISMgAi8BDCEkIAIvAQohJSACLwEIISYgAi8BBiEoIAIvAQQhLCACLwECIS0gAi8BACEwQQAhAwNAIAIgA2ogJzsBACADQQJqIgNBIEcNAAtBACACLgEcQQ9IGyAGaiEDIApBACACLgEaQQ5IGyAHaiEGIB5BACACLgEYQQ1IGyAJaiELIB9BACACLgEWQQxIGyAMaiEMICBBACACLgEUQQtIGyANaiEKICFBACACLgESQQpIGyAOaiEJICJBACACLgEQQQlIGyAPaiENICNBACACLgEOQQhIGyARaiERICRBACACLgEMQQdIGyASaiESICVBACACLgEKQQZIGyAQaiEQICZBACACLgEIQQVIGyAFaiEHIChBACACLgEGQQRIGyAUaiEOICxBACACLgEEQQNIGyAYaiEUIC1BACACLgECQQJIGyAbaiEFIDBBACACLgEAQQBMGyAcaiEPICsgHUEAIAIuAR5BEEgbIBNqwSITTARAIBNBEGoiEyATwUECdWshEyAGQQ5qIgYgBsFBAnVrIQYgC0ENaiILIAvBQQJ1ayELIAxBDGoiDCAMwUECdWshDCAKQQtqIgogCsFBAnVrIQogCUEKaiIJIAnBQQJ1ayEJIA1BCWoiDSANwUECdWshDSARQQhqIhEgEcFBAnVrIREgEkEHaiISIBLBQQJ1ayESIBBBBmoiECAQwUECdWshECAHQQVqIgcgB8FBAnVrIQcgDkEEaiIOIA7BQQJ1ayEOIBRBA2oiFCAUwUECdWshFCAFQQJqIgUgBcFBAnVrIQUgD0EBaiIPIA/BQQJ1ayEPIANBD2oiAyADwUECdWshAwsgBCATOwEeIAQgAzsBHCAEIAY7ARogBCALOwEYIAQgDDsBFiAEIAo7ARQgBCAJOwESIAQgDTsBECAEIBE7AQ4gBCASOwEMIAQgEDsBCiAEIAc7AQggBCAOOwEGIAQgFDsBBCAEIAU7AQIgBCAPOwEAIBkgCEEGakEHcWotAAAiG0EJdCAWciIDIAAoAmQiGE8NDiAAKAJgIhwgA0EFdGoiBCAaQQF0ai8BACEDIC5BEE8EfyAaQQFrIgZBEE8NFCADIAQgBkEBdGovAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIU8gBC8BHiITQQJ0QcyG4wBqKgIAIVAgBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEdIAQvAQIhHiAELwEAIR9BACEDA0AgAiADaiAqOwEAIANBAmoiA0EgRw0ACyACLwEeISAgAi8BHCACLwEaIQogAi8BGCEhIAIvARYhIiACLwEUISMgAi8BEiEkIAIvARAhJSACLwEOISYgAi8BDCEoIAIvAQohLCACLwEIIS0gAi8BBiEwIAIvAQQhNSACLwECITggAi8BACE5QQAhAwNAIAIgA2ogGjsBACADQQJqIgNBIEcNAAtBACACLgEcQQ9IGyAGaiEDIApBACACLgEaQQ5IGyAHaiEGICFBACACLgEYQQ1IGyAJaiELICJBACACLgEWQQxIGyAMaiEMICNBACACLgEUQQtIGyANaiEKICRBACACLgESQQpIGyAOaiEJICVBACACLgEQQQlIGyAPaiENICZBACACLgEOQQhIGyARaiERIChBACACLgEMQQdIGyASaiESICxBACACLgEKQQZIGyAQaiEQIC1BACACLgEIQQVIGyAFaiEHIDBBACACLgEGQQRIGyAUaiEOIDVBACACLgEEQQNIGyAdaiEUIDhBACACLgECQQJIGyAeaiEFIDlBACACLgEAQQBMGyAfaiEPIC8gIEEAIAIuAR5BEEgbIBNqwSITTARAIBNBEGoiEyATwUECdWshEyAGQQ5qIgYgBsFBAnVrIQYgC0ENaiILIAvBQQJ1ayELIAxBDGoiDCAMwUECdWshDCAKQQtqIgogCsFBAnVrIQogCUEKaiIJIAnBQQJ1ayEJIA1BCWoiDSANwUECdWshDSARQQhqIhEgEcFBAnVrIREgEkEHaiISIBLBQQJ1ayESIBBBBmoiECAQwUECdWshECAHQQVqIgcgB8FBAnVrIQcgDkEEaiIOIA7BQQJ1ayEOIBRBA2oiFCAUwUECdWshFCAFQQJqIgUgBcFBAnVrIQUgD0EBaiIPIA/BQQJ1ayEPIANBD2oiAyADwUECdWshAwsgBCATOwEeIAQgAzsBHCAEIAY7ARogBCALOwEYIAQgDDsBFiAEIAo7ARQgBCAJOwESIAQgDTsBECAEIBE7AQ4gBCASOwEMIAQgEDsBCiAEIAc7AQggBCAOOwEGIAQgFDsBBCAEIAU7AQIgBCAPOwEAIBtBD3FBCHQgKXIgFXJBAXRBAXIiAyAYTw0OIBwgA0EFdGoiBCAnQQF0aiIGLwEAIQMgJwR/IAMgBkECay8BAGsFIAMLQf//A3FBAnRBzIbjAGoqAgAhUSAELwEeIhNBAnRBzIbjAGoqAgAhUiAELwEcIQYgBC8BGiEHIAQvARghCSAELwEWIQwgBC8BFCENIAQvARIhDiAELwEQIQ8gBC8BDiERIAQvAQwhEiAELwEKIRAgBC8BCCEFIAQvAQYhFCAELwEEIRggBC8BAiEbIAQvAQAhHEEAIQMDQCACIANqIBc7AQAgA0ECaiIDQSBHDQALIAIvAR4hHSACLwEcIAIvARohCiACLwEYIR4gAi8BFiEfIAIvARQhICACLwESISEgAi8BECEiIAIvAQ4hIyACLwEMISQgAi8BCiElIAIvAQghJiACLwEGISggAi8BBCEsIAIvAQIhLSACLwEAITBBACEDA0AgAiADaiAnOwEAIANBAmoiA0EgRw0AC0EAIAIuARxBD0gbIAZqIQMgCkEAIAIuARpBDkgbIAdqIQYgHkEAIAIuARhBDUgbIAlqIQsgH0EAIAIuARZBDEgbIAxqIQwgIEEAIAIuARRBC0gbIA1qIQogIUEAIAIuARJBCkgbIA5qIQkgIkEAIAIuARBBCUgbIA9qIQ0gI0EAIAIuAQ5BCEgbIBFqIREgJEEAIAIuAQxBB0gbIBJqIRIgJUEAIAIuAQpBBkgbIBBqIRAgJkEAIAIuAQhBBUgbIAVqIQcgKEEAIAIuAQZBBEgbIBRqIQ4gLEEAIAIuAQRBA0gbIBhqIRQgLUEAIAIuAQJBAkgbIBtqIQUgMEEAIAIuAQBBAEwbIBxqIQ8gKyAdQQAgAi4BHkEQSBsgE2rBIhNMBEAgE0EQaiITIBPBQQJ1ayETIAZBDmoiBiAGwUECdWshBiALQQ1qIgsgC8FBAnVrIQsgDEEMaiIMIAzBQQJ1ayEMIApBC2oiCiAKwUECdWshCiAJQQpqIgkgCcFBAnVrIQkgDUEJaiINIA3BQQJ1ayENIBFBCGoiESARwUECdWshESASQQdqIhIgEsFBAnVrIRIgEEEGaiIQIBDBQQJ1ayEQIAdBBWoiByAHwUECdWshByAOQQRqIg4gDsFBAnVrIQ4gFEEDaiIUIBTBQQJ1ayEUIAVBAmoiBSAFwUECdWshBSAPQQFqIg8gD8FBAnVrIQ8gA0EPaiIDIAPBQQJ1ayEDCyAEIBM7AR4gBCADOwEcIAQgBjsBGiAEIAs7ARggBCAMOwEWIAQgCjsBFCAEIAk7ARIgBCANOwEQIAQgETsBDiAEIBI7AQwgBCAQOwEKIAQgBzsBCCAEIA47AQYgBCAUOwEEIAQgBTsBAiAEIA87AQAgGSAIQQVqQQdxai0AACIFQQl0IBZyIgggACgCbCIPTw0IIAAoAmgiBCAIQQV0aiIIIBpBAXRqLwEAIQMgLkEQTwR/IBpBAWsiBkEQTw0UIAMgCCAGQQF0ai8BAGsFIAMLQf//A3FBAnRBzIbjAGoqAgAhUyAILwEeIhRBAnRBzIbjAGoqAgAhVCAILwEcIQYgCC8BGiEHIAgvARghCSAILwEWIQsgCC8BFCEMIAgvARIhDSAILwEQIQ4gCC8BDiEKIAgvAQwhESAILwEKIRIgCC8BCCEQIAgvAQYhGCAILwEEIRsgCC8BAiEcIAgvAQAhHUEAIQMDQCACIANqICo7AQAgA0ECaiIDQSBHDQALIAIvAR4hHiACLwEcIAIvARohFiACLwEYIRkgAi8BFiEfIAIvARQhICACLwESISEgAi8BECEiIAIvAQ4hIyACLwEMISQgAi8BCiElIAIvAQghJiACLwEGISggAi8BBCEsIAIvAQIhLSACLwEAITBBACEDA0AgAiADaiAaOwEAIANBAmoiA0EgRw0AC0EAIAIuARxBD0gbIAZqIQMgFkEAIAIuARpBDkgbIAdqIRMgGUEAIAIuARhBDUgbIAlqIRkgH0EAIAIuARZBDEgbIAtqIRYgIEEAIAIuARRBC0gbIAxqIQYgIUEAIAIuARJBCkgbIA1qIQsgIkEAIAIuARBBCUgbIA5qIQwgI0EAIAIuAQ5BCEgbIApqIQogJEEAIAIuAQxBB0gbIBFqIQkgJUEAIAIuAQpBBkgbIBJqIQ0gJkEAIAIuAQhBBUgbIBBqIREgKEEAIAIuAQZBBEgbIBhqIRIgLEEAIAIuAQRBA0gbIBtqIRAgLUEAIAIuAQJBAkgbIBxqIQcgMEEAIAIuAQBBAEwbIB1qIQ4gLyAeQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIBNBDmoiEyATwUECdWshEyAWQQxqIhYgFsFBAnVrIRYgBkELaiIGIAbBQQJ1ayEGIAtBCmoiCyALwUECdWshCyAMQQlqIgwgDMFBAnVrIQwgCkEIaiIKIArBQQJ1ayEKIAlBB2oiCSAJwUECdWshCSANQQZqIg0gDcFBAnVrIQ0gEUEFaiIRIBHBQQJ1ayERIBJBBGoiEiASwUECdWshEiAQQQNqIhAgEMFBAnVrIRAgB0ECaiIHIAfBQQJ1ayEHIA5BAWoiDiAOwUECdWshDiAZQQ1qIhkgGcFBAnVrIRkgA0EPaiIDIAPBQQJ1ayEDCyAIIBQ7AR4gCCADOwEcIAggEzsBGiAIIBk7ARggCCAWOwEWIAggBjsBFCAIIAs7ARIgCCAMOwEQIAggCjsBDiAIIAk7AQwgCCANOwEKIAggETsBCCAIIBI7AQYgCCAQOwEEIAggBzsBAiAIIA47AQAgBUEPcUEIdCApciAVckEBdEEBciIIIA9PDQkgBCAIQQV0aiIIICdBAXRqIgYvAQAhAyAnBH8gAyAGQQJrLwEAawUgAwtB//8DcUECdEHMhuMAaioCACFVIAgvAR4iDkECdEHMhuMAaioCACFWIAgvARwhBiAILwEaIQcgCC8BGCEJIAgvARYhCyAILwEUIQwgCC8BEiENIAgvARAhCiAILwEOIREgCC8BDCESIAgvAQohECAILwEIIQUgCC8BBiEEIAgvAQQhFCAILwECIRggCC8BACEpQQAhAwNAIAIgA2ogFzsBACADQQJqIgNBIEcNAAsgAi8BHiEbIAIvARwgAi8BGiETIAIvARghFiACLwEWIRwgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQMDQCACIANqICc7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyATQQAgAi4BGkEOSBsgB2ohEyAWQQAgAi4BGEENSBsgCWohGSAcQQAgAi4BFkEMSBsgC2ohFiAdQQAgAi4BFEELSBsgDGohDyAeQQAgAi4BEkEKSBsgDWohBiAfQQAgAi4BEEEJSBsgCmohCyAgQQAgAi4BDkEISBsgEWohDCAhQQAgAi4BDEEHSBsgEmohCiAiQQAgAi4BCkEGSBsgEGohCSAjQQAgAi4BCEEFSBsgBWohDSAkQQAgAi4BBkEESBsgBGohESAlQQAgAi4BBEEDSBsgFGohEiAmQQAgAi4BAkECSBsgGGohECAoQQAgAi4BAEEATBsgKWohByArIBtBACACLgEeQRBIGyAOasEiDkwEQCAOQRBqIg4gDsFBAnVrIQ4gE0EOaiIFIAXBQQJ1ayETIBZBDGoiBSAFwUECdWshFiAPQQtqIg8gD8FBAnVrIQ8gBkEKaiIGIAbBQQJ1ayEGIAtBCWoiCyALwUECdWshCyAMQQhqIgwgDMFBAnVrIQwgCkEHaiIKIArBQQJ1ayEKIAlBBmoiCSAJwUECdWshCSANQQVqIg0gDcFBAnVrIQ0gEUEEaiIRIBHBQQJ1ayERIBJBA2oiEiASwUECdWshEiAQQQJqIhAgEMFBAnVrIRAgB0EBaiIHIAfBQQJ1ayEHIBlBDWoiBSAFwUECdWshGSADQQ9qIgMgA8FBAnVrIQMLIAggDjsBHiAIIAM7ARwgCCATOwEaIAggGTsBGCAIIBY7ARYgCCAPOwEUIAggBjsBEiAIIAs7ARAgCCAMOwEOIAggCjsBDCAIIAk7AQogCCANOwEIIAggETsBBiAIIBI7AQQgCCAQOwECIAggBzsBACA0QfABcUEIdCAVciIIIAAoAnQiB08NCiAAKAJwIg4gCEEFdGoiCCAaQQF0ai8BACEDIC5BEE8EfyAaQQFrIgZBEE8NFCADIAggBkEBdGovAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIVcgCC8BHiIQQQJ0QcyG4wBqKgIAIVggCC8BHCEGIAgvARohCSAILwEYIQsgCC8BFiEMIAgvARQhDSAILwESIQ8gCC8BECEKIAgvAQ4hESAILwEMIRIgCC8BCiEFIAgvAQghLiAILwEGIRggCC8BBCEpIAgvAQIhGyAILwEAIRxBACEDA0AgAiADaiAqOwEAIANBAmoiA0EgRw0ACyACLwEeISogAi8BHCACLwEaIRMgAi8BGCEUIAIvARYhFiACLwEUIRkgAi8BEiEdIAIvARAhHiACLwEOIR8gAi8BDCEgIAIvAQohISACLwEIISIgAi8BBiEjIAIvAQQhJCACLwECISUgAi8BACEmQQAhBANAIAIgBGogGjsBACAEQQJqIgRBIEcNAAtBACACLgEcQQ9IGyAGaiEEIBNBACACLgEaQQ5IGyAJaiEDIBRBACACLgEYQQ1IGyALaiEUIBZBACACLgEWQQxIGyAMaiETIBlBACACLgEUQQtIGyANaiEZIB1BACACLgESQQpIGyAPaiEWIB5BACACLgEQQQlIGyAKaiEPIB9BACACLgEOQQhIGyARaiEGICBBACACLgEMQQdIGyASaiELICFBACACLgEKQQZIGyAFaiEMICJBACACLgEIQQVIGyAuaiEKICNBACACLgEGQQRIGyAYaiEJICRBACACLgEEQQNIGyApaiENICVBACACLgECQQJIGyAbaiERICZBACACLgEAQQBMGyAcaiESIC8gKkEAIAIuAR5BEEgbIBBqwSIQTARAIBBBEGoiECAQwUECdWshECAEQQ9qIgUgBcFBAnVrIQQgFEENaiIFIAXBQQJ1ayEUIBNBDGoiBSAFwUECdWshEyAWQQpqIgUgBcFBAnVrIRYgD0EJaiIPIA/BQQJ1ayEPIAZBCGoiBiAGwUECdWshBiALQQdqIgsgC8FBAnVrIQsgDEEGaiIMIAzBQQJ1ayEMIApBBWoiCiAKwUECdWshCiAJQQRqIgkgCcFBAnVrIQkgDUEDaiINIA3BQQJ1ayENIBFBAmoiESARwUECdWshESASQQFqIhIgEsFBAnVrIRIgGUELaiIFIAXBQQJ1ayEZIANBDmoiAyADwUECdWshAwsgCCAQOwEeIAggBDsBHCAIIAM7ARogCCAUOwEYIAggEzsBFiAIIBk7ARQgCCAWOwESIAggDzsBECAIIAY7AQ4gCCALOwEMIAggDDsBCiAIIAo7AQggCCAJOwEGIAggDTsBBCAIIBE7AQIgCCASOwEAIDRBCHQgGkEQdHIgFXJBgIAEaiIVIAdPDQsgDiAVQQV0aiIVICdBAXRqIgMvAQAhCCAnBH8gCCADQQJrLwEAawUgCAtB//8DcUECdEHMhuMAaioCACFZIBUvAR4iDEECdEHMhuMAaioCACFaIBUvARwhCCAVLwEaIQMgFS8BGCEGIBUvARYhCyAVLwEUIQ0gFS8BEiEOIBUvARAhDyAVLwEOIQogFS8BDCERIBUvAQohEiAVLwEIIRAgFS8BBiEEIBUvAQQhGiAVLwECIS4gFS8BACEvQQAhCQNAIAIgCWogFzsBACAJQQJqIglBIEcNAAsgAi8BHiEqIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRQgAi8BFCEWIAIvARIhGSACLwEQIRggAi8BDiE0IAIvAQwhKSACLwEKIRsgAi8BCCEcIAIvAQYhHSACLwEEIR4gAi8BAiEfIAIvAQAhIEEAIQkDQCACIAlqICc7AQAgCUECaiIJQSBHDQALQQAgAi4BHEEPSBsgCGohCSAFQQAgAi4BGkEOSBsgA2ohByATQQAgAi4BGEENSBsgBmohBSAUQQAgAi4BFkEMSBsgC2ohAyAWQQAgAi4BFEELSBsgDWohFyAZQQAgAi4BEkEKSBsgDmohFCAYQQAgAi4BEEEJSBsgD2ohCCA0QQAgAi4BDkEISBsgCmohEyApQQAgAi4BDEEHSBsgEWohGSAbQQAgAi4BCkEGSBsgEmohFiAcQQAgAi4BCEEFSBsgEGohDiAdQQAgAi4BBkEESBsgBGohDSAeQQAgAi4BBEEDSBsgGmohDyAfQQAgAi4BAkECSBsgLmohBiAgQQAgAi4BAEEATBsgL2ohCyArICpBACACLgEeQRBIGyAMasEiDEwEQCAMQRBqIgwgDMFBAnVrIQwgCUEPaiIJIAnBQQJ1ayEJIAdBDmoiByAHwUECdWshByAFQQ1qIgogCsFBAnVrIQUgA0EMaiIDIAPBQQJ1ayEDIBdBC2oiCiAKwUECdWshFyAUQQpqIgogCsFBAnVrIRQgE0EIaiIKIArBQQJ1ayETIBZBBmoiCiAKwUECdWshFiAOQQVqIg4gDsFBAnVrIQ4gDUEEaiINIA3BQQJ1ayENIA9BA2oiDyAPwUECdWshDyAGQQJqIgYgBsFBAnVrIQYgC0EBaiILIAvBQQJ1ayELIBlBB2oiCiAKwUECdWshGSAIQQlqIgggCMFBAnVrIQgLIBUgDDsBHiAVIAk7ARwgFSAHOwEaIBUgBTsBGCAVIAM7ARYgFSAXOwEUIBUgFDsBEiAVIAg7ARAgFSATOwEOIBUgGTsBDCAVIBY7AQogFSAOOwEIIBUgDTsBBiAVIA87AQQgFSAGOwECIBUgCzsBACA2IAAoAnwiCE8NDCAAKAJ4IgMgNkEFdGoiFSA+ID2TIBUqAgCSOAIAIBUgWiBZkyAVKgIEkjgCBCAVIEIgQZMgFSoCCJI4AgggFSBGIEWTIBUqAgySOAIMIBUgSiBJkyAVKgIQkjgCECAVIE4gTZMgFSoCFJI4AhQgFSBSIFGTIBUqAhiSOAIYIBUgViBVkyAVKgIckjgCHCAIIDdLDQ0gNyAIQbiGzgAQwyEACyAXIBRB3IbOABDDIQALIANBEEHMhs4AEMMhAAsgFiAUQdyGzgAQwyEACyAXIARB3IbOABDDIQALIBYgBEHchs4AEMMhAAsgAyAGQdyGzgAQwyEACyADIARB3IbOABDDIQALIAMgBEHchs4AEMMhAAsgCCAPQdyGzgAQwyEACyAIIA9B3IbOABDDIQALIAggB0Hchs4AEMMhAAsgFSAHQdyGzgAQwyEACyA2IAhBqIbOABDDIQALIAMgN0EFdGoiFSA8IDuTIBUqAgCSOAIAIBUgWCBXkyAVKgIEkjgCBCAVIEAgP5MgFSoCCJI4AgggFSBEIEOTIBUqAgySOAIMIBUgSCBHkyAVKgIQkjgCECAVIEwgS5MgFSoCFJI4AhQgFSBQIE+TIBUqAhiSOAIYIBUgVCBTkyAVKgIckjgCHCACQSBqJAAMAQsgAyAYQdyGzgAQwyEACyAxQRBqIDNqIDItAAA6AAAgM0EBakEHcSEzIDJBAWohMiABQQFrIgENAAsLIAAgACgCgAEgOmo2AoABCyAxQSBqJAAPCyAGQRBBzIbOABDDIQAL0QMBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDg4BAgMEBQYHCAkKCwwNDgALIAIgAEEBajYCDCABQcTN0QBBECACQQxqQbTN0QAQ0BMMDgsgAiAAQQRqNgIMIAFB5M3RAEESIAJBDGpB1M3RABDQEwwNCyACIABBBGo2AgwgAUGIztEAQQcgAkEMakH4zdEAENATDAwLIAIgAEEBajYCDCABQaDO0QBBFCACQQxqQZDO0QAQ0BMMCwsgAiAAQQFqNgIMIAFBtM7RAEESIAJBDGpBkM7RABDQEwwKCyABQcbO0QBBEBD7NQwJCyABQdbO0QBBDxD7NQwICyABQeXO0QBBEBD7NQwHCyABQfXO0QBBCxD7NQwGCyABQYDP0QBBExD7NQwFCyABQZPP0QBBEhD7NQwECyABQaXP0QBBFBD7NQwDCyACIABBBGo2AgwgAUHMz9EAQQ4gAkEMakG8z9EAENATDAILIAFB2s/RAEEWEPs1DAELIAIgAEEQajYCDCABQZDQ0QBBEkHuzNEAQQggAEEIakHwz9EAQfbM0QBBBiACQQxqQYDQ0QAQjhgLIAJBEGokAAuMAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFBAnRqKAIAIQMgAiAAKAIAIgQoAgAoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC+gCAQV/AkACQAJAIAEoAhAiAkGFwABPBEAgAkGFwABGDQEgAkGGwABNDQIgAkGHwABGDQMgASgCDCIBLQCGQCECIAEtAIRAIgNBCE8EQCADQQdxIANBA3ZBAWtBD3EiA3RB+P8DcUEDdkEBIAN0ciEFCyABLQCFQCEDIAJBCE8EQCACQQdxIAJBA3ZBAWtBD3EiAnRB+P8DcUEDdkEBIAJ0ciEECyABLQCHQCECQQAhASADQQhPBEAgA0EHcSADQQN2QQFrQQ9xIgN0Qfj/A3FBA3ZBASADdHIhBgsgACACQQhPBH8gAkEHcSACQQN2QQFrQQ9xIgF0Qfj/A3FBA3ZBASABdHIFIAELOwEGIAAgBjsBBCAAIAQ7AQIgACAFOwEADwtBhMAAIAJB/PTOABDDIQALQYXAAEGFwABBjPXOABDDIQALQYbAAEGGwABBnPXOABDDIQALQYfAAEGHwABBrPXOABDDIQALiQMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQF0ai8BACEDIAIgACgCACIEKAIAKAIAIgU2AiAgAiADNgIcAkACQAJAAkAgBawgA61+IgZCIIinIAanIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIGNwMIIAanQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuJAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFBA3RqKAIAIQMgAiAAKAIAIgQoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC4kDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAUEBdGouAQAhAyACIAAoAgAiBCgCACgCACIFNgIgIAIgAzYCHAJAAkACQAJAIAOsIAWsfiIGQiCIpyAGpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALiQMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQJ0aigCACEDIAIgACgCACIEKAIAKAIAIgU2AiAgAiADNgIcAkACQAJAAkAgA6wgBax+IgZCIIinIAanIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIGNwMIIAanQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuGAwIGfwF+IwBBIGsiBSQAAkACQAJAIAJFBEAMAQsgAUEQaiEHA0AgAiADayEEAkACQCABKAI0IgZFBEAgASgCOCEIA0AgCEUEQCAHKAIARQ0HIAUgBxClGCAFKAIAQQFHDQYgBSkDCCIJUA0GIAlCAYNQRQRAIAEgCadBAnRBeHE2AjgMBQsgASAJQgGIPgI0IAVBEGogByABLQA8IgRBA3YgBEEHcUEAR2oQwRwgBSkDECEJIAEgBSkDGDcDCCABIAk3AwAgCacNBEHA+swAQS5B8PrMABCfKQALIAcoAgBFDQcgByAIIAQgBCAISxsgAS0APBCzFiIGDQJBACEIIAFBADYCOCABKAI0IgZFDQALCyABIAYgBiAEIAQgBksbIgRrNgI0IAMgBGohAwwBCyABIAEoAjggBms2AjggAyAGaiEDCyACIANLDQALCyAAQQg2AgAgACADNgIEIAVBIGokAA8LQZz4zABBGEGw+swAEMskAAtBnPjMAEEYQfT4zAAQyyQAC9EdAhF/A34jAEEwayIKJAAgCkEMaiEPIwBBgAFrIgMkACADQRBqIgIQvS8gA0EYaiIGQQEQlSQgA0HMAGogACAGIAIQnBAgA0HwAGoiAiADKAJUIgBBCGpBAEEBQQEQoBggAygCdCEGAkACQAJAIAMoAnBBAUcEQCADQQA2AmwgAyADKAJ4NgJoIAMgBjYCZEEEQQEQrTYiBkUNASAGQX82AAAgAyAGNgJ0IANBBDYCcCADQeQAaiIEQQQQ5S0gAygCaCADKAJsaiAGKAAANgAAIANBADYCeCADIAMoAmxBBGo2AmwgAhDeOyACQQRBAEEBQQEQoBggAygCdCEGIAMoAnBBAUYNAiADKAJ4IgUgADYAACADIAU2AnQgAyAGNgJwIARBBBDlLSADKAJoIAMoAmxqIAUoAAA2AAAgA0EANgJ4IAMgAygCbEEEajYCbCACEN47IAMoAlAhAiAEIAAQ5S0gAARAIAMoAmggAygCbGogAiAA/AoAAAsgA0EANgJUIAMgAygCbCAAajYCbCADQQhqIANB5ABqIhAQ3DsgAygCCCEOIAMoAgwhCCMAQTBrIgkkACAJQQhqIQJB+NnPAC0AACEEQQAhACAIQQNuIQYCQCAIQf////97SwRAQQAhBAwBCyAGQQJ0IQAgCCAGQQNsayIGRQRAQQEhBAwBCyAERQRAQQEhBEECQQMgBkEBRhsgAHIhAAwBCyAAQXxHIQQgAEEEaiEACyACIAA2AgQgAiAENgIAAkACQCAJKAIIQQFxBEAgCUEQaiAJKAIMQZD0zgAQzhggCSgCFCEGIAkoAhghBEEAIQUCQAJAAkACf0EAIQACQCAIQRtJDQAgCEEaayIAQQAgACAITRshDQJAA0AgCCAFQRpqTwRAIAdBYEYNAiAEIAdBIGoiAEkEQCAAIARBzJiBARCwOwALIAYgB2oiAiAFIA5qIgcpAAAiE0I4hiIUQjqIp0H72c8Aai0AADoAACACQQRqIBNCgICA+A+DQgiGIhVCIoinQfvZzwBqLQAAOgAAIAJBAWogFCATQoD+A4NCKIaEIhRCNIinQT9xQfvZzwBqLQAAOgAAIAJBAmogFCATQoCA/AeDQhiGIBWEhCIUQi6Ip0E/cUH72c8Aai0AADoAACACQQNqIBRCKIinQT9xQfvZzwBqLQAAOgAAIAJBBmogE0IIiEKAgID4D4MgE0IYiEKAgPwHg4QgE0IoiEKA/gODIBNCOIiEhCITpyIMQRZ2QT9xQfvZzwBqLQAAOgAAIAJBB2ogDEEQdkE/cUH72c8Aai0AADoAACACQQVqIBMgFIRCHIinQT9xQfvZzwBqLQAAOgAAIAJBCGogB0EGaikAACITQjiGIhRCOoinQfvZzwBqLQAAOgAAIAJBCWogFCATQoD+A4NCKIaEIhRCNIinQT9xQfvZzwBqLQAAOgAAIAJBCmogFCATQoCAgPgPg0IIhiIVIBNCgID8B4NCGIaEhCIUQi6Ip0E/cUH72c8Aai0AADoAACACQQtqIBRCKIinQT9xQfvZzwBqLQAAOgAAIAJBDGogFUIiiKdB+9nPAGotAAA6AAAgAkENaiAUIBNCCIhCgICA+A+DIBNCGIhCgID8B4OEIBNCKIhCgP4DgyATQjiIhIQiE4RCHIinQT9xQfvZzwBqLQAAOgAAIAJBDmogE6ciDEEWdkE/cUH72c8Aai0AADoAACACQQ9qIAxBEHZBP3FB+9nPAGotAAA6AAAgAkEQaiAHQQxqKQAAIhNCOIYiFEI6iKdB+9nPAGotAAA6AAAgAkERaiAUIBNCgP4Dg0IohoQiFEI0iKdBP3FB+9nPAGotAAA6AAAgAkESaiAUIBNCgICA+A+DQgiGIhUgE0KAgPwHg0IYhoSEIhRCLoinQT9xQfvZzwBqLQAAOgAAIAJBE2ogFEIoiKdBP3FB+9nPAGotAAA6AAAgAkEUaiAVQiKIp0H72c8Aai0AADoAACACQRZqIBNCCIhCgICA+A+DIBNCGIhCgID8B4OEIBNCKIhCgP4DgyATQjiIhIQiE6ciDEEWdkE/cUH72c8Aai0AADoAACACQRdqIAxBEHZBP3FB+9nPAGotAAA6AAAgAkEVaiATIBSEQhyIp0E/cUH72c8Aai0AADoAACACQRhqIAdBEmopAAAiE0I4hiIUQjqIp0H72c8Aai0AADoAACACQRlqIBQgE0KA/gODQiiGhCIUQjSIp0E/cUH72c8Aai0AADoAACACQRpqIBQgE0KAgID4D4NCCIYiFSATQoCA/AeDQhiGhIQiFEIuiKdBP3FB+9nPAGotAAA6AAAgAkEbaiAUQiiIp0E/cUH72c8Aai0AADoAACACQRxqIBVCIoinQfvZzwBqLQAAOgAAIAJBHWogFCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOEQhyIp0E/cUH72c8Aai0AADoAACACQR5qIBOnIgdBFnZBP3FB+9nPAGotAAA6AAAgAkEfaiAHQRB2QT9xQfvZzwBqLQAAOgAAIAAhByANIAVBGGoiBU8NAQwDCwsgBUEaaiAIQbyYgQEQsDsAC0FgQQBBzJiBARCxOwALAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAggCEEDcCIMayINIAVNBEAgACECDAELA0AgBUF8Sw0CIAVBA2oiByAISw0DIABBe0sNBCAEIABBBGoiAkkEQCACIARBrJiBARCwOwALIAAgBmoiACAFIA5qIgUtAAAiEUECdkH72c8Aai0AADoAACAAQQNqIAVBAmotAAAiEkE/cUH72c8Aai0AADoAACAAQQJqIAVBAWotAAAiBUECdCASQQZ2ckE/cUH72c8Aai0AADoAACAAQQFqIBFBBHQgBUEEdnJBP3FB+9nPAGotAAA6AAAgAiEAIAciBSANSQ0ACwsgDEEBaw4CAwQGCyAFIAVBA2pBnJiBARCxOwALIAVBA2ogCEGcmIEBELA7AAsgACAAQQRqQayYgQEQsTsACyACIARJBEBBAiEHIAIgBmogDSAOai0AACIAQQJ2QfjZzwBqLQADOgAAIABBBHRBMHEgBCACQQFqIgBLDQIaIAAgBEGMmIEBEMMhAAsgAiAEQfyXgQEQwyEACyACIARPDQIgAiAGaiANIA5qLQAAIgdBAnZB+9nPAGotAAA6AAAgDUEBaiIAIAhPDQMgAkEBaiIFIARPDQQgBSAGaiAHQQR0IAAgDmotAAAiBUEEdnJBP3FB+9nPAGotAAA6AAAgAkECaiIAIARPDQVBAyEHIAVBAnRBPHELIQUgACAGaiAFQfjZzwBqLQADOgAAIAIgB2ohAgsgAgwECyACIARBvJeBARDDIQALIAAgCEHMl4EBEMMhAAsgBSAEQdyXgQEQwyEACyAAIARB7JeBARDDIQALIgBB+NnPAC0AAEEBRgR/IAAgBEsNAQJ/IAAgBmohByAEIABrIQVBACECAkBBACAAa0EDcSIIBEADQCACIAVGDQIgAiAHakE9OgAAIAggAkEBaiICRw0ACwsgCAwBCyAFIAVB3JaBARDDIQALBUEACyAAaksNAQwCCyAAIARBwPLOABCvOwALQdDyzgBBKkH88s4AEMskAAsgCSgCECEAIAlBHGogBiAEEJ0JAkAgCSgCHEUEQCAErSETIAYhBAwBCyAJKQIgIRMgAEGAgICAeEcNAiAGIQALIA8gEz4CCCAPIACtIAStQiCGhDcCACAJQTBqJAAMAgtB0PPOAEEtQYD0zgAQyyQACyAJIBM3AiggCSAANgIcIAkgBq0gBK1CIIaENwIgQaD0zgBBDCAJQRxqQaTvzgBBrPTOABDVHgALIBAQ3jsgA0HMAGoQ3jsgA0HYAGoQ3jsCQCADQRhqIgYoAgQiBEUNACAGKAIMIgUEQCAGKAIAIgBBCGohAiAAKQMAQn+FQoCBgoSIkKDAgH+DIRMDQCATUARAA0AgAEGABWshACACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyITQoCBgoSIkKDAgH9RDQALIBNCgIGChIiQoMCAf4UhEwsgACATeqdBA3ZBsH9sakHIAGsQ9yYgE0IBfSATgyETIAVBAWsiBQ0ACwsgBCAEQdAAbEHXAGpBeHEiAGpBCWoiAkUNACAGKAIAIABrIAJBCBD4OgsgA0E4ahDjPCADQYABaiQADAMLIAYgAygCeEHk3c8AEP0vAAtBAUEEEKM9AAsgBiADKAJ4QeSjzwAQ/S8ACyAKQRhqQQxBAEEBQQEQoBggCigCHCEIIAooAhhBAUcEQCAKKAIgIgdBCGpBxNnPACgAADYAACAHQbzZzwApAAA3AAACfyABKAJsQYCAgIB4RwRAIAEoAnQhCyABKAJwDAELIAFBADYCdCABQoCAgIDAADcCbEEECyEAIAFB7ABqIQYgC0EYbCELQX8hAgJAAkADQCALRQ0BIAtBGGshCyACQQFqIQIgACgCCCEEIAAoAgQgAEEYaiEAIARBvNnPAEEMEMEuRQ0ACyAKQRhqIQACQCAGKAIIIgUgAksEQCAAIAYoAgQgAkEYbGoiBCkCADcCACAAQQhqIARBCGopAgA3AgAgAEEQaiAEQRBqKQIANwIAIAUgAkF/c2pBGGwiAgRAIAQgBEEYaiAC/AoAAAsgBiAFQQFrNgIIDAELIwBBMGsiACQAIAAgBTYCBCAAIAI2AgAgAEEDNgIMIABB/MSJATYCCCAAQgI3AhQgACAAQQRqrUKAgICAsAeENwMoIAAgAK1CgICAgLAHhDcDICAAIABBIGo2AhAgAEEIakG03s8AEO8sAAsgABDeOyAKQSRqEIYwIAEoAnQiCyABKAJsRw0BIAZBxN7PABCRKAwBCyABKAJ0IgsgASgCbEcNACAGQaTezwAQkSgLIAEoAnAgC0EYbGoiAEEMNgIIIAAgBzYCBCAAIAg2AgAgACAKKQIMNwIMIABBFGogCkEUaigCADYCACABIAtBAWo2AnQgCkEwaiQADwsgCCAKKAIgQeSjzwAQ/S8AC/kCAgV/BH4jAEHwAGsiAiQAAkACQAJAIAEoAgwiBgR/IAEoAggiAyABKAIEIgRLDQIgASgCACEEIAEgBkEBazYCDCABIANBBGo2AgggAiADIARqKAAAIgQ6AB8gAkIBQgAgBEH/AHEQxiMgASgCECIDKQMAIgcgAikDACIIgyADKQMIIgkgAikDCCIKg4RQRQ0DIAMgByAIhDcDACADIAkgCoQ3AwhBAQVBAAtFDQAgASgCGCIDIAEoAiBGDQAgASADQcgAajYCGCADKAI0IgFBgICAgHhGDQAgAkEoaiIFIANBNPwKAAAgAkHoAGogA0FAaykDADcDACACIAE2AlwgAiADKQM4NwNgIAUQ0CkhBQsgACAFNgIEIAAgBDoAACACQfAAaiQADwsgAyAEQdDt/gAQrzsACyACQQE2AiwgAkH07f4ANgIoIAJCATcCNCACQfQLNgIkIAIgAkEgajYCMCACIAJBH2o2AiAgAkEoakH87f4AEO8sAAuRAwEGfyMAQaACayICJAAgASgCKCEDIAJB4AFqIAFBCGooAgA2AgAgAkEAOwGQAiACQQA2AowCIAJBADYC9AEgAkEANgLoASACIANBAnY2AuQBIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACIAEpAgA3AtgBIAJB3ABqIgQgAkG4AWoiBSABQSxqEMIZAkBBGEEEEK02IgMEQCADIAEpAhQ3AgAgAyABKQIgNwIMIANBCGogAUEcaigCADYCACADQRRqIAFBKGooAgA2AgAgAkECNgKcAiACIAM2ApgCIAJBAjYClAIgBSAEIAJBlAJqEJYpQcQAQQQQrTYiA0UNASADIAEoAgwiBiABKAIQIgcoAghBAWtBeHFqQQhqIAcoAhQRAAAgAkEBNgJkIAIgAzYCYCACQQE2AlwgAiAFIAQQ/CIgACACEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQQxqELsjCyACQaACaiQADwtBBEEYEKM9AAtBBEHEABCjPQALkQMBBn8jAEGgAmsiAiQAIAEoAighAyACQeABaiABQQhqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQN2NgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQIANwLYASACQdwAaiIEIAJBuAFqIgUgAUEsahDCGQJAQRhBBBCtNiIDBEAgAyABKQIUNwIAIAMgASkCIDcCDCADQQhqIAFBHGooAgA2AgAgA0EUaiABQShqKAIANgIAIAJBAjYCnAIgAiADNgKYAiACQQI2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABKAIMIgYgASgCECIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCAGIAYoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBGBCjPQALQQRBxAAQoz0AC9sCAQp/IAAgAUECdEEEayIEaiEHIAIgBGohCCAAIAFBAXYiCkECdGoiBEEEayEFA0AgAiAAIAQgBCgCACIDKAIEIAAoAgAiBigCBCADKAIIIgMgBigCCCIGIAMgBkkbEJknIgkgAyAGayAJGyIJQQBOIgsbKAIANgIAIAggByAFIAcoAgAiAygCBCAFKAIAIgYoAgQgAygCCCIDIAYoAggiBiADIAZJGxCZJyIMIAMgBmsgDBsiA0EAThsoAgA2AgAgACALQQJ0aiEAIAQgCUEddkEEcWohBCAFIANBH3UiA0ECdGohBSAHIANBf3NBAnRqIQcgCEEEayEIIAJBBGohAiAKQQFrIgoNAAsgBUEEaiEFIAFBAXEEfyACIAAgBCAAIAVJIgEbKAIANgIAIAQgACAFT0ECdGohBCAAIAFBAnRqBSAACyAFRyAEIAdBBGpHckUEQA8LEOQrAAuHAwIFfwN+IwBBIGsiAiQAAkACQAJAIAEOAgACAQsgAEEANgIIDAELIAFpQQFHBEAgACgCCCIDRQ0BIAAoAgQhBCADQQJ0IQUgAa0hCUEAIQEDQCABIARqIgYgBjUCACAJfiAHfCIIPgIAIAhCIIghByAFIAFBBGoiAUcNAAsgCEKAgICAEFQNASAAKAIAIANGBH8gAEGAjYgBEJ0oIAAoAgQFIAQLIANBAnRqIAc+AgAgACADQQFqNgIIDAELIAAoAgQhAyAAKAIAIQQgAEGwjYgBKQIANwIAIABBCGoiBigCACEFIAZBuI2IASgCADYCAAJAAkACQCAEQYCAgIB4RgRAIAMoAggNASACQQhqIAMQ6R0MAwsgBUUNAQsgAiAFNgIcIAIgAzYCGCACIAQ2AhQgAkEIaiACQRRqQQAgAWgQqAUMAQsgAkEANgIQIAIgAzYCDCACIAQ2AggLIABBBEEEEOAeIABBCGogAkEQaigCADYCACAAIAIpAgg3AgALIAJBIGokAAuOAwIFfwFvIwBBMGsiACQAIABBIGpBzKuIARD9KSAAKAIkIQICQCAAKAIgIgRBAXEEQCAEIQEgAiEDDAELIABBGGpB0KuIARD9KSAAKAIcIQMgACgCGCEBIARFIAJBhAFJcg0AIAIQ8h8LAkAgAUEBcQRAIAEhAiADIQQMAQsgAEEQakHIq4gBEP0pIAAoAhQhBCAAKAIQIQIgAUUgA0GEAUlyDQAgAxDyHwsCQCACQQFxBEAgAiEDIAQhAQwBCyAAQQhqQdSriAEQ/SkgACgCDCEBIAAoAgghAyACRSAEQYQBSXINACAEEPIfCwJAAkAgA0EBcUUNACAAIAE2AiwgAEEsahCpO0UNASABQYQBSQ0AIAEQ8h8LQdiriAFBCxA9IQUQ3xIiASAFJgEgACABNgIoIABBgAE2AiwgACAAQShqIABBLGoQgiQgACgCACICQQFxRSAAKAIEIgNBhAFJckUEQCADEPIfCyABQYQBTwRAIAEQ8h8LQYABIAMgAkEBcRshAQsgAEEwaiQAIAEL3y8BFH8jAEEQayIXJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAEiAiACQQF2aiIGBEAgBCgCACEEA0ACQAJ/IAIgBkEBayIGTQRAIAYgAmsMAQsgAC0AACEBIAAgACAGaiIDLQAAOgAAIAMgAToAAEEACyIDQQF0IgdBAXIiASACIAYgAiAGSRsiDE8NAANAIAdBAmoiByAMSQRAIAAgAWogACAHaiAEKAIAKAIAEQIAQR92IAFqIQELIAAgA2oiAyAAIAFqIgcgBCgCACgCABECAEEATg0BIAMtAAAhBSADIActAAA6AAAgByAFOgAAIAEhAyABQQF0IgdBAXIiASAMSQ0ACwsgBg0ACwsMAwsgACABQQN2IgxBB2xqIQYgACAMQQJ0aiEHAn8gAUHAAE8EQCAAIAcgBiAMIAQQyxgMAQsgACAAIAcgBCgCACIMKAIAKAIAEQIAIgUgACAGIAwoAgAoAgARAgBzQQBIDQAaIAYgByAHIAYgDCgCACgCABECACAFc0EASBsLIABrIQYCQAJAIAJFDQAgAiAAIAZqIgcgBCgCACgCACgCABECAEEASA0AIBcgBDYCDAJ/QQAgAUUNABogF0EMaiECAkAgASAGTQ0AIAAtAAAhBiAAIActAAA6AAAgByAGOgAAIABBAWohByMAQRBrIgUkACABQQFrIg0EfyAFIActAAA6AA8gAigCACEJQQAhDCAHIgZBAWoiAiAGIA1qIg1BAWsiEEkEQCAGIQIDQCAAIAJBAWoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIAxqIgYtAAA6AAAgBiAKLQAAOgAAIAAgAkECaiIGIAkoAgAoAgAoAgARAgAhEyAKIAcgDCASQX9zQR92aiIMaiIKLQAAOgAAIAogBi0AADoAACAMIBNBf3NBH3ZqIQwgAkEDaiAGIQIgEEkNAAsgBkEBaiECCyACIA1HBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAMaiIGLQAAOgAAIAYgAi0AADoAACAMIApBf3NBH3ZqIQwgAiIGQQFqIgIgDUcNAAsgAkEBayEGCyAAIAVBD2ogCSgCACgCACgCABECACECIAYgByAMaiIGLQAAOgAAIAYgBS0ADzoAACAMIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgAC0AACEGIAAgACACaiIHLQAAOgAAIAcgBjoAACACDAELAAsiBkEBaiECIAEgBksEQCAAIAJqIQAgASACayEBQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAtAAAhByAAIAAgBmoiBi0AADoAACAGIAc6AAAgAEEBaiEMIwBBEGsiCSQAIAFBAWsiCgR/IAkgDC0AADoADyAEKAIAIQ1BACEFIAwiB0EBaiIGIAcgCmoiCkEBayISSQRAIAchBgNAIAZBAWoiECAAIA0oAgAoAgARAgAhEyAGIAUgDGoiBy0AADoAACAHIBAtAAA6AAAgBkECaiIHIAAgDSgCACgCABECACAQIAwgE0EfdiAFaiIFaiIQLQAAOgAAIBAgBy0AADoAAEEfdiAFaiEFIAZBA2ogByEGIBJJDQALIAZBAWohBgsgBiAKRwRAA0AgBiAAIA0oAgAoAgARAgAgByAFIAxqIgctAAA6AAAgByAGLQAAOgAAQR92IAVqIQUgBiEHIAZBAWoiBiAKRw0ACyAGQQFrIQcLIAlBD2ogACANKAIAKAIAEQIAIAcgBSAMaiIHLQAAOgAAIAcgCS0ADzoAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAtAAAhByAAIAAgBmoiDC0AADoAACAMIAc6AAAgBgwBCwALIgYgAiADIAQQ5Q4gASAGQX9zaiEBIAAgBmoiAkEBaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBIGsiBiQAAkACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgwgAUESSSIYGyECIAEgDGshByAAIAxqIQwDQAJ/IAJBDE0EQEEBIAJBCE0NARoCQCACQQlPBEAgACAAQQNqIgkgACAEKAIAIgUoAgAoAgARAgAiDUEfdUEDcWotAAAhCiAAIABBA0EAIA1BAE4bai0AADoAAyAAIAo6AAAgAEEHQQEgAEEHaiISIABBAWoiEyAFKAIAKAIAEQIAQQBIIg0bai0AACEKIAAgAEEBQQcgDRtqLQAAOgAHIAAgCjoAASAAQQVBAiAAQQVqIg0gAEECaiIQIAUoAgAoAgARAgBBAEgiChtqLQAAIQ4gACAAQQJBBSAKG2otAAA6AAUgACAOOgACIABBCEEEIABBCGoiFCAAQQRqIgogBSgCACgCABECAEEASCIOG2otAAAhCyAAIABBBEEIIA4bai0AADoACCAAIAs6AAQgACASIAAgBSgCACgCABECACIOQR91QQdxai0AACELIAAgAEEHQQAgDkEAThtqLQAAOgAHIAAgCzoAACAAQQRBAiAKIBAgBSgCACgCABECAEEASCIOG2otAAAhCyAAIABBAkEEIA4bai0AADoABCAAIAs6AAIgAEEIQQMgFCAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIQsgACAAQQNBCCAOG2otAAA6AAggACALOgADIABBBkEFIABBBmoiDiANIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQVBBiALG2otAAA6AAYgACAPOgAFIAAgECAAIAUoAgAoAgARAgAiC0EedkECcWotAAAhDyAAIAAgC0F/c0EedkECcWotAAA6AAIgACAPOgAAIABBA0EBIAkgEyAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEEBQQMgCxtqLQAAOgADIAAgDzoAASAAQQVBBCANIAogBSgCACgCABECAEEASCILG2otAAAhDyAAIABBBEEFIAsbai0AADoABSAAIA86AAQgAEEIQQcgFCASIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQdBCCALG2otAAA6AAggACAPOgAHIABBBEEBIAogEyAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEEBQQQgCxtqLQAAOgAEIAAgDzoAASAAQQZBAyAOIAkgBSgCACgCABECAEEASCILG2otAAAhDyAAIABBA0EGIAsbai0AADoABiAAIA86AAMgAEEHQQUgEiANIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQVBByALG2otAAA6AAcgACAPOgAFIAAgEyAAIAUoAgAoAgARAgAiC0EfdmotAAAhDyAAIAAgC0F/c0EfdmotAAA6AAEgACAPOgAAIABBBEECIAogECAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEECQQQgCxtqLQAAOgAEIAAgDzoAAiAAQQVBAyANIAkgBSgCACgCABECAEEASCILG2otAAAhDyAAIABBA0EFIAsbai0AADoABSAAIA86AAMgAEEIQQYgFCAOIAUoAgAoAgARAgBBAEgiFBtqLQAAIQsgACAAQQZBCCAUG2otAAA6AAggACALOgAGIABBA0ECIAkgECAFKAIAKAIAEQIAQQBIIhQbai0AACELIAAgAEECQQMgFBtqLQAAOgADIAAgCzoAAiAAQQVBBCANIAogBSgCACgCABECAEEASCIUG2otAAAhCyAAIABBBEEFIBQbai0AADoABSAAIAs6AAQgAEEHQQYgEiAOIAUoAgAoAgARAgBBAEgiEhtqLQAAIRQgACAAQQZBByASG2otAAA6AAcgACAUOgAGIABBAkEBIBAgEyAFKAIAKAIAEQIAQQBIIhAbai0AACESIAAgAEEBQQIgEBtqLQAAOgACIAAgEjoAASAAQQRBAyAKIAkgBSgCACgCABECAEEASCIJG2otAAAhCiAAIABBA0EEIAkbai0AADoABCAAIAo6AAMgAEEGQQUgDiANIAUoAgAoAgARAgBBAEgiBRtqLQAAIQkgACAAQQVBBiAFG2otAAA6AAYgACAJOgAFDAELAAtBCQwBCwJAIAJBDU8EQCAAIABBDGoiESAAIAQoAgAiBSgCACgCABECACIJQR91QQxxai0AACENIAAgAEEMQQAgCUEAThtqLQAAOgAMIAAgDToAACAAQQpBASAAQQpqIg4gAEEBaiIPIAUoAgAoAgARAgBBAEgiCRtqLQAAIQ0gACAAQQFBCiAJG2otAAA6AAogACANOgABIABBCUECIABBCWoiDSAAQQJqIhQgBSgCACgCABECAEEASCIJG2otAAAhCiAAIABBAkEJIAkbai0AADoACSAAIAo6AAIgAEEHQQMgAEEHaiILIABBA2oiCiAFKAIAKAIAEQIAQQBIIgkbai0AACEQIAAgAEEDQQcgCRtqLQAAOgAHIAAgEDoAAyAAQQtBBSAAQQtqIhYgAEEFaiIQIAUoAgAoAgARAgBBAEgiCRtqLQAAIRIgACAAQQVBCyAJG2otAAA6AAsgACASOgAFIABBCEEGIABBCGoiEiAAQQZqIgkgBSgCACgCABECAEEASCITG2otAAAhCCAAIABBBkEIIBMbai0AADoACCAAIAg6AAYgAEEGQQEgCSAPIAUoAgAoAgARAgBBAEgiExtqLQAAIQggACAAQQFBBiATG2otAAA6AAYgACAIOgABIABBA0ECIAogFCAFKAIAKAIAEQIAQQBIIhMbai0AACEIIAAgAEECQQMgExtqLQAAOgADIAAgCDoAAiAAQQtBBCAWIABBBGoiEyAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEEQQsgCBtqLQAAOgALIAAgFToABCAAQQlBByANIAsgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBB0EJIAgbai0AADoACSAAIBU6AAcgAEEKQQggDiASIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQhBCiAIG2otAAA6AAogACAVOgAIIAAgEyAAIAUoAgAoAgARAgAiCEEddkEEcWotAAAhFSAAIAAgCEF/c0EddkEEcWotAAA6AAQgACAVOgAAIABBAkEBIBQgDyAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEBQQIgCBtqLQAAOgACIAAgFToAASAAQQZBAyAJIAogBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBA0EGIAgbai0AADoABiAAIBU6AAMgAEEIQQcgEiALIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQdBCCAIG2otAAA6AAggACAVOgAHIABBCkEJIA4gDSAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEJQQogCBtqLQAAOgAKIAAgFToACSAAQQxBCyARIBYgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBC0EMIAgbai0AADoADCAAIBU6AAsgAEEGQQQgCSATIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQRBBiAIG2otAAA6AAYgACAVOgAEIABBCUEFIA0gECAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEFQQkgCBtqLQAAOgAJIAAgFToABSAAQQtBCCAWIBIgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBCEELIAgbai0AADoACyAAIBU6AAggAEEMQQogESAOIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQpBDCARG2otAAA6AAwgACAIOgAKIAAgECAAIAUoAgAoAgARAgAiEUEfdUEFcWotAAAhCCAAIABBBUEAIBFBAE4bai0AADoABSAAIAg6AAAgAEEIQQMgEiAKIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQNBCCARG2otAAA6AAggACAIOgADIABBB0EEIAsgEyAFKAIAKAIAEQIAQQBIIhEbai0AACEIIAAgAEEEQQcgERtqLQAAOgAHIAAgCDoABCAAQQtBBiAWIAkgBSgCACgCABECAEEASCIRG2otAAAhCCAAIABBBkELIBEbai0AADoACyAAIAg6AAYgAEEKQQkgDiANIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQlBCiARG2otAAA6AAogACAIOgAJIAAgDyAAIAUoAgAoAgARAgAiEUEfdmotAAAhCCAAIAAgEUF/c0EfdmotAAA6AAEgACAIOgAAIABBBUECIBAgFCAFKAIAKAIAEQIAQQBIIhEbai0AACEIIAAgAEECQQUgERtqLQAAOgAFIAAgCDoAAiAAQQlBBiANIAkgBSgCACgCABECAEEASCIRG2otAAAhCCAAIABBBkEJIBEbai0AADoACSAAIAg6AAYgAEEIQQcgEiALIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQdBCCARG2otAAA6AAggACAIOgAHIABBC0EKIBYgDiAFKAIAKAIAEQIAQQBIIhYbai0AACERIAAgAEEKQQsgFhtqLQAAOgALIAAgEToACiAAQQNBASAKIA8gBSgCACgCABECAEEASCIWG2otAAAhESAAIABBAUEDIBYbai0AADoAAyAAIBE6AAEgAEEEQQIgEyAUIAUoAgAoAgARAgBBAEgiFhtqLQAAIREgACAAQQJBBCAWG2otAAA6AAQgACAROgACIABBBkEFIAkgECAFKAIAKAIAEQIAQQBIIhYbai0AACERIAAgAEEFQQYgFhtqLQAAOgAGIAAgEToABSAAQQpBCSAOIA0gBSgCACgCABECAEEASCIOG2otAAAhFiAAIABBCUEKIA4bai0AADoACiAAIBY6AAkgAEECQQEgFCAPIAUoAgAoAgARAgBBAEgiDhtqLQAAIQ8gACAAQQFBAiAOG2otAAA6AAIgACAPOgABIABBBEEDIBMgCiAFKAIAKAIAEQIAQQBIIg4bai0AACEPIAAgAEEDQQQgDhtqLQAAOgAEIAAgDzoAAyAAQQdBBSALIBAgBSgCACgCABECAEEASCIOG2otAAAhDyAAIABBBUEHIA4bai0AADoAByAAIA86AAUgAEEIQQYgEiAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIQ8gACAAQQZBCCAOG2otAAA6AAggACAPOgAGIABBA0ECIAogFCAFKAIAKAIAEQIAQQBIIg4bai0AACEUIAAgAEECQQMgDhtqLQAAOgADIAAgFDoAAiAAQQVBBCAQIBMgBSgCACgCABECAEEASCIOG2otAAAhFCAAIABBBEEFIA4bai0AADoABSAAIBQ6AAQgAEEHQQYgCyAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIRQgACAAQQZBByAOG2otAAA6AAcgACAUOgAGIABBCUEIIA0gEiAFKAIAKAIAEQIAQQBIIg0bai0AACESIAAgAEEIQQkgDRtqLQAAOgAJIAAgEjoACCAAQQRBAyATIAogBSgCACgCABECAEEASCING2otAAAhCiAAIABBA0EEIA0bai0AADoABCAAIAo6AAMgAEEGQQUgCSAQIAUoAgAoAgARAgBBAEgiBRtqLQAAIQkgACAAQQVBBiAFG2otAAA6AAYgACAJOgAFDAELAAtBDQsiBUEBayACTw0CIAIgBUcEQANAIAAgACAFaiAEEMAeIAIgBUEBaiIFRw0ACwsgGA0BIAAgA0YgByECIAwhAA0ACyABQQFrIgcgBiICaiEJIAcgAyIAaiEMIAAgAUEBdiINaiIHQQFrIQUgBCgCACEEA0AgAiAAIAcgByAAIAQoAgAoAgARAgAiCkEATiIQGy0AADoAACAJIAwgBSAMIAUgBCgCACgCABECACISQQBOIhMbLQAAOgAAIAAgEGohACAHIApBH3ZqIQcgBSASQR91aiEFIAwgE2shDCAJQQFrIQkgAkEBaiECIA1BAWsiDQ0ACyAFQQFqIQQgAUEBcQR/IAIgACAHIAAgBEkiAhstAAA6AAAgByAAIARPaiEHIAAgAmoFIAALIARHIAcgDEEBakdyBEAQ5CsACyABRQ0AIAMgBiAB/AoAAAsgBkEgaiQADAELAAsLIBdBEGokAAucAwICfwJ+IwBBkAFrIgIkACAAKAIEKAIQIAFBA3RqKQMAIQQgAiAAKAIAIgMoAgAoAgApAwAiBTcDSCACIAQ3A0AgAkEQaiAEIARCP4cgBSAFQj+HEKgeAkACQAJAIAIpAxggAikDECIEQj+HUgRAIAJBAjYCbCACQayQ/wA2AmggAkICNwJ0IAJBhgw2AowBIAJBhgw2AoQBIAIgAkGAAWo2AnAgAiACQcgAajYCiAEgAiACQUBrNgKAASACQdgAaiACQegAahCZDiACQTRqIAJB3ABqKQIANwIAIAJBPGogAkHkAGooAgA2AgAgAkGIgICAeDYCVCACIAIpAlQ3AiwgAkEBNgIoIAJBKGpBBHIQiBEMAQsgBCADKAIELQAAEMUpRQ0AIAAoAgggAUEDdGogBDcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGQAWokAA8LIAAgA0GIi/8AEMMhAAuGAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFqLAAAIQMgAiAAKAIAIgQoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC4YDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAWotAAAhAyACIAAoAgAiBCgCACgCACIFNgIgIAIgAzYCHAJAAkACQAJAIAWsIAOtfiIGQiCIpyAGpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALnAMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQJ0ajQCACEEIAIgACgCACIDKAIAKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQAL7QIBDH8jAEEQayIGJAACQCABKAIQIgMgASgCDCICSQ0AIAMgASgCCCIHSw0AIAFBE2ohDCABQRRqIQ0DQCABKAIEIAJqIQogDCABLQAYIgRqLQAAIQgCQAJAAkAgAyACayILQQdNBEAgAiADRg0BQQAhBQNAIAUgCmotAAAgCEYNBCALIAVBAWoiBUcNAAsMAQsgBkEIaiAIIAogCxCdEiAGKAIIQQFxDQEgASgCECEDCyABIAM2AgwMAwsgBigCDCEFIAEtABghBCABKAIIIQcgASgCDCECCyABIAIgBWpBAWoiAjYCDAJAIAIgBEkgAiAHS3INACAEQQVJBEAgAiAEayIIIAEoAgRqIAQgDSAEEMEuIAEoAgwhAkUEQCABKAIIIQcMAgsgACACNgIIIAAgCDYCBEEBIQkMAwsgBEEEQaDDgAEQsDsACyABKAIQIgMgAkkNASADIAdNDQALCyAAIAk2AgAgBkEQaiQAC5IDAgd/AX4jAEHwAmsiAiQAIAFBGGoiCBD0NSEDIAJB6AFqQZSo0KABNgIAIAJClKjQoMGChYoUNwLgASACQgQ3AtgBIAJCADcC0AEgAkKAgICAwAA3AsgBIAJBADYCwAEgAkEAOwGYAiACQQA2ApQCIAJBADYC/AEgAkEANgLwASACIAM2AuwBIAJB6ABqIAFBFGoiAygCADYCACADQQA2AgAgASkCDCEJIAFCgICAgMAANwIMIAIgCTcDYCACQaACaiIGIAJB4ABqIgQQ8RggBCACQcABaiIHIAYQ+iMgAkHIAWogAUEIaiIFKAIANgIAIAVBADYCACABKQIAIQkgAUKAgICAEDcCACACIAk3A8ABIAYgBxCTGSAHIAQgBhD6IyAEIAgQ9BIgAkEEaiAHIAQQwhkgBSgCACEFIAMoAgAiAyABKAIMRgRAIAFBDGpB3OaFARCdKAsgASgCECADQQJ0aiAFNgIAIAEgA0EBajYCFCACQawCaiIBIAJBBGoQzRwgACABEI0MIAJB8AJqJAALkgMCB38BfiMAQfACayICJAAgAUEYaiIIEPQ1IQMgAkHoAWpBlqzYsAE2AgAgAkKWrNiw4cKFixY3AuABIAJCBDcC2AEgAkIANwLQASACQoCAgIDAADcCyAEgAkEANgLAASACQQA7AZgCIAJBADYClAIgAkEANgL8ASACQQA2AvABIAIgAzYC7AEgAkHoAGogAUEUaiIDKAIANgIAIANBADYCACABKQIMIQkgAUKAgICAgAE3AgwgAiAJNwNgIAJBoAJqIgUgAkHgAGoiBBDzGCAEIAJBwAFqIgYgBRD6IyACQcgBaiABQQhqIgcoAgA2AgAgB0EANgIAIAEpAgAhCSABQoCAgIAQNwIAIAIgCTcDwAEgBSAGEJMZIAYgBCAFEPojIAQgCBD0EiACQQRqIAYgBBDCGSAHNQIAIQkgAygCACIDIAEoAgxGBEAgAUEMakHc5oUBELMoCyABKAIQIANBA3RqIAk3AwAgASADQQFqNgIUIAJBrAJqIgEgAkEEahDNHCAAIAEQiwwgAkHwAmokAAuSAwIHfwF+IwBB8AJrIgIkACABQRhqIggQ9DUhAyACQegBakGYsODAATYCACACQpiw4MCBg4aMGDcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiADNgLsASACQegAaiABQRRqIgMoAgA2AgAgA0EANgIAIAEpAgwhCSABQoCAgIDAADcCDCACIAk3A2AgAkGgAmoiBiACQeAAaiIEEPEYIAQgAkHAAWoiByAGEPojIAJByAFqIAFBCGoiBSgCADYCACAFQQA2AgAgASkCACEJIAFCgICAgBA3AgAgAiAJNwPAASAGIAcQkxkgByAEIAYQ+iMgBCAIEPQSIAJBBGogByAEEMIZIAUoAgAhBSADKAIAIgMgASgCDEYEQCABQQxqQdzmhQEQnSgLIAEoAhAgA0ECdGogBTYCACABIANBAWo2AhQgAkGsAmoiASACQQRqEM0cIAAgARCODCACQfACaiQAC5IDAgd/AX4jAEHwAmsiAiQAIAFBGGoiCBD0NSEDIAJB6AFqQZmy5MgBNgIAIAJCmbLkyJGjxowZNwLgASACQgQ3AtgBIAJCADcC0AEgAkKAgICAwAA3AsgBIAJBADYCwAEgAkEAOwGYAiACQQA2ApQCIAJBADYC/AEgAkEANgLwASACIAM2AuwBIAJB6ABqIAFBFGoiAygCADYCACADQQA2AgAgASkCDCEJIAFCgICAgIABNwIMIAIgCTcDYCACQaACaiIFIAJB4ABqIgQQ8xggBCACQcABaiIGIAUQ+iMgAkHIAWogAUEIaiIHKAIANgIAIAdBADYCACABKQIAIQkgAUKAgICAEDcCACACIAk3A8ABIAUgBhCTGSAGIAQgBRD6IyAEIAgQ9BIgAkEEaiAGIAQQwhkgBzUCACEJIAMoAgAiAyABKAIMRgRAIAFBDGpB3OaFARCzKAsgASgCECADQQN0aiAJNwMAIAEgA0EBajYCFCACQawCaiIBIAJBBGoQzRwgACABEIwMIAJB8AJqJAAL/QICB38BfiMAQSBrIgQkAEGAgICAeCECAkAgASgCACIFQYCAgIB4RgRAIAEoAgwhBwwBCyABKAIIQQN0IQMgASgCBCIIIQICQANAIAMEQCADQQhrIQMgAi0ABCACQQhqIQINAQwCCwsgBEKEgICAwAA3AhAgBEKAgICAwAA3AhggBEEEaiAEQRBqEOcMIAFBBEEIEOAeIAFBCGogBEEMaigCADYCACABIAQpAgQ3AgAgASgCBCEIIAEoAgAhBQtBgICAgHghAiABKAIMIQcgBUGAgICAeEYNACABKQIEIglCIIinIQMCQCAJQoCAgIAQVA0AIAmnIgEgA0EDdCICakEIRg0AIAEgAmoiAkEEay0AAEEBRw0AIANBAWshASACQRBrIQIDQCABIgNFIAJFcg0BIAFBAWshASACQQRqIAJBCGshAi0AAEEBRg0ACwsgBSECCyAAIAM2AgwgAEEANgIIIAAgCDYCBCAAIAI2AgAgACAHNgIQIARBIGokAAuCAwEEfyMAQTBrIgIkACAAKAIAIgBBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEEAkBBACAAKAIwIgVrQQNxIgMgACgCCCAFa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAQgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIARBBBCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBCIDQQNLBEAgAigCACADIAFrNgAAIAAoAjAhAyAAKAIUIgEgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAUEDdGoiBEEIOwEEIAQgAzYCACAAIAFBAWo2AhQgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALggMBBH8jAEEwayICJAAgACgCACIAQQQgACgCNCIDIANBBE0bNgI0IABBMGohBAJAQQAgACgCMCIFa0EDcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EDSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAEQQQQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGsx/4AENcmIAIoAgQiA0EDSwRAIAIoAgAgAyABazYAACAAKAIwIQMgACgCFCIBIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIAFBA3RqIgRBBjsBBCAEIAM2AgAgACABQQFqNgIUIAJBMGokAA8LIAJBADYCKCACQQE2AhwgAkH0yP4ANgIYIAJCBDcCICACQRhqQbzH/gAQ7ywAC4IDAQR/IwBBMGsiAiQAIAAoAgAiAEEEIAAoAjQiAyADQQRNGzYCNCAAQTBqIQQCQEEAIAAoAjAiBWtBA3EiAyAAKAIIIAVrTQ0AIAAoAgggACgCMGsgA08NAANAIAAQ+xYgACgCCCAAKAIwayADSQ0ACwsgBCADEI03IAAoAgggACgCMGtBA0siAyADckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IAJBEGogABDcOyACKAIUIQMgAigCECEEIAJBCGogACgCMBCMNyACIAQgAyACKAIIIAIoAgxBrMf+ABDXJiACKAIEIgNBA0sEQCACKAIAIAMgAWs2AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQo7AQQgBCADNgIAIAAgAUEBajYCFCACQTBqJAAPCyACQQA2AiggAkEBNgIcIAJB9Mj+ADYCGCACQgQ3AiAgAkEYakG8x/4AEO8sAAuCAwEEfyMAQTBrIgIkACAAKAIAIgBBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEEAkBBACAAKAIwIgVrQQNxIgMgACgCCCAFa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAQgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIARBBBCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBCIDQQNLBEAgAigCACADIAFrNgAAIAAoAjAhAyAAKAIUIgEgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAUEDdGoiBEEMOwEEIAQgAzYCACAAIAFBAWo2AhQgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQF0ajIBACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQN0aikDACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQJ0ajQCACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALkgYCDH8CfiMAQSBrIgMkACAAKAIoIQECfwJAAkAgACkDAEIBUgRAQQAgASAAKAIcIgIgAkECdmtHDQMaIAFFBEAgAEEHOwE4IANBFGoiAUEIQYDhwwAQsTYgA0EIaiABQZDhwwAQliEgAygCDCEBIAMoAgghAiAAKAIcIgQEQCAAKAIYIARBAnRBAhD4OgsgACABNgIcIAAgAjYCGCADQRRqQQZBAEEEQTQQoBggAygCGCEBIAMoAhRBAUYNAiADKAIcIQIgAEEgaiIEEN8eIAQQ1TsgAEEANgIoIAAgAjYCJCAAIAE2AiBBAAwECyAAIAJBAXQQtgoMAwsgAbMgACgCHCIBs5VDzcxMPmBFDQEgAEIANwMAIAAgAUEBdBC2CgwCCyABIAMoAhxBoOHDABD9LwALIwBBEGsiASQAAn5B+POKASgCAEEBRgRAQYj0igEpAwAhDUGA9IoBKQMADAELIAEQ4yZB+POKAUIBNwMAQYj0igEgASkDCCINNwMAIAEpAwALIQ4gACANNwMQIAAgDjcDCCAAQgI3AwBBgPSKASAOQgF8NwMAIAFBEGokACAAKAIcIgIEQCAAKAIYIgEgAkECdGohAgNAIAFB//8DNgEAIAFBBGoiASACRw0ACwsgACILKAIoIgEEQCAAKAIkIgUgAUE0bGohDCAALwE4IQcgACgCGCEIIAAoAhwhCgNAIAUgCyAFQSBqEKEJQf//A3EiBDsBMCAJIgJBAWohCSAFQTRqIQUgBCAHcSEAQQAhBgJAAkADQCAAIQFBACEAIAEgCk8NACAIIAFBAnRqIgAvAQBB//8DRg0BIAYgASAALwECIAdxayAHcU0EQCABQQFqIQAgBkEBaiEGDAELCwNAIAEhAEEAIQEgACAKTw0AIAggAEECdGoiAS8BACIGQf//A0cEQCABIAI7AQAgAS8BAiABIAQ7AQIgAEEBaiEBIQQgBiECDAELCyABIAI7AQAMAQsgACACOwEAIAEhAAsgCCAAQQJ0aiAEOwECIAUgDEcNAAsLQQALIANBIGokAAvmBQEEfyAALQC7KkUEQCAAQQhqIgFBCyABKAIUIgJBACACQQBKGyICIAJBC04bNgIUAkAgAQJ/QQogASgCGCICQQpIDQAaIAJBGUkNAUEYIAEtAFJBAUcNABogAkEfSQ0BQR4LNgIYCyABLQBUBEAgAUEBOgBWCyAAAn8gASgCFCICQQFNBEAgASgCGAwBC0EOIAJBA0wNABoCQCABKAIcIgNFBEAgAkEISw0BQRAMAgtBGEEQIAMgA0EQTBsiAiACQRhOGwwBC0EQQRIgASgCGCICIAJBEk8bIAJBEEwbCzYCJEEAIQICQCABKAIUQQROBEACQEEBIAEoAgQgASgCAEECRiIDGyICQQNLDQBBDCABKAIIIAMbIgNB+ABLDQAgAyACdkEPcSACdCADRg0CC0EAIQILQQAhAwsgASACIAMQxBUgAEF/NgKsKkEBIQIgAEEBIAEoAhwiAyABKAIYIgEgASADSBtBAWp0IgE2AvQpIABBASAAKAIkdCIDNgL8KSAAIAFBAWs2AvgpIAAgASADajYCgCpBEiAAKAIgIgEgAUESTBsgASAAKAIcIgRBAkkbIQMCQAJAAkAgAC0AWkUEQEEAIQEgA0EQaw4CAwECCyADQQh0QYD+AHFBEXIhAUEOIQIMAgtBByECQQEhAQwBCyADQRFMBEAgA0EEdEH/AGshAUEHIQIMAQsgA0EBdEEhayEBQQQhAgsgACACOgC+KiAAIAE7AbgqIARFBEAgAEHQImpBgAFBvO7RAEGAAUHU9dEAENUsIABB0CNqQZT20QBBgAL8CgAAIABB0CVqQTlBvO/RAEE5QYT20QAQ1SwgAEGkKmpBwAM2AgALIAAtAFxBAUYEQCAAQYACaiECQQAhAQNAIAEgAmpB8P///wc2AgAgAUEEaiIBQcAARw0ACyAAQcACaiECQQAhAQNAIAEgAmpB8P///wc2AgAgAUEEaiIBQRBHDQALCyAAQQE6ALsqCwufFgISfwN+IwBB0BNrIgEkACMAQSBrIgkkACAJQRBqEP0nIAkoAhQgCSgCECEKIAlBCGogCUEfaiAGQYAgIAVBAXEbIgVBgCAgBRsQuCkgCSgCCCELIAkoAgwhDCMAQdATayIHJAAgB0HIE2pBFUGAoNAAQQwQzRogB0EgaiENIQVBACEIIwBBoBVrIgYkACAGQThqEP0nIAYoAjwhDiAGKAI4IQ8gBkHYE2oQhSAgBkHwE2oQhSAgBkGIFGoQhSAgBkEwahD/JyAGKAI0IRAgBigCMCERIAZBKGoQ/ycgBigCLCESIAYoAighEyAGQSBqEP0nIAYoAiQhFCAGKAIgIRUDQCAGQaAUaiIWIAhqIhdBADsBACAXQQJqQQA6AAAgCEEEaiIIQYABRw0ACyAGQcIRakEAOwEAIAZBuhFqQgA3AQAgBkIANwGyESAGQcABakEAQcAM/AsAIAZBGGoQ/ycgBikDGCEZIAZB0BFqQQBBgAL8CwAgBkEQahD9JyAGKQMQIRogBkEIahD9JyAGQYgOakIANwMAIAZBkA5qQgA3AwAgBkGYDmpCADcDACAGQbgOakIANwMAIAZBwA5qQQA2AgAgBkIANwOADiAGQQA6AMoRIAZCADcDsA4gBkIANwPIDiAGKQMIIRsgBkGQEGpBAEEk/AsAIAZB2A5qIAZB4BNqKQIANwMAIAZB4A5qIAZB6BNqKQIANwMAIAZB8A5qIAZB+BNqKQIANwMAIAZB+A5qIAZBgBRqKQIANwMAIAZBADsBsBEgBiAONgKcDyAGIA82ApgPIAZCi4CAgMAANwOoDiAGQpCAgIDwATcDoA4gBkHEq/sANgKoESAGQQA2ArwQIAZCADcCtBAgBiAGKQLYEzcD0A4gBiAGKQLwEzcD6A4gBkHUEGpCADcCACAGQZAPaiAGQZgUaikCADcDACAGQYgPaiAGQZAUaikCADcDACAGQQA2AsgQIAZCADcDwBAgBiAQNgLMDyAGIBI2AtQPIAYgEzYC0A8gBiARNgLIDyAGQgA3AswQIAYgBikCiBQ3A4APIAZB2A9qQQBBNfwLACAGQQA7AdATIAZBADsBxBEgBiAUNgKkDyAGIBU2AqAPIAZBATYCrBEgBkHcEGpBAEEk/AsAIAZBQGsgFkGAAfwKAAAgBkGMEWpCADcCACAGQZQRakKAgICA8B83AgAgBkIANwKEESAGQRA2AoARIAZBADoAzxEgBiAZNwOoDyAGQQA7ANMTIAYgBUEARzoA0hMgBiAFNgKcESAGIAU2ArQPIAYgCjYCsA8gBkEANgDLESAGQQA2AcYRIAZCADcDoBEgBiAbNwPADyAGIBo3A7gPIwBBIGsiBSQAIAVBFGoiCEG4CBD3GyAFQQhqIAhB1Kj7ABCWISAGIAUpAwg3AwAgBUEgaiQAIAYoAgQhBSAGKAIAIQggBigCrA8iCgRAIAYoAqgPIApBAnRBAhD4OgsgBkEBOgDQEyAGIAg2AqgPIAYgBTYCrA8gBkGwDmoiBUHAADYCCCAFQgA3AwAgDSAGQUBrQZgT/AoAACAGQaAVaiQAIAdBADYCwBMgB0IANwO4EyAHIAw2AgwgByALNgIIIAdBADoAxBMgByADNgIUIAcgAjYCECAHIAcpA8gTNwMYIAFBCGoiCiAHQQhqQcAT/AoAACAHQdATaiQAIAlBIGokAEEAIQcjAEEwayIFJABBgMAAIQgCQAJAIAQoAgAiDCAEKAIIIgJrQSBPBEAgAiEDDAELIAVBEGogCiAEEJQTAkAgBS0AEEEERgRAIAUoAhQhAwwBCyAFKQMQIhlCIIinIQMgGaciBkH/AXFBBEYNACABIAM2AgQgASAGOgAAIAFBA2ogBkEYdjoAACABIAZBCHY7AAEMAgsgAwRAIAQoAgghAwwBCyABQQQ6AAAgAUEANgIEDAELA0ACQCADIAQoAgAiBkcgBiAMR3INACAFQRBqIAogBBCUEwJAIAUtABBBBEYEQCAFKAIUIQYMAQsgBSkDECIZQiCIpyEGIBmnIgNB/wFxQQRGDQAgASAGNgIEIAEgAzoAACABQQNqIANBGHY6AAAgASADQQh2OwABDAMLIAQoAgghAyAGBEAgBCgCACEGDAELIAFBBDoAACABIAMgAms2AgQMAgsCQAJAAkACQCADIAZGBEAgBUEIaiAEIAYQtCAgBSgCCEGBgICAeEcNASAEKAIAIQYgBCgCCCEDCyAEKAIEIQkgBSAHNgIcIAVBADYCGCAFIAMgCWo2AhAgBSAIIAYgA2siAyADIAhLGyIHNgIUIAVBIGogCiAFQRBqEIQWIAUtACAiA0EERw0BDAILIAFCgcwANwIADAQLA0BBACEGAkACQAJAAkAgA0H/AXFBAWsOAwECAAYLIAUoAiQtAAhBI0cNBQwCCyAFLQAhQSNGDQEMBAsgBSgCJC0ACEEjRw0DCyAFIAUpAyA3AyggBUEoahC5LiAFQSBqIAogBUEQahCEFiAFLQAgIgNBBEcNAAsLQQEhBgsgBCAFKAIYIgkgBCgCCGoiAzYCCCAFKAIcIQsCQCAGDQAgBSkDICIZpyIGQf8BcUEERg0AIAEgBjoAACABQQdqIBlCOIg8AAAgAUEFaiAZQiiIPQAAIAEgGUIIiD4AAQwCCyAJBEAgByAJRyAHQX8gCCAYQQFqQQAgByAJSxsiGEEBShsgCCAHIAtHGyIISXJFBEBBfyAIQQF0IAhBAEgbIQgLIAsgCWshBwwBBSABQQQ6AAAgASADIAJrNgIECwsLIAVBMGokAAJAIAEtAABBBEcEQCABIAEpAwA3A8gTIAAgAUHIE2oQgSsMAQsgACABKAIENgIEIABBCDYCAAsgASgCDCIABEAgASgCCCAAQQEQ+DoLIAEtABhBBEcEQCABQRhqELkuCyMAQUBqIgAkACABQSBqIgIQyhMgAEEANgI8IABCgICAgBA3AjQgAEEoaiAAQTRqQfSo+wAQkCEgAigC3A4hAyACKALYDiEEIAIgACkDKDcD2A4gAwRAIAQgA0EBEPg6CyAAQQA2AjwgAEKAgICAIDcCNCAAQSBqIABBNGpB9Kj7ABCWISACKAKMDyEDIAIoAogPIQQgAiAAKQMgNwOIDyADBEAgBCADQQJ0QQIQ+DoLIABBADYCPCAAQoCAgIAgNwI0IABBGGogAEE0akH0qPsAEJYhIAIoApQPIQMgAigCkA8hBCACIAApAxg3A5APIAMEQCAEIANBAnRBAhD4OgsgAEEANgI8IABCgICAgCA3AjQgAEEQaiAAQTRqQfSo+wAQliEgAigC7A4hAyACKALoDiEEIAIgACkDEDcD6A4gAwRAIAQgA0ECdEECEPg6CyAAQQA2AjwgAEKAgICAEDcCNCAAQQhqIABBNGpB9Kj7ABCQISACKAL0DiEDIAIoAvAOIQQgAiAAKQMINwPwDiADBEAgBCADQQEQ+DoLIABBQGskACABKAL8DiIABEAgASgC+A4gAEEBEPg6CyABQbAOahCZKiABQcgOahCZKiABQeAOahCZKiABKAKsDyIABEAgASgCqA8gAEECdEECEPg6CyABKAK0DyIABEAgASgCsA8gAEECdEECEPg6CyABKAKEDyIABEAgASgCgA8gAEEBEPg6CyABKAKMDyIABEAgASgCiA8gAEECdEECEPg6CyABKAKUDyIABEAgASgCkA8gAEEBEPg6CyABKAKcDyIABEAgASgCmA8gAEEBEPg6CyABKAKkDyIABEAgASgCoA8gAEEBEPg6CyABQdATaiQAC+wCAQV/IwBBMGsiAiQAIAEtAAwhAyACQShqIgQgAUEIaigCADYCACACIAEpAgA3AyAgAkEgakECEOMOIAJBGGogBCgCADYCACACIAIpAyA3AxACQCADQQFHBEAgA0EBIAIoAhgbIQEMAQsgAkEANgIYIAJBEGpBBEEEEJ4kAkAgAigCGCIDRQ0AIAIoAhQiBCADQQJ0IgVqQQRrIgFFDQAgASgCAA0AIAUhASAEQQRrIQUgA0H/////A3EhBAJAA0AgAUUEQEEAIQEMAgsgBEEBayEEIAEgBWogAUEEayEBKAIARQ0ACyAEQQFqIgEgA0sNAQsgAiABNgIYIAEhAwtBASEBIAMgAigCEEECdk8NACACQQhqIAJBEGogA0EEQQQQ9BQgAigCCCIDQYGAgIB4Rg0AIAMgAigCDEHMjYgBEP0vAAsgACACKQMQNwIAIAAgAToADCAAQQhqIAJBGGooAgA2AgAgAkEwaiQAC/4DAgR/AW8jAEHwAGsiASQAIAEgADYCECABQQA2AiggAUEANgIgIAFCgICAgCA3AhQgAUEUahD2KSIAIAAoAgBBAWoiAjYCAAJAAkAgAkUNAEEEQQQQrTYiAkUEQEEEQQQQoz0ACyACIAA2AgAgAUEIaiIDQfiniAE2AgQgAyACNgIAIAEoAggiAkH4p4gBEJM1IQMgACAAKAIAQQFqIgQ2AgAgAUH4p4gBNgJEIAEgAjYCQCABIAM2AkggBEUNAEEEQQQQrTYiAkUEQEEEQQQQoz0ACyACIAA2AgAgAUHkp4gBNgIEIAEgAjYCACABKAIAIgJB5KeIARCTNSEDIAFB5KeIATYCUCABIAI2AkwgASADNgJUIAFBEGooAgAlASABQUBrKAIIJQEgAUHMAGooAgglARBSIQUQ3xIiAiAFJgEgAkGEAU8EQCACEPIfCyABQeAAaiICIAFByABqKAIANgIAIAFB7ABqIAFB1ABqKAIANgIAIAEgASkCQDcDWCABIAEpAkw3AmQgACgCCA0BIABBfzYCCCAAQRxqEKkrIABBLGogAUHoAGopAwA3AgAgAEEkaiACKQMANwIAIAAgASkDWDcCHCAAIAAoAghBAWo2AgggASgCECICQYQBTwRAIAIQ8h8LIAFB8ABqJAAgAA8LAAtB/KiIARCbPgAL/QIBBH8jAEEwayIDJAAgAEEEIAAoAjQiBCAEQQRNGzYCNCAAQTBqIQUCQEEAIAAoAjAiBmtBA3EiBCAAKAIIIAZrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBSAEEI03IAAoAgggACgCMGtBA0siBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBUEEEI03IANBEGogABDcOyADKAIUIQQgAygCECEFIANBCGogACgCMBCMNyADIAUgBCADKAIIIAMoAgxBsLf+ABDXJiADKAIEIgRBA0sEQCADKAIAIAQgAms2AAAgACgCMCEEIAAoAhQiAiAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECACQQN0aiIFIAE7AQQgBSAENgIAIAAgAkEBajYCFCADQTBqJAAPCyADQQA2AiggA0EBNgIcIANB7Lf+ADYCGCADQgQ3AiAgA0EYakHAt/4AEO8sAAv9AgEEfyMAQTBrIgMkACAAQQQgACgCNCIEIARBBE0bNgI0IABBMGohBQJAQQAgACgCMCIGa0EDcSIEIAAoAgggBmtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAFIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAFQQQQjTcgA0EQaiAAENw7IAMoAhQhBCADKAIQIQUgA0EIaiAAKAIwEIw3IAMgBSAEIAMoAgggAygCDEGEgf8AENcmIAMoAgQiBEEDSwRAIAMoAgAgBCACazYAACAAKAIwIQQgACgCFCICIAAoAgxGBEAgAEEMakGcgP8AEJsoCyAAKAIQIAJBA3RqIgUgATsBBCAFIAQ2AgAgACACQQFqNgIUIANBMGokAA8LIANBADYCKCADQQE2AhwgA0Gwgf8ANgIYIANCBDcCICADQRhqQZSB/wAQ7ywAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAUECdGo1AgAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIARCACAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAUEBdGozAQAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIARCACAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAWowAAAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIAQgBEI/hyAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC7sDAQJ/IwBBEGsiAyQAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDgYBAgMEBQYACyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAYLIAMgAUEEahDMIiAAIAMpAwA3AgQgAEEBOgAADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgA0EIaiABQQRqEMwiIAAgAykDCDcCBCAAQQM6AAAMAwsgAEEEOgAAIAAgAS8AATsAAQwCC0EEIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRMgAS0AASIBQQRrIAFBA00bQf8BcUEBaw4TAAECAwQFBgcICQoLDA0ODxAREhMLQQUhAgwSC0EGIQIMEQtBByECDBALQQghAgwPC0EJIQIMDgtBCiECDA0LQQshAgwMC0EMIQIMCwtBDSECDAoLQQ4hAgwJC0EPIQIMCAtBECECDAcLQREhAgwGC0ESIQIMBQtBEyECDAQLQRQhAgwDC0EVIQIMAgtBFiECDAELIAEhAgsgAEEFOgAAIAAgAjoAAQwBCyAAQQY6AAALIANBEGokAAuPBgEPfyMAQTBrIgQkACAEQQg6AAsgBCACNgIQIAQgATYCDCAEQQQ2AhQgBCAEQQtqNgIYIARBJGohCyMAQSBrIgMkAAJAAkACQCADQRRqIARBDGoiASgCBCICBH8gASgCCCIFRQ0BIAIgBW4iBiACIAUgBmxHagVBAAtBAEEEQQQQoBggAygCGCECIAMoAhRBAUYNASADQRBqIgxBADYCACADIAMoAhw2AgwgAyACNgIIIANBCGohAiMAQRBrIgkkAAJAAkACQCABKAIEIgZFBEAgAkEIaiEFDAELIAEoAggiB0UNASACQQhqIQUgBiAHbiIIIAYgByAIbEdqIgYgAigCACACKAIIIgdrTQ0AIAIgByAGEN8oCyAJIAIpAgRCIIk3AgggCSAFNgIEIAlBBGoiAigCBCEFIAIoAgAgASgCBCIGBEAgAigCCCEOIAEoAgwhDyABKAIIIQggASgCACEKA0AgBiAIIAYgBiAISxsiAmshBgJAIAhFBEBBACEHDAELIApBAWshECAPLQAAQR9xIRFBACEHIAIhAQNAIAEgEGotAAAgByARdHIhByABQQFrIgENAAsLIAIgCmohCiAOIAVBAnRqIAc2AgAgBUEBaiEFIAYNAAsLIAU2AgAgCUEQaiQADAELQcCiiAEQ4isACyALQQhqIAwoAgA2AgAgCyADKQIINwIAIANBIGokAAwCC0HAoogBEOIrAAsgAiADKAIcQdyNiAEQ/S8ACwJAIAQoAiwiAUUNACAEKAIoIgIgAUECdCIDakEEayIFRQ0AIAUoAgANACACQQRrIQUgAUH/////A3EhAgJAA0AgA0UEQEEAIQMMAgsgAkEBayECIAMgBWogA0EEayEDKAIARQ0ACyACQQFqIgMgAUsNAQsgBCADNgIsIAMhAQsCQCABIAQoAiRBAnZPDQAgBCAEQSRqIAFBBEEEEPQUIAQoAgAiAUGBgICAeEYNACABIAQoAgRBgKKIARD9LwALIAAgBCkCJDcCACAAQQhqIARBLGooAgA2AgAgBEEwaiQAC6ADAQJ/IwBBIGsiByQAAkAgACgCACIIIAEgAiAAKAIEKAIMIgERBgAEQEEBIQIMAQsCQCAALQAKQYABcUUEQEEBIQIgCEHZ8YkBQQEgAREGAA0CIAMgACAEKAIMEQIARQ0BDAILIAhB2vGJAUECIAERBgAEQEEBIQIMAgtBASECIAdBAToADyAHQbDxiQE2AhQgByAAKQIANwIAIAcgACkCCDcCGCAHIAdBD2o2AgggByAHNgIQIAMgB0EQaiAEKAIMEQIADQEgBygCEEHU8YkBQQIgBygCFCgCDBEGAA0BCwJAIAAtAApBgAFxRQRAIAAoAgBBz/GJAUECIAAoAgQoAgwRBgAEQAwDCyAFIAAgBigCDBECAEUNAQwCCyAHQQE6AA8gB0Gw8YkBNgIUIAcgACkCADcCACAHIAApAgg3AhggByAHQQ9qNgIIIAcgBzYCECAFIAdBEGogBigCDBECAA0BIAcoAhBB1PGJAUECIAcoAhQoAgwRBgANAQsgACgCAEGT7YkBQQEgACgCBCgCDBEGACECCyAHQSBqJAAgAguJAwEFfyMAQRBrIgUkACAFQQhqIAAgAUEJahC4KSAFKAIMIQQgBSgCCCEGAkACQAJAAkACQCACKAIEIgdFBEAgAiAENgIEIAIgBjYCAAwBCyACKAIYQQlqIgMgBEsNASADIAdLDQIgBiADIAIoAgAgA0Gsu9AAENUsIAUQ/ScgBSgCBCEDIAUoAgAgACACKAIAIAIoAgQQ4DUgAiAENgIEIAIgBjYCACADRQ0AIANBARD4OgsgAkECNgIgIAIgATYCGCAERQ0CIAZBADoAACACKAIgIgRBAWsiASACKAIEIgBPDQMgAigCACIDIAFqQQA6AAAgACACKAIYIARqIgFrIgJBACAAIAJPGyEEIAEgA2ohA0EAIQICQANAIAIgBEYNASACIANqQQA6AAAgAkEBaiICQQdHDQALIAVBEGokAA8LIAEgAmogAEHcu9AAEMMhAAsgAyAEQYy70AAQsDsACyADIAdBnLvQABCwOwALQQBBAEG8u9AAEMMhAAsgASAAQcy70AAQwyEAC4IDAQR/IAAoAgwhAgJAAkACQCABQYACTwRAIAAoAhghAwJAAkAgACACRgRAIABBFEEQIAAoAhQiAhtqKAIAIgENAUEAIQIMAgsgACgCCCIBIAI2AgwgAiABNgIIDAELIABBFGogAEEQaiACGyEEA0AgBCEFIAEiAkEUaiACQRBqIAIoAhQiARshBCACQRRBECABG2ooAgAiAQ0ACyAFQQA2AgALIANFDQICQCAAKAIcQQJ0QajwigFqIgEoAgAgAEcEQCADKAIQIABGDQEgAyACNgIUIAINAwwECyABIAI2AgAgAkUNBAwCCyADIAI2AhAgAg0BDAILIAAoAggiACACRwRAIAAgAjYCDCACIAA2AggPC0HA84oBQcDzigEoAgBBfiABQQN2d3E2AgAPCyACIAM2AhggACgCECIBBEAgAiABNgIQIAEgAjYCGAsgACgCFCIARQ0AIAIgADYCFCAAIAI2AhgPCw8LQcTzigFBxPOKASgCAEF+IAAoAhx3cTYCAAuxCAMFfwJ9BH4jAEEgayIJJAACQAJAAn8CQAJAIAEgB0kEQCAGIAFBFGxqIggoAgBFBEAgCCoCBCENC0EAIAFFDQMaIAgoAhAhCiAIKAIIQf///w9xIQsgAiAIKAIMIgxJDQIgCyAMaiAAIAFqTQ0BDAILIAEgB0GUstAAEMMhAAsgASAMQQ9qIApBG3ZBAWsgCkGAgIDAAEkbDQEaCyABIAsgCkH///8/cWprIgAgB08NAUEAIAYgAEEUbGoiACgCAEECRw0AGiAAKAIECyEAIAggADYCBCAIQQI2AgAgASAEKAIMIgBPDQEgBCgCCCIAIAFBAnRqKgIAIAAqAgCTIg4gDWAEQCAJQQhqQgA3AwAgCUIANwMAIAkgATYCECAJIA04AhggCSANIA6TOAIUQQAhAEEAIQJBECEKIwBBIGsiCCQAAkACQAJAAkACQAJAIAEgB0kEQCAGIAFBFGxqIgEoAgBBAkcNAiABKAIEIgRFDQIgCSEBA0AgAiEAAkACQAJAIAQgB0kEQCAAQQRGDQEgASAGIARBFGxqIgIoAgw2AgAgBCACKAIIQf///w9xIAIoAhBB////P3FqayICIAdPDQIgBiACQRRsaiIEKAIAQQJGDQMMBgsgBCAHQYCg1gAQwyEAC0EEQQRBkKDWABDDIQALIAIgB0GgoNYAEMMhAAsgAEECSw0CIABBAWohAiABQQRqIQEgBCgCBCIEDQALDAELIAEgB0HQn9YAEMMhAAsgAEECSw0BIABBAWohAAtBBCAAIABBBE0bIQEgCSAAQQJ0aiEEA0AgCkUNAyAAIAFGDQIgBCADKAIANgIAIARBBGohBCADQQRqIQMgCkEBayEKIABBAWoiAEEERw0ACwsgCEEgaiQADAILIAFBBEHwn9YAEMMhAAsgCEEANgIYIAhBATYCDCAIQfie1gA2AgggCEIENwIQIAhBCGpB4J/WABDvLAALIAUgBSgC4AEiAUEBaiIANgLgASAFIAFBf3NBB3EiAkEcbGoiASAJKQIANwIAIAFBCGogCUEIaikCADcCACABQRBqIAlBEGopAgA3AgAgAUEYaiAJQRhqKAIANgIAIABBAk8EQEEIIAAgAEEITxtBAWshAwNAIAUgAkEHcUEcbGoiACoCFCAFIAJBAWoiAkEHcUEcbGoiASoCFF4EQCAAKQIAIRAgAUEIaiIEKQIAIREgAUEQaiIGKQIAIQ8gAUEYaiIHKAIAIQggACABKQIANwIAIABBGGoiCigCACELIAogCDYCACAAQRBqIggpAgAhEiAIIA83AgAgAEEIaiIAKQIAIQ8gACARNwIAIAcgCzYCACAGIBI3AgAgBCAPNwIAIAEgEDcCAAsgA0EBayIDDQALCwsgCUEgaiQADwsgACAHQdy00AAQwyEACyABIABBzLXQABDDIQALkwMCAn8CfiMAQZABayICJAAgACgCBCgCECABajEAACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBEIAIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALuQMBCH8jAEEQayIFJAAgAiABayIDQQAgAiADTxshAwJAAkACQCAAKAIMBEAgAEEMaiEGIAAoAhwiB0EHcSIIRQ0CIAVBCGogBhCGPSAFKAIMIgRFDQEgBSgCCCAEakEBayIERQ0BIAQgBC0AAEF/IAh0cjoAAAwCCyAAIAAoAiAgA2o2AiAMAgtBjPWBARCyOwALAkAgAyAHaiIHQQN2IAdBB3EiCEEAR2oiAyAAKAIYIgRNDQAgAyAEayEJIAAoAhAgA0kEQCADENIqIQQgBiAAKAIQQQF0IgogBCAEIApJGxDoGSAAKAIYIQQLIAlFDQAgACgCFCAEakH/ASAJ/AsACyAAIAM2AhggCARAIAUgBhCGPQJAIAUoAgQiAwRAIAUoAgAgA2pBAWsiAw0BC0Gc9YEBELI7AAsgAyADLQAAQX8gCHRBf3NxOgAACyAAIAc2AhwLIAAgAiABayIDQQAgAiADTxsQhS4gACgCCCEDIAAgASACSQR/IAIgA2ogAWsgACgCBCADQQJ0aiEAA0AgACABNgIAIABBBGohACACIAFBAWoiAUcNAAsFIAMLNgIIIAVBEGokAAvRAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QYi2gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACADQQBIIAIgA01yDwtBAAvTAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QbC4gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACACIANNIANB//8BS3IPC0EAC9ICAQp/AkACQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBxLmDAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB08NAQsgACABQQJ0aiEIIAYgBSgCJBEEACEDQQEhAUEBIQQDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIANqIQNBASEJIARBAXFBACEBQQAhBEUNASAGIAUgCyAKIAcRCgAhBAwBCwsgBEEBcQ0AIAIgA00gA0H/AEtyDwtBAAvTAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QYC9gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACACIANNIANB//8DS3IPC0EAC9ICAQp/AkACQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBlL6DAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB08NAQsgACABQQJ0aiEIIAYgBSgCJBEEACEDQQEhAUEBIQQDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIANqIQNBASEJIARBAXFBACEBQQAhBEUNASAGIAUgCyAKIAcRCgAhBAwBCwsgBEEBcQ0AIAIgA00gA0H/AUtyDwtBAAuFGAIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDgAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8CQAJAIAkQ9C1BgIACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDOJyAKIA82AhQgCiAINgIQIApCAjcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEIUtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAXRqIA0gCWsQvAsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQmgsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABCZFSADQTBqIBMgAygCJCADKAIoELwLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ8w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahCdPAwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJoLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEJ08CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQhS0gBiADIAcgAiAEIAUQ/AkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALwRACGH8DfiMAQSBrIggkAAJAAkACQAJAAkAgASkDAEIFUgRAIAhBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQsjAEEwayIDJAACQAJAAkAgAiIMRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ3wIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgDCAPayEGIAEpAwBCBFINASACIAYgAiAGSRsiCiECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQogAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCAKNgIEIAQgBzYCAAwGCyAFIApyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiAKTQ0CIAEtAEwgAUEAOgBMIApqIQoLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgBzYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIRBBACEJIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACINQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIA1qKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAJQQhqIglqIBdxIQcMAAsACyAGQQdqEIUpAAsgCyALKAIIIgcgBWoQhi0gCygCCCIJIAdJDQEgBkEIaiANIBpBDGxqIg1BCGsoAgAgCygCBCAHQQJ0aiAJIAdrIA1BBGsoAgAoAhARBQAgBigCDCEJAkAgBigCCCINQQhHBEAgECAGKQMQNwMIIBBBEGogBkEYaikDADcDAAwBCyALIAcgCWoQ9DQLIBAgDTYCACAQIAk2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAJQaSuzgAQrzsACyADKAIcIQYgAygCGCIHQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAHNgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBFqIREgAiASaiESIAogD2oiDyAMSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCARNgIIIAQgDzYCBCAEQQg2AgALIANBMGokAAwACyAIKAIQIQUgCCgCFCECIAgoAgwhDCAIKAIIIgNBCEcEQCAAIAgpAxg3AxAgACACNgIMIAAgBTYCCCAAIAw2AgQgACADNgIADAULIAIgBU0NAyATKAIAIgNBgYCAgHhHDQIgCEEIakE9QQBBAUEBEKAYIAgoAgwhASAIKAIIQQFGDQEgCCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAgoAhBB1P3MABD9LwALIAEoAqQCIQQgCCATQQRBDCADQYCAgIB4RhtqEIY9IAsgBCAFIAIgCCgCACAIKAIEEP0JCyAAIAw2AgQgAEEINgIAIAEgASgCqAIgDGo2AqgCIAEgASgCpAIgAmo2AqQCCyAIQSBqJAAPCyACIAMoAiBB9I7PABD9LwALqzUCI38IfiMAQSBrIhokAAJAAkACQAJAAkAgASkDAEIFUgRAIBpBCGohDSABQcACaiIiQQAgASgCwAJBgYCAgHhHGyEjIAFB6AJqQQAgASgC6AJBgICAgHhHGyEkIAFBqAJqIREjAEEwayIIJAACQAJAIAIiHkUNACABQaABaiELIAFB0ABqISUgASgCoAIhBAJAAkADQAJAAkACQCABKAKcAiICQQAgAiAERxtFBEAgCEEYaiABENACIAgtABwhBSAIKAIYIgJBCEcNASAFQQFxRQ0HIAEoApwCIgJFDQcgASgCoAIhBAsgAiAEayECIB4gIWshCiABKQMAQgRSDQEgAiAKIAIgCkkbIhghAgwCCyANIAgpAB03AAUgDUEUaiAIQSxqKAAANgAAIA1BDWogCEElaikAADcAACANIAU6AAQgDSACNgIADAYLICRFBEAgCEEYakEeQQBBAUEBEKAYIAgoAhwhAiAIKAIYQQFGDQwgCCgCICIFQRZqQeiSzwApAAA3AAAgBUEQakHiks8AKQAANwAAIAVBCGpB2pLPACkAADcAACAFQdKSzwApAAA3AAAgDUEeNgIMIA0gBTYCCCANIAI2AgQgDUEANgIADAYLIAhBGGogASAkIAogAhCMECAIKAIgIQUgCCgCHCEYIAgoAhgiBEEIRwRAIA0gCCkCJDcCDCANQRRqIAhBLGooAgA2AgAgDSAFNgIIIA0gGDYCBCANIAQ2AgAMBgsgBSAYckUEQCAIQRhqQS9BAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNDCAIKAIgIgVBuJDPAEEv/AoAACANQS82AgwgDSAFNgIIIA0gAjYCBCANQQA2AgAMBgsgAiAFRwRAIAUhAgwBCyABLQCkAkEBRw0AIAogGE0NAiABLQBMIAFBADoATCAYaiEYCyACIQUCQCAlKQMAQgVRDQAgI0UEQCAIQRhqQR5BAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNBCAIKAIgIgVBFmpBhpPPACkAADcAACAFQRBqQYCTzwApAAA3AAAgBUEIakH4ks8AKQAANwAAIAVB8JLPACkAADcAACANQR42AgwgDSAFNgIIIA0gAjYCBCANQQA2AgAMBgsgCEEYaiAlICMgAhDFAyAIKAIgIQogCCgCHCEFIAgoAhgiBEEIRwRAIA0gCCkCJDcCDCANQRRqIAhBLGooAgA2AgAgDSAKNgIIIA0gBTYCBCANIAQ2AgAMBgsgAiAKRg0AIAhBGGpB3gBBAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNCyAIKAIgIgVB9JHPAEHeAPwKAAAgDUHeADYCDCANIAU2AgggDSACNgIEIA1BADYCAAwFCyAIIAU2AgAjAEHwAGsiAyQAAkACQAJAIAhBGGoiCgJ/IAspAwAiJkIGUQRAIANB2ABqQQ5BAEEBQQEQoBggAygCXCEbIAMoAlhBAUYNAyADKAJgIgRBBmpBrozNACkAADcAACAEQaiMzQApAAA3AAAgCkEONgIMIAogBDYCCCAKIBs2AgQgCkEANgIADAILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEBICanQQJrICZCAVgbQQFrDgMAAQIFCyALKAJQIg5BgICAgHhHDQMgA0HYAGpBK0EAQQFBARCgGCADKAJcIRsgAygCWEEBRw0CDBILIBEgCygCECIGIAsoAiQiCWsiBCAFIAQgBUkbIg8Q6y0gCSAPaiIEIA9JDQQgBCAGSw0FIAsoAgwhBiADQdgAaiIEIAtBIGogCygCGCALKAIcIAsoAhQoAgARBQAgA0EoaiAEEPwbIBEoAhQiByARKAIMRgRAIBFBDGpBjITNABCQKAsgESgCECAHQQxsaiIEIAMpAig3AgAgBEEIaiADQTBqKAIANgIAIBEgB0EBajYCFCALKAIoIg4hGSAPBEAgBiAJQQJ0aiEXIA9BAnQhFANAIBEgByAZIBcoAgAQjRogFygCACAZaiEZIBdBBGohFyAUQQRrIhQNAAsLIAstACxFDQ4gDiAZSw0GIBkgCygCHCIESw0HIANByABqIAsoAhggDmogGSAOaxCdCSADKAJIQQFHDQ4gAyADKQJMNwNAIANBATYCXCADQfCIzQA2AlggA0IBNwJkIANBsAM2AhggAyADQRRqNgJgIAMgA0FAazYCFCAKQQRqIANB2ABqEJkOQQAMDwsgESALKAIQIAsoAjxrIgQgBSAEIAVJGxDrLSADQdgAaiIdQYAgQQBBAUEBEKAYIAMoAlwhBCADKAJYQQFGDQcgC0EIaiESIANBADYCHCADIAMoAmA2AhggAyAENgIUIAMgESgCFDYCICALLQBERQRAIAMgETYCUCADIANBIGo2AkwgAyADQRRqNgJIIANByABqIQkjAEEwayIWJAACQAJAAkACQAJAAkAgEigCCCIGIBIoAjQiB2siBCAFIAQgBUkbIhUgB2oiDCAVTwRAIAYgDEkNASAMIBIoAhQiBEsNAiAWQQhqIAdBAnQiByASKAIEaiIEIAQgFUECdCIGaiASKAIQIAdqIgQgBCAGahCLKAJAIBYoAhwiBCAWKAIYIgZLBEAgEigCLCEMIBIoAighByAEIAZrIRwgEkEYaiEPIAZBAnQiBCAWKAIQaiEXIBYoAgggBGohFCASKAI4IRsgCSgCCCETIAkoAgQhBiAJKAIAIQ4DQCASKAIsIBsgFygCACIQakkNAiAPIBQoAgAQ9DQgEigCOCIJIBBqIgQgCUkNBiAEIAxLDQcgDyAHIAlqIBAQoTYgFkEgaiASKAIcIgQgEigCICIJIAYoAgAgDigCCBDwCiAJQQ1PBEAgDiAEIAkQoTYLIBYpAyghJyAWKQMgISYgEygCCCIJIBMoAgBGBEAgE0GshM0AELEoCyATKAIEIAlBBHRqIgQgJzcDCCAEICY3AwAgEyAJQQFqNgIIIBIgEigCOCAQaiIbNgI4IBdBBGohFyAUQQRqIRQgHEEBayIcDQALIBIoAjQgFWohDAsgHSAVNgIEIBIgDDYCNCAdQQg2AgAMBwsgFkEgakEXQQBBAUEBEKAYIBYoAiQhBCAWKAIgQQFGDQUgFigCKCIGQQ9qQduGzQApAAA3AAAgBkEIakHUhs0AKQAANwAAIAZBzIbNACkAADcAACAdQRc2AgwgHSAGNgIIIB0gBDYCBCAdQQI2AgAMBgsgByAMQYyGzQAQsTsACyAMIAZBjIbNABCwOwALIAwgBEGchs0AELA7AAsgCSAEQayGzQAQsTsACyAEIAxBrIbNABCwOwALIAQgFigCKEHU/cwAEP0vAAsgFkEwaiQAIAMoAlwhGSADKAJYIgRBCEYNDCAKIAMpA2A3AwggCkEQaiADQegAaikDADcDACAKIBk2AgQgCiAENgIADA0LIANB2ABqIhtBgCBBAEEBQQEQoBggAygCXCEEIAMoAlhBAUYNCCADQQA2AjAgAyADKAJgNgIsIAMgBDYCKCADIBE2AlQgAyADQShqNgJQIAMgA0EgajYCTCADIANBFGo2AkggA0HIAGohDiMAQTBrIhQkAAJAAkACQAJAAkACQAJAAkAgEigCCCIGIBIoAjQiB2siBCAFIAQgBUkbIh0gB2oiDCAdTwRAIAYgDEkNASAMIBIoAhQiBEsNAiAUQQhqIAdBAnQiByASKAIEaiIEIAQgHUECdCIGaiASKAIQIAdqIgQgBCAGahCLKCAUKAIcIgQgFCgCGCIGTQ0HIBIoAiwhECASKAIoIQkgBCAGayEWIBJBGGohDCAGQQJ0IgQgFCgCEGohEyAUKAIIIARqIRcgEigCOCEZIA4oAgwhHCAOKAIIIQcgDigCBCEGIA4oAgAhDwNAIBIoAiwgGSATKAIAIhVqTwRAIAwgFygCABD0NCASKAI4Ig4gFWoiBCAOSQ0FIAQgEEsNBiAMIAkgDmogFRChNiAUQSBqIBIoAhwiBCASKAIgIg4gBigCACAPKAIIEPAKAkAgDkEMTQRAIAcgBCAOEKE2DAELIA8gBCAOEKE2CyAUKQMoIScgFCkDICEmIBwoAggiDiAcKAIARgRAIBxBrITNABCxKAsgHCgCBCAOQQR0aiIEICc3AwggBCAmNwMAIBwgDkEBajYCCCASIBIoAjggFWoiGTYCOCATQQRqIRMgF0EEaiEXIBZBAWsiFg0BDAgLCyAUQSBqQRdBAEEBQQEQoBggFCgCJCEEIBQoAiBBAUYNBSAUKAIoIgZBD2pB24bNACkAADcAACAGQQhqQdSGzQApAAA3AAAgBkHMhs0AKQAANwAAIBtBFzYCDCAbIAY2AgggGyAENgIEIBtBAjYCAAwICyAHIAxBjIbNABCxOwALIAwgBkGMhs0AELA7AAsgDCAEQZyGzQAQsDsACyAOIARBrIbNABCxOwALIAQgEEGshs0AELA7AAsgBCAUKAIoQdT9zAAQ/S8ACyASKAI0IB1qIQwLIBsgHTYCBCASIAw2AjQgG0EINgIACyAUQTBqJAAgAygCXCEZAkAgAygCWCIEQQhHBEAgCiADKQNgNwMIIApBEGogA0HoAGopAwA3AwAgCiAZNgIEIAogBDYCAAwBCyADQcgAaiADKAIYIAMoAhwQnQkgAygCSEEBRgRAIAMgAykCTDcDOCADQQE2AlwgA0HwiM0ANgJYIANCATcCZCADQbADNgJEIAMgA0FAazYCYCADIANBOGo2AkAgCkEEaiADQdgAahCZDiAKQQA2AgAMAQsgA0HIAGogAygCLCADKAIwEJ0JIAMoAkhBAUcNCyADIAMpAkw3AzggA0EBNgJcIANB8IjNADYCWCADQgE3AmQgA0GwAzYCRCADIANBQGs2AmAgAyADQThqNgJAIApBBGogA0HYAGoQmQ4gCkEANgIACyADQShqEN47DAwLIAMoAmAiBEGokM0AQSv8CgAAIApBKzYCDCAKIAQ2AgggCiAbNgIEIApBADYCAAwOCwJAIAUEQCALKAJYDQELIApCCDcDAAwOCwJAAkAgESgCFCIJIAsoAmQiFUkEQCALKAJgIRcMAQsgESgCECIEIAkgFWtBDGxqIQcgCygCYCEXIANB2ABqIg9BADYCECAPIBcgFUEMbGoiBjYCDCAPIBc2AgggDyAEIAlBDGxqIgQ2AgQgDyAHNgIAIA8gBiAXa0EMbiIGIAQgB2tBDG4iBCAEIAZLGzYCFCADKAJoIhYgAygCbCIPTw0BIBYgDyAPIBZJGyEHIAMoAmAhFCADKAJYIQwgFkEMbCEJA0ACQCAJIAxqIgZBBGooAgAgCSAUaiIEQQRqKAIARw0AIAZBCGooAgAgBEEIaigCAEcNACAMQQxqIQwgFEEMaiEUIBZBAWoiFiAHRw0BDAMLCyAVRSAPIBZNcg0BCyARQQxqIQkgFyAVQQxsaiEHA0AgFygCACIQIBAoAgAiBEEBajYCACAEQQBIDQkgF0EIaigCACEGIBdBBGooAgAhBCARKAIUIgwgESgCDEYEQCAJQfSQzQAQkCgLIBEoAhAgDEEMbGoiDyAGNgIIIA8gBDYCBCAPIBA2AgAgESAMQQFqNgIUIBdBDGoiFyAHRw0ACwsgAyARKAIUIBVrNgJIIAMgETYCXCADIAtB0ABqQQAgDkGAgICAeEcbNgJYIAMgA0HIAGo2AmAgA0HYAGohB0EAIRwjAEFAaiITJAACQAJAAkACQAJAIAVFDQAgCygCTCIGRQ0AIAsoAkghBCAHKAIEIRUgBygCCCEOIAcoAgAhDANAIAsoAkQiByAERgRAIBNBIGogCyALKAJAQYAIENwKIBMoAiQhByATKAIgIgRBCEcEQCAKIBMpAyg3AwggCkEQaiATQTBqKQMANwMAIAogBzYCBCAKIAQ2AgAMBwsgB0UNAiALQQA2AkggCyAHNgJEIAsoAkwhBkEAIQQLIAYgByAEayIJIAUgHGsiByAHIAlLGyIHIAYgB0kbIhAgBGoiByAQSQ0DIAdBgAhLDQQgEARAIAsoAkAiCSAEQQJ0IgRqIQYgEEECdCEHIAQgCWohBANAIAYoAgAiCSAMKAIITw0EAkAgDCgCBCAJQQR0aiIJKQMAIienQQ1PBEAgDigCACAJKQMIIianaq0gJkKAgICAcIOEISYgFSgCCCIPIBUoAgBGBEAgFUGshM0AELEoCyAVKAIEIA9BBHRqIgkgJjcDCCAJICc3AwAMAQsgCSkDCCEnIAkpAwAhJiAVKAIIIg8gFSgCAEYEQCAVQayEzQAQsSgLIBUoAgQgD0EEdGoiCSAnNwMIIAkgJjcDAAsgFSAPQQFqNgIIIAZBBGohBiAEQQRqIQQgB0EEayIHDQALIAsoAkggEGohByALKAJMIQYLIAsgBzYCSCALIAYgEGsiBDYCTCAQIBxqIhwgBUYNASAGIBBGIAQhBiAHIQRFDQALCyAKQQg2AgAgCiAcNgIEDAMLIBNBAjYCJCATQdSPzgA2AiAgE0IBNwIsIBNBnAM2AjwgEyAENgI4IBMgE0E4ajYCKCATQQhqQQRyIBNBIGoQmQ4gCiATKQMQNwMIIApBEGogE0EYaikDADcDACAKIBMoAgw2AgQgCkEANgIADAILIAQgB0HMiM4AELE7AAsgB0GACEHMiM4AELA7AAsgE0FAayQADA0LIAogC0EIaiARIAUQ5gcMDAsgCSAEQaSRzQAQsTsACyAEIAZBpJHNABCwOwALIA4gGUG0kc0AELE7AAsgGSAEQbSRzQAQsDsACyAEIAMoAmBB5JHNABD9LwALIAQgAygCYEH0kc0AEP0vAAsACyADQShqEN47CyADQTBqIANBHGooAgA2AgAgAyADKQIUNwMoIANByABqIANBKGoQ8i8gAyADKQJINwJkIANBADYCYCADIAMoAlQiBjYCXCADIAMoAlA2AlggA0EIaiADQdgAahDXOyADKAIIIQQCQEEcQQQQrTYiDgRAIA5CgYCAgBA3AgAgDiADKQJYNwIIIA5BEGogA0HgAGopAgA3AgAgDkEYaiADQegAaigCADYCACARKAIUIgkgESgCDEYEQCARQQxqQYyEzQAQkCgLIBEoAhAgCUEMbGoiByAGNgIIIAcgBDYCBCAHIA42AgAgESAJQQFqNgIUIAMgCTYCJCAJIAMoAiBGDQEgA0EANgJYIANBJGogA0EgaiADQdgAakGEks0AEKgrAAtBBEEcEKM9AAsgCkEINgIAIAogGTYCBAwDCyADQRRqEN47DAILIAsgGTYCKCAKIA82AgQgCyALKAIkIA9qNgIkQQgLNgIACyADQfAAaiQADAELIBsgAygCYEHU/cwAEP0vAAsgCCgCHCEKIAgoAhgiBEEIRwRAIA0gCCkDIDcDCCANQRBqIAhBKGopAwA3AwAgDSAKNgIEIA0gBDYCAAwFCyAIIAo2AgQgBSAKRgRAIAEgASgCoAIgAmoiBDYCoAIgBSAfaiEfIAIgIGohICAYICFqIiEgHkkNAQwECwsgCEECNgIcIAhB5JHPADYCGCAIQgI3AiQgCEE7NgIUIAhBOzYCDCAIIAhBCGo2AiAgCCAIQQRqNgIQIAggCDYCCCANQQRqIAhBGGoQmQ4gDUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMBwsgDSAgNgIMIA0gHzYCCCANICE2AgQgDUEINgIACyAIQTBqJAAgGigCECEeIBooAhQhDiAaKAIMIQkgGigCCCICQQhHBEAgACAaKQMYNwMQIAAgDjYCDCAAIB42AgggACAJNgIEIAAgAjYCAAwFCyAOIB5NDQMgIigCACICQYGAgIB4Rw0CIBpBCGpBPUEAQQFBARCgGCAaKAIMIQIgGigCCEEBRg0BIBooAhAiAUHEh80AQT38CgAAIABBPTYCDCAAIAE2AgggACACNgIEIABBADYCAAwEC0G0h80AELI7AAsgAiAaKAIQQdT9zAAQ/S8ACyABKAL4AiEPIBogIkEEQQwgAkGAgICAeEYbahCGPSAaKAIAIQsgGigCBCEEIwBB8ABrIhAkAAJAIA4gD2oiBSARKAIIIgJNBEAgESAFNgIIDAELIBEgBSACayICEOstIBEoAgQgESgCCCIYQQR0aiEFAkACQCACQQJPBEAgAkEBayEgA0AgBUIANwMAIAVCADcDCCAFQRBqIQUgIEEBayIgDQALIAIgGGpBAWshGAwBCyACRQ0BCyAFQgA3AwAgBUIANwMIIBhBAWohGAsgESAYNgIICyAQIAsgBBDgHCAQQgA3A2ggECAPNgJgIBAgDyAeaiICIgU2AmQCQAJAAkACQCAFIA9NDQAgAkEEdEEQayEHIBAoAlghCiAQKQMgISogECgCVCEYIBAoAlAhBiAQKQNAISggECkDMCErIBAoAhAhHyAQKQMIISkgECgCKCEeIBAoAhghCyAQKQNIIS0gECkDOCEnIBApAwAhLANAICynQQFxRSEMAkADQAJAAkACQCAMRQRAIClQRQ0BQgAhKUIAISxBASEMDAQLAn4CQCArQgJ9IiZCAVgEQCAmp0EBaw0BDAULICunICtQrUIBhiErQQFxRQ0AICcMAQsgKEIDUQRAQgMhKAwECyAGRSAGIBhGckUEQCAYQQhrIhgpAwAMAQtBACEGIChCAlEEQEICISgMBAsgKKdCACEoQQFxRQ0DIC0LISlCASEsIApBQGoiCiEfDAELIB8gKXmnQT9zIgJqIQxCASACrYYgKYUhKQwDC0EAIQwMAQsLIAsgKkIAUnFFDQIgHiAqeadBP3MiAmohDEIBIAKthiAqhSEqCyAMIAVBAWsiAk0NASACIBEoAggiBE8NAiAEIAxNDQMgESgCBCIFIAxBBHRqIgQgBSAHaiIFKQMANwMAIAQgBSkDCDcDCCAHQRBrIQcgAiIFIA9LDQALCyAQQfAAaiQADAILIAVBAWsgBEGwms8AEMMhAAsgDCAEQcCazwAQwyEACwsgACAJNgIEIABBCDYCACABIAEoAvwCIAlqNgL8AiABIAEoAvgCIA5qNgL4AgsgGkEgaiQADwsgAiAIKAIgQfSOzwAQ/S8AC6MOARN/IwBBIGsiByQAAkACQAJAAkACQCABKQMAQgVSBEAgB0EIaiEEIAFBwAJqIg9BACABKALAAkGBgICAeEcbIRAgAUHoAmpBACABKALoAkGAgICAeEcbIREgAUGoAmohEiMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDCABQdAAaiETIAEoAqACIQYCQAJAA0ACQAJAAkAgASgCnAIiAkEAIAIgBkcbRQRAIANBGGogARDZAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKAKcAiICRQ0HIAEoAqACIQYLIAIgBmshAiAKIAtrIQYgASkDAEIEUg0BIAIgBiACIAZJGyIJIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyARRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgESAGIAIQjBAgAygCICEFIAMoAhwhCSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAk2AgQgBCAINgIADAYLIAUgCXJFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0ApAJBAUcNACAGIAlNDQIgAS0ATCABQQA6AEwgCWohCQsgAiEFAkAgEykDAEIFUQ0AIBBFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogEyAQIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohCCMAQRBrIgYkAAJAAkACQCAMKQMAQgZRBEAgBkEEakEOQQBBAUEBEKAYIAYoAgghFCAGKAIEQQFGDQIgBigCDCIVQQZqQa6MzQApAAA3AAAgFUGojM0AKQAANwAAIAhBDjYCDCAIIBU2AgggCCAUNgIEIAhBADYCAAwBCyAIIAwgEiAFIAxB0ABqQQAgDCgCUEGAgICAeEcbEMEUCyAGQRBqJAAMAQsgFCAGKAIMQdT9zAAQ/S8ACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKAKgAiACaiIGNgKgAiAFIA1qIQ0gAiAOaiEOIAkgC2oiCyAKSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIA42AgwgBCANNgIIIAQgCzYCBCAEQQg2AgALIANBMGokAAwACyAHKAIQIQUgBygCFCECIAcoAgwhCiAHKAIIIgNBCEcEQCAAIAcpAxg3AxAgACACNgIMIAAgBTYCCCAAIAo2AgQgACADNgIADAULIAIgBU0NAyAPKAIAIgNBgYCAgHhHDQIgB0EIakE9QQBBAUEBEKAYIAcoAgwhASAHKAIIQQFGDQEgBygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAcoAhBB1P3MABD9LwALIAEoAvgCIQQgByAPQQRBDCADQYCAgIB4RhtqEIY9IBIgBCAFIAIgBygCACAHKAIEEMwHCyAAIAo2AgQgAEEINgIAIAEgASgC/AIgCmo2AvwCIAEgASgC+AIgAmo2AvgCCyAHQSBqJAAPCyACIAMoAiBB9I7PABD9LwALjScCIH8IfiMAQSBrIhEkAAJAAkACQAJAAkAgASkDAEIFUgRAIBFBCGohByABQaACaiIbQQAgASgCoAJBgYCAgHhHGyEdIAFB3AJqQQAgASgC3AJBgICAgHhHGyEfIAFByAJqIQwjAEEwayIGJAACQAJAAkAgAiITRQ0AIAFBoAFqIQkgAUHQAGohICABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAGQRhqIAEQ1QIgBi0AHCECIAYoAhgiA0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgEyAVayEKIAEpAwBCBFINASACIAogAiAKSRsiEiECDAILIAcgBikAHTcABSAHQRRqIAZBLGooAAA2AAAgB0ENaiAGQSVqKQAANwAAIAcgAjoABCAHIAM2AgAMBgsgH0UEQCAGQRhqQR5BAEEBQQEQoBggBigCHCECIAYoAhhBAUYNDSAGKAIgIgNBFmpB6JLPACkAADcAACADQRBqQeKSzwApAAA3AAAgA0EIakHaks8AKQAANwAAIANB0pLPACkAADcAACAHQR42AgwgByADNgIIIAcgAjYCBCAHQQA2AgAMBgsgBkEYaiABIB8gCiACEIwQIAYoAiAhAyAGKAIcIRIgBigCGCIEQQhHBEAgByAGKQIkNwIMIAdBFGogBkEsaigCADYCACAHIAM2AgggByASNgIEIAcgBDYCAAwGCyADIBJyRQRAIAZBGGpBL0EAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0NIAYoAiAiA0G4kM8AQS/8CgAAIAdBLzYCDCAHIAM2AgggByACNgIEIAdBADYCAAwGCyACIANHBEAgAyECDAELIAEtAJwCQQFHDQAgCiASTQ0CIAEtAEwgAUEAOgBMIBJqIRILIAIhCgJAICApAwBCBVENACAdRQRAIAZBGGpBHkEAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0EIAYoAiAiA0EWakGGk88AKQAANwAAIANBEGpBgJPPACkAADcAACADQQhqQfiSzwApAAA3AAAgA0Hwks8AKQAANwAAIAdBHjYCDCAHIAM2AgggByACNgIEIAdBADYCAAwGCyAGQRhqICAgHSACEMUDIAYoAiAhAyAGKAIcIQogBigCGCIEQQhHBEAgByAGKQIkNwIMIAdBFGogBkEsaigCADYCACAHIAM2AgggByAKNgIEIAcgBDYCAAwGCyACIANGDQAgBkEYakHeAEEAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0MIAYoAiAiA0H0kc8AQd4A/AoAACAHQd4ANgIMIAcgAzYCCCAHIAI2AgQgB0EANgIADAULIAYgCjYCACAGQRhqIQ4jAEEgayIQJAACQCAMKAIAQQFGBEAgECAMKAIEIgg2AgQgCCAJKAJgRg0BIBBBADYCCEEAIBBBBGogCUHgAGogEEEIakGQnc0AEK8rAAsgDEEBNgIAIAwgCSgCYCIINgIECwJAAkAgCSkDACIjQgZSBEACQAJAAkACQAJAAkACQAJAQQEgI6dBAmsgI0IBWBtBAWsOAwACBAELIAkoAlBFDQYgCSgCWEUNAiAQIAlB0ABqNgIQIBAgCUHgAGo2AgwgECAMQQhqNgIIIBBBCGohBEEAIQMjAEEgayILJAACQAJAAkACQAJAAkAgCkUNACAJKAJMIghFDQAgCSgCSCEFIAQoAgghDyAEKAIEIRQgBCgCACEYA0AgCSgCRCIEIAVGBEAgC0EIaiAJIAkoAkBBgAgQ3AogCygCDCEEIAsoAggiBUEIRwRAIA4gCykDEDcDCCAOQRBqIAtBGGopAwA3AwAgDiAENgIEIA4gBTYCAAwICyAERQ0CIAlBADYCSCAJIAQ2AkQgCSgCTCEIQQAhBQsgCCAEIAVrIgQgCiADayINIAQgDUkbIgQgBCAISxsiBCAFaiIIIARJDQIgCEGACEsNAyAJKAJAIQggGCAUKAIAIARsEOUtIAQEQCAIIAVBAnRqIQUgBEECdCEZA0AgFCgCACIaIAUoAgBsIgggGmoiDSAISQ0GIA0gDygCCCIcSw0HIAVBBGohBSAYIA8oAgQgCGogGhChNiAZQQRrIhkNAAsLIAkgCSgCSCAEaiIFNgJIIAkgCSgCTCINIARrIgg2AkwgAyAEaiIDIApGDQEgBCANRw0ACwsgDkEINgIAIA4gAzYCBAwECyAFIAhBzIjOABCxOwALIAhBgAhBzIjOABCwOwALIAggDUH0j84AELE7AAsgDSAcQfSPzgAQsDsACyALQSBqJAAMCQsgCARAIAggCSgCECIFIAkoAhgiBGsiAyAIIApsIgsgAyALSRsgCG4iDWwiCyAEaiIDIAtJDQUgAyAFSw0EIAxBCGogCSgCDCAEaiALEKE2IA4gDTYCBCAJIAM2AhggDkEINgIADAkLQbCdzQAQ4isACyAMQQhqIiEgCSgCECAJKAI8ayIDIAogAyAKSRsiAyAIbBDlLSAJQeAAaiEYIwBB4ABrIgQkAAJAAkACQAJAAkACQCAJQQhqIgUoAggiDSAFKAI0IghrIgsgAyADIAtLGyILIAhqIgMgC08EQCADIA1LDQEgAyAFKAIUIg1LDQIgBCAIQQJ0IgggBSgCBGoiDSANIAtBAnQiD2ogBSgCECAIaiIIIAggD2oQiygCQAJAIAQoAhQiDSAEKAIQIghLBEAgBSgCLCEZIAUoAighIiANIAhrIRogBUEYaiEcIAhBAnQiCCAEKAIIaiEDIAQoAgAgCGohDSAFKAI4IQ8gGCgCACEeA0AgBSgCLCAPIAMoAgAiCGpJDQMgHCANKAIAEPQ0IAUoAjgiDyAIaiIUIA9JDQcgFCAZSw0IIBwgDyAiaiAIEKE2IAUoAiAiDyAeRw0CICEgBSgCHCAeEKE2IAUgBSgCOCAIaiIPNgI4IANBBGohAyANQQRqIQ0gGkEBayIaDQALIAUoAjQgC2ohAwsgDiALNgIEIAUgAzYCNCAOQQg2AgAMCAsgBCAPNgJMIARBAjYCOCAEQdiezQA2AjQgBEICNwJAIARBOzYCXCAEIBg2AlggBEE7NgJUIAQgBEHQAGo2AjwgBCAEQcwAajYCUCAEQRhqQQRyIARBNGoQmQ4gDkEUaiAEQSxqKAIANgIAIA5BDGogBEEkaikCADcCACAOIAQpAhw3AgQgDkEANgIADAcLIARBNGpBF0EAQQFBARCgGCAEKAI4IQUgBCgCNEEBRg0FIAQoAjwiA0EPakHbhs0AKQAANwAAIANBCGpB1IbNACkAADcAACADQcyGzQApAAA3AAAgDkEXNgIMIA4gAzYCCCAOIAU2AgQgDkECNgIADAYLIAggA0GMhs0AELE7AAsgAyANQYyGzQAQsDsACyADIA1BnIbNABCwOwALIA8gFEGshs0AELE7AAsgFCAZQayGzQAQsDsACyAFIAQoAjxB1P3MABD9LwALIARB4ABqJAAMBwsgDkIINwMADAYLIAhFDQQgDEEIaiAMKAIQIgQgCSgCECIPIAhuIhggCSgCGCIZayIDIAogAyAKSRsiBSAIbCIUaiIDEI4tIAMgBE8EQCAMKAIQIgsgA08EQCAMKAIMIARqIRogCSgCDCEcQQAhCwNAAkACQCALIBhsIBlqIgMgBWoiBCADTwRAIAQgD0sNASAFRQ0CIAMgHGohHkEAIQ0gCyEEIAUhAwNAIAQgFEkEQCAEIBpqIA0gHmotAAA6AAAgBCAIaiEEIA1BAWohDSADQQFrIgMNAQwECwsgBCAUQcifzQAQwyEACyADIARBuJ/NABCxOwALIAQgD0G4n80AELA7AAsgC0EBaiILIAhHDQALIA4gBTYCBCAOQQg2AgAgCSAJKAIYIAVqNgIYDAcLIAMgC0Gon80AELA7AAsgBCADQaifzQAQsTsACyADIAVBwJ3NABCwOwALIAQgA0HAnc0AELE7AAtB4J3NABCyOwALQaCdzQAQsjsAC0GAns0AEOIrAAsgEEEgaiQAIAYoAhwhAyAGKAIYIgRBCEcEQCAHIAYpAyA3AwggB0EQaiAGQShqKQMANwMAIAcgAzYCBCAHIAQ2AgAMBQsgBiADNgIEIAMgCkYEQCABIAEoApgCIAJqIgM2ApgCIAogFmohFiACIBdqIRcgEiAVaiIVIBNJDQEMBAsLIAZBAjYCHCAGQeSRzwA2AhggBkICNwIkIAZBOzYCFCAGQTs2AgwgBiAGQQhqNgIgIAYgBkEEajYCECAGIAY2AgggB0EEaiAGQRhqEJkOIAdBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAcgFzYCDCAHIBY2AgggByAVNgIEIAdBCDYCAAsgBkEwaiQADAALIBEoAhAhAyARKAIUIQ4gESgCDCEIIBEoAggiAkEIRwRAIAAgESkDGDcDECAAIA42AgwgACADNgIIIAAgCDYCBCAAIAI2AgAMBQsgAyAOTw0DIBsoAgAiAkGBgICAeEcNAiARQQhqQT1BAEEBQQEQoBggESgCDCEBIBEoAghBAUYNASARKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgESgCEEHU/cwAEP0vAAsgASgC7AIhCyARIBtBBEEMIAJBgICAgHhGG2oQhj0gESgCACEFIBEoAgQhEyMAQZABayICJAAgAiAMKAIQIgY2AgAgAiAMKAIEQQAgDCgCABsiCiADIAtqIgRsIhA2AgQCQAJAAkACQAJAAkACQCAGIBBGBEAgDEEIaiAKIAsgDmpsEI4tIApBBEsNASACQQhqIAUgExDgHCACQgA3A3AgAiALNgJoIAIgBDYCbCAEIAtNDQIgDCgCECEHQQAgCmshFSAMKAIMIhYgCiAEQQFrbCITaiEMQQAgE2shECACKAJgIQkgAikDKCElIAIoAlwhEiACKAJYIQYgAikDSCEjIAIpAzghJiACKAIYIQ0gAikDECEkIAIoAjAhFyACKAIgIQ8gAikDUCEoIAIpA0AhKSACKQMIIScCQANAICenQQFxRSEDAkADQAJAAkACQCADRQRAICRQRQ0BQgAhJEIAISdBASEDDAQLAn4CQCAmQgJ9IipCAVgEQCAqp0EBaw0BDAULICanICZQrUIBhiEmQQFxRQ0AICkMAQsgI0IDUQRAQgMhIwwECyAGRSAGIBJGckUEQCASQQhrIhIpAwAMAQtBACEGICNCAlEEQEICISMMBAsgI6dCACEjQQFxRQ0DICgLISRCASEnIAlBQGoiCSENDAELIA0gJHmnQT9zIgNqIQVCASADrYYgJIUhJAwDC0EAIQMMAQsLIA8gJUIAUnFFDQUgFyAleadBP3MiA2ohBUIBIAOthiAlhSElCyAFIARBAWsiBE0NBAJAIAoEQCAHIBNrIgNBACADIAdNGyEUQQAhAyAHIAUgCmwiBWsiG0EAIAcgG08bIRsgBSAWaiEdA0AgAyAURg0CIAMgG0YNBCADIB1qIAMgDGotAAA6AAAgA0EBaiIDIApHDQALCyAMIBVqIQwgCiAQaiEQIBMgCmshEyAEIAtLDQEMBQsLIAMgEGsgB0H0m80AEMMhAAsgAyAFaiAHQYSczQAQwyEACyACQQA2AghBACACIAJBBGogAkEIakGkm80AEK8rAAsgAkEIaiAFIBMQ4BwgAkIANwNwIAIgCzYCaCACIAQ2AmwgBCALTQ0AIAwoAhAhEiAMKAIMIg0gCiADIAtqIhVBAWtsIhZqIRdBACEDIAIoAmAhCSACKQMoISUgAigCXCEGIAIoAlghByACKQNIISMgAikDOCEmIAIoAhghEyACKQMQISQgAigCMCEPIAIoAiAhFCACKQNQISggAikDQCEpIAIpAwghJwNAICenQQFxRSEFAkADQAJAAkACQCAFRQRAICRQRQ0BQgAhJEIAISdBASEFDAQLAn4CQCAmQgJ9IipCAVgEQCAqp0EBaw0BDAULICanICZQrUIBhiEmQQFxRQ0AICkMAQsgI0IDUQRAQgMhIwwECyAHRSAGIAdGckUEQCAGQQhrIgYpAwAMAQtBACEHICNCAlEEQEICISMMBAsgI6dCACEjQQFxRQ0DICgLISRCASEnIAlBQGoiCSETDAELIBMgJHmnQT9zIgxqIQVCASAMrYYgJIUhJAwDC0EAIQUMAQsLIBQgJUIAUnFFDQIgDyAleadBP3MiDGohBUIBIAythiAlhSElCyAFIARBAWsiBE0NASASIAUgCmwiBUkNAiAKIBIgBWsiDEsNAyADIBBqIgwgAyAWakkNBCAFIAxJDQUgCgRAIAUgDWogAyAXaiAK/AoAAAsgAyAKayEDIAQgC0sNAAsLIAJBkAFqJAAMBAsgAkEANgKIASACQQE2AnwgAkHM/cwANgJ4IAJCBDcCgAEgAkH4AGpBxJvNABDvLAALIAogDEHUm80AELA7AAsgCiAVQQFrbCADaiAMQeSbzQAQsTsACyAMIAVB5JvNABCwOwALCyAAIAg2AgQgAEEINgIAIAEgASgC8AIgCGo2AvACIAEgASgC7AIgDmo2AuwCCyARQSBqJAAPCyACIAYoAiBB9I7PABD9LwAL8BUCF38BfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBSABQbgCaiIVQQAgASgCuAJBgYCAgHhHGyEWIAFB4AJqQQAgASgC4AJBgICAgHhHGyEXIAFBoAJqIQ8jAEEwayIEJAACQAJAAkAgAiIQRQ0AIAFBoAFqIQ0gAUHQAGohGCABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ0gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgECARayEDIAEpAwBCBFINASACIAMgAiADSRsiDiECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgF0UEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBcgAyACEIwQIAQoAiAhByAEKAIcIQ4gBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAONgIEIAUgBjYCAAwGCyAHIA5yRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAOTQ0CIAEtAEwgAUEAOgBMIA5qIQ4LIAIhBwJAIBgpAwBCBVENACAWRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBggFiACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDSkDAEIGfSIaQgFYBEAgGqdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA0oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA0oAkghCCADIA1B0ABqIgkQ8y0iCzYCICADIA1B2ABqIgw2AnggCyAMELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshCyANQQhqIRICQCAPIAkQ1BMiCARAIAggCCgCCCIJIAtqEIctIAgoAggiDCAJSQ0GIANBMGogEiAIKAIEIAlBA3RqIAwgCWsQ2wogAygCNCEMIAMoAjAiC0EIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAMNgIEIAYgCzYCAAwMCyADQTBqIA8QkwsgAygCNCEZIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAZNgIEIAYgCDYCAAwMCyADQSBqIAtBgNXNABC2FSADQTBqIBIgAygCJCADKAIoENsKIAMoAjQhCAJAIAMoAjAiC0EIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCzYCAAwBCyADIAkQ8y0iCzYCLCADIAw2AnggCyAMELgIRQ0HIANBMGoiDCAJEMMtIANBGGogDBDcOyADKAIcIglFDQggA0EQaiADKAIYIgsQxxsgCUEBRg0KIAMoAhQhCSADKAIQIRIgA0EIaiALQQxqENw7IAggAygCKCILSw0JIANB+ABqIBkgAygCJCAIIBIgCSADKAIIIAMoAgwQ8A8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDBDvJgsgA0EgahDjPAwLCyAIIAkgDGoQ9DQgBiAMNgIEIAZBCDYCACANIA0oAkggDGs2AkgMCgsgA0EwaiAPEJMLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMIUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDEHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAtBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAooAhAhByAKKAIUIQIgCigCDCEQIAooAggiA0EIRwRAIAAgCikDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgC8AIhAyAKIBVBBEEMIARBgICAgHhGG2oQhj0gCigCACEEIAooAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzQcMAQsgD0EEaiIGIAIgA2oQhy0gBiADIAcgAiAEIAUQ/gkLCyAAIBA2AgQgAEEINgIAIAEgASgC9AIgEGo2AvQCIAEgASgC8AIgAmo2AvACCyAKQSBqJAAPCyACIAQoAiBB9I7PABD9LwAL7xcCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3AIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/IAkQ9C0aAkACQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAMLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0DIAggCCgCACIWQQFqNgIAIBZBAEgNAiAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMAwsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQAgCSgCBCEPIAoQ0CcgCiAPNgIUIAogCDYCECAKQgQ3AgggCkKAgICACDcCACAKQQRqDAILAAtBAAsiCARAIAggCCgCCCIJIAxqEJUtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAnRqIA0gCWsQuwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQkQsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABC/FSADQTBqIBMgAygCJCADKAIoELsLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ7w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDpOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJELIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEOk7CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQlS0gBiADIAcgAiAEIAUQ/wkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALyhgCGX8BfiMAQSBrIgwkAAJAAkACQAJAAkAgASkDAEIFUgRAIAxBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ1wIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA4oAkghCSADIA5B0ABqIggQ8y0iDTYCICADIA5B2ABqIgs2AnggDSALELgIRQ0CIAgQ9S0NAyAJIAcgByAJSxshDSAOQQhqIRMCQAJ/AkACQCAIEPQtQYCABEkEQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCCgCACIJIAgoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAkgCSgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAk2AhALIApBBGoMBAsgCCgCACIJIAkoAgAiD0EBajYCACAPQQBIDQEgCCgCBCEPIAoQzScgCiAPNgIUIAogCTYCECAKQgI3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIgkEQAJAIAkoAggiCCANaiILIAhNBEAgCSALNgIIDAELIAkgDRDMGiAJKAIIIQsLIAggC0sNBiADQTBqIBMgCSgCBCAIQQF0aiALIAhrELwLIAMoAjQhCyADKAIwIg1BCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCzYCBCAGIA02AgAMDAsgA0EwaiAKEJkLIAMoAjQhDyADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAk2AgAMDAsgA0EgaiANQYDVzQAQmRUgA0EwaiATIAMoAiQgAygCKBC8CyADKAI0IQkCQCADKAIwIg1BCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIA02AgAMAQsgAyAIEPMtIg02AiwgAyALNgJ4IA0gCxC4CEUNByADQTBqIgsgCBDDLSADQRhqIAsQ3DsgAygCHCIIRQ0IIANBEGogAygCGCINEMcbIAhBAUYNCiADKAIUIQggAygCECETIANBCGogDUEMahDcOyAJIAMoAigiDUsNCSADQfgAaiAPIAMoAiQgCSATIAggAygCCCADKAIMELcQIAMoAngiCEEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAINgIAIAsQ7yYLIANBIGoQnTwMCwsgCCALaiIIIAkoAghNBEAgCSAINgIICyAGIAs2AgQgBkEINgIAIA4gDigCSCALazYCSAwKCyADQTBqIAoQmQsgAygCNCEIIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCTYCAAwKCyAGIA4gCCAHQQAQwhQMCQsgCCADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCCALQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAkgDUHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAk2AgQgBkEINgIAIA4gDigCSCAJazYCSCADQTBqEO8mIANBIGoQnTwLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgDCgCECEHIAwoAhQhAiAMKAIMIREgDCgCCCIDQQhHBEAgACAMKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAxBCGpBPUEAQQFBARCgGCAMKAIMIQEgDCgCCEEBRg0BIAwoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASAMKAIQQdT9zAAQ/S8ACyABKALwAiEDIAwgGEEEQQwgBEGAgICAeEYbahCGPSAMKAIAIQQgDCgCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIQYCQCACIANqIg4gCigCDCIITQRAIAogDjYCDAwBCyAGIA4gCGsQzBoLIAYgAyAHIAIgBCAFEMkJCwsgACARNgIEIABBCDYCACABIAEoAvQCIBFqNgL0AiABIAEoAvACIAJqNgLwAgsgDEEgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC58VAhh/CH4jAEEgayIKJAACQAJAAkACQAJAIAEpAwBCBVIEQCAKQQhqIQQgAUHgAWoiE0EAIAEoAuABQYGAgIB4RxshFCABQZQCakEAIAEoApQCQYCAgIB4RxshFSABQYgCaiEMIwBBMGsiAyQAAkACQAJAIAIiCUUNACABQaABaiENIAFB0ABqIRYgASgC2AEhBgJAAkADQAJAAkACQCABKALUASICQQAgAiAGRxtFBEAgA0EYaiABENoCIAMtABwhAiADKAIYIgVBCEcNASACQQFxRQ0HIAEoAtQBIgJFDQcgASgC2AEhBgsgAiAGayECIAkgDmshBiABKQMAQgRSDQEgAiAGIAIgBkkbIgshAgwCCyAEIAMpAB03AAUgBEEUaiADQSxqKAAANgAAIARBDWogA0ElaikAADcAACAEIAI6AAQgBCAFNgIADAYLIBVFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQRZqQeiSzwApAAA3AAAgBUEQakHiks8AKQAANwAAIAVBCGpB2pLPACkAADcAACAFQdKSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogASAVIAYgAhCMECADKAIgIQUgAygCHCELIAMoAhgiB0EIRwRAIAQgAykCJDcCDCAEQRRqIANBLGooAgA2AgAgBCAFNgIIIAQgCzYCBCAEIAc2AgAMBgsgBSALckUEQCADQRhqQS9BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBuJDPAEEv/AoAACAEQS82AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgAiAFRwRAIAUhAgwBCyABLQDcAUEBRw0AIAYgC00NAiABLQBMIAFBADoATCALaiELCyACIQUCQCAWKQMAQgVRDQAgFEUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNBCADKAIgIgVBFmpBhpPPACkAADcAACAFQRBqQYCTzwApAAA3AAAgBUEIakH4ks8AKQAANwAAIAVB8JLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiAWIBQgAhDFAyADKAIgIQYgAygCHCEFIAMoAhgiB0EIRwRAIAQgAykCJDcCDCAEQRRqIANBLGooAgA2AgAgBCAGNgIIIAQgBTYCBCAEIAc2AgAMBgsgAiAGRg0AIANBGGpB3gBBAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDCADKAIgIgVB9JHPAEHeAPwKAAAgBEHeADYCDCAEIAU2AgggBCACNgIEIARBADYCAAwFCyADIAU2AgAgA0EYaiEPQQAhByMAQSBrIgYkAAJAAkAgDS0AJCIIQQlHBEAgBiAIOgAHAkACQCANKAIMRQ0AIA1BEGogBkEHahDsDCEbIA0oAgAiEUEMayEYIA0oAgQiFyAbp3EhCCAbQhmIQv8Ag0KBgoSIkKDAgAF+IR0gBi0AByEZA0AgCCARaikAACIcIB2FIhtCf4UgG0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIbUEUEQANAIBkgGEEAIBt6p0EDdiAIaiAXcWsiGkEMbGotAABGDQQgG0IBfSAbgyIbUEUNAAsLIBwgHEIBhoNCgIGChIiQoMCAf4NQRQ0BIAggB0EIaiIHaiAXcSEIDAALAAsgBkEHahCFKQALAkAgDCgCCCIIIAVqIgcgCE0EQCAMIAc2AggMAQsgDCAFEIMfIAwoAgghBwsgByAISQ0BIAZBCGogESAaQQxsaiIRQQhrKAIAIAwoAgQgCEEDdGogByAIayARQQRrKAIAKAIQEQUAIAYoAgwhBwJAIAYoAggiEUEIRwRAIA8gBikDEDcDCCAPQRBqIAZBGGopAwA3AwAMAQsgByAIaiIIIAwoAghLDQAgDCAINgIICyAPIBE2AgAgDyAHNgIEIAZBIGokAAwCC0Hkrc4AQR5BhK7OABDLJAALIAggB0Gkrs4AEK87AAsgAygCHCEGIAMoAhgiB0EIRwRAIAQgAykDIDcDCCAEQRBqIANBKGopAwA3AwAgBCAGNgIEIAQgBzYCAAwFCyADIAY2AgQgBSAGRgRAIAEgASgC2AEgAmoiBjYC2AEgBSAQaiEQIAIgEmohEiALIA5qIg4gCUkNAQwECwsgA0ECNgIcIANB5JHPADYCGCADQgI3AiQgA0E7NgIUIANBOzYCDCADIANBCGo2AiAgAyADQQRqNgIQIAMgAzYCCCAEQQRqIANBGGoQmQ4gBEEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBCASNgIMIAQgEDYCCCAEIA42AgQgBEEINgIACyADQTBqJAAMAAsgCigCECEFIAooAhQhBiAKKAIMIQcgCigCCCICQQhHBEAgACAKKQMYNwMQIAAgBjYCDCAAIAU2AgggACAHNgIEIAAgAjYCAAwFCyAFIAZPDQMgEygCACIJQYGAgIB4Rw0CIApBCGpBPUEAQQFBARCgGCAKKAIMIQEgCigCCEEBRg0BIAooAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASAKKAIQQdT9zAAQ/S8ACyABKAKkAiECIAogE0EEQQwgCUGAgICAeEYbahCGPSAKKAIAIQQgCigCBCELIwBB8ABrIgMkAAJAIAIgBmoiCSAMKAIIIghNBEAgDCAJNgIIDAELIAwgCSAIaxCDHwsgAyAEIAsQ4BwgA0IANwNoIAMgAjYCYCADIAIgBWoiBTYCZAJAAkACQAJAIAIgBU8NACAFQQN0QQhrIQsgAygCWCEPIAMpAyAhHSADKAJUIQggAygCUCENIAMpA0AhGyADKQMwIR4gAygCECEQIAMpAwghHCADKAIoIRIgAygCGCETIAMpA0ghICADKQM4ISEgAykDACEfA0AgH6dBAXFFIQQCQANAAkACQAJAIARFBEAgHFBFDQFCACEcQgAhH0EBIQQMBAsCfgJAIB5CAn0iIkIBWARAICKnQQFrDQEMBQsgHqcgHlCtQgGGIR5BAXFFDQAgIQwBCyAbQgNRBEBCAyEbDAQLIA1FIAggDUZyRQRAIAhBCGsiCCkDAAwBC0EAIQ0gG0ICUQRAQgIhGwwECyAbp0IAIRtBAXFFDQMgIAshHEIBIR8gD0FAaiIPIRAMAQsgECAceadBP3MiCWohBEIBIAmthiAchSEcDAMLQQAhBAwBCwsgEyAdQgBScUUNAiASIB15p0E/cyIJaiEEQgEgCa2GIB2FIR0LIAQgBUEBayIJTQ0BIAkgDCgCCCIOTw0CIAQgDk8NAyAMKAIEIgUgBEEDdGogBSALaisDADkDACALQQhrIQsgCSIFIAJLDQALCyADQfAAaiQADAILIAVBAWsgDkGwms8AEMMhAAsgBCAOQcCazwAQwyEACwsgACAHNgIEIABBCDYCACABIAEoAqgCIAdqNgKoAiABIAEoAqQCIAZqNgKkAgsgCkEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC6MOARN/IwBBIGsiByQAAkACQAJAAkACQCABKQMAQgVSBEAgB0EIaiEEIAFBwAJqIg9BACABKALAAkGBgICAeEcbIRAgAUHoAmpBACABKALoAkGAgICAeEcbIREgAUGoAmohEiMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDCABQdAAaiETIAEoAqACIQYCQAJAA0ACQAJAAkAgASgCnAIiAkEAIAIgBkcbRQRAIANBGGogARDTAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKAKcAiICRQ0HIAEoAqACIQYLIAIgBmshAiAKIAtrIQYgASkDAEIEUg0BIAIgBiACIAZJGyIJIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyARRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgESAGIAIQjBAgAygCICEFIAMoAhwhCSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAk2AgQgBCAINgIADAYLIAUgCXJFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0ApAJBAUcNACAGIAlNDQIgAS0ATCABQQA6AEwgCWohCQsgAiEFAkAgEykDAEIFUQ0AIBBFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogEyAQIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohCCMAQRBrIgYkAAJAAkACQCAMKQMAQgZRBEAgBkEEakEOQQBBAUEBEKAYIAYoAgghFCAGKAIEQQFGDQIgBigCDCIVQQZqQa6MzQApAAA3AAAgFUGojM0AKQAANwAAIAhBDjYCDCAIIBU2AgggCCAUNgIEIAhBADYCAAwBCyAIIAwgEiAFIAxB0ABqQQAgDCgCUEGAgICAeEcbEMIUCyAGQRBqJAAMAQsgFCAGKAIMQdT9zAAQ/S8ACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKAKgAiACaiIGNgKgAiAFIA1qIQ0gAiAOaiEOIAkgC2oiCyAKSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIA42AgwgBCANNgIIIAQgCzYCBCAEQQg2AgALIANBMGokAAwACyAHKAIQIQUgBygCFCECIAcoAgwhCiAHKAIIIgNBCEcEQCAAIAcpAxg3AxAgACACNgIMIAAgBTYCCCAAIAo2AgQgACADNgIADAULIAIgBU0NAyAPKAIAIgNBgYCAgHhHDQIgB0EIakE9QQBBAUEBEKAYIAcoAgwhASAHKAIIQQFGDQEgBygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAcoAhBB1P3MABD9LwALIAEoAvgCIQQgByAPQQRBDCADQYCAgIB4RhtqEIY9IBIgBCAFIAIgBygCACAHKAIEEM0HCyAAIAo2AgQgAEEINgIAIAEgASgC/AIgCmo2AvwCIAEgASgC+AIgAmo2AvgCCyAHQSBqJAAPCyACIAMoAiBB9I7PABD9LwALxhgCGX8BfiMAQSBrIgwkAAJAAkACQAJAAkAgASkDAEIFUgRAIAxBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ1gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA4oAkghCSADIA5B0ABqIggQ8y0iDTYCICADIA5B2ABqIgs2AnggDSALELgIRQ0CIAgQ9S0NAyAJIAcgByAJSxshDSAOQQhqIRMCQAJ/AkACQCAIEPQtQYABSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAIKAIAIgkgCCgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCSAJKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCTYCEAsgCkEEagwECyAIKAIAIgkgCSgCACIPQQFqNgIAIA9BAEgNASAIKAIEIQ8gChDMJyAKIA82AhQgCiAJNgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCQRAAkAgCSgCCCIIIA1qIgsgCE0EQCAJIAs2AggMAQsgCSANEMggIAkoAgghCwsgCCALSw0GIANBMGogEyAJKAIEIAhqIAsgCGsQqAsgAygCNCELIAMoAjAiDUEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiALNgIEIAYgDTYCAAwMCyADQTBqIAoQlwsgAygCNCEPIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCTYCAAwMCyADQSBqIA1BgNXNABDOGCADQTBqIBMgAygCJCADKAIoEKgLIAMoAjQhCQJAIAMoAjAiDUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgDTYCAAwBCyADIAgQ8y0iDTYCLCADIAs2AnggDSALELgIRQ0HIANBMGoiCyAIEMMtIANBGGogCxDcOyADKAIcIghFDQggA0EQaiADKAIYIg0QxRsgCEEBRg0KIAMoAhQhCCADKAIQIRMgA0EIaiANQQxqENw7IAkgAygCKCINSw0JIANB+ABqIA8gAygCJCAJIBMgCCADKAIIIAMoAgwQkhAgAygCeCIIQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAg2AgAgCxDvJgsgA0EgahDeOwwLCyAIIAtqIgggCSgCCE0EQCAJIAg2AggLIAYgCzYCBCAGQQg2AgAgDiAOKAJIIAtrNgJIDAoLIANBMGogChCXCyADKAI0IQggAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAJNgIADAoLIAYgDiAIIAdBABDBFAwJCyAIIAMoAjhB/LvNABD9LwALIANBADYCMCADQSBqIANB+ABqIANBMGpB8NTNABCjKwALIAZCCDcDAAwGCyAIIAtB4NXNABCvOwALIANBADYCMCADQSxqIANB+ABqIANBMGpBkNXNABCjKwALQQBBAEGg1c0AEMMhAAsgCSANQcDVzQAQsDsAC0EBQQFBsNXNABDDIQALIAYgCTYCBCAGQQg2AgAgDiAOKAJIIAlrNgJIIANBMGoQ7yYgA0EgahDeOwsgA0GQAWokACAEKAIcIQMgBCgCGCIGQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAGNgIADAULIAQgAzYCBCADIAdGBEAgASABKAKYAiACaiIDNgKYAiAHIBRqIRQgAiAVaiEVIBAgEmoiEiARSQ0BDAQLCyAEQQI2AhwgBEHkkc8ANgIYIARCAjcCJCAEQTs2AhQgBEE7NgIMIAQgBEEIajYCICAEIARBBGo2AhAgBCAENgIIIAVBBGogBEEYahCZDiAFQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAFIBU2AgwgBSAUNgIIIAUgEjYCBCAFQQg2AgALIARBMGokAAwACyAMKAIQIQcgDCgCFCECIAwoAgwhESAMKAIIIgNBCEcEQCAAIAwpAxg3AxAgACACNgIMIAAgBzYCCCAAIBE2AgQgACADNgIADAULIAIgB00NAyAYKAIAIgRBgYCAgHhHDQIgDEEIakE9QQBBAUEBEKAYIAwoAgwhASAMKAIIQQFGDQEgDCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAwoAhBB1P3MABD9LwALIAEoAvACIQMgDCAYQQRBDCAEQYCAgIB4RhtqEIY9IAwoAgAhBCAMKAIEIQUCQCAKKAIAQYCAgIB4RwRAIAogAyAHIAIgBCAFEMwHDAELIApBBGohBgJAIAIgA2oiDiAKKAIMIghNBEAgCiAONgIMDAELIAYgDiAIaxDIIAsgBiADIAcgAiAEIAUQ6gkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyAMQSBqJAAPCyACIAQoAiBB9I7PABD9LwALgRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDMJyAKIA82AhQgCiAINgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEI4tIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlqIA0gCWsQxwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQlgsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABDOGCADQTBqIBMgAygCJCADKAIoEMcLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQyhAgAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDeOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJYLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQji0gBiADIAcgAiAEIAUQqgoLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwAL8BUCF38BfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBSABQbgCaiIVQQAgASgCuAJBgYCAgHhHGyEWIAFB4AJqQQAgASgC4AJBgICAgHhHGyEXIAFBoAJqIQ8jAEEwayIEJAACQAJAAkAgAiIQRQ0AIAFBoAFqIQ0gAUHQAGohGCABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3AIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgECARayEDIAEpAwBCBFINASACIAMgAiADSRsiDiECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgF0UEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBcgAyACEIwQIAQoAiAhByAEKAIcIQ4gBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAONgIEIAUgBjYCAAwGCyAHIA5yRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAOTQ0CIAEtAEwgAUEAOgBMIA5qIQ4LIAIhBwJAIBgpAwBCBVENACAWRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBggFiACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDSkDAEIGfSIaQgFYBEAgGqdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA0oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA0oAkghCCADIA1B0ABqIgkQ8y0iCzYCICADIA1B2ABqIgw2AnggCyAMELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshCyANQQhqIRICQCAPIAkQ0xMiCARAIAggCCgCCCIJIAtqEIctIAgoAggiDCAJSQ0GIANBMGogEiAIKAIEIAlBA3RqIAwgCWsQ2wogAygCNCEMIAMoAjAiC0EIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAMNgIEIAYgCzYCAAwMCyADQTBqIA8QmAsgAygCNCEZIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAZNgIEIAYgCDYCAAwMCyADQSBqIAtBgNXNABC2FSADQTBqIBIgAygCJCADKAIoENsKIAMoAjQhCAJAIAMoAjAiC0EIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCzYCAAwBCyADIAkQ8y0iCzYCLCADIAw2AnggCyAMELgIRQ0HIANBMGoiDCAJEMMtIANBGGogDBDcOyADKAIcIglFDQggA0EQaiADKAIYIgsQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRIgA0EIaiALQQxqENw7IAggAygCKCILSw0JIANB+ABqIBkgAygCJCAIIBIgCSADKAIIIAMoAgwQ8g8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDBDvJgsgA0EgahDjPAwLCyAIIAkgDGoQ9DQgBiAMNgIEIAZBCDYCACANIA0oAkggDGs2AkgMCgsgA0EwaiAPEJgLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDEHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAtBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAooAhAhByAKKAIUIQIgCigCDCEQIAooAggiA0EIRwRAIAAgCikDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgC8AIhAyAKIBVBBEEMIARBgICAgHhGG2oQhj0gCigCACEEIAooAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzAcMAQsgD0EEaiIGIAIgA2oQhy0gBiADIAcgAiAEIAUQ/gkLCyAAIBA2AgQgAEEINgIAIAEgASgC9AIgEGo2AvQCIAEgASgC8AIgAmo2AvACCyAKQSBqJAAPCyACIAQoAiBB9I7PABD9LwALwRACGH8DfiMAQSBrIggkAAJAAkACQAJAAkAgASkDAEIFUgRAIAhBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQsjAEEwayIDJAACQAJAAkAgAiIMRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ1AIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgDCAPayEGIAEpAwBCBFINASACIAYgAiAGSRsiCiECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQogAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCAKNgIEIAQgBzYCAAwGCyAFIApyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiAKTQ0CIAEtAEwgAUEAOgBMIApqIQoLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgBzYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIRBBACEJIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACINQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIA1qKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAJQQhqIglqIBdxIQcMAAsACyAGQQdqEIUpAAsgCyALKAIIIgcgBWoQhy0gCygCCCIJIAdJDQEgBkEIaiANIBpBDGxqIg1BCGsoAgAgCygCBCAHQQN0aiAJIAdrIA1BBGsoAgAoAhARBQAgBigCDCEJAkAgBigCCCINQQhHBEAgECAGKQMQNwMIIBBBEGogBkEYaikDADcDAAwBCyALIAcgCWoQ9DQLIBAgDTYCACAQIAk2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAJQaSuzgAQrzsACyADKAIcIQYgAygCGCIHQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAHNgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBFqIREgAiASaiESIAogD2oiDyAMSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCARNgIIIAQgDzYCBCAEQQg2AgALIANBMGokAAwACyAIKAIQIQUgCCgCFCECIAgoAgwhDCAIKAIIIgNBCEcEQCAAIAgpAxg3AxAgACACNgIMIAAgBTYCCCAAIAw2AgQgACADNgIADAULIAIgBU0NAyATKAIAIgNBgYCAgHhHDQIgCEEIakE9QQBBAUEBEKAYIAgoAgwhASAIKAIIQQFGDQEgCCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAgoAhBB1P3MABD9LwALIAEoAqQCIQQgCCATQQRBDCADQYCAgIB4RhtqEIY9IAsgBCAFIAIgCCgCACAIKAIEEP4JCyAAIAw2AgQgAEEINgIAIAEgASgCqAIgDGo2AqgCIAEgASgCpAIgAmo2AqQCCyAIQSBqJAAPCyACIAMoAiBB9I7PABD9LwAL3BUCGH8IfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQwjAEEwayIDJAACQAJAAkAgAiIJRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ0QIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgCSANayEGIAEpAwBCBFINASACIAYgAiAGSRsiCyECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQsgAygCGCIIQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCALNgIEIAQgCDYCAAwGCyAFIAtyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiALTQ0CIAEtAEwgAUEAOgBMIAtqIQsLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIIQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgCDYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIQ9BACEIIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACIRQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIBFqKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAIQQhqIghqIBdxIQcMAAsACyAGQQdqEIUpAAsgDCgCCCEHIAZBADYCECAGQgA3AggCQCAHIAUgB2oiCE8EQCAMIAg2AggMAQsgDCAFIAZBCGoQhBggDCgCCCEICyAHIAhLDQEgBkEIaiARIBpBDGxqIhFBCGsoAgAgDCgCBCAHQQxsaiAIIAdrIBFBBGsoAgAoAhARBQAgBigCDCEIAkAgBigCCCIRQQhHBEAgDyAGKQMQNwMIIA9BEGogBkEYaikDADcDAAwBCyAHIAhqIgcgDCgCCEsNACAMIAc2AggLIA8gETYCACAPIAg2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAIQaSuzgAQrzsACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBBqIRAgAiASaiESIAsgDWoiDSAJSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCAQNgIIIAQgDTYCBCAEQQg2AgALIANBMGokAAwACyAKKAIQIQUgCigCFCEGIAooAgwhCCAKKAIIIgJBCEcEQCAAIAopAxg3AxAgACAGNgIMIAAgBTYCCCAAIAg2AgQgACACNgIADAULIAUgBk8NAyATKAIAIglBgYCAgHhHDQIgCkEIakE9QQBBAUEBEKAYIAooAgwhASAKKAIIQQFGDQEgCigCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAooAhBB1P3MABD9LwALIAEoAqQCIQIgCiATQQRBDCAJQYCAgIB4RhtqEIY9IAooAgAhBCAKKAIEIQsjAEHwAGsiAyQAIANBADYCCCADQgA3AgACQCACIAZqIgkgDCgCCCIHTQRAIAwgCTYCCAwBCyAMIAkgB2sgAxCEGAsgAyAEIAsQ4BwgA0IANwNoIAMgAjYCYCADIAIgBWoiBTYCZAJAAkACQAJAIAIgBU8NACAFQQxsQQxrIQsgAygCWCEPIAMpAyAhHSADKAJUIQcgAygCUCEOIAMpA0AhGyADKQMwIR4gAygCECEQIAMpAwghHCADKAIoIRIgAygCGCETIAMpA0ghISADKQM4ISIgAykDACEfA0AgH6dBAXFFIQQCQANAAkACQAJAIARFBEAgHFBFDQFCACEcQgAhH0EBIQQMBAsCfgJAIB5CAn0iIEIBWARAICCnQQFrDQEMBQsgHqcgHlCtQgGGIR5BAXFFDQAgIgwBCyAbQgNRBEBCAyEbDAQLIA5FIAcgDkZyRQRAIAdBCGsiBykDAAwBC0EAIQ4gG0ICUQRAQgIhGwwECyAbp0IAIRtBAXFFDQMgIQshHEIBIR8gD0FAaiIPIRAMAQsgECAceadBP3MiCWohBEIBIAmthiAchSEcDAMLQQAhBAwBCwsgEyAdQgBScUUNAiASIB15p0E/cyIJaiEEQgEgCa2GIB2FIR0LIAQgBUEBayIJTQ0BIAkgDCgCCCINTw0CIAQgDU8NAyAMKAIEIgUgC2oiDSkCACEgIAUgBEEMbGoiBUEIaiANQQhqKAIANgIAIAUgIDcCACALQQxrIQsgCSIFIAJLDQALCyADQfAAaiQADAILIAVBAWsgDUGwms8AEMMhAAsgBCANQcCazwAQwyEACwsgACAINgIEIABBCDYCACABIAEoAqgCIAhqNgKoAiABIAEoAqQCIAZqNgKkAgsgCkEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC8oYAhl/AX4jAEEgayIMJAACQAJAAkACQAJAIAEpAwBCBVIEQCAMQQhqIQUgAUG4AmoiGEEAIAEoArgCQYGAgIB4RxshGSABQeACakEAIAEoAuACQYCAgIB4RxshGiABQaACaiEKIwBBMGsiBCQAAkACQAJAIAIiEUUNACABQaABaiEOIAFB0ABqIRsgASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABEOMCIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBEgEmshAyABKQMAQgRSDQEgAiADIAIgA0kbIhAhAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBpFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAaIAMgAhCMECAEKAIgIQcgBCgCHCEQIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgEDYCBCAFIAY2AgAMBgsgByAQckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgEE0NAiABLQBMIAFBADoATCAQaiEQCyACIQcCQCAbKQMAQgVRDQAgGUUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAbIBkgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA4pAwBCBn0iHEIBWARAIBynQQFGBEBB1NTNAEELQeDUzQAQyyQACyAOKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQggAygCMEEBRg0CIAMoAjgiCUHw1c0AQSL8CgAAIAZBIjYCDCAGIAk2AgggBiAINgIEIAZBADYCAAwLCyAOKAJIIQkgAyAOQdAAaiIIEPMtIg02AiAgAyAOQdgAaiILNgJ4IA0gCxC4CEUNAiAIEPUtDQMgCSAHIAcgCUsbIQ0gDkEIaiETAkACfwJAAkAgCBD0LUGAgARJBEACQCAKKAIAQYCAgIB4RwRAIAooAghBAUYNAQwECyAKKAIQIAooAhQoAghBAWtBeHFqIAgoAgAiCSAIKAIEIg8oAghBAWtBeHFqRwRAIAooAgwNBCAJIAkoAgAiFkEBajYCACAWQQBIDQMgCkEQaiIWKAIAIhcgFygCACIXQQFrNgIAIBdBAUYEQCAWELsjCyAKIA82AhQgCiAJNgIQCyAKQQRqDAQLIAgoAgAiCSAJKAIAIg9BAWo2AgAgD0EASA0BIAgoAgQhDyAKEM4nIAogDzYCFCAKIAk2AhAgCkICNwIIIApCgICAgAg3AgAgCkEEagwDC0Hgxs0AQTtBnMfNABCfKQsAC0EACyIJBEACQCAJKAIIIgggDWoiCyAITQRAIAkgCzYCCAwBCyAJIA0QzBogCSgCCCELCyAIIAtLDQYgA0EwaiATIAkoAgQgCEEBdGogCyAIaxC8CyADKAI0IQsgAygCMCINQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAs2AgQgBiANNgIADAwLIANBMGogChCSCyADKAI0IQ8gAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAJNgIADAwLIANBIGogDUGA1c0AEJkVIANBMGogEyADKAIkIAMoAigQvAsgAygCNCEJAkAgAygCMCINQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiANNgIADAELIAMgCBDzLSINNgIsIAMgCzYCeCANIAsQuAhFDQcgA0EwaiILIAgQwy0gA0EYaiALENw7IAMoAhwiCEUNCCADQRBqIAMoAhgiDRDFGyAIQQFGDQogAygCFCEIIAMoAhAhEyADQQhqIA1BDGoQ3DsgCSADKAIoIg1LDQkgA0H4AGogDyADKAIkIAkgEyAIIAMoAgggAygCDBC2ECADKAJ4IghBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCDYCACALEO8mCyADQSBqEJ08DAsLIAggC2oiCCAJKAIITQRAIAkgCDYCCAsgBiALNgIEIAZBCDYCACAOIA4oAkggC2s2AkgMCgsgA0EwaiAKEJILIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiAOIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAggC0Hg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAJIA1BwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAJNgIEIAZBCDYCACAOIA4oAkggCWs2AkggA0EwahDvJiADQSBqEJ08CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAwoAhAhByAMKAIUIQIgDCgCDCERIAwoAggiA0EIRwRAIAAgDCkDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiAMQQhqQT1BAEEBQQEQoBggDCgCDCEBIAwoAghBAUYNASAMKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgDCgCEEHU/cwAEP0vAAsgASgC8AIhAyAMIBhBBEEMIARBgICAgHhGG2oQhj0gDCgCACEEIAwoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiEGAkAgAiADaiIOIAooAgwiCE0EQCAKIA42AgwMAQsgBiAOIAhrEMwaCyAGIAMgByACIAQgBRDJCQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAxBIGokAA8LIAIgBCgCIEH0js8AEP0vAAuMFQIYfwh+IwBBIGsiCSQAAkACQAJAAkACQCABKQMAQgVSBEAgCUEIaiEFIAFB4AFqIhNBACABKALgAUGBgICAeEcbIRQgAUGUAmpBACABKAKUAkGAgICAeEcbIRUgAUGIAmohDCMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDSABQdAAaiEWIAEoAtgBIQYCQAJAA0ACQAJAAkAgASgC1AEiAkEAIAIgBkcbRQRAIANBGGogARDhAiADLQAcIQIgAygCGCIEQQhHDQEgAkEBcUUNByABKALUASICRQ0HIAEoAtgBIQYLIAIgBmshAiAKIA5rIQYgASkDAEIEUg0BIAIgBiACIAZJGyILIQIMAgsgBSADKQAdNwAFIAVBFGogA0EsaigAADYAACAFQQ1qIANBJWopAAA3AAAgBSACOgAEIAUgBDYCAAwGCyAVRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBEEWakHoks8AKQAANwAAIARBEGpB4pLPACkAADcAACAEQQhqQdqSzwApAAA3AAAgBEHSks8AKQAANwAAIAVBHjYCDCAFIAQ2AgggBSACNgIEIAVBADYCAAwGCyADQRhqIAEgFSAGIAIQjBAgAygCICEEIAMoAhwhCyADKAIYIghBCEcEQCAFIAMpAiQ3AgwgBUEUaiADQSxqKAIANgIAIAUgBDYCCCAFIAs2AgQgBSAINgIADAYLIAQgC3JFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIEQbiQzwBBL/wKAAAgBUEvNgIMIAUgBDYCCCAFIAI2AgQgBUEANgIADAYLIAIgBEcEQCAEIQIMAQsgAS0A3AFBAUcNACAGIAtNDQIgAS0ATCABQQA6AEwgC2ohCwsgAiEEAkAgFikDAEIFUQ0AIBRFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIEQRZqQYaTzwApAAA3AAAgBEEQakGAk88AKQAANwAAIARBCGpB+JLPACkAADcAACAEQfCSzwApAAA3AAAgBUEeNgIMIAUgBDYCCCAFIAI2AgQgBUEANgIADAYLIANBGGogFiAUIAIQxQMgAygCICEGIAMoAhwhBCADKAIYIghBCEcEQCAFIAMpAiQ3AgwgBUEUaiADQSxqKAIANgIAIAUgBjYCCCAFIAQ2AgQgBSAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIEQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAENgIIIAUgAjYCBCAFQQA2AgAMBQsgAyAENgIAIANBGGohD0EAIQgjAEEgayIGJAACQAJAIA0tACQiB0EJRwRAIAYgBzoABwJAAkAgDSgCDEUNACANQRBqIAZBB2oQ7AwhGyANKAIAIhBBDGshGCANKAIEIhcgG6dxIQcgG0IZiEL/AINCgYKEiJCgwIABfiEdIAYtAAchGQNAIAcgEGopAAAiHCAdhSIbQn+FIBtCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiG1BFBEADQCAZIBhBACAbeqdBA3YgB2ogF3FrIhpBDGxqLQAARg0EIBtCAX0gG4MiG1BFDQALCyAcIBxCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAhBCGoiCGogF3EhBwwACwALIAZBB2oQhSkACwJAIAwoAggiByAEaiIIIAdNBEAgDCAINgIIDAELIAwgBBCGHCAMKAIIIQgLIAcgCEsNASAGQQhqIBAgGkEMbGoiEEEIaygCACAMKAIEIAdqIAggB2sgEEEEaygCACgCEBEFACAGKAIMIQgCQCAGKAIIIhBBCEcEQCAPIAYpAxA3AwggD0EQaiAGQRhqKQMANwMADAELIAcgCGoiByAMKAIISw0AIAwgBzYCCAsgDyAQNgIAIA8gCDYCBCAGQSBqJAAMAgtB5K3OAEEeQYSuzgAQyyQACyAHIAhBpK7OABCvOwALIAMoAhwhBiADKAIYIghBCEcEQCAFIAMpAyA3AwggBUEQaiADQShqKQMANwMAIAUgBjYCBCAFIAg2AgAMBQsgAyAGNgIEIAQgBkYEQCABIAEoAtgBIAJqIgY2AtgBIAQgEWohESACIBJqIRIgCyAOaiIOIApJDQEMBAsLIANBAjYCHCADQeSRzwA2AhggA0ICNwIkIANBOzYCFCADQTs2AgwgAyADQQhqNgIgIAMgA0EEajYCECADIAM2AgggBUEEaiADQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgEjYCDCAFIBE2AgggBSAONgIEIAVBCDYCAAsgA0EwaiQADAALIAkoAhAhBCAJKAIUIQUgCSgCDCEGIAkoAggiAkEIRwRAIAAgCSkDGDcDECAAIAU2AgwgACAENgIIIAAgBjYCBCAAIAI2AgAMBQsgBCAFTw0DIBMoAgAiAkGBgICAeEcNAiAJQQhqQT1BAEEBQQEQoBggCSgCDCEBIAkoAghBAUYNASAJKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCSgCEEHU/cwAEP0vAAsgASgCpAIhAyAJIBNBBEEMIAJBgICAgHhGG2oQhj0gCSgCACEIIAkoAgQhCyMAQfAAayICJAACQCADIAVqIgogDCgCCCIHTQRAIAwgCjYCCAwBCyAMIAogB2sQhhwLIAIgCCALEOAcIAJCADcDaCACIAM2AmAgAiADIARqIgQ2AmQCQAJAAkACQCADIARPDQAgBEEBayEKIAIoAlghDSACKQMgIR0gAigCVCEIIAIoAlAhCyACKQNAIRsgAikDMCEeIAIoAhAhDiACKQMIIRwgAigCKCEPIAIoAhghESACKQNIISAgAikDOCEhIAIpAwAhHwNAIB+nQQFxRSEEAkADQAJAAkACQCAERQRAIBxQRQ0BQgAhHEIAIR9BASEEDAQLAn4CQCAeQgJ9IiJCAVgEQCAip0EBaw0BDAULIB6nIB5QrUIBhiEeQQFxRQ0AICEMAQsgG0IDUQRAQgMhGwwECyALRSAIIAtGckUEQCAIQQhrIggpAwAMAQtBACELIBtCAlEEQEICIRsMBAsgG6dCACEbQQFxRQ0DICALIRxCASEfIA1BQGoiDSEODAELIA4gHHmnQT9zIgdqIQRCASAHrYYgHIUhHAwDC0EAIQQMAQsLIBEgHUIAUnFFDQIgDyAdeadBP3MiB2ohBEIBIAethiAdhSEdCyAEIApNDQEgCiAMKAIIIgdPDQIgBCAHTw0DIAQgDCgCBCIHaiAHIApqLQAAOgAAIAMgCkkgCkEBayEKDQALCyACQfAAaiQADAILIAogB0Gwms8AEMMhAAsgBCAHQcCazwAQwyEACwsgACAGNgIEIABBCDYCACABIAEoAqgCIAZqNgKoAiABIAEoAqQCIAVqNgKkAgsgCUEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC4UYAhl/AX4jAEEgayILJAACQAJAAkACQAJAIAEpAwBCBVIEQCALQQhqIQUgAUG4AmoiGEEAIAEoArgCQYGAgIB4RxshGSABQeACakEAIAEoAuACQYCAgIB4RxshGiABQaACaiEKIwBBMGsiBCQAAkACQAJAIAIiEUUNACABQaABaiEOIAFB0ABqIRsgASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABENsCIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBEgEmshAyABKQMAQgRSDQEgAiADIAIgA0kbIhAhAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBpFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAaIAMgAhCMECAEKAIgIQcgBCgCHCEQIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgEDYCBCAFIAY2AgAMBgsgByAQckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgEE0NAiABLQBMIAFBADoATCAQaiEQCyACIQcCQCAbKQMAQgVRDQAgGUUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAbIBkgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA4pAwBCBn0iHEIBWARAIBynQQFGBEBB1NTNAEELQeDUzQAQyyQACyAOKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQkgAygCMEEBRg0CIAMoAjgiCEHw1c0AQSL8CgAAIAZBIjYCDCAGIAg2AgggBiAJNgIEIAZBADYCAAwLCyAOKAJIIQggAyAOQdAAaiIJEPMtIgw2AiAgAyAOQdgAaiINNgJ4IAwgDRC4CEUNAiAJEPUtDQMgCCAHIAcgCEsbIQwgDkEIaiETAkACfwJAAkAgCRD0LUEATgRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDPJyAKIA82AhQgCiAINgIQIApCBDcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEIYtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAnRqIA0gCWsQ3AogAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQlQsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqQQAgDEGA1c0AELMVIANBMGogEyADKAIkIAMoAigQ3AogAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgDTYCeCAMIA0QuAhFDQcgA0EwaiINIAkQwy0gA0EYaiANENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDHGyAJQQFGDQogAygCFCEJIAMoAhAhEyADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogDyADKAIkIAggEyAJIAMoAgggAygCDBDuDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACANEO8mCyADQSBqEOk7DAsLIAggCSANahD0NCAGIA02AgQgBkEINgIAIA4gDigCSCANazYCSAwKCyADQTBqIAoQlQsgAygCNCEJIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgCDYCAAwKCyAGIA4gCSAHQQAQwhQMCQsgCSADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSANQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA4gDigCSCAIazYCSCADQTBqEO8mIANBIGoQ6TsLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIREgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgGEEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIgYgAiADahCGLSAGIAMgByACIAQgBRD9CQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAu1FgIXfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhVBACABKAK4AkGBgICAeEcbIRYgAUHgAmpBACABKALgAkGAgICAeEcbIRcgAUGgAmohDyMAQTBrIgQkAAJAAkACQCACIhBFDQAgAUGgAWohDSABQdAAaiEYIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDcAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiAQIBFrIQMgASkDAEIEUg0BIAIgAyACIANJGyIOIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAXRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgFyADIAIQjBAgBCgCICEHIAQoAhwhDiAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIA42AgQgBSAGNgIADAYLIAcgDnJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIA5NDQIgAS0ATCABQQA6AEwgDmohDgsgAiEHAkAgGCkDAEIFUQ0AIBZFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGCAWIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCANKQMAQgZ9IhpCAVgEQCAap0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDSgCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEIIAMoAjBBAUYNAiADKAI4IglB8NXNAEEi/AoAACAGQSI2AgwgBiAJNgIIIAYgCDYCBCAGQQA2AgAMCwsgDSgCSCEIIAMgDUHQAGoiCRDzLSIMNgIgIAMgDUHYAGoiCjYCeCAMIAoQuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA1BCGohEgJAIA8gCRDTEyIIBEACQCAIKAIIIgkgDGoiCiAJTQRAIAggCjYCCAwBCyAIIAwQix8gCCgCCCEKCyAJIApLDQYgA0EwaiASIAgoAgQgCUEDdGogCiAJaxDbCiADKAI0IQogAygCMCIMQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAo2AgQgBiAMNgIADAwLIANBMGogDxCYCyADKAI0IRkgAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIBk2AgQgBiAINgIADAwLIANBIGogDEGA1c0AELYVIANBMGogEiADKAIkIAMoAigQ2wogAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgCjYCeCAMIAoQuAhFDQcgA0EwaiIKIAkQwy0gA0EYaiAKENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDFGyAJQQFGDQogAygCFCEJIAMoAhAhEiADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogGSADKAIkIAggEiAJIAMoAgggAygCDBDyDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACAKEO8mCyADQSBqEOM8DAsLIAkgCmoiCSAIKAIITQRAIAggCTYCCAsgBiAKNgIEIAZBCDYCACANIA0oAkggCms2AkgMCgsgA0EwaiAPEJgLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgCkHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCEQIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBVBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzAcMAQsgD0EEaiEGAkAgAiADaiINIA8oAgwiDk0EQCAPIA02AgwMAQsgBiANIA5rEIsfCyAGIAMgByACIAQgBRDICQsLIAAgEDYCBCAAQQg2AgAgASABKAL0AiAQajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAvGGAIZfwF+IwBBIGsiDCQAAkACQAJAAkACQCABKQMAQgVSBEAgDEEIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDkAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEIIAMoAjBBAUYNAiADKAI4IglB8NXNAEEi/AoAACAGQSI2AgwgBiAJNgIIIAYgCDYCBCAGQQA2AgAMCwsgDigCSCEJIAMgDkHQAGoiCBDzLSINNgIgIAMgDkHYAGoiCzYCeCANIAsQuAhFDQIgCBD1LQ0DIAkgByAHIAlLGyENIA5BCGohEwJAAn8CQAJAIAgQ9C1BgAFJBEACQCAKKAIAQYCAgIB4RwRAIAooAghBAUYNAQwECyAKKAIQIAooAhQoAghBAWtBeHFqIAgoAgAiCSAIKAIEIg8oAghBAWtBeHFqRwRAIAooAgwNBCAJIAkoAgAiFkEBajYCACAWQQBIDQMgCkEQaiIWKAIAIhcgFygCACIXQQFrNgIAIBdBAUYEQCAWELsjCyAKIA82AhQgCiAJNgIQCyAKQQRqDAQLIAgoAgAiCSAJKAIAIg9BAWo2AgAgD0EASA0BIAgoAgQhDyAKEMsnIAogDzYCFCAKIAk2AhAgCkIBNwIIIApCgICAgAg3AgAgCkEEagwDC0Hgxs0AQTtBnMfNABCfKQsAC0EACyIJBEACQCAJKAIIIgggDWoiCyAITQRAIAkgCzYCCAwBCyAJIA0QyCAgCSgCCCELCyAIIAtLDQYgA0EwaiATIAkoAgQgCGogCyAIaxCoCyADKAI0IQsgAygCMCINQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAs2AgQgBiANNgIADAwLIANBMGogChCQCyADKAI0IQ8gAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAJNgIADAwLIANBIGogDUGA1c0AEM4YIANBMGogEyADKAIkIAMoAigQqAsgAygCNCEJAkAgAygCMCINQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiANNgIADAELIAMgCBDzLSINNgIsIAMgCzYCeCANIAsQuAhFDQcgA0EwaiILIAgQwy0gA0EYaiALENw7IAMoAhwiCEUNCCADQRBqIAMoAhgiDRDHGyAIQQFGDQogAygCFCEIIAMoAhAhEyADQQhqIA1BDGoQ3DsgCSADKAIoIg1LDQkgA0H4AGogDyADKAIkIAkgEyAIIAMoAgggAygCDBCRECADKAJ4IghBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCDYCACALEO8mCyADQSBqEN47DAsLIAggC2oiCCAJKAIITQRAIAkgCDYCCAsgBiALNgIEIAZBCDYCACAOIA4oAkggC2s2AkgMCgsgA0EwaiAKEJALIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiAOIAggB0EAEMIUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAggC0Hg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAJIA1BwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAJNgIEIAZBCDYCACAOIA4oAkggCWs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAwoAhAhByAMKAIUIQIgDCgCDCERIAwoAggiA0EIRwRAIAAgDCkDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiAMQQhqQT1BAEEBQQEQoBggDCgCDCEBIAwoAghBAUYNASAMKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgDCgCEEHU/cwAEP0vAAsgASgC8AIhAyAMIBhBBEEMIARBgICAgHhGG2oQhj0gDCgCACEEIAwoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzQcMAQsgCkEEaiEGAkAgAiADaiIOIAooAgwiCE0EQCAKIA42AgwMAQsgBiAOIAhrEMggCyAGIAMgByACIAQgBRDqCQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAxBIGokAA8LIAIgBCgCIEH0js8AEP0vAAufFQIYfwh+IwBBIGsiCiQAAkACQAJAAkACQCABKQMAQgVSBEAgCkEIaiEEIAFB4AFqIhNBACABKALgAUGBgICAeEcbIRQgAUGUAmpBACABKAKUAkGAgICAeEcbIRUgAUGIAmohDCMAQTBrIgMkAAJAAkACQCACIglFDQAgAUGgAWohDSABQdAAaiEWIAEoAtgBIQYCQAJAA0ACQAJAAkAgASgC1AEiAkEAIAIgBkcbRQRAIANBGGogARDdAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKALUASICRQ0HIAEoAtgBIQYLIAIgBmshAiAJIA5rIQYgASkDAEIEUg0BIAIgBiACIAZJGyILIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyAVRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgFSAGIAIQjBAgAygCICEFIAMoAhwhCyADKAIYIgdBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAs2AgQgBCAHNgIADAYLIAUgC3JFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0A3AFBAUcNACAGIAtNDQIgAS0ATCABQQA6AEwgC2ohCwsgAiEFAkAgFikDAEIFUQ0AIBRFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogFiAUIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIgdBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAHNgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohD0EAIQcjAEEgayIGJAACQAJAIA0tACQiCEEJRwRAIAYgCDoABwJAAkAgDSgCDEUNACANQRBqIAZBB2oQ7AwhGyANKAIAIhFBDGshGCANKAIEIhcgG6dxIQggG0IZiEL/AINCgYKEiJCgwIABfiEdIAYtAAchGQNAIAggEWopAAAiHCAdhSIbQn+FIBtCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiG1BFBEADQCAZIBhBACAbeqdBA3YgCGogF3FrIhpBDGxqLQAARg0EIBtCAX0gG4MiG1BFDQALCyAcIBxCAYaDQoCBgoSIkKDAgH+DUEUNASAIIAdBCGoiB2ogF3EhCAwACwALIAZBB2oQhSkACwJAIAwoAggiCCAFaiIHIAhNBEAgDCAHNgIIDAELIAwgBRCEHyAMKAIIIQcLIAcgCEkNASAGQQhqIBEgGkEMbGoiEUEIaygCACAMKAIEIAhBAnRqIAcgCGsgEUEEaygCACgCEBEFACAGKAIMIQcCQCAGKAIIIhFBCEcEQCAPIAYpAxA3AwggD0EQaiAGQRhqKQMANwMADAELIAcgCGoiCCAMKAIISw0AIAwgCDYCCAsgDyARNgIAIA8gBzYCBCAGQSBqJAAMAgtB5K3OAEEeQYSuzgAQyyQACyAIIAdBpK7OABCvOwALIAMoAhwhBiADKAIYIgdBCEcEQCAEIAMpAyA3AwggBEEQaiADQShqKQMANwMAIAQgBjYCBCAEIAc2AgAMBQsgAyAGNgIEIAUgBkYEQCABIAEoAtgBIAJqIgY2AtgBIAUgEGohECACIBJqIRIgCyAOaiIOIAlJDQEMBAsLIANBAjYCHCADQeSRzwA2AhggA0ICNwIkIANBOzYCFCADQTs2AgwgAyADQQhqNgIgIAMgA0EEajYCECADIAM2AgggBEEEaiADQRhqEJkOIARBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAQgEjYCDCAEIBA2AgggBCAONgIEIARBCDYCAAsgA0EwaiQADAALIAooAhAhBSAKKAIUIQYgCigCDCEHIAooAggiAkEIRwRAIAAgCikDGDcDECAAIAY2AgwgACAFNgIIIAAgBzYCBCAAIAI2AgAMBQsgBSAGTw0DIBMoAgAiCUGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgCpAIhAiAKIBNBBEEMIAlBgICAgHhGG2oQhj0gCigCACEEIAooAgQhCyMAQfAAayIDJAACQCACIAZqIgkgDCgCCCIITQRAIAwgCTYCCAwBCyAMIAkgCGsQhB8LIAMgBCALEOAcIANCADcDaCADIAI2AmAgAyACIAVqIgU2AmQCQAJAAkACQCACIAVPDQAgBUECdEEEayELIAMoAlghDyADKQMgIR0gAygCVCEIIAMoAlAhDSADKQNAIRsgAykDMCEeIAMoAhAhECADKQMIIRwgAygCKCESIAMoAhghEyADKQNIISAgAykDOCEhIAMpAwAhHwNAIB+nQQFxRSEEAkADQAJAAkACQCAERQRAIBxQRQ0BQgAhHEIAIR9BASEEDAQLAn4CQCAeQgJ9IiJCAVgEQCAip0EBaw0BDAULIB6nIB5QrUIBhiEeQQFxRQ0AICEMAQsgG0IDUQRAQgMhGwwECyANRSAIIA1GckUEQCAIQQhrIggpAwAMAQtBACENIBtCAlEEQEICIRsMBAsgG6dCACEbQQFxRQ0DICALIRxCASEfIA9BQGoiDyEQDAELIBAgHHmnQT9zIglqIQRCASAJrYYgHIUhHAwDC0EAIQQMAQsLIBMgHUIAUnFFDQIgEiAdeadBP3MiCWohBEIBIAmthiAdhSEdCyAEIAVBAWsiCU0NASAJIAwoAggiDk8NAiAEIA5PDQMgDCgCBCIFIARBAnRqIAUgC2oqAgA4AgAgC0EEayELIAkiBSACSw0ACwsgA0HwAGokAAwCCyAFQQFrIA5BsJrPABDDIQALIAQgDkHAms8AEMMhAAsLIAAgBzYCBCAAQQg2AgAgASABKAKoAiAHajYCqAIgASABKAKkAiAGajYCpAILIApBIGokAA8LIAIgAygCIEH0js8AEP0vAAvvFwIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDSAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8gCRD0LRoCQAJAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMAwsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQMgCCAIKAIAIhZBAWo2AgAgFkEASA0CIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwDCyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNACAJKAIEIQ8gChDPJyAKIA82AhQgCiAINgIQIApCBDcCCCAKQoCAgIAINwIAIApBBGoMAgsAC0EACyIIBEAgCCAIKAIIIgkgDGoQlS0gCCgCCCINIAlJDQYgA0EwaiATIAgoAgQgCUECdGogDSAJaxC7CyADKAI0IQ0gAygCMCIMQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA02AgQgBiAMNgIADAwLIANBMGogChCVCyADKAI0IQ8gAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAINgIADAwLIANBIGogDEGA1c0AEL8VIANBMGogEyADKAIkIAMoAigQuwsgAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgDTYCeCAMIA0QuAhFDQcgA0EwaiINIAkQwy0gA0EYaiANENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDHGyAJQQFGDQogAygCFCEJIAMoAhAhEyADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogDyADKAIkIAggEyAJIAMoAgggAygCDBDuDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACANEO8mCyADQSBqEOk7DAsLIAggCSANahD0NCAGIA02AgQgBkEINgIAIA4gDigCSCANazYCSAwKCyADQTBqIAoQlQsgAygCNCEJIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgCDYCAAwKCyAGIA4gCSAHQQAQwhQMCQsgCSADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSANQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA4gDigCSCAIazYCSCADQTBqEO8mIANBIGoQ6TsLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIREgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgGEEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIgYgAiADahCVLSAGIAMgByACIAQgBRD/CQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAuFGAIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDYAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8CQAJAIAkQ9C1BAE4EQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAggCCgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMBAsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQEgCSgCBCEPIAoQ0CcgCiAPNgIUIAogCDYCECAKQgQ3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIggEQCAIIAgoAggiCSAMahCGLSAIKAIIIg0gCUkNBiADQTBqIBMgCCgCBCAJQQJ0aiANIAlrENwKIAMoAjQhDSADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDTYCBCAGIAw2AgAMDAsgA0EwaiAKEJELIAMoAjQhDyADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAg2AgAMDAsgA0EgakEAIAxBgNXNABCzFSADQTBqIBMgAygCJCADKAIoENwKIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ7w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDpOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJELIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEOk7CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQhi0gBiADIAcgAiAEIAUQ/QkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALgRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ4gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDLJyAKIA82AhQgCiAINgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEI4tIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlqIA0gCWsQxwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQmwsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABDOGCADQTBqIBMgAygCJCADKAIoEMcLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxxsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQyRAgAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDeOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJsLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMIUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzQcMAQsgCkEEaiIGIAIgA2oQji0gBiADIAcgAiAEIAUQqgoLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALhRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ5QIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYCAAkkEQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAggCCgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMBAsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQEgCSgCBCEPIAoQzScgCiAPNgIUIAogCDYCECAKQgI3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIggEQCAIIAgoAggiCSAMahCFLSAIKAIIIg0gCUkNBiADQTBqIBMgCCgCBCAJQQF0aiANIAlrELwLIAMoAjQhDSADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDTYCBCAGIAw2AgAMDAsgA0EwaiAKEJQLIAMoAjQhDyADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAg2AgAMDAsgA0EgaiAMQYDVzQAQmRUgA0EwaiATIAMoAiQgAygCKBC8CyADKAI0IQgCQCADKAIwIgxBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAw2AgAMAQsgAyAJEPMtIgw2AiwgAyANNgJ4IAwgDRC4CEUNByADQTBqIg0gCRDDLSADQRhqIA0Q3DsgAygCHCIJRQ0IIANBEGogAygCGCIMEMcbIAlBAUYNCiADKAIUIQkgAygCECETIANBCGogDEEMahDcOyAIIAMoAigiDEsNCSADQfgAaiAPIAMoAiQgCCATIAkgAygCCCADKAIMEPEPIAMoAngiCUEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAJNgIAIA0Q7yYLIANBIGoQnTwMCwsgCCAJIA1qEPQ0IAYgDTYCBCAGQQg2AgAgDiAOKAJIIA1rNgJIDAoLIANBMGogChCUCyADKAI0IQkgAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiAINgIADAoLIAYgDiAJIAdBABDCFAwJCyAJIAMoAjhB/LvNABD9LwALIANBADYCMCADQSBqIANB+ABqIANBMGpB8NTNABCjKwALIAZCCDcDAAwGCyAJIA1B4NXNABCvOwALIANBADYCMCADQSxqIANB+ABqIANBMGpBkNXNABCjKwALQQBBAEGg1c0AEMMhAAsgCCAMQcDVzQAQsDsAC0EBQQFBsNXNABDDIQALIAYgCDYCBCAGQQg2AgAgDiAOKAJIIAhrNgJIIANBMGoQ7yYgA0EgahCdPAsgA0GQAWokACAEKAIcIQMgBCgCGCIGQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAGNgIADAULIAQgAzYCBCADIAdGBEAgASABKAKYAiACaiIDNgKYAiAHIBRqIRQgAiAVaiEVIBAgEmoiEiARSQ0BDAQLCyAEQQI2AhwgBEHkkc8ANgIYIARCAjcCJCAEQTs2AhQgBEE7NgIMIAQgBEEIajYCICAEIARBBGo2AhAgBCAENgIIIAVBBGogBEEYahCZDiAFQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAFIBU2AgwgBSAUNgIIIAUgEjYCBCAFQQg2AgALIARBMGokAAwACyALKAIQIQcgCygCFCECIAsoAgwhESALKAIIIgNBCEcEQCAAIAspAxg3AxAgACACNgIMIAAgBzYCCCAAIBE2AgQgACADNgIADAULIAIgB00NAyAYKAIAIgRBgYCAgHhHDQIgC0EIakE9QQBBAUEBEKAYIAsoAgwhASALKAIIQQFGDQEgCygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAsoAhBB1P3MABD9LwALIAEoAvACIQMgCyAYQQRBDCAEQYCAgIB4RhtqEIY9IAsoAgAhBCALKAIEIQUCQCAKKAIAQYCAgIB4RwRAIAogAyAHIAIgBCAFEM0HDAELIApBBGoiBiACIANqEIUtIAYgAyAHIAIgBCAFEPwJCwsgACARNgIEIABBCDYCACABIAEoAvQCIBFqNgL0AiABIAEoAvACIAJqNgLwAgsgC0EgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC7UWAhd/AX4jAEEgayILJAACQAJAAkACQAJAIAEpAwBCBVIEQCALQQhqIQUgAUG4AmoiFUEAIAEoArgCQYGAgIB4RxshFiABQeACakEAIAEoAuACQYCAgIB4RxshFyABQaACaiEPIwBBMGsiBCQAAkACQAJAIAIiEEUNACABQaABaiENIAFB0ABqIRggASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABENICIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBAgEWshAyABKQMAQgRSDQEgAiADIAIgA0kbIg4hAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBdFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAXIAMgAhCMECAEKAIgIQcgBCgCHCEOIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgDjYCBCAFIAY2AgAMBgsgByAOckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgDk0NAiABLQBMIAFBADoATCAOaiEOCyACIQcCQCAYKQMAQgVRDQAgFkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAYIBYgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA0pAwBCBn0iGkIBWARAIBqnQQFGBEBB1NTNAEELQeDUzQAQyyQACyANKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQggAygCMEEBRg0CIAMoAjgiCUHw1c0AQSL8CgAAIAZBIjYCDCAGIAk2AgggBiAINgIEIAZBADYCAAwLCyANKAJIIQggAyANQdAAaiIJEPMtIgw2AiAgAyANQdgAaiIKNgJ4IAwgChC4CEUNAiAJEPUtDQMgCCAHIAcgCEsbIQwgDUEIaiESAkAgDyAJENQTIggEQAJAIAgoAggiCSAMaiIKIAlNBEAgCCAKNgIIDAELIAggDBCLHyAIKAIIIQoLIAkgCksNBiADQTBqIBIgCCgCBCAJQQN0aiAKIAlrENsKIAMoAjQhCiADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCjYCBCAGIAw2AgAMDAsgA0EwaiAPEJMLIAMoAjQhGSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgGTYCBCAGIAg2AgAMDAsgA0EgaiAMQYDVzQAQthUgA0EwaiASIAMoAiQgAygCKBDbCiADKAI0IQgCQCADKAIwIgxBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAw2AgAMAQsgAyAJEPMtIgw2AiwgAyAKNgJ4IAwgChC4CEUNByADQTBqIgogCRDDLSADQRhqIAoQ3DsgAygCHCIJRQ0IIANBEGogAygCGCIMEMcbIAlBAUYNCiADKAIUIQkgAygCECESIANBCGogDEEMahDcOyAIIAMoAigiDEsNCSADQfgAaiAZIAMoAiQgCCASIAkgAygCCCADKAIMEPAPIAMoAngiCUEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAJNgIAIAoQ7yYLIANBIGoQ4zwMCwsgCSAKaiIJIAgoAghNBEAgCCAJNgIICyAGIAo2AgQgBkEINgIAIA0gDSgCSCAKazYCSAwKCyADQTBqIA8QkwsgAygCNCEIIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCTYCAAwKCyAGIA0gCCAHQQAQwhQMCQsgCCADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSAKQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA0gDSgCSCAIazYCSCADQTBqEO8mIANBIGoQ4zwLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByATaiETIAIgFGohFCAOIBFqIhEgEEkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAUNgIMIAUgEzYCCCAFIBE2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIRAgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACAQNgIEIAAgAzYCAAwFCyACIAdNDQMgFSgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgFUEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgDygCAEGAgICAeEcEQCAPIAMgByACIAQgBRDNBwwBCyAPQQRqIQYCQCACIANqIg0gDygCDCIOTQRAIA8gDTYCDAwBCyAGIA0gDmsQix8LIAYgAyAHIAIgBCAFEMgJCwsgACAQNgIEIABBCDYCACABIAEoAvQCIBBqNgL0AiABIAEoAvACIAJqNgLwAgsgC0EgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC5sDAgJ/An4jAEHwAGsiAiQAIAAoAgQoAhAgAUEDdGopAwAhBCACIAAoAgAiAygCACkDACIFNwMoIAIgBDcDIAJAAkACQAJAAkAgBVBFBEAgBEKAgICAgICAgIB/UiAFQn9Scg0CIAJBAjYCTCACQZiQ/wA2AkggAkICNwJUIAJBhgw2AmwgAkGGDDYCZCACIAJB4ABqNgJQIAIgAkEoajYCaCACIAJBIGo2AmAgAkE4aiACQcgAahCZDiACQRRqIAJBPGopAgA3AgAgAkEcaiACQcQAaigCADYCACACQYiAgIB4NgI0IAIgAikCNDcCDAwBCyACQYeAgIB4NgIMCyACQQE2AgggAkEIakEEchCIEQwBCyAEIAV/IgQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB8ABqJAAPCyAAIANBiIv/ABDDIQAL1AIBBn8gACgCECIFQQFqIgZBA3YgBkEHcUEAR2oiAiAAKAIMIgNLBEAgAiADayEEIAAoAgQiByACSQRAIAAgB0EBdCIDIAIQzSoiByADIAdLGxDoGSAAKAIMIQMLIAQEQCAAKAIIIANqQQAgBPwLAAsgACACNgIMCyAAIAY2AhAgAQRAIAAoAgggBUEDdmoiASABLQAAQQEgBUEHcXRyOgAACyAAKAIUBEAgACgCJCIDQQFqIgVBA3YgBUEHcUEAR2oiASAAKAIgIgJLBEAgASACayEGIAAoAhgiBCABSQRAIABBFGogBEEBdCICIAEQzSoiBCACIARLGxDoGSAAKAIgIQILIAYEQCAAKAIcIAJqQQAgBvwLAAsgACABNgIgCyAAIAU2AiQgACgCHCADQQN2aiIAIAAtAABBASADQQdxdHI6AAAPCyAAIAAoAihBAWo2AigL1wIBBX9BEkEAIABBsLgETxsiAiACQQlyIgEgAEELdCICIAFBAnRBrJGKAWooAgBBC3RJGyIBIAFBBWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAmoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBQQJ0QayRigFqKAIAQQt0IgQgAkYgAiAES2ogAWoiBEECdEGskYoBaiIFKAIAQRV2IQJBiQchAQJAIARBI00EQCAFKAIEQRV2IQEgBEUNAQsgBUEEaygCAEH///8AcSEDCwJAIAEgAkF/c2pFDQAgACADayEDIAFBAWshAUEAIQADQCAAIAJBxMWJAWotAABqIgAgA0sNASABIAJBAWoiAkcNAAsLIAJBAXELiwMBA38jAEEQayIDJAAgACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqEJcVCyAAKALEASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHEAWoQ+CMLIAMgAEH4AGoiASAAKAKEARD4GCABEOk7IABBqAFqEIYwIABBtAFqEI4wAkAgACkDAEIEUQ0AIAAoAmQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB5ABqEJcVCwJAIAAoAmgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHoAGoQ2x4LIAAQ/RsgAEHYAGoQni8gACgCbCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQewAahCBLAsCQAJAAkBBASAAKAKIASIBQf////8HaiABQYCAgIB4TRtBAWsOAgABAgsgAEGIAWoQ9x8MAQsgACgCjAEhASAAKAKQASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAkUNACABIAIgACgCCBD4OgsgA0EQaiQAC8wCAQl/IAIgAUEEdEEQayIEaiEHIAAgBGohBiAAIAFBAXYiCkEEdGoiBEEQayEFIAMoAgAhAwNAIAIgACAEIAQgACADKAIAKAIAEQIAIghBAE4iCxsiCSkAADcAACACQQhqIAlBCGopAAA3AAAgByAGIAUgBiAFIAMoAgAoAgARAgAiCUEAThsiDCkAADcAACAHQQhqIAxBCGopAAA3AAAgACALQQR0aiEAIAQgCEEbdkEQcWohBCAFIAlBH3UiCEEEdGohBSAGIAhBf3NBBHRqIQYgB0EQayEHIAJBEGohAiAKQQFrIgoNAAsgBUEQaiEDIAFBAXEEfyACIAAgBCAAIANJIgEbIgUpAAA3AAAgAkEIaiAFQQhqKQAANwAAIAQgACADT0EEdGohBCAAIAFBBHRqBSAACyADRyAEIAZBEGpHckUEQA8LEOQrAAuVBAIHfwJ+IwBBEGsiByQAAkACQAJAIAQgAyAEaiICTQRAIAIgACgCBCIFSw0BIAAoAgAgA0EEdGohAyABKAIMIgIgBEEEdCIFaiIIIAEoAgQiBksEQCABIAZBAXQiAiAIENwqIgYgAiAGSxsQ6BkgASgCBCEGIAEoAgwhAgsgAyAFaiEJIABBCGohCCAERSACQRBqIAZLcg0CIAVBEGshBCAIKAIAIQogASgCCCELA0AgCiADKQMIIgynaq0gDEKAgICAcIOEIAwgAykDACIMp0ENTxshDSADQRBqIQMgAiALaiIAIAw3AAAgACANNwAIIAJBEGohACACQSBqIAZLDQQgBCAEQRBrIQQgACECDQALDAMLIAMgAkGUkYcBELE7AAsgAiAFQZSRhwEQsDsACyACIQALIAEgADYCDCAHIAg2AgwgByAJNgIIIAcgAzYCBCAHQQRqIgIoAgAiACACKAIEIgNHBEAgAyAAa0EEdiEDIAIoAggoAgAhAgNAIAIgACkDCCIMp2qtIAxCgICAgHCDhCAMIAApAwAiDKdBDU8bIQ0gASgCDCIEQRBqIgUgASgCBCIGSwR/IAEgBkEBdCIEIAUQ2yoiBSAEIAVLGxDoGSABKAIMBSAECyABKAIIaiIEIA03AAggBCAMNwAAIAEgASgCDEEQajYCDCAAQRBqIQAgA0EBayIDDQALCyAHQRBqJAAL0QIBBH8CQAJAIAIgASgCFCIFTw0AIAJBAWohAwJAIAEoAhAiBiACQQF0ai4AACIBQQBOBEAgAUHAgAFJDQEgAUHA/wFPBEAgAyAFTw0EIAJBAmoiAiAFTw0EIAYgAkEBdGovAAAgBiADQQF0ai8AAEEQdHIhAUEDIQQMBAsgAyAFTw0CIAYgA0EBdGovAAAgAUHA/wFxQcCAAWtBwP8DcUEKdHIhAUEDIQQMAwsCQCABQf//AXEiAUGAgAFJDQACQCABQf//AUYEQCADIAVJDQEMBQsgAyAFTw0DIAYgA0EBdGovAAAgAUEQdHJBgICAgARrIQEMAQsgAkECaiICIAVPDQMgBiACQQF0ai8AACAGIANBAXRqLwAAQRB0ciEBC0ECIQQMAgsgAUHA/wNxQQZ2QQFrQf//A3EhAUEDIQQMAQsLIAAgATYCBCAAIAQ2AgAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAAAz2BFIAZDAAAAT11FckUEQCAAKAIIIAFBAnRqIAaoNgIADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAAA32BFIAZDAAAAX11FckUEQCAAKAIIIAFBA3RqIAauNwMADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAX11FckUEQCAAKAIIIAFBA3RqIAavNwMADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4QICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAR11FckUEQCAAKAIIIAFBAXRqIAb8ATsBAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC+ACAgR/AX0jAEEQayIFJAACQAJAAn8gACgCBCgCECABQQF0ai8BACIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSECIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IQMgA0GAgID8B3IgAkUNARogAyACQQ10ckGAgID+B3IMAQsgBEEQdCEEIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAEciADDQAaIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAEQYCAgNgDciACQRd0a3ILviIGQwAAgL9eRSAGQwAAgE9dRXJFBEAgACgCCCABQQJ0aiAGqTYCAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC/0CAgR+A38jAEEwayIGJABCgICAgICAgICAfyEDAkACQCAGQRBqAn4CQAJAIAAoAgQoAhAgAUEDdGopAwAiBEKAgICAgICAgIB/UiAAKAIAIggoAgAiBygCACkDACICQn9SckUEQEIAIQIMAQsgAlANAyAEIAQgAn8iAyACfn1CACACQn9SGyECIARCAFkNAQsgAyACIAcoAggpAwBXrX0MAQsgAyACIAcoAgQpAwBZrXwLIgIgAkI/hxCyLgJAIAYpAxAiAiAGKQMYIgMgBikDICIEIAYpAygiBSAIKAIELQAAENwdBEAgACgCCCABQQV0aiIAIAU3AxggACAENwMQIAAgAzcDCCAAIAI3AwAMAQsgACgCECIHIAcoAgBBAWo2AgAgBkEIaiAAKAIUEIY9IAFBA3YiACAGKAIMIgdPDQIgBigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAZBMGokAA8LQbyP/wAQ4isACyAAIAdBiIv/ABDDIQAL4QICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAEAx15FIAZDAAAAR11FckUEQCAAKAIIIAFBAXRqIAb8ADsBAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakG43YABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQbDbgAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAv8DQIWfwR+IwBBIGsiCyQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBSACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAFNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBU0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBUkEQAJAAkAgB0EBaiIGIAUgBSAGSRsiBkEPTwRAIAZB/////wFLDQFBfyAGQQN0QQduQQFrZ3ZBAWohBgwCC0EEQQhBECAGQQhJGyAGQQRJGyEGDAELEN0nIAQoAiQhBiAEKAIgIgVBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAYQ+xQgBCgCaCEGIAQoAmQhBSAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBjYCWCAEIAU2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIGBEAgBCgCGEH/ASAG/AsACyAEKAJYIQYgBCgCVCEFIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAGNgJIIAQgBTYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhDCAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAFIAwgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAkgDGohCSAMQQhqIQwgByAFIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBXEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igw6AAAgFyAJQQhrIAVxaiAMOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBTYCTCAEIAYgBWs2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpBsN6AARDuCQtBgYCAgHghBQwBCxDdJyAEKAIMIQYgBCgCCCEFCyATIAY2AgQgEyAFNgIAIARB8ABqJAALIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQUDQAJAIAQgBWopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAGcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAZxIQ8LQQEgGiAbQgGGg1ANAhogCiAFIA9qLAAAQQBOBH8gBSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrNQIAIRogCEGQgICAeDYCGCAKEIgRIAtBCGoiAkEANgIAIAIgGjcDCCAIQUBrJABBASEDAn8gCygCCEEBRgRAIAspAxghGiALKAIMIQEgACALKQMQNwMIIAAgATYCBEEQDAELIAspAxAhGgJAIAEoAjwEQCABKAJMIghBAWoiBEEDdiAEQQdxQQBHaiICIAEoAkgiA0sEQCACIANrIQYgASgCQCIFIAJJBEAgAUE8aiAFQQF0IgMgAhDPKiIFIAMgBUsbEOgZIAEoAkghAwsgBgRAIAEoAkQgA2pBACAG/AsACyABIAI2AkgLIAEgBDYCTCABKAJEIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCzKAsgASgCNCACQQN0aiAaNwMAIAEgAkEBajYCOEEAIQNBCAsgAGogGjcDACAAIAM2AgAgC0EgaiQAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHw2YABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejggAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAv8DQIWfwR+IwBBIGsiCyQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBSACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAFNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBU0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBUkEQAJAAkAgB0EBaiIGIAUgBSAGSRsiBkEPTwRAIAZB/////wFLDQFBfyAGQQN0QQduQQFrZ3ZBAWohBgwCC0EEQQhBECAGQQhJGyAGQQRJGyEGDAELEN0nIAQoAiQhBiAEKAIgIgVBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAYQ+xQgBCgCaCEGIAQoAmQhBSAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBjYCWCAEIAU2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIGBEAgBCgCGEH/ASAG/AsACyAEKAJYIQYgBCgCVCEFIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAGNgJIIAQgBTYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhDCAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAFIAwgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAkgDGohCSAMQQhqIQwgByAFIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBXEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igw6AAAgFyAJQQhrIAVxaiAMOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBTYCTCAEIAYgBWs2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB+NiAARDuCQtBgYCAgHghBQwBCxDdJyAEKAIMIQYgBCgCCCEFCyATIAY2AgQgEyAFNgIAIARB8ABqJAALIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQUDQAJAIAQgBWopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAGcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAZxIQ8LQQEgGiAbQgGGg1ANAhogCiAFIA9qLAAAQQBOBH8gBSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrNQIAIRogCEGQgICAeDYCGCAKEIgRIAtBCGoiAkEANgIAIAIgGjcDCCAIQUBrJABBASEDAn8gCygCCEEBRgRAIAspAxghGiALKAIMIQEgACALKQMQNwMIIAAgATYCBEEQDAELIAspAxAhGgJAIAEoAjwEQCABKAJMIghBAWoiBEEDdiAEQQdxQQBHaiICIAEoAkgiA0sEQCACIANrIQYgASgCQCIFIAJJBEAgAUE8aiAFQQF0IgMgAhDPKiIFIAMgBUsbEOgZIAEoAkghAwsgBgRAIAEoAkQgA2pBACAG/AsACyABIAI2AkgLIAEgBDYCTCABKAJEIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCzKAsgASgCNCACQQN0aiAaNwMAIAEgAkEBajYCOEEAIQNBCAsgAGogGjcDACAAIAM2AgAgC0EgaiQAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGA2IABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQcjbgAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAvEBQIIfwF+IwBBEGsiCCQAAkACQAJAAkACQAJAAkADQCABKAIIIQUCQCABKAIIIgMgASgCBCIERg0AAkAgAyAESQRAIAEoAgAiByADai0AACIGQSJGIAZB3ABGciAGQSBJcg0CIAEgA0EBaiIGNgIIIAdBAWohB0EAIAQgBmtBeHEiCWshBANAIARFDQIgAyAHaiAEQQhqIQQgA0EIaiEDKQAAIgtCf4UgC0LcuPHixYuXrtwAhUKBgoSIkKDAgAF9IAtCosSIkaLEiJEihUKBgoSIkKDAgAF9IAtCoMCAgYKEiJAgfYSEg0KAgYKEiJCgwIB/gyILUA0ACyABIAt6p0EDdiADakEHazYCCAwCCyADIARBiMaIARDDIQALIAEgBiAJajYCCAJAIAEoAggiAyABKAIEIgZPDQAgASgCACEHA0AgAyAHai0AACIEQSJGIARB3ABGciAEQSBJcg0BIAEgA0EBaiIDNgIIIAMgBkcNAAsLCyABKAIIIgMgASgCBCIERg0DIAMgBE8NBCABKAIAIgQgA2oiBi0AACIHQdwARwRAIAdBIkYNAyABIANBAWo2AgggCEEQNgIEIAAgASAIQQRqEJspDAgLIAMgBUkNASACIAQgBWogBhC/JiABIANBAWo2AgggAUEBIAIQwQoiA0UNAAsgAEECNgIAIAAgAzYCBAwGCyAFIANByMaIARCxOwALIAIoAggEQCADIAVJDQMgAiAEIAVqIAYQvyYgASADQQFqNgIIIABBATYCACAAIAIpAgQ3AgQMBQsgAyAFSQ0DIABBADYCACAAIAMgBWs2AgggASADQQFqNgIIIAAgBCAFajYCBAwECyAIQQQ2AgQgACABIAhBBGoQmykMAwsgAyAEQZjGiAEQwyEACyAFIANBqMaIARCxOwALIAUgA0G4xogBELE7AAsgCEEQaiQAC+YEAQR/IwBBIGsiBSQAAkACQCACQX9HBEACQCACQQFqIgZBAEgNAEEBIQMgBkEBEK02IgRFDQAgAgRAIAQgASAC/AoAAAsCQCACQQdNBEAgAkUNBCABLQAARQRAQQAhAwwCCyACQQFGDQQgAS0AAUUNAUECIQMgAkECRg0EIAEtAAJFDQFBAyEDIAJBA0YNBCABLQADRQ0BQQQhAyACQQRGDQQgAS0ABEUNAUEFIQMgAkEFRg0EIAEtAAVFDQFBBiEDIAJBBkYNBCABLQAGRQ0BDAQLIAVBCGpBACABIAIQnRIgBSgCCEEBcUUNAyAFKAIMIQMLIAAgAzYCDCAAIAI2AgggACAENgIEIAAgBjYCAAwDCyADIAZB2MGJARD9LwALQejBiQEQsjsACyAFIAI2AhwgBSAENgIYIAUgBjYCFEEAIQQjAEEgayIDJAAgBUEUaiIBKAIAIgYgASgCCCICRgRAAkAgAkEBaiIGQQBOBH8gAyACBH8gAyACNgIcIAMgASgCBDYCFEEBBUEACzYCGCADQQhqIAYgA0EUahCiGyADKAIIQQFHDQEgAygCECEEIAMoAgwFQQALIARB+MGJARD9LwALIAMoAgwhBCABIAY2AgAgASAENgIECyABIAJBAWoiBDYCCCABKAIEIgEgAmpBADoAAAJAIAQgBk8EQCABIQIMAQsgBEUEQEEBIQIgASAGQQEQ+DoMAQsgASAGQQEgBBCXNSICDQBBASAEEKM9AAsgBSAENgIEIAUgAjYCACADQSBqJAAgACAFKQMANwIEIABBgICAgHg2AgALIAVBIGokAAuaAgEFfwJAIAFBD3ECfwJAAkAgAC0AKAR/IAEgACgCGCICTyACQYAgTXINAUHAAAVB/AcLIAFBDnZqIgMgACgCBCICTw0DIAAoAgAiBCADQQF0ai8AACABQQl2QR9xaiIFIAJPDQMgAUEEdiIDQR9xIQEgBCAFQQF0ai4AACIGQf//A3EhBSAGQQBOBEAgAiABIAVqIgJNDQQgBCACQQF0ai8AAAwDCyACIAVB//8BcSADQRhxIAFBA3ZyaiIBTQ0DIAIgA0EHcSICIAFqQQFqIgNLDQEMAwtB7P3FAEHdAEHM/sUAEJ8pAAsgBCADQQF0ai8AACAEIAFBAXRqLwAAIAJBAXRBAmp0QYCADHFyC2oPCyAAKAIQQQFrC5oCAQV/AkAgAUEPcQJ/AkACQCAALQAsBH8gASAAKAIcIgJPIAJBgCBNcg0BQcAABUH8BwsgAUEOdmoiAyAAKAIIIgJPDQMgACgCBCIEIANBAXRqLwAAIAFBCXZBH3FqIgUgAk8NAyABQQR2IgNBH3EhASAEIAVBAXRqLgAAIgZB//8DcSEFIAZBAE4EQCACIAEgBWoiAk0NBCAEIAJBAXRqLwAADAMLIAIgBUH//wFxIANBGHEgAUEDdnJqIgFNDQMgAiADQQdxIgIgAWpBAWoiA0sNAQwDC0HgrMwAQd0AQcCtzAAQnykACyAEIANBAXRqLwAAIAQgAUEBdGovAAAgAkEBdEECanRBgIAMcXILag8LIAAoAhRBAWsL5QIBBX8jAEEQayIFJAAgAEEEIAAoAjQiAyADQQRNGzYCNCAAQTBqIQYgAkECdCEDAkBBACAAKAIwIgdrQQNxIgQgACgCCCAHa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAYgBBCNNwJAAkAgA0EEaiIEIAAoAgggACgCMGsiB00NACAEQYCAgIB4Sw0BIAQgB00NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBiADEI03IAAoAjAhBCAFQQhqIAAQ3DsgBSAFKAIIIAUoAgwgACgCMCIGIAYgA2tByLb+ABDXJiAFKAIEQQJ2IgMgAiACIANLGyIGBEAgBSgCACEDA0AgAyAEIAEoAgBrNgAAIAFBBGohASADQQRqIQMgBEEEayEEIAZBAWsiBg0ACwsgACACEKkRIAVBEGokAA8LQdi2/gBBJUGAt/4AEJ8pAAvyAgIHfwJ+IAEpAggiCUIgiKciBEEEaiEHIAEoAgQhAyABKAIcIQUgASgCECECIAmnIQYgASgCAEEBcSEIAkACQAJAA0AgAgRAIAUEQCABKAIYIgMgASgCFCIESw0FIABCATcDACABIAVBAWs2AhwgASADQQhqNgIYIAAgAiADaikAADcDCA8LIAFBADYCEAsgAyECAkAgCEUNACABQQA2AgQgAkUNACAEIAZLDQIgASAHNgIYIAEgBjYCFCABIAI2AhAgASACIARqKAAAIgU2AhxBACEDDAELCwJ+AkAgASgCICIDBEAgASgCLCIERQ0BIAEoAigiAiABKAIkIgVLDQQgASAEQQFrNgIsIAEgAkEIajYCKCACIANqKQAAIQlCAQwCCyAAQgA3AwAPCyABQQA2AiBCAAshCiAAIAk3AwggACAKNwMADwsgBCAGQdDt/gAQrzsACyACIAVB0O3+ABCvOwALIAMgBEHQ7f4AEK87AAvyAgIGfwR+IwBBMGsiAyQAQYCAgIB4IQQCQAJAIANBEGoCfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNAyAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qC6wiCCAIQj+HELIuAkAgAykDECIIIAMpAxgiCSADKQMgIgogAykDKCILIAcoAgQtAAAQ3B0EQCAAKAIIIAFBBXRqIgAgCzcDGCAAIAo3AxAgACAJNwMIIAAgCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EwaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAvuAgEGfyMAQbABayICJAAgASgCACEEIAJBoAFqIAFBFGopAgA3AgAgAkGYAWogAUEMaikCADcCACACIAEpAgQ3ApABIAEoAiAhBSABKAIcIQEgBBDTOiEDIAQQ0zoaIAJBEGogAyABaxDEGyACIAU2AqwBIAIgATYCqAEgAiAENgKMASACKAKQASEDAkAgASAFRwRAA0AgAkEQagJ/AkAgAwRAIAEgAigCoAFPDQUgAigClAEgASACKAKcAWoiBkEDdmotAABB/wFzIAZBB3F2QQFxDQELIAIgAUEBajYCqAEgAkEIaiAEIAEQjywgAigCDCEHIAIoAggMAQsgAiABQQFqNgKoAUEACyAHELoBIAUgAUEBaiIBRw0ACwsCQCADRQ0AIAMgAygCACIBQQFrNgIAIAFBAUcNACACQZABahD7HgsgACACQRBqIgAQ3AwgABDpJSACQbABaiQADwtBrOyAAUEgQczsgAEQnykAC+4CAQZ/IwBBsAFrIgIkACABKAIAIQQgAkGgAWogAUEUaikCADcCACACQZgBaiABQQxqKQIANwIAIAIgASkCBDcCkAEgASgCICEFIAEoAhwhASAEENQ6IQMgBBDUOhogAkEQaiADIAFrEMQbIAIgBTYCrAEgAiABNgKoASACIAQ2AowBIAIoApABIQMCQCABIAVHBEADQCACQRBqAn8CQCADBEAgASACKAKgAU8NBSACKAKUASABIAIoApwBaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENAQsgAiABQQFqNgKoASACQQhqIAQgARDaKyACKAIMIQcgAigCCAwBCyACIAFBAWo2AqgBQQALIAcQugEgBSABQQFqIgFHDQALCwJAIANFDQAgAyADKAIAIgFBAWs2AgAgAUEBRw0AIAJBkAFqEPseCyAAIAJBEGoiABDcDCAAEOklIAJBsAFqJAAPC0Gs7IABQSBBzOyAARCfKQAL4gQCDH8CfiMAQTBrIgMkAAJAIAEoAgAiAiABKAIEIgdHBEAgASgCDCEGIAEoAgghBANAIAEgAkEEaiIFNgIAAkACQCACKAIARQRAIAYgBBDyJiABIARBAWo2AggNAQwCCyABIARBAWo2AggMAQsgA0EYaiICIAEoAhAgBBCJLRDsICADKQMgIQ8gAykDGCEOIAJBBEEAQQhBEBCgGCADKAIcIQUgAygCGEEBRwRAIAMoAiAiBCAOIA98NwMIIAQgDjcDACADQRRqIgpBATYCACADIAQ2AhAgAyAFNgIMIANBKGogAUEQaigCADYCACADQSBqIAFBCGopAgA3AwAgAyABKQIANwMYIANBDGohBiMAQRBrIggkAAJAIAIiASgCACIFIAEoAgQiCUYNACABKAIQIQsgASgCDCEMIAEoAgghBANAIAQhAgNAIAEgBUEEaiIHNgIAAkACQCAFKAIARQRAIAwgAhDyJiABIAJBAWoiBDYCCA0BDAILIAEgAkEBajYCCAwBCyAIIAsgAhCJLRDsICAIKQMAIg4gCCkDCHwhDyAGKAIIIgIgBigCAEYEQCAGIAJBAUEIQRAQ0CgLIAYoAgQgAkEEdGoiByAPNwMIIAcgDjcDACAGIAJBAWo2AgggBUEEaiIFIAlHDQIMAwsgAkEBaiECIAciBSAJRw0ACwsLIAhBEGokACAAQQhqIAooAgA2AgAgACADKQIMNwIADAQLIAUgAygCIEGI+sIAEP0vAAsgBEEBaiEEIAUiAiAHRw0ACwsgAEEANgIIIABCgICAgIABNwIACyADQTBqJAALvRICEX8EfiMAQYAGayIRJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIwBBEGsiByQAIAEiAiABQQF2aiIEBEADQAJAAn8gAiAEQQFrIgRNBEAgBCACawwBCyAAIARBBHRqIgFBCGoiAykDACEXIAApAwAhGCAAIAEpAwA3AwAgAEEIaiIFKQMAIRYgBSAXNwMAIAMgFjcDACABIBg3AwBBAAsiA0EBdCIFQQFyIgEgAiAEIAIgBEkbIgZPDQADQCAFQQJqIgUgBkkEQCABIAAgAUEEdGopAwAgACAFQQR0aikDAFRqIQELIAAgA0EEdGoiAykDACAAIAFBBHRqIgUpAwBaDQEgAyAFQQQQ+iogASEDIAFBAXQiBUEBciIBIAZJDQALCyAEDQALCyAHQRBqJAAMAwsgACABQQN2IgdB8ABsaiEFIAAgB0EGdGohBgJ/IAFBwABPBEAgACAGIAUgByAEEJsaDAELIAAgBSAGIAApAwAiFyAGKQMAIhhUIgYgGCAFKQMAIhZUcxsgBiAWIBdWcxsLIABrIgZBBHYhBQJ/AkAgAkUNACACKQMAIAAgBmopAwBUDQAjAEEgayILJAACQCABRQRAQQAhAgwBCwJAIAEgBU0NACAAIAVBBHRqIgJBCGoiBSkDACEXIAApAwAhGCAAIAIpAwA3AwAgAEEIaiIIKQMAIRYgCCAXNwMAIAUgFjcDACACIBg3AwACfyAAQRBqIQZBACEHQQAgAUEBayINRQ0AGiAAKQMAIRcgBikDCCEZIAYpAwAhGCAGIgVBEGoiAiAFIA1BBHRqIg1BEGsiDEkEQCAFIQIDQCAGIAdBBHRqIgVBCGoiCSkDACEWIAIgBSkDADcDACACQQhqIBY3AwAgAkEQaiIKKQMAIRYgCSACQRhqIgkpAwA3AwAgBSAWNwMAIAYgByAWIBdYaiIOQQR0aiIHQQhqIg8pAwAhFiAKIAcpAwA3AwAgCSAWNwMAIAJBIGoiBSkDACEWIA8gAkEoaikDADcDACAHIBY3AwAgDiAWIBdYaiEHIAJBMGogBSECIAxJDQALIAVBEGohAgsgAiANRwRAA0AgBiAHQQR0aiIMQQhqIgkpAwAhFiAFIAwpAwA3AwAgBUEIaiAWNwMAIAIpAwAhFiAJIAJBCGopAwA3AwAgDCAWNwMAIAcgFiAXWGohByACIgVBEGoiAiANRw0ACyACQRBrIQULIAYgB0EEdGoiAikDACEWIAVBCGogAkEIaiIGKQMANwMAIAUgFjcDACAGIBk3AwAgAiAYNwMAIAcgFyAYWmoLIgIgAU8NACAAIAJBBHRqIgVBCGoiBikDACEXIAApAwAhGCAAIAUpAwA3AwAgCCkDACEWIAggFzcDACAGIBY3AwAgBSAYNwMADAELAAsgC0EgaiQAIAJBAWohBSABIAJLBEAgASAFayEBQQAhAiAAIAVBBHRqDAILIAUgAUHU7sMAEK87AAsjAEEgayIJJAACQCABRQRAQQAhBQwBCwJAIAEgBU0NACAAIAVBBHRqIgVBCGoiBikDACEXIAApAwAhGCAAIAUpAwA3AwAgAEEIaiINKQMAIRYgDSAXNwMAIAYgFjcDACAFIBg3AwACfyAAQRBqIQdBACEIQQAgAUEBayIMRQ0AGiAAKQMAIRcgBykDCCEZIAcpAwAhGCAHIgZBEGoiBSAGIAxBBHRqIgxBEGsiC0kEQCAGIQUDQCAHIAhBBHRqIgZBCGoiCikDACEWIAUgBikDADcDACAFQQhqIBY3AwAgBUEQaiIOKQMAIRYgCiAFQRhqIgopAwA3AwAgBiAWNwMAIAcgCCAWIBdUaiIPQQR0aiIIQQhqIhApAwAhFiAOIAgpAwA3AwAgCiAWNwMAIAVBIGoiBikDACEWIBAgBUEoaikDADcDACAIIBY3AwAgDyAWIBdUaiEIIAVBMGogBiEFIAtJDQALIAVBEGohBQsgBSAMRwRAA0AgByAIQQR0aiILQQhqIgopAwAhFiAGIAspAwA3AwAgBkEIaiAWNwMAIAUpAwAhFiAKIAVBCGopAwA3AwAgCyAWNwMAIAggFiAXVGohCCAFIQYgBUEQaiIFIAxHDQALIAVBEGshBgsgByAIQQR0aiIFKQMAIRYgBkEIaiAFQQhqIgcpAwA3AwAgBiAWNwMAIAcgGTcDACAFIBg3AwAgCCAXIBhWagsiBSABTw0AIAAgBUEEdGoiBkEIaiIHKQMAIRcgACkDACEYIAAgBikDADcDACANKQMAIRYgDSAXNwMAIAcgFjcDACAGIBg3AwAMAQsACyAJQSBqJAAgACAFIAIgAyAEEMgPIAEgBUF/c2ohASAAIAVBBHRqIgJBEGoLIQAgA0EBayEDIAFBIU8NAAsLIAAhBCARIQMjAEEQayILJAAgASIGQQJPBEACQAJAIAFBEGpBME0EQCABQQF2IQkgAUEPSw0BQQQhBSADIAlBBHQiB2ohAiAAIAdqIQcgAUEHSwRAIAAgAxDsEiAHIAIQ7BIMAwsgAyAEKQMANwMAIANBCGogBEEIaikDADcDACACIAcpAwA3AwAgAkEIaiAHQQhqKQMANwMAQQEhBQwCCwALIAQgAyADIAZBBHRqIgAQpy0gBCAJQQR0IgFqIAEgA2ogAEGAAWoQpy1BCCEFCyALQgI3AgQgBUEEdCEKIAVBAWohDSALIAk2AgwgBiAJayEQIAtBCGohEkEAIQADQCAAIBAgCSASIABBAnRqKAIAIgAbIhMgBUsEQCAEIABBBHQiAGohFEEQIQcgACADaiIPIQggDSEAIAUhAQNAIAAhAiAPIAFBBHQiAWoiACABIBRqIgEpAwAiFzcDACAAQQhqIAFBCGopAwA3AwAgAEEQaykDACAXVgRAIAApAwghGCAHIQAgCCEBAn8DQCABIApqIg4gDkEQayIVKQMANwMAIA5BCGogFUEIaikDADcDACAPIAAgCkYNARogAEEQaiEAIAFBEGshASAXIA5BIGspAwBUDQALIAEgCmoLIgAgGDcDCCAAIBc3AwALIAdBEGshByAIQRBqIQggAiACIBNJIg5qIQAgAiEBIA4NAAsLQQEhAEEBcUUNAAsgC0ECNgIAIAMgBiAEEP4PCyALQRBqJAALIBFBgAZqJAAL8QICBH8BfiMAQSBrIgIkAAJAAn4CQAJAAkAgASgCECIERQRAIAJBCGoQtB4gAigCCCIFQQRGDQEgAigCDCIEQQh2IQEMAwsgASgCDCEDIAEgBEEBazYCECABIANBAWo2AgxBAiEEAkAgAy0AACIDQQ9xIgVBAWtBAkkNACACQQhqIAUQoxIgAi0ADCEEIAIoAggiBUEERg0AIAIvAA0gAkEPai0AAEEQdHIhAQwDCyADQQR2IgNBD0cNASACQQhqIAEQyxMgAigCCEUEQCACKAIQIQMMAgsgAikDECIGQiCIpyEDIAanIQQgAigCDCIFQQRGDQEgBkIIiKchASACKQMYDAMLQQFBAEHUs84AEK87AAsgACAEOgAIIAAgAzYCBCAAQQQ2AgAMAgsgAigCECEDIAIpAhQLIQYgACABOwAFIAAgBjcCDCAAIAM2AgggACAEOgAEIAAgBTYCACAAQQdqIAFBEHY6AAALIAJBIGokAAvxAgIDfwJ+IwBBQGoiAiQAIABBEGohAwJAIAAoAhAiBARAIABBHGogACgCFCAAKAIYIAQoAhARAQAgAEIANwMgIABBKGpCADcDACADQQhqIAFBCGopAgA3AgAgAyABKQIANwIADAELIAJBEGpCADcDACACQRhqQgA3AwAgAyABKQIAIgU3AwAgA0EQakIANwMAIANBGGpCADcDACACQQhqIAFBCGopAgAiBjcDACADQQhqIAY3AwAgAiAFNwMACwJAIAMoAgAEQCACQSBqIAMQpRgCQCACKAIgQQFHDQAgAikDKCIFUA0AIAVCAYNQRQRAIAAgBadBAnRBeHE2AjgMAQsgACAFQgGIPgI0IAJBMGogAyAALQA8IgFBA3YgAUEHcUEAR2oQwRwgAikDMCEFIAAgAikDODcDCCAAIAU3AwAgBadFDQILIAJBQGskAA8LQZTEzgBBGEGsxM4AEMskAAtBvMTOAEEuQezEzgAQnykAC+MCAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBCwJAAkBBf0F/IAJBBGoiBSACIAVLGyICQX8gBEEEdCAEQf////8ASxsiBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC+sCAgR/AX4jAEFAaiIDJAAgASgCCCgCACEFIANBNGoiBCABKAIMKAIQIAJBA3RqKQMAEP0VAkACQAJAAkACQCADKAI0IgZFDQAgAyADKQI4NwIgIANBGGogA0EkaigCADYCACADIAY2AhwgAyADKQIcNwMQIAQgBSgCABCWNiADKAI0DQAgBCADQRxqIAMoAjgQ+BEgAygCNEUNBCADQTBqIANBPGooAgA2AgAgAyADKQI0NwMoIAMgA0EoahCZGiADKAIAQQFxDQELIANBKkEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkGIk/8AQSr8CgAAIABCKjcCDCAAQYKAgIB4NgIAIAAgAa0gAq1CIIaENwIEDAELIAMpAwghByAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0FAayQADwsgASADKAIIQYSR/wAQ/S8AC0GIiv8AQSpBtIr/ABDLJAAL6wICBH8BfiMAQUBqIgMkACABKAIIKAIAIQUgA0E0aiIEIAEoAgwoAhAgAkEDdGopAwAQ/RcCQAJAAkACQAJAIAMoAjQiBkUNACADIAMpAjg3AiAgA0EYaiADQSRqKAIANgIAIAMgBjYCHCADIAMpAhw3AxAgBCAFKAIAEJY2IAMoAjQNACAEIANBHGogAygCOBD4ESADKAI0RQ0EIANBMGogA0E8aigCADYCACADIAMpAjQ3AyggAyADQShqEMQnIAMoAgBBAXENAQsgA0EqQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQIgAygCCCICQYiT/wBBKvwKAAAgAEIqNwIMIABBgoCAgHg2AgAgACABrSACrUIghoQ3AgQMAQsgAykDCCEHIABBk4CAgHg2AgAgASgCACACQQN0aiAHNwMACyADQUBrJAAPCyABIAMoAghBhJH/ABD9LwALQYiK/wBBKkG0iv8AEMskAAvrAgIEfwF+IwBBQGoiAyQAIAEoAggoAgAhBSADQTRqIgQgASgCDCgCECACQQN0aikDABDWFQJAAkACQAJAAkAgAygCNCIGRQ0AIAMgAykCODcCICADQRhqIANBJGooAgA2AgAgAyAGNgIcIAMgAykCHDcDECAEIAUoAgAQljYgAygCNA0AIAQgA0EcaiADKAI4EPgRIAMoAjRFDQQgA0EwaiADQTxqKAIANgIAIAMgAykCNDcDKCADIANBKGoQ4BkgAygCAEEBcQ0BCyADQSpBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBiJP/AEEq/AoAACAAQio3AgwgAEGCgICAeDYCACAAIAGtIAKtQiCGhDcCBAwBCyADKQMIIQcgAEGTgICAeDYCACABKAIAIAJBA3RqIAc3AwALIANBQGskAA8LIAEgAygCCEGEkf8AEP0vAAtBiIr/AEEqQbSK/wAQyyQAC+sCAgR/AX4jAEFAaiIDJAAgASgCCCgCACEFIANBNGoiBCABKAIMKAIQIAJBA3RqKQMAEIEVAkACQAJAAkACQCADKAI0IgZFDQAgAyADKQI4NwIgIANBGGogA0EkaigCADYCACADIAY2AhwgAyADKQIcNwMQIAQgBSgCABCWNiADKAI0DQAgBCADQRxqIAMoAjgQ+BEgAygCNEUNBCADQTBqIANBPGooAgA2AgAgAyADKQI0NwMoIAMgA0EoahCZJCADKAIAQQFxDQELIANBKkEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkGIk/8AQSr8CgAAIABCKjcCDCAAQYKAgIB4NgIAIAAgAa0gAq1CIIaENwIEDAELIAMpAwghByAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0FAayQADwsgASADKAIIQYSR/wAQ/S8AC0GIiv8AQSpBtIr/ABDLJAAL3gICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAQ11FckUEQCAAKAIIIAFqIAb8AToAAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC94CAgR/AX0jAEEQayIFJAACQAJAAn8gACgCBCgCECABQQF0ai8BACIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSECIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IQMgA0GAgID8B3IgAkUNARogAyACQQ10ckGAgID+B3IMAQsgBEEQdCEEIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAEciADDQAaIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAEQYCAgNgDciACQRd0a3ILviIGQwAAAcNeRSAGQwAAAENdRXJFBEAgACgCCCABaiAG/AA6AAAMAQsgACgCECICIAIoAgBBAWo2AgAgBUEIaiAAKAIUEIY9IAFBA3YiACAFKAIMIgJPDQEgBSgCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAVBEGokAA8LIAAgAkGIi/8AEMMhAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpByN6AARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC4YOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHA2YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAoQiBEgDEEMaiIDQZOAgIB4NgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5UOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHY2YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQQBOBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakH424ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQbjXgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB//8BTQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI7AQQgCEFAayQAIAwvARAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpARI3AQYgAEEMaiAMQRhqKQEANwEAIAAgAzsBBCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQrSgLIAEoAjQgAkEBdGogAzsBACAAIAM7AQQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB6NqAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wNNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGI3YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlQ4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQcDfgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJBAE4EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQZjYgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB//8DTQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI7AQQgCEFAayQAIAwvARAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpARI3AQYgAEEMaiAMQRhqKQEANwEAIAAgAzsBBCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQrSgLIAEoAjQgAkEBdGogAzsBACAAIAM7AQQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB+N6AARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wNNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC4YOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHg2IABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAoQiBEgDEEMaiIDQZOAgIB4NgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5UOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGQ34ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQQBOBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGA4YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//A00EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlQ4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQajcgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJBAE4EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALhg4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejdgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggChCIESAMQQxqIgNBk4CAgHg2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALhg4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQZDZgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggChCIESAMQQxqIgNBk4CAgHg2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALxwIBCn8CQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBnLeDAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB0kNAEEADwsgACABQQJ0aiEIIAYgBSgCJBEEACEEQQEhAUEBIQMDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIARqIQRBASEJIANBAXFBACEBQQAhA0UNASAGIAUgCyAKIAcRCgAhAwwBCwsgA0F/cyACIARNcQvHAgEKfwJAAkAgAQRAIAAoAgAiAygCPCADKAJAIgUoAghBAWtBeHFqQQhqIgYgBSgCHBEEAC0AACIEQQJrIgNB/wFxQSVPQv+P0IbgAyADrYinQQFxRXINASADQf8BcUECdEHYuoMBaigCACEHDAILQQBBAEHYs4MBEMMhAAtBzhYhByAEQQ1rQf8BcUEHSQ0AQQAPCyAAIAFBAnRqIQggBiAFKAIkEQQAIQRBASEBQQEhAwNAAkACfyAJBEAgACIBIAEgCEcNARoMAgsgASAIIABrQQJ2Tw0BIAAgAUECdGoLIgFBBGohACABKAIAIgEoAjwgASgCQCIKKAIIQQFrQXhxakEIaiILIAooAiQRBAAgBGohBEEBIQkgA0EBcUEAIQFBACEDRQ0BIAYgBSALIAogBxEKACEDDAELCyADQX9zIAIgBE1xC8cCAQp/AkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0Qey7gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdJDQBBAA8LIAAgAUECdGohCCAGIAUoAiQRBAAhBEEBIQFBASEDA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACAEaiEEQQEhCSADQQFxQQAhAUEAIQNFDQEgBiAFIAsgCiAHEQoAIQMMAQsLIANBf3MgAiAETXEL9gIBAn8jAEEwayIFJAAgBSACNgIEIAUgATYCAAJAAkAgAygCCEUEQCAFQRhqQZUBQQBBAUEBEKAYIAUoAhwhASAFKAIYQQFGDQIgBSgCICICQYzyhQFBlQH8CgAAIABBlQE2AhAgACACNgIMIAAgATYCCCAAQoCAgIDYgYCAgH83AgACQCAEKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAQQ+x4LIAMQwycgA0EEQQgQ4B4gBSgCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBRCFHQwBCyADKAIEIgYoAgAgBigCBCIGKAIIQQFrQXhxakEIaiAGKAIkEQQAIQYgBUEQaiADQQhqKAIANgIAIAUgAykCADcDCCAFQShqIARBEGopAgA3AwAgBUEgaiAEQQhqKQIANwMAIAUgBCkCADcDGCAAIAEgAiAFQQhqIAVBGGogBhDPAwsgBUEwaiQADwsgASAFKAIgQaTuhQEQ/S8AC8ICAgF/AX4jAEHwAGsiByQAIAcgAjYCDCAHIAE2AgggByAENgIUIAcgAzYCECAHIABB/wFxQQJ0IgBBjO6KAWooAgA2AhwgByAAQYDuigFqKAIANgIYAkAgBSgCAARAIAdBMGogBUEQaikCADcDACAHQShqIAVBCGopAgA3AwAgByAFKQIANwMgIAdBBDYCXCAHQfzwiQE2AlggB0IENwJkIAdCgICAgNDjAyIIIAdBEGqthDcDUCAHIAggB0EIaq2ENwNIIAcgB0Egaq1CgICAgPDjA4Q3A0AMAQsgB0EDNgJcIAdByPCJATYCWCAHQgM3AmQgB0KAgICA0OMDIgggB0EQaq2ENwNIIAcgCCAHQQhqrYQ3A0ALIAcgB0EYaq1CgICAgODjA4Q3AzggByAHQThqNgJgIAdB2ABqIAYQ7ywAC8cDAwJ+BXwCfwJAAkACfyAAvSIBQoCAgICAgIAIWQRAIAFC//////////f/AFYNA0GBeCEJIAFCIIgiAkKAgMD/A1IEQCACpwwCC0GAgMD/AyABpw0BGkQAAAAAAAAAAA8LIABEAAAAAAAAAABhBEBEAAAAAAAA8L8gACAAoqMPCyABQgBTDQFBy3chCSAARAAAAAAAAFBDor0iAUIgiKcLIQggAUL/////D4MgCEHiviVqIghB//8/cUGewZr/A2qtQiCGhL9EAAAAAAAA8L+gIgAgACAARAAAAAAAAOA/oqIiA6G9QoCAgIBwg78iBEQAACBlRxX3P6IiBSAIQRR2IAlqtyIGoCIHIAUgBiAHoaAgACAEoSADoSAAIABEAAAAAAAAAECgoyIAIAMgACAAoiIDIAOiIgAgACAARJ/GeNAJmsM/okSveI4dxXHMP6CiRAT6l5mZmdk/oKIgAyAAIAAgAEREUj7fEvHCP6JE3gPLlmRGxz+gokRZkyKUJEnSP6CiRJNVVVVVVeU/oKKgoKKgIgBEAAAgZUcV9z+iIAAgBKBEAKLvLvwF5z2ioKCgDwsgACAAoUQAAAAAAAAAAKMhAAsgAAvGAgICfwF+IwBBQGoiAiQAIAJBEGogAUEMaiIBEI0UAkACQAJAIAJBBGoCfyACLQAQQQRGBEAgAigCFAwBCyACKQMQIgRC/wGDQgRSDQEgBEIgiKcLQZTGzgAQzhggAkEoaiABKAIAIAIoAgggAigCDBCbISACLQAoQQRGBEAgAkE4aiACQQxqKAIANgIAIAIgAikCBDcDMAwCCyACIAIpAyg3AzAgAkEQaiACQTBqIgEQ0AkgAigCECACQThqIAJBDGooAgA2AgAgAiACKQIENwMwQQRGDQEgACACKQIQNwIAIABBEGogAkEgaigCADYCACAAQQhqIAJBGGopAgA3AgAgARDeOwwCCyACIAQ3AxAgACACQRBqENAJDAELIAAgAikDMDcCBCAAQQQ2AgAgAEEMaiACQThqKAIANgIACyACQUBrJAAL7QMCBn8DfiMAQUBqIgIkACACQRBqIAFBDGoiARD/EwJAAkACQCACQQRqAn8gAi0AEEEERgRAIAIoAhQMAQsgAikDECIIQv8Bg0IEUg0BIAhCIIinC0GUxs4AEM4YIAJBKGohBSACKAIIIQYgASgCACIDKAIEIgStIQgCQAJAIAIoAgwiASAEQv////8PIAMpAwgiCSAJQv////8PWhunayIHQQAgBCAHTxtNBEAgAygCACAJIAggCCAJVhunaiEEAkAgAUEBRwRAIAFFDQEgBiAEIAH8CgAADAELIAYgBC0AADoAAAsgBUEEOgAADAELIAVBqKHQACkDACIKNwIAIApC/wGDQgRSDQELIAkgAa18IQgLIAMgCDcDCCACLQAoQQRGBEAgAkE4aiACQQxqKAIANgIAIAIgAikCBDcDMAwCCyACIAIpAyg3AzAgAkEQaiACQTBqIgEQ0AkgAigCECACQThqIAJBDGooAgA2AgAgAiACKQIENwMwQQRGDQEgACACKQIQNwIAIABBEGogAkEgaigCADYCACAAQQhqIAJBGGopAgA3AgAgARDeOwwCCyACIAg3AxAgACACQRBqENAJDAELIAAgAikDMDcCBCAAQQQ2AgAgAEEMaiACQThqKAIANgIACyACQUBrJAALjQMBAn8jAEFAaiIDJAAgAyACOgAPIAMgATYCCCAAAn8CQCACQf8BcSICQQpPBEAgA0ECNgIsIANBiJCFATYCKCADQgI3AjQgA0G7BzYCHCADQbsHNgIUIANB5I+FATYCECADIANBEGo2AjAgAyADQQ9qNgIYIABBBGogA0EoahCZDgwBCyACQQJ0IgRB/I2FAWoiAigCACABSARAIANBAzYCFCADQcyPhQE2AhAgA0IDNwIcIANBnAM2AjwgAyACNgI4IANBuwc2AjQgA0GcAzYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgA0EIajYCKCAAQQRqIANBEGoQmQ4MAQtBk4CAgHggASAEQaSOhQFqIgQoAgBODQEaIANBAzYCFCADQYCPhQE2AhAgA0IDNwIcIANBnAM2AjwgAyAENgI4IANBuwc2AjQgA0GcAzYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgA0EIajYCKCAAQQRqIANBEGoQmQ4LQY2AgIB4CzYCACADQUBrJAAL+gIBBn8jAEGgAmsiAiQAIAEoAhwhAyACQeABaiABQQhqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQN2QQFrNgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQIANwLYASACQdwAaiIEIAJBuAFqIgUgAUEgahDCGQJAQQxBBBCtNiIDBEAgAyABKQIUNwIAIANBCGogAUEcaigCADYCACACQQE2ApwCIAIgAzYCmAIgAkEBNgKUAiAFIAQgAkGUAmoQlilBxABBBBCtNiIDRQ0BIAMgASgCDCIGIAEoAhAiBygCCEEBa0F4cWpBCGogBygCFBEAACACQQE2AmQgAiADNgJgIAJBATYCXCACIAUgBBD8IiAAIAIQzRwgBiAGKAIAIgBBAWs2AgAgAEEBRgRAIAFBDGoQuyMLIAJBoAJqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAv6AgEGfyMAQaACayICJAAgASgCHCEDIAJB4AFqIAFBCGooAgA2AgAgAkEAOwGQAiACQQA2AowCIAJBADYC9AEgAkEANgLoASACIANBAnZBAWs2AuQBIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACIAEpAgA3AtgBIAJB3ABqIgQgAkG4AWoiBSABQSBqEMIZAkBBDEEEEK02IgMEQCADIAEpAhQ3AgAgA0EIaiABQRxqKAIANgIAIAJBATYCnAIgAiADNgKYAiACQQE2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABKAIMIgYgASgCECIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCAGIAYoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBDBCjPQALQQRBxAAQoz0AC/ICAQF/AkAgAgRAIAEtAABBME0NASAFQQI7AQACQAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf//A3EiA0sNASAFQQA7AQwgBSACNgIIIAUgAyACazYCECAEDQJBAiEBDAULIAUgAjYCICAFIAE2AhwgBUECOwEYIAVBADsBDCAFQQI2AgggBUHF64kBNgIEIAVBACAGayIDNgIQQQMhASACIARPDQQgBCACayICIANNDQQgAiAGaiEEDAMLIAVBAjsBGCAFQQE2AhQgBUHE64kBNgIQIAVBAjsBDCAFIAM2AgggBSACIANrIgI2AiAgBSABIANqNgIcIAIgBEkNAUEDIQEMAwsgBUEBNgIgIAVBxOuJATYCHCAFQQI7ARgMAQsgBCACayEECyAFIAQ2AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQcDoiQFBIUHQ6okBEJ8pAAtB4OqJAUEfQYDriQEQnykAC9sCAQN/IwBBMGsiCCQAAkACQCADRQ0AIANBAnQhCgJAA0ACQCAFIAIoAgAiCUEBaiIDSwRAIAUgCUsNASAJIAVBgMrQABDDIQALIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBAnRqKAIAIgMgBCAJQQJ0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQnxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkEEaiECIApBBGsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvbAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQJ0IQoCQANAAkAgBSACKAIAIglBAWoiA0sEQCAFIAlLDQEgCSAFQYDK0AAQwyEACyAIQQE2AhwgCEHQytAANgIYIAhCATcCJCAIQTs2AhBBACEDIAggBUEBayIBQQAgASAFTRs2AhQgCCAIQQxqNgIgIAggCEEUajYCDCAAQQRqIAhBGGoQmQ4MBAsgBCADQQN0aigCACIDIAQgCUEDdGooAgAiCU8EQCADIAdLDQIgCEEYaiABIAYgCWogAyAJa0EAEJcUIAgoAhgiA0EIRwRAIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIADAULIAJBBGohAiAKQQRrIgpFDQMMAQsLIAkgA0GQytAAELE7AAsgAyAHQZDK0AAQsDsAC0EIIQMLIAAgAzYCACAIQTBqJAAL2wIBA38jAEEwayIIJAACQAJAIANFDQAgA0EDdCEKAkADQAJAIAUgAigCACIJQQFqIgNLBEAgBSAJSw0BIAkgBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0ECdGooAgAiAyAEIAlBAnRqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCfFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQhqIQIgCkEIayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC9sCAQN/IwBBMGsiCCQAAkACQCADRQ0AIANBAXQhCgJAA0ACQCAFIAIuAQAiCUEBaiIDSwRAIAUgCUsNASAJIAVBgMrQABDDIQALIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBAnRqKAIAIgMgBCAJQQJ0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQnxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkECaiECIApBAmsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvbAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQN0IQoCQANAAkAgBSACKAIAIglBAWoiA0sEQCAFIAlLDQEgCSAFQYDK0AAQwyEACyAIQQE2AhwgCEHQytAANgIYIAhCATcCJCAIQTs2AhBBACEDIAggBUEBayIBQQAgASAFTRs2AhQgCCAIQQxqNgIgIAggCEEUajYCDCAAQQRqIAhBGGoQmQ4MBAsgBCADQQN0aigCACIDIAQgCUEDdGooAgAiCU8EQCADIAdLDQIgCEEYaiABIAYgCWogAyAJa0EAEJcUIAgoAhgiA0EIRwRAIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIADAULIAJBCGohAiAKQQhrIgpFDQMMAQsLIAkgA0GQytAAELE7AAsgAyAHQZDK0AAQsDsAC0EIIQMLIAAgAzYCACAIQTBqJAAL2wIBA38jAEEwayIIJAACQAJAIANFDQAgA0EBdCEKAkADQAJAIAUgAi4BACIJQQFqIgNLBEAgBSAJSw0BIAkgBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0EDdGooAgAiAyAEIAlBA3RqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCXFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQJqIQIgCkECayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC94CAQR/IwBB0ABrIgMkACADIAI3AwACQCABKAIABEAgAEEEaiABIAKnIAEoAhBrEOoUIABBCDYCAAwBCyABKAIIIQUCQAJAAkACQCABKAIMIgEOAgIBAAsDQCAEIAFBAXYiBiAEaiIEIAIgBSAEQRRsajUCAFQbIQQgASAGayIBQQFLDQALCyACIAUgBEEUbGoiATUCAFINACADQQhqIAFBEGogASgCCCABKAIMIAEoAgQoAgARBQAgAygCCA0BCyADQQE2AjQgA0HU5dAANgIwIANCATcCPCADQTw2AkwgAyADQcgAajYCOCADIAM2AkggA0EYakEEciADQTBqEJkOIANBADYCGCAAIAMpAxg3AwAgAEEIaiADQSBqKQMANwMAIABBEGogA0EoaikDADcDAAwBCyAAIAMpAgg3AgQgAEEINgIAIABBDGogA0EQaikCADcCAAsgA0HQAGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB4NuAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKkZCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQfDcgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5MOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGI4IABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf8ATQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI6AAQgCEFAayQAIAwtABAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpABE3AAUgAEEMaiAMQRhqKQAANwAAIAAgAzoABCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQoygLIAEoAjQgAmogAzoAACAAIAM6AAQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB0NqAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AE0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKMoCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejXgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5MOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHY34ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf8ATQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI6AAQgCEFAayQAIAwtABAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpABE3AAUgAEEMaiAMQRhqKQAANwAAIAAgAzoABCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQoygLIAEoAjQgAmogAzoAACAAIAM6AAQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpBuOCAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AE0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKMoCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQYDbgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC9cCAQZ/IwBBgARrIgUkACAFQQxqIAEgASACQQN0akHIy4MBEMEbIAVBGGoiAiAFKAIQIgEgASAFKAIUQcQAbGpByMuDARDAGyAFQSRqIAJBACAEEMAsIAMgBEEDdGohCCADKAIAIQZBASEEIAMoAgQiByEBA0ACQAJAIARFBEAgAyAIRw0BDAILIAQgCCADa0EDdk8NASADIARBA3RqIQMLIAFBAWohASADQQhqIQkgAygCBCECQQAhBCAGIAMoAgAiCkYEQCAJIQMgASACRg0CCyAFQSRqIAYgByABENgbIAohBiACIQcgCSEDIAIhAQwBCwsgBUEkaiIDIAYgByABQQFqENgbIAVBtAJqIgIgA0HMAfwKAAAgBUHwAWoiASACEOosIAUgARCgASAAIAUpAwA3AgQgAEGTgICAeDYCACAFQQxqIgAQpCwgABD1PCAFQYAEaiQAC74CAgh/BH4gACABQQR0QRBrIgNqIQYgAiADaiEFIAAgAUEBdiIIQQR0aiIDQRBrIQQDQCACIAMgACADKQMAIgsgACkDACIMVCIJGyIHKQMANwMAIAJBCGogB0EIaikDADcDACAFIAQgBiAGKQMAIg0gBCkDACIOVCIHGyIKKQMANwMAIAVBCGogCkEIaikDADcDACAFQRBrIQUgAkEQaiECIARBcEEAIAcbaiEEIAZBcEEAIA0gDlobaiEGIAAgCyAMWkEEdGohACADIAlBBHRqIQMgCEEBayIIDQALIARBEGohBCABQQFxBH8gAiAAIAMgACAESSIBGyIFKQMANwMAIAJBCGogBUEIaikDADcDACADIAAgBE9BBHRqIQMgACABQQR0agUgAAsgBEcgAyAGQRBqR3JFBEAPCxDkKwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkEDdCIFIAEoAiggASgCNCIHa00EQCAFIANBA3QiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGUiM0AEMskAAsgBSADQZSIzQAQsDsACyAFIANBlIjNABCzOwALIAIgBCgCCEHU/cwAEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQN0IgUgASgCKCABKAI0IgdrTQRAIAUgA0EDdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHs/swALwAAOwAAIAFBEGpB5P7MACkAADcAACABQQhqQdz+zAApAAA3AAAgAUHU/swAKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB5P3MAEEgQbSIzQAQyyQACyAFIANBtIjNABCwOwALIAUgA0G0iM0AELM7AAsgAiAEKAIIQdT9zAAQ/S8AC4MDAQR/IwBBEGsiBCQAAkACQAJAIAEoAiAEQAJAIAEoAjAiBSADIAMgBUsbIgZBAnQiBSABKAIoIAEoAjQiB2tNBEAgBSADQQJ0IgNLDQMgBCABQSBqIAcgBSAHahDSECAFIAQoAggiA0cNBCAEKAIEIQMgBQRAIAIgAyAF/AoAAAsgBEEMaiADIAUgBCgCACgCEBEBACAAIAY2AgQgAEEINgIAIAEgASgCNCAFajYCNCABIAEoAjAgBms2AjAMAQsgBEEaQQBBAUEBEKAYIAQoAgQhAiAEKAIAQQFGDQQgBCgCCCIBQRhqQez+zAAvAAA7AAAgAUEQakHk/swAKQAANwAAIAFBCGpB3P7MACkAADcAACABQdT+zAApAAA3AAAgAEEaNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyAEQRBqJAAPC0Hk/cwAQSBBhIjNABDLJAALIAUgA0GEiM0AELA7AAsgBSADQYSIzQAQszsACyACIAQoAghB1P3MABD9LwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkECdCIFIAEoAiggASgCNCIHa00EQCAFIANBAnQiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGkiM0AEMskAAsgBSADQaSIzQAQsDsACyAFIANBpIjNABCzOwALIAIgBCgCCEHU/cwAEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQJ0IgUgASgCKCABKAI0IgdrTQRAIAUgA0ECdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHwqM4ALwAAOwAAIAFBEGpB6KjOACkAADcAACABQQhqQeCozgApAAA3AAAgAUHYqM4AKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB+KfOAEEgQZC0zgAQyyQACyAFIANBkLTOABCwOwALIAUgA0GQtM4AELM7AAsgAiAEKAIIQdinzgAQ/S8AC4MDAQR/IwBBEGsiBCQAAkACQAJAIAEoAiAEQAJAIAEoAjAiBSADIAMgBUsbIgZBAnQiBSABKAIoIAEoAjQiB2tNBEAgBSADQQJ0IgNLDQMgBCABQSBqIAcgBSAHahDSECAFIAQoAggiA0cNBCAEKAIEIQMgBQRAIAIgAyAF/AoAAAsgBEEMaiADIAUgBCgCACgCEBEBACAAIAY2AgQgAEEINgIAIAEgASgCNCAFajYCNCABIAEoAjAgBms2AjAMAQsgBEEaQQBBAUEBEKAYIAQoAgQhAiAEKAIAQQFGDQQgBCgCCCIBQRhqQfCozgAvAAA7AAAgAUEQakHoqM4AKQAANwAAIAFBCGpB4KjOACkAADcAACABQdiozgApAAA3AAAgAEEaNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyAEQRBqJAAPC0H4p84AQSBByLTOABDLJAALIAUgA0HItM4AELA7AAsgBSADQci0zgAQszsACyACIAQoAghB2KfOABD9LwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkEDdCIFIAEoAiggASgCNCIHa00EQCAFIANBA3QiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB8KjOAC8AADsAACABQRBqQeiozgApAAA3AAAgAUEIakHgqM4AKQAANwAAIAFB2KjOACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQfinzgBBIEHYtM4AEMskAAsgBSADQdi0zgAQsDsACyAFIANB2LTOABCzOwALIAIgBCgCCEHYp84AEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQN0IgUgASgCKCABKAI0IgdrTQRAIAUgA0EDdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHwqM4ALwAAOwAAIAFBEGpB6KjOACkAADcAACABQQhqQeCozgApAAA3AAAgAUHYqM4AKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB+KfOAEEgQbi0zgAQyyQACyAFIANBuLTOABCwOwALIAUgA0G4tM4AELM7AAsgAiAEKAIIQdinzgAQ/S8AC9oCAwN/AXwBfiMAQbARayIGJAAgBkEQakEAQYQR/AsAIAZBo+D/+wc2ApQRAn8CQCABIAJPBEAgAkUNASAEKAIAIgEgAygCAEYgBCgCBCIHIAMoAgRGcSEIIAJBBHQhAiABrSEKIAQoAgwhAQNAAkAgAEEEaigCAEH///8PcUUNACAAQQxqLwEAQf8ATQ0AAkACQCAIRQRAIAAgAxCzICIEIAFNDQFBAAwHCyAGIABBDmovAQAiBDsBDgwBCyAEIAcgCiAGQQ5qIAZBmBFqEJYYIAYvAQ4hBAsgBkEQaiAEQf8HcRC1KSAJIARBgPgDcUEKdrigIQkLIABBEGohACACQRBrIgINAAsMAQsgBkEANgKoESAGQQE2ApwRIAZBrJfSADYCmBEgBkIENwKgESAGQZgRakG0mNIAEO8sAAsgBSAJIAZBEGoQoge7oDkDAEEBCyAGQbARaiQAC7wCAQx/IAAgAUEMbEEMayIDaiEGIAIgA2ohBSAAIAFBAXYiCEEMbGoiA0EMayEEA0AgAiADIAAgAygCACIJIAAoAgAiCkkiCxsiBykCADcCACACQQhqIAdBCGooAgA2AgAgBSAEIAYgBigCACIHIAQoAgAiDEkiDRsiDikCADcCACAFQQhqIA5BCGooAgA2AgAgBUEMayEFIAJBDGohAiAEQXRBACANG2ohBCAGQXRBACAHIAxPG2ohBiAAIAkgCk9BDGxqIQAgAyALQQxsaiEDIAhBAWsiCA0ACyAEQQxqIQQgAUEBcQR/IAIgACADIAAgBEkiARsiBSkCADcCACACQQhqIAVBCGooAgA2AgAgAyAAIARPQQxsaiEDIAAgAUEMbGoFIAALIARHIAMgBkEMakdyRQRADwsQ5CsAC9QCAgR/An4jAEEgayIEJAAgBEEIaiAAKAJIIAFBDGxqENw7IARBEGogBCgCCCACakF/IAIgA2oiAyACIANLGyACayABIAIQ8AogBCkDGCEIIAQpAxAhCSAAKAJAIgEgACgCOEYEQCAAQThqQejrgAEQsSgLIAAoAjwgAUEEdGoiAiAINwMIIAIgCTcDACAAIAFBAWo2AkACQCAAKAJcBEAgACgCbCIDQQFqIgZBA3YgBkEHcUEAR2oiASAAKAJoIgJLBEAgASACayEHIAAoAmAiBSABSQRAIABB3ABqIAVBAXQiAiABENAqIgUgAiAFSxsQ6BkgACgCaCECCyAHBEAgACgCZCACakEAIAf8CwALIAAgATYCaAsgACAGNgJsIAAoAmQgA0EDdmoiACAALQAAQQEgA0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgBEEgaiQAC/wCAgR/AX4gASACIAMQrAIhCQJ/AkACQCABKAIsIgYgCSABNQIgiKciBUsEQAJAIAEoAiggBUEEdGoiASgCAEEBRgRAIAJFIAEoAgQiBUVyDQEgBSABKAIIIAIgAxCfOw0EDAMLIAQoAggoAgAhBiAEKAIEKAIAIQcgBCgCACIEKAIIIgUgBCgCAEYEQCAEQbi0gwEQmygLIAQoAgQgBUEDdGoiCCAGNgIEIAggBzYCACAEIAVBAWo2AgggASAFNgIMIAEgAzYCCCABIAI2AgQgAUEBNgIAIAFBDGoMBAsgAiAFcg0BDAILIAUgBkHIs4MBEMMhAAsgBCgCCCgCACEGIAQoAgQoAgAhByAEKAIAIgQoAggiBSAEKAIARgRAIARBuLSDARCbKAsgBCgCBCAFQQN0aiIIIAY2AgQgCCAHNgIAIAQgBUEBajYCCCABIAM2AgggASACNgIEIAEgBTYCDAsgAUEMagshASAAQZOAgIB4NgIAIAAgATYCBAvKAgEGfyABIAJBAXRqIQkgAEGA/gNxQQh2IQogAEH/AXEhDAJAAkACQAJAA0AgAUECaiELIAcgAS0AASICaiEIIAogAS0AACIBRwRAIAEgCksNBCAIIQcgCyIBIAlHDQEMBAsgByAISw0BIAQgCEkNAiADIAdqIQEDQCACRQRAIAghByALIgEgCUcNAgwFCyACQQFrIQIgAS0AACABQQFqIQEgDEcNAAsLQQAhAgwDCyAHIAhB1P6JARCxOwALIAggBEHU/okBELA7AAsgAEH//wNxIQcgBSAGaiEDQQEhAgNAIAVBAWohAAJAIAUsAAAiAUEATgRAIAAhBQwBCyAAIANHBEAgBS0AASABQf8AcUEIdHIhASAFQQJqIQUMAQtBxP6JARCyOwALIAcgAWsiB0EASA0BIAJBAXMhAiADIAVHDQALCyACQQFxC8cCAQd/IwBBIGsiBSQAAkACQAJAAkAgA0UEQAwBCyAERQ0AIAEoAkghBgNAIAYgASgCREYEQCAFQQhqIAEQ8hsgBSgCCCIGQQhHBEAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAMBgsgASgCREUNAiABKAJIIQYLIAVBCGogASADIAhrIAQgB2sQ6hMgBSgCECIKIAZqIgkgCkkNAiAJQYAISw0DIAUoAgghCSAFLQAMIQsgAiABKAJAIAZBAXRqIAoQ+CkgASALOgBMIAEgASgCSCAKaiIGNgJIIAcgCmohByAIIAlqIgggA08NASAEIAdLDQALCyAAIAc2AgggACAINgIEQQghBgwCCyAGIAlBxLDOABCxOwALIAlBgAhBxLDOABCwOwALIAAgBjYCACAFQSBqJAALhwMBAn8jAEFAaiIDJAAgAyACOgAPIAMgATcDACAAAn8CQCACQf8BcSICQRNPBEAgA0ECNgIsIANBhJSFATYCKCADQgI3AjQgA0G7BzYCHCADQbsHNgIUIANB4JOFATYCECADIANBEGo2AjAgAyADQQ9qNgIYIABBBGogA0EoahCZDgwBCyACQQN0IgRBmJCFAWoiAikDACABUwRAIANBAzYCFCADQciThQE2AhAgA0IDNwIcIANB7gY2AjwgAyACNgI4IANBuwc2AjQgA0HuBjYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgAzYCKCAAQQRqIANBEGoQmQ4MAQtBk4CAgHggASAEQbCRhQFqIgQpAwBZDQEaIANBAzYCFCADQfyShQE2AhAgA0IDNwIcIANB7gY2AjwgAyAENgI4IANBuwc2AjQgA0HuBjYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgAzYCKCAAQQRqIANBEGoQmQ4LQY2AgIB4CzYCACADQUBrJAAL7AUCDX8BfiMAQfACayIGJAAgA0EIaiIHKAIAIQ8gBCgCACEMIAYgAjYCvAIgBiABNgK4AiAGIAxBAEc6ALUCIAZBIToAtAIgBkEANgLoAiAGQQA2AtACIAZCADcCwAIgBkEANgKUAiAGQQA7AewCIAZCBDcCrAIgBkIANwKkAiAGQoCAgIDAADcCnAIgBkHIAWogBygCADYCACAGIAMpAgA3A8ABIAZB4ABqIg0gBkGUAmoiByAGQcABaiIKEPojIAUoAgghAiAFKAIEIQEgBiAFKAIANgKcAiAGIAE2ApgCIAYgATYClAIgBiABIAJBA3RqNgKgAiMAQSBrIgMkACADQRRqIAcoAgwgBygCBGtBA3ZBAEEEQcQAEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQbTmhAEQ/S8ACyADQRBqIhBBADYCACADIAMoAhw2AgwgAyABNgIIIwBBIGsiBSQAIANBCGoiASAHKAIMIAcoAgRrQQN2EP4tIAEpAgQhEyAFQQhqIAdBCGopAgA3AwAgBSAHKQIANwMAIAUgE0IgiTcCGCAFIAFBCGo2AhQgBUEUaiEIIwBB0ABrIg4kAAJAIAUoAgQiASAFKAIMIhFGBEAgCCgCBCEJDAELIAgoAgggCCgCBCIJQcQAbGohCwNAIAUgAUEIaiICNgIEIA5BDGoiEiABKAIAIAFBBGooAgAQ0yMgCyASQcQA/AoAACAIIAlBAWoiCTYCBCALQcQAaiELIAIiASARRw0ACwsgCCgCACAJNgIAIAUQshwgDkHQAGokACAFQSBqJAAgCkEIaiAQKAIANgIAIAogAykCCDcCACADQSBqJAAgBkEEaiIBIA0gChD8IiAGIA82AjACQCAMBEAgBkHoAGogBEEIaigCADYCACAGIAQpAgA3A2AgByABIA0Q+iMgBkHQAWogBxDNHAwBCyAGQdABaiAGQQRqEM0cCyAAIAZB0AFqELcEIAZB8AJqJAAL7wIBBH8jAEEQayIGJAAgBiAENgIMIAYgAzYCCAJAIAIoAghBAUYEQCACKAIUIQcgAigCDCIFRQRAQQAhBQwCCwJAIAIoAhgiCCAFTQRAIAUgCEcNAQwDCyAFIAdqLAAAQb9/Sg0CCyAHIAhBACAFQZSVxAAQozYACyACKAIYIQUgAigCFCEHCyABIAQgA2sgBWoQ2C0gASAHIAUgB2oQgSYgAUEIaiIDKAIAIQQgAUEBENgtIAEoAgQgAygCAGpBIzoAACADIARBAWo2AgAgBkEIahDuEhogASAGKAIIIAYoAgwQ3BwgAEEBNgIIIAAgBTYCDCAAQRhqIAMoAgA2AgAgACABKQIANwIQIAAgAikCNDcCNCAAQTxqIAJBPGopAgA3AgAgAEHEAGogAkHEAGotAAA6AAAgACACKAIwNgIwIAAgAikCADcCACAAIAIpAiA3AiAgACACKQIoNwIoIAAgAigCHDYCHCAGQRBqJAAL2yACDH8BfiMAQdAAayIJJAAgASgCACEMIwBBEGsiCyQAIwBBMGsiByQAIwBBEGsiBiQAIAZBCGoiCiIBQQA2AgAgBkIANwMAIwBBEGsiCCQAAkAgBigCAEUgBigCBEVzDQAgCEEIaiABKAIANgIAIAggBikCADcDAEHIHSAIENkuIgFFDQAgAUEAQcgd/AsAIAFBwAVqIAooAgA2AgAgASAGKQIANwK4BSABQQIQoB8aIAEhBQsgCEEQaiQAIAZBEGokACAFRQRAQZTw0ABBNEHI8NAAEMskAAsgCUEoaiEIIAtBCGohCiAHIAU2AhwgB0EAOgAoIAcgDDYCLCAHQRBqIQ0gB0EcaiEFAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQShqIgEtAABBAWsOEgECAwQFBgcICQoLDA0ODxAREgALQeQAIQYgASgCBAwSC0HlACEGIAEoAgQMEQtB5gAhBiABKAIEDBALQecAIQYgASgCBAwPC0HoACEGIAEoAgQMDgtB6QAhBiABKAIEDA0LQeoAIQYgASgCBAwMC0HrACEGIAEoAgQMCwtBoAEhBiABLQABDAoLQaEBIQYgASgCBAwJC0GiASEGIAEoAgQMCAtBowEhBiABKAIEDAcLQaQBIQYgASgCBAwGC0HIASEGIAEtAAEMBQtByQEhBiABLQABDAQLQcoBIQYgAS0AAQwDC0GQAyEGIAEoAgQMAgtBkQMhBiABKAIEDAELQZIDIQYgASgCBAshAQJAIAUoAgAiDCgC5BIEQEFEIQUgBkHkAGsiDkEHSyAOQQFGcg0BIAxBATYCBAsCQCAGQegHa0ERSSAGQeQAa0EISXIgBkGgAWtBBUkgBkHIAWtBA0lycg0AQVghBQJAAkAgBkGQA2sOAwECAgALIAZBCkYgBkH0A0ZyDQEMAgsgAUUNACAMKALIBQ0BCwJ/IAxBDGohBQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkHoB2sOEQECAwoLBAwNDg8QERITFBUWAAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkHkAGsOCAECAwQFBgcIAAsCQCAGQaABaw4FEBESExQACwJAIAZByAFrDgMJCgsACwJAIAZBkANrDgMkJCQACyAGQfQDRg0jQVggBkEKRw0kGkEKIAEQ2CdFDSEgBSABNgIADCILIAUCf0GAgHggAUGAgHhIDQAaQRYgAUEWSg0AGiABQQMgARsLIgE2AiwgAUEAIAFBAEobDCMLIAEEQEHlACABENgnRQ0gCyAFIAE2AgQMIAsgAQRAQeYAIAEQ2CdFDR8LIAUgATYCDAwfCyABBEBB5wAgARDYJ0UNHgsgBSABNgIIDB4LIAEEQEHoACABENgnRQ0dCyAFIAE2AhAMHQsgAQRAQekAIAEQ2CdFDRwLIAUgATYCFAwcC0HqACABENgnRQ0aIAUgATYCGAwbCyABBEBB6wAgARDYJ0UNGgsgBSABNgIcDBoLIAUgAUEARyIBNgIgIAEMGwsgBSABQQBHIgE2AiQgAQwaCyAFIAFFNgIoIAFBAEcMGQsgBSABQQBHIgE2AjAgAQwYC0HpByABENgnRQ0UIAUgATYCPAwVC0HqByABENgnRQ0TIAUgATYCQAwUCyAFIAFBAEciATYCbCABDBULQaABIAEQ2CdFDREgBSABNgJUDBILIAEEQEGhASABENgnRQ0RCyAFIAE2AlgMEQsgAQRAQaIBIAEQ2CdFDRALIAUgATYCYAwQCyABBEBBowEgARDYJ0UNDwsgBSABNgJcDA8LIAEEQEGkASABENgnRQ0OCyAFIAE2AmQMDgsgAQRAQesHIAEQ2CdFDQ0LIAUgATYCNAwNCyABBEBB7AcgARDYJ0UNDAsgBSABNgI4DAwLQe4HIAEQ2CdFDQogBSABNgJwDAsLQe8HIAEQ2CdFDQkgBSABNgJ0DAoLQfAHIAEQ2CdFDQggBSABNgJ4DAkLQfEHIAEQ2CdFDQcgBSABNgJ8DAgLQfIHIAEQ2CdFDQYgBSABNgKAAQwHC0HzByABENgnRQ0FIAUgATYChAEMBgtB9AcgARDYJ0UNBCAFIAFBAEciATYCiAEgAQwHC0H1ByABENgnRQ0DIAUgATYCmAEMBAtB9gcgARDYJ0UNAiAFIAE2ApwBDAMLIAEEQEH3ByABENgnRQ0CCyAFIAE2AqQBDAILQfgHIAEQ2CdFDQAgBSABNgKoAQwBC0FWDAILIAEMAQtBWEEAIAEbCyEFCyAFENI9IQEgDSAFNgIEIA0gAUEARzYCAAJAAkACQCAHKAIQQQFxRQ0AIAdBIGogBygCFBDiGiAHLQAgQQRGDQAgBykDICIRQv8Bg0IEUg0BCyAHQRxqKAIAIQUjAEEQayIGJABBRCEBIAUoAuQSRQRAIAUQ5SRBACEBCyAGQRBqJAAgARDSPSEFIAdBCGoiBiABNgIEIAYgBUEARzYCAAJAIAcoAghBAXFFDQAgB0EoaiAHKAIMEOIaIActAChBBEYNACAHKQMoIhFC/wGDQgRSDQELIAogBygCHDYCBCAKQQQ6AAAMAQsgCiARNwIAIAdBHGoQjjwLIAdBMGokAAJAAkAgCy0ACEEERgRAIAsoAgwhAQwBCyALKAIMIQEgCygCCCIFQf8BcUEERg0AIAhBgICAgHg2AgAgCCAFrSABrUIghoQ3AgQMAQsjAEEQayIFJAAgBUEEakGAgAJBAEEBQQEQoBggBSgCCCEGIAUoAgRBAUYEQCAGIAUoAgxB9PHNABD9LwALIAUoAgwhByAIQQA2AhQgCCABNgIQIAggBDYCDCAIQQA7ARggCEEANgIIIAggBzYCBCAIIAY2AgAgBUEQaiQACyALQRBqJAAgCSkCLCERAkAgCSgCKCIBQYCAgIB4RgRAIAkgETcDKCAAIAgQgSsMAQsgCUEYaiAJQTxqKQIANwIAIAkgCSkCNDcCECAJIBE3AgggCSABNgIEIAlBKGohCyAJQQRqIQYjAEEQayIHJAACQAJAIAMEQANAIAdBCGohBCMAQSBrIgEkACAGQRBqIQwCQANAIAEgBhDeKQJAIAEtAABBBEYNACABKQMAIhFC/wGDQgRRDQAgBCARNwIADAILIAYtABkEQCMAQRBrIgUkACAMKAIAQQEQoB8iCBDSPSEKIAUgCDYCBCAFIApBAEc2AgACQAJAIAUoAgBBAXFFDQAgBUEIaiAFKAIEEOIaIAUtAAhBBEYNACAFKQMIIhFC/wGDQgRRDQAgASARNwIADAELIAFBBDoAAAsgBUEQaiQAAkAgAS0AAEEERg0AIAEpAwAiEUL/AYNCBFENACAEIBE3AgAMAwsgBkEAOgAZCyAGQQA2AgggAUEANgIIIAEgAzYCBCABIAI2AgAgAUEANgIcIAEgBjYCGCABQRBqIQojAEEQayIIJAAgCEEIaiMAQTBrIgUkACABQRhqIg0oAgAiDygCBCEQIAUgDygCADYCGCAFIBA2AhQgBSANNgIQIAUgDSgCBDYCHCAFQSBqIg0gARDfLyAFQQhqIAwoAgAiDyAFQRRqIAVBJGpBABCSBCIQQYh/TQR/IA8QjCsFIBALEN4vIAUpAwggDRCKLSAFKAIQIAUoAhwQsyw3AwAgBUEwaiQAIAgoAgwhBQJAIAgoAghBAXEEQCAKIAUQ4hoMAQsgCkEEOgAAIAogBTYCBAsgCEEQaiQAIAZBADYCFCABKAIIIQUCQCABLQAQQQRGBEAgASgCFCEIDAELIAEpAxAiEUL/AYNCBFEEQCARQiCIpyEIDAELIAQgETcCAAwCCyAIRQRAIAZBAToAGQtBACADIAUbDQALIARBBDoAACAEIAU2AgQLIAFBIGokAAJAAkACQAJAAkAgBy0ACCIBQQRHBEACQCABQQFrDgMABAIJCyAHLQAJQSNHDQgMBAsgBygCDCIBRQRAQeDf0AAhBAwICyABIANNDQEgASADQejf0AAQrzsACyAHKAIMLQAIQSNGDQIMBgsgASACaiECIAMgAWshAwwCCyAHKAIMLQAIQSNHDQQLIAdBCGoQuS4LIAMNAAsLIAtBBDoAAAwBCyALIAQpAgA3AgALIAdBEGokAAJAIAktAChBBEYNACAJKQMoIhFC/wGDQgRRDQAgCSARNwMoIAAgCxCBKyAJQRRqEI48IAYQ3jsMAQsgCUFAayAJQRxqKAIANgIAIAlBOGogCUEUaikCADcDACAJQTBqIAlBDGopAgA3AwAgCSAJKQIENwMoIAlBIGohCyMAQdAAayIGJAAgBkEIaiEFIwBBMGsiASQAIwBBIGsiAiQAIAlBKGoiBEEQaiEMA0ACQCACQRhqIAQQ3ikCQAJAAkAgAi0AGEEERg0AIAIpAxgiEUL/AYNCBFENACABIBE3AgAMAQsCQAJAIAQtABhFBEAgBEEANgIIIAJBADYCHCACIAQ2AhgjAEEgayIDJAAgAkEYaiIHKAIAIggoAgQhCiADIAgoAgA2AhggAyAKNgIUIAMgBzYCECADIAcoAgQ2AhwgDCgCACEHIANBFGohCiMAQRBrIggkAAJAIAcoAqgCQQFGBEAgCEEIaiAHQfQSaigCADYCACAIIAcpAuwSNwMADAELIAhBCGpBADYCACAIQgA3AwALAkAgByAKIAhBAhCSBCIKQYh/Sw0AIAcoAvwBQQBKDQBBAEEDIAcoAugSIg0bIQ4gDQR/QQAFIAcoAtwBQQJ0CyAKIA5qaiEKCyAIQRBqJAAgA0EIaiAKEN4vIAMpAwghESADKAIQIAMoAhwQsywgAkEIaiARNwMAIANBIGokACACKAIMIQMgAigCCEEBcUUEQCACQQQ6ABAgAiADNgIUIARBADYCFAwDCyACQRBqIAMQ4hogAi0AECAEQQA2AhRBBEYEQCACKAIUIQMMAwsgAikDECIRQv8Bg0IEUg0BIBFCIIinIQMMAgsgAUEEOgAADAILIAEgETcCAAwBCyADRQ0BIAQoAggNASABQSVBhPLNAEEQEM0aCyACQSBqJAAMAQsgBCADRToAGAwBCwsCQCABLQAAQQRHBEAgBSABKQMANwIcIAUgBCkCADcCACAFQQhqIARBCGopAgA3AgAgBUEQaiAEQRBqKQIANwIAIAVBGGogBEEYaigCADYCAAwBCyABQRhqIARBCGopAgA3AwAgAUEoaiAEQRhqKAIANgIAIAFBIGogBEEQaikCACIRNwMAIAEgBCkCADcDECABKAIcIQIgAUEQahDeOyABIBE+AgwgASACNgIIIAVBgICAgHg2AgAgBSACNgIEIAFBDGoQjjwLIAFBMGokAAJAIAYoAghBgICAgHhHBEAgBkEsaiIBIAVBJPwKAAAgBikCSCERIAZBPGoQjjwgARDeOyALIBE3AgAMAQsgCyAGKAIMNgIEIAtBBDoAAAsgBkHQAGokACAJLQAgQQRHBEAgCSAJKQMgNwNIIAAgCUHIAGoQgSsMAQsgAEEINgIACyAJQdAAaiQAC9QCAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQAJAIAUgAiwAACIKQQFqIglLBEAgBSAKSw0BIAogBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUECdGooAgAiCSAEIApBAnRqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCfFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC9QCAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQAJAIAUgAiwAACIKQQFqIglLBEAgBSAKSw0BIAogBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUEDdGooAgAiCSAEIApBA3RqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCXFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC9ICAQV/IwBBQGoiAiQAIAAoAgAhAyACQQhqIgQgAUEDdCIFIAAoAgQoAhBqKQMAENYVAkACQAJAAkACQCACKAIIIgZFDQAgAiACKQIMNwIoIAJBIGogAkEsaigCADYCACACIAY2AiQgAiACKQIkNwMYIAQgAygCABCWNiACKAIIDQAgBCACQSRqIAIoAgwQ+BEgAigCCEUNBCACQThqIAJBEGooAgA2AgAgAiACKQIINwMwIAQgAkEwahDgGSACKAIIQQFxRQ0BIAUgACgCCGogAikDEDcDAAwCCyACQgA3AwgLIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALQYiK/wBBKkG0iv8AEMskAAvSAgEFfyMAQUBqIgIkACAAKAIAIQMgAkEIaiIEIAFBA3QiBSAAKAIEKAIQaikDABCBFQJAAkACQAJAAkAgAigCCCIGRQ0AIAIgAikCDDcCKCACQSBqIAJBLGooAgA2AgAgAiAGNgIkIAIgAikCJDcDGCAEIAMoAgAQljYgAigCCA0AIAQgAkEkaiACKAIMEPgRIAIoAghFDQQgAkE4aiACQRBqKAIANgIAIAIgAikCCDcDMCAEIAJBMGoQmSQgAigCCEEBcUUNASAFIAAoAghqIAIpAxA3AwAMAgsgAkIANwMICyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkFAayQADwsgACADQYiL/wAQwyEAC0GIiv8AQSpBtIr/ABDLJAAL0gIBBX8jAEFAaiICJAAgACgCACEDIAJBCGoiBCABQQN0IgUgACgCBCgCEGopAwAQ/RcCQAJAAkACQAJAIAIoAggiBkUNACACIAIpAgw3AiggAkEgaiACQSxqKAIANgIAIAIgBjYCJCACIAIpAiQ3AxggBCADKAIAEJY2IAIoAggNACAEIAJBJGogAigCDBD4ESACKAIIRQ0EIAJBOGogAkEQaigCADYCACACIAIpAgg3AzAgBCACQTBqEMQnIAIoAghBAXFFDQEgBSAAKAIIaiACKQMQNwMADAILIAJCADcDCAsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBQGskAA8LIAAgA0GIi/8AEMMhAAtBiIr/AEEqQbSK/wAQyyQAC9ICAQV/IwBBQGoiAiQAIAAoAgAhAyACQQhqIgQgAUEDdCIFIAAoAgQoAhBqKQMAEP0VAkACQAJAAkACQCACKAIIIgZFDQAgAiACKQIMNwIoIAJBIGogAkEsaigCADYCACACIAY2AiQgAiACKQIkNwMYIAQgAygCABCWNiACKAIIDQAgBCACQSRqIAIoAgwQ+BEgAigCCEUNBCACQThqIAJBEGooAgA2AgAgAiACKQIINwMwIAQgAkEwahCZGiACKAIIQQFxRQ0BIAUgACgCCGogAikDEDcDAAwCCyACQgA3AwgLIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALQYiK/wBBKkG0iv8AEMskAAvZAgEKfyMAQRBrIgUkAAJAIAEoAhwiAiABKAIgIghGBEAgASgCBCEDDAELIAJBf3MhByABKAIEIQMDQAJAAn8CQCADBEAgAiABKAIUTw0DIAEoAgggAiABKAIQaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENAQsgASACQQFqNgIcIAVBCGogASgCACACENorIAUoAgwhCSAFKAIIDAELIAEgAkEBajYCHEEACyEKIAAoAggiBiAAKAIARgRAIAEoAgAiBBDUOiELIAQQ1DoaIAAgByALakEBaiIEQX8gBBsQ6i0LIAAoAgQgBkEDdGoiBCAJNgIEIAQgCjYCACAAIAZBAWo2AgggB0EBayEHIAJBAWoiAiAIRw0BDAILC0G8tIABQSBB3LSAARCfKQALAkAgA0UNACADIAMoAgAiAEEBazYCACAAQQFHDQAgAUEEahD7HgsgBUEQaiQAC7gCAQR/AkAgBEUgASAETXINACADIAEgBGsiBiAEIAQgBksiCBsiB0kNACAAIARBA3RqIQMgB0EDdCIFBEAgAiADIAAgCBsgBfwKAAALIAIgBWohBQJAAkAgBCAGSwRAIAFBA3QgAGpBCGshBANAIAQgA0EIayIBIAVBCGsiAyADKAIAIgYgASgCACIHSSIFGykCADcCACADIAVBA3RqIQUgASAGIAdPQQN0aiIDIABGDQIgBEEIayEEIAIgBUcNAAsMAQsgB0UNASAAIAFBA3RqIQEDQCAAIAMgAiADKAIAIgQgAigCACIGSSIHGykCADcCACAAQQhqIQAgAiAEIAZPQQN0aiICIAVGDQIgAyAHQQN0aiIDIAFHDQALDAELIAMhAAsgBSACayIBRQ0AIAAgAiAB/AoAAAsLywIBBH8jAEEgayIFJAAgAiADIAIoAggiA2oQhS0CQAJAAkACQCABKQMAQgNSBEAgAigCCCIEIANJDQEgBUEIaiABIAIoAgQgA0EBdGogBCADaxDVGSAFKAIMIQYgBSgCCCIEQQhHBEAgACAFKQMQNwMIIABBEGogBUEYaikDADcDACAAIAY2AgQgACAENgIADAULIAIgAyAGahD0NCACKAIIIQQgAigCBCIHIQIgAwRAIANBAWsiAiAETw0DIAcgAkEBdGpBAmohAgsgAiAHIARBAXRqIgNGDQIgAyACa0EBdiEDQQAhBCABLwFAIQEDQCAEIAIvAQAgAUZqIQQgAkECaiECIANBAWsiAw0ACwwDC0GEsM4AELI7AAsgAyAEQZSwzgAQrzsAC0EAIQQLIAAgBjYCCCAAIAQ2AgQgAEEINgIACyAFQSBqJAAL9QIBBH8jAEEwayICJAACQCAALQAAIgRBEUYNACAALQABIQNBASEBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBEEBaw4QAgMEBQYAAQcICQoICAgICBALQYgSIANBA3R2IQEMDwtBihYgA0EDdHYhAQwOC0ECIQEMDQtBBCEBDAwLQQUhAQwLC0EGIQEMCgtBByEBDAkLIAAtAAIhACADQQhrIgFBBXQgAUH4AXFBA3ZyQf8BcQ4IBAUDBgMDAwcDC0EAIQEMBwtBFCEBDAYLQRUhAQwFCyACIAM6AA4gAiAAQQFxOgAPIAJBAjYCFCACQfT4zgA2AhAgAkIBNwIcIAJBkAg2AiwgAiACQShqNgIYIAIgAkEOajYCKCACQRBqQYT5zgAQ7ywAC0EQQQwgAEEBcRshAQwDC0ERQQ0gAEEBcRshAQwCC0ESQQ4gAEEBcRshAQwBC0ETQQ8gAEEBcRshAQsgAkEwaiQAIAELygIBAn8CfyAGKAIAQQAgAEEQRiINGyIGIAcoAgBHBEAgByAGNgIAQQAMAQtBACAEKAIAIgBFDQAaIABBAmtBAkEDIA0bdCEMIAALIQAgBCABIAxqQQNqIgE2AgACQAJAAkAgAiADKAIAIgQgASAAayIAaiIBTwRAIAZFBEAgAyABNgIADwsgBkEgTw0BIAsgBkECdGoiBygCACECIAAhDANAIAIgCWoiAUHQBU8NAyADIAQiAkEBaiIENgIAIAggAUEBdGogAjsBACAMQQFrIgwNAAsgByAEQQFrNgIAIAUgBSgCACAAQQ8gBmt0azYCACAGQRBPDQMgCiAGQQF0aiIBIAEvAQAgAGo7AQAPCyAFQf//PzYCACADIAI2AgAPCyAGQSBB/J/zABDDIQALIAFB0AVBjKDzABDDIQALIAZBEEGcoPMAEMMhAAuPBwEPfyMAQfAAayIEJAAgBEEgaiIFEIYgIAQgAjYCZCMAQTBrIgckACAHQQhqIAEQwzQgBygCDCEGIAcoAgghAiAHIARB5ABqIg02AiwgByAFNgIoIAcgAjYCICAHIAIgBkECdGo2AiQjAEEgayICJAAgAkEUaiAHQSBqIgYoAgQgBigCAGtBAnZBAEEEQQQQoBggAigCGCEKIAIoAhRBAUYEQCAKIAIoAhxB0Lf+ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAo2AggjAEEQayIKJAAgBigCBCAGKAIAa0ECdiIMIAJBCGoiCCgCACAIKAIIIglrSwRAIAggCSAMQQRBBBDeKCAIKAIIIQkLIAdBFGohDCAKIAgoAgQ2AgwgCiAJNgIIIAogCEEIajYCBCAKQQRqIgsoAgQhCCALKAIAIAYoAgAiCSAGKAIEIhBHBEAgBigCDCERIAYoAgghEiALKAIIIAhBAnRqIQYgCCAQIAlrQQJ2IgtqIQgDQCAGIBIgESAJKAIAQQhqEKsCNgIAIAlBBGohCSAGQQRqIQYgC0EBayILDQALCyAINgIAIApBEGokACAMQQhqIA4oAgA2AgAgDCACKQIINwIAIAJBIGokACAFIAcoAhggBygCHBDCDyEGAkAgASgCFEUEQCAFQQE6ADggBSgCMCECIAVBBiAGEPwODAELIAUgAUEIahD9CiEBIAVBAToAOCAFKAIwIQIgBUEGIAYQ/A4gBUEIIAEQ/A4LIAUgAhDYByECIAVBADYCFCAFQQA6ADggB0EUakEEQQQQ4B4gB0EwaiQAIARBAToAWCAEIAQoAlAiBzYCYCAEIAU2AlwgBEHcAGoiASADLwECEMQOIAFBARCfEiAFQQpCABDLDiABIAIQ8A4gBSAHENgHIQEgBEEANgI0IARBADoAWCAFIAEQpAwgBEEYaiAFENw7IAQoAhwhASAEKAIYIQIgBEEQaiAEKAJQEIw3IARBCGogAiABIAQoAhAgBCgCFEHkxv4AENcmIAQoAgghBSANIAQoAgwiAUEAQQFBARCgGCAEKAJoIQIgBCgCZEEBRwRAIAQoAmwhAyABBEAgAyAFIAH8CgAACyAAQQA2AhQgAEKAgICAEDcCDCAAIAE2AgggACADNgIEIAAgAjYCACAEQSBqEMwqIARB8ABqJAAPCyACIAQoAmxBqMn+ABD9LwALwAQCCH8CfiMAQYABayICJAAgAkEYaiABEPEHAkACQCACKAIYQQFGBEAgASgCHCABKAIUa0EEdkEAIAEoAhAbIAEoAgwgASgCBGtBBHZBACABKAIAG2ohBSACKQMoIQogAikDICELAn8gASgCIARAIAJB9ABqIAEoAjQgASgCMEcNARoLIAUhAyACQRRqCyADNgIAIAJB9ABqQQMgBSAFQQNNG0EBakEAQQhBEBCgGCACKAJ4IQYgAigCdEEBRg0CIAIoAnwiAyAKNwMIIAMgCzcDACACQRBqIgVBATYCACACIAM2AgwgAiAGNgIIIAJBGGoiAyABQdgA/AoAACACQQhqIQcjAEEgayIEJAAgBCADEPEHIAQoAgBBAUYEQANAIAQpAxAhCiAEKQMIIQsgBygCCCIIIAcoAgBGBEAgAygCHCADKAIUa0EEdkEAIAMoAhAbIAMoAgwgAygCBGtBBHZBACADKAIAG2ohCQJ/AkAgAygCIEUNACADKAI0IAMoAjBGDQAgBEEcaiEGQQAMAQsgBEEYaiEGIAkLIQEgBiABNgIAIAcgCCAJQQFqQQhBEBDQKAsgBygCBCAIQQR0aiIBIAo3AwggASALNwMAIAcgCEEBajYCCCAEIAMQ8QcgBCgCAA0ACwsgAxDQLSAEQSBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCAAwBCyAAQQA2AgggAEKAgICAgAE3AgAgARDQLQsgAkGAAWokAA8LIAYgAigCfEGI+sIAEP0vAAuVAwEBfyMAQUBqIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAIAAoAgAiAC8BSEEBaw4GAQIDBAUGAAsgAUG26cMAQQ0Q+zVFDQYMBwsgAUHD6cMAQRUQ+zUNBgwFCyABQdjpwwBBGBD7NQ0FDAQLIAIgAEHKAGo2AgwgAkEYNgIUIAJBiOrDAEHw6cMAIAAvAUpBkANrQf//A3FB5ABJGzYCECACQQM2AiwgAkGk6sMANgIoIAJCAjcCNCACQbECNgIkIAJBsgI2AhwgAiACQRhqNgIwIAIgAkEMajYCICACIAJBEGo2AhggASgCACABKAIEIAJBKGoQywoNBAwDCyABQbzqwwBBHhD7NQ0DDAILIAFB2urDAEEcEPs1DQIMAQsgAUH26sMAQRoQ+zUNAQtBACAAKAIAQQJGDQEaIAIgADYCECACQQI2AiwgAkGc68MANgIoIAJCATcCNCACQbMCNgIcIAIgAkEYajYCMCACIAJBEGo2AhggASgCACABKAIEIAJBKGoQywoMAQtBAQsgAkFAayQAC+gCACMAQUBqIgUkACAFIAQ6AA8CQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgIYIAVBoIzNADYCFCAFQgE3AiAgBUGuAzYCNCAFIAVBMGo2AhwgBSAFQQ9qNgIwIABBBGogBUEUahCZDiAAQQE2AgAgAigCCCEEDAELIAUgASgCYCADbCIDNgIQIAIoAggiBCADTwRAIAEoAlAiAwRAIAFB3ABqIAEoAlQgASgCWCADKAIQEQEACyAAQQg2AgAgAUHQAGoiACACKQIANwIAIABBCGogAkEIaikCADcCAAwCCyAFIAQ2AiwgBUECNgIYIAVBxJzNADYCFCAFQgI3AiAgBUE7NgI8IAVBOzYCNCAFIAVBMGo2AhwgBSAFQSxqNgI4IAUgBUEQajYCMCAAQQRqIAVBFGoQmQ4gAEEANgIACyACQQxqIAIoAgQgBCACKAIAKAIQEQEACyAFQUBrJAAL+gQBC38jAEEwayIEJAAjAEEgayIFJAAgBUEUaiACIANBBHRqIgsgAmtBBHZBAEEEQQQQoBggBSgCGCEGIAUoAhRBAUYEQCAGIAUoAhxBoIPOABD9LwALIARBDGohDCAFQRBqIg1BADYCACAFIAUoAhw2AgwgBSAGNgIIIwBBEGsiCiQAIAVBCGoiCCALIAIiBmtBBHYiBxDuLSAKIAgpAgRCIIk3AgggCiAIQQhqNgIEIApBBGoiCSgCBCEIIAkoAgAhDgJAAkAgAiALRwRAIAkoAgggCEECdGohCQNAIAYoAgBFDQIgCSAGQQhqKAIANgIAIAZBEGohBiAJQQRqIQkgCEEBaiEIIAdBAWsiBw0ACwsgDiAINgIADAELQbjj0ABBJUHg49AAEJ8pAAsgCkEQaiQAIAxBCGogDSgCADYCACAMIAUpAgg3AgAgBUEgaiQAIARBGGogASAEKAIQIAQoAhQQzxFBCCEGAkACQCAEKAIYIgdBCEcEQCAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAHIQYMAQsgA0UNACABQeAAaiEDA0AgAigCACIGRQ0CIAEgAkEIaigCACIHIAEoAmxqNgJsIARBGGogAkEMaiIFIAJBBGooAgAgByAGKAIAEQUAIAEoAmgiAiABKAJgRgRAIANBhKDOABCeKAsgASgCZCACQQR0aiIHIAQpAhg3AgBBCCEGIAdBCGogBEEgaikCADcCACABIAJBAWo2AmggBUEEaiICIAtHDQALCyAAIAY2AgAgBEEMahDpOyAEQTBqJAAPC0Gsh84AQSVB1IfOABCfKQAL0gIBBH8jAEEwayIDJAAgA0EMaiABIAIQkw4gAygCECEFAkAgAygCDCIEQYqAgIB4RwRAIAAgAykCFDcCCCAAQSBqIANBLGooAgA2AgAgAEEYaiADQSRqKQIANwIAIABBEGogA0EcaikCADcCACAAIAU2AgQgACAENgIADAELAkACQEF/QX8gAkEEaiIEIAIgBEsbIgIgBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC9gCAQV/IwBBEGsiBCQAAkACQCADIAEoAihGBEAgASACIAMQoTYCQCABKAIMBEAgASgCHCIGQQFqIgdBA3YgB0EHcUEAR2oiAiABKAIYIgNLBEAgAiADayEIIAEoAhAiBSACSQRAIAFBDGogBUEBdCIDIAIQzSoiBSADIAVLGxDoGSABKAIYIQMLIAgEQCABKAIUIANqQQAgCPwLAAsgASACNgIYCyABIAc2AhwgASgCFCAGQQN2aiIBIAEtAABBASAGQQdxdHI6AAAMAQsgASABKAIgQQFqNgIgCyAAQZOAgIB4NgIADAELIARBBGpB0ABBAEEBQQEQoBggBCgCCCEBIAQoAgRBAUYNASAEKAIMIgJB0L7/AEHQAPwKAAAgAEHQADYCDCAAIAI2AgggACABNgIEIABBjYCAgHg2AgALIARBEGokAA8LIAEgBCgCDEGMyf8AEP0vAAviAgIEfgF/AkACQAJAAkACQAJAAkACQAJAIAUgCEsEQCAHIAlNDQEgCCAKaiIPIAVPDQIgBCAPQQN0aikDACAEIAhBA3RqKQMAIg19IgtCgICAgBBaDQMgCSAKaiIEIAdPDQQgBiAEQQN0aikDACAGIAlBA3RqKQMAIg59IgxCgICAgBBaDQUgCyAMhFAEQEEBDwsgCyAMUgRAQQAPCyALpyIEIA2nIgZqIgUgBEkNBiABIAVJDQcgBCAOpyIFaiIBIARJDQggASADSw0JIAAgBmogBCACIAVqIAQQnzsPCyAIIAVB1K2HARDDIQALIAkgB0HkrYcBEMMhAAsgDyAFQfSthwEQwyEAC0GErocBELI7AAsgBCAHQZSuhwEQwyEAC0GkrocBELI7AAsgBiAFQbSthwEQsTsACyAFIAFBtK2HARCwOwALIAUgAUHErYcBELE7AAsgASADQcSthwEQsDsAC/MCAgV/A34jAEEwayIDJAACQAJAIAECfwJAAkACQAJAAkACQCABLQAYQQFrDgMEAQACCyABKAIUIQUMAgsACyADEM4iIAMoAgQhBSADKAIAIQYgASgCECIEKAIIEPQ6IQcgASkDCCEIIAEpAwAhCSAEKQMAIQpByABBCBCtNiIERQ0EIARBADoARCAEIAY2AkAgBCAINwMYIAQgCTcDECAEIAc2AgggBCAKNwMAIARB3N7CABDUGiABIAU2AhQLIANBDGogBUEIaiACEKgUIAMoAgxFDQEgAEEJNgIAQQMMAgtB7PXCABDoKwALIANBKGoiBCADQRxqKAIANgIAIAMgAykCFDcDICADKAIQIQIgAUEUahCuLCACRQ0CIAAgAykDIDcCCCAAQRBqIAQoAgA2AgAgACACNgIEIABBCDYCAEEBCzoAGCADQTBqJAAPC0EIQcgAEKM9AAtBnODCAEErIANBDGpB+ODCAEH89cIAENUeAAvqAgEGf0H9ASEEAkACQAJ/IAEoAvgHIgNB/QFNBEAgAUEEaiEGIAMMAQsgASgCCCEGIAMhBCABKAIECyIIIAJNBEACQAJAIAJB/gFPBEBBgYCAgHghBSACIARGDQUgAkECdCEHQQAhBSACQf////8DSw0FIAdBBBDRNEUNBSADQf4BSQ0CIARBAnQhAyAEQf////8DTQ0BIAMhBwwFC0GBgICAeCEFIANB/QFNDQQgAUEANgIAIAhBAnQiAgRAIAFBBGogBiAC/AoAAAsgASAINgL4ByAGIAQQoiQMBAsgA0EEENE0RQ0DQQQhBSAGIANBBCAHEJc1IgRFDQMMAgtBBCEFIAdBBBCtNiIERQ0CIAhBAnQiA0UNASAEIAYgA/wKAAAMAQtB6J3EAEEgQYiexAAQnykACyABIAI2AvgHIAEgBDYCCCABIAg2AgQgAUEBNgIAQYGAgIB4IQULIAAgBzYCBCAAIAU2AgAL5QIBBn9BOyEEAkACQAJ/IAEoAvABIgNBO00EQCABQQRqIQYgAwwBCyABKAIIIQYgAyEEIAEoAgQLIgggAk0EQAJAAkAgAkE8TwRAQYGAgIB4IQUgAiAERg0FIAJBAnQhB0EAIQUgAkH/////A0sNBSAHQQQQ0TRFDQUgA0E8SQ0CIARBAnQhAyAEQf////8DTQ0BIAMhBwwFC0GBgICAeCEFIANBO00NBCABQQA2AgAgCEECdCICBEAgAUEEaiAGIAL8CgAACyABIAg2AvABIAYgBBCiJAwECyADQQQQ0TRFDQNBBCEFIAYgA0EEIAcQlzUiBEUNAwwCC0EEIQUgB0EEEK02IgRFDQIgCEECdCIDRQ0BIAQgBiAD/AoAAAwBC0HoncQAQSBBiJ7EABCfKQALIAEgAjYC8AEgASAENgIIIAEgCDYCBCABQQE2AgBBgYCAgHghBQsgACAHNgIEIAAgBTYCAAu7AwEGf0ERIQMCQAJAAn8gASgCSCIEQRFNBEAgAUEEaiEGIAQMAQsgASgCCCEGIAQhAyABKAIECyIIIAJNBEACQAJAIAJBEk8EQEGBgICAeCEFIAIgA0YNBSACQQJ0IQdBACEFIAJB/////wNLDQUgB0EEENE0RQ0FIARBEkkNAiADQQJ0IQQgA0H/////A00NASAEIQcMBQtBgYCAgHghBSAEQRFNDQQgAUEANgIAIAhBAnQiAgRAIAFBBGogBiAC/AoAAAsgASAINgJIIwBBEGsiASQAIANBAnQhAgJAIANB/////wNNBEAgAkEEENE0DQELIAEgAjYCDCABQQA2AghBgK7MAEErIAFBCGpB8K3MAEHcrswAENUeAAsgBiACQQQQ+DogAUEQaiQADAQLIARBBBDRNEUNA0EEIQUgBiAEQQQgBxCXNSIDRQ0DDAILQQQhBSAHQQQQrTYiA0UNAiAIQQJ0IgRFDQEgAyAGIAT8CgAADAELQaywzABBIEHMsMwAEJ8pAAsgASACNgJIIAEgAzYCCCABIAg2AgQgAUEBNgIAQYGAgIB4IQULIAAgBzYCBCAAIAU2AgALxQIBA38jAEHQAGsiBSQAIAVBLGogASAEEJMOIAUoAjAhBgJAIAUoAiwiB0GKgICAeEcEQCAFQShqIAVBzABqKAIANgIAIAVBIGogBUHEAGopAgA3AgAgBUEYaiAFQTxqKQIANwIAIAUgBSkCNDcCECAFIAY2AgwgBSAHNgIIDAELIAVBLGogAUF/IAQgBmoiASABIAZJGxC0BiAFKAIwIQECQCAFKAIsIgZBioCAgHhHBEAgBUEYaiAFQTxqKAIANgIAIAVBJGogBUHIAGopAgA3AgAgBSAFKQI0NwIQIAUgBSkCQDcCHCAFIAE2AgwMAQsgASABKAIMQQFrNgIMCyAFIAY2AggLIAUgAzYCPCAFIAI2AjggBUGAgICAeDYCNCAFIAQ2AjAgBUECNgIsIAAgBUEIaiAFQSxqEIEUIAVB0ABqJAAL4QICCX8CfiMAQTBrIgIkACABKAIEIQUgASgCACEIAkACQCAAKAIAIgQgACgCBCIDRwRAIAAoAhQhByAAKAIQIQkgACgCDCEKIAAoAgghBiABKAIIIAVBBHRqIQAgAyAEa0EDdiEBA0AgAiAENgIMAkAgBCgCACIDIAlJBEAgCiADQQR0aiIDKQMIIQsgAykDACEMDAELIAYgBygCEE8NA0IAIQxCACELIAcoAgQgBiAHKAIMaiIDQQN2ai0AACADQQdxdkEBcQ0ECyAAIAw3AwAgACALNwMIIARBCGohBCAAQRBqIQAgBkEBaiEGIAVBAWohBSABQQFrIgENAAsLIAggBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC+ECAgl/An4jAEEwayICJAAgASgCBCEFIAEoAgAhCAJAAkAgACgCACIEIAAoAgQiA0cEQCAAKAIUIQcgACgCECEJIAAoAgwhCiAAKAIIIQYgASgCCCAFQQR0aiEAIAMgBGtBAnYhAQNAIAIgBDYCDAJAIAkgBCgCACIDSwRAIAogA0EEdGoiAykDCCELIAMpAwAhDAwBCyAGIAcoAhBPDQNCACEMQgAhCyAHKAIEIAYgBygCDGoiA0EDdmotAAAgA0EHcXZBAXENBAsgACAMNwMAIAAgCzcDCCAEQQRqIQQgAEEQaiEAIAZBAWohBiAFQQFqIQUgAUEBayIBDQALCyAIIAU2AgAgAkEwaiQADwtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQe0GNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAvhAgIJfwJ+IwBBMGsiAiQAIAEoAgQhBSABKAIAIQgCQAJAIAAoAgAiBCAAKAIEIgNHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEGIAEoAgggBUEEdGohACADIARrQQJ2IQEDQCACIAQ2AgwCQCAJIAQoAgAiA0sEQCAKIANBBHRqIgMpAwghCyADKQMAIQwMAQsgBiAHKAIQTw0DQgAhDEIAIQsgBygCBCAGIAcoAgxqIgNBA3ZqLQAAIANBB3F2QQFxDQQLIAAgDDcDACAAIAs3AwggBEEEaiEEIABBEGohACAGQQFqIQYgBUEBaiEFIAFBAWsiAQ0ACwsgCCAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG7EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAAL4QICCX8CfiMAQTBrIgIkACABKAIEIQUgASgCACEIAkACQCAAKAIAIgQgACgCBCIDRwRAIAAoAhQhByAAKAIQIQkgACgCDCEKIAAoAgghBiABKAIIIAVBBHRqIQAgAyAEa0EDdiEBA0AgAiAENgIMAkAgBCgCACIDIAlJBEAgCiADQQR0aiIDKQMIIQsgAykDACEMDAELIAYgBygCEE8NA0IAIQxCACELIAcoAgQgBiAHKAIMaiIDQQN2ai0AACADQQdxdkEBcQ0ECyAAIAw3AwAgACALNwMIIARBCGohBCAAQRBqIQAgBkEBaiEGIAVBAWohBSABQQFrIgENAAsLIAggBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJByBA2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC78CAgV/AX4jAEHwAGsiAiQAIAEoAgQhAyABKAIIIgUEQCADKAIEIAMoAggiBCgCCEEBa0F4cWpBCGogBCgCJBEEACEECyACIAM2AkggAiADNgJMIAIgASgCADYCUCACIAMgBUEMbGo2AlQgAkHoAGoiA0IENwIAIAJB4ABqIgVCADcCACACQoCAgIDAADcCWCACQcgAaiACQdgAaiIGIAJB5ABqEPoeIAJBQGsgAykCADcDACACQThqIAUpAgAiBzcDACACQRhqIAc+AgAgAkEoaiACQcQAaigCADYCACACIAIpAlgiBzcDMCACIAc3AxAgAiACKQI8NwMgIAJBMGoiAyABQQxqQQAgBBDyFSAGIAMQ4ScgAkEIaiACQRBqELYZIAAgAigCCCACKAIMIAJBIGogBhDLHCACQfAAaiQAC6MGAQ1/IwBBMGsiAyQAIAMgADYCAAJ/IAAtAABBIEYEQEEBIAEoAgAiCEHsyIcBQQcgASgCBCIKKAIMIgsRBgANARogACgCCCIBBEAgACgCBEEIaiEAIwBBIGsiBCQAIARBFGogACABQQJ0aiIBIABrQQJ2QQBBBEEMEKAYIAQoAhghAiAEKAIUQQFGBEAgAiAEKAIcQdzIhwEQ/S8ACyADQRhqIQkgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgAjYCCCMAQRBrIgckACABIABrQQJ2IgUgBEEIaiICKAIAIAIoAggiBmtLBEAgAiAGIAVBBEEMENwoIAIoAgghBgsgByACKAIENgIMIAcgBjYCCCAHIAJBCGo2AgQjAEFAaiICJAAgB0EEaiIFKAIEIQYgBSgCACAAIAFHBEAgBSgCCCAGQQxsaiEFIAYgASAAa0ECdiIBaiEGA0AgAiAAKAIAIg5BPGo2AiggAiAOQTBqNgIsIAJBAjYCFCACQZjchwE2AhAgAkICNwIcIAJBpwQ2AjwgAkH0GzYCNCACIAJBMGo2AhggAiACQSxqNgI4IAIgAkEoajYCMCACQQRqIAJBEGoQmQ4gBUEIaiACQQxqKAIANgIAIAUgAikCBDcCACAAQQRqIQAgBUEMaiEFIAFBAWsiAQ0ACwsgBjYCACACQUBrJAAgB0EQaiQAIAlBCGogDCgCADYCACAJIAQpAgg3AgAgBEEgaiQAIANBBGogAygCHCIAIAMoAiAiAUHzyIcBQQIQ8QMgAQRAA0AgAEEBQQEQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsgA0EYaiIAQQRBDBDgHiADQQE2AhwgA0H4yIcBNgIYIANCATcCJCADQeMcNgIUIAMgA0EQajYCICADIANBBGoiATYCECAIIAogABDLCiEAIAFBAUEBEOAeQQEgAA0CGgsgCEGAyYcBQQEgCxEGAAwBCyADQQE2AhwgA0H4yIcBNgIYIANCATcCJCADQa8DNgIIIAMgA0EEajYCICADIAM2AgQgASgCACABKAIEIANBGGoQywoLIANBMGokAAv8CAIPfwR+IwBBEGsiCyQAIAFBEGoiBiACEO4LIRQgASgCBCIEIBSncSEDIBRCGYhC/wCDQoGChIiQoMCAAX4hFSACKAIIIQggAigCBCEJIAEoAgAhBQJAAkADQAJAIAMgBWopAAAiEyAVhSISQn+FIBJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiElBFBEADQCAFIBJ6p0EDdiADaiAEcUEGdGsiB0E8aygCACAHQThrKAIAIAkgCBDkHA0CIBJCAX0gEoMiElBFDQALCyATIBNCAYaDQoCBgoSIkKDAgH+DUEUNAiADIApBCGoiCmogBHEhAwwBCwsgAEGAgICAeDYCCCAAIAE2AgQgACAHNgIAIAIQ0SsgAhDoOwwBCyABKAIIRQRAIAtBCGohCiMAQdAAayIDJAAgAyAGNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgA0FAayABQRBqIgZBwABBCCAEEJ0UIAMoAkQhBSADKAJAIgdFBEAgAygCSCEEDAULIAMpAkghEiAFQQlqIgQEQCAHQf8BIAT8CwALIAMgEkIgiD4CPCADIBKnIg02AjggAyAFNgI0IAMgBzYCMCADQsCAgICAATcCKCADIAY2AiQgA0EwaiEOIAMgCAR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhEkEAIQQDQCASUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyISQoCBgoSIkKDAgH9RDQALIBJCgIGChIiQoMCAf4UhEgsgByAFIAMoAhwgASgCACASeqdBA3YgBGoiEEEGdGtBQGoQ7gunIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhNQBEBBCCEJA0AgBiAJaiEGIAlBCGohCSAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiE1ANAAsLIAcgE3qnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiIJOgAAIA8gBkEIayAFcWogCToAACAHIAZBf3NBBnRqIAEoAgAgEEF/c0EGdGpBwAD8CgAAIBJCAX0gEoMhEiAIQQFrIggNAAsgASgCDAVBAAsiBDYCPCADIA0gBGs2AjggASAOQQQQ+iogA0EkahDQJgwBCyABIANBIGpB3KTPAEHAABDFCQtBgYCAgHghBQwCCxDjJyADKAIMIQQgAygCCCEFDAELEOMnIAMoAhQhBCADKAIQIQULIAogBDYCBCAKIAU2AgAgA0HQAGokAAsgACABNgIUIAAgFDcDACAAIAIpAgA3AgggAEEQaiACQQhqKAIANgIACyALQRBqJAALzgIBCH9BCiEDIAEiBEHoB08EQCACQQRrIQggBCEFA0AgAyAIaiIGQQFqIAUgBUGQzgBuIgRBkM4AbGsiB0H//wNxQeQAbiIJQQF0IgpB4/OJAWotAAA6AAAgBiAKQeLziQFqLQAAOgAAIAZBA2ogByAJQeQAbGtB//8DcUEBdCIHQePziQFqLQAAOgAAIAZBAmogB0Hi84kBai0AADoAACADQQRrIQMgBUH/rOIESyAEIQUNAAsLAkAgBEEJTQRAIAQhBQwBCyACIANqQQFrIAQgBEH//wNxQeQAbiIFQeQAbGtB//8DcUEBdCIEQePziQFqLQAAOgAAIAIgA0ECayIDaiAEQeLziQFqLQAAOgAAC0EAIAEgBRtFBEAgAiADQQFrIgNqIAVBAXRBHnFB4/OJAWotAAA6AAALIABBCiADazYCBCAAIAIgA2o2AgAL1gIBAX8jAEFAaiIDJAAgAyACNgIEIAMgATYCAAJAIAFBgAFrQf99TQRAIANBATYCJCADQbjqzQA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgAzYCOCADQQhqQQRyIANBIGoQmQ4gACADKQANNwAFIABBDWogA0EVaikAADcAACAAQRRqIANBHGooAAA2AAAgACADLQAMOgAEIABBAzYCAAwBCyACQYACTwRAIANBATYCJCADQeDqzQA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQQhqQQRyIANBIGoQmQ4gACADKQANNwAFIABBDWogA0EVaikAADcAACAAQRRqIANBHGooAAA2AAAgACADLQAMOgAEIABBAzYCAAwBCyAAIAE6AAYgACACOgAFIABBJToABCAAQQg2AgALIANBQGskAAvWAgEBfyMAQUBqIgMkACADIAI2AgQgAyABNgIAAkAgAUGAAWtB/31NBEAgA0EBNgIkIANBuOrNADYCICADQgE3AiwgA0GcAzYCPCADIANBOGo2AiggAyADNgI4IANBCGpBBHIgA0EgahCZDiAAIAMpAA03AAUgAEENaiADQRVqKQAANwAAIABBFGogA0EcaigAADYAACAAIAMtAAw6AAQgAEEDNgIADAELIAJBgAJPBEAgA0EBNgIkIANB4OrNADYCICADQgE3AiwgA0GcAzYCPCADIANBOGo2AiggAyADQQRqNgI4IANBCGpBBHIgA0EgahCZDiAAIAMpAA03AAUgAEENaiADQRVqKQAANwAAIABBFGogA0EcaigAADYAACAAIAMtAAw6AAQgAEEDNgIADAELIAAgAToABiAAIAI6AAUgAEEmOgAEIABBCDYCAAsgA0FAayQAC7oRAhZ/BX4jAEEgayIPJAACQCABLQCUAUUNACABKAKMASIGKAIUIgdBCGogBygCCEECRkECdGotACFBFkYNACAGQQhqIQsgD0EMaiIJIAIiByAHIANBAnRqIgRGBH9BAAUCQCAEIAdBBGoiCEYEQCAHIQYMAQsgByEGA0AgCCAGIAsgBiAIEOwVGyEGIAggByALIAggBxDsFRshByAIQQRqIgggBEcNAAsLIAkgBygCADYCCCAJIAYoAgA2AgRBAQs2AgAgDygCDEEBRw0AIA8gDygCECIGNgIYIA8gDygCFCIHNgIcAkAgASgCEEEBRgRAIAsgAUEUaiAPQRhqEOwVRQ0BCyABIAY2AhQgAUEBNgIQCyABKAIYQQFGBEAgCyAPQRxqIAFBHGoQ7BVFDQELIAEgBzYCHCABQQE2AhgLIANFIAEoAoABQYCAgIB4RnJFBEAgAUGAAWohBCADQQJ0IQYgAiEHA0AgBCAHQQQQhgoQohUgB0EEaiEHIAZBBGsiBg0ACwsCQCABKAJoQYCAgIB4RwRAIAFBIGoiBkHIAGogAxDsLSADBEAgA0ECdCEBA0AjAEEwayISJAAgEkEYaiEDIAZBEGoiBCACQQQQzQIhHCAGQTBqIQdBACENQQAhFEEAIRNBACEVQQAhFiMAQRBrIhckACAGKAIIRQRAAkAgF0EIaiEYIwBB4ABrIgUkACAFIAc2AhwgBSAENgIYIAYoAgwhBCAFIAVBGGo2AiACQAJAAkACQAJAIAQgBEEBaiIJTQRAIAYoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgCUkEQCAEQQFqIgQgCSAEIAlLGyIEQQ9JDQIgBEH/////AU0EQEF/IARBA3RBB25BAWtndkEBaiENDAQLEN0nIAUoAhQhDSAFKAIQIg5BgYCAgHhHDQUMAwsgBiAFQSBqQaykzwAQ6wkMAwsQ3ScgBSgCBCENIAUoAgAhDgwDC0EEQQhBECAEQQhJGyAEQQRJGyENCyAFQdAAaiAGQRBqIglBCCANEPsUIAUoAlghDSAFKAJUIQ4gBSgCUCIERQ0BIAUgBSgCXDYCTCAFIA02AkggBSAONgJEIAUgBDYCQCAFQQhqIAVBQGsQwTQgBSgCDCIEBEAgBSgCCEH/ASAE/AsACyAFKAJIIQ0gBSgCRCEOIAUoAkAiEEUNASAFIAUoAkw2AjwgBSANNgI4IAUgDjYCNCAFIBA2AjAgBUKIgICAgAE3AiggBSAJNgIkIAUgBigCDCIZBH8gEEEIaiEMIAYoAgAiESkDAEJ/hUKAgYKEiJCgwIB/gyEbA0AgG1AEQANAIBRBCGohFCARQQhqIhEpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRsLIAUoAiAiCCgCBCIJKAIIIgQgBigCACAbeqdBA3YgFGpBA3QiC2tBCGsoAgAiCk0NBCAQIA4gCCgCACAJKAIEIApBAnRqQQQQzQKnIglxIgpqKQAAQoCBgoSIkKDAgH+DIhpQBEBBCCEIA0AgCCAKaiEEIAhBCGohCCAQIAQgDnEiCmopAABCgIGChIiQoMCAf4MiGlANAAsLIBtCAX0gG4MhGyAQIBp6p0EDdiAKaiAOcSIKaiwAAEEATgRAIBApAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAKIBBqIAlBGXYiBDoAACAMIApBCGsgDnFqIAQ6AAAgECAKQQN0a0EIayAGKAIAIAtrQQhrKQAANwAAIBlBAWsiGQ0ACyAGKAIMBUEACyIENgI8IAUgDSAEazYCOCAGIAVBMGpBBBD6KiAFQSRqEPUnC0GBgICAeCEOCyAYIA02AgQgGCAONgIAIAVB4ABqJAAMAQsgCiAEQZSQzgAQwyEACwsgBigCBCIKIByncSERIBxCGYhC/wCDQoGChIiQoMCAAX4hHiAHKAIEIQkgBygCCCEIIAYoAgAhDANAAkAgDCARaikAACIdIB6FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEbAn8CQAJAIAMCfgJAA0AgG1ANASAIIAYoAgAgG3qnQQN2IBFqIApxIgRBA3RrQQhrKAIAIgtNDQMgG0IBfSAbgyEbIAJBBCAJIAtBAnRqQQQQnztFDQALIAMgHDcDCCADIAYoAgBBACAEa0EDdGo2AhBCAAwBCyAdQoCBgoSIkKDAgH+DIRogFUUEQCAaUA0DIBp6p0EDdiARaiAKcSETC0EBIBogHUIBhoNQDQMaIAMgDCATaiwAAEEATgR/IAwpAwBCgIGChIiQoMCAf4N6p0EDdgUgEws2AhAgAyAcNwMIQgELNwMAIAMgBjYCFCAXQRBqJAAMAwsgCyAIQZSQzgAQwyEAC0EACyEVIBEgFkEIaiIWaiAKcSERDAELCyASQQhqIQgCQCADKAIAQQFGBEAgAykDCCEaIAMoAhAhCyADKAIUIQwgByAHKAIMQQRqNgIMIAIoAgAhAyAHKAIIIgkgBygCAEYEQCAHQaSQzgAQnSgLIAcoAgQgCUECdGogAzYCACAHIAlBAWo2AgggCyAMKAIAIgRqIgMtAAAhByADIBqnQRl2IgM6AAAgBCAMKAIEIAtBCGtxakEIaiADOgAAIAggDDYCDCAIIBo3AwAgDCAMKAIMQQFqNgIMIAggBCALQQN0ayIDNgIIIAwgDCgCCCAHQQFxazYCCCADQQhrIAmtNwMADAELIAggA0EIaiIDKQMANwMAIAhBCGogA0EIaikDADcDAAsgEigCEEEIaykDACEaIBJBMGokACAGKAJQIgMgBigCSEYEQCAGQcgAakHUkM4AELMoCyAGKAJMIANBA3RqIBo3AwAgBiADQQFqNgJQIAJBBGohAiABQQRrIgENAAsLIABBCDYCAAwBCyAAIAEoAnggAiADIAEoAnwoAgwRBQALIA9BIGokAAu8EQIWfwV+IwBBMGsiDyQAAkAgAS0ApAFFDQAgASgCnAEiBigCFCIHQQhqIAcoAghBAkZBAnRqLQAhQRZGDQAgBkEIaiELIA9BCGoiCSACIgcgByADQQN0aiIERgR+QgAFAkAgBCAHQQhqIghGBEAgByEGDAELIAchBgNAIAggBiALIAYgCBDzGxshBiAIIAcgCyAIIAcQ8xsbIQcgCEEIaiIIIARHDQALCyAJIAcpAwA3AxAgCSAGKQMANwMIQgELNwMAIA8oAghBAUcNACAPIA8pAxAiHDcDICAPIA8pAxgiGjcDKAJAIAEoAgBBAUYEQCALIAFBCGogD0EgahDzG0UNAQsgASAcNwMIIAFCATcDAAsgASgCEEEBRgRAIAsgD0EoaiABQRhqEPMbRQ0BCyABIBo3AxggAUIBNwMQCyADRSABKAKQAUGAgICAeEZyRQRAIAFBkAFqIQQgA0EDdCEGIAIhBwNAIAQgB0EIEIYKEKIVIAdBCGohByAGQQhrIgYNAAsLAkAgASgCeEGAgICAeEcEQCABQTBqIgZByABqIAMQ7C0gAwRAIANBA3QhAQNAIwBBMGsiEiQAIBJBGGohAyAGQRBqIgQgAkEIEM0CIR0gBkEwaiEHQQAhDUEAIRRBACETQQAhFUEAIRYjAEEQayIXJAAgBigCCEUEQAJAIBdBCGohGCMAQeAAayIFJAAgBSAHNgIcIAUgBDYCGCAGKAIMIQQgBSAFQRhqNgIgAkACQAJAAkACQCAEIARBAWoiCU0EQCAGKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAlJBEAgBEEBaiIEIAkgBCAJSxsiBEEPSQ0CIARB/////wFNBEBBfyAEQQN0QQduQQFrZ3ZBAWohDQwECxDdJyAFKAIUIQ0gBSgCECIOQYGAgIB4Rw0FDAMLIAYgBUEgakGkpc8AEOsJDAMLEN0nIAUoAgQhDSAFKAIAIQ4MAwtBBEEIQRAgBEEISRsgBEEESRshDQsgBUHQAGogBkEQaiIJQQggDRD7FCAFKAJYIQ0gBSgCVCEOIAUoAlAiBEUNASAFIAUoAlw2AkwgBSANNgJIIAUgDjYCRCAFIAQ2AkAgBUEIaiAFQUBrEME0IAUoAgwiBARAIAUoAghB/wEgBPwLAAsgBSgCSCENIAUoAkQhDiAFKAJAIhBFDQEgBSAFKAJMNgI8IAUgDTYCOCAFIA42AjQgBSAQNgIwIAVCiICAgIABNwIoIAUgCTYCJCAFIAYoAgwiGQR/IBBBCGohDCAGKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhGwNAIBtQBEADQCAUQQhqIRQgEUEIaiIRKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEbCyAFKAIgIggoAgQiCSgCCCIEIAYoAgAgG3qnQQN2IBRqQQN0IgtrQQhrKAIAIgpNDQQgECAOIAgoAgAgCSgCBCAKQQN0akEIEM0CpyIJcSIKaikAAEKAgYKEiJCgwIB/gyIaUARAQQghCANAIAggCmohBCAIQQhqIQggECAEIA5xIgpqKQAAQoCBgoSIkKDAgH+DIhpQDQALCyAbQgF9IBuDIRsgECAaeqdBA3YgCmogDnEiCmosAABBAE4EQCAQKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCiAQaiAJQRl2IgQ6AAAgDCAKQQhrIA5xaiAEOgAAIBAgCkEDdGtBCGsgBigCACALa0EIaykAADcAACAZQQFrIhkNAAsgBigCDAVBAAsiBDYCPCAFIA0gBGs2AjggBiAFQTBqQQQQ+iogBUEkahD1JwtBgYCAgHghDgsgGCANNgIEIBggDjYCACAFQeAAaiQADAELIAogBEGUkM4AEMMhAAsLIAYoAgQiCiAdp3EhESAdQhmIQv8Ag0KBgoSIkKDAgAF+IRwgBygCBCEJIAcoAgghCCAGKAIAIQwDQAJAIAwgEWopAAAiHiAchSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGwJ/AkACQCADAn4CQANAIBtQDQEgCCAGKAIAIBt6p0EDdiARaiAKcSIEQQN0a0EIaygCACILTQ0DIBtCAX0gG4MhGyACQQggCSALQQN0akEIEJ87RQ0ACyADIB03AwggAyAGKAIAQQAgBGtBA3RqNgIQQgAMAQsgHkKAgYKEiJCgwIB/gyEaIBVFBEAgGlANAyAaeqdBA3YgEWogCnEhEwtBASAaIB5CAYaDUA0DGiADIAwgE2osAABBAE4EfyAMKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBMLNgIQIAMgHTcDCEIBCzcDACADIAY2AhQgF0EQaiQADAMLIAsgCEGUkM4AEMMhAAtBAAshFSARIBZBCGoiFmogCnEhEQwBCwsgEkEIaiEIAkAgAygCAEEBRgRAIAMpAwghHCADKAIQIQsgAygCFCEMIAcgBygCDEEIajYCDCACKQMAIRogBygCCCIJIAcoAgBGBEAgB0GkkM4AELMoCyAHKAIEIAlBA3RqIBo3AwAgByAJQQFqNgIIIAsgDCgCACIEaiIDLQAAIQcgAyAcp0EZdiIDOgAAIAQgDCgCBCALQQhrcWpBCGogAzoAACAIIAw2AgwgCCAcNwMAIAwgDCgCDEEBajYCDCAIIAQgC0EDdGsiAzYCCCAMIAwoAgggB0EBcWs2AgggA0EIayAJrTcDAAwBCyAIIANBCGoiAykDADcDACAIQQhqIANBCGopAwA3AwALIBIoAhBBCGspAwAhGiASQTBqJAAgBigCUCIDIAYoAkhGBEAgBkHIAGpB1JDOABCzKAsgBigCTCADQQN0aiAaNwMAIAYgA0EBajYCUCACQQhqIQIgAUEIayIBDQALCyAAQQg2AgAMAQsgACABKAKIASACIAMgASgCjAEoAgwRBQALIA9BMGokAAvbAgIGfwF9IwBBEGsiBCQAIAQgAUECIAJBAXMgAxtBB3RqIgEoAswDNgIEIAQgASgCjAQ2AgAgBEEANgIMIARBADYCCCABQcwDaiEHQQEhBQNAIAcgBUECdGohCCAEQQxqIQYgBEEEaiECQQEhA0EAIQEDQCAIIAFBBnRqKgIAIgogAioCAF0EQCACIAo4AgAgBiAFNgIAC0EBIQEgA0EBcSAEQQhqIQYgBCECQQAhAw0ACyAFQQFqIgVBEEcNAAsCQCAEKAIMIgFBEEkEQCAEKAIIIgJBEE8NASAAIAQoAgA2AgwgACAEKAIENgIIIAAgAkEBdCICQYjlzgBqLwEAOwEGIAAgAkHY5M4Aai8BADsBBCAAIAFBAXQiAUGI5c4Aai8BADsBAiAAIAFB2OTOAGovAQA7AQAgBEEQaiQADwsgAUEQQfjkzgAQwyEACyACQRBBqOXOABDDIQALxAIBA38jAEEwayIIJAACQAJAIANFDQAgA0EBdCEKAkADQCAFIAIvAQAiCUEBaiIDTQRAIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBA3RqKAIAIgMgBCAJQQN0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQlxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkECaiECIApBAmsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvEAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQF0IQoCQANAIAUgAi8BACIJQQFqIgNNBEAgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0ECdGooAgAiAyAEIAlBAnRqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCfFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQJqIQIgCkECayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC+8NAgh/AX4jAEGgAWsiASQAIwBBwAFrIgUkACAFQSxqIgZBgIACQeTF0AAQzhggBUEIaiAGQfTF0AAQkCEgBUIANwIkIAUgAzYCGCAFIAI2AhQgBSAFKQMINwIcIAVBOGohAyMAQfABayICJAAgAkEMaiIGEM0rIAJB+ABqIAYgBUEUaiIGEPYDAn8CQAJAIAItAHgiB0EERwRAAn8CQAJAAkAgB0EBaw4DAAECBgsgAi0AeQwCCyACKAJ8LQAIDAELIAIoAnwtAAgLQf8BcUENRw0CIAIpAhAhDyACKAIMIQcgAkHUAGogAkEYakEk/AoAACACQdAAaiACQcQAaigCADYCACACIAIpAjw3A0ggAkH4AGoQuS4MAQsgAkGwAWoiByACQQxqQTz8CgAAIAJBgAFqIAcQkCsgAikDgAEhDyACQdQAaiACQYgBakEk/AoAAEGBgICAeCEHC0EADAELQYOAgIB4IQcgAikDeCEPQQELIAJBkAFqIgogBkEQaikCADcDACACQYgBaiIJIAZBCGopAgA3AwAgAiAGKQIANwOAASACQcgBahDAHyACQcABaiAKKQMANwMAIAJBuAFqIAkpAwA3AwAgAiACKQOAATcDsAEgA0EwahCPKyADIAJBsAFqQTD8CgAAIAMgDzcCTCADIAc2AkggA0HUAGogAkHUAGpBJPwKAAAgA0EAOgCEASADQYABaiACQdAAaigCADYCACADIAIpA0g3AngEQCACQQxqENUuCyACQfABaiQAIAVBAToAvAEgAUEIaiIKIANBiAH8CgAAIAVBwAFqJAAgAUGQAWohBiMAQTBrIgUkAEGAwAAhCAJAAkAgBCgCACINIAQoAggiA2tBIE8EQCADIQIMAQsgBUEQaiAKIAQQlRMCQCAFLQAQQQRGBEAgBSgCFCECDAELIAUpAxAiD0IgiKchAiAPpyIHQf8BcUEERg0AIAYgAjYCBCAGIAc6AAAgBkEDaiAHQRh2OgAAIAYgB0EIdjsAAQwCCyACBEAgBCgCCCECDAELIAZBBDoAACAGQQA2AgQMAQsDQAJAIAIgBCgCACIHRyAHIA1Hcg0AIAVBEGogCiAEEJUTAkAgBS0AEEEERgRAIAUoAhQhBwwBCyAFKQMQIg9CIIinIQcgD6ciAkH/AXFBBEYNACAGIAc2AgQgBiACOgAAIAZBA2ogAkEYdjoAACAGIAJBCHY7AAEMAwsgBCgCCCECIAcEQCAEKAIAIQcMAQsgBkEEOgAAIAYgAiADazYCBAwCCwJAAkACQAJAIAIgB0YEQCAFQQhqIAQgBxC0ICAFKAIIQYGAgIB4Rw0BIAQoAgAhByAEKAIIIQILIAQoAgQhCSAFIAs2AhwgBUEANgIYIAUgAiAJajYCECAFIAggByACayICIAIgCEsbIgk2AhQgBUEgaiAKIAVBEGoQgxYgBS0AICICQQRHDQEMAgsgBkKBzAA3AgAMBAsDQEEAIQcCQAJAAkACQCACQf8BcUEBaw4DAQIABgsgBSgCJC0ACEEjRw0FDAILIAUtACFBI0YNAQwECyAFKAIkLQAIQSNHDQMLIAUgBSkDIDcDKCAFQShqELkuIAVBIGogCiAFQRBqEIMWIAUtACAiAkEERw0ACwtBASEHCyAEIAUoAhgiCyAEKAIIaiICNgIIIAUoAhwhDAJAIAcNACAFKQMgIg+nIgdB/wFxQQRGDQAgBiAHOgAAIAZBB2ogD0I4iDwAACAGQQVqIA9CKIg9AAAgBiAPQgiIPgABDAILIAsEQCAJIAtHIAlBfyAIIA5BAWpBACAJIAtLGyIOQQFKGyAIIAkgDEcbIghJckUEQEF/IAhBAXQgCEEASBshCAsgDCALayELDAEFIAZBBDoAACAGIAIgA2s2AgQLCwsgBUEwaiQAAkAgAS0AkAFBBEcEQCABIAEpA5ABNwOYASAAIAFBmAFqEIErDAELIAAgASgClAE2AgQgAEEINgIACwJAAkACQAJAAkACQEGAgICAeCABKAJQIgAgAEGAgICAeE0bQf////8HcQ4EAQIDBAALIAEoAlRBgYCAgHhGDQQgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMBAsgAUHQAGoCQAJAIAEtAHxBAWsOBQAAAAAAAQsgASgCgAEiAkUNACACQRhBCBD4OgsQhjAgAUHcAGoQhjAgAUHoAGoQhjAMAwsgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMAgsgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMAQsgAUHUAGoQuS4LIAEoAhQiAARAIAEoAhAgAEEBEPg6CyABKAIwEJIrIAFBMGoQhjsgAUGgAWokAAviAgIGfwF+IwBBQGoiASQAAkACQCAAKAJYBEAgACkCUCEHIABCgICAgBA3A1AgAUEQaiAAQdgAaiICKAIANgIAIAJBADYCACABIAc3AwggAUEYaiABQQhqEPIvIAEgASkCGDcCNCABQQA2AjAgASABKAIkIgM2AiwgASABKAIgNgIoIAEgAUEoahDXOyABKAIAIQZBHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAEpAig3AgggAkEQaiABQTBqKQIANwIAIAJBGGogAUE4aigCADYCACADQX9GDQIgACgCTCIEIAAoAkRGBEAgAEHEAGpB2OuAARCQKAsgACgCSCAEQQxsaiIFIAM2AgggBSAGNgIEIAUgAjYCACAAIARBAWo2AkwLIAFBQGskAA8LQQRBHBCjPQALIAFBADYCOCABQQE2AiwgAUHA64ABNgIoIAFCBDcCMCABQShqQcjrgAEQ7ywAC7kCAQV/QQtBACAAQYCPBE8bIgIgAkEFaiIBIABBC3QiAiABQQJ0QcCSigFqKAIAQQt0SRsiASABQQNqIgEgAUECdEHAkooBaigCAEELdCACSxsiASABQQFqIgEgAUECdEHAkooBaigCAEELdCACSxsiASABQQFqIgEgAUECdEHAkooBaigCAEELdCACSxsiAUECdEHAkooBaigCAEELdCIEIAJGIAIgBEtqIAFqIgRBAnRBwJKKAWoiBSgCAEEVdiECQb8CIQECQCAEQRRNBEAgBSgCBEEVdiEBIARFDQELIAVBBGsoAgBB////AHEhAwsCQCABIAJBf3NqRQ0AIAAgA2shAyABQQFrIQFBACEAA0AgACACQc3MiQFqLQAAaiIAIANLDQEgASACQQFqIgJHDQALCyACQQFxC8cCAQJ/IwBBMGsiAyQAAkAgAkEhSQRAIAJFDQECQCABLAAAQQBIBEAgA0EgakJ/NwMAIANBGGpCfzcDACADQRBqQn83AwAgA0J/NwMIDAELIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCAsgAyABNgIoIAMgASACajYCLAJAIANBKGoQgzsiBEUNACAEIAIgAiAESxsiBEUNACADIAJrQShqIAEgBPwKAAALIAAgAykDCDcAACAAQRhqIANBIGopAwA3AAAgAEEQaiADQRhqKQMANwAAIABBCGogA0EQaikDADcAACADQTBqJAAPCyADQQE2AgwgA0H0/M4ANgIIIANCATcCFCADQTs2AiwgA0HM/M4ANgIoIAMgA0EoajYCECADQQhqQfz8zgAQ7ywAC0EAQQBBjP3OABDDIQAL3gIBA38jAEEgayIGJABBgIAIQYCAAiADGyIHIAQgBCAHSxshCEGAAiEEA0AgBCIHQQF0IQQgByAISQ0ACwJAAkAgByAEIAdBgNQqcSADchsiBEGBCE8EQCACKAIAIQEgAigCBCIDIARJBEAgBkEANgIcIAZCgICAgMAANwIUIAZBCGogBkEUakGMh84AEJghIAYoAgghByACIAYoAgwiCDYCBCACIAc2AgAgAwRAIAEgA0ECdEEEEPg6CyAGQRRqIgFBACAEQcSe0AAQsxUgBiABQcyCzgAQmCEgBigCBCEDIAYoAgAhASAIBEAgByAIQQJ0QQQQ+DoLIAIgAzYCBCACIAE2AgALIAUgBDYCACADIARPDQEgBCADQfy60AAQsDsACyAFIAQ2AgBBgAghAyAERQ0BCyAEQQJ0IgJFDQAgAUEAIAL8CwALIAAgAzYCBCAAIAE2AgAgBkEgaiQAC80CAQF/IwBBQGoiBCQAIAQgAjYCCCAEIAM2AgwgASgCGEF/IAIgA2oiAyACIANLG08EQCABKAIIIQIgBCABKAIEIgM2AiggBCADIAJBA3RqNgIsIAQgBEEMajYCNCAEIARBCGo2AjAgBEEQaiAEQShqIgJB0OqFARCfGyAEQRxqIAFBDGoQ1gYCQCABKAIcBEAgAiABQRxqIAQoAgggBCgCDBCxHwwBCyAEQQA2AigLIAAgBCgCDDYCGCAAIAQpAhw3AgwgACAEKQIoNwIcIAAgBCkCEDcCACAAQRRqIARBJGooAgA2AgAgAEEkaiAEQTBqKQIANwIAIABBLGogBEE4aikCADcCACAAQQhqIARBGGooAgA2AgAgBEFAayQADwsgBEEANgI4IARBATYCLCAEQYz5hQE2AiggBEIENwIwIARBKGpBlPmFARDvLAALzwIBBX8jAEEwayIBJAAgAUEIaiAAQRhqEOYLIAEoAhAiAiAAKAIIIgMgAiADSRsiBQRAIAAoAgQhAiABKAIMIQMDQAJAIAMoAgANACADQQhqKAIAIgRpQQFGBEAgAkEEaigCACAEEPgvRQ0BIAEgAhDcOyABQRhqIAEoAgAgASgCBBD9FCACKAIAIgQgBCgCACIEQQFrNgIAIARBAUYEQCACEPseCyACIAEpAhg3AgAgAkEIaiABQSBqKAIANgIADAELIAFBADYCKCABQQE2AhwgAUGw2oYBNgIYIAFCBDcCICABQRhqQbjahgEQ7ywACyACQQxqIQIgA0EMaiEDIAVBAWsiBQ0ACwsgACgCFCIDBEAgACgCECECIANBxABsIQMDQCACEL4QIAJBxABqIQIgA0HEAGsiAw0ACwsgAUEIakEEQQwQ4B4gAUEwaiQAC8kCAQZ/IwBBEGsiAiQAAkAgAC4BACIFIAXBQQ91IgBzIABrIgNB//8DcSIEQegHTwRAQQEhACACIAMgBEGQzgBuIgNBkM4AbGsiBEH//wNxQeQAbiIGQQF0IgdB4/OJAWotAAA6AA0gAiAHQeLziQFqLQAAOgAMIAIgBCAGQeQAbGtB//8DcUEBdCIEQePziQFqLQAAOgAPIAIgBEHi84kBai0AADoADgwBC0EFIQAgBEEKSQ0AIAIgAyADQf//A3FB5ABuIgNB5ABsa0H//wNxQQF0IgBB4/OJAWotAAA6AA8gAiAAQeLziQFqLQAAOgAOQQMhAAtBACAFIANB//8DcRtFBEAgAEEBayIAIAJBC2pqIANBAXRBHnFB4/OJAWotAAA6AAALIAEgBUEATkEBQQAgAkELaiAAakEFIABrEIEJIAJBEGokAAvVAgEDfyMAQRBrIgQkAAJAAkACQAJAIAIoAggiBUEETwRAIAIoAgQoAAAiBiAFQQRrSw0BIAEQkSogAUEBOgA8IAFBADYCOCABQgA3AzAgAUEANgIQIAFCADcDACAEIAJBBCAGQQRqENIQIAEgBBDKDyABIAM2AkAgAEEINgIADAMLIARBGkEAQQFBARCgGCAEKAIEIQEgBCgCAEEBRg0DDAELIARBGkEAQQFBARCgGCAEKAIEIQEgBCgCAEEBRw0ADAILIAQoAggiA0EYakHwqM4ALwAAOwAAIANBEGpB6KjOACkAADcAACADQQhqQeCozgApAAA3AAAgA0HYqM4AKQAANwAAIABBGjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBACAEQRBqJAAPCyABIAQoAghB2KfOABD9LwALywMAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4PAQIDBAUGBwgJCgsMDQ4PAAsgASgCAEHEpf4AQQQgASgCBCgCDBEGAA8LIAEoAgBByKX+AEEEIAEoAgQoAgwRBgAPCyABKAIAQcyl/gBBBCABKAIEKAIMEQYADwsgASgCAEHQpf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB06X+AEEGIAEoAgQoAgwRBgAPCyABKAIAQdml/gBBAyABKAIEKAIMEQYADwsgASgCAEHcpf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB36X+AEEDIAEoAgQoAgwRBgAPCyABKAIAQeKl/gBBBiABKAIEKAIMEQYADwsgASgCAEHopf4AQQQgASgCBCgCDBEGAA8LIAEoAgBB7KX+AEEGIAEoAgQoAgwRBgAPCyABKAIAQfKl/gBBAyABKAIEKAIMEQYADwsgASgCAEH1pf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB+KX+AEEEIAEoAgQoAgwRBgAPCyABKAIAQfyl/gBBBCABKAIEKAIMEQYADwsgASgCAEGApv4AQQUgASgCBCgCDBEGAAv6CwENfyMAQaABayIHJAAgB0EgaiEIIwBBMGsiBCQAAkACQAJAIAMQyzpFBEAgAygCACIMIAwoAgAiBkEBajYCACAGQQBIDQIgAygCECEPIAMoAgwhDSADKAIIIQ4gAygCBCEQIAMoAhQiBgRAIAYgBigCACIFQQFqNgIAIAVBAEgNAyADKAIoIQUgAygCJCEKIAMoAiAhCyADKAIcIQkgAygCGCEDCyAEIAU2AiwgBCAKNgIoIAQgCzYCJCAEIAk2AiAgBCADNgIcIAQgBjYCGCAEIA82AhQgBCANNgIQIAQgDjYCDCAEIBA2AgggBCAMNgIEDAELIARBBGogAxDaJwsCf0EFIARBBGoiBhDnOiIDRSAGKAIQIgZFcg0AGkEEIAMgBkYNABogA7ggBrijRJqZmZmZmek/ZEULIQYgCEEQaiAEQQRqQSz8CgAAIAggBjYCACAIIAM2AjwgBEEwaiQADAELAAsgASACKAIcEQQAIQMCQANAAkACQCADLQAAIgRBIEcEQCAEQSFHDQQgAy0AAQ0EIANBBGoQjj5FDQEMBAsgB0EYaiADQQRqIgMQwzQgBygCHEEBTQ0BCyAHQeAAaiIIIAdBIGoiD0HAAPwKAAAjAEHQAGsiBiQAAkACQAJAIAgoAgAOAgABAgsgBkEQaiIEIAhBEGoQyTQgBkEEaiEKIwBB4ABrIgMkACADQRRqIAQQ1QkCQAJAAkAgAygCFEEBRgRAIAMoAhwhDCADKAIYIQ0gA0EgaiILQQRBAEEEQQgQoBggAygCJCEFIAMoAiBBAUYNAiADKAIoIgkgDDYCBCAJIA02AgAgA0EQaiIMQQE2AgAgAyAJNgIMIAMgBTYCCCALIARBwAD8CgAAIwBBEGsiBCQAIARBBGogCxDVCSAEKAIEQQFGBEAgA0EIaiEFA0AgBCgCDCENIAQoAgghDiAFKAIIIgkgBSgCAEYEQCAFIAlBAUEEQQgQ3igLIAUoAgQgCUEDdGoiECANNgIEIBAgDjYCACAFIAlBAWo2AgggBEEEaiALENUJIAQoAgQNAAsLIARBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgA0HgAGokAAwBCyAFIAMoAihBoIKDARD9LwALIAgQiywgCEEDNgIAIAggBikCBDcCBCAIQQxqIAZBDGooAgA2AgAMAQsgBkEQaiIDIAhBEGogCCgCPBCxJiAGQQRqIQojAEHgAGsiBCQAIARBCGogAxDWEAJAAkACQCAEKAIIQQFxBEAgBCgCDCEJIARBIGoiC0EEIAMoAjhBAWoiBUF/IAUbIgUgBUEETRtBAEEEQQQQoBggBCgCJCEFIAQoAiBBAUYNAiAEKAIoIgwgCTYCACAEQRxqIg1BATYCACAEIAw2AhggBCAFNgIUIAsgA0HAAPwKAAAjAEEQayIDJAAgA0EIaiALENYQIAMoAghBAXEEQCAEQRRqIQUgAygCDCEJA0AgBSgCCCIMIAUoAgBGBEAgBSALKAI4QQFqIg5BfyAOGxDuLQsgBSgCBCAMQQJ0aiAJNgIAIAUgDEEBajYCCCADIAsQ1hAgAygCBCEJIAMoAgBBAXENAAsLIANBEGokACAKQQhqIA0oAgA2AgAgCiAEKQIUNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgBEHgAGokAAwBCyAFIAQoAihBoIKDARD9LwALIAgQiywgCEECNgIAIAggBikCBDcCBCAIQQxqIAZBDGooAgA2AgALIA8gCEHAAPwKAAAgBkHQAGokAAwCCyAHQRBqIAMQwzQgBygCFEEBRw0BIAdBCGogAxDDNCAHKAIMBEAgBygCCCgCAEEwaiEDDAELC0EAQQBBnISDARDDIQALIAcoAlwhAyAHQfAAaiIEIAdBMGpBLPwKAAAgB0HoAGogB0EoaikCADcDACAHIAM2ApwBIAcgBykCIDcDYCAAIAEgAiAHQeAAaiIAEKIBIAQQzSYgABCLLCAHQaABaiQAC7kCAQZ+IAApAwgiAiABMQAAQoCAgICAgICAAYQiA4VC88rRy6eM2bL0AIUiBEIQiSAEIAApAwAiBULh5JXz1uzZvOwAhXwiBIUiBkIViSAGIAJC7d6R85bM3LfkAIUiAiAFQvXKzYPXrNu38wCFfCIFQiCJfCIGhSIHQhCJIAcgBCACQg2JIAWFIgJ8IgRCIIlC/wGFfCIFhSIHQhWJIAcgBCACQhGJhSICIAMgBoV8IgNCIIl8IgSFIgZCEIkgBiADIAJCDYmFIgIgBXwiA0IgiXwiBYUiBkIViSAGIAMgAkIRiYUiAiAEfCIDQiCJfCIEhSIGQhCJIAYgAkINiSADhSICIAV8IgNCIIl8IgWFQhWJIAJCEYkgA4UiAkINiSACIAR8hSICQhGJhSACIAV8IgJCIImFIAKFC8sCAgl/AX4jAEEwayICJAAgASgCBCEEIAIgASgCCCIHQQBBBEEYEKAYIAIoAgQhBSACKAIAQQFHBEAgAigCCCEIAkAgBUUNACAHQRhsIQYgBEEMaiEDIAJBDGohCSAIIQEgBSEEA0AgBkUNASACQRhqIANBDGsQ3SACQCADKAIAQYCAgIB4RwRAIAJBJGogAxDdIAwBCyACQYCAgIB4NgIkCyAJIAIpAiQ3AgAgAkEIaiIKIAJBIGooAgA2AgAgCUEIaiACQSxqKAIANgIAIAIgAikCGCILNwMAIAFBEGogAkEQaikDADcCACABQQhqIAopAwA3AgAgASALNwIAIAFBGGohASAGQRhrIQYgA0EYaiEDIARBAWsiBA0ACwsgACAHNgIIIAAgCDYCBCAAIAU2AgAgAkEwaiQADwsgBSACKAIIQdC1wgAQ/S8AC7YCAQV/IwBB4AJrIgIkACACQZgCaiIDIAFBDGoQ3AECQCACKAKYAkEIRgRAIAIgAikCnAI3AgggAkEQaiIFIAJBCGoiBhDDLSACQbABaiIEIAUQoRsgAyABEMMGIAJB1ABqIgEgBCADEIwYIAMgARDNHCAEIAMQuAZB7ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAEQeQA/AoAACAAQdDPzwA2AgggACABNgIEIABBCDYCACACKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAGELsjCyACQeACaiQADwsgAkHAAWogAkGoAmopAwA3AwAgAkG4AWogAkGgAmopAwA3AwAgAiACKQOYAjcDsAFBzJ7PAEErIAJBsAFqQbyezwBBwM/PABDVHgALQQRB7AAQoz0AC4oDAQN/IwBBEGsiAiQAAkACQAJAAkACQAJAQQIgASgCACIDQf////8HaiADQYCAgIB4TRtBAWsOBAECAwQACyAAQYGAgIB4NgIAIAAgASgCDDYCDCAAIAEpAgQ3AgQMBAsgASgCBCEDAkAgASgCCCIERQRAQQAhAQwBCxDMLyEBIAIgBBDGECABQQhqIAJBCGopAgA3AgAgASACKQIANwIACyAAIAE2AgggACADNgIEIABBgoCAgHg2AgAMAwsgASgCDCEEAkAgA0GAgICAeEcEQCACIAEQzwsMAQsgAkGAgICAeDYCAAsgACAENgIMIAAgAikCADcCACAAQQhqIAJBCGooAgA2AgAMAgsgASgCBCEDAkAgASgCCCIERQRAQQAhAQwBCxDMLyEBIAIgBBDGECABQQhqIAJBCGopAgA3AgAgASACKQIANwIACyAAIAE2AgggACADNgIEIABBhICAgHg2AgAMAQsgACABKQIANwIAIABBCGogAUEIaikCADcCAAsgAkEQaiQAC4kDAgN+B38jAEEQayIGJAAgAS0AJCIHQQlHBEAgBiAHOgAPAkACQCABKAIMRQ0AIAFBEGogBkEPahDsDCEDIAEoAgAiB0EMayEJIAEoAgQiCCADp3EhASADQhmIQv8Ag0KBgoSIkKDAgAF+IQUgBi0ADyEKA0AgASAHaikAACIEIAWFIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIDUEUEQANAIAogCUEAIAN6p0EDdiABaiAIcWsiC0EMbGotAABGDQQgA0IBfSADgyIDUEUNAAsLIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0BIAEgDEEIaiIMaiAIcSEBDAALAAsjAEEgayIAJAAgAEECNgIEIABB2K7OADYCACAAQgE3AgwgAEGuAzYCHCAAIAZBD2o2AhggACAAQRhqNgIIIABBiK/OABDvLAALIAAgByALQQxsaiIAQQhrKAIAIAIgAEEEaygCACgCIBEBACAGQRBqJAAPC0Hkrc4AQR5B+K7OABDLJAAL0iQBBX8jAEEwayIHJAAgByADNgIMAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDhEAAQIDBAUGBwgJCgsMDQ4PEBELIAJCADcBACACQRhqQgA3AQAgAkEQakIANwEAIAJBCGpCADcBAAwRCyABQQFNBEAMEgsgAiAALwAAIgBBD3Y7AR4gAiAAQQFxOwEAIAIgAEEOdkEBcTsBHCACIABBDXZBAXE7ARogAiAAQQx2QQFxOwEYIAIgAEELdkEBcTsBFiACIABBCnZBAXE7ARQgAiAAQQl2QQFxOwESIAIgAEEIdkEBcTsBECACIABBB3ZBAXE7AQ4gAiAAQQZ2QQFxOwEMIAIgAEEFdkEBcTsBCiACIABBBHZBAXE7AQggAiAAQQN2QQFxOwEGIAIgAEECdkEBcTsBBCACIABBAXZBAXE7AQIMEAsgAUEDTQRADBELIAIgAC8AACIBQQ52OwEOIAIgAUEDcTsBACACIAAvAAIiAEEOdjsBHiACIABBA3E7ARAgAiABQQx2QQNxOwEMIAIgAUEKdkEDcTsBCiACIAFBCHZBA3E7AQggAiABQQZ2QQNxOwEGIAIgAUEEdkEDcTsBBCACIAFBAnZBA3E7AQIgAiAAQQx2QQNxOwEcIAIgAEEKdkEDcTsBGiACIABBCHZBA3E7ARggAiAAQQZ2QQNxOwEWIAIgAEEEdkEDcTsBFCACIABBAnZBA3E7ARIMDwsgAUEFTQRADBALIAIgAC8AACIBQQdxOwEAIAIgAC8ABCIDQQ12OwEeIAIgAUEMdkEHcTsBCCACIAFBCXZBB3E7AQYgAiABQQZ2QQdxOwEEIAIgAUEDdkEHcTsBAiACIAAvAAIiAEELdkEHcTsBEiACIABBCHZBB3E7ARAgAiAAQQV2QQdxOwEOIAIgAEECdkEHcTsBDCACIANBCnZBB3E7ARwgAiADQQd2QQdxOwEaIAIgA0EEdkEHcTsBGCACIANBAXZBB3E7ARYgAiAAQQF0QQZxIAFBD3ZyOwEKIAIgA0ECdEEEcSAAQQ52cjsBFAwOCyABQQdNBEAMDwsgAiAALwAAIgFBDHY7AQYgAiABQQ9xOwEAIAIgAC8AAiIDQQx2OwEOIAIgA0EPcTsBCCACIAAvAAQiBEEMdjsBFiACIARBD3E7ARAgAiAALwAGIgBBDHY7AR4gAiAAQQ9xOwEYIAIgAUEIdkEPcTsBBCACIAFBBHZBD3E7AQIgAiADQQh2QQ9xOwEMIAIgA0EEdkEPcTsBCiACIARBCHZBD3E7ARQgAiAEQQR2QQ9xOwESIAIgAEEIdkEPcTsBHCACIABBBHZBD3E7ARoMDQsgAUEJTQRADA4LIAIgAC8AACIBQR9xOwEAIAIgAC8ACCIDQQt2OwEeIAIgAUEKdkEfcTsBBCACIAFBBXZBH3E7AQIgAiAALwACIgRBCXZBH3E7AQogAiAEQQR2QR9xOwEIIAIgAC8ABCIFQQh2QR9xOwEQIAIgBUEDdkEfcTsBDiACIAAvAAYiAEEHdkEfcTsBFiACIABBAnZBH3E7ARQgAiADQQZ2QR9xOwEcIAIgA0EBdkEfcTsBGiACIARBAXRBHnEgAUEPdnI7AQYgAiAFQQJ0QRxxIARBDnZyOwEMIAIgAEEDdEEYcSAFQQ12cjsBEiACIANBBHRBEHEgAEEMdnI7ARgMDAsgAUELTQRADA0LIAIgAC8AACIEQT9xOwEAIAIgAC8ABCIFQQp2OwEOIAIgAC8ABiIGQT9xOwEQIAIgBEEGdkE/cTsBAiACIAAvAAIiAUEIdkE/cTsBCCACIAFBAnZBP3E7AQYgAiAFQQR2QT9xOwEMIAIgBkEGdkE/cTsBEiACIAAvAAgiA0EIdkE/cTsBGCACIANBAnZBP3E7ARYgAiABQQR0QTBxIARBDHZyOwEEIAIgBUECdEE8cSABQQ52cjsBCiACIANBBHRBMHEgBkEMdnI7ARQgAiAALwAKIgBBCnY7AR4gAiAAQQR2QT9xOwEcIAIgAEECdEE8cSADQQ52cjsBGgwLCyABQQ1NBEAMDAsgAiAALwAAIgNB/wBxOwEAIAIgA0EHdkH/AHE7AQIgAiAALwACIgRBBXZB/wBxOwEGIAIgAC8ABCIFQQN2Qf8AcTsBCiACIAAvAAYiAUEIdkH/AHE7ARAgAiABQQF2Qf8AcTsBDiACIAAvAAgiBkEGdkH/AHE7ARQgAiAALwAKIghBBHZB/wBxOwEYIAIgBEECdEH8AHEgA0EOdnI7AQQgAiAFQQR0QfAAcSAEQQx2cjsBCCACIAFBBnRBwABxIAVBCnZyOwEMIAIgBkEBdEH+AHEgAUEPdnI7ARIgAiAIQQN0QfgAcSAGQQ12cjsBFiACIAAvAAwiAEEJdjsBHiACIABBAnZB/wBxOwEcIAIgAEEFdEHgAHEgCEELdnI7ARoMCgsgAUEPTQRADAsLIAIgAC8AACIBQQh2OwECIAIgAUH/AXE7AQAgAiAALwACIgFBCHY7AQYgAiABQf8BcTsBBCACIAAvAAQiAUEIdjsBCiACIAFB/wFxOwEIIAIgAC8ABiIBQQh2OwEOIAIgAUH/AXE7AQwgAiAALwAIIgFBCHY7ARIgAiABQf8BcTsBECACIAAvAAoiAUEIdjsBFiACIAFB/wFxOwEUIAIgAC8ADCIBQQh2OwEaIAIgAUH/AXE7ARggAiAALwAOIgBBCHY7AR4gAiAAQf8BcTsBHAwJCyABQRFNBEAMCgsgAiAALwAAIghB/wNxOwEAIAIgAC8AAiIBQQJ2Qf8DcTsBBCACIAAvAAQiA0EEdkH/A3E7AQggAiAALwAGIgRBBnZB/wNxOwEMIAIgAC8ACiIFQQF2Qf8DcTsBEiACIAAvAAwiBkEDdkH/A3E7ARYgAiABQQd0QYADcSAIQQl2cjsBAiACIANBBXRB4ANxIAFBC3ZyOwEGIAIgBEEDdEH4A3EgA0ENdnI7AQogAiAALwAIIgFBAXRB/gNxIARBD3ZyOwEOIAIgBUEIdEGAAnEgAUEIdnI7ARAgAiAGQQZ0QcADcSAFQQp2cjsBFCACIAAvABAiAUEHdjsBHiACIAAvAA4iAEEFdkH/A3E7ARogAiAAQQR0QfADcSAGQQx2cjsBGCACIAFBAnRB/ANxIABBDnZyOwEcDAgLIAFBE00EQAwJCyACIAAvAAAiBUH/B3E7AQAgAiAALwAIIgZBBnY7AQ4gAiAALwAKIghB/wdxOwEQIAIgAC8AAiIBQQR2Qf8HcTsBBCACIAAvAAYiA0ECdkH/B3E7AQogAiAALwAMIgRBBHZB/wdxOwEUIAIgAUEGdEHAB3EgBUEKdnI7AQIgAiAALwAEIgVBAnRB/AdxIAFBDnZyOwEGIAIgA0EIdEGABnEgBUEIdnI7AQggAiAGQQR0QfAHcSADQQx2cjsBDCACIARBBnRBwAdxIAhBCnZyOwESIAIgAC8ADiIBQQJ0QfwHcSAEQQ52cjsBFiACIAAvABIiA0EGdjsBHiACIAAvABAiAEECdkH/B3E7ARogAiAAQQh0QYAGcSABQQh2cjsBGCACIANBBHRB8AdxIABBDHZyOwEcDAcLIAFBFU0EQAwICyACIAAvAAAiBUH/D3E7AQAgAiAALwAEIgFBAXZB/w9xOwEGIAIgAC8ACCIDQQJ2Qf8PcTsBDCACIAAvAAwiBEEDdkH/D3E7ARIgAiAALwACIgZBBXRB4A9xIAVBC3ZyOwECIAIgAUEKdEGACHEgBkEGdnI7AQQgAiAALwAGIgVBBHRB8A9xIAFBDHZyOwEIIAIgA0EJdEGADHEgBUEHdnI7AQogAiAALwAKIgFBA3RB+A9xIANBDXZyOwEOIAIgBEEIdEGADnEgAUEIdnI7ARAgAiAALwAOIgNBAnRB/A9xIARBDnZyOwEUIAIgAC8AFCIEQQV2OwEeIAIgAC8AECIBQQR2Qf8PcTsBGCACIAFBB3RBgA9xIANBCXZyOwEWIAIgAC8AEiIAQQF0Qf4PcSABQQ92cjsBGiACIARBBnRBwA9xIABBCnZyOwEcDAYLIAFBF00EQAwHCyACIAAvAAAiAUH/H3E7AQAgAiAALwAEIgNBBHY7AQYgAiAALwAGIgRB/x9xOwEIIAIgAC8ACiIFQQR2OwEOIAIgAC8ADCIGQf8fcTsBECACIAAvAAIiCEEEdEHwH3EgAUEMdnI7AQIgAiADQQh0QYAecSAIQQh2cjsBBCACIAAvAAgiAUEEdEHwH3EgBEEMdnI7AQogAiAFQQh0QYAecSABQQh2cjsBDCACIAAvAA4iAUEEdEHwH3EgBkEMdnI7ARIgAiAALwAQIgNBBHY7ARYgAiADQQh0QYAecSABQQh2cjsBFCACIAAvABIiAUH/H3E7ARggAiAALwAWIgNBBHY7AR4gAiAALwAUIgBBBHRB8B9xIAFBDHZyOwEaIAIgA0EIdEGAHnEgAEEIdnI7ARwMBQsgAUEZTQRADAYLIAIgAC8AACIEQf8/cTsBACACIAAvAAgiAUEBdkH/P3E7AQogAiAALwAQIgNBAnZB/z9xOwEUIAIgAC8AAiIFQQN0Qfg/cSAEQQ12cjsBAiACIAAvAAQiBEEGdEHAP3EgBUEKdnI7AQQgAiAALwAGIgVBCXRBgDxxIARBB3ZyOwEGIAIgAUEMdEGAIHEgBUEEdnI7AQggAiAALwAKIgRBAnRB/D9xIAFBDnZyOwEMIAIgAC8ADCIBQQV0QeA/cSAEQQt2cjsBDiACIAAvAA4iBEEIdEGAPnEgAUEIdnI7ARAgAiADQQt0QYAwcSAEQQV2cjsBEiACIAAvABgiAUEDdjsBHiACIAAvABIiBEEBdEH+P3EgA0EPdnI7ARYgAiAALwAUIgNBBHRB8D9xIARBDHZyOwEYIAIgAC8AFiIAQQd0QYA/cSADQQl2cjsBGiACIAFBCnRBgDhxIABBBnZyOwEcDAQLIAFBG00EQAwFCyACIAAvAAAiAUH//wBxOwEAIAIgAC8ADCIDQQJ2OwEOIAIgAC8ADiIEQf//AHE7ARAgAiAALwACIgVBAnRB/P8AcSABQQ52cjsBAiACIAAvAAQiAUEEdEHw/wBxIAVBDHZyOwEEIAIgAC8ABiIFQQZ0QcD/AHEgAUEKdnI7AQYgAiAALwAIIgFBCHRBgP4AcSAFQQh2cjsBCCACIAAvAAoiBUEKdEGA+ABxIAFBBnZyOwEKIAIgA0EMdEGA4ABxIAVBBHZyOwEMIAIgAC8AECIBQQJ0Qfz/AHEgBEEOdnI7ARIgAiAALwAaIgNBAnY7AR4gAiAALwASIgRBBHRB8P8AcSABQQx2cjsBFCACIAAvABQiAUEGdEHA/wBxIARBCnZyOwEWIAIgAC8AFiIEQQh0QYD+AHEgAUEIdnI7ARggAiAALwAYIgBBCnRBgPgAcSAEQQZ2cjsBGiACIANBDHRBgOAAcSAAQQR2cjsBHAwDCyABQR1NBEAMBAsgAiAALwAAIgFB//8BcTsBACACIAAvAAIiA0EBdEH+/wFxIAFBD3ZyOwECIAIgAC8ABCIBQQJ0Qfz/AXEgA0EOdnI7AQQgAiAALwAGIgNBA3RB+P8BcSABQQ12cjsBBiACIAAvAAgiAUEEdEHw/wFxIANBDHZyOwEIIAIgAC8ACiIDQQV0QeD/AXEgAUELdnI7AQogAiAALwAMIgFBBnRBwP8BcSADQQp2cjsBDCACIAAvAA4iA0EHdEGA/wFxIAFBCXZyOwEOIAIgAC8AECIBQQh0QYD+AXEgA0EIdnI7ARAgAiAALwASIgNBCXRBgPwBcSABQQd2cjsBEiACIAAvABwiAUEBdjsBHiACIAAvABQiBEEKdEGA+AFxIANBBnZyOwEUIAIgAC8AFiIDQQt0QYDwAXEgBEEFdnI7ARYgAiAALwAYIgRBDHRBgOABcSADQQR2cjsBGCACIAAvABoiAEENdEGAwAFxIARBA3ZyOwEaIAIgAUEOdEGAgAFxIABBAnZyOwEcDAILIAFBH00EQAwDCyACIAAvAAA7AQAgAiAAKQACNwECIAIgACkACjcBCiACIAApABI3ARIgAiAAKAAaNgEaIAIgAC8AHjsBHgwBCyAHQQE2AhQgB0H8ic8ANgIQIAdCATcCHCAHQTs2AiwgByAHQShqNgIYIAcgB0EMajYCKCAHQRBqQZSKzwAQ7ywACyAHQTBqJAAPC0GkvM4AQS1BlLzOABCfKQALvQIBA38jAEEwayIIJAACQAJAIANFDQACQANAIAUgAi0AACIKQQFqIglNBEAgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUECdGooAgAiCSAEIApBAnRqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCfFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC70CAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQCAFIAItAAAiCkEBaiIJTQRAIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQkgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIAlBA3RqKAIAIgkgBCAKQQN0aigCACIKTwRAIAcgCUkNAiAIQRhqIAEgBiAKaiAJIAprQQAQlxQgCCgCGCIJQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkEBaiECIANBAWsiA0UNAwwBCwsgCiAJQZDK0AAQsTsACyAJIAdBkMrQABCwOwALQQghCQsgACAJNgIAIAhBMGokAAvKAgECfyMAQaACayIDJAAgAiABLQBDQQFzOgBYIANBEGoiBCACQdwA/AoAACABLQBEQQFGBEAgA0HsAGoiASACQdwA/AoAACABQQE6AFkgBCABQdwA/AoAAAsgA0HsAGogA0EQahDfByADQdABaiIBIANB+ABqKQIANwMAIANB2AFqIgIgA0GAAWooAgA2AgAgAyADKQJwNwPIAQJAIAMoAmwiBEGAgICAeEYEQCAAIAMpA8gBNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMAQsgA0H0AWogA0GEAWpBLPwKAAAgA0HoAWogA0HQAWopAwA3AgAgA0HwAWogA0HYAWooAgA2AgAgAyAENgLcASADIAMpA8gBNwLgASADQQhqIANB3AFqEKABIAAgAykDCDcCBCAAQZOAgIB4NgIACyADQaACaiQAC9QCAgJ/A34jAEEwayIDJAACQAJAAkACQCACQSZNBEAgA0EQaiABIAIQ+gggAy0AEEUNASAAQgA3AwggAEIBNwMADAQLAkACQAJAIAEtAABBK2sOAwECAAILQQEhBCABLAABQb9/TA0DIAFBAWohASACQQFrIQIMAQsgASwAAUG/f0wNAyABQQFqIQEgAkEBayECCyADQQhqIAEgAkEwEMkTIAMoAgwiAUUEQCAAQQBBMPwLAAwECyADKAIIIgItAABBMGtB/wFxQQpPBEAgAEIANwMIIABCATcDAAwECyAAIAIgASAEEIIGDAMLIAMpAyAhBSAAIAMpAygiBkI/hyIHNwMoIAAgBzcDICAAIAY3AxggACAFNwMQIABCADcDCCAAQgA3AwAMAgsgASACQQEgAkHQ84cBEKM2AAsgASACQQEgAkHg84cBEKM2AAsgA0EwaiQAC7ICAQp/IwBBIGsiBCQAIAQgADYCCCAEIAAgAyABIAEgA0sbIghBAnQiCWoiBzYCDAJAAkACQCAIIARBCGoQnjYiBiAGIAhLGyIKRQ0AIAIhBgNAIAAgACgCACILIAYoAgAiDGsiDSAFazYCACALIAxJIAUgDUtyIQUgAEEEaiEAIAZBBGohBiAKQQFrIgoNAAsgBUUNACABQQJ0IAhBAnRrIQADQCAARQ0CIAcgBygCACIBQQFrNgIAIABBBGshACAHQQRqIQcgAUUNAAsLIAIgCWohBSADQQJ0IAlrIQADQCAARQ0CIABBBGshACAFKAIAIAVBBGohBUUNAAsLIARBADYCGCAEQQE2AgwgBEH4pogBNgIIIARCBDcCECAEQQhqQYCniAEQ7ywACyAEQSBqJAALygICBH8BfiMAQRBrIgIkACACQQhqIAEQgRgCQAJAIAItAAhBBEYNACACKQMIIgZC/wGDQgRRDQAgACAGNwIADAELIAJBCGogAUEYahCCGAJAIAItAAhBBEYNACACKQMIIgZC/wGDQgRRDQAgACAGNwIADAELAkACQCABKAJAQQdNBEAgAkEQaiEFA0AgARCFOyEDIAIgASgCECIEQRh2OgAPIAIgBEEQdjoADiACIARBCHY6AA0gAiAEOgAMIAIgA0EYdjoACyACIANBEHY6AAogAiADQQh2OgAJIAIgAzoACCABKAIwIgRFDQIgASgCQCIDQQlPDQMgBCACQQhqIANqIAUQvSYgASABKAJAIANrIgNBCGo2AkAgA0F3Sw0ACwsgAEEEOgAADAILQYD1zQAQsjsACyADQQhBuPTNABCvOwALIAJBEGokAAvIAgIDfgh/An9BCCABKAJMRQ0AGiABQdAAaiACEO4LIQMgASgCQCIIQUBqIQsgASgCRCIJIAOncSEGIANCGYhC/wCDQoGChIiQoMCAAX4hBSACKAIIIQwgAigCBCENA0ACQCAGIAhqKQAAIgQgBYUiA0J/hSADQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgNQRQRAA0AgDSAMIAsgA3qnQQN2IAZqIAlxIgdBBnRrIgIoAgQgAigCCBDkHA0CIANCAX0gA4MiA1BFDQALC0EIIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0CGiAGIApBCGoiCmogCXEhBgwBCwsgCEEAIAdrQQZ0aiICQQxrKAIAIQcgAkEQaygCAAshAiAAIAEoAiQgByACQQhGIgYbNgIEIAAgASgCICACIAYbIgBBACAAQQhHGzYCAAvEAgIDfwF+IwBBoAJrIgIkACABQQhqIQMCQAJAAkACQAJAAkAgAS0AAEEBaw4CAQIACyACQQhqIgEgA0H4APwKAAAgAkGAAWogARD/ECACKAKIASIBQQNNDQMgACACKQKAATcCACACKAKEASABQQRrNgAAIABBCGogAkGIAWooAgA2AgAMAgsgAkGQAWoiASADQfgA/AoAACAAIAEQ/xAMAQsgAkGYAmoiASADQRBqKQMANwMAIAJBkAJqIgQgA0EIaikDADcDACACIAMpAwAiBTcDiAIgAi0AnAIhAyACIAU3A4ABIANBA3YgA0EHcUEAR2oiA0EJTw0CIAQgAkGAAWogAxChNiAAQQhqIAEoAgA2AgAgACACKQOQAjcCAAsgAkGgAmokAA8LQQQgAUGEi88AELA7AAsgA0EIQZCJzwAQsDsAC+0CAQR/IwBB0ABrIgIkACACIAFBGGoiAzYCHAJAAkAgA0HQ74UBEMYIBEAgAkEQaiABENw7IAIgAigCFCIDNgI0IANBAUcNASACQQhqIAEQ3DsgAigCDARAIAIoAggiBCgCACIDIAMoAgAiBUEBajYCACAFQQBIDQMgAiADNgI4IAIgBCkCBDcCPCAAIAJBOGogASgCKCABKAIkEPIVIABBFGogAUEsakEAIAEoAiwbEO4lIAEQiicgAkHQAGokAA8LQQBBAEGM8YUBEMMhAAsgAiADNgIgIAJCAjcCRCACQQI2AjwgAkHo8IUBNgI4IAJBpwQ2AjAgAkGtAzYCKCACQdDvhQE2AiQgAiACQSRqNgJAIAIgAkEgajYCLCACQRxqQbTwhQEgAkE4akH48IUBEKMrAAsgAkIANwJEIAJCgYCAgMAANwI8IAJB5PGFATYCOEEAIAJBNGpBiPGFASACQThqQezxhQEQrysLAAvgAgECfyMAQUBqIgQkACAEIAEoAggiBTYCDCAEIAI2AhAgBCADNgIUAkAgAiADTQRAIAMgBUsNAQJAIAIgA0cEQCAEQRhqIAFBDGogASgCBCAFIAEoAgAoAgARBQAgBEEgaiIBIAQoAhQgAms2AgAgBCAEKAIcIAJqNgIcIAAgBCkCGDcCACAAQQhqIAEpAgA3AgAMAQsgAEEANgIMIABCATcCBCAAQdCFiAE2AgALIARBQGskAA8LIARBAjYCHCAEQZSGiAE2AhggBEICNwIkIARBqx02AjwgBEGrHTYCNCAEIARBMGo2AiAgBCAEQRRqNgI4IAQgBEEQajYCMCAEQRhqQaSGiAEQ7ywACyAEQQI2AhwgBEHQhogBNgIYIARCAjcCJCAEQasdNgI8IARBqx02AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBEEYakHghogBEO8sAAujAgEDfyMAQZABayIDJAACfwJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxDQEgA0EIaiAAKAIAIANBEGoQsBAgAUEBQQFBACADKAIIIAMoAgwQgQkMAgsgACgCACEAQQAhAgNAIAIgA2pBjwFqIABBD3EiBEEwciAEQdcAaiAEQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIANqQZABakEAIAJrEIEJDAELIAAoAgAhAEEAIQIDQCACIANqQY8BaiAAQQ9xIgRBMHIgBEE3aiAEQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIANqQZABakEAIAJrEIEJCyADQZABaiQAC+UCAgN/AX4jAEHgA2siBCQAIARByAFqIAMoAgQgAygCCBC4GSADEN47IAIoAgghAyACKAIEIQUgAi0AACEGAkAgBCgCyAFBAkYEQEIDIQcgBCgCzAEhAiADRSAGQQpJcg0BIAUgA0EBEPg6DAELIAIpAgwhByAEQZACahD+LCAEQccDaiACQQNqLQAAOgAAIAQgBjoAxAMgBCAHNwPQAyAEIAM2AswDIAQgBTYCyAMgBCACLwABOwDFAyAEQdACaiAEQcgBakHIAPwKAAAgBEEBOgDYAyAEQYCU69wDNgKgAyAEQQA2AqgDIARChICAgPAANwK8AyAEKQOQAiEHIAQoApgCIQIgBEEEaiAEQZwCakHEAfwKAAALIAEoAgAiASABKAIAIgNBAWo2AgAgA0EATgRAIAAgAjYCCCAAIAc3AwAgACABNgLQASAAQQxqIARBBGpBxAH8CgAAIARB4ANqJAAPCwALwwIBBX8jAEEQayIFJAAgAEEIIAAoAjQiAyADQQhNGzYCNCAAQTBqIQcgAkEEdCEDAkBBACAAKAIwIgZrQQdxIgQgACgCCCAGa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAcgBBCNNwJAAkAgA0EEciIEIAAoAgggACgCMGsiBk0NACAEQYCAgIB4Sw0BIAQgBk0NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgByADEI03IAVBCGogABDcOyAFIAUoAgggBSgCDCAAKAIwIgQgBCADa0HUxv4AENcmAkAgBSgCBEEEdiIDIAIgAiADSxsiA0UNACADQQR0IgNFDQAgBSgCACABIAP8CgAACyAAIAIQqhEgBUEQaiQADwtB9Mb+AEElQZzH/gAQnykAC8ICAgJ+An8jAEEQayIFJAACQCABKAI4IgQEfwJAIAEpAygiA1BFBEAgASkDMCECDAELIAFBIGohBANAAn4CQCABKQMQIgJCA1IEQAJAAkACQCACQgJRDQAgASACUK1CAYY3AxAgAqdBAXFFDQAgBSABKQMYNwMIDAELIAQoAgBFDQEgBSAEELYqIAUpAwAhAgsgAkIAUg0CCyABQgM3AxALIAEpAwAiAkICUQ0FIAFCADcDACABKQMIDAELIAUpAwgLIQMgAqdBAXFFDQMgASADNwMoIAEgASkDMEJAfSICNwMwIANQDQALIAEoAjghBAsgASAEQQFrNgI4IAEgA0IBIAN6IgOGhTcDKCADpyACp2ohBEEBBUEACyEBIAAgBDYCBCAAIAE2AgAgBUEQaiQADwtB3IODAUEdQfyDgwEQyyQAC4YDAgR/AX4jAEEQayICJABBgICAgHghAwJAAkACQAJAAkACQEECIAEoAgAiBEH/////B2ogBEGAgICAeE0bQQFrDgQBAgMEAAsgAEGBgICAeDYCACAAIAEoAgw2AgwgACABKQIENwIEDAQLIAEoAgQhAwJAIAEoAggiBEUEQEEAIQEMAQsQzC8hASACIAQQ1xAgAUEIaiACQQhqKQIANwIAIAEgAikCADcCAAsgACABNgIIIAAgAzYCBCAAQYKAgIB4NgIADAMLIAEoAgwhBSAEQYCAgIB4RwRAIAIgARDPCyACKQIEIQYgAigCACEDCyAAIAY3AgQgACADNgIAIAAgBTYCDAwCCyABKAIEIQMCQCABKAIIIgRFBEBBACEBDAELEMwvIQEgAiAEENcQIAFBCGogAkEIaikCADcCACABIAIpAgA3AgALIAAgATYCCCAAIAM2AgQgAEGEgICAeDYCAAwBCyAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIACyACQRBqJAALzAIBAX8CQAJAAkACQAJAAkACQAJAAkAgBSAISwRAIAcgCU0NASAIIApqIgsgBU8NAiAEIAtBAnRqKAIAIgUgBCAIQQJ0aigCACIIayIEQQBIDQMgCSAKaiIKIAdPDQQgBiAKQQJ0aigCACAGIAlBAnRqKAIAIgZrIgdBAEgNBSAEIAdyRQRAQQEPCyAEIAdHBEBBAA8LIAUgCEkNBiABIAVJDQcgBCAGaiIBIARJDQggASADSw0JIAAgCGogBCACIAZqIAQQnzsPCyAIIAVB1K2HARDDIQALIAkgB0HkrYcBEMMhAAsgCyAFQfSthwEQwyEAC0GErocBELI7AAsgCiAHQZSuhwEQwyEAC0GkrocBELI7AAsgCCAFQbSthwEQsTsACyAFIAFBtK2HARCwOwALIAYgAUHErYcBELE7AAsgASADQcSthwEQsDsAC7wCAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtB8KzNABCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEHIAAoAgQiBiABSQRAIAAgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiBiACIAZLGxDoGSAAKAIMIQILIAdFDQAgACgCCCACakH/ASAH/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQYCtzQAQsjsACyAAIAQ2AhAgA0EQaiQAC9oCAQN/IwBBMGsiAiQAIAEtABYhAyABQQI6ABYCQAJAIANBAkcEQCAAQQQ2AgAgACADOgAEDAELIAEoAhAiBEUEQCACQRBqELQeIAIoAhAiA0EERg0CIAAgAikCGDcCCCAAQRBqIAJBIGooAgA2AgAgAEEHaiACKAIUIgFBGHY6AAAgACABQQh2OwAFIAAgAToABCAAIAM2AgAMAQsgASgCDCEDIAEgBEEBazYCECABIANBAWo2AgwCQAJAAkAgAy0AACIBDgMCAQIACyACIAE6AA8gAkECNgIUIAJBpLPOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAILIABBBDYCACAAQQE6AAQMAQsgAEEENgIAIABBADoABAsgAkEwaiQADwtBAUEAQdSzzgAQrzsAC6UFAgV/AX4jAEEQayIIJAACQAJAAkACQAJAAkACQAJAIAAoAugpQQFGBEAgAC0AvioNAQsgACgCqCoiBkUNByABKAIAIglFDQcgBCgCACIKIAkgBiAGIAlLGyIGaiIHIApJDQQgAyAHSQ0FIAhBCGogACAAKALIASAAKALMASAAQdgpahDqHiAGIAgoAgwiA0sNBiACIApqIAYgCCgCCCAGQcjD0AAQ1SwgASAJIAZrNgIAIAQgBzYCACAAKAIAQQFrDgICAwELIwBBEGsiAiQAIAAtAL4qIQEgAEEAOgC+KiAALwG4KiAAQQA7AbgqQQYgAXQiB3IhAwJAAkACQAJAAkACQCAAKAIAQQFNBEAgAkEIaiAAIAAoAsgBIAAoAswBIABB2ClqEOoeIAIoAgwiBSAAKAKoKiIESQ0CIAQgBUYNAyACKAIIIARqIgYgAzoAACABQQJNDQYgBSAEayIEQQFHBEAgBiADQQh2OgABIAFBCk0NByAEQQJNDQIMBgtBAUEBQYjD0AAQwyEACyAAIAM6ANgpIABCATcDACABQQJLDQMMBQtBAiAEQZjD0AAQwyEACyAEIAVB6MLQABCvOwALQQBBAEH4wtAAEMMhAAsgACADQQh2OgDZKSABQQpNDQEgAEHYKWohBgsgBiAHQRB2OgACCyAAIAAoAqgqIAFBDWpBA3ZqNgKoKiACQRBqJABBASEHDAYLIAAoAgQgBmohAQwBCyAAKAIEIAZqIQELIAAgATYCBCAAIAAoAqgqIAZrNgKoKiAAIAApA9ApIAatfCILNwPQKUEBIQcgBSgCAEEBRw0DIAUgCz4CBAwDCyAKIAdBqMPQABCxOwALIAcgA0Gow9AAELA7AAsgBiADQbjD0AAQsDsACyAIQRBqJAAgBwu6AgEHfyAAQRBqIAAgAigCACICKAIAKAIAEQIAIQMgAEEwQSAgAEEwaiAAQSBqIAIoAgAoAgARAgBBAEgiBBtqIQUgAEEgQTAgBBtqIgYgACADQX9zQRt2QRBxaiIEIAUgBSAAIANBG3ZBEHFqIgAgAigCACgCABECAEEASCIDGyAGIAQgAigCACgCABECAEEASCIHGyIIIAAgBSAEIAcbIAMbIgkgAigCACgCABECACECIAFBCGogBSAAIAMbIgBBCGopAAA3AAAgASAAKQAANwAAIAEgCCAJIAJBAEgiABsiAikAADcAECABQRhqIAJBCGopAAA3AAAgAUEoaiAJIAggABsiAEEIaikAADcAACABIAApAAA3ACAgASAEIAYgBxsiACkAADcAMCABQThqIABBCGopAAA3AAAL1QIBA38CQAJAIAJB//8DcSICIAEoAgxPDQBBfyACIAEoAggiAmoiAyACIANLGyICQQFxBEBBhICAgHghAUGAgICAeCEDQciB/wAhBAwCC0F/IAJBAmoiAyACIANLGyIEIAEoAgAiAygCBCIFSwRAQYWAgIB4IQEgAiEDDAILIAMgAygCFEECaiIENgIUIAMoAggoAgggBEkEQEGIgICAeCEBDAILIAIgBUkEQCAFIAJBAXIiBE0EQCAEIAVBzIL/ABDDIQALIAMoAgAiAyAEai0AAEEIdCACIANqLQAAciICRQ0BIABCioCAgBg3AgAgAEF/IAEoAgQiACACaiIBIAAgAUsbNgIIDwsgAiAFQbyC/wAQwyEACyAAQoqAgIAINwIADwsgACACNgIcIABBAzYCGCAAIAQ2AhQgACADNgIQIABCBDcCCCAAQQA2AgQgACABNgIAC7wCAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtBmIz/ABCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEHIAAoAgQiBiABSQRAIAAgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiBiACIAZLGxDoGSAAKAIMIQILIAdFDQAgACgCCCACakH/ASAH/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQaiM/wAQsjsACyAAIAQ2AhAgA0EQaiQAC80CAgN+A38jAEEQayIGJABCgICAgICAgICAfyEDAkACQAJAAn4CQAJAIAAoAgQoAhAgAUEDdGopAwAiBEKAgICAgICAgIB/UiAAKAIAIgcoAgAiBSgCACkDACICQn9SckUEQEIAIQIMAQsgAlANBCAEIAQgAn8iAyACfn1CACACQn9SGyECIARCAFkNAQsgAyACIAUoAggpAwBXrX0MAQsgAyACIAUoAgQpAwBZrXwLIgIgAkI/hyIDIAcoAgQtAAAQ/yAEQCAAKAIIIAFBBHRqIgAgAzcDCCAAIAI3AwAMAQsgACgCECIFIAUoAgBBAWo2AgAgBkEIaiAAKAIUEIY9IAFBA3YiACAGKAIMIgVPDQIgBigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAZBEGokAA8LQbyP/wAQ4isACyAAIAVBiIv/ABDDIQAL1QICA34DfyMAQRBrIgYkAEKAgICAgICAgIB/IQMCQAJAAkACQAJ+AkACQCAAKAIEKAIQIAFBA3RqKQMAIgRCgICAgICAgICAf1IgACgCACIHKAIAIgUoAgApAwAiAkJ/UnJFBEBCACECDAELIAJQDQUgBCAEIAJ/IgMgAn59QgAgAkJ/UhshAiAEQgBZDQELIAMgAiAFKAIIKQMAV619DAELIAMgAiAFKAIEKQMAWa18CyICQoCAgIAIfEL/////D1YNACACpyIFIAcoAgQtAAAQxClFDQAgACgCCCABQQJ0aiAFNgIADAELIAAoAhAiBSAFKAIAQQFqNgIAIAZBCGogACgCFBCGPSABQQN2IgAgBigCDCIFTw0CIAYoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAGQRBqJAAPC0G8j/8AEOIrAAsgACAFQYiL/wAQwyEAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQN2IQUDQCACIAM2AgwCQCADKAIAIgYgCUkEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBCGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQJ2IQUDQCACIAM2AgwCQCAJIAMoAgAiBksEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBBGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQJ2IQUDQCACIAM2AgwCQCAJIAMoAgAiBksEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBBGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQN2IQUDQCACIAM2AgwCQCADKAIAIgYgCUkEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBCGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJByBA2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC4QBAQF/AkACQCAAKAIAIgFBk4CAgHhGDQACQAJAAkBBCyABQYCAgIB4cyABQQBOGw4QBAAEBAQEBAMEBAQBBAQEAgMLIABBBGoQvCoPCyAAEN47IAAtAAxBA0cNASAAKAIQIgAQvCogAEEMQQQQ+DoPCyAAQQRqEN47Cw8LIABBBGoQ3jsLvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0HswIIBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtB/MCCARCyOwALIAAgBDYCECADQRBqJAALvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0HQ54QBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtB4OeEARCyOwALIAAgBDYCECADQRBqJAALvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0Gw9YQBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtBwPWEARCyOwALIAAgBDYCECADQRBqJAALzQMCBn8CfiMAQRBrIgckAAJAAkACQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIANBA3RqIQUgASgCDCIDIARBA3QiAmoiCCABKAIEIgZLBEAgASAGQQF0IgMgCBDdKiIGIAMgBksbEOgZIAEoAgQhBiABKAIMIQMLIAIgBWohCSAAQQhqIQggBEUgA0EIaiAGS3INAiACQQhrIQQgCCkDACELIAEoAgghCgNAIAMgCmogBSkDACALfDcAACADQQhqIQAgBUEIaiEFIANBEGogBksNBCAEIgJBCGshBCAAIQMgAg0ACwwDCyADIAJBxJyHARCxOwALIAIgBUHEnIcBELA7AAsgAyEACyABIAA2AgwgByAINgIMIAcgCTYCCCAHIAU2AgQgB0EEaiIDKAIAIgAgAygCBCICRwRAIAIgAGtBA3YhBCABKAIMIQIgAygCCCkDACELA0AgACkDACEMIAJBCGoiAyABKAIEIgVLBH8gASAFQQF0IgIgAxDbKiIDIAIgA0sbEOgZIAEoAgwFIAILIAEoAghqIAsgDHw3AAAgASABKAIMQQhqIgI2AgwgAEEIaiEAIARBAWsiBA0ACwsgB0EQaiQAC8sDAQd/IwBBEGsiCCQAAkACQAJAIAQgAyAEaiICTQRAIAIgACgCBCIGSw0BIAAoAgAgA0ECdGohBiABKAIMIgMgBEECdCICaiIHIAEoAgQiBUsEQCABIAVBAXQiAyAHEN0qIgUgAyAFSxsQ6BkgASgCBCEFIAEoAgwhAwsgAiAGaiEJIABBCGohByAERSADQQRqIAVLcg0CIAJBBGshBCAHKAIAIQogASgCCCELA0AgAyALaiAGKAIAIApqNgAAIANBBGohACAGQQRqIQYgA0EIaiAFSw0EIAQiAkEEayEEIAAhAyACDQALDAMLIAMgAkHEnIcBELE7AAsgAiAGQcSchwEQsDsACyADIQALIAEgADYCDCAIIAc2AgwgCCAJNgIIIAggBjYCBCAIQQRqIgMoAgAiACADKAIEIgJHBEAgAiAAa0ECdiEEIAEoAgwhAiADKAIIKAIAIQMDQCAAKAIAIQYgAkEEaiIFIAEoAgQiB0sEfyABIAdBAXQiAiAFENsqIgUgAiAFSxsQ6BkgASgCDAUgAgsgASgCCGogAyAGajYAACABIAEoAgxBBGoiAjYCDCAAQQRqIQAgBEEBayIEDQALCyAIQRBqJAALywMBB38jAEEQayIIJAACQAJAAkAgBCADIARqIgJNBEAgAiAAKAIEIgZLDQEgACgCACADQQF0aiEGIAEoAgwiAyAEQQF0IgJqIgcgASgCBCIFSwRAIAEgBUEBdCIDIAcQ3SoiBSADIAVLGxDoGSABKAIEIQUgASgCDCEDCyACIAZqIQkgAEEIaiEHIARFIANBAmogBUtyDQIgAkECayEEIAcvAQAhCiABKAIIIQsDQCADIAtqIAYvAQAgCmo7AAAgA0ECaiEAIAZBAmohBiADQQRqIAVLDQQgBCICQQJrIQQgACEDIAINAAsMAwsgAyACQcSchwEQsTsACyACIAZBxJyHARCwOwALIAMhAAsgASAANgIMIAggBzYCDCAIIAk2AgggCCAGNgIEIAhBBGoiAygCACIAIAMoAgQiAkcEQCACIABrQQF2IQQgASgCDCECIAMoAggvAQAhAwNAIAAvAQAhBiACQQJqIgUgASgCBCIHSwR/IAEgB0EBdCICIAUQ2yoiBSACIAVLGxDoGSABKAIMBSACCyABKAIIaiADIAZqOwAAIAEgASgCDEECaiICNgIMIABBAmohACAEQQFrIgQNAAsLIAhBEGokAAvEAgEEfyAAQgA3AhAgAAJ/QQAgAUGAAkkNABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEgA0EBdGtBPmoLIgI2AhwgAkECdEGo8IoBaiEEQQEgAnQiA0HE84oBKAIAcUUEQCAEIAA2AgAgACAENgIYIAAgADYCDCAAIAA2AghBxPOKAUHE84oBKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgAkEBdmtBACACQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGCAAIAA2AgwgACAANgIIC8MCAgV/An4CQCAAQugHVARAIAAhCAwBCyABQQRrIQYgACEJA0AgAiAGaiIEQQFqIAkgCUKQzgCAIghCkM4Afn2nIgdB//8DcUHkAG4iBUEBdCIDQePziQFqLQAAOgAAIAQgA0Hi84kBai0AADoAACAEQQNqIAcgBUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAACAEQQJqIANB4vOJAWotAAA6AAAgAkEEayECIAlC/6ziBFYgCCEJDQALCyAIQglWBEAgASACakEBayAIpyIDIANB//8DcUHkAG4iBUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAACABIAJBAmsiAmogA0Hi84kBai0AADoAACAFrSEICyAAUEUgCFBxRQRAIAEgAkEBayICaiAIp0EBdEEecUHj84kBai0AADoAAAsgAgu4AgEGfyMAQTBrIgMkAAJAIAEoAggiBAR/IAEoAgQiASAEQQN0aiEHAkADQCADQQhqIAEoAgAgAiABQQRqKAIAKAIUEQEAIAMoAgwhBCADKAIIIghBCEcEQCAAIAMpAxA3AwggAEEQaiADQRhqKQMANwMAIAAgBDYCBCAAIAg2AgAMBAsgAyAENgIAAkACQCAFRQRAIAQhBkEBIQUMAQsgAyAGNgIEIAQgBkcNAQsgAUEIaiIBIAdGDQIMAQsLIANBAjYCDCADQeTV0AA2AgggA0ICNwIUIANBOzYCLCADQTs2AiQgAyADQSBqNgIQIAMgAzYCKCADIANBBGo2AiAgAEEEaiADQQhqEJkOIABBADYCAAwCCyAGQQAgBRsFQQALIQEgAEEINgIAIAAgATYCBAsgA0EwaiQAC7gCAQZ/IwBBMGsiAyQAAkAgASgCCCIEBH8gASgCBCIBIARBA3RqIQcCQANAIANBCGogASgCACACIAFBBGooAgAoAhwRAQAgAygCDCEEIAMoAggiCEEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwAgACAENgIEIAAgCDYCAAwECyADIAQ2AgACQAJAIAVFBEAgBCEGQQEhBQwBCyADIAY2AgQgBCAGRw0BCyABQQhqIgEgB0YNAgwBCwsgA0ECNgIMIANB6NjQADYCCCADQgI3AhQgA0E7NgIsIANBOzYCJCADIANBIGo2AhAgAyADNgIoIAMgA0EEajYCICAAQQRqIANBCGoQmQ4gAEEANgIADAILIAZBACAFGwVBAAshASAAQQg2AgAgACABNgIECyADQTBqJAAL1QICBX8BfiMAQSBrIgMkAAJAAkACQAJAAkAgAC0AGCIFQcAARwRAIAAoAgQiBiAAKAIMIgcgACgCCGoiBGtBB00NAiAEIAZLDQMgACkDECEIIAAgB0EIajYCDCAAKAIAIARqIAggASAFrYaENwAAIAAgAUEAIAVrQT9xrYg3AxAMAQsgACgCBCIFIAAoAgwiBiAAKAIIaiIEa0EHTQ0DIAQgBUsNBCAAKQMQIQggACABNwMQIAAgBkEIajYCDCAAKAIAIARqIAg3AAALIAAgAkFAajoAGCADQSBqJAAPCyADQQA2AhggA0EBNgIMIANBrML7ADYCCCADQgQ3AhAgA0EIakHM3PsAEO8sAAsgBCAGQczc+wAQrzsACyADQQA2AhggA0EBNgIMIANBrML7ADYCCCADQgQ3AhAgA0EIakHc3PsAEO8sAAsgBCAFQdzc+wAQrzsAC7oCAQR/IABCADcCECAAAn9BACABQYACSQ0AGkEfIAFB////B0sNABogAUEGIAFBCHZnIgNrdkEBcSADQQF0a0E+agsiBDYCHCAEQQJ0QajwigFqIQICQEEBIAR0IgNBxPOKASgCAHFFBEAgAiAANgIAIAAgAjYCGEHE84oBQcTzigEoAgAgA3I2AgAMAQsCQAJAIAEgAigCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgBEEBdmtBACAEQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGAsgACAANgIMIAAgADYCCAvCAgIGfwJ+IwBBEGsiAyQAQYCAgIB4IQQCQAJAAkACfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNBCAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qC6wiCCAIQj+HIgkgBygCBC0AABD/IARAIAAoAgggAUEEdGoiACAJNwMIIAAgCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EQaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAu7BAEIfyMAQYABayIDJAAgA0H0AGogASACEMYvIgEQyQYgASgCDCIEIAQoAgAiAkEBajYCAAJAAkAgAkEASA0AIAEoAhAhBiABKAIUIgIEQCACIAIoAgAiBUEBajYCACAFQQBIDQEgASgCICEHIAEoAhwhCCABKAIYIQkgASgCKCEKIAEoAiQhBQsgA0HIAGogA0H8AGooAgA2AgAgAyADKQJ0NwNAIAMgCjYCaCADIAU2AmQgAyAHNgJgIAMgCDYCXCADIAk2AlggAyACNgJUIAMgBjYCUCADIAQ2AkwgAyABKQIsNwJsIANBCGoiByEBIwBBMGsiAiQAAkACQCADQUBrIgQtAABBHUYEQCACQQxqIAQoAjAgBCgCBBCKESAEKAIIIgYgBigCACIFQQFqNgIAIAVBAEgNASACQRhqIAQQmzYQ7iUgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIDQEgASAGNgIEIAFBHjoAACABIAIpAhg3AiAgASAFNgIMIAEgAikCDDcCFCABIAQoAhA2AhAgAUEoaiACQSBqKQIANwIAIAFBMGogAkEoaikCADcCACABQRxqIAJBFGooAgA2AgAgBBD7JCACQTBqJAAMAgtB/OOAAUEoQaTkgAEQnykLAAtBwABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABB5OWAATYCCCAAIAE2AgQgAEGTgICAeDYCACADQYABaiQADwsAC0EEQcAAEKM9AAu7BAEIfyMAQYABayIDJAAgA0H0AGogASACEMYvIgEQyQYgASgCDCIEIAQoAgAiAkEBajYCAAJAAkAgAkEASA0AIAEoAhAhBiABKAIUIgIEQCACIAIoAgAiBUEBajYCACAFQQBIDQEgASgCICEHIAEoAhwhCCABKAIYIQkgASgCKCEKIAEoAiQhBQsgA0HIAGogA0H8AGooAgA2AgAgAyADKQJ0NwNAIAMgCjYCaCADIAU2AmQgAyAHNgJgIAMgCDYCXCADIAk2AlggAyACNgJUIAMgBjYCUCADIAQ2AkwgAyABKQIsNwJsIANBCGoiByEBIwBBMGsiAiQAAkACQCADQUBrIgQtAABBHUYEQCACQQxqIAQoAjAgBCgCBBCCESAEKAIIIgYgBigCACIFQQFqNgIAIAVBAEgNASACQRhqIAQQmzYQ7iUgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIDQEgASAGNgIEIAFBGzoAACABIAIpAhg3AiAgASAFNgIMIAEgAikCDDcCFCABIAQoAhA2AhAgAUEoaiACQSBqKQIANwIAIAFBMGogAkEoaikCADcCACABQRxqIAJBFGooAgA2AgAgBBD7JCACQTBqJAAMAgtB/OOAAUEoQaTkgAEQnykLAAtBwABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCACADQYABaiQADwsAC0EEQcAAEKM9AAvOAgECfyAAQQRBBBDgHiAAQcgAahDNDCAAKAI4BEAgAEE4ahDPLwsgAEEMahDPLyAAQRxqEM8vIABBLGoiARCKFCABQQRBzAEQ4B4CQCAAKAKAAUGAgICAeEYNACAAQZgBahDNDCAAQYABaiIBEMUnIAFBBEEMEOAeIAAoApQBIgIEQCAAKAKQASEBA0AgARClHiABQcQAaiEBIAJBAWsiAg0ACwsgAEGMAWpBBEHEABDgHiAAKAKsASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQawBahD7HgsgAEHcAGoiARDFJyABQQRBDBDgHiAAQegAaiIBEIEjIAFBBEEIEOAeIABB9ABqIgEQgSMgAUEEQQgQ4B4gACgCxAEhASAAKALIASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAgRAIAEgAiAAKAIIEPg6Cwv5EwMdfwR+AW8jAEEgayIJJAACQAJAIAEoAggiESABKAIMRg0AIAFBEGohHAJAA0ACQCABIBFBCGo2AgggESgCACECIBEoAgQhAyMAQRBrIhYkACAWIAM2AgwgFiACNgIIAn8gFkEIaiECIwBBIGsiDyQAAkACfwJAQQBBkNLMACgCABEEACITBEAgEygCAA0DIBNBfzYCACAPQQhqIRAgAigCACEUIAIoAgQhF0EAIQIjAEEQayIdJAAgE0EEaiIMKAIEIgQgFCAXIBQbIgVxIQMgBa0iIUIZiEKBgoSIkKDAgAF+ISIgDCgCACEFAkACQANAAkAgAyAFaikAACIfICKFIiBCf4UgIEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIgUEUEQANAIBQgBSAgeqdBA3YgA2ogBHFBdGxqIg5BDGsoAgBGBEAgDkEIaygCACAXRg0DCyAgQgF9ICCDIiBQRQ0ACwsgHyAfQgGGg0KAgYKEiJCgwIB/g1BFDQIgAyACQQhqIgJqIARxIQMMAQsLIBAgDDYCBCAQIA42AgBBACEMDAELIAwoAghFBEAgHUEIaiEeIwBBQGoiByQAAkAgDCgCDCIOQQFqIgIgDk8EQAJAAkAgDCgCBCIGIAZBAWoiCEEDdiIEQQdsIAZBCEkbIhhBAXYgAkkEQCAHQTBqAn8gGEEBaiIDIAIgAiADSRsiAkEPTwRAIAJB/////wFLDQRBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIgJBDEEIIAIQnRQgBygCNCEKIAcoAjAiC0UEQCAHKAI4IQIMBQsgBykCOCEfIApBCWoiAgRAIAtB/wEgAvwLAAsgByAfQiCIPgIsIAcgH6ciEjYCKCAHIAo2AiQgByALNgIgIAdBCDYCHCAOBEAgC0EMayEVIAtBCGohDSAMKAIAIgNBDGshGCADKQMAQn+FQoCBgoSIkKDAgH+DIR9BACECIA4hBCADIQUDQCAfUARAA0AgAkEIaiECIAVBCGoiBSkDAEKAgYKEiJCgwIB/gyIfQoCBgoSIkKDAgH9RDQALIB9CgIGChIiQoMCAf4UhHwsgCyADIB96p0EDdiACaiIZQXRsaiIGQQxrKAIAIgggBkEIaygCACAIGyIaIApxIgZqKQAAQoCBgoSIkKDAgH+DIiBQBEBBCCEIA0AgBiAIaiEGIAhBCGohCCALIAYgCnEiBmopAABCgIGChIiQoMCAf4MiIFANAAsLIB9CAX0gH4MhHyALICB6p0EDdiAGaiAKcSIGaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAtqIBpBGXYiCDoAACANIAZBCGsgCnFqIAg6AAAgFSAGQXRsaiIGQQhqIBggGUF0bGoiCEEIaigAADYAACAGIAgpAAA3AAAgBEEBayIEDQALCyAHIA42AiwgByASIA5rNgIoQQAhAgNAIAIgDGoiAygCACEEIAMgAiAHakEgaiIDKAIANgIAIAMgBDYCACACQQRqIgJBEEcNAAsgBygCJCICRQ0BIAIgAkEMbEETakF4cSIDakEJaiICRQ0BIAcoAiAgA2sgAkEIEPg6DAELIAwoAgAhAyAEIAhBB3FBAEdqIgUEQCADIQIDQCACIAIpAwAiH0J/hUIHiEKBgoSIkKDAgAGDIB9C//79+/fv37//AIR8NwMAIAJBCGohAiAFQQFrIgUNAAsLAkACQCAIQQhPBEAgAyAIaiADKQAANwAADAELIAgEQCADQQhqIAMgCPwKAAALIAhFDQELIANBCGohFSADQQxrIRlBASEEIAMhC0EAIQIDQCACIQogBCECAkAgAyAKaiIaLQAAQYABRw0AIBkgCkF0bGohEgJAA0AgEigCACIEIBIoAgQgBBsiGyAGcSIEIQUgAyAEaikAAEKAgYKEiJCgwIB/gyIfUARAQQghDQNAIAUgDWohBSANQQhqIQ0gAyAFIAZxIgVqKQAAQoCBgoSIkKDAgH+DIh9QDQALCyADIB96p0EDdiAFaiAGcSIFaiwAAEEATgRAIAMpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIARrIAogBGtzIAZxQQhPBEAgAyAFaiIELQAAIAQgG0EZdiIEOgAAIBUgBUEIayAGcWogBDoAACAFQXRsIQRB/wFGDQIgAyAEaiEFQXQhBANAIAQgC2oiDSgAACEbIA0gBCAFaiINKAAANgAAIA0gGzYAACAEQQRqIgQNAAsMAQsLIBogG0EZdiIEOgAAIBUgCkEIayAGcWogBDoAAAwBCyAaQf8BOgAAIBUgCkEIayAGcWpB/wE6AAAgBCAZaiIEQQhqIBJBCGooAAA2AAAgBCASKQAANwAACyALQQxrIQsgAiACIAhJIgVqIQQgBQ0ACwsgDCAYIA5rNgIIC0GBgICAeCEKDAILEOMnIAcoAgwhAiAHKAIIIQoMAQsQ4ycgBygCBCECIAcoAgAhCgsgHiAKNgIAIB4gAjYCBCAHQUBrJAALIBAgFzYCDCAQIBQ2AgggECAhNwMACyAQIAw2AhAgHUEQaiQAIA8oAhgiAkUNASAPKQMIIR8gDykDECEgIA8gFCAXEJM+NgIQIA8gIDcCCCACIB8gEBD6EgwCC0HQ0cwAEJgnAAsgDygCCAtBBGsoAgAQ9DogEyATKAIAQQFqNgIAIA9BIGokAAwBC0GU0swAEJs+AAshAiAWQRBqJAAgCSACNgIQIBwoAgAlASAJQRBqIgIoAgAlARAMISMQ3xIiAyAjJgEgCSADNgIUAkAgCUEUahCpOwRAIAIoAgAlASAcKAIAJQEQb0UNAQsgCSgCFCECAkAgASgCAEUNACABKAIEIgNBhAFJDQAgAxDyHwsgASACNgIEQQEhBCABQQE2AgAgCUEIaiARKAIAIBEoAgQQtTYgCUEYaiEBAkACQAJAAkACQCAJKAIIIgIgCSgCDCIDQbzKwwBBCRDBLkUEQCACIANBxcrDAEEJEMEuDQEgAiADQc7KwwBBBRDBLg0CIAIgA0HTysMAQQYQwS4NAyACIANB2crDAEEHEMEuDQQgAiADQeDKwwBBCxDBLkUEQCABQQY6AAEMBgsgAUEFOgABDAULIAFBADoAAQwECyABQQE6AAEMAwsgAUECOgABDAILIAFBAzoAAQwBCyABQQQ6AAELIAFBADoAACAJLQAYRQ0BIAAgCSgCHDYCBAwDCyAJKAIUIgJBhAFPBEAgAhDyHwsgCSgCECICQYQBTwRAIAIQ8h8LIAEoAggiESABKAIMRw0BDAMLCyAAIAktABk6AAFBACEECyAAIAQ6AAAgCSgCECIAQYQBSQ0BIAAQ8h8MAQsgAEGADjsBAAsgCUEgaiQAC5QCAQt/IAAgAUECdEEEayIDaiEFIAIgA2ohBiAAIAFBAXYiC0ECdGoiA0EEayEEA0AgAiADKAIAIgcgACgCACIIIAdBGHYiByAIQRh2IghJIgwbNgIAIAYgBCgCACIJIAUoAgAiCiAKQRh2IgogCUEYdiIJSSINGzYCACAEQXxBACANG2ohBCAFQXxBACAJIApNG2ohBSAAIAcgCE9BAnRqIQAgAyAMQQJ0aiEDIAZBBGshBiACQQRqIQIgC0EBayILDQALIARBBGohBCABQQFxBH8gAiAAIAMgACAESSIBGygCADYCACADIAAgBE9BAnRqIQMgACABQQJ0agUgAAsgBEcgAyAFQQRqR3JFBEAPCxDkKwAL0AIBBn8jAEHAAmsiBSQAIAEoAvQCIgYoAhQiBEEIaiAEKAIIQQJGQQJ0aiIHLQAhIQhBACEEAkACQAJAAkAgBi8BGCIJDgIAAQILIAVCBTcDAAwCCyAGLwEaDQAgBy0AICIEQQNHIARBAEdxIQQLIAUgCSAEEJ8aCwJAIAYvARoiBEUEQCAFQgQ3A1AMAQsgBUHQAGogBBDgIwsgBiAGKAIAIgRBAWo2AgAgBEEATgRAQQAiBEUEQCAFQfABaiAFQdAA/AoAAAsgBEUEQCAFQaABaiAFQdAAakHQAPwKAAALIAEQvB8gASAFQaABakGgAfwKAAAgAUIANwKcAiABIAY2ApgCIAEgAzYClAIgASACNgKQAiABIAhBAUY6AIgCIAFBgICAgHg2AvABIAFCBjcDoAEgAUGkAmpBADoAACAAQQg2AgAgBUHAAmokAA8LAAvQAgEGfyMAQcACayIFJAAgASgC9AIiBigCFCIEQQhqIAQoAghBAkZBAnRqIgctACEhCEEAIQQCQAJAAkACQCAGLwEYIgkOAgABAgsgBUIFNwMADAILIAYvARoNACAHLQAgIgRBA0cgBEEAR3EhBAsgBSAJIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDUAwBCyAFQdAAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBOBEBBACIERQRAIAVB8AFqIAVB0AD8CgAACyAERQRAIAVBoAFqIAVB0ABqQdAA/AoAAAsgARDNISABIAVBoAFqQaAB/AoAACABQgA3ApwCIAEgBjYCmAIgASADNgKUAiABIAI2ApACIAEgCEEBRjoAiAIgAUGAgICAeDYC8AEgAUIGNwOgASABQaQCakEAOgAAIABBCDYCACAFQcACaiQADwsAC9ACAQZ/IwBBwAJrIgUkACABKAL0AiIGKAIUIgRBCGogBCgCCEECRkECdGoiBy0AISEIQQAhBAJAAkACQAJAIAYvARgiCQ4CAAECCyAFQgU3AwAMAgsgBi8BGg0AIActACAiBEEDRyAEQQBHcSEECyAFIAkgBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNQDAELIAVB0ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQEEAIgRFBEAgBUHwAWogBUHQAPwKAAALIARFBEAgBUGgAWogBUHQAGpB0AD8CgAACyABELsfIAEgBUGgAWpBoAH8CgAAIAFCADcCnAIgASAGNgKYAiABIAM2ApQCIAEgAjYCkAIgASAIQQFGOgCIAiABQYCAgIB4NgLwASABQgY3A6ABIAFBpAJqQQA6AAAgAEEINgIAIAVBwAJqJAAPCwALgBIDFn8EfgN9IwBBEGsiDCQAAkAgAS0AlAFFDQAgASgCjAEoAhQiBUEIaiAFKAIIQQJGQQJ0ai0AIUEWRg0AIAIiBSADQQJ0aiEGIAxBBGoiBwJ/A0BBACAFIAZGDQEaIAUqAgAhHiAFQQRqIgghBSAeIB5cDQALIB4hHyAIQQRrIgUhBANAIAYgCEcEQCAIKgIAISAgCEEEaiEIICAgIFwNASAIQQRrIgkgBCAeICBdIgobIQQgCSAFIB8gIF4iCRshBSAgIB4gChshHiAgIB8gCRshHwwBCwsgBSoAACEeIAdDAAAAACAEKgAAIh8gH0MAAAAAWxs4AgggB0MAAACAIB4gHkMAAAAAWxs4AgRBAQs2AgAgDCgCBEEBRw0AIAwqAgwhHgJAIAwqAggiHyAfXA0AIAEoAhBBAUYEQCABKgIUIB9eRQ0BCyABIB84AhQgAUEBNgIQCyAeIB5cDQAgASgCGEEBRgRAIB4gASoCHF5FDQELIAEgHjgCHCABQQE2AhgLIANFIAEoAoABQYCAgIB4RnJFBEAgAUGAAWohBCADQQJ0IQggAiEFA0AgBCAFQQQQhgoQohUgBUEEaiEFIAhBBGsiCA0ACwsCQCABKAJoQYCAgIB4RwRAIAFBIGoiAUHIAGogAxDsLSADBEAgA0ECdCEDA0AjAEEwayIOJAAgDkEYaiEIIAFBEGoiByACQQQQzQIhHCABQTBqIQVBACEGQQAhDUEAIQ9BACERQQAhEiMAQRBrIhMkACABKAIIRQRAAkAgE0EIaiEUIwBB4ABrIgQkACAEIAU2AhwgBCAHNgIYIAEoAgwhCSAEIARBGGo2AiACQAJAAkACQAJAIAkgCUEBaiIHTQRAIAEoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgB0kEQCAJQQFqIgYgByAGIAdLGyIGQQ9JDQIgBkH/////AU0EQEF/IAZBA3RBB25BAWtndkEBaiEGDAQLEN0nIAQoAhQhBiAEKAIQIgdBgYCAgHhHDQUMAwsgASAEQSBqQeSmzwAQ6wkMAwsQ3ScgBCgCBCEGIAQoAgAhBwwDC0EEQQhBECAGQQhJGyAGQQRJGyEGCyAEQdAAaiABQRBqIgpBCCAGEPsUIAQoAlghBiAEKAJUIQcgBCgCUCIJRQ0BIAQgBCgCXDYCTCAEIAY2AkggBCAHNgJEIAQgCTYCQCAEQQhqIARBQGsQwTQgBCgCDCIGBEAgBCgCCEH/ASAG/AsACyAEKAJIIQYgBCgCRCEHIAQoAkAiCUUNASAEIAQoAkw2AjwgBCAGNgI4IAQgBzYCNCAEIAk2AjAgBEKIgICAgAE3AiggBCAKNgIkIAQgASgCDCIVBH8gCUEIaiEXIAEoAgAiFikDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAWQQhqIhYpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAiAiCygCBCIQKAIIIhggASgCACAaeqdBA3YgDWpBA3QiGWtBCGsoAgAiCk0NBCAJIAcgCygCACAQKAIEIApBAnRqQQQQzQKnIhBxIgpqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCiALaiEKIAtBCGohCyAJIAcgCnEiCmopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAJIBt6p0EDdiAKaiAHcSIKaiwAAEEATgRAIAkpAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAJIApqIBBBGXYiCzoAACAXIApBCGsgB3FqIAs6AAAgCSAKQQN0a0EIayABKAIAIBlrQQhrKQAANwAAIBVBAWsiFQ0ACyABKAIMBUEACyIHNgI8IAQgBiAHazYCOCABIARBMGpBBBD6KiAEQSRqEPUnC0GBgICAeCEHCyAUIAY2AgQgFCAHNgIAIARB4ABqJAAMAQsgCiAYQZSQzgAQwyEACwsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAFKAIEIQ0gBSgCCCEJIAEoAgAhBwNAAkAgBCAHaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQAJAIAgCfgJAA0AgGlANASAJIAEoAgAgGnqnQQN2IARqIAZxIgtBA3RrQQhrKAIAIgpNDQMgGkIBfSAagyEaIAJBBCANIApBAnRqQQQQnztFDQALIAggHDcDCCAIIAEoAgBBACALa0EDdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0DIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQMaIAggByAPaiwAAEEATgR/IAcpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCCAcNwMIQgELNwMAIAggATYCFCATQRBqJAAMAwsgCiAJQZSQzgAQwyEAC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAOQQhqIQQCQCAIKAIAQQFGBEAgCCkDCCEaIAgoAhAhBiAIKAIUIQggBSAFKAIMQQRqNgIMIAIqAgAhHiAFKAIIIgcgBSgCAEYEQCAFQaSQzgAQnSgLIAUoAgQgB0ECdGogHjgCACAFIAdBAWo2AgggBiAIKAIAIgVqIgktAAAhCiAJIBqnQRl2Igk6AAAgBSAIKAIEIAZBCGtxakEIaiAJOgAAIAQgCDYCDCAEIBo3AwAgCCAIKAIMQQFqNgIMIAQgBSAGQQN0ayIFNgIIIAggCCgCCCAKQQFxazYCCCAFQQhrIAetNwMADAELIAQgCEEIaiIFKQMANwMAIARBCGogBUEIaikDADcDAAsgDigCEEEIaykDACEaIA5BMGokACABKAJQIgUgASgCSEYEQCABQcgAakHUkM4AELMoCyABKAJMIAVBA3RqIBo3AwAgASAFQQFqNgJQIAJBBGohAiADQQRrIgMNAAsLIABBCDYCAAwBCyAAIAEoAnggAiADIAEoAnwoAgwRBQALIAxBEGokAAuQEgMWfwR+A3wjAEEgayIMJAACQCABLQCkAUUNACABKAKcASgCFCIFQQhqIAUoAghBAkZBAnRqLQAhQRZGDQAgAiIFIANBA3RqIQYgDEEIaiIHAn4DQEIAIAUgBkYNARogBSsDACEeIAVBCGohBSAeIB5iDQALIB4hHyAFQQhrIgkhBANAIAUgBkcEQCAFKwMAISAgBUEIaiEFICAgIGINASAFQQhrIgggBCAeICBjIgobIQQgCCAJIB8gIGQiCBshCSAgIB4gChshHiAgIB8gCBshHwwBCwsgCSsAACEeIAdEAAAAAAAAAAAgBCsAACIfIB9EAAAAAAAAAABhGzkDECAHRAAAAAAAAACAIB4gHkQAAAAAAAAAAGEbOQMIQgELNwMAIAwoAghBAUcNACAMKwMYIR4CQCAMKwMQIh8gH2INACABKAIAQQFGBEAgASsDCCAfZEUNAQsgASAfOQMIIAFCATcDAAsgHiAeYg0AIAEoAhBBAUYEQCAeIAErAxhkRQ0BCyABIB45AxggAUIBNwMQCyADRSABKAKQAUGAgICAeEZyRQRAIAFBkAFqIQQgA0EDdCEJIAIhBQNAIAQgBUEIEIYKEKIVIAVBCGohBSAJQQhrIgkNAAsLAkAgASgCeEGAgICAeEcEQCABQTBqIgVByABqIAMQ7C0gAwRAIANBA3QhAQNAIwBBMGsiDiQAIA5BGGohCSAFQRBqIgcgAkEIEM0CIRwgBUEwaiEDQQAhBkEAIQ1BACEPQQAhEUEAIRIjAEEQayITJAAgBSgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCADNgIcIAQgBzYCGCAFKAIMIQggBCAEQRhqNgIgAkACQAJAAkACQCAIIAhBAWoiB00EQCAFKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAdJBEAgCEEBaiIGIAcgBiAHSxsiBkEPSQ0CIAZB/////wFNBEBBfyAGQQN0QQduQQFrZ3ZBAWohBgwECxDdJyAEKAIUIQYgBCgCECIHQYGAgIB4Rw0FDAMLIAUgBEEgakH0pM8AEOsJDAMLEN0nIAQoAgQhBiAEKAIAIQcMAwtBBEEIQRAgBkEISRsgBkEESRshBgsgBEHQAGogBUEQaiIKQQggBhD7FCAEKAJYIQYgBCgCVCEHIAQoAlAiCEUNASAEIAQoAlw2AkwgBCAGNgJIIAQgBzYCRCAEIAg2AkAgBEEIaiAEQUBrEME0IAQoAgwiBgRAIAQoAghB/wEgBvwLAAsgBCgCSCEGIAQoAkQhByAEKAJAIghFDQEgBCAEKAJMNgI8IAQgBjYCOCAEIAc2AjQgBCAINgIwIARCiICAgIABNwIoIAQgCjYCJCAEIAUoAgwiFQR/IAhBCGohFyAFKAIAIhYpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFkEIaiIWKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIgIgsoAgQiECgCCCIYIAUoAgAgGnqnQQN2IA1qQQN0IhlrQQhrKAIAIgpNDQQgCCAHIAsoAgAgECgCBCAKQQN0akEIEM0CpyIQcSIKaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAogC2ohCiALQQhqIQsgCCAHIApxIgpqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogCCAbeqdBA3YgCmogB3EiCmosAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCCAKaiAQQRl2Igs6AAAgFyAKQQhrIAdxaiALOgAAIAggCkEDdGtBCGsgBSgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgBSgCDAVBAAsiBzYCPCAEIAYgB2s2AjggBSAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBwsgFCAGNgIEIBQgBzYCACAEQeAAaiQADAELIAogGEGUkM4AEMMhAAsLIAUoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gAygCBCENIAMoAgghCCAFKAIAIQcDQAJAIAQgB2opAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkACQCAJAn4CQANAIBpQDQEgCCAFKAIAIBp6p0EDdiAEaiAGcSILQQN0a0EIaygCACIKTQ0DIBpCAX0gGoMhGiACQQggDSAKQQN0akEIEJ87RQ0ACyAJIBw3AwggCSAFKAIAQQAgC2tBA3RqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAyAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0DGiAJIAcgD2osAABBAE4EfyAHKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAkgHDcDCEIBCzcDACAJIAU2AhQgE0EQaiQADAMLIAogCEGUkM4AEMMhAAtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgDkEIaiEEAkAgCSgCAEEBRgRAIAkpAwghGiAJKAIQIQYgCSgCFCEJIAMgAygCDEEIajYCDCACKwMAIR4gAygCCCIHIAMoAgBGBEAgA0GkkM4AELMoCyADKAIEIAdBA3RqIB45AwAgAyAHQQFqNgIIIAYgCSgCACIDaiIILQAAIQogCCAap0EZdiIIOgAAIAMgCSgCBCAGQQhrcWpBCGogCDoAACAEIAk2AgwgBCAaNwMAIAkgCSgCDEEBajYCDCAEIAMgBkEDdGsiAzYCCCAJIAkoAgggCkEBcWs2AgggA0EIayAHrTcDAAwBCyAEIAlBCGoiAykDADcDACAEQQhqIANBCGopAwA3AwALIA4oAhBBCGspAwAhGiAOQTBqJAAgBSgCUCIDIAUoAkhGBEAgBUHIAGpB1JDOABCzKAsgBSgCTCADQQN0aiAaNwMAIAUgA0EBajYCUCACQQhqIQIgAUEIayIBDQALCyAAQQg2AgAMAQsgACABKAKIASACIAMgASgCjAEoAgwRBQALIAxBIGokAAu1AgIEfwF+IwBBIGsiAyQAAkAgASgCbCIEIAEoAnAiBXIgASgCaCICckUNAAJAAkAgBQ0AIAIgBEcEQCAERSACcg0BDAILIAQNAQsgAkEBa0EHSQRAIAFBGGohBANAIAQgAkEDdGpCADcDACABIAEoAmhBAWoiAjYCaCACQQhJDQALIAEoAnAhBQsgASACIAVqNgJwIAFBARD6CyABQQA2AmwMAQsgARC9DQsgA0EQaiICIAFBEGopAwA3AwAgA0EIaiIEIAFBCGopAwA3AwAgAyABKQMAIgY3AwAgAy0AFCEBIAMgBjcDGCABQQN2IAFBB3FBAEdqIgFBCU8EQCABQQhB6I7OABCwOwALIAQgA0EYaiABEKE2IABBCGogAigCADYCACAAIAMpAwg3AgAgA0EgaiQAC4YOAgZ/An4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgoBAgMEBQYHCAkKAAtB5M3OAEEMQZDOzgAQ7SwACwJ/AkACQCAAQQRqIgUoAiAiCkUEQAJAIAFFIAJBgBBLckUEQCACRQ0BIAUoAgAhASAFKAIEIQcgBCEAA0AgBCAGSQ0EIAMgBmogABC3HiIIIAdPDQUgASAIQQJ0akEANgIAIABBAWshACACIAZBAWoiBkcNAAsMAQsgBSgCBCIARQ0AIABBAnQiAEUNACAFKAIAQQAgAPwLAAsgBUEBNgIgCyAKRQwCCyAGIARBxM3OABCvOwALIAhBAWogB0HUzc4AELA7AAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAEEtyRQRAIAJFDQEgCSgCACEIIAkoAgQhBiAEIQADQCAEIAVJDQ4gAyAFaiAAELceIgpBAmoiASAGSw0PIAggCkECdGpCADcCACAAQQFrIQAgAiAFQQFqIgVHDQALDAELIAkoAgQiAEUNACAAQQJ0IgBFDQAgCSgCAEEAIAD8CwALIAlBATYCIAsgB0UMAAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAIEtyRQRAIAJFDQEgCSgCACEIIAkoAgQhBiAEIQADQCAEIAVJDQ0gAyAFaiAAELYeIgpBBGoiASAGSw0OIAggCkECdGoiAUIANwIAIAFBCGpCADcCACAAQQFrIQAgAiAFQQFqIgVHDQALDAELIAkoAgQiAEUNACAAQQJ0IgBFDQAgCSgCAEEAIAD8CwALIAlBATYCIAsgB0UMAAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAgAJLckUEQCACRQ0BIAkoAgAhCCAJKAIEIQYgBCEAA0AgBCAFSQ0MIAMgBWogABCWGiIKQQRqIgEgBksNDSAIIApBAnRqIgFCADcCACABQQhqQgA3AgAgAEEBayEAIAIgBUEBaiIFRw0ACwwBCyAJKAIEIgBFDQAgAEECdCIARQ0AIAkoAgBBACAA/AsACyAJQQE2AiALIAdFDAALDwsCfwJAAkACQCAAQQRqIgYoAigiCkUEQAJAIAFFIAIgBigCOCIBQQZ2S3JFBEAgAkUNASAEIQADQCAEIAdJDQYgBjUCNCELIAMgB2ogABDvICEMIAYoAgQiASAMIAuIpyIITQ0EIAYoAgAgCEEBdGpBADsBACAAQQFrIQAgAiAHQQFqIgdHDQALDAELIAEgBigCBCIASw0DIAFFDQAgAUEBdCIARQ0AIAYoAgBBACAA/AsACyAGQQE2AigLIApFDAMLIAggAUHc1s4AEMMhAAsgASAAQbzWzgAQsDsACyAHIARBzNbOABCvOwALDwsCfwJAIABBBGoiBSgCKCIKRQRAAkAgAUUgAkGABEtyRQRAIAJFDQEgBSgCACEBIAUoAgQhByAEIQADQCAEIAZJDQ4gAyAGaiAAEMYgIgggB08NDSABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyAFKAIEIgBB//8BTQ0CIAUoAgBBAEGAgAT8CwALIAVBATYCKAsgCkUMAQtBgIACIABBvNbOABCwOwALDwsCfwJAIABBBGoiBSgCKCIKRQRAAkAgAUUgAkGAAktyRQRAIAJFDQEgBSgCACEBIAUoAgQhByAEIQADQCAEIAZJDQ0gAyAGaiAAEMcgIgggB08NDCABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyAFKAIEIgBB//8ATQ0CIAUoAgBBAEGAgAL8CwALIAVBATYCKAsgCkUMAQtBgIABIABBvNbOABCwOwALDwsCfwJAIABBCGoiBSgCQCIKRQRAAkAgAUUgAiAFKAIcIgFBBnZLckUEQCACRQ0BIAUoAgAhASAFKAIEIQcgBCEAA0AgBCAGSQ0MIAUgAyAGaiAAEJcdIgggB08NCyABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyABIAUoAgQiAEsNAiABRQ0AIAFBAXQiAEUNACAFKAIAQQAgAPwLAAsgBUEBNgJACyAKRQwBCyABIABBvNbOABCwOwALDwsgACgCLA0BAkAgACgCCCIBRQ0AIAFBAXQiAUUNACAAKAIEQQAgAfwLAAsgAEEBNgIsQQEPCyAAKAI0DQAgACgCCCICBEAgACgCBCEEIAAoAkAhASACQQJ0IQMDQCAEIAE2AgAgBEEEaiEEIANBBGsiAw0ACwsgAEEBNgI0QQEPC0EADwsgBSAEQcTNzgAQrzsACyABIAZB1M3OABCwOwALIAggB0Hc1s4AEMMhAAsgBiAEQczWzgAQrzsAC7UCAgR/AX4jAEEgayIDJAACQCABKAJsIgQgASgCcCIFciABKAJoIgJyRQ0AAkACQCAFDQAgAiAERwRAIARFIAJyDQEMAgsgBA0BCyACQQFrQQdJBEAgAUEYaiEEA0AgBCACQQN0akIANwMAIAEgASgCaEEBaiICNgJoIAJBCEkNAAsgASgCcCEFCyABIAIgBWo2AnAgAUEBEPoLIAFBADYCbAwBCyABEL0NCyADQRBqIgIgAUEQaikDADcDACADQQhqIgQgAUEIaikDADcDACADIAEpAwAiBjcDACADLQAUIQEgAyAGNwMYIAFBA3YgAUEHcUEAR2oiAUEJTwRAIAFBCEGQic8AELA7AAsgBCADQRhqIAEQoTYgAEEIaiACKAIANgIAIAAgAykDCDcCACADQSBqJAALrAICBX8BfiMAQUBqIgUkAEJ/IQogAkJ/USIHIANBACAEQQFHGyIGRXFFBEAgAiAGrXxC9ANCACAGG0IAIAcbfCEKCyAFQThqIgggCkKBgBBUIApCgYAIVGogCkKBgAFUakGEBWxBFiABIAFBFk8bQQAgAUEAThtBAyABG0EcbGoiBkH4+tAAaigCADYCACAFQTBqIgcgBkHw+tAAaikCADcDACAFQShqIgkgBkHo+tAAaikCADcDACAFIAZB4PrQAGopAgA3AyAgAUEASARAIAVBAEGAgHggASABQYCAeE0bazYCNAsgBUEYaiAIKAIANgIAIAVBEGogBykDADcDACAFQQhqIAkpAwA3AwAgBSAFKQMgNwMAIAAgBSACIAMgBEEAEOoLIAVBQGskAAuoAgIDfwJ9IwBBIGsiBSQAAkAgA0EBcUUEQAwBCyACRQRAQQAhAgwBCyACQQFrIQJDAAAAACABKAIAIgRB//8DcUECdEHMhuMAaioCACAEs5STIQcgAUEEaiEBCyACIANBfnEiBk8EQCAGBEAgA0ECdEF4cSECA0AgASgCACIDIARqIQQgByADQf//A3FBAnRBzIbjAGoqAgAgA7OUkyEHIAFBBGohASACQQRrIgINAAsLIAQEQCAEsyEIIAcCfSAEQYACTwRAIAgQ6hIMAQsgBEECdEHAh/MAaioCAAsgCJSSIQcLIAAgBDYCBCAAIAc4AgAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQayX0gA2AgggBUIENwIQIAVBCGpBtJfSABDvLAALuwIBBX8jAEEgayIDJAAgA0EQaiABQQFqQQBBBEEEEKAYIAMoAhQhBQJAAkAgAygCEEEBRwRAIANBADYCDCADIAMoAhgiBDYCCCADIAU2AgQgBQR/IAQFIANBBGpBwLeAARCdKCADKAIIC0EANgIAIANBATYCDCABBEBBBCEHQQAhBANAIAQgAiAEaiIESw0DIAZBAWoiBSADKAIERgRAIANBBGpBkLiAARCdKAsgAygCCCAHaiAENgIAIAMgBkECajYCDCAHQQRqIQcgBSIGIAFHDQALIARBAEgNAwsgA0EYaiADQQxqKAIANgIAIAMgAykCBDcDECAAIANBEGoQ6BggA0EgaiQADwsgBSADKAIYQbC3gAEQ/S8AC0Hwt4ABQQ5BgLiAARDLJAALQdC3gAFBD0Hgt4ABEMskAAvPAgENfyMAQdAAayICJAAgAkHEAGogARDYBgJAIAEoAiwiBgRAIAYgBigCACIDQQFqNgIAIANBAEgNASABKAI8IQkgASgCOCEKIAEoAjQhCyABKAIwIQwgASgCQCEICyABKAIMIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIUIgQgBCgCACIFQQFqNgIAIAVBAEgNACABKAIQIQ0gASgCICIFIAUoAgAiB0EBajYCACAHQQBIDQAgASgCHCEHIAEoAhghDiACQQhqIAJBzABqKAIANgIAIAIgAikCRDcDACACIAg2AkAgAiAJNgI8IAIgCjYCOCACIAs2AjQgAiAMNgIwIAIgBjYCLCACIAU2AiAgAiAHNgIcIAIgDjYCGCACIAQ2AhQgAiANNgIQIAIgAzYCDCACIAEpAiQ3AiQgACACEOAOIAJB0ABqJAAPCwALzwIBDX8jAEHQAGsiAiQAIAJBxABqIAEQ2AYCQCABKAIsIgYEQCAGIAYoAgAiA0EBajYCACADQQBIDQEgASgCPCEJIAEoAjghCiABKAI0IQsgASgCMCEMIAEoAkAhCAsgASgCDCIDIAMoAgAiBEEBajYCACAEQQBIDQAgASgCFCIEIAQoAgAiBUEBajYCACAFQQBIDQAgASgCECENIAEoAiAiBSAFKAIAIgdBAWo2AgAgB0EASA0AIAEoAhwhByABKAIYIQ4gAkEIaiACQcwAaigCADYCACACIAIpAkQ3AwAgAiAINgJAIAIgCTYCPCACIAo2AjggAiALNgI0IAIgDDYCMCACIAY2AiwgAiAFNgIgIAIgBzYCHCACIA42AhggAiAENgIUIAIgDTYCECACIAM2AgwgAiABKQIkNwIkIAAgAhDhDiACQdAAaiQADwsAC7wDAQd/IwBBEGsiCCQAAkAgBCADIARqIgJNBEAgAiAAKAIEIgZLDQEgACgCACADaiICIARqIQYgASgCDCIDIARqIgcgASgCBCIFSwRAIAEgBUEBdCIDIAcQ3SoiBSADIAVLGxDoGSABKAIEIQUgASgCDCEDCyAAQQhqIQcCQCAFIANBAWpJDQAgAyAEaiEAIActAAAhCSABKAIIIQoDQCAERQRAIAYhAiAAIQMMAgsgAyAKaiACLQAAIAlqOgAAIARBAWshBCACQQFqIQIgA0ECaiELIANBAWohAyAFIAtPDQALCyABIAM2AgwgCCAHNgIMIAggBjYCCCAIIAI2AgQgCEEEaiIDKAIAIgAgAygCBCICRwRAIAIgAGshBCABKAIMIQIgAygCCC0AACEDA0AgAC0AACEGIAJBAWoiBSABKAIEIgdLBH8gASAHQQF0IgIgBRDbKiIFIAIgBUsbEOgZIAEoAgwFIAILIAEoAghqIAMgBmo6AAAgASABKAIMQQFqIgI2AgwgAEEBaiEAIARBAWsiBA0ACwsgCEEQaiQADwsgAyACQcSchwEQsTsACyACIAZBxJyHARCwOwALzQICBH8EfiMAQcACayIBJAAgAUEIaiICIAAQlRogASkCjAEhBSABKQKUASEGIAEvAZwBIQAgAUGQAmogAUHwAGooAgA2AgAgAUGcAmogAUH8AGooAgA2AgAgAUHwAWogAUHQAGopAwA3AwAgAUH4AWogAUHYAGopAwA3AwAgAUGAAmogAUHgAGopAwA3AwAgASABKQNoNwOIAiABIAEpAnQ3ApQCIAEgASkDSDcD6AEgAS0AngEhAyABQagCaiABQYgBaigCADYCACABIAEpA4ABNwOgAiABKQM4IQcgASkDQCEIIAEtAJ8BIQQgAUGoAWogAkEw/AoAACABIAQ6AL8CIAEgAzoAvgIgASAAOwG8AiABIAY3ArQCIAEgBTcCrAIgASAINwPgASABIAc3A9gBIAFBADYCoAEgAUGgAWoQ0SlBCGogAUHAAmokAAvPAgEDfyMAQTBrIgIkACAAKAIAIQACQAJAIAFB/wFxRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiAyADQQFNGzYCNCAAKAIIGiAAQTBqIgNBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIANBARCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBEUNASACKAIAIAE6AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALeQEBfwJAAkACQAJAAkBBCyAAKAIAIgFBgICAgHhzIAFBAE4bDhAEAAQEBAQEAwQEBAEEBAQCAwsgAEEEahC8Kg8LIAAQ3jsgAC0ADEEDRw0BIAAoAhAiABC8KiAAQQxBBBD4Og8LIABBBGoQ3jsLDwsgAEEEahDeOwuqAgEEfyMAQUBqIgckACAHQQRqQQBBPPwLACAHQX82AgACQCAAIAJJBEADQAJAAkACQAJAIAEgAEEDdGoiAC4BBCIJQQBOBEAgBkEBaiIGIAVMDQEMBwsgBCAALgEGIgBNDQEgACADaiAGOgAAIAZBD0sNAkEAIAZrIQggByAGQQJ0aiEGA0AgBigCACIAQX9GBEAgBkEEayEGIAhBAWoiCEEBRw0BDAgLCyAGQX82AgBBACAIayEGDAMLIAZBD00EQCAHIAZBAnRqIAAuAQY2AgAgCSEADAMLIAZBEEGoj9IAEMMhAAsgACAEQYiP0gAQwyEACyAGQRBBmI/SABDDIQALIAAgAkkNAAsLIAAgAkH4jtIAEMMhAAsgB0FAayQAIAlBgIACcUEPdgu1AgIFfwJ+IwBBIGsiAyQAIANBEGogAUEBakEAQQhBCBCgGCADKAIUIQQCQCADKAIQQQFHBEAgA0EANgIMIAMgAygCGCIFNgIIIAMgBDYCBCAEBH8gBQUgA0EEakHAt4ABELMoIAMoAggLQgA3AwAgA0EBNgIMIAEEQEEAIQVBCCEGIAKtIgkhCEEAIQQDQCAEIAIgBGoiBEsNAyAFQQFqIgcgAygCBEYEQCADQQRqQZC4gAEQsygLIAMoAgggBmogCDcDACADIAVBAmo2AgwgBkEIaiEGIAggCXwhCCAHIgUgAUcNAAsLIANBGGogA0EMaigCADYCACADIAMpAgQ3AxAgACADQRBqEL0YIANBIGokAA8LIAQgAygCGEGwt4ABEP0vAAtB8LeAAUEOQYC4gAEQyyQAC8YCAQV/IwBBwAJrIgUkACABKALoAiIGQQhqEN4lIQcCQAJAAkACQCAGLwEYIggOAgABAgsgBUIFNwMADAILIAYvARoNACAGKAIUIgRBCGogBCgCCEECRkECdGotACAiBEEDRyAEQQBHcSEECyAFIAggBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNQDAELIAVB0ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQEEAIgRFBEAgBUHwAWogBUHQAPwKAAALIARFBEAgBUGgAWogBUHQAGpB0AD8CgAACyABEOEfIAEgBUGgAWpBoAH8CgAAIAFCADcClAIgASAGNgKQAiABIAM2AowCIAEgAjYCiAIgASAHNgKAAiABQQA2AvABIAFCBjcDoAEgAUGcAmpBADoAACAAQQg2AgAgBUHAAmokAA8LAAvHAgIEfwR+IwBBQGoiAiQAIAAoAgAiBSgCACEDIAJBEGoiBCAAKAIEKAIQIAFBAnRqNAIAIgYgBkI/hxCyLiAEIAIpAxAgAikDGCACKQMgIAIpAyggAygCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBEEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBSgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkFAayQADwsgACADQYiL/wAQwyEAC8cCAgR/BH4jAEFAaiICJAAgACgCACIFKAIAIQMgAkEQaiIEIAAoAgQoAhAgAUEDdGopAwAiBiAGQj+HELIuIAQgAikDECACKQMYIAIpAyAgAikDKCADKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAEQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAFKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDsDiACQUBrIgQgAUEwahDWFAJAAkBBDEEEEK02IgEEQCABQoKEiJCgwICBAjcCACABQQhqQYKEiBA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQvRUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJgUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQngggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO4OIAJBQGsiBCABQTBqENAUAkACQEEMQQQQrTYiAQRAIAFChIiQoMCAgYIENwIAIAFBCGpBhIiQIDYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCbFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCiCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDsDiACQUBrIgQgAUEwahDQFAJAAkBBDEEEEK02IgEEQCABQoSIkKDAgIGCBDcCACABQQhqQYSIkCA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQmxUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJgUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQogggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO4OIAJBQGsiBCABQTBqENYUAkACQEEMQQQQrTYiAQRAIAFCgoSIkKDAgIECNwIAIAFBCGpBgoSIEDYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBC9FSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCeCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCYFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDtDiACQUBrIgQgAUEwahDOFAJAAkBBDEEEEK02IgEEQCABQoOGjJiw4MCBAzcCACABQQhqQYOGjBg2AgBBDEEEEK02IgNFDQEgA0KYsODAgYOGjBg3AgAgA0EIakGYsODAATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQnBUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQpAggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqENsUAkACQEEMQQQQrTYiAQRAIAFChYqUqNCgwYIFNwIAIAFBCGpBhYqUKDYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCaFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCgCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQzhQCQAJAQQxBBBCtNiIBBEAgAUKDhoyYsODAgQM3AgAgAUEIakGDhowYNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJwVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCYFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKQIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDQFAJAAkBBDEEEEK02IgEEQCABQoSIkKDAgIGCBDcCACABQQhqQYSIkCA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQmxUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQogggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqEM4UAkACQEEMQQQQrTYiAQRAIAFCg4aMmLDgwIEDNwIAIAFBCGpBg4aMGDYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCcFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCkCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQzhQCQAJAQQxBBBCtNiIBBEAgAUKDhoyYsODAgQM3AgAgAUEIakGDhowYNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJwVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKQIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDWFAJAAkBBDEEEEK02IgEEQCABQoKEiJCgwICBAjcCACABQQhqQYKEiBA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQvRUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQngggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqENYUAkACQEEMQQQQrTYiAQRAIAFCgoSIkKDAgIECNwIAIAFBCGpBgoSIEDYCAEEMQQQQrTYiA0UNASADQpiw4MCBg4aMGDcCACADQQhqQZiw4MABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBC9FSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmRQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCeCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ0BQCQAJAQQxBBBCtNiIBBEAgAUKEiJCgwICBggQ3AgAgAUEIakGEiJAgNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJsVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKIIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAvMAgEFfyMAQdAAayIEJAAgBCACNgIMAkACQCABKAIIIgUgAksEQCAEIAEoAigiBiADaiIFQQN0Igc2AhAgAAJ/IAcgASgCBCACQQxsaiICKAIIIghNBEAgBCACEMUbIAUgBkkNAyAFIAQoAgQiAUsNBCAEKAIAIQEgACADNgIIIAAgASAGQQN0ajYCBEGTgICAeAwBCyAEIAg2AiwgBEGk7YYBNgIUIARCBDcCICAEQTs2AkwgBEE7NgJEIARBrQM2AjwgBCABQRhqNgI4IARBOzYCNCAEQQQ2AhggBCAEQTBqNgIcIAQgBEEsajYCSCAEIARBEGo2AkAgBCAEQQxqNgIwIABBBGogBEEUahCZDkGNgICAeAs2AgAgBEHQAGokAA8LIAIgBUHQ7IYBEMMhAAsgBiAFQeDshgEQsTsACyAFIAFB4OyGARCwOwALzAIBBX8jAEHQAGsiBCQAIAQgAjYCDAJAAkAgASgCCCIFIAJLBEAgBCABKAIoIgYgA2oiBUECdCIHNgIQIAACfyAHIAEoAgQgAkEMbGoiAigCCCIITQRAIAQgAhDHGyAFIAZJDQMgBSAEKAIEIgFLDQQgBCgCACEBIAAgAzYCCCAAIAEgBkECdGo2AgRBk4CAgHgMAQsgBCAINgIsIARBpO2GATYCFCAEQgQ3AiAgBEE7NgJMIARBOzYCRCAEQa0DNgI8IAQgAUEYajYCOCAEQTs2AjQgBEEENgIYIAQgBEEwajYCHCAEIARBLGo2AkggBCAEQRBqNgJAIAQgBEEMajYCMCAAQQRqIARBFGoQmQ5BjYCAgHgLNgIAIARB0ABqJAAPCyACIAVB0OyGARDDIQALIAYgBUHg7IYBELE7AAsgBSABQeDshgEQsDsAC7UCAQZ/IwBBEGsiAyQAIAAEQCADQQhqIAAoAgAQkTUgAygCDCEBIAMoAggiAkEAOgAAIAEEQCACIAFBARD4OgsCQCAAKAIEIgFFDQAgAyABEJE1IAMoAgQhASADKAIAIgJBADoAACABRQ0AIAIgAUEBEPg6CyAAKAIsIgEEQCABKAIQIgQEQCABKAIMIQIgBEECdCEEA0AgAigCACIFKAIoIgYEQCAFIAYRAwALIAJBBGohAiAFQTBBCBD4OiAEQQRrIgQNAAsLIAEoAhQiAgRAIAIoAigiBARAIAIgBBEDAAsgAkEwQQgQ+DoLIAEoAhAiAgRAIAEoAgwgAkECdEEEEPg6CyABKAIAQYCAgIB4RwRAIAFBAUEBEOAeCyABQRhBBBD4OgsgAEEANgIoCyADQRBqJAALxwICBX8EfiMAQUBqIgIkACAAKAIAIgUoAgAhAyACQRBqIgQgACgCBCgCECABQQR0aiIGKQMAIAYpAwgQsi4gBCACKQMQIAIpAxggAikDICACKQMoIAMoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIARBBHIQiBEMAQsgAikDICIHIAIpAygiCCACKQMwIgkgAikDOCIKIAUoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAo3AxggACAJNwMQIAAgCDcDCCAAIAc3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBQGskAA8LIAAgA0GIi/8AEMMhAAuWAwEGfyMAQSBrIgQkAAJAIAAoAiggASgCKEcNACAAKAIkIAEoAiRHDQAgAEEYaiABQRhqEMkIRQ0AIAAoAggiBSABKAIIRw0AIAAoAhQiBiABKAIURw0AIAEoAiwhAgJAIAAoAiwEQCACRQ0CIABBLGogAUEsahCTLA0BDAILIAINAQsCQCAFRQ0AIAAoAgRBBGohAyABKAIEQQRqIQIDQCADKAIAIAIoAgBGBEAgA0EMaiEDIAJBDGohAiAHQQFqIgcgBUcNAQwCCwtBACEDIAUgB0sNAQsgBEEANgIYIAQgASgCECIBNgIQIAQgACgCECIANgIIIAQgBjYCHCAEIAEgBkHEAGwiA2o2AhQgBCAAIANqNgIMIARBCGoiASgCECIAIAEoAhQiBiAAIAZLGyEDIABBxABsIgIgASgCCGohBSABKAIAIAJqIQICQANAIAAgA0YNASABIABBAWoiADYCECACIAUQohEgBUHEAGohBSACQcQAaiECDQALIABBAWshAwsgAyAGTyEDCyAEQSBqJAAgAwutAgEEfyMAQSBrIgUkACAFQRRqIAIgBGpBAWpB8IyIARC/FSAFKAIUIQggBSgCGCIHIAUoAhwiBiABIAIgAyAEEIsBIAUgBjYCHCAFIAc2AhggBSAINgIUAkAgBkUNACAHIAZBAnQiBGpBBGsiAUUNACABKAIADQAgB0EEayEBIAZB/////wNxIQICQANAIARFBEBBACEEDAILIAJBAWshAiABIARqIARBBGshBCgCAEUNAAsgAkEBaiIEIAZLDQELIAUgBDYCHCAEIQYLAkAgBiAIQQJ2Tw0AIAVBCGogBUEUaiAGQQRBBBD0FCAFKAIIIgFBgYCAgHhGDQAgASAFKAIMQcyNiAEQ/S8ACyAAIAUpAhQ3AgAgAEEIaiAFQRxqKAIANgIAIAVBIGokAAukAgECfyMAQRBrIgIkACACQQA2AgwCfwJAIAFBgAFPBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAwsgAiABQT9xQYABcjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwCCyACIAE6AAxBAQwBCyACIAFBP3FBgAFyOgANIAIgAUEGdkHAAXI6AAxBAgsiASAAKAIIIgAoAgAgACgCCCIDa0sEQCAAIAMgARCFEyAAKAIIIQMLIAEEQCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYCCCACQRBqJABBAAvMAgIJfwF+IwBBIGsiAiQAIAJBCGogARDLEwJAAkACQCACKAIIQQFGBEAgAigCDCEBIAIpAxAhCyAAIAIpAxg3AgwgACALNwIEIAAgATYCAAwBCyACKAIQIgQhAyABKAIMIgkhBgJAIAEoAhAiByAETyIKDQAgAkEIahC0HiACKAIQIQMgAigCDCEGIAIoAggiBUEERg0AIAAgAikCFDcCDCAAIAM2AgggACAGNgIEIAAgBTYCAAwBCyACQQhqIANBAEEBQQEQoBggAigCDCEFIAIoAghBAUYNASACKAIQIQggAwRAIAggBiAD/AoAAAsgCkUNAiAAIAM2AgwgACAINgIIIAAgBTYCBCAAQQQ2AgAgASAHIARrNgIQIAEgBCAJajYCDAsgAkEgaiQADwsgBSACKAIQQdinzgAQ/S8ACyAEIAdBtLPOABCvOwALxQIBAX8jAEEgayIFJAAgBUEEaiAAKAIMIgBBCGogACgCCEECRkECdGoQiRkCQAJAIAUtAARBDUYEQCABKAIARQ0CAkACQAJAIAEoAggOAgABAgtBAEEAQdCEzwAQwyEAC0EBQQFB4ITPABDDIQALIAEoAgQiAC0AAUEIdEGA/gFxIAAtAAByQYD4AUsNAQsgAkEEaiEAIAIoAgBBAUYEQCADIAAgBBCJDUUNAQsCQCABKAIAIgMEQCAFQRBqIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgBUEANgIQCwJAIAIoAgBFDQAgACgCACIBRQ0AIAJBEGogAigCCCACKAIMIAEoAhARAQALIAJBATYCACAAIAUpAhA3AgAgAEEIaiAFQRhqKQIANwIACyAFQSBqJAAPC0Hkh84AQSBBhIjOABDLJAALxQIBAX8jAEEgayIFJAAgBUEEaiAAKAIMIgBBCGogACgCCEECRkECdGoQiRkCQAJAIAUtAARBDUYEQCABKAIARQ0CAkACQAJAIAEoAggOAgABAgtBAEEAQdCEzwAQwyEAC0EBQQFB4ITPABDDIQALIAEoAgQiAC0AAUEIdEGA/gFxIAAtAAByQYD4AUsNAQsgAkEEaiEAIAIoAgBBAUYEQCADIAQgABCJDUUNAQsCQCABKAIAIgMEQCAFQRBqIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgBUEANgIQCwJAIAIoAgBFDQAgACgCACIBRQ0AIAJBEGogAigCCCACKAIMIAEoAhARAQALIAJBATYCACAAIAUpAhA3AgAgAEEIaiAFQRhqKQIANwIACyAFQSBqJAAPC0Hkh84AQSBBhIjOABDLJAALoQIBA38jAEEgayIFJAAgBUEANgIEAkACQAJAAkAgAUEDSwRAIAVBBGoiBkEEIABBBEGojtIAENUsIAUoAgQhByAFQQA2AgQgA0EDTQ0EIAZBBCACQQRBqI7SABDVLAJAAn9BACAHIAUoAgRHDQAaQQEgBEEERg0AGiABQQRGDQMgA0EERg0EQQAgAC0ABCACLQAERw0AGiABQQVGDQUgA0EFRg0BIAAtAAUgAi0ABUYLIAVBIGokAA8LQQVBBUGogtIAEMMhAAsMAwtBBEEEQfiB0gAQwyEAC0EEQQRBiILSABDDIQALQQVBBUGYgtIAEMMhAAsgBUEANgIYIAVBATYCDCAFQcD/0QA2AgggBUIENwIQIAVBCGpBmI7SABDvLAALtQIBBH8jAEEwayICJAAgAEEEIAAoAjQiBCAEQQRNGzYCNCAAQTBqIQQCQEEAIAAoAjAiBWtBA3EiAyAAKAIIIAVrTQ0AIAAoAgggACgCMGsgA08NAANAIAAQ+xYgACgCCCAAKAIwayADSQ0ACwsgBCADEI03IAAoAgggACgCMGtBA0siAyADckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IAJBEGogABDcOyACKAIUIQMgAigCECEFIAJBCGogACgCMBCMNyACIAUgAyACKAIIIAIoAgxBsLf+ABDXJiACKAIEQQNNBEAgAkEANgIoIAJBATYCHCACQey3/gA2AhggAkIENwIgIAJBGGpBwLf+ABDvLAALIAIoAgAgATYAACAEKAIAIAJBMGokAAu1AgEEfyMAQTBrIgIkACAAQQQgACgCNCIEIARBBE0bNgI0IABBMGohBAJAQQAgACgCMCIFa0EDcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EDSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAEQQQQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQUgAkEIaiAAKAIwEIw3IAIgBSADIAIoAgggAigCDEGsx/4AENcmIAIoAgRBA00EQCACQQA2AiggAkEBNgIcIAJB9Mj+ADYCGCACQgQ3AiAgAkEYakG8x/4AEO8sAAsgAigCACABNgAAIAQoAgAgAkEwaiQAC7ACAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtB3OOAARCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEGIAAoAgQgAUkEQCABEM8qIQIgACAAKAIEQQF0IgcgAiACIAdJGxDoGSAAKAIMIQILIAZFDQAgACgCCCACakH/ASAG/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQezjgAEQsjsACyAAIAQ2AhAgA0EQaiQAC9YCAQF/IwBBMGsiAiQAAn8CQAJAAkACQAJAAkAgACgCAEEBaw4FAQIDBAUACyAAQQRqKAIAIAEQnwQMBQsgACgCBCABELkJDAQLIAIgAEEEajYCDCACQQI2AhQgAkGkmcMANgIQIAJCATcCHCACQYQBNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMAwsgAiAAQQRqNgIMIAJBAjYCFCACQcSZwwA2AhAgAkIBNwIcIAJBhQE2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwCCyACIABBBGo2AgwgAkECNgIUIAJB6JnDADYCECACQgE3AhwgAkGEATYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAELIAFB+JnDAEEREPs1CyACQTBqJAALugIBBX8gACgCGCEDAkACQCAAIAAoAgwiAUYEQCAAQRRBECAAKAIUIgEbaigCACICDQFBACEBDAILIAAoAggiAiABNgIMIAEgAjYCCAwBCyAAQRRqIABBEGogARshBANAIAQhBSACIgFBFGogAUEQaiABKAIUIgIbIQQgAUEUQRAgAhtqKAIAIgINAAsgBUEANgIACwJAIANFDQACQAJAIAAoAhwiAkECdEGo8IoBaiIEKAIAIABHBEACQCAAIAMoAhBHBEAgAyABNgIUDAELIAMgATYCEAsgAQ0BDAMLIAQgATYCACABRQ0BCyABIAM2AhggACgCECICBEAgASACNgIQIAIgATYCGAsgACgCFCIARQ0BIAEgADYCFCAAIAE2AhgPC0HE84oBQcTzigEoAgBBfiACd3E2AgALC8QCAQN/IwBBMGsiAyQAAkACQCACRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiBCAEQQFNGzYCNCAAKAIIGiAAQTBqIgRBABCNNyAAKAIIIAAoAjBHIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIARBARCNNyADQRBqIAAQ3DsgAygCFCEEIAMoAhAhBSADQQhqIAAoAjAQjDcgAyAFIAQgAygCCCADKAIMQbC3/gAQ1yYgAygCBEUNASADKAIAIAI6AAAgACgCMCEEIAAoAhQiAiAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECACQQN0aiIFIAE7AQQgBSAENgIAIAAgAkEBajYCFAsgA0EwaiQADwsgA0EANgIoIANBATYCHCADQey3/gA2AhggA0IENwIgIANBGGpBwLf+ABDvLAALvQICA34DfyMAQRBrIgYkAEKAgICAgICAgIB/IQMCQAJAAkACfgJAAkAgACgCBCgCECABQQN0aikDACIEQoCAgICAgICAgH9SIAAoAgAiBygCACIFKAIAKQMAIgJCf1JyRQRAQgAhAgwBCyACUA0EIAQgBCACfyIDIAJ+fUIAIAJCf1IbIQIgBEIAWQ0BCyADIAIgBSgCCCkDAFetfQwBCyADIAIgBSgCBCkDAFmtfAsiAiAHKAIELQAAEMUpBEAgACgCCCABQQN0aiACNwMADAELIAAoAhAiBSAFKAIAQQFqNgIAIAZBCGogACgCFBCGPSABQQN2IgAgBigCDCIFTw0CIAYoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAGQRBqJAAPC0G8j/8AEOIrAAsgACAFQYiL/wAQwyEAC74CAQp/IwBBMGsiAiQAIAEoAgQhBSABKAIAIQcCQAJAIAAoAgAiBCAAKAIEIgNHBEAgASgCCCEIIAAoAhQhBiAAKAIQIQkgACgCDCEKIAAoAgghACADIARrQQN2IQEDQCACIAQ2AgwCQCAEKAIAIgMgCUkEQCADIApqLQAAIQMMAQsgACAGKAIQTw0DQQAhAyAGKAIEIAAgBigCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgBSAIaiADOgAAIARBCGohBCAAQQFqIQAgBUEBaiEFIAFBAWsiAQ0ACwsgByAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG6EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALvgIBCn8jAEEwayICJAAgASgCBCEFIAEoAgAhBwJAAkAgACgCACIEIAAoAgQiA0cEQCABKAIIIQggACgCFCEGIAAoAhAhCSAAKAIMIQogACgCCCEAIAMgBGtBA3YhAQNAIAIgBDYCDAJAIAQoAgAiAyAJSQRAIAMgCmotAAAhAwwBCyAAIAYoAhBPDQNBACEDIAYoAgQgACAGKAIMaiILQQN2ai0AACALQQdxdkEBcQ0ECyAFIAhqIAM6AAAgBEEIaiEEIABBAWohACAFQQFqIQUgAUEBayIBDQALCyAHIAU2AgAgAkEwaiQADwtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAu+AgEKfyMAQTBrIgIkACABKAIEIQUgASgCACEHAkACQCAAKAIAIgQgACgCBCIDRwRAIAEoAgghCCAAKAIUIQYgACgCECEJIAAoAgwhCiAAKAIIIQAgAyAEa0ECdiEBA0AgAiAENgIMAkAgCSAEKAIAIgNLBEAgAyAKai0AACEDDAELIAAgBigCEE8NA0EAIQMgBigCBCAAIAYoAgxqIgtBA3ZqLQAAIAtBB3F2QQFxDQQLIAUgCGogAzoAACAEQQRqIQQgAEEBaiEAIAVBAWohBSABQQFrIgENAAsLIAcgBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC74CAQp/IwBBMGsiAiQAIAEoAgQhBSABKAIAIQcCQAJAIAAoAgAiBCAAKAIEIgNHBEAgASgCCCEIIAAoAhQhBiAAKAIQIQkgACgCDCEKIAAoAgghACADIARrQQJ2IQEDQCACIAQ2AgwCQCAJIAQoAgAiA0sEQCADIApqLQAAIQMMAQsgACAGKAIQTw0DQQAhAyAGKAIEIAAgBigCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgBSAIaiADOgAAIARBBGohBCAAQQFqIQAgBUEBaiEFIAFBAWsiAQ0ACwsgByAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkHtBjYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALvAIBBH8jAEHQAGsiAyQAIAAgACgCCCACQQRBBEGwsYMBEMMoIAMgAUHAAPwKAAAgA0HEAGogAxDVCQJAAkACQCADKAJEQQFGBEADQCADKAJIIgIgAygCTCIFSQRAIAJBAnQhAQNAIAIgACgCHCIETw0EIAJBAWoiBiAETw0FIAAoAhggAWoiAkEEaigCACACKAIAayICQQBIDQYgACAAKAIoIAJqIgQ2AiggACgCCCICIAAoAgBGBEAgAEHAsYMBEJ0oCyAAKAIEIAJBAnRqIAQ2AgAgACACQQFqNgIIIAFBBGohASAGIgIgBUcNAAsLIANBxABqIAMQ1QkgAygCRA0ACwsgA0HQAGokAA8LIAIgBEGcsIMBEMMhAAsgAkEBaiAEQZywgwEQwyEAC0GssIMBQRRBwLCDARDLJAALrgIBAn8gASgCCCEEAn8CQAJAAkAgASgCBCACaiICIAJBgKMFbSIDQYCjBWxrIgJBH3UgA2pBAWoOAwEAAgALIAEoAgAMAgsCfyABKAIAIgFB8D9xIgNBEE0EQCABQQ11QQFrIgEgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAABB8DNyEMYkDAELIANBEGsgAUGPQHFyCyIBQeetgIB4IAEbDAELIAEoAgAiA0H4P3EiAUHRLU8EQEGfwP//ByADQQ11IgNB/v8Pa0GCgGBJDQEaIANBAWoiAUENdCABQZADbyIBQR91QZADcSABakH0yYYBai0AAHJBEHIMAQsgAUEQaiADQYdAcXILIQEgACAENgIIIAAgATYCACAAIAJBgKMFaiACIAJBAEgbNgIEC6UCAQN/AkACQCABKAIAQQFGBEAgAUEEaiECDAELIAEoAggEQCABQQxqIQIMAQsgASgCGCECIAEoAhQhAwJAAkAgASgCMCIBRQ0AIAEgAk8EQCABIAJGDQEMAgsgASADaiwAAEG/f0wNAQsgASADaiEDDAILIAMgAiABIAJB4JfEABCjNgALIAEoAhghAyABKAIUIQQCQCACKAIAIgIgASgCMCIBSQ0AAkAgAUUNACABIANPBEAgASADRw0CDAELIAEgBGosAABBv39MDQELAkAgAkUNACACIANPBEAgAiADRw0CDAELIAIgBGosAABBv39MDQELIAEgBGohAwwBCyAEIAMgASACQdCXxAAQozYACyACIAFrIQEgACABNgIEIAAgAzYCAAuYAgIEfwF+IwBBIGsiBiQAAkAgBUUNACACIANqIgMgAkkNACAEIAVqQQFrQQAgBGtxrSADIAEoAgAiCEEBdCICIAIgA0kbIgJBCEEEQQEgBUGBCEkbIAVBAUYbIgMgAiADSxsiA61+IgpCIIinDQAgCqciCUGAgICAeCAEa0sNAAJ/IAhFBEAgBkEYaiEHQQAMAQsgBkEcaiEHIAYgBDYCGCAGIAEoAgQ2AhQgBSAIbAshBSAHIAU2AgAgBkEIaiAEIAkgBkEUahC+GiAGKAIIQQFGBEAgBigCECECIAYoAgwhBwwBCyAGKAIMIQQgASADNgIAIAEgBDYCBEGBgICAeCEHCyAAIAI2AgQgACAHNgIAIAZBIGokAAuoEQIWfwR+IwBBEGsiDiQAAkAgAS0AhAFFDQAgASgCfCgCFCIFQQhqIAUoAghBAkZBAnRqLQAhQRZGDQAgDkEIaiEKIAIiBSADIAVqIg1GBH9BAgUCQCANIAVBAWoiBEYEQCAFIQkMAQsgBS0AACIGIQcgBSEJA0AgBCAFIAQtAAAiCCAGQX9zcUEBcSILGyEFIAggBiALGyEGIAQgCSAHIAhBf3NxQQFxIgsbIQkgCCAHIAsbIQcgBEEBaiIEIA1HDQALCyAFLQAAIQYgCS0AAAshBSAKIAY6AAEgCiAFOgAAIA4tAAgiBUECRg0AIA4tAAkhCSABLQCFASIEQQJHIAVBAXMgBHFBAXFFcUUEQCABIAVBAXE6AIUBCyABLQCGASIFQQJHIAkgBUEBc3FBAXFFcQ0AIAEgCUEBcToAhgELIANFIAEoAnBBgICAgHhGckUEQCABQfAAaiEEIAMhCSACIQUDQCAEIAVBARCGChCiFSAFQQFqIQUgCUEBayIJDQALCwJAIAEoAlhBgICAgHhHBEAgAUEQaiIBQcgAaiADEOwtIAMEQANAIwBBMGsiDSQAIA1BGGohCSABQRBqIgcgAkEBEM0CIRwgAUEwaiEFQQAhBkEAIQtBACEPQQAhEUEAIRIjAEEQayITJAAgASgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCAFNgIcIAQgBzYCGCABKAIMIQggBCAEQRhqNgIgAkACQAJAAkACQCAIIAhBAWoiB00EQCABKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAdJBEAgCEEBaiIGIAcgBiAHSxsiBkEPSQ0CIAZB/////wFNBEBBfyAGQQN0QQduQQFrZ3ZBAWohBgwECxDdJyAEKAIUIQYgBCgCECIHQYGAgIB4Rw0FDAMLIAEgBEEgakG8pc8AEOsJDAMLEN0nIAQoAgQhBiAEKAIAIQcMAwtBBEEIQRAgBkEISRsgBkEESRshBgsgBEHQAGogAUEQaiIKQQggBhD7FCAEKAJYIQYgBCgCVCEHIAQoAlAiCEUNASAEIAQoAlw2AkwgBCAGNgJIIAQgBzYCRCAEIAg2AkAgBEEIaiAEQUBrEME0IAQoAgwiBgRAIAQoAghB/wEgBvwLAAsgBCgCSCEGIAQoAkQhByAEKAJAIghFDQEgBCAEKAJMNgI8IAQgBjYCOCAEIAc2AjQgBCAINgIwIARCiICAgIABNwIoIAQgCjYCJCAEIAEoAgwiFQR/IAhBCGohFyABKAIAIhYpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCALQQhqIQsgFkEIaiIWKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIgIgwoAgQiECgCCCIYIAEoAgAgGnqnQQN2IAtqQQN0IhlrQQhrKAIAIgpNDQQgCCAHIAwoAgAgECgCBCAKakEBEM0CpyIQcSIKaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAogDGohCiAMQQhqIQwgCCAHIApxIgpqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogCCAbeqdBA3YgCmogB3EiCmosAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCCAKaiAQQRl2Igw6AAAgFyAKQQhrIAdxaiAMOgAAIAggCkEDdGtBCGsgASgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgASgCDAVBAAsiBzYCPCAEIAYgB2s2AjggASAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBwsgFCAGNgIEIBQgBzYCACAEQeAAaiQADAELIAogGEGUkM4AEMMhAAsLIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gBSgCBCELIAUoAgghCCABKAIAIQcDQAJAIAQgB2opAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkACQCAJAn4CQANAIBpQDQEgCCABKAIAIBp6p0EDdiAEaiAGcSIMQQN0a0EIaygCACIKTQ0DIBpCAX0gGoMhGiACQQEgCiALakEBEJ87RQ0ACyAJIBw3AwggCSABKAIAQQAgDGtBA3RqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAyAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0DGiAJIAcgD2osAABBAE4EfyAHKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAkgHDcDCEIBCzcDACAJIAE2AhQgE0EQaiQADAMLIAogCEGUkM4AEMMhAAtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgDUEIaiEEAkAgCSgCAEEBRgRAIAkpAwghGiAJKAIQIQYgCSgCFCEJIAUgBSgCDEEBajYCDCACLQAAIQggBSgCCCIHIAUoAgBGBEAgBUGkkM4AEKMoCyAFKAIEIAdqIAg6AAAgBSAHQQFqNgIIIAYgCSgCACIFaiIILQAAIQogCCAap0EZdiIIOgAAIAUgCSgCBCAGQQhrcWpBCGogCDoAACAEIAk2AgwgBCAaNwMAIAkgCSgCDEEBajYCDCAEIAUgBkEDdGsiBTYCCCAJIAkoAgggCkEBcWs2AgggBUEIayAHrTcDAAwBCyAEIAlBCGoiBSkDADcDACAEQQhqIAVBCGopAwA3AwALIA0oAhBBCGspAwAhGiANQTBqJAAgASgCUCIFIAEoAkhGBEAgAUHIAGpB1JDOABCzKAsgASgCTCAFQQN0aiAaNwMAIAEgBUEBajYCUCACQQFqIQIgA0EBayIDDQALCyAAQQg2AgAMAQsgACABKAJoIAIgAyABKAJsKAIMEQUACyAOQRBqJAAL5AMBBX8jAEEgayIDJAACQAJAIAAoApQKIgIgACgChAoiBUcNACADIAJBAXQQ+SYgAiADKAIEIgVLDQEgAygCACEEIAJBFGwiAgRAIAQgACgCgAogAvwKAAALIAAoAoQKIQIgACAFNgKECiAAKAKACiAAIAQ2AoAKIAJFDQAgAkEUbEEEEPg6CwJAIAUgACgClAoiBEcEQCADQQhqIQICQAJAAkACQAJAAkACQAJAIAEtAAAiBkEBaw4GAQIDBAUGAAsgAiABKQIENwIEDAYLIAIgASkCBDcCBAwFCyACIAEtABA6AAwgAiABKQIIQiCJNwIEDAQLIAIgAS0AAToAAQwDCyACIAEvAAE7AAEMAgsgAiABLQABOgABDAELIAIgASgCFDYCECACIAEoAhg2AgwgAiABKAIINgIIIAIgASgCDDYCBAsgAiAGOgAAIAQgBUkEQCAAKAKACiAEQRRsaiIBIAMpAgg3AgAgAUEIaiADQRBqKQIANwIAIAFBEGogA0EYaigCADYCACAAIARBAWo2ApQKDAILIAQgBUGEn9AAEMMhAAsgAEEBOgCjCgsgA0EgaiQADwsgA0EANgIYIANBATYCDCADQfig0AA2AgggA0IENwIQIANBCGpB9J7QABDvLAALmgIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBBDRKCAAKAIIBSACCyAAKAIEaiECAkACQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoAAyACIAFBEnZB8AFyOgAAIAIgAUEGdkE/cUGAAXI6AAIgAiABQQx2QT9xQYABcjoAAQwDCyACIAFBP3FBgAFyOgACIAIgAUEMdkHgAXI6AAAgAiABQQZ2QT9xQYABcjoAAQwCCyACIAE6AAAMAQsgAiABQT9xQYABcjoAASACIAFBBnZBwAFyOgAACyAAIAMgBGo2AghBAAvBAgEEfyMAQTBrIgEkAAJAIAAoAgAiAC0AOkEBRgRAIABBASAAKAI0IgIgAkEBTRs2AjQgACgCCBogAEEwaiICQQAQjTcgACgCCCAAKAIwRyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBGDQALCyACQQEQjTcgAUEQaiAAENw7IAEoAhQhAiABKAIQIQMgAUEIaiAAKAIwEIw3IAEgAyACIAEoAgggASgCDEGsx/4AENcmIAEoAgRFDQEgASgCAEEAOgAAIAAoAjAhAyAAKAIUIgIgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAkEDdGoiBEEGOwEEIAQgAzYCACAAIAJBAWo2AhQLIAFBMGokAA8LIAFBADYCKCABQQE2AhwgAUH0yP4ANgIYIAFCBDcCICABQRhqQbzH/gAQ7ywAC9wCAgJ/AX4jAEHgAGsiAyQAIANBBGogASgCDCgCECACQQN0aikDACIFIAEoAggoAgAoAgAQzyUCQAJAIAMoAgQEQCADQSBqIANBDGopAgA3AgAgAyADKQIENwIYIANBk4CAgHg2AhQgA0EwaiADQRhqIAMoAiQQ9xEgAygCMCIEDQFBx5D/AEErQfSQ/wAQyyQACyADIAU3AyggA0EnNgJMIANBg4//ADYCSCADQQM2AjQgA0HEkv8ANgIwIANCAjcCPCADQe4GNgJcIANBzAE2AlQgAyADQdAAajYCOCADIANBKGo2AlggAyADQcgAajYCUCADQRhqIANBMGoQmQ4gACADKQIcNwIIIABBEGogA0EkaigCADYCACAAIAMoAhg2AgQgAEGCgICAeDYCAAwBCyAEEMUkIQQgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANB4ABqJAAL3AICAn8BfiMAQeAAayIDJAAgA0EEaiABKAIMKAIQIAJBA3RqKQMAIgUgASgCCCgCACgCABDOJQJAAkAgAygCBARAIANBIGogA0EMaikCADcCACADIAMpAgQ3AhggA0GTgICAeDYCFCADQTBqIANBGGogAygCJBD3ESADKAIwIgQNAUHHkP8AQStB9JD/ABDLJAALIAMgBTcDKCADQSw2AkwgA0Gsjv8ANgJIIANBAzYCNCADQcSS/wA2AjAgA0ICNwI8IANB7gY2AlwgA0HMATYCVCADIANB0ABqNgI4IAMgA0EoajYCWCADIANByABqNgJQIANBGGogA0EwahCZDiAAIAMpAhw3AgggAEEQaiADQSRqKAIANgIAIAAgAygCGDYCBCAAQYKAgIB4NgIADAELIAQQxSQhBCAAQZOAgIB4NgIAIAEoAgAgAkECdGogBDYCAAsgA0HgAGokAAvcAgICfwF+IwBB4ABrIgMkACADQQRqIAEoAgwoAhAgAkEDdGopAwAiBSABKAIIKAIAKAIAEMwlAkACQCADKAIEBEAgA0EgaiADQQxqKQIANwIAIAMgAykCBDcCGCADQZOAgIB4NgIUIANBMGogA0EYaiADKAIkEPcRIAMoAjAiBA0BQceQ/wBBK0H0kP8AEMskAAsgAyAFNwMoIANBLDYCTCADQYCO/wA2AkggA0EDNgI0IANBxJL/ADYCMCADQgI3AjwgA0HuBjYCXCADQcwBNgJUIAMgA0HQAGo2AjggAyADQShqNgJYIAMgA0HIAGo2AlAgA0EYaiADQTBqEJkOIAAgAykCHDcCCCAAQRBqIANBJGooAgA2AgAgACADKAIYNgIEIABBgoCAgHg2AgAMAQsgBBDFJCEEIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIACyADQeAAaiQAC9wCAgJ/AX4jAEHgAGsiAyQAIANBBGogASgCDCgCECACQQN0aikDACIFIAEoAggoAgAoAgAQzSUCQAJAIAMoAgQEQCADQSBqIANBDGopAgA3AgAgAyADKQIENwIYIANBk4CAgHg2AhQgA0EwaiADQRhqIAMoAiQQ9xEgAygCMCIEDQFBx5D/AEErQfSQ/wAQyyQACyADIAU3AyggA0ErNgJMIANB2I7/ADYCSCADQQM2AjQgA0HEkv8ANgIwIANCAjcCPCADQe4GNgJcIANBzAE2AlQgAyADQdAAajYCOCADIANBKGo2AlggAyADQcgAajYCUCADQRhqIANBMGoQmQ4gACADKQIcNwIIIABBEGogA0EkaigCADYCACAAIAMoAhg2AgQgAEGCgICAeDYCAAwBCyAEEMUkIQQgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANB4ABqJAALsgICBn8BfiMAQRBrIgMkAEGAgICAeCEEAkACQAJAAn8CQAJAIAAoAgQoAhAgAUECdGooAgAiBUGAgICAeEcgACgCACIHKAIAIgYoAgAoAgAiAkF/R3JFBEBBACECDAELIAJFDQQgBSAFIAJtIgQgAmxrQQAgAkF/RxshAiAFQQBODQELIAQgAiAGKAIIKAIATGsMAQsgBCACIAYoAgQoAgBOagusIgggBygCBC0AABDFKQRAIAAoAgggAUEDdGogCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EQaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAugBAECfyMAQTBrIgQkAAJAIAACfwJAAkACQAJAIAJB/wFxQQFrDgMBAgMACyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUHAg/8AEIwYIAEgAxDNHCAEIAEQvBMgAkGAAmokAEE4QQQQrTYiAkUNBCACQoGAgIAQNwIAIAJBCGogBEEw/AoAAEGgz/8ADAMLIwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQaiD/wAQjBggASADEM0cIAQgARC1EyACQYACaiQAQThBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQdDQ/wAMAgsjAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBkIP/ABCMGCABIAMQzRwgBCABELoTIAJBgAJqJABBOEEEEK02IgJFDQIgAkKBgICAEDcCACACQQhqIARBMPwKAABBoM7/AAwBCyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUH8g/8AEIwYIAEgAxDNHCAEIAEQwRMgAkGAAmokAEE4QQQQrTYiAkUNASACQoGAgIAQNwIAIAJBCGogBEEw/AoAAEH4z/8ACzYCBCAAIAI2AgAgBEEwaiQADwtBBEE4EKM9AAvMAgICfwJ+IwBBIGsiBCQAIARBCGogACABKAIQEQAAIARBEGoiACAEKAIIIgEgBCgCDCgCDBEAACAEKQMQIQYgBCkDGCEHIAQgAiADKAIQEQAAIAAgBCgCACICIAQoAgQoAgwRAABBACEAAkAgAUEAIAZCx9n0597Etpx3hSAHQo2yzpSMypLmp3+FhFAbIgFFDQAgAkEAIAQpAxBCx9n0597Etpx3hSAEKQMYQo2yzpSMypLmp3+FhFAbIgNFDQACQAJ/AkAgASgCHCADKAIcRgRAIAEoAiAgAygCIEYNAQsgARCTNiECIAMQkzYhAUEAIAJFDQEaDAMLIAEoAhAgAygCEEYgASgCFCADKAIURnEhAiABEJM2IQUgAxCTNiEBIAUNASACCyABRXEhAAwBCyACRSABRXINACAFIAEQkywhAAsgBEEgaiQAIAALzgICAn8CfiMAQSBrIgQkACAEQQhqIAAgASgCEBEAACAEQRBqIgAgBCgCCCIBIAQoAgwoAgwRAAAgBCkDECEGIAQpAxghByAEIAIgAygCEBEAACAAIAQoAgAiAiAEKAIEKAIMEQAAQQAhAAJAIAFBACAGQpCes+7ZtI2S6QCFIAdCiPSrgeCxxeTCAIWEUBsiAUUNACACQQAgBCkDEEKQnrPu2bSNkukAhSAEKQMYQoj0q4HgscXkwgCFhFAbIgNFDQACQAJ/AkAgASgCHCADKAIcRgRAIAEoAiAgAygCIEYNAQsgARCTNiECIAMQkzYhAUEAIAJFDQEaDAMLIAEoAhAgAygCEEYgASgCFCADKAIURnEhAiABEJM2IQUgAxCTNiEBIAUNASACCyABRXEhAAwBCyACRSABRXINACAFIAEQkywhAAsgBEEgaiQAIAALzAICAn8CfiMAQSBrIgQkACAEQQhqIAAgASgCEBEAACAEQRBqIgAgBCgCCCIBIAQoAgwoAgwRAAAgBCkDECEGIAQpAxghByAEIAIgAygCEBEAACAAIAQoAgAiAiAEKAIEKAIMEQAAQQAhAAJAIAFBACAGQtPY0/j95vaSSIUgB0Ki2J6I4aDq6cwAhYRQGyIBRQ0AIAJBACAEKQMQQtPY0/j95vaSSIUgBCkDGEKi2J6I4aDq6cwAhYRQGyIDRQ0AAkACfwJAIAEoAhwgAygCHEYEQCABKAIgIAMoAiBGDQELIAEQkzYhAiADEJM2IQFBACACRQ0BGgwDCyABKAIQIAMoAhBGIAEoAhQgAygCFEZxIQIgARCTNiEFIAMQkzYhASAFDQEgAgsgAUVxIQAMAQsgAkUgAUVyDQAgBSABEJMsIQALIARBIGokACAAC84CAgJ/An4jAEEgayIEJAAgBEEIaiAAIAEoAhARAAAgBEEQaiIAIAQoAggiASAEKAIMKAIMEQAAIAQpAxAhBiAEKQMYIQcgBCACIAMoAhARAAAgACAEKAIAIgIgBCgCBCgCDBEAAEEAIQACQCABQQAgBkLCjPf26svc0YR/hSAHQuWT9Jj5r/joqH+FhFAbIgFFDQAgAkEAIAQpAxBCwoz39urL3NGEf4UgBCkDGELlk/SY+a/46Kh/hYRQGyIDRQ0AAkACfwJAIAEoAhwgAygCHEYEQCABKAIgIAMoAiBGDQELIAEQkzYhAiADEJM2IQFBACACRQ0BGgwDCyABKAIQIAMoAhBGIAEoAhQgAygCFEZxIQIgARCTNiEFIAMQkzYhASAFDQEgAgsgAUVxIQAMAQsgAkUgAUVyDQAgBSABEJMsIQALIARBIGokACAAC5oCAQN/IAAoAggiAyECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIEIAAoAgAgA2tLBH8gACADIAQQ2yggACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALuQIBAn8jAEHQAGsiAiQAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACIAQ2AgwCQCAEKAIAIgQgASgCCCIBKAIEIgVJBEAgASgCACAEQQJ0aigCCCIBIAEoAgAiA0EBajYCACADQQBODQEACyACIAU2AjwgAkECNgIoIAJB0NyHATYCJCACQgI3AjAgAkE7NgJMIAJB/Rw2AkQgAiACQUBrNgIsIAIgAkE8ajYCSCACIAJBDGo2AkAgAkEUaiACQSRqEJkOIAJBCGoiASACQSBqKAIANgIAIAIgAikCGDcDACACKAIUIQQgAxCOEiADIAQ2AgQgA0GFgICAeDYCACADIAIpAwA3AgggA0EQaiABKAIANgIAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAALngIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBEEBQQEQ3CggACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALlAIBBX8gA0H4////AXEEQCAAIAAgA0EDdiIDQQR0IgVqIAAgA0EcbCIHaiADIAQQyREhACABIAEgBWogASAHaiADIAQQyREhASACIAIgBWogAiAHaiADIAQQyREhAgsgACgCACIDKAIEIgUgASgCACIEKAIEIgcgAygCCCIDIAQoAggiBCADIARJGxCZJyIGIAMgBGsgBhsiBkEASiAGQQBIayIGIAUgAigCACIFKAIEIgggAyAFKAIIIgUgAyAFSRsQmSciCSADIAVrIAkbIgNBAEogA0EASGtzQQBOBH8gAiABIAcgCCAEIAUgBCAFSRsQmSciACAEIAVrIAAbIgBBAEogAEEASGsgBnNBAEgbBSAACwuaAgEDfyAAKAIIIgMhAgJ/QQEgAUGAAUkNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiBCAAKAIAIANrSwR/IAAgAyAEEOAoIAAoAggFIAILIAAoAgRqIQICQAJAIAFBgAFPBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgADIAIgAUESdkHwAXI6AAAgAiABQQZ2QT9xQYABcjoAAiACIAFBDHZBP3FBgAFyOgABDAMLIAIgAUE/cUGAAXI6AAIgAiABQQx2QeABcjoAACACIAFBBnZBP3FBgAFyOgABDAILIAIgAToAAAwBCyACIAFBP3FBgAFyOgABIAIgAUEGdkHAAXI6AAALIAAgAyAEajYCCEEAC5oCAQN/IAAoAggiAyECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIEIAAoAgAgA2tLBH8gACADIAQQhRMgACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALggcDCn8BfgFvIwBBIGsiBCQAIAECfwJAAkACQAJAAkACQAJAAkACQCABLQAEQQFrDgQFAgEAAwsgASgCCCEFDAYLIAEoAgghBQwCCwALIAEgASgCACIFNgIICyAEQRhqIQkjAEEQayIHJAAgB0EIaiELIAIhBiMAQRBrIggkAAJAIAVBEGoiBSgCDEUNACAIQQhqIAVBDGoiCiAGEMcYQQIhAyAIKAIIIgxBAkYNACAIKAIMIQYCQCAKKAIAIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAoQshoLIApBADYCAEEBIQMgDEEBcQRAIAUQpS0gBUEANgIADAELIAZBhAFPBEAgBhDyHwtBACEDCyALIAY2AgQgCyADNgIAIAhBEGokAAJAIAcoAggiBkECRgRAIAlBBToAAAwBCyAGQQFxBEAgCSAHKAIMEI8SDAELIAlBBDoAAAsgB0EQaiQAIAQtABhBBUcNASAAQQk2AgBBAwwEC0HAtcMAEOgrAAsgBCkDGCINQv8Bg0IEUgRAIAQgDTcDGCAEIARBGGoQgSsMAgsgASABKAIAIgU2AggLIARBGGohCSMAQRBrIgckACAHQQhqIQpBACEDIwBBEGsiCCQAIAVBEGoiAUEQaiEGAkAgASgCEEUEQCABKAIAQQFHDQEgAUEEaigCACUBECshDhDfEiIDIA4mASADEPsOIQUCQCABKAIQIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAYQshoLIAYgBTYCAAsgCEEIaiAGIAIQxxhBAiEDIAgoAggiBUECRg0AIAgoAgwhAgJAIAYoAgAiA0UNACADIAMoAgBBAWsiAzYCACADDQAgBhCyGgtBACEDIAFBADYCECABEKUtIAFBADYCACAFQQFxBEBBASEDDAELIAJBhAFJDQAgAhDyHwsgCiACNgIEIAogAzYCACAIQRBqJAACQCAHKAIIIgFBAkYEQCAJQQU6AAAMAQsgAUEBcQRAIAkgBygCDBCPEgwBCyAJQQQ6AAALIAdBEGokACAELQAYQQVGBEAgAEEJNgIAQQQMAgsgBCkDGCINQv8Bg0IEUgRAIAQgDTcDGCAEIARBGGoQgSsMAQsgBEEINgIACyAAIAQpAwA3AwAgAEEQaiAEQRBqKQMANwMAIABBCGogBEEIaikDADcDAEEBCzoABCAEQSBqJAAL7gIDA38BfgFvIwBBQGoiAyQAIAAoAhAQ9DohBUEIQQQQrTYiBEUEQEEEQQgQoz0ACyAEIAU2AgQgBEEBNgIAIANBGGoiBUG47MMANgIEIAUgBDYCACADKAIYIgRBuOzDABB5IQcQ3xIiBSAHJgEgA0G47MMANgIoIAMgBDYCJCADIAU2AiwgAyABQgBC6AdCABCoHiADKQMAIgYgAkHAhD1urXwiAUKAgICACFQgAykDCCABIAZUrXxQcQRAIANBLGoiAigCACUBIAGnEAYhBxDfEiIEIAcmASADQThqIABBCGopAgA3AwAgACkCACEBIAAgBDYCACAAIAMpAiQ3AgQgAEEMaiACKAIANgIAIAMgATcDMAJAIAMoAjRFDQAgAygCMBD/LyIAQYQBTwRAIAAQ8h8LIANBPGoQrDtFDQAgA0EwakEEchC8KgsgA0FAayQADwtBl+3DAEEHIANBMGpB6OzDAEGg7cMAENUeAAuIBgEIfyMAQRBrIgYkACAGIAU2AgwgBiAENgIIAn8CQAJ/AkACQCAGQQhqEO4SIgVBgIDEAEcEQCAFQT9GDQIgBUEjRw0BIAYoAgghAyAGKAIMDAMLQQAhBSAAQQA2AgBBCAwEC0HYksQAQcMAQZyTxAAQnykACyABKAIIIQRBASENIAFBARDYLSABKAIEIAEoAghqQT86AAAgASAEQQFqNgIIIAYoAgghByAGKAIMIQgjAEFAaiIFJAAgBSAINgIMIAUgBzYCCCAFIAEpAhg3AhAgBSABLQAgRToAGAJAAkACf0EAIAEoAhAiCUUNABogASgCFCEKIAEoAgQhBwJAIANFDQAgASgCCCIIIANNBEAgAyAIRg0BDAMLIAMgB2osAABBv39MDQILAkAgByADQbSGxABBBBDBLg0AIAcgA0G4hsQAQQUQwS4NACAHIANBxYbEAEEEEMEuDQBBACAHIANBwobEAEEDEMEuRQ0BGgsgCQshByAFQRxqIAVBCGoQnwsCQCAFLQAkIgNBAkYNAEGsk8QAQbyTxAAgAkH/AXFBAkYbIQIDQCAFKAIgIQggBSgCHCEJAkAgBwRAIAVBNGoiDCAHIAkgCCAKKAIUEQUAIAUgDBDcOyAFIAI2AjAgBSAFKQMANwIoIAEgBUEoahCvHiAFKAI0QYCAgIB4Rg0BIAwQ3jsMAQsgBSACNgI8IAUgCDYCOCAFIAk2AjQgASAFQTRqEK8eCyADQQFxRQRAIAVBHGogBUEIahCfCyAFLQAkIgNBAkYNAgwBCwsgBSgCDCEDIAUoAgghCwsgBiADNgIEIAYgCzYCACAFQUBrJAAMAQsgByAIQQAgA0GElMQAEKM2AAsgBigCACIDRQ0BIAYoAgQLIQIgASgCCCEFIAFBARDYLSABKAIEIAEoAghqQSM6AAAgASAFQQFqNgIIIAEgAyACENwcIABBATYCCCAAIAQ2AgQgACANNgIAQQwMAQsgACAENgIEIABBATYCAEEAIQVBCAsgAGogBTYCACAGQRBqJAALpwICBH8BfiMAQSBrIgUkAEEIIQcCQAJAIANFDQAgASgCTCIGRQRAIAEgAjQCACIINwM4IAEgCDcDMEEBIQQLIAEgAyAGajYCTCADIARNDQAgAyAEayEGIAIgBEECdGohAwNAIAEoAlwiAiABKAJIIgRPDQIgASgCRCACQQN0aiADNAIAIgggASkDOH3ENwMAIAEgCDcDOCABIAEoAlxBAWoiAjYCXAJAIAIgASgCUEcNACAFQQhqIAEQiwcgBSgCCCIHQQhGDQAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAMAgsgA0EEaiEDIAZBAWsiBg0AC0EIIQcLIAAgBzYCACAFQSBqJAAPCyACIARBgJ/OABDDIQALvgICA34IfwJAAkAgACgCTEUNACAAQdAAaiABEO4LIQIgACgCQCIGQUBqIQggACgCRCIHIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQkgASgCBCEKQQAhAQNAIAUgBmopAAAiAyAEhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAKIAkgCCACeqdBA3YgBWogB3EiC0EGdGsiDCgCBCAMKAIIEOQcDQQgAkIBfSACgyICUEUNAAsLIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0BIAUgAUEIaiIBaiAHcSEFDAALAAsgACgCHEGAgMAAIAAoAhhBAXEbDwsgBkEAIAtrQQZ0aiIBQRRrKAIAIAAoAhxBgIDAACAAKAIYQQFxGyABQRhrKAIAGwuwAgIDfgh/An9BACAAKAJMRQ0AGiAAQdAAaiABEO4LIQIgACgCQCIHQUBqIQkgACgCRCIIIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQogASgCBCELQQAhAQNAAkAgBSAHaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAsgCiAJIAJ6p0EDdiAFaiAIcSIGQQZ0ayIMKAIEIAwoAggQ5BwNAiACQgF9IAKDIgJQRQ0ACwtBACADIANCAYaDQoCBgoSIkKDAgH+DUEUNAhogBSABQQhqIgFqIAhxIQUMAQsLIAdBACAGa0EGdGoiAUEoa0EAIAFBMGsoAgAbCyIGIABBCGpBACAAKAIAQQFxGyAGGwvyEQMGfwR8AX4jAEEwayIFJAAgBSACOQMAAkAgAAJ/IAJEAAAAAAAA8D9jIAJEAAAAAAAAAABmcUUEQCAFQQE2AhQgBUHI6c4ANgIQIAVCATcCHCAFQYoINgIMIAUgBUEIajYCGCAFIAU2AgggAEEEaiAFQRBqEJkOQQAMAQsgBUF/QSBBgICAwAAgAbpEAAAAAAAAIMCiAnwCQAJAAn9EAAAAAAAA8D8CfEQAAAAAAADwPyEJAkACQAJAIAK9IgGnIgdFIAFCIIgiDUKAgMD/A1FxDQAgAkQAAAAAAADAP6AgDaciBEH/////B3EiBkGAgMD/B0sgBkGAgMD/B0ZBACAHG3INAxoCQCABQgBZDQALIAKZIQkCQAJAIAcNACAEQQBIBEAgBEGAgICAeEYgBEGAgMD/e0ZyDQIgBEGAgEBHDQEMAgsgBEUgBEGAgMD/A0ZyIARBgIDA/wdGcg0BCyABQgBTBEAgAiACoSICIAKjDAULIAlEAAAAAAAAQEOiIgIgCSAGQYCAwABJIgcbIQkgAr1CIIinIAYgBxsiCEH//z9xIgRBgIDA/wNyIQYgCEEUdUHMd0GBeCAHG2ohBwJAIARBj7EOSQ0AIARB+uwuSQRAQQEhAwwBCyAEQYCAgP8DciEGIAdBAWohBwsgA0EDdCIEQajuigFqKwMARAAAAAAAAPA/IARBmO6KAWorAwAiAiAJvUL/////D4MgBq1CIIaEvyILoKMiCSALIAKhIgogA0ESdCAGQQF2akGAgKCAAmqtQiCGvyIMIAogCaIiCr1CgICAgHCDvyIJoqEgAiAMoSALoCAJoqGiIgIgCSAJoiILRAAAAAAAAAhAoCACIAogCaCiIAogCqIiAiACoiACIAIgAiACIAJE705FSih+yj+iRGXbyZNKhs0/oKJEAUEdqWB00T+gokRNJo9RVVXVP6CiRP+rb9u2bds/oKJEAzMzMzMz4z+goqAiDKC9QoCAgIBwg78iAqIgCiAMIAJEAAAAAAAACMCgIAuhoaKgIgogCiAJIAKiIgmgvUKAgICAcIO/IgIgCaGhRP0DOtwJx+4/oiACRPUBWxTgLz6+oqCgIgkgBEG47ooBaisDACIKIAkgAkQAAADgCcfuP6IiCaCgIAe3IgugvUKAgICAcIO/IgIgC6EgCqEgCaGhIQogAkQAAAAAAADAP6IiCSAKRAAAAAAAAMA/oiACRAAAAAAAAAAAoqAiAqAiCr0iAachAwJAIAFCIIinIgRB//+/hARMBEAgBEGA+P//B3FB/5fDhARNDQEgBEGA6Lz7A2ogA3INBCACIAogCaFlRQ0BDAQLIARBgIDAhARrIANyDQQgAkT+gitlRxWXPKAgCiAJoWRFDQAMBAtBACEDAnwgBEH/////B3FBgICA/wNLBH5BAEGAgMAAIARBFHZBAmp2IARqIgRB//8/cUGAgMAAckETIARBFHYiBmt2IgNrIAMgAUIAUxshAyACIAlBgIBAIAZBAWp1IARxrUIghr+hIgmgvQUgAQtCgICAgHCDvyIKRAAAAABDLuY/oiILIAIgCiAJoaFE7zn6/kIu5j+iIApEOWyoDGFcIL6ioCIKoCICIAIgAiACIAKiIgkgCSAJIAkgCUTQpL5yaTdmPqJE8WvSxUG9u76gokQs3iWvalYRP6CiRJO9vhZswWa/oKJEPlVVVVVVxT+goqEiCaIgCUQAAAAAAAAAwKCjIAogAiALoaEiCSACIAmioKGhRAAAAAAAAPA/oCICvSIBQiCIpyADQRR0aiIEQYCAwABOBEAgAUL/////D4MgBK1CIIaEvwwBCwJAAkACQCADQf8HTARAIANBgnhODQMgAkQAAAAAAABgA6IhAiADQbhwTQ0BIANByQdqIQMMAwsgAkQAAAAAAADgf6IhAiADQf4PSw0BIANB/wdrIQMMAgsgAkQAAAAAAABgA6IhAkHwaCADIANB8GhNG0GSD2ohAwwBCyACRAAAAAAAAOB/oiECQf0XIAMgA0H9F08bQf4PayEDCyACIANB/wdqrUI0hr+iC0QAAAAAAADwP6IhCQwBCyABQgBZDQAgBkGAgMD/A0YEQCAJIAmhIgIgAqMMBAsgCQwDCyAJDAILRAAAAAAAAAAADAELRAAAAAAAAPB/C6EiAr0iAUKAgICAgICACFkEQCABQv/////////3/wBWDQNBgXghAyABQiCIIg1CgIDA/wNSBEAgDacMAgtBgIDA/wMgAacNARpEAAAAAAAAAAAMBAtEAAAAAAAA8L8gAiACoqMgAkQAAAAAAAAAAGENAxogAUIAUw0BQct3IQMgAkQAAAAAAABQQ6K9IgFCIIinCyEEIAMgBEHiviVqIgNBFHZqtyIJRAAA4P5CLuY/oiABQv////8PgyADQf//P3FBnsGa/wNqrUIghoS/RAAAAAAAAPC/oCICIAlEdjx5Ne856j2iIAIgAkQAAAAAAAAAQKCjIgkgAiACRAAAAAAAAOA/oqIiCiAJIAmiIgkgCaIiAiACIAJEn8Z40Amawz+iRK94jh3Fccw/oKJEBPqXmZmZ2T+goiAJIAIgAiACRERSPt8S8cI/okTeA8uWZEbHP6CiRFmTIpQkSdI/oKJEk1VVVVVV5T+goqCgoqAgCqGgoAwCCyACIAKhRAAAAAAAAAAAoyECCyACC6P8A0EDdiIDIANBgICAwABPGyIDIANBIE0bQQFrZ3ZBAWoiBEEecSIDNgIIIAMNASAFQShqQgA3AwAgBUEgakIANwMAIAVBGGpCADcDACAFQgA3AxAjAEEgayIDJAAgA0EUaiAEQQV2IgZBAEEEQSAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxB1OnOABD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AgggA0EIaiAGIAVBEGoQlBQgAEEEaiIAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAEEICzYCACAFQTBqJAAPCyAFQQA2AhBBACAFQQhqQdDpzgAgBUEQakHk6c4AEK8rAAufAgECfyMAQSBrIgEkACAEIAQoAggiBUEIahCOLSABQQhqIAEgAiADIAQQ4QsCQAJAAkACQCABKAIIIgZBCEcEQCAAIAEpAgw3AgQgAEEUaiABQRxqKAIANgIAIABBDGogAUEUaikCADcCAAwBCyAEKAIIIgIgBUkNASACIAVrIgJBA00NAiAEKAIEIAVqIgQgA0EYdCADQYD+A3FBCHRyIANBCHZBgP4DcSADQRh2cnI2AAAgAkEHTQ0DIAQgAkEIayICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycjYABAsgACAGNgIAIAFBIGokAA8LIAUgAkH03dAAEK87AAtBBCACQYTe0AAQsDsAC0EIIAJBlN7QABCwOwALsAIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqEM8UAkACQEEMQQQQrTYiAQRAIAFCh46cuPDgwYMHNwIAIAFBCGpBh46cODYCAEEMQQQQrTYiA0UNASADQpiw4MCBg4aMGDcCACADQQhqQZiw4MABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBD5PSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ7j0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCfCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEOsOIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEO49IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDtDiACQUBrIgQgAUEwahDUFAJAAkBBDEEEEK02IgEEQCABQoiQoMCAgYKECDcCACABQQhqQYiQoMAANgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPE9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKMIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuxAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ1BQCQAJAQQxBBBCtNiIBBEAgAUKIkKDAgIGChAg3AgAgAUEIakGIkKDAADYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBDxPSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ9D0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCjCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEPQ9IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDUFAJAAkBBDEEEEK02IgEEQCABQoiQoMCAgYKECDcCACABQQhqQYiQoMAANgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPE9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKMIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANClqzYsOHChYsWNwIAIANBCGpBlqzYsAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuxAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQ1BQCQAJAQQxBBBCtNiIBBEAgAUKIkKDAgIGChAg3AgAgAUEIakGIkKDAADYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBDxPSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ9D0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCjCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KYsODAgYOGjBg3AgAgA0EIakGYsODAATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEO49IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDuDiACQUBrIgQgAUEwahDZFAJAAkBBDEEEEK02IgEEQCABQomSpMiQocKECTcCACABQQhqQYmSpMgANgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPA9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKEIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANClqzYsOHChYsWNwIAIANBCGpBlqzYsAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAvfDAIVfwJ+IwBBMGsiBiQAIAFBqAFqIQggBkEcaiEPIAZBIGohCwJAA0ACQCAGQRhqIQUjAEGwBGsiAyQAIAFBgAFqIRAgAUGMAWohEyABQdAAaiEUIAFBIGohFSABQQhqIQwgAUHkAGohDSABQeAAaiEHIAEoAmAhBCADQewCaiERIANB4AJqIRIgA0GQAWohCSADQdwBaiEOIANBqAFqIRYCQANAAkACQAJAAkACQAJAAkACQAJAAkBBASAEQf////8HaiAEQYCAgIB4TRtBAWsOAwIDAAELIAVBCTYCAAwHCyADQRBqIBQQ0yIgAygCEEEBcQ0HIAVBCTYCAAwGCyADQYgBaiAHEIcGIAMoAogBIgRBAkYNASAEQQFxBEAgA0EoaiADQZwBaigCADYCACADQSBqIANBlAFqKQIANwMAIAMgAykCjAE3AxggBxCGJCAHQYSAgIB4NgIAIANBADYCmAQgA0KAgICAEDcCkAQgA0GY+cIANgKgBCADQqCAgIAONwKkBCADIANBkARqNgKcBCADQRhqIgcgA0GcBGoQnwQNAyAFIAMpApAENwIEIAVBDGogA0GYBGooAgA2AgAgBUEDNgIAIAcQiBEMBgsgBSADKQKMATcCBCAFQQg2AgAgBUEUaiADQZwBaigCADYCACAFQQxqIANBlAFqKQIANwIADAULIANBiAFqIAEoAmQgAiABKAJoKAIMEQEAIAMpA4gBIhhCA1ENAyAYQgJRBEAgBSAJKQMANwMAIAVBEGogCUEQaikDADcDACAFQQhqIAlBCGopAwA3AwAgBxCGJCAHQYSAgIB4NgIADAULIAMoAtgBIQQgASkDAEICUgRAIAEQ2BULIAEgGDcDACAMIAkpAwA3AwAgDEEIaiAJQQhqKQMANwMAIAxBEGogCUEQaikDADcDACAVIBZBMPwKAAAgBxCGJCAEQYGAgIB4Rg0CIA0gDikCADcCACANQRhqIA5BGGooAgA2AgAgDUEQaiAOQRBqKQIANwIAIA1BCGogDkEIaikCADcCAAwCCyAHEIYkQYGAgIB4IQQMAQtBwPnCAEE3IANBrwRqQbD5wgBB+PnCABDVHgALIAcgBDYCAAwDCyAFQQo2AgALIANBsARqJAAMAgsgAygCFCEEIAEpAwAhGCABQgI3AwAgGEICUgRAIANBMGogDEHIAPwKAAAgASgCmAFBCGogBBCILSEKAkAgASgCjAFBgICAgHhHBEAgA0H8AGogEyAKKAIQEKAODAELIANBgICAgHg2AnwLAkAgECgCAEGAgICAeEcEQCADQRhqIBAQ5x4MAQsgA0GAgICAeDYCGAsgESADKQIYNwIAIBFBCGogA0EgaigCADYCACADIBg3A4gBIAEoAqABIQogCSADQTBqQcgA/AoAACASIAMpAnw3AgAgEkEIaiADQYQBaigCADYCACADIAQ2AvgCIANBADoApAMgAyAKNgL8AiADQQhqIQQgA0GIAWohFwJAQYgDQQgQrTYiCgRAIAogF0GIA/wKAAAgBEHY+MIANgIEIAQgCjYCAAwBC0EIQYgDEKM9AAsgAygCCCEEIAcQhiQgAUHY+MIANgJoIAEgBDYCZEGDgICAeCEEIAFBg4CAgHg2AmAMAQsLQZT4wgBBE0Go+MIAEMskAAsCQAJAIAYoAhgiA0EIRwRAAkAgA0EJaw4CBAIACyAGQRBqIAtBCGopAwAiGDcDACAGIAspAwAiGTcDCCAGKAIcIQEgAEEQaiAYNwMAIAAgGTcDCCAAIAE2AgQgACADNgIADAULIAZBEGoiAyALQQhqKQMANwMAIAYgCykDADcDCCAGKAIcIgVBgICAgHhrDgICAAELIABBCTYCAAwDCyAPIAYpAwg3AgAgD0EIaiADKQMANwIAIAYgBTYCGCAGQRhqIgUoAgAiB0GAgICAeEciBCAIKAIAIAgoAggiA2tLBEAgCCADIARBBEEUENAoIAgoAgghAwsgCCAHQYCAgIB4RwR/IAgoAgQgA0EUbGoiBCAHNgIAIAQgBSkCBDcCBCAEQQxqIAVBDGopAgA3AgAgA0EBagUgAws2AggMAQsLIAAgCCkCADcCBCAAQQxqIAhBCGooAgA2AgAgAUEANgKwASABQoCAgIDAADcDqAEgAEEINgIACyAGQTBqJAALrgIBCH8jAEEgayIEJAACQCABKAIEIgNFBEAMAQsgASgCACIFLAAAIgZB/wFxIQICQAJAAkAgBkEASA0AIAEoAggiCCACQQN2QRxxaigCACACdkEBcQ0AQQEhBgNAIAMgBiICRg0CIAIgBWoiCSwAACIHQQBOBEAgAkEBaiEGIAggB0EDdkH8////AXFqKAIAIAd2QQFxRQ0BCwsgAiADSw0CIAEgAyACazYCBCABIAk2AgAgAiEDDAMLIAEgA0EBazYCBCABIAVBAWo2AgBBAyEDIAJBA2xBsLHMAGohBQwCCyABQgE3AgAMAQsgBEEANgIYIARBATYCDCAEQYixzAA2AgggBEIENwIQIARBCGpBsLfMABDvLAALIAAgAzYCBCAAIAU2AgAgBEEgaiQAC6UCAgR/AX4jAEEgayIFJABBCCEHAkAgA0UNACABKAJMIgZFBEAgASACKQMAIgg3AzggASAINwMwQQEhBAsgASADIAZqNgJMIAMgBE0NACADIARrIQYgAiAEQQN0aiEDA0AgASgCXCICIAEoAkgiBEkEQCABKAJEIAJBA3RqIAMpAwAiCCABKQM4fTcDACABIAg3AzggASABKAJcQQFqIgI2AlwCQCACIAEoAlBHDQAgBUEIaiABEJIHIAUoAggiB0EIRg0AIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIADAMLQQghByADQQhqIQMgBkEBayIGDQEMAgsLIAIgBEGAn84AEMMhAAsgACAHNgIAIAVBIGokAAuyAgIDfgh/An8CQAJAIAAoAkxFDQAgAEHQAGogARDuCyECIAAoAkAiBkFAaiEIIAAoAkQiByACp3EhBSACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgASgCCCEJIAEoAgQhCkEAIQEDQCAFIAZqKQAAIgMgBIUiAkJ/hSACQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgJQRQRAA0AgCiAJIAggAnqnQQN2IAVqIAdxIgtBBnRrIgwoAgQgDCgCCBDkHA0EIAJCAX0gAoMiAlBFDQALCyADIANCAYaDQoCBgoSIkKDAgH+DUEUNASAFIAFBCGoiAWogB3EhBQwACwALIAAtACgMAQsgAC0AKCAGQQAgC2tBBnRqQQhrLQAAIgAgAEECRhsLIgAgAEH/AXFBAkZyQQFxC8YFAgp/An4jAEEwayICJAAgASgCHCEGIAEoAgwhCSABKAIQIQMgAiABKAIYIgQ2AgAgAiAJIANBA3RqNgIsIAIgCTYCKCACIAQgBkECdGoiBjYCBCACQShqEJg2IQUgAhCeNiEIIAIpAighDCACIAEoAiQiCiABKAIoQQN0aiIDNgIsIAIgCjYCKCACQShqEJg2IQkgAkEANgIgIAIgAzYCHCACIAo2AhggAkEANgIQIAIgBjYCDCACIAQ2AgggAiAMNwIAIAIgCCAFIAUgCEsbIgM2AhQgAiAJIAMgAyAJSxs2AiQjAEEgayIHJAAgB0EUaiACKAIkIAIoAiBrQQBBCEEYEKAYIAcoAhghAyAHKAIUQQFGBEAgAyAHKAIcQbjmzwAQ/S8ACyAHQRBqIglBADYCACAHIAcoAhw2AgwgByADNgIIIwBBEGsiCyQAIAIoAiQgAigCIGsiAyAHQQhqIgYoAgAgBigCCCIEa0sEQCAGIAQgA0EIQRgQ0CggBigCCCEECyALIAYoAgQ2AgwgCyAENgIIIAsgBkEIajYCBCALQQRqIggoAgQhBSAIKAIAIAIoAiQiAyACKAIgIgRHBH8gAyAEayEKIAMgBWogBGsgCCgCCCAFQRhsaiEFIAIoAhggBEEDdGohCCACKAIAIAIoAhAgBGoiA0EDdGohBCACKAIIIANBAnRqIQMDQCAEKQMAIQ0gCCkDACEMIAVBEGogAygCADYCACAFQQhqIAw3AwAgBSANNwMAIARBCGohBCADQQRqIQMgCEEIaiEIIAVBGGohBSAKQQFrIgoNAAsFIAULNgIAIAtBEGokACAAQQhqIAkoAgA2AgAgACAHKQIINwIAIAdBIGokACAAQRRqIAFBNGooAgA2AgAgACABKQIsNwIMIAFBCGoQ4zwgAUEUahDpOyABQSBqEOM8IAJBMGokAAugFgIMfwF+AkAgAEGN/3tPDQACfwJAAkACQEEQIABBC2pBeHEgAEELSRsiCUHMAGoiAEH1AU8EQCAAQcz/e0sNAiAAQQtqQXhxIQRBxPOKASgCAEUNAUEAIARrIQMCQAJAAkACf0EAIARBgAJJDQAaQR8gBEH///8HSw0AGiAEQQYgBEEIdmciAGt2QQFxIABBAXRrQT5qCyIHQQJ0QajwigFqKAIAIgAEQCAEQRkgB0EBdmtBACAHQR9HG3QhBgNAAkAgACgCBEF4cSIFIARJDQAgBSAEayIFIANPDQAgACECIAUiAw0AQQAhAyAAIQEMAwsgACgCFCIFIAEgBSAAIAZBHXZBBHFqKAIQIgBHGyABIAUbIQEgBkEBdCEGIAANAAsLIAEgAnJFBEBBACEBQcTzigEoAgBBAiAHdCIAQQAgAGtycSIARQ0DQQAhAiAAaEECdEGo8IoBaigCACEBCyABRQ0BCwNAIAEgAiABKAIEQXhxIgUgBGsiBiADSSIHGyEIIAEoAhAiAEUEQCABKAIUIQALIAIgCCAEIAVLIgEbIQIgAyAGIAMgBxsgARshAyAAIgENAAsLQQAhASACRQ0AIARByPOKASgCACIATSADIAAgBGtPcQ0AIAIgBBCYPiEAIAIQrRECQCADQRBPBEAgAiAEQQNyNgIEIAAgAxDQNCAAIAMQihwMAQsgAiADIARqEPMuCyACEJk+IQELIAENAgwBCwJAAkACQEHA84oBKAIAIgNBECAAQQtqQfgDcSAAQQtJGyIEQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgVBA3QiBEGo8IoBaiIBQZABaiIAIAFBmAFqKAIAIgEoAggiAkYNASACIAA2AgwgACACNgIIDAILIARByPOKASgCAE0NAyABRQRAQcTzigEoAgBFDQRBxPOKASgCAGhBAnRBqPCKAWooAgAiASgCBEF4cSAEayEDIAEhAAJAA0ACQAJAIAEoAhAiAg0AIAEoAhQiAg0AIAAgBBCYPiEFIAAQrREgA0EQTwRAIAAgBEEDcjYCBCAFIAMQ0DRByPOKASgCACICRQ0CQdDzigEoAgAhAQJ/QcDzigEoAgAiBkEBIAJBA3Z0IgdxRQRAQcDzigEgBiAHcjYCACACQXhxQbjxigFqIgIMAQsgAkF4cUGo8IoBaiIGQZABaiECIAZBmAFqKAIACyEGIAIgATYCCCAGIAE2AgwgASACNgIMIAEgBjYCCAwCCyAAIAMgBGoQ8y4MAwsgAigCBEF4cSAEayIBIAMgASADSSIBGyEDIAIgACABGyEAIAIhAQwBCwtB0POKASAFNgIAQcjzigEgAzYCAAsgABCZPiIBRQ0EDAULAkBBAiAAdCICQQAgAmtyIAEgAHRxaCIFQQN0IgZBuPGKAWoiACAAKAIIIgIoAggiAUcEQCABIAA2AgwgACABNgIIDAELQcDzigEgA0F+IAV3cTYCAAsgAiAEQQNyNgIEIAIgBBCYPiIFIAYgBGsiBBDQNEHI84oBKAIAIgFFDQJB0POKASgCACEAAn9BwPOKASgCACIDQQEgAUEDdnQiBnFFBEBBwPOKASADIAZyNgIAIAFBeHFBuPGKAWoiAQwBCyABQXhxQbjxigFqIgEoAggLIQMgASAANgIIIAMgADYCDCAAIAE2AgwgACADNgIIDAILQcDzigEgA0F+IAV3cTYCAAsgASAEEPMuIAEQmT4MBAtB0POKASAFNgIAQcjzigEgBDYCACACEJk+DAMLQcjzigEoAgAiASAETw0BIARBzPOKASgCACIATwRAQQAhBiMAQRBrIgckACAHQQRqIARBr4AEakGAgHxxEMsiAkAgBygCBCIARQ0AIAcoAgwhCEHY84oBIAcoAggiBUHY84oBKAIAaiIBNgIAQdzzigEgAUHc84oBKAIAIgIgASACSxs2AgACQEHU84oBKAIARQRAQeTzigEoAgAiAUEAIAAgAU8bRQRAQeTzigEgADYCAAtB6POKAUH/HzYCAEG08YoBIAg2AgBBrPGKASAFNgIAQajxigEgADYCAEEAIQIDQCACQajwigFqIgFBmAFqIAFBkAFqIgM2AgAgAUGcAWogAzYCACACQQhqIgJBgAJHDQALIAAgBUEoaxDRJgwBC0Go8YoBIgMhAgJAA0AgAhCuOyAARwRAIAIoAggiAg0BDAILCyACKAIMIgFBAXEgAUEBdiAIR3INACACQdTzigEoAgAQzy1FDQAgAiACKAIEIAVqNgIEQdTzigEoAgBBzPOKASgCACAFahDRJgwBC0Hk84oBQeTzigEoAgAiASAAIAAgAUsbNgIAIAAgBWohAgJAAkADQCACIAMoAgAiAUcEQCADKAIIIgMNAQwCCwsgAygCDCICQQFxDQAgAkEBdiAIRg0BC0HU84oBKAIAIQJBqPGKASEBAkADQCACIAEoAgBPBEAgARCuOyACSw0CCyABKAIIIgENAAtBACEBCyACIAEQrjsiC0EvayIBEJk+IgNBB2pBeHEgA2sgAWoiASABIAJBEGpJGyIDEJk+IQogA0EYEJg+IQEgACAFQShrENEmIANBGzYCBEGo8YoBKQIAIQ0gCkEIakGw8YoBKQIANwIAIAogDTcCAEG08YoBIAg2AgBBrPGKASAFNgIAQajxigEgADYCAEGw8YoBIAo2AgADQCABQQQQmD4gAUEHNgIEIgFBBGogC0kNAAsgAiADRwRAIAIgAyACayIAIAIgABCYPhCJLiACIAAQihwLDAELIAMgADYCACADIAMoAgQgBWo2AgQgABCZPiECIAEQmT4hAyAAIAJBB2pBeHEgAmtqIgIgBBCYPiEAIAIgBEEDcjYCBCABIANBB2pBeHEgA2tqIgEgAiAEamshBAJAAkBB1POKASgCACABRwRAIAFB0POKASgCAEYNASABKAIEIgNBA3FBAUYEQCABIANBeHEiAxCpJyADIARqIQQgASADEJg+IQELIAAgBCABEIkuIAAgBBCKHAwCC0HU84oBIAA2AgBBzPOKAUHM84oBKAIAIARqIgE2AgAgACABQQFyNgIEDAELQdDzigEgADYCAEHI84oBQcjzigEoAgAgBGoiATYCACAAIAEQ0DQLIAIQmT4hBgwBC0HM84oBKAIAIgAgBE0NAEHM84oBIAAgBGsiATYCAEHU84oBQdTzigEoAgAiACAEEJg+IgI2AgAgAiABQQFyNgIEIAAgBEEDcjYCBCAAEJk+IQYLIAdBEGokACAGDAMLQczzigEgACAEayIBNgIAQdTzigFB1POKASgCACIAIAQQmD4iAjYCACACIAFBAXI2AgQgACAEQQNyNgIEIAAQmT4hAQsgAQwBC0HQ84oBKAIAIQACQCABIARrIgJBD00EQEHQ84oBQQA2AgBByPOKAUEANgIAIAAgARDzLgwBCyAAIAQQmD4hAUHI84oBIAI2AgBB0POKASABNgIAIAEgAhDQNCAAIARBA3I2AgQLIAAQmT4LIgBFDQAgABCaPiEBAkAgAEE/cUUEQCABIQAMAQsgAEE/akFAcRCaPiEAIAEoAgQiBUF4cSAAQcAAQQAgACABa0EQTRtqIgAgAWsiAmshAyAFQQNxBEAgACADEO4sIAEgAhDuLCABIAIQlxIMAQsgASgCACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAJQRBqTQ0AIAAgCRCYPiEBIAAgCRDuLCABIAIgCWsiAhDuLCABIAIQlxILIAAQmT4hDAsgDAvAAgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFBA3RqKQMAEM4vIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQF0ai8BABC1LiACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC8ACAgR/BH4jAEHgAGsiAiQAIAAoAgAhBCACQUBrIAAoAgQoAhAgAUECdGooAgAQlC8gAkEQaiIFIAIpA0AgAikDSCACKQNQIAIpA1ggBCgCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBUEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBCgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAvAAgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFBAXRqLwEAEJMtIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQJ0aigCABDJLSACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC68CAQZ/IwBBEGsiAyQAQYCAgIB4IQQCQAJAAkACfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNBCAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qCyICIAcoAgQtAAAQxCkEQCAAKAIIIAFBAnRqIAI2AgAMAQsgACgCECICIAIoAgBBAWo2AgAgA0EIaiAAKAIUEIY9IAFBA3YiACADKAIMIgJPDQIgAygCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIANBEGokAA8LQayP/wAQ4isACyAAIAJBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQN0aikDABCzLiACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC70CAQF/IwBB0ABrIgQkACAEIAE3AwACQAJAIAACfyACQQFxBEAgBEEgaiABIAMQzyUgBCgCIEUNAiAEKAIsIQIgBCAEKQIkNwJAIARBDGogBEFAayACEIooIAQoAgwhAyAEKAIQDAELIARBIGogARD9FyAEKAIgRQ0BIAQoAiQhAyAEKAIoCzYCCCAAIAM2AgQgAEGTgICAeDYCAAwBCyAEQSc2AjwgBEGLyP8ANgI4IARBAjYCJCAEQazb/wA2AiAgBEICNwIsIARB7gY2AkwgBEHMATYCRCAEIARBQGs2AiggBCAENgJIIAQgBEE4ajYCQCAEQRBqIARBIGoQmQ4gBEGCgICAeDYCDCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIAIABBEGogBEEcaigCADYCAAsgBEHQAGokAAu9AgEBfyMAQdAAayIEJAAgBCABNwMAAkACQCAAAn8gAkEBcQRAIARBIGogASADEM0lIAQoAiBFDQIgBCgCLCECIAQgBCkCJDcCQCAEQQxqIARBQGsgAhCKKCAEKAIMIQMgBCgCEAwBCyAEQSBqIAEQ/RUgBCgCIEUNASAEKAIkIQMgBCgCKAs2AgggACADNgIEIABBk4CAgHg2AgAMAQsgBEErNgI8IARB4Mf/ADYCOCAEQQI2AiQgBEGs2/8ANgIgIARCAjcCLCAEQe4GNgJMIARBzAE2AkQgBCAEQUBrNgIoIAQgBDYCSCAEIARBOGo2AkAgBEEQaiAEQSBqEJkOIARBgoCAgHg2AgwgACAEKQIMNwIAIABBCGogBEEUaikCADcCACAAQRBqIARBHGooAgA2AgALIARB0ABqJAALvQIBAX8jAEHQAGsiBCQAIAQgATcDAAJAAkAgAAJ/IAJBAXEEQCAEQSBqIAEgAxDMJSAEKAIgRQ0CIAQoAiwhAiAEIAQpAiQ3AkAgBEEMaiAEQUBrIAIQiiggBCgCDCEDIAQoAhAMAQsgBEEgaiABEIEVIAQoAiBFDQEgBCgCJCEDIAQoAigLNgIIIAAgAzYCBCAAQZOAgIB4NgIADAELIARBLDYCPCAEQYjH/wA2AjggBEECNgIkIARBrNv/ADYCICAEQgI3AiwgBEHuBjYCTCAEQcwBNgJEIAQgBEFAazYCKCAEIAQ2AkggBCAEQThqNgJAIARBEGogBEEgahCZDiAEQYKAgIB4NgIMIAAgBCkCDDcCACAAQQhqIARBFGopAgA3AgAgAEEQaiAEQRxqKAIANgIACyAEQdAAaiQAC70CAQF/IwBB0ABrIgQkACAEIAE3AwACQAJAIAACfyACQQFxBEAgBEEgaiABIAMQziUgBCgCIEUNAiAEKAIsIQIgBCAEKQIkNwJAIARBDGogBEFAayACEIooIAQoAgwhAyAEKAIQDAELIARBIGogARDWFSAEKAIgRQ0BIAQoAiQhAyAEKAIoCzYCCCAAIAM2AgQgAEGTgICAeDYCAAwBCyAEQSw2AjwgBEG0x/8ANgI4IARBAjYCJCAEQazb/wA2AiAgBEICNwIsIARB7gY2AkwgBEHMATYCRCAEIARBQGs2AiggBCAENgJIIAQgBEE4ajYCQCAEQRBqIARBIGoQmQ4gBEGCgICAeDYCDCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIAIABBEGogBEEcaigCADYCAAsgBEHQAGokAAu3AgEHfyMAQTBrIgIkACABKAIEIQQgASgCACEIAkACQCAAKAIAIgMgACgCBCIFRwRAIAEoAgggBEECdGohASAFIANrQQN2IQUgACgCCCEHA0AgAygCACIAIAcoAggiBk8NAiAHKAIEIABBAnRqKAIAIQAgAiADQQRqKAIAIgY2AgAgAEEMahDbPCAGTQ0DIAEgACgCECAGQQJ0aigCADYCACADQQhqIQMgAUEEaiEBIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPCyAAIAZB/LSCARDDIQALIAIgABD8OzYCHCACQQI2AgggAkGosYIBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBuLGCARDvLAALxAIBBH8jAEGgAmsiAiQAIAEoAkghAyACQeABaiABQTxqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQJ2QQFrNgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQI0NwLYASACQdwAaiIEIAJBuAFqIgUgAUHMAGoQwhkCQEEMQQQQrTYiAwRAIAMgASkCQDcCACADQQhqIAFByABqKAIANgIAIAJBATYCnAIgAiADNgKYAiACQQE2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABEPAWIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCABENYoIAJBoAJqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAuuAgECfyABKAIIIQQCQAJAAkACQAJAAkAgASgCBCACaiICIAJBgKMFbSIDQYCjBWxrIgJBH3UgA2pBAWoOAwAEAQQLIAEoAgAiAUHwP3EiA0ERSQ0BIANBEGsgAUGPQHFyIQEMBAsgASgCACIBQfg/cSIDQdAtTQRAIANBEGogAUGHQHFyIQEMBAsgAUENdSIBQf7/D2tBgoBgSQ0BIAFBAWoiAUENdCABQZADbyIBQR91QZADcSABakH0yYYBai0AAHJBEHIhAQwDCyABQQ11QQFrIgEgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAABB8DNyEMYkIgENAgsgAEEANgIADwsgASgCACEBCyAAIAQ2AgggACACQYCjBWogAiACQQBIGzYCBCAAIAE2AgALrgIBAn8gASgCCCEEAkACQAJAAkACQAJAIAEoAgQgAmsiAiACQYCjBW0iA0GAowVsayICQR91IANqQQFqDgMABAEECyABKAIAIgFB8D9xIgNBEUkNASADQRBrIAFBj0BxciEBDAQLIAEoAgAiAUH4P3EiA0HQLU0EQCADQRBqIAFBh0BxciEBDAQLIAFBDXUiAUH+/w9rQYKAYEkNASABQQFqIgFBDXQgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAAByQRByIQEMAwsgAUENdUEBayIBIAFBkANvIgFBH3VBkANxIAFqQfTJhgFqLQAAQfAzchDGJCIBDQILIABBADYCAA8LIAEoAgAhAQsgACAENgIIIAAgAkGAowVqIAIgAkEASBs2AgQgACABNgIAC8ECAQZ/IwBB0ABrIgMkACADQQA2AgwCQAJAIAEoAggEQCADIAEoAigiBSACaiIEQQR0IgY2AhAgAAJ/IAYgASgCBCIHKAIIIghNBEAgAyAHEMgbIAQgBUkNAyAEIAMoAgQiAUsNBCADKAIAIQEgACACNgIIIAAgASAFQQR0ajYCBEGTgICAeAwBCyADIAg2AiwgA0Gk7YYBNgIUIANCBDcCICADQTs2AkwgA0E7NgJEIANBrQM2AjwgAyABQRhqNgI4IANBOzYCNCADQQQ2AhggAyADQTBqNgIcIAMgA0EsajYCSCADIANBEGo2AkAgAyADQQxqNgIwIABBBGogA0EUahCZDkGNgICAeAs2AgAgA0HQAGokAA8LQQBBAEHQ7IYBEMMhAAsgBSAEQeDshgEQsTsACyAEIAFB4OyGARCwOwALmgIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBBDPFiAAKAIIBSACCyAAKAIEaiECAkACQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoAAyACIAFBEnZB8AFyOgAAIAIgAUEGdkE/cUGAAXI6AAIgAiABQQx2QT9xQYABcjoAAQwDCyACIAFBP3FBgAFyOgACIAIgAUEMdkHgAXI6AAAgAiABQQZ2QT9xQYABcjoAAQwCCyACIAE6AAAMAQsgAiABQT9xQYABcjoAASACIAFBBnZBwAFyOgAACyAAIAMgBGo2AghBAAvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFBvNXCAEEHIAJBDGpBrNXCABDQEwwHCyACIABBBGo2AgwgAUHD1cIAQQMgAkEMakGs1cIAENATDAYLIAIgAEEEajYCDCABQcbVwgBBAyACQQxqQazVwgAQ0BMMBQsgAiAAQQRqNgIMIAFBydXCAEEKIAJBDGpBrNXCABDQEwwECyACIABBCGo2AgwgAUHk1cIAQQ8gAEEEakHwysIAIAJBDGpB1NXCABCDDwwDCyACIABBBGo2AgwgAUGE1sIAQQggAkEMakH01cIAENATDAILIAIgAEEEajYCDCABQYzWwgBBDCACQQxqQdTVwgAQ0BMMAQsgAiAAQQhqNgIMIAFBqNbCAEERIAJBDGpBmNbCABDQEwsgAkEQaiQAC9kCAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAIAAoAgBBAWsOBwECAwQFBgcACyACIABBBGo2AgwgAUGk68IAQQcgAkEMakGU68IAENATDAcLIAIgAEEEajYCDCABQavrwgBBAyACQQxqQZTrwgAQ0BMMBgsgAiAAQQRqNgIMIAFBruvCAEEDIAJBDGpBlOvCABDQEwwFCyACIABBBGo2AgwgAUGx68IAQQogAkEMakGU68IAENATDAQLIAIgAEEIajYCDCABQdzrwgBBDyAAQQRqQbzrwgAgAkEMakHM68IAEIMPDAMLIAIgAEEEajYCDCABQfzrwgBBCCACQQxqQezrwgAQ0BMMAgsgAiAAQQRqNgIMIAFBhOzCAEEMIAJBDGpBzOvCABDQEwwBCyACIABBCGo2AgwgAUGg7MIAQREgAkEMakGQ7MIAENATCyACQRBqJAALrAIBA38CQAJAIAAoAgAiACgCDCAAKAIQIAEoAgAiASgCDCABKAIQEMEuRQ0AIAEtACAgAC0AIEcNACAALQAhIAEtACFHDQACQCAALQAUIgNBEUYgAS0AFCICQRFGckUEQCACIANHDQICQAJAAkACQCADQQRrDgUABQECAwULIAAoAhggASgCGEcNBSAAKAIcIAEoAhxGDQQMBQsgAC0AFiABLQAWRw0EIAAtABUgAS0AFUYNAwwECyAALQAWIAEtABZHDQMgAC0AFSABLQAVRg0CDAMLIAAtABUgAS0AFUcNAiAALQAWIAEtABZGDQEMAgsgA0ERRyACQRFHcg0BCyABKAIAIQIgACgCAEEBRw0BIAJFDQAgACgCBCABKAIERiEECyAEDwsgAkEBcwvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFBxJvDAEEHIAJBDGpBtJvDABDQEwwHCyACIABBBGo2AgwgAUHLm8MAQQMgAkEMakG0m8MAENATDAYLIAIgAEEEajYCDCABQc6bwwBBAyACQQxqQbSbwwAQ0BMMBQsgAiAAQQRqNgIMIAFB0ZvDAEEKIAJBDGpBtJvDABDQEwwECyACIABBCGo2AgwgAUH8m8MAQQ8gAEEEakHcm8MAIAJBDGpB7JvDABCDDwwDCyACIABBBGo2AgwgAUGcnMMAQQggAkEMakGMnMMAENATDAILIAIgAEEEajYCDCABQaScwwBBDCACQQxqQeybwwAQ0BMMAQsgAiAAQQhqNgIMIAFBwJzDAEERIAJBDGpBsJzDABDQEwsgAkEQaiQAC4YCAQt/IAAgAUEDdEEIayIDaiEFIAIgA2ohBiAAIAFBAXYiB0EDdGoiA0EIayEEA0AgAiADIAAgAygCACIIIAAoAgAiCUkiChspAgA3AgAgBiAEIAUgBSgCACILIAQoAgAiDEkiDRspAgA3AgAgBkEIayEGIAJBCGohAiAEQXhBACANG2ohBCAFQXhBACALIAxPG2ohBSAAIAggCU9BA3RqIQAgAyAKQQN0aiEDIAdBAWsiBw0ACyAEQQhqIQQgAUEBcQR/IAIgACADIAAgBEkiARspAgA3AgAgAyAAIARPQQN0aiEDIAAgAUEDdGoFIAALIARHIAMgBUEIakdyRQRADwsQ5CsAC9kCAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAIAAoAgBBAWsOBwECAwQFBgcACyACIABBBGo2AgwgAUHkgM4AQQcgAkEMakHUgM4AENATDAcLIAIgAEEEajYCDCABQeuAzgBBAyACQQxqQdSAzgAQ0BMMBgsgAiAAQQRqNgIMIAFB7oDOAEEDIAJBDGpB1IDOABDQEwwFCyACIABBBGo2AgwgAUHxgM4AQQogAkEMakHUgM4AENATDAQLIAIgAEEIajYCDCABQZyBzgBBDyAAQQRqQfyAzgAgAkEMakGMgc4AEIMPDAMLIAIgAEEEajYCDCABQbyBzgBBCCACQQxqQayBzgAQ0BMMAgsgAiAAQQRqNgIMIAFBxIHOAEEMIAJBDGpBjIHOABDQEwwBCyACIABBCGo2AgwgAUHggc4AQREgAkEMakHQgc4AENATCyACQRBqJAAL2QIBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkAgACgCAEEBaw4HAQIDBAUGBwALIAIgAEEEajYCDCABQeCMzgBBByACQQxqQdCMzgAQ0BMMBwsgAiAAQQRqNgIMIAFB54zOAEEDIAJBDGpB0IzOABDQEwwGCyACIABBBGo2AgwgAUHqjM4AQQMgAkEMakHQjM4AENATDAULIAIgAEEEajYCDCABQe2MzgBBCiACQQxqQdCMzgAQ0BMMBAsgAiAAQQhqNgIMIAFBmI3OAEEPIABBBGpB+IzOACACQQxqQYiNzgAQgw8MAwsgAiAAQQRqNgIMIAFBuI3OAEEIIAJBDGpBqI3OABDQEwwCCyACIABBBGo2AgwgAUHAjc4AQQwgAkEMakGIjc4AENATDAELIAIgAEEIajYCDCABQdyNzgBBESACQQxqQcyNzgAQ0BMLIAJBEGokAAuxAgIDfgh/QQICfwJAAkAgACgCTEUNACAAQdAAaiABEO4LIQIgACgCQCIGQUBqIQggACgCRCIHIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQkgASgCBCEKQQAhAQNAIAUgBmopAAAiAyAEhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAKIAkgCCACeqdBA3YgBWogB3EiC0EGdGsiDCgCBCAMKAIIEOQcDQQgAkIBfSACgyICUEUNAAsLIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0BIAUgAUEIaiIBaiAHcSEFDAALAAsgAC0AKgwBCyAALQAqIAZBACALa0EGdGpBBmstAAAiACAAQQNGGwsiACAAQf8BcUEDRhsL2QIBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkAgACgCAEEBaw4HAQIDBAUGBwALIAIgAEEEajYCDCABQdCFzwBBByACQQxqQcCFzwAQ0BMMBwsgAiAAQQRqNgIMIAFB14XPAEEDIAJBDGpBwIXPABDQEwwGCyACIABBBGo2AgwgAUHahc8AQQMgAkEMakHAhc8AENATDAULIAIgAEEEajYCDCABQd2FzwBBCiACQQxqQcCFzwAQ0BMMBAsgAiAAQQhqNgIMIAFBiIbPAEEPIABBBGpB6IXPACACQQxqQfiFzwAQgw8MAwsgAiAAQQRqNgIMIAFBqIbPAEEIIAJBDGpBmIbPABDQEwwCCyACIABBBGo2AgwgAUGwhs8AQQwgAkEMakH4hc8AENATDAELIAIgAEEIajYCDCABQcyGzwBBESACQQxqQbyGzwAQ0BMLIAJBEGokAAvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFB0MHPAEEHIAJBDGpBwMHPABDQEwwHCyACIABBBGo2AgwgAUHXwc8AQQMgAkEMakHAwc8AENATDAYLIAIgAEEEajYCDCABQdrBzwBBAyACQQxqQcDBzwAQ0BMMBQsgAiAAQQRqNgIMIAFB3cHPAEEKIAJBDGpBwMHPABDQEwwECyACIABBCGo2AgwgAUHnwc8AQQ8gAEEEakHYn88AIAJBDGpBhKDPABCDDwwDCyACIABBBGo2AgwgAUGIws8AQQggAkEMakH4wc8AENATDAILIAIgAEEEajYCDCABQZDCzwBBDCACQQxqQYSgzwAQ0BMMAQsgAiAAQQhqNgIMIAFBrMLPAEERIAJBDGpBnMLPABDQEwsgAkEQaiQAC60CAgJ/AX4gACgCDCEGAkAgASACaiIHIANBIGsiA00EQCACKQAAIQggBkEIaiACQQhqKQAANwAAIAYgCDcAACABQRFJDQEgACgCDEEQaiACQRBqIAFBEGsQ2BkMAQsCQCACIANLBEAgAiEDDAELIAYgAiADIAJrIgIQ2BkgAiAGaiEGCwNAIAMgB08NASAGIAMtAAA6AAAgBkEBaiEGIANBAWohAwwACwALIAAgACgCDCABajYCDAJAIAFB//8DTQRAIAAoAgQhAwwBCyAAQQE2AiQgACAAKAIEIgMgACgCAGtBA3U2AigLIAMgBDYCACADIAE7AQQgBUEDayIBQYCABE8EQCAAQQI2AiQgACADIAAoAgBrQQN1NgIoCyADIAE7AQYgACADQQhqNgIEC7ECAQF/IwBBgAFrIg4kACAOIAM2AnwCQAJAAkACQAJAAkAgAkEBaw4DAAMCAQsgBkUEQEG4fyEKDAULIAMgBS0AACICSQ0DIAIgCGotAAAhAyAAQQA6AAsgACADOgAKIABBADsBCCABIAA2AgAgByACQQJ0aigCACEBIABCADcCACAAIAE2AgxBASEKDAQLIAEgCTYCAEEAIQoMAwsgCkUNAUEAIQogC0UgDEEZSXINAkEIIAR0QQhyIQBBACEDA0AgACADTQ0DIANBQGshAwwACwALQWwhCiAOIA5B/ABqIA5B+ABqIAUgBhCCNyICQYh/Sw0BIA4oAngiAyAESw0BIAAgDiAOKAJ8IAcgCCADIA0Q5gggASAANgIAIAIhCgwBC0FsIQoLIA5BgAFqJAAgCguqAgIBfwR+IwBBkAFrIgYkACAGQRBqIAEpAwAiCEIAIABCAoYiAEIChCIHQgAQqB4gBkHgAGogASkDCCIKQgAgB0IAEKgeIAYgBikDGCIHIAYpA2B8IgkgBikDaCAHIAlWrXwgAkH/AHFBwABzIgEQxyMgAyAGKQMANwMAIAZBMGogCEIAIAAgBUF/c6x8IgdCABCoHiAGQfAAaiAKQgAgB0IAEKgeIAZBIGogBikDOCIHIAYpA3B8IgkgBikDeCAHIAlWrXwgARDHIyAEIAYpAyA3AwAgBkHQAGogCEIAIABCABCoHiAGQYABaiAKQgAgAEIAEKgeIAZBQGsgBikDWCIAIAYpA4ABfCIIIAYpA4gBIAAgCFatfCABEMcjIAYpA0AgBkGQAWokAAvQAgEEfyMAQSBrIgUkAEEBIQcCQCAALQAEDQAgAC0ABSEIIAAoAgAiBi0ACkGAAXFFBEAgBigCAEHP8YkBQczxiQEgCEEBcSIIG0ECQQMgCBsgBigCBCgCDBEGAA0BIAYoAgAgASACIAYoAgQoAgwRBgANASAGKAIAQZzxiQFBAiAGKAIEKAIMEQYADQEgAyAGIAQoAgwRAgAhBwwBCyAIQQFxRQRAIAYoAgBB0fGJAUEDIAYoAgQoAgwRBgANAQsgBUEBOgAPIAVBsPGJATYCFCAFIAYpAgA3AgAgBSAGKQIINwIYIAUgBUEPajYCCCAFIAU2AhAgBSABIAIQzAoNACAFQZzxiQFBAhDMCg0AIAMgBUEQaiAEKAIMEQIADQAgBSgCEEHU8YkBQQIgBSgCFCgCDBEGACEHCyAAQQE6AAUgACAHOgAEIAVBIGokACAAC2QBAX8CQAJAAkACQAJAQQsgACgCACIBQYCAgIB4cyABQQBOGw4QBAAEBAQEBAMEBAQBBAQEAgMLIABBBGoQvCoPCyAAEN47IABBDGoQuS4PCyAAQQRqEN47Cw8LIABBBGoQ3jsLkwIBBX8CQCABQRFJIANBDElyDQAgAEEGaiIHIAFBBmsgAiADQQNqQQJ2IgYgBBCtEiIFQYh/SwRAIAUPCyAFQYCABGtBgYB8SQ0AIAAgBTsAACAFIAdqIgUgACABaiIHIAVrIAIgBmoiCCAGIAQQrRIiAUGIf0sEQCABDwsgAUGAgARrQYGAfEkNACAAIAE7AAIgASAFaiIFIAcgBWsgBiAIaiIIIAYgBBCtEiIBQYh/SwRAIAEPCyABQYCABGtBgYB8SQ0AIAAgATsABCABIAVqIgUgByAFayAGIAhqIgEgAiADaiABayAEEK0SIgFBiH9LBEAgAQ8LIAFBgIAEa0GBgHxJDQAgASAFaiAAayEJCyAJC70CAgR/BH4jAEHgAGsiAiQAIAAoAgAhBCACQUBrIAAoAgQoAhAgAWotAAAQki0gAkEQaiIFIAIpA0AgAikDSCACKQNQIAIpA1ggBCgCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBUEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBCgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAu9AgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFqLQAAELQuIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALtgMCCH8DfgJ/IAEoAhgEQANAAkAgASkDACIKUEUEQCABKAIQIQIMAQsgASgCECECIAEoAgghAwNAIAJBCGshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIKQoCBgoSIkKDAgH9RDQALIAEgAjYCECABIAM2AgggCkKAgYKEiJCgwIB/hSEKCyABIApCAX0gCoM3AwAgAiAKeqdBA3ZrIAEgASgCGEEBayIGNgIYQQFrIQMCQAJAIAEoAiAiAigCDEUNACACKAIAIgdBAWshCCACKAIEIgQgAkEQaiADEMMQIgqncSECIApCGYhC/wCDQoGChIiQoMCAAX4hDEEAIQUDQCACIAdqKQAAIgsgDIUiCkJ/hSAKQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgpQRQRAIAMtAAAhCQNAIAkgCCAKeqdBA3YgAmogBHFrLQAARg0EIApCAX0gCoMiClBFDQALCyALIAtCAYaDQoCBgoSIkKDAgH+DUEUNASACIAVBCGoiBWogBHEhAgwACwALIAMtAAAhAkEBDAMLIAYNAAsLQQALIQEgACACOgABIAAgAToAAAuQAQEBfwJAAkAgACgCACIBQZOAgIB4Rg0AAkACQAJAQQsgAUGAgICAeHMgAUEAThsOEAQABAQEBAQDBAQEAQQEBAIDCyAAQQRqELwqDwsgAEEBQQEQ4B4gAC0ADEEDRw0BIAAoAhAiABC8KiAAQQxBBBD4Og8LIABBBGpBAUEBEOAeCw8LIABBBGpBAUEBEOAeC7kDAgJ/AW8jAEFAaiICJAAgAiABNgIIIAJBGGogAkEIahCSHwJAAkACQCACAn4gAigCGCIBQYCAgIB4RwRAIAIpAhwMAQsgAkEIaiIBQQAgARCqOxsiAUUNASABKAIAJQEQTSEEEN8SIgEgBCYBIAIgATYCMCACQTRqIgEgAkEwahCSHyACQSRqIQMCQCABKAIAQYCAgIB4RwRAIAMgASkCADcCACADQQhqIAFBCGooAgA2AgAMAQtBoq2IAUExEJc9AAsgAigCMCIBQYQBTwRAIAEQ8h8LIAIoAiQiAUGAgICAeEYNASACKQIoCzcCEAwBCyACQTRqQQ1BAEEBQQEQoBggAigCOCEBIAIoAjRBAUYNASACKAI8IgNBBWpBhdnDACkAADcAACADQYDZwwApAAA3AAAgAkENNgIUIAIgAzYCEAsgAiABNgIMQQxBBBCtNiIBRQRAQQRBDBCjPQALIAEgAkEMaiIDKQIANwIAIAFBCGogA0EIaigCADYCACAAQSggAUGo28MAEMkpIAIoAggiAEGEAU8EQCAAEPIfCyACQUBrJAAPCyABIAIoAjxB8NjDABD9LwALwwIBBH8jAEHwAWsiAiQAIAJBsAFqIAEQwgYgAkEAOwHoASACQQA2AuQBIAJBADYCzAEgAkEANgLAASACQgQ3AqgBIAJCADcCoAEgAkKAgICAwAA3ApgBIAJBADYCkAEgAiABKAIQNgK8ASACQcwAaiIEIAJBkAFqIgMQ3wcCQCACKAJMQYCAgIB4RwRAIAJBCGoiBSAEQcQA/AoAACABQQA2AhAgAyAFEIYXQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiADQTT8CgAAIABB9MDNADYCCCAAIAE2AgQgAEEINgIAIAJB8AFqJAAPCyACQaABaiACQeAAaigCADYCACACQZgBaiACQdgAaikCADcDACACIAIpAlA3A5ABQaizzQBBKyACQZABakGIs80AQfDXzQAQ1R4AC0EEQTwQoz0AC7QCAgd/AX4jAEEgayIDJAAgAUEIaiEHIAJB/wFxQQFGIQgCQAJAAkACQANAIANBADYCDCADQQA2AhAgAyABKALkKiIENgIUIAEoAuAqIQUgA0EANgIYIAcgAiADQQxqQQFBACADQRBqIANBFGogBSAEIANBGGogARDPCSADKAIYIgQEQCABKALoKiIGRQ0CIAQgASgC5CoiCUsNBCAGIAEoAuAqIgYgBCAGahC9JgtFBEAgASkD0CohCiABQQQ6ANAqIApC/wGDQgRRDQMgACAKNwIADAULIAhFBEAgASgC8ClBAkcNASABKAKwKg0BIABBBDoAAAwFCyABKAKwKg0ACyAAQQQ6AAAMAwtBiPTNABCyOwALQaj0zQAQsjsACyAEIAlBmPTNABCwOwALIANBIGokAAufAgIEfwF+IwBBIGsiAiQAIAJBCGogARDEGSACLQAMIQMCQCACKAIIIgRBBEcEQCAAIAIpAA03AAUgAEEMaiACQRRqKQAANwAAIAAgAzoABCAAIAQ2AgAMAQsgAkEIaiADQQ9xEK4tIAItAAwhBCACKAIIIgVBBEcEQCAAIAIpAA03AAUgAEEMaiACQRRqKQAANwAAIAAgBDoABCAAIAU2AgAMAQsCQAJAIANBBHYiA0EPRw0AIAJBCGogAUEMahCNFCACLQAIQQRGBEAgAigCDCEDDAELIAIpAwgiBkL/AYNCBFINASAGQiCIpyEDCyAAIAM2AgggACAEOgAEIABBBDYCAAwBCyACIAY3AwggACACQQhqENAJCyACQSBqJAALnwICBH8BfiMAQSBrIgIkACACQQhqIAEQmxMgAi0ADCEDAkAgAigCCCIEQQRHBEAgACACKQANNwAFIABBDGogAkEUaikAADcAACAAIAM6AAQgACAENgIADAELIAJBCGogA0EPcRCuLSACLQAMIQQgAigCCCIFQQRHBEAgACACKQANNwAFIABBDGogAkEUaikAADcAACAAIAQ6AAQgACAFNgIADAELAkACQCADQQR2IgNBD0cNACACQQhqIAFBDGoQ/xMgAi0ACEEERgRAIAIoAgwhAwwBCyACKQMIIgZC/wGDQgRSDQEgBkIgiKchAwsgACADNgIIIAAgBDoABCAAQQQ2AgAMAQsgAiAGNwMIIAAgAkEIahDQCQsgAkEgaiQAC4ICAQZ/IAFBACADG0UEQCABQQBHDwsCQCACLAAAIgQgACwAACIGc0EASCABIANGIgUgBCAGR3FyRQRAIAUNASAGQQd1IQQCQCABIANLIglFBEAgAyABayEFIARB/wFxIQcgAiEEA0AgBUUNBCAFQQFrIQUgBC0AACEIIARBAWohBCAHIAhGDQALDAELIAEgA2shBSAEQf8BcSEHIAAhBANAIAVFDQMgBUEBayEFIAQtAAAhCCAEQQFqIQQgByAIRg0ACwsgCSAGQQBIcw8LIAQgBkgPCyAAQQFqIAJBAWogAUEBayIAIANBAWsiAiAAIAJJGxCZJyIAIAEgA2sgABtBAEoLxgICAn8BfiMAQSBrIgMkAAJAAkACQCACRQRAQcAAIQJBAEHAABDRNEUNAyABKAIALwEYIQFCAiEFDAILIAMgASgCACIBLwEYIgI7AQQgAkEBRwRAIANCADcCFCADQoGAgIDAADcCDCADQczN0AA2AgggA0EEakG4zNAAIANBCGpB1M3QABCHKwALIAMgAS8BGiICOwEGIAJFDQAgA0IANwIUIANCgYCAgMAANwIMIANB+MzQADYCCCADQQZqQbrM0AAgA0EIakGAzdAAEIcrAAtBACECQQBBwAAQ0TQEQEGAgICAeCEEQsAAIQUMAQsMAQsgAEEANgIkIAAgATsBICAAQgA3AhggACACNgIUIABCwAA3AgwgACAFNwIEIAAgBDYCACADQSBqJAAPC0GUn9AAQSkgA0EIakHUotAAQcCf0AAQ1R4AC6QCAQN/AkACQAJAAkAgBQRAIAMhBwNAIAQgBkYNAiAHQYACOwEAIAdBAmohByAFIAZBAWoiBkcNAAsLIAJFBEBBACEFDAQLQQAhBUEAIQYDQCABIAZGDQMgBCAAIAZqLQAAIgdNDQIgAyAHQQF0aiIHLwEAQYACRgRAIAcgBTsBACAFQQFqIQULIAIgBkEBaiIGRw0ACyAFQf//A3EhBUEAIQYDQCABIAZGBEAgASABQYCi1gAQwyEACyAAIAZqIggtAAAiByAETwRAIAcgBEGQotYAEMMhAAsgCCADIAdBAXRqLQAAOgAAIAZBAWoiBiACRw0ACwwDCyAEIARBwKLWABDDIQALIAcgBEGwotYAEMMhAAsgASABQaCi1gAQwyEACyAFC9QCAQJ/IAAgARCYPiECAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAgAxCWPiIAQdDzigEoAgBGBEAgAigCBEEDcUEDRw0BQcjzigEgATYCACAAIAEgAhCJLgwCCyAAIAMQqScLAkACQAJAIAIoAgQiA0ECcUUEQCACQdTzigEoAgBGDQIgAkHQ84oBKAIARg0DIAIgA0F4cSICEKknIAAgASACaiIBENA0IABB0POKASgCAEcNAUHI84oBIAE2AgAPCyAAIAEgAhCJLgsgACABEIocDwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBCAAQdDzigEoAgBHDQFByPOKAUEANgIAQdDzigFBADYCAA8LQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLC64CAgV/AX4jAEHQAGsiAyQAIABBGGoiBSAAKAIgIAJBCEEIQbCxgwEQwyggAyABQcAA/AoAACADQcQAaiADENUJAkACQCADKAJEQQFGBEADQCADKAJIIgIgAygCTCIGSQRAIAJBA3QhAQNAIAIgACgCDCIETw0EIAJBAWoiByAETw0FIAAgACkDACAAKAIIIAFqIgJBCGopAwAgAikDAH1C/////w+DfCIINwMAIAAoAiAiAiAAKAIYRgRAIAVBwLGDARCzKAsgACgCHCACQQN0aiAINwMAIAAgAkEBajYCICABQQhqIQEgByICIAZHDQALCyADQcQAaiADENUJIAMoAkQNAAsLIANB0ABqJAAPCyACIARBnLCDARDDIQALIAJBAWogBEGcsIMBEMMhAAvfAgEDfyMAQcACayICJAAgAkGYAWpBhIiQIDYCACACQoSIkKDAgIGCBDcCkAEgAkIENwKIASACQgA3AoABIAJCgICAgMAANwJ4IAJBADYCcCACQQA7AcgBIAJBADYCxAEgAkEANgKsASACQQA2AqABIAIgASgCCDYCnAEgAkGcAmogARDgLCACIAIpApwCNwK4AiACQQA2ArQCIAIgAigCqAIiAzYCsAIgAiACKAKkAjYCrAIgAkEIaiACQawCahDXOyACKAIIIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAqwCNwIIIAFBEGogAkG0AmopAgA3AgAgAUEYaiACQbwCaigCADYCACACIAM2AtQBIAIgBDYC0AEgAiABNgLMASACQRRqIgEgAkHwAGogAkHMAWoQ+iMgAkHYAWoiAyABEM0cIAAgAxCtEyACQcACaiQAC98CAQN/IwBBwAJrIgIkACACQZgBakGFipQoNgIAIAJChYqUqNCgwYIFNwKQASACQgQ3AogBIAJCADcCgAEgAkKAgICAwAA3AnggAkEANgJwIAJBADsByAEgAkEANgLEASACQQA2AqwBIAJBADYCoAEgAiABKAIINgKcASACQZwCaiABEN4sIAIgAikCnAI3ArgCIAJBADYCtAIgAiACKAKoAiIDNgKwAiACIAIoAqQCNgKsAiACQQhqIAJBrAJqENc7IAIoAgghBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCrAI3AgggAUEQaiACQbQCaikCADcCACABQRhqIAJBvAJqKAIANgIAIAIgAzYC1AEgAiAENgLQASACIAE2AswBIAJBFGoiASACQfAAaiACQcwBahD6IyACQdgBaiIDIAEQzRwgACADELETIAJBwAJqJAALkQIBBH8CQCABQc3/e0EQIAAgAEEQTRsiAGtPDQAgAEEQIAFBC2pBeHEgAUELSRsiBGpBDGoQrAEiAkUNACACEJo+IQECQCAAQQFrIgMgAnFFBEAgASEADAELIAIgA2pBACAAa3EQmj4hAiABKAIEIgVBeHEgAiAAQQAgAiABa0EQTRtqIgAgAWsiAmshAyAFQQNxBEAgACADEO4sIAEgAhDuLCABIAIQrg4MAQsgASgCACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAEQRBqTQ0AIAAgBBCYPiEBIAAgBBDuLCABIAIgBGsiBBDuLCABIAQQrg4LIAAQmT4hAwsgAwuoAgEFfyMAQRBrIgMkAAJ/IAAvAQAiAEHoB08EQCADIAAgAEGQzgBuIgRBkM4AbGsiAkH//wNxQeQAbiIFQQF0IgZB4/OJAWotAAA6AA0gAyAGQeLziQFqLQAAOgAMIAMgAiAFQeQAbGtB//8DcUEBdCICQePziQFqLQAAOgAPIAMgAkHi84kBai0AADoADkEBDAELIAAhBEEFIABBCkkNABogAyAAIABB5ABuIgRB5ABsa0H//wNxQQF0IgJB4/OJAWotAAA6AA8gAyACQeLziQFqLQAAOgAOQQMLIQJBACAAIAQbRQRAIAJBAWsiAiADQQtqaiAEQQF0QR5xQePziQFqLQAAOgAACyABQQFBAUEAIANBC2ogAmpBBSACaxCBCSADQRBqJAALnQIBBX8CQAJAAkACQCACQQNqQXxxIgQgAkYNACADIAQgAmsiBCADIARJGyIFRQ0AQQAhBCABQf8BcSEGQQEhBwNAIAIgBGotAAAgBkYNBCAFIARBAWoiBEcNAAsgBSADQQhrIghLDQIMAQsgA0EIayEIQQAhBQsgAUH/AXFBgYKECGwhBANAQYCChAggAiAFaiIHKAIAIARzIgZrIAZyQYCChAggB0EEaigCACAEcyIGayAGcnFBgIGChHhxQYCBgoR4Rw0BIAVBCGoiBSAITQ0ACwsgAyAFRwRAIAFB/wFxIQRBASEHA0AgBCACIAVqLQAARgRAIAUhBAwDCyADIAVBAWoiBUcNAAsLQQAhBwsgACAENgIEIAAgBzYCAAudAgEEfyAAKAIEIQcgACAAKAIAIgg2AgQgACACQf8BcSICNgIAIANFBEAgAEEBIAJBAmpBACACIAdHGyAIQQFqIAJGGyICai0AwAQgACACQQF0ajMBCCAEIAUgBhDlEgtBFEEOIAFB8AVLG0EHQQAgAUEoSxsgAUGwAUsbIgJBwgZqIQMgAkEDdEHc49EAaiEKIAJBAXQgAGpBjARqIQcCQANAIAchCCAKIQkgAyICQdsGRg0BIAJBAWohAyAIQQJqIQcgASAJQQhqIgooAgBPDQALIANBwwZrIgNBGkkNACADQRpBvOnRABDDIQALIAAgAmotAAAgCDMBACAEIAUgBhDlEiAJQQRqKAIAIAEgCSgCAGutIAQgBSAGEOUSC7MCAQN/IwBBMGsiAiQAIAAoAgAiAEEBIAAoAjQiAyADQQFNGzYCNCAAKAIIGiAAQTBqIgNBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIANBARCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBARAIAIoAgAgAToAACAAKAIwIQMgACgCFCIBIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIAFBA3RqIgRBBjsBBCAEIAM2AgAgACABQQFqNgIUIAJBMGokAA8LIAJBADYCKCACQQE2AhwgAkH0yP4ANgIYIAJCBDcCICACQRhqQbzH/gAQ7ywAC5ICAQZ/IABBFGoiAxDmOiAAKAIUBEAgACgCJEEBaiIEQQN2IARBB3FBAEdqIgIgACgCICIBSwRAIAIgAWshBSAAKAIYIgYgAkkEQCADIAZBAXQiASACEM0qIgMgASADSxsQ6BkgACgCICEBCyAFBEAgACgCHCABakEAIAX8CwALIAAgAjYCIAsgACAENgIkIAAoAhBBAWoiBEEDdiAEQQdxQQBHaiICIAAoAgwiAUsEQCACIAFrIQUgACgCBCIDIAJJBEAgACADQQF0IgEgAhDNKiIDIAEgA0sbEOgZIAAoAgwhAQsgBQRAIAAoAgggAWpBACAF/AsACyAAIAI2AgwLIAAgBDYCEA8LQejB/wAQsjsAC7YCAQR/IwBBIGsiByQAAkACQCABQdsAIAIoAhAiCRECAA0AIAMgBEkEQCAHQQhqIAUgAyABIAIgBigCDBEHACAHKAIIIghBlICAgHhHBEAgACAHKQIMNwIEIABBDGogB0EUaikCADcCAAwDCyADQQFqIQMLIAMgBEkEQCAGKAIMIQYgAigCFCEKA0AgB0EANgIYIAdBjJaBATYCCCAHQgQ3AhAgB0EBNgIMIAEgB0EIaiIIIAoRAgANAiAIIAUgAyABIAIgBhEHACAHKAIIIghBlICAgHhHBEAgACAHKQIMNwIEIABBDGogB0EUaikCADcCAAwECyAEIANBAWoiA0cNAAsLQZOAgIB4QZSAgIB4IAFB3QAgCRECABshCAwBC0GTgICAeCEICyAAIAg2AgAgB0EgaiQAC60CAgV/BH4jAEGgAWsiASQAIAFBCGoiAhDVEyAAIAEpA2g3A2AgAEHoAGogAUHwAGooAgA2AgAgACABKQJ0NwJsIABB9ABqIAFB/ABqKAIANgIAIAAgASkDSDcDQCAAQcgAaiABQdAAaikDADcDACAAQdAAaiABQdgAaikDADcDACAAQdgAaiABQeAAaikDADcDACABKQKMASEGIAEpApQBIQcgAS8BnAEhAyABLQCeASEEIABBgAFqIAFBiAFqKAIANgIAIAAgASkDgAE3A3ggASkDOCEIIAEpA0AhCSABLQCfASEFIAAgAkEw/AoAACAAIAU6AJcBIAAgBDoAlgEgACADOwGUASAAIAc3AowBIAAgBjcChAEgACAJNwM4IAAgCDcDMCABQaABaiQAC9cCAQF/IwBBMGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUH/AXEODQEAAAIDBAUGBwgJCgsACyACIAE6AA8gAkECNgIUIAJB8LPOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAsLIABBBDYCACAAQQA6AAQMCgsgAEEENgIAIABBAzoABAwJCyAAQQQ2AgAgAEEFOgAEDAgLIABBBDYCACAAQQY6AAQMBwsgAEEENgIAIABBBzoABAwGCyAAQQQ2AgAgAEEEOgAEDAULIABBBDYCACAAQQg6AAQMBAsgAEEENgIAIABBDToABAwDCyAAQQQ2AgAgAEEMOgAEDAILIABBBDYCACAAQQs6AAQMAQsgAEEENgIAIABBCjoABAsgAkEwaiQAC5UCAQJ/IwBBIGsiAiQAAkACQCABKAIAIgFBAE4EQCACQRRqQQpBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYNAiACQQA2AhAgAiACKAIcNgIMIAIgAzYCCAwBCyACQRRqQQtBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYNASACQQA2AhAgAiACKAIcNgIMIAIgAzYCCCACQQhqQQEQ5S0gAigCDCACKAIQakEtOgAAIAJBATYCEAsgAiABIAFBH3UiA3MgA2sgAkEUahCwECACQQhqIAIoAgAiASABIAIoAgRqEL0mIABBCGogAkEQaigCADYCACAAIAIpAgg3AgAgAkEgaiQADwsgAyACKAIcQfiezwAQ/S8AC6UCAQV/IwBBQGoiAiQAIAEoAghBAkYEQCACQQA2AjAgAkKAgICAwAA3AiggAkEANgI8IAJCgICAgMAANwI0IAJBCGogAUEIahCKJiACKAIMIgMEQCACKAIIIQQgA0ECdCEFQQAhAwNAIAJBADYCGCACQoCAgIDAADcCECAEIANBAEEAIAJBKGogAkE0aiACQRBqIgYQ0wogA0EBaiEDIARBBGohBCAGEOo7IAVBBGsiBQ0ACwsgACACKQIoNwIAIAAgAikCNDcCDCAAIAE2AhggAEEIaiACQTBqKAIANgIAIABBFGogAkE8aigCADYCACACQUBrJAAPCyACQQA2AiAgAkEBNgIUIAJB/LvPADYCECACQgQ3AhggAkEQakGEvM8AEO8sAAuIBwEKfyMAQdAAayIEJAAgBCADNwMIIAEoAmBBgICAgHhHBEACQCABLQBwBEAgASgCaCEGIAEoAmQhBSAEIAFBEGo2AkwgBCACNgJIIARBADYCQCAEIAU2AjggBCAFIAZBBnRqNgI8IAQgBEEIajYCRCAEQSBqIQgjAEHQAGsiBSQAIAVBCDYCCCAFQUBrIARBOGoiAkEQaikCADcDACAFQThqIAJBCGopAgA3AwAgBSACKQIANwMwIAUgBUEIajYCSCAFQSRqIQkjAEFAaiICJAAgAkEUaiAFQTBqIgYQqCUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgtBBEEAQQRBDBCgGCACKAIkIQcgAigCIEEBRg0CIAIoAigiCiACKQIUNwIAIApBCGogAkEcaigCADYCACACQRBqIgxBATYCACACIAo2AgwgAiAHNgIIIAJBOGogBkEYaigCADYCACACQTBqIAZBEGopAgA3AwAgAkEoaiAGQQhqKQIANwMAIAIgBikCADcDICMAQRBrIgYkACAGQQRqIAsQqCUgBigCBEGAgICAeEcEQCACQQhqIQcDQCAHKAIIIgogBygCAEYEQCAHIApBAUEEQQwQ0CgLIAcoAgQgCkEMbGoiDSAGKQIENwIAIA1BCGogBkEMaigCADYCACAHIApBAWo2AgggBkEEaiALEKglIAYoAgRBgICAgHhHDQALCyAGQRBqJAAgCUEIaiAMKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAJBQGskAAwBCyAHIAIoAihByJfPABD9LwALAkAgBSgCCEEIRwRAIAggBSkDCDcDACAIQRBqIAVBGGopAwA3AwAgCEEIaiAFQRBqKQMANwMAIAkQxiogCUEEQQwQ4B4MAQsgCCAFKQIkNwIEIAhBCDYCACAIQQxqIAVBLGooAgA2AgALIAVB0ABqJAAgBEEYaiICIARBLGooAgA2AgAgBCAEKQIkNwMQIAQoAiAiBUEIRwRAIAQpAzAhAyAAIAQpAxA3AgQgACADNwMQIAAgBTYCACAAQQxqIAIoAgA2AgAMAgsgBEFAayIFIAIoAgA2AgAgBCAEKQMQNwM4IAFByABqELgvIAFB0ABqIAUoAgA2AgAgASAEKQM4NwJICyAAQQg2AgALIARB0ABqJAAPC0H49M8AELI7AAulAgEBfyMAQSBrIgMkACADIAI2AgQgAkGAAkYEQCAAIAFBEGoiAS8BADsBACAAIAFB4ANqLwEAOwEeIAAgAUHAA2ovAQA7ARwgACABQaADai8BADsBGiAAIAFBgANqLwEAOwEYIAAgAUHgAmovAQA7ARYgACABQcACai8BADsBFCAAIAFBoAJqLwEAOwESIAAgAUGAAmovAQA7ARAgACABQeABai8BADsBDiAAIAFBwAFqLwEAOwEMIAAgAUGgAWovAQA7AQogACABQYABai8BADsBCCAAIAFB4ABqLwEAOwEGIAAgAUFAay8BADsBBCAAIAFBIGovAQA7AQIgA0EgaiQADwsgA0EANgIIQQAgA0EEakG88dEAIANBCGpB8PTRABCvKwAL1wIBAX8jAEEwayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcQ4NAQAAAgMEBQYHCAkKCwALIAIgAToADyACQQI2AhQgAkHspP4ANgIQIAJCATcCHCACQbsHNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBAToAECAAQQE2AgAMCwsgAEEENgIAIABBADoABAwKCyAAQQQ2AgAgAEEDOgAEDAkLIABBBDYCACAAQQU6AAQMCAsgAEEENgIAIABBBjoABAwHCyAAQQQ2AgAgAEEHOgAEDAYLIABBBDYCACAAQQQ6AAQMBQsgAEEENgIAIABBCDoABAwECyAAQQQ2AgAgAEENOgAEDAMLIABBBDYCACAAQQw6AAQMAgsgAEEENgIAIABBCzoABAwBCyAAQQQ2AgAgAEEKOgAECyACQTBqJAALtAICBH8EfiMAQUBqIgMkACADQRBqIgQgACgCBCgCECABQQV0aiICKQMAIAIpAwggAikDECACKQMYIAAoAgAiBSgCACgCACICKQMAIAIpAwggAikDECACKQMYEJwGAkACQAJAIAMoAhAiAkEBRgRAIAJFDQEgBEEEchCIEQwBCyADKQMgIgYgAykDKCIHIAMpAzAiCCADKQM4IgkgBSgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NASADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0FAayQADwsgACACQYiL/wAQwyEAC4sCAQN/IwBBEGsiAiQAAkAgAUKAAVQNACAAQQhqIQQDQAJAIAIgAadBgAFyOgAHIAAtABQhAyACIAApAwA3AwggA0EDdiADQQdxQQBHaiIDQQlPDQAgBCACQQhqIAMQoTYgAEEAOgAUIABCADcDACAEIAJBB2pBARChNiABQoCAAVQgAUIHiCEBRQ0BDAILCyADQQhB6I7OABCwOwALIAIgATwAByAALQAUIQQgAiAAKQMANwMIIARBA3YgBEEHcUEAR2oiBEEJSQRAIABBCGoiAyACQQhqIAQQoTYgAEEAOgAUIABCADcDACADIAJBB2pBARChNiACQRBqJAAPCyAEQQhB6I7OABCwOwALpgICA34IfwJ/AkACQCAAKAJMRQ0AIABB0ABqIAEQ7gshAiAAKAJAIgZBQGohCCAAKAJEIgcgAqdxIQUgAkIZiEL/AINCgYKEiJCgwIABfiEEIAEoAgghCSABKAIEIQpBACEBA0AgBSAGaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAogCSAIIAJ6p0EDdiAFaiAHcSILQQZ0ayIMKAIEIAwoAggQ5BwNBCACQgF9IAKDIgJQRQ0ACwsgAyADQgGGg0KAgYKEiJCgwIB/g1BFDQEgBSABQQhqIgFqIAdxIQUMAAsACyAALQApDAELIAAtACkgBkEAIAtrQQZ0akEHay0AACIAIABBAkYbC0EBcQu6AgECfwJAAkACQAJAAkAgACAAKAKMByIJBH8gCQUgACAAKAKIB0EBaiIJNgKIByAJIAAoAgwiCk8NASAJIAAoAgQiCk8NAiAAKAIAIAlqLQAAIQogACAAKAIIIAlBAnRqKAIAIgk2AowHIAAgCiAIdDYCkAcgAEEsaiAJIApBACAFIAYgBxCeEiAAKAKMBwtBAWs2AowHIAAoApAHIAJqIgIgBE8NAiAAKAIgIAMgAkECdGooAgBsIAFqIgEgACgCFCICTw0DIAEgACgCHCICSQ0EIAEgAkHUrNAAEMMhAAsgCSAKQZSs0AAQwyEACyAJIApBpKzQABDDIQALIAIgBEG0rNAAEMMhAAsgASACQcSs0AAQwyEACyAAKAIQIAFqLQAAIAAoAhggAUEBdGozAQAgBSAGIAcQ5RILpAIBAn8jAEEgayIFJAACf0EAIAFBCEkNABogBEEEaiEGIAQoAgAhBCAFQQhqQgA3AwAgBUIANwMAIAUgADYCFCAFIAA2AhAgBSAAIAFqQQRrNgIYAkAgBEEMSSADIARsQQN2QQhqIAFNcUUEQCAFIAIgAyAGQQJBAEEAEPIMDAELAkACQAJAIARBCGsOBAEBAQACCyAFIAIgAyAGQQJBAUEAEPIMDAILIAUgAiADIAZBAkEBQQEQ8gwMAQsgBSACIAMgBkEDQQFBARDyDAsgBSAFKAIIQf////8HazYCCCAFIAUoAgBBAXZBgICAgHhyNgIAIAVBABCtJUEAIAUoAhQiACAFKAIYTw0AGiAAIAUoAhBrIAUtAAhBAEdqCyAFQSBqJAALjwYBDX8jAEEgayIFJAAgBSABEMUbAkACQAJAIAIoAigiAyACKAIkIgZqQQFqIgIgA08EQCACIAUoAgQiBEsNASACIANGDQIgBSgCACIERQ0CIAQgAkEDdGoiAkEIayILRQ0DAkAgBCADQQN0IgNqIgkoAgBFBEAgBUEIaiABIAMgBkEDdEEIahDmFQwBCyAFIAk2AhwgBSACNgIYIAUgCTYCFCMAQUBqIgEkACMAQSBrIgIkACACQRRqIAVBFGoiAygCBCADKAIAa0EDdkEAQQhBCBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEG4+/4AEP0vAAsgAUEQaiEKIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIGIAMoAgQgAygCAGtBA3YQ7C0gBCAGKQIEQiCJNwIIIAQgBkEIajYCBCAEQQRqIgcoAgQhBiAHKAIAIAMoAgAiCCADKAIEIg5HBEAgAygCCCEPIAcoAgggBkEDdGohAyAGIA4gCGtBA3YiB2ohBgNAIAMgCCkDACAPKQMAfTcDACAIQQhqIQggA0EIaiEDIAdBAWsiBw0ACwsgBjYCACAEQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgAUEcaiAKEN4sIAEgASkCHDcCOCABQQA2AjQgASABKAIoIgQ2AjAgASABKAIkNgIsIAFBCGogAUEsahDXOyABKAIIIQZBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAEpAiw3AgggBUEIaiIDIAQ2AgggAyAGNgIEIAMgAjYCACACQRBqIAFBNGopAgA3AgAgAkEYaiABQTxqKAIANgIAIAFBQGskAAsgCygCACECIAkoAgAhASAAIAUpAgg3AgAgACABNgIMIABBCGogBUEQaigCADYCACAAIAIgAWs2AhAgBUEgaiQADwsgAyACQZDR/gAQsTsACyACIARBkNH+ABCwOwALQaDR/gAQsjsAC0Gw0f4AELI7AAuPBgENfyMAQSBrIgUkACAFIAEQxxsCQAJAAkAgAigCKCIDIAIoAiQiBmpBAWoiAiADTwRAIAIgBSgCBCIESw0BIAIgA0YNAiAFKAIAIgRFDQIgBCACQQJ0aiICQQRrIgtFDQMCQCAEIANBAnQiA2oiCSgCAEUEQCAFQQhqIAEgAyAGQQJ0QQRqEOYVDAELIAUgCTYCHCAFIAI2AhggBSAJNgIUIwBBQGoiASQAIwBBIGsiAiQAIAJBFGogBUEUaiIDKAIEIAMoAgBrQQJ2QQBBBEEEEKAYIAIoAhghBCACKAIUQQFGBEAgBCACKAIcQbj7/gAQ/S8ACyABQRBqIQogAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgYgAygCBCADKAIAa0ECdhDuLSAEIAYpAgRCIIk3AgggBCAGQQhqNgIEIARBBGoiBygCBCEGIAcoAgAgAygCACIIIAMoAgQiDkcEQCADKAIIIQ8gBygCCCAGQQJ0aiEDIAYgDiAIa0ECdiIHaiEGA0AgAyAIKAIAIA8oAgBrNgIAIAhBBGohCCADQQRqIQMgB0EBayIHDQALCyAGNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACABQRxqIAoQ4CwgASABKQIcNwI4IAFBADYCNCABIAEoAigiBDYCMCABIAEoAiQ2AiwgAUEIaiABQSxqENc7IAEoAgghBkEcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgASkCLDcCCCAFQQhqIgMgBDYCCCADIAY2AgQgAyACNgIAIAJBEGogAUE0aikCADcCACACQRhqIAFBPGooAgA2AgAgAUFAayQACyALKAIAIQIgCSgCACEBIAAgBSkCCDcCACAAIAE2AgwgAEEIaiAFQRBqKAIANgIAIAAgAiABazYCECAFQSBqJAAPCyADIAJBkNH+ABCxOwALIAIgBEGQ0f4AELA7AAtBoNH+ABCyOwALQbDR/gAQsjsAC6wCAgJ/AnwjAEEgayIFJAAgA7ohByAAAn8CQAJAAkACQCAEIARBH3UiBnMgBmsiBkG1Ak8EQANAIAdEAAAAAAAAAABhDQUgBEEATg0CIAdEoMjrhfPM4X+jIQcgBEG0AmoiBCAEQR91IgZzIAZrIgZBtAJLDQALCyAGQQN0QYiyiAFqKwMAIQggBEEATg0BIAcgCKMhBwwDCyAFQQ42AhQgBSABQQxqIAEoAhQQ6gwgACAFQRRqIAUoAgAgBSgCBBD7KDYCBAwBCyAHIAiiIgeZRAAAAAAAAPB/Yg0BIAVBDjYCFCAFQQhqIAFBDGogASgCFBDqDCAAIAVBFGogBSgCCCAFKAIMEPsoNgIEC0EBDAELIAAgByAHmiACGzkDCEEACzYCACAFQSBqJAALgQICBH8BfiMAQSBrIgYkAAJAIAVFDQAgAiADaiIDIAJJDQAgBCAFakEBa0EAIARrca0gAyABKAIAIghBAXQiAiACIANJGyICQQhBBEEBIAVBgQhJGyAFQQFGGyIDIAIgA0sbIgOtfiIKQiCIpw0AIAqnIglBgICAgHggBGtLDQAgBiAIBH8gBiAFIAhsNgIcIAYgASgCBDYCFCAEBSAHCzYCGCAGQQhqIAQgCSAGQRRqEL4aIAYoAghBAUYEQCAGKAIQIQIgBigCDCEHDAELIAYoAgwhBCABIAM2AgAgASAENgIEQYGAgIB4IQcLIAAgAjYCBCAAIAc2AgAgBkEgaiQAC6kCAgN/An4jAEGgAWsiASQAIAFBCGoiAxDVEyAAIAEpA2g3A2AgAEHoAGogAUHwAGooAgA2AgAgACABKQJ0NwJsIABB9ABqIAFB/ABqKAIANgIAIAAgASkDSDcDQCAAQcgAaiABQdAAaikDADcDACAAQdAAaiABQdgAaikDADcDACAAQdgAaiABQeAAaikDADcDACABLQCeASECIAEpAowBIQQgASkClAEhBSAAIAEvAZwBOwGUASAAIAU3AowBIAAgBDcChAEgACACOgCWASAAQYABaiABQYgBaigCADYCACAAIAEpA4ABNwN4IAEpAzghBCABKQNAIQUgAS0AnwEhAiAAIANBMPwKAAAgACACOgCXASAAIAU3AzggACAENwMwIAFBoAFqJAALoAIBAX8CQAJAAkACQEECIAAoAmAiAUGAgICAeHMgAUEAThsOAgECAAsgAEHgAGoQ3jsgAEHsAGoQ3jsgAEH4AGoQ3SkgAEH8AGoQ3SkMAgsgAEHkAGoQ3jsMAQsgAEHkAGoQ3jsgAEHwAGoQ3SkLIAAoAgBBgICAgHhHBEAgAEEYakEIEO4oIAAQ3jsgAEEMakEEQQgQ4B4gAEHQAGoQ4zwLAkAgACgCnAFFDQAgACgCoAEiAUUNACAAQawBaiAAKAKkASAAKAKoASABKAIQEQEACwJAIAAoArABRQ0AIAAoArQBIgFFDQAgAEHAAWogACgCuAEgACgCvAEgASgCEBEBAAsgACgCkAFBgICAgHhHBEAgAEGQAWpBBEEgEOAeCwuWAgIDfwF+IAApAxAhBCAAKAIYIQEgAEEcaiEDIAAoAiwiAkERSQRAAn8gBEIQWgRAIAAoAgRBB3cgACgCAEEBd2ogACgCCEEMd2ogACgCDEESd2oMAQsgAUGxz9myAWoLIASnaiEBAkAgAkEESQRAIAMhAAwBCwNAIAMoAABBvdzKlXxsIAFqQRF3Qa/W074CbCEBIANBBGoiACEDIAJBBGsiAkEDSw0ACwsgAgRAA0AgAC0AABDUPUGxz9myAWwgAWpBC3dBsfPd8XlsIQEgAEEBaiEAIAJBAWsiAg0ACwsgAUEPdiABc0H3lK+veGwiAEENdiAAc0G93MqVfGwiAEEQdiAAc60PCyACQRBBpMnQABCwOwALkgQCA38BfiMAQSBrIggkAAJAAkACQCAGQf8BcUECRwRAIAggBjoACyAIQQxqIQYgCEELaiEJIwBBEGsiASQAAkACQAJAIAIEQCABIAI2AgQgBCABQQRqIgJBBBChNgJAAkAgCS0AAEEBRgRAQS4hCSACQS5BAEEBQQEQoBggASgCCCECIAEoAgRBAUYNBSABKAIMIgpByvr+AEEu/AoAAAwBC0EsIQkgAUEEakEsQQBBAUEBEKAYIAEoAgghAiABKAIEQQFGDQEgASgCDCIKQfD5/gBBLPwKAAALIAYgCTYCDCAGIAo2AgggBiACNgIEIAZBjYCAgHg2AgAMAgsMAgsgBkKTgICACDcCAAsgAUEQaiQADAELIAIgASgCDEHo+P4AEP0vAAsgCCgCECECIAgoAgwiAUGTgICAeEYNASAAIAgpAhQ3AgwgAEEUaiAIQRxqKAIANgIAIAAgAjYCCCAAIAE2AgQgAEEBNgIADAILIAQgASACEKE2CyADKAIIIgEgAygCAEYEQCADQZzU/gAQrigLIAMoAgQgAUEEdGoiBiACrSILNwAIIAYgBTcAACADIAFBAWo2AgggAiAHQQFrQf8BcSIBaiABQX9zcSACayIBQcEATw0BIARB/Mz+ACABEKE2IABBADYCACAAIAGtIAUgC3x8NwMICyAIQSBqJAAPCyABQcAAQazU/gAQsDsAC7cCAgJ/AX4jAEEgayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQMhAQwBCwJAIAEoAgRFDQAgBCABKAIUTw0CIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAhAQwBCyABIARBAWo2AhwgAiABKAIAIAQQjywgAkEMaiACKAIAIAIoAgQQsQxBACEBAkACQCACKAIMIgVB7f///wdqDgIAAgELIAIoAhAhBEEBIQEMAQsgAikCGCEGIAIoAhQhASACKAIQIQQgAygCAEGTgICAeEcEQCADEIgRCyADIAY3AgwgAyABNgIIIAMgBDYCBCADIAU2AgBBAiEBCyAAIAQ2AgQgACABNgIAIAJBIGokAA8LQfSngAFBIEGUqIABEJ8pAAu3AgICfwF+IwBBIGsiAiQAAkACQCABKAIcIgQgASgCIEYEQEEDIQEMAQsCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEAIQEMAQsgASAEQQFqNgIcIAIgASgCACAEENorIAJBDGogAigCACACKAIEELEMQQAhAQJAAkAgAigCDCIFQe3///8Hag4CAAIBCyACKAIQIQRBASEBDAELIAIpAhghBiACKAIUIQEgAigCECEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAGNwIMIAMgATYCCCADIAQ2AgQgAyAFNgIAQQIhAQsgACAENgIEIAAgATYCACACQSBqJAAPC0H0p4ABQSBBlKiAARCfKQALjgQDBH8BfgFvIwBBIGsiAiQAIAIgATYCCAJAIAJBCGooAgAlARBuBEAgAiABNgIMIwBBEGsiAyQAIAMgAkEMaiIFKAIAJQEQcyACQRBqIgQgAygCAAR+IAQgAykDCDcDCEIBBUIACzcDACADQRBqJABBASEDAkACQCACKAIQQQFHDQAgAikDGCIGEHwhBxDfEiIBIAcmASACIAE2AhAgBSgCACUBIAQoAgAlARB2QQBHIAFBhAFPBEAgARDyHwsgAigCDCEBRQ0AIAFBhAFPBEAgARDyHwsgBkKAgICAEFoNASAGpyEEQQAhAwwDC0G0ycMAQcgAENwbIQQgAUGEAUkNAiABEPIfDAILIAJBAToAECACIAY3AxggAkEQaiACQQxqENEiIQQMAQsjAEEwayIDJAAgA0EIaiIBIAJBCGoiBSgCACUBEEsEfiABIAUoAgAlARBp/AY3AwhCAQVCAAs3AwBBASEEIAICfwJAIAMoAghBAUYEQCADKQMQIgZCAFkNAQsgBSADQS9qQYDGwwAQ0QsMAQsgBkKAgICAEFQEQEEAIQQgBqcMAQsgA0EBOgAYIAMgBjcDICADQRhqIANBL2oQ0SILNgIEIAIgBDYCACADQTBqJAAgAigCBCEEIAIoAgAhAyACKAIIIgFBhAFJDQAgARDyHwsgACAENgIEIAAgAzYCACACQSBqJAAL/wEBB38jAEEgayIEJAACQAJAIAJFBEAMAQsgA0UNACABKAJIIQUgASgCRCEIA0AgBSAIRgRAIARBCGogARDyGyAEKAIIIgVBCEcEQCAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwECyABKAJEIghFDQIgASgCSCEFCyAEQQhqIAEgAiAHayADIAZrEOoTIAQoAgghCiAEKAIQIQkgASAELQAMOgBMIAEgBSAJaiIFNgJIIAYgCWohBiAHIApqIgcgAk8NASADIAZLDQALCyAAIAY2AgggACAHNgIEQQghBQsgACAFNgIAIARBIGokAAvxAQEDfyAAKAJAQQJHBEAgACgCGEEBaiIDZyECIAACfyABBEBBHyACayICQQh0IANBCHQgAnZqDAELQYA+IAJBCHRrCzYCKAsgACgCHEEBaiIDZyECAn8gAQRAQR8gAmsiAUEIdCADQQh0IAF2aiEBQR8gACgCJEEBaiICZ2siA0EIdCACQQh0IAN2aiECQR8gACgCIEEBaiIDZ2siBEEIdCADQQh0IAR2agwBC0GAPiACQQh0ayEBQYA+IAAoAiRBAWpnQQh0ayECQYA+IAAoAiBBAWpnQQh0awshAyAAIAI2AjQgACADNgIwIAAgATYCLAuZAgIDfwJ+IwBBIGsiAyQAIAJBAWsiBEH//wNxEMoqQf8BcSICQR5JBEAgAUH/AXFBAnQiBUGO5vsAai8BACEBIAVBjOb7AGozAQAhByACQQJ0QYzu+wBqMwEAIQYgAkGw2/sAai0AACIFBH8gBCACQQF0Qc7b+wBqLwEAa61C//8Dg0IFhiAGhCEGIAVBBWoFQQULIQIgBiABQT9xrYYgB4QhBgJAIAAtABgiBCABIAJqaiIBQf8BcUHAAE8EQCAAIAYgARDwEAwBCyAAIAE6ABggACAAKQMQIAYgBK2GhDcDEAsgA0EgaiQADwsgA0EANgIYIANBATYCDCADQZjb+wA2AgggA0IENwIQIANBCGpBoNv7ABDvLAALkgICBH8BfiAAIAEgAhChNgJAIAAoAhgEQCAAKAIoIgRBAWoiBUEDdiAFQQdxQQBHaiIBIAAoAiQiAksEQCABIAJrIQYgACgCHCIDIAFJBEAgAEEYaiADQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAiQhAgsgBgRAIAAoAiAgAmpBACAG/AsACyAAIAE2AiQLIAAgBTYCKCAAKAIgIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAAIAAoAixBAWo2AiwLIAA1AgghByAAKAIUIgEgACgCDEYEQCAAQQxqQeD0/wAQsygLIAAoAhAgAUEDdGogBzcDACAAIAFBAWo2AhQLkAIBBH8gACABIAIQoTYCQCAAKAIYBEAgACgCKCIEQQFqIgVBA3YgBUEHcUEAR2oiASAAKAIkIgJLBEAgASACayEGIAAoAhwiAyABSQRAIABBGGogA0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIkIQILIAYEQCAAKAIgIAJqQQAgBvwLAAsgACABNgIkCyAAIAU2AiggACgCICAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgACAAKAIsQQFqNgIsCyAAKAIIIQIgACgCFCIBIAAoAgxGBEAgAEEMakHg9P8AEJ0oCyAAKAIQIAFBAnRqIAI2AgAgACABQQFqNgIUC7QCAgJ/AX4jAEEgayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQMhAQwBCwJAIAEoAgRFDQAgBCABKAIUTw0CIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAhAQwBCyABIARBAWo2AhwgAiABIAQQrSogAkEMaiACKAIAIAIoAgQQsQxBACEBAkACQCACKAIMIgVB7f///wdqDgIAAgELIAIoAhAhBEEBIQEMAQsgAikCGCEGIAIoAhQhASACKAIQIQQgAygCAEGTgICAeEcEQCADEIgRCyADIAY3AgwgAyABNgIIIAMgBDYCBCADIAU2AgBBAiEBCyAAIAQ2AgQgACABNgIAIAJBIGokAA8LQfSngAFBIEGUqIABEJ8pAAuyAgICfwF+IwBBMGsiAyQAAkAgAkELTwRAIANBGGoiBEEBIAEgAhCCAwJAAkAgAygCGEGTgICAeEcEQCAEEIgRDAELIAMoAhwiAQ0BCyAAQgA3AwAMAgsgAykCICEFIAMgATYCGCADQRhqENEfIQEgAEIBNwMAIAAgBUIgiKdBwIQ9bq0gAaxCgKMFfiAFQv////8Pg3xC6Ad+fEKA6My6sZAOfTcDCAwBCyABIAIQxQIiAQRAIANCADcDACADIAE2AgwgAyADKQMANwIQIANBGGogA0EMahDKLyADIAMoAhg2AiwgA0EsahDRHyEBIABCATcDACAAIAMoAiBBwIQ9bq0gAzUCHCABrEKAowV+fELoB358QoDozLqxkA59NwMIDAELIABCADcDAAsgA0EwaiQAC6oCAQd/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQcCQAJAIAAoAgAiAyAAKAIEIgVHBEAgASgCCCEIIAUgA2tBA3YhASAAKAIIIQUDQCADKAIAIgAgBSgCCCIGTw0CIAUoAgQgAEECdGooAgAhACACIANBBGooAgAiBjYCACAGIABBDGooAghPDQMgBCAIaiAAKAIQIAZqLQAAOgAAIANBCGohAyAEQQFqIQQgAUEBayIBDQALCyAHIAQ2AgAgAkEwaiQADwsgACAGQfy0ggEQwyEACyACIAAQozw2AhwgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywAC4wCAQF/IwBBEGsiAiQAIAAoAgAhAAJ/IAEtAAtBGHFFBEAgASgCACAAIAEoAgQoAhARAgAMAQsgAkEANgIMIAEgAkEMagJ/AkAgAEGAAU8EQCAAQYAQSQ0BIABBgIAETwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfABcjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAOIAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoADUEDDAILIAIgADoADEEBDAELIAIgAEE/cUGAAXI6AA0gAiAAQQZ2QcABcjoADEECCxDWCQsgAkEQaiQAC4kCAQR/IwBBEGsiAkEANgIMAn8CQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoADyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAMLIAIgAUE/cUGAAXI6AA4gAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANQQMMAgsgAiABOgAMQQEMAQsgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQILIgEgACgCACIDaiIEIANJIARBD0tyIgVFBEAgAQRAIAAgA2pBBGogAkEMaiAB/AoAAAsgACAENgIACyAFC7oCAgN/AX4jAEEwayIDJAACQCABAn8CQAJAAkACQAJAIAEtAERBAWsOAwMAAgELAAsgA0EIaiIEIAFBQGsoAgA2AgAgAyABKQI4NwMAIAEoAjQhBSADQQxqIAEpAwAiBiABKQMIIAZ9ENgfIAFBADoAMCABIAU2AiggAUEgaiADQRBqKQMANwIAIAFBGGogBCkDADcCACABIAMpAwA3AhALIANBHGogAUEQaiIFIAIQsQ4gAygCHEUNASAAQQk2AgBBAwwCC0GM9MIAEOgrAAsgAykCKCEGIAMoAiQhAiADKAIgIQQgBRCgJSAERQ0BIAAgBjcCDCAAIAI2AgggACAENgIEIABBCDYCAEEBCzoARCADQTBqJAAPCyADIAI2AhxBnODCAEErIANBHGpB2ODCAEGc9MIAENUeAAuLAgICfwF+AkAgAUEfcSIJQRhNBEACQCAEIAlJDQAgACgCBCAJQQJ0aigCACAJIAFBBXYiBGxqIgFBob8HTw0CIAIgAyAAKAIIIAFqQaC/ByABayAJELIgIgFFIAFBCmogCU1yDQAgBCAFakKA5LTRrcHUjQcgCSABa60iC0IGfohCP4MgC0IChnynIAAoAgAgCWotAAB0akEBaiIAIAZLDQAgASAHQQJ2bK0gAGdBIGpBP3NBHmytfUKAD3wiCyAIKQMAVA0AIAggADYCECAIIAE2AgggCCALNwMAIAggASAJczYCDEEBIQoLIAoPCyAJQRlB+JrSABDDIQALIAFBoL8HQYib0gAQrzsAC4wCAQV/IwBBEGsiACQAAkAgASgCLARAIAFBLGohByABKAJMIgIgA2oiBEEDdiAEQQdxQQBHaiIEIAEoAjgiBUsEQCAEIAVrIQggASgCMCIGIARJBEAgByAGQQF0IgUgBBDcKiIGIAUgBksbEOgZIAEoAjghBQsgCARAIAEoAjQgBWpBACAI/AsACyABIAQ2AjgLIABBCGogBxCGPSADBEAgACgCDCEBIAAoAgghBQNAIAJBA3YiBCABTw0DIAQgBWoiBCAELQAAQQEgAkEHcXRyOgAAIAJBAWohAiADQQFrIgMNAAsLIABBEGokAA8LQcyPhwFBHUHsj4cBEMskAAsgBCABQYyLhwEQwyEAC5kCAQN/IwBBEGsiBCQAAkACQCABKAIIQQFGBEAgASgCACEFIAEoAgQhBiABQQxBBBD4OiAEQQhqIgEgBjYCACAEIAIgBWsiAiADajYCBCAEIAU2AgAgBEEHQSAgBkEKdmdrIgMgA0EHTxtBAnRBAXI2AgwgBCACEKceIABBCGogASkCADcCACAAIAQpAgA3AgAMAQsgBCADQQBBAUEBEKAYIAQoAgQhBSAEKAIAQQFGDQEgBCgCCCEGIAMEQCAGIAIgA/wKAAALIAEQlC0gACAFNgIIIAAgAzYCBCAAIAY2AgAgAEEHQSAgBUEKdmdrIgAgAEEHTxtBAnRBAXI2AgwLIARBEGokAA8LIAUgBCgCCEHAhYgBEP0vAAvVAwIGfwFvIwBBIGsiAiQAEEIhCBDfEiIHIAgmASACIAc2AhQjAEEQayIDJAAgASgCACUBIAJBFGooAgAlARBiIQgQ3xIiBCAIJgEgBCEFIANBCGoQzi1BASEEIAJBCGoiBgJ/IAMoAghBAXEEQCADKAIMDAELQQAhBCAFCzYCBCAGIAQ2AgAgA0EQaiQAIAIoAgwhAwJAAkACQCACKAIIQQFxBEAgAEEDOgAEIAAgAzYCAAwBCyACIAM2AhwCQCACQRxqEKs7BEAgAiADNgIYIAIgAkEYaiABEIIkIAIoAgQhAQJAIAIoAgBBAXEEQCAAQQM6AAQgACABNgIADAELIAIgATYCHEEAIQUjAEEQayIEJAACQCACQRxqIgYQqjtFDQAgBigCACUBED8hCBDfEiIFIAgmASAEIAUiBjYCDCAEQQxqEKs7IQUgBkGEAUkNACAGEPIfCyAEQRBqJAAgBQRAIABBADoABCAAIAE2AgAgA0GEAU8EQCADEPIfCyAHQYQBSQ0GDAULIABBAjoABCABQYQBSQ0AIAEQ8h8LIANBhAFJDQIMAQsgAEECOgAEIANBgwFNDQELIAMQ8h8LIAdBgwFNDQELIAcQ8h8LIAJBIGokAAu6EAIJfwF+IwBB4ABrIgEkACMAQTBrIgckACMAQSBrIgUkACAFQRRqQYOACEEAQQFBARCgGCAFKAIYIQYgBSgCFEEBRgRAIAYgBSgCHEGQ880AEP0vAAsgBSgCHCEGIAVBCGoiCEGDgAg2AgQgCCAGNgIAIAUoAgwhBiAHQQhqIgggBSgCCDYCACAIIAY2AgQgBUEgaiQAIAcgAzYCLCAHIAI2AiggB0EANgIkIAdCADcCHCAHIAcpAwg3AhQgAUEwaiEGIAdBFGohCiMAQRBrIgkkACAJQQhqIQwjAEEgayICJABBACEDIwBBEGsiCCQAIAhBCGoiDUEANgIAIAhCADcDACMAQRBrIgskAAJAIAgoAgBFIAgoAgRFcw0AIAtBCGogDSgCADYCACALIAgpAgA3AwBBuOwFIAsQ2S4iBUUNACAFIAgpAgA3AvzqASAFQYTrAWogDSgCADYCACAFIgNBADYCmOsBIAVCADcDkOsBIAVBADYCzOsBIAVBADYCvOsBIAVCADcDoOsBIAVBADYCuOkBIAVBADYCtOwFIAVCADcCtOsBIAVBADYCqOsBIAVCADcD4OsBIAVBgYCAwAA2AsTrASAFQgA3AqzrASAFQgA3AuzqAQsgC0EQaiQAIAhBEGokACADRQRAQZTw0ABBNEGE8dAAEMskAAsgAiADNgIUIAJBCGohCCACQRRqKAIAIgVBADYC4OsBIAVBADYCtOsBIwBBQGoiCyQAQUQhAyAFKAK06wFFBEAgBRD8MEEAIQMLIAtBQGskACADQYh/TQRAQQFBBSAFKALs6gEbIQMLIAMQ0j0hBSAIIAM2AgQgCCAFQQBHNgIAAkACQAJAIAIoAghBAXFFDQAgAkEYaiACKAIMEOIaIAItABhBBEYNACACKQMYIhBC/wGDQgRSDQELIAJBFGooAgAhBUEAIQMjAEEQayIIJAACQCAFKAK06wEEQEFEIQMMAQsgBRD8MAsgCEEQaiQAIAMQ0j0hBSACIAM2AgQgAiAFQQBHNgIAAkAgAigCAEEBcUUNACACQRhqIAIoAgQQ4hogAi0AGEEERg0AIAIpAxgiEEL/AYNCBFINAQsgDCACKAIUNgIEIAxBBDoAAAwBCyAMIBA3AgAgAkEUahCPPAsgAkEgaiQAAkACQCAJLQAIQQRGBEAgCSgCDCECDAELIAkoAgwhAiAJKAIIIgNB/wFxQQRGDQAgBkECOgAiIAYgA60gAq1CIIaENwIAIAooAgQiAkUNASAKKAIAIAJBARD4OgwBCyAGQQA6ACIgBkEAOwEgIAYgAjYCHCAGIAopAgA3AgAgBkEYaiAKQRhqKAIANgIAIAZBEGogCkEQaikCADcCACAGQQhqIApBCGopAgA3AgALIAlBEGokACAHQTBqJAAgASkDMCEQAkAgAS0AUiICQQJGBEAgASAQNwMwIAAgBhCBKwwBCyABQShqIAFB0ABqLwEAOwEAIAFBIGogAUHIAGopAwA3AwAgAUEYaiABQUBrKQMANwMAIAEgASkDODcDECABIAEtAFM6ACsgASACOgAqIAEgEDcDCCABQTBqIQYgAUEIaiEKIwBBMGsiBSQAQYDAACEIAkACQCAEKAIAIg0gBCgCCCIDa0EgTwRAIAMhAgwBCyAFQRBqIAogBBCSEwJAIAUtABBBBEYEQCAFKAIUIQIMAQsgBSkDECIQQiCIpyECIBCnIgdB/wFxQQRGDQAgBiACNgIEIAYgBzoAACAGQQNqIAdBGHY6AAAgBiAHQQh2OwABDAILIAIEQCAEKAIIIQIMAQsgBkEEOgAAIAZBADYCBAwBCwNAAkAgAiAEKAIAIgdHIAcgDUdyDQAgBUEQaiAKIAQQkhMCQCAFLQAQQQRGBEAgBSgCFCEHDAELIAUpAxAiEEIgiKchByAQpyICQf8BcUEERg0AIAYgBzYCBCAGIAI6AAAgBkEDaiACQRh2OgAAIAYgAkEIdjsAAQwDCyAEKAIIIQIgBwRAIAQoAgAhBwwBCyAGQQQ6AAAgBiACIANrNgIEDAILAkACQAJAAkAgAiAHRgRAIAVBCGogBCAHELQgIAUoAghBgYCAgHhHDQEgBCgCACEHIAQoAgghAgsgBCgCBCEJIAUgDjYCHCAFQQA2AhggBSACIAlqNgIQIAUgCCAHIAJrIgIgAiAISxsiCTYCFCAFQSBqIAogBUEQahCFFiAFLQAgIgJBBEcNAQwCCyAGQoHMADcCAAwECwNAQQAhBwJAAkACQAJAIAJB/wFxQQFrDgMBAgAGCyAFKAIkLQAIQSNHDQUMAgsgBS0AIUEjRg0BDAQLIAUoAiQtAAhBI0cNAwsgBSAFKQMgNwMoIAVBKGoQuS4gBUEgaiAKIAVBEGoQhRYgBS0AICICQQRHDQALC0EBIQcLIAQgBSgCGCILIAQoAghqIgI2AgggBSgCHCEMAkAgBw0AIAUpAyAiEKciB0H/AXFBBEYNACAGIAc6AAAgBkEHaiAQQjiIPAAAIAZBBWogEEIoiD0AACAGIBBCCIg+AAEMAgsgCwRAIAkgC0cgCUF/IAggD0EBakEAIAkgC0sbIg9BAUobIAggCSAMRxsiCElyRQRAQX8gCEEBdCAIQQBIGyEICyAMIAtrIQ4MAQUgBkEEOgAAIAYgAiADazYCBAsLCyAFQTBqJAACQCABLQAwQQRHBEAgASABKQMwNwNYIAAgAUHYAGoQgSsMAQsgASgCNCECIABBCDYCACAAIAI2AgQLIAEoAgwiAARAIAEoAgggAEEBEPg6CyABQSRqEI88CyABQeAAaiQAC8QCAQN/IwBBgAFrIQMCQCABLwEOIgVB/wdxIgRBEE8EQAJ/IAQgAigCBCIDQRBqTwRAIAMgBCADa0EQayIEQX8gAigCACICdEF/c3FqIAEoAgggBCACdkEBcUECciAFQQp2dGpBBGsgAnRqQQFqDAELIARBD2sLIQFBACECDAELIANCgoCAgDA3AnggA0KCgICAUDcCcCADQoKAgIAgNwJoIANCgoCAgGA3AmAgA0KCgICAEDcCWCADQoKAgIBwNwJQIANCgYCAgDA3AkggA0KBgICAUDcCQCADQoGAgIAgNwI4IANCgYCAgGA3AjAgA0KBgICAEDcCKCADQoGAgIBwNwIgIANCBDcCGCADQgM3AhAgA0ICNwIIIANCATcCACADIARBA3RqIgEoAgAhAiABKAIEIQELIAAgATYCBCAAIAI2AgAL/gIBBn8jAEFAaiIDJAAgA0EIaiABEN0oAkACQCADKAIIIgcEQCADQSBqIghBBCABKAIYQQFqIgRBfyAEGyIEIARBBE0bQQBBBEEEEKAYIAMoAiQhBSADKAIgQQFGDQIgAygCKCIEIAc2AgAgA0EcaiICQQE2AgAgAyAENgIYIAMgBTYCFCADQThqIAFBGGopAwA3AwAgA0EwaiABQRBqKQMANwMAIANBKGogAUEIaikDADcDACADIAEpAwA3AyAgA0EUaiEGIwBBEGsiBSQAIAVBCGogCBDdKCAFKAIIIgcEQANAIAYoAggiBCAGKAIARgRAIAYgCCgCGEEBaiIBQX8gARsQgC4LIAYoAgQgBEECdGogBzYCACAGIARBAWo2AgggBSAIEN0oIAUoAgAiBw0ACwsgBUEQaiQAIABBCGogAigCADYCACAAIAMpAhQ3AgAMAQsgAEEANgIIIABCgICAgMAANwIACyADQUBrJAAPCyAFIAMoAiggAhD9LwALtwIBAn8jAEFAaiICJAAgAkEQaiABENw7IAIgAigCFCIDNgIYAkACQCADQQFGBEAgAS0AGEEVRw0BIAEoAhwhAyACQQhqIAEQ3DsgAigCDA0CQQBBAEGIoYYBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJBmKKGATYCHEEAIAJBGGpBhKGGASACQRxqQaCihgEQrysACyACQQA2AiwgAkEBNgIgIAJBwKGGATYCHCACQgQ3AiQgAkEcakHIoYYBEO8sAAsgAkE0aiACKAIIIAEoAiggA2wgASgCJCADbBDmFSAAIAFBGGoQ2QYgAEEYaiABQSxqQQAgASgCLBsQ7iUgACADNgI0IAAgAikCNDcCDCAAQRRqIAJBPGooAgA2AgAgACABKAIkNgIwIAEQjCcgAkFAayQAC54CAQV/IwBBEGsiAiQAQQEhBQJAIAAoAgAiAy8BECABKAIAIgQvARBHDQAgAy8BEiAELwESRw0AIAMoAgwiACgCCCIGQQJGIAQoAgwiASgCCEECRnMNAAJAIAZBAkYEQCACIABBDGo2AgggAiABQQxqNgIMIAJBCGogAkEMahD9EUUNAiAAKAI0IAAoAjggASgCNCABKAI4EOsSDQEMAgsgAiAAQQhqNgIIIAIgAUEIajYCDCAAKAIsIAEoAixHDQEgACgCMCABKAIwRw0BIAAoAjQgASgCNEcNASACQQhqIAJBDGoQ/RFFDQEgAC0AOCABLQA4Rw0BCyADKAIEIAMoAgggBCgCBCAEKAIIEOQcQQFzIQULIAJBEGokACAFC6oCAgZ/AX4jAEEgayIEJAAgAygCACEIIAMoAgghBSADKAIEIgYgAygCDCIHSwRAIAYgB2siCQRAIAcgCGpBACAJ/AsACyADIAY2AgwgBiEHCwJAAkACQCAFIAZNBEAgBCABQRBqIAIgBSAIaiAGIAVrELwNIAQtAABBBEcNAyAEKAIEIAVqIgEgBUkNASABIAdLDQIgAyABNgIIDAMLIAUgBkHgzcMAELE7AAtBgM7DAEEPQeDOwwAQyyQACyAEQQA2AhggBEEBNgIMIARB2M3DADYCCCAEQgQ3AhAgBEEIakHgzsMAEO8sAAsCQAJAAkACQCAEKQMAIgqnQf8BcUEEaw4CAgABCyAAQQU6AAAMAgsgACAKNwIADAELIABBBDoAAAsgBEEgaiQAC7MQAg1/Bn4jAEHwAGsiCCQAIAhBFGoiBCABKAIAQQhqEPsuIAhBCGogBBDtEiAIKAIIIgoEQCAIKAIMIQEDQCMAQSBrIgUkAEEAIQRBACEJIwBBIGsiCyQAIAsgCjYCDCAFAn9BAyACEPcODQAaIAtBDGohBiMAQdAAayIDJAACQCACKQMAQgJRBEAgA0FAa0IANwMAIANCADcDOCADIAIpAxAiEDcDMCADIAIpAwgiETcDKCADIBBC88rRy6eM2bL0AIU3AyAgAyAQQu3ekfOWzNy35ACFNwMYIAMgEULh5JXz1uzZvOwAhTcDECADIBFC9crNg9es27fzAIU3AwggAyAGKAIAIgQoAgAiBkEARzYCTCADQQhqIgcgA0HMAGpBBBC7CQJAIAYEQCAHIAQoAgQgBCgCCBC7CQwBCyADIAQtAAQ2AkwgA0EIaiADQcwAakEEELsJCyADKQM4IAM1AkBCOIaEIhAgAykDIIUiEUIQiSARIAMpAxB8IhGFIhJCFYkgEiADKQMYIhMgAykDCHwiFEIgiXwiEoUiFUIQiSAVIBEgE0INiSAUhSITfCIRQiCJQv8BhXwiFIUiFUIViSAVIBEgE0IRiYUiESAQIBKFfCIQQiCJfCIShSITQhCJIBMgECARQg2JhSIQIBR8IhFCIIl8IhOFIhRCFYkgFCARIBBCEYmFIhAgEnwiEUIgiXwiEoUiFEIQhiAUIBBCDYkgEYUiECATfCIRQiCJfCIThUIriCAQQhGJIBGFIhBCDYkgECASfIUiEEIviIUgECATfCIQQiCIhSAQhSEQDAELIAMgBigCACIGKAIAIgdBAEc2AghCpcaIocicp/lLIRADQCAQIANBCGogBGoxAACFQrODgICAIH4hECAEQQFqIgRBBEcNAAsgBwRAIAYoAggiB0UNASAGKAIEIQQDQCAQIAQxAACFQrODgICAIH4hECAEQQFqIQQgB0EBayIHDQALDAELIAMgBi0ABDYCCEEAIQQDQCAQIANBCGogBGoxAACFQrODgICAIH4hECAEQQFqIgRBBEcNAAsLIANB0ABqJAAgEKdB//8BcSIGIAIvAThxIQQCQAJAAkADQCACKAIcIQcDQCAEIQNBACEEIAMgB08NAAsgAigCGCADQQJ0aiIHLwEAIgRB//8DRwRAIAMgAi8BOCIMIAcvAQIiB3FrIAxxIAlJDQICQCAGIAdHDQAgAigCKCIHIARNDQQgCigCAEUgAigCJCAEQTRsaiIHKAIgIgxBAEdGDQAgB0EgaiEHIAwEQCAHIAoQjDVFDQEMBgsgBy0ABCAKLQAERg0FCyADQQFqIQQgCUEBaiEJDAELCyACKQMAIRAgC0EQaiAKENUiIAspAhAhESALKQIYIRIgBSAGOwEYIAUgAzYCFCAFIBI3AgwgBSARNwIEIAUgAjYCACAJQf8DSyAQQgJScQwDCyACKQMAIRAgC0EQaiAKENUiIAspAhAhESALKQIYIRIgBSAGOwEYIAUgAzYCFCAFIBI3AgwgBSARNwIEIAUgAjYCACAJQf8DSyAQQgJScQwCCyAEIAdB8ODDABDDIQALIAUgBDYCCCAFIAM2AgQgBSACNgIAQQILOgAaIAtBIGokACAFLQAaQQNGBEBB0OHDAEEXIAVBH2pB4ODDAEHo4cMAENUeAAsgCEEkaiIEIAUpAgA3AgAgBEEYaiAFQRhqKAIANgIAIARBEGogBUEQaikCADcCACAEQQhqIAVBCGopAgA3AgAgBUEgaiQAIAgtAD5BAkcEQCAIQdgAaiAIQTxqKAIANgIAIAhB0ABqIAhBNGopAgA3AwAgCEHIAGogCEEsaikCADcDACAIIAgpAiQ3A0AgCEHcAGoiBCABQQxqIAEoAgQgASgCCCABKAIAKAIAEQUAIAggAS0AEDoAbCMAQRBrIgwkAAJ/IAQhAUEAIQcjAEEwayIJJAAgCEFAayIFKAIAIQYgCUEIaiAFQQxqKQIANwMAIAkgBSkCBDcDAAJAAn8CQCAGKAIoIgNB//8BTQRAIAUtABohDiAFKAIUIQogBS8BGCEEIAlBLGoiCyABQRBqKAIANgIAIAlBJGoiDSABQQhqKQIANwIAIAkgASkCADcCHCAGQSBqIgEoAgAgA0YEQCABQbDhwwAQkygLIAYoAiQgA0E0bGoiASAJKQIUNwIEIAFBADYCACABIAVBBGoiBSkCADcCICABIAQ7ATAgAUEMaiAJQRxqKQIANwIAIAFBFGogDSkCADcCACABQRxqIAsoAgA2AgAgAUEoaiAFQQhqKQIANwIAIAYgA0EBajYCKCAGKAIcIQ0gBigCGCEPIAMhAQNAIAohC0EAIQogCyANTw0AIA8gC0ECdGoiCi8BACIFQf//A0YNAiAKIAE7AQAgCi8BAiAKIAQ7AQIgC0EBaiEKIAdBAWohByEEIAUhAQwACwALIAFBDGogASgCBCABKAIIIAEoAgAoAhARAQAgCSgCACIBBEAgCUEMaiAJKAIEIAkoAgggASgCEBEBAAtBAAwBCyAKIAQ7AQIgCiABOwEAAkAgDkEBcyAHQYABSXENACAGKQMAQgBSDQAgBkIBNwMACyADIAYoAigiAU8NASAGKAIkIANBNGxqQQxqCyAJQTBqJAAMAQsgAyABQbjiwwAQwyEAC0UEQEHQ4cMAQRcgDEEPakHg4MMAQcjiwwAQ1R4ACyAMQRBqJAALIAggCEEUahDtEiAIKAIEIQEgCCgCACIKDQALCyAAIAJB0AH8CgAAIABBADoAzAMgCEHwAGokAAuBAgIBfwF+IwBBoAFrIgckACAHQdAAaiACIAMgBCAFIAYgAS0AaBD8AiAHQUBrIgIgB0HgAGopAwA3AwAgB0HIAGoiAyAHQegAaikDADcDACAHIAcpA1g3AzgCQCAHKQNQIghCBlEEQCAAIAcpAzg3AwAgAEEQaiADKQMANwMAIABBCGogAikDADcDAAwBCyAHQQhqIAdB8ABqQTD8CgAAIAEpAwBCBlIEQCABELEeCyABIAg3AwAgASAHKQM4NwMIIAFBEGogB0FAaykDADcDACABQRhqIAdByABqKQMANwMAIAFBIGogB0EIakEw/AoAACAAQQg2AgALIAdBoAFqJAALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQbTDzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQdTDzQAQrSgLIAAoAhAgAUEBdGogA0ECazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDQEiAAQcgAaiEAIAJByABrIgINAAsLDwtBpMPNABCyOwALQcTDzQAQsjsABSAAKAIEIQAMAQsACwALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQfTCzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQZTDzQAQrSgLIAAoAhAgAUEBdGogA0EBazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDREiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MLNABCyOwALQYTDzQAQsjsABSAAKAIEIQAMAQsACwALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQfTEzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQZTFzQAQrSgLIAAoAhAgAUEBdGogA0ECazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDSEiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MTNABCyOwALQYTFzQAQsjsABSAAKAIEIQAMAQsACwALmAIAIwBBMGsiAiQAIAJBADYCCCACQoCAgIDAADcCACACQQA2AhQgAkKAgICAwAA3AgwgA0UEQCACQRhqIAFB4ABqQQRBABCgECACKAIYIgFBCEcEQCAAIAIpAhw3AgQgAEEUaiACQSxqKAIANgIAIABBDGogAkEkaikCADcCAAsgACABNgIAIAIoAhQiAwRAIAIoAhAhAANAIAAoAgAiAQRAIABBDGogAEEEaigCACAAQQhqKAIAIAEoAhARAQALIABBEGohACADQQFrIgMNAAsLIAJBDGpBBEEQEOAeIAIQ6TsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQaCizgA2AhggAkIENwIgIAJBGGpBqKLOABDvLAALngIBBn8gASgCACEEAkACQAJAAkACQAJAIAAoAgQiCCAAKAIIIgVrIgkgAyACayIGQQhqSQRAIAEoAggiByABKAIEIgFLDQIgAiADSw0DIAMgB0sNBCAFIAhLDQUgBiAJSw0GIAZFDQEgACgCACAFaiACIARqIAb8CgAADAELIAAoAgAgBWoiASACIARqIgIpAAA3AAAgAkEIaiICIAMgBGoiBE8NACABQQhqIQMDQCADIAIpAAA3AAAgA0EIaiEDIAJBCGoiAiAESQ0ACwsgACAFIAZqNgIIDwsgByABQdTw/AAQsDsACyACIANBxPH8ABCxOwALIAMgB0HE8fwAELA7AAsgBSAIQdTx/AAQrzsACyAGIAlB5PH8ABCwOwALhwICAn8CfiMAQSBrIQMgAAJ+IAJFBEAgACABKQMANwMAIABBGGogAUEYaikDADcDACAAQRBqIAFBEGopAwA3AwAgAEEIaiABQQhqKQMANwMAQgAMAQsgA0EYakIANwMAIANBEGpCADcDACADQgA3AwggAyABKQMAIAJBP3GtIgaGNwMAQQAgAmtBP3GtIQUDQCADIARqQQhqIAEgBGoiAkEIaikDACAGhiACKQMAIAWIhDcDACAEQQhqIgRBGEcNAAsgACADKQMANwMAIABBCGogA0EIaikDADcDACAAQRBqIANBEGopAwA3AwAgAEEYaiADQRhqKQMANwMAIAEpAxggBYgLNwMgC6ICAgN/AX4jAEFAaiICJAAgASgCAEGAgICAeEYEQCABKAIMIQMgAkEkaiIEQQA2AgAgAkKAgICAEDcCHCACQTBqIAMoAgAiA0EIaikCADcDACACQThqIANBEGopAgA3AwAgAiADKQIANwMoIAJBHGpB4KiJASACQShqEMsKGiACQRhqIAQoAgAiAzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIACyABKQIAIQUgAUKAgICAEDcCACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCACACIAU3AwBBDEEEEK02IgFFBEBBBEEMEKM9AAsgASACKQMANwIAIAFBCGogAygCADYCACAAQdy1iQE2AgQgACABNgIAIAJBQGskAAuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEOUtIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQAL3gECAX8BfiAAKAK8AiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEG8AmoQ2SELIABBgAJqEN47IABBjAJqEIYwAkAgACkDYCICQghRIAKnQQZJcg0AAkAgACgCiAFFDQAgACgCjAEiAUUNACAAQZgBaiAAKAKQASAAKAKUASABKAIQEQEACyAAKAKcAUUNACAAKAKgASIBRQ0AIABBrAFqIAAoAqQBIAAoAqgBIAEoAhARAQALIAAoApgCQYCAgIB4RwRAIABBmAJqEOo7CyAAQaQCahCFMCAAQbACahCFMAuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEIguIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQALhAIBBH8gACgCCCEDIAACf0EBIAFBgAFJIgQNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiBRDYLSAAKAIEIAAoAghqIQICQAJAIARFBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgADIAIgAUESdkHwAXI6AAAgAiABQQZ2QT9xQYABcjoAAiACIAFBDHZBP3FBgAFyOgABDAMLIAIgAUE/cUGAAXI6AAIgAiABQQx2QeABcjoAACACIAFBBnZBP3FBgAFyOgABDAILIAIgAToAAAwBCyACIAFBP3FBgAFyOgABIAIgAUEGdkHAAXI6AAALIAAgAyAFajYCCEEAC58CAgN+CH8CQAJAIAAoAkxFDQAgAEHQAGogARDuCyECIAAoAkAiBkFAaiEIIAAoAkQiByACp3EhBSACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgASgCCCEJIAEoAgQhCkEAIQEDQCAFIAZqKQAAIgMgBIUiAkJ/hSACQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgJQRQRAA0AgCiAJIAggAnqnQQN2IAVqIAdxIgtBBnRrIgwoAgQgDCgCCBDkHA0EIAJCAX0gAoMiAlBFDQALCyADIANCAYaDQoCBgoSIkKDAgH+DUEUNASAFIAFBCGoiAWogB3EhBQwACwALIAAtACsPCyAALQArIAZBACALa0EGdGpBBWstAAAiACAAQQlGGwuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEIQuIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQALlgIBBH8jAEHQAGsiAyQAIABBDGoiBSAAKAIUIAAoAihBAUEBQeCwgwEQwyggA0EQaiICIAFBwAD8CgAAIANBCGogAhDWEAJAAkACQAJAIAMoAghBAXEEQCADKAIMIQEDQCABIAAoAhwiAk8NAyABQQFqIgQgAk8NAiAAKAIYIgIgBEECdGooAgAiBCACIAFBAnRqKAIAIgJJDQQgBCAAKAIkIgFLDQUgBSAAKAIgIAJqIAQgAmsQoTYgAyADQRBqENYQIAMoAgQhASADKAIAQQFxDQALCyADQdAAaiQADwsgBCACQYCxgwEQwyEACyABIAJB8LCDARDDIQALIAIgBEGQsYMBELE7AAsgBCABQZCxgwEQsDsAC5YCAQR/IwBB0ABrIgMkACAAQSRqIgUgACgCLCAAKAIAQQFBAUHgsIMBEMMoIANBEGoiAiABQcAA/AoAACADQQhqIAIQ1hACQAJAAkACQCADKAIIQQFxBEAgAygCDCEBA0AgASAAKAIMIgJPDQMgAUEBaiIEIAJPDQIgACgCCCICIARBA3RqKAIAIgQgAiABQQN0aigCACICSQ0EIAAoAhQiASAESQ0FIAUgACgCECACaiAEIAJrEKE2IAMgA0EQahDWECADKAIEIQEgAygCAEEBcQ0ACwsgA0HQAGokAA8LIAQgAkGAsYMBEMMhAAsgASACQfCwgwEQwyEACyACIARBkLGDARCxOwALIAQgAUGQsYMBELA7AAuvAwEGfyMAQRBrIgUkAAJAQaDvigEoAgBFBEBBoO+KAUF/NgIAQbDvigEoAgAiAkGs74oBKAIAIgBGBEAgAiEAQaTvigEoAgAiASACRgRA0G9BgAEgAiACQYABTRsiAPwPASIDQX9GDQMCQEG074oBKAIAIgFFBEBBtO+KASADNgIADAELIAEgAmogA0cNBAsgBUEIaiEDIwBBEGsiBCQAAn9BgYCAgHhBpO+KASgCAEGs74oBKAIAIgFrIABPDQAaIARBCGpBpO+KASABIABBBEEEEMwUQYGAgIB4IAQoAggiAUGBgICAeEYNABogBCgCDCEAIAELIQEgAyAANgIEIAMgATYCACAEQRBqJAAgBSgCCEGBgICAeEcNA0Gk74oBKAIAIQFBrO+KASgCACEACyAAIAFPDQJBqO+KASgCACAAQQJ0aiACQQFqNgIAQazvigEgAEEBaiIANgIACyAAIAJNDQFBsO+KAUGo74oBKAIAIAJBAnRqKAIANgIAQaDvigFBoO+KASgCAEEBajYCAEG074oBKAIAIAVBEGokACACag8LQeiuiAEQmz4ACwAL/QECBH8BfiMAQZABayIDJAAgAS0ACSEEIAEtAAghBQJAIAEpAwAiB0IDUQRAQgMhBwwBCyADIAQ6AFEgAyAFOgBQIAMgBzcDSCADQdIAaiIGIAFBCmpBPvwKAABBACACQQAgAkHkAGtB//8DcUGEB0kbIgFBEHRBASABQf//A3EbIgFBgICAGHEgAUEBcSICGyABQYCA/AdxckEQdiEBIAIEQCADQcgAahC8LkIDIQcgASEEQQAhBQwBCyADIAE7AYwBIANBCmogBkE+/AoAAAsgACAEOgAJIAAgBToACCAAIAc3AwAgAEEKaiADQQpqQT78CgAAIANBkAFqJAALmQIBA38jAEEQayIEJAACQAJAAkAgASgCECABKAIURgRAIAMgASgCDE8NAQsgBEEEaiABENsWIAQoAgRFDQEgACAEKQIINwIADAILIAEoAgAhBQJAIAEoAgQiBiADIAMgBksbIgNBAUcEQCADRQ0BIAIgBSAD/AoAAAwBCyACIAUtAAA6AAALIAAgAzYCBCAAQQQ6AAAgASAGIANrNgIEIAEgAyAFajYCAAwBCyAEKAIIIQUCQCAEKAIMIgYgAyADIAZLGyIDQQFHBEAgA0UNASACIAUgA/wKAAAMAQsgAiAFLQAAOgAACyAAIAM2AgQgAEEEOgAAIAEgASgCFCIAIAEoAhAgA2oiASAAIAFJGzYCEAsgBEEQaiQAC4kCAQJ/IwBB0ABrIgIkAAJAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACQRhqIgUgBCgCAEEIaiABKAIILQAAEJUBAkAgAigCGEUEQEE8QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEEckE0/AoAAAwBCyACQRBqIAJBMGopAwA3AwAgAiACKQMoNwMIIAIoAiQhASACKAIgIgRBCEYNACADKAIAQQhHBEAgAxDJIwsgAyABNgIEIAMgBDYCACADIAIpAwg3AwggA0EQaiACQRBqKQMANwMAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAAPC0EEQTwQoz0AC4kCAQJ/IwBB0ABrIgIkAAJAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACQRhqIgUgBCgCAEEIaiABKAIILQAIEJUBAkAgAigCGEUEQEE8QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEEckE0/AoAAAwBCyACQRBqIAJBMGopAwA3AwAgAiACKQMoNwMIIAIoAiQhASACKAIgIgRBCEYNACADKAIAQQhHBEAgAxDJIwsgAyABNgIEIAMgBDYCACADIAIpAwg3AwggA0EQaiACQRBqKQMANwMAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAAPC0EEQTwQoz0AC+ABAQN/IAEoAjhBAUchBSAAIQMCfwNAIAVFBEAgAEEBaiIBZyEAIAIEQEEAIQRBHyAAayIAQQh0IAFBCHQgAHZqDAMLQQAhBEGAPiAAQQh0awwCCyADQYCACEYEQCAEQYACaiEEQf//ByEDDAELCyABKAIsIANBwABPBH9BMiADZ2sFIANBwK7RAGotAAALIgNBkK7RAGotAABBCHRqIQUgASgCBCADQQJ0aigCAEEBaiIBZyEAIAIEfyAAQQh0IAFBCHRBHyAAa3ZrQYA+awUgAEEIdEGAPmsLIAVqCyAEaguTAgIEfwF+IwBBIGsiBSQAIAUgASAArYgiCTcDAAJAAkACQCAJUARAIABB/wFxQTlPDQEgAigCACIHQQN2IgYgBE8NAiAGQQdqIgggBEkNAyAIIARB+OXRABDDIQALIAVBADYCCCAFQbDl0QAgBUEIakGI5tEAEK4rAAtBuOXRAEEeQdjl0QAQnykACyAGIARB6OXRABDDIQALIAIgByAAQf8BcWo2AgAgAyAIaiABIAdBB3GthiIBQjiIPAAAIAMgBmoiACABQjCIPAAGIAAgAUIoiDwABSAAIAFCIIg8AAQgACABQhiIPAADIAAgAUIQiDwAAiAAIAFCCIg8AAEgACAALQAAIAGncjoAACAFQSBqJAALmQIBBX8jAEEgayICJAAgAiABQf8BcSIDNgIEAkACQAJAIANFBEBBACEDA0AgASAESQ0CIAEgBGtBD00NAyADQQFqIQUgA0ECdEEEaiEGQQAhAwNAIAAgA2ogBjsBACADQQJqIgNBIEcNAAsgBEEQaiEEIAVBEEYEQEEAIQUgASAERg0FCyAAQSBqIQAgBSEDDAALAAsgAkEANgIIQQAgAkEEakGI8dEAIAJBCGpBrPHRABCvKwALIAJBADYCGCACQQE2AgwgAkGA8NEANgIIIAJCBDcCECACQQhqQYzx0QAQ7ywACyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGc8dEAEO8sAAsgAkEgaiQAC7MCAQR/IwBBsAJrIgIkACABQSBqIgMoAgAhBCACQcgBaiIFIAMoAgA2AgAgAiABKQIYNwPAASABIAJBwAFqIgNBhOOFARD5GyACQegBakGatOjQATYCACACQpq06NChw4aNGjcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiAEQQR2NgLsASACQagCaiABQQhqKAIANgIAIAIgASkCADcDoAIgAkHkAGoiBCADIAJBoAJqEJYpIAJB0AFqIAFBNGopAgA3AwAgBSABQSxqKQIANwMAIAIgASkCJDcDwAEgAkEIaiIFIAQgAxDCGSAAIAUQzRwgAUEMahDDDCACQbACaiQAC7MCAQR/IwBBsAJrIgIkACABQSBqIgMoAgAhBCACQcgBaiIFIAMoAgA2AgAgAiABKQIYNwPAASABIAJBwAFqIgNBhOOFARD5GyACQegBakGXrty4ATYCACACQpeu3Ljx4sWLFzcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiAEQQR2NgLsASACQagCaiABQQhqKAIANgIAIAIgASkCADcDoAIgAkHkAGoiBCADIAJBoAJqEJYpIAJB0AFqIAFBNGopAgA3AwAgBSABQSxqKQIANwMAIAIgASkCJDcDwAEgAkEIaiIFIAQgAxDCGSAAIAUQzRwgAUEMahDDDCACQbACaiQAC6ACAQV/IwBBMGsiAiQAIAIgACgCACIAQQ11IgM2AgwCQAJAIABBA3ZB/wdxIgRB3QVJBEAgBEGUzYYBai0AACEFIANBkM4ATwRAQQEhACACQQE2AiQgAkGoxoYBNgIgIAJBATYCFCACQaDGhgE2AhAgAkEBNgIcIAJBnAM2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCg0DDAILQQEhACABIANB//8DcUHkAG4iBhC1KA0CIAEgAyAGQeQAbGsQtShFDQEMAgsgBEHdBUH00oYBEMMhAAsgAUEtEIM2DQAgASAEIAVqIgNBBnYQtSgNACABQS0QgzYNACABIANBAXZBH3EQtSghAAsgAkEwaiQAIAALoQICAn8CfQJAAkAgALwiAUGAgIAETgRAIAFB////+wdLDQFBgX8hAkMAAAAAIQAgAUGAgID8A0YNAQwCCyAAQwAAAABbBEBDAACAvyAAIACUlQ8LIAFBAE4EQCAAQwAAAEyUvCEBQeh+IQIMAgsgACAAk0MAAAAAlSEACyAADwsgAUGN9qsCaiIBQf///wNxQfOJ1PkDar5DAACAv5IiACAAIABDAAAAP5SUIgOTvEGAYHG+IgRDALC4P5QgACAEkyADkyAAIABDAAAAQJKVIgAgAyAAIACUIgAgACAAlCIAQ+7pkT6UQ6qqKj+SlCAAIABDJp54PpRDE87MPpKUkpKUkiIAQwCwuD+UIAAgBJJD1Jo4uZSSkiABQRd2IAJqspILhQIBBH8jAEEQayIEJAACQCABIANHDQAgAQRAA0AgACgCACIDKAIIIgdBAkYgAigCACIFKAIIQQJGcw0CAkAgB0ECRgRAIAQgA0EMajYCCCAEIAVBDGo2AgwgBEEIaiAEQQxqEP0RRQ0EIAMoAjQgAygCOCAFKAI0IAUoAjgQ6xJFDQQMAQsgBCADQQhqNgIIIAQgBUEIajYCDCADKAIsIAUoAixHDQMgAygCMCAFKAIwRw0DIAMoAjQgBSgCNEcNAyAEQQhqIARBDGoQ/RFFDQMgAy0AOCAFLQA4Rw0DCyAAQQRqIQAgAkEEaiECIAFBAWsiAQ0ACwtBASEGCyAEQRBqJAAgBguKAgIHfwJ+IAAgACkDECIJIAApAwAiClRBBHRqIgMgAEEwQSAgACkDMCAAKQMgVCIEG2oiAiAAIAkgClpBBHRqIgUgAEEgQTAgBBtqIgApAwAgBSkDAFQiBBsgAikDACADKQMAVCIGGyIHKQMAIQkgACAFIAIgBhsgBBsiCCkDACEKIAFBCGogAiADIAYbIgJBCGopAwA3AwAgASACKQMANwMAIAEgCCAHIAkgClYiAhsiAykDADcDECABQRhqIANBCGopAwA3AwAgAUEoaiAHIAggAhsiAkEIaikDADcDACABIAIpAwA3AyAgAUE4aiAFIAAgBBsiAEEIaikDADcDACABIAApAwA3AzALkgIBBH8CQAJAAn8CfyABAn8CQCABKAIAIgVBAkYEQCABKAIMQQFqIgMgASgCCCICKAIoSQ0BQQAMBAsgASgCDCICIAEoAggiBCgCKCIDTw0EIAQoAiQgAkE0bGoiAyAFQQFxRQ0BGiABKAIEIgUgBCgCNCICTw0FQQIhAiABIAQoAjAgBUEkbGoiBCgCCAR/IAEgBCgCDDYCBEEBBSACCzYCACAEQRBqDAILIAEgAzYCDCACKAIkIANBNGxqCyIDKAIENgIEIAFBAUECIAMoAgBBAXEbNgIAIANBDGoLIQIgA0EgagshASAAIAI2AgQgACABNgIADwsgAiADQaz2wwAQwyEACyAFIAJBvPbDABDDIQALiwIBB38gACgCACEBIAAoAgQhBwNAIAEgB0YEQEGAgMQADwsgACABQQFqIgQ2AgACQAJAIAEtAAAiAsBBAE4NACAAIAFBAmoiBDYCACABLQABQT9xIQMgAkEfcSEFIAJB3wFNBEAgBUEGdCADciECDAELIAAgAUEDaiIENgIAIAEtAAJBP3EgA0EGdHIhBiACQfABSQRAIAYgBUEMdHIhAgwBCyAAIAFBBGoiBDYCAEGAgMQAIQMgBUESdEGAgPAAcSABLQADQT9xIAZBBnRyciICQYCAxABGDQELIAQhAQJ/IAJBDU0EQEGAgMQAQQEgAnRBgMwAcQ0BGgsgAgsiA0GAgMQARg0BCwsgAwuOAgEBfyMAQRBrIgQkAAJAAkACQAJAIAEoAgBBgICAgHhHBEAgASgCCCADSQ0BCyACKAIAQYCAgIB4RwRAIAIoAgggA0kNAgsgAEEINgIADAILIARBBGpBKUEAQQFBARCgGCAEKAIIIQEgBCgCBEEBRg0CIAQoAgwiAkHcis4AQSn8CgAAIABBKTYCDCAAIAI2AgggACABNgIEIABBADYCAAwBCyAEQQRqQSlBAEEBQQEQoBggBCgCCCEBIAQoAgRBAUYNASAEKAIMIgJBhYvOAEEp/AoAACAAQSk2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMAAsgBEEQaiQADwsgASAEKAIMQZyHzgAQ/S8AC+8BAgF/AX4gACgCvAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBvAJqENkhCyAAQYACakEBQQEQ4B4gAEGMAmoQhjACQCAAKQNgIgJCCFENACACpyIBQQZJDQAgAUEHRhoCQCAAKAKIAUUNACAAKAKMASIBRQ0AIABBmAFqIAAoApABIAAoApQBIAEoAhARAQALIAAoApwBRQ0AIAAoAqABIgFFDQAgAEGsAWogACgCpAEgACgCqAEgASgCEBEBAAsgACgCmAJBgICAgHhHBEAgAEGYAmpBBEEIEOAeCyAAQaQCahCFMCAAQbACahCFMAuIAgEJfyAAIAAoAgwiAyAAKAIAIgRJQQxsaiIFIABBJEEYIAAoAiQgACgCGEkiBhtqIgIgACADIARPQQxsaiIDIABBGEEkIAYbaiIAKAIAIAMoAgBJIgQbIAIoAgAgBSgCAEkiBhsiBygCACEJIAAgAyACIAYbIAQbIggoAgAhCiABQQhqIAIgBSAGGyICQQhqKAIANgIAIAEgAikCADcCACABIAggByAJIApLIgIbIgUpAgA3AgwgAUEUaiAFQQhqKAIANgIAIAFBIGogByAIIAIbIgJBCGooAgA2AgAgASACKQIANwIYIAFBLGogAyAAIAQbIgBBCGooAgA2AgAgASAAKQIANwIkC5wCAQV/IwBB0ABrIgMkAAJAAkACQCABRQ0AIAEoAhRFDQAgA0EMaiIEIAEgAhDlCCADQThqIgUgBBDhJyADQShqIgIgA0HEAGoiBCkCADcDACADQTBqIgYgA0HMAGoiBygCADYCACADIAMpAjw3AyAgAygCOCIBRQ0BIAQgAikDADcCACAHIAYoAgAiAjYCACADIAE2AjggAyADKQMgNwI8IAJFBEAgASABKAIAIgFBAWs2AgAgAUEBRgRAIAUQ+x4LIABBADYCAAwDCyAAIAE2AgAgACADKQMgNwIEIABBDGogA0EoaikDADcCACAAQRRqIANBMGooAgA2AgAMAgsgACACEJI2EO4lDAELIABBADYCAAsgA0HQAGokAAucAgEFfyMAQdAAayIDJAACQAJAAkAgAUUNACABKAIURQ0AIANBDGoiBCABIAIQ5AggA0E4aiIFIAQQ4ScgA0EoaiICIANBxABqIgQpAgA3AwAgA0EwaiIGIANBzABqIgcoAgA2AgAgAyADKQI8NwMgIAMoAjgiAUUNASAEIAIpAwA3AgAgByAGKAIAIgI2AgAgAyABNgI4IAMgAykDIDcCPCACRQRAIAEgASgCACIBQQFrNgIAIAFBAUYEQCAFEPseCyAAQQA2AgAMAwsgACABNgIAIAAgAykDIDcCBCAAQQxqIANBKGopAwA3AgAgAEEUaiADQTBqKAIANgIADAILIAAgAhCSNhDuJQwBCyAAQQA2AgALIANB0ABqJAALrgIBBn8jAEEgayICJAAgAUEANgIUIAEoAgAhAyABQQA2AgACQAJAAkAgA0UEQCAAQQA2AgAMAQsgASgCECEGIAEoAgwhBCABKAIIIQUgASgCBCEHQQBBwAAQ0TRFDQFBHEEEEK02IgFFDQIgASAHNgIYIAEgAzYCFCABQQA2AhAgASAENgIMIAEgBTYCCCABQoGAgIAQNwIAIAIgBDYCHCACIAU2AhggAiABNgIUIAIgAkEUakEAIAYQ8hUgAiACKAIMIAJBEGoiASgCACIDENMfIQQgAEEQaiABKAIANgIAIABBCGogAkEIaikCADcCACAAIAIpAgA3AgAgACADIARrNgIUCyACQSBqJAAPC0HY/ocBQSkgAkHM/IcBQYT/hwEQ1R4AC0EEQRwQoz0AC00BA38jAEEQayIDJAAgA0EANgIMIANBLToADCABIAIgA0EMakEBIgQQ9C4hBSAAIAIgBGs2AgQgACABIARqQQAgBRs2AgAgA0EQaiQAC5UCAQp/IAEoAlwhAyABKAKEASEFIAEoAlQhAiABKAJYIQYgAS0AiAEiB0EBRiEIAkADQCACIAZGBEBBgIDEACEEDAILIAEgAkEEaiIJNgJUIAUgAigCACIESwRAQQAhAgwCCwJ/Qf8fQf//AyADLQAsGyAETwRAIARBBnYiAiADKAIISQRAIAMoAgQgAkEBdGovAAAgBEE/cWoMAgsgAygCFEEBawwBCyADIAQQwC4LIgIgAygCFCIKSQRAIAMoAhAgAkECdGooAAAhCwsgCyADKAIAIAIgCkkbIgJBf0cNASAJIQIgCA0AC0F/IQICQAJAIAdBAWsOAgABAgsAC0H9/4OABCECCyAAIAI2AgQgACAENgIAC6wOAgt/BH4jAEHgAGsiByQAAkACQCAEIAVBAXEEfyAGBUEAIQECQAJAIAMEQANAAkAgASACaiwAACIFrSEUAkAgBUEASARAQQMhBiABQQpHDQEMBQsgEkLAAFoEQEEDIQYMBQsgFEL/AYMgEoYgE4QiEqchBSASQoCAgIAQVA0BIAFBAWohCSASQiCIpyEKQQAhBgwECyAUQv8AgyAShiAThCETIBJCB3whEiADIAFBAWoiAUcNAQwDCwsgB0EOOgAAIAcgBTYCBAwCCyAHQQ46AAAgB0EANgIEDAELIAdC/////w83AxAgByAKNgIMIAcgBTYCCCAHIAk2AgQgByAGOgAACyAHLQAAIgFBDkcEQCAHQdAAaiAHQRBqKQMANwMAIAdB2ABqIAdBGGopAwA3AwAgByAHLQADOgBDIAcgBy8AATsAQSAHIAcpAwg3A0ggByAHKAIENgJEIAcgAToAQCAAIAdBQGsQ0SEMAgsgBygCBAsgBCgCCCIFahCOLSAEKAIIIgYgBUkNASAHQSBqIQsgAiEBIAQoAgQgBWohDSAGIAVrIQVBACEGQQAhCUIAIRJCACETQQAhAgJAAkAgAwRAA0ACQCABIAlqIg8sAAAiCq0hFAJAIApBAEgEQEEDIQQgCUEKRw0BDAULIBJCwABaBEBBAyEEDAULIAlBAWohBiAUQv8BgyAShiAThCITpyEKIBNCgICAgBBUDQEgE0IgiKchCEEAIQQMBAsgFEL/AIMgEoYgE4QhEyASQgd8IRIgAyAJQQFqIglHDQEMAwsLAkAgBSAKTwRAIAMgCU0NAUEAIQECQAJAIAkgA0EBa0cEQCADIAlrIRAgCUF/cyADaiIOrSEVA0AgDEEBaiEGAkACfgJAAkACQAJAAn8CQAJAAkAgDCAPaiIEQQFqLQAAIgVBA3FFBEAgBUECdkEBaiIIrSESAkAgBUE/TQRAIAxBEWogDksgAUEQaiAKS3INASABIA1qIgVBCGogBEEKaikAADcAACAFIARBAmopAAA3AAAgBiAIaiEMIAEgCGohAQwMCyAFQewBTQ0AIAytQgV8IBVWDQIgCEE8ayIFQQJ0Qdyd/gBqKAIAIARBAmooAABxrUIBfCESIAUgBmohBgsgEiAGQX9zIBBqrSIUViASIAogAWsiCK1Wcg0IIBKnIgQEQCABIA1qIAYgD2pBAWogBPwKAAALIAEgBGohASAEIAZqIQwMCgsgBUEBdEHwnf4Aai8BACIIQQt2IQUCQAJ+AkAgDiAMQQVqSQRAAkACQCAFQQFrDgIAAQMLIAYgDkkNBEIBDAMLQgIgDiAMQQJqTQ0CGiAQIAxrQQJrQQFNDQUgBEECai8AAAwHCyAIQYDQAEkNBSAFQQVBkKL+ABDDIQALIAWtCyETIAMgDGsgCWtBAmshAUEGIQkMBQsgBEECai0AAAwDCyAKIAFrIQggAyAMayAJa0ECa60hFEIEDAcLQQIgAyAMayAJa0ECa0HonP4AELA7AAsgBUECdEHcnf4AaigCACAEQQJqKAAAcQshAgJAAkACQAJAIAIgCEGADnFyIgJBAWsgAUkEQCAFIAZqIQwgCEH/AXEiBiABaiEEIAJBCEkgBkEQS3JFIAFBEGogCk1xDQEgCiAEQRhqSQRAIAQgCksNAyAGRQ0IIAEgCiABIApLGyEFIA0gAmshCEEAIAJrIREDQCABIBFqIApPDQUgASAFRwRAIAEgDWogASAIai0AADoAACABQQFqIQEgBkEBayIGDQEMCgsLIAUgCkGAov4AEMMhAAsgASANaiIGIAJrIQggAiIFQQ9LDQYDQCAIKQAAIRIgBkEIaiAIQQhqKQAANwAAIAYgEjcAACABIAVqIQEgBSAGaiIGIAhrIgVBD00NAAsMBgsgAq0hE0EIIQkMAwsgASANaiIBIAEgAmsiBSkAADcAACABIAUpAAg3AAgMBQsgCiABayEBIAatIRNBByEJDAELIAEgAmsgCkHwof4AEMMhAAsLIAGtIRQMBwsgASAETw0AA0AgBiAIKQAANwAAIAZBCGogCEEIaikAADcAACAGQRBqIQYgCEEQaiEIIAFBEGoiASAESQ0ACwsgBCEBDAILIBILIRMgCK0hEkEFIQkMAwsgDCAOSQ0ACwsgASAKRg0BIAGtIRRBBCEJCyALIBI3AxggCyAUNwMQIAsgEzcDCCALIAI2AgQgCyAJOgAADAULIAtBDjoAACALIAo2AgQMBAsgCyATNwMQIAtBAToAACALIAWtNwMIDAMLIAYgA0HMnf4AEK87AAsgC0ECOgAADAELIAtC/////w83AxAgCyAINgIMIAsgCjYCCCALIAY2AgQgCyAEOgAACyAHLQAgQQ5HBEAgACALENEhDAELIAAgBygCJDYCBCAAQQg2AgALIAdB4ABqJAAPCyAFIAZB1IrPABCvOwALlQICBH8BfiMAQRBrIgQkAAJAAkACQAJAAkACQCABKAJAIAJLBEAgASgCPCACQQR0aiICKQMApyIFQQ1JDQEgAikDCCIHQiCIpyECIAenIgMgASgCTE8EQCACIAVqIgMgAkkNAyADIAEoAlgiBksNBCABKAJUIAJqIQEMBwsgBEEIaiABKAJIIANBDGxqENw7IAIgBWoiASACSQ0EIAEgBCgCDCIDSw0FIAQoAgggAmohAQwGC0GkxoUBELI7AAsgAkEEaiEBDAQLIAIgA0G0xoUBELE7AAsgAyAGQbTGhQEQsDsACyACIAFBxMaFARCxOwALIAEgA0HExoUBELA7AAsgACAFNgIEIAAgATYCACAEQRBqJAAL9gEBAn9BBiEFIwBBIGsiBCQAIARBBjYCACAEQQY2AgQgACgCACABQQUgACgCBCgCDBEGACEBIARBADoADSAEIAE6AAwgBCAANgIIA0AgBEEIaiACKAIAIAJBBGooAgAgA0H09okBEIgSIQEgA0EIaiEDIAJBCGohAiAFQQFrIgUNAAsgBC0ADSICIAQtAAwiA3IhAAJAIAJBAXFFIANBAXFyDQAgASgCACIALQAKQYABcUUEQCAAKAIAQdfxiQFBAiAAKAIEKAIMEQYAIQAMAQsgACgCAEHW8YkBQQEgACgCBCgCDBEGACEACyAEQSBqJAAgAEEBcQuIAgEFfyAAKAIAIgQgACgCBCIGIAGnIgdxIgNqKQAAQoCBgoSIkKDAgH+DIgFQBEBBCCEFA0AgAyAFaiEDIAVBCGohBSAEIAMgBnEiA2opAABCgIGChIiQoMCAf4MiAVANAAsLIAQgAXqnQQN2IANqIAZxIgNqLAAAIgVBAE4EQCAEIAQpAwBCgIGChIiQoMCAf4N6p0EDdiIDai0AACEFCyADIARqIAdBGXYiBzoAACAEIANBCGsgBnFqQQhqIAc6AAAgACAAKAIIIAVBAXFrNgIIIAAgACgCDEEBajYCDCAEIANBdGxqIgBBDGsiAyACKQIANwIAIANBCGogAkEIaigCADYCACAAC6ICAQV/A0AgACgCACICQR91IAJB/////wdrcSICQQFrQQNPBEACQAJAAkACQAJAIAJBAWsOBAAAAAIBCwALIAAoAhhBgICAgHhGDQIgASgCDCIELwEAQQFrIQUgACgCHCIGIAAoAiBBAXRqIQAgASgCBCgCACABKAIIKAIAayECIAEoAgAoAgAiAyEBA0AgACAGRg0CIABBAmsiAC8BACAELwEARw0AIAJFIAEgA3JFcg0CIAJBAWshAiABIAMgARtBAWsiAQ0AIAAgBTsBAAwACwALIAAoAgwiAkUNACAAKAIIIQAgAkHIAGwhAgNAIAAgARD7EiAAQcgAaiEAIAJByABrIgINAAsLDwtBlMTNABCyOwAFIAAoAgQhAAwBCwALAAv/AQQCfwR8AX0BfiMAQSBrIgMkACADIAE2AgQgAUGAgARGBEBBACEBA0ACfQJAIAFBgIAQRwRAIAAgAWogAUEEaiEBKAIAIgJFDQMgArghByACQYACSQ0BIAKzEOoSDAILAn0gBPwHIglCgAJaBEAgCbUQ6hIMAQsgCadBAnRBwIfzAGoqAgALIQggA0EgaiQAIAZEAAAAAAAAMECiIAWgIAQgCLuioA8LIAJBAnRBwIfzAGoqAgALIQggBkQAAAAAAADwP6AhBiAEIAegIQQgBSAHIAi7oqEhBQwACwALIANBADYCCEEAIANBBGpBmJvWACADQQhqQZyb1gAQrysAC4ECAQR/IAAgASACEKE2AkAgACgCGARAIAAoAigiBEEBaiIFQQN2IAVBB3FBAEdqIgEgACgCJCICSwRAIAEgAmshBiAAKAIcIgMgAUkEQCAAQRhqIANBAXQiAiABEM0qIgMgAiADSxsQ6BkgACgCJCECCyAGBEAgACgCICACakEAIAb8CwALIAAgATYCJAsgACAFNgIoIAAoAiAgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAAgACgCLEEBajYCLAsgACgCCCECIAAoAhQiASAAKAIMRgRAIABBDGpBoL7/ABCdKAsgACgCECABQQJ0aiACNgIAIAAgAUEBajYCFAuDAgIEfwF+IAAgASACEKE2AkAgACgCGARAIAAoAigiBEEBaiIFQQN2IAVBB3FBAEdqIgEgACgCJCICSwRAIAEgAmshBiAAKAIcIgMgAUkEQCAAQRhqIANBAXQiAiABEM0qIgMgAiADSxsQ6BkgACgCJCECCyAGBEAgACgCICACakEAIAb8CwALIAAgATYCJAsgACAFNgIoIAAoAiAgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAAgACgCLEEBajYCLAsgADUCCCEHIAAoAhQiASAAKAIMRgRAIABBDGpBoL7/ABCzKAsgACgCECABQQN0aiAHNwMAIAAgAUEBajYCFAuVCwEOfyMAQYABayIMJAACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgMgAUESSSILGyEEIAEgA2shByAAIANBAnRqIQogACEDA0ACfyAEQQxNBEBBASAEQQhNDQEaAkAgBEEJTwRAIANBAEEDIAIQ5xsgA0EBQQcgAhDnGyADQQJBBSACEOcbIANBBEEIIAIQ5xsgA0EAQQcgAhDnGyADQQJBBCACEOcbIANBA0EIIAIQ5xsgA0EFQQYgAhDnGyADQQBBAiACEOcbIANBAUEDIAIQ5xsgA0EEQQUgAhDnGyADQQdBCCACEOcbIANBAUEEIAIQ5xsgA0EDQQYgAhDnGyADQQVBByACEOcbIANBAEEBIAIQ5xsgA0ECQQQgAhDnGyADQQNBBSACEOcbIANBBkEIIAIQ5xsgA0ECQQMgAhDnGyADQQRBBSACEOcbIANBBkEHIAIQ5xsgA0EBQQIgAhDnGyADQQNBBCACEOcbIANBBUEGIAIQ5xsMAQsAC0EJDAELAkAgBEENTwRAIANBAEEMIAIQ5xsgA0EBQQogAhDnGyADQQJBCSACEOcbIANBA0EHIAIQ5xsgA0EFQQsgAhDnGyADQQZBCCACEOcbIANBAUEGIAIQ5xsgA0ECQQMgAhDnGyADQQRBCyACEOcbIANBB0EJIAIQ5xsgA0EIQQogAhDnGyADQQBBBCACEOcbIANBAUECIAIQ5xsgA0EDQQYgAhDnGyADQQdBCCACEOcbIANBCUEKIAIQ5xsgA0ELQQwgAhDnGyADQQRBBiACEOcbIANBBUEJIAIQ5xsgA0EIQQsgAhDnGyADQQpBDCACEOcbIANBAEEFIAIQ5xsgA0EDQQggAhDnGyADQQRBByACEOcbIANBBkELIAIQ5xsgA0EJQQogAhDnGyADQQBBASACEOcbIANBAkEFIAIQ5xsgA0EGQQkgAhDnGyADQQdBCCACEOcbIANBCkELIAIQ5xsgA0EBQQMgAhDnGyADQQJBBCACEOcbIANBBUEGIAIQ5xsgA0EJQQogAhDnGyADQQFBAiACEOcbIANBA0EEIAIQ5xsgA0EFQQcgAhDnGyADQQZBCCACEOcbIANBAkEDIAIQ5xsgA0EEQQUgAhDnGyADQQZBByACEOcbIANBCEEJIAIQ5xsgA0EDQQQgAhDnGyADQQVBBiACEOcbDAELAAtBDQsiBUEBayAETw0CIAQgBUcEQCAFQQJ0IQUgBEECdCEEA0AgAyADIAVqIAIQuBUgBCAFQQRqIgVHDQALCyALDQEgACADRiAHIQQgCiEDDQALIAFBAnRBBGsiByAMIgRqIQsgByAAIgNqIQogAyABQQF2Ig1BAnRqIgdBBGshBSACKAIAIQICQAJAAkACQAJAA0AgBygCACIIIAIoAgQiBk8NASADKAIAIgkgBk8NAiAEIAggCSACKAIAIgYgCEECdGooAgAiDiAGIAlBAnRqKAIAIg9IIhAbNgIAIAooAgAiCCACKAIEIgZPDQMgBSgCACIJIAZPDQQgAyAOIA9OQQJ0aiEDIAcgEEECdGohByAEQQRqIQQgCyAJIAggAigCACIGIAhBAnRqKAIAIgggBiAJQQJ0aigCACIGSCIJGzYCACAFQXxBACAJG2ohBSAKQXxBACAGIAhMG2ohCiALQQRrIQsgDUEBayINDQALIAVBBGohAiABQQFxBH8gBCADIAcgAiADSyIEGygCADYCACAHIAIgA01BAnRqIQcgAyAEQQJ0agUgAwsgAkYgByAKQQRqRnENBBDkKwALIAggBkGov4MBEMMhAAsgCSAGQbi/gwEQwyEACyAIIAZBqL+DARDDIQALIAkgBkG4v4MBEMMhAAsgAUECdCIBRQ0AIAAgDCAB/AoAAAsgDEGAAWokAA8LAAuXCwIMfwJ+IwBBgAFrIgwkAAJAAkAgAUECSQ0AIAFBIEsNASABIAFBAXYiAyABQRJJIgsbIQQgASADayEGIAAgA0ECdGohCiAAIQMDQAJ/IARBDE0EQEEBIARBCE0NARoCQCAEQQlPBEAgA0EAQQMgAhDpGyADQQFBByACEOkbIANBAkEFIAIQ6RsgA0EEQQggAhDpGyADQQBBByACEOkbIANBAkEEIAIQ6RsgA0EDQQggAhDpGyADQQVBBiACEOkbIANBAEECIAIQ6RsgA0EBQQMgAhDpGyADQQRBBSACEOkbIANBB0EIIAIQ6RsgA0EBQQQgAhDpGyADQQNBBiACEOkbIANBBUEHIAIQ6RsgA0EAQQEgAhDpGyADQQJBBCACEOkbIANBA0EFIAIQ6RsgA0EGQQggAhDpGyADQQJBAyACEOkbIANBBEEFIAIQ6RsgA0EGQQcgAhDpGyADQQFBAiACEOkbIANBA0EEIAIQ6RsgA0EFQQYgAhDpGwwBCwALQQkMAQsCQCAEQQ1PBEAgA0EAQQwgAhDpGyADQQFBCiACEOkbIANBAkEJIAIQ6RsgA0EDQQcgAhDpGyADQQVBCyACEOkbIANBBkEIIAIQ6RsgA0EBQQYgAhDpGyADQQJBAyACEOkbIANBBEELIAIQ6RsgA0EHQQkgAhDpGyADQQhBCiACEOkbIANBAEEEIAIQ6RsgA0EBQQIgAhDpGyADQQNBBiACEOkbIANBB0EIIAIQ6RsgA0EJQQogAhDpGyADQQtBDCACEOkbIANBBEEGIAIQ6RsgA0EFQQkgAhDpGyADQQhBCyACEOkbIANBCkEMIAIQ6RsgA0EAQQUgAhDpGyADQQNBCCACEOkbIANBBEEHIAIQ6RsgA0EGQQsgAhDpGyADQQlBCiACEOkbIANBAEEBIAIQ6RsgA0ECQQUgAhDpGyADQQZBCSACEOkbIANBB0EIIAIQ6RsgA0EKQQsgAhDpGyADQQFBAyACEOkbIANBAkEEIAIQ6RsgA0EFQQYgAhDpGyADQQlBCiACEOkbIANBAUECIAIQ6RsgA0EDQQQgAhDpGyADQQVBByACEOkbIANBBkEIIAIQ6RsgA0ECQQMgAhDpGyADQQRBBSACEOkbIANBBkEHIAIQ6RsgA0EIQQkgAhDpGyADQQNBBCACEOkbIANBBUEGIAIQ6RsMAQsAC0ENCyIFQQFrIARPDQIgBCAFRwRAIAVBAnQhBSAEQQJ0IQQDQCADIAMgBWogAhC3FSAEIAVBBGoiBUcNAAsLIAsNASAAIANGIAYhBCAKIQMNAAsgAUECdEEEayIGIAwiBGohCyAGIAAiA2ohCiADIAFBAXYiDUECdGoiBkEEayEFIAIoAgAhAgJAAkACQAJAAkADQCAGKAIAIgggAigCBCIHTw0BIAMoAgAiCSAHTw0CIAQgCCAJIAIoAgAiByAIQQN0aikDACIPIAcgCUEDdGopAwAiEFMiDhs2AgAgCigCACIIIAIoAgQiB08NAyAFKAIAIgkgB08NBCADIA8gEFlBAnRqIQMgBiAOQQJ0aiEGIARBBGohBCALIAkgCCACKAIAIgcgCEEDdGopAwAiDyAHIAlBA3RqKQMAIhBTIggbNgIAIAVBfEEAIAgbaiEFIApBfEEAIA8gEFkbaiEKIAtBBGshCyANQQFrIg0NAAsgBUEEaiECIAFBAXEEfyAEIAMgBiACIANLIgQbKAIANgIAIAYgAiADTUECdGohBiADIARBAnRqBSADCyACRiAGIApBBGpGcQ0EEOQrAAsgCCAHQai/gwEQwyEACyAJIAdBuL+DARDDIQALIAggB0Gov4MBEMMhAAsgCSAHQbi/gwEQwyEACyABQQJ0IgFFDQAgACAMIAH8CgAACyAMQYABaiQADwsAC5cLAgx/An4jAEGAAWsiDCQAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIDIAFBEkkiCxshBCABIANrIQYgACADQQJ0aiEKIAAhAwNAAn8gBEEMTQRAQQEgBEEITQ0BGgJAIARBCU8EQCADQQBBAyACEOobIANBAUEHIAIQ6hsgA0ECQQUgAhDqGyADQQRBCCACEOobIANBAEEHIAIQ6hsgA0ECQQQgAhDqGyADQQNBCCACEOobIANBBUEGIAIQ6hsgA0EAQQIgAhDqGyADQQFBAyACEOobIANBBEEFIAIQ6hsgA0EHQQggAhDqGyADQQFBBCACEOobIANBA0EGIAIQ6hsgA0EFQQcgAhDqGyADQQBBASACEOobIANBAkEEIAIQ6hsgA0EDQQUgAhDqGyADQQZBCCACEOobIANBAkEDIAIQ6hsgA0EEQQUgAhDqGyADQQZBByACEOobIANBAUECIAIQ6hsgA0EDQQQgAhDqGyADQQVBBiACEOobDAELAAtBCQwBCwJAIARBDU8EQCADQQBBDCACEOobIANBAUEKIAIQ6hsgA0ECQQkgAhDqGyADQQNBByACEOobIANBBUELIAIQ6hsgA0EGQQggAhDqGyADQQFBBiACEOobIANBAkEDIAIQ6hsgA0EEQQsgAhDqGyADQQdBCSACEOobIANBCEEKIAIQ6hsgA0EAQQQgAhDqGyADQQFBAiACEOobIANBA0EGIAIQ6hsgA0EHQQggAhDqGyADQQlBCiACEOobIANBC0EMIAIQ6hsgA0EEQQYgAhDqGyADQQVBCSACEOobIANBCEELIAIQ6hsgA0EKQQwgAhDqGyADQQBBBSACEOobIANBA0EIIAIQ6hsgA0EEQQcgAhDqGyADQQZBCyACEOobIANBCUEKIAIQ6hsgA0EAQQEgAhDqGyADQQJBBSACEOobIANBBkEJIAIQ6hsgA0EHQQggAhDqGyADQQpBCyACEOobIANBAUEDIAIQ6hsgA0ECQQQgAhDqGyADQQVBBiACEOobIANBCUEKIAIQ6hsgA0EBQQIgAhDqGyADQQNBBCACEOobIANBBUEHIAIQ6hsgA0EGQQggAhDqGyADQQJBAyACEOobIANBBEEFIAIQ6hsgA0EGQQcgAhDqGyADQQhBCSACEOobIANBA0EEIAIQ6hsgA0EFQQYgAhDqGwwBCwALQQ0LIgVBAWsgBE8NAiAEIAVHBEAgBUECdCEFIARBAnQhBANAIAMgAyAFaiACELoVIAQgBUEEaiIFRw0ACwsgCw0BIAAgA0YgBiEEIAohAw0ACyABQQJ0QQRrIgYgDCIEaiELIAYgACIDaiEKIAMgAUEBdiINQQJ0aiIGQQRrIQUgAigCACECAkACQAJAAkACQANAIAYoAgAiCCACKAIEIgdPDQEgAygCACIJIAdPDQIgBCAIIAkgAigCACIHIAhBA3RqKQMAIg8gByAJQQN0aikDACIQVCIOGzYCACAKKAIAIgggAigCBCIHTw0DIAUoAgAiCSAHTw0EIAMgDyAQWkECdGohAyAGIA5BAnRqIQYgBEEEaiEEIAsgCSAIIAIoAgAiByAIQQN0aikDACIPIAcgCUEDdGopAwAiEFQiCBs2AgAgBUF8QQAgCBtqIQUgCkF8QQAgDyAQWhtqIQogC0EEayELIA1BAWsiDQ0ACyAFQQRqIQIgAUEBcQR/IAQgAyAGIAIgA0siBBsoAgA2AgAgBiACIANNQQJ0aiEGIAMgBEECdGoFIAMLIAJGIAYgCkEEakZxDQQQ5CsACyAIIAdBqL+DARDDIQALIAkgB0G4v4MBEMMhAAsgCCAHQai/gwEQwyEACyAJIAdBuL+DARDDIQALIAFBAnQiAUUNACAAIAwgAfwKAAALIAxBgAFqJAAPCwALlQsBDn8jAEGAAWsiDCQAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIDIAFBEkkiCxshBCABIANrIQcgACADQQJ0aiEKIAAhAwNAAn8gBEEMTQRAQQEgBEEITQ0BGgJAIARBCU8EQCADQQBBAyACEOgbIANBAUEHIAIQ6BsgA0ECQQUgAhDoGyADQQRBCCACEOgbIANBAEEHIAIQ6BsgA0ECQQQgAhDoGyADQQNBCCACEOgbIANBBUEGIAIQ6BsgA0EAQQIgAhDoGyADQQFBAyACEOgbIANBBEEFIAIQ6BsgA0EHQQggAhDoGyADQQFBBCACEOgbIANBA0EGIAIQ6BsgA0EFQQcgAhDoGyADQQBBASACEOgbIANBAkEEIAIQ6BsgA0EDQQUgAhDoGyADQQZBCCACEOgbIANBAkEDIAIQ6BsgA0EEQQUgAhDoGyADQQZBByACEOgbIANBAUECIAIQ6BsgA0EDQQQgAhDoGyADQQVBBiACEOgbDAELAAtBCQwBCwJAIARBDU8EQCADQQBBDCACEOgbIANBAUEKIAIQ6BsgA0ECQQkgAhDoGyADQQNBByACEOgbIANBBUELIAIQ6BsgA0EGQQggAhDoGyADQQFBBiACEOgbIANBAkEDIAIQ6BsgA0EEQQsgAhDoGyADQQdBCSACEOgbIANBCEEKIAIQ6BsgA0EAQQQgAhDoGyADQQFBAiACEOgbIANBA0EGIAIQ6BsgA0EHQQggAhDoGyADQQlBCiACEOgbIANBC0EMIAIQ6BsgA0EEQQYgAhDoGyADQQVBCSACEOgbIANBCEELIAIQ6BsgA0EKQQwgAhDoGyADQQBBBSACEOgbIANBA0EIIAIQ6BsgA0EEQQcgAhDoGyADQQZBCyACEOgbIANBCUEKIAIQ6BsgA0EAQQEgAhDoGyADQQJBBSACEOgbIANBBkEJIAIQ6BsgA0EHQQggAhDoGyADQQpBCyACEOgbIANBAUEDIAIQ6BsgA0ECQQQgAhDoGyADQQVBBiACEOgbIANBCUEKIAIQ6BsgA0EBQQIgAhDoGyADQQNBBCACEOgbIANBBUEHIAIQ6BsgA0EGQQggAhDoGyADQQJBAyACEOgbIANBBEEFIAIQ6BsgA0EGQQcgAhDoGyADQQhBCSACEOgbIANBA0EEIAIQ6BsgA0EFQQYgAhDoGwwBCwALQQ0LIgVBAWsgBE8NAiAEIAVHBEAgBUECdCEFIARBAnQhBANAIAMgAyAFaiACELkVIAQgBUEEaiIFRw0ACwsgCw0BIAAgA0YgByEEIAohAw0ACyABQQJ0QQRrIgcgDCIEaiELIAcgACIDaiEKIAMgAUEBdiINQQJ0aiIHQQRrIQUgAigCACECAkACQAJAAkACQANAIAcoAgAiCCACKAIEIgZPDQEgAygCACIJIAZPDQIgBCAIIAkgAigCACIGIAhBAnRqKAIAIg4gBiAJQQJ0aigCACIPSSIQGzYCACAKKAIAIgggAigCBCIGTw0DIAUoAgAiCSAGTw0EIAMgDiAPT0ECdGohAyAHIBBBAnRqIQcgBEEEaiEEIAsgCSAIIAIoAgAiBiAIQQJ0aigCACIIIAYgCUECdGooAgAiBkkiCRs2AgAgBUF8QQAgCRtqIQUgCkF8QQAgBiAITRtqIQogC0EEayELIA1BAWsiDQ0ACyAFQQRqIQIgAUEBcQR/IAQgAyAHIAIgA0siBBsoAgA2AgAgByACIANNQQJ0aiEHIAMgBEECdGoFIAMLIAJGIAcgCkEEakZxDQQQ5CsACyAIIAZBqL+DARDDIQALIAkgBkG4v4MBEMMhAAsgCCAGQai/gwEQwyEACyAJIAZBuL+DARDDIQALIAFBAnQiAUUNACAAIAwgAfwKAAALIAxBgAFqJAAPCwALogIBBn8jAEGgAmsiAiQAIAJB7AFqIAFBCGooAgA2AgAgAkEAOwGcAiACQQA2ApgCIAJBADYCgAIgAkEANgL0ASACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAiABKQIANwLkASACIAEoAjA2AvABIAJB6ABqIgUgAkHEAWoiBiABQRRqEMIZQcQAQQQQrTYiAwRAIAMgASgCDCIEIAEoAhAiBygCCEEBa0F4cWpBCGogBygCFBEAACACQQE2AswBIAIgAzYCyAEgAkEBNgLEASACQQxqIgMgBSAGEPwiIAAgAxDNHCAEIAQoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBxAAQoz0AC/YBAQZ/IwBBIGsiBCQAIAEgA08EQCAEIAA2AgggBCAAIANBAnRqIgY2AgwCQCADIARBCGoQnjYiByADIAdJGyIHRQ0AA0AgACAFIAAoAgAiCCACKAIAaiIFaiIJNgIAIAUgCEkgBSAJS3IhBSAAQQRqIQAgAkEEaiECIAdBAWsiBw0ACyAFRQ0AIAFBAnQgA0ECdGshAANAIABFDQEgBiAGKAIAQQFqIgE2AgAgAEEEayEAIAZBBGohBiABRQ0ACwsgBEEgaiQADwsgBEEANgIYIARBATYCDCAEQfCliAE2AgggBEIENwIQIARBCGpBpKaIARDvLAAL1AECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgRLBEBBACECDAELQQAhAkEIIAQgACgCACIFQQF0IgEgASAESRsiASABQQhNGyIErSIHQiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMgBTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIaiAGIANBFGoQohsgAygCCEEBRw0BIAMoAhAhASADKAIMIQILIAIgAUGgqIkBEP0vAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC5ICAQN/IwBBQGoiAiQAIAIgATYCCAJAIAEuARgiBEEATARAIAJBgYCAgHg2AgwMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBDGogAkEIaiADEJUSCyABLgEaIQMgAkE8aiIEQQA2AgAgAkKAgICAgAE3AjQgAkE0akEBEIctIABBADYCtAIgAEKAgICAEDcCrAIgAEGoAmogBCgCADYCACAAIAIpAjQ3AqACIAAgATYC7AIgAEG4AmogAkEMakEo/AoAACAAQgI3AuQCIAAgA0EATEEfdDYC4AIgAEIANwPwAiAAQgU3AwAgAkFAayQAC5ICAQN/IwBBQGoiAiQAIAIgATYCCAJAIAEuARgiBEEATARAIAJBgYCAgHg2AgwMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBDGogAkEIaiADEJUSCyABLgEaIQMgAkE8aiIEQQA2AgAgAkKAgICAwAA3AjQgAkE0akEBEIYtIABBADYCtAIgAEKAgICAEDcCrAIgAEGoAmogBCgCADYCACAAIAIpAjQ3AqACIAAgATYC7AIgAEG4AmogAkEMakEo/AoAACAAQgI3AuQCIAAgA0EATEEfdDYC4AIgAEIANwPwAiAAQgU3AwAgAkFAayQAC8YCAgR/AX4jAEEQayIDJAACf0GAgICAeCABKALgASICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQLkASEGIAFBADYC6AEgAUKAgICAIDcD4AEgAgshAiABKAKkAiEEIAFBuAJqELQwIAEgBjcCvAIgASACNgK4AiABKAKUAiICQYCAgIB4RwRAIAEpA5gCIQYgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAGNwPIAiABIAI2AsQCIANBBGoiBSABENYYAkAgAygCBCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAFEPseCyABQgA3AqQCQQxBBBCtNiIBRQRAQQRBDBCjPQALIAEgBDYCCCABQoGAgIAQNwIAIABBgNjNADYCCCAAIAE2AgQgAEEINgIAIANBEGokAAufAgEBfyMAQSBrIgUkAAJAAkACQCADIARxIgMgAk0EQCAFQQA2AgQgAiADa0EDTQ0BIAVBBGpBBCABIANqQQRBtNnOABDVLCAFKAIEQb3P1vEBbEERdiIBIAAoAgQiAk8NAiAAKAIAIAFBAXRqIgItAAAgAUEIdHIiASAAKAIMIgNJDQMgASADQZTLzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakH0ys4AEO8sAAsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpBpNnOABDvLAALIAEgAkGEy84AEMMhAAsgACgCCCABQQJ0aiAENgIAIAIgAi8BAEEBajsBACAFQSBqJAALggMBCH8jAEFAaiICJAAgAkEIaiABEIIoAkACQCACKAIIIgUEQCACKAIMIQYgAkEgaiIHQQRBAEEEQQgQoBggAigCJCEDIAIoAiBBAUYNAiACKAIoIgQgBjYCBCAEIAU2AgAgAkEcaiIIQQE2AgAgAiAENgIYIAIgAzYCFCACQThqIAFBGGopAgA3AwAgAkEwaiABQRBqKQIANwMAIAJBKGogAUEIaikCADcDACACIAEpAgA3AyAgAkEUaiEDIwBBEGsiASQAIAFBCGogBxCCKCABKAIIIgQEQCABKAIMIQUDQCADKAIIIgYgAygCAEYEQCADQQEQ6i0LIAMoAgQgBkEDdGoiCSAFNgIEIAkgBDYCACADIAZBAWo2AgggASAHEIIoIAEoAgQhBSABKAIAIgQNAAsLIAFBEGokACAAQQhqIAgoAgA2AgAgACACKQIUNwIADAELIABBADYCCCAAQoCAgIDAADcCAAsgAkFAayQADwsgAyACKAIoQbi1gAEQ/S8AC/EEAgt/AX4jAEEgayIHJAACQCABKAIAQQFGBEAgASgCFCEFIAEoAhAhCCABKQMIIQ4gAigCCCEDIAIoAgQhBCACKAIAIgFBDGoQ9DUhDSAHQQxqIQYjAEEQayICJAACQAJAAkAgAyABKAIoRgRAIAEgBCADEKE2AkAgASgCDARAIAEoAhwiCkEBaiILQQN2IAtBB3FBAEdqIgMgASgCGCIESwRAIAMgBGshDCABKAIQIgkgA0kEQCABQQxqIAlBAXQiBCADQcD///8DcUFAayADIANBP3EbIgkgBCAJSxsQ6BkgASgCGCEECyAMBEAgASgCFCAEakEAIAz8CwALIAEgAzYCGAsgASALNgIcIAEoAhQgCkEDdmoiASABLQAAQQEgCkEHcXRyOgAADAELIAEgASgCIEEBajYCIAsgBkGTgICAeDYCAAwBCyACQQRqQdAAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQEgAigCDCIDQYi2gAFB0AD8CgAAIAZB0AA2AgwgBiADNgIIIAYgATYCBCAGQY2AgIB4NgIACyACQRBqJAAMAQsgASACKAIMQfTBgAEQ/S8ACyAHKAIMQZOAgIB4RwRAIAYQiBELIAUoAgAiASAIaiICLQAAIQMgAiAOp0EZdiICOgAAIAEgBSgCBCAIQQhrcWpBCGogAjoAACAAIAU2AgwgACAONwMAIAUgBSgCDEEBajYCDCAAIAEgCEECdGsiADYCCCAFIAUoAgggA0EBcWs2AgggAEEEayANNgIADAELIAAgAUEIaiIBKQMANwMAIABBCGogAUEIaikDADcDAAsgB0EgaiQAC6ECAQJ/IwBBsAFrIgckACAHQfgAaiABQQhqKAIANgIAIAdBiAFqIARBCGooAgA2AgAgB0HgAGoiCCAFQQhqKAIANgIAIAdB7ABqIAZBCGooAgA2AgAgByACNgJ8IAcgAzYCVCAHQQA2AlAgB0EANgKkASAHQQA2AowBIAcgASkCADcCcCAHIAQpAgA3AoABIAcgBSkCADcCWCAHIAYpAgA3AmQgB0GAAjsBqAEgB0EMaiIBIAdB0ABqEN8HIAcoAgxBgICAgHhHBEAgACABQcQA/AoAACAHQbABaiQADwsgCCAHQSBqKAIANgIAIAdB2ABqIAdBGGopAgA3AwAgByAHKQIQNwNQQejahgFBKyAHQdAAakGU24YBQZDjhgEQ1R4AC40CAQZ/IwBBEGsiBiQAIAZBCGogARCGPSAGKAIMIQogBigCCCIIQQgQ+C8hBQJAAkACQAJAIAMgAyAEaiIJQQFqIgdNBEAgByAAKAIEIgRLDQEgAUEIIAUgCGogBSAKSyIIG0EAIAogBWtBA3YgCBtBA3RqQQhrKQMAIAAoAgAiACADQQN0aiIFIAcgA2sQ+BMgASgCKEUNAiADIARPDQMgBCAJSw0EIAkgBEHUoocBEMMhAAsgAyAHQaSihwEQsTsACyAHIARBpKKHARCwOwALQQBBAEG0oocBEMMhAAsgAyAEQcSihwEQwyEACyABKAIkIAIgBSgCACAAIAlBA3RqKAIAENgbIAZBEGokAAuNAgEGfyMAQRBrIgYkACAGQQhqIAEQhj0gBigCDCEKIAYoAggiCEEEEPgvIQUCQAJAAkACQCADIAMgBGoiCUEBaiIHTQRAIAcgACgCBCIESw0BIAFBBCAFIAhqIAUgCksiCBtBACAKIAVrQQJ2IAgbQQJ0akEEaygCACAAKAIAIgAgA0ECdGoiBSAHIANrEPkTIAEoAihFDQIgAyAETw0DIAQgCUsNBCAJIARB1KKHARDDIQALIAMgB0GkoocBELE7AAsgByAEQaSihwEQsDsAC0EAQQBBtKKHARDDIQALIAMgBEHEoocBEMMhAAsgASgCJCACIAUoAgAgACAJQQJ0aigCABDYGyAGQRBqJAALjAIBA38gACgCZCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHkAGoQlxULAkAgACgCaCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQegAahDbHgsCQCAAKAIYQYCAgIB4RwRAIABBGGoQ3jsMAQsgACgCECEBIAAoAhQiAygCACICBEAgASACEQMACyADKAIEIgJFDQAgASACIAMoAggQ+DoLIAAoAighASAAKAIsIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIABB2ABqEJ4vAkAgACgCbCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQewAahCBLAsL9gECBX8BfiMAQSBrIgNBEGoiBSAAKAIEIgQgAUEFdGoiAEEIaikDADcDACADQRhqIgYgAEEQaikDADcDACADIAApAwA3AwggACkDGCEHAkACQCABRQ0AA0AgBCABQQFrQQF2IgBBBXRqIgIpAxggB1cNASAEIAFBBXRqIgEgAikDADcDACABQRhqIAJBGGopAwA3AwAgAUEQaiACQRBqKQMANwMAIAFBCGogAkEIaikDADcDACAAIgENAAsMAQsgASEACyAEIABBBXRqIgAgAykDCDcDACAAIAc3AxggAEEQaiAGKQMANwMAIABBCGogBSkDADcDAAvHAgEEfyMAQdAAayIDJAACQCABLwFEIgRBkANrQf//A3FByAFPBEAgACABQegA/AoAAAwBCyADQQhqIAEoAlBByAD8CgAAIwBBEGsiBSQAQdQAQQQQrTYiAkUEQEEEQdQAEKM9AAsgAkEANgJQIAJBADYCTCACIAQ7AUogAkEDOwFIIAJBAjYCACAFQRBqJAAgAhD5LiACIANBCGpByAD8CgAAIABCAzcDACAAIAI2AgggARDLKSABKAJAIgAEQCAAEOkmIABBEEEEEPg6CyABKAJIIgBBhAFPBEAgABDyHwsgAUHUAGoiABCaHyABKAJkIgJBhAFPBEAgAhDyHwsCQCABKAJYRQ0AIAAoAgAiAEGEAU8EQCAAEPIfCyABQeAAahCsO0UNACABQdgAahC8KgsgASgCUEHIAEEEEPg6CyADQdAAaiQAC48CAQJ/IwBBMGsiAyQAIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCCADQShqIAEgA0EIakEgENIKAkACQAJAIAMtACgiBEEERg0AA0ACQAJAAkACQAJAIARBAWsOAwACAQQLIAMtAClBI0cNAwwCCyADKAIsLQAIQSNGDQEMAgsgAygCLC0ACEEjRw0BCyADQShqIgQQuS4gBCABIANBCGpBIBDSCiADLQAoIgRBBEcNAQwCCwsgACADKQMoNwIADAELIAMoAiwiAUEhTw0BIAIgA0EIaiICIAEgAmoQvSYgAEEEOgAAIAAgATYCBAsgA0EwaiQADwsgAUEgQYDwzQAQsDsAC4sCAQJ/IwBBMGsiAyQAIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCCADQShqIAEgA0EIahCrGQJAAkACQCADLQAoIgRBBEYNAANAAkACQAJAAkACQCAEQQFrDgMAAgEECyADLQApQSNHDQMMAgsgAygCLC0ACEEjRg0BDAILIAMoAiwtAAhBI0cNAQsgA0EoaiIEELkuIAQgASADQQhqEKsZIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALjwIBAn8jAEEwayIDJAAgA0EgakIANwMAIANBGGpCADcDACADQRBqQgA3AwAgA0IANwMIIANBKGogASADQQhqQSAQnQsCQAJAAkAgAy0AKCIEQQRGDQADQAJAAkACQAJAAkAgBEEBaw4DAAIBBAsgAy0AKUEjRw0DDAILIAMoAiwtAAhBI0YNAQwCCyADKAIsLQAIQSNHDQELIANBKGoiBBC5LiAEIAEgA0EIakEgEJ0LIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALjwIBAn8jAEEwayIDJAAgA0EgakIANwMAIANBGGpCADcDACADQRBqQgA3AwAgA0IANwMIIANBKGogASADQQhqQSAQpwcCQAJAAkAgAy0AKCIEQQRGDQADQAJAAkACQAJAAkAgBEEBaw4DAAIBBAsgAy0AKUEjRw0DDAILIAMoAiwtAAhBI0YNAQwCCyADKAIsLQAIQSNHDQELIANBKGoiBBC5LiAEIAEgA0EIakEgEKcHIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALmgIBA38jAEEQayIDJAACQCAALQBMQQFHDQAgASgCAEGAgICAeEcEQCADQQA2AgwgA0KAgICAgAE3AgQgAEEwaiEEAkAgACgCMEGAgICAeEYEQCAEEIUwIABBADYCOCAAQoCAgICAATcCMAwBCyADQQRqEOM8CyAEIAEoAggiBRDsLSAEIAEoAgQiASABIAVBA3RqEPcoCyACKAIAQYCAgIB4Rg0AIANBADYCDCADQoCAgICAATcCBCAAQTxqIQECQCAAKAI8QYCAgIB4RgRAIAEQhTAgAEEANgJEIABCgICAgIABNwI8DAELIANBBGoQ4zwLIAEgAigCCCIAEOwtIAEgAigCBCIBIAEgAEEDdGoQ9ygLIANBEGokAAv1AQEIfyMAQTBrIgEkAAJAIABFDQAgAEEQaiEFIAAoApwmIQMgACgCmCYhAiAAKAKUJiEGAkAgACAAKAIQIgdPBEAgACgCFCEEIAFBKGoiCCADNgIAIAEgAjYCJCABIAY2AiAgBUEAQSz8CwAgAUEYaiAIKAIANgIAIAEgASkDIDcDECAHIAFBEGoQiy0gACAETw0BDAILIAFBKGoiBCADNgIAIAEgAjYCJCABIAY2AiAgBUEAQSz8CwAgAUEIaiAEKAIANgIAIAEgASkDIDcDACAHIAEQiy0LIAIEQCADIAAgAhEAAAwBCyAAENI1CyABQTBqJAALhgIBCH8CfyABKAIEIgMgAksEQCAAIAEpAgw3AiQgACABKAIAIgU2AgAgAEEsaiABQRRqKAIANgIAIAMgAmshBCACIAVqIQVBACEDQQEhB0EIIQhBBCEJIAEoAggiASACagwBCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIAIAAgASgCDCIHIAEoAhAiBCACIANrIgYgBCAGSRsiA2o2AiQgBCADayECIAYgASgCFCIKaiEBQQAhBEEBIQVBLCEIQSghCUEACyEGIAAgCWogAjYCACAAIAhqIAE2AgAgACAGNgIgIAAgBDYCHCAAIAU2AhggACAKNgIUIAAgAzYCECAAIAc2AgwLigIBBH8jAEEQayIEJAAgBEEIaiABENYQAkAgBCgCCEEBcQRAIAQoAgwhAgNAIAIgASgCRCIDTw0CAkAgAyACQQFqIgVLBEAgASgCQCIDIAVBAnRqKAIAIAMgAkECdGooAgBrIgJBAE4NAUHMuIIBQRRB4LiCARDLJAALIAUgA0G8uIIBEMMhAAsgASgCSCIDIAMoAgAgAmoiAzYCACAAKAIIIgIgACgCAEYEQCAAIAEoAjhBAWoiBUF/IAUbEO4tCyAAKAIEIAJBAnRqIAM2AgAgACACQQFqNgIIIAQgARDWECAEKAIEIQIgBCgCAEEBcQ0ACwsgBEEQaiQADwsgAiADQay4ggEQwyEAC48CAQR/IwBBEGsiAyQAIAAoAgwiAiAAKAIEIgFrQdADbiEEIAEgAkcEQCABQcACaiEBA0AgAUGAAWoiAhDUJyACEO47IAFBwAJrENgSIAFBKGoiAigCAEGAgICAeEcEQCACEPA7CyABQTRqIgIoAgBBgICAgHhHBEAgAhDeOyABQUBrIgIQ0SsgAhDoOyABQcwAaiICENErIAIQ6DsgAUHYAGoQhTAgAUHkAGoQhTAgAUHwAGoQhTALIAEoAgBBgICAgHhHBEAgARD1OyABQQxqEIUwCyABQdADaiEBIARBAWsiBA0ACwsgAyAAKAIANgIMIAMgACgCCDYCCCADQQhqQQhB0AMQ4B4gA0EQaiQAC/UBAgN/BH4jAEEgayICJAACQAJAIAEoAgwiASgCBCIDIAEpAwgiBiADrSIFIAUgBlYbpyIDRwRAIAEoAgAgA2otAAAhBEEEIQMMAQtBqKHQACkCACIIQgiIIQcgCKchAyAIQv8Bg0IEUg0BCyAGQgF8IQULIAEgBTcDCAJAAkAgA0H/AXFBBEYNACACIAOtQv8BgyAHQgiGhDcDGCACQQRqIAJBGGoQ0AkgAigCBEEERg0AIAAgAikCBDcCACAAQRBqIAJBFGooAgA2AgAgAEEIaiACQQxqKQIANwIADAELIABBBDYCACAAIAQ6AAQLIAJBIGokAAuLAgEBfyMAQTBrIgUkACAFIAM6AA8CQCAAAn8CQAJAAkAgA0H/AXFBAmsOAgECAAsgBUEBNgIUIAVB+JXPADYCECAFQgE3AhwgBUGuAzYCLCAFIAVBKGo2AhggBSAFQQ9qNgIoIABBBGogBUEQahCZDkEADAILIAQoAghBA00NAiAAQQhqIARBBCAEKAIEKAAAQQRqIgEQ0hAgACABNgIEQQgMAQsgAEEIaiAEQcAAIAGtw3mnayACbCIBQQN2IAFBB3FBAEdqIgEQzRUgACABNgIEQQgLNgIAIARBDGogBCgCBCAEKAIIIAQoAgAoAhARAQAgBUEwaiQADwtBtLXOAEEjQdi1zgAQnykAC4YDAQZ/IwBB4AFrIgIkACACQRBqIgUgARCaHQJAAkAgAikDEEICUgRAIAJB5ABqIgQgARCtGiAEQQQgAigCZEEBaiIDQX8gAxsiAyADQQRNG0EAQQhB0AAQoBggAigCaCEDIAIoAmRBAUYNAiACKAJsIgYgBUHQAPwKAAAgAkEMaiIHQQE2AgAgAiAGNgIIIAIgAzYCBCAEIAFB/AD8CgAAIAJBBGohAyMAQeAAayIBJAAgASAEEJodIAEpAwBCAlIEQANAIAMoAggiBSADKAIARgRAIAFB1ABqIAQQrRogAyAFIAEoAlRBAWoiBkF/IAYbQQhB0AAQ0CgLIAMoAgQgBUHQAGxqIAFB0AD8CgAAIAMgBUEBajYCCCABIAQQmh0gASkDAEICUg0ACwsgBBDiJCABQeAAaiQAIABBCGogBygCADYCACAAIAIpAgQ3AgAMAQsgAEEANgIIIABCgICAgIABNwIAIAEQ4iQLIAJB4AFqJAAPCyADIAIoAmxByJfPABD9LwAL0gYCBX4FfyAAIAEgAiADIARBARDMAiIKQYh/SwRAIAoPCyACIAprIQNBRCECIAEgCmoiCyEBAkACQAJAAkACQCAAKAIADgQDAAECAQsgCyADIABBuAFqQgBBABCiDiICQYh/Sw0CIABBAjYCACACIAtqIQEgAyACayEDCyADQQRJDQIgAUEBNgAAIANBA2shAyABQQNqIQELIAAoAtwBBEACfiAAQeAEaiICKQMAIgZCIFoEQCACKQMQIgVCB4kgAikDCCIHQgGJfCACKQMYIghCDIl8IAIpAyAiCUISiXwgB0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAFQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAhCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCULP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfQwBCyACKQMYQsXP2bLx5brqJ3wLIAZ8IQUgBqciDEEYcSAMQR9xIQQgAkEoaiIOIQIDQCAEQQhPBEAgBEEIayEEIAIpAwBCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAFhUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSEFIAJBCGohAgwBCwsgDmohAiAMQQdxIgRBBE8EQCAEQQRrIQQgAjUCAEKHla+vmLbem55/fiAFhUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhBSACQQRqIQILA0AgBARAIARBAWshBCACMQAAQsXP2bLx5brqJ34gBYVCC4lCh5Wvr5i23puef34hBSACQQFqIQIMAQsLIAVCIYggBYVCz9bTvtLHq9lCfiIFQh2IIAWFQvnz3fGZ9pmrFn4iBUIgiCAFhSEFIANBBEkNAiABIAU+AAAgAUEEaiEBCyAAQQA2AgAgASALayICQYh/Sw0AAkAgACkDyAQiBVANACAFIAApA9AEQgF8UQ0AQbh/DwsgAiAKaiECCyACDwtBun8LpgQBBX8CQANAIAIoAggiBkHBAGtBcUkNASACIAQgBRDLIA0ACwJ/AkACQAJAAkACQAJAIAIoAggiBEHAAEYEQAJAIAEEQCAALQACRQ0BDAgLQQBBAEHMnvMAEMMhAAsgAC8BACEGDAELIAIpAwAgBEE/ca2IpyIKQf8BcSIHIAFPDQJBwAAgBGshCSAAIAdBAnRqIgUvAQAhBiAFLQACIgVBCU8EQCAJQQlJDQIgBUEhTw0EIAYgB2ogBUECdEH4nPMAaigCACAKcUEIdmoiBSABTw0FIAAgBUECdGoiAC0AAiIBQTggBGtLDQIgAiABIARqQQhqNgIIIAAvAQAhBgwBCyAFIAlLDQUgAiAEIAVqNgIICyADIAY2AgBBASEICyAIDAQLIAcgAUHcnvMAEMMhAAsgBUEhQfyd8wAQwyEACyAFIAFB7J7zABDDIQALQQALDwsCQAJAIAEgAikDACAGQT9xrYinIghB/wFxIgRLBEAgACAEQQJ0aiIFLwEAIQcgAyAFLQACIgVBCEsEfyAFQQhrQf8BcSIDQSFPDQIgBCAHaiADQQJ0Qfic8wBqKAIAIAhBCHZxQf8AcWoiAyABTw0DIAZBCGohBiAAIANBAnRqIgAtAAIhBSAALwEABSAHC0H//wNxNgIAIAIgBiAFQf8BcWo2AghBAQ8LIAQgAUGsnvMAEMMhAAsgA0EhQfyd8wAQwyEACyADIAFBvJ7zABDDIQALjQIBAn8jAEEgayIEJAAgBEEMaiACIAMQzg4CQCAEKAIMIgVBk4CAgHhHBEAgACAEKQIQNwIIIABBEGogBEEYaikCADcCACAAQSk6AAAgACAFNgIEIAEQpQwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD7HgsgASgCGCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAgAzoAAiAAIAI6AAEgAEEjOgAAIAAgASkCDDcCDCAAIAEpAhg3AhggAEEUaiABQRRqKAIANgIAIABBIGogAUEgaikCADcCACAAQShqIAFBKGopAgA3AgAgARClDAsgBEEgaiQAC40CAQJ/IwBBIGsiBCQAIARBDGogAiADEMwOAkAgBCgCDCIFQZOAgIB4RwRAIAAgBCkCEDcCCCAAQRBqIARBGGopAgA3AgAgAEEpOgAAIAAgBTYCBCABEKUMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAFBDGoQ+x4LIAEoAhgiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAIAM6AAIgACACOgABIABBJToAACAAIAEpAgw3AgwgACABKQIYNwIYIABBFGogAUEUaigCADYCACAAQSBqIAFBIGopAgA3AgAgAEEoaiABQShqKQIANwIAIAEQpQwLIARBIGokAAuNAgECfyMAQSBrIgQkACAEQQxqIAIgAxDNDgJAIAQoAgwiBUGTgICAeEcEQCAAIAQpAhA3AgggAEEQaiAEQRhqKQIANwIAIABBKToAACAAIAU2AgQgARClDCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCABQQxqEPseCyABKAIYIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAFBGGoQ+x4MAQsgACADOgACIAAgAjoAASAAQSQ6AAAgACABKQIMNwIMIAAgASkCGDcCGCAAQRRqIAFBFGooAgA2AgAgAEEgaiABQSBqKQIANwIAIABBKGogAUEoaikCADcCACABEKUMCyAEQSBqJAALjQIBAn8jAEEgayIEJAAgBEEMaiACIAMQzw4CQCAEKAIMIgVBk4CAgHhHBEAgACAEKQIQNwIIIABBEGogBEEYaikCADcCACAAQSk6AAAgACAFNgIEIAEQpQwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD7HgsgASgCGCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAgAzoAAiAAIAI6AAEgAEEmOgAAIAAgASkCDDcCDCAAIAEpAhg3AhggAEEUaiABQRRqKAIANgIAIABBIGogAUEgaikCADcCACAAQShqIAFBKGopAgA3AgAgARClDAsgBEEgaiQAC4ACAgN/A34gA0H4////AXEEQCAAIAAgA0EDdiIDQQR0IgVqIAAgA0EcbCIGaiADIAQQpBMhACABIAEgBWogASAGaiADIAQQpBMhASACIAIgBWogAiAGaiADIAQQpBMhAgsCQAJAIAAoAgAiBSAEKAIAIgcoAgQiA0kEQCABKAIAIgQgA08NASACKAIAIgYgA08NAiAAIAIgASAHKAIAIgAgBUEDdGopAwAiCCAAIARBA3RqKQMAIglTIgEgCSAAIAZBA3RqKQMAIgpTcxsgASAIIApTcxsPCyAFIANB8PaDARDDIQALIAQgA0GA94MBEMMhAAsgBiADQYD3gwEQwyEAC/4BAQN/IANB+P///wFxBEAgACAAIANBA3YiA0EEdCIFaiAAIANBHGwiBmogAyAEEKUTIQAgASABIAVqIAEgBmogAyAEEKUTIQEgAiACIAVqIAIgBmogAyAEEKUTIQILAkACQCAAKAIAIgUgBCgCACIHKAIEIgNJBEAgASgCACIEIANPDQEgAigCACIGIANPDQIgACACIAEgBygCACIAIAVBAnRqKAIAIgEgACAEQQJ0aigCACICSCIDIAIgACAGQQJ0aigCACIASHMbIAMgACABSnMbDwsgBSADQfD2gwEQwyEACyAEIANBgPeDARDDIQALIAYgA0GA94MBEMMhAAv+AQEDfyADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBCmEyEAIAEgASAFaiABIAZqIAMgBBCmEyEBIAIgAiAFaiACIAZqIAMgBBCmEyECCwJAAkAgACgCACIFIAQoAgAiBygCBCIDSQRAIAEoAgAiBCADTw0BIAIoAgAiBiADTw0CIAAgAiABIAcoAgAiACAFQQJ0aigCACIBIAAgBEECdGooAgAiAkkiAyACIAAgBkECdGooAgAiAElzGyADIAAgAUtzGw8LIAUgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEACyAGIANBgPeDARDDIQALgAICA38DfiADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBCnEyEAIAEgASAFaiABIAZqIAMgBBCnEyEBIAIgAiAFaiACIAZqIAMgBBCnEyECCwJAAkAgACgCACIFIAQoAgAiBygCBCIDSQRAIAEoAgAiBCADTw0BIAIoAgAiBiADTw0CIAAgAiABIAcoAgAiACAFQQN0aikDACIIIAAgBEEDdGopAwAiCVQiASAJIAAgBkEDdGopAwAiClRzGyABIAggClRzGw8LIAUgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEACyAGIANBgPeDARDDIQALmQIBBX8jAEFAaiICJAAgAUEYaiIEEP0WIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD2HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQlh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/BwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJgeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEPwcIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD3HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCCHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQkh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJEeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD0HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ0xggAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/RwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJUeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBDzHCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQkx4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEPwWIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD1HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQmh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ3SYgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEENIYIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCbHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBDdJiAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQjx4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEPocIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD4HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ8hwgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJkeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEPwcIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBDxHCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCBHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQhRcgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJceIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD5HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ+xwgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEENAYIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEIAdIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCUHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ0RggAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/xwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEP4WIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCQHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAvIDQIPfwJ+IwBB0ABrIgYkACAGQQRqIgNBgAE6ABggA0EANgIIIANCgICAgBA3AgAgAyABKQIANwIMIANBFGogAUEIaigCADYCACAGQThqIQgjAEFAaiICJAAgAkEwaiADEP4eAkACQAJAAkACQAJ/IAItADBBAUYEQCACKAI0DAELIAItADFBAUYEQCACLQAyQdsARw0DIAMgAy0AGEEBayIBOgAYIAFB/wFxDQIgAkEYNgIAIAMgAhCWJyEBIAhBgICAgHg2AgAgCCABNgIEDAYLIAJBBTYCACADIAIQlicLIQEgCEGAgICAeDYCACAIIAE2AgQMBAsgAxDvOiACIAM2AhwgAkEBOgAgIAJBMGogAkEcahCqGkGAgICAeCEKAkACfwJAAkACQAJAAkACQCACKAIwIgFBgICAgHhrDgICAAELIAIoAjQhCQwGCyACIAIpAjQiETcCKCACIAE2AiQgAiACQRxqEKoaIAIoAgAiDkGAgICAeGsOAgMBAgtBACACQT9qEN0fIQkMBAsgAigCBAwCCyARQiCIpyEPIAIpAgQhEiARpyEJIAEhCgwCC0EBIAJBP2oQ3R8LIQkgAkEkahDeOwsgAyADLQAYQQFqOgAYQgAhESMAQUBqIgUkAAJAIAMoAhQiASADKAIQIgRJBEAgA0EMaiELIAMoAgwhDANAAkACQAJAAkAgASAMai0AACIHQQxNBEAgB0EJa0ECSQ0EDAELIAdBH00EQCAHQQ1HDQEMBAsgB0EgRg0DIAdB3QBGDQEgB0EsRg0CCyAFQRY2AjQgBUEIaiALIAFBAWoiASAEIAEgBEkbEOoMIAVBNGogBSgCCCAFKAIMEPsoIQEMBQsgAyABQQFqNgIUQQAhAQwECyADIAFBAWoiATYCFAJAIAEgBEkEQAJ+AkADQCABIAxqLQAAIgdBCWsiDUEXS0EBIA10QZOAgARxRXINASADIAFBAWoiATYCFCABIARHDQALIAQhAUIADAELQoACCyERIAUgESAHrUIQhoQiETcDKCARQoCC9AJSDQEgBUEVNgI0IAVBGGogCyABQQFqIgEgBCABIARJGxDqDCAFQTRqIAUoAhggBSgCHBD7KCEBDAULIAVCADcDKAsgBUEWNgI0IAVBIGogCyABQQFqIgEgBCABIARJGxDqDCAFQTRqIAUoAiAgBSgCJBD7KCEBIBFC/wGDUA0DAkACQAJAIAVBKGpBBHIoAgAiBCgCAA4CAAECCyAEKAIIIgdFDQEgBCgCBCAHQQEQ+DoMAQsgBC0ABEEDRw0AIAQoAggiBygCACELIAcoAgQiDCgCACINBEAgCyANEQMACyAMKAIEIg0EQCALIA0gDCgCCBD4OgsgB0EMQQQQ+DoLIARBFEEEEPg6DAMLIAMgAUEBaiIBNgIUIAEgBEcNAAsgBCEBCyAFQQI2AjQgBUEQaiADQQxqIAFBAWoiASAEIAEgBEkbEOoMIAVBNGogBSgCECAFKAIUEPsoIQELIAVBQGskACACIAE2AhggAiASNwIQIAIgDjYCDCACIA82AgggAiAJNgIEIAIgCjYCACAKQYCAgIB4RwRAIAFFDQMgAhCkLSABIQkMAgsgAUUNAQJAAkACQCABKAIADgIAAQILIAEoAggiBEUNASABKAIEIARBARD4OgwBCyABQQRqELkuCyABQRRBBBD4OgwBCyADIAJBP2pBtMvDABCeCiEJCyADIAkQlT4hASAIQYCAgIB4NgIAIAggATYCBAwBCyAIIAJBCGoiASkCADcCCCAIQRBqIAFBCGopAgA3AgAgCCAJNgIEIAggCjYCAAsgAkFAayQAAkAgBigCOEGAgICAeEYEQCAAIAYpAjg3AgAgAEEQaiAGQcgAaikCADcCACAAQQhqIAZBQGspAgA3AgAMAQsgBkEwaiAGQcgAaiIKKQIANwMAIAZBKGogBkFAayICKQIANwMAIAYgBikCODcDICMAQSBrIgEkAAJAIAZBBGoiAygCFCIEIAMoAhAiCU8NACADQQxqIQUgAygCDCEIA0AgBCAIai0AAEEJayIHQRdLQQEgB3RBk4CABHFFckUEQCADIARBAWoiBDYCFCAEIAlHDQEMAgsLIAFBFjYCFCABQQhqIAUgBEEBaiIEIAkgBCAJSRsQ6gwgAUEUaiABKAIIIAEoAgwQ+yghEAsgAUEgaiQAIBAEQCAAQYCAgIB4NgIAIAAgEDYCBCAGQSBqEKQtDAELIAAgBikCODcCACAAQRBqIAopAgA3AgAgAEEIaiACKQIANwIACyAGQQRqEN47IAZB0ABqJAAL3AEBBn8gAiABIAJqayEJA0ACQCACIAQiB0YEQCACIQcMAQsCfyABIAdqIgQsAAAiBUEATgRAIAVB/wFxIQUgBEEBagwBCyAELQABQT9xIQYgBUEfcSEIIAVBX00EQCAIQQZ0IAZyIQUgBEECagwBCyAELQACQT9xIAZBBnRyIQYgBUFwSQRAIAYgCEEMdHIhBSAEQQNqDAELIAhBEnRBgIDwAHEgBC0AA0E/cSAGQQZ0cnIhBSAEQQRqCyAJaiEEIAMgBUYNAQsLIAAgAiAHazYCBCAAIAEgB2o2AgALogIBA38jAEEwayIBJAAgAUEANgIsIAFCgICAgBA3AiQgAUEYaiABQSRqQfSo+wAQkCEgACgC/A4hAiAAKAL4DiEDIAAgASkDGDcD+A4gAgRAIAMgAkEBEPg6CyABQQA2AiwgAUKAgICAEDcCJCABQRBqIAFBJGpB9Kj7ABCQISAAKAKEDyECIAAoAoAPIQMgACABKQMQNwOADyACBEAgAyACQQEQ+DoLIAFBADYCLCABQoCAgIAQNwIkIAFBCGogAUEkakH0qPsAEJAhIAAoAuQOIQIgACgC4A4hAyAAIAEpAwg3A+AOIAIEQCADIAJBARD4OgsgAEGQDmogAEGEEWoiAhCAGiAAQagOaiACEIAaIABBwA5qIAIQgBogAUEwaiQAC/QBAgZ/AX4jAEEgayICJAAgASgCEEEBayEEIAEoAgwhAwJAIAACfwNAIARBf0YEQCACQQxqELQeIAIoAgwiA0EERg0DIAAgAikCFDcCDCAAQRRqIAJBHGooAgA2AgAgAEELaiACKAIQIgFBGHY6AAAgACABQQh2OwAJIAAgAToACCAAIAM2AgRBAQwCCyABIAQ2AhAgASADQQFqIgY2AgwgAywAACIHQf8Aca0gBUE/ca2GIAiEIQggBEEBayEEIAVBB2ohBSAGIQMgB0EASA0ACyAAIAg3AwhBAAs2AgAgAkEgaiQADwtBAUEAQdSzzgAQrzsAC5YCAQR/IAIgACgCBCIDIAIgA0kbIgIEQCAAIAMgAms2AgQgACgCHCIDLQACIQQgA0EUaiIFIAEgASACaiAAKAIAIgYQ0iYCQAJAAkACQAJAAkACQCAEQQFrDgIBAAYLIAMoAhgiBCABSQ0BIAIgBCABayIESw0CIAMgAygCoAEgAygCFCABaiACEN0HNgKgAQwFCyADKAIYIgMgAUkNAiACIAMgAWsiA0sNAyAAIAAoAjAgBSgCACABaiACEOgHNgIwDAQLIAEgBEGs9PsAEK87AAsgAiAEQbz0+wAQsDsACyABIANBzPT7ABCvOwALIAIgA0Hc9PsAELA7AAsgACACIAZqNgIAIAAgACgCCCACajYCCAsgAguLAgEEfyAAIAAoAgggA0EEQQRBsLGDARDDKAJAAkACQCABIAJHBEADQCABKAIAIgMgASgCBCIGSQRAIANBAnQhBQNAIAMgACgCHCIETw0EIANBAWoiByAETw0FIAAoAhggBWoiA0EEaigCACADKAIAayIDQQBIDQYgACAAKAIoIANqIgQ2AiggACgCCCIDIAAoAgBGBEAgAEHAsYMBEJ0oCyAAKAIEIANBAnRqIAQ2AgAgACADQQFqNgIIIAVBBGohBSAHIgMgBkcNAAsLIAFBCGoiASACRw0ACwsPCyADIARBnLCDARDDIQALIANBAWogBEGcsIMBEMMhAAtBrLCDAUEUQcCwgwEQyyQAC/kBAQJ/IAFB/wFxIgNBCm4hBAJAAkACQCADQQlLDQACQCACQf8BcUEBaw4CAQIACyAAKAIIIQMMAgsgACgCCCIDIQIgAyAAKAIARgRAIAAgA0EBENsoIAAoAgghAgsgACADQQFqIgM2AgggACgCBCACaiAEQTBqOgAADAELIAAoAggiAyECIAMgACgCAEYEQCAAIANBARDbKCAAKAIIIQILIAAgA0EBaiIDNgIIIAAoAgQgAmpBIDoAAAsgAyICIAAoAgBGBEAgACADQQEQ2yggACgCCCECCyAAIANBAWo2AgggACgCBCACaiABIARBCmxrQTByOgAAQQALmAIBBX8jAEEQayIDJAACQAJAAkACQCABKAIIIgQEQCACKAIIIgUNAQsgAEEIakG4jYgBKAIANgIAIABBsI2IASkCADcCAAwBCyACKAIEIQYgBUEBRgRAIAYoAgAhBCADQQhqIgUgAUEIaigCADYCACADIAEpAgA3AwAgAyAEEOMOIABBCGogBSgCADYCACAAIAMpAwA3AgAgAiEBDAMLIAEoAgQhByAEQQFGDQEgACAHIAQgBiAFEKMRCyACQQRBBBDgHgwBCyAHKAIAIQQgA0EIaiIFIAJBCGooAgA2AgAgAyACKQIANwMAIAMgBBDjDiAAQQhqIAUoAgA2AgAgACADKQMANwIACyABQQRBBBDgHiADQRBqJAALogIBBH8jAEEgayIFJABBASEGAkAgACgCACIHIAEgAiAAKAIEIggoAgwiAREGAA0AAkAgAC0ACkGAAXFFBEAgB0HZ8YkBQQEgAREGAA0CIAMgACAEKAIMEQIARQ0BDAILIAdB2vGJAUECIAERBgANASAFQQE6AA8gBSAINgIEIAUgBzYCACAFQbDxiQE2AhQgBSAAKQIINwIYIAUgBUEPajYCCCAFIAU2AhAgAyAFQRBqIAQoAgwRAgANASAFKAIQQdTxiQFBAiAFKAIUKAIMEQYADQELAkAgAg0AIAAtAApBgAFxDQAgACgCAEHc8YkBQQEgACgCBCgCDBEGAA0BCyAAKAIAQZPtiQFBASAAKAIEKAIMEQYAIQYLIAVBIGokACAGC4cCAQV/IwBBMGsiAyQAIAFBFGohBAJAIAEoAhRBgYCAgHhHDQAgA0EMaiABIAIQqRogAygCDCIHQYKAgIB4RgRAQQEhBgwBCyADQShqIANBGGopAgA3AwAgAyADKQIQNwMgIAdBgYCAgHhGBEBBACEEDAELIAFBGGohAgJAIAQoAgAiBUGBgICAeEYNACAFQYCAgIB4RwRAIAFBIGoiASgCACIFIAUoAgAiBUEBazYCACAFQQFGBEAgARD4IwsgBBDDJyAEEOo7DAELIAIQ0CILIAQgBzYCACACIAMpAyA3AgAgAkEIaiADQShqKQMANwIACyAAIAQ2AgQgACAGNgIAIANBMGokAAuqEAIMfwF+IwBB4ABrIggkACAIIAMQ3DsgCCgCACIEIAgoAgRBAnRqIQkjAEEgayIFJAAgBUEUaiAJIARrQQJ2QQBBBEEMEKAYIAUoAhghByAFKAIUQQFGBEAgByAFKAIcQfDGwwAQ/S8ACyAFQRBqIgxBADYCACAFIAUoAhw2AgwgBSAHNgIIIwBBEGsiByQAIAVBCGoiBiAJIARrQQJ2Ig0Qgi4gByAGKQIEQiCJNwIIIAcgBkEIajYCBCMAQRBrIgYkACAHQQRqIgooAgQhCyAKKAIAIAQgCUcEQCAKKAIIIAtBDGxqIQogCyANIglqIQsDQCAGQQRqIAQoAgBBCGoiDSgCBCANKAIIQZC7zwBBARDkOiAKQQhqIAZBDGooAgA2AgAgCiAGKQIENwIAIARBBGohBCAKQQxqIQogCUEBayIJDQALCyALNgIAIAZBEGokACAHQRBqJAAgCEEMaiIEQQhqIAwoAgA2AgAgBCAFKQIINwIAIAVBIGokACAIIAE2AiQgCCABIAJBDGxqNgIoIAggBDYCLCAIQTBqIQkjAEEwayICJAAgAkEGNgIEIAJBKGogCEEkaiIBQQhqKAIANgIAIAIgASkCADcDICACIAJBBGo2AiwgAkEUaiEFIwBBMGsiASQAIAFBFGogAkEgaiIEEKIlAkACQAJAIAEoAhRBgICAgHhHBEAgAUEgaiILQQRBAEEEQQwQoBggASgCJCEHIAEoAiBBAUYNAiABKAIoIgYgASkCFDcCACAGQQhqIAFBHGooAgA2AgAgAUEQaiIKQQE2AgAgASAGNgIMIAEgBzYCCCABQShqIARBCGopAgA3AwAgASAEKQIANwMgIwBBEGsiBCQAIARBBGogCxCiJSAEKAIEQYCAgIB4RwRAIAFBCGohBwNAIAcoAggiBiAHKAIARgRAIAcgBkEBQQRBDBDQKAsgBygCBCAGQQxsaiIMIAQpAgQ3AgAgDEEIaiAEQQxqKAIANgIAIAcgBkEBajYCCCAEQQRqIAsQoiUgBCgCBEGAgICAeEcNAAsLIARBEGokACAFQQhqIAooAgA2AgAgBSABKQIINwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEG4gcMAEP0vAAsCQCACKAIEQQZHBEAgCSACKQIENwIAIAlBCGogAkEMaikCADcCACAFELArIAVBBEEMEOAeDAELIAkgAikCFDcCBCAJQQY2AgAgCUEMaiACQRxqKAIANgIACyACQTBqJAAgCCgCNCECIAgoAjghASAIKAI8IQQCQCAIKAIwIgxBBkcEQCAAIAQ2AgwgACABNgIIIAAgAjYCBAwBCyAIQQA2AlAgCEEANgJAIAggAjYCOCAIIAE2AjQgCCABNgIwIAggASAEQQxsajYCPCAIQRhqIQkjAEFAaiIFJAAgCEEwaiIEQRBqIQYgBCgCECECAkACQAJAAn8CQANAIAIEQCAEKAIUIgEgBCgCHCIKRw0CIAYQoSwgBkEANgIACwJAIAQoAgAiB0UNACAEKAIEIgEgBCgCDEYNACAEIAFBDGo2AgQgASgCACICQYCAgIB4Rg0AIAEpAgQhECAEIAI2AhggBCAQpyICNgIUIAQgAjYCECAEIAIgEEIgiKdBAnRqNgIcDAELCwJAIAQoAiAEQCAEKAIkIgEgBCgCLCICRw0BIARBIGoiARChLCABQQA2AgALIAlBADYCCCAJQoCAgIDAADcCACAEELkqDAMLIAQgAUEEaiIGNgIkIAIgBmtBAnYhAiABKAIAIQtBAAwBCyAEIAFBBGoiBjYCFCAEKAIsIAQoAiRrQQJ2QQAgBCgCIBshAiAEKAIAIQcgASgCACELIAogBmtBAnYLIAJqIQYCfwJAIAdFDQAgBCgCDCAEKAIERg0AIAVBEGohAkEADAELIAVBDGohAiAGCyEBIAIgATYCACAFQRBqIgFBAyAGIAZBA00bQQFqQQBBBEEEEKAYIAUoAhQhAiAFKAIQQQFGDQEgBSgCGCIHIAs2AgAgBUEIaiIOQQE2AgAgBSAHNgIEIAUgAjYCACABIARBMPwKAAAjAEEQayIEJAAgAUEgaiEGIAFBEGohCwNAAkAgCygCACECAkACfwJAAkACQAJ/AkADQCACBEAgASgCFCICIAEoAhxHDQIgCxChLCALQQA2AgALAkAgASgCAEUNACABKAIEIgIgASgCDEYNACABIAJBDGo2AgQgAigCACIHQYCAgIB4Rg0AIAIpAgQhECABIAc2AhggASAQpyICNgIUIAEgAjYCECABIAIgEEIgiKdBAnRqNgIcDAELCyAGKAIARQ0DIAEoAiQiAiABKAIsRg0CIAEgAkEEajYCJEEBDAELIAEgAkEEajYCFEEACyEHIAIoAgAhDSAFKAIIIgIgBSgCAEcNBCABKAIsIAEoAiRrQQJ2QQAgASgCIBtBACABKAIcIAEoAhRrQQJ2IAcbaiEKIAEoAgBFDQIgASgCDCABKAIERg0CIARBDGohB0EADAMLIAYQoSwgBkEANgIACyABELkqIARBEGokAAwDCyAEQQhqIQcgCgshDyAHIA82AgAgBSAKQQFqEO4tCyAFKAIEIAJBAnRqIA02AgAgBSACQQFqNgIIDAELCyAJQQhqIA4oAgA2AgAgCSAFKQIANwIACyAFQUBrJAAMAQsgAiAFKAIYQfDGwwAQ/S8ACyAAQQRqIAMgCRDoFQsgCEEMaiIBENErIAEQ6DsgACAMNgIAIAhB4ABqJAALhQIBA38gARD0LRoCQAJAAkAgACgCAEGAgICAeEcEQCAAKAIIQQFGDQEMAwsgACgCECAAKAIUKAIIQQFrQXhxaiABKAIAIgIgASgCBCIBKAIIQQFrQXhxakcEQCAAKAIMDQMgAiACKAIAIgNBAWo2AgAgA0EASA0CIABBEGoiAygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgAxC7IwsgACABNgIUIAAgAjYCEAsgAEEEag8LIAEoAgAiAiACKAIAIgNBAWo2AgAgA0EASA0AIAEoAgQhASAAENInIAAgATYCFCAAIAI2AhAgAEIINwIIIABCgICAgAg3AgAgAEEEag8LAAtBAAuFAgEDfyABEPQtGgJAAkACQCAAKAIAQYCAgIB4RwRAIAAoAghBAUYNAQwDCyAAKAIQIAAoAhQoAghBAWtBeHFqIAEoAgAiAiABKAIEIgEoAghBAWtBeHFqRwRAIAAoAgwNAyACIAIoAgAiA0EBajYCACADQQBIDQIgAEEQaiIDKAIAIgQgBCgCACIEQQFrNgIAIARBAUYEQCADELsjCyAAIAE2AhQgACACNgIQCyAAQQRqDwsgASgCACICIAIoAgAiA0EBajYCACADQQBIDQAgASgCBCEBIAAQ0ScgACABNgIUIAAgAjYCECAAQgg3AgggAEKAgICACDcCACAAQQRqDwsAC0EAC+ECAgN/An4jAEEQayIBJAAgAUEZQQBBAUEBEKAYIAEoAgQhAyABKAIAQQFGBEAgAyABKAIIQdinzgAQ/S8ACyABKAIIIgJBGGpB/LDOAC0AADoAACACQRBqQfSwzgApAAA3AAAgAkEIakHssM4AKQAANwAAIAJB5LDOACkAADcAACABQaClzgAQpSsgASkDACEEIAEpAwghBSAAQQA7AZQBIABCgIiAgICAgAg3AowBIABCgIDAgIDEEzcChAEgAEEAOgCWASAAIAI2AmQgACADNgJgIABCmYCAgICAgICAfzcDaCAAQYKEjMgANgIoIABBCDYCICAAQQA2AhggAEIANwMAIABBsKXOACkDADcDQCAAQcgAakG4pc4AKQMANwMAIABBgICAgHg2AnggACAFNwNYIAAgBDcDUCAAQQA6AJcBIABCgYCAgIAINwM4IABCgYCAgIAINwMwIAFBEGokAAuFAgIBfwJ+IwBBIGsiBSQAAkACQAJAIAMgBHEiAyACTQRAIAA1AjQhBiABIANqIAIgA2sQ7yAhByAAKAIEIgIgByAGiKciAU0NASAAKAI8IAAoAgAgAUEBdGovAQBxIAEgACgCQHRqIgIgACgCDCIDTw0CIAAoAgggAkECdGogBDYCACAAKAIEIgIgAUsNAyABIAJBrNbOABDDIQALIAVBADYCGCAFQQE2AgwgBUGY184ANgIIIAVCBDcCECAFQQhqQfzVzgAQ7ywACyABIAJBjNbOABDDIQALIAIgA0Gc1s4AEMMhAAsgACgCACABQQF0aiIAIAAvAQBBAWo7AQAgBUEgaiQAC40CAQN/IAAoAmghASAAKAJsIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAlhBgICAgHhHBEAgAEEQakEIEO4oIABBQGsiARDcJSABQQRBEBDgHiAAQdgAahDjPAsgACgCpAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBpAFqENkhCwJAIAAoAnBFDQAgACgCdCIBRQ0AIABBgAFqIAAoAnggACgCfCABKAIQEQEACwJAIAAoAoQBRQ0AIAAoAogBIgFFDQAgAEGUAWogACgCjAEgACgCkAEgASgCEBEBAAsgACgCmAFBgICAgHhHBEAgAEGYAWpBBEEgEOAeCwuaAgEBfyAAQdADahCGMAJAIAApAyBCAlENACAAQegCakEEQQQQ4B4gAEH0AmoiARDRKyABEOg7IAAoAoADQYCAgIB4RwRAIABBgANqIgEQ4CkgAUEEQRgQ4B4LIAApA1BCAlIEQCAAQfAAahCGMCAAQfwAahCGMCAAQYgBahCGMCAAQZQBahCGMAsgACgCjANBgICAgHhHBEAgAEGMA2pBBEEMEOAeCyAAKQOoAUICUgRAIABBuAFqEIUwIABBxAFqEIUwCyAAKQPQAUIDUQ0AIAAoArACQYCAgIB4Rg0AIABBsAJqEOk7CyAAKAKwA0GCgICAeE4EQCAAQbADaiIBENErIAEQ6DsgAEG8A2oQhjALIABB3ANqEIYwC/cBAQV/IAAoAgAiBCAAKAIEIgYgAaciB3EiA2opAABCgIGChIiQoMCAf4MiAVAEQEEIIQUDQCADIAVqIQMgBUEIaiEFIAQgAyAGcSIDaikAAEKAgYKEiJCgwIB/gyIBUA0ACwsgBCABeqdBA3YgA2ogBnEiA2osAAAiBUEATgRAIAQgBCkDAEKAgYKEiJCgwIB/g3qnQQN2IgNqLQAAIQULIAMgBGogB0EZdiIHOgAAIAAgACgCCCAFQQFxazYCCCAEIANBCGsgBnFqQQhqIAc6AAAgBCADQQZ0ayIDQUBqIAJBwAD8CgAAIAAgACgCDEEBajYCDCADC/8BAQV/IwBB4ABrIgQkACABLwEaIQUgAS8BGCEGIARB1ABqIgcgAUEMahDDBiAEQQhqIgggAiADIAdBABCbFAJAQdAAQQgQrTYiAwRAIANCgYCAgBA3AwAgA0EIaiAIQcgA/AoAAEEgQQQQrTYiAkUNASAAQQA6ABwgACAFOwEaIAAgBjsBGCAAIAM2AhAgAEEbOgAMIABBATYCCCAAIAI2AgQgAEEBNgIAIAIgASkCADcCACACQRhqIAFBGGopAgA3AgAgAkEQaiABQRBqKQIANwIAIAJBCGogAUEIaikCADcCACAEQeAAaiQADwtBCEHQABCjPQALQQRBIBCjPQALjwIBAn8jAEHQAGsiAyQAAkAgACkDAEIEUgRAIANBEGoiBCABIAIgAC0AQhCTFSAAEJIqIAAgBEHAAPwKAAAMAQsgAEEAOgAoIABBADYCHCAAQQA2AiQgAyABOgAHAkACQAJAIAFB/wFxQQJrDgICAQALIANBATYCFCADQczQ0AA2AhAgA0IBNwIcIANBrgM2AgwgAyADQQhqNgIYIAMgA0EHajYCCCADQRBqQdTQ0AAQ7ywACyACKAIIQQN0IQQLIAAgBDYCICAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEAIABBADYCGCAAQQhqIgBBCGogAkEIaikCADcCACAAIAIpAgA3AgALIANB0ABqJAALoQIBAX9BfyEPAkACQAJAAkACQCAEDgQCAAMBBAsgAkEANgEEIAIgBkH/AXEiAzsBAiACQQA7AQAgAiADQQN0akIANwIIQQAhD0EADQMgAUUEQEG6fw8LIAAgBy0AADoAAEEBDwsgDQRAIAIgDCAN/AoAAAtBAA8LIAIgCSALIAogDkGExAAQyAciAEEAIABBiX9PGw8LIA4gAyAIIAYQgTsiAyAFIAUgByAIakEBay0AAEECdGoiBCgCACIFQQJPBEAgBCAFQQFrNgIAIAhBAWshCAsgCCAGIAhB/w9LEPQGIg9BiH9LDQAgACABIA4gBiADEPsmIg9BiH9LDQAgDyACIA4gBiADIA5B7ABqQfQIEMgHIgAgAEGJf0kbIQ8LIA8L+wEBAX8gAkUEQCAAQgA3AgAgAEEQakEANgIAIABBCGpCADcCAEG4fw8LIAAgATYCDCAAIAFBBGo2AhAgAkEETwRAIAAgASACaiIBQQRrIgM2AgggACADKAAANgIAIAFBAWstAAAiAQRAIABBCCABZ0Efc2s2AgQgAg8LIABBADYCBEF/DwsgACABNgIIIAAgAS0AACIDNgIAAkACQAJAIAJBAmsOAgEAAgsgACABLQACQRB0IANyIgM2AgALIAAgAS0AAUEIdCADajYCAAsgASACakEBay0AACIBRQRAIABBADYCBEFsDwsgACABZyACQQN0a0EJajYCBCACC7ECAQN/IAJBB3EhAyACQRhxIQUgAkEfcSECIAEhBANAIAJBCElFBEAgAkEIayECIAQpAABCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAAhUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSEAIARBCGohBAwBCwsgASAFaiEBIANBBEkEfyABBSADQQRrIQMgATUAAEKHla+vmLbem55/fiAAhUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhACABQQRqCyECA0AgAwRAIANBAWshAyACMQAAQsXP2bLx5brqJ34gAIVCC4lCh5Wvr5i23puef34hACACQQFqIQIMAQsLIABCIYggAIVCz9bTvtLHq9lCfiIAQh2IIACFQvnz3fGZ9pmrFn4iAEIgiCAAhQuDAgEEfyMAQSBrIgUkAAJAIAIoAgAiB0EDdiIGIARNBEAgBCAGRwRAIAMgBmoiAy0AACEIIAUgASAHQQdxrYYiAUI4iDwAByAFIAFCMIg8AAYgBSABQiiIPAAFIAUgAUIgiDwABCAFIAFCGIg8AAMgBSABQhCIPAACIAUgAUIIiDwAASAFIAggAadyOgAAIAQgBmtBB00NAiADQQggBUEIQeiO0gAQ1SwgAiAAIAdqNgIAIAVBIGokAA8LQQBBAEG4iNIAEMMhAAsgBiAEQaiI0gAQrzsACyAFQQA2AhggBUEBNgIMIAVBwP/RADYCCCAFQgQ3AhAgBUEIakHYjtIAEO8sAAuCAgELfyAAKAIYIgMgAUECaiIETwRAIAMgBGsiAyACTwRAIAIEQCAAKAIgQf//A2ohCCAAKAIUIARqIQkgACgCKCEKIAAoAiwhBSAAKAIwIQsgACgChAEhBEEAIQMDQAJAIAsgAyAJai0AACAEQQV0QeD/AXFzIgRBAXRqIgwvAQAiDSABIANqIgZB//8DcUYNACAFIAYgCHFB//8DcSIHSwRAIAogB0EBdGogDTsBACAMIAY7AQAMAQsgACAENgKEASAHIAVBhOD8ABDDIQALIAIgA0EBaiIDRw0ACyAAIAQ2AoQBCw8LIAIgA0H03/wAELA7AAsgBCADQeTf/AAQrzsAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQF2IAIQiQUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARC9EyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQJ2IAIQigUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCtEyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQN2IAIQpwUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCxEyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQF2IAIQiQUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCqEyADQaACaiQAC8QNAQt/IwBBoAJrIgYkACAGQQhqIQogASgCECELIAEoAhRBAnYhCCMAQcABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAIIAJBEGoiBCgCEE8EQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMFBQALIANB+ABqIgUgAigCPEEAQQRBBBCgGCADKAJ8IQcgAygCeEEBRg0GIANBADYCLCADIAMoAoABNgIoIAMgBzYCJCAFIAQQyTQgA0HsAGogBRDVCSADKAJsQQFGBEADQCADKAJ0IgQgAygCcCIFSQ0QIAQgCEsNESADQSRqIAsgBUECdGogBCAFaxCNNSADQewAaiADQfgAahDVCSADKAJsDQALCyADQYABaiADQSxqKAIANgIAIAMgAykCJDcDeCAKIANB+ABqELgYDAMLIANB+ABqIgUgBCACKAI8ELEmIANBMGogBUE4/AoAACADKAK0ASEFIAMgAygCsAEiDEECdCIENgIkIAQhByAEQTxxIgkEQCAEIAlrQUBrIgcgBEkNBwtBwAAhCSAHQcAAENE0RQ0HIAcEQCAHQcAAEK02IglFDQkLIANB+ABqIg0gA0EwakE4/AoAACADIAg2ArwBIAMgCzYCuAEgAyAFNgK0ASADIAw2ArABIANBGGogDRDWECAJIQUgAygCGEEBcQRAIAMoAhwhBANAIAQgAygCvAEiCE8NCyAFIAMoArgBIARBAnRqKAIANgAAIAVBBGohBSADQRBqIANB+ABqENYQIAMoAhQhBCADKAIQQQFxDQALIAMoAiQhBAsgAyAFIAlrIgU2AmwgBCAFRw0KIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgBDYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQdBHEEEEK02IgVFDQsgBUKBgICAEDcCACAFIAMpAng3AgggCiAENgIIIAogBzYCBCAKIAU2AgAgBUEQaiADQYABaikCADcCACAFQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AngjAEEgayIEJAAgBEEUaiADQfgAaiIFKAIEIAUoAgBrQQJ2QQBBBEEEEKAYIAQoAhghByAEKAIUQQFGBEAgByAEKAIcQaCCgwEQ/S8ACyAEQRBqIghBADYCACAEIAQoAhw2AgwgBCAHNgIIIwBBEGsiByQAIARBCGoiCSAFKAIEIAUoAgBrQQJ2EIUuIAcgCSkCBEIgiTcCCCAHIAlBCGo2AgQgBSAHQQRqENsZIAdBEGokACADQewAaiIFQQhqIAgoAgA2AgAgBSAEKQIINwIAIARBIGokACAKIAUQuBgMAQsgA0H4AGogAigCPEEAQQRBBBCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgQEQCACKAIIIgUgBEEDdGohCQNAIAVBBGooAgAiBCAFKAIAIgdJDQ8gBCAISw0QIANB7ABqIAsgB0ECdGogBCAHaxCNNSAFQQhqIgUgCUcNAAsLIANBgAFqIANB9ABqKAIANgIAIAMgAykCbDcDeCAKIANB+ABqELgYCyADQcABaiQADA4LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyAHIAMoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSADQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAHEKM9AAsgBCAIQeyvgwEQwyEACyADQgA3AoQBIANCgYCAgMAANwJ8IANBqPuCATYCeEEAIANB7ABqIANBJGogA0H4AGpBsPuCARCvKwALQQRBHBCjPQALIAQgAygCgAFBrK+DARD9LwALIAUgBEGMr4MBELE7AAsgBCAIQYyvgwEQsDsACyAHIARBvK+DARCxOwALIAQgCEG8r4MBELA7AAsgBkGgAWogARDMBiAGQQA7AdgBIAZBADYC1AEgBkEANgK8ASAGQQA2ArABIAZCBDcCmAEgBkIANwKQASAGQoCAgIDAADcCiAEgBkEANgKAASAGIAIoAjw2AqwBIAZBFGoiBCAGQYABaiIFIAoQ+iMgBkHwAGogARCSNiACEOYYIAYoAnQEQCAGKAJwIQEgBkGIAWogBkEcakHUAPwKAAAgBiABNgKEASAGQQE2AoABIAQgBSAGQfQAahCuFgsgBkHcAWoiASAGQRRqEM0cIAAgARC5EyAGQaACaiQAC88MAQt/IwBBoAJrIgYkACAGQQhqIQogASgCECELIAEoAhRBA3YhCCMAQcABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAIIAJBEGoiBCgCEE8EQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMFBQALIANB+ABqIgUgAigCPEEAQQhBCBCgGCADKAJ8IQcgAygCeEEBRg0GIANBADYCLCADIAMoAoABNgIoIAMgBzYCJCAFIAQQyTQgA0HsAGogBRDVCSADKAJsQQFGBEADQCADKAJ0IgQgAygCcCIFSQ0QIAQgCEsNESADQSRqIAQgBWsiBBDsLSAEQQN0IgcEQCADKAIoIAMoAixBA3RqIAsgBUEDdGogB/wKAAALIAMgAygCLCAEajYCLCADQewAaiADQfgAahDVCSADKAJsDQALCyADQYABaiADQSxqKAIANgIAIAMgAykCJDcDeCAKIANB+ABqELMYDAMLIANB+ABqIgUgBCACKAI8ELEmIANBMGogBUE4/AoAACADKAK0ASEEIAMgAygCsAEiDEEDdCIHNgIkIAciBUE4cSIJBEAgBSAFIAlrQUBrIgVLDQcLQcAAIQkgBUHAABDRNEUNByAFBEAgBUHAABCtNiIJRQ0JCyADQfgAaiINIANBMGpBOPwKAAAgAyAINgK8ASADIAs2ArgBIAMgBDYCtAEgAyAMNgKwASADQRhqIA0Q1hAgCSEEIAMoAhhBAXEEQCADKAIcIQgDQCAIIAMoArwBIgtPDQsgBCADKAK4ASAIQQN0aikDADcAACAEQQhqIQQgA0EQaiADQfgAahDWECADKAIUIQggAygCEEEBcQ0ACwsgAyAEIAlrIgQ2AmwgBCAHRw0KIAMgBTYCiAEgA0KAgICAgAg3AoABIAMgBzYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQVBHEEEEK02IgRFDQsgBEKBgICAEDcCACAEIAMpAng3AgggCiAHNgIIIAogBTYCBCAKIAQ2AgAgBEEQaiADQYABaikCADcCACAEQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AnggA0HsAGoiBCADQfgAahD9GiAKIAQQsxgMAQsgA0H4AGogAigCPEEAQQhBCBCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgUEQCACKAIIIgQgBUEDdGohCQNAIARBBGooAgAiBSAEKAIAIgdJDQ8gBSAISw0QIANB7ABqIAUgB2siBRDsLSAFQQN0IgwEQCADKAJwIAMoAnRBA3RqIAsgB0EDdGogDPwKAAALIAMgAygCdCAFajYCdCAEQQhqIgQgCUcNAAsLIANBgAFqIANB9ABqKAIANgIAIAMgAykCbDcDeCAKIANB+ABqELMYCyADQcABaiQADA4LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyAHIAMoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSADQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgCCALQeyvgwEQwyEACyADQgA3AoQBIANCgYCAgMAANwJ8IANBqPuCATYCeEEAIANB7ABqIANBJGogA0H4AGpBsPuCARCvKwALQQRBHBCjPQALIAQgAygCgAFBrK+DARD9LwALIAUgBEGMr4MBELE7AAsgBCAIQYyvgwEQsDsACyAHIAVBvK+DARCxOwALIAUgCEG8r4MBELA7AAsgBkGgAWogARDMBiAGQQA7AdgBIAZBADYC1AEgBkEANgK8ASAGQQA2ArABIAZCBDcCmAEgBkIANwKQASAGQoCAgIDAADcCiAEgBkEANgKAASAGIAIoAjw2AqwBIAZBFGoiBCAGQYABaiIFIAoQ+iMgBkHwAGogARCSNiACEOYYIAYoAnQEQCAGKAJwIQEgBkGIAWogBkEcakHUAPwKAAAgBiABNgKEASAGQQE2AoABIAQgBSAGQfQAahCuFgsgBkHcAWoiASAGQRRqEM0cIAAgARCuEyAGQaACaiQAC4YCAQp/IwBBEGsiAiQAIAJBBGogARDUBgJAIAEoAiAiBQRAIAUgBSgCACIDQQFqNgIAIANBAEgNASABKAIwIQggASgCLCEJIAEoAighCiABKAIkIQsgASgCNCEHCyABKAIMIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIUIgQgBCgCACIGQQFqNgIAIAZBAEgNACABKAIQIQYgACACKQIENwIAIAAgBzYCNCAAIAg2AjAgACAJNgIsIAAgCjYCKCAAIAs2AiQgACAFNgIgIAAgBDYCFCAAIAY2AhAgACADNgIMIAAgASkCGDcCGCAAQQhqIAJBDGooAgA2AgAgAkEQaiQADwsAC5MCAgd/AX4jAEGQAmsiAiQAAkAgAQRAIAJBpAFqIQUgAkGYAWohAyACQfwBaiEGIAJB9AFqIQcgAkGQAWohBANAIAJBCGoiCCAAENkcIAIpAwhCDVENAiAEIAhBgAH8CgAAIAIgATYCiAECQCACKQOQASIJQgxSBEACQAJAAkBBASAJp0EJayAJQghYGw4CAQIACyAFIAIoApwBIAIoAqABIAIoApgBKAIQEQEADAMLIAYgAigC9AEgAigC+AEgAigC8AEoAhARAQAgAxDCGAwCCyAHIAIoAuwBIAIoAvABIAIoAugBKAIQEQEAIAQQwhgMAQsgAxDJIwsgAUEBayIBDQALC0EAIQELIAJBkAJqJAAgAQvrAQEHfyAAKAIAIgRBCGohBQJAIAAoAggiAEEBaiIGIAQvAQYiA0sNACADIABrIgdFDQAgBSAGaiAAIAVqIAf8CgAACyADQQFqIQcgACAFaiABOgAAIARBFGohAQJAIANBAmoiBSAAQQJqIghNDQAgAyAAa0ECdCIJRQ0AIAEgCEECdGogASAGQQJ0aiAJ/AoAAAsgASAGQQJ0aiACNgIAIAQgBzsBBiAFIAZLBEAgA0EBaiECIABBAnQgBGpBGGohAQNAIAEoAgAiAyAAQQFqIgA7AQQgAyAENgIAIAFBBGohASAAIAJHDQALCwvuAQEHfwJ/IAEoAkQgASgCSCIFayIEIAMgAyAESxsiBkUEQEEAIQRBACEGQQEMAQsgASgCQCIHQYAQaiEJIAEtAEwhCiAHIQhBACEEQQAhA0EAIQEDQAJAAkAgBUUEQCABQYAQRw0BDAILQQEgBSAJIAhrQQF2Tw0DGiAFQQF0IAFqIQELAkAgASAHai8BACADQQBHIApyQQFxRXINACAEQQFqIgQgAkcNACACIQQgAyEGQQAMAwsgByABQQJqIgFqIQhBACEFIAYgA0EBaiIDRw0BCwtBAQshASAAIAY2AgggACAENgIAIAAgAToABAuOAgECfyMAQTBrIgIkACABLQASIQMgAUECOgASAkAgA0ECRwRAIABBBDYCACAAIAM6AAQMAQsgAkEQaiABEJsTIAItABQhASACKAIQIgNBBEcEQCAAIAIpABU3AAUgAEEMaiACQRxqKQAANwAAIAAgAToABCAAIAM2AgAMAQsCQAJAAkAgAUEBaw4CAQIACyACIAE6AA8gAkECNgIUIAJBgMfOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAILIABBBDYCACAAQQE6AAQMAQsgAEEENgIAIABBADoABAsgAkEwaiQAC44CAQJ/IwBBMGsiAiQAIAEtABIhAyABQQI6ABICQCADQQJHBEAgAEEENgIAIAAgAzoABAwBCyACQRBqIAEQxBkgAi0AFCEBIAIoAhAiA0EERwRAIAAgAikAFTcABSAAQQxqIAJBHGopAAA3AAAgACABOgAEIAAgAzYCAAwBCwJAAkACQCABQQFrDgIBAgALIAIgAToADyACQQI2AhQgAkGAx84ANgIQIAJCATcCHCACQbsHNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBAToAECAAQQE2AgAMAgsgAEEENgIAIABBAToABAwBCyAAQQQ2AgAgAEEAOgAECyACQTBqJAAL+Q0BBX8gASgCCCEHIAEgASgCDCADbCIGEOUtIAFBfyABKAIIIgQgBmoiBSAEIAVLGxCOLQJAAkACQAJAIAYgBiAHaiIETQRAIAQgASgCCCIFSw0BIAEoAgQgB2ohBwJAAkACQAJAAkACQAJAAkACQCABKAIMIgFBAmsOBwECAwQFBgcACyAHIQQgBiEHIwBBMGsiBSQAIAUgATYCAAJAAkAgAwRAIAIgA0EEdGohCEEAIQMDQCACKAIARQ0OAkAgASACQQhqKAIAIgZGBEAgASADaiIGIAFJDQQgBiAHTQ0BIAYgB0G07M4AELA7AAsgBSAGNgIcIAVBAjYCCCAFQfzrzgA2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBTYCKCAFIAVBHGo2AiAgBUEEakHE7M4AEO8sAAsgAQRAIAMgBGogAkEEaigCACAB/AoAAAsgBiEDIAJBEGoiAiAIRw0ACwsgBUEwaiQADAELIAMgBkG07M4AELE7AAsMBwsjAEEwayIEJAACQCADBEAgAiADQQR0aiEFQQAhAQNAIAIoAgBFDQwCQCACQQhqKAIAIgNBAkYEQCABQQJqIgMgBk0NAQwPCyAEIAM2AhwgBEECNgIIIARB/OvOADYCBCAEQgI3AhAgBEE7NgIsIARBoOzOADYCKAwPCyABIAdqIAJBBGooAgAvAAA7AAAgAyEBIAJBEGoiAiAFRw0ACwsgBEEwaiQADAALDAYLIwBBMGsiBCQAAkAgAwRAIAIgA0EEdGohBUEAIQEDQCACKAIARQ0LAkAgAkEIaigCACIDQQNGBEAgAUEDaiIDIAZNDQEMDgsgBCADNgIcIARBAjYCCCAEQfzrzgA2AgQgBEICNwIQIARBOzYCLCAEQajszgA2AigMDgsgASAHaiIBIAJBBGooAgAiCC8AADsAACABQQJqIAhBAmotAAA6AAAgAyEBIAJBEGoiAiAFRw0ACwsgBEEwaiQADAALDAULIwBBMGsiBCQAAkAgAwRAIAIgA0EEdGohBUEAIQEDQCACKAIARQ0KAkAgAkEIaigCACIDQQRGBEAgAUEEaiIDIAZNDQEMDQsgBCADNgIcIARBAjYCCCAEQfzrzgA2AgQgBEICNwIQIARBOzYCLCAEQdDrzgA2AigMDQsgASAHaiACQQRqKAIAKAAANgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwECyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNCQJAIAJBCGooAgAiA0EFRgRAIAFBBWoiAyAGTQ0BDAwLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGw7M4ANgIoDAwLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEEaiAIQQRqLQAAOgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwDCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNCAJAIAJBCGooAgAiA0EGRgRAIAFBBmoiAyAGTQ0BDAsLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGs7M4ANgIoDAsLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEEaiAIQQRqLwAAOwAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwCCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNBwJAIAJBCGooAgAiA0EHRgRAIAFBB2oiAyAGTQ0BDAoLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGc7M4ANgIoDAoLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEDaiAIQQNqKAAANgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwBCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNBgJAIAJBCGooAgAiA0EIRgRAIAFBCGoiAyAGTQ0BDAkLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGk7M4ANgIoDAkLIAEgB2ogAkEEaigCACkAADcAACADIQEgAkEQaiICIAVHDQALCyAEQTBqJAAMAAsLIABBCDYCAA8LIAcgBEHk7M4AELE7AAsgBCAFQeTszgAQsDsAC0Hkh84AQSBBhIjOABDLJAALIAMgBkHA684AELA7AAsgBEE7NgIkIAQgBEEgajYCDCAEIARBHGo2AiAgBEEEakGM7M4AEO8sAAuBAgECfyMAQRBrIgUkACAFQQA2AgwgAC0AACEGAn8CQANAAkACQAJAAkACQCAGQQFrDgIBAgALIAFBASAFQQxqIAMgBBDtH0UNBUEBIQYgBSgCDEUNAwwCCyABQQMgBUEMaiADIAQQ7R9FBEAgAEEBOgAADAULIAUoAgwiBkUEQCAAQQA6AAAgAkEBNgIAQQEMBgsgAiAGNgIAQQIhBgwBCyABIAIoAgAiASAFQQxqIAMgBBDtH0UEQCAAQQI6AABBAgwFCyAAQQA6AAAgAiAFKAIMQQEgAXRqNgIAQQEMBAsgACAGOgAADAELCyACQQA2AgBBAQwBC0ECCyAFQRBqJAAL4QMBBn8jAEEQayIFJAAgACgCACIAQQA6ABwCQCAAKAIIIgJB/////wdJBEACQCAAKAIYIgZFDQAgAg0CA0ACQCAAQX82AgggACgCGCICRQ0AIAAgAkEBazYCGCAAKAIQIAAoAhQiA0ECdGooAgAhAiAAQQA2AgggACADQQFqIgMgACgCDCIEQQAgAyAETxtrNgIUIAUgAjYCDCMAQRBrIgMkAAJAIAJBCGoiAigCAEUEQCACQX82AgAgAigCBCIERQRAQQAhBAwCCyACQQA6ABQgA0EANgIIIAMgAkEMaiIHNgIEIAMgBzYCACAEIAMgAigCCCgCDBECAEUEQCACQQRqIgQQ4icgBEEANgIACyACKAIAQQFqIQQMAQtB6KqIARCbPgALIAIgBDYCACADQRBqJAAgBSgCDCICIAIoAgBBAWsiAjYCACACRQRAIAVBDGoQqisLIAZBAWsiBkUNAiAAKAIIRQ0BDAQLCyAAQQA2AggLIAFBhAFPBEAgARDyHwsgBUEQaiQADwsjAEEwayIAJAAgAEEBNgIMIABBwO2JATYCCCAAQgE3AhQgACAAQS9qrUKAgICAwOMDhDcDICAAIABBIGo2AhAgAEEIakG8qIgBEO8sAAtBzKiIARCbPgAL9gwCDn8FfiMAQZABayIEJAAgBEEIaiACEMUKIAQoAhQhAiAEKAIQIQUgBCgCDCEGAkAgBCgCCCIHQQZHBEAgACACNgIUIAAgBTYCECAAIAY2AgwgACAHNgIIIABCAjcDACABEPslDAELIARBMGogAUEYaikDADcDACAEQShqIAFBEGopAwA3AwAgBEEgaiABQQhqKQMANwMAIARBgAg2AoQBIAQgAjYCgAEgBCAFNgJ8IAQgBjYCeCAEQYCAgIB4NgJsIARBgICAgHg2AmAgBEGAgICAeDYCVCAEQYCAgIB4NgJIIARCgICAgICAgKAGNwOIASAEQQA2AkAgBEEANgI4IAQgASkDADcDGCAEQRhqIQIjAEHgAWsiASQAIAMoAgBBAUYEQCACIAIoAmAoAggiBSADKAIEIgYgBSAGSRs2AmwLIAMoAghBAUYEQCACQQE2AiAgAiADKAIMNgIkCyADKAIQQQFGBEAgAkEBNgIoIAIgAygCFDYCLAsCQCADKAIsQYCAgIB4RwRAIAIoAmBBCGoQhTwhBSABQegAaiADKAIwIAMoAjQgBRDSEyABQdAAaiIFIAFB9ABqKAIANgIAIAEgASkCbDcDSCABKAJoIgZBBkcEQCACQeAAaiEDIAAgASkDSDcCDCAAIAY2AgggAEICNwMAIABBFGogBSgCADYCAAJAIAIoAgBFBEAgAigCECIAQYQBSQ0BIAAQ8h8MAQsgAkEQahDeOyACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNACACQRxqEJ0nCyADKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCADEJcVCyACKAJkIgAgACgCACIAQQFrNgIAIABBAUYEQCACQeQAahD4IwsCQCACKAJoIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJB6ABqENseCyACQTBqEJcwIAJBPGoQhjAgAkHIAGoQni8gAkHUAGoQjjAgAigCcCIARQ0CIAAgACgCACIAQQFrNgIAIABBAUcNAiACQfAAahCBLAwCCyABQTBqIgYgBSgCADYCACABIAEpA0g3AyggAUHoAGogAkH4APwKAAAgAUHgAGoiByACQRhqIggpAwA3AwAgAUHYAGoiCSACQRBqIgopAwA3AwAgBSACQQhqIgspAwA3AwAgAUFAayIMIAJBOGoiDSgCADYCACABQSBqIg4gAkHQAGoiDygCADYCACABIAIpAwA3A0ggASACKQMwNwM4IAEgAikDSDcDGCABKQPQASESIAEpA8gBIRMgAUEQaiIQIAJB3ABqIhEoAgA2AgAgASACKQJUNwMIIAEpA9gBIRQgASkDiAEhFSABKQOQASEWIAFBpAFqEIYwIAggBykDADcDACAKIAkpAwA3AwAgCyAFKQMANwMAIAIgASkDSDcDACACIBY3AyggAiAVNwMgIAIgASkDODcDMCANIAwoAgA2AgAgAiABKQMoNwI8IAJBxABqIAYoAgA2AgAgAiATNwNgIAIgEjcDaCACIBQ3A3AgDyAOKAIANgIAIAIgASkDGDcDSCACIAEpAwg3AlQgESAQKAIANgIACyADKAIgQYCAgIB4RwRAIAFB6ABqIAJB+AD8CgAAIAFBOGogA0EgahCJHSABQeAAaiIDIAFBgAFqKQMANwMAIAFB2ABqIgUgAUH4AGopAwA3AwAgAUHQAGoiBiABQfAAaikDADcDACABQTBqIgcgAUGsAWooAgA2AgAgAUEgaiIIIAFBuAFqKAIANgIAIAEgASkDaDcDSCABIAEpAqQBNwMoIAEgASkDsAE3AxggASkDyAEhEiABKQPQASETIAFBEGoiCSABQcQBaigCADYCACABIAEpArwBNwMIIAEpA9gBIRQgASkDiAEhFSABKQOQASEWIAFBmAFqEJcwIAJBGGogAykDADcDACACQRBqIAUpAwA3AwAgAkEIaiAGKQMANwMAIAIgASkDSDcDACACIBY3AyggAiAVNwMgIAIgASkDODcDMCACQThqIAFBQGsoAgA2AgAgAiABKQMoNwI8IAJBxABqIAcoAgA2AgAgAiAUNwNwIAIgEzcDaCACIBI3A2AgAkHQAGogCCgCADYCACACIAEpAxg3A0ggAkHcAGogCSgCADYCACACIAEpAwg3AlQLIAAgAkH4APwKAAALIAFB4AFqJAALIARBkAFqJAAL6QEBAX4jAEGwAmsiAiQAIAJBADYCDCACIAE2AgggAkEoaiACQQhqEI4UIAJBGGoiASACQThqKQMANwMAIAJBIGoiAyACQUBrKQMANwMAIAIgAikDMDcDEAJAIAIpAygiBEIEUQRAIAAgAikDEDcDECAAQgQ3AwggAEEgaiADKQMANwMAIABBGGogASkDADcDAAwBCyAAQShqIAJByABqQegB/AoAACAAQSBqIAJBIGopAwA3AwAgAEEYaiACQRhqKQMANwMAIAAgAikDEDcDECAAIAQ3AwggACACKAIMNgIACyACQbACaiQAC+sBAgJ/AX4jAEGwAmsiAiQAIAJBADYCDCACIAE2AgggAkEoaiACQQhqEI4UIAJBGGoiASACQThqKQMANwMAIAJBIGoiAyACQUBrKQMANwMAIAIgAikDMDcDEAJAIAIpAygiBEIEUQRAIAAgAikDEDcDECAAQgQ3AwggAEEgaiADKQMANwMAIABBGGogASkDADcDAAwBCyAAQShqIAJByABqQegB/AoAACAAQSBqIAJBIGopAwA3AwAgAEEYaiACQRhqKQMANwMAIAAgAikDEDcDECAAIAQ3AwggACACKAIMNgIACyACQbACaiQAC4oCAQF/AkACfwJAAkACQAJAAkACQAJAAkAgACgCAA4KCQEBAQECAwQFBgALIAAoAggiAUUNBiAAKAIEIAFBAnRBBBD4OgwGCyAAKAIIIgFFDQdBBAwGCyAAKAIIIgFFDQQgACgCBCABQQF0QQIQ+DoMBAsgACgCCCIBRQ0DIAAoAgQgAUEBdEECEPg6DAMLIAAoAggiAUUNAiAAKAIEIAFBAXRBAhD4OgwCCyAAKAIMIgEEQCAAKAIIIAFBAXRBAhD4OgsgACgCFCIBRQ0DQRAMAgsgACgCCCIBRQ0AIAAoAgQgAUEBdEECEPg6CyAAKAIQIgFFDQFBDAsgAGooAgAgAUECdEEEEPg6Cwv9DQEKfyMAQaACayIGJAAgBkEIaiEKIAEoAhAhCyABKAIUIQgjAEHAAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCCACQRBqIgQoAhBPBEACQAJAAkACQAJAAkAgAigCAEEBaw4FAQIDBQUACyADQfgAaiIFIAIoAjxBAEEBQQEQoBggAygCfCEHIAMoAnhBAUYNBiADQQA2AiwgAyADKAKAATYCKCADIAc2AiQgBSAEEMk0IANB7ABqIAUQ1QkgAygCbEEBRgRAA0AgAygCdCIEIAMoAnAiBUkNECAEIAhLDREgA0EkaiAEIAVrIgQQgS4gBARAIAMoAiggAygCLGogBSALaiAE/AoAAAsgAyADKAIsIARqNgIsIANB7ABqIANB+ABqENUJIAMoAmwNAAsLIANBgAFqIANBLGooAgA2AgAgAyADKQIkNwN4IAogA0H4AGoQ8hgMAwsgA0H4AGoiBSAEIAIoAjwQsSYgA0EwaiAFQTj8CgAAIAMoArQBIQUgAyADKAKwASIENgIkIAQhByAEQT9xIgkEQCAEIAlrQUBrIgcgBEkNBwtBwAAhCSAHQcAAENE0RQ0HIAcEQCAHQcAAEK02IglFDQkLIANB+ABqIgwgA0EwakE4/AoAACADIAg2ArwBIAMgCzYCuAEgAyAFNgK0ASADIAQ2ArABIANBGGogDBDWECAJIQUgAygCGEEBcQRAIAMoAhwhBANAIAQgAygCvAEiCE8NCyAFIAMoArgBIARqLQAAOgAAIAVBAWohBSADQRBqIANB+ABqENYQIAMoAhQhBCADKAIQQQFxDQALIAMoAiQhBAsgAyAFIAlrIgU2AmwgBCAFRw0KIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgBDYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQdBHEEEEK02IgVFDQsgBUKBgICAEDcCACAFIAMpAng3AgggCiAENgIIIAogBzYCBCAKIAU2AgAgBUEQaiADQYABaikCADcCACAFQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AngjAEEgayIEJAAgBEEUaiADQfgAaiIFKAIEIAUoAgBrQQJ2QQBBAUEBEKAYIAQoAhghByAEKAIUQQFGBEAgByAEKAIcQaCCgwEQ/S8ACyAEQRBqIghBADYCACAEIAQoAhw2AgwgBCAHNgIIIwBBEGsiByQAIARBCGoiCSAFKAIEIAUoAgBrQQJ2EIEuIAcgCSkCBEIgiTcCCCAHIAlBCGo2AgQgBSAHQQRqELwbIAdBEGokACADQewAaiIFQQhqIAgoAgA2AgAgBSAEKQIINwIAIARBIGokACAKIAUQ8hgMAQsgA0H4AGogAigCPEEAQQFBARCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgQEQCACKAIIIgUgBEEDdGohCQNAIAVBBGooAgAiBCAFKAIAIgdJDQ8gBCAISw0QIANB7ABqIAQgB2siBBCBLiAEBEAgAygCcCADKAJ0aiAHIAtqIAT8CgAACyADIAMoAnQgBGo2AnQgBUEIaiIFIAlHDQALCyADQYABaiADQfQAaigCADYCACADIAMpAmw3A3ggCiADQfgAahDyGAsgA0HAAWokAAwOC0H8rYMBQShB3K+DARCfKQALQbSugwFBOEHsroMBEJ8pAAsgByADKAKAAUH8roMBEP0vAAtB9PmCAUEjQZj6ggEQyyQAC0G4+oIBQSkgA0H4AGpBsIKDAUHk+oIBENUeAAtBwAAgBxCjPQALIAQgCEHsr4MBEMMhAAsgA0IANwKEASADQoGAgIDAADcCfCADQaj7ggE2AnhBACADQewAaiADQSRqIANB+ABqQbD7ggEQrysAC0EEQRwQoz0ACyAEIAMoAoABQayvgwEQ/S8ACyAFIARBjK+DARCxOwALIAQgCEGMr4MBELA7AAsgByAEQbyvgwEQsTsACyAEIAhBvK+DARCwOwALIAZBoAFqIAEQzAYgBkEAOwHYASAGQQA2AtQBIAZBADYCvAEgBkEANgKwASAGQgQ3ApgBIAZCADcCkAEgBkKAgICAwAA3AogBIAZBADYCgAEgBiACKAI8NgKsASAGQRRqIgQgBkGAAWoiBSAKEPojIAZB8ABqIAEQkjYgAhDmGCAGKAJ0BEAgBigCcCEBIAZBiAFqIAZBHGpB1AD8CgAAIAYgATYChAEgBkEBNgKAASAEIAUgBkH0AGoQrhYLIAZB3AFqIgEgBkEUahDNHCAAIAEQthMgBkGgAmokAAuzDQEKfyMAQaACayIGJAAgBkEIaiEKIAEoAhAhCyABKAIUIQgjAEHAAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCCACQRBqIgQoAhBPBEACQAJAAkACQAJAAkAgAigCAEEBaw4FAQIDBQUACyADQfgAaiIFIAIoAjxBAEEBQQEQoBggAygCfCEHIAMoAnhBAUYNBiADQQA2AiwgAyADKAKAATYCKCADIAc2AiQgBSAEEMk0IANB7ABqIAUQ1QkgAygCbEEBRgRAA0AgAygCdCIEIAMoAnAiBUkNECAEIAhLDREgA0EkaiAFIAtqIAQgBWsQoTYgA0HsAGogA0H4AGoQ1QkgAygCbA0ACwsgA0GAAWogA0EsaigCADYCACADIAMpAiQ3A3ggCiADQfgAahCTGQwDCyADQfgAaiIFIAQgAigCPBCxJiADQTBqIAVBOPwKAAAgAygCtAEhBSADIAMoArABIgQ2AiQgBCEHIARBP3EiCQRAIAQgCWtBQGsiByAESQ0HC0HAACEJIAdBwAAQ0TRFDQcgBwRAIAdBwAAQrTYiCUUNCQsgA0H4AGoiDCADQTBqQTj8CgAAIAMgCDYCvAEgAyALNgK4ASADIAU2ArQBIAMgBDYCsAEgA0EYaiAMENYQIAkhBSADKAIYQQFxBEAgAygCHCEEA0AgBCADKAK8ASIITw0LIAUgAygCuAEgBGotAAA6AAAgBUEBaiEFIANBEGogA0H4AGoQ1hAgAygCFCEEIAMoAhBBAXENAAsgAygCJCEECyADIAUgCWsiBTYCbCAEIAVHDQogAyAHNgKIASADQoCAgICACDcCgAEgAyAENgJ8IAMgCTYCeCADQQhqIANB+ABqENc7IAMoAgghB0EcQQQQrTYiBUUNCyAFQoGAgIAQNwIAIAUgAykCeDcCCCAKIAQ2AgggCiAHNgIEIAogBTYCACAFQRBqIANBgAFqKQIANwIAIAVBGGogA0GIAWooAgA2AgAMAgsgAigCCCEEIAIoAgwhBSADIAg2AoQBIAMgCzYCgAEgAyAEIAVBAnRqNgJ8IAMgBDYCeCMAQSBrIgQkACAEQRRqIANB+ABqIgUoAgQgBSgCAGtBAnZBAEEBQQEQoBggBCgCGCEHIAQoAhRBAUYEQCAHIAQoAhxBoIKDARD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAc2AggjAEEQayIHJAAgBEEIaiIJIAUoAgQgBSgCAGtBAnYQhC4gByAJKQIEQiCJNwIIIAcgCUEIajYCBCAFIAdBBGoQvBsgB0EQaiQAIANB7ABqIgVBCGogCCgCADYCACAFIAQpAgg3AgAgBEEgaiQAIAogBRCTGQwBCyADQfgAaiACKAI8QQBBAUEBEKAYIAMoAnwhBCADKAJ4QQFGDQogA0EANgJ0IAMgAygCgAE2AnAgAyAENgJsIAIoAgwiBARAIAIoAggiBSAEQQN0aiEJA0AgBUEEaigCACIEIAUoAgAiB0kNDyAEIAhLDRAgA0HsAGogByALaiAEIAdrEKE2IAVBCGoiBSAJRw0ACwsgA0GAAWogA0H0AGooAgA2AgAgAyADKQJsNwN4IAogA0H4AGoQkxkLIANBwAFqJAAMDgtB/K2DAUEoQdyvgwEQnykAC0G0roMBQThB7K6DARCfKQALIAcgAygCgAFB/K6DARD9LwALQfT5ggFBI0GY+oIBEMskAAtBuPqCAUEpIANB+ABqQbCCgwFB5PqCARDVHgALQcAAIAcQoz0ACyAEIAhB7K+DARDDIQALIANCADcChAEgA0KBgICAwAA3AnwgA0Go+4IBNgJ4QQAgA0HsAGogA0EkaiADQfgAakGw+4IBEK8rAAtBBEEcEKM9AAsgBCADKAKAAUGsr4MBEP0vAAsgBSAEQYyvgwEQsTsACyAEIAhBjK+DARCwOwALIAcgBEG8r4MBELE7AAsgBCAIQbyvgwEQsDsACyAGQaABaiABEMwGIAZBADsB2AEgBkEANgLUASAGQQA2ArwBIAZBADYCsAEgBkIENwKYASAGQgA3ApABIAZCgICAgMAANwKIASAGQQA2AoABIAYgAigCPDYCrAEgBkEUaiIEIAZBgAFqIgUgChD6IyAGQfAAaiABEJI2IAIQ5hggBigCdARAIAYoAnAhASAGQYgBaiAGQRxqQdQA/AoAACAGIAE2AoQBIAZBATYCgAEgBCAFIAZB9ABqEK4WCyAGQdwBaiIBIAZBFGoQzRwgACABELgTIAZBoAJqJAALhwIBBX8jAEHQAGsiAiQAIABBDGoiBSAAKAIUIAAoAihBAUEBQdCxgwEQwyggAiABQcAA/AoAACACQcQAaiACENUJAkACQAJAAkAgAigCREEBRgRAA0AgAigCSCIDIAAoAhwiAU8NAiACKAJMIgQgAU8NAyAAKAIYIgYgBEECdGooAgAiASAGIANBAnRqKAIAIgNJDQQgASAAKAIkIgRLDQUgBSAAKAIgIANqIAEgA2sQoTYgAkHEAGogAhDVCSACKAJEDQALCyACQdAAaiQADwsgAyABQZywgwEQwyEACyAEIAFBnLCDARDDIQALIAMgAUHgsYMBELE7AAsgASAEQeCxgwEQsDsAC4cCAQV/IwBB0ABrIgIkACAAQSRqIgUgACgCLCAAKAIAQQFBAUHQsYMBEMMoIAIgAUHAAPwKAAAgAkHEAGogAhDVCQJAAkACQAJAIAIoAkRBAUYEQANAIAIoAkgiAyAAKAIMIgFPDQIgAigCTCIEIAFPDQMgACgCCCIGIARBA3RqKAIAIgEgBiADQQN0aigCACIDSQ0EIAAoAhQiBCABSQ0FIAUgACgCECADaiABIANrEKE2IAJBxABqIAIQ1QkgAigCRA0ACwsgAkHQAGokAA8LIAMgAUGcsIMBEMMhAAsgBCABQZywgwEQwyEACyADIAFB4LGDARCxOwALIAEgBEHgsYMBELA7AAvxAQIDfwJ+IAAoAgwgA0EDdGoiBCAAKAIESwRAIAQQ3iohBCAAIAAoAgRBAXQiBSAEIAQgBUkbEOgZCwJAIANBAk8EQCACQQhqIQQgA0EBaiEDIAIpAwAhBwNAIAQpAwAiCCAHfSIHQgBTIAEgASAHfCIBVUcNAiAAKAIMIgJBCGoiBSAAKAIEIgZLBH8gACAGQQF0IgIgBRDeKiIFIAIgBUsbEOgZIAAoAgwFIAILIAAoAghqIAE3AAAgACAAKAIMQQhqNgIMIARBCGohBCAIIQcgA0EBayIDQQJLDQALCw8LQeSihwFBD0H0oocBEMskAAvzAQEEfyAAKAIMIANBAnRqIgQgACgCBEsEQCAEEN4qIQQgACAAKAIEQQF0IgUgBCAEIAVJGxDoGQsCQCADQQJPBEAgAkEEaiEFIANBAWohBiACKAIAIQIDQCAFKAIAIgQgAmsiAkEASCABIAJqIgMgAUhHDQIgACgCDCIBQQRqIgIgACgCBCIHSwR/IAAgB0EBdCIBIAIQ3ioiAiABIAJLGxDoGSAAKAIMBSABCyAAKAIIaiADNgAAIAAgACgCDEEEajYCDCAFQQRqIQUgBCECIAMhASAGQQFrIgZBAksNAAsLDwtB5KKHAUEPQfSihwEQyyQAC/QBAgF/B34jAEEwayIFJAAgBSABIAIgAyAEENAIIAU1AighDCAFKQMYIQogBSkDECEGIAUoAiQhAyAFKAIgIQIgBSkDCCELAn8CQCAFKQMAIgenIgFFBEAgA0UNASAHUK1CAYYhCCACKQMAIQcgBiEJQgEhBiACQQhqDAILIAFFDQAgBiEJIAshB0IBIQYgAgwBC0IDIQggCiEHIAILIQEgACAENgI4IAAgATYCICAAIAs3AxggACAINwMQIAAgCjcDCCAAIAk3AwAgAEIAIAx9NwMoIAAgAiADQQN0ajYCJCAAIAdCACAGpxs3AzAgBUEwaiQAC6ACAQF/AkACQAJAAkACQAJAAkAgAC0AsAUOBwAGBgQDAQIGCyAAQZgBahD5JSAAQYAFahCHGiAAKQMAQgJRDQQgABCgKQwECwJAIAAtAPgFQQNHDQAgAC0A9AVBA0cNACAAQewFahC8KgsgAEHMBWoQ6SsgACgCuAVBgICAgHhHDQEgAEG4BWoQ9S4MAQsgAEG4BWoQ0S0LIAAtALMFBEAgAEGoA2oQ1AwLIABBADoAswULIABBqAFqEJ0vIAAtALIFBEAgAEGABWoQhxoLAkAgAC0AsQVFDQAgACkDAEICUQ0AIAAQoCkLIAAtALQFRQ0BCyAAKAKUBSIBQQhqEJMfIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQZQFahCWHwsLjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBtKzNAEEpIAJBHGpBmLPNAEHgrM0AENUeAAtBBEEcEKM9AAuXAgACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4QAQIDBAUGBwgJCgsMDQ4PEAALIABBAjYCAA8LIABBAzYCAA8LIABBBDYCAA8LIABBBTYCAA8LIABBBjYCACAAIAEpAgQ3AgQPCyAAQQc2AgAPCyAAQQg2AgAMCgsgAEEJNgIADAkLIABBCjYCAAwICyAAQQs2AgAPCyAAQQw2AgAPCyAAQQ02AgAPCyAAQQ42AgAPCyAAQQ82AgAPCyAAQRA2AgAgAEEAOgAEDwsgAEKRgICAgICAgIB/NwIADwsgAEGAgICAeDYCCCAAQQA2AgAPCyAAIAEtAAE6AAUgACABLQACOgAEC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQZSf0ABBKSACQRxqQdSi0ABBwJ/QABDVHgALQQRBHBCjPQAL/gECAn8CfiMAQTBrIgIkACACQRRqIgMQ7i8gASgCACEBAkACQCADEOkpDQADQCABKAIEIgMgASkDCCIEIAOtIgUgBCAFVBunIgNGBEAgAigCGA0CIABBJUHAo9AAQQsQzRoMAwsgASAEQgF8NwMIIAJBKGogAkEUaiABKAIAIANqLQAAENQmAkAgAi0AKEEERg0AIAIpAygiBEL/AYNCBFENACAAIAQ3AgAMAwsgAkEUahDpKUUNAAsLIAJBCGogAkEUahCBKCACKAIIQQFxBEAgAigCDCEBIABBBDoAACAAIAE2AgQMAQsgAEElQcCj0ABBCxDNGgsgAkEwaiQAC9QBAQZ/AkACQCACQQNrIgMgAE0EfyAABSABKAAAIgQgACgAACIFRw0CIABBBGohBSABQQRqIQhBACEEAkADQCAEIAVqIgYgA08NASAEIAhqIARBBGohBCgAACIHIAYoAAAiBkYNAAsgBiAHc2hBA3YgBGoPCyABIARqQQRqIQEgACAEakEEagsiAyACQQFrTw0AIAEvAAAgAy8AAEcNACABQQJqIQEgA0ECaiEDCyACIANLBH8gAyABLQAAIAMtAABGagUgAwsgAGsPCyAEIAVzaEEDdguAAgEDfwJAAkACQAJAAkACQAJAAkACQCABKAIAIgRBioCAgHhGDQAgASEDQQEgBEGAgICAeHMgBEEAThsOBwEHAgMEBQYACyAAIAFBJPwKAAAgAigCAEUNByACQQhqEIYwDwsgAUEEaiEDDAULIAFBBGohAwwECyABQQRqIQMMAwsgAUEEaiEDDAILIAFBBGohAwwBCyABQQRqIQMLIAMoAggiBCADKAIARgRAIANB4OH+ABCvKAsgAygCBCAEQRRsaiIFIAIpAgA3AgAgBUEQaiACQRBqKAIANgIAIAVBCGogAkEIaikCADcCACADIARBAWo2AgggACABQST8CgAACwuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0Hci/8AQSkgAkEcakHsj/8AQYiM/wAQ1R4AC0EEQRwQoz0AC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQaDjgAFBKSACQRxqQfTkgAFBzOOAARDVHgALQQRBHBCjPQALjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBvLKCAUEpIAJBHGpBmLOCAUHosoIBENUeAAtBBEEcEKM9AAuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0GwwIIBQSkgAkEcakHgyIIBQdzAggEQ1R4AC0EEQRwQoz0AC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQeCygwFBKSACQRxqQayzgwFBjLODARDVHgALQQRBHBCjPQALjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBlOeEAUEpIAJBHGpB8OiEAUHA54QBENUeAAtBBEEcEKM9AAuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0H09IQBQSkgAkEcakHQ9oQBQaD1hAEQ1R4AC0EEQRwQoz0AC4ACAQp/IwBB0ABrIgIkACACQcQAaiABENkGIAEoAgwiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgASgCFCEGIAEoAhAhByABKAIYIgMEQCADIAMoAgAiBEEBajYCACAEQQBIDQEgASgCKCEIIAEoAiQhCSABKAIgIQogASgCHCELIAEoAiwhBAsgAkEQaiACQcwAaigCADYCACACIAIpAkQ3AwggAiAENgI0IAIgCDYCMCACIAk2AiwgAiAKNgIoIAIgCzYCJCACIAM2AiAgAiAGNgIcIAIgBzYCGCACIAU2AhQgAiABKQIwNwM4IAAgAkEIahDkFSACQdAAaiQADwsAC4ICAQR/IAAoAggiAwRAIAAoAgQhAANAIABBBEEEEOAeIABByABqEMsMIABBOGoiASgCAARAIAEQzy8LIABBDGoQzy8gAEEcahDPLyAAQSxqIgEQihQgAUEEQcwBEOAeIABBgAFqIgEoAgBBgICAgHhHBEAgARClHgsgAEHcAGoiARDFJyABQQRBDBDgHiAAQegAaiIBEIEjIAFBBEEIEOAeIABB9ABqIgEQgSMgAUEEQQgQ4B4gAEHEAWooAgAhASAAQcgBaigCACIEKAIAIgIEQCABIAIRAwALIAQoAgQiAgRAIAEgAiAEKAIIEPg6CyAAQcwBaiEAIANBAWsiAw0ACwsLkAIBA38jAEEQayIDJAAgACAAKAIIIgJBASACGzYCCAJAAkACQAJAAkACQAJAIAIOAwAFAQULIAEoAgAhAiAAKAIAIgQNASABKAIEIQEMAgsgASgCBCABKAIAKAIIEQMADAMLIAEoAgQiASAAKAIERw0AIAIgBEYNAQsgA0EIaiABIAIoAgARAAAgAygCDCEBIAMoAgghAiAAKAIAIgQEQCAAKAIEIAQoAgwRAwALIAAgATYCBCAAIAI2AgALIABBACAAKAIIIgEgAUEBRiIBGzYCCCABDQAgACgCACEBIABBADYCACABRQ0BIAAoAgQgAEEANgIIIAEoAgQRAwALIANBEGokAA8LQbiriAEQsjsAC/8BAQd/IAEoAgAiCC8BBiECEKgvIgNBADsBBiADQQA2AgAgASADEIUcIQcgAy8BBiIGQQFqIQQCQCAGQQxJBEAgAiABKAIIIgJrIgUgBEcNASADQRRqIQQgBUECdCIFBEAgBCAIIAJBAnRqQRhqIAX8CgAACyAHQf8BcSEHIAEoAgQhAkEAIQEDQAJAIAQgAUECdGooAgAiBSABOwEEIAUgAzYCACABIAZPDQAgASABIAZJaiIBIAZNDQELCyAAIAc6ABAgACACNgIEIAAgCDYCACAAIAI2AgwgACADNgIIDwsgBEEMQYS4zQAQsDsAC0G8t80AQShB5LfNABCfKQALgwICA38BfiMAQTBrIgIkACACQQA6ABMgAkEUaiIDEO4vIAEoAgAhAQJAAkAgAxDpKQ0AA0AgASgCACIDIAJBE2ogAygCCCIDQQBHIgQQlxogASABKAIEIARqNgIEIANFBEAgAigCGA0CIABBJUHc880AQQsQzRoMAwsgAkEoaiACQRRqIAItABMQ1CYCQCACLQAoQQRGDQAgAikDKCIFQv8Bg0IEUQ0AIAAgBTcCAAwDCyACQRRqEOkpRQ0ACwsgAkEIaiACQRRqEIEoIAIoAghBAXEEQCACKAIMIQEgAEEEOgAAIAAgATYCBAwBCyAAQSVB3PPNAEELEM0aCyACQTBqJAALlkQCMX8CfiMAQcACayIKJAAgCkECOgAeIApBADYCFCAKQoCAgIAgNwIMIApBADsBHCAKIAE2AhggCkE4aiEEIwBB8AVrIgEkACABQbgCaiAKQQxqIgUQ8ScgAUGYAWoiGSABQcQCaiICKAIANgIAIAEgASkCvAI3A5ABAkAgASgCuAIiA0EERwRAIAEoAsgCIQIgBCABKQOQATcCDCAEIAI2AhggBCADNgIIIARCBDcDACAEQRRqIBkoAgA2AgAMAQsgAUEoaiIkIBkoAgA2AgAgASABKQOQATcDICABQSBqEIYwIAFBADYCCCABQgM3AyAgAUIDNwOQASABQbgCaiAFELMOIAFBuANqIAIpAgA3AwAgAUHAA2oiJSABQcwCaigCADYCACABIAEpArwCNwOwAwJAAkACQCABKAK4AkUEQCABQTxqISwgAUHUAmohKiABQcACaiEYIAFBxQJqISsgAUGsAWohLSABQbwCaiEmQQMhGgNAIAFBmAJqICUoAgAiAjYCACABQZACaiABQbgDaiIuKQMANwMAIAEgASkDsAM3A4gCAkACQAJAAkACQAJAIAJB/wFxBEAgAUG4AmogAUGIAmoQ/BcgAS8BvAIhAiABKAK4AiIDQQRHBEAgBCABKQG+AjcBDiAEQRRqIAFBxAJqKQEANwEAIAQgAjsBDCAEIAM2AgggBEIENwMADAsLAkACQAJAAkACQAJAAkACQAJAIAJBAWsOCAABAgMEBQYHCAsgAUG4AmogBRCIJiABKAK8AiEdIAEoArgCIgJBBEYNCSAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAdNgIMIAQgAjYCCCAEQgQ3AwAMEgsgAUG4AmogBRCIJiABKAK8AiEeIAEoArgCIgJBBEcEQCAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAeNgIMIAQgAjYCCCAEQgQ3AwAMEgtBASEgDA0LIAFBuAJqIAUQiCYgASgCvAIhHyABKAK4AiICQQRHBEAgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHzYCDCAEIAI2AgggBEIENwMADBELQQEhIQwMCyABQbgCaiAFEIgmIAEoArwCISIgASgCuAIiAkEERwRAIAQgASkCwAI3AhAgBEEYaiABQcgCaigCADYCACAEICI2AgwgBCACNgIIIARCBDcDAAwQC0EBISgMCwsgAUG4AmohA0EAIQhBACENQQAhEEEAIQxBACEHQQAhCUEAIQ5BACELIwBBwAJrIgIkACACQagBaiAFEPEnIAJBKGoiBiACQbQBaiITKAIANgIAIAIgAikCrAE3AyACQCACKAKoASIRQQRHBEAgAigCuAEhByADIAIpAyA3AgwgAyAHNgIYIAMgETYCCCADQgM3AwAgA0EUaiAGKAIANgIADAELIAJBiAJqIhEgBigCADYCACACIAIpAyA3A4ACIAJBgAJqEIYwIAJCAjcDICACQagBaiAFELMOIBEgEykCADcDACACQZACaiITIAJBvAFqKAIANgIAIAIgAikCrAE3A4ACAkACQCACKAKoAUUEQCACQTxqIRYgAkHEAWohFyACQbABaiERIAJBrAFqIRQDQCACQYgBaiATKAIAIg82AgAgAkGAAWogAkGIAmoiGykDADcDACACIAIpA4ACNwN4AkACQAJAAkACQAJAAkAgD0H/AXEEQCACQagBaiACQfgAahD8FyACLwGsASEPIAIoAqgBIhVBBEcEQCADIAIpAa4BNwEOIANBFGogAkG0AWopAQA3AQAgAyAPOwEMIAMgFTYCCCADQgM3AwAMCwsCQAJAAkACQAJAAkAgD0EBaw4FAAECAwQFCyACQagBaiAFEIgmIAIoAqwBIQcgAigCqAEiDEEERg0GIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAc2AgwgAyAMNgIIIANCAzcDAAwPCyACQagBaiAFEIgmIAIoAqwBIQkgAigCqAEiEEEERwRAIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAk2AgwgAyAQNgIIIANCAzcDAAwPC0EBIRAMCwsgAkGoAWogBRCIJiACKAKsASEOIAIoAqgBIg1BBEcEQCADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAONgIMIAMgDTYCCCADQgM3AwAMDgtBASENDAoLIAJBqAFqIAUQiCYgAigCrAEhCyACKAKoASIIQQRHBEAgAyACKQKwATcCECADQRhqIAJBuAFqKAIANgIAIAMgCzYCDCADIAg2AgggA0IDNwMADA0LQQEhCAwJCyACQagBaiAFEO0CIAJBmAFqIg8gEUEIaikDADcDACACQaABaiIVIBFBEGooAgA2AgAgAiARKQMANwOQASACKQOoASIzQgJRDQcgAkGAAmoiEiAXQTz8CgAAIAJBuAFqIicgFSgCADYCACACQbABaiIVIA8pAwA3AwAgAiACKQOQATcDqAEgAkEgahDxKyAGIAIpA6gBNwMAIAZBCGogFSkDADcDACAGQRBqICcoAgA2AgAgAiAzNwMgIBYgEkE8/AoAAAwICyACQagBaiAFIAItAIgBQcAAELQCIAIoAqgBIg9BBEYNByADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgDzYCCAwKCyACIAs2AhwgAiAINgIYIAIgDjYCFCACIA02AhAgAiAJNgIMIAIgEDYCCCACIAc2AgQgAiAMNgIAIAJB+ABqEIYwIAJBqAFqIAUQqikgAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQbyD0ABBGSACEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakHVg9AAQRcgAkEIahDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgAkGoAWpB7IPQAEEoIAJBEGoQ5h4gAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQZSE0ABBKCACQRhqEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyAMRQ0BIBBFDQIgDUUNAyAIRQ0EIAMgAkEgakHYAPwKAAAgAyALNgJkIAMgDjYCYCADIAk2AlwgAyAHNgJYDAsLQQEhDAwFC0H4/M8AQccAQbyE0AAQyyQAC0H4/M8AQccAQcyE0AAQyyQAC0H4/M8AQccAQdyE0AAQyyQAC0H4/M8AQccAQeyE0AAQyyQACyADIAIpA5ABNwMIIANCAzcDACADQRhqIAJBoAFqKAIANgIAIANBEGogAkGYAWopAwA3AwAMAwsgAkH4AGoQhjAgAkGoAWogBRCzDiAbIBRBCGopAgA3AwAgEyAUQRBqKAIANgIAIAIgFCkCADcDgAIgAigCqAFFDQALCyADIAIpA4ACNwIIIANCAzcDACADQRhqIBMoAgA2AgAgA0EQaiACQYgCaikDADcCAAwBCyACQfgAahCGMAsgAkEgahDxKwsgAkHAAmokACABQagCaiICIBhBCGopAwA3AwAgAUGwAmoiAyAYQRBqKAIANgIAIAEgGCkDADcDoAIgASkDuAIiM0IDUQ0NIAFBsANqICpBzAD8CgAAIAFByAJqIgcgAygCADYCACABQcACaiIDIAIpAwA3AwAgASABKQOgAjcDuAIgASkDIEIDUgRAIAFBIGoQ8SsLICQgASkDuAI3AwAgJEEIaiADKQMANwMAICRBEGogBygCADYCACABIDM3AyAgLCABQbADakHMAPwKAAAMCgsgAUG4AmohAyMAQdAAayICJAAgAkE4aiAFEPEnIAJBKGoiByACQcQAaiIJKAIANgIAIAIgAikCPDcDIAJAIAIoAjgiCEEERwRAIAIoAkghCSADIAIpAyA3AgQgAyAJNgIQIAMgCDYCACADQQxqIAcoAgA2AgAMAQsgAkEQaiAHKAIANgIAIAIgAikDIDcDCCACQQhqEIYwIAJBOGogBRCzDiAHIAkpAgA3AwAgAkEwaiIHIAJBzABqKAIANgIAIAIgAikCPDcDIAJAAkAgAigCOEUEQCACQTxqIQkDQCACQRhqIAcoAgAiCDYCACACQRBqIAJBKGoiDSkDADcDACACIAIpAyA3AwggCEH/AXFFDQMgAkE4aiIOIAUgCEHAABC0AiACKAI4IghBBEcNAiACQQhqEIYwIA4gBRCzDiANIAlBCGopAgA3AwAgByAJQRBqKAIANgIAIAIgCSkCADcDICACKAI4RQ0ACwsgAyACKQMgNwIAIANBEGogBygCADYCACADQQhqIAJBKGopAwA3AgAMAgsgAyACKQI8NwIEIANBDGogAkHEAGopAgA3AgAgAyAINgIAIAJBCGoQhjAMAQsgAkEIahCGMCACQThqIAUQqikgAigCOCIHQQRHBEAgAyACKQI8NwIEIANBDGogAkHEAGopAgA3AgAgAyAHNgIADAELIANBBDYCAAsgAkHQAGokACABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMDgtBASEpDAkLIAFBuAJqIQNBACEJQQAhDkEAIQcjAEHgAGsiAiQAIAJByABqIAUQ8ScgAkE4aiIIIAJB1ABqIg0oAgA2AgAgAiACKQJMNwMwAkAgAigCSCILQQRHBEAgAigCWCEHIAMgAikDMDcCBCADIAc2AhAgAyALNgIAIANBDGogCCgCADYCAAwBCyACQSBqIAgoAgA2AgAgAiACKQMwNwMYIAJBGGoQhjAgAkHIAGogBRCzDiAIIA0pAgA3AwAgAkFAayILIAJB3ABqKAIANgIAIAIgAikCTDcDMAJAIAIoAkhFBEAgAkHMAGohEEEAIQhBAiENA0AgAkEoaiALKAIAIgw2AgAgAkEgaiACQThqIgYpAwA3AwAgAiACKQMwNwMYAkACQAJAAkAgDEH/AXEEQCACQcgAaiACQRhqEPwXIAIvAUwhDCACKAJIIhpBBEcEQCADIAIpAU43AQYgA0EMaiACQdQAaikBADcBACADIAw7AQQgAyAaNgIADAgLAkACQAJAAkAgDEEBaw4DAAECAwsgAkHIAGogBRCIJiACKAJMIQ4gAigCSCIJQQRGDQQgAyACKQJQNwIIIANBEGogAkHYAGooAgA2AgAgAyAONgIEIAMgCTYCAAwKCyACQcgAaiAFEIgmIAIoAkwhByACKAJIIghBBEcEQCADIAIpAlA3AgggA0EQaiACQdgAaigCADYCACADIAc2AgQgAyAINgIADAoLQQEhCAwGCyACQcgAaiAFEOwTIAItAEwhDSACKAJIIgxBBEYNBSADIAIpAE03AAUgA0EMaiACQdQAaikAADcAACADIA06AAQgAyAMNgIADAgLIAJByABqIAUgAi0AKEHAABC0AiACKAJIIgxBBEYNBCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAw2AgAMBwsgAiAHNgIUIAIgCDYCECACIA42AgwgAiAJNgIIIAJBGGoQhjAgAkHIAGogBRCqKSACKAJIIgtBBEcEQCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAs2AgAMCAsgAkHIAGpB54XQAEEfIAJBCGoQ5h4gAigCSCILQQRHBEAgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyALNgIADAgLIAJByABqQYaG0ABBHSACQRBqEOYeIAIoAkgiC0EERwRAIAMgAikCTDcCBCADQQxqIAJB1ABqKQIANwIAIAMgCzYCAAwICyAJRQ0BIAhFDQIgAyANOgAMIAMgBzYCCCADIA42AgQgA0EENgIADAcLQQEhCQwCC0H4/M8AQccAQaSG0AAQyyQAC0H4/M8AQccAQbSG0AAQyyQACyACQRhqEIYwIAJByABqIAUQsw4gBiAQQQhqKQIANwMAIAsgEEEQaigCADYCACACIBApAgA3AzAgAigCSEUNAAsLIAMgAikDMDcCACADQRBqIAsoAgA2AgAgA0EIaiACQThqKQMANwIADAELIAJBGGoQhjALIAJB4ABqJAAgAUGyA2oiAiArQQJqLQAAOgAAIAEgKy8AADsBsAMgAS0AxAIhGiABKQK8AiE0IAEoArgCIgNBBEcEQCABKALIAiEFIAQgAS8BsAM7ABUgBCAFNgIYIAQgGjoAFCAEIDQ3AgwgBCADNgIIIARCBDcDACAEQRdqIAItAAA6AAAMDQsgAUGOAWogAi0AADoAACABIAEvAbADOwGMAQwICyABQbgCaiEDQQAhEEEAIQxBACETQQAhEUEAIRRBACEHQQAhCUEAIQ5BACELQQAhCEEAIQ0jAEHQAmsiAiQAIAJBuAFqIAUQ8ScgAkE4aiIGIAJBxAFqIhYoAgA2AgAgAiACKQK8ATcDMAJAIAIoArgBIg9BBEcEQCACKALIASEHIAMgAikDMDcCDCADIAc2AhggAyAPNgIIIANCAzcDACADQRRqIAYoAgA2AgAMAQsgAkGYAmoiFyAGKAIANgIAIAIgAikDMDcDkAIgAkGQAmoQhjBBACEPIAJBADYCACACQQA2AgggAkEANgIQIAJCAjcDMCACQbgBaiAFELMOIBcgFikCADcDACACQaACaiIWIAJBzAFqKAIANgIAIAIgAikCvAE3A5ACAkACQCACKAK4AUUEQCACQcwAaiEnIAJB1AFqIS8gAkHAAWohFyACQbwBaiEbQQIhFQNAIAJBmAFqIBYoAgAiEjYCACACQZABaiACQZgCaiIwKQMANwMAIAIgAikDkAI3A4gBAkACQAJAAkACQAJAAkACQAJAIBJB/wFxBEAgAkG4AWogAkGIAWoQ/BcgAi8BvAEhEiACKAK4ASIcQQRHBEAgAyACKQG+ATcBDiADQRRqIAJBxAFqKQEANwEAIAMgEjsBDCADIBw2AgggA0IDNwMADA0LAkACQAJAAkACQAJAAkACQAJAIBJBAWsOCAABAgMEBQYHCAsgAkG4AWogBRCIJiACKAK8ASEHIAIoArgBIhRBBEYNCSADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAHNgIMIAMgFDYCCCADQgM3AwAMFAsgAkG4AWogBRCIJiACKAK8ASEJIAIoArgBIhFBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAJNgIMIAMgETYCCCADQgM3AwAMFAtBASERDBALIAJBuAFqIAUQiCYgAigCvAEhDiACKAK4ASITQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgDjYCDCADIBM2AgggA0IDNwMADBMLQQEhEwwPCyACQbgBaiAFEIgmIAIoArwBIQsgAigCuAEiDEEERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIAs2AgwgAyAMNgIIIANCAzcDAAwSC0EBIQwMDgsgAkG4AWogBRCIJiACKAK8ASEIIAIoArgBIhBBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAINgIMIAMgEDYCCCADQgM3AwAMEQtBASEQDA0LIAJBuAFqIAUQiCYgAigCvAEhDSACKAK4ASIPQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgDTYCDCADIA82AgggA0IDNwMADBALQQEhDwwMCyACQbgBaiAFEOwTIAItALwBIRUgAigCuAEiEkEERg0LIAMgAikAvQE3AA0gA0EUaiACQcQBaikAADcAACADIBU6AAwgAyASNgIIIANCAzcDAAwOCyACQbgBaiAFEO0CIAJBqAFqIhIgF0EIaikDADcDACACQbABaiIcIBdBEGooAgA2AgAgAiAXKQMANwOgASACKQO4ASIzQgJRDQkgAkGQAmoiMSAvQTz8CgAAIAJByAFqIjIgHCgCADYCACACQcABaiIcIBIpAwA3AwAgAiACKQOgATcDuAEgAkEwahDxKyAGIAIpA7gBNwMAIAZBCGogHCkDADcDACAGQRBqIDIoAgA2AgAgAiAzNwMwICcgMUE8/AoAAAwKCyACQbgBaiAFIAItAJgBQcAAELQCIAIoArgBIhJBBEYNCSADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgEjYCCAwMCyACIA02AiwgAiAPNgIoIAIgCDYCJCACIBA2AiAgAiALNgIcIAIgDDYCGCACIA42AhQgAiATNgIQIAIgCTYCDCACIBE2AgggAiAHNgIEIAIgFDYCACACQYgBahCGMCACQbgBaiAFEKopIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakHhhtAAQRsgAhDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpB/IbQAEEaIAJBCGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQZaH0ABBGSACQRBqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakGvh9AAQRkgAkEYahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpByIfQAEEuIAJBIGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQfaH0ABBLiACQShqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyAURQ0BIBFFDQIgE0UNAyAMRQ0EIBBFDQUgD0UNBiADIAJBMGpB2AD8CgAAIAMgFToAcCADIA02AmwgAyAINgJoIAMgCzYCZCADIA42AmAgAyAJNgJcIAMgBzYCWAwNC0EBIRQMBwtB+PzPAEHHAEGkiNAAEMskAAtB+PzPAEHHAEG0iNAAEMskAAtB+PzPAEHHAEHEiNAAEMskAAtB+PzPAEHHAEHUiNAAEMskAAtB+PzPAEHHAEHkiNAAEMskAAtB+PzPAEHHAEH0iNAAEMskAAsgAyACKQOgATcDCCADQgM3AwAgA0EYaiACQbABaigCADYCACADQRBqIAJBqAFqKQMANwMADAMLIAJBiAFqEIYwIAJBuAFqIAUQsw4gMCAbQQhqKQIANwMAIBYgG0EQaigCADYCACACIBspAgA3A5ACIAIoArgBRQ0ACwsgAyACKQOQAjcCCCADQgM3AwAgA0EYaiAWKAIANgIAIANBEGogAkGYAmopAwA3AgAMAQsgAkGIAWoQhjALIAJBMGoQ8SsLIAJB0AJqJAAgAUGoAmoiAiAYQQhqKQMANwMAIAFBsAJqIgMgGEEQaigCADYCACABIBgpAwA3A6ACIAEpA7gCIjNCA1ENBiABQbADaiAqQdwA/AoAACABQcgCaiIHIAMoAgA2AgAgAUHAAmoiAyACKQMANwMAIAEgASkDoAI3A7gCIAEpA5ABQgNSBEAgAUGQAWoQ8SsLIBkgASkDuAI3AwAgGUEIaiADKQMANwMAIBlBEGogBygCADYCACABIDM3A5ABIC0gAUGwA2pB3AD8CgAADAcLIAFBuAJqIAUgAS0AmAJBwAAQtAIgASgCuAIiAkEERg0GIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAoLIAEgHzYCHCABICE2AhggASAeNgIUIAEgIDYCECABIB02AgwgASAjNgIIIAFBiAJqEIYwIAFBuAJqIAUQqikgASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLIAFBuAJqQeyJ0ABBECABQQhqEOYeIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyABQbgCakH8idAAQSEgAUEQahDmHiABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMCwsgAUG4AmpBnYrQAEEfIAFBGGoQ5h4gASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLICNFDQEgIEUNAiAhRQ0DIAFBkARqIgIgAUEgakHoAPwKAAAgBEHzAWogAUGOAWotAAA6AAAgBCABLwGMATsA8QEgAUH4BGogAUGQAWpB+AD8CgAAIAQgAkHgAfwKAAAgBCApOgCAAiAEIB82AvwBIAQgHjYC+AEgBCAdNgL0ASAEIBo6APABIAQgNDcD6AEgBCAiNgLkASAEICg2AuABDAsLQQEhIwwEC0H4/M8AQccAQbyK0AAQyyQAC0H4/M8AQccAQcyK0AAQyyQAC0H4/M8AQccAQdyK0AAQyyQACyAEIAEpA6ACNwMIIARCBDcDACAEQRhqIAFBsAJqKAIANgIAIARBEGogAUGoAmopAwA3AwAMBAsgAUGIAmoQhjAgAUG4AmogBRCzDiAuICZBCGopAgA3AwAgJSAmQRBqKAIANgIAIAEgJikCADcDsAMgASgCuAJFDQALCyAEIAEpA7ADNwIIIARCBDcDACAEQRhqICUoAgA2AgAgBEEQaiABQbgDaikDADcCAAwCCyAEIAEpA6ACNwMIIARCBDcDACAEQRhqIAFBsAJqKAIANgIAIARBEGogAUGoAmopAwA3AwALIAFBiAJqEIYwCyABKQOQAUIDUgRAIAFBkAFqEPErCyABKQMgQgNRDQAgAUEgahDxKwsgAUHwBWokACAKQShqIApByABqKQMANwMAIApBMGogCkHQAGooAgA2AgAgCiAKKQNANwMgAkAgCikDOCI0QgRRBEAgAEEIaiAKQSBqEKUlDAELIABBHGogCkHUAGpB7AH8CgAAIABBGGogCkEwaigCADYCACAAQRBqIApBKGopAwA3AwAgACAKKQMgNwMICyAKQQxqEJ08IAAgNDcDACAKQcACaiQAC5ZEAjF/An4jAEHAAmsiCiQAIApBAjoAHiAKQQA2AhQgCkKAgICAIDcCDCAKQQA7ARwgCiABNgIYIApBOGohBCMAQfAFayIBJAAgAUG4AmogCkEMaiIFEPEnIAFBmAFqIhkgAUHEAmoiAigCADYCACABIAEpArwCNwOQAQJAIAEoArgCIgNBBEcEQCABKALIAiECIAQgASkDkAE3AgwgBCACNgIYIAQgAzYCCCAEQgQ3AwAgBEEUaiAZKAIANgIADAELIAFBKGoiJCAZKAIANgIAIAEgASkDkAE3AyAgAUEgahCGMCABQQA2AgggAUIDNwMgIAFCAzcDkAEgAUG4AmogBRCyDiABQbgDaiACKQIANwMAIAFBwANqIiUgAUHMAmooAgA2AgAgASABKQK8AjcDsAMCQAJAAkAgASgCuAJFBEAgAUE8aiEsIAFB1AJqISogAUHAAmohGCABQcUCaiErIAFBrAFqIS0gAUG8AmohJkEDIRoDQCABQZgCaiAlKAIAIgI2AgAgAUGQAmogAUG4A2oiLikDADcDACABIAEpA7ADNwOIAgJAAkACQAJAAkACQCACQf8BcQRAIAFBuAJqIAFBiAJqEPwXIAEvAbwCIQIgASgCuAIiA0EERwRAIAQgASkBvgI3AQ4gBEEUaiABQcQCaikBADcBACAEIAI7AQwgBCADNgIIIARCBDcDAAwLCwJAAkACQAJAAkACQAJAAkACQCACQQFrDggAAQIDBAUGBwgLIAFBuAJqIAUQiSYgASgCvAIhHSABKAK4AiICQQRGDQkgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHTYCDCAEIAI2AgggBEIENwMADBILIAFBuAJqIAUQiSYgASgCvAIhHiABKAK4AiICQQRHBEAgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHjYCDCAEIAI2AgggBEIENwMADBILQQEhIAwNCyABQbgCaiAFEIkmIAEoArwCIR8gASgCuAIiAkEERwRAIAQgASkCwAI3AhAgBEEYaiABQcgCaigCADYCACAEIB82AgwgBCACNgIIIARCBDcDAAwRC0EBISEMDAsgAUG4AmogBRCJJiABKAK8AiEiIAEoArgCIgJBBEcEQCAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAiNgIMIAQgAjYCCCAEQgQ3AwAMEAtBASEoDAsLIAFBuAJqIQNBACEIQQAhDUEAIRBBACEMQQAhB0EAIQlBACEOQQAhCyMAQcACayICJAAgAkGoAWogBRDxJyACQShqIgYgAkG0AWoiEygCADYCACACIAIpAqwBNwMgAkAgAigCqAEiEUEERwRAIAIoArgBIQcgAyACKQMgNwIMIAMgBzYCGCADIBE2AgggA0IDNwMAIANBFGogBigCADYCAAwBCyACQYgCaiIRIAYoAgA2AgAgAiACKQMgNwOAAiACQYACahCGMCACQgI3AyAgAkGoAWogBRCyDiARIBMpAgA3AwAgAkGQAmoiEyACQbwBaigCADYCACACIAIpAqwBNwOAAgJAAkAgAigCqAFFBEAgAkE8aiEWIAJBxAFqIRcgAkGwAWohESACQawBaiEUA0AgAkGIAWogEygCACIPNgIAIAJBgAFqIAJBiAJqIhspAwA3AwAgAiACKQOAAjcDeAJAAkACQAJAAkACQAJAIA9B/wFxBEAgAkGoAWogAkH4AGoQ/BcgAi8BrAEhDyACKAKoASIVQQRHBEAgAyACKQGuATcBDiADQRRqIAJBtAFqKQEANwEAIAMgDzsBDCADIBU2AgggA0IDNwMADAsLAkACQAJAAkACQAJAIA9BAWsOBQABAgMEBQsgAkGoAWogBRCJJiACKAKsASEHIAIoAqgBIgxBBEYNBiADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAHNgIMIAMgDDYCCCADQgM3AwAMDwsgAkGoAWogBRCJJiACKAKsASEJIAIoAqgBIhBBBEcEQCADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAJNgIMIAMgEDYCCCADQgM3AwAMDwtBASEQDAsLIAJBqAFqIAUQiSYgAigCrAEhDiACKAKoASINQQRHBEAgAyACKQKwATcCECADQRhqIAJBuAFqKAIANgIAIAMgDjYCDCADIA02AgggA0IDNwMADA4LQQEhDQwKCyACQagBaiAFEIkmIAIoAqwBIQsgAigCqAEiCEEERwRAIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAs2AgwgAyAINgIIIANCAzcDAAwNC0EBIQgMCQsgAkGoAWogBRDuAiACQZgBaiIPIBFBCGopAwA3AwAgAkGgAWoiFSARQRBqKAIANgIAIAIgESkDADcDkAEgAikDqAEiM0ICUQ0HIAJBgAJqIhIgF0E8/AoAACACQbgBaiInIBUoAgA2AgAgAkGwAWoiFSAPKQMANwMAIAIgAikDkAE3A6gBIAJBIGoQ8SsgBiACKQOoATcDACAGQQhqIBUpAwA3AwAgBkEQaiAnKAIANgIAIAIgMzcDICAWIBJBPPwKAAAMCAsgAkGoAWogBSACLQCIAUHAABCzAiACKAKoASIPQQRGDQcgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIA82AggMCgsgAiALNgIcIAIgCDYCGCACIA42AhQgAiANNgIQIAIgCTYCDCACIBA2AgggAiAHNgIEIAIgDDYCACACQfgAahCGMCACQagBaiAFEKopIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakG8g9AAQRkgAhDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgAkGoAWpB1YPQAEEXIAJBCGoQ5h4gAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQeyD0ABBKCACQRBqEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakGUhNAAQSggAkEYahDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgDEUNASAQRQ0CIA1FDQMgCEUNBCADIAJBIGpB2AD8CgAAIAMgCzYCZCADIA42AmAgAyAJNgJcIAMgBzYCWAwLC0EBIQwMBQtB+PzPAEHHAEG8hNAAEMskAAtB+PzPAEHHAEHMhNAAEMskAAtB+PzPAEHHAEHchNAAEMskAAtB+PzPAEHHAEHshNAAEMskAAsgAyACKQOQATcDCCADQgM3AwAgA0EYaiACQaABaigCADYCACADQRBqIAJBmAFqKQMANwMADAMLIAJB+ABqEIYwIAJBqAFqIAUQsg4gGyAUQQhqKQIANwMAIBMgFEEQaigCADYCACACIBQpAgA3A4ACIAIoAqgBRQ0ACwsgAyACKQOAAjcCCCADQgM3AwAgA0EYaiATKAIANgIAIANBEGogAkGIAmopAwA3AgAMAQsgAkH4AGoQhjALIAJBIGoQ8SsLIAJBwAJqJAAgAUGoAmoiAiAYQQhqKQMANwMAIAFBsAJqIgMgGEEQaigCADYCACABIBgpAwA3A6ACIAEpA7gCIjNCA1ENDSABQbADaiAqQcwA/AoAACABQcgCaiIHIAMoAgA2AgAgAUHAAmoiAyACKQMANwMAIAEgASkDoAI3A7gCIAEpAyBCA1IEQCABQSBqEPErCyAkIAEpA7gCNwMAICRBCGogAykDADcDACAkQRBqIAcoAgA2AgAgASAzNwMgICwgAUGwA2pBzAD8CgAADAoLIAFBuAJqIQMjAEHQAGsiAiQAIAJBOGogBRDxJyACQShqIgcgAkHEAGoiCSgCADYCACACIAIpAjw3AyACQCACKAI4IghBBEcEQCACKAJIIQkgAyACKQMgNwIEIAMgCTYCECADIAg2AgAgA0EMaiAHKAIANgIADAELIAJBEGogBygCADYCACACIAIpAyA3AwggAkEIahCGMCACQThqIAUQsg4gByAJKQIANwMAIAJBMGoiByACQcwAaigCADYCACACIAIpAjw3AyACQAJAIAIoAjhFBEAgAkE8aiEJA0AgAkEYaiAHKAIAIgg2AgAgAkEQaiACQShqIg0pAwA3AwAgAiACKQMgNwMIIAhB/wFxRQ0DIAJBOGoiDiAFIAhBwAAQswIgAigCOCIIQQRHDQIgAkEIahCGMCAOIAUQsg4gDSAJQQhqKQIANwMAIAcgCUEQaigCADYCACACIAkpAgA3AyAgAigCOEUNAAsLIAMgAikDIDcCACADQRBqIAcoAgA2AgAgA0EIaiACQShqKQMANwIADAILIAMgAikCPDcCBCADQQxqIAJBxABqKQIANwIAIAMgCDYCACACQQhqEIYwDAELIAJBCGoQhjAgAkE4aiAFEKopIAIoAjgiB0EERwRAIAMgAikCPDcCBCADQQxqIAJBxABqKQIANwIAIAMgBzYCAAwBCyADQQQ2AgALIAJB0ABqJAAgASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDA4LQQEhKQwJCyABQbgCaiEDQQAhCUEAIQ5BACEHIwBB4ABrIgIkACACQcgAaiAFEPEnIAJBOGoiCCACQdQAaiINKAIANgIAIAIgAikCTDcDMAJAIAIoAkgiC0EERwRAIAIoAlghByADIAIpAzA3AgQgAyAHNgIQIAMgCzYCACADQQxqIAgoAgA2AgAMAQsgAkEgaiAIKAIANgIAIAIgAikDMDcDGCACQRhqEIYwIAJByABqIAUQsg4gCCANKQIANwMAIAJBQGsiCyACQdwAaigCADYCACACIAIpAkw3AzACQCACKAJIRQRAIAJBzABqIRBBACEIQQIhDQNAIAJBKGogCygCACIMNgIAIAJBIGogAkE4aiIGKQMANwMAIAIgAikDMDcDGAJAAkACQAJAIAxB/wFxBEAgAkHIAGogAkEYahD8FyACLwFMIQwgAigCSCIaQQRHBEAgAyACKQFONwEGIANBDGogAkHUAGopAQA3AQAgAyAMOwEEIAMgGjYCAAwICwJAAkACQAJAIAxBAWsOAwABAgMLIAJByABqIAUQiSYgAigCTCEOIAIoAkgiCUEERg0EIAMgAikCUDcCCCADQRBqIAJB2ABqKAIANgIAIAMgDjYCBCADIAk2AgAMCgsgAkHIAGogBRCJJiACKAJMIQcgAigCSCIIQQRHBEAgAyACKQJQNwIIIANBEGogAkHYAGooAgA2AgAgAyAHNgIEIAMgCDYCAAwKC0EBIQgMBgsgAkHIAGogBRDrEyACLQBMIQ0gAigCSCIMQQRGDQUgAyACKQBNNwAFIANBDGogAkHUAGopAAA3AAAgAyANOgAEIAMgDDYCAAwICyACQcgAaiAFIAItAChBwAAQswIgAigCSCIMQQRGDQQgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyAMNgIADAcLIAIgBzYCFCACIAg2AhAgAiAONgIMIAIgCTYCCCACQRhqEIYwIAJByABqIAUQqikgAigCSCILQQRHBEAgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyALNgIADAgLIAJByABqQeeF0ABBHyACQQhqEOYeIAIoAkgiC0EERwRAIAMgAikCTDcCBCADQQxqIAJB1ABqKQIANwIAIAMgCzYCAAwICyACQcgAakGGhtAAQR0gAkEQahDmHiACKAJIIgtBBEcEQCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAs2AgAMCAsgCUUNASAIRQ0CIAMgDToADCADIAc2AgggAyAONgIEIANBBDYCAAwHC0EBIQkMAgtB+PzPAEHHAEGkhtAAEMskAAtB+PzPAEHHAEG0htAAEMskAAsgAkEYahCGMCACQcgAaiAFELIOIAYgEEEIaikCADcDACALIBBBEGooAgA2AgAgAiAQKQIANwMwIAIoAkhFDQALCyADIAIpAzA3AgAgA0EQaiALKAIANgIAIANBCGogAkE4aikDADcCAAwBCyACQRhqEIYwCyACQeAAaiQAIAFBsgNqIgIgK0ECai0AADoAACABICsvAAA7AbADIAEtAMQCIRogASkCvAIhNCABKAK4AiIDQQRHBEAgASgCyAIhBSAEIAEvAbADOwAVIAQgBTYCGCAEIBo6ABQgBCA0NwIMIAQgAzYCCCAEQgQ3AwAgBEEXaiACLQAAOgAADA0LIAFBjgFqIAItAAA6AAAgASABLwGwAzsBjAEMCAsgAUG4AmohA0EAIRBBACEMQQAhE0EAIRFBACEUQQAhB0EAIQlBACEOQQAhC0EAIQhBACENIwBB0AJrIgIkACACQbgBaiAFEPEnIAJBOGoiBiACQcQBaiIWKAIANgIAIAIgAikCvAE3AzACQCACKAK4ASIPQQRHBEAgAigCyAEhByADIAIpAzA3AgwgAyAHNgIYIAMgDzYCCCADQgM3AwAgA0EUaiAGKAIANgIADAELIAJBmAJqIhcgBigCADYCACACIAIpAzA3A5ACIAJBkAJqEIYwQQAhDyACQQA2AgAgAkEANgIIIAJBADYCECACQgI3AzAgAkG4AWogBRCyDiAXIBYpAgA3AwAgAkGgAmoiFiACQcwBaigCADYCACACIAIpArwBNwOQAgJAAkAgAigCuAFFBEAgAkHMAGohJyACQdQBaiEvIAJBwAFqIRcgAkG8AWohG0ECIRUDQCACQZgBaiAWKAIAIhI2AgAgAkGQAWogAkGYAmoiMCkDADcDACACIAIpA5ACNwOIAQJAAkACQAJAAkACQAJAAkACQCASQf8BcQRAIAJBuAFqIAJBiAFqEPwXIAIvAbwBIRIgAigCuAEiHEEERwRAIAMgAikBvgE3AQ4gA0EUaiACQcQBaikBADcBACADIBI7AQwgAyAcNgIIIANCAzcDAAwNCwJAAkACQAJAAkACQAJAAkACQCASQQFrDggAAQIDBAUGBwgLIAJBuAFqIAUQiSYgAigCvAEhByACKAK4ASIUQQRGDQkgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgBzYCDCADIBQ2AgggA0IDNwMADBQLIAJBuAFqIAUQiSYgAigCvAEhCSACKAK4ASIRQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgCTYCDCADIBE2AgggA0IDNwMADBQLQQEhEQwQCyACQbgBaiAFEIkmIAIoArwBIQ4gAigCuAEiE0EERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIA42AgwgAyATNgIIIANCAzcDAAwTC0EBIRMMDwsgAkG4AWogBRCJJiACKAK8ASELIAIoArgBIgxBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyALNgIMIAMgDDYCCCADQgM3AwAMEgtBASEMDA4LIAJBuAFqIAUQiSYgAigCvAEhCCACKAK4ASIQQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgCDYCDCADIBA2AgggA0IDNwMADBELQQEhEAwNCyACQbgBaiAFEIkmIAIoArwBIQ0gAigCuAEiD0EERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIA02AgwgAyAPNgIIIANCAzcDAAwQC0EBIQ8MDAsgAkG4AWogBRDrEyACLQC8ASEVIAIoArgBIhJBBEYNCyADIAIpAL0BNwANIANBFGogAkHEAWopAAA3AAAgAyAVOgAMIAMgEjYCCCADQgM3AwAMDgsgAkG4AWogBRDuAiACQagBaiISIBdBCGopAwA3AwAgAkGwAWoiHCAXQRBqKAIANgIAIAIgFykDADcDoAEgAikDuAEiM0ICUQ0JIAJBkAJqIjEgL0E8/AoAACACQcgBaiIyIBwoAgA2AgAgAkHAAWoiHCASKQMANwMAIAIgAikDoAE3A7gBIAJBMGoQ8SsgBiACKQO4ATcDACAGQQhqIBwpAwA3AwAgBkEQaiAyKAIANgIAIAIgMzcDMCAnIDFBPPwKAAAMCgsgAkG4AWogBSACLQCYAUHAABCzAiACKAK4ASISQQRGDQkgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIBI2AggMDAsgAiANNgIsIAIgDzYCKCACIAg2AiQgAiAQNgIgIAIgCzYCHCACIAw2AhggAiAONgIUIAIgEzYCECACIAk2AgwgAiARNgIIIAIgBzYCBCACIBQ2AgAgAkGIAWoQhjAgAkG4AWogBRCqKSACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpB4YbQAEEbIAIQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQfyG0ABBGiACQQhqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakGWh9AAQRkgAkEQahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpBr4fQAEEZIAJBGGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQciH0ABBLiACQSBqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakH2h9AAQS4gAkEoahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgFEUNASARRQ0CIBNFDQMgDEUNBCAQRQ0FIA9FDQYgAyACQTBqQdgA/AoAACADIBU6AHAgAyANNgJsIAMgCDYCaCADIAs2AmQgAyAONgJgIAMgCTYCXCADIAc2AlgMDQtBASEUDAcLQfj8zwBBxwBBpIjQABDLJAALQfj8zwBBxwBBtIjQABDLJAALQfj8zwBBxwBBxIjQABDLJAALQfj8zwBBxwBB1IjQABDLJAALQfj8zwBBxwBB5IjQABDLJAALQfj8zwBBxwBB9IjQABDLJAALIAMgAikDoAE3AwggA0IDNwMAIANBGGogAkGwAWooAgA2AgAgA0EQaiACQagBaikDADcDAAwDCyACQYgBahCGMCACQbgBaiAFELIOIDAgG0EIaikCADcDACAWIBtBEGooAgA2AgAgAiAbKQIANwOQAiACKAK4AUUNAAsLIAMgAikDkAI3AgggA0IDNwMAIANBGGogFigCADYCACADQRBqIAJBmAJqKQMANwIADAELIAJBiAFqEIYwCyACQTBqEPErCyACQdACaiQAIAFBqAJqIgIgGEEIaikDADcDACABQbACaiIDIBhBEGooAgA2AgAgASAYKQMANwOgAiABKQO4AiIzQgNRDQYgAUGwA2ogKkHcAPwKAAAgAUHIAmoiByADKAIANgIAIAFBwAJqIgMgAikDADcDACABIAEpA6ACNwO4AiABKQOQAUIDUgRAIAFBkAFqEPErCyAZIAEpA7gCNwMAIBlBCGogAykDADcDACAZQRBqIAcoAgA2AgAgASAzNwOQASAtIAFBsANqQdwA/AoAAAwHCyABQbgCaiAFIAEtAJgCQcAAELMCIAEoArgCIgJBBEYNBiAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwKCyABIB82AhwgASAhNgIYIAEgHjYCFCABICA2AhAgASAdNgIMIAEgIzYCCCABQYgCahCGMCABQbgCaiAFEKopIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyABQbgCakHsidAAQRAgAUEIahDmHiABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMCwsgAUG4AmpB/InQAEEhIAFBEGoQ5h4gASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLIAFBuAJqQZ2K0ABBHyABQRhqEOYeIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyAjRQ0BICBFDQIgIUUNAyABQZAEaiICIAFBIGpB6AD8CgAAIARB8wFqIAFBjgFqLQAAOgAAIAQgAS8BjAE7APEBIAFB+ARqIAFBkAFqQfgA/AoAACAEIAJB4AH8CgAAIAQgKToAgAIgBCAfNgL8ASAEIB42AvgBIAQgHTYC9AEgBCAaOgDwASAEIDQ3A+gBIAQgIjYC5AEgBCAoNgLgAQwLC0EBISMMBAtB+PzPAEHHAEG8itAAEMskAAtB+PzPAEHHAEHMitAAEMskAAtB+PzPAEHHAEHcitAAEMskAAsgBCABKQOgAjcDCCAEQgQ3AwAgBEEYaiABQbACaigCADYCACAEQRBqIAFBqAJqKQMANwMADAQLIAFBiAJqEIYwIAFBuAJqIAUQsg4gLiAmQQhqKQIANwMAICUgJkEQaigCADYCACABICYpAgA3A7ADIAEoArgCRQ0ACwsgBCABKQOwAzcCCCAEQgQ3AwAgBEEYaiAlKAIANgIAIARBEGogAUG4A2opAwA3AgAMAgsgBCABKQOgAjcDCCAEQgQ3AwAgBEEYaiABQbACaigCADYCACAEQRBqIAFBqAJqKQMANwMACyABQYgCahCGMAsgASkDkAFCA1IEQCABQZABahDxKwsgASkDIEIDUQ0AIAFBIGoQ8SsLIAFB8AVqJAAgCkEoaiAKQcgAaikDADcDACAKQTBqIApB0ABqKAIANgIAIAogCikDQDcDIAJAIAopAzgiNEIEUQRAIABBCGogCkEgahClJQwBCyAAQRxqIApB1ABqQewB/AoAACAAQRhqIApBMGooAgA2AgAgAEEQaiAKQShqKQMANwMAIAAgCikDIDcDCAsgCkEMahCdPCAAIDQ3AwAgCkHAAmokAAvmAQEFfyMAQSBrIgMkAAJAAkAgASgCTCIFIAIgAiAFSxsiBkUNAANAIAECfyABKAJEIgcgASgCSCICRwRAIAEgAiAHIAJrIgIgBiAEayIHIAIgB0kbIgJqNgJIIAUgAmsMAQsgA0EIaiABIAYgBGsQ3Q4gAygCDCECIAMoAggiBUEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwAgACACNgIEIAAgBTYCAAwECyACRQ0CIAEoAkwgAmsLIgU2AkwgAiAEaiIEIAZJDQALCyAAQQg2AgAgACAENgIECyADQSBqJAAL3wQBDH8jAEEwayIDJAAgASgCACECAkAgACgCAEGAgICAeEcEQCACQYCAgIB4Rg0BIABBCGoiCigCACECIAAoAgQhBCABKAIIIQUgASgCBCEBIANBADYCKCADIAEgBWo2AiQgAyABNgIgIAMgAiAEajYCHCADIAQ2AhggAyAFIAIgAiAFSxs2AiwjAEEgayICJAAgAkEUaiADQRhqIgEoAhQgASgCEGtBAEEBQQEQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBwKXOABD9LwALIANBDGohCSACQRBqIgtBADYCACACIAIoAhw2AgwgAiAFNgIIIwBBEGsiBSQAIAEoAhQgASgCEGsiBiACQQhqIgQoAgAgBCgCCCIHa0sEQCAEIAcgBkEBQQEQ0CggBCgCCCEHCyAFIAQoAgQ2AgwgBSAHNgIIIAUgBEEIajYCBCAFQQRqIgYoAgQhBCAGKAIAIAEoAhQiCCABKAIQIgdHBEAgCCAHayEIIAYoAgghDSABKAIAIAdqIQYgASgCCCAHaiEBA0AgBCANaiAGLQAAIAEtAABxOgAAIAZBAWohBiABQQFqIQEgBEEBaiEEIAhBAWsiCA0ACwsgBDYCACAFQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCACACQSBqJAAgABCGMCAKIANBFGooAgA2AgAgACADKQIMNwIADAELAkAgAkGAgICAeEcEQCADQRhqIAEQ5x4MAQsgA0GAgICAeDYCGAsgABCGMCAAQQhqIANBIGooAgA2AgAgACADKQIYNwIACyADQTBqJAALhgIBAn8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAIAMOAgIBAAsDQAJAIAIgA00EQCACIANHDQEMBgsgASADaiwAAEG/f0oNBAsgA0EBayIDQQFLDQALC0EBIQMgAkEBTQRAIAJBAUcNAQwCCyABLAABQb9/Sg0BCyAAQYCAgIB4NgIADAILIAIgA0kNAiADIQILIARBBGogAkEAQQFBARCgGCAEKAIIIQMgBCgCBEEBRg0CIAQoAgwhBSACBEAgBSABIAL8CgAACyAAIAI2AgggACAFNgIEIAAgAzYCAAsgBEEQaiQADwsgAyACQZCFzwAQsDsACyADIAQoAgxBwPXOABD9LwALtxQCFX8CfiMAQUBqIgskACAEIAQoAggiEiADQQZurSIbIAOtfEIgfCIap0EAIBpC/////w9YG2oQji0gEiAEKAIIIglNBEAgASEQIAIhFCAEKAIEIBJqIQogCSASayEIQQAhASMAQRBrIhMkAAJAAkACQAJAAkACQAJAIBsgA60iGnxCIHwiG0KAgICAEFoEQCALQv////8PNwMQIAsgGjcDCCALQQA6AAAMAQsCQCAbpyAITQRAIANFDQEgCEEBayERIBBBDGohFgJ/AkAgGkKAAVQNAANAIAEgCEcEQCABIApqIBqnQYABcjoAACABQQFqIQEgGkL//wBWIBpCB4ghGg0BDAILCyAIIAhBvJ3+ABDDIQALIAEgCEkEQCABIApqIBo8AAAgAUEBagwBCyABIAhBrJ3+ABDDIQALIQUDQAJAIBQhDAJAAkACQAJAAkACfyADQYCABEsEQCAMQYCABGohFCADQYCABGshAUGAgAEhBkGAgAQMAQsgA0ERSQ0BIAMgDGohFEEAIQEgA0GBAkkNAkGAgAEgAyADQYCAAU8bIQYgAwshCUGAAiEHQRghDgNAIA5BAWshDiAHIgJBAXQiByAGSQ0ACyACQYEESQRAIAEhAyAWIQ0MBQsgECgCCCIGRQRAIBNBBGpBgIABQaCT/gAQmRUgEEECQQIQ4B4gEEEIaiICIBNBDGooAgA2AgAgECATKQIENwIAIAIoAgAhBgsgBiAHSQ0CIBAoAgQhDSABIQMMBAsgBSAITw0JIAUgCmogA0ECdEEEazoAACAKIAVBAWoiAmohASADQRBHDQIgASAMKQAANwAAIAFBCGogDEEIaikAADcAACAFQRFqIQUMBAtBgAIhB0EYIQ4gAyEJQQAhAyAWIQ0MAgsgByAGQbCT/gAQsDsACyADBEAgASAMIAP8CgAACyACIANqIQUMAQtBASEGQQAhAiAHQQF0IgEEQCANQQAgAfwLAAsgDEEBayEYIA5BH3EhFSAJQQ9rIRcgDCgAASEPAkACQAJAAkACQAJAAkACQAJAAkADQEEgIQcCfwJAAkACQAJ/AkACQAJAAkADQCAHQQV2IhkgBiIBaiIGIBdLDQEgDSAPQb3P1vEBbCAVdkEBdGoiDy8BACEOIA8gATsBACAHIBlqIQcgBiAMaigAACEPIAEgDGooAAAgDCAOaigAAEcNAAsgASACRg0GIAEgAmsiB0EBayIGQTxJDQIgBkGAAkkNASAFIAhPDRogBSAKakH0AToAACAFQQFqIg8gEU8NGyAKIA9qIAY7AAAgBUEDagwECyACIAlPDRIgCSACayIBQQFrIg1BPE8EQCANQYACTwRAIAUgCEkEQCAFIApqQfQBOgAAIAVBAWoiCSARTw0dIAkgCmogDTsAACAFQQNqIQUMFAsMGwsgBSAITw0cIAUgCmpB8AE6AAAgBUEBaiIJIAhPDQUgCSAKaiANOgAAIAVBAmohBQwSCyAFIAhJDRAMGAsgBSAITw0aIAUgCmpB8AE6AAAgBUEBaiIPIAhJDQEgDyAIQYCT/gAQwyEACyAFIAhJDQQMFgsgCiAPaiAGOgAAIAVBAmoLIQUgBwwDCyAJIAhBgJP+ABDDIQALQdCS/gAQsjsACyAFIApqIAZBAnQ6AAAgBUEBaiEFIAdBECAHIAdBEE0bIAJBEGogCUsbCyIGBEAgBSAKaiACIAxqIAb8CgAACyAFIAdqIQUCQANAIA5BBGohBgJAIAkgAUEMaiIHSQR/IAFBBGoFAkADQCAHIAxqQQhrKQAAIhogBiAMaikAACIbUQRAIAZBCGohBiAJIAdBCGoiB08NAQwCCwsgGiAbhXqnQQN2IAdqQQhrIQIMAgsgB0EIawsiAiAJTw0AIAYgCSAGIAlLGyEHA0AgBiAHRg0FIAIgDGotAAAgBiAMai0AAEcNASAGQQFqIQYgCSACQQFqIgJHDQALIAkhAgsgASAOayEGIAIgAWsiB0HEAE8EQCAGQQh2IQ4DQCAFIAhPDRggBSAKaiIBQf4BOgAAIAVBAWogEU8NFiABQQJqIA46AAAgAUEBaiAGOgAAIAVBA2ohBSAHQUBqIgdBwwBLDQALCwJ/IAdBwABLBEAgBSAITw0YIAUgCmpB7gE6AAAgBUEBaiIBIBFPDRYgASAKaiAGOwAAIAVBA2ohBSAHQTxrIQcLIAdBDEkgBkH/D01xRQRAIAUgCE8NGCAFIApqIAdBAnRBAms6AAAgBUEBaiIBIBFPDRYgASAKaiAGOwAAQQMMAQsgBSAITw0FIAUgCmogB0ECdEEQayAGQQN2QeABcXJBAXI6AAAgBUEBaiIBIAhPDQYgASAKaiAGOgAAQQILIAVqIQUgAiAXTw0BIA0gAiAYaikAACIap0G9z9bxAWwgFXZBAXRqIAJBAWs7AQAgDSAaQgiIpyIHQb3P1vEBbCAVdkEBdGoiAS8BACEOIAEgAjsBACACIQEgDCAOaigAACAHRg0ACyABQQFqIQYgGkIQiKchDwwBCwsgAiAJTw0JIAkgAmsiAUEBayINQTxPBEAgDUGAAk8EQCAFIAhJBEAgBSAKakH0AToAACAFQQFqIgkgEU8NFCAJIApqIA07AAAgBUEDaiEFDAgLDBILIAUgCE8NEyAFIApqQfABOgAAIAVBAWoiCSAITw0EIAkgCmogDToAACAFQQJqIQUMBgsgBSAISQ0EDA8LIAcgCUHAkv4AEMMhAAsgBSAIQZCS/gAQwyEACyABIAhBoJL+ABDDIQALIAkgCEGAk/4AEMMhAAsgBSAKaiANQQJ0OgAAIAVBAWohBSACQRBqIAlLIAFBEEtyDQAgBSAKaiIJIAIgDGoiAikAADcAACAJQQhqIAJBCGopAAA3AAAMAQsgAUUNACAFIApqIAIgDGogAfwKAAALIAEgBWohBQwCCyAFIApqIA1BAnQ6AAAgBUEBaiEFIAJBEGogCUsgAUEQS3INACAFIApqIgkgAiAMaiICKQAANwAAIAlBCGogAkEIaikAADcAACABIAVqIQUMAQsgAQRAIAUgCmogAiAMaiAB/AoAAAsgASAFaiEFCyADDQELCyALQQ46AAAgCyAFNgIEDAILIAsgGzcDECALQQE6AAAgCyAIrTcDCAwBCyALQQE2AgQgCkEAOgAAIAtBDjoAAAsgE0EQaiQADAULIAUgCEGQk/4AEMMhAAsgBSAIQeCS/gAQwyEAC0H4nP4AQSJBnJ3+ABCfKQALIAUgCEHwkv4AEMMhAAsgBSAIQbCS/gAQwyEACwJAIAstAAAiAUEORwRAIAtBMGogC0EQaikDADcDACALQThqIAtBGGopAwA3AwAgCyALLQADOgAjIAsgCy8AATsAISALIAspAwg3AyggCyALKAIENgIkIAsgAToAICAAIAtBIGoQ0SEMAQsgBCALKAIEIBJqEPQ0IABBCDYCAAsgC0FAayQADwsgEiAJQfSKzwAQrzsAC/MBAQN/IAAoAgAgACgCCCIEayABSQRAIAAgBCABQQRBIBDQKCAAKAIIIQQLIAAoAgQgBEEFdGohAwJAAkAgAUECTwRAIAFBAWshBQNAIAMgAikCADcCACADQRhqIAJBGGopAgA3AgAgA0EQaiACQRBqKQIANwIAIANBCGogAkEIaikCADcCACADQSBqIQMgBUEBayIFDQALIAEgBGpBAWshBAwBCyABRQ0BCyADIAIpAgA3AgAgA0EYaiACQRhqKQIANwIAIANBEGogAkEQaikCADcCACADQQhqIAJBCGopAgA3AgAgBEEBaiEECyAAIAQ2AggLhAIBAX8gACgCCCIFIAAoAgBGBEAgAEG4+s8AEKMoCyAAKAIEIAVqIAE6AAAgACAFQQFqNgIIIAAoAhQiASAAKAIMRgRAIABBDGpByPrPABCQKAsgACgCECABQQxsaiIFIAIpAgA3AgAgBUEIaiACQQhqKAIANgIAIAAgAUEBajYCFCAAKAIgIgEgACgCGEYEQCAAQRhqQdj6zwAQkCgLIAAoAhwgAUEMbGoiAiADKQIANwIAIAJBCGogA0EIaigCADYCACAAIAFBAWo2AiAgACgCLCIBIAAoAiRGBEAgAEEkakHo+s8AELMoCyAAKAIoIAFBA3RqIAQ3AwAgACABQQFqNgIsC5ICAQJ/AkACQAJAAkAgACAAKAKMByIFBH8gBQUgACAAKAKIB0EBaiIFNgKIByAFIAAoAgwiBk8NASAFIAAoAgQiBk8NAiAAKAIAIAVqLQAAIQYgACAAKAIIIAVBAnRqKAIAIgU2AowHIAAgBiAAKAIgbDYCkAcgAEEsaiAFIAZBACACIAMgBBCeEiAAKAKMBwtBAWs2AowHIAAoApAHIAFqIgEgACgCFCIFTw0CIAEgACgCHCIFSQ0DIAEgBUGErNAAEMMhAAsgBSAGQdSr0AAQwyEACyAFIAZB5KvQABDDIQALIAEgBUH0q9AAEMMhAAsgACgCECABai0AACAAKAIYIAFBAXRqMwEAIAIgAyAEEOUSC5QCAgF/AX4jAEEQayIFJAACQAJAAkAgA0UgBEVyDQAgAiwAAEG/f0oNACAFQQRqQRpBAEEBQQEQoBggBSgCCCECIAUoAgRBAUYNASAFKAIMIgFBGGpB3MnQAC8AADsAACABQRBqQdTJ0AApAAA3AAAgAUEIakHMydAAKQAANwAAIAFBxMnQACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAgsgAUEMaiACIAMQoTYgATUCFCEGIAEoAggiAiABKAIARgRAIAFB8MnQABCzKAsgASgCBCACQQN0aiAGNwMAIABBCDYCACABIAJBAWo2AggMAQsgAiAFKAIMQaTG0AAQ/S8ACyAFQRBqJAALlwIBAn8jAEGgAmsiAiQAIAEoAhQhAyACQeABaiABQQhqKAIANgIAIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACQQA7AZACIAJBADYCjAIgAkEANgL0ASACQQA2AugBIAIgA0EDdkEBazYC5AEgAiABKQIANwLYAUEYQQQQrTYiA0UEQEEEQRgQoz0ACyADIAEpAhg3AgwgAyABKQIMNwIAIANBFGogAUEgaigCADYCACADQQhqIAFBFGooAgA2AgAgAkECNgKcAiACIAM2ApgCIAJBAjYClAIgAkHcAGoiAyACQbgBaiACQZQCahCWKSACIAMgAUEkahDCGSAAIAIQzRwgAkGgAmokAAuXAgECfyMAQaACayICJAAgASgCFCEDIAJB4AFqIAFBCGooAgA2AgAgAkIENwLQASACQgA3AsgBIAJCgICAgMAANwLAASACQQA2ArgBIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQJ2QQFrNgLkASACIAEpAgA3AtgBQRhBBBCtNiIDRQRAQQRBGBCjPQALIAMgASkCGDcCDCADIAEpAgw3AgAgA0EUaiABQSBqKAIANgIAIANBCGogAUEUaigCADYCACACQQI2ApwCIAIgAzYCmAIgAkECNgKUAiACQdwAaiIDIAJBuAFqIAJBlAJqEJYpIAIgAyABQSRqEMIZIAAgAhDNHCACQaACaiQAC6oCAQd/IwBBEGsiAyQAAkAgACgCACIBRQRAQQAhAAwBCxDMLyEAQYCAgIB4IQICQAJAAkACQAJAAkBBAiABKAIAIgZB/////wdqIAZBgICAgHhNG0EBaw4EAQIDBAALIAEoAgghBCABKAIEIQUgASgCDCEHQYGAgIB4IQIMBAsgASgCBCEFQYKAgIB4IQIgAUEIahCaFCEEDAMLIAEoAgwhByAGQYCAgIB4Rg0CIANBBGogARDPCyADKAIMIQQgAygCCCEFIAMoAgQhAgwCCyABKAIEIQVBhICAgHghAiABQQhqEJoUIQQMAQsgASgCDCEHIAEoAgghBCABKAIEIQUgBiECCyAAIAc2AgwgACAENgIIIAAgBTYCBCAAIAI2AgALIANBEGokACAAC6ICAgN/An4jAEEQayIFJAAgBSACQQBBAUEBEKAYIAUoAgQhBiAFKAIAQQFHBEAgBSgCCCEHIAIEQCAHIAEgAvwKAAALAn5B+POKASgCAEEBRgRAQYj0igEpAwAhCEGA9IoBKQMADAELIAUQ4yZB+POKAUIBNwMAQYj0igEgBSkDCCIINwMAIAUpAwALIQkgACACNgI8IAAgBzYCOCAAIAY2AjQgACAEOgBAIABBADoAQSAAQgA3AyAgACAINwMYIAAgCTcDEEGA9IoBIAlCAXw3AwAgACADKQIANwIoIABB6M6HASkDADcDACAAQQhqQfDOhwEpAwA3AwAgAEEwaiADQQhqKAIANgIAIAVBEGokAA8LIAYgBSgCCEHQzocBEP0vAAvkAQEBfyMAQRBrIgMkACADQQA2AgwgACABIANBDGoCfwJAIAJBgAFPBEAgAkGAEEkNASACQYCABE8EQCADIAJBP3FBgAFyOgAPIAMgAkESdkHwAXI6AAwgAyACQQZ2QT9xQYABcjoADiADIAJBDHZBP3FBgAFyOgANQQQMAwsgAyACQT9xQYABcjoADiADIAJBDHZB4AFyOgAMIAMgAkEGdkE/cUGAAXI6AA1BAwwCCyADIAI6AAxBAQwBCyADIAJBP3FBgAFyOgANIAMgAkEGdkHAAXI6AAxBAgsQ9C4gA0EQaiQAC9kBAgJ/AX4jAEEQayIFJAACQAJAAkAgAq0gBK1+IgdCIIinDQAgB6ciASADQQFraiICIAFJDQAgAkEAIANrcSIGIARBCGpqIgIgBkkgAkGAgICAeCADa0tyDQAgAgR/IAIgAxCtNgUgAwsiAQ0BIAMgAhDlLiAAIAUpAwg3AgQgAEEANgIADAILEOMnIAAgBSkDADcCBCAAQQA2AgAMAQsgAEEANgIMIAAgBEEBayICNgIEIAAgASAGajYCACAAIAIgBEEDdkEHbCACQQhJGzYCCAsgBUEQaiQAC+IBAQh/IAIEQCABQUBrIQogASgCTCEDIAEoAlAhBgNAIAEoAjQiBSACIAdrIgQgBCAFSxsiCCAHaiEHIAMgBiAIaiIGQQN2IAZBB3FBAEdqIgRJBEAgBCADayEJIAEoAkQiBSAESQRAIAogBUEBdCIFIARBwP///wNxQUBrIAQgBEE/cRsiAyADIAVJGxDoGSABKAJMIQMLIAkEQCABKAJIIANqQQAgCfwLAAsgASAENgJMIAQhAwsgASAGNgJQIAEgASgCLCAIajYCLCACIAdLDQALCyAAQQg2AgAgACACNgIEC44CAQF/IwBBEGsiBSQAAkACQCADRSAERXINACACLAAAQb9/Sg0AIAVBBGpBGkEAQQFBARCgGCAFKAIIIQIgBSgCBEEBRwRAIAUoAgwiAUEYakHcydAALwAAOwAAIAFBEGpB1MnQACkAADcAACABQQhqQczJ0AApAAA3AAAgAUHEydAAKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBADYCAAwCCyACIAUoAgxBpMbQABD9LwALIAFBDGogAiADEKE2IAEoAhQhAyABKAIIIgIgASgCAEYEQCABQfDJ0AAQnSgLIAEoAgQgAkECdGogAzYCACAAQQg2AgAgASACQQFqNgIICyAFQRBqJAAL5AEBAX8jAEEQayICJAAgAkEANgIMIAAgAkEMagJ/AkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA1BBAwDCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAILIAIgAToADEEBDAELIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECCxChNiACQRBqJABBAAv5AQIEfwF+IwBBEGsiBCQAIARBCGogARDWEAJAAkAgBCgCCEEBcQRAIAQoAgwhAwNAIAMgASgCRCICTw0CIANBAWoiBSACTw0DIAEoAkgiAiACKQMAIAEoAkAiAiAFQQN0aikDACACIANBA3RqKQMAfUL/////D4N8IgY3AwAgACgCCCIDIAAoAgBGBEAgACABKAI4QQFqIgJBfyACGxDsLQsgACgCBCADQQN0aiAGNwMAIAAgA0EBajYCCCAEIAEQ1hAgBCgCBCEDIAQoAgBBAXENAAsLIARBEGokAA8LIAMgAkGsuIIBEMMhAAsgBSACQby4ggEQwyEAC/0BAgV/AX4gAEEYaiIGIAAoAiAgA0EIQQhBsLGDARDDKAJAAkAgASACRwRAA0AgASgCACIDIAEoAgQiB0kEQCADQQN0IQQDQCADIAAoAgwiBU8NBCADQQFqIgggBU8NBSAAIAApAwAgACgCCCAEaiIDQQhqKQMAIAMpAwB9Qv////8Pg3wiCTcDACAAKAIgIgMgACgCGEYEQCAGQcCxgwEQsygLIAAoAhwgA0EDdGogCTcDACAAIANBAWo2AiAgBEEIaiEEIAgiAyAHRw0ACwsgAUEIaiIBIAJHDQALCw8LIAMgBUGcsIMBEMMhAAsgA0EBaiAFQZywgwEQwyEAC4UCAQl/IwBBEGsiAyQAIAEoAhgiBSAFKAIAIgJBAWo2AgACQCACQQBIDQAgASgCICEGIAEoAhwhByADQQRqIAEQvhUgASgCJCICBEAgAiACKAIAIgRBAWo2AgAgBEEASA0BIAEoAjghBCABKAI0IQggASgCMCEJIAEoAiwhCiABKAIoIQELIABCmrTo0KHDho0aNwIMIAAgBjYCICAAIAc2AhwgACAFNgIYIAAgAykCBDcCACAAIAQ2AjggACAINgI0IAAgCTYCMCAAIAo2AiwgACABNgIoIAAgAjYCJCAAQRRqQZq06NABNgIAIABBCGogA0EMaigCADYCACADQRBqJAAPCwALhQIBCX8jAEEQayIDJAAgASgCGCIFIAUoAgAiAkEBajYCAAJAIAJBAEgNACABKAIgIQYgASgCHCEHIANBBGogARC+FSABKAIkIgIEQCACIAIoAgAiBEEBajYCACAEQQBIDQEgASgCOCEEIAEoAjQhCCABKAIwIQkgASgCLCEKIAEoAighAQsgAEKXrty48eLFixc3AgwgACAGNgIgIAAgBzYCHCAAIAU2AhggACADKQIENwIAIAAgBDYCOCAAIAg2AjQgACAJNgIwIAAgCjYCLCAAIAE2AiggACACNgIkIABBFGpBl67cuAE2AgAgAEEIaiADQQxqKAIANgIAIANBEGokAA8LAAuJAgEDfyMAQSBrIgMkACADQRRqIAFBAWpBAEEIQQgQoBggAygCGCEEAkAgAygCFEEBRwRAIANBADYCECADIAMoAhwiBTYCDCADIAQ2AgggBAR/IAUFIANBCGpBvOaFARCzKCADKAIMC0IANwMAIANBATYCECADQRRqIAJBAEEBQQEQoBggAygCGCECIAMoAhRBAUYNASADKAIcIQQgACADKQIINwIMIAAgATYCMCAAQQA2AiwgAEEANgIYIABBADYCCCAAIAQ2AgQgACACNgIAIABBFGogA0EQaigCADYCACADQSBqJAAPCyAEIAMoAhxBrOaFARD9LwALIAIgAygCHEHM5oUBEP0vAAuJAgEDfyMAQSBrIgMkACADQRRqIAFBAWpBAEEEQQQQoBggAygCGCEEAkAgAygCFEEBRwRAIANBADYCECADIAMoAhwiBTYCDCADIAQ2AgggBAR/IAUFIANBCGpBvOaFARCdKCADKAIMC0EANgIAIANBATYCECADQRRqIAJBAEEBQQEQoBggAygCGCECIAMoAhRBAUYNASADKAIcIQQgACADKQIINwIMIAAgATYCMCAAQQA2AiwgAEEANgIYIABBADYCCCAAIAQ2AgQgACACNgIAIABBFGogA0EQaigCADYCACADQSBqJAAPCyAEIAMoAhxBrOaFARD9LwALIAIgAygCHEHM5oUBEP0vAAvKBgIKfwJ+IwBBQGoiBCQAIAQgATYCPCAEIAI2AjQgBCACIANBAnRqNgI4IARBFGohByMAQTBrIgMkACADQZOAgIB4NgIAIANBKGogBEE0aiICQQhqKAIANgIAIAMgAikCADcDICADIAM2AiwgA0EUaiEIIwBBMGsiAiQAIAJBCGogA0EgaiIFIAJBIGoiCiAFKAIMEMcRAkACQAJAAkAgAigCCEEBcUUNACACKAIMIglFDQAgCkEEQQBBBEEEEKAYIAIoAiQhBiACKAIgQQFGDQIgAkEcaiINQQE2AgAgAigCKCILIAk2AgAgAiALNgIYIAIgBjYCFCACQShqIAVBCGopAgA3AwAgAiAFKQIANwMgIAJBFGohBiMAQSBrIgUkACAFQRBqIAogBUEfaiAKKAIMEMcRAkAgBSgCEEEBcUUNACAFKAIUIgxFDQAgBigCCCIJQQJ0IQsDQCAGKAIAIAlGBEAgBiAJQQFBBEEEENwoCyAGIAlBAWoiCTYCCCAGKAIEIAtqIAw2AgAgBUEIaiAKIAVBH2ogCigCDBDHESAFKAIIQQFxRQ0BIAtBBGohCyAFKAIMIgwNAAsLIAVBIGokACAIQQhqIA0oAgA2AgAgCCACKQIUNwIADAELIAhBADYCCCAIQoCAgIDAADcCAAsgAkEwaiQADAELIAYgAigCKEHc7IcBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAcgAykCADcCACAHQRBqIANBEGooAgA2AgAgB0EIaiADQQhqKQIANwIAIAgQxycgCEEEQQQQ4B4MAQsgByADKQIUNwIEIAdBk4CAgHg2AgAgB0EMaiADQRxqKAIANgIACyADQTBqJAAgBEEQaiIDIARBIGooAgA2AgAgBCAEKQIYNwMIAn8gBCgCFCICQZOAgIB4RwRAIAQoAiQhASAAIAQpAwg3AgggACABNgIUIABBEGogAygCADYCAEEADAELIARBMGogAygCADYCACAEIAQpAwg3AyggASkDGCEOIAEpAyAhDyAAQQhqIAFBCGoQ/iIgACAPNwMgIAAgDjcDGCAEIARBKGoQthkgBCgCBCECIAQoAgALIQEgACACNgIEIAAgATYCACAEQUBrJAALgQIBA38jAEEQayIDJAACQAJAIAEtACwNACADQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAEtABwgAygCDCECIAMoAgghBSABQQE6ABxFBEAgASgCFCIEBEAgASgCGCAEKAIMEQMACyABQQA6ABwgASACNgIYIAEgBTYCFCABLQAsDQEgAEEBNgIADAILIAIgBSgCDBEDAAsgAS0AECABQQE6ABBFBEAgASgCACECIAFBADYCACACBEAgACACNgIEIABBADYCACABQQA6ABAgACABKQIENwIIIABBEGogAUEMaigCADYCAAwCCyABQQA6ABALIABCADcCAAsgA0EQaiQAC+cBAQJ/IwBBIGsiBCQAAkACQCADIAEvASRrIgVBAWtB//8DcUEOTwRAIARBDGogASACEIgaIAQoAgwiAkEERwRAIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAMAwsgBEEMaiABIAMQqRsgBCgCDCICQQRGDQEgACAEKQIQNwIEIABBDGogBEEYaikCADcCAAwCCyAEQQxqIAEgBUEEdCACchCIGiAEKAIMIgJBBEYNACAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAELIAEgAzsBJEEEIQILIAAgAjYCACAEQSBqJAAL5wEBAn8jAEEgayIEJAACQAJAIAMgAS8BJGsiBUEBa0H//wNxQQ5PBEAgBEEMaiABIAIQiRogBCgCDCICQQRHBEAgACAEKQIQNwIEIABBDGogBEEYaikCADcCAAwDCyAEQQxqIAEgAxCoGyAEKAIMIgJBBEYNASAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAILIARBDGogASAFQQR0IAJyEIkaIAQoAgwiAkEERg0AIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAMAQsgASADOwEkQQQhAgsgACACNgIAIARBIGokAAvmAQEBfyMAQTBrIgQkACACEKMuIQICQCADQQ9OBEAgBEEMaiABIAJBcHIQiBogBCgCDCICQQRHBEAgACAEKQIQNwIEIABBDGogBEEYaikCADcCACAAIAI2AgAMAgsgBEEgaiABQSBqIAMQuBoCQCAELQAgQQRGDQAgBCAEKQMgNwMoIARBDGogBEEoahDQCSAEKAIMQQRGDQAgACAEKQIMNwIAIABBEGogBEEcaigCADYCACAAQQhqIARBFGopAgA3AgAMAgsgAEEENgIADAELIAAgASACIANBBHRyEIgaCyAEQTBqJAAL5gEBAX8jAEEwayIEJAAgAhCjLiECAkAgA0EPTgRAIARBDGogASACQXByEIkaIAQoAgwiAkEERwRAIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAgACACNgIADAILIARBIGogAUEgaiADELkaAkAgBC0AIEEERg0AIAQgBCkDIDcDKCAEQQxqIARBKGoQ0AkgBCgCDEEERg0AIAAgBCkCDDcCACAAQRBqIARBHGooAgA2AgAgAEEIaiAEQRRqKQIANwIADAILIABBBDYCAAwBCyAAIAEgAiADQQR0chCJGgsgBEEwaiQAC5ACAQJ/IwBBMGsiAyQAIAMgAjYCAAJAAkACQCACLQAQIgRBAkYEQCABKAIMQYGAgIB4Rg0BIANBATYCCCADQcSFwwA2AgQgA0IBNwIQIANBgwE2AiAgAyADQRxqNgIMIAMgAzYCHCADQQRqQcyFwwAQ7ywACyAEEIscIQQgAi8BDEUNAiAAIAEgBCACLwEOEKoUDAELIAFBDGohBAJAIAIoAgBBgICAgHhGBEAgA0GAgICAeDYCJAwBCyADQSRqIAIQ3SALIAQgAykCJDcCACABQQI6ABwgAEEENgIAIAEgAigCDDYCGCAEQQhqIANBLGooAgA2AgALIANBMGokAA8LQdyFwwBBI0GAhsMAEMskAAuQAgECfyMAQTBrIgMkACADIAI2AgACQAJAAkAgAi0AECIEQQJGBEAgASgCDEGBgICAeEYNASADQQE2AgggA0HEhcMANgIEIANCATcCECADQYMBNgIgIAMgA0EcajYCDCADIAM2AhwgA0EEakHMhcMAEO8sAAsgBBCLHCEEIAIvAQxFDQIgACABIAQgAi8BDhCpFAwBCyABQQxqIQQCQCACKAIAQYCAgIB4RgRAIANBgICAgHg2AiQMAQsgA0EkaiACEN0gCyAEIAMpAiQ3AgAgAUECOgAcIABBBDYCACABIAIoAgw2AhggBEEIaiADQSxqKAIANgIACyADQTBqJAAPC0HchcMAQSNBgIbDABDLJAAL7AECBX8BfiMAQRBrIgMkAAJAIAEpAwgiCFAEQCAAQQQ6AAAMAQsgAigCBCACKAIIIgVrrSAIWARAIAAgAUEQaiACEP8VIAEgASkDCCACKAIIIAVrrX03AwgMAQsgAigCDCEGIAIoAgAhBCADQQA2AgggAyAEIAVqNgIAIAMgCKciBDYCBCADIAYgBWsiByAEIAQgB0sbNgIMIAAgAUEQaiADEP8VIAIgAygCCCIEIAVqIgA2AgggASABKQMIIAStfTcDCCACIAMoAgwgBWoiASAAIAYgACAGSxsiACAAIAFJGzYCDAsgA0EQaiQAC5ACAQJ/IwBBMGsiAyQAIAMgAjYCAAJAAkACQCACLQAQIgRBAkYEQCABKAIMQYGAgIB4Rg0BIANBATYCCCADQZjIzgA2AgQgA0IBNwIQIANBgwE2AiAgAyADQRxqNgIMIAMgAzYCHCADQQRqQaDIzgAQ7ywACyAEEIscIQQgAi8BDEUNAiAAIAEgBCACLwEOEPoXDAELIAFBDGohBAJAIAIoAgBBgICAgHhGBEAgA0GAgICAeDYCJAwBCyADQSRqIAIQ3SALIAQgAykCJDcCACABQQI6ABwgAEEENgIAIAEgAigCDDYCGCAEQQhqIANBLGooAgA2AgALIANBMGokAA8LQbDIzgBBI0HUyM4AEMskAAvqAQECfyMAQRBrIgUkACAFIAI2AgggBSAANgIMIAAgA2ohBgJAIANBB0wEQANAIAAgBk8NAiAAIAItAAA6AAAgAEEBaiEAIAJBAWohAgwACwALIAQEQCAFQQxqIAVBCGogACACaxDFGSADQQhrIQMLIAUoAgwhAiABIAZPBEAgAiAFKAIIIAMgBBDRFQwBCyAFKAIIIQACQCABIAJJBEAgAiEBDAELIAIgACABIAJrIgIgBBDRFSAAIAJqIQALA0AgASAGTw0BIAEgAC0AADoAACABQQFqIQEgAEEBaiEADAALAAsgBUEQaiQAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpas2LDhwoWLFjcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZas2LABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpiw4MCBg4aMGDcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZiw4MABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpSo0KDBgoWKFDcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZSo0KABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpmy5MiRo8aMGTcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZmy5MgBNgIADwsAC8YCAgJ/A34jAEEgayIBJAAgACgCACEAAkBBmPCKASkDACIDUARAQaDwigEpAwAhBANAIARCf1ENAkGg8IoBIARCAXwiA0Gg8IoBKQMAIgUgBCAFUSICGzcDACAFIQQgAkUNAAtBmPCKASADNwMACwJAAkAgACkDACADUgRAIAAtAAwhAiAAQQE6AAwgASACOgAHIAJFDQEgAUIANwIUIAFCgYCAgMAANwIMIAFByLSJATYCCCABQQdqQfi6iQEgAUEIakHQtIkBEK0rAAsgACgCCCICQX9HBEAgACACQQFqNgIIDAILQeC0iQFBJkGItYkBEMskAAsgAEEBNgIIIAAgAzcDAAsgAUEgaiQAIAAPCyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBnKuJATYCCCAAQgQ3AhAgAEEIakGkq4kBEO8sAAuEAgEDfyMAQSBrIgEkAAJAIAAoAgQiAyAAKAIARg0AQQEhAiAAQQE2AgACQAJAAkACQAJAIAAoAggoAgAiAC0AMEEXaw4KBQQEBQAEAQIEAwQLIAFCgICAgBA3AhQgASAAQTRqNgIcIAFBFGoQtxQgA0EBR3IhAgwECyABQoCAgIAQNwIUIAEgAEE4ajYCHCABQRRqELcUIANBAUdyIQIMAwsgAUKAgICAEDcCFCABIABBNGo2AhwgAUEUahC3FCADQQFHciECDAILIAFBCGogAEE0ahDDNCABKAIIIgAgACABKAIMQQJ0ahC6CiADQQFHciECDAELQQAhAgsgAUEgaiQAIAIL7gEBBX8jAEEQayIDJAAgASgCCCICQQRqIQQCQAJAIAJBe00EQCAEIAEoAgQiBUsNASADQQRqIgYgASgCACIEIAUgAiACIARqKAAAaxD2NAJAAkAgBkEGEMwgQf//A3EiBgRAIAIgBmoiAiAFSw0FIAIgBGotAABBAUYNAQsgAEEANgIADAELIANBBGogARCSFSADKAIEBEAgACADKQIENwIAIABBCGogA0EMaigCADYCAAwBCyAAQQA2AgALIANBEGokAA8LIAIgBEHQzMwAELE7AAsgBCAFQdDMzAAQsDsACyACIAVBjMnMABCvOwAL/AEBAn8jAEEgayIDJAACQCACQRFJBEAgAkUNAQJAIAEsAABBAEgEQCADQQhqQn83AwAgA0J/NwMADAELIANBCGpCADcDACADQgA3AwALIAMgATYCGCADIAEgAmo2AhwCQCADQRhqEIM7IgRFDQAgBCACIAIgBEsbIgRFDQAgAyACa0EQaiABIAT8CgAACyAAIAMpAwA3AAAgAEEIaiADQQhqKQMANwAAIANBIGokAA8LIANBATYCBCADQfT8zgA2AgAgA0IBNwIMIANBOzYCHCADQZz9zgA2AhggAyADQRhqNgIIIANB/PzOABDvLAALQQBBAEGM/c4AEMMhAAu+BAIHfwF+IwBBQGoiAiQAIAJBGGohBCABQSBqIQcjAEHQAGsiAyQAIANBEGogAUEcaiIIKAIAQQhqIgYQwzQgA0EwaiADKAIUQQBBCEG4BRCgGCADKAI0IQUCQCADKAIwQQFHBEAgA0EANgIkIAMgAygCODYCICADIAU2AhwgAyABKAIEIgU2AiggAyAFIAEoAghBAnRqNgIsIANBCGogBhCvLgJAIAMoAggiASADKAIMIgZHBEADQCADQTBqIANBzwBqIAEoAgBBMGogByADQShqIANBHGoiBRC8ASADKAIwIglBCEcEQCAEIAMpAjQ3AgQgBEEUaiADQcQAaigCADYCACAEQQxqIANBPGopAgA3AgAgBCAJNgIAIAUQqwEgBUEIQbgFEOAeDAMLIAFBBGoiASAGRw0ACwsgBCADKQIcNwIEIARBCDYCACAEQQxqIANBJGooAgA2AgALIANB0ABqJAAMAQsgBSADKAI4QfjpzwAQ/S8ACyACQRBqIgEgAkEkaigCADYCACACIAIpAhw3AwgCQAJAIAIoAhgiA0EIRwRAIAIpAyghCiAAIAIpAwg3AgQgACAKNwMQIAAgAzYCACAAQQxqIAEoAgA2AgAMAQsgAkE4aiIDIAEoAgA2AgAgAiACKQMINwMwIAgoAgAiASABKAIAIgRBAWo2AgAgBEEASA0BIAAgAikDMDcCBCAAQQA2AhQgACABNgIQIABBCDYCACAAQQxqIAMoAgA2AgALIAJBQGskAA8LAAvUAQIBfwN+QQEhAiAArcMiA0IBhiIEIANCP4ciBVIEQCAEIAWFIQNBACECA0AgAkEBaiECIANC/wBWIANCB4ghAw0ACwsCQCACQQpNBEBBACECIAQgBYUiA0KAAVQNAQNAIAJBCkcEQCABIAJqIAOnQYABcjoAACACQQFqIQIgA0L//wBWIANCB4ghAw0BDAMLC0EKQQpBsLX+ABDDIQALQay0/gBBNEGQtf4AEJ8pAAsgAkEKTwRAIAJBCkGgtf4AEMMhAAsgASACaiADPAAAIAJBAWoL+QEBBX8jAEEQayIHJAAgASgCCCIFQQRqIQQCQAJAAkAgBUF7TQRAIAQgASgCBCIGSw0BIAdBBGoiCCABKAIAIgQgBiAFIAQgBWooAABrEPY0AkAgCCACEMwgQf//A3EiAUUEQCAAIAMpAgA3AgAgAEEIaiADQQhqKAIANgIADAELIAEgBWoiAUEEaiECIAFBe0sNAyACIAZLDQQgACAGNgIEIAAgBDYCACAAIAEgBGooAAAgAWo2AggLIAdBEGokAA8LIAUgBEGQuf4AELE7AAsgBCAGQZC5/gAQsDsACyABIAJBgLn+ABCxOwALIAIgBkGAuf4AELA7AAvxAQEEfyMAQSBrIgQkACABKAIIIgNBBGohBQJAAkACQCADQXtNBEAgBSABKAIEIgZLDQEgBEEUaiIFIAEoAgAiASAGIAMgASADaigAAGsQ9jQgBSACEMwgQf//A3EiAgR/IAIgA2oiAkEEaiEDIAJBe0sNAyADIAZLDQQgBEEIaiABIAYgASACaigAACACahCsISAEKAIMIQEgBCgCCAVBAAshAiAAIAE2AgQgACACNgIAIARBIGokAA8LIAMgBUGQuf4AELE7AAsgBSAGQZC5/gAQsDsACyACIANBgLn+ABCxOwALIAMgBkGAuf4AELA7AAvxAQEEfyMAQSBrIgQkACABKAIIIgNBBGohBQJAAkACQCADQXtNBEAgBSABKAIEIgZLDQEgBEEUaiIFIAEoAgAiASAGIAMgASADaigAAGsQ9jQgBSACEMwgQf//A3EiAgR/IAIgA2oiAkEEaiEDIAJBe0sNAyADIAZLDQQgBEEIaiABIAYgASACaigAACACahCsISAEKAIMIQEgBCgCCAVBAAshAiAAIAE2AgQgACACNgIAIARBIGokAA8LIAMgBUGA9/4AELE7AAsgBSAGQYD3/gAQsDsACyACIANB8Pb+ABCxOwALIAMgBkHw9v4AELA7AAvlAQIBfwZ+IwBBMGsiBSQAIAUgASACIAMgBBDQCCAFKQMYIQogBSkDECEGIAUoAiQhAyAFKAIgIQEgBSkDCCELIAACfwJAIAUpAwAiB6ciAkUEQCADRQ0BIAdQrUIBhiEIIAEpAwAhByAGIQlCASEGIAFBCGoMAgsgAkUNACAGIQkgCyEHQgEhBiABDAELQgMhCCAKIQcgAQs2AiAgACALNwMYIAAgCDcDECAAIAo3AwggACAJNwMAIABCACAFNQIofTcDMCAAIAdCACAGpxs3AyggACABIANBA3RqNgIkIAVBMGokAAvxAQEDfwJAIABBkM4ASQRAIAAhAgwBCyABQQRrIQEDQCABIABBkM4AbiICQfCxf2wgAGoiA0HkAG4iBEEBdEGI0IgBai8AADsAACABQQJqIAMgBEHkAGxrQQF0QYjQiAFqLwAAOwAAIAFBBGshASAAQf/B1y9LIAIhAA0ACyABQQRqIQELAkAgAkHjAE0EQCACIQAMAQsgAUECayIBIAIgAkH//wNxQeQAbiIAQeQAbGtB//8DcUEBdEGI0IgBai8AADsAAAsgAEEJTQRAIAFBAWsgAEEwcjoAAA8LIAFBAmsgAEEBdEGI0IgBai8AADsAAAuHEAIPfwF+IwBBEGsiDSQAAkACQAJAAkACQAJAAkBBASABKQMAIhSnQQJrIBRCAVgbQQFrDgMBAgMACyAAIAFBCGogAiADEOoIDAULIAQNAyANQQRqQSJBAEEBQQEQoBggDSgCCCEBIA0oAgRBAUcNAiABIA0oAgxB1P3MABD9LwALIAAhBCMAQSBrIgUkACACKAIUIQ4gAiABQQhqIgYoAggiCiAGKAIcIgBrIgEgAyABIANJGyIBEOwtAkACQAJAAkACQCABIAAgAWoiB00EQCAHIApLDQEgAkEMaiEJAkAgAQRAIAYoAgQgAEECdGoiCiEDIAEhAANAIAMoAgAgCGohCCADQQRqIQMgAEEBayIADQALIAkgCBDlLSABQQJ0IQggBigCFCEJIAYoAhAhDCAGKAIgIQMgBi0AJCIPQQFxIRADQCAKKAIAIgsgA2oiACALSQ0FIAAgCUsNBiAFQQhqIAIgAyAMaiALIBAQlxQgBSgCCCIDQQhHBEAgBCAFKQIMNwIEIARBFGogBUEcaigCADYCACAEQQxqIAVBFGopAgA3AgAMCQsgCkEEaiEKIAAhAyAIQQRrIggNAAsgBiAHNgIcIAYgADYCICAPQQFxDQEMBgsgCUEAEOUtIAYgBzYCHCAGLQAkQQFxRQ0FCyAFQQhqIAIgDhCuGSAFKAIIIgNBCEYNBCAEIAUpAgw3AgQgBEEUaiAFQRxqKAIANgIAIARBDGogBUEUaikCADcCAAwFCyAAIAdB3I7NABCxOwALIAcgCkHcjs0AELA7AAsgAyAAQfyOzQAQsTsACyAAIAlB/I7NABCwOwALIAQgATYCBEEIIQMLIAQgAzYCACAFQSBqJAAMAwsjAEEgayIFJAAgAigCFCEQIAIgAUEIaiIBKAIIIAEoAjRrIgQgAyADIARLGxDsLSAFQQhqIQYgAUE8aiIRIQsjAEEwayIEJAACQAJAAkACQAJAAkAgASgCCCIIIAEoAjQiB2siCiADIAMgCksbIgogB2oiAyAKTwRAIAMgCEsNASADIAEoAhQiCEsNAiAEIAdBAnQiByABKAIEaiIIIAggCkECdCIJaiABKAIQIAdqIgcgByAJahCLKAJAAkAgBCgCFCIIIAQoAhAiB0sEQCABKAIsIQ4gASgCKCESIAggB2shDCABQRhqIQ8gB0ECdCIHIAQoAghqIQMgBCgCACAHaiEHIAEoAjghCSALLQAAQQFxIRMDQCABKAIsIAkgAygCACIIakkNAyAPIAcoAgAQ9DQgASgCOCIJIAhqIgsgCUkNByALIA5LDQggDyAJIBJqIAgQoTYgBEEYaiACIAEoAhwgASgCICATEJcUIAQoAhgiCUEIRw0CIAEgASgCOCAIaiIJNgI4IANBBGohAyAHQQRqIQcgDEEBayIMDQALIAEoAjQgCmohAwsgBiAKNgIEIAEgAzYCNCAGQQg2AgAMCAsgBiAEKQIcNwIEIAZBFGogBEEsaigCADYCACAGQQxqIARBJGopAgA3AgAgBiAJNgIADAcLIARBGGpBF0EAQQFBARCgGCAEKAIcIQMgBCgCGEEBRg0FIAQoAiAiAUEPakHbhs0AKQAANwAAIAFBCGpB1IbNACkAADcAACABQcyGzQApAAA3AAAgBkEXNgIMIAYgATYCCCAGIAM2AgQgBkECNgIADAYLIAcgA0GMhs0AELE7AAsgAyAIQYyGzQAQsDsACyADIAhBnIbNABCwOwALIAkgC0Gshs0AELE7AAsgCyAOQayGzQAQsDsACyADIAQoAiBB1P3MABD9LwALIARBMGokACAFKAIMIQECQCAFKAIIIgNBCEcEQCAAIAUpAxA3AwggAEEQaiAFQRhqKQMANwMAIAAgATYCBCAAIAM2AgAMAQsCQCARLQAARQ0AIAVBCGogAiAQEK4ZIAUoAggiAkEIRg0AIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIAIAAgAjYCAAwBCyAAQQg2AgAgACABNgIECyAFQSBqJAAMAgsgDSgCDCICQeSMzQBBIvwKAAAgAEEiNgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAQoAghBAUcEQCMAQSBrIgUkAAJAAkACQAJAIANFDQAgASgCTCIHRQ0AIAEoAkghBiAEKAIUIQggBCgCECEJIAQoAgghCyAEKAIEIQ4DQCABKAJEIgQgBkYEQCAFQQhqIAEgASgCQEGACBDcCiAFKAIMIQQgBSgCCCIGQQhHBEAgACAFKQMQNwMIIABBEGogBUEYaikDADcDACAAIAQ2AgQgACAGNgIADAYLIARFDQIgAUEANgJIIAEgBDYCRCABKAJMIQdBACEGCyAHIAQgBmsiBCADIAprIgwgBCAMSRsiBCAEIAdLGyIEIAZqIgcgBEkNAiAHQYAISw0DIAVBCGogAiABKAJAIAZBAnRqIAQgDiALIAkgCBDvDyAFKAIIIgZBCEcEQCAAIAUpAgw3AgQgAEEUaiAFQRxqKAIANgIAIABBDGogBUEUaikCADcCACAAIAY2AgAMBQsgASABKAJIIARqIgY2AkggASABKAJMIgwgBGsiBzYCTCAEIApqIgogA0YNASAEIAxHDQALCyAAQQg2AgAgACAKNgIEDAILIAYgB0HMiM4AELE7AAsgB0GACEHMiM4AELA7AAsgBUEgaiQADAELIABCCDcDAAsgDUEQaiQAC4cQAg9/AX4jAEEQayINJAACQAJAAkACQAJAAkACQEEBIAEpAwAiFKdBAmsgFEIBWBtBAWsOAwECAwALIAAgAUEIaiACIAMQ6QgMBQsgBA0DIA1BBGpBIkEAQQFBARCgGCANKAIIIQEgDSgCBEEBRw0CIAEgDSgCDEHU/cwAEP0vAAsgACEEIwBBIGsiBSQAIAIoAhQhDiACIAFBCGoiBigCCCIKIAYoAhwiAGsiASADIAEgA0kbIgEQ7i0CQAJAAkACQAJAIAEgACABaiIHTQRAIAcgCksNASACQQxqIQkCQCABBEAgBigCBCAAQQJ0aiIKIQMgASEAA0AgAygCACAIaiEIIANBBGohAyAAQQFrIgANAAsgCSAIEOUtIAFBAnQhCCAGKAIUIQkgBigCECEMIAYoAiAhAyAGLQAkIg9BAXEhEANAIAooAgAiCyADaiIAIAtJDQUgACAJSw0GIAVBCGogAiADIAxqIAsgEBCfFCAFKAIIIgNBCEcEQCAEIAUpAgw3AgQgBEEUaiAFQRxqKAIANgIAIARBDGogBUEUaikCADcCAAwJCyAKQQRqIQogACEDIAhBBGsiCA0ACyAGIAc2AhwgBiAANgIgIA9BAXENAQwGCyAJQQAQ5S0gBiAHNgIcIAYtACRBAXFFDQULIAVBCGogAiAOEK4ZIAUoAggiA0EIRg0EIAQgBSkCDDcCBCAEQRRqIAVBHGooAgA2AgAgBEEMaiAFQRRqKQIANwIADAULIAAgB0Hcjs0AELE7AAsgByAKQdyOzQAQsDsACyADIABB/I7NABCxOwALIAAgCUH8js0AELA7AAsgBCABNgIEQQghAwsgBCADNgIAIAVBIGokAAwDCyMAQSBrIgUkACACKAIUIRAgAiABQQhqIgEoAgggASgCNGsiBCADIAMgBEsbEO4tIAVBCGohBiABQTxqIhEhCyMAQTBrIgQkAAJAAkACQAJAAkACQCABKAIIIgggASgCNCIHayIKIAMgAyAKSxsiCiAHaiIDIApPBEAgAyAISw0BIAMgASgCFCIISw0CIAQgB0ECdCIHIAEoAgRqIgggCCAKQQJ0IglqIAEoAhAgB2oiByAHIAlqEIsoAkACQCAEKAIUIgggBCgCECIHSwRAIAEoAiwhDiABKAIoIRIgCCAHayEMIAFBGGohDyAHQQJ0IgcgBCgCCGohAyAEKAIAIAdqIQcgASgCOCEJIAstAABBAXEhEwNAIAEoAiwgCSADKAIAIghqSQ0DIA8gBygCABD0NCABKAI4IgkgCGoiCyAJSQ0HIAsgDksNCCAPIAkgEmogCBChNiAEQRhqIAIgASgCHCABKAIgIBMQnxQgBCgCGCIJQQhHDQIgASABKAI4IAhqIgk2AjggA0EEaiEDIAdBBGohByAMQQFrIgwNAAsgASgCNCAKaiEDCyAGIAo2AgQgASADNgI0IAZBCDYCAAwICyAGIAQpAhw3AgQgBkEUaiAEQSxqKAIANgIAIAZBDGogBEEkaikCADcCACAGIAk2AgAMBwsgBEEYakEXQQBBAUEBEKAYIAQoAhwhAyAEKAIYQQFGDQUgBCgCICIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAGQRc2AgwgBiABNgIIIAYgAzYCBCAGQQI2AgAMBgsgByADQYyGzQAQsTsACyADIAhBjIbNABCwOwALIAMgCEGchs0AELA7AAsgCSALQayGzQAQsTsACyALIA5BrIbNABCwOwALIAMgBCgCIEHU/cwAEP0vAAsgBEEwaiQAIAUoAgwhAQJAIAUoAggiA0EIRwRAIAAgBSkDEDcDCCAAQRBqIAVBGGopAwA3AwAgACABNgIEIAAgAzYCAAwBCwJAIBEtAABFDQAgBUEIaiACIBAQrhkgBSgCCCICQQhGDQAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAgACACNgIADAELIABBCDYCACAAIAE2AgQLIAVBIGokAAwCCyANKAIMIgJB5IzNAEEi/AoAACAAQSI2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMAQsgBCgCCEEBRwRAIwBBIGsiBSQAAkACQAJAAkAgA0UNACABKAJMIgdFDQAgASgCSCEGIAQoAhQhCCAEKAIQIQkgBCgCCCELIAQoAgQhDgNAIAEoAkQiBCAGRgRAIAVBCGogASABKAJAQYAIENwKIAUoAgwhBCAFKAIIIgZBCEcEQCAAIAUpAxA3AwggAEEQaiAFQRhqKQMANwMAIAAgBDYCBCAAIAY2AgAMBgsgBEUNAiABQQA2AkggASAENgJEIAEoAkwhB0EAIQYLIAcgBCAGayIEIAMgCmsiDCAEIAxJGyIEIAQgB0sbIgQgBmoiByAESQ0CIAdBgAhLDQMgBUEIaiACIAEoAkAgBkECdGogBCAOIAsgCSAIEO4PIAUoAggiBkEIRwRAIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIAIAAgBjYCAAwFCyABIAEoAkggBGoiBjYCSCABIAEoAkwiDCAEayIHNgJMIAQgCmoiCiADRg0BIAQgDEcNAAsLIABBCDYCACAAIAo2AgQMAgsgBiAHQcyIzgAQsTsACyAHQYAIQcyIzgAQsDsACyAFQSBqJAAMAQsgAEIINwMACyANQRBqJAAL9wEBBX8gACgCBCECIAAoAgAhASAAQoiAgICAATcCACACIAFrQegDbiEDIAAoAgghBAJAAkAgASACRgRAIAAoAhAiAUUNASAAKAIMIgIgBCgCCCIARg0CIAFB6ANsIgNFDQIgBCgCBCIFIABB6ANsaiAFIAJB6ANsaiAD/AoAAAwCCwNAIAEQ2BMgAUHoA2ohASADQQFrIgMNAAsgACgCECIBRQ0AAkAgACgCDCICIAQoAggiAEYNACABQegDbCIDRQ0AIAQoAgQiBSAAQegDbGogBSACQegDbGogA/wKAAALIAQgACABajYCCAsPCyAEIAAgAWo2AggL1QEBC38CQCAAKAIQIgUgACgCBCIGaiABKAIQIgQgASgCBCICakYEQCABKAIMIgcgBGohCCABKAIAIgMgAmohCSAAKAIMIgIgBWohCiAAKAIAIgEgBmohCwNAAn8gAUUgASALRnJFBEAgAiEEIAFBAWoMAQsgAiAKRg0DIAJBAWohBCACIQFBAAsgA0UgAyAJRnIEfyAHIAhGDQMgByIDQQFqIQdBAAUgA0EBagshBiADLQAAIQwgAS0AACEFIQEgBCECIAYhAyAFIAxGDQALC0EADwtBAQvcAQEDfyMAQSBrIgQkACAEQQA2AgQCQAJAIAFBA0sEQCAEQQRqIgVBBCAAQQRBtJzzABDVLCAEKAIEIQYgBEEANgIEIANBA00NAiAFQQQgAkEEQbSc8wAQ1SxBACEFAkAgBCgCBCAGRgRAIAFBBEYNAyADQQRGDQEgAC0ABCACLQAERiEFCyAEQSBqJAAgBQ8LQQRBBEHkk/MAEMMhAAsMAQtBBEEEQdST8wAQwyEACyAEQQA2AhggBEEBNgIMIARBzI/zADYCCCAEQgQ3AhAgBEEIakGknPMAEO8sAAvTAQIBfwN+QQEhAiAArCIDQgGGIgQgA0I/hyIFUgRAIAQgBYUhA0EAIQIDQCACQQFqIQIgA0L/AFYgA0IHiCEDDQALCwJAIAJBCk0EQEEAIQIgBCAFhSIDQoABVA0BA0AgAkEKRwRAIAEgAmogA6dBgAFyOgAAIAJBAWohAiADQv//AFYgA0IHiCEDDQEMAwsLQQpBCkGwtf4AEMMhAAtBrLT+AEE0QZC1/gAQnykACyACQQpPBEAgAkEKQaC1/gAQwyEACyABIAJqIAM8AAAgAkEBaguBAgIFfwF+IwBB8AJrIgIkACABQQxqIgQQ9DUhBSACQRU6AOQBIAJBADYCmAIgAkEANgKAAiACQgA3AvABIAJBADYCxAEgAkEAOwGcAiACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAIgASgCKDYC6AEgAkHwAGogAUEIaiIDKAIANgIAIANBADYCACABKQIAIQcgAUKAgICAEDcCACACIAc3A2ggAkGgAmoiBiACQegAaiIBEJMZIAEgAkHEAWoiAyAGEPojIAMgBBD0EiACQQxqIgQgASADEMIZIAIgBTYCOCACQawCaiIBIAQQzRwgACABEMsSIAJB8AJqJAAL+AECAn8CfiMAQRBrIgQkAAJAAkACQAJAAkACQAJAIAEoAhQiBSABKAIQSQRAIAEoAgwgBWotAAAiBUEuRg0BIAVBxQBGIAVB5QBGcg0CCyACRQ0CQgEhBgwFCyAEIAEgAiADQQAQ1A0gBCgCAA0CDAMLIAQgASACIANBABDpDCAEKAIARQ0CIAAgBCgCBDYCCCAAQgM3AwAMBAtCACADfSIHQgBTBEBCAiEGIAchAwwDCyADur1CgICAgICAgICAf4QhAwwCCyAAIAQoAgQ2AgggAEIDNwMADAILIAQpAwghAwsgACADNwMIIAAgBjcDAAsgBEEQaiQAC4ICAQR/IwBBIGsiAyQAQQEhBQJAIAAtAAQNACAALQAFIQYCQCAAKAIAIgQtAApBgAFxRQRAIAZBAXFFDQEgBCgCAEHP8YkBQQIgBCgCBCgCDBEGAEUNAQwCCyAGQQFxRQRAIAQoAgBB3fGJAUEBIAQoAgQoAgwRBgANAgsgA0EBOgAPIANBsPGJATYCFCADIAQpAgA3AgAgAyAEKQIINwIYIAMgA0EPajYCCCADIAM2AhAgASADQRBqIAIoAgwRAgANASADKAIQQdTxiQFBAiADKAIUKAIMEQYAIQUMAQsgASAEIAIoAgwRAgAhBQsgAEEBOgAFIAAgBToABCADQSBqJAAL7gEBAX8CQCAAKAIAIgAoAhBFBEAgACgCICIBQYQBSQ0BIAEQ8h8MAQsgAEEgahDeOyAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEJ0nCyAAKAIwIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTBqEJcVCyAAKAI0IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTRqEPgjCwJAIAAoAjgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEE4ahDbHgsCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBwABBCBD4OgsLcgACfyAAQcKwAU8EQCABLQA/IAIzAX4gBCAFIAYQ3xNBGCAArULCsAF9IAQgBSAGEN8TQfwBDAELIAEtAD4gAjMBfCAEIAUgBhDfE0EOIACtQsIwfSAEIAUgBhDfE0H4AQsgA2oiACAAKAIAQQFqNgIAC9UBAgN/AX4jAEEgayIGJAACQCAFRQ0AIAIgA2oiAyACSQ0AIAQgBWpBAWtBACAEa3GtIAOtfiIJQiCIpw0AIAmnIghBgICAgHggBGtLDQAgBiABKAIAIgIEfyAGIAIgBWw2AhwgBiABKAIENgIUIAQFIAcLNgIYIAZBCGogBCAIIAZBFGoQvhogBigCCEEBRgRAIAYoAhAhAiAGKAIMIQcMAQsgBigCDCEEIAEgAzYCACABIAQ2AgRBgYCAgHghBwsgACACNgIEIAAgBzYCACAGQSBqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIDAADcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELgYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQsxMgAkGAA2okAAv+AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgCA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARC2GCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEL0TIAJBgANqJAAL/gECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIAgNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQthggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARCqEyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAwAA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDxGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEK0TIAJBgANqJAAL/gECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIAQNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQkxkgASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARC4EyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAgAE3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDzGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABELcTIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgICAAjcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELUYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQsBMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgMAANwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQuBggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARC5EyACQYADaiQAC/4BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAIDcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELYYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQqxMgAkGAA2okAAv+AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgBA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDyGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABELYTIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIDAADcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBEPEYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQwxMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgIABNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQsxggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARDHEyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAgAE3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARCzGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEK4TIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgICAAjcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELkYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQxRMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgIABNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQ8xggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARCxEyACQYADaiQAC4ECAgR/AX4jAEHgAGsiAiQAIAFBGGohBAJAIAEtABhBHUYEQCABKAIcIQMgAkEIaiABEO88IAIoAgwNAUEAQQBBrKaGARDDIQALIAIgBDYCECACQQE2AiAgAkGEp4YBNgIcIAJCATcCKCACQa8DNgIYIAIgAkEUajYCJCACIAJBEGo2AhQgAkEcakGMp4YBEO8sAAsgAkEcaiIFIAIoAgggASgCKCADbCABKAIkIANsENYIIAIgBRCgASACKQMAIQYgACAEENkGIABBFGogAUEsakEAIAEoAiwbEO4lIAAgAzYCLCAAIAY3AgwgACABKAIkNgIwIAEQjCcgAkHgAGokAAuXAgECfyMAQRBrIgIkAAJ/AkACQAJAAkACQEECIAAoAgAiA0H/////B2ogA0GAgICAeE0bQQFrDgQBAgMEAAsgAiAAQQRqNgIMIAFB9I6HAUEGIABBDGpBnI+HASACQQxqQZiXhwEQgw8MBAsgAiAAQQhqNgIMIAFB+o6HAUEEIABBBGpBnI+HASACQQxqQaiXhwEQgw8MAwsgAiAANgIMIAFB/o6HAUEGIABBDGpBnI+HASACQQxqQbiXhwEQgw8MAgsgAiAAQQhqNgIMIAFBhI+HAUEKIABBBGpBnI+HASACQQxqQaiXhwEQgw8MAQsgAiAAQQRqNgIMIAFByJeHAUEFIAJBDGpBwI6HARDQEwsgAkEQaiQAC4oCAQN/IwBBEGsiBCQAAkACQAJAIAEtACgNACAEQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAEtABggBCgCDCECIAQoAgghAyABQQE6ABhFBEAgASgCECIFBEAgASgCFCAFKAIMEQMACyABQQA6ABggASACNgIUIAEgAzYCECABLQAoDQFBgYCAgHghAgwCCyACIAMoAgwRAwALIAEtAAwgAUEBOgAMBEBBgICAgHghAgwBCyABKAIAIQNBgICAgHghAiABQYCAgIB4NgIAIANBgICAgHhHBEAgACABKQIENwIEIAAgAzYCACABQQA6AAwMAgsgAUEAOgAMCyAAIAI2AgALIARBEGokAAuMAgECfwJAIAAoAgBFDQAgAEEEaiECAkACQAJAIAAtAEAOBAACAgECCyACKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgAhDfHwsgACgCCCICQYQBSQ0BIAIQ8h8MAQsCQAJAAkACQCAALQA8DgQAAwMBAwsgACgCGCIBQYMBTQ0CDAELIAAoAigiAUGEAU8EQCABEPIfCyAAKAIkIgFBhAFPBEAgARDyHwsgACgCICIBQYMBTQ0BCyABEPIfCyAAKAIQIgEgASgCAEEBajYCACAAKAIEIgEgASgCAEEBayIBNgIAIAENACACEN8fCyAAKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACAAEOknCwuXAgECfyMAQTBrIgIkAAJAAkACQAJAAkACQAJAIAEoAvQBIgMOBAEAAgMACyACIAM2AgwgAkECNgIUIAJBqJDPADYCECACQgE3AhwgAkGhCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIABBBGogAkEQahCZDiAAQQA2AgAMAwsgASkDAEIDUQ0DIABBADoAFCAAQQE2AgwgAEIINwMAIAAgASgCWDYCEAwCCyAAQQE6ABQgAEEANgIMIABCCDcDAAwBCyABKQNoQgNRDQIgAEEAOgAUIABBATYCDCAAQoiAgIAQNwMAIAAgASgCwAE2AhAgACABKALIATYCCAsgAkEwaiQADwtB2I/PABCyOwALQeiPzwAQsjsAC+oBAQl/IwBBEGsiAiQAIAEoAgQhAyACQQRqIAEoAggiCEEAQQRBCBCgGCACKAIIIQQCQCACKAIEQQFHBEAgAigCDCEJAkAgBEUNACAIQQN0IQYgCSEBIAQhCgNAIAZFDQEgAygCACIHBEAgByAHKAIAIgVBAWo2AgAgBUEASA0EIANBBGooAgAhBQsgA0EIaiEDIAEgBzYCACABQQRqIAU2AgAgAUEIaiEBIAZBCGshBiAKQQFrIgoNAAsLIAAgCDYCCCAAIAk2AgQgACAENgIAIAJBEGokAA8LIAQgAigCDEHE5oQBEP0vCwAL1wEBA38jAEEQayIEJAAgBAJ/IAAvAQAiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhACACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCECIAJBgICA/AdyIABFDQEaIAIgAEENdHJBgICA/gdyDAELIANBEHQhAyACQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogA3IgAg0AGiAAIABnQRBrIgBB//8DcUEIanRB////A3EgA0GAgIDYA3IgAEEXdGtyCzYCDCAEQQxqIAEQjyAgBEEQaiQAC5UCAgN/AX0jAEEQayIEJAAgBAJ/IAAvAQAiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhACACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCICQYCAgPwHciAARQ0BGiACIABBDXRyQYCAgP4HcgwBCyADQRB0IgMgAkENdEGAgID8AHEgAEENdHJBgICAwANqciACDQAaIAAgAGdBEGsiAEH//wNxQQhqdEH///8DcSADQYCAgNgDciAAQRd0a3ILNgIMAn8gASgCCCICQYCAgAFxIQAgBEEMaioCACEFIAJBgICAgAFxRQRAIAEgBSAAQQBHQQAQkAkMAQsgASAFIABBAEcgAS8BDhDpBwsgBEEQaiQAC4UCAQN/IwBBIGsiAyQAIAAoAgAhBSAAAn9BASAALQAIDQAaIAAoAgQiBC0ACkGAAXFFBEBBASAEKAIAQc/xiQFB2fGJASAFG0ECQQEgBRsgBCgCBCgCDBEGAA0BGiABIAQgAigCDBECAAwBCyAFRQRAQQEgBCgCAEHa8YkBQQIgBCgCBCgCDBEGAA0BGgsgA0EBOgAPIANBsPGJATYCFCADIAQpAgA3AgAgAyAEKQIINwIYIAMgA0EPajYCCCADIAM2AhBBASABIANBEGogAigCDBECAA0AGiADKAIQQdTxiQFBAiADKAIUKAIMEQYACzoACCAAIAVBAWo2AgAgA0EgaiQAIAAL2QEBBn8gACgCACIBIAAoAgQiAkcEQCAAIAEgAiABa0EEa0F8cWpBBGo2AgALIAAoAhAiAwRAIAAoAggiAkHIAGohBAJAAkACfwJAIAIoAkgiAUESTwRAIAAoAgwiACACKAIEIgFHDQEgASADaiEADAMLIAEgACgCDCIARgRAIAEgA2ohAAwECyACQQRqDAELIAIoAggLIQUgA0ECdCIGBEAgBSABQQJ0aiAFIABBAnRqIAb8CgAACyABIANqIQAgBCgCAEESSQ0BCyACQQRqIQQLIAQgADYCAAsLggIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGEGAgICAeEYNASABKAIAKAIAIAEoAgQoAgBrIQIgACgCHCIDIAAoAiBBAXRqIQAgASgCCCEBA0AgACADRg0DIAEuAQAiBCAAQQJrIgAuAQBIDQAgAkEBayICDQALIAAgBEEBazsBAA8LIAAoAgwiAgRAIAAoAgghACACQcgAbCECA0AgACABEOYUIABByABqIQAgAkHIAGsiAg0ACwsPC0HEws0AELI7AAtB1MLNABCyOwAFIAAoAgQhAAwBCwALAAu0AgIGfwF+IAEpAxgiCVAEQCAAQQQ6AAAPCyACKAIEIAIoAggiB2utIAlYBEAgAigCACEDIAIoAgQiBCACKAIMIgZrIgUEQCADIAZqQQAgBfwLAAsgAiAENgIMIAEgAyACKAIIIgZqIAQgBmsiAyABKAIIIgQgAyAESRsiAxCXGiAAQQQ6AAAgAiADIAZqNgIIIAEgASkDGCACKAIIIAdrrX03AxgPCyACKAIAIAdqIQQgCaciAyACKAIMIgYgB2siBSADIAMgBUsbIgVrIggEQCAEIAVqQQAgCPwLAAsgASAEIAMgASgCCCIEIAMgBEkbIgQQlxogAiAEIAdqIgU2AgggAEEEOgAAIAEgASkDGCAErX03AxggAiADIAdqIgAgBSAGIAUgBksbIgEgACABSxs2AgwL0AEBCX8gASgCMCINIAEoAiwiC0EHdk8EQCABKAI0IQ9BgIACIAIgAxDKICIIQQF0IgxrIglBACAJQYCAAk0bIRAgC0EBaiEJIAhBAnRBmJvSAGohCANAIAoCQCAKIBBHBEAgASAJNgIsIAgvAQAiCkUNASAAIAogAiADIAQgBSAGIA8gBxDEEkUNAUEBIQ4gASANQQFqIg02AjAMAQsgDEGAgAJBhOLOABDDIQALQQEhCiAJQQFqIQkgCEECaiEIIAxBAWohDEEBcUUNAAsLIA4L0wEBCX8gASgCKCINIAEoAiQiC0EHdk8EQCABKAIsIQ9BgIACIAIgAxDKICIIQQF0IgxrIglBACAJQYCAAk0bIRAgC0EBaiEJIAhBAnRBmJvSAGohCANAIAoCQCAKIBBHBEAgASAJNgIkIAgvAQAiCkUNASAAIAogAiADIAQgBSAGIA8gBxDEEkUNAUEBIQ4gASANQQFqIg02AigMAQsgDEGAgAJBhOLOABDDIQALQQEhCiAJQQFqIQkgCEECaiEIIAxBAWohDEEBckEBcUUNAAsLIA4L9wEBAn8jAEEwayIDJAAgASgCCCEEIAMgAjYCACADIAQ2AgQgAiAETQRAAkAgAiAERwRAIANBCGogAUEMaiABKAIEIAQgASgCACgCABEFACADQRBqIgEgBCACazYCACAAQQhqIAEpAgA3AgAgAyADKAIMIAJqNgIMIAAgAykCCDcCAAwBCyAAQQA2AgwgAEIBNwIEIABBtPDOADYCAAsgA0EwaiQADwsgA0ECNgIMIANB+PDOADYCCCADQgI3AhQgA0GLCDYCLCADQYsINgIkIAMgA0EgajYCECADIANBBGo2AiggAyADNgIgIANBCGpBiPHOABDvLAAL6AEBCX8gASAAKAIYIgNNBEAgAkEDaiICIAMgAWsiAyACIANJGyICQQRPBEAgACgCIEH//wNqIQUgAkEDayEGIAAoAhQgAWohByAAKAIoIQggACgCLCECIAAoAjAhCUEAIQADQAJAIAkgACAHaigAAEGx893xeWxBD3ZB/v8HcWoiCi8BACILIAAgAWoiA0H//wNxRg0AIAIgAyAFcUH//wNxIgRLBEAgCCAEQQF0aiALOwEAIAogAzsBAAwBCyAEIAJBtN/8ABDDIQALIAYgAEEBaiIARw0ACwsPCyABIANBpN/8ABCvOwAL8gcCB38FfiMAQeAAayIDJAAgA0EgaiEEIAEoAiwhBiMAQfABayICJAACQCABKAIcIgUgASgCIEcEQAJAAkACfgJAIAEoAgRFDQAgBSABKAIUTw0DIAEoAgggASgCECAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASAFQQFqNgIcQgAMAQsgASAFQQFqNgIcIAJBCGogASAFEK0qIAIoAgghBSABKAIoIQcgASgCJCEBIAIgAigCDCIINgJMIAIgBTYCSCACQdAAaiAFIAggASwAABDWAQJAAn4gAigCUEEBRgRAIAJBqAFqIAIpAlw3AwAgAkGwAWogAkHkAGooAgA2AgAgAiACKQJUNwOgASACQdgBakGYroABKAIANgIAIAJBkK6AASkCADcD0AEgAkEDNgK8ASACQcSugAE2ArgBIAJCAjcCxAEgAkGuEDYC7AEgAkHMATYC5AEgAiACQeABajYCwAEgAiACQdABaiIBNgLoASACIAJByABqNgLgASACQZABaiACQbgBahCZDiABEKoMIAJBgoCAgHg2AowBIAJBoAFqEIgRIAJBQGsgAkGUAWooAgA2AgAgAiACKQKMATcDOCACKQKYAQwBCyACQdAAaiACKQNgIgkgAikDaCIKIAIpA3AiCyACKQN4IgwgBy0AABDQDiACKAJQQZOAgIB4Rg0BIAJBQGsgAkHYAGooAgA2AgAgAiACKQJQNwM4IAIpAlwLIQkgAiACKQM4NwMQIAIgCTcCHCACIAJBQGsoAgA2AhhCAiEJIAYoAgBBk4CAgHhGDQIgBhCIEQwCCyACIAs3AyAgAiAJNwMQIAIgDDcDKCACIAo3AxhCAQshCSACQewAaiACQSxqKAIANgIAIAIgAikCJDcCZCACQdAAaiEGCyAGIAIpAxA3AgAgBkEIaiACKQMYNwIAIAZBEGogAkEgaigCADYCACAEQgA3AwggBCAJNwMAIAQgAikDUDcDECAEQRhqIAIpA1g3AwAgBEEgaiACQeAAaikDADcDACAEQShqIAJB6ABqKQMANwMADAILQfSngAFBIEGUqIABEJ8pAAsgBEIANwMIIARCAzcDAAsgAkHwAWokACAAAn5CAiADKQMoIgkgAykDICIKQgOFhFANABogA0EYaiIBIANByABqKQMANwMAIANBEGoiAiADQUBrKQMANwMAIAMgAykDMDcDACADIANBOGopAwA3AwhCAiAKQgKFIAmEUA0AGiAAIAMpAwA3AxAgAEEYaiADKQMINwMAIABBKGogASkDADcDACAAQSBqIAIpAwA3AwAgCSENIAoLNwMAIAAgDTcDCCADQeAAaiQAC/UHAgd/BX4jAEHgAGsiAyQAIANBIGohBCABKAIsIQYjAEHwAWsiAiQAAkAgASgCHCIFIAEoAiBHBEACQAJAAn4CQCABKAIERQ0AIAUgASgCFE8NAyABKAIIIAEoAhAgBWoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBUEBajYCHEIADAELIAEgBUEBajYCHCACQQhqIAEoAgAgBRCPLCACKAIIIQUgASgCKCEHIAEoAiQhASACIAIoAgwiCDYCTCACIAU2AkggAkHQAGogBSAIIAEsAAAQ1gECQAJ+IAIoAlBBAUYEQCACQagBaiACKQJcNwMAIAJBsAFqIAJB5ABqKAIANgIAIAIgAikCVDcDoAEgAkHYAWpBmK6AASgCADYCACACQZCugAEpAgA3A9ABIAJBAzYCvAEgAkHEroABNgK4ASACQgI3AsQBIAJBrhA2AuwBIAJBzAE2AuQBIAIgAkHgAWo2AsABIAIgAkHQAWoiATYC6AEgAiACQcgAajYC4AEgAkGQAWogAkG4AWoQmQ4gARCqDCACQYKAgIB4NgKMASACQaABahCIESACQUBrIAJBlAFqKAIANgIAIAIgAikCjAE3AzggAikCmAEMAQsgAkHQAGogAikDYCIJIAIpA2giCiACKQNwIgsgAikDeCIMIActAAAQ0A4gAigCUEGTgICAeEYNASACQUBrIAJB2ABqKAIANgIAIAIgAikCUDcDOCACKQJcCyEJIAIgAikDODcDECACIAk3AhwgAiACQUBrKAIANgIYQgIhCSAGKAIAQZOAgIB4Rg0CIAYQiBEMAgsgAiALNwMgIAIgCTcDECACIAw3AyggAiAKNwMYQgELIQkgAkHsAGogAkEsaigCADYCACACIAIpAiQ3AmQgAkHQAGohBgsgBiACKQMQNwIAIAZBCGogAikDGDcCACAGQRBqIAJBIGooAgA2AgAgBEIANwMIIAQgCTcDACAEIAIpA1A3AxAgBEEYaiACKQNYNwMAIARBIGogAkHgAGopAwA3AwAgBEEoaiACQegAaikDADcDAAwCC0H0p4ABQSBBlKiAARCfKQALIARCADcDCCAEQgM3AwALIAJB8AFqJAAgAAJ+QgIgAykDKCIJIAMpAyAiCkIDhYRQDQAaIANBGGoiASADQcgAaikDADcDACADQRBqIgIgA0FAaykDADcDACADIAMpAzA3AwAgAyADQThqKQMANwMIQgIgCkIChSAJhFANABogACADKQMANwMQIABBGGogAykDCDcDACAAQShqIAEpAwA3AwAgAEEgaiACKQMANwMAIAkhDSAKCzcDACAAIA03AwggA0HgAGokAAv1BwIHfwV+IwBB4ABrIgMkACADQSBqIQQgASgCLCEGIwBB8AFrIgIkAAJAIAEoAhwiBSABKAIgRwRAAkACQAJ+AkAgASgCBEUNACAFIAEoAhRPDQMgASgCCCABKAIQIAVqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAVBAWo2AhxCAAwBCyABIAVBAWo2AhwgAkEIaiABKAIAIAUQ2isgAigCCCEFIAEoAighByABKAIkIQEgAiACKAIMIgg2AkwgAiAFNgJIIAJB0ABqIAUgCCABLAAAENYBAkACfiACKAJQQQFGBEAgAkGoAWogAikCXDcDACACQbABaiACQeQAaigCADYCACACIAIpAlQ3A6ABIAJB2AFqQZiugAEoAgA2AgAgAkGQroABKQIANwPQASACQQM2ArwBIAJBxK6AATYCuAEgAkICNwLEASACQa4QNgLsASACQcwBNgLkASACIAJB4AFqNgLAASACIAJB0AFqIgE2AugBIAIgAkHIAGo2AuABIAJBkAFqIAJBuAFqEJkOIAEQqgwgAkGCgICAeDYCjAEgAkGgAWoQiBEgAkFAayACQZQBaigCADYCACACIAIpAowBNwM4IAIpApgBDAELIAJB0ABqIAIpA2AiCSACKQNoIgogAikDcCILIAIpA3giDCAHLQAAENAOIAIoAlBBk4CAgHhGDQEgAkFAayACQdgAaigCADYCACACIAIpAlA3AzggAikCXAshCSACIAIpAzg3AxAgAiAJNwIcIAIgAkFAaygCADYCGEICIQkgBigCAEGTgICAeEYNAiAGEIgRDAILIAIgCzcDICACIAk3AxAgAiAMNwMoIAIgCjcDGEIBCyEJIAJB7ABqIAJBLGooAgA2AgAgAiACKQIkNwJkIAJB0ABqIQYLIAYgAikDEDcCACAGQQhqIAIpAxg3AgAgBkEQaiACQSBqKAIANgIAIARCADcDCCAEIAk3AwAgBCACKQNQNwMQIARBGGogAikDWDcDACAEQSBqIAJB4ABqKQMANwMAIARBKGogAkHoAGopAwA3AwAMAgtB9KeAAUEgQZSogAEQnykACyAEQgA3AwggBEIDNwMACyACQfABaiQAIAACfkICIAMpAygiCSADKQMgIgpCA4WEUA0AGiADQRhqIgEgA0HIAGopAwA3AwAgA0EQaiICIANBQGspAwA3AwAgAyADKQMwNwMAIAMgA0E4aikDADcDCEICIApCAoUgCYRQDQAaIAAgAykDADcDECAAQRhqIAMpAwg3AwAgAEEoaiABKQMANwMAIABBIGogAikDADcDACAJIQ0gCgs3AwAgACANNwMIIANB4ABqJAAL6AEBBX8jAEEQayIEJAAgACgCBCIDIAAoAggiAiABKAIEIAEoAggQzRACQCACRQ0AIAMgAkECdCIFakEEayIBRQ0AIAEoAgANACAFIQEgA0EEayEFIAJB/////wNxIQMCQANAIAFFBEBBACEBDAILIANBAWshAyABIAVqIAFBBGshASgCAEUNAAsgA0EBaiIBIAJLDQELIAAgATYCCCABIQILAkAgAiAAKAIAQQJ2Tw0AIARBCGogACACQQRBBBD0FCAEKAIIIgBBgYCAgHhGDQAgACAEKAIMQdiJiAEQ/S8ACyAEQRBqJAAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQN0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQbi0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQJ0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQZC0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQJ0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQci0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQN0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQdi0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL3wEBBX8jAEEQayIHJAAgB0EMaiEIAkAgBEUNACABKAIAIgZFDQAgByADNgIMIAQgBmwhBSABKAIEIQkgB0EIaiEICyAIIAU2AgACQCAHKAIMIgUEQCAHKAIIIQYCQCACRQRAIAYEQCAJIAYgBRD4OgsgASADNgIEDAELIAIgBGwhCAJ/AkAgBEUEQCAGRQ0BIAkgBiAFEPg6DAELIAkgBiAFIAgQlzUMAQsgBQsiBEUNAiABIAQ2AgQLIAEgAjYCAAtBgYCAgHghBQsgACAINgIEIAAgBTYCACAHQRBqJAAL4wEBB38jAEEQayIGJAAgASgCLARAIAFBLGohCCABKAJMIgogA2oiBEEDdiAEQQdxQQBHaiIEIAEoAjgiBUsEQCAEIAVrIQkgASgCMCIHIARJBEAgCCAHQQF0IgUgBBDcKiIHIAUgB0sbEOgZIAEoAjghBQsgCQRAIAEoAjQgBWpBACAJ/AsACyABIAQ2AjgLIAZBCGogCBCGPSABIAYoAgggBigCDCAAKAIAIAAoAgQgCiAAKAIIKAIMIAJqIAMQhAkgASgCSGo2AkggBkEQaiQADwtBzI+HAUEdQeyPhwEQyyQAC5wIAw9/AX4BbyMAQSBrIgYkACABAn8CQAJAAkACQAJAIAEtACBBAWsOAwMAAgELAAsgASABKAIMNgIcIAEgASgCCDYCGCABIAEoAgA2AhQLIAZBGGohCyMAQSBrIgkkACABQRRqIgooAgghDAJAAkACQANAIAxFDQEgCUEIaiENIAooAgBBEGohBCAKKAIEIREjAEEgayIHJAAgB0EQaiEQIAIhBUEAIQMjAEEQayIOJAAgBEEIaiEIAkAgBCgCCEUEQCAEKAIAQQFHDQEgBEEEaigCACUBECohExDfEiIDIBMmASADEPsOIQ8CQCAEKAIIIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAgQshoLIAggDzYCAAsgDkEIaiAIIAUQxxhBAiEDIA4oAggiD0ECRg0AIA4oAgwhBQJAIAgoAgAiA0UNACADIAMoAgBBAWsiAzYCACADDQAgCBCyGgsgCEEANgIAQQEhAyAPQQFxBEAgBBClLSAEQQA2AgAMAQsgBUGEAU8EQCAFEPIfC0EAIQMLIBAgBTYCBCAQIAM2AgAgDkEQaiQAAkACQCAHKAIQIgVBAkcEQCAFQQFxRQRAIAdBBDoAGAwCCyAHQRhqIAcoAhQQjxIgBy0AGEEFRw0BCyANQQU6AAAMAQsgBykDGCISQv8Bg0IEUgRAIA0gEjcCAAwBCyARIAwQlT0hBSMAQRBrIggkACAIIAU2AgwgBCgCAEEBRgRAIARBDGohBSAEQQRqKAIAJQEgCEEMaigCACUBEC0hExDfEiIDIBMmASADEPsOIQMCQCAEKAIMIgRFDQAgBCAEKAIAQQFrIgQ2AgAgBA0AIAUQshoLIAUgAzYCACAIKAIMIQULIAVBhAFPBEAgBRDyHwsgB0EIakEANgIAIAhBEGokACANIAw2AgQgDUEEOgAACyAHQSBqJAAgCS0ACEEFRgRAIAtBBToAAAwECyAJKQMIIhJC/wGDQgRSBEAgCyASNwIADAQLIAooAgQhByAKKAIIIQUgCkIBNwIEIAUgEkIgiKciBEkNAiAKIAUgBGsiDDYCCCAKIAQgB2o2AgQgEkL/////D1YNAAsgC0KBLjcCAAwCCyALQQQ6AAAMAQsgCUEANgIYIAlBATYCDCAJQYzHwwA2AgggCUIENwIQIAlBCGpB/MnDABDvLAALIAlBIGokACAGLQAYQQVHDQEgAEEJNgIAQQMMAgtBsLXDABDoKwALAkAgBikDGCISQv8Bg0IEUgRAIAYgEjcDGCAGIAZBGGoQgSsMAQsgBkEINgIACyABQRBqIAEoAgggASgCDCABKAIEKAIQEQEAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAgACAGKQMANwMAQQELOgAgIAZBIGokAAvCCQIPfwN+IwBB4ABrIgUkAAJAAkAgASgCCCICIAEoAhBGBEAgAEEJNgIADAELIAEgAkEEajYCCCAFQRhqIQogAigCACECIwBB8ABrIgQkACABKAIUQQhqIgMgAhCILSIGIAEoAhgiBxCJLSEJAkACQAJAAkACQAJAIAMQ1zQiA0UNACACIAMoAggiCE8NAiADKAIEIgMgAkEMbCIIaigCCCICRQ0AIAIgB00NAyAEQQRqIAMgCGooAgQgB0EYbGoQzhUMAQsgBEGAgICAeDYCBAsgBikDECABKAIAIgsgCygCACIBQQFqNgIAIAFBAEgNAiMAQRBrIgckACAHQQhqQYEEOwEAIActAAghASAHIActAAlBAXE6AAEgByABOgAAIActAAEhASAHLQAAIQJBDEEEEK02IgZFBEBBBEEMEKM9AAsgBkKBgICAEDcCACAGIAJBAXE6AAggBiABQQFxOgAJIARBKGohAachECAEQQRqIQMjAEEgayICJAAgAiAGNgIEIAIgCzYCACACQQhqIAkoAtABIAkoAtQBIAZBCGoQxw0gAigCECEOIAIoAgwhDwJAIAIoAggiCEEIRwRAIAEgAikCFDcCFCABQRxqIAJBHGooAgA2AgAgASAONgIQIAEgDzYCDCABIAg2AgggAUIDNwMAIAYgBigCACIBQQFrNgIAIAFBAUYEQCACQQRqEIIsCyADKAIAQYCAgIB4RwRAIAMQ9TsLIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAIQ6CcMAQsgAkEIaiAJEOwgIAIpAwghEQJAAn4CQCADKAIAIgZBgICAgHhHBEAgAygCBCEIIAMoAggiDA0BQgAMAgsgAikDECETIAktABAhBkICIRIMAgtCACAIKQMAIhIgEVENABogEiARfachDUIBCyESIAZBCHYhAwsgCSgCvAJBCGoQ3SVB/wFxIQkgAUEjaiADQRB2OgAAIAEgAzsAISABIAs2AkAgASAONgI8IAEgDzYCOCABQQA2AjQgASAQNgIwIAEgDDYCLCABQQA2AiggASAINgIkIAEgBjoAICABQQA2AhwgASANNgIYIAEgEzcDECABIBE3AwggASASNwMAIAEgCToARCACKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACACQQRqEIIsCyACQSBqJAAgB0EQaiQAIARBGGoiASAEQThqKQMANwMAIARBIGoiAiAEQUBrKQMANwMAIAQgBCkDMDcDECAEKQMoIhFCA1IEQCAKQSBqIARByABqQSj8CgAACyAKIAQpAxA3AwggCkEYaiACKQMANwMAIApBEGogASkDADcDACAKIBE3AwAgBEHwAGokAAwDCyACIAhBgNbDABDDIQALIAcgAkGQ1sMAEMMhCwALIAACfyAFKQMYQgNRBEAgBUEQaiAFQTRqKAIANgIAIAUgBSkCLDcDCCAFKAIkIQEgBSgCICECIAUoAigMAQtByABBCBCtNiIBRQ0CIAEgBUEYakHIAPwKAABBCCECQazPwwALNgIIIAAgATYCBCAAIAI2AgAgACAFKQMINwIMIABBFGogBUEQaigCADYCAAsgBUHgAGokAA8LQQhByAAQoz0AC94FAgh/AX4jAEEQayIGJAACQAJAAkACQAJAAkACQEEBIAEpAwAiDKdBAmsgDEIBWBtBAWsOAwECAwALQQAhAyMAQRBrIgUkAAJAAkACQAJAAkAgAUEIaiIEKAIUIgcgAiACIAdLGyIBRQ0AIAQoAhAiAiAEKAIIIghPDQAgBCgCBCEJIAFBAWshCkEAIQEDQCACQQRqIgMgCEsNAiACQXxPDQMgBCACIAlqKAAAIANqIgI2AhAgAUEBaiEDIAIgCE8NASABIApHIAMhAQ0ACwsgACADNgIEIABBCDYCACAEIAcgA2s2AhQMAwsgBUEEakEXQQBBAUEBEKAYIAUoAgghAiAFKAIEQQFGDQEgBSgCDCIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMAgsgAiADQdiNzQAQsTsACyACIAUoAgxB1P3MABD9LwALIAVBEGokAAwFCyADDQMgBkEEakEiQQBBAUEBEKAYIAYoAgghASAGKAIEQQFHDQIgASAGKAIMQdT9zAAQ/S8ACyAAIQMCQAJAIAIgAUEIaiIFKAIIIgQgBSgCHCIBayIAIAAgAksbIgAgAWoiAiAATwRAIAIgBEsNAQJAIABFBEBBACEEDAELIAUoAgQgAUECdGohB0EAIQQgACEBA0AgBygCACAEaiEEIAdBBGohByABQQFrIgENAAsLIAUgAjYCHCADIAA2AgQgA0EINgIAIAUgBSgCICAEajYCIAwCCyABIAJBjI/NABCxOwALIAIgBEGMj80AELA7AAsMAwsgACABQQhqIAIQpAsMAgsgBigCDCICQeSMzQBBIvwKAAAgAEEiNgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAMoAghBAUcEQCAAIAEgAhCQFAwBCyAAQgg3AwALIAZBEGokAAvvAQEEfyMAQUBqIgQkAAJAAkAgASACKAIQEQQAIgUtAABBIEYEQCAFKAIEIgYgBigCACIHQQFqNgIAIAdBAEgNASAEIAYgBSgCCBDOHEEwQQgQrTYiBUUNAiAFQoGAgIAQNwMAIAVBCGogBEEo/AoAACAAIAU2AhwgACACNgIYIAAgATYCFCAAIAMpAgA3AgAgAEEIaiADQQhqKQIANwIAIABBEGogA0EQaigCADYCACAEQUBrJAAPCyAEQQA2AjggBEEBNgIsIARB5KvPADYCKCAEQgQ3AjAgBEEoakHsq88AEO8sCwALQQhBMBCjPQAL4wEBA38jAEGABGsiBCQAIARBDGogASABIAJBA3RqIgVB0MiCARDBGyAEQRhqIgYgBCgCECICIAIgBCgCFEHEAGxqQdDIggEQwBsgBEEkaiAGQQAgAxCjAUEAIQIDQCAEQSRqIgMgAkEAIAEoAgAgAUEEaigCACgCJBEEABDYGyACQQFqIQIgAUEIaiIBIAVHDQALIARBtAJqIgEgA0HMAfwKAAAgBEHwAWoiAiABEOosIAQgAhCgASAAIAQpAwA3AgQgAEGTgICAeDYCACAEQQxqIgAQpCwgABD1PCAEQYAEaiQAC8gBAgJ/AX4jAEEQayIBJAACQAJAAkAgAq0gA61+IgZCIIinDQAgBqciAkEHaiIEIAJJDQAgAyAEQXhxIgRqQQhqIgIgBEkgAkH4////B0tyDQAgAkEIEK02IgUNAUEIIAIQ5S4gACABKQMINwIEIABBADYCAAwCCxDdJyAAIAEpAwA3AgQgAEEANgIADAELIABBADYCDCAAIANBAWsiAjYCBCAAIAQgBWo2AgAgACACIANBA3ZBB2wgAkEISRs2AggLIAFBEGokAAvrAQEJfyMAQUBqIgIkACACQTRqIAEQ2QYgASgCDCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIQIQYgASgCFCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiQhByABKAIgIQggASgCHCEJIAEoAhghCiABKAIoIQQLIAJBCGogAkE8aigCADYCACACIAIpAjQ3AwAgAiAENgIoIAIgBzYCJCACIAg2AiAgAiAJNgIcIAIgCjYCGCACIAM2AhQgAiAGNgIQIAIgBTYCDCACIAEpAiw3AiwgACACEIMTIAJBQGskAA8LAAv3AQEDfyMAQRBrIgUkACACIQMCQAJAAkACQCACQT9xIgQEQCACIARrQUBrIgMgAkkNAQtBwAAhBCADQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAIEQCAEIAEgAvwKAAALQRxBBBCtNiIBRQ0DIAEgAzYCGCABQoCAgICACDcCECABIAI2AgwgASAENgIIIAFCgYCAgBA3AgAgACACNgIIIAAgBDYCBCAAIAE2AgAgBUEQaiQADwtBpP+HAUEjQcj/hwEQyyQAC0HY/ocBQSkgBUEPakHM/IcBQYT/hwEQ1R4AC0HAACADEKM9AAtBBEEcEKM9AAuGAgECfyMAQRBrIgIkACABKAJgIQMgAUGAgICAeDYCYAJAAkAgA0GAgICAeEcEQCAAIAFBEGpB0AD8CgAAIAAgAzYCUCAAIAEpAmQ3AlQgAEHcAGogAUHsAGooAgA2AgAMAQsgAkEEakEgQQBBAUEBEKAYIAIoAgghAyACKAIEQQFGDQEgAigCDCIBQRhqQfD0zwApAAA3AAAgAUEQakHo9M8AKQAANwAAIAFBCGpB4PTPACkAADcAACABQdj0zwApAAA3AAAgAEGAgICAeDYCUCAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgALIAJBEGokAA8LIAMgAigCDEGw6M8AEP0vAAvrAQEHfyMAQeAAayIBJAACQAJAAkACQCAAKAIMIgdFDQAgACgCCCICQQRqIQMgAkF7Sw0BIAMgACgCBCIFSw0CIAAoAgAhBiAAIAM2AgggACAHQQFrNgIMIAEgAiAGaigAACACajYCXCABIAU2AlggASAGNgJUIAFBCGoiACABQdQAahDwAyABKAI8QYCAgIB4Rg0AQdAAQQgQrTYiBEUNAyAEQoGAgIAQNwMAIARBCGogAEHIAPwKAAALIAFB4ABqJAAgBA8LIAIgA0G87v4AELE7AAsgAyAFQbzu/gAQsDsAC0EIQdAAEKM9AAvoAQEJfyMAQRBrIgMkACADQQRqIAEQ0AYgASgCDCIFIAUoAgAiAkEBajYCAAJAIAJBAEgNACABKAIUIQYgASgCECEHIAEoAhgiAgRAIAIgAigCACIEQQFqNgIAIARBAEgNASABKAIsIQQgASgCKCEIIAEoAiQhCSABKAIgIQogASgCHCEBCyAAIAMpAgQ3AgAgACAENgIsIAAgCDYCKCAAIAk2AiQgACAKNgIgIAAgATYCHCAAIAI2AhggACAGNgIUIAAgBzYCECAAIAU2AgwgAEEIaiADQQxqKAIANgIAIANBEGokAA8LAAv0AQICfwR+IwBBMGsiAiQAIAJBEGpBuKyGASgCADYCACACQbCshgEpAgA3AwgCQAJAAkAgASABQugHfyIBQugHfn0iBEI/hyIFIAF8IgEgAUKAowV/IgFCgKMFfn0iBkI/hyIHIAF8IgFCxY3U/wd9QoCAgIBwVA0AIAGnQbvyK2oQ8xYiA0UNACACIAVC6AeDIAR8p0HAhD1sNgIsIAIgB0KAowWDIAZ8PgIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAvQAQEDfyMAQTBrIgQkACADKAIsIQYCQAJAIAIEQEGTgICAeCEFIAZFDQIgAiADQSxqEOIIDQIgBEECNgIcIARByPuGATYCGCAEQgE3AiQMAQtBk4CAgHghBSAGRQ0BIAMoAkBFDQEgBEECNgIcIARBkPuGATYCGCAEQgI3AiQgBEGtAzYCFCAEIAFBGGo2AhALIARBrQM2AgwgBCADQRhqNgIIIAQgBEEIajYCICAAQQRqIARBGGoQmQ5BjYCAgHghBQsgACAFNgIAIARBMGokAAuqFAEUfyMAQSBrIgkkAAJAQQRBBBCtNiIQBEAgECABNgIAQQEhEyAJQQE2AhAgCSAQNgIMIAlBATYCCCAJQRRqIQIgAUEoaiEBIwBBMGsiCiQAAkACfwJAAkADQCABLQAAIgNBIkcEQAJAAkACQAJAIANBG2sODgYABwYAAQIAAAAAAAYDAAsgAkEANgIIIAJCgICAgMAANwIADAgLIAEoAgQhAyABKAIIIQEgCkEANgIYIApBADYCCCAKIANBCGoiAzYCKCAKIAMgAUECdGo2AiwgAiENQQAhAyMAQUBqIgQkAAJ/IApBCGoiASgCACICBEAgASgCBCEDIAEoAgwhB0EADAELQQELIQYDQAJAAkACQAJ/AkAgBkUEQCADIAdHDQEgBCACNgIUIAQgASgCCDYCECAEQRBqQQRBBBDgHiABQQA2AgBBASEGDAYLAkAgASgCICICRQ0AIAIgASgCJEYNACABIAJBBGo2AiAgBEEQaiACKAIAQQhqEIMVIAQoAhAiAkGAgICAeEYNACABIAI2AgggASAEKAIUIgI2AgQgASACNgIAIAEgAiAEKAIYQQJ0aiIHNgIMIAIhAwwECwJAIAEoAhAiAgRAIAEoAhQiAyABKAIcIgdHDQEgBCACNgI8IAQgASgCGDYCOCAEQThqQQRBBBDgHiABQQA2AhALIA1BADYCCCANQoCAgIDAADcCACABEP0iDAMLIAEgA0EEaiICNgIUIAcgAmtBAnYhAkEAIQYgAygCAAwBCyABIANBBGoiDjYCBCABKAIcIAEoAhRrQQJ2QQAgASgCEBshAiAHIA5rQQJ2IQYgAygCAAshAyAEQRBqIgVBAyACIAZqIgIgAkEDTRtBAWpBAEEEQQQQoBggBCgCFCECIAQoAhBBAUYNDSAEQQxqIhRBATYCACAEKAIYIgcgAzYCACAEIAc2AgggBCACNgIEIAUgAUEo/AoAACAEQQRqIQsjAEEgayIIJAAgBSgCHCERIAUoAhAhDyAFKAIkIRUgBSgCFCEMIAUoAgghDiAFKAIgIQIgBSgCBCEBIAUoAgwhByAFKAIAIQMDQAJAIANFIQYDQAJAAkACQCAGRQRAIAEgB0cNASAIIAM2AhAgCCAONgIMIAhBDGpBBEEEEOAeIAVBADYCACABIQdBASEGDAQLAkAgAkUEQEEAIQIMAQsgAiAVRg0AIAUgAkEEaiIDNgIgIAhBDGogAigCAEEIahCDFSAIKAIMIgJBgICAgHhHDQIgAyECCwJAIA8EQCAMIBFHDQEgCCAPNgIcIAggBSgCGDYCGCAIQRhqQQRBBBDgHiAFQQA2AhALIAUQ/SIgCEEgaiQADAULIAUgDEEEaiIGNgIUIAwoAgAhEkEAIQMgBiEMDAILIAUgAUEEaiIGNgIEIAEoAgAhEiAGIQEMAQsgBSACNgIIIAUgCCgCECIBNgIEIAUgATYCACAFIAEgCCgCFEECdGoiBzYCDCACIQ4gAyECIAEhA0EAIQYMAQsLIAsoAggiBiALKAIARgRAIAsgBiAHIAFrQQJ2QQAgAxsgESAMa0ECdkEBakEBIA8bakEEQQQQ3CgLIAsgBkEBajYCCCALKAIEIAZBAnRqIBI2AgAMAQsLIA1BCGogFCgCADYCACANIAQpAgQ3AgALIARBQGskAAwBC0EAIQYMAQsLDAcLIAEoAgQhAyABKAIIIQEgCkEANgIYIApBADYCCCAKIANBCGoiAzYCKCAKIAMgAUEDdGo2AiwgAiENQQAhAyMAQUBqIgQkAAJ/IApBCGoiASgCACICBEAgASgCBCEDIAEoAgwhB0EADAELQQELIQYDQAJAAkACQAJ/AkAgBkUEQCADIAdHDQEgBCACNgIUIAQgASgCCDYCECAEQRBqQQRBBBDgHiABQQA2AgBBASEGDAYLAkAgASgCICICRQ0AIAIgASgCJEYNACABIAJBCGo2AiAgBEEQaiACKAIEQQhqEIMVIAQoAhAiAkGAgICAeEYNACABIAI2AgggASAEKAIUIgI2AgQgASACNgIAIAEgAiAEKAIYQQJ0aiIHNgIMIAIhAwwECwJAIAEoAhAiAgRAIAEoAhQiAyABKAIcIgdHDQEgBCACNgI8IAQgASgCGDYCOCAEQThqQQRBBBDgHiABQQA2AhALIA1BADYCCCANQoCAgIDAADcCACABEP0iDAMLIAEgA0EEaiICNgIUIAcgAmtBAnYhAkEAIQYgAygCAAwBCyABIANBBGoiDjYCBCABKAIcIAEoAhRrQQJ2QQAgASgCEBshAiAHIA5rQQJ2IQYgAygCAAshAyAEQRBqIgVBAyACIAZqIgIgAkEDTRtBAWpBAEEEQQQQoBggBCgCFCECIAQoAhBBAUYNDCAEQQxqIhRBATYCACAEKAIYIgcgAzYCACAEIAc2AgggBCACNgIEIAUgAUEo/AoAACAEQQRqIQsjAEEgayIIJAAgBSgCHCERIAUoAhAhDyAFKAIkIRUgBSgCFCEMIAUoAgghDiAFKAIgIQIgBSgCBCEBIAUoAgwhByAFKAIAIQMDQAJAIANFIQYDQAJAAkACQCAGRQRAIAEgB0cNASAIIAM2AhAgCCAONgIMIAhBDGpBBEEEEOAeIAVBADYCACABIQdBASEGDAQLAkAgAkUEQEEAIQIMAQsgAiAVRg0AIAUgAkEIaiIDNgIgIAhBDGogAigCBEEIahCDFSAIKAIMIgJBgICAgHhHDQIgAyECCwJAIA8EQCAMIBFHDQEgCCAPNgIcIAggBSgCGDYCGCAIQRhqQQRBBBDgHiAFQQA2AhALIAUQ/SIgCEEgaiQADAULIAUgDEEEaiIGNgIUIAwoAgAhEkEAIQMgBiEMDAILIAUgAUEEaiIGNgIEIAEoAgAhEiAGIQEMAQsgBSACNgIIIAUgCCgCECIBNgIEIAUgATYCACAFIAEgCCgCFEECdGoiBzYCDCACIQ4gAyECIAEhA0EAIQYMAQsLIAsoAggiBiALKAIARgRAIAsgBiAHIAFrQQJ2QQAgAxsgESAMa0ECdkEBakEBIA8bakEEQQQQ3CgLIAsgBkEBajYCCCALKAIEIAZBAnRqIBI2AgAMAQsLIA1BCGogFCgCADYCACANIAQpAgQ3AgALIARBQGskAAwBC0EAIQYMAQsLDAYLBSABKAIIIQEMAQsLIAIgASgCCEEIahCDFQwDC0EEDAELQQgLIQMgAiABIANqKAIAQQhqEIMVCyAKQTBqJAAgCSgCGCECIAkoAhwiAQRAIAlBCGpBASABQQRBBBDcKCAJKAIQIRMgCSgCDCEQCyABQQJ0IgMEQCAQIBNBAnRqIAIgA/wKAAALIAlBEGoiAiABIBNqNgIAIAlBADYCHCAJQRRqQQRBBBDgHiAAQQhqIAIoAgA2AgAgACAJKQIINwIAIAlBIGokAA8LQQRBBBCjPQALIAIgBCgCGEHAzocBEP0vAAv5BAEJfyMAQSBrIgQkAAJAAkAgASgCCCICRQ0AIAEgAkEBayIGNgIIIAEoAgQiAyAGQQV0aiIHKAIAIgJBCUYNACAEQRxqIAdBHGooAgA2AgAgBEEUaiAHQRRqKQIANwIAIARBDGogB0EMaikCADcCACAEIAcpAgQ3AgQgBCACNgIAIAYEQCAEIANBCBD6KiMAQSBrIgUkACAFQQhqIAEoAgQiCCICQQhqKQMANwMAIAVBEGogAkEQaikDADcDACAFQRhqIAJBGGopAwA3AwAgBSACKQMANwMAQQEhAwJAIAEoAggiAkECayIHQQAgAiAHTxsiBkUEQEEAIQIMAQtBACECA0AgCCACQQV0aiIKIAggAyAJQQV0IAhqQdgAaikDACAIIANBBXRqKQMYV2oiAkEFdGoiAykDADcDACAKQQhqIANBCGopAwA3AwAgCkEQaiADQRBqKQMANwMAIApBGGogA0EYaikDADcDACACQQF0IglBAXIhAyAGIAlLDQALCwJAIAcgCUcEQCACIQMMAQsgCCACQQV0aiIGIAggA0EFdGoiAikDADcDACAGQRhqIAJBGGopAwA3AwAgBkEQaiACQRBqKQMANwMAIAZBCGogAkEIaikDADcDAAsgCCADQQV0aiICIAUpAwA3AwAgAkEYaiAFQRhqKQMANwMAIAJBEGogBUEQaikDADcDACACQQhqIAVBCGopAwA3AwAgASADEJATIAVBIGokAAsgACAEKQMANwMAIABBGGogBEEYaikDADcDACAAQRBqIARBEGopAwA3AwAgAEEIaiAEQQhqKQMANwMADAELIABBCTYCAAsgBEEgaiQAC8kBAQR/IAAgAWohBkEBIQUCQANAIAAgBkYNAQJ/IAAsAAAiAUEATgRAIAFB/wFxIQEgAEEBagwBCyAALQABQT9xIQMgAUEfcSEEIAFBX00EQCAEQQZ0IANyIQEgAEECagwBCyAALQACQT9xIANBBnRyIQMgAUFwSQRAIAMgBEEMdHIhASAAQQNqDAELIARBEnRBgIDwAHEgAC0AA0E/cSADQQZ0cnIiAUGAgMQARg0CIABBBGoLIQAgAhDuEiABRg0AC0EAIQULIAUL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDLJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqEMwnIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/ABAQF/IABBmANqEJUMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAuwCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQewCahDZIQsgAEGgAmoQzScgAEG4AmoQsiwgAEHgAmoQtDAgACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LgJAIAAoAvABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABB8AFqELsjCyAAQaABahDZFSAAQfgBahCVDAsL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDOJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqEM8nIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/ABAQF/IABBmANqEJUMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAuwCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQewCahDZIQsgAEGgAmoQ0CcgAEG4AmoQsiwgAEHgAmoQtDAgACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LgJAIAAoAvABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABB8AFqELsjCyAAQaABahDZFSAAQfgBahCVDAsL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDRJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqENInIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/oBAgJ/AX4jAEGgAWsiAiQAIAEoAgghAyABQYCAgIB4NgIIAkAgA0GAgICAeEcEQCABKQMAIQQgAiADNgIIIAIgBDcDACACQQxqIAFBDGpB7AD8CgAAIAJB/ABqIAIQ/RAgAigChAEiAUEDTQ0BIAIoAoABIAFBBGs2AAAgAkGQAWogAkGEAWooAgA2AgAgAiACKQJ8NwOIASAAQQRqIAJBiAFqEOcVIABBCDYCACACQaABaiQADwtBiJ3OAEEkQaydzgAQyyQACyACQQA2ApgBIAJBATYCjAEgAkHcnc4ANgKIASACQgQ3ApABIAJBiAFqQeSdzgAQ7ywAC+QBAQV/IAAoAiAiAkUEQEEADwsgACACQQFrNgIgAkACQCAAEM0jIgMEQCADKAIEIQACQAJAIAMoAggiBCADKAIAIgEvAQZJBEAgASECDAELA0AgASgCACICRQ0CIABBAWohACABLwEEIQQgBCACIgEvAQZPDQALCyAEQQFqIQEgAA0CIAIhBQwDC0HI4NAAELI7AAtB2ODQABCyOwALIAIgAUECdGpBFGohAQNAIAEoAgAiBUEUaiEBIABBAWsiAA0AC0EAIQELIAMgATYCCCADQQA2AgQgAyAFNgIAIAIgBGpBCGoL6wECBn8BfiMAQSBrIgEkACAALQAYIQIgASAAKQMQIgc3AwAgAkEDdiEDAkACQCACQcgASQRAIAAoAgQiBSAAKAIMIgYgACgCCGoiBGsgA0kNASAEIAVLDQIgAwRAIAAoAgAgBGogASAD/AoAAAsgACACQQdxOgAYIAAgAyAGajYCDCAAIAcgAq1C+ACDiEIAIAJBwABJGzcDECABQSBqJAAPCyADQQhBjNz7ABCwOwALIAFBADYCGCABQQE2AgwgAUGswvsANgIIIAFCBDcCECABQQhqQZzc+wAQ7ywACyAEIAVBnNz7ABCvOwAL0gEBBn8gACAAKAIoIgIQhC4gACgCCCEBIAAgAgR/IAIEQCAAKAIEIAFqQQAgAvwLAAsgASACagUgAQs2AgggAEEMaiIDEOY6IAAoAgwEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiAiAAKAIYIgFLBEAgAiABayEFIAAoAhAiBiACSQRAIAMgBkEBdCIBIAIQzSoiAyABIANLGxDoGSAAKAIYIQELIAUEQCAAKAIUIAFqQQAgBfwLAAsgACACNgIYCyAAIAQ2AhwPC0Howf8AELI7AAvmAQEFfyMAQRBrIgUkACABKAIIIgJBBGohAwJAAkACQCACQXtNBEAgAyABKAIEIgRLDQEgBUEEaiIGIAEoAgAiAyAEIAIgAiADaigAAGsQ9jQCQCAGQQgQzCBB//8DcSIBRQRAIABBADYCAAwBCyABIAJqIgFBBGohAiABQXtLDQMgAiAESw0EIAAgBDYCBCAAIAM2AgAgACABIANqKAAAIAFqNgIICyAFQRBqJAAPCyACIANB0MzMABCxOwALIAMgBEHQzMwAELA7AAsgASACQcDMzAAQsTsACyACIARBwMzMABCwOwAL8gEBAX8jAEHwAGsiBCQAIAQgAToABwJAAkACQAJAIAFB/wFxQQJrDgIBAgALIARBATYCDCAEQdyvzgA2AgggBEIBNwIUIARBrgM2AmwgBCAEQegAajYCECAEIARBB2o2AmggBEEIakHkr84AEO8sAAsgBEEANgJAIARCADcDOCAEQQA2AhggBCADOgBEIARCADcDCCAEQQhqIgEgAhDKDyAAIAFBwAD8CgAADAELIAAgAzoAKCAAQgI3AwAgACACKQIANwMIIABBGGpCADcDACAAQSBqQgA3AwAgAEEQaiACQQhqKQIANwMACyAEQfAAaiQAC+ABAQF/IABB0AJqEJ0MIABBsAJqELwqIABBuAJqELQwIABBxAJqELQwIAAoAqACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaACahDZIQsgAEGIAmoQ3jsgAEHgAWoQsiwgAEGUAmoQtDAgACkDAEIFUgRAIAAoAtABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQdABahDZIQsgAEHIAWoQvCogAEHQAGoQlSogABCCLyAAKALAASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHAAWoQ2SELIABBoAFqEPYmCwvgAQEBfyAAQdACahCdDCAAQbACahC8KiAAQbgCahC0MCAAQcQCahC0MCAAKAKgAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGgAmoQ2SELIABBiAJqEOk7IABB4AFqELIsIABBlAJqELQwIAApAwBCBVIEQCAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ2SELIABByAFqELwqIABB0ABqEJUqIAAQgi8gACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqENkhCyAAQaABahD2JgsL4AEBAX8gAEHQAmoQnQwgAEGwAmoQvCogAEG4AmoQtDAgAEHEAmoQtDAgACgCoAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBoAJqENkhCyAAQYgCahDjPCAAQeABahCyLCAAQZQCahC0MCAAKQMAQgVSBEAgACgC0AEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB0AFqENkhCyAAQcgBahC8KiAAQdAAahCVKiAAEIIvIAAoAsABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcABahDZIQsgAEGgAWoQ9iYLC+sBAQF/IAAoAgAiACgCEEGAgICAeEcEQCAAQRBqEN47CyAAQRxqEK4vIAAoAjQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBNGoQhh8LIAAoAihBgICAgHhHBEAgAEEoakEBQQEQ4B4LIABB2ABqIgEQ3BggAUEIQcAAEOAeIAAoAkBBgICAgHhHBEAgAEFAayIBEMYqIAFBBEEMEOAeCyAAKAJMQYCAgIB4RwRAIABBzABqIgEQxyogAUEEQQwQ4B4LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQegAQQgQ+DoLC88BAQJ/IAEoAgAiBEECdEEEaiIFBEAgAEEAIAX8CwALAkAgAwRAIAIgA2ohAwNAIAIgA08EQCAEQQFqIQIgACAEQQJ0aiEDA0AgAkEBayECIAMoAgAgA0EEayEDRQ0ACyABIAI2AgBBACEDQX8hAQNAIAEgAkYNBCAAKAIAIgQgAyADIARJGyEDIABBBGohACABQQFqIQEMAAsABSAAIAItAABBAnRqIgUgBSgCAEEBajYCACACQQFqIQIMAQsACwALQQAhAyABQQA2AgALIAMLYAECfyMAQSBrIgMkACADQRRqIAFBAUECQQIQoBggAygCGCEEIAMoAhRBAUcEQCADKAIcIQIgACABNgIIIAAgAjYCBCAAIAQ2AgAgA0EgaiQADwsgBCADKAIcIAIQ/S8AC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQN2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQJ2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQF2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQR2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQV2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC+oBAQt/IwBBMGsiAiQAIAEoAgAiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgASgCECEGIAEoAgwhByABKAIIIQggASgCBCEJIAEoAhQiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNASABKAIoIQQgASgCJCEKIAEoAiAhCyABKAIcIQwgASgCGCEBCyACIAQ2AiwgAiAKNgIoIAIgCzYCJCACIAw2AiAgAiABNgIcIAIgAzYCGCACIAY2AhQgAiAHNgIQIAIgCDYCDCACIAk2AgggAiAFNgIEIAAgAkEEahCtFiACQTBqJAAPCwAL9AECAn8EfiMAQTBrIgIkACACQRBqQY+evPgANgIAIAJCj568+PDhw4cPNwMIAkACQAJAIAEgAULoB38iAULoB359IgRCP4ciBSABfCIBIAFCgKMFfyIBQoCjBX59IgZCP4ciByABfCIBQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAiAFQugHgyAEfKdBwIQ9bDYCLCACIAdCgKMFgyAGfD4CKCACIAM2AiQgAkEYaiACQSRqEMovIAIoAhgiAw0BCyAAQQA2AgAMAQsgACACKQIcNwIEIAAgAzYCAAsgAkEIahDJDCACQTBqJAAL5AEBBH8jAEEQayIBJAAgACgCDCECAkACQAJAAkACQAJAIAAoAgQOAgABAgsgAg0BQQEhA0EAIQAMAgsgAg0AIAAoAgAiAigCBCEAIAIoAgAhAwwBCyABQQRqIAAQmQ4gASgCDCEAIAEoAgghAgwBCyABQQRqIABBAEEBQQEQoBggASgCCCEEIAEoAgRBAUYNASABKAIMIQIgAARAIAIgAyAA/AoAAAsgASAANgIMIAEgAjYCCCABIAQ2AgQLIAIgABCUPiABQQRqEN47IAFBEGokAA8LIAQgASgCDEHg0cwAEP0vAAvNAQEEfyMAQSBrIgIkACAAKAIIIgMgA60gAUIgiH5CIIinIgRLBEAgACgCBCACQRhqQgA3AwAgAkEQakIANwMAIAJBCGpCADcDACACQgA3AwAgAachBUEAIQADQCAAIAJqQQEgAEHs6M4AaigCACAFbEEbdnQ2AgAgAEEEaiIAQSBHDQALIARBBXRqIQNBACEAA0AgACADaiIEIAQoAgAgACACaigCAHI2AgAgAEEEaiIAQSBHDQALIAJBIGokAA8LIAQgA0H06c4AEMMhAAtjAQN/IwBBIGsiAiQAIAJBFGogAUEBQQRBBBCgGCACKAIYIQMgAigCFEEBRwRAIAIoAhwhBCAAIAE2AgggACAENgIEIAAgAzYCACACQSBqJAAPCyADIAIoAhxBxJ7QABD9LwALYwEDfyMAQSBrIgIkACACQRRqIAFBAUEIQRAQoBggAigCGCEDIAIoAhRBAUcEQCACKAIcIQQgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEgaiQADwsgAyACKAIcQazKzQAQ/S8AC+QBAQF/IABB0AJqEJ0MIABBsAJqELwqIABBuAJqELQwIABBxAJqELQwIAAoAqACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaACahDZIQsgAEGIAmpBBEEMEOAeIABB4AFqELIsIABBlAJqELQwIAApAwBCBVIEQCAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ2SELIABByAFqELwqIABB0ABqEJUqIAAQgi8gACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqENkhCyAAQaABahD2JgsL1wEBBn8gAEEYaiIDEOY6IAAoAhgEQCAAKAIoQQFqIgRBA3YgBEEHcUEAR2oiAiAAKAIkIgFLBEAgAiABayEFIAAoAhwiBiACSQRAIAMgBkEBdCIBIAIQzSoiAyABIANLGxDoGSAAKAIkIQELIAUEQCAAKAIgIAFqQQAgBfwLAAsgACACNgIkCyAAIAQ2AiggACgCCCEBIAAoAhQiAiAAKAIMRgRAIABBDGpBgL7/ABCdKAsgACgCECACQQJ0aiABNgIAIAAgAkEBajYCFA8LQejB/wAQsjsAC9kBAgZ/AX4gAEEYaiIDEOY6IAAoAhgEQCAAKAIoQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIkIgJLBEAgASACayEFIAAoAhwiBiABSQRAIAMgBkEBdCICIAEQzSoiAyACIANLGxDoGSAAKAIkIQILIAUEQCAAKAIgIAJqQQAgBfwLAAsgACABNgIkCyAAIAQ2AiggADUCCCEHIAAoAhQiASAAKAIMRgRAIABBDGpBgL7/ABCzKAsgACgCECABQQN0aiAHNwMAIAAgAUEBajYCFA8LQejB/wAQsjsAC2MBA38jAEEgayICJAAgAkEUaiABQQFBBEEIEKAYIAIoAhghAyACKAIUQQFHBEAgAigCHCEEIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBIGokAA8LIAMgAigCHEGQ7oMBEP0vAAuiBwILfwF+IwBBIGsiBiQAIAEoAgghAiAGQRRqAn8gASgCACIEBEAgASgCBCAEa0EYbiIEIAJFDQEaIAEoAgwgAmtBGG4gBGoMAQtBACACRQ0AGiABKAIMIAJrQRhuC0EAQQRBGBCgGCAGKAIYIQIgBigCFEEBRgRAIAIgBigCHEGUvMMAEP0vAAsgBkEQaiILQQA2AgAgBiAGKAIcNgIMIAYgAjYCCCAGQQhqIQIjAEEQayIJJAAgASgCCCEEAkACQAJ/IAEoAgAiAwRAIAEoAgQgA2tBGG4iAyAERQ0BGiABKAIMIARrQRhuIANqDAELIARFBEAgAkEIaiEDDAILIAEoAgwgBGtBGG4LIQcgAkEIaiEDIAcgAigCACACKAIIIgRrTQ0BIAIgBCAHQQRBGBDQKAsgAigCCCEECyAJIAIoAgQ2AgwgCSAENgIIIAkgAzYCBCAJQQRqIQgjAEEwayICJAACQCABKAIAIgRFDQAgASgCBCEDIAIgCDYCACADIARGDQAgAyAEa0EYbiEHA0AjAEEwayIDJAAgAigCACEFIANBGGogBBDdIAJAIAQoAgxBgICAgHhHBEAgA0EkaiAEQQxqEN0gDAELIANBgICAgHg2AiQLIANBCGoiCiADQSBqKAIANgIAIANBFGogA0EsaigCADYCACADIAMpAhgiDTcDACADIAMpAiQ3AgwgBSAFKAIEIgxBAWo2AgQgBSgCCCAMQRhsaiIFIA03AgAgBUEIaiAKKQMANwIAIAVBEGogA0EQaikDADcCACADQTBqJAAgBEEYaiEEIAdBAWsiBw0ACwsCQCABKAIIIgUEQCAIKAIEIQMgCCgCACABKAIMIgEgBUcEQCAFQQxqIQcgCCgCCCADQRhsaiEEIAMgASAFa0EYbiIBaiEDIAJBDGohCANAIAJBGGogB0EMaxDdIAJAIAcoAgBBgICAgHhHBEAgAkEkaiAHEN0gDAELIAJBgICAgHg2AiQLIAggAikCJDcCACACQQhqIgUgAkEgaigCADYCACAIQQhqIAJBLGooAgA2AgAgAiACKQIYIg03AwAgBEEQaiACQRBqKQMANwIAIARBCGogBSkDADcCACAEIA03AgAgB0EYaiEHIARBGGohBCABQQFrIgENAAsLIAM2AgAMAQsgCCgCACAIKAIENgIACyACQTBqJAAgCUEQaiQAIABBCGogCygCADYCACAAIAYpAgg3AgAgBkEgaiQAC80BAgJ/An4jAEHwAGsiBCQAIAQgATYCDCAEQRBqIgFBABCVJCAEQUBrIgUgAiABIAMQnBAgBEHYAGogBEEMaiAFIAMQ2goCQCAEKAJYIgJBk4CAgHhHBEAgBCkCXCEGIAQpAmQhByAAQYCAgIB4NgIoIAAgBzcCDCAAIAY3AgQgACACNgIAIAEQ7SYgBEEwahDjPAwBCyAEKAIMIQEgAEEIaiAEQRBqQTD8CgAAIABBADoAPCAAIAE2AjggACADKQEANwMACyAEQfAAaiQAC4AEAQV/IwBBIGsiAyQAAkACQAJAIAEtADxFBEAgA0EMaiEGIAFBOGohBCMAQTBrIgIkAAJAAkACQAJAAkAgAS8BAiIFDgUBAQECAwALIAIgBTsBDiACQQE2AhQgAkGkvswANgIQIAJCATcCHCACQfgCNgIsIAIgAkEoajYCGCACIAJBDmo2AiggAkEQakGsvswAEO8sAAsgAkEANgIgIAJBATYCFCACQeS9zAA2AhAgAkIENwIYIAJBEGpB7L3MABDvLAALIAQoAgAhBUEIIQQgAS0ABEUEQCAFQfy9zABBBBChNkEEIQQLIAJBADYCECAFIAJBEGpBBBChNgwBCyAEKAIAIgRB/L3MAEEEEKE2IAJBADYCECAEIAJBEGpBBBChNkEIIQQLIAZBk4CAgHg2AgAgBiAENgIEIAJBMGokACADKAIMIgJBk4CAgHhGDQEgACADKQIUNwIIIABBEGogA0EcaigCADYCACAAIAMoAhA2AgQgACACNgIADAILIANBDGpBNEEAQQFBARCgGCADKAIQIQEgAygCDEEBRg0CIAMoAhQiAkHKv8wAQTT8CgAAIABBNDYCDCAAIAI2AgggACABNgIEIABBjICAgHg2AgAMAQsgAEGTgICAeDYCACABQQE6ADwLIANBIGokAA8LIAEgAygCFEHsu8wAEP0vAAuvAgEFfyMAQTBrIgIkAAJAAkAgARCPFSIEBEAgBC0AACEFIAJBDGoiBEEIIAEoAiBBAWoiA0F/IAMbIgMgA0EITRtBAEEBQQEQoBggAigCECEDIAIoAgxBAUYNAiACKAIUIgYgBToAACACQQhqIgVBATYCACACIAY2AgQgAiADNgIAIAQgAUEk/AoAACAEEI8VIgEEQANAIAEtAAAhAyACKAIIIgEgAigCAEYEQCACIAEgBCgCIEEBaiIGQX8gBhtBAUEBENAoCyACKAIEIAFqIAM6AAAgAiABQQFqNgIIIAQQjxUiAQ0ACwsgAEEIaiAFKAIANgIAIAAgAikCADcCAAwBCyAAQQA2AgggAEKAgICAEDcCAAsgAkEwaiQADwsgAyACKAIUQZTvzgAQ/S8AC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBAUEBEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAv3AQECfyMAQRBrIgIkAAJAAkAgASgCAEECRwRAIAJBBGpBHkEAQQFBARCgGCACKAIIIQMgAigCBEEBRg0CIAIoAgwiAUEWakGWwc8AKQAANwAAIAFBEGpBkMHPACkAADcAACABQQhqQYjBzwApAAA3AAAgAUGAwc8AKQAANwAAIABBHjYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACQQxqIgNBADYCACACQoCAgIDAADcCBCABIAJBBGoQywcgAEEINgIAIABBDGogAygCADYCACAAIAIpAgQ3AgQLIAJBEGokAA8LIAMgAigCDEHko88AEP0vAAvSAQEBfyAAIAFBLPwKAAAgAgRAIAAgASgCACACQQN0ajYCBCAAIAAoAgggABDsH2o2AggLAkAgASgCJEUNACACIAEoAigiBE0gAyAET3FFBEAgAEEANgIkDAELIAAgACgCKCACazYCKAsgACABKAIAIAJBA3RqNgIAIAAgASgCACIEIANBA3RqNgIEIAEoAgQgBGtBA3UgA0cEQCAAIAAoAgggABDsH2o2AgwLIAAgACgCECACajYCECAAIAAoAhQgAmo2AhQgACAAKAIYIAJqNgIYC2MBA38jAEEgayICJAAgAkEUaiABQQFBBEEEEKAYIAIoAhghAyACKAIUQQFHBEAgAigCHCEEIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBIGokAA8LIAMgAigCHEHEqPsAEP0vAAvTAQEHfyMAQYAQayIDJAADQCACIANqQgI3AgAgAkEIaiICQYAQRw0ACwJAAkAgASgCBCICBEAgASgCACEGIAJBAnQhByABKAIIIQggASgCDCEEIAMhAUEAIQIDQCAEIAIgBmooAgAiBUkNAyACQQRqIgJBhAhGDQIgAUEEaiAEIAVrNgIAIAEgCCAFQQJ0ajYCACABQQhqIQEgAiAHRw0ACwsgACADQYAQ/AoAACADQYAQaiQADwtBgAJBgAJB8N/zABDDIQALIAUgBEHg3/MAEK87AAvOAQICfwJ+AkACQAJAAkAgAARAAkBBfyECIACtIgUhBANAIAJBAWohAiAEQv8AViAEQgeIIQQNAAsgAkEKTw0FIABBgAFJDQBBACECIAUhBANAIAJBCkYNBCABIAJqIASnQYABcjoAACACQQFqIQIgBEL//wBWIARCB4giBSEEDQALDAILC0EAIQILIAJBCkkNASACQQpB8LT+ABDDIQALQQpBCkGAtf4AEMMhAAsgASACaiAFPAAAIAJBAWoPC0GstP4AQTRB4LT+ABCfKQAL3QEBA38jAEEgayIEJAACQAJAAkAgAQRAIARBFGogAkEAQQRBBBCgGCAEKAIYIQUgBCgCFEEBRg0CIARBEGoiBkEANgIAIAQgBCgCHDYCDCAEIAU2AgggBEEIaiACIAEQih8gAEEIaiAGKAIANgIAIAAgBCkCCDcCAAwBCyAEQRRqIAJBAUEEQQQQoBggBCgCGCEBIAQoAhRBAUYNAiAEKAIcIQMgACACNgIIIAAgAzYCBCAAIAE2AgALIARBIGokAA8LIAUgBCgCHCADEP0vAAsgASAEKAIcIAMQ/S8AC+QDAgh/An4gASgCAEEBRgRAIAEpAwghCyABKAIQIQYgASgCFCEEIAIoAgghAyACKAIEIQUgAigCACIBEN48IQogASAFIAMQoTYCQCABKAIYBEAgASgCKCIFQQFqIghBA3YgCEEHcUEAR2oiAiABKAIkIgNLBEAgAiADayEJIAEoAhwiByACSQRAIAFBGGogB0EBdCIDIAJBwP///wNxQUBrIAIgAkE/cRsiByADIAdLGxDoGSABKAIkIQMLIAkEQCABKAIgIANqQQAgCfwLAAsgASACNgIkCyABIAg2AiggASgCICAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAQsgASABKAIsQQFqNgIsCyABNQIIIQwgASgCFCICIAEoAgxGBEAgAUEMakHotYABELMoCyABKAIQIAJBA3RqIAw3AwAgASACQQFqNgIUIAYgBCgCACIBaiICLQAAIQMgAiALp0EZdiICOgAAIAEgBCgCBCAGQQhrcWpBCGogAjoAACAAIAQ2AgwgACALNwMAIAQgBCgCDEEBajYCDCAAIAEgBkECdGsiADYCCCAEIAQoAgggA0EBcWs2AgggAEEEayAKNgIADwsgACABQQhqIgEpAwA3AwAgAEEIaiABQQhqKQMANwMAC+QDAgh/AX4gASgCAEEBRgRAIAEpAwghCyABKAIQIQYgASgCFCEEIAIoAgghAyACKAIEIQUgAigCACIBEN48IQogASAFIAMQoTYCQCABKAIYBEAgASgCKCIFQQFqIghBA3YgCEEHcUEAR2oiAiABKAIkIgNLBEAgAiADayEJIAEoAhwiByACSQRAIAFBGGogB0EBdCIDIAJBwP///wNxQUBrIAIgAkE/cRsiByADIAdLGxDoGSABKAIkIQMLIAkEQCABKAIgIANqQQAgCfwLAAsgASACNgIkCyABIAg2AiggASgCICAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAQsgASABKAIsQQFqNgIsCyABKAIIIQMgASgCFCICIAEoAgxGBEAgAUEMakHotYABEJ0oCyABKAIQIAJBAnRqIAM2AgAgASACQQFqNgIUIAYgBCgCACIBaiICLQAAIQMgAiALp0EZdiICOgAAIAEgBCgCBCAGQQhrcWpBCGogAjoAACAAIAQ2AgwgACALNwMAIAQgBCgCDEEBajYCDCAAIAEgBkECdGsiADYCCCAEIAQoAgggA0EBcWs2AgggAEEEayAKNgIADwsgACABQQhqIgEpAwA3AwAgAEEIaiABQQhqKQMANwMAC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBCEEIEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAvjAQEFfwJAAkACQCABKAIAIgMgAigCACIFKAIEIgJJBEAgAUEEayIGKAIAIgEgAk8NASAFKAIAIgIgA0EDdCIHaikDACACIAFBA3RqKQMAUwRAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgAyAFKAIEIgRPDQUgAkEEayIGKAIAIgEgBE8NBiAFKAIAIgQgB2opAwAgBCABQQN0aikDAFMNAQsLIAIgAzYCAAsPCyADIAJBqL+DARDDIQALIAEgAkG4v4MBEMMhAAsgAyAEQai/gwEQwyEACyABIARBuL+DARDDIQAL4wEBBX8CQAJAAkAgASgCACIDIAIoAgAiBSgCBCICSQRAIAFBBGsiBigCACIBIAJPDQEgBSgCACICIANBAnQiB2ooAgAgAiABQQJ0aigCAEgEQANAAkAgBiICQQRqIAE2AgAgACACRg0AIAMgBSgCBCIETw0FIAJBBGsiBigCACIBIARPDQYgBSgCACIEIAdqKAIAIAQgAUECdGooAgBIDQELCyACIAM2AgALDwsgAyACQai/gwEQwyEACyABIAJBuL+DARDDIQALIAMgBEGov4MBEMMhAAsgASAEQbi/gwEQwyEAC+MBAQV/AkACQAJAIAEoAgAiAyACKAIAIgUoAgQiAkkEQCABQQRrIgYoAgAiASACTw0BIAUoAgAiAiADQQJ0IgdqKAIAIAIgAUECdGooAgBJBEADQAJAIAYiAkEEaiABNgIAIAAgAkYNACADIAUoAgQiBE8NBSACQQRrIgYoAgAiASAETw0GIAUoAgAiBCAHaigCACAEIAFBAnRqKAIASQ0BCwsgAiADNgIACw8LIAMgAkGov4MBEMMhAAsgASACQbi/gwEQwyEACyADIARBqL+DARDDIQALIAEgBEG4v4MBEMMhAAvjAQEFfwJAAkACQCABKAIAIgMgAigCACIFKAIEIgJJBEAgAUEEayIGKAIAIgEgAk8NASAFKAIAIgIgA0EDdCIHaikDACACIAFBA3RqKQMAVARAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgAyAFKAIEIgRPDQUgAkEEayIGKAIAIgEgBE8NBiAFKAIAIgQgB2opAwAgBCABQQN0aikDAFQNAQsLIAIgAzYCAAsPCyADIAJBqL+DARDDIQALIAEgAkG4v4MBEMMhAAsgAyAEQai/gwEQwyEACyABIARBuL+DARDDIQALuwQBCn8jAEFAaiICJAAgAkGTgICAeDYCCCACQThqIAFBEGooAgA2AgAgAkEwaiABQQhqKQIANwMAIAIgASkCADcDKCACIAJBCGo2AjwgAkEcaiEFIwBBMGsiASQAIAEgAkEoaiIDEK4hAkACQAJAIAEoAgAiBwRAIAEoAgQhCCABQRhqIglBBEEAQQRBCBCgGCABKAIcIQQgASgCGEEBRg0CIAEoAiAiBiAINgIEIAYgBzYCACABQRRqIgpBATYCACABIAY2AhAgASAENgIMIAFBKGogA0EQaikCADcDACABQSBqIANBCGopAgA3AwAgASADKQIANwMYIwBBEGsiAyQAIANBCGogCRCuISADKAIIIgYEQCABQQxqIQQgAygCDCEHA0AgBCgCCCIIIAQoAgBGBEAgBEEBEOotCyAEKAIEIAhBA3RqIgsgBzYCBCALIAY2AgAgBCAIQQFqNgIIIAMgCRCuISADKAIEIQcgAygCACIGDQALCyADQRBqJAAgBUEIaiAKKAIANgIAIAUgASkCDDcCAAwBCyAFQQA2AgggBUKAgICAwAA3AgALIAFBMGokAAwBCyAEIAEoAiBBiPmDARD9LwALAkAgAigCCEGTgICAeEcEQCAAIAIpAgg3AgAgAEEQaiACQRhqKAIANgIAIABBCGogAkEQaikCADcCACAFEMMnIAUQ6jsMAQsgACACKQIcNwIEIABBk4CAgHg2AgAgAEEMaiACQSRqKAIANgIACyACQUBrJAAL3gEBCX8jAEEQayICJAAgASgCBCEDIAJBBGogASgCCCIGQQBBBEEIEKAYIAIoAgghBAJAIAIoAgRBAUcEQCACKAIMIQcCQCAERQ0AIAZBA3QhBSAHIQEgBCEIA0AgBUUNASADKAIAIgkgCSgCACIKQQFqNgIAIApBAEgNAyABQQRqIAMoAgQ2AgAgASAJNgIAIAFBCGohASAFQQhrIQUgA0EIaiEDIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAQ2AgAgAkEQaiQADwsgBCACKAIMQcTmhAEQ/S8LAAv6AQECfyMAQaACayICJAAgAkHsAWogAUEIaigCADYCACACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAkEAOwGcAiACQQA2ApgCIAJBADYCgAIgAkEANgL0ASACIAEpAgA3AuQBIAIgASgCFDYC8AEgAkHoAGogAkHEAWogAUEYahDCGUEMQQQQrTYiA0UEQEEEQQwQoz0ACyADIAEpAgw3AgAgA0EIaiABQRRqKAIANgIAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiASACQegAaiACQcQBahCWKSAAIAEQzRwgAkGgAmokAAveAQEJfyMAQRBrIgIkACABKAIEIQMgAkEEaiABKAIIIgZBAEEEQQwQoBggAigCCCEEAkAgAigCBEEBRwRAIAIoAgwhBwJAIARFDQAgBkEMbCEFIAchASAEIQgDQCAFRQ0BIAMoAgAiCSAJKAIAIgpBAWo2AgAgCkEASA0DIAFBBGogAykCBDcCACABIAk2AgAgAUEMaiEBIAVBDGshBSADQQxqIQMgCEEBayIIDQALCyAAIAY2AgggACAHNgIEIAAgBDYCACACQRBqJAAPCyAEIAIoAgxByIqHARD9LwsAC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBBEEEEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAvkAQEEfyMAQSBrIgMkACAAKAIAIgAoAgAhBCAAQQA2AgACQCAEQQFxBEAgA0EYaiIEIABBHGopAgA3AwAgA0EQaiIFIABBFGopAgA3AwAgA0EIaiIGIABBDGopAgA3AwAgAyAAKQIENwMAQcwAQQQQrTYiAEUNASAAIAMpAwA3AgAgAEEAOgBIIAAgAjYCJCAAIAE2AiAgAEEYaiAEKQMANwIAIABBEGogBSkDADcCACAAQQhqIAYpAwA3AgAgAEHk3MMAENQaIANBIGokAA8LQebZwwBBMRCXPQALQQRBzAAQoz0AC80BAQl/IAAgACgCBEEYdiIDIAAoAgBBGHYiBUlBAnRqIgIgAEEMQQggAC0ADyAALQALSSIGG2oiBCAAIAMgBU9BAnRqIgMgAEEIQQwgBhtqIgAtAAMgAy0AA0kiBRsgBCgCACIHQRh2IAIoAgAiCEEYdkkiAhsiBi0AAyEJIAAgAyAEIAIbIAUbIgQtAAMhCiABIAcgCCACGzYCACABIAQgBiAJIApLIgIbKAIANgIEIAEgBiAEIAIbKAIANgIIIAEgAyAAIAUbKAIANgIMC+0BAgR/AX4jAEEgayICJAAgAkEMaiABEKURIAIoAhghASACKAIUIQMgAigCECEEAkAgAigCDCIFQQRHBEAgACACKAIcNgIQIAAgATYCDCAAIAM2AgggACAENgIEIAAgBTYCAAwBCyACQQxqIAMgARCdCQJAAkAgAigCDEUEQCABrSEGIAMhAQwBCyACKQIQIQYgBEGAgICAeEcNASADIQQLIAAgBj4CDCAAIAE2AgggACAENgIEIABBBDYCAAwBCyACIAY3AhggAiABNgIUIAIgAzYCECACIAQ2AgwgACACQQxqEMgcCyACQSBqJAAL8gEBAn8gACgCCCICBEAgACgCBCEAA0ACQAJAAkACQAJAAkACQAJAAkAgACgCAA4ICAECAwQFBgcACyAAQQRqEMUqDAcLIABBBGoiARDiKSABQQhBMBDgHgwGCyAAQQRqIgEQ4ykgAUEIQTgQ4B4MBQsgAEEEaiIBEOEpIAFBCEHIABDgHgwECyAAQQRqIgEQ4SkgAUEIQcgAEOAeDAMLIABBBGoiARDjKSABQQhBOBDgHgwCCyAAQQRqIgEQ4SkgAUEIQcgAEOAeDAELIABBBGoiARDbGCABQQhB0AAQ4B4LIABBFGohACACQQFrIgINAAsLC9wBAQN/IwBBEGsiBCQAIAAgAjYCCCAAIAE2AgQCfyAALQBSRQRAQQEgAUEaanQgAmpBfyABQQJqdGohBUEYDAELIARCjICAgMADNwIIIARCgICAgMAANwIAAkAgAUEDTQRAIAQgAUECdGooAgAiAyACTQRAQfz//z8hBSACIANBASABdGpJDQIgAiADa0H8////BWohBQwCCyACIANrQfz//z9qIQUMAQsgAUEEQZSY0gAQwyEAC0E+CyEDIAAgBTYCECAAIAIgAyABQQFqdGpBEGo2AgwgBEEQaiQAC8gBAQR/IwBBEGsiAiQAQQMhAyAALAAAIgQgBMBBB3UiAHMgAGsiAEH/AXEiBUEKTwRAQQEhAyACIABBAXQiACAAQThqIAVB5ABJG0H+AXEiAEHj84kBai0AADoADyACIABB4vOJAWotAAA6AA4gBUHjAEshAAtBACAEIABB/wFxG0UEQCADQQFrIgMgAkENamogAEEBdEH+AXFB4/OJAWotAAA6AAALIAEgBEEATkEBQQAgAkENaiADakEDIANrEIEJIAJBEGokAAvcAQICfwF+IwBBIGsiAyQAIAEoAgwhBCABQYGAgIB4NgIMAkACQCAEQYGAgIB4RwRAIANBGGogAUEYaikCACIFNwIAIAMgBDYCDCADIAEpAhA3AhAgBadBAXFFDQIgACABQQFBAiACGyADLwEaEPoXIANBDGoQhjAMAQsgAkUEQCADQQI6AAwgASgCICADQQxqIANBDWoQvSYgAEEENgIADAELIAEoAiAgA0EBOgAMIANBDGogA0ENahC9JiAAQQQ2AgALIANBIGokAA8LQZDHzgBBIUG0x84AEMskAAvNAQECfyMAQSBrIgQkACAEIAM2AhAgBCACNgIMIARBFGoiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAhQ3AgAgAkEIaiAEQRxqIgUoAgA2AgAgAyAEQQxqEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCFDcCACADQQhqIAUoAgA2AgAgACADNgIIIAAgAjYCBCAAQSI6AAAgAEEMaiABQTD8CgAAIABBADoARCAAIAQpAgw3AjwgBEEgaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvXAQEEfwJAIAQgAyAEaiIFTQRAIAUgACgCBCIGSw0BIAAoAgAhBiABKAIMIgAgBGoiByABKAIEIghLBEAgASAIQQF0IgAgBxDfKiIHIAAgB0sbEOgZIAEoAgwhAAsgBARAIAEoAgggAGogAyAGaiAE/AoAAAsgASABKAIMIARqNgIMIAEoAigiAARAIAEoAiQhASAAQcwBbCEEA0AgASACIAMgBRDYGyABQcwBaiEBIARBzAFrIgQNAAsLDwsgAyAFQYCohwEQsTsACyAFIAZBgKiHARCwOwALywEBCH8jAEEgayIDJAAgACgCFCIEIAAoAhAiBSAEIAVLGyEGIABBDGohByAAKAIMIQgCfwJAA0BBACACRQ0CGiAEIAZGDQEgACAEQQFqIgU2AhQgAkEBayECIAQgCGohCSABLQAAIAUhBCABQQFqIQEgCS0AAEYNAAsgA0EJNgIUIANBCGogByAEEOoMIANBFGogAygCCCADKAIMEPsoDAELIANBBTYCFCADIAcgBhDqDCADQRRqIAMoAgAgAygCBBD7KAsgA0EgaiQAC9gBAQN/IwBBMGsiAiQAIAIgATYCBAJAIAEuARgiBEEATARAIAJBgYCAgHg2AggMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBCGogAkEEaiADEJUSCyAAIAE2AqACIABBADYCkAIgAEKAgICAwAA3A4gCIAEuARohASAAQeABaiACQQhqQSj8CgAAIABCAjcDmAIgAEIANwKkAiAAQgU3AwAgACABQQBMQR90NgKUAiACQTBqJAALyQEBBH8jAEEQayIHJAAgBCAFQT9rIARBP2ogBUsbIgYgBEGABGpJIAQgBk9yRQRAIAAoAhBBD2shCCAAKAIUIQkDQCAHQQA2AgggACABIAIgBCADIAlBgAEgCCAHQQhqQQhBABCDBxogBEEIaiIEIAZJDQALCyAFIAZLBEAgACgCEEEPayEEIAAoAhQhCANAIAdBADYCDCAAIAEgAiAGIAMgCEGAASAEIAdBDGpBCEEAEIMHGiAGQQFqIgYgBUkNAAsLIAdBEGokAAvlCAERfyMAQRBrIg0kACANQQRqIAEoAggiAkH07M4AEM4YIAEoAgQhCCANKAIMIQcgDSgCCCEKAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIMIgRBAmsOBwECAwQFBgcACyAIIQYgAiEJIAohCyAHIQVBACEHAkACQCAEIggEQCACIAhuIRAgCEECdiAIQQNxQQBHaiIRRQ0CDAELQaTqzgAQ4isACwNAIAggCU0EQEEBQQQgBCAEQQRPGyICIAJBAU0bIQxBACEOIAchAgNAAkAgByAIRg0AQQAhDyAMIQMgAiEKAkADQCAJIApNDQEgBSAHIA9qIBBsIA5qIhJLBEAgCyASaiAGIApqLQAAOgAAIA9BAWohDyAKQQFqIQogA0EBayIDRQ0DDAELCyASIAVBxOrOABDDIQALIAogCUG06s4AEMMhAAsgAiAIaiECIA5BAWoiDiAQSQ0ACwsgB0EEaiEHIARBBGshBCARQQFrIhENAAsLDAcLQQAhBCACQQJPBEAgCCEJIAJBAXYhCwNAQQEhCCAEIgVBAXQhDCAFQQFqIQRBACEGAkACQANAIAYgDHIiAyACTw0BIAcgBiALbCAFaiIGSwRAIAYgCmogAyAJai0AADoAAEEBIQYgCEEAIQhFDQMMAQsLIAYgB0GU6s4AEMMhAAsgAyACQYTqzgAQwyEACyAEIAtHDQALCwwGC0EAIQQgAiIJQQNPBEAgAkEDbiEGA0AgBSAIaiELIAQiAkEBaiEEQQAhAwJAA0AgAyAFaiIMIAlPDQsgAiAHSQRAIAIgCmogAyALai0AADoAACACIAZqIQIgA0EBaiIDQQNGDQIMAQsLDAkLIAVBA2ohBSAEIAZHDQALCwwFCyAIIAIgCiAHEKAZDAQLQQAhBCACIglBBU8EQCACQQVuIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NCSACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBBUYNAgwBCwsMBwsgBUEFaiEFIAQgBkcNAAsLDAMLQQAhBCACIglBBk8EQCACQQZuIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NCCACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBBkYNAgwBCwsMBgsgBUEGaiEFIAQgBkcNAAsLDAILQQAhBCACIglBB08EQCACQQduIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NByACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBB0YNAgwBCwsMBQsgBUEHaiEFIAQgBkcNAAsLDAELIAggAiAKIAcQoRkLIAFBADYCCCAAQQRqIA1BBGoQ5xUgAEEINgIAIA1BEGokAA8LIAIgB0GU6s4AEMMhAAsgDCAJQYTqzgAQwyEAC+IBAQJ/IwBBMGsiAyQAIAMgASgCCCIENgIAIAMgAjYCBCACIARNBEACQCACBEAgA0EIaiABQQxqIAEoAgQgBCABKAIAKAIAEQUAIANBEGoiASACNgIAIAAgAykCCDcCACAAQQhqIAEpAgA3AgAMAQsgAEEANgIMIABCATcCBCAAQbTwzgA2AgALIANBMGokAA8LIANBAjYCDCADQbTxzgA2AgggA0ICNwIUIANBiwg2AiwgA0GLCDYCJCADIANBIGo2AhAgAyADNgIoIAMgA0EEajYCICADQQhqQcTxzgAQ7ywAC9YBAQd/IwBBEGsiAiQAIAEoAgQhAyACQQRqIAEoAggiBkEAQQhBGBCgGCACKAIIIQQgAigCBEEBRwRAIAIoAgwhBwJAIARFDQAgBkEYbCEFIAchASAEIQgDQCAFRQ0BIAEgAykDADcDACABQRBqIANBEGopAwA3AwAgAUEIaiADQQhqKQMANwMAIAFBGGohASAFQRhrIQUgA0EYaiEDIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAQ2AgAgAkEQaiQADwsgBCACKAIMQeiZzwAQ/S8AC7kDAgR/AX4jAEEQayIDJAAgAyABNgIEAkADQCADQQhqIQQjAEEQayIBJAAgAUEAOgAHIAFBCGogA0EEaigCACIGIAFBB2pBARDhEgJAAkAgAS0ACCIFQQRGDQADQAJAAkACQAJAAkAgBUEBaw4DAAIBBAsgAS0ACUEjRw0DDAILIAEoAgwtAAhBI0YNAQwCCyABKAIMLQAIQSNHDQELIAFBCGoiBRC5LiAFIAYgAUEHakEBEOESIAEtAAgiBUEERw0BDAILCyAEIAEpAwg3AgAMAQsgASgCDEUEQCAEQQU6AAAMAQsgBCABLQAHOgABIARBBDoAAAsgAUEQaiQAAkACQAJ/AkACQCADLQAIQQRrDgIAAwELIAMtAAkMAQsgAykDCCIHQv8Bg0IEUgRAIAAgBzcCAAwFCyAHQoACg1ANASAHQhCIpwsiBEH/AXENASAAQQQ6AAAMAwsgAEKBygA3AgAMAgsgAigCCCIBQf//A0cEQCACKAIAIAFGBEAgAkGYxdAAEKkZCyACKAIEIAFqIAQ6AAAgAiABQQFqNgIIDAELCyAAQRRBqMXQAEEaEM0aCyADQRBqJAALwAEBCn8gAiABIAEgAkkbIQwgAEEsaiENIAAoAiQiDkEIaiEPIAAoAgQhCCAAKAIoIQkgACgCXCEKA0AgASAMRkUEQCAJAn8gBgRAIA0gCCABIA4gAyAAKQNQEKcoDAELIAEgCGogDyADIAApA1AQ5iMLIgJBCHYgBHQiEGoiC0EAIAUgCy0AAEE/aiAFcSIHGyAHaiIHOgAAIAcgC2ogAjoAACAKIBBBAnRqIAdBAnRqIAE2AgAgAUEBaiEBDAELCwvQAQIBfgF/IAAgAmohBQJAIANFIAAgAWtBD0pyRQRAA0AgACABKQAANwAAIAFBCGohASAAQQhqIgAgBUkNAAwCCwALIAEpAAAhBCAAQQhqIAFBCGopAAA3AAAgACAENwAAIAJBEUgNACABQSBqIQEgAEEQaiEAA0AgAUEQayICKQAAIQQgAEEIaiACQQhqKQAANwAAIAAgBDcAACABKQAAIQQgAEEYaiABQQhqKQAANwAAIABBEGogBDcAACABQSBqIQEgAEEgaiIAIAVJDQALCwvPAgEIfyMAQUBqIgIkACACIAEQ5QsCQAJAIAIoAgAiBQRAIAIoAgQhBiACQRhqIgdBBEEAQQRBCBCgGCACKAIcIQMgAigCGEEBRg0CIAIoAiAiBCAGNgIEIAQgBTYCACACQRRqIghBATYCACACIAQ2AhAgAiADNgIMIAcgAUEo/AoAACACQQxqIQMjAEEQayIBJAAgAUEIaiAHEOULIAEoAggiBARAIAEoAgwhBQNAIAMoAggiBiADKAIARgRAIANBARD/LQsgAygCBCAGQQN0aiIJIAU2AgQgCSAENgIAIAMgBkEBajYCCCABIAcQ5QsgASgCBCEFIAEoAgAiBA0ACwsgAUEQaiQAIABBCGogCCgCADYCACAAIAIpAgw3AgAMAQsgAEEANgIIIABCgICAgMAANwIACyACQUBrJAAPCyADIAIoAiBBuJeAARD9LwAL/gEBAn8jAEEgayIEJAAgBCABKAIAIgUoAgAgASgCBCACIAMgBSgCBCgCDBEHAAJAAkACQAJAIAQoAgBB7f///wdqDgICAAELIABBk4CAgHg2AgAMAgsgACAEKQIANwIAIABBEGogBEEQaigCADYCACAAQQhqIARBCGopAgA3AgAMAQsgBEEUakEMQQBBAUEBEKAYIAQoAhghASAEKAIUQQFGBEAgASAEKAIcQbiHgQEQ/S8ACyAEKAIcIgJBCGpB44mBASgAADYAACACQduJgQEpAAA3AAAgAEEMNgIMIAAgAjYCCCAAIAE2AgQgAEGCgICAeDYCAAsgBEEgaiQAC5EGAQp/IwBBQGoiBCQAIAQgARCSNjYCCCACKAIUIQUgAigCECECIAQgATYCPCAEIAI2AjAgBCACIAVBeHFqNgI0IAQgBEEIajYCOCAEQRxqIQYjAEFAaiICJAAgAkGTgICAeDYCCCACQTBqIARBMGoiAUEIaikCADcDACACIAEpAgA3AyggAiACQQhqNgI4IAJBHGohCCMAQTBrIgEkACABQQxqIAJBKGoiBRDzIAJAAkACQCABKAIMQQFGBEAgASgCFCEKIAEoAhAhCyABQRhqIgxBBEEAQQRBCBCgGCABKAIcIQcgASgCGEEBRg0CIAEoAiAiCSAKNgIEIAkgCzYCACABQQhqIgpBATYCACABIAk2AgQgASAHNgIAIAFBKGogBUEQaigCADYCACABQSBqIAVBCGopAgA3AwAgASAFKQIANwMYIwBBEGsiBSQAIAVBBGogDBDzICAFKAIEQQFGBEADQCAFKAIMIQkgBSgCCCELIAEoAggiByABKAIARgRAIAEgB0EBQQRBCBDeKAsgASgCBCAHQQN0aiINIAk2AgQgDSALNgIAIAEgB0EBajYCCCAFQQRqIAwQ8yAgBSgCBA0ACwsgBUEQaiQAIAhBCGogCigCADYCACAIIAEpAgA3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyABQTBqJAAMAQsgByABKAIgQYj5gwEQ/S8ACwJAIAIoAghBk4CAgHhHBEAgBiACKQIINwIAIAZBEGogAkEYaigCADYCACAGQQhqIAJBEGopAgA3AgAgCBDqOwwBCyAGIAIpAhw3AgQgBkGTgICAeDYCACAGQQxqIAJBJGooAgA2AgALIAJBQGskACAEKAIoIQIgBCgCJCEBIAQoAiAhBQJAIAQoAhwiBkGTgICAeEcEQCAAIAQoAiw2AhQgACACNgIQIAAgATYCDCAAIAU2AgggACAGNgIEIABBKToAAAwBCyAEIAU2AhQgBCABNgIMIAQgATYCECAEIAEgAkEDdGo2AhggACAEQQxqIAMQugYLIARBQGskAAvUAQEIfyMAQUBqIgIkACACQTRqIAFBDGoQ1wYgASgCGCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIgIQYgASgCHCEHIAEoAiQiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNASABKAIoIQggASgCLCEECyACQQRqIgkgARDhFCACQRhqIAJBPGooAgA2AgAgAiAENgIwIAIgCDYCLCACIAM2AiggAiAGNgIkIAIgBzYCICACIAU2AhwgAiACKQI0NwIQIAAgCRDtDSACQUBrJAAPCwAL3wECAn8EfiMAQTBrIgIkACACQRBqQdSthgEoAgA2AgAgAkHMrYYBKQIANwMIAkACQCABIAFCwIQ9fyIBQsCEPX59IgRCP4ciBSABfCIBIAFCgKMFfyIBQoCjBX59IgZCP4ciByABfKdBu/IrahDzFiIDBEAgAiADNgIkIAIgB0KAowWDIAZ8PgIoIAIgBULAhD2DIAR8p0HoB2w2AiwgAkEYaiACQSRqEMovIAIoAhgiAw0BCyAAQQA2AgAMAQsgACACKQIcNwIEIAAgAzYCAAsgAkEIahDJDCACQTBqJAAL6QEBAX8jAEEQayIWJAAgACgCACABQQ0gACgCBCgCDBEGACEBIBZBADoADSAWIAE6AAwgFiAANgIIIBZBCGogAiADIAQgBRCIEiAGIAcgCCAJEIgSIAogCyAMIA0QiBIgDiAPIBAgERCIEiASIBMgFCAVEIgSIQEgFi0ADSICIBYtAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIBZBEGokACAAQQFxC9IBAQF/IAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQlxULAkAgACgCQCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQUBrENseCwJAIAAoAgBFBEAgACgCECIBQYQBSQ0BIAEQ8h8MAQsgAEEQahDeOyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEJ0nCyAAQTBqEJ4vAkAgACgCRCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQcQAahCBLAsLxQEBAX4gACkDACIBQgdSBEAgAUIGUQRAIABBCGoQkSoPCwJAAkACQAJAQQEgAadBAmsgAUIBWBsOAwECAwALIABBCGoQ6TsgAEEUahDpOyAAQThqIAAoAjAgACgCNCAAKAIsKAIQEQEAIABBIGoQ3jsPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKiAAKAJAQYAgQQQQ+DoPCyAAQQhqEOk7IABBIGogACgCGCAAKAIcIAAoAhQoAhARAQALC/QBAQZ/AkAgB0ECcUUEQCAAIAEgAkEBEO0gIQEMAQsgBEHsBWshCyADQewFaiEMQX4hCiAAIQEgBiEHIAJBAWohCQNAIAkEQCAJQQFrIQkgCCAHKAIAQQBHaiEIIAdBBGohBwwBCwtBICAIZ2siCSEHA0AgACAHSQ0BAkAgBSAGIAIgByADIAQQ+AEiCEGIf0sNACAHIAhLIAcgCUtxDQIgDCALIAUgAiAIIAMgBBCkCSIIQYh/Sw0AIAUgBiACEOUjIAhqIgggCkEBaksNAiAHIAEgCCAKSSINGyEBIAggCiANGyEKCyAHQQFqIQcMAAsACyABC/MKAQ1/IAVBACAGQQdLG0UEQEFgQQAgB0ECRhsPCyAAQoSAgICAATcC7CMgAEKAgICAEDcC5CMgAEIANwLcIyAAQQA2AoQIAkAgB0EBRg0AAkACQCAFKAAAQbfIwuF+Rg0AQWAhEwJAIAcOAwABAgELDAILQQAhEyAEKAIoRQRAIAUoAAQhEwsjAEHAAWsiDSQAIABBATYChAggDUEfNgJ8IA1B/wE2AhAgDUEBNgKAASANQRBqIRUgDUGAAWohByMAQZADayIMJAAgDEEANgJMIAxBADYCSCMAQfAGayICJAAgDEGQAWogDEHQAGogDEHIAGogDEHMAGogBUEIaiIWIAZBCGsgAhDxDCERIAJB8AZqJAACQCARQYh/Sw0AIAcgDCgCUEEARzYCACAMKAJMIg5BDEsEQEFUIREMAQsgDCgCSCIHIBUoAgBBAWpLBEBBUCERDAELIABBBGohECAAIA42AgAgDkEBaiEXIAxB0ABqQQRyIQIgDiELQQEhEgNAIAsEQCACKAIAIAIgDzYCACACQQRqIQIgC0EBayELIBJBAWt0IA9qIQ8gEkEBaiESDAEFIA5BAWohEiAMQZABaiELIBAhDyAHIQIDQCACBEAgDyASIAstAAAiFGtBACAUG0H/AXE2AgAgD0EEaiEPIAtBAWohCyACQQFrIQIMAQsLIAxBOGpBADYCACAMQTBqQgA3AwAgDEIANwMoIAxCADcDICAMQRhqQQA2AgAgDEEQakIANwMAIAxCADcDCCAMQgA3AwAgECELIAchAgNAIAIEQCAMQSBqIAstAABBAXRqIg8gDy8BAEEBajsBACALQQRqIQsgAkEBayECDAELC0EAIQsgDCAXQQF0akEAOwEAIA5BAXQhAgNAIA4EQCACIAxqIAs7AQAgDkEBayEOIAxBIGogAmovAQAgC2pB/v8DcUEBdiELIAJBAmshAgwBBSAHIQIDQCACBEAgDCAQKAIAIg5B/wFxIgtBAXRqIg8gDy8BACIPQQFqOwEAIAsEQCAQIA9BICALa3QgDnI2AgALIBBBBGohECACQQFrIQIMAQsLIBUgB0EBazYCAAsLCwsLIAxBkANqJAAgESELIA0oAoABRQRAIABBAjYChAgLQWIhAgJAIAtBiX9JIA0oAhBB/gFLcSIORQ0AIA1BgAFqIhAgDUH8AGogDUEQaiIHIBYgC0EAIA4baiIOIAUgBmoiCyAOaxCCNyIPQYh/Sw0AIA0oAhAiEUEJTw0AIABBiAhqIBBBHyARIApBgMQAEMgHQYh/Sw0AIA1BNDYCDCAHIA1BDGoiESANQQhqIgwgDiAPaiIOIAsgDmsQgjciD0GIf0sNACANKAIIIhJBCUsNACAAQYwOaiAHIA0oAgwgEiAKQYDEABDIB0GJf08NACAAIAcgDSgCDEE0EPEoNgLgIyANQSM2AgwgByARIAwgDiAPaiIOIAsgDmsQgjciD0GIf0sNACANKAIIIhFBCUsNACAAQbgZaiAHIA0oAgwgESAKQYDEABDIB0GJf08NACAAIAcgDSgCDEEjEPEoNgLkIyAOIA9qIgdBDGoiCiALSw0AIAAgBygAADYC6CMgACAHKAAENgLsIyAAIAcoAAg2AvAjIAAgECANKAJ8QR8gCyAKayILQYCACGpnQR9zIAtBgIB4TxsQ8Sg2AtwjIABB6CNqIRBBACEAA0AgAEEEaiIHQRBHBEAgACAQaiAHIQAoAgBBAWsgC0kNAQwCCwsgCiAFayECCyANQcABaiQAIAIiAEGIf0sEQCAADwsgAUEAIAMgBCAAIAVqIAYgAGsgCCAJENkMCyATDwsgASACIAMgBCAFIAYgCCAJENkMQQALyQEBAX8jAEEQayIKJAAgCiACNgIMIAkgCkEMaiABIAMgCUHYxQAQ+ScaQQAhAgJ/AkACQAJ/AkACQCAADgIAAwELIAooAgwiACAISw0DIAYgByAJIAAQhCAMAQsgAEF+cUECRw0BIAQgCSAKKAIMEO4VCyICQYh/Sw0BCyABIANqIQADQCAAIAFNRQRAIAEhCSAFBEAgBSABLQAAaiEJCyABQQFqIQEgAiAJLQAAaiECDAELCyACQQN2DAELIANBCmwLIApBEGokAAvLAQICfwJ9IwBBkAhrIgUkAEEBIQQCQCADsyACsyIGQ0jhej+UXUUEQCAFQRBqQQBBgAj8CwAgAgRAQQAhBANAIAEgBE0NAyAFQRBqIAAgBGotAABBAnRqIgMgAygCAEEBajYCACAEQStqIgQgAkkNAAsLIAVBCGogBUEQakGAAkGAAhCBESAGQwAAAEGUQ0jhej+UQwAALEKVIAUoAgyzIgYgBSoCCCIHIAYgB14bXiEECyAFQZAIaiQAIAQPCyAEIAFBmIjSABDDIQAL5QEBAX8jAEHQAGsiAyQAAkAgASgCAARAIABBk4CAgHg2AgAgACABKQIANwIEIABBDGogAUEIaikCADcCAAwBCyADQR82AiQgA0HuxIABNgIgIANBAjYCLCADQczEgAE2AiggA0ICNwI0IAIoAgAhASADQcwBNgJMIANBzAE2AkQgAyABNgJAIAMgA0FAazYCMCADIANBIGo2AkggA0EQaiADQShqEJkOIANBhICAgHg2AgwgAEEQaiADQRxqKAIANgIAIABBCGogA0EUaikCADcCACAAIAMpAgw3AgALIANB0ABqJAAL1gEBBH8gACgCACICIAAoAgRGBEBBAA8LIAAgAkEIajYCACACKAIAIAIoAgQQkSIiAhC/OiEBIAAoAggiAyABIAMoAgBqNgIAIAIQwTohASAAKAIMIgMgAy0AACABQQBHcjoAAAJAIAIoAhwiA0EITwRAQQEhASACKAIYIgQpAwBCAFcEQCAEIANBeHFqQQhrIgFFDQIgASgCACEBIAJBDGoQ9C0gAUshAQsgACgCECIAIAEgAC0AAHI6AAAgAg8LQQBBAEHst4IBEMMhAAtB/LeCARCyOwALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCaFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahC9FSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCbFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCcFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQAL8wEBAn8jAEGgAmsiAiQAIAJB4AFqIAFBCGooAgA2AgAgAkIENwLQASACQgA3AsgBIAJCgICAgMAANwLAASACQQA2ArgBIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiABKQIANwLYASACIAEoAjA2AuQBQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgKcAiACIAM2ApgCIAJBATYClAIgAkHcAGoiAyACQbgBaiACQZQCahCWKSACIAMgAUEYahDCGSAAIAIQzRwgAkGgAmokAAuVAgEFfyAABEAgACgCOCICKAIYIgEEQCACKAIUIQMgAUECdCEBA0AgAygCACIEKAI0IgUEQCAEIAURAwALIANBBGohAyAEQcAAQQgQ+DogAUEEayIBDQALCyACKAIcIgMEQCADKAI0IgEEQCADIAERAwALIANBwABBCBD4OgsgAEEANgI0IAIoAggiAwRAIAIoAgQhAANAAkAgACgCACIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAEPseCyAAQQxqIQAgA0EBayIDDQALCyACQQRBDBDgHiACKAIQIgAEQCACKAIMIABBAnRBBBD4OgsgAigCGCIABEAgAigCFCAAQQJ0QQQQ+DoLIAJBIEEEEPg6CwvbAQEDfyMAQUBqIgQkACAEIAM2AgwgBCACNgIIAkAgASgCCEF/IAIgA2oiBSACIAVLG08EQCABKAIEIQUgASgCACIBIAEoAgAiBkEBajYCACAGQQBIDQEgACADNgIIIAAgATYCACAAIAIgBWo2AgQgBEFAayQADwsgBEEDNgIUIARBsP6HATYCECAEQgM3AhwgBEE7NgI8IAQgAUEIajYCOCAEQTs2AjQgBEE7NgIsIAQgBEEoajYCGCAEIARBDGo2AjAgBCAEQQhqNgIoIARBEGpByP6HARDvLAsAC+ABAQR/IwBBIGsiAiQAIAEoAgQhBAJAAn8gASgCCCIFIAEoAgAiA0cEQEEMQQQQrTYiAUUNAiABQQE2AgggASADNgIEIAEgBDYCAEGAiIgBDAELIAIgAzYCHCACIAQ2AhggAiADNgIUIAJBCGogAkEUakGoh4gBEJAhIAIoAggiA0EBIAIoAgwiBRshBCADQQFyQQAgBRshAUHMh4gBQbiHiAEgA0EBcRtB0IWIASAFGwshAyAAIAE2AgwgACAFNgIIIAAgBDYCBCAAIAM2AgAgAkEgaiQADwtBBEEMEKM9AAvTAQEEfyMAQSBrIgMkACADQQRqIAEoAghBkJ7DABCtFSACKAIIIQQgAigCBCEBIAMgAigCADYCGCADIAE2AhQgAyABNgIQIAMgASAEQQJ0IgJqNgIcAkAgBARAIAMoAgghBiADKAIMIQUDQCADIAFBBGoiBDYCFCABKAIAIgEgBU8NAiABIAZqQQE6AAAgBCEBIAJBBGsiAg0ACwsgA0EQahChLCAAIAMpAgQ3AgAgAEEIaiADQQxqKAIANgIAIANBIGokAA8LIAEgBUGgnsMAEMMhAAv4AQECfyMAQRBrIgIkACAAQQRqIQMCfwJAAkACQAJAAkACQCAAKAIAQQFrDgUBAgMEBQALIAIgAzYCDCABQdGbwwBBCiACQQxqQbCewwAQ0BMMBQsgAiADNgIMIAFB0J7DAEEMIAJBDGpBwJ7DABDQEwwECyACIAM2AgwgAUHcnsMAQQ0gAkEMakG0m8MAENATDAMLIAIgAzYCDCABQfyewwBBCSACQQxqQeyewwAQ0BMMAgsgAiADNgIMIAFBhZ/DAEEUIAJBDGpBtJvDABDQEwwBCyACIAM2AgwgAUGsn8MAQQ8gAkEMakGcn8MAENATCyACQRBqJAAL2gEBAn8jAEEQayIGJAACQAJAIAIgA0YNAAJAIAIgAiADayIHTQRAIANFDQEMAwsgASAHaiwAAEG/f0wNAgsgBEH/AXFBAkcEQCAGQYyPxAA2AgwgBiAHNgIIIAYgATYCBCAAIAZBBGoQrx4MAQsgBUH/AXFBAkYEQCAGQZyPxAA2AgwgBiAHNgIIIAYgATYCBCAAIAZBBGoQrx4MAQsgBkGsj8QANgIMIAYgBzYCCCAGIAE2AgQgACAGQQRqEK8eCyAGQRBqJAAPCyABIAJBACAHQfyOxAAQozYAC74BAgR/An4jAEEQayIGJAAgAwRAIAFBCGohByABKQMAIQggAS0AFCEEA0AgASAEQQFqIgU6ABQgASACMQAAIgkgBK2GIAiEIgg3AwAgBUH/AXFBwABJBH8gBQUgBiAINwMIIAcgBkEIakEIEKE2IAEgBEE/ayIFOgAUIAEgCUHAACAEayIErYhCACAEQf8BcUHAAEkbIgg3AwAgBQshBCACQQFqIQIgA0EBayIDDQALCyAAQQg2AgAgBkEQaiQAC7IBAQF/IwBBEGsiAyQAIANBBGogACgCDCIAQQhqIAAoAghBAkZBAnRqIgAQiRkCfwJAIAMtAARBCEcNACADLQAGDQAgASgCACIAQR91rUIghiAArYQgAigCACIAQR91rUIghiAArYRWDAELIAAtACFBHHFBDEYEQCABKAIAIgBBH3WtQiCGIACthCACKAIAIgBBH3WtQiCGIACthFYMAQsgASgCACACKAIASgsgA0EQaiQAC9MBAQR/IwBBEGsiAyQAIAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ3xgLAkAgACgCOCIBRQ0AIAAoAjwiBCgCACICBEAgASACEQMACyAEKAIEIgJFDQAgASACIAQoAggQ+DoLAkAgACkDAEICUQRAIAAoAhgiAEUNASAAKQMAQgNSBEAgABDxKwsgACkDaEIDUgRAIABB6ABqEPErCyAAQYgCQQgQ+DoMAQsgAyAAQSBqIgEgACgCLBD4GCABQQhBGBDgHgsgA0EQaiQAC7IBAQl/QX8hBwJAIAIgAC8AAksNAEEBIAAvAAAiA3QhCCADQQh0QYACaiEJQQEgA0EBa3RBASADG0ECdCAAakEIaiEFQQAhAANAIAAgAk0EQCABKAIAIgoEQCAFKAIAIgZBEHZBAWoiC0EIdCALQRh0IAYgCGpBCHRrIAN2ayIGIAlPDQMgBiAKbCAEaiEECyABQQRqIQEgBUEIaiEFIABBAWohAAwBCwsgBEEIdiEHCyAHC8oBAQF/IwBBIGsiByQAAkACfyAFBEAgBkH/AXFBDHQgA0EPcUEIdHIgBHIhBEEQDAELIANB/wFxQQ10CyAEQQV0ciIDIAJNBEAgAiADa0EPTQ0BIABBEDYCBCAAIAEgA0EBdGo2AgAgB0EgaiQADwsgB0EANgIYIAdBATYCDCAHQdSd4gA2AgggB0IENwIQIAdBCGpBzIbzABDvLAALIAdBADYCGCAHQQE2AgwgB0HUneIANgIIIAdCBDcCECAHQQhqQdyG8wAQ7ywAC9kBAQV/IwBBIGsiASQAIAAtABghAiABIAApAxA3AwACQAJAIAJBA3YgAkEHcUEAR2oiAkEJSQRAIAAoAgQiBCAAKAIMIgUgACgCCGoiA2sgAkkNASADIARLDQIgAgRAIAAoAgAgA2ogASAC/AoAAAsgAEEAOgAYIAAgAiAFajYCDCAAQgA3AxAgAUEgaiQADwsgAkEIQazc+wAQsDsACyABQQA2AhggAUEBNgIMIAFBrML7ADYCCCABQgQ3AhAgAUEIakG83PsAEO8sAAsgAyAEQbzc+wAQrzsAC9wBAQN/IwBBQGoiAyQAIAMgAjYCCAJAIAEoAgwiAgRAIAEoAgAgASgCBCABKAIIIgQQuikhBSABIAJBAWs2AgwgASAEQRBqNgIIIAAgBTYCBCAAQZOAgIB4NgIADAELIANBAjYCJCADQbDf/gA2AiAgA0IBNwIsIANB0gs2AjwgAyADQThqNgIoIAMgA0EIajYCOCADQRBqIANBIGoQmQ4gA0GFgICAeDYCDCAAIAMpAgw3AgAgAEEIaiADQRRqKQIANwIAIABBEGogA0EcaigCADYCAAsgA0FAayQAC94BAQJ/IwBBQGoiBCQAIAQgAzYCCCAEIAI2AgQgBCABKAIIIgU2AgwCQCAFQf////8BSw0AIAVBA3RBfyACIANqIgUgAiAFSxtPDQAgBEEENgIUIARB5ICIATYCECAEQgM3AhwgBEE7NgI8IARBOzYCNCAEQTs2AiwgBCAEQShqNgIYIAQgBEEMajYCOCAEIARBCGo2AjAgBCAEQQRqNgIoIARBEGpBhIGIARDvLAALIAAgAzYCECAAIAI2AgwgACABKQIANwIAIABBCGogAUEIaigCADYCACAEQUBrJAALwgEBBX8jAEFAaiICJAACQCABBEAgAkEoaiEDA0AgAkEIaiAAEPcUIAIoAghBCUYNAiADIAIpAwg3AwAgA0EQaiACQRhqKQMANwMAIANBCGogAkEQaikDADcDACACIAE2AiACQCACKAIoQQhGBEAgAigCLCEFIAIoAjAiBigCACIEBEAgBSAEEQMACyAGKAIEIgRFDQEgBSAEIAYoAggQ+DoMAQsgAxDJIwsgAUEBayIBDQALC0EAIQELIAJBQGskACABC8MEAgV/An4jAEGgAWsiAyQAIANBOGohBCMAQaACayICJAAgASgCACIFIAUoAgAiBkEBajYCAAJAIAZBAE4EQCACIAU2AgggAkEgOgAEIAIgASgCBDYCDCACQbgBaiACQQRqELEBAkAgAigCuAFBAUYEQCACQZABaiACQcwBaigCACIBNgIAIAJBiAFqIAJBxAFqKQIAIgc3AwAgAiACKQK8ASIINwOAASAEQRRqIAE2AgAgBEEMaiAHNwIAIAQgCDcCBCAEQQE2AgAMAQsgAkGEAWohBSAFIAJBwAFqQTD8CgAAIAJB8AFqIgYgBUEw/AoAACACQcgAaiAGIAFBCGoQ6AggAigCSEEBRgRAIAJBIGogAkHcAGooAgAiATYCACACQRhqIAJB1ABqKQIAIgc3AwAgAiACKQJMIgg3AxAgBEEUaiABNgIAIARBDGogBzcCACAEIAg3AgQgBEEBNgIADAELIAJBFGohASABIAJB0ABqQTD8CgAAIARBCGogAUEw/AoAACAEQQA2AgALIAJBBGoQ0AwgAkGgAmokAAwBCwALAkACQCADKAI4QQFGBEAgA0EQaiADQcwAaigCADYCACADQQhqIANBxABqKQIANwMAIAMgAykCPDcDACAAIAMQyiYMAQsgA0EEaiIBIANBQGtBMPwKAAAgA0HwAGoiAiABQTD8CgAAQTBBCBCtNiIBRQ0BIAEgAkEw/AoAACAAQYGAgIB4NgIAIAAgATYCBAsgA0GgAWokAA8LQQhBMBCjPQALzwECAn4EfyAAKAJAIgNBCGohBCADKQMAQn+FQoCBgoSIkKDAgH+DIQIgACgCTCEFIAAtACohBgJ/AkADQCAFBEAgBUEBayEFIAIiAVAEQANAIANBgARrIQMgBCkDACAEQQhqIQRCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAFCAX0gAYMhAiADIAF6p0EDdEHAB3FrQQZrLQAAQQJHDQEMAgsLIAZBAkYNACAALQCWAQwBC0EAC0EBcQvRAQEFfyAAKAIEIQEgACgCACEDIABChICAgMAANwIAIAAoAhAhAgJAAkACQCABIANHBEAgAg0BDAMLIAJFDQIgACgCDCIDIAAoAggiACgCCCIBRg0BIAJBAnQiBEUNASAAKAIEIgUgAUECdGogBSADQQJ0aiAE/AoAAAwBCwJAIAAoAgwiAyAAKAIIIgAoAggiAUYNACACQQJ0IgRFDQAgACgCBCIFIAFBAnRqIAUgA0ECdGogBPwKAAALIAAgASACajYCCA8LIAAgASACajYCCAsLswEBAX8jAEFAaiIFJAAgAkJ/UQRAQn8gATQCOCICIAJCAFcbIQILIAVBJGogASgCLCACIAMgBBCAESABKAJUQQFGBEAgBUEbNgIkCyAFQSRqIAFBBGoQxBwgASgChAEhASAFQSBqIAVBPGooAgA2AgAgBUEYaiAFQTRqKQIANwMAIAVBEGogBUEsaikCADcDACAFIAUpAiQ3AwggACAFQQhqIAIgAyAEIAEQ6gsgBUFAayQAC7IBAQF/IAAoAhghBAJAAkBBACACIAMbDQBBACECIARBAUYNASABQQFHDQAgBEEDa0EDSQ0BC0EEIAAoAgR0IQILQcCOCUGAASAEQQZLG0GAASADGyACakEEIAAoAggiAnRqQQEgAnRBP2pBQHFBACAEQQZrQX1PG0EAIAFBAUYbakEEAn9BACADRQ0AGkEAIAAoAhBBA0cNABpBESAAKAIAIgAgAEERTxsLIgJ0QQAgAhtqC9IBAQR/IAAoAgAiASAAKAIERgRAQQAPCyAAIAFBCGo2AgAgASgCACABKAIEEJAiIgEQwDohAiAAKAIIIgMgAiADKAIAajYCACABEME6IQIgACgCDCIDIAMtAAAgAkEAR3I6AAACQCABKAIcIgNBBE8EQEEBIQIgASgCGCIEKAIAQQBMBEAgBCADQXxxakEEayICRQ0CIAIoAgAgAUEMahD0LUkhAgsgACgCECIAIAIgAC0AAHI6AAAgAQ8LQQBBAEHst4IBEMMhAAtB/LeCARCyOwAL2QEBBX8gAEEMaiIGIAAoAhQgACgCKEEBQQFB0LGDARDDKAJAAkACQAJAIAEgAkcEQANAIAEoAgAiBCAAKAIcIgNPDQIgAUEEaigCACIFIANPDQMgACgCGCIHIAVBAnRqKAIAIgMgByAEQQJ0aigCACIESQ0EIAMgACgCJCIFSw0FIAYgACgCICAEaiADIARrEKE2IAFBCGoiASACRw0ACwsPCyAEIANBnLCDARDDIQALIAUgA0GcsIMBEMMhAAsgBCADQeCxgwEQsTsACyADIAVB4LGDARCwOwAL2QEBBX8gAEEkaiIGIAAoAiwgACgCAEEBQQFB0LGDARDDKAJAAkACQAJAIAEgAkcEQANAIAEoAgAiBCAAKAIMIgNPDQIgAUEEaigCACIFIANPDQMgACgCCCIHIAVBA3RqKAIAIgMgByAEQQN0aigCACIESQ0EIAAoAhQiBSADSQ0FIAYgACgCECAEaiADIARrEKE2IAFBCGoiASACRw0ACwsPCyAEIANBnLCDARDDIQALIAUgA0GcsIMBEMMhAAsgBCADQeCxgwEQsTsACyADIAVB4LGDARCwOwALygEBA38jAEHgAmsiAiQAAkAgAS0ANEEnRgRAIAEoAjgiAyADKAIAIgRBAWo2AgAgBEEASA0BIAJBGzoADCACIAM2AhAgAkH8AWoiAyABQeQA/AoAACACQfQAaiIBIAMQ9hEgAyABEKEbIAJBGGoiASADIAJBDGoQjBggAkG4AWoiAyABEM0cIAAgAxCvHyACQeACaiQADwsgAkEANgKMAiACQQE2AoACIAJB3OKFATYC/AEgAkIENwKEAiACQfwBakHk4oUBEO8sCwAL4AECAn8EfiMAQTBrIgIkACACQRBqQYythgEoAgA2AgAgAkGErYYBKQIANwMIAkACQCABIAFCgJTr3AN/IgFCgJTr3AN+fSIEQj+HIgUgAXwiASABQoCjBX8iAUKAowV+fSIGQj+HIgcgAXynQbvyK2oQ8xYiAwRAIAIgAzYCJCACIAVCgJTr3AODIAR8PgIsIAIgB0KAowWDIAZ8PgIoIAJBGGogAkEkahDKLyACKAIYIgMNAQsgAEEANgIADAELIAAgAikCHDcCBCAAIAM2AgALIAJBCGoQyQwgAkEwaiQAC80CAQJ/IwBBMGsiAiQAAkACQCABRQRAIwBBQGoiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQTj8CgAAIANBADYCAAJAIANBf0YNACAAQQRrIgAgACgCAEEBayIANgIAIAANACADQcAAQQgQ+DoLIAIgAUEQakEw/AoAACABQUBrJAAMAgsQmD0AC0HE98IAQT8Qlz0ACyACEPslIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAJBIGoQlxULIAIoAiQiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAJBJGoQ+CMLIAIoAigiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEoahDbHgwBCyAARQ0BIAIgAEEIayIANgIAIAAgACgCAEEBayIANgIAIAANACACEMoUCyACQTBqJAAPCxCYPQALsgcCDH8BfiMAQRBrIggkACACKAIAIQkgAigCBCIEIAIoAgwiA2siBgRAIAMgCWpBACAG/AsACyACIAQ2AgwgCEEIaiEKIAkgAigCCCIMaiEOIAQgDGshCyMAQRBrIgUkACABIgZBCGohDSABQRBqIQkgAUEEaiEBIAVBDGohBAJAAkADQAJAIAYoAgAiA0EBRgRAIAEoAgAhBwwBCyAGKAIYIgcgBigCIEYEf0EABSAGIAdBEGo2AhggBUEIaiAHQQxqKAIANgIAIAUgBykCBDcDACAHKAIACyEHAkAgA0UNACABKAIAIgNFDQAgCSAGKAIIIAYoAgwgAygCEBEBAAsgBiAHNgIEIAZBATYCACANIAUpAwA3AgAgDUEIaiAFQQhqKAIANgIACyAHBEAgBigCDCIDDQIgBkEANgIAIAVBCGogAUEIaikCADcDACAFIAEpAgAiDzcDACAPpyIDRQ0BIAQgBSgCBCAFKAIIIAMoAhARAQAMAQsLIApBBDoAACAKQQA2AgQMAQsjAEEwayIEJAAgBCALIAMgAyALSxsiAzYCAAJAAkAgASgCCCIGIANHBEAgAw0BIAVCADcCCCAFQdCFiAE2AgAgBSABKAIENgIEDAILIAEpAgAhDyABQdCFiAE2AgAgBSAPNwIAIAFBCGoiBikCACEPIAZCADcCACAFQQhqIA83AgAgASABKAIEIANqNgIEDAELIAMgBk0EQCAEQQRqIAFBDGogASgCBCAGIAEoAgAoAgARBQAgBEEMaiIGIAM2AgAgBSAEKQIENwIAIAEgASgCCCADazYCCCABIAEoAgQgA2o2AgQgBUEIaiAGKQIANwIADAELIAQgBjYCHCAEQQI2AgggBEGIh4gBNgIEIARCAjcCECAEQasdNgIsIARBqx02AiQgBCAEQSBqNgIMIAQgBEEcajYCKCAEIAQ2AiAgBEEEakGYh4gBEO8sAAsgBEEwaiQAIAUoAggiASADRgRAIAUoAgQhASADBEAgDiABIAP8CgAACyAKQQQ6AAAgCiADNgIEIAVBDGogASADIAUoAgAoAhARAQAMAQsgAyABQYjpzwAQszsACyAFQRBqJAACQAJAIAgtAAhBBEcEQCAAIAgpAwgiD0IgiD4CBCAAIA88AAAgAEEDaiAPpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyALIAgoAgwiAUkNASAAQQQ6AAAgAiABIAxqNgIICyAIQRBqJAAPC0GQzMMAQTZByMzDABCfKQAL1AEBBn8jAEEQayIEJAAgASgCDCIFIAUoAgAiA0EBajYCAAJAAkAgA0EASA0AIAEoAhAiBiAGKAIAIgNBAWo2AgAgA0EASA0AIARBBGogARCJHSAEKAIMIQcgBCgCCCEDIAQoAgQhCEEcQQQQrTYiAUUNASABIAI2AhggASAGNgIUIAEgCDYCDCABIAM2AgggASADNgIEIAEgBTYCACAAQZDPwwA2AgggACABNgIEIABBCDYCACABIAMgB0ECdGo2AhAgBEEQaiQADwsAC0EEQRwQoz0AC7wBAQZ/IAEgBU8EQCADQQhPBEAgA0EDdiEIIAAgBWohCSABIAVrIQdBACEAA0AgAiAGaiEKIAAiBUEBaiEAQQAhAQJAAkADQCAFIAdPDQEgAyABIAZqIgtLBEAgASAKaiAFIAlqLQAAOgAAIAQgBWohBSABQQFqIgFBCEYNAwwBCwsgCyADQbj2zAAQwyEACyAFIAdBqPbMABDDIQALIAZBCGohBiAAIAhHDQALCw8LIAUgAUGY9swAEK87AAu8AQEGfyABIAVPBEAgA0EETwRAIANBAnYhCCAAIAVqIQkgASAFayEHQQAhAANAIAIgBmohCiAAIgVBAWohAEEAIQECQAJAA0AgBSAHTw0BIAMgASAGaiILSwRAIAEgCmogBSAJai0AADoAACAEIAVqIQUgAUEBaiIBQQRGDQMMAQsLIAsgA0G49swAEMMhAAsgBSAHQaj2zAAQwyEACyAGQQRqIQYgACAIRw0ACwsPCyAFIAFBmPbMABCvOwAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQpwcCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQnQsCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQ0goCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQALxwEBBn8gA0H8E2ohByADQdATaiEIIANBpBNqIQkDQAJAIAIgAWtBrAJJDQAgACgCBEHDAUsNACAJIAQgASACEK8VIAggBCABIAEgAmpBAXYiBRCvFSAHIAQgBSACEK8VIAkgAxCjDiIGQYh/SyAIIAMQow4iCkGIf0tyIAYgByADEKMOIgYgCmpNIAZBiH9LcnINACAAIAEgBSADIAQQhhYgACAAKAIEIgFBAWo2AgQgACgCACABQQJ0aiAFNgIAIAUhAQwBCwsL8QEBA38jAEEQayICJAACQAJAIAEtAABBA0YEQCACIAEoAgQiAygCACADKAIEKAIcEQAAIAMoAgAhASADKAIEIQQgA0EMQQQQ+DogAiABIAQoAhwRAAAgAikDAEKJrPzB6qf/qRKFIAIpAwhCqZ7qidv+mNeMf4WEUEUNAiAAIAEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDACABQRhBCBD4OgwBCyAAQQI6AAAgACABKQIANwIECyACQRBqJAAPCyACIAQ2AgQgAiABNgIAQejH0QBBKyACQdjH0QBBqMzRABDVHgAL1QgCBn8CfiMAQRBrIgUkACABKAIcIgMEQCABKAIQIAEoAhQgASgCGCIEELopIQIgASADQQFrNgIcIAEgBEEQajYCGCABLQBCIQMgBSABKAI8IAIoAAAgAigACBDmFQJAAkAgA0ECRwRAIAUoAggNAQsgACAFKQIANwIEIABBk4CAgHg2AgAgAEEMaiAFQQhqKAIANgIADAELIAUgAzoADyAFQQ9qIQIjAEHQAGsiASQAIAFBEGogBRDcOwJAAkACQAJAAkACQCABKAIUIgNBB0sEQCABIAEoAhApAAAiCDcDGCAIQgF8IglCAVgEQCAJp0EBRgRAIAFBJGohBCMAQSBrIgIkAAJAQQBBwAAQ0TQEQCACQQA2AhwgAkKAgICAgAg3AhQgAkLAADcCDCACIAJBDGoQ1zsgAigCACEGQRxBBBCtNiIDRQ0BIANCgYCAgBA3AgAgAyACKQIMNwIIIARBADYCCCAEIAY2AgQgBCADNgIAIANBEGogAkEUaikCADcCACADQRhqIAJBHGooAgA2AgAgAkEgaiQADAcLQYD+/gBBKSACQQxqQdD+/gBBrP7+ABDVHgALQQRBHBCjPQALIAFBJGohAyMAQUBqIgIkACAFKAIAIgQgBCgCACIGQQFqNgIAAkACQCAGQQBOBEAgAiAENgIIIAIgBSgCCCIENgIQIAIgBSgCBCIHNgIMIAJBCDYCFCACQRBqIQYgBEEISQ0BIAYgBEEIayIENgIAIAIgB0EIajYCDCADQQhqIAQ2AgAgAyACKQIINwIAIAJBQGskAAwCCwALIAJBAjYCHCACQbj9hwE2AhggAkICNwIkIAJBOzYCPCACIAY2AjggAkE7NgI0IAIgAkEwajYCICACIAJBFGo2AjAgAkEYakHI/YcBEO8sAAsMBAsgCEL/////D1YNAiABQQhqIAUQ3DsgASgCDCIDQQdNDQECQAJAIAItAABBAUYEQEEwIQMgAUEwakEwQQBBAUEBEKAYIAEoAjQhAiABKAIwQQFHDQEMCAtBLiEDIAFBMGpBLkEAQQFBARCgGCABKAI0IQIgASgCMEEBRg0HIAEoAjgiBEGc+v4AQS78CgAADAELIAEoAjgiBEH4+v4AQTD8CgAACyAAIAM2AgwgACAENgIIIAAgAjYCBCAAQY2AgIB4NgIADAQLQQggA0Go+/4AELA7AAtBCCADQbj5/gAQrzsACyABQQE2AjQgAUHo+f4ANgIwIAFCATcCPCABQe4GNgJMIAEgAUHIAGo2AjggASABQRhqNgJIIABBBGogAUEwahCZDiAAQYyAgIB4NgIADAELIAAgASkCJDcCBCAAQZOAgIB4NgIAIABBDGogAUEsaigCADYCAAsgAUHQAGokAAwBCyACIAEoAjhB6Pj+ABD9LwALIAUoAgAiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAUQ+x4LIAVBEGokAA8LQdTe/gAQsjsAC9YBAQV/IABBJGoiBiAAKAIsIAAoAgBBAUEBQeCwgwEQwygCQAJAAkACQCABIAJHBEADQCABKAIAIgQgACgCDCIDTw0DIARBAWoiBSADTw0CIAAoAggiByAFQQN0aigCACIDIAcgBEEDdGooAgAiBEkNBCAAKAIUIgUgA0kNBSAGIAAoAhAgBGogAyAEaxChNiABQQRqIgEgAkcNAAsLDwsgBSADQYCxgwEQwyEACyAEIANB8LCDARDDIQALIAQgA0GQsYMBELE7AAsgAyAFQZCxgwEQsDsAC9YBAQV/IABBDGoiBiAAKAIUIAAoAihBAUEBQeCwgwEQwygCQAJAAkACQCABIAJHBEADQCABKAIAIgQgACgCHCIDTw0DIARBAWoiBSADTw0CIAAoAhgiByAFQQJ0aigCACIDIAcgBEECdGooAgAiBEkNBCADIAAoAiQiBUsNBSAGIAAoAiAgBGogAyAEaxChNiABQQRqIgEgAkcNAAsLDwsgBSADQYCxgwEQwyEACyAEIANB8LCDARDDIQALIAQgA0GQsYMBELE7AAsgAyAFQZCxgwEQsDsAC8ABAQV/IwBBEGsiBCQAIARBCGogABCGPSAEKAIMIQUgBCgCCCIDQQQQ+C8hAiABBEBBBCACIANqIAIgBUsiAxtBACAFIAJrQQJ2IAMbQQJ0akEEaygCACEFIAAoAgwhAgNAIAJBBGoiAyAAKAIEIgZLBH8gACAGQQF0IgIgAxDeKiIDIAIgA0sbEOgZIAAoAgwFIAILIAAoAghqIAU2AAAgACAAKAIMQQRqIgI2AgwgAUEBayIBDQALCyAEQRBqJAALwgECBH8BfiMAQRBrIgUkACAFQQhqIAAQhj0gBSgCDCEDIAUoAggiBEEIEPgvIQIgAQRAQQggAiAEaiACIANLIgQbQQAgAyACa0EDdiAEG0EDdGpBCGspAwAhBiAAKAIMIQIDQCACQQhqIgMgACgCBCIESwR/IAAgBEEBdCICIAMQ3ioiAyACIANLGxDoGSAAKAIMBSACCyAAKAIIaiAGNwAAIAAgACgCDEEIaiICNgIMIAFBAWsiAQ0ACwsgBUEQaiQAC+wCAgZ/AX4jAEGAAWsiAiQAIAEoAgghAyACIAFBCGo2AhAgAiADNgIMIAIgAkH/AGo2AgggAkFAayEFIAJBCGoiByEEIwBB8ABrIgMkAAJAIAEoAgAiBiABKAIERwRAIAQoAgQhBCABIAZBCGo2AgAgA0E4aiAGKAIEQQhqEOgMIAUCfiADKAI4QQFxBEAgBBCOEiAEQRBqIANBzABqKAIANgIAIARBCGogA0HEAGopAgA3AgAgBCADKQI8NwIAQgAMAQsgA0EIaiADQUBrQTD8CgAAQgELNwMAIAVBCGogA0EIakEw/AoAAAwBCyAFQgI3AwALIANB8ABqJAACQCACKQNAQgJSBEAgByAFQTj8CgAAIAIpAwgiCKdBAXEEQCAAQQhqIAJBEGpBMPwKAAAgAEIBNwMADAILIABCADcDACAIUA0BIAIoAjgiAEUNASACQRBqIAARAwAMAQsgAEIANwMACyACQYABaiQAC70BAgN+A38jAEGAAWsiBiQAIAApAwghAiAAKQMAIQNBACEAAkADQCAAQf8AakH/AEsNASAAIAZqQf8AaiADp0EPcSIFQTByIAVB1wBqIAVBCkkbOgAAIAJCPIYgA0IQVCEFIAJQIQcgAEEBayEAIAJCBIghAiADQgSIhCEDIAUgB3FFDQALIAFBAUHg84kBQQIgACAGakGAAWpBACAAaxCBCSAGQYABaiQADwsgAEH/AGpBgAFB0POJARDDIQALvAECA34DfyMAQYABayIGJAAgACkDCCECIAApAwAhA0EAIQACQANAIABB/wBqQf8ASw0BIAAgBmpB/wBqIAOnQQ9xIgVBMHIgBUE3aiAFQQpJGzoAACACQjyGIANCEFQhBSACUCEHIABBAWshACACQgSIIQIgA0IEiIQhAyAFIAdxRQ0ACyABQQFB4POJAUECIAAgBmpBgAFqQQAgAGsQgQkgBkGAAWokAA8LIABB/wBqQYABQdDziQEQwyEAC9IBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCAAIAEgA2ogAiADaxCXHSIBIAAoAgQiAk8NASAAKAIgIAAoAgAgAUEBdGoiAi8BAHEgASAAKAIkdGoiASAAKAIMIgNPDQIgACgCCCABQQJ0aiAENgIAIAIgAi8BAEEBajsBACAFQSBqJAAPCyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakH81c4AEO8sAAsgASACQYzWzgAQwyEACyABIANBnNbOABDDIQALwQEBBX8CQCAAKAIMIgMEQCADIAAoAgQiA0sNAQsgAEJ/NwIUDwsgAiAAKAIAIANBDGxqIgMoAgQiBCAAKAIIIgZrIgVBACAEIAVPGyIFTQRAIABCfzcCFCAAIAIQiB8PCyADKAIIIQcgACADKAIANgIcIAAgASAFaiIDNgIUIAAgAyAHIAYgBGsiBEEAIAQgBk0bayIEaiIDNgIYIAEgAmoiASADSQRAIAAgATYCGCAAIAIQiB8PCyAAIAQgBWoQiB8LwgEBBn8gBgRAA0ACQCAFIAtHBEAgBCALQQR0aiIKLwEOIQ0gCigCBCEOIAooAgAhDCAIIAovAQwiDxC3KSAMRQ0BA0AgASACIANxIgpLBEAgByAAIApqLQAAELYpIAJBAWohAiAMQQFrIgwNAQwDCwsgCiABQezs0QAQwyEACyAFIAVB3OzRABDDIQALIA5B////D3EiCkUgD0H/AE1yRQRAIAkgDUH/B3EQtSkLIAIgCmohAiALQQFqIgsgBkcNAAsLC8cBAgF/A34CQAJAIABBA2oiAGdBIGpBP3MiB0EBdCAArSIIIAdBAWsiB0E/ca0iCYhCAYMiCqdyQcwAaiIAQYABSQRAIABBgAFPDQEgACABai0AACACIABBAXRqMwEAIAQgBSAGEN8TIAcgCCAKQgKEIAmGfSAEIAUgBhDfEyAAQYABSQ0CIABBgAFBhJfzABDDIQALIABBgAFB5JbzABDDIQALIABBgAFB9JbzABDDIQALIAMgAEECdGoiACAAKAIAQQFqNgIAC8YBAQd/IAAoAjAhAUGAgAQhAyAAKAIgIgRB//8DcSEFA0BBACECA0AgASACaiIGIAYvAQAiBiAFayIHQQAgBiAHTxs7AQAgAkECaiICQcAARw0ACyABQUBrIQEgA0EgayIDDQALIAAoAixBYHEiAwRAIAAoAighASAEQf//A3EhAANAQQAhAgNAIAEgAmoiBCAELwEAIgQgAGsiBUEAIAQgBU8bOwEAIAJBAmoiAkHAAEcNAAsgAUFAayEBIANBIGsiAw0ACwsLwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQuhYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENodIANB1ABqIgQgARDKBiAEEJkeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQJ2IAIQuxYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEEL8dIANB1ABqIgQgARDKBiAEEJIeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQN2IAIQvBYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENYdIANB1ABqIgQgARDKBiAEEJUeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQuhYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEEM0dIANB1ABqIgQgARDKBiAEEJYeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwwQBCH8jAEHgAGsiBSQAIAEoAhAhBCABKAIUQQJ2IQgjAEEwayIDJAACQAJAIAIQkjYiBkUNACAGKAIURQ0AIAIoAhAhByACKAIUIQkgAyAGNgIgIAMgCDYCHCADIAQ2AhggA0EANgIUIAMgByAJQXxxajYCECADIAc2AgwgA0EkaiEHIwBBIGsiBCQAIARBFGogA0EMaiIIKAIEIAgoAgBrQQJ2QQBBBEEEEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIARBCGoiCSAIKAIEIAgoAgBrQQJ2EIUuIAYgCSkCBEIgiTcCCCAGIAlBCGo2AgQgCCAGQQRqEOIQIAZBEGokACAHQQhqIAooAgA2AgAgByAEKQIINwIAIARBIGokAAwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAQ2AhQgAyAGIAdBfHFqNgIQIAMgBjYCDCADQSRqIgcgA0EMahD8GgsgBSAHEOgYIANBMGokACAFQQxqIgMgARCSNiACEPISIAVBJGoiAiAFIAMQxx0gBUHUAGoiAyABEMoGIAMQjx4gAEEIaiAFQdwAaigCADYCACAAIAUpAlQ3AgAgACAFKQIwNwIMIABBFGogBUE4aigCADYCACAAIAUpAjw3AhggAEEgaiAFQcQAaikCADcCACAAQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokAAv7AgEHfyMAQeAAayIEJAAgASgCECEFIAEoAhRBA3YhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBTYCGCADQQA2AhQgAyAHIAlBfHFqNgIQIAMgBzYCDCADQSRqIgUgA0EMahCMGwwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAU2AhQgAyAGIAdBfHFqNgIQIAMgBjYCDCADQSRqIgUgA0EMahCBGwsgBCAFEOcYIANBMGokACAEQQxqIgMgARCSNiACEPISIARBJGoiAiAEIAMQ2R0gBEHUAGoiAyABEMoGIAMQkR4gAEEIaiAEQdwAaigCADYCACAAIAQpAlQ3AgAgACAEKQIwNwIMIABBFGogBEE4aigCADYCACAAIAQpAjw3AhggAEEgaiAEQcQAaikCADcCACAAQShqIARBzABqKQIANwIAIAIQuwwgBEHgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAXYgAhC+FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQ2h0gA0HUAGoiBCABEMoGIAQQmR4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAnYgAhC/FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQvx0gA0HUAGoiBCABEMoGIAQQkh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBA3YgAhDAFiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQ1h0gA0HUAGoiBCABEMoGIAQQlR4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAXYgAhC+FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQzR0gA0HUAGoiBCABEMoGIAQQlh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvDBAEIfyMAQeAAayIFJAAgASgCECEEIAEoAhRBAnYhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBDYCGCADQQA2AhQgAyAHIAlBfHFqNgIQIAMgBzYCDCADQSRqIQcjAEEgayIEJAAgBEEUaiADQQxqIggoAgQgCCgCAGtBAnZBAEEEQQQQoBggBCgCGCEGIAQoAhRBAUYEQCAGIAQoAhxBvPyBARD9LwALIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAY2AggjAEEQayIGJAAgBEEIaiIJIAgoAgQgCCgCAGtBAnYQhS4gBiAJKQIEQiCJNwIIIAYgCUEIajYCBCAIIAZBBGoQ4xAgBkEQaiQAIAdBCGogCigCADYCACAHIAQpAgg3AgAgBEEgaiQADAELIAIoAhAhBiACKAIUIQcgAyAINgIYIAMgBDYCFCADIAYgB0F8cWo2AhAgAyAGNgIMIANBJGoiByADQQxqEPwaCyAFIAcQ6BggA0EwaiQAIAVBDGoiAyABEJI2IAIQ8hIgBUEkaiICIAUgAxDHHSAFQdQAaiIDIAEQygYgAxCPHiAAQQhqIAVB3ABqKAIANgIAIAAgBSkCVDcCACAAIAUpAjA3AgwgAEEUaiAFQThqKAIANgIAIAAgBSkCPDcCGCAAQSBqIAVBxABqKQIANwIAIABBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAC/sCAQd/IwBB4ABrIgQkACABKAIQIQUgASgCFEEDdiEIIwBBMGsiAyQAAkACQCACEJI2IgZFDQAgBigCFEUNACACKAIQIQcgAigCFCEJIAMgBjYCICADIAg2AhwgAyAFNgIYIANBADYCFCADIAcgCUF8cWo2AhAgAyAHNgIMIANBJGoiBSADQQxqEIYbDAELIAIoAhAhBiACKAIUIQcgAyAINgIYIAMgBTYCFCADIAYgB0F8cWo2AhAgAyAGNgIMIANBJGoiBSADQQxqEIEbCyAEIAUQ5xggA0EwaiQAIARBDGoiAyABEJI2IAIQ8hIgBEEkaiICIAQgAxDZHSAEQdQAaiIDIAEQygYgAxCRHiAAQQhqIARB3ABqKAIANgIAIAAgBCkCVDcCACAAIAQpAjA3AgwgAEEUaiAEQThqKAIANgIAIAAgBCkCPDcCGCAAQSBqIARBxABqKQIANwIAIABBKGogBEHMAGopAgA3AgAgAhC7DCAEQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEBdiACEMIWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDaHSADQdQAaiIEIAEQygYgBBCZHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEECdiACEMMWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBC/HSADQdQAaiIEIAEQygYgBBCSHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEDdiACEMQWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDWHSADQdQAaiIEIAEQygYgBBCVHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEBdiACEMIWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDNHSADQdQAaiIEIAEQygYgBBCWHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC/YEAgh/AX4jAEHgAGsiBiQAIAEoAhAhBCABKAIUQQJ2IQUjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhCCACKAIUIQkgAyAHNgIgIAMgBTYCHCADIAQ2AhggA0EANgIUIAMgCCAJQXhxajYCECADIAg2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQN2QQBBBEEEEKAYIAQoAhghBSAEKAIUQQFGBEAgBSAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAFNgIIIwBBMGsiBSQAIARBCGoiCSAHKAIEIAcoAgBrQQN2EIUuIAkpAgQhCyAFQRhqIAdBEGopAgA3AwAgBUEQaiAHQQhqKQIANwMAIAUgBykCADcDCCAFIAtCIIk3AiggBSAJQQhqNgIkIAVBCGogBUEkahDhECAFQTBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhCCADIAU2AhggAyAENgIUIAMgByAIQXhxajYCECADIAc2AgwgA0EkaiIIIANBDGoQmxsLIAYgCBDoGCADQTBqJAAgBkEMaiIDIAEQkjYgAhDzEiAGQSRqIgIgBiADEMcdIAZB1ABqIgMgARDKBiADEI8eIABBCGogBkHcAGooAgA2AgAgACAGKQJUNwIAIAAgBikCMDcCDCAAQRRqIAZBOGooAgA2AgAgACAGKQI8NwIYIABBIGogBkHEAGopAgA3AgAgAEEoaiAGQcwAaikCADcCACACELsMIAZB4ABqJAAL+wIBB38jAEHgAGsiBCQAIAEoAhAhBSABKAIUQQN2IQgjAEEwayIDJAACQAJAIAIQkjYiBkUNACAGKAIURQ0AIAIoAhAhByACKAIUIQkgAyAGNgIgIAMgCDYCHCADIAU2AhggA0EANgIUIAMgByAJQXhxajYCECADIAc2AgwgA0EkaiIFIANBDGoQ9xoMAQsgAigCECEGIAIoAhQhByADIAg2AhggAyAFNgIUIAMgBiAHQXhxajYCECADIAY2AgwgA0EkaiIFIANBDGoQghsLIAQgBRDnGCADQTBqJAAgBEEMaiIDIAEQkjYgAhDzEiAEQSRqIgIgBCADENkdIARB1ABqIgMgARDKBiADEJEeIABBCGogBEHcAGooAgA2AgAgACAEKQJUNwIAIAAgBCkCMDcCDCAAQRRqIARBOGooAgA2AgAgACAEKQI8NwIYIABBIGogBEHEAGopAgA3AgAgAEEoaiAEQcwAaikCADcCACACELsMIARB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQxhYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEENodIANB1ABqIgQgARDKBiAEEJkeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQJ2IAIQxxYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEEL8dIANB1ABqIgQgARDKBiAEEJIeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQN2IAIQyBYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEENYdIANB1ABqIgQgARDKBiAEEJUeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQxhYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEEM0dIANB1ABqIgQgARDKBiAEEJYeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAAL9gQCCH8BfiMAQeAAayIGJAAgASgCECEEIAEoAhRBAnYhBSMAQTBrIgMkAAJAAkAgAhCSNiIHRQ0AIAcoAhRFDQAgAigCECEIIAIoAhQhCSADIAc2AiAgAyAFNgIcIAMgBDYCGCADQQA2AhQgAyAIIAlBeHFqNgIQIAMgCDYCDCADQSRqIQgjAEEgayIEJAAgBEEUaiADQQxqIgcoAgQgBygCAGtBA3ZBAEEEQQQQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhxBvPyBARD9LwALIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAU2AggjAEEwayIFJAAgBEEIaiIJIAcoAgQgBygCAGtBA3YQhS4gCSkCBCELIAVBGGogB0EQaikCADcDACAFQRBqIAdBCGopAgA3AwAgBSAHKQIANwMIIAUgC0IgiTcCKCAFIAlBCGo2AiQgBUEIaiAFQSRqEOQQIAVBMGokACAIQQhqIAooAgA2AgAgCCAEKQIINwIAIARBIGokAAwBCyACKAIQIQcgAigCFCEIIAMgBTYCGCADIAQ2AhQgAyAHIAhBeHFqNgIQIAMgBzYCDCADQSRqIgggA0EMahCbGwsgBiAIEOgYIANBMGokACAGQQxqIgMgARCSNiACEPMSIAZBJGoiAiAGIAMQxx0gBkHUAGoiAyABEMoGIAMQjx4gAEEIaiAGQdwAaigCADYCACAAIAYpAlQ3AgAgACAGKQIwNwIMIABBFGogBkE4aigCADYCACAAIAYpAjw3AhggAEEgaiAGQcQAaikCADcCACAAQShqIAZBzABqKQIANwIAIAIQuwwgBkHgAGokAAv7AgEHfyMAQeAAayIEJAAgASgCECEFIAEoAhRBA3YhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBTYCGCADQQA2AhQgAyAHIAlBeHFqNgIQIAMgBzYCDCADQSRqIgUgA0EMahD4GgwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAU2AhQgAyAGIAdBeHFqNgIQIAMgBjYCDCADQSRqIgUgA0EMahCCGwsgBCAFEOcYIANBMGokACAEQQxqIgMgARCSNiACEPMSIARBJGoiAiAEIAMQ2R0gBEHUAGoiAyABEMoGIAMQkR4gAEEIaiAEQdwAaigCADYCACAAIAQpAlQ3AgAgACAEKQIwNwIMIABBFGogBEE4aigCADYCACAAIAQpAjw3AhggAEEgaiAEQcQAaikCADcCACAAQShqIARBzABqKQIANwIAIAIQuwwgBEHgAGokAAvpAQECfyMAQaACayICJAAgAkEANgKcAiACQQA2AoACIAJBADYC9AEgAkEBOgDkASACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAiABKAIMNgKYAiACIAEoAhA2AvABIAJB6ABqIAJBxAFqIAFBFGoQwhlBDEEEEK02IgNFBEBBBEEMEKM9AAsgAyABKQIANwIAIANBCGogAUEIaigCADYCACACQQE2AswBIAIgAzYCyAEgAkEBNgLEASACQQxqIgEgAkHoAGogAkHEAWoQlikgACABEM0cIAJBoAJqJAALxgEBA38jAEEgayIEJAACQCABKAI8IgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFBPGoQ+x4LIAFBADYCPCABIAQpAgw3AkAgAUHIAGogBEEUaikCADcCACABQdAAaiAEQRxqKAIANgIAIAFBMGohAwJAIAEoAjAiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgAxD7HgsgAyACKQIANwIAIANBCGogAkEIaigCADYCACAAIAFB3AD8CgAAIARBIGokAAulAgIHfwFvIwBBIGsiAiQAIAJBHGpBADoAACACQgA3AhQgAkEENgIQIAJCADcCCCACQQhqIgUQnychBBCmOyIDJQEQDyEIEN8SIgEgCCYBIAIgATYCCCAFEKs7IQUgAUGEAU8EQCABEPIfCyADQYQBTwRAIAMQ8h8LIAJBgAE2AgggAkEIaigCACUBEE8hCBDfEiIBIAgmASABIQYgBCAEKAIAQQFqIgE2AgAgAQRAQQRBBBCtNiIBRQRAQQRBBBCjPQALIAEgBDYCACABQaioiAEQkzUhByAAQQRqIgNBqKiIATYCBCADIAE2AgAgAyAHNgIIIAAgBToAFCAAIAY2AhAgACAENgIAIAIoAggiAEGEAU8EQCAAEPIfCyACQSBqJAAPCwAL0QEBBX8CQCAAQoCAgIAQVARAIAEhBAwBCyABQQhrIgQgACAAQoDC1y+AIgBCgL6o0A9+fKciAkGQzgBuIgNBkM4AcCIFQeQAbiIGQQF0QYjQiAFqLwAAOwAAIAFBBGsgAiADQZDOAGxrIgJB//8DcUHkAG4iA0EBdEGI0IgBai8AADsAACABQQZrIAUgBkHkAGxrQf//A3FBAXRBiNCIAWovAAA7AAAgAUECayACIANB5ABsa0H//wNxQQF0QYjQiAFqLwAAOwAACyAApyAEEMAUC94BAQF/IwBBEGsiDiQAIAAoAgAgAUEQIAAoAgQoAgwRBgAhASAOQQA6AA0gDiABOgAMIA4gADYCCCAOQQhqIAJBDiADIAQQiBIgBUENIAYgBxCIEiAIQQ0gCSAKEIgSIAtBBCAMIA0QiBIhASAOLQANIgIgDi0ADCIDciEAAkAgA0EBcSACQQFHcg0AIAEoAgAiAC0ACkGAAXFFBEAgACgCAEHX8YkBQQIgACgCBCgCDBEGACEADAELIAAoAgBB1vGJAUEBIAAoAgQoAgwRBgAhAAsgDkEQaiQAIABBAXELxwECAn8BfiMAQSBrIgIkAAJAIAEEQCABQQhrIgMoAgBBAUcNASACQRhqIAFBEGopAgA3AgAgAkEQaiABQQhqKQIANwIAIAEpAgAhBCADQQA2AgAgAiAENwIIAkAgA0F/Rg0AIAFBBGsiASABKAIAQQFrIgE2AgAgAQ0AIANBIEEEEPg6CyAAIAIpAgw3AgAgAEEQaiACQRxqKAIANgIAIABBCGogAkEUaikCADcCACACQSBqJAAPCxCYPQALQf6/zABBPxCXPQALwwEBBX8CQAJAIAJBwQBJBEAgACAAKAIIIgMgACgCGCIFa0EDdCAAKAIcIgZrIgcgASACbCIESQR/IAJFDQIgByACbiIBIAJsBSAECyAGIAVBA3RqaiICQQdxIgQ2AhwgACACQQN2IgI2AhggBARAIAIgA0sNAyAAQQggAyACayIDIANBCE8bIAAoAgQgAmogAxDZIjcDEAsgAQ8LQZi2zgBBIEGous4AEJ8pAAtBuLrOABDiKwALIAIgA0HEu84AEK87AAuTCQEEfyMAQTBrIgQkACAEIAM2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAw4JAAECAwQFBgcICQsgAkIANwAADAkLIAFFBEAMCgsgAiAALQAAIgBBB3Y6AAcgAiAAQQFxOgAAIAIgAEEGdkEBcToABiACIABBBXZBAXE6AAUgAiAAQQR2QQFxOgAEIAIgAEEDdkEBcToAAyACIABBAnZBAXE6AAIgAiAAQQF2QQFxOgABDAgLIAFBAU0EQAwJCyACIAAtAAAiAUEGdjoAAyACIAFBA3E6AAAgAiAALQABIgBBBnY6AAcgAiAAQQNxOgAEIAIgAUEEdkEDcToAAiACIAFBAnZBA3E6AAEgAiAAQQR2QQNxOgAGIAIgAEECdkEDcToABQwHCyABQQJNBEAMCAsgAiAALQAAIgFBB3E6AAAgAiAALQACIgNBBXY6AAcgAiABQQN2QQdxOgABIAIgAC0AASIAQQR2QQdxOgAEIAIgAEEBdkEHcToAAyACIANBAnZBB3E6AAYgAiAAQQJ0QQRxIAFBBnZyOgACIAIgA0EBdEEGcSAAQQd2cjoABQwGCyABQQNNBEAMBwsgAiAALQAAIgFBBHY6AAEgAiABQQ9xOgAAIAIgAC0AASIBQQR2OgADIAIgAUEPcToAAiACIAAtAAIiAUEEdjoABSACIAFBD3E6AAQgAiAALQADIgBBBHY6AAcgAiAAQQ9xOgAGDAULIAFBBE0EQAwGCyACIAAtAAAiBUEfcToAACACIAAtAAQiBkEDdjoAByACIAAtAAEiAUECdkEfcToAAiACIAAtAAMiA0EBdkEfcToABSACIAFBA3RBGHEgBUEFdnI6AAEgAiAALQACIgBBAXRBHnEgAUEHdnI6AAMgAiADQQR0QRBxIABBBHZyOgAEIAIgBkECdEEccSADQQZ2cjoABgwECyABQQVNBEAMBQsgAiAALQAAIgFBP3E6AAAgAiAALQACIgNBAnY6AAMgAiAALQADIgVBP3E6AAQgAiAALQAFIgZBAnY6AAcgAiAALQABIgdBAnRBPHEgAUEGdnI6AAEgAiADQQR0QTBxIAdBBHZyOgACIAIgAC0ABCIAQQJ0QTxxIAVBBnZyOgAFIAIgBkEEdEEwcSAAQQR2cjoABgwDCyABQQZNBEAMBAsgAiAALQAAIgFB/wBxOgAAIAIgAC0ABiIDQQF2OgAHIAIgAC0AASIFQQF0Qf4AcSABQQd2cjoAASACIAAtAAIiAUECdEH8AHEgBUEGdnI6AAIgAiAALQADIgVBA3RB+ABxIAFBBXZyOgADIAIgAC0ABCIBQQR0QfAAcSAFQQR2cjoABCACIAAtAAUiAEEFdEHgAHEgAUEDdnI6AAUgAiADQQZ0QcAAcSAAQQJ2cjoABgwCCyABQQdNBEAMAwsgAiAAKQAANwAADAELIARBATYCFCAEQfyJzwA2AhAgBEIBNwIcIARBOzYCLCAEIARBKGo2AhggBCAEQQxqNgIoIARBEGpBhIrPABDvLAALIARBMGokAA8LQeS7zgBBLUHUu84AEJ8pAAvIAQEHfyMAQRBrIgIkACABKAIEIQMgAkEEaiABKAIIIgZBAEEEQQgQoBggAigCCCEEIAIoAgRBAUcEQCACKAIMIQcCQCAERQ0AIAZBA3QhASAHIQUgBCEIA0AgAUUNASAFIAM1AgAgAzEABEIghiADMQAFQiiGhIQ3AgAgBUEIaiEFIAFBCGshASADQQhqIQMgCEEBayIIDQALCyAAIAY2AgggACAHNgIEIAAgBDYCACACQRBqJAAPCyAEIAIoAgxB6JnPABD9LwALlx0CG38DfiMAQeAAayIJJAAgASgCACEPIwBBMGsiByQAIAdBADoAICAHQQA2AhQgB0EANgIMIAdBgICAgHg2AgAgB0EANgIcIwBBIGsiASQAIAcoAhwhCiAHLQAhIRQgBy0AICEVIAcoAhghECAHKAIUIQ0gBygCECERIAcoAgwhDiAHKQIEISAgBygCACESIAFBBGoiBUEKQei++wAQzhggEkGAgICAeEcEQCABQoCAgIAgNwIQIAEgIEIgiCIhPQEYIwBBEGsiDCQAIAUgAUEQaiIIKAIEIAgoAgBrEOQtIAUoAgghCyAFKAIEIRYgDEEIaiAIQQhqKAIANgIAIAwgCCkCACIiNwMAICKnIgYgDCgCBCITRwRAA0AgCyAWaiAGIAxqQQhqLQAAOgAAIAtBAWohCyATIAZBAWoiBkcNAAsgDCATNgIACyAFIAs2AgggDEEQaiQAIAEgEjYCGCABICCnIgY2AhAgASAGICGnajYCHCABIAY2AhQjAEEQayIGJAAgBSAIKAIMIAgoAgQiC2siDBDkLSAMBEAgBSgCBCAFKAIIaiALIAz8CgAACyAIIAs2AgwgBSAFKAIIIAxqNgIIIAYgCCgCADYCDCAGIAgoAgg2AgggBkEIakEBQQEQ4B4gBkEQaiQAQQQhBgsgB0EkaiESAkAgDkUNACABQQRqIA4gDiARahDoJCAOQQA6AAAgBkEIciEGIBFFDQAgDiARQQEQ+DoLAkAgDUUNACABQQRqIA0gDSAQahDoJCANQQA6AAAgBkEQciEGIBBFDQAgDSAQQQEQ+DoLAkACQAJAAkACQAJAAkACQAJAAkAgASgCDARAIAEoAghBHzoAACABKAIMIgVBAU0NASABKAIIQYsBOgABIAEoAgwiBUECTQ0CIAEoAghBCDoAAiABKAIMIgVBA00NAyABKAIIIAY6AAMgASgCDCIFQQRNDQQgASgCCCAKOgAEIAEoAgwiBUEFTQ0FIAEoAgggCkEIdjoABSABKAIMIgVBBk0NBiABKAIIIApBEHY6AAYgASgCDCIFQQdNDQcgASgCCCAKQRh2OgAHIAEoAgwiBUEITQ0IIAEoAggiBUECIA9BAklBAnQgD0EISxs6AAggASgCDCIGQQlNDQkgBSAUQX8gFUEBcRs6AAkgEiABKQIENwIAIBJBCGogAUEMaigCADYCACABQSBqJAAMCgtBAEEAQbi/+wAQwyEAC0EBIAVByL/7ABDDIQALQQIgBUHYv/sAEMMhAAtBAyAFQei/+wAQwyEAC0EEIAVB+L/7ABDDIQALQQUgBUGIwPsAEMMhAAtBBiAFQZjA+wAQwyEAC0EHIAVBqMD7ABDDIQALQQggBUG4wPsAEMMhAAtBCSAGQcjA+wAQwyEACyMAQSBrIhgkACAYQQhqIQ0jAEEgayIOJAAQiCwhASMAQSBrIgwkAAJ/QXpBt7TCAC0AAEExRw0AGkF+IAFFDQAaIAxBADoAHCAMQQg2AhggDEFxNgIUIAxBCDYCDCAMIA82AhBBACEFIwBBEGsiCCQAIAFBADYCGCAMQQxqIgooAgghBgJAIAEoAiAiFQRAIAEoAiQiFg0BCyABQQA2AihBnAshFiABQZwLNgIkQZ0LIRUgAUGdCzYCIAsgCigCBCELIAotABAhHCAKKAIMIRECQAJ/IAZBAE4EQEEBIQVBASAGQQ9NDQEaIAZBEGshBkEAIQVBAgwBC0F+IQogBkFxSQ0BQQAgBmshBkEACyEdQX4hCiAGQXhxQQhHIBFBAWtBCEtyDQAgBkEIRyAFckVBBiALIAtBf0YbIh5BCUtyDQAgCCAWNgIIIAggFTYCBCAIIAEoAig2AgxBfCEKIAhBBGoiHyILQcAAQcAWELYbIgVFDQBBAUEJIAYgBkEIRhsiGXQhFyALQQIgGXQiBhCBGiETIAtBAiAGELYbIQ8gC0ECQYCACBC2GyEQIAtBAUGAAiARdCIaELYbIRQgC0HAASARdCIbEIEaIQsCQAJAIA9FIBBFIBNFcnJBASAUGwRAIAsEQCAfIAsgGxCNGQsgFEUNAgwBCyALRQ0AIAYEQCAPQQAgBvwLAAsgEEEAQYCACPwLACAFQgA3AAUgBSAeOgAEIAUgHDoAAyAFIB06AAIgBUEBOwEAIAVBDGpCADcAACAFQQA2AjwgBSAQNgIwIAUgFzYCLCAFIA82AiggBUEANgIkIAUgFzYCICAFIBk2AhwgBSAGNgIYIAUgEzYCFCAFQQA2AjQgBUE3akEANgAAIAUgCzYCQCAFIBs2AkQgBUEANgJIIAVBwAAgEXQ2AkwgBUEANgJQIAUgFDYCWCAFIBo2AlwgBUHwAGpBADoAACAFQegAakIANwIAIAVCADcCYCAFQfgAakEAQSz8CwAgBUGkAWpB8ML7AEH8EfwKAAAgBUGgE2pBgNX7AEH8AfwKAAAgBUGcFWpB/Nb7AEGkAfwKAAAgASAFNgIcQX4hCiAVRSAWRXINAiABQQI2AiwgAUIANwIUIAFBADYCCCABKAIcIgVBADYCZCAFIAUtAAIiBiAGwEEHdSIGcyAGayIGOgACIAVBBEEBIAZB/wFxIgpBAkYbOgAAQQEhBiAKQQJGBEAgBUEANgKgAUEAIQYLIAVBkPT7ADYCnBUgBUHg8/sANgKgEyAFQcTz+wA2AqQBIAVB/gE6AAEgASAGNgIwIAVBADoAcCAFQgA3A2ggBRCxGiAFIAUoAiBBAXQ2AlAgBSgCMEEAQYCACPwLACAFLQAEIgbAIQoCQCAGQQlNBEAgBSAGOgAEIAUgCkEMbCIGQeKA/QBqLwEAIgo7ATYgBSAGQeCA/QBqLwEAOwEKIAUgBkHcgP0Aai8BADsBCCAFIAZB3oD9AGovAQA7ATggBSAKQYAISzoABgwBCyAKQQpBoNj7ABDDIQALIAVBADYCPCAFQQA2AhAgBUEANgIkIAVBADsBNCAFQgA3A4ABIAVBADsBDCAFQQA6AAdBACEKDAILIAhBBGogFCAaEI4ZCyAQBEAgCEEEaiAQEOMYCyAPBEAgCEEEaiAPIBcQ5BgLIBMEQCAIQQRqIBMgBhCNGQsgCEEEaiAFEOUYCyAIQRBqJAAgCgshBSAMQSBqJAAgDiAFNgIEAkAgBUUEQCANQgA3AwAgDSABNgIQIA1BCGpCADcDACAOQSBqJAAMAQsgDkEANgIIIA5BBGogDkEIakGAvvsAEI4rAAsjAEEQayIBJAAgAUEEakGAgAJBAEEBQQEQoBggASgCCCEGIAEoAgRBAUYEQCAGIAEoAgxB4PTNABD9LwALIAEoAgwhCCAJQRhqIgUgBDYCGCAFQQA2AiQgBSAINgIgIAUgBjYCHCAFIA0pAwA3AwAgBUEIaiANQQhqKQMANwMAIAVBEGogDUEQaikDADcDACABQRBqJAAgCRCPKyAJQQA2AkAgCSASKQIANwJEIAlBzABqIBJBCGooAgA2AgAgGEEgaiQAIAdBMGokACAJQdgAaiEMIwBBEGsiBSQAAkACQCADBEADQCAFQQhqIQQjAEEgayIBJAACQAJAAkAgCSgCQEUEQCABQQhqIAkQgRgCQCABLQAIQQRGDQAgASkDCCIgQv8Bg0IEUQ0AIAQgIDcCAAwECyABQQhqIQYjAEEQayIHJAAgCUEYaiIIQRxqIQ0CQANAIAcgCBCDGAJAIActAABBBEYNACAHKQMAIiBC/wGDQgRRDQAgBkEBNgIAIAYgIDcCBAwCCyAIKQMAISAgByAIIAIgAyANQQAQkDYgBy0AACIOIAgpAwAgIH2nIgogA0VyckUgBy0AASILQQJHcQ0AC0EBIQgCQCAOQQFxBEAgBkEEakEUQcj0zQBBFhDNGgwBCyAGIAs6AAggBiAKNgIEQQAhCAsgBiAINgIACyAHQRBqJAACfyABKAIIRQRAIAEoAgwMAQsgASkCDCIgQv8Bg0IEUg0CICBCIIinCyIHIANLDQIgCSACIAcQgzEgBEEEOgAAIAQgBzYCBAwDCyABQQA2AghBACAJQUBrQZD1zQAgAUEIakGk9c0AEK8rAAsgBCAgNwIADAELIAcgA0GU9c0AELA7AAsgAUEgaiQAAkACQAJAAkACQCAFLQAIIgFBBEcEQAJAIAFBAWsOAwAEAgkLIAUtAAlBI0cNCAwECyAFKAIMIgFFBEBByPDNACEEDAgLIAEgA00NASABIANB0PDNABCvOwALIAUoAgwtAAhBI0YNAgwGCyABIAJqIQIgAyABayEDDAILIAUoAgwtAAhBI0cNBAsgBUEIahC5LgsgAw0ACwsgDEEEOgAADAELIAwgBCkCADcCAAsgBUEQaiQAAkACQCAJLQBYQQRGDQAgCSkDWCIgQv8Bg0IEUQ0AIAkgIDcDWCAAIAwQgSsMAQsgCUHQAGogCRDOECAJLQBQQQRHBEAgCSAJKQNQNwNYIAAgCUHYAGoQgSsMAQsgAEEINgIACyMAQRBrIgAkAAJAIAkoAjBFDQAgAEEIaiIBIAkQzhAgAC0ACEEERg0AIAEQuS4LIABBEGokACMAQRBrIgAkAAJAIAlBGGoiASgCGEUNACAAQQhqIgIgARCCGCAALQAIQQRGDQAgAhC5LgsgAEEQaiQAIAkoAighASMAQRBrIgMkAAJAIAFFDQAgASgCIEUNACABKAIkRQ0AIAEoAhxFDQAgAUEgaiECIAEoAhwiAC0AACEEIAAoAkQiBQRAIAAoAkAhByAAQgE3A0AgAiAHIAUQjRkLIAIgACgCWCAAKAJcEI4ZIAIgACgCMBDjGCAAKAIsIgUEQCACIAAoAiggBRDkGAsgACgCGCIFBEAgACgCFCEHIABCATcCFCACIAcgBRCNGQsgAUEANgIcIAIgABDlGCADQQhqIgAgATYCBCAAIARBAkY2AgAgAygCCBoLIANBEGokACAJQShqEIY7IAlBNGoQ3jsgCUHEAGoQ3jsgCUHgAGokAAvAAQEBfyMAQRBrIgkkACAJIAM2AgwgCCAJQQxqIAEgAiAIQdjFABD5JxpBACEDAn8CQAJAAn8CQAJAIAAOAgADAQsgBiAHIAggCSgCDBCEIAwBCyAAQX5xQQJHDQEgBCAIIAkoAgwQ7hULIgNBiH9LDQELIAEgAmohAANAIAAgAU1FBEAgASEIIAUEQCAFIAEtAABqIQgLIAFBAWohASADIAgtAABqIQMMAQsLIANBA3YMAQsgAkEKbAsgCUEQaiQAC8cBAQJ/IwBBIGsiBCQAIAQgACgCBCIFNgIEIAVBEEYEQCABQQ9xQQF0IQEgACgCACEAA0AgACABaiIFIAUvAQAgAmo7AQAgAUECaiIBQSBHDQALIAAvAR4gA0H//wNxTwRAQQAhAQNAIAAgAWoiAiABQZCH8wBqLwEAIAIvAQBqIgIgAkH8/wNxQQJ2azsBACABQQJqIgFBIEcNAAsLIARBIGokAA8LIARBADYCCEEAIARBBGpB7IbzACAEQQhqQbCH8wAQrysAC+MBAgN/An4jAEEQayIHJAAgByACQQBBAUEBEKAYIAcoAgQhCCAHKAIAQQFHBEAgBygCCCEJIAIEQCAJIAEgAvwKAAALIAdBpPb+ABClKyAHKQMAIQogBykDCCELIAAgAjYCPCAAIAk2AjggACAINgI0IAAgBDoAQCAAIAY6AEEgACAFNwMgIABBsPb+ACkDADcDACAAQQhqQbj2/gApAwA3AwAgACALNwMYIAAgCjcDECAAIAMpAgA3AiggAEEwaiADQQhqKAIANgIAIAdBEGokAA8LIAggBygCCEHg9v4AEP0vAAvPBQEOfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBfHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBAnZBAEECQQIQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEQayIIJAAgA0EIaiIEIAIoAgQgAigCAGtBAnYQ7S0gCCAEKQIEQiCJNwIIIAggBEEIajYCBCMAQTBrIgQkACAIQQRqIgcoAgQhCSAHKAIAIQ4CQAJAAkAgAigCACIGIAIoAgQiCkcEQCACKAIUIQwgAigCECEPIAIoAgwhECACKAIIIQIgBygCCCAJQQF0aiEHIAogBmtBAnYhCgNAIAQgBjYCDAJAIA8gBigCACILSwRAIBAgC0EBdGovAQAhCwwBCyACIAwoAhBPDQNBACELIAwoAgQgAiAMKAIMaiIRQQN2ai0AACARQQdxdkEBcQ0ECyAHIAs7AQAgBkEEaiEGIAdBAmohByACQQFqIQIgCUEBaiEJIApBAWsiCg0ACwsgDiAJNgIAIARBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIARBATYCFCAEQdy2ggE2AhAgBEIBNwIcIARB7QY2AiwgBCAEQShqNgIYIAQgBEEMajYCKCAEQRBqQeS2ggEQ7ywACyAIQRBqJAAgAUEIaiANKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAFIAI2AhggBSABNgIUIAUgBCADQXxxajYCECAFIAQ2AgwgBUEkaiIBIAVBDGoQihsLIAAgARDpGCAFQTBqJAALiQMBBH8jAEEwayIEJAACQAJAIAMQkjYiBUUNACAFKAIURQ0AIAMoAhAhBiADKAIUIQMgBCAFNgIgIAQgAjYCHCAEIAE2AhggBEEANgIUIAQgBiADQXxxajYCECAEIAY2AgwgBEEkaiEBIwBBIGsiAiQAIAJBFGogBEEMaiIDKAIEIAMoAgBrQQJ2QQBBBEEEEKAYIAIoAhghBSACKAIUQQFGBEAgBSACKAIcQbz8gQEQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiAFNgIIIwBBEGsiBSQAIAJBCGoiBiADKAIEIAMoAgBrQQJ2EO4tIAUgBikCBEIgiTcCCCAFIAZBCGo2AgQgAyAFQQRqEOIQIAVBEGokACABQQhqIAcoAgA2AgAgASACKQIINwIAIAJBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCdGwsgACABEOgYIARBMGokAAvBAQEDfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIgEgBEEMahCMGwwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCBGwsgACABEL0YIARBMGokAAuJAwEEfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIQEjAEEgayICJAAgAkEUaiAEQQxqIgMoAgQgAygCAGtBAnZBAEEBQQEQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBvPyBARD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAU2AggjAEEQayIFJAAgAkEIaiIGIAMoAgQgAygCAGtBAnYQgS4gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCADIAVBBGoQsxEgBUEQaiQAIAFBCGogBygCADYCACABIAIpAgg3AgAgAkEgaiQADAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEJQbCyAAIAEQ7hggBEEwaiQAC88FAQ5/IwBBMGsiBSQAAkACQCADEJI2IgRFDQAgBCgCFEUNACADKAIQIQYgAygCFCEDIAUgBDYCICAFIAI2AhwgBSABNgIYIAVBADYCFCAFIAYgA0F8cWo2AhAgBSAGNgIMIAVBJGohASMAQSBrIgMkACADQRRqIAVBDGoiAigCBCACKAIAa0ECdkEAQQJBAhCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEG8/IEBEP0vAAsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBDYCCCMAQRBrIggkACADQQhqIgQgAigCBCACKAIAa0ECdhDtLSAIIAQpAgRCIIk3AgggCCAEQQhqNgIEIwBBMGsiBCQAIAhBBGoiBygCBCEJIAcoAgAhDgJAAkACQCACKAIAIgYgAigCBCIKRwRAIAIoAhQhDCACKAIQIQ8gAigCDCEQIAIoAgghAiAHKAIIIAlBAXRqIQcgCiAGa0ECdiEKA0AgBCAGNgIMAkAgDyAGKAIAIgtLBEAgECALQQF0ai8BACELDAELIAIgDCgCEE8NA0EAIQsgDCgCBCACIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDQQLIAcgCzsBACAGQQRqIQYgB0ECaiEHIAJBAWohAiAJQQFqIQkgCkEBayIKDQALCyAOIAk2AgAgBEEwaiQADAILQYyyggFBIEGssoIBEJ8pAAsgBEEBNgIUIARB3LaCATYCECAEQgE3AhwgBEG7EzYCLCAEIARBKGo2AhggBCAEQQxqNgIoIARBEGpB5LaCARDvLAALIAhBEGokACABQQhqIA0oAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBfHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCKGwsgACABEOkYIAVBMGokAAuJAwEEfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIQEjAEEgayICJAAgAkEUaiAEQQxqIgMoAgQgAygCAGtBAnZBAEEEQQQQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBvPyBARD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAU2AggjAEEQayIFJAAgAkEIaiIGIAMoAgQgAygCAGtBAnYQ7i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCADIAVBBGoQ4xAgBUEQaiQAIAFBCGogBygCADYCACABIAIpAgg3AgAgAkEgaiQADAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEJ0bCyAAIAEQ6BggBEEwaiQAC8EBAQN/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGoiASAEQQxqEIYbDAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEIEbCyAAIAEQvRggBEEwaiQAC4kDAQR/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgIkACACQRRqIARBDGoiAygCBCADKAIAa0ECdkEAQQFBARCgGCACKAIYIQUgAigCFEEBRgRAIAUgAigCHEG8/IEBEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgBTYCCCMAQRBrIgUkACACQQhqIgYgAygCBCADKAIAa0ECdhCBLiAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAMgBUEEahCyESAFQRBqJAAgAUEIaiAHKAIANgIAIAEgAikCCDcCACACQSBqJAAMAQsgAygCECEFIAMoAhQhAyAEIAI2AhggBCABNgIUIAQgBSADQXxxajYCECAEIAU2AgwgBEEkaiIBIARBDGoQlBsLIAAgARDuGCAEQTBqJAALhAYCDn8BfiMAQTBrIgYkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEFIAMoAhQhAyAGIAQ2AiAgBiACNgIcIAYgATYCGCAGQQA2AhQgBiAFIANBeHFqNgIQIAYgBTYCDCAGQSRqIQEjAEEgayIDJAAgA0EUaiAGQQxqIgIoAgQgAigCAGtBA3ZBAEECQQIQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIFIAIoAgQgAigCAGtBA3YQ7S0gBSkCBCESIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgEkIgiTcCKCAEIAVBCGo2AiQjAEEwayICJAAgBEEkaiIHKAIEIQkgBygCACEOAkACQAJAIARBCGoiBSgCACIIIAUoAgQiCkcEQCAFKAIUIQwgBSgCECEPIAUoAgwhECAFKAIIIQUgBygCCCAJQQF0aiEHIAogCGtBA3YhCgNAIAIgCDYCDAJAIAgoAgAiCyAPSQRAIBAgC0EBdGovAQAhCwwBCyAFIAwoAhBPDQNBACELIAwoAgQgBSAMKAIMaiIRQQN2ai0AACARQQdxdkEBcQ0ECyAHIAs7AQAgCEEIaiEIIAdBAmohByAFQQFqIQUgCUEBaiEJIApBAWsiCg0ACwsgDiAJNgIAIAJBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyAEQTBqJAAgAUEIaiANKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAGIAI2AhggBiABNgIUIAYgBCADQXhxajYCECAGIAQ2AgwgBkEkaiIBIAZBDGoQixsLIAAgARDpGCAGQTBqJAALvAMCBH8BfiMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIGIAIoAgQgAigCAGtBA3YQ7i0gBikCBCEIIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgCEIgiTcCKCAEIAZBCGo2AiQgBEEIaiAEQSRqEOEQIARBMGokACABQQhqIAcoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBeHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCDGwsgACABEOgYIAVBMGokAAvBAQEDfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBeHFqNgIQIAQgBjYCDCAEQSRqIgEgBEEMahD3GgwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBeHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCCGwsgACABEL0YIARBMGokAAu8AwIEfwF+IwBBMGsiBSQAAkACQCADEJI2IgRFDQAgBCgCFEUNACADKAIQIQYgAygCFCEDIAUgBDYCICAFIAI2AhwgBSABNgIYIAVBADYCFCAFIAYgA0F4cWo2AhAgBSAGNgIMIAVBJGohASMAQSBrIgMkACADQRRqIAVBDGoiAigCBCACKAIAa0EDdkEAQQFBARCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEG8/IEBEP0vAAsgA0EQaiIHQQA2AgAgAyADKAIcNgIMIAMgBDYCCCMAQTBrIgQkACADQQhqIgYgAigCBCACKAIAa0EDdhCBLiAGKQIEIQggBEEYaiACQRBqKQIANwMAIARBEGogAkEIaikCADcDACAEIAIpAgA3AwggBCAIQiCJNwIoIAQgBkEIajYCJCAEQQhqIARBJGoQsBEgBEEwaiQAIAFBCGogBygCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJobCyAAIAEQ7hggBUEwaiQAC4QGAg5/AX4jAEEwayIGJAACQAJAIAMQkjYiBEUNACAEKAIURQ0AIAMoAhAhBSADKAIUIQMgBiAENgIgIAYgAjYCHCAGIAE2AhggBkEANgIUIAYgBSADQXhxajYCECAGIAU2AgwgBkEkaiEBIwBBIGsiAyQAIANBFGogBkEMaiICKAIEIAIoAgBrQQN2QQBBAkECEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQbz8gQEQ/S8ACyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAENgIIIwBBMGsiBCQAIANBCGoiBSACKAIEIAIoAgBrQQN2EO0tIAUpAgQhEiAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIBJCIIk3AiggBCAFQQhqNgIkIwBBMGsiAiQAIARBJGoiBygCBCEJIAcoAgAhDgJAAkACQCAEQQhqIgUoAgAiCCAFKAIEIgpHBEAgBSgCFCEMIAUoAhAhDyAFKAIMIRAgBSgCCCEFIAcoAgggCUEBdGohByAKIAhrQQN2IQoDQCACIAg2AgwCQCAIKAIAIgsgD0kEQCAQIAtBAXRqLwEAIQsMAQsgBSAMKAIQTw0DQQAhCyAMKAIEIAUgDCgCDGoiEUEDdmotAAAgEUEHcXZBAXENBAsgByALOwEAIAhBCGohCCAHQQJqIQcgBUEBaiEFIAlBAWohCSAKQQFrIgoNAAsLIA4gCTYCACACQTBqJAAMAgtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgBEEwaiQAIAFBCGogDSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBiACNgIYIAYgATYCFCAGIAQgA0F4cWo2AhAgBiAENgIMIAZBJGoiASAGQQxqEIsbCyAAIAEQ6RggBkEwaiQAC7wDAgR/AX4jAEEwayIFJAACQAJAIAMQkjYiBEUNACAEKAIURQ0AIAMoAhAhBiADKAIUIQMgBSAENgIgIAUgAjYCHCAFIAE2AhggBUEANgIUIAUgBiADQXhxajYCECAFIAY2AgwgBUEkaiEBIwBBIGsiAyQAIANBFGogBUEMaiICKAIEIAIoAgBrQQN2QQBBBEEEEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQbz8gQEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIwBBMGsiBCQAIANBCGoiBiACKAIEIAIoAgBrQQN2EO4tIAYpAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAhCIIk3AiggBCAGQQhqNgIkIARBCGogBEEkahDkECAEQTBqJAAgAUEIaiAHKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAFIAI2AhggBSABNgIUIAUgBCADQXhxajYCECAFIAQ2AgwgBUEkaiIBIAVBDGoQgxsLIAAgARDoGCAFQTBqJAALwQEBA38jAEEwayIEJAACQAJAIAMQkjYiBUUNACAFKAIURQ0AIAMoAhAhBiADKAIUIQMgBCAFNgIgIAQgAjYCHCAEIAE2AhggBEEANgIUIAQgBiADQXhxajYCECAEIAY2AgwgBEEkaiIBIARBDGoQ+BoMAQsgAygCECEFIAMoAhQhAyAEIAI2AhggBCABNgIUIAQgBSADQXhxajYCECAEIAU2AgwgBEEkaiIBIARBDGoQghsLIAAgARC9GCAEQTBqJAALvAMCBH8BfiMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEBQQEQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIGIAIoAgQgAigCAGtBA3YQgS4gBikCBCEIIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgCEIgiTcCKCAEIAZBCGo2AiQgBEEIaiAEQSRqELERIARBMGokACABQQhqIAcoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBeHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCaGwsgACABEO4YIAVBMGokAAvgAwEGfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgAigCBCACKAIAa0EDdiIIIANBCGoiBigCACAGKAIIIgdrSwRAIAYgByAIQRBBEBDeKCAGKAIIIQcLIAYoAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAg2AiwgBCAHNgIoIAQgBkEIajYCJCAEQQhqIARBJGoQqRAgBEEwaiQAIAFBCGogCSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJYbCyAAIAEQuhggBUEwaiQAC68DAQZ/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgMkACADQRRqIARBDGoiAigCBCACKAIAa0ECdkEAQRBBEBCgGCADKAIYIQUgAygCFEEBRgRAIAUgAygCHEG8/IEBEP0vAAsgA0EQaiIIQQA2AgAgAyADKAIcNgIMIAMgBTYCCCMAQRBrIgUkACACKAIEIAIoAgBrQQJ2IgkgA0EIaiIGKAIAIAYoAggiB2tLBEAgBiAHIAlBEEEQEN4oIAYoAgghBwsgBSAGKAIENgIMIAUgBzYCCCAFIAZBCGo2AgQgAiAFQQRqEKsQIAVBEGokACABQQhqIAgoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCQGwsgACABELoYIARBMGokAAvgAwEGfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgAigCBCACKAIAa0EDdiIIIANBCGoiBigCACAGKAIIIgdrSwRAIAYgByAIQRBBEBDeKCAGKAIIIQcLIAYoAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAg2AiwgBCAHNgIoIAQgBkEIajYCJCAEQQhqIARBJGoQrBAgBEEwaiQAIAFBCGogCSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJYbCyAAIAEQuhggBUEwaiQAC68DAQZ/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgMkACADQRRqIARBDGoiAigCBCACKAIAa0ECdkEAQRBBEBCgGCADKAIYIQUgAygCFEEBRgRAIAUgAygCHEG8/IEBEP0vAAsgA0EQaiIIQQA2AgAgAyADKAIcNgIMIAMgBTYCCCMAQRBrIgUkACACKAIEIAIoAgBrQQJ2IgkgA0EIaiIGKAIAIAYoAggiB2tLBEAgBiAHIAlBEEEQEN4oIAYoAgghBwsgBSAGKAIENgIMIAUgBzYCCCAFIAZBCGo2AgQgAiAFQQRqEKoQIAVBEGokACABQQhqIAgoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCQGwsgACABELoYIARBMGokAAvQAQEBfyMAQTBrIgQkACAEIAI2AgwgBCADNgIQAkAgASgCECACIANqTwRAIAEoAgghAiAEIAEoAgQiAzYCICAEIAMgAkEDdGo2AiQgBCAEQRBqNgIsIAQgBEEMajYCKCAEQRRqIARBIGpBwPaEARCfGyABKAIMIgEgASgCACICQQFqNgIAIAJBAEgNASAAIAE2AgwgACAEKQIUNwIAIAAgBCgCEDYCECAAQQhqIARBHGooAgA2AgAgBEEwaiQADwtB6P+EAUE2QaCAhQEQnykLAAu6AQEDfyMAQSBrIgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIEQQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFIAILNgIYIANBCGogBCADQRRqEKIbIAMoAghBAUcNASADKAIQIQUgAygCDAsgBUGowYkBEP0vAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC8oBAQF/IwBBMGsiAiQAAn8gAC0ABEEBRgRAIAIgAC0ABToAByACQQI2AhwgAkHQ+YkBNgIYIAJCAjcCJCACIACtQoCAgICwB4Q3AxAgAiACQQdqrUKAgICAsPcAhDcDCCACIAJBCGo2AiAgASgCACABKAIEIAJBGGoQywoMAQsgAkEBNgIcIAJBjPqJATYCGCACQgE3AiQgAiAArUKAgICAsAeENwMIIAIgAkEIajYCICABKAIAIAEoAgQgAkEYahDLCgsgAkEwaiQAC7wBAgR+An8jAEEQayIGJAAgBkIAIAB9IAAgAUIAUyIHGyIDQgAgASAAQgBSrXx9IAEgBxsiAiACeSADeUJAfSACQgBSGyIEp0H/AHEQxiMgBikDCCECIAYpAwAhAyAGQRBqJAAgAkILiCIFIAFCgICAgICAgICAf4OEQgBCgICAgICAgOjHACAEQjSGfSAAIAGEUBt8IANC/////w+DIAJCNYYiACADQguIhIQgBUJ/hSAAQj+Ig31CP4h8vwvRAQEBfwJAIAAoAlBBgICAgHhGDQAgACgCCEGAgICAeEcEQCAAQQhqEN47CyAAKAIUQYCAgIB4RwRAIABBFGoiARDgKSABEPI7CyAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSxqEIYfCyAAKAIgQYCAgIB4RwRAIABBIGoQ3jsLIABB0ABqIgEQ3BggARDsOyAAKAI4QYCAgIB4RwRAIABBOGoiARDGKiABEOg7CyAAKAJEQYCAgIB4Rg0AIABBxABqIgAQxyogABDoOwsL5gEBAn8CQCAAKAIARQ0AIABBBGohAgJAAkACQCAALQAsDgQAAgIBAgsgAigCACIBIAEoAgBBAWsiATYCACABRQRAIAIQ1CILIAAoAggiAkGEAUkNASACEPIfDAELAkACQAJAAkAgAC0AKA4EAAMDAQMLIAAoAhgiAUGDAU0NAgwBCyAAKAIgIgFBgwFNDQELIAEQ8h8LIAAoAhAiASABKAIAQQFqNgIAIAAoAgQiASABKAIAQQFrIgE2AgAgAQ0AIAIQ1CILIAAoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAAQ6ScLC8ABAQl/IAAgACgCCCICIAAoAgAiBElBA3RqIgYgAEEYQRAgACgCGCAAKAIQSSIFG2oiAyAAIAIgBE9BA3RqIgIgAEEQQRggBRtqIgAoAgAgAigCAEkiBBsgAygCACAGKAIASSIFGyIHKAIAIQkgACACIAMgBRsgBBsiCCgCACEKIAEgAyAGIAUbKQIANwIAIAEgCCAHIAkgCksiAxspAgA3AgggASAHIAggAxspAgA3AhAgASACIAAgBBspAgA3AhgLowECBX8BfiABBEAgAUEBRwRAIAAgAUEDdGohBiAAQQgiAWohAgNAIAIoAgAiBCACQQhrKAIASQRAIAI1AgQhByABIQMCfwNAIAAgA2oiBSAFQQhrKQIANwIAIAAgA0EIRg0BGiADQQhrIQMgBCAFQRBrKAIASQ0ACyAAIANqCyAErSAHQiCGhDcCAAsgAUEIaiEBIAJBCGoiAiAGRw0ACwsPCwAL4QEBAX8DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCDEGAgICAeEYNAiAAQQxqIAEoAgQoAgAgASgCACgCAGsiAiABKAIIIgEvAQJBAWsQqSUgACgCGEGAgICAeEYNASAAQRhqIAIgAS8BABCpJQ8LIAAoAgwiAkUNACAAKAIIIQAgAkHIAGwhAgNAIAAgARDWFiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MPNABCyOwAFIAAoAgQhAAwBCwALAAveAQEBfwNAIAAoAgAiA0EfdSADQf////8Ha3EiA0EBa0EDTwRAAkACQAJAAkACQCADQQFrDgQAAAACAQsACyAAKAIYQYCAgIB4Rg0BIABBGGogAigCACICIAEvAQBBAWsQqSUgACgCDEGAgICAeEYNAiAAQQxqIAIgAS8BAkEBaxCpJQ8LIAAoAgwiAwRAIAAoAgghACADQcgAbCEDA0AgACABIAIQ1xYgAEHIAGohACADQcgAayIDDQALCw8LQaTEzQAQsjsAC0HExM0AELI7AAUgACgCBCEADAELAAsAC8cBAQF/IwBB0ABrIgMkACAAAn8gAkUEQEEAIQIgA0EANgI8IANBAjYCKCADQZi1zgA2AiQgA0ICNwIwIANBOzYCTCADQTs2AkQgA0Gstc4ANgJAIAMgA0FAazYCLCADIANBPGo2AkggA0EIakEEciADQSRqEJkOIAAgAykADTcABSAAQQ1qIANBFWopAAA3AAAgAEEUaiADQRxqKAAANgAAIAMtAAwMAQtBCCECIAEtAABBAEcLOgAEIAAgAjYCACADQdAAaiQAC8oBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCABIANqIAIgA2sQxiAiASAAKAIEIgJPDQEgACgCACABQQF0aiICLwEAQT9xIAFBBnRyIgEgACgCDCIDTw0CIAAoAgggAUECdGogBDYCACACIAIvAQBBAWo7AQAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpB/NXOABDvLAALIAEgAkGM1s4AEMMhAAsgASADQZzWzgAQwyEAC8oBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCABIANqIAIgA2sQxyAiASAAKAIEIgJPDQEgACgCACABQQF0aiICLwEAQQ9xIAFBBHRyIgEgACgCDCIDTw0CIAAoAgggAUECdGogBDYCACACIAIvAQBBAWo7AQAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpB/NXOABDvLAALIAEgAkGM1s4AEMMhAAsgASADQZzWzgAQwyEAC9IBAQZ/IAEoAgwhBCABKAIIIQUCQAJAAkACQCABKAIQIgMgASgCFCICRgRAIAEoAgAhBiABKAIEIgcgBCAEIAdLGyICQQFGDQEgAkUNAiAFIAYgAvwKAAAMAgsgAiADSQ0DIAIgBE0NAiACIARBhMbQABCwOwALIAUgBi0AADoAAAsgASACNgIUQQAhAyABQQA2AhAgASAHIAJrNgIEIAEgAiAGajYCAAsgAEEANgIAIAAgAiADazYCCCAAIAMgBWo2AgQPCyADIAJBhMbQABCxOwAL1QEBAX8gACgCyAEhBSAAKALMAUECTwRAAkACQAJAAkAgBUEFaw4DAQIDAAsgACABIAIgAyAEQQRBARCzBg8LIAAgASACIAMgBEEFQQEQswYPCyAAIAEgAiADIARBBkEBELMGDwsgACABIAIgAyAEQQdBARCzBg8LAkACQAJAAkAgBUEFaw4DAQIDAAsgACABIAIgAyAEQQRBABCzBg8LIAAgASACIAMgBEEFQQAQswYPCyAAIAEgAiADIARBBkEAELMGDwsgACABIAIgAyAEQQdBABCzBgu7AQEBfwJAIAAoAgwiBUUNACAAKAIEIAVPDQAgACgCGCIFIANNBEAgAyAFSwRAIAAgAyAFaxCIHwsgACADIAQQkRYgACgCGCEFCyADIAAoAhRJIAMgBU9yDQAgBSADayIEQQNJDQAgAigCACIDBEAgA0H/H0sNASAEIAEgA0EDdGpBBGsoAgBNDQELIAEgA0EDdGogBDYCBCABIAIoAgBBA3RqIAAoAhxBA2o2AgAgAiACKAIAQQFqNgIACwvAAQEBfyMAQSBrIgQkACAAIAAQgBogACADOwEUIAAgAjsBEiAAIAE7ARAgBEEUaiIBIANB//8DcSICELAVIARBCGogAUHUqPsAEJghIAAoAgQhASAAKAIAIQMgACAEKQMINwIAIAEEQCADIAFBAnRBBBD4OgsgBEEUaiIBIAJBuAhsEPcbIAQgAUHUqPsAEJYhIAAoAgwhASAAKAIIIQIgACAEKQMANwIIIAEEQCACIAFBAnRBAhD4OgsgBEEgaiQAC74BAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFCACEL0WIANBDGoiBCABEJI2IAIQ8hIgA0EkaiICIAMgBBDYHSADQdQAaiIEIAEQygYgBBCaHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8AEAQh/IwBB4ABrIgUkACABKAIQIQQgASgCFCEIIwBBMGsiAyQAAkACQCACEJI2IgdFDQAgBygCFEUNACACKAIQIQYgAigCFCEJIAMgBzYCICADIAg2AhwgAyAENgIYIANBADYCFCADIAYgCUF8cWo2AhAgAyAGNgIMIANBJGohCCMAQSBrIgQkACAEQRRqIANBDGoiBygCBCAHKAIAa0ECdkEAQQFBARCgGCAEKAIYIQYgBCgCFEEBRgRAIAYgBCgCHEG8/IEBEP0vAAsgBEEQaiIKQQA2AgAgBCAEKAIcNgIMIAQgBjYCCCMAQRBrIgYkACAEQQhqIgkgBygCBCAHKAIAa0ECdhCELiAGIAkpAgRCIIk3AgggBiAJQQhqNgIEIAcgBkEEahCzESAGQRBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhBiADIAg2AhggAyAENgIUIAMgByAGQXxxajYCECADIAc2AgwgA0EkaiIIIANBDGoQnhsLIAUgCBDuGCADQTBqJAAgBUEMaiIDIAEQkjYgAhDyEiAFQSRqIgIgBSADEMEdIAVB1ABqIgMgARDKBiADEJseIABBCGogBUHcAGooAgA2AgAgACAFKQJUNwIAIAAgBSkCMDcCDCAAQRRqIAVBOGooAgA2AgAgACAFKQI8NwIYIABBIGogBUHEAGopAgA3AgAgAEEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAALvgEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUIAIQwRYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENgdIANB1ABqIgQgARDKBiAEEJoeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwAQBCH8jAEHgAGsiBSQAIAEoAhAhBCABKAIUIQgjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhBiACKAIUIQkgAyAHNgIgIAMgCDYCHCADIAQ2AhggA0EANgIUIAMgBiAJQXxxajYCECADIAY2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQJ2QQBBAUEBEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIARBCGoiCSAHKAIEIAcoAgBrQQJ2EIQuIAYgCSkCBEIgiTcCCCAGIAlBCGo2AgQgByAGQQRqELIRIAZBEGokACAIQQhqIAooAgA2AgAgCCAEKQIINwIAIARBIGokAAwBCyACKAIQIQcgAigCFCEGIAMgCDYCGCADIAQ2AhQgAyAHIAZBfHFqNgIQIAMgBzYCDCADQSRqIgggA0EMahCeGwsgBSAIEO4YIANBMGokACAFQQxqIgMgARCSNiACEPISIAVBJGoiAiAFIAMQwR0gBUHUAGoiAyABEMoGIAMQmx4gAEEIaiAFQdwAaigCADYCACAAIAUpAlQ3AgAgACAFKQIwNwIMIABBFGogBUE4aigCADYCACAAIAUpAjw3AhggAEEgaiAFQcQAaikCADcCACAAQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokAAu+AQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhQgAhDFFiADQQxqIgQgARCSNiACEPMSIANBJGoiAiADIAQQ2B0gA0HUAGoiBCABEMoGIAQQmh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvzBAIIfwF+IwBB4ABrIgYkACABKAIQIQQgASgCFCEFIwBBMGsiAyQAAkACQCACEJI2IgdFDQAgBygCFEUNACACKAIQIQggAigCFCEJIAMgBzYCICADIAU2AhwgAyAENgIYIANBADYCFCADIAggCUF4cWo2AhAgAyAINgIMIANBJGohCCMAQSBrIgQkACAEQRRqIANBDGoiBygCBCAHKAIAa0EDdkEAQQFBARCgGCAEKAIYIQUgBCgCFEEBRgRAIAUgBCgCHEG8/IEBEP0vAAsgBEEQaiIKQQA2AgAgBCAEKAIcNgIMIAQgBTYCCCMAQTBrIgUkACAEQQhqIgkgBygCBCAHKAIAa0EDdhCELiAJKQIEIQsgBUEYaiAHQRBqKQIANwMAIAVBEGogB0EIaikCADcDACAFIAcpAgA3AwggBSALQiCJNwIoIAUgCUEIajYCJCAFQQhqIAVBJGoQsBEgBUEwaiQAIAhBCGogCigCADYCACAIIAQpAgg3AgAgBEEgaiQADAELIAIoAhAhByACKAIUIQggAyAFNgIYIAMgBDYCFCADIAcgCEF4cWo2AhAgAyAHNgIMIANBJGoiCCADQQxqEJEbCyAGIAgQ7hggA0EwaiQAIAZBDGoiAyABEJI2IAIQ8xIgBkEkaiICIAYgAxDBHSAGQdQAaiIDIAEQygYgAxCbHiAAQQhqIAZB3ABqKAIANgIAIAAgBikCVDcCACAAIAYpAjA3AgwgAEEUaiAGQThqKAIANgIAIAAgBikCPDcCGCAAQSBqIAZBxABqKQIANwIAIABBKGogBkHMAGopAgA3AgAgAhC7DCAGQeAAaiQAC74BAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFCACEMkWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDYHSADQdQAaiIEIAEQygYgBBCaHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC/MEAgh/AX4jAEHgAGsiBiQAIAEoAhAhBCABKAIUIQUjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhCCACKAIUIQkgAyAHNgIgIAMgBTYCHCADIAQ2AhggA0EANgIUIAMgCCAJQXhxajYCECADIAg2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQN2QQBBAUEBEKAYIAQoAhghBSAEKAIUQQFGBEAgBSAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAFNgIIIwBBMGsiBSQAIARBCGoiCSAHKAIEIAcoAgBrQQN2EIQuIAkpAgQhCyAFQRhqIAdBEGopAgA3AwAgBUEQaiAHQQhqKQIANwMAIAUgBykCADcDCCAFIAtCIIk3AiggBSAJQQhqNgIkIAVBCGogBUEkahCxESAFQTBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhCCADIAU2AhggAyAENgIUIAMgByAIQXhxajYCECADIAc2AgwgA0EkaiIIIANBDGoQkRsLIAYgCBDuGCADQTBqJAAgBkEMaiIDIAEQkjYgAhDzEiAGQSRqIgIgBiADEMEdIAZB1ABqIgMgARDKBiADEJseIABBCGogBkHcAGooAgA2AgAgACAGKQJUNwIAIAAgBikCMDcCDCAAQRRqIAZBOGooAgA2AgAgACAGKQI8NwIYIABBIGogBkHEAGopAgA3AgAgAEEoaiAGQcwAaikCADcCACACELsMIAZB4ABqJAAL2nICEX8CfiMAQSBrIg4kACAOQQxqIAEQuQECQCAOKAIMIgNBk4CAgHhHBEAgACAOKQIQNwIEIABBDGogDkEYaikCADcCAAwBCyAOQQxqIQIjAEFAaiIDJAAgAUEsaiEEAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIsIgcEQCADIAEoAjwgBBDnOmsiBjYCDCAGIAEoAkAiBUcNAQsgAS0AGCIGQRtrDgYHCAEHCAIGCyADIAU2AhAgA0EDNgIYIANBlPqGATYCFCADQgI3AiAgA0E7NgI4IANBOzYCMCADIANBLGo2AhwgAyADQQxqNgI0IAMgA0EQajYCLCACQQRqIANBFGoQmQ4gAkGNgICAeDYCAAwJCyABKAIURQ0BIAEoAiAtAEgNBiABKAIQIQYgB0UNAyADQRRqIgUgBCABKAIcEIoOIANBLGogASAFIAYQghUgAygCLCIGQZOAgIB4Rg0CIAIgAykCMDcCBCACQQxqIANBOGopAgA3AgAgAiAGNgIAIAMoAhQiAiACKAIAIgJBAWs2AgAgAkEBRw0IIAUQ+x4MCAsgAyABQRxqEMM0IAEoAhAhBSABKAIUIQggAygCBCEJIAMgAygCACIGNgIUIAMgBiAJQQJ0ajYCGCAIIANBFGoQnjYiCSAIIAlJGyIIRQ0FIARBACAHGyEEA0ACQCAGKAIALQBIDQAgA0EUaiABIAQgBRCCFSADKAIUIgdBk4CAgHhGDQAgAiADKQIYNwIEIAJBDGogA0EgaikCADcCACACIAc2AgAMCQsgBkEEaiEGIAVBxABqIQUgCEEBayIIDQALDAULQQBBAEGs+oYBEMMhAAsgAygCFCIGIAYoAgAiBkEBazYCACAGQQFHDQMgA0EUahD7HgwDCyADQRRqIAFBACAGEIIVIAMoAhQiBkGTgICAeEYNAiACIAMpAhg3AgQgAkEMaiADQSBqKQIANwIAIAIgBjYCAAwECyAGQSdHDQELIAEoAhwtAEgNACABKAIURQ0BIANBFGogAUEAIAEoAhAQghUgAygCFCIGQZOAgIB4Rg0AIAIgAykCGDcCBCACQQxqIANBIGopAgA3AgAgAiAGNgIADAILIAJBk4CAgHg2AgAMAQtBAEEAQbz6hgEQwyEACyADQUBrJAAgDigCDCIDQZOAgIB4RwRAIAAgDikCEDcCBCAAQQxqIA5BGGopAgA3AgAMAQsgDkEMaiEGQQAhCEEAIQdBACEFQQAhCSMAQYACayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AGEEUaw4VAAgBCQIDCgQICAUICAYHCAgICAQUCAsgASgCCCIDQQFNDRQgBiABIAEoAgQoAhQQsQoMKAsgASgCCCIDQQFNDRQgBiABIAEoAgQoAhQQsgoMJwsgASgCCCIDQQFNDRQgAkEIaiABKAIEQQxqENw7IAJB6ABqIAIoAggiBCACKAIMIgMQnQkgAigCaEEBRgRAIAIgAzYCfCACIAQ2AnggAiADNgJ0IAJBIGogARCPJyACKAIoIQQgAigCJCEBIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgATYCBCAGIAU2AgAMKAsgAkIANwL4ASACIAEgBEECdGo2AuwBIAIgAkH0AGo2AvQBIAQEQCACQfwBaiEEIAJB+AFqIQUgAkEBNgLwASACIAFBBGo2AugBIAJBADYCmAEgAiABNgKcAQJ/IAEoAgAiAUEASARAIAJBAjYCJCACQcT+hgE2AiAgAkICNwIsIAJBOzYCrAEgAkGpCDYCpAEgAiACQaABajYCKCACIAJBmAFqNgKoASACIAJBnAFqNgKgASACQbgBaiACQSBqEJkOIAJB5AFqIAJBxAFqKAIANgIAIAIgAikCvAE3AtwBIAIoArgBDAELIAEgA00NJyACQQM2ArgBIAJB4P2GATYCtAEgAkIDNwLAASACQTs2AjQgAkGpCDYCLCACQTs2AiQgAiACQSBqNgK8ASACIAJB9ABqNgIwIAIgAkGcAWo2AiggAiACQZgBajYCICACQdgBaiACQbQBahCZDiACKALYAQshASACIAIpAuABNwKMASACIAIoAtwBNgKIASACIAE2AoQBIAJBjYCAgHg2AoABIAJBgAFqEIgRDCcLIAZBk4CAgHg2AgAMJwsgAiACKQJsNwJ4IAIgAzYCdCACQSBqIAEQjycgAigCKCEEIAIoAiQhASACKAIgIgVBk4CAgHhHBEAgBiACKQIsNwIMIAYgBDYCCCAGIAE2AgQgBiAFNgIADCcLIAJCADcC+AEgAiABIARBAnRqNgLsASACIAJB9ABqNgL0ASAEBEAgAkH8AWohBCACQfgBaiEFIAJBATYC8AEgAiABQQRqNgLoASACQQA2ApgBIAIgATYCnAECfyABKAIAIgFBAEgEQCACQQI2AiQgAkHE/oYBNgIgIAJCAjcCLCACQTs2AqwBIAJBqQg2AqQBIAIgAkGgAWo2AiggAiACQZgBajYCqAEgAiACQZwBajYCoAEgAkG4AWogAkEgahCZDiACQeQBaiACQcQBaigCADYCACACIAIpArwBNwLcASACKAK4AQwBCyABIANNDSQgAkEDNgK4ASACQeD9hgE2ArQBIAJCAzcCwAEgAkE7NgI0IAJBqQg2AiwgAkE7NgIkIAIgAkEgajYCvAEgAiACQfQAajYCMCACIAJBnAFqNgIoIAIgAkGYAWo2AiAgAkHYAWogAkG0AWoQmQ4gAigC2AELIQEgAiACKQLgATcCjAEgAiACKALcATYCiAEgAiABNgKEASACQY2AgIB4NgKAASACQYABahCIEQwkCyAGQZOAgIB4NgIADCYLIAEoAggiA0EBTQ0UIAJBEGogASgCBEEMahDcOyACQegAaiACKAIQIgQgAigCFCIDEJ0JIAIoAmhBAUYEQCACIAM2AnwgAiAENgJ4IAIgAzYCdCACQSBqIAEQkCcgAigCKCEEIAIoAiQhASACKAIgIgVBk4CAgHhHBEAgBiACKQIsNwIMIAYgBDYCCCAGIAE2AgQgBiAFNgIADCcLIAJCADcC+AEgAiABIARBA3RqNgLsASACIAJB9ABqNgL0ASAEBEAgAkH8AWohBCACQfgBaiEFIAJBATYC8AEgAiABQQhqNgLoASACQQA2ApgBIAIgATYCnAECfyABKQMAIhNCgICAgBBaBEAgAkECNgIkIAJBxP6GATYCICACQgI3AiwgAkE7NgKsASACQccQNgKkASACIAJBoAFqNgIoIAIgAkGYAWo2AqgBIAIgAkGcAWo2AqABIAJBuAFqIAJBIGoQmQ4gAkHkAWogAkHEAWooAgA2AgAgAiACKQK8ATcC3AEgAigCuAEMAQsgAyATpyIBTw0iIAJBAzYCuAEgAkHg/YYBNgK0ASACQgM3AsABIAJBOzYCNCACQccQNgIsIAJBOzYCJCACIAJBIGo2ArwBIAIgAkH0AGo2AjAgAiACQZwBajYCKCACIAJBmAFqNgIgIAJB2AFqIAJBtAFqEJkOIAIoAtgBCyEBIAIgAikC4AE3AowBIAIgAigC3AE2AogBIAIgATYChAEgAkGNgICAeDYCgAEgAkGAAWoQiBEMIgsgBkGTgICAeDYCAAwmCyACIAIpAmw3AnggAiADNgJ0IAJBIGogARCQJyACKAIoIQQgAigCJCEBIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgATYCBCAGIAU2AgAMJgsgAkIANwL4ASACIAEgBEEDdGo2AuwBIAIgAkH0AGo2AvQBIAQEQCACQfwBaiEEIAJB+AFqIQUgAkEBNgLwASACIAFBCGo2AugBIAJBADYCmAEgAiABNgKcAQJ/IAEpAwAiE0KAgICAEFoEQCACQQI2AiQgAkHE/oYBNgIgIAJCAjcCLCACQTs2AqwBIAJBxxA2AqQBIAIgAkGgAWo2AiggAiACQZgBajYCqAEgAiACQZwBajYCoAEgAkG4AWogAkEgahCZDiACQeQBaiACQcQBaigCADYCACACIAIpArwBNwLcASACKAK4AQwBCyADIBOnIgFPDR8gAkEDNgK4ASACQeD9hgE2ArQBIAJCAzcCwAEgAkE7NgI0IAJBxxA2AiwgAkE7NgIkIAIgAkEgajYCvAEgAiACQfQAajYCMCACIAJBnAFqNgIoIAIgAkGYAWo2AiAgAkHYAWogAkG0AWoQmQ4gAigC2AELIQEgAiACKQLgATcCjAEgAiACKALcATYCiAEgAiABNgKEASACQY2AgIB4NgKAASACQYABahCIEQwfCyAGQZOAgIB4NgIADCULIAEoAhRFDRQgBiABIAEoAhAoAiQQsQoMJAsgASgCFEUNFCAGIAEgASgCECgCJBCyCgwjCyAGQZOAgIB4NgIADCILIAEoAhRFDRMgASgCEDUCJEIBfSETIAEoAhwtAABBAmsOCAQFBgcICQoLAwsgBkGTgICAeDYCAAwgCyACQSBqIAEgASgCJBD5ESACKAIoIQQgAigCJCEDIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgAzYCBCAGIAU2AgAMIAsgASgCCCIFRQ0SIAEoAgRBDGohDSAFQQFrIQkjAEGQAWsiASQAAkAgBARAIARBBHQhBSABQShqIQoDQCABIAc2AhggASADKQMAIhSnIgQ2AhwgAykDCCETAkACQCAEQQ1PBEAgASAENgIgIAEgFEIgiD4CJCABIBOnIgs2AiggASATQiCIpyIINgIsIAkgC00EQCABIAk2AmQgAUGsx4cBNgJMIAFCAzcCWCABQTs2AnwgAUE7NgJ0IAEgCjYCcCABQTs2AmwgASABQegAajYCVCABIAFB5ABqNgJ4IAEgAUEYajYCaCABQQQ2AlAgAUE8aiABQcwAahCZDiAGIAEpAkA3AgggBkEQaiABQcgAaigCADYCACAGIAEoAjw2AgQgBkGNgICAeDYCAAwGCyABIAg2AjAgASAEIAhqIgw2AjQgAUEQaiANIAtBDGxqIgsQ3DsCQAJAIAggDEsNACAMIAEoAhRLDQAgASgCECIMDQELIAEgCygCCDYCZCABQQU2AlAgAUGEyIcBNgJMIAFCBTcCWCABQTs2AowBIAFBOzYChAEgASAKNgKAASABQTs2AnwgAUE7NgJ0IAFBOzYCbCABIAFB6ABqNgJUIAEgAUHkAGo2AogBIAEgAUE0ajYCeCABIAFBMGo2AnAgASABQRhqNgJoIAFBPGogAUHMAGoQmQ4gASkCPCETIAYgASkCRDcCDCAGIBM3AgQgBkGNgICAeDYCAAwGCyABIAEoAiQ2AmggCCAMaiAEIAFB6ABqIgRBBBD0Lg0CIARBKUEAQQFBARCgGCABKAJsIQMgASgCaEEBRg0BIAEoAnAiBEH4xYcBQSn8CgAAIAZBKTYCDCAGIAQ2AgggBiADNgIEIAZBjYCAgHg2AgAMBQsgBEEMRg0BIAEgFCATIARBA3RBIGoQxyMgASkDACABKQMIhFANASABQQI2AmwgAUHgxocBNgJoIAFCAjcCdCABQTs2AlggAUE7NgJQIAEgAUHMAGo2AnAgASABQRxqNgJUIAEgAUEYajYCTCAGQQRqIAFB6ABqEJkOIAZBjYCAgHg2AgAMBAsgAyABKAJwQaDEhwEQ/S8ACyADQRBqIQMgB0EBaiEHIAVBEGsiBQ0ACwsgBkGTgICAeDYCAAsgAUGQAWokAAwfCyACQSBqIAEgASgCJBD5ESACKAIoIQMgAigCJCEEIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiADNgIIIAYgBDYCBCAGIAU2AgAMHwsgASgCCCIFRQ0SIAYgBCADIAEoAgRBDGogBUEBaxDiBgweC0G4/IYBQShB4PyGARCfKQALIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghLDSAgAyAIEI8fIAQgBUkNISAEIAMoAgQiCEsNIkGTgICAeCEEAkAgB0UNACADKAIAIAVqIQggASgCOCEJIAEoAjAhCiABKAI8IQsgASgCLCEMQQAhAQNAIAMgATYCJCABIAhqLAAAIQUCQCAMBEAgASALTw0nIAogASAJaiINQQN2ai0AACANQQdxdkEBcUUNAQsgAyAFrCIUNwMoIAVBAE4gEyAUWXENACADQYCAhwE2AjAgA0IDNwI8IANB7gY2AlwgA0HuBjYCVCADQTs2AkwgAyADQcgAajYCOCADIANBCGo2AlggAyADQShqNgJQIAMgA0EkajYCSCADQQQ2AjQgA0EUaiADQTBqEJkOIAZBDGogA0EcaikCADcCACAGIAMpAhQ3AgRBjYCAgHghBAwCCyAHIAFBAWoiAUcNAAsLIAYgBDYCACADQeAAaiQADAELDB4LDBwLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAXZLDR8gAyAIEMYbIAQgBUkNICAEIAMoAgQiCEsNIUGTgICAeCEIAkAgB0UNACADKAIAIAVBAXRqIQQgB0EBdCEFIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDEEAIQEDQCADIAE2AiQgBC4BACEHAkAgDARAIAEgC08NJiAKIAEgCWoiDUEDdmotAAAgDUEHcXZBAXFFDQELIAMgB6wiFDcDKCAHQQBOIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEECaiEEIAFBAWohASAFQQJrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDB0LDBsLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAnZLDR4gAyAIEMcbIAQgBUkNHyAEIAMoAgQiCEsNIEGTgICAeCEIAkAgB0UNACADKAIAIAVBAnRqIQQgB0ECdCEFIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDEEAIQEDQCADIAE2AiQgBCgCACEHAkAgDARAIAEgC08NJSAKIAEgCWoiDUEDdmotAAAgDUEHcXZBAXFFDQELIAMgB6wiFDcDKCAHQQBOIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEEaiEEIAFBAWohASAFQQRrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBwLDBoLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBA3ZLDR0gAyAIEMUbIAQgBUkNHiAEIAMoAgQiCEsNH0GTgICAeCEIAkAgB0UNACADKAIAIAVBA3RqIQQgB0EDdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBCkDACEUAkAgCwRAIAEgCk8NJCAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCAUQgBZIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEIaiEEIAFBAWohASAFQQhrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBsLDBkLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghLDRwgAyAIEI8fIAQgBUkNHSAEIAMoAgQiCEsNHkGTgICAeCEEAkAgB0UNACADKAIAIAVqIQUgASgCOCEIIAEoAjAhCSABKAI8IQogASgCLCELQQAhAQNAIAMgATYCJCABIAVqMQAAIRQCQCALBEAgASAKTw0jIAkgASAIaiIMQQN2ai0AACAMQQdxdkEBcUUNAQsgAyAUNwMoIBMgFFkNACADQYCAhwE2AjAgA0IDNwI8IANB7gY2AlwgA0HuBjYCVCADQTs2AkwgAyADQcgAajYCOCADIANBCGo2AlggAyADQShqNgJQIAMgA0EkajYCSCADQQQ2AjQgA0EUaiADQTBqEJkOIAZBDGogA0EcaikCADcCACAGIAMpAhQ3AgRBjYCAgHghBAwCCyAHIAFBAWoiAUcNAAsLIAYgBDYCACADQeAAaiQADAELDBoLDBgLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAXZLDRsgAyAIEMYbIAQgBUkNHCAEIAMoAgQiCEsNHUGTgICAeCEIAkAgB0UNACADKAIAIAVBAXRqIQQgB0EBdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBDMBACEUAkAgCwRAIAEgCk8NIiAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCATIBRZDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEECaiEEIAFBAWohASAFQQJrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBkLDBcLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAnZLDRogAyAIEMcbIAQgBUkNGyAEIAMoAgQiCEsNHEGTgICAeCEIAkAgB0UNACADKAIAIAVBAnRqIQQgB0ECdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBDUCACEUAkAgCwRAIAEgCk8NISAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCATIBRZDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEEaiEEIAFBAWohASAFQQRrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBgLDBYLIwBBgAFrIgMkACADIBM3AxACQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBA3ZLDRkgA0EIaiAIEJskIAQgBUkNGiAEIAMoAgwiCEsNG0GTgICAeCEIAkAgB0UNACADKAIIIAVBA3RqIQQgB0EDdCEHIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDCADQcQAaiENIANBHGohBUEAIQEDQCADIAE2AiwgAyAEKQMAIhQ3AzACQCAMBEAgASALTw0gIAogASAJaiIPQQN2ai0AACAPQQdxdkEBcUUNAQsCQCAUQgBTBEAgA0EDNgJcIANBvICHATYCWCADQgI3AmQgA0E8NgJ8IANBOzYCdCADIANB8ABqNgJgIAMgA0EwajYCeCADIANBLGo2AnAgDSADQdgAahCZDiADIAMpAkw3AiQgAyADKQJENwIcDAELIAMgFDcDOCATIBRZDQEgA0EENgJEIANBgICHATYCQCADQgM3AkwgA0HuBjYCbCADQe4GNgJkIANBOzYCXCADIANB2ABqNgJIIAMgA0EQajYCaCADIANBOGo2AmAgAyADQSxqNgJYIAUgA0FAaxCZDgsgBkEMaiAFQQhqKQIANwIAIAYgBSkCADcCBEGNgICAeCEIDAILIARBCGohBCABQQFqIQEgB0EIayIHDQALCyAGIAg2AgAgA0GAAWokAAwBCwwXCwwVCwJAAkACQAJAAkAgASgCFARAIAJB1AFqIAEoAhAiA0EYahDaBiADKAIoIQQgAygCJCEKIAJB6AFqIAMQvhUgAkG0AWogA0EMahCACyADKAIsIgcEQCAHIAcoAgAiBUEBajYCACAFQQBIDRAgAygCQCEIIAMoAjwhBSADKAI4IQkgAygCNCELIAMoAjAhAwsgAkFAayACQdwBaigCADYCACACQShqIAJB8AFqKAIANgIAIAJBNGogAkG8AWooAgA2AgAgAiACKQLUATcDOCACIAQ2AkggAiAKNgJEIAIgAikC6AE3AyAgAiACKQK0ATcCLCACIAg2AmAgAiAFNgJcIAIgCTYCWCACIAs2AlQgAiADNgJQIAIgBzYCTCABKAIcLQAwQQNrDgMCAwQBC0EAQQBBgP2GARDDIQALQbj8hgFBKEGQ/YYBEJ8pAAsgAkEANgJoIAIoAihFDQ0gAiAEIApqIgdBAXQiATYCoAECQCABIAIoAiQiAygCCCIFTQRAIAJBGGogAxDGGyAEIAdLDRAgByACKAIcIgFNDQEgByABQeDshgEQsDsACyACIAU2AoABIAJBpO2GATYC6AEgAkIENwL0ASACQTs2AtABIAJBOzYCyAEgAkGtAzYCwAEgAiACQThqNgK8ASACQTs2ArgBIAIgAkG0AWo2AvABIAIgAkGAAWo2AswBIAIgAkGgAWo2AsQBIAIgAkHoAGo2ArQBIAJBBDYC7AEgAkHYAWogAkHoAWoQmQ4gAikC2AEhEyAGIAIpAuABNwIMIAYgEzcCBCAGQY2AgIB4NgIADAMLIAIoAhghASACQgA3A6ABAkACQCAKRQRAQQAhBQwBCyABIARBAXRqIQMgCkEBdCEEQQAhAQNAIAIgATYCaCACIAMvAQAiBa3DIhQ3A4ABAkACQCAFwUEASgRAIAFFIBMgFFNyDQIgAiATNwOgASACQYyDhwE2AugBIAJCAzcC9AEgAkHuBjYCyAEgAkE7NgLAASACQe4GNgK4ASACIAJBtAFqNgLwASACIAJBoAFqNgLEASACIAJB6ABqNgK8ASACIAJBgAFqNgK0ASACQQQ2AuwBIAJB2AFqIAJB6AFqEJkODAELIAIgEzcDoAEgAkEDNgK4ASACQfSDhwE2ArQBIAJCAjcCwAEgAkE7NgL0ASACQe4GNgLsASACIAJB6AFqNgK8ASACIAJB6ABqNgLwASACIAJBgAFqNgLoASACQdgBaiACQbQBahCZDgsgBiACKQLYATcCBCAGQQxqIAJB4AFqKQIANwIADAMLIANBAmohAyABQQFqIQEgFCETIARBAmsiBA0ACyACIBM3A6ABCyAFIAdPBEAgBkGTgICAeDYCAAwECyACIAc2AtQBIAJBAzYCuAEgAkH0gYcBNgK0ASACQgI3AsABIAJBOzYC9AEgAkHuBjYC7AEgAiACQegBajYCvAEgAiACQdQBajYC8AEgAiACQaABajYC6AEgBkEEaiACQbQBahCZDgsgBkGNgICAeDYCAAwCC0EAIQQgAkG0AWogAkEgakEAIAoQnxEgAigCvAEhASACKAK4ASEDIAIoArQBIgVBk4CAgHhHBEAgBiACKQLAATcCDCAGIAE2AgggBiADNgIEIAYgBTYCAAwCCyACQgA3A6ABAkAgAQRAIAFBAnQhB0EAIQEDQCACIAE2AmggAiADKAIAIgSsIhQ3A4ABAkACQCAEQQBKBEAgAUUgEyAUU3INAiACIBM3A6ABIAJBjIOHATYC6AEgAkIDNwL0ASACQe4GNgLIASACQTs2AsABIAJB7gY2ArgBIAIgAkG0AWo2AvABIAIgAkGgAWo2AsQBIAIgAkHoAGo2ArwBIAIgAkGAAWo2ArQBIAJBBDYC7AEgAkHYAWogAkHoAWoQmQ4MAQsgAiATNwOgASACQQM2ArgBIAJB9IOHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHoAGo2AvABIAIgAkGAAWo2AugBIAJB2AFqIAJBtAFqEJkOCyAGIAIpAtgBNwIEIAZBDGogAkHgAWopAgA3AgAMAwsgA0EEaiEDIAFBAWohASAUIRMgB0EEayIHDQALIAIgEzcDoAELIAQgAigCSCAKaiIBTwRAIAZBk4CAgHg2AgAMAwsgAiABNgLUASACQQM2ArgBIAJB9IGHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHUAWo2AvABIAIgAkGgAWo2AugBIAZBBGogAkG0AWoQmQ4LIAZBjYCAgHg2AgAMAQtBACEHIAJBtAFqIAJBIGpBACAKEJ4RIAIoArwBIQEgAigCuAEhAyACKAK0ASIEQZOAgIB4RwRAIAYgAikCwAE3AgwgBiABNgIIIAYgAzYCBCAGIAQ2AgAMAQsgAkIANwOgAQJAIAEEQCABQQN0IQRBACEBA0AgAiABNgJoIAIgAykDACIUNwOAAQJAAkAgFEIAVQRAIAFFIBMgFFNyDQIgAiATNwOgASACQYyDhwE2AugBIAJCAzcC9AEgAkHuBjYCyAEgAkE7NgLAASACQe4GNgK4ASACIAJBtAFqNgLwASACIAJBoAFqNgLEASACIAJB6ABqNgK8ASACIAJBgAFqNgK0ASACQQQ2AuwBIAJB2AFqIAJB6AFqEJkODAELIAIgEzcDoAEgAkEDNgK4ASACQfSDhwE2ArQBIAJCAjcCwAEgAkE7NgL0ASACQe4GNgLsASACIAJB6AFqNgK8ASACIAJB6ABqNgLwASACIAJBgAFqNgLoASACQdgBaiACQbQBahCZDgsgBiACKQLYATcCBCAGQQxqIAJB4AFqKQIANwIADAMLIANBCGohAyABQQFqIQEgFCETIARBCGsiBA0ACyACIBM3A6ABIBOnIQcLIAcgAigCSCAKaiIBTwRAIAZBk4CAgHg2AgAMAgsgAiABNgLUASACQQM2ArgBIAJB9IGHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHUAWo2AvABIAIgAkGgAWo2AugBIAZBBGogAkG0AWoQmQ4LIAZBjYCAgHg2AgALIAJBIGoQpB4MFAtBASADQdj7hgEQwyEAC0EBIANB6PuGARDDIQALQQEgA0HU/oYBEMMhAAtBASADQdT+hgEQwyEAC0EAQQBB8PyGARDDIQALQQBBAEGY/IYBEMMhAAtBAEEAQaj8hgEQwyEAC0EBQQBB+PuGARCvOwALQQFBAEGI/IYBEK87CwALQQBBAEHQ7IYBEMMhAAsgBCAHQeDshgEQsTsACyACIAE2AvgBCyACIAU2ArgBIAIgBDYCtAEgAiACQfgAajYCvAEgAkEgaiELIAJBtAFqIQUjAEHwAGsiASQAQZSAgIB4IQgCQCACQegBaiIEKAIAIgMgBCgCBCIRRg0AIAUoAgghDSAFKAIEIQwgBCgCDCEPIAQoAgghBwJAAn8CQANAIAEgBzYCTCABIAM2AmggAykDACITQoCAgIAQWgRAIAQgA0EIajYCACABQQI2AlQgAUGAh4cBNgJQIAFCAjcCXCABQTs2AiggAUHHEDYCICABIAFBHGo2AlggASABQcwAajYCJCABIAFB6ABqNgIcIAFBOGogAUHQAGoQmQ4gAUEYaiABQcQAaigCADYCACABIAEpAjw3AhAgASgCOCEDDAILIBOnIgUgDygCAEsEQCAEIANBCGo2AgAgAUEDNgI4IAFBnIaHATYCNCABQgM3AkAgAUE7NgJkIAEgDzYCYCABQccQNgJcIAFBOzYCVCABIAFB0ABqNgI8IAEgAUHoAGo2AlggASABQcwAajYCUCABQQxqIAFBNGoQmQ4gASgCDCEDDAILIAEgDDYCMCAFIAwoAgAiCUkEQCAEIANBCGo2AgAgASAFNgJMIAEgB0EBazYCaCABQQM2AjggAUHMh4cBNgI0IAFCAzcCQCABQTs2AmQgAUH/GzYCXCABQTs2AlQgASABQdAAajYCPCABIAFBzABqNgJgIAEgAUEwajYCWCABIAFB6ABqNgJQIAFBIGogAUE0ahCZDiABKAIgIQMgASgCKCEFIAEoAiwhCCABKAIkDAMLIAwgBTYCACABIAdBAWsiEjYCTCANKAIEIQogDSgCACEQAkACQAJAIAlFDQAgCSAKTwRAIAkgCkYNAQwCCyAJIBBqLAAAQUBIDQELIBNQDQEgBSAKTwRAIAUgCkcNAQwCCyAFIBBqLAAAQb9/Sg0BCyAEIANBCGo2AgAgAUEBNgJUIAFBkIiHATYCUCABQgE3AlwgAUE7NgJsIAEgAUHoAGo2AlggASABQcwAajYCaCABQThqIAFB0ABqEJkODAQLIAQgEkECaiIHNgIIIANBCGoiAyARRw0ACyAEIAM2AgAMAwsgASkCFCITQiCIpyEIIBOnIQUgASgCEAshCSABIAg2AkQgASAFNgJAIAEgCTYCPCABIAM2AjgLIAsgASkCODcCBCALQQxqIAFBQGspAgA3AgAgBCAHQQFqNgIIQY2AgIB4IQgLIAsgCDYCACABQfAAaiQAIAIoAiBBlICAgHhHBEAgBiACKQIgNwIAIAZBEGogAkEwaigCADYCACAGQQhqIAJBKGopAgA3AgAMBwsgBkGTgICAeDYCAAwGCyACIAE2AvgBCyACIAU2ArgBIAIgBDYCtAEgAiACQfgAajYCvAEgAkG0AWohAyMAQZABayIEJAACQCACQSBqIgoCfgJ/AkACQCACQegBaiIIKAIAIgEgCCgCBCINRwRAIAMoAgghCyADKAIEIQUgCCgCDCEMIAgoAgghBwNAIAggAUEIaiIDNgIAIAQgBzYCOCAEIAE2AhggASkDACITQoCAgIAQWgRAIARBAjYCfCAEQYCHhwE2AnggBEICNwKEASAEQTs2AlAgBEHHEDYCSCAEIARBxABqNgKAASAEIARBOGo2AkwgBCAEQRhqNgJEIARB5ABqIARB+ABqEJkOIARBFGogBEHwAGooAgA2AgAgBCAEKQJoNwIMIAQoAmQhAQwECyATpyIBIAwoAgBLBEAgBEEDNgJkIARBnIaHATYCYCAEQgM3AmwgBEE7NgKMASAEIAw2AogBIARBxxA2AoQBIARBOzYCfCAEIARB+ABqNgJoIAQgBEEYajYCgAEgBCAEQThqNgJ4IARBCGogBEHgAGoQmQ4gBCgCCCEBDAQLIAQgBTYCWCAFKAIAIgkgAUsEQCAEIAE2AjggBCAHQQFrNgJEIARBAzYCZCAEQcyHhwE2AmAgBEIDNwJsIARBOzYCjAEgBEH/GzYChAEgBEE7NgJ8IAQgBEH4AGo2AmggBCAEQThqNgKIASAEIARB2ABqNgKAASAEIARBxABqNgJ4IARBHGogBEHgAGoQmQ4gBCgCKCEDIAQoAiQhBSAEKAIcIQEgBCgCIAwFCyAFIAE2AgAgBCABNgI0IAQgCTYCMCAEIAdBAWs2AiwgCygCBCIPIAFJDQIgBEE4aiALKAIAIAlqIAEgCWsQnQkgBCgCOEEBRgRAIAQgBCkCPDcDWCAEQQM2AmQgBEHUiIcBNgJgIARCAzcCbCAEQbADNgKMASAEQaQDNgKEASAEQTs2AnwgBCAEQfgAajYCaCAEIARB2ABqNgKIASAEIARBMGo2AoABIAQgBEEsajYCeCAEQcgAaiAEQeAAahCZDiAEKAJIIQEgBCgCTCEJIAQpAlAMBgsgCCAHQQFqIgc2AgggAyIBIA1HDQALCyAKQZSAgIB4NgIADAQLIAEgD0GYiIcBELA7AAsgBCkCECITQiCIpyEDIBOnIQUgBCgCDAshCSAFrSADrUIghoQLNwIMIAogCTYCCCAKIAE2AgQgCkGNgICAeDYCACAIIAdBAWo2AggLIARBkAFqJAAgAigCIEGUgICAeEcEQCAGIAIpAiA3AgAgBkEQaiACQTBqKAIANgIAIAZBCGogAkEoaikCADcCAAwFCyAGQZOAgIB4NgIADAQLIAIgATYC+AELIAIgBTYCuAEgAiAENgK0ASACIAJB+ABqNgK8ASACQSBqIQsgAkG0AWohBSMAQfAAayIBJABBlICAgHghCAJAIAJB6AFqIgQoAgAiAyAEKAIEIhFGDQAgBSgCCCENIAUoAgQhDCAEKAIMIQ8gBCgCCCEHAkACfwJAA0AgASAHNgJMIAEgAzYCaCADKAIAIgVBAEgEQCAEIANBBGo2AgAgAUECNgJUIAFBgIeHATYCUCABQgI3AlwgAUE7NgIoIAFBqQg2AiAgASABQRxqNgJYIAEgAUHMAGo2AiQgASABQegAajYCHCABQThqIAFB0ABqEJkOIAFBGGogAUHEAGooAgA2AgAgASABKQI8NwIQIAEoAjghBQwCCyAPKAIAIAVJBEAgBCADQQRqNgIAIAFBAzYCOCABQZyGhwE2AjQgAUIDNwJAIAFBOzYCZCABIA82AmAgAUGpCDYCXCABQTs2AlQgASABQdAAajYCPCABIAFB6ABqNgJYIAEgAUHMAGo2AlAgAUEMaiABQTRqEJkOIAEoAgwhBQwCCyABIAw2AjAgBSAMKAIAIglJBEAgBCADQQRqNgIAIAEgBTYCTCABIAdBAWs2AmggAUEDNgI4IAFBzIeHATYCNCABQgM3AkAgAUE7NgJkIAFB/xs2AlwgAUE7NgJUIAEgAUHQAGo2AjwgASABQcwAajYCYCABIAFBMGo2AlggASABQegAajYCUCABQSBqIAFBNGoQmQ4gASgCICEFIAEoAighCCABKAIsIQMgASgCJAwDCyAMIAU2AgAgASAHQQFrIhI2AkwgDSgCBCEKIA0oAgAhEAJAAkACQCAJRQ0AIAkgCk8EQCAJIApGDQEMAgsgCSAQaiwAAEFASA0BCyAFRQ0BIAUgCk8EQCAFIApHDQEMAgsgBSAQaiwAAEG/f0oNAQsgBCADQQRqNgIAIAFBATYCVCABQZCIhwE2AlAgAUIBNwJcIAFBOzYCbCABIAFB6ABqNgJYIAEgAUHMAGo2AmggAUE4aiABQdAAahCZDgwECyAEIBJBAmoiBzYCCCADQQRqIgMgEUcNAAsgBCADNgIADAMLIAEpAhQiE0IgiKchAyATpyEIIAEoAhALIQkgASADNgJEIAEgCDYCQCABIAk2AjwgASAFNgI4CyALIAEpAjg3AgQgC0EMaiABQUBrKQIANwIAIAQgB0EBajYCCEGNgICAeCEICyALIAg2AgAgAUHwAGokACACKAIgQZSAgIB4RwRAIAYgAikCIDcCACAGQRBqIAJBMGooAgA2AgAgBkEIaiACQShqKQIANwIADAMLIAZBk4CAgHg2AgAMAgsgAiABNgL4AQsgAiAFNgK4ASACIAQ2ArQBIAIgAkH4AGo2ArwBIAJBtAFqIQMjAEGQAWsiBCQAAkAgAkEgaiIKAn4CfwJAAkAgAkHoAWoiCCgCACIBIAgoAgQiDUcEQCADKAIIIQsgAygCBCEFIAgoAgwhDCAIKAIIIQcDQCAIIAFBBGoiAzYCACAEIAc2AjggBCABNgIYIAEoAgAiAUEASARAIARBAjYCfCAEQYCHhwE2AnggBEICNwKEASAEQTs2AlAgBEGpCDYCSCAEIARBxABqNgKAASAEIARBOGo2AkwgBCAEQRhqNgJEIARB5ABqIARB+ABqEJkOIARBFGogBEHwAGooAgA2AgAgBCAEKQJoNwIMIAQoAmQhAQwECyAMKAIAIAFJBEAgBEEDNgJkIARBnIaHATYCYCAEQgM3AmwgBEE7NgKMASAEIAw2AogBIARBqQg2AoQBIARBOzYCfCAEIARB+ABqNgJoIAQgBEEYajYCgAEgBCAEQThqNgJ4IARBCGogBEHgAGoQmQ4gBCgCCCEBDAQLIAQgBTYCWCAFKAIAIgkgAUsEQCAEIAE2AjggBCAHQQFrNgJEIARBAzYCZCAEQcyHhwE2AmAgBEIDNwJsIARBOzYCjAEgBEH/GzYChAEgBEE7NgJ8IAQgBEH4AGo2AmggBCAEQThqNgKIASAEIARB2ABqNgKAASAEIARBxABqNgJ4IARBHGogBEHgAGoQmQ4gBCgCKCEDIAQoAiQhBSAEKAIcIQEgBCgCIAwFCyAFIAE2AgAgBCABNgI0IAQgCTYCMCAEIAdBAWs2AiwgASALKAIEIg9LDQIgBEE4aiALKAIAIAlqIAEgCWsQnQkgBCgCOEEBRgRAIAQgBCkCPDcDWCAEQQM2AmQgBEHUiIcBNgJgIARCAzcCbCAEQbADNgKMASAEQaQDNgKEASAEQTs2AnwgBCAEQfgAajYCaCAEIARB2ABqNgKIASAEIARBMGo2AoABIAQgBEEsajYCeCAEQcgAaiAEQeAAahCZDiAEKAJIIQEgBCgCTCEJIAQpAlAMBgsgCCAHQQFqIgc2AgggAyIBIA1HDQALCyAKQZSAgIB4NgIADAQLIAEgD0GYiIcBELA7AAsgBCkCECITQiCIpyEDIBOnIQUgBCgCDAshCSAFrSADrUIghoQLNwIMIAogCTYCCCAKIAE2AgQgCkGNgICAeDYCACAIIAdBAWo2AggLIARBkAFqJAAgAigCIEGUgICAeEcEQCAGIAIpAiA3AgAgBkEQaiACQTBqKAIANgIAIAZBCGogAkEoaikCADcCAAwBCyAGQZOAgIB4NgIACyACQYACaiQADAULQQBBAEHk/oYBEMMhAAtB9P6GAUHEAEG4/4YBEJ8pAAsgBSAEQcj/hgEQsTsACyAEIAhByP+GARCwOwALQdTZhgFBIEH02YYBEJ8pAAsgDigCDCIDQZOAgIB4RwRAIAAgDikCEDcCBCAAQQxqIA5BGGopAgA3AgAMAQtBk4CAgHghAwsgACADNgIAIA5BIGokAAvtAQECfyMAQTBrIgIkAAJAIAApAwBC////////////AINCgICAgICAgPj/AFoEQCACQQE2AhQgAkG8p4kBNgIQIAJCATcCHCACQYoINgIsIAIgADYCKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQywohAwwBCyACQQA6AAwgAiABNgIIQQEhAyACQQE2AhQgAkG8p4kBNgIQIAJCATcCHCACQYoINgIsIAIgADYCKCACIAJBKGo2AhggAkEIaiACQRBqEJs9DQAgAi0ADEUEQCABQcSniQFBAhD7NQ0BC0EAIQMLIAJBMGokACADC9oBAgR+An8jAEEQayIGJAACQCABvSIFQv///////////wCDIgRCgICAgICAgPg/VA0AIARCgICAgICAgPDHAFoEQCAEQoGAgICAgID4/wBaDQEgBUI/hyIDQv///////////wCFIQIgA0J/hSEDDAELIAZCACAEQguGQoCAgICAgICAgH+EQf4AIARCNIina0H/AHEQxyNCACAGKQMAIgJ9IAIgBUIAUyIHGyEDQgAgBikDCCIEIAJCAFKtfH0gBCAHGyECCyAAIAM3AwAgACACNwMIIAZBEGokAAuQDAIRfwF+IwBBQGoiBSQAIAVBKGohBiMAQaAFayIDJAAgAUGoAWohDSABQbQBaiEQIAFB+ABqIREgAUEgaiESIAFBCGohCiABQYwBaiELIAFBiAFqIQcgASgCiAEhBCADQdwDaiEOIANB0ANqIQ8gA0GwAWohCCADQaQCaiEMIANByAFqIRMCQANAAkACQAJAAkACQAJAAkACQAJAAkBBASAEQf////8HaiAEQYCAgIB4TRtBAWsOAwIDAAELIAZBCTYCAAwHCyADQQhqIBEQ0yIgAygCCEEBcQ0HIAZBCTYCAAwGCyADQagBaiAHEIcGIAMoAqgBIgRBAkYNASAEQQFxBEAgA0EgaiADQbwBaigCADYCACADQRhqIANBtAFqKQIANwMAIAMgAykCrAE3AxAgBxCGJCAHQYSAgIB4NgIAIANBADYCiAUgA0KAgICAEDcCgAUgA0GY+cIANgKQBSADQqCAgIAONwKUBSADIANBgAVqNgKMBSADQRBqIgEgA0GMBWoQnwQNAyAGIAMpAoAFNwIEIAZBDGogA0GIBWooAgA2AgAgBkEDNgIAIAEQiBEMBgsgBiADKQKsATcCBCAGQQg2AgAgBkEUaiADQbwBaigCADYCACAGQQxqIANBtAFqKQIANwIADAULIANBqAFqIAEoAowBIAIgASgCkAEoAgwRAQAgAykDqAEiFEIFUQ0DIBRCBFEEQCAGIAgpAwA3AwAgBkEQaiAIQRBqKQMANwMAIAZBCGogCEEIaikDADcDACAHEIYkIAdBhICAgHg2AgAMBQsgAygCoAIhBCABKQMAQgRSBEAgARCPEwsgASAUNwMAIAogCCkDADcDACAKQQhqIAhBCGopAwA3AwAgCkEQaiAIQRBqKQMANwMAIBIgE0HYAPwKAAAgBxCGJCAEQYGAgIB4Rg0CIAsgDCkCADcCACALQRhqIAxBGGooAgA2AgAgC0EQaiAMQRBqKQIANwIAIAtBCGogDEEIaikCADcCAAwCCyAHEIYkQYGAgIB4IQQMAQtBwPnCAEE3IANBnwVqQbD5wgBB+PnCABDVHgALIAcgBDYCAAwDCyAGQQo2AgALIANBoAVqJAAMAgsgAygCDCEEIAEpAwAhFCABQgQ3AwAgFEIEUgRAIANBKGogCkHwAPwKAAAgASgCwAFBCGogBBCILSEJAkAgASgCtAFBgICAgHhHBEAgA0GcAWogECAJKAIQEKAODAELIANBgICAgHg2ApwBCwJAIA0oAgBBgICAgHhHBEAgA0EQaiANEOceDAELIANBgICAgHg2AhALIA4gAykCEDcCACAOQQhqIANBGGooAgA2AgAgAyAUNwOoASABKALIASEJIAggA0EoakHwAPwKAAAgDyADKQKcATcCACAPQQhqIANBpAFqKAIANgIAIAMgBDYC6AMgA0EAOgCUBCADIAk2AuwDIANBqAFqIQkCQEHYA0EIEK02IgQEQCAEIAlB2AP8CgAAIANBiPnCADYCBCADIAQ2AgAMAQtBCEHYAxCjPQALIAMoAgAhBCAHEIYkIAFBiPnCADYCkAEgASAENgKMAUGDgICAeCEEIAFBg4CAgHg2AogBDAELC0GU+MIAQRNBqPjCABDLJAALAn9BAyAFKAIoIgJBCkYNABogBUEgaiIBIAVBPGoiAygCADYCACAFQRhqIgcgBUE0aiIEKQIANwMAIAUgBSkCLDcDEEECIAJBCUYNABogBCAHKQMANwIAIAMgASgCADYCACAFIAI2AiggBSAFKQMQNwIsIwBBIGsiASQAIAZBBGohAiAGKAIAIgNBCEcEQCABQRRqIAJBCGopAgA3AgAgAUEcaiACQRBqKAIANgIAIAEgAzYCCCABIAIpAgA3AgxBvJrDAEErIAFBCGpBrJrDAEHsn8MAENUeAAsgAUEYaiACQRBqKAIANgIAIAFBEGogAkEIaikCADcDACABIAIpAgA3AwggBUEIaiICIAFBCGoQ2CQ2AgQgAkEANgIAIAFBIGokACAFKAIMIQIgBSgCCAshASAAIAI2AgQgACABNgIAIAVBQGskAAupBAIFfwJ+IwBBgAFrIgQkACACKAIIBEAgAigCBC0AACEHIARBADYCOCAEQgA3AzAgBEEANgIQIAQgBzoAPCAEQgA3AwAgBEFAayIHIAJBARDqFCMAQUBqIgUkACAEQRBqIQYCQCAEKAIQIggEQCAEQRxqIAQoAhQgBCgCGCAIKAIQEQEAIARCADcDICAEQShqQgA3AwAgBkEIaiAHQQhqKQIANwIAIAYgBykCADcCAAwBCyAFQRBqQgA3AwAgBUEYakIANwMAIAYgBykCACIKNwMAIAZBEGpCADcDACAGQRhqQgA3AwAgBUEIaiAHQQhqKQIAIgk3AwAgBkEIaiAJNwMAIAUgCjcDAAsCQAJAIAYoAgAEQCAFQSBqIAYQpRgCQCAFKAIgQQFHDQAgBSkDKCIJUA0AIAlCAYNQRQRAIAQgCadBAnRBeHE2AjgMAQsgBCAJQgGIPgI0IAVBMGogBiAELQA8IghBA3YgCEEHcUEAR2oQwRwgBSkDMCEJIAQgBSkDODcDCCAEIAk3AwAgCadFDQILIAVBQGskAAwCC0H8qM0AQRhBlKnNABDLJAALQaSpzQBBLkHUqc0AEJ8pAAsgASADNgJMIAcgBEHAAPwKAAAgASkDAEICUgRAIAEQkSoLIAEgBEFAa0HAAPwKAAAgAEEINgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAgBEGAAWokAA8LQQBBAEGIoc0AEMMhAAvOAQICfwF+IwBBEGsiAyQAIAEtABQhAiADIAEpAwA3AwAgAkEDdiACQQdxQQBHaiICQQlPBEAgAkEIQeiOzgAQsDsACyABQQhqIAMgAhChNiABQQA6ABQgAUIANwMAIAFBGGogASgCDCABKAIQEKE2IAFBADoAFCABQgA3AwAgAUEANgIQIANBCGogAUEgaiICKAIANgIAIAJBADYCACABKQIYIQQgAUKAgICAEDcDGCADIAQ3AwAgAEEEaiADEOcVIABBCDYCACADQRBqJAALtgEBA38jAEEgayIDJAAgA0EUaiACQQN2IAJBB3FBAEdqIgJBwAAgAa3DeadrIgFB/wFxIgRBA3YgAUEHcUEAR2pBAWpsIgUgBEEBaiACbCICIAIgBUkbQQBBAUEBEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQYTEzgAQ/S8ACyADQQA2AhAgAyADKAIcNgIMIAMgAjYCCCAAQQhqIAEgA0EIahCcHyAAQQE6AAAgA0EgaiQAC7MCAQV+An4gACkDACICQiBaBEAgACkDECIBQgeJIAApAwgiA0IBiXwgACkDGCIEQgyJfCAAKQMgIgVCEol8IANCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gAULP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0MAQsgACkDGELFz9my8eW66id8CyACfCAAQShqIAKnEN4TC8UBAQF/AkACQAJAAn8gAyAFcSIDIARqIgYgBUEBaiIFTQRAAkAgAyAGTQRAIAIgBkkNAUEAIQVBAQwDCyADIAZB/O3RABCxOwALIAYgAkH87dEAELA7AAsgAyAFSw0BIAIgBUkNAiAEIAUgA2siBGsiBSACSw0DIAELIQIgACAFNgIMIAAgAjYCCCAAIAQ2AgQgACABIANqNgIADwsgAyAFQYzu0QAQsTsACyAFIAJBjO7RABCwOwALIAUgAkGc7tEAELA7AAvJAQEIfyMAQUBqIgIkACABKAIYIQUgAkE0aiABQQxqENYGAkAgASgCHCIEBEAgBCAEKAIAIgNBAWo2AgAgA0EASA0BIAEoAiwhBiABKAIoIQcgASgCJCEIIAEoAiAhCSABKAIwIQMLIAIgARC8FSACQRRqIAJBPGooAgA2AgAgAiAFNgIYIAIgAzYCMCACIAY2AiwgAiAHNgIoIAIgCDYCJCACIAk2AiAgAiAENgIcIAIgAikCNDcCDCAAIAIQ7xcgAkFAayQADwsAC9gBAgJ/AX4jAEFAaiIDJAAgAyACNgIAIAEoAhRBA3ZBAWsiBCACTQRAIAMgBDYCHCADQQQ2AgggA0Gkj4YBNgIEIANCBDcCECADQTs2AjwgA0HHAjYCNCADQdyOhgE2AjAgA0HHAjYCLCADQdyPhgE2AiggA0E7NgIkIAMgA0EgajYCDCADIANBHGo2AjggAyADNgIgIANBBGpBxI+GARDvLAALIAAgASgCECACQQN0aiICQQhqKQMAIAIpAwAiBX0+AgQgACABKAIcIAWnajYCACADQUBrJAAL2AECAn8BfiMAQUBqIgMkACADIAI2AgAgASgCFEEDdkEBayIEIAJNBEAgAyAENgIcIANBBDYCCCADQaSPhgE2AgQgA0IENwIQIANBOzYCPCADQccCNgI0IANB7I+GATYCMCADQccCNgIsIANB3I+GATYCKCADQTs2AiQgAyADQSBqNgIMIAMgA0EcajYCOCADIAM2AiAgA0EEakHEj4YBEO8sAAsgACABKAIQIAJBA3RqIgJBCGopAwAgAikDACIFfT4CBCAAIAEoAhwgBadqNgIAIANBQGskAAvIAgEHfyMAQRBrIgIkAAJAAkAgACAAQe0CaiIBSg0AIAJBCGohAyABIAFBsfUIbSIEQbH1CGxrIgBBH3UiBUGx9QhxIABqIgFB7QJuIQACfwJAIAFBvPcITQRAIAEgAEHtAmxrIgEgAEHAxoYBai0AACIGTwRAIAEgBmsMAwsgAEEBayIAQZEDSQ0BQX9BkQNB5MmGARDDIQALIABBkQNB1MmGARDDIQALIAEgAEHAxoYBai0AAGtB7QJqCyEBIAMgADYCACADIAFBAWo2AgQgAigCCCIAQZADTw0BIAIoAgwiAUHvAmtBkn1JDQAgACAEIAVqQZADbGoiA0H//w9rQYKAYEkNACAAQfTJhgFqLQAAIANBDXQgAUEEdHJyIgBBACAAQfg/cUHhLUkbIQcLIAJBEGokACAHDwsgAEGQA0GEzYYBEMMhAAvEAQEDfyMAQRBrIgQkAAJAAkAgASgCACIBKAIQQQFHBEAgBEEEaiADQQBBAUEBEKAYIAQoAgghBSAEKAIEQQFGDQIgBCgCDCEGIAMEQCAGIAIgA/wKAAALIAEQwyxBB0EgIAVBCnZnayIBIAFBB08bQQJ0QQFyIQEMAQsgASgCBCABKAIAIAJraiEFIAIhBgsgACABNgIMIAAgBTYCCCAAIAM2AgQgACAGNgIAIARBEGokAA8LIAUgBCgCDEGUiIgBEP0vAAuyAQEEfyAAKAIAIgEgACgCBEYEQEGAgMQADwsgACABQQFqNgIAIAEtAAAiA8BBAEgEfyAAIAFBAmo2AgAgAS0AAUE/cSECIANBH3EhBCADQd8BTQRAIARBBnQgAnIPCyAAIAFBA2o2AgAgAS0AAkE/cSACQQZ0ciECIANB8AFJBEAgAiAEQQx0cg8LIAAgAUEEajYCACAEQRJ0QYCA8ABxIAEtAANBP3EgAkEGdHJyBSADCwucAQEHfyABBEAgAUEBRwRAIAAgAUECdGohBSAAQQQiBGohAwNAIAMoAgAiBkEYdiIHIANBBGsoAgAiAUEYdkkEQCAEIQICfwNAIAAgAmoiCCABNgIAIAAgAkEERg0BGiACQQRrIQIgByAIQQhrKAIAIgFBGHZJDQALIAAgAmoLIAY2AgALIARBBGohBCADQQRqIgMgBUcNAAsLDwsAC8ACAQN/IwBBMGsiASQAIAFBADYCHCABQoCAgIAQNwIUIAFBqMXMADYCJCABQqCAgIAONwIoIAEgAUEUajYCICABQSBqIQMjAEEwayICJAACfyAAKAIAQYCAgIB4RwRAIAIgADYCDCACQQI2AhQgAkGgxMwANgIQIAJCATcCHCACQYQBNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAygCACADKAIEIAJBEGoQywoMAQsgACgCBCADEJ8ECyACQTBqJABFBEAgAUEQaiABQRxqKAIAIgI2AgAgASABKQIUNwMIIAEoAgwgAhCUPiABQQhqEN47AkAgACgCAEGAgICAeEYEQCAAKAIEIgAQiBEgAEEUQQQQ+DoMAQsgABDeOwsgAUEwaiQADwtB0MXMAEE3IAFBCGpBwMXMAEGIxswAENUeAAu8AQEIfyMAQRBrIgIkACAAKAIMIgEgACgCBCIFa0HQAG4hByABIAVHBEADQCAFIANB0ABsaiIBQTBqIAEoAjgiBgRAIAEoAjQhBANAIAQQ2BMgBEHoA2ohBCAGQQFrIgYNAAsLQQhB6AMQ4B4gASgCPEGAgICAeEcEQCABQTxqQQRBCBDgHgsgA0EBaiIDIAdHDQALCyACIAAoAgA2AgwgAiAAKAIINgIIIAJBCGpBCEHQABDgHiACQRBqJAAL3KsBAhN/EX4gAEEIaiEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAAJ+AkACQAJAAkACQAJAAkACQCABQQhqEN0lQf8BcUEBaw4HAQIDBAUGBwALIwBBgARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABB4AFqIAwgDSAAQQ9qEMcNAkACQCAAKALgAUEIRgRAIAAoAugBIRAgACgC5AEhESAAQfACaiEGIwBB4ABrIgckACAIIABBCGooAgAiCkEIaiIJEOcRGiAIIAkQ2xIhAUECQQAgCC0AlQFBAXEbIAFB/wFxIgEgAUEJRhshBSMAQfABayIBJAACQAJAIAdBEGoiCwJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcUAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDRQgBSABQSj8CgAAQfSQzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDRQgASgCCCIOQfSRzgBBNfwKAAAgC0E1NgIMIAsgDjYCCCALIAU2AgQgC0EANgIADAYLQfgAQQgQrTYiBUUNFCAFQYCAgIB4NgIIQZSRzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0UIAUgAUHwAPwKAABBtJHOAAwCCyABEKEnQeABQQgQrTYiBUUNFCAFIAFB4AH8CgAAQdSRzgAMAQtBDEEEEK02IgVFDRQgBUEANgIIIAVCgICAgBA3AgBBrJLOAAs2AgggCyAFNgIEIAtBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgC0EEaiABEJkOIAtBATYCAAsgAUHwAWokACAHKAIYIQEgBygCFCELAkACQAJAIAcoAhAiBUEIRwRAIAYgBykCHDcCFCAGQRxqIAdBJGooAgA2AgAgBiABNgIQIAYgCzYCDCAGIAU2AgggBkICNwMADAELIAcgATYCXCAHIAs2AlggCCAJEIISIQ5BgICAgHghBQJAIAggCRDRESIJRQ0AIAdBEGogCSkDCCAJKwMAENIRAkACQCAHKAIQIglBCGsOAgECAAsgBygCFCEBIAcpAxghFyAGIAcpAyA3AxggBiAXNwMQIAYgATYCDCAGIAk2AgggBkICNwMAIAdB2ABqELwqDAILIAcpAxghFyAHKAIUIQULIAogCigCACIJQQFqNgIAIAlBAEgNASAGQRBqIAdBEGpByAD8CgAAIAZBgICAgHg2AlggBkGCBDsAhQEgBiAOOgCEASAGQQA2AoABIAYgCjYCfCAGIBc3AnQgBiAFNgJwIAYgATYCbCAGIAs2AmggBkIANwMAIAYgBykCBDcCXCAGQeQAaiAHQQxqKAIANgIACyAHQeAAaiQADAELAAsgACkD8AJCAlENASAAQRBqIAZBiAH8CgAAIAggDxCCEiEFQQAhASAAQQA2AqQBIABBADYCnAFBAiEGIABBnAFqQQIQ6R4gAEG4AWpBAEEo/AsAAn8gBUH/AXEiC0UEQEGAgICAeCEFQYCAgIB4IQdBgICAgHghCkGAgICAeCEJQQIMAQsgAEIANwOQAyAAQYCAgIB4NgKEAyAAQYCAgIB4NgL4AiAAQgA3A/ACIABB+AJqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgLgAQwBCyAAQeABaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABB6AFqKAIANgIAIAEgACkC4AE3AgAgAEHgAWogAEHwAmpBKPwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgLwAgwBCyAAQfACaiABQQFqQf//A3FBoPnPABC2FQsgAEH0AWoQhTAgAEH8AWogAEH4AmooAgA2AgAgACAAKQLwAiIXNwL0ASAAKQPgASEYIAAoAugBIQUgACkC7AEhGSAAKAKAAiETIAAoAoQCIRQgACkD+AEhGiAAQgA3A6ADIABCADcDkAMgAEIANwOAAyAAQgA3A/ACIABBqANqIABBsAFqQTD8CgAAIABBggQ7AfgDIABBgICAgHg2AuwDIABBgICAgHg2AuADIABCADcD2AMgAEHgA2ohAQJAIAAoAgguARoiBkEATARAIABBgICAgHg2AuABDAELIABB4AFqIAZBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEHoAWooAgA2AgAgASAAKQLgATcCACAAQeABaiAAQfACakGQAfwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgLwAgwBCyAAQfACaiABQQFqQf//A3FBoPnPABC2FQsgAEHcAmoQhTAgAEHkAmogAEH4AmooAgA2AgAgACAAKQLwAjcC3AIgACkD4AEhGyAAKQPoASEcIAApA/ABIR0gACkD+AEhHiAAKQOAAiEfIAApA4gCISAgACkDkAIhISAAQbABaiAAQZgCakEw/AoAACAXpyEHIABBrAFqIABB7gJqLwEAOwEAIAAgACgB6gI2AqgBIAtBAkYhASAALQDpAiEGIAApA+ACISIgACgC3AIhCSAAKQLUAiEjIAAoAtACIQogACkDyAIhJCAALQDoAgshDyAIEPUVIQggBCALOgCsBCAEIAI2ApgEIARBuO3PADYC5AMgBCADNgLgAyAEIBA2AuwDIAQgETYC6AMgBCANNgKcAiAEIAw2ApgCIARBpARqIABBpAFqKAIANgIAIAQgACkCnAE3ApwEIAQgACgCCDYClAQgBCAAQRBqQYgB/AoAACAEIBQ2AqQDIAQgEzYCoAMgBCAaNwOYAyAEIAc2ApQDIAQgGTcCjAMgBCAFNgKIAyAEIBg3A4ADIAQgITcDuAEgBCAgNwOwASAEIB83A6gBIAQgHjcDoAEgBCAdNwOYASAEIBw3A5ABIAQgGzcDiAEgBEHAAWogAEGwAWpBMPwKAAAgBCAGOgCRAiAEIA86AJACIAQgIjcDiAIgBCAJNgKEAiAEICM3AvwBIAQgCjYC+AEgBCAkNwPwASAEQQA2ApAEIARCgICAgCA3A4gEIARCAjcDgAQgBEIANwP4AyAEQoCAgIDAADcD8AMgBEGAgICAeDYC4AIgBEGAgICAeDYC7AIgBEEANgL4AiAEQgA3A6gDIARBgICAgHhBACAIGzYCsAMgBEGAgICAeDYC1AMgBEGBAjsBqgQgBEKAgICAgAE3A6ACIARCADcDqAIgBEKAgICAEDcDsAIgBEIANwO4AiAEQgQ3A8ACIARCgICAgMAANwPIAiAEQgA3A9ACIARCCDcD2AIgBEIINwK0AyAEQoCAgIDAADcCvAMgBEIANwLEAyAEQgg3AswDIAQgAToA/AIgBCAAKAKoATYBkgIgBEGWAmogAEGsAWovAQA7AQAgBEECOgCoBCAAQYAEaiQADAILIABBgANqIABB8AFqKQMANwMAIABB+AJqIABB6AFqKQMANwMAIAAgACkD4AE3A/ACQcTvzgBBKyAAQfACakG0784AQaj9zgAQ1R4ACyAAQfABaiAAQYgDaikDADcDACAAQegBaiAAQYADaikDADcDACAAIAApA/gCNwPgAUHE784AQSsgAEHgAWpBtO/OAEG4/c4AENUeAAtCAAwHCyMAQaAEayIAJAAgACABNgIQIABBCGogAkEIaiIKIAFBCGoiDhDPECAAKAIMIRAgACgCCCERIABBAToAFyAAQfABaiARIBAgAEEXahDHDQJAIAAoAvABQQhGBEAgACgC+AEhEiAAKAL0ASEVIABBiANqIQYjAEGAAWsiByQAAkACQAJAIAogAEEQaigCACIJQQhqIgwQ5xFFBEAgB0GAgICAeDYCUAwBCyAJIAkoAgAiAUEBajYCACABQQBIDQEgB0EIaiAJEMMgCyAKIAwQ2xIhAUEEQQAgCi0AlQFBAXEbIAFB/wFxIgEgAUEJRhshBSMAQfABayIBJAACQAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAAkAgBUH/AXFBAWsOCAECCQMEBQEGAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNFiAFIAFBKPwKAABB2JrOAAwGCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNFiABKAIIIhZB9JHOAEE1/AoAACAIQTU2AgwgCCAWNgIIIAggBTYCBCAIQQA2AgAMCAtB+ABBCBCtNiIFRQ0WIAVBgICAgHg2AghB+JrOAAwECyABEJkoQeAAQQgQrTYiBUUNBCAFIAFB4AD8CgAAQZibzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0VIAUgAUHwAPwKAABBuJvOAAwCCyABEKEnQeABQQgQrTYiBUUNFSAFIAFB4AH8CgAAQdibzgAMAQtBDEEEEK02IgVFDRUgBUEANgIIIAVCgICAgBA3AgBB+JvOAAs2AgggCCAFNgIEIAhBCDYCAAwCC0EIQeAAEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAhBBGogARCZDiAIQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCAJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAg2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByAINgJgIAogDBCCEiEWQYCAgIB4IQECQAJAIAogDBDRESIMRQ0AIAdB6ABqIAwpAwggDCsDABDSEQJAIAcoAmgiDEEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAJIAkoAgAiDEEBajYCACAMQQBIDQIgBkEgaiAHQQhqQdgA/AoAACAGIBY6AJQBIAZBADYCkAEgBiAJNgKMASAGIBc3AoQBIAYgATYCgAEgBiAFNgJ8IAYgCDYCeCAGQQA2AhggBkEANgIQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDDYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDSLAwBCwALIAdBgAFqJAAgACkDiANCAlENESAAQRhqIAZBmAH8CgAAIAogDhCCEiEBQQAhBiAAQQA2ArgBIABBADYCsAEgAEGwAWpBAhDpHiAAQcABakEAQTD8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDqAMgAEGAgICAeDYCnAMgAEGAgICAeDYCkAMgAEIANwOIAyAAQZADaiEBAkAgACgCEC4BGiIFQQBMBEAgAEGAgICAeDYC8AEMAQsgAEHwAWogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQfgBaigCADYCACABIAApAvABNwIAIABB8AFqIABBiANqQSj8CgAAAkAgACgCEC4BGCIBQQBMBEAgAEGAgICAeDYCiAMMAQsgAEGIA2ogAUEBakH//wNxQaD5zwAQthULIABBhAJqEIUwIABBjAJqIABBkANqKAIANgIAIAAgACkCiAMiFzcChAIgACkD8AEhGCAAKAL4ASEHIAApAvwBIRkgACgCkAIhEyAAKAKUAiEUIAApA4gCIRogAEEANgLQAyAAQQA2AsgDIABCADcDuAMgAEIANwOoAyAAQgA3A5gDIABCADcDiAMgAEHUA2ogAEG8AWpBNPwKAAAgAEGAgICAeDYClAQgAEGAgICAeDYCiAQgAEGIBGohAQJAIAAoAhAuARoiBUEATARAIABBgICAgHg2AvABDAELIABB8AFqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEH4AWooAgA2AgAgASAAKQLwATcCACAAQfABaiAAQYgDakGYAfwKAAACQCAAKAIQLgEYIgFBAEwEQCAAQYCAgIB4NgKIAwwBCyAAQYgDaiABQQFqQf//A3FBoPnPABC2FQsgAEH8AmoQhTAgAEGEA2ogAEGQA2ooAgA2AgAgACAAKQKIAzcC/AIgACkD8AEhGyAAKQP4ASEcIAApA4ACIR0gACkDiAIhHiAAKQOQAiEfIAApA5gCISAgACkDoAIhISAAKQOoAiEiIAAoArACIQsgACgCtAIhDSAAKAK4AiEPIABBvAFqIABBvAJqQTT8CgAAIBenIQUgCEECRiEGIAApA4ADISMgACkC9AIhJCAAKALwAiEBIAAoAvwCCyEJIAoQ9RUhCiAEIAg6AM4EIAQgAjYCvAQgBEG47c8ANgL8AyAEIAM2AvgDIAQgEjYChAQgBCAVNgKABCAEIBA2ArQCIAQgETYCsAIgBEHIBGogAEG4AWooAgA2AgAgBCAAKQKwATcCwAQgBCAAKAIQNgK4BCAEIABBGGpBmAH8CgAAIAQgFDYCvAMgBCATNgK4AyAEIBo3A7ADIAQgBTYCrAMgBCAZNwKkAyAEIAc2AqADIAQgGDcDmAMgBCAPNgLgASAEIA02AtwBIAQgCzYC2AEgBCAiNwPQASAEICE3A8gBIAQgIDcDwAEgBCAfNwO4ASAEIB43A7ABIAQgHTcDqAEgBCAcNwOgASAEIBs3A5gBIARB5AFqIABBvAFqQTT8CgAAIARBADYCtAQgBEKAgICAIDcCrAQgBEICNwKkBCAEQgA3ApwEIARCgICAgMAANwKUBCAEICM3A6gCIAQgCTYCpAIgBCAkNwKcAiAEIAE2ApgCIARBgQI7AcwEIARBgICAgHg2AuwDIARCCDcC5AMgBEIANwLcAyAEQoCAgIDAADcC1AMgBEIINwLMAyAEQYCAgIB4QQAgChs2AsgDIARCADcDwAMgBCAGOgCUAyAEQQA2ApADIARBgICAgHg2AoQDIARBgICAgHg2AvgCIARCCDcD8AIgBEIANwPoAiAEQoCAgIDAADcD4AIgBEIENwPYAiAEQgA3A9ACIARCgICAgBA3A8gCIARCADcDwAIgBEKAgICAgAE3A7gCIARBADYCiAQgAEGgBGokAAwBCwwPC0IBDAYLIwBB0ARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABBgAJqIAwgDSAAQQ9qEMcNAkAgACgCgAJBCEYEQCAAKAKIAiEQIAAoAoQCIREgAEGoA2ohBiMAQYABayIHJAACQAJAAkAgCCAAQQhqKAIAIgpBCGoiCRDnEUUEQCAHQYCAgIB4NgJQDAELIAogCigCACIBQQFqNgIAIAFBAEgNASAHQQhqIAoQxCALIAggCRDbEiEBQQRBACAILQCVAUEBcRsgAUH/AXEiASABQQlGGyEFIwBB8AFrIgEkAAJAAkACQCAHQegAaiILAn8CQAJAAkACQAJAAkACQCAFQf8BcUEBaw4IAQIJAwQFAQYACyABQYACEOggIAFBADYCICABQoCAgIAQNwMYQShBCBCtNiIFRQ0VIAUgAUEo/AoAAEH4ks4ADAYLIAFBNUEAQQFBARCgGCABKAIEIQUgASgCAEEBRg0VIAEoAggiDkH0kc4AQTX8CgAAIAtBNTYCDCALIA42AgggCyAFNgIEIAtBADYCAAwIC0H4AEEIEK02IgVFDRUgBUGAgICAeDYCCEGYk84ADAQLIAFBIBDoICABQRhqQYCAwAAQ6CAgAUFAa0GAAkGEns4AELYVIAFCADcDMCABQoCAgICAIDcCTCABQThqQgA3AwAgAUEANgJcIAFCwICAgMAANwJUQeAAQQgQrTYiBUUNBCAFIAFB4AD8CgAAQbiTzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0UIAUgAUHwAPwKAABB2JPOAAwCCyABEKEnQeABQQgQrTYiBUUNFCAFIAFB4AH8CgAAQfiTzgAMAQtBDEEEEK02IgVFDRQgBUEANgIIIAVCgICAgBA3AgBBmJTOAAs2AgggCyAFNgIEIAtBCDYCAAwCC0EIQeAAEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAtBBGogARCZDiALQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCwJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAs2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByALNgJgIAggCRCCEiEOQYCAgIB4IQECQAJAIAggCRDRESIJRQ0AIAdB6ABqIAkpAwggCSsDABDSEQJAIAcoAmgiCUEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAKIAooAgAiCUEBajYCACAJQQBIDQIgBkEwaiAHQQhqQdgA/AoAACAGIA46AKQBIAZBADYCoAEgBiAKNgKcASAGIBc3ApQBIAYgATYCkAEgBiAFNgKMASAGIAs2AogBIAZCADcDICAGQgA3AxAgBkIANwMADAMLIAcoAmwhASAHKQNwIRcgBiAHKQN4NwMYIAYgFzcDECAGIAE2AgwgBiAJNgIIIAZCAjcDACAHQeAAahC8KgsgBygCUEGAgICAeEYNASAHQQhqENMsDAELAAsgB0GAAWokACAAKQOoA0ICUQ0SIABBEGogBkGoAfwKAAAgCCAPEIISIQFBACEGIABBADYCxAEgAEEANgK8ASAAQbwBakECEOkeIABB0AFqQQBBMPwLAAJ/IAFB/wFxIgtFBEBBgICAgHghB0GAgICAeCEFQYCAgIB4IQFBgICAgHgMAQsgAEIANwPIAyAAQYCAgIB4NgK8AyAAQYCAgIB4NgKwAyAAQgA3A6gDIABBsANqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKAAgwBCyAAQYACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBiAJqKAIANgIAIAEgACkCgAI3AgAgAEGAAmogAEGoA2pBKPwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgKoAwwBCyAAQagDaiABQQFqQf//A3FBoPnPABC2FQsgAEGUAmoQhTAgAEGcAmogAEGwA2ooAgA2AgAgACAAKQKoAyIXNwKUAiAAKQOAAiEYIAAoAogCIQcgACkCjAIhGSAAKAKgAiETIAAoAqQCIRQgACkDmAIhGiAAQgA3A/gDIABCADcD6AMgAEIANwPYAyAAQgA3A8gDIABCADcDuAMgAEIANwOoAyAAQYAEaiAAQcgBakE4/AoAACAAQYCAgIB4NgLEBCAAQYCAgIB4NgK4BCAAQbgEaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCgAIMAQsgAEGAAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQYgCaigCADYCACABIAApAoACNwIAIABBgAJqIABBqANqQagB/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AqgDDAELIABBqANqIAFBAWpB//8DcUGg+c8AELYVCyAAQZwDahCFMCAAQaQDaiAAQbADaigCADYCACAAIAApAqgDNwKcAyAAKQOAAiEbIAApA4gCIRwgACkDkAIhHSAAKQOYAiEeIAApA6ACIR8gACkDqAIhICAAKQOwAiEhIAApA7gCISIgACkDwAIhIyAAKQPIAiEkIAApA9ACISUgAEHIAWogAEHYAmpBOPwKAAAgF6chBSALQQJGIQYgACkDoAMhJiAAKQKUAyEnIAAoApADIQEgACgCnAMLIQogCBD1FSEIIAQgCzoA+gQgBCACNgLoBCAEQbjtzwA2ArQEIAQgAzYCsAQgBCAQNgK8BCAEIBE2ArgEIAQgDTYC7AIgBCAMNgLoAiAEQfQEaiAAQcQBaigCADYCACAEIAApArwBNwLsBCAEIAAoAgg2AuQEIAQgAEEQakGoAfwKAAAgBCAUNgL0AyAEIBM2AvADIAQgGjcD6AMgBCAFNgLkAyAEIBk3AtwDIAQgBzYC2AMgBCAYNwPQAyAEICU3A/gBIAQgJDcD8AEgBCAjNwPoASAEICI3A+ABIAQgITcD2AEgBCAgNwPQASAEIB83A8gBIAQgHjcDwAEgBCAdNwO4ASAEIBw3A7ABIAQgGzcDqAEgBEGAAmogAEHIAWpBOPwKAAAgBEEANgLgBCAEQoCAgIAgNwPYBCAEQgI3A9AEIARCADcDyAQgBEKAgICAwAA3A8AEIAQgJjcDyAIgBCAKNgLEAiAEICc3ArwCIAQgATYCuAIgBEGBAjsB+AQgBEGAgICAeDYCpAQgBEIINwKcBCAEQgA3ApQEIARCgICAgMAANwKMBCAEQgg3AoQEIARBgICAgHhBACAIGzYCgAQgBEIANwP4AyAEIAY6AMwDIARBADYCyAMgBEGAgICAeDYCvAMgBEGAgICAeDYCsAMgBEIINwOoAyAEQgA3A6ADIARCgICAgMAANwOYAyAEQgQ3A5ADIARCADcDiAMgBEKAgICAEDcDgAMgBEIANwP4AiAEQoCAgICAATcD8AIgBEIANwPQAiAAQdAEaiQADAELDBALQgIMBQsjAEHgBGsiACQAIAAgATYCCCAAIAJBCGoiCiABQQhqIhEQzxAgACgCBCEPIAAoAgAhECAAQQE6AA8gAEGQAmogECAPIABBD2oQxw0CQAJAIAAoApACQQhGBEAgACgCmAIhDiAAKAKUAiESIABBuANqIQYjAEGAAWsiByQAAkACQAJAIAogAEEIaigCACIJQQhqIgwQ5xFFBEAgB0GAgICAeDYCUAwBCyAJIAkoAgAiAUEBajYCACABQQBIDQEgB0EIaiAJEMMgCyAKIAwQ2xJB/wFxIgFBACABQQlHGyEFIwBB8AFrIgEkAAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcTAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDRMgBSABQSj8CgAAQbiZzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDRMgASgCCCIVQfSRzgBBNfwKAAAgCEE1NgIMIAggFTYCCCAIIAU2AgQgCEEANgIADAYLQfgAQQgQrTYiBUUNEyAFQYCAgIB4NgIIQdiZzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0TIAUgAUHwAPwKAABB+JnOAAwCCyABEKEnQeABQQgQrTYiBUUNEyAFIAFB4AH8CgAAQZiazgAMAQtBDEEEEK02IgVFDRMgBUEANgIIIAVCgICAgBA3AgBBuJrOAAs2AgggCCAFNgIEIAhBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgCEEEaiABEJkOIAhBATYCAAsgAUHwAWokACAHKAJwIQUgBygCbCEIAkAgBygCaCIBQQhHBEAgBiAHKQJ0NwIUIAZBHGogB0H8AGooAgA2AgAgBiAFNgIQIAYgCDYCDCAGIAE2AgggBkICNwMADAELIAcgBTYCZCAHIAg2AmAgCiAMEIISIRVBgICAgHghAQJAAkAgCiAMENERIgxFDQAgB0HoAGogDCkDCCAMKwMAENIRAkAgBygCaCIMQQhrDgIAAQILIAcpA3AhFyAHKAJsIQELIAkgCSgCACIMQQFqNgIAIAxBAEgNAiAGQTBqIAdBCGpB2AD8CgAAIAYgFToApAEgBkEANgKgASAGIAk2ApwBIAYgFzcClAEgBiABNgKQASAGIAU2AowBIAYgCDYCiAEgBkEANgIgIAZBADYCECAGQgA3AwAMAwsgBygCbCEBIAcpA3AhFyAGIAcpA3g3AxggBiAXNwMQIAYgATYCDCAGIAw2AgggBkICNwMAIAdB4ABqELwqCyAHKAJQQYCAgIB4Rg0BIAdBCGoQgy0MAQsACyAHQYABaiQAIAApA7gDQgJRDQEgAEEQaiAGQagB/AoAACAKIBEQghIhAUEAIQYgAEEANgLAASAAQQA2ArgBIABBuAFqQQIQ6R4gAEHQAWpBAEEw/AsAAn8gAUH/AXEiCEUEQEGAgICAeCEHQYCAgIB4IQVBgICAgHghAUGAgICAeAwBCyAAQgA3A9gDIABBgICAgHg2AswDIABBgICAgHg2AsADIABCADcDuAMgAEHAA2ohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2ApACDAELIABBkAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEGYAmooAgA2AgAgASAAKQKQAjcCACAAQZACaiAAQbgDakEo/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2ArgDDAELIABBuANqIAFBAWpB//8DcUGg+c8AELYVCyAAQaQCahCFMCAAQawCaiAAQcADaigCADYCACAAIAApArgDIhc3AqQCIAApA5ACIRggACgCmAIhByAAKQKcAiEZIAAoArACIRMgACgCtAIhFCAAKQOoAiEaIABBADYCiAQgAEEANgL4AyAAQgA3A+gDIABCADcD2AMgAEIANwPIAyAAQgA3A7gDIABBjARqIABBxAFqQTz8CgAAIABBgICAgHg2AtQEIABBgICAgHg2AsgEIABByARqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKQAgwBCyAAQZACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBmAJqKAIANgIAIAEgACkCkAI3AgAgAEGQAmogAEG4A2pBqAH8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYCuAMMAQsgAEG4A2ogAUEBakH//wNxQaD5zwAQthULIABBrANqEIUwIABBtANqIABBwANqKAIANgIAIABBiAJqIABB3AJqKAIANgIAIAAgACkCuAM3AqwDIAAgACkC1AI3A4ACIAApA5ACIRsgACkDmAIhHCAAKQOgAiEdIAApA6gCIR4gACkDsAIhHyAAKQO4AiEgIAApA8ACISEgACkDyAIhIiAAKALQAiELIAAoAuACIQ0gAEHEAWogAEHkAmpBPPwKAAAgF6chBSAIQQJGIQYgACkDsAMhIyAAKQKkAyEkIAAoAqADIQEgACgCrAMLIQkgChD1FSEKIAQgCDoA/gQgBCACNgLsBCAEQbjtzwA2ApwEIAQgAzYCmAQgBCAONgKkBCAEIBI2AqAEIAQgDzYC1AIgBCAQNgLQAiAEQfgEaiAAQcABaigCADYCACAEIAApArgBNwLwBCAEIAAoAgg2AugEIAQgAEEQakGoAfwKAAAgBCAUNgLcAyAEIBM2AtgDIAQgGjcD0AMgBCAFNgLMAyAEIBk3AsQDIAQgBzYCwAMgBCAYNwO4AyAEIAs2AugBIAQgIjcD4AEgBCAhNwPYASAEICA3A9ABIAQgHzcDyAEgBCAeNwPAASAEIB03A7gBIAQgHDcDsAEgBCAbNwOoASAEIAApA4ACNwLsASAEQfQBaiAAQYgCaigCADYCACAEIA02AvgBIARB/AFqIABBxAFqQTz8CgAAIARBADYC5AQgBEKAgICAIDcC3AQgBEICNwLUBCAEQgA3AswEIARCgICAgMAANwLEBCAEICM3A8gCIAQgCTYCxAIgBCAkNwK8AiAEIAE2ArgCIARBgQI7AfwEIARBgICAgHg2AowEIARCCDcChAQgBEIANwL8AyAEQoCAgIDAADcC9AMgBEIINwLsAyAEQYCAgIB4QQAgChs2AugDIARCADcD4AMgBCAGOgC0AyAEQQA2ArADIARBgICAgHg2AqQDIARBgICAgHg2ApgDIARCCDcDkAMgBEIANwOIAyAEQoCAgIDAADcDgAMgBEIENwP4AiAEQgA3A/ACIARCgICAgBA3A+gCIARCADcD4AIgBEKAgICAgAE3A9gCIARBADYCqAQgAEHgBGokAAwCCyAAQcgDaiAAQaACaikDADcDACAAQcADaiAAQZgCaikDADcDACAAIAApA5ACNwO4A0HE784AQSsgAEG4A2pBtO/OAEGo/c4AENUeAAsgAEGgAmogAEHQA2opAwA3AwAgAEGYAmogAEHIA2opAwA3AwAgACAAKQPAAzcDkAJBxO/OAEErIABBkAJqQbTvzgBBuP3OABDVHgALQgMMBAsjAEGgBGsiACQAIAAgATYCECAAQQhqIAJBCGoiCiABQQhqIg4QzxAgACgCDCEQIAAoAgghESAAQQE6ABcgAEHwAWogESAQIABBF2oQxw0CQCAAKALwAUEIRgRAIAAoAvgBIRIgACgC9AEhFSAAQYgDaiEGIwBBgAFrIgckAAJAAkACQCAKIABBEGooAgAiCUEIaiIMEOcRRQRAIAdBgICAgHg2AlAMAQsgCSAJKAIAIgFBAWo2AgAgAUEASA0BIAdBCGogCRDDIAsgCiAMENsSQf8BcSIBQQAgAUEJRxshBSMAQfABayIBJAACQAJAIAdB6ABqIggCfwJAAkACQAJAAkACQCAFQf8BcUEBaw4IAQIHEQMEAQUACyABQYACEOggIAFBADYCICABQoCAgIAQNwMYQShBCBCtNiIFRQ0RIAUgAUEo/AoAAEG4lM4ADAULIAFBNUEAQQFBARCgGCABKAIEIQUgASgCAEEBRg0RIAEoAggiFkH0kc4AQTX8CgAAIAhBNTYCDCAIIBY2AgggCCAFNgIEIAhBADYCAAwGC0H4AEEIEK02IgVFDREgBUGAgICAeDYCCEHYlM4ADAMLIAEQmSggAUIANwNoIAFCgICAgMAANwNgQfAAQQgQrTYiBUUNESAFIAFB8AD8CgAAQfiUzgAMAgsgARChJ0HgAUEIEK02IgVFDREgBSABQeAB/AoAAEGYlc4ADAELQQxBBBCtNiIFRQ0RIAVBADYCCCAFQoCAgIAQNwIAQbiVzgALNgIIIAggBTYCBCAIQQg2AgAMAQsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAhBBGogARCZDiAIQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCAJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAg2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByAINgJgIAogDBCCEiEWQYCAgIB4IQECQAJAIAogDBDRESIMRQ0AIAdB6ABqIAwpAwggDCsDABDSEQJAIAcoAmgiDEEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAJIAkoAgAiDEEBajYCACAMQQBIDQIgBkEgaiAHQQhqQdgA/AoAACAGIBY6AJQBIAZBADYCkAEgBiAJNgKMASAGIBc3AoQBIAYgATYCgAEgBiAFNgJ8IAYgCDYCeCAGQQA2AhggBkEANgIQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDDYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDSLAwBCwALIAdBgAFqJAAgACkDiANCAlENDiAAQRhqIAZBmAH8CgAAIAogDhCCEiEBQQAhBiAAQQA2ArgBIABBADYCsAEgAEGwAWpBAhDpHiAAQcABakEAQTD8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDqAMgAEGAgICAeDYCnAMgAEGAgICAeDYCkAMgAEIANwOIAyAAQZADaiEBAkAgACgCEC4BGiIFQQBMBEAgAEGAgICAeDYC8AEMAQsgAEHwAWogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQfgBaigCADYCACABIAApAvABNwIAIABB8AFqIABBiANqQSj8CgAAAkAgACgCEC4BGCIBQQBMBEAgAEGAgICAeDYCiAMMAQsgAEGIA2ogAUEBakH//wNxQaD5zwAQthULIABBhAJqEIUwIABBjAJqIABBkANqKAIANgIAIAAgACkCiAMiFzcChAIgACkD8AEhGCAAKAL4ASEHIAApAvwBIRkgACgCkAIhEyAAKAKUAiEUIAApA4gCIRogAEEANgLQAyAAQQA2AsgDIABCADcDuAMgAEIANwOoAyAAQgA3A5gDIABCADcDiAMgAEHUA2ogAEG8AWpBNPwKAAAgAEGAgICAeDYClAQgAEGAgICAeDYCiAQgAEGIBGohAQJAIAAoAhAuARoiBUEATARAIABBgICAgHg2AvABDAELIABB8AFqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEH4AWooAgA2AgAgASAAKQLwATcCACAAQfABaiAAQYgDakGYAfwKAAACQCAAKAIQLgEYIgFBAEwEQCAAQYCAgIB4NgKIAwwBCyAAQYgDaiABQQFqQf//A3FBoPnPABC2FQsgAEH8AmoQhTAgAEGEA2ogAEGQA2ooAgA2AgAgACAAKQKIAzcC/AIgACkD8AEhGyAAKQP4ASEcIAApA4ACIR0gACkDiAIhHiAAKQOQAiEfIAApA5gCISAgACkDoAIhISAAKQOoAiEiIAAoArACIQsgACgCtAIhDSAAKAK4AiEPIABBvAFqIABBvAJqQTT8CgAAIBenIQUgCEECRiEGIAApA4ADISMgACkC9AIhJCAAKALwAiEBIAAoAvwCCyEJIAoQ9RUhCiAEIAg6AM4EIAQgAjYCvAQgBEG47c8ANgL8AyAEIAM2AvgDIAQgEjYChAQgBCAVNgKABCAEIBA2ArQCIAQgETYCsAIgBEHIBGogAEG4AWooAgA2AgAgBCAAKQKwATcCwAQgBCAAKAIQNgK4BCAEIABBGGpBmAH8CgAAIAQgFDYCvAMgBCATNgK4AyAEIBo3A7ADIAQgBTYCrAMgBCAZNwKkAyAEIAc2AqADIAQgGDcDmAMgBCAPNgLgASAEIA02AtwBIAQgCzYC2AEgBCAiNwPQASAEICE3A8gBIAQgIDcDwAEgBCAfNwO4ASAEIB43A7ABIAQgHTcDqAEgBCAcNwOgASAEIBs3A5gBIARB5AFqIABBvAFqQTT8CgAAIARBADYCtAQgBEKAgICAIDcCrAQgBEICNwKkBCAEQgA3ApwEIARCgICAgMAANwKUBCAEICM3A6gCIAQgCTYCpAIgBCAkNwKcAiAEIAE2ApgCIARBgQI7AcwEIARBgICAgHg2AuwDIARCCDcC5AMgBEIANwLcAyAEQoCAgIDAADcC1AMgBEIINwLMAyAEQYCAgIB4QQAgChs2AsgDIARCADcDwAMgBCAGOgCUAyAEQQA2ApADIARBgICAgHg2AoQDIARBgICAgHg2AvgCIARCCDcD8AIgBEIANwPoAiAEQoCAgIDAADcD4AIgBEIENwPYAiAEQgA3A9ACIARCgICAgBA3A8gCIARCADcDwAIgBEKAgICAgAE3A7gCIARBADYCiAQgAEGgBGokAAwBCwwMC0IEDAMLIwBB0ARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABBgAJqIAwgDSAAQQ9qEMcNAkAgACgCgAJBCEYEQCAAKAKIAiEQIAAoAoQCIREgAEGoA2ohBiMAQYABayIHJAACQAJAAkAgCCAAQQhqKAIAIgpBCGoiCRDnEUUEQCAHQYCAgIB4NgJQDAELIAogCigCACIBQQFqNgIAIAFBAEgNASAHQQhqIAoQxCALIAggCRDbEkH/AXEiAUEAIAFBCUcbIQUjAEHwAWsiASQAAkACQCAHQegAaiILAn8CQAJAAkACQAJAAkAgBUH/AXFBAWsOCAECBxADBAEFAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNECAFIAFBKPwKAABBmJjOAAwFCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNECABKAIIIg5B9JHOAEE1/AoAACALQTU2AgwgCyAONgIIIAsgBTYCBCALQQA2AgAMBgtB+ABBCBCtNiIFRQ0QIAVBgICAgHg2AghBuJjOAAwDCyABEJkoIAFCADcDaCABQoCAgIDAADcDYEHwAEEIEK02IgVFDRAgBSABQfAA/AoAAEHYmM4ADAILIAEQoSdB4AFBCBCtNiIFRQ0QIAUgAUHgAfwKAABB+JjOAAwBC0EMQQQQrTYiBUUNECAFQQA2AgggBUKAgICAEDcCAEGYmc4ACzYCCCALIAU2AgQgC0EINgIADAELIAFBAzoA5wEgAUECNgIEIAFB6JLOADYCACABQgE3AgwgAUGuAzYC7AEgASABQegBajYCCCABIAFB5wFqNgLoASALQQRqIAEQmQ4gC0EBNgIACyABQfABaiQAIAcoAnAhBSAHKAJsIQsCQCAHKAJoIgFBCEcEQCAGIAcpAnQ3AhQgBkEcaiAHQfwAaigCADYCACAGIAU2AhAgBiALNgIMIAYgATYCCCAGQgI3AwAMAQsgByAFNgJkIAcgCzYCYCAIIAkQghIhDkGAgICAeCEBAkACQCAIIAkQ0REiCUUNACAHQegAaiAJKQMIIAkrAwAQ0hECQCAHKAJoIglBCGsOAgABAgsgBykDcCEXIAcoAmwhAQsgCiAKKAIAIglBAWo2AgAgCUEASA0CIAZBMGogB0EIakHYAPwKAAAgBiAOOgCkASAGQQA2AqABIAYgCjYCnAEgBiAXNwKUASAGIAE2ApABIAYgBTYCjAEgBiALNgKIASAGQgA3AyAgBkIANwMQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgCTYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDTLAwBCwALIAdBgAFqJAAgACkDqANCAlENDyAAQRBqIAZBqAH8CgAAIAggDxCCEiEBQQAhBiAAQQA2AsQBIABBADYCvAEgAEG8AWpBAhDpHiAAQdABakEAQTD8CwACfyABQf8BcSILRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDyAMgAEGAgICAeDYCvAMgAEGAgICAeDYCsAMgAEIANwOoAyAAQbADaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCgAIMAQsgAEGAAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQYgCaigCADYCACABIAApAoACNwIAIABBgAJqIABBqANqQSj8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYCqAMMAQsgAEGoA2ogAUEBakH//wNxQaD5zwAQthULIABBlAJqEIUwIABBnAJqIABBsANqKAIANgIAIAAgACkCqAMiFzcClAIgACkDgAIhGCAAKAKIAiEHIAApAowCIRkgACgCoAIhEyAAKAKkAiEUIAApA5gCIRogAEIANwP4AyAAQgA3A+gDIABCADcD2AMgAEIANwPIAyAAQgA3A7gDIABCADcDqAMgAEGABGogAEHIAWpBOPwKAAAgAEGAgICAeDYCxAQgAEGAgICAeDYCuAQgAEG4BGohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2AoACDAELIABBgAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEGIAmooAgA2AgAgASAAKQKAAjcCACAAQYACaiAAQagDakGoAfwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgKoAwwBCyAAQagDaiABQQFqQf//A3FBoPnPABC2FQsgAEGcA2oQhTAgAEGkA2ogAEGwA2ooAgA2AgAgACAAKQKoAzcCnAMgACkDgAIhGyAAKQOIAiEcIAApA5ACIR0gACkDmAIhHiAAKQOgAiEfIAApA6gCISAgACkDsAIhISAAKQO4AiEiIAApA8ACISMgACkDyAIhJCAAKQPQAiElIABByAFqIABB2AJqQTj8CgAAIBenIQUgC0ECRiEGIAApA6ADISYgACkClAMhJyAAKAKQAyEBIAAoApwDCyEKIAgQ9RUhCCAEIAs6APoEIAQgAjYC6AQgBEG47c8ANgK0BCAEIAM2ArAEIAQgEDYCvAQgBCARNgK4BCAEIA02AuwCIAQgDDYC6AIgBEH0BGogAEHEAWooAgA2AgAgBCAAKQK8ATcC7AQgBCAAKAIINgLkBCAEIABBEGpBqAH8CgAAIAQgFDYC9AMgBCATNgLwAyAEIBo3A+gDIAQgBTYC5AMgBCAZNwLcAyAEIAc2AtgDIAQgGDcD0AMgBCAlNwP4ASAEICQ3A/ABIAQgIzcD6AEgBCAiNwPgASAEICE3A9gBIAQgIDcD0AEgBCAfNwPIASAEIB43A8ABIAQgHTcDuAEgBCAcNwOwASAEIBs3A6gBIARBgAJqIABByAFqQTj8CgAAIARBADYC4AQgBEKAgICAIDcD2AQgBEICNwPQBCAEQgA3A8gEIARCgICAgMAANwPABCAEICY3A8gCIAQgCjYCxAIgBCAnNwK8AiAEIAE2ArgCIARBgQI7AfgEIARBgICAgHg2AqQEIARCCDcCnAQgBEIANwKUBCAEQoCAgIDAADcCjAQgBEIINwKEBCAEQYCAgIB4QQAgCBs2AoAEIARCADcD+AMgBCAGOgDMAyAEQQA2AsgDIARBgICAgHg2ArwDIARBgICAgHg2ArADIARCCDcDqAMgBEIANwOgAyAEQoCAgIDAADcDmAMgBEIENwOQAyAEQgA3A4gDIARCgICAgBA3A4ADIARCADcD+AIgBEKAgICAgAE3A/ACIARCADcD0AIgAEHQBGokAAwBCwwNC0IFDAILIwBBkAVrIgAkACAAIAE2AgggACACQQhqIgogAUEIaiIQEM8QIAAoAgQhDCAAKAIAIQ8gAEEBOgAPIABBsAJqIA8gDCAAQQ9qEMcNAkAgACgCsAJBCEYEQCAAKAK4AiERIAAoArQCIQ4gAEHgA2ohBiMAQYABayIHJAACQAJAAkAgCiAAQQhqKAIAIglBCGoiDRDnEUUEQCAHQYCAgIB4NgJQDAELIAkgCSgCACIBQQFqNgIAIAFBAEgNASAHQQhqIAkQwyALIAogDRDbEiEBQQZBACAKLQCVAUEBcRsgAUH/AXEiASABQQlGGyEFIwBB8AFrIgEkAAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcPAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDQ8gBSABQSj8CgAAQdiVzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDQ8gASgCCCISQfSRzgBBNfwKAAAgCEE1NgIMIAggEjYCCCAIIAU2AgQgCEEANgIADAYLQfgAQQgQrTYiBUUNDyAFQYCAgIB4NgIIQfiVzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0PIAUgAUHwAPwKAABBmJbOAAwCCyABEKEnQeABQQgQrTYiBUUNDyAFIAFB4AH8CgAAQbiWzgAMAQtBDEEEEK02IgVFDQ8gBUEANgIIIAVCgICAgBA3AgBB2JbOAAs2AgggCCAFNgIEIAhBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgCEEEaiABEJkOIAhBATYCAAsgAUHwAWokACAHKAJwIQUgBygCbCEIAkAgBygCaCIBQQhHBEAgBiAHKQJ0NwIUIAZBHGogB0H8AGooAgA2AgAgBiAFNgIQIAYgCDYCDCAGIAE2AgggBkICNwMADAELIAcgBTYCZCAHIAg2AmAgCiANEIISIRJBgICAgHghAQJAAkAgCiANENERIg1FDQAgB0HoAGogDSkDCCANKwMAENIRAkAgBygCaCINQQhrDgIAAQILIAcpA3AhFyAHKAJsIQELIAkgCSgCACINQQFqNgIAIA1BAEgNAiAGQRBqIAdBCGpB2AD8CgAAIAYgEjoArAEgBkEANgKoASAGIAk2AqQBIAYgFzcCnAEgBiABNgKYASAGQQA2AoQBIAZBADYCcCAGIAU2AmwgBiAINgJoIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDTYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahCeLAwBCwALIAdBgAFqJAAgACkD4ANCAlENECAAQRBqIAZBsAH8CgAAIAogEBCCEiEBQQAhBiAAQQA2AswBIABBADYCxAEgAEHEAWpBAhDpHiAAQfgBakEAQTT8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDgAQgAEGAgICAeDYC9AMgAEGAgICAeDYC6AMgAEIANwPgAyAAQegDaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCsAIMAQsgAEGwAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQbgCaigCADYCACABIAApArACNwIAIABBsAJqIABB4ANqQSj8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYC4AMMAQsgAEHgA2ogAUEBakH//wNxQaD5zwAQthULIABBxAJqEIUwIABBzAJqIABB6ANqKAIANgIAIAAgACkC4AMiFzcCxAIgACkDsAIhGCAAKAK4AiEHIAApArwCIRkgACgC0AIhEyAAKALUAiEUIAApA8gCIRogAEIANwOQBCAAQgA3A4AEIABCADcD8AMgAEIANwPgAyAAQZgEaiAAQfABakE8/AoAACAAQYCAgIB4NgKEBSAAQYCAgIB4NgL4BCAAQQA2AuQEIABB+ARqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKwAgwBCyAAQbACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBuAJqKAIANgIAIAEgACkCsAI3AgAgAEGwAmogAEHgA2pBsAH8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYC4AMMAQsgAEHgA2ogAUEBakH//wNxQaD5zwAQthULIABB1ANqEIUwIABB3ANqIABB6ANqKAIANgIAIAAgACkC4AM3AtQDIAApA7ACIRsgACkDuAIhHCAAKQPAAiEdIAApA8gCIR4gACkD0AIhHyAAKQPYAiEgIAApA+ACISEgAEHwAWogAEHoAmpBPPwKAAAgF6chBSAAQegBaiAAQawDaikCADcDACAAQdgBaiAAQcADaikDADcDACAAIAApAqQDNwPgASAAIAApA7gDNwPQASAIQQJGIQYgACgCtAMhCyAAKALIAyEBIAApAswDISIgACkD2AMhIyAAKALUAwshCSAKEPUVIQogBCAIOgCWBSAEIAI2AoQFIARBuO3PADYCrAQgBCADNgKoBCAEIBE2ArQEIAQgDjYCsAQgBCAMNgLkAiAEIA82AuACIARBkAVqIABBzAFqKAIANgIAIAQgACkCxAE3AogFIAQgACgCCDYCgAUgBCAAQRBqQbAB/AoAACAEIBQ2AuwDIAQgEzYC6AMgBCAaNwPgAyAEIAU2AtwDIAQgGTcC1AMgBCAHNgLQAyAEIBg3A8gDIAQgITcD4AEgBCAgNwPYASAEIB83A9ABIAQgHjcDyAEgBCAdNwPAASAEIBw3A7gBIAQgGzcDsAEgBEHoAWogAEHwAWpBPPwKAAAgBCALNgK0AiAEQQA2AvwEIARCgICAgCA3AvQEIARCAjcC7AQgBEIANwLkBCAEQoCAgIDAADcC3AQgBCAjNwPYAiAEIAk2AtQCIAQgIjcCzAIgBCABNgLIAiAEQawCaiAAQegBaikDADcCACAEIAApA+ABNwKkAiAEIAApA9ABNwO4AiAEQcACaiAAQdgBaikDADcDACAEQYECOwGUBSAEQYCAgIB4NgKcBCAEQgg3ApQEIARCADcCjAQgBEKAgICAwAA3AoQEIARCCDcC/AMgBEGAgICAeEEAIAobNgL4AyAEQgA3A/ADIAQgBjoAxAMgBEEANgLAAyAEQYCAgIB4NgK0AyAEQYCAgIB4NgKoAyAEQgg3A6ADIARCADcDmAMgBEKAgICAwAA3A5ADIARCBDcDiAMgBEIANwOAAyAEQoCAgIAQNwP4AiAEQgA3A/ACIARCgICAgIABNwPoAiAEQQA2ArgEIABBkAVqJAAMAQsMDgtCBgwBCyMAQZAFayIAJAAgACABNgIIIAAgAkEIaiIIIAFBCGoiEBDPECAAKAIEIQwgACgCACEPIABBAToADyAAQbACaiAPIAwgAEEPahDHDQJAIAAoArACQQhGBEAgACgCuAIhESAAKAK0AiEOIABB4ANqIQZBACEBIwBBgAFrIgckAAJAAkACQAJAAkAgCCAAQQhqIgUoAgAiCUEIaiINEOcRRQRAQQZBACAILQCVAUEBcRshAQwBCyAILQCVAQ0BCyAHQYCAgIB4NgJQDAELIAkgCSgCACIBQQFqNgIAIAFBAEgNASAHQQhqIAkQwyBBBiEBCyABIAggDRDbEkH/AXEiASABQQlGGyESIwBB8AFrIgEkAAJAAkACQCAHQegAaiIKAn8CQAJAAkACQAJAAkAgEkH/AXFBAWsOCAECCA8DBAEFAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNDyAFIAFBKPwKAABB+JbOAAwFCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNDyABKAIIIhJB9JHOAEE1/AoAACAKQTU2AgwgCiASNgIIIAogBTYCBCAKQQA2AgAMBwtB+ABBCBCtNiIFRQ0PIAVBgICAgHg2AghBmJfOAAwDCyABEJkoIAFCADcDaCABQoCAgIDAADcDYEHwAEEIEK02IgVFDQ8gBSABQfAA/AoAAEG4l84ADAILIAEQoSdB4AFBCBCtNiIFRQ0PIAUgAUHgAfwKAABB2JfOAAwBCyAFKAIAQQhqEN4lIRJBEEEEEK02IgVFDQEgBSASNgIMIAVBADYCCCAFQoCAgIAQNwIAQfiXzgALNgIIIAogBTYCBCAKQQg2AgAMAgtBBEEQEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIApBBGogARCZDiAKQQE2AgALIAFB8AFqJAAgBygCcCEBIAcoAmwhCgJAIAcoAmgiBUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgATYCECAGIAo2AgwgBiAFNgIIIAZCAjcDAAwBCyAHIAE2AmQgByAKNgJgIAggDRCCEiESQYCAgIB4IQUCQAJAIAggDRDRESINRQ0AIAdB6ABqIA0pAwggDSsDABDSEQJAIAcoAmgiDUEIaw4CAAECCyAHKQNwIRcgBygCbCEFCyAJIAkoAgAiDUEBajYCACANQQBIDQIgBkEQaiAHQQhqQdgA/AoAACAGIBI6AKwBIAZBADYCqAEgBiAJNgKkASAGIBc3ApwBIAYgBTYCmAEgBkEANgKEASAGQQA2AnAgBiABNgJsIAYgCjYCaCAGQgA3AwAMAwsgBygCbCEBIAcpA3AhFyAGIAcpA3g3AxggBiAXNwMQIAYgATYCDCAGIA02AgggBkICNwMAIAdB4ABqELwqCyAHKAJQQYCAgIB4Rg0BIAdBCGoQniwMAQsACyAHQYABaiQAIAApA+ADQgJRDQ8gAEEQaiAGQbAB/AoAACAIIBAQghIhBUEAIQEgAEEANgLMASAAQQA2AsQBIABBxAFqQQIQ6R4gAEH4AWpBAEE0/AsAAn8gBUH/AXEiBkUEQEGAgICAeCEHQYCAgIB4IQpBgICAgHghBUGAgICAeAwBCyAAQgA3A4AEIABBgICAgHg2AvQDIABBgICAgHg2AugDIABCADcD4AMgAEHoA2ohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2ArACDAELIABBsAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEG4AmooAgA2AgAgASAAKQKwAjcCACAAQbACaiAAQeADakEo/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AuADDAELIABB4ANqIAFBAWpB//8DcUGg+c8AELYVCyAAQcQCahCFMCAAQcwCaiAAQegDaigCADYCACAAIAApAuADIhc3AsQCIAApA7ACIRggACgCuAIhByAAKQK8AiEZIAAoAtACIRMgACgC1AIhFCAAKQPIAiEaIABCADcDkAQgAEIANwOABCAAQgA3A/ADIABCADcD4AMgAEGYBGogAEHwAWpBPPwKAAAgAEGAgICAeDYChAUgAEGAgICAeDYC+AQgAEEANgLkBCAAQfgEaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCsAIMAQsgAEGwAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQbgCaigCADYCACABIAApArACNwIAIABBsAJqIABB4ANqQbAB/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AuADDAELIABB4ANqIAFBAWpB//8DcUGg+c8AELYVCyAAQdQDahCFMCAAQdwDaiAAQegDaigCADYCACAAIAApAuADNwLUAyAAKQOwAiEbIAApA7gCIRwgACkDwAIhHSAAKQPIAiEeIAApA9ACIR8gACkD2AIhICAAKQPgAiEhIABB8AFqIABB6AJqQTz8CgAAIBenIQogAEHoAWogAEGsA2opAgA3AwAgAEHYAWogAEHAA2opAwA3AwAgACAAKQKkAzcD4AEgACAAKQO4AzcD0AEgBkECRiEBIAAoArQDIQsgACgCyAMhBSAAKQLMAyEiIAApA9gDISMgACgC1AMLIQkgCBD1FSEIIAQgBjoAlgUgBCACNgKEBSAEQbjtzwA2AqwEIAQgAzYCqAQgBCARNgK0BCAEIA42ArAEIAQgDDYC5AIgBCAPNgLgAiAEQZAFaiAAQcwBaigCADYCACAEIAApAsQBNwKIBSAEIAAoAgg2AoAFIAQgAEEQakGwAfwKAAAgBCAUNgLsAyAEIBM2AugDIAQgGjcD4AMgBCAKNgLcAyAEIBk3AtQDIAQgBzYC0AMgBCAYNwPIAyAEICE3A+ABIAQgIDcD2AEgBCAfNwPQASAEIB43A8gBIAQgHTcDwAEgBCAcNwO4ASAEIBs3A7ABIARB6AFqIABB8AFqQTz8CgAAIAQgCzYCtAIgBEEANgL8BCAEQoCAgIAgNwL0BCAEQgI3AuwEIARCADcC5AQgBEKAgICAwAA3AtwEIAQgIzcD2AIgBCAJNgLUAiAEICI3AswCIAQgBTYCyAIgBEGsAmogAEHoAWopAwA3AgAgBCAAKQPgATcCpAIgBCAAKQPQATcDuAIgBEHAAmogAEHYAWopAwA3AwAgBEGBAjsBlAUgBEGAgICAeDYCnAQgBEIINwKUBCAEQgA3AowEIARCgICAgMAANwKEBCAEQgg3AvwDIARBgICAgHhBACAIGzYC+AMgBEIANwPwAyAEIAE6AMQDIARBADYCwAMgBEGAgICAeDYCtAMgBEGAgICAeDYCqAMgBEIINwOgAyAEQgA3A5gDIARCgICAgMAANwOQAyAEQgQ3A4gDIARCADcDgAMgBEKAgICAEDcD+AIgBEIANwPwAiAEQoCAgICAATcD6AIgBEEANgK4BCAAQZAFaiQADAELDA0LQgcLNwMADwsjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyfzgA2AgggAEIENwIQIABBCGpB9J/OABDvLAALQQhBKBCjPQALIAUgASgCCEGch84AEP0vAAtBCEH4ABCjPQALQQhB8AAQoz0AC0EIQeABEKM9AAtBBEEMEKM9AAsgAEGYA2ogAEGAAmopAwA3AwAgAEGQA2ogAEH4AWopAwA3AwAgACAAKQPwATcDiANBxO/OAEErIABBiANqQbTvzgBBqP3OABDVHgALIABBgAJqIABBoANqKQMANwMAIABB+AFqIABBmANqKQMANwMAIAAgACkDkAM3A/ABQcTvzgBBKyAAQfABakG0784AQbj9zgAQ1R4ACyAAQbgDaiAAQZACaikDADcDACAAQbADaiAAQYgCaikDADcDACAAIAApA4ACNwOoA0HE784AQSsgAEGoA2pBtO/OAEGo/c4AENUeAAsgAEGQAmogAEHAA2opAwA3AwAgAEGIAmogAEG4A2opAwA3AwAgACAAKQOwAzcDgAJBxO/OAEErIABBgAJqQbTvzgBBuP3OABDVHgALIABB8ANqIABBwAJqKQMANwMAIABB6ANqIABBuAJqKQMANwMAIAAgACkDsAI3A+ADQcTvzgBBKyAAQeADakG0784AQaj9zgAQ1R4ACyAAQcACaiAAQfgDaikDADcDACAAQbgCaiAAQfADaikDADcDACAAIAApA+gDNwOwAkHE784AQSsgAEGwAmpBtO/OAEG4/c4AENUeAAvAAQIDfwJ9IwBBIGsiAiQAIAIgACgCBCIDNgIEAkAgA0EQRgRAIAAoAgAiAyABQQ9xIgRBAXRqLwEAIQAgAUH/AXEEfyAEQQFrIgFBD0sNAiAAIAMgAUEBdGovAQBrBSAAC0H//wNxQQJ0QcyG4wBqKgIAIQUgAy8BHkECdEHMhuMAaioCACACQSBqJAAgBZMPCyACQQA2AghBACACQQRqQeyG8wAgAkEIakGAh/MAEK8rAAtBf0EQQfCG8wAQwyEAC8QBAQN/IwBBIGsiAyQAIABBASAAKAIIIgJBAXQiASABQQFNGyIBIAJrEIwcAkACQAJAIAFBAUYNACAAKAIIIgIgAUEBdiIBSQ0BIAIgAWsiAiABRw0CIAAoAgQhACABRSICRQRAIAAgAWogACAB/AoAAAsgAg0AIABBACAB/AsACyADQSBqJAAPCyADQQA2AhggA0EBNgIMIANB1IH/ADYCCCADQgQ3AhAgA0EIakHsgf8AEO8sAAsgAiABQfyB/wAQszsAC8MBAgR/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpB3MmEASgCACICNgIAIAFB1MmEASkCACIFNwMIIAAtAAAgAC0AASEAIAFBCGoiBBC/DEENRiAAQQNGcUUEQCABQShqIAI2AgAgASAFNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCAEQfDIhAEQ7ywACyABQUBrJAALwwECBH8BfiMAQUBqIgEkACABIAA2AgQgAUEQakGAyoQBKAIAIgI2AgAgAUH4yYQBKQIAIgU3AwggAC0AACAALQABIQAgAUEIaiIEEL8MQQ1GIABBAkZxRQRAIAFBKGogAjYCACABIAU3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIARB8MiEARDvLAALIAFBQGskAAvDAQIEfwF+IwBBQGoiASQAIAEgADYCBCABQRBqQaTKhAEoAgAiAjYCACABQZzKhAEpAgAiBTcDCCAALQAAIAAtAAEhACABQQhqIgQQvwxBDUYgAEEBRnFFBEAgAUEoaiACNgIAIAEgBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgBEHwyIQBEO8sAAsgAUFAayQAC9UBAQJ/IwBBQGoiAyQAIAMgAjYCACABKAIUQQJ2QQFrIgQgAk0EQCADIAQ2AhwgA0EENgIIIANBpI+GATYCBCADQgQ3AhAgA0E7NgI8IANBxwI2AjQgA0HcjoYBNgIwIANBxwI2AiwgA0HMjoYBNgIoIANBOzYCJCADIANBIGo2AgwgAyADQRxqNgI4IAMgAzYCICADQQRqQcSPhgEQ7ywACyAAIAEoAhAgAkECdGoiAigCACIEIAEoAhxqNgIAIAAgAkEEaigCACAEazYCBCADQUBrJAAL1QEBAn8jAEFAaiIDJAAgAyACNgIAIAEoAhRBAnZBAWsiBCACTQRAIAMgBDYCHCADQQQ2AgggA0Gkj4YBNgIEIANCBDcCECADQTs2AjwgA0HHAjYCNCADQeyPhgE2AjAgA0HHAjYCLCADQcyOhgE2AiggA0E7NgIkIAMgA0EgajYCDCADIANBHGo2AjggAyADNgIgIANBBGpBxI+GARDvLAALIAAgASgCECACQQJ0aiICKAIAIgQgASgCHGo2AgAgACACQQRqKAIAIARrNgIEIANBQGskAAu6DgIPfwF+IwBBEGsiCiQAIAAoAgwhAwJAAkACQAJAAkACQCAAKAIEDgIAAQILIAMNAUEBIQNBACEADAILIAMNACAAKAIAIgMoAgQhACADKAIAIQMMAQsgCkEEaiAAEJkODAELIApBBGogAEEAQQFBARCgGCAKKAIIIQIgCigCBEEBRg0BIAooAgwhBiAABEAgBiADIAD8CgAACyAKIAA2AgwgCiAGNgIIIAogAjYCBAsCf0EAIQYjAEHgAGsiBSQAIAVBIGogCkEEaiINKAIEIgkgDSgCCCICQaiwiAFBCRCpAwJAAkAgBQJ/AkACQAJAIAUoAiBBAUYEQCAFQShqIQAgBSgCXCEDIAUoAlghBiAFKAJUIQQgBSgCUCEIIAUoAkRBf0YNASAFQRRqIAAgCCAEIAYgA0EAEOALDAULQQAgBS0ALg0DGiAFLQAtIQYgBSgCKCIBRQ0BIAUoAlQhCCAFKAJQIQMDQAJAIAEgCE8EQCABIAhGDQEMCAsgASADaiwAAEFASA0HCyABIANqIgRBAWssAAAiAEEASARAIABBP3ECfyAEQQJrLQAAIgDAIgdBQE4EQCAAQR9xDAELIAdBP3ECfyAEQQNrLQAAIgDAIgdBQE4EQCAAQQ9xDAELIAdBP3EgBEEEay0AAEEHcUEGdHILQQZ0cgtBBnRyIQALIAZBAXENA0EBIQYCf0F/IABBgAFJDQAaQX4gAEGAEEkNABpBfUF8IABBgIAESRsLIAFqIgENAAtBACEBDAILIAVBFGogACAIIAQgBiADQQEQ4AsMAwtBACIBIAZBAXFFDQEaCyAFIAE2AhhBAQs2AhQLAkAgBSgCFEEBRw0AIAIgCWohACAFKAIYIgxBCWoiByEBAkACQAJAAkACQAJAA0ACQCABRQ0AIAEgAk8EQCABIAJGDQEMCAsgASAJaiwAAEG/f0wNBwsCQAJAAn8gASACRgRAIAAhBiACDAELIAEgCWoiBi0AAEEwa0H/AXFBCkkNASABCyEEAkAgAUUNACACIARNBEAgAiAERg0BDAkLIAYsAABBv39MDQgLIAYgAiAEa0GxsIgBQQgQ9C5FDQkgBEEIaiILIQADQAJAIABFDQAgACACTwRAIAAgAkYNAQwJCyAAIAlqLAAAQb9/TA0ICwJAAkACQCAAIAJGBEAgAiEDDAELIAAgCWotAABBMGtB/wFxQQpJDQEgACEDIAAgAkkNDQsgBCAHSQ0GIAdFDQQgAiAHSw0BIAIgB0cNBgwECyAAQQFqIQAMAQsLIAcgCWosAABBv39KDQEMAwsgAUEBaiEBDAELCwJAIAFFDQAgAiAETQRAIAIgBEYNAQwCCyAGLAAAQb9/TA0BCyAHIAlqIQECQAJAAkAgBCAHayIHDgIJAAELQQEhBCABLQAAQStrDgMIAQgBCyABLQAAQStGBEAgB0EBayEEIAFBAWohASAHQQpJDQEMAwsgByIEQQlPDQILQQAhBgNAIAEtAABBMGsiCEEJSw0HIAFBAWohASAIIAZBCmxqIQYgBEEBayIEDQALDAILIAkgAiAHIARBzLGIARCjNgALQQAhBgNAIARFDQEgAS0AAEEwayIHQQlLDQUgBq1CCn4iEEIgiKcNBSABQQFqIQEgBEEBayEEIAcgEKciD2oiBiAPTw0ACwwECwJAAkACQAJAAkACQCADIAtJDQACQCALRQ0AIAIgC00EQCACIAtHDQIMAQsgCSALaiwAAEG/f0wNAQsgAEEAIAIgA0cbDQAgCSALaiEBIAMgC2siAw4CCQECCyAJIAIgCyADQdyxiAEQozYAC0EBIQAgAS0AAEEraw4DBwEHAQsgAS0AAEErRgRAIANBAWshACABQQFqIQEgA0EKSQ0BDAILIAMiAEEJTw0BC0EAIQgDQCABLQAAQTBrIgNBCUsNBiABQQFqIQEgAyAIQQpsaiEIIABBAWsiAA0ACwwBC0EAIQgDQCAARQ0BIAEtAABBMGsiA0EJSw0FIAitQgp+IhBCIIinDQUgAUEBaiEBIABBAWshACADIBCnIgRqIgggBE8NAAsMBAtBASEOIAIgDEkNAwJAIAxFIAIgDE1yRQRAIAkgDGosAABBv39MDQELIA0gDDYCCAwEC0HYr4gBQTBB7LGIARCfKQALIAkgAiAAIAJBvLGIARCjNgALIAkgAiAEIAJBrLGIARCjNgALIAkgAiABIAJBnLGIARCjNgALIAVBKGogDUEIaigCADYCACAFIA0pAgA3AyAgBUEIaiAFQSBqQYyxiAEQkCEgBSgCDCEDIAUoAgghAkEUQQQQrTYiAARAIAAgAjYCBCAAQQA2AgAgACAIQQAgDhs2AhAgACAGQQAgDhs2AgwgACADNgIIIAVB4ABqJAAgAAwCC0EEQRQQoz0ACyADIAhBACABQZiwiAEQozYACyAKQRBqJAAPCyACIAooAgxBiLCIARD9LwALnCMDF38BfgN9AkAgAgRAIAJBA3RBH2oCfyALKAIAIh0gBmdBIGpBP3MiBkEPSw0AGiAdQQEgBnRBgNQCcUUNABogBCEXIAUhEyAGIQQgByERIAghEiAKIRpBACEKIwBBoAprIg8kACAPQQBBgAT8CwAgCygCACEOIA9BgARqIgVBAEGAAvwLACAPQYAGaiIGQQBBgAT8CwBBgIAGIAIiFCAUQYCABk8bIghBACALIAwgDRDoI0ENQgAgCyAMIA0Q3xMgACABIAggBSAGIAsgDCANEPULIR8CQAJAIAkiISgCACIFQQhPBEBBByEGA0AgBkEHa0EDdiIHQYAETw0CQQggByAaajEAACALIAwgDRDfEyAGQQhqIgYgBUkNAAsLIAVBA3YiBkGABE8EQCAGQYAEQeTZzgAQwyEAC0HAACAEayEVIA5BA2ohGyAFQQdxIAYgGmoxAAAgCyAMIA0Q3xNBASEZIAghB0EAIQQMAQsgB0GABEGU3s4AEMMhAAsCQAJAAkADQAJAIAQhCQJAAkACQAJAIBlBAWsOAgACAQsgD0HUj/MAQYAE/AoAACAHIApqIR5BACEZIAdBD00NBCAKQQFqIgYgAU0EQCAAIAZqIAEgBmsgFRDnHCEFIApBAmoiECAUQRBrIg4gB0EFayIWIA4gFkkbIApqIhxLDQUgHkEFayEiQX8hBANAQSEhIANAAkACQAJAAkACQAJAIBAiDiABTQRAIAAgDmogASAOayAVEOccIRYgASAGSQ0BIAEgBiAEayIQSQ0CIAYgEEtBACAAIAZqIiMgASAGayIkIAAgEGogASAQaxDFFBtFBEAgBSATSQRAIBcgBUECdGoiBSgCACEQIAUgBjYCACABIBBJDQUgIyAkIAAgEGogASAQaxDFFA0HDAgLIAUgE0H02s4AEMMhAAsgBSATSQ0EIAUgE0GU284AEMMhAAsgDiABQcTazgAQrzsACyAGIAFB1NrOABCvOwALIBAgAUHk2s4AEK87AAsgECABQYTbzgAQrzsACyAXIAVBAnRqIAY2AgALIAYgEGsiBUHw/w9LDQACQAJAAkACQCAQQQVqIg4gAU0EQCABIAZBBWoiEEkNASAAIA5qIAEgDmsgACAQaiABIBBrICIgBmsQsiAhEAJAIAYgCWsiDkHCME8EQCAJIBhrIA4gHxDzNEUEQCAOIBEgEiAPIAsgDCANEMsUDAILIAAgGGogASAYayAGIBhrIBtBA2sgCyAMIA0QsBkgCiAUaiAGayEUQQIhGSAGIQogBiEEDA8LIA4gESASIA8gCyAMIA0QmgoLIAEgCUkNAiAAIAlqIAEgCWsgDiAPQYAEaiAPQYAGaiALIAwgDRDHHCAEIAVHBEAgBSARIBIgDyALIAwgDRCTFgwFCwwDCyAOIAFBpNvOABCvOwALIBAgAUG0284AEK87AAsgCSABQcTbzgAQrzsACyARLQBAIBIzAYABIAsgDCANEN8TIA8gDygCgAJBAWo2AoACIAQhBQsCQAJAAkACQAJAAkACQAJAAkACQCAQQQVqIhAiBEEMTwRAIARByABPBEAgBEGIAU8EQCAEQcgQTwRAIBEtACcgEjMBTiALIAwgDRDfE0EYIARByBBrrSALIAwgDRDfEyARLQBAIBIzAYABIAsgDCANEN8TIA8gDygCnAFBAWo2ApwBDAwLIARByABrIg5nQSBqQT9zIglBHGoiBEGAAU8NAyAEQYABTyIWDQQgBCARai0AACASIARBAXRqMwEAIAsgDCANEN8TIAkgDq1CfyAJrYZ8IAsgDCANEN8TIBEtAEAgEjMBgAEgCyAMIA0Q3xMgFg0FIA8gBEECdGoiBCAEKAIAQQFqNgIADAsLIARBCGsiCUEFdkEeaiIEQYABTw0FIARBgAFPIg4NBiAEIBFqLQAAIBIgBEEBdGozAQAgCyAMIA0Q3xNBBSAJQR9xrSALIAwgDRDfEyARLQBAIBIzAYABIAsgDCANEN8TIA4EQCAEQYABQZSZ8wAQwyEACyAPIARBAnRqIgQgBCgCAEEBajYCAAwKCyAEQQhrIg4gDmdBIGpBP3NBAWsiCXYiFiAJQQF0akEEaiIEQYABTw0GIARBgAFPBEAgBEGAAUHEmfMAEMMhAAsgBCARai0AACASIARBAXRqMwEAIAsgDCANEN8TIAkgDiAWIAl0a60gCyAMIA0Q3xMgBEGAAUkNCCAEQYABQdSZ8wAQwyEACyAEQQRrIgRBgAFPDQYgBEGAAU8EQCAEQYABQfSZ8wAQwyEACyAEIBFqLQAAIBIgBEEBdGozAQAgCyAMIA0Q3xMgBEGAAUkNByAEQYABQYSa8wAQwyEACyAEQYABQfSX8wAQwyEACyAEQYABQYSY8wAQwyEACyAEQYABQbSY8wAQwyEACyAEQYABQdSY8wAQwyEACyAEQYABQeSY8wAQwyEACyAEQYABQbSZ8wAQwyEACyAEQYABQeSZ8wAQwyEACyAPIARBAnRqIgQgBCgCAEEBajYCAAwBCyAPIA8oAoACQQFqNgKAAgsgBiAQaiIJIBxPDQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCUECSwRAIAEgCUEDayIESQ0BIA9CADcDgAogASAEa0EHTQ0XIA9BgApqQQggACAEakEIQdTZzgAQ1SwgDykDgAoiJUEAIBUQ4y0hBiAlQQMgFRDjLSEOIAYgE08NAiAXIAZBAnRqIAQ2AgAgJUEBIBUQ4y0iBCATTw0DIBcgBEECdGogCUECazYCACAlQQIgFRDjLSIEIBNPDQQgFyAEQQJ0aiAJQQFrNgIAAkACQAJAIA4gE0kEQCAXIA5BAnRqIgQoAgAhBiAEIAk2AgAgASAGSQ0CIAUhBCAAIAlqIAEgCWsgACAGaiABIAZrEMUUDQEMEAsgDiATQeTczgAQwyEACwNAIAEgBkEFaiIESQ0IIAEgCUEFaiIOSQ0JIAAgBGogASAEayAAIA5qIAEgDmsgIiAJaxCyICEOIAkgBmsiBEHw/w9LBEAgBSEEDBALAkACQAJAAkACQAJAAkAgDkEFaiIQIgVBCk8EQCAFQYYBTwRAIAVBxhBPBEAgES0AJyASMwFOIAsgDCANEN8TQRggBa1CxhB9IAsgDCANEN8TIA8gDygCnAFBAWo2ApwBDAkLIAVBxgBrIg5nQSBqQT9zIgZBHGoiBUGAAU8NAiAFQYABTw0DIAUgEWotAAAgEiAFQQF0ajMBACALIAwgDRDfEyAGIA6tQn8gBq2GfCALIAwgDRDfEyAFQYABSQ0HIAVBgAFB5JrzABDDIQALIAVBBmsiDiAOZ0EgakE/c0EBayIGdiIWIAZBAXRqQRRqIgVBgAFPDQMgBUGAAU8EQCAFQYABQYSb8wAQwyEACyAFIBFqLQAAIBIgBUEBdGozAQAgCyAMIA0Q3xMgBiAOrSAWrSAGrYZ9IAsgDCANEN8TIAVBgAFJDQUgBUGAAUGUm/MAEMMhAAsgBUEOaiIFQYABTw0DIAVBgAFPBEAgBUGAAUG0m/MAEMMhAAsgBSARai0AACASIAVBAXRqMwEAIAsgDCANEN8TIAVBgAFJDQUgBUGAAUHEm/MAEMMhAAsgBUGAAUHEmvMAEMMhAAsgBUGAAUHUmvMAEMMhAAsgBUGAAUH0mvMAEMMhAAsgBUGAAUGkm/MAEMMhAAsgDyAFQQJ0aiIFIAUoAgBBAWo2AgAMAQsgDyAFQQJ0aiIFIAUoAgBBAWo2AgALIAQgESASIA8gCyAMIA0QkxYgCSAQaiIJIBxPDRYgCUECTQ0KIAEgCUEDayIFSQ0LIA9CADcDgAogASAFa0EHTQ0aIA9BgApqQQggACAFakEIQdTZzgAQ1SwgDykDgAoiJUEAIBUQ4y0hBiAlQQMgFRDjLSEOIAYgE08NDCAXIAZBAnRqIAU2AgAgJUEBIBUQ4y0iBSATTw0NIBcgBUECdGogCUECazYCACAlQQIgFRDjLSIFIBNPDQ4gFyAFQQJ0aiAJQQFrNgIAIA4gE08NAiAXIA5BAnRqIgUoAgAhBiAFIAk2AgAgASAGSQ0BIAQhBSAAIAlqIAEgCWsgACAGaiABIAZrEMUUDQALDA4LIAYgAUH03M4AEK87AAsgDiATQfTdzgAQwyEAC0H0284AQR9BlNzOABCfKQALIAQgAUGk3M4AEK87AAsgBiATQbTczgAQwyEACyAEIBNBxNzOABDDIQALIAQgE0HU3M4AEMMhAAsgBCABQYTdzgAQrzsACyAOIAFBlN3OABCvOwALQfTbzgBBH0Gk3c4AEJ8pAAsgBSABQbTdzgAQrzsACyAGIBNBxN3OABDDIQALIAUgE0HU3c4AEMMhAAsgBSATQeTdzgAQwyEACyAJQQFqIQYgASAJSwRAIAAgBmogASAGayAVEOccIQUgCUECaiIQIBxNDQMMBwsgBiABQYTezgAQrzsACyAgQQV2ICBBAWohICAWIQUgDiIGaiIQIBxNDQALCwwDCyAGIAFBtNrOABCvOwALQYCABCAUIAdrIhQgFEGAgARPGyEFIAcgCmohCgJAAkACQAJAAkACQAJAIBRFDQAgBSAIaiIGQYGAwABPDQAgASAKSQ0EAn8gACAKaiEWIAEgCmshECAPQYAEaiEOQQAhBCMAQYAIayIHJAAgB0EAQYAI/AsAAkACfQJAIAVFDQADQCAEIBBPDQMgByAEIBZqLQAAQQJ0aiIZIBkoAgBBAWo2AgAgBEEraiIEIAVJDQALIAVBKmoiEEErbiEEIBBBgNYASQ0AIASzIiYQ6hIMAQsgBLMhJiAEQQJ0QcCH8wBqKgIACyEnICYgJ0MAAAA/kpRDAABIQ5IhJkEAIQQDQCAOLQAAsyEoIAQgB2ooAgAiELMhJyAOQQFqIQ4gJgJ9IBBBgAJPBEAgJxDqEgwBCyAQQQJ0QcCH8wBqKgIACyAokiAnlJMhJiAEQQRqIgRBgAhHDQALIAdBgAhqJAAgJkMAAAAAYAwBCyAEIBBB5JvzABDDIQALDQELQQIhGSAFIQcgCSAeIgRPDQkgBCAJayIFQcIwSQ0BIAkgGGsgBSAfEPM0RQ0CIAAgGGogASAYayAEIBhrIBtBA2sgCyAMIA0QsBkMCQsgBkEBayEOIBshBEEUIQcCQAJAA0AgBEEDdiIIIA1PDQEgCCAMaiIIIAgtAABBf0EIIARBB3EiEGsiCCAHIAcgCEsbIgggEGp0QX8gEHRBf3NycSAOQX8gCHRBf3NxIBB0cjoAACAEIAhqIQQgDiAIdiEOIAcgCGsiBw0ACwwBCyAIIA1B9JvzABDDIQALQQEhGSAGIQggBSEHDAYLIAUgESASIA8gCyAMIA0QmgogASAJSQ0CIAAgCWogASAJayAFIA9BgARqIA9BgAZqIAsgDCANEMccDAcLIAUgESASIA8gCyAMIA0QyxQgASAJSQ0CIAAgCWogASAJayAFIA9BgARqIA9BgAZqIAsgDCANEMccDAYLIAogAUGE2s4AEK87AAsgCSABQaTazgAQrzsACyAJIAFBlNrOABCvOwALAkAgFEUEQCADRQ0BDAULIAsoAgBBgIAGIBQgFEGAgAZPGyIIQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAEgCkkNAiAAIApqIAEgCmsgCCAPQYAEaiAPQYAGaiALIAwgDRD1CyEfIA8gESASIAsgDCANEOIHQQNqIRtBASEZIAghByAKIRgMAQsgIUEANgIAIBpBADoAACAPIBEgEiAhIBpBgAQQ4gcMAwsgCSEEDAELCyAKIAFB9NnOABCvOwALIA9BoApqJAAMAQsgD0EANgKYCiAPQQE2AowKIA9BmNfOADYCiAogD0IENwKQCiAPQYgKakHE2c4AEO8sAAsgCygCAAsgHWtJBEAgACABIAIgHSALIAwgDRCwGQsgA0UNAQtBAUIBIAsgDCANEN8TQQFCASALIAwgDRDfEyALIAsoAgBBB2pBeHE2AgALC7oBAQN/IAJFBEBBAQ8LAkAgAyAAKAIAIgUgAUdyRQRAIAAoAgwhAyAAKAIQIQYgACgCCCEEQQEhBQwBCyAAIAAoAgwiBjYCECAAIAAoAgQiBDYCCCAAIAUgBGsiAzYCDCAAIAEgA2s2AgRBACEFIAMgBmtBB0sNACAAIAM2AhAgAyEGCyAAIAEgAmoiAjYCACACIAQgBmpNIAEgAyAEak9yRQRAIAAgAiAEayIAIAMgACADSBs2AhALIAUL7wEBAn8jAEEQayICJAAgAEEEaiEDAn8CQAJAAkACQCAAKAIAQQFrDgMBAgMACyACIAM2AgQgAUH0rf4AQQ5Bgq7+AEEEIABBEGpB1K3+AEGQqv4AQQcgAkEEakHkrf4AEI4YDAMLIAIgAzYCCCABQdiu/gBBDUGCrv4AQQQgAEEQakHIrv4AQZCq/gBBByACQQhqQeSt/gAQjhgMAgsgAiADNgIMIAFBpK/+AEEQQYKu/gBBBCAAQRBqQZSv/gBBkKr+AEEHIAJBDGpB5K3+ABCOGAwBCyAAKAIEIAEgACgCCCgCDBECAAsgAkEQaiQAC8EBAgR/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBuMmEASgCACICNgIAIAFBsMmEASkCACIFNwMIIAAtAAAhAyAALQABIAFBCGoiBBC/DEUgA0ENRnFFBEAgAUEoaiACNgIAIAEgBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgBEHwyIQBEO8sAAsgAUFAayQAC+kHARd/IwBBMGsiBCQAIAQgASgCKDYCDCAEIAEoAiQ2AhAgBCABEO88IAQoAgQhAiAEIAQoAgAiAzYCICAEIAMgAkHEAGxqNgIkIAQgBEEQajYCLCAEIARBDGo2AigjAEEgayIFJAAgBUEUaiAEQSBqIgIoAgQgAigCAGtBxABuQQBBBEEIEKAYIAUoAhghAyAFKAIUQQFGBEAgAyAFKAIcQdDqhQEQ/S8ACyAEQRRqIQ0gBUEQaiIVQQA2AgAgBSAFKAIcNgIMIAUgAzYCCCMAQSBrIgYkACACKAIEIAIoAgBrQcQAbiIHIAVBCGoiAygCACADKAIIIghrSwRAIAMgCCAHQQRBCBDeKCADKAIIIQgLIAMoAgQhByAGQQhqIAJBCGopAgA3AwAgBiACKQIANwMAIAYgBzYCHCAGIAg2AhggBiADQQhqNgIUIwBBgAFrIgIkACAGQRRqIgcoAgQhCCAHKAIAIRYCQAJAIAYoAgAiAyAGKAIEIglHBEAgBigCDCEXIAYoAgghGCAHKAIIIAhBA3RqIQcgCSADa0HEAG4hEiACQSRqIRMgAkEwaiEUA0AgFygCACEJAn8CQCAYKAIAIgoNACAJIANBJGooAgBHDQAgAkHcAGogA0EYahDRBiADQShqKAIAIQwgAkHoAGogAxC+FSACQfQAaiADQQxqEIALIANBLGooAgAiCgRAIAogCigCACILQQFqNgIAIAtBAEgNBSADQTxqKAIAIQ4gA0E4aigCACEPIANBNGooAgAhECADQTBqKAIAIREgA0FAaygCACELCyAUIAIpAlw3AgAgEyACKQJ0NwIAIBRBCGogAkHkAGooAgA2AgAgAkEgaiACQfAAaigCADYCACATQQhqIAJB/ABqKAIANgIAIAIgDDYCQCACIAk2AjwgAiACKQJoNwMYIAIgCzYCWCACIA42AlQgAiAPNgJQIAIgEDYCTCACIBE2AkggAiAKNgJEIAJBCGogAkEYahCgASACKAIIIQkgAigCDAwBCyACQRhqIgwgAyAKIAkQ1gggAkEQaiAMEKABIAIoAhAhCSACKAIUCyEKIAcgCTYCACAHQQRqIAo2AgAgA0HEAGohAyAHQQhqIQcgCEEBaiEIIBJBAWsiEg0ACwsgFiAINgIAIAJBgAFqJAAMAQsACyAGQSBqJAAgDUEIaiAVKAIANgIAIA0gBSkCCDcCACAFQSBqJAAgASgCJCECIABBDGogAUEYahDWBiAAQRxqIAFBLGpBACABKAIsGxDuJSAAIAI2AhggACAEKQIUNwIAIABBCGogBEEcaigCADYCACABEIonIARBMGokAAvEAQEEfyAAIAAoAlggAWoiAjYCWCAAKAI4BEACQCACQQN2IAJBB3FBAEdqIgIgACgCRCIDTQ0AIAIgA2shBCAAKAI8IAJJBEAgAhDcKiEDIABBOGogACgCPEEBdCIFIAMgAyAFSRsQ6BkgACgCRCEDCyAERQ0AIAAoAkAgA2pBACAE/AsACyAAIAI2AkQgACAAKAJUIAFqNgJUIAAoAsQBIABBDGogASAAKALIASgCFBEBAA8LQcyPhwFBHUHsj4cBEMskAAu6AQEEfyMAQRBrIgIkACABKAJMIARqIgVBA3YgBUEHcUEAR2oiBSABKAIMIgZLBEAgBSAGayEIIAEoAgQiByAFSQRAIAEgB0EBdCIGIAUQ3ioiByAGIAdLGxDoGSABKAIMIQYLIAgEQCABKAIIIAZqQQAgCPwLAAsgASAFNgIMCyACQQhqIAEQhj0gAigCCCACKAIMIAAoAgAgACgCBCABKAJMIAAoAggoAiggA2ogBBCECRogAkEQaiQAC9MBAQF/IwBBEGsiDyQAIAAoAgAgASACIAAoAgQoAgwRBgAhASAPQQA6AA0gDyABOgAMIA8gADYCCCAPQQhqIAMgBCAFIAYQiBIgByAIIAkgChCIEiALIAwgDSAOEIgSIQEgDy0ADSICIA8tAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIA9BEGokACAAQQFxC5gEAQh/IwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiABQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEFIwBBMGsiASQAIAFBCGogAkEgaiIDEL4gAkACQAJAIAEoAghBAXEEQCABKAIMIQYgAUEgaiIIQQRBAEEEQQQQoBggASgCJCEEIAEoAiBBAUYNAiABKAIoIgcgBjYCACABQRxqIglBATYCACABIAc2AhggASAENgIUIAFBKGogA0EIaikCADcDACABIAMpAgA3AyAjAEEQayIDJAAgA0EIaiAIEL4gIAMoAghBAXEEQCABQRRqIQQgAygCDCEHA0AgBCgCCCIGIAQoAgBGBEAgBCAGQQFBBEEEENAoCyAEKAIEIAZBAnRqIAc2AgAgBCAGQQFqNgIIIAMgCBC+ICADKAIEIQcgAygCAEEBcQ0ACwsgA0EQaiQAIAVBCGogCSgCADYCACAFIAEpAhQ3AgAMAQsgBUEANgIIIAVCgICAgMAANwIACyABQTBqJAAMAQsgBCABKAIoQbiBwwAQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgACACKQIANwIAIABBEGogAkEQaigCADYCACAAQQhqIAJBCGopAgA3AgAgBRD4JSAFQQRBBBDgHgwBCyAAIAIpAhQ3AgQgAEGTgICAeDYCACAAQQxqIAJBHGooAgA2AgALIAJBMGokAAuYBAEIfyMAQTBrIgIkACACQZOAgIB4NgIAIAJBKGogAUEIaigCADYCACACIAEpAgA3AyAgAiACNgIsIAJBFGohBSMAQTBrIgEkACABQQhqIAJBIGoiAxC/IAJAAkACQCABKAIIQQFxBEAgASgCDCEGIAFBIGoiCEEEQQBBBEEEEKAYIAEoAiQhBCABKAIgQQFGDQIgASgCKCIHIAY2AgAgAUEcaiIJQQE2AgAgASAHNgIYIAEgBDYCFCABQShqIANBCGopAgA3AwAgASADKQIANwMgIwBBEGsiAyQAIANBCGogCBC/ICADKAIIQQFxBEAgAUEUaiEEIAMoAgwhBwNAIAQoAggiBiAEKAIARgRAIAQgBkEBQQRBBBDQKAsgBCgCBCAGQQJ0aiAHNgIAIAQgBkEBajYCCCADIAgQvyAgAygCBCEHIAMoAgBBAXENAAsLIANBEGokACAFQQhqIAkoAgA2AgAgBSABKQIUNwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAUEwaiQADAELIAQgASgCKEG4gcMAEP0vAAsCQCACKAIAQZOAgIB4RwRAIAAgAikCADcCACAAQRBqIAJBEGooAgA2AgAgAEEIaiACQQhqKQIANwIAIAUQ+CUgBUEEQQQQ4B4MAQsgACACKQIUNwIEIABBk4CAgHg2AgAgAEEMaiACQRxqKAIANgIACyACQTBqJAALvgICBn8BbyMAQSBrIgEkACABEKY7IgM2AgwgAUGg7MMAQRgQkz42AhggAUEQaiEEIwBBEGsiAiQAIAFBDGooAgAlASABQRhqKAIAJQEQYyEGIAJBCGoQzi1BASEFAkAgAigCCEEBcQRAIAQgAigCDDYCBAwBC0EAIQUgBCAGQQBHOgABCyAEIAU6AAAgAkEQaiQAAkACQCABLQAQIgJBAUYNACABLQARQQFHDQAgASADNgIcIAFBHGooAgAlASAAKAIAJQEQECEHEN8SIgAgByYBIANBhAFJDQEgAxDyHwwBCyAAKAIAJQEQBSEHEN8SIgAgByYBIAEoAgwiA0GEAUkNACADEPIfCwJAIAJFDQAgASgCFCICQYQBSQ0AIAIQ8h8LIAEoAhgiAkGEAU8EQCACEPIfCyABQSBqJAAgAAu4AQEEfyMAQRBrIgEkACABIAApAgA3AgggAUEIahDuEiECIAFBCGoQ7hIhACABQQhqEO4SIQQCQCACQYCAxABGIABBgIDEAEZyDQAgAkHf//8AcUHBAGshAiAEQYCAxABHBEAgAEH8AEcgAEE6R3EgAkEaT3INASAEQSNrIgBBOk8NAUKBoICAgYCAgAIgAK2IpyEDDAELIAJBGUsNACAAQTpGIABB/ABGciEDCyABQRBqJAAgA0EBcQusBAEMfyMAQTBrIgUkAAJAAkAgACgCAEGAgICAeEcEQCABKAIAQYCAgIB4Rw0BCyAAEIYwIABBgICAgHg2AgAMAQsgAEEIaiIKKAIAIQIgACgCBCEDIAEoAgghBCABKAIEIQEgBUEANgIoIAUgASAEajYCJCAFIAE2AiAgBSACIANqNgIcIAUgAzYCGCAFIAQgAiACIARLGzYCLCMAQSBrIgIkACACQRRqIAVBGGoiASgCFCABKAIQa0EAQQFBARCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHApc4AEP0vAAsgBUEMaiEJIAJBEGoiC0EANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgASgCFCABKAIQayIGIAJBCGoiAygCACADKAIIIgdrSwRAIAMgByAGQQFBARDQKCADKAIIIQcLIAQgAygCBDYCDCAEIAc2AgggBCADQQhqNgIEIARBBGoiBigCBCEDIAYoAgAgASgCFCIIIAEoAhAiB0cEQCAIIAdrIQggBigCCCENIAEoAgAgB2ohBiABKAIIIAdqIQEDQCADIA1qIAYtAAAgAS0AAHJBAXE6AAAgBkEBaiEGIAFBAWohASADQQFqIQMgCEEBayIIDQALCyADNgIAIARBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIAIAJBIGokACAAEIYwIAogBUEUaigCADYCACAAIAUpAgw3AgALIAVBMGokAAvOAQEDfyMAQTBrIgMkACADIAI2AgwCQCACQQBOBEAgA0EQaiABIAJsQQBBAUEBEKAYIAMoAhQhBCADKAIQQQFGDQEgAygCGCEFIAAgAjYCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAU2AgQgACAENgIAIANBMGokAA8LIANBAjYCFCADQdTFhQE2AhAgA0IBNwIcIANBnAM2AiwgAyADQShqNgIYIAMgA0EMajYCKCADQRBqQeTFhQEQ7ywACyAEIAMoAhhB9MWFARD9LwAL7QEAIABBwOkBaiABIAIgACgC7OoBEOcJIgFBiH9NBH8gAQRAQbh/DwsCQCAAKAKs6wFBAUcNACAAKAKo6wFFDQAgABDFHAsCQCAAKALc6QEiAUUNACAAKAKc6wEgAUYNAEFgDwsCQCAAKALg6QEEQCAAIAAoAvDqASIBRTYC9OoBIAENASAAQZDqAWpBAEHYAPwLACAAQvnq0NDnyaHk4QA3A7DqASAAQs/W077Sx6vZQjcDoOoBIABC1uuC7ur9ifXgADcDmOoBDAELIABBADYC9OoBCyAAIAApA/DpASACrXw3A/DpAUEABSABCwvDAQEBfyMAQRBrIgUkACAFQgA3AwAgBUEANgIIIAVBADYCDEEBIACtIAIgAyAEEOUSAkAgAARAQQFCACACIAMgBBDlEiABIAUgBUEIaiAFQQxqEL0ZQQIgBTUCDCACIAMgBBDlEiAFKAIIIAUpAwAgAiADIAQQ5RIMAQsgASAFIAVBCGogBUEMahC9GUECIAU1AgwgAiADIAQQ5RIgBSgCCCAFKQMAIAIgAyAEEOUSQQFCACACIAMgBBDlEgsgBUEQaiQAC84BAQJ/IwBBQGoiAyQAQQEhBAJAIAEoAgBBAXEEQCAAIAEpAyg3AyggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxBBACEEDAELIANBATYCJCADQdScgAE2AiAgA0IBNwIsIANBzAE2AjwgAyACNgI4IAMgA0E4ajYCKCADQRBqIANBIGoQmQ4gA0GNgICAeDYCDCAAIAMpAgw3AgQgAEEMaiADQRRqKQIANwIAIABBFGogA0EcaigCADYCAAsgACAENgIAIANBQGskAAvDAQEHfyMAQRBrIgIkACACQQRqIAEQ0wYgASgCDCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIgIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIcIQQgASgCGCEGIAEoAhQhByABKAIQIQggACACKQIENwIAIAAgAzYCICAAIAQ2AhwgACAGNgIYIAAgBzYCFCAAIAg2AhAgACAFNgIMIAAgASgCJDYCJCAAQQhqIAJBDGooAgA2AgAgAkEQaiQADwsAC+QBAgJ/An4jAEEQayICJAAgAiABQQBBBEEEEKAYIAIoAgQhASACKAIAQQFHBEAgAigCCCEDAn5B+POKASgCAEEBRgRAQYj0igEpAwAhBEGA9IoBKQMADAELIAIQ4yZB+POKAUIBNwMAQYj0igEgAikDCCIENwMAIAIpAwALIQUgAEEANgIoIAAgAzYCJCAAIAE2AiAgACAENwMYIAAgBTcDEEGA9IoBIAVCAXw3AwAgAEHo3IcBKQMANwMAIABBCGpB8NyHASkDADcDACACQRBqJAAPCyABIAIoAghBiN2HARD9LwALkAEBBH8gASgCSCIDIQQgA0ESTwRAIAEoAgQhBAsgAiAETQRAIAFBBGoiBSABQcgAaiIGIANBEk8bQQA2AgAgBigCAEERTQR/IAUFIAEoAggLIQMgACACNgIMIAAgATYCCCAAIAQgAms2AhAgACADIAJBAnRqNgIEIAAgAzYCAA8LQdCvzABBHEHsr8wAEJ8pAAu/AQECfyAAEOk7IABByABqEJ0MIAAoAjgEQCAAQThqEM8vCyAAQQxqEM8vIABBHGoQzy8gAEEsaiIBEIoUIAEQ9DwgACgCgAFBgICAgHhHBEAgAEGAAWoQ9yYLIABB3ABqIgEQxScgARDoOyAAQegAaiIBEIEjIAEQ6jsgAEH0AGoiARCBIyABEOo7IAAoAsQBIQEgACgCyAEiACgCACICBEAgASACEQMACyAAKAIEIgIEQCABIAIgACgCCBD4OgsLvwEBAn8gABDpOyAAQcgAahCfDCAAKAI4BEAgAEE4ahDPLwsgAEEMahDPLyAAQRxqEM8vIABBLGoiARCKFCABEPQ8IAAoAoABQYCAgIB4RwRAIABBgAFqEPomCyAAQdwAaiIBEMUnIAEQ6DsgAEHoAGoiARCBIyABEOo7IABB9ABqIgEQgSMgARDqOyAAKALEASEBIAAoAsgBIgAoAgAiAgRAIAEgAhEDAAsgACgCBCICBEAgASACIAAoAggQ+DoLC6kBAgF+An8gA0EEaiEFIAFBgYKECGwhAQNAIAAgBWpBCGsoAAAgAXMiBkGAgYKEeHJBgYKECGsgBnJBgIGChHhxQYGBgQFsQRx2rSAEQgSGhCEEIAVBBGsiBUEHSw0ACyAEQn+FIQQCQCADQSBHBEAgA0EQRw0BIASnIgBB//8DcSACQQ9xdiAAQQAgAmtBD3F0cq1C//8Dgw8LIASnIAJ4rQ8LIAQgAq2KC8kBAQJ/IAAoAoTqASIFQQdGIQYCQCAAAn8CQCAAKALk6wFFBEACfyAFQQdGBEAgACgC0OsBIQFBAAwBCyAAKALM6wEgACgC0OsBIgFrCyECIAAgACgCyOsBIAFqIAIgAyAEENsHIgRBiH9LDQMgBCAGckUNASAAIAAoAtDrASAEajYC1OsBQQQMAgsgACABKAIAIgVBACACIAVrIAYbIAMgBBDbByIEQYh/Sw0CIAEgASgCACAEajYCAAtBAgs2ArTrAUEAIQQLIAQLkAUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ9A0CQAJAAkAgAi0ACEEBcQRAIAItAAkhCiAFIAYQoSogBUEIIAIoAhhBAWoiAUF/IAEbIgEgAUEITRtBAEEBQQEQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjoAACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEPQNIAQtABBBAXEEQCACQQxqIQkgBC0AESEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQgS4LIAkoAgQgBmogCDoAACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBD0DSAELQAJIQggBC0ACEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAQNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ3jsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQviQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQviQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQviQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBCtDQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQrQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkEK0NIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQsyQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQsyQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQsyQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDnDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ5w0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOcNIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDtIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDtIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDtIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDqDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC9KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6g0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxCBLgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOoNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQtg0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkELYNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQhS4LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBC2DSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOoiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL4pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOoiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL4pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOoiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQvCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC/KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQvCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEL8pIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQvCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuQBQIIfwF9IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEKwNAkACQAJAIAIoAgBBAXEEQCACKgIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhByACKAIYQQFGDQIgAigCICIBIAo4AgAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBzYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBCsDSAEKAIIQQFxBEAgAkEMaiEHIAQqAgwhCgNAIAcoAggiBiAHKAIARgRAIARBFGogBRC9KSAHIAQoAhRBAWoiAUF/IAEbEO4tCyAHKAIEIAZBAnRqIAo4AgAgByAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQrA0gBCoCBCEKIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgByACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgCBDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC9JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFEL8pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC9JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC9JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEKgNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL4pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBCoDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQqA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQrw0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQoSogBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEK8NIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCvDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDiDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhC+KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ4g0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOINIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQqg0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvSkgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEKoNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL0pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCqDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELskAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELskIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELskIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQpw0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEKcNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCnDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEKkkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEKkkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEKkkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC3JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC3JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC3JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC8oFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQkjAEHgAGsiAiQAIAJBGGogBRDjGwJAAkACQCACKQMYQgJSBEAgAkE0aiIGIAUQwSkgBkEEIAIoAjRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRgQoBggAigCOCEBIAIoAjRBAUYNAiACKAI8IgggAikDGDcDACAIQRBqIAJBKGopAwA3AwAgCEEIaiACQSBqKQMANwMAIAJBFGoiCkEBNgIAIAIgCDYCECACIAE2AgwgBiAFQSz8CgAAIwBBMGsiBCQAIARBCGogBhDjGyAEKQMIQgJSBEAgAkEMaiEHA0ACQCAHKAIIIgggBygCAEcNACAEQSRqIAYQwSkgBCgCJEEBaiIBQX8gARsiBSAHKAIAIAcoAggiAWtNDQAgByABIAVBCEEYEN4oCyAHKAIEIAhBGGxqIgEgBCkDCDcDACABQRBqIARBGGopAwA3AwAgAUEIaiAEQRBqKQMANwMAIAcgCEEBajYCCCAEQQhqIAYQ4xsgBCkDCEICUg0ACwsCQCAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIARBMGokACAJQQhqIAooAgA2AgAgCSACKQIMNwIADAELIAlBADYCCCAJQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB4ABqJAAMAQsgASACKAI8Qbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCRD1OwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfCMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDoIgJAAkACQCACKAIYQQFGBEAgAisDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKOQMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDoIiAGKAIAQQFGBEAgAkEMaiEFA0AgBisDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo5AwAgBSAEQQFqNgIIIAYgBxDoIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBC1DQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhC9KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQtQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkELUNIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMQNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDEDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRCoJAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELwpIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxCoJCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvCkgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxCoJCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC5MFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAkEIaiAGIAJBGGoiBSAGKAIkEOENAkACQAJAIAIvAQhBAXEEQCACLwEKIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBAkECEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo7AQAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEQaiAFIARBFGogBSgCJBDhDSAELwEQQQFxBEAgAkEMaiEJIAQvARIhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEO0tCyAJKAIEIAZBAXRqIAg7AQAgCSAGQQFqNgIIIARBCGogBSAEQRRqIAUoAiQQ4Q0gBC8BCiEIIAQvAQhBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAIDcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEJ08DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOQiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOQiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOQiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELsNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC7DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQuw0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDhIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDhIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDhIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEO8iAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEO8iIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEO8iIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC8kFAQt/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBiABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEFAaiICJAAgAiAGIAJBFGoiBSAGKAIoELYSAkACQAJAIAIoAgAiCkF+cUECRwRAIAIoAgQhCyAFIAYQvykgBUEEIAIoAhRBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQgQoBggAigCGCEJIAIoAhRBAUYNAiACKAIcIgEgCzYCBCABIAo2AgAgAkEQaiILQQE2AgAgAiABNgIMIAIgCTYCCCAFIAZBLPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCKBC2EiAEKAIIIgxBfnFBAkcEQCACQQhqIQcgBCgCDCEJA0ACQCAHKAIIIgogBygCAEcNACAEQRRqIAUQvykgBCgCFEEBaiIBQX8gARsiBiAHKAIAIAcoAggiAWtNDQAgByABIAZBBEEIEN4oCyAHKAIEIApBA3RqIgEgCTYCBCABIAw2AgAgByAKQQFqNgIIIAQgBSAEQRRqIAUoAigQthIgBCgCBCEJIAQoAgAiDEF+cUECRw0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAIQQhqIAsoAgA2AgAgCCACKQIINwIADAELIAhBADYCCCAIQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAJIAIoAhxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEOo7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvJBQELfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgYgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBBQGoiAiQAIAIgBiACQRRqIgUgBigCKBC3EgJAAkACQCACKAIAIgpBfnFBAkcEQCACKAIEIQsgBSAGELspIAVBBCACKAIUQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEIEKAYIAIoAhghCSACKAIUQQFGDQIgAigCHCIBIAs2AgQgASAKNgIAIAJBEGoiC0EBNgIAIAIgATYCDCACIAk2AgggBSAGQSz8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAigQtxIgBCgCCCIMQX5xQQJHBEAgAkEIaiEHIAQoAgwhCQNAAkAgBygCCCIKIAcoAgBHDQAgBEEUaiAFELspIAQoAhRBAWoiAUF/IAEbIgYgBygCACAHKAIIIgFrTQ0AIAcgASAGQQRBCBDeKAsgBygCBCAKQQN0aiIBIAk2AgQgASAMNgIAIAcgCkEBajYCCCAEIAUgBEEUaiAFKAIoELcSIAQoAgQhCSAEKAIAIgxBfnFBAkcNAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiALKAIANgIAIAggAikCCDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCSACKAIcQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDqOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC5JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC5JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC5JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQryQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQryQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQryQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELgkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELgkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELgkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC6JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC6JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC6JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQwCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQwCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQwCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEL8kAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEL8kIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEL8kIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALkwUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ6A0CQAJAAkAgAi8BCEEBcQRAIAIvAQohCiAFIAYQoSogBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEECQQIQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjsBACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEOgNIAQvARBBAXEEQCACQQxqIQkgBC8BEiEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQ7S0LIAkoAgQgBkEBdGogCDsBACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBDoDSAELwEKIQggBC8BCEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAgNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQnTwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC5AFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAkEIaiAGIAJBGGoiBSAGKAIkEOwNAkACQAJAIAItAAhBAXEEQCACLQAJIQogBSAGEL4pIAVBCCACKAIYQQFqIgFBfyABGyIBIAFBCE0bQQBBAUEBEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo6AAAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEQaiAFIARBFGogBSgCJBDsDSAELQAQQQFxBEAgAkEMaiEJIAQtABEhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEIEuCyAJKAIEIAZqIAg6AAAgCSAGQQFqNgIIIARBCGogBSAEQRRqIAUoAiQQ7A0gBC0ACSEIIAQtAAhBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAEDcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEN47DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOUiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOUiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOUiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQwSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC/KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQwSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEL8pIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQwSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELEkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELEkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELEkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDjIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDjIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDjIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDzDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhChKiAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ8w0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEPMNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDmIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDmIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDmIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEPEiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEPEiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEPEiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMUNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDFDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxQ0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALkwUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ4w0CQAJAAkAgAi8BCEEBcQRAIAIvAQohCiAFIAYQvSkgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEECQQIQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjsBACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEOMNIAQvARBBAXEEQCACQQxqIQkgBC8BEiEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL0pIAkgBCgCFEEBaiIBQX8gARsQ7S0LIAkoAgQgBkEBdGogCDsBACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBDjDSAELwEKIQggBC8BCEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAgNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQnTwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMYNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDGDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEIUuCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxg0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDgIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDgIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDgIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELQkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELQkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELQkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQuQ0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkELkNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBC5DSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDrDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC9KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6w0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOsNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRCuJAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFEL8pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxCuJCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxCuJCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQtSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQtSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQtSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDgDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhC+KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ4A0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOANIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDpIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDpIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDpIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEMMkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEMMkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEMMkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALygUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCSMAQeAAayICJAAgAkEYaiAFEOUbAkACQAJAIAIpAxhCAlIEQCACQTRqIgYgBRCiKiAGQQQgAigCNEEBaiIBQX8gARsiASABQQRNG0EAQQhBGBCgGCACKAI4IQEgAigCNEEBRg0CIAIoAjwiCCACKQMYNwMAIAhBEGogAkEoaikDADcDACAIQQhqIAJBIGopAwA3AwAgAkEUaiIKQQE2AgAgAiAINgIQIAIgATYCDCAGIAVBLPwKAAAjAEEwayIEJAAgBEEIaiAGEOUbIAQpAwhCAlIEQCACQQxqIQcDQAJAIAcoAggiCCAHKAIARw0AIARBJGogBhCiKiAEKAIkQQFqIgFBfyABGyIFIAcoAgAgBygCCCIBa00NACAHIAEgBUEIQRgQ3igLIAcoAgQgCEEYbGoiASAEKQMINwMAIAFBEGogBEEYaikDADcDACABQQhqIARBEGopAwA3AwAgByAIQQFqNgIIIARBCGogBhDlGyAEKQMIQgJSDQALCwJAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgBEEwaiQAIAlBCGogCigCADYCACAJIAIpAgw3AgAMAQsgCUEANgIIIAlCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHgAGokAAwBCyABIAIoAjxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAJEPU7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvJBQELfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgYgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBBQGoiAiQAIAIgBiACQRRqIgUgBigCKBC+EgJAAkACQCACKAIAIgpBfnFBAkcEQCACKAIEIQsgBSAGEKIqIAVBBCACKAIUQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEIEKAYIAIoAhghCSACKAIUQQFGDQIgAigCHCIBIAs2AgQgASAKNgIAIAJBEGoiC0EBNgIAIAIgATYCDCACIAk2AgggBSAGQSz8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAigQvhIgBCgCCCIMQX5xQQJHBEAgAkEIaiEHIAQoAgwhCQNAAkAgBygCCCIKIAcoAgBHDQAgBEEUaiAFEKIqIAQoAhRBAWoiAUF/IAEbIgYgBygCACAHKAIIIgFrTQ0AIAcgASAGQQRBCBDeKAsgBygCBCAKQQN0aiIBIAk2AgQgASAMNgIAIAcgCkEBajYCCCAEIAUgBEEUaiAFKAIoEL4SIAQoAgQhCSAEKAIAIgxBfnFBAkcNAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiALKAIANgIAIAggAikCCDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCSACKAIcQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDqOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALqgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiAFELElAkACQAJAIAIoAhhBAkcEQCACQSRqIgYgBRC/KSAGQQQgAigCJEEBaiIBQX8gARsiASABQQRNG0EAQQRBDBCgGCACKAIoIQkgAigCJEEBRg0CIAIoAiwiASACKQIYNwIAIAFBCGogAkEgaigCADYCACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAYgBUEs/AoAACMAQSBrIgQkACAEQQhqIAYQsSUgBCgCCEECRwRAIAJBDGohBwNAAkAgBygCCCIJIAcoAgBHDQAgBEEUaiAGEL8pIAQoAhRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQRBDBDeKAsgBygCBCAJQQxsaiIBIAQpAgg3AgAgAUEIaiAEQRBqKAIANgIAIAcgCUEBajYCCCAEQQhqIAYQsSUgBCgCCEECRw0ACwsCQCAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgIDAADcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAIsQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDoOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDrIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDrIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDrIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF8IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOwiAkACQAJAIAIoAhhBAUYEQCACKwMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo5AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOwiIAYoAgBBAUYEQCACQQxqIQUDQCAGKwMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjkDACAFIARBAWo2AgggBiAHEOwiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELoNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC6DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEIUuCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQug0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALkAUCCH8BfSMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBC3DQJAAkACQCACKAIAQQFxBEAgAioCBCEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQcgAigCGEEBRg0CIAIoAiAiASAKOAIAIAJBFGoiCUEBNgIAIAIgATYCECACIAc2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQtw0gBCgCCEEBcQRAIAJBDGohByAEKgIMIQoDQCAHKAIIIgYgBygCAEYEQCAEQRRqIAUQoSogByAEKAIUQQFqIgFBfyABGxDuLQsgBygCBCAGQQJ0aiAKOAIAIAcgBkEBajYCCCAEIAUgBEEUaiAFKAIkELcNIAQqAgQhCiAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAcgAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC5AFAgh/AX0jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohCCMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQrg0CQAJAAkAgAigCAEEBcQRAIAIqAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEHIAIoAhhBAUYNAiACKAIgIgEgCjgCACACQRRqIglBATYCACACIAE2AhAgAiAHNgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEK4NIAQoAghBAXEEQCACQQxqIQcgBCoCDCEKA0AgBygCCCIGIAcoAgBGBEAgBEEUaiAFEL4pIAcgBCgCFEEBaiIBQX8gARsQ7i0LIAcoAgQgBkECdGogCjgCACAHIAZBAWo2AgggBCAFIARBFGogBSgCJBCuDSAEKgIEIQogBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAIQQhqIAkoAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAHIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuqBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIAUQsCUCQAJAAkAgAigCGEECRwRAIAJBJGoiBiAFELspIAZBBCACKAIkQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEMEKAYIAIoAighCSACKAIkQQFGDQIgAigCLCIBIAIpAhg3AgAgAUEIaiACQSBqKAIANgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgBiAFQSz8CgAAIwBBIGsiBCQAIARBCGogBhCwJSAEKAIIQQJHBEAgAkEMaiEHA0ACQCAHKAIIIgkgBygCAEcNACAEQRRqIAYQuykgBCgCFEEBaiIBQX8gARsiBSAHKAIAIAcoAggiAWtNDQAgByABIAVBBEEMEN4oCyAHKAIEIAlBDGxqIgEgBCkCCDcCACABQQhqIARBEGooAgA2AgAgByAJQQFqNgIIIARBCGogBhCwJSAEKAIIQQJHDQALCwJAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAixBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEOg7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOIiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOIiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOIiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6oFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGogBRCvJQJAAkACQCACKAIYQQJHBEAgAkEkaiIGIAUQoiogBkEEIAIoAiRBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQwQoBggAigCKCEJIAIoAiRBAUYNAiACKAIsIgEgAikCGDcCACABQQhqIAJBIGooAgA2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAGIAVBLPwKAAAjAEEgayIEJAAgBEEIaiAGEK8lIAQoAghBAkcEQCACQQxqIQcDQAJAIAcoAggiCSAHKAIARw0AIARBFGogBhCiKiAEKAIUQQFqIgFBfyABGyIFIAcoAgAgBygCCCIBa00NACAHIAEgBUEEQQwQ3igLIAcoAgQgCUEMbGoiASAEKQIINwIAIAFBCGogBEEQaigCADYCACAHIAlBAWo2AgggBEEIaiAGEK8lIAQoAghBAkcNAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCLEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ6DsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQrSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQrSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQrSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvKBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEJIwBB4ABrIgIkACACQRhqIAUQ5hsCQAJAAkAgAikDGEICUgRAIAJBNGoiBiAFEL8pIAZBBCACKAI0QQFqIgFBfyABGyIBIAFBBE0bQQBBCEEYEKAYIAIoAjghASACKAI0QQFGDQIgAigCPCIIIAIpAxg3AwAgCEEQaiACQShqKQMANwMAIAhBCGogAkEgaikDADcDACACQRRqIgpBATYCACACIAg2AhAgAiABNgIMIAYgBUEs/AoAACMAQTBrIgQkACAEQQhqIAYQ5hsgBCkDCEICUgRAIAJBDGohBwNAAkAgBygCCCIIIAcoAgBHDQAgBEEkaiAGEL8pIAQoAiRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQhBGBDeKAsgBygCBCAIQRhsaiIBIAQpAwg3AwAgAUEQaiAEQRhqKQMANwMAIAFBCGogBEEQaikDADcDACAHIAhBAWo2AgggBEEIaiAGEOYbIAQpAwhCAlINAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQTBqJAAgCUEIaiAKKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQeAAaiQADAELIAEgAigCPEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAkQ9TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELgNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL4pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC4DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQuA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfCMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDwIgJAAkACQCACKAIYQQFGBEAgAisDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKOQMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDwIiAGKAIAQQFGBEAgAkEMaiEFA0AgBisDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo5AwAgBSAEQQFqNgIIIAYgBxDwIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEKskAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEKskIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEKskIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDuIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDuIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDuIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvKBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEJIwBB4ABrIgIkACACQRhqIAUQ5BsCQAJAAkAgAikDGEICUgRAIAJBNGoiBiAFELspIAZBBCACKAI0QQFqIgFBfyABGyIBIAFBBE0bQQBBCEEYEKAYIAIoAjghASACKAI0QQFGDQIgAigCPCIIIAIpAxg3AwAgCEEQaiACQShqKQMANwMAIAhBCGogAkEgaikDADcDACACQRRqIgpBATYCACACIAg2AhAgAiABNgIMIAYgBUEs/AoAACMAQTBrIgQkACAEQQhqIAYQ5BsgBCkDCEICUgRAIAJBDGohBwNAAkAgBygCCCIIIAcoAgBHDQAgBEEkaiAGELspIAQoAiRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQhBGBDeKAsgBygCBCAIQRhsaiIBIAQpAwg3AwAgAUEQaiAEQRhqKQMANwMAIAFBCGogBEEQaikDADcDACAHIAhBAWo2AgggBEEIaiAGEOQbIAQpAwhCAlINAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQTBqJAAgCUEIaiAKKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQeAAaiQADAELIAEgAigCPEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAkQ9TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQrCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQrCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQrCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEMIkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQuykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEMIkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC7KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEMIkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDnIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDnIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDnIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBCpDQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhC9KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQqQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkEKkNIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQqiQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQqiQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQqiQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDpDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC+KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6Q0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOkNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALTgECfyMAQRBrIgIkACACIAFBABD4EQJAAkAgAigCACIBRQRADAELIAAgAikCBDcCCCAAIAE2AgQMAQtBAiEDCyAAIAM2AgAgAkEQaiQAC78BAQJ/IAAQ6TsgAEHIAGoQsgwgACgCOARAIABBOGoQzy8LIABBDGoQzy8gAEEcahDPLyAAQSxqIgEQihQgARD0PCAAKAKAAUGAgICAeEcEQCAAQYABahCBJwsgAEHcAGoiARDFJyABEOg7IABB6ABqIgEQgSMgARDqOyAAQfQAaiIBEIEjIAEQ6jsgACgCxAEhASAAKALIASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAgRAIAEgAiAAKAIIEPg6CwuSBAEOfyMAQaACayICJAAgAkHsAWogAUEUaikCADcCACACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACIAEpAgw3AuQBIAJB6ABqIgwgAkHEAWoiCiABQRxqEMIZIAEoAgQiBCABKAIIQQN0aiEFIwBBIGsiAyQAIANBFGogBSAEa0EDdkEAQQRBxAAQoBggAygCGCEHIAMoAhRBAUYEQCAHIAMoAhxBjM+FARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAc2AggjAEEQayIIJAAgA0EIaiIGIAUgBGtBA3YiBxD+LSAIIAYpAgRCIIk3AgggCCAGQQhqNgIEIwBB0ABrIgskACAIQQRqIgkoAgQhBiAJKAIAIAQgBUcEQCAJKAIIIAZBxABsaiEFIAYgB2ohBgNAIAtBDGoiCSAEKAIAIARBBGooAgAiDygCCEEBa0F4cWpBCGogDygCFBEAACAFIAlBxAD8CgAAIARBCGohBCAFQcQAaiEFIAdBAWsiBw0ACwsgBjYCACALQdAAaiQAIAhBEGokACAKQQhqIA0oAgA2AgAgCiADKQIINwIAIANBIGokACACQQxqIgQgDCAKEPwiIAAgBBDNHCABEMMnIAFBBEEIEOAeIAJBoAJqJAALxwECAn8BfiMAQSBrIgMkACAAKAIARQRAIABBfzYCACADQRhqIABBJGopAgA3AwAgA0EQaiAAQRxqKQIANwMAIAApAhQhBSAAQQA2AhQgAyAFNwMIIANBCGoQqSsCQCAAKAIEQQJGDQAgACgCCCIEQYQBSQ0AIAQQ8h8LIAAgAjYCCCAAIAE2AgQgACgCDCEBIABBADYCDCAAIAAoAgBBAWo2AgAgAQRAIAAoAhAgASgCBBEDAAsgA0EgaiQADwtBjKmIARCbPgALyAEBAX8jAEHQAGsiAiQAAn8CQAJAAkAgAC0AAEEDaw4FAQAAAAIACyACQUBrIABBCGopAwA3AwAgAiAAKQMANwM4IAJBOGogARDDCQwCCyACQQhqIAJBOGogACsDCBCuJSACQccCNgIsIAJBAjYCFCACQfiwiAE2AhAgAkIBNwIcIAIgAikDCDcCMCACIAJBMGo2AiggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEMsKDAELIAFBiLGIAUEEEPs1CyACQdAAaiQAC8IBAgN/AX4jAEEwayICJAAgASgCAEGAgICAeEYEQCABKAIMIQMgAkEUaiIEQQA2AgAgAkKAgICAEDcCDCACQSBqIAMoAgAiA0EIaikCADcDACACQShqIANBEGopAgA3AwAgAiADKQIANwMYIAJBDGpB4KiJASACQRhqEMsKGiACQQhqIAQoAgAiAzYCACACIAIpAgwiBTcDACABQQhqIAM2AgAgASAFNwIACyAAQdy1iQE2AgQgACABNgIAIAJBMGokAAuXAgECfyMAQSBrIgUkAEGQ8IoBQZDwigEoAgAiBkEBajYCAAJAAn9BACAGQQBIDQAaQQFB8POKAS0AAA0AGkHw84oBQQE6AABB7POKAUHs84oBKAIAQQFqNgIAQQILQf8BcSIGQQJHBEAgBkEBcUUNASAFQQhqIAAgASgCGBEAAAwBC0GE8IoBKAIAIgZBAEgNAEGE8IoBIAZBAWo2AgBBhPCKAUGI8IoBKAIABH8gBSAAIAEoAhQRAAAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQYjwigEoAgAgBUEQakGM8IoBKAIAKAIUEQAAQYTwigEoAgBBAWsFIAYLNgIAQfDzigFBADoAACADRQ0AAAsAC7cCAQJ/IwBBsAFrIgMkACABQQhqIQQCfyABKAIAQQFGBEAgA0GkAWogAkEIaigCADYCACADQQA6AKgBIAMgBDYCmAEgAyACKQIANwKcASADQQhqIQEgA0EYaiEEAkBBmAFBCBCtNiICBEAgAiAEQZgB/AoAACABQezdwgA2AgQgASACNgIADAELQQhBmAEQoz0ACyADKAIIIQIgAygCDAwBCyADQaQBaiACQQhqKAIANgIAIANBADoAqAEgAyAENgKYASADIAIpAgA3ApwBIANBEGohASADQRhqIQQCQEGYAUEIEK02IgIEQCACIARBmAH8CgAAIAFBvN3CADYCBCABIAI2AgAMAQtBCEGYARCjPQALIAMoAhAhAiADKAIUCyEBIAAgAjYCACAAIAE2AgQgA0GwAWokAAvVAQEBfwJAAkACQAJAAkAgAC0AnAIOBQAEBAECBAsgABDYFSAAQdgBahCOMCAAQeQBahCGMA8LIABBsAJqEL4oDAELIABBoAJqEL4oIABB7AJqEI4wIABBADoAnQILIAAtAJ4CBEAgAEHIAWoQjjALIABBADoAngIgAEGgAWoiARD3JSABQQRBBBDgHiAAKAKYAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGYAmoQiSkLIABBjAJqEIYwIABB/AFqEIYwIABB0ABqENgVIABBADoAnwILC9UBAQF/AkACQAJAAkACQCAALQDsAg4FAAQEAQIECyAAEI8TIABBqAJqEI4wIABBtAJqEIYwDwsgAEGAA2oQvigMAQsgAEHwAmoQviggAEG8A2oQjjAgAEEAOgDtAgsgAC0A7gIEQCAAQZgCahCOMAsgAEEAOgDuAiAAQfABaiIBEPclIAFBBEEEEOAeIAAoAugCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegCahCJKQsgAEHcAmoQhjAgAEHMAmoQhjAgAEH4AGoQjxMgAEEAOgDvAgsLtwECAn8BfiMAQSBrIgIkAAJAIAEEQCABQQhrIgMoAgBBAUcNASACQRxqIAFBEGooAgA2AgAgAkEUaiABQQhqKQIANwIAIAEpAgAhBCADQQA2AgAgAiAENwIMAkAgA0F/Rg0AIAFBBGsiASABKAIAQQFrIgE2AgAgAQ0AIANBHEEEEPg6CyAAIAIpAhA3AgAgAEEIaiACQRhqKQIANwIAIAJBIGokAA8LEJg9AAtBsMTMAEE/EJc9AAu3AQICfwF+IwBBIGsiAiQAAkAgAQRAIAFBCGsiAygCAEEBRw0BIAJBHGogAUEQaigCADYCACACQRRqIAFBCGopAgA3AgAgASkCACEEIANBADYCACACIAQ3AgwCQCADQX9GDQAgAUEEayIBIAEoAgBBAWsiATYCACABDQAgA0EcQQQQ+DoLIAAgAikCEDcCACAAQQhqIAJBGGopAgA3AgAgAkEgaiQADwsQmD0AC0HU0MwAQT8Qlz0AC78BAQF/IwBB0ABrIgMkACAAAn8gAkELTQRAIAMgAjYCPCADQQI2AiggA0HYjs4ANgIkIANCAjcCMCADQTs2AkwgA0E7NgJEIANBjIrOADYCQCADIANBQGs2AiwgAyADQTxqNgJIIANBCGpBBHIgA0EkahCZDiAAQQxqIANBFGooAgA2AgAgACADKQIMNwIEIAAgAykDGDcDEEEADAELIAAgASgACDYCDCAAIAEpAAA3AgRBCAs2AgAgA0HQAGokAAv7AgEGfyMAQSBrIgQkAAJAAkAgAyABLwEkayIFQQFrQf//A3FBDk8EQCAEIAI6AAwgASgCICAEQQxqIgYgBEENahC9JiMAQTBrIgIkACACQSBqIQggAUEgaiMAQRBrIgUkACAFQQhqQQA7AQAgBUIANwMAIAMgBRC7FCIHQQtPBEAgB0EKQayZzwAQsDsACygCACAFIAcQoTYgCEEEOgAAIAggBzYCBCAFQRBqJAACQAJAIAItACBBBEYNACACIAIpAyA3AyggAkEMaiACQShqENAJIAIoAgxBBEYNACAGIAIpAgw3AgAgBkEQaiACQRxqKAIANgIAIAZBCGogAkEUaikCADcCAAwBCyAGQQQ2AgALIAJBMGokACAEKAIMIgJBBEYNASAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAILIAQgBUEEdCACcjoADCABKAIgIARBDGogBEENahC9JgsgASADOwEkQQQhAgsgACACNgIAIARBIGokAAu0AQEDfyMAQSBrIgIkACACIAAoAggiAzYCACACIAEoAggiBDYCBCADIARGBEAgACgCBCEAIAIgASgCBCIBIANBA3RqNgIMIAIgATYCCCACQQhqEJg2IgQgAyADIARLGyIDBEADQCAAIAApAwAgASkDAHw3AwAgAEEIaiEAIAFBCGohASADQQFrIgMNAAsLIAJBIGokAA8LIAJBADYCCEEAIAIgAkEEaiACQQhqQbD5zwAQrysAC7sBAQF/IwBBQGoiAiQAIAIgATYCCAJAIAEvAQxBAUYEQCABLwEOIQEgAEEENgIAIAAgATsBBAwBCyACQQE2AiQgAkGcpv4ANgIgIAJCATcCLCACQYMBNgI8IAIgAkE4ajYCKCACIAJBCGo2AjggAkEQaiACQSBqEJkOIAJBHGoiAUEAOgAAIAJBATYCDCAAIAIpAgw3AgAgAEEIaiACQRRqKQIANwIAIABBEGogASgCADYCAAsgAkFAayQAC84BAgJ/An4jAEEwayICJAAgAkEQakGwrYYBKAIANgIAIAJBqK2GASkCADcDCAJAAkACQCABIAFCgKMFfyIBQoCjBX59IgRCP4ciBSABfCIBQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAkEANgIsIAIgBUKAowWDIAR8PgIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAvEAwIHfwF+IwBBIGsiAiQAIAEoAgwhAyACIAFBCGo2AhggAiADNgIUIAIgAkEfajYCECACQQRqIQYgAkEQaiEEIwBBIGsiAyQAAkACfwJAIAEoAgAiBSABKAIERwRAIAQoAgghByAEKAIEIQQgASAFQQhqNgIAIAUxAAAhCSADQQxqIAVBBGogBygCABCTAyADKAIMIgFBk4CAgHhGDQEgA0EKaiIFIANBE2otAAA6AAAgAyADLwAROwEIIAMtABAhByADKAIUIQggAykCGCEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAHOgAEIAQgATYCACAEIAMvAQg7AAUgBCAJNwIMIAQgCDYCCCAEQQdqIAUtAAA6AABCACEJQQAMAgsgBkECNgIADAILIAM1AhBCIIYgCYQhCUEBCyEBIAYgCTcCBCAGIAE2AgALIANBIGokAAJAAkAgAigCBEECRgRAIAJBADYCEAwBCyACQRhqIAJBDGooAgA2AgAgAiACKQIEIgk3AxBBASEBIAmnQQFxRQ0AIAAgAigCGDYCCCAAIAItABQ6AAQMAQsgAkEQahC+KkEAIQELIAAgATYCACACQSBqJAALxAMCB38BfiMAQSBrIgIkACABKAIMIQMgAiABQQhqNgIYIAIgAzYCFCACIAJBH2o2AhAgAkEEaiEGIAJBEGohBCMAQSBrIgMkAAJAAn8CQCABKAIAIgUgASgCBEcEQCAEKAIIIQcgBCgCBCEEIAEgBUEIajYCACAFMQAAIQkgA0EMaiAFQQRqIAcoAgAQlAMgAygCDCIBQZOAgIB4Rg0BIANBCmoiBSADQRNqLQAAOgAAIAMgAy8AETsBCCADLQAQIQcgAygCFCEIIAMpAhghCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgBzoABCAEIAE2AgAgBCADLwEIOwAFIAQgCTcCDCAEIAg2AgggBEEHaiAFLQAAOgAAQgAhCUEADAILIAZBAjYCAAwCCyADNQIQQiCGIAmEIQlBAQshASAGIAk3AgQgBiABNgIACyADQSBqJAACQAJAIAIoAgRBAkYEQCACQQA2AhAMAQsgAkEYaiACQQxqKAIANgIAIAIgAikCBCIJNwMQQQEhASAJp0EBcUUNACAAIAIoAhg2AgggACACLQAUOgAEDAELIAJBEGoQvipBACEBCyAAIAE2AgAgAkEgaiQAC5YCAQN/IwBBMGsiASQAIAEgADYCBCABQQA2AhwgAUKAgICAEDcCFCABQajFzAA2AiQgAUKggICADjcCKCABIAFBFGo2AiAjAEEgayIAJAAgAEEUaiICIAFBBGooAgAlARALIABBCGogACgCFCAAKAIYELU2IAAgACgCCCAAKAIMEPooIAIgACgCACAAKAIEEI81IAAoAhggACgCHCABQSBqEKk9IAIQ3jsgAEEgaiQARQRAIAFBEGogAUEcaigCACIANgIAIAEgASkCFDcDCCABKAIMIAAQlD4gAUEIahDeOyABKAIEIgJBhAFPBEAgAhDyHwsgAUEwaiQADwtB0MXMAEE3IAFBCGpBwMXMAEGIxswAENUeAAu7AQEFfyMAQSBrIgIkAAJAIAEoAkwiAwRAIAFBxABqIQUDQCABKAIwIgRFDQIgBCABKAJIIgQgAyAEahC9JiACIAMgASgCTCIEEMotIAIoAgQhAyABIAIoAgAiBjYCTCACIAU2AhQgAiADNgIYIAIgBCADazYCHCACIAMgASgCSCIEajYCECACIAQgBmo2AgwgAkEMahCdGCABKAJMIgMNAAsLIABBBDoAACACQSBqJAAPC0GA9c0AELI7AAuUAgIHfwJ+IwBBIGsiAiQAIAFBHGohBgJAA0AgAkEQaiABEIMYAkAgAi0AEEEERg0AIAIpAxAiCUL/AYNCBFENACAAIAk3AgAMAgsgASkDCCACQRBqIAFBAUEAIAZBBBCQNgJAIAItABBFDQAgAigCFCEHIAIoAhghCCMAQRBrIgMkACADQQhqIQVBCEEEEK02IgRFBEBBBEEIEKM9AAsgBCAINgIEIAQgBzYCACAFQay8+wA2AgQgBSAENgIAIAJBCGpBKCADKAIIQay8+wAQySkgA0EQaiQAIAItAAhBBEYNACACKQMIIgpC/wGDQgRRDQAgACAKNwIADAILIAEpAwhSDQALIABBBDoAAAsgAkEgaiQAC7oBAQV/IwBBIGsiAiQAAkAgASgCJCIDBEAgAUEcaiEFA0AgASgCGCIERQ0CIAQgASgCICIEIAMgBGoQvSYgAiADIAEoAiQiBBDKLSACKAIEIQMgASACKAIAIgY2AiQgAiAFNgIUIAIgAzYCGCACIAQgA2s2AhwgAiADIAEoAiAiBGo2AhAgAiAEIAZqNgIMIAJBDGoQnRggASgCJCIDDQALCyAAQQQ6AAAgAkEgaiQADwtB8PTNABCyOwALswEBA38gACgCACAAKAIIIgNrIAFJBEAgACADIAFBBEEMENAoIAAoAgghAwsgACgCBCADQQxsaiEEAkACQCABQQJPBEAgAUEBayEFA0AgBCACKQIANwIAIARBCGogAkEIaigCADYCACAEQQxqIQQgBUEBayIFDQALIAEgA2pBAWshAwwBCyABRQ0BCyAEIAIpAgA3AgAgBEEIaiACQQhqKAIANgIAIANBAWohAwsgACADNgIIC581AiN/Bn4jAEFAaiIRJAAgEUEgaiEcIAEoAgwhFiMAQSBrIg8kAAJAAkAgASgCACIDIAEoAgQiIkYNACABKAIIISMCQANAIAEgA0EQaiIkNgIAIA9BCGohBCADKAIAIQcgA0EEaigCACEGQgAhJiMAQeAAayICJAAgAiAGNgIMIAIgBzYCCCACIAY2AjAgAkEANgIsIAIgBjYCKCACIAc2AiQgAkEBOgA4IAJBLjYCICACQS42AjQgAkFAayACQSBqEOoOAkACQAJAAkACQCACKAJARQ0AIAcgAigCSCIJaiELAkACQAJAAkAgBiAJayIMQRBPDQAgAigCRCEFIAsgDEEtEJwUIQogBiAJRgRAIApFDQUMAgsgCg0AIAcgBUEtEJwUIQoCQCAFRQ0AIAcgBUHkyYABQQEQwS4NACACQUBrIgkgByAFEJsKIAJBIGohBiACQQhqIRMjAEFAaiIHJABBASEFAkAgCS0AAEEBRgRAIAdBAjYCJCAHQdDKgAE2AiAgB0IBNwIsIAdBzAE2AjwgByATNgI4IAcgB0E4ajYCKCAHQRBqIAdBIGoQmQ4gB0GEgICAeDYCDCAGIAcpAgw3AgQgBkEMaiAHQRRqKQIANwIAIAZBFGogB0EcaigCADYCAAwBCyAGIAkpAwg3AwhBACEFCyAGIAU2AgAgB0FAayQAIAIoAiBBAXENAyACKQMoISYLIAJBEGogCyAMEJsKQQEhByACLQAQQQFGBEAgAkECNgIkIAJB0MqAATYCICACQgE3AiwgAkHMATYCXCACIAJB2ABqNgIoIAIgAkEIajYCWCACQcQAaiACQSBqEJkOIAIpAkQhJSAEIAIpAkw3AxAgBCAlNwMIIARBhICAgHg2AgQMCQsgAikDGCEqQgEhJwJAIAxBD0YNAEEPIAxrIQdCCiElA0AgB0EBcQRAICUgJ34hJyAHQQFGDQILIAdBAXYhByAlICV+ISUMAAsACyAEICY3AwggBEIAICcgKn4iJX0iJyAnICUgJkIAUxsgChs3AxAMBwsgCyAMQS0QnBRFDQILIAJBAjYCJCACQdDKgAE2AiAgAkIBNwIsIAJBzAE2AkQgAiACQUBrNgIoIAIgAkEIajYCQCAEQQhqIAJBIGoQmQ4gBEGEgICAeDYCBEEBIQcMBgsgAigCJCEHIAIpAyghJSAEIAIpAzA3AxAgBCAlNwMIIAQgBzYCBEEBIQcMBQsgDEEPSw0BCyACQRBqIAIoAgggAigCDBCbCiACLQAQRQ0BIAJBAjYCJCACQdDKgAE2AiAgAkIBNwIsIAJBzAE2AlwgAiACQdgAajYCKCACIAJBCGo2AlggAkHEAGogAkEgahCZDiACKQJEISUgBCACKQJMNwMQIAQgJTcDCCAEQYSAgIB4NgIEQQEhBwwDCyACQQI2AiQgAkGcyoABNgIgIAJCATcCLCACQcwBNgJEIAIgAkFAazYCKCACIAJBCGo2AkAgBEEIaiACQSBqEJkOIARBhICAgHg2AgRBASEHDAILIAIpAxghJSAEQgA3AxAgBCAlNwMIC0EAIQcLIAQgBzYCACACQeAAaiQAAkACfiAPKAIIQQFGBEAgDykDECImQhCIISUgDygCDCECICanIQMgDykDGAwBCyAPKQMYISUgDykDECEmIANBCGooAgAiDEUEQCAjLwEAIQMMAgsgD0EIaiEQIANBDGooAgAhC0EAIQRBACECIwBBQGoiDSQAIA0gCzYCECANIAw2AgwgDUEUaiEdQQAhAyMAQSBrIggkAAJAAkACQAJAIAtBAEgNAAJAAkACQCALRQRAQQEhCQwBC0EBIQQgC0EBEK02IglFDQMgDCEFIAkhBAJAIAsiCkEQSQ0AIAtB8P///wdxIQMDQCACIAlqIQQgAiAMaiIFQQFqLAAAIgdBf3NBgAFxQQd2IAUsAAAiBkF/c0GAAXFBB3ZqIAVBAmosAAAiE0F/c0GAAXFBB3ZqIAVBA2osAAAiEkF/c0GAAXFBB3ZqIAVBBGosAAAiDkF/c0GAAXFBB3ZqIAVBBWosAAAiFEF/c0GAAXFBB3ZqIAVBBmosAAAiF0F/c0GAAXFBB3ZqIAVBB2osAAAiGEF/c0GAAXFBB3ZqIAVBCGosAAAiGUF/c0GAAXFBB3ZqIAVBCWosAAAiGkF/c0GAAXFBB3ZqIAVBCmosAAAiG0F/c0GAAXFBB3ZqIAVBC2osAAAiFUF/c0GAAXFBB3ZqIAVBDGosAAAiHkF/c0GAAXFBB3ZqIAVBDWosAAAiH0F/c0GAAXFBB3ZqIAVBDmosAAAiIEF/c0GAAXFBB3ZqIAVBD2osAAAiIUF/c0GAAXFBB3ZqQf8BcUEQRwRAIAIhAwwCCyAEQQ9qICFBwQBrQf8BcUEaSUEFdCAhcjoAACAEQQ5qICBBwQBrQf8BcUEaSUEFdCAgcjoAACAEQQ1qIB9BwQBrQf8BcUEaSUEFdCAfcjoAACAEQQxqIB5BwQBrQf8BcUEaSUEFdCAecjoAACAEQQtqIBVBwQBrQf8BcUEaSUEFdCAVcjoAACAEQQpqIBtBwQBrQf8BcUEaSUEFdCAbcjoAACAEQQlqIBpBwQBrQf8BcUEaSUEFdCAacjoAACAEQQhqIBlBwQBrQf8BcUEaSUEFdCAZcjoAACAEQQdqIBhBwQBrQf8BcUEaSUEFdCAYcjoAACAEQQZqIBdBwQBrQf8BcUEaSUEFdCAXcjoAACAEQQVqIBRBwQBrQf8BcUEaSUEFdCAUcjoAACAEQQRqIA5BwQBrQf8BcUEaSUEFdCAOcjoAACAEQQNqIBJBwQBrQf8BcUEaSUEFdCAScjoAACAEQQJqIBNBwQBrQf8BcUEaSUEFdCATcjoAACAEQQFqIAdBwQBrQf8BcUEaSUEFdCAHcjoAACAEIAZBwQBrQf8BcUEaSUEFdCAGcjoAACACQRBqIQIgCkEQayIKQQ9LDQALIAIgC0YNASACIAlqIQQgAiAMaiEFCyADIApqQQAhDgNAIAUgDmoiAiwAACIGQQBIDQIgBCAOaiAGQcEAa0H/AXFBGklBBXQgBnI6AAAgCiAOQQFqIg5HDQALIQMLIAggAzYCECAIIAk2AgwgCCALNgIIDAELIAggCTYCDCAIIAMgDmoiEzYCECACIAogDmtqIRcgDCATaiEUIANBAmoiBCAOaiEYIAggCzYCCCALIAxqIRkgAyALayAOaiEaIAQgC2sgDmohG0EAIQcgEyEDA0ACQAJ/IAIsAAAiBEEASARAIAItAAFBP3EhBSAEQR9xIQYCfyAEQV9NBEAgBkEGdCAFciEEIAJBAmoMAQsgAi0AAkE/cSAFQQZ0ciEFIARBcEkEQCAFIAZBDHRyIQQgAkEDagwBCyAGQRJ0QYCA8ABxIAItAANBP3EgBUEGdHJyIQQgAkEEagsiEiAHIAJraiEGIARBowdHBEAgBiEHIBIMAgsCQCAHIBNqIglFDQAgCSALTwRAIAcgGmpFDQEMCQsgByAUaiwAAEFASA0ICyAHIBRqIQRBACEOAkADQEGDASEKIAQgDEYNASAEQQFrIgIsAAAiBUEASARAIAVBP3ECfyAEQQJrIgItAAAiBcAiFUFATgRAIAVBH3EMAQsgFUE/cQJ/IARBA2siAi0AACIFwCIVQb9/SgRAIAVBD3EMAQsgFUE/cSAEQQRrIgItAABBB3FBBnRyC0EGdHILQQZ0ciIFQYCAxABGDQILAn8CQCAOQQFxDQAgBRCqD0UNAEGAgMQAIQVBAAwBC0EBCyEOIAIhBCAFQYCAxABGDQALIAUQuhBFDQACQCAHIBhqRQ0AIAsgCUECak0EQCAHIBtqRQ0BDAkLIAcgFGpBAmosAABBQEgNCAsgByAUakECaiEEQQAhAgNAQYIBIQogBCAZRg0BAn8gBCwAACIHQQBOBEAgB0H/AXEhBSAEQQFqDAELIAQtAAFBP3EhCSAHQR9xIQUgB0FfTQRAIAVBBnQgCXIhBSAEQQJqDAELIAQtAAJBP3EgCUEGdHIhCSAHQXBJBEAgCSAFQQx0ciEFIARBA2oMAQsgBUESdEGAgPAAcSAELQADQT9xIAlBBnRyciIFQYCAxABGDQIgBEEEagshBAJ/AkAgAkEBcQ0AIAUQqg9FDQBBgIDEACEFQQAMAQtBAQshAiAFQYCAxABGDQALQYN/QYJ/IAUQuhAbIQoLIAgoAgggA2tBAU0EfyAIQQhqIANBAhDPFiAIKAIQBSADCyAIKAIMIglqIgIgCjoAASACQc8BOgAAIAggA0ECaiIDNgIQIAYhByASIQIMAgsgBEH/AXEhBCACQQFqIgYgByACa2ohByAGCyECIAhBFGogBBD9DAJAIAgoAhgiBEUEQAJ/QQEgCCgCFCIEQYABSSIKDQAaQQIgBEGAEEkNABpBA0EEIARBgIAESRsLIgUgCCgCCCADa0sEfyAIQQhqIAMgBRDPFiAIKAIMIQkgCCgCEAUgAwsgCWohBgJAAkAgCkUEQCAEQYAQSQ0BIARBgIAESQ0CIAYgBEE/cUGAAXI6AAMgBiAEQRJ2QfABcjoAACAGIARBBnZBP3FBgAFyOgACIAYgBEEMdkE/cUGAAXI6AAEMBAsgBiAEOgAADAMLIAYgBEE/cUGAAXI6AAEgBiAEQQZ2QcABcjoAAAwCCyAGIARBP3FBgAFyOgACIAYgBEEMdkHgAXI6AAAgBiAEQQZ2QT9xQYABcjoAAQwBCyAIKAIUIQYCQAJAAkACQAJAAkAgCCgCHCIFRQRAAn9BASAGQYABSSISDQAaQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIgogCCgCCCADa0sEfyAIQQhqIAMgChDPFiAIKAIMIQkgCCgCEAUgAwsgCWohBSASDQEgBkGAEEkNAiAGQYCABE8EQCAFIAZBP3FBgAFyOgADIAUgBkESdkHwAXI6AAAgBSAGQQZ2QT9xQYABcjoAAiAFIAZBDHZBP3FBgAFyOgABDAcLIAUgBkE/cUGAAXI6AAIgBSAGQQx2QeABcjoAACAFIAZBBnZBP3FBgAFyOgABDAYLAn9BASAGQYABSSISDQAaQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIgogCCgCCCADa0sEfyAIQQhqIAMgChDPFiAIKAIMIQkgCCgCEAUgAwsgCWohCSASDQIgBkGAEEkNAyAGQYCABE8EQCAJIAZBP3FBgAFyOgADIAkgBkESdkHwAXI6AAAgCSAGQQZ2QT9xQYABcjoAAiAJIAZBDHZBP3FBgAFyOgABDAULIAkgBkE/cUGAAXI6AAIgCSAGQQx2QeABcjoAACAJIAZBBnZBP3FBgAFyOgABDAQLIAUgBjoAAAwECyAFIAZBP3FBgAFyOgABIAUgBkEGdkHAAXI6AAAMAwsgCSAGOgAADAELIAkgBkE/cUGAAXI6AAEgCSAGQQZ2QcABcjoAAAsgCCADIApqIgY2AhACf0EBIARBgAFJIhINABpBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiCiAIKAIIIAZrSwR/IAhBCGogBiAKEM8WIAgoAhAFIAYLIAgoAgwiCWohAwJAAkAgEkUEQCAEQYAQSQ0BIARBgIAETwRAIAMgBEE/cUGAAXI6AAMgAyAEQRJ2QfABcjoAACADIARBBnZBP3FBgAFyOgACIAMgBEEMdkE/cUGAAXI6AAEMAwsgAyAEQT9xQYABcjoAAiADIARBDHZB4AFyOgAAIAMgBEEGdkE/cUGAAXI6AAEMAgsgAyAEOgAADAELIAMgBEE/cUGAAXI6AAEgAyAEQQZ2QcABcjoAAAsgCCAGIApqIgQ2AhACf0EBIAVBgAFJIgoNABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiBiAIKAIIIARrSwR/IAhBCGogBCAGEM8WIAgoAgwhCSAIKAIQBSAECyAJaiEDAkACQCAKRQRAIAVBgBBJDQEgBUGAgARPBEAgAyAFQT9xQYABcjoAAyADIAVBEnZB8AFyOgAAIAMgBUEGdkE/cUGAAXI6AAIgAyAFQQx2QT9xQYABcjoAAQwDCyADIAVBP3FBgAFyOgACIAMgBUEMdkHgAXI6AAAgAyAFQQZ2QT9xQYABcjoAAQwCCyADIAU6AAAMAQsgAyAFQT9xQYABcjoAASADIAVBBnZBwAFyOgAACyAIIAQgBmoiAzYCEAwCCyAIIAMgCmoiBjYCEAJ/QQEgBEGAAUkiCg0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyIFIAgoAgggBmtLBH8gCEEIaiAGIAUQzxYgCCgCEAUgBgsgCCgCDCIJaiEDAkACQCAKRQRAIARBgBBJDQEgBEGAgARPBEAgAyAEQT9xQYABcjoAAyADIARBEnZB8AFyOgAAIAMgBEEGdkE/cUGAAXI6AAIgAyAEQQx2QT9xQYABcjoAAQwDCyADIARBP3FBgAFyOgACIAMgBEEMdkHgAXI6AAAgAyAEQQZ2QT9xQYABcjoAAQwCCyADIAQ6AAAMAQsgAyAEQT9xQYABcjoAASADIARBBnZBwAFyOgAACyAIIAUgBmoiAzYCEAwBCyAIIAMgBWoiAzYCEAsgAiAXRw0ACwsgHSAIKQIINwIAIB1BCGogCEEQaigCADYCACAIQSBqJAAMAwsgBCALQezDiQEQ/S8ACyAMIAsgCUECaiALQdzDiQEQozYACyAMIAtBACAJQczDiQEQozYACyAQAn8CQCANKAIYIgMgDSgCHCICQbTHgAFBARDBLg0AIAMgAkG1x4ABQQQQwS4NACADIAJBuceAAUEFEMEuDQAgAyACQb7HgAFBBxDBLg0AIAMgAkHFx4ABQQkQwS4NAAJAIAMgAkHOx4ABQQMQwS4NACADIAJB0ceAAUEEEMEuDQAgAyACQdXHgAFBBhDBLg0AIAMgAkHbx4ABQQcQwS4NAAJAIAMgAkHix4ABQQEQwS4NACADIAJB48eAAUECEMEuDQAgAyACQeXHgAFBAxDBLg0AIAMgAkHox4ABQQQQwS4NACADIAJB7MeAAUEFEMEuDQACQCADIAJB8ceAAUEDEMEuDQAgAyACQfTHgAFBBBDBLg0AIAMgAkH4x4ABQQUQwS4NACADIAJB/ceAAUEGEMEuDQACQCADIAJBg8iAAUEBEMEuDQAgAyACQYTIgAFBBBDBLg0AIAMgAkGIyIABQQUQwS4NAAJAIAMgAkGNyIABQQEQwS4NACADIAJBjsiAAUEDEMEuDQAgAyACQZHIgAFBBBDBLg0AAkAgAyACQZXIgAFBARDBLg0AIAMgAkGWyIABQQIQwS4NACADIAJBmMiAAUEDEMEuDQAgAyACQZvIgAFBBBDBLg0AIAMgAkGfyIABQQUQwS4NAAJAIAMgAkGkyIABQQEQwS4NACADIAJBpciAAUEDEMEuDQAgAyACQajIgAFBBBDBLg0AIAMgAkGsyIABQQYQwS4NACADIAJBssiAAUEHEMEuDQACQCADIAJBuciAAUEBEMEuDQAgAyACQbrIgAFBAxDBLg0AIAMgAkG9yIABQQQQwS4NACADIAJBwciAAUEGEMEuDQAgAyACQcfIgAFBBxDBLg0AAkAgAyACQc7IgAFBAhDBLg0AIAMgAkHQyIABQQQQwS4NACADIAJB1MiAAUEFEMEuDQAgAyACQdnIgAFBBxDBLg0AIAMgAkHgyIABQQgQwS4NACADIAJB6MiAAUELEMEuDQAgAyACQfPIgAFBDBDBLg0AAkAgAyACQf/IgAFBAhDBLg0AIAMgAkGByYABQQQQwS4NACADIAJBhcmAAUEFEMEuDQAgAyACQYrJgAFBBxDBLg0AIAMgAkGRyYABQQgQwS4NACADIAJBmcmAAUELEMEuDQAgAyACQaTJgAFBDBDBLg0AAkAgAyACQbDJgAFBChDBLkUEQCADIAJBusmAAUELEMEuRQ0BCyAQQYAQOwEEQZOAgIB4DAwLIA1BATYCJCANQdzJgAE2AiAgDUIBNwIsIA1BzAE2AjwgDSANQThqNgIoIA0gDUEMajYCOCAQQQRqIQcjAEEQayIEJAAgDUEgaiIDKAIMIQICQAJAAkACQAJAAkACQCADKAIEDgIAAQILIAINAUEBIQJBACEDDAILIAINACADKAIAIgIoAgQhAyACKAIAIQIMAQsgByADEJkODAELIARBBGogA0EAQQFBARCgGCAEKAIIIQwgBCgCBEEBRg0BIAQoAgwhBiADBEAgBiACIAP8CgAACyAHIAM2AgggByAGNgIEIAcgDDYCAAsgBEEQaiQADAELIAwgBCgCDEGww4ABEP0vAAtBjYCAgHgMCwsgEEGACDsBBEGTgICAeAwKCyAQQYAEOwEEQZOAgIB4DAkLIBBBgAI7AQRBk4CAgHgMCAsgEEGAATsBBEGTgICAeAwHCyAQQcAAOwEEQZOAgIB4DAYLIBBBIDsBBEGTgICAeAwFCyAQQRA7AQRBk4CAgHgMBAsgEEEIOwEEQZOAgIB4DAMLIBBBBDsBBEGTgICAeAwCCyAQQQI7AQRBk4CAgHgMAQsgEEEBOwEEQZOAgIB4CzYCACANQRRqEN47IA1BQGskACAPLwEMIQMgDygCCCICQZOAgIB4Rg0BIA81AQ4gD0ESajMBAEIghoQhJSAPKQIUCyEmIBYoAgBBk4CAgHhHBEAgFhCIEQsgFiAmNwIMIBYgA61C//8DgyAlQhCGhDcCBCAWIAI2AgBBACEDDAILAkAgA0H//wNxIgIEQCACQYEQRw0BICYhKSAlISgLICQiAyAiRg0DDAELCyAlISggJiEpCyAcICg3AwggHCApNwMADAELQYEQIQMLIBwgAzsBECAPQSBqJAACQAJAIBEvATAiAUGBEEYNACARQRhqIgMgEUEoaikDADcDACARQQxqIgIgEUE2ai8BADsBACARIBEpAyA3AxAgESARKAEyNgIIIAFFDQAgACARKQMQNwMAIAAgESgCCDYBEiAAQQhqIAMpAwA3AwAgAEEWaiACLwEAOwEADAELQQAhAQsgACABOwEQIBFBQGskAAuvAQEBfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC3JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgACAEKQIANwIAIAAgBCkCDDcCDCAAIAQpAhg3AhggAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaigCADYCACAAQSBqIARBIGopAgA3AgAgAEEoaiAEQShqKQIANwIAIARBMGokAAuvAQEBfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC4JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgACAEKQIANwIAIAAgBCkCDDcCDCAAIAQpAhg3AhggAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaigCADYCACAAQSBqIARBIGopAgA3AgAgAEEoaiAEQShqKQIANwIAIARBMGokAAvyAQEGfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiMAQRBrIgUkACABQQxqIggoAgAiBiAGKAIAIglBAWo2AgAgCUEASARAAAsgBSAGNgIEIAUgCCkCBDcCCCAFQQRqIAIgAxD8HCAFQRBqJAACQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAAgBCkCADcCACAAIAQpAgw3AgwgACAEKQIYNwIYIABBCGogBEEIaigCADYCACAAQRRqIARBFGooAgA2AgAgAEEgaiAEQSBqKQIANwIAIABBKGogBEEoaikCADcCACAEQTBqJAALrwEBAX8jAEEwayIEJAAgBCABENAGIARBDGogAUEMaiACIAMQtSYCQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAAgBCkCADcCACAAIAQpAgw3AgwgACAEKQIYNwIYIABBCGogBEEIaigCADYCACAAQRRqIARBFGooAgA2AgAgAEEgaiAEQSBqKQIANwIAIABBKGogBEEoaikCADcCACAEQTBqJAALhwQBCX8jAEHQAGsiAyQAIAMgAjYCGCADIAE2AhQgA0EIaiEHIwBBEGsiBSQAQQMhCEEwIQlBBCEKQTAhCwJAAkACQAJAIAJBA2sOBAIDAQADCyABLQADQTpHDQJBBSEKQQQhCAsgASAKai0AACELIAEgCGotAAAhCQsgBSALOgAPIAUgCToADiAFIAEvAAE7AAwDQCAFQQxqIARqIgYgBi0AAEEwazoAACAEQQFqIgRBBEcNAAtBACEEAkADQCAEQQRGDQEgBUEMaiAEaiAEQQFqIQQtAABBCU0NAAtBACEGDAELAkACQCACBEAgBS0ADyAFLQAOQQpsakH/AXFBPGwgBS0ADSAFLQAMQQpsakH/AXFBkBxsaiEEQQAhBiABLQAAQStrDgMBAwIDC0EAQQBBtOmFARDDIQALIARBgKMFSSEGDAELIARBgKMFSSEGQQAgBGshBAsgByAENgIEIAcgBjYCACAFQRBqJAAgAAJ/IAMoAghBAXFFBEAgA0ECNgI0IANBhIKFATYCMCADQgE3AjwgA0HHAjYCTCADIANByABqNgI4IAMgA0EUajYCSCADQSBqIANBMGoQmQ4gACADKQIkNwIIIABBEGogA0EsaigCADYCACADKAIgIQJBhICAgHgMAQsgAygCDCECQZOAgIB4CzYCACAAIAI2AgQgA0HQAGokAAuoAQEHfyABQf8BcSICQeMASyIGRQRAIAJBCm4iB0EwciEIIAAoAggiAiEDIAIgACgCACIERgRAIAAgAkEBENsoIAAoAgghAyAAKAIAIQQLIAAgAkEBaiIFNgIIIAMgACgCBCIDaiAIOgAAIAQgBUYEQCAAIARBARDbKCAAKAIEIQMgACgCCCEFCyAAIAJBAmo2AgggAyAFaiABIAdBCmxrQTByOgAACyAGC8gBACAAIAIpAgA3AiAgACABKAIsNgIsIAAgASkCADcCACAAIAEpAjA3AjAgACABKQI8NwI8IABBKGogAkEIaigCADYCACAAQThqIAFBOGooAgA2AgAgAEHEAGogAUHEAGopAgA3AgAgAEHMAGogAUHMAGopAgA3AgAgACABKAJUNgJUIAAgASkCCDcCCCAAQRBqIAFBEGooAgA2AgAgACABKQIUNwIUIABBHGogAUEcaigCADYCACAAIAEvAVg7AVggAUEgahDKDAvAAQEDfyMAQRBrIgUkACABQQAgASgCCCIEIARBAUYiBBs2AggCQAJAIARFBEAgBUEEaiADQQBBAUEBEKAYIAUoAgghBiAFKAIEQQFGDQIgBSgCDCEEIAMEQCAEIAIgA/wKAAALIAEQlC0MAQsgASgCBCEGIAEoAgAhBCABQQxBBBD4OiADRQ0AIAQgAiAD/AoAAAsgACADNgIIIAAgBDYCBCAAIAY2AgAgBUEQaiQADwsgBiAFKAIMQcCFiAEQ/S8AC8gBAQF/IwBBEGsiCyQAIAAoAgAgASACIAAoAgQoAgwRBgAhASALQQA6AA0gCyABOgAMIAsgADYCCCALQQhqIAMgBCAFIAYQiBIgByAIIAkgChCIEiEBIAstAA0iAiALLQAMIgNyIQACQCADQQFxIAJBAUdyDQAgASgCACIALQAKQYABcUUEQCAAKAIAQdfxiQFBAiAAKAIEKAIMEQYAIQAMAQsgACgCAEHW8YkBQQEgACgCBCgCDBEGACEACyALQRBqJAAgAEEBcQu3AQEDfyAAKAJAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQUBrEOgnCwJAIAAoAjgiAUUNACAAKAI8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CwJAIAApAwBCAlEEQCAAKAIYIgBFDQEgACkDAEIDUgRAIAAQ8SsLIAApA2hCA1IEQCAAQegAahDxKwsgAEGIAkEIEPg6DwsgAEEgaiIAENAuIAAQ9TsLC5YEAQZ/IwBBkAFrIgQkACABKAIMIgIoAggiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgBCACKAIMNgJQIAQgBTYCTCAEQSA6AEggBEEBQQAgBEHIAGoiBUEAEJsUIAIgAigCACIDQQFqNgIAIANBAEgNACAEQfwAaiIDIAEQvBUgBCACNgKIASAEIAEoAhA2AowBIAUgAxCfDiMAQfABayIBJAAgAUGoAWogBBDoDCAEQTRqQQFBARDgHiAEQShqENAMIAQQkycCQAJAAkACQCABKAKoAUEBRgRAIAFBEGogAUG8AWooAgA2AgAgAUEIaiABQbQBaikCADcDACABIAEpAqwBNwMAIAAgARDKJgwBCyABQQRqIgIgAUGwAWpBMPwKAAAgAUE4aiIGIAJBMPwKAAAgAUGoAWoiAiAFQYjIzAAoAgARAAAgAUHoAGoiByACEI0EIAJBGGoQkwwgAhDFJyACEOg7IAJBDGoiAxCkLCADEPU8AkAgAigCLCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACACQSxqEPseC0HAAEEIEK02IgJFDQEgAiAHQcAA/AoAAEEwQQgQrTYiA0UNAiADIAZBMPwKAAAgACADNgIIIAAgAjYCBCAAQYGAgIB4NgIACyABQfABaiQADAILQQhBwAAQoz0AC0EIQTAQoz0ACyAFEIIpIARBkAFqJAAPCwALqwEBBH8jAEEQayIEJAAgACgCCCIBQQRqIQICQAJAIAFBe00EQCACIAAoAgQiA0sNASAEQQRqIgIgACgCACIAIAMgASAAIAFqKAAAaxD2NCACQQgQzCBB//8DcSICBH8gASACaiIBIANLDQMgACABai0AAEEARwVBAAsgBEEQaiQADwsgASACQdDMzAAQsTsACyACIANB0MzMABCwOwALIAEgA0GMycwAEK87AAu5AQEDfyMAQSBrIgIkAAJAAkAgASgCECIERQRAIAJBDGoQtB4gAigCDCIDQQRGDQIgACACKQIUNwIIIABBEGogAkEcaigCADYCACAAQQdqIAIoAhAiAUEYdjoAACAAIAFBCHY7AAUgACABOgAEIAAgAzYCAAwBCyABKAIMIQMgASAEQQFrNgIQIAEgA0EBajYCDCAAQQQ2AgAgACADLQAAOgAECyACQSBqJAAPC0EBQQBB1LPOABCvOwALtgEBB38jAEEQayICJAAgASgCBCEEIAJBBGogASgCCCIGQQBBBEEIEKAYIAIoAgghAyACKAIEQQFHBEAgAigCDCEHAkAgA0UNACAGQQN0IQEgByEFIAMhCANAIAFFDQEgBSAEKQIANwIAIAVBCGohBSABQQhrIQEgBEEIaiEEIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQeiZzwAQ/S8AC6gCAQN/IwBBIGsiBCQAAkACfwJAIAJFDQAgBEEIaiABIAIgAxCeASAEKAIMIQIgBCgCCCIDQQhGBEAgAkUNASAEKAIQDAILIAAgBCkCFDcCDCAAQRRqIARBHGooAgA2AgAgACAEKAIQNgIIIAAgAjYCBCAAIAM2AgAMAgsgASgCACABKAIEKAIMEQQAIQMjAEEQayICJAAgAkEIahDBLCACKAIMIQUgAigCCCEGQRRBBBCtNiIBRQRAQQRBFBCjPQALIAFBADYCECABIAM2AgwgASAGNgIEIAFBIDoAACABIAU2AgggBEG4180ANgIEIAQgATYCACACQRBqJAAgBCgCACECIAQoAgQLIQEgACACNgIEIABBCDYCACAAIAE2AggLIARBIGokAAvMAQECfyMAQRBrIgUkAAJAIAAoAowBDQAgASgCBCABKAIARw0AIAAoAgwiBiAAKAIQRyAEQQlJcg0AIAMgACgCBGsgBkcNACAFQQhqIAJBCGooAgA2AgAgBSACKQIANwMAIAAgASAFIAMgBEEAEN81GiABQQA2AiQgASABKAIINgIMIAEgASgCADYCBCAAIAAoAgQgBGs2AgQgACAAKAIMIARqIgY2AgwgACAGNgIcIAAgBjYCEAsgACABIAIgAyAEQQAQ3zUgBUEQaiQAC5oBAQR+AkAgAUEQaiAATQRAIACtIAGtIgd9QgEgAkICfIZ8QhB9IgUgBSAFeUI/hUL/////D3wiBohCAYMiCEIChCAGhn0gAoinIQEgByAFQX8gAqd0QX9zrYN8IAZC/////w+DIAJ9IgVCAYYgCIRC/v8DfCAChnxCEHwgBUIKhoSnIQAMAQtBACEBCyAEIAE2AgAgAyAAOwEAC7kBACACQQA2AgAgASgCACECAkACQAJAIAAEQCAAQSBPDQEgCCAAQQJ0aiIIKAIAIAZqIgZB0AVPDQIgCCACNgIAIAQgADYCACAFIAZBAXRqIAI7AQAgAyADKAIAQYCAAiAAdms2AgAgAEEQTw0DIAcgAEEBdGoiACAALwEAQQFqOwEACyABIAJBAWo2AgAPCyAAQSBBzJ/zABDDIQALIAZB0AVB3J/zABDDIQALIABBEEHsn/MAEMMhAAveAQEBfyMAQRBrIgIkAAJ/AkACQAJAIAAoAgAiACgCAEEBaw4CAQIACyACIABBCGo2AgQgAUHY5f4AQQ1B5eX+AEEFIABBBGpBuOX+AEHq5f4AQQggAkEEakHI5f4AEI4YDAILIAIgAEEEajYCCCABQYTm/gBBCkGO5v4AQQogAEEIakH05f4AQerl/gBBCCACQQhqQcjl/gAQjhgMAQsgAiAAQQRqNgIMIAFBmOb+AEEMQaTm/gBBByAAQQhqQfTl/gBB6uX+AEEIIAJBDGpByOX+ABCOGAsgAkEQaiQAC8sBAQJ/IwBBIGsiAyQAAkACQCABKAIAIgEtAABBDUYEQCABKAIEIgRFDQEgA0EMaiAEQQhqIAEoAggQihggAygCECEBIAMoAgwiBEGTgICAeEcEQCAAIAMpAhQ3AgggAEEQaiADQRxqKAIANgIAIAAgATYCBCAAIAQ2AgAMAwsgACABNgIIIABCk4CAgBg3AgAgACACKQIYNwIMDAILQZCJ/wBBKEGolP8AEJ8pAAsgAEKTgICACDcCACAAIAIpAhA3AgwLIANBIGokAAu7AQEDfyMAQUBqIgIkACACQQhqIgMgACgCACUBEGUgAigCCCEAIAIgAigCDCIENgI8IAIgADYCOCACIAQ2AjQgAiACQTRqQYiviAEQkCEgAkHnHTYCJCACQQI2AgwgAkHIrogBNgIIIAJCATcCFCACIAIoAgQiADYCMCACIAIoAgA2AiwgAiAANgIoIAIgAkEoaiIANgIgIAIgAkEgajYCECABKAIAIAEoAgQgAxDLCiAAEN47IAJBQGskAAvgAwEHfyMAQTBrIgMkACADQRBqIQcjAEEQayIEJAACQAJAAkACQCABIAJGDQADQCABQQAgASgCABsQkSwiCEUEQCACIAFBBGoiAUcNAQwCCwsgBEEEaiIFQQRBAEEEQQQQoBggBCgCCCEGIAQoAgRBAUYNAiAEKAIMIgkgCDYCACAEQQxqIghBATYCACAEIAk2AgggBCAGNgIEAkAgAiABQQRqIgFGDQADQCABQQAgASgCABsgAUEEaiEBEJEsIglFBEAgASACRg0CDAELIAUoAggiBiAFKAIARgRAIAVBARCALgsgBSgCBCAGQQJ0aiAJNgIAIAUgBkEBajYCCCABIAJHDQALCyAHQQhqIAgoAgA2AgAgByAEKQIENwIADAELIAdBADYCCCAHQoCAgIDAADcCAAsgBEEQaiQADAELIAYgBCgCDEGQ0MMAEP0vAAsgAygCECEFIAMoAhQhASADIAMoAhgiAjYCHCADQQhqIAJBAnQiAiADQRxqEL8hIAMoAgghBCADKAIMIQcgAgRAIARBCGogASAC/AoAAAsgA0EANgIoIAMgATYCICADIAU2AhwgAyADQS9qNgIkIANBHGoiARDGJyABEOk7IAAgBzYCBCAAIAQ2AgAgA0EwaiQAC7AEAQl/IwBBMGsiAyQAIANBEGohCCMAQRBrIgQkAAJAAkACQAJAAkAgASACRg0AA0AgAUEEaigCACIFRQRAIAIgAUEIaiIBRw0BDAILCyABLQAAIQogBSAFKAIAIgZBAWo2AgAgBkEASA0CIARBBGoiBkEEQQBBBEEIEKAYIAQoAgghByAEKAIEQQFGDQMgBCgCDCIJIAU2AgQgCSAKOgAAIARBDGoiCkEBNgIAIAQgCTYCCCAEIAc2AgQCQCABQQhqIgEgAiIFRg0AAkADQCABQQhqIQIgAUEEaigCACIHRQRAIAIiASAFRg0DDAELIAEtAAAhCSAHIAcoAgAiAUEBajYCACABQQBIDQEgBigCCCIBIAYoAgBGBEAgBkEBEP8tCyAGKAIEIAFBA3RqIgsgBzYCBCALIAk6AAAgBiABQQFqNgIIIAIiASAFRw0ACwwBCwALIAhBCGogCigCADYCACAIIAQpAgQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyAEQRBqJAAMAgsACyAHIAQoAgxBkNDDABD9LwALIAMoAhAhBCADKAIUIQEgAyADKAIYIgI2AhwgA0EIaiACQQN0IgIgA0EcahC/ISADKAIIIQUgAygCDCEGIAIEQCAFQQhqIAEgAvwKAAALIANBADYCKCADIAE2AiAgAyAENgIcIAMgA0EvajYCJCADQRxqIgEQ3yYgARDqOyAAIAY2AgQgACAFNgIAIANBMGokAAu3AQEEfyAAKAIEIQIgACgCACEDIABCgYCAgBA3AgAgACgCECEBAkACQAJAIAIgA0cEQCABDQEMAwsgAUUNAiABRSAAKAIMIgMgACgCCCIAKAIIIgJGcg0BIAAoAgQiBCACaiADIARqIAH8CgAADAELIAFFIAAoAgwiAyAAKAIIIgAoAggiAkZyRQRAIAAoAgQiBCACaiADIARqIAH8CgAACyAAIAEgAmo2AggPCyAAIAEgAmo2AggLC58BAQN/IwBBEGsiBSQAAkAgASgC8AEiBEE8SQRAIAQhA0E7IQQMAQsgASgCBCEDCwJ/QYGAgIB4IAIgBCADa00NABpBACADIAIgA2oiAksNABpBAEF/IAJBAWtndkEAIAJBAk8bIgNBf0YNABogBUEIaiABIANBAWoQphAgBSgCDCEDIAUoAggLIQQgACADNgIEIAAgBDYCACAFQRBqJAALngEBA38jAEEQayIFJAACQCABKAJIIgRBEkkEQCAEIQNBESEEDAELIAEoAgQhAwsCf0GBgICAeCACIAQgA2tNDQAaQQAgAyACIANqIgJLDQAaQQBBfyACQQFrZ3ZBACACQQJPGyIDQX9GDQAaIAVBCGogASADQQFqEKcQIAUoAgwhAyAFKAIICyEEIAAgAzYCBCAAIAQ2AgAgBUEQaiQAC54BAQF+IAACfwJAIAMgBGpBAWtBACADa3GtIAGtfiIFQiCIUARAIAWnIgRBgICAgHggA2tNDQELIABBADYCBEEBDAELIARFBEAgACADNgIIIABBADYCBEEADAELAn8gAgRAIAQgAxCuNgwBCyAEIAMQrTYLIgIEQCAAIAI2AgggACABNgIEQQAMAQsgACAENgIIIAAgAzYCBEEBCzYCAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHU/cwAEP0vAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEH8u80AEP0vAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHYp84AEP0vAAu2AQEBfyMAQdAAayIDJAAgAAJ/IAJBA00EQCADIAI2AjwgA0ECNgIoIANBmLXOADYCJCADQgI3AjAgA0E7NgJMIANBOzYCRCADQai1zgA2AkAgAyADQUBrNgIsIAMgA0E8ajYCSCADQQhqQQRyIANBJGoQmQ4gACADKQMQNwMIIABBEGogA0EYaikDADcDAEEAIQIgAygCDAwBC0EIIQIgASgAAAs2AgQgACACNgIAIANB0ABqJAAL8QICB38DfiMAQTBrIgIkAAJAAkADQCACQQhqIQZBACEEIAEoAhwhAyABQQA2AhwgASABKAIYIANBA3ZqIANBB3FBAEdqIgM2AhgCQAJAIANBAWoiByABKAIIIgVNBEAgAyAFSw0BAn8gASgCBCADaiEIIwBBEGsiBCQAIAUgA2sEQCAEQQA6AA8gBEEPaiAILQAAOgAAIAQtAA8gBEEQaiQADAELQbS1zgBBI0HYtc4AEJ8pAAshBCABIAc2AhgLIAYgBDoAASAGIAUgB086AAAMAQsgAyAFQei6zgAQrzsACyACLQAIRQ0BIAlCwABaDQIgAiwACSIDrUL/AIMgCYYgCoQhCiAJQgd8IQkgA0EASA0ACyAAIAo3AwhCASELCyAAIAs3AwAgAkEwaiQADwsgAkECNgIUIAJBpLvOADYCECACQgE3AhwgAkE7NgIsIAJB+LrOADYCKCACIAJBKGo2AhggAkEQakG0u84AEO8sAAu4AQICfwJ+IwBBQGoiBCQAIAEpAwAhByABIAIpAgA3AwAgAUEIaiIFKQMAIQYgBSACQQhqKQIANwMAIARBCGogBjcDACABQRBqIgIpAwAhBiACQgA3AwAgBEEQaiAGNwMAIAFBGGoiAikDACEGIAJCADcDACAEQRhqIAY3AwAgBCAHNwMAIAenIgIEQCAEQQxqIAQoAgQgBCgCCCACKAIQEQEACyAAQQg2AgAgASADNgIwIARBQGskAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHko88AEP0vAAuuAQEEfwNAAkACQCABRQ0AIAAoAgQiBSAAKAIMIgZPDQAgACgCACAFQQxsaiIDKAIEIgQgAU8EQCADIAQgAWs2AgQPCyADQQA2AgQgASAEayIBIAMoAggiBE8NASADIAQgAWsiATYCCCABIAJPDQAgBiAFQQFqIgJLBEAgAyADKAIQIAFqNgIQCyAAIAI2AgQLDwsgA0EANgIIIAAgBUEBajYCBCABIARrIQEMAAsAC8ABAgJ/AX4jAEEQayICJAACQAJAAkACQCABLQAYIgNBF2sOBAIBAQIACyADQSJGDQILIAIgARDvPCACKAIEIgNFDQEgAigCACEBIANBxABsIQMDQCAAIAEQqRggAUHEAGohASADQcQAayIDDQALDAELIAJBCGogARDcOyACNQIMQgF9IQQgACgCCCIBIAAoAgBGBEAgAEH8zf4AELMoCyAAKAIEIAFBA3RqIAQ3AwAgACABQQFqNgIICyACQRBqJAALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxB0KD/ABD9LwALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxBjMn/ABD9LwALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxB4K2AARD9LwALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQkyIiBigCFCIDQQN2IghBAWshBSADQQhJDQIgBigCECIDIAVBA3RqKAIAIQUgAygCACEDIAYQ1DogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQlSIiBigCFCIDQQN2IghBAWshBSADQQhJDQIgBigCECIDIAVBA3RqKAIAIQUgAygCACEDIAYQ1DogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQlCIiBigCFCIDQQJ2IghBAWshBSADQQRJDQIgBigCECIDIAVBAnRqKAIAIQUgAygCACEDIAYQ0zogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQkiIiBigCFCIDQQJ2IghBAWshBSADQQRJDQIgBigCECIDIAVBAnRqKAIAIQUgAygCACEDIAYQ0zogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQAL+gIBBX8jAEEgayICJAACQAJAAkACQAJAIAEoAiQiBEUEQCACQQhqIAEQ3DsgAigCDEUNASACKAIIKAIIRQ0DCyACIAEQ3DsgAigCBA0BQQBBAEG8w4QBEMMhAAtBAEEAQazDhAEQwyEACyACKAIAIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCFCACIAUpAgQ3AhggACACQRRqIAEoAiggBEEBahD+HAwBCyMAQUBqIgEkACABQRBqQQgQ0h8gASABKQIQNwI4IAFBADYCNCABIAEoAhwiBDYCMCABIAEoAhg2AiwgAUEIaiABQSxqENc7IAEoAgghBUEcQQQQrTYiA0UEQEEEQRwQoz0ACyADQoGAgIAQNwIAIAMgASkCLDcCCCADQRBqIAFBNGopAgA3AgAgA0EYaiABQTxqKAIANgIAIAEgBDYCKCABIAU2AiQgASADNgIgIAAgAUEgahDkGSABQUBrJAALIAJBIGokAA8LAAv6AgEFfyMAQSBrIgIkAAJAAkACQAJAAkAgASgCJCIERQRAIAJBCGogARDcOyACKAIMRQ0BIAIoAggoAghFDQMLIAIgARDcOyACKAIEDQFBAEEAQbzDhAEQwyEAC0EAQQBBrMOEARDDIQALIAIoAgAiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIUIAIgBSkCBDcCGCAAIAJBFGogASgCKCAEQQFqEIAdDAELIwBBQGoiASQAIAFBEGpBBBDSHyABIAEpAhA3AjggAUEANgI0IAEgASgCHCIENgIwIAEgASgCGDYCLCABQQhqIAFBLGoQ1zsgASgCCCEFQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyABKQIsNwIIIANBEGogAUE0aikCADcCACADQRhqIAFBPGooAgA2AgAgASAENgIoIAEgBTYCJCABIAM2AiAgACABQSBqEOUZIAFBQGskAAsgAkEgaiQADwsAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgIABNwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgMAANwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQR0NgIcIAJCgICAgIACNwIUIAIgBEEEdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC70BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQF0NgIcIAJCgICAgCA3AhQgAiAEQQF0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBHQ2AhwgAkKAgICAgAE3AhQgAiAEQQR0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBAnQ2AhwgAkKAgICAwAA3AhQgAiAEQQJ0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBXQ2AhwgAkKAgICAgAI3AhQgAiAEQQV0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBHQ2AhwgAkKAgICAgAI3AhQgAiAEQQR0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACAAIAQ2AgggACADNgIEIAAgATYCACACQSBqJAALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxBgOOGARD9LwALsAEBAn8CQCAAKAIIIgUgAyAEamwiAiADIAVsIgNPBEAgAiAAKAIEIgZLDQEgACgCACEGIAEoAgwiAiAEIAVsIgBqIgQgASgCBCIFSwRAIAEgBUEBdCICIAQQ3ioiBCACIARLGxDoGSABKAIMIQILIAAEQCABKAIIIAJqIAMgBmogAPwKAAALIAEgASgCDCAAajYCDA8LIAMgAkHUoYcBELE7AAsgAiAGQdShhwEQsDsAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgIABNwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgACAENgIIIAAgAzYCBCAAIAE2AgAgAkEgaiQAC8QBAQR/IwBBEGsiAyQAIAEoAgwhAgJAAkACQAJAAkACQCABKAIEDgIAAQILIAINAUEBIQJBACEBDAILIAINACABKAIAIgIoAgQhASACKAIAIQIMAQsgACABEJkODAELIANBBGogAUEAQQFBARCgGCADKAIIIQQgAygCBEEBRg0BIAMoAgwhBSABBEAgBSACIAH8CgAACyAAIAE2AgggACAFNgIEIAAgBDYCAAsgA0EQaiQADwsgBCADKAIMQbDWhwEQ/S8AC9MBAQd/AkAgACgCECIJIAIgAWsiCmoiB0EDdiAHQQdxQQBHaiICIAAoAgwiBU0EQCAAKAIIIQYgBSECDAELIAIgBWshCCAAKAIEIgYgAkkEQAJAIAIiBUE/cSILRQ0AIAIgC2tBQGsiBSACTw0AQaCDiAFBI0HEg4gBEMskAAsgACAGQQF0IgYgBSAFIAZJGxDoGSAAKAIMIQULIAAoAgghBiAIBEAgBSAGakEAIAj8CwALIAAgAjYCDAsgACAHNgIQIAYgAiADIAQgCSABIAoQhAkaC8IBAQN/IwBBEGsiBCQAAkACQCABKAIAIgEoAhBBAUcEQCAEQQRqIANBAEEBQQEQoBggBCgCCCEGIAQoAgRBAUYNAiAEKAIMIQUgAwRAIAUgAiAD/AoAAAsgARDDLAwBCyABQQA2AgggASgCACEGIAEoAgQhBSABQoCAgIAQNwIAIAEQwywgA0UNACAFIAIgA/wKAAALIAAgAzYCCCAAIAU2AgQgACAGNgIAIARBEGokAA8LIAYgBCgCDEGUiIgBEP0vAAuoAQEDfyMAQRBrIgMkAEEDIQIgAC0AACIAIQQgAEEKTwRAIAMgACAAQeQAbiIEQeQAbGtB/wFxQQF0IgJB4/OJAWotAAA6AA8gAyACQeLziQFqLQAAOgAOQQEhAgtBACAAIAQbRQRAIAJBAWsiAiADQQ1qaiAEQQF0Qf4BcUHj84kBai0AADoAAAsgAUEBQQFBACADQQ1qIAJqQQMgAmsQgQkgA0EQaiQAC3sCAX8BfgJAIAApAwAiAkIIUQ0AIAKnIgFBBkkNACABQQdGGgJAIAAoAihFDQAgACgCLCIBRQ0AIABBOGogACgCMCAAKAI0IAEoAhARAQALIAAoAjxFDQAgACgCQCIBRQ0AIABBzABqIAAoAkQgACgCSCABKAIQEQEACwuqAQIEfwF+IwBBEGsiBCQAIAAoAggiAUEEaiECAkACQCABQXtNBEAgAiAAKAIEIgNLDQEgBEEEaiICIAAoAgAiACADIAEgACABaigAAGsQ9jQgAkEEEMwgQf//A3EiAgR+IAEgAmoiASADSw0DIAAgAWopAAAFQgALIARBEGokAA8LIAEgAkHQzMwAELE7AAsgAiADQdDMzAAQsDsACyABIANBjMnMABCvOwALtQEBAX8jAEHQAGsiAyQAIAACfyACQQdNBEAgAyACNgI8IANBAjYCKCADQZi1zgA2AiQgA0ICNwIwIANBOzYCTCADQTs2AkQgA0Gwtc4ANgJAIAMgA0FAazYCLCADIANBPGo2AkggA0EIakEEciADQSRqEJkOIAAgAykCFDcCDCAAQRRqIANBHGooAgA2AgAgACADKQIMNwIEQQAMAQsgACABKQAANwMIQQgLNgIAIANB0ABqJAALmwEAAkAgASACQQdxIgFBB2ogASABQQNJG2oiAUEHTwRAQQEgAUEHbiIBIAFBhgggAnZBAXFBNHJLIgEbIQIgACABaiIBQZADbyEADAELQYYIIABBAWsiAUGQA28iAEEfdUGQA3EgAGpB5L+GAWotAAB2QQFxQTRyIQILIABBH3VBkANxIABqQeS/hgFqLQAAIAFBCnQgAkEEdHJyC8MCAgV/AX4jAEGAAWsiAyQAIANBQGshBCABKAIIIQUjAEHwAGsiAiQAAkAgASgCACIGIAEoAgRHBEAgASAGQQRqNgIAIAJBOGogBigCAEEIahDoDCAEAn4gAigCOEEBcQRAIAUQjhIgBUEQaiACQcwAaigCADYCACAFQQhqIAJBxABqKQIANwIAIAUgAikCPDcCAEIADAELIAJBCGogAkFAa0Ew/AoAAEIBCzcDACAEQQhqIAJBCGpBMPwKAAAMAQsgBEICNwMACyACQfAAaiQAAkAgAykDQEICUgRAIANBCGogBEE4/AoAACADKQMIIgenQQFxBEAgAEEIaiADQRBqQTD8CgAAIABCATcDAAwCCyAAQgA3AwAgB1ANASADKAI4IgBFDQEgA0EQaiAAEQMADAELIABCADcDAAsgA0GAAWokAAu8AQEEfyMAQRBrIgMkACABKAIAIgEoAghFBEAgASgCDCEEIAFC/////y83AgggAQJ/IARBAkcEQCABKAIQIQJBAAwBCyADQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAMoAgwhAiADKAIIIQUgASgCFCIGBEAgASgCGCAGKAIMEQMACyABIAI2AhggASAFNgIUIAEoAghBAWoLNgIIIAAgAjYCBCAAIAQ2AgAgA0EQaiQADwtBnKmIARCbPgALpgEBAX8jAEEgayIBJAACf0EKIAAoAgAiAyAAKAIERg0AGiAAIANBBGo2AgAgAUEIaiADKAIAEMYaIAEtAAwiACABKAIIIgNBCEYNABogAigCAEEIRwRAIAIQySMLIAIgADoABCACIAM2AgAgAiABQQhqQQVyIgApAAA3AAUgAkENaiAAQQhqKQAANwAAIAJBFGogAEEPaigAADYAAEEJCyABQSBqJAALqwEBAn8gA0H4////AXEEQCAAIAAgA0F4cSIFaiAAIANBA3YiA0EObCIGaiADIAQQyRghACABIAEgBWogASAGaiADIAQQyRghASACIAIgBWogAiAGaiADIAQQyRghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwurAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBDKGCEAIAEgASAFaiABIAZqIAMgBBDKGCEBIAIgAiAFaiACIAZqIAMgBBDKGCECCyAAIAEgBCgCACgCACgCABECACIDIAAgAiAEKAIAKAIAKAIAEQIAc0EATgR/IAIgASABIAIgBCgCACgCACgCABECACADc0EASBsFIAALC6sBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0ECdCIFaiAAIANBB2wiBmogAyAEEMsYIQAgASABIAVqIAEgBmogAyAEEMsYIQEgAiACIAVqIAIgBmogAyAEEMsYIQILIAAgASAEKAIAKAIAKAIAEQIAIgMgACACIAQoAgAoAgAoAgARAgBzQQBOBH8gAiABIAEgAiAEKAIAKAIAKAIAEQIAIANzQQBIGwUgAAsLqwEBAn8gA0H4////AXEEQCAAIAAgA0EDdiIDQQV0IgVqIAAgA0E4bCIGaiADIAQQzBghACABIAEgBWogASAGaiADIAQQzBghASACIAIgBWogAiAGaiADIAQQzBghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwusAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBnQiBWogACADQfAAbCIGaiADIAQQzRghACABIAEgBWogASAGaiADIAQQzRghASACIAIgBWogAiAGaiADIAQQzRghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwtiAQJ/IwBBEGsiAyQAIANBBGogAUEBQQFBARCgGCADKAIIIQQCQCADKAIEBEAMAQsgAygCDCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAuTAQIDfwN+IAEoAgQiAkELSQRAIAFBCGohAQJAA0AgAkUNASABLQAAIgNB/wBxrSAFhiAGhCEGIAPAIgNBAEgEQCACQQFrIQIgAUEBaiEBIAVCOVQgBUIHfCEFDQELCyADQQBIDQBCASEHIABCACAGQgGDfSAGQgGIhTcDCAsgACAHNwMADwsgAkEKQdCo/gAQsDsAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBoMmEASgCACICNgIAIAFBmMmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSNHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBxMmEASgCACICNgIAIAFBvMmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSZHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpB6MmEASgCACICNgIAIAFB4MmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSRHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpByMqEASgCACICNgIAIAFBwMqEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSVHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7EBAQN/IwBBIGsiAyQAAkAgAigCAARAIAMgASgCECIENgIAIAMgAigCECIFNgIEIAQgBUcNAQsgACABKQIANwIAIAAgAikCADcCFCAAQRBqIAFBEGooAgA2AgAgAEEIaiABQQhqKQIANwIAIABBHGogAkEIaikCADcCACAAQSRqIAJBEGopAgA3AgAgA0EgaiQADwsgA0EANgIIQQAgAyADQQRqIANBCGpBzO6FARCvKwALuAEBAn8jAEEwayIDJAAgAyABNgIQAkAgAigCAARAIAMgAigCECIENgIUIAEgBEcNAQsgA0EIahDBLCAAIAMpAwg3AhAgAEEgOgAMIAAgATYCGCAAIAIpAgA3AhwgAEEANgIIIABCgICAgMAANwIAIABBJGogAkEIaikCADcCACAAQSxqIAJBEGopAgA3AgAgA0EwaiQADwsgA0EANgIYQQAgA0EQaiADQRRqIANBGGpB6PaFARCvKwALtgEBAX8jAEEQayICJAACQCABKALgAUGBgICAeEcEQCACQQRqIAFB4AFqEOMcDAELIAJBADYCBAsCQAJAAkAgASgCoAIoAhQiAUEIaiABKAIIQQJGQQJ0ai0AIA4EAAEBAAELIABBADYCACACKAIEIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAJBBGoQ+x4MAQsgACACKQIENwIAIABBCGogAkEMaigCADYCAAsgAkEQaiQAC7YBAQF/IwBBEGsiAiQAAkAgASgCuAJBgYCAgHhHBEAgAkEEaiABQbgCahDjHAwBCyACQQA2AgQLAkACQAJAIAEoAuwCKAIUIgFBCGogASgCCEECRkECdGotACAOBAABAQABCyAAQQA2AgAgAigCBCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASACQQRqEPseDAELIAAgAikCBDcCACAAQQhqIAJBDGooAgA2AgALIAJBEGokAAu2AQEBfyMAQRBrIgIkAAJAIAEoAsACQYGAgIB4RwRAIAJBBGogAUHAAmoQ4xwMAQsgAkEANgIECwJAAkACQCABKAL0AigCFCIBQQhqIAEoAghBAkZBAnRqLQAgDgQAAQEAAQsgAEEANgIAIAIoAgQiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEEahD7HgwBCyAAIAIpAgQ3AgAgAEEIaiACQQxqKAIANgIACyACQRBqJAALsQEBAn8jAEEQayIEJAAgAUEEaiEFAkAgASgCAEEBRgRAIAIgBSADEIkNRQ0BCwJAIAAoAgAiAgRAIAQgAEEMaiAAKAIEIAAoAgggAigCABEFAAwBCyAEQQA2AgALAkAgASgCAEUNACAFKAIAIgBFDQAgAUEQaiABKAIIIAEoAgwgACgCEBEBAAsgAUEBNgIAIAUgBCkCADcCACAFQQhqIARBCGopAgA3AgALIARBEGokAAuxAQECfyMAQRBrIgQkACABQQRqIQUCQCABKAIAQQFGBEAgAiADIAUQiQ1FDQELAkAgACgCACICBEAgBCAAQQxqIAAoAgQgACgCCCACKAIAEQUADAELIARBADYCAAsCQCABKAIARQ0AIAUoAgAiAEUNACABQRBqIAEoAgggASgCDCAAKAIQEQEACyABQQE2AgAgBSAEKQIANwIAIAVBCGogBEEIaikCADcCAAsgBEEQaiQAC6oBAQJ/IAAoAggiAgRAIAAoAgRBxABqIQADQAJAIABBNGsoAgBFDQAgAEEwaygCACIBRQ0AIABBJGsgAEEsaygCACAAQShrKAIAIAEoAhARAQALAkAgAEEgaygCAEUNACAAQRxrKAIAIgFFDQAgAEEQayAAQRhrKAIAIABBFGsoAgAgASgCEBEBAAsgAEEMaxCFMCAAEIUwIABB0ABqIQAgAkEBayICDQALCwuiAQEGfyAAKAIIIgQEQCAAKAIEIQUDQCAFIAJBBnRqIgFBIGogASgCKCIDBEAgASgCJCEAA0AgABDwEiAAQcACaiEAIANBAWsiAw0ACwtBCEHAAhDgHiABKAIsQYCAgIB4RwRAIAFBLGpBBEEIEOAeCyABKAI8IgAgACgCACIAQQFrNgIAIABBAUYEQCABQTxqEIYfCyACQQFqIgIgBEcNAAsLC7UBAQJ/IwBBMGsiAiQAIAJBDGogARDgLCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAAgAzYCCCAAIAQ2AgQgACABNgIAIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAkEwaiQAC7UBAQJ/IwBBMGsiAiQAIAJBDGogARDeLCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAAgAzYCCCAAIAQ2AgQgACABNgIAIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAkEwaiQAC6wBAQJ/AkAgACgCACIBKAIIIgBFBEAgASgCFCICBEAgASgCEEEQaiEAA0AgACAAQQhrKAIAIABBBGsoAgAgAEEMaygCACgCEBEBACAAQRRqIQAgAkEBayICDQALCyABQQxqQQRBFBDgHgwBCyABQRRqIAEoAgwgASgCECAAKAIQEQEACwJAIAFBf0YNACABIAEoAgQiAEEBazYCBCAAQQFHDQAgAUEcQQQQ+DoLC6QBAQF/AkAgAiAAa0EETgRAIAJBA2shBQNAIAEQ4BsgACAFT3INAiAAIAEgAyAEEIcsOgAAIABBAWogASADIAQQhyw6AAAgAEECaiEADAALAAsgARDgGxoLA0AgARDgGyAAIAJPckUEQCAAIAEgAyAEEIcsOgAAIABBAWohAAwBCwsDQCAAIAJPRQRAIAAgASADIAQQhyw6AAAgAEEBaiEADAELCwvEAQEBfyMAQTBrIgIkAAJ/AkACQAJAAkAgACgCAEEBaw4DAQIDAAsgAiAAQQRqNgIAIAIgAEEIajYCBCACQQI2AgwgAkHMydEANgIIIAJCAjcCFCACQfoKNgIsIAJB+go2AiQgAiACQSBqNgIQIAIgAjYCKCACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMAwsgAUHcydEAQSUQ+zUMAgsgAUGBytEAQSEQ+zUMAQsgAUGiytEAQT4Q+zULIAJBMGokAAuuAQEFfyMAQRBrIgMkACAAKAIcIgJB2ABqIgEQkBUgA0EIaiABEOQlAkAgACgCECIEIAMoAgwiASABIARLGyIBRQ0AIAAoAgwhBSABBEAgBSADKAIIIAH8CgAACyAAIAEgBWo2AgwgACAEIAFrNgIQIAAgACgCFCABajYCFCACIAIoAmAgAWo2AmAgAiACKAJkIgAgAWs2AmQgACABRw0AIAJBADYCYAsgA0EQaiQAC18BAn8jAEEwayICJAAgAkEBNgIMIAIgATYCCAJAIAFFDQAgACgCBCIDQZwLRwRAIAAoAgggAUEEaygAACADEQAADAELIAJBgIAINgIQIAJBEGogARDpJAsgAkEwaiQAC7cBAQJ/IwBBMGsiAyQAIAMgAjYCDCADIAE2AggCQAJAIAFFDQAgACgCBCIEQZwLRwRAIAAoAgggAUEEaygAACAEEQAADAELIAJFDQEgAyACQQF0NgIQIANBEGogARDpJAsgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQdD1/AA2AhAgA0GeCzYCLCADIANBKGo2AhggAyADQQhqNgIoQQEgA0EMakG49fwAIANBEGpB2PX8ABCvKwALXgECfyMAQTBrIgIkACACQQE2AgwgAiABNgIIAkAgAUUNACAAKAIEIgNBnAtHBEAgACgCCCABQQRrKAAAIAMRAAAMAQsgAkHAFjYCECACQRBqIAEQ6SQLIAJBMGokAAusAQECfyMAQRBrIgMkAAJAIAFFBEAgAEEANgIEDAELIAEoAhRFBEAgAEEANgIEDAELIANBBGoiBCABIAIQlQIgAigCPCIBIARBACABENMfIgJHBEAgACADKQIENwIEIAAgASACazYCACAAQQxqIANBDGooAgA2AgAMAQsgAEEANgIEIAMoAgQiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBBGoQ+x4LIANBEGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3iwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ4CwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3ywgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAvbAQEDfyMAQTBrIgIkACACQQxqIgNBCDYCACADIAEoAgQ2AgggAyABKAIIQQR0NgIMIAMgASgCAEEEdDYCBCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgACADNgIIIAAgBDYCBCAAIAE2AgAgAkEwaiQAC9sBAQN/IwBBMGsiAiQAIAJBDGoiA0EENgIAIAMgASgCBDYCCCADIAEoAghBA3Q2AgwgAyABKAIAQQN0NgIEIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACAAIAM2AgggACAENgIEIAAgATYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEN0sIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACAAIAM2AgggACAENgIEIAAgATYCACACQTBqJAAL2wEBA38jAEEwayICJAAgAkEMaiIDQRA2AgAgAyABKAIENgIIIAMgASgCCEEFdDYCDCADIAEoAgBBBXQ2AgQgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ8i8gAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3SwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCAAIAM2AgggACAENgIEIAAgATYCACABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAJBMGokAAvTBgIQfwF+IwBBMGsiBSQAIAVBDGohCiMAQUBqIgIkACACQQhqIAFBKPwKAAAgAigCCCIIEMA8IQQgAigCJCEBIAgQwDwaQcAAIQcCQEF/IAQgAWsiBEEHaiIDIAMgBEkbIgRBA3YiA0HA////AXFBQGsgAyAEQfgDcRsiBEHAABDRNARAAkAgBARAIARBwAAQrTYiB0UNAQsgAkEANgI8IAIgBzYCOCACIAQ2AjQgAkHAADYCMCACQQxqIQsgAigCLCEMIAIoAhghDSACKAIQIQ4gAigCHCEPIAIoAgwhCSACKAIoIQRBACEHQQEhAwNAAkACQAJAAkAgASAERiIQRQRAAn8gCQRAIAEgD08NA0EAIA4gASANaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENARoLIAgoAhAgAUEDdGopAwAiEkKAgICAEFoNAyADQQAgDCASpxCTOxsLIAdyIQcgAUEBaiEBIANBAXQiA0H+AXENBSACIAE2AiQMAwsgAiAENgIkIAQhASADQf8BcUEBRw0CDAMLQZz4gwFBIEG8+IMBEJ8pAAtBtPmDARCyOwALAkAgAigCPCIGIAIoAjRHDQAgCBDAPCEDIAgQwDwaIAIoAjwiBkF/IAMgAWsiA0EHaiIRIAMgEUsbQQN2akEBaiIDIAIoAjRNDQAgAxDVKiEDIAJBMGogAigCNEEBdCIGIAMgAyAGSRsQ6BkgAigCPCEGCyACKAI4IAZqIAc6AABBASEDIAIgBkEBajYCPEEAIQcgEEUNAQsLIAogAikCMDcCACAKQQhqIAJBOGopAgA3AgACQCAJRQ0AIAkgCSgCACIBQQFrNgIAIAFBAUcNACALEPseCyACQUBrJAAMAgtBwAAgBBCjPQALQcz4gwFBKSACQTBqQZj5gwFB+PiDARDVHgALIAUgBSkCDDcCKCAFQQA2AiQgBSAFKAIYIgQ2AiAgBSAFKAIUNgIcIAUgBUEcahDXOyAFKAIAIQJBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAUpAhw3AgggACAENgIIIAAgAjYCBCAAIAE2AgAgAUEQaiAFQSRqKQIANwIAIAFBGGogBUEsaigCADYCACAFQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEOAsIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEPIvIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEN4sIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALsQEBA38jAEEQayIDJABBwAAhBAJAIAFBA3YgAUEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0BEAgAgRAIAJBwAAQrTYiBEUNAgsgACABNgIsIABBADYCKCAAQQA2AhQgAEIANwIMIAAgBDYCCCAAIAI2AgQgAEHAADYCACADQRBqJAAPC0H06YUBQSkgA0EPakHg6oUBQaDqhQEQ1R4AC0HAACACEKM9AAuyAQEBfwJAQQxBBBCtNiIGBEAgBkECNgIIIAYgAzYCACAGIAQgA2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAgASABKAIIIgJBAWo2AgggAkEASA0CIAAgATYCDCAAIAU2AgggACAENgIEIABBgIiIATYCACAGQQxBBBD4Og8LIAAgBjYCDCAAIAU2AgggACAENgIEIABBgIiIATYCAA8LQQRBDBCjPQALAAu9AQEBfyMAQRBrIgckACAAKAIAIAEgAiAAKAIEKAIMEQYAIQEgB0EAOgANIAcgAToADCAHIAA2AgggB0EIaiADIAQgBSAGEIgSIQEgBy0ADSICIActAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIAdBEGokACAAQQFxC7sEAg1/AX4jAEEgayIEJAAgBEEUaiABKAIcIAEoAhRrQQR2IgIgASgCDCABKAIEa0EDdiIFIAIgBUkbQQBBBEEUEKAYIAQoAhghAiAEKAIUQQFGBEAgAiAEKAIcQdC0wgAQ/S8ACyAEQRBqIgtBADYCACAEIAQoAhw2AgwgBCACNgIIIwBB0ABrIgIkACABKAIcIAEoAhRrQQR2IgUgASgCDCABKAIEa0EDdiIDIAMgBUsbIgMgBEEIaiIHKAIAIAcoAggiBWtLBEAgByAFIANBBEEUENAoIAcoAgghBQsgBygCBCEJIAJBCGogAUEo/AoAACACKAIkIgwgAigCHCIBa0EEdiIDIAIoAhQiDSACKAIMIgZrQQN2IgggAyAISRsiCARAIAkgBUEUbGohAwNAIAYgDUcEQCAGKAIAIQkgBkEIaiEGCwJAIAEgDEYEQEEAIQoMAQsgASgCACEKIAJBOGogAUEMaigCADYCACACIAEpAgQ3AzAgAUEQaiEBCyACQcgAaiACQThqKAIAIg42AgAgAiACKQMwIg83A0AgA0EEaiAKNgIAIAMgCTYCACADQQhqIA83AgAgA0EQaiAONgIAIANBFGohAyAFQQFqIQUgCEEBayIIDQALIAIgATYCHCACIAY2AgwLIAcgBTYCCCACIAIoAgg2AkQgAiACKAIQNgJAIAJBQGsQ4zwgAkEYahC7HCACQdAAaiQAIABBCGogCygCADYCACAAIAQpAgg3AgAgBEEgaiQAC6QBAQN/IwBBEGsiAyQAIANBCGogAhDqOgJAIAMoAgwiBSADKAIIIgJGBEAgAEIANwIAIABBCGpCADcCAAwBCyAAIAEoAgggAmoiBCABKAIAIgFBACABIARNG2siBDYCACAFIAJrIgIgASAEayIFTQRAIABCADcCCCAAIAIgBGo2AgQMAQsgAEEANgIIIAAgATYCBCAAIAIgBWs2AgwLIANBEGokAAuiAQEDfyAAKAJoIQEgACgCbCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJYQYCAgIB4RwRAIABBEGpBCBDuKCAAQUBrEN47IABB2ABqEOM8CyAAKAJ8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfwAahDZIQsgACgCcEGAgICAeEcEQCAAQfAAakEEQSAQ4B4LC6UBAQN/IAAoAnghASAAKAJ8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAmhBgICAgHhHBEAgAEEgakEIEO4oIABB0ABqEOk7IABB6ABqEOM8CyAAKAKMASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGMAWoQ2SELIAAoAoABQYCAgIB4RwRAIABBgAFqQQRBIBDgHgsLpwEBA38gACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDjPCAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LC8sBAQJ/IwBBEGsiAiQAIAAoAgAiAEEwaiEDAn8gACgCCEECRgRAIAIgAzYCDCABQZzr0ABBCUHZ6tAAQQogAEEMakGc6tAAQaXr0ABBBiACQQxqQYzr0AAQjhgMAQsgAiAAQTRqNgIIIAFBzOrQAEHZ6tAAQQogAEEIakGc6tAAQePq0ABBDSAAQThqQazq0ABB8OrQAEELIABBLGpBvOrQAEH76tAAQQUgA0G86tAAQYDr0ABBCSACQQhqQfDp0AAQ1xULIAJBEGokAAufAQEDf0EDIQIgACgCBCIBQSBNBEAgACgCCCIDIAAoAhBPBEAgACABQQdxNgIEIAAgAyABQQN2ayIBNgIIIAAgASgAADYCAEEADwsgACgCDCICIANGBEBBAkEBIAFBIEYbDwsgACABIAMgAmsgAUEDdiIBIAMgAWsgAkkiAhsiAUEDdGs2AgQgACADIAFrIgE2AgggACABKAAANgIACyACC6UBAQF/IAAgAmohAwJAAkAgAkEITgRAIAAgAWsiAkF5SA0BCwNAIAAgA08NAiAAIAEtAAA6AAAgAEEBaiEAIAFBAWohAQwACwALAkACQCACQW9LDQAgACADQSBrIgJLDQAgACABIAIgAGsiAEEAENEVIAAgAWohAQwBCyAAIQILA0AgAiADTw0BIAIgAS0AADoAACACQQFqIQIgAUEBaiEBDAALAAsLpAQCCX8BfiMAQSBrIgUkACAFQRRqIAEoAhQgASgCDGtBA3YiAiABKAIEIAEoAgBrQQJ2IgMgAiADSRtBAEEEQQwQoBggBSgCGCECIAUoAhRBAUYEQCACIAUoAhxBvPyBARD9LwALIAVBEGoiCEEANgIAIAUgBSgCHDYCDCAFIAI2AggjAEEgayICJAAgASgCFCABKAIMa0EDdiIDIAEoAgQgASgCAGtBAnYiBCADIARJGyIGIAVBCGoiBCgCACAEKAIIIgNrSwRAIAQgAyAGQQRBDBDeKCAEKAIIIQMLIAQoAgQhBiACQQhqIgkgAUEIaikCADcDACACQRBqIAFBEGopAgA3AwAgAkEYaiABQRhqKQIANwMAIAIgASkCACILNwMAIAQgAigCFCACKAIMa0EDdiIBIAIoAgQgC6drQQJ2IgQgASAESRsiBAR/IAMgBGogBiADQQxsaiEBA0ACQCACKAIAIgMgAigCBEYEQEEAIQMMAQsgAiADQQRqNgIAIAMoAgAiAyADKAIAIgZBAWo2AgAgBkEATg0AAAsgAigCDCIGIAIoAhRGBH9BAAUgAiAGQQhqNgIMIAYoAgQhByAGKAIACyEGIAEgAzYCACABQQhqIAc2AgAgAUEEaiAGNgIAIAFBDGohASAEQQFrIgQNAAsFIAMLNgIIIAkQshwgAkEgaiQAIABBCGogCCgCADYCACAAIAUpAgg3AgAgBUEgaiQAC6sBAQN/IwBBEGsiBCQAAkAgAkEBaiIFIAEoAhxBAnYiA0kEQCACIANJDQEgAiADQcDVhQEQwyEACyAFIANBsNWFARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAEoAhgiASACQQJ0aigCACICIAEgBUECdGooAgAgAmsgAygCIBEFACAEKAIMIQEgACAEKAIINgIAIAAgATYCBCAEQRBqJAALqwEBA38jAEEQayIEJAACQCACQQFqIgUgASgCHEEDdiIDSQRAIAIgA0kNASACIANBwNWFARDDIQALIAUgA0Gw1YUBEMMhAAsgBEEIaiABKAIMIAEoAhAiAygCCEEBa0F4cWpBCGogASgCGCIBIAJBA3RqKAIAIgIgASAFQQN0aigCACACayADKAIgEQUAIAQoAgwhASAAIAQoAgg2AgAgACABNgIEIARBEGokAAuZHwMUfwN+AXwjAEEQayINJAAgAC0ADCEVIA1BBGohDyMAQSBrIg4kAAJAAkACQCAAKAIIBEAgDkEIaiEQIwBBgAFrIgIkAAJAAkACQAJAAkACQAJAAkACQCAAKAIIIgMEQCAAKAIEIANBAnRqQQRrIghFDQQgAkHYAGoiBAJ/QQAgA61CBYYgCCgCAGetfbpEcaN5CU+TCkCjmyIZRAAAAAAAAPC/ZEUNABpBACAZRAAAAAAAAPBBY0UNABogGasLQQBBAUEBEKAYIAIoAlwhAyACKAJYQQFGDQMgAkEANgIkIAIgAigCYDYCICACIAM2AhwgAkEoaiAAEOkdIAIoAjAiCEHAAEkNBiACQeAAaiISQeyOiAEoAgA2AgAgAkHkjogBKQIANwNYIARB8I6IARCdKCACKAJcQZDOADYCACACQUBrIgVBATYCACACIAIpA1g3AzgCfwJAAkACQAJAAkAgAigCMCIEQQRPBEAgBLif/AMiCEUNASAIIAQgCG4gCGpBAXYiA0kNAiADIQAMAwsgBEEARyEIDAMLQdSniAEQ4isACwNAIAMgBCADbiADakEBdiIASSADIQggACEDDQALCyAAIAhPDQADQCAAIghFDQIgCCAEIABuIABqQQF2IgBLDQALCyAIDAELQdSniAEQ4isACyIEIAUoAgAiA0sNAUEBIQgMAgtBAUEBEK02IgBFDQQgEEEBNgIIIBAgADYCBCAQQQE2AgAgAEEAOgAADAYLQQEhCANAIAIoAjwhAAJAAkACQAJAIAMOAgABAgsgAkH4AGpB7I6IASgCADYCACACQeSOiAEpAgA3A3AMAgsgACgCACEAIAJB2ABqIgMgAkE4ahDpHSADIAAQ4w4gAkH4AGogEigCADYCACACIAIpAlg3A3AMAQsgAkHwAGogACADIAAgAxCjEQsgAkE4akEEQQQQ4B4gBSACQfgAaigCACIDNgIAIAIgAikDcDcDOCAIQQF0IQggAyAESQ0ACwsgAkHkAGohFANAAkACQCADIAIoAjAiAEYEQCACKAIsQQRrIQAgA0ECdCEDIAIoAjxBBGshBANAIANFDQIgAyAEaiEFIAAgA2ogA0EEayEDKAIAIgYgBSgCACIFRg0ACyAFIAZPDQEMAgsgACADSw0BCyACQThqQQRBBBDgHiACKAIwIQgMBQsgAkHYAGohBSACQShqIhEhACMAQeAAayIEJAACQAJAAkACQCACQThqIgcoAggiAwRAIAAoAggiBkUNAQJAAkACQAJAIANBAUYEQCAHKAIEIgYoAABBAUYNASAEQdQAaiIDIAAQ6R0gBEEwaiELIAYoAgAhAEEAIQlCACEWIwBBIGsiBiQAAkAgAARAIAMoAgghByADKAIEIQoCQCAAQYCABE8EQCAHDQEMAwsgB0UNAiAKQQRrIQogB0ECdCEHA0AgByAKaiIMIAwoAgAiDEEQdiITIBMgCUEQdHIgAG4iCSAAbGtBEHQgDEH//wNxciIMIABuIhMgCUEQdHI2AgAgDCAAIBNsayEJIAdBBGsiBw0ACwwCCyAKQQRrIQkgB0ECdCEHIACtIRcDQCAHIAlqIgAgADUCACAWQiCGhCIWIBeAIhg+AgAgFiAXIBh+fSEWIAdBBGsiBw0ACyAWpyEJDAELIAZBADYCGCAGQQE2AgwgBkGQo4gBNgIIIAZCBDcCECAGQQhqQZijiAEQ7ywACyAGQRBqIANBCGooAgAiADYCACAGIAMpAgA3AwgCQCAARQ0AIAYoAgwiByAAQQJ0IgNqQQRrIgpFDQAgCigCAA0AIAdBBGshCiAAQf////8DcSEHAkADQCADRQRAQQAhAwwCCyAHQQFrIQcgAyAKaiADQQRrIQMoAgBFDQALIAdBAWoiAyAASw0BCyAGIAM2AhAgAyEACwJAIAAgBigCCEECdk8NACAGIAZBCGogAEEEQQQQ9BQgBigCACIAQYGAgIB4Rg0AIAAgBigCBEH0pIgBEP0vAAsgCyAGKQMINwIAIAtBCGogBkEQaigCADYCACALIAk2AgwgBkEgaiQAIARBCGoiBiAEQThqIgAoAgA2AgAgBCAEKQIwNwMAIAQoAjwhAyAAQbCjiAEoAgA2AgAgBEGoo4gBKQIANwMwIAMEQCALQdSkiAEQnSggBCgCNCADNgIAIARBATYCOAsgBSAEKQMwNwIMIAVBFGogACgCADYCACAFQQhqIAYoAgA2AgAgBSAEKQMANwIADAkLIAMgBkcEfyADIAZJIAMgBktrBSADQQJ0IQYgACgCBEEEayEKIAcoAgRBBGshDANAIAZFDQQgBiAMaiEJIAYgCmogBkEEayEGKAIAIgsgCSgCACIJRg0ACyAJIAtJIAkgC0trC0H/AXEOAgIDAQsgBSAAEOkdIAVBFGpBsKOIASgCADYCACAFQaijiAEpAgA3AgwMBwsgBUEMaiAAEOkdIAVBCGpBsKOIASgCADYCACAFQaijiAEpAgA3AgAMBgtBBEEEEK02IgBFDQMgBUEBNgIIIAUgADYCBCAFQQE2AgAgAEEBNgIAIAVBqKOIASkCADcCDCAFQRRqQbCjiAEoAgA2AgAMBQsgBygCBCIGIANBAnRqQQRrIgtFDQMgCygCACILZyIJRQRAIARBMGoiByAAEOkdIAUgByAGIAMQjwQMBQsgBCAANgI0IARBgICAgHg2AjAgBEHIAGoiCiAEQTBqIgAgC0UiAyAJQR9xIgYQqAUgBCAHNgI0IARBgICAgHg2AjAgBEHUAGoiByAAIAMgBhCoBSAAIAogBCgCWCAEKAJcEI8EIARBGGogBEE4aigCADYCACAEQShqIARBxABqKAIANgIAIAQgBCkCMDcDECAEIAQpAjw3AyAgB0EEQQQQ4B4CQCAEKAIkIgcgBEEgaiILIAQoAiAiCUGAgICAeEYiChsoAggEQCAAIAsgAyAGEJUJDAELIApFBEAgBCAEKAIoNgI4IAQgBzYCNCAEIAk2AjAMAQsgBEEwaiAHEOkdCyAFIAQpAxA3AgAgBSAEKQIwNwIMIAVBCGogBEEYaigCADYCACAFQRRqIARBOGooAgA2AgAMBAsgBEEANgJAIARBATYCNCAEQZCjiAE2AjAgBEIENwI4IARBMGpBxKOIARDvLAALIAVBCGpBsKOIASgCACIANgIAIAVBqKOIASkCACIWNwIAIAUgFjcCDCAFQRRqIAA2AgAMAgtBBEEEEKM9AAtBtKOIARCyOwALIARB4ABqJAAgAkHQAGoiACASKAIANgIAIAIgAikCWDcDSCACQfgAaiILIBRBCGooAgA2AgAgAiAUKQIANwNwIBFBBEEEEOAeIAJBMGogACgCADYCACACIAIpA0g3AyggCARAQQAhBgNAIAIoAnQhBSACKAJwIQdBACEDIAIoAngiBARAIAVBBGshCSAEQQJ0IQADQCAAIAlqIgogCigCACIKQRB2IhEgESADQRB0ckGQzgBuIgNBkM4AbGtBEHQgCkH//wNxciIKQZDOAG4iESADQRB0cjYCACAKIBFBkM4AbGshAyAAQQRrIgANAAsLIAIgBDYCYCACIAc2AlggAiAFNgJcAkAgBEUNACAFIARBAnQiAGpBBGsiCUUNACAJKAIADQAgBUEEayEJIARB/////wNxIQUCQANAIABFBEBBACEADAILIAVBAWshBSAAIAlqIABBBGshACgCAEUNAAsgBUEBaiIAIARLDQELIAIgADYCYCAAIQQLAkAgBCAHQQJ2Tw0AIAJBCGogAkHYAGogBEEEQQQQ9BQgAigCCCIAQYGAgIB4Rg0AIAAgAigCDEGAoogBEP0vAAsgCyASKAIANgIAIAIgAikCWDcDcEEAIQAgAigCJCEFA0AgAyADQQpuIgNBCmxrIQcgACAFaiIEIAIoAhxGBEAgAkEcakHwkIgBEKkZCyAEIAIoAiBqIAc6AAAgAiAEQQFqNgIkIABBAWoiAEEERw0ACyAGQQFqIgYgCEcNAAsLIAJB8ABqQQRBBBDgHiACKAJAIQMMAAsACyADIAIoAmBBgJCIARD9LwALQfChiAEQsjsAC0EBQQEQoz0ACyAIQQJPBEADQEEAIQMgAigCLCEFIAIoAighBiAIQQJ0IgQhAANAIABBBGsiACAFaiIHIAcoAgAiB0EQdiILIAsgA0EQdHJBkM4AbiIDQZDOAGxrQRB0IAdB//8DcXIiB0GQzgBuIgsgA0EQdHI2AgAgByALQZDOAGxrIQMgAA0ACyACIAY2AlggAiAINgJgIAIgBTYCXAJAIAUgCEECdGpBBGsiAEUNACAAKAIADQAgBUEEayEFIAghAAJAA0AgBEUEQEEAIQAMAgsgAEEBayEAIAQgBWogBEEEayEEKAIARQ0ACyAAQQFqIgAgCEsNAQsgAiAANgJgIAAhCAsCQCAIIAZBAnZPDQAgAiACQdgAaiAIQQRBBBD0FCACKAIAIgBBgYCAgHhGDQAgACACKAIEQYCiiAEQ/S8ACyACQfgAaiIEIAJB4ABqKAIANgIAIAIgAikCWDcDcEEAIQAgAigCJCEFA0AgAyADQQpuIgNBCmxrIQYgACAFaiIIIAIoAhxGBEAgAkEcakHQkIgBEKkZCyAIIAIoAiBqIAY6AAAgAiAIQQFqNgIkIABBAWoiAEEERw0ACyACQTBqIAQoAgAiCDYCACACIAIpA3A3AyggCEEBSw0ACwsgCEUNASACKAIsKAIAIgMEQCACKAIkIQADQCADIANBCm4iCEEKbGshBCACKAIcIABGBEAgAkEcakGwkIgBEKkZCyACKAIgIABqIAQ6AAAgAiAAQQFqIgA2AiQgA0EKSSAIIQNFDQALCyAQIAIpAhw3AgAgEEEIaiACQSRqKAIANgIAIAJBKGpBBEEEEOAeCyACQYABaiQADAELQQBBAEGQkIgBEMMhAAsgDigCECIDBEAgDigCDCEAA0AgACAALQAAIghBMHIgCEHXAGogCEEKSRs6AAAgAEEBaiEAIANBAWsiAw0ACwsgDyAOKQIINwIAIA9BCGogDkEQaigCADYCAAwBC0EBQQEQrTYiAEUNASAPQQE2AgggDyAANgIEIA9BATYCACAAQTA6AAALIA5BIGokAAwBC0EBQQEQoz0ACyANKAIMIgNBAk8EQCADQQF2IQggAyANKAIIIgBqQQFrIQMDQCAALQAAIQQgACADLQAAOgAAIAMgBDoAACADQQFrIQMgAEEBaiEAIAhBAWsiCA0ACwsgASAVQQBHQQFBACANKAIIIA0oAgwQgQkgDUEEakEBQQEQ4B4gDUEQaiQAC5IBAQJ/IwBBIGsiBiQAIAZCACABfSABIAJCAFMiBRtCACACIAFCAFKtfH0gAiAFG0IAIAN9IAMgBEIAUyIFG0IAIAQgA0IAUq18fSAEIAUbEKcGIAYpAwghASAAQgAgBikDACIDfSADIAIgBIVCAFMiBRs3AwAgAEIAIAEgA0IAUq18fSABIAUbNwMIIAZBIGokAAusAQECfyMAQTBrIgIkACACIAE2AgAgAkEBNgIUIAJBmOzDADYCECACQgE3AhwgAkHaADYCLCACIAJBKGo2AhggAiACNgIoIAJBBGogAkEQahCZDkEMQQQQrTYiAQRAIAEgAikCBDcCACABQQhqIAJBDGooAgA2AgAgAigCACIDQYQBTwRAIAMQ8h8LIABBvOjDADYCBCAAIAE2AgAgAkEwaiQADwtBBEEMEKM9AAu2AQEBfyMAQRBrIgQkAAJAAkAgASACckEATiADIAGsWnFFBEAgBEEEakETQQBBAUEBEKAYIAQoAgghAiAEKAIEQQFGDQIgBCgCDCIBQQ9qQYOAzgAoAAA2AAAgAUEIakH8/80AKQAANwAAIAFB9P/NACkAADcAACAAQRM2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMAQsgAEEINgIACyAEQRBqJAAPCyACIAQoAgxBtPXNABD9LwALqwEBA38gACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAakEEQQwQ4B4gAEH4AGoQ4zwLIAAoApwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZwBahDZIQsgACgCkAFBgICAgHhHBEAgAEGQAWpBBEEgEOAeCwulAQEFfyMAQRBrIgIkACACIAAgACgCDBD4GCACKAIIIQMgAigCDCEEIAAoAgQhBSACKAIEIgEgAigCACIARwRAIAEgAGshASAFIABBiAFsaiEAA0AgABCfHyAAQYgBaiEAIAFBAWsiAQ0ACwsgAyAERwRAIAQgA2shASAFIANBiAFsaiEAA0AgABCfHyAAQYgBaiEAIAFBAWsiAQ0ACwsgAkEQaiQAC7EBAQN/IwBBIGsiAiQAIAEoAgghAyABKAIMIQQgAiABKQIANwIYIAJBADYCFCACIAQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALnQEBBH8gAS0AFCIDQRFHBEAjAEEQayECAkACQAJAIANBBGsOBQECAAABAgsgAS0AFSEEIAEtABYhBQwBCyACQQhqIAFBH2otAAA6AAAgAiABKQAXNwMAIAEtABYhBSABLQAVIQQLIAAgBToAAiAAIAQ6AAEgACADOgAAIAAgAikDADcAAyAAQQtqIAJBCGotAAA6AAAPCyAAQRE6AAALtwEBA38jAEEQayICJAACQAJAAkAgAUEEaiIDQfz1zwAQiDsiBA0AIANBgPbPABCIOw0AIAJBBGpBJEEAQQFBARCgGCACKAIIIQEgAigCBEEBRg0BIAIoAgwiA0GE9s8AQST8CgAAIABBJDYCDCAAIAM2AgggACABNgIEIABBADYCAAwCCyAAIAQ6AAggAEEINgIAIAAgASgAADYCBAwBCyABIAIoAgxBsOjPABD9LwALIAJBEGokAAu2AQEBfyMAQRBrIgQkACAEQQhqIAEgAiADEOESAkACQCAELQAIIgFBBEcEQAJ/AkACQAJAIAFBAWsOAwABAgULIAQtAAkMAgsgBCgCDC0ACAwBCyAEKAIMLQAIC0H/AXFBI0cNASAAQQQ6AAAgAEEANgIEIARBCGoQuS4MAgsgBCgCDCIBRQRAIABCgcoANwIADAILIABBBDoAACAAIAE2AgQMAQsgACAEKQMINwIACyAEQRBqJAALrAEBAn8jAEEQayIDJAAgASABQRBrIgQgAigCACICKAIAKAIAEQIAQQBIBEAgA0EIaiABQQhqKQAANwMAIAMgASkAADcDAANAAkAgBCIBQRBqIAEpAAA3AAAgAUEYaiABQQhqKQAANwAAIAAgAUYNACADIAFBEGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMpAwA3AAAgAUEIaiADQQhqKQMANwAACyADQRBqJAALtAEBAn8jAEEwayIDJAAgAyACNgIMIAMgATYCCAJAAkAgAUUNACAAKAIEIgRBnAtHBEAgACgCCCABQQRrKAAAIAQRAAAMAQsgAkUNASADIAI2AhAgA0EQaiABEOkkCyADQTBqJAAPCyADQgE3AhwgA0EBNgIUIANB0PX8ADYCECADQZ4LNgIsIAMgA0EoajYCGCADIANBCGo2AihBASADQQxqQbj1/AAgA0EQakHY9fwAEK8rAAu0AQECfyMAQTBrIgMkACADIAI2AgwgAyABNgIIAkACQCABRQ0AIAAoAgQiBEGcC0cEQCAAKAIIIAFBBGsoAAAgBBEAAAwBCyACRQ0BIAMgAjYCECADQRBqIAEQ6SQLIANBMGokAA8LIANCATcCHCADQQE2AhQgA0HQ9fwANgIQIANBoAs2AiwgAyADQShqNgIYIAMgA0EIajYCKEEBIANBDGpBuPX8ACADQRBqQdj1/AAQrysAC6oBAQZ/IAEoAgQhAyABKAIAIQYCQCAAKAIAIgQgACgCBCICRwRAIAAoAgwhBSAAKAIIIQcgASgCCCADQQR0aiEAIAIgBGtBAnYhAQNAIAQoAgAiAiAFTw0CIAAgByACQQR0aiICKQMANwMAIAAgAikDCDcDCCAEQQRqIQQgAEEQaiEAIANBAWohAyABQQFrIgENAAsLIAYgAzYCAA8LIAIgBUH0toIBEMMhAAuqAQEGfyABKAIEIQMgASgCACEGAkAgACgCACIEIAAoAgQiAkcEQCAAKAIMIQUgACgCCCEHIAEoAgggA0EEdGohACACIARrQQN2IQEDQCAFIAQoAgAiAk0NAiAAIAcgAkEEdGoiAikDADcDACAAIAIpAwg3AwggBEEIaiEEIABBEGohACADQQFqIQMgAUEBayIBDQALCyAGIAM2AgAPCyACIAVB9LaCARDDIQALqgEBBn8gASgCBCEDIAEoAgAhBgJAIAAoAgAiBCAAKAIEIgJHBEAgACgCDCEFIAAoAgghByABKAIIIANBBHRqIQAgAiAEa0ECdiEBA0AgBCgCACICIAVPDQIgACAHIAJBBHRqIgIpAwA3AwAgACACKQMINwMIIARBBGohBCAAQRBqIQAgA0EBaiEDIAFBAWsiAQ0ACwsgBiADNgIADwsgAiAFQby0ggEQwyEAC5sBAQN/IAAoAhAgAWohAyAAKAIEIQRBACEBIAAoAghBAXYiACECAkACQAJAIAAOAgIBAAsDQCABIABBAXYiAiABaiIBIAQgAUEBdGouAQAgA8FKGyEBIAAgAmsiAEEBSw0ACwsgBCABQQF0ai8BACIAIANB//8DcUYEQCABIQBBASECDAELIAEgAMEgA8FIaiEAQQAhAgsgACACagu1AQEDfyMAQSBrIgIkACABKAIEIQMgASgCCCEEIAIgASgCADYCHCACQoCAgIAQNwIUIAIgBDYCECACIAM2AgwgAiACQQxqENc7IAIoAgAhA0EcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCDDcCCCAAIAQ2AgggACADNgIEIAAgATYCACABQRBqIAJBFGopAgA3AgAgAUEYaiACQRxqKAIANgIAIAJBIGokAAulAQEDfyMAQRBrIgIkACAAQRhqENQeIAAoAggiAwR/IAAoAgQhASADQQxsIQMDQCABENQeIAFBDGohASADQQxrIgMNAAsgACgCCAVBAAshAQJAIAEgACgCAEkEQCACQQhqIAAgAUEEQQwQ9BQgAigCCCIBQYGAgIB4Rw0BCyAAKAIkBEAgAEEkahDUHgsgAkEQaiQADwsgASACKAIMQfzMhQEQ/S8AC6sBAQN/IwBBEGsiAiQAIABBGGoQ1B4gACgCJARAIABBJGoQ1B4LIAAoAghBA3QhAyAAKAIEIQEDQAJAIAMEQCABKAIARQ0BIAEQ+SMMAQsCQCAAKAIIIgEgACgCAE8NACACQQhqIAAgAUEEQQgQ9BQgAigCCCIAQYGAgIB4Rg0AIAAgAigCDEHUiIYBEP0vAAsgAkEQaiQADwsgAUEIaiEBIANBCGshAwwACwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBAXQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQF0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBBXQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQV0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBA3QiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQN0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBAnQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQJ0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBBHQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQR0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALmgICA38CfiMAQfADayIEJAAgBEEIaiIFIAAQlRogBCABIAIQ+iggBEGgAWoiACAEKAIAIAQoAgQQjzUgA0EJSQRAIARBrAFqIgIgABCkKCAEQbgBaiIAIAVBmAH8CgAAIARB2AJqIwBBQGoiASQAIAEgAEFAayACEK8QAn8gASgCCCICQYCAgIB4RwRAIAEoAhQgASkDACABKQIMIQggAUGChIzIADYCOCABQQg2AjAgAUEANgIoIAFCADcDECABIAg3AgQgASACNgIAIAEQ2RMMAQsgASgCAAtBMGsgAxCUJCAAQZgB/AoAACABQUBrJAAgBEEANgLQAiAEQdACahDRKUEIaiAEQfADaiQADwtB5ILDAEEZEJc9AAuaAgIDfwJ+IwBB8ANrIgQkACAEQQhqIgUgABCVGiAEIAEgAhD6KCAEQaABaiIAIAQoAgAgBCgCBBCPNSADQQNJBEAgBEGsAWoiAiAAEKQoIARBuAFqIgAgBUGYAfwKAAAgBEHYAmojAEFAaiIBJAAgASAAQUBrIAIQrxACfyABKAIIIgJBgICAgHhHBEAgASgCFCABKQMAIAEpAgwhCCABQYKEjMgANgI4IAFBCDYCMCABQQA2AiggAUIANwMQIAEgCDcCBCABIAI2AgAgARDZEwwBCyABKAIAC0EGayADOgAAIABBmAH8CgAAIAFBQGskACAEQQA2AtACIARB0AJqENEpQQhqIARB8ANqJAAPC0HkgsMAQRkQlz0AC6YBAQR/IwBBEGsiAiQAIAJBADYCDCACIAE2AggCQCABKAIIBEAgAUEQaiEEA0AgAUEBOgAMIAIgAkEIahD+KSAEIAIoAgAiBSAFIAIoAgQiA2oQwCYgAUEAOgAMIANFBEAgAEKCgICAwPCwCDcCAAwDCyACIAIoAgwgA2oiAzYCDCADIAIoAggoAghJDQALCyAAQQQ6AAALIAJBCGoQxCMgAkEQaiQAC6QBAQV/IAAoAgQhAyAAKAIAIQEgACgCFCECAkACQCAAKAIQIgQgACgCDEkEQCAAKAIIIARBA3RqIgUoAgAgAkYNASABIANHDQIDQAwACwALIAEgA0cNAUGAgMQADwsgACACQQFqNgIUIAAgBEEBajYCECAFKAIEDwsgACACQQFqNgIUIAAgAUEBajYCACABLQAAIgBBwQBrQf8BcUEaSUEFdCAAcgusAQICfwN+IAEoAgQiBK0hBgJAAkAgBEL/////DyABKQMIIgcgB0L/////D1obp2siBUEAIAQgBU8bIANPBEAgASgCACAHIAYgBiAHVhunaiEEAkAgA0EBRwRAIANFDQEgAiAEIAP8CgAADAELIAIgBC0AADoAAAsgAEEEOgAADAELIABBuLjMACkDACIINwIAIAhC/wGDQgRSDQELIAcgA618IQYLIAEgBjcDCAuYAQEHfyABQQRPBEAgAUECdiEJA0AgACAFaiEKIAciBEEBaiEHQQAhBgJAAkADQCAFIAZqIgggAU8NASADIARLBEAgAiAEaiAGIApqLQAAOgAAIAQgCWohBCAGQQFqIgghBiAIQQRGDQMMAQsLIAQgA0GU6s4AEMMhAAsgCCABQYTqzgAQwyEACyAFQQRqIQUgByAJRw0ACwsLmAEBB38gAUEITwRAIAFBA3YhCQNAIAAgBWohCiAHIgRBAWohB0EAIQYCQAJAA0AgBSAGaiIIIAFPDQEgAyAESwRAIAIgBGogBiAKai0AADoAACAEIAlqIQQgBkEBaiIIIQYgCEEIRg0DDAELCyAEIANBlOrOABDDIQALIAggAUGE6s4AEMMhAAsgBUEIaiEFIAcgCUcNAAsLC5kBAQJ/IwBBQGoiBCQAIARBBGogARDSBiAEQRBqIgUgAUEMaiACIAMQhxggASgCPCICIAIoAgAiA0EBajYCACADQQBOBEAgACAEKQIENwIAIABBCGogBEEMaigCADYCACABKAJAIQMgAS0ARCEBIABBDGogBUEw/AoAACAAIAE6AEQgACADNgJAIAAgAjYCPCAEQUBrJAAPCwALmQEBAn8jAEFAaiIEJAAgBEEEaiABENIGIARBEGoiBSABQQxqIAIgAxCGGCABKAI8IgIgAigCACIDQQFqNgIAIANBAE4EQCAAIAQpAgQ3AgAgAEEIaiAEQQxqKAIANgIAIAEoAkAhAyABLQBEIQEgAEEMaiAFQTD8CgAAIAAgAToARCAAIAM2AkAgACACNgI8IARBQGskAA8LAAuZAQECfyMAQUBqIgQkACAEQQRqIAEQ0gYgBEEQaiIFIAFBDGogAiADEIkYIAEoAjwiAiACKAIAIgNBAWo2AgAgA0EATgRAIAAgBCkCBDcCACAAQQhqIARBDGooAgA2AgAgASgCQCEDIAEtAEQhASAAQQxqIAVBMPwKAAAgACABOgBEIAAgAzYCQCAAIAI2AjwgBEFAayQADwsAC5kBAQJ/IwBBQGoiBCQAIARBBGogARDSBiAEQRBqIgUgAUEMaiACIAMQiBggASgCPCICIAIoAgAiA0EBajYCACADQQBOBEAgACAEKQIENwIAIABBCGogBEEMaigCADYCACABKAJAIQMgAS0ARCEBIABBDGogBUEw/AoAACAAIAE6AEQgACADNgJAIAAgAjYCPCAEQUBrJAAPCwALtwEBAn8jAEFAaiIDJAAgAyACNgIIIAEoAiBBBHYiBCACTQRAIAMgBDYCJCADQQM2AhAgA0HEyoUBNgIMIANCAzcCGCADQTs2AjwgA0HHAjYCNCADQfjJhQE2AjAgA0E7NgIsIAMgA0EoajYCFCADIANBJGo2AjggAyADQQhqNgIoIANBDGpB3MqFARDvLAALIAMgASACEKwfIAMoAgQhASAAIAMoAgA2AgAgACABNgIEIANBQGskAAu3AQECfyMAQUBqIgMkACADIAI2AgggASgCIEEEdiIEIAJNBEAgAyAENgIkIANBAzYCECADQcTKhQE2AgwgA0IDNwIYIANBOzYCPCADQccCNgI0IANB9MqFATYCMCADQTs2AiwgAyADQShqNgIUIAMgA0EkajYCOCADIANBCGo2AiggA0EMakHcyoUBEO8sAAsgAyABIAIQrB8gAygCBCEBIAAgAygCADYCACAAIAE2AgQgA0FAayQAC5QBAQJ/IABBAE4EfyAABSABQS06AAAgAUEBaiEBQQAgAGsLIgJB4wBMBEAgAkEJTARAIAEgAkEwajoAACAAQR92QQFqDwsgASACQQF0QYjQiAFqLwAAOwAAIABBH3ZBAnIPCyABIAJB5ABuIgNBMGo6AAAgASACIANB5ABsa0EBdEGI0IgBai8AADsAASAAQR92QQNqC5gBAQR/IwBBIGsiAiQAAkBBCCAAKAIAIgVBAXQiBCAEQQhNGyIEQQBOBH8gAiAFBH8gAiAFNgIcIAIgACgCBDYCFEEBBSADCzYCGCACQQhqIAQgAkEUahCiGyACKAIIQQFHDQEgAigCECEDIAIoAgwFIAMLIAMgARD9LwALIAIoAgwhASAAIAQ2AgAgACABNgIEIAJBIGokAAuQAQEFfwJAIAEoAgAiBCABKAIEIgJGDQAgBC0AACIDQcEAa0FfcUEKaiADQTBrIANBOUsbIgZBD0sNACACIARBAWoiAkYNACACLQAAIgJBwQBrQV9xQQpqIAJBMGsgAkE5SxsiAkEPSw0AIAEgBEECajYCACAGQQR0IAJyIQNBASEFCyAAIAM6AAEgACAFOgAAC6IBAgJ/An4jAEEgayIDJAACQCABKQMYIgVQBEBBACECDAELIAEgAkIgIAUgBUIgWhunIgIgASgCCCIEIAIgBEkbIgIQlxogASkDGCIFIAKtIgZUBEAgA0EANgIYIANBATYCDCADQbjyzQA2AgggA0IENwIQIANBCGpBwPLNABDvLAALIAEgBSAGfTcDGAsgAEEEOgAAIAAgAjYCBCADQSBqJAALrQIBBn8jAEEwayIFJAAjAEEgayIEJAAgBEEUaiACIANBBHRqIgYgAmtBBHZBAEEEQQQQoBggBCgCGCEHIAQoAhRBAUYEQCAHIAQoAhxBoIPOABD9LwALIAVBDGohCCAEQRBqIglBADYCACAEIAQoAhw2AgwgBCAHNgIIIARBCGogBiACa0EEdhDuLSACIAZHBEBBjOrQABCyOwALIAhBCGogCSgCADYCACAIIAQpAgg3AgAgBEEgaiQAIAVBGGogASAFKAIQIAUoAhQQzxECQCAFKAIYIgFBCEcEQCAAIAUpAhw3AgQgAEEUaiAFQSxqKAIANgIAIABBDGogBUEkaikCADcCAAwBCyADRQ0AQeSgzgAQsjsACyAAIAE2AgAgBUEMahDpOyAFQTBqJAALlAQBCH8jAEFAaiIDJAACfyABRQRAIANBADYCKCADQoCAgIAgNwIgIANBCGogA0EgakGMh84AEKEhIAMoAgghAiADKAIMDAELIANBOGpCADcDACADQTBqQgA3AwAgA0EoakIANwMAIANCADcDICMAQSBrIgEkACABQRRqIAJBAEECQSAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxBxJ7QABD9LwALIANBFGohCCABQRBqIgpBADYCACABIAEoAhw2AgwgASAENgIIIANBIGohBiABQQhqIgcoAgAgBygCCCIFayACSQRAIAcgBSACQQJBIBDQKCAHKAIIIQULIAcoAgQgBUEFdGohBAJAAkAgAkECTwRAIAJBAWshCQNAIAQgBikBADcBACAEQRhqIAZBGGopAQA3AQAgBEEQaiAGQRBqKQEANwEAIARBCGogBkEIaikBADcBACAEQSBqIQQgCUEBayIJDQALIAIgBWpBAWshBQwBCyACRQ0BCyAEIAYpAQA3AQAgBEEYaiAGQRhqKQEANwEAIARBEGogBkEQaikBADcBACAEQQhqIAZBCGopAQA3AQAgBUEBaiEFCyAHIAU2AgggCEEIaiAKKAIANgIAIAggASkCCDcCACABQSBqJAAgAyAIQcyCzgAQoSEgAygCACECIAMoAgQLIQEgACACNgIAIAAgATYCBCADQUBrJAALqAEBAn8jAEFAaiIDJAAgAiABKAIUIgRNBEAgA0EMaiABKAIQIAJqIAQgAmsQnQlBCCECIAAgAygCDEEBRgR/IAMgAykCEDcDGCADQQE2AiQgA0GA0dAANgIgIANCATcCLCADQbADNgI8IAMgA0E4ajYCKCADIANBGGo2AjggAEEEaiADQSBqEJkOQQAFIAILNgIAIANBQGskAA8LIAIgBEHYytAAEK87AAutAQEBfyMAQSBrIgUkAAJAIANBEWwgBEH/AXFqQQh0QYACaiIDIAJNBEAgAiADa0H/AU0NASAAQYACNgIEIAAgASADQQF0ajYCACAFQSBqJAAPCyAFQQA2AhggBUEBNgIMIAVBgPDRADYCCCAFQgQ3AhAgBUEIakHI8NEAEO8sAAsgBUEANgIYIAVBATYCDCAFQYDw0QA2AgggBUIENwIQIAVBCGpB2PDRABDvLAALnwEBAX8CQCAGIANBA3YiB0sEQCAEIAM2AgAgBSAHaiIHIActAABBfyADQQdxdEF/c3E6AAAgAkEBIAQgBSAGEOgjIAUgBiAEKAIAQQdqIgNBA3YgACABIAIQiR8gBCADQXhxIAJBA3RqIgA2AgAgAEEDdiIAIAZJDQEgACAGQcSV8wAQwyEACyAHIAZBtJXzABDDIQALIAAgBWpBADoAAAu3AQEDfyAAIAAoArgPIgFBBnQiAjYC9A8gAUEFdiEDAkACQCABQf8BTQRAIAAgACADQQJ0aigCwA0gAXZBAXE2AoAQIAIgACgC/A4iA08NASAAIAAoAvgOIAJqLQAAOgCEESABIAAoAoQPIgJPDQIgACAAKAKADyABai0AAEEDcUEJdEHEq/sAajYC6BAPCyADQQhBtKXzABDDIQALIAIgA0HEpfMAEMMhAAsgASACQdSl8wAQwyEAC7sBAQF/IwBBMGsiBSQAIAACfyABKAIAIAIQhyVFBEAgASACEM4aIQEgBUGEETYCKCAFIAE7AS4gBUEBNgIQIAVBtJP/ADYCDCAFQgE3AhggBSAFQS5qNgIkIAUgBUEkajYCFEGTgICAeEGUgICAeCADIAVBDGogBCgCFBECABsMAQtBlICAgHggASgCCCICRQ0AGkGTgICAeEGUgICAeCADIAEoAgQgAiAEKAIMEQYAGws2AgAgBUEwaiQAC6kBAQJ/IwBBEGsiBCQAAkAgASgCHEEDdiIDIAJLBEAgAiABKAIoQQN2IgNJDQEgAiADQYSVhgEQwyEACyACIANB9JSGARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAJBA3QiAiABKAIYaigCACABKAIkIAJqKAIAIAMoAiARBQAgBCgCDCEBIAAgBCgCCDYCACAAIAE2AgQgBEEQaiQAC6kBAQJ/IwBBEGsiBCQAAkAgASgCHEECdiIDIAJLBEAgAiABKAIoQQJ2IgNJDQEgAiADQYSVhgEQwyEACyACIANB9JSGARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAJBAnQiAiABKAIYaigCACABKAIkIAJqKAIAIAMoAiARBQAgBCgCDCEBIAAgBCgCCDYCACAAIAE2AgQgBEEQaiQAC6kBAQV/AkBBBEEEEK02IgEEQCABQeithgE2AgBBCEEEEK02IgBFDQEgAEGIrIYBNgIEIAAgATYCAEHQ74oBQdDvigEoAgAiASAAIAEbNgIAIAFFBEAgAA8LIAAoAgAhAyAAKAIEIgQoAgAiAgRAIAMgAhEDAAsgBCgCBCICBEAgAyACIAQoAggQ+DoLIABBCEEEEPg6IAEPC0EEQQQQoz0AC0EEQQgQoz0AC58BAQV/IwBBIGsiAiQAIAEoAgAhBSABKAIEIQMgAiABKAIIIgE2AgwgAiABQQJ0IgEgAkEMahC/ISACKAIAIQQgAigCBCEGIAEEQCAEQQhqIAMgAfwKAAALIAJBADYCGCACIAM2AhAgAiAFNgIMIAIgAkEfajYCFCACQQxqIgEQxicgAUEEQQQQ4B4gACAGNgIEIAAgBDYCACACQSBqJAALowECA38BfgJAIAEoAgwiA0EDdCACTwRAIAJBA3YgAkEHcSIFQQBHaiIEIAMgAyAESxshAyABKAIIIQQgASkCACEGIAUEQCADRQ0CIAMgBGpBAWsiAUUNAiABIAEtAABBfyAFdEF/c3E6AAALIAAgAjYCECAAIAM2AgwgACAENgIIIAAgBjcCAA8LQdSCiAFBKUGAg4gBEJ8pAAtBkIOIARCyOwALhQYBBn8jAEGwAWsiAyQAIANBADYCpAEgA0EANgKcASADQQA2AqwBIANBDGogA0GcAWogASACELwaAkAgAygCDCIBQQJGBEAgAy0AECEBIwBBEGsiAiQAIAFBCkYEf0EABUEBQQEQrTYiBUUEQEEBQQEQoz0ACyAFIAE6AAAgAkEIaiIBQfzkwwA2AgQgASAFNgIAIAIoAgwhBSACKAIICyEGQdQAQQQQrTYiAUUEQEEEQdQAEKM9AAsgASAFNgJQIAEgBjYCTCABIAM7AUogAUEAOwFIIAFBAjYCACACQRBqJAAgAEECNgIAIAAgATYCBAwBCyADKAIQIQIgA0HcAGogA0EUakHAAPwKAAAgAyACNgJYIAMgATYCVCMAQdAAayIFJAAgA0HUAGoiASgCGCECIAEoAhQhBgJAAkACQCABKAIgIgRFDQAgAiAETQRAIAIgBEYNAQwCCyAEIAZqLAAAQb9/TA0BCwJAAkAgBiAEQdztwwBBBBDBLkUNACAFIAEQthEgBSgCACAFKAIEQeDtwwBBBBCtO0UNAAJAAkAgAkEFTQRAIAJBBUYNAQwCCyAGLAAFQb9/TA0BCyAFQQhqIgQgBkEFaiACQQVrELgZIAUoAggCQCAEKAIAQQJHBEAgBEEQahDeOwwBCwJAIAQoAgQiAigCTCIGRQ0AIAIoAlAiBCgCACIHBEAgBiAHEQMACyAEKAIEIgdFDQAgBiAHIAQoAggQ+DoLIAIoAgBBAkcEQCACQRBqEN47CyACQdQAQQQQ+DoLQQJGDQEgACABQcgA/AoAAAwCCyAGIAJBBSACQeTtwwAQozYACyABLQA0RQRAQdQAQQQQrTYiAkUEQEEEQdQAEKM9AAsgAkG45cMANgJQIAJBATYCTCACIAE7AUogAkEAOwFIIAJBAjYCACACEPkuIAIgAUHIAPwKAAAgAEECNgIAIAAgAjYCBAwBCyAAIAFByAD8CgAACyAFQdAAaiQADAELIAYgAkEAIARBzO3DABCjNgALCyADQbABaiQAC5MBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0EEdCIFaiAAIANBHGwiBmogAyAEELkZIQAgASABIAVqIAEgBmogAyAEELkZIQEgAiACIAVqIAIgBmogAyAEELkZIQILIAAgAiABIAAoAgBBGHYiACABKAIAQRh2IgFJIgMgASACKAIAQRh2IgJJcxsgAyAAIAJJcxsLtQEBAX8jAEEQayIDJAACQAJAIAEpAwBCBlEEQCADQQRqQQ5BAEEBQQEQoBggAygCCCEBIAMoAgRBAUYNAiADKAIMIgJBBmpBrozNACkAADcAACACQaiMzQApAAA3AAAgAEEONgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAAgASACIAFB0ABqQQAgASgCUEGAgICAeEcbEPgUCyADQRBqJAAPCyABIAMoAgxB1P3MABD9LwALpAEBAn8jAEEQayIEJAACQAJAIAMEQCABQRhqIQEgAiADQQR0aiEDA0AgAigCAEUNAiAEIAJBCGoiBSgCADYCDCABIARBDGpBBBChNiACKAIARQ0DIAEgAkEEaigCACAFKAIAEKE2IAJBEGoiAiADRw0ACwsgAEEINgIAIARBEGokAA8LQayHzgBBJUHUh84AEJ8pAAtB5IfOAEEgQYSIzgAQyyQAC50BAQh/IAAoAhwiBSACIAAoAgQiCGsiBiAFIAZLGyEJQX8gASgCBHRBf3MhCiAAKAJkIQsgASgCCCEBIAAoAlwhBwNAIAUgCUcEQCALIAUgCnFBAnRqIAcgBSAIaiABIAMQox1BAnRqIgwoAgA2AgAgDCAFNgIAIAVBAWohBSAERQ0BCwsgACAGNgIcIAcgAiABIAMQox1BAnRqKAIAC6QBAAJAAkACQCACAn8gAEEBRgRAQQAhAkEEDAELIABFDQEgAEGBgIAITw0CQQFBICAAQQFrIgJnayACQQJJGyIAQRlPDQNBBCAAQQNqQQJ2IABBEEkbCyIAQQJ0NgIAIAMgAEEEazYCACABIAKtNwMADwtBvOfRAEEcQdjn0QAQnykAC0Ho59EAQSVBkOjRABCfKQALQaDo0QBBGkG86NEAEJ8pAAv3DgISfwJ+IwBB8ABrIgckACAHQZOAgIB4NgIEIAdBxABqIgMgAUEo/AoAACAHIAdBBGo2AmwgB0EYaiENIwBBkAJrIgIkACACQShqIgEgA0Es/AoAACACQdABaiIIIAEQuykCQAJAAkACQCACKALUAQRAIAJB1ABqIgMgAigC2AEiDkEDdiAOQQdxQQBHaiIGENIfIAJB5ABqIgQgBhDSHyACQSBqIAQQhj0gAikDICEUIAJBGGogAxCGPSACKQMYIRUgCCABQSz8CgAAIAJBADYCjAIgAiAUNwKEAiACIBU3AvwBIAIoAvgBIQkjAEHgAGsiBSQAIAgoAhwiASAIKAIgIhBHBEACQCAIKAIEIREgAkH8AWoiCigCECELIAVBHGohEgNAAkACQAJAAkACQAJAAkAgEQRAIAEgCCgCFE8NAiAIKAIIIAgoAhAgAWoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAggAUEBaiIMNgIcIAVBEGogCCgCACABENorIAUoAhAhASAFQUBrIAUoAhQiA0EAQQFBARCgGCAFKAJEIQ8gBSgCQEEBRg0CIAUoAkghBCADBEAgBCABIAP8CgAACyADBEAgBCEBIAMhBgNAIAEgAS0AACITQcEAa0H/AXFBGklBBXQgE3I6AAAgAUEBaiEBIAZBAWsiBg0ACwsgBSADNgI0IAUgBDYCMCAFIA82AiwgBUEIaiAEIAMQ9AhBk4CAgHghBkEBIQECQCAFKAIIIgMgBSgCDCIEQfmwgAFBARDBLg0AIAMgBEH6sIABQQIQwS4NACADIARB/LCAAUEDEMEuDQAgAyAEQf+wgAFBBBDBLg0AIAMgBEGDsYABQQEQwS4NACADIARBhLGAAUECEMEuDQAgAyAEQYaxgAFBAxDBLg0AIAMgBEGJsYABQQIQwS4NACADIARBi7GAAUEBEMEuDQBBACEBIAMgBEGMsYABQQEQwS4NACADIARBjbGAAUECEMEuDQAgAyAEQY+xgAFBAxDBLg0AIAMgBEGSsYABQQQQwS4NACADIARBlrGAAUEFEMEuDQAgAyAEQZuxgAFBARDBLg0AIAMgBEGcsYABQQIQwS4NACADIARBnrGAAUECEMEuDQAgAyAEQaCxgAFBAxDBLg0AIAMgBEGjsYABQQEQwS4NACAFIAQ2AjwgBSADNgI4IAgoAiQtADQEQEECIQEMAQsgBUECNgJEIAVB1LGAATYCQCAFQgE3AkwgBUHMATYCXCAFIAVB2ABqNgJIIAUgBUE4ajYCWCASIAVBQGsQrBhBgoCAgHghBiAFLQAcIQELIAVBLGoQ3jsgBkGTgICAeEcEQCAJKAIAQZOAgIB4RwRAIAkQiBELIAkgAToABCAJIAY2AgAgCSAFQR1qIgEpAAA3AAUgCUEMaiABQQdqKQAANwAADAkLIAFB/wFxQQJGDQUgC0EDdiIDIAooAgQiBk8NAyAKKAIAIANqIgZBASALQQdxdCIEIAYtAAByOgAAIAFBAXFFDQUgAyAKKAIMIgFPDQQgCigCCCADaiIBIAEtAAAgBHI6AAAMBQsgCCABQQFqIgE2AhwMBQtB9KeAAUEgQZSogAEQnykACyAPIAUoAkhB4K2AARD9LwALIAMgBkGgp4ABEMMhAAsgAyABQaCngAEQwyEACyAMIQELIAogC0EBaiILNgIQIAEgEEcNAAsLCyAFQeAAaiQAAkAgAigC1AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAkHUAWoQ+x4LIAJBAToAuAEgAigCXCEBIAIoAmAhAyACIAIpAlQ3AtwBIAJBADYC2AEgAiADNgLUASACIAE2AtABIAJBEGogAkHQAWoiBhDXOyACKAIQIQRBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAtABNwIIIAFBEGogAkHYAWopAgA3AgAgAUEYaiACQeABaigCADYCACACIAM2AswBIAIgBDYCyAEgAiABNgLEAUEMQQQQrTYiA0UNAiACKAJsIQEgAigCcCEEIAIgAikCZDcC3AEgAkEANgLYASACIAQ2AtQBIAIgATYC0AEgAkEIaiAGENc7IAIoAgghDEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAMgBDYCCCADIAw2AgQgAyABNgIAIAJBATYChAIgAiADNgKAAiACQQE2AvwBIAJBADYC2AEgAkKAgICAwAA3AtABIAJB9ABqIgEgAkG4AWogDiACIAJBxAFqIAJB/AFqIAYQjBMgDSABENEQIAJBkAJqJAAMBAtB/LSAAUEWQZS1gAEQyyQAC0EEQRwQoz0AC0EEQQwQoz0AC0EEQRwQoz0ACwJAIAcoAgRBk4CAgHhHBEAgACAHKQIENwIEIABBADYCACAAQRRqIAdBFGooAgA2AgAgAEEMaiAHQQxqKQIANwIAIA0QzSYMAQsgACAHQRhqQSz8CgAACyAHQfAAaiQAC/cOAhJ/An4jAEHwAGsiByQAIAdBk4CAgHg2AgQgB0HEAGoiAyABQSj8CgAAIAcgB0EEajYCbCAHQRhqIQ0jAEGQAmsiAiQAIAJBKGoiASADQSz8CgAAIAJB0AFqIgggARC/KQJAAkACQAJAIAIoAtQBBEAgAkHUAGoiAyACKALYASIOQQN2IA5BB3FBAEdqIgYQ0h8gAkHkAGoiBCAGENIfIAJBIGogBBCGPSACKQMgIRQgAkEYaiADEIY9IAIpAxghFSAIIAFBLPwKAAAgAkEANgKMAiACIBQ3AoQCIAIgFTcC/AEgAigC+AEhCSMAQeAAayIFJAAgCCgCHCIBIAgoAiAiEEcEQAJAIAgoAgQhESACQfwBaiIKKAIQIQsgBUEcaiESA0ACQAJAAkACQAJAAkACQCARBEAgASAIKAIUTw0CIAgoAgggCCgCECABaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgCCABQQFqIgw2AhwgBUEQaiAIKAIAIAEQjywgBSgCECEBIAVBQGsgBSgCFCIDQQBBAUEBEKAYIAUoAkQhDyAFKAJAQQFGDQIgBSgCSCEEIAMEQCAEIAEgA/wKAAALIAMEQCAEIQEgAyEGA0AgASABLQAAIhNBwQBrQf8BcUEaSUEFdCATcjoAACABQQFqIQEgBkEBayIGDQALCyAFIAM2AjQgBSAENgIwIAUgDzYCLCAFQQhqIAQgAxD0CEGTgICAeCEGQQEhAQJAIAUoAggiAyAFKAIMIgRB+bCAAUEBEMEuDQAgAyAEQfqwgAFBAhDBLg0AIAMgBEH8sIABQQMQwS4NACADIARB/7CAAUEEEMEuDQAgAyAEQYOxgAFBARDBLg0AIAMgBEGEsYABQQIQwS4NACADIARBhrGAAUEDEMEuDQAgAyAEQYmxgAFBAhDBLg0AIAMgBEGLsYABQQEQwS4NAEEAIQEgAyAEQYyxgAFBARDBLg0AIAMgBEGNsYABQQIQwS4NACADIARBj7GAAUEDEMEuDQAgAyAEQZKxgAFBBBDBLg0AIAMgBEGWsYABQQUQwS4NACADIARBm7GAAUEBEMEuDQAgAyAEQZyxgAFBAhDBLg0AIAMgBEGesYABQQIQwS4NACADIARBoLGAAUEDEMEuDQAgAyAEQaOxgAFBARDBLg0AIAUgBDYCPCAFIAM2AjggCCgCJC0ANARAQQIhAQwBCyAFQQI2AkQgBUHUsYABNgJAIAVCATcCTCAFQcwBNgJcIAUgBUHYAGo2AkggBSAFQThqNgJYIBIgBUFAaxCsGEGCgICAeCEGIAUtABwhAQsgBUEsahDeOyAGQZOAgIB4RwRAIAkoAgBBk4CAgHhHBEAgCRCIEQsgCSABOgAEIAkgBjYCACAJIAVBHWoiASkAADcABSAJQQxqIAFBB2opAAA3AAAMCQsgAUH/AXFBAkYNBSALQQN2IgMgCigCBCIGTw0DIAooAgAgA2oiBkEBIAtBB3F0IgQgBi0AAHI6AAAgAUEBcUUNBSADIAooAgwiAU8NBCAKKAIIIANqIgEgAS0AACAEcjoAAAwFCyAIIAFBAWoiATYCHAwFC0H0p4ABQSBBlKiAARCfKQALIA8gBSgCSEHgrYABEP0vAAsgAyAGQaCngAEQwyEACyADIAFBoKeAARDDIQALIAwhAQsgCiALQQFqIgs2AhAgASAQRw0ACwsLIAVB4ABqJAACQCACKALUASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACACQdQBahD7HgsgAkEBOgC4ASACKAJcIQEgAigCYCEDIAIgAikCVDcC3AEgAkEANgLYASACIAM2AtQBIAIgATYC0AEgAkEQaiACQdABaiIGENc7IAIoAhAhBEEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAIgAzYCzAEgAiAENgLIASACIAE2AsQBQQxBBBCtNiIDRQ0CIAIoAmwhASACKAJwIQQgAiACKQJkNwLcASACQQA2AtgBIAIgBDYC1AEgAiABNgLQASACQQhqIAYQ1zsgAigCCCEMQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQLQATcCCCABQRBqIAJB2AFqKQIANwIAIAFBGGogAkHgAWooAgA2AgAgAyAENgIIIAMgDDYCBCADIAE2AgAgAkEBNgKEAiACIAM2AoACIAJBATYC/AEgAkEANgLYASACQoCAgIDAADcC0AEgAkH0AGoiASACQbgBaiAOIAIgAkHEAWogAkH8AWogBhCMEyANIAEQ0RAgAkGQAmokAAwEC0H8tIABQRZBlLWAARDLJAALQQRBHBCjPQALQQRBDBCjPQALQQRBHBCjPQALAkAgBygCBEGTgICAeEcEQCAAIAcpAgQ3AgQgAEEANgIAIABBFGogB0EUaigCADYCACAAQQxqIAdBDGopAgA3AgAgDRDNJgwBCyAAIAdBGGpBLPwKAAALIAdB8ABqJAAL8A4CD38CfiMAQfAAayIIJAAgCEGTgICAeDYCBCAIQcQAaiIDIAFBKPwKAAAgCCAIQQRqNgJsIAhBGGohDCMAQZACayICJAAgAkEoaiIBIANBLPwKAAAgAkHQAWoiByABEKIqAkACQAJAAkAgAigC1AEEQCACQdQAaiIDIAIoAtgBIg1BA3YgDUEHcUEAR2oiBhDSHyACQeQAaiIEIAYQ0h8gAkEgaiAEEIY9IAIpAyAhESACQRhqIAMQhj0gAikDGCESIAcgAUEs/AoAACACQQA2AowCIAIgETcChAIgAiASNwL8ASACQfwBaiEJIAIoAvgBIQojAEHgAGsiBSQAAkACQAJAAkACQCAHKAIcIgEgBygCIEcEQAJAIAkoAhAhCyAFQRxqIQ8DQAJAAkAgBygCBARAIAEgBygCFE8NBiAHKAIIIAcoAhAgAWoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAcgAUEBajYCHCAFQRBqIAcgARCtKiAFKAIQIQEgBUFAayAFKAIUIgNBAEEBQQEQoBggBSgCRCEOIAUoAkBBAUYNBiAFKAJIIQQgAwRAIAQgASAD/AoAAAsgAwRAIAQhASADIQYDQCABIAEtAAAiEEHBAGtB/wFxQRpJQQV0IBByOgAAIAFBAWohASAGQQFrIgYNAAsLIAUgAzYCNCAFIAQ2AjAgBSAONgIsIAVBCGogBCADEPQIQZOAgIB4IQZBASEBAkAgBSgCCCIDIAUoAgwiBEH5sIABQQEQwS4NACADIARB+rCAAUECEMEuDQAgAyAEQfywgAFBAxDBLg0AIAMgBEH/sIABQQQQwS4NACADIARBg7GAAUEBEMEuDQAgAyAEQYSxgAFBAhDBLg0AIAMgBEGGsYABQQMQwS4NACADIARBibGAAUECEMEuDQAgAyAEQYuxgAFBARDBLg0AQQAhASADIARBjLGAAUEBEMEuDQAgAyAEQY2xgAFBAhDBLg0AIAMgBEGPsYABQQMQwS4NACADIARBkrGAAUEEEMEuDQAgAyAEQZaxgAFBBRDBLg0AIAMgBEGbsYABQQEQwS4NACADIARBnLGAAUECEMEuDQAgAyAEQZ6xgAFBAhDBLg0AIAMgBEGgsYABQQMQwS4NACADIARBo7GAAUEBEMEuDQAgBSAENgI8IAUgAzYCOCAHKAIkLQA0BEBBAiEBDAELIAVBAjYCRCAFQdSxgAE2AkAgBUIBNwJMIAVBzAE2AlwgBSAFQdgAajYCSCAFIAVBOGo2AlggDyAFQUBrEKwYQYKAgIB4IQYgBS0AHCEBCyAFQSxqEN47IAZBk4CAgHhHBEAgCigCAEGTgICAeEcEQCAKEIgRCyAKIAE6AAQgCiAGNgIAIAogBUEdaiIBKQAANwAFIApBDGogAUEHaikAADcAAAwECyABQf8BcUECRg0BIAtBA3YiAyAJKAIEIgZPDQcgCSgCACADaiIGQQEgC0EHcXQiBCAGLQAAcjoAACABQQFxRQ0BIAMgCSgCDCIBTw0IIAkoAgggA2oiASABLQAAIARyOgAADAELIAcgAUEBajYCHAsgCSALQQFqIgs2AhAgBygCHCIBIAcoAiBHDQALCwsgBUHgAGokAAwEC0H0p4ABQSBBlKiAARCfKQALIA4gBSgCSEHgrYABEP0vAAsgAyAGQaCngAEQwyEACyADIAFBoKeAARDDIQALAkAgAigC1AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAkHUAWoQ+x4LIAJBAToAuAEgAigCXCEBIAIoAmAhAyACIAIpAlQ3AtwBIAJBADYC2AEgAiADNgLUASACIAE2AtABIAJBEGogAkHQAWoiBhDXOyACKAIQIQRBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAtABNwIIIAFBEGogAkHYAWopAgA3AgAgAUEYaiACQeABaigCADYCACACIAM2AswBIAIgBDYCyAEgAiABNgLEAUEMQQQQrTYiA0UNAiACKAJsIQEgAigCcCEEIAIgAikCZDcC3AEgAkEANgLYASACIAQ2AtQBIAIgATYC0AEgAkEIaiAGENc7IAIoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAMgBDYCCCADIAU2AgQgAyABNgIAIAJBATYChAIgAiADNgKAAiACQQE2AvwBIAJBADYC2AEgAkKAgICAwAA3AtABIAJB9ABqIgEgAkG4AWogDSACIAJBxAFqIAJB/AFqIAYQjBMgDCABENEQIAJBkAJqJAAMBAtB/LSAAUEWQZS1gAEQyyQAC0EEQRwQoz0AC0EEQQwQoz0AC0EEQRwQoz0ACwJAIAgoAgRBk4CAgHhHBEAgACAIKQIENwIEIABBADYCACAAQRRqIAhBFGooAgA2AgAgAEEMaiAIQQxqKQIANwIAIAwQzSYMAQsgACAIQRhqQSz8CgAACyAIQfAAaiQAC5UBAQR/IwBBQGoiAiQAIAJBBGogARDSBiACQRBqIgUgAUEMahCAFSABKAI8IgQgBCgCACIDQQFqNgIAIANBAE4EQCAAIAIpAgQ3AgAgAEEIaiACQQxqKAIANgIAIAEoAkAhAyABLQBEIQEgAEEMaiAFQTD8CgAAIAAgAToARCAAIAM2AkAgACAENgI8IAJBQGskAA8LAAuhAQECfyABQTxqIQMCQCABKAI8IgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAMQ+x4LIAFBADYCACADIAIpAgA3AgAgA0EQaiACQRBqKQIANwIAIANBCGogAkEIaikCADcCAAJAIAEoAjAiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEwahD7HgsgAUEANgIwIAAgAUHcAPwKAAALogEBA38jAEEQayICJAAgAkEANgIMIAIgATYCCAJAIAEoAggEQANAIAFBAToADCACIAJBCGoQ/ikgASgCECACKAIAIgQgBCACKAIEIgNqEMAmIAFBADoADCADRQRAIABCgoCAgMDwsAg3AgAMAwsgAiACKAIMIANqIgM2AgwgAyACKAIIKAIISQ0ACwsgAEEEOgAACyACQQhqEMQjIAJBEGokAAudAQEBfyMAQTBrIgIkACACQQA6AAsgAkEgaiABKAIMIAJBC2pBARCbIQJAAkAgAi0AIEEERg0AIAIgAikDIDcDKCACQQxqIAJBKGoQ0AkgAigCDEEERg0AIAAgAikCDDcCACAAQRBqIAJBHGooAgA2AgAgAEEIaiACQRRqKQIANwIADAELIAAgAi0ACzoABCAAQQQ2AgALIAJBMGokAAu2AQEBfyABAn8gAkEHTQRAIAAoAgAgASgCAC0AADoAACAAKAIAIAEoAgAtAAE6AAEgACgCACABKAIALQACOgACIAAoAgAgASgCAC0AAzoAAyABIAEoAgAgAkECdCICQbDG0QBqKAIAaiIDNgIAIAAoAgAgAygAADYABCABKAIAIAJB0MbRAGooAgBrDAELIAAoAgAgASgCACkAADcAACABKAIAC0EIajYCACAAIAAoAgBBCGo2AgALogEBAX8CQAJAIAEEQCAALQAAIgJBwAFPBEAgAkHgAU8EQCABQQJNDQMgACAALQACQQVzOgACQQMhAQwECyABQQFHBEAgACAALQABQSBzOgABQQIPC0EBQQFB1NnzABDDIQALQQEhASACQeEAa0H/AXFBGUsNAiAAIAJB3wBxOgAAQQEPC0EAQQBBtNnzABDDIQALQQIgAUHE2fMAEMMhAAsgAQupAQEDfyAAQoCAgIDQxwA3AvQRIAJFBEBBfw8LIAJBAnQhBCAAQfwRaiEFQX8hA0EAIQIDQAJAIAEvAQBFBEAgAUECakEAOwEADAELIAAgACgC9BFBAWoiAzYC9BEgA0G9BE8EQCADQb0EQdj9+wAQwyEACyAAIANBAnRqIAI2AgAgAiAFakEAOgAAIAIhAwsgAUEEaiEBIAJBAWohAiAEQQRrIgQNAAsgAwuWAQICfwJ+IAAoAhAgAWqtIQQgACgCBCEDQQAhASAAKAIIQQN2IgAhAgJAAkACQCAADgICAQALA0AgASAAQQF2IgIgAWoiASADIAFBA3RqKQMAIARVGyEBIAAgAmsiAEEBSw0ACwtBASECIAQgAyABQQN0aikDACIFUQRAIAEhAAwBCyABIAQgBVVqIQBBACECCyAAIAJqC6ABAQF/IAAQvgwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQ+x4LC7YCAQZ/IwBBIGsiBCQAIAQgARDTBiAEQQxqIQYjAEEgayIFJAACQAJAIAFBDGoiCCgCDEF/IAIgA2oiByACIAdLG08EQCAIKAIAIgcgBygCACIJQQFqNgIAIAlBAEgNASAGIAM2AgwgBiAHNgIAIAYgCCkCBDcCBCAGIAgoAhAgAmo2AhAgBUEgaiQADAILIAVBADYCGCAFQQE2AgwgBUGs9IQBNgIIIAVCBDcCECAFQQhqQbT0hAEQ7ywLAAsgASgCICICIAIoAgAiA0EBajYCACADQQBIBEAACyAAIAQpAgA3AgAgACAEKQIMNwIMIAAgAjYCICAAIAEoAiQ2AiQgAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaikCADcCACAAQRxqIARBHGooAgA2AgAgBEEgaiQAC6ABAQF/IAAQxwwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQ+x4LC7MBAQF/IwBBQGoiAiQAIAAoAgAhACACQaDmhwE2AjggAkGA5ocBNgIwIAIgAEHJAGo2AiwgAkGQ5ocBNgIoIAIgAEEoajYCJCACQYDmhwE2AiAgAiAAQcgAajYCHCACQfDlhwE2AhggAiAAQTBqNgIUIAJB4OWHATYCECACIABBPGo2AgwgAiAAQQhqNgI8IAIgAkE8ajYCNCABQZTnhwFB5OaHASACQQxqEPkSIAJBQGskAAukAQEEfyABKAIUIgQoAmQhAgJAAkAgASgCAEEIaiAERwRAIAIhAyAEIQIMAQsgAkUEQEEBIQQMAgsgASACNgIUIAIoAmQhAwsCQCADDQBBAiEEIAIgASgCEEYEQCABKAIAIgNBADYCbCABKAIQIAEgA0EIaiIDNgIQIAM2AmQgAigCZCIDDQELDAELIAEgAzYCFEEAIQQLIAAgAjYCBCAAIAQ2AgALpAEBBH8gASgCFCIEKAJEIQICQAJAIAEoAgBBCGogBEcEQCACIQMgBCECDAELIAJFBEBBASEEDAILIAEgAjYCFCACKAJEIQMLAkAgAw0AQQIhBCACIAEoAhBGBEAgASgCACIDQQA2AkwgASgCECABIANBCGoiAzYCECADNgJEIAIoAkQiAw0BCwwBCyABIAM2AhRBACEECyAAIAI2AgQgACAENgIAC6kBAQR/IAEoAhQiBCgCzAEhAgJAAkAgASgCAEEIaiAERwRAIAIhAyAEIQIMAQsgAkUEQEEBIQQMAgsgASACNgIUIAIoAswBIQMLAkAgAw0AQQIhBCACIAEoAhBGBEAgASgCACIDQQA2AtQBIAEoAhAgASADQQhqIgM2AhAgAzYCzAEgAigCzAEiAw0BCwwBCyABIAM2AhRBACEECyAAIAI2AgQgACAENgIAC64BAgJ/AX4jAEEgayIDJAAgASgCDCEEIAFBgYCAgHg2AgwCQAJAIARBgYCAgHhHBEAgA0EYaiABQRhqKQIAIgU3AgAgAyAENgIMIAMgASkCEDcCECAFp0EBcUUNAiAAIAFBAUECIAIbIAMvARoQqRQgA0EMahCGMAwBCyACRQRAIAAgAUECEIgaDAELIAAgAUEBEIgaCyADQSBqJAAPC0GchMMAQSFBwITDABDLJAALrgECAn8BfiMAQSBrIgMkACABKAIMIQQgAUGBgICAeDYCDAJAAkAgBEGBgICAeEcEQCADQRhqIAFBGGopAgAiBTcCACADIAQ2AgwgAyABKQIQNwIQIAWnQQFxRQ0CIAAgAUEBQQIgAhsgAy8BGhCqFCADQQxqEIYwDAELIAJFBEAgACABQQIQiRoMAQsgACABQQEQiRoLIANBIGokAA8LQZyEwwBBIUHAhMMAEMskAAufAQECfyMAQTBrIgEkACABQQA2AhwgAUKAgICAEDcCFCABQZCHwwA2AiQgAUKggICADjcCKCABIAFBFGo2AiAgACABQSBqELkJBEBBuIfDAEE3IAFBCGpBqIfDAEHwh8MAENUeAAsgAUEQaiABQRxqKAIAIgI2AgAgASABKQIUNwMIIAEoAgwgAhCUPiABQQhqEN47IAAQySMgAUEwaiQAC58BAQJ/IwBBMGsiASQAIAFBADYCHCABQoCAgIAQNwIUIAFBkIfDADYCJCABQqCAgIAONwIoIAEgAUEUajYCICAAIAFBIGoQrBEEQEG4h8MAQTcgAUEIakGoh8MAQfCHwwAQ1R4ACyABQRBqIAFBHGooAgAiAjYCACABIAEpAhQ3AwggASgCDCACEJQ+IAFBCGoQ3jsgABDQIiABQTBqJAALnwEBAn8jAEEwayIBJAAgAUEANgIcIAFCgICAgBA3AhQgAUGoxcwANgIkIAFCoICAgA43AiggASABQRRqNgIgIAAgAUEgahCfBARAQdDFzABBNyABQQhqQcDFzABBiMbMABDVHgALIAFBEGogAUEcaigCACICNgIAIAEgASkCFDcDCCABKAIMIAIQlD4gAUEIahDeOyAAEIgRIAFBMGokAAuhAQEBfyMAQSBrIgQkAAJAAkAgASkDAEICUgRAIARBCGogASACIAMQvAsgBCgCDCEBIAQoAggiAkEIRg0BIAAgBCkDEDcDCCAAQRBqIARBGGopAwA3AwAgACABNgIEIAAgAjYCAAwCCyABQQhqIAIgAyABLQAoEKYIIQEgAEEINgIAIAAgATYCBAwBCyAAQQg2AgAgACABNgIECyAEQSBqJAALtwEBAX8jAEEQayICJAACfwJAAkACQAJAIAAtAABBAWsOAwECAwALIAIgAEEBajYCBCABQfifzwBBCyAAQQRqQdifzwAgAkEEakHon88AEIMPDAMLIAIgAEEEajYCCCABQZSgzwBBDSACQQhqQYSgzwAQ0BMMAgsgAiAAQQFqNgIMIAFBoaDPAEERIABBBGpB2J/PACACQQxqQeifzwAQgw8MAQsgAUGyoM8AQQ4Q+zULIAJBEGokAAuhAQEDfyMAQRBrIgMkACABp0EBcQRAIANBADYCDCADQoCAgICAATcCBCAAQSxqIQQCQAJAIAAoAixBgICAgHhGBEAgBBCFMCAAQQA2AjQgAEKAgICAgAE3AiwMAQsgA0EEahDjPCAAKAI0IgUgACgCLEcNAQsgBEHo+88AELMoCyAAKAIwIAVBA3RqIAI3AwAgACAFQQFqNgI0CyADQRBqJAALmwECAX4BfyABKQAAIQMgAEEIaiABQQhqKQAANwAAIAAgAzcAACACQRFOBEAgACACaiECIAFBIGohASAAQRBqIQADQCABQRBrIgQpAAAhAyAAQQhqIARBCGopAAA3AAAgACADNwAAIAEpAAAhAyAAQRhqIAFBCGopAAA3AAAgAEEQaiADNwAAIAFBIGohASAAQSBqIgAgAkkNAAsLC6MBAQR/IAFBAmoiAiAAKAIYIgNJBEAgACAAKAIUIAJqLQAAIAAoAoQBQQV0QeD/AXFzIgI2AoQBAkAgACgCMCACQQF0aiIELwEAIgIgAUH//wNxRwRAIAAoAiBBAWsgAXEiAyAAKAIsIgVPDQEgACgCKCADQQF0aiACOwEAIAQgATsBAAsgAg8LIAMgBUHU3/wAEMMhAAsgAiADQcTf/AAQwyEAC5cBAgN/An5BASECIAEoAhgoAgBBk4CAgHhGBEAjAEEQayEDQQAhAgJ/IAEpAwAiBSABKQMIIgZTBEAgA0EMaiAFQgBVIAYgBX0iBSAGU3MgBUL/////D1ZyDQEaIAWnIQILIANBATYCDCADQQhqCyACNgIAIAMoAgghBCADKAIMIQILIAAgBDYCCCAAIAI2AgQgAEEANgIAC54BAQZ/IAEoAgQhAiABKAIAIQYCQCAAKAIAIgMgACgCBCIERwRAIAAoAgwhBSAAKAIIIQcgASgCCCACQQJ0aiEAIAQgA2tBAnYhAQNAIAMoAgAiBCAFTw0CIAAgByAEQQJ0aigCADYCACADQQRqIQMgAEEEaiEAIAJBAWohAiABQQFrIgENAAsLIAYgAjYCAA8LIAQgBUG8tIIBEMMhAAueAQEGfyABKAIEIQIgASgCACEGAkAgACgCACIDIAAoAgQiBEcEQCAAKAIMIQUgACgCCCEHIAEoAgggAkECdGohACAEIANrQQN2IQEDQCAFIAMoAgAiBE0NAiAAIAcgBEECdGooAgA2AgAgA0EIaiEDIABBBGohACACQQFqIQIgAUEBayIBDQALCyAGIAI2AgAPCyAEIAVB9LaCARDDIQALngEBBn8gASgCBCECIAEoAgAhBgJAIAAoAgAiAyAAKAIEIgRHBEAgACgCDCEFIAAoAgghByABKAIIIAJBAnRqIQAgBCADa0ECdiEBA0AgAygCACIEIAVPDQIgACAHIARBAnRqKAIANgIAIANBBGohAyAAQQRqIQAgAkEBaiECIAFBAWsiAQ0ACwsgBiACNgIADwsgBCAFQfS2ggEQwyEAC5cBAQZ/IAIoAgQhAyACKAIAIQYCQCAAIAFHBEAgAigCCCADQQxsaiEHIAEgAGtBDG4hAUEAIQIDQCAAIAJqIggoAgAiBSAFKAIAIgRBAWo2AgAgBEEASA0CIAIgB2oiBCAFNgIAIARBBGogCEEEaikCADcCACACQQxqIQIgA0EBaiEDIAFBAWsiAQ0ACwsgBiADNgIADwsAC5MBAQN/IAAoAhAgAWohAyAAKAIEIQRBACEBIAAoAghBAnYiACECAkACQAJAIAAOAgIBAAsDQCABIABBAXYiAiABaiIBIAQgAUECdGooAgAgA0obIQEgACACayIAQQFLDQALC0EBIQIgAyAEIAFBAnRqKAIAIgBGBEAgASEADAELIAEgACADSGohAEEAIQILIAAgAmoLnQECAX8CfiMAQSBrIgIkACACQRBqIAEQyi8gAiACKAIQNgIcIAIgAkEcahDRH6xCgKMFfiACNQIUfEKAkc285wF9IgMgA0I/h0LAhD1CABCoHiAAAn5CACACKQMIIAIpAwAiA0I/h1INABpCACACKAIYQegHbq0iBEIAVCADIAMgBHwiA1VzDQAaIAAgAzcDCEIBCzcDACACQSBqJAALrwEBAn8jAEEgayICJAAgASgCBEECEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEQEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEBEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEIEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEEEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALngEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQIgASgCDCIAIARqIgUgASgCBCIGSwRAIAEgBkEBdCIAIAUQ3SoiBSAAIAVLGxDoGSABKAIMIQALIAQEQCABKAIIIABqIAIgA2ogBPwKAAALIAEgASgCDCAEajYCDA8LIAMgAkH0mocBELE7AAsgAiAFQfSahwEQsDsAC54BAQZ/IAEoAgAiBCgCBCABQQRrIgYoAgAiASgCBCAEKAIIIgIgASgCCCIDIAIgA0kbEJknIgUgAiADayAFG0EASARAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgBCgCBCACQQRrIgYoAgAiASgCBCAEKAIIIgMgASgCCCIFIAMgBUkbEJknIgcgAyAFayAHG0EASA0BCwsgAiAENgIACwuiAQEDfyMAQRBrIgQkAAJAAkACfwJAIAEgACgCACIDENE0BEAgACgCBCECIAFFBEAgAkUNBSAAKAIIIAIgAxD4OgwECyACRQ0BIAAoAgggAiADIAEQlzUMAgtBsPSHAUErIARBD2pBoPSHAUHs9YcBENUeAAsgASADEK02CyICBEAgACACNgIIDAELIAMgARCjPQALIAAgATYCBAsgBEEQaiQAC5YBAQJ/IwBBEGsiBCQAAkAgASgCACIBQQFxBEAgBCABQX5xIgE2AgAgBEEIaiIFIAIgAWsiAiADaiIBNgIAIAQgATYCBCAEQQdBICABQQp2Z2siASABQQdPG0ECdEEBcjYCDCAEIAIQpx4gAEEIaiAFKQIANwIAIAAgBCkCADcCAAwBCyAAIAEgAiADEMYSCyAEQRBqJAALowEBAn8gACgCACIAQQxqIgEQ0yQgACgCFCICIAIoAgBBAWsiAjYCACACRQRAIABBFGoQ3x8LAkAgASgCAEUNACAAKAIQIgFBhAFJDQAgARDyHwsCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ6ScLAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLjAEBAn8Cf0H/H0H//wMgAC0AKBsgAU8EQCABQQZ2IgIgACgCBEkEQCAAKAIAIAJBAXRqLwAAIAFBP3FqDAILIAAoAhBBAWsMAQsgACgCGCABSwRAIAAgARDADwwBCyAAKAIQQQJrCyIBIAAoAhAiA0kEfyAAKAIMIAFqLQAABSACCyAALQAsIAEgA0kbC94BAQJ/IwBBMGsiAiQAIAIgATYCAAJAIAAoAggiAyABSwRAIAEgACgCFE8NASAAKAIQIAFBAnRqKAIAIAJBMGokAA8LIAIgAzYCHCACQQM2AgggAkG0vM8ANgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBzLzPABDvLAALIwBBIGsiACQAIABBAjYCBCAAQYi9zwA2AgAgAEIBNwIMIABBOzYCHCAAIAI2AhggACAAQRhqNgIIIABBmL3PABDvLAALhwIBA38jAEFAaiIDJAAgAyACNgIQIAIgASgCACgCIE8EQCADIAEQzD02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAAgASgCACgCHCACaiwAACECAn8gAUEEaiIBEN49IAJNBEBBACEBQQEMAQsgBEEIaiABIAIQpyogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4cCAQN/IwBBQGoiAyQAIAMgAjYCECACIAEoAgAoAiBPBEAgAyABEMw9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAmosAAAhAgJ/IAFBBGoiARDfPSACTQRAQQAhAUEBDAELIARBCGogASACEKYqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuIAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDJPCACTQRAIAMgARDLPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkAAJ/IAEoAgAoAhwgAkECdGooAgAiAiABQQRqIgEQ3z1PBEBBACEBQQEMAQsgBEEIaiABIAIQpiogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4oCAQN/IwBBQGoiAyQAIAMgAjYCECABKAIAEMo8IAJNBEAgAyABEMk9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAkEDdGooAgAhAgJ/IAFBBGoiARDfPSACTQRAQQAhAUEBDAELIARBCGogASACEKYqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLgEAIQIgA0EIaiIHIAFBBGoiARDfPSACSwR/IARBCGogASACEKYqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLwEAIQIgA0EIaiIHIAFBBGoiARDfPSACSwR/IARBCGogASACEKYqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLgEAIQIgA0EIaiIHIAFBBGoiARCMPiACSwR/IARBCGogASACEKwuIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLwEAIQIgA0EIaiIHIAFBBGoiARDePSACSwR/IARBCGogASACEKcqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuKAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDKPCACTQRAIAMgARDJPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJBA3RqKAIAIQICfyABQQRqIgEQ3j0gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCnKiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALiAIBA38jAEFAaiIDJAAgAyACNgIQIAEoAgAQyTwgAk0EQCADIAEQyz02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAACfyABKAIAKAIcIAJBAnRqKAIAIgIgAUEEaiIBEN49TwRAQQAhAUEBDAELIARBCGogASACEKcqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuHAgEDfyMAQUBqIgMkACADIAI2AhAgAiABKAIAKAIgTwRAIAMgARDMPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJqLQAAIQICfyABQQRqIgEQ3z0gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCmKiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALiAIBA38jAEFAaiIDJAAgAyACNgIQIAEoAgAQyTwgAk0EQCADIAEQyz02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAACfyABKAIAKAIcIAJBAnRqKAIAIgIgAUEEaiIBEIw+TwRAQQAhAUEBDAELIARBCGogASACEKwuIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuKAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDKPCACTQRAIAMgARDJPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJBA3RqKAIAIQICfyABQQRqIgEQjD4gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCsLiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALgAIBBX8jAEFAaiIDJAAgAyACNgIQIAEoAgAQyzwgAk0EQCADIAEQyj02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyMAQRBrIgQkAEEBIQUgASgCACgCHCACQQF0ai8BACECIANBCGoiByABQQRqIgEQjD4gAksEfyAEQQhqIAEgAhCsLiAEKAIIIQUgBCgCDAUgBgs2AgQgByAFNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALhwIBA38jAEFAaiIDJAAgAyACNgIQIAIgASgCACgCIE8EQCADIAEQzD02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAAgASgCACgCHCACai0AACECAn8gAUEEaiIBEN49IAJNBEBBACEBQQEMAQsgBEEIaiABIAIQpyogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4ACAQV/IwBBQGoiAyQAIAMgAjYCECABKAIAEMs8IAJNBEAgAyABEMo9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsjAEEQayIEJABBASEFIAEoAgAoAhwgAkEBdGouAQAhAiADQQhqIgcgAUEEaiIBEN49IAJLBH8gBEEIaiABIAIQpyogBCgCCCEFIAQoAgwFIAYLNgIEIAcgBTYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4cCAQN/IwBBQGoiAyQAIAMgAjYCECACIAEoAgAoAiBPBEAgAyABEMw9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAmotAAAhAgJ/IAFBBGoiARCMPiACTQRAQQAhAUEBDAELIARBCGogASACEKwuIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuHAgEDfyMAQUBqIgMkACADIAI2AhAgAiABKAIAKAIgTwRAIAMgARDMPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJqLAAAIQICfyABQQRqIgEQjD4gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCsLiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAAL+YUDA0l/JX4IfCMAQeAAayIBJAACQAJAIAQtAARFBEAjAEGQBGsiECQAIBBBCGoiBCACIAMQnR8gEEHYAWohDiMAQfADayIDJAAgA0GwAWogBBDwJyADQfAAaiICIANBvAFqIgcoAgA2AgAgAyADKQK0ATcDaAJAIAMoArABIgZBBEcEQCADKALAASEEIA4gAykDaDcCCCAOIAQ2AhQgDiAGNgIEIA5BAzYCACAOQRBqIAIoAgA2AgAMAQsgA0HgA2oiBiACKAIANgIAIAMgAykDaDcD2AMgA0HYA2oQhjAgA0EANgIAIANBgICAgHg2AgggA0IANwMYIANBgICAgHg2AiggA0GAgICAeDYCOCADQYCAgIB4NgJIIANBgICAgHg2AlggA0ECNgJoIANBgICAgHg2AogBIANBsAFqIAQQ0wkgBiAHKQIANwMAIANB6ANqIiIgA0HEAWooAgA2AgAgAyADKQK0ATcD2AMCQAJAAkAgAygCsAFFBEAgA0HIAWohRyADQbQBaiEeIANBzAFqIUggA0G4AWohOyADQewAaiE8A0AgA0GoAWogIigCACICNgIAIANBoAFqIANB4ANqIh8pAwA3AwAgAyADKQPYAzcDmAECQAJAAkACQAJAAkACQAJAAkACQAJAIAJB/wFxBEAgA0GwAWogA0GYAWoQ/BcgAy8BtAEhAiADKAKwASIHQQRHBEAgDiADKQG2ATcBCiAOQRBqIANBvAFqKQEANwEAIA4gAjsBCCAOIAc2AgQgDkEDNgIADBALAkACQAJAAkACQAJAAkACQAJAAkAgAkEBaw4JAAECAwQFBgcICQsgA0GwAWogBBDAHCADKAKwAUUEQCADKAK4ASE1QQEhOAwVCyADKQO4ASJOpyE1QQEhOCADKAK0ASICQQRGDRQgDiADKQPAATcDECAOIDU2AgggDiACNgIEIA5BAzYCACAOIE5CIIg+AgwMGAsgA0GwAWogBBDJDyADKAK0ASEVIAMoArABIgJBBEcEQCAOIAMpALkBNwANIA5BFGogA0HAAWooAAA2AAAgDiADLQC4AToADCAOIBU2AgggDiACNgIEIA5BAzYCAAwYCyADQbABaiAVQQBBBEHgABCgGCADKAK0ASECIAMoArABQQFGDQkgA0EANgK8AyADIAMoArgBNgK4AyADIAI2ArQDIBVBAEoEQANAIANBsAFqIQpBACE2QQAhN0EAIRNBACEsQQAhGEEAIS1BACEuQQAhJkEAIQlBACEWQQAhJUEAIRJBACEnQQAhL0EAIShBACEpIwBB8ABrIgckACAHQdgAaiAEEPAnIAdByABqIgIgB0HkAGoiBigCADYCACAHIAcpAlw3A0ACQCAHKAJYIgVBBEcEQCAHKAJoIQYgCiAHKQNANwIIIAogBjYCFCAKIAU2AgQgCkECNgIAIApBEGogAigCADYCAAwBCyAHQTBqIAIoAgA2AgAgByAHKQNANwMoIAdBKGoQhjAgB0GAgICAeDYCACAHQRI2AhAgB0HYAGogBBDTCSACIAYpAgA3AwAgB0HQAGoiFCAHQewAaigCADYCACAHIAcpAlw3A0ACQAJAAkAgBygCWEUEQCAHQdwAaiEaA0AgB0E4aiAUKAIAIgI2AgAgB0EwaiAHQcgAaiIZKQMANwMAIAcgBykDQDcDKAJAIAJB/wFxBEAgB0HYAGogB0EoahD8FyAHLwFcIQIgBygCWCIGQQRHBEAgCiAHKQFeNwEKIApBEGogB0HkAGopAQA3AQAgCiACOwEIIAogBjYCBCAKQQI2AgAMBgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACQQFrDgoAAQILAwQFBgcREgsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCEJDAELIAcpA2AiTqchCSAHKAJcIgJBBEcNCAtBASE2DBMLIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhFgwBCyAHKQNgIk6nIRYgBygCXCICQQRHDQgLQQEhNwwSCyAHQdgAaiAEEMAcAkAgBygCWEUEQCAHKAJgISUMAQsgBykDYCJOpyElIAcoAlwiAkEERw0IC0EBIRMMEQsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCESDAELIAcpA2AiTqchEiAHKAJcIgJBBEcNCQtBASEsDBALIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhJwwBCyAHKQNgIk6nIScgBygCXCICQQRHDQkLQQEhGAwPCyAHQdgAaiAEEMAcAkAgBygCWEUEQCAHKAJgIS8MAQsgBykDYCJOpyEvIAcoAlwiAkEERw0JC0EBIS0MDgsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCEoDAELIAcpA2AiTqchKCAHKAJcIgJBBEcNCQtBASEuDA0LIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhKQwBCyAHKQNgIk6nISkgBygCXCICQQRHDQkLQQEhJgwMCyAKIAcpA2g3AhAgCiAJNgIIIAogAjYCBCAKQQI2AgAgCiBOQiCIPgIMDA8LIAogBykDaDcCECAKIBY2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMDgsgCiAHKQNoNwIQIAogJTYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwNCyAHQdgAaiAEEMIVIBkgGkEIaigCADYCACAHIBopAgA3A0AgBygCWCICQQRHBEAgBygCaCEGIAogBykDQDcCCCAKIAY2AhQgCiACNgIEIApBAjYCACAKQRBqIAdByABqKAIANgIADA0LIAdB4ABqIgIgGSgCADYCACAHIAcpA0A3A1ggBxCGMCAHQQhqIAIoAgA2AgAgByAHKQNYNwMADAgLIAogBykDaDcCECAKIBI2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMCwsgCiAHKQNoNwIQIAogJzYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwKCyAKIAcpA2g3AhAgCiAvNgIIIAogAjYCBCAKQQI2AgAgCiBOQiCIPgIMDAkLIAogBykDaDcCECAKICg2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMCAsgCiAHKQNoNwIQIAogKTYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwHCyAHQdgAaiEGQQAhICMAQYABayICJAAgAkESNgIIIAJB6ABqIAQQ8CcgAkHYAGoiBSACQfQAaiIIKAIANgIAIAIgAikCbDcDUAJAAkAgAigCaCINQQRHBEAgAigCeCEIIAYgAikDUDcCCCAGIAg2AhQgBiANNgIEIAZBATYCACAGQRBqIAUoAgA2AgAMAQsgAkFAayIzIAUoAgA2AgAgAiACKQNQNwM4IAJBOGoQhjAgAkHoAGogBBDTCSAFIAgpAgA3AwAgAkHgAGoiIyACQfwAaigCADYCACACIAIpAmw3A1ACQCACKAJoRQRAIAJBDGohMiACQewAaiEdA0AgAkEwaiAjKAIAIgU2AgAgAkEoaiACQdgAaiIkKQMANwMAIAIgAikDUDcDIAJAAkAgBUH/AXEEQCACQegAaiACQSBqEPwXIAIvAWwhBSACKAJoIghBBEcEQCAGIAIpAW43AQogBkEQaiACQfQAaikBADcBACAGIAU7AQggBiAINgIEIAZBATYCAAwGCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFQQFrDhIAAQIDBAUGBxEICQoLDA0ODxARCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMFwsgAigCCEESRw0TIAJBCGoQpiggAkECNgIIDBMLIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwWCyACKAIIQRJHDRIgAkEIahCmKCACQQM2AggMEgsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDBULIAIoAghBEkcNESACQQhqEKYoIAJBBDYCCAwRCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMFAsgAigCCEESRw0QIAJBCGoQpiggAkEFNgIIDBALIAJB6ABqIQhBACERQQAhDSMAQeAAayIFJAAgBUHIAGogBBDwJyAFQThqIgsgBUHUAGoiDCgCADYCACAFIAUpAkw3AzACQCAFKAJIIg9BBEcEQCAFKAJYIQ0gCCAFKQMwNwIEIAggDTYCECAIIA82AgAgCEEMaiALKAIANgIADAELIAVBIGogCygCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQcgAaiAEENMJIAsgDCkCADcDACAFQUBrIgwgBUHcAGooAgA2AgAgBSAFKQJMNwMwAkAgBSgCSEUEQCAFQcwAaiEXQQAhD0EAIQsDQCAFQShqIAwoAgAiGzYCACAFQSBqIAVBOGoiMCkDADcDACAFIAUpAzA3AxgCQCAbQf8BcQRAIAVByABqIAVBGGoQ/BcgBS8BTCEbIAUoAkgiNEEERwRAIAggBSkBTjcBBiAIQQxqIAVB1ABqKQEANwEAIAggGzsBBCAIIDQ2AgAMBQsCQAJAAkAgG0EBaw4CAAECCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCERQQEhCwwECyAFKQNQIk6nIRFBASELIAUoAkwiG0EERg0DIAggBSkDWDcCDCAIIBE2AgQgCCAbNgIAIAggTkIgiD4CCAwGCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCENQQEhDwwDCyAFKQNQIk6nIQ1BASEPIAUoAkwiG0EERg0CIAggBSkDWDcCDCAIIA02AgQgCCAbNgIAIAggTkIgiD4CCAwFCyAFQcgAaiAEIAUtAChBwAAQyQIgBSgCSCIbQQRGDQEgCCAFKQJMNwIEIAhBDGogBUHUAGopAgA3AgAgCCAbNgIADAQLIAUgDTYCFCAFIA82AhAgBSARNgIMIAUgCzYCCCAFQRhqEIYwIAVByABqIAQQqCkgBSgCSCIMQQRHBEAgCCAFKQJMNwIEIAhBDGogBUHUAGopAgA3AgAgCCAMNgIADAULIAVByABqQf7+zwBBESAFQQhqEOYeIAUoAkgiDEEERwRAIAggBSkCTDcCBCAIQQxqIAVB1ABqKQIANwIAIAggDDYCAAwFCyAFQcgAakGP/88AQRUgBUEQahDmHiAFKAJIIgxBBEcEQCAIIAUpAkw3AgQgCEEMaiAFQdQAaikCADcCACAIIAw2AgAMBQsCQCALBEAgD0UNASAIIA02AgggCCARNgIEIAhBBDYCAAwGC0H4/M8AQccAQaT/zwAQyyQAC0H4/M8AQccAQbT/zwAQyyQACyAFQRhqEIYwIAVByABqIAQQ0wkgMCAXQQhqKQIANwMAIAwgF0EQaigCADYCACAFIBcpAgA3AzAgBSgCSEUNAAsLIAggBSkDMDcCACAIQRBqIAwoAgA2AgAgCEEIaiAFQThqKQMANwIADAELIAVBGGoQhjALIAVB4ABqJAAgAigCcCEFIAIoAmwhCCACKAJoIg1BBEcEQCAGIAIpAnQ3AhAgBiAFNgIMIAYgCDYCCCAGIA02AgQgBkEBNgIADBMLIAIoAghBEkcNDyACQQhqEKYoIAIgBTYCECACIAg2AgwgAkEGNgIIDA8LIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwSCyACKAIIQRJHDQ4gAkEIahCmKCACQQc2AggMDgsgAkHoAGohCCMAQdAAayIFJAAgBUE4aiAEEPAnIAVBKGoiDSAFQcQAaiILKAIANgIAIAUgBSkCPDcDIAJAIAUoAjgiEUEERwRAIAUoAkghCyAIIAUpAyA3AgQgCCALNgIQIAggETYCACAIQQxqIA0oAgA2AgAMAQsgBUEQaiANKAIANgIAIAUgBSkDIDcDCCAFQQhqEIYwIAVBOGogBBDTCSANIAspAgA3AwAgBUEwaiILIAVBzABqKAIANgIAIAUgBSkCPDcDIAJAAkAgBSgCOEUEQCAFQTxqIQ9BAiERQQMhDQNAIAVBGGogCygCACIMNgIAIAVBEGogBUEoaiIbKQMANwMAIAUgBSkDIDcDCCAMQf8BcUUNAiAFQThqIAVBCGoQ/BcgBS8BPCEXIAUoAjgiDEEERwRAIAggBSkBPjcBBiAIQQxqIAVBxABqKQEANwEAIAggFzsBBAwECwJAAkACQAJAIBdBAWsOAgABAgsgBUE4aiAEENoQIAUtADwhESAFKAI4IgxBBEYNAiAIIAUpAD03AAUgCEEMaiAFQcQAaikAADcAACAIIBE6AAQMBgsgBUE4aiAEEM4HIAUtADwhDSAFKAI4IgxBBEYNASAIIAUpAD03AAUgCEEMaiAFQcQAaikAADcAACAIIA06AAQMBQsgBUE4aiAEIAUtABhBwAAQyQIgBSgCOCIMQQRGDQAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAMBAsgBUEIahCGMCAFQThqIAQQ0wkgGyAPQQhqKQIANwMAIAsgD0EQaigCADYCACAFIA8pAgA3AyAgBSgCOEUNAAsLIAggBSkDIDcCACAIQRBqIAsoAgA2AgAgCEEIaiAFQShqKQMANwIADAILIAUgEToABiAFIA06AAcgBUEIahCGMCAFQThqIAQQqCkgBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILIAVBOGpBpIHQAEEdIAVBBmoQ9B0gBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILIAVBOGpBwYHQAEENIAVBB2oQ9h0gBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILAkAgEUECRwRAIA1BA0YNASAIIA06AAUgCCAROgAEIAhBBDYCAAwDC0H4/M8AQccAQdCB0AAQyyQAC0H4/M8AQccAQeCB0AAQyyQACyAIIAw2AgAgBUEIahCGMAsgBUHQAGokACACLQBtIQUgAi0AbCEIIAIoAmgiDUEERwRAIAYgAikBbjcBCiAGQRBqIAJB9ABqKQEANwEAIAYgBToACSAGIAg6AAggBiANNgIEIAZBATYCAAwRCyACKAIIQRJHDQ0gAkEIahCmKCACIAU6AA0gAiAIOgAMIAJBCDYCCAwNCyACQegAaiEIIwBB0ABrIgUkACAFQThqIAQQ8CcgBUEoaiINIAVBxABqIgsoAgA2AgAgBSAFKQI8NwMgAkAgBSgCOCIRQQRHBEAgBSgCSCELIAggBSkDIDcCBCAIIAs2AhAgCCARNgIAIAhBDGogDSgCADYCAAwBCyAFQRBqIA0oAgA2AgAgBSAFKQMgNwMIIAVBCGoQhjAgBUE4aiAEENMJIA0gCykCADcDACAFQTBqIgsgBUHMAGooAgA2AgAgBSAFKQI8NwMgAkACQCAFKAI4RQRAIAVBPGohD0ECIRFBAyENA0AgBUEYaiALKAIAIgw2AgAgBUEQaiAFQShqIhspAwA3AwAgBSAFKQMgNwMIIAxB/wFxRQ0CIAVBOGogBUEIahD8FyAFLwE8IRcgBSgCOCIMQQRHBEAgCCAFKQE+NwEGIAhBDGogBUHEAGopAQA3AQAgCCAXOwEEDAQLAkACQAJAAkAgF0EBaw4CAAECCyAFQThqIAQQ2hAgBS0APCERIAUoAjgiDEEERg0CIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwGCyAFQThqIAQQzgcgBS0APCENIAUoAjgiDEEERg0BIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggDToABAwFCyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNACAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwECyAFQQhqEIYwIAVBOGogBBDTCSAbIA9BCGopAgA3AwAgCyAPQRBqKAIANgIAIAUgDykCADcDICAFKAI4RQ0ACwsgCCAFKQMgNwIAIAhBEGogCygCADYCACAIQQhqIAVBKGopAwA3AgAMAgsgBSAROgAGIAUgDToAByAFQQhqEIYwIAVBOGogBBCoKSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsgBUE4akHNgNAAQSIgBUEGahD0HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsgBUE4akHvgNAAQRIgBUEHahD2HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsCQCARQQJHBEAgDUEDRg0BIAggDToABSAIIBE6AAQgCEEENgIADAMLQfj8zwBBxwBBhIHQABDLJAALQfj8zwBBxwBBlIHQABDLJAALIAggDDYCACAFQQhqEIYwCyAFQdAAaiQAIAItAG0hBSACLQBsIQggAigCaCINQQRHBEAgBiACKQFuNwEKIAZBEGogAkH0AGopAQA3AQAgBiAFOgAJIAYgCDoACCAGIA02AgQgBkEBNgIADBALIAIoAghBEkcNDCACQQhqEKYoIAIgBToADSACIAg6AAwgAkEJNgIIDAwLIAJB6ABqIQhBACEPQQAhDSMAQdAAayIFJAAgBUE4aiAEEPAnIAVBKGoiCyAFQcQAaiIRKAIANgIAIAUgBSkCPDcDIAJAIAUoAjgiDEEERwRAIAUoAkghDSAIIAUpAyA3AgQgCCANNgIQIAggDDYCACAIQQxqIAsoAgA2AgAMAQsgBUEQaiALKAIANgIAIAUgBSkDIDcDCCAFQQhqEIYwIAVBOGogBBDTCSALIBEpAgA3AwAgBUEwaiILIAVBzABqKAIANgIAIAUgBSkCPDcDIAJAAkACQCAFKAI4RQRAIAVBPGohF0ECIREDQCAFQRhqIAsoAgAiDDYCACAFQRBqIAVBKGoiMCkDADcDACAFIAUpAyA3AwgCQAJAIAxB/wFxBEAgBUE4aiAFQQhqEPwXIAUvATwhGyAFKAI4IgxBBEcEQCAIIAUpAT43AQYgCEEMaiAFQcQAaikBADcBACAIIBs7AQQMCAsCQAJAAkAgG0EBaw4CAAECCyAFQThqIAQQkhggBS0APCENIAUoAjgiDEEERg0DIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggDToABAwJCyAFQThqIAQQ2hAgBS0APCERIAUoAjgiDEEERg0DIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwICyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNAiAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwHCyAFIA06AAYgBSAPOgAFIAUgEToAByAFQQhqEIYwIAVBOGogBBCoKSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsjAEEwayILJAAgC0ERNgIMIAtB8IHQADYCCCAFQThqIgwgBUEFai0AAAR/QQQFIAtBATYCFCALQeyOzwA2AhAgC0IBNwIcIAtBzAE2AiwgCyALQShqNgIYIAsgC0EIajYCKCAMQQRqIAtBEGoQmQ4gDEEAOgAQQQELNgIAIAtBMGokACAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsgBUE4akGBgtAAQREgBUEHahD0HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsgD0UNBCARQQJGDQUgCCANOgAFIAhBBDYCACAIIBFBAXE6AAQMBwtBASEPCyAFQQhqEIYwIAVBOGogBBDTCSAwIBdBCGopAgA3AwAgCyAXQRBqKAIANgIAIAUgFykCADcDICAFKAI4RQ0ACwsgCCAFKQMgNwIAIAhBEGogCygCADYCACAIQQhqIAVBKGopAwA3AgAMAwtB+PzPAEHHAEGUgtAAEMskAAtB+PzPAEHHAEGkgtAAEMskAAsgCCAMNgIAIAVBCGoQhjALIAVB0ABqJAAgAi0AbSEFIAItAGwhCCACKAJoIg1BBEcEQCAGIAIpAW43AQogBkEQaiACQfQAaikBADcBACAGIAU6AAkgBiAIOgAIIAYgDTYCBCAGQQE2AgAMDwsgAigCCEESRw0LIAJBCGoQpiggAiAFOgANIAIgCDoADCACQQo2AggMCwsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDA4LIAIoAghBEkcNCiACQQhqEKYoIAJBCzYCCAwKCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMDQsgAigCCEESRw0JIAJBCGoQpiggAkEMNgIIDAkLIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwMCyACKAIIQRJHDQggAkEIahCmKCACQQ02AggMCAsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAsLIAIoAghBEkcNByACQQhqEKYoIAJBDjYCCAwHCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMCgsgAigCCEESRw0GIAJBCGoQpiggAkEPNgIIDAYLIAJB6ABqIQhBACERIwBB0ABrIgUkACAFQThqIAQQ8CcgBUEoaiINIAVBxABqIgsoAgA2AgAgBSAFKQI8NwMgAkAgBSgCOCIMQQRHBEAgBSgCSCELIAggBSkDIDcCBCAIIAs2AhAgCCAMNgIAIAhBDGogDSgCADYCAAwBCyAFQRBqIA0oAgA2AgAgBSAFKQMgNwMIIAVBCGoQhjAgBUE4aiAEENMJIA0gCykCADcDACAFQTBqIg0gBUHMAGooAgA2AgAgBSAFKQI8NwMgAkAgBSgCOEUEQCAFQTxqIQ9BACELA0AgBUEYaiANKAIAIgw2AgAgBUEQaiAFQShqIhspAwA3AwAgBSAFKQMgNwMIAkACQCAMQf8BcQRAIAVBOGogBUEIahD8FyAFLwE8IRcgBSgCOCIMQQRHBEAgCCAFKQE+NwEGIAhBDGogBUHEAGopAQA3AQAgCCAXOwEEDAYLIBdBAUYEQCAFQThqIAQQkhggBS0APCERIAUoAjgiDEEERg0CIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwGCyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNAiAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwFCyAFQQhqEIYwIAVBOGogBBCoKSAFKAI4Ig1BBEcEQCAIQQRqIgsgBSkCPDcCACALQQhqIAVBxABqKQIANwIAIAggDTYCAAwGCyAIIBE6AAUgCEEENgIAIAggCzoABAwFC0EBIQsLIAVBCGoQhjAgBUE4aiAEENMJIBsgD0EIaikCADcDACANIA9BEGooAgA2AgAgBSAPKQIANwMgIAUoAjhFDQALCyAIIAUpAyA3AgAgCEEQaiANKAIANgIAIAhBCGogBUEoaikDADcCAAwBCyAIIAw2AgAgBUEIahCGMAsgBUHQAGokACACLQBtIQUgAi0AbCEIIAIoAmgiDUEERwRAIAYgAikBbjcBCiAGQRBqIAJB9ABqKQEANwEAIAYgBToACSAGIAg6AAggBiANNgIEIAZBATYCAAwJCyACKAIIQRJHDQUgAkEIahCmKCACIAU6AA0gAiAIOgAMIAJBEDYCCAwFCyACQegAaiEIIwBB4ABrIgUkACAFQcgAaiAEEPAnIAVBOGoiDSAFQdQAaiILKAIANgIAIAUgBSkCTDcDMAJAIAUoAkgiEUEERwRAIAUoAlghCyAIIAUpAzA3AgQgCCALNgIQIAggETYCACAIQQxqIA0oAgA2AgAMAQsgBUEgaiANKAIANgIAIAUgBSkDMDcDGCAFQRhqEIYwIAVBgICAgHg2AgggBUHIAGogBBDTCSANIAspAgA3AwAgBUFAayILIAVB3ABqKAIANgIAIAUgBSkCTDcDMAJAAkAgBSgCSEUEQCAFQcwAaiENA0AgBUEoaiALKAIAIgw2AgAgBUEgaiAFQThqIhEpAwA3AwAgBSAFKQMwNwMYAkACQCAMQf8BcQRAIAVByABqIAVBGGoQ/BcgBS8BTCEMIAUoAkgiD0EERwRAIAggBSkBTjcBBiAIQQxqIAVB1ABqKQEANwEAIAggDDsBBCAIIA82AgAMBgsgDEEBRgRAIAVByABqIAQQwhUgESANQQhqKAIANgIAIAUgDSkCADcDMCAFKAJIIgxBBEYNAiAFKAJYIQ0gCCAFKQMwNwIEIAggDTYCECAIIAw2AgAgCEEMaiAFQThqKAIANgIADAYLIAVByABqIAQgBS0AKEHAABDJAiAFKAJIIgxBBEYNAiAIIAUpAkw3AgQgCEEMaiAFQdQAaikCADcCACAIIAw2AgAMBQsgBUEYahCGMCAFQcgAaiAEEKgpIAhBBGohDSAFKAJIIgtBBEcEQCANIAUpAkw3AgAgDUEIaiAFQdQAaikCADcCACAIIAs2AgAMBgsgDSAFKQMINwIAIAhBBDYCACANQQhqIAVBEGooAgA2AgAMBgsgBUHQAGoiDCARKAIANgIAIAUgBSkDMDcDSCAFQQhqEIYwIAVBEGogDCgCADYCACAFIAUpA0g3AwgLIAVBGGoQhjAgBUHIAGogBBDTCSARIA1BCGopAgA3AwAgCyANQRBqKAIANgIAIAUgDSkCADcDMCAFKAJIRQ0ACwsgCCAFKQMwNwIAIAhBEGogCygCADYCACAIQQhqIAVBOGopAwA3AgAMAQsgBUEYahCGMAsgBUEIahCGMAsgBUHgAGokACAkIB1BCGooAgA2AgAgAiAdKQIANwNQIAIoAmgiBUEERwRAIAIoAnghCCAGIAIpA1A3AgggBiAINgIUIAYgBTYCBCAGQQE2AgAgBkEQaiACQdgAaigCADYCAAwICyACQUBrIgUgJCgCADYCACACIAIpA1A3AzggAigCCEESRwRAIAJBOGoQhjAMBQsgAkHwAGoiCCAFKAIANgIAIAIgAikDODcDaCACQQhqEKYoIDIgAikDaDcCACAyQQhqIAgoAgA2AgAgAkERNgIIDAQLIAJB6ABqIQhBACENIwBB4ABrIgUkACAFQcgAaiAEEPAnIAVBOGoiCyAFQdQAaiIRKAIANgIAIAUgBSkCTDcDMAJAIAUoAkgiDEEERwRAIAUoAlghDSAIIAUpAzA3AgggCCANNgIUIAggDDYCBCAIQQE2AgAgCEEQaiALKAIANgIADAELIAVBIGogCygCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQYCAgIB4NgIIIAVByABqIAQQ0wkgCyARKQIANwMAIAVBQGsiDCAFQdwAaigCADYCACAFIAUpAkw3AzACQCAFKAJIRQRAIAVBzABqIRFBACELA0AgBUEoaiAMKAIAIhc2AgAgBUEgaiAFQThqIg8pAwA3AwAgBSAFKQMwNwMYAkACQAJAIBdB/wFxBEAgBUHIAGogBUEYahD8FyAFLwFMIRcgBSgCSCIbQQRHBEAgCCAFKQFONwEKIAhBEGogBUHUAGopAQA3AQAgCCAXOwEIIAggGzYCBCAIQQE2AgAMAwsCQAJAAkAgF0EBaw4CAQACCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCENQQEhCwwGCyAFKQNQIk6nIQ1BASELIAUoAkwiF0EERg0FIAggBSkDWDcCECAIIA02AgggCCAXNgIEIAhBATYCACAIIE5CIIg+AgwMBAsgBUHIAGogBBDCFSAPIBFBCGooAgA2AgAgBSARKQIANwMwIAUoAkgiF0EERg0CIAUoAlghDSAIIAUpAzA3AgggCCANNgIUIAggFzYCBCAIQQE2AgAgCEEQaiAFQThqKAIANgIADAMLIAVByABqIAQgBS0AKEHAABDJAiAFKAJIIhdBBEYNAyAIIAUpAkw3AgggCEEQaiAFQdQAaikCADcCACAIQQE2AgAgCCAXNgIEDAILIAVBGGoQhjAgBUHIAGogBBCoKSAFKAJIIhFBBEcEQCAIIAUpAkw3AgggCEEQaiAFQdQAaikCADcCACAIQQE2AgAgCCARNgIEDAYLIAggBSkDCDcCDCAIIA02AgggCCALNgIEIAhBADYCACAIQRRqIAVBEGooAgA2AgAMBgsgBUHQAGoiFyAPKAIANgIAIAUgBSkDMDcDSCAFQQhqEIYwIAVBEGogFygCADYCACAFIAUpA0g3AwgMAQsgBUEYahCGMAwDCyAFQRhqEIYwIAVByABqIAQQ0wkgDyARQQhqKQIANwMAIAwgEUEQaigCADYCACAFIBEpAgA3AzAgBSgCSEUNAAsLIAggBSkDMDcCBCAIQQE2AgAgCEEUaiAMKAIANgIAIAhBDGogBUE4aikDADcCAAsgBUEIahCGMAsgBUHgAGokACAkIB1BCGopAgA3AwAgIyAdQRBqKAIANgIAIAIgHSkCADcDUCACKAJoDQIgAkHIAGoiBSAjKAIANgIAIAJBQGsiCCAkKQMANwMAIAIgAikDUDcDOCACKAIIQRJHBEAgMxCGMAwECyACQfgAaiINIAUoAgA2AgAgAkHwAGoiBSAIKQMANwMAIAIgAikDODcDaCACQQhqEKYoIAJBGGogDSgCADYCACACQRBqIAUpAwA3AwAgAiACKQNoNwMIDAMLIAJB6ABqIAQgAi0AMEHAABDJAiACKAJoIgVBBEYNAiAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAULIAJBIGoQhjAgAkHoAGogBBCoKSACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAYLAkAgIEUEQCACQegAakG0gtAAQSwQoh8MAQsgIEEBTARAIAJB+ABqIAJBGGooAgA2AgAgAkHwAGogAkEQaikDADcDACACIAIpAwg3A2gjAEEgayIFJAAgBgJ/IAJB6ABqIggoAgBBEkcEQCAGIAgpAgA3AgQgBkEUaiAIQRBqKAIANgIAIAZBDGogCEEIaikCADcCAEEADAELIAVBEGpBpIDQAEEpEKIfIAZBDGogBUEUaikCADcCACAGQRRqIAVBHGooAgA2AgAgBUEBNgIMIAYgBSkCDDcCBEEBCzYCACAFQSBqJAAMCAsgAkHoAGpB4ILQAEE6EKIfCyAGQoGAgIAQNwIAIAYgAikCaDcCCCAGQRBqIAJB8ABqKQIANwIAIAJBCGoQpigMBgsgBiACKQNQNwIEIAZBATYCACAGQRRqIAJB4ABqKAIANgIAIAZBDGogAkHYAGopAwA3AgAMAwsgAkEgahCGMCACQegAaiAEENMJICQgHUEIaikCADcDACAjIB1BEGooAgA2AgAgAiAdKQIANwNQICBBAWohICACKAJoRQ0ACwsgBiACKQNQNwIEIAZBATYCACAGQRRqICMoAgA2AgAgBkEMaiACQdgAaikDADcCAAwBCyACQSBqEIYwCyACQQhqEKYoCyACQYABaiQAIBkgGkEIaikCADcDACAUIBpBEGooAgA2AgAgByAaKQIANwNAIAcoAlgNBSAHQegAaiICIBQoAgA2AgAgB0HgAGoiBiAZKQMANwMAIAcgBykDQDcDWCAHQRBqEKYoIAdBIGogAigCADYCACAHQRhqIAYpAwA3AwAgByAHKQNYNwMQDAILIAdB2ABqIAQgBy0AOEHAABDJAiAHKAJYIgJBBEYNASAKIAcpAlw3AgggCkEQaiAHQeQAaikCADcCACAKQQI2AgAgCiACNgIEDAULIAdBKGoQhjAgB0HYAGogBBCoKSAHKAJYIgJBBEcEQCAKIAcpAlw3AgggCkEQaiAHQeQAaikCADcCACAKQQI2AgAgCiACNgIEDAYLIAdB2ABqQZqD0ABBEiAHEPUdIAcoAlgiAkEERwRAIAogBykCXDcCCCAKQRBqIAdB5ABqKQIANwIAIApBAjYCACAKIAI2AgQMBgsgBygCACICQYCAgIB4RwRAIAogBykDEDcCQCAKIAcpAgQ3AlggCiACNgJUIAogKTYCPCAKICY2AjggCiAoNgI0IAogLjYCMCAKIC82AiwgCiAtNgIoIAogJzYCJCAKIBg2AiAgCiASNgIcIAogLDYCGCAKICU2AhQgCiATNgIQIAogFjYCDCAKIDc2AgggCiAJNgIEIAogNjYCACAKQcgAaiAHQRhqKQMANwIAIApB0ABqIAdBIGooAgA2AgAMBwtB+PzPAEHHAEGsg9AAEMskAAsgB0EoahCGMCAHQdgAaiAEENMJIBkgGkEIaikCADcDACAUIBpBEGooAgA2AgAgByAaKQIANwNAIAcoAlhFDQALCyAKIAcpA0A3AgQgCkECNgIAIApBFGogFCgCADYCACAKQQxqIAdByABqKQMANwIADAILIAogBykDQDcCBCAKQQI2AgAgCkEUaiAHQdAAaigCADYCACAKQQxqIAdByABqKQMANwIACyAHQShqEIYwCyAHQRBqEKYoIAcQhjALIAdB8ABqJAAgHyAeQQhqKQIANwMAICIgHkEQaigCADYCACADIB4pAgA3A9gDIAMoArABIgZBAkYEQCAOIAMpA9gDNwIEIA5BAzYCACAOQRRqIANB6ANqKAIANgIAIA5BDGogA0HgA2opAwA3AgAgA0G0A2oiAhD3HSACQQRB4AAQ4B4MGgsgA0GQAmogR0HIAPwKAAAgA0HgAmoiCiAfKQMANwMAIANB6AJqIgUgIigCADYCACADIAMpA9gDNwPYAiADKAK8AyIHIAMoArQDRgRAIANBtANqQcSb0AAQnygLIAMoArgDIAdB4ABsaiICIAY2AgAgAiADKQPYAjcCBCACQQxqIAopAwA3AgAgAkEUaiAFKAIANgIAIAJBGGogA0GQAmpByAD8CgAAIAMgB0EBajYCvAMgFUEBayIVDQALCyADQbgBaiICIANBvANqKAIANgIAIAMgAykCtAM3A7ABIANBCGoQty8gA0EQaiACKAIANgIAIAMgAykDsAE3AwgMEwsgA0GwAWogBBDAHCADKAKwAQ0VIAMpA7gBIVRCASFVDBILIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMFgsgA0GwAWogFUEAQQhB0AAQoBggAygCtAEhAiADKAKwAUEBRg0IIANBADYCvAMgAyADKAK4ATYCuAMgAyACNgK0AyAVQQBKBEADQCADQbABaiEIQgAhVkEAISVBACEsQgAhXUIAIV5BACEvQgAhX0IAIVdCACFYQgAhYEIAIWEjAEHQCGsiByQAIAdBgAFqIAQQ8CcgB0HwAGoiAiAHQYwBaiIGKAIANgIAIAcgBykChAE3A2gCQCAHKAKAASIKQQRHBEAgBygCkAEhBiAIIAcpA2g3AgwgCCAGNgIYIAggCjYCCCAIQgI3AwAgCEEUaiACKAIANgIADAELIAdB0ABqIAIoAgA2AgAgByAHKQNoNwNIIAdByABqEIYwIAdBgICAgHg2AgggB0IANwMYIAdCADcDKCAHQYCAgIB4NgI4IAdBgAFqIAQQ0wkgAiAGKQIANwMAIAdB+ABqIhcgB0GUAWooAgA2AgAgByAHKQKEATcDaAJAAkAgBygCgAFFBEAgB0GcAWohSSAHQYgBaiE9IAdBhAFqIT4DQCAHQdgAaiAXKAIAIgI2AgAgB0HQAGogB0HwAGoiNCkDADcDACAHIAcpA2g3A0gCQAJAAkACQAJAAkACQAJAAkACQAJAIAJB/wFxBEAgB0GAAWogB0HIAGoQ/BcgBy8BhAEhAiAHKAKAASIGQQRHBEAgCCAHKQGGATcBDiAIQRRqIAdBjAFqKQEANwEAIAggAjsBDCAIIAY2AgggCEICNwMADA8LAkACQAJAAkACQAJAAkACQCACQQFrDgcBAgMEBQYABwsgB0GAAWogBBDAHCAHKAKAAUUEQCAHLwGIASEsQQEhJQwTCyAHKQOIASJOpyEsQQEhJSAHKAKEASICQQRGDRIgCCAHKQOQATcCFCAIICw7AQwgCCACNgIIIAhCAjcDACAIQRJqIE5CMIg9AQAgCCBOQhCIPgEODBULIAdBgAFqIAQQyQ8gBygChAEhESAHKAKAASICQQRHBEAgCCAHKQCJATcAESAIQRhqIAdBkAFqKAAANgAAIAggBy0AiAE6ABAgCCARNgIMIAggAjYCCCAIQgI3AwAMFQsgB0GAAWogEUEAQQhB6AMQoBggBygChAEhAiAHKAKAAUEBRg0HIAdBADYCZCAHIAcoAogBNgJgIAcgAjYCXCARQQBKBEADQCAHQYABaiENQgAhWUEAIS1BACEuQQAhREEAITZBACE3QgAhUkIAIVpCACFbQgAhXEIAIVEjAEHgCWsiCiQAIApB+ANqIAQQ8CcgCkEoaiIyIApBhARqIgIoAgA2AgAgCiAKKQL8AzcDIAJAIAooAvgDIgZBBEcEQCAKKAKIBCECIA0gCikDIDcCDCANIAI2AhggDSAGNgIIIA1CAjcDACANQRRqIDIoAgA2AgAMAQsgCkGAB2oiBiAyKAIANgIAIAogCikDIDcD+AYgCkH4BmoQhjAgCkGAgICAeDYCACAKQgI3AyAgCkGBgICAeDYCoAMgCkGAgICAeDYCuAMgCkH4A2ogBBDTCSAGIAIpAgA3AwAgCkGIB2oiGyAKQYwEaigCADYCACAKIAopAvwDNwP4BgJAAkACQAJAAkACQAJAIAooAvgDRQRAIApB/ANqIRggCkE8aiFKIApBlARqIUsgCkGABGohPyAKQaQDaiFAA0AgCkHYA2ogGygCACICNgIAIApB0ANqIApBgAdqIiMpAwA3AwAgCiAKKQP4BjcDyAMCQAJAAkAgAkH/AXEEQCAKQfgDaiAKQcgDahD8FyAKLwH8AyECIAooAvgDIgZBBEcEQCANIAopAf4DNwEOIA1BFGogCkGEBGopAQA3AQAgDSACOwEMIA0gBjYCCCANQgI3AwAMDAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkEBaw4JAgMEBQAHAQkKCwsgCkH4A2ogBBDAHAJAIAooAvgDRQRAIAooAoAEIS0MAQsgCikDgAQiTqchLSAKKAL8AyICQQRHDQYLQQEhRAwOCyAKQfgDaiAEEMAcAkAgCigC+ANFBEAgCigCgAQhLgwBCyAKKQOABCJOpyEuIAooAvwDIgJBBEcNBwtBASE2DA0LIApB+ANqIAQQwhUgIyAYQQhqKAIANgIAIAogGCkCADcD+AYgCigC+AMiAkEERg0KIAooAogEIQYgDSAKKQP4BjcCDCANIAY2AhggDSACNgIIIA1CAjcDACANQRRqIApBgAdqKAIANgIADBQLIApB+ANqIAQQwBwgCigC+AMNEiAKKQOABCFZQQEhN0IBIVIMCwsgCkH4A2ohBkEAISBBACEzQQAhJkEAIRZBACEnQQAhKEIAIWJCACFjQgAhZEEAISlCACFlQgAhZkIAIWdCACFoQgAhaUIAIWpCACFrQgAhbEIAIW1CACFuIwBBsAVrIgIkACACQegDaiAEEPAnIAJBmAJqIjAgAkH0A2oiBSgCADYCACACIAIpAuwDNwOQAgJAIAIoAugDIglBBEcEQCACKAL4AyEFIAYgAikDkAI3AgwgBiAFNgIYIAYgCTYCCCAGQgI3AwAgBkEUaiAwKAIANgIADAELIAJBiAFqIkEgMCgCADYCACACIAIpA5ACNwOAASACQYABahCGMCACQQA2AgAgAkGAgICAeDYCCCACQYCAgIB4NgIYIAJBADYCKCACQgA3AzAgAkIANwNAIAJCADcDUCACQYCAgIB4NgJgIAJCADcDcCACQgI3A4ABIAJBgICAgHg2AtgBIAJCAjcD6AEgAkIDNwOQAiACQegDaiAEENMJIAJB4ARqIAUpAgA3AwAgAkHoBGoiJCACQfwDaigCADYCACACIAIpAuwDNwPYBCACQfACaiFFAkACQCACKALoA0UEQCACQewDaiEaIAJBnAFqIUwgAkGEBGohOSACQfADaiEZIAJBhAJqIUYgAkHwAWohQiACQawCaiFNA0AgAkGQA2ogJCgCACIFNgIAIAJBiANqIAJB4ARqIh0pAwA3AwAgAiACKQPYBDcDgAMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAVB/wFxBEAgAkHoA2ogAkGAA2oQ/BcgAi8B7AMhBSACKALoAyIJQQRHBEAgBiACKQHuAzcBDiAGQRRqIAJB9ANqKQEANwEAIAYgBTsBDCAGIAk2AgggBkICNwMADBULAkACQAJAAkAgBUEBaw4RAAMSAREQDw4NDAsKCQgCBwYFCyACQegDaiAEEMAcIAIoAugDRQRAIAIoAvADISAMFAsgAikD8AMiTqchICACKALsAyIFQQRGDRMgBiACKQP4AzcCFCAGICA2AgwgBiAFNgIIIAZCAjcDACAGIE5CIIg+AhAMFwsgAkHoA2ogBBDAHCACKALoA0UEQCACKALwAyEzDBILIAIpA/ADIk6nITMgAigC7AMiBUEERg0RIAYgAikD+AM3AhQgBiAzNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQDBYLIAJB6ANqIAQQwBwgAigC6ANFBEAgAigC8AMhJkEBIRYMEwsgAikD8AMiTqchJkEBIRYgAigC7AMiBUEERg0SIAYgAikD+AM3AhQgBiAmNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQDBULIAJB6ANqIAQQyQ8gAigC7AMhCyACKALoAyIFQQRHBEAgBiACKQDxAzcAESAGQRhqIAJB+ANqKAAANgAAIAYgAi0A8AM6ABAgBiALNgIMIAYgBTYCCCAGQgI3AwAMFQsgAkHoA2ogC0EAQQRBBBCgGCACKALsAyEFIAIoAugDQQFHBEAgAkEANgLgBCACIAIoAvADNgLcBCACIAU2AtgEIAtBAEoEQANAIAJB6ANqIAQQwBwCQCACKALoA0UEQCACKALwAyEPDAELIAIpA/ADIk6nIQ8gAigC7AMiBUEERg0AIAYgAikD+AM3AhQgBiAPNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQIAJB2ARqQQRBBBDgHgwYCyACKALgBCIFIAIoAtgERgRAIAJB2ARqQZiO0AAQnSgLIAIoAtwEIAVBAnRqIA82AgAgAiAFQQFqNgLgBCALQQFrIgsNAAsLIAJB8ANqIgUgHSgCADYCACACIAIpAtgENwPoAyACKAIIQYCAgIB4RwRAIAJBCGpBBEEEEOAeCyACQRBqIAUoAgA2AgAgAiACKQPoAzcDCAwSCyAFIAIoAvADQYiO0AAQ/S8ACyACQYADahCGMCACQegDaiAEEKgpIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakGIj9AAQRQgAhDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsgAkHoA2pBnI/QAEEYIAJBCGoQ9R0gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQbSP0ABBHSACQRhqEPUdIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakHRj9AAQRQgAkEoahDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsgAkHoA2pB5Y/QAEEZIAJBMGoQ5h4gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQf6P0ABBJiACQUBrEOYeIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakGkkNAAQSQgAkHQAGoQ5h4gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQciQ0ABBHyACQfAAahDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsCQAJAAkACQAJAAkACQCAnBEAgAigCCCIFQYCAgIB4Rg0BIAIoAhgiCUGAgICAeEYNAiAoRQ0DIGJQDQQgY1ANBSBkUA0GIClFDQcgAikCDCFOIAIpAhwhTyAGQTBqIAJBgAFqQdgA/AoAACAGQfQCaiACQeABaigCADYCACAGIAIpA9gBNwLsAiAGQYgBaiACQegBakEo/AoAACAGQbABaiACQZACakHwAPwKAAAgBiAzNgL8AiAGICA2AvgCIAYgTzcD2AIgBiAJNgLUAiAGIE43AswCIAYgBTYCyAIgBiBlNwPAAiAGIGY3A7gCIAYgZzcDsAIgBiBoNwOoAiAGICY2AqQCIAYgFjYCoAIgBiBpNwMoIAYgajcDICAGIGs3AxggBiBsNwMQIAYgbTcDCCAGIG43AwAgBkHoAmogAkHoAGooAgA2AgAgBiACKQNgNwLgAgwdC0H4/M8AQccAQeiQ0AAQyyQAC0H4/M8AQccAQfiQ0AAQyyQAC0H4/M8AQccAQYiR0AAQyyQAC0H4/M8AQccAQZiR0AAQyyQAC0H4/M8AQccAQaiR0AAQyyQAC0H4/M8AQccAQbiR0AAQyyQAC0H4/M8AQccAQciR0AAQyyQAC0H4/M8AQccAQdiR0AAQyyQACyACQegDaiAEIAItAJADQcAAEMkCIAIoAugDIgVBBEYNDyAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwSCyACQegDaiEPIwBBwAJrIgUkACAFQeABaiAEEPAnIAVBkAFqIgkgBUHsAWoiCygCADYCACAFIAUpAuQBNwOIAQJAIAUoAuABIgxBBEcEQCAFKALwASELIA8gBSkDiAE3AgwgDyALNgIYIA8gDDYCCCAPQgM3AwAgD0EUaiAJKAIANgIADAELIAVBEGogCSgCADYCACAFIAUpA4gBNwMIIAVBCGoQhjAgBUGAgICAeDYCYCAFQeABaiAEENMJIAkgCykCADcDACAFQZgBaiITIAVB9AFqKAIANgIAIAUgBSkC5AE3A4gBAkACQCAFKALgAUUEQCAFQegBaiEUIAVB5AFqISpCAiFOA0AgBUGAAWogEygCACIJNgIAIAVB+ABqIAVBkAFqIispAwA3AwAgBSAFKQOIATcDcAJAAkAgCUH/AXEEQCAFQeABaiAFQfAAahD8FyAFLwHkASEJIAUoAuABIgtBBEcEQCAPIAUpAeYBNwEOIA9BFGogBUHsAWopAQA3AQAgDyAJOwEMIA8gCzYCCCAPQgM3AwAMBgsCQAJAIAlBAWsOAgABAwsgBUHgAWohC0IAIU5CACFPQgAhUEIAIVNCACFvQgAhcEIAIXFCACFyRAAAAAAAAAAAIXNEAAAAAAAAAAAhdEQAAAAAAAAAACF1RAAAAAAAAAAAIXZEAAAAAAAAAAAhd0QAAAAAAAAAACF4RAAAAAAAAAAAIXlEAAAAAAAAAAAheiMAQZABayIJJAAgCUH4AGogBBDwJyAJQegAaiIMIAlBhAFqIhIoAgA2AgAgCSAJKQJ8NwNgAkACQAJAIAkoAngiIUEERwRAIAkoAogBIRIgCyAJKQNgNwIMIAsgEjYCGCALICE2AgggC0ICNwMAIAtBFGogDCgCADYCAAwBCyAJQdAAaiAMKAIANgIAIAkgCSkDYDcDSCAJQcgAahCGMCAJQgA3AwggCUH4AGogBBDTCSAMIBIpAgA3AwAgCUHwAGoiISAJQYwBaigCADYCACAJIAkpAnw3A2ACQCAJKAJ4RQRAIAlB/ABqITFBACESA0AgCUHYAGogISgCACIMNgIAIAlB0ABqIAlB6ABqIkMpAwA3AwAgCSAJKQNgNwNIAkAgDEH/AXEEQCAJQfgAaiAJQcgAahD8FyAJLwF8ITogCSgCeCIMQQRHBEAgCyAJKQF+NwEOIAtBFGogCUGEAWopAQA3AQAgCyA6OwEMDAULAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCA6QQFrDggAAQIDBAUGBxALIAQoAhAiDEEHSw0HDBYLIAQoAhAiDEEHSw0HDBULIAQoAhAiDEEHSw0HDBQLIAQoAhAiDEEHSw0HQQggDEHEs84AELA7AAsgBCgCECIMQQdLDQcMEgsgBCgCECIMQQdLDQcMEQsgBCgCECIMQQdLDQcMEAsgBCgCECIMQQdLDQcMDwsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhc0IBIVAMCQsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdEIBIU8MCAsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdUIBIU4MBwsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdkEBIRJCASFyDAYLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXdCASFTDAULIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXhCASFvDAQLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXlCASFwDAMLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXpCASFxDAILIAlB+ABqIAQgCS0AWEHAABDJAiAJKAJ4IgxBBEYNASALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCAAwECyAJIHY5A0AgCSByNwM4IAkgdTkDMCAJIE43AyggCSB0OQMgIAkgTzcDGCAJIHM5AxAgCSBQNwMIIAlByABqEIYwIAlB+ABqIAQQqCkgCSgCeCIMQQRHBEAgCyAJKQJ8NwIMIAtBFGogCUGEAWopAgA3AgAgC0ICNwMAIAsgDDYCCAwFCyAJQfgAakG4/M8AQRAgCUEIahDmHiAJKAJ4IgxBBEcEQCALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCACALQgI3AwAgCyAMNgIIDAULIAlB+ABqQcj8zwBBECAJQRhqEOYeIAkoAngiDEEERwRAIAsgCSkCfDcCDCALQRRqIAlBhAFqKQIANwIAIAtCAjcDACALIAw2AggMBQsgCUH4AGpB2PzPAEEQIAlBKGoQ5h4gCSgCeCIMQQRHBEAgCyAJKQJ8NwIMIAtBFGogCUGEAWopAgA3AgAgC0ICNwMAIAsgDDYCCAwFCyAJQfgAakHo/M8AQRAgCUE4ahDmHiAJKAJ4IgxBBEcEQCALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCACALQgI3AwAgCyAMNgIIDAULAkACQAJAIFBQRQRAIE9QDQEgTlANAiASRQ0DIAsgdjkDWCALIHU5A1AgCyB0OQNIIAsgczkDQCALIHo5AzggCyBxNwMwIAsgeTkDKCALIHA3AyAgCyB4OQMYIAsgbzcDECALIHc5AwggCyBTNwMADAgLQfj8zwBBxwBBwP3PABDLJAALQfj8zwBBxwBB0P3PABDLJAALQfj8zwBBxwBB4P3PABDLJAALQfj8zwBBxwBB8P3PABDLJAALIAlByABqEIYwIAlB+ABqIAQQ0wkgQyAxQQhqKQIANwMAICEgMUEQaigCADYCACAJIDEpAgA3A2AgCSgCeEUNAAsLIAsgCSkDYDcCCCALQgI3AwAgC0EYaiAhKAIANgIAIAtBEGogCUHoAGopAwA3AgAMAQsgCyAMNgIIIAtCAjcDACAJQcgAahCGMAsgCUGQAWokAAwBC0EIIAxBxLPOABCwOwALIAUpA+ABIk5CAlIEQCAFQYgBaiIJIBRB2AD8CgAAIAVBCGogCUHYAPwKAAAMBAsgBUGYAWogFEEQaigCACIJNgIAIAVBkAFqIBRBCGopAwAiTjcDACAFIBQpAwAiTzcDiAEgD0EYaiAJNgIAIA9BEGogTjcDACAPIE83AwggD0IDNwMADAYLIAVB4AFqIAQQyQ8gBSgC5AEhCyAFKALgASIJQQRHBEAgDyAFKQDpATcAESAPQRhqIAVB8AFqKAAANgAAIA8gBS0A6AE6ABAgDyALNgIMIA8gCTYCCCAPQgM3AwAMBgsgBUHgAWogC0EAQQRBBBCgGCAFKALkASEJIAUoAuABQQFHBEAgBUEANgKQASAFIAUoAugBNgKMASAFIAk2AogBIAtBAEoEQANAIAVB4AFqIAQQwBwCQCAFKALgAUUEQCAFKALoASEMDAELIAUpA+gBIk+nIQwgBSgC5AEiCUEERg0AIA8gBSkD8AE3AhQgDyAMNgIMIA8gCTYCCCAPQgM3AwAgDyBPQiCIPgIQIAVBiAFqEOk7DAkLIAUoApABIgkgBSgCiAFGBEAgBUGIAWpBkP7PABCdKAsgBSgCjAEgCUECdGogDDYCACAFIAlBAWo2ApABIAtBAWsiCw0ACwsgBUHoAWoiCSArKAIANgIAIAUgBSkCiAE3A+ABIAVB4ABqEJcwIAVB6ABqIAkoAgA2AgAgBSAFKQPgATcDYAwDCyAJIAUoAugBQYD+zwAQ/S8ACyAFQfAAahCGMCAFQeABaiAEEKgpIAUoAuABIglBBEcEQCAPIAUpAuQBNwIMIA9BFGogBUHsAWopAgA3AgAgD0IDNwMAIA8gCTYCCAwGCyAPQQhqIAVBCGpB2AD8CgAAIA8gTjcDACAPQegAaiAFQegAaigCADYCACAPIAUpA2A3AmAMBgsgBUHgAWogBCAFLQCAAUHAABDJAiAFKALgASIJQQRGDQAgDyAFKQLkATcCDCAPQRRqIAVB7AFqKQIANwIAIA9CAzcDACAPIAk2AggMAwsgBUHwAGoQhjAgBUHgAWogBBDTCSArICpBCGopAgA3AwAgEyAqQRBqKAIANgIAIAUgKikCADcDiAEgBSgC4AFFDQALCyAPIAUpA4gBNwIIIA9CAzcDACAPQRhqIBMoAgA2AgAgD0EQaiAFQZABaikDADcCAAwBCyAFQfAAahCGMAsgBUHgAGoQlzALIAVBwAJqJAAgAkHYA2oiBSAZQQhqKQMANwMAIAJB4ANqIgkgGUEQaigCADYCACACIBkpAwA3A9ADIAIpA+gDIk5CA1IEQCACQdgEaiA5QdQA/AoAACACQfgDaiILIAkoAgA2AgAgAkHwA2oiCSAFKQMANwMAIAIgAikD0AM3A+gDIAIpA5ACQgNSBEAgRRCXMAsgMCACKQPoAzcDACAwQQhqIAkpAwA3AwAgMEEQaiALKAIANgIAIAIgTjcDkAIgTSACQdgEakHUAPwKAAAMDwsgBiACKQPQAzcDCCAGQgI3AwAgBkEYaiACQeADaigCADYCACAGQRBqIAJB2ANqKQMANwMADBELIAJB6ANqIQlCACFOQgAhTyMAQfAAayIFJAAgBUHYAGogBBDwJyAFQcgAaiILIAVB5ABqIgwoAgA2AgAgBSAFKQJcNwNAAkAgBSgCWCIPQQRHBEAgBSgCaCEMIAkgBSkDQDcCDCAJIAw2AhggCSAPNgIIIAlCAjcDACAJQRRqIAsoAgA2AgAMAQsgBUEwaiALKAIANgIAIAUgBSkDQDcDKCAFQShqEIYwIAVBgICAgHg2AgggBUGAgICAeDYCGCAFQdgAaiAEENMJIAsgDCkCADcDACAFQdAAaiIMIAVB7ABqKAIANgIAIAUgBSkCXDcDQAJAAkAgBSgCWEUEQCAFQdwAaiEPA0AgBUE4aiAMKAIAIgs2AgAgBUEwaiAFQcgAaiISKQMANwMAIAUgBSkDQDcDKAJAAkACQCALQf8BcQRAIAVB2ABqIAVBKGoQ/BcgBS8BXCELIAUoAlgiFEEERwRAIAkgBSkBXjcBDiAJQRRqIAVB5ABqKQEANwEAIAkgCzsBDCAJIBQ2AgggCUICNwMADAcLAkACQAJAAkAgC0EBaw4DAAECAwsgBUHYAGogBBDAHCAFKAJYRQRAIAUpA2AhT0IBIU4MBwsgBSgCXCELIAUpA2AhTiAJIAUpA2g3AhQgCSBONwIMIAkgCzYCCCAJQgI3AwAMCQsgBUHYAGogBBDJDyAFKAJcIQsgBSgCWCIUQQRHBEAgCSAFKQBhNwARIAlBGGogBUHoAGooAAA2AAAgCSAFLQBgOgAQIAkgCzYCDCAJIBQ2AgggCUICNwMADAkLIAVB2ABqIAtBAEEIQQgQoBggBSgCXCEUIAUoAlhBAUYNAyAFQQA2AkggBSAFKAJgNgJEIAUgFDYCQCALQQBKBEADQCAFQdgAaiAEEMAcIAUoAlgEQCAFKAJcIQsgBSkDYCFOIAkgBSkDaDcCFCAJIE43AgwgCSALNgIIIAlCAjcDACAFQUBrEOM8DAsLIAUpA2AhUCAFKAJIIhQgBSgCQEYEQCAFQUBrQYj8zwAQsygLIAUoAkQgFEEDdGogUDcDACAFIBRBAWo2AkggC0EBayILDQALCyAFQeAAaiILIBIoAgA2AgAgBSAFKQJANwNYIAVBCGoQhTAgBUEQaiALKAIANgIAIAUgBSkDWDcDCAwFCyAFQdgAaiAEEMkPIAUoAlwhCyAFKAJYIhRBBEcEQCAJIAUpAGE3ABEgCUEYaiAFQegAaigAADYAACAJIAUtAGA6ABAgCSALNgIMIAkgFDYCCCAJQgI3AwAMCAsgBUHYAGogC0EAQQhBCBCgGCAFKAJcIRQgBSgCWEEBRg0DIAVBADYCSCAFIAUoAmA2AkQgBSAUNgJAIAtBAEoEQANAIAVB2ABqIAQQwBwgBSgCWARAIAUoAlwhCyAFKQNgIU4gCSAFKQNoNwIUIAkgTjcCDCAJIAs2AgggCUICNwMAIAVBQGsQ4zwMCgsgBSkDYCFQIAUoAkgiFCAFKAJARgRAIAVBQGtBqPzPABCzKAsgBSgCRCAUQQN0aiBQNwMAIAUgFEEBajYCSCALQQFrIgsNAAsLIAVB4ABqIgsgEigCADYCACAFIAUpAkA3A1ggBUEYahCFMCAFQSBqIAsoAgA2AgAgBSAFKQNYNwMYDAQLIAVB2ABqIAQgBS0AOEHAABDJAiAFKAJYIgtBBEYNAyAJIAUpAlw3AgwgCUEUaiAFQeQAaikCADcCACAJQgI3AwAgCSALNgIIDAYLIAVBKGoQhjAgBUHYAGogBBCoKSAFKAJYIgtBBEcEQCAJIAUpAlw3AgwgCUEUaiAFQeQAaikCADcCACAJQgI3AwAgCSALNgIIDAcLIAkgBSkDCDcCECAJIAUpAxg3AhwgCSBPNwMIIAkgTjcDACAJQRhqIAVBEGooAgA2AgAgCUEkaiAFQSBqKAIANgIADAcLIBQgBSgCYEH4+88AEP0vAAsgFCAFKAJgQZj8zwAQ/S8ACyAFQShqEIYwIAVB2ABqIAQQ0wkgEiAPQQhqKQIANwMAIAwgD0EQaigCADYCACAFIA8pAgA3A0AgBSgCWEUNAAsLIAkgBSkDQDcCCCAJQgI3AwAgCUEYaiAMKAIANgIAIAlBEGogBUHIAGopAwA3AgAMAQsgBUEoahCGMAsgBUEYahCFMCAFQQhqEIUwCyAFQfAAaiQAIB0gGUEIaikDADcDACAkIBlBEGooAgA2AgAgAiAZKQMANwPYBCACKQPoAyJOQgJSBEAgAkHYA2oiBSA5QQhqKAIANgIAIAIgOSkCADcD0AMgAkH4A2oiCSAkKAIANgIAIAJB8ANqIgsgHSkDADcDACACIAIpA9gENwPoAyACQegBahDTLiBCIAIpA+gDNwMAIEJBCGogCykDADcDACBCQRBqIAkoAgA2AgAgRiACKQPQAzcCACBGQQhqIAUoAgA2AgAgAiBONwPoAQwOCyAGIAIpA9gENwMIIAZCAjcDACAGQRhqIAJB6ARqKAIANgIAIAZBEGogAkHgBGopAwA3AwAMEAsgAkHoA2ogBBDAHCACKALoA0UEQCACKQPwAyFpQgEhagwNCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwPCyACQegDaiAEEMkPIAIoAuwDIQsgAigC6AMiBUEERwRAIAYgAikA8QM3ABEgBkEYaiACQfgDaigAADYAACAGIAItAPADOgAQIAYgCzYCDCAGIAU2AgggBkICNwMADA8LIAJB6ANqIAtBAEEEQQwQoBggAigC7AMhBQJAIAIoAugDQQFHBEAgAkEANgLYAyACIAIoAvADNgLUAyACIAU2AtADIAtBAEwNAQNAIAJB6ANqIQlBACEqQQAhD0EAIRRBACETQQAhEiMAQeAAayIFJAAgBUHIAGogBBDwJyAFQThqIgwgBUHUAGoiISgCADYCACAFIAUpAkw3AzACQCAFKAJIIjFBBEcEQCAFKAJYIQ8gCSAFKQMwNwIEIAkgDzYCECAJIDE2AgAgCUEMaiAMKAIANgIADAELIAVBIGogDCgCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQcgAaiAEENMJIAwgISkCADcDACAFQUBrIiEgBUHcAGooAgA2AgAgBSAFKQJMNwMwIAUoAkhFBEAgBUHMAGohMUEAIQwDQCAFQShqICEoAgAiKzYCACAFQSBqIAVBOGoiOikDADcDACAFIAUpAzA3AxgCQAJAICtB/wFxBEAgBUHIAGogBUEYahD8FyAFLwFMISsgBSgCSCJDQQRHBEAgCSAFKQFONwEGIAlBDGogBUHUAGopAQA3AQAgCSArOwEEIAkgQzYCAAwCCwJAAkACQAJAAkACQCArQQFrDgMAAQIFCyAFQcgAaiAEEMAcAkAgBSgCSEUEQCAFKAJQIRQMAQsgBSkDUCJOpyEUIAUoAkwiD0EERw0DC0EBIQ8MBwsgBUHIAGogBBDAHAJAIAUoAkhFBEAgBSgCUCETDAELIAUpA1AiTqchEyAFKAJMIipBBEcNAwtBASEqDAYLIAVByABqIAQQwBwgBSgCSEUEQCAFKAJQIRJBASEMDAYLIAUpA1AiTqchEkEBIQwgBSgCTCIrQQRGDQUgCSAFKQNYNwIMIAkgEjYCBCAJICs2AgAgCSBOQiCIPgIIDAQLIAkgBSkDWDcCDCAJIBQ2AgQgCSAPNgIAIAkgTkIgiD4CCAwDCyAJIAUpA1g3AgwgCSATNgIEIAkgKjYCACAJIE5CIIg+AggMAgsgBUHIAGogBCAFLQAoQcAAEMkCIAUoAkgiK0EERg0CIAkgBSkCTDcCBCAJQQxqIAVB1ABqKQIANwIAIAkgKzYCAAwBCyAFIBI2AhQgBSAMNgIQIAUgEzYCDCAFICo2AgggBSAUNgIEIAUgDzYCACAFQRhqEIYwIAVByABqIAQQqCkgBSgCSCIhQQRHBEAgCSAFKQJMNwIEIAlBDGogBUHUAGopAgA3AgAgCSAhNgIADAULIAVByABqQYyN0ABBGyAFEOYeIAUoAkgiIUEERwRAIAkgBSkCTDcCBCAJQQxqIAVB1ABqKQIANwIAIAkgITYCAAwFCyAFQcgAakGnjdAAQRogBUEIahDmHiAFKAJIIiFBBEcEQCAJIAUpAkw3AgQgCUEMaiAFQdQAaikCADcCACAJICE2AgAMBQsgBUHIAGpBwY3QAEEXIAVBEGoQ5h4gBSgCSCIhQQRHBEAgCSAFKQJMNwIEIAlBDGogBUHUAGopAgA3AgAgCSAhNgIADAULAkACQCAPBEAgKkUNASAMRQ0CIAkgEjYCDCAJIBM2AgggCSAUNgIEIAlBBDYCAAwHC0H4/M8AQccAQdiN0AAQyyQAC0H4/M8AQccAQeiN0AAQyyQAC0H4/M8AQccAQfiN0AAQyyQACyAFQRhqEIYwDAMLIAVBGGoQhjAgBUHIAGogBBDTCSA6IDFBCGopAgA3AwAgISAxQRBqKAIANgIAIAUgMSkCADcDMCAFKAJIRQ0ACwsgCSAFKQMwNwIAIAlBEGogISgCADYCACAJQQhqIAVBOGopAwA3AgALIAVB4ABqJAAgHSAaQQhqKAIANgIAIAIgGikCADcD2AQgAigC6AMiBUEERwRAIAIoAvgDIQkgBiACKQPYBDcCDCAGIAk2AhggBiAFNgIIIAZCAjcDACAGQRRqIAJB4ARqKAIANgIAIAJB0ANqQQRBDBDgHgwSCyACQcgDaiIJIB0oAgA2AgAgAiACKQPYBDcDwAMgAigC2AMiBSACKALQA0YEQCACQdADakH4jtAAEJAoCyACKALUAyAFQQxsaiIMIAIpA8ADNwIAIAxBCGogCSgCADYCACACIAVBAWo2AtgDIAtBAWsiCw0ACwwBCyAFIAIoAvADQeiO0AAQ/S8ACyACQfADaiIFIAJB2ANqKAIANgIAIAIgAikC0AM3A+gDIAIoAtgBQYCAgIB4RwRAIAJB2AFqQQRBDBDgHgsgAkHgAWogBSgCADYCACACIAIpA+gDNwPYAQwLCyACQegDaiEJQgAhTkIAIU9CACFQQgAhUyMAQZABayIFJAAgBUH4AGogBBDwJyAFQegAaiILIAVBhAFqIgwoAgA2AgAgBSAFKQJ8NwNgAkAgBSgCeCIPQQRHBEAgBSgCiAEhDCAJIAUpA2A3AgwgCSAMNgIYIAkgDzYCCCAJQgI3AwAgCUEUaiALKAIANgIADAELIAVB0ABqIAsoAgA2AgAgBSAFKQNgNwNIIAVByABqEIYwIAVBgICAgHg2AgggBUGAgICAeDYCGCAFQYCAgIB4NgIoIAVBgICAgHg2AjggBUH4AGogBBDTCSALIAwpAgA3AwAgBUHwAGoiFCAFQYwBaigCADYCACAFIAUpAnw3A2ACQAJAAkACQCAFKAJ4RQRAIAVB/ABqIQtBAiESQQIhDANAIAVB2ABqIBQoAgAiEzYCACAFQdAAaiAFQegAaiIPKQMANwMAIAUgBSkDYDcDSAJAAkAgE0H/AXEEQCAFQfgAaiAFQcgAahD8FyAFLwF8IRMgBSgCeCIqQQRHBEAgCSAFKQF+NwEOIAlBFGogBUGEAWopAQA3AQAgCSATOwEMIAkgKjYCCCAJQgI3AwAMCAsCQAJAAkACQAJAAkACQAJAAkAgE0EBaw4IAAECAwQFBgcICyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRGDQkgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwPCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwPCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBGGoQhjAgBUEgaiATKAIANgIAIAUgBSkDeDcDGAwJCyAFQfgAaiAEEMAcIAUoAngNDCAFKQOAASFQQgEhTgwICyAFQfgAaiAEEMAcIAUoAngNCiAFKQOAASFTQgEhTwwHCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwMCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBKGoQhjAgBUEwaiATKAIANgIAIAUgBSkDeDcDKAwGCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwLCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBOGoQhjAgBUFAayATKAIANgIAIAUgBSkDeDcDOAwFCyAFQfgAaiAEENoQIAUtAHwhEiAFKAJ4IhNBBEYNBCAJIAUpAH03AA0gCUEUaiAFQYQBaikAADcAACAJIBI6AAwgCSATNgIIIAlCAjcDAAwJCyAFQfgAaiAEENoQIAUtAHwhDCAFKAJ4IhNBBEYNAyAJIAUpAH03AA0gCUEUaiAFQYQBaikAADcAACAJIAw6AAwgCSATNgIIIAlCAjcDAAwICyAFQfgAaiAEIAUtAFhBwAAQyQIgBSgCeCITQQRGDQIgCSAFKQJ8NwIMIAlBFGogBUGEAWopAgA3AgAgCUICNwMAIAkgEzYCCAwHCyAFQcgAahCGMCAFQfgAaiAEEKgpIAUoAngiC0EERwRAIAkgBSkCfDcCDCAJQRRqIAVBhAFqKQIANwIAIAlCAjcDACAJIAs2AggMCAsgCSAFKQMINwIgIAkgBSkDGDcCLCAJIAUpAyg3AjggCSAFKQM4NwJEIAkgEjoAUCAJIAw6AFEgCSBTNwMYIAkgTzcDECAJIFA3AwggCSBONwMAIAlBKGogBUEQaigCADYCACAJQTRqIAVBIGooAgA2AgAgCUFAayAFQTBqKAIANgIAIAlBzABqIAVBQGsoAgA2AgAMCAsgBUGAAWoiEyAPKAIANgIAIAUgBSkDYDcDeCAFQQhqEIYwIAVBEGogEygCADYCACAFIAUpA3g3AwgLIAVByABqEIYwIAVB+ABqIAQQ0wkgDyALQQhqKQIANwMAIBQgC0EQaigCADYCACAFIAspAgA3A2AgBSgCeEUNAAsLIAkgBSkDYDcCCCAJQgI3AwAgCUEYaiAUKAIANgIAIAlBEGogBUHoAGopAwA3AgAMAwsgBSgCfCELIAUpA4ABIU4gCSAFKQOIATcCFCAJIE43AgwgCSALNgIIIAlCAjcDAAwBCyAFKAJ8IQsgBSkDgAEhTiAJIAUpA4gBNwIUIAkgTjcCDCAJIAs2AgggCUICNwMACyAFQcgAahCGMAsgBUE4ahCGMCAFQShqEIYwIAVBGGoQhjAgBUEIahCGMAsgBUGQAWokACACQdgDaiIFIBlBCGopAwA3AwAgAkHgA2oiCSAZQRBqKAIANgIAIAIgGSkDADcD0AMgAikD6AMiTkICUgRAIAJB2ARqIgsgOUE8/AoAACACQfgDaiIMIAkoAgA2AgAgAkHwA2oiCSAFKQMANwMAIAIgAikD0AM3A+gDIAJBgAFqEPErIEEgAikD6AM3AwAgQUEIaiAJKQMANwMAIEFBEGogDCgCADYCACACIE43A4ABIEwgC0E8/AoAAAwLCyAGIAIpA9ADNwMIIAZCAjcDACAGQRhqIAJB4ANqKAIANgIAIAZBEGogAkHYA2opAwA3AwAMDQsgAkHoA2ogBBDAHCACKALoA0UEQCACKQPwAyFrQgEhbAwKCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwMCyACQegDaiAEEMAcIAIoAugDRQRAIAIpA/ADIW1CASFuDAkLIAIoAuwDIQUgAikD8AMhTiAGIAIpA/gDNwIUIAYgTjcCDCAGIAU2AgggBkICNwMADAsLIAJB6ANqIAQQwBwgAigC6ANFBEAgAiACKQPwAyJlNwN4IAJCATcDcEEBISkMCAsgAigC7AMhBSACKQPwAyFOIAYgAikD+AM3AhQgBiBONwIMIAYgBTYCCCAGQgI3AwAMCgsgAkHoA2ogBBDJDyACKALsAyEPIAIoAugDIgVBBEcEQCAGIAIpAPEDNwARIAZBGGogAkH4A2ooAAA2AAAgBiACLQDwAzoAECAGIA82AgwgBiAFNgIIIAZCAjcDAAwKCyACQegDaiAPQQBBBEEYEKAYIAIoAuwDIQUgAigC6ANBAUcEQCACQQA2AtgDIAIgAigC8AM2AtQDIAIgBTYC0AMgD0EASgRAA0AgAkHoA2ogBBCyBiAdIBpBCGopAgA3AwAgJCAaQRBqKAIANgIAIAIgGikCADcD2AQgAigC6AMiC0GAgICAeEYEQCAGIAIpA9gENwIIIAZCAjcDACAGQRhqIAJB6ARqKAIANgIAIAZBEGogAkHgBGopAwA3AgAgAkHQA2oiBhDgKSAGQQRBGBDgHgwNCyACQbgDaiIMICQoAgA2AgAgAkGwA2oiEiAdKQMANwMAIAIgAikD2AQ3A6gDIAIoAtgDIgkgAigC0ANGBEAgAkHQA2pB2I7QABCRKAsgAigC1AMgCUEYbGoiBSACKQOoAzcCBCAFIAs2AgAgBUEMaiASKQMANwIAIAVBFGogDCgCADYCACACIAlBAWo2AtgDIA9BAWsiDw0ACwsgAkHwA2oiBSACQdgDaigCADYCACACIAIpAtADNwPoAyACQeAAahCuLyACQegAaiAFKAIANgIAIAIgAikD6AM3A2AMBwsgBSACKALwA0HIjtAAEP0vAAsgAkHoA2ogBBDAHCACKALoA0UEQCACIAIpA/ADImY3A1hCASFkIAJCATcDUAwGCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwICyACQegDaiAEEMAcIAIoAugDRQRAIAIgAikD8AMiZzcDSEIBIWMgAkIBNwNADAULIAIoAuwDIQUgAikD8AMhTiAGIAIpA/gDNwIUIAYgTjcCDCAGIAU2AgggBkICNwMADAcLIAJB6ANqIAQQwBwgAigC6ANFBEAgAiACKQPwAyJoNwM4QgEhYiACQgE3AzAMBAsgAigC7AMhBSACKQPwAyFOIAYgAikD+AM3AhQgBiBONwIMIAYgBTYCCCAGQgI3AwAMBgsgAkHoA2ogBBDJDyACKALsAyELIAIoAugDIgVBBEcEQCAGIAIpAPEDNwARIAZBGGogAkH4A2ooAAA2AAAgBiACLQDwAzoAECAGIAs2AgwgBiAFNgIIIAZCAjcDAAwGCyACQegDaiALQQBBBEEMEKAYIAIoAuwDIQUgAigC6ANBAUcEQCACQQA2AtgDIAIgAigC8AM2AtQDIAIgBTYC0AMgC0EASgRAA0AgAkHoA2ogBBDCFSAdIBpBCGooAgA2AgAgAiAaKQIANwPYBCACKALoAyIFQQRHBEAgAigC+AMhCSAGIAIpA9gENwIMIAYgCTYCGCAGIAU2AgggBkICNwMAIAZBFGogAkHgBGooAgA2AgAgAkHQA2oiBhDRKyAGEOg7DAkLIAJBoANqIgkgHSgCADYCACACIAIpA9gENwOYAyACKALYAyIFIAIoAtADRgRAIAJB0ANqQbiO0AAQkCgLIAIoAtQDIAVBDGxqIgwgAikDmAM3AgAgDEEIaiAJKAIANgIAIAIgBUEBajYC2AMgC0EBayILDQALCyACQfADaiIFIAJB2ANqKAIANgIAIAIgAikC0AM3A+gDIAJBGGoQmDAgAkEgaiAFKAIANgIAIAIgAikD6AM3AxgMAwsgBSACKALwA0GojtAAEP0vAAsgAiAzNgIsQQEhKCACQQE2AigMAQsgAiAgNgIEQQEhJyACQQE2AgALIAJBgANqEIYwIAJB6ANqIAQQ0wkgHSAaQQhqKQIANwMAICQgGkEQaigCADYCACACIBopAgA3A9gEIAIoAugDRQ0ACwsgBiACKQPYBDcCCCAGQgI3AwAgBkEYaiAkKAIANgIAIAZBEGogAkHgBGopAwA3AgAMAQsgAkGAA2oQhjALIAIpA5ACQgNSBEAgRRCXMAsgAkHoAWoQ0y4gAigC2AFBgICAgHhHBEAgAkHYAWpBBEEMEOAeCyACQYABahDxKyACQeAAahCuLyACQRhqEJgwIAIoAghBgICAgHhGDQAgAkEIakEEQQQQ4B4LIAJBsAVqJAAgCkHoA2oiAiA/QQhqKQMANwMAIApB8ANqIgYgP0EQaigCADYCACAKID8pAwA3A+ADIAopA/gDIk5CAlENECAKQfgGaiIFIEtB5AL8CgAAIApBiARqIgkgBigCADYCACAKQYAEaiIGIAIpAwA3AwAgCiAKKQPgAzcD+AMgCkEgahCsICAyIAopA/gDNwMAIDJBCGogBikDADcDACAyQRBqIAkoAgA2AgAgCiBONwMgIEogBUHkAvwKAAAMCgsgCkH4A2ogBBDAHCAKKAL4Aw0OIAopA4AEIVpCASFbDAkLIA0gCikDiAQ3AhQgDSAtNgIMIA0gAjYCCCANQgI3AwAgDSBOQiCIPgIQDBALIApB+ANqIAQQwBwgCigC+AMNCyAKKQOABCFcQgEhUQwHCyANIAopA4gENwIUIA0gLjYCDCANIAI2AgggDUICNwMAIA0gTkIgiD4CEAwOCyAKQfgDaiEJIwBBgAFrIgYkACAGQYGAgIB4NgIIIAZB6ABqIAQQ8CcgBkFAayICIAZB9ABqIgUoAgA2AgAgBiAGKQJsNwM4AkACQCAGKAJoIgtBBEcEQCAGKAJ4IQUgCSAGKQM4NwIIIAkgBTYCFCAJIAs2AgQgCUGBgICAeDYCACAJQRBqIAIoAgA2AgAMAQsgBkHYAGogAigCADYCACAGIAYpAzg3A1AgBkHQAGoQhjAgBkHoAGogBBDTCSACIAUpAgA3AwAgBkHIAGoiICAGQfwAaigCADYCACAGIAYpAmw3AzgCQCAGKAJoRQRAIAZBxABqIRMgBkE8aiEaIAZB7ABqIQxBACESA0AgBkEwaiAgKAIAIgI2AgAgBkEoaiAGQUBrIhQpAwA3AwAgBiAGKQM4NwMgAkACQCACQf8BcQRAIAZB6ABqIAZBIGoQ/BcgBi8BbCECIAYoAmgiBUEERwRAIAkgBikBbjcBCiAJQRBqIAZB9ABqKQEANwEAIAkgAjsBCCAJIAU2AgQgCUGBgICAeDYCAAwGCwJAAkACQCACQQFrDgIAAQILIAZB6ABqIAQQ+gogBigCaCICQQRHBEAgCSAGKQJsNwIIIAlBEGogBkH0AGopAgA3AgAgCUGBgICAeDYCACAJIAI2AgQMCAsgBigCCEGBgICAeEcNBCAGQQhqENQuIAZBgICAgHg2AggMBAsgBkHoAGohBSMAQZABayICJAAgAkHYAGogBBDwJyACQcgAaiILIAJB5ABqIg8oAgA2AgAgAiACKQJcNwNAAkAgAigCWCIWQQRHBEAgAigCaCEPIAUgAikDQDcCCCAFIA82AhQgBSAWNgIEIAVBgICAgHg2AgAgBUEQaiALKAIANgIADAELIAJBMGogCygCADYCACACIAIpA0A3AyggAkEoahCGMCACQYCAgIB4NgIIIAJBgICAgHg2AhggAkHYAGogBBDTCSALIA8pAgA3AwAgAkHQAGoiHSACQewAaigCADYCACACIAIpAlw3A0ACQAJAIAIoAlhFBEAgAkHcAGohCwNAIAJBOGogHSgCACIWNgIAIAJBMGogAkHIAGoiDykDADcDACACIAIpA0A3AygCQAJAAkAgFkH/AXEEQCACQdgAaiACQShqEPwXIAIvAVwhFiACKAJYIhlBBEcEQCAFIAIpAV43AQogBUEQaiACQeQAaikBADcBACAFIBY7AQggBSAZNgIEIAVBgICAgHg2AgAMBwsCQAJAAkAgFkEBaw4CAAECCyACQdgAaiAEEMkPIAIoAlwhFiACKAJYIhlBBEcEQCAFIAIpAGE3AA0gBUEUaiACQegAaigAADYAACAFIAItAGA6AAwgBSAWNgIIIAUgGTYCBCAFQYCAgIB4NgIADAkLIAJB2ABqIBZBAEEEQQwQoBggAigCXCEZIAIoAlhBAUYNAyACQQA2AnwgAiACKAJgNgJ4IAIgGTYCdCAWQQBKBEADQCACQdgAaiAEEMIVIA8gC0EIaigCADYCACACIAspAgA3A0AgAigCWCIZQQRHBEAgAigCaCELIAUgAikDQDcCCCAFIAs2AhQgBSAZNgIEIAVBgICAgHg2AgAgBUEQaiACQcgAaigCADYCACACQfQAaiIFENErIAUQ6DsMCwsgAkGIAWoiJiAPKAIANgIAIAIgAikDQDcDgAEgAigCfCIZIAIoAnRGBEAgAkH0AGpB+JHQABCQKAsgAigCeCAZQQxsaiIkIAIpA4ABNwIAICRBCGogJigCADYCACACIBlBAWo2AnwgFkEBayIWDQALCyACQeAAaiIWIAJB/ABqKAIANgIAIAIgAikCdDcDWCACQQhqEJgwIAJBEGogFigCADYCACACIAIpA1g3AwgMBQsgAkHYAGogBBClESAPIAtBCGooAgA2AgAgAiALKQIANwNAIAIoAlgiFkEERwRAIAIoAmghCyAFIAIpA0A3AgggBSALNgIUIAUgFjYCBCAFQYCAgIB4NgIAIAVBEGogAkHIAGooAgA2AgAMCAsgAkHgAGoiFiAPKAIANgIAIAIgAikDQDcDWCACQRhqEIYwIAJBIGogFigCADYCACACIAIpA1g3AxgMBAsgAkHYAGogBCACLQA4QcAAEMkCIAIoAlgiFkEERg0DIAUgAikCXDcCCCAFQRBqIAJB5ABqKQIANwIAIAVBgICAgHg2AgAgBSAWNgIEDAYLIAJBKGoQhjAgAkHYAGogBBCoKSACKAJYIgtBBEcEQCAFIAIpAlw3AgggBUEQaiACQeQAaikCADcCACAFQYCAgIB4NgIAIAUgCzYCBAwHCyACQdgAakGIktAAQSYgAkEIahD1HSACKAJYIgtBBEcEQCAFIAIpAlw3AgggBUEQaiACQeQAaikCADcCACAFQYCAgIB4NgIAIAUgCzYCBAwHCyACKAIIIgtBgICAgHhGDQEgBSACKQMYNwIMIAUgAikCDDcCBCAFIAs2AgAgBUEUaiACQSBqKAIANgIADAcLIBkgAigCYEHokdAAEP0vAAtB+PzPAEHHAEGwktAAEMskAAsgAkEoahCGMCACQdgAaiAEENMJIA8gC0EIaikCADcDACAdIAtBEGooAgA2AgAgAiALKQIANwNAIAIoAlhFDQALCyAFIAIpA0A3AgQgBUGAgICAeDYCACAFQRRqIB0oAgA2AgAgBUEMaiACQcgAaikDADcCAAwBCyACQShqEIYwCyACQRhqEIYwIAJBCGoQmDALIAJBkAFqJAAgBkHYAGoiAiAMQQhqKQIANwMAIAZB4ABqIgUgDEEQaigCADYCACAGIAwpAgA3A1AgBigCaCILQYCAgIB4Rg0CIBogBikDUDcCACAaQRBqIAUoAgA2AgAgGkEIaiACKQMANwIAIAYgCzYCOCAGKAIIQYGAgIB4RwRAIAZBOGoiAhDRKyACEOg7IBMQhjAMBAsgBkH4AGoiAiAgKQIANwMAIAZB8ABqIgUgFCkCADcDACAGIAYpAjg3A2ggBkEIahDULiAGQRhqIAIpAwA3AwAgBkEQaiAFKQMANwMAIAYgBikDaDcDCAwDCyAGQegAaiAEIAYtADBBwAAQyQIgBigCaCICQQRGDQIgCSAGKQJsNwIIIAlBEGogBkH0AGopAgA3AgAgCUGBgICAeDYCACAJIAI2AgQMBQsgBkEgahCGMCAGQegAaiAEEKgpIAYoAmgiAkEERwRAIAkgBikCbDcCCCAJQRBqIAZB9ABqKQIANwIAIAlBgYCAgHg2AgAgCSACNgIEDAYLAkAgEkUEQCAJQQhqQcCS0ABBNRCiHwwBCyASQQFMBEAgBkH4AGogBkEYaikDADcDACAGQfAAaiAGQRBqKQMANwMAIAYgBikDCDcDaCMAQSBrIgIkAAJAIAZB6ABqIgUoAgBBgYCAgHhHBEAgCSAFKQIANwIAIAlBEGogBUEQaikCADcCACAJQQhqIAVBCGopAgA3AgAMAQsgAkEQakGkgNAAQSkQoh8gCUGBgICAeDYCACAJQQxqIAJBFGopAgA3AgAgCUEUaiACQRxqKAIANgIAIAJBATYCDCAJIAIpAgw3AgQLIAJBIGokAAwICyAJQQhqQfWS0ABBwwAQoh8LIAlCgYCAgBg3AgAgBkEIahDULgwGCyAJIAYpA1A3AgQgCUGBgICAeDYCACAJQRRqIAZB4ABqKAIANgIAIAlBDGogBkHYAGopAwA3AgAMAwsgBkEgahCGMCAGQegAaiAEENMJIBQgDEEIaikCADcDACAgIAxBEGooAgA2AgAgBiAMKQIANwM4IBJBAWohEiAGKAJoRQ0ACwsgCSAGKQM4NwIEIAlBgYCAgHg2AgAgCUEUaiAgKAIANgIAIAlBDGogBkFAaykDADcCAAwBCyAGQSBqEIYwCyAGQQhqENQuCyAGQYABaiQAICMgGEEIaikCADcDACAbIBhBEGooAgA2AgAgCiAYKQIANwP4BiAKKAL4AyICQYGAgIB4Rg0IIApBiARqIgYgGygCADYCACAKQYAEaiIFICMpAwA3AwAgCiAKKQP4BjcD+AMgCkGgA2oQ1C4gQCAKKQP4AzcCACBAQQhqIAUpAwA3AgAgQEEQaiAGKAIANgIAIAogAjYCoAMMBQsgCkH4A2ogBBClESAjIBhBCGooAgA2AgAgCiAYKQIANwP4BiAKKAL4AyICQQRHBEAgCigCiAQhBiANIAopA/gGNwIMIA0gBjYCGCANIAI2AgggDUICNwMAIA1BFGogCkGAB2ooAgA2AgAMDQsgCkGABGoiAiAjKAIANgIAIAogCikD+AY3A/gDIApBuANqEIYwIApBwANqIAIoAgA2AgAgCiAKKQP4AzcDuAMMBAsgCkH4A2ogBCAKLQDYA0HAABDJAiAKKAL4AyICQQRGDQMgDSAKKQL8AzcCDCANQRRqIApBhARqKQIANwIAIA1CAjcDACANIAI2AggMCwsgCiBZNwMYIAogUjcDECAKQcgDahCGMCAKQfgDaiAEEKgpIAooAvgDIgJBBEcEQCANIAopAvwDNwIMIA1BFGogCkGEBGopAgA3AgAgDUICNwMAIA0gAjYCCAwMCyAKQfgDakG4k9AAQRcgCkEQahDmHiAKKAL4AyICQQRHBEAgDSAKKQL8AzcCDCANQRRqIApBhARqKQIANwIAIA1CAjcDACANIAI2AggMDAsgN0UNASANQSBqIApBIGpBgAP8CgAAIA0gWTcDyAMgDSAuNgKsAyANIDY2AqgDIA0gLTYCpAMgDSBENgKgAyANIFw3AxggDSBRNwMQIA0gWjcDCCANIFs3AwAgDUHAA2ogCkGwA2opAgA3AgAgDUG4A2ogCkGoA2opAgA3AgAgDSAKKQKgAzcCsAMgDSAKKQO4AzcC3AMgDUHkA2ogCkHAA2ooAgA2AgAgDSAKKQMANwLQAyANQdgDaiAKQQhqKAIANgIADAwLIApBgARqIgIgIygCADYCACAKIAopA/gGNwP4AyAKEIYwIApBCGogAigCADYCACAKIAopA/gDNwMADAELQfj8zwBBxwBB0JPQABDLJAALIApByANqEIYwIApB+ANqIAQQ0wkgIyAYQQhqKQIANwMAIBsgGEEQaigCADYCACAKIBgpAgA3A/gGIAooAvgDRQ0ACwsgDSAKKQP4BjcCCCANQgI3AwAgDUEYaiAbKAIANgIAIA1BEGogCkGAB2opAwA3AgAMBgsgDSAKKQP4BjcCCCANQgI3AwAgDUEYaiAKQYgHaigCADYCACANQRBqIApBgAdqKQMANwIADAQLIAooAvwDIQIgCikDgAQhTiANIAopA4gENwIUIA0gTjcCDCANIAI2AgggDUICNwMADAMLIAooAvwDIQIgCikDgAQhTiANIAopA4gENwIUIA0gTjcCDCANIAI2AgggDUICNwMADAILIA0gCikD4AM3AwggDUICNwMAIA1BGGogCkHwA2ooAgA2AgAgDUEQaiAKQegDaikDADcDAAwBCyAKKAL8AyECIAopA4AEIU4gDSAKKQOIBDcCFCANIE43AgwgDSACNgIIIA1CAjcDAAsgCkHIA2oQhjALIApBuANqEIYwIApBoANqENQuIApBIGoQrCAgChCGMAsgCkHgCWokACA0ID1BCGopAwA3AwAgFyA9QRBqKAIANgIAIAcgPSkDADcDaCAHKQOAASJOQgJRBEAgCCAHKQNoNwMIIAhCAjcDACAIQRhqIAdB+ABqKAIANgIAIAhBEGogB0HwAGopAwA3AwAgBygCZCIRBEAgBygCYCEMA0AgDBDYEyAMQegDaiEMIBFBAWsiEQ0ACwsgB0HcAGpBCEHoAxDgHgwXCyAHQewEaiBJQcwD/AoAACAHQcAIaiIKIDQpAwA3AwAgB0HICGoiBSAXKAIANgIAIAcgBykDaDcDuAggBygCZCIGIAcoAlxGBEAjAEEQayICJAAgAkEIaiAHQdwAaiINIA0oAgBBAUEIQegDELcRIAIoAggiDUGBgICAeEcEQCANIAIoAgxB8JPQABD9LwALIAJBEGokAAsgBygCYCAGQegDbGoiAiBONwMAIAIgBykDuAg3AwggAkEQaiAKKQMANwMAIAJBGGogBSgCADYCACACQRxqIAdB7ARqQcwD/AoAACAHIAZBAWo2AmQgEUEBayIRDQALCyAHQYgBaiICIAdB5ABqKAIANgIAIAcgBykCXDcDgAEgB0EIahDKKCAHQRBqIAIoAgA2AgAgByAHKQOAATcDCAwRCyAHQYABaiAEEMAcIAcoAoABDQ8gBykDiAEhV0IBIVYMEAsgB0GAAWogBBDAHCAHKAKAAQ0NIAcpA4gBIVhBASEvQgEhXwwPCyAHQYABaiAEEMkPIAcoAoQBIREgBygCgAEiAkEERwRAIAggBykAiQE3ABEgCEEYaiAHQZABaigAADYAACAIIActAIgBOgAQIAggETYCDCAIIAI2AgggCEICNwMADBILIAdBgAFqIBFBAEEEQQgQoBggBygChAEhAiAHKAKAAUEBRg0FIAdBADYCcCAHIAcoAogBNgJsIAcgAjYCaCARQQBMDQsDQCAHQYABaiEGQQAhGCMAQeAAayICJAAgAkHIAGogBBDwJyACQThqIgogAkHUAGoiBSgCADYCACACIAIpAkw3AzACQCACKAJIIg1BBEcEQCACKAJYIQUgBiACKQMwNwIEIAYgBTYCECAGIA02AgAgBkEMaiAKKAIANgIADAELIAJBIGogCigCADYCACACIAIpAzA3AxggAkEYahCGMCACQcgAaiAEENMJIAogBSkCADcDACACQUBrIgogAkHcAGooAgA2AgAgAiACKQJMNwMwIAIoAkhFBEAgAkHMAGohBUEAIQlBAiEPQQIhDQNAIAJBKGogCigCACILNgIAIAJBIGogAkE4aiIMKQMANwMAIAIgAikDMDcDGAJAAkAgC0H/AXEEQCACQcgAaiACQRhqEPwXIAIvAUwhCyACKAJIIhJBBEcEQCAGIAIpAU43AQYgBkEMaiACQdQAaikBADcBACAGIAs7AQQgBiASNgIADAILAkACQAJAAkAgC0EBaw4DAAECAwsgAkHIAGogBBDAHCACKAJIRQRAIAIoAlAhGEEBIQkMBgsgAikDUCJOpyEYQQEhCSACKAJMIgtBBEYNBSAGIAIpA1g3AgwgBiAYNgIEIAYgCzYCACAGIE5CIIg+AggMBAsgAkHIAGogBBDaECACLQBMIQ0gAigCSCILQQRGDQQgBiACKQBNNwAFIAZBDGogAkHUAGopAAA3AAAgBiANOgAEIAYgCzYCAAwDCyACQcgAaiAEENoQIAItAEwhDyACKAJIIgtBBEYNAyAGIAIpAE03AAUgBkEMaiACQdQAaikAADcAACAGIA86AAQgBiALNgIADAILIAJByABqIAQgAi0AKEHAABDJAiACKAJIIgtBBEYNAiAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAs2AgAMAQsgAiANOgAWIAIgDzoAFyACIBg2AhAgAiAJNgIMIAJBGGoQhjAgAkHIAGogBBCoKSACKAJIIgpBBEcEQCAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAo2AgAMBQsgAkHIAGpBkIzQAEEYIAJBDGoQ5h4gAigCSCIKQQRHBEAgBiACKQJMNwIEIAZBDGogAkHUAGopAgA3AgAgBiAKNgIADAULIAJByABqQaiM0ABBGCACQRZqEPQdIAIoAkgiCkEERwRAIAYgAikCTDcCBCAGQQxqIAJB1ABqKQIANwIAIAYgCjYCAAwFCyACQcgAakHAjNAAQRkgAkEXahD0HSACKAJIIgpBBEcEQCAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAo2AgAMBQsCQAJAIAkEQCANQQJGDQEgD0ECRg0CIAYgDToACCAGIBg2AgQgBkEENgIAIAYgD0EBcToACQwHC0H4/M8AQccAQdyM0AAQyyQAC0H4/M8AQccAQeyM0AAQyyQAC0H4/M8AQccAQfyM0AAQyyQACyACQRhqEIYwDAMLIAJBGGoQhjAgAkHIAGogBBDTCSAMIAVBCGopAgA3AwAgCiAFQRBqKAIANgIAIAIgBSkCADcDMCACKAJIRQ0ACwsgBiACKQMwNwIAIAZBEGogCigCADYCACAGQQhqIAJBOGopAwA3AgALIAJB4ABqJAAgBykChAEhTiAHKAKAASICQQRHBEAgCCAHKQKMATcCFCAIIE43AgwgCCACNgIIIAhCAjcDACAHQegAakEEQQgQ4B4MEwsgBygCcCICIAcoAmhGBEAgB0HoAGpBkJTQABCbKAsgBygCbCACQQN0aiBONwIAIAcgAkEBajYCcCARQQFrIhENAAsMCwsgB0GAAWogBBDAHCAHKAKAAQ0JIAcpA4gBIWBCASFdDA0LIAdBgAFqIAQQwBwgBygCgAENByAHKQOIASFhQgEhXgwMCyAHQYABaiAEIActAFhBwAAQyQIgBygCgAEiAkEERg0LIAggBykChAE3AgwgCEEUaiAHQYwBaikCADcCACAIQgI3AwAgCCACNgIIDA4LIAcgWDcDMCAHIF83AyggByBXNwMgIAcgVjcDGCAHQcgAahCGMCAHQYABaiAEEKgpIAcoAoABIgJBBEcEQCAIIAcpAoQBNwIMIAhBFGogB0GMAWopAgA3AgAgCEICNwMAIAggAjYCCAwPCyAHQYABakGglNAAQRAgB0EIahD1HSAHKAKAASICQQRHBEAgCCAHKQKEATcCDCAIQRRqIAdBjAFqKQIANwIAIAhCAjcDACAIIAI2AggMDwsgB0GAAWpBsJTQAEEYIAdBGGoQ5h4gBygCgAEiAkEERwRAIAggBykChAE3AgwgCEEUaiAHQYwBaikCADcCACAIQgI3AwAgCCACNgIIDA8LIAdBgAFqQciU0ABBESAHQShqEOYeIAcoAoABIgJBBEcEQCAIIAcpAoQBNwIMIAhBFGogB0GMAWopAgA3AgAgCEICNwMAIAggAjYCCAwPCyAHKAIIIgJBgICAgHhGDQIgVlANAyAvRQ0EIAcpAgwhTiAIIAcpAzg3AjwgCCAsOwFKIAggJTsBSCAIIE43AjQgCCACNgIwIAggWDcDKCAIIFc3AyAgCCBhNwMYIAggXjcDECAIIGA3AwggCCBdNwMAIAhBxABqIAdBQGsoAgA2AgAMDwsgAiAHKAKIAUHgk9AAEP0vAAsgAiAHKAKIAUGAlNAAEP0vAAtB+PzPAEHHAEHclNAAEMskAAtB+PzPAEHHAEHslNAAEMskAAtB+PzPAEHHAEH8lNAAEMskAAsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBwsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBgsgB0GIAWoiAiA0KAIANgIAIAcgBykCaDcDgAEgBygCOEGAgICAeEcEQCAHQThqQQRBCBDgHgsgB0FAayACKAIANgIAIAcgBykDgAE3AzgMAgsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBAsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMAwsgB0HIAGoQhjAgB0GAAWogBBDTCSA0ID5BCGopAgA3AwAgFyA+QRBqKAIANgIAIAcgPikCADcDaCAHKAKAAUUNAAsLIAggBykDaDcCCCAIQgI3AwAgCEEYaiAXKAIANgIAIAhBEGogB0HwAGopAwA3AgAMAQsgB0HIAGoQhjALIAcoAjhBgICAgHhHBEAgB0E4akEEQQgQ4B4LIAdBCGoQyigLIAdB0AhqJAAgHyA7QQhqKQMANwMAICIgO0EQaigCADYCACADIDspAwA3A9gDIAMpA7ABIk5CAlEEQCAOIAMpA9gDNwIEIA5BAzYCACAOQRRqIANB6ANqKAIANgIAIA5BDGogA0HgA2opAwA3AgAgA0G0A2oiAhD0GyACQQhB0AAQ4B4MGAsgA0HsAmogSEE0/AoAACADQagDaiIGIB8pAwA3AwAgA0GwA2oiCiAiKAIANgIAIAMgAykD2AM3A6ADIAMoArwDIgcgAygCtANGBEAjAEEQayICJAAgAkEIaiADQbQDaiIFIAUoAgBBAUEIQdAAELcRIAIoAggiBUGBgICAeEcEQCAFIAIoAgxB5JvQABD9LwALIAJBEGokAAsgAygCuAMgB0HQAGxqIgIgTjcDACACIAMpA6ADNwMIIAJBEGogBikDADcDACACQRhqIAooAgA2AgAgAkEcaiADQewCakE0/AoAACADIAdBAWo2ArwDIBVBAWsiFQ0ACwsgA0G4AWoiAiADQbwDaigCADYCACADIAMpArQDNwOwASADQShqELovIANBMGogAigCADYCACADIAMpA7ABNwMoDBELIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMFQsgA0GwAWogFUEAQQRBGBCgGCADKAK0ASECIAMoArABQQFGDQggA0EANgK8AyADIAMoArgBNgK4AyADIAI2ArQDIBVBAEoEQANAIANBsAFqIAQQsgYgHyAeQQhqKQIANwMAICIgHkEQaigCADYCACADIB4pAgA3A9gDIAMoArABIgZBgICAgHhGBEAgDiADKQPYAzcCBCAOQQM2AgAgDkEUaiADQegDaigCADYCACAOQQxqIANB4ANqKQMANwIAIANBtANqIgIQ4CkgAkEEQRgQ4B4MFwsgA0HQA2oiCiAiKAIANgIAIANByANqIgUgHykDADcDACADIAMpA9gDNwPAAyADKAK8AyIHIAMoArQDRgRAIANBtANqQYSc0AAQkSgLIAMoArgDIAdBGGxqIgIgAykDwAM3AgQgAiAGNgIAIAJBDGogBSkDADcCACACQRRqIAooAgA2AgAgAyAHQQFqNgK8AyAVQQFrIhUNAAsLIANBuAFqIgIgA0G8A2ooAgA2AgAgAyADKQK0AzcDsAEgA0E4ahCuLyADQUBrIAIoAgA2AgAgAyADKQOwATcDOAwQCyADQbABaiAEEMIVIB8gHkEIaigCADYCACADIB4pAgA3A9gDIAMoArABIgJBBEcEQCADKALAASEEIA4gAykD2AM3AgggDiAENgIUIA4gAjYCBCAOQQM2AgAgDkEQaiADQeADaigCADYCAAwUCyADQbgBaiICIB8oAgA2AgAgAyADKQPYAzcDsAEgA0HIAGoQhjAgA0HQAGogAigCADYCACADIAMpA7ABNwNIDA8LIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMEwsgA0GwAWogFUEAQQFBABCgGCADKAK0ASECIAMoArABQQFGDQcgA0EANgLgAyADIAMoArgBNgLcAyADIAI2AtgDIBVBAEwNDQNAIANBsAFqIQdBACEJIwBB0ABrIgIkACACQThqIAQQ8CcgAkEoaiIGIAJBxABqIgooAgA2AgAgAiACKQI8NwMgAkAgAigCOCIFQQRHBEAgAigCSCEKIAcgAikDIDcCBCAHIAo2AhAgByAFNgIAIAdBDGogBigCADYCAAwBCyACQRBqIAYoAgA2AgAgAiACKQMgNwMIIAJBCGoQhjAgAkE4aiAEENMJIAYgCikCADcDACACQTBqIgYgAkHMAGooAgA2AgAgAiACKQI8NwMgAkAgAigCOEUEQCACQTxqIQpBACERA0AgAkEYaiAGKAIAIgU2AgAgAkEQaiACQShqIggpAwA3AwAgAiACKQMgNwMIAkACQCAFQf8BcQRAIAJBOGogAkEIahD8FyACLwE8IQUgAigCOCIMQQRHBEAgByACKQE+NwEGIAdBDGogAkHEAGopAQA3AQAgByAFOwEEDAYLIAVBAUYEQCACQThqIAQQ+gogAigCOCIMQQRGDQIgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAMBgsgAkE4aiAEIAItABhBwAAQyQIgAigCOCIMQQRGDQIgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAMBQsgAkEIahCGMCACQThqIAQQqCkgAigCOCIGQQRHBEAgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAgByAGNgIADAYLIBFFBEAgB0EEakGMldAAQSwQoh8gB0EBNgIADAYLIBFBAUwEQCAJBEAgB0EENgIADAcLIAJBPGpBpIDQAEEpEKIfIAdBCGogAkFAaykCADcCACAHQRBqIAJByABqKAIANgIAIAJBATYCOCAHIAIpAjg3AgAMBgsgB0EEakG4ldAAQToQoh8gB0EBNgIADAULQQEhCQsgAkEIahCGMCACQThqIAQQ0wkgCCAKQQhqKQIANwMAIAYgCkEQaigCADYCACACIAopAgA3AyAgEUEBaiERIAIoAjhFDQALCyAHIAIpAyA3AgAgB0EQaiAGKAIANgIAIAdBCGogAkEoaikDADcCAAwBCyAHIAw2AgAgAkEIahCGMAsgAkHQAGokACADKAKwASICQQRHBEAgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQgA0HYA2pBAUEAEOAeDBQLIAMoAuADIgdBf0YEQCMAQRBrIgIkACACQQhqIANB2ANqIgYgBigCAEEBQQFBABC3ESACKAIIIgZBgYCAgHhHBEAgBiACKAIMQaSc0AAQ/S8ACyACQRBqJAALIAMgB0EBajYC4AMgFUEBayIVDQALDA0LIANBsAFqIQdBACEJIwBBkAFrIgIkACACQQI2AgAgAkHwAGogBBDwJyACQUBrIgYgAkH8AGoiCigCADYCACACIAIpAnQ3AzgCQAJAIAIoAnAiBUEERwRAIAIoAoABIQogByACKQM4NwIIIAcgCjYCFCAHIAU2AgQgB0ECNgIAIAdBEGogBigCADYCAAwBCyACQeAAaiAGKAIANgIAIAIgAikDODcDWCACQdgAahCGMCACQfAAaiAEENMJIAYgCikCADcDACACQcgAaiIIIAJBhAFqKAIANgIAIAIgAikCdDcDOCACKAJwRQRAIAJBxABqIREgAkE8aiEFIAJB9ABqIQYgAkEEaiEKA0AgAkEwaiAIKAIAIgs2AgAgAkEoaiACQUBrIg0pAwA3AwAgAiACKQM4NwMgAkACQAJAAkAgC0H/AXEEQCACQfAAaiACQSBqEPwXIAIvAXQhCyACKAJwIgxBBEcEQCAHIAIpAXY3AQogB0EQaiACQfwAaikBADcBACAHIAs7AQggByAMNgIEIAdBAjYCAAwDCwJAAkACQCALQQFrDgIAAQILIAJB8ABqIAQQpQYgAkHgAGoiCyAGQQhqKQIANwMAIAJB6ABqIgwgBkEQaigCADYCACACIAYpAgA3A1ggAigCcCIPQYGAgIB4RwRAIAIoAogBIRUgBSACKQNYNwIAIAVBEGogDCgCADYCACAFQQhqIAspAwA3AgAgAiAVNgJQIAIgDzYCOCACKAIAQQJHDQYgAkGIAWoiCyACQdAAaigCADYCACACQYABaiIMIAgpAgA3AwAgAkH4AGoiDyANKQIANwMAIAIgAikCODcDcCACELsuIAogAikDcDcCACAKQQhqIA8pAwA3AgAgCkEQaiAMKQMANwIAIApBGGogCygCADYCACACQQA2AgAMBwsgByACKQNYNwIEIAdBAjYCACAHQRRqIAJB6ABqKAIANgIAIAdBDGogAkHgAGopAwA3AgAMBAsgAkHwAGogBBClBiACQeAAaiILIAZBCGopAgA3AwAgAkHoAGoiDCAGQRBqKAIANgIAIAIgBikCADcDWCACKAJwIg9BgYCAgHhGDQIgAigCiAEhFSAFIAIpA1g3AgAgBUEQaiAMKAIANgIAIAVBCGogCykDADcCACACIBU2AlAgAiAPNgI4IAIoAgBBAkcNBCACQYgBaiILIAJB0ABqKAIANgIAIAJBgAFqIgwgCCkCADcDACACQfgAaiIPIA0pAgA3AwAgAiACKQI4NwNwIAIQuy4gCiACKQNwNwIAIApBCGogDykDADcCACAKQRBqIAwpAwA3AgAgCkEYaiALKAIANgIAIAJBATYCAAwFCyACQfAAaiAEIAItADBBwAAQyQIgAigCcCILQQRGDQQgByACKQJ0NwIIIAdBEGogAkH8AGopAgA3AgAgB0ECNgIAIAcgCzYCBAwCCyACQSBqEIYwIAJB8ABqIAQQqCkgAigCcCIGQQRHBEAgByACKQJ0NwIIIAdBEGogAkH8AGopAgA3AgAgB0ECNgIAIAcgBjYCBAwHCwJAIAlFBEAgB0EIakG8mtAAQTQQoh8MAQsgCUEBTARAIAJBiAFqIAJBGGopAgA3AwAgAkGAAWogAkEQaikCADcDACACQfgAaiACQQhqKQIANwMAIAIgAikCADcDcCMAQSBrIgYkAAJAIAJB8ABqIgooAgBBAkcEQCAHIAopAgA3AgAgB0EYaiAKQRhqKQIANwIAIAdBEGogCkEQaikCADcCACAHQQhqIApBCGopAgA3AgAMAQsgBkEQakGkgNAAQSkQoh8gB0ECNgIAIAdBDGogBkEUaikCADcCACAHQRRqIAZBHGooAgA2AgAgBkEBNgIMIAcgBikCDDcCBAsgBkEgaiQADAkLIAdBCGpB8JrQAEHCABCiHwsgB0KCgICAEDcCAAwGCyAHIAIpA1g3AgQgB0ECNgIAIAdBFGogAkHoAGooAgA2AgAgB0EMaiACQeAAaikDADcCAAsgAkEgahCGMAwECyACQThqEIYwIBEQhjALIAJBIGoQhjAgAkHwAGogBBDTCSANIAZBCGopAgA3AwAgCCAGQRBqKAIANgIAIAIgBikCADcDOCAJQQFqIQkgAigCcEUNAAsLIAcgAikDODcCBCAHQQI2AgAgB0EUaiAIKAIANgIAIAdBDGogAkFAaykDADcCAAsgAhC7LgsgAkGQAWokACAfIB5BCGopAgA3AwAgIiAeQRBqKAIANgIAIAMgHikCADcD2AMgAygCsAEiAkECRg0LIAMpAsgBIU4gA0HAAWoiByAiKAIANgIAIANBuAFqIgYgHykDADcDACADIAMpA9gDNwOwASADQegAahC7LiA8IAMpA7ABNwIAIDxBCGogBikDADcCACA8QRBqIAcoAgA2AgAgAyACNgJoIAMgTjcCgAEMDQsgA0GwAWogBBClESAfIB5BCGooAgA2AgAgAyAeKQIANwPYAyADKAKwASICQQRHBEAgAygCwAEhBCAOIAMpA9gDNwIIIA4gBDYCFCAOIAI2AgQgDkEDNgIAIA5BEGogA0HgA2ooAgA2AgAMEQsgA0G4AWoiAiAfKAIANgIAIAMgAykD2AM3A7ABIANBiAFqEIYwIANBkAFqIAIoAgA2AgAgAyADKQOwATcDiAEMDAsgA0GwAWogBCADLQCoAUHAABDJAiADKAKwASICQQRGDQsgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQMDwsgAyBUNwMgIAMgVTcDGCADIDU2AgQgAyA4NgIAIANBmAFqEIYwIANBsAFqIAQQqCkgAygCsAEiAkEERwRAIA4gAykCtAE3AgggDkEQaiADQbwBaikCADcCACAOQQM2AgAgDiACNgIEDBALIANBsAFqQbSc0ABBFCADEOYeIAMoArABIgJBBEcEQCAOIAMpArQBNwIIIA5BEGogA0G8AWopAgA3AgAgDkEDNgIAIA4gAjYCBAwQCyADQbABakHInNAAQRMgA0EIahD1HSADKAKwASICQQRHBEAgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQMEAsgA0GwAWpB25zQAEEVIANBGGoQ5h4gAygCsAEiAkEERwRAIA4gAykCtAE3AgggDkEQaiADQbwBaikCADcCACAOQQM2AgAgDiACNgIEDBALIANBsAFqQfCc0ABBFyADQShqEPUdIAMoArABIgJBBEcEQCAOIAMpArQBNwIIIA5BEGogA0G8AWopAgA3AgAgDkEDNgIAIA4gAjYCBAwQCyA4RQ0EIAMoAggiAkGAgICAeEYNBSBVUA0GIAMoAigiBEGAgICAeEYNByADKQIMIU4gDiADKQM4NwJAIA4gAykDSDcCTCAOIAMpA1g3AlggDiADKQJoNwIAIA5ByABqIANBQGsoAgA2AgAgDkHUAGogA0HQAGooAgA2AgAgDkHgAGogA0HgAGooAgA2AgAgDkEIaiADQfAAaikCADcCACAOQRBqIANB+ABqKQIANwIAIA5BGGogA0GAAWopAgA3AgAgAykCLCFPIA4gNTYCcCAOIE83AzggDiAENgI0IA4gTjcCLCAOIAI2AiggDiBUNwMgIA5B7ABqIANBkAFqKAIANgIAIA4gAykDiAE3AmQMEAsgAiADKAK4AUG0m9AAEP0vAAsgAiADKAK4AUHUm9AAEP0vAAsgAiADKAK4AUH0m9AAEP0vAAsgAiADKAK4AUGUnNAAEP0vAAtB+PzPAEHHAEGIndAAEMskAAtB+PzPAEHHAEGYndAAEMskAAtB+PzPAEHHAEGondAAEMskAAtB+PzPAEHHAEG4ndAAEMskAAsgDiADKQPYAzcCBCAOQQM2AgAgDkEUaiADQegDaigCADYCACAOQQxqIANB4ANqKQMANwIADAULIANBuAFqIgIgHygCADYCACADIAMpAtgDNwOwASADKAJYQYCAgIB4RwRAIANB2ABqQQFBABDgHgsgA0HgAGogAigCADYCACADIAMpA7ABNwNYCyADQZgBahCGMCADQbABaiAEENMJIB8gHkEIaikCADcDACAiIB5BEGooAgA2AgAgAyAeKQIANwPYAyADKAKwAUUNAAsLIA4gAykD2AM3AgQgDkEDNgIAIA5BFGogIigCADYCACAOQQxqIANB4ANqKQMANwIADAILIAMoArQBIQIgAykDuAEhTiAOIAMpA8ABNwMQIA4gTjcDCCAOIAI2AgQgDkEDNgIACyADQZgBahCGMAsgA0GIAWoQhjAgA0HoAGoQuy4gAygCWEGAgICAeEcEQCADQdgAakEBQQAQ4B4LIANByABqEIYwIANBOGoQri8gA0EoahC6LyADQQhqELcvCyADQfADaiQAIA5BBHIhAgJAIBAoAtgBIgNBA0YEQCAQQYAEaiACQRBqKAIANgIAIBBB+ANqIAJBCGopAgA3AwAgECACKQIANwPwAyAQQQE2AiQgEEGg988ANgIgIBBCATcCLCAQQYcBNgKMBCAQIBBBiARqNgIoIBAgEEHwA2oiAjYCiAQgEEHYA2pBBHIgEEEgahCZDiAQQQA2AtgDIAJBBHIhAgJAIBAoAvADQQNGBEAgAhC8KgwBCyACEN47CyAQQaQBaiAQQeADaikDACJONwIAIBBBrAFqIBBB6ANqKQMAIk83AgAgECAQKQPYAyJSNwKcASABQRBqIE83AgAgAUEIaiBONwIAIAEgUjcCACABQYCAgIB4NgJQDAELIBBB0AFqIgQgAkEYaigCADYCACAQQcgBaiIHIAJBEGopAgA3AwAgEEHAAWoiBiACQQhqKQIANwMAIBAgAikCADcDuAEgEEFAayAQQfgBakHYAPwKAAAgEEGwAWogBCgCACICNgIAIBBBqAFqIAcpAwAiTjcDACAQQSxqIAYpAwA3AgAgEEE0aiBONwIAIBBBPGogAjYCACAQIAM2AiAgECAQKQO4ATcCJCAQQdgBaiEDIBAoAkwhCiAQKAJQIQRBACESIwBBQGoiAiQAIAJBADYCFCACQoCAgIDAADcCDAJAAkAgBEUNAANAIAJBGGogCiAEIBIQwwEgAigCICEGIAIoAhwhEiACKAIYIgdBCEcEQCADIAIpAiQ3AgwgA0EUaiACQSxqKAIANgIAIAMgBjYCCCADIBI2AgQgAyAHNgIADAMLIAIoAhQiByACKAIMRgRAIAJBDGpBiL/PABCdKAsgAigCECAHQQJ0aiAGNgIAIAIgB0EBaiIcNgIUIAQgEksNAAsgBw0AIAIoAhAoAgAiBCgCCEECRgRAIAMgBDYCBCADQQg2AgAgAkEANgIUDAILIAJBGGpBJUEAQQFBARCgGCACKAIcIQQgAigCGEEBRwRAIAIoAiAiB0Gwvs8AQSX8CgAAIANBJTYCDCADIAc2AgggAyAENgIEIANBADYCAAwCCyAEIAIoAiBB5KPPABD9LwALIAJBATYCHCACQYC/zwA2AhggAkIBNwIkIAJBOzYCOCACIBw2AjwgAiACQTRqNgIgIAIgAkE8ajYCNCADQQRqIAJBGGoQmQ4gA0EANgIACyACQQxqIgMQoicgA0EEQQQQ4B4gAkFAayQAIBBByABqIR4gECgC3AEhAgJAIBAoAtgBIh1BCEcEQCABIBApA+ABNwMIIAFBEGogEEHoAWopAwA3AwAgAUGAgICAeDYCUCABIAI2AgQgASAdNgIAQQEhBwwBCyAQQdgBaiACEKUSAkACQAJAAkACQAJAQSRBBBCtNiIGBEAgBkKBgICAEDcCACAGIBApAtgBNwIIIAZBEGogEEHgAWoiIikCADcCACAGQRhqIBBB6AFqKQIANwIAIAZBIGogEEHwAWooAgA2AgAgECAGNgLwAyAQQQA2AuADIBBCgICAgIABNwLYAyAQKAJUIQIgECAQKAJYIgwgECgCXCINQdAAbGoiDzYCxAEgECACNgLAASAQIAw2ArwBIBAgDDYCuAEgDUUNAyAQQfgBaiENIBBB2AJqIS0DQAJAIAwpAwAiTkICUgRAIBAgTjcD0AIgLSAMQQhqQcgA/AoAACAGIAYoAgAiAkEBajYCACACQQBIDQQgEEHYAWohBSMAQcAKayIEJAAgBCAGNgIAIBBB0AJqIg5BMGohIAJAAkACQAJAAkAgBigCECICIA4oAjgiA0YEQCAOKQMoIU8gDikDICFQIARBADYCECAEQoCAgICAATcCCCAOQQA2AjggBEEANgIkIAQgAjYCICAEICA2AhwgBEIANwIwIAQgDigCNCIcNgIUIAQgBigCDCIWNgIoIAQgHCACQegDbGoiJzYCGCAEIBYgAkECdCIoaiIuNgIsIAJFDQQgBEH4BmohJiAEQeAGaiEfIARBQGshLwNAAkAgHCkDACJOQgJSBEAgHyAcQQhqIgJB4AP8CgAAIAQgTjcD2AYgKEUEQCAEIC42AiggBCAcQegDajYCFCAEQagKahCGMCAEQfgGahCsICAEQYgKahDULiAEQbQKahCGMAwICyAvIAJB4AP8CgAAIAQgTjcDOCAWKAIAIhEgESgCACICQQFqNgIAIAJBAEgNBSAEQdgGaiEDQgAhWkIAIVtCACFcIwBB0AVrIgIkACACIBE2AgwCQAJAAkACQAJAAkAgBEE4aiIKKQMgIk5CAlIEQCACQRhqIApBKGpB+AL8CgAAIAIgTjcDECACQfgEaiACKAKIAxDkHiACLQD8BCEZIAIoAvgEIgdBCEYNASADIAIpAP0ENwANIANBHGogAkGMBWooAAA2AAAgA0EVaiACQYUFaikAADcAACADIBk6AAwgAyAHNgIIIANCAjcDACACQdgCaiEUDAMLIAJBEGpBIEEAQQFBARCgGCACKAIUIQggAigCEEEBRg0BIAIoAhgiB0EYakGw+s8AKQAANwAAIAdBEGpBqPrPACkAADcAACAHQQhqQaD6zwApAAA3AAAgB0GY+s8AKQAANwAAIANBIDYCFCADIAc2AhAgAyAINgIMIANBADYCCCADQgI3AwAgCkHQA2oQhjAgCkEgahCsIAwECyACKALgAiEHIAJBADYC4AIgAkEANgKwBCACIAc2AqwEIAIgAkHYAmoiFDYCqAQgAiACKALcAiIIIAdBAnRqNgKkBCACIAg2AqAEIAJB+ARqIQkjAEFAaiIHJAAgB0EINgIAIAdBOGogAkGgBGoiCEEQaigCADYCACAHQTBqIAhBCGopAgA3AwAgByAIKQIANwMoIAcgBzYCPCAHQRxqIRUjAEEwayIIJAACQAJAAkAgB0EoaiISIAhBGGoiCyASKAIUEMgYQf8BcSIaQQlrQQJPBEAgC0EIQQBBAUEBEKAYIAgoAhwhGCAIKAIYQQFGDQIgCCgCICITIBo6AAAgCEEUaiIlQQE2AgAgCCATNgIQIAggGDYCDCAIQShqIBJBEGopAgA3AwAgCEEgaiASQQhqKQIANwMAIAggEikCADcDGCMAQRBrIhgkACALIBhBD2ogCygCFBDIGEH/AXEiE0EJa0ECTwRAIAhBDGohEgNAIBIoAggiGiASKAIARgRAIBIgGkEBQQFBARDQKAsgEigCBCAaaiATOgAAIBIgGkEBajYCCCALIBhBD2ogCygCFBDIGEH/AXEiE0EJa0ECTw0ACwsgCxD2FSAYQRBqJAAgFUEIaiAlKAIANgIAIBUgCCkCDDcCAAwBCyAVQQA2AgggFUKAgICAEDcCACASEPYVCyAIQTBqJAAMAQsgGCAIKAIgQciXzwAQ/S8ACwJAIAcoAgBBCEcEQCAJIAcpAwA3AwAgCUEQaiAHQRBqKQMANwMAIAlBCGogB0EIaikDADcDACAVQQFBARDgHgwBCyAJIAcpAhw3AgQgCUEINgIAIAlBDGogB0EkaigCADYCAAsgB0FAayQAIAJBuANqIgcgAkGEBWooAgA2AgAgAiACKQL8BDcDsAMgAigC+AQiCEEIRwRAIAIpA4gFIU4gAyACKQOwAzcCDCADIE43AxggAyAINgIIIANCAjcDACADQRRqIAcoAgA2AgAMAgsgAkGYA2ogBygCADYCACACIAIpA7ADNwOQAyACQfgEaiEJIAIoAowDIQsjAEEwayIIJAAgCCALNgIMQQghBwJAIAtBCE8EQCAIQQE2AhQgCEGQ+s4ANgIQIAhCATcCHCAIQZwDNgIsIAggCEEoajYCGCAIIAhBDGo2AiggCUEEaiAIQRBqEJkOQQAhBwwBCyAJIAs2AgQgCSALQQJ0QfyNzwBqKAIANgIICyAJIAc2AgAgCEEwaiQAIAIoAoAFIRogAigC/AQhEwJAIAIoAvgEIiVBCEcEQCADIAIpAoQFNwIUIANBHGogAkGMBWooAgA2AgAgAyAaNgIQIAMgEzYCDCADICU2AgggA0ICNwMADAELIAJBqANqIApB2ANqKAIANgIAIAIgCikC0AM3A6ADIAopA8gDIU4gAikDuAIhUyACKQPIAiFUIAIpA8ACIVUgAikD0AIhViACKQMQIVcgAikDGCFYIAIpAyAhWSACKQMoIV0gAkH4BGoiByACQUBrQdgA/AoAACACQaAEaiAZIAcQqgIgAkGQBGoiByACQbAEaikDADcDACACQZgEaiIIIAJBuARqKQMANwMAIAIgAikDqAQ3A4gEAkAgAikDoAQiUkIJUQRAIAMgAikDiAQ3AwggA0ICNwMAIANBGGogCCkDADcDACADQRBqIAcpAwA3AwAMAQsgAkHQA2ogAkHABGpBOPwKAAAgAkHAA2ogAkGQBGopAwA3AwAgAkHIA2ogAkGYBGopAwA3AwAgAiBSNwOwAyACIAIpA4gENwO4A0GAgICAeCEZQYCAgIB4ISkCQAJAIAIoAvwCQYCAgIB4Rg0AIAJB+ARqIQkgAigCgAMiByACKAKEA0EMbGohCyMAQTBrIggkACAIQQg2AgAgCCALNgIoIAggBzYCJCAIIAg2AiwgCEEYaiEVIwBBMGsiByQAIAdBGGogCEEkaiILENslAkACQAJAIActAB1BBEcEQCAHKQMYIVEgB0EgaiIsQQRBAEEEQQgQoBggBygCJCESIAcoAiBBAUYNAiAHKAIoIhggUTcCACAHQRRqIiNBATYCACAHIBg2AhAgByASNgIMIAdBKGogC0EIaigCADYCACAHIAspAgA3AyAjAEEQayILJAAgC0EIaiAsENslIAstAA1BBEcEQCAHQQxqIRIDQCALKQMIIVEgEigCCCIYIBIoAgBGBEAgEiAYQQFBBEEIENAoCyASKAIEIBhBA3RqIFE3AgAgEiAYQQFqNgIIIAtBCGogLBDbJSALLQANQQRHDQALCyALQRBqJAAgFUEIaiAjKAIANgIAIBUgBykCDDcCAAwBCyAVQQA2AgggFUKAgICAwAA3AgALIAdBMGokAAwBCyASIAcoAihByJfPABD9LwALAkAgCCgCAEEIRwRAIAkgCCkDADcDACAJQRBqIAhBEGopAwA3AwAgCUEIaiAIQQhqKQMANwMAIBVBBEEIEOAeDAELIAkgCCkCGDcCBCAJQQg2AgAgCUEMaiAIQSBqKAIANgIACyAIQTBqJAACQCACKAL4BCIHQQhrDgIAAQILIAIpA4AFIVIgAigC/AQhKQsCfyACKQOYASJRQgJRBEBCACFRQYCAgIB4DAELIAIpA7gBIVogAikCrAEhWyACKAKoASEZIAIpA6ABIVwgAigCtAELIQcgCigCrAMhCCAKKAKoAyEJIAopAxghXiAKKQMQIV8gCigCpAMhCyAKKAKgAyEVIAopAwghYCAKKQMAIWEgAigCtAIhEiACKAKwAiEYIAIpAzghYiACKQMwIWMgAyACKQOQAzcCgAIgAyACKQOgAzcCjAIgA0GIAmogAkGYA2ooAgA2AgAgA0GUAmogAkGoA2ooAgA2AgAgA0HgAGogAkGwA2pB2AD8CgAAIAMgETYCvAIgAyBaNwK0AiADIAc2ArACIAMgWzcDqAIgAyAZNgKkAiADIFI3ApwCIAMgKTYCmAIgAyBWNwP4ASADIFU3A/ABIAMgVDcD6AEgAyBTNwPgASADIE43A9gBIAMgGjYC1AEgAyATNgLQASADIAg2AswBIAMgCTYCyAEgAyALNgLEASADIBU2AsABIAMgEjYCvAEgAyAYNgK4ASADIFw3A1ggAyBRNwNQIAMgXjcDSCADIF83A0AgAyBgNwM4IAMgYTcDMCADIGI3AyggAyBjNwMgIAMgXTcDGCADIFk3AxAgAyBYNwMIIAMgVzcDACAUQQRBBBDgHiACQeQCaiIDENErIAMQ6DsgAkHwAmoQri8gAigC/AJBgICAgHhHBEAgAkH8AmpBBEEMEOAeCyACKQPAAUIDUgRAIAJBoAJqEJcwCyAKQbADahDULiAKQdwDahCGMAwHCyACKAL8BCEIIAIpA4AFIU4gAyACKQOIBTcDGCADIE43AxAgAyAINgIMIAMgBzYCCCADQgI3AwAgAkGwA2oQwhgLIAJBoANqEIYwCyACQZADakEBQQEQ4B4gFEEEQQQQ4B4gAkHkAmoiAxDRKyADEOg7IAJB8AJqEK4vICVBCEcNAiACKAL8AkGAgICAeEcEQCACQfwCakEEQQwQ4B4LIAJBmAFqENMuIAIpA8ABQgNRDQMgAkGgAmoQlzAMAwsgCCACKAIYQbDozwAQ/S8ACyAUQQRBBBDgHiACQeQCaiIDENErIAMQ6DsgAkHwAmoQri8LIAJBQGsQ8SsgAigC/AJBgICAgHhHBEAgAkH8AmpBBEEMEOAeCyACQZgBahDTLiACKQPAAUIDUgRAIAJBoAJqEJcwCyAKQdADahCGMAsgCkGwA2oQ1C4gCkHcA2oQhjAgESARKAIAIgNBAWs2AgAgA0EBRw0AIAJBDGoQ2SELIAJB0AVqJAAgBEGoBGoiAyAfQQhqKQMANwMAIARBsARqIgcgH0EQaikDADcDACAEIB8pAwA3A6AEIAQpA9gGIk5CAlINASAEIBZBBGo2AiggBCAcQegDajYCFCAFQRhqIAcpAwA3AwAgBUEQaiADKQMANwMAIAUgBCkDoAQ3AwggBUICNwMAIARBFGoQwxQgBCgCECIHBEAgBCgCDCEcA0AgHBDwEiAcQcACaiEcIAdBAWsiBw0ACwsgBEEIakEIQcACEOAeDAQLIBxB6ANqIScMBQsgBEG4BGogJkGgAvwKAAAgBCgCECIKIAQoAghGBEAgBEEIakGE+M8AEKEoCyAEKAIMIApBwAJsaiICIE43AwAgAiAEKQOgBDcDCCACQRBqIAMpAwA3AwAgAkEYaiAHKQMANwMAIAJBIGogBEG4BGpBoAL8CgAAIBZBBGohFiAEIApBAWo2AhAgKEEEayEoIBxB6ANqIhwgJ0cNAAsMAwsgBCACNgIEIAQgAzYCCCAEQQI2AtwGIARB1PjPADYC2AYgBEICNwLkBiAEQTs2AiAgBEE7NgIYIAQgBEEUajYC4AYgBCAEQQhqNgIcIAQgBEEEajYCFCAFQQxqIARB2AZqEJkOIAVCAjcDACAFQQA2AggLIA4oAjgiBwRAIA4oAjQhHANAIBwQ2BMgHEHoA2ohHCAHQQFrIgcNAAsLICBBCEHoAxDgHiAOKAI8QYCAgIB4RwRAIA5BPGpBBEEIEOAeCyAGIAYoAgAiAkEBazYCACACQQFHDQMgBBCGHwwDCwALIAQgFjYCKCAEICc2AhQLIARBFGoQwxQgBSAEKQIINwIgIAVBKGogBEEQaigCADYCACAFIAY2AjwgBSBQNwMYIAUgTzcDECAFQTRqIA5BxABqKQIANwIAIAUgDikCPDcCLCAFIA4pAwg3AwggBSAOKQMANwMAIA4oAjgiBwRAIA4oAjQhHANAIBwQ2BMgHEHoA2ohHCAHQQFrIgcNAAsLICBBCEHoAxDgHgsgBEHACmokACAQQagDaiICIgQgIkEIaikDADcDACAQQbADaiIDIgcgIkEQaikDADcDACAQICIpAwA3A6ADIBApA9gBIk5CAlINASAQIAxB0ABqNgK8ASABQRBqIAMpAwA3AwAgAUEIaiACKQMANwMAIAEgECkDoAM3AwAgAUGAgICAeDYCUCAQQbgBahD4FkEBIQcMBwsgDEHQAGohDwwECyAQQdADaiIKIA1BGGopAwA3AwAgEEHIA2oiBSANQRBqKQMANwMAIBBBwANqIg4gDUEIaikDADcDACAQIA0pAwA3A7gDIBAoAuADIgMgECgC2ANGBEAgEEHYA2pB9PbPABCcKAsgECgC3AMgA0EGdGoiAiAQKQOgAzcDCCACIE43AwAgAiAQKQO4AzcDICACQRBqIAQpAwA3AwAgAkEYaiAHKQMANwMAIAJBKGogDikDADcDACACQTBqIAUpAwA3AwAgAkE4aiAKKQMANwMAIBAgA0EBajYC4AMgDEHQAGoiDCAPRw0ACwwCC0EEQSQQoz0LAAsgECAPNgK8AQsgEEG4AWoQ+BYCQAJAIBAoAngiAkGAgICAeEYEQEGAgICAeCEHDAELIBAgECkCfCJONwKcASAQIAI2ApgBIE5CIIinIgIgBigCEEcNASAQQQA2AsABIBBCgICAgBA3ArgBQQAhDUEBIQxBACEHIE5CgICAgBBaBEAgBigCDCEMIAJBAnQhHANAIAcgECgCoAEiAk8NBSAQQdgBaiICIAwoAgAiAygCFCIEQQhqIAQoAghBAkZBAnRqIgQQiRkgAiAELQAhIANBCGoQ3SVB/wFxEM4mQf8BcSEDIBAoAsABIgIgECgCuAFGBEAgEEG4AWpBuPfPABCjKAsgDEEEaiEMIBAoArwBIAJqIAM6AAAgECACQQFqIg02AsABIAdBAWohByAcQQRrIhwNAAsgECgCvAEhDCAQKAK4ASEHCyAQQZgBakEBQQAQ4B4LIAEgECkCbDcCCCABIBApA2A3AhQgAUEQaiAQQfQAaigCADYCACABQRxqIBBB6ABqKAIANgIAIBApA0AhTiAQKAKQASECIAFBgICAgHg2AkQgAUGAgICAeDYCOCABIAI2AjAgASAGNgIsIAEgDTYCKCABIAw2AiQgASAHNgIgIAEgTjcDACABQdAAaiAQKQLYAzcDACABQdgAaiAQQeADaigCADYCACABIBApA9gBNwNIIB4Q9x0gHkEEQeAAEOAeIBBBIGoQuy4gEEGEAWoQhjAMBQtBACEHIBBB2AFqQRxBAEEBQQEQoBggECgC3AEhAyAQKALYAUEBRg0CIBAoAuABIgJBGGpB4PfPACgAADYAACACQRBqQdj3zwApAAA3AAAgAkEIakHQ988AKQAANwAAIAJByPfPACkAADcAACAQQZgBakEBQQAQ4B4gAUGAgICAeDYCUCABQRw2AgwgASACNgIIIAEgAzYCBCABQQA2AgALIBBB2ANqIgIQ3BggAkEIQcAAEOAeIAYgBigCACICQQFrNgIAIAJBAUcNAiAQQfADahCGHwwCCyAHIAJBqPfPABDDIQALIAMgECgC4AFBsOjPABD9LwALIB4Q9x0gHkEEQeAAEOAeIB1BCEcEQCAQQdQAaiICEPQbIAJBCEHQABDgHgsgEEHgAGoQri8gEEHsAGoQhjACQCAHRQ0AIBAoAnhBgICAgHhGDQAgEEH4AGpBAUEAEOAeCyAQQSBqELsuIBBBhAFqEIYwCyAQQQhqEJ08IBBBkARqJAAMAQsgAUHLAEEAQQFBARCgGCABKAIEIQIgASgCAEEBRg0BIAEoAggiA0Go9s8AQcsA/AoAACABQYCAgIB4NgJQIAFBywA2AgwgASADNgIIIAEgAjYCBCABQQA2AgALIAAgAUHgAPwKAAAgAUHgAGokAA8LIAIgASgCCEGw6M8AEP0vAAusAQECfyMAQSBrIgEkACABQQA2AhwgAUKAgICAwAA3AhQgAUEIaiABQRRqQfSo+wAQmCEgACgCBCECIAAoAgAhAyAAIAEpAwg3AgAgAgRAIAMgAkECdEEEEPg6CyABQQA2AhwgAUKAgICAIDcCFCABIAFBFGpB9Kj7ABCWISAAKAIMIQIgACgCCCEDIAAgASkDADcCCCACBEAgAyACQQJ0QQIQ+DoLIAFBIGokAAuOAQEBfyMAQRBrIgIkAAJAAkACQAJAIAAoAgBBnQtHBEAgAEEBIAEQthsiAA0BDAMLIAFBwAAQ0TRFDQEgARDpESIARQ0CIAAQmj4tAARBA3FFDQMLIAFFDQIgAEEAIAH8CwAMAgtBgPT8AEErIAJBD2pB8PP8AEHI9PwAENUeAAtBACEACyACQRBqJAAgAAuiAQECfwJAAkAgAkEBaiIEIAEoAhQiA0kEQCACIANJBEAgASgCECIDIARBAnRqKAIAIgQgAyACQQJ0aigCACIDSQ0CIAQgASgCCCICSw0DIAEoAgQhASAAIAQgA2s2AgQgACABIANqNgIADwsgAiADQbzigAEQwyEACyAEIANBrOKAARDDIQALIAMgBEHM4oABELE7AAsgBCACQczigAEQsDsAC6IBAQJ/AkACQCACQQFqIgQgASgCFCIDSQRAIAIgA0kEQCABKAIQIgMgBEEDdGooAgAiBCADIAJBA3RqKAIAIgNJDQIgASgCCCICIARJDQMgASgCBCEBIAAgBCADazYCBCAAIAEgA2o2AgAPCyACIANBvOKAARDDIQALIAQgA0Gs4oABEMMhAAsgAyAEQczigAEQsTsACyAEIAJBzOKAARCwOwALnQEBAn8jAEEwayICJAAgAiABNgIAIAAoAhAiAyABTQRAIAIgAzYCHCACQQI2AgggAkGg74UBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBsO+FARDvLAALIAAoAgQgACgCDCABaiIAQQN2ai0AACACQTBqJAAgAEEHcXZBAXELrwEBAX8jAEFAaiICJAAgACgCACEAIAJBoNSHATYCOCACQYDUhwE2AjAgAiAAQcEAajYCLCACQZDUhwE2AiggAiAAQSBqNgIkIAJBgNSHATYCICACIABBQGs2AhwgAkHw04cBNgIYIAIgAEEoajYCFCACQeDThwE2AhAgAiAAQTRqNgIMIAIgADYCPCACIAJBPGo2AjQgAUGU1YcBQeTUhwEgAkEMahD5EiACQUBrJAALjwEBAn8jAEEwayIEJAAgACgCACIAKAIAIQMgAEEANgIAAkAgA0EBcQRAIARBCGoiAyAAQQRqQSj8CgAAQdwAQQQQrTYiAEUNASAAIANBKPwKAAAgAEEAOgBYIAAgAjYCLCAAIAE2AiggAEHUx8IAENQaIARBMGokAA8LQdSiwwBBMRCXPQALQQRB3AAQoz0AC6EBAQF/AkAgACgCAEUNACAAQQRqEJI+IAAoAgQiAUGEAUkNACABEPIfCwJAIAAoAggiAUUNACABIAEoAgBBAWsiATYCACABDQAgAEEIahCyGgsCQCAAKAIMIgFFDQAgASABKAIAQQFrIgE2AgAgAQ0AIABBDGoQshoLAkAgACgCECIBRQ0AIAEgASgCAEEBayIBNgIAIAENACAAQRBqELIaCwvlAwIGfwF+IwBBMGsiAyQAIAMgAjoAJyADQRhqIQcgASgCICgCACEBIANBJ2ohBkEBIQQjAEEQayICJAACQAJAAkAgASgCACABKAIIIgVrQQFLBEAgASgCBCAFaiAGLQAAOgAAIAEgBUEBajYCCAwBCyACQQhqIQQjAEEQayIFJAACQCABKAIAIgggASgCCEYEfyAFQQhqIAEQwxkgBS0ACEEERwRAIAQgBSkDCDcCAAwCCyABKAIABSAIC0EBSwRAIAEoAggiCCABKAIEaiAGLQAAOgAAIARBATYCBCABIAhBAWo2AgggBEEEOgAADAELIAFBAToADCABKAIQIAYgBkEBahDAJiABQQA6AAwgBEKEgICAEDcCAAsgBUEQaiQAIAItAAhBBEYEQCACKAIMIQQMAQsgAikDCCIJQv8Bg0IEUg0BIAlCIIinIQQLIAcgBDYCBCAHQQQ6AAAgASABKAIUIARqNgIUDAELIAcgCTcCAAsgAkEQaiQAAkACQCADLQAYQQRGDQAgAyADKQMYNwMoIANBBGogA0EoahDQCSADKAIEQQRGDQAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAMAQsgAEEENgIACyADQTBqJAAL5QMCBn8BfiMAQTBrIgMkACADIAI6ACcgA0EYaiEHIAEoAiAoAgAhASADQSdqIQZBASEEIwBBEGsiAiQAAkACQAJAIAEoAgAgASgCCCIFa0EBSwRAIAEoAgQgBWogBi0AADoAACABIAVBAWo2AggMAQsgAkEIaiEEIwBBEGsiBSQAAkAgASgCACIIIAEoAghGBH8gBUEIaiABEJ0ZIAUtAAhBBEcEQCAEIAUpAwg3AgAMAgsgASgCAAUgCAtBAUsEQCABKAIIIgggASgCBGogBi0AADoAACAEQQE2AgQgASAIQQFqNgIIIARBBDoAAAwBCyABQQE6AAwgAUEQaiAGIAZBAWoQwCYgAUEAOgAMIARChICAgBA3AgALIAVBEGokACACLQAIQQRGBEAgAigCDCEEDAELIAIpAwgiCUL/AYNCBFINASAJQiCIpyEECyAHIAQ2AgQgB0EEOgAAIAEgASgCHCAEajYCHAwBCyAHIAk3AgALIAJBEGokAAJAAkAgAy0AGEEERg0AIAMgAykDGDcDKCADQQRqIANBKGoQ0AkgAygCBEEERg0AIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC48BAQJ/IwBBMGsiBCQAIAAoAgAiACgCACEDIABBADYCAAJAIANBAXEEQCAEQQxqIgMgAEEEakEk/AoAAEHUAEEEEK02IgBFDQEgACADQST8CgAAIABBADoAUCAAIAI2AiggACABNgIkIABB9NzDABDUGiAEQTBqJAAPC0Hm2cMAQTEQlz0AC0EEQdQAEKM9AAuUAQECfyMAQdAAayIEJAAgACgCACIAKAIAIQMgAEEANgIAAkAgA0EBcQRAIARBDGoiAyAAQQRqQcQA/AoAAEGUAUEEEK02IgBFDQEgACADQcQA/AoAACAAQQA6AJABIAAgAjYCSCAAIAE2AkQgAEG03MMAENQaIARB0ABqJAAPC0Hm2cMAQTEQlz0AC0EEQZQBEKM9AAudAQEBfyMAQRBrIgIkAAJAAkAgAUUEQCACIAAQ9xcgAigCDCIAEIg1IABBMEEIEPg6IAIoAggiAQRAIAIoAgQhAANAIAAQhzUgAEFAayEAIAFBAWsiAQ0ACwsgAkEIQcAAEOAeDAELIABFDQEgAiAAQQhrIgA2AgAgACAAKAIAQQFrIgA2AgAgAA0AIAIQgR8LIAJBEGokAA8LEJg9AAuaAQIBfwJ+IwBBIGsiBCQAIARBCGogACgCECABQQxsahDcOyAEQRBqIAQoAgggAmpBfyACIANqIgMgAiADSxsgAmsgASACEPAKIAQpAxghBSAEKQMQIQYgACgCCCIBIAAoAgBGBEAgAEGchM0AELEoCyAAKAIEIAFBBHRqIgIgBTcDCCACIAY3AwAgACABQQFqNgIIIARBIGokAAusAQECfyMAQRBrIgMkAAJAAkAgAa0gAlgEQCAAQQg2AgAMAQsgA0EEakETQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCIBQQ9qQYOAzgAoAAA2AAAgAUEIakH8/80AKQAANwAAIAFB9P/NACkAADcAACAAQRM2AgwgACABNgIIIAAgBDYCBCAAQQI2AgALIANBEGokAA8LIAQgAygCDEG09c0AEP0vAAudAQAgACABKQIANwIAIABBCGogAUEIaigCADYCAAJAAkAgAkEETwRAIAAgACkCADcCBCACQQNrIQEMAQsCfwJAAkAgAiADakEBayICDgQEAQEAAQsgACgCACIDQQFrDAELIAAoAgAhAyAAIAJBAnRqKAIACyEBIAAgAEEIaiAAQQRqIAJBAUYbKAIANgIIIAAgAzYCBAsgACABNgIACwunAQECfwJAAkACQAJAAkACQAJAAkACQAJAAkAgAUH/AXFBMGsOCgABAgMEBQYHCAkKC0EBIQIMCQtBASEDQQEhAgwIC0EBIQJBAiEDDAcLQQEhAkEDIQMMBgtBASECQQQhAwwFC0EBIQJBBSEDDAQLQQEhAkEGIQMMAwtBASECQQchAwwCC0EBIQJBCCEDDAELQQEhAkEJIQMLIAAgAzoAASAAIAI6AAALqAEBA38jAEFAaiIDJAAgAyACNgIIQZOAgIB4IQQgACACIAEoAhQiBUcEfyADIAU2AiQgA0EDNgIQIANBjPiGATYCDCADQgM3AhggA0E7NgI8IANBOzYCNCADQa0DNgIsIAMgAUEYajYCKCADIANBKGo2AhQgAyADQSRqNgI4IAMgA0EIajYCMCAAQQRqIANBDGoQmQ5BjYCAgHgFIAQLNgIAIANBQGskAAuXAQECfyMAQSBrIgEkAAJAIAAoAlgiAkUEQEEAIQAMAQsgAUEIaiAAQQxqEIY9IAFBFGoiACABKAIIIAEoAgwQiz0gASAAEMcbQQAhACACIAEoAgRNBEAgASgCACACQQJ0akEEaygCACEACyABKAIUIgIgAigCACICQQFrNgIAIAJBAUcNACABQRRqEPseCyABQSBqJAAgAAuRAQICfwF+IwBBIGsiASQAAkAgACgCWCICRQRADAELIAFBCGogAEEMahCGPSABQRRqIgAgASgCCCABKAIMEIs9IAEgABDFGyACIAEoAgRNBEAgASgCACACQQN0akEIaykDACEDCyABKAIUIgAgACgCACIAQQFrNgIAIABBAUcNACABQRRqEPseCyABQSBqJAAgAwuXAQECfyMAQSBrIgEkAAJAIAAoAlgiAkUEQEEAIQAMAQsgAUEIaiAAQQxqEIY9IAFBFGoiACABKAIIIAEoAgwQiz0gASAAEMYbQQAhACACIAEoAgRNBEAgASgCACACQQF0akECay8BACEACyABKAIUIgIgAigCACICQQFrNgIAIAJBAUcNACABQRRqEPseCyABQSBqJAAgAAuMAQECfyMAQbABayICJAACQCABBEAgAUEIayIDKAIAQQFHDQEgAkEQaiABQaAB/AoAACADQQA2AgACQCADQX9GDQAgAUEEayIBIAEoAgBBAWsiATYCACABDQAgA0GoAUEIEPg6CyAAIAJBGGpBmAH8CgAAIAJBsAFqJAAPCxCYPQALQf2CwwBBPxCXPQALoAECAX8EfiMAQSBrIgIkACACQgA3AwAgAUEHTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQcTZzgAQ7ywACyACQQggAEEIQdTZzgAQ1SwgAjUCACEDIAIxAAQgAjEABSEFIAIxAAYhBiACQSBqJABCKIYgA0IIhoQgBUIwhoQgBkI4hoRCvc/W8dH36ZoefkIsiKcLjQEBBH8jAEEQayIFJAAgAiAAKAIIIgNNBEAgAgRAIAAoAgQhBgNAIAIgAyACIANJGyIEBEAgASAGIAT8CgAACyAEIAZqIQYgAyAEayEDIAEgBGohASACIARrIgINAAsgACADNgIIIAAgBjYCBAsgBUEQaiQADwsgBSADNgIMIAUgAjYCCCAFQQhqEPMlAAuYAQAgAAJ/IAQgAiADQcCACGpNckUEQCAAIAFBoIAIaiIBNgL06wEgASADaiEDQQEMAQsgA0GBgARPBEAgACABIAVqIgEgA2siAkHg/wNqIgQgAiAGGzYC9OsBIAMgBGpBgIAEayABIAYbIQNBAgwBCyAAIABBgOwBaiIBNgL06wEgASADaiEDQQALNgL86wEgACADNgL46wELmgECAX8CfiMAQSBrIgIkACACQRBqIAEQyi8gAiACKAIQNgIcIAIgAkEcahDRH6xCgKMFfiACNQIUfEKAkc285wF9IgMgA0I/h0KAlOvcA0IAEKgeIAACfkIAIAIpAwggAikDACIDQj+HUg0AGkIAIAI1AhgiBEIAVCADIAMgBHwiA1VzDQAaIAAgAzcDCEIBCzcDACACQSBqJAALkQEBAn8jAEEQayIEJAACQCABKAIAIgFBAXEEQCAEIAE2AgAgBEEIaiIFIAIgAWsiAiADaiIBNgIAIAQgATYCBCAEQQdBICABQQp2Z2siASABQQdPG0ECdEEBcjYCDCAEIAIQpx4gAEEIaiAFKQIANwIAIAAgBCkCADcCAAwBCyAAIAEgAiADEMYSCyAEQRBqJAALjQECAn8DfiADQfj///8BcQRAIAAgACADQQN2IgNBBnQiBWogACADQfAAbCIGaiADIAQQmxohACABIAEgBWogASAGaiADIAQQmxohASACIAIgBWogAiAGaiADIAQQmxohAgsgACACIAEgACkDACIHIAEpAwAiCFQiACAIIAIpAwAiCVRzGyAAIAcgCVRzGwuKAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBXQiBWogACADQThsIgZqIAMgBBCcGiEAIAEgASAFaiABIAZqIAMgBBCcGiEBIAIgAiAFaiACIAZqIAMgBBCcGiECCyAAIAIgASAAKAIAIgAgASgCACIBSSIDIAEgAigCACICSXMbIAMgACACSXMbC4oBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0EFdCIFaiAAIANBOGwiBmogAyAEEJ0aIQAgASABIAVqIAEgBmogAyAEEJ0aIQEgAiACIAVqIAIgBmogAyAEEJ0aIQILIAAgAiABIAAoAgAiACABKAIAIgFJIgMgASACKAIAIgJJcxsgAyAAIAJJcxsLmQEBAX8gAEE0ahCdDAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIABBDGoQnQwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgABDqOyAAKAJAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQUBrEPseCwuNAQEBfyMAQTBrIgMkACAAAn4gAkUEQEHAACABrcN5p2shAkIDDAELIANBADYCLCADQoCAgIAQNwIkIAMgA0EkahDnFSADQRhqQgA3AwAgA0EgakEAOgAAIANCADcDEEIECzcDACAAIAE7AUggAEEIaiADQST8CgAAIAAgAjoAQiAAIAE7AUAgA0EwaiQAC3YBAn8gA0EIIAQgASADaiIFa0EBaiIGIAZBCE8bQQAgBCAFTxsgA2oiBCADIARLGyEEIABBLGohBSAAKAIkQQhqIQYDQCADIARHBEAgBSADQQdxQQJ0aiABIANqIAYgAiAAKQNQEOYjNgIAIANBAWohAwwBCwsLiwEBAn8gA0H4////AXEEQCAAIAAgA0EDdiIDQTBsIgVqIAAgA0HUAGwiBmogAyAEEKEaIQAgASABIAVqIAEgBmogAyAEEKEaIQEgAiACIAVqIAIgBmogAyAEEKEaIQILIAAgAiABIAAoAgAiACABKAIAIgFJIgMgASACKAIAIgJJcxsgAyAAIAJJcxsL3gEBBH8jAEEgayIDJAAgA0EUaiABQQBBBEEQEKAYIAMoAhghBSADKAIUQQFGBEAgBSADKAIcIAIQ/S8ACyADQRBqIgJBADYCACADIAMoAhw2AgwgAyAFNgIIIAEiBSADQQhqIgYoAgAgBigCCCIEa0sEQCAGIAQgAUEEQRAQ3iggBigCCCEECyAGIAEEfyABIARqIAYoAgQgBEEEdGohBANAIARBADYCACAEQRBqIQQgBUEBayIFDQALBSAECzYCCCAAQQhqIAIoAgA2AgAgACADKQIINwIAIANBIGokAAuZAQEBfyAAQTRqELMMAkAgACgCTCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQcwAahD7HgsgAEEMahCzDAJAIAAoAhwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEcahD7HgsgABDDJyAAEOo7IAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ+x4LC4MBAQJ/IwBBIGsiAyQAIANBFGogAUEAQQRBBBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHCACEP0vAAsgA0EQaiICQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqQQAgARCIICAAQQhqIAIoAgA2AgAgACADKQIINwIAIANBIGokAAudAQEDfyMAQSBrIgQkAAJAIAEoAhBBfyACIANqIgUgAiAFSxtPBEAgASgCACIFIAUoAgAiBkEBajYCACAGQQBIDQEgACADNgIQIAAgBTYCACAAIAEpAgQ3AgQgACABKAIMIAJqNgIMIARBIGokAA8LIARBADYCGCAEQQE2AgwgBEHogYgBNgIIIARCBDcCECAEQQhqQfCBiAEQ7ywLAAuJAQEFfyMAQRBrIgMkAAJAAkAgAkEHTQRAIAINAQwCCyADQQhqQS4gASACEJ0SIAMoAghBAUYhBAwBCyACQQFrIQYgASEFA0AgBS0AAEEuRiIEDQEgBUEBaiEFIAYiB0EBayEGIAcNAAsLIAAgBCAALQAEcjoABCAAKAIAIAEgAhD7NSADQRBqJAALswICBH8BfiMAQRBrIgUkAAJAAkAgASgCACABKAIIIgRrIANLBEAgAwRAIAEoAgQgBGogAiAD/AoAAAsgASADIARqNgIIDAELIAVBCGohByMAQRBrIgQkAAJAIAEoAgAiBiABKAIIayADSQR/IARBCGogARCdGSAELQAIQQRHBEAgByAEKQMINwIADAILIAEoAgAFIAYLIANLBEAgASgCCCEGIAMEQCABKAIEIAZqIAIgA/wKAAALIAdBBDoAACABIAMgBmo2AggMAQsgAUEBOgAMIAFBEGogAiADEKE2IAdCBDcCACABQQA6AAwLIARBEGokACAFLQAIQQRGDQAgBSkDCCIIQv8Bg0IEUQ0AIAAgCDcCAAwBCyAAQQQ6AAAgASABKAIcIANqNgIcCyAFQRBqJAALswICBH8BfiMAQRBrIgUkAAJAAkAgASgCACABKAIIIgRrIANLBEAgAwRAIAEoAgQgBGogAiAD/AoAAAsgASADIARqNgIIDAELIAVBCGohByMAQRBrIgQkAAJAIAEoAgAiBiABKAIIayADSQR/IARBCGogARDDGSAELQAIQQRHBEAgByAEKQMINwIADAILIAEoAgAFIAYLIANLBEAgASgCCCEGIAMEQCABKAIEIAZqIAIgA/wKAAALIAdBBDoAACABIAMgBmo2AggMAQsgAUEBOgAMIAEoAhAgAiADEKE2IAdCBDcCACABQQA6AAwLIARBEGokACAFLQAIQQRGDQAgBSkDCCIIQv8Bg0IEUQ0AIAAgCDcCAAwBCyAAQQQ6AAAgASABKAIUIANqNgIUCyAFQRBqJAALzgYCCn8BbyMAQTBrIgckAAJAIAEtABBFBEAgB0EcaiEKIwBBIGsiCCQAIAhBDGohCyACIQNBACECIwBBIGsiBCQAIwBBEGsiBiQAIAFBCGohBQJAIAEoAghFBEAgASgCAEEBRwRAQQIhAwwCCyABQQRqKAIAJQEQJCENEN8SIgIgDSYBIAIQ+w4hCQJAIAEoAggiAkUNACACIAIoAgBBAWsiDDYCACAMDQAgBRCyGgsgBSAJNgIACyAGIAUgAxDHGCAGKAIAIgNBAkYEQEEDIQMMAQsgBigCBCECAkAgBSgCACIJRQ0AIAkgCSgCAEEBayIJNgIAIAkNACAFELIaCyAFQQA2AgAgA0EBcQRAIAEoAgAEQCABQQRqENUvCyABQQA2AgAMAQsgBiACNgIMAn9BAiAGQQxqIgMoAgAlARA1IgVBAEcgBUH///8HRhtB/QFxRQRAIAMoAgAlARA2IQ0Q3xIiAiANJgFBAAwBCyABKAIABEAgAUEEahDVLwsgAUEANgIAQQILIQMgBigCDCIFQYQBSQ0AIAUQ8h8LIAQgAjYCBCAEIAM2AgAgBkEQaiQAAkAgBCgCACIDQQNGBEAgC0GCgICAeDYCAAwBCwJAIANBAkcEQCAEKAIEIQIgA0EBcQRAIARBgICAgHg2AgwgBCACNgIQDAILIARBDGohAyACJQEhDSACEPIfAkAgDRAIIgZFBEAgA0GAgICAeDYCACADIAI2AgQMAQsgAyAGELIWCwwBCyAEQYGAgIB4NgIMCyALIAQpAgw3AgAgC0EQaiAEQRxqKAIANgIAIAtBCGogBEEUaikCADcCAAsgBEEgaiQAIAgoAgwiAkGCgICAeEcEQCAIKAIUIQQgCCgCECEDIAogCCkCGDcCDCAKIAMgBCACQYCAgIB4RiIEGzYCCCAKQQUgAyAEGzYCBAsgCiACNgIAIAhBIGokACAHKAIcIgJBgoCAgHhGBEAgAEGCgICAeDYCAAwCCyAHQRBqIgMgB0EoaikCADcDACAHIAcpAiA3AwggAkGBgICAeEYEQCABQQE6ABALIAAgAjYCACAAIAcpAwg3AgQgAEEMaiADKQMANwIADAELIABBgYCAgHg2AgALIAdBMGokAAuBCQELfyMAQRBrIggkACAIQQRqIQUjAEEwayIDJAACQAJAIAEoAgAiBygCFCICIAcoAhAiBEkEQCAHQQxqIQkgBygCDCEKA0AgAiAKai0AACIGQQlrIgtBF0tBASALdEGTgIAEcUVyDQIgByACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBAjYCJEEBIQYgA0EYaiAHQQxqIAJBAWoiAiAEIAIgBEkbEOoMIAUgA0EkaiADKAIYIAMoAhwQ+yg2AgQMAQsgBkHdAEYEQEEAIQYgBUEAOgABDAELAkACQCABLQAERQRAIAZBLEcNAUEBIQYgByACQQFqIgI2AhQgAiAESQRAA0AgAiAKai0AACILQQlrIgxBF0tBASAMdEGTgIAEcUVyDQQgByACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBBTYCJCADIAkgAkEBaiICIAQgAiAESRsQ6gwgBSADQSRqIAMoAgAgAygCBBD7KDYCBAwDCyAFQQE6AAFBACEGIAFBADoABAwCCyADQQc2AiRBASEGIANBEGogCSACQQFqIgIgBCACIARJGxDqDCAFIANBJGogAygCECADKAIUEPsoNgIEDAELIAtB3QBGBEAgA0EVNgIkIANBCGogCSACQQFqIgIgBCACIARJGxDqDCAFIANBJGogAygCCCADKAIMEPsoNgIEDAELIAVBAToAAUEAIQYLIAUgBjoAACADQTBqJAACQCAILQAEQQFGBEAgACAIKAIINgIEIABBgYCAgHg2AgAMAQsgCC0ABUUEQCAAQYCAgIB4NgIADAELIAhBBGohAiABKAIAIQQjAEEgayIBJAAgAUEEaiAEEP4eAkACQAJAAkACQAJ/IAEtAARBAUYEQCABKAIIDAELIAEtAAVBAUYEQCABLQAGQSJHDQIgBBDvOiAEQQA2AgggAUEQaiAEQQxqIAQQvg8gASgCFCEGIAEoAhAiC0ECRw0DIAJBgICAgHg2AgAgAiAGNgIEDAYLIAFBBTYCECAEIAFBEGoQlicLIQQgAkGAgICAeDYCACACIAQ2AgQMBAsgASAEIAFBH2pB8M7DABCeCjYCCAwBCyABQQRqIQcgASgCGCEFIwBBEGsiAyQAIANBBGogBUEAQQFBARCgGCADKAIIIQkCQCADKAIEQQFHBEAgAygCDCEKIAUEQCAKIAYgBfwKAAALIAcgBTYCCCAHIAo2AgQgByAJNgIAIANBEGokAAwBCyAJIAMoAgxB+M+IARD9LwALIAEoAgQhAyALQQFxBEAgA0GAgICAeEYNASACIAEpAgQ3AgAgAkEIaiABQQxqKAIANgIADAMLIANBgICAgHhHDQELIAQgASgCCBCVPiEEIAJBgICAgHg2AgAgAiAENgIEDAELIAIgASkCBDcCACACQQhqIAFBDGooAgA2AgALIAFBIGokACAIKAIEQYCAgIB4RwRAIAAgCCkCBDcCACAAQQhqIAhBDGooAgA2AgAMAQsgACAIKAIINgIEIABBgYCAgHg2AgALIAhBEGokAAuxAQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkAgAC8BAEEBaw4GAQIDBAUGAAsgAUHY68MAQQcQ+zUMBgsgAUHf68MAQQcQ+zUMBQsgAUHm68MAQQgQ+zUMBAsgAiAAQQJqNgIMIAFBgOzDAEEGIAJBDGpB8OvDABDQEwwDCyABQYbswwBBBBD7NQwCCyABQYrswwBBBhD7NQwBCyABQZDswwBBBxD7NQsgAkEQaiQAC5MBAQN/IwBBEGsiAyQAAkACQCABp0EBcQRAIABBCDYCACAAIAI3AwgMAQsgA0EEakEnQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCIFQfbCzgBBJ/wKAAAgAEEnNgIMIAAgBTYCCCAAIAQ2AgQgAEECNgIACyADQRBqJAAPCyAEIAMoAgxB2KfOABD9LwALjQEBBH8gACABKAJ4KAIAQQhGBH8gASgCbCABKAJka0EMbiICIAEoAlQgASgCTGtBDG4iAyABKAI8IAEoAjRrQQR2IgQgASgCJCABKAIcayIFIAEoAhQgASgCEGsiASABIAVLGyIBIAEgBEsbIgEgASADSxsiASABIAJLGwUgAgs2AgggAEKAgICAEDcCAAuPAQEDfyMAQSBrIgIkAAJAIAFFDQAgACgCACEEIABBCTYCACAEQQlGBEAgASEDDAELIAJBHGogAEEUaigCADYCACACQRRqIABBDGopAgA3AgAgAiAENgIIIAIgACkCBDcCDCACIAE2AgAgAkEIahDWJyABQQFrIgFFDQAgAEEJNgIAIAEhAwsgAkEgaiQAIAMLoAEBAX8jAEEgayIEJAACQCADQYAibCIDIAJNBEAgAiADa0H/AU0NASAAQYACNgIEIAAgASADQQF0ajYCACAEQSBqJAAPCyAEQQA2AhggBEEBNgIMIARBgPDRADYCCCAEQgQ3AhAgBEEIakHo8NEAEO8sAAsgBEEANgIYIARBATYCDCAEQYDw0QA2AgggBEIENwIQIARBCGpB+PDRABDvLAALYwIEfwJ9IwBBIGsiAiQAIAJBEDYCBCAAQQRqIQEgACoCACEFQQEhAANAIAEqAgAiBiAFIAUgBl4iBBshBSAAIAMgBBshAyABQQRqIQEgAEEBaiIAQRBHDQALIAJBIGokACADC5sBAQJ/QagBIQEDQCAAIAFqQQA7AQAgAUEEaiIBQaAKRw0ACyAAQaQTaiECQQAhAQNAIAEgAmpBADsBACABQQRqIgFB+ABHDQALIABBoBVqIQJBACEBA0AgASACakEAOwEAIAFBBGoiAUHMAEcNAAsgAEIANwN4IABBATsBqAkgACgCQCAAKAJEQQAQ7S8gAEEAOgA6IABBADYCSAuWAQEBfwJAIAAoAgAiACgCDEECRg0AIAAoAhAiAUGEAUkNACABEPIfCyAAKAIUIgEEQCAAKAIYIAEoAgwRAwALAkAgACgCHEUNACAAQSRqEKw7BEAgAEEcahC8KgsgAEEwahCsO0UNACAAQShqELwqCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEE0QQQQ+DoLC5EBAQJ/IwBBsAFrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQdgA/AoAAEHAAUEIEK02IgBFDQEgACADQbAB/AoAACAAQQA6ALgBIAAgAjYCtAEgACABNgKwASAAQbTHwgAQ1BogA0GwAWokAA8LQdSiwwBBMRCXPQALQQhBwAEQoz0AC5EBAQJ/IwBBsAZrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQZgD/AoAAEHABkEIEK02IgBFDQEgACADQbAG/AoAACAAQQA6ALgGIAAgAjYCtAYgACABNgKwBiAAQfTGwgAQ1BogA0GwBmokAA8LQdSiwwBBMRCXPQALQQhBwAYQoz0AC5EBAQJ/IwBBkAFrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQcgA/AoAAEGgAUEIEK02IgBFDQEgACADQZAB/AoAACAAQQA6AJgBIAAgAjYClAEgACABNgKQASAAQaTHwgAQ1BogA0GQAWokAA8LQdSiwwBBMRCXPQALQQhBoAEQoz0AC5EBAQJ/IwBBgANrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQcAB/AoAAEGQA0EIEK02IgBFDQEgACADQYAD/AoAACAAQQA6AIgDIAAgAjYChAMgACABNgKAAyAAQYTHwgAQ1BogA0GAA2okAA8LQdSiwwBBMRCXPQALQQhBkAMQoz0AC5EBAQJ/IwBB4AVrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQfAC/AoAAEHwBUEIEK02IgBFDQEgACADQeAF/AoAACAAQQA6AOgFIAAgAjYC5AUgACABNgLgBSAAQcTHwgAQ1BogA0HgBWokAA8LQdSiwwBBMRCXPQALQQhB8AUQoz0AC5QBAgJ/AX4jAEEgayIDJAAgA0EQakEAOwEAIANCADcDCCACIANBCGoiBBCyFSICQQtJBEAgA0EYaiABKAIAKAIAIAQgAhCoGgJAAkAgAy0AGEEERg0AIAMpAxgiBUL/AYNCBFENACAAIAU3AgAMAQsgAEEEOgAAIAAgAjYCBAsgA0EgaiQADwsgAkEKQYi9wwAQsDsAC5QBAgJ/AX4jAEEgayIDJAAgA0EQakEAOwEAIANCADcDCCACIANBCGoiBBCyFSICQQtJBEAgA0EYaiABKAIAKAIAIAQgAhCnGgJAAkAgAy0AGEEERg0AIAMpAxgiBUL/AYNCBFENACAAIAU3AgAMAQsgAEEEOgAAIAAgAjYCBAsgA0EgaiQADwsgAkEKQYi9wwAQsDsAC4oBAQJ/IwBBMGsiAyQAIAAoAgAiACgCACEEIABBADYCAAJAIARBAXEEQCADIABBBGpBMPwKAABB7ABBBBCtNiIARQ0BIAAgA0Ew/AoAACAAQQA6AGggACACNgI0IAAgATYCMCAAQdTcwwAQ1BogA0EwaiQADwtB5tnDAEExEJc9AAtBBEHsABCjPQALigEBAn8jAEEwayIDJAAgACgCACIAKAIAIQQgAEEANgIAAkAgBEEBcQRAIAMgAEEEakEw/AoAAEHsAEEEEK02IgBFDQEgACADQTD8CgAAIABBADoAaCAAIAI2AjQgACABNgIwIABBxNzDABDUGiADQTBqJAAPC0Hm2cMAQTEQlz0AC0EEQewAEKM9AAu2GQENfyMAQTBrIgokACAKQSRqIANBAEEBQQEQoBggCigCKCEFIAooAiRBAUYEQCAFIAooAixBwJfEABD9LwALIApBADoAICAKQQA2AgggCiAKKAIsNgIEIAogBTYCACAKIAEoAgw2AhwgCiABKAIINgIYIAogASgCBDYCFCAKIAEoAgA2AhAgCiABKAIQNgIMIAAhDCMAQaABayIEJAAgCiIAKAIcIQ0gACgCGCEJIARBGGohDiACIhAgAyIGaiEBA0ACQCAIIQUgASACIgNGBEAgASECQQAhC0EAIQUMAQsCfyADLAAAIgJBAE4EQCACQf8BcSEHIANBAWoMAQsgAy0AAUE/cSEHIAJBH3EhCCACQV9NBEAgCEEGdCAHciEHIANBAmoMAQsgAy0AAkE/cSAHQQZ0ciEHIAJBcEkEQCAHIAhBDHRyIQcgA0EDagwBCyAIQRJ0QYCA8ABxIAMtAANBP3EgB0EGdHJyIQcgA0EEagsiAiADayAFaiIIIQsgB0EhSQ0BCwsCQANAIAIgASIDRg0BIAFBAWsiASwAACIHQQBIBH8gB0E/cQJ/IANBAmsiAS0AACIHwCIPQUBOBEAgB0EfcQwBCyAPQT9xAn8gA0EDayIBLQAAIgfAIg9BQE4EQCAHQQ9xDAELIA9BP3EgA0EEayIBLQAAQQdxQQZ0cgtBBnRyC0EGdHIFIAcLQSFJDQALIAggAmsgA2ohCwsgDiALIAVrNgIEIA4gBSAQajYCACAEKAIcIQggBCgCGCEFAkAgCUUNACAGIAhLBEAgCUEBIA0oAhQRAAALIAUgCGohByAFIQEDQCABIAdGDQECfyABLAAAIgJBAE4EQCACQf8BcSECIAFBAWoMAQsgAS0AAUE/cSEGIAJBH3EhAyACQV9NBEAgA0EGdCAGciECIAFBAmoMAQsgAS0AAkE/cSAGQQZ0ciEGIAJBcEkEQCAGIANBDHRyIQIgAUEDagwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgJBgIDEAEYNAiABQQRqCyEBQQEgAnRBgMwAcUUgAkENS3INAAsgCUEJIA0oAhQRAAALIARBEGohBiAAIQIjAEEQayIDJAAgAyAFIAhqIggiATYCBCADIAU2AgAgAyABNgIMIAMgBTYCCAJ/QQAgA0EIahDuEkHf//8AcUHBAGtBGUsNABoCQAJAIAMQ7hIiAUGAgMQARwRAA0ACQCABQeEAa0EaSSABQTBrQQpJciABQStGIAFBLWtBAklyckUEQCABQTpGDQQgAUHBAGtBGk8NBSACKAIIIQcgAkEBENgtIAIoAgQgAigCCGogAUEgcjoAAAwBCyACKAIIIQcgAkEBENgtIAIoAgQgAigCCGogAToAAAsgAiAHQQFqNgIIIAMQ7hIiAUGAgMQARw0ACwsgAi0AIEEBRw0BCyADKAIEIQIgAygCAAwBCyACQQA2AghBAAshASAGIAI2AgQgBiABNgIAIANBEGokAAJAAkACQAJAAkACQAJAAkACQCAEKAIQIgNFBEAgACgCDCIBDQFBBiEBDAgLIAQoAhQhCCAEQSBqIgIgAEEk/AoAACAEKAIoIQdBASEFAkAgAigCBCIAIAIoAggiAUG0hsQAQQQQwS4NACAAIAFBuIbEAEEFEMEuDQAgACABQb2GxABBAhDBLg0AIAAgAUG/hsQAQQMQwS4NACAAIAFBwobEAEEDEMEuDQBBAEECIAAgAUHFhsQAQQQQwS4bIQULIAJBARDYLSAEKAIkIAQoAihqQTo6AAAgBCAHQQFqIgs2AigCQAJAAkACQCAFQf8BcUEBaw4CAQIACwJAIAQoAjgiAEUNACAEKAI8IQEgBCAINgKAASAEIAM2AnxBnIfEAEECIARB/ABqEIUVDQAgAEEEIAEoAhQRAAALQQAhAiAEKAIsIgEEQCABKAIUIQICQCABKAIgIgBFDQAgASgCGCIFIABNBEAgACAFRg0BDAwLIAAgAmosAABBv39MDQsLIAFBACACIABBxYbEAEEEEMEuGyECCyAEQQA2AiggBEH8AGoiACAEQSBqQST8CgAAIAwgACADIAggAhC1AQwLC0EAIQAgCCEBIAMhAgNAIAQgATYCgAEgBCACNgJ8IARB/ABqEO4SIgVB3ABHIAVBL0dxRQRAIABBAWohACAEKAKAASEBIAQoAnwhAgwBCwsgAEEBSw0HIAQoAiwiBQ0BDAcLIARBxABqIARBIGoiAUEk/AoAACAEIAg2AoABIAQgAzYCfEGch8QAQQIgBEH8AGoiABCFFQRAIAQoAoABIQIgBCgCfCEDIAAgAUEk/AoAACAMIAAgAyACQQIgBxCUAgwKCyAEQQA6AGggBCgCTCEJIAQgCDYCgAEgBCADNgJ8An8gBEH8AGoiABDuEkEvRgRAIAQoAoABIQEgBCgCfCECIARBxABqIgNBARDYLSAEKAJIIAQoAkxqQS86AAAgBCAJQQFqNgJMIARBADoAfCAEIANBAiAAIAkgAiABEL8BIAQoAgAhACAEKAIEDAELIARBCGohDiAEQcQAaiELIwBBIGsiBiQAIAYgCDYCECAGIAMiADYCDAJAAkACQAJAIAMgCEYNAANAIAAiAyEBA0ACQCABLAAAIgJBAE4EQCABQQFqIQAgAkH/AXEhBQwBCyABLQABQT9xIQAgAkEfcSEFIAJBX00EQCAFQQZ0IAByIQUgAUECaiEADAELIAEtAAJBP3EgAEEGdHIhDSACQXBJBEAgDSAFQQx0ciEFIAFBA2ohAAwBCyABQQRqIgAhAiAFQRJ0QYCA8ABxIAEtAANBP3EgDUEGdHJyIgVBgIDEAEYNBAtBASAFdEGAzABxRSAFQQ1LckUEQCAAIgEiAiAIRw0BDAQLCyAGIAA2AgwCQAJ/QQEgBUGAAUkNABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiDSAIIAFrIgJPBEAgAiANRg0BDAULIAEgDWosAABBv39MDQQLAkAgBUEjRwRAIAVBP0cEQCAFQYCAxABHDQIMBAsgAyECIAstACBFDQQMAQsgAyECIAstACBFDQMLIAsoAhgiAgRAIAIgCygCHCAFIAZBDGoQkAwLIAZBrJDEADYCHCAGIA02AhggBiABNgIUIAsgBkEUahCvHiAIIAAiAkcNAAsMAQsgACECCyAOIAg2AgQgDiACNgIAIAZBIGokAAwBCyABIAJBACANQcyGxAAQozYACyAEKAIIIQAgBCgCDAshASAEQfwAaiICIARBxABqQST8CgAAIAwgAkECIAcgCSAJIAkgBEHoAGpBACAEIAkgACABENEHDAkLIAUoAhQhBgJAIAUoAiAiAEUNACAFKAIYIgkgAE0EQCAAIAlGDQEMBgsgACAGaiwAAEG/f0wNBQsgBCgCJCEJIAcEQCAHIAlqLAAAQb9/TA0CCyAGIAAgCSAHEMEuRQ0FIARBADYCKCAEQfwAaiIAIARBIGpBJPwKAAAgDCAAIAMgCEEBIAUQxgIMCAsgBCAINgKAASAEIAU2AnwCQCAEQfwAahDuEkEjRwRAIAEoAhghAyABKAIUIQYCQCABKAIgQQFqIgJFDQAgAiADTwRAIAIgA0YNAQwGCyACIAZqLAAAQb9/TA0FCyAEQS82AnwgAiAGaiADIAJrIARB/ABqQQEQ9C4NAUEHIQEMCAsgBEH8AGoiAiAAQST8CgAAIAwgAiABIAUgCBCPEAwICyABKAIUIQMCQCABKAIgIgJFDQAgASgCGCIGIAJNBEAgAiAGRg0BDAMLIAIgA2osAABBv39MDQILIAMgAhCPJEH/AXEiAgRAIARB/ABqIgMgAEEk/AoAACAMIAMgBSAIIAIgARDGAgwICyAEQfwAaiICIABBJPwKAAAgDCACIAUgCCABELUBDAcLIAkgC0EAIAdBjIfEABCjNgALIAMgBkEAIAJBlJXEABCjNgALIAYgAyACIANBhJXEABCjNgALIAYgCUEAIABBlJXEABCjNgALAkAgBCgCOCIARQ0AIAQoAjwhBSAEQQA6AEwgBCAINgJIIAQgAzYCRCAEQYQBaiIDQQA2AgAgBEKAgICAEDcCfCAEQfwAaiAEQcQAahC6HCAEQfAAaiADKAIAIgM2AgAgBCAEKQJ8NwNoIAQoAmwgA0Gch8QAQQIQwS4gBEHoAGoQ3jsNACAAQQMgBSgCFBEAAAsgBEH8AGoiACAEQSBqQST8CgAAIAwgACACIAFBASAHEJQCDAILIAIgBUEAIABBlJXEABCjNgALIAxBAjYCACAMIAE6AAQgABDeOwsgBEGgAWokACAKQTBqJAALcgEDfyMAQfAAayICJAAgAkECaiIDIAFBIvwKAAAgAiACQSRqNgJsIAMhAUEAIQMDQCACQSRqIgQgA2ogAS8BADYCACABQQJqIQEgA0EEaiIDQcQARw0ACyACIAE2AmggACAEQcQA/AoAACACQfAAaiQAC4kBAQF/IAACfwJ/AkAgAkEATgRAAkAgAygCBARAIAMoAggiBEUEQCACDQIMBAsgAygCACAEIAEgAhCXNQwECyACRQ0CCyACIAEQrTYMAgsgAEEANgIEQQEMAgsgAQsiA0UEQCAAIAI2AgggACABNgIEQQEMAQsgACACNgIIIAAgAzYCBEEACzYCAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahCdDgsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahCdDgsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqEJ0OCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqEJ0OCyACQSBqJAALlwECAX8BfgJAIAApAwAiAkIGUQ0AAkACQAJAAkBBASACp0ECayACQgFYGw4DAQIDAAsgAEEIahCDKQ8LIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBCGoQ+x4PCyAAEJEqIAAoAkBBgCBBBBD4Og8LIABBCGoQ6TsgAEEgaiAAKAIYIAAoAhwgACgCFCgCEBEBAAsLjQEBAX8jAEEgayICJAAgASgCBARAIAJBEGogAUEIaigCADYCACACQQA6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQ1Q4LIAFBDGoiASgCBARAIAJBEGogAUEIaigCADYCACACQQA6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQ1Q4LIAJBIGokAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBAToAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahDVDgsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBAToAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahDVDgsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEAOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELQOCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEAOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELQOCyACQSBqJAALjQEBAX8jAEEgayICJAAgASgCBARAIAJBEGogAUEIaigCADYCACACQQE6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQtA4LIAFBDGoiASgCBARAIAJBEGogAUEIaigCADYCACACQQE6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQtA4LIAJBIGokAAuOAQEBfyMAQTBrIgIkACACIAE2AgwgAAJ/Qf0HIAF2QQFxRSABQQpPckUEQCAAIAFB8I3PAGotAAA6AARBCAwBCyACQQE2AhQgAkHg+c4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQALNgIAIAJBMGokAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahC5EQsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahC5EQsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELkRCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELkRCyACQSBqJAALpAEBBH8jAEEQayICJAAgASAAKAKgKksEQCACQQhqEP0nIAAoAsgBIQMgACACKAIINgLIASAAKALMASEEIAAgAigCDDYCzAEgAEG+KmoiBSADIAQQ4DUgAiAFIAEQuCkgAigCBCEDIAIoAgAhBCAAKALMASIFBEAgACgCyAEgBUEBEPg6CyAAIAE2AqAqIAAgAzYCzAEgACAENgLIAQsgAkEQaiQAC5cBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQCQCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALQQxBBBCtNiIBRQ0BIAEgAjYCCCABIAU2AgQgASAENgIAIABBKCABQfjg0AAQySkgA0EQaiQADwsgBCADKAIMQaji0AAQ/S8AC0EEQQwQoz0AC5cBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQCQCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALQQxBBBCtNiIBRQ0BIAEgAjYCCCABIAU2AgQgASAENgIAIABBFCABQei8+wAQySkgA0EQaiQADwsgBCADKAIMQay9+wAQ/S8AC0EEQQwQoz0AC40BAQN/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQJBAhDQKCAAKAIIIQILIAAoAgQgAkEBdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANBADsBACADQQJqIQMgBEEBayIEDQALIAEgAmpBAWshAgwBCyABRQ0BCyADQQA7AQAgAkEBaiECCyAAIAI2AggLlwEBA38jAEEQayIEJAAgBEEEaiADQQBBAUEBEKAYIAQoAgghBQJAIAQoAgRBAUcEQCAEKAIMIQYgAwRAIAYgAiAD/AoAAAtBDEEEEK02IgJFDQEgAiADNgIIIAIgBjYCBCACIAU2AgAgACABIAJB6KL+ABDJKSAEQRBqJAAPCyAFIAQoAgxB1KP+ABD9LwALQQRBDBCjPQALlwEBAX8jAEEwayICJAAgACgCACEAIAIgATYCACAAQQxqENk8IAFNBEAgAiAAEP47NgIcIAJBAjYCCCACQfCI/wA2AgQgAkICNwIQIAJBOzYCLCACQTs2AiQgAiACQSBqNgIMIAIgAkEcajYCKCACIAI2AiAgAkEEakGAif8AEO8sAAsgACgCECABQQF0ai8BACACQTBqJAALlwEBAX8jAEEwayICJAAgACgCACEAIAIgATYCACAAQQxqENs8IAFNBEAgAiAAEPw7NgIcIAJBAjYCCCACQfCI/wA2AgQgAkICNwIQIAJBOzYCLCACQTs2AiQgAiACQSBqNgIMIAIgAkEcajYCKCACIAI2AiAgAkEEakGAif8AEO8sAAsgACgCECABQQJ0aigCACACQTBqJAALmQECAX8BfiMAQTBrIgIkACAAKAIAIQAgAiABNgIAIABBDGoQ2DwgAU0EQCACIAAQ/Ts2AhwgAkECNgIIIAJB8Ij/ADYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQYCJ/wAQ7ywACyAAKAIQIAFBA3RqKQMAIAJBMGokAAuiAQECfwJAAkACQAJAQQIgACgCACIBQf////8HaiABQYCAgIB4TRtBAWsOAwABAgMLIAAoAggiAEUNAiAAENEaIABBEEEEEPg6DwsgAUGAgICAeEYNASAAKAIIIgIEQCAAKAIEIQEDQCABENEaIAFBEGohASACQQFrIgINAAsLIABBBEEQEOAeDwsgACgCCCIARQ0AIAAQ0RogAEEQQQQQ+DoLC6IBAQJ/AkACQAJAAkBBAiAAKAIAIgFB/////wdqIAFBgICAgHhNG0EBaw4DAAECAwsgACgCCCIARQ0CIAAQ0hogAEEQQQQQ+DoPCyABQYCAgIB4Rg0BIAAoAggiAgRAIAAoAgQhAQNAIAEQ0RogAUEQaiEBIAJBAWsiAg0ACwsgAEEEQRAQ4B4PCyAAKAIIIgBFDQAgABDSGiAAQRBBBBD4OgsLiQEBA38gACgCACAAKAIIIgJrIAFJBEAgACACIAEQ3yggACgCCCECCyAAKAIEIAJBAnRqIQMCQAJAIAFBAk8EQCABQQFrIQQDQCADQQA2AgAgA0EEaiEDIARBAWsiBA0ACyABIAJqQQFrIQIMAQsgAUUNAQsgA0EANgIAIAJBAWohAgsgACACNgIIC5MBAQN/IwBBIGsiAyQAIANCADcCCCADQQE6ABwgA0EIahCfJyICIAIoAgBBAWoiBDYCAAJAIAQEQCACKAIIDQEgAkF/NgIIIAJBDGoQ4icgAiACQQhqNgIYIAJB2KqIATYCFCACIAE2AhAgAiAANgIMIAJBADYCCBCUDSACEP0eIANBIGokAA8LAAtByKqIARCbPgALyQQCD38BfiMAQSBrIgQkACAEQRRqIAEoAgQgASgCAGtBBHZBAEEEQRAQoBggBCgCGCECIAQoAhRBAUYEQCACIAQoAhxB3N/CABD9LwALIARBEGoiDkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIGJAAgBEEIaiICIAEoAgQgASgCAGtBBHYQ1y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQRBrIgckACAGQQRqIgUoAgQhCCAFKAIAIQ8CQAJAAkAgASgCACICIAEoAgQiA0cEQCAFKAIIIAhBBHRqIQUgAyACa0EEdiEKIAEoAgghCyABKAIMIQwDQAJ/IAsoAgQhCUEAIAsoAggiDSIDRQ0AGiACKQMAIRFBACEBIANBAUcEQANAIAEgA0EBdiIQIAFqIgEgCSABQQR0aikDACARVhshASADIBBrIgNBAUsNAAsLIAEgCSABQQR0aikDACARWGoLQQFrIgEgDU8NAiABIAwoAggiA08NAyAHIAFBBHQiASAMKAIEaiIDIAIpAwAgASAJaikDACIRfacgAygCCCIBIAJBCGopAwAgEX2nIgMgASADSRsQ0hAgBUEIaiAHQQhqKQIANwIAIAUgBykCADcCACACQRBqIQIgBUEQaiEFIAhBAWohCCAKQQFrIgoNAAsLIA8gCDYCACAHQRBqJAAMAgsgASANQYygwwAQwyEACyABIANBnKDDABDDIQALIAZBEGokACAAQQhqIA4oAgA2AgAgACAEKQIINwIAIARBIGokAAuMAQEBfwJAAkACQCAALQAgDgQBAgIAAgsgACgCHCIBIAEoAgBBAWsiATYCACABRQRAIABBHGoQshoLIAAoAhgiAUGEAU8EQCABEPIfCwsgACgCFCIBQYMBSwRAIAEQ8h8LIAAoAhAiAUEIahCVHyABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDHIQsLkwEBAX8CQAJAAkACQAJAAkAgAC0AIA4FAAUFAQIFCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEJ0nCyAAEN47IABBDGoQ3jsMAwsgAEEoahCqHgwBCyAAQShqENItCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEJ0nCyAAQRxqEK8sCwuTAQEBfwJAAkACQAJAAkACQCAALQAgDgUABQUBAgULIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQnScLIAAQ3jsgAEEMahDeOwwDCyAAQShqEMghDAELIABBKGoQ1S0LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQnScLIABBHGoQrywLC4YBAQJ/An8gACgCSCICQRFNBEAgAEHIAGohAyAAQQRqDAELIABBBGohAyAAKAIEIQIgACgCCAshACABIAJJBEAgAyACQQFrNgIAIAAgAUECdGoiACgCABogAiABQX9zakECdCIBBEAgACAAQQRqIAH8CgAACw8LQfyvzABBHUGcsMwAEJ8pAAucAgEFfyMAQTBrIgIkACACQRhqIgUgABCHIyACQQRqIQQgAigCGCEDIwBBIGsiACQAAkACQAJAIAMoAgggAU0EQCAEQYCAgIB4NgIADAELIAMoAgQgAUEUbGoiASgCDCIDIAMoAgAiBkEBajYCACAGQQBIDQEgAEEMaiABELwVIABBHGogASgCECIBNgIAIAQgACkCDDcCACAEQRBqIAE2AgAgACADNgIYIARBCGogAEEUaikCADcCAAsgAEEgaiQADAELAAsgBRCAKyACKAIEQYCAgIB4RwR/IAJBLGogAkEUaigCADYCACACQSRqIAJBDGopAgA3AgAgAiACKQIENwIcIAJBADYCGCAFEJ8nQQhqBUEACyACQTBqJAALkAEBAX8jAEEgayIFJAACQCADIARxIgMgAk0EQCABIANqIAIgA2sQtx4gBEEDdkEBcWoiASAAKAIEIgJJDQEgASACQbTNzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakGkzc4AEO8sAAsgACgCACABQQJ0aiAENgIAIAVBIGokAAuQAQEBfyMAQSBrIgUkAAJAIAMgBHEiAyACTQRAIAEgA2ogAiADaxCWGiAEQQN2QQNxaiIBIAAoAgQiAkkNASABIAJBtM3OABDDIQALIAVBADYCGCAFQQE2AgwgBUGY184ANgIIIAVCBDcCECAFQQhqQaTNzgAQ7ywACyAAKAIAIAFBAnRqIAQ2AgAgBUEgaiQAC5ABAQF/IwBBIGsiBSQAAkAgAyAEcSIDIAJNBEAgASADaiACIANrELYeIARBA3ZBA3FqIgEgACgCBCICSQ0BIAEgAkG0zc4AEMMhAAsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpBpM3OABDvLAALIAAoAgAgAUECdGogBDYCACAFQSBqJAAL8QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQcTSzAAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgASkDADcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL8QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQcTSzAAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASgCADYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAALlQMCB38BfiMAQSBrIgMkACADQRRqIAEoAgwgASgCBGtBA3ZBAEEIQRAQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxByJbPABD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAI2AggjAEEgayICJAAgA0EIaiIEIAEoAgwgASgCBGtBA3YQ6S0gBCkCBCEJIAJBCGogAUEIaikCADcDACACIAEpAgA3AwAgAiAJQiCJNwIYIAIgBEEIajYCFCACQRRqIQECQCACKAIEIgUgAigCDCIIRgRAIAEoAgQhBAwBCyABKAIIIAEoAgQiBEEEdGohBgNAIAUpAwAhCSACIAVBCGoiBTYCBCAGQQhqIAk3AwAgBkIBNwMAIAZBEGohBiAEQQFqIQQgBSAIRw0ACyABIAQ2AgQLIAEoAgAgBDYCACMAQRBrIgEkACABIAIoAgA2AgwgASACKAIINgIIIAFBCGoQ4zwgAUEQaiQAIAJBIGokACAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuaAQECfyMAQTBrIgIkAAJ/IAFFBEAgAkEANgIoIAJCgICAgMAANwIgIAIgAkEgakGMh84AEJ0hIAIoAgAhASACKAIEDAELIAJBKGpCADcDACACQgA3AyAgAkEUaiIDIAJBIGogARCDHCACQQhqIANBzILOABCdISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBMGokAAvOAgEEfyMAQSBrIgEkACMAQRBrIgMkACADQQhqIwBBIGsiAiQAIAJBDGpBoLTCAEGgtMIAELgqEJ0JIAIoAgxBAUYEQCACIAIpAhA3AxhB2PDQAEEbIAJBGGpBrO/QAEH08NAAENUeAAsgAikCEDcDACACQSBqJAAgAygCDCECIAFBCGoiBCADKAIINgIAIAQgAjYCBCADQRBqJAAgASgCCCEFIAFBFGogASgCDCICQQBBAUEBEKAYIAEoAhghAyABKAIUQQFHBEAgASgCHCEEIAIEQCAEIAUgAvwKAAALIAEgAjYCHCABIAQ2AhggASADNgIUQQxBBBCtNiICRQRAQQRBDBCjPQALIAIgAUEUaiIDKQIANwIAIAJBCGogA0EIaigCADYCACAAQSggAkHw7tAAEMkpIAFBIGokAA8LIAMgASgCHEGc79AAEP0vAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQN2IgUQ7C0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQN0aiEDA0AgAyABKQMAQugHfjcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL+AEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAEKAlOvcA343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC4EDAgh/An4jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIghBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiBSQAIAJBCGoiAyABKAIEIAEoAgBrQQN2EOwtIAUgAykCBEIgiTcCCCAFIANBCGo2AgQgBUEEaiIEKAIEIQYgBCgCACEJAkACQAJAIAEoAgAiByABKAIEIgNHBEAgASgCCCEBIAQoAgggBkEDdGohBCADIAdrQQN2IQMDQCABKAIAKQMAIgpQDQIgBykDACILQoCAgICAgICAgH9RIApCf1FxDQMgBCALIAp/NwMAIAdBCGohByAEQQhqIQQgBkEBaiEGIANBAWsiAw0ACwsgCSAGNgIADAILQfyzgAEQ4isAC0H8s4ABEOYrAAsgBUEQaiQAIABBCGogCCgCADYCACAAIAIpAgg3AgAgAkEgaiQAC/UBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAEpAwBC6Ad/NwMAIAFBCGohASADQQhqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv2AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQN2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKQMAQsCEPX8+AgAgAUEIaiEBIANBBGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCwIQ9fjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9wEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAEKAuJkpfjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9gEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgASkDAELAhD1+NwMAIAFBCGohASADQQhqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv5AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7C0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQN0aiEDA0AgAyABNAIAQoDA3e7BAn43AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC4EDAgh/An4jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIghBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiBSQAIAJBCGoiAyABKAIEIAEoAgBrQQN2EOwtIAUgAykCBEIgiTcCCCAFIANBCGo2AgQgBUEEaiIEKAIEIQYgBCgCACEJAkACQAJAIAEoAgAiByABKAIEIgNHBEAgASgCCCEBIAQoAgggBkEDdGohBCADIAdrQQN2IQMDQCABKAIAKQMAIgpQDQIgBykDACILQoCAgICAgICAgH9RIApCf1FxDQMgBCALIAp/NwMAIAdBCGohByAEQQhqIQQgBkEBaiEGIANBAWsiAw0ACwsgCSAGNgIADAILQYy0gAEQ4isAC0GMtIABEOYrAAsgBUEQaiQAIABBCGogCCgCADYCACAAIAIpAgg3AgAgAkEgaiQAC/oBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCgIC8isnSE343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/gBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDuLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBAnRqIQMDQCADIAEpAwBCgJTr3AN/PgIAIAFBCGohASADQQRqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKAIAQegHbDYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASkDAELoB38+AgAgAUEIaiEBIANBBGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCgKMFfjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAELoB343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAEpAwBCwIQ9fzcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL3gEBB38jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIGayIHQQJ2IggQ7C0gAygCCCEBIAMgBCAGRwR/IAdBAXQiBARAIAMoAgQgAUEDdGpBACAE/AsACyABIAhqBSABCzYCCCAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKAIAQegHbTYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9wEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASkDAEKAuJkpfz4CACABQQhqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAALygQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiICIAEoAgQgASgCAGtBA3YQ7C0gAikCBCEPIARBGGogAUEQaikCADcDACAEQRBqIAFBCGopAgA3AwAgBCABKQIANwMIIAQgD0IgiTcCKCAEIAJBCGo2AiQjAEEwayIBJAAgBEEkaiIFKAIEIQcgBSgCACEMAkACQAJAIARBCGoiAigCACIGIAIoAgQiCEcEQCACKAIUIQkgAigCECENIAIoAgwhDiACKAIIIQIgBSgCCCAHQQN0aiEFIAggBmtBA3YhCANAIAEgBjYCDAJAIAYoAgAiCiANSQRAIA4gCkEDdGopAwAhDwwBCyACIAkoAhBPDQNCACEPIAkoAgQgAiAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAFIA83AwAgBkEIaiEGIAVBCGohBSACQQFqIQIgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAFBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAFBATYCFCABQdy2ggE2AhAgAUIBNwIcIAFBuhM2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQeS2ggEQ7ywACyAEQTBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAALygQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiICIAEoAgQgASgCAGtBA3YQ7C0gAikCBCEPIARBGGogAUEQaikCADcDACAEQRBqIAFBCGopAgA3AwAgBCABKQIANwMIIAQgD0IgiTcCKCAEIAJBCGo2AiQjAEEwayIBJAAgBEEkaiIFKAIEIQcgBSgCACEMAkACQAJAIARBCGoiAigCACIGIAIoAgQiCEcEQCACKAIUIQkgAigCECENIAIoAgwhDiACKAIIIQIgBSgCCCAHQQN0aiEFIAggBmtBA3YhCANAIAEgBjYCDAJAIAYoAgAiCiANSQRAIA4gCkEDdGopAwAhDwwBCyACIAkoAhBPDQNCACEPIAkoAgQgAiAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAFIA83AwAgBkEIaiEGIAVBCGohBSACQQFqIQIgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAFBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAFBATYCFCABQdy2ggE2AhAgAUIBNwIcIAFByBA2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQeS2ggEQ7ywACyAEQTBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyjwQ9y8gBEEcaiABIAIoAgAQyjwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyTwQ9y8gBEEcaiABIAIoAgAQyTwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOwtIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQN0aisDADkDACAGQQhqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQhS4gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQ3RkgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEGggoMBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhDsLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEDdGohASAHIAZrQQJ2IQUDQCAGKAIAIgcgCE8NAiABIAsgB0EDdGopAwA3AwAgBkEEaiEGIAFBCGohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQby0ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAALgAMCCn8BfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQ6S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgYoAgQhBCAGKAIAIQoCQAJAIAEoAgAiByABKAIEIgVHBEAgASgCDCEIIAEoAgghCyAGKAIIIARBBHRqIQEgBSAHa0EDdiEGA0AgCCAHKAIAIgVNDQIgCyAFQQR0aiIFKQMAIQwgAUEIaiAFQQhqKQMANwMAIAEgDDcDACAHQQhqIQcgAUEQaiEBIARBAWohBCAGQQFrIgYNAAsLIAogBDYCAAwBCyAFIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvLBgIRfwJ+IwBBIGsiBCQAIARBFGogASgCBCABKAIAa0EDdkEAQRBBEBCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHIy4MBEP0vAAsgBEEQaiIQQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCMAQTBrIgMkACABKAIEIAEoAgBrQQN2IgggBEEIaiIFKAIAIAUoAggiBmtLBEAgBSAGIAhBEEEQEN4oIAUoAgghBgsgBSgCBCEIIANBGGogAUEQaikCADcDACADQRBqIAFBCGopAgA3AwAgAyABKQIANwMIIAMgCDYCLCADIAY2AiggAyAFQQhqNgIkIANBJGoiCigCBCEIIAooAgAhEQJAAkACQAJAAkACQAJAIANBCGoiASgCACIFIAEoAgQiB0cEQCABKAIUIQYgASgCECEMIAEoAgwhDSABKAIIIQ4gCigCCCAIQQR0aiEKIAcgBWtBA3YhDwNAIAUoAgAiASAOKAIIIgdPDQIgAUECdCIJIA4oAgRqKAIAIgcoAhwiAkUNAyAFQQRqKAIAIgsgBygCIEEEdk8NAyACIAtBBHRqIgIpAwghEyACKQMAIhSnQQ1PBEAgASANKAIIIgJPDQUgE6ciASANKAIEIAlqKAIAaiIJIAwoAggiAk8NBgJAIAwoAgQgCUEDdGoiCSgCAEEBRgRAIAkoAgQhAQwBCyAHKAIIIgIgAU0NCSAHKAIEIAFBDGxqIgEoAgAiByAHKAIAIgJBAWo2AgAgAkEASA0IIAEoAgghCyABKAIEIRIgBigCCCIBIAYoAgBGBEAgBkGktoIBEJAoCyAGKAIEIAFBDGxqIgIgCzYCCCACIBI2AgQgAiAHNgIAIAkgATYCBCAJQQE2AgAgBiABQQFqNgIICyABrSATQoCAgIBwg4QhEwsgCiAUNwMAIAogEzcDCCAFQQhqIQUgCkEQaiEKIAhBAWohCCAPQQFrIg8NAAsLIBEgCDYCAAwGCyABIAdB1LWCARDDIQALQeS1ggEQsjsACyABIAJB9LWCARDDIQALIAkgAkGEtoIBEMMhCwALIAEgAkGUtoIBEMMhAAsgA0EwaiQAIABBCGogECgCADYCACAAIAQpAgg3AgAgBEEgaiQAC4EEAQt/IwBBIGsiAyQAIANBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCADKAIYIQIgAygCFEEBRgRAIAIgAygCHEHIy4MBEP0vAAsgA0EQaiILQQA2AgAgAyADKAIcNgIMIAMgAjYCCCMAQRBrIgYkACADQQhqIgIgASgCBCABKAIAa0EDdhDsLSAGIAIpAgRCIIk3AgggBiACQQhqNgIEIwBBMGsiAiQAIAZBBGoiBCgCBCEHIAQoAgAhDAJAAkACQCABKAIAIgUgASgCBCIIRwRAIAQoAgggB0EDdGohBCAIIAVrQQN2IQggASgCCCEKA0AgBSgCACIBIAooAggiCU8NAiAKKAIEIAFBAnRqKAIAIQEgAiAFQQRqKAIAIgk2AgAgAUEMahDYPCAJTQ0DIAQgASgCECAJQQN0aikDADcDACAFQQhqIQUgBEEIaiEEIAdBAWohByAIQQFrIggNAAsLIAwgBzYCACACQTBqJAAMAgsgASAJQfy0ggEQwyEACyACIAEQ/Ts2AhwgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywACyAGQRBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQJ2EOwtIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBAnYhBQNAIAYoAgAiByAITw0CIAEgCyAHQQN0aikDADcDACAGQQRqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQ7C0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBA3RqIQEgByAGa0EDdiEFA0AgCCAGKAIAIgdNDQIgASALIAdBA3RqKQMANwMAIAZBCGohBiABQQhqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDuLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahDcGSADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALqAMBCn8jAEEgayIEJAAgBEEUaiABKAIEIAEoAgBrQQJ2QQBBBEEIEKAYIAQoAhghAyAEKAIUQQFGBEAgAyAEKAIcIAIQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCADNgIIIwBBEGsiAiQAIAEoAgQgASgCAGtBAnYiByAEQQhqIgMoAgAgAygCCCIFa0sEQCADIAUgB0EEQQgQ3iggAygCCCEFCyACIAMoAgQ2AgwgAiAFNgIIIAIgA0EIajYCBCACQQRqIgcoAgQhAyAHKAIAIAEoAgAiBSABKAIEIgZHBEAgASgCCCELIAcoAgggA0EDdGohASADIAYgBWtBAnYiB2ohAwNAIAsoAgAiBiAFKAIAIggoAggiDE8EQCAGIAxBsPeFARDDIQALIAgoAgQgBkEDdGoiBigCACEIIAFBBGogBigCBCIGNgIAIAEgCCAGKAIIQQFrQXhxakEIajYCACAFQQRqIQUgAUEIaiEBIAdBAWsiBw0ACwsgAzYCACACQRBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAALmAMCCn8CfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEQQSAQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBA3YQ7y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyADKAIIIAVBBXRqIQEgByAGa0EDdiEHA0AgCCAGKAIAIgNNDQIgCyADQQV0aiIDKQMAIQwgAUEQaiADKQMQNwMAIAMpAwghDSABQRhqIAMpAxg3AwAgASAMNwMAIAEgDTcDCCAGQQhqIQYgAUEgaiEBIAVBAWohBSAHQQFrIgcNAAsLIAogBTYCAAwBCyADIAhB9LaCARDDIQALIARBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAuXBAINfwF+IwBBIGsiAyQAIANBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCADKAIYIQIgAygCFEEBRgRAIAIgAygCHEG8/IEBEP0vAAsgA0EQaiILQQA2AgAgAyADKAIcNgIMIAMgAjYCCCMAQRBrIgYkACADQQhqIgIgASgCBCABKAIAa0ECdhDsLSAGIAIpAgRCIIk3AgggBiACQQhqNgIEIwBBMGsiAiQAIAZBBGoiBCgCBCEHIAQoAgAhDAJAAkACQCABKAIAIgUgASgCBCIIRwRAIAEoAhQhCSABKAIQIQ0gASgCDCEOIAEoAgghASAEKAIIIAdBA3RqIQQgCCAFa0ECdiEIA0AgAiAFNgIMAkAgDSAFKAIAIgpLBEAgDiAKQQN0aikDACEPDAELIAEgCSgCEE8NA0IAIQ8gCSgCBCABIAkoAgxqIgpBA3ZqLQAAIApBB3F2QQFxDQQLIAQgDzcDACAFQQRqIQUgBEEIaiEEIAFBAWohASAHQQFqIQcgCEEBayIIDQALCyAMIAc2AgAgAkEwaiQADAILQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG7EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALIAZBEGokACAAQQhqIAsoAgA2AgAgACADKQIINwIAIANBIGokAAuYAwIKfwJ+IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQRBBIBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgASgCBCABKAIAa0ECdhDvLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiAygCBCEFIAMoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAMoAgggBUEFdGohASAHIAZrQQJ2IQcDQCAGKAIAIgMgCE8NAiALIANBBXRqIgMpAwAhDCABQRBqIAMpAxA3AwAgAykDCCENIAFBGGogAykDGDcDACABIAw3AwAgASANNwMIIAZBBGohBiABQSBqIQEgBUEBaiEFIAdBAWsiBw0ACwsgCiAFNgIADAELIAMgCEH0toIBEMMhAAsgBEEQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHIy4MBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDuLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahD1ESADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALzwEBBH8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOstIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgASADQQRqEJAZIANBEGokACAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEECQQIQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBAXRqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBAXRqLwEAOwEAIAZBBGohBiABQQJqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQJBAhCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDtLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEBdGohASAHIAZrQQN2IQUDQCAIIAYoAgAiB00NAiABIAsgB0EBdGovAQA7AQAgBkEIaiEGIAFBAmohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQfS2ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAALlwQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAI2AggjAEEQayIGJAAgA0EIaiICIAEoAgQgASgCAGtBAnYQ7C0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQTBrIgIkACAGQQRqIgQoAgQhByAEKAIAIQwCQAJAAkAgASgCACIFIAEoAgQiCEcEQCABKAIUIQkgASgCECENIAEoAgwhDiABKAIIIQEgBCgCCCAHQQN0aiEEIAggBWtBAnYhCANAIAIgBTYCDAJAIA0gBSgCACIKSwRAIA4gCkEDdGopAwAhDwwBCyABIAkoAhBPDQNCACEPIAkoAgQgASAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAEIA83AwAgBUEEaiEFIARBCGohBCABQQFqIQEgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAJBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyAGQRBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EO4tIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQJ0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQJ0aioCADgCACAGQQhqIQYgAUEEaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7i0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBAnRqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBAnRqKgIAOAIAIAZBBGohBiABQQRqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQRBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhDqLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEDdGohASAHIAZrQQJ2IQUDQCAGKAIAIgcgCE8NAiABIAsgB0EDdGopAgA3AgAgBkEEaiEGIAFBCGohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQfS2ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgZBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAEoAgQgASgCAGtBAnYiByACQQhqIgQoAgAgBCgCCCIFa0sEQCAEIAUgB0EQQRAQ3iggBCgCCCEFCyADIAQoAgQ2AgwgAyAFNgIIIAMgBEEIajYCBCABIANBBGoQjxkgA0EQaiQAIABBCGogBigCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC7GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALgAMCCn8BfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ6S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgYoAgQhBCAGKAIAIQoCQAJAIAEoAgAiByABKAIEIgVHBEAgASgCDCEIIAEoAgghCyAGKAIIIARBBHRqIQEgBSAHa0ECdiEGA0AgBygCACIFIAhPDQIgCyAFQQR0aiIFKQMAIQwgAUEIaiAFQQhqKQMANwMAIAEgDDcDACAHQQRqIQcgAUEQaiEBIARBAWohBCAGQQFrIgYNAAsLIAogBDYCAAwBCyAFIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7C0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBA3RqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBA3RqKwMAOQMAIAZBBGohBiABQQhqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhCBLiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC6GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOotIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQN0aikCADcCACAGQQhqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEQQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBkEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgASgCBCABKAIAa0EDdiIHIAJBCGoiBCgCACAEKAIIIgVrSwRAIAQgBSAHQRBBEBDeKCAEKAIIIQULIAMgBCgCBDYCDCADIAU2AgggAyAEQQhqNgIEIAEgA0EEahCQGSADQRBqJAAgAEEIaiAGKAIANgIAIAAgAikCCDcCACACQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyzwQ9y8gBEEcaiABIAIoAgAQyzwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAALzwEBBH8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQJ2EOstIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgASADQQRqEI8ZIANBEGokACAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAubBQESfyMAQSBrIgUkACAFQRRqIAEoAgQgASgCAGtBAnZBAEEEQRQQoBggBSgCGCECIAUoAhRBAUYEQCACIAUoAhxByMuDARD9LwALIAVBEGoiDkEANgIAIAUgBSgCHDYCDCAFIAI2AggjAEEgayIDJAAgASgCBCABKAIAa0ECdiIHIAVBCGoiAigCACACKAIIIgZrSwRAIAIgBiAHQQRBFBDeKCACKAIIIQYLIAIoAgQhByADQRBqIAFBEGooAgA2AgAgA0EIaiABQQhqKQIANwMAIAMgASkCADcDACADIAc2AhwgAyAGNgIYIAMgAkEIajYCFCMAQTBrIgQkACADQRRqIgEoAgQhCCABKAIAIQ8CQAJAIAMoAgAiDCADKAIEIgJHBEAgASgCCCEQIAMoAgwhBiADKAIIIQogAygCECIRQQN0QQhrIQcgAiAMa0ECdiESA0AgBEEIaiIBIAwgC0ECdGoiAigCACgCIBD3LyAEQRxqIAEgAigCACgCIBC3GSAHIQIgBiEBAkAgEUUNAANAIAEoAgAgCkYEQCABQQRqKAIAIQ0gBCAEQRxqEIY9IA1BA3YiCSAEKAIEIhNPDQUgBCgCACAJaiIJIAktAABBASANQQdxdHI6AAALIAJFDQEgAUEIaiEBIAJBCGshAgwACwALIARBCGogBEEcaiIBEIQUIAEQzy8gECAIQRRsaiIBIAQpAgg3AgAgAUEQaiAEQRhqKAIANgIAIAFBCGogBEEQaikCADcCACAKQQFqIQogCEEBaiEIIAtBAWoiCyASRw0ACwsgDyAINgIAIARBMGokAAwBCyAJIBNB/LGCARDDIQALIANBIGokACAAQQhqIA4oAgA2AgAgACAFKQIINwIAIAVBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQgS4gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQuxsgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhCFLiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahDcGSADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALgQQBC38jAEEgayIDJAAgA0EUaiABKAIEIAEoAgBrQQN2QQBBAkECEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQcjLgwEQ/S8ACyADQRBqIgtBADYCACADIAMoAhw2AgwgAyACNgIIIwBBEGsiBiQAIANBCGoiAiABKAIEIAEoAgBrQQN2EO0tIAYgAikCBEIgiTcCCCAGIAJBCGo2AgQjAEEwayICJAAgBkEEaiIEKAIEIQcgBCgCACEMAkACQAJAIAEoAgAiBSABKAIEIghHBEAgBCgCCCAHQQF0aiEEIAggBWtBA3YhCCABKAIIIQoDQCAFKAIAIgEgCigCCCIJTw0CIAooAgQgAUECdGooAgAhASACIAVBBGooAgAiCTYCACABQQxqENk8IAlNDQMgBCABKAIQIAlBAXRqLwEAOwEAIAVBCGohBSAEQQJqIQQgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAJBMGokAAwCCyABIAlB/LSCARDDIQALIAIgARD+OzYCHCACQQI2AgggAkGosYIBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBuLGCARDvLAALIAZBEGokACAAQQhqIAsoAgA2AgAgACADKQIINwIAIANBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7i0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQ3RkgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC6GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALoQMBCn8jAEEgayIEJAAgBEEUaiABKAIEIAEoAgBrQQN2QQBBBEEIEKAYIAQoAhghAyAEKAIUQQFGBEAgAyAEKAIcIAIQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCADNgIIIwBBEGsiAiQAIAEoAgQgASgCAGtBA3YiBiAEQQhqIgMoAgAgAygCCCIFa0sEQCADIAUgBkEEQQgQ3iggAygCCCEFCyACIAMoAgQ2AgwgAiAFNgIIIAIgA0EIajYCBCMAQRBrIgYkACACQQRqIgcoAgQhBSAHKAIAIAEoAgAiAyABKAIEIghHBEAgASgCDCELIAEoAgghDCAHKAIIIAVBA3RqIQEgBSAIIANrQQN2IgdqIQUDQCAGQQhqIAMoAgAgA0EEaigCACIIKAIIQQFrQXhxakEIaiAMKAIAIAsoAgAgCCgCIBEFACABIAYpAwg3AgAgA0EIaiEDIAFBCGohASAHQQFrIgcNAAsLIAU2AgAgBkEQaiQAIAJBEGokACAAQQhqIAkoAgA2AgAgACAEKQIINwIAIARBIGokAAuaAQECfyMAQTBrIgMkACADIAI2AgAgASgCMCIEIAJNBEAgAyAENgIcIANBAjYCCCADQfSfhgE2AgQgA0ICNwIQIANBOzYCLCADQTs2AiQgAyADQSBqNgIMIAMgA0EcajYCKCADIAM2AiAgA0EEakGEoIYBEO8sAAsgACABKAI0IgQ2AgQgACABKAIQIAIgBGxqNgIAIANBMGokAAubAQAgAEEANgIwIABBADYCACAAIAEpAhg3AiAgACABKQIMNwIUIAAgASkCLDcCPCAAIAEoAig2AlQgAEEcaiABQRRqKAIANgIAIABBxABqIAFBNGopAgA3AgAgAEHMAGogAUE8aikCADcCACAAQShqIAFBIGopAgA3AgAgAEEAOwFYIABBEGogAUEIaigCADYCACAAIAEpAgA3AggLjAEBAX8gAUEATgRAAn8CQCACKAIEBEAgAigCCCIDRQRAIAENAkEBDAMLIAIoAgAgA0EBIAEQlzUMAgsgAQ0AQQEMAQsgAUEBEK02CyICRQRAIAAgATYCCCAAQQE2AgQgAEEBNgIADwsgACABNgIIIAAgAjYCBCAAQQA2AgAPCyAAQQA2AgQgAEEBNgIAC44BAQR/IwBBEGsiAiQAAn9BASABKAIAIgNBJyABKAIEIgUoAhAiARECAA0AGiACIAAoAgBBgQIQjwkCQCACLQANIgBBgQFPBEAgAyACKAIAIAERAgBFDQFBAQwCCyADIAIgAi0ADCIEaiAAIARrIAUoAgwRBgBFDQBBAQwBCyADQScgARECAAsgAkEQaiQAC8YVAiZ/Dn4jAEEgayINJAAgDUEUaiACIAFrQQZ2QQBBCEHQABCgGCANKAIYIQMgDSgCFEEBRgRAIAMgDSgCHEGUvMMAEP0vAAsgDUEQaiIhQQA2AgAgDSANKAIcNgIMIA0gAzYCCCMAQRBrIhQkACACIAFrQQZ2IgwgDUEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAxBCEHQABDQKCADKAIIIQQLIBQgAygCBDYCDCAUIAQ2AgggFCADQQhqNgIEIwBB0ABrIgwkACAUQQRqIgMoAgQhFiADKAIAIAEgAkcEQCADKAIIIBZB0ABsaiEbIBYgAiABa0EGdiICaiEWA0BCACEqIAEoAiQiFyABKAIoIhxBwAJsaiEEIwBBIGsiDiQAIA5BFGogBCAXa0HAAm5BAEEIQegDEKAYIA4oAhghAyAOKAIUQQFGBEAgAyAOKAIcQbjmzwAQ/S8ACyAOQRBqIiNBADYCACAOIA4oAhw2AgwgDiADNgIIIwBBEGsiFSQAIAQgF2tBwAJuIgogDkEIaiIDKAIAIAMoAggiBWtLBEAgAyAFIApBCEHoAxDQKCADKAIIIQULIBUgAygCBDYCDCAVIAU2AgggFSADQQhqNgIEIwBB8ANrIh8kACAVQQRqIgUoAgQhGCAFKAIAIAQgFyIDRwRAIAUoAgggGEHoA2xqIR0gGCAEIANrQcACbiIgaiEYA0BBACEZQQAhHiMAQZADayIGJABCACEpIwBBkAFrIgckACADKAKkAiEEAn4CQAJAAkAgAygCUEUEQCAEQYCAgIB4Rw0BIAMoArACQYCAgIB4Rw0CQgIMBAsgBEGAgICAeEYNAQsgByADQaQCahClHQwBCyAHQYCAgIB4NgIACwJAIAMoArACQYCAgIB4RwRAIAdBEGogA0GwAmoQpR0MAQsgB0GAgICAeDYCEAsgAykDWCEpIAMpA1ALISsgAygCvAJBCGoQ3SUhESADKAKEAiIFIAMoAogCaiEEIwBBIGsiCiQAIApBFGogBCAFa0EAQQRBBBCgGCAKKAIYIQ8gCigCFEEBRgRAIA8gCigCHEG45s8AEP0vAAsgCkEQaiITQQA2AgAgCiAKKAIcNgIMIAogDzYCCCMAQRBrIg8kACAEIAVrIgsgCkEIaiIIKAIAIAgoAggiCWtLBEAgCCAJIAtBBEEEENAoIAgoAgghCQsgH0EIaiELIAdBHGohEiAPIAgoAgQ2AgwgDyAJNgIIIA8gCEEIajYCBCAPQQRqIhAoAgQhCCAQKAIAIAQgBUcEfyAEIAVrIQkgBCAIaiAFayAQKAIIIAhBAnRqIQQDQCAEIAUtAABBAnRBtOzQAGooAgA2AgAgBUEBaiEFIARBBGohBCAJQQFrIgkNAAsFIAgLNgIAIA9BEGokACASQQhqIBMoAgA2AgAgEiAKKQIINwIAIApBIGokACADKAK8AiIEKAIMIQggB0EoaiAEKAIQIhpBAEEEQQwQoBggBygCLCEKAkAgBygCKEEBRwRAIAcoAjAhDwJAIApFDQAgGkEMbCEJIA8hBCAKIQUDQCAJRQ0BIAdBKGogCBDdICAEQQhqIAdBMGooAgA2AgAgBCAHKQIoNwIAIARBDGohBCAJQQxrIQkgCEEMaiEIIAVBAWsiBQ0ACwsgEUH/AXEhJSADKQMYISwgAykDECEtIAMpAwghLiADKQMAIS8gAykD+AEhMCADKQPoASExIAMpA/ABITIgAykD4AEhMyADKALQASEmIAdBKGogA0HgAGpBACADKQNgQghSGxC3CAJAIAMoApgCQYCAgIB4RwRAIAMoApwCIgQgAygCoAJBA3RqIRAjAEEgayIIJAAgCEEUaiAQIARrQQN2QQBBBEEMEKAYIAgoAhghBSAIKAIUQQFGBEAgBSAIKAIcQbjmzwAQ/S8ACyAIQRBqIidBADYCACAIIAgoAhw2AgwgCCAFNgIIIwBBEGsiEiQAIBAgBGtBA3YiESAIQQhqIgUoAgAgBSgCCCIJa0sEQCAFIAkgEUEEQQwQ0CggBSgCCCEJCyASIAUoAgQ2AgwgEiAJNgIIIBIgBUEIajYCBCMAQRBrIhEkACASQQRqIgUoAgQhEyAFKAIAIAQgEEcEQCAFKAIIIBNBDGxqIQkgEyAQIARrQQN2IgVqIRMDQCARQQRqIhAgBCgCADYCCCAQIAQtAAU2AgAgECAELQAEQQJ0QbTs0ABqKAIANgIEIAlBCGogEUEMaigCADYCACAJIBEpAgQ3AgAgCUEMaiEJIARBCGohBCAFQQFrIgUNAAsLIBM2AgAgEUEQaiQAIBJBEGokACAHQYQBaiIEQQhqICcoAgA2AgAgBCAIKQIINwIAIAhBIGokAAwBCyAHQYCAgIB4NgKEAQsgBiAHKQMANwOYASAGIAcpAhA3AqQBIAYgJTYC+AIgBiAHKQIcNwLIAiAGIAo2AtQCIAYgDzYC2AIgBiAaNgLcAiAGICY2AvwCIAZBoAFqIAdBCGooAgA2AgAgBkGsAWogB0EYaigCADYCACAGQdACaiAHQSRqKAIANgIAIAMpAyAhNCADKQMoITUgAykDuAEhNiAGQYCAgIB4NgLgAiAGIDE3A7gCIAYgMjcDsAIgBiAzNwOoAiAGIDA3A8ACIAYgLDcDGCAGIC03AxAgBiAuNwMIIAYgLzcDACAGQTBqIAdBKGpB2AD8CgAAIAYgNjcDoAIgBiA1NwMoIAYgNDcDICAGQgM3A7ABIAYgKTcDkAEgBiArNwOIASAGQfQCaiAHQYwBaigCADYCACAGIAcpAoQBNwLsAiAHQZABaiQADAELIAogBygCMEHA6M8AEP0vAAtBgICAgHghBAJAAkACQCADKAKMAkGAgICAeEYNACADKAKQAiEFIAZBhANqIAMoApQCIhlBAEEBQQEQoBggBigCiAMhBCAGKAKEA0EBRg0BIAYoAowDIR4gGUUNACAeIAUgGfwKAAALIAMpA9gBISkgC0EgaiAGQYAD/AoAACALIBk2AtgDIAsgHjYC1AMgCyAENgLQAyALICk3A8gDIAtBgICAgHg2AtwDIAtBgYCAgHg2ArADIAsgAykDwAE3A6ADIAsgAykDODcDCCALIAMpAzA3AwAgCyADKQPIATcDqAMgCyADKQNINwMYIAsgAykDQDcDECAGQZADaiQADAELIAQgBigCjANBsOjPABD9LwALIB0gC0HoA/wKAAAgHUHoA2ohHSADQcACaiEDICBBAWsiIA0ACwsgGDYCACAfQfADaiQAIBVBEGokACAMQTBqIgNBCGogIygCADYCACADIA4pAgg3AgAgDkEgaiQAIAxBPGohAyABKQMQISkgASkDGCErAkAgASgCLEGAgICAeEcEQCADIAFBLGoQkxgMAQsgA0GAgICAeDYCAAsgASkDCCEsIAEpAwAhLSAcBEAgF0HoAWohAwNAIAMpAwAgKnwhKiADQcACaiEDIBxBAWsiHA0ACwsgDCApNwMoIAwgKzcDICAMICo3AxggDEIBNwMQIAwgLDcDCCAMIC03AwAgDCABKAI4NgJIIBsgDEHQAPwKAAAgG0HQAGohGyABQUBrIQEgAkEBayICDQALCyAWNgIAIAxB0ABqJAAgFEEQaiQAIABBCGogISgCADYCACAAIA0pAgg3AgAgDUEgaiQAC+MHAg1/AX4jAEEgayIFJAAgBUEUaiACIAFrQQJ2QQBBBEEEEKAYIAUoAhghAyAFKAIUQQFGBEAgAyAFKAIcQZDQwwAQ/S8ACyAFQRBqIgxBADYCACAFIAUoAhw2AgwgBSADNgIIIwBBEGsiCCQAIAVBCGoiAyACIAFrQQJ2IgsQgC4gCCADKQIEQiCJNwIIIAggA0EIajYCBCMAQbABayIDJAAgCEEEaiIHKAIEIQkgBygCACENAkACQAJAAkACQCABIAJHBEAgBygCCCAJQQJ0aiEHIANBkAFqIQ4gA0GcAWohDwNAIAEoAgAiAkEwaiEKAkACQAJAAkACQAJAAkACQCACLQAwQRdrDgoBAAACAwAEBQAGAAsgA0EUaiAKEL8GDAYLIANBFDoAFAwFCyADQRg6ABQMBAsgAyACQTRqNgIoIANCgICAgBA3AiAgA0EUaiADQSBqEMobIAMgAygCFDYCcCADIAMoAhgiBDYCaCADIAQgAygCHCIGQQJ0ajYCdCAGRQ0GIANBGzoAFCADIARBBGo2AmwgAyAEKAIANgIYIANB6ABqENUcDAMLIAMgAkE4ajYCKCADQoCAgIAQNwIgIANBFGogA0EgahDKGyADIAMoAhQ2AnAgAyADKAIYIgQ2AmggAyAEIAMoAhwiBkECdGo2AnQgBkUNBiADQR06ABQgAyAEQQRqNgJsIAMgBCgCADYCHCADIAIoAjQ2AhggA0HoAGoQ1RwMAgsgAyACQTRqNgIoIANCgICAgBA3AiAgA0EUaiADQSBqEMobIAMgAygCFDYCcCADIAMoAhgiBDYCaCADIAQgAygCHCIGQQJ0ajYCdCAGRQ0GIANBHjoAFCADIARBBGo2AmwgAyAEKAIANgIYIANB6ABqENUcDAELIANBCGogAkE0ahDDNCADQegAaiIEIAMoAggiBiAGIAMoAgxBAnRqEKUbIAMgBBC2GSADQSA6ABQgAyADKQMANwIYCyAPIAJBPGoQ3SAgDiAKEL8GIAIvAUghBCACKQMoIRAgA0HoAGoiCiACQQhqELEuIAMgEDcDiAEgAyAEOwGoASADQSBqIgQgCiADQRRqEKQrQdAAQQgQrTYiAkUNBSACQoGAgIAQNwMAIAJBCGogBEHIAPwKAAAgByACNgIAIAFBBGohASAHQQRqIQcgCUEBaiEJIAtBAWsiCw0ACwsgDSAJNgIAIANBsAFqJAAMBAtBqKPDABCyOwALQbijwwAQsjsAC0HIo8MAELI7AAtBCEHQABCjPQALIAhBEGokACAAQQhqIAwoAgA2AgAgACAFKQIINwIAIAVBIGokAAuSAQICfwF+IwBBEGsiBCQAIARBCGoiBSABQSBqIgEgAxC5GgJAAkAgBC0ACEEERg0AIAQpAwgiBkL/AYNCBFENACAEIAY3AwggACAFENAJDAELIAQgASgCACgCACACIAMQpxogBC0AAEEERwRAIAQgBCkDADcDCCAAIARBCGoQ0AkMAQsgAEEENgIACyAEQRBqJAALkgECAn8BfiMAQRBrIgQkACAEQQhqIgUgAUEgaiIBIAMQuBoCQAJAIAQtAAhBBEYNACAEKQMIIgZC/wGDQgRRDQAgBCAGNwMIIAAgBRDQCQwBCyAEIAEoAgAoAgAgAiADEKgaIAQtAABBBEcEQCAEIAQpAwA3AwggACAEQQhqENAJDAELIABBBDYCAAsgBEEQaiQAC5oCAgR/AX4jAEEwayIDJAAgA0EgaiEEIAFBIGohBSMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAkAgAiABQQhqIgYQuxQiAkELSQRAIAFBGGogBSgCACgCACAGIAIQpxoCQAJAIAEtABhBBEYNACABKQMYIgdC/wGDQgRRDQAgBCAHNwIADAELIARBBDoAACAEIAI2AgQLIAFBIGokAAwBCyACQQpBiL3DABCwOwALAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALmgICBH8BfiMAQTBrIgMkACADQSBqIQQgAUEgaiEFIwBBIGsiASQAIAFBEGpBADsBACABQgA3AwgCQCACIAFBCGoiBhC7FCICQQtJBEAgAUEYaiAFKAIAKAIAIAYgAhCoGgJAAkAgAS0AGEEERg0AIAEpAxgiB0L/AYNCBFENACAEIAc3AgAMAQsgBEEEOgAAIAQgAjYCBAsgAUEgaiQADAELIAJBCkGIvcMAELA7AAsCQAJAIAMtACBBBEYNACADIAMpAyA3AyggA0EMaiADQShqENAJIAMoAgxBBEYNACAAIAMpAgw3AgAgAEEQaiADQRxqKAIANgIAIABBCGogA0EUaikCADcCAAwBCyAAQQQ2AgALIANBMGokAAuaAgIEfwF+IwBBMGsiAyQAIANBIGohBCABQSBqIQUjAEEgayIBJAAgAUEQakEAOwEAIAFCADcDCAJAIAIgAUEIaiIGEMYUIgJBC0kEQCABQRhqIAUoAgAoAgAgBiACEKcaAkACQCABLQAYQQRGDQAgASkDGCIHQv8Bg0IEUQ0AIAQgBzcCAAwBCyAEQQQ6AAAgBCACNgIECyABQSBqJAAMAQsgAkEKQYi9wwAQsDsACwJAAkAgAy0AIEEERg0AIAMgAykDIDcDKCADQQxqIANBKGoQ0AkgAygCDEEERg0AIAAgAykCDDcCACAAQRBqIANBHGooAgA2AgAgAEEIaiADQRRqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC5oCAgR/AX4jAEEwayIDJAAgA0EgaiEEIAFBIGohBSMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAkAgAiABQQhqIgYQxhQiAkELSQRAIAFBGGogBSgCACgCACAGIAIQqBoCQAJAIAEtABhBBEYNACABKQMYIgdC/wGDQgRRDQAgBCAHNwIADAELIARBBDoAACAEIAI2AgQLIAFBIGokAAwBCyACQQpBiL3DABCwOwALAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALpQMBBX8jAEEwayIDJAAgA0EgaiEFIAFBIGohBiMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIARBCkYNASABQQhqIARqIAKnQYABcjoAACAEQQFqIQQgAkL//wBWIAJCB4ghAg0ACyAEQQFrQQlJDQEgBEEKQei8wwAQwyEAC0EKQQpB+LzDABDDIQALIAFBCGogBGogAjwAACAEQQFqDAILQaS8wwBBNEHYvMMAEJ8pAAsgASACPAAIQQELIQQgAUEYaiAGKAIAKAIAIAFBCGogBBCoGgJAAkAgAS0AGEEERg0AIAEpAxgiAkL/AYNCBFENACAFIAI3AgAMAQsgBUEEOgAAIAUgBDYCBAsgAUEgaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALpQMBBX8jAEEwayIDJAAgA0EgaiEFIAFBIGohBiMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIARBCkYNASABQQhqIARqIAKnQYABcjoAACAEQQFqIQQgAkL//wBWIAJCB4ghAg0ACyAEQQFrQQlJDQEgBEEKQei8wwAQwyEAC0EKQQpB+LzDABDDIQALIAFBCGogBGogAjwAACAEQQFqDAILQaS8wwBBNEHYvMMAEJ8pAAsgASACPAAIQQELIQQgAUEYaiAGKAIAKAIAIAFBCGogBBCnGgJAAkAgAS0AGEEERg0AIAEpAxgiAkL/AYNCBFENACAFIAI3AgAMAQsgBUEEOgAAIAUgBDYCBAsgAUEgaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALjAEBAn8CQAJAIAAoAggiAyACRg0AAkAgAUH/AXENACAAKAIEIQQgAgRAIAIgA08NAyACIARqLAAAQb9/TA0DCyADIAJrQQJHDQAgAiAEaiIDLQAAQd8BcUHBAGtB/wFxQRlLDQAgAy0AAUE6Rg0BCyAAIAEgAhCPCwsPCyAEIAMgAiADQdyPxAAQozYAC+gBAQR/IwBBgCBrIgMkAAJAQYCJ+gAgASABQYCJ+gBPGyIGIAEgAUEBdmsiBSAFIAZJGyIFQYEITwRAIwBBEGsiBCQAIARBBGogBUEAQQRBBBCgGCAEKAIIIQYgBCgCBEEBRgRAIAYgBCgCDEHQrcwAEP0vAAsgBCgCDCEFIANBADYCCCADIAU2AgQgAyAGNgIAIARBEGokACAAIAEgAygCBCADKAIIIgBBAnRqIAMoAgAgAGsgAUHBAEkgAhD6CSADQQRBBBDgHgwBCyAAIAEgA0GACCABQcEASSACEPoJCyADQYAgaiQAC9kBAQN/IwBBMGsiAyQAIANBIGohBCABQSBqIwBBEGsiASQAIAFBCGpBADsBACABQgA3AwAgAiABEMYUIgJBC08EQCACQQpBrJnPABCwOwALKAIAIAEgAhChNiAEQQQ6AAAgBCACNgIEIAFBEGokAAJAAkAgAy0AIEEERg0AIAMgAykDIDcDKCADQQxqIANBKGoQ0AkgAygCDEEERg0AIAAgAykCDDcCACAAQRBqIANBHGooAgA2AgAgAEEIaiADQRRqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC+sCAQV/IwBBMGsiAyQAIANBIGohBSABQSBqQQAhASMAQRBrIgQkACAEQQhqQQA7AQAgBEIANwMAAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIAFBCkYNASABIARqIAKnQYABcjoAACABQQFqIQEgAkL//wBWIAJCB4ghAg0ACyABQQFrQQlJDQEgAUEKQdyYzwAQwyEAC0EKQQpB7JjPABDDIQALIAEgBGogAjwAACABQQFqDAILQZiYzwBBNEHMmM8AEJ8pAAsgBCACPAAAQQELIQEoAgAgBCABEKE2IAVBBDoAACAFIAE2AgQgBEEQaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALhQEBA38jAEEQayIEJAAgBEEEaiADQQBBAUEBEKAYIAQoAgghBSAEKAIEQQFHBEAgBCgCDCEGIAMEQCAGIAIgA/wKAAALIAFBNGoQ3jsgASADNgI8IAEgBjYCOCABIAU2AjQgACABQcgA/AoAACAEQRBqJAAPCyAFIAQoAgxB9I7PABD9LwALbwEBfwJAAkACQAJAAkBBgICAgHggACgCACIBIAFBgICAgHhNG0H/////B3EOBAEEBAIACyAAKAIEQYGAgIB4Rg0CDAMLIAAQ1S4PCyAAQQRqELkuCw8LIABBBGoQhjAgAEEQahCGMCAAQRxqEIYwC30BBX8gAUEQbSIBQQAgAUEAShshBiACQQJqIQcDQCAFIAZGRQRAQQAhAQNAIAFBwABGRQRAIAAgAWoiBEEBIAQoAgAiBCACa0EAIAQgB08bIgggBEEBRhsgCCADGzYCACABQQRqIQEMAQsLIABBQGshACAFQQFqIQUMAQsLC5UBAQF/IwBBEGsiByQAAkAgBUH/AXFBBEkEQCABIAIgBRDbIiIBQf8BcUHAAE8NASAEIAFB/wFxIgIgBkH/AXFBBnRyIgVLBEAgAyAFai0AACECCyAAIAE6AAQgACACNgIAIAdBEGokAA8LQeyd4gBBKyAHQQ9qQdyd4gBBkIbjABDVHgALQaCG4wBBHEG8huMAEJ8pAAuHAQEBfyABQcEASQRAAkAgACgCACIDQZ0LRwRAIAAoAgggASACakEEakEBIAMRBgAiAA0BQQAPCyABIAJBARCrKA8LIAAgASAAIAFwIgJrQQAgAhsiAmpBBCABIAFBBE0bQQAgAkEESRtqIgFBBGsgADYAACABDwtB6PT8AEEwQZj1/AAQnykAC5QBAQF/IwBBMGsiAiQAIAAoAgAhACACIAE2AgAgASAAQQxqKAIITwRAIAIgABCjPDYCHCACQQI2AgggAkHwiP8ANgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBgIn/ABDvLAALIAAoAhAgAWotAAAgAkEwaiQAC+EBAQV/IwBBIGsiAyQAIANBFGogAiABa0EDdkEAQQRBBBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEHk5IABEP0vAAsgA0EQaiIHQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqIgUgAiABa0EDdiIGEO4tIAUoAgghBCAFIAEgAkcEfyAEIAZqIAUoAgQgBEECdGohBANAIAQgASkDAD4CACABQQhqIQEgBEEEaiEEIAZBAWsiBg0ACwUgBAs2AgggAEEIaiAHKAIANgIAIAAgAykCCDcCACADQSBqJAAL4QEBBX8jAEEgayIDJAAgA0EUaiACIAFrQQJ2QQBBCEEIEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQeTkgAEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIANBCGoiBSACIAFrQQJ2IgYQ7C0gBSgCCCEEIAUgASACRwR/IAQgBmogBSgCBCAEQQN0aiEEA0AgBCABNQIANwMAIAFBBGohASAEQQhqIQQgBkEBayIGDQALBSAECzYCCCAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQJ2IQADQCADKAIAIgQgAU8NAiACIAZqIAQgB2otAAA6AAAgA0EEaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUH0toIBEMMhAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQN2IQADQCABIAMoAgAiBE0NAiACIAZqIAQgB2otAAA6AAAgA0EIaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUH0toIBEMMhAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQJ2IQADQCADKAIAIgQgAU8NAiACIAZqIAQgB2otAAA6AAAgA0EEaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUG8tIIBEMMhAAvkAgEIfyMAQSBrIgQkACAEQRRqIAIgAWtBAnZBAEEEQQgQoBggBCgCGCEGIAQoAhRBAUYEQCAGIAQoAhxB0MiCARD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAY2AggjAEEQayIGJAAgAiABa0ECdiIHIARBCGoiBSgCACAFKAIIIgNrSwRAIAUgAyAHQQRBCBDeKCAFKAIIIQMLIAYgBSgCBDYCDCAGIAM2AgggBiAFQQhqNgIEIAZBBGoiAygCBCEFIAMoAgAgASACRwRAIAMoAgggBUEDdGohAyAFIAIgAWtBAnYiAmohBQNAIAEoAgAiCCgCICEKIANBBGogCCgCJCIINgIAIAMgCiAIKAIIQQFrQXhxakEIajYCACABQQRqIQEgA0EIaiEDIAJBAWsiAg0ACwsgBTYCACAGQRBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAAL6wEBBn8jAEEgayIDJAAgA0EUaiACIAFrQQN2QQBBBEEIEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQdDIggEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIwBBEGsiBCQAIAIgAWtBA3YiCCADQQhqIgUoAgAgBSgCCCIGa0sEQCAFIAYgCEEEQQgQ3iggBSgCCCEGCyAEIAUoAgQ2AgwgBCAGNgIIIAQgBUEIajYCBCABIAIgBEEEahDfGyAEQRBqJAAgAEEIaiAHKAIANgIAIAAgAykCCDcCACADQSBqJAAL5AIBCH8jAEEgayIEJAAgBEEUaiACIAFrQQJ2QQBBBEEIEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQdDIggEQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIAIgAWtBAnYiByAEQQhqIgUoAgAgBSgCCCIDa0sEQCAFIAMgB0EEQQgQ3iggBSgCCCEDCyAGIAUoAgQ2AgwgBiADNgIIIAYgBUEIajYCBCAGQQRqIgMoAgQhBSADKAIAIAEgAkcEQCADKAIIIAVBA3RqIQMgBSACIAFrQQJ2IgJqIQUDQCABKAIAIggoAgwhCiADQQRqIAgoAhAiCDYCACADIAogCCgCCEEBa0F4cWpBCGo2AgAgAUEEaiEBIANBCGohAyACQQFrIgINAAsLIAU2AgAgBkEQaiQAIABBCGogCSgCADYCACAAIAQpAgg3AgAgBEEgaiQAC9kBAQR/IwBBIGsiBCQAIARBFGogAiABa0HEAG5BAEEEQQQQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhwgAxD9LwALIARBEGoiB0EANgIAIAQgBCgCHDYCDCAEIAU2AgggBEEIaiIFIAIgAWtBxABuEO4tIAUoAgghAyABIAJHBEAgBSgCBCADQQJ0aiEGA0AgBiABNgIAIAZBBGohBiADQQFqIQMgAUHEAGoiASACRw0ACwsgBSADNgIIIABBCGogBygCADYCACAAIAQpAgg3AgAgBEEgaiQAC8ACAQd/IwBBIGsiBCQAIARBFGogAiABa0EDdkEAQQRBxAAQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhwgAxD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAU2AggjAEEQayIDJAAgBEEIaiIFIAIgAWtBA3YiBxD+LSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIwBB0ABrIggkACADQQRqIgYoAgQhBSAGKAIAIAEgAkcEQCAGKAIIIAVBxABsaiEGIAUgByICaiEFA0AgCEEMaiIHIAEoAgAgAUEEaigCACgCFBEAACAGIAdBxAD8CgAAIAFBCGohASAGQcQAaiEGIAJBAWsiAg0ACwsgBTYCACAIQdAAaiQAIANBEGokACAAQQhqIAkoAgA2AgAgACAEKQIINwIAIARBIGokAAvuAgEJfyMAQSBrIgMkACADQRRqIAIgAWtBGG5BAEEEQRgQoBggAygCGCEGIAMoAhRBAUYEQCAGIAMoAhxByP+FARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAY2AggjAEEQayIGJAAgAiABa0EYbiIHIANBCGoiBSgCACAFKAIIIgRrSwRAIAUgBCAHQQRBGBDeKCAFKAIIIQQLIAYgBSgCBDYCDCAGIAQ2AgggBiAFQQhqNgIEIAZBBGoiBCgCBCEFIAQoAgAgASACRwRAIAQoAgggBUEYbGohCyAFIAIgAWtBGG4iB2ohBUEAIQIDQCACIAtqIgRBFGpBADYCACAEIAEgAmoiCC0AADoAACAEQQxqIAhBDGopAgA3AgAgBEEEaiAIQQRqKQIANwIAIAJBGGohAiAHQQFrIgcNAAsLIAU2AgAgBkEQaiQAIABBCGogCSgCADYCACAAIAMpAgg3AgAgA0EgaiQAC6sDAQl/IwBBIGsiBSQAIAVBFGogAiABa0EcbkEAQQRBGBCgGCAFKAIYIQMgBSgCFEEBRgRAIAMgBSgCHEHI/4UBEP0vAAsgBUEQaiIIQQA2AgAgBSAFKAIcNgIMIAUgAzYCCCMAQRBrIgckACACIAFrQRxuIgYgBUEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAZBBEEYEN4oIAMoAgghBAsgByADKAIENgIMIAcgBDYCCCAHIANBCGo2AgQjAEEgayIDJAAgB0EEaiIEKAIEIQYgBCgCACABIAJHBEAgBCgCCCAGQRhsaiEEIAYgAiABa0EcbiICaiEGIANBDGohCgNAIAEtAAAhCyADIAFBBGoQ3DsgCiADKAIAIAMoAgQgAUEQaigCACABQRRqKAIAEIcdIARBCGogA0EQaikCADcCACAEQRBqIANBGGopAgA3AgAgAyALOgAIIAQgAykCCDcCACABQRxqIQEgBEEYaiEEIAJBAWsiAg0ACwsgBjYCACADQSBqJAAgB0EQaiQAIABBCGogCCgCADYCACAAIAUpAgg3AgAgBUEgaiQAC6UBAQN/IwBBEGsiAiQAIAJBBGogAUEAQRBBEBCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEGExoUBEP0vAAsgAigCDCEEIAAgATYCdCAAQQA2AnAgAEEANgJcIABBADYCQCAAIAQ2AjwgACADNgI4IABCATcCVCAAQgA3AkwgAEKAgICAwAA3AkQgAEEANgIIIABCgYCAgICACDcDACACQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQghBQJAIAMoAgwiAiADKAIIIgZBCBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEHcSECIARBA3YhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQIhBQJAIAMoAgwiAiADKAIIIgZBAhD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEBcSECIARBAXYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQQhBQJAIAMoAgwiAiADKAIIIgZBBBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEDcSECIARBAnYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QRAhBQJAIAMoAgwiAiADKAIIIgZBEBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEPcSECIARBBHYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAAL6AEBBH8jAEGAIGsiAyQAAkBBgIn6ACABIAFBgIn6AE8bIgYgASABQQF2ayIFIAUgBkkbIgVBgQhPBEAjAEEQayIEJAAgBEEEaiAFQQBBBEEEEKAYIAQoAgghBiAEKAIEQQFGBEAgBiAEKAIMQczIhwEQ/S8ACyAEKAIMIQUgA0EANgIIIAMgBTYCBCADIAY2AgAgBEEQaiQAIAAgASADKAIEIAMoAggiAEECdGogAygCACAAayABQcEASSACEIEKIANBBEEEEOAeDAELIAAgASADQYAIIAFBwQBJIAIQgQoLIANBgCBqJAAL6AcCCX8BfiMAQSBrIgQkACAEQRRqIAEoAgQgASgCAGtBAEEEQQQQoBggBCgCGCECIAQoAhRBAUYEQCACIAQoAhxBkNDDABD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEgayIFJAAgBEEIaiICIAEoAgQgASgCAGsQgC4gAikCBCELIAVBEGogAUEIaigCADYCACAFIAEpAgA3AwggBSALQiCJNwIYIAUgAkEIajYCFCMAQbABayIBJAAgBUEUaiICKAIEIQgCQAJAAkACQAJAIAIoAgAgBUEIaiIDKAIAIAMoAgRHBH8gAigCCCADKAIIKAIAIgJBMGohBwJAAkACQAJAAkACQAJAAkAgAi0AMEEXaw4KAQAAAgMABAUABgALIAFBFGogBxC/BgwGCyABQRQ6ABQMBQsgAUEYOgAUDAQLIAEgAkE0ajYCKCABQoCAgIAQNwIgIAFBFGogAUEgahDKGyABIAEoAhQ2AnAgASABKAIYIgM2AmggASADIAEoAhwiBkECdGo2AnQgBkUNBSABQRs6ABQgASADQQRqNgJsIAEgAygCADYCGCABQegAahDVHAwDCyABIAJBOGo2AiggAUKAgICAEDcCICABQRRqIAFBIGoQyhsgASABKAIUNgJwIAEgASgCGCIDNgJoIAEgAyABKAIcIgZBAnRqNgJ0IAZFDQUgAUEdOgAUIAEgA0EEajYCbCABIAMoAgA2AhwgASACKAI0NgIYIAFB6ABqENUcDAILIAEgAkE0ajYCKCABQoCAgIAQNwIgIAFBFGogAUEgahDKGyABIAEoAhQ2AnAgASABKAIYIgM2AmggASADIAEoAhwiBkECdGo2AnQgBkUNBSABQR46ABQgASADQQRqNgJsIAEgAygCADYCGCABQegAahDVHAwBCyABQQhqIAJBNGoQwzQgAUHoAGoiAyABKAIIIgYgBiABKAIMQQJ0ahClGyABIAMQthkgAUEgOgAUIAEgASkDADcCGAsgAUGcAWogAkE8ahDdICABQZABaiAHEL8GIAIvAUghAyACKQMoIQsgAUHoAGoiByACQQhqELEuIAEgCzcDiAEgASADOwGoASABQSBqIgMgByABQRRqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogA0HIAPwKAAAgCEECdGogAjYCACAIQQFqBSAICzYCACABQbABaiQADAQLQaijwwAQsjsAC0G4o8MAELI7AAtByKPDABCyOwALQQhB0AAQoz0ACyAFQSBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAALigEBA38jAEEQayIBJAACQCAAKAIAIgJB0ABqEJQhIgBFDQAgAi0AVCACQYECOwBUIAEgADYCDEUEQCACQQA2AkwgACgCGCAAIAJBCGoiADYCGCAANgJEIAEoAgwiAEEMahD5KAsgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBDGoQ2x8LIAFBEGokAAuKAQEDfyMAQRBrIgEkAAJAIAAoAgAiAkHwAGoQlCEiAEUNACACLQB0IAJBgQI7AHQgASAANgIMRQRAIAJBADYCbCAAKAIYIAAgAkEIaiIANgIYIAA2AmQgASgCDCIAQQxqEPkoCyAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEMahDaHwsgAUEQaiQAC44BAQN/IwBBEGsiASQAAkAgACgCACICQdgBahCUISIARQ0AIAItANwBIAJBgQI7ANwBIAEgADYCDEUEQCACQQA2AtQBIAAoAhggACACQQhqIgA2AhggADYCzAEgASgCDCIAQQxqEPkoCyAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEMahDZHwsgAUEQaiQAC5EBAQJ/IwBBEGsiAiQAIAJBCGogARD8KQJAAkAgAigCCCIDQQJHBEAgAigCDCEBIANBAXFFDQEgAEECNgIAIAAgATYCBAwCCyAAQQA2AgAMAQsgAiABELgSIAIoAgQhASACKAIAQQFxRQRAIAAgATYCBCAAQQE2AgAMAQsgAEECNgIAIAAgATYCBAsgAkEQaiQAC4sBAQJ/IwBBIGsiAiQAAkAgASkDAEICUgRAIABBCDYCACAAQQE6AAQMAQsgAkEIaiABEJ0GIAIoAgwhASACKAIIIgNBCEcEQCAAIAIpAxA3AwggAEEQaiACQRhqKQMANwMAIAAgATYCBCAAIAM2AgAMAQsgAEEINgIAIAAgAUECRjoABAsgAkEgaiQAC30BAX8gAEEQahDeOyAAKAJ4IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgAahD4IwsgAEHYAGoQ7CYgACgCIEGAgICAeEcEQCAAQSBqEOk7IAAoAjAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBMGoQhR0LIABBOGoQkycLC48BAQR/IwBBEGsiAyQAIAAoAhQhASAAKAIYIgQoAgAiAgRAIAEgAhEDAAsgBCgCBCICBEAgASACIAQoAggQ+DoLIAAoAhwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBHGoQ+CMLIAAoAgBBgICAgHhHBEAgAyAAIAAoAgwQ+BggAEEEQQgQ4B4LIANBEGokAAuLAQECfyMAQSBrIgIkAAJAIAEpAwBCAlIEQCAAQQg2AgAgAEEBOgAEDAELIAJBCGogARD8BSACKAIMIQEgAigCCCIDQQhHBEAgACACKQMQNwMIIABBEGogAkEYaikDADcDACAAIAE2AgQgACADNgIADAELIABBCDYCACAAIAFBAkY6AAQLIAJBIGokAAueAQEBfwJAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEOMoRQ0CDAMLIAAgARC5HA0CDAELIAAgARC4HA0BCyABKAIAQbz1zgBBAiABKAIEKAIMEQYADQAgAEEIaiEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDjKA8LIAAgARC5HA8LIAAgARC4HA8LQQELhwEBAn8jAEEQayIHJAAgAwRAIAdBADYCDCAAAn8CQCAEQRpJBEAgASAEQQJ0IgFB0qHzAGotAAAgB0EMaiAFIAYQ7R8iCA0BIAAgBDYCHEEBDAILIARBGkG4ovMAEMMhAAsgAiAHKAIMIAFB0KHzAGovAQBqNgIAQQALOgBECyAHQRBqJAAgCAvXBAIHfwN+IwBBIGsiBSQAAkACQAJAIAJFDQAgASACakEBayIDRQ0AIAMtAABBMGtB/wFxQQpJDQELIABCADcDAAwBCyAFQQhqIQkgASEHQQAhASMAQRBrIggkAAJAAkACQAJAAkACQCACIgNFDQAgBy0AACIBQStGIgQgAUEtRiIGciEBAkAgBkUEQCABIANGBEBBASEBDAMLQRRBEyAEGyIEIAMgAyAESxshBANAIAEgA0YNAiABIAdqLQAAQTBrIgZB/wFxQQpPDQMgC0IKfiAGrUL/AYN8IQsgBCABQQFqIgFHDQALIAQhAQwCCyABIANGBEBBASEDDAMLQgEhCgNAIAEgB2otAABBMGtB/wFxIgRBCUsNBSAEQQN0QdD1gAFqKQMAQgAgCqdBAXEbIQogAyABQQFqIgFHDQALDAYLIAMgA0Gw84ABEMMhAAsgASADRw0BC0IBIQoMAwsgASADIAEgA0sbIQRCASEKA0AgASAERg0CIAEgB2otAABBMGsiBkH/AXFBCk8NAQJ+QgAgCqdBAXFFDQAaIAggC0IAQgpCABCoHkIAIAgpAwhCAFINABogCyAIKQMAIgogBq1C/wGDfCIMIAogDFYbIQsgCiAMWK0LIQogAyABQQFqIgFHDQALDAILIAEhAwwBCyAEIANBwPOAARDDIQALIAkgAzYCECAJIAs3AwggCSAKNwMAIAhBEGokAAJAIAUpAwgiCqdBAUYEQCAFKAIYIAJGDQELIABCADcDAAwBCyAAIAUpAxA3AwggACAKNwMACyAFQSBqJAALpwYCB38DfiMAQSBrIgckAAJAAkACQCACRQ0AIAEgAmpBAWsiA0UNACADLQAAQTBrQf8BcUEKSQ0BCyAAQgA3AwAMAQsgB0EIaiEJIAEhCEEAIQEjAEEgayIGJAACQAJAAkACQAJAIAIiA0UNACAILQAAIgFBK0YgAUEtRiIEciEBAkACQAJAAkAgBARAIAEgA0cNAUEBIQEMBAsgASADRgRAQQEhAQwFCyABQRJyIgQgAyADIARLGyEEA0AgASADRg0CIAEgCGotAABBMGsiBUH/AXFBCk8NBSAKQgp+IAWtQv8Bg3whCiAEIAFBAWoiAUcNAAsgBCEBDAQLQRMgAyADQRNPGyEEA0AgASADRg0CIAEgCGotAABBMGsiBUH/AXFBCk8NAyAKQgp+IAWtQv8Bg30hCiAEIAFBAWoiAUcNAAsgBCEBDAILIAMgA0Gw84ABEMMhAAsgAyADQdDzgAEQwyEACyABIANGDQEgASADIAEgA0sbIQRCASELA0ACQCABIARHBEAgASAIai0AAEEwayIFQf8BcUEKSQ0BDAYLIAQgA0Hg84ABEMMhAAsCfkIAIAunQQFxRQ0AGiAGQRBqIAogCkI/h0IKQgAQqB5CACAGKQMYIAYpAxAiC0I/h1INABogCiALIAWtQv8BgyIKfSIMIApCAFIgCyAMVXMiBRshCiAFRa0LIQsgAyABQQFqIgFHDQALDAQLIAEgA0cNAQtCASELDAILIAEgAyABIANLGyEEQgEhCwNAIAEgBEcEQCABIAhqLQAAQTBrIgVB/wFxQQpPDQICfkIAIAunQQFxRQ0AGiAGIAogCkI/h0IKQgAQqB5CACAGKQMIIAYpAwAiC0I/h1INABogCiALIAWtQv8Bg3wiCiAKIAtTIgUbIQogBUWtCyELIAMgAUEBaiIBRw0BDAMLCyAEIANBwPOAARDDIQALIAEhAwsgCSADNgIQIAkgCjcDCCAJIAs3AwAgBkEgaiQAAkAgBykDCCIKp0EBRgRAIAcoAhggAkYNAQsgAEIANwMADAELIAAgBykDEDcDCCAAIAo3AwALIAdBIGokAAujAQECfyMAQTBrIgIkACACQRBqQY6cuPAANgIAIAJCjpy48ODBg4cONwMIAkACQAJAIAHEQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAkIANwIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAuVAQEDfwJAIAAoAnwiBCABSwRAIAFBA3QiBCAAKAJ4aiIFKAIAIABBDGoiBiACIAMgAmsiAyAFKAIEKAIUEQUAIAEgACgCcCIFTw0BIAAoAmwgBGoiBCgCACAGIAEgAiADIAQoAgQoAhQRBwAgACAAKAJYIANqNgJYDwsgASAEQciWhwEQwyEACyABIAVB2JaHARDDIQALngEBAX8CQAJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARD8KEUNAgwDCyAAIAEQ0xwNAgwBCyAAIAEQ0hwNAQsgASgCAEGMu4cBQQIgASgCBCgCDBEGAA0AIABBBGohACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ/CgPCyAAIAEQ0xwPCyAAIAEQ0hwPC0EBC6gBAQN/IwBBEGsiAiQAQbKxiQEhA0ETIQQCQAJAAkACQCABLQAAQQFrDgMCAAEDCyABKAIEIgEoAgQhBCABKAIAIQMMAgsgAkEIaiABKAIEIgEoAgAgASgCBCgCIBEAACACKAIMIQQgAigCCCEDDAELIAEtAAFBAnQiAUGkvIkBaigCACEDIAFB/LqJAWooAgAhBAsgACADNgIAIAAgBDYCBCACQRBqJAALmQEBA38gAC0ACCEBAkAgACgCACIDRQRAIAEhAgwBC0EBIQICQCABQQFxRQRAIANBAUcNASAALQAJRQ0BIAAoAgQiAS0ACkGAAXENASABKAIAQdzxiQFBASABKAIEKAIMEQYARQ0BCyAAIAI6AAgMAQsgACAAKAIEIgAoAgBBk+2JAUEBIAAoAgQoAgwRBgAiAjoACAsgAkEBcQuBAQEDfyMAQRBrIgIkACACQQRqIAFBAEEBQQEQoBggAigCCCEEIAIoAgRBAUcEQCACKAIMIQMgAQRAIAMgACAB/AoAAAsgAiABNgIMIAIgAzYCCCACIAQ2AgQgAyABEJQ+IAJBBGoQ3jsgAkEQaiQADwsgBCACKAIMQdzDzAAQ/S8AC5EBAQF/IwBBIGsiAiQAIAIgATYCDCACQRBqIAJBDGoQkh8CQCACKAIQQYCAgIB4RwRAIAAgAikCEDcCACAAQQhqIAJBGGooAgA2AgAMAQsgAkEMaiACQR9qQZDFzAAQ0QshASAAQYCAgIB4NgIAIAAgATYCBCACKAIMIQELIAFBhAFPBEAgARDyHwsgAkEgaiQAC8B4Aht/A34jAEEwayISJAAgEkEYaiEWIAEoAhwhEyMAQdAAayIPJAACQAJAAn8CQAJAIAEiESgCACIBIBEoAgQiGUcEQCARKAIIIhdBAWohFCARKAIQIRggESgCDCEaIA9BGGohFSAPQRBqQQRyIRsDQCARIAFBwAJqIhw2AgAgAUFAaygCAEEBRw0DIAFByABqKQMAIh1CAFMNAyABQcgBaigCAEEBRw0DIAFBzAFqKAIAIgZBAEgNAwJAAkACQAJAIB0gGikDACIffSIeQv////8PVg0AIB0gBq18IB99Ih1C/////w9WDQAgHqchAiAdpyEDIB0gHlQNBiAYKAIIIgYgA08NASADIAZB7OXQABCwOwALIA9BATYCMCAPQay+zQA2AiwgD0IBNwI4IA9BpgQ2AkggDyAPQcQAajYCNCAPIA9BzwBqNgJEIBsgD0EsahCZDkEAIQYgDygCFCEBDAELIA9BEGohDSAYKAIEIAJqIQQgAUG8AmooAgBBCGoQ3SVB/wFxIQ5BACEIQQAhCyMAQfABayIGJAAgBkEIaiIFIAQgAyACaxCdHyAGQThqIQMjAEHgAWsiASQAIAFByAFqIAUQ8CcgAUGQAWoiAiABQdQBaiIEKAIANgIAIAEgASkCzAE3A4gBAkAgASgCyAEiCUEERwRAIAEoAtgBIQUgAyABKQOIATcCCCADIAU2AhQgAyAJNgIEIANBgICAgHg2AgAgA0EQaiACKAIANgIADAELIAFB+ABqIAIoAgA2AgAgASABKQOIATcDcCABQfAAahCGMCABQYCAgIB4NgIIIAFBgICAgHg2AhggAUGAgICAeDYCKCABQQA2AjggAUGAgICAeDYCQCABQYCAgIB4NgJQIAFBgICAgHg2AmAgAUHIAWogBRDTCSACIAQpAgA3AwAgAUGYAWoiCiABQdwBaigCADYCACABIAEpAswBNwOIAQJAAkAgASgCyAFFBEAgAUHMAWohCQNAIAFBgAFqIAooAgAiAjYCACABQfgAaiABQZABaiIEKQMANwMAIAEgASkDiAE3A3ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXEEQCABQcgBaiABQfAAahD8FyABLwHMASECIAEoAsgBIgdBBEcEQCADIAEpAc4BNwEKIANBEGogAUHUAWopAQA3AQAgAyACOwEIIAMgBzYCBCADQYCAgIB4NgIADBALAkACQAJAAkACQAJAAkACQCACQQFrDgcBAgMABAUGBwsgAUHIAWogBRDAHCABKALIAUUEQCABKALQASEIDBMLIAEpA9ABIh2nIQggASgCzAEiAkEERg0SIAMgASkD2AE3AhAgAyAINgIIIAMgAjYCBCADQYCAgIB4NgIAIAMgHUIgiD4CDAwWCyABQcgBaiAFEMkPIAEoAswBIQIgASgCyAEiB0EERwRAIAMgASkA0QE3AA0gA0EUaiABQdgBaigAADYAACADIAEtANABOgAMIAMgAjYCCCADIAc2AgQgA0GAgICAeDYCAAwWCyABQcgBaiACQQBBAUEBEKAYIAEoAswBIQcgASgCyAFBAUYNByABQQA2ApABIAEgASgC0AE2AowBIAEgBzYCiAEgAkEASgRAA0AgAUHIAWogBRDaECABLQDMASEHIAEoAsgBIgxBBEcEQCADIAEpAM0BNwAJIANBEGogAUHUAWopAAA3AAAgAyAHOgAIIAMgDDYCBCADQYCAgIB4NgIAIAFBiAFqEN47DBgLIAEoApABIgwgASgCiAFGBEAgAUGIAWpB8JfQABCjKAsgASgCjAEgDGogBzoAACABIAxBAWo2ApABIAJBAWsiAg0ACwsgAUHQAWoiAiAEKAIANgIAIAEgASkCiAE3A8gBIAFBCGoQhjAgAUEQaiACKAIANgIAIAEgASkDyAE3AwgMEgsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMFQsgAUHIAWogAkEAQQRBDBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgK0ASABIAEoAtABNgKwASABIAc2AqwBIAJBAEoEQANAIAFByAFqIAUQpREgBCAJQQhqKAIANgIAIAEgCSkCADcDiAEgASgCyAEiB0EERwRAIAEoAtgBIQIgAyABKQOIATcCCCADIAI2AhQgAyAHNgIEIANBgICAgHg2AgAgA0EQaiABQZABaigCADYCACABQawBaiIDENcrIAMQ6DsMFwsgAUGoAWoiDCAEKAIANgIAIAEgASkDiAE3A6ABIAEoArQBIgcgASgCrAFGBEAgAUGsAWpBkJjQABCQKAsgASgCsAEgB0EMbGoiECABKQOgATcCACAQQQhqIAwoAgA2AgAgASAHQQFqNgK0ASACQQFrIgINAAsLIAFB0AFqIgIgAUG0AWooAgA2AgAgASABKQKsATcDyAEgAUEYahDzMCABQSBqIAIoAgA2AgAgASABKQPIATcDGAwRCyABQcgBaiAFEMkPIAEoAswBIQIgASgCyAEiB0EERwRAIAMgASkA0QE3AA0gA0EUaiABQdgBaigAADYAACADIAEtANABOgAMIAMgAjYCCCADIAc2AgQgA0GAgICAeDYCAAwUCyABQcgBaiACQQBBBEEMEKAYIAEoAswBIQcgASgCyAFBAUYNByABQQA2ArQBIAEgASgC0AE2ArABIAEgBzYCrAEgAkEASgRAA0AgAUHIAWogBRClESAEIAlBCGooAgA2AgAgASAJKQIANwOIASABKALIASIHQQRHBEAgASgC2AEhAiADIAEpA4gBNwIIIAMgAjYCFCADIAc2AgQgA0GAgICAeDYCACADQRBqIAFBkAFqKAIANgIAIAFBrAFqIgMQ1ysgAxDoOwwWCyABQcABaiIMIAQoAgA2AgAgASABKQOIATcDuAEgASgCtAEiByABKAKsAUYEQCABQawBakGwmNAAEJAoCyABKAKwASAHQQxsaiIQIAEpA7gBNwIAIBBBCGogDCgCADYCACABIAdBAWo2ArQBIAJBAWsiAg0ACwsgAUHQAWoiAiABQbQBaigCADYCACABIAEpAqwBNwPIASABQShqEPMwIAFBMGogAigCADYCACABIAEpA8gBNwMoDBALIAFByAFqIAUQyQ8gASgCzAEhAiABKALIASIHQQRHBEAgAyABKQDRATcADSADQRRqIAFB2AFqKAAANgAAIAMgAS0A0AE6AAwgAyACNgIIIAMgBzYCBCADQYCAgIB4NgIADBMLIAFByAFqIAJBAEEIQQgQoBggASgCzAEhByABKALIAUEBRg0HIAFBADYCkAEgASABKALQATYCjAEgASAHNgKIASACQQBKBEADQCABQcgBaiAFEMAcIAEoAsgBBEAgASgCzAEhAiABKQPQASEdIAMgASkD2AE3AhAgAyAdNwIIIAMgAjYCBCADQYCAgIB4NgIAIAFBiAFqEOM8DBULIAEpA9ABIR0gASgCkAEiByABKAKIAUYEQCABQYgBakHQmNAAELMoCyABKAKMASAHQQN0aiAdNwMAIAEgB0EBajYCkAEgAkEBayICDQALCyABQdABaiICIAQoAgA2AgAgASABKQKIATcDyAEgAUFAaxCFMCABQcgAaiACKAIANgIAIAEgASkDyAE3A0AMDwsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMEgsgAUHIAWogAkEAQQhBCBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgKQASABIAEoAtABNgKMASABIAc2AogBIAJBAEoEQANAIAFByAFqIAUQwBwgASgCyAEEQCABKALMASECIAEpA9ABIR0gAyABKQPYATcCECADIB03AgggAyACNgIEIANBgICAgHg2AgAgAUGIAWoQ4zwMFAsgASkD0AEhHSABKAKQASIHIAEoAogBRgRAIAFBiAFqQfCY0AAQsygLIAEoAowBIAdBA3RqIB03AwAgASAHQQFqNgKQASACQQFrIgINAAsLIAFB0AFqIgIgBCgCADYCACABIAEpAogBNwPIASABQdAAahCFMCABQdgAaiACKAIANgIAIAEgASkDyAE3A1AMDgsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMEQsgAUHIAWogAkEAQQhBCBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgKQASABIAEoAtABNgKMASABIAc2AogBIAJBAEoEQANAIAFByAFqIAUQwBwgASgCyAEEQCABKALMASECIAEpA9ABIR0gAyABKQPYATcCECADIB03AgggAyACNgIEIANBgICAgHg2AgAgAUGIAWoQ4zwMEwsgASkD0AEhHSABKAKQASIHIAEoAogBRgRAIAFBiAFqQZCZ0AAQsygLIAEoAowBIAdBA3RqIB03AwAgASAHQQFqNgKQASACQQFrIgINAAsLIAFB0AFqIgIgBCgCADYCACABIAEpAogBNwPIASABQeAAahCFMCABQegAaiACKAIANgIAIAEgASkDyAE3A2AMDQsgAUHIAWogBSABLQCAAUHAABDJAiABKALIASICQQRGDQwgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDA8LIAFB8ABqEIYwIAFByAFqIAUQqCkgASgCyAEiAkEERwRAIAMgASkCzAE3AgggA0EQaiABQdQBaikCADcCACADQYCAgIB4NgIAIAMgAjYCBAwQCyABQcgBakGgmdAAQRYgAUEIahD1HSABKALIASICQQRHBEAgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDBALIAFByAFqQbaZ0ABBFiABQRhqEPUdIAEoAsgBIgJBBEcEQCADIAEpAswBNwIIIANBEGogAUHUAWopAgA3AgAgA0GAgICAeDYCACADIAI2AgQMEAsgAUHIAWpBzJnQAEEWIAFBKGoQ9R0gASgCyAEiAkEERwRAIAMgASkCzAE3AgggA0EQaiABQdQBaikCADcCACADQYCAgIB4NgIAIAMgAjYCBAwQCyABQcgBakHimdAAQRogAUE4ahDmHiABKALIASICQQRHBEAgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDBALIAEoAggiAkGAgICAeEYNBiABKAIYIgVBgICAgHhGDQcgASgCKCIEQYCAgIB4Rg0IIAtFDQkgASkCDCEdIAEpAhwhHiABKQIsIR8gAyABKQNANwIkIAMgASkDUDcCMCADIAEpA2A3AjwgAyAINgJIIAMgHzcCHCADIAQ2AhggAyAeNwIQIAMgBTYCDCADIB03AgQgAyACNgIAIANBLGogAUHIAGooAgA2AgAgA0E4aiABQdgAaigCADYCACADQcQAaiABQegAaigCADYCAAwQCyAHIAEoAtABQeCX0AAQ/S8ACyAHIAEoAtABQYCY0AAQ/S8ACyAHIAEoAtABQaCY0AAQ/S8ACyAHIAEoAtABQcCY0AAQ/S8ACyAHIAEoAtABQeCY0AAQ/S8ACyAHIAEoAtABQYCZ0AAQ/S8AC0H4/M8AQccAQfyZ0AAQyyQAC0H4/M8AQccAQYya0AAQyyQAC0H4/M8AQccAQZya0AAQyyQAC0H4/M8AQccAQaya0AAQyyQACyABIAg2AjxBASELIAFBATYCOAsgAUHwAGoQhjAgAUHIAWogBRDTCSAEIAlBCGopAgA3AwAgCiAJQRBqKAIANgIAIAEgCSkCADcDiAEgASgCyAFFDQALCyADIAEpA4gBNwIEIANBgICAgHg2AgAgA0EUaiAKKAIANgIAIANBDGogAUGQAWopAwA3AgAMAQsgAUHwAGoQhjALIAFB4ABqEIUwIAFB0ABqEIUwIAFBQGsQhTAgAUEoahDzMCABQRhqEPMwIAFBCGoQhjALIAFB4AFqJAAgBkEoaiAGQcQAaikCADcDACAGQTBqIAZBzABqKAIANgIAIAYgBikCPDcDIAJAAkACQAJAIAYoAjgiAUGAgICAeEYEQCANIAZBIGoQpSUMAQsgBkGcAWogBkHQAGpBNPwKAAAgBkGQAWogBkEoaikDADcCACAGQZgBaiAGQTBqKAIANgIAIAYgATYChAEgBiAGKQMgNwKIASANAn8CQAJAAkACQAJAAkACQAJAIA5BAWsOBwECAwQFBgcACyAGQThqIQkjAEHQAWsiASQAIAEgBkGEAWoiAygCFCICNgIEAkACQCADKAIkIgRBgICAgHhGDQAgAygCLCEIIAMoAighBSABIAQ2AmAgASAFNgJcIAEgBTYCWCABIAUgCEEDdGo2AmQgAUFAayABQdgAahDgGiABKAJAQYCAgIB4Rg0AIAFBEGogAUHIAGooAgA2AgAgASABKQJANwMIDAELIAFBCGogAhCkFQsgASABQQRqNgIUIAFBGGogAUEUaiIFIANBMGoQ8wsgAUEkaiAFIANBPGoQ8wsgAygCICEFIAMoAhAhBCADKAIcIQggAUEANgJoIAEgCDYCYCABIAQgAkEMbGo2AlwgASAENgJYIAFCADcCyAEgASABKAIoIgQgASgCLEEMbGo2AsQBIAEgASgCJDYCwAEgASAENgK8ASABIAQ2ArgBIAFCADcCsAEgASABKAIcIgQgASgCIEEMbGo2AqwBIAEgASgCGDYCqAEgASAENgKkASABIAQ2AqABIAFCADcCmAEgASABKAIMIgQgASgCEEEEdGo2ApQBIAEgASgCCDYCkAEgASAENgKMASABIAQ2AogBIAFCADcCgAEgASAFIAIgAiAFSxs2AmwgASAIIAVBDGxqNgJkIAEgAygCADYCeCABIAMoAgQiAjYCdCABIAI2AnAgASACIAMoAghqNgJ8IAFBQGshCCMAQaABayIFJAAgBUEINgIAIAVBJGoiBCABQdgAakH4APwKAAAgBSAFNgKcASAFQRhqIQojAEHAAWsiAiQAIAJBEGoiDCAEEJkdAkACQAJAIAIpAxBCAlIEQCACQcQAaiILIAQQrRogC0EEIAIoAkRBAWoiB0F/IAcbIgcgB0EETRtBAEEIQTAQoBggAigCSCEHIAIoAkRBAUYNAiACKAJMIg4gDEEw/AoAACACQQxqIhBBATYCACACIA42AgggAiAHNgIEIAsgBEH8APwKAAAjAEFAaiIEJAAgBCALEJkdIAQpAwBCAlIEQCACQQRqIQcDQCAHKAIIIgwgBygCAEYEQCAEQTRqIAsQrRogByAMIAQoAjRBAWoiDkF/IA4bQQhBMBDQKAsgBygCBCAMQTBsaiAEQTD8CgAAIAcgDEEBajYCCCAEIAsQmR0gBCkDAEICUg0ACwsgCxDiJCAEQUBrJAAgCkEIaiAQKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAE3AgAgBBDiJAsgAkHAAWokAAwBCyAHIAIoAkxByJfPABD9LwALAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ikgCkEIQTAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAkLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQEMBwsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB0AFrIgIkACACQRhqIgwgBxCdHQJAIAIpAxhCAlIEQCACQdQAaiILIAcQrRogC0EEIAIoAlRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQTgQoBggAigCWCEEIAIoAlRBAUYNCiACKAJcIg4gDEE4/AoAACACQRRqIhBBATYCACACIA42AhAgAiAENgIMIAsgB0H8APwKAAAjAEHQAGsiBCQAIARBCGogCxCdHSAEKQMIQgJSBEAgAkEMaiEHA0AgBygCCCIMIAcoAgBGBEAgBEHEAGogCxCtGiAHIAwgBCgCREEBaiIOQX8gDhtBCEE4ENAoCyAHKAIEIAxBOGxqIARBCGoiDkE4/AoAACAHIAxBAWo2AgggDiALEJ0dIAQpAwhCAlINAAsLIAsQ4iQgBEHQAGokACAKQQhqIBAoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgICAATcCACAHEOIkCyACQdABaiQAAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ykgCkEIQTgQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAgLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQIMBgsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCYHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQogAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJgdIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQmB0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAcLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQMMBQsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCeHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQkgAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJ4dIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQnh0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAYLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQQMBAsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB0AFrIgIkACACQRhqIgwgBxCcHQJAIAIpAxhCAlIEQCACQdQAaiILIAcQrRogC0EEIAIoAlRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQTgQoBggAigCWCEEIAIoAlRBAUYNByACKAJcIg4gDEE4/AoAACACQRRqIhBBATYCACACIA42AhAgAiAENgIMIAsgB0H8APwKAAAjAEHQAGsiBCQAIARBCGogCxCcHSAEKQMIQgJSBEAgAkEMaiEHA0AgBygCCCIMIAcoAgBGBEAgBEHEAGogCxCtGiAHIAwgBCgCREEBaiIOQX8gDhtBCEE4ENAoCyAHKAIEIAxBOGxqIARBCGoiDkE4/AoAACAHIAxBAWo2AgggDiALEJwdIAQpAwhCAlINAAsLIAsQ4iQgBEHQAGokACAKQQhqIBAoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgICAATcCACAHEOIkCyACQdABaiQAAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ykgCkEIQTgQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAULIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQUMAwsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCbHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQcgAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJsdIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQmx0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAQLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQYMAgsgBkE4aiEFIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIJQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQQgASAJNgJgIAEgBDYCXCABIAQ2AlggASAEIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBCADQTBqEPMLIAFBJGogBCADQTxqEPMLIAMoAiAhBCADKAIQIQkgAygCHCEIIAFBADYCaCABIAg2AmAgASAJIAJBDGxqNgJcIAEgCTYCWCABQgA3AsgBIAEgASgCKCIJIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgCTYCvAEgASAJNgK4ASABQgA3ArABIAEgASgCHCIJIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgCTYCpAEgASAJNgKgASABQgA3ApgBIAEgASgCDCIJIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgCTYCjAEgASAJNgKIASABQgA3AoABIAEgBCACIAIgBEsbNgJsIAEgCCAEQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQQjAEGgAWsiAiQAIAJBCDYCACACQSRqIgggAUHYAGpB+AD8CgAAIAIgAjYCnAEgAkEYaiIJIAgQnRMCQCACKAIAQQhHBEAgBCACKQMANwMAIARBEGogAkEQaikDADcDACAEQQhqIAJBCGopAwA3AwAgCRDbGCAJQQhB0AAQ4B4MAQsgBCACKQIYNwIEIARBCDYCACAEQQxqIAJBIGooAgA2AgALIAJBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBEEIRwRAIAEpA1AhHSAFIAEpAzA3AgQgBSAdNwMQIAVBDGogAigCADYCAAwBCyAFIAEpAzA3AgQgBUEMaiACKAIANgIAIAUgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgBSAENgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAMLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQcMAQsgBkE4aiEFIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIJQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQQgASAJNgJgIAEgBDYCXCABIAQ2AlggASAEIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBCADQTBqEPMLIAFBJGogBCADQTxqEPMLIAMoAiAhBCADKAIQIQkgAygCHCEIIAFBADYCaCABIAg2AmAgASAJIAJBDGxqNgJcIAEgCTYCWCABQgA3AsgBIAEgASgCKCIJIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgCTYCvAEgASAJNgK4ASABQgA3ArABIAEgASgCHCIJIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgCTYCpAEgASAJNgKgASABQgA3ApgBIAEgASgCDCIJIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgCTYCjAEgASAJNgKIASABQgA3AoABIAEgBCACIAIgBEsbNgJsIAEgCCAEQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQQjAEGgAWsiAiQAIAJBCDYCACACQSRqIgkgAUHYAGpB+AD8CgAAIAIgAjYCnAEgAkEYaiIIIAkQnRMCQCACKAIAQQhHBEAgBCACKQMANwMAIARBEGogAkEQaikDADcDACAEQQhqIAJBCGopAwA3AwAgCBDFKgwBCyAEIAIpAhg3AgQgBEEINgIAIARBDGogAkEgaigCADYCAAsgAkGgAWokACABQThqIgIgAUHMAGooAgA2AgAgASABKQJENwMwAkAgASgCQCIEQQhHBEAgASkDUCEdIAUgASkDMDcCBCAFIB03AxAgBUEMaiACKAIANgIADAELIAUgASkDMDcCBCAFQQxqIAIoAgA2AgAgBSADKAJINgIQCyADQQxqIgIQ1ysgAhDoOyADQRhqIgMQ1ysgAxDoOyAFIAQ2AgAgAUHQAWokACAGQegBaiIBIAZBxABqKQIANwMAIAYgBikCPDcD4AEgBigCOCIDQQhHBEAgBigCTCECIA0gBikD4AE3AgQgDSACNgIUIA0gAzYCACANQQxqIAEpAwA3AgAMAgsgBkHYAWogBkHoAWopAwA3AwAgBiAGKQPgATcD0AFBCAs2AgQgDSAGKQPQATcCCCANQQg2AgAgDUEQaiAGQdgBaikDADcCAAsgBkEIahCdPCAGQfABaiQADAILIAQgAigCXEHIl88AEP0vAAsgBCACKAJsQciXzwAQ/S8ACyAPKAIUIQEgDygCECIGQQhGDQELIBMoAgBBCEcEQCATEMkjCyATIAE2AgQgEyAGNgIAIBMgFSkDADcDCCATQRBqIBVBCGopAwA3AwBBCQwFCwJAIAFBCUYEQCARIBQ2AggMAQsgD0EIaiAVQQhqKQIANwMAIA8gFSkCADcDACARIBQ2AgggAUEKRw0GCyAXQQFqIRcgFEEBaiEUIBwiASAZRw0ACwtBCiEBDAQLIAIgA0Hs5dAAELE7AAtBAAshASARIBQ2AggLIBYgDykDADcCBCAWQQxqIA9BCGopAwA3AgALIBYgATYCACAPQdAAaiQAIAACf0EJIBIoAhgiAUEKRg0AGiASQRBqIhEgEkEkaikCADcDACASIBIpAhw3AwhBCSABQQlGDQAaIAAgEikDCDcCBCAAQQxqIBEpAwA3AgAgAQs2AgAgEkEwaiQAC34BA38gAigCBCEDIAIoAgAgACABRwRAIAIoAgggA0EDdGohAiADIAEgAGtBA3YiAWohAwNAIAJBBGogAEEEaigCACIFNgIAIAIgACgCACAFKAIIQQFrQXhxakEIajYCACAAQQhqIQAgAkEIaiECIAFBAWsiAQ0ACwsgAzYCAAu3AQEDf0EDIQMgACgCBCICQSBNBEAgACgCCCIBIAAoAhBPBEAgACgCCCIBIAAoAhBJBH9BAwUgACAAKAIEIgJBB3E2AgQgACABIAJBA3ZrIgE2AgggACABKAAANgIAQQALDwsgACgCDCIDIAFGBEBBAkEBIAJBIEYbDwsgACACIAEgA2sgAkEDdiICIAEgAmsgA0kiAxsiAkEDdGs2AgQgACABIAJrIgE2AgggACABKAAANgIACyADC7MBACAAQgA3AqzpASAAQgA3A/DpASAAQYyAgOAANgKoUCAAQQA2ApzrASAAQgA3A4jqASAAQgM3A4DqASAAQbTpAWpCADcCACAAQfjpAWpCADcDACAAQbS10QApAgA3AqzQASAAQbTQAWpBvLXRACgCADYCACAAIABBEGo2AgAgACAAQaAwajYCBCAAIABBmCBqNgIIIAAgAEGo0ABqNgIMIABBAUEFIAAoAuzqARs2ArzpAQumAQEBfyMAQTBrIgIkAAJAAkACQAJAIAFB/wFxDgICAQALIAIgAToADyACQQI2AhQgAkGY+f4ANgIQIAJCATcCHCACQf0LNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBgICAgHg2AgAMAgsgAEGTgICAeDYCACAAQQE6AAQMAQsgAEGTgICAeDYCACAAQQA6AAQLIAJBMGokAAvkBQIGfwN+IwBBMGsiAyQAIANBEGohBiABKAIoIQUjAEGgAWsiAiQAAkACQAJAIAEoAhwiBCABKAIgRwRAAkAgASgCBEUNACAEIAEoAhRPDQIgASgCCCABKAIQIARqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIARBAWo2AhwMAwsgASAEQQFqNgIcIAEoAiQhByACIAEoAgAoAhAgBEEDdGopAwAiCDcDMCACIAcpAwAiCTcDWCACIAg3A1AgAiAIIAhCP4cgCSAJQj+HEKgeIAIpAwggAikDACIIQj+HUQRAQgEhCQwDCyACQQI2AnwgAkHwqIABNgJ4QgIhCSACQgI3AoQBIAJBsRA2ApwBIAJBsRA2ApQBIAIgAkGQAWoiATYCgAEgAiACQdgAajYCmAEgAiACQdAAajYCkAEgAkHoAGogAkH4AGoiBBCZDiACQcQAaiACQewAaikCADcCACACQcwAaiACQfQAaigCADYCACACQYiAgIB4NgJkIAIgAikCZDcCPCACQQE2AjggAkGYAWpBxLKAASgCADYCACACQbyygAEpAgA3A5ABIAJBAjYCfCACQeiygAE2AnggAkICNwKEASACQbEQNgJwIAJBrhA2AmggAiACQeQAajYCgAEgAiACQTBqNgJsIAIgATYCZCACQSBqIAQQmQ4gARCqDCACQThqQQRyEIgRIAIpAyAhCCACKQMoIQogBSgCAEGTgICAeEcEQCAFEIgRCyAFIAo3AgwgBSAINwIEIAVBhoCAgHg2AgAMAgsgBkIDNwMADAILQfSngAFBIEGUqIABEJ8pAAsgBiAINwMQIAYgCjcDCCAGIAk3AwALIAJBoAFqJAAgAAJ+QgIgAykDECIIQgNRDQAaIANBCGoiASADQSBqKQMANwMAIAMgAykDGDcDAEICIAhCAlENABogACADKQMANwMIIABBEGogASkDADcDACAICzcDACADQTBqJAALswMCBn8DfiMAQTBrIgMkACADQRBqIQYgASgCKCEEIwBBIGsiAiQAAkAgASgCHCIFIAEoAiBHBEACQAJ+AkACQAJAIAEoAgRFDQAgBSABKAIUTw0EIAEoAgggASgCECAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASAFQQFqNgIcDAELIAEgBUEBajYCHCACIAEoAgAgBRDaKyACQQhqIAIoAgAgAigCBBDpHCACKAIIIgFBAkcNAQtCAAwBCyABQQFxRQRAIAIpAxghCiACKQMQIQhCAQwBCyACKQMYIQkgAikDECEIIAIoAgwhASAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgILIQkgBiAKNwMQIAYgCDcDCCAGIAk3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBIGokACAAAn5CAiADKQMQIghCA1ENABogA0EIaiIBIANBIGopAwA3AwAgAyADKQMYNwMAQgIgCEICUQ0AGiAAIAMpAwA3AwggAEEQaiABKQMANwMAIAgLNwMAIANBMGokAAuwAwIGfwN+IwBBMGsiAyQAIANBEGohBiABKAIoIQQjAEEgayICJAACQCABKAIcIgUgASgCIEcEQAJAAn4CQAJAAkAgASgCBEUNACAFIAEoAhRPDQQgASgCCCABKAIQIAVqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAVBAWo2AhwMAQsgASAFQQFqNgIcIAIgASAFEK0qIAJBCGogAigCACACKAIEEOkcIAIoAggiAUECRw0BC0IADAELIAFBAXFFBEAgAikDGCEKIAIpAxAhCEIBDAELIAIpAxghCSACKQMQIQggAigCDCEBIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgshCSAGIAo3AxAgBiAINwMIIAYgCTcDAAwCC0H0p4ABQSBBlKiAARCfKQALIAZCAzcDAAsgAkEgaiQAIAACfkICIAMpAxAiCEIDUQ0AGiADQQhqIgEgA0EgaikDADcDACADIAMpAxg3AwBCAiAIQgJRDQAaIAAgAykDADcDCCAAQRBqIAEpAwA3AwAgCAs3AwAgA0EwaiQAC7MDAgZ/A34jAEEwayIDJAAgA0EQaiEGIAEoAighBCMAQSBrIgIkAAJAIAEoAhwiBSABKAIgRwRAAkACfgJAAkACQCABKAIERQ0AIAUgASgCFE8NBCABKAIIIAEoAhAgBWoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBUEBajYCHAwBCyABIAVBAWo2AhwgAiABKAIAIAUQjywgAkEIaiACKAIAIAIoAgQQ6RwgAigCCCIBQQJHDQELQgAMAQsgAUEBcUUEQCACKQMYIQogAikDECEIQgEMAQsgAikDGCEJIAIpAxAhCCACKAIMIQEgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICCyEJIAYgCjcDECAGIAg3AwggBiAJNwMADAILQfSngAFBIEGUqIABEJ8pAAsgBkIDNwMACyACQSBqJAAgAAJ+QgIgAykDECIIQgNRDQAaIANBCGoiASADQSBqKQMANwMAIAMgAykDGDcDAEICIAhCAlENABogACADKQMANwMIIABBEGogASkDADcDACAICzcDACADQTBqJAALiQEBAn8CQCAAIAJBAnRqIgQoAgAiAiADKAIAIgUoAgQiA0kEQCAAIAFBAnRqIgEoAgAiACADTw0BIAEgAiAAIAUoAgAiASACQQJ0aigCACABIABBAnRqKAIASCIBGzYCACAEIAAgAiABGzYCAA8LIAIgA0Gov4MBEMMhAAsgACADQbi/gwEQwyEAC4kBAQJ/AkAgACACQQJ0aiIEKAIAIgIgAygCACIFKAIEIgNJBEAgACABQQJ0aiIBKAIAIgAgA08NASABIAIgACAFKAIAIgEgAkECdGooAgAgASAAQQJ0aigCAEkiARs2AgAgBCAAIAIgARs2AgAPCyACIANBqL+DARDDIQALIAAgA0G4v4MBEMMhAAuJAQECfwJAIAAgAkECdGoiBCgCACICIAMoAgAiBSgCBCIDSQRAIAAgAUECdGoiASgCACIAIANPDQEgASACIAAgBSgCACIBIAJBA3RqKQMAIAEgAEEDdGopAwBTIgEbNgIAIAQgACACIAEbNgIADwsgAiADQai/gwEQwyEACyAAIANBuL+DARDDIQALiQEBAn8CQCAAIAJBAnRqIgQoAgAiAiADKAIAIgUoAgQiA0kEQCAAIAFBAnRqIgEoAgAiACADTw0BIAEgAiAAIAUoAgAiASACQQN0aikDACABIABBA3RqKQMAVCIBGzYCACAEIAAgAiABGzYCAA8LIAIgA0Gov4MBEMMhAAsgACADQbi/gwEQwyEAC4UBAgJ/AX4jAEEwayIBJAAgASAAELMIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAELEIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAELIIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAEJcDAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC5QBAQF/IwBBIGsiBCQAAkAgASgCAEF/IAIgA2oiASABIAJJG08EQEEMQQQQrTYiAUUNASABIAM2AgggAUKBgICAEDcCACAAQbCphgE2AgQgACABNgIAIARBIGokAA8LIARBADYCGCAEQQE2AgwgBEH8qIYBNgIIIARCBDcCECAEQQhqQYSphgEQ7ywAC0EEQQwQoz0AC1cBAn8CQAJAAkAgACgCAA4GAgICAgEAAQsgACgCBCECIAAoAggiACgCACIBBEAgAiABEQMACyAAKAIEIgFFDQAgAiABIAAoAggQ+DoLDwsgAEEEahDeOwuRAQEBfyMAQRBrIgYkACAGIAU2AgwgBiAENgIIIABBLGogBkEIahDELSAAQgI3AhwgAEICNwIQIAAgATsBRiAAIAIgA2oiAjsBRCAAQQA2AgggAEKAgICAwAA3AgAgACAFNgIoIAAgBDYCJCAAIAFB//8DcUVBH3Q2AhggACACQf//A3FFQR90NgIMIAZBEGokAAuKAQEDfyMAQSBrIgIkACABKQMAQgNSBEAgAkEIaiABIAEoAkBBgAgQ1RkgAigCDCEDAkAgAigCCCIEQQhHBEAgACACKQMQNwMIIABBEGogAkEYaikDADcDACAAIAM2AgQMAQsgASADNgJEIAFBADYCSAsgACAENgIAIAJBIGokAA8LQbSwzgAQsjsAC34BAX8jAEEQayIDJAAgA0EEaiAAKAIMIgBBCGogACgCCEECRkECdGoiABCJGQJ/AkAgAy0ABEEIRw0AIAMtAAYNACABKQMAIAIpAwBWDAELIAAtACFBHHFBDEYEQCABKQMAIAIpAwBWDAELIAEpAwAgAikDAFULIANBEGokAAt/AQZ/IAAoAggiBARAIAAoAgQhBQNAIAUgAkHQAGxqIgFBMGogASgCOCIDBEAgASgCNCEAA0AgABDYEyAAQegDaiEAIANBAWsiAw0ACwtBCEHoAxDgHiABKAI8QYCAgIB4RwRAIAFBPGpBBEEIEOAeCyACQQFqIgIgBEcNAAsLC+8NAhd/BX4jAEFAaiIJJAAgAEEoaiIEIAEgAhDNAiEcIAkgADYCECAJIAI2AgwgCSABNgIIIAlBGGohCCAJQQhqIQ0jAEEQayISJAAgAEEYaiIFKAIIRQRAIBJBCGohGSMAQfAAayIDJAAgAyAANgIsIAMgBDYCKCAFKAIMIQQgAyADQShqNgIwAkACQAJAAkAgBCAEQQFqIgZNBEAgBSgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiAGSQRAIARBAWoiBCAGIAQgBksbIgRBD0kNAiAEQf////8BTQRAQX8gBEEDdEEHbkEBa2d2QQFqIQoMBAsQ3ScgAygCJCEKIAMoAiAiC0GBgICAeEcNBQwDCyAFIANBMGpBtKbPABDrCQwDCxDdJyADKAIMIQogAygCCCELDAMLQQRBCEEQIARBCEkbIARBBEkbIQoLIANB4ABqIAVBEGoiBkEIIAoQ+xQgAygCaCEKIAMoAmQhCyADKAJgIgRFDQEgAyADKAJsNgJcIAMgCjYCWCADIAs2AlQgAyAENgJQIANBGGogA0HQAGoQwTQgAygCHCIEBEAgAygCGEH/ASAE/AsACyADKAJYIQogAygCVCELIAMoAlAiDkUNASADIAMoAlw2AkwgAyAKNgJIIAMgCzYCRCADIA42AkAgA0KIgICAgAE3AjggAyAGNgI0IANBQGshEyADIAUoAgwiDwR/IA5BCGohByAFKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCAVQQhqIRUgEUEIaiIRKQMAQoCBgoSIkKDAgH+DIhtCgIGChIiQoMCAf1ENAAsgG0KAgYKEiJCgwIB/hSEaCyADKAIwIgYoAgAhBCADQRBqIAYoAgQgBSgCACAaeqdBA3YgFWpBA3QiDGtBCGspAwAQ8h0gDiALIAQgAygCECADKAIUEM0CpyIGcSIQaikAAEKAgYKEiJCgwIB/gyIbUARAQQghFgNAIBAgFmohBCAWQQhqIRYgDiAEIAtxIhBqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogDiAbeqdBA3YgEGogC3EiEGosAABBAE4EQCAOKQMAQoCBgoSIkKDAgH+DeqdBA3YhEAsgDiAQaiAGQRl2IgQ6AAAgByAQQQhrIAtxaiAEOgAAIA4gEEEDdGtBCGsgBSgCACAMa0EIaykAADcAACAPQQFrIg8NAAsgBSgCDAVBAAsiBDYCTCADIAogBGs2AkggBSATQQQQ+iogA0E0ahD1JwtBgYCAgHghCwsgGSAKNgIEIBkgCzYCACADQfAAaiQACyAFKAIEIhEgHKdxIQ8gHEIZiEL/AINCgYKEiJCgwIABfiEeIA0oAgghByANKAIEIQwgDSgCACEGIAUoAgAhEwNAAkAgDyATaikAACIdIB6FIhtCf4UgG0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAIAn4CQANAIBpQDQEgEiAHIAUoAgAgGnqnQQN2IA9qIBFxIgRBA3RrQQhrKQMAEPIdIBpCAX0gGoMhGiAGIAwgEigCACASKAIEEJ87RQ0ACyAIIBw3AwggCCAFKAIAQQAgBGtBA3RqNgIQQgAMAQsgHUKAgYKEiJCgwIB/gyEbIBdFBEAgG1ANAiAbeqdBA3YgD2ogEXEhFAtBASAbIB1CAYaDUA0CGiAIIBMgFGosAABBAE4EfyATKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAggHDcDCEIBCzcDACAIIAU2AhQgEkEQaiQADAILQQALIRcgDyAYQQhqIhhqIBFxIQ8MAQsLIAkgAjYCPCAJIAE2AjggCSAANgI0IAlBNGohAQJAIAgoAgBBAUYEQCAIKQMIIRsgCCgCECEGIAgoAhQhDCABKAIAIQcgASgCBCEAIAEoAgghASMAQRBrIgQkACAHNQIUIRwgByABQQRqEOUtIAQgATYCDCAHIARBDGpBBBChNiAHKAIIIQIgByAAIAEQoTYgBygCCCEBIAcoAhQiCCAHKAIMRgRAIAdBDGpB0PjNABCbKAsgBygCECAIQQN0aiIAIAE2AgQgACACNgIAIAcgCEEBajYCFCAEQRBqJAAgBiAMKAIAIgJqIgAtAAAhASAAIBunQRl2IgA6AAAgAiAMKAIEIAZBCGtxakEIaiAAOgAAIA0gDDYCDCANIBs3AwAgDCAMKAIMQQFqNgIMIA0gAiAGQQN0ayIANgIIIAwgDCgCCCABQQFxazYCCCAAQQhrIBw3AwAMAQsgDSAIQQhqIgApAwA3AwAgDUEIaiAAQQhqKQMANwMACyAJKAIQQQhrKQMAIAlBQGskAAuVAQEEfyMAQSBrIgIkACACQQhqEP0nIAAoAhQhAyACKAIIIQQgACACKAIMNgIUIAAoAhAhBSAAIAQ2AhAgASAFIAMQ4DUgAkEANgIcIAJCgICAgCA3AhQgAiACQRRqQYyHzgAQqiEgACgCHCEBIAAoAhghAyAAIAIpAwA3AhggAQRAIAMgAUEBdEECEPg6CyACQSBqJAALlwIBBn8jAEEgayIDJAAgA0EUaiABQQBBAkEEEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQcSo+wAQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyACNgIIIANBCGoiBSgCACAFKAIIIgJrIAFJBEAgBSACIAFBAhDOKCAFKAIIIQILIAUoAgQgAkECdGohBAJAAkAgAUECTwRAIAFBAWshBgNAIARBADsBACAEQQJqQQA6AAAgBEEEaiEEIAZBAWsiBg0ACyABIAJqQQFrIQIMAQsgAUUNAQsgBEEAOgACIARBADsBACACQQFqIQILIAUgAjYCCCAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuRAQECfyMAQTBrIgIkAAJ/IAAoAgAiAwRAIAIgACgCBDYCDCACIAM2AgggAkEBNgIUIAJBjMH7ADYCECACQgE3AhwgAkHHAjYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDAELIAEoAgBB2MD7AEEZIAEoAgQoAgwRBgALIAJBMGokAAt4AQJ/IAAoAggiA0EATwRAIAAoAgAgA0YEQCAAIAIQkCgLIAAoAgQhAgJAIANFDQAgA0EMbCIERQ0AIAJBDGogAiAE/AoAAAsgAiABKQIANwIAIAJBCGogAUEIaigCADYCACAAIANBAWo2AggPC0EAIAMgAhDCIQALlwECAX4CfwJAIAApAwAiAVBFBEAgACgCECECDAELIAAoAhAhAiAAKAIIIQMDQCACQcABayECIAMpAwAgA0EIaiEDQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgACACNgIQIAAgAzYCCCABQoCBgoSIkKDAgH+FIQELIAAgAUIBfSABgzcDACACIAF6p0EDdkFobGoLewIEfgF/IAApAwAiBCABKQMAIgVWIAApAwgiAiABKQMIIgNWIAIgA1EiBhsgBCAFVCACIANUIAYbayAAKQMQIgQgASkDECIFViAAKQMYIgIgASkDGCIDVSACIANRIgAbIAQgBVQgAiADUyAAG2sgBCAFhSACIAOFhFAbC4kCAQV/IwBBIGsiAiQAIAJBDGohAwJAAkAgASgCBCIGBEAgASgCCCEFQRhBBBCtNiIERQ0BIARCgYCAgBA3AgAgAyAFNgIQIANBsPmHATYCDCADIAQ2AgggAyAFNgIEIAMgBjYCACAEIAEpAgA3AgggBEEQaiABQQhqKQIANwIADAILQaD5hwEQsjsAC0EEQRgQoz0ACyACKAIMIQMgAigCECEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC4YBAQN/AkAgACgCGEGAgICAeEcEQCAAQRhqEN47DAELIAAoAhAhAiAAKAIUIgEoAgAiAwRAIAIgAxEDAAsgASgCBCIDRQ0AIAIgAyABKAIIEPg6CyAAKAIoIQIgACgCLCIAKAIAIgEEQCACIAERAwALIAAoAgQiAQRAIAIgASAAKAIIEPg6CwuOAQECfyMAQdADayICJAAgAiAAEJUaIAFBCEkEQCACQZgBaiIAIAJBmAH8CgAAIAFBAnQiAUH8g8MAaigCACEDIAAgAUHcg8MAaigCADYCJCAAIAM2AiAgAkG4AmogAEGYAfwKAAAgAkEANgKwAiACQbACahDRKUEIaiACQdADaiQADwtB5ILDAEEZEJc9AAueAgEGfyMAQSBrIgIkACACQRRqIAFBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxByP7CABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIGJAAgBkEANgIMIAJBCGoiBCgCACAEKAIIIgNrIAFJBEAgBCADIAFBBEEEENAoIAQoAgghAwsgBCgCBCADQQJ0aiEFAkACQCABQQJPBEAgAUEBayIBIANqIQMDQCAFQQA2AgAgBUEEaiEFIAFBAWsiAQ0ACwwBCyABDQAgBCADNgIIDAELIAVBADYCACAEIANBAWo2AggLIAZBEGokACAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAuHAQEBfwJAIAEEQCABQQhrIgIoAgBBAUcNASAAIAEpAgQ3AgAgAEEQaiABQRRqKAIANgIAIABBCGogAUEMaikCADcCACACQQA2AgACQCACQX9GDQAgAUEEayIAIAAoAgBBAWsiADYCACAADQAgAkEgQQQQ+DoLDwsQmD0AC0GX2sMAQT8Qlz0AC5QCAQZ/IwBBIGsiBCQAIARBFGogAkEAQQRBiAgQoBggBCgCGCEDIAQoAhRBAUYEQCADIAQoAhxBxJ7QABD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAM2AgggBEEIaiIFKAIAIAUoAggiA2sgAkkEQCAFIAMgAkEEQYgIENAoIAUoAgghAwsgBSgCBCADQYgIbGohBgJAAkAgAkECTwRAIAJBAWshBwNAIAYgAUGICPwKAAAgBkGICGohBiAHQQFrIgcNAAsgAiADakEBayEDDAELIAJFDQELIAYgAUGICPwKAAAgA0EBaiEDCyAFIAM2AgggAEEIaiAIKAIANgIAIAAgBCkCCDcCACAEQSBqJAALlAIBBn8jAEEgayIEJAAgBEEUaiACQQBBBEGIERCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBiBEQ0CggBSgCCCEDCyAFKAIEIANBiBFsaiEGAkACQCACQQJPBEAgAkEBayEHA0AgBiABQYgR/AoAACAGQYgRaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNAQsgBiABQYgR/AoAACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuuAgEGfyMAQSBrIgQkACAEQRRqIAJBAEEEQRAQoBggBCgCGCEDIAQoAhRBAUYEQCADIAQoAhxBxJ7QABD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAM2AgggBEEIaiIGKAIAIAYoAggiA2sgAkkEQCAGIAMgAkEEQRAQ0CggBigCCCEDCyAGKAIEIANBBHRqIQUCQAJAIAJBAk8EQCACQQFrIQcDQCAFIAEpAgA3AgAgBUEIaiABQQhqKQIANwIAIAVBEGohBSAHQQFrIgcNAAsgAiADakEBayEDDAELIAJFDQELIAUgASkCADcCACAFQQhqIAFBCGopAgA3AgAgA0EBaiEDCyAGIAM2AgggAEEIaiAIKAIANgIAIAAgBCkCCDcCACAEQSBqJAALlAIBBn8jAEEgayIEJAAgBEEUaiACQQBBBEGIFhCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBiBYQ0CggBSgCCCEDCyAFKAIEIANBiBZsaiEGAkACQCACQQJPBEAgAkEBayEHA0AgBiABQYgW/AoAACAGQYgWaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNAQsgBiABQYgW/AoAACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuDAQEFfyABIAAoAgAiBC8BBiICIAAoAggiA0F/c2oiADsBBgJAIABBDEkEQCACIANBAWoiAmsgAEcNASAEQQhqIgUgA2otAAAgAARAIAFBCGogAiAFaiAA/AoAAAsgBCADOwEGDwsgAEELQfS3zQAQsDsAC0G8t80AQShB5LfNABCfKQALgAEBA38gACgCACAAKAIIIgJrIAFJBEAgACACIAFBAUEBENAoIAAoAgghAgsgACgCBCIEIAJqIQMCQAJAIAFBAk8EQCABQQFrIgEEQCADQQAgAfwLAAsgBCABIAJqIgJqIQMMAQsgAUUNAQsgA0EAOgAAIAJBAWohAgsgACACNgIIC4YBAQN/IwBBIGsiAyQAIANBFGogAkEAQQRBIBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEHEntAAEP0vAAsgA0EQaiIFQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqIAIgARCUFCAAQQhqIAUoAgA2AgAgACADKQIINwIAIANBIGokAAuCAQEDfyAAKAIAIgFBDGogASgCFCICBEAgASgCECEAA0AgAEEMaiAAQQRqKAIAIABBCGooAgAgACgCACgCEBEBACAAQRBqIQAgAkEBayICDQALC0EEQRAQ4B4CQCABQX9GDQAgASABKAIEIgBBAWs2AgQgAEEBRw0AIAFBHEEEEPg6CwuYAgIGfwF+IwBBIGsiBCQAIARBFGogAkEAQQRBCBCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBCBDQKCAFKAIIIQMLIAUoAgQgA0EDdGohBgJAAkAgAkECTwRAIAJBAWshByABKQIAIQkDQCAGIAk3AgAgBkEIaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNASABKQIAIQkLIAYgCTcCACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuJAQECfyABQYACTwRAIAAgARDxEA8LAn9BwPOKASgCACICQQEgAUEDdnQiA3FFBEBBwPOKASACIANyNgIAIAFB+AFxQbjxigFqIgEMAQsgAUH4AXFBqPCKAWoiAkGQAWohASACQZgBaigCAAshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggLhAEBAX8jAEEwayIBJAAgASAAOgAPIABB/wFxIgBBDk9B+fsAIAB2QQFxRXJFBEAgAEH8pP4Aai0AACABQTBqJAAPCyABQQI2AhQgAUHApP4ANgIQIAFCATcCHCABQbALNgIsIAEgAUEoajYCGCABIAFBD2o2AiggAUEQakHQpP4AEO8sAAu2AQEDfyAAKAIAIAAoAggiAmsgAUkEQCMAQRBrIgMkACADQQhqIAAgAiABQQFBARC3ESADKAIIIgJBgYCAgHhHBEAgAiADKAIMQdyB/wAQ/S8ACyADQRBqJAAgACgCCCECCyAAKAIEIgQgAmohAwJAAkAgAUECTwRAIAFBAWsiAQRAIANBACAB/AsACyAEIAEgAmoiAmohAwwBCyABRQ0BCyADQQA6AAAgAkEBaiECCyAAIAI2AggLfgEBfwJAIAAoAiBB/wdxQe8GRw0AIAAtAARB/QFHDQAgAC0AB0H9AUcNACAALQADIAAtAAFB5ABsIAAtAABB6AdsaiAALQACQQpsampB//8DcSAALQAGIAAtAAVBCmxqQf8BcSAALQAJIAAtAAhBCmxqQf8BcRCOJyEBCyABC4ABAgN/AX4jAEEgayIDJAAgA0EIaiIEIAEgAhCBBAJAIAMoAggiBUEBRgRAIAUEQCAEQQRyEIgRCyADQQhqIAEgAhCbCiAAIAMtAAgEfiAGBSAAIAMpAxA3AwhCAQs3AwAMAQsgACADKQMQQugHfzcDCCAAQgE3AwALIANBIGokAAt6AQR/IwBBIGsiAyQAIANBCGoiBSABIAIQgQRBASEEIAACfyADKAIIIgZBAUYEQCAGBEAgBUEEchCIEQsgA0EIaiABIAIQzwogAy0ACEF/c0EBcSEEIAMoAgwMAQsgAykDEELAhD1/pws2AgQgACAENgIAIANBIGokAAt8AQR/IwBBIGsiAyQAIANBCGoiBSABIAIQgQRBASEEIAACfyADKAIIIgZBAUYEQCAGBEAgBUEEchCIEQsgA0EIaiABIAIQzwogAy0ACEF/c0EBcSEEIAMoAgwMAQsgAykDEEKAlOvcA3+nCzYCBCAAIAQ2AgAgA0EgaiQAC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQqgYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCqBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDwBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDwBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkLygQBB38jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCAJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIFRQ0AQQogBSAFQQpPGyEHQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMQHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByADQQFqIgNHDQALIAVBC0kNASAFQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAHIAMgB0sbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDEBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCAsgBEEwaiQAIAgL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC9Bg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC9Bg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDxBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPEGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJ4LDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJ4LDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPMGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPMGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO4GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO4GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvKBAEHfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEIAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgVFDQBBCiAFIAVBCk8bIQdBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQwwcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIANBAWoiA0cNAAsgBUELSQ0BIAVBFU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAcgAyAHSxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMMHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEICyAEQTBqJAAgCAvSBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBBEkNAEEKIAdBAnYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIkHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBLEkNASAHQdQATwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQiQcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EQSQ0AQQogB0EEdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQogoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0GwAUkNASAHQdACTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQogoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQwgsNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDCCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDtBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDtBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDyBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDyBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC2Aw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC2Aw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0QQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQJJDQBBCiAHQQF2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCHBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQRZJDQEgB0EqTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQhwcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EISQ0AQQogB0EDdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7QoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0HYAEkNASAHQagBTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7QoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EISQ0AQQogB0EDdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQkwYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0HYAEkNASAHQagBTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQkwYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9EEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0ECSQ0AQQogB0EBdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQhQcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EWSQ0BIAdBKk8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIUHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELUDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELUDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIsGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBsAFJDQEgB0HQAk8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIsGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvRBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBAkkNAEEKIAdBAXYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMELDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBFkkNASAHQSpPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDBCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCIBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIgHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIYHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIYHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELQDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELQDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELMDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELMDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIMEDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIMEDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvSBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBBEkNAEEKIAdBAnYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO8GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBLEkNASAHQdQATwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7wYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQggQNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCCBA0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCUBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCUBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQSBJDQBBCiAHQQV2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCbBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQeACSQ0BIAdBoAVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCbBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCWBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJYGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQuaCgEIfyMAQYABayIJJAAgCUEEaiEHIwBB0ABrIgYkACAGIAE2AgggBiACKAIIIgpBAnZBAWsiCzYCDAJAAkACQAJAAkACQAJAAkAgCkEESQ0AIAIoAgQgCkF8cWpBBGsiCEUNACADKAIYIQogBiAIKAIAIgg2AhACQCAIIApNBEACQCAEKAIAIgoEQCALIAQoAhAiCEcNAQsgAS0ASEUEQCADKAIcRQ0DIAMoAjBFDQMLIAZBNGpBJUEAQQFBARCgGCAGKAI4IQEgBigCNEEBRg0EIAYoAjwiBUG03IUBQSX8CgAAIAdBJTYCECAHIAU2AgwgByABNgIIIAdCgICAgNiBgICAfzcCAAwHCyAGIAg2AkwgBkECNgI4IAZBuNuFATYCNCAGQgI3AkAgBkE7NgIgIAZBOzYCGCAGIAZBFGo2AjwgBiAGQcwAajYCHCAGIAZBDGo2AhQgB0EIaiAGQTRqEJkOIAdCgICAgNiBgICAfzcCAAwHCyAGIAo2AkwgBkECNgI4IAZB9NyFATYCNCAGQgI3AkAgBkE7NgIgIAZBOzYCGCAGIAZBFGo2AjwgBiAGQcwAajYCHCAGIAZBEGo2AhQgB0EIaiAGQTRqEJkOIAdCgICAgNiBgICAfzcCACAEKAIAIQoMBQsgAUEwaiILIANBDGoiCBDFCEUNAiADKAIIIgtBAkcNAyAHIAQpAgA3AkwgB0HcAGogBEEQaikCADcCACAHQdQAaiAEQQhqKQIANwIAIAcgA0E0/AoAACAHIAE2AjggByAFOgA1IAdBJzoANCAHQcgAaiACQQhqKAIANgIAIAcgAikCADcCQAwHC0Hw2oUBELI7AAsgASAGKAI8QcTShQEQ/S8ACyAGIAs2AiwgBiAINgIwIAYgAUE8ajYCTCAGQQM2AhggBkGc3IUBNgIUIAZCAzcCICAGQcoENgJIIAZBpwQ2AkAgBkGnBDYCOCAGIAZBNGo2AhwgBiAGQcwAajYCRCAGIAZBMGo2AjwgBiAGQSxqNgI0IAdBCGogBkEUahCZDiAHQoCAgIDYgYCAgH83AgAMAQsgBkEBNgI4IAZB+NuFATYCNCAGQgE3AkAgBkE7NgIYIAYgCzYCTCAGIAZBFGo2AjwgBiAGQcwAajYCFCAHQQhqIQsjAEEQayIBJAAgBkE0aiIFKAIMIQgCQAJAAkACQAJAAkACQCAFKAIEDgIAAQILIAgNAUEBIQhBACEFDAILIAgNACAFKAIAIggoAgQhBSAIKAIAIQgMAQsgCyAFEJkODAELIAFBBGogBUEAQQFBARCgGCABKAIIIQwgASgCBEEBRg0BIAEoAgwhDSAFBEAgDSAIIAX8CgAACyALIAU2AgggCyANNgIEIAsgDDYCAAsgAUEQaiQADAELIAwgASgCDEHE0oUBEP0vAAsgB0KAgICA2IGAgIB/NwIACyAKRQ0BCyAKIAooAgAiAUEBazYCACABQQFHDQAgBBD7HgsgAxDWKCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAGKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNACAGQQhqEPIlCyAGQdAAaiQAIAkoAgRBgICAgHhHBEAgACAHQeQA/AoAACAJQYABaiQADwsgCUH4AGogCUEYaigCADYCACAJQfAAaiAJQRBqKQIANwMAIAkgCSkCCDcDaEGsz4UBQSsgCUHoAGpBnM+FAUGE3YUBENUeAAuEAQEEfyMAQRBrIgIkACAAKAIMIgMgACgCBCIBRwRAIAMgAWtBA3YhAwNAIAEoAgAiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAEQuyMLIAFBCGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEEQQgQ4B4gAkEQaiQAC4UBAQJ/IwBB0ABrIgYkACAGQQRqIgcgASACIAMgBCAFEOEGIAYtAARBKUcEQCAAIAdBNPwKAAAgBkHQAGokAA8LIAZByABqIAZBGGooAgA2AgAgBkFAayAGQRBqKQIANwMAIAYgBikCCDcDOEH0m4YBQSsgBkE4akHkm4YBQcyjhgEQ1R4AC3kBA38jAEGAAWsiAyQAIAAvAQAhBEEAIQADQCAAIANqQf8AaiAEQQ9xIgJBMHIgAkHXAGogAkEKSRs6AAAgAEEBayEAIAQiAkEEdiEEIAJBD0sNAAsgAUEBQeDziQFBAiAAIANqQYABakEAIABrEIEJIANBgAFqJAALeAEDfyMAQYABayIDJAAgAC0AACEEQQAhAANAIAAgA2pB/wBqIARBD3EiAkEwciACQTdqIAJBCkkbOgAAIABBAWshACAEIgJBBHYhBCACQQ9LDQALIAFBAUHg84kBQQIgACADakGAAWpBACAAaxCBCSADQYABaiQAC3kBA38jAEGAAWsiAyQAIAAtAAAhBEEAIQADQCAAIANqQf8AaiAEQQ9xIgJBMHIgAkHXAGogAkEKSRs6AAAgAEEBayEAIAQiAkEEdiEEIAJBD0sNAAsgAUEBQeDziQFBAiAAIANqQYABakEAIABrEIEJIANBgAFqJAALeAEDfyMAQYABayIDJAAgAC8BACEEQQAhAANAIAAgA2pB/wBqIARBD3EiAkEwciACQTdqIAJBCkkbOgAAIABBAWshACAEIgJBBHYhBCACQQ9LDQALIAFBAUHg84kBQQIgACADakGAAWpBACAAaxCBCSADQYABaiQAC3oCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUHg84kBQQIgACAEakGAAWpBACAAaxCBCSAEQYABaiQAC3kCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJIARBgAFqJAALggEBAn8jAEEQayICJAAgAEEAENgtIAJBCGogAUEIaigCACIDNgIAIAIgASkCADcDAAJAIANBAXENAANAIAIQ7hIiAUHcAEcgAUEvR3ENASAAKAIIIQMgAEEBENgtIAAoAgQgACgCCGogAToAACAAIANBAWo2AggMAAsACyACQRBqJAALgwEBA38jAEEQayICJAAgACgCDCIDIAAoAgQiAUcEQCADIAFrQQR2IQMDQCABQQxqIAFBBGooAgAgAUEIaigCACABKAIAKAIQEQEAIAFBEGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEEQRAQ4B4gAkEQaiQAC3cBAn8gACgCWEGAgICAeEcEQCAAKAJgIgJBA3YgAkEHcUEAR2oiAkEgIAAoAkgiAEEBayIBQQAgACABTxtnIgBrIgFBA3YgAUEHcUEAR2pBAWpsIgEgAkEhIABrbCIAIAAgAUkbDwsgACgCaCAAKAJsKAIUEQQAC3cBAn8gACgCaEGAgICAeEcEQCAAKAJwIgJBA3YgAkEHcUEAR2oiAkEgIAAoAlgiAEEBayIBQQAgACABTxtnIgBrIgFBA3YgAUEHcUEAR2pBAWpsIgEgAkEhIABrbCIAIAAgAUkbDwsgACgCeCAAKAJ8KAIUEQQAC3oBAn8gACgCeEGAgICAeEcEQCAAKAKAASICQQN2IAJBB3FBAEdqIgJBICAAKAJoIgBBAWsiAUEAIAAgAU8bZyIAayIBQQN2IAFBB3FBAEdqQQFqbCIBIAJBISAAa2wiACAAIAFJGw8LIAAoAogBIAAoAowBKAIUEQQAC4YBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQgAygCBEEBRwRAIAMoAgwhBSACBEAgBSABIAL8CgAACyADIAI2AgwgAyAFNgIIIAMgBDYCBCAAQQRqIANBBGoQ5xUgAEEINgIAIANBEGokAA8LIAQgAygCDEGch84AEP0vAAt/AgJ/AX4jAEEgayICJAAgAkEIaiABEMsTQQEhAQJ/IAIoAghBAUYEQCACKQMYIQQgAigCDCEDIAAgAikDEDcDCCAAIAM2AgRBEAwBCyACKQMQIgRCAYhCACAEQgGDfYUhBEEAIQFBCAsgAGogBDcDACAAIAE2AgAgAkEgaiQAC4EBAgN/AX4gASgCHCEDIAFBADYCHCABIAEoAhggA0EDdmogA0EHcUEAR2oiAzYCGAJAIAAgAiADaiIFIAEoAggiBE0EfiADIARLDQEgACACIAEoAgQgA2ogBCADaxDZIjcDCCABIAU2AhhCAQUgBgs3AwAPCyADIARB6LrOABCvOwALhwEBAX8jAEEgayIFJAACQCADIARxIgMgAk0EQCABIANqIAIgA2sQtx4iASAAKAIEIgJJDQEgASACQbTNzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakGkzc4AEO8sAAsgACgCACABQQJ0aiAENgIAIAVBIGokAAvNBQIMfwF+IwBBMGsiASQAAn8gACgCACICRQRAQQAhAEEADAELIAEgAjYCGCABQQA2AhQgASACNgIIIAFBADYCBCABIAAoAgQiAjYCHCABIAI2AgwgACgCCCEAQQELIQIgASAANgIgIAEgAjYCECABIAI2AgADQCABQSRqIQojAEEQayIFJAACQCABKAIgIgBFBEAgASgCACABQQA2AgBBAXEEQCABKAIMIQAgASgCCCECAkAgASgCBCIEBEAgBSACNgIIIAUgBDYCBAwBCyAABEADQCACKAIUIQIgAEEBayIADQALC0EAIQAgBUEANgIIIAUgAjYCBAsgBSAANgIMIwBBEGsiACQAIABBBGogBUEEaiICKAIAIAIoAgQQ8CYDQCAAKAIEIgIEQCAAQQRqIAIgACgCCBDwJgwBCwsgAEEQaiQACyAKQQA2AgAMAQsgASAAQQFrNgIgIAEQzSMiCARAIwBBMGsiAyQAIANBCGohBiMAQRBrIgkkACAIKAIEIQACQAJAIAgoAggiCyAIKAIAIgQvAQZPBEADQCAJQQRqIAQgABDwJiAJKAIEIgRFDQIgCSgCCCEAIAkoAgwiCyAELwEGTw0ACwsgC0EBaiEHAkAgAEUEQCAEIQIMAQsgBCAHQQJ0akEUaiEHIAAhDANAIAcoAgAiAkEUaiEHIAxBAWsiDA0AC0EAIQcLIAYgCzYCFCAGIAA2AhAgBiAENgIMIAYgBzYCCCAGQQA2AgQgBiACNgIADAELIAZBADYCAAsgCUEQaiQAIAMoAggEQCAKIAMpAhQ3AgAgA0EoaiADQRBqKAIAIgA2AgAgCkEIaiADQRxqKAIANgIAIAMgAykCCCINNwMgIAhBCGogADYCACAIIA03AgAgA0EwaiQADAILQdy4zQAQsjsAC0G44NAAELI7AAsgBUEQaiQAIAEoAiQNAAsgAUEwaiQAC3sBAX8gASgCACICBEAgACACNgIACyABKAIIIgIEQCAAIAI2AggLIAEoAgQiAgRAIAAgAjYCBAsgASgCDCICBEAgACACNgIMCyABKAIQIgIEQCAAIAI2AhALIAEoAhQiAgRAIAAgAjYCFAsgASgCGCIBBEAgACABNgIYCwuWAQEGfwJAIAAoApjrAUUNACAAKAKo6wEiAiAAKALc6QEiAxCzKSEBIAIoAgRBAWshBANAIAMgAigCACABIgVBAnRqKAIAEI42IgZHBEAgASAEcUEBaiEBIAYNAQsLIAIoAgAgBUECdGooAgAiAUUNACAAEPwwIABBfzYCpOsBIAAgATYCmOsBIAAgACgC3OkBNgKc6wELC4cBAQN/AkACQCACQQFrIgIgAUsEQEHABSABIAFBwAVNGyEEA0AgASAERg0CIAJBwAVPDQMgACABaiIDLQAAIQUgAyAAIAJqIgMtAAA6AAAgAyAFOgAAIAFBAWoiASACQQFrIgJJDQALCw8LIARBwAVB8JPSABDDIQALIAJBwAVB8JPSABDDIQALVgECfwJAIAIEQANAIAEgCEYNAiAAIAhqLQAAIQkgAyAJai0AACAEIAlBAXRqMwEAIAUgBiAHEN8TIAIgCEEBaiIIRw0ACwsPCyABIAFBtJbzABDDIQALmQEBAX8jAEEgayICJAAgAkEANgIIIAJCgICAgBA3AgAgAkH4qP4ANgIQIAJCoICAgA43AhQgAiACNgIMIAFBDGogAkEMahDQFgRAQaCp/gBBNyACQR9qQZCp/gBB2Kn+ABDVHgALIAAgAikCADcCBCAAQQxqIAJBCGooAgA2AgAgAEEBNgIAIABBAToAECABEN47IAJBIGokAAuEAQEBfyAAEMAMIABBDGoQwAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQuyMLC+gFAQp/IwBBMGsiAyQAIANBBTYCDCADQZDVhQE2AgggA0ECNgIUIANB3NqFATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCgJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAhxBA3YiC0EBayIHRQ0AQQogByAHQQpPGyEGAkADQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIEZIAIgAigCFCIJNgIgIAIgAigCECIFNgIcIAUgCSgCCEEBa0F4cWpBCGogASAJKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAHQQtJDQEgB0EVTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAtBFWs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyALQQtrIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEEIEZIAIgAigCDCIFNgIgIAIgAigCCCIGNgIcIAYgBSgCCEEBa0F4cWpBCGogASAFKAIMEQIAIAYgBigCACIGQQFrNgIAIAZBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQgMAQtBACEICyACQUBrJAAgCA0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCgsgA0EwaiQAIAoLhwEBAn8jAEHQAGsiBSQAIAVBBGoiBiABIAIgAyAEEOUPIAUoAgRBgICAgHhHBEAgACAGQTT8CgAAIAVB0ABqJAAPCyAFQcgAaiAFQRhqKAIANgIAIAVBQGsgBUEQaikCADcDACAFIAUpAgg3AzhBgOuFAUErIAVBOGpB8OqFAUH88YUBENUeAAvpBQEKfyMAQTBrIgMkACADQQU2AgwgA0HUj4YBNgIIIANBAjYCFCADQfSWhgE2AhAgA0IBNwIcIANBxwI2AiwgAyADQShqNgIYIAMgA0EIajYCKEEBIQsCQCABKAIAIAEoAgQgA0EQahDLCg0AIwBBQGoiAiQAAkACQCAAKAIoIgVBCEkNAEEKIAVBA3YiByAHQQpPGyEGAkADQAJAIAAgBBCXJUUEQEEBIQkgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEELMZIAIgAigCFCIKNgIgIAIgAigCECIINgIcIAggCigCCEEBa0F4cWpBCGogASAKKAIMEQIAIAggCCgCACIIQQFrNgIAIAhBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAFQdgASQ0BIAVBqAFPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgB0EUazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAdBCmsiBCAGIAQgBksbIgQgB08NAQNAAkAgACAEEJclRQRAQQEhCSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQsxkgAiACKAIMIgY2AiAgAiACKAIIIgU2AhwgBSAGKAIIQQFrQXhxakEIaiABIAYoAgwRAgAgBSAFKAIAIgVBAWs2AgAgBUEBRgRAIAJBHGoQuyMLDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBEEBaiIEIAdHDQALDAELQQEhCQwBC0EAIQkLIAJBQGskACAJDQAgASgCAEGUkIYBQQEgASgCBCgCDBEGACELCyADQTBqJAAgCwuLAQECfyMAQeAAayICJAAgAUEBOgBZIAJBBGoiAyABEN8HIAIoAgRBgICAgHhHBEAgACADQcQA/AoAACACQeAAaiQADwsgAkHYAGogAkEYaigCADYCACACQdAAaiACQRBqKQIANwMAIAIgAikCCDcDSEHo2oYBQSsgAkHIAGpBlNuGAUG8hIcBENUeAAumAQIBfwJ+IwBBEGsiAyQAAn5B+POKASgCAEEBRgRAQYj0igEpAwAhBEGA9IoBKQMADAELIAMQ4yZB+POKAUIBNwMAQYj0igEgAykDCCIENwMAIAMpAwALIQUgACACNgIEIAAgATYCACAAIAQ3AyAgACAFNwMYQYD0igEgBUIBfDcDACAAQejchwEpAwA3AwggAEEQakHw3IcBKQMANwMAIANBEGokAAt+AQN/AkACQCAAKAIAIgIgASgCACIDRg0AIAAoAgQiBCABKAIERw0BIARFDQAgAkEIaiEBIANBCGohAANAIAEoAgAiAiAAKAIAIgNHBEAgAkEIaiADQQhqEPEKRQ0DCyABQQRqIQEgAEEEaiEAIARBAWsiBA0ACwtBAQ8LQQALfwEEfyMAQRBrIgIkACAAKAIMIgQgACgCBCIBa0HIAG4hAyABIARHBEADQCABQTRqQQFBARDgHiABQShqENMMIAEQkycgAUHIAGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEIQcgAEOAeIAJBEGokAAuHAQEBfyMAQUBqIgMkACADIAI2AgQgAyABNgIAIANBKGogAEEIaikDADcDACADIAApAwA3AyAgA0ECNgIMIANB1LCIATYCCCADQgI3AhQgA0HKATYCPCADQegdNgI0IAMgA0EwajYCECADIAM2AjggAyADQSBqNgIwIANBCGoQgRcgA0FAayQAC3MBA38jAEGAAWsiBCQAIAAoAgAhAANAIAIgBGpB/wBqIABBD3EiA0EwciADQdcAaiADQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIARqQYABakEAIAJrEIEJIARBgAFqJAALcgEDfyMAQYABayIEJAAgACgCACEAA0AgAiAEakH/AGogAEEPcSIDQTByIANBN2ogA0EKSRs6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUHg84kBQQIgAiAEakGAAWpBACACaxCBCSAEQYABaiQAC34BAX8gAEEoaiIBEPcdIAEQ8TsgAEE0aiIBEPQbIAEQ7zsgAEFAaxCHMCAAKAJMQYCAgIB4RwRAIABBzABqEN47CyAAKAJYQYCAgIB4RwRAIABB2ABqEOs7CyAAKAIAQQJHBEAgAEEEahCGMCAAQRBqEIYwCyAAQeQAahCGMAuAAQEEfyMAQRBrIgIkACAAKAIMIgMgACgCBCIBRwRAIAMgAWtBAnYhAwNAIAEoAgAiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAEQ8iULIAFBBGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIahDpOyACQRBqJAALgQEBAX8jAEHAAmsiAiQAIAJBCGogABCVGkEAIQACQAJAAkAgAQ4CAgEAC0HkgsMAQRkQlz0AC0EBIQALIAIvAZ4BIQEgAkGoAWogAkEIakGVAfwKAAAgAiABOwG+AiACIAA6AL0CIAJBADYCoAEgAkGgAWoQ0SlBCGogAkHAAmokAAv/AQIDfwJ+IwBB4AJrIgQkACAEQRBqIgUgABCVGiAEQQhqIAEgAhD6KCAEQagBaiIAIAQoAgggBCgCDBCPNSAEQbQBaiIBIAAQpCggBEHIAWogA0EARyEDIwBBQGoiACQAIAAgBUFAayABEK8QAn8gACgCCCIBQYCAgIB4RwRAIAAoAhQgACkDACAAKQIMIQggAEGChIzIADYCOCAAQQg2AjAgAEEANgIoIABCADcDECAAIAg3AgQgACABNgIAIAAQ2RMMAQsgACgCAAtBCGsgAzoAACAFQZgB/AoAACAAQUBrJAAgBEEANgLAASAEQcABahDRKUEIaiAEQeACaiQAC4UBAQF/IABBKGoiARD3HSABEPE7IABBNGoiARD0GyABEO87IAAoAkBBgICAgHhHBEAgAEFAayIBEOApIAEQ8jsLIABBzABqEIYwIAAoAlhBgICAgHhHBEAgAEHYAGoQ6zsLIAAoAgBBAkcEQCAAQQRqEIYwIABBEGoQhjALIABB5ABqEIYwC4QBAgF/AX4jAEGAAWsiAiQAIAIgARDdAQJAAkAgAikDAEIMfSIDQgFYBEAgA6dBAWsNASAAIAIpAwg3AwggAEIMNwMAIABBGGogAkEYaikDADcDACAAQRBqIAJBEGopAwA3AwAMAgsgACACQYAB/AoAAAwBCyAAQg03AwALIAJBgAFqJAALlgEBAX8CQAJAAkAgAC0AHA4EAAICAQILIAAoAgAiASABKAIAQQFrIgE2AgAgAUUEQCAAENQiCyAAKAIEIgBBhAFJDQEgABDyHw8LAkAgAC0AGA0AIAAoAhQiAUGEAUkNACABEPIfCyAAKAIMIgEgASgCAEEBajYCACAAKAIAIgEgASgCAEEBayIBNgIAIAENACAAENQiCwuQAQEBfyMAQRBrIgIkACACIAFB6OjDAEEOEJYtIAJBiOnDAEEEIAAoAgAiAEHIAGpB+OjDABCIEhogACgCAEECRwRAIAIgACkCFDcCCCACQZzpwwBBAyACQQhqQYzpwwAQiBIaCyAAKAJMBEAgAkGw6cMAQQYgAEHMAGpBoOnDABCIEhoLIAIQxCEgAkEQaiQAC4kBAQF/IwBBMGsiAyQAIAMgACkCGDcCHCADIAI2AhggAyABNgIUIANBCGogA0EUahCIDSADKAIIIgIEQCADKAIMIQEDQCADQcSUxAA2AiwgAyACNgIkIAMgATYCKCAAIANBJGoQrx4gAyADQRRqEIgNIAMoAgQhASADKAIAIgINAAsLIANBMGokAAu1AQACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDgkBAgMEBQYHCAkACyABQaSVxABBChD7NQ8LIAFBrpXEAEEhEPs1DwsgAUHPlcQAQRMQ+zUPCyABQeKVxABBFBD7NQ8LIAFB9pXEAEEUEPs1DwsgAUGKlsQAQRgQ+zUPCyABQaKWxABBGxD7NQ8LIAFBvZbEAEEpEPs1DwsgAUHmlsQAQTMQ+zUPCyABQZmXxABBJRD7NQuBAQECfyMAQSBrIgIkACAALQBYBEAgACgCICAAKAIkIgFBA3ZqIAFBB3FBAEdqIQEgACgCOEUEQCAAKAJIIgAgASAAIAFLGyEBCyACQSBqJAAgAQ8LIAJBADYCGCACQQE2AgwgAkHIos0ANgIIIAJCBDcCECACQQhqQdCizQAQ7ywAC4QBAgF/AX4jAEGAAWsiAiQAIAIgARDTAQJAAkAgAikDAEIMfSIDQgFYBEAgA6dBAWsNASAAIAIpAwg3AwggAEIMNwMAIABBGGogAkEYaikDADcDACAAQRBqIAJBEGopAwA3AwAMAgsgACACQYAB/AoAAAwBCyAAQg03AwALIAJBgAFqJAALiwEBAX8jAEEwayIDJAAgAyABIAJBACACQQN0IgEQ0AggAEIANwMYIABCADcDACAAIAMoAiAiAjYCUCAAIAMpAwg3A0ggACADKQMANwNAIAAgAykDGDcDOCAAIAMpAxA3AzAgACADKAIsIAMoAiggAWpqNgJYIAAgAiADKAIkQQN0ajYCVCADQTBqJAALeAECfyAAIAEoAgwiAgR+IAEgAkEBazYCDCAAIAEoAgQgASgCCCIDQRhsaiICKQMANwMIIAEgA0EBaiIDIAEoAgAiAUEAIAEgA00bazYCCCAAQRBqIAJBCGopAwA3AwAgAEEYaiACQRBqKQMANwMAQgEFQgALNwMAC94CAQl/IwBBIGsiAyQAIAMgAjcDACACUARAIANBCGohByMAQRBrIgQkACABKAIEIQUgBCABKAIIIglBAEEEQRAQoBggBCgCBCEBAkAgBCgCAEEBRwRAIAQoAgghCgJAIAFFDQAgCUEEdCEIIAohBiABIQsDQCAIRQ0BIAQgBUEMaiAFKAIEIAUoAgggBSgCACgCABEFACAGQQhqIARBCGopAgA3AgAgBiAEKQIANwIAIAZBEGohBiAIQRBrIQggBUEQaiEFIAtBAWsiCw0ACwsgByAJNgIIIAcgCjYCBCAHIAE2AgAgBEEQaiQADAELIAEgBCgCCEHomc8AEP0vAAsgAygCECEGIAMoAgwhASAAIAMoAgg2AiAgACABNgIcIAAgATYCGCAAQgA3AwAgACABIAZBBHRqNgIkIANBIGokAA8LIANBADYCCCADQeDozwAgA0EIakH46M8AEK4rAAtjAQF/IwBBIGsiAiQAIAFBADYCJAJAIAEoAgBBgICAgHhGBEAgAkEMaiABQQRqEP4TDAELIAJBDGogAUEMahD+EwsgAEEIaiACQRRqKAIANgIAIAAgAikCDDcCACACQSBqJAALdgEBfyABIANHBEBBAA8LAkAgAUUEQEEBIQAMAQsgAEEIaiEDIAJBCGohAiABQQFrIQEDQCADQQRrKAIAIAMoAgAgAkEEaygCACACKAIAEMEuIgBFDQEgAUEARyADQQxqIQMgAkEMaiECIAFBAWshAQ0ACwsgAAuGAQEBfwJAAkAgAUEETwRAIAAgACkCADcCBCABQQNrIQEMAQsCfwJAAkAgASACakEBayICDgQEAQEAAQsgACgCACIDQQFrDAELIAAoAgAhAyAAIAJBAnRqKAIACyEBIABBCEEEIAJBAUYbaigCACECIAAgAzYCBCAAIAI2AggLIAAgATYCAAsLfAEDf0G6fyEFIAEgA0H/H0tBAkEBIANBH0sbaiIEIANqIgZPBH8CQAJAAkACQCAEQQJrDgIBAgALIAAgA0EDdDoAAAwCCyAAIANBBHRBBHI7AAAMAQsgACADQQR0QQxyNgAACyADBEAgACAEaiACIAP8CgAACyAGBSAFCwuGAQIBfwJ+IwBBIGsiAyQAIANCADcDACABQQdNBEAgA0EANgIYIANBATYCDCADQcyP8wA2AgggA0IENwIQIANBCGpBxJzzABDvLAALIANBCCAAQQhB1JzzABDVLCADNQIAIQQgAzEABCADQSBqJABCOIYgBEIYhoRCvc/W8QF+IAJBP3GtiKcLhwEBA38jAEEQayIFJAAgBUEEaiACQQBBAUEBEKAYIAUoAgghBiAFKAIEQQFHBEAgBSgCDCEHIAIEQCAHIAEgAvwKAAALIAAgAzoAECAAIAI2AgggACAHNgIEIAAgBjYCACAAIAQ7AQ4gAEEBOwEMIAVBEGokAA8LIAYgBSgCDEG0pf4AEP0vAAuLAQIBfwF+IwBBIGsiAyQAIANBCDsBBiADQQhqIAEgAiADQQZqEJUDQQEhAQJAIAMoAghBAUYEQCADKAIMIQIgAykDECEEIAAgAykDGDcDECAAIAQ3AwggACACNgIEDAELIAMpAxghBCAAIAMpAxA3AxAgACAENwMIQQAhAQsgACABNgIAIANBIGokAAt8AgN/AX4jAEEgayIDJAAgA0EIaiIEIAEgAhCBBAJAIAMoAggiBUEBRgRAIAUEQCAEQQRyEIgRCyADQQhqIAEgAhCbCiAAIAMtAAgEfiAGBSAAIAMpAxA3AwhCAQs3AwAMAQsgACADKQMQNwMIIABCATcDAAsgA0EgaiQAC50EAgp/AX4jAEEQayIIJAACQCACRQ0AIAEgAmpBAWsiA0UNACADLQAAQTBrQf8BcUEJSw0AIAhBBGohCiMAQSBrIgckAAJAAkAgAiIDRQ0AIAEtAAAiBEErRiIGIARBLUYiBXIhBCAFRQRAQQEhBSADIARGDQFBCkEJIAYbIgUgAyADIAVLGyEFA0ACQCADIARHBEAgB0EYaiABIARqLQAAEI0vIAcoAhhBAXENASAEIQUMBAsgAyADQbDzgAEQwyEACyAHKAIcIAlBCmxqIQkgBEEBaiIEIAVHDQALDAELIAMgBEYEQEEBIQZBASEDDAILQQEhBgNAIAdBEGogASAEai0AABCNLyAHKAIQQQFxRQRAIAQhAwwDCyAGIAcoAhRFcSEGIARBAWoiBCADRw0ACwwBCyADIAVGBEBBASEGDAELIAUgAyADIAVJGyELQQEhBgNAAkAgBSALRwRAIAdBCGogASAFai0AABCNLyAHKAIIQQFxDQEgBSEDDAMLIAsgA0HA84ABEMMhAAsgBiEEQQAhBgJAIARFDQAgCa1CCn4iDUIgiKcNACANpyIEIAcoAgxqIgkgBE8hBgsgAyAFQQFqIgVHDQALCyAKIAM2AgggCiAJNgIEIAogBjYCACAHQSBqJAAgCCgCBCIDQQFHDQAgCCgCDCACRw0AIAgoAgghASADIQwLIAAgATYCBCAAIAw2AgAgCEEQaiQAC6EEAQl/IwBBEGsiByQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAHQQhqIQlBACEDIwBBIGsiBSQAAkACQAJAAkACQCACRQ0AIAEtAAAiA0ErRiADQS1GIgRyIQMCQCAERQRAIAIgA0YEQEEBIQMMAwsgA0EEciIEIAIgAiAESxshBANAIAIgA0YNAiAFQRhqIAEgA2otAAAQji8gBS8BGEEBcUUNAyAFLwEaIAZBCmxqIQYgBCADQQFqIgNHDQALIAQhAwwCC0EBIQQgAiADRgRAQQEhAwwECwNAIAVBEGogASADai0AABCOLyAFLwEQQQFxRQ0EIAQgBS8BEkVxIQQgA0EBaiIDIAJHDQALDAILIAIgAkGw84ABEMMhAAtBASEEIAIgA0YNACADIAIgAiADSRshCgNAIAMgCkYNAyAFQQhqIAEgA2otAAAQji8gBS8BCEEBcUUNAiAEIQhBACEEAkAgCEUNACAGQf//A3FBCmwiCEEQdg0AIAUvAQoiBiAIQf//A3FqIgRB//8DcSAERiEEIAYgCGohBgsgAiADQQFqIgNHDQALCyACIQMLIAkgAzYCBCAJIAY7AQIgCSAEOwEAIAVBIGokAAwBCyAKIAJBwPOAARDDIQALIAcvAQgiA0EBRw0AIAcoAgwgAkcNACAHLwEKIQEgAyELCyAAIAE7AQIgACALOwEAIAdBEGokAAvcBQIJfwF+IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQRqIQpBACEDIwBBIGsiBiQAAkACQAJAAkACQCACRQ0AIAEtAAAiA0ErRiIFIANBLUYiA3IhBAJAIAMEQEEBIQVBASEDIAIgBEYNAUEKIAIgAkEKTxshAwNAAkAgAiAERwRAIAZBEGogASAEai0AABCNLyAGKAIQQQFxDQEgBCEDDAQLIAIgAkHQ84ABEMMhAAsgB0EKbCAGKAIUayEHIAMgBEEBaiIERw0ACwwBC0EBIQMgAiAERg0BQQpBCSAFGyIDIAIgAiADSxshAwNAAkAgAiAERwRAIAZBGGogASAEai0AABCNLyAGKAIYQQFxDQEgBCEDDAQLIAIgAkGw84ABEMMhAAsgBigCHCAHQQpsaiEHIARBAWoiBCADRw0ACwwBCyACIANGDQEgAyACIAIgA0kbIQkDQCADIAlHBEAgBkEIaiABIANqLQAAEI0vIAYoAghBAXFFDQQgBSEEQQAhBQJAIARFDQAgB6xCCn4iDEIgiKcgDKciBEEfdUcNACAGKAIMIgVBAEogBCAFayIHIARIc0UhBQsgAiADQQFqIgNHDQEMAwsLIAkgAkHg84ABEMMhAAtBASEFIAIgA0YNACADIAIgAiADSRshCQNAIAMgCUYNAyAGIAEgA2otAAAQjS8gBigCAEEBcUUNAiAFIQRBACEFAkAgBEUNACAHrEIKfiIMQiCIpyAMpyIEQR91Rw0AIAYoAgQiBUEASCAEIAVqIgcgBEhzRSEFCyACIANBAWoiA0cNAAsLIAIhAwsgCiADNgIIIAogBzYCBCAKIAU2AgAgBkEgaiQADAELIAkgAkHA84ABEMMhAAsgCCgCBCIDQQFHDQAgCCgCDCACRw0AIAgoAgghASADIQsLIAAgATYCBCAAIAs2AgAgCEEQaiQAC7gFAQp/IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQhqIQojAEEgayIFJAACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIDciEEAkAgAwRAQQEhB0EBIQMgAiAERg0BQQUgAiACQQVPGyEDA0ACQCACIARHBEAgBUEQaiABIARqLQAAEI4vIAUvARBBAXENASAEIQMMBAsgAiACQdDzgAEQwyEACyAGQQpsIAUvARJrIQYgAyAEQQFqIgRHDQALDAELIAIgBEYEQEEBIQQMAgsgBEEEciIDIAIgAiADSxshAwJAA0AgAiAERg0BIAVBGGogASAEai0AABCOLyAFLwEYQQFxRQ0DIAUvARogBkEKbGohBiADIARBAWoiBEcNAAsgAyEEDAILIAIgAkGw84ABEMMhAAsgAiADRg0BIAMgAiACIANJGyEJA0AgAyAJRwRAIAVBCGogASADai0AABCOLyAFLwEIQQFxRQ0EIAchBEEAIQcCQCAERQ0AIAbBQQpsIgvBIgQgC0cNACAEIAUvAQrBayIGwSAGRiEHCyACIANBAWoiA0cNAQwDCwsgCSACQeDzgAEQwyEAC0EBIQcgAiAERg0AIAQgAiACIARJGyEJA0ACQCAEIAlHBEAgBSABIARqLQAAEI4vIAUvAQBBAXENASAEIQMMBAsgCSACQcDzgAEQwyEACyAHIQNBACEHAkAgA0UNACAGwUEKbCILwSIDIAtHDQAgAyAFLwECwWoiBsEgBkYhBwsgAiAEQQFqIgRHDQALCyACIQMLIAogAzYCBCAKIAY7AQIgCiAHOwEAIAVBIGokACAILwEIIgNBAUcNACAIKAIMIAJHDQAgCC8BCiEBIAMhDAsgACABOwECIAAgDDsBACAIQRBqJAALwQYBCH8jAEHgAGsiBiQAIAZBDGohByMAQeAAayIEJAAgBCABKAIIQQJ2QQFrIgs2AgAgBEEgaiEIIwBBMGsiBSQAAkACQCABKAIIIglBBEkNACABKAIEIAlBfHFqQQRrIgpFDQAgAigCCCEJIAUgCigCACIKNgIAIAggCSAKSQR/IAUgCTYCHCAFQQI2AgggBUGA0YABNgIEIAVCAjcCECAFQTs2AiwgBUE7NgIkIAUgBUEgajYCDCAFIAVBHGo2AiggBSAFNgIgIAhBBGogBUEEahCZDkGNgICAeAVBk4CAgHgLNgIAIAVBMGokAAwBC0G80IABELI7AAsCQAJAAkAgBCgCICIFQZOAgIB4RgRAAkAgAygCACIFBEAgCyADKAIQIghHDQELIARBKGpBlKjQoAE2AgAgBEE0aiABQQhqKAIANgIAIARBQGsgAkEIaigCADYCACAEQcwAaiADQQhqKQIANwIAIARB1ABqIANBEGopAgA3AgAgBEKUqNCgwYKFihQ3AyAgBCABKQIANwIsIAQgAikCADcDOCAEIAMpAgA3AkQgByAEQSBqQTz8CgAADAQLIAQgCDYCHCAEQQQ2AgggBEGM94ABNgIEIARCBDcCECAEQTs2AjwgBEE7NgI0IARBzAE2AiwgBEG894ABNgIoIARBzAE2AiQgBEGs94ABNgIgIAQgBEEgajYCDCAEIARBHGo2AjggBCAENgIwIAdBCGogBEEEahCZDiAHQSk6AAAgB0GNgICAeDYCBAwBCyAHIAQpAiQ3AgggB0EQaiAEQSxqKQIANwIAIAdBKToAACAHIAU2AgQgAygCACIFRQ0BCyAFIAUoAgAiBUEBazYCACAFQQFHDQAgAxD7HgsgAigCACIDIAMoAgAiA0EBazYCACADQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgBEHgAGokACAGLQAMQSlHBEAgACAHQTz8CgAAIAZB4ABqJAAPCyAGQdgAaiAGQSBqKAIANgIAIAZB0ABqIAZBGGopAgA3AwAgBiAGKQIQNwNIQez4gAFBKyAGQcgAakHc+IABQaD2gAEQ1R4AC78GAQh/IwBB4ABrIgYkACAGQQxqIQcjAEHgAGsiBCQAIAQgASgCCEEDdkEBayIKNgIAIARBIGohCSMAQTBrIgUkAAJAAkAgASgCCCIIQQhJDQAgASgCBCAIQXhxakEIayIIRQ0AIAUgCCgCACIINgIAIAkgCCACKAIIIgtLBH8gBSALNgIcIAVBAjYCCCAFQYDRgAE2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBUEcajYCKCAFIAU2AiAgCUEEaiAFQQRqEJkOQY2AgIB4BUGTgICAeAs2AgAgBUEwaiQADAELQbzQgAEQsjsACwJAAkACQCAEKAIgIgVBk4CAgHhGBEACQCADKAIAIgUEQCAKIAMoAhAiCUcNAQsgBEEoakGWrNiwATYCACAEQTRqIAFBCGooAgA2AgAgBEFAayACQQhqKAIANgIAIARBzABqIANBCGopAgA3AgAgBEHUAGogA0EQaikCADcCACAEQpas2LDhwoWLFjcDICAEIAEpAgA3AiwgBCACKQIANwM4IAQgAykCADcCRCAHIARBIGpBPPwKAAAMBAsgBCAJNgIcIARBBDYCCCAEQYz3gAE2AgQgBEIENwIQIARBOzYCPCAEQTs2AjQgBEHMATYCLCAEQbz3gAE2AiggBEHMATYCJCAEQbj2gAE2AiAgBCAEQSBqNgIMIAQgBEEcajYCOCAEIAQ2AjAgB0EIaiAEQQRqEJkOIAdBKToAACAHQY2AgIB4NgIEDAELIAcgBCkCJDcCCCAHQRBqIARBLGopAgA3AgAgB0EpOgAAIAcgBTYCBCADKAIAIgVFDQELIAUgBSgCACIFQQFrNgIAIAVBAUcNACADEPseCyACKAIAIgMgAygCACIDQQFrNgIAIANBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyAEQeAAaiQAIAYtAAxBKUcEQCAAIAdBPPwKAAAgBkHgAGokAA8LIAZB2ABqIAZBIGooAgA2AgAgBkHQAGogBkEYaikCADcDACAGIAYpAhA3A0hB7PiAAUErIAZByABqQdz4gAFBoPaAARDVHgALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ7CNFBEAgAUEoakG0yIQBKAIANgIAIAFBrMiEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEO0jRQRAIAFBKGpBiMmEASgCADYCACABQYDJhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDuI0UEQCABQShqQZTJhAEoAgA2AgAgAUGMyYQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ7yNFBEAgAUEoakGsyYQBKAIANgIAIAFBpMmEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPAjRQRAIAFBKGpB0MmEASgCADYCACABQcjJhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDxI0UEQCABQShqQfTJhAEoAgA2AgAgAUHsyYQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ8iNFBEAgAUEoakGMyoQBKAIANgIAIAFBhMqEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPMjRQRAIAFBKGpBmMqEASgCADYCACABQZDKhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABD0I0UEQCABQShqQbDKhAEoAgA2AgAgAUGoyoQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ9SNFBEAgAUEoakG8yoQBKAIANgIAIAFBtMqEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPYjRQRAIAFBKGpB1MqEASgCADYCACABQczKhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuFAQECfyMAQRBrIgQkAAJAIAJBAE4EQCADQQBIDQEgBEEEaiIFIAEgAkEBdCADQQF0EOYVIAAgBRDhGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAuNAQECfyMAQRBrIgQkAAJAIAJBgICAgAFJBEAgA0GAgICAAU8NASAEQQRqIgUgASACQQR0IANBBHQQ5hUgACAFEOIZIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIARBEGokAA8LQaTjhQFBD0G044UBEMskAAtBxOOFAUEPQdTjhQEQyyQAC40BAQJ/IwBBEGsiBCQAAkAgAkGAgICAAkkEQCADQYCAgIACTw0BIARBBGoiBSABIAJBA3QgA0EDdBDmFSAAIAUQ5BkgASgCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgARD7HgsgBEEQaiQADwtBpOOFAUEPQbTjhQEQyyQAC0HE44UBQQ9B1OOFARDLJAALjQEBAn8jAEEQayIEJAACQCACQYCAgMAASQRAIANBgICAwABPDQEgBEEEaiIFIAEgAkEFdCADQQV0EOYVIAAgBRDiGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAuNAQECfyMAQRBrIgQkAAJAIAJBgICAgARJBEAgA0GAgICABE8NASAEQQRqIgUgASACQQJ0IANBAnQQ5hUgACAFEOUZIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIARBEGokAA8LQaTjhQFBD0G044UBEMskAAtBxOOFAUEPQdTjhQEQyyQAC40BAQJ/IwBBEGsiBCQAAkAgAkGAgICAAUkEQCADQYCAgIABTw0BIARBBGoiBSABIAJBBHQgA0EEdBDmFSAAIAUQ5BkgASgCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgARD7HgsgBEEQaiQADwtBpOOFAUEPQbTjhQEQyyQAC0HE44UBQQ9B1OOFARDLJAALjQEBAn8jAEEQayIEJAACQCACQYCAgIACSQRAIANBgICAgAJPDQEgBEEEaiIFIAEgAkEDdCADQQN0EOYVIAAgBRDlGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAt0AQR/IAAoAggiAiEDQQFBAiABQTBqwCIBQQBOIgUbIgQgACgCACACa0sEfyAAIAIgBBDbKCAAKAIIBSADCyAAKAIEaiIDIAUEfyABBSADIAFBvwFxOgABIAFBwAFxQQZ2QUByCzoAACAAIAIgBGo2AghBAAuEAQEDfyAALQA8QRVGBEACQCAAKAIMIgIgACgCQCABbCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDeKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMDwtBnKGHAUEoQeShhwEQnykAC7UBAQN/IwBBEGsiASQAIAEgAEEIajYCDCABIAAoAgQiAjYCCCABIAAoAgAiADYCBCACBEAgAEEIaiEAA0AgACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABDyJQsgAEEEaiEAIAJBAWsiAg0ACwsCQCABQQRqIgIoAgAiAEF/Rg0AIAAgACgCBCIDQQFrNgIEIANBAUcNACAAIAIoAgRBAnRBC2pBfHFBBBD4OgsgAUEQaiQAC7UBAQN/IwBBEGsiASQAIAEgAEEIajYCDCABIAAoAgQiAjYCCCABIAAoAgAiADYCBCACBEAgAEEMaiEAA0AgACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABDyJQsgAEEIaiEAIAJBAWsiAg0ACwsCQCABQQRqIgIoAgAiAEF/Rg0AIAAgACgCBCIDQQFrNgIEIANBAUcNACAAIAIoAgRBA3RBC2pBeHFBBBD4OgsgAUEQaiQAC38BAX8CQCADIARqIgVBA3YgBUEHcUEAR2ogAkEDdE0EQCACIANBA3YiBUkNASAAIARBP3E2AhAgACAEQQZ2NgIMIAAgA0EHcTYCCCAAIAIgBWs2AgQgACABIAVqNgIADwtB3PmHAUE7QZj6hwEQnykACyAFIAJBqPqHARCvOwALhAEBA38jAEEQayICJAAgAkEEahDrOgJAQRhBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAgQ3AgggAUEAOgAUIAFBEGogAkEMaigCADYCACABIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIEIAAgATYCACACQRBqJAAPC0EEQRgQoz0LAAuDAQEFfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEEQQQQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAUECdCIGBEAgBCAFIAb8CgAACyAAIAE2AgggACAENgIEIAAgAzYCACACQRBqJAAPCyADIAIoAgxB4LXCABD9LwALkAEBBX8gASgCxAEhAyAAKAIEIgQoAsgBIQUgACgCACgCCCEGIAFBADYCxAEgASgCwAEhAiABIAZBCGo2AsABAkACQAJAAkAgAgRAIAIgAzYCxAEgA0UNAQwCCyADDQEgAEEANgIEDAMLIAAgAjYCBCACIQQMAQsgAyACNgLAAQsgBCAFQQFrNgLIAQsgAUEIawuIAQEFfyABKAJcIQMgACgCBCIEKAJgIQUgACgCACgCCCEGIAFBADYCXCABKAJYIQIgASAGQQhqNgJYAkACQAJAAkAgAgRAIAIgAzYCXCADRQ0BDAILIAMNASAAQQA2AgQMAwsgACACNgIEIAIhBAwBCyADIAI2AlgLIAQgBUEBazYCYAsgAUEIawuIAQEFfyABKAI8IQMgACgCBCIEKAJAIQUgACgCACgCCCEGIAFBADYCPCABKAI4IQIgASAGQQhqNgI4AkACQAJAAkAgAgRAIAIgAzYCPCADRQ0BDAILIAMNASAAQQA2AgQMAwsgACACNgIEIAIhBAwBCyADIAI2AjgLIAQgBUEBazYCQAsgAUEIawuCAQEFf0EBIQQCQCAAKAIMIgIgACgCCCIDKAIIIgBGDQAgAiAAayEFIAMoAgQgAGohAiABKAIEIQYgASgCACEAA0AgACAGRyIERQ0BIAIgAC0AADoAACABIABBAWoiADYCACADIAMoAghBAWo2AgggAkEBaiECIAVBAWsiBQ0ACwsgBAv9BgIEfg5/IwBBQGoiCCQAIAggATYCBCAIQQhqIhAgCEEEaiIBEK08IAggARDfPTYCOCAIQQA2AjQgCCABNgIwIAggCEE/ajYCLCAIQSBqIQ0jAEEgayIBJAAgAUEUaiAIQSxqIg4iBygCDCIGIAcoAghrIgpBACAGIApPG0EAQRBBIBCgGCABKAIYIQYgASgCFEEBRgRAIAYgASgCHEHE0swAEP0vAAsgAUEQaiIRQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgokACABQQhqIgYgBygCDCILIAcoAghrIglBACAJIAtNGxDvLSAKIAYpAgRCIIk3AgggCiAGQQhqNgIEIwBB0ABrIgYkACAKQQRqIgwoAgQhCSAMKAIAIAcoAggiCyAHKAIMIg9JBH8gBygCBCESIAkgD2ogC2sgDCgCCCAJQQV0aiEHA0AgBkEIaiASIAsQpioCfiAGKAIMIglFBEBCACEDQgAhBEIAIQVCAAwBCyAGQRBqIgwgBigCCCAJELsQIAZBMGogDBCmKyAGKQNAIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhBCAGKQNIIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhAyAGKQMwIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhBSAGKQM4IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQLIQIgByADNwMAIAdBGGogBTcDACAHQRBqIAI3AwAgByAENwMIIAdBIGohByAPIAtBAWoiC0cNAAsFIAkLNgIAIAZB0ABqJAAgCkEQaiQAIA1BCGogESgCADYCACANIAEpAgg3AgAgAUEgaiQAIA4gDRDtGCAAIA4gEBDOHSAIQUBrJAALmQUCDX8CfiMAQUBqIgIkACACIAE2AgQgAkEIaiINIAJBBGoiARCtPCACIAEQ3z02AjggAkEANgI0IAIgATYCMCACIAJBP2o2AiwgAkEgaiELIwBBIGsiAyQAIANBFGogAkEsaiIEKAIMIgcgBCgCCGsiAUEAIAEgB00bQQBBEEEQEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQcTSzAAQ/S8ACyADQRBqIg5BADYCACADIAMoAhw2AgwgAyABNgIIIwBBEGsiCCQAIANBCGoiCSAEKAIMIgcgBCgCCGsiAUEAIAEgB00bEOstIAggCSkCBEIgiTcCCCAIIAlBCGo2AgQjAEEgayIGJAAgCEEEaiIBKAIEIQUgASgCACAEKAIIIgogBCgCDCIMSQR/IAQoAgQhCSAFIAxqIAprIAEoAgggBUEEdGohBQNAIAZBCGogCSAKEKYqIAUCfiAGKAIMIgFFBEBCACEPQgAMAQsgBkEQaiAGKAIIIAEQuRQgBikDECIPQjiGIA9CgP4Dg0IohoQgD0KAgPwHg0IYhiAPQoCAgPgPg0IIhoSEIA9CCIhCgICA+A+DIA9CGIhCgID8B4OEIA9CKIhCgP4DgyAPQjiIhISEIQ8gBikDGCIQQjiGIBBCgP4Dg0IohoQgEEKAgPwHg0IYhiAQQoCAgPgPg0IIhoSEIBBCCIhCgICA+A+DIBBCGIhCgID8B4OEIBBCKIhCgP4DgyAQQjiIhISECzcDACAFIA83AwggBUEQaiEFIAwgCkEBaiIKRw0ACwUgBQs2AgAgBkEgaiQAIAhBEGokACALQQhqIA4oAgA2AgAgCyADKQIINwIAIANBIGokACAEIAsQ7BggACAEIA0Qyx0gAkFAayQAC/cHAw5/AX4BfSMAQSBrIggkAAJAIAEpAwBCAlIEQCABLQBQRQ0BIAAhDSABIgQoAkQhDiAEKAJIIQwgAiEPIAQoAkwiACADIAAgA0kbIQlBACEAIwBBIGsiBiQAAkACQCADIAlPBEAgCQ0BDAILQYT5zABBLEGw+cwAEJ8pAAsgBEEQaiELA0ACQAJAAkACQAJAAkACQAJAAkACQCAEKAIwRQRAQYAgQQQQrTYiAUUNASABQQBBgCD8CwAgBCABNgIwCyAEKAI0IgcNByAEKAI4IgVFDQYgCygCACIBRQ0FIAtBACABGyEQIAAhAQNAIAkgAWsiACAFIAAgBUkbIgBFDQkgECAEKAIwQYAIIAAgAEGACE8bIhEgBC0APBC5BiICRQRAIARBADYCOAwKCyABIAJqIgAgAkkNAiAAIANLDQMgAkGBCE8NBCAGIAQoAjAiBSACQQJ0ajYCFCAGIAU2AhAgBkEQahCeNiIHBEAgByACIAIgB0sbIQcgDyABQQJ0aiEBA0AgBSgCACIKIAxPDQcgASAOIApBAnRqKgIAOAIAIAFBBGohASAFQQRqIQUgB0EBayIHDQALCyAEIAQoAjggAmsiBTYCOCAAIQEgAiARTw0ACwwJC0EEQYAgEKM9AAsgASAAQdD5zAAQsTsACyAAIANB0PnMABCwOwALIAJBgAhB4PnMABCwOwALIAogDEGg+swAEMMhAAtBnPjMAEEYQcD5zAAQyyQACyALKAIABEAgBiALEKUYIAYoAgBBAUcNBSAGKQMIIhJQDQUgEkIBg1BFBEAgBCASp0ECdEF4cTYCOAwECyAEIBJCAYg+AjQgBkEQaiALIAQtADwiAUEDdiABQQdxQQBHahDBHCAGKQMQIRIgBCAGKQMYNwMIIAQgEjcDACASpw0DQcD6zABBLkHw+swAEJ8pAAtBnPjMAEEYQbD6zAAQyyQACwJAAkAgBCgCAARAIAQoAggiASAMTwRAIAEgDEGA+swAEMMhAAsgByAJIABrIgIgAiAHSxsiCiAAaiICIApJDQEgAiADSw0CIAAgCUcEQCAOIAFBAnRqKgIAIRMgDyAAQQJ0aiEFIApBAnQhAQNAIAUgEzgCACAFQQRqIQUgAUEEayIBDQALCyAEIAcgCms2AjQgAiEADAQLQfD5zAAQsjsACyAAIAJBkPrMABCxOwALIAIgA0GQ+swAELA7AAsgASEACyAAIAlJDQALCyANQQg2AgAgDSAANgIEIAZBIGokACAIQSBqJAAPC0GYoc0AQSxBxKHNABCfKQALIAhBADYCGCAIQQE2AgwgCEHwoc0ANgIIIAhCBDcCECAIQQhqQfihzQAQ7ywAC5cIAg5/AX4jAEEgayIJJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ4gASIEKAJEIQ8gBCgCSCEMIAIhECAEKAJMIgAgAyAAIANJGyEKQQAhACMAQSBrIgYkAAJAAkAgAyAKTwRAIAoNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIFDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshDSAAIQEDQCAKIAFrIgAgBSAAIAVJGyIARQ0JIA0gBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIBAgAUEMbGohAQNAIAUoAgAiCCAMTw0HIAEgDyAIQQxsaiIIKQIANwIAIAFBCGogCEEIaigCADYCACABQQxqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAIIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAUgCiAAayICIAIgBUsbIgggAGoiAiAISQ0BIAIgA0sNAiAAIApHBEAgDyABQQxsaiENIBAgAEEMbGohASAIQQxsIQcDQCABIA0pAgA3AgAgAUEIaiANQQhqKAIANgIAIAFBDGohASAHQQxrIgcNAAsLIAQgBSAIazYCNCACIQAMBAtB8PnMABCyOwALIAAgAkGQ+swAELE7AAsgAiADQZD6zAAQsDsACyABIQALIAAgCkkNAAsLIA5BCDYCACAOIAA2AgQgBkEgaiQAIAlBIGokAA8LQZihzQBBLEHEoc0AEJ8pAAsgCUEANgIYIAlBATYCDCAJQfChzQA2AgggCUIENwIQIAlBCGpB+KHNABDvLAAL9QcCDn8BfiMAQSBrIggkAAJAIAEpAwBCAlIEQCABLQBQRQ0BIAAhDiABIgQoAkQhDyAEKAJIIQwgAiEQIAQoAkwiACADIAAgA0kbIQlBACEAIwBBIGsiBiQAAkACQCADIAlPBEAgCQ0BDAILQYT5zABBLEGw+cwAEJ8pAAsgBEEQaiELA0ACQAJAAkACQAJAAkACQAJAAkACQCAEKAIwRQRAQYAgQQQQrTYiAUUNASABQQBBgCD8CwAgBCABNgIwCyAEKAI0IgcNByAEKAI4IgVFDQYgCygCACIBRQ0FIAtBACABGyENIAAhAQNAIAkgAWsiACAFIAAgBUkbIgBFDQkgDSAEKAIwQYAIIAAgAEGACE8bIhEgBC0APBC5BiICRQRAIARBADYCOAwKCyABIAJqIgAgAkkNAiAAIANLDQMgAkGBCE8NBCAGIAQoAjAiBSACQQJ0ajYCFCAGIAU2AhAgBkEQahCeNiIHBEAgByACIAIgB0sbIQcgECABQQJ0aiEBA0AgBSgCACIKIAxPDQcgASAPIApBAnRqKAIANgIAIAFBBGohASAFQQRqIQUgB0EBayIHDQALCyAEIAQoAjggAmsiBTYCOCAAIQEgAiARTw0ACwwJC0EEQYAgEKM9AAsgASAAQdD5zAAQsTsACyAAIANB0PnMABCwOwALIAJBgAhB4PnMABCwOwALIAogDEGg+swAEMMhAAtBnPjMAEEYQcD5zAAQyyQACyALKAIABEAgBiALEKUYIAYoAgBBAUcNBSAGKQMIIhJQDQUgEkIBg1BFBEAgBCASp0ECdEF4cTYCOAwECyAEIBJCAYg+AjQgBkEQaiALIAQtADwiAUEDdiABQQdxQQBHahDBHCAGKQMQIRIgBCAGKQMYNwMIIAQgEjcDACASpw0DQcD6zABBLkHw+swAEJ8pAAtBnPjMAEEYQbD6zAAQyyQACwJAAkAgBCgCAARAIAQoAggiASAMTwRAIAEgDEGA+swAEMMhAAsgByAJIABrIgIgAiAHSxsiCiAAaiICIApJDQEgAiADSw0CIAAgCUcEQCAPIAFBAnRqKAIAIQ0gECAAQQJ0aiEFIApBAnQhAQNAIAUgDTYCACAFQQRqIQUgAUEEayIBDQALCyAEIAcgCms2AjQgAiEADAQLQfD5zAAQsjsACyAAIAJBkPrMABCxOwALIAIgA0GQ+swAELA7AAsgASEACyAAIAlJDQALCyAOQQg2AgAgDiAANgIEIAZBIGokACAIQSBqJAAPC0GYoc0AQSxBxKHNABCfKQALIAhBADYCGCAIQQE2AgwgCEHwoc0ANgIIIAhCBDcCECAIQQhqQfihzQAQ7ywAC/UHAg5/AX4jAEEgayIIJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ0gASIEKAJEIQ4gBCgCSCEMIAIhDyAEKAJMIgAgAyAAIANJGyEJQQAhACMAQSBrIgYkAAJAAkAgAyAJTwRAIAkNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIHDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAJIAFrIgAgBSAAIAVJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIA8gAUEDdGohAQNAIAUoAgAiCiAMTw0HIAEgDiAKQQN0aikDADcDACABQQhqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAKIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAcgCSAAayICIAIgB0sbIgogAGoiAiAKSQ0BIAIgA0sNAiAAIAlHBEAgDiABQQN0aikDACESIA8gAEEDdGohBSAKQQN0IQEDQCAFIBI3AwAgBUEIaiEFIAFBCGsiAQ0ACwsgBCAHIAprNgI0IAIhAAwEC0Hw+cwAELI7AAsgACACQZD6zAAQsTsACyACIANBkPrMABCwOwALIAEhAAsgACAJSQ0ACwsgDUEINgIAIA0gADYCBCAGQSBqJAAgCEEgaiQADwtBmKHNAEEsQcShzQAQnykACyAIQQA2AhggCEEBNgIMIAhB8KHNADYCCCAIQgQ3AhAgCEEIakH4oc0AEO8sAAvKBwIOfwF+IwBBIGsiCSQAAkAgASkDAEICUgRAIAEtAFBFDQEgACENIAEiBCgCRCEOIAQoAkghDCAEKAJMIgAgAyAAIANJGyEKQQAhACMAQSBrIgckAAJAAkAgAyAKTwRAIAoNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIGDQcgBCgCOCIGRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAKIAFrIgAgBiAAIAZJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiBUUEQCAEQQA2AjgMCgsgASAFaiIAIAVJDQIgACADSw0DIAVBgQhPDQQgByAEKAIwIgYgBUECdGo2AhQgByAGNgIQIAdBEGoQnjYiCARAIAggBSAFIAhLGyEIIAEgAmohAQNAIAYoAgAiDyAMTw0HIAEgDiAPai0AADoAACABQQFqIQEgBkEEaiEGIAhBAWsiCA0ACwsgBCAEKAI4IAVrIgY2AjggACEBIAUgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyAFQYAIQeD5zAAQsDsACyAPIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAcgCxClGCAHKAIAQQFHDQUgBykDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAdBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBykDECESIAQgBykDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgggDE8EQCAIIAxBgPrMABDDIQALIAYgCiAAayIBIAEgBksbIgUgAGoiASAFSQ0BIAEgA0sNAiAFRSAAIApGckUEQCAAIAJqIAggDmotAAAgBfwLAAsgBCAGIAVrNgI0IAEhAAwEC0Hw+cwAELI7AAsgACABQZD6zAAQsTsACyABIANBkPrMABCwOwALIAEhAAsgACAKSQ0ACwsgDUEINgIAIA0gADYCBCAHQSBqJAAgCUEgaiQADwtBmKHNAEEsQcShzQAQnykACyAJQQA2AhggCUEBNgIMIAlB8KHNADYCCCAJQgQ3AhAgCUEIakH4oc0AEO8sAAv3BwMOfwF+AXwjAEEgayIIJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ0gASIEKAJEIQ4gBCgCSCEMIAIhDyAEKAJMIgAgAyAAIANJGyEJQQAhACMAQSBrIgYkAAJAAkAgAyAJTwRAIAkNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIHDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAJIAFrIgAgBSAAIAVJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIA8gAUEDdGohAQNAIAUoAgAiCiAMTw0HIAEgDiAKQQN0aisDADkDACABQQhqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAKIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAcgCSAAayICIAIgB0sbIgogAGoiAiAKSQ0BIAIgA0sNAiAAIAlHBEAgDiABQQN0aisDACETIA8gAEEDdGohBSAKQQN0IQEDQCAFIBM5AwAgBUEIaiEFIAFBCGsiAQ0ACwsgBCAHIAprNgI0IAIhAAwEC0Hw+cwAELI7AAsgACACQZD6zAAQsTsACyACIANBkPrMABCwOwALIAEhAAsgACAJSQ0ACwsgDUEINgIAIA0gADYCBCAGQSBqJAAgCEEgaiQADwtBmKHNAEEsQcShzQAQnykACyAIQQA2AhggCEEBNgIMIAhB8KHNADYCCCAIQgQ3AhAgCEEIakH4oc0AEO8sAAt9AQF/IwBBIGsiBCQAIARBCGogASACIAEoAkAiAiADIAIgA0kbEKALIAQoAgwhAgJAIAQoAggiA0EIRwRAIAAgBCkDEDcDCCAAQRBqIARBGGopAwA3AwAMAQsgASABKAJAIAJrNgJACyAAIAM2AgAgACACNgIEIARBIGokAAuHAQICfwJ+IwBBIGsiAyQAIAAoAhghBCADQgA3AwAgAkEHTQRAIANBADYCGCADQQE2AgwgA0GY184ANgIIIANCBDcCECADQQhqQcTZzgAQ7ywACyADQQggAUEIQdTZzgAQ1SwgAykDACAAKQMQIANBIGokAINC07femr3P1vEffiAEQT9xrYinC7oGAgp/Bn4jAEGQAWsiCCQAIAhBQGshBCABKAJ4IQojAEHgAGsiAiQAIAJB0ABqIQMCfgJAIAEoAhAiByABKAIUTw0AIAEgB0EBajYCECABKAIcIgYgASgCJEYNACABKAIIIQkgASgCACELIAEgBkEBajYCHCABKAI0IgUgASgCPEYNACAGLQAAIQYgASAFQRBqNgI0IAIgBSkDADcDUCAJIAdBDGwiB2ohCSAHIAtqIQcgAkFAayEDIAUpAwgMAQtCAgshDCADIAw3AwACQAJAAkAgAikDUCIRQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDQCEMIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAHNgIQIAIgAykCBDcCNCACIAU2AjAgAiAMNwMoIAIgETcDICACIAY6ABggAiAJNgIUIAJBMGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACIBQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCEOIAJBCGoiBSADQQhqKAIAIgs2AgAgAiADKQMAIg03AwAgAkHIAGogCzYCACACIA03A0AgAiAONwJUIAIgATYCUAJAAkAgBkEBcQR+QgAFIAJBEGoiBiAHKAIEIAcoAggQxBggAigCECIDQQhHDQEgAikDGCEPIAYgCSgCBCAJKAIIEMQYIAIoAhAiA0EIRw0BIAIpAxghEEIBCyENIAJBGGogBSgCADYCACACIAIpAwA3AxAMAQsgAikDICEMIAIpAxghDiADrSACNQIUQiCGhCENIAJB0ABqEIUwIAJBQGsQhTAgCigCAEEIRwRAIAoQySMLIAogDDcDECAKIA43AwggCiANNwMAQgIhDQsgBCAMNwMoIAQgETcDICAEIBA3AxggBCANNwMQIAQgDzcDCCAEIA03AwAgBCACKQMQNwMwIAQgDjcDQCAEIAE2AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAgpA0AiDEIDUQ0AGiAIIAhByABqQcAA/AoAAEICIAxCAlENABogAEEIaiAIQcAA/AoAACAMCzcDACAIQZABaiQAC+8HAgp/BH4jAEHgAGsiCiQAIApBKGohCCABKAJ4IQsjAEHwAGsiAiQAIAJB4ABqIQQCfgJAIAEiAygCECIBIAMoAhRPDQAgAyABQQFqNgIQIAMoAhwiBiADKAIkRg0AIAMoAgghByADKAIAIQkgAyAGQQFqNgIcIAMoAjQiBSADKAI8Rg0AIAYtAAAhBiADIAVBEGo2AjQgAiAFKQMANwNgIAcgAUEMbCIBaiEHIAEgCWohASACQdAAaiEEIAUpAwgMAQtCAgshDCAEIAw3AwACQAJAAkAgAikDYCIMQgJRDQAgAygCTCIEIAMoAlRGDQAgAikDUCENIAMgBEEMajYCTCAEKAIAIgVBgYCAgHhGDQAgAiABNgIQIAIgBCkCBDcCNCACIAU2AjAgAiANNwMoIAIgDDcDICACIAY6ABggAiAHNgIUIAJBMGohBCADKAJkIgkgAygCbEcEQCADIAlBDGo2AmQgCSgCACIFQYGAgIB4Rw0CCyAEEIUwCyAIQgM3AwAMAQsgCSkCBCEOIAJBCGoiCSAEQQhqKAIAIgM2AgAgAiAEKQMAIg83AwAgAkHYAGogAzYCACACIA83A1AgAiAONwJkIAIgBTYCYEECIQNBAiEEAkACQCAGQQFxRQRAIAJBEGogASgCBCABKAIIENgWIAItABQhASACKAIQIgZBCEcEQCACQcgAaiACQSBqKAIANgIAIAIgAikDGDcDQCACLwAVIAItABdBEHRyIQcgAigCJCEFDAILIAJBEGogBygCBCAHKAIIENgWIAItABQhBCACKAIQIgZBCEcEQCACQcgAaiACQSBqKAIANgIAIAIgAikDGDcDQCACLwAVIAItABdBEHRyIQcgAigCJCEFIAQhAQwCCyABIQMLIAJByABqIAkoAgA2AgAgAiACKQMANwNAIA1CKIinIQcgDUIgiKchASANpyEGDAELIAJB4ABqEIUwIAJB0ABqEIUwQgIhDAsgBq0gB61CKIYgAa1C/wGDQiCGhIQhDQJAIAxCAlEEQCALKAIAQQhHBEAgCxDJIwsgCyANNwMAIAsgAikDQDcDCCALIAU2AhQgC0EQaiACQcgAaigCADYCAAwBCyACQRhqIAJByABqKAIANgIAIAIgAikDQDcDEAsgCCANNwMIIAggDDcDACAIIAIpAxA3AxAgCCAEOgApIAggAzoAKCAIIA43AyAgCCAFNgIcIAhBGGogAkEYaigCADYCAAsgAkHwAGokACAAAn5CAiAKKQMoIgxCA1ENABogCiAKQTBqQSj8CgAAQgIgDEICUQ0AGiAAQQhqIApBKPwKAAAgDAs3AwAgCkHgAGokAAvfBwIMfwZ+IwBBoAFrIgokACAKQcgAaiEEIAEoAnghCCMAQYABayICJAAgAkHoAGohBQJ+AkAgASgCECIGIAEoAhRPDQAgASAGQQFqNgIQIAEoAhwiByABKAIkRg0AIAEoAgghCSABKAIAIQsgASAHQQFqNgIcIAEoAjQiAyABKAI8Rg0AIActAAAhByABIANBEGo2AjQgAiADKQMANwNoIAkgBkEMbCIGaiEJIAYgC2ohBiACQdgAaiEFIAMpAwgMAQtCAgshDiAFIA43AwACQAJAAkAgAikDaCIQQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDWCESIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAGNgIYIAIgAykCBDcCPCACIAU2AjggAiASNwMwIAIgEDcDKCACIAc6ACAgAiAJNgIcIAJBOGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACILQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCETIAJBEGoiDSADQQhqKAIAIgE2AgAgAiADKQMAIg43AwggAkHQAGogATYCACACIA43A0ggAiATNwJcIAIgCzYCWAJAAkACQAJAIAdBAXEEQEEAIQUMAQsgAkEYaiAGKAIEIAYoAggQvxwgAikCJCEOIAIoAiAhAyACKAIcIQEgAigCGCIMQQhHBEAgAigCLCEFDAMLIAIgAzYCcCACIAE2AmxBASEFIAJBATYCaCACIA43AnQgAkEYaiAJKAIEIAkoAggQvxwgAikCJCEPIAIoAiAhByACKAIcIQYgAigCGCIMQQhHBEAgAigCLCEFIAFFDQIgAkH4AGogAyAOpyABKAIQEQEADAILIAGtIAOtQiCGhCERCyACQSBqIA0oAgA2AgAgAiACKQMINwMYIA5CIIinIQkgDqchCAwCCyAGIQEgDyEOIAchAwsgAkHYAGoQhTAgAkHIAGoQhTAgCCgCAEEIRwRAIAgQySMLIAggBTYCFCAIIA43AgwgCCADNgIIIAggDK0gAa1CIIaENwMAQgIhEAsgBCAPNwMwIAQgBzYCLCAEIAY2AiggBCAFNgIkIAQgCTYCICAEIAg2AhwgBCARNwIUIAQgBTYCECAEIBI3AwggBCAQNwMAIAQgAikDGDcDOCAEIBM3A0ggBCALNgJEIARBQGsgAkEgaigCADYCAAsgAkGAAWokACAAAn5CAiAKKQNIIg5CA1ENABogCiAKQdAAakHIAPwKAABCAiAOQgJRDQAaIABBCGogCkHIAPwKAAAgDgs3AwAgCkGgAWokAAu8BgMKfwV+AXwjAEGQAWsiCCQAIAhBQGshBCABKAJ4IQojAEHgAGsiAiQAIAJB0ABqIQMCfgJAIAEoAhAiByABKAIUTw0AIAEgB0EBajYCECABKAIcIgYgASgCJEYNACABKAIIIQkgASgCACELIAEgBkEBajYCHCABKAI0IgUgASgCPEYNACAGLQAAIQYgASAFQRBqNgI0IAIgBSkDADcDUCAJIAdBDGwiB2ohCSAHIAtqIQcgAkFAayEDIAUpAwgMAQtCAgshDCADIAw3AwACQAJAAkAgAikDUCIQQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDQCEMIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAHNgIQIAIgAykCBDcCNCACIAU2AjAgAiAMNwMoIAIgEDcDICACIAY6ABggAiAJNgIUIAJBMGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACIBQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCEOIAJBCGoiBSADQQhqKAIAIgs2AgAgAiADKQMAIg03AwAgAkHIAGogCzYCACACIA03A0AgAiAONwJUIAIgATYCUAJAAkAgBkEBcQR+QgAFIAJBEGoiBiAHKAIEIAcoAggQxBggAigCECIDQQhHDQEgAisDGCERIAYgCSgCBCAJKAIIEMQYIAIoAhAiA0EIRw0BIAIpAxghD0IBCyENIAJBGGogBSgCADYCACACIAIpAwA3AxAMAQsgAikDICEMIAIrAxghESADrSACNQIUQiCGhCEOIAJB0ABqEIUwIAJBQGsQhTAgCigCAEEIRwRAIAoQySMLIAogDDcDECAKIBE5AwggCiAONwMAQgIhDQsgBCAMNwMoIAQgEDcDICAEIA83AxggBCANNwMQIAQgETkDCCAEIA03AwAgBCACKQMQNwMwIAQgDjcDQCAEIAE2AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAgpA0AiDEIDUQ0AGiAIIAhByABqQcAA/AoAAEICIAxCAlENABogAEEIaiAIQcAA/AoAACAMCzcDACAIQZABaiQAC40HAwp/BH4EfSMAQfAAayIJJAAgCUEwaiEEIAEoAnghCCMAQeAAayICJAAgAkHQAGohAwJ+AkAgASgCECIFIAEoAhRPDQAgASAFQQFqNgIQIAEoAhwiBiABKAIkRg0AIAEoAgghCiABKAIAIQsgASAGQQFqNgIcIAEoAjQiByABKAI8Rg0AIAYtAAAhBiABIAdBEGo2AjQgAiAHKQMANwNQIAogBUEMbCIFaiEKIAUgC2ohBSACQUBrIQMgBykDCAwBC0ICCyEMIAMgDDcDAAJAAkACQCACKQNQIgxCAlENACABKAJMIgMgASgCVEYNACACKQNAIQ0gASADQQxqNgJMIAMoAgAiB0GBgICAeEYNACACIAU2AhAgAiADKQIENwI0IAIgBzYCMCACIAw3AyAgAiAGOgAYIAIgCjYCFCABKAJsIQsgASgCZCEDIAIgDTcDKCACQTBqIQcgAyALRwRAIAEgA0EMajYCZCADKAIAIgFBgYCAgHhHDQILIAcQhTALIARCAzcDAAwBCyADKQIEIQ4gAkEIaiILIAdBCGooAgAiAzYCACACIAcpAwAiDzcDACACQcgAaiADNgIAIAIgDzcDQCACIA43AlQgAiABNgJQAkAgBkEBcQR/QQAFIAJBEGogBSgCBCAFKAIIEKQYIAIqAhQhEAJAAn8gAigCECIDQQhHBEAgAioCJCESIAIqAhwhEyACKAIYIQYgAigCIAwBCyACQRBqIAooAgQgCigCCBCkGCACKgIUIREgAigCECIDQQhGDQEgAioCJCESIAIqAhwhEyACKAIYIQYgESEQIAIoAiALIQUgAkHQAGoQhTAgAkFAaxCFMCAIKAIAQQhHBEAgCBDJIwsgCCASOAIUIAggBTYCECAIIBM4AgwgCCAGNgIIIAggEDgCBCAIIAM2AgBCAiEMDAILQQELIQMgDUIgiKchBSANpyEGIAJBGGogCygCADYCACACIAIpAwA3AxALIAQgETgCHCAEIAM2AhggBCAQOAIUIAQgAzYCECAEIAU2AgwgBCAGNgIIIAQgDDcDACAEIAIpAxA3AyAgBCAONwMwIAQgATYCLCAEQShqIAJBGGooAgA2AgALIAJB4ABqJAAgAAJ+QgIgCSkDMCIMQgNRDQAaIAkgCUE4akEw/AoAAEICIAxCAlENABogAEEIaiAJQTD8CgAAIAwLNwMAIAlB8ABqJAAL8gYCC38EfiMAQfAAayIKJAAgCkEwaiEGIAEoAnghCSMAQeAAayICJAAgAkHQAGohAwJ+AkAgASgCECIFIAEoAhRPDQAgASAFQQFqNgIQIAEoAhwiByABKAIkRg0AIAEoAgghCCABKAIAIQsgASAHQQFqNgIcIAEoAjQiBCABKAI8Rg0AIActAAAhByABIARBEGo2AjQgAiAEKQMANwNQIAggBUEMbCIFaiEIIAUgC2ohBSACQUBrIQMgBCkDCAwBC0ICCyENIAMgDTcDAAJAAkACQCACKQNQIg1CAlENACABKAJMIgMgASgCVEYNACACKQNAIQ4gASADQQxqNgJMIAMoAgAiBEGBgICAeEYNACACIAU2AhAgAiADKQIENwI0IAIgBDYCMCACIA43AyggAiANNwMgIAIgBzoAGCACIAg2AhQgAkEwaiEDIAEoAmQiBCABKAJsRwRAIAEgBEEMajYCZCAEKAIAIgFBgYCAgHhHDQILIAMQhTALIAZCAzcDAAwBCyAEKQIEIQ8gAkEIaiIEIANBCGooAgAiCzYCACACIAMpAwAiEDcDACACQcgAaiALNgIAIAIgEDcDQCACIA83AlQgAiABNgJQAkAgB0EBcQR/QQAFIAJBEGogBSgCBCAFKAIIEKQYIAIoAhQhBQJAAn8gAigCECIDQQhHBEAgAigCICEIIAIoAhwhBCACKAIYIQsgAigCJAwBCyACQRBqIAgoAgQgCCgCCBCkGCACKAIUIQcgAigCECIDQQhGDQEgAigCICEIIAIoAhwhBCACKAIYIQsgByEFIAIoAiQLIQwgAkHQAGoQhTAgAkFAaxCFMCAJKAIAQQhHBEAgCRDJIwsgCSAMNgIUIAkgCDYCECAJIAQ2AgwgCSALNgIIIAkgA60gBa1CIIaENwMAQgIhDQwCC0EBCyEDIAJBGGogBCgCADYCACACIAIpAwA3AxALIAYgBzYCHCAGIAM2AhggBiAFNgIUIAYgAzYCECAGIA43AwggBiANNwMAIAYgAikDEDcDICAGIA83AzAgBiABNgIsIAZBKGogAkEYaigCADYCAAsgAkHgAGokACAAAn5CAiAKKQMwIg1CA1ENABogCiAKQThqQTD8CgAAQgIgDUICUQ0AGiAAQQhqIApBMPwKAAAgDQs3AwAgCkHwAGokAAuNBwIMfwR+IwBBkAFrIgkkACAJQUBrIQQgASgCeCEKIwBB4ABrIgIkACACQdAAaiEDAn4CQCABKAIQIgUgASgCFE8NACABIAVBAWo2AhAgASgCHCIHIAEoAiRGDQAgASgCCCEIIAEoAgAhDCABIAdBAWo2AhwgASgCNCILIAEoAjxGDQAgBy0AACEHIAEgC0EQajYCNCACIAspAwA3A1AgCCAFQQxsIgZqIQggBiAMaiEFIAJBQGshAyALKQMIDAELQgILIQ4gAyAONwMAAkACQAJAIAIpA1AiDkICUQ0AIAEoAkwiAyABKAJURg0AIAIpA0AhDyABIANBDGo2AkwgAygCACIGQYGAgIB4Rg0AIAIgBTYCECACIAMpAgQ3AjQgAiAGNgIwIAIgDzcDKCACIA43AyAgAiAHOgAYIAIgCDYCFCACQTBqIQYgASgCZCIDIAEoAmxHBEAgASADQQxqNgJkIAMoAgAiDUGBgICAeEcNAgsgBhCFMAsgBEIDNwMADAELIAMpAgQhESACQQhqIgwgBkEIaigCACIBNgIAIAIgBikDACIQNwMAIAJByABqIAE2AgAgAiAQNwNAIAIgETcCVCACIA02AlACQCAHQQFxBH9BAAUgAkEQaiAFKAIEIAUoAggQ+RcgAigCHCEDIAIoAhghASACKAIUIQUCQAJ+IAIoAhAiC0EIRwRAIAIpAyAMAQsgAkEQaiAIKAIEIAgoAggQ+RcgAigCHCEGIAIoAhghCCACKAIUIQcgAigCECILQQhGDQEgByEFIAYhAyAIIQEgAikDIAshDiALrSAFrUIghoQhDyACQdAAahCFMCACQUBrEIUwIAooAgBBCEcEQCAKEMkjCyAKIA43AxAgCiADNgIMIAogATYCCCAKIA83AwBCAiEODAILIAGtIAOtQiCGhCEQQQELIQMgAkEYaiAMKAIANgIAIAIgAikDADcDEAsgBCAGNgIsIAQgCDYCKCAEIAc2AiQgBCADNgIgIAQgEDcDGCAEIAU2AhQgBCADNgIQIAQgDzcDCCAEIA43AwAgBCACKQMQNwMwIAQgETcDQCAEIA02AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAkpA0AiDkIDUQ0AGiAJIAlByABqQcAA/AoAAEICIA5CAlENABogAEEIaiAJQcAA/AoAACAOCzcDACAJQZABaiQAC9gDAQ1/IwBBkAFrIgMkACADQcQAaiEKIAEoAhwhBCMAQZABayICJAACQCABKAIQIgUgASgCFCIMSQRAIAEoAgAgBUECdGohByABKAIIIAVBA3RqIQggAkHkAGohDSACQSBqIQ4gAkEEciEGIAEoAhghCwNAIAEgBUEBaiIFNgIQIAIgBygCAEEIaiALLwEAIAsvAQIgCBC2AQJAAkAgAigCACIJQYSAgIB4RgRAIAQoAgBBCEcEQCAEEMkjCyAEIAIpAwg3AwAgBEEQaiACQRhqKQMANwMAIARBCGogAkEQaikDADcDAAwBCyACQeAAaiAGQRhqKAIANgIAIAJB2ABqIAZBEGopAgA3AwAgAkHQAGogBkEIaikCADcDACACIAYpAgA3A0ggDSAOQSj8CgAAIAlBhYCAgHhGDQELIApBBGogAkHIAGpBxAD8CgAADAMLIAdBBGohByAIQQhqIQggBSAMRw0ACwtBhYCAgHghCQsgCiAJNgIAIAJBkAFqJAAgAAJ/QYSAgIB4IAMoAkQiAUGFgICAeEYNABogAyADQcgAakHEAPwKAABBhICAgHggAUGEgICAeEYNABogAEEEaiADQcQA/AoAACABCzYCACADQZABaiQAC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQRBCBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQN0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEHYmc8AEP0vAAuUAQECfyMAQRBrIgIkACAAKAIAIgNBAWohAAJ/AkACQAJAIAMtAABBAWsOAgECAAsgAiAANgIEIAFB2J3QAEEGIAJBBGpByJ3QABDQEwwCCyACIAA2AgggAUHwndAAQQYgAkEIakHgndAAENATDAELIAIgADYCDCABQYie0ABBBSACQQxqQfid0AAQ0BMLIAJBEGokAAugAQAgAEEANgLQASAAQQA2AsgBIABBADYCwAEgAEEANgK4ASAAQgg3A2AgAEIANwNQIABCADcDQCAAQgA3AzAgAEIANwMgIABCADcDECAAQgA3AwAgAEHYAWpBAEEs/AsAIAAgATYCvAIgAEGAgICAeDYCsAIgAEGAgICAeDYCpAIgAEGAgICAeDYCmAIgAEGAgICAeDYCjAIgAEIBNwKEAguXAQACQAJAAkACQAJAIAJBBWsOBAECAwQACyAAKAAAQbHz3fF5bEEgIAFrdg8LIAApAABCgICA2Mub741PfkHAACABa62Ipw8LIAApAABCgIDs/Mub741PfkHAACABa62Ipw8LIAApAABCgMaV/cub741PfkHAACABa62Ipw8LIAApAABC48iVvcub741PfkHAACABa62Ipwt5AQR/IAAoAgAoAgAiACgCCCICIQNBAUECIAHAQQBOIgUbIgQgACgCACACa0sEfyAAIAIgBEEBQQEQ0CggACgCCAUgAwsgACgCBGoiAyAFBH8gAQUgAyABQb8BcToAASABQcABcUEGdkFAcgs6AAAgACACIARqNgIIC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQhBCBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQN0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEGs7v4AEP0vAAuNBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayIBJAAgAUEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQQhBCBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHcj/8AEP0vAAsgAUEQaiIVQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIg8kACABQQhqIgIgCigCBCAKKAIAa0EEdhDsLSAPIAIpAgRCIIk3AgggDyACQQhqNgIEIwBBIGsiAiQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBA3RqIQogDCAOa0EEdiENA0ACfgJAAkAgDikDACIGIA4pAwgiB0KAgICAgICAgIB/hYRCAFIgFygCACIMKAIAIhIpAwgiAyASKQMAIgSDQn9SckUEQEIAIQRCACEDQgAhBUKAgICAgICAgIB/IQgMAQsgAyAEhFANBSACQRBqIAYgByAEIAMQgxkgAiACKQMQIgUgAikDGCIIIAQgAxCoHkIAIAYgAikDACIJfSADIASDQn9RIhIbIQRCACAHIAIpAwh9IAYgCVStfSASGyEDIAdCAFkNAQsgBSAEIAwoAggiDCkDAFggAyAMKQMIIgRXIAMgBFEbrSIEfSEDIAggBCAFVq19DAELIAggBSAEIAwoAgQiDCkDAFogAyAMKQMIIgRZIAMgBFEbrXwiAyAFVK18CyADQoCAgICAgICAgH99IANUrXxQRQ0DIAogAzcDACAOQRBqIQ4gCkEIaiEKIBBBAWohECANQQFrIg0NAAsLIBYgEDYCACACQSBqJAAMAgtBxKiAARDiKwALQfCtgAEQsjsACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgASkCCDcCACABQSBqJAAgEyAREL0YIAAgEyAUEMYdIAtBQGskAAvgAwILfwF+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgsgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQojAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBBHZBAEEIQQgQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDEEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIIJAAgA0EIaiIBIAUoAgQgBSgCAGtBBHYQ7C0gCCABKQIEQiCJNwIIIAggAUEIajYCBCAIQQRqIgYoAgQhCSAGKAIAIQ0CQAJAIAUoAgAiByAFKAIEIgJHBEAgBSgCCCEBIAYoAgggCUEDdGohBiACIAdrQQR2IQIDQCAHKQMIIAcpAwAiDkKAgICAgICAgIB/fSAOVK18UEUNAiAGIAEoAgApAwAgDn43AwAgB0EQaiEHIAZBCGohBiAJQQFqIQkgAkEBayICDQALCyANIAk2AgAMAQtBgK6AARCyOwALIAhBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQvRggACAFIAsQxh0gBEFAayQAC/MFAgd+Dn8jAEFAaiILJAAgCyACNgIMIAtBEGoiFCABEJI2EO4lIAEoAhQhAiALIAEoAhAiATYCNCALIAEgAkFwcWo2AjggCyALQQxqNgI8IAtBKGohESMAQSBrIgEkACABQRRqIAtBNGoiEyIKKAIEIAooAgBrQQR2QQBBEEEQEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQdyP/wAQ/S8ACyABQRBqIhVBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiDyQAIAFBCGoiAiAKKAIEIAooAgBrQQR2EOstIA8gAikCBEIgiTcCCCAPIAJBCGo2AgQjAEEgayICJAAgD0EEaiINKAIEIRAgDSgCACEWAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBBHRqIQogDCAOa0EEdiENA0BCgICAgICAgICAfyEGAn4CQAJAIA4pAwAiByAOKQMIIghCgICAgICAgICAf4WEQgBSIBcoAgAiDCgCACISKQMIIgQgEikDACIDg0J/UnJFBEBCACEDQgAhBEIAIQUMAQsgAyAEhFANBSACQRBqIAcgCCADIAQQgxkgAiACKQMQIgUgAikDGCIGIAMgBBCoHkIAIAcgAikDACIJfSADIASDQn9RIhIbIQNCACAIIAIpAwh9IAcgCVStfSASGyEEIAhCAFkNAQsgBSADIAwoAggiDCkDAFggBCAMKQMIIgNXIAMgBFEbrSIDfSEEIAYgAyAFVq19DAELIAYgBSADIAwoAgQiDCkDAFogBCAMKQMIIgNZIAMgBFEbrXwiBCAFVK18CyEFIAogBDcDACAKIAU3AwggDkEQaiEOIApBEGohCiAQQQFqIRAgDUEBayINDQALCyAWIBA2AgAgAkEgaiQADAELQcSogAEQ4isACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgASkCCDcCACABQSBqJAAgEyAREOwYIAAgEyAUEMsdIAtBQGskAAuiCQIOfwh+IwBBQGoiBiQAIAYgAjYCDCAGQRBqIg0gARCSNhDuJSABKAIUIQIgBiABKAIQIgE2AjQgBiABIAJBYHFqNgI4IAYgBkEMajYCPCAGQShqIQojAEEgayICJAAgAkEUaiAGQTRqIgsiASgCBCABKAIAa0EFdkEAQQRBBBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQSBrIgQkACACQQhqIgUgASgCBCABKAIAa0EFdhDuLSAFKQIEIREgBEEQaiABQQhqKAIANgIAIAQgASkCADcDCCAEIBFCIIk3AhggBCAFQQhqNgIUIwBBkAFrIgEkACAEQRRqIgMoAgQhCSADKAIAIQ8CQAJAIARBCGoiBygCACIFIAcoAgQiCEcEQCAHKAIIIRAgAygCCCAJQQJ0aiEHIAggBWtBBXYhDANAIAVBGGopAwAhEyAQKAIAIQggBSkDCCEUIAUpAwAhFSABIAVBEGopAwAiGDcDECABIBM3AxggASAVNwMAIAEgFDcDCCABQUBrIBUgFCAYIBMgCCgCACIDKQMAIAMpAwggAykDECADKQMYEJoIAn4gAS0AQEEBRgRAIAEtAEEEQEKAgICAgICAgIB/IRZCACESQgAhEUIADAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQdSngAEQ7ywACyABKQNoIRYgASkDYCERIAEpA1ghEiABKQNQCyEXIAFBQGsgFSAUIBggEyADKQMAIAMpAwggAykDECADKQMYEJoIAkAgAS0AQEEBRgRAIAEtAEEEQCABQThqQgA3AwAgAUEwakIANwMAIAFCADcDKCABQgA3AyAMAgsgAUEANgIwIAFBATYCJCABQcyngAE2AiAgAUIENwIoIAFBIGpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEyASIBNQrXwiFIRQrXwiFSARVK18IRYMAgsgF0IBfSETIBIgF1CtfSEUIBEgEiAXhFCtIhJ9IRUgFiARIBJUrX0hFgwBCyARIRUgFyETIBIhFAsgAUFAayATIBQgFSAWENYjIAEoAkBBAXFFDQIgASkDUCIRQoCAgIAIfCISQoCAgIAQVCABKQNYIBEgElatfFBxRQ0CIAcgET4CACAFQSBqIQUgB0EEaiEHIAlBAWohCSAMQQFrIgwNAAsLIA8gCTYCACABQZABaiQADAELQfCtgAEQsjsACyAEQSBqJAAgCkEIaiAOKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEOgYIAAgCyANEModIAZBQGskAAuYBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayIBJAAgAUEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHcj/8AEP0vAAsgAUEQaiIVQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIg8kACABQQhqIgIgCigCBCAKKAIAa0EEdhDuLSAPIAIpAgRCIIk3AgggDyACQQhqNgIEIwBBIGsiAiQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBAnRqIQogDCAOa0EEdiENA0BCgICAgICAgICAfyEGAn4CQAJAIA4pAwAiByAOKQMIIghCgICAgICAgICAf4WEQgBSIBcoAgAiDCgCACISKQMIIgQgEikDACIDg0J/UnJFBEBCACEDQgAhBEIAIQUMAQsgAyAEhFANBSACQRBqIAcgCCADIAQQgxkgAiACKQMQIgUgAikDGCIGIAMgBBCoHkIAIAcgAikDACIJfSADIASDQn9RIhIbIQNCACAIIAIpAwh9IAcgCVStfSASGyEEIAhCAFkNAQsgBSADIAwoAggiDCkDAFggBCAMKQMIIgNXIAMgBFEbrSIDfSEEIAYgAyAFVq19DAELIAYgBSADIAwoAgQiDCkDAFogBCAMKQMIIgNZIAMgBFEbrXwiBCAFVK18CyEFIARCgICAgAh8IgNCgICAgBBUIAUgAyAEVK18UHFFDQMgCiAEPgIAIA5BEGohDiAKQQRqIQogEEEBaiEQIA1BAWsiDQ0ACwsgFiAQNgIAIAJBIGokAAwCC0HEqIABEOIrAAtB8K2AARCyOwALIA9BEGokACARQQhqIBUoAgA2AgAgESABKQIINwIAIAFBIGokACATIBEQ6BggACATIBQQyh0gC0FAayQAC+gDAgt/An4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFwcWo2AjggBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EEdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIggkACADQQhqIgEgBSgCBCAFKAIAa0EEdhDuLSAIIAEpAgRCIIk3AgggCCABQQhqNgIEIAhBBGoiBigCBCEJIAYoAgAhDQJAAkAgBSgCACIHIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAJQQJ0aiEGIAIgB2tBBHYhAgNAIAcpAwAiDkKAgICACHwiD0KAgICAEFQgBykDCCAOIA9WrXxQcUUNAiAGIAEoAgAoAgAgDqdsNgIAIAdBEGohByAGQQRqIQYgCUEBaiEJIAJBAWsiAg0ACwsgDSAJNgIADAELQYCugAEQsjsACyAIQRBqJAAgCkEIaiAMKAIANgIAIAogAykCCDcCACADQSBqJAAgBSAKEOgYIAAgBSALEModIARBQGskAAvkBQINfwZ+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQojAEEgayICJAAgAkEUaiAEQTRqIgsiAygCBCADKAIAa0EEdkEAQRBBIBCgGCACKAIYIQEgAigCFEEBRgRAIAEgAigCHEHcj/8AEP0vAAsgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgATYCCCMAQRBrIgckACACQQhqIgEgAygCBCADKAIAa0EEdhDvLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIwBBgAFrIgEkACAHQQRqIgUoAgQhCCAFKAIAIAMoAgAiBiADKAIEIglHBEAgAygCCCEPIAUoAgggCEEFdGohAyAIIAkgBmtBBHYiCWohCANAIAFB4ABqIAYpAwAgBikDCBCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAZBEGohBiADQSBqIQMgCUEBayIJDQALCyAINgIAIAFBgAFqJAAgB0EQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALngQBDX8jAEFAaiIEJAAgBCACNgIMIARBEGoiDCABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFgcWo2AjggBCAEQQxqNgI8IARBKGohCSMAQSBrIgEkACABQRRqIARBNGoiCyIDKAIEIAMoAgBrQQV2QQBBEEEQEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiByQAIAFBCGoiAiADKAIEIAMoAgBrQQV2EOstIAcgAikCBEIgiTcCCCAHIAJBCGo2AgQjAEEwayICJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCADKAIAIgUgAygCBCIKRwRAIAMoAgghDyAGKAIIIAhBBHRqIQMgCiAFa0EFdiEGA0AgAkEQaiAFKQMAIAUpAwggBUEQaikDACAFQRhqKQMAENYjIAIoAhBBAXFFDQIgAiAPKAIAIgopAwAgCikDCCACKQMgIAIpAygQqB4gAyACKQMANwMAIAMgAikDCDcDCCAFQSBqIQUgA0EQaiEDIAhBAWohCCAGQQFrIgYNAAsLIA4gCDYCACACQTBqJAAMAQtBgK6AARCyOwALIAdBEGokACAJQQhqIA0oAgA2AgAgCSABKQIINwIAIAFBIGokACALIAkQ7BggACALIAwQyx0gBEFAayQAC8kDAgt/AX4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkF4cWo2AjggBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQhBEBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIggkACADQQhqIgEgBSgCBCAFKAIAa0EDdhDpLSAIIAEpAgRCIIk3AgggCCABQQhqNgIEIAhBBGoiBigCBCEJIAYoAgAgBSgCACIHIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAJQQR0aiEGIAkgAiAHa0EDdiICaiEJA0AgASgCACkDACEOIAZBBGogBygCADYCACAGQQA2AgAgBkEIaiAOIAdBBGo0AgB+NwMAIAdBCGohByAGQRBqIQYgAkEBayICDQALCyAJNgIAIAhBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQ6hggACAFIAsQxR0gBEFAayQAC6IEAgx/An4jAEFAaiIEJAAgBCACNgIMIARBEGoiDCABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFgcWo2AjggBCAEQQxqNgI8IARBKGohCyMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EFdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgkkACADQQhqIgEgBSgCBCAFKAIAa0EFdhDuLSAJIAEpAgRCIIk3AgggCSABQQhqNgIEIwBBIGsiCCQAIAlBBGoiBygCBCEKIAcoAgAhDgJAAkAgBSgCACIGIAUoAgQiAkcEQCAFKAIIIQEgBygCCCAKQQJ0aiEHIAIgBmtBBXYhAgNAIAggBikDACAGKQMIIAZBEGopAwAgBkEYaikDABDWIyAIKAIAQQFxRQ0CIAgpAxAiD0KAgICACHwiEEKAgICAEFQgCCkDGCAPIBBWrXxQcUUNAiAHIAEoAgAoAgAgD6dsNgIAIAZBIGohBiAHQQRqIQcgCkEBaiEKIAJBAWsiAg0ACwsgDiAKNgIAIAhBIGokAAwBC0GAroABELI7AAsgCUEQaiQAIAtBCGogDSgCADYCACALIAMpAgg3AgAgA0EgaiQAIAUgCxDoGCAAIAUgDBDKHSAEQUBrJAALoAkCDn8IfiMAQUBqIgYkACAGIAI2AgwgBkEQaiINIAEQkjYQ7iUgASgCFCECIAYgASgCECIBNgI0IAYgASACQWBxajYCOCAGIAZBDGo2AjwgBkEoaiEKIwBBIGsiAiQAIAJBFGogBkE0aiILIgEoAgQgASgCAGtBBXZBAEEIQQgQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEgayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBBXYQ7C0gBSkCBCERIARBEGogAUEIaigCADYCACAEIAEpAgA3AwggBCARQiCJNwIYIAQgBUEIajYCFCMAQbABayIBJAAgBEEUaiIDKAIEIQkgAygCACEPAkACQCAEQQhqIgcoAgAiBSAHKAIEIghHBEAgBygCCCEQIAMoAgggCUEDdGohByAIIAVrQQV2IQwDQCAFQRhqKQMAIRIgECgCACEIIAUpAwghEyAFKQMAIRQgASAFQRBqKQMAIhg3AxAgASASNwMYIAEgFDcDACABIBM3AwggAUFAayAUIBMgGCASIAgoAgAiAykDACADKQMIIAMpAxAgAykDGBCaCAJ+IAEtAEBBAUYEQCABLQBBBEBCgICAgICAgICAfyEWQgAhFUIAIRFCAAwCCyABQQA2AjAgAUEBNgIkIAFBzKeAATYCICABQgQ3AiggAUEgakHUp4ABEO8sAAsgASkDaCEWIAEpA2AhESABKQNYIRUgASkDUAshFyABQUBrIBQgEyAYIBIgAykDACADKQMIIAMpAxAgAykDGBCaCAJAIAEtAEBBAUYEQCABLQBBBEAgAUE4akIANwMAIAFBMGpCADcDACABQgA3AyggAUIANwMgDAILIAFBADYCqAEgAUEBNgKcASABQcyngAE2ApgBIAFCBDcCoAEgAUGYAWpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEiAVIBJQrXwiE4RQrXwiFCARVK18IRYMAgsgF0IBfSESIBUgF1CtfSETIBEgFSAXhFCtIhV9IRQgFiARIBVUrX0hFgwBCyARIRQgFyESIBUhEwsgAUFAayASIBMgFCAWENYjIAEoAkBBAXFFDQIgASkDWCABKQNQIhFCgICAgICAgICAf30gEVStfFBFDQIgByARNwMAIAVBIGohBSAHQQhqIQcgCUEBaiEJIAxBAWsiDA0ACwsgDyAJNgIAIAFBsAFqJAAMAQtB8K2AARCyOwALIARBIGokACAKQQhqIA4oAgA2AgAgCiACKQIINwIAIAJBIGokACALIAoQvRggACALIA0Qxh0gBkFAayQAC9oDAQ1/IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQkjAEEgayIBJAAgAUEUaiAEQTRqIgsiAigCBCACKAIAa0EEdkEAQRBBEBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEHcj/8AEP0vAAsgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgYkACABQQhqIgMgAigCBCACKAIAa0EEdhDrLSAGIAMpAgRCIIk3AgggBiADQQhqNgIEIwBBEGsiByQAIAZBBGoiBSgCBCEIIAUoAgAgAigCACIDIAIoAgQiCkcEQCACKAIIIQ8gBSgCCCAIQQR0aiECIAggCiADa0EEdiIFaiEIA0AgByAPKAIAIgopAwAgCikDCCADKQMAIAMpAwgQqB4gAiAHKQMANwMAIAIgBykDCDcDCCADQRBqIQMgAkEQaiECIAVBAWsiBQ0ACwsgCDYCACAHQRBqJAAgBkEQaiQAIAlBCGogDSgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAsgCRDsGCAAIAsgDBDLHSAEQUBrJAALzQUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgASgCFCECIAQgASgCECIBNgI0IAQgASACQWBxajYCOCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBBXZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAMoAgQgAygCAGtBBXYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQeAAayIBJAAgB0EEaiIGKAIEIQggBigCACADKAIAIgUgAygCBCIJRwRAIAMoAgghDyAGKAIIIAhBBXRqIQMgCCAJIAVrQQV2IglqIQgDQCABQdAAaiAPKAIAIgYpAwAiEEIAIAUpAwAiEkIAEKgeIAFBQGsgEEIAIAUpAwgiE0IAEKgeIAFBMGogBikDCCIRQgAgEkIAEKgeIAFBIGogEUIAIBNCABCoHiABQRBqIBAgESAFQRBqKQMAIAVBGGopAwAQqB4gASAGKQMQIAYpAxggEiATEKgeIAMgASkDUDcDACADIAEpA1giESABKQNAfCIQIAEpAzB8IhQ3AwggA0EQaiABKQMgIhUgASkDEHwiEiABKQMAfCITIAEpA0ggECARVK18fCIRIAEpAzggECAUVq18fCIQNwMAIANBGGogECARVK0gESATVK0gEiATVq0gASkDCCASIBVUrSABKQMoIAEpAxh8fHx8fHw3AwAgBUEgaiEFIANBIGohAyAJQQFrIgkNAAsLIAg2AgAgAUHgAGokACAHQRBqJAAgCkEIaiANKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEO0YIAAgCyAMEM4dIARBQGskAAuLCQIOfwh+IwBBQGoiBiQAIAYgAjYCDCAGQRBqIg0gARCSNhDuJSABKAIUIQIgBiABKAIQIgE2AjQgBiABIAJBYHFqNgI4IAYgBkEMajYCPCAGQShqIQojAEEgayICJAAgAkEUaiAGQTRqIgsiASgCBCABKAIAa0EFdkEAQRBBEBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQSBrIgQkACACQQhqIgUgASgCBCABKAIAa0EFdhDrLSAFKQIEIREgBEEQaiABQQhqKAIANgIAIAQgASkCADcDCCAEIBFCIIk3AhggBCAFQQhqNgIUIwBBkAFrIgEkACAEQRRqIgMoAgQhCSADKAIAIQ8CQAJAIARBCGoiBygCACIFIAcoAgQiCEcEQCAHKAIIIRAgAygCCCAJQQR0aiEHIAggBWtBBXYhDANAIAVBGGopAwAhEiAQKAIAIQggBSkDCCETIAUpAwAhFCABIAVBEGopAwAiGDcDECABIBI3AxggASAUNwMAIAEgEzcDCCABQUBrIBQgEyAYIBIgCCgCACIDKQMAIAMpAwggAykDECADKQMYEJoIAn4gAS0AQEEBRgRAIAEtAEEEQEKAgICAgICAgIB/IRZCACEVQgAhEUIADAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQdSngAEQ7ywACyABKQNoIRYgASkDYCERIAEpA1ghFSABKQNQCyEXIAFBQGsgFCATIBggEiADKQMAIAMpAwggAykDECADKQMYEJoIAkAgAS0AQEEBRgRAIAEtAEEEQCABQThqQgA3AwAgAUEwakIANwMAIAFCADcDKCABQgA3AyAMAgsgAUEANgIwIAFBATYCJCABQcyngAE2AiAgAUIENwIoIAFBIGpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEiAVIBJQrXwiE4RQrXwiFCARVK18IRYMAgsgF0IBfSESIBUgF1CtfSETIBEgFSAXhFCtIhV9IRQgFiARIBVUrX0hFgwBCyARIRQgFyESIBUhEwsgAUFAayASIBMgFCAWENYjIAEoAkBBAXFFDQIgASkDWCERIAcgASkDUDcDACAHIBE3AwggBUEgaiEFIAdBEGohByAJQQFqIQkgDEEBayIMDQALCyAPIAk2AgAgAUGQAWokAAwBC0HwrYABELI7AAsgBEEgaiQAIApBCGogDigCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDsGCAAIAsgDRDLHSAGQUBrJAAL5QgCDn8IfiMAQUBqIgYkACAGIAI2AgwgBkEQaiINIAEQkjYQ7iUgASgCFCECIAYgASgCECIBNgI0IAYgASACQWBxajYCOCAGIAZBDGo2AjwgBkEoaiEKIwBBIGsiAiQAIAJBFGogBkE0aiILIgEoAgQgASgCAGtBBXZBAEEQQSAQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEgayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBBXYQ7y0gBSkCBCERIARBEGogAUEIaigCADYCACAEIAEpAgA3AwggBCARQiCJNwIYIAQgBUEIajYCFCMAQZABayIBJAAgBEEUaiIDKAIEIQkgAygCACAEQQhqIgcoAgAiBSAHKAIEIghHBEAgBygCCCEQIAMoAgggCUEFdGohByAIIAVrQQV2IQwDQCAFQRhqKQMAIRIgECgCACEIIAUpAwghEyAFKQMAIRQgASAFQRBqKQMAIhg3AxAgASASNwMYIAEgFDcDACABIBM3AwggAUFAayAUIBMgGCASIAgoAgAiAykDACADKQMIIAMpAxAgAykDGBCaCAJ+IAEtAEBBAUYEQCABLQBBBEBCgICAgICAgICAfyEWQgAhFUIAIRFCAAwCCyABQQA2AjAgAUEBNgIkIAFBzKeAATYCICABQgQ3AiggAUEgakHUp4ABEO8sAAsgASkDaCEWIAEpA2AhESABKQNYIRUgASkDUAshFyABQUBrIBQgEyAYIBIgAykDACADKQMIIAMpAxAgAykDGBCaCAJAIAEtAEBBAUYEQCABLQBBBEAgAUE4akIANwMAIAFBMGpCADcDACABQgA3AyggAUIANwMgDAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQeSngAEQ7ywACyABIAEpA4gBNwM4IAEgASkDgAE3AzAgASABKQN4NwMoIAEgASkDcDcDIAsgAUHYAGpCADcDACABQdAAakIANwMAIAFCADcDSCABQgA3A0ACQAJAAkAgASABQUBrEPsbIgNB/wFxQQJHIAPAQQBOcUUEQCABQSBqIAgoAggQ+xvAQQBMDQEMAgsgAUEgaiAIKAIEEPsbIgNB/wFxQQJGIAPAQQBIcg0BIBYgESAXQgF8IhIgFSASUK18IhOEUK18IhQgEVStfCEWDAILIBdCAX0hEiAVIBdQrX0hEyARIBUgF4RQrSIVfSEUIBYgESAVVK19IRYMAQsgESEUIBchEiAVIRMLIAdBGGogFjcDACAHQRBqIBQ3AwAgByATNwMIIAcgEjcDACAFQSBqIQUgB0EgaiEHIAlBAWohCSAMQQFrIgwNAAsLIAk2AgAgAUGQAWokACAEQSBqJAAgCkEIaiAOKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEO0YIAAgCyANEM4dIAZBQGskAAuaBAIMfwF+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBYHFqNgI4IAQgBEEMajYCPCAEQShqIQsjAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBBXZBAEEIQQgQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIJJAAgA0EIaiIBIAUoAgQgBSgCAGtBBXYQ7C0gCSABKQIEQiCJNwIIIAkgAUEIajYCBCMAQSBrIggkACAJQQRqIgcoAgQhCiAHKAIAIQ4CQAJAIAUoAgAiBiAFKAIEIgJHBEAgBSgCCCEBIAcoAgggCkEDdGohByACIAZrQQV2IQIDQCAIIAYpAwAgBikDCCAGQRBqKQMAIAZBGGopAwAQ1iMgCCgCAEEBcUUNAiAIKQMYIAgpAxAiD0KAgICAgICAgIB/fSAPVK18UEUNAiAHIAEoAgApAwAgD343AwAgBkEgaiEGIAdBCGohByAKQQFqIQogAkEBayICDQALCyAOIAo2AgAgCEEgaiQADAELQYCugAEQsjsACyAJQRBqJAAgC0EIaiANKAIANgIAIAsgAykCCDcCACADQSBqJAAgBSALEL0YIAAgBSAMEMYdIARBQGskAAurBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayICJAAgAkEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQRBBIBCgGCACKAIYIQEgAigCFEEBRgRAIAEgAigCHEHcj/8AEP0vAAsgAkEQaiIVQQA2AgAgAiACKAIcNgIMIAIgATYCCCMAQRBrIg8kACACQQhqIgEgCigCBCAKKAIAa0EEdhDvLSAPIAEpAgRCIIk3AgggDyABQQhqNgIEIwBBQGoiASQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkAgCigCACIOIAooAgQiDEcEQCAKKAIIIRcgDSgCCCAQQQV0aiEKIAwgDmtBBHYhDQNAQoCAgICAgICAgH8hBgJ+AkACQCAOKQMAIgcgDikDCCIIQoCAgICAgICAgH+FhEIAUiAXKAIAIgwoAgAiEikDCCIEIBIpAwAiA4NCf1JyRQRAQgAhA0IAIQRCACEFDAELIAMgBIRQDQUgAUEQaiAHIAggAyAEEIMZIAEgASkDECIFIAEpAxgiBiADIAQQqB5CACAHIAEpAwAiCX0gAyAEg0J/USISGyEDQgAgCCABKQMIfSAHIAlUrX0gEhshBCAIQgBZDQELIAUgAyAMKAIIIgwpAwBYIAQgDCkDCCIDVyADIARRG60iA30hBCAGIAMgBVatfQwBCyAGIAUgAyAMKAIEIgwpAwBaIAQgDCkDCCIDWSADIARRG618IgQgBVStfAshBSABQSBqIAQgBRCyLiABKQMgIQQgASkDKCEFIAEpAzAhAyAKQRhqIAEpAzg3AwAgCkEQaiADNwMAIAogBTcDCCAKIAQ3AwAgDkEQaiEOIApBIGohCiAQQQFqIRAgDUEBayINDQALCyAWIBA2AgAgAUFAayQADAELQcSogAEQ4isACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgAikCCDcCACACQSBqJAAgEyAREO0YIAAgEyAUEM4dIAtBQGskAAv7BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASgCACAEENorIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAv4BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASAEEK0qIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAv7BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASgCACAEEI8sIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAuTBAEJfyMAQRBrIgckAAJAIAJFDQAgASACakEBayIDRQ0AIAMtAABBMGtB/wFxQQlLDQAgB0EIaiEJQQAhAyMAQSBrIgUkAAJAAkACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIEciEDAkAgBEUEQCACIANGBEBBASEDDAMLIANBAnIiBCACIAIgBEsbIQQDQCACIANGDQIgBUEYaiABIANqLQAAEJAaIAUtABhFDQMgBS0AGSAGQQpsaiEGIAQgA0EBaiIDRw0ACyAEIQMMAgtBASEEIAIgA0YEQEEBIQMMBAsDQCAFQRBqIAEgA2otAAAQkBogBS0AEEUNBCAEIAUtABFFcSEEIANBAWoiAyACRw0ACwwCCyACIAJBsPOAARDDIQALQQEhBCACIANGDQAgAyACIAIgA0kbIQoDQCADIApGDQMgBUEIaiABIANqLQAAEJAaIAUtAAhFDQIgBCEIQQAhBAJAIAhFDQAgBkH/AXFBCmwiCEEIdg0AIAUtAAkiBiAIQf8BcWoiBEH/AXEgBEYhBCAGIAhqIQYLIAIgA0EBaiIDRw0ACwsgAiEDCyAJIAM2AgQgCSAGOgABIAkgBDoAACAFQSBqJAAMAQsgCiACQcDzgAEQwyEACyAHLQAIQQFHDQAgBygCDCACRw0AQQEhCyAHLQAJIQELIAAgAToAASAAIAs6AAAgB0EQaiQAC6oFAQp/IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQhqIQojAEEgayIFJAACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIDciEEAkAgAwRAQQEhB0EBIQMgAiAERg0BQQMgAiACQQNPGyEDA0ACQCACIARHBEAgBUEQaiABIARqLQAAEJAaIAUtABANASAEIQMMBAsgAiACQdDzgAEQwyEACyAGQQpsIAUtABFrIQYgAyAEQQFqIgRHDQALDAELIAIgBEYEQEEBIQQMAgsgBEECciIDIAIgAiADSxshAwJAA0AgAiAERg0BIAVBGGogASAEai0AABCQGiAFLQAYRQ0DIAUtABkgBkEKbGohBiADIARBAWoiBEcNAAsgAyEEDAILIAIgAkGw84ABEMMhAAsgAiADRg0BIAMgAiACIANJGyEJA0AgAyAJRwRAIAVBCGogASADai0AABCQGiAFLQAIRQ0EIAchBEEAIQcCQCAERQ0AIAbAQQpsIgvAIgQgC0cNACAEIAUtAAnAayIGwCAGRiEHCyACIANBAWoiA0cNAQwDCwsgCSACQeDzgAEQwyEAC0EBIQcgAiAERg0AIAQgAiACIARJGyEJA0ACQCAEIAlHBEAgBSABIARqLQAAEJAaIAUtAAANASAEIQMMBAsgCSACQcDzgAEQwyEACyAHIQNBACEHAkAgA0UNACAGwEEKbCILwCIDIAtHDQAgAyAFLQABwGoiBsAgBkYhBwsgAiAEQQFqIgRHDQALCyACIQMLIAogAzYCBCAKIAY6AAEgCiAHOgAAIAVBIGokACAILQAIQQFHDQAgCCgCDCACRw0AQQEhDCAILQAJIQELIAAgAToAASAAIAw6AAAgCEEQaiQAC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGE/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANB/PuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2zxHDQELIANBKGpBgPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQfj6gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDbPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQYuWrNgANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQouWrNiw4cKFCzcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakGEiJAgNgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoSIkKDAgIGCBDcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGQ/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBiPyDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvJAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEoAghHDQELIANBKGpBhoyYMDYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KGjJiw4MCBgwY3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABKAIINgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpBqPyDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQaD8gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQdT7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HM+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGPnrz4ADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KPnrz48OHDhw83AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2jxHDQELIANBKGpBvPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQbT7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDaPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQez7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Hk+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakGIkKDAADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KIkKDAgIGChAg3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENs8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpB+PuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQfD7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQZj7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0GQ+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakHg+4MBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANB2PuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENs8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2jxHDQELIANBKGpBjPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQYT7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDaPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQcj7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HA+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDZPEcNAQsgA0EoakGHjpw4NgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoeOnLjw4MGDBzcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2Tw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDcPEcNAQsgA0EoakGc/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBlPyDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENw8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2TxHDQELIANBKGpBipSo0AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCipSo0KDBgoUKNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDZPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQaT7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Gc+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGw+4MBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBqPuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2zxHDQELIANBKGpBjpy48AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCjpy48ODBg4cONwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDbPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQfT6gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Hs+oMBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakHQ+oMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANByPqDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpB6PqDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQeD6gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALyQMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQYWKlCg2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANChYqUqNCgwYIFNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQdz6gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HU+oMBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgASgCCEcNAQsgA0EoakGChIgQNgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoKEiJCgwICBAjcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEoAgg2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGJkqTIADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KJkqTIkKHChAk3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvJAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2TxHDQELIANBKGpBg4aMGDYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KDhoyYsODAgQM3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENk8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpBjJiw4AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCjJiw4MCBg4YMNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALegEDfyMAQSBrIgUkACAFIAM3AxggBSACNwMQIAUgATcDCCAFIAA3AwACQCAEQf8BcSIEQcwASw0AIAUgBEEFdCIEQcCnhQFqEPsbIgdB/wFxQQJGIAfAQQBIcg0AIAUgBEGglIUBahD7G8BBAEwhBgsgBUEgaiQAIAYL4wQBCH8jAEEwayIDJAAgA0EDNgIMIANB/I+GATYCCCADQgI3AhQgA0HHAjYCLCADQeyPhgE2AiggA0HHAjYCJCADQcyOhgE2AiAgAyADQSBqNgIQQQEhCAJAIAEoAgAgASgCBCADQQhqEMsKDQAjAEFAaiICJAACQAJAIAAoAhRBAnYiCUEBayIFRQ0AQQogBSAFQQpPGyEHAkADQAJAIAAgBBCWJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIAXIAIoAhAgAigCFCABEMUjDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByAEQQFqIgRHDQALIAVBC0kNASAFQRVPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgCUEVazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAlBC2siBCAHIAQgB0sbIgQgBU8NAQNAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQgBcgAigCCCACKAIMIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAEQQFqIgQgBUcNAAsMAQtBASEGDAELQQAhBgsgAkFAayQAIAYNACABKAIAQZSQhgFBASABKAIEKAIMEQYAIQgLIANBMGokACAIC+0EAQh/IwBBMGsiAyQAIANBAzYCDCADQfyPhgE2AgggA0ICNwIUIANBxwI2AiwgA0HcjoYBNgIoIANBxwI2AiQgA0HMjoYBNgIgIAMgA0EgajYCEEEBIQgCQCABKAIAIAEoAgQgA0EIahDLCg0AIwBBQGoiAiQAAkACQCAAKAIUQQJ2IglBAWsiBUUNAEEKIAUgBUEKTxshBwJAA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQRBqIAAgBBD/FiACIAIpAxA3AhwgAkEcaiABELI2DQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByAEQQFqIgRHDQALIAVBC0kNASAFQRVPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgCUEVazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAlBC2siBCAHIAQgB0sbIgQgBU8NAQNAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQ/xYgAiACKQMINwIcIAJBHGogARCyNg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgL7QQBCH8jAEEwayIDJAAgA0EDNgIMIANB/I+GATYCCCADQgI3AhQgA0HHAjYCLCADQdyOhgE2AiggA0HHAjYCJCADQdyPhgE2AiAgAyADQSBqNgIQQQEhCAJAIAEoAgAgASgCBCADQQhqEMsKDQAjAEFAaiICJAACQAJAIAAoAhRBA3YiCUEBayIFRQ0AQQogBSAFQQpPGyEHAkADQAJAIAAgBBCWJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEPEWIAIgAikDEDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAJQRVrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgCUELayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBDxFiACIAIpAwg3AhwgAkEcaiABELI2DQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBEEBaiIEIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBQGskACAGDQAgASgCAEGUkIYBQQEgASgCBCgCDBEGACEICyADQTBqJAAgCAvjBAEIfyMAQTBrIgMkACADQQM2AgwgA0H8j4YBNgIIIANCAjcCFCADQccCNgIsIANB7I+GATYCKCADQccCNgIkIANB3I+GATYCICADIANBIGo2AhBBASEIAkAgASgCACABKAIEIANBCGoQywoNACMAQUBqIgIkAAJAAkAgACgCFEEDdiIJQQFrIgVFDQBBCiAFIAVBCk8bIQcCQANAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQ8hYgAigCECACKAIUIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAJQRVrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgCUELayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBDyFiACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgL0wQBB38jAEEwayIDJAAgA0ECNgIQIANB0KKGATYCDCADQgE3AhggA0GcAzYCKCADIAAoAjQ2AiwgAyADQSRqNgIUIAMgA0EsajYCJEEBIQgCQCABKAIAIAEoAgQgA0EMahDLCg0AIwBBQGoiAiQAAkACQCAAKAIwIgVFDQBBCiAFIAVBCk8bIQcCQANAAkAgACAEEJslRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQoBsgAigCECACKAIUIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAFQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBUEKayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQmyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBCgGyACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBB4KKGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgLwgYBDX8jAEEwayIDJAAgA0ECNgIQIANBmKiGATYCDCADQgE3AhggA0GcAzYCKCADIAAoAiw2AiwgAyADQSRqNgIUIAMgA0EsajYCJEEBIQ0CQCABKAIAIAEoAgQgA0EMahDLCg0AIwBBQGoiAiQAAkACQCAAKAIwIgZFDQBBCiAGIAZBCk8bIQUgACgCDEEIaiEOIAAoAhAhCyAAKAIsIQkCQANAAkAgACAEEJolRQRAQQEhDCABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAOIAsoAghBAWtBeHFqIAggCSALKAIgEQUAIAIgAigCFCIKNgIgIAIgAigCECIHNgIcIAcgCigCCEEBa0F4cWpBCGogASAKKAIMEQIAIAcgBygCACIHQQFrNgIAIAdBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggCWohCCAFIARBAWoiBEcNAAsgBkELSQ0BIAZBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAGQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBkEKayIEIAUgBCAFSxsiBCAGTw0BIAAoAiwiByAEbCEIIAAoAgxBCGohCiAAKAIQIQsDQAJAIAAgBBCaJUUEQEEBIQwgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogCiALKAIIQQFrQXhxaiAIIAcgCygCIBEFACACIAIoAgwiCTYCICACIAIoAggiBTYCHCAFIAkoAghBAWtBeHFqQQhqIAEgCSgCDBECACAFIAUoAgAiBUEBazYCACAFQQFGBEAgAkEcahC7IwsNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIAhqIQggBEEBaiIEIAZHDQALDAELQQEhDAwBC0EAIQwLIAJBQGskACAMDQAgASgCAEHgooYBQQEgASgCBCgCDBEGACENCyADQTBqJAAgDQt4AQN/IwBBEGsiAiQAAkAgASgCCCIDBEAgAkEIaiABKAIEEMUbIAIoAgwiAyABKAIoIgFJDQEgAigCCCEEIAAgAyABazYCBCAAIAQgAUEDdGo2AgAgAkEQaiQADwtBACADQbDkhgEQwyEACyABIANBwOSGARCvOwALeAEDfyMAQRBrIgIkAAJAIAEoAggiAwRAIAJBCGogASgCBBDGGyACKAIMIgMgASgCKCIBSQ0BIAIoAgghBCAAIAMgAWs2AgQgACAEIAFBAXRqNgIAIAJBEGokAA8LQQAgA0Gw5IYBEMMhAAsgASADQcDkhgEQrzsAC3gBA38jAEEQayICJAACQCABKAIIIgMEQCACQQhqIAEoAgQQmyQgAigCDCIDIAEoAigiAUkNASACKAIIIQQgACADIAFrNgIEIAAgBCABQQN0ajYCACACQRBqJAAPC0EAIANBsOSGARDDIQALIAEgA0HA5IYBEK87AAt4AQN/IwBBEGsiAiQAAkAgASgCCCIDBEAgAkEIaiABKAIEEMgbIAIoAgwiAyABKAIoIgFJDQEgAigCCCEEIAAgAyABazYCBCAAIAQgAUEEdGo2AgAgAkEQaiQADwtBACADQbDkhgEQwyEACyABIANBwOSGARCvOwALgQEBAn8jAEEQayIDJAACQCABKAIIIgQgAksEQCADQQhqIAEoAgQgAkEMbGoQxxsgAygCDCICIAEoAigiAUkNASADKAIIIQQgACACIAFrNgIEIAAgBCABQQJ0ajYCACADQRBqJAAPCyACIARBsOSGARDDIQALIAEgAkHA5IYBEK87AAt2AQN/IAAoAkwgAWoiAUEDdiABQQdxQQBHaiIBIAAoAgwiAksEQCABIAJrIQQgACgCBCIDIAFJBEAgACADQQF0IgIgARDeKiIDIAIgA0sbEOgZIAAoAgwhAgsgBARAIAAoAgggAmpBACAE/AsACyAAIAE2AgwLC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQRBBBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQJ0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEGwoogBEP0vAAt7AQF/IwBBIGsiAiQAAn8gACgCAEGAgICAeEcEQCABIAAoAgQgACgCCBD7NQwBCyACQRBqIAAoAgwoAgAiAEEIaikCADcDACACQRhqIABBEGopAgA3AwAgAiAAKQIANwMIIAEoAgAgASgCBCACQQhqEMsKCyACQSBqJAALkQEBAX8CQAJAAkACQCAALQCIAw4EAAMDAQMLIAAtALgBQQNGBEAgAEEIahD1LAsgACgCgAMiAUGEAU8EQCABEPIfCyAAKAKEAyIAQYMBSw0BDAILIAAtAPgCQQNGBEAgAEHIAWoQ9SwLIAAoAoADIgFBhAFPBEAgARDyHwsgACgChAMiAEGDAU0NAQsgABDyHwsL2wICBX8CfiMAQdACayIEJAAgBEEIaiAAEJUaIAQgASACEPooIARBpAFqIAQoAgAgBCgCBBCPNSADQQhPBEBB5ILDAEEZEJc9AAsjAEGwAWsiAiQAIAJBDGoiBSAEQaQBahCkKCACQRhqIgAgBEEIakGYAfwKAAAgBEG4AWogA0H/AXFBAnQiAUH8g8MAaigCACEDIAFB3IPDAGooAgAhByMAQUBqIgEkACABIABBQGsgBRCvEAJ/IAEoAggiBUGAgICAeEcEQCABKAIUIAEpAwAgASkCDCEKIAFBgoSMyAA2AjggAUEINgIwIAFBADYCKCABQgA3AxAgASAKNwIEIAEgBTYCACABENkTDAELIAEoAgALIgVBDGsgBzYCACAFQRBrIAM2AgAgAEGYAfwKAAAgAUFAayQAIAJBsAFqJAAgBEEANgKwASAEQbABahDRKUEIaiAEQdACaiQAC4EBAQF/IAAoAgAiACgCCCIBBEAgAEEUaiAAKAIMIAAoAhAgASgCEBEBAAsgACgCHCIBBEAgACgCICABKAIMEQMACyAAKAIoIgEEQCAAKAIsIAEoAgwRAwALAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQThBBBD4OgsLfgEBfyAAKAIAIgBBKGoiARCfLCABEPM7IAAoAjRBgICAgHhHBEAgAEE0ahDqOwsgACgCRCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHEAGoQhh8LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQcgAQQgQ+DoLC4MBAQJ/IAAoAgAiAEEMaiIBENIkIAAoAgwiAiACKAIAQQFrIgI2AgAgAkUEQCABENQiCwJAIAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDpJwsCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBFEEEEPg6Cwv1AQEDfyMAQRBrIgIkAAJAAkAgAUUEQAJAAkAgAARAIABBCGsiASgCAEEBRw0BIAAoAgghAyAAKAIEIQQgAUEANgIAAkAgAUF/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIAFBFEEEEPg6CyACIAM2AgQgAiAENgIADAILEJg9AAtBzMjMAEE/EJc9AAsgAigCBCEAIAIoAgAiARCHNSABQcAAQQgQ+DogABCINSAAQTBBCBD4OgwBCyAARQ0BIAIgAEEIayIANgIMIAAgACgCAEEBayIANgIAIAANACACQQxqEO4mCyACQRBqJAAPCxCYPQALfQEBfyMAQRBrIgIkAAJAAkAgAUUEQCACIAAQzCEiADYCCCAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEIahD4IwwBCyAARQ0BIAIgAEEIayIANgIMIAAgACgCAEEBayIANgIAIAANACACQQxqEIQmCyACQRBqJAAPCxCYPQALhQEBA38CQAJAIAEoAhQiAyACpyIESwRAIAEoAhAgBEEDdGoiAygCBCIEIAMoAgAiA0kNASAEIAEoAggiBUsNAiABKAIEIQEgACAEIANrNgIEIAAgASADajYCAA8LIAQgA0GA+M0AEMMhAAsgAyAEQZD4zQAQsTsACyAEIAVBkPjNABCwOwALewECfyMAQSBrIgMkACADQQhqIAEgASgCQCIEIAIgAiAESxsQ3Q4gAygCDCECAkAgAygCCCIEQQhHBEAgACADKQMQNwMIIABBEGogA0EYaikDADcDAAwBCyABIAEoAkAgAms2AkALIAAgBDYCACAAIAI2AgQgA0EgaiQAC4MBAQF/IwBBMGsiBCQAIAQgAjYCDCAEIAE2AghBBCECIAAgAy0AAEECRgR/IARBATYCFCAEQeyOzwA2AhAgBEIBNwIcIARBzAE2AiwgBCAEQShqNgIYIAQgBEEIajYCKCAAQQRqIARBEGoQmQ4gAEEAOgAQQQEFIAILNgIAIARBMGokAAuHAQEBfyMAQTBrIgQkACAEIAI2AgwgBCABNgIIQQQhAiAAIAMoAgBBgICAgHhGBH8gBEEBNgIUIARB7I7PADYCECAEQgE3AhwgBEHMATYCLCAEIARBKGo2AhggBCAEQQhqNgIoIABBBGogBEEQahCZDiAAQQA6ABBBAQUgAgs2AgAgBEEwaiQAC4MBAQF/IwBBMGsiBCQAIAQgAjYCDCAEIAE2AghBBCECIAAgAy0AAEEDRgR/IARBATYCFCAEQeyOzwA2AhAgBEIBNwIcIARBzAE2AiwgBCAEQShqNgIYIAQgBEEIajYCKCAAQQRqIARBEGoQmQ4gAEEAOgAQQQEFIAILNgIAIARBMGokAAtnAQJ/IAAoAggiAgRAIAAoAgRBQGshAANAIABBFGoQ3jsCQCAAKAIAIgFBEkYNAEEQIAFBAmsgAUEBTRsiAUEPSQ0AQQhBBCABQQ9HGyAAahCGMAsgAEHgAGohACACQQFrIgINAAsLC4kBAQN/EKkvIQUQqi8iA0IANwIUIANCgICAgMAANwIMIANBADoACCADQoKAgIAQNwIAIAUgAzYCACACKAIAIgIgAigCACIEQQFqNgIAAkAgBEEASA0AIAEoAggoAgAiASABKAIAIgRBAWo2AgAgBEEASA0AIAAgAiABIAUQnAMgACADNgKwBQ8LAAuYAQEBfyMAQRBrIgIkAAJ/AkACQAJAAkAgACgCACIAKAIAQQFrDgMBAgMACyACIABBCGo2AgwgAUHgzNEAQQ5B7szRAEEIIABBBGpBwMzRAEH2zNEAQQYgAkEMakHQzNEAEI4YDAMLIAFB/MzRAEESEPs1DAILIAFBjs3RAEETEPs1DAELIAFBoc3RAEEREPs1CyACQRBqJAALgAECAX8BfiMAQSBrIgQkACAEQgA3AwAgAUEHTQRAIARBADYCGCAEQQE2AgwgBEHA/9EANgIIIARCBDcCECAEQQhqQbiO0gAQ7ywACyAEQQggAEEIQciO0gAQ1SwgBCkDACAEQSBqJAAgA0E4bEE4ca2GQr3P1vEBfiACQT9xrYinC4YBAQJ/IwBBIGsiAiQAAn8gAC8BACIDQQJNBEAgASADQQJ0IgBBxPH+AGooAgAgAEG48f4AaigCABD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfULNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAuGAQECfyMAQSBrIgIkAAJ/IAAvAQAiA0EDTQRAIAEgA0ECdCIAQeDx/gBqKAIAIABB0PH+AGooAgAQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALhgEBAn8jAEEgayICJAACfyAALwEAIgNBAk0EQCABIANBAnQiAEH88f4AaigCACAAQfDx/gBqKAIAEPs1DAELIAJBAjYCBCACQeDu/gA2AgAgAkIBNwIMIAJB9Qs2AhwgAiAANgIYIAIgAkEYajYCCCABKAIAIAEoAgQgAhDLCgsgAkEgaiQAC4YBAQJ/IwBBIGsiAiQAAn8gAC0AACIDQRpNBEAgASADQQJ0IgBB9PL+AGooAgAgAEGI8v4AaigCABD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfYLNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAuGAQECfyMAQSBrIgIkAAJ/IAAtAAAiA0EFTQRAIAEgA0ECdCIAQfT//gBqKAIAIABB3P/+AGooAgAQ+zUMAQsgAkECNgIEIAJBlP/+ADYCACACQgE3AgwgAkGADDYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALkQEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC47Di8bKTqs3WAIUgASkDGEKw3+Dy+LaU9Id/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC8vypnuWPoZ0rhSABKQMYQtmLjbqZvu3vr3+FhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEELut8rBy8Ln6Ll/hSABKQMYQvCO45ubiNaLEYWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC48BAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQqSv9PqoqZ2QLYUgASkDGELjrPqF49vQ9WyFhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEELMtKL9lYSLoWSFIAEpAxhC/oqN/Lqw25rcAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQofA7OjEzr/RyQCFIAEpAxhCvr+ev6/DpIL4AIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5ABAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQof529rX0fyYPIUgASkDGEK27+i19KWCvpZ/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC3KeGzZSXyb2Wf4UgASkDGEKF8OaFkNqf4wyFhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEEKfwr6izL/IoCGFIAEpAxhC1sWUxpj99dj4AIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQsmQrefTvtn4nH+FIAEpAxhC8fLKq+fn0cbCAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQo2j65PMtMaQ9wCFIAEpAxhC2avs9tngxfSMf4WEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQvv22Orw4o2fxgCFIAEpAxhCmYalv/ivoY7SAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5ABAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQtHx98ycuun+ToUgASkDGELWwo+ZmLzyo/EAhYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkQEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBCtcP+voycqqbDAIUgASkDGEKS+8eQvuyY/qN/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBCmcTpt9SjhcVuhSABKQMYQpiWydPQ9J6WrX+FhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABC9JUUEQCABQShqQYiQoMAANgIAIAFCiJCgwICBgoQINwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQviVFBEAgAUEoakGMmLDgADYCACABQoyYsODAgYOGDDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEL8lRQRAIAFBKGpBiZKkyAA2AgAgAUKJkqTIkKHChAk3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuUAQEBfyMAQUBqIgEkACABIAA2AgQgABDAJUUEQCABQShqQYSIkCA2AgAgAUKEiJCgwICBggQ3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDBJUUEQCABQShqQYuWrNgANgIAIAFCi5as2LDhwoULNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQwiVFBEAgAUEoakGOnLjwADYCACABQo6cuPDgwYOHDjcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5QBAQF/IwBBQGoiASQAIAEgADYCBCAAEMMlRQRAIAFBKGpBhYqUKDYCACABQoWKlKjQoMGCBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5QBAQF/IwBBQGoiASQAIAEgADYCBCAAEMQlRQRAIAFBKGpBh46cODYCACABQoeOnLjw4MGDBzcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEMUlRQRAIAFBKGpBj568+AA2AgAgAUKPnrz48OHDhw83AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDGJUUEQCABQShqQYqUqNAANgIAIAFCipSo0KDBgoUKNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQxyVFBEAgAUEoakGDhowYNgIAIAFCg4aMmLDgwIEDNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQyCVFBEAgAUEoakGChIgQNgIAIAFCgoSIkKDAgIECNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQySVFBEAgAUEoakGGjJgwNgIAIAFChoyYsODAgYMGNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALgAEBAX8jAEHQAGsiBiQAIAYgASACIAMgBCAFEOQHIAYtAABBKUcEQCAAIAZBOPwKAAAgBkHQAGokAA8LIAZByABqIAZBFGooAgA2AgAgBkFAayAGQQxqKQIANwMAIAYgBikCBDcDOEGsz4UBQSsgBkE4akGcz4UBQaDVhQEQ1R4AC4ABAQF/IwBB0ABrIgYkACAGIAEgAiADIAQgBRDlByAGLQAAQSlHBEAgACAGQTj8CgAAIAZB0ABqJAAPCyAGQcgAaiAGQRRqKAIANgIAIAZBQGsgBkEMaikCADcDACAGIAYpAgQ3AzhBrM+FAUErIAZBOGpBnM+FAUGg1YUBENUeAAveBQEKfyMAQTBrIgMkACADQgE3AgggA0ECNgIUIANB3NqFATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCgJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAhxBAnYiC0EBayIHRQ0AQQogByAHQQpPGyEGAkADQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIAZIAIgAigCFCIJNgIgIAIgAigCECIFNgIcIAUgCSgCCEEBa0F4cWpBCGogASAJKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAHQQtJDQEgB0EVTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAtBFWs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyALQQtrIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEEIAZIAIgAigCDCIFNgIgIAIgAigCCCIGNgIcIAYgBSgCCEEBa0F4cWpBCGogASAFKAIMEQIAIAYgBigCACIGQQFrNgIAIAZBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQgMAQtBACEICyACQUBrJAAgCA0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCgsgA0EwaiQAIAoLjQEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQcTnhQEpAgA3AiggAEEwakHM54UBKAIANgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEQQRAQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABB9OeFASkCADcCKCAAQTBqQfznhQEoAgA2AgAgAkEQaiQAC40BAQN/IwBBEGsiAiQAIAJBBGogAUEAQQhBCBCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEGA6IUBKQIANwIoIABBMGpBiOiFASgCADYCACACQRBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBEEEgEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQcjohQEpAgA3AiggAEEwakHQ6IUBKAIANgIAIAJBEGokAAveBQEKfyMAQTBrIgMkACADQgE3AgggA0ECNgIUIANB9JaGATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCwJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAigiBUEESQ0AQQogBUECdiIHIAdBCk8bIQYCQANAAkAgACAEEJclRQRAQQEhCSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQtBkgAiACKAIUIgo2AiAgAiACKAIQIgg2AhwgCCAKKAIIQQFrQXhxakEIaiABIAooAgwRAgAgCCAIKAIAIghBAWs2AgAgCEEBRgRAIAJBHGoQuyMLDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBiAEQQFqIgRHDQALIAVBLEkNASAFQdQATwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAdBFGs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyAHQQprIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCXJUUEQEEBIQkgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEELQZIAIgAigCDCIGNgIgIAIgAigCCCIFNgIcIAUgBigCCEEBa0F4cWpBCGogASAGKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQkMAQtBACEJCyACQUBrJAAgCQ0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCwsgA0EwaiQAIAsLfAECfyAAQRhqEMoMIAAQxScgAEEEQQwQ4B4gACgCFCICBEAgACgCECEBA0AgARClHiABQcQAaiEBIAJBAWsiAg0ACwsgAEEMakEEQcQAEOAeAkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwt8AQJ/IABBGGoQywwgABDFJyAAQQRBDBDgHiAAKAIUIgIEQCAAKAIQIQEDQCABEKUeIAFBxABqIQEgAkEBayICDQALCyAAQQxqQQRBxAAQ4B4CQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LC3gBBH8gASgCBCABKAIAayIDIAAoAgAgACgCCCICa0sEQCAAIAIgA0EBQQEQ3CggACgCCCECCyAAIAEoAgQiBCABKAIAIgNHBH8gBCADayIFBEAgACgCBCACaiABIANqQQhqIAX8CgAACyACIARqIANrBSACCzYCCAvhAQEFfyABBEACQCAAKAIMIgJBAXFFDQAgAkEFdiABaiIDQYCAgMAATwRAIAAoAgghBCAAKAIEIQUgACgCACEGIAAoAgwhA0EUQQQQrTYiAkUEQEEEQRQQoz0ACyACQQE2AhAgACACNgIMIAIgA0ECdkEHcTYCDCACIANBBXYiAyAFajYCCCACIAYgA2s2AgQgAiADIARqNgIADAELIAAgAkEfcSADQQV0cjYCDAsgACAAKAIAIAFqNgIAIAAgACgCCCABazYCCCAAIAAoAgQiACABayIBQQAgACABTxs2AgQLC24BBn4gACADQv////8PgyIFIAFC/////w+DIgZ+IgcgBiADQiCIIgZ+IgggBSABQiCIIgl+fCIFQiCGfCIKNwMAIAAgByAKVq0gBiAJfiAFIAhUrUIghiAFQiCIhHx8IAEgBH4gAiADfnx8NwMIC4IBAQF/AkAgAC0AtAFBCkkNACAAKAK8ASIBRQ0AIAAoArgBIAFBARD4OgsgAEHQAGoQ3jsgABDLKQJAIAAoApgBRQ0AIAAoApwBIgEEQCAAQagBaiAAKAKgASAAKAKkASABKAIQEQEADwsgACgCoAFBgICAgHhGDQAgAEGgAWoQ3jsLC4gBAQF/AkACQAJAIAAtAIAHDgQAAgIBAgsgACgC0AEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB0AFqEJ0nCyAAKQMAQgNSBEAgABCpHg8LIABBCGoQoSkPCyAAQbADahDNJCAAKAKoAyIBIAEoAgAiAUEBazYCACABQQFHDQAgAEGoA2oQnScLC3oBAn8jAEEQayIFJAAgBUEEaiABEN0gQcAAQQgQrTYiBEUEQEEIQcAAEKM9AAsgBCADNgIoIAQgAjcDICAEIAUpAgQ3AiwgBEEAOgA4IARBNGogBUEMaigCADYCACABEN47IABBsJjDADYCBCAAIAQ2AgAgBUEQaiQAC6YBAQJ/IwBBEGsiBSQAIAJB/wFxQQdGBH9BAAVBAkEBEK02IgRFBEBBAUECEKM9AAsgBCADOgABIAQgAjoAACAFQQhqIgJBhOTDADYCBCACIAQ2AgAgBSgCDCEEIAUoAggLIQNB1ABBBBCtNiICRQRAQQRB1AAQoz0ACyACIAQ2AlAgAiADNgJMIAIgATsBSiACIAA7AUggAkECNgIAIAVBEGokACACC3wBAn8jAEEQayIBJAAgACgCACAAQQA2AgAEQCABIAAoAgQiADYCCCABQbDtwwBBGRCTPiICNgIMIAFBCGogAUEMahCiOyACQYQBTwRAIAIQ8h8gASgCCCEACyAAQYQBTwRAIAAQ8h8LIAFBEGokAA8LQczswwBBHBCXPQALiwEBAn8jAEEQayICJAACQAJAAkACQCABLQAAQQFrDgIAAQILIABBAjoAACAAIAEoAAE2AAEMAgsgAEEDOgAAIAAgASkAATcAASAAQQlqIAFBCWopAAA3AAAMAQsgAkEIaiABQQRqIgMQ3DsgACACKAIMQQBHOgAAIAEtAAANACADEIYwCyACQRBqJAALdQECfyMAQSBrIgIkACACQRhqIAFBCGooAgA2AgAgAiABKQIANwMQIAJBCGogAkEQahDlESACKAIIIgEEQCACKAIMIQMDQCAAIAEgASADahCCJiACIAJBEGoQ5REgAigCBCEDIAIoAgAiAQ0ACwsgAkEgaiQAC4QBAQN/AkACQCAAIAAoAgwiAQR/IAEFIAAgACgCBEEBaiIBNgIEIAEgACgCACICKAIEIgNPDQEgACACKAIAIAFqLQAANgIIIAEgAigCDCIDTw0CIAIoAgggAUECdGooAgALQQFrNgIMDwsgASADQfzqzAAQwyEACyABIANBjOvMABDDIQALggEBAX4CQAJAAkACQEEBIAApAwAiAadBAmsgAUIBWBsOAwECAwALIABBCGoQgykPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKiAAKAJAQYAgQQQQ+DoPCyAAQQhqEOk7IABBIGogACgCGCAAKAIcIAAoAhQoAhARAQALjwEBAn8jAEEQayICJAAgAEEBaiEDAn8CQAJAAkAgAC0AAEEBaw4CAQIACyACIAM2AgQgAUGcy80AQQYgAkEEakGMy80AENATDAILIAIgAzYCCCABQbTLzQBBBiACQQhqQaTLzQAQ0BMMAQsgAiADNgIMIAFBzMvNAEEFIAJBDGpBvMvNABDQEwsgAkEQaiQAC4sBAQN/IwBBEGsiASQAIAFBBGpBD0EAQQFBARCgGCABKAIIIQIgASgCBEEBRgRAIAIgASgCDEHYp84AEP0vAAsgASgCDCIDQQdqQZ+yzgApAAA3AAAgA0GYss4AKQAANwAAIABBBToAECAAQQ82AgwgACADNgIIIAAgAjYCBCAAQQE2AgAgAUEQaiQAC4sBAQN/IwBBEGsiASQAIAFBBGpBDkEAQQFBARCgGCABKAIIIQIgASgCBEEBRgRAIAIgASgCDEHYp84AEP0vAAsgASgCDCIDQQZqQYa0zgApAAA3AAAgA0GAtM4AKQAANwAAIABBBDoAECAAQQ42AgwgACADNgIIIAAgAjYCBCAAQQA2AgAgAUEQaiQAC4EBAgJ/AX4jAEEQayIEJAAgASkCICEGIAEgAikCADcCICAEQQhqIAFBKGoiBSkCADcDACAFIAJBCGopAgA3AgAgBCAGNwMAIAanIgIEQCAEQQxqIAQoAgQgBCgCCCACKAIQEQEACyABIAM2AjAgAUEANgI0IABBCDYCACAEQRBqJAALhgECAX8CfiMAQSBrIgIkACACQgA3AwAgAUEHTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQcTZzgAQ7ywACyACQQggAEEIQdTZzgAQ1SwgAjUCACEDIAIxAAQgAkEgaiQAQjiGIANCGIaEQr3P1vHR9+maHn5CL4inC4YBAgF/An4jAEEgayICJAAgAkIANwMAIAFBB00EQCACQQA2AhggAkEBNgIMIAJBmNfOADYCCCACQgQ3AhAgAkEIakHE2c4AEO8sAAsgAkEIIABBCEHU2c4AENUsIAI1AgAhAyACMQAEIAJBIGokAEI4hiADQhiGhEK9z9bx0ffpmh5+QjCIpwuJAQECfyMAQSBrIgIkAAJ/IAFFBEAgAkEANgIcIAJCgICAgIABNwIUIAIgAkEUakGMh84AEKMhIAIoAgAhASACKAIEDAELIAJBFGoiAyABQcSe0AAQthUgAkEIaiADQcyCzgAQoyEgAigCCCEBIAIoAgwLIQMgACABNgIAIAAgAzYCBCACQSBqJAALhAEBAn8jAEEgayICJAACfyABRQRAIAJBADYCHCACQoCAgIDAADcCFCACIAJBFGpBjIfOABCYISACKAIAIQEgAigCBAwBCyACQRRqIgMgARCjFSACQQhqIANBzILOABCYISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBIGokAAuIAQECfyMAQSBrIgIkAAJ/IAFFBEAgAkEANgIcIAJCgICAgCA3AhQgAiACQRRqQYyHzgAQqiEgAigCACEBIAIoAgQMAQsgAkEUaiIDIAFBxJ7QABCZFSACQQhqIANBzILOABCqISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBIGokAAuIAQEBfyMAQSBrIgMkAAJ/IAFFBEAgA0EANgIcIANCgICAgCA3AhQgA0EIaiADQRRqQYyHzgAQqiEgAygCCCECIAMoAgwMAQsgA0EUaiIBIAJBxJ7QABCZFSADIAFBzILOABCqISADKAIAIQIgAygCBAshASAAIAI2AgAgACABNgIEIANBIGokAAuEAQEBfyMAQSBrIgMkAAJ/IAFFBEAgA0EANgIcIANCgICAgMAANwIUIANBCGogA0EUakGMh84AEJghIAMoAgghAiADKAIMDAELIANBFGoiASACEKMVIAMgAUHMgs4AEJghIAMoAgAhAiADKAIECyEBIAAgAjYCACAAIAE2AgQgA0EgaiQAC3wBAX8gABCfDAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfwECfyMAQRBrIgMkACABIAFBBGsiBCACKAIAIgIoAgAoAgARAgBBAEgEQCADIAEoAAA2AgwDQAJAIAQiAUEEaiABKAAANgAAIAAgAUYNACADQQxqIAFBBGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMoAgw2AAALIANBEGokAAt/AQJ/IwBBEGsiAyQAIAEgAUECayIEIAIoAgAiAigCACgCABECAEEASARAIAMgAS8AADsBDgNAAkAgBCIBQQJqIAEvAAA7AAAgACABRg0AIANBDmogAUECayIEIAIoAgAoAgARAgBBAEgNAQsLIAEgAy8BDjsAAAsgA0EQaiQAC38BAn8jAEEQayIDJAAgASABQQFrIgQgAigCACICKAIAKAIAEQIAQQBIBEAgAyABLQAAOgAPA0ACQCAEIgFBAWogAS0AADoAACAAIAFGDQAgA0EPaiABQQFrIgQgAigCACgCABECAEEASA0BCwsgASADLQAPOgAACyADQRBqJAALfwECfyMAQRBrIgMkACABIAFBCGsiBCACKAIAIgIoAgAoAgARAgBBAEgEQCADIAEpAAA3AwgDQAJAIAQiAUEIaiABKQAANwAAIAAgAUYNACADQQhqIAFBCGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMpAwg3AAALIANBEGokAAt2AQF/IwBBIGsiBSQAIAUgAiADIAEgBBCHKiABIAUoAgQgBSgCACICayIBa0EATwRAIAEEQCAAIAAgAmogAfwKAAALIAVBIGokAA8LIAVBADYCGCAFQQE2AgwgBUHk6PwANgIIIAVCBDcCECAFQQhqIAQQ7ywAC3wBAX8gABCnDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEPseCwJAIAAoAiQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEkahD7HgsLfAEBfyAAEKgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQsgwCQCAAKAIgIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBIGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LC58CAgF/AXwjAEEgayIFJAAgAAJ/IAEoAgAgAhCHJUUEQCMAQTBrIgAkACABKAIAIQEgACACNgIAIAFBDGoQ2DwgAk0EQCAAIAEQ/Ts2AhwgAEECNgIIIABB8Ij/ADYCBCAAQgI3AhAgAEE7NgIsIABBOzYCJCAAIABBIGo2AgwgACAAQRxqNgIoIAAgADYCICAAQQRqQYCJ/wAQ7ywACyABKAIQIAJBA3RqKwMAIQYgAEEwaiQAIAUgBUEIaiAGEK4lQZOAgIB4QZSAgIB4IAMgBSgCACAFKAIEIAQoAgwRBgAbDAELQZSAgIB4IAEoAggiAEUNABpBk4CAgHhBlICAgHggAyABKAIEIAAgBCgCDBEGABsLNgIAIAVBIGokAAuKEgMOfwR+AX0jAEEgayIPJAAgAAJ/IAEoAgAgAhCHJUUEQCAPQQhqIQgjAEEwayIAJAAgASgCACEBIAAgAjYCACABQQxqENs8IAJNBEAgACABEPw7NgIcIABBAjYCCCAAQfCI/wA2AgQgAEICNwIQIABBOzYCLCAAQTs2AiQgACAAQSBqNgIMIAAgAEEcajYCKCAAIAA2AiAgAEEEakGAif8AEO8sAAsgASgCECACQQJ0aioCACEXIABBMGokACMAQRBrIhAkAAJ/IBe8Qf////8HcUH////7B00EQAJ/IBe8IgJB////A3EhACACQQBIBEAgCEEtOgAAQQEhCQsCfwJAAn8CQAJAAkACQAJAAkACQCACQRd2Qf8BcSIBIAByBEAgAEGAgIAEciAAIAEbIgJBAnQiBSAAQQBHIAFBAklyIhFBf3NqIQcgAkEBcSESIAVBAnIhAiABQZgBa0HpfiABGyINQQBIBEBByPyIASANIA1BhaJTbCIKQRR2Ig5qIgxBBHRrKQMAIhNC/////w+DIhQgB60iFX5CIIggFSATQiCIIhZ+fCAOQTxqIgcgDEGx2bUPbEETdmtBP3FBIHOtIhWIpyEBIBQgAq0iE35CIIggEyAWfnwgFYinIQYgFCAFrSITfkIgiCATIBZ+fCAViKchACAKQYCAwABJDQggBkEBa0EKbiABQQpuTQ0CDAULIA1BwegEbEESdiIMQQR0QejRiAFqKQMAQgF8IhNC/////w+DIhQgB60iFX5CIIggFSATQiCIIhZ+fCAMIA1rIgogDEHPpsoAbEETdmpBPWpBP3FBIHOtIhWIpyEBIBQgAq0iE35CIIggEyAWfnwgFYinIQYgFCAFrSITfkIgiCATIBZ+fCAViKchACANQQRPDQIMAwsgCCAJaiIAQaCliQEvAAA7AAAgAEECakGipYkBLQAAOgAAIAJBH3ZBA2oMCgtBASAMayICQQR0Qcj8iAFqKQMAIhRC/////w+DIBN+QiCIIBRCIIggE358IAcgAkHPpsoAbEF/c0ETdmpBP3FBIHOtiKdBCnAhCwwCCyAGQQFrQQpuIAFBCm5NBEAgDEEBayILQQR0QejRiAFqKQMAQgF8IhRC/////w+DIBN+QiCIIBRCIIggE358IAogC0HPpsoAbEETdmpBPGpBP3FBIHOtiKdBCnAhCwsgDUEiTw0CCyAFQQVwRQRAQQAhBwNAIAdBAWohByAFQQVuIgVBBXBFDQALIAcgDEkNAgwDCyASBEBBACEFIAJBBXBFBEADQCAFQQFqIQUgAkEFbiICQQVwRQ0ACwsgBiAFIAxPayEGDAILQQAhCkEAIQUgB0EFcEUEQANAIAVBAWohBSAHQQVuIgdBBXBFDQALCyAFIAxJDQFBASEODAULIApBgICAAUkNAiAKQYCAwA9PDQAgBUF/IA5BAWt0QX9zcUUNAQtBACEFIAZBCm4iByABQQpuIgJLBEADQCAFQQFqIQUgACIGQQpuIQAgB0EKbiIHIAIiAUEKbiICSw0ACyAGIABBCmxrIQsLIAAgAUYgC0H/AXFBBEtyDAQLQQAMAQsgBiASayEGIBJFIBFxCyEOQQEhCgtBACEFAkAgBkEKbiIRIAFBCm4iDU0EQCALIQYgASEHIAAhAgwBCwNAIA5BACABayANIgdBdmxGcSEOIAVBAWohBSAAIABBCm4iAkEKbGshBiAKIAtB/wFxRXEhCiACIQAgBiELIBFBCm4iESAHIgFBCm4iDUsNAAsLAkAgDkUgB0EKcHJFBEADQCAFQQFqIQUgAiACQQpuIgBBCmxrIQEgCiAGQf8BcUVxIQogACECIAEhBiAHQQpuIgdBCnBFDQAMAgsACyAGIQEgAiEACyASRSAOcUUgACAHRnFBBUEEIABBAXEbIAEgAUH/AXFBBUYbIAEgChtB/wFxQQRLcgshAgJ/AkACQAJAAkACQCAFIAxqIgFBAE4gAQJ/QQkgACACaiIAQf/B1y9LDQAaQQggAEH/rOIESw0AGkEHIABBv4Q9Sw0AGkEGIABBn40GSw0AGkEFIABBj84ASw0AGkEEIABB5wdLDQAaQQMgAEHjAEsNABpBAkEBIABBCUsbCyIGaiICQQ5IcUUEQCACQQFrIgFBDUkNASACQQVqQQZJDQIgBkEBRw0EIAggCWoiBkHlADoAASAGIABBMGo6AAAgCCAJQQJyIgZqIQUgAUEASA0DIAEhAAwFCyAAIAggCWogBmoQwBQgAUUgAiAGTHJFBEAgBiAIaiAJakEwIAH8CwALIAggAiAJaiIAakGu4AA7AAAgAEECagwGCyAAIAggBiAJakEBaiIBahDAFCAIIAlqIQAgAgRAIAAgAEEBaiAC/AoAAAsgACACakEuOgAAIAEMBQsgCCAJaiIHQbDcADsAAEECIAJrIQECQCACQQBODQBBAyABIAFBA00bQQJrIgJFDQAgB0ECakEwIAL8CwALIAAgCCAGIAlqIAFqIgBqEMAUIAAMBAsgBUEtOgAAIAVBAWohBUEBIAJrIgBBCUoNASAFIABBMGo6AABBAgwCCyAAIAggBiAJaiIGaiIHQQFqEMAUIAggCWoiACAALQABOgAAIABBLjoAASAHQeUAOgABIAggBkECaiIGaiEFAn8CQCABQQBOBEAgASEADAELIAVBLToAACAFQQFqIQVBASACayIAQQlKDQAgBSAAQTBqOgAAQQIMAQsgBSAAQQF0QYjQiAFqLwAAOwAAIAFBH3ZBAnILIAZqDAILIAUgAEEBdEGI0IgBai8AADsAACABQR92QQJyCyAGagsMAQsgEEEIaiIAQQNBA0EEIBe8IgFBAE4iAhsgAUH///8DcSIBGzYCBCAAQdfRiAFB0NGIAUHT0YgBIAIbIAEbNgIAIBAoAgghCCAQKAIMCyEAIA8gCDYCACAPIAA2AgQgEEEQaiQAQZOAgIB4QZSAgIB4IAMgDygCACAPKAIEIAQoAgwRBgAbDAELQZSAgIB4IAEoAggiAEUNABpBk4CAgHhBlICAgHggAyABKAIEIAAgBCgCDBEGABsLNgIAIA9BIGokAAt8AQF/IAAQtAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3wBAX8gABC0DAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfAEBfyAAELYMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQtgwCQCAAKAIgIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBIGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LC3wBAX8gABC3DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEPseCwJAIAAoAiQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEkahD7HgsLfAEBfyAAELkMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQvgwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3wBAX8gABC+DAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfAEBfyAAEMMMAkAgACgCICIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSBqEPseCyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCyAAKAIUIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRRqEPseCwt8AQF/IAAQxwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3UBA38jAEEQayICJAACQCABKAIIIgMEQCACQQhqIAEoAgQQjx8gAigCDCIDIAEoAigiAUkNASACKAIIIQQgACADIAFrNgIEIAAgASAEajYCACACQRBqJAAPC0EAIANBsOSGARDDIQALIAEgA0HA5IYBEK87AAtzAQZ+IAEpAxgiAyABKQMIIgaFIQQgASkDACEFAkACQCABKQMQIgcgA4NCf1EEQCAEQgBZDQEMAgsgAyAHhEIAUiAEQgBTcg0BCyAFIAaFQoCAgICAgICAgH+DQgBSDQAgACAFNwMIQgEhAgsgACACNwMAC/gBAQd/AkAgACgCBCAAKAIAIgEoAghrIgcgACgCCCIEakEAIAQbIgMgASgCGE8NACABQX8gASgCBCICIAJBAUYbNgIEIAJBAUcNACABQQE2AgQgASgCAEEBRw0AAn8CQCABQQhqIgEoAggNAAJ/QQAgASgCECICIANGDQAaIAMgASgCDCIFENE0RQ0BIAEoAgAhBgJAIANFBEAgBiACIAUQ+DpBwAAhAgwBC0EBIAYgAiAFIAMQlzUiAkUNARoLIAEgAzYCECABQQA2AgggASADNgIEIAEgAjYCAEEACwwBC0EBCw0AIAAgASgCACAHQQAgBBtqNgIECwt+AQF/IwBBQGoiBSQAIAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAFQQI2AhwgBUGg8YkBNgIYIAVCAjcCJCAFIAVBEGqtQoCAgIDQ4wOENwM4IAUgBUEIaq1CgICAgODjA4Q3AzAgBSAFQTBqNgIgIAVBGGogBBDvLAALfgEEfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAQRAIAQgBSAB/AoAAAsgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQeC1wgAQ/S8AC3gBAn8gACgCCCICBEAgACgCBEE8aiEAA0AgAEE8ayIBKAIAQYCAgIB4RwRAIAEQ3jsgAEEwayIBENErIAEQ6DsgAEEkayIBENErIAEQ6DsgAEEYaxCFMCAAQQxrEIUwIAAQhTALIABBzABqIQAgAkEBayICDQALCwuOAQEBfwJAAkACQAJAIAAtAOgFDgQAAwMBAwsgAC0A6AJBA0YEQCAAEMopCyAAKALgBSIBQYQBTwRAIAEQ8h8LIAAoAuQFIgBBgwFLDQEMAgsgAC0A2AVBA0YEQCAAQfACahDKKQsgACgC4AUiAUGEAU8EQCABEPIfCyAAKALkBSIAQYMBTQ0BCyAAEPIfCwuNAQEBfwJAAkACQAJAIAAtALgBDgQAAwMBAwsgAC0AUEEDRgRAIAAQqywLIAAoArABIgFBhAFPBEAgARDyHwsgACgCtAEiAEGDAUsNAQwCCyAALQCoAUEDRgRAIABB2ABqEKssCyAAKAKwASIBQYQBTwRAIAEQ8h8LIAAoArQBIgBBgwFNDQELIAAQ8h8LC40BAQF/AkACQAJAAkAgAC0AmAEOBAADAwEDCyAALQBEQQNGBEAgABCAKgsgACgCkAEiAUGEAU8EQCABEPIfCyAAKAKUASIAQYMBSw0BDAILIAAtAIwBQQNGBEAgAEHIAGoQgCoLIAAoApABIgFBhAFPBEAgARDyHwsgACgClAEiAEGDAU0NAQsgABDyHwsLgAEBAX8gACgCACIAQRRqEI8MAkAgACgCCEGAgICAeEYEQCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQQxqEIMgDAELIABBCGoiARC+HyABEPA7CwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEoQQQQ+DoLC3IBBH8jAEEQayIBJAAgAUEIaiAAKAJgQQhqENw7AkACQCAAKAJsIgQgASgCDE8NACABKAIIIgNFDQAgAyAEQQJ0aigCACICIAIoAgAiA0EBajYCACADQQBIDQEgACAEQQFqNgJsCyABQRBqJAAgAg8LAAu4AQICfwJ+IwBBEGsiAiQAAkAgASkDACIFQgNSBEAgAUEQaiEDIAEpAwghBAJAAkACQCAFp0EBaw4CAAECCyADKQMoIAR8IQQMAQsgAykDICAEfCEECyADIAQ3AyAgAiAENwMIIAJBADYCACACKAIAQQJGBEAgAEECNgIADAILIAFCAzcDACAAIAIpAwA3AwAgAEEIaiACQQhqKQMANwMADAELIABCADcDCCAAQQA2AgALIAJBEGokAAt6AQF/IwBBEGsiAiQAAkACQCABRQRAIAIgABDJISIANgIIIAAgACgCAEEBayIANgIAIAANASACQQhqENQiDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQ5yYLIAJBEGokAA8LEJg9AAt1AQJ/IAAoAggiAQRAIAAoAgQhAANAIABBIGooAgAiAgRAIABBLGogAEEkaigCACAAQShqKAIAIAIoAhARAQALIABBGGogAEEQaigCACAAQRRqKAIAIABBDGooAgAoAhARAQAgAEE0aiEAIAFBAWsiAQ0ACwsLcAEEfyMAQRBrIgMkACADQQxqIQUCQCACRQ0AIAAoAgAiBkUNACADIAE2AgwgAiAGbCEEIAAoAgQhAiADQQhqIQULIAUgBDYCAAJAIAMoAgwiAEUNACADKAIIIgFFDQAgAiABIAAQ+DoLIANBEGokAAuAAQEEfyMAQRBrIgIkACACQQhqEP0nIAAoAgQhAyACKAIIIQQgACACKAIMNgIEIAAoAgAhBSAAIAQ2AgAgASAFIAMQ4DUgAhD+JyAAKAIMIQMgAigCACEEIAAgAigCBDYCDCAAKAIIIAAgBDYCCCADEIAxIABCADcCECACQRBqJAALeQAgACAAKAKAESADajYCgBEgAiADTwRAAkAgAwRAIANBAXQhAwNAIAEvAQAiAkGgBE8NAiAAIAJBAnRqIgIgAigCAEEBajYCACABQQJqIQEgA0ECayIDDQALCw8LIAJBoARBzOrMABDDIQALIAMgAkG86swAELA7AAt5ACAAIAAoAoAWIANqNgKAFiACIANPBEACQCADBEAgA0EBdCEDA0AgAS8BACICQcAFTw0CIAAgAkECdGoiAiACKAIAQQFqNgIAIAFBAmohASADQQJrIgMNAAsLDwsgAkHABUHM6swAEMMhAAsgAyACQbzqzAAQsDsAC38BAn8jAEEwayICJAAgAiABNgIMQQghAwJAIAFBCE8EQCACQQE2AhQgAkGg+M4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQAhAwwBCyAAIAE6AAQLIAAgAzYCACACQTBqJAALeQEBfyMAQTBrIgIkACACIAE2AgwgAAJ/IAFBA08EQCACQQE2AhQgAkG4+c4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQAMAQsgACABOgAEQQgLNgIAIAJBMGokAAuAAQEBfyMAQTBrIgQkACAEIAI2AgwgBCABNgIIQQQhAiAAIAMoAgAEfyACBSAEQQE2AhQgBEHsjs8ANgIQIARCATcCHCAEQcwBNgIsIAQgBEEoajYCGCAEIARBCGo2AiggAEEEaiAEQRBqEJkOIABBADoAEEEBCzYCACAEQTBqJAALfgEEfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAQRAIAQgBSAB/AoAAAsgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQdiZzwAQ/S8AC5MBAQF/IwBBEGsiAiQAAn8CQAJAAkACQCAAKAIAQQFrDgMBAgMACyACIABBCGo2AgwgAUHLo9AAQQ5BhKTQAEEIIABBBGpB5KPQAEGMpNAAQQYgAkEMakH0o9AAEI4YDAMLIAFBkqTQAEESEPs1DAILIAFBpKTQAEETEPs1DAELIAFBt6TQAEEREPs1CyACQRBqJAAL3Q4BEX8jAEFAaiILJAAgC0EEaiEIAkACQAJAAkAgACgCACICBEAgAUH/AXEhBiAAKAIEIQQDQCACLwEGIQNBACEFAkADQCADIAVGDQEgAiAFaiEKIAVBAWohBSAGIApBCGotAAAiCkogBiAKSGtB/wFxIgpBAUYNAAsgCkUNBCAFQQFrIQMLIARFDQIgBEEBayEEIAIgA0ECdGooAhQhAgwACwALIAhBADYCBAwCCyAIIAM2AgwgCEEANgIIIAggAjYCBAwBCyAIIAA2AgwgCCAENgIEIAggAjYCACAIIAVBAWs2AghBCSEBDAELIAggADYCAAsgCCABOgAQIAstABRBCUcEQCALQShqIAtBFGooAgA2AgAgC0EgaiALQQxqKQIANwMAIAsgCykCBDcDGCALQTBqIRFBACEEIwBBIGsiCiQAAn8gC0EYaiIIKAIEBEAgCkEYaiAIQQRqIgBBCGooAgA2AgAgCiAAKQIANwMQIApBBGohDiAILQAQIQ1BACECIwBBMGsiBSQAIAVBBGohAyMAQRBrIgYkAAJ/AkACQAJAIApBEGoiACIHKAIAIgEvAQYiCUELTwRAQQUhCUEEIQQgACgCCCIAQQVJDQEgACEEIABBBWsOAgEDAgsgAUEIaiECIAcoAgQhBAJAIAcoAggiAEEBaiIHIAlLDQAgCSAAayIMRQ0AIAIgB2ogACACaiAM/AoAAAsgASAJQQFqOwEGIAAgAmogDToAAEEJDAMLIAYgBDYCDCAGIAcoAgQiBDYCCCAGIAE2AgQQpy8iAkEAOwEGIAJBADYCACABQQhqIQcgBkEEaiACEIUcAkAgAS8BBiIJIABNDQAgCSAAayIPRQ0AIAAgB2oiEEEBaiAQIA/8CgAACyADQQA2AgwgAyACNgIIIAMgBDYCBCADIAE2AgAgASAJQQFqOwEGIAAgB2ogDToAAEH/AXEMAgsgAEEHayECQQYhCQsgBiAJNgIMIAYgATYCBCAGIAcoAgQiDDYCCBCnLyIAQQA7AQYgAEEANgIAIABBCGohByAGQQRqIAAQhRwCQCAALwEGIgkgAk0NACAJIAJrIgRFDQAgAiAHaiIQQQFqIBAgBPwKAAALQQAhBCADQQA2AgwgAyAANgIIIAMgDDYCBCADIAE2AgAgACAJQQFqOwEGIAIgB2ogDToAACAAIQEgAiEAQf8BcQshAiADIAA2AhwgAyAENgIYIAMgATYCFCADIAI6ABAgBkEQaiQAAkAgBS0AFCIBQQlHBEAgBSgCICEPIAUoAhghECAFKAIcIRIgBSgCDCEAIAUoAhAhBAJAAkAgBSgCBCIHKAIAIgIEQCAFKAIIIQMDQCAFIAI2AiQgBSAHLwEENgIsIAUgA0EBajYCKCAFQQRqIQYgACECQQAhDSMAQTBrIgMkAAJAAkAgBCAFQSRqIgQoAgQiCUEBa0YEQCAEKAIAIgwvAQZBC0kNAUEFIQdBBCEAAkACQAJAIAQoAggiBEEFSQ0AIAQiAEEFaw4CAAIBCyADIAA2AgwgAyAJNgIIIAMgDDYCBCADQRBqIANBBGoQjBQgAyAENgIsIAMgAykCEDcCJCADQSRqIAEgAhDpEyAGQRBqIANBIGooAgA2AgAgBkEIaiADQRhqKQIANwIAIAYgAykCEDcCAAwECyAEQQdrIQ1BBiEHCyADIAc2AgwgAyAJNgIIIAMgDDYCBCADQRBqIANBBGoQjBQgAyANNgIsIAMgA0EYaiIAKQIANwIkIANBJGogASACEOkTIAZBEGogA0EgaigCADYCACAGQQhqIAApAgA3AgAgBiADKQIQNwIADAILQZS4zQBBNUHMuM0AEJ8pAAsgBCABIAIQ6RMgBkEJOgAQCyADQTBqJAAgBS0AFCIBQQlGDQIgBSgCDCEAIAUoAhAhBCAFKAIIIQMgBSgCBCIHKAIAIgINAAsLIAgoAgAiAygCACIGRQ0BIAMoAgQhBxCoLyICIAY2AhQgAkEAOwEGIAJBADYCACAGQQA7AQQgBiACNgIAIAMgB0EBaiIGNgIEIAMgAjYCACAFIAY2AgggBSACNgIEAkACQCAFQQRqIgIoAgRBAWsgBEYEQCACKAIAIgIvAQYiBEELTw0BIAIgBGogAToACCACIARBAWoiATsBBiACIAFBAnRqIAA2AhQgACABOwEEIAAgAjYCAAwCC0Hsts0AQTBBnLfNABCfKQALQcy2zQBBIEGst80AEJ8pAAsLIA4gDzYCCCAOIBI2AgQgDiAQNgIADAILQby2zQAQsjsACyAOIAUoAiA2AgggDiAFKQIYNwIACyAFQTBqJAAgCCgCACEAIAooAgQhAiAKKAIIIQQgCigCDAwBCyAIKAIAIQAQpy8iAkEANgIAIABBADYCBCAAIAI2AgAgAkEBOwEGIAIgCC0AEDoACEEACyEBIAAgACgCCEEBajYCCCARIAE2AgggESAENgIEIBEgAjYCACARIAgoAgA2AgwgCkEgaiQACyALQUBrJAALgwEBAn9BASEFAkACQAJAAkACQCABKAIAQQFrDgIBAgALIAMgASgCBCIBSQ0CIAEgAmohBSADIAFrIQYMAQsgASgCBCIBQRFPDQIgASAEaiEFQRAgAWshBgsgACAGNgIEIAAgBTYCAA8LIAEgA0G09dEAEK87AAsgAUEQQcT10QAQrzsAC20BAX8gASgCBCICBEAgASACQQFrNgIEIAEgASgCACIBQQRqNgIAIAEgAEEDaiIAZyIBQQF0QT5zIAAgAEEeIAFrIgB2QQFxIgFBAnIgAHRrQQh0ciABckHMAGo2AgAPC0EAQQBBqIDSABDDIQALiwEBA38jAEEgayICJABB8O7+ACEDQQYhBAJ/AkACQAJAIAAvAQAOAgEAAgtB9u7+ACEDQQUhBAsgASADIAQQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALiwEBA38jAEEgayICJABBi+/+ACEDQQMhBAJ/AkACQAJAIAAvAQAOAgEAAgtBju/+ACEDQQshBAsgASADIAQQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALiwEBA38jAEEgayICJABB/P7+ACEDQQkhBAJ/AkACQAJAIAAtAAAOAgEAAgtBhf/+ACEDQQQhBAsgASADIAQQ+zUMAQsgAkECNgIEIAJBlP/+ADYCACACQgE3AgwgAkH/CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBCEEIEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKJkqTIkKHChAk3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYmSpMgANgIAIAJBEGokAAuMAQEDfyMAQRBrIgIkACACQQRqIAFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoKEiJCgwICBAjcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBgoSIEDYCACACQRBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKLlqzYsOHChQs3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYuWrNgANgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEEQQQQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoiQoMCAgYKECDcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBiJCgwAA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQJBAhCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABCh46cuPDgwYMHNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGHjpw4NgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEECQQIQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoqUqNCgwYKFCjcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBipSo0AA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQJBAhCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABCg4aMmLDgwIEDNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGDhowYNgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEIQQgQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoyYsODAgYOGDDcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBjJiw4AA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQFBARCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABChoyYsODAgYMGNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGGjJgwNgIAIAJBEGokAAuMAQEDfyMAQRBrIgIkACACQQRqIAFBAEEIQQgQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoWKlKjQoMGCBTcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBhYqUKDYCACACQRBqJAALjAEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKEiJCgwICBggQ3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYSIkCA2AgAgAkEQaiQAC6kDAgZ/AX4jAEEQayIEJAACQCAAKAIMIgUgACgCBCIDRg0AIAEgBSADa0EMbiIFEIAuIAUgAigCACACKAIIIgNrTQ0AIAIgAyAFQQRBCBDeKAsgBEEIaiAAQQhqKQIANwMAIAQgACkCADcDACAEKAIEIgYgBCgCDCIARwRAIAEoAgQgASgCCCIHQQJ0aiEIIAIoAgQgAigCCCIFQQN0aiEDA0AgBkEEaikCACEJIAggBigCADYCACADIAk3AgAgCEEEaiEIIANBCGohAyAFQQFqIQUgB0EBaiEHIAZBDGoiBiAARw0ACyABIAc2AgggBCAGNgIEIAIgBTYCCAsjAEEQayICJAAgBCgCDCIAIAQoAgQiA2tBDG4hBiAAIANHBEADQCADKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCADEPIlCyADQQRqIgEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQuyMLIANBDGohAyAGQQFrIgYNAAsLIAIgBCgCADYCDCACIAQoAgg2AgggAkEIakEEQQwQ4B4gAkEQaiQAIARBEGokAAt/AQJ/AkACQCAAKAIAIgAoAhAiAQ0AIAAoAhgiAkUNACAAKAIIIAIgACgCFBD4OgwBCyABRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRBqELsjCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEcQQQQ+DoLC3wBA38jAEEQayIDJAAgA0EEaiACQQBBAUEBEKAYIAMoAgghBCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALIAMgAjYCDCADIAU2AgggAyAENgIEIAAgA0EEahDnFSADQRBqJAAPCyAEIAMoAgxBwIWIARD9LwALgAMCB38Bb0HI7ooBKAIAIgUoAghFBEAgBUF/NgIIIAVBDGoiASgCDCIDIAEoAgAiAkYEQCABKAIAIQQgAUHsqIgBEJcoAkAgASgCCCIHIAQgASgCDCICa00NACAEIAdrIgYgAiAGayIDSyABKAIAIgIgBGsgA09xRQRAIAIgBmshBCAGQQJ0IgMEQCABKAIEIgIgBEECdGogAiAHQQJ0aiAD/AoAAAsgASAENgIIDAELIANBAnQiA0UNACABKAIEIgIgBEECdGogAiAD/AoAAAsgASgCDCEDIAEoAgAhAgsgASADQQFqNgIMIAEoAgQgASgCCCADaiIBIAJBACABIAJPG2tBAnRqIAA2AgAgBS0AHCEAIAVBAToAHCAFIAUoAghBAWo2AggCQCAADQBB3O6KAS0AAEUEQEHY7ooBKAIAJQFB1O6KASgCACUBEFEhCBDfEiIAIAgmASAAQYQBSQ0BIAAQ8h8PC0HU7ooBKAIAJQEQDgsPC0HcqIgBEJs+AAtuAgF+BH8gACABKAIUIgAgASgCECIDSQR+IAEoAgwhBAJ+A0BCgAIgACAEai0AACIFQQlrIgZBF0tBASAGdEGTgIAEcUVyDQEaIAEgAEEBaiIANgIUIAAgA0cNAAtCAAsgBa1CEIaEBSACCzcCAAvaAQEEfyAAQegAahChLCAAEPslIABB2ABqELIfIABBQGsQlzAgAEHMAGoQmDAgAEGQAWohAQNAIAEoAgQiAgRAIAEgAhCKHRCHJAwBCwsgACgCkAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAEQ2R8LIABBnAFqIgMiASgCCCICBEAgASgCBCEBA0ACQCABKAIAQQhGBEAgAUEEaiIEEN4jIAQQ4DsMAQsgARDwGwsgAUEgaiEBIAJBAWsiAg0ACwsgA0EIQSAQ4B4gACgCsAEEQCAAQbABahDlIAsLbAEEfyMAQRBrIgIkACAAKAIMIgQgACgCBCIBa0EYbiEDIAEgBEcEQANAIAEQ3jsgAUEMahDeOyABQRhqIQEgA0EBayIDDQALCyACIAAoAgA2AgwgAiAAKAIINgIIIAJBCGoQ8jsgAkEQaiQAC3gBAn8gACgCACIBKAIYIgAQiDUgAEEwQQgQ+DogASgCFCICBEAgASgCECEAA0AgABCHNSAAQUBrIQAgAkEBayICDQALCyABQQxqQQhBwAAQ4B4CQCABQX9GDQAgASABKAIEQQFrIgA2AgQgAA0AIAFBHEEEEPg6CwtkAQF+AkAgACkDACIBQgZSBEACQAJAQQEgAadBAmsgAUIBWBsOAwMAAQMLIAAQkSogACgCQEGAIEEEEPg6DwsgAEEIahCDKQsPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEAC4ABAQN/IAAgARDsLSAAKAIEIAAoAggiAkEDdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANEAAAAAAAAAAA5AwAgA0EIaiEDIARBAWsiBA0ACyABIAJqQQFrIQIMAQsgAUUNAQsgA0QAAAAAAAAAADkDACACQQFqIQILIAAgAjYCCAt4AQN/IAAgARDuLSAAKAIEIAAoAggiAkECdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANDAAAAADgCACADQQRqIQMgBEEBayIEDQALIAEgAmpBAWshAgwBCyABRQ0BCyADQwAAAAA4AgAgAkEBaiECCyAAIAI2AggLdgEDfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCwJAIABBFGoiAygCACIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADEPseCyAAQSxqIQAgAkEBayICDQALCwtxAQF/IAAoAgAiACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahCDIAsgAEEIaiIBEKMnIAFBBEEEEOAeIABBFGoQ6TsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBJEEEEPg6CwtxAQF/IAAgAS8AACIDNgIMIAAgAUEEaiIBNgIEIAAgAUEBIANBAWt0QQEgAxtBAnRqIgM2AgggACABIAMgAkEDdGoiACgCBCICQYCAAmoiA0GAgHxxIAJrIANBEHZ1QQF0aiAAKAIAQQF0ai8BADYCAAt1AQN/IAAoAgggAWohAQNAAkACQCABBEAgACgCBCICIAAoAgwiBEkEQCABIAAoAgAgAkEMbGoiAygCCCADKAIEaiIDTw0DIAAgATYCCAsgAiAERw0BCyAAQQA2AggLDwsgACACQQFqNgIEIAEgA2shAQwACwALdAEBfwJAAkACQCAFIAIgBWoiBk0EQCABIAZJDQFBAA0CIAQgBUkNAyAAIAJqIAUgAyAFQeiI0gAQ1SwPCyACIAZByIjSABCxOwALIAYgAUHIiNIAELA7AAtBACAFQdiI0gAQsTsACyAFIARB2IjSABCwOwALcgEDfyAAIAEQ7i0gACgCBCAAKAIIIgNBAnRqIQQCQAJAIAFBAk8EQCABQQFrIQUDQCAEIAI2AgAgBEEEaiEEIAVBAWsiBQ0ACyABIANqQQFrIQMMAQsgAUUNAQsgBCACNgIAIANBAWohAwsgACADNgIIC3IBA38gACABEOwtIAAoAgQgACgCCCICQQN0aiEDAkACQCABQQJPBEAgAUEBayEEA0AgA0IANwMAIANBCGohAyAEQQFrIgQNAAsgASACakEBayECDAELIAFFDQELIANCADcDACACQQFqIQILIAAgAjYCCAuAAQEBfyMAQTBrIgIkACACIAAoAhA2AhggAiAAKAIUQQF2NgIcIAJBAzYCBCACQbz7hAE2AgAgAkICNwIMIAJB8gQ2AiwgAiAAQSBqNgIoIAJB5xo2AiQgAiACQSBqNgIIIAIgAkEYajYCICABKAIAIAEoAgQgAhDLCiACQTBqJAALgAEBAX8jAEEwayICJAAgAiAAKAIQNgIYIAIgACgCFEECdjYCHCACQQM2AgQgAkG8+4QBNgIAIAJCAjcCDCACQfIENgIsIAIgAEEgajYCKCACQegaNgIkIAIgAkEgajYCCCACIAJBGGo2AiAgASgCACABKAIEIAIQywogAkEwaiQAC4ABAQF/IwBBMGsiAiQAIAIgACgCEDYCGCACQQM2AgQgAiAAKAIUQQN2NgIcIAJBvPuEATYCACACQgI3AgwgAkHyBDYCLCACIABBIGo2AiggAkHpGjYCJCACIAJBIGo2AgggAiACQRhqNgIgIAEoAgAgASgCBCACEMsKIAJBMGokAAt0AQN/IwBBEGsiAiQAIAJBCGogARDcOyACKAIMIQEgAigCCCIEQQEQ+C8iAyABIAEgA0sbBEBBtKWHAUE4QeylhwEQnykACyAAQQEgAyAEaiABIANJGzYCACAAIAEgA2siAEEAIAAgAU0bNgIEIAJBEGokAAuNAQEBfyMAQSBrIgIkACACQQA2AgggAkKAgICAEDcCACACQfzshwE2AhAgAkKggICADjcCFCACIAI2AgwgASACQQxqENQOBEBBpO2HAUE3IAJBH2pBlO2HAUHc7YcBENUeAAsgACACKQIANwIAIABBCGogAkEIaigCADYCACAAIAEpAgA3AgwgAkEgaiQAC2cBBn4gASkDGCIDIAEpAwgiBIUhBSABKQMAIQYCQAJAIAEpAxAiByADg0J/UQRAIARCAFINAiAFQgBZDQEMAgsgAyAHhCAEhEIAUiAFQgBTcg0BCyAAIAY3AwhCASECCyAAIAI3AwALhwEBAn8jAEEgayICJAAgAkEUaiABKAIAJQEQcgJAIAIoAhQiAUUEQEGAgICAeCEBDAELIAIgAigCGCIDNgIcIAIgATYCGCACIAM2AhQgAkEIaiACQRRqQYiviAEQkCEgAigCCCEDIAAgAigCDCIBNgIIIAAgAzYCBAsgACABNgIAIAJBIGokAAt+AQF/IABBAToALCAALQAcIQEgAEEBOgAcAkAgAQ0AIABBADoAHCAAKAIUIQEgAEEANgIUIAFFDQAgACgCGCABKAIEEQMACyAALQAoIABBAToAKEUEQCAAKAIgIQEgAEEANgIgIAEEQCAAKAIkIAEoAgwRAwALIABBADoAKAsLfgEBfyAAQQE6ACQgAC0AFCEBIABBAToAFAJAIAENACAAQQA6ABQgACgCDCEBIABBADYCDCABRQ0AIAAoAhAgASgCBBEDAAsgAC0AICAAQQE6ACBFBEAgACgCGCEBIABBADYCGCABBEAgACgCHCABKAIMEQMACyAAQQA6ACALC34BAX8gAEEBOgAoIAAtABghASAAQQE6ABgCQCABDQAgAEEAOgAYIAAoAhAhASAAQQA2AhAgAUUNACAAKAIUIAEoAgQRAwALIAAtACQgAEEBOgAkRQRAIAAoAhwhASAAQQA2AhwgAQRAIAAoAiAgASgCDBEDAAsgAEEAOgAkCwt2AQF/IAAoAgAiACgCCEEGcUEGRwRAIABBCGoQ4AwLIAAoAhwiAQRAIAAoAiAgASgCDBEDAAsgACgCKCIBBEAgACgCLCABKAIMEQMACwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEE4QQQQ+DoLC3MBAn8jAEEQayICJAACQCABKAIARQ0AIAJBCGogARC7KCACKAIIQQFxRQ0AIAIoAgwhAyABIAEoAgxBAWo2AgwgAiADELgSIAIoAgAhASAAIAIoAgQ2AgRBAkEBIAFBAXEbIQMLIAAgAzYCACACQRBqJAALeQEDfwJAIAEEQCABQQhrIgIoAgBBAUcNASABKAIIIQMgASgCBCEEIAJBADYCAAJAIAJBf0YNACABQQRrIgEgASgCAEEBayIBNgIAIAENACACQRRBBBD4OgsgACADNgIEIAAgBDYCAA8LEJg9AAtBl9rDAEE/EJc9AAvIAQIFfwFvIwBBEGsiAiQAIwBBEGsiASQAEBIhBhDfEiIDIAYmASADIQQgAUEIahDOLUEBIQMgAkEIaiIFAn8gASgCCEEBcQRAIAEoAgwMAQtBACEDIAQLNgIEIAUgAzYCACABQRBqJAAgAigCDCEBIAACfwJAIAIoAghBAXFFDQAgAiABEIQZIAIoAgQhASACKAIAIgNFDQAgAEEAIAIgAyABENgpNgIEQQEMAQsgACABNgIUIABBADYCCEEACzYCACACQRBqJAALewIBfwF+IwBBEGsiASQAIABBEGooAgAlARATIAFBCGogAEEIaikCADcDACAAKQIAIQIgAEEANgIEIAEgAjcDAAJAIAEoAgRFDQAgASgCABD/LyIAQYQBTwRAIAAQ8h8LIAFBDGoQrDtFDQAgAUEEchC8KgsgAUEQaiQAC3oBAX8CQAJAAkACQCAALQAADgIBAgALIAAoAhAiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBEGoQuyMPCyAAQQhqELEsDwsgACgCECIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEQahD4IwsgAEEEaiIAEMMnIAAQ6jsLC3gAIAFB/wFxQcEASQRAIAAgAikCADcCCCAAQRBqIAJBCGooAgA2AgAgAEEYakEAQcAA/AsAIABBADYCaCAAQQA6ABQgAEIANwMAIAAgAToAdCAAQgA3AmwgAEIANwNYIABCfzcDYA8LQdj3zABBIUH898wAEJ8pAAt+AQN/IwBBEGsiAyQAIANBBGpBEEEAQQJBAhCgGCADKAIIIQQgAygCBEEBRgRAIAQgAygCDEGIss4AEP0vAAsgAygCDCEFIABBADsBFCAAIAI2AhAgACABNgIMIABBAjoAFiAAQQA2AgggACAFNgIEIAAgBDYCACADQRBqJAALbAIBfwJ+IwBBEGsiBCQAIARBCGogAUECIAJBAXMgAxtBB3RqIgFBzANqEIwpIAQzAQghBSAEMwEKIQYgBCABQYwEahCMKSAAIAUgBDMBAkIwhiAEMwEAQiCGhCAGQhCGhIQ3AQAgBEEQaiQAC4QBAQF+AkACQAJAQQEgACkDACIBp0EJayABQghYGw4CAQIACyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgAEHsAGogACgCZCAAKAJoIAAoAmAoAhARAQAgAEEIahDCGA8LIABB5ABqIAAoAlwgACgCYCAAKAJYKAIQEQEAIAAQwhgLbAAgAUF9cUEBRgRAIABCADcDyAQgAEEANgLkEgsgAUF+cUECRwRAQQAPCyAAKALkEgRAQUQPCyAAEOUkIABBvB1qQgA3AgAgAEIANwK0HSAAQQxqQQBBrAH8CwAgAEEBNgIsIABBAzYCOEEAC3IBAn8Cf0EAIAEgACgCJCICTQ0AGgJAIAINACAAIAAoAggiAjYCECAAIAAoAgQiA0FAcTYCGEFAIAMgAkEAIAJrQT9xIgNqIgJJDQEaIAAgAjYCDCAAIAI2AgggA0UNACAAIAI2AhALIAAgATYCJEEACwt5AQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQgAygCBEEBRwRAIAMoAgwhBSACBEAgBSABIAL8CgAACyAAIAI2AgggACAFNgIEIAAgBDYCACAAQQE6AAwgA0EQaiQADwsgBCADKAIMQYCq/gAQ/S8AC3sBAn8jAEEgayICJAACfyAALwEAIgNBBE0EQCABIANBAnRBpPH+AGooAgBBAhD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfULNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAvWBQIKfwR+IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhByAAIAAgAkECdGoiAigCADYCACACIAc2AgAgAQJ/IABBBGohB0EAIAFBAWsiBUUNABogAygCACEIIAcoAgAhCgJAAkACQAJAIAciAkEEaiIDIAIgBUECdGoiC0EEayIJSQRAIAAoAgAhAwNAIAJBBGoiDCgCACIFIAgoAgQiBE8NAiADIARPDQMgCCgCACIEIANBA3QiDWopAwAhDiAEIAVBA3RqKQMAIQ8gAiAHIAZBAnRqIgQoAgA2AgAgBCAFNgIAIAJBCGoiAigCACIFIAgoAgQiBE8NBCADIARPDQUgCCgCACIEIA1qKQMAIRAgBCAFQQN0aikDACERIAwgByAGIA4gD1VqIgZBAnRqIgQoAgA2AgAgBCAFNgIAIAYgECARVWohBiACQQRqIAlJDQALIAJBBGohAwsCQAJAAkACQCADIAtHBEAgACgCACEFA0AgAygCACIEIAgoAgQiCU8NAiAFIAlPDQMgCCgCACIJIAVBA3RqKQMAIQ4gCSAEQQN0aikDACEPIAIgByAGQQJ0aiICKAIANgIAIAIgBDYCACAGIA4gD1VqIQYgAyICQQRqIgMgC0cNAAsgA0EEayECCyAKIAgoAgQiA08NAiAAKAIAIgUgA08NAyAIKAIAIgMgBUEDdGopAwAhDiADIApBA3RqKQMAIQ8gAiAHIAZBAnRqIgIoAgA2AgAgAiAKNgIAIAYgDiAPVWoMCAsgBCAJQZCDhAEQwyEACyAFIAlBoIOEARDDIQALIAogA0GQg4QBEMMhAAsgBSADQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsgBSAEQZCDhAEQwyEACyADIARBoIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC6wFAQ1/IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhByAAIAAgAkECdGoiAigCADYCACACIAc2AgAgAQJ/IABBBGohB0EAIAFBAWsiBEUNABogAygCACEKIAAoAgAhCCAHKAIAIQsCQAJAAkAgByICQQRqIgMgAiAEQQJ0aiINQQRrIglJBEADQCAIIAooAgAiBigCBCIETw0EIAJBBGoiDigCACIDIARPDQIgBigCACIEIANBAnRqKAIAIQYgBCAIQQJ0Ig9qKAIAIRAgAiAHIAVBAnRqIgQoAgA2AgAgBCADNgIAIAggCigCACIMKAIEIgRPDQQgAkEIaiICKAIAIgMgBE8NAyAMKAIAIgQgA0ECdGooAgAhDCAEIA9qKAIAIQQgDiAHIAUgBiAQTWoiBUECdGoiBigCADYCACAGIAM2AgAgBSAEIAxPaiEFIAJBBGogCUkNAAsgAkEEaiEDCwJAAkAgAyANRwRAA0AgCCAKKAIAIgYoAgQiBE8NBiADKAIAIgkgBE8NAiAGKAIAIgQgCUECdGooAgAhBiAEIAhBAnRqKAIAIQQgAiAHIAVBAnRqIgIoAgA2AgAgAiAJNgIAIAUgBCAGT2ohBSADIgJBBGoiAyANRw0ACyADQQRrIQILIAggCigCACIDKAIEIgRPDQQgBCALTQ0BIAMoAgAiAyALQQJ0aigCACEEIAMgCEECdGooAgAhAyACIAcgBUECdGoiAigCADYCACACIAs2AgAgBSADIARPagwFCyAJIARBoIOEARDDIQALIAsgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyADIARBoIOEARDDIQALIAggBEGQg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwALrgUCC38EfiABRQRAQQAPCwJAIAEgAk0NACAAKAIAIQYgACAAIAJBAnRqIgIoAgA2AgAgAiAGNgIAIAECfyAAQQRqIQZBACABQQFrIgRFDQAaIAMoAgAhCiAAKAIAIQcgBigCACELAkACQAJAIAYiAkEEaiIDIAIgBEECdGoiDEEEayIISQRAA0AgByAKKAIAIgkoAgQiBE8NBCACQQRqIg0oAgAiAyAETw0CIAkoAgAiBCADQQN0aikDACEPIAQgB0EDdCIJaikDACEQIAIgBiAFQQJ0aiIEKAIANgIAIAQgAzYCACAHIAooAgAiDigCBCIETw0EIAJBCGoiAigCACIDIARPDQMgDigCACIEIANBA3RqKQMAIREgBCAJaikDACESIA0gBiAFIA8gEFhqIgRBAnRqIgUoAgA2AgAgBSADNgIAIAQgESASWGohBSACQQRqIAhJDQALIAJBBGohAwsCQAJAIAMgDEcEQANAIAcgCigCACIJKAIEIgRPDQYgAygCACIIIARPDQIgCSgCACIEIAhBA3RqKQMAIQ8gBCAHQQN0aikDACEQIAIgBiAFQQJ0aiICKAIANgIAIAIgCDYCACAFIA8gEFhqIQUgAyICQQRqIgMgDEcNAAsgA0EEayECCyAHIAooAgAiAygCBCIETw0EIAQgC00NASADKAIAIgMgC0EDdGopAwAhDyADIAdBA3RqKQMAIRAgAiAGIAVBAnRqIgIoAgA2AgAgAiALNgIAIAUgDyAQWGoMBQsgCCAEQaCDhAEQwyEACyALIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAHIARBkIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC9QFAQx/IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhCSAAIAAgAkECdGoiAigCADYCACACIAk2AgAgAQJ/IABBBGohCUEAIAFBAWsiBUUNABogAygCACEHIAkoAgAhCwJAAkACQAJAIAkiAkEEaiIDIAIgBUECdGoiDUEEayIISQRAIAAoAgAhAwNAIAJBBGoiCigCACIFIAcoAgQiBE8NAiADIARPDQMgBygCACIEIANBAnQiDGooAgAhDiAEIAVBAnRqKAIAIQ8gAiAJIAZBAnRqIgQoAgA2AgAgBCAFNgIAIAJBCGoiAigCACIFIAcoAgQiBE8NBCADIARPDQUgBygCACIEIAxqKAIAIQwgBCAFQQJ0aigCACEEIAogCSAGIA4gD0pqIgZBAnRqIgooAgA2AgAgCiAFNgIAIAYgBCAMSGohBiACQQRqIAhJDQALIAJBBGohAwsCQAJAAkACQCADIA1HBEAgACgCACEFA0AgAygCACIEIAcoAgQiCE8NAiAFIAhPDQMgBygCACIIIAVBAnRqKAIAIQogCCAEQQJ0aigCACEIIAIgCSAGQQJ0aiICKAIANgIAIAIgBDYCACAGIAggCkhqIQYgAyICQQRqIgMgDUcNAAsgA0EEayECCyALIAcoAgQiA08NAiAAKAIAIgUgA08NAyAHKAIAIgMgBUECdGooAgAhByADIAtBAnRqKAIAIQMgAiAJIAZBAnRqIgIoAgA2AgAgAiALNgIAIAYgAyAHSGoMCAsgBCAIQZCDhAEQwyEACyAFIAhBoIOEARDDIQALIAsgA0GQg4QBEMMhAAsgBSADQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsgBSAEQZCDhAEQwyEACyADIARBoIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC64FAgt/BH4gAUUEQEEADwsCQCABIAJNDQAgACgCACEGIAAgACACQQJ0aiICKAIANgIAIAIgBjYCACABAn8gAEEEaiEGQQAgAUEBayIERQ0AGiADKAIAIQogACgCACEHIAYoAgAhCwJAAkACQCAGIgJBBGoiAyACIARBAnRqIgxBBGsiCEkEQANAIAcgCigCACIJKAIEIgRPDQQgAkEEaiINKAIAIgMgBE8NAiAJKAIAIgQgA0EDdGopAwAhDyAEIAdBA3QiCWopAwAhECACIAYgBUECdGoiBCgCADYCACAEIAM2AgAgByAKKAIAIg4oAgQiBE8NBCACQQhqIgIoAgAiAyAETw0DIA4oAgAiBCADQQN0aikDACERIAQgCWopAwAhEiANIAYgBSAPIBBXaiIEQQJ0aiIFKAIANgIAIAUgAzYCACAEIBEgEldqIQUgAkEEaiAISQ0ACyACQQRqIQMLAkACQCADIAxHBEADQCAHIAooAgAiCSgCBCIETw0GIAMoAgAiCCAETw0CIAkoAgAiBCAIQQN0aikDACEPIAQgB0EDdGopAwAhECACIAYgBUECdGoiAigCADYCACACIAg2AgAgBSAPIBBXaiEFIAMiAkEEaiIDIAxHDQALIANBBGshAgsgByAKKAIAIgMoAgQiBE8NBCAEIAtNDQEgAygCACIDIAtBA3RqKQMAIQ8gAyAHQQN0aikDACEQIAIgBiAFQQJ0aiICKAIANgIAIAIgCzYCACAFIA8gEFdqDAULIAggBEGgg4QBEMMhAAsgCyAEQaCDhAEQwyEACyADIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgByAEQZCDhAEQwyEACyICTQ0AIAAoAgAhASAAIAAgAkECdGoiACgCADYCACAAIAE2AgAgAg8LAAusBQENfyABRQRAQQAPCwJAIAEgAk0NACAAKAIAIQcgACAAIAJBAnRqIgIoAgA2AgAgAiAHNgIAIAECfyAAQQRqIQdBACABQQFrIgRFDQAaIAMoAgAhCiAAKAIAIQggBygCACELAkACQAJAIAciAkEEaiIDIAIgBEECdGoiDUEEayIJSQRAA0AgCCAKKAIAIgYoAgQiBE8NBCACQQRqIg4oAgAiAyAETw0CIAYoAgAiBCADQQJ0aigCACEGIAQgCEECdCIPaigCACEQIAIgByAFQQJ0aiIEKAIANgIAIAQgAzYCACAIIAooAgAiDCgCBCIETw0EIAJBCGoiAigCACIDIARPDQMgDCgCACIEIANBAnRqKAIAIQwgBCAPaigCACEEIA4gByAFIAYgEExqIgVBAnRqIgYoAgA2AgAgBiADNgIAIAUgBCAMTmohBSACQQRqIAlJDQALIAJBBGohAwsCQAJAIAMgDUcEQANAIAggCigCACIGKAIEIgRPDQYgAygCACIJIARPDQIgBigCACIEIAlBAnRqKAIAIQYgBCAIQQJ0aigCACEEIAIgByAFQQJ0aiICKAIANgIAIAIgCTYCACAFIAQgBk5qIQUgAyICQQRqIgMgDUcNAAsgA0EEayECCyAIIAooAgAiAygCBCIETw0EIAQgC00NASADKAIAIgMgC0ECdGooAgAhBCADIAhBAnRqKAIAIQMgAiAHIAVBAnRqIgIoAgA2AgAgAiALNgIAIAUgAyAETmoMBQsgCSAEQaCDhAEQwyEACyALIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAIIARBkIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC9YFAgp/BH4gAUUEQEEADwsCQCABIAJNDQAgACgCACEHIAAgACACQQJ0aiICKAIANgIAIAIgBzYCACABAn8gAEEEaiEHQQAgAUEBayIFRQ0AGiADKAIAIQggBygCACEKAkACQAJAAkAgByICQQRqIgMgAiAFQQJ0aiILQQRrIglJBEAgACgCACEDA0AgAkEEaiIMKAIAIgUgCCgCBCIETw0CIAMgBE8NAyAIKAIAIgQgA0EDdCINaikDACEOIAQgBUEDdGopAwAhDyACIAcgBkECdGoiBCgCADYCACAEIAU2AgAgAkEIaiICKAIAIgUgCCgCBCIETw0EIAMgBE8NBSAIKAIAIgQgDWopAwAhECAEIAVBA3RqKQMAIREgDCAHIAYgDiAPVmoiBkECdGoiBCgCADYCACAEIAU2AgAgBiAQIBFWaiEGIAJBBGogCUkNAAsgAkEEaiEDCwJAAkACQAJAIAMgC0cEQCAAKAIAIQUDQCADKAIAIgQgCCgCBCIJTw0CIAUgCU8NAyAIKAIAIgkgBUEDdGopAwAhDiAJIARBA3RqKQMAIQ8gAiAHIAZBAnRqIgIoAgA2AgAgAiAENgIAIAYgDiAPVmohBiADIgJBBGoiAyALRw0ACyADQQRrIQILIAogCCgCBCIDTw0CIAAoAgAiBSADTw0DIAgoAgAiAyAFQQN0aikDACEOIAMgCkEDdGopAwAhDyACIAcgBkECdGoiAigCADYCACACIAo2AgAgBiAOIA9WagwICyAEIAlBkIOEARDDIQALIAUgCUGgg4QBEMMhAAsgCiADQZCDhAEQwyEACyAFIANBoIOEARDDIQALIAUgBEGQg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwAL1AUBDH8gAUUEQEEADwsCQCABIAJNDQAgACgCACEJIAAgACACQQJ0aiICKAIANgIAIAIgCTYCACABAn8gAEEEaiEJQQAgAUEBayIFRQ0AGiADKAIAIQcgCSgCACELAkACQAJAAkAgCSICQQRqIgMgAiAFQQJ0aiINQQRrIghJBEAgACgCACEDA0AgAkEEaiIKKAIAIgUgBygCBCIETw0CIAMgBE8NAyAHKAIAIgQgA0ECdCIMaigCACEOIAQgBUECdGooAgAhDyACIAkgBkECdGoiBCgCADYCACAEIAU2AgAgAkEIaiICKAIAIgUgBygCBCIETw0EIAMgBE8NBSAHKAIAIgQgDGooAgAhDCAEIAVBAnRqKAIAIQQgCiAJIAYgDiAPS2oiBkECdGoiCigCADYCACAKIAU2AgAgBiAEIAxJaiEGIAJBBGogCEkNAAsgAkEEaiEDCwJAAkACQAJAIAMgDUcEQCAAKAIAIQUDQCADKAIAIgQgBygCBCIITw0CIAUgCE8NAyAHKAIAIgggBUECdGooAgAhCiAIIARBAnRqKAIAIQggAiAJIAZBAnRqIgIoAgA2AgAgAiAENgIAIAYgCCAKSWohBiADIgJBBGoiAyANRw0ACyADQQRrIQILIAsgBygCBCIDTw0CIAAoAgAiBSADTw0DIAcoAgAiAyAFQQJ0aigCACEHIAMgC0ECdGooAgAhAyACIAkgBkECdGoiAigCADYCACACIAs2AgAgBiADIAdJagwICyAEIAhBkIOEARDDIQALIAUgCEGgg4QBEMMhAAsgCyADQZCDhAEQwyEACyAFIANBoIOEARDDIQALIAUgBEGQg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwALbgICfwF+IwBBEGsiAyQAAn8gASgCHCACQQR0aiICKQMApyIEQQ1PBEAgA0EIaiABKAIEIAIpAwgiBadBDGxqENw7IAMoAgggBUIgiKdqDAELIAJBBGoLIQEgACAENgIEIAAgATYCACADQRBqJAALhQEAIABCl67cuPHixYsXNwIMIAAgASkCGDcCGCAAIAEpAgA3AgAgACABKQIkNwIkIABBFGpBl67cuAE2AgAgAEEgaiABQSBqKAIANgIAIABBCGogAUEIaigCADYCACAAQSxqIAFBLGopAgA3AgAgAEE0aiABQTRqKQIANwIAIAFBDGoQwgwLqQgCCn8BfiMAQdAAayIDJAAjAEHgAWsiAiQAIAJBMGogARDcOwJAAkACQAJAAkACQCACKAI0QQFGBEAgAkEgaiABEO88IAIoAiRBAUcNAyACQRBqIAEQ7zwgAigCFEUNBSACQdQBaiACKAIQIgRBGGoQ1AYgBCgCKCEKIAQoAiQhCyACQYABaiAEEL4VIAJBkAFqIARBDGoQgAsgBCgCLCIFBEAgBSAFKAIAIgZBAWo2AgAgBkEASA0FIAQoAkAhBiAEKAI8IQcgBCgCOCEIIAQoAjQhCSAEKAIwIQQLIAJB2ABqIAJB3AFqKAIANgIAIAJBQGsgAkGIAWooAgA2AgAgAkHMAGogAkGYAWooAgA2AgAgAiACKQLUATcDUCACIAo2AmAgAiALNgJcIAIgAikCgAE3AzggAiACKQKQATcCRCACIAY2AnggAiAHNgJ0IAIgCDYCcCACIAk2AmwgAiAENgJoIAIgBTYCZCABQRhqIQQgAS0AGEEeRw0BIAIgASgCHEEwaiIFNgJ8IAJB0ABqIgYgBRDFCARAIAJBkAFqIgUgAkE4akHEAPwKAAAgAkEIaiAFEKABIAIpAwghDCAFIAEQsRggAyAEENQGIANBIGogAUEsakEAIAEoAiwbEO4lIAMgDDcCDCADIAIpApABNwIUIANBHGogAkGYAWooAgA2AgAMBwsgAiAGNgLUASACQQI2ApQBIAJBjNeFATYCkAEgAkICNwKcASACQa8DNgKMASACQa8DNgKEASACIAJBgAFqNgKYASACIAJB/ABqNgKIAQwCCyACQShqIAEQ3DsgAkE7NgI8IAJBATYClAEgAkH42IUBNgKQASACQgE3ApwBIAIgAigCLDYCgAEgAiACQYABajYCOCACIAJBOGo2ApgBIANBCGogAkGQAWoQmQ4gA0EpOgAAIANBjYCAgHg2AgQMBQsgAkEBNgKUASACQdzXhQE2ApABIAJCATcCnAEgAkGvAzYChAEgAiAENgLUASACIAJBgAFqNgKYAQsgAiACQdQBajYCgAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBCACQThqEIknDAMLIAJBGGogARDvPCACQTs2AjwgAkEBNgKUASACQajYhQE2ApABIAJCATcCnAEgAiACKAIcNgKAASACIAJBgAFqNgI4IAIgAkE4ajYCmAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBAwCCwALQQBBAEGs1oUBEMMhAAsgARCJJyACQeABaiQAIAMtAABBKUcEQCAAIANBOPwKAAAgA0HQAGokAA8LIANByABqIANBFGooAgA2AgAgA0FAayADQQxqKQIANwMAIAMgAykCBDcDOEHQ1YUBQckAIANBOGpBnM+FAUGc1oUBENUeAAupCAIKfwF+IwBB0ABrIgMkACMAQeABayICJAAgAkEwaiABENw7AkACQAJAAkACQAJAIAIoAjRBAUYEQCACQSBqIAEQ7zwgAigCJEEBRw0DIAJBEGogARDvPCACKAIURQ0FIAJB1AFqIAIoAhAiBEEYahDUBiAEKAIoIQogBCgCJCELIAJBgAFqIAQQvhUgAkGQAWogBEEMahCACyAEKAIsIgUEQCAFIAUoAgAiBkEBajYCACAGQQBIDQUgBCgCQCEGIAQoAjwhByAEKAI4IQggBCgCNCEJIAQoAjAhBAsgAkHYAGogAkHcAWooAgA2AgAgAkFAayACQYgBaigCADYCACACQcwAaiACQZgBaigCADYCACACIAIpAtQBNwNQIAIgCjYCYCACIAs2AlwgAiACKQKAATcDOCACIAIpApABNwJEIAIgBjYCeCACIAc2AnQgAiAINgJwIAIgCTYCbCACIAQ2AmggAiAFNgJkIAFBGGohBCABLQAYQRtHDQEgAiABKAIcQTBqIgU2AnwgAkHQAGoiBiAFEMUIBEAgAkGQAWoiBSACQThqQcQA/AoAACACQQhqIAUQoAEgAikDCCEMIAUgARCyGCADIAQQ1AYgA0EgaiABQSxqQQAgASgCLBsQ7iUgAyAMNwIMIAMgAikCkAE3AhQgA0EcaiACQZgBaigCADYCAAwHCyACIAY2AtQBIAJBAjYClAEgAkGM14UBNgKQASACQgI3ApwBIAJBrwM2AowBIAJBrwM2AoQBIAIgAkGAAWo2ApgBIAIgAkH8AGo2AogBDAILIAJBKGogARDcOyACQTs2AjwgAkEBNgKUASACQfjYhQE2ApABIAJCATcCnAEgAiACKAIsNgKAASACIAJBgAFqNgI4IAIgAkE4ajYCmAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBAwFCyACQQE2ApQBIAJB3NeFATYCkAEgAkIBNwKcASACQa8DNgKEASACIAQ2AtQBIAIgAkGAAWo2ApgBCyACIAJB1AFqNgKAASADQQhqIAJBkAFqEJkOIANBKToAACADQY2AgIB4NgIEIAJBOGoQiScMAwsgAkEYaiABEO88IAJBOzYCPCACQQE2ApQBIAJBqNiFATYCkAEgAkIBNwKcASACIAIoAhw2AoABIAIgAkGAAWo2AjggAiACQThqNgKYASADQQhqIAJBkAFqEJkOIANBKToAACADQY2AgIB4NgIEDAILAAtBAEEAQazWhQEQwyEACyABEIknIAJB4AFqJAAgAy0AAEEpRwRAIAAgA0E4/AoAACADQdAAaiQADwsgA0HIAGogA0EUaigCADYCACADQUBrIANBDGopAgA3AwAgAyADKQIENwM4QdDVhQFByQAgA0E4akGcz4UBQZzWhQEQ1R4AC2gBAn8CQCABIANHDQAgAQRAA0AgAC0AACACLQAARw0CIABBBGooAgAiAyACQQRqKAIAIgVHBEAgA0EIaiAFQQhqEN8nRQ0DCyAAQQhqIQAgAkEIaiECIAFBAWsiAQ0ACwtBASEECyAEC20BAn8jAEEgayIEJAAgBEEMaiIFIAEgAiADEKUaIAUgBCgCGCAEQRxqIgEoAgAiAhDTHyEDIABBEGogASgCADYCACAAQQhqIARBFGopAgA3AgAgACAEKQIMNwIAIAAgAiADazYCFCAEQSBqJAALdAEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEJcVCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPgjCwJAIAAoAggiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEIahDbHgsLgwEBAX8gAEEBOgAsIAAtABwhASAAQQE6ABwCQCABDQAgAEEAOgAcIAAoAhQhASAAQQA2AhQgAUUNACAAKAIYIAEoAgwRAwALIAAtACghASAAQQE6ACgCQCABDQAgAEEAOgAoIAAoAiAhASAAQQA2AiAgAUUNACAAKAIkIAEoAgQRAwALC2sBAn8jAEHAAmsiAiQAIAJBCGoiAyAAEJUaIAJBuAJqIAJBmAFqKQMANwMAIAIgAikDkAE3A7ACIAJBqAFqIANBhAH8CgAAIAIgATYCrAIgAkEANgKgASACQaABahDRKUEIaiACQcACaiQAC3UBAX8jAEEQayIEJAAgBEEEaiABEN0gQcAAQQgQrTYiAUUEQEEIQcAAEKM9AAsgASADNgIoIAEgAjcDICABIAQpAgQ3AiwgAUEAOgA4IAFBNGogBEEMaigCADYCACAAQbCYwwA2AgQgACABNgIAIARBEGokAAt5AQJ/IAAoAgAiACkDCEIDUQRAAkAgACgC2AEiAUF/Rg0AIAEgASgCBCICQQFrNgIEIAJBAUcNACABQSBBBBD4OgsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABB4AFBCBD4OgsPC0H8/8IAQR8Qhi4AC3YBAn8gACgCACIAKQMIUARAAkAgACgCcCIBQX9GDQAgASABKAIEIgJBAWs2AgQgAkEBRw0AIAFBIEEEEPg6CwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEH4AEEIEPg6Cw8LQfz/wgBBHxCGLgALdgECfyAAKAIAIgApAwhQBEACQCAAKAJQIgFBf0YNACABIAEoAgQiAkEBazYCBCACQQFHDQAgAUEgQQQQ+DoLAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQdgAQQgQ+DoLDwtB/P/CAEEfEIYuAAuwAQEDfyAAKAIIIgMgACgCAEYEQCMAQRBrIgIkACACQQhqIAAgACgCAEEBQQhBIBC3ESACKAIIIgRBgYCAgHhHBEAgBCACKAIMQZTHwwAQ/S8ACyACQRBqJAALIAAoAgQgA0EFdGoiAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAIAAgA0EBajYCCCAAIAMQkBMLewECfyMAQRBrIgMkAAJAIAMgASACQYCABE8EfyADQQhqIAEgAkEKdkHA0ABrEPcDQQAhAQJAIAMoAghBAWsOAwACAAILIAJB/wdxQYC4f3IFIAILEPcDIAMoAgQhBCADKAIAIQELIAAgBDYCBCAAIAE2AgAgA0EQaiQAC3wBAX8CQCAAKQMAQgVRDQAgACgCmAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAJqENkhCyAAQZACahC8KiAAQdAAahCTKiAAEP0uIAAoAvABQYCAgIB4RwRAIABB8AFqENovCyAAQaABaiIAKQMAQgZRDQAgABCxHgsLfAEBfwJAIAApAwBCBVENACAAKAKYAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGYAmoQ2SELIABBkAJqELwqIABB0ABqEJMqIAAQ/S4gACgC8AFBgICAgHhHBEAgAEHwAWoQ2y8LIABBoAFqIgApAwBCBlENACAAELEeCwt+AQF/IwBBIGsiAyQAAkAgASkDAEICUgRAIAEtAFBFDQEgACABIAEoAkwiACACIAAgAkkbEN0OIANBIGokAA8LQZihzQBBLEGIos0AEJ8pAAsgA0EANgIYIANBATYCDCADQfChzQA2AgggA0IENwIQIANBCGpBmKLNABDvLAALdwEDfyAAKAIIIgIEQCAAKAIEIQADQCAAQQxqEJwMAkAgACgCAEGAgICAeEYEQCAAQQRqIgMoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAMQgyAMAQsgABC+HyAAQQRBIBDgHgsgAEEgaiEAIAJBAWsiAg0ACwsLawEDfyMAQSBrIgUkACAEKAIAIQYgBUEMaiIHIAIgAxDdEyIDQYh/TQRAIAAgByAAIAFqIARBBGogBkEQdkH/AXEQ4BhBbEFsIAEgBSgCEEEgRxsgBSgCFCAFKAIYRxshAwsgBUEgaiQAIAMLzgcBCX8jAEEgayIGJAAgBgJ/EIgsIQJBt7TCAC0AAEExRgR/QX4gAkUNARojAEGQ5gBrIgQkACACQQA2AhgCQCACKAIgIgEEQCACKAIkIgMNAQsgAkEANgIoQZwLIQMgAkGcCzYCJEGdCyEBIAJBnQs2AiALIARBEGpBAEHg5QD8CwAgBEH55QBqQgA3AAAgBEIANwL0ZSAEIAM2AohmIAQgATYChGYgBCACKAIoNgKMZiAEQYTmAGpBwABBgPEAELYbIgEEfyABQgA3AjAgAUEBNgIIIAFBADoABCABQYAINgIAIAFCADcCDCABQgA3AkwgAUEBNgJIIAFBADoAQCABQoGAgIAQNwI4IAFBIDYCbCABQgA3A3AgAUEUakIANwIAIAFBHGpCADcCACABQSRqQgA3AgAgAUHUAGpCADcCACABQdwAakIANwIAIAFB5ABqQgA3AgAgAUGAAWpCADcDACABQfgAakIANwMAIAFBADYCnAEgAUEAOgCgASABQZgBaiAEQYDmAGotAAA6AAAgAUGQAWogBEH45QBqKQMANwMAIAEgBCkD8GU3A4gBIAFBoQFqIARBDWpB4+UA/AoAACABQYTnAGpBAEHACfwLACACIAE2AhwjAEEwayIDJAACQAJAIAIoAhwiASgCDCIHQUBqQUFJBEAgB0HBAEkNAiABLQACQQ9GDQIgAUEIaiEHIANCADcCDCADQgE3AgQDQCADQQRqIAVqIggoAgAhCSAIIAUgB2oiCCgCADYCACAIIAk2AgAgBUEEaiIFQRBHDQALIAMgAygCCCIFNgIUIAVFDQEgAkEgaiADKAIEIAUQjRkMAgtB+O/8AEHKAEHE8PwAEJ8pAAsgA0EANgIYQQEgA0EUakHI//sAIANBGGpBvJX8ABCvKwALIAFBADYChAEgAUIANwMQIAFBDzoAAiABQQA6AAMgAkEANgIIIAJCADcCFCACKAIcIgFBADYCVCABLQADIgUEQCACIAVBAXE2AjALIAFBADoAACABQv////8fNwN4IAFCgICAgICAIDcCjAEgAUEAOgBAIAFCgYCAgBA3AzggAUIANwMwIAFBADoAoAEgAUEANgKcASABQQA6AJgBIAFBADYClAEgAUEANgIoIAFBfzYCZCABIAEtAAFB+AFxQQRyOgABIANBMGokAEEABUF8CyAEQZDmAGokAAVBegsLIgE2AgQgAUUEQCAAQgA3AwAgACACNgIQIABBCGpCADcDACAGQSBqJAAPCyAGQQA2AgggBkEEaiAGQQhqQcC9+wAQjisAC9IDAg1/AX4jAEFAaiIDJAAgAyACNgIMIANBEGoiDCABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjQgAyADQQxqNgI8IANBKGohCSMAQSBrIgEkACABQRRqIANBNGoiCyICKAIEIAIoAgBrQQJ2QQBBEEEQEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBCQAIAFBCGoiBSACKAIEIAIoAgBrQQJ2EOstIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQjAEEQayIFJAAgBEEEaiIGKAIEIQcgBigCACACKAIAIgggAigCBCIKRwRAIAIoAgghDyAGKAIIIAdBBHRqIQIgByAKIAhrQQJ2IgZqIQcDQCAFIA8oAgAiCikDACAKKQMIIAg0AgAiECAQQj+HEKgeIAIgBSkDADcDACACIAUpAwg3AwggCEEEaiEIIAJBEGohAiAGQQFrIgYNAAsLIAc2AgAgBUEQaiQAIARBEGokACAJQQhqIA0oAgA2AgAgCSABKQIINwIAIAFBIGokACALIAkQ7BggACALIAwQyx0gA0FAayQAC8sDAgt/AX4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAQgAUEMahCQLyAEIAQpAwA3AjQgBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgckACADQQhqIgEgBSgCBCAFKAIAa0EDdhDuLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIAdBBGoiBigCBCEIIAYoAgAhDQJAAkAgBSgCACIJIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAIQQJ0aiEGIAIgCWtBA3YhAgNAIAkpAwAiDkKAgICACHxCgICAgBBaDQIgBiABKAIAKAIAIA6nbDYCACAJQQhqIQkgBkEEaiEGIAhBAWohCCACQQFrIgINAAsLIA0gCDYCAAwBC0GAroABELI7AAsgB0EQaiQAIApBCGogDCgCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUgChDoGCAAIAUgCxDKHSAEQUBrJAAL2gUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIGJAAgAkEIaiIBIAMoAgQgAygCAGtBAnYQ7y0gBiABKQIEQiCJNwIIIAYgAUEIajYCBCMAQYABayIBJAAgBkEEaiIFKAIEIQcgBSgCACADKAIAIgggAygCBCIJRwRAIAMoAgghDyAFKAIIIAdBBXRqIQMgByAJIAhrQQJ2IglqIQcDQCABQeAAaiAINAIAIhAgEEI/hxCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAhBBGohCCADQSBqIQMgCUEBayIJDQALCyAHNgIAIAFBgAFqJAAgBkEQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALtAQCEH8BfiMAQUBqIgMkACADIAI2AgwgA0EQaiIPIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiIMIgIoAgQgAigCAGtBAnZBAEEQQRAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiEEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBAnYQ6y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIRECQAJAIAIoAgAiCCACKAIEIgdHBEAgAigCCCESIAYoAgggBUEEdGohBiAHIAhrQQJ2IQ0DQEGAgICAeCEHIBIoAgAiDigCACgCACECIAYCfwJAAkAgCCgCACIKQYCAgIB4RgRAQQAhCyACQX9GDQELIAJFDQUgCiAKIAJtIgcgAmxrQQAgAkF/RxshCyAKQQBODQELIAcgCyAOKAIIKAIATGsMAQsgByALIA4oAgQoAgBOagusIhM3AwAgBiATQj+HNwMIIAhBBGohCCAGQRBqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEOwYIAAgDCAPEMsdIANBQGskAAvTBAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQQRBBBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDuLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkACQCACKAIAIgcgAigCBCIIRwRAIAIoAgghDiAGKAIIIAVBAnRqIQIgCCAHa0EDdiEGA0BCgICAgICAgICAfyEQIA4oAgAiCCgCACkDACEPAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CyIPQoCAgIAIfEKAgICAEFoNAyACIA8+AgAgB0EIaiEHIAJBBGohAiAFQQFqIQUgBkEBayIGDQALCyANIAU2AgAMAgtBtKiAARDiKwALQfCtgAEQsjsACyAEQRBqJAAgCUEIaiAMKAIANgIAIAkgASkCCDcCACABQSBqJAAgCiAJEOgYIAAgCiALEModIANBQGskAAumBAEQfyMAQUBqIgMkACADIAI2AgwgA0EQaiIPIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiIMIgIoAgQgAigCAGtBAnZBAEEIQQgQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiEEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBAnYQ7C0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIRECQAJAIAIoAgAiCCACKAIEIgdHBEAgAigCCCESIAYoAgggBUEDdGohBiAHIAhrQQJ2IQ0DQEGAgICAeCEHIBIoAgAiDigCACgCACECIAYCfwJAAkAgCCgCACIKQYCAgIB4RgRAQQAhCyACQX9GDQELIAJFDQUgCiAKIAJtIgcgAmxrQQAgAkF/RxshCyAKQQBODQELIAcgCyAOKAIIKAIATGsMAQsgByALIA4oAgQoAgBOagusNwMAIAhBBGohCCAGQQhqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEL0YIAAgDCAPEMYdIANBQGskAAu/BAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQRBBEBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDrLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkAgAigCACIHIAIoAgQiCEcEQCACKAIIIQ4gBigCCCAFQQR0aiECIAggB2tBA3YhBgNAQoCAgICAgICAgH8hECAOKAIAIggoAgApAwAhDyACAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CyIPNwMAIAIgD0I/hzcDCCAHQQhqIQcgAkEQaiECIAVBAWohBSAGQQFrIgYNAAsLIA0gBTYCAAwBC0G0qIABEOIrAAsgBEEQaiQAIAlBCGogDCgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAogCRDsGCAAIAogCxDLHSADQUBrJAALnQMBC38jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAQgAUEMahCQLyAEIAQpAwA3AjQgBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQhBCBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgckACADQQhqIgEgBSgCBCAFKAIAa0EDdhDsLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIAdBBGoiBigCBCEIIAYoAgAgBSgCACIJIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAIQQN0aiEGIAggAiAJa0EDdiICaiEIA0AgBiABKAIAKQMAIAkpAwB+NwMAIAlBCGohCSAGQQhqIQYgAkEBayICDQALCyAINgIAIAdBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQvRggACAFIAsQxh0gBEFAayQAC50DAQt/IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgsgARCSNhDuJSAEIAFBDGoQjy8gBCAEKQMANwI0IAQgBEEMajYCPCAEQShqIQojAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBAnZBAEEEQQQQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDEEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIHJAAgA0EIaiIBIAUoAgQgBSgCAGtBAnYQ7i0gByABKQIEQiCJNwIIIAcgAUEIajYCBCAHQQRqIgYoAgQhCCAGKAIAIAUoAgAiCSAFKAIEIgJHBEAgBSgCCCEBIAYoAgggCEECdGohBiAIIAIgCWtBAnYiAmohCANAIAYgASgCACgCACAJKAIAbDYCACAJQQRqIQkgBkEEaiEGIAJBAWsiAg0ACwsgCDYCACAHQRBqJAAgCkEIaiAMKAIANgIAIAogAykCCDcCACADQSBqJAAgBSAKEOgYIAAgBSALEModIARBQGskAAuzBAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQQhBCBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDsLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkAgAigCACIHIAIoAgQiCEcEQCACKAIIIQ4gBigCCCAFQQN0aiECIAggB2tBA3YhBgNAQoCAgICAgICAgH8hECAOKAIAIggoAgApAwAhDyACAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CzcDACAHQQhqIQcgAkEIaiECIAVBAWohBSAGQQFrIgYNAAsLIA0gBTYCAAwBC0G0qIABEOIrAAsgBEEQaiQAIAlBCGogDCgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAogCRC9GCAAIAogCxDGHSADQUBrJAAL2gUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgBCABQQxqEJAvIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBA3ZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIGJAAgAkEIaiIBIAMoAgQgAygCAGtBA3YQ7y0gBiABKQIEQiCJNwIIIAYgAUEIajYCBCMAQYABayIBJAAgBkEEaiIFKAIEIQcgBSgCACADKAIAIgggAygCBCIJRwRAIAMoAgghDyAFKAIIIAdBBXRqIQMgByAJIAhrQQN2IglqIQcDQCABQeAAaiAIKQMAIhAgEEI/hxCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAhBCGohCCADQSBqIQMgCUEBayIJDQALCyAHNgIAIAFBgAFqJAAgBkEQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALpQQBEH8jAEFAaiIDJAAgAyACNgIMIANBEGoiDyABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjQgAyADQQxqNgI8IANBKGohCSMAQSBrIgEkACABQRRqIANBNGoiDCICKAIEIAIoAgBrQQJ2QQBBBEEEEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIhBBADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBCQAIAFBCGoiBSACKAIEIAIoAgBrQQJ2EO4tIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQgBEEEaiIGKAIEIQUgBigCACERAkACQCACKAIAIgggAigCBCIHRwRAIAIoAgghEiAGKAIIIAVBAnRqIQYgByAIa0ECdiENA0BBgICAgHghByASKAIAIg4oAgAoAgAhAiAGAn8CQAJAIAgoAgAiCkGAgICAeEYEQEEAIQsgAkF/Rg0BCyACRQ0FIAogCiACbSIHIAJsa0EAIAJBf0cbIQsgCkEATg0BCyAHIAsgDigCCCgCAExrDAELIAcgCyAOKAIEKAIATmoLNgIAIAhBBGohCCAGQQRqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEOgYIAAgDCAPEModIANBQGskAAudAwELfyMAQUBqIgQkACAEIAI2AgwgBEEQaiILIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAyQAIANBFGogBEE0aiIFKAIEIAUoAgBrQQJ2QQBBCEEIEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQdyP/wAQ/S8ACyADQRBqIgxBADYCACADIAMoAhw2AgwgAyABNgIIIwBBEGsiByQAIANBCGoiASAFKAIEIAUoAgBrQQJ2EOwtIAcgASkCBEIgiTcCCCAHIAFBCGo2AgQgB0EEaiIGKAIEIQggBigCACAFKAIAIgkgBSgCBCICRwRAIAUoAgghASAGKAIIIAhBA3RqIQYgCCACIAlrQQJ2IgJqIQgDQCAGIAEoAgApAwAgCTQCAH43AwAgCUEEaiEJIAZBCGohBiACQQFrIgINAAsLIAg2AgAgB0EQaiQAIApBCGogDCgCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUgChC9GCAAIAUgCxDGHSAEQUBrJAAL0gMCDX8BfiMAQUBqIgMkACADIAI2AgwgA0EQaiIMIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiILIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBA3YQ6y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCMAQRBrIgUkACAEQQRqIgYoAgQhByAGKAIAIAIoAgAiCCACKAIEIgpHBEAgAigCCCEPIAYoAgggB0EEdGohAiAHIAogCGtBA3YiBmohBwNAIAUgDygCACIKKQMAIAopAwggCCkDACIQIBBCP4cQqB4gAiAFKQMANwMAIAIgBSkDCDcDCCAIQQhqIQggAkEQaiECIAZBAWsiBg0ACwsgBzYCACAFQRBqJAAgBEEQaiQAIAlBCGogDSgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAsgCRDsGCAAIAsgDBDLHSADQUBrJAAL+QQCEX8DfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIQIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiASQAIAFBFGogBEE0aiINIgIoAgQgAigCAGtBAnZBAEEQQSAQoBggASgCGCEDIAEoAhRBAUYEQCADIAEoAhxB3I//ABD9LwALIAFBEGoiEUEANgIAIAEgASgCHDYCDCABIAM2AggjAEEQayIHJAAgAUEIaiIDIAIoAgQgAigCAGtBAnYQ7y0gByADKQIEQiCJNwIIIAcgA0EIajYCBCMAQSBrIgMkACAHQQRqIgUoAgQhCCAFKAIAIRICQAJAIAIoAgAiCSACKAIEIgZHBEAgAigCCCETIAUoAgggCEEFdGohAiAGIAlrQQJ2IQ4DQEGAgICAeCEGIBMoAgAiDygCACgCACEFIAMCfwJAAkAgCSgCACILQYCAgIB4RgRAQQAhDCAFQX9GDQELIAVFDQUgCyALIAVtIgYgBWxrQQAgBUF/RxshDCALQQBODQELIAYgDCAPKAIIKAIATGsMAQsgBiAMIA8oAgQoAgBOagusIhQgFEI/hxCyLiADKQMAIRQgAykDCCEVIAMpAxAhFiACQRhqIAMpAxg3AwAgAkEQaiAWNwMAIAIgFTcDCCACIBQ3AwAgCUEEaiEJIAJBIGohAiAIQQFqIQggDkEBayIODQALCyASIAg2AgAgA0EgaiQADAELQaSogAEQ4isACyAHQRBqJAAgCkEIaiARKAIANgIAIAogASkCCDcCACABQSBqJAAgDSAKEO0YIAAgDSAQEM4dIARBQGskAAuEBQINfwR+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSAEIAFBDGoQkC8gBCAEKQMANwI0IAQgBEEMajYCPCAEQShqIQojAEEgayIBJAAgAUEUaiAEQTRqIgsiAigCBCACKAIAa0EDdkEAQRBBIBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEHcj/8AEP0vAAsgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgYkACABQQhqIgMgAigCBCACKAIAa0EDdhDvLSAGIAMpAgRCIIk3AgggBiADQQhqNgIEIwBBIGsiAyQAIAZBBGoiBSgCBCEHIAUoAgAhDgJAAkAgAigCACIIIAIoAgQiCUcEQCACKAIIIQ8gBSgCCCAHQQV0aiECIAkgCGtBA3YhBQNAQoCAgICAgICAgH8hESAPKAIAIgkoAgApAwAhECADAn4CQAJAIAgpAwAiEkKAgICAgICAgIB/UQRAQgAhEyAQQn9RDQELIBBQDQUgEiASIBB/IhEgEH59QgAgEEJ/UhshEyASQgBZDQELIBEgEyAJKAIIKQMAV619DAELIBEgEyAJKAIEKQMAWa18CyIQIBBCP4cQsi4gAykDACEQIAMpAwghESADKQMQIRIgAkEYaiADKQMYNwMAIAJBEGogEjcDACACIBE3AwggAiAQNwMAIAhBCGohCCACQSBqIQIgB0EBaiEHIAVBAWsiBQ0ACwsgDiAHNgIAIANBIGokAAwBC0G0qIABEOIrAAsgBkEQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALYgEDfyAAKAIAIgNBDXUiAUEBayEAIAFBAEwEQEEBIAFrQZADbkEBaiIBQc+Kd2whAiABQZADbCAAaiEACyACIANBBHZB/wNxaiAAQeQAbSIBayAAQbULbEECdWogAUECdWoLegECfyMAQRBrIgIkAEHAACEDAkAgAUHAABDRNARAIAEEQCABQcAAEK42IgNFDQILIAAgATYCDCAAIAM2AgggACABNgIEIABBwAA2AgAgAkEQaiQADwtBsPSHAUErIAJBD2pBoPSHAUGg9YcBENUeAAtBwAAgARCjPQALeAEBfyMAQeAAayIDJAAgA0EIaiAAKAIEIAAoAgggASACENAIIAMgAygCKCIANgJYIAMgAykDEDcDUCADIAMpAwg3A0ggAyADKQMgNwNAIAMgAykDGDcDOCADIAAgAygCLEEDdGo2AlwgA0E4ahDgJyADQeAAaiQAC2ICAn4BfyMAQTBrIgQkACABIAApAwgiAkIAWUEBQQBCACAAKQMAIgN9IAMgAkIAUyIAG0IAIAIgA0IAUq18fSACIAAbIARBCWoiARD6AiIAIAFqQScgAGsQgQkgBEEwaiQAC4kBAQF/AkACQAJAIAAtALwBDgQAAgIBAgsgAEGYAWoQ+SUgABCgKQ8LIABBuAFqEK0sIAAoArQBIgFBhAFPBEAgARDyHwsgAEEAOgC9ASAAKAKwASIBQYQBTwRAIAEQ8h8LAkAgACgCqAFFDQAgACgCrAEiAUGEAUkNACABEPIfCyAAQQA7Ab4BCwtsAQF/IwBB0ANrIgIkACACIAAQlRogAUEJSQRAIAJBmAFqIgAgAkGYAfwKAAAgACABEJQkIAJBuAJqIABBmAH8CgAAIAJBADYCsAIgAkGwAmoQ0SlBCGogAkHQA2okAA8LQeSCwwBBGRCXPQALbAEBfyMAQdADayICJAAgAiAAEJUaIAFBA0kEQCACQZgBaiIAIAJBmAH8CgAAIAAgAToAKiACQbgCaiAAQZgB/AoAACACQQA2ArACIAJBsAJqENEpQQhqIAJB0ANqJAAPC0HkgsMAQRkQlz0AC3YBAX8jAEFAaiIDJAAgAyABNwMIIAMgASACfEIBfTcDKCADQQI2AhQgA0GAl8MANgIQIANCAjcCHCADQTw2AjwgA0E8NgI0IAMgA0EwajYCGCADIANBKGo2AjggAyADQQhqNgIwIAAgA0EQahCZDiADQUBrJAAL4wEBA38gACgCACIAQQhqIQMjAEEQayIBJAACQAJAA0ACQCABIAMQzxkgASgCACICBEAgAkECaw0BDAMLIAEgASgCBEEIayICNgIMIAIgAigCACICQQFrNgIAIAJBAUcNASABQQxqELYfDAELCyABQRBqJAAMAQtBxIDDAEEUEIYuAAsgACgCDCIBBEAgACgCECABKAIMEQMACyADKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCADELYfCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEgQQQQ+DoLC+MBAQN/IAAoAgAiAEEIaiEDIwBBEGsiASQAAkACQANAAkAgASADEM0ZIAEoAgAiAgRAIAJBAmsNAQwDCyABIAEoAgRBCGsiAjYCDCACIAIoAgAiAkEBazYCACACQQFHDQEgAUEMahC3HwwBCwsgAUEQaiQADAELQcSAwwBBFBCGLgALIAAoAgwiAQRAIAAoAhAgASgCDBEDAAsgAygCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAxC3HwsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBIEEEEPg6CwvjAQEDfyAAKAIAIgBBCGohAyMAQRBrIgEkAAJAAkADQAJAIAEgAxDOGSABKAIAIgIEQCACQQJrDQEMAwsgASABKAIEQQhrIgI2AgwgAiACKAIAIgJBAWs2AgAgAkEBRw0BIAFBDGoQuB8MAQsLIAFBEGokAAwBC0HEgMMAQRQQhi4ACyAAKAIMIgEEQCAAKAIQIAEoAgwRAwALIAMoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAMQuB8LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQSBBBBD4OgsLcAEFfwJAIAAoAgAiASAAKAIEIgJHBEAgACgCDCEEIAAoAgghBSACIAFrQQJ2IQADQCABKAIAIgIgBE8NAiABQQRqIQEgAyAFIAJBBnRqKAIQaiEDIABBAWsiAA0ACwsgAw8LIAIgBEH8n8MAEMMhAAt5AQF/IwBBQGoiAiQAIAJBtMvDADYCFCACIAE2AhAgAiAANgIMIAJBAjYCHCACQeC7wwA2AhggAkICNwIkIAJBygE2AjwgAkE7NgI0IAIgAkEwajYCICACIAJBEGo2AjggAiACQQxqNgIwIAJBGGoQgRcgAkFAayQAC4IBAQF/AkACQAJAIAAtACwOBAACAgECCyAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABDUIgsgACgCBCIAQYQBSQ0BIAAQ8h8PCyAAQRBqEIYqIAAoAgwiASABKAIAQQFqNgIAIAAoAgAiASABKAIAQQFrIgE2AgAgAQ0AIAAQ1CILC3ABA38CQCAAKAIAIgAoAhgiAUUNACAAKAIcIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CyAAQQxqEN47AkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLdQECfyMAQRBrIgEkACAAKAIABEAgASAAKAIEIgA2AgggAUGw7cMAQRkQkz4iAjYCDCABQQhqIAFBDGoQojsgAkGEAU8EQCACEPIfIAEoAgghAAsgAEGEAU8EQCAAEPIfCyABQRBqJAAPC0HM7MMAQRwQlz0AC3oBAX8gACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LiAAKALwASIBBEAgAEH8AWogACgC9AEgACgC+AEgASgCEBEBAAsgAEGgAWoQgh8LC3YBAX8jAEEwayICJAAgAiABKAIIQeTqzgAQzhggAkEBNgIMIAJBAjYCFCACQbDrzgA2AhAgAkIBNwIcIAJBOzYCLCACIAJBKGo2AhggAiACQQxqNgIoIABBBGogAkEQahCZDiAAQQA2AgAgAhDeOyACQTBqJAALdgEBfyMAQTBrIgIkACACIAEoAghB5OrOABDOGCACQRA2AgwgAkECNgIUIAJBsOvOADYCECACQgE3AhwgAkE7NgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOIABBADYCACACEN47IAJBMGokAAt2AQF/IwBBMGsiAiQAIAIgASgCCEHk6s4AEM4YIAJBDDYCDCACQQI2AhQgAkGw684ANgIQIAJCATcCHCACQTs2AiwgAiACQShqNgIYIAIgAkEMajYCKCAAQQRqIAJBEGoQmQ4gAEEANgIAIAIQ3jsgAkEwaiQAC20BAn8jAEEQayIBJAACQAJAAkAgACgC5AQiAEEIahDdJUH/AXFBBmsOAgEAAgsgAUEEaiAAKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKAKUBCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgtvAQJ/IwBBEGsiASQAAkACQAJAIAAoAoAFQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAoAFKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKAK4BCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgtvAQJ/IwBBEGsiASQAAkACQAJAIAAoApgFQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoApgFKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKALoBCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgttACAAIAJBmAH8CgAAIAAgAS0ApAE6AKQBIAAgASkDmAE3A5gBIABBoAFqIAFBoAFqKAIANgIAIAFB4ABqEN47IAFB7ABqEK4vIAFBQGsQ+CYgASgCeEGAgICAeEcEQCABQfgAakEEQQgQ4B4LC2gBBH8gACgCACIBQQRqIQMgACgCBCABa0EDdSEEQQAhAQNAIAIgBEZFBEAgASADLwEAaiEBIAAoAiggAkYEQCABQYCABGogASAAKAIkQQFGGyEBCyADQQhqIQMgAkEBaiECDAELCyABC3IBAn8CQANAAkAgAUHAACAAKAIIIgVrIgZNBEAgAUEhTw0DIAAgASAFajYCCCACIAFBAnRBhKn7AGooAgAgACkDACAFQT9xrYincTYCAAwBCyAAIAMgBBDLIA0BCwsgASAGTQ8LIAFBIUGIqvsAEMMhAAtvAQN/IAAoAggiAwRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ8iULIABBBGoiASgCACICIAIoAgAiAkEBazYCACACQQFGBEAgARC7IwsgAEEMaiEAIANBAWsiAw0ACwsLYAEDfyAAKAIIIgIEQCAAKAIEIQEDQCADIAEoAgBBCGooAhBqIQMgAUEMaiEBIAJBAWsiAg0ACwsgAyAAKAIYQQhqKAIQaiEBIAAoAiQiAAR/IAEgAEEIaigCEGoFIAELC3EBAn8CQCABKAIUIgUgACgCFCIGIAUgBkkbIgZFBEBBACEFDAELIAEoAhAhASAAKAIQIQBBACEFA0AgACABIAIgAyAEEOssRQ0BIABBxABqIQAgAUHEAGohASAGIAVBAWoiBUcNAAsgBiEFCyAFIAZPC3MBAn8jAEEQayICJAAgAkEIaiABQSBqELYZIAIoAgghAyAAIAIoAgw2AgQgACADNgIAIAAgASkDADcDCCAAQRBqIAFBCGopAwA3AwAgAEEYaiABQRBqKQMANwMAIABBIGogAUEYaikDADcDACACQRBqJAALjwEBAX8CQAJAIABBhAFPBEAgANBvJgFBoO+KASgCAA0BQaDvigFBfzYCACAAQbTvigEoAgAiAUkNAiAAIAFrIgBBrO+KASgCAE8NAkGo74oBKAIAIABBAnRqQbDvigEoAgA2AgBBsO+KASAANgIAQaDvigFBoO+KASgCAEEBajYCAAsPC0H4rogBEJs+AAsAC28BAX8jAEEQayIDJAAgAUEHakEAIAFrcSACaiICQYCAgIB4QQQgASABQQRNGyIBa0sEQEGQw4kBQSsgA0EPakGAw4kBQfzDiQEQ1R4ACyAAIAE2AgAgACABIAJqQQFrQQAgAWtxNgIEIANBEGokAAtkAQN/IwBBEGsiAiQAIAJBBGogASIDQQBBAUEAEKAYIAIoAgghASACKAIEQQFGBEAgASACKAIMQZyawwAQ/S8ACyACKAIMIQQgACADNgIIIAAgBDYCBCAAIAE2AgAgAkEQaiQAC5kBAgJ/AW8jAEFAaiICJAAgAAJ/IAEpAwBCAlEEQEEBIQMgASgCCAwBCyACQQA2AgggAkEQaiABQTD8CgAAAn9BwABBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIAJBCGpBOPwKAAAgAQwBC0EIQcAAEKM9AAtBCGoQACEEEN8SIgEgBCYBIAELNgIEIAAgAzYCACACQUBrJAALcQEDfyMAQRBrIgEkACABQQRqQccAQQBBAUEBEKAYIAEoAgghAiABKAIEQQFHBEAgASgCDCIDQajDwwBBxwD8CgAAIABBxwA2AgggACADNgIEIAAgAjYCACABQRBqJAAPCyACIAEoAgxB8MXDABD9LwALdAEDfyAAKAIUIQEgACgCGCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRxqEPgjCyAAKAIAQYCAgIB4RwRAIAAQ0C4gABDqOwsLcgECfyMAQRBrIgIkAAJAAkAgACgC8AEiAUE8TwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0cNAQtBxJ3EAEERQdidxAAQyyQACyACQQhqIAAgAUEBahCmECACKAIIIAIoAgwQgC0gAkEQaiQAC3MBAn8jAEEQayICJAACQAJAIAAoAvgHIgFB/gFPBEAgACgCBCIBQX9GDQELQX8gAWd2QQAgARsiAUF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAJBCGogACABQQFqEKUQIAIoAgggAigCDBCALSACQRBqJAALqgQCCX8BfiMAQRBrIgYkAAJAAkAgACgCZCIBQQlPBEAgACgCBCIBQX9GDQELQX8gAWd2QQAgARsiAkF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAZBCGohCUEIIQECQAJAIAJBAWoiBwJ/IAAoAmQiAkEITQRAIABBBGohBSACDAELIAAoAgghBSACIQEgACgCBAsiCE8EQAJAAkAgB0EJTwRAQYGAgIB4IQQgASAHRg0FIAetQgx+IgqnIQNBACEEIApCIIinDQUgA0EEENE0RQ0FIAJBCUkNAiABrUIMfiIKpyEBIApCIIhQDQEgASEDDAULQYGAgIB4IQQgAkEITQ0EIABBADYCACAIQQxsIgIEQCAAQQRqIAUgAvwKAAALIAAgCDYCZCMAQRBrIgAkACABrUIMfiIKpyEBAkAgCkIgiFAEQCABQQQQ0TQNAQsgACABNgIMIABBADYCCEHYnMQAQSsgAEEIakHInMQAQbSdxAAQ1R4ACyAFIAFBBBD4OiAAQRBqJAAMBAsgAUEEENE0RQ0DQQQhBCAFIAFBBCADEJc1IgFFDQMMAgtBBCEEIANBBBCtNiIBRQ0CIAhBDGwiAkUNASABIAUgAvwKAAAMAQtB6J3EAEEgQYiexAAQnykACyAAIAc2AmQgACABNgIIIAAgCDYCBCAAQQE2AgBBgYCAgHghBAsgCSADNgIEIAkgBDYCACAGKAIIIAYoAgwQgC0gBkEQaiQAC6kEAQl/IwBBEGsiByQAAkACQCAAKALcAyICQTxPBEAgACgCBCICQX9GDQELQX8gAmd2QQAgAhsiAUF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAdBCGohCUE7IQICQAJAIAFBAWoiBQJ/IAAoAtwDIgFBO00EQCAAQQRqIQYgAQwBCyAAKAIIIQYgASECIAAoAgQLIghPBEACQAJAIAVBPE8EQEGBgICAeCEEIAIgBUYNBSAFQQN0IQNBACEEIAVB/////wFLDQUgA0EEENE0RQ0FIAFBPEkNAiACQQN0IQEgAkH/////AU0NASABIQMMBQtBgYCAgHghBCABQTtNDQQgAEEANgIAIAhBA3QiAQRAIABBBGogBiAB/AoAAAsgACAINgLcAyMAQRBrIgAkACACQQN0IQECQCACQf////8BTQRAIAFBBBDRNA0BCyAAIAE2AgwgAEEANgIIQdicxABBKyAAQQhqQcicxABBtJ3EABDVHgALIAYgAUEEEPg6IABBEGokAAwECyABQQQQ0TRFDQNBBCEEIAYgAUEEIAMQlzUiAkUNAwwCC0EEIQQgA0EEEK02IgJFDQIgCEEDdCIBRQ0BIAIgBiAB/AoAAAwBC0HoncQAQSBBiJ7EABCfKQALIAAgBTYC3AMgACACNgIIIAAgCDYCBCAAQQE2AgBBgYCAgHghBAsgCSADNgIEIAkgBDYCACAHKAIIIAcoAgwQgC0gB0EQaiQAC3EBAn8jAEEQayICJAACQAJAIAAoAkgiAUESTwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0cNAQtB7K7MAEERQZCvzAAQyyQACyACQQhqIAAgAUEBahCnECACKAIIIAIoAgwQgC0gAkEQaiQAC1sBA38jAEEQayIBJAAgAUEEaiAAEIcjIAEoAgQiACgCCCICBEAgACgCBCEAA0AgABCuNCADaiEDIABBFGohACACQQFrIgINAAsLIAFBBGoQgCsgAUEQaiQAIAMLaAECfyAAKAIcIQMgAEEANgIcIAAoAggiBCAAKAIYIANBA3ZqIANBB3FBAEdqIgNJBEAgAyAEQci6zgAQrzsACyABIAAoAgQgA2ogBCADayIBIAIgASACSRsiARChNiAAIAEgA2o2AhgLcQEDfyABKAIEQQFrIQQgASgCCCECAkADQCACRQ0BIAIgBGoiAyADLQAAQQFqIgM6AAAgAkEBayECIANB/wFxIANHDQALIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAPCyAAQYCAgIB4NgIAIAEQ3jsLcgEDfyMAQRBrIgMkACADQQRqIAJBAEEBQQEQoBggAygCCCEEIAMoAgRBAUcEQCADKAIMIQUgAgRAIAUgASAC/AoAAAsgACACNgIIIAAgBTYCBCAAIAQ2AgAgA0EQaiQADwsgBCADKAIMQfSOzwAQ/S8AC3IBA38jAEEQayIDJAAgA0EEaiACQQBBAUEBEKAYIAMoAgghBCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALIAAgAjYCCCAAIAU2AgQgACAENgIAIANBEGokAA8LIAQgAygCDEHko88AEP0vAAujlAICIX8KfiMAQRBrIhckACABKAIIIRQgASgCBCEQIBcgASgCADYCCCAXIBA2AgQgFyAQNgIAIBcgECAUQbgFbGo2AgwgACEUIwBBQGoiEiQAIBJBCDYCACASQTBqIBdBCGopAgA3AwAgEiAXKQIANwMoIBIgEjYCOCMAQSBrIhYkACASQShqIhEoAgghHCARKAIAIRAgFiARKAIMNgIEIBEoAhAhACAWIBFBEGo2AhwgFiAANgIYIBYgFkEEajYCFCAWQQhqIRsgECEAIBZBFGohHiMAQZAJayIYJAACQCARKAIEIhMgESgCDCIfRg0AIBhBKGohICAYQRBqIRkDQCAYQdgDaiIOIBNBuAX8CgAAIBEgE0G4BWoiEzYCBCAYQQhqIRVBACEHQQAhCkEAIQsjAEHgDGsiDSQAAkACQAJAAkACQCAOKQMAQgJRBEAgDUGICWohBCMAQYAnayIJJAAgDkEIaiIDQQhqIQICQAJAAkACQAJAAkACQAJAAkAgAygCAEEBaw4HAQIDBAUGBwALIAkgAkGwBPwKAAAjAEGwBmsiAyQAAkACQAJAIAkoAqADRQ0AIANB2ANqIAkQ5gEgAygC2AMiAkEIRg0AIAQgAykC3AM3AgwgBEEcaiADQewDaigCADYCACAEQRRqIANB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCAJKAJYQYCAgIB4Rg0AIANB2ANqIAkQjwcgAygC2AMiAkEIRg0AIAQgAykC3AM3AgwgBEEcaiADQewDaigCADYCACAEQRRqIANB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAkoAqADRQ0AIANBGGogCRDmASADKAIYIgZBCEYNAAwBCwJAIAkoAqwCIgZFDQAgA0HgA2ohAgNAIAkgBkEBazYCrAIgCSAJKAKoAiIGQQFqIgUgCSgCoAIiB0EAIAUgB08bazYCqAIgCSgCpAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAMgIzcD2AMgAiAGQQhqQYAB/AoAACADQRhqIAkgA0HYA2oQqQogAygCGCIGQQhHDQIgCSgCrAIiBg0ACwsgA0HYA2ohBiMAQbANayICJAAgCSkDkAEhJSAJKQOIASEoIAkpA+gBISkgCSkD2AEhKiAJKQPgASEnIAkpA6ABISYgCSgCmAEhCiAJKAKUBCIFIAUoAgAiB0EBajYCAAJAIAdBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAU2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiAJKQOYAjcDgAYgCSgCoAQhCCACIAkoAqQEQQAgCSgCnAQiBxs2ApALIAIgCDYCjAsgAiAHNgKICyACQQA2AoQLIAIgB0EARyILNgKACyACIAg2AvwKIAIgBzYC+AogAkEANgL0CiACIAs2AvAKIAJB4AJqIAJB8ApqIgcQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAcgAkGwBGpBwAL8CgAAIAJB9AZqIAlB8ANqELUWIAJBiA1qIQcgAigCiA1BgICAgHhHBEAgB0EEQQgQ4B4LIAcgAikC9AY3AgAgB0EIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgcgAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACAKGyEmIAktAKwEBEAgBUEIahCqJSEFIAJBADoAqgcgAkIBNwOYByACQgA3A4AHIAIgCS0AkQIiCDoArQcgAiAJLQCQAiIKOgCsByACIAkpA/ABNwOgByACIAkpA7ABNwOQByACIAkpA6gBNwOIByACIAVB/wFxRToAqwcgAiAKQQJHOgCpByACIAhBAkc6AKgHIAJB2AdqIgUgCSACQYAHahDpBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgggB0HAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiIKIAJBwAD8CgAAIAJB0AtqIgsQwhggCyAFQdgA/AoAACACQbAIaiILIAJB8ApqIgxBwAL8CgAAIAIgCSkDwAE3A4gJIAIgCSkDuAE3A4AJIAJB6AJqIgUgCUGAAmooAgA2AgAgCSkC+AEhIyAJQYCAgIB4NgL4ASACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAUoAgA2AgAgAiACKQPgAjcC1AogDCALQcAC/AoAACAFIAlBjAJqKAIANgIAIAkpAoQCISMgCUGAgICAeDYChAIgAiAjNwPgAiACQaANahCFMCACQagNaiAFKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgByAIQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgCkHAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgA0HgAmoiAiADQegDaikDADcDACADQegCaiIGIANB8ANqKQMANwMAIAMgAykD4AM3A9gCIAMpA9gDIiNCAlEEQCAEIAMpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIANBOGogA0H4A2pBoAL8CgAAIANBKGogA0HgAmopAwA3AwAgA0EwaiADQegCaikDADcDACADICM3AxggAyADKQPYAjcDICADQdgDaiAJKALgAyAJKALkAygCEBEAACADKALYAyICQQhHBEAgBCADKQLcAzcCDCAEQRxqIANB7ANqKAIANgIAIARBFGogA0HkA2opAgA3AgAgBEICNwMAIAQgAjYCCCADQRhqEKogDAILIAlBAUECQQAgCS0AqwRBAXEbIAktAKoEGzYC+AIgCS0A/AIhAiADQdgDaiIFIAlBsAJqQdAA/AoAAAJ/IAJFBEAgBRDtJ0GAgICAeAwBCyADQbgDaiAJQcQCaigCADYCACADQagDaiAJQdACaigCADYCACADQZgDaiAJQdwCaigCADYCACADQYgDaiAJQegCaigCADYCACADIAkpArwCNwOwAyADIAkpAsgCNwOgAyADIAkpAtQCNwOQAyADIAkpAuACNwOAAyADKAKgBCEGIANB+AJqIAlB9AJqKAIANgIAIAMgCSkC7AI3A/ACIAMpAtwDISMgAygC2AMLIQICQCAJKAKwAyIFQYCAgIB4RwRAIAkpA6gDISQgAyAFNgLgAyADICQ3A9gDIANB5ANqIAlBtANqQSz8CgAAIANBwANqIANB2ANqEOgRDAELIANBgICAgHg2AsADCyAJKQNwISQgCUGAgICAeDYCcCAEICQ3A+gCIARB8AJqIAlB+ABqKAIANgIAIAkpA8gBISQgCSkD0AEhJSADQdgDaiIFIANBGGpBwAL8CgAAIANBqAZqIANB0ANqKQIANwMAIANBoAZqIANByANqKQIANwMAIAMgAykCwAM3A5gGIAQgBUHYAvwKAAAgBCAjNwP4AiAEIAI2AvQCIAQgJTcD4AIgBCAkNwPYAiAEIAMpA7ADNwKAAyAEQYgDaiADQbgDaigCADYCACAEIAMpA6ADNwKMAyAEQZQDaiADQagDaigCADYCACAEIAMpA5ADNwKYAyAEQaADaiADQZgDaigCADYCACAEIAMpA4ADNwKkAyAEQawDaiADQYgDaigCADYCACAEIAY2ArwDIARBuANqIANB+AJqKAIANgIAIAQgAykD8AI3ArADIAkoApQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCAJQZQEahDZIQsgCSgCmAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAlBmARqEK4gCyAJQeADahC8KiAJQegDahDXKSAJEPkYIAlBiANqEIUwIAlBlANqEIUwIAlB+AFqEIUwIAlBhAJqEIUwIAlBnARqEMMcIAlB8ANqQQRBCBDgHiAJQfwDahCdPCAJQYgEahCdPCAJQaACaiIEEIcZIARBCEGIARDgHgwCCyADQRBqIgIgA0EsaigCADYCACADQQhqIgUgA0EkaikCADcDACADIAMpAhw3AwAgBCAGNgIIIAQgAykDADcCDCAEQgI3AwAgBEEUaiAFKQMANwIAIARBHGogAigCADYCAAsgCSgClAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAlBlARqENkhCyAJKAKYBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgCUGYBGoQriALIAlB4ANqELwqIAlB6ANqENcpIAkQ+RggCUGIA2oQhTAgCUGUA2oQhTAgCUH4AWoQhTAgCUGEAmoQhTAgCUGcBGoQwxwgCUHwA2pBBEEIEOAeIAlB/ANqEJ08IAlBiARqEJ08IAlBoAJqIgQQhxkgBEEIQYgBEOAeIAlBsAJqEO0nIAlBqANqEMcoCyADQbAGaiQADAcLIAlBsARqIgMgAkHQBPwKAAAjAEGwBmsiBSQAAkACQAJAIAMoArgDRQ0AIAVB2ANqIAMQ5AEgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCADKAJoQYCAgIB4Rg0AIAVB2ANqIAMQjgcgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAMoArgDRQ0AIAVBGGogAxDkASAFKAIYIgZBCEYNAAwBCwJAIAMoAsQCIgZFDQAgBUHgA2ohAgNAIAMgBkEBazYCxAIgAyADKALAAiIGQQFqIgcgAygCuAIiCEEAIAcgCE8bazYCwAIgAygCvAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAUgIzcD2AMgAiAGQQhqQYAB/AoAACAFQRhqIAMgBUHYA2oQqAogBSgCGCIGQQhHDQIgAygCxAIiBg0ACwsgBUHYA2ohBiMAQbANayICJAAgAykDoAEhJSADKQOYASEoIAMpA4gCISkgAykD+AEhKiADKQOAAiEnIAMpA7ABISYgAygCqAEhCyADKAK4BCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAc2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiADKQOwAjcDgAYgAygCxAQhCiACIAMoAsgEQQAgAygCwAQiCBs2ApALIAIgCjYCjAsgAiAINgKICyACQQA2AoQLIAIgCEEARyIMNgKACyACIAo2AvwKIAIgCDYC+AogAkEANgL0CiACIAw2AvAKIAJB4AJqIAJB8ApqIggQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAggAkGwBGpBwAL8CgAAIAJB9AZqIANBlARqELUWIAJBiA1qIQggAigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggAikC9AY3AgAgCEEIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgggAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACALGyEmIAMtAM4EBEAgB0EIahCqJSEHIAJBADoAugcgAkIBNwOYByACIAMoAtgBIgo6ALkHIAIgAygC4AEiCzoAuAcgAiADKALkATYCtAcgAiALNgKwByACIAMoAtwBNgKsByACIAo2AqgHIAIgAykDkAI3A6AHIAIgAykDwAE3A5AHIAIgAykDuAE3A4gHIAIgB0H/AXFFOgC7ByACQgE3A4AHIAJB2AdqIgcgAyACQYAHahDnBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgogCEHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAHQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD0AE3A4gJIAIgAykDyAE3A4AJIAJB6AJqIgcgA0GgAmooAgA2AgAgAykCmAIhIyADQYCAgIB4NgKYAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAcoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAHIANBrAJqKAIANgIAIAMpAqQCISMgA0GAgICAeDYCpAIgAiAjNwPgAiACQaANahCFMCACQagNaiAHKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCCAKQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAL4AyADKAL8AygCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AzQRBAXEbIAMtAMwEGzYCkAMgAy0AlAMhAiAFQdgDaiIHIANByAJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQdwCaigCADYCACAFQagDaiADQegCaigCADYCACAFQZgDaiADQfQCaigCADYCACAFQYgDaiADQYADaigCADYCACAFIAMpAtQCNwOwAyAFIAMpAuACNwOgAyAFIAMpAuwCNwOQAyAFIAMpAvgCNwOAAyAFKAKgBCEGIAVB+AJqIANBjANqKAIANgIAIAUgAykChAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKALIAyIHQYCAgIB4RwRAIAMpA8ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANBzANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOAASEkIANBgICAgHg2AoABIAQgJDcD6AIgBEHwAmogA0GIAWooAgA2AgAgAykD6AEhJCADKQPwASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCuAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBuARqENkhCyADKAK8BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G8BGoQriALIANB+ANqELwqIANBgARqENcpIAMQ+hggA0GgA2oQhTAgA0GsA2oQhTAgA0GYAmoQhTAgA0GkAmoQhTAgA0HABGoQwxwgA0GUBGpBBEEIEOAeIANBoARqEJ08IANBrARqEJ08IANBuAJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAK4BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G4BGoQ2SELIAMoArwEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQbwEahCuIAsgA0H4A2oQvCogA0GABGoQ1ykgAxD6GCADQaADahCFMCADQawDahCFMCADQZgCahCFMCADQaQCahCFMCADQcAEahDDHCADQZQEakEEQQgQ4B4gA0GgBGoQnTwgA0GsBGoQnTwgA0G4AmoiBBCHGSAEQQhBiAEQ4B4gA0HIAmoQ7ScgA0HAA2oQxygLIAVBsAZqJAAMBgsgCUGACWoiAyACQYAF/AoAACMAQbAGayIFJAACQAJAAkAgAygC8ANFDQAgBUHYA2ogAxDnASAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAIAMoAnhBgICAgHhGDQAgBUHYA2ogAxCMByAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAAkAgAygC8ANFDQAgBUEYaiADEOcBIAUoAhgiBkEIRg0ADAELAkAgAygC/AIiBkUNACAFQeADaiECA0AgAyAGQQFrNgL8AiADIAMoAvgCIgZBAWoiByADKALwAiIIQQAgByAITxtrNgL4AiADKAL0AiAGQYgBbGoiBikDACIjQgxRDQEgBSAjNwPYAyACIAZBCGpBgAH8CgAAIAVBGGogAyAFQdgDahCkCiAFKAIYIgZBCEcNAiADKAL8AiIGDQALCyAFQdgDaiEGIwBBsA1rIgIkACADKQOwASEmIAMpA6gBISMgAykDqAIhJSADKQOYAiEoIAMpA6ACISkgAykDwAEhJyADKAK4ASELIAMoAuQEIgcgBygCACIIQQFqNgIAAkAgCEEATgRAIAJBADYC+AUgAkEANgLwBSACQQA2AugFIAJCCDcDkAUgAkIANwOABSACQgA3A/AEIAJCADcD4AQgAkIANwPQBCACQgA3A8AEIAJCADcDsAQgAkGIBmpBAEEs/AsAIAIgBzYC7AYgAkGAgICAeDYC4AYgAkGAgICAeDYC1AYgAkGAgICAeDYCyAYgAkGAgICAeDYCvAYgAkIBNwK0BiACIAMpA+gCNwOABiADKALwBCEKIAIgAygC9ARBACADKALsBCIIGzYCkAsgAiAKNgKMCyACIAg2AogLIAJBADYChAsgAiAIQQBHIgw2AoALIAIgCjYC/AogAiAINgL4CiACQQA2AvQKIAIgDDYC8AogAkHgAmogAkHwCmoiCBCsFSACQbAGakEBQQEQ4B4gAkG4BmogAkHoAmooAgA2AgAgAiACKQLgAjcDsAYgCCACQbAEakHAAvwKAAAgAkH0BmogA0HABGoQtRYgAkGIDWohCCACKAKIDUGAgICAeEcEQCAIQQRBCBDgHgsgCCACKQL0BjcCACAIQQhqIAJB/AZqKAIANgIAIAIpA/AKISQgAikD+AohKiACQeACaiACQYALakHQAfwKAAAgAkGAAmogAkHQDGpB4AD8CgAAIAJBQGsiCCACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJ0IAIAsbIScgAy0A+gQEQCAHQQhqEKolIQcgAkEAOgDKByACQgE3A7gHIAIgAykDyAEiKzwAyQcgAiADKQPYASIsPADIByACIAMpA7ACNwPAByACIAMpA/ABNwOwByACIAMpA+gBNwOoByACIAMpA+ABNwOgByACICw3A5gHIAIgAykD0AE3A5AHIAIgKzcDiAcgAiAHQf8BcUU6AMsHIAJCAjcDgAcgAkHYB2oiByADIAJBgAdqEOgGIAIgJjcDiAsgAiAjNwOACyACICo3A/gKIAIgJDcD8AogAkGQC2oiCiAIQcAB/AoAACACICc3A+gMIAIgKDcD4AwgAiApNwPYDCACICU3A9AMIAJB8AxqIgsgAkHAAPwKAAAgAkHQC2oiDBDCGCAMIAdB2AD8CgAAIAJBsAhqIgwgAkHwCmoiD0HAAvwKAAAgAiADKQOAAjcDiAkgAiADKQP4ATcDgAkgAkHoAmoiByADQcACaigCADYCACADKQK4AiEjIANBgICAgHg2ArgCIAIgIzcD4AIgAkHUCmoQhTAgAkHcCmogBygCADYCACACIAIpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HMAmooAgA2AgAgAykCxAIhIyADQYCAgIB4NgLEAiACICM3A+ACIAJBoA1qEIUwIAJBqA1qIAcoAgA2AgAgAiACKQPgAjcDoA0gAikD8AohJCACKQP4CiEqIAIpA4ALISMgAikDiAshJiAIIApBwAH8CgAAIAIpA+gMIScgAikD4AwhKCACKQPYDCEpIAIpA9AMISUgAiALQcAA/AoAAAsgJEICUgRAIAZBIGogAkFAa0HAAfwKAAAgBkGAAmogAkHAAPwKAAAgBiAnNwP4ASAGICg3A/ABIAYgKTcD6AEgBiAlNwPgAQsgBiAmNwMYIAYgIzcDECAGICo3AwggBiAkNwMAIAJBsA1qJAAMAQsACyAFQeACaiICIAVB6ANqKQMANwMAIAVB6AJqIgYgBUHwA2opAwA3AwAgBSAFKQPgAzcD2AIgBSkD2AMiJEICUQRAIAQgBSkD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAIpAwA3AwAMAgsgBUE4aiAFQfgDakGgAvwKAAAgBUEoaiAFQeACaikDADcDACAFQTBqIAVB6AJqKQMANwMAIAUgJDcDGCAFIAUpA9gCNwMgIAVB2ANqIAMoArAEIAMoArQEKAIQEQAAIAUoAtgDIgJBCEcEQCAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIIAVBGGoQqiAMAgsgA0EBQQJBACADLQD5BEEBcRsgAy0A+AQbNgLIAyADLQDMAyECIAVB2ANqIgcgA0GAA2pB0AD8CgAAAn8gAkUEQCAHEO0nQYCAgIB4DAELIAVBuANqIANBlANqKAIANgIAIAVBqANqIANBoANqKAIANgIAIAVBmANqIANBrANqKAIANgIAIAVBiANqIANBuANqKAIANgIAIAUgAykCjAM3A7ADIAUgAykCmAM3A6ADIAUgAykCpAM3A5ADIAUgAykCsAM3A4ADIAUoAqAEIQYgBUH4AmogA0HEA2ooAgA2AgAgBSADKQK8AzcD8AIgBSkC3AMhJCAFKALYAwshAgJAIAMoAoAEIgdBgICAgHhHBEAgAykD+AMhIyAFIAc2AuADIAUgIzcD2AMgBUHkA2ogA0GEBGpBLPwKAAAgBUHAA2ogBUHYA2oQ6BEMAQsgBUGAgICAeDYCwAMLIAMpA5ABISMgA0GAgICAeDYCkAEgBCAjNwPoAiAEQfACaiADQZgBaigCADYCACADKQOIAiEjIAMpA5ACISUgBUHYA2oiByAFQRhqQcAC/AoAACAFQagGaiAFQdADaikCADcDACAFQaAGaiAFQcgDaikCADcDACAFIAUpAsADNwOYBiAEIAdB2AL8CgAAIAQgJDcD+AIgBCACNgL0AiAEICU3A+ACIAQgIzcD2AIgBCAFKQOwAzcCgAMgBEGIA2ogBUG4A2ooAgA2AgAgBCAFKQOgAzcCjAMgBEGUA2ogBUGoA2ooAgA2AgAgBCAFKQOQAzcCmAMgBEGgA2ogBUGYA2ooAgA2AgAgBCAFKQOAAzcCpAMgBEGsA2ogBUGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiAFQfgCaigCADYCACAEIAUpA/ACNwKwAyADKALkBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HkBGoQ2SELIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahCuIAsgA0GwBGoQvCogA0G4BGoQ1ykgAxD7GCADQdgDahCFMCADQeQDahCFMCADQbgCahCFMCADQcQCahCFMCADQewEahDDHCADQcAEakEEQQgQ4B4gA0HMBGoQnTwgA0HYBGoQnTwgA0HwAmoiBBCHGSAEQQhBiAEQ4B4MAgsgBUEQaiICIAVBLGooAgA2AgAgBUEIaiIHIAVBJGopAgA3AwAgBSAFKQIcNwMAIAQgBjYCCCAEIAUpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAIoAgA2AgALIAMoAuQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQeQEahDZIQsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqEK4gCyADQbAEahC8KiADQbgEahDXKSADEPsYIANB2ANqEIUwIANB5ANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB7ARqEMMcIANBwARqQQRBCBDgHiADQcwEahCdPCADQdgEahCdPCADQfACaiIEEIcZIARBCEGIARDgHiADQYADahDtJyADQfgDahDHKAsgBUGwBmokAAwFCyAJQYAOaiIDIAJBgAX8CgAAIwBB0AZrIgIkAAJAAkACQCADKALYA0UNACACQdgDaiADEOABIAIoAtgDIgZBCEYNACAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAGNgIIDAELAkAgAygCeEGAgICAeEYNACACQdgDaiEIIwBBgAFrIgYkACADKAJ4IQUgA0GAgICAeDYCeAJAAkAgBUGAgICAeEcEQCAGIANBMGpByAD8CgAAIAZB1ABqIANBhAFqKAIANgIAIAYgBTYCSCAGIAMpAnw3AkwCQAJAIAMoAqABRQRAIwBBQGoiBSQAIAVBCGpBgAIQ6CAgBUEANgIoIAVCgICAgBA3AyAgBUEgaiELIAYoAjgiDwRAIAYoAjQhDCAPQQxsIQ8DQCALIAxBDBChNiAMQQxqIQwgD0EMayIPDQALCyAFLQAcIQwgBSAFKQMINwMwIAxBA3YgDEEHcUEAR2oiDEEJTwRAIAxBCEHojs4AELA7AAsgBUEQaiAFQTBqIg8gDBChNiAFQQA6ABwgBUIANwMIIAsgBSgCFCAFKAIYEKE2IAVBADoAHCAFQgA3AwggBUEANgIYIAVBOGogC0EIaigCADYCACAFIAspAgA3AzAgBUEANgIoIAVCgICAgBA3AyAgBkHoAGoiC0EEaiAPEOcVIAtBCDYCACAFQQhqEMouIAVBQGskACAGQeAAaiIFIAZB9ABqKQIANwMAIAYgBikCbDcDWCAGKAJoIgtBCEYNASAGKAJ8IQwgCCAGKQNYNwIMIAggDDYCHCAIIAs2AgggCEEBNgIAIAhBFGogBSkDADcCAAwCCyAGQegAakEwQQBBAUEBEKAYIAYoAmwhBSAGKAJoQQFGDQMgBigCcCILQZiJzgBBMPwKAAAgCEEwNgIUIAggCzYCECAIIAU2AgwgCEEANgIIIAhBATYCAAwBCyAIIAYpA1g3AgQgCEEMaiAFKQMANwIAIAhBADoAGCAIIAYoAjg2AhQgCEEANgIACyAGEIMtDAILIAhBADYCACAIQQI6ABgMAQsgBSAGKAJwQZyHzgAQ/S8ACyAGQYABaiQAAn8CQAJAIAIoAtgDQQFGBEAgAigC9AMhByACKALwAyEKIAIoAuwDIQsgAigC6AMhBiACKALkAyEIIAIoAuADIQUMAQsgAigC8AMiBUH/AXFBAkYEQEEAIQVBHSELIAJB2ANqQR1BAEEBQQEQoBggAigC3AMhCCACKALYA0EBRg0OIAIoAuADIgZBFWpBjYTPACkAADcAACAGQRBqQYiEzwApAAA3AAAgBkEIakGAhM8AKQAANwAAIAZB+IPPACkAADcAAAwBCyACKALsAyEHIAIoAugDIQogAigC5AMhBiACKALgAyEIIAIoAtwDIQsgAiAFNgIsIAIgBzYCKCACIAo2AiQgAiAGNgIgIAIgCDYCHCACIAs2AhggAygCoAQEQCACQdgDaiIHIAZBAEEBQQEQoBggAigC3AMhBSACKALYA0EBRg0PIAJBJGohDCACQQA2ArwGIAIgAigC4AM2ArgGIAIgBTYCtAYgByADKAKgBCAIIAYgAkG0BmoiDyADKAKkBCgCDBEHACACKALYAyIFQQhHBEAgAigC7AMhByACKALoAyEKIAIoAuQDIQsgAigC4AMhBiACKALcAyEIIA8Q3jsgDCACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACQcgGaiACQbwGaigCADYCACACIAIpArQGNwPABiACQdgDaiACQcAGahDnFSAMIAIoAhwgAkEgaiIFKAIAIAIoAhgoAhARAQAgBSACQeADaikCADcDACACIAIpAtgDNwMYIAIoAighByACLQAsIQULIAJB4AJqIgogAkEgaikDADcDACACIAIpAxg3A9gCIANB8ARqQQAQ6R4gAygCzAQiCCADKALEBEYEQCADQcQEakHog88AEJsoCyADKALIBCAIQQN0akKBgICAgMAANwIAIAMgCEEBajYCzAQgAygCmAQhCCADKAKcBCELIAJB6ANqIAopAwA3AwAgAkILNwPYAyACIAIpA9gCNwPgAyACIAY2AtgEIAIgBToA9QMgAkEAOgD0AyACIAc2AvADIAJBGGogCCACQdgDaiALKAIMEQEAIAIoAiwhByACKAIoIQogAikDGCEjIAItADQiBkEERw0BICNCIIinIQggAigCICEGIAIoAiQhCyAjpyEFCyAFQQhGDQIgBCAHNgIcIAQgCjYCGCAEIAs2AhQgBCAGNgIQIAQgCDYCDCAEIAU2AgggBEICNwMADAMLIAI1AjAhJCACKQMgISUgAyADKQOYAiAKrXw3A5gCIAMgAykDoAIgB618NwOgAiADICUgAykDiAJ8NwOIAgJAAkAgBkEBaw4CAwABCyADKQOoAVBFDQ4gA0IBNwOoAUGwAQwBCyADIAMpA6gCICR8NwOoAiADKQO4AVBFBEAMAgsgA0IBNwO4AUHAAQsgA2ogIzcDAAsCQAJAIAMoAtgDRQ0AIAJBGGogAxDgASACKAIYIgVBCEYNAAwBCwJAIAMoAuQCIgVFDQAgAkHgA2ohBgNAIAMgBUEBazYC5AIgAyADKALgAiIFQQFqIgcgAygC2AIiCEEAIAcgCE8bazYC4AIgAygC3AIgBUGIAWxqIgUpAwAiI0IMUQ0BIAIgIzcD2AMgBiAFQQhqQYAB/AoAACACQRhqIAMgAkHYA2oQpwogAigCGCIFQQhHDQIgAygC5AIiBQ0ACwsgAkHYA2ohBSMAQdANayIGJAAgAykDsAEhJSADKQOoASEoIAMpA6gCISkgAykDmAIhKiADKQOgAiEnIAMpA8ABISYgAygCuAEhCyADKALoBCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCAGQQA2AvgFIAZBADYC8AUgBkEANgLoBSAGQgg3A5AFIAZCADcDgAUgBkIANwPwBCAGQgA3A+AEIAZCADcD0AQgBkIANwPABCAGQgA3A7AEIAZBiAZqQQBBLPwLACAGIAc2AuwGIAZBgICAgHg2AuAGIAZBgICAgHg2AtQGIAZBgICAgHg2AsgGIAZBgICAgHg2ArwGIAZCATcCtAYgBiADKQPQAjcDgAYgAygC9AQhCiAGIAMoAvgEQQAgAygC8AQiCBs2ArALIAYgCjYCrAsgBiAINgKoCyAGQQA2AqQLIAYgCEEARyIMNgKgCyAGIAo2ApwLIAYgCDYCmAsgBkEANgKUCyAGIAw2ApALIAZB4AJqIAZBkAtqIggQrBUgBkGwBmpBAUEBEOAeIAZBuAZqIAZB6AJqKAIANgIAIAYgBikC4AI3A7AGIAggBkGwBGpBwAL8CgAAIAZB9AZqIANBxARqELUWIAZBqA1qIQggBigCqA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggBikC9AY3AgAgCEEIaiAGQfwGaigCADYCACAGKQOQCyEjIAYpA5gLISQgBkHgAmogBkGgC2pB0AH8CgAAIAZBgAJqIAZB8AxqQeAA/AoAACAGQUBrIAZB8AJqQcAB/AoAACAGIAZBoAJqQcAA/AoAACAmQgAgCxshJiADLQD+BARAIAdBCGoQqiUhCkEAIQdBACEIIAMoAugBQQFGBEAgBkHgB2ogA0H0AWooAgA2AgAgBiADKQLsATcD2AdBASEICyADKAL4AUEBRgRAIAZB8AdqIANBhAJqKAIANgIAIAYgAykC/AE3A+gHQQEhBwsgBkG0B2ogBkHgB2ooAgA2AgAgBkHEB2ogBkHwB2ooAgA2AgAgBiAINgKoByAGQgE3A5gHIAYgBikD2Ac3AqwHIAYgBzYCuAcgBiAGKQPoBzcCvAcgBiADKQOwAjcDoAcgBiADKQPQATcDkAcgBiADKQPIATcDiAcgBiAKQf8BcUU6AMsHIAZBADoAygcgBiAIOgDJByAGIAc6AMgHIAZCAzcDgAcgBkH4B2oiByADIAZBgAdqEOoGIAYgJTcDqAsgBiAoNwOgCyAGICQ3A5gLIAYgIzcDkAsgBkGwC2oiCCAGQUBrIgpBwAH8CgAAIAYgJjcDiA0gBiAqNwOADSAGICc3A/gMIAYgKTcD8AwgBkGQDWoiCyAGQcAA/AoAACAGQfALaiIMEMIYIAwgB0HYAPwKAAAgBkHQCGoiDCAGQZALaiIPQcAC/AoAACAGIAMpA+ABNwOoCSAGIAMpA9gBNwOgCSAGQegCaiIHIANBwAJqKAIANgIAIAMpArgCISMgA0GAgICAeDYCuAIgBiAjNwPgAiAGQfQKahCFMCAGQfwKaiAHKAIANgIAIAYgBikD4AI3AvQKIA8gDEHAAvwKAAAgByADQcwCaigCADYCACADKQLEAiEjIANBgICAgHg2AsQCIAYgIzcD4AIgBkHADWoQhTAgBkHIDWogBygCADYCACAGIAYpA+ACNwPADSAGKQOQCyEjIAYpA5gLISQgBikDoAshKCAGKQOoCyElIAogCEHAAfwKAAAgBikDiA0hJiAGKQOADSEqIAYpA/gMIScgBikD8AwhKSAGIAtBwAD8CgAACyAjQgJSBEAgBUEgaiAGQUBrQcAB/AoAACAFQYACaiAGQcAA/AoAACAFICY3A/gBIAUgKjcD8AEgBSAnNwPoASAFICk3A+ABCyAFICU3AxggBSAoNwMQIAUgJDcDCCAFICM3AwAgBkHQDWokAAwBCwALIAJB4AJqIgUgAkHoA2opAwA3AwAgAkHoAmoiBiACQfADaikDADcDACACIAIpA+ADNwPYAiACKQPYAyIjQgJRBEAgBCACKQPYAjcDCCAEQgI3AwAgBEEYaiAGKQMANwMAIARBEGogBSkDADcDAAwCCyACQThqIAJB+ANqQaAC/AoAACACQShqIAJB4AJqKQMANwMAIAJBMGogAkHoAmopAwA3AwAgAiAjNwMYIAIgAikD2AI3AyAgAkHYA2ogAygCmAQgAygCnAQoAhARAAAgAigC2AMiBUEIRwRAIAQgAikC3AM3AgwgBEEcaiACQewDaigCADYCACAEQRRqIAJB5ANqKQIANwIAIARCAjcDACAEIAU2AgggAkEYahCqIAwCCyADQQFBAkEAIAMtAP0EQQFxGyADLQD8BBs2ArADIAMtALQDIQUgAkHYA2oiByADQegCakHQAPwKAAACfyAFRQRAIAcQ7SdBgICAgHgMAQsgAkG4A2ogA0H8AmooAgA2AgAgAkGoA2ogA0GIA2ooAgA2AgAgAkGYA2ogA0GUA2ooAgA2AgAgAkGIA2ogA0GgA2ooAgA2AgAgAiADKQL0AjcDsAMgAiADKQKAAzcDoAMgAiADKQKMAzcDkAMgAiADKQKYAzcDgAMgAigCoAQhBiACQfgCaiADQawDaigCADYCACACIAMpAqQDNwPwAiACKQLcAyEjIAIoAtgDCyEFAkAgAygC6AMiB0GAgICAeEcEQCADKQPgAyEkIAIgBzYC4AMgAiAkNwPYAyACQeQDaiADQewDakEs/AoAACACQcADaiACQdgDahDoEQwBCyACQYCAgIB4NgLAAwsgAykDkAEhJCADQYCAgIB4NgKQASAEICQ3A+gCIARB8AJqIANBmAFqKAIANgIAIAMpA4gCISQgAykDkAIhJSACQdgDaiIHIAJBGGpBwAL8CgAAIAJBqAZqIAJB0ANqKQIANwMAIAJBoAZqIAJByANqKQIANwMAIAIgAikCwAM3A5gGIAQgB0HYAvwKAAAgBCAjNwP4AiAEIAU2AvQCIAQgJTcD4AIgBCAkNwPYAiAEIAIpA7ADNwKAAyAEQYgDaiACQbgDaigCADYCACAEIAIpA6ADNwKMAyAEQZQDaiACQagDaigCADYCACAEIAIpA5ADNwKYAyAEQaADaiACQZgDaigCADYCACAEIAIpA4ADNwKkAyAEQawDaiACQYgDaigCADYCACAEIAY2ArwDIARBuANqIAJB+AJqKAIANgIAIAQgAikD8AI3ArADIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahDZIQsgAygC7AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB7ARqEK4gCyADQZgEahC8KiADQaAEahDXKSADEIYZIANBwANqEIUwIANBzANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB8ARqEMMcIANBxARqQQRBCBDgHiADQdAEahCdPCADQdwEahCdPCADQdgCaiIEEIcZIARBCEGIARDgHgwCCyACQRBqIgYgAkEsaigCADYCACACQQhqIgcgAkEkaikCADcDACACIAIpAhw3AwAgBCAFNgIIIAQgAikDADcCDCAEQgI3AwAgBEEUaiAHKQMANwIAIARBHGogBigCADYCAAsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqENkhCyADKALsBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HsBGoQriALIANBmARqELwqIANBoARqENcpIAMQhhkgA0HAA2oQhTAgA0HMA2oQhTAgA0G4AmoQhTAgA0HEAmoQhTAgA0HwBGoQwxwgA0HEBGpBBEEIEOAeIANB0ARqEJ08IANB3ARqEJ08IANB2AJqIgQQhxkgBEEIQYgBEOAeIANB6AJqEO0nIANB4ANqEMcoCyACQdAGaiQADAQLIAlBgBNqIgMgAkHQBPwKAAAjAEGwBmsiBSQAAkACQAJAIAMoArgDRQ0AIAVB2ANqIAMQ6AEgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCADKAJoQYCAgIB4Rg0AIAVB2ANqIAMQjgcgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAMoArgDRQ0AIAVBGGogAxDoASAFKAIYIgZBCEYNAAwBCwJAIAMoAsQCIgZFDQAgBUHgA2ohAgNAIAMgBkEBazYCxAIgAyADKALAAiIGQQFqIgcgAygCuAIiCEEAIAcgCE8bazYCwAIgAygCvAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAUgIzcD2AMgAiAGQQhqQYAB/AoAACAFQRhqIAMgBUHYA2oQqAogBSgCGCIGQQhHDQIgAygCxAIiBg0ACwsgBUHYA2ohBiMAQbANayICJAAgAykDoAEhJSADKQOYASEoIAMpA4gCISkgAykD+AEhKiADKQOAAiEnIAMpA7ABISYgAygCqAEhCyADKAK4BCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAc2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiADKQOwAjcDgAYgAygCxAQhCiACIAMoAsgEQQAgAygCwAQiCBs2ApALIAIgCjYCjAsgAiAINgKICyACQQA2AoQLIAIgCEEARyIMNgKACyACIAo2AvwKIAIgCDYC+AogAkEANgL0CiACIAw2AvAKIAJB4AJqIAJB8ApqIggQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAggAkGwBGpBwAL8CgAAIAJB9AZqIANBlARqELUWIAJBiA1qIQggAigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggAikC9AY3AgAgCEEIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgggAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACALGyEmIAMtAM4EBEAgB0EIahCqJSEHIAJBADoAugcgAkIBNwOYByACIAMoAtgBIgo6ALkHIAIgAygC4AEiCzoAuAcgAiADKgLkATgCtAcgAiALNgKwByACIAMqAtwBOAKsByACIAo2AqgHIAIgAykDkAI3A6AHIAIgAykDwAE3A5AHIAIgAykDuAE3A4gHIAIgB0H/AXFFOgC7ByACQgQ3A4AHIAJB2AdqIgcgAyACQYAHahDnBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgogCEHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAHQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD0AE3A4gJIAIgAykDyAE3A4AJIAJB6AJqIgcgA0GgAmooAgA2AgAgAykCmAIhIyADQYCAgIB4NgKYAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAcoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAHIANBrAJqKAIANgIAIAMpAqQCISMgA0GAgICAeDYCpAIgAiAjNwPgAiACQaANahCFMCACQagNaiAHKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCCAKQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAL4AyADKAL8AygCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AzQRBAXEbIAMtAMwEGzYCkAMgAy0AlAMhAiAFQdgDaiIHIANByAJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQdwCaigCADYCACAFQagDaiADQegCaigCADYCACAFQZgDaiADQfQCaigCADYCACAFQYgDaiADQYADaigCADYCACAFIAMpAtQCNwOwAyAFIAMpAuACNwOgAyAFIAMpAuwCNwOQAyAFIAMpAvgCNwOAAyAFKAKgBCEGIAVB+AJqIANBjANqKAIANgIAIAUgAykChAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKALIAyIHQYCAgIB4RwRAIAMpA8ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANBzANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOAASEkIANBgICAgHg2AoABIAQgJDcD6AIgBEHwAmogA0GIAWooAgA2AgAgAykD6AEhJCADKQPwASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCuAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBuARqENkhCyADKAK8BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G8BGoQriALIANB+ANqELwqIANBgARqENcpIAMQ+hggA0GgA2oQhTAgA0GsA2oQhTAgA0GYAmoQhTAgA0GkAmoQhTAgA0HABGoQwxwgA0GUBGpBBEEIEOAeIANBoARqEJ08IANBrARqEJ08IANBuAJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAK4BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G4BGoQ2SELIAMoArwEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQbwEahCuIAsgA0H4A2oQvCogA0GABGoQ1ykgAxD6GCADQaADahCFMCADQawDahCFMCADQZgCahCFMCADQaQCahCFMCADQcAEahDDHCADQZQEakEEQQgQ4B4gA0GgBGoQnTwgA0GsBGoQnTwgA0G4AmoiBBCHGSAEQQhBiAEQ4B4gA0HIAmoQ7ScgA0HAA2oQxygLIAVBsAZqJAAMAwsgCUHQF2oiAyACQYAF/AoAACMAQbAGayIFJAACQAJAAkAgAygC8ANFDQAgBUHYA2ogAxDqASAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAIAMoAnhBgICAgHhGDQAgBUHYA2ogAxCMByAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAAkAgAygC8ANFDQAgBUEYaiADEOoBIAUoAhgiBkEIRg0ADAELAkAgAygC/AIiBkUNACAFQeADaiECA0AgAyAGQQFrNgL8AiADIAMoAvgCIgZBAWoiByADKALwAiIIQQAgByAITxtrNgL4AiADKAL0AiAGQYgBbGoiBikDACIjQgxRDQEgBSAjNwPYAyACIAZBCGpBgAH8CgAAIAVBGGogAyAFQdgDahCkCiAFKAIYIgZBCEcNAiADKAL8AiIGDQALCyAFQdgDaiEGIwBBsA1rIgIkACADKQOwASEmIAMpA6gBISMgAykDqAIhJSADKQOYAiEoIAMpA6ACISkgAykDwAEhJyADKAK4ASELIAMoAuQEIgcgBygCACIIQQFqNgIAAkAgCEEATgRAIAJBADYC+AUgAkEANgLwBSACQQA2AugFIAJCCDcDkAUgAkIANwOABSACQgA3A/AEIAJCADcD4AQgAkIANwPQBCACQgA3A8AEIAJCADcDsAQgAkGIBmpBAEEs/AsAIAIgBzYC7AYgAkGAgICAeDYC4AYgAkGAgICAeDYC1AYgAkGAgICAeDYCyAYgAkGAgICAeDYCvAYgAkIBNwK0BiACIAMpA+gCNwOABiADKALwBCEKIAIgAygC9ARBACADKALsBCIIGzYCkAsgAiAKNgKMCyACIAg2AogLIAJBADYChAsgAiAIQQBHIgw2AoALIAIgCjYC/AogAiAINgL4CiACQQA2AvQKIAIgDDYC8AogAkHgAmogAkHwCmoiCBCsFSACQbAGakEBQQEQ4B4gAkG4BmogAkHoAmooAgA2AgAgAiACKQLgAjcDsAYgCCACQbAEakHAAvwKAAAgAkH0BmogA0HABGoQtRYgAkGIDWohCCACKAKIDUGAgICAeEcEQCAIQQRBCBDgHgsgCCACKQL0BjcCACAIQQhqIAJB/AZqKAIANgIAIAIpA/AKISQgAikD+AohKiACQeACaiACQYALakHQAfwKAAAgAkGAAmogAkHQDGpB4AD8CgAAIAJBQGsiCCACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJ0IAIAsbIScgAy0A+gQEQCAHQQhqEKolIQcgAkEAOgDKByACQgE3A7gHIAIgAykDyAEiKzwAyQcgAiADKQPYASIsPADIByACIAMpA7ACNwPAByACIAMpA/ABNwOwByACIAMpA+gBNwOoByACIAMrA+ABOQOgByACICw3A5gHIAIgAysD0AE5A5AHIAIgKzcDiAcgAiAHQf8BcUU6AMsHIAJCBTcDgAcgAkHYB2oiByADIAJBgAdqEOgGIAIgJjcDiAsgAiAjNwOACyACICo3A/gKIAIgJDcD8AogAkGQC2oiCiAIQcAB/AoAACACICc3A+gMIAIgKDcD4AwgAiApNwPYDCACICU3A9AMIAJB8AxqIgsgAkHAAPwKAAAgAkHQC2oiDBDCGCAMIAdB2AD8CgAAIAJBsAhqIgwgAkHwCmoiD0HAAvwKAAAgAiADKQOAAjcDiAkgAiADKQP4ATcDgAkgAkHoAmoiByADQcACaigCADYCACADKQK4AiEjIANBgICAgHg2ArgCIAIgIzcD4AIgAkHUCmoQhTAgAkHcCmogBygCADYCACACIAIpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HMAmooAgA2AgAgAykCxAIhIyADQYCAgIB4NgLEAiACICM3A+ACIAJBoA1qEIUwIAJBqA1qIAcoAgA2AgAgAiACKQPgAjcDoA0gAikD8AohJCACKQP4CiEqIAIpA4ALISMgAikDiAshJiAIIApBwAH8CgAAIAIpA+gMIScgAikD4AwhKCACKQPYDCEpIAIpA9AMISUgAiALQcAA/AoAAAsgJEICUgRAIAZBIGogAkFAa0HAAfwKAAAgBkGAAmogAkHAAPwKAAAgBiAnNwP4ASAGICg3A/ABIAYgKTcD6AEgBiAlNwPgAQsgBiAmNwMYIAYgIzcDECAGICo3AwggBiAkNwMAIAJBsA1qJAAMAQsACyAFQeACaiICIAVB6ANqKQMANwMAIAVB6AJqIgYgBUHwA2opAwA3AwAgBSAFKQPgAzcD2AIgBSkD2AMiJEICUQRAIAQgBSkD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAIpAwA3AwAMAgsgBUE4aiAFQfgDakGgAvwKAAAgBUEoaiAFQeACaikDADcDACAFQTBqIAVB6AJqKQMANwMAIAUgJDcDGCAFIAUpA9gCNwMgIAVB2ANqIAMoArAEIAMoArQEKAIQEQAAIAUoAtgDIgJBCEcEQCAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIIAVBGGoQqiAMAgsgA0EBQQJBACADLQD5BEEBcRsgAy0A+AQbNgLIAyADLQDMAyECIAVB2ANqIgcgA0GAA2pB0AD8CgAAAn8gAkUEQCAHEO0nQYCAgIB4DAELIAVBuANqIANBlANqKAIANgIAIAVBqANqIANBoANqKAIANgIAIAVBmANqIANBrANqKAIANgIAIAVBiANqIANBuANqKAIANgIAIAUgAykCjAM3A7ADIAUgAykCmAM3A6ADIAUgAykCpAM3A5ADIAUgAykCsAM3A4ADIAUoAqAEIQYgBUH4AmogA0HEA2ooAgA2AgAgBSADKQK8AzcD8AIgBSkC3AMhJCAFKALYAwshAgJAIAMoAoAEIgdBgICAgHhHBEAgAykD+AMhIyAFIAc2AuADIAUgIzcD2AMgBUHkA2ogA0GEBGpBLPwKAAAgBUHAA2ogBUHYA2oQ6BEMAQsgBUGAgICAeDYCwAMLIAMpA5ABISMgA0GAgICAeDYCkAEgBCAjNwPoAiAEQfACaiADQZgBaigCADYCACADKQOIAiEjIAMpA5ACISUgBUHYA2oiByAFQRhqQcAC/AoAACAFQagGaiAFQdADaikCADcDACAFQaAGaiAFQcgDaikCADcDACAFIAUpAsADNwOYBiAEIAdB2AL8CgAAIAQgJDcD+AIgBCACNgL0AiAEICU3A+ACIAQgIzcD2AIgBCAFKQOwAzcCgAMgBEGIA2ogBUG4A2ooAgA2AgAgBCAFKQOgAzcCjAMgBEGUA2ogBUGoA2ooAgA2AgAgBCAFKQOQAzcCmAMgBEGgA2ogBUGYA2ooAgA2AgAgBCAFKQOAAzcCpAMgBEGsA2ogBUGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiAFQfgCaigCADYCACAEIAUpA/ACNwKwAyADKALkBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HkBGoQ2SELIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahCuIAsgA0GwBGoQvCogA0G4BGoQ1ykgAxD7GCADQdgDahCFMCADQeQDahCFMCADQbgCahCFMCADQcQCahCFMCADQewEahDDHCADQcAEakEEQQgQ4B4gA0HMBGoQnTwgA0HYBGoQnTwgA0HwAmoiBBCHGSAEQQhBiAEQ4B4MAgsgBUEQaiICIAVBLGooAgA2AgAgBUEIaiIHIAVBJGopAgA3AwAgBSAFKQIcNwMAIAQgBjYCCCAEIAUpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAIoAgA2AgALIAMoAuQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQeQEahDZIQsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqEK4gCyADQbAEahC8KiADQbgEahDXKSADEPsYIANB2ANqEIUwIANB5ANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB7ARqEMMcIANBwARqQQRBCBDgHiADQcwEahCdPCADQdgEahCdPCADQfACaiIEEIcZIARBCEGIARDgHiADQYADahDtJyADQfgDahDHKAsgBUGwBmokAAwCCyAJQdAcaiIDIAJBmAX8CgAAIwBB0AZrIgIkAAJAAkACQCADKALoA0UNACACQdgDaiADEMsBIAIoAtgDIgZBCEYNACAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAGNgIIDAELAkAgAygCWEGAgICAeEYNACACQdgDaiEIIwBBgAFrIgUkACADKAJYIQYgA0GAgICAeDYCWAJAAkAgBkGAgICAeEcEQCAFIANBEGpByAD8CgAAIAVB1ABqIANB5ABqKAIANgIAIAUgBjYCSCAFIAMpAlw3AkwCQAJAIAMoAqgBRQRAIAVB6ABqIQ8jAEFAaiIGJAAgBkEIakGAAhDoICAGQQA2AiggBkKAgICAEDcDICAGQSBqIQwCQAJAAkACQCAFKAI4IhoEQCAFKAI0IgogGkEEdGohGgNAIAooAgBFDQIgBiAKQQhqIiEoAgA2AjAgDCAGQTBqQQQQoTYgCigCAEUNAyAMIApBBGooAgAgISgCABChNiAKQRBqIgogGkcNAAsLIAYtABwhCiAGIAYpAwg3AzAgCkEDdiAKQQdxQQBHaiIKQQlPDQIgBkEQaiAGQTBqIhogChChNiAGQQA6ABwgBkIANwMIIAwgBigCFCAGKAIYEKE2IAZBADoAHCAGQgA3AwggBkEANgIYIAZBOGogDEEIaigCADYCACAGIAwpAgA3AzAgBkEANgIoIAZCgICAgBA3AyAgD0EEaiAaEOcVIA9BCDYCACAGQQhqEMouIAZBQGskAAwDC0Gsh84AQSVB1IfOABCfKQALQeSHzgBBIEGEiM4AEMskAAsgCkEIQeiOzgAQsDsACyAFQeAAaiIGIAVB9ABqKQIANwMAIAUgBSkCbDcDWCAFKAJoIgpBCEYNASAFKAJ8IQwgCCAFKQNYNwIMIAggDDYCHCAIIAo2AgggCEEBNgIAIAhBFGogBikDADcCAAwCCyAFQegAakEwQQBBAUEBEKAYIAUoAmwhBiAFKAJoQQFGDQMgBSgCcCIKQZiJzgBBMPwKAAAgCEEwNgIUIAggCjYCECAIIAY2AgwgCEEANgIIIAhBATYCAAwBCyAIIAUpA1g3AgQgCEEMaiAGKQMANwIAIAhBADoAGCAIIAUoAjg2AhQgCEEANgIACyAFEJ4sDAILIAhBADYCACAIQQI6ABgMAQsgBiAFKAJwQZyHzgAQ/S8ACyAFQYABaiQAAn8CQAJAIAIoAtgDQQFGBEAgAigC9AMhByACKALwAyELIAIoAuwDIQogAigC6AMhBiACKALkAyEIIAIoAuADIQUMAQsgAigC8AMiBUH/AXFBAkYEQEEAIQVBHSEKIAJB2ANqQR1BAEEBQQEQoBggAigC3AMhCCACKALYA0EBRg0LIAIoAuADIgZBFWpBjYTPACkAADcAACAGQRBqQYiEzwApAAA3AAAgBkEIakGAhM8AKQAANwAAIAZB+IPPACkAADcAAAwBCyACKALsAyEHIAIoAugDIQogAigC5AMhBiACKALgAyEIIAIoAtwDIQsgAiAFNgIsIAIgBzYCKCACIAo2AiQgAiAGNgIgIAIgCDYCHCACIAs2AhggAygCsAQEQCACQdgDaiIHIAZBAEEBQQEQoBggAigC3AMhBSACKALYA0EBRg0MIAJBJGohDCACQQA2ArwGIAIgAigC4AM2ArgGIAIgBTYCtAYgByADKAKwBCAIIAYgAkG0BmoiDyADKAK0BCgCDBEHACACKALYAyIFQQhHBEAgAigC7AMhByACKALoAyELIAIoAuQDIQogAigC4AMhBiACKALcAyEIIA8Q3jsgDCACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACQcgGaiACQbwGaigCADYCACACIAIpArQGNwPABiACQdgDaiACQcAGahDnFSAMIAIoAhwgAkEgaiIFKAIAIAIoAhgoAhARAQAgBSACQeADaikCADcDACACIAIpAtgDNwMYIAIoAighByACLQAsIQULIAJB4AJqIgogAkEgaikDADcDACACIAIpAxg3A9gCIANBiAVqQQAQ6R4gAygC5AQiCCADKALcBEYEQCADQdwEakHog88AEJsoCyADKALgBCAIQQN0akKBgICAgMAANwIAIAMgCEEBajYC5AQgAygCqAQhCCADKAKsBCELIAJB6ANqIAopAwA3AwAgAkILNwPYAyACIAIpA9gCNwPgAyACIAY2AtgEIAIgBToA9QMgAkEAOgD0AyACIAc2AvADIAJBGGogCCACQdgDaiALKAIMEQEAIAIoAiwhByACKAIoIQsgAikDGCEjIAItADQiBkEERw0BICNCIIinIQggAigCICEGIAIoAiQhCiAjpyEFCyAFQQhGDQIgBCAHNgIcIAQgCzYCGCAEIAo2AhQgBCAGNgIQIAQgCDYCDCAEIAU2AgggBEICNwMADAMLIAI1AjAhJCACKQMgISUgAyADKQOAAiALrXw3A4ACIAMgAykDiAIgB618NwOIAiADICUgAykD8AF8NwPwAQJAAkAgBkEBaw4CAwABCyADKQOwAVBFDQsgA0IBNwOwAUG4AQwBCyADIAMpA5ACICR8NwOQAiADKQPAAVBFBEAMAgsgA0IBNwPAAUHIAQsgA2ogIzcDAAsCQAJAIAMoAugDRQ0AIAJBGGogAxDLASACKAIYIgVBCEYNAAwBCwJAIAMoAvQCIgVFDQAgAkHgA2ohBgNAIAMgBUEBazYC9AIgAyADKALwAiIFQQFqIgcgAygC6AIiCEEAIAcgCE8bazYC8AIgAygC7AIgBUGIAWxqIgUpAwAiI0IMUQ0BIAIgIzcD2AMgBiAFQQhqQYAB/AoAACACQRhqIAMgAkHYA2oQpgogAigCGCIFQQhHDQIgAygC9AIiBQ0ACwsgAkHYA2ohBSMAQdANayIGJAAgAykDuAEhJSADKQOwASEoIAMpA5ACISkgAykDgAIhKiADKQOIAiEnIAMpA8gBISYgAygCwAEhCyADKAKABSIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCAGQQA2AvgFIAZBADYC8AUgBkEANgLoBSAGQgg3A5AFIAZCADcDgAUgBkIANwPwBCAGQgA3A+AEIAZCADcD0AQgBkIANwPABCAGQgA3A7AEIAZBiAZqQQBBLPwLACAGIAc2AuwGIAZBgICAgHg2AuAGIAZBgICAgHg2AtQGIAZBgICAgHg2AsgGIAZBgICAgHg2ArwGIAZCATcCtAYgBiADKQPgAjcDgAYgAygCjAUhCiAGIAMoApAFQQAgAygCiAUiCBs2ApALIAYgCjYCjAsgBiAINgKICyAGQQA2AoQLIAYgCEEARyIMNgKACyAGIAo2AvwKIAYgCDYC+AogBkEANgL0CiAGIAw2AvAKIAZB4AJqIAZB8ApqIggQrBUgBkGwBmpBAUEBEOAeIAZBuAZqIAZB6AJqKAIANgIAIAYgBikC4AI3A7AGIAggBkGwBGpBwAL8CgAAIAZB9AZqIANB3ARqELUWIAZBiA1qIQggBigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggBikC9AY3AgAgCEEIaiAGQfwGaigCADYCACAGKQPwCiEjIAYpA/gKISQgBkHgAmogBkGAC2pB0AH8CgAAIAZBgAJqIAZB0AxqQeAA/AoAACAGQUBrIAZB8AJqQcAB/AoAACAGIAZBoAJqQcAA/AoAACAmQgAgCxshJiADLQCWBQRAIAdBCGoQqiUhCkEAIQdBACEIIAMoAqACQQFGBEACQCADKAKkAiIIBEAgBkGwDWogA0GwAmogAygCqAIgAygCrAIgCCgCABEFAAwBCyAGQQA2ArANC0EBIQgLIAMoArQCQQFGBEACQCADKAK4AiIHBEAgBkHADWogA0HEAmogAygCvAIgAygCwAIgBygCABEFAAwBCyAGQQA2AsANC0EBIQcLIAZBtAdqIAZBuA1qKQIANwIAIAZByAdqIAZByA1qKQIANwMAIAYgCDYCqAcgBkIBNwOYByAGIAYpArANNwKsByAGIAc2ArwHIAYgBikCwA03A8AHIAYgAykDmAI3A6AHIAYgAykD2AE3A5AHIAYgAykD0AE3A4gHIAYgCkH/AXFFOgDTByAGQQA6ANIHIAYgCDoA0QcgBiAHOgDQByAGQgY3A4AHIAZB2AdqIgcgAyAGQYAHahDjBiAGICU3A4gLIAYgKDcDgAsgBiAkNwP4CiAGICM3A/AKIAZBkAtqIgggBkFAayIKQcAB/AoAACAGICY3A+gMIAYgKjcD4AwgBiAnNwPYDCAGICk3A9AMIAZB8AxqIgsgBkHAAPwKAAAgBkHQC2oiDBDCGCAMIAdB2AD8CgAAIAZBsAhqIgwgBkHwCmoiD0HAAvwKAAAgBiADKQPoATcDiAkgBiADKQPgATcDgAkgBkHoAmoiByADQdACaigCADYCACADKQLIAiEjIANBgICAgHg2AsgCIAYgIzcD4AIgBkHUCmoQhTAgBkHcCmogBygCADYCACAGIAYpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HcAmooAgA2AgAgAykC1AIhIyADQYCAgIB4NgLUAiAGICM3A+ACIAZBoA1qEIUwIAZBqA1qIAcoAgA2AgAgBiAGKQPgAjcDoA0gBikD8AohIyAGKQP4CiEkIAYpA4ALISggBikDiAshJSAKIAhBwAH8CgAAIAYpA+gMISYgBikD4AwhKiAGKQPYDCEnIAYpA9AMISkgBiALQcAA/AoAAAsgI0ICUgRAIAVBIGogBkFAa0HAAfwKAAAgBUGAAmogBkHAAPwKAAAgBSAmNwP4ASAFICo3A/ABIAUgJzcD6AEgBSApNwPgAQsgBSAlNwMYIAUgKDcDECAFICQ3AwggBSAjNwMAIAZB0A1qJAAMAQsACyACQeACaiIFIAJB6ANqKQMANwMAIAJB6AJqIgYgAkHwA2opAwA3AwAgAiACKQPgAzcD2AIgAikD2AMiI0ICUQRAIAQgAikD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAUpAwA3AwAMAgsgAkE4aiACQfgDakGgAvwKAAAgAkEoaiACQeACaikDADcDACACQTBqIAJB6AJqKQMANwMAIAIgIzcDGCACIAIpA9gCNwMgIAJB2ANqIAMoAqgEIAMoAqwEKAIQEQAAIAIoAtgDIgVBCEcEQCAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAFNgIIIAJBGGoQqiAMAgsgA0EBQQJBACADLQCVBUEBcRsgAy0AlAUbNgLAAyADLQDEAyEFIAJB2ANqIgcgA0H4AmpB0AD8CgAAAn8gBUUEQCAHEO0nQYCAgIB4DAELIAJBuANqIANBjANqKAIANgIAIAJBqANqIANBmANqKAIANgIAIAJBmANqIANBpANqKAIANgIAIAJBiANqIANBsANqKAIANgIAIAIgAykChAM3A7ADIAIgAykCkAM3A6ADIAIgAykCnAM3A5ADIAIgAykCqAM3A4ADIAIoAqAEIQYgAkH4AmogA0G8A2ooAgA2AgAgAiADKQK0AzcD8AIgAikC3AMhIyACKALYAwshBQJAIAMoAvgDIgdBgICAgHhHBEAgAykD8AMhJCACIAc2AuADIAIgJDcD2AMgAkHkA2ogA0H8A2pBLPwKAAAgAkHAA2ogAkHYA2oQ6BEMAQsgAkGAgICAeDYCwAMLIAMpA5gBISQgA0GAgICAeDYCmAEgBCAkNwPoAiAEQfACaiADQaABaigCADYCACADKQPwASEkIAMpA/gBISUgAkHYA2oiByACQRhqQcAC/AoAACACQagGaiACQdADaikCADcDACACQaAGaiACQcgDaikCADcDACACIAIpAsADNwOYBiAEIAdB2AL8CgAAIAQgIzcD+AIgBCAFNgL0AiAEICU3A+ACIAQgJDcD2AIgBCACKQOwAzcCgAMgBEGIA2ogAkG4A2ooAgA2AgAgBCACKQOgAzcCjAMgBEGUA2ogAkGoA2ooAgA2AgAgBCACKQOQAzcCmAMgBEGgA2ogAkGYA2ooAgA2AgAgBCACKQOAAzcCpAMgBEGsA2ogAkGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiACQfgCaigCADYCACAEIAIpA/ACNwKwAyADKAKABSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GABWoQ2SELIAMoAoQFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYQFahCuIAsgA0GoBGoQvCogA0GwBGoQ1ykgAxDXEyADQdADahCFMCADQdwDahCFMCADQbABahDSISADQYgFahDDHCADQdwEakEEQQgQ4B4gA0HoBGoQnTwgA0H0BGoQnTwgA0HoAmoiBBCHGSAEQQhBiAEQ4B4MAgsgAkEQaiIGIAJBLGooAgA2AgAgAkEIaiIHIAJBJGopAgA3AwAgAiACKQIcNwMAIAQgBTYCCCAEIAIpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAYoAgA2AgALIAMoAoAFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYAFahDZIQsgAygChAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBhAVqEK4gCyADQagEahC8KiADQbAEahDXKSADENcTIANB0ANqEIUwIANB3ANqEIUwIANBsAFqENIhIANBiAVqEMMcIANB3ARqQQRBCBDgHiADQegEahCdPCADQfQEahCdPCADQegCaiIEEIcZIARBCEGIARDgHiADQfgCahDtJyADQfADahDHKAsgA0G4BGoQ8SYgAkHQBmokAAwBCyAJQeghaiIDIAJBmAX8CgAAIwBBsAZrIgUkAAJAAkACQCADKALoA0UNACAFQdgDaiADEMoBIAUoAtgDIgJBCEYNACAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIDAELAkAgAygCWEGAgICAeEYNACAFQdgDaiADEI0HIAUoAtgDIgJBCEYNACAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIDAELAkACQCADKALoA0UNACAFQRhqIAMQygEgBSgCGCIGQQhGDQAMAQsCQCADKAL0AiIGRQ0AIAVB4ANqIQIDQCADIAZBAWs2AvQCIAMgAygC8AIiBkEBaiIHIAMoAugCIghBACAHIAhPG2s2AvACIAMoAuwCIAZBiAFsaiIGKQMAIiNCDFENASAFICM3A9gDIAIgBkEIakGAAfwKAAAgBUEYaiADIAVB2ANqEKYKIAUoAhgiBkEIRw0CIAMoAvQCIgYNAAsLIAVB2ANqIQgjAEHQDWsiAiQAIAMpA7gBISUgAykDsAEhKCADKQOQAiEpIAMpA4ACISogAykDiAIhJyADKQPIASEmIAMoAsABIQsgAygCgAUiBiAGKAIAIgdBAWo2AgACQCAHQQBOBEAgAkEANgL4BSACQQA2AvAFIAJBADYC6AUgAkIINwOQBSACQgA3A4AFIAJCADcD8AQgAkIANwPgBCACQgA3A9AEIAJCADcDwAQgAkIANwOwBCACQYgGakEAQSz8CwAgAiAGNgLsBiACQYCAgIB4NgLgBiACQYCAgIB4NgLUBiACQYCAgIB4NgLIBiACQYCAgIB4NgK8BiACQgE3ArQGIAIgAykD4AI3A4AGIAMoAowFIQogAiADKAKQBUEAIAMoAogFIgcbNgKQCyACIAo2AowLIAIgBzYCiAsgAkEANgKECyACIAdBAEciDDYCgAsgAiAKNgL8CiACIAc2AvgKIAJBADYC9AogAiAMNgLwCiACQeACaiACQfAKaiIHEKwVIAJBsAZqQQFBARDgHiACQbgGaiACQegCaigCADYCACACIAIpAuACNwOwBiAHIAJBsARqQcAC/AoAACACQfQGaiADQdwEahC1FiACQYgNaiEHIAIoAogNQYCAgIB4RwRAIAdBBEEIEOAeCyAHIAIpAvQGNwIAIAdBCGogAkH8BmooAgA2AgAgAikD8AohIyACKQP4CiEkIAJB4AJqIAJBgAtqQdAB/AoAACACQYACaiACQdAMakHgAPwKAAAgAkFAayACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJkIAIAsbISYgAy0AlgUEQCAGQQhqEKolIQpBACEHQQAhBiADKAKgAkEBRgRAAkAgAygCpAIiBgRAIAJBsA1qIANBsAJqIAMoAqgCIAMoAqwCIAYoAgARBQAMAQsgAkEANgKwDQtBASEGCyADKAK0AkEBRgRAAkAgAygCuAIiBwRAIAJBwA1qIANBxAJqIAMoArwCIAMoAsACIAcoAgARBQAMAQsgAkEANgLADQtBASEHCyACQbQHaiACQbgNaikCADcCACACQcgHaiACQcgNaikCADcDACACIAY2AqgHIAJCATcDmAcgAiACKQKwDTcCrAcgAiAHNgK8ByACIAIpAsANNwPAByACIAMpA5gCNwOgByACIAMpA9gBNwOQByACIAMpA9ABNwOIByACIApB/wFxRToA0wcgAkEAOgDSByACIAY6ANEHIAIgBzoA0AcgAkIHNwOAByACQdgHaiIGIAMgAkGAB2oQ4wYgAiAlNwOICyACICg3A4ALIAIgJDcD+AogAiAjNwPwCiACQZALaiIHIAJBQGsiCkHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAGQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD6AE3A4gJIAIgAykD4AE3A4AJIAJB6AJqIgYgA0HQAmooAgA2AgAgAykCyAIhIyADQYCAgIB4NgLIAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAYoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAGIANB3AJqKAIANgIAIAMpAtQCISMgA0GAgICAeDYC1AIgAiAjNwPgAiACQaANahCFMCACQagNaiAGKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCiAHQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAIQSBqIAJBQGtBwAH8CgAAIAhBgAJqIAJBwAD8CgAAIAggJjcD+AEgCCAqNwPwASAIICc3A+gBIAggKTcD4AELIAggJTcDGCAIICg3AxAgCCAkNwMIIAggIzcDACACQdANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAKoBCADKAKsBCgCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AlQVBAXEbIAMtAJQFGzYCwAMgAy0AxAMhAiAFQdgDaiIHIANB+AJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQYwDaigCADYCACAFQagDaiADQZgDaigCADYCACAFQZgDaiADQaQDaigCADYCACAFQYgDaiADQbADaigCADYCACAFIAMpAoQDNwOwAyAFIAMpApADNwOgAyAFIAMpApwDNwOQAyAFIAMpAqgDNwOAAyAFKAKgBCEGIAVB+AJqIANBvANqKAIANgIAIAUgAykCtAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKAL4AyIHQYCAgIB4RwRAIAMpA/ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANB/ANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOYASEkIANBgICAgHg2ApgBIAQgJDcD6AIgBEHwAmogA0GgAWooAgA2AgAgAykD8AEhJCADKQP4ASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCgAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBgAVqENkhCyADKAKEBSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GEBWoQriALIANBqARqELwqIANBsARqENcpIAMQ1xMgA0HQA2oQhTAgA0HcA2oQhTAgA0GwAWoQ0iEgA0GIBWoQwxwgA0HcBGpBBEEIEOAeIANB6ARqEJ08IANB9ARqEJ08IANB6AJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAKABSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GABWoQ2SELIAMoAoQFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYQFahCuIAsgA0GoBGoQvCogA0GwBGoQ1ykgAxDXEyADQdADahCFMCADQdwDahCFMCADQbABahDSISADQYgFahDDHCADQdwEakEEQQgQ4B4gA0HoBGoQnTwgA0H0BGoQnTwgA0HoAmoiBBCHGSAEQQhBiAEQ4B4gA0H4AmoQ7ScgA0HwA2oQxygLIANBuARqEPEmIAVBsAZqJAALIAlBgCdqJAAMAQsgDUHAA2oiAiAOQbAF/AoAACANQYgJaiEJIwBBsAZrIgMkAAJAAkACQCACKAKABEUNACADQdgDaiACEMwBIAMoAtgDIgRBCEYNACAJIAMpAtwDNwIMIAlBHGogA0HsA2ooAgA2AgAgCUEUaiADQeQDaikCADcCACAJQgI3AwAgCSAENgIIDAELAkAgAigCsAFBgICAgHhGDQAgA0HYA2ogAhCKByADKALYAyIEQQhGDQAgCSADKQLcAzcCDCAJQRxqIANB7ANqKAIANgIAIAlBFGogA0HkA2opAgA3AgAgCUICNwMAIAkgBDYCCAwBCwJAAkAgAigCgARFDQAgA0EYaiACEMwBIAMoAhgiBUEIRg0ADAELAkAgAigCjAMiBUUNACADQeADaiEEA0AgAiAFQQFrNgKMAyACIAIoAogDIgZBAWoiBSACKAKAAyIHQQAgBSAHTxtrNgKIAyACKAKEAyAGQYgBbGoiBikDACIjQgxRDQEgAyAjNwPYAyAEIAZBCGpBgAH8CgAAIANBGGogAiADQdgDahClCiADKAIYIgVBCEcNAiACKAKMAyIFDQALCyADQdgDaiEHIwBB0A1rIgQkACACKQMIISUgAikDACEoIAIpA2AhKSACKQNQISogAikDWCEnIAIpAxghJiACKAIQIQogAigCmAUiBiAGKAIAIgVBAWo2AgACQCAFQQBOBEAgBEEANgL4BSAEQQA2AvAFIARBADYC6AUgBEIINwOQBSAEQgA3A4AFIARCADcD8AQgBEIANwPgBCAEQgA3A9AEIARCADcDwAQgBEIANwOwBCAEQYgGakEAQSz8CwAgBCAGNgLsBiAEQYCAgIB4NgLgBiAEQYCAgIB4NgLUBiAEQYCAgIB4NgLIBiAEQYCAgIB4NgK8BiAEQgE3ArQGIAQgAikD+AI3A4AGIAIoAqQFIQggBCACKAKoBUEAIAIoAqAFIgUbNgKQCyAEIAg2AowLIAQgBTYCiAsgBEEANgKECyAEIAVBAEciCzYCgAsgBCAINgL8CiAEIAU2AvgKIARBADYC9AogBCALNgLwCiAEQeACaiAEQfAKaiIFEKwVIARBsAZqQQFBARDgHiAEQbgGaiAEQegCaigCADYCACAEIAQpAuACNwOwBiAFIARBsARqQcAC/AoAACAEQfQGaiACQfQEahC1FiAEQYgNaiEFIAQoAogNQYCAgIB4RwRAIAVBBEEIEOAeCyAFIAQpAvQGNwIAIAVBCGogBEH8BmooAgA2AgAgBCkD8AohIyAEKQP4CiEkIARB4AJqIARBgAtqQdAB/AoAACAEQYACaiAEQdAMakHgAPwKAAAgBEFAayAEQfACakHAAfwKAAAgBCAEQaACakHAAPwKAAAgJkIAIAobISYgAi0ArgUEQCAGQQhqEKolIQhBACEGQQAhBSACKAJwQQFGBEACQCACKAJ0IgUEQCAEQbANaiACQYABaiACKAJ4IAIoAnwgBSgCABEFAAwBCyAEQQA2ArANC0EBIQULIAIoAoQBQQFGBEACQCACKAKIASIGBEAgBEHADWogAkGUAWogAigCjAEgAigCkAEgBigCABEFAAwBCyAEQQA2AsANC0EBIQYLIARBtAdqIARBuA1qKQIANwIAIARByAdqIARByA1qKQIANwMAIAQgBTYCqAcgBEIBNwOYByAEIAQpArANNwKsByAEIAY2ArwHIAQgBCkCwA03A8AHIAQgAikDaDcDoAcgBCACKQMoNwOQByAEIAIpAyA3A4gHIAQgCEH/AXFFOgDTByAEQQA6ANIHIAQgBToA0QcgBCAGOgDQByAEQgY3A4AHIARB2AdqIgYgAiAEQYAHahDkBiAEICU3A4gLIAQgKDcDgAsgBCAkNwP4CiAEICM3A/AKIARBkAtqIgUgBEFAayIIQcAB/AoAACAEICY3A+gMIAQgKjcD4AwgBCAnNwPYDCAEICk3A9AMIARB8AxqIgogBEHAAPwKAAAgBEHQC2oiCxDCGCALIAZB2AD8CgAAIARBsAhqIgsgBEHwCmoiDEHAAvwKAAAgBCACKQM4NwOICSAEIAIpAzA3A4AJIARB6AJqIgYgAkGgAWooAgA2AgAgAikCmAEhIyACQYCAgIB4NgKYASAEICM3A+ACIARB1ApqEIUwIARB3ApqIAYoAgA2AgAgBCAEKQPgAjcC1AogDCALQcAC/AoAACAGIAJBrAFqKAIANgIAIAIpAqQBISMgAkGAgICAeDYCpAEgBCAjNwPgAiAEQaANahCFMCAEQagNaiAGKAIANgIAIAQgBCkD4AI3A6ANIAQpA/AKISMgBCkD+AohJCAEKQOACyEoIAQpA4gLISUgCCAFQcAB/AoAACAEKQPoDCEmIAQpA+AMISogBCkD2AwhJyAEKQPQDCEpIAQgCkHAAPwKAAALICNCAlIEQCAHQSBqIARBQGtBwAH8CgAAIAdBgAJqIARBwAD8CgAAIAcgJjcD+AEgByAqNwPwASAHICc3A+gBIAcgKTcD4AELIAcgJTcDGCAHICg3AxAgByAkNwMIIAcgIzcDACAEQdANaiQADAELAAsgA0HgAmoiBCADQegDaikDADcDACADQegCaiIFIANB8ANqKQMANwMAIAMgAykD4AM3A9gCIAMpA9gDIiNCAlEEQCAJIAMpA9gCNwMIIAlCAjcDACAJQRhqIAUpAwA3AwAgCUEQaiAEKQMANwMADAILIANBOGogA0H4A2pBoAL8CgAAIANBKGogA0HgAmopAwA3AwAgA0EwaiADQegCaikDADcDACADICM3AxggAyADKQPYAjcDICADQdgDaiACKALABCACKALEBCgCEBEAACADKALYAyIEQQhHBEAgCSADKQLcAzcCDCAJQRxqIANB7ANqKAIANgIAIAlBFGogA0HkA2opAgA3AgAgCUICNwMAIAkgBDYCCCADQRhqEKogDAILIAJBAUECQQAgAi0ArQVBAXEbIAItAKwFGzYC2AMgAi0A3AMhBCADQdgDaiIGIAJBkANqQdAA/AoAAAJ/IARFBEAgBhDtJ0GAgICAeAwBCyADQbgDaiACQaQDaigCADYCACADQagDaiACQbADaigCADYCACADQZgDaiACQbwDaigCADYCACADQYgDaiACQcgDaigCADYCACADIAIpApwDNwOwAyADIAIpAqgDNwOgAyADIAIpArQDNwOQAyADIAIpAsADNwOAAyADKAKgBCEFIANB+AJqIAJB1ANqKAIANgIAIAMgAikCzAM3A/ACIAMpAtwDISMgAygC2AMLIQQCQCACKAKQBCIGQYCAgIB4RwRAIAIpA4gEISQgAyAGNgLgAyADICQ3A9gDIANB5ANqIAJBlARqQSz8CgAAIANBwANqIANB2ANqEOgRDAELIANBgICAgHg2AsADCyACKQPAAiEkIAJBgICAgHg2AsACIAkgJDcD6AIgCUHwAmogAkHIAmooAgA2AgAgAikDQCEkIAIpA0ghJSADQdgDaiIGIANBGGpBwAL8CgAAIANBqAZqIANB0ANqKQIANwMAIANBoAZqIANByANqKQIANwMAIAMgAykCwAM3A5gGIAkgBkHYAvwKAAAgCSAjNwP4AiAJIAQ2AvQCIAkgJTcD4AIgCSAkNwPYAiAJIAMpA7ADNwKAAyAJQYgDaiADQbgDaigCADYCACAJIAMpA6ADNwKMAyAJQZQDaiADQagDaigCADYCACAJIAMpA5ADNwKYAyAJQaADaiADQZgDaigCADYCACAJIAMpA4ADNwKkAyAJQawDaiADQYgDaigCADYCACAJIAU2ArwDIAlBuANqIANB+AJqKAIANgIAIAkgAykD8AI3ArADIAIoApgFIgQgBCgCACIEQQFrNgIAIARBAUYEQCACQZgFahDZIQsgAigCnAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBnAVqEK4gCyACQcAEahC8KiACQcgEahDXKSACQbABahCzEiACQegDahCFMCACQfQDahCFMCACENIhIAJBoAVqEMMcIAJB9ARqQQRBCBDgHiACQYAFahCdPCACQYwFahCdPCACQYADaiIEEIcZIARBCEGIARDgHgwCCyADQRBqIgQgA0EsaigCADYCACADQQhqIgYgA0EkaikCADcDACADIAMpAhw3AwAgCSAFNgIIIAkgAykDADcCDCAJQgI3AwAgCUEUaiAGKQMANwIAIAlBHGogBCgCADYCAAsgAigCmAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBmAVqENkhCyACKAKcBSIEIAQoAgAiBEEBazYCACAEQQFGBEAgAkGcBWoQriALIAJBwARqELwqIAJByARqENcpIAJBsAFqELMSIAJB6ANqEIUwIAJB9ANqEIUwIAIQ0iEgAkGgBWoQwxwgAkH0BGpBBEEIEOAeIAJBgAVqEJ08IAJBjAVqEJ08IAJBgANqIgQQhxkgBEEIQYgBEOAeIAJBkANqEO0nIAJBiARqEMcoCyACQdAEahDxJiADQbAGaiQACyANQfgIaiIEIA1BmAlqKQMANwMAIA1BgAlqIgIgDUGgCWopAwA3AwAgDSANKQOQCTcD8AgCQCANKQOICSIjQgJRBEAgFSANKQPwCDcDCCAVQgI3AwAgFUEYaiACKQMANwMAIBVBEGogBCkDADcDACAOKAKwBSIEIAQoAgAiBEEBazYCACAEQQFHDQEgDkGwBWoQiBwMAQsgDUEIaiANQagJakGgA/wKAAAgDUGwA2ogDUH4CGopAwA3AwAgDUG4A2ogDUGACWopAwA3AwAgDSANKQPwCDcDqAMgDigCsAUiDkEAIA4oAgAiBCAEQQFGIgQbNgIAIARFBEAgDSAONgKMCSANQQE2AogJIA4gDigCACIAQQFrNgIAIABBAUYEQCANQYwJahCIHAtB2OnPABCyOwALIA1BnAlqIA5BGGooAgA2AgAgDUGUCWogDkEQaikCADcCACANIA4pAgg3AowJIA1BjAlqIQQCQCAOQX9GDQAgDiAOKAIEIgJBAWs2AgQgAkEBRw0AIA5BHEEEEPg6CyANQdgMaiAEQRBqKAIANgIAIA1B0AxqIARBCGopAgA3AwAgDSAEKQIANwPIDCAVQcgDaiANQdQMaikCADcCACAVIA0pAswMNwLAAyAVIA0pA6gDNwMIIBVBEGogDUGwA2opAwA3AwAgFUEYaiANQbgDaikDADcDACAVQSBqIA1BCGpBoAP8CgAAIBUgIzcDAAsgDUHgDGokAAwDCyAIIAIoAuADQcD1zgAQ/S8ACyAFIAIoAuADQdiDzwAQ/S8ACyACQQA2AugDIAJBATYC3AMgAkG4hM8ANgLYAyACQgQ3AuADIAJB2ANqQcCEzwAQ7ywACyAYKQMIIiNCAlEEQCAeKAIEIg4oAgBBCEcEQCAOEPAbCyAOIBkpAwA3AwAgDkEQaiAZQRBqKQMANwMAIA5BCGogGUEIaikDADcDAEEBISIMAgsgACAjNwMAIABBCGogGSkDADcDACAAQRBqIBlBCGopAwA3AwAgAEEYaiAZQRBqKQMANwMAIABBIGogIEGwA/wKAAAgAEHQA2ohACATIB9HDQALCyAbIAA2AgggGyAQNgIEIBsgIjYCACAYQZAJaiQAIBYoAhAhBiMAQRBrIgQkACARQQA2AgggESgCDCEOIBEoAgQhACARQQg2AgAgBEKAgICAgAE3AgggBEEIakEIQbgFEOAeIBFBCDYCDCARQQg2AgQgDiAAa0G4BW4hEyAAIA5HBEADQCAAELsKIABBuAVqIQAgE0EBayITDQALCyASQRxqIQ4gBEEQaiQAIBxBuAVsIgRB0ANuIQIgECEAAkAgHEUNACAEIAJB0ANsIgNGDQAgBEHPA00EQEEIIQAgBEUNASAQIARBCBD4OgwBCyAQIARBCCADEJc1IgANAEEIIAMQoz0ACyAOIAA2AgQgDiACNgIAIA4gBiAQa0HQA242AggjAEEQayIQJAAgESgCDCIEIBEoAgQiE2tBuAVuIQAgBCATRwRAA0AgExC7CiATQbgFaiETIABBAWsiAA0ACwsgECARKAIANgIMIBAgESgCCDYCCCAQQQhqQQhBuAUQ4B4gEEEQaiQAIBZBIGokAAJAIBIoAgBBCEcEQCAUIBIpAwA3AwAgFEEQaiASQRBqKQMANwMAIBRBCGogEkEIaikDADcDACAOKAIIIgQEQCAOKAIEIQIDQCACIB1B0ANsaiIAKALIAyIUBEAgACgCxAMhEANAIBBBDGogEEEEaigCACAQQQhqKAIAIBAoAgAoAhARAQAgEEEQaiEQIBRBAWsiFA0ACwsgAEHAA2pBBEEQEOAeIAAQ8BIgACgC6AJBgICAgHhHBEAgAEHoAmpBBEEgEOAeCyAAKAL0AkGAgICAeEcEQCAAQfQCahDeOyAAQYADaiIQENcrIBAQ6DsgAEGMA2oiEBDXKyAQEOg7IABBmANqEIUwIABBpANqEIUwIABBsANqEIUwCyAAKALAAkGAgICAeEcEQCAAQcACakEIQRgQ4B4gAEHMAmoQhTALIB1BAWoiHSAERw0ACwsgDkEIQdADEOAeDAELIBQgEikCHDcCBCAUQQg2AgAgFEEMaiASQSRqKAIANgIACyASQUBrJAAgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD4IwsgF0EQaiQAC2UBAX8CQCAAKAIAIgAoAghBAkcEQCAAQRBqEN47DAELIABBFGoQ3jsgAEEwaiIBEKInIAFBBEEEEOAeCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEE8QQQQ+DoLC2YBAX8gA0EBaiEDQQggAWshBEEAIQEDQCADBEAgA0EBayEDIAFBASAALwEAIgEgAUH//wNGG8EgBHRBAnRB8I7RAGooAgAgAigCAGxqIQEgAkEEaiECIABBAmohAAwBCwsgAUEIdguFAQICfwJ+IwBBIGsiASQAIAFBADYCHCABQoCAgIDAADcCFCABQQhqIAFBFGoiAkH0qPsAEJghIAEpAwghAyABQQA2AhwgAUKAgICAIDcCFCABIAJB9Kj7ABCWISABKQMAIQQgAEEAOwEUIABBADYCECAAIAQ3AgggACADNwIAIAFBIGokAAt2AQF/IwBBEGsiASQAIAFBBGpBAEGMgv8AEM4YIABCADcCMCAAQQA2AiQgAEIENwIcIABCADcCFCAAQoCAgIDAADcCDCAAQTdqQQA2AAAgAEIENwIoIABBCGogAUEMaigCADYCACAAIAEpAgQ3AgAgAUEQaiQAC7kDAQt/IwBBIGsiBiQAIAEoAhwhAyMAQSBrIgIkACAGQQhqIgggASgCECIEIAEoAhRJBH8gASAEQQFqNgIQIAEoAgghByACQQxqIAEoAgAgBEEDdGoiBSgCACAFKAIEIgUoAghBAWtBeHFqQQhqIAUgASgCGBDbASACKAIUIQEgAigCECEFAkAgAigCDCIMQZOAgIB4RwRAIAIoAhwhBCACKAIYIQcgAygCAEGTgICAeEcEQCADEIgRCyADQRBqIQkgA0EMaiEKIANBCGohCyADIAU2AgQgAyAMNgIAQQAhAwwBCyAHIARBAnRqKAIAIgcoAkAhAyACQQRqIQkgAkEIaiEKIAJBDGohCyABIQQgBygCRCEBIAUhBwsgCyABNgIAIAogBzYCACAJIAQ2AgAgCCADNgIEIAggAigCDDYCCCAIIAIoAgg2AgwgCCACKAIENgIQQQEFQQALNgIAIAJBIGokAAJAAkAgBigCCEUNACAGKAIMIgFFDQAgBigCFCEFIAYoAhAhBCAAIAYoAhg2AgwgACAFNgIIIAAgBDYCBCAAIAE2AgAMAQsgAEEANgIACyAGQSBqJAALYQECfyAAIAIgAWsiA0EAIAIgA08bEO4tIAAoAgghAyAAIAEgAkkEfyACIANqIAFrIAAoAgQgA0ECdGohAANAIAAgATYCACAAQQRqIQAgAiABQQFqIgFHDQALBSADCzYCCAtkAQJ/IwBBEGsiAiQAIAAgACgCBAR/IAJBCGogABDBNCACKAIMIgEEQCACKAIIQf8BIAH8CwALIAAoAgQiASABQQFqQQN2QQdsIAFBCEkbBSABCzYCCCAAQQA2AgwgAkEQaiQAC9kEAQh/IwBBIGsiBCQAIARBAjYCBCAEQZjLhQE2AgAgBEIBNwIMIARBxwI2AhwgBEH4yYUBNgIYIAQgBEEYajYCCEEBIQkCQCABKAIAIAEoAgQgBBDLCg0AIwBBQGoiAiQAAkACQCAAKAIgIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIAkADQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACADEKYZIAIgAikDEDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0GwAUkNASAHQdACTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAVBFGs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACADEKYZIAIgAikDCDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkFAayQAIAYNACABKAIAQajLhQFBASABKAIEKAIMEQYAIQkLIARBIGokACAJC88EAQh/IwBBIGsiBCQAIARBAjYCBCAEQZjLhQE2AgAgBEIBNwIMIARBxwI2AhwgBEH0yoUBNgIYIAQgBEEYajYCCEEBIQkCQCABKAIAIAEoAgQgBBDLCg0AIwBBQGoiAiQAAkACQCAAKAIgIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIAkADQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACADEKcZIAIoAhAgAigCFCABEMUjDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBsAFJDQEgB0HQAk8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAFQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQkSVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgAxCnGSACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBqMuFAUEBIAEoAgQoAgwRBgAhCQsgBEEgaiQAIAkLbgEBf0EGIQUCQCAAIAEtABBBAUYEfyADIARrIQECQCADIARGDQAgASADTwRAIARFDQEMAwsgASACaiwAAEG/f0wNAgsgACABNgIIIAAgAjYCBEEABSAFCzoAAA8LIAIgA0EAIAFBsLyGARCjNgALcgEDfyMAQRBrIgMkACADQQRqIAJBAEEBQQEQoBggAygCCCEEIAMoAgRBAUcEQCADKAIMIQUgAgRAIAUgASAC/AoAAAsgACACNgIIIAAgBTYCBCAAIAQ2AgAgA0EQaiQADwsgBCADKAIMQYDjhgEQ/S8AC3IBAn8jAEEQayIBJAAgAUEEaiADQQBBAUEBEKAYIAEoAgghBCABKAIEQQFHBEAgASgCDCEFIAMEQCAFIAIgA/wKAAALIAAgAzYCCCAAIAU2AgQgACAENgIAIAFBEGokAA8LIAQgASgCDEHAhYgBEP0vAAu5BwMIfwJ9A34gASgCCCIDQYCAgAFxIQIgACoCACEKIANBgICAgAFxRQRAIAqLIgtDyhsOWmAgCkMAAAAAXCALQxe30ThdcXJFBEAgASAKIAJBAEdBARCQCQ8LIAJBAEchBkEAIQIjAEGgAWsiACQAIAq8IQMCf0EDIAqLQwAAgH9bDQAaQQIgA0GAgID8B3EiBEGAgID8B0YNABogA0H///8DcSIFQYCAgARyIANBAXRB/v//B3EgA0EXdkH/AXEiAhsiB60iDEIBgyEOIARFBEBBBCAFRQ0BGiACQZYBayECQgEhDSAOUAwBC0KAgIAQIAxCAYYgB0GAgIAERiIEGyEMQgJCASAEGyENQeh+Qel+IAQbIAJqIQIgDlALIQQgACACOwGIASAAIA03A4ABIABCATcDeCAAIAw3A3AgACAEOgCKAQJAAkACQAJAAkACQCAEQf8BcUEBTQRAIABB4ABqIABB8ABqIABBB2oQ/wIgACgCYEUNASAAQZgBaiAAQegAaigCADYCACAAIAApAmA3A5ABDAILIARB/wFxIgVBAkYNAkEBIQRB7uuJAUHv64kBIANBAEgiAhtB7uuJAUEBIAIbIAYbIQIgA0EfdiAGciEGIAVBBEcEQCAAQQM2AiAgAEHz64kBNgIcIABBAjsBGAwGCyAAQQM2AiAgAEECOwEYIABB9+uJATYCHAwFCyAAQZABaiAAQfAAaiAAQQdqEJQBCyAAKAKUASICRQ0BIAAoApABIgQtAABBME0NAkHu64kBQQEgA0EASCIFGyEHQe7riQFB7+uJASAFGyADQR92IQkgAC4BmAEhBSAAIAQ2AhwgAEECOwEYIABBATYCIAJ/IAJBAUYEQCAAQSRqIQNBAwwBCyAAQTxqIQMgAEECOwEwIABBxOuJATYCKCAAQQI7ASQgACACQQFrNgI4IABBATYCLCAAIARBAWo2AjRBBQshBCAHIAYbIQIgBiAJciEGIANBATsBDCADQQI7AQAgA0EBIAVrIAVBAWsgBUEATCIFGzsBDiADQQJBASAFGzYCCCADQerriQFB6OuJASAFGzYCBAwDCyAAQQM2AiAgAEHw64kBNgIcIABBAjsBGEEBIQJBACEGQQEhBAwCC0HA6IkBQSFByOuJARCfKQALQeDqiQFBH0HY64kBEJ8pAAsgACAENgJsIAAgBjYCZCAAIAI2AmAgACAAQRhqNgJoIAEgAEHgAGoQtQogAEGgAWokAA8LIAEgCiACQQBHIAEvAQ4Q6QcL3QcDBn8FfgJ8IAEoAggiBEGAgIABcSECIAArAwAhDSAEQYCAgIABcUUEQCANmSIORACA4Dd5w0FDZiANRAAAAAAAAAAAYiAORC1DHOviNho/Y3FyRQRAIAEgDSACQQBHQQEQ/QgPCyACQQBHIQRBACECIwBBoAFrIgAkACANvSEIAn9BAyANmUQAAAAAAADwf2ENABpBAiAIQoCAgICAgID4/wCDIglCgICAgICAgPj/AFENABogCEL/////////B4MiDEKAgICAgICACIQgCEIBhkL+////////D4MgCEI0iKdB/w9xIgIbIgpCAYMhCyAJUARAQQQgDFANARogAkGzCGshAkIBIQkgC1AMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIDGyEKQgJCASADGyEJQct3Qcx3IAMbIAJqIQIgC1ALIQMgACACOwGIASAAIAk3A4ABIABCATcDeCAAIAo3A3AgACADOgCKAQJAAkACQAJAAkACQCADQf8BcSICQQFNBEAgAEHgAGogAEHwAGogAEEHahD/AiAAKAJgRQ0BIABBmAFqIABB6ABqKAIANgIAIAAgACkCYDcDkAEMAgsgAkECRg0CQQEhAkHu64kBQe/riQEgCEIAUyIFG0Hu64kBQQEgBRsgBBshBSAIQj+IpyAEciEGIANB/wFxQQRHBEAgAEEDNgIgIABB8+uJATYCHCAAQQI7ARgMBgsgAEEDNgIgIABBAjsBGCAAQffriQE2AhwMBQsgAEGQAWogAEHwAGogAEEHahCUAQsgACgClAEiAkUNASAAKAKQASIHLQAAQTBNDQJB7uuJAUEBIAhCAFMiBRshBiAALgGYASEDIAAgBzYCHCAAQQI7ARggAEEBNgIgQe7riQFB7+uJASAFGyAGIAQbIQUgCEI/iKcgBHIhBgJ/IAJBAUYEQEEDIQIgAEEkagwBCyAAQQI7ATAgAEHE64kBNgIoIABBAjsBJCAAIAJBAWs2AjggAEEBNgIsIAAgB0EBajYCNEEFIQIgAEE8agsiBEEBOwEMIARBAjsBACAEQQEgA2sgA0EBayADQQBMIgMbOwEOIARBAkEBIAMbNgIIIARB6uuJAUHo64kBIAMbNgIEDAMLIABBAzYCICAAQfDriQE2AhwgAEECOwEYQQEhBUEBIQIMAgtBwOiJAUEhQcjriQEQnykAC0Hg6okBQR9B2OuJARCfKQALIAAgAjYCbCAAIAY2AmQgACAFNgJgIAAgAEEYajYCaCABIABB4ABqELUKIABBoAFqJAAPCyABIA0gAkEARyABLwEOEOcHC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEOk7IAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC3MBAX8gABDTJCAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDfHwsCQCAAKAIARQ0AIAAoAgQiAUGEAUkNACABEPIfCwJAIAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDpJwsLZAEBf0HIAEEEEK02IgQEQCAEIAJByAD8CgAAIAAgAUHQAPwKAAAgACAENgJQIABB5ABqIANBEGooAgA2AgAgAEHcAGogA0EIaikCADcCACAAIAMpAgA3AlQPC0EEQcgAEKM9AAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3xogASAEEOgYIAAgASADEModIAJBQGskAAvlAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQcjAEEgayIBJAAgAUEUaiADQTBqIgkiAigCBCACKAIAa0ECdkEAQQJBAhCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgBDYCCCACKAIEIgggAigCACIEa0ECdiIGIAFBCGoiAigCACACKAIIIgVrSwRAIAIgBSAGQQJBAhDQKAsgAigCCCEFIAIgBCAIRwR/IAUgBmogAigCBCAFQQF0aiECA0AgAiAEKAIAOwEAIARBBGohBCACQQJqIQIgBkEBayIGDQALBSAFCzYCCCAHQQhqIAsoAgA2AgAgByABKQIINwIAIAFBIGokACAJIAcQ6RggACAJIAoQzR0gA0FAayQAC8MCAQp/IwBBQGoiAiQAIAJBDGoiCiABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGohBSMAQSBrIgEkACABQRRqIAJBMGoiCCIDKAIEIAMoAgBrQQJ2QQBBAUEBEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASAENgIIIAFBCGoiBiADKAIEIgcgAygCACIDa0ECdiIJEIEuIAYoAgghBCADIAdHBEAgBigCBCEHA0AgBCAHaiADKAIAOgAAIANBBGohAyAEQQFqIQQgCUEBayIJDQALCyAGIAQ2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCCAFEO4YIAAgCCAKENgdIAJBQGskAAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3xogASAEEOgYIAAgASADEL8dIAJBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjC8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0EEdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBBHYiBxDuLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBAnRqIQIDQCACIAQoAgA2AgAgBEEQaiEEIAJBBGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDoGCAAIAkgChC/HSADQUBrJAALzAIBCn8jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBAnZBAEEIQQgQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQJ2IgcQ7C0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQN0aiECA0AgAiAENAIANwMAIARBBGohBCACQQhqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQvRggACAJIAoQxh0gA0FAayQAC9oCAgp/AX4jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBA3ZBAEEQQRAQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQN2IgcQ6y0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQR0aiECA0AgAiAEKQMAIgw3AwAgAiAMQj+HNwMIIARBCGohBCACQRBqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ7BggACAJIAoQyx0gA0FAayQAC9kDAgx/A34jAEFAaiIDJAAgA0EMaiILIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEKIwBBIGsiAiQAIAJBFGogA0EwaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAIoAhghASACKAIUQQFGBEAgASACKAIcQcTSzAAQ/S8ACyACQRBqIgxBADYCACACIAIoAhw2AgwgAiABNgIIIwBBEGsiByQAIAJBCGoiASAFKAIEIAUoAgBrQQN2EO8tIAcgASkCBEIgiTcCCCAHIAFBCGo2AgQjAEEgayIGJAAgB0EEaiIEKAIEIQggBCgCACAFKAIAIgkgBSgCBCIBRwRAIAQoAgggCEEFdGohBCAIIAEgCWtBA3YiAWohCANAIAYgCSkDACIOIA5CP4cQsi4gBikDACEPIAYpAwghECAGKQMQIQ4gBEEYaiAGKQMYNwMAIARBEGogDjcDACAEIBA3AwggBCAPNwMAIAlBCGohCSAEQSBqIQQgAUEBayIBDQALCyAINgIAIAZBIGokACAHQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgBSAKEO0YIAAgBSALEM4dIANBQGskAAvDAgEKfyMAQUBqIgIkACACQQxqIgogARCSNhDuJSACIAFBDGoQjy8gAiACKQMANwIwIAIgAkE/ajYCOCACQSRqIQUjAEEgayIBJAAgAUEUaiACQTBqIggiAygCBCADKAIAa0ECdkEAQQFBARCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgBDYCCCABQQhqIgYgAygCBCIHIAMoAgAiA2tBAnYiCRDlLSAGKAIIIQQgAyAHRwRAIAYoAgQhBwNAIAQgB2ogAygCADoAACADQQRqIQMgBEEBaiEEIAlBAWsiCQ0ACwsgBiAENgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAggBRDuGCAAIAggChDBHSACQUBrJAALYgEDfyMAQUBqIgIkACACQQxqIgMgARCSNhDuJSACIAFBDGoQkC8gAiACKQMANwIwIAIgAkE/ajYCOCACQSRqIgQgAkEwaiIBEN4aIAEgBBC9GCAAIAEgAxDWHSACQUBrJAAL0gMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBAnYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0ECdiIBaiEIA0AgBiAJKAIAEMktIAYpAwAhDiAGKQMIIQ8gBikDECEQIARBGGogBikDGDcDACAEQRBqIBA3AwAgBCAPNwMIIAQgDjcDACAJQQRqIQkgBEEgaiEEIAFBAWsiAQ0ACwsgCDYCACAGQSBqJAAgB0EQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAUgChDtGCAAIAUgCxDOHSADQUBrJAALzAIBCn8jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQN2IgcQ7i0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQJ0aiECA0AgAiAEKQMAPgIAIARBCGohBCACQQRqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ6BggACAJIAoQvx0gA0FAayQAC8wCAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCMLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSIEKAIEIAQoAgBrQQR2QQBBCEEIEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASACNgIIIAFBCGoiAiAEKAIEIgYgBCgCACIEa0EEdiIHEOwtIAIoAgghCCACIAQgBkcEfyAHIAhqIAIoAgQgCEEDdGohAgNAIAIgBCkDADcDACAEQRBqIQQgAkEIaiECIAdBAWsiBw0ACwUgCAs2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCSAFEL0YIAAgCSAKENYdIANBQGskAAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCQLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3hogASAEEL0YIAAgASADEMYdIAJBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0ECdkEAQQJBAhCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBAnYiBxDtLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBAXRqIQIDQCACIAQoAgA7AQAgBEEEaiEEIAJBAmohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDpGCAAIAkgChDaHSADQUBrJAAL2gICCn8BfiMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0ECdkEAQRBBEBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBAnYiBxDrLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBBHRqIQIDQCACIAQ0AgAiDDcDACACIAxCP4c3AwggBEEEaiEEIAJBEGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDsGCAAIAkgChDLHSADQUBrJAAL2QMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBAnYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0ECdiIBaiEIA0AgBiAJNAIAIg4gDkI/hxCyLiAGKQMAIQ8gBikDCCEQIAYpAxAhDiAEQRhqIAYpAxg3AwAgBEEQaiAONwMAIAQgEDcDCCAEIA83AwAgCUEEaiEJIARBIGohBCABQQFrIgENAAsLIAg2AgAgBkEgaiQAIAdBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACAFIAoQ7RggACAFIAsQzh0gA0FAayQAC8wCAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCLLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSIEKAIEIAQoAgBrQQV2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASACNgIIIAFBCGoiAiAEKAIEIgYgBCgCACIEa0EFdiIHEO4tIAIoAgghCCACIAQgBkcEfyAHIAhqIAIoAgQgCEECdGohAgNAIAIgBCgCADYCACAEQSBqIQQgAkEEaiECIAdBAWsiBw0ACwUgCAs2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCSAFEOgYIAAgCSAKEL8dIANBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQiy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0EFdkEAQQhBCBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBBXYiBxDsLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBA3RqIQIDQCACIAQpAwA3AwAgBEEgaiEEIAJBCGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRC9GCAAIAkgChDWHSADQUBrJAAL0gMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBA3ZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBA3YQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0EDdiIBaiEIA0AgBiAJKQMAELMuIAYpAwAhDiAGKQMIIQ8gBikDECEQIARBGGogBikDGDcDACAEQRBqIBA3AwAgBCAPNwMIIAQgDjcDACAJQQhqIQkgBEEgaiEEIAFBAWsiAQ0ACwsgCDYCACAGQSBqJAAgB0EQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAUgChDtGCAAIAUgCxDOHSADQUBrJAALZgEDfwJAIAEoAgBBgICAgHhGBEAMAQtBASEDIAEoAggiBEUEQAwBCyABKAIEIQEDQEEAIAEoAgAgAUEEai0AABsgAmohAiABQQhqIQEgBEEBayIEDQALCyAAIAI2AgQgACADNgIAC/oBAgN/AX4jAEGQAmsiAyQAAkAgAQRAIANBkAFqIQIDQCADQQhqIgQgABDfHCADKQMIQg1RDQIgAiAEQYAB/AoAACADIAE2AogBAkAgAikDACIFQgxSBEACQAJAAkBBASAFp0EJayAFQghYGw4CAQIACyACQRRqIAIoAgwgAigCECACKAIIKAIQEQEADAMLIAJB7ABqIAIoAmQgAigCaCACKAJgKAIQEQEAIAJBCGoQwhgMAgsgAkHkAGogAigCXCACKAJgIAIoAlgoAhARAQAgAhDCGAwBCyACQQhqEMkjCyABQQFrIgENAAsLQQAhAQsgA0GQAmokACABC3gBAX8gACgCvAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBvAJqENkhCyAAQYACakEBQQEQ4B4gAEGMAmoQhjAgAEHgAGoQrCkgACgCmAJBgICAgHhHBEAgAEGYAmpBBEEIEOAeCyAAQaQCahCFMCAAQbACahCFMAvVAgIGfwF+IABBIGoQvCogACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahCJKQsgAEFAaxDPLwJAIAAoAgQiBEUNACAAKAIMIgUEQCAAKAIAIgFBCGohAiABKQMAQn+FQoCBgoSIkKDAgH+DIQcDQCAHUARAA0AgAUHgAGshASACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyIHQoCBgoSIkKDAgH9RDQALIAdCgIGChIiQoMCAf4UhBwsgASAHeqdBA3ZBdGxqQQhrIgYoAgAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAYQuyMLIAdCAX0gB4MhByAFQQFrIgUNAAsLIAQgBEEMbEETakF4cSIBakEJaiICRQ0AIAAoAgAgAWsgAkEIEPg6CwJAIAAoAjgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEE4ahCBLAsLeQEBfwJAIAApAwBCAlENACAAQcgCakEEQQQQ4B4gAEHUAmoiARDRKyABEOg7IABB4AJqEK4vIABBMGoQ8SsgACgC7AJBgICAgHhHBEAgAEHsAmpBBEEMEOAeCyAAQYgBahDTLiAAKQOwAUIDUQ0AIABBkAJqEJcwCwtyAQF/IAAoAhAiAyAAKAIIRgRAIABBCGpByPvPABCzKAsgACgCDCADQQN0aiABNwMAIAAgA0EBajYCECAAKAIcIgMgACgCFEYEQCAAQRRqQdj7zwAQnSgLIAAoAhggA0ECdGogAjYCACAAIANBAWo2AhwLawEBfyAAKAIAIgBB6ABqEN47IABB9ABqEK4vIABByABqEPgmIAAoAoABQYCAgIB4RwRAIABBgAFqQQRBCBDgHgsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBoAFBCBD4OgsLZgEDfyMAQSBrIgEkACAAEOUkIAFBGGoiAiAAQcAFaigAADYCACABIAApALgFNwMQIAAoApgEIABBmARqQQBBLPwLACABQQhqIAIoAgA2AgAgASABKQMQNwMAIAEQiy0gAUEgaiQAC2YBA38gBUUgASAAKAIEIghrIgcgACgCHCIGa0GBA0lyRQRAIAAgBiAGQeAAaiACIAMgBEEBENAVIAAgCCACIAdBIGsiBiABQQFqEKAaCyAAIAYgByACIAMgBCAFENAVIAAgBzYCHAtiAQF/Qbh/IQMgAUEBQQUgAhsiAU8EfyAAIAFqQQFrLQAAIgBBA3FBAnRBwLXRAGooAgAgAWogAEEEdkEMcUHQtdEAaigCAGogAEEgcSIBRWogAUEFdiAAQcAASXFqBSADCwtpAQF/AkAgASAETwRAIAMgBEkNAUEAIQECQANAIAEgBEYNASABIAJqIQMgACABaiABQQFqIQEtAAAgAy0AAEYNAAsgAUEBayEECyAEDwsgBCABQYzS0QAQsDsACyAEIANBnNLRABCwOwALXQEEfyABKAIEIgNBEGoiBCAALwEOIgVB/wdxIgJMBH8gAiADa0EQayICQX8gASgCACIBdEF/c3EgBGogACgCCCACIAF2QQFxQQJyIAVBCnZ0akEEayABdGoFIAILC3EBAn9BASEEIwBBEGsiAyQAAn9BgYCAgHggASgCACACa0EgTw0AGiADQQhqIAEgAkEgQQFBARC3EUGBgICAeCADKAIIIgFBgYCAgHhGDQAaIAMoAgwhBCABCyEBIAAgBDYCBCAAIAE2AgAgA0EQaiQAC+ACAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSICKAIEIAIoAgBrQQJ2QQBBCEEQEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASAENgIIIAFBCGoiBiACKAIEIgcgAigCACIEa0ECdiIIEOktIAYoAgghAiAGIAQgB0cEfyACIAhqIAYoAgQgAkEEdGohAgNAIAJBCGpCADcDACACQQRqQQA2AgAgAiAEKAIANgIAIARBBGohBCACQRBqIQIgCEEBayIIDQALBSACCzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ6hggACAJIAoQxR0gA0FAayQAC8ACAgl/AX4jAEEgayICJAAgACABKAIEIgMgASgCACIEa0ECdhDsLSAAKQIEIQsgAkEcaiABQRBqKAIANgIAIAIgC0IgiTcCDCACIABBCGo2AgggAiABKQIINwIUIAJBCGoiASgCBCEFIAEoAgAhAAJAAkACQCADIARHBEAgASgCFCEJIAEoAhAhBiABKAIMIQogASgCCCAFQQN0aiEHIAMgBGtBAnYhAwNAIAQoAgAiCCAGTw0CIAhBAWoiASAGTw0DIAkgCSkDACAKIAFBA3RqKQMAIAogCEEDdGopAwB9Qv////8Pg3wiCzcDACAHIAs3AwAgBEEEaiEEIAdBCGohByAFQQFqIQUgA0EBayIDDQALCyAAIAU2AgAMAgsgCCAGQbCBhAEQwyEACyABIAZBwIGEARDDIQALIAJBIGokAAvTAgIJfwF+IwBBIGsiAiQAIAAgASgCBCIDIAEoAgAiBGtBAnYQ7i0gACkCBCELIAJBHGogAUEQaigCADYCACACIAtCIIk3AgwgAiAAQQhqNgIIIAIgASkCCDcCFCACQQhqIgAoAgQhBSAAKAIAIQECQAJAIAMgBEcEQCAAKAIUIQkgACgCECEGIAAoAgwhCiAAKAIIIAVBAnRqIQcgAyAEa0ECdiEDA0AgBCgCACIIIAZPDQICQCAGIAhBAWoiAEsEQCAKIABBAnRqKAIAIAogCEECdGooAgBrIgBBAE4NAUHQgYQBQRRB5IGEARDLJAALIAAgBkHAgYQBEMMhAAsgCSAJKAIAIABqIgA2AgAgByAANgIAIARBBGohBCAHQQRqIQcgBUEBaiEFIANBAWsiAw0ACwsgASAFNgIADAELIAggBkGwgYQBEMMhAAsgAkEgaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEJ08IAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC2wBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACQQRBDBDgHiACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAtoAQR/IwBBEGsiASQAIAAoAgwiBCAAKAIEIgJrQQxuIQMgAiAERwRAA0AgAhDeOyACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAtoAQR/IwBBEGsiASQAIAAoAgwiBCAAKAIEIgJrQQxuIQMgAiAERwRAA0AgAhDjPCACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAt9ACAAQpeu3Ljx4sWLFzcCDCAAQRRqQZeu3LgBNgIAIAAgASkCADcCGCAAIAIpAgA3AgAgACADKQIANwIkIABBIGogAUEIaigCADYCACAAQQhqIAJBCGooAgA2AgAgAEEsaiADQQhqKQIANwIAIABBNGogA0EQaikCADcCAAt9ACAAQpq06NChw4aNGjcCDCAAQRRqQZq06NABNgIAIAAgASkCADcCGCAAIAIpAgA3AgAgACADKQIANwIkIABBIGogAUEIaigCADYCACAAQQhqIAJBCGooAgA2AgAgAEEsaiADQQhqKQIANwIAIABBNGogA0EQaikCADcCAAuQAgEFfyMAQSBrIgMkACADQQhqIQYgASgCDCECIwBBIGsiBSQAAn9BAiABKAIAIgQgASgCBEYNABogASAEQQRqNgIAIAVBDGogBCABKAIIEJQDIAUoAhAhAUEBIAUoAgwiBEGTgICAeEYNABogAigCAEGTgICAeEcEQCACEIgRCyACIAE2AgQgAiAENgIAIAIgBUEUaiIEKQIANwIIIAJBEGogBEEIaigCADYCAEEACyECIAYgATYCBCAGIAI2AgAgBUEgaiQAIAMgAygCDCIBNgIYIAMgAygCCCICQQAgAkECRxsiAjYCFCACQQFxIgJFBEAgA0EUahC/KgsgACABNgIEIAAgAjYCACADQSBqJAALkAIBBX8jAEEgayIDJAAgA0EIaiEGIAEoAgwhAiMAQSBrIgUkAAJ/QQIgASgCACIEIAEoAgRGDQAaIAEgBEEEajYCACAFQQxqIAQgASgCCBCTAyAFKAIQIQFBASAFKAIMIgRBk4CAgHhGDQAaIAIoAgBBk4CAgHhHBEAgAhCIEQsgAiABNgIEIAIgBDYCACACIAVBFGoiBCkCADcCCCACQRBqIARBCGooAgA2AgBBAAshAiAGIAE2AgQgBiACNgIAIAVBIGokACADIAMoAgwiATYCGCADIAMoAggiAkEAIAJBAkcbIgI2AhQgAkEBcSICRQRAIANBFGoQvyoLIAAgATYCBCAAIAI2AgAgA0EgaiQAC2wBAX8jAEEQayICJAACQAJAIAFFBEAgAiAAEJgfIAIgAikDADcCCCACQQhqEMkmDAELIABFDQEgAiAAQQhrIgA2AgggACAAKAIAQQFrIgA2AgAgAA0AIAJBCGoQ7x0LIAJBEGokAA8LEJg9AAtuAQF/IABBmANqEJQMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAugCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegCahDZIQsgAEHQAmoQ3jsgAEGgAmoQsiwgAEHcAmoQtDAgABDhHwtoAQF/IABBDGoQtDAgAEEYahC0MCAAEOk7IAAoAiQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBJGoQuyMLAkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwt3AQF/IwBBIGsiAiQAIAIgATYCCCACIAFBCGoQ3iU2AhwgAkIANwIUIAJCgICAgMAANwIMIAAgAkEMahDJICAAQQA2AlAgAEKAgICAgAE3A0ggASABKAIAIgBBAWs2AgAgAEEBRgRAIAJBCGoQ2SELIAJBIGokAAt3AQF/IwBBIGsiAiQAIAIgATYCCCACIAFBCGoQ3iU2AhwgAkIANwIUIAJCgICAgIABNwIMIAAgAkEMahDJICAAQQA2AlAgAEKAgICAgAE3A0ggASABKAIAIgBBAWs2AgAgAEEBRgRAIAJBCGoQ2SELIAJBIGokAAu+AQIEfwF+IwBBEGsiBCQAIARBCGohBSABQSBqIQcjAEEQayIBJAAgAUEIakEAOwEAIAFCADcDACADIAEQshUiBkELTwRAIAZBCkGsmc8AELA7AAsgBygCACABIAYQoTYgBUEEOgAAIAUgBjYCBCABQRBqJAACQAJAIAQtAAhBBEYNACAEKQMIIghC/wGDQgRRDQAgBCAINwMIIAAgBRDQCQwBCyAHKAIAIAIgAxChNiAAQQQ2AgALIARBEGokAAtyAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQZjXzgA2AgggAkIENwIQIAJBCGpBpNnOABDvLAALIAJBBGpBBCAAQQRBtNnOABDVLCACKAIEIAJBIGokAEG9z9bxAWxBEXYLcgEBfyMAQSBrIgIkACACQQA2AgQgAUEDTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQaTZzgAQ7ywACyACQQRqQQQgAEEEQbTZzgAQ1SwgAigCBCACQSBqJABBvc/W8QFsQRJ2C2UBA38gACABEIEuIAAoAgQiBCAAKAIIIgJqIQMCQAJAIAFBAk8EQCABQQFrIgEEQCADQQAgAfwLAAsgBCABIAJqIgJqIQMMAQsgAUUNAQsgA0EAOgAAIAJBAWohAgsgACACNgIIC+8BAQV/IwBBEGsiBCQAIABBEGpBmJ/PAEG4n88AEIU1IgIoAgAgAigCBCgCDBEEABDaASMAQTBrIgIkACACQSBqIARBD2pBCEGAwAAQ+xQgAiACKQIoNwIYIAIgAikCIDcCECACIAJBEGoQwTQgAigCBCIDBEAgAigCAEH/ASAD/AsACyACKAIYIQMgAigCFCEFIAIoAhAhBiAAIAIoAhw2AgwgACADNgIIIAAgBTYCBCAAIAY2AgAgAkEwaiQAIABBQGsgAUEQaigCADYCACAAQThqIAFBCGopAgA3AgAgACABKQIANwIwIARBEGokAAtyAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQdCY0gA2AgggAkIENwIQIAJBCGpBzJ3WABDvLAALIAJBBGpBBCAAQQRB3J3WABDVLCACKAIEIAJBIGokAEG9z9bxAWxBEnYLagECfwJAIAAoAhAiBARAIAAoAgwiAyACTw0BIAAgBEEBazYCECAAIANBAWo2AgwgACAAKAIIQQhrNgIIIAAgASADajEAAEI4hiAAKQMAQgiIhDcDAAsgBEEARw8LIAMgAkG4qvsAEMMhAAtoAQR/AkAgACgCCCICIAAoAgQiA00EQCAAKAIAIgUgAmovAAAgAUH//wNxIgBBAmpPBH8gACACaiIAIANLDQIgACAFai8AAAUgBAsPCyACIANBnIL/ABCvOwALIAAgA0Gcgv8AEK87AAtuAQF/IwBBMGsiASQAIAAtAABBI0YEQCAALQABIAFBMGokAA8LIAFBATYCECABQZSH/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHIif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJUYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZiG/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHYif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJkYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZCI/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHoif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJEYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZyF/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakH4if8AEO8sAAuaBQILfwN+IwBBMGsiCiQAIAEgAhDjISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiIMIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQWBxajYCOCACIAJBCGo2AjwgAkEoaiELIwBBIGsiASQAIAFBFGogAkE0aiIFKAIEIAUoAgBrQQV2QQBBCEEIEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAyAFKAIEIAUoAgBrQQV2EOwtIAcgAykCBEIgiTcCCCAHIANBCGo2AgQjAEEwayIDJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCAFKAIAIgQgBSgCBCIJRwRAIAYoAgggCEEDdGohBiAJIARrQQV2IQkgBSgCCCEPA0AgBEEQaikDACEQIAQpAwAhESAEKQMIIRIgAyAEQRhqKQMANwMYIAMgEDcDECADIBI3AwggAyARNwMAIANBIGogAxDTDiADKAIgRQ0CIAYgAysDKEQAAAAAAAAkQCAPKAIELAAAEN4gozkDACAEQSBqIQQgBkEIaiEGIAhBAWohCCAJQQFrIgkNAAsLIA4gCDYCACADQTBqJAAMAQtB+LKAAUEaQZSzgAEQyyQACyAHQRBqJAAgC0EIaiANKAIANgIAIAsgASkCCDcCACABQSBqJAAgBSALEOcYIAogBSAMENsdIAJBQGskAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAKQTD8CgAAIABB8KWAATYCCCAAIAE2AgQgAEGTgICAeDYCACAKQTBqJAAPC0EEQTgQoz0AC5MEAQp/IwBBMGsiCSQAIAEgAhDoISECIwBBQGoiASQAIAEgBDYCDCABIAM2AgggAUEQaiILIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCNCABIAFBCGo2AjwgAUEoaiEKIwBBIGsiAiQAIAJBFGogAUE0aiIDKAIEIAMoAgBrQQN2QQBBCEEIEKAYIAIoAhghBCACKAIUQQFGBEAgBCACKAIcQdyP/wAQ/S8ACyACQRBqIgxBADYCACACIAIoAhw2AgwgAiAENgIIIwBBEGsiBCQAIAJBCGoiBSADKAIEIAMoAgBrQQN2EOwtIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQgBEEEaiIGKAIEIQUgBigCACADKAIAIgcgAygCBCIIRwRAIAYoAgggBUEDdGohBiAFIAggB2tBA3YiCGohBSADKAIIIQ4DQCAGIAcpAwC5RAAAAAAAACRAIA4oAgQsAAAQ3iCjOQMAIAdBCGohByAGQQhqIQYgCEEBayIIDQALCyAFNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACADIAoQ5xggCSADIAsQ2x0gAUFAayQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAlBMPwKAAAgAEHwpYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAlBMGokAA8LQQRBOBCjPQALlAQBCn8jAEEwayIJJAAgASACEOQhIQIjAEFAaiIBJAAgASAENgIMIAEgAzYCCCABQRBqIgsgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwI0IAEgAUEIajYCPCABQShqIQojAEEgayICJAAgAkEUaiABQTRqIgMoAgQgAygCAGtBAnZBAEEEQQQQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAMoAgQgAygCAGtBAnYQ7i0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIAMoAgAiByADKAIEIghHBEAgBigCCCAFQQJ0aiEGIAUgCCAHa0ECdiIIaiEFIAMoAgghDgNAIAYgBygCALdEAAAAAAAAJEAgDigCBCwAABDeIKO2OAIAIAdBBGohByAGQQRqIQYgCEEBayIIDQALCyAFNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACADIAoQ6BggCSADIAsQvh0gAUFAayQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAlBMPwKAAAgAEHIpoABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAlBMGokAA8LQQRBOBCjPQALqwQBC38jAEEwayIJJAAgASACEPwhIQEjAEFAaiICJAAgAiAENgIMIAIgAzYCCCACQRBqIgsgARCSNhDuJSABKAIUIQMgAiABKAIQIgE2AjQgAiABIANBcHFqNgI4IAIgAkEIajYCPCACQShqIQojAEEgayIBJAAgAUEUaiACQTRqIgMoAgQgAygCAGtBBHZBAEEEQQQQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiDEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIGJAAgAUEIaiIEIAMoAgQgAygCAGtBBHYQ7i0gBiAEKQIEQiCJNwIIIAYgBEEIajYCBCAGQQRqIgUoAgQhByAFKAIAIAMoAgAiBCADKAIEIghHBEAgBSgCCCAHQQJ0aiEFIAcgCCAEa0EEdiIIaiEHIAMoAgghDgNAIA4oAgQsAAAhDyAFIAQpAwAgBCkDCBDRFkQAAAAAAAAkQCAPEN4go7Y4AgAgBEEQaiEEIAVBBGohBSAIQQFrIggNAAsLIAc2AgAgBkEQaiQAIApBCGogDCgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAMgChDoGCAJIAMgCxC+HSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAuUBAEKfyMAQTBrIgkkACABIAIQ6CEhAiMAQUBqIgEkACABIAQ2AgwgASADNgIIIAFBEGoiCyACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjQgASABQQhqNgI8IAFBKGohCiMAQSBrIgIkACACQRRqIAFBNGoiAygCBCADKAIAa0EDdkEAQQRBBBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgAygCBCADKAIAa0EDdhDuLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAgAygCACIHIAMoAgQiCEcEQCAGKAIIIAVBAnRqIQYgBSAIIAdrQQN2IghqIQUgAygCCCEOA0AgBiAHKQMAuUQAAAAAAAAkQCAOKAIELAAAEN4go7Y4AgAgB0EIaiEHIAZBBGohBiAIQQFrIggNAAsLIAU2AgAgBEEQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAMgChDoGCAJIAMgCxC+HSABQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAubBQILfwN+IwBBMGsiCiQAIAEgAhDjISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiIMIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQWBxajYCOCACIAJBCGo2AjwgAkEoaiELIwBBIGsiASQAIAFBFGogAkE0aiIFKAIEIAUoAgBrQQV2QQBBBEEEEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAyAFKAIEIAUoAgBrQQV2EO4tIAcgAykCBEIgiTcCCCAHIANBCGo2AgQjAEEwayIDJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCAFKAIAIgQgBSgCBCIJRwRAIAYoAgggCEECdGohBiAJIARrQQV2IQkgBSgCCCEPA0AgBEEQaikDACEQIAQpAwAhESAEKQMIIRIgAyAEQRhqKQMANwMYIAMgEDcDECADIBI3AwggAyARNwMAIANBIGogAxDTDiADKAIgRQ0CIAYgAysDKEQAAAAAAAAkQCAPKAIELAAAEN4go7Y4AgAgBEEgaiEEIAZBBGohBiAIQQFqIQggCUEBayIJDQALCyAOIAg2AgAgA0EwaiQADAELQfiygAFBGkGUs4ABEMskAAsgB0EQaiQAIAtBCGogDSgCADYCACALIAEpAgg3AgAgAUEgaiQAIAUgCxDoGCAKIAUgDBC+HSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCkEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCkEwaiQADwtBBEE4EKM9AAuTBAEKfyMAQTBrIgkkACABIAIQ5CEhAiMAQUBqIgEkACABIAQ2AgwgASADNgIIIAFBEGoiCyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjQgASABQQhqNgI8IAFBKGohCiMAQSBrIgIkACACQRRqIAFBNGoiAygCBCADKAIAa0ECdkEAQQhBCBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgAygCBCADKAIAa0ECdhDsLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAgAygCACIHIAMoAgQiCEcEQCAGKAIIIAVBA3RqIQYgBSAIIAdrQQJ2IghqIQUgAygCCCEOA0AgBiAHKAIAt0QAAAAAAAAkQCAOKAIELAAAEN4gozkDACAHQQRqIQcgBkEIaiEGIAhBAWsiCA0ACwsgBTYCACAEQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgAyAKEOcYIAkgAyALENsdIAFBQGskAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAJQTD8CgAAIABB8KWAATYCCCAAIAE2AgQgAEGTgICAeDYCACAJQTBqJAAPC0EEQTgQoz0AC6oEAQt/IwBBMGsiCSQAIAEgAhD8ISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiILIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQXBxajYCOCACIAJBCGo2AjwgAkEoaiEKIwBBIGsiASQAIAFBFGogAkE0aiIDKAIEIAMoAgBrQQR2QQBBCEEIEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIgxBADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBiQAIAFBCGoiBCADKAIEIAMoAgBrQQR2EOwtIAYgBCkCBEIgiTcCCCAGIARBCGo2AgQgBkEEaiIFKAIEIQcgBSgCACADKAIAIgQgAygCBCIIRwRAIAUoAgggB0EDdGohBSAHIAggBGtBBHYiCGohByADKAIIIQ4DQCAOKAIELAAAIQ8gBSAEKQMAIAQpAwgQ0RZEAAAAAAAAJEAgDxDeIKM5AwAgBEEQaiEEIAVBCGohBSAIQQFrIggNAAsLIAc2AgAgBkEQaiQAIApBCGogDCgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAMgChDnGCAJIAMgCxDbHSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQfClgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAt0AQJ/IAEoAghBf0cEQCAAELkQIAAoAkwiAiAAKAJERgRAIABBxABqQdjrgAEQkCgLIAAoAkggAkEMbGoiAyABKQIANwIAIANBCGogAUEIaigCADYCACAAIAJBAWo2AkwgAg8LQYzqgAFBMkHA6oABEJ8pAAtmAQN/IwBBEGsiAyQAIAAoAgAhBCADIAAoAgQiAjYCDCABIANBDGpBBBC7CSACBEAgBEEIaiEAIAJBAnQhAgNAIAAoAgBBCGogARDZCiAAQQRqIQAgAkEEayICDQALCyADQRBqJAALZQEDfyAAKAIIIgEEQCAAKAIEIQAgAUEDdCEBA0ACQCAAKAIAIgJFDQAgAiAAQQRqKAIAIgMoAghBAWtBeHFqQQhqIAMoAkwRBABFDQBBAQ8LIABBCGohACABQQhrIgENAAsLQQALfQMBfwF+AXwjAEEQayIDJAACQAJAAkACQCAAKAIAQQFrDgIBAgALIAArAwghBSADQQM6AAAgAyAFOQMIDAILIAApAwghBCADQQE6AAAgAyAENwMIDAELIAApAwghBCADQQI6AAAgAyAENwMICyADIAEgAhDRHCADQRBqJAALawEDfwJAIAEoAggiAkEASA0AIAEoAgQhAwJAIAJFBEBBASEBDAELQQEhBCACQQEQrTYiAUUNAQsgAgRAIAEgAyAC/AoAAAsgACACNgIIIAAgATYCBCAAIAI2AgAPCyAEIAJBvMOJARD9LwALZwICfwF8IABEAAAAAAAA8D8gASABQR91IgJzIAJrIgJBAXEbIQQgAkECTwRAA0AgBCAAIACiIgCiIAQgAkECcRshBCACQQNLIAJBAXYhAg0ACwtEAAAAAAAA8D8gBKMgBCABQQBIGwtyAQF/AkACQAJAAkAgAC0AHA4EAAMDAQMLIAAoAgAiAUUNAiABIAEoAgAiAUEBazYCACABQQFGDQEMAgsgAEEUahC8KiAAKAIMIgFFDQEgASABKAIAIgFBAWs2AgAgAUEBRw0BIABBDGohAAsgABD4IwsLhwEBAn8jAEHQAmsiAyQAIANBCGoiBCAAEJUaIAMgASACEPooIANBpAFqIgAgAygCACADKAIEEI81IARB4ABqEN47IARB6ABqIABBCGooAgA2AgAgBCAAKQIANwJgIANBuAFqIARBmAH8CgAAIANBADYCsAEgA0GwAWoQ0SlBCGogA0HQAmokAAtzAQN/IwBBIGsiAiQAIAEoAgAiAygCCCIEIAEoAgQiAUsEQCACQQA2AhggAkEBNgIMIAJBnKHDADYCCCACQgQ3AhAgAkEIakG8oMMAEO8sAAsgACABNgIMIAAgBDYCCCAAIAMpAgBCIIk3AgAgAkEgaiQAC1sBAX8CQAJAAkAgAC0AIA4EAQICAAILIAAtABxBA0YEQCAAQRBqELwqCyAAKAIIIgEgASgCAEEBajYCAAsgACgCACIBIAEoAgBBAWsiATYCACABDQAgABDUIgsLZAEFfyABKAIIIQMgASgCBCEEQQAhAQNAAkAgASADRgRAIAQhAgwBCyABIARqIAFBAWohAS0AACIFQSBrIQZBACECIAVBCUYgBkH/AXFB3wBJcg0BCwsgACADNgIEIAAgAjYCAAvkAQEHfyMAQRBrIgMkAAJ/IAEoAghFBEAgASgCBCECIAEoAgAMAQsgA0EEaiECIAEoAgAhByABKAIEIQQjAEEQayIBJAAgAUEEaiAEQQBBAUECEKAYIAEoAgghBQJAIAEoAgRBAUcEQCABKAIMIQYgBEEBdCIIBEAgBiAHIAj8CgAACyACIAQ2AgggAiAGNgIEIAIgBTYCACABQRBqJAAMAQsgBSABKAIMQeCtzAAQ/S8ACyADKAIMIQIgAygCBCEEIAMoAggLIQEgACAENgIIIAAgAjYCBCAAIAE2AgAgA0EQaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBFG4hAyACIARHBEADQCACEOkrIAJBFGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQRQQ4B4gAUEQaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEIUwIAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC2sBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtByABuIQMgAiAERwRAA0AgAhDCICACQcgAaiECIANBAWsiAw0ACwsgASAAKAIANgIMIAEgACgCCDYCCCABQQhqQQRByAAQ4B4gAUEQaiQAC3ABAn8jAEEQayICJAAgAkEEaiABQQBBAUEBEKAYIAIoAgghASACKAIEQQFGBEAgASACKAIMQfi1zgAQ/S8ACyACKAIMIQMgAEEANgIQIAAgAzYCDCAAIAE2AgggAEEAOgAUIABCADcDACACQRBqJAALdAEBfyAAQgA3AwAgAEIANwMgAkAgACgCCEGAgICAeEYNACAAKAIQIgFFDQAgAUEDdCIBRQ0AIAAoAgxBACAB/AsACwJAIAAoAhRBgICAgHhGDQAgACgCHCIBRQ0AIAFBA3QiAUUNACAAKAIYQQAgAfwLAAsLtQIBBX8gACgCDCIDIAAoAgAiAkYEQCAAKAIAIQMjAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQYgBELcRIAIoAggiBEGBgICAeEcEQCAEIAIoAgxBqIPPABD9LwALIAJBEGokAAJAIAAoAggiBCADIAAoAgwiBWtNDQAgAyAEayICIAUgAmsiBUsgACgCACIGIANrIAVPcUUEQCAGIAJrIQMgAkGIAWwiAgRAIAAoAgQiBSADQYgBbGogBSAEQYgBbGogAvwKAAALIAAgAzYCCAwBCyAFQYgBbCICRQ0AIAAoAgQiBCADQYgBbGogBCAC/AoAAAsgACgCACECIAAoAgwhAwsgACADQQFqNgIMIAAoAgQgACgCCCADaiIAIAJBACAAIAJPG2tBiAFsaiABQYgB/AoAAAuHBAEKfyMAQSBrIgQkACAAAn8gAUUEQCAEQQA2AhwgBEKAgICAwAA3AhQgBCAEQRRqQYyHzgAQmSEgBCgCBCEBIAQoAgAMAQsjAEEwayIFJAAgBUEANgIsIAVCATcCJCAFQoCAgIDgs/L//gA3AhwgBUEQaiEJIAVBHGohByMAQSBrIgMkACADQRRqIAFBAEEEQRQQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxBxJ7QABD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAI2AgggA0EIaiIIKAIAIAgoAggiAmsgAUkEQCAIIAIgAUEEQRQQ0CggCCgCCCECCyAIKAIEIAJBFGxqIQYCQAJAIAFBAk8EQCABQQFrIQoDQCAGIAcpAgA3AgAgBkEQaiAHQRBqKAIANgIAIAZBCGogB0EIaikCADcCACAGQRRqIQYgCkEBayIKDQALIAEgAmpBAWshAgwBCyABRQ0BCyAGIAcpAgA3AgAgBkEQaiAHQRBqKAIANgIAIAZBCGogB0EIaikCADcCACACQQFqIQILIAggAjYCCCAJQQhqIAsoAgA2AgAgCSADKQIINwIAIANBIGokACAFQQhqIAlBzILOABCZISAEQQhqIAUpAwg3AwAgBUEwaiQAIAQoAgwhASAEKAIICzYCACAAIAE2AgQgBEEgaiQAC3MCAX8CfiMAQSBrIgIkACABKQPoASIDIAFBGEH4ASABKAIQG2opAwAiBIRCAFMEQCACQQA2AhggAkEBNgIMIAJBgPrPADYCCCACQgQ3AhAgAkEIakGI+s8AEO8sAAsgACADNwMIIAAgBDcDACACQSBqJAALVQEBf0EMQQVBICABZ2siBEEhIAJnayICIAIgBEsbIgJBHyADIAFBAWtnamsiASAAQQsgABsiACAAIAFLGyIAIAAgAkkbIgAgAEEFTRsiACAAQQxPGwtoAQF/AkACQAJAAkAgAkH/H0tBAkEBIAJBH0sbaiIDQQJrDgIBAgALIAAgAkEDdEEBcjoAAAwCCyAAIAJBBHRBBXI7AAAMAQsgACACQQR0QQ1yNgAACyAAIANqIAEtAAA6AAAgA0EBagtwAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQdCY0gA2AgggAkIENwIQIAJBCGpBzJ3WABDvLAALIAJBBGpBBCAAQQRB3J3WABDVLCACKAIEIAJBIGokAEG9z9bxAWytC3IBBH8CQAJAIAEoAggiAiABKAIEIgNNBEAgAiABKAIAIAJqIgQvAAAiBWoiASACSQ0BIAEgA0sNAiAAIAU2AgQgACAENgIADwsgAiADQZyC/wAQrzsACyACIAFB3IL/ABCxOwALIAEgA0Hcgv8AELA7AAuFAgEEfyMAQRBrIgMkACABKAIQGiMAQRBrIgQkAAJAIAEoAgAiAiABKAIERwRAIAEgAkEEajYCACACKAIAIQUCQCADAn4gASgCCCgCACICBEAgBSACKAIQTw0CQgAgAigCBCACKAIMIAVqIgJBA3ZqLQAAIAJBB3F2QQFxRQ0BGgsgBEEIaiABKAIMIAUQoBsgBCkDCAs3AgQgA0EBNgIADAILQYyyggFBIEGssoIBEJ8pAAsgA0ECNgIACyAEQRBqJAAgAAJ/QQAgAygCACIBQQJGDQAaQQAgAUEBcUUNABogAygCBCEBIAAgAygCCDYCCCAAIAE2AgRBAQs2AgAgA0EQaiQAC6gDAQV/IwBBEGsiBSQAIAEoAhAhAiMAQSBrIgQkAAJAAkACQCAFAn4CQCABKAIAIgMgASgCBEcEQCABIANBBGo2AgAgAygCACIDQQBIBEAgBEEUakEUQQBBAUEBEKAYIAQoAhghAyAEKAIUQQFHDQIgAyAEKAIcQbSzggEQ/S8ACyABKAIIKAIAIgIEQCADIAIoAhBPDQVBASEGQgAgAigCBCACKAIMIANqIgJBA3ZqLQAAIAJBB3F2QQFxRQ0DGgsgBEEIaiABKAIMIAMQoBtBASEGIAQpAwgMAgsgBUECNgIADAILIAQoAhwiAUEQakHEtoIBKAAANgAAIAFBCGpBvLaCASkAADcAACABQbS2ggEpAAA3AAAgAhDlECACQhQ3AgwgAiABNgIIIAIgAzYCBCACQYaAgIB4NgIAQgALNwIEIAUgBjYCAAsgBEEgaiQADAELQYyyggFBIEGssoIBEJ8pAAsgAAJ/QQAgBSgCACIBQQJGDQAaQQAgAUEBcUUNABogBSgCBCEBIAAgBSgCCDYCCCAAIAE2AgRBAQs2AgAgBUEQaiQAC7cDAgV/AX4jAEEQayIFJAAgASgCECECIwBBIGsiAyQAAkACQAJAIAUCfgJAIAEoAgAiBiABKAIERwRAIAEgBkEIajYCACAGKQMAIgdCgICAgBBaBEBBACEGIANBFGpBFEEAQQFBARCgGCADKAIYIQQgAygCFEEBRw0CIAQgAygCHEG0s4IBEP0vAAsgB6chAiABKAIIKAIAIgQEQCAEKAIQIAJNDQVBASEGQgAgBCgCBCAEKAIMIAJqIgRBA3ZqLQAAIARBB3F2QQFxRQ0DGgsgA0EIaiABKAIMIAIQoBtBASEGIAMpAwgMAgsgBUECNgIADAILIAMoAhwiAUEQakHEtoIBKAAANgAAIAFBCGpBvLaCASkAADcAACABQbS2ggEpAAA3AAAgAhDlECACQhQ3AgwgAiABNgIIIAIgBDYCBCACQYaAgIB4NgIAQgALNwIEIAUgBjYCAAsgA0EgaiQADAELQYyyggFBIEGssoIBEJ8pAAsgAAJ/QQAgBSgCACIBQQJGDQAaQQAgAUEBcUUNABogBSgCBCEBIAAgBSgCCDYCCCAAIAE2AgRBAQs2AgAgBUEQaiQAC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxCiGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHg7YQBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKMZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQbjuhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtnAQJ/IwBB0ABrIgQkACAEQQhqIgUgASACIAMQpBlB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVByAD8CgAAIABBkO+EATYCBCAAIAE2AgAgBEHQAGokAA8LQQRB0AAQoz0AC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxClGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHo74QBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKUZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQcDwhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtnAQJ/IwBB0ABrIgQkACAEQQhqIgUgASACIAMQoxlB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVByAD8CgAAIABBmPGEATYCBCAAIAE2AgAgBEHQAGokAA8LQQRB0AAQoz0AC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxCiGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHw8YQBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKQZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQcjyhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABBhPmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABB3PmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABBtPqEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtpAgF/AX4CQCACQf8BcSICQSZLDQAgACACQQR0IgJBoIeFAWopAwBUIAEgAkGoh4UBaikDACIEUyABIARRGw0AIAAgAkGwgoUBaikDAFggASACQbiChQFqKQMAIgBXIAAgAVEbIQMLIAMLowIBA38jAEFAaiIGJAAgBkEEaiEFIwBBMGsiBCQAIAQgAUEYaiACIAMQtiYgBEEMaiABEL4VAkAgASgCJARAIARBGGogAUEkaiACIAMQsR8MAQsgBEEANgIYCyAFQpq06NChw4aNGjcCDCAFIAQpAgA3AhggBSAEKQIMNwIAIAUgBCkCGDcCJCAFQRRqQZq06NABNgIAIAVBIGogBEEIaigCADYCACAFQQhqIARBFGooAgA2AgAgBUEsaiAEQSBqKQIANwIAIAVBNGogBEEoaikCADcCACAEQTBqJABBxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBPPwKAAAgAEHMy4UBNgIEIAAgATYCACAGQUBrJAAPC0EEQcQAEKM9AAujAgEDfyMAQUBqIgYkACAGQQRqIQUjAEEwayIEJAAgBCABQRhqIAIgAxC2JiAEQQxqIAEQvhUCQCABKAIkBEAgBEEYaiABQSRqIAIgAxCxHwwBCyAEQQA2AhgLIAVCl67cuPHixYsXNwIMIAUgBCkCADcCGCAFIAQpAgw3AgAgBSAEKQIYNwIkIAVBFGpBl67cuAE2AgAgBUEgaiAEQQhqKAIANgIAIAVBCGogBEEUaigCADYCACAFQSxqIARBIGopAgA3AgAgBUE0aiAEQShqKQIANwIAIARBMGokAEHEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUE8/AoAACAAQaTMhQE2AgQgACABNgIAIAZBQGskAA8LQQRBxAAQoz0AC6sCAQV/IwBBQGoiByQAIAdBCGohBCMAQTBrIgUkACAFQQxqIAEQ1AYCQCABKAIgBEAgBUEYaiABQSBqIAIgAxCxHwwBCyAFQQA2AhgLIAEoAgwiCCAIKAIAIgZBAWo2AgAgBkEASARAAAsgASgCECEGIARBFGogAUEUaiACIANBAWoiAUF/IAEbELcmIAQgBjYCECAEIAg2AgwgBEEIaiAFQRRqKAIANgIAIAQgBSkCDDcCACAEIAUpAhg3AiAgBEEoaiAFQSBqKQIANwIAIARBMGogBUEoaikCADcCACAFQTBqJABBwABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBOPwKAAAgAEGg2YUBNgIEIAAgATYCACAHQUBrJAAPC0EEQcAAEKM9AAurAgEFfyMAQUBqIgckACAHQQhqIQQjAEEwayIFJAAgBUEMaiABENQGAkAgASgCIARAIAVBGGogAUEgaiACIAMQsR8MAQsgBUEANgIYCyABKAIMIgggCCgCACIGQQFqNgIAIAZBAEgEQAALIAEoAhAhBiAEQRRqIAFBFGogAiADQQFqIgFBfyABGxC4JiAEIAY2AhAgBCAINgIMIARBCGogBUEUaigCADYCACAEIAUpAgw3AgAgBCAFKQIYNwIgIARBKGogBUEgaikCADcCACAEQTBqIAVBKGopAgA3AgAgBUEwaiQAQcAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTj8CgAAIABB+NmFATYCBCAAIAE2AgAgB0FAayQADwtBBEHAABCjPQALyAMBC38jAEHwAGsiCCQAIAhBDGohBSMAQfAAayIEJAAgBEEMaiABQTRqENQGAkAgASgCTARAIARBGGogAUHMAGogAiADELEfDAELIARBADYCGAsgASgCGCENIARB5ABqIAFBDGoQ1AYCQAJAIAEoAhwiBwRAIAcgBygCACIGQQFqNgIAIAZBAEgNASABKAIsIQkgASgCKCEKIAEoAiQhCyABKAIgIQwgASgCMCEGCyAEQTBqIg4gARC8FSAEQcQAaiAEQewAaigCADYCACAEIA02AkggBCAGNgJgIAQgCTYCXCAEIAo2AlggBCALNgJUIAQgDDYCUCAEIAc2AkwgBCAEKQJkNwI8IAVBQGsgAUFAayACIANBAWoiAUF/IAEbELgmIAVBPGogBEEUaigCADYCACAFIAQpAgw3AjQgBSAEKQIYNwJMIAVB1ABqIARBIGopAgA3AgAgBUHcAGogBEEoaikCADcCACAFIA5BNPwKAAAgBEHwAGokAAwBCwALQewAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQeQA/AoAACAAQbThhQE2AgQgACABNgIAIAhB8ABqJAAPC0EEQewAEKM9AAvwAQEDfyMAQTBrIgYkACAGQQRqIQUjAEEwayIEJAAgBEEEaiABIAIgAxClGgJAIAEoAhQEQCAEQRhqIAFBFGogAiADELEfDAELIARBADYCGAsgBSAEKQIENwIAIAUgBCkCGDcCFCAFQRBqIARBFGooAgA2AgAgBUEIaiAEQQxqKQIANwIAIAVBHGogBEEgaikCADcCACAFQSRqIARBKGopAgA3AgAgBEEwaiQAQTRBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBLPwKAAAgAEHc74UBNgIEIAAgATYCACAGQTBqJAAPC0EEQTQQoz0AC2IBAn8jAEFAaiIEJAAgBEEMaiIFIAEgAiADEL0QQTxBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBNPwKAAAgAEG0+YUBNgIEIAAgATYCACAEQUBrJAAPC0EEQTwQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC4JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARCmLDgwIGDhowYNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGYsODAATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQdiQhgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC3JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARCmbLkyJGjxowZNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGZsuTIATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQbCRhgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC4JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARClKjQoMGChYoUNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGUqNCgATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQYiShgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC3JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARClqzYsOHChYsWNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGWrNiwATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQeCShgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC7UCAQV/IwBB0ABrIgckACAHQQxqIQQjAEEwayIFJAAgBUEMaiABENgGAkAgASgCLARAIAVBGGogAUEsaiACIAMQsR8MAQsgBUEANgIYCyABKAIMIgggCCgCACIGQQFqNgIAIAZBAEgEQAALIAEoAhAhBiAEQRRqIAFBFGogAiADELcmIARBIGogAUEgaiACIAMQtyYgBCAGNgIQIAQgCDYCDCAEQQhqIAVBFGooAgA2AgAgBCAFKQIMNwIAIAQgBSkCGDcCLCAEQTRqIAVBIGopAgA3AgAgBEE8aiAFQShqKQIANwIAIAVBMGokAEHMAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHEAPwKAAAgAEG0lYYBNgIEIAAgATYCACAHQdAAaiQADwtBBEHMABCjPQALtQIBBX8jAEHQAGsiByQAIAdBDGohBCMAQTBrIgUkACAFQQxqIAEQ2AYCQCABKAIsBEAgBUEYaiABQSxqIAIgAxCxHwwBCyAFQQA2AhgLIAEoAgwiCCAIKAIAIgZBAWo2AgAgBkEASARAAAsgASgCECEGIARBFGogAUEUaiACIAMQuCYgBEEgaiABQSBqIAIgAxC4JiAEIAY2AhAgBCAINgIMIARBCGogBUEUaigCADYCACAEIAUpAgw3AgAgBCAFKQIYNwIsIARBNGogBUEgaikCADcCACAEQTxqIAVBKGopAgA3AgAgBUEwaiQAQcwAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcQA/AoAACAAQYyWhgE2AgQgACABNgIAIAdB0ABqJAAPC0EEQcwAEKM9AAvUAgEEfyMAQUBqIgckACAHQQhqIQUjAEEwayIEJAACQCABKAIwQX8gAiADaiIGIAIgBksbTwRAIAEoAjQhBiAEQQxqIAEQ2QYCQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAVBDGogAUEMaiACIAZsIAMgBmwQ5hUgBSAGNgI0IAUgAzYCMCAFQQhqIARBFGooAgA2AgAgBSAEKQIMNwIAIAUgBCkCGDcCGCAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAAwBCyAEQQA2AiggBEEBNgIcIARB7KCGATYCGCAEQgQ3AiAgBEEYakH0oIYBEO8sAAtBwABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBOPwKAAAgAEH0ooYBNgIEIAAgATYCACAHQUBrJAAPC0EEQcAAEKM9AAuEAwEGfyMAQUBqIggkACAIQQxqIQUjAEEwayIEJAACQCABKAIwQX8gAiADaiIGIAIgBksbTwRAIAEoAiwhBiAEQQxqIAEQ2QYgBCABKAIMIAEoAhAiBygCCEEBa0F4cWpBCGogAiAGbCADIAZsIAcoAiARBQAgBCgCBCEHIAQoAgAhCQJAIAEoAhQEQCAEQRhqIAFBFGogAiADELEfDAELIARBADYCGAsgBSAEKQIMNwIAIAUgCTYCDCAFIAQpAhg3AhQgBSADNgIwIAUgBjYCLCAFIAc2AhAgBUEIaiAEQRRqKAIANgIAIAVBHGogBEEgaikCADcCACAFQSRqIARBKGopAgA3AgAgBEEwaiQADAELIARBADYCKCAEQQE2AhwgBEGUpoYBNgIYIARCBDcCICAEQRhqQZymhgEQ7ywAC0E8QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTT8CgAAIABBrKeGATYCBCAAIAE2AgAgCEFAayQADwtBBEE8EKM9AAt3AQR/IwBBEGsiAiQAIAJBBGogASgCABCcPiIEQQBBAUEBEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQeSriAEQ/S8ACyABIAIoAgwiBSABKAIAEJw+EIMkIAAgBDYCCCAAIAU2AgQgACADNgIAIAJBEGokAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEBQQEQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwAL6gEBA38jAEFAaiICJAACQAJAIAFFBEAgAkEIaiEEIwBB0ABrIgEkAAJAAkAgAARAIABBCGsiAygCAEEBRw0BIAFBEGogAEHAAPwKAAAgA0EANgIAAkAgA0F/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIANByABBCBD4OgsgBCABQRhqQTj8CgAAIAFB0ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyAEENQlDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgggAQ0AIAJBCGoQ5yoLIAJBQGskAA8LEJg9AAuVAQEBfyMAQaABayICJAACQAJAIAFFBEAgAkEIaiIBIAAQlRogARDMLAwBCyAARQ0BIABBCGsiACAAKAIAQQFrIgE2AgAgAiAANgIIIAENACACQQhqKAIAIgBBEGoQzCwCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBqAFBCBD4OgsLIAJBoAFqJAAPCxCYPQALXwICfwF+IwBBwAJrIgIkACACQQhqIgMgABCVGiACKQOYASEEIAJBqAFqIANBjAH8CgAAIAIgBDcDuAIgAiABNgK0AiACQQA2AqABIAJBoAFqENEpQQhqIAJBwAJqJAALlwEBBH8CQAJAIAAoAgAiAUF/Rg0AIAEoAgAhAANAIABFDQEgAEEASA0CIAEgAEEBaiABKAIAIgIgACACRhs2AgAgACACRyACIQANAAsgASEECyAEDwsjAEEgayIAJAAgAEEBNgIEIABBmKuIATYCACAAQgE3AgwgAEKMm8OA8Cg3AxggACAAQRhqNgIIIABBpJvDABDvLAALZAEBfyMAQSBrIgIkAAJAAkAgAUUEQCACQQxqIgEgABCAHCABEJIgDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQ6hkLIAJBIGokAA8LEJg9AAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEECQQQQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALZgEDfyMAQRBrIgMkAAJAIAEoAgAiAiABKAIERyIERQ0AIAEgAkEBajYCACACLQAAIgJBJUcNACADQQhqIAEQqhkgAy0ACUElIAMtAAgbIQILIAAgAjoAASAAIAQ6AAAgA0EQaiQAC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQRBBBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQRQQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALZAEBfyMAQSBrIgIkAAJAAkAgAUUEQCACQQxqIgEgABCyFiABEOkrDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQzCMLIAJBIGokAA8LEJg9AAtpAQR/IAMEQCABKAIEIQUgASgCACEGA0AgBiACIAMgBigCCCIHIAMgB0kbIgQQlxogASAEIAVqIgU2AgQgB0UEQCAAQfjvzQApAwA3AgAPCyACIARqIQIgAyAEayIDDQALCyAAQQQ6AAALbQECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBBEGIFhD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQRAQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALbAECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBBEEgEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQRBCBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAttAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQYgREPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQJBIBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAttAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQYgIEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQhBCBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtyAQJ/AkAgACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFLBEAgBCgCBCABQQR0aiIAKAIARQ0BIAMoAgAgACgCBCAAKAIIEM0CDwsgASAAQZSQzgAQwyEAC0Hkh84AQSBBhIjOABDLJAALbQIBfgF/AkAgACkDACIBQgNRDQAgAUICUQRAIABBFGogACgCDCAAKAIQIAAoAggoAhARAQAPCyAAKAIQIgIEQCAAQRxqIAAoAhQgACgCGCACKAIQEQEACyAAKAIwIgBFDQAgAEGAIEEEEPg6CwtnAQF/IwBBIGsiAyQAIANBCGogASgCDCACIAEoAhAoAhQRAQAgAygCDCEBIAMoAggiAkEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwALIAAgAjYCACAAIAE2AgQgA0EgaiQAC2cBAX8jAEEgayIDJAAgA0EIaiABKAIYIAIgASgCHCgCFBEBACADKAIMIQEgAygCCCICQQhHBEAgACADKQMQNwMIIABBEGogA0EYaikDADcDAAsgACACNgIAIAAgATYCBCADQSBqJAALdAECfyMAQSBrIgIkACABLQAAIQMgAUEBOgAAIAIgAzoAByADQQFGBEAgAkIANwIUIAJCgYCAgMAANwIMIAJB4KHQADYCCCACQQdqQcy0wgAgAkEIakHoodAAEK0rAAsgACABNgIEIABBADYCACACQSBqJAALYgEBfyACQQEgAyAEIAUQ6CMgBCAFIAMoAgBBB2oiBkEDdiAAIAEgAhCJHyADIAZBeHEgAkEDdGoiADYCACAFIABBA3YiAEsEQCAAIARqQQA6AAAPCyAAIAVB+I3SABDDIQALbAECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBAkECEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2UBAX4gASADSQRAIAIgAUECdGoiATMBACEEIAAtABgiAiABLQACaiIBQf8BcUHAAE8EQCAAIAQgARDwEA8LIAAgAToAGCAAIAApAxAgBCACrYaENwMQDwsgASADQezc+wAQwyEAC2sBAn8CQAJAIAIgA08EQCABIANqKAAAIgQgA0EEaiIFaiIDIARJDQEgAiADSQ0CIAAgBDYCBCAAIAEgBWo2AgAPCyADIAJBnIL/ABCvOwALIAUgA0Gsgv8AELE7AAsgAyACQayC/wAQsDsAC54BAQJ/AkACQAJAAkBBAiAAKAIAIgFB/////wdqIAFBgICAgHhNG0EBaw4DAAECAwsgACgCCCIARQ0CIAAQrSEgAEEQQQQQ+DoPCyABQYCAgIB4Rg0BIAAoAggiAgRAIAAoAgQhAQNAIAEQ0RogAUEQaiEBIAJBAWsiAg0ACwsgABDuOw8LIAAoAggiAEUNACAAEK0hIABBEEEEEPg6CwvICAIUfwR+IwBBIGsiBiQAIAEoAhQhAyAGIAFBCGo2AhggBiADNgIUIAYgBkEfajYCECAGQRBqIQIjAEHgAGsiAyQAIAZBBGoiDSABKAIAIgQgASgCBEYEf0EABSACKAIIIQwgAigCBCELIAEgBEEIajYCACADIAQtAAA6ABcgDCgCACEBIwBBQGoiBCQAIAQgA0EXajYCECAEIAE2AgwgBEEUaiISIAEQ9zQgBEEsaiEOIAEoAhQhByAEQRBqIQ8gBEEMaiEQIwBBMGsiASQAQcAAIQgCQAJAAkAgB0EGdiIFIAdBP3EiEUEAR2oiAkEDdCIJQcD///8DcUFAayAJIAJBB3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiIIRQ0CC0EAIQIgB0HAAE8EQCAFrSEZIA8oAgAhEyAQKAIAIRQDQCAUKAIQIApqIQUgEy0AACEVQgAhFkIAIRcDQCAFLQAAIBVGrSAWhiAXhCEXIAVBAWohBSAWQgF8IhZCwABSDQALIAIgCGogFzcDACAKQUBrIQogAkEIaiECIBhCAXwiGCAZUg0ACwsgEQRAIBAoAgAoAhAgB0FAcWohBSARrSEYQgAhFiAPKAIALQAAIQpCACEXA0AgBS0AACAKRq0gFoYgF4QhFyAFQQFqIQUgGCAWQgF8IhZSDQALIAIgCGogFzcAACACQQhqIQILIAEgCTYCLCABQoCAgICACDcCJCABIAg2AhwgASAHQQN2IAdBB3FBAEdqIgUgAiACIAVLGyIFNgIgIAFBCGogAUEcahDXOyABKAIIIQhBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAEpAhw3AgggAkEQaiABQSRqKQIANwIAIAJBGGogAUEsaigCADYCACABIAU2AhggASAINgIUIAEgAjYCECAOIAFBEGpBACAHEPIVIAFBMGokAAwDC0Hw9IMBQSkgAUEcakGs9YMBQZz1gwEQ1R4AC0HAACAJEKM9AAtBBEEcEKM9AAsgA0EYaiIBIA4gEhDUGCAEQUBrJAAgA0HMAGogDCgCBEGEt4IBIAEQwhAgAygCVCECIAMoAlAhAQJAIAMoAkwiBEGTgICAeEcEQCADIAMpAlg3AgwgAyACNgIIIAMgATYCBCADIAQ2AgAMAQsgAyACNgJIIAMgATYCRCADIAwoAgggAy0AFxDZKEHks4IBIANBxABqIgIQgx4QiQEgASABKAIAIgFBAWs2AgAgAUEBRw0AIAIQuyMLIANBGGoQzSYgAygCCCECIAMoAgQhASADKAIAIgRBk4CAgHhHBEAgAykCDCEWIAsQ5RAgCyAWNwIMIAsgAjYCCCALIAE2AgQgCyAENgIAQQAhAQsgDSACNgIIIA0gATYCBEEBCzYCACADQeAAaiQAIAYoAgQhASAGKAIIIQMgACAGKAIMNgIEIAAgA0EAIAEbNgIAIAZBIGokAAuiAgIGfwF+IwBBIGsiAiQAIAEoAhAhAyACIAFBCGo2AhggAiADNgIUIAIgAkEfajYCECACQRBqIQQjAEEgayIDJAAgAkEEaiIHIAEoAgAiBSABKAIERgR/QQAFIAQoAgghBiAEKAIEIQQgASAFQQhqNgIAIANBDGogBigCACAFLQAAENkoQeSzggEgBigCBBCiASADKAIUIQUgAygCECEBIAMoAgwiBkGTgICAeEcEQCADKQIYIQggBBDlECAEIAg3AgwgBCAFNgIIIAQgATYCBCAEIAY2AgBBACEBCyAHIAU2AgggByABNgIEQQELNgIAIANBIGokACACKAIEIQEgAigCCCEDIAAgAigCDDYCBCAAIANBACABGzYCACACQSBqJAALaQEBfyAAQQxqEL4MIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCyAAELMmIABBBEEIEOAeC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHYBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBmwY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALbAEBfyMAQTBrIgIkACACQQM2AgwgAkHE84QBNgIIIAJCAjcCFCACQfIENgIsIAIgAEE8ajYCKCACQcwGNgIkIAIgAEEMajYCICACIAJBIGo2AhAgASgCACABKAIEIAJBCGoQywogAkEwaiQAC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHTBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBlQY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALbAEBfyMAQTBrIgIkACACQQM2AgwgAkHE84QBNgIIIAJCAjcCFCACQfIENgIsIAIgAEE8ajYCKCACQacGNgIkIAIgAEEMajYCICACIAJBIGo2AhAgASgCACABKAIEIAJBCGoQywogAkEwaiQAC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHdBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBogY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALaQEBfyAAQQxqEMYMIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCyAAELMmIABBBEEIEOAeC2UBA38CQCAAKAIMIgIgAUECdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEBdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEDdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEEdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEFdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38jAEEQayIDJAAgA0EIakEEIAEQ8x8gAygCCCEBIAMoAgwiBAR/IAQgARCtNgUgAQsiBUUEQCABIAQQoz0ACyAFQoGAgIAQNwIAIAAgAigCADYCBCAAIAU2AgAgA0EQaiQAC2UBAn8jAEEQayIEJAAgBEEIaiABIAIQ8x8gBCgCCCEBIAQoAgwiBQR/IAUgARCtNgUgAQsiAkUEQCABIAUQoz0ACyACQoGAgIAQNwIAIAAgAygCADYCBCAAIAI2AgAgBEEQaiQACxIAIwBBMGsiACQAIABBMGokAAtqAgF/AX4jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQM2AgwgA0HQxIkBNgIIIANCAjcCFCADQoCAgICwByIEIANBBGqthDcDKCADIAQgA62ENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2oCAX8BfiMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCADQdzviQE2AgggA0ICNwIUIANCgICAgLAHIgQgA62ENwMoIAMgBCADQQRqrYQ3AyAgAyADQSBqNgIQIANBCGogAhDvLAALbgEBfyAALQAEIQEgAC0ABQRAIAACf0EBIAFBAXENABogACgCACIBLQAKQYABcUUEQCABKAIAQdfxiQFBAiABKAIEKAIMEQYADAELIAEoAgBB1vGJAUEBIAEoAgQoAgwRBgALIgE6AAQLIAFBAXELcAEEfwJAAn8CQAJAIAAtAFAOBAADAwEDCyAAKAIkIgFFDQJBKCECQTAhA0EsDAELIABBEGoQvCogACgCQCIBRQ0BQcQAIQJBzAAhA0HIAAshBCAAIANqIAAgAmooAgAgACAEaigCACABKAIQEQEACwtvAQF/IwBBMGsiASQAIAAoAgxBgYCAgHhHBEAgASAAQQxqNgIMIAFBAjYCFCABQZiTwwA2AhAgAUIBNwIcIAFBgwE2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQaiTwwAQ7ywACyABQTBqJAALaAEBfyAAKAIAIgBBCGoQhjAgACgCGCIBBEAgACgCHCABKAIMEQMACyAAKAIkIgEEQCAAKAIoIAEoAgwRAwALAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQTRBBBD4OgsLdAEBfwJAAkACQCAALQCABw4EAAICAQILIAAoAtABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQdABahCdJwsgABD4Lg8LIABBsANqEM0kIAAoAqgDIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQagDahCdJwsLYgECfwJAIAAEQCAAQQhrIgEoAgBBAUcNASAAKAIEIAFBADYCAAJAIAFBf0YNACAAQQRrIgAgACgCAEEBayIANgIAIAANACABQRBBBBD4OgsPCxCYPQALQafZwwBBPxCXPQALbQECfyMAQRBrIgIkAAJAIAEoAgBFBEAgAkEIaiABQQRqENw7IAIoAgggAigCDBCTPiEBDAELIAEoAgQgASgCCBCVPSIDEPQ6IQEgA0GEAUkNACADEPIfCyAAIAE2AgQgAEEANgIAIAJBEGokAAvDAQECfyMAQRBrIgIkAAJAAkAgAUUEQAJ/AkAgAARAIABBCGsiASgCAEEBRw0BIAAoAgQgAUEANgIAAkAgAUF/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIAFBEEEEEPg6CwwCCxCYPQALQbDEzABBPxCXPQALIgAQiDUgAEEwQQgQ+DoMAQsgAEUNASACIABBCGsiADYCDCAAIAAoAgBBAWsiADYCACAADQAgAkEMahCnKQsgAkEQaiQADwsQmD0AC2IBAn8CQCAABEAgAEEIayIBKAIAQQFHDQEgACgCBCABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgAUEQQQQQ+DoLDwsQmD0AC0HMyMwAQT8Qlz0AC24BAX8gACkDAEIFUgRAIAAoApgCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZgCahDZIQsgAEGQAmoQvCogAEHQAGoQkyogABD9LiAAKALwAUGAgICAeEcEQCAAQfABahDZLwsgAEGgAWoQwRoLC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDZLyAAQcACahCyLCAAQegCahC0MCAAEM0hC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDaLyAAQcACahCyLCAAQegCahC0MCAAELsfC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDbLyAAQcACahCyLCAAQegCahC0MCAAELwfC2sBAX9BIEEIEK02IgJFBEBBCEEgEKM9AAsgAEGAv80ANgIIIAAgAjYCBCAAQQU2AgAgAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAC3QBAX8CQCAAKAJwRQ0AIAAoAnQiAUUNACAAQYABaiAAKAJ4IAAoAnwgASgCEBEBAAsCQCAAKAKEAUUNACAAKAKIASIBRQ0AIABBlAFqIAAoAowBIAAoApABIAEoAhARAQALIABBmAFqEIUwIABBpAFqEIUwC28BAX8jAEEwayIBJAAgACgCDEGBgICAeEcEQCABIABBDGo2AgwgAUECNgIUIAFBvOjOADYCECABQgE3AhwgAUGDATYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpBzOjOABDvLAALIAFBMGokAAtzAQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCwOO13tL+pZUshSACKQMYQvXOqKjR/trMpH+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3QBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEELCjPf26svc0YR/hSACKQMYQuWT9Jj5r/joqH+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3MBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUBsiAzYCBCAAIAFBACADGzYCACACQSBqJAALYwECfwJAIAIEQCACQQF0IQIgACgCBCEEIAAoAgghAANAIAAgAS4BACIDTQ0CIAQgA0EDdGoiAyADKQMAQgF8NwMAIAFBAmohASACQQJrIgINAAsLDwsgAyAAQcD5zwAQwyEAC1oBAn8jAEEgayICJAAgAkEMaiIDIAFBAUEAEMYsIAIgADYCGCACIABBAWo2AhwgAyACQRhqQZjg0AAQ5BQaIAMgAkEcakGo4NAAEOQUGiADENsbIAJBIGokAAtlAQF/IAAoAgAiACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahCDIAsgAEEIaiIBENErIAEQ6DsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBHEEEEPg6Cwt6AQF/IwBBEGsiAiQAIAIgADYCDCABQfzr0ABBiezQAEEEIABBCGpBrOvQAEGN7NAAQQogAEEgakG869AAQZfs0ABBDiAAQSFqQczr0ABBpezQAEEMIABBFGpB3OvQAEGx7NAAQQIgAkEMakHs69AAENcVIAJBEGokAAtYACACIAFrIQICfyAFRQRAIAEgAiADIAQgBhCtEgwBCyABIAIgAyAEIAYQihILIgJBiH9NBH8gAkUEQEEADwsgASACaiAAayIAQQAgACAEQQFrSRsFIAILC3cBAn9BzI/8ACEDQSAhAgJAAkACQAJAIAAtAKABQQFrDgMAAQIDCyAAQaQBaiEDQbQKIQIMAgsgAEH0KmohA0G0CiECDAELIABBxNQAaiEDQdAEIQILIAEgAkkEQCADIAFBAnRqKAEADwsgASACQdyQ/AAQwyEAC3MBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEEKH+dva19H8mDyFIAIpAxhCtu/otfSlgr6Wf4WEUBsiAzYCBCAAIAFBACADGzYCACACQSBqJAALcwECfyMAQSBrIgIkACACQQhqIAFBPGoQuSYgAkEQaiACKAIIIgMgAigCDCgCDBEAACAAIANBACACKQMQQp/CvqLMv8igIYUgAikDGELWxZTGmP312PgAhYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAt0AQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBC47Di8bKTqs3WAIUgAikDGEKw3+Dy+LaU9Id/hYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAt0AQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCkJ6z7tm0jZLpAIUgAikDGEKI9KuB4LHF5MIAhYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAtzAQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3QBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEEK1w/6+jJyqpsMAhSACKQMYQpL7x5C+7Jj+o3+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuOw4vGyk6rN1gCFIAIpAxhCsN/g8vi2lPSHf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQp/CvqLMv8igIYUgAikDGELWxZTGmP312PgAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCxfnL/5Gu4aXzAIUgAikDGELu9LKa/ZmulEKFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1+Meo1t3Ut75/hSACKQMYQqfy1Pyvr4CpZYWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvqYtvqSporDHIUgAikDGEKjwLrZ1ubhqiaFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1w/6+jJyqpsMAhSACKQMYQpL7x5C+7Jj+o3+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELkqcXy3YrhxjSFIAIpAxhCtcmJlamX+rcZhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCqPiJ3+794vcZhSACKQMYQoKIosHluO7+FoWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQrWospbEp++mTIUgAikDGEL384vm1Y6BzQKFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELcp4bNlJfJvZZ/hSACKQMYQoXw5oWQ2p/jDIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQoaB0JC4h5OjmX+FIAIpAxhCo9XjoNqy+597hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsy0ov2VhIuhZIUgAikDGEL+io38urDbmtwAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCyZCt59O+2ficf4UgAikDGELx8sqr5+fRxsIAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELy/Kme5Y+hnSuFIAIpAxhC2YuNupm+7e+vf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQo2j65PMtMaQ9wCFIAIpAxhC2avs9tngxfSMf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQofA7OjEzr/RyQCFIAIpAxhCvr+ev6/DpIL4AIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtHx98ycuun+ToUgAikDGELWwo+ZmLzyo/EAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC5LbKrM/B44XgAIUgAikDGELN0Z2bnfy4qLl/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC+/bY6vDijZ/GAIUgAikDGEKZhqW/+K+hjtIAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCmcTpt9SjhcVuhSACKQMYQpiWydPQ9J6WrX+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKLtaPljNen43SFIAIpAxhCsKP53sDxp9eEf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpfRsJvd/7iVWYUgAikDGEL8orOPiOix2PYAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCpK/0+qipnZAthSACKQMYQuOs+oXj29D1bIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQof529rX0fyYPIUgAikDGEK27+i19KWCvpZ/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC4tPyx9PVg5z+AIUgAikDGELF2bmBmqaTpYB/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC65CWiN2g5IZghSACKQMYQrmNv6eS/6CCYYWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQr7mw9mBkoazVoUgAikDGEK8v5Wj/azytTeFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELJ4PqEqc+Tli+FIAIpAxhCy92l0q6Ggoz8AIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQu3Flqe9j+DYVIUgAikDGELXg/+44uuX8dwAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC7rfKwcvC5+i5f4UgAikDGELwjuObm4jWixGFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKTk+716KiClmeFIAIpAxhCmJLh6biI4pZphYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCxsy654zqoIW8f4UgAikDGEK60pHvivb0+MwAhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Ou54rzv+NByhSACKQMYQtrjn43Mj+GBqX+FhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKkm/HxpumCqhCFIAIpAxhCzbvaxOvHxIIYhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC2s6AyavF6v3HAIUgAikDGEKb9N23mYvTjj+FhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKGspjZnam3pm6FIAIpAxhC3a+72du2z9ZmhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Pb4rvGI1KEVhSACKQMYQu/K0/2j0b7R8ACFhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELyyPrD9OmMmPMAhSACKQMYQvC4kO3DhNv9ToWEUA0BC0Go8YMBQRBBuPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQq/zkNiUnMf7M4UgAikDGEKgpcX0zdDRpI1/hYRQDQELQcjxgwFBEUHc8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCq5iR8ZX61fyAf4UgAikDGEKWlPir8LHps+EAhYRQDQELQezxgwFBEUGA8oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCvsjTtePru+NihSACKQMYQqyK4YGkm+2Qun+FhFANAQtB/PKDAUEJQYjzgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELhwrPKg/7PuESFIAIpAxhCjanii7uO56xnhYRQDQELQfzygwFBCUGI84MBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC0b7uy62VofSpf4UgAikDGEKHt8DPz47l1JN/hYRQDQELQfzygwFBCUGI84MBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC++Ty4bGz7cN8hSACKQMYQoG3yp62q+3MboWEUA0BC0GY84MBQQpBpPODARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuP/28bZwLK/2gCFIAIpAxhC66qH95GRkJUkhYRQDQELQZjzgwFBCkGk84MBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFANAQtBtPODAUEKQcDzgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsKM9/bqy9zRhH+FIAIpAxhC5ZP0mPmv+Oiof4WEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsKM9/bqy9zRhH+FIAIpAxhC5ZP0mPmv+Oiof4WEUA0BC0Hs84MBQQxB+PODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUA0BC0Hs84MBQQxB+PODARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtPY0/j95vaSSIUgAikDGEKi2J6I4aDq6cwAhYRQDQELQYj0gwFBDEGU9IMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFANAQtBiPSDAUEMQZT0gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK+yNO14+u742KFIAIpAxhCrIrhgaSb7ZC6f4WEUA0BC0GI9oMBQR9BqPaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtG+7sutlaH0qX+FIAIpAxhCh7fAz8+O5dSTf4WEUA0BC0GI9oMBQR9BqPaDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuHCs8qD/s+4RIUgAikDGEKNqeKLu47nrGeFhFANAQtBiPaDAUEfQaj2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELtxZanvY/g2FSFIAIpAxhC14P/uOLrl/HcAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuuQlojdoOSGYIUgAikDGEK5jb+nkv+ggmGFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELktsqsz8HjheAAhSACKQMYQs3RnZud/LiouX+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELi0/LH09WDnP4AhSACKQMYQsXZuYGappOlgH+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEL6mLb6kqaKwxyFIAIpAxhCo8C62dbm4aomhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC3KeGzZSXyb2Wf4UgAikDGEKF8OaFkNqf4wyFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1qLKWxKfvpkyFIAIpAxhC9/OL5tWOgc0ChYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCjaPrk8y0xpD3AIUgAikDGELZq+z22eDF9Ix/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCvubD2YGShrNWhSACKQMYQry/laP9rPK1N4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQu63ysHLwufouX+FIAIpAxhC8I7jm5uI1osRhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCn8K+osy/yKAhhSACKQMYQtbFlMaY/fXY+ACFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKZxOm31KOFxW6FIAIpAxhCmJbJ09D0npatf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuOw4vGyk6rN1gCFIAIpAxhCsN/g8vi2lPSHf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvv22Orw4o2fxgCFIAIpAxhCmYalv/ivoY7SAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQrXD/r6MnKqmwwCFIAIpAxhCkvvHkL7smP6jf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQou1o+WM16fjdIUgAikDGEKwo/newPGn14R/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCyZCt59O+2ficf4UgAikDGELx8sqr5+fRxsIAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsX5y/+RruGl8wCFIAIpAxhC7vSymv2ZrpRChYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCl9Gwm93/uJVZhSACKQMYQvyis4+I6LHY9gCFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKkr/T6qKmdkC2FIAIpAxhC46z6hePb0PVshYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCtfjHqNbd1Le+f4UgAikDGEKn8tT8r6+AqWWFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKo+Inf7v3i9xmFIAIpAxhCgoiiweW47v4WhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC5KnF8t2K4cY0hSACKQMYQrXJiZWpl/q3GYWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsy0ov2VhIuhZIUgAikDGEL+io38urDbmtwAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELR8ffMnLrp/k6FIAIpAxhC1sKPmZi88qPxAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsng+oSpz5OWL4UgAikDGELL3aXSroaCjPwAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCh8Ds6MTOv9HJAIUgAikDGEK+v56/r8OkgvgAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBChoHQkLiHk6OZf4UgAikDGEKj1eOg2rL7n3uFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELy/Kme5Y+hnSuFIAIpAxhC2YuNupm+7e+vf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQof529rX0fyYPIUgAikDGEK27+i19KWCvpZ/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCpJvx8abpgqoQhSACKQMYQs272sTrx8SCGIWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvLI+sP06YyY8wCFIAIpAxhC8LiQ7cOE2/1OhYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBChrKY2Z2pt6ZuhSACKQMYQt2vu9nbts/WZoWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtrOgMmrxer9xwCFIAIpAxhCm/Tdt5mL044/hYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCk5Pu9eiogpZnhSACKQMYQpiS4em4iOKWaYWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvz2+K7xiNShFYUgAikDGELvytP9o9G+0fAAhYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Ou54rzv+NByhSACKQMYQtrjn43Mj+GBqX+FhFANAQtB3fqFAUEmQYT7hQEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELGzLrnjOqghbx/hSACKQMYQrrSke+K9vT4zACFhFANAQtB3fqFAUEmQYT7hQEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK+uaqJmdKNmuAAhSACKQMYQsWRgbqRwsPNNIWEUA0BC0G8/IUBQTlB+PyFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQueZwdKG0azNs3+FIAIpAxhC5ZLhj9uJra5ShYRQDQELQYj9hQFBOEHA/YUBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBClY2j2tTIv9zGAIUgAikDGEKzz/m4y5qOxTKFhFANAQtB0P2FAUE2QYj+hQEQyyQACyACQSBqJAAgAAtmAQJ/IwBBEGsiBSQAIAUgBDYCDCAFIAM2AgggBUEIahCeNiEGIABBADYCECAAIAQ2AgwgACADNgIIIAAgAjYCBCAAIAE2AgAgACAGIAIgAWtBA3YiACAAIAZLGzYCFCAFQRBqJAALZgECfyMAQRBrIgUkACAFIAI2AgwgBSABNgIIIAVBCGoQnjYhBiAAQQA2AhAgACAENgIMIAAgAzYCCCAAIAI2AgQgACABNgIAIAAgBCADa0EDdiIAIAYgACAGSRs2AhQgBUEQaiQAC4sJAhB/Bn4jAEEgayIRJAAgASgCECISIAIoAhBHBEAgEUEANgIIQQAgAUEQaiACQRBqIBFBCGpBgIKIARCvKwALIAEoAgwhBCACKAIMIQ0jAEHQAGsiAyQAIAMgASgCBCABKAIIIAQgEhCHHSADQRRqIAIoAgQgAigCCCANIBIQhx0gAygCHCEOIAMoAhQhDSADKAIIIQ8gAygCACECIAMgAygCICIHIAMoAgwiCCAHIAhJG0EDdCIKNgI0IAohCwJAAkACQAJAAkACQAJAIApBOHEiAQRAIAogAWtBQGsiCyAKSQ0BC0HAACEMIAtBwAAQ0TRFDQEgCwRAIAtBwAAQrTYiDEUNAwsgDCEJAkAgCEUNACAOQT9xrSEWIA9BP3GtIRdBACAOa0E/ca0hGEEAIA9rQT9xrSEUIAIhBSAIIQEgByEEIA0hBgNAIAUpAAAhEyAPBEAgBUEIajEAACAUhiATIBeIhCETCyAERQ0BIAYpAAAhFSAJIA4EfiAGQQhqMQAAIBiGIBUgFoiEBSAVCyATgzcAACAFQQhqIQUgBEEBayEEIAZBCGohBiAJQQhqIQkgAUEBayIBDQALCyADIAkgDGsiATYCKCABIApHDQMgAyAKNgJEIAMgDDYCQCADIAs2AjwgA0HAADYCOCADKAIQIhBBA3ZCACEUIBAEQCACIAhBA3RqIgIxAAAgD0E/ca2IIRMgDyAQaiIBQQN2IAFBB3FBAEdqIgFBAk8EQEEIIA9rIQUgAUEBayEJIAJBAWohBgNAIAYxAAAgBUE/ca2GIBOEIRMgBkEBaiEGIAVBCGohBSAJQQFrIgkNAAsLIBNCfyAQQT9xrYZCf4WDIRQLIBBBB3FBAEdqIQggAyADKAIkIgQEfiANIAdBA3RqIgIxAAAgDkE/ca2IIRMgBCAOaiIBQQN2IAFBB3FBAEdqIgFBAk8EQEEIIA5rIQUgAUEBayEJIAJBAWohBgNAIAYxAAAgBUE/ca2GIBOEIRMgBkEBaiEGIAVBCGohBSAJQQFrIgkNAAsLIBNCfyAEQT9xrYZCf4WDBUIACyAUgzcDKCAIQQlPDQQgCyAIIApqIgFJBEAgA0E4aiALQQF0IgIgARDhKiIBIAEgAkkbEOgZIAMoAkQhCiADKAJAIQwLIAgEQCAKIAxqIANBKGogCPwKAAALIAMoAkAhBCADKAI8IQ0gAygCOCECIAMoAkQhAUEcQQQQrTYiB0UNBSAHIA02AhggByACNgIUIAdBADYCECAHIAQ2AgggB0KBgICAEDcCACAAIAQ2AgQgACAHNgIAIAcgASAIaiIBNgIMIAAgATYCCCADQdAAaiQADAYLQZj8hwFBI0G8/IcBEMskAAtB8/qHAUEpIANBOGpB2PqHAUGc+4cBENUeAAtBwAAgCxCjPQALIANCADcCRCADQoGAgIDAADcCPCADQeD7hwE2AjhBACADQShqIANBNGogA0E4akHo+4cBEK8rAAsgCEEIQfj7hwEQsDsAC0EEQRwQoz0ACyAAIBI2AhAgAEEANgIMIBFBIGokAAtcAQF/An8gAUEQdiABQf//A3FBAEdqIgJAACIBQX9GBEBBACEBQQAMAQsgAkEQdCICQRBrIAIgAUEQdCIBQQAgAmtGGwshAiAAQQA2AgggACACNgIEIAAgATYCAAtkAQN/AkAgASgCBCICQQBIDQAgASgCACEDAkAgAkUEQEEBIQEMAQtBASEEIAJBARCtNiIBRQ0BCyACBEAgASADIAL8CgAACyAAIAI2AgQgACABNgIADwsgBCACQcjBiQEQ/S8AC2AAAkACQAJAAkACQCAALQAgDgUABAQBAgQLIABBCGoQ3jsPCyAAQSRqEJIuDAELIABB8ABqEN8gIABBKGoQ/RsgAEEAOgAhCyAALQAiBEAgAEEUahDeOwsgAEEAOgAiCwtjAQF/QThBBBCtNiIBBEAgAUEAOgA0IAFBADoAMCABQQA2AiggAUEAOgAkIAFBADYCHCABQQA6ABggAUEANgIIIAFCgoCAgBA3AgAgACABNgIEIAAgATYCAA8LQQRBOBCjPQALZwEBf0E0QQQQrTYiAQRAIAFBADoAMCABQQA6ACwgAUEANgIkIAFBADoAICABQQA2AhggAUEAOgAUIAFBgICAgHg2AgggAUKCgICAEDcCACAAIAE2AgQgACABNgIADwtBBEE0EKM9AAvrAgEBfyAAQQRqIQECQAJAAkACQAJAAkAgACgCAA4FAQIEAwQACyABKAIAIgBBhAFJDQQgABDyHw8LAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyABKAIAIgAoAgAiAUGAgICAeHMgAUEAThsOEAABAgMEBQYPBwgJCgsMDQ4PCyAAQQRqEN47DA4LIABBBGoQvCoMDQsgAEEEahDeOwwMCyAAQQRqEN47DAsLIABBBGoQ3jsMCgsgAEEEahDeOwwJCyAAQQRqEN47DAgLIABBBGoQ3jsMBwsgAEEEahDeOwwGCyAAQQRqEN47DAULIAAQ3jsgAEEMahC5LgwECyAAQQRqEN47DAMLIABBBGoQ3jsMAgsgAEEEahDeOwwBCyAAQQRqEN47CyAAQRRBBBD4Og8LIAEoAgAiABDJIyAAQRhBCBD4Og8LIAEoAgAiABChKSAAQQRBBBD4Og8LIAEQ3jsLC20BAX8jAEEwayICJAAgAkGAxsMANgIEIAIgATYCACACQQI2AgwgAkHAu8MANgIIIAJCAjcCFCACQcoBNgIsIAJBywE2AiQgAiAANgIgIAIgAkEgajYCECACIAI2AiggAkEIahChFSACQTBqJAALZwEBfyMAQRBrIgIkACACIAE2AgwCQCACQQxqEM8sRQRAIAIgARC4EiACKAIAIQEgACACKAIENgIEIABBAkEBIAFBAXEbNgIADAELIABBADYCACABQYQBSQ0AIAEQ8h8LIAJBEGokAAteAQN/IAEoAgwiAgR/IAEgAkEBazYCDCABIAEoAggiAkEBaiIDIAEoAgAiBEEAIAMgBE8bazYCCCABKAIEIAJBAnRqKAIAIQFBAQVBAAshAiAAIAE2AgQgACACNgIAC2gBA38CQCAAKAIAIgAoAgwiAUUNACAAKAIQIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEUQQQQ+DoLC2cBAn8jAEEQayICJAACQCABKAIAIgMEQCACIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgAkEANgIAIAIgAS0ABDoABAsgACACKQIANwIAIABBCGogAkEIaikCADcCACACQRBqJAALZgEBfyAAKAIAIgAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+CMLIABBDGoiARDeIyABQQRBFBDgHgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEcQQQQ+DoLC2oBAX8jAEEwayIDJAAgAyACNgIEIAMgATYCACADQQI2AgwgA0HA0cwANgIIIANCAjcCFCADQcoBNgIsIANBywE2AiQgAyAANgIgIAMgA0EgajYCECADIAM2AiggA0EIahChFSADQTBqJAALXwACQCADBEAgAUEYaiEBIAIgA0EEdGohAwNAIAIoAgBFDQIgASACQQRqKAIAIAJBCGooAgAQoTYgAkEQaiICIANHDQALCyAAQQg2AgAPC0Hkh84AQSBBhIjOABDLJAALZAIBfwF+IwBBEGsiAyQAAkAgACACTQRAIANCADcDCCAAQQlPDQEgAARAIANBCGogASAA/AoAAAsgAykDCCADQRBqJAAPC0G0tc4AQSNB2LXOABCfKQALIABBCEHotc4AELA7AAtkAQR/IwBBEGsiASQAAkAgAEUNACAAKAK01QEhAiAAKAIAIAFBCGogAEG41QFqKAIAIgQ2AgAgASAAKQKw1QE3AwAgARCLLSACBEAgBCAAIAIRAAAMAQsgABDSNQsgAUEQaiQAC28AAkACQAJAAkAgAkH/AXFBAWsOAwECAwALIABBP3EPCyAAQfwBcUECdg8LIAFB/wFxQbST4gBqLQAAIABB/wFxQbSR4gBqLQAAcg8LIAFB/wFxQbSV4gBqLQAAIABB/wFxQbSV4gBqLQAAQQN0agtlAQF/IABBDGoQowwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQpgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQpwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQqAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxC/EiACKAIoBEAgAikDMCEIDAMLIAJByABqQY+evPgANgIAIAJCj568+PDhw4cPNwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENUbIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ6hwgAigCKARAIAIpAzAhCAwDCyACQcgAakGIr4ABKAIANgIAIAJBgK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxCOHCACKAIoBEAgAikDMCEIDAMLIAJByABqQayvgAEoAgA2AgAgAkGkr4ABKQIANwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADEL8SIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBj568+AA2AgAgAkKPnrz48OHDhw83A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1hsgAigCKARAIAIpAzAhCAwDCyACQcgAakGFipQoNgIAIAJChYqUqNCgwYIFNwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADEOocIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBiK+AASgCADYCACACQYCvgAEpAgA3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQjhwgAigCKARAIAIpAzAhCAwDCyACQcgAakGsr4ABKAIANgIAIAJBpK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv3AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEgAxCtKiACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL+AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASgCACADEI8sIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1RsgAigCKARAIAIpAzAhCAwDCyACQcgAakGJkqTIADYCACACQomSpMiQocKECTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv3AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxDWGyACKAIoBEAgAikDMCEIDAMLIAJByABqQYWKlCg2AgAgAkKFipSo0KDBggU3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL+AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASgCACADEI8sIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQjhwgAigCKARAIAIpAzAhCAwDCyACQcgAakGsr4ABKAIANgIAIAJBpK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv6AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQvxIgAigCKARAIAIpAzAhCAwDCyACQcgAakGPnrz4ADYCACACQo+evPjw4cOHDzcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxDqHCACKAIoBEAgAikDMCEIDAMLIAJByABqQYivgAEoAgA2AgAgAkGAr4ABKQIANwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/cDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENYbIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBhYqUKDYCACACQoWKlKjQoMGCBTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv6AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1RsgAigCKARAIAIpAzAhCAwDCyACQcgAakGJkqTIADYCACACQomSpMiQocKECTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAtlAQF/IABBDGoQtAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQtgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQuQwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQvgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQwgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtkAQJ/AkAgAkEBaiIEIAEoAkhBAnYiA0kEQCACIANJDQEgAiADQczdhQEQwyEACyAEIANBvN2FARDDIQALIAAgASABKAJEIgAgAkECdGooAgAiASAAIARBAnRqKAIAIAFrEL0QC1sBAn8gACABRgRAQQAPCyABIABrQQN2IQJBACEBA0AgACgCACAAQQRqKAIAIgMoAghBAWtBeHFqQQhqIAMoAlQRBAAgAWohASAAQQhqIQAgAkEBayICDQALIAELYAECfyABKAIcIgQEQCABKAIYIQMDQCADEKUeIANBxABqIQMgBEEBayIEDQALCyABQRRqQQRBxAAQ4B4gAUEcaiACQQhqKAIANgIAIAEgAikCADcCFCAAIAFB3AD8CgAAC2IBAn8jAEEQayIBJAAgACgCACICBEAgASACNgIMIAEgACgCCDYCCCABQQhqQQRBBBDgHgsgACgCECICBEAgASACNgIMIAEgACgCGDYCCCABQQhqQQRBBBDgHgsgAUEQaiQAC/QDAgp/AX4jAEEQayIDJAACQCABKAIEIgRFBEAgAEEIakGg4IcBKQIANwIAIABBmOCHASkCADcCAAwBCyMAQRBrIgIkACACIAJBGEEIIARBAWoQnRQgAigCCCEEIAIoAgQhBSACKAIAIggEQCADIAIoAgw2AgwLIAMgBDYCCCADIAU2AgQgAyAINgIAIAJBEGokACMAQSBrIgYkACADKAIAIQIgASIEKAIAIQEgAygCBEEJaiIFBEAgAiABIAX8CgAACyAEKAIMIgUEQCACQRhrIQogAUEIaiEJIAEpAwBCf4VCgIGChIiQoMCAf4MhDCAGQRRqIQsgBSEIIAEhAgNAIAxQBEADQCACQcABayECIAkpAwAgCUEIaiEJQoCBgoSIkKDAgH+DIgxCgIGChIiQoMCAf1ENAAsgDEKAgYKEiJCgwIB/hSEMCyAGQQhqIAIgDHqnQQN2QWhsaiIHQRhrEN0gIAsgB0EMaxDdICAKIAEgB2tBaG1BGGxqIgcgBikCCDcCACAHQRBqIAZBGGopAgA3AgAgB0EIaiAGQRBqKQIANwIAIAxCAX0gDIMhDCAIQQFrIggNAAsLIAMgBTYCDCADIAQoAgg2AgggBkEgaiQAIABBCGogA0EIaikCADcCACAAIAMpAgA3AgALIANBEGokAAtjAQJ/IwBBEGsiAyQAIAAoAgAhAiAAQQA2AgAgAgRAIAMgAjYCDCACQQhqQQAgARDwFyACIAIoAgBBAWsiADYCACAARQRAIANBDGoQshoLIANBEGokAA8LQYyoiAFBHBCXPQALYwECfyMAQRBrIgMkACAAKAIAIQIgAEEANgIAIAIEQCADIAI2AgwgAkEIakEBIAEQ8BcgAiACKAIAQQFrIgA2AgAgAEUEQCADQQxqELIaCyADQRBqJAAPC0GMqIgBQRwQlz0AC14BBH8gACgCCCICBEAgACgCBCEAA0AgACgCACEDIABBBGooAgAiBCgCACIBBEAgAyABEQMACyAEKAIEIgEEQCADIAEgBCgCCBD4OgsgAEEIaiEAIAJBAWsiAg0ACwsLYAEBfyAAKAIIIgEEQCAAKAIEIQADQAJAIAAoAgBBCEYEQCAAQRBqIABBCGooAgAgAEEMaigCACAAQQRqKAIAKAIQEQEADAELIAAQ8BsLIABBIGohACABQQFrIgENAAsLC3YBAX8CQAJAAkACQCAALQC4Bg4EAAMDAQMLIAAQnC8gACgCsAYiAUGEAU8EQCABEPIfCyAAKAK0BiIAQYMBSw0BDAILIABBmANqEJwvIAAoArAGIgFBhAFPBEAgARDyHwsgACgCtAYiAEGDAU0NAQsgABDyHwsLcAEBfwJAAkACQAJAIAAtAFgOBAADAwEDCyAAEP8pIAAoAigiAUGEAU8EQCABEPIfCyAAKAIsIgBBgwFLDQEMAgsgAEEwahD/KSAAKAIoIgFBhAFPBEAgARDyHwsgACgCLCIAQYMBTQ0BCyAAEPIfCwtfAQJ/AkACQCABBEAgAUEIayIDIAMoAgBBAWoiAjYCACACRQ0BIAEoAgAiAkF/Rg0CIAAgAzYCCCAAIAE2AgQgACABQQhqNgIAIAEgAkEBajYCAA8LEJg9CwALEJk9AAtpAQF/IwBBEGsiAiQAIAIgACgCACIAQQhqNgIMIAFBlJ3DAEGkncMAIABBFGpB5JzDAEGyncMAIABBGGpB9JzDAEG/ncMAIABBGmpB9JzDAEHMncMAIAJBDGpBhJ3DABCxFiACQRBqJAALXwECfwJAAkAgAQRAIAFBCGsiAyADKAIAQQFqIgI2AgAgAkUNASABKAIAIgJBf0YNAiAAIAM2AgggACABNgIEIAAgAUEEajYCACABIAJBAWo2AgAPCxCYPQsACxCZPQALcAEBfwJAAkACQAJAIAAtAEgOBAADAwEDCyAAENocIAAoAiAiAUGEAU8EQCABEPIfCyAAKAIkIgBBgwFLDQEMAgsgAEEoahDaHCAAKAIgIgFBhAFPBEAgARDyHwsgACgCJCIAQYMBTQ0BCyAAEPIfCwtwAQF/AkACQAJAAkAgAC0AUA4EAAMDAQMLIAAQ4iAgACgCJCIBQYQBTwRAIAEQ8h8LIAAoAigiAEGDAUsNAQwCCyAAQSxqEOIgIAAoAiQiAUGEAU8EQCABEPIfCyAAKAIoIgBBgwFNDQELIAAQ8h8LC3ABAX8CQAJAAkACQCAALQBoDgQAAwMBAwsgABDeHyAAKAIwIgFBhAFPBEAgARDyHwsgACgCNCIAQYMBSw0BDAILIABBOGoQ3h8gACgCMCIBQYQBTwRAIAEQ8h8LIAAoAjQiAEGDAU0NAQsgABDyHwsLcAEBfwJAAkACQAJAIAAtAGgOBAADAwEDCyAAENMWIAAoAjAiAUGEAU8EQCABEPIfCyAAKAI0IgBBgwFLDQEMAgsgAEE4ahDTFiAAKAIwIgFBhAFPBEAgARDyHwsgACgCNCIAQYMBTQ0BCyAAEPIfCwtyAQF/AkACQAJAAkAgAC0AkAEOBAADAwEDCyAAEN8UIAAoAkQiAUGEAU8EQCABEPIfCyAAKAJIIgBBgwFLDQEMAgsgAEHMAGoQ3xQgACgCRCIBQYQBTwRAIAEQ8h8LIAAoAkgiAEGDAU0NAQsgABDyHwsLXwEDfwJAIAAoAgAiACgCTCICRQ0AIAAoAlAiAygCACIBBEAgAiABEQMACyADKAIEIgFFDQAgAiABIAMoAggQ+DoLIAAoAgBBAkcEQCAAQRBqEN47CyAAQdQAQQQQ+DoLawEBfyMAQRBrIgMkACADQQhqIAAgAhC6H0GAgMQAIQICQCADKAIIQQFHDQAgAyAAIAEQuh8gAygCAEECRw0AQYCAxAAgAygCBCIAIABBgLADc0GAgMQAa0GAkLx/SRshAgsgA0EQaiQAIAILWgECfyMAQRBrIgEkACABQQRqIAAQhyMgASgCBCgCACABKAIIIgIgAigCAEEBazYCACABKAIMIgIgAigCAEEBayICNgIAIAJFBEAgAUEMahCnKQsgAUEQaiQAC1kBA39BAiEBIAAoAgBBgICAgHhHBEAgACgCCEEDdCECIAAoAgQhAQNAIAIiAARAIABBCGshAiABLQAEIAFBCGohAQ0BCwsgAEEARyEBCyABQQJGIAFyQQFxC+oCAgR/An4jAEEgayIDJAAgA0EIaiEEIwBBMGsiAiQAIAJBDGoiBRDvLyABQQxqKAIAIQECQAJAIAUQ6SkNAANAIAEoAgQiBSABKQMIIgYgBa0iByAGIAdUG6ciBUYEQCACKAIQDQIgBEEEakElQcCj0ABBCxDNGkEBIQEMAwsgASAGQgF8NwMIIAJBIGogAkEMaiABKAIAIAVqLQAAENQmAkAgAi0AIEEERg0AIAIpAyAiBkL/AYNCBFENACAEIAY3AgRBASEBDAMLIAJBDGoQ6SlFDQALCyACQSBqIAJBDGoQzxhBASEBIAIoAiBBAUYEQCAEIAIpAyg3AwhBACEBDAELIARBBGpBJUHAo9AAQQsQzRoLIAQgATYCACACQTBqJABBASEBAkAgAygCCEEBRgRAIAMgAykCDDcDGCAAQQRqIANBGGoQ0AkMAQsgACADKQMQNwMIQQAhAQsgACABNgIAIANBIGokAAvvAgIFfwF+IwBBIGsiAyQAIANBCGohBCMAQTBrIgIkACACQQA6AAsgAkEMaiIFEO8vIAFBDGooAgAhAQJAAkAgBRDpKQ0AA0AgASgCACIFIAJBC2ogBSgCCCIFQQBHIgYQlxogASABKAIEIAZqNgIEIAVFBEAgAigCEA0CIARBBGpBJUHc880AQQsQzRpBASEBDAMLIAJBIGogAkEMaiACLQALENQmAkAgAi0AIEEERg0AIAIpAyAiB0L/AYNCBFENACAEIAc3AgRBASEBDAMLIAJBDGoQ6SlFDQALCyACQSBqIAJBDGoQzxhBASEBIAIoAiBBAUYEQCAEIAIpAyg3AwhBACEBDAELIARBBGpBJUHc880AQQsQzRoLIAQgATYCACACQTBqJABBASEBAkAgAygCCEEBRgRAIAMgAykCDDcDGCAAQQRqIANBGGoQ0AkMAQsgACADKQMQNwMIQQAhAQsgACABNgIAIANBIGokAAtQAQF/IABBBGohAEF/IAIgAkEASBtBAWohAgNAIAIEQCACQQFrIQIgAyAALQAARSABKAIAQQBHcXIhAyAAQQRqIQAgAUEEaiEBDAELCyADRQtkAQF/Qbh/IQMCQCABQQNJDQAgAC0AAiEBIAIgAC8AACIAQQFxNgIEIAIgAEEBdkEDcSIDNgIAIAIgACABQRB0ckEDdiIANgIIAkACQCADQQFrDgMCAQABC0FsDwsgACEDCyADC1kCAX8BfiAAUARAQQFCACABIAIgAxDlEg8LQQFCASABIAIgAxDlEkEDIAB5p0E/c0EAIABCAVIbIgStIgUgASACIAMQ5RIgBEJ/IAWGIAB8IAEgAiADEOUSC2ABA38gACgCCCIDQQJqIgQgACgCBCIFTwRAIAQgBUHEwvsAEMMhAAsgACADQQNqNgIIIAAoAgAgBGogAjoAACABIAJB/wFxQQJ0aiIAIAAvAQRBAWo7AQQgAyAFQQZrRgtsACABKAIAIAIQmiVFBEAgACADIAQgASgCDCIAIAJsIgIgACACaiABKAIQIAEoAhQQoRIPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALLAEBfyABKAIIQQxqIAIQkhkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LLAEBfyABKAIIQQxqIAIQyBkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LLAEBfyABKAIIQQxqIAIQ3xkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHYzoQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBsM+EATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQYjQhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg0IQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBuNGEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZDShAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo0oQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBwNOEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZjUhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALwAIBBn8jAEEwayIFJAAjAEEwayIEJAAgBCABENAGIwBBEGsiBiQAIAFBDGoiCCgCACIHIAcoAgAiCUEBajYCACAJQQBIBEAACyAGIAc2AgQgBiAIKQIENwIIIARBDGogBkEEaiACIAMQgR0gBkEQaiQAAkAgASgCGARAIARBGGogAUEYaiACIAMQsR8MAQsgBEEANgIYCyAFIAQpAgA3AgAgBSAEKQIMNwIMIAUgBCkCGDcCGCAFQQhqIARBCGooAgA2AgAgBUEUaiAEQRRqKAIANgIAIAVBIGogBEEgaikCADcCACAFQShqIARBKGopAgA3AgAgBEEwaiQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHw1IQBNgIEIAAgATYCACAFQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABByNWEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQaDWhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEH41oQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC8ACAQZ/IwBBMGsiBSQAIwBBMGsiBCQAIAQgARDQBiMAQRBrIgYkACABQQxqIggoAgAiByAHKAIAIglBAWo2AgAgCUEASARAAAsgBiAHNgIEIAYgCCkCBDcCCCAEQQxqIAZBBGogAiADEP8cIAZBEGokAAJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgBSAEKQIANwIAIAUgBCkCDDcCDCAFIAQpAhg3AhggBUEIaiAEQQhqKAIANgIAIAVBFGogBEEUaigCADYCACAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0NeEATYCBCAAIAE2AgAgBUEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQajYhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEGA2YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCHGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB2NmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAv9AQECfyMAQTBrIgUkACMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC2JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgBSAEKQIANwIAIAUgBCkCDDcCDCAFIAQpAhg3AhggBUEIaiAEQQhqKAIANgIAIAVBFGogBEEUaigCADYCACAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABBsNqEATYCBCAAIAE2AgAgBUEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhxhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQYjbhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg24QBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBuNyEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAvAAgEGfyMAQTBrIgUkACMAQTBrIgQkACAEIAEQ0AYjAEEQayIGJAAgAUEMaiIIKAIAIgcgBygCACIJQQFqNgIAIAlBAEgEQAALIAYgBzYCBCAGIAgpAgQ3AgggBEEMaiAGQQRqIAIgAxCCHSAGQRBqJAACQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAUgBCkCADcCACAFIAQpAgw3AgwgBSAEKQIYNwIYIAVBCGogBEEIaigCADYCACAFQRRqIARBFGooAgA2AgAgBUEgaiAEQSBqKQIANwIAIAVBKGogBEEoaikCADcCACAEQTBqJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAAQZDdhAE2AgQgACABNgIAIAVBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo3YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCJGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBwN6EATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhxhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZjfhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHw34QBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABByOCEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQaDhhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIkYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEH44YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB0OKEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQajjhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEGA5IQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC7MBAQN/IwBBEGsiAiQAIAIgAEEIajYCDCACIAAoAgQiATYCCCACIAAoAgAiADYCBCABKAIAIgMEQCAAIAEoAghBAWtBeHFqQQhqIAMRAwALAkAgAkEEaiIBKAIAIgBBf0YNACAAIAAoAgQiA0EBazYCBCADQQFHDQAgASgCBCIBKAIEQQQgASgCCCIBIAFBBE0bIgFqQQdqQQAgAWtxIgNFDQAgACADIAEQ+DoLIAJBEGokAAvxBQINfwF+IwBBMGsiByQAIwBBMGsiBCQAIAQgAzYCECAEIAI2AgwCQCABKAIkBEAgBEEgaiABQSRqIAIgAxC4JiAEKQIkIREgBCgCICECIARBFGogARDhFAwBCyABKAIIIQIgBCABKAIEIgM2AiAgBCADIAJBA3RqNgIkIAQgBEEQajYCLCAEIARBDGo2AigjAEEgayICJAAgAkEUaiAEQSBqIgMoAgQgAygCAGtBA3ZBAEEEQQgQoBggAigCGCEIIAIoAhRBAUYEQCAIIAIoAhxByP+FARD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIIJAAgAygCBCADKAIAa0EDdiIJIAJBCGoiBSgCACAFKAIIIgZrSwRAIAUgBiAJQQRBCBDeKCAFKAIIIQYLIAggBSgCBDYCDCAIIAY2AgggCCAFQQhqNgIEIwBBEGsiBiQAIAhBBGoiCigCBCEJIAooAgAgAygCACIFIAMoAgQiDEcEQCADKAIMIQ8gAygCCCEQIAooAgggCUEDdGohAyAJIAwgBWtBA3YiCmohCQNAIAMgBSgCACIMBH8gBkEIaiAMIAVBBGooAgAiCygCCEEBa0F4cWpBCGogECgCACAPKAIAIAsoAiARBQAgBigCDCELIAYoAggFQQALNgIAIANBBGogCzYCACAFQQhqIQUgA0EIaiEDIApBAWsiCg0ACwsgCTYCACAGQRBqJAAgCEEQaiQAIARBFGoiA0EIaiANKAIANgIAIAMgAikCCDcCACACQSBqJABBACECCyAHQQxqIAFBDGoQ1wYgB0EYaiABQRhqIAQoAgwgBCgCEBC1JiAHIBE3AiggByACNgIkIAcgBCkCFDcCACAHQQhqIARBHGooAgA2AgAgBEEwaiQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAdBMPwKAAAgAEH8h4YBNgIEIAAgATYCACAHQTBqJAAPC0EEQTgQoz0AC2IBAn8jAEEgayIDJAAgA0EMaiABQQEQkRoCQCADKAIMIgRBk4CAgHhHBEAgACADKQIQNwIEIABBDGogA0EYaikCADcCACAAIAQ2AgAMAQsgACABQQAgAhDFDgsgA0EgaiQAC2ABA38CQCAAKAIMIgIgAWoiAyACTQ0AIAAoAgQiBCADSQRAIAAgBEEBdCICIAMQ3SoiBCACIARLGxDoGSAAKAIMIQILIAFFDQAgACgCCCACakEAIAH8CwALIAAgAzYCDAtVAQJ/AkAgASADRw0AIAEEQANAIAAoAgAiAyACKAIAIgVHBEAgA0EIaiAFQQhqEN8nRQ0DCyAAQQRqIQAgAkEEaiECIAFBAWsiAQ0ACwtBASEECyAEC1gBAX4CQCACIAFCgICAgICAgICAf30gAVStfEIAUiACIASFQgBTcg0AIANCAX1CflQgBCADUK19IgJCf1IgAkJ/URsNACAAIAE3AwhCASEFCyAAIAU3AwALXAECfyMAQRBrIgEkACAALQAUIQIgAEEBOgAUIAEgAEEIayIANgIMAkAgAkUEQBCUDSAAEP0eDAELIAAgACgCAEEBayIANgIAIAANACABQQxqEKorCyABQRBqJAALawIBfwFvIwBBEGsiBCQAIAEoAgAlASACKAIAJQEgAygCACUBEEghBRDfEiIBIAUmASAEQQhqEM4tQQEhAyAAAn8gBCgCCEEBcQRAIAQoAgwMAQtBACEDIAELNgIEIAAgAzYCACAEQRBqJAALXgEDfyAAKAIEIQEgAC0AACIAQQRNIABBA0dxRQRAIAEoAgAhACABQQRqKAIAIgMoAgAiAgRAIAAgAhEDAAsgAygCBCICBEAgACACIAMoAggQ+DoLIAFBDEEEEPg6CwtkAQN/AkACQCAAKAIEIgJFDQAgACgCACIAKAIIIgEgAkkNASAAQQA2AgggASACRg0AIAEgAmsiAQRAIAAoAgQiAyACIANqIAH8CgAACyAAIAE2AggLDwsgAiABQZCoiQEQsDsAC1cBAX8jAEEQayIDJAAgA0EEaiACEJctIAEEQANAIAMgADYCDCADQQRqIANBDGpBoMCJARDJFCAAQQFqIQAgAUEBayIBDQALCyADQQRqEKksIANBEGokAAtWAQF+AkAgA0HAAHFFBEAgA0UNASACIANBP3GtIgSGIAFBACADa0E/ca2IhCECIAEgBIYhAQwBCyABIANBP3GthiECQgAhAQsgACABNwMAIAAgAjcDCAtWAQF+AkAgA0HAAHFFBEAgA0UNASACQQAgA2tBP3GthiABIANBP3GtIgSIhCEBIAIgBIghAgwBCyACIANBP3GtiCEBQgAhAgsgACABNwMAIAAgAjcDCAtsAQF/AkACQAJAIAAtAPgCDgQAAgIBAgsgACgCAEUNASAAKAIEIgBBhAFJDQEgABDyHw8LIABBuAFqEMIKIAAoAvQCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfQCahD4IwsgAEEIahCBKgsLKgACQAJAAkAgACgCAA4GAgICAgEAAQsgAEEEahC8KgsPCyAAQQRqEN47C2QBAX9BIEEIEK02IgJFBEBBCEEgEKM9AAsgAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAIABBnN7CADYCBCAAIAI2AgALXwEEfyAAIAEoAgQiBCABKAIAIgJrENgtIAAoAgghAyACIARHBEAgACgCBCEFA0AgAyAFaiACLQAAOgAAIANBAWohAyACQQFqIgIgBEcNAAsgASACNgIACyAAIAM2AggLYgEBfyAAKAIAIgAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+CMLIABBDGoiARDDJyABEOo7AkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLYQECfwJAIAAoAgAiAUEBRw0AIAAoAgQNACAAKAIIIQEgACgCDCICBEADQCABKAIUIQEgAkEBayICDQALCyAAQgA3AgggACABNgIEQQEhASAAQQE2AgALIABBBGpBACABGwtnACAAIAEoAiQ2AiQgACABLwEoOwEoIAAgASkCFDcCFCAAIAIpAgA3AgggACABKQIANwIAIABBHGogAUEcaikCADcCACAAQRBqIAJBCGooAgA2AgAgAUEIaiIAEKInIABBBEEEEOAeC2EBAX8gAEE0ahC0DAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIAAQkCkgACgCQCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEFAaxD7HgsLWAEBfyMAQRBrIgMkACABBEAgACABQQN0aiEBA0AgAyAALQAAOgAPIAIgA0EPakEBELsJIABBBGooAgBBCGogAhDZCiAAQQhqIgAgAUcNAAsLIANBEGokAAthAQF/IABBNGoQvgwCQCAAKAJMIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBzABqEPseCyAAENIoIAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ+x4LC2EBAX8gAEE0ahDDDAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIAAQ1iggACgCQCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEFAaxD7HgsLXAEBfyMAQRBrIgMkACADIAE2AgggAyACNgIMIAAgASACKAIIQQFrQXhxakEIaiACKAIUEQAAIAEgASgCACIAQQFrNgIAIABBAUYEQCADQQhqELsjCyADQRBqJAALWwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCVBEEACAAKAIUQQhqKAIQaiAAKAIgQQhqKAIQakHEAGohASAAKAIsIgAEfyABIABBCGooAhBqBSABCwtjAQF/IwBBMGsiAiQAIAJBAjYCECACQfirhgE2AgwgAkIBNwIYIAJBOzYCKCACIAAoAgA2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCiACQTBqJAALTQECfgJAIAIgBIVCAFMNACADQgF8IgNCAVYgBCADUK18IgNCAFIgA1AbDQAgACABNwMQIAAgAjcDGEIBIQYLIAAgBjcDACAAIAU3AwgLYAECfyMAQTBrIgEkACABIAAoAiAiAjYCKCABIAApAwg3AyAgASAAKQMANwMYIAEgACkDGDcDECABIAApAxA3AwggASACIAAoAiRBA3RqNgIsIAFBCGoQ4CcgAUEwaiQAC1wBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQ9RgPCyAEIAQoAggiAUEBajYCCCABQQBOBEAgACAENgIMIAAgAzYCCCAAIAI2AgQgAEGAiIgBNgIADwsAC2ABAX8gACgCACIAKAIUIgEEQCAAKAIYIAEoAgwRAwALIAAoAiAiAQRAIAAoAiQgASgCDBEDAAsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBMEEEEPg6CwtgAQN/IwBBIGsiAiQAIAIgACgCACIDKAIEIgQ2AgQgASgCACAERwRAIAJBADYCCCACQQRqIAEgAkEIakHMoMMAEPUqAAsgACABKAIINgIEIAMgASgCBDYCCCACQSBqJAALZgEBfyMAQRBrIgIkACACIAAoAgAiADYCDCABQfi9wwBBiL7DACAAQQxqQci9wwBBlr7DACAAQRBqQdi9wwBBo77DACAAQRJqQdi9wwBBsL7DACACQQxqQei9wwAQsRYgAkEQaiQAC1sBBH8gACgCCCICKAIAIAAoAhAiAyAAKAIMIgRqIgVrIAFJBEAgAiAFIAFBAUEBEMUoCyABIARqIQEgAwRAIAIoAgQiAiABaiACIARqIAP8CgAACyAAIAE2AgwLYgECfyMAQRBrIgIkACACQQRqIAFBAEEEQQgQoBggAigCCCEBIAIoAgRBAUYEQCABIAIoAgxB3P3FABD9LwALIAIoAgwhAyAAQQA2AgggACADNgIEIAAgATYCACACQRBqJAALWwECfyAAKAIIIgIEQCAAKAIEQQxqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPgjCyAAQQxrIgEQwycgARDqOyAAQRRqIQAgAkEBayICDQALCwtiAgF/AX4CQCABKQMAQgZ9IgRCAVgEQCAEp0EBaw0BQdTUzQBBC0GU1s0AEMskAAsgACABIAJBABD4FA8LIAEgASgCSCIDIAMgAiACIANLGyICazYCSCAAIAFBCGogAhDdDgtUAQF/QYAQQQIQrTYiAgRAIAJBAEGAEPwLACAAQgM3AwAgAEIANwJEIAAgAjYCQCAAQcwAakEAOgAAIABBwAAgAa3DeadrOgBNDwtBAkGAEBCjPQALYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJB0PfOADYCECACQgE3AhwgAkGMCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAthAQF/IwBBMGsiAiQAIAIgADYCDCACQQE2AhQgAkHQ984ANgIQIAJCATcCHCACQY0INgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywogAkEwaiQAC2EBAX8jAEEwayICJAAgAiAANgIMIAJBATYCFCACQdD3zgA2AhAgAkIBNwIcIAJBjgg2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCiACQTBqJAALYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJB0PfOADYCECACQgE3AhwgAkGPCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAtOAQF/IABBBGohAEF/IAIgAkEASBtBAWohAgNAIAIEQCACQQFrIQIgAC0AACABKAIAbCADaiEDIAFBBGohASAAQQRqIQAMAQsLIANBA3YLZQACQAJAAkAgAkEFaw4CAQIACyADpyAAKAAAQbHz3fF5bHNBICABa3YPCyAAKQAAQoCAgNjLm++NT34gA4VBwAAgAWutiKcPCyAAKQAAQoCA7PzLm++NT34gA4VBwAAgAWutiKcLYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJBuMzRADYCECACQgE3AhwgAkH7CjYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAtbAQF+QQFCACACIAMgBBDfE0ECQgRCBUIGIABBgYDAAEkbIABBgYAESRsiBUIEfSACIAMgBBDfEyAFp0ECdCAAQQFrrSACIAMgBBDfE0EBIAGtIAIgAyAEEN8TC2MBAX8jAEFAaiIEJAAgBEIBNwIwIARBATsBOCAEQQE6ADwgBEEAOgA6IARBADYCKCAEQQA2AiAgBEEANgIYIARBADYCECAEQQA2AgggACABIAIgAyAEQQhqEIYBIARBQGskAAtiAQJ/IwBBEGsiAiQAIAJBBGogAUEAQQRBCBCgGCACKAIIIQEgAigCBEEBRgRAIAEgAigCDEGQnoIBEP0vAAsgAigCDCEDIABBADYCCCAAIAM2AgQgACABNgIAIAJBEGokAAtaAQJ/IAIgAWsiA0EEdiIEIAAoAgAgACgCCCICa0sEQCAAIAIgBEEQQRAQ3iggACgCCCECCyADBEAgACgCBCACQQR0aiABIAP8CgAACyAAIAAoAgggBGo2AggLXgICfwF+IwBBIGsiASQAIAFBCGpBtMiEASgCACICNgIAIAFBrMiEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakGIyYQBKAIAIgI2AgAgAUGAyYQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQZTJhAEoAgAiAjYCACABQYzJhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBrMmEASgCACICNgIAIAFBpMmEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakHQyYQBKAIAIgI2AgAgAUHIyYQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQfTJhAEoAgAiAjYCACABQezJhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBjMqEASgCACICNgIAIAFBhMqEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakGYyoQBKAIAIgI2AgAgAUGQyoQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQbDKhAEoAgAiAjYCACABQajKhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBvMqEASgCACICNgIAIAFBtMqEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakHUyoQBKAIAIgI2AgAgAUHMyoQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2sBAX8jAEHgAGsiAiQAIAJBADsBXCACQQA2AlggAkEANgJAIAJBADYCNCACIAE2AjAgAkEAOgAkIAJCBDcCHCACQgA3AhQgAkKAgICAwAA3AgwgAkEANgIEIAAgAkEEahDNHCACQeAAaiQAC14BAX8gACgCACIAKAIIIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQhqEIUdCyAAQRBqEJMnAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQTBBCBD4OgsLXQECfyAAKAIAIgFBfyABKAIEIgIgAkEBRhs2AgQCQCACQQFHDQAgAUEBNgIEIAEoAgBBAUcNACABIAAoAgQiACgCCEEBa0F4cWpBCGoiAUUNACABIAAoAiwRAwALC1sBAn8gASgCECIDIAEoAghGBEAgAUEIakGchIcBEJAoCyABKAIMIANBDGxqIgQgAikCADcCACAEQQhqIAJBCGooAgA2AgAgASADQQFqNgIQIAAgAUHcAPwKAAALYAEDfyMAQRBrIgIkACACQQhqIAEQ4x0gAigCDCEDIAIoAgghBEEIQQQQrTYiAUUEQEEEQQgQoz0ACyABIAQ2AgAgASADNgIEIABB1JiHATYCBCAAIAE2AgAgAkEQaiQAC2IBA38jAEEQayICJAAgAkEIaiABQQAQ5x0gAigCDCEDIAIoAgghBEEIQQQQrTYiAUUEQEEEQQgQoz0ACyABIAQ2AgAgASADNgIEIABBhJmHATYCBCAAIAE2AgAgAkEQaiQAC2ABA38jAEEQayICJAAgAkEIaiABEOYdIAIoAgwhAyACKAIIIQRBCEEEEK02IgFFBEBBBEEIEKM9AAsgASAENgIAIAEgAzYCBCAAQcyZhwE2AgQgACABNgIAIAJBEGokAAuEBAEJfyMAQSBrIgQkACABKAIIIQIgASgCBCEDIAQgASgCADYCGCAEIAM2AhQgBCADNgIQIAQgAyACQcgAbGo2AhwgBEEIaiEIIARBEGohBSMAQfAAayIBJAAjAEEQayIDJAAgAyACNgIIIAJBgICAgAJPBEBB2OCHAUErIANBD2pByOCHAUGE4YcBENUeAAsgA0EEIAJBAnQgA0EIahDAISADKAIEIQIgAUEIaiIGIAMoAgA2AgAgBiACNgIEIANBEGokACABKAIMIQYgASgCCCEDIAFBGGogBUEIaikCADcDACABIAUpAgA3AxAgAUEANgIgAkACQAJAIAEoAhQiAiABKAIcRg0AIANBCGohBQNAIAEgAkHIAGo2AhQgAigCNCIHQYCAgIB4Rg0BIAFBOGoiCSACQTT8CgAAIAFBMGoiCiACQUBrKQMANwMAIAEgAikDODcDKEHQAEEIEK02IgJFDQIgAkKBgICAEDcDACACQQhqIAlBNPwKAAAgAiAHNgI8IAIgASkDKDcDQCACQcgAaiAKKQMANwMAIAEgASgCICIHQQFqNgIgIAUgB0ECdGogAjYCACABKAIUIgIgASgCHEcNAAsLIAFBEGoQ0BwgCCAGNgIEIAggAzYCACABQfAAaiQADAELQQhB0AAQoz0ACyAAIAQpAwg3AwAgBEEgaiQAC2EBAX8jAEEwayICJAAgAiAANgIMIAJBATYCFCACQcjzhwE2AhAgAkIBNwIcIAJBoh02AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCiACQTBqJAALYQIBfwFvIwBBEGsiBCQAIAEgAiADKAIAJQEQFyEFEN8SIgEgBSYBIARBCGoQzi1BASEDIAACfyAEKAIIQQFxBEAgBCgCDAwBC0EAIQMgAQs2AgQgACADNgIAIARBEGokAAtlAgF/AW8jAEEQayIEJAAgASgCACUBIAIgAxAgIQUQ3xIiASAFJgEgASECIARBCGoQzi1BASEBIAACfyAEKAIIQQFxBEAgBCgCDAwBC0EAIQEgAgs2AgQgACABNgIAIARBEGokAAtkAgF/AW8jAEEQayIDJAAgASgCACUBIAIoAgAlARBHIQQQ3xIiASAEJgEgA0EIahDOLUEBIQIgAAJ/IAMoAghBAXEEQCADKAIMDAELQQAhAiABCzYCBCAAIAI2AgAgA0EQaiQAC14BAn8jAEEgayIDJAAgACgCACIEEJw+IQAgAyACNgIEIAMgADYCACAAIAJHBEAgA0EANgIIQQAgAyADQQRqIANBCGpB5KuIARCvKwALIAEgAiAEJQEQWCADQSBqJAALZAECfyMAQSBrIgYkACABRQRAQfCsiAFBMhCXPQALIAZBFGoiByABIAMgBCAFIAIoAhARBwAgBkEIaiAHQeCsiAEQmCEgBiAGKAIIIAYoAgwQtTYgACAGKQMANwIAIAZBIGokAAtYAQJ/IAAgASgCACIDQQBHENctIAAoAgghAiAAIAMEfyAAKAIEIAJBBHRqIgAgAzYCACAAIAEpAgQ3AgQgAEEMaiABQQxqKAIANgIAIAJBAWoFIAILNgIIC78BAQN/AkACQAJAQQEgACgCACIBQf////8HaiABQYCAgIB4TRtBAWsOAgABAgsgACgCFCEBIAAoAhgiAigCACIDBEAgASADEQMACyACKAIEIgMEQCABIAMgAigCCBD4OgsgACgCHCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEcahD4IwsgABCPMA8LIAAoAgQhASAAKAIIIgAoAgAiAgRAIAEgAhEDAAsgACgCBCICRQ0AIAEgAiAAKAIIEPg6CwvkBQEHfyMAQRBrIgUkACAALQDcASEHIABBAToA3AEgBSAANgIMIwBBEGsiBiQAIABBCGoiAikDAEIDUgRAIAIoApgBIgEgASgCACIBQQFrNgIAIAFBAUYEQCACQZgBahCXFQsgAigCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIAJBnAFqEPgjCyAGIAJB0ABqIgEgAigCXBD4GCABEOk7IAIoAoABQYCAgIB4RwRAIAJBgAFqEN47CyACKAKMAUGAgICAeEcEQCACQYwBahDqOwsCQCACKQMAQgJRDQAgAigCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAkE8ahCXFQsCQCACKAJAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBQGsQ2x4LAkAgAigCAEUEQCACKAIQIgFBhAFJDQEgARDyHwwBCyACQRBqEN47IAIoAhwiASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBHGoQnScLIAIoAjBBgICAgHhHBEAgAkEwaiIBEIEjIAFBBEEIEOAeCyACKAJEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBxABqEIEsCwJAAkACQEEBIAIoAmAiAUH/////B2ogAUGAgICAeE0bQQFrDgIAAQILIAIoAnQhASACKAJ4IgQoAgAiAwRAIAEgAxEDAAsgBCgCBCIDBEAgASADIAQoAggQ+DoLIAIoAnwiASABKAIAIgFBAWs2AgAgAUEBRgRAIAJB/ABqEPgjCyACQeAAaiIBKAIAQYCAgIB4Rg0BIAEQ0C4gARDqOwwBCyACKAJkIQEgAigCaCIEKAIAIgMEQCABIAMRAwALIAQoAgQiA0UNACABIAMgBCgCCBD4OgsgAkGoAWoiAhDeIyACEOA7CyAGQRBqJAAgAEIDNwMIAkAgBw0AIAAgACgCACIAQQFrNgIAIABBAUcNACAFQQxqELYfCyAFQRBqJAAL9AEBBH8jAEEQayIDJAAgAC0AdCEEIABBAToAdCADIAA2AgwCQCAAQQhqIgEoAgBFDQACQAJAIAEtAEwOBAACAgECCyABQUBrEN47IAEoAjwiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAFBPGoQnScMAQsCQAJAIAEtADgOBAACAgECCyABQRhqEN47IAEoAjAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBMGoQnScLIAFBJGoQ3jsMAQsgAUE0ahCuLAsgAEIANwMIAkAgBA0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQxqELcfCyADQRBqJAALkwEBA38jAEEQayICJAAgAC0AVCEDIABBAToAVCACIAA2AgwCQCAAQQhqIgEoAgBFDQACQAJAIAEtACwOBAACAgECCyABKAIQIgFBhAFJDQEgARDyHwwBCyABQShqEK4sCyAAQgA3AwgCQCADDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBDGoQuB8LIAJBEGokAAvjAQECfyMAQeAAayICJAACQAJAIAFFBEAjAEHwAGsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQegA/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HwAEEIEPg6CyACIAFBEGpB4AD8CgAAIAFB8ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACEJsnDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ6SoLIAJB4ABqJAAPCxCYPQAL4QEBAn8jAEFAaiICJAACQAJAIAFFBEAjAEHQAGsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQcgA/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HQAEEIEPg6CyACIAFBEGpBwAD8CgAAIAFB0ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACEP8oDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ6yoLIAJBQGskAA8LEJg9AAvjAQECfyMAQcACayICJAACQAJAIAFFBEAjAEHQAmsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQcgC/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HQAkEIEPg6CyACIAFBEGpBwAL8CgAAIAFB0AJqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACENgSDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ7SoLIAJBwAJqJAAPCxCYPQALkAEBA38gACgCACEBAkADQCABKAIEIQADQCAAQX9GDQEgAEEASA0CIAEgAEEBaiABKAIEIgIgACACRhs2AgQgACACRyACIQANAAsLIAEPCyMAQSBrIgAkACAAQQE2AgQgAEGgq4gBNgIAIABCATcCDCAAQoybw4DwKDcDGCAAIABBGGo2AgggAEGUm8MAEO8sAAteAQF/IwBBMGsiAiQAIAIgATYCDCACIAA2AgggAkECNgIUIAJBhLzDADYCECACQgE3AhwgAkHMATYCLCACIAJBKGo2AhggAiACQQhqNgIoIAJBEGoQoRUgAkEwaiQAC3IBAX9BASECAkAgACABQbSGxABBBBDBLg0AIAAgAUG4hsQAQQUQwS4NACAAIAFBvYbEAEECEMEuDQAgACABQb+GxABBAxDBLg0AIAAgAUHChsQAQQMQwS4NAEEAQQIgACABQcWGxABBBBDBLhshAgsgAgtQAQJ/IwBBEGsiAiQAIAJBBGogABCHIyACKAIEIgAoAggiAyABTQRAIAEgA0HwxMwAEMMhAAsgACgCBCACQQRqEPwqIAJBEGokACABQQZ0agtcAQF/IwBBEGsiAiQAAkACQCABRQRAIAIgABD4FyACEP8qDAELIABFDQEgAiAAQQhrIgA2AgAgACAAKAIAQQFrIgA2AgAgAA0AIAIQ1iILIAJBEGokAA8LEJg9AAtXACAAIAAoAoAIIANqNgKACCACIANPBEAgAwRAA0AgACABLQAAQQJ0aiICIAIoAgBBAWo2AgAgAUEBaiEBIANBAWsiAw0ACwsPCyADIAJBvOrMABCwOwALbgIBfwJ+IwBBEGsiAyQAIANB8LHNABClKyADKQMAIQQgAykDCCEFIABBCGpBiLLNACkDADcDACAAQYCyzQApAwA3AwAgAEEANgIoIAAgAjYCJCAAIAE2AiAgACAFNwMYIAAgBDcDECADQRBqJAALXgECfyMAQSBrIgIkACABQf8BcSIDQQFGIANBB0ZyRQRAIAAgAToAKyACQSBqJAAPCyACQQA2AhggAkEBNgIMIAJB8LHOADYCCCACQgQ3AhAgAkEIakH4sc4AEO8sAAtzAgF/An4jAEEQayICJAAgAkG8yP4AEKUrIAIpAwAhAyACKQMIIQQgAEEIakHQyP4AKQMANwMAIABByMj+ACkDADcDACAAIAE6ACwgAEEANgIoIABCgICAgIABNwMgIAAgBDcDGCAAIAM3AxAgAkEQaiQAC2wCAX8CfiMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAIAIpAxghAyACKQMQIQQgAkEgaiQAIABBACAEQtPY0/j95vaSSIUgA0Ki2J6I4aDq6cwAhYRQGwtsAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBELH2fTn3sS2nHeFIANCjbLOlIzKkuanf4WEUBsLVgECfyMAQRBrIgMkACADIAIoAgA2AgggAyACKAIEIgQ2AgAgAyAENgIEIAMgBCACKAIIQQxsajYCDCABQQhqIAMQriYgACABQdwA/AoAACADQRBqJAALYgEBfyMAQRBrIgIkACACIAEQyi8gAiACKAIANgIMIAJBDGoQ0R8hASAAQgE3AwAgACACKAIIQcCEPW6tIAI1AgQgAaxCgKMFfnxC6Ad+fEKA6My6sZAOfTcDCCACQRBqJAALVwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACAAKAIUQQhqKAIQaiAAKAIgQQhqKAIQaiEBIAAoAiwiAAR/IAEgAEEIaigCEGoFIAELC9IBAQh/IwBBIGsiAiQAIAIgARDcOyACQQhqIQMCQCACKAIEIgEgAigCACIEQQdqQXhxIARrIgVJBEBBASEIQQghCQwBCyAEIAVqIgkgASAFayIBQXhxaiEIIAFBB3EhByABQQN2IQYgBSEBCyADIAc2AhQgAyAINgIQIAMgBjYCDCADIAk2AgggAyABNgIEIAMgBDYCACACKAIcIAIoAgxyBEBBtKWHAUE4QeylhwEQnykACyACKAIQIQEgACACKAIUNgIEIAAgATYCACACQSBqJAALXwECfyAALQA8QR1GBEAgACgCKCICBEAgACgCJCEDIAJBzAFsIQIgACgCQCABbCEAA0AgAyAAEIcXIANBzAFqIQMgAkHMAWsiAg0ACwsPC0HIpocBQShBqKeHARCfKQALWQEBfyABKAIAIgRBAXEEQCAAIAEgBCAEIAIgAxD1GA8LIAQgBCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQYCIiAE2AgAPCwALUwECfyACIAFrIgNBAnYiBCAAKAIAIAAoAggiAmtLBEAgACACIAQQ3yggACgCCCECCyADBEAgACgCBCACQQJ0aiABIAP8CgAACyAAIAIgBGo2AggLWgEBfyMAQRBrIgIkACAAKAIAIgAEQCACIAA2AgwgAEEIakEBIAEQ8BcgACAAKAIAQQFrIgA2AgAgAEUEQCACQQxqELIaCyACQRBqJAAPC0GMqIgBQRwQlz0AC1oBAX8jAEEQayICJAAgACgCACIABEAgAiAANgIMIABBCGpBACABEPAXIAAgACgCAEEBayIANgIAIABFBEAgAkEMahCyGgsgAkEQaiQADwtBjKiIAUEcEJc9AAtjAgJ+AX8gAET////////fPyAApqAiAL0iAUI0iKdB/w9xIgNBsghNBHxCf0KAgICAgICAgIB/QoCAgICAgIB4IANB/wdrrYcgA0H/B0kbIgIgAkJ/hSABg1AbIAGDvwUgAAsLZAECfyMAQRBrIgIkACABQQJ0IQMCQCABQf////8DTQRAIANBBBDRNA0BCyACIAM2AgwgAkEANgIIQdicxABBKyACQQhqQcicxABBtJ3EABDVHgALIAAgA0EEEPg6IAJBEGokAAtQAQJ/IwBBEGsiASQAIAFBBGogABCHIyABKAIEKAIMIgAgACgCACICQQFqNgIAIAJBAEgEQAALIAFBBGoQgCtBACAAEJosQQhqIAFBEGokAAtSAQJ/IwBB0ABrIgQkACAEQQhqIgUQ0yYgBSABIAIQ3QsCQCAFELQSpyADRgRAIABBBDoAAAwBCyAEQQo6ADggACAEQThqEIspCyAEQdAAaiQAC1QAAkAgAygCGEEDa0F+TwRAA0AgAkUNAiAAIAEoAgBBCHY2AgAgAEEEaiEAIAFBBGohASACQQFrIQIMAAsACyACQQJ0IgJFDQAgACABIAL8CgAACwtPAQF/IAFFIAAgAhChH0GIf0tyRQRAIAAoAhQgAWsiAyAAKAIMSQRAIABBAToAHEEADwsgACgCECADSwRAIAAgAzYCEAsgACADNgIUCyADC1cBAn8jAEEQayICJAAgASgCECgCGCIBBH8gAkEEaiABIAEQuCoQnQkgAigCDCEDQQAgAigCCCACKAIEGwVBAAshASAAIAM2AgQgACABNgIAIAJBEGokAAvhAwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEEQayIDJAACQCABKAIcIgIgASgCIEcEQAJAAkACQAJ+AkAgASgCBEUNACACIAEoAhRPDQIgASgCCCABKAIQIAJqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAJBAWo2AhxCAAwBCyABIAJBAWo2AhwCQCABKAIAKAIQIAJBBHRqIgIoAgQgAigCAHIEQCADQQRqQcYAQQBBAUEBEKAYIAMoAgghASADKAIEQQFHDQEgASADKAIMQeCtgAEQ/S8ACyABKAIkKQMAIghQDQMgAikDCCIJQoCAgICAgICAgH9RIAhCf1FxDQQgCSAIfyEIQgEMAQsgAygCDCICQfSxgAFBxgD8CgAAIAQoAgBBk4CAgHhHBEAgBBCIEQsgBELGADcCDCAEIAGtIAKtQiCGhDcCBCAEQYaAgIB4NgIAQgILIQkgBiAINwMIIAYgCTcDAAwEC0H0p4ABQSBBlKiAARCfKQALQeSxgAEQ4isAC0HksYABEOYrAAsgBkIDNwMACyADQRBqJAACQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQxCcgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHMtMIANgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuUBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJBMGogASgCJCACKAIIIAIoAgwQggMgAigCPCEBIAIpAjQhCQJ/IAIoAjAiA0GTgICAeEcEQCACKAJADAELIAIgATYCGCACIAk3AxAgAkEwaiIBIAJBEGoiAxCZGiACKAIwDQIgAkECNgI0IAJB0LCAATYCMCACQgE3AjwgAkGvEDYCTCACIAJByABqNgI4IAIgAzYCSCACQSBqIAEQmQ4gAikCICEJIAIoAighAUGCgICAeCEDIAIoAiwLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQM4IQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuyBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASADEK0qIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQ4BkgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHgsIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAubBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHgAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASADEK0qIAJBQGsgASgCJCACKAIAIAIoAgQQ+QIgAkEgaiIDIAJBzABqKQIANwMAIAIgAikCRDcDGAJ+IAIoAkAiAUGTgICAeEcEQCACKQMYIQggAikDIAwBCyACQRBqIAMoAgA2AgAgAiACKQMYNwMIIAJBQGsiASACQRhqEJkaIAIoAkANAiACQQI2AkQgAkHQsIABNgJAIAJCATcCTCACQa8QNgJcIAIgAkHYAGo2AkggAiACQQhqNgJYIAJBMGogARCZDiACKQIwIQhBgoCAgHghASACKQI4CyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDSCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALngQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB4ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACQUBrIAEoAiQgAigCACACKAIEEPkCIAJBIGoiAyACQcwAaikCADcDACACIAIpAkQ3AxgCfiACKAJAIgFBk4CAgHhHBEAgAikDGCEIIAIpAyAMAQsgAkEQaiADKAIANgIAIAIgAikDGDcDCCACQUBrIgEgAkEYahCZGiACKAJADQIgAkECNgJEIAJB0LCAATYCQCACQgE3AkwgAkGvEDYCXCACIAJB2ABqNgJIIAIgAkEIajYCWCACQTBqIAEQmQ4gAikCMCEIQYKAgIB4IQEgAikCOAshCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgIMAgsgBkIDNwMADAILIAIpA0ghCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQjywgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEJkkIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB+LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALnwQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEgAxCtKiACQShqIAEoAiQgAigCACACKAIEEIIDIAIoAjQhASACKQIsIQkCfyACKAIoIgNBk4CAgHhHBEAgAigCOAwBCyACIAE2AhAgAiAJNwMIIAJBKGoiASACQQhqIgMQxCcgAigCKA0CIAJBAjYCLCACQeiwgAE2AiggAkICNwI0IAJBsBA2AkwgAkHMtMIANgJIIAJBrxA2AkQgAiACQUBrNgIwIAIgAzYCQCACQRhqIAEQmQ4gAikCGCEJIAIoAiAhAUGCgICAeCEDIAIoAiQLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQMwIQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAv2BAIHfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIsIQQjAEGQAWsiAiQAAkAgASgCHCIDIAEoAiBHBEACQAJ+AkAgASgCBEUNACADIAEoAhRPDQIgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwBCyABIANBAWo2AhwgAiABIAMQrSogASgCKCEDIAEoAiQhByACKAIAIQEgAiACKAIEIgg2AgwgAiABNgIIIAJBEGogASAIIAcsAAAQwgECfiACKAIQQQFGBEAgAkHQAGogAkEkaigCADYCACACQcgAaiACQRxqKQIANwMAIAIgAikCFDcDQCACQfgAakHkroABKAIANgIAIAJB3K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQQhqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKQI4IQlBgoCAgHghASACKQIwDAELIAJB2ABqIAIpAxgiCSADLQAAEI0QQgEgAigCWCIBQZOAgIB4Rg0BGiACKQJkIQkgAikCXAshCiAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAo3AgQgBCABNgIAQgILIQogBiAJNwMIIAYgCjcDAAwCC0H0p4ABQSBBlKiAARCfKQALIAZCAzcDAAsgAkGQAWokAAJAIAUpAwgiCUIDUSAJQgJRckUEQCAAIAUpAxA3AwggACAJNwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQjywgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEMQnIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJBzLTCADYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAAL+QQCB38CfiMAQSBrIgUkACAFQQhqIQYgASgCLCEEIwBBkAFrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACfgJAIAEoAgRFDQAgAyABKAIUTw0CIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAQsgASADQQFqNgIcIAIgASgCACADEI8sIAEoAighAyABKAIkIQcgAigCACEBIAIgAigCBCIINgIMIAIgATYCCCACQRBqIAEgCCAHLAAAEMIBAn4gAigCEEEBRgRAIAJB0ABqIAJBJGooAgA2AgAgAkHIAGogAkEcaikCADcDACACIAIpAhQ3A0AgAkH4AGpB5K6AASgCADYCACACQdyugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEIajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAikCOCEJQYKAgIB4IQEgAikCMAwBCyACQdgAaiACKQMYIgkgAy0AABCNEEIBIAIoAlgiAUGTgICAeEYNARogAikCZCEJIAIpAlwLIQogBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAKNwIEIAQgATYCAEICCyEKIAYgCTcDCCAGIAo3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBkAFqJAACQCAFKQMIIglCA1EgCUICUXJFBEAgACAFKQMQNwMIIAAgCTcDAAwBCyAAQgI3AwALIAVBIGokAAuiBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASgCACADENorIAJBKGogASgCJCACKAIAIAIoAgQQggMgAigCNCEBIAIpAiwhCQJ/IAIoAigiA0GTgICAeEcEQCACKAI4DAELIAIgATYCECACIAk3AwggAkEoaiIBIAJBCGoiAxDgGSACKAIoDQIgAkECNgIsIAJB6LCAATYCKCACQgI3AjQgAkGwEDYCTCACQeCwgAE2AkggAkGvEDYCRCACIAJBQGs2AjAgAiADNgJAIAJBGGogARCZDiACKQIYIQkgAigCICEBQYKAgIB4IQMgAigCJAshByABrSAHrUIghoQhCCAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCDcCDCAEIAk3AgQgBCADNgIAQgIMAgsgBkIDNwMADAILIAIpAzAhCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB0ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC58EAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABIAMQrSogAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEJkkIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB+LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALsgQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEMQnIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJBzLTCADYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAAL+QQCB38CfiMAQSBrIgUkACAFQQhqIQYgASgCLCEEIwBBkAFrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACfgJAIAEoAgRFDQAgAyABKAIUTw0CIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAQsgASADQQFqNgIcIAIgASgCACADENorIAEoAighAyABKAIkIQcgAigCACEBIAIgAigCBCIINgIMIAIgATYCCCACQRBqIAEgCCAHLAAAEMIBAn4gAigCEEEBRgRAIAJB0ABqIAJBJGooAgA2AgAgAkHIAGogAkEcaikCADcDACACIAIpAhQ3A0AgAkH4AGpB5K6AASgCADYCACACQdyugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEIajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAikCOCEJQYKAgIB4IQEgAikCMAwBCyACQdgAaiACKQMYIgkgAy0AABCNEEIBIAIoAlgiAUGTgICAeEYNARogAikCZCEJIAIpAlwLIQogBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAKNwIEIAQgATYCAEICCyEKIAYgCTcDCCAGIAo3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBkAFqJAACQCAFKQMIIglCA1EgCUICUXJFBEAgACAFKQMQNwMIIAAgCTcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQxCcgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHMtMIANgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQmSQgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkH4sIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuiBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASgCACADENorIAJBKGogASgCJCACKAIAIAIoAgQQggMgAigCNCEBIAIpAiwhCQJ/IAIoAigiA0GTgICAeEcEQCACKAI4DAELIAIgATYCECACIAk3AwggAkEoaiIBIAJBCGoiAxCZJCACKAIoDQIgAkECNgIsIAJB6LCAATYCKCACQgI3AjQgAkGwEDYCTCACQfiwgAE2AkggAkGvEDYCRCACIAJBQGs2AjAgAiADNgJAIAJBGGogARCZDiACKQIYIQkgAigCICEBQYKAgIB4IQMgAigCJAshByABrSAHrUIghoQhCCAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCDcCDCAEIAk3AgQgBCADNgIAQgIMAgsgBkIDNwMADAILIAIpAzAhCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB0ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEMQnIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJBzLTCADYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALsgQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEJkkIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB+LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALtQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEoAgAgAxCPLCACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEOAZIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB4LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALngQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB4ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQUBrIAEoAiQgAigCACACKAIEEPkCIAJBIGoiAyACQcwAaikCADcDACACIAIpAkQ3AxgCfiACKAJAIgFBk4CAgHhHBEAgAikDGCEIIAIpAyAMAQsgAkEQaiADKAIANgIAIAIgAikDGDcDCCACQUBrIgEgAkEYahCZGiACKAJADQIgAkECNgJEIAJB0LCAATYCQCACQgE3AkwgAkGvEDYCXCACIAJB2ABqNgJIIAIgAkEIajYCWCACQTBqIAEQmQ4gAikCMCEIQYKAgIB4IQEgAikCOAshCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgIMAgsgBkIDNwMADAILIAIpA0ghCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC58EAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABIAMQrSogAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEOAZIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB4LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALkQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQTBqIAEoAiQgAigCCCACKAIMEIIDIAIoAjwhASACKQI0IQkCfyACKAIwIgNBk4CAgHhHBEAgAigCQAwBCyACIAE2AhggAiAJNwMQIAJBMGoiASACQRBqIgMQmRogAigCMA0CIAJBAjYCNCACQdCwgAE2AjAgAkIBNwI8IAJBrxA2AkwgAiACQcgAajYCOCACIAM2AkggAkEgaiABEJkOIAIpAiAhCSACKAIoIQFBgoCAgHghAyACKAIsCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDOCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALtQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEoAgAgAxDaKyACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEJkkIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB+LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALogQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQShqIAEoAiQgAigCACACKAIEEIIDIAIoAjQhASACKQIsIQkCfyACKAIoIgNBk4CAgHhHBEAgAigCOAwBCyACIAE2AhAgAiAJNwMIIAJBKGoiASACQQhqIgMQ4BkgAigCKA0CIAJBAjYCLCACQeiwgAE2AiggAkICNwI0IAJBsBA2AkwgAkHgsIABNgJIIAJBrxA2AkQgAiACQUBrNgIwIAIgAzYCQCACQRhqIAEQmQ4gAikCGCEJIAIoAiAhAUGCgICAeCEDIAIoAiQLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQMwIQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQ4BkgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHgsIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuUBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJBMGogASgCJCACKAIIIAIoAgwQggMgAigCPCEBIAIpAjQhCQJ/IAIoAjAiA0GTgICAeEcEQCACKAJADAELIAIgATYCGCACIAk3AxAgAkEwaiIBIAJBEGoiAxCZGiACKAIwDQIgAkECNgI0IAJB0LCAATYCMCACQgE3AjwgAkGvEDYCTCACIAJByABqNgI4IAIgAzYCSCACQSBqIAEQmQ4gAikCICEJIAIoAighAUGCgICAeCEDIAIoAiwLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQM4IQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAszACAAAn8gASgCCBpBk4CAgHhBlICAgHggAyABKAIAIAEoAgQgBCgCDBEGABsMAAs2AgAL9gECBX8BfiMAQRBrIgIkAEGyD0EBQQEQjiciBEUEQEHUxoUBELI7AAsgAkEANgIIIAIgAEENdSIBIAFBkANtIgFBkANsayIDQR91IgUgAWogBEENdSIBQfB8bWogAUGQA28iAUEfdmqsQrH1CH4gBUGQA3EgA2oiA0HtAmwgAEEEdkH/A3FqIANBwMaGAWotAABqQQFrrXwgAUEfdUGQA3EgAWoiAEHtAmwgBEEEdkH/A3FqIABBwMaGAWotAABqQQFrrX1CgKMFfjcDACACKQMAIQYgAigCCCEAIAJBEGokACAGIABBAEogBkIAU3GtfEKAowV/pwtYAQJ/AkACQCAAQf//D2tBgoBgSQ0AIAFBA3YhAiABQYA0Tw0BIAJBhNOGAWosAAAiAkUNACABIAJBA3RrIABBDXRyIQMLIAMPCyACQcAGQcTZhgEQwyEAC2ECAn8BbyMAQRBrIgIkACABKAIAJQEQHCEEEN8SIgEgBCYBIAEhAyACQQhqEM4tQQEhASAAAn8gAigCCEEBcQRAIAIoAgwMAQtBACEBIAMLNgIEIAAgATYCACACQRBqJAALYQICfwFvIwBBEGsiAiQAIAEoAgAlARBkIQQQ3xIiASAEJgEgASEDIAJBCGoQzi1BASEBIAACfyACKAIIQQFxBEAgAigCDAwBC0EAIQEgAws2AgQgACABNgIAIAJBEGokAAtYAQJ/IwBBEGsiAiQAIAEtAABBA0cEf0EABSACQQhqIAEoAgQiASgCACABKAIEKAIkEQAAIAIoAgwhAyACKAIICyEBIAAgAzYCBCAAIAE2AgAgAkEQaiQAC1gBAn8jAEEQayICJAAgAS0AAEEDRwR/QQAFIAJBCGogASgCBCIBKAIAIAEoAgQoAhgRAAAgAigCDCEDIAIoAggLIQEgACADNgIEIAAgATYCACACQRBqJAALXAEBfyMAQTBrIgMkACADIAE2AgwgAyAANgIIIANBATYCFCADQcDtiQE2AhAgA0IBNwIcIAMgA0EIaq1CgICAgODjA4Q3AyggAyADQShqNgIYIANBEGogAhDvLAALTgECfyMAQSBrIgIkACACQQhqIAAoAgAiACAAQR91IgNzIANrIAJBFmoQsBAgASAAQX9zQR92QQFBACACKAIIIAIoAgwQgQkgAkEgaiQAC2kBAX8CQAJAAkAgAC0AzAMOBAECAgACCyAAQcADahDkKCAAKAK8AyIBQYQBTwRAIAEQ8h8LIABBqANqEL0oIABBADoAzQMgACgCoAMiAUGEAU8EQCABEPIfCyAAQdABaiEACyAAEKkeCwtZAQF/IwBBEGsiAyQAIAMgAjkDCCADIAEoAiAoAgAgA0EIaiIBQQgQqBoCQCADLQAAQQRHBEAgAyADKQMANwMIIAAgARDQCQwBCyAAQQQ2AgALIANBEGokAAtZAQF/IwBBEGsiAyQAIAMgAjkDCCADIAEoAiAoAgAgA0EIaiIBQQgQpxoCQCADLQAAQQRHBEAgAyADKQMANwMIIAAgARDQCQwBCyAAQQQ2AgALIANBEGokAAtSAQJ/IwBBIGsiASQAIAFBCGogACgCEEEIahCEPCABIAEpAwg3AhggASAAKAIEIgI2AhAgASACIAAoAghBAnRqNgIUIAFBEGoQ3B8gAUEgaiQAC1cBAn8CQAJAIAEEQCABQQhrIgIgAigCAEEBaiIDNgIAIANFDQEgASgCAA0CIAAgAjYCCCAAIAE2AgQgAUF/NgIAIAAgAUEEajYCAA8LEJg9CwALEJk9AAtWAQN/IwBBEGsiAiQAIAAoAgQhASAAQQA2AgQCQCABRQ0AIAIgATYCDCACQQxqIgMQjjUgASABKAIAIgBBAWs2AgAgAEEBRw0AIAMQ6ScLIAJBEGokAAtWAQN/IwBBEGsiAiQAIAAoAhAhASAAQQA2AhACQCABRQ0AIAIgATYCDCACQQxqIgMQjjUgASABKAIAIgBBAWs2AgAgAEEBRw0AIAMQ6ScLIAJBEGokAAtZAQJ/IwBBIGsiAiQAIAJBDGoiAyABQYD5wwBBCxDGLCACIABBAWo2AhggAiAALQAAQQJ0QaCExABqKAIANgIcIAMgAkEYakGM+cMAEOQUENsbIAJBIGokAAuoCAEGfwJAAkACQCAALQAAQQFrDgIBAgALIAAoAgggACgCDCABEKk9DwsjAEHgAGsiAiQAIAIgAEEBaigAADYCCAJAAkACQCABLQALQRhxBEAgAkEANgIMIAJBgO6JATYCICACQgQ3AiwgAiACQQhqIgBBA3KtQoCAgICw9wCENwNQIAIgAEECcq1CgICAgLD3AIQ3A0ggAiAAQQFyrUKAgICAsPcAhDcDQCACIACtQoCAgICw9wCENwM4IAIgAkE4ajYCKCACQQQ2AiQgAkEMakH89YkBIAJBIGoQywoNASACKAIMIgBBEE8NAiABIAJBEGogABDWCSEADAMLIAJBBDYCJCACQYDuiQE2AiAgAkIENwIsIAIgAkEIaiIAQQNyrUKAgICAsPcAhDcDUCACIABBAnKtQoCAgICw9wCENwNIIAIgAEEBcq1CgICAgLD3AIQ3A0AgAiAArUKAgICAsPcAhDcDOCACIAJBOGo2AiggASgCACABKAIEIAJBIGoQywohAAwCC0HA7okBQSsgAkHfAGpBsO6JAUHs7okBENUeAAsgAEEPQaDuiQEQsDsACyACQeAAaiQAIAAPCwJ/QQEgAUHAmMQAQQEQ+zUNABpBAQJ/IwBBMGsiAiQAIAIgAEEBaiIALwAOIgNBCHQgA0EIdnI7AQ4gAiAALwAMIgNBCHQgA0EIdnI7AQwgAiAALwAKIgNBCHQgA0EIdnI7AQogAiAALwAIIgNBCHQgA0EIdnI7AQggAiAALwAGIgNBCHQgA0EIdnI7AQYgAiAALwAEIgNBCHQgA0EIdnI7AQQgAiAALwACIgNBCHQgA0EIdnI7AQIgAiAALwAAIgBBCHQgAEEIdnI7AQBBfyEGIAIhAEF/IQNBfyEEA0AgAC8BAAR/IARBAE4EQCAFIARrIgcgAyADIAdIIgcbIQMgBCAGIAcbIQYLQX8FIAUgBCAEQQBIGwshBCAAQQJqIQAgBUEBaiIFQQhHDQALQX8gBCAGQQggBGsiACADSiIFGyAGIARBAE4iBBsiByAAIAMgBRsgAyAEGyIDQQJIIgQbIQZBACEAQX4gAyAHaiIDIAQbIgVBB0ohBwJAAkADQAJAIAAgBkYEQEEBIQQgAUHCmMQAQQEQ+zUNAwJAIAZFBEAgAUHCmMQAQQEQ+zUiBCAHcg0FDAELIAVBCE4NAgsgAyEAIAVBCE8NBAsgAkHtAjYCLEEBIQQgAkEBNgIUIAJB1JjEADYCECACQgE3AhwgAiACIABBAXRqNgIoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahDLCg0CIABBB0YNACAAQQFqIQAgAUHCmMQAQQEQ+zVFDQEMAgsLQQAhBAsgAkEwaiQAIAQMAQsgBUEIQcSYxAAQwyEACw0AGiABQcGYxABBARD7NQsLUAEBfyABKAL4ByIEQf0BTQR/IAFBBGoFIAEoAgQhBCABKAIICyEBIAIgBEsEQCACIAQgAxCvOwALIAAgBCACazYCBCAAIAEgAkECdGo2AgALUQEBfyABKAJIIgNBEU0EfyABQQRqBSABKAIEIQMgASgCCAshASACIANLBEAgAiADQYifxAAQrzsACyAAIAMgAms2AgQgACABIAJBAnRqNgIAC1MBAX8jAEEgayIBJAAgAUEUaiAAQQhqKQIANwIAIAFBHGogAEEQaigCADYCACABQQA2AgggASAAKQIANwIMIAFBCGoQnydBCGoQ/TUgAUEgaiQAC1gBAX8gABCUDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAEJUMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtcAQF/IwBBMGsiASQAIAFBATYCECABQay+zQA2AgwgAUIBNwIYIAFBpgQ2AiggASABQSRqNgIUIAEgAUEvajYCJCAAQQRqIAFBDGoQmQ4gAEEANgIAIAFBMGokAAtLAQF/IwBBEGsiASQAIAFBBGogACgCmAUoAhQiAEEIaiAAKAIIQQJGQQJ0aiIAEIkZIAEtAAQEfyAALQAhQQFGBUEBCyABQRBqJAALSwEBfyMAQRBrIgEkACABQQRqIAAoAoAFKAIUIgBBCGogACgCCEECRkECdGoiABCJGSABLQAEBH8gAC0AIUEBRgVBAQsgAUEQaiQAC0sBAX8jAEEQayIBJAAgAUEEaiAAKAK4BCgCFCIAQQhqIAAoAghBAkZBAnRqIgAQiRkgAS0ABAR/IAAtACFBAUYFQQELIAFBEGokAAtLAQF/IwBBEGsiASQAIAFBBGogACgC5AQoAhQiAEEIaiAAKAIIQQJGQQJ0aiIAEIkZIAEtAAQEfyAALQAhQQFGBUEBCyABQRBqJAALSwEBfyMAQRBrIgEkACABQQRqIAAoApQEKAIUIgBBCGogACgCCEECRkECdGoiABCJGSABLQAEBH8gAC0AIUEBRgVBAQsgAUEQaiQAC0sBAX8jAEEQayIBJAAgAUEEaiAAKALoBCgCFCIAQQhqIAAoAghBAkZBAnRqIgAQiRkgAS0ABAR/IAAtACFBAUYFQQELIAFBEGokAAtdAQJ/IwBBEGsiASQAIAEgACgCGDYCDCABIAAoAiA2AgggAUEIaiICEN47IAEgACgCMDYCDCABIAAoAjg2AgggAhDtOyAAQcgAahDmICAAQeAAahDmICABQRBqJAALWAEBfyAAEJ0MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQngwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1EBAn8jAEEQayIBJAAgACgCgBMgAUEIaiAAQcAFaigCADYCACABIAApArgFNwMAIAEQiy0gACgCkBMQlxMgAEGAE2pBAEEk/AsAIAFBEGokAAtXAQF/IAAoAqwBBEBBAQ8LIAEoAjwhAwJAAkACQCACQn9RDQAgAiAAKAKQAkECdEGw+tAAajUCAFgNACADQQFGDQEMAgsgA0ECRg0BCyABKAIwRQ8LQQALYQECfyAAIAIvAQQiAzYCACAAIAIvAQYiBEEDajYCBAJAIAEoAiggAiABKAIAa0EDdUcNAAJAAkAgASgCJEEBaw4CAAECCyAAIANBgIAEcjYCAA8LIAAgBEGDgARqNgIECwtUAQJ/IAAgAiABayIEEOQtIAAoAgghAyABIAJHBEAgACgCBCECA0AgAiADaiABLQAAOgAAIAFBAWohASADQQFqIQMgBEEBayIEDQALCyAAIAM2AggLkgcBA38jAEEQayIEJAACQCAARSABRXJFBEAgACgCACIAQcAAENE0RQ0BAkAgARCaPigCBCICQXhxIgNBBEEIIAJBA3EiAhsgAGpPBEAgAkUgAyAAQSdqTXINAUGw8/wAQS5B4PP8ABCfKQALQfDy/ABBLkGg8/wAEJ8pAAsgARCaPiIAIAAoAgRBeHEiARCYPiECAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAgAxCWPiIAQdDzigEoAgBGBEAgAigCBEEDcUEDRw0BQcjzigEgATYCACAAIAEgAhCJLgwCCyAAIAMQqScLAkACQAJAAkACQAJAIAIoAgQiA0ECcUUEQCACQdTzigEoAgBGDQIgAkHQ84oBKAIARg0GIAIgA0F4cSICEKknIAAgASACaiIBENA0IABB0POKASgCAEcNAUHI84oBIAE2AgAMBwsgACABIAIQiS4LIAFBgAJJDQEgACABEPEQQejzigFB6POKASgCAEEBayIANgIAIAANBUGw8YoBKAIAIgENAkEAIQAMAwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBEHQ84oBKAIAIABGBEBByPOKAUEANgIAQdDzigFBADYCAAsgAUHg84oBKAIATQ0EAkBB1POKASgCACIBRQ0AAkBBzPOKASgCAEEoTQ0AQajxigEhAANAIAEgACgCAE8EQCAAEK47IAFLDQILIAAoAggiAA0ACwsCQEGw8YoBKAIAIgFFBEBBACEADAELQQAhAANAIABBAWohACABKAIIIgENAAsLQejzigFB/x8gACAAQf8fTRs2AgBBzPOKASgCAEHg84oBKAIATQ0AQeDzigFBfzYCAAsMBAsCf0HA84oBKAIAIgJBASABQQN2dCIDcUUEQEHA84oBIAIgA3I2AgAgAUH4AXFBuPGKAWoiAQwBCyABQfgBcUGo8IoBaiICQZABaiEBIAJBmAFqKAIACyECIAEgADYCCCACIAA2AgwgACABNgIMIAAgAjYCCAwDC0EAIQADQCAAQQFqIQAgASgCCCIBDQALC0Ho84oBQf8fIAAgAEH/H00bNgIADAELQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLCyAEQRBqJAAPC0GA9PwAQSsgBEEPakHw8/wAQdj0/AAQ1R4AC6EEAgh/A34jAEEgayIEJAAgBEEMaiEHIAEoAhghAiMAQSBrIgMkAAJAIAEpAwAiCiABKQMIIgxZDQAgASgCECEIA0AgASAKQgF8Igo3AwAgA0EMaiAIEIgWIAMpAhQhCyADKAIQIQYCQAJAIAMoAgwiCUGTgICAeEcEQCADKAIcIQUCQCACKAIAIgFBk4CAgHhGDQACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyABQYCAgIB4cyABQQBOGw4QAAECAwQFBg8HCAkKCwwNDg8LIAJBBGoQ3jsMDgsgAkEEahC8KgwNCyACQQRqEN47DAwLIAJBBGoQ3jsMCwsgAkEEahDeOwwKCyACQQRqEN47DAkLIAJBBGoQ3jsMCAsgAkEEahDeOwwHCyACQQRqEN47DAYLIAJBBGoQ3jsMBQsgAhDeOyACLQAMQQNHDQQgAigCECIBELwqIAFBDEEEEPg6DAQLIAJBBGoQ3jsMAwsgAkEEahDeOwwCCyACQQRqEN47DAELIAJBBGoQ3jsLIAIgBTYCECACIAs3AgggAiAGNgIEIAIgCTYCAEEAIQYMAQsgBkUNAQsgByALNwIIIAcgBjYCBEEBIQUMAgsgCiAMUg0ACwsgByAFNgIAIANBIGokAAJAAkAgBCgCDEUNACAEKAIQIgFFDQAgACAEKQIUNwIEIAAgATYCAAwBCyAAQQA2AgALIARBIGokAAtPACABIAJHBEAgAiABayECIAAgAUEMbGohAQNAIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIAFBDGohASACQQFrIgINAAsLC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFB7IL/ABCMGCABIAMQzRwgACABELETIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUH4gv8AEIwYIAEgAxDNHCAAIAEQwBMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQZyD/wAQjBggASADEM0cIAAgARDCEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCpLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBtIP/ABCMGCABIAMQzRwgACABEK0TIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKkuIAJB4ABqIgEgAxChGyACQQRqIgMgAUHMg/8AEIwYIAEgAxDNHCAAIAEQshMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQdiD/wAQjBggASADEM0cIAAgARCpEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCpLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFB5IP/ABCMGCABIAMQzRwgACABELsTIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKkuIAJB4ABqIgEgAxChGyACQQRqIgMgAUHwg/8AEIwYIAEgAxDNHCAAIAEQrxMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqS4gAkHgAGoiASADEKEbIAJBBGoiAyABQYiE/wAQjBggASADEM0cIAAgARDEEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBoIT/ABCMGCABIAMQzRwgACABEMYTIAJBgAJqJAALWAEBfyAAEKYMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQpwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABCnDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLWAEBfyAAEKgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQqQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABCyDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLTwECfyMAQYACayICJAAgAkG8AWoiAyABEPQ9IAJB4ABqIgEgAxChGyACQQRqIgMgAUHQ94ABEIwYIAEgAxDNHCAAIAEQiwwgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQ7j0gAkHgAGoiASADEKEbIAJBBGoiAyABQcT3gAEQjBggASADEM0cIAAgARCNDCACQYACaiQAC1gBAX8gABC0DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAELQMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQtQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABC2DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAELcMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQuQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABC+DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAEL4MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQvwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC04AAkAgACgCGAR/IAEgACgCKE8NASAAKAIcIAAoAiQgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQfzDhAFBIEGcxIQBEJ8pAAtOAAJAIAAoAiQEfyABIAAoAjRPDQEgACgCKCAAKAIwIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0Hk5oQBQSBBhOeEARCfKQALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARD1HiAAQeQAakGACEGACBCmFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ8B4gAEHkAGpBgAhBgAgQphQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtvAQF/QdDvigEoAgAiAkUEQBC1GSECCyAAQRBqQejHhQFBiMiFASACKAIAIAIoAgQoAgwRBAAQ2gEgAEEwaiABEPgeIABB5ABqQYAIQYAIEKYUIABBCGpBuMiFASkCADcCACAAQbDIhQEpAgA3AgALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARD4HiAAQeQAakGACEGACBClFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ+R4gAEHkAGpBgAhBgAgQpRQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtvAQF/QdDvigEoAgAiAkUEQBC1GSECCyAAQRBqQejHhQFBiMiFASACKAIAIAIoAgQoAgwRBAAQ2gEgAEEwaiABEPkeIABB5ABqQYAIQYAIEKYUIABBCGpBuMiFASkCADcCACAAQbDIhQEpAgA3AgALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARDwHiAAQeQAakGACEGACBClFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ9R4gAEHkAGpBgAhBgAgQpRQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtOAAJAIAAoAiQEfyABIAAoAjRPDQEgACgCKCAAKAIwIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HwyIUBQSBBkMmFARCfKQALTgACQCAAKAIgBH8gASAAKAIwTw0BIAAoAiQgACgCLCABaiIAQQN2ai0AAEH/AXMgAEEHcXYFQQALQQFxDwtBrM6FAUEgQczOhQEQnykAC04AAkAgACgCTAR/IAEgACgCXE8NASAAKAJQIAAoAlggAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQazOhQFBIEHMzoUBEJ8pAAtOAAJAIAAoAhwEfyABIAAoAixPDQEgACgCICAAKAIoIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HE6YUBQSBB5OmFARCfKQALTgACQCAAKAIUBH8gASAAKAIkTw0BIAAoAhggACgCICABaiIAQQN2ai0AAEH/AXMgAEEHcXYFQQALQQFxDwtBxOmFAUEgQeTphQEQnykAC04AAkAgACgCJAR/IAEgACgCNE8NASAAKAIoIAAoAjAgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQcCKhgFBIEHgioYBEJ8pAAtOAAJAIAAoAiwEfyABIAAoAjxPDQEgACgCMCAAKAI4IAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HAioYBQSBB4IqGARCfKQALWAEBfyAAEMgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQyAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC04AAkAgACgCFAR/IAEgACgCJE8NASAAKAIYIAAoAiAgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQfSahgFBIEGUm4YBEJ8pAAtOAAJAIAAoAhgEfyABIAAoAihPDQEgACgCHCAAKAIkIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0H0moYBQSBBlJuGARCfKQALTAAgARCTJyABQRhqIAJBGGopAwA3AwAgAUEQaiACQRBqKQMANwMAIAFBCGogAkEIaikDADcDACABIAIpAwA3AwAgACABQcgA/AoAAAtYAQN/AkBBCyABKAIAIgJBgICAgHhzIAJBAE4bIgRBC0cEQCAEQQFHDQEgASgCCCECIAEoAgQhAwwBCyABQQxqIQNBpPKHASECCyAAIAI2AgQgACADNgIAC0wCAX8CfiMAQSBrIgIkACABIAApAwAiA0IAWUEBQQAgAyADQj+HIgSFIAR9IAJBDGoiAUEUEO0QIgAgAWpBFCAAaxCBCSACQSBqJAALUwECfyAAKAIIIgIEQCAAKAIEQQRqIQADQAJAIAAoAgAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgABDyJQsgAEEIaiEAIAJBAWsiAg0ACwsLUwEBfwJAAkACQCAALQAgDgQAAgIBAgsgABDeOyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEJ0nCyAAQQxqEN47DwsgAEEcahCuLAsLVAEBfyAAEMspIAAoAkAiAQRAIAEQ6SYgAUEQQQQQ+DoLIAAoAkgiAUGEAU8EQCABEPIfCyAAQdQAahC9KCAAKAJQIgBBEGoQ3jsgAEHIAEEEEPg6C9QJAhR/An4jAEEQayIIJAAgASgCDCEKIwBBMGsiAyQAAkACQAJAIAEiDigCACIBIA4oAgQiE0cEQCAOKAIIIREDQCAOIAFBDGoiCzYCACADIAFBBGopAgA3AgwgESgCCCEBIBEoAgQhAiADQQA2AiggAyACNgIgIAMgAiABQQxsajYCJCADIANBDGo2AiwgA0EUaiEMIwBBIGsiBCQAIAQgA0EgaiIHQQhqNgIIIAQgB0EMajYCBCAHKAIAIQEgBygCBCEPAkACQAJAAkADQCABIA9GDQEgByABQQxqIgU2AgAgBCgCCCgCACENIAQgATYCFCAEIA02AhAgBEEEaiICIARBEGoiCRCMBiAEKAIIIgEgASgCAEEBajYCACAFIQFFDQALIAFBDEYNACAJQQRBAEEEQQQQoBggBCgCFCEFIAQoAhBBAUYNAiAEKAIYIgEgDTYCACAEQQxqIhRBATYCACAEIAE2AgggBCAFNgIEIARBGGogB0EIaikCADcDACAEIAcpAgA3AxAgAiEFIwBBEGsiBiQAIAlBCGohFSAJQQxqIQ0DQCAGIBU2AgQgBiANNgIAIAkoAgAhAiAJKAIEIQ8CQANAIAIgD0YNASAJIAJBDGoiATYCACAGKAIEKAIAIRIgBiACNgIMIAYgEjYCCCAGIAZBCGoQjAYgBigCBCICIAIoAgBBAWo2AgAgASECRQ0ACyABQQxGDQAgBSgCCCIBIAUoAgBGBEAgBUEBEO4tCyAFKAIEIAFBAnRqIBI2AgAgBSABQQFqNgIIDAELCyAGQRBqJAAgDEEIaiAUKAIANgIAIAwgBCkCBDcCAAwBCyAMQQA2AgggDEKAgICAwAA3AgALIARBIGokAAwBCyAFIAQoAhhBrKDDABD9LwALAkACQCADKAIcIgJFBEAgAygCDCEBIAcgAygCECILQQBBAUEBEKAYIAMoAiQhBSADKAIgQQFGDQYgAygCKCECIAsEQCACIAEgC/wKAAALIAKtIAutQiCGhCEXIANBFGoQ6TsCQCAKKAIAIgFBBkYNACAKQQRqIQICQAJAAkACQAJAIAEOBQECBAMEAAsgAigCACIBQYQBSQ0EIAEQ8h8MBAsgAigCACIBEIgRIAFBFEEEEPg6DAMLAkACQAJAAkACQAJAIAIoAgAiASgCAA4GAAECAwUEBQsgAUEEahDeOwwECyABQQRqEN47DAMLIAFBBGoQ3jsMAgsgAUEEahDeOwwBCyABQQRqELwqCyABQRhBCBD4OgwCCyACKAIAIgEoAgAiAigCTARAIAJBzABqELwqCyACKAIAQQJHBEAgAkEQahDeOwsgAkHUAEEEEPg6IAFBBEEEEPg6DAELIAIQ3jsLIAogFzcCCCAKIAU2AgQgCkECNgIAQYCAgIB4IQEMAQsgAygCFCIBQYCAgIB4Rg0BIAM1AhggAq1CIIaEIRYgAUGBgICAeEYNAQsgCCAWNwIEIAggATYCAAwDCyALIgEgE0cNAAsLIAhBgYCAgHg2AgALIANBMGokAAwBCyAFIAMoAihBxKLDABD9LwALAkAgCCgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAIKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAIQRBqJAALUQEBfyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEOgnCyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRBqEJcVCyAAEOk7C1MBA38jAEEQayICJAAgAiABNgIMIAJBDGoiAUEAEKc7IQMgAUEBEKc7IQEgAigCDCIEQYQBTwRAIAQQ8h8LIAAgATYCBCAAIAM2AgAgAkEQaiQAC1sBAX9BFEEEEK02IgJFBEBBBEEUEKM9AAsgAEG8v80ANgIIIAAgAjYCBCAAQQU2AgAgAiABKQIANwIAIAJBEGogAUEQaigCADYCACACQQhqIAFBCGopAgA3AgALWwEBf0EUQQQQrTYiAkUEQEEEQRQQoz0ACyAAQfi/zQA2AgggACACNgIEIABBBTYCACACIAEpAgA3AgAgAkEQaiABQRBqKAIANgIAIAJBCGogAUEIaikCADcCAAtdAQF/AkAgACgCIEUNACAAKAIkIgFFDQAgAEEwaiAAKAIoIAAoAiwgASgCEBEBAAsCQCAAKAI0RQ0AIAAoAjgiAUUNACAAQcQAaiAAKAI8IAAoAkAgASgCEBEBAAsLvwgCEn8DfiMAQRBrIgckACABKAIYIQgjAEFAaiIDJAACQCABIgUoAgAiASAFKAIEIg5HBEAgBSgCFCEPIAUoAhAhECAFKAIMIREgBSgCCCEMA0AgBSABQUBrIhI2AgAgAyAMNgIgIAFBKGooAgAhAiABQSRqKAIAIQEgAyAPNgI4IAMgEDYCNCADIBE2AjAgA0EANgIsIAMgATYCJCADIAEgAkHAAmxqNgIoIAMgA0EgajYCPCADQQhqIQkjAEHQAGsiAiQAIAJBCDYCCCACQcgAaiADQSRqIgFBGGooAgA2AgAgAkFAayABQRBqKQIANwMAIAJBOGogAUEIaikCADcDACACIAEpAgA3AzAgAiACQQhqNgJMIAJBJGohCiMAQUBqIgEkACABQQxqIAJBMGoiBBDeGwJAAkACQCABKAIMQQlHBEAgAUEgaiINQQRBAEEEQRQQoBggASgCJCELIAEoAiBBAUYNAiABKAIoIgYgASkCDDcCACAGQRBqIAFBHGooAgA2AgAgBkEIaiABQRRqKQIANwIAIAFBCGoiE0EBNgIAIAEgBjYCBCABIAs2AgAgAUE4aiAEQRhqKQIANwMAIAFBMGogBEEQaikCADcDACABQShqIARBCGopAgA3AwAgASAEKQIANwMgIwBBIGsiBCQAIARBDGogDRDeGyAEKAIMQQlHBEADQCABKAIIIgYgASgCAEYEQCABIAZBAUEEQRQQ0CgLIAEoAgQgBkEUbGoiCyAEKQIMNwIAIAtBEGogBEEcaigCADYCACALQQhqIARBFGopAgA3AgAgASAGQQFqNgIIIARBDGogDRDeGyAEKAIMQQlHDQALCyAEQSBqJAAgCkEIaiATKAIANgIAIAogASkCADcCAAwBCyAKQQA2AgggCkKAgICAwAA3AgALIAFBQGskAAwBCyALIAEoAihByJfPABD9LwALAkAgAigCCEEIRwRAIAkgAikDCDcDACAJQRBqIAJBGGopAwA3AwAgCUEIaiACQRBqKQMANwMAIAoQwxUgCkEEQRQQ4B4MAQsgCSACKQIkNwIEIAlBCDYCACAJQQxqIAJBLGooAgA2AgALIAJB0ABqJAAgAykDECEVIAMoAgwhAQJAAkACQCADKAIIIgJBCEcEQCADKQMYIRYgCCgCAEEIRwRAIAgQySMLIAggFjcDECAIIBU3AwggCCABNgIEIAggAjYCACAFIAxBAWo2AghBgICAgHghAQwBCyAFIAxBAWoiDDYCCAJAIAFBgICAgHhrDgIDAgALIBUhFAsgByAUNwIEIAcgATYCAAwECyAVIRQLIBIiASAORw0ACwsgB0GBgICAeDYCAAsgA0FAayQAAkAgBygCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAHKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAHQRBqJAALSwECfyAAIAEQ7S0gACgCCCEDIAAgAQR/IAEgA2ogACgCBCADQQF0aiEAA0AgACACOwEAIABBAmohACABQQFrIgENAAsFIAMLNgIIC00BA38jAEEQayICJAAgAkEEaiIDIAAoAgwiAUEIaiABKAIIQQJGQQJ0aiIBEIkZIAMgAS0AISAAEN0lQf8BcRDOJiACQRBqJABB/wFxC1UBAn8jAEEQayICJAAgASgCCAR/IAJBCGogASgCBCIBKAIAIAEoAgQoAiARAAAgAigCDCEDIAIoAggFQQALIQEgACADNgIEIAAgATYCACACQRBqJAALVQECfyMAQRBrIgIkACABKAIIBH8gAkEIaiABKAIEIgEoAgAgASgCBCgCJBEAACACKAIMIQMgAigCCAVBAAshASAAIAM2AgQgACABNgIAIAJBEGokAAtXAQN/IAAgACgCCCICQQdxNgIIIAAgACgCFCIDIAJB/wFxIgJBA3ZqIgQ2AhQgAyAAKAIAQSAgAmt2NgAAAkAgAQ0AIAQgACgCGCIBTQ0AIAAgATYCFAsLog4CCH8HfiMAQRBrIgokAAJ/IAK9Qv///////////wCDQv/////////3/wBYBEAjAEEQayIJJAAgAr0iDUL/////////B4MhCyANQgBTBEAgAUEtOgAAQQEhBgsCQAJ/An8CQAJAAkAgDUI0iKdB/w9xIgNFIAtQcUUEQCADQQJJIAtCAFJyIQQgC0KAgICAgICACIQgCyADGyILQgKGIQwgC0IBgyEQIANBtQhrQcx3IAMbIgNBAEgEQCALQcD8iAEgAyADQYWiU2xBFHYgA0F/R2siCGoiBUEEdGsgCCAFQbHZtX9sQRN2a0H8AGogCSAJQQhqIAQQhxIhDiAJKQMIIQsgCSkDACENIAhBAk8EQCAMQn8gCK2GQn+Fg1BFIAhBP09yDQQMBQsgDSAQfSENIBBQIARxIQdBAQwFCyALIANBwegEbEESdiADQQNLayIFQQR0QeDRiAFqIAUgA2sgBUHPpsoAbEETdmpB/QBqIAkgCUEIaiAEEIcSIQ4gCSkDCCELIAkpAwAhDSAFQRZPDQJBACAMp2sgDEIFgKdBe2xGBEBBfyEDA0AgA0EBaiEDIAxCzZmz5syZs+ZMfiIMQrPmzJmz5syZM1gNAAsgAyAFTw0EDAMLIBBQRQRAIAxCAoQhDEF/IQMDQCADQQFqIQMgDELNmbPmzJmz5kx+IgxCtObMmbPmzJkzVA0ACyANIAMgBU+tfSENDAMLIAStQn+FIAx8IQxBfyEDA0AgA0EBaiEDIAxCzZmz5syZs+ZMfiIMQrPmzJmz5syZM1gNAAsMAQsgASAGaiIDQaCliQEvAAA7AAAgA0ECakGipYkBLQAAOgAAIA1CP4inQQNqIQQMBQsgAyAFSQ0AQQEhB0EADAILQQAhBAJ/IA1C5ACAIgwgC0LkAIAiD1gEQCALIQ8gDSEMIA4hC0EADAELIA6nIA5C5ACAIgunQZx/bGpBMUshBEECCyEDIAxCCoAiDCAPQgqAIg1WBH8DQCADQQFqIQMgCyIOQgqAIQsgDEIKgCIMIA0iD0IKgCINVg0ACyAOpyALp0F2bGpBBEsFIAQLIAsgD1FyDAILQQELIQhBACEEAkAgDUIKgCIPIAtCCoAiEVgEQEEAIQMgCyEMIA4hDQwBC0EAIQMDQCAHQQAgC6drIBEiDKdBdmxGcSEHIANBAWohAyAIIARB/wFxRXEhCCAOpyAOQgqAIg2nQXZsaiEEIA0hDiAPQgqAIg8gDCILQgqAIhFWDQALCwJAAkAgB0UNAEEAIAynayAMQgqAIg6nQXZsRw0AA0AgA0EBaiEDIAggBEH/AXFFcSEIIA2nIA1CCoAiC6dBdmxqIQQgCyENQQAgDqdrIA4iDEIKgCIOp0F2bEYNAAsMAQsgDSELCyAQUCAHcUUgCyAMUXFBBEEFIAtCAYNQGyAEIAgbIAQgBEH/AXFBBUYbQf8BcUEES3ILIQQCQAJAAkAgAyAFaiIFQQBOIAUCf0ERIAsgBK1CAYN8IgtC//+D/qbe4RFWDQAaQRAgC0L//5mm6q/jAVYNABpBDyALQv//6IOx3hZWDQAaQQ4gC0L/v8rzhKMCVg0AGkENIAtC/5+UpY0dVg0AGkEMIAtC/8/bw/QCVg0AGkELIAtC/8evoCVWDQAaQQogC0L/k+vcA1YNABpBCSALQv/B1y9WDQAaQQggC0L/rOIEVg0AGkEHIAtCv4Q9Vg0AGkEGIAtCn40GVg0AGkEFIAtCj84AVg0AGkEEIAtC5wdWDQAaQQMgC0LjAFYNABpBAkEBIAtCCVYbCyIEaiIDQRFIcUUEQCADQQFrIgVBEEkNASADQQRqQQVJDQIgBEEBRw0DIAEgBmoiA0HlADoAASADIAunQTBqOgAAIAUgASAGQQJyIgNqEKgZIANqIQQMBAsgCyABIAZqIARqELAWIAVFIAMgBExyRQRAIAEgBGogBmpBMCAF/AsACyABIAMgBmoiA2pBruAAOwAAIANBAmohBAwDCyALIAEgBCAGakEBaiIEahCwFiABIAZqIQYgAwRAIAYgBkEBaiAD/AoAAAsgAyAGakEuOgAADAILIAEgBmoiB0Gw3AA7AABBAiADayEFAkAgA0EATg0AQQMgBSAFQQNNG0ECayIDRQ0AIAdBAmpBMCAD/AsACyALIAEgBCAGaiAFaiIEahCwFgwBCyALIAEgBCAGaiIEaiIHQQFqELAWIAEgBmoiAyADLQABOgAAIANBLjoAASAHQeUAOgABIAUgASAEQQJqIgNqEKgZIANqIQQLIAlBEGokACAEDAELIApBCGoiAUEDQQQgAr0iC0IAWSIDG0EDIAtC/////////weDUCIEGzYCBCABQdDRiAFB09GIASADG0HX0YgBIAQbNgIAIAooAgghASAKKAIMCyEDIAAgATYCACAAIAM2AgQgCkEQaiQAC5UDAgV/An4jAEEQayIEJAAgASgCKCEFIwBBIGsiAiQAAkAgASgCHCIDIAEoAiBHBEACQAJAAkACQCABKAIERQ0AIAMgASgCFE8NAyABKAIIIAEoAhAgA2oiBkEDdmotAABB/wFzIAZBB3F2QQFxRQ0AIAEgA0EBajYCHEEAIQEMAQsgASADQQFqNgIcIAIgASADEK0qIAJBDGogAigCACACKAIEEOAHQQAhAQJAAkAgAigCDCIDQe3///8Hag4CAQIACyACKAIcIQEgAikCFCEHIAIoAhAhBiAFKAIAQZOAgIB4RwRAIAUQiBELIAUgATYCECAFIAc3AgggBSAGNgIEIAUgAzYCAEECIQEMAgsgAjUCFEIghiEIIAI1AhAhB0EBIQELIAcgCIQhBwsgBCAHNwIEIAQgATYCAAwCC0H0p4ABQSBBlKiAARCfKQALIARBAzYCAAsgAkEgaiQAAkAgBCgCACIBQQNGIAFBAkZyRQRAIAAgBCkCBDcCBCAAIAE2AgAMAQsgAEECNgIACyAEQRBqJAALmAMCBX8CfiMAQRBrIgQkACABKAIoIQUjAEEgayICJAACQCABKAIcIgMgASgCIEcEQAJAAkACQAJAIAEoAgRFDQAgAyABKAIUTw0DIAEoAgggASgCECADaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASADQQFqNgIcQQAhAQwBCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAkEMaiACKAIAIAIoAgQQ4AdBACEBAkACQCACKAIMIgNB7f///wdqDgIBAgALIAIoAhwhASACKQIUIQcgAigCECEGIAUoAgBBk4CAgHhHBEAgBRCIEQsgBSABNgIQIAUgBzcCCCAFIAY2AgQgBSADNgIAQQIhAQwCCyACNQIUQiCGIQggAjUCECEHQQEhAQsgByAIhCEHCyAEIAc3AgQgBCABNgIADAILQfSngAFBIEGUqIABEJ8pAAsgBEEDNgIACyACQSBqJAACQCAEKAIAIgFBA0YgAUECRnJFBEAgACAEKQIENwIEIAAgATYCAAwBCyAAQQI2AgALIARBEGokAAuYAwIFfwJ+IwBBEGsiBCQAIAEoAighBSMAQSBrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACQAJAAkAgASgCBEUNACADIAEoAhRPDQMgASgCCCABKAIQIANqIgZBA3ZqLQAAQf8BcyAGQQdxdkEBcUUNACABIANBAWo2AhxBACEBDAELIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQQxqIAIoAgAgAigCBBDgB0EAIQECQAJAIAIoAgwiA0Ht////B2oOAgECAAsgAigCHCEBIAIpAhQhByACKAIQIQYgBSgCAEGTgICAeEcEQCAFEIgRCyAFIAE2AhAgBSAHNwIIIAUgBjYCBCAFIAM2AgBBAiEBDAILIAI1AhRCIIYhCCACNQIQIQdBASEBCyAHIAiEIQcLIAQgBzcCBCAEIAE2AgAMAgtB9KeAAUEgQZSogAEQnykACyAEQQM2AgALIAJBIGokAAJAIAQoAgAiAUEDRiABQQJGckUEQCAAIAQpAgQ3AgQgACABNgIADAELIABBAjYCAAsgBEEQaiQAC1MCAn8BfiMAQRBrIgMkACAAKAIAIgAoAgAgA0EIaiAAKAIEIAAoAggoAgAgASgCACACQQJ0a0EEaygCABDKJSADKAIIIAMoAgwQzQIgA0EQaiQAC4cvAhB/AX4jAEEQayIMJAAgDEEANgIMIAxCgICAgBA3AgRBASENAn8gDEEEaiEEIwBBMGsiCSQAIAlBEGogAEEsaigCADYCACAJQQhqIABBJGopAgA3AwAgCSAAKQIcNwMAIAlBFGogCRCZAQJAAkAgCS0AFEEHRg0AIAlBIGpBAXIhEQNAIAlBKGogCUEcaigCADYCACAJIAkpAhQiEjcDIAJAIBKnQf8BcSICQQRPBEACQAJAAkAgAkEFaw4CAAIBCyMAQeAAayICJAAgACgCDCELIAAoAgghBiAAKAIEIQggACgCACEHIAAoAjAhAwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBEyARLQAAIgVBBGsgBUEDTRsiCkH/AXEOFAADBAUGDQwLCgkBDw8PDw8PDw8HDwsgAw0BDA4LIAtBgICAgHhHDQZBASEFDA4LIANBA3ZB/wdxIgVB3QVPDRQgBSAFQZf8gAFqLQAAakEGdkEBayIDQQtNBEAgBCADQQN0QYiFgQFqKAIAIgMgA0EDahC9JgwMCyADQQxBmIOBARDDIQALIANFDQsgA0EDdkH/B3EiBUHdBU8NEyAFIAVBl/yAAWotAABqQQZ2QQFrIgNBC00EQCAEIANBA3QiA0GEhIEBaigCACIFIAUgA0GIhIEBaigCAGoQvSYMCwsgA0EMQaiDgQEQwyEACyADRQ0KQQAhBSAEIANBBHZB/wNxIANBB3FqQQdwIgNBAWpBACADQQZJG0EDdEHshoEBaigCACIDIANBA2oQvSYMCwsgA0UNCUEAIQUgBCADQQR2Qf8DcSADQQdxakEHcCIDQQFqQQAgA0EGSRtBA3QiA0GchoEBaigCACIGIAYgA0GghoEBaigCAGoQvSYMCgsgB0EBcUUNCEEAIQUgAkEANgIkIAJBADYCDCACQaiHgQFBpoeBASAIQb/RAksiAxs2AkAgAkGmh4EBQaSHgQEgAxs2AjwgAkEYaiEIIAJBKGohCyACQRBqIQ4DQCAFQQFxRSEDA0ACQAJAAkAgA0UEQCAOEOUrIgNBgIDEAEcNASACKAIMBEAgAigCEBogAigCFBoLQQAhBSACQQA2AgxBASEDDAQLAkAgAigCPCIDRQ0AIAMgAigCQEYNACACIANBAWo2AjwgAy0AACIGIQcCQCAGwEEATg0AIAIgA0ECajYCPCADLQABQT9xIg8gBkEfcSIKQQZ0ciEHIAZB3wFNDQAgAiADQQNqNgI8IAMtAAJBP3EgD0EGdHIiDyAKQQx0ciEHIAZB8AFJDQAgAiADQQRqNgI8IApBEnRBgIDwAHEgAy0AA0E/cSAPQQZ0cnIiB0GAgMQARg0BCyACQdQAaiAHEP0MIAIoAlghAyACQdAAaiIGIAJB3ABqKAIAIgc2AgAgAiACKQJUNwNIIAIoAgwEQCACKAIQGiACKAIUGgsgCCACKQNINwIAIAhBCGogBigCADYCACACQQNBAkEBIAMbIAcbNgIUIAJCATcCDAwCCyACKAIkIgNBAUYEfyALEOUrIgNBgIDEAEcNASACKAIkBEAgAigCKBogAigCLBoLIAJBADYCJEEAIQMgAigCDAUgBQsEfyACKAIQGiACKAIUGiACKAIkBSADC0UNDCACKAIoGiACKAIsGgwMCyAEKAIIIQYgBAJ/QQEgA0GAAUkiBw0AGkECIANBgBBJDQAaQQNBBCADQYCABEkbCyIKEIQuIAQoAgQgBCgCCGohBQJAIAdFBEAgA0GAEEkNASADQYCABE8EQCAFIANBP3FBgAFyOgADIAUgA0ESdkHwAXI6AAAgBSADQQZ2QT9xQYABcjoAAiAFIANBDHZBP3FBgAFyOgABDAQLIAUgA0E/cUGAAXI6AAIgBSADQQx2QeABcjoAACAFIANBBnZBP3FBgAFyOgABDAMLIAUgAzoAAAwCCyAFIANBP3FBgAFyOgABIAUgA0EGdkHAAXI6AAAMAQtBACEDDAELCyAEIAYgCmo2AgggAigCDCEFDAALAAsgB0EBcUUNBwJAAkACQCAFQQFrDgMAAQIKCyACQQE2AiAgAkGogoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAZBwIQ9bkHoB3A2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAoLIAJBATYCICACQcCCgQE2AhwgAkEBNgIQIAJBrPeAATYCDCACQQE2AhggAkE7NgJYIAIgBkHoB25BwIQ9cDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMCQsgAkEBNgIgIAJB2IKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQYCU69wDcDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMCAsgAiAAQQxqNgJIIAJBATYCECACQaz3gAE2AgwgAkIBNwIYIAJBhAE2AlggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAcLIAdBAXFFDQUgBEGcgoEBQZ2CgQEQvSYgAkEBNgIgIAJB2IKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQYCU69wDcDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMBgsgB0EBcUUNBCAEQZyCgQFBnYKBARC9JiACQQE2AiAgAkHAgoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAZB6AduQcCEPXA2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAULIAdBAXFFDQMgBEGcgoEBQZ2CgQEQvSYgAkEBNgIgIAJBqIKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQcCEPW5B6AdwNgJIIAIgAkHUAGo2AhQgAiACQcgAajYCVCAEIAJBDGoQ7jwhBQwECyAHQQFxRQ0CIAIgBkGAlOvcA3AiAzYCRCADRQ0BIARBnIKBAUGdgoEBEL0mIAMgA0HAhD1uIgVBwIQ9bEYEQCACQQE2AiAgAkGogoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAU2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAQLIAMgA0HoB24iBUHoB2xGBEAgAkEBNgIgIAJBwIKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAFNgJIIAIgAkHUAGo2AhQgAiACQcgAajYCVCAEIAJBDGoQ7jwhBQwECyACQQE2AiAgAkHYgoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAJB1ABqNgIUIAIgAkHEAGo2AlQgBCACQQxqEO48IQUMAwsgB0EBcUUNASAEQaaHgQFBpIeBASAIQb/RAksiAxtBqIeBAUGmh4EBIAMbEL0mC0EAIQUMAQtBASEFIAtBgICAgHhGDQACQAJAAkACQAJAAkAgCkH/AXFBC2sOCAABAgADAwQFBgsgAkEBOgANIAJBgQI7AA4gAiAKQQ5GOgAMIAJBDGogBCAAKAIYEP4HIQUMBQsgAkGAgoQQNgAMIAJBDGogBCAAKAIYEP4HIQUMBAsgAkGAgAQ2AAwgAkEMaiAEIAAoAhgQ/gchBQwDCyACQQI6AA0gAkGBAjsADiACIApBEEY6AAwgAkEMaiAEIAAoAhgQ/gchBQwCCyADRSAHQQFxRXINASACIAY2AhQgAiAINgIQIAIgAzYCDAJ/IAAoAhghCgJAIAJBDGoiBigCACIDQQ11IgdBj84ASw0AIAQgA0EEdkH/A3EgA0EHcWpBB3AiBUEBakEAIAVBBkkbQQN0QeixhgFqKAIAIgUgBUEDahC7JiAEQbSwhgFBtrCGARC7JgJAIANBA3YiA0H/B3EiBUHdBUkEQAJAIAMgBUGgsoYBai0AACILakEBdkEfcSIIQQpPBEAgBCAIEIsYDQQgBCgCCCEDDAELIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqIAhBMHI6AAAgBCADQQFqIgM2AggLIAQoAgAgA0YEfyAEIANBARDbKCAEKAIIBSADCyAEKAIEakEgOgAAIAQgA0EBajYCCCAFIAtqQQZ2QQFrIgNBDE8NASAEIANBA3RB8LCGAWooAgAiAyADQQNqELsmIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIIAQgB0H//wNxQeQAbiIDEIsYDQIgBCAHIANB5ABsaxCLGA0CIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIIAYoAgQiBUE8biEHIAYoAgghBiAEIAVBkBxuEIsYDQIgBCgCCCIDIAQoAgBGBH8gBCADQQEQ2yggBCgCCAUgAwsgBCgCBGpBOjoAACAEIANBAWo2AgggBCAHQTxwEIsYDQIgBCgCCCIDIAQoAgBGBH8gBCADQQEQ2yggBCgCCAUgAwsgBCgCBGpBOjoAACAEIANBAWo2AgggBCAFIAdBPGxrIAZBgJTr3ANuahCLGA0CIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIQciwhgEgBCAKEP4HDAMLIAVB3QVBgLiGARDDIQALIANBDEG4sIYBEMMhAAtBAQshBQwBCyADRSAHQQFxRXINACACIAY2AhQgAiAINgIQIAIgAzYCDCAAKAIYIQojAEEwayIDJAAgAyACQQxqIggoAgAiB0ENdSIGNgIEAkACQCAGQZDOAE8EQCADQQE2AiQgA0GEgoEBNgIgIANBATYCFCADQaz3gAE2AhAgA0EBNgIcIANBnAM2AiwgAyADQShqNgIYIAMgA0EEajYCKCAEIANBEGoQ7jxFDQEMAgsgBCAGQf//A3FB5ABuIgsQixgNASAEIAYgC0HkAGxrEIsYDQELIAQoAgghBiAEQQEQhC4gBCgCBCAEKAIIakEtOgAAIAQgBkEBajYCCAJAIAdBA3YiB0H/B3EiBkHdBUkEQCAEIAYgBkGX/IABai0AACILakEGdhCLGA0CIAQoAgghBiAEQQEQhC4gBCgCBCAEKAIIakEtOgAAIAQgBkEBajYCCCAEIAcgC2pBAXZBH3EQixgNAiAEKAIIIQYgBEEBEIQuIAQoAgQgBCgCCGpB1AA6AAAgBCAGQQFqNgIIIAgoAgQhByADIAgoAggiBkGAlOvcA2sgBiAGQf+T69wDSyIIGyIGNgIIIAQgB0GQHG4QixgNAiAEKAIIIQsgBEEBEIQuIAQoAgQgBCgCCGpBOjoAACAEIAtBAWo2AgggBCAHQTxuIgtBPHAQixgNAiAEKAIIIQ4gBEEBEIQuIAQoAgQgBCgCCGpBOjoAACAEIA5BAWo2AgggBCAHIAtBPGxrIAhqEIsYDQIgBkUNASAGIAZBwIQ9biIHQcCEPWxGBEAgA0EBNgIkIANBqIKBATYCICADQQE2AhQgA0GggoEBNgIQIANBATYCHCADQTs2AiwgAyAHNgIMIAMgA0EoajYCGCADIANBDGo2AiggBCADQRBqEO48RQ0CDAMLIAYgBkHoB24iB0HoB2xGBEAgA0EBNgIkIANBwIKBATYCICADQQE2AhQgA0GggoEBNgIQIANBATYCHCADQTs2AiwgAyAHNgIMIAMgA0EoajYCGCADIANBDGo2AiggBCADQRBqEO48RQ0CDAMLIANBATYCJCADQdiCgQE2AiAgA0EBNgIUIANBoIKBATYCECADQQE2AhwgA0E7NgIsIAMgA0EoajYCGCADIANBCGo2AiggBCADQRBqEO48RQ0BDAILIAZB3QVB9IGBARDDIQALIANBgIKECDYAECADQRBqIAQgChD+ByEFCyADQTBqJAALIAJB4ABqJAAgBQ0BDAMLAn8gCS0AIiEGIwBBIGsiByQAIAAoAgghCiAAKAIEIQggACgCACEFIAAoAjAhAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBEtAABBAWsOFAABDQIDDg8QBAUGBwgJERITFBUKCwsgAg0LDBULIAJFDRQgBCACQQ11QeQAbyICQeQAaiACIAJBAEgbIAYQzhMhAwwVCyACRQ0TIAQgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1IgIgAkHkAG0iAkHkAGxrQR91IAJqIAYQzhMhAwwUCyACRQ0SIAQgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1QeQAbyICQeQAaiACIAJBAEgbIAYQzhMhAwwTCyACRQ0RIAcgAjYCECAEIAdBEGpBBhDeJyAGEM4TIQMMEgsgAkUNECAHIAI2AhAgBCAHQRBqQQAQ3icgBhDOEyEDDBELIAJFDQ8gBCACQQ11IAJBBHZB/wNxIAJBD3EQxRhBBHZBP3EgBhDOEyEDDBALIAJFDQ4gBEKBhIyg0MABIAJBBHZB/wNxIAJBB3FqQQdwQQN0rYinEIMdIQMMDwsgAkUNDSAEIAJBBHZB/wNxIAJBB3FqQQdwQQFqEIMdIQMMDgsgAkUNDCAEQQMgAkEEdkH/A3GtIAZBABCcCSEDDA0LIAJFDQtBASEDIAVBAXFFDQwgACgCGCEDIAAoAgwhBSAHIAo2AhggByAINgIUIAcgAjYCECAHQQRqIAdBEGoQyi8gByAHKAIENgIcIARBCSAHQRxqENEfrEKAowV+IANBACAFQYCAgIB4RxusfSAHNQIIfEKAkc285wF9IAZBABCcCSEDDAwLQQEhAyACRQ0LIAJBDXUiAkHoB2tBqMYATwRAIARBBCACrCAGIAJBj84ASxCcCSEDDAwLIAQgAkH//wNxQeQAbiIFEIsYDQsgBCACIAVB5ABsaxCLGCEDDAsLIAQgAkENdSICIAJB5ABtIgJB5ABsa0EfdSACaiAGEM4TIQMMCgtBASEDIAJFDQkgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1IgJB6AdrQajGAE8EQCAEQQQgAqwgBiACQY/OAEsQnAkhAwwKCyAEIAJB//8DcUHkAG4iBRCLGA0JIAQgAiAFQeQAbGsQixghAwwJCyACRQ0HIAJBA3ZB/wdxIgVB3QVPDQkgBCAFIAVBl/yAAWotAABqQQZ2QQFrQQNuQQFqEIMdIQMMCAsgAkUNBiACQQN2Qf8HcSIFQd0FTw0IIAQgBSAFQZf8gAFqLQAAakEGdiAGEM4TIQMMBwsgAkUNBSACQQN2IgJB/wdxIgVB3QVPDQcgBCAFQZf8gAFqLQAAIAJqQQF2QR9xIAYQzhMhAwwGC0EBIQMgBUEBcUUNBSAEIAhBkBxuIAYQzhMhAwwFC0EBIQMgBUEBcUUNBCAEIAhBkBxuQQxwIgJBDCACGyAGEM4TIQMMBAtBASEDIAVBAXFFDQMgBCAIQTxuQTxwIAYQzhMhAwwDC0EBIQMgBUEBcUUNAiAEIApBgJTr3ANuIAhBPHBqIAYQzhMhAwwCC0EBIQMgBUEBcUUNASAEQQkgCkGAlOvcA3CtIAZBABCcCSEDDAELQQEhAwsgB0EgaiQAIAMMAQsMBgtFDQILIAlBFGoQuy1BASEQDAMLIAQgCSgCJCICIAIgCSgCKGoQvSYLIAlBFGoiAhC7LSACIAkQmQEgCS0AFEEHRw0ACwsgCUEwaiQAIBAMAQsgBUHdBUH0gYEBEMMhAAtFBEAgASAMKAIIIAwoAgwQ1gkhDQsgDEEEahDeOyAMQRBqJAAgDQtLAQJ/IAAgARCFLiAAKAIIIQIgACABBH8gASACaiAAKAIEIAJBAnRqIQADQCAAQQA2AgAgAEEEaiEAIAFBAWsiAQ0ACwUgAgs2AggLSgECfyMAQZABayIEJAAgBEEIaiIFIAAgASgCFBEAACAEQcwAaiIBIAIgAygCFBEAACAFIAEQohEgARCEJyAFEIQnIARBkAFqJAALsggCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEJkVIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf//A0sNAyALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAHOwEMIAQgEDYCCCAEIAo2AgQgBEEBNgIAIARBDGoMBQsgAyAKcg0BDAMLIAUgA0HIs4MBEMMhAAsgCygCACIGKAIIIgdB//8DSw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzsBDAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBUEBdGogDC8BADsBACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahCdPCANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAutCAIXfwJ+IwBBEGsiCSQAIAEoAiwhDSMAQUBqIgIkAAJAAkACQAJAAkAgASIOKAIAIgMgASgCBCISRg0AIAEoAighEyABKAIkIQ8gASgCECEBIA4oAgghCCAOKAIYIRQDQCAOIAhBAWoiFTYCCCAOIANBBGoiFjYCACABIBRGDQEgDiABQQxqIhc2AhAgASgCACIRQYCAgIB4Rg0BIAEpAgQhGSACIAg2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQzhggGachCCAZQoCAgIAQWgRAIAggGUIgiKdBDGxqIRggCCEBA0AgAUEIaigCACEQIAFBBGooAgAhCiACIAEoAgA2AhwgAiATNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkE0aiELIA8gCiAQEKwCIRkgAkEgaiIDAn8gAwJ/AkACQAJAIA8oAiwiAyAZIA81AiCIpyIFSwRAAkAgDygCKCAFQQR0aiIEKAIAQQFGBEAgCkUgBCgCBCIDRXINASADIAQoAgggCiAQEJ87DQUMAwsgCygCACIGKAIIIgdB/wBLDQMgCygCCCgCACEMIAsoAgQoAgAhBSAGKAIAIAdGBEAgBkG4tIMBEJsoCyAGKAIEIAdBA3RqIgMgDDYCBCADIAU2AgAgBiAHQQFqNgIIIAQgBzoADCAEIBA2AgggBCAKNgIEIARBATYCACAEQQxqDAULIAMgCnINAQwDCyAFIANByLODARDDIQALIAsoAgAiBigCCCIHQf8ASw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzoADAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBWogDC0AADoAACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahDeOyANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAulBQIRfwJ+IwBBEGsiBSQAIAEoAiwhByMAQUBqIgIkAAJAAkACQAJAAkAgASIIKAIAIgMgASgCBCIKRg0AIAEoAighCyABKAIkIQwgASgCECEBIAgoAgghBCAIKAIYIQ0DQCAIIARBAWoiDjYCCCAIIANBBGoiDzYCACABIA1GDQEgCCABQQxqIhA2AhAgASgCACIJQYCAgIB4Rg0BIAEpAgQhEyACIAQ2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQvxUgE6chAyATQoCAgIAQWgRAIAMgE0IgiKdBDGxqIREgAyEBA0AgAUEIaigCACEEIAFBBGooAgAhBiACIAEoAgA2AhwgAiALNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkEgaiAMIAYgBCACQTRqEIoQIAIoAiQhBCACKAIgIgZBk4CAgHhHDQUgAigCHCIGIAIoAhgiEk8NBCACKAIUIAZBAnRqIAQoAgA2AgAgAUEMaiIBIBFHDQALCyACIAM2AiQgAiAJNgIgIAJBIGpBBEEMEOAeIAIpAhQhEwJAAkACQCACKAIQIgFBgICAgHhrDgICAQALIBMhFAwGCyATIRQLIBAhASAOIQQgDyIDIApHDQALCyAFQYGAgIB4NgIADAMLIAYgEkHUs4IBEMMhAAsgAikCKCETIAIoAjAhASACIAM2AiQgAiAJNgIgIAJBIGpBBEEMEOAeIAJBEGoQ6TsgBxDlECAHIAE2AhAgByATNwIIIAcgBDYCBCAHIAY2AgBBgICAgHghAQsgBSAUNwIEIAUgATYCAAsgAkFAayQAAkAgBSgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAFKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAFQRBqJAALrQgCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEM4YIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf8BSw0DIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIAc6AAwgBCAQNgIIIAQgCjYCBCAEQQE2AgAgBEEMagwFCyADIApyDQEMAwsgBSADQcizgwEQwyEACyALKAIAIgYoAggiB0H/AUsNACALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAQNgIIIAQgCjYCBCAEIAc6AAwMAQtBkICAgHgMAgsgBEEMags2AgRBk4CAgHgLNgIAIAIoAiQhDCACKAIgIgNBk4CAgHhHDQUgAigCHCIFIAIoAhgiA08NBCACKAIUIAVqIAwtAAA6AAAgAUEMaiIBIBhHDQALCyACIAg2AiQgAiARNgIgIAJBIGpBBEEMEOAeIAIpAhQhGQJAAkACQCACKAIQIgFBgICAgHhrDgICAQALIBkhGgwGCyAZIRoLIBchASAVIQggFiIDIBJHDQALCyAJQYGAgIB4NgIADAMLIAUgA0HUs4IBEMMhAAsgAikCKCEZIAIoAjAhASACIAg2AiQgAiARNgIgIAJBIGpBBEEMEOAeIAJBEGoQ3jsgDRDlECANIAE2AhAgDSAZNwIIIA0gDDYCBCANIAM2AgBBgICAgHghAQsgCSAaNwIEIAkgATYCAAsgAkFAayQAAkAgCSgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAJKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAJQRBqJAALsggCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEJkVIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf//AUsNAyALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAHOwEMIAQgEDYCCCAEIAo2AgQgBEEBNgIAIARBDGoMBQsgAyAKcg0BDAMLIAUgA0HIs4MBEMMhAAsgCygCACIGKAIIIgdB//8BSw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzsBDAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBUEBdGogDC8BADsBACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahCdPCANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAunBQIRfwJ+IwBBEGsiBSQAIAEoAiwhByMAQUBqIgIkAAJAAkACQAJAAkAgASIIKAIAIgMgASgCBCIKRg0AIAEoAighCyABKAIkIQwgASgCECEBIAgoAgghBCAIKAIYIQ0DQCAIIARBAWoiDjYCCCAIIANBBGoiDzYCACABIA1GDQEgCCABQQxqIhA2AhAgASgCACIJQYCAgIB4Rg0BIAEpAgQhEyACIAQ2AgwgAkEQakEAIAMoAgBBPGoQ9C1BxLOCARCzFSATpyEDIBNCgICAgBBaBEAgAyATQiCIp0EMbGohESADIQEDQCABQQhqKAIAIQQgAUEEaigCACEGIAIgASgCADYCHCACIAs2AjQgAiACQRxqNgI8IAIgAkEMajYCOCACQSBqIAwgBiAEIAJBNGoQihAgAigCJCEEIAIoAiAiBkGTgICAeEcNBSACKAIcIgYgAigCGCISTw0EIAIoAhQgBkECdGogBCgCADYCACABQQxqIgEgEUcNAAsLIAIgAzYCJCACIAk2AiAgAkEgakEEQQwQ4B4gAikCFCETAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgEyEUDAYLIBMhFAsgECEBIA4hBCAPIgMgCkcNAAsLIAVBgYCAgHg2AgAMAwsgBiASQdSzggEQwyEACyACKQIoIRMgAigCMCEBIAIgAzYCJCACIAk2AiAgAkEgakEEQQwQ4B4gAkEQahDpOyAHEOUQIAcgATYCECAHIBM3AgggByAENgIEIAcgBjYCAEGAgICAeCEBCyAFIBQ3AgQgBSABNgIACyACQUBrJAACQCAFKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAUpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAVBEGokAAuYCAIXfwJ+IwBBEGsiCSQAIAEoAiwhDCMAQUBqIgIkAAJAAkACQAJAAkAgASINKAIAIgMgASgCBCISRg0AIAEoAighEyABKAIkIQ4gASgCECEBIA0oAgghCCANKAIYIRQDQCANIAhBAWoiFTYCCCANIANBBGoiFjYCACABIBRGDQEgDSABQQxqIhc2AhAgASgCACIQQYCAgIB4Rg0BIAEpAgQhGSACIAg2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQthUgGachCCAZQoCAgIAQWgRAIAggGUIgiKdBDGxqIRggCCEBA0AgAUEIaigCACEPIAFBBGooAgAhCiACIAEoAgA2AhwgAiATNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkEgaiERIAJBNGohBCAOIAogDxCsAiEZAn8CQAJAIA4oAiwiAyAZIA41AiCIpyIGSwRAAkAgDigCKCAGQRhsaiIFKAIAQQFGBEAgCkUgBSgCCCIDRXINASADIAUoAgwgCiAPEJ87DQQMAwsgBCgCCCgCACELIAQoAgQoAgAhBiAEKAIAIgcoAggiBCAHKAIARgRAIAdBuLSDARCbKAsgBygCBCAEQQN0aiIDIAs2AgQgAyAGNgIAIAcgBEEBajYCCCAFIAStNwMQIAUgDzYCDCAFIAo2AgggBUIBNwMAIAVBEGoMBAsgAyAKcg0BDAILIAYgA0HIs4MBEMMhAAsgBCgCCCgCACELIAQoAgQoAgAhBiAEKAIAIgcoAggiBCAHKAIARgRAIAdBuLSDARCbKAsgBygCBCAEQQN0aiIDIAs2AgQgAyAGNgIAIAcgBEEBajYCCCAFIA82AgwgBSAKNgIIIAUgBK03AxALIAVBEGoLIQMgEUGTgICAeDYCACARIAM2AgQgAigCJCELIAIoAiAiA0GTgICAeEcNBSACKAIcIgYgAigCGCIDTw0EIAIoAhQgBkEDdGogCykDADcDACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBA2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBiADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBA2AiAgAkEgakEEQQwQ4B4gAkEQahDjPCAMEOUQIAwgATYCECAMIBk3AgggDCALNgIEIAwgAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBiJCgwAA2AgAgAUKIkKDAgIGChAg3AwAgAUEYakGIkKDAADYCACABQoiQoMCAgYKECDcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2QBAn8jAEEgayIBJAAgAUEIakGMmLDgADYCACABQoyYsODAgYOGDDcDACABQRhqQYyYsOAANgIAIAFCjJiw4MCBg4YMNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALZAECfyMAQSBrIgEkACABQQhqQYmSpMgANgIAIAFCiZKkyJChwoQJNwMAIAFBGGpBiZKkyAA2AgAgAUKJkqTIkKHChAk3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtiAQJ/IwBBIGsiASQAIAFBCGpBhIiQIDYCACABQoSIkKDAgIGCBDcDACABQRhqQYSIkCA2AgAgAUKEiJCgwICBggQ3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBi5as2AA2AgAgAUKLlqzYsOHChQs3AwAgAUEYakGLlqzYADYCACABQouWrNiw4cKFCzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2QBAn8jAEEgayIBJAAgAUEIakGOnLjwADYCACABQo6cuPDgwYOHDjcDACABQRhqQY6cuPAANgIAIAFCjpy48ODBg4cONwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALYgECfyMAQSBrIgEkACABQQhqQYWKlCg2AgAgAUKFipSo0KDBggU3AwAgAUEYakGFipQoNgIAIAFChYqUqNCgwYIFNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALYgECfyMAQSBrIgEkACABQQhqQYeOnDg2AgAgAUKHjpy48ODBgwc3AwAgAUEYakGHjpw4NgIAIAFCh46cuPDgwYMHNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALZAECfyMAQSBrIgEkACABQQhqQY+evPgANgIAIAFCj568+PDhw4cPNwMAIAFBGGpBj568+AA2AgAgAUKPnrz48OHDhw83AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBipSo0AA2AgAgAUKKlKjQoMGChQo3AwAgAUEYakGKlKjQADYCACABQoqUqNCgwYKFCjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGDhowYNgIAIAFCg4aMmLDgwIEDNwMAIAFBGGpBg4aMGDYCACABQoOGjJiw4MCBAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGChIgQNgIAIAFCgoSIkKDAgIECNwMAIAFBGGpBgoSIEDYCACABQoKEiJCgwICBAjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGGjJgwNgIAIAFChoyYsODAgYMGNwMAIAFBGGpBhoyYMDYCACABQoaMmLDgwIGDBjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC1gBAn8CQCACIANsIgMgAmoiBCADTwRAIAQgASgCCCIFSw0BIAEoAgQhASAAIAI2AgQgACABIANqNgIADwsgAyAEQaCBhQEQsTsACyAEIAVBoIGFARCwOwALVgEBfyMAQRBrIgQkACAEQQhqIAEoAgAgASgCBCIBKAIIQQFrQXhxakEIaiACIAMgASgCIBEFACAEKAIMIQEgACAEKAIINgIAIAAgATYCBCAEQRBqJAALVwECfyMAQSBrIgMkACADQRRqIAEQgRUCQCADKAIUIgRFBEAgAEEANgIADAELIAMgAykCGDcCDCADIAQ2AgggACADQQhqEMovIAAgAjYCDAsgA0EgaiQAC1cBAn8jAEEgayIDJAAgA0EUaiABEP0VAkAgAygCFCIERQRAIABBADYCAAwBCyADIAMpAhg3AgwgAyAENgIIIAAgA0EIahDKLyAAIAI2AgwLIANBIGokAAtXAQJ/IwBBIGsiAyQAIANBFGogARDWFQJAIAMoAhQiBEUEQCAAQQA2AgAMAQsgAyADKQIYNwIMIAMgBDYCCCAAIANBCGoQyi8gACACNgIMCyADQSBqJAALVwECfyMAQSBrIgMkACADQRRqIAEQ/RcCQCADKAIUIgRFBEAgAEEANgIADAELIAMgAykCGDcCDCADIAQ2AgggACADQQhqEMovIAAgAjYCDAsgA0EgaiQAC1MBAn8gASgCKCIFBEAgASgCJCEBIAVBzAFsIQUgACgCACIAIANsIQYgACADIARqbCEAA0AgASACIAYgABDYGyABQcwBaiEBIAVBzAFrIgUNAAsLC1MBAX8gASgCKCIFBEAgASgCJCEBIAVBzAFsIQUgACgCACIAIAMgBGpsIQQgACADbCEAA0AgASACIAAgBBDYGyABQcwBaiEBIAVBzAFrIgUNAAsLC1YBAX8gASgCBCACTwRAIAFBCGohAyACBEAgAygCAEF/IAL8CwALIAEgAjYCDCAAIAEpAgA3AgAgAEEIaiADKQIANwIADwtBsPWHAUErQdz1hwEQnykAC1oCA38BbyMAQRBrIgEkABAiIQQQ3xIiAiAEJgEgAiEDIAFBCGoQzi1BASECIAACfyABKAIIQQFxBEAgASgCDAwBC0EAIQIgAws2AgQgACACNgIAIAFBEGokAAtPAQF/IABBCGoQhjAgAEEUahCHMCAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSxqEIYfCyAAKAIgQYCAgIB4RwRAIABBIGoQ3jsLC7cCAgV/BH4jAEHgAGsiAyQAIANBDGoiBSAAEIUjIANBIGohACADKAIMIQQjAEEgayICJAAgAkEIaiAEIAEQiC0iAUEgahDAASABKQMQIQcCQCABKAIsQYCAgIB4RwRAIAJBFGogAUEsahCTGAwBCyACQYCAgIB4NgIUCyABKQMYIQggASgCPCIEIAQoAgAiBkEBajYCACAGQQBIBEAACyAAIAIpAgg3AiAgACACKQIUNwIsIABBKGogAkEQaigCADYCACAAQTRqIAJBHGooAgA2AgAgASkDACEJIAEpAwghCiABKAI4IQEgACAENgI8IAAgATYCOCAAIAg3AxggACAHNwMQIAAgCjcDCCAAIAk3AwAgAkEgaiQAIAUQ6CogA0EANgIYIANBGGoQ0ClBCGogA0HgAGokAAvRFgIefxd+IwBB4AJrIhAkACAQQQxqIhogABCFIyAQQSBqIQMgECgCDCMAQeAAayICJAAgARCJLSIAKAK8AiIZIBkoAgAiAUEBajYCAAJAAn8CQCABQQBOBEAgAiAAQYACahDWHgJAIAAoAowCQYCAgIB4RwRAIAJBDGogAEGMAmoQ3SAMAQsgAkGAgICAeDYCDAsgACgCAEEBRgRAIAApAwghLUIBISgLIAAoAhBBAUYEQCAAKQMYIS5CASEnCyAAKQP4ASEyIAApA/ABITMgACkD6AEhNCAAKALUASEbIAAoAtABIRwgACkD4AEhNSAAKQPYASE2QgghICAAKQNgIiZCCFENAwJ+AkACQAJAAkACQAJAAkACQCAmp0EBaw4HAQIDBAUGBwALIAAtAIoBIREgAC0AiQEhEiAALQCIASEEIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgAC0AjQEhByAALQCMASEGQgAhICACQT9qIQkgAC0AiwEMCgsgAiAAKAKMASIGQQh2OgA/IAZBEHYhCyAAKAKIASEEIAAtAJsBIQcgAC0AmgEhASAALQCZASEIIAAtAJgBIQUgACkDgAEhIyAAKQN4ISEgACkDcCEkIAApA2ghIiAAKAKUASEMIAAoApABIQ1CASEgDAgLIABBmgFqLQAAIQEgAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOgASElIAAoApwBIQogAC8BjgEhCyAALQCMASEGIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgACkDkAEhICAALwGYASEOIAAoAogBIQQgAC0AjQEhDyACIAAtAJsBOgA+IAIgDzoAPyAEQRB2IREgBEEIdiESIA4gAUEQdHIiBUEIdiEIICBCIIinIQwgIKchDUICISAgAkE9aiEJIARBGHYMCAsgACgCiAFBAUcEf0EABSAAKAKUASEMIAAoApABIQ0gAC8BjgEhCyAALQCNASEBIAAtAIwBIQZBAQshBCAAKAKYAUEBRgRAIAApA6ABISUgACgCnAEhCkEBIQULIAIgAToAPyACQQA6AD4gAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOAASEjIAApA3ghISAAKQNwISQgACkDaCEiQgMhICACQT1qIQlBACEBQQAMBwsgAiAAKAKMASIGQQh2OgA/IAZBEHYhCyAAKAKUASEMIAAoAogBIQQgAC0AmwEhByAALQCaASEBIAAtAJkBIQggAC0AmAEhBSAAKQOAASEjIAApA3ghISAAKQNwISQgACkDaCEiIAAoApABIQ1CBCEgDAULIABBmgFqLQAAIQEgAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOgASElIAAoApwBIQogAC8BjgEhCyAALQCMASEGIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgACkDkAEhICAALwGYASEOIAAoAogBIQQgAC0AjQEhDyACIAAtAJsBOgA+IAIgDzoAPyAEQRB2IREgBEEIdiESIA4gAUEQdHIiBUEIdiEIICBCIIinIQwgIKchDUIFISAgAkE9aiEJIARBGHYMBQsgACgCiAFBAUYEQAJAIAAoAowBIgEEQCACQUBrIABBmAFqIAAoApABIAAoApQBIAEoAgARBQAMAQsgAkEANgJAC0EBIQQLIAAoApwBQQFGBEACQCAAKAKgASIBBEAgAkHQAGogAEGsAWogACgCpAEgACgCqAEgASgCABEFAAwBCyACQQA2AlALQQEhCgsgACgCaEEBRgRAIAApA3AhJEIBISILIAAoAnhBAUYEQCAAKQOAASEjQgEhIQsgAiACLQBBOgA/IAIgAi0ATzoAPiAALQCzASEHIAAtALIBIQ4gAC0AsQEhDyAALQCwASEWIAJBzgBqLQAAIQEgAi8BQiELIAItAEAhBiACKAJEIQ0gAigCSCEMIAIpA1AhJSACLQBYIRUgAi0AWSEUIAItAFohEyACLwFMIAIgAi0AWzoAPSABQRB0ciIFQQh2IQggAkE8aiEJQgYMAQsgACgCiAFBAUYEQAJAIAAoAowBIgEEQCACQUBrIABBmAFqIAAoApABIAAoApQBIAEoAgARBQAMAQsgAkEANgJAC0EBIQQLIAAoApwBQQFGBEACQCAAKAKgASIBBEAgAkHQAGogAEGsAWogACgCpAEgACgCqAEgASgCABEFAAwBCyACQQA2AlALQQEhCgsgACgCaEEBRgRAIAApA3AhJEIBISILIAAoAnhBAUYEQCAAKQOAASEjQgEhIQsgAiACLQBBOgA/IAIgAi0ATzoAPiAALQCzASEHIAAtALIBIQ4gAC0AsQEhDyAALQCwASEWIAJBzgBqLQAAIQEgAi8BQiELIAItAEAhBiACKAJEIQ0gAigCSCEMIAIpA1AhJSACLQBYIRUgAi0AWSEUIAItAFohEyACLwFMIAIgAi0AWzoAPSABQRB0ciIFQQh2IQggAkE8aiEJQgcLISAgAigCXCEYQQAMAgsACyACQT5qIQlBAAshFyAJIAc6AAAgBUH/AXEgCEH/AXFBCHQgAUEQdHJyIQEgBEH/AXEgEUH/AXFBEHQgF0EYdHIgEkH/AXFBCHRyciESIAItAD8hESACLQA+IQcgAi0APSEFIAItADwhBAsCQCAAKAKYAkGAgICAeEcEQCACQRhqIABBmAJqELUWDAELIAJBgICAgHg2AhgLQgAhJiAAKAIgQQFGBEAgACkDKCEvQgEhKQsgACgCMEEBRgRAQgEhJiAAKQM4ISwLIAAoAkBBAUYEQCAAKQNIITBCASErCyAAKAJQQQFGBEAgACkDWCExQgEhKgsgACgCvAEhCCAAKAK4ASEJIAAoAsQBIRcgACgCwAEhHSAAKALMASEeIAAoAsgBIR8CQCAAKAKkAkGAgICAeEcEQCACQSRqIABBpAJqEKUdDAELIAJBgICAgHg2AiQLAkAgACgCsAJBgICAgHhHBEAgAkEwaiAAQbACahClHQwBCyACQYCAgIB4NgIwCyADIAIpAgA3AoACIAMgAikCDDcCjAIgA0GIAmogAkEIaigCADYCACADQZQCaiACQRRqKAIANgIAIANBmgFqIAFBEHY6AAAgAyABOwGYASADIDI3A/gBIAMgMzcD8AEgAyA0NwPoASADIDU3A+ABIAMgNjcD2AEgAyAbNgLUASADIBw2AtABIAMgHjYCzAEgAyAfNgLIASADIBc2AsQBIAMgHTYCwAEgAyAINgK8ASADIAk2ArgBIAMgBDoAswEgAyAOOgCyASADIA86ALEBIAMgFjoAsAEgAyAYNgKsASADIAU6AKsBIAMgEzoAqgEgAyAUOgCpASADIBU6AKgBIAMgJTcDoAEgAyAKNgKcASADIAc6AJsBIAMgDDYClAEgAyANNgKQASADIAs7AY4BIAMgEToAjQEgAyAGOgCMASADIBI2AogBIAMgIzcDgAEgAyAhNwN4IAMgJDcDcCADICI3A2ggAyAgNwNgIAMgMTcDWCADICo3A1AgAyAwNwNIIAMgKzcDQCADICw3AzggAyAmNwMwIAMgLzcDKCADICk3AyAgAyAuNwMYIAMgJzcDECADIC03AwggAyAoNwMAIAMgGTYCvAIgA0GgAmogAkEgaigCADYCACADIAIpAxg3A5gCIAMgAikCJDcCpAIgA0GsAmogAkEsaigCADYCACADIAIpAzA3A7ACIANBuAJqIAJBOGooAgA2AgAgAkHgAGokACAaEOoqIBBBADYCGCAQQRhqENIpQQhqIBBB4AJqJAALSAEBfyAAKAIAIgEgACgCBEYEf0EABSAAIAFBA2o2AgAgAUECai0AAEEYdCABLwAAQQh0ckEBcgsiAEEIdkGAgMQAIABBAXEbC1UBAX8jAEEQayICJAACfyAAKAIAIgAoAgBBAUYEQCACIABBBGo2AgwgAUGQhM4AQQQgAkEMakGUhM4AENATDAELIAFBjITOAEEEEPs1CyACQRBqJAALVgEDfyMAQRBrIgIkACACQQRqIgMgASgCCCIEQeTqzgAQzhggASgCBCAEIAIoAgggAigCDBCgGSABQQA2AgggAEEEaiADEOcVIABBCDYCACACQRBqJAALVgEDfyMAQRBrIgIkACACQQRqIgMgASgCCCIEQeTqzgAQzhggASgCBCAEIAIoAgggAigCDBChGSABQQA2AgggAEEEaiADEOcVIABBCDYCACACQRBqJAALkgUCDX8BfiMAQRBrIgckACABKAIIIQgjAEEgayIJJAACQCABKAIAIgYgASgCBCINRwRAIAhBDGohCyAJQRRqIQwDQCABIAZBDGoiDjYCACAJQQhqIQIjAEEgayIEJAAgBigCACEFIwBBMGsiAyQAIAMgBTYCDCAEQQhqIgoCfyAFQQRPBEAgA0EBNgIUIANBuPrOADYCECADQgE3AhwgA0GcAzYCLCADIANBKGo2AhggAyADQQxqNgIoIApBBGogA0EQahCZDkEADAELIAogBToABEEICzYCACADQTBqJAAgBC0ADCEDAkAgBCgCCCIFQQhHBEAgAiAEKQANNwAFIAJBFGogBEEcaigAADYAACACQQ1qIARBFWopAAA3AAAgAiADOgAEIAIgBTYCAAwBCyAEQQhqIAYoAgQQxhogBC0ADCEFIAQoAggiCkEIRwRAIAIgBCkADTcABSACQRRqIARBHGooAAA2AAAgAkENaiAEQRVqKQAANwAAIAIgBToABCACIAo2AgAMAQsgAiADOgAJIAIgBToACCACQQg2AgAgAiAGKAIINgIECyAEQSBqJAAgCSkCDCEPAkACQCAJKAIIIgZBCEcEQCAIKAIAQQhHBEAgCBDJIwsgCCAPNwIEIAggBjYCACALIAwpAgA3AgAgC0EIaiAMQQhqKAIANgIAQoCAgICAgAEhDwwBCyAPQoCAgICAIIRCgICAgIDgP4NCgICAgICgAVENAQsgByAPNwIADAMLIA4iBiANRw0ACwsgB0EFOgAFCyAJQSBqJAACQAJAIActAAVBBUYNACAHKQMAIg9CgICAgIDgP4NCgICAgICAAVENACAAIA83AgAMAQsgAEEEOgAFCyAHQRBqJAALTwECfyAAKAIIIgEEQCAAKAIEIQADQCAAKAIAIgIEQCAAQQxqIABBBGooAgAgAEEIaigCACACKAIQEQEACyAAQRBqIQAgAUEBayIBDQALCwtWAQF/IwBBIGsiASQAIAAoAgwiACgCCEECRgRAIAFBADYCGCABQQE2AgwgAUGsu88ANgIIIAFCBDcCECABQQhqQbS7zwAQ7ywACyAALQA4IAFBIGokAAtWAQF/IwBBIGsiASQAIAAoAgwiACgCCEECRgRAIAFBADYCGCABQQE2AgwgAUGsu88ANgIIIAFCBDcCECABQQhqQcS7zwAQ7ywACyAAKAIsIAFBIGokAAtVAQF/IwBBEGsiAiQAAn8gACgCACIALQAAQQFGBEAgAiAAQQFqNgIMIAFBkPDQAEEEIAJBDGpBgPDQABDQEwwBCyABQfnv0ABBBBD7NQsgAkEQaiQAC00AIARBA3EEQEF/DwsgBUGAIEkEQEG+fw8LIAEoAgBB/gFNBEAgACABIAIgA0EBIAQQsAgPCyABQf8BNgIAIAAgASACIAMgBCAFEPknC1IBAn8gASgCCCACQQN0aiICKAIAIQMgASgCBCEEIAAgASgCACIAIAAgAigCBGpBEHYiABCDLCABIAQgASgCACAAdUEBdGogA0EBdGovAQA2AgALUgECfyABKAIIIAJBA3RqIgIoAgAhAyABKAIEIQQgACABKAIAIgAgACACKAIEakEQdiIAEIUsIAEgBCABKAIAIAB1QQF0aiADQQF0ai8BADYCAAtGAQJ/IAFBAWohAQNAIAEEQCAAIAAoAgAiBSACdiADIAVyQQBHaiIFNgIAIAQgBWohBCAAQQRqIQAgAUEBayEBDAELCyAEC1kBA38CQCABKAIEIgIgASgCCCIDTwRAIAEoAgwiBCACIANrIgJLDQEgACAENgIEIAAgASgCACADajYCAA8LIAMgAkHo7vwAEK87AAsgBCACQfju/AAQsDsAC1UBAX8jAEEQayICJAACfyAAKAIAIgAtAABBAUYEQCACIABBAWo2AgwgAUHEov4AQQQgAkEMakG0ov4AENATDAELIAFBsKL+AEEEEPs1CyACQRBqJAALXAEDfwJAIAEoAggiAyABKAIEIgJNBEAgASgCDCIEIAJLDQEgASgCACEBIAAgBDYCCCAAIAM2AgQgACABNgIADwsgAyACQeSj/gAQsDsACyAEIAJB9KP+ABCwOwALygECB38CfiMAQRBrIgMkACABKAIEIgVBC08EQCAFQQpB0Kj+ABCwOwALIANBBGohBCABQQhqIQdBACEBAkADQCABIAVGDQEgASAHaiABQQFqIQEtAAAiAkH/AHGtIAmGIAqEIQogAsAiAkEASARAIAlCOVQgCUIHfCEJDQELCyACQQBIDQAgBCABNgIIIARCACAKQgGDfSAKQgGIhT0BBEEBIQYLIAQgBjYCACADKAIEIQEgACADLwEIOwECIAAgATsBACADQRBqJAALVQEBfyMAQRBrIgIkAAJ/IAAoAgAiAC8BAEEBRgRAIAIgAEECajYCDCABQfSo/gBBBCACQQxqQeSo/gAQ0BMMAQsgAUHgqP4AQQQQ+zULIAJBEGokAAtGAQF/IABBOGoQ5jwgACgCXARAIABB3ABqEM8vCyAAQcQAaiIBEMUnIAEQ6DsgAEHQAGoQ3jsgACgCCARAIABBCGoQjjsLC1EAAkAgA0UNAAJAIAIgA00EQCACIANHDQEMAgsgASADaiwAAEG/f0oNAQsgASACIAMgAkHsw4ABEKM2AAsgACACIANrNgIEIAAgASADajYCAAtLAQJ/IwBBEGsiASQAIAAoAgAiAC0AMEEgRgRAIAFBCGogAEE0ahDDNCABKAIIQQRqQQAgASgCDEEBSxsQkSwhAgsgAUEQaiQAIAILVQEBfyMAQRBrIgIkAAJ/IAAoAgAiAC0AAEEBRgRAIAIgAEEBajYCDCABQaiWgQFBBCACQQxqQZiWgQEQ0BMMAQsgAUGUloEBQQQQ+zULIAJBEGokAAtOAQF/IAAoAgwgACgCECIBKAIIQQFrQXhxakEIaiABKAJUEQQAIAAoAhRBCGooAhBqQThqIQEgACgCICIABH8gASAAQQhqKAIQagUgAQsLVgECfwJAIAEEQCABKAIAIgIgAigCACIDQQFqNgIAIANBAEgNASAAIAI2AgAgACABKAIUNgIUIAAgASkCDDcCDCAAIAEpAgQ3AgQPCyAAQQA2AgAPCwALigEBA38gASgCHCIFIAEoAhRGBEAjAEEQayIDJAAgA0EIaiABQRRqIgQgBCgCAEEBQQRBxAAQtxEgAygCCCIEQYGAgIB4RwRAIAQgAygCDEGshIcBEP0vAAsgA0EQaiQACyABKAIYIAVBxABsaiACQcQA/AoAACABIAVBAWo2AhwgACABQdwA/AoAAAtVAQF/IwBBEGsiAiQAAn8gACgCACIAKAIAQQFGBEAgAiAAQQRqNgIMIAFB/MOHAUEEIAJBDGpB7MOHARDQEwwBCyABQejDhwFBBBD7NQsgAkEQaiQAC1UBAX8jAEEQayICJAACfyAAKAIAIgAtAABBAUYEQCACIABBAWo2AgwgAUHs3YcBQQQgAkEMakHc3YcBENATDAELIAFB1t2HAUEEEPs1CyACQRBqJAALTwEBfyAAKAIAIgBBPGpBAUEBEOAeIABBMGoQ0gwgAEEIahCTJwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEHQAEEIEPg6CwtcAQF/IwBBMGsiASQAIAFBAjYCDCABQdiEiAE2AgggAUICNwIUIAFBOzYCLCABQTs2AiQgASAANgIoIAEgAEEEajYCICABIAFBIGo2AhAgAUEIakHohIgBEO8sAAtMACABKAIAIgFBAXEEQCABQX5xIQEgAwRAIAEgAiAD/AoAAAsgACADNgIIIAAgATYCBCAAIAIgA2ogAWs2AgAPCyAAIAEgAiADEI0YC1YBAX8CQCAALQAUQQJGDQAgACgCACIBIAEoAgBBAWsiATYCACABRQRAIAAQmCkLIAAoAhAiAUGEAU8EQCABEPIfCyAAQQxqEKw7RQ0AIABBBGoQvCoLC1YBAn8gASgCACECIAFBADYCAAJAIAIEQCABKAIEIQNBCEEEEK02IgFFDQEgASADNgIEIAEgAjYCACAAQey1iQE2AgQgACABNgIADwsAC0EEQQgQoz0AC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQ3xgLIABBBGohACACQQFrIgINAAsLC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQ8iULIABBBGohACACQQFrIgINAAsLC94CAgR/AW8jAEEgayIBJAACQCAALQAMRQ0AIAAoAgAgAEEANgIAQQFHDQAgASAAKAIENgIMQQFBARCtNiICRQRAQQFBARCjPQALIAJBAToAACABQdjawwA2AgQgASACNgIAIAEoAgAiAkHY2sMAEJM1IQQgAUEQaiIDQdjawwA2AgQgAyACNgIAIAMgBDYCCCABQQxqKAIAJQEQJiEFEN8SIgIgBSYBIAEgAjYCHCABQRxqKAIAJQEgAygCCCUBEFAhBRDfEiIDIAUmASADQYQBTwRAIAMQ8h8gASgCHCECCyACQYQBTwRAIAIQ8h8LIAEoAhgiAkGEAU8EQCACEPIfCyABQQxqENUvCyABQSBqJAACQCAAKAIARQ0AIABBBGoQkT4gACgCBCIBQYQBSQ0AIAEQ8h8LAkAgACgCCCIBRQ0AIAEgASgCAEEBayIBNgIAIAENACAAQQhqELIaCwtaAQF/AkACQAJAAkAgAC0AsAcOBAADAwEDCyAAQaQHahDeOwwBCyAAEOYnCyAAKAKgByIBQQhqEJQfIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQaAHahDZIwsLTgEBfwJAIAAoAgBFBEAgACgCECIAQYQBSQ0BIAAQ8h8PCyAAQRBqEN47IAAoAhwiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQnScLC6EDAgd/AX4jAEHQAGsiAyQAIANBBGoiBSAAEIUjIANBGGohASADKAIEIQIjAEEwayIAJAAgAikDACEIIAIoAjAhBgJAIAIoAghBgICAgHhHBEAgAEEIaiACQQhqEN0gDAELIABBgICAgHg2AggLAkAgAigCFEGAgICAeEcEQCAAQRRqIAJBFGoQxBAMAQsgAEGAgICAeDYCFAsgAigCLCIEIAQoAgAiB0EBajYCAAJAIAdBAE4EQAJAIAIoAiBBgICAgHhHBEAgAEEgaiACQSBqENYeDAELIABBgICAgHg2AiALIAEgACkCCDcCCCABIAApAhQ3AhQgAUEQaiAAQRBqKAIANgIAIAFBHGogAEEcaigCADYCACABIAg3AwAgASAAKQMgNwMgIAFBKGogAEEoaigCADYCACABIAY2AjAgASAENgIsIABBMGokAAwBCwALIAUQ6CogA0EANgIQAn9ByABBCBCtNiIABEAgAEKBgICAEDcDACAAQQhqIANBEGpBwAD8CgAAIAAMAQtBCEHIABCjPQALQQhqIANB0ABqJAALTwECfyMAQcACayICJAAgAkEIaiIDIAAQlRogAyABQQBHOgAoIAJBqAFqIANBmAH8CgAAIAJBADYCoAEgAkGgAWoQ0SlBCGogAkHAAmokAAtYAQF/AkACQAJAIAAtAMQHDgQBAgIAAgsgAEEIahCcJwsgAEG4B2oQ3jsgACgCtAciAUEIahCVHyABIAEoAgAiAUEBazYCACABQQFHDQAgAEG0B2oQxyELC04BAX8gAEEgaiIBEJ8sIAEQ8zsgACgCLEGAgICAeEcEQCAAQSxqEOo7CyAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEIYfCwtRAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ6CcLIABBBGoQoSwgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahCXFQsLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDFKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQxiggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLSAECfyMAQTBrIgMkACADQQxqIgQgABCHIyADQRxqIAMoAgwgASACEM4WIAQQ+yogA0EANgIYIANBGGoQnydBCGogA0EwaiQAC1MBAX8gACgCACIAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPgjCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEQQQQQ+DoLC0oCAX8BfiMAQRBrIgIkACACIAEQpRggACACKAIAQQFGBH4gACACKQMIIgNCAYhCACADQgGDfYU3AwhCAQUgAws3AwAgAkEQaiQAC8MCAgN/An4jAEEQayIDJAAjAEEgayICJAAgAkEEaiIEEPAvIAFBDGooAgAhAQJAAkAgBBDpKQ0AA0AgASgCBCIEIAEpAwgiBSAErSIGIAUgBlQbpyIERgRAIAIoAggNAiADQSVBwKPQAEELEM0aDAMLIAEgBUIBfDcDCCACQRhqIAJBBGogASgCACAEai0AABDUJgJAIAItABhBBEYNACACKQMYIgVC/wGDQgRRDQAgAyAFNwIADAMLIAJBBGoQ6SlFDQALCyACIAJBBGoQ5yUgAi8BAEEBcQRAIAIvAQIhASADQQQ6AAAgAyABOwECDAELIANBJUHAo9AAQQsQzRoLIAJBIGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAy8BAjsBBCAAQQQ2AgALIANBEGokAAvLAgIEfwF+IwBBEGsiAyQAIwBBMGsiAiQAIAJBADoAEyACQRRqIgQQ8C8gAUEMaigCACEBAkACQCAEEOkpDQADQCABKAIAIgQgAkETaiAEKAIIIgRBAEciBRCXGiABIAEoAgQgBWo2AgQgBEUEQCACKAIYDQIgA0ElQdzzzQBBCxDNGgwDCyACQShqIAJBFGogAi0AExDUJgJAIAItAChBBEYNACACKQMoIgZC/wGDQgRRDQAgAyAGNwIADAMLIAJBFGoQ6SlFDQALCyACQQhqIAJBFGoQ5yUgAi8BCEEBcQRAIAIvAQohASADQQQ6AAAgAyABOwECDAELIANBJUHc880AQQsQzRoLIAJBMGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAy8BAjsBBCAAQQQ2AgALIANBEGokAAvLAgIEfwF+IwBBEGsiAyQAIwBBMGsiAiQAIAJBADoAEyACQRRqIgQQ7i8gAUEMaigCACEBAkACQCAEEOkpDQADQCABKAIAIgQgAkETaiAEKAIIIgRBAEciBRCXGiABIAEoAgQgBWo2AgQgBEUEQCACKAIYDQIgA0ElQdzzzQBBCxDNGgwDCyACQShqIAJBFGogAi0AExDUJgJAIAItAChBBEYNACACKQMoIgZC/wGDQgRRDQAgAyAGNwIADAMLIAJBFGoQ6SlFDQALCyACQQhqIAJBFGoQgCggAigCCEEBcQRAIAIoAgwhASADQQQ6AAAgAyABNgIEDAELIANBJUHc880AQQsQzRoLIAJBMGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAygCBDYCBCAAQQQ2AgALIANBEGokAAvGAgIDfwJ+IwBBEGsiAyQAIwBBMGsiAiQAIAJBFGoiBBDuLyABQQxqKAIAIQECQAJAIAQQ6SkNAANAIAEoAgQiBCABKQMIIgUgBK0iBiAFIAZUG6ciBEYEQCACKAIYDQIgA0ElQcCj0ABBCxDNGgwDCyABIAVCAXw3AwggAkEoaiACQRRqIAEoAgAgBGotAAAQ1CYCQCACLQAoQQRGDQAgAikDKCIFQv8Bg0IEUQ0AIAMgBTcCAAwDCyACQRRqEOkpRQ0ACwsgAkEIaiACQRRqEIAoIAIoAghBAXEEQCACKAIMIQEgA0EEOgAAIAMgATYCBAwBCyADQSVBwKPQAEELEM0aCyACQTBqJAACQCADLQAAQQRHBEAgAyADKQMANwMIIAAgA0EIahDQCQwBCyAAIAMoAgQ2AgQgAEEENgIACyADQRBqJAALVwEBfyMAQSBrIgIkACABKAIAQQJGBEAgACABKQIsNwMAIAJBIGokAA8LIAJBADYCGCACQQE2AgwgAkGsrM8ANgIIIAJCBDcCECACQQhqQbSszwAQ7ywAC1IBA38gACgCBCEBIAAoAgwiAiAAKAIAIgM2AAAgACADIAFBeHF2NgIAIAAgACgCBEEHcTYCBCAAIAAoAhAiACACIAFBA3ZqIgEgACABSRs2AgwLTAEBfiABQQF0IAJyrUL/AYMhAyAALQAYIgJBA2oiAUH/AXFBwABPBEAgACADIAEQ8BAPCyAAIAE6ABggACAAKQMQIAMgAq2GhDcDEAtfAQF/IwBBEGsiAiQAIAIgACgCACIAQQxqNgIMIAFB1Kb+AEEQQeSm/gBBBCAAQaSm/gBB6Kb+AEEKIABBEGpBtKb+AEHypv4AQQIgAkEMakHEpv4AEIkXIAJBEGokAAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQ0SggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLXwEBfyMAQRBrIgIkACACIAAoAgAiADYCDCABQazQgAFBCEH9x4ABQQYgAEEIakGM0IABQZHIgAFBBCAAQQxqQYzQgAFBtNCAAUEFIAJBDGpBnNCAARCJFyACQRBqJAAL6gYCAX8FfiABKAIAIAIQhyVFBEAjAEGAAWsiBSQAIAEgAhDQGiEGAkACQAJAIAFBDGotAABBAUYEQCAGQoCAgICAgICAgH9SDQEgBUEANgJoIAVBATYCXCAFQZyV/wA2AlggBUIENwJgIAMgBUHYAGogBCgCFBECAEUNAiAAQZOAgIB4NgIADAMLIAZCgICAgICAgICAf1IEQCAFIAZC6AeBIghCP4ciByAGQugHf3w3A0AgBSAHQugHgyAIfKdBwIQ9bDYCSCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBUE4ajYCYCAFIAVBQGs2AjggAyAFQdgAaiAEKAIUEQIARQ0CIABBk4CAgHg2AgAMAwsgBUEANgJoIAVBATYCXCAFQZyV/wA2AlggBUIENwJgIAMgBUHYAGogBCgCFBECAEUNASAAQZOAgIB4NgIADAILIAUgBkLoB38iB0KYeH4gBnwiCDcDECAFIAZC4NQDfyIJQkR+IAd8Igc3AxggBSAGQoC4mSl/Igo3AwggBSAGQoDd2wF/IgZCRH4gCXw3AyAgBSAKQmh+IAZ8NwMoAkAgCEIAUwRAIAUgByAHQj+HIgaFIAZ9NwMwIAVCACAIfTcDOCAFQQU2AlQgBUGYlv8ANgJQIAVBBjYCRCAFQZiX/wA2AkAgBUHuBjYCfCAFQe4GNgJ0IAVB7gY2AmwgBUHuBjYCZCAFQe4GNgJcIAUgBUE4ajYCeCAFIAVBMGo2AnAgBSAFQSBqNgJoIAUgBUEoajYCYCAFIAVBCGo2AlggBUEFNgJMIAUgBUHYAGo2AkgMAQsgBUEFNgJUIAVBmJb/ADYCUCAFQQY2AkQgBUHolf8ANgJAIAVBBTYCTCAFQe4GNgJ8IAVB7gY2AnQgBUHuBjYCbCAFQe4GNgJkIAVB7gY2AlwgBSAFQdgAajYCSCAFIAVBEGo2AnggBSAFQRhqNgJwIAUgBUEgajYCaCAFIAVBKGo2AmAgBSAFQQhqNgJYCyADIAVBQGsgBCgCFBECAEUNACAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVBgAFqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALmAEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgQQF2IgYgAksEQCAAIAEoAgAgBSgCHCACQQF0ai4BACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8QDAQR/IAEoAhAaIwBBMGsiBSQAIAFBEGooAgAiBigCICACTQRAQciDhgFBLUH4g4YBEJ8pAAsgBigCHCACai0AACEIIAEtAAxBAUYEQAJ/IAYoAiAgAksEQAJAIAYoAiQEfyACIAYoAixBAnYiB08NASAGKAIoIAJBAnRqKAIABSACCwwCCyACIAdBvISGARDDIQALQYiEhgFBJEGshIYBEJ8pAAshAgsCQAJAIAEoAggiByAIwCIGSwRAIAEoAgQgBkEEdGoiASgCAEUNASAFIAE2AgwgBUECNgIUIAVBvPWAATYCECAFQgE3AhwgBUGDETYCLCAFIAVBKGo2AhggBSAFQQxqNgIoAkAgAyAFQRBqIAQoAhQRAgAEQCAAQZOAgIB4NgIADAELIAVBEGogASgCCCACIAMgBCABKAIMKAIMEQcAIAUoAhAiAUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgATYCAAwBCyADQf0AIAQoAhARAgAEQCAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVBMGokAAwCCyAGIAdBmPWAARDDIQALQaj1gAEQsjsACwvzAgICfwF+IAEoAhAgAhCHJUUEQCMAQYABayIFJAAgBSABQRBqIgYgAhDQGiIHNwMAIAVBJGogBxD9FQJAIAUoAiRFBEAgBSAGKAIANgJsIAVBAjYCWCAFQdyU/wA2AlQgBUICNwJgIAVBpwQ2AnwgBUHuBjYCdCAFIAVB8ABqNgJcIAUgBUHsAGo2AnggBSAFNgJwIAVBxABqIAVB1ABqEJkOIAVBEGogBUHMAGooAgAiATYCACAFIAUpAkQiBzcDGCAFIAc3AwggBSgCUCECIABBDGogATYCACAAIAc3AgQgACACNgIQIABBgoCAgHg2AgAMAQsgBUE4aiAFQSxqKAIANgIAIAUgBSkCJDcDMCAAIAMgBCAFQTBqIAEoAgAgASgCBCABKAIIIAEoAgwQhwoLIAVBgAFqJAAPCwJAIAEoAhgiAgRAIAMgASgCFCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALzAQCA38CfiABKAIAIAIQhyVFBEAgAUEMaiEGIwBB8ABrIgUkACAFIAEgAhDQGiIINwMAAkACQCAIQsCEPX8iCaciAkH/ogVNBEAgCCAJQsCEPX59p0HoB2wiB0GAqNa5B0kNAQsgBSABKAIANgIMIAVBAjYCMCAFQYCV/wA2AiwgBUICNwI4IAVBpwQ2AmwgBUHuBjYCZCAFIAVB4ABqNgI0IAUgBUEMajYCaCAFIAU2AmAgBUEYaiAFQSxqEJkOIAUpAhghCCAAIAUpAiA3AgwgACAINwIEIABBgoCAgHg2AgAMAQsgBSAHNgIQIAUgAjYCDAJAAkAgBigCACIBBEAgBUEBNgIYIAVBtJP/ADYCFCAFQgE3AiAgBUGRDDYCZCAFQQA2AlwgBUEAOgBYIAVCBDcCUCAFIAE2AkggBUGAgICAeDYCOCAFIAc2AjQgBSACNgIwIAVBATYCLCAFIAYoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvNBQICfwV+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACENAaIgc3AwACQAJAAkAgByAHQugHfyIHQugHfn0iCEI/hyIJIAd8IgcgB0KAowV/IgdCgKMFfn0iCkI/hyILIAd8IgdCxY3U/wd9QoCAgIBwVA0AIAenQbvyK2oQ8xYiAkUNACAFIAlC6AeDIAh8p0HAhD1sNgI0IAUgC0KAowWDIAp8PgIwIAUgAjYCLCAFQQxqIAVBLGoQyi8gBSgCDCICDQELIAUgASgCADYCJCAFQQI2AjAgBUGAlf8ANgIsIAVCAjcCOCAFQacENgJsIAVB7gY2AmQgBSAFQeAAajYCNCAFIAVBJGo2AmggBSAFNgJgIAVBEGogBUEsahCZDiAFKAIQIQEgBSkCFCEHIAAgBSgCHDYCECAAIAc3AgggACABNgIEIABBgoCAgHg2AgAMAQsgBSAFKQIQIgc3AmQgBSACNgJgAkACQCAGKAIAIgEEQCAFQQE2AhAgBUG0k/8ANgIMIAVCATcCGCAFQZEMNgIoIAUgAjYCXCAFQQA6AFggBUIENwJQIAUgATYCSCAFQYCAgIB4NgI4IAVBATYCLCAFIAYoAgQ2AkwgBSAHPgIwIAUgB0IgiD4CNCAFIAVBJGo2AhQgBSAFQSxqIgE2AiQgAyAFQQxqIAQoAhQRAgBFDQEgAEGTgICAeDYCACABEIkvDAMLIAVBATYCMCAFQbST/wA2AiwgBUIBNwI4IAVBkww2AhAgBSAFQQxqNgI0IAUgBUHgAGo2AgwgAyAFQSxqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQSxqEIkvCyAAQZSAgIB4NgIACyAFQfAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8oEAgN/An4gASgCACACEIclRQRAIAFBDGohBiMAQfAAayIFJAAgBSABIAIQ0BoiCDcDAAJAAkAgCCAIQoCU69wDfyIIQoCU69wDfn0iCUIAWQRAIAinIgJBgKMFSQ0BCyAFIAEoAgA2AgwgBUECNgIwIAVBgJX/ADYCLCAFQgI3AjggBUGnBDYCbCAFQe4GNgJkIAUgBUHgAGo2AjQgBSAFQQxqNgJoIAUgBTYCYCAFQRhqIAVBLGoQmQ4gBSkCGCEIIAAgBSkCIDcCDCAAIAg3AgQgAEGCgICAeDYCAAwBCyAFIAI2AgwgBSAJpyIBNgIQAkACQCAGKAIAIgcEQCAFQQE2AhggBUG0k/8ANgIUIAVCATcCICAFQZEMNgJkIAVBADYCXCAFQQA6AFggBUIENwJQIAUgBzYCSCAFQYCAgIB4NgI4IAUgATYCNCAFIAI2AjAgBUEBNgIsIAUgBigCBDYCTCAFIAVB4ABqNgIcIAUgBUEsaiIBNgJgIAMgBUEUaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAgARCJLwwDCyAFQQE2AjAgBUG0k/8ANgIsIAVCATcCOCAFQZQMNgIYIAUgBUEUajYCNCAFIAVBDGo2AhQgAyAFQSxqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQSxqEIkvCyAAQZSAgIB4NgIACyAFQfAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5gBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCIEEDdiIGIAJLBEAgACABKAIAIAUoAhwgAkEDdGooAgAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvzAgICfwF+IAEoAhAgAhCHJUUEQCMAQYABayIFJAAgBSABQRBqIgYgAhDQGiIHNwMAIAVBJGogBxDWFQJAIAUoAiRFBEAgBSAGKAIANgJsIAVBAjYCWCAFQdyU/wA2AlQgBUICNwJgIAVBpwQ2AnwgBUHuBjYCdCAFIAVB8ABqNgJcIAUgBUHsAGo2AnggBSAFNgJwIAVBxABqIAVB1ABqEJkOIAVBEGogBUHMAGooAgAiATYCACAFIAUpAkQiBzcDGCAFIAc3AwggBSgCUCECIABBDGogATYCACAAIAc3AgQgACACNgIQIABBgoCAgHg2AgAMAQsgBUE4aiAFQSxqKAIANgIAIAUgBSkCJDcDMCAAIAMgBCAFQTBqIAEoAgAgASgCBCABKAIIIAEoAgwQhwoLIAVBgAFqJAAPCwJAIAEoAhgiAgRAIAMgASgCFCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL8wICAn8BfiABKAIQIAIQhyVFBEAjAEGAAWsiBSQAIAUgAUEQaiIGIAIQ0BoiBzcDACAFQSRqIAcQ/RcCQCAFKAIkRQRAIAUgBigCADYCbCAFQQI2AlggBUHclP8ANgJUIAVCAjcCYCAFQacENgJ8IAVB7gY2AnQgBSAFQfAAajYCXCAFIAVB7ABqNgJ4IAUgBTYCcCAFQcQAaiAFQdQAahCZDiAFQRBqIAVBzABqKAIAIgE2AgAgBSAFKQJEIgc3AxggBSAHNwMIIAUoAlAhAiAAQQxqIAE2AgAgACAHNwIEIAAgAjYCECAAQYKAgIB4NgIADAELIAVBOGogBUEsaigCADYCACAFIAUpAiQ3AzAgACADIAQgBUEwaiABKAIAIAEoAgQgASgCCCABKAIMEIcKCyAFQYABaiQADwsCQCABKAIYIgIEQCADIAEoAhQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5gBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCIEECdiIGIAJLBEAgACABKAIAIAUoAhwgAkECdGooAgAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAumBAICfwF+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACEM8aIgI2AggCQCACQYCjBU8EQCAFIAEoAgA2AgwgBUECNgIwIAVBgJX/ADYCLCAFQgI3AjggBUGnBDYCbCAFQZwDNgJkIAUgBUHgAGo2AjQgBSAFQQxqNgJoIAUgBUEIajYCYCAFQRhqIAVBLGoQmQ4gBSkCGCEHIAAgBSkCIDcCDCAAIAc3AgQgAEGCgICAeDYCAAwBCyAFQQA2AhAgBSACNgIMAkACQCAGKAIAIgEEQCAFQQE2AhggBUG0k/8ANgIUIAVCATcCICAFQZEMNgJkIAVBADYCXCAFQQA6AFggBUIENwJQIAUgATYCSCAFQoCAgICAgICAgH83AjQgBSACNgIwIAVBATYCLCAFIAYoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvPBAIGfwJ+IAEoAgAgAhCHJUUEQCABQQxqIQcjAEEwayIFJAACQCABKAIAIgEoAhRBA3YiBiACSwRAIAVBJGohBiABKAIQIAJBA3RqKQMAIQsgBy0AACEIIActAAEhByMAQUBqIgEkAAJAAkACQCALQgBZBEAgAUEgakETQQBBAUEBEKAYIAEoAiQhAiABKAIgQQFGDQIgAUEANgI8IAEgASgCKDYCOCABIAI2AjQMAQsgAUEgakEUQQBBAUEBEKAYIAEoAiQhAiABKAIgQQFGDQEgAUEANgI8IAEgASgCKDYCOCABIAI2AjQgAUE0akEBEIQuIAEoAjggASgCPGpBLToAACABQQE2AjwLIAFBCGoiAkETIAsgC0I/hyIMhSAMfSABQSBqIglBExDtECIKazYCBCACIAkgCmo2AgAgAUE0aiABKAIIIgIgAiABKAIMahC9JiABQRhqIAFBPGooAgAiAjYCACABIAEpAjQ3AxAgBiABKAIUIAIgCCAHEL0JIAFBEGoQ3jsgAUFAayQADAELIAIgASgCKEGsvYUBEP0vAAsgBUGQDDYCICAFQQE2AgggBUG0k/8ANgIEIAVCATcCECAFIAY2AhwgBSAFQRxqNgIMIAMgBUEEaiAEKAIUEQIAIQEgBhDeOyAAQZOAgIB4QZSAgIB4IAEbNgIAIAVBMGokAAwBCyACIAZBmJT/ABDDIQALDwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC74EAQV/IAEoAgwgAhCUJUUEQCACIQcjAEEwayIFJAAgASgCCCEGIAEoAgQhAgJAIANB+wAgBCgCECIIEQIABEAgAEGTgICAeDYCAAwBCyACIQEgBgRAIAUgATYCDCAFQQI2AhQgBUGk9IABNgIQIAVCATcCHCAFQYMRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAQoAhQRAgAEQCAAQZOAgIB4NgIADAILIAVBEGogAigCCCAHIAMgBCACKAIMKAIMEQcAIAUoAhAiAUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgATYCAAwCCyACQRBqIQELIAIgBkEEdGoiAiABRwRAIAQoAhQhBgNAIAUgATYCDCAFQQI2AhQgBUG49IABNgIQIAVCATcCHCAFQYMRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAYRAgAEQCAAQZOAgIB4NgIADAMLIAVBEGogAUEIaigCACAHIAMgBCABQQxqKAIAKAIMEQcAIAUoAhAiCUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgCTYCAAwDCyABQRBqIgEgAkcNAAsLIANB/QAgCBECAARAIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIUIgIEQCADIAEoAhAgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC7kBAQN/IAEoAgggAhCSJUUEQAJAIAJBAWoiBiABQQhqKAIAIgcoAhxBA3YiBUkEQCACIAVJDQEgAiAFQezpgAEQwyEACyAGIAVB3OmAARDDIQALIAAgAyAEIAcoAhgiACACQQN0aigCACAAIAZBA3RqKAIAIAEoAgAgASgCBBChEg8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuyBAEFfyABKAIAIAIQhyVFBEAgAUEMaiEHIwBBMGsiBSQAAkAgASgCACIBKAIUQQJ2IgYgAksEQCAFQSRqIQYgASgCECACQQJ0aigCACEIIActAAAhCSAHLQABIQcjAEEwayIBJAACQAJAAkAgCEEATgRAIAFBIGpBCkEAQQFBARCgGCABKAIkIQIgASgCIEEBRg0CIAFBADYCHCABIAEoAig2AhggASACNgIUDAELIAFBIGpBC0EAQQFBARCgGCABKAIkIQIgASgCIEEBRg0BIAFBADYCHCABIAEoAig2AhggASACNgIUIAFBFGpBARCELiABKAIYIAEoAhxqQS06AAAgAUEBNgIcCyABIAggCEEfdSICcyACayABQQpqELAQIAFBFGogASgCACICIAIgASgCBGoQvSYgAUEoaiABQRxqKAIAIgI2AgAgASABKQIUNwMgIAYgASgCJCACIAkgBxC9CSABQSBqEN47IAFBMGokAAwBCyACIAEoAihBrL2FARD9LwALIAVBkAw2AiAgBUEBNgIIIAVBtJP/ADYCBCAFQgE3AhAgBSAGNgIcIAUgBUEcajYCDCADIAVBBGogBCgCFBECACEBIAYQ3jsgAEGTgICAeEGUgICAeCABGzYCACAFQTBqJAAMAQsgAiAGQZiU/wAQwyEACw8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvKBAIDfwF+IAEoAgAgAhCHJUUEQCABQQxqIQcjAEHwAGsiBSQAIAUgASACEM8aIgY2AggCQAJAIAZB6AdtIgJB/6IFTQRAIAYgAkHoB2xrQcCEPWwiBkGAqNa5B0kNAQsgBSABKAIANgIMIAVBAjYCMCAFQYCV/wA2AiwgBUICNwI4IAVBpwQ2AmwgBUGcAzYCZCAFIAVB4ABqNgI0IAUgBUEMajYCaCAFIAVBCGo2AmAgBUEYaiAFQSxqEJkOIAUpAhghCCAAIAUpAiA3AgwgACAINwIEIABBgoCAgHg2AgAMAQsgBSAGNgIQIAUgAjYCDAJAAkAgBygCACIBBEAgBUEBNgIYIAVBtJP/ADYCFCAFQgE3AiAgBUGRDDYCZCAFQQA2AlwgBUEAOgBYIAVCBDcCUCAFIAE2AkggBUGAgICAeDYCOCAFIAY2AjQgBSACNgIwIAVBATYCLCAFIAcoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvYBAIBfwN+IAEoAgAgAhCHJUUEQCMAQeAAayIFJAAgASACENAaIgZC+KeNr7qTsRB9IQcCQAJAAkAgAUEMai0AAEEBRgRAIAdCkbDloYvZnV9UDQEgBSAGQoCjBX8iBzcDCCAFIAZCPH8iCEJEfiAGfDcDECAFIAZCkBx/IgZCRH4gCHw3AxggBSAHQmh+IAZ8NwMgIAVBBTYCLCAFQbyV/wA2AiggBUIENwI0IAVB7gY2AlwgBUHuBjYCVCAFQe4GNgJMIAVB7gY2AkQgBSAFQUBrNgIwIAUgBUEQajYCWCAFIAVBGGo2AlAgBSAFQSBqNgJIIAUgBUEIajYCQCADIAVBKGogBCgCFBECAEUNAiAAQZOAgIB4NgIADAMLIAdCkbDloYvZnV9aBEAgBUEANgIwIAUgBjcDKCAFQQE2AkQgBUG0k/8ANgJAIAVCATcCTCAFQZUMNgIkIAUgBUEgajYCSCAFIAVBKGo2AiAgAyAFQUBrIAQoAhQRAgBFDQIgAEGTgICAeDYCAAwDCyAFQQA2AlAgBUEBNgJEIAVBnJX/ADYCQCAFQgQ3AkggAyAFQUBrIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQQA2AlAgBUEBNgJEIAVBnJX/ADYCQCAFQgQ3AkggAyAFQUBrIAQoAhQRAgBFDQAgAEGTgICAeDYCAAwBCyAAQZSAgIB4NgIACyAFQeAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+EEAQJ/IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACEM8aIgI2AgwCQAJAAkAgAqxCxY3U/wd9QoCAgIBwVA0AIAJBu/IrahDzFiICRQ0AIAVCADcCLCAFIAI2AiggBUEQaiAFQShqEMovIAUoAhAiAg0BCyAFIAEoAgA2AlwgBUECNgIsIAVBgJX/ADYCKCAFQgI3AjQgBUGnBDYCbCAFQZwDNgJkIAUgBUHgAGo2AjAgBSAFQdwAajYCaCAFIAVBDGo2AmAgBUEUaiAFQShqEJkOIAAgBSkCGDcCCCAAQRBqIAVBIGooAgA2AgAgACAFKAIUNgIEIABBgoCAgHg2AgAMAQsgBSACNgJcAkACQCAGKAIAIgEEQCAFQQE2AhQgBUG0k/8ANgIQIAVCATcCHCAFQZEMNgJkIAUgAjYCWCAFQQA6AFQgBUIENwJMIAUgATYCRCAFQYCAgIB4NgI0IAVBADYCKCAFIAYoAgQ2AkggBSAFQeAAajYCGCAFIAVBKGoiATYCYCADIAVBEGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIsIAVBtJP/ADYCKCAFQgE3AjQgBUGSDDYCFCAFIAVBEGo2AjAgBSAFQdwAajYCECADIAVBKGogBCgCFBECAEUNASAAQZOAgIB4NgIADAILIAVBKGoQiS8LIABBlICAgHg2AgALIAVB8ABqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALkgEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgIgYgAksEQCAAIAEoAgAgBSgCHCACaiwAACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5IBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCICIGIAJLBEAgACABKAIAIAUoAhwgAmotAAAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAu5AQEDfyABKAIIIAIQkiVFBEACQCACQQFqIgYgAUEIaigCACIHKAIcQQJ2IgVJBEAgAiAFSQ0BIAIgBUHs6YABEMMhAAsgBiAFQdzpgAEQwyEACyAAIAMgBCAHKAIYIgAgAkECdGooAgAgACAGQQJ0aigCACABKAIAIAEoAgQQoRIPCwJAIAEoAhAiAgRAIAMgASgCDCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALmAEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgQQF2IgYgAksEQCAAIAEoAgAgBSgCHCACQQF0ai8BACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC84FAgF/BX4gASgCACACEIclRQRAIwBBgAFrIgUkACABIAIQ0BohBgJAAkAgAUEMai0AAEUEQCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBkLAhD2BIghCP4ciByAGQsCEPX98NwNAIAUgB0LAhD2DIAh8p0HoB2w2AkggBSAFQThqNgJgIAUgBUFAazYCOCADIAVB2ABqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFIAZCwIQ9fyIHQsD7Qn4gBnwiCDcDECAFIAZCgI7OHH8iCUJEfiAHfCIHNwMYIAUgBkKAwN3uwQJ/Igo3AwggBSAGQoDIzrQNfyIGQkR+IAl8NwMgIAUgCkJofiAGfDcDKAJAIAhCAFMEQCAFIAcgB0I/hyIGhSAGfTcDMCAFQgAgCH03AzggBUEFNgJUIAVByJf/ADYCUCAFQQY2AkQgBUGYl/8ANgJAIAVB7gY2AnwgBUHuBjYCdCAFQe4GNgJsIAVB7gY2AmQgBUHuBjYCXCAFIAVBOGo2AnggBSAFQTBqNgJwIAUgBUEgajYCaCAFIAVBKGo2AmAgBSAFQQhqNgJYIAVBBTYCTCAFIAVB2ABqNgJIDAELIAVBBTYCVCAFQciX/wA2AlAgBUEGNgJEIAVB6JX/ADYCQCAFQQU2AkwgBUHuBjYCfCAFQe4GNgJ0IAVB7gY2AmwgBUHuBjYCZCAFQe4GNgJcIAUgBUHYAGo2AkggBSAFQRBqNgJ4IAUgBUEYajYCcCAFIAVBIGo2AmggBSAFQShqNgJgIAUgBUEIajYCWAsgAyAFQUBrIAQoAhQRAgBFDQAgAEGTgICAeDYCAAwBCyAAQZSAgIB4NgIACyAFQYABaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC9gFAgF/BX4gASgCACACEIclRQRAIwBBgAFrIgUkACABIAIQ0BohBgJAAkAgAUEMai0AAEUEQCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBkKAlOvcA4EiCEI/hyIHIAZCgJTr3AN/fDcDQCAFIAdCgJTr3AODIAh8PgJIIAUgBUE4ajYCYCAFIAVBQGs2AjggAyAFQdgAaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBSAGQoCU69wDfyIHQoDslKN8fiAGfCIINwMQIAUgBkKAsJ3C3wF/IglCRH4gB3wiBzcDGCAFIAZCgIC8isnSE38iCjcDCCAFIAZCgMDihePoAH8iBkJEfiAJfDcDICAFIApCaH4gBnw3AygCQCAIQgBTBEAgBSAHIAdCP4ciBoUgBn03AzAgBUIAIAh9NwM4IAVBBTYCVCAFQcCY/wA2AlAgBUEGNgJEIAVBmJf/ADYCQCAFQe4GNgJ8IAVB7gY2AnQgBUHuBjYCbCAFQe4GNgJkIAVB7gY2AlwgBSAFQThqNgJ4IAUgBUEwajYCcCAFIAVBIGo2AmggBSAFQShqNgJgIAUgBUEIajYCWCAFQQU2AkwgBSAFQdgAajYCSAwBCyAFQQU2AlQgBUHAmP8ANgJQIAVBBjYCRCAFQeiV/wA2AkAgBUEFNgJMIAVB7gY2AnwgBUHuBjYCdCAFQe4GNgJsIAVB7gY2AmQgBUHuBjYCXCAFIAVB2ABqNgJIIAUgBUEQajYCeCAFIAVBGGo2AnAgBSAFQSBqNgJoIAUgBUEoajYCYCAFIAVBCGo2AlgLIAMgBUFAayAEKAIUEQIARQ0AIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUGAAWokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvZAwIEfwR+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEEwayIFJAACQCABKAIAIgEoAhRBBXYiByACSwRAIAEoAhAgAkEFdGoiASkDACEJIAEpAwghCiABKQMQIQsgASkDGCEMIAYtAAAhByAGLQABIQYjAEHQAGsiASQAIAEgDDcDGCABIAs3AxAgASAKNwMIIAEgCTcDACABQQA2AjwgAUKAgICAEDcCNCABQay8hQE2AkQgAUKggICADjcCSCABIAFBNGo2AkAgASABQUBrEIENBEBB1LyFAUE3IAFBKGpBxLyFAUGMvYUBENUeAAsgAUEwaiABQTxqKAIAIgg2AgAgASABKQI0NwMoIAVBJGoiAiABKAIsIAggByAGEL0JIAFBKGoQ3jsgAUHQAGokACAFQZAMNgIgIAVBATYCCCAFQbST/wA2AgQgBUIBNwIQIAUgAjYCHCAFIAVBHGo2AgwgAyAFQQRqIAQoAhQRAgAhASACEN47IABBk4CAgHhBlICAgHggARs2AgAgBUEwaiQADAELIAIgB0GYlP8AEMMhAAsPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL7gQCBn8CfiABKAIAIAIQhyVFBEAgAUEMaiEHIwBBMGsiBSQAAkAgASgCACIBKAIUQQR2IgYgAksEQCAFQSRqIQYgASgCECACQQR0aiIBKQMAIQwgASkDCCELIActAAAhCSAHLQABIQcjAEHQAGsiASQAAkACQAJAIAtCAFkEQCABQRxqQSdBAEEBQQEQoBggASgCICECIAEoAhxBAUYNAiABQQA2AkwgASABKAIkNgJIIAEgAjYCRAwBCyABQRxqQShBAEEBQQEQoBggASgCICECIAEoAhxBAUYNASABQQA2AkwgASABKAIkNgJIIAEgAjYCRCABQcQAakEBEIQuIAEoAkggASgCTGpBLToAACABQQE2AkwLIAFBCGoiAkEnQgAgDH0gDCALQgBTIggbQgAgCyAMQgBSrXx9IAsgCBsgAUEcaiIIEPoCIgprNgIEIAIgCCAKajYCACABQcQAaiABKAIIIgIgAiABKAIMahC9JiABQRhqIAFBzABqKAIAIgI2AgAgASABKQJENwMQIAYgASgCFCACIAkgBxC9CSABQRBqEN47IAFB0ABqJAAMAQsgAiABKAIkQay9hQEQ/S8ACyAFQZAMNgIgIAVBATYCCCAFQbST/wA2AgQgBUIBNwIQIAUgBjYCHCAFIAVBHGo2AgwgAyAFQQRqIAQoAhQRAgAhASAGEN47IABBk4CAgHhBlICAgHggARs2AgAgBUEwaiQADAELIAIgBkGYlP8AEMMhAAsPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL8wICAn8BfiABKAIQIAIQhyVFBEAjAEGAAWsiBSQAIAUgAUEQaiIGIAIQ0BoiBzcDACAFQSRqIAcQgRUCQCAFKAIkRQRAIAUgBigCADYCbCAFQQI2AlggBUHclP8ANgJUIAVCAjcCYCAFQacENgJ8IAVB7gY2AnQgBSAFQfAAajYCXCAFIAVB7ABqNgJ4IAUgBTYCcCAFQcQAaiAFQdQAahCZDiAFQRBqIAVBzABqKAIAIgE2AgAgBSAFKQJEIgc3AxggBSAHNwMIIAUoAlAhAiAAQQxqIAE2AgAgACAHNwIEIAAgAjYCECAAQYKAgIB4NgIADAELIAVBOGogBUEsaigCADYCACAFIAUpAiQ3AzAgACADIAQgBUEwaiABKAIAIAEoAgQgASgCCCABKAIMEIcKCyAFQYABaiQADwsCQCABKAIYIgIEQCADIAEoAhQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+cFAQh/IAEoAhAgAhCTJUUEQCMAQSBrIgUkAAJAAkACQAJAIAJBAWoiByABQRBqKAIAIggoAkhBAnYiBkkEQAJAIAIgBkkEQCAIKAJEIgYgB0ECdGooAgAhByAGIAJBAnRqKAIAIQIgA0H7ACAEKAIQIggRAgBFDQEMBQsgAiAGQdj0gAEQwyEACyACIAdPDQIgBUEIaiABKAIAIAIgAyAEIAEoAgQoAgwRBwAgBSgCCCIGQZSAgIB4RwRAIAAgBSkCDDcCBCAAQQxqIAVBFGopAgA3AgAMBQsgBUEANgIYIAVBATYCDCAFQej0gAE2AgggBUIENwIQIAMgBUEIaiIGIAQoAhQRAgANAyAGIAEoAgggAiADIAQgASgCDCgCDBEHACAFKAIIIgZBlICAgHhGDQEgACAFKQIMNwIEIABBDGogBUEUaikCADcCAAwECyAHIAZByPSAARDDIQALIAJBAWohAgsgAiAHSQRAIAEoAgwhCSABKAIIIQogASgCBCELIAEoAgAhDCAEKAIUIQEDQCAFQQA2AhggBUHw9IABNgIIIAVCBDcCECAFQQE2AgwgAyAFQQhqIgYgARECAA0CIAYgDCACIAMgBCALKAIMEQcAIAUoAggiBkGUgICAeEcEQCAAIAUpAgw3AgQgAEEMaiAFQRRqKQIANwIADAQLIAVBADYCGCAFQQE2AgwgBUHo9IABNgIIIAVCBDcCECADIAVBCGoiBiABEQIADQIgBiAKIAIgAyAEIAkoAgwRBwAgBSgCCCIGQZSAgIB4RwRAIAAgBSkCDDcCBCAAQQxqIAVBFGopAgA3AgAMBAsgByACQQFqIgJHDQALC0GTgICAeEGUgICAeCADQf0AIAgRAgAbIQYMAQtBk4CAgHghBgsgACAGNgIAIAVBIGokAA8LAkAgASgCGCICBEAgAyABKAIUIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAtRAQF/IAAQtAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahC7IwsLyAEBA38gACABKAIMIAEoAgQiAmsiBEEMbiIDEP0tIAQEQCAAKAIEIAAoAghBDGxqIAIgBPwKAAALIAEgAjYCDCAAIAAoAgggA2o2AggjAEEQayICJAAgASgCDCIDIAEoAgQiAGtBDG4hBCAAIANHBEADQCAAKAIAIgMgAygCACIDQQFrNgIAIANBAUYEQCAAEPseCyAAQQxqIQAgBEEBayIEDQALCyACIAEoAgA2AgwgAiABKAIINgIIIAJBCGoQ6DsgAkEQaiQAC1EBAX8gABC2DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSBqELsjCwtRAQF/IAAQtwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahC7IwsLVgECfyMAQSBrIgMkACADIAEQyzoiBDYCBCAERQRAIAAgARDINCAAIAI2AjggA0EgaiQADwsgA0EANgIIQQAgA0EEakHIg4MBIANBCGpBzIODARCvKwALUQEBfyAAEL4MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQuyMLC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQuyMLIABBCGohACACQQFrIgINAAsLC1EBAX8gABDBDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSBqELsjCwtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEN0mIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEP0cIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEP4cIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEIAdIARBEGokAAtSAQF/IwBBEGsiAiQAIAJBCGogASgCACABKAIEIgEoAghBAWtBeHFqQQhqIAEoAhARAAAgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQAC1IBAX8jAEEgayIBJAAgAC0ADEEhRgRAIAAtAA0gAUEgaiQADwsgAUEANgIYIAFBATYCDCABQaCFhgE2AgggAUIENwIQIAFBCGpBqIWGARDvLAALSwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACENsoIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIC08BAX8gAiABayICIAAoAgAgACgCCCIDa0sEQCAAIAMgAkEBQQEQ3CggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDeKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtTAQJ/IwBBEGsiAiQAAkAgASgCCCIDIAEoAgRJBEAgAEEAOgAAIAAgASgCACADai0AADoAAQwBCyACQQQ2AgQgACABIAJBBGoQnSkLIAJBEGokAAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQ4CggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDhKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtNAQF/IAAoAggiACgCACAAKAIIIgNrIAJJBEAgACADIAIQhRMgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/AkACQAJAIAAtAEQOBAECAgACCyAALQA4QQNGBEAgAEE0ahCwLAsLIAAoAggiAUGDAUsEQCABEPIfCyAAQUBrEK8sCwtnAQJ/IABBIGohAQNAIAEoAgQiAgRAIAEgAhCMHRCJJAwBCwsgACgCICICIAIoAgAiAkEBazYCACACQQFGBEAgARDbHwsgAEEsaiIBEIIjIAFBCEEgEOAeIABBQGsiABDUJyAAEO47C2cBAn8gAEEQaiEBA0AgASgCBCICBEAgASACEIsdEIgkDAELCyAAKAIQIgIgAigCACICQQFrNgIAIAJBAUYEQCABENofCyAAQRxqIgEQgiMgAUEIQSAQ4B4gAEFAayIAENQnIAAQ7jsLpgIBA38jAEEQayIEJAAgBCABNgIMAkACQAJAAkAgAUEIaiIDLQAoRQRAIAMtAAwgA0EBOgAMDQMgAygCAEGAgICAeEcNASADQQA6AAwgAyACKQIANwIAIANBCGogAkEIaigCADYCACADLQAoRQ0CIAMtAAwgA0EBOgAMDQIgAygCACECIANBgICAgHg2AgAgAkGAgICAeEcEQCAAIAMpAgQ3AgQgACACNgIAIANBADoADAwFCyADQQA6AAwMAgsMAgtBiIHDAEEgQaiBwwAQnykACyAAQYCAgIB4NgIADAELIAAgAikCADcCACAAQQhqIAJBCGooAgA2AgALIAMQlR8gASABKAIAIgBBAWs2AgAgAEEBRgRAIARBDGoQxyELIARBEGokAAugAgEDfyMAQRBrIgQkACAEIAE2AgwCQAJAAkACQCABQQhqIgMtACxFBEAgAy0AECADQQE6ABANAyADKAIADQEgA0EAOgAQIAMgAikCADcCACADQQhqIAJBCGopAgA3AgAgAy0ALEUNAiADLQAQIANBAToAEA0CIAMoAgAhAiADQQA2AgAgAgRAIAAgAjYCACADQQA6ABAgACADKQIENwIEIABBDGogA0EMaigCADYCAAwFCyADQQA6ABAMAgsMAgtBiIHDAEEgQaiBwwAQnykACyAAQQA2AgAMAQsgACACKQIANwIAIABBCGogAkEIaikCADcCAAsgAxCTHyABIAEoAgAiAEEBazYCACAAQQFGBEAgBEEMahDtHQsgBEEQaiQAC6YCAQN/IwBBEGsiBCQAIAQgATYCDAJAAkACQAJAIAFBCGoiAy0ALEUEQCADLQAQIANBAToAEA0DIAMoAgBBB0cNASADQQA6ABAgAyACKQIANwIAIANBCGogAkEIaikCADcCACADLQAsRQ0CIAMtABAgA0EBOgAQDQIgAygCACECIANBBzYCACACQQdHBEAgACACNgIAIANBADoAECAAIAMpAgQ3AgQgAEEMaiADQQxqKAIANgIADAULIANBADoAEAwCCwwCC0GIgcMAQSBBqIHDABCfKQALIABBBzYCAAwBCyAAIAIpAgA3AgAgAEEIaiACQQhqKQIANwIACyADEJMfIAEgASgCACIAQQFrNgIAIABBAUYEQCAEQQxqEJYfCyAEQRBqJAALUQEBf0EYQQgQrTYiAkUEQEEIQRgQoz0ACyAAIAI2AgQgAEEBNgIAIAIgASkDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAC1MBAX8gABDSJCAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABDUIgsCQCAAKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ6ScLC1UBAX9BFEEEEK02IgJFBEBBBEEUEKM9AAsgACACNgIEIABBgICAgHg2AgAgAiABKQIANwIAIAJBEGogAUEQaigCADYCACACQQhqIAFBCGopAgA3AgALUAECfyABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0EDdCAEQQN2IAIQgRYgACADNgIEIAEgAiADajYCFCAAQQg2AgALUAECfyABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0ECdCAEQQJ2IAIQghYgACADNgIEIAEgAiADajYCFCAAQQg2AgALUAEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLhAEBAX9BASEDAkACQAJAAkACQCAALQAAQQFrDhECAgEDAwMDBAIBAQEDAgICAAELAkAgAUH/AXFBAWsOFgECAgIBAwMDAwMDAQEBAQMDAwMBAQIAC0KBgICQgIDAgAEgAkEDdK1C+AGDiKchAwsgAw8LQQIPC0EADwsgAC0AAkF/c0EBcQtLAgJ/AX4jAEEQayIDJAAgACgCACIAKAIAIANBCGogACgCBCABKAIAIAJBA3RrQQhrKQMAEPIdIAMoAgggAygCDBDNAiADQRBqJAALSQEDfwJAIAAoAhAiAUUNACABIAAoAggiAiAAKAIEIAFBAWpsakEBa0EAIAJrcSIDakEJaiIBRQ0AIAAoAgwgA2sgASACEPg6CwtZAQF/IAAgABCZPiIAQQdqQXhxIABrIgIQmD4hAEHM84oBIAEgAmsiATYCAEHU84oBIAA2AgAgACABQQFyNgIEIAAgARCYPkHg84oBQYCAgAE2AgBBKDYCBAtQAQF/AkAgASACTQRAIAIgACgCBCIESw0BIAIgAWsiAgRAIAAoAgAgAWogAyAC/AoAAAsPCyABIAJB0IH9ABCxOwALIAIgBEHQgf0AELA7AAtTACAAQgA3AhwgAEEANgIYIABCADcDECAAQQA2AgggAEEsakEANgIAIABBJGpCADcCACAAQc+Moo4GNgIMIABB95Svr3g2AgQgAEGoiI2hAjYCAAvYAQECfyABKAIEIgMgASgCAEkEQCADQQpJBEAgAEEEOgAAIAEgA0EBajYCBCABIANqIAI6AAgPCyADQQpBwLX+ABDDIQALIwBBEGsiASQAIAFBBGpBE0EAQQFBARCgGCABKAIIIQMCQAJAIAEoAgRBAUcEQCABKAIMIgRB0LX+AEET/AoAAEEMQQQQrTYiAkUNASACQRM2AgggAiAENgIEIAIgAzYCACAAQRUgAkHws/4AEMkpIAFBEGokAAwCCyADIAEoAgxBnLT+ABD9LwALQQRBDBCjPQALC0wBAX8gACgCCCIBBEAgACgCBEEIaiEAA0ACQCAAQQhrKAIARQ0AIAAoAgBBgICAgHhGDQAgABDeOwsgAEEUaiEAIAFBAWsiAQ0ACwsLTAECfyAAKAIIIgIEQCAAKAIEQQRqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAELsjCyAAQQxqIQAgAkEBayICDQALCwtJAQF/AkAgAiAEayIGIAIgA2siA08EQCACIARJDQEgACAGIANrNgIEIAAgASADajYCAA8LIAMgBiAFELE7AAsgBiACIAUQsDsAC0sBAX8jAEEQayIDJAAgASACEMUCIgIEfyADIAI2AgwgA0EMahDRH0G78itrIQFBAQVBAAshAiAAIAE2AgQgACACNgIAIANBEGokAAtLAgJ/AX4jAEEQayIDJAAgACgCACIAKAIAIANBCGogACgCBCABKAIAIAJBAnRrQQRrKAIAEIMaIAMoAgggAygCDBDNAiADQRBqJAALSwICfwF+IwBBEGsiAyQAIAAoAgAiACgCACADQQhqIAAoAgQgASgCACACQQJ0a0EEaygCABCCGiADKAIIIAMoAgwQzQIgA0EQaiQAC0wBAn8gACgCCCICBEAgACgCBEEEaiEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABD7HgsgAEEcaiEAIAJBAWsiAg0ACwsLSwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACAAKAIUQQhqKAIQaiEBIAAoAiAiAAR/IAEgAEEIaigCEGoFIAELC0wBAn8jAEEQayIEJAAgBEEEaiIFIAEgAiADEOYVIAAgBRDjGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAALVgEBfyMAQRBrIgIkAAJ/IAAoAgAiACgCAEGAgICAeEcEQCACIAA2AgwgAUH8w4cBQQQgAkEMakGQxIcBENATDAELIAFB6MOHAUEEEPs1CyACQRBqJAALTAECfyAAKAIMIgIEQCAAKAIEQQRqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPIlCyAAQQhqIQAgAkEBayICDQALCwtQAQN/IAAtAABBA0YEQCAAKAIEIgAoAgAhAiAAKAIEIgMoAgAiAQRAIAIgAREDAAsgAygCBCIBBEAgAiABIAMoAggQ+DoLIABBDEEEEPg6CwtTAAJAAkAgASgCFARAIAAoAgANASAAEIQNCyAAKAIARQ0BCyAAIAEoAgwiACAAIAEoAhBqIAEoAgQgASgCCBC/GA8LIAAgACgCFCABKAIQajYCFAtVAQF/IwBBIGsiAiQAIAJBGGogASgCACUBEBkgAkEQaiACKAIYIAIoAhwQtTYgAkEIaiACKAIQIAIoAhQQ+iggACACKAIIIAIoAgwQjzUgAkEgaiQAC0wBAn8jAEEQayIBJAAgAUEAOgAPQQFBARCtNiICRQRAQQFBARCjPQALIAAgAUEPaq03AwAgACACrTcDCCACQQFBARD4OiABQRBqJAALUwECfyMAQcACayICJAAgAkEIaiIDIAAQlRogAyABNgIcIANBATYCGCACQagBaiADQZgB/AoAACACQQA2AqABIAJBoAFqENEpQQhqIAJBwAJqJAALmAEBA38jAEHAAmsiAyQAIANBCGoiBCAAEJUaIANBqAFqIQAjAEEgayICJAACQCABBEAgBCABNgKQASAAIARBmAH8CgAAIAJBIGokAAwBCyACQQA2AhggAkEBNgIMIAJBoLHOADYCCCACQgQ3AhAgAkEIakGosc4AEO8sAAsgA0EANgKgASADQaABahDRKUEIaiADQcACaiQAC04BAX8gACgCAEGAgICAeEcEQCAAEN47IABBDGoiARDRKyABEOg7IABBGGoiARDRKyABEOg7IABBJGoQhTAgAEEwahCFMCAAQTxqEIUwCwtRAQF/IAAoAgAiACgCDCIBIAEoAgBBAWsiATYCACABRQRAIABBDGoQ1CILAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQRBBBBD4OgsLiQIBBX8jAEHQAGsiASQAIAFBCGoiABD+LCABQQA2AkgjAEGQAWsiAyQAAkACQAJAIAAoAkAiAgRAIAAQyylBASEEDAELIANByABqIgIQ/iwgA0EANgKIASADIABByAD8CgAAIAAgAkHIAPwKAABB0ABBCBCtNiICRQ0BIAJCgYCAgBA3AwAgAkEIaiADQcgA/AoAACAAEMspIAAoAkAiAEUNACAAKAJMBEAgAEHMAGoQvCoLIAAQ+S4gAEHUAEEEEPg6CyABIAI2AgQgASAENgIAIANBkAFqJAAMAQtBCEHQABCjPQALIAEoAgBBAXEEQEGS58MAQTEQlz0ACyABKAIEIAFB0ABqJAALiAICAX4HfwJAIAAoAgQiBkUNACAAKAIMIgcEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHAAWshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBaGxqQRhrIgQoAhAhCCAEKAIUIgQoAgAiBQRAIAggBREDAAsgBCgCBCIFBEAgCCAFIAQoAggQ+DoLIAFCAX0gAYMhASAHQQFrIgcNAAsLIAYgBkEYbEEfakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwtRAQF/IwBBEGsiAiQAAn8gACgCAARAIAIgADYCDCABQaSdxABBCEGsncQAQQYgAkEMakGUncQAEPYYDAELIAFBg53EAEEQEPs1CyACQRBqJAALUQEBfyMAQRBrIgIkAAJ/IAAoAgAEQCACIAA2AgwgAUHMrswAQQhB1K7MAEEGIAJBDGpBvK7MABD2GAwBCyABQauuzABBEBD7NQsgAkEQaiQAC/cBAgF+Bn8CQCAAKAIEIgVFDQAgACgCDCIGBEAgACgCACICQQhqIQMgAikDAEJ/hUKAgYKEiJCgwIB/gyEBA0AgAVAEQANAIAJBgAFrIQIgAykDACADQQhqIQNCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAIgAXqnQQF0QfABcWtBCGsiBygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgBxC7IwsgAUIBfSABgyEBIAZBAWsiBg0ACwsgBSAFQQR0QRdqQXhxIgJqQQlqIgNFDQAgACgCACACayADQQgQ+DoLC60CAgJ+Bn8CQCAAKAIEIgdFDQAgACgCDCIIBEAgACgCACIEQQhqIQUgBCkDAEJ/hUKAgYKEiJCgwIB/gyEBA0AgAVAEQANAIARBgAVrIQQgBSkDACAFQQhqIQVCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAQgAXqnQQN2QbB/bGoiA0EwaxCRDCADQcgAayIGEMUnIAYQ6DsgA0E8ayIGEKQsIAYQ9TwgAUIBfSECAkAgA0EcayIGKAIAIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAYQ+x4LIAEgAoMhASAIQQFrIggNAAsLIAcgB0HQAGxB1wBqQXhxIgRqQQlqIgVFDQAgACgCACAEayAFQQgQ+DoLC1YBAX8gACgCACIAKAIMIgEQhzUgAUHAAEEIEPg6IAAoAhAiARCINSABQTBBCBD4OgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEUQQQQ+DoLC1ABAX8gAEEYahCVDCAAEMUnIAAQ6DsgAEEMaiIBEKQsIAEQ9TwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LC0kBA38gASEDIAIhBCABKAIAIgUEQCABLwEEIQQgAkEBaiEDCyABQcQAQRQgAhtBBBD4OiAAIAU2AgAgACADrSAErUIghoQ3AgQLUQEBfwJAIAAoAgBFDQAgACgCBCIBBEAgAEEQaiAAKAIIIAAoAgwgASgCEBEBAAsgACgCFCIBRQ0AIABBIGogACgCGCAAKAIcIAEoAhARAQALC0wBAX9BAiECAkAgACgCAEGAgICAeEcEQCABIAAoAggiAk8NASAAKAIEIAFqLQAAIQILIAJBAkYgAnJBAXEPCyABIAJBhKnOABDDIQALXgACQCABKAIUQYCAgIB4Rg0AIAAoAqQBQYCAgIB4Rg0AIABBpAFqIAFBFGoQ+xcLAkAgASgCCEGAgICAeEYNACAAKAKYAUGAgICAeEYNACAAQZgBaiABQQhqEPsXCwteAAJAIAEoAhRBgICAgHhGDQAgACgCjAFBgICAgHhGDQAgAEGMAWogAUEUahD7FwsCQCABKAIIQYCAgIB4Rg0AIAAoAoABQYCAgIB4Rg0AIABBgAFqIAFBCGoQ+xcLC14AAkAgASgCFEGAgICAeEYNACAAKAKcAUGAgICAeEYNACAAQZwBaiABQRRqEPsXCwJAIAEoAghBgICAgHhGDQAgACgCkAFBgICAgHhGDQAgAEGQAWogAUEIahD7FwsLiAICAX4HfwJAIAAoAgQiBkUNACAAKAIMIgcEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHgAGshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBdGxqQQxrIgQoAgQhCCAEKAIIIgQoAgAiBQRAIAggBREDAAsgBCgCBCIFBEAgCCAFIAQoAggQ+DoLIAFCAX0gAYMhASAHQQFrIgcNAAsLIAYgBkEMbEETakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwtQAQF/IABBGGoQnQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwvhAQIBfgV/AkAgACgCBCIERQ0AIAAoAgwiBQRAIAAoAgAiAkEIaiEDIAIpAwBCf4VCgIGChIiQoMCAf4MhAQNAIAFQBEADQCACQYAEayECIAMpAwAgA0EIaiEDQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgAUKAgYKEiJCgwIB/hSEBCyACIAF6p0EDdEHAB3FrQUBqIgYQ0SsgBhDoOyABQgF9IAGDIQEgBUEBayIFDQALCyAEIARBBnRBxwBqQXhxIgJqQQlqIgNFDQAgACgCACACayADQQgQ+DoLC7EEAhZ/AX4jAEEwayIGJAAgBkEAOgAcIAZCATcCICAGQRBqIQkgBkEcaiECIwBBIGsiAyQAIANBFGogAUEAQQRBFBCgGCADKAIYIQcgAygCFEEBRgRAIAcgAygCHEHEntAAEP0vAAsgA0EQaiIOQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIggoAgAgCCgCCCIFayABSQRAIAggBSABQQRBFBDQKCAIKAIIIQULIAgoAgQgBUEUbGohBAJAAkAgAUECTwRAIAFBAWsiDCAFaiEFIAIoAgwiD0EIdiEQIAIpAgQiGEIgiKchESACLQACIRIgAi0AASETIAIoAhAhFCACKAIIIRUgAigCBCEWIAItAAAhDSAYpyEXA0AgFyEBIBEhBwJAAkACQCANQQJrDgUBAAAAAQILIAshASAKIQcMAQsgFiEBIBUhBwsgBCANOgAAIARBEGogFDYCACAEQQJqIBI6AAAgBEEBaiATOgAAIARBDGogD0H/AXEgEEEIdHI2AgAgBEEEaiABrSAHrUIghoQ3AgAgBEEUaiEEIAchCiABIQsgDEEBayIMDQALDAELIAFFDQELIAQgAikCADcCACAEQRBqIAJBEGooAgA2AgAgBEEIaiACQQhqKQIANwIAIAVBAWohBQsgCCAFNgIIIAlBCGogDigCADYCACAJIAMpAgg3AgAgA0EgaiQAIAZBCGogCUHMgs4AEJkhIAAgBikDCDcDACAGQTBqJAALUAEBfyAAQRhqEJ8MIAAQxScgABDoOyAAQQxqIgEQpCwgARD1PAJAIAAoAiwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEsahD7HgsLjQUBC38gBEEMSwRAQVQPCyAEQQVJBEBBfw8LAn8gAiEPIAEgA0EBaiILIARsQQZqQQN2QQNqQYAEIAMbTyEMIARBAWohDiAEQQVrIQYgASAAIgNqQQJrIQ1BASAEdCIIQQFyIQlBBCEFQQAhACADIQRBASEKAkADQAJAAkACQCAJQQJJIAAgC09yDQAgCkEBcQRAIAUhByAAIQEMAgsgACALIAAgC0sbIQEgDyAAQQF0aiEHIAAhAgNAAkAgASACRwRAIAcvAQBFDQEgAiEBCyABIAtGDQJB//8DIAV0IQcDQCAAQRhqIgIgAU0EQCAMRSAEIA1LcQ0IIAQgBiAHaiIAOwAAIARBAmohBCAAQRB2IQYgAiEADAELCwNAIABBA2oiAiABTQRAQQMgBXQgBmohBiAFQQJqIQUgAiEADAELCyABIABrIAV0IAZqIQYgBUEPSARAIAVBAmohBwwECyAMRSAEIA1LcQ0GIAQgBjsAACAFQQ5rIQcgBkEQdiEGIARBAmohBAwDCyAHQQJqIQcgAkEBaiECDAALAAtBfyAJQQFHDQQaIAxFIAQgDUtxDQMgBCAGOwAAIAQgBUEHakEIbWogA2shCgwBC0F/IQogCSAPIAFBAXRqLgEAIgBBH3UiAiAAIAJza2oiAkEATA0AIAcgDmogCUF/cyAIQQF0aiIFQQAgAEEBaiIAIAhOGyAAaiIAIAVIayEFIABBAUchCiAAIAd0IAZqIQYgAUEBaiEAA0AgAiAISARAIAhBAXUhCCAOQQFrIQ4MAQsLIAIhCSAFQRFIDQEgDEUgBCANS3ENAiAEIAY7AAAgBUEQayEFIAZBEHYhBiAEQQJqIQQMAQsLIAoMAQtBun8LC0MBA38DQAJAIAIgBGoiBSADTQ0AIAAgBGoiBiABTQ0AIAZBAWstAAAgBUEBay0AAEcNACAEQQFrIQQMAQsLQQAgBGsLYQAgAQRAIAAgAUEFdGohAQNAIABChICggMCBgAg3AQAgAEEYakK0gOCBwIeAIDcBACAAQRBqQqSAoIHAhYAYNwEAIABBCGpClIDggMCDgBA3AQAgAEEgaiIAIAFHDQALCwtQAQF/IABBGGoQogwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQpgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQpwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQsgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQtAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQtgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQuAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQvQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQvwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQxQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQxwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQyAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtJAAJAAkAgAiADTQRAIAIgA0cNAQwCCyABIANqLAAAQb9/Sg0BCyABIAIgAyACIAQQozYACyAAIAIgA2s2AgQgACABIANqNgIAC0EBAX8gAUEMSyACQR9LcgR/IAMFIAAgAEGQA28iAEEfdUGQA3EgAGpB9MmGAWotAAAgAkEEdCABQQl0cnIQxiQLC1gBAX8CQAJAIAEoAiQiAkUEQCABKAIIRQ0CIAEoAgQoAghFDQELIAAgAUEAIAJBAWoQnxEPCyAAQQA2AgggAEKTgICAyAA3AgAPC0EAQQBBwOyGARDDIQALWAEBfwJAAkAgASgCJCICRQRAIAEoAghFDQIgASgCBCgCCEUNAQsgACABQQAgAkEBahCeEQ8LIABBADYCCCAAQpOAgICIATcCAA8LQQBBAEHA7IYBEMMhAAtPAQF/IwBBEGsiAiQAAn8gACgCACIAKAIABEAgAiAANgIMIAFB/MOHAUEEIAJBDGpBgMSHARDQEwwBCyABQejDhwFBBBD7NQsgAkEQaiQAC08BAX8jAEEQayICJAACfyAAKAIAIgAoAgAEQCACIAA2AgwgAUHs3YcBQQQgAkEMakHw3YcBENATDAELIAFB1t2HAUEEEPs1CyACQRBqJAAL6gECAX4FfwJAIAAoAgQiBEUNACAAKAIMIgUEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHAAWshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBaGxqIgZBGGtBAUEBEOAeIAZBDGtBAUEBEOAeIAFCAX0gAYMhASAFQQFrIgUNAAsLIAQgBEEYbEEfakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwuoAQEEfyMAQRBrIgQkACAEQQhqIQUjAEEQayIDJAAgAyACNgIIIAJBAEgEQEHY4IcBQSsgA0EPakHI4IcBQYThhwEQ1R4ACyADQQEgAiADQQhqEMAhIAMoAgQhBiAFIAMoAgA2AgAgBSAGNgIEIANBEGokACAEKAIIIQMgBCgCDCEFIAIEQCADQQhqIAEgAvwKAAALIAAgBTYCBCAAIAM2AgAgBEEQaiQACzcBAX8gAQRAIAFBAUcEQEEEIQIgAUECdCEBA0AgACAAIAJqEOcZIAEgAkEEaiICRw0ACwsPCwALRwECfyMAQRBrIgIkACACQQhqIABBDGogACgCFEEBaiIDIAAoAhAiACAAIANLGxDqDCABIAIoAgggAigCDBD7KCACQRBqJAALSAEBfyAAKAIAIAAoAggiA2sgAkkEQCAAIAMgAhCFEyAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC04BAX8jAEEwayIBJAAgAUEBNgIMIAFB3KqJATYCCCABQgE3AhQgASABQS9qrUKAgICAgN4DhDcDICABIAFBIGo2AhAgAUEIaiAAEO8sAAtDAQN/AkAgAkUNAANAIAAtAAAiBCABLQAAIgVGBEAgAEEBaiEAIAFBAWohASACQQFrIgINAQwCCwsgBCAFayEDCyADC00BAX8CQAJAAkAgAC0ARA4EAAICAQILIABBOGoQ3jsgACgCNCIBIAEoAgAiAUEBazYCACABQQFHDQEgAEE0ahCdJw8LIABBEGoQoCULC1YBAX8gABDUJSAAQdAAaiIBENwYIAEQ7DsgACgCOEGAgICAeEcEQCAAQThqIgEQxiogARDoOwsgACgCREGAgICAeEcEQCAAQcQAaiIAEMcqIAAQ6DsLC1IBAX8CQAJAAkACQCAALQAYQQNrDgIAAQMLIABBIGoQqh4MAQsgAEEgahDSLQsgACgCFCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahCdJwsLTAEBfyAAKAIAIgBBCGoQyykgACgCSARAIABByABqEI0jCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEHQAEEIEPg6CwtQAQF/QRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASAAKQIANwIIIAFBEGogAEEIaikCADcCACABQRhqIABBEGooAgA2AgAgAQtQAQF/QSBBBBCtNiIBRQRAQQRBIBCjPQALIAFCgYCAgBA3AgAgASAAKQIANwIIIAFBEGogAEEIaikCADcCACABQRhqIABBEGopAgA3AgAgAQtNAQF/IwBBEGsiAiQAAn8gAC0AAEERRwRAIAIgADYCDCABQYC5zQBBBCACQQxqQfC4zQAQ0BMMAQsgAUHsuM0AQQQQ+zULIAJBEGokAAtWAQF/IwBB8ABrIgEkACAAEJkoIAEQmSggAUIANwNoIAFCgICAgMAANwNgIABB4ABqIAFB8AD8CgAAIABBADYC2AEgAEKAgICAEDcD0AEgAUHwAGokAAtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQgyALIABBBGohACACQQFrIgINAAsLC0kBAn8gACgCCCICBEAgACgCBCEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDZIQsgAEEEaiEAIAJBAWsiAg0ACwsLTgECfyAAKAIAIgMoAgQiBCgCCCIAIAEoAgAgAkEDdGtBCGsoAgAiAU0EQCABIABBlJDOABDDIQALIAMoAgAgBCgCBCABQQN0akEIEM0CC04BAn8gACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFNBEAgASAAQZSQzgAQwyEACyADKAIAIAQoAgQgAUECdGpBBBDNAgtRAgF/AX4gACkDACEDIAAoAigiAiAAKAIgRgRAIABBIGpBuPvPABCzKAsgACgCJCACQQN0aiADNwMAIAAgAkEBajYCKCAAIAApAwAgAXw3AwALTQEBfyMAQRBrIgIkAAJ/IAAtAABBEUcEQCACIAA2AgwgAUG44dAAQQQgAkEMakGo4dAAENATDAELIAFBpOHQAEEEEPs1CyACQRBqJAALTQEBfyMAQRBrIgIkAAJ/IAAtAABBA0cEQCACIAA2AgwgAUG44dAAQQQgAkEMakG84dAAENATDAELIAFBpOHQAEEEEPs1CyACQRBqJAALTQEBfyABQYACTwRAIAAQrREPCyAAKAIMIgIgACgCCCIARwRAIAAgAjYCDCACIAA2AggPC0HA84oBQcDzigEoAgBBfiABQQN2d3E2AgALUQEBfyMAQRBrIgIkAAJ/IAAoAgBBgICAgHhHBEAgAiAANgIMIAFBsKX+AEEEIAJBDGpBoKX+ABDQEwwBCyABQZyl/gBBBBD7NQsgAkEQaiQAC0ICAn8BfkEBIQEgAEIBhiIDIABCP4ciAFIEQCAAIAOFIQBBACEBA0AgAUEBaiEBIABC/wBWIABCB4ghAA0ACwsgAQtFAQJ/IwBBEGsiASQAIAAoAgAiAC0AMEEgRgRAIAFBCGogAEE0ahDDNCABKAIIQQAgASgCDBsQkSwhAgsgAUEQaiQAIAILjy8CBn8EfiABKAIAIAIQhyVFBEAgACMAQUBqIgUkACABIAIQ0BohCyAFQThqQQA2AgAgBUEwaiIAQgA3AwAgBUIANwMoIAVBKGoiBkEBciECAkACQAJAAkACQAJAAkACQAJAAkACQCALQgBZBEAgC0KQzgBaBEAgBkECciEBIAtCgMivoCVaBEAgCyALQoDIr6AlgCIMQoDIr6Alfn0hDQJ/AkAgC0KAgOmDsd4WWgRAIAtCgICQu7rWrfANWg0BIAtC//+D/qbe4RFYBEAgDEK5mxp+IgxCIIghDiALQoCAmqbqr+MBWgRAIAZBBnIhACAFIA6nQQF0IgFBuYz/AGotAAA6ACkgBSABQbiM/wBqLQAAOgAoIAZBA3IhAUEBIQIDQCABIAxC/////w+DQuQAfiIMQh+IpyIGQQFyQbiM/wBqLQAAOgAAIAFBAWsgBkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIAJBAXFBACECDQALQRAMBAsgBUEoakEFciEAIAUgDqdBMHI6AChBASECA0AgASAMQv////8Pg0LkAH4iDEIfiKciBkEBckG4jP8Aai0AADoAACABQQFrIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmohASACQQFxQQAhAg0AC0EPDAMLIAxCou+bhgF+IgxCMIghDiAMQhCIIQwgC0KAgKjsha/RsQFaBEAgBSAOp0EBdCIBQbmM/wBqLQAAOgApIAUgAUG4jP8Aai0AADoAKEEAIQEDQCAFQShqIAFqIgJBA2ogDEL/////D4NC5AB+IgxCH4inIgZBAXJBuIz/AGotAAA6AAAgAkECaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBEgwDCyAFQShqQQdyIQAgBSAOp0EwcjoAKEEAIQEDQCAFQShqIAFqIgJBAmogDEL/////D4NC5AB+IgxCH4inIgZBAXJBuIz/AGotAAA6AAAgAkEBaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBEQwCCyALQv+flKWNHVgEQCAMpyEAIAtC/8/bw/QCWARAIAUgAEEwcjoAKCACIQBBCwwDCyAFIABBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggASEAQQwMAgsgDEKpuL0UfiIMQiCIIQ4gC0KAwMrzhKMCWgRAIAVBKGpBBHIhACAFIA6nQQF0IgFBuYz/AGotAAA6ACkgBSABQbiM/wBqLQAAOgAoIAUgDEL/////D4NC5AB+Qh+IpyIBQQFyQbiM/wBqLQAAOgArIAUgAUH+AXFBuIz/AGotAAA6ACpBDgwCCyAFQShqQQNyIQAgBSAOp0EwcjoAKCAFIAxC/////w+DQuQAfkIfiKciAUEBckG4jP8Aai0AADoAKiAFIAFB/gFxQbiM/wBqLQAAOgApQQ0MAQsgBUExaiEAIAUgDEKK95ivBX4iC0I5iKdBMHI6ACggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAUEBckG4jP8Aai0AADoAKiAFIAFB/gFxQbiM/wBqLQAAOgApIAUgC0L8////D4NC5AB+IgtCH4inIgFBAXJBuIz/AGotAAA6ACwgBSABQf4BcUG4jP8Aai0AADoAKyAFIAtC8P///w+DQuQAfiILQh+IpyIBQQFyQbiM/wBqLQAAOgAuIAUgAUH+AXFBuIz/AGotAAA6AC0gBSALQsD///8Pg0LkAH5CH4inIgFBAXJBuIz/AGotAAA6ADAgBSABQf4BcUG4jP8Aai0AADoAL0ETCyECIAAgDUKAwtcvgKdBAXQiAUG5jP8Aai0AADoAASAAIAFBuIz/AGotAAA6AAAgACANIA1CkM4AgCILQpDOAH59pyIBQf//A3FB5ABuIgZBAXQiB0G5jP8Aai0AADoAByAAIAdBuIz/AGotAAA6AAYgACALQpDOAIKnIgdB5ABuIghBAXQiCUG5jP8Aai0AADoAAyAAIAlBuIz/AGotAAA6AAIgACABIAZB5ABsa0H//wNxQQF0IgFBuYz/AGotAAA6AAkgACABQbiM/wBqLQAAOgAIIAAgByAIQeQAbGtB//8DcUEBdCIBQbmM/wBqLQAAOgAFIAAgAUG4jP8Aai0AADoABAwNCyALQv+T69wDWARAIAtC/8HXL1gEQCALQr+EPVgEQCALQrmbGn4iDEIgiCENIAtCoI0GWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggBUEoakEDciEBQQEhAANAIAEgDEL/////D4NC5AB+IgxCH4inIgJBAXJBuIz/AGotAAA6AAAgAUEBayACQf4BcUG4jP8Aai0AADoAACABQQJqIQEgAEEBcUEAIQANAAsMDwsgBSANp0EwcjoAKEEBIQADQCABIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIAFBAWsgAkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALDA0LIAtCou+bhgF+IgxCMIghDSAMQhCIIQwgC0KAreIEWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6AChBACEBA0AgBUEoaiABaiIAQQNqIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBAmogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALDAwLIAUgDadBMHI6AChBACEBA0AgBUEoaiABaiIAQQJqIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBAWogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALDAoLIAUgC0KK95ivBX4iC0I5iKdBMHI6ACggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKiAFIABB/gFxQbiM/wBqLQAAOgApIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6ACwgBSAAQf4BcUG4jP8Aai0AADoAKyAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAuIAUgAEH+AXFBuIz/AGotAAA6AC0gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADAgBSAAQf4BcUG4jP8Aai0AADoALwwDCyAFQRBqIAtCAELHuMf5KkIAEKgeIAUgBSkDGEIFhiAFKQMQIgtCO4iEp0H+A3EiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggBSALQhyIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKyAFIABB/gFxQbiM/wBqLQAAOgAqIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC0gBSAAQf4BcUG4jP8Aai0AADoALCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAvIAUgAEH+AXFBuIz/AGotAAA6AC4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADEgBSAAQf4BcUG4jP8Aai0AADoAMEEKIQIMDAsgC0LjAFgEQCALQglYBEAgBSALp0EwcjoAKEEBIQIMDQsgBSALp0EBdCIAQbmM/wBqLQAAOgApIAUgAEG4jP8Aai0AADoAKEECIQIMDAsgC0KpuL0UfiIMQiCIIQ0gC0LoB1oEQCAFIA2nQQF0IgBBuYz/AGotAAA6ACkgBSAAQbiM/wBqLQAAOgAoIAUgDEL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgArDAcLIAUgDadBMHI6ACggBSAMQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACogBSAAQf4BcUG4jP8Aai0AADoAKUEDIQIMCwsgBUEtOgAoQgAgC30iDEKQzgBUDQQgDEKAyK+gJVoEQCAMIAxCgMivoCWAIgtCgMivoCV+fSENIAICfwJAIAxCgIDpg7HeFloEQCAMQoCAkLu61q3wDVoNASAMQv//g/6m3uERWARAIAtCuZsafiILQiCIIQ4gDEKAgJqm6q/jAVoEQCAFIA6nQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApIAVBKGpBBHIhAUEBIQADQCABIAtC/////w+DQuQAfiILQh+IpyIGQQFyQbiM/wBqLQAAOgAAIAFBAWsgBkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALQQYMBAsgBSAOp0EwcjoAKSAFQShqQQNyIQFBASEAA0AgASALQv////8Pg0LkAH4iC0IfiKciBkEBckG4jP8Aai0AADoAACABQQFrIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmohASAAQQFxQQAhAA0AC0EFDAMLIAtCou+bhgF+IgtCMIghDiALQhCIIQsgDEKAgKjsha/RsQFaBEAgBSAOp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKUEAIQEDQCAFQShqIAFqIgBBBGogC0L/////D4NC5AB+IgtCH4inIgZBAXJBuIz/AGotAAA6AAAgAEEDaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBCAwDCyAFIA6nQTByOgApQQAhAQNAIAVBKGogAWoiAEEDaiALQv////8Pg0LkAH4iC0IfiKciBkEBckG4jP8Aai0AADoAACAAQQJqIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmoiAUEGRw0AC0EHDAILIAxC/5+UpY0dWARAIAunIQAgDEL/z9vD9AJYBEAgBSAAQTByOgApQQEMAwsgBSAAQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApQQIMAgsgC0KpuL0UfiILQiCIIQ4gDEKAwMrzhKMCWgRAIAUgDqdBAXQiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6ACkgBSALQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACwgBSAAQf4BcUG4jP8Aai0AADoAK0EEDAILIAUgDqdBMHI6ACkgBSALQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACsgBSAAQf4BcUG4jP8Aai0AADoAKkEDDAELIAUgC0KK95ivBX4iC0I5iKdBMHI6ACkgBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKyAFIABB/gFxQbiM/wBqLQAAOgAqIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC0gBSAAQf4BcUG4jP8Aai0AADoALCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAvIAUgAEH+AXFBuIz/AGotAAA6AC4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADEgBSAAQf4BcUG4jP8Aai0AADoAMEEJCyIBaiIAIA1CgMLXL4CnQQF0IgJBuYz/AGotAAA6AAEgACACQbiM/wBqLQAAOgAAIAAgDSANQpDOAIAiC0KQzgB+faciAkH//wNxQeQAbiIGQQF0IgdBuYz/AGotAAA6AAcgACAHQbiM/wBqLQAAOgAGIAAgC0KQzgCCpyIHQeQAbiIIQQF0IglBuYz/AGotAAA6AAMgACAJQbiM/wBqLQAAOgACIAAgAiAGQeQAbGtB//8DcUEBdCICQbmM/wBqLQAAOgAJIAAgAkG4jP8Aai0AADoACCAAIAcgCEHkAGxrQf//A3FBAXQiAkG5jP8Aai0AADoABSAAIAJBuIz/AGotAAA6AAQgAUELaiECDAsLIAxC/5Pr3ANWDQMgDEL/wdcvVg0CIAxCv4Q9WARAIAtCx+RlfiILQiCIIQ0gDEKgjQZaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKSAFQShqQQRyIQFBASEAA0AgASALQv////8Pg0LkAH4iC0IfiKciAkEBckG4jP8Aai0AADoAACABQQFrIAJB/gFxQbiM/wBqLQAAOgAAIAFBAmohASAAQQFxQQAhAA0ACwwICyAFIA2nQTByOgApIAVBKGpBA3IhAUEBIQADQCABIAtC/////w+DQuQAfiILQh+IpyICQQFyQbiM/wBqLQAAOgAAIAFBAWsgAkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALDAoLIAtC3pDk+X5+IgtCMIghDSALQhCIIQsgDEKAreIEVA0BIAUgDadBAXQiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6AClBACEBA0AgBUEoaiABaiIAQQRqIAtC/////w+DQuQAfiILQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBA2ogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALC0EJIQIMCQsgBSANp0EwcjoAKUEAIQEDQCAFQShqIAFqIgBBA2ogC0L/////D4NC5AB+IgtCH4inIgJBAXJBuIz/AGotAAA6AAAgAEECaiACQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAsMBQsgBSALQvaI59B6fiILQjmIp0EwcjoAKSAFIAtCGYhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgArIAUgAEH+AXFBuIz/AGotAAA6ACogBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoALSAFIABB/gFxQbiM/wBqLQAAOgAsIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC8gBSAAQf4BcUG4jP8Aai0AADoALiAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAMSAFIABB/gFxQbiM/wBqLQAAOgAwQQohAgwHCyAFIAxCAELHuMf5KkIAEKgeIAUgBSkDCEIFhiAFKQMAIgtCO4iEp0H+A3EiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6ACkgBSALQhyIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoALCAFIABB/gFxQbiM/wBqLQAAOgArIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC4gBSAAQf4BcUG4jP8Aai0AADoALSAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAwIAUgAEH+AXFBuIz/AGotAAA6AC8gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADIgBSAAQf4BcUG4jP8Aai0AADoAMUELIQIMBgsgDELjAFgEQCAMQglYBEAgBSAMp0EwcjoAKUECIQIMBwsgBSAMp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKUEDIQIMBgsgC0LXx8JrfiILQiCIIQ0gDELoB1oEQCAFIA2nQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApIAUgC0L/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAsIAUgAEH+AXFBuIz/AGotAAA6ACsMBAsgBSANp0EwcjoAKSAFIAtC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAKwsgBSAAQf4BcUG4jP8Aai0AADoAKkEEIQIMBAtBByECDAMLQQghAgwCC0EFIQIMAQtBBiECC0GTgICAeEGUgICAeCADIAVBKGogAiAEKAIMEQYAGzYCACAFQUBrJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALhwIBAX8gASgCACACEJYlRQRAIwBBMGsiBSQAIAUgASgCACACEIAXAkAgBSgCBCICBEAgBSgCACEBIAQoAhQhBANAIAUgATYCDCAFQQE2AiQgBUHwlYEBNgIgIAVBATYCFCAFQaz3gAE2AhAgBUEBNgIcIAVBghE2AiwgBSAFQShqNgIYIAUgBUEMajYCKCADIAVBEGogBBECAARAIABBk4CAgHg2AgAMAwsgAUEBaiEBIAJBAWsiAg0ACwsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC68VAgF/An4gASgCACACEIclRQRAIwBBEGsiBSQAIAEgAhDPGiEBIAVCADcDACAFQQA2AAcgAEGTgICAeEGUgICAeCADIAUCfwJAAkACQAJAAkACQAJAAkAgAUEATgRAIAFBkM4ATwRAIAGtIQYgAUGAwtcvTwRAIAFB/5Pr3ANNBEAgBSAGQor3mK8FfiIGQjmIp0EwcjoAACAFIAZCGYhC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgACIAUgAEH+AXFBuIz/AGotAAA6AAEgBSAGQvz///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoABCAFIABB/gFxQbiM/wBqLQAAOgADIAUgBkLw////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAYgBSAAQf4BcUG4jP8Aai0AADoABSAFIAZCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACCAFIABB/gFxQbiM/wBqLQAAOgAHDAQLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAASAFIABBPnFBuIz/AGotAAA6AAAgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAUgBSAAQf4BcUG4jP8Aai0AADoABCAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAHIAUgAEH+AXFBuIz/AGotAAA6AAYgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAkgBSAAQf4BcUG4jP8Aai0AADoACEEKDAsLIAFBv4Q9TQRAIAZCuZsafiIGQiCIIQcgAUGgjQZPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAAwLCyAFIAenQTByOgAAIAVBAnIhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALDAkLIAZCou+bhgF+IgZCMIghByAGQhCIIQYgAUGAreIETwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAMCAsgBSAHp0EwcjoAAEEAIQIDQCACIAVqIgBBAmogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEEBaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAsMBgsgAUHjAE0EQCABQQlNBEAgBSABQTByOgAAQQEMCwsgBSABQQF0IgBBuYz/AGotAAA6AAEgBSAAQbiM/wBqLQAAOgAAQQIMCgsgAa1Cqbi9FH4iBkIgiCEHIAFB6AdPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAAwFCyAFIAenQTByOgAAIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgACIAUgAEH+AXFBuIz/AGotAAA6AAFBAwwJCyAFQS06AABBACABayIAQZDOAEkNAiAArSEGIABBgMLXL08EQCAAQf+T69wDTQRAIAUgBkKK95ivBX4iBkI5iKdBMHI6AAEgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAUgBSAAQf4BcUG4jP8Aai0AADoABCAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAHIAUgAEH+AXFBuIz/AGotAAA6AAYgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAkgBSAAQf4BcUG4jP8Aai0AADoACEEKDAoLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAAiAFIABB/gBxQbiM/wBqLQAAOgABIAUgBkIZiEL/////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAyAFIAZC/P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAGIAUgAEH+AXFBuIz/AGotAAA6AAUgBSAGQvD///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoACCAFIABB/gFxQbiM/wBqLQAAOgAHIAUgBkLA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAlBCwwJCyAAQb+EPU0EQCAGQrmbGn4iBkIgiCEHIABBoI0GTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAAiAFIABBuIz/AGotAAA6AAEgBUEEciECQQEhAANAIAIgBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAkEBayABQf4BcUG4jP8Aai0AADoAACACQQJqIQIgAEEAIQANAAsMBgsgBSAHp0EwcjoAAQwICyAGQqLvm4YBfiIGQjCIIQcgBkIQiCEGIABBgK3iBEkNASAFIAenQQF0IgBBuYz/AGotAAA6AAIgBSAAQbiM/wBqLQAAOgABQQAhAgNAIAIgBWoiAEEEaiAGQv////8Pg0LkAH4iBkIfiKciAUEBckG4jP8Aai0AADoAACAAQQNqIAFB/gFxQbiM/wBqLQAAOgAAIAJBAmoiAkEGRw0ACwtBCQwHCyAFIAenQTByOgABDAMLIABB4wBNBEAgAEEJTQRAIAUgAEEwcjoAAUECDAcLIAUgAEEBdCIAQbmM/wBqLQAAOgACIAUgAEG4jP8Aai0AADoAAUEDDAYLIACtQqm4vRR+IgZCIIghByAAQegHTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAAiAFIABBuIz/AGotAAA6AAEgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAwwECyAFIAenQTByOgABCyAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACQQQMBAtBBwwDC0EAIQIDQCACIAVqIgBBA2ogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCAwCC0EFDAELIAVBA3IhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALQQYLIAQoAgwRBgAbNgIAIAVBEGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuHAgEBfyABKAIAIAIQliVFBEAjAEEwayIFJAAgBSABKAIAIAIQ8hYCQCAFKAIEIgIEQCAFKAIAIQEgBCgCFCEEA0AgBSABNgIMIAVBATYCJCAFQfCVgQE2AiAgBUEBNgIUIAVBrPeAATYCECAFQQE2AhwgBUGCETYCLCAFIAVBKGo2AhggBSAFQQxqNgIoIAMgBUEQaiAEEQIABEAgAEGTgICAeDYCAAwDCyABQQFqIQEgAkEBayICDQALCyAAQZSAgIB4NgIACyAFQTBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALwgEBAX8gASgCACACEJUlRQRAIwBBMGsiBSQAIAEoAgAgAhCEGiEBIAVByAs2AiggBSABOgAvIAVBATYCECAFQbC1gAE2AgwgBUIBNwIYIAUgBUEvajYCJCAFIAVBJGo2AhQgAEGTgICAeEGUgICAeCADIAVBDGogBCgCFBECABs2AgAgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC4YMAgF/An4gASgCACACEIclRQRAIwBBEGsiBSQAIAEgAhDPGiEBIAVBCGpBADsBACAFQgA3AwAgAEGTgICAeEGUgICAeCADIAUCfyABQZDOAE8EQCABrSEGIAFBgMLXL08EQCABQf+T69wDTQRAIAUgBkKK95ivBX4iBkI5iKdBMHI6AAAgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAiAFIABB/gFxQbiM/wBqLQAAOgABIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAyAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAGIAUgAEH+AXFBuIz/AGotAAA6AAUgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAggBSAAQf4BcUG4jP8Aai0AADoAB0EJDAMLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAASAFIABB/gBxQbiM/wBqLQAAOgAAIAUgBkIZiEL/////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAMgBSAAQf4BcUG4jP8Aai0AADoAAiAFIAZC/P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAFIAUgAEH+AXFBuIz/AGotAAA6AAQgBSAGQvD///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAByAFIABB/gFxQbiM/wBqLQAAOgAGIAUgBkLA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAJIAUgAEH+AXFBuIz/AGotAAA6AAhBCgwCCyABQb+EPU0EQCAGQrmbGn4iBkIgiCEHIAFBoI0GTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAgBUEDciECQQEhAANAIAIgBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAkEBayABQf4BcUG4jP8Aai0AADoAACACQQJqIQIgAEEAIQANAAtBBgwDCyAFIAenQTByOgAAIAVBAnIhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALQQUMAgsgBkKi75uGAX4iBkIwiCEHIAZCEIghBiABQYCt4gRPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAEEAIQIDQCACIAVqIgBBA2ogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCAwCCyAFIAenQTByOgAAQQAhAgNAIAIgBWoiAEECaiAGQv////8Pg0LkAH4iBkIfiKciAUEBckG4jP8Aai0AADoAACAAQQFqIAFB/gFxQbiM/wBqLQAAOgAAIAJBAmoiAkEGRw0AC0EHDAELIAFB4wBNBEAgAUEJTQRAIAUgAUEwcjoAAEEBDAILIAUgAUEBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAEECDAELIAGtQqm4vRR+IgZCIIghByABQegHTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAMgBSAAQf4BcUG4jP8Aai0AADoAAkEEDAELIAUgB6dBMHI6AAAgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAIgBSAAQf4BcUG4jP8Aai0AADoAAUEDCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALrwQBA38gASgCACACEIclRQRAIwBB0ABrIgUkACMAQTBrIgYkACABKAIAIQEgBiACNgIAIAFBDGoQ2DwgAk0EQCAGIAEQ/Ts2AhwgBkECNgIIIAZB8Ij/ADYCBCAGQgI3AhAgBkE7NgIsIAZBOzYCJCAGIAZBIGo2AgwgBiAGQRxqNgIoIAYgBjYCICAGQQRqQYCJ/wAQ7ywACyAFQQhqIAEoAhAgAkEDdGopAgA3AwAgBkEwaiQAIAUgBSgCDCIBNgIUIAUgBSgCCCICNgIQIAVCATcCGAJAAkAgAkUEQEEBIQIMAQsgBUEDNgI0IAVB6JP/ADYCMCAFQgI3AjwgBUGcAzYCLCAFQcwBNgIkIAUgBUEgajYCOCAFIAVBEGo2AiggBSAFQRhqNgIgIAMgBUEwaiAEKAIUEQIARQRAQQEhByAFQQE2AhxBt5L/ACECIAVBt5L/ADYCGCAFKAIUIQEMAQsgAEGTgICAeDYCAAwBCwJAIAFFDQAgBSAHNgIkIAUgAjYCICAFIAE2AiggBUEBNgI0IAVBtJP/ADYCMCAFQgE3AjwgBUGODDYCTCAFIAVByABqNgI4IAUgBUEgajYCSCADIAVBMGogBCgCFBECAEUNACAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVB0ABqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL0wQCAX8CfiABKAIAIAIQhyVFBEAjAEEQayIFJAAgASACEM4aIQEgBUEMakEAOgAAIAVBADYCCCAAQZOAgIB4QZSAgIB4IAMgBUEIagJ/IAFB//8DcSIAQY/OAE0EQCAAQeMATQRAIABBCU0EQCAFIAFBMHI6AAhBAQwDCyAFIAFBAXRB/v8HcSIAQbmM/wBqLQAAOgAJIAUgAEG4jP8Aai0AADoACEECDAILIAGtQv//A4NCqbi9FH4iBkIgiCEHIAFB//8DcUHoB08EQCAFIAenQQF0IgBBuYz/AGotAAA6AAkgBSAAQbiM/wBqLQAAOgAIIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AApBBAwCCyAFIAenQTByOgAIIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAlBAwwBCyAFIAGtQv//A4NCuZsafiIGQiCIp0EwcjoACCAFIAZC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAkgBSAGQvz///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAwgBSAAQf4BcUG4jP8Aai0AADoAC0EFCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALvgUCA38BfiABKAIAIAIQhyVFBEAjAEHQAGsiBSQAIwBBMGsiBiQAIAEoAgAhASAGIAI2AgAgAUEMahDaPCACTQRAIAYgARD/OzYCHCAGQQI2AgggBkHwiP8ANgIEIAZCAjcCECAGQTs2AiwgBkE7NgIkIAYgBkEgajYCDCAGIAZBHGo2AiggBiAGNgIgIAZBBGpBgIn/ABDvLAALIAVBCGoiByABKAIQIAJBBHRqIgEpAwA3AwAgB0EIaiABQQhqKQMANwMAIAZBMGokACAFQgE3AhgCQAJAIAUoAghFBEBBASEBQQAhAgwBCyAFQQM2AjQgBUGAlP8ANgIwIAVCAjcCPCAFQZwDNgIsIAVBzAE2AiQgBSAFQSBqNgI4IAUgBUEIajYCKCAFIAVBGGo2AiAgAyAFQTBqIAQoAhQRAgBFBEBBASECIAVBATYCHEG3kv8AIQEgBUG3kv8ANgIYDAELIABBk4CAgHg2AgAMAQsgBSgCDARAIAVBAzYCNCAFQeiT/wA2AjAgBUICNwI8IAVBnAM2AiwgBSAFQQhqQQRyNgIoIAVBzAE2AiQgBSAFQSBqNgI4IAUgBUEYajYCICADIAVBMGogBCgCFBECAARAIABBk4CAgHg2AgAMAgsgBUEBNgIcIAVBt5L/ADYCGEEBIQJBt5L/ACEBCwJAIAUpAxAiCFANACAFIAI2AiQgBSABNgIgIAUgCDcDKCAFQQE2AjQgBUG0k/8ANgIwIAVCATcCPCAFQY8MNgJMIAUgBUHIAGo2AjggBSAFQSBqNgJIIAMgBUEwaiAEKAIUEQIARQ0AIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUHQAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuyAgECfyABKAIAIAIQmyVFBEAjAEEwayIFJAAjAEEQayIGJAAgBkEIaiABKAIAIAIQoBsgBigCDCEBIAUgBigCCDYCACAFIAE2AgQgBkEQaiQAAkAgBSgCBCICBEAgBSgCACEBIAQoAhQhBANAIAUgATYCDCAFQQE2AiQgBUH484ABNgIgIAVBATYCFCAFQfDzgAE2AhAgBUEBNgIcIAVBghE2AiwgBSAFQShqNgIYIAUgBUEMajYCKCADIAVBEGogBBECAARAIABBk4CAgHg2AgAMAwsgAUEBaiEBIAJBAWsiAg0ACwsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCRJUUEQCMAQTBrIgUkACAFIAEoAgAgAhCmGSAFQcwBNgIkIAVBATYCDCAFQfDzgAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvBAgIBfwF+IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQtxshASAFQQ5qQQA6AAAgBUEAOwEMIABBk4CAgHhBlICAgHggAyAFQQxqAn8gAUH/AXEiAEHjAE0EQCAAQQlNBEAgBSABQTByOgAMQQEMAgsgBSABQQF0Qf4DcSIAQbmM/wBqLQAAOgANIAUgAEG4jP8Aai0AADoADEECDAELIAUgAa1C/wGDQqm4vRR+IgZCIIinQTByOgAMIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAOIAUgAEH+AXFBuIz/AGotAAA6AA1BAwsgBCgCDBEGABs2AgAgBUEQaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+EDAQF/IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQtxshASAFQQA2AgwgAEGTgICAeEGUgICAeCADIAVBDGoCfyABwEEATgRAIAFB/wFxIgBB4wBNBEAgAEEJTQRAIAUgAUEwcjoADEEBDAMLIAUgAUEBdEH+A3EiAEG5jP8Aai0AADoADSAFIABBuIz/AGotAAA6AAxBAgwCCyAFQTE6AAwgBSABrUL/AYNCqbi9FH5C/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoADiAFIABB/gFxQbiM/wBqLQAAOgANQQMMAQsgBUEtOgAMQQAgAWsiAEH/AXEiAUHjAE0EQCABQQlNBEAgBSAAQTByOgANQQIMAgsgBSAAQQF0Qf4DcSIAQbmM/wBqLQAAOgAOIAUgAEG4jP8Aai0AADoADUEDDAELIAVBMToADSAFIACtQv8Bg0KpuL0UfkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAPIAUgAEH+AXFBuIz/AGotAAA6AA5BBAsgBCgCDBEGABs2AgAgBUEQaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCWJUUEQCMAQTBrIgUkACAFIAEoAgAgAhDxFiAFQcwBNgIkIAVBATYCDCAFQaz3gAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuoCAIBfwJ+IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQzhohASAFQQxqQQA7AQAgBUEANgIIIABBk4CAgHhBlICAgHggAyAFQQhqAn8gAcFBAE4EQCABQf//A3EiAEGPzgBNBEAgAEHjAE0EQCAAQQlNBEAgBSABQTByOgAIQQEMBAsgBSABQQF0Qf7/B3EiAEG5jP8Aai0AADoACSAFIABBuIz/AGotAAA6AAhBAgwDCyABrUL//wODQqm4vRR+IgZCIIghByABQf//A3FB6AdPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgAJIAUgAEG4jP8Aai0AADoACCAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACyAFIABB/gFxQbiM/wBqLQAAOgAKQQQMAwsgBSAHp0EwcjoACCAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACiAFIABB/gFxQbiM/wBqLQAAOgAJQQMMAgsgBSABrUL//wODQrmbGn4iBkIgiKdBMHI6AAggBSAGQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoACiAFIABB/gFxQbiM/wBqLQAAOgAJIAUgBkL8////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAMIAUgAEH+AXFBuIz/AGotAAA6AAtBBQwBCyAFQS06AAhBACABayIAQf//A3EiAUGPzgBNBEAgAUHjAE0EQCAAQf//A3FBCU0EQCAFIABBMHI6AAlBAgwDCyAFIABBAXRB/v8HcSIAQbmM/wBqLQAAOgAKIAUgAEG4jP8Aai0AADoACUEDDAILIACtQv//A4NCqbi9FH4iBkIgiCEHIABB//8DcUHoB08EQCAFIAenQQF0IgBBuYz/AGotAAA6AAogBSAAQbiM/wBqLQAAOgAJIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAMIAUgAEH+AXFBuIz/AGotAAA6AAtBBQwCCyAFIAenQTByOgAJIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AApBBAwBCyAFIACtQv//A4NCuZsafiIGQiCIp0EwcjoACSAFIAZC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AAogBSAGQvz///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AA0gBSAAQf4BcUG4jP8Aai0AADoADEEGCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL5xoCBn8EfiABKAIAIAIQhyVFBEAgACMAQTBrIgUkACABIAIQ0BohCyAFQShqQQA2AgAgBUEgaiICQgA3AwAgBUIANwMYAkAgC0KQzgBaBEAgC0KAyK+gJVoEQCALIAtCgMivoCWAIgxCgMivoCV+fSENAn8gC0KAgOmDsd4WWgRAIAtCgICQu7rWrfANWgRAIAtC//+fz8jgyOOKf1gEQCAFQSFqIQIgBSAMQor3mK8FfiILQjmIp0EwcjoAGCAFIAtCGYhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAaIAUgAEH+AXFBuIz/AGotAAA6ABkgBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHCAFIABB/gFxQbiM/wBqLQAAOgAbIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB4gBSAAQf4BcUG4jP8Aai0AADoAHSAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAICAFIABB/gFxQbiM/wBqLQAAOgAfQRMMAwsgBUEiaiECIAUgDEKJ95ivBX4iC0I4iKciAEEBckG4jP8Aai0AADoAGSAFIABBPnFBuIz/AGotAAA6ABggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAGyAFIABB/gFxQbiM/wBqLQAAOgAaIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB0gBSAAQf4BcUG4jP8Aai0AADoAHCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAfIAUgAEH+AXFBuIz/AGotAAA6AB4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACEgBSAAQf4BcUG4jP8Aai0AADoAIEEUDAILIAtC//+D/qbe4RFYBEAgDEK5mxp+IgxCIIghDiALQoCAmqbqr+MBWgRAIAVBGGoiAEEGciECIAUgDqdBAXQiAUG5jP8Aai0AADoAGSAFIAFBuIz/AGotAAA6ABggAEEDciEGQQEhAANAIAYgDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgBkEBayABQf4BcUG4jP8Aai0AADoAACAGQQJqIQYgAEEAIQANAAtBEAwDCyAFQRhqIgBBBXIhAiAFIA6nQTByOgAYIABBAnIhBkEBIQADQCAGIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAZBAWsgAUH+AXFBuIz/AGotAAA6AAAgBkECaiEGIABBACEADQALQQ8MAgsgDEKi75uGAX4iDEIwiCEOIAxCEIghDCALQoCAqOyFr9GxAVoEQCAFIA6nQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYA0AgBUEYaiAGaiIAQQNqIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIABBAmogAUH+AXFBuIz/AGotAAA6AAAgBkECaiIGQQZHDQALQRIMAgsgBUEYakEHciECIAUgDqdBMHI6ABgDQCAFQRhqIAZqIgBBAmogDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgAEEBaiABQf4BcUG4jP8Aai0AADoAACAGQQJqIgZBBkcNAAtBEQwBCyALQv+flKWNHVgEQCAMpyEAIAtC/8/bw/QCWARAIAVBGGpBAXIhAiAFIABBMHI6ABhBCwwCCyAFQRhqQQJyIQIgBSAAQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYQQwMAQsgDEKpuL0UfiIMQiCIIQ4gC0KAwMrzhKMCWgRAIAVBGGpBBHIhAiAFIA6nQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYIAUgDEL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAbIAUgAEH+AXFBuIz/AGotAAA6ABpBDgwBCyAFQRhqQQNyIQIgBSAOp0EwcjoAGCAFIAxC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAGiAFIABB/gFxQbiM/wBqLQAAOgAZQQ0LIQYgAiANQoDC1y+Ap0EBdCIAQbmM/wBqLQAAOgABIAIgAEG4jP8Aai0AADoAACACIA0gDUKQzgCAIgtCkM4Afn2nIgBB//8DcUHkAG4iAUEBdCIHQbmM/wBqLQAAOgAHIAIgB0G4jP8Aai0AADoABiACIAtCkM4AgqciB0HkAG4iCUEBdCIKQbmM/wBqLQAAOgADIAIgCkG4jP8Aai0AADoAAiACIAAgAUHkAGxrQf//A3FBAXQiAEG5jP8Aai0AADoACSACIABBuIz/AGotAAA6AAggAiAHIAlB5ABsa0H//wNxQQF0IgBBuYz/AGotAAA6AAUgAiAAQbiM/wBqLQAAOgAEDAILIAtC/5Pr3ANYBEAgC0L/wdcvWARAIAtCv4Q9WARAIAtCuZsafiIMQiCIIQ0gC0KgjQZaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGCAFQRhqQQNyIQJBASEGA0AgAiAMQv////8Pg0LkAH4iDEIfiKciAEEBckG4jP8Aai0AADoAACACQQFrIABB/gFxQbiM/wBqLQAAOgAAIAJBAmohAiAGQQFxQQAhBg0AC0EGIQYMBQsgBSANp0EwcjoAGCAFQRhqQQJyIQJBASEGA0AgAiAMQv////8Pg0LkAH4iDEIfiKciAEEBckG4jP8Aai0AADoAACACQQFrIABB/gFxQbiM/wBqLQAAOgAAIAJBAmohAiAGQQFxQQAhBg0AC0EFIQYMBAsgC0Ki75uGAX4iDEIwiCENIAxCEIghDCALQoCt4gRaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGEEAIQIDQCAFQRhqIAJqIgBBA2ogDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCCEGDAQLIAUgDadBMHI6ABhBACECA0AgBUEYaiACaiIAQQJqIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIABBAWogAUH+AXFBuIz/AGotAAA6AAAgAkECaiICQQZHDQALQQchBgwDCyAFIAtCiveYrwV+IgtCOYinQTByOgAYIAUgC0IZiEL/////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6ABogBSAAQf4BcUG4jP8Aai0AADoAGSAFIAtC/P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAcIAUgAEH+AXFBuIz/AGotAAA6ABsgBSALQvD///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHiAFIABB/gFxQbiM/wBqLQAAOgAdIAUgC0LA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAgIAUgAEH+AXFBuIz/AGotAAA6AB9BCSEGDAILIAUgC0IAQse4x/kqQgAQqB4gBSAFKQMIQgWGIAUpAwAiC0I7iISnQf4DcSIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGCAFIAtCHIhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAbIAUgAEH+AXFBuIz/AGotAAA6ABogBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHSAFIABB/gFxQbiM/wBqLQAAOgAcIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB8gBSAAQf4BcUG4jP8Aai0AADoAHiAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAISAFIABB/gFxQbiM/wBqLQAAOgAgQQohBgwBCyALQuMAWARAIAtCCVgEQCAFIAunQTByOgAYQQEhBgwCCyAFIAunQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYQQIhBgwBCyALQqm4vRR+IgxCIIghDSALQugHWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAGSAFIABBuIz/AGotAAA6ABggBSAMQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ABsgBSAAQf4BcUG4jP8Aai0AADoAGkEEIQYMAQsgBSANp0EwcjoAGCAFIAxC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAGiAFIABB/gFxQbiM/wBqLQAAOgAZQQMhBgtBk4CAgHhBlICAgHggAyAFQRhqIAYgBCgCDBEGABs2AgAgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCWJUUEQCMAQTBrIgUkACAFIAEoAgAgAhD/FiAFQcwBNgIkIAVBATYCDCAFQaz3gAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvzAQIBfwJ8IAEoAgAgAhCHJUUEQCMAQUBqIgUkACAFIAEgAhDPGrciBkQAAAAAAAAoQKOcIgc5AwggBSAGIAdEAAAAAAAAKECioTkDECAFQQM2AhwgBUHIk/8ANgIYIAVCAjcCJCAFQYoINgI8IAVBigg2AjQgBSAFQTBqNgIgIAUgBUEQajYCOCAFIAVBCGo2AjAgAEGTgICAeEGUgICAeCADIAVBGGogBCgCFBECABs2AgAgBUFAayQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC4cCAQF/IAEoAgAgAhCRJUUEQCMAQTBrIgUkACAFIAEoAgAgAhCnGQJAIAUoAgQiAgRAIAUoAgAhASAEKAIUIQQDQCAFIAE2AgwgBUEBNgIkIAVB+POAATYCICAFQQE2AhQgBUHw84ABNgIQIAVBATYCHCAFQYIRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAQRAgAEQCAAQZOAgIB4NgIADAMLIAFBAWohASACQQFrIgINAAsLIABBlICAgHg2AgALIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvvAgEKfyMAQRBrIgQkACAAIAEoAgQgASgCAGtBA3YQ7i0gBCAAKQIEQiCJNwIIIAQgAEEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAAkAgASgCACIAIAEoAgQiAkcEQCABKAIMIQYgAygCCCAFQQJ0aiEDIAIgAGtBA3YhByABKAIIIQgDQCAAKAIAIgIgCCgCCCIBTw0CIABBBGooAgAiAUEBaiIJIAgoAgQgAkECdGooAgAiCygCFEECdiICTw0DAkAgASACSQRAIAYgBigCACALKAIQIgIgCUECdGooAgAgAiABQQJ0aigCAGtqIgE2AgAgAUEATg0BQby1ggFBCEHEtYIBEMskAAsgASACQay1ggEQwyEACyADIAE2AgAgAEEIaiEAIANBBGohAyAFQQFqIQUgB0EBayIHDQALCyAKIAU2AgAMAgsgAiABQYy1ggEQwyEACyAJIAJBnLWCARDDIQALIARBEGokAAvYAgEKfyMAQRBrIgQkACAAIAEoAgQgASgCAGtBA3YQ7C0gBCAAKQIEQiCJNwIIIAQgAEEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAAkACQCABKAIAIgAgASgCBCICRwRAIAEoAgwhBiADKAIIIAVBA3RqIQMgAiAAa0EDdiEHIAEoAgghCANAIAAoAgAiAiAIKAIIIgFPDQIgAEEEaigCACIBQQFqIgkgCCgCBCACQQJ0aigCACILKAIUQQN2IgJPDQMgASACTw0EIAYgBigCACALKAIQIgIgCUEDdGooAgAgAiABQQN0aigCAGtqIgE2AgAgAyABrTcDACAAQQhqIQAgA0EIaiEDIAVBAWohBSAHQQFrIgcNAAsLIAogBTYCAAwDCyACIAFBjLWCARDDIQALIAkgAkGctYIBEMMhAAsgASACQay1ggEQwyEACyAEQRBqJAALSQECfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCyAAQRRqIQAgAkEBayICDQALCwtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQuyMLIABBCGohACACQQFrIgINAAsLC1EBAX8jAEEQayICJAAgAiABEMovIAIgAigCADYCDCACQQxqENEfIQEgAEIBNwMAIAAgAjUCBCABrEKAowV+fEKAkc285wF9NwMIIAJBEGokAAtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ+x4LIABBDGohACACQQFrIgINAAsLC0kBAn8gACgCDCICBEAgACgCBCEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDyJQsgAEEEaiEAIAJBAWsiAg0ACwsLSQECfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPIlCyAAQQRqIQAgAkEBayICDQALCwtFACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAiADaiABazYCAA8LIAAgASACIAMQjRgLTQEBfyMAQRBrIgIkACACQQhqIAFBAWogAS0AAEECdEGghMQAaigCACgCGBEAACACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALSgEBfyAAKAJsQQdNBEAgACAAKAJwIAAoAmhqIgE2AnAgACABQfcDSxD6CyAAQQA2AmwPCyAAQQA2AmggACgCcARAIABBARD6CwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDeOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDeOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahCdPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahCdPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDpOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDpOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDjPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDjPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRQEBfyMAQcADayIEJAAgBCADQcAD/AoAACAAIAEgBCACKAIMEQEAIAIoAgQiAARAIAEgACACKAIIEPg6CyAEQcADaiQAC0gBAX8gACgCCCIBBEAgACgCBCEAA0AgAEEMaiAAQQRqKAIAIABBCGooAgAgACgCACgCEBEBACAAQRBqIQAgAUEBayIBDQALCwtKAQF/IAFBmAJqIQMgASgCmAJBgICAgHhHBEAgA0EEQQgQ4B4LIAMgAikCADcCACADQQhqIAJBCGooAgA2AgAgACABQcAC/AoAAAtLAQJ/AkAgACgCAEEIRgRAIAAoAgQhAiAAKAIIIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBRQ0BIAIgASAAKAIIEPg6DwsgABDJIwsLSwEBfwJAIAAoAiRFBEAgACgCCCICIAFBA2pBfHFqIgEgACgCBE0NAQsgAEEBOgAcQQAPCyAAIAE2AhAgACABNgIMIAAgATYCCCACC+YDAQN/IwBBEGsiAyQAIANBBGoiAkIANwIAIAJBCGpBADYCAAJAAkACQAJAAkACQAJAAkACQCAAQegHaw4RBgEHAgMGBgYGBgcHBgcGBAcACwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB5ABrDggBAgMEBQYHCAALAkAgAEGgAWsOBRMJCgsMAAsCQCAAQcgBaw4DEhISAAsgAEGQA2tBA0kNEyAAQQpGDREgAEH0A0cNEAwRCyACQoCA+P/vAjcCBAwSCyACQoqAgIDgAzcCBAwRCyACQoaAgIDgAzcCBAwQCyACQoaAgIDQAzcCBAwPCyACQoGAgIDQAzcCBAwOCyACQoOAgIDwADcCBAwNCyACQYCACDYCCAwMCyACQoGAgICQATcCBAwLCyACQoaAgIDgAzcCBAwKCyACQoSAgICAgAQ3AgQMCQsgAkKBgICAgAE3AgQMCAsgAkEYNgIIDAcLIAJBAzYCCAwGCyACQsCAgICAgIABNwIEDAULIAJB/////wc2AggMBAsgAkKAiICAgICAATcCBAwDCyACQVg2AgAMAgsgAkEBNgIIDAELIAJBAjYCCAsgAygCBCADKAIIIQIgAygCDCEEIANBEGokAEGJf0kgASACTnEgASAETHELQQEBfwJAIAAoAgQiA0UNACADIAIgA0EBaiABbGpBAWtBACACa3EiAWpBCWoiA0UNACAAKAIAIAFrIAMgAhD4OgsLSQEDfyMAQTBrIgIkACABEJs2IgNFBEBBjISDARCyOwALIAJBBGoiBCABIAMQyiIgAkEANgIYIAAgBCACQRhqENQYIAJBMGokAAtEAQF/IAAoAhwEQCAAQRxqENQeCyAAKAIIIgEEQCAAKAIEIQAgAUEDdCEBA0AgABD5IyAAQQhqIQAgAUEIayIBDQALCwucAQEFfyAAKAIYQQhqKAIQIQIgACgCJCIBBEAgAiABQQhqKAIQaiECCyAAKAIEIgEgASAAKAIIQQN0aiIARwRAIAAgAWtBA3YhAANAIAEoAgAiBAR/IAQgAUEEaigCACIFKAIIQQFrQXhxakEIaiAFKAJUEQQABUEACyEEIAFBCGohASADIARqIQMgAEEBayIADQALCyACIANqQTBqCzoBAX8jAEEgayIAJAAgAEEANgIYIABBATYCDCAAQaSuhgE2AgggAEIENwIQIABBCGpBrK6GARDvLAALPQEBfyAAKAIAIgBBBHZB/wNxIgIgAUH/AXEiAWogAiAAQQdxakEHcCIAQQdqIAAgACABSRtrQQZqQQdtwQtJAQF/AkAgACgCOCAAKAI8IAEoAjggASgCPBDBLkUNACAAQShqIAFBKGoQzQhFDQAgAC0AQCABLQBARw0AIAAgARDlDCECCyACC54BAgN/AX4gACkDEEIDUgRAIABBEGoiAikDACIEQgJRIASnQQFxRXJFBEAgAikDCHunIQMLAkAgAigCECIBRQ0AIAEgAigCFCICRg0AIAIgAWtBA3YhAgNAIAMgASkDAHunaiEDIAFBCGohASACQQFrIgINAAsLIAMhAQsgACkDACIEQgJSBH8gACkDCHunQQAgBKdBAXEbIAFqBSABCwtNAQN/IAEgASgCDCABQRBqIgIoAgAiAxDTHyEEIABBEGogAigCADYCACAAQQhqIAFBCGopAgA3AgAgACABKQIANwIAIAAgAyAEazYCFAtKAQN/IAAoAgAiAgRAIAAoAgQiAygCACIBBEAgAiABEQMACyADKAIEIgEEQCACIAEgAygCCBD4OgsgACgCDCAAKAIIKAIMEQMACws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHMwIkBNgIIIABCBDcCECAAQQhqQdTAiQEQ7ywAC0gBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQzxYgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtEAQF/IAAoAggiAQRAIAAoAgQhAANAIAAoAgBBgICAgHhHBEAgABD1OyAAQQxqEIUwCyAAQRhqIQAgAUEBayIBDQALCwtOAQF/AkACQAJAIAAtAJgHDgQAAgIBAgsgAEGMB2oQ3jsPCyAAEKoeIAAoAogHIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQYgHahCdJwsLTQECfyABLwEkIQMgASgCCCICIAEoAgBGBEAgAUGQhsMAEK0oCyABKAIEIAJBAXRqIAM7AQAgAEEENgIAIAFBADsBJCABIAJBAWo2AggLTAEBfyAAKAIAIgBBFGogACgCDCAAKAIQIAAoAggoAhARAQACQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBGEEEEPg6CwtJAQF/IAAoAgAiACgCCCIBBEAgACgCDCABKAIMEQMACwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEYQQQQ+DoLC08BAX8gAUEMaiABKAIEIAFBCGoiBCgCACABKAIAKAIQEQEAIAFBADYCFCABIAM2AhAgAEEINgIAIAQgAkEIaikCADcCACABIAIpAgA3AgALUAIBfwF+IAEoAgBBgICAgHhHBEAgAUEEQQgQ4B4LIAFBCGoiAyACQQhqKAIANgIAIAEgAikCACIENwIAIAAgBDcCACAAQQhqIAMpAgA3AgALRAEDfyAAKAIAIgMoAgAiACABKAIAIgQoAgAiAnJFIQEgAEUgAkVyBH8gAQUgAEEIaiADKAIEIAJBCGogBCgCBBDBLgsLPwEBfyAAEN47IABBDGoiARDXKyABEOg7IABBGGoiARDXKyABEOg7IABBJGoQ4zwgAEEwahCFMCAAQTxqEIUwC0oBAX8CQCABKAIgQQFHBH9BAAUgASgCJEUNASABKAIsIQIgASgCKAshASAAIAI2AgQgACABNgIADwtB5IfOAEEgQYSIzgAQyyQAC0oBAX8CQCABKAI0QQFHBH9BAAUgASgCOEUNASABKAJAIQIgASgCPAshASAAIAI2AgQgACABNgIADwtB5IfOAEEgQYSIzgAQyyQAC1YBAn8gAS8BFCEDIAEoAggiAiABKAIARgRAIAFBqLLOABCtKAsgASgCBCACQQF0aiADOwEAIABChICAgICAgICAfzcCACABQQA7ARQgASACQQFqNgIIC1YBAn8gAS8BECEDIAEoAggiAiABKAIARgRAIAFB1MbOABCtKAsgASgCBCACQQF0aiADOwEAIABChICAgICAgICAfzcCACABQQA7ARAgASACQQFqNgIIC00BAn8gAS8BJCEDIAEoAggiAiABKAIARgRAIAFB5MjOABCtKAsgASgCBCACQQF0aiADOwEAIABBBDYCACABQQA7ASQgASACQQFqNgIIC5sCAQV/IwBBEGsiAyQAIAEoAgghBCMAQSBrIgIkACADIAEoAgAiBSABKAIERgR/QQAFIAEgBUEIajYCACACQQhqIAUoAgAgBSgCBCgCGBEAACACKAIQIQEgAigCDCEFAn8gAigCCCIGQQhHBEAgBCgCAEEIRwRAIAQQySMLIAQgATYCCCAEIAU2AgQgBCAGNgIAIAQgAkEUaiIBKQIANwIMIARBFGogAUEIaigCADYCAEEAIQEgAkEEagwBCyACIAU2AgQgAgsgATYCACACKAIEIQEgAyACKAIANgIIIAMgATYCBEEBCzYCACACQSBqJAAgAygCBCEBIAMoAgAhAiAAIAMoAgg2AgQgACABQQAgAhs2AgAgA0EQaiQAC0sBAn8gACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFNBEAgASAAQZSQzgAQwyEACyADKAIAIAQoAgQgAWpBARDNAgs/AQJ/IAAoAhAiAQRAIAAoAgwgACgCCCICIAAoAgQgAUEBamxqQQFrQQAgAmtxIgBrIAAgAWpBCWogAhD4OgsLsxYCG38BfiAAIQ0gASEGIAIhGCAEKAIEIRkgBCgCCCEaIAQoAhBBACAEKAIMQYCAgIB4RxshFCAEKAIUIREgBCgCHEEAIAQoAhhBgICAgHhHGyESIAQoAiAhEEEAIQQjAEEwayILJAACQAJAIBRBACASG0UEQCADIQAgFEUNASARIQAMAQsgESEAIBAgEUYNACALIBE2AgAgCyAQNgIEIAtBAjYCHCALQYj+zgA2AhggC0ICNwIkIAtBOzYCFCALQTs2AgwgCyALQQhqNgIgIAsgC0EEajYCECALIAs2AgggDUEEaiALQRhqEJkOIA1BADYCAAwBCyAGKAKQAUUEQCAGQgA3A8ABCyAGQgA3A7gBAkACQAJAAkAgAARAIAYoArwEKAKUASEcA0ACQCASRSAEIBxqIgEgACAAIAFLGyIBIBBPcg0AIBIgAUEBdGohAgNAIAIvAQBFDQEgAkECaiECIBAgAUEBaiIBRw0ACyAQIQELQQAhAkEAIQggFARAIAEgBEkNAyABIBFLDQQgFCAEQQF0aiEICyASBEAgASAESQ0FIAEgEEsNBiASIARBAXRqIQILIAtBGGohByABIARrIQkgAiEEIwBBQGoiBSQAIAkhDAJAAkACQAJAAkAgBigCuAQiCi4BGCICQQBKBH8gCEUEQCAFQQE2AhwgBUH4/84ANgIYIAVCATcCJCAFQc0BNgI4IAUgAjsBPiAFIAVBNGo2AiAgBSAFQT5qNgI0IAVBBHIgBUEYahCZDiAHIAUpAgw3AgwgB0EUaiAFQRRqKAIANgIAIAcgBSkCBDcCBCAHQQA2AgAMAwtBACEMIAkEQCACQf//A3EhDiAIIQIgCSEKA0AgDCACLwEAIA5GaiEMIAJBAmohAiAKQQFrIgoNAAsLIAYgBikDmAMgCSAMa618NwOYAyAGKAKsA0GAgICAeEcEQCAGQawDaiAIIAkQ1yELIAZBoARqIAggCRD4KSAGKAK4BAUgCgsuARoiAkEATARAIAYgBigCvAMgCWo2ArwDDAELIAQEQCAJBEAgBC8BAARAIAVBATYCHCAFQZD/zgA2AhggBUIBNwIkIAVBzQE2AgQgBSAENgIAIAUgBTYCICAHQQRqIAVBGGoQmQ4gB0EANgIADAQLIAlBAXQhCCAGKAK8AyEKIAQhAgNAIAogAi8BAEVqIQogAkECaiECIAhBAmsiCA0ACyAGIAo2ArwDCyAGKAKgA0GAgICAeEcEQCAGQaADaiAEIAkQ1yELIAZBrARqIAQgCRD4KQwBCyAFQQE2AhwgBUHAgM8ANgIYIAVCATcCJCAFQc0BNgI4IAUgAjsBPiAFIAVBNGo2AiAgBSAFQT5qNgI0IAVBBHIgBUEYahCZDiAHIAUpAgw3AgwgB0EUaiAFQRRqKAIANgIAIAcgBSkCBDcCBCAHQQA2AgAMAQsCQCAZBEAgDCAPaiICIAxJDQMgAiAaSw0EIwBBIGsiBCQAIAYgBigCkAEgDGo2ApABIAQgAzYCHCAEIBg2AhggBCAZIA9BAnRqIgI2AhAgBCACIAxBAnRqNgIUIwBBIGsiAiQAIAJBFGogBEEQaiIKKAIEIAooAgBrQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGBEAgCCACKAIcQaCDzgAQ/S8ACyAEQQRqIRcgAkEQaiIdQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIg4kACACQQhqIgggCigCBCAKKAIAa0ECdhDuLSAOIAgpAgRCIIk3AgggDiAIQQhqNgIEIA5BBGoiEygCBCEVIBMoAgAhHgJAAkAgCigCACIIIAooAgQiFkcEQCAKKAIMIRsgCigCCCEfIBMoAgggFUECdGohCiAWIAhrQQJ2IRMDQCAIKAIAIhYgG08NAiAKIB8gFkECdGooAgA2AgAgCEEEaiEIIApBBGohCiAVQQFqIRUgE0EBayITDQALCyAeIBU2AgAMAQsgFiAbQdzl0AAQwyEACyAOQRBqJAAgF0EIaiAdKAIANgIAIBcgAikCCDcCACACQSBqJAAgBUEYaiAGIAQoAgggBCgCDBCzECAXEOk7IARBIGokACAFKAIYIgJBCEYNASAHIAUpAhw3AgQgB0EUaiAFQSxqKAIANgIAIAdBDGogBUEkaikCADcCACAHIAI2AgAMAgsgBUEYaiEEIwBB0ABrIgIkACAGIAYoApABIAxqNgKQASACIAw2AgQCQCAMIAwgD2oiCE0gAyAIT3FFBEAgAiADIA9rNgI8IAJBAjYCKCACQYiJzgA2AiQgAkICNwIwIAJBOzYCTCACQTs2AkQgAiACQUBrNgIsIAIgAkE8ajYCSCACIAJBBGo2AkAgAkEIakEEciACQSRqEJkOIAQgAikCFDcCDCAEQRRqIAJBHGooAgA2AgAgBCACKQIMNwIEIARBADYCAAwBCyAEIAYgGCAPQQJ0aiAMELMQCyACQdAAaiQAIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCyAGIAYoArgDIAlqIgI2ArgDAkAgAkUNACAGKAK8AyAGKAK8BCICKAKQAUkEQCAGEL0cIAIoAowBSQ0BCyAFQRhqIAYQ5AEgBSgCGCICQQhGDQAgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAELAkAgBigCaEGAgICAeEYNACAGKAJcIAYoArwEQQhqIAYoArgEQQhqENARSQ0AIAVBGGohBCMAQcABayICJAACQAJAIAYoArgDRQ0AIAJBIGogBhDkASACKAIgIglBCEYNACAEIAIpAiQ3AgQgBEEUaiACQTRqKAIANgIAIARBDGogAkEsaikCADcCACAEIAk2AgAMAQsgAkEgaiAGEI4HIAIoAiAiCUEIRwRAIAQgAikCJDcCBCAEQRRqIAJBNGooAgA2AgAgBEEMaiACQSxqKQIANwIAIAQgCTYCAAwBCwJAAkAgBigCuANFDQAgAkGoAWogBhDkASACKAKoASIJQQhGDQAMAQsCQCAGKALEAiIJRQ0AIAJBKGohCANAIAYgCUEBazYCxAIgBiAGKALAAiIJQQFqIgogBigCuAIiDkEAIAogDk8bazYCwAIgBigCvAIgCUGIAWxqIgkpAwAiIEIMUQ0BIAIgIDcDICAIIAlBCGpBgAH8CgAAIAJBqAFqIAYgAkEgahCoCiACKAKoASIJQQhHDQIgBigCxAIiCQ0ACwsgBEEINgIADAELIAJBGGoiCCACQbwBaigCADYCACACQRBqIgogAkG0AWopAgA3AwAgAiACKQKsATcDCCAEIAk2AgAgBCACKQMINwIEIARBDGogCikDADcCACAEQRRqIAgoAgA2AgALIAJBwAFqJAAgBSgCGCICQQhGDQAgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAELIAdBCDYCACAHIAw2AgQLIAVBQGskAAwCCyAPIAJBqP/OABCxOwALIAIgGkGo/84AELA7AAsgCygCHCECIAsoAhgiBEEIRwRAIA0gCykDIDcDCCANQRBqIAtBKGopAwA3AwAgDSACNgIEIA0gBDYCAAwHCyACIA9qIQ8gACABIgRLDQALCyANQQg2AgAgDSAPNgIEDAQLIAQgAUGY/s4AELE7AAsgASARQZj+zgAQsDsACyAEIAFBqP7OABCxOwALIAEgEEGo/s4AELA7AAsgC0EwaiQAC7MWAht/AX4gACENIAEhBiACIRggBCgCBCEZIAQoAgghGiAEKAIQQQAgBCgCDEGAgICAeEcbIRQgBCgCFCERIAQoAhxBACAEKAIYQYCAgIB4RxshEiAEKAIgIRBBACEEIwBBMGsiCyQAAkACQCAUQQAgEhtFBEAgAyEAIBRFDQEgESEADAELIBEhACAQIBFGDQAgCyARNgIAIAsgEDYCBCALQQI2AhwgC0GI/s4ANgIYIAtCAjcCJCALQTs2AhQgC0E7NgIMIAsgC0EIajYCICALIAtBBGo2AhAgCyALNgIIIA1BBGogC0EYahCZDiANQQA2AgAMAQsgBigCoAFFBEAgBkIANwPwAQsgBkIANwPoAQJAAkACQAJAIAAEQCAGKALoBCgClAEhHANAAkAgEkUgBCAcaiIBIAAgACABSxsiASAQT3INACASIAFBAXRqIQIDQCACLwEARQ0BIAJBAmohAiAQIAFBAWoiAUcNAAsgECEBC0EAIQJBACEIIBQEQCABIARJDQMgASARSw0EIBQgBEEBdGohCAsgEgRAIAEgBEkNBSABIBBLDQYgEiAEQQF0aiECCyALQRhqIQcgASAEayEJIAIhBCMAQUBqIgUkACAJIQwCQAJAAkACQAJAIAYoAuQEIgouARgiAkEASgR/IAhFBEAgBUEBNgIcIAVB+P/OADYCGCAFQgE3AiQgBUHNATYCOCAFIAI7AT4gBSAFQTRqNgIgIAUgBUE+ajYCNCAFQQRyIAVBGGoQmQ4gByAFKQIMNwIMIAdBFGogBUEUaigCADYCACAHIAUpAgQ3AgQgB0EANgIADAMLQQAhDCAJBEAgAkH//wNxIQ4gCCECIAkhCgNAIAwgAi8BACAORmohDCACQQJqIQIgCkEBayIKDQALCyAGIAYpA9ADIAkgDGutfDcD0AMgBigC5ANBgICAgHhHBEAgBkHkA2ogCCAJENchCyAGQcwEaiAIIAkQ+CkgBigC5AQFIAoLLgEaIgJBAEwEQCAGIAYoAvQDIAlqNgL0AwwBCyAEBEAgCQRAIAQvAQAEQCAFQQE2AhwgBUGQ/84ANgIYIAVCATcCJCAFQc0BNgIEIAUgBDYCACAFIAU2AiAgB0EEaiAFQRhqEJkOIAdBADYCAAwECyAJQQF0IQggBigC9AMhCiAEIQIDQCAKIAIvAQBFaiEKIAJBAmohAiAIQQJrIggNAAsgBiAKNgL0AwsgBigC2ANBgICAgHhHBEAgBkHYA2ogBCAJENchCyAGQdgEaiAEIAkQ+CkMAQsgBUEBNgIcIAVBwIDPADYCGCAFQgE3AiQgBUHNATYCOCAFIAI7AT4gBSAFQTRqNgIgIAUgBUE+ajYCNCAFQQRyIAVBGGoQmQ4gByAFKQIMNwIMIAdBFGogBUEUaigCADYCACAHIAUpAgQ3AgQgB0EANgIADAELAkAgGQRAIAwgD2oiAiAMSQ0DIAIgGksNBCMAQSBrIgQkACAGIAYoAqABIAxqNgKgASAEIAM2AhwgBCAYNgIYIAQgGSAPQQJ0aiICNgIQIAQgAiAMQQJ0ajYCFCMAQSBrIgIkACACQRRqIARBEGoiCigCBCAKKAIAa0ECdkEAQQhBCBCgGCACKAIYIQggAigCFEEBRgRAIAggAigCHEGgg84AEP0vAAsgBEEEaiEXIAJBEGoiHUEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIOJAAgAkEIaiIIIAooAgQgCigCAGtBAnYQ7C0gDiAIKQIEQiCJNwIIIA4gCEEIajYCBCAOQQRqIhMoAgQhFSATKAIAIR4CQAJAIAooAgAiCCAKKAIEIhZHBEAgCigCDCEbIAooAgghHyATKAIIIBVBA3RqIQogFiAIa0ECdiETA0AgCCgCACIWIBtPDQIgCiAfIBZBA3RqKQMANwMAIAhBBGohCCAKQQhqIQogFUEBaiEVIBNBAWsiEw0ACwsgHiAVNgIADAELIBYgG0Hc5dAAEMMhAAsgDkEQaiQAIBdBCGogHSgCADYCACAXIAIpAgg3AgAgAkEgaiQAIAVBGGogBiAEKAIIIAQoAgwQtBAgFxDjPCAEQSBqJAAgBSgCGCICQQhGDQEgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAILIAVBGGohBCMAQdAAayICJAAgBiAGKAKgASAMajYCoAEgAiAMNgIEAkAgDCAMIA9qIghNIAMgCE9xRQRAIAIgAyAPazYCPCACQQI2AiggAkGIic4ANgIkIAJCAjcCMCACQTs2AkwgAkE7NgJEIAIgAkFAazYCLCACIAJBPGo2AkggAiACQQRqNgJAIAJBCGpBBHIgAkEkahCZDiAEIAIpAhQ3AgwgBEEUaiACQRxqKAIANgIAIAQgAikCDDcCBCAEQQA2AgAMAQsgBCAGIBggD0EDdGogDBC0EAsgAkHQAGokACAFKAIYIgJBCEYNACAHIAUpAhw3AgQgB0EUaiAFQSxqKAIANgIAIAdBDGogBUEkaikCADcCACAHIAI2AgAMAQsgBiAGKALwAyAJaiICNgLwAwJAIAJFDQAgBigC9AMgBigC6AQiAigCkAFJBEAgBhC+HCACKAKMAUkNAQsgBUEYaiAGEOcBIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCwJAIAYoAnhBgICAgHhGDQAgBigCbCAGKALoBEEIaiAGKALkBEEIahDQEUkNACAFQRhqIQQjAEHAAWsiAiQAAkACQCAGKALwA0UNACACQSBqIAYQ5wEgAigCICIJQQhGDQAgBCACKQIkNwIEIARBFGogAkE0aigCADYCACAEQQxqIAJBLGopAgA3AgAgBCAJNgIADAELIAJBIGogBhCMByACKAIgIglBCEcEQCAEIAIpAiQ3AgQgBEEUaiACQTRqKAIANgIAIARBDGogAkEsaikCADcCACAEIAk2AgAMAQsCQAJAIAYoAvADRQ0AIAJBqAFqIAYQ5wEgAigCqAEiCUEIRg0ADAELAkAgBigC/AIiCUUNACACQShqIQgDQCAGIAlBAWs2AvwCIAYgBigC+AIiCUEBaiIKIAYoAvACIg5BACAKIA5PG2s2AvgCIAYoAvQCIAlBiAFsaiIJKQMAIiBCDFENASACICA3AyAgCCAJQQhqQYAB/AoAACACQagBaiAGIAJBIGoQpAogAigCqAEiCUEIRw0CIAYoAvwCIgkNAAsLIARBCDYCAAwBCyACQRhqIgggAkG8AWooAgA2AgAgAkEQaiIKIAJBtAFqKQIANwMAIAIgAikCrAE3AwggBCAJNgIAIAQgAikDCDcCBCAEQQxqIAopAwA3AgAgBEEUaiAIKAIANgIACyACQcABaiQAIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCyAHQQg2AgAgByAMNgIECyAFQUBrJAAMAgsgDyACQaj/zgAQsTsACyACIBpBqP/OABCwOwALIAsoAhwhAiALKAIYIgRBCEcEQCANIAspAyA3AwggDUEQaiALQShqKQMANwMAIA0gAjYCBCANIAQ2AgAMBwsgAiAPaiEPIAAgASIESw0ACwsgDUEINgIAIA0gDzYCBAwECyAEIAFBmP7OABCxOwALIAEgEUGY/s4AELA7AAsgBCABQaj+zgAQsTsACyABIBBBqP7OABCwOwALIAtBMGokAAtGAAJAIAEgAhCuGgRAIAAhAQwBCyAAIAEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDAAsgAUEJNgIACz4AIANB2wtNBEAgACABIAIgAxCYFQ8LIARBA3EEQEF/DwsgBUGAIEkEQEG+fw8LIAAgASACIANBACAEELAIC0QBBH8gACgCBCAAKAIAQQJ0aiICLQACIAEgASgCBCIEIAItAAMiBWo2AgQgACACLwEAIAEoAgAgBHRBACAFa3ZqNgIAC0UBAX8CQCAAKAIkRQRAIABBARChH0GIf0sNAQsgACgCDCICIAFqIgEgACgCFEsEQCAAQQE6ABxBAA8LIAAgATYCDAsgAgtDACAAQv////8PNwMAIABCfyABKAIQIgCthkJ/hUHAACABKAIMIgEgAUHAAE8bIgEgAGtBACAAQQFrIAFJG62GNwMIC1ABAn8jAEEgayIBJAAgAUEANgIcIAFCgICAgBA3AhQgAUEIaiABQRRqQfSo+wAQkCEgASgCDCECIAAgASgCCDYCACAAIAI2AgQgAUEgaiQAC1EBAn8jAEEgayIBJAAgAUEANgIcIAFCgICAgMAANwIUIAFBCGogAUEUakH0qPsAEJghIAEoAgwhAiAAIAEoAgg2AgAgACACNgIEIAFBIGokAAtQAQJ/IwBBIGsiASQAIAFBADYCHCABQoCAgIAgNwIUIAFBCGogAUEUakH0qPsAEJYhIAEoAgwhAiAAIAEoAgg2AgAgACACNgIEIAFBIGokAAu8AQIHfwJ+IwBBEGsiAyQAIAEoAgQiBUELTwRAIAVBCkHQqP4AELA7AAsgA0EEaiEEIAFBCGohB0EAIQECQANAIAEgBUYNASABIAdqIAFBAWohAS0AACICQf8Aca0gCYYgCoQhCiACwCICQQBIBEAgCUI5VCAJQgd8IQkNAQsLIAJBAEgNACAEIAE2AgggBEIAIApCAYN9IApCAYiFPgIEQQEhBgsgBCAGNgIAIAAgAykCBDcDACADQRBqJAALsAECB38CfiMAQRBrIgMkACABKAIEIgVBC08EQCAFQQpB0Kj+ABCwOwALIANBBGohBCABQQhqIQdBACEBAkADQCABIAVGDQEgASAHaiABQQFqIQEtAAAiAkH/AHGtIAmGIAqEIQogAsAiAkEASARAIAlCOVQgCUIHfCEJDQELCyACQQBIDQAgBCABNgIIIAQgCj4CBEEBIQYLIAQgBjYCACAAIAMpAgQ3AwAgA0EQaiQAC7ACAgV/AX4jAEEQayIDJAAgASgCHCEEIwBBIGsiAiQAIAMgASgCECIFIAEoAhRJBH8gASAFQQFqNgIQIAJBDGogASgCACAFQQN0akGks4ABIAEoAgggBUECdGooAgBBMGogASgCGBCGASACKAIUIQEgAigCECEFAn8gAigCDCIGQZOAgIB4RwRAIAIpAhghByAEKAIAQZOAgIB4RwRAIAQQiBELIAQgBzcCDCAEIAE2AgggBCAFNgIEIAQgBjYCAEEAIQEgAkEIagwBCyACIAU2AgggAkEEagsgATYCACACKAIIIQEgAyACKAIENgIIIAMgATYCBEEBBUEACzYCACACQSBqJAAgAygCBCEBIAMoAgAhAiAAIAMoAgg2AgQgACABQQAgAhs2AgAgA0EQaiQAC/YBAgV/AX4jAEEQayIEJAAgASgCDCEFIwBBIGsiAiQAIAQgASgCACIDIAEoAgRGBH9BAAUgASADQQhqNgIAIAJBDGogAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAMgASgCCBCIASACKAIUIQMgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBRDlECAFIAc3AgwgBSADNgIIIAUgATYCBCAFIAY2AgBBACEBCyAEIAM2AgggBCABNgIEQQELNgIAIAJBIGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAAL9gECBX8BfiMAQRBrIgQkACABKAIMIQUjAEEgayICJAAgBCABKAIAIgMgASgCBEYEf0EABSABIANBCGo2AgAgAkEMaiADKAIAIAMoAgQiAygCCEEBa0F4cWpBCGogAyABKAIIEIcBIAIoAhQhAyACKAIQIQEgAigCDCIGQZOAgIB4RwRAIAIpAhghByAFEOUQIAUgBzcCDCAFIAM2AgggBSABNgIEIAUgBjYCAEEAIQELIAQgAzYCCCAEIAE2AgRBAQs2AgAgAkEgaiQAIAQoAgQhASAEKAIAIQIgACAEKAIINgIEIAAgAUEAIAIbNgIAIARBEGokAAv2AQIFfwF+IwBBEGsiBCQAIAEoAgwhBSMAQSBrIgIkACAEIAEoAgAiAyABKAIERgR/QQAFIAEgA0EIajYCACACQQxqIAMoAgAgAygCBCIDKAIIQQFrQXhxakEIaiADIAEoAggQigEgAigCFCEDIAIoAhAhASACKAIMIgZBk4CAgHhHBEAgAikCGCEHIAUQ5RAgBSAHNwIMIAUgAzYCCCAFIAE2AgQgBSAGNgIAQQAhAQsgBCADNgIIIAQgATYCBEEBCzYCACACQSBqJAAgBCgCBCEBIAQoAgAhAiAAIAQoAgg2AgQgACABQQAgAhs2AgAgBEEQaiQAC/YBAgV/AX4jAEEQayIEJAAgASgCDCEFIwBBIGsiAiQAIAQgASgCACIDIAEoAgRGBH9BAAUgASADQQhqNgIAIAJBDGogAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAMgASgCCBCJASACKAIUIQMgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBRDlECAFIAc3AgwgBSADNgIIIAUgATYCBCAFIAY2AgBBACEBCyAEIAM2AgggBCABNgIEQQELNgIAIAJBIGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAAL4gECBX8BfiMAQRBrIgMkACABKAIMIQQjAEEgayICJAAgAyABKAIAIgUgASgCBEYEf0EABSABIAVBCGo2AgAgAkEMaiAFQeSzggEgASgCCBCiASACKAIUIQUgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBBDlECAEIAc3AgwgBCAFNgIIIAQgATYCBCAEIAY2AgBBACEBCyADIAU2AgggAyABNgIEQQELNgIAIAJBIGokACADKAIEIQEgAygCACECIAAgAygCCDYCBCAAIAFBACACGzYCACADQRBqJAALswICBn8BfiMAQRBrIgQkACABKAIMIQUjAEEwayICJAAgASgCBCIDIAEoAghJBEBBASEGIAEgA0EBajYCBCACIAM2AiAgASgCACIBKAIIIQMgAiABKAIEIgE2AgwgAiABIANBAnRqNgIQIAIgAkEgajYCFCACQSRqIgEgAkEMaiIDQYizggEQhBsgAyACKAIoIAIoAiwQnQEgAUEEQQgQ4B4gAigCFCEDIAIoAhAhASACKAIMIgdBk4CAgHhHBEAgAikCGCEIIAUQ5RAgBSAINwIMIAUgAzYCCCAFIAE2AgQgBSAHNgIAQQAhAQsgBCADNgIIIAQgATYCBAsgBCAGNgIAIAJBMGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAALQgEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCVBEEAEE0aiEBIAAoAhQiAAR/IAEgAEEIaigCEGoFIAELC0YAIAAgASgCBDYCBCAAIAEoAgAgAmoiASABQYCjBW0iAkGAowVsayIBQR91IAJqNgIIIAAgAUGAowVqIAEgAUEASBs2AgALRAAgAEEANgIQIAAgBDYCDCAAIAM2AgggACACNgIEIAAgATYCACAAIAQgA2tBAnYiACACIAFrQQJ2IgEgACABSRs2AhQLgwsBCH8jAEEQayIIJAAgASgCECEJIwBBIGsiByQAIAggASgCACICIAEoAgRGBH9BAAUgASACQQRqNgIAAkACQCACKAIAIgIoAhQEQCABKAIIIgUoAgAiBCACKAIQKAIkaiEDIAEoAgwtAAANAQwCC0EAQQBB/ImHARDDIQALIAUgAzYCAAsgBCEBQQAhBSMAQUBqIgQkAAJAAkACQCACLQAYQSJHDQACQAJAAkACQAJAAkACQAJAAkACQCACKAIcLQAAQQJrDggDBAEGBwgCCQALQcSQhwFBKEHskIcBEJ8pAAsgASADckEATg0DDAgLIwBBEGsiAyQAIANBCGogAkEAEOcdIAMoAgwhBSADKAIIIQZBDEEEEK02IgJFDQggAiABNgIIIAIgBjYCACACIAU2AgQgBEEwaiIBQbSbhwE2AgQgASACNgIAIANBEGokACAEKAI0IQUgBCgCMCEGDAcLIAEgA3JBgAFPDQYjAEEQayIDJAAgA0EIaiACENIeIAMoAgwhBSADKAIIIQZBDEEEEK02IgJFDQcgAiABOgAIIAIgBjYCACACIAU2AgQgBEHMm4cBNgIEIAQgAjYCACADQRBqJAAgBCgCBCEFIAQoAgAhBgwGCyABIANyQYCAAk8NBSMAQRBrIgMkACADQQhqIAIQ5B0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNBiACIAE7AQggAiAGNgIAIAIgBTYCBCAEQQhqIgFBlJyHATYCBCABIAI2AgAgA0EQaiQAIAQoAgwhBSAEKAIIIQYMBQsjAEEQayIDJAAgA0EIaiACQQAQ5x0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNBSACIAE2AgggAiAGNgIAIAIgBTYCBCAEQRBqIgFBhJuHATYCBCABIAI2AgAgA0EQaiQAIAQoAhQhBSAEKAIQIQYMBAsjAEEQayIDJAAgA0EIaiACEOMdIAMoAgwhBSADKAIIIQZBEEEIEK02IgJFBEBBCEEQEKM9AAsgAiABrTcDCCACIAY2AgAgAiAFNgIEIARBGGoiAUGcm4cBNgIEIAEgAjYCACADQRBqJAAgBCgCHCEFIAQoAhghBgwDCyABIANyQYACTw0CIwBBEGsiAyQAIANBCGogAhDSHiADKAIMIQUgAygCCCEGQQxBBBCtNiICRQ0DIAIgAToACCACIAY2AgAgAiAFNgIEIARBIGoiAUGsnIcBNgIEIAEgAjYCACADQRBqJAAgBCgCJCEFIAQoAiAhBgwCCyABIANyQYCABE8NASMAQRBrIgMkACADQQhqIAIQ5B0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNAiACIAE7AQggAiAGNgIAIAIgBTYCBCAEQShqIgFB5JuHATYCBCABIAI2AgAgA0EQaiQAIAQoAiwhBSAEKAIoIQYMAQsjAEEQayIDJAAgA0EIaiACEOUdIAMoAgwhBSADKAIIIQZBEEEIEK02IgJFBEBBCEEQEKM9AAsgAiABrTcDCCACIAY2AgAgAiAFNgIEIARBOGoiAUH8m4cBNgIEIAEgAjYCACADQRBqJAAgBCgCPCEFIAQoAjghBgsgByAFNgIEIAcgBjYCACAEQUBrJAAMAQtBBEEMEKM9AAsgBygCBCEBIAcoAgAhAiAHQZCAgIB4NgIMAn8gAkUEQCAJKAIAQZOAgIB4RwRAIAkQiBELIAlBkICAgHg2AgBBACEBIAdBCGoMAQsgB0EMaiIDEIgRIAcgAjYCCCADCyABNgIAIAcoAgghASAIIAcoAgw2AgggCCABNgIEQQELNgIAIAdBIGokACAIKAIEIQEgCCgCACEHIAAgCCgCCDYCBCAAIAFBACAHGzYCACAIQRBqJAALRwEBfwJAIAAvAQAiAEH//wFxQYD4AUsNACABLwEAIgFB//8BcUGA+AFLDQBBASECIAAgAUYNACAAIAFyQf//AXFFIQILIAILRgECfyMAQRBrIgIkACACIAAoAgAiADYCDCACQQxqIgMgARDvEyAAIAAoAgBBAWsiADYCACAARQRAIAMQmCkLIAJBEGokAAtPAQJ/IAAoAgQhAiAAKAIAIQMCQCAAKAIIIgAtAABFDQAgA0HI8YkBQQQgAigCDBEGAEUNAEEBDwsgACABQQpGOgAAIAMgASACKAIQEQIAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQQwQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQRgQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0oBAX8gAEEoaiIBEPcdIAEQ8TsgAEE0aiIBEPQbIAEQ7zsgAEFAaxCHMCAAQcwAahCGMCAAQdgAahCRMCAAELsuIABB5ABqEIYwC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQTQQsRIgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQSQQsRIgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC/MCAQZ/IwBBEGsiAyQAIABBABDYLSACBEAgAyABNgIIIAMgAjYCDCACQQFrIQQgA0EIaigCACEFAn8DQEEBIAUQ7hIiAUGAgMQARg0BGiAAKAIIIQYgAAJ/QQEgAUGAAUkiBw0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIIENgtIAAoAgQgACgCCGohAgJAAkAgB0UEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACAGIAhqNgIIIARBAWsiBEF/Rw0AC0EACyEAIAMgBDYCBCADIAA2AgALIANBEGokAAtHAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEEEELESIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtOAQF/IwBBEGsiAiQAIAIgACgCACIANgIMIAFBgLjMAEEGQYa4zABBBCAAQQRqQeC3zABBirjMAEEFIAJBDGpB8LfMABCOGCACQRBqJAALVgAgAEEgEOggIABBGGpBgIDAABDoICAAQUBrQYABQYSezgAQthUgAEIANwMwIABCgICAgIAQNwJMIABBOGpCADcDACAAQQA2AlwgAEKggICAwAA3AlQLQAEBfyAAKALMASAAKAKIASAAKAIoamogAC0ALCIBQQN2IAFBB3FBAEdqaiAALQCMASIAQQN2IABBB3FBAEdqagtHAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEEIELcRIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHAABC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBBBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBEBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSAEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRB4AAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0gBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQbgFELcRIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHAAhC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBLBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQFBARC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSAEBf0EMQQQQrTYiAkUEQEEEQQwQoz0ACyAAQQE2AgggACACNgIEIABBATYCACACIAEpAgA3AgAgAkEIaiABQQhqKAIANgIAC04BAX8jAEEQayICJAAgAiAAKAIAIgBBCGo2AgwgAUGQ6M8AQQ5BnujPAEEEIABB8OfPAEGi6M8AQQsgAkEMakGA6M8AEI4YIAJBEGokAAs7AQJ/AkAgACgCACIBQRJGDQBBECABQQJrIAFBAU0bIgJBD0kNAEEEIQFBCCABIAJBD0cbIABqEIYwCwstAQF/IAAgAkEHcUECdGoiACgCACAAIAEgAmpBCGogA0EIaiAEIAUQ5iM2AgALRgEBfyAAKAKE6gFBA2tBAk8EQCAAKAK86QEPCyAAKAK86QEhAiAAKAKA6gEEfyACBUEBIAEgAiABIAJJGyIAIABBAU0bCwtBAQF/AkAgACgCBCIDIAFNBEAgASADayIBIAAoAhAiA08NASAAKAIMIAFqDwsgACgCACABag8LIAEgAyACEMMhAAupBAICfwF+AkAgAEUEQAJ/AkACQAJAAkACQAJAAn4gAwJ+AkAgAygCCCIAQTdNBEAgAEEvSw0BIAMpAwAhCiAAQR9LBEAgAyAAQSBzIgA2AgggAygCDCIJQQRqIQggCUF7Sw0JIAcgCEkNCiADIAg2AgwgAyADKAIQQQRrNgIQIAMgBiAJajUAAEIghiAKQiCIhCIKNwMACyAKIABBP3GtiAwDCyADIABBOHMiCTYCCCADKAIMIgBBCGohCCAAQXdLDQMgByAISQ0EIAMpAwAhCiADIABBB2o2AgwgAyADKAIQQQdrNgIQIAAgBmoiADUAAEIIhiAKQjiIhCAAMQAEQiiGhCAAMQAFQjCGhCAAMQAGQjiGhAwBCyADIABBMHMiCTYCCCADKAIMIgBBCGohCCAAQXdLDQQgByAISQ0FIAMpAwAhCiADIABBBmo2AgwgAyADKAIQQQZrNgIQIAAgBmoiADUAAEIQhiAKQjCIhCAAMQAEQjCGhCAAMQAFQjiGhAsiCjcDACAKIAlBP3GtiAshCkGkqfsAKAIAIAqncQwGCyAAIAhBqKr7ABCxOwALIAggB0GoqvsAELA7AAsgACAIQaiq+wAQsTsACyAIIAdBqKr7ABCwOwALIAkgCEGYqvsAELE7AAsgCCAHQZiq+wAQsDsACyIAIAJPDQEgBCABIABBAnRqIgAtAAI2AgAgBSAALwEANgIACw8LIAAgAkH8nvMAEMMhAAtCACMAQRBrIgAkACABIAJsIgFBwAAQ0TRFBEBBgPT8AEErIABBD2pB8PP8AEG49PwAENUeAAsgARDpESAAQRBqJAALTgEBfyMAQRBrIgIkACACIAAoAgAiAEEEajYCDCABQbSj/gBBCUG9o/4AQQsgAEGUo/4AQcij/gBBCSACQQxqQaSj/gAQjhggAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUECQQIQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEBQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQRQQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQACzsBAX8gAC0AACIAQQJrIgFB/wFxQSVPQv+PgIDgAyABrYinQQFxRXJFBEBBAQ8LIABBDWtB/wFxQQdJC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEQQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0oBAX8jAEEQayIBJAAgAUEIaiAAIAAoAgBBAUEQQSAQtxEgASgCCCIAQYGAgIB4RwRAIAAgASgCDEGQnf8AEP0vAAsgAUEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQQgQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC5kBAQV/IAAoAhhBCGooAhAhAiAAKAIkIgEEQCACIAFBCGooAhBqIQILIAAoAgQiASABIAAoAghBA3RqIgBHBEAgACABa0EDdiEAA0AgASgCACIEBH8gBCABQQRqKAIAIgUoAghBAWtBeHFqQQhqIAUoAlARBAAFQQALIQQgAUEIaiEBIAMgBGohAyAAQQFrIgANAAsLIAIgA2oLQgECf0EBIQMCQCABQf8BcSICQeMASw0AIAAgAkEKbiICQTByEIM2DQAgACABIAJBCmxrQTByQf8BcRCDNiEDCyADC0IAIAEoAigiAARAIAEoAiQhASAAQcwBbCEAIAMgBGohBANAIAEgAiADIAQQ2BsgAUHMAWohASAAQcwBayIADQALCwtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHIABC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSgEBfyMAQRBrIgMkACABIABrIAJqIgFBARDRNEUEQEGIhYgBQSsgA0EPakH4hIgBQeCHiAEQ1R4ACyAAIAFBARD4OiADQRBqJAALPgEBfyAALQAUIQEgAEEBOgAUAkAgAUUEQCAAQQhrIgAgACgCAEEBaiIBNgIAIAFFDQEQlA0gABD9HgsPCwALSAEBfyMAQRBrIgYkACABKAIAJQEgAiADIAQgBRAjIAZBCGoQzi0gBigCDCEBIAAgBigCCEEBcTYCACAAIAE2AgQgBkEQaiQAC0IBAX8gASgCBCICIAEoAghPBH9BAAUgASACQQFqNgIEIAEoAgAoAgAgAhDSNCEBQQELIQIgACABNgIEIAAgAjYCAAtKAQF/IwBBEGsiASQAIAFBCGogACAAKAIAQQFBBEEMELESIAEoAggiAEGBgICAeEcEQCAAIAEoAgxBuKTDABD9LwALIAFBEGokAAtMAQF/IAAQmh8gACgCECIBQYQBTwRAIAEQ8h8LIAAoAgQEQCAAKAIAIgFBhAFPBEAgARDyHwsgAEEEaiIAQQhqEKw7BEAgABC8KgsLC0MBAX8CQAJAAkAgAC0AKEEDaw4CAAIBCyAAQcQAahC8KiAAQThqIgEQ1isgARDoOyAAQSxqEOo7Cw8LIABBLGoQvCoLPwECfyMAQRBrIgEkACAAQQhrIgAgACgCACICQQFrNgIAIAEgADYCDCACQQFGBEAgAUEMahC4HwsgAUEQaiQACz8BAn8jAEEQayIBJAAgAEEIayIAIAAoAgAiAkEBazYCACABIAA2AgwgAkEBRgRAIAFBDGoQtx8LIAFBEGokAAs/AQJ/IwBBEGsiASQAIABBCGsiACAAKAIAIgJBAWs2AgAgASAANgIMIAJBAUYEQCABQQxqELYfCyABQRBqJAALOgECfyMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKALQAUECdEG8g8MAaigCACACEOwqIAFBEGokAAunAQEDfyMAQRBrIgYkACAGQQhqIQgjAEEQayIHJAACf0GBgICAeCAAKAIAQX8gBBsgAWsgAk8NABogB0EIaiAAIAEgAiADIAQQzBRBgYCAgHggBygCCCIAQYGAgIB4Rg0AGiAHKAIMIQQgAAshACAIIAQ2AgQgCCAANgIAIAdBEGokACAGKAIIIgBBgYCAgHhHBEAgACAGKAIMIAUQ/S8ACyAGQRBqJAALQQECfyMAQRBrIgEkACAAKAJIIgJBEk8EQCABIAApAgRCIIk3AgggASACNgIEIAFBBGpBBEEEEOAeCyABQRBqJAALRwEBfyMAQRBrIgUkACAFQQhqIAAgASACIAMgBBCxEiAFKAIIIgBBgYCAgHhHBEAgACAFKAIMQdywzAAQ/S8ACyAFQRBqJAALRwEBfyMAQRBrIgMkACADQQhqIAAgASACQQFBARC3ESADKAIIIgBBgYCAgHhHBEAgACADKAIMQZCxzAAQ/S8ACyADQRBqJAALMQAgACgCCEGAgICAeEcEQCAAQQhqEOM8IABBFGoQ6TsgAEEgahDjPCAAQSxqEIUwCwtHACABKAIARQRAQeinzgAQsjsACyAAIAEgAiABKAIwIgIgAyACIANJG0EBEKELIgI2AgQgAEEINgIAIAEgASgCMCACazYCMAtIAQF/AkAgACgCAEGAgICAeEYEQCAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQQRqEIMgDwsgABC+HyAAQQRBIBDgHgsLRwECfyAAKAIAQYCAgIB4RwRAIAAoAggiAgRAIAAoAgQhAQNAIAEQ2BMgAUHoA2ohASACQQFrIgINAAsLIABBCEHoAxDgHgsLRwAgAEEANgIoIABBADYCJCAAIAE2AhAgACABNgIIIAAgATYCACAAIAEgAmoiATYCBCAAIAFBQHE2AhggABCELCAAQQA2AiALRwAgACgCqAJBAUYEQCAAIAIpAgA3AuwSIABB9BJqIAJBCGooAgA2AgALIAAoAqwCQQFGBEAgACABKAIEIAEoAghrNgL8EgsLOgEBfyADIAEgACABIAAgAyABa2oiBSACIAIgBUsbEIAUIgVqRgR/IAAgBWogBCACEIAUIAVqBSAFCwtHAQF/IwBBEGsiBCQAIARBCGogACABIAIgA0EEELcRIAQoAggiAEGBgICAeEcEQCAAIAQoAgxBpNnzABD9LwALIARBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxB5MH7ABD9LwALIANBEGokAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELcRIAUoAggiAEGBgICAeEcEQCAAIAUoAgxBoKL+ABD9LwALIAVBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBjKX+ABD9LwALIANBEGokAAtFAQF/IABBDGoQvgwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgAEEEQQgQ4B4LPAAgACgCIEEESQRAQQAPCyAAKAIkBEBBAQ8LIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACzwAIAAoAiBBCEkEQEEADwsgACgCJARAQQEPCyAAKAI8IAAoAkAiACgCCEEBa0F4cWpBCGogACgCTBEEAAs8ACAAKAIgQQJJBEBBAA8LIAAoAiQEQEEBDwsgACgCPCAAKAJAIgAoAghBAWtBeHFqQQhqIAAoAkwRBAALRQEBfyAAQQxqEMMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIABBBEEIEOAeC0MBAn8jAEEgayICJAAgAkEMaiIDIAFBgOaFAUEMEMYsIAIgACkCBDcCGCADIAJBGGpBnOaFARDkFBDbGyACQSBqJAALRQEBfyAAQQxqEMUMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIABBBEEIEOAeC0kAAkAgAcAiASAAKAIISQRAIAAoAgQgAUEDdGoiACgCAEUNASAADwtB4IKGAUE4QZiDhgEQnykAC0Gog4YBQQ9BuIOGARDLJAALPwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACEBIAAoAhQiAAR/IAEgAEEIaigCEGoFIAELC0cBAX8jAEEQayIDJAAgA0EIaiAAIAEgAkEBQQEQtxEgAygCCCIAQYGAgIB4RwRAIAAgAygCDEGsv4YBEP0vAAsgA0EQaiQAC0cBAX8jAEEQayIFJAAgBUEIaiAAIAEgAiADIAQQtxEgBSgCCCIAQYGAgIB4RwRAIAAgBSgCDEHM54cBEP0vAAsgBUEQaiQACz8BAn8gASgCGAR/IAEQ+hshAiABIAEoAhhBAWs2AhggAkEMayEDIAJBGGsFQQALIQEgACADNgIEIAAgATYCAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELcRIAUoAggiAEGBgICAeEcEQCAAIAUoAgxB1IOIARD9LwALIAVBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBBEEEELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBkKKIARD9LwALIANBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBwMWIARD9LwALIANBEGokAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELESIAUoAggiAEGBgICAeEcEQCAAIAUoAgxBzKeJARD9LwALIAVBEGokAAs9AQN/IAAoAgAiAyACaiIEIANJIARBD0tyIgVFBEAgAgRAIAAgA2pBBGogASAC/AoAAAsgACAENgIACyAFCzoBAX8jAEEgayICJAAgAUEBQQFBACAAKQMAIAJBDGoiAUEUEO0QIgAgAWpBFCAAaxCBCSACQSBqJAALTAEBfwJAAkACQCAALQAIDgQAAgIBAgsgACgCACIAQYQBSQ0BIAAQ8h8PCyAAKAIEIgEgASgCAEEBayIBNgIAIAENACAAQQRqELIaCwtKAQF/IAEQxiEgASgCCCICRQRAQdCEwwBBHkHwhMMAEMskAAsgAEEENgIAIAEgAkEBayIANgIIIAEgASgCBCAAQQF0ai8BADsBJAs6AQF/IwBBEGsiASQAAn8gACgCAEUEQCABQQhqIABBBGoQ3DsgASgCDAwBCyAAKAIICyABQRBqJABFCzkBAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBBDxLSEAIAIQ+ypBACAAEJosQQhqIAFBEGokAAtJAQF/IwBBEGsiAiQAIAIgAEEEajYCDCABQdjJzABBCUHhycwAQQsgAEG4ycwAQezJzABBCSACQQxqQcjJzAAQjhggAkEQaiQACzgAIAMEQCABQRhqIQEgA0EMbCEDA0AgASACQQwQoTYgAkEMaiECIANBDGsiAw0ACwsgAEEINgIAC0oBAX8gARDTISABKAIIIgJFBEBBpMbOAEEeQcTHzgAQyyQACyAAQQQ2AgAgASACQQFrIgA2AgggASABKAIEIABBAXRqLwEAOwEkC0kBAX8jAEEQayICJAAgAiAAQQxqNgIMIAFB9PHOAEENQYHyzgBBBSAAQdTxzgBBhvLOAEEFIAJBDGpB5PHOABCOGCACQRBqJAALSQEBfyMAQRBrIgIkACACIABBBGo2AgwgAUHQoM8AQQlB2aDPAEELIABB2J/PAEHkoM8AQQkgAkEMakHAoM8AEI4YIAJBEGokAAtDAgF/AX4gAEE0aiABQTRqEN0gIABBKGogAUEoahDDBiABLwFAIQIgASkDICEDIAAgARCxLiAAIAM3AyAgACACOwFACzEBAX8gACgCBCICBEAgACgCACACQQFqIAFsQQdqQXhxIgBrIAAgAmpBCWpBCBD4OgsLSQEBfyMAQRBrIgIkACACIABBCGo2AgwgAUGQ6M8AQQ5BnujPAEEEIABB8OfPAEGi6M8AQQsgAkEMakGA6M8AEI4YIAJBEGokAAtJAQF/IwBBEGsiAiQAIAIgAEEEajYCDCABQdzv0ABBCUHl79AAQQsgAEG879AAQfDv0ABBCSACQQxqQczv0AAQjhggAkEQaiQACzUBAX8CfyABIAJPBEBBfyEBA0BBAiABQQFqIgEgAksNAhogAC8BACAAQQJqIQANAAsLQQELC+wBAQF/AkAgAQRAIAAgACgCuOkBIAEoAgQgASgCCGpHNgKg6wEgABDhGyAAIAEoAqjVATYCnOsBIAAgASgCBCICNgK06QEgACACNgKw6QEgACACIAEoAghqIgI2ArjpASAAIAI2AqzpAQJAIAEoAqzVAQRAIABCgYCAgBA3A4jqASAAIAEoAqjQATYCrNABIAAgASgCrNABNgKw0AEgACABQaTQAGo2AgwgACABQZQgajYCCCAAIAFBnDBqNgIEIAAgAUEMajYCACAAIAEoArDQATYCtNABDAELIABCADcDiOoBCwwBCyAAEOEbCwtfACAAQQA2AkggAEKBgICAwAA3AkAgAEIENwI4IABCATcCMCAAQoCAgIAQNwIoIABCgICAgMAANwIgIABCgICAgBA3AhggAEKBgICAwAA3AhAgAEIENwIIIABCATcCAAu0AwEBfyAAQQRqIQICQAJAAkACQCAAKAIAQQFrDgMBAgMACyMAQTBrIgAkACAAIAItAAxBAnQiAkHcsP4AaigCADYCDCAAIAJBwLD+AGooAgA2AgggAEEBNgIUIABB9Kr+ADYCECAAQgE3AhwgAEHHAjYCLCAAIABBKGo2AhggACAAQQhqNgIoIAEoAgAgASgCBCAAQRBqEMsKIABBMGokAA8LIwBBMGsiACQAIAAgAi0ADEECdCICQZSx/gBqKAIANgIMIAAgAkH4sP4AaigCADYCCCAAQQE2AhQgAEH0qv4ANgIQIABCATcCHCAAQccCNgIsIAAgAEEoajYCGCAAIABBCGo2AiggASgCACABKAIEIABBEGoQywogAEEwaiQADwsjAEEwayIAJAAgACACLQAMQQJ0IgJB3LH+AGooAgA2AgwgACACQbCx/gBqKAIANgIIIABBATYCFCAAQfSq/gA2AhAgAEIBNwIcIABBxwI2AiwgACAAQShqNgIYIAAgAEEIajYCKCABKAIAIAEoAgQgAEEQahDLCiAAQTBqJAAPCyAAKAIEIAEgACgCCCgCEBECAAs8AQN/IwBBMGsiAyQAIANBBGoiBCABIAIQ5QggA0EYaiIFIAEQmzYgAhDyEiAAIAQgBRDUGCADQTBqJAALPAEDfyMAQTBrIgMkACADQQRqIgQgASACEOQIIANBGGoiBSABEJs2IAIQ8xIgACAEIAUQ1BggA0EwaiQACz0BAX8gACACIAFrIgJBA3YiAxDsLSACBEAgACgCBCAAKAIIQQN0aiABIAL8CgAACyAAIAAoAgggA2o2AggLTQEBfyAAIAEoAgw2AhggACABKAIAIgI2AhAgACACQQhqNgIIIAAgAiABKAIEakEBajYCDCAAIAIpAwBCf4VCgIGChIiQoMCAf4M3AwALRwEBfyAAIAAoAggiAUECcjYCCAJAIAENACAAKAIAIQEgAEEANgIAIAAgACgCCEF9cTYCCCABRQ0AIAAoAgQgASgCBBEDAAsLRQEBfyMAQSBrIgMkACADIAI2AhwgAyABNgIYIAMgAjYCFCADQQhqIANBFGpBiK+IARCQISAAIAMpAwg3AwAgA0EgaiQAC0MBAX9BFEEEEK02IgNFBEBBBEEUEKM9AAsgAyACNgIQIAMgATYCDCADIAApAgA3AgAgA0EIaiAAQQhqKAIANgIAIAMLOwEBfyMAQSBrIgIkACACQQhqIAAoAgAgAkEWahCwECABQQFBAUEAIAIoAgggAigCDBCBCSACQSBqJAALSQICfwF8IAEoAggiA0GAgIABcSECIAArAwAhBCADQYCAgIABcUUEQCABIAQgAkEAR0EAEP0IDwsgASAEIAJBAEcgAS8BDhDnBws6AQF/IAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQgyALIAAQoycgABDpOyAAQQxqEOk7Cz8BAX8gAEEgaiIBEJ8sIAEQ8zsgAEEsahCOMCAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEIYfCwtBAQF/IwBBEGsiAyQAIAMgAjYCDCADIAE2AgggA0EANgIEIANBBGoQ1ikhASAAQQA2AgQgACABNgIAIANBEGokAAtOAgF/AW8jAEEQayIDJAAgAyABNgIMIAMgADYCCCADQQA2AgQgA0EEahDWKUEIaiACJQEgAhDyHxADIQQQ3xIiACAEJgEgA0EQaiQAIAALQQEBfyAAQQxqEJMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLMQAgABDpOyAAQQxqEOk7IABBMGogACgCKCAAKAIsIAAoAiQoAhARAQAgAEEYahDeOwtBAQF/IABBDGoQlQwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgABDqOwtJAQF/IwBBIGsiASQAIAFBAjYCBCABQdiuzgA2AgAgAUIBNwIMIAFBrgM2AhwgASAANgIYIAEgAUEYajYCCCABQeiuzgAQ7ywAC0ABAX8gACgCCCIBBEAgACgCBCEAA0AgACgCAEGAgICAeEcEQCAAQQRBIBDgHgsgAEEMaiEAIAFBAWsiAQ0ACwsLQQEBfyAAQQxqEJ8MAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQgEBfyABENApIQIgACgCKCIBIAAoAiBGBEAgAEEgakGo39AAEJ0oCyAAKAIkIAFBAnRqIAI2AgAgACABQQFqNgIoCzsBAX8gACgCACIAQRBqEOwmAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQcAAQQgQ+DoLC00BAX8CQCACRQ0AIAEgACgCrOkBIgJGDQAgACACNgK46QEgACABNgKs6QEgACgCsOkBIQMgACABNgKw6QEgACABIAMgAmtqNgK06QELCz8BAX9BASABLQAAdCICQfifAXFFBEAgAkGD4ABxBEAgAEEoIAEQtywPCyAAIAEpAgQ3AgAPCyAAQRUgARC3LAtCACABELAaIgFBD00EQCAAIAFBAXQiAUGE89EAai8BADsBAiAAIAFB9PPRAGovAQA7AQAPCyABQRBBlPXRABDDIQALQQEBfyAAQQxqEKMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqEKcMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLOAEBfyAAIAEQhC4gACgCCCEDIAAgAQR/IAEEQCAAKAIEIANqIAIgAfwLAAsgASADagUgAws2AggLQQEBfyAAQQxqELQMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELYMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELcMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELkMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQwECfyMAQdAAayICJAAgAkEMaiIDIAFBABCvASACIAMQoAEgAigCBCEBIAAgAigCADYCACAAIAE2AgQgAkHQAGokAAs6ACAAKAIgRQRAQQAPCyAAKAIkBEBBAQ8LIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACzwBAX8gAUEIaiIDEMUnIANBBEEMEOAeIAFBEGogAkEIaigCADYCACABIAIpAgA3AgggACABQdwA/AoAAAtKAQF/IwBBEGsiASQAQQBBwAAQ0TRFBEBB5vSHAUEpIAFBD2pBoPSHAUGQ9YcBENUeAAsgAELAADcCACAAQsAANwIIIAFBEGokAAvVAgEIfyAAKAIAIgRBDGoiBiEAIwBBEGsiAyQAAkAgACgCDCIBRQRAIAAoAgQhACADQQA2AgwgAyAANgIIDAELIAAoAgAhAiAAKAIIIQUgAyAAKAIEIgc2AgggAyABIAIgBSACQQAgAiAFTRtrIgBrIgVrIghBACABIAhPGzYCDCACIAAgAWogASAFSxsiASAARg0AIAEgAGshASAHIABBAnRqIQADQCAAKAIAIgIgAigCAEEBayICNgIAIAJFBEAgABCqKwsgAEEEaiEAIAFBAWsiAQ0ACwsgA0EIaiIAKAIEIgEEQCAAKAIAIQADQCAAKAIAIgIgAigCAEEBayICNgIAIAJFBEAgABCqKwsgAEEEaiEAIAFBAWsiAQ0ACwsgA0EQaiQAIAZBBEEEEOAeAkAgBEF/Rg0AIAQgBCgCBEEBayIANgIEIAANACAEQSBBBBD4OgsLPQECfyMAQRBrIgEkACAAQQhrIgAgACgCAEEBayICNgIAIAEgADYCDCACRQRAIAFBDGoQqisLIAFBEGokAAtCAQF/IwBBEGsiAyQAIAEoAgAlASACEBYgA0EIahDOLSADKAIMIQEgACADKAIIQQFxNgIAIAAgATYCBCADQRBqJAALQgEBfyMAQRBrIgMkACADQQhqIAEgASgCCBDqDCACIAMoAgggAygCDBD7KCEBIABBAjYCACAAIAE2AgQgA0EQaiQAC0IBAX8jAEEQayIDJAAgA0EIaiABIAEoAggQ6gwgAiADKAIIIAMoAgwQ+yghASAAQQE7AQAgACABNgIEIANBEGokAAtCAQF/IwBBEGsiAyQAIANBCGogASABKAIIEOoMIAIgAygCCCADKAIMEPsoIQEgAEEBOgAAIAAgATYCBCADQRBqJAALRgECfyABKAIEIQIgASgCACEDQQhBBBCtNiIBRQRAQQRBCBCjPQALIAEgAjYCBCABIAM2AgAgAEHstYkBNgIEIAAgATYCAAtCAQF/IwBBIGsiAyQAIANBADYCECADQQE2AgQgA0IENwIIIAMgATYCHCADIAA2AhggAyADQRhqNgIAIAMgAhDvLAALNAAgAEHgAGoQ3jsgAEHsAGoQhzAgAEFAaxD4JiAAKAJ4QYCAgIB4RwRAIABB+ABqEOo7Cws1ACAAKAIAIgAoAkwEQCAAQcwAahC8KgsgACgCAEECRwRAIABBEGoQ3jsLIABB1ABBBBD4OgtEAAJAAkACQCAALQAoQQNrDgIAAgELIABBMGoQvCoLDwsgAEFAaxC8KiAAQdQAaiAAKAJMIAAoAlAgACgCSCgCEBEBAAtDAAJAAkACQCAALQAQQQNrDgIAAgELIABBFGoQvCoLDwsgAEEsahC8KiAAQUBrIAAoAjggACgCPCAAKAI0KAIQEQEACzwBAX8gABC8LiAAKAJIIgFBhAFPBEAgARDyHwsgAEHUAGoQvSggACgCUCIAQRBqEN47IABByABBBBD4Ogs6AQF/IAEoAgAiAiABKAIERgR/QQAFIAEgAkECajYCACACLwAAIQJBAQshASAAIAI7AQIgACABOwEACzIBAX8gACgCSCIBQRJJBH8gAEHIAGoFIAAoAgQhASAAQQRqCyEAIAEEQCAAQQA2AgALC0IBAX8gACgCACIAKAIMIgEQiDUgAUEwQQgQ+DoCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBEEEEEPg6CwtFAQF/IAEoAggiAkUEQEG4ss4AQR5B2LLOABDLJAALIABBBDYCACABIAJBAWsiADYCCCABIAEoAgQgAEEBdGovAQA7ARQLOQEBfyMAQUBqIgMkACADIAEgAiAALQBNEJMVIAAQkiogACADQcAA/AoAACAAQgA3AkQgA0FAayQAC0UBAX8gASgCCCICRQRAQaTGzgBBHkHExs4AEMskAAsgAEEENgIAIAEgAkEBayIANgIIIAEgASgCBCAAQQF0ai8BADsBEAs7AQF/IwBBEGsiAiQAIAEQ0yEgAkEAEIscOgAPIAEoAiAgAkEPaiACQRBqIgEQvSYgAEEENgIAIAEkAAs4AgF+AX8CQCAAKQMAIgFCCFENACABpyICQQZJDQAgAkEHRgRAIABBCGoQpyUPCyAAQQhqEKclCwtBAQF/IwBBEGsiAiQAIAJBCGogASgCDCABKAIQKAIgEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCDCABKAIQKAIkEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCGCABKAIcKAIgEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCGCABKAIcKAIkEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtAAQF/IwBBEGsiAiQAIAIgACgCACIAQQxqNgIMIAFBxOfPAEEJIABBpOfPACACQQxqQbTnzwAQgw8gAkEQaiQACzoBAX8gASAAKAIEayIBIAAoAhwiAkGACGpLBEAgACABQYAEIAEgAmtBgAhrIgAgAEGABE8bazYCHAsLPwIBfwF+IwBBEGsiAiQAIAIgATYCDELJz9my8eW66icgAkEMakEEEN4TIAAoAgQhACACQRBqJACnIABBAWtxCzkAIAAgACgCAEEHaiIAQXhxNgIAIAIgAEEDdiIASwRAIAAgAWpBADoAAA8LIAAgAkHM7NEAEMMhAAs+ACABQZ8ETQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgBFBAWo2AoARDwsgAUGgBEGsm9YAEMMhAAs+ACABQf8BTQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgAhBAWo2AoAIDwsgAUGAAkGsm9YAEMMhAAs+ACABQb8FTQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgBZBAWo2AoAWDwsgAUHABUGsm9YAEMMhAAs+AQF/IwBBIGsiASQAIAFBFGoiAyACQcSo+wAQzhggAUEIaiADQdSo+wAQkCEgACABKQMINwMAIAFBIGokAAs5AQF/IwBBIGsiASQAIAFBFGoiAyACELAVIAFBCGogA0HUqPsAEJghIAAgASkDCDcDACABQSBqJAALPQEBfyACQRBqIQMCQCACQW9NBEAgASADSQ0BIAAgAmoPCyACIANB7P7+ABCxOwALIAMgAUHs/v4AELA7AAtDAQF/IAAgASgCKCgCAEGTgICAeEYEfyABKAIAIgIQ1DoaIAEoAhwhASACENQ6IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIoKAIAQZOAgIB4RgR/IAEoAgAiAhC+PBogASgCHCEBIAIQvjwgAWsFIAILNgIIIABCgICAgBA3AgALQwEBfyAAIAEoAiQoAgBBk4CAgHhGBH8gASgCACICENM6GiABKAIcIQEgAhDTOiABawUgAgs2AgggAEKAgICAEDcCAAtDAQF/IAAgASgCJCgCAEGTgICAeEYEfyABKAIAIgIQ1DoaIAEoAhwhASACENQ6IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIoKAIAQZOAgIB4RgR/IAEoAgAiAhDTOhogASgCHCEBIAIQ0zogAWsFIAILNgIIIABCgICAgBA3AgALQwEBfyAAIAEoAiwoAgBBk4CAgHhGBH8gASgCACICENQ6GiABKAIcIQEgAhDUOiABawUgAgs2AgggAEKAgICAEDcCAAtDAQF/IAAgASgCKCgCAEGTgICAeEYEfyABKAIAIgIQwDwaIAEoAhwhASACEMA8IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIsKAIAQZOAgIB4RgR/IAEoAgAiAhDTOhogASgCHCEBIAIQ0zogAWsFIAILNgIIIABCgICAgBA3AgALOgEBfyABKAIAIgIgASgCBEYEf0EABSABIAJBBGo2AgAgAigCACECQQELIQEgACACNgIEIAAgATYCAAs7AQF/AkAgAUH/AXEiAUEJSw0AIAAgAUECdCIBQaSOhQFqKAIASA0AIAAgAUH8jYUBaigCAEwhAgsgAgs7AQF/AkAgAUH/AXEiAUESSw0AIAAgAUEDdCIBQbCRhQFqKQMAUw0AIAAgAUGYkIUBaikDAFchAgsgAgs6AQF/IAAoAgQgASgCBCAAKAIIIgAgASgCCCIBIAAgAUkbEJknIgIgACABayACGyIAQQBKIABBAEhrC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYCBCAAQYCIiAE2AgALQAEBfyABKAIAIgEgASgCECIEQQFqNgIQIARBAEgEQAALIAAgATYCDCAAIAM2AgggACACNgIEIABB3IiIATYCAAs8AQF/QQxBBBCtNiIERQRAQQRBDBCjPQALIAQgAToACCAEIAM2AgQgBCACNgIAIAAgBK1CIIZCA4Q3AgALRwEBfwJAAkACQCAALQDcAg4EAAICAQILIAAoAtgCIgFBhAFPBEAgARDyHwsgACkDAEICUQ0BIAAQoCkPCyAAQZgBahDVHwsLgwEBAn8gACgCHCIBBEAgACgCGCABQQJ0QQIQ+DoLIABBIGoiARDfHiABENU7IABBLGoiAiIAKAIIIgEEQCAAKAIEQRxqIQADQCAAIABBCGsoAgAgAEEEaygCACAAQQxrKAIAKAIQEQEAIABBJGohACABQQFrIgENAAsLIAJBBEEkEOAeCzQBAX9BMEEEEK02IgIEQCACIAFBMPwKAAAgAEHM3cIANgIEIAAgAjYCAA8LQQRBMBCjPQALNwEBf0HQAEEIEK02IgIEQCACIAFB0AD8CgAAIABBuPjCADYCBCAAIAI2AgAPC0EIQdAAEKM9AAs0AQF/QThBBBCtNiICBEAgAiABQTj8CgAAIABB6PjCADYCBCAAIAI2AgAPC0EEQTgQoz0ACzcBAX9BwABBCBCtNiICBEAgAiABQcAA/AoAACAAQfj4wgA2AgQgACACNgIADwtBCEHAABCjPQALNgEBf0HQAEEIEK02IgEEQCABQoGAgIAQNwMAIAFBCGogAEHIAPwKAAAgAQ8LQQhB0AAQoz0ACzYBAX9BqAFBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIABBoAH8CgAAIAEPC0EIQagBEKM9AAs2AQF/QdACQQgQrTYiAQRAIAFCgYCAgBA3AwAgAUEIaiAAQcgC/AoAACABDwtBCEHQAhCjPQALOQECfyMAQRBrIgEkAAJAIAAtAAwNACABQQhqIgIgABCdGSABLQAIQQRGDQAgAhC5LgsgAUEQaiQACzkBAn8jAEEQayIBJAACQCAALQAMDQAgAUEIaiICIAAQwxkgAS0ACEEERg0AIAIQuS4LIAFBEGokAAtDAQF/QdQAQQQQrTYiAUUEQEEEQdQAEKM9AAsgAUHkssMANgJQIAFBATYCTCABIAA7AUogAUEAOwFIIAFBAjYCACABC0ABAX9BFEEEEK02IgFFBEBBBEEUEKM9AAsgAUKBgICAEDcCACABIAApAgA3AgggAUEQaiAAQQhqKAIANgIAIAELPQECfwJAIAAoAgAiAkUNACAAKAIEIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBRQ0AIAIgASAAKAIIEPg6CwtAAQF/QdQAQQQQrTYiBEUEQEEEQdQAEKM9AAsgBCADNgJQIAQgAjYCTCAEIAE7AUogBCAAOwFIIARBAjYCACAEC0cAIABBAjoARiAAQcgBOwFEIABBADsBOCAAQgQ3AzAgAEIANwMoIABCgICAgMAANwMgIABCAjcDGCAAQgA3AwAgAEEANgJAC0gBAn8jAEEQayICJAAgACgCCARAIAJBBGoiASAAKAIENgIIIAEgACgCADYCBCABIAAoAgg2AgAgAUEBQQIQ4B4LIAJBEGokAAveAQEDfyAAKAIAIgJBgICAeE8EQCAAAn8CQCACQf///wdxIgIiAEH/H0H//wMgAS0ALBtLBEAgAEGAgMQASQ0BIAEoAhRBAWsMAgsgAEEGdiIDIAEoAghJBEAgASgCBCADQQF0ai8AACAAQT9xagwCCyABKAIUQQFrDAELIAEoAhwgAEsEQCABIAAQwQ8MAQsgASgCFEECawsiACABKAIUIgRJBH8gASgCECAAQQJ0aigAAAUgAwsgASgCACAAIARJGyIAQRh0QQAgAEGA/P//A3FBgLADRhsgAnI2AgALCzMBAX9BOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEEw/AoAACABDwtBBEE4EKM9AAspACAAKAIAIgBBCGoQ3jsgAEEgahDeOyAAQUBrEOM8IABB4ABBCBD4Ogs7AQJ/IAEoAhQiAiABKAIIIgNJBEAgASgCDCACIAEoAgQiAmogAiADahC9JiABIAM2AhQLIABBBDoAAAs8ACAAKALQASAAKALIASAAKAKAASAAKAJoIAAoAgggACgCIGpqamogACgCoAEgACgCQGpBA3RqakGwAmoLNQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEN47IABBDGoQhjAgAEEYaiEAIAFBAWsiAQ0ACwsLOQEBfyAAKAIIIgEEQCAAKAIEQTxqIQADQCAAQQxrEIUwIAAQhTAgAEHIAGohACABQQFrIgENAAsLCzgBAX8gACgCCCIBBEAgACgCBEEcaiEAA0AgAEEMaxCFMCAAEIUwIABBMGohACABQQFrIgENAAsLCzgBAX8gACgCCCIBBEAgACgCBEEsaiEAA0AgAEEMaxCFMCAAEIUwIABBOGohACABQQFrIgENAAsLCzkBAX8gACgCCCIBBEAgACgCBCEAA0AgAEEIQRgQ4B4gAEEMahCFMCAAQRhqIQAgAUEBayIBDQALCwszAQF/QTxBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIABBNPwKAAAgAQ8LQQRBPBCjPQALNQEBf0HAAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEE4/AoAACABDwtBBEHAABCjPQALOAACQCAAQf/9g3hNBEAgAEEIdiAAakGAgAggAGtBC3ZBACAAQYCACEkbaiIADQELQbh/IQALIAALXQEBf0GAgAQhAQJAAkACQAJAAkACQAJAIAAtAABBAWsOCAAAAAYCAwQFAQsAC0HAy9EAQShB6MvRABCfKQALQYCAEA8LQYCAwAAPC0GAgIACDwtBgICABCEBCyABCzkBAn8gACgCBCIBRQRAQQAPCyABQQFrIQIgAUELTwRAIAJBCkHktf4AEMMhAAsgACACaiwACEEATgtBAQJ/IAAoAhwiAUUEQEHk3v4AELI7AAsgACgCECAAKAIUIAAoAhgiAhC6KRogACABQQFrNgIcIAAgAkEQajYCGAs2AQF/QdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQcgA/AoAACABDwtBBEHQABCjPQALNQEBf0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEE8/AoAACABDwtBBEHEABCjPQALRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ7x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8h4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ9x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ9x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ7x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8h4gAEHkAGpBgAhBgAgQpRQLMwEBf0EwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQSj8CgAAIAEPC0EEQTAQoz0ACzMBAX9BNEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEEs/AoAACABDwtBBEE0EKM9AAs2AQF/QewAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQeQA/AoAACABDwtBBEHsABCjPQALOAEBfyAAIAIQ7S0gAkEBdCIDBEAgACgCBCAAKAIIQQF0aiABIAP8CgAACyAAIAAoAgggAmo2AggLPQEBfyMAQRBrIgQkACAEQQhqIAEoAgAgAiADEMslIAQoAgwhASAAIAQoAgg2AgAgACABNgIEIARBEGokAAs9AQF/IAEoAgAiASgCICECIABBBGogAUEkakEAIAEoAiQbEO4lIAAgAkEEdjYCICAAQQA2AhwgACABNgIACzYBAX8gACgCBCIBIAEgACgCCEEDdGoQ+yJBNGohASAAKAIcIgAEfyABIABBCGooAhBqBSABCwunAgIHfwFvIwBBEGsiAyQAIANBCGohByMAQRBrIgQkAAJAIAFBBGoiBS0AAARAQQIhAgwBCyMAQRBrIgYkACABKAIAJQEQSiEJEN8SIgEgCSYBIAEhAiAGQQhqEM4tQQEhASAEQQhqIggCfyAGKAIIQQFxBEAgBigCDAwBC0EAIQEgAgs2AgQgCCABNgIAIAZBEGokAEEBIQIgBCgCDCEBIAQoAghBAXEEQCAFQQE6AAAMAQsCfyABJQEQQEUEQCABJQEQQSEJEN8SIgUgCSYBQQAMAQsgBUEBOgAAQQILIQIgAUGEAU8EQCABEPIfCyAFIQELIAcgATYCBCAHIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAu+AgEEf0EBIQQCQAJ/IAEoAgAhASMAQSBrIgIkAAJAAkACQCABKAIAQQJHDQAgASgCCCEDIAFBADYCCCADRQ0BIAIgAxEDACACKAIEIQUgAigCACEDIAEoAgBBAkYEQCABIAU2AgQgASADNgIADAELIAIgBTYCDCACIAM2AgggA0ECRw0CCyACQSBqJAAgAQwCCyACQQA2AhggAkEBNgIMIAJBoKyIATYCCCACQgQ3AhAgAkEIakGorIgBEO8sAAsCQCACQQhqIgAoAgAiAUECRiABRXINACAAKAIEIgFBhAFJDQAgARDyHwsgAkEANgIYIAJBATYCDCACQcisiAE2AgggAkIENwIQIABB0KyIARDvLAALIgEoAgBBAUcEQEEAIQQMAQsgASgCBBD0OiEBCyAAIAE2AgQgACAENgIACz8BAn8gASgCACIDKAIIIgIgASgCBCIBSQRAIAEgAkHAq4kBEK87AAsgACACIAFrNgIEIAAgAygCBCABajYCAAs7AQF/IAAtACRBA0YEQAJAIAAtACANACAAKAIURQ0AIAAoAhgiAUGEAUkNACABEPIfCyAAQQhqEOQqCwtDAAJAAkACQAJAIAAtADwOBAADAwEDCyAAKAI4IgBBgwFNDQIMAQsgAEEYahDfICAAKAIIIgBBgwFNDQELIAAQ8h8LCzcAIAAoAiBBgICAgHhHBEAgAEEgahDpOwsgACgCLEGAgICAeEcEQCAAQSxqIgAQ0SsgABDoOwsLPAACQAJAAkAgAC0ANA4EAAICAQILIAAQ7TsPCyAAQSxqELwqIABBHGoQvSsgAEEQaiIAENQnIAAQ7jsLCy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCgCWCACEOgqIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQoAiggAhDqKiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIMIAIQ+CogAUEQaiQAC0MAAkACQAJAAkAgAC0AGA4EAAMDAQMLIAAoAgQiAEGDAU0NAgwBCyAAKAIMRQ0BIAAoAhAiAEGDAU0NAQsgABDyHwsLNgACQCABIAJNBEAgAiADTQ0BIAIgAyAEELA7AAsgASACIAQQsTsACyAAIAI2AgQgACABNgIACz8BAX8gACgCACEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDBGA8LIAAgARC1HA8LIAAgARC2HAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAhAgAhD7KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIIIAIQ+yogAUEQaiQACy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBBCuNCACEPsqIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAgggAhD8KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIMIAIQ/CogAUEQaiQACy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBCgCACACEP4qIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAgQgAhD+KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIIIAIQgCsgAUEQaiQACzkBAX8gACgCECIBBEAgAEEcaiAAKAIUIAAoAhggASgCEBEBAAsgACgCMCIABEAgAEGAIEEEEPg6Cws5AQF+IAApAwAiAUIDUgRAIAFCAlEEQCAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKgsLOQEBfiAAKQMAIgFCBVIEQCABQgRRBEAgAEEUaiAAKAIMIAAoAhAgACgCCCgCEBEBAA8LIAAQkioLC1EBAX9BDCEBAkACQAJAAkACQCAAKAIAQQFrDgoEBAQEAQEBAgEDAAtB5M3OAEEMQfDNzgAQ7SwAC0EUIQEMAgtBMCEBDAELQRwhAQsgACABags5AQF+IAApAwAiAUIFUgRAIAFCBFEEQCAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABClIQsLNwAgASACOgBwIAAgAUHxAPwKAAAgACACOgBxIABB9gBqIAFB9gBqLwEAOwEAIAAgASgBcjYBcgs2ACABQYACakEBQQEQ4B4gAUGIAmogAkEIaigCADYCACABIAIpAgA3AoACIAAgAUHAAvwKAAALNgEBfyAAKAIEIgEEQCAAKAIAIAFBAnRBBBD4OgsgACgCDCIBBEAgACgCCCABQQJ0QQQQ+DoLCzYBAX8gACgCBCIBBEAgACgCACABQQJ0QQQQ+DoLIAAoAgwiAQRAIAAoAgggAUECdEECEPg6Cws/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ/CgPCyAAIAEQ0xwPCyAAIAEQ0hwLPwEBfyAAKAIAIQAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEJwSDwsgACABELccDwsgACABELQcCz8BAX8gACgCACEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDMJA8LIAAgARDTHA8LIAAgARDSHAs4ACAAIAAoAgAgAyAEEN0HNgIAIAIgBE8EQCAEBEAgASADIAT8CgAACw8LIAQgAkGQ6fwAELA7AAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ4ygPCyAAIAEQuRwPCyAAIAEQuBwLPwEBfyAAKAIAIQAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEL8QDwsgACABELccDwsgACABELQcCzwAIAEtAABBDUYEQCAAIAEoAgg2AgQgACABKAIEIgBBCGpBACAAGzYCAA8LQZCJ/wBBKEG4if8AEJ8pAAs+AQF/IAAgASgCJCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs+AQF/IAAgASgCKCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs+AQF/IAAgASgCLCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEKYZIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEKcZIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEI8sIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACENorIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEP8WIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEIAXIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEPIWIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEPEWIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs5AQF/IwBBEGsiAiQAIAJBCGogAUEYahDcOyACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALOwEBfyMAQRBrIgMkACADQQhqIAEoAgAgAhCsHyADKAIMIQEgACADKAIINgIAIAAgATYCBCADQRBqJAALjQQBCX9BASEIAkAgASgCAEGM4oUBQQsgASgCBCgCDBEGAA0AIwBBQGoiAiQAAkACQCAAKAJIQQJ2IgZBAWsiBEUNAEEKIAQgBEEKTxshBQJAA0ACQCAAIAMQkyVFBEBBASEHIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQxqIgkgACADEPoiIAkgARDpCyAJENIoDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBSADQQFqIgNHDQALIARBC0kNASAEQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIEIAIgBkEVazYCCCACIAI2AhQgAiACQQhqNgIAIAEoAgAgASgCBCACQQxqEMsKDQELIAZBC2siAyAFIAMgBUsbIgMgBE8NAQNAAkAgACADEJMlRQRAQQEhByABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEMaiIFIAAgAxD6IiAFIAEQ6QsgBRDSKA0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAERw0ACwwBC0EBIQcMAQtBACEHCyACQUBrJAAgBw0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCAsgCAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQniUPCyAAIAEQuRwPCyAAIAEQuBwLgAQBBn9BASEHAkAgASgCAEG07oUBQQ8gASgCBCgCDBEGAA0AIwBBMGsiAiQAAkACQCAAKAIQIgRFDQBBCiAEIARBCk8bIQYCQANAAkAgACADEJUlRQRAQQEhBSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAiAAIAMQhBo6AAwgAkEMaiABEJovDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBiADQQFqIgNHDQALIARBC0kNASAEQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBEEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIARBCmsiAyAGIAMgBksbIgMgBE8NAQNAAkAgACADEJUlRQRAQQEhBSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAiAAIAMQhBo6AAwgAkEMaiABEJovDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIARHDQALDAELQQEhBQwBC0EAIQULIAJBMGokACAFDQAgASgCAEHD7oUBQQEgASgCBCgCDBEGACEHCyAHCzUBAX8gACgCDEEIaigCECAAKAIYQQhqKAIQaiEBIAAoAiQiAAR/IAEgAEEIaigCEGoFIAELCzkBAX8gACgCKCICBEAgACgCJCEAIAJBzAFsIQIDQCAAIAEQhxcgAEHMAWohACACQcwBayICDQALCws7AQF/IwBBEGsiAiQAIAIgADYCDCABQajWhwFBCCAAQQxqQYjWhwEgAkEMakGY1ocBEIMPIAJBEGokAAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQxRUPCyAAIAEQtRwPCyAAIAEQthwLoAcCBH8DfiACQQdxRQRAIAAgASACQQN2IANBA3YgA0EHcUEAR2oQ5hUPCyAAIQcjAEFAaiIEJABBwAAhBQJAAkACQAJAAkAgA0EDdiIGIANBB3FBAEdqIgBBwP///wNxQUBrIAAgAEE/cRsiAEHAABDRNARAIAAEQCAAQcAAEK02IgVFDQILIAZB+P///wFxIgYgAEsNAiAGBEAgBUEAIAb8CwALIAQgBjYCICAEIAU2AhwgBCAANgIYIARBwAA2AhQgBEEkaiABKAIEIAEoAgggAiADEIcdQQAhAgJ/IARBFGoiASgCDCIAIAEoAggiA0EHakF4cSADayIBSQRAQQAhBUEIDAELIAAgAWsiAEEHcSEFIABBA3YhAiABIgAgA2oLIQEgACAFcgRAQfz1hwFBOEG09ocBEJ8pAAsgBEEIaiIAIAI2AgQgACABNgIAAkAgBCgCDCICRQ0AIAQoAiQhASAEKAIIIQAgAkEDdCEFIAQoAjBBAWohAiAEKAIsIgNBP3GtIQlBACADa0E/ca0hCgNAIAJBAWsiAkUNASABKQAAIQggAwRAIAFBCGoxAAAgCoYgCCAJiIQhCAsgAUEIaiEBIAAgCDcDACAAQQhqIQAgBUEIayIFDQALCyAEKAI0IgVBA3YgBUEHcUEAR2ohAyAEIAUEfiAEKAIkIAQoAjBBA3RqIgYxAAAgBCgCLCIAQT9xrYghCCAAIAVqIgFBA3YgAUEHcUEAR2oiAkECTwRAQQggAGshASACQQFrIQIgBkEBaiEAA0AgADEAACABQT9xrYYgCIQhCCAAQQFqIQAgAUEIaiEBIAJBAWsiAg0ACwsgCEJ/IAVBP3GthkJ/hYMFQgALNwM4IANBCU8NAyAEKAIgIgEgA2oiAiAEKAIYIgBLBEAgBEEUaiAAQQF0IgAgAhDhKiIBIAAgAUsbEOgZIAQoAiAiASADaiECIAQoAhghAAsgBCgCHCEFIAMEQCABIAVqIARBOGogA/wKAAALIAQoAhQhA0EcQQQQrTYiAUUNBCABIAA2AhggASADNgIUIAFBADYCECABIAI2AgwgASAFNgIIIAFCgYCAgBA3AgAgByACNgIIIAcgBTYCBCAHIAE2AgAgBEFAayQADAULQfP6hwFBKSAEQSRqQdj6hwFBnPuHARDVHgALQcAAIAAQoz0AC0Gw9YcBQStB3PWHARCfKQALIANBCEGI/IcBELA7AAtBBEEcEKM9AAsLMgEBfyAAIAEoAgAiAiABKAIERgR+QgAFIAEgAkEIajYCACAAIAIpAwA3AwhCAQs3AwALKAACQCABRSAAIAEQ0TRFcg0AIAAEQCAAIAEQrTYiAUUNAQsgAQ8LAAsxAQJ/IAAtAABFBEBBAA8LIABBAWohAUEAIQADQCAAIAFqIABBAWohAC0AAA0ACyAACy8AIAAoAgAEQCAAEJEgCyAAKAIQBEAgAEEQahChLAsgACgCIARAIABBIGoQoSwLCzcBAX8gACgCCCIBBEAgACgCBCEAA0AgABDXHiAAQQRBzAAQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsLNgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOUnIABBBEEYEOAeIABBDGohACABQQFrIgENAAsLCzcBAn8gACgCACECIAAoAgQiACgCACIBBEAgAiABEQMACyAAKAIEIgEEQCACIAEgACgCCBD4OgsLMAEBfyAAQQhqEN47IAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQnScLCzcBAX8CQCAAKAIARQ0AIAAoAggiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEIahDyJQsLNwEBfwJAIAAoAgBFDQAgACgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCwuZHQIhfwF+IwBBEGsiGSQAIBlBCGohGyMAQSBrIg8kACABIgdBtAFqIRwgAUGwAWohDCAPQRRqIR0gASgCsAFFIRoCQAJAA0ACQAJAIBpBAXFFBEBBACEGIwBBIGsiASQAAkACQCAMKAIEIgQgDCgCDEYNACAMIARBFGo2AgRBAyEFAkAgBCgCACIDQYCAgIB4aw4CAQIACyABQRhqIARBDGopAgA3AgAgASADNgIMIAEgBCkCBDcCECABQQxqENgkIQZBACEFDAELQQIhBQsgDyAGNgIEIA8gBTYCACABQSBqJAAgDygCACIBQQJHBEAgAUEDRg0GIA8oAgQhDAwGCyAMKAIABEAgDBDlIAsgDEEANgIADAELIA9BDGohFEEAIR4jAEEgayILJAAgC0EIaiEYIwBBkANrIgokACAHQZABaiEIIAdBgAFqIQ4DQAJAIAcoAqgBIAcoApQBIgEEfyAIKAIAKAIIQQhqIQQDQCABKALAASAERg0ACyABKALIAQVBAAsgBygCpAFqTQ0AIwBB8AJrIg0kAAJAIActAHhFBEAgDUG4AWohECMAQZAEayIDJAACQAJAAkACQAJAAkAgBygCbCIBIAcoAnRGBEBCAyEkDAELIAcgAUEEajYCbCABKAIAIRUgAwJ+IAcoAgBBAUYEQCADQegCaiAHQRBqEN0gIAcoAhwiASABKAIAIgRBAWo2AgAgBEEASA0DIANBIGogA0HwAmooAgA2AgAgAyADKQLoAjcDGCADIAE2AiQgAyAHKQMINwMQQgEMAQsgAyAHKAIQEPQ6NgIYIAMgBykDGDcDICADIAcpAwg3AxBCAAs3AwggBygCWCIEIAQoAgAiAUEBajYCACABQQBIDQEgBygCXCIFIAUoAgAiAUEBajYCACABQQBIDQEgBygCYCIBBEAgASABKAIAIgZBAWo2AgAgBkEASA0CCyADIAE2AqwCIAMgBTYCqAIgAyAENgKkAiAHKAIkIRIgBygCICEfAkAgBygCQEGAgICAeEcEQCADQagBaiAHQUBrEIkdDAELIANBgICAgHg2AqgBCyAHKAI0ISAgBygCMCEhIAcoAiwhIiAHKAIoISMCQCAHKAJMQYCAgIB4RwRAIwBBEGsiCSQAIAdBzABqIgEoAgQhESAJQQRqIAEoAggiFkEAQQRBDBCgGCAJKAIIIQUgCSgCBEEBRwRAIANB6AJqIRMgCSgCDCEGAkAgBUUNACAWQQxsIRcgBiEBIAUhBANAIBdFDQEgCUEEaiAREN0gIAFBCGogCUEMaigCADYCACABIAkpAgQ3AgAgAUEMaiEBIBdBDGshFyARQQxqIREgBEEBayIEDQALCyATIBY2AgggEyAGNgIEIBMgBTYCACAJQRBqJAAMAgsgBSAJKAIMQeiZzwAQ/S8ACyADQYCAgIB4NgLoAgsgA0HYAmogA0GwAWoiBCgCADYCACADQeQCaiADQfACaigCADYCACADIBI2ArQCIAMgHzYCsAIgAyADKQKoATcC0AIgAyAgNgLEAiADICE2AsACIAMgIjYCvAIgAyAjNgK4AiADIAMpAugCNwLcAiADIAcpAzg3AsgCIANB6AJqIgEgA0EIaiIFIANBpAJqIANBsAJqEPATIAMpA+gCQgJRDQIgBSABQfgA/AoAAEEEQQQQrTYiAUUNAyABIBU2AgAgBCADQRBqKQMANwMAIANBuAFqIANBGGopAwA3AwAgA0HAAWogA0EgaikDADcDACADQewBaiADQcwAaigCADYCACADIAMpAwg3A6gBIAMgAykDaDcDiAIgAyADKQNwNwOQAiADQQE2AuABIAMgATYC3AEgA0EBNgLYASADIAMpAkQ3AuQBIANB+AFqIANB2ABqKAIANgIAIANBhAJqIANB5ABqKAIANgIAIAMgAykDUDcD8AEgAyADKQJcNwL8ASADIAMpAyg3A8gBIAMgAykDMDcD0AEgAyADKQN4NwOYAiADQThqEJcwIAMoAtACQYCAgIB4RwRAIANB0AJqEOk7CyADKALcAkGAgICAeEcEQCADQdwCaiIBENErIAEQ6DsLIAMoAqQCIgEgASgCACIBQQFrNgIAIAFBAUYEQCADQaQCahCXFQsgAygCqAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIANBqAJqEPgjCwJAIAMoAqwCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBrAJqENseCyADQegCaiADQagBahDKBSADKQPoAiIkQgNRDQQgA0EIaiADQfACakGgAfwKAAALIBAgJDcDACAQQQhqIANBCGpBoAH8CgAAIBBBADYCsAEgEEKAgICAwAA3A6gBIANBkARqJAAMBAsACyADQRBqIANB+AJqKQMANwMAIAMgAykD8AI3AwhBvJrDAEErIANBCGpB6JrDAEG8n8MAENUeAAtBBEEEEKM9AAsgA0EYaiADQYADaikDADcDACADQRBqIANB+AJqKQMANwMAIAMgAykD8AI3AwhBvJrDAEErIANBCGpBrJrDAEHMn8MAENUeAAsgDSkDuAEiJEIEUQRAIApCBDcDAAwCCyANQQhqIA1BwAFqQbAB/AoAACAkQgNRBEAgB0EBOgB4CyAKICQ3AwAgCkEIaiANQQhqQbAB/AoAAAwBCyAKQgM3AwALIA1B8AJqJAAgCikDAEIDfUICVA0AIApB0AFqIgQgCkG4AfwKAAAgDiAOKQMAIiRCAXw3AwAgCiAkNwOIAyAIKAIAKAIIIQYgCBCNJCEDAkBB4AFBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIgUgBEHAAfwKAAAgAUEBOwHcASABIAM2AtgBIAFBADYC1AEgAUIANwLMASABIAZBCGo2AsgBIAhBADoACCAIKAIEIQQgCCAFNgIEAkAgBEUEQCABQQA2AsgBIAFBATYC0AEMAQsgCCgCACgCCEEIaiEGA0AgBCgCwAEgBkYNAAsgBCgCyAEhBiABIAQ2AsgBIAEgBkEBajYC0AEgBCAFNgLEAQsgAUEANgLUASAIKAIAIgEoAhggASAFNgIYIAU2AswBDAELQQhB4AEQoz0ACwwBCwsgCkG4AWohCSMAQeAAayIFJAAgDkEcaiEXAkACQCAOKAIkBEAgDigCICkDGCIkIA4pAwhRDQELIA5BEGohAyAFQSBqQQRyIQ0gBUEEciEQA0BBACEWQQAhE0EAIQEjAEFAaiIGJAAgAygCBCIEBEAgAygCACgCCEEIaiEIA0AgBCgCwAEgCEYNAAsgBCgCyAEhFgsgAygCACIEQQxqIAIoAgAiERCLFANAAkAgBkEIaiAEQQhqEM8ZAkACQAJAAkAgBigCCCIEBEAgBEECaw0BIBEoAgQgESgCACgCCBEDACAFQQo2AgAMAwsCQCAGKAIMIggpAwBCA1IEQCADIAgQih0iBC0A3AEgBEEAOgDcAQ0BQZuAwwBBFkG0gMMAEJ8pAAsgBiAIQQhrIgQ2AiggBCAEKAIAIgRBAWs2AgAgBEEBRw0EIAZBKGoQth8MBAsgBEEAOgDdASAGIARBCGoiFTYCFCAGQdiAwwA2AhAgBkEANgIgIAYgBkEQaiISNgIcIAYgEjYCGCAIKQO4ASEkIAZBKGogCCAGQRhqEOQRIAYoAigiCEEJRw0BIAMoAgQhCCADIBU2AgQgEyAELQDdAUEAR2ohEwJAIAhFBEAgBEEANgLIASAEQQE2AtABDAELIAMoAgAoAghBCGohEgNAIAgoAsABIBJGDQALIAgoAsgBIRIgBCAINgLIASAEIBJBAWo2AtABIAggFTYCxAELIBNBAU0EQCABQQFqIgEgFkcNBAsgESgCBCARKAIAKAIIEQMAIAVBCjYCAAwCCyADKAIEBEAgBUEKNgIADAILIAVBCTYCACADQQE6AAgMAQsgBSAGKQIsNwIEIAVBFGogBkE8aigCADYCACAFQQxqIAZBNGopAgA3AgAgBSAkNwMYIAUgCDYCACAEEIckCyAGQUBrJAAMAQsgAygCACEEDAELCwJAAkACQCAFKAIAIgFBCWsOAgEAAgsgCUEKNgIADAQLIAlBCTYCAAwDCyANQRhqIBBBGGooAgA2AgAgDUEQaiAQQRBqKQIANwIAIA0gECkCADcCACANQQhqIBBBCGopAgA3AgAgBSABNgIgIAUpAzgiJCAOKQMIUgRAIBcgBUEgahC5HwwBCwsgCSAFKQMgNwMAIA4gJEIBfDcDCCAJQQhqIAVBKGopAwA3AwAgCUEQaiAFQTBqKQMANwMADAELIA4gJEIBfDcDCCAFQUBrIBcQhBUgCUEQaiAFQdAAaikDADcDACAJQQhqIAVByABqKQMANwMAIAkgBSkDQDcDAAsgBUHgAGokAAJAAkACQAJAIAooArgBQQlrDgICAAELIBhBCjYCAAwCCyAYIAopA7gBNwMAIBhBEGogCkHIAWopAwA3AwAgGEEIaiAKQcABaikDADcDAAwBCyAYQQlBCiAHLQB4GzYCAAsgCkGQA2okAAJAIAsoAggiBUEKRgRAIBRBATYCAAwBCyALKAIUIQYgCygCECEEIAsoAgwhA0EAIQECQAJAAkAgBUEIaw4CAQIACyALIAspAxg3AxggCyAGNgIUIAsgBDYCECALIAM2AgwgCyAFNgIIQZzgwgBBKyALQQhqQejgwgBBhPjCABDVHgALIAQgBkEUbGohHiAEIQELIBQgHjYCECAUIAM2AgwgFCAENgIIIBQgATYCBCAUQQA2AgALIAtBIGokACAPKAIMDQMgDygCECIBRQ0BIAwoAgAEQCAMEOUgCyAMIAE2AgAgHCAdKQIANwIAIBxBCGogHUEIaigCADYCAAsgGkEBcyEaDAELC0ECIQEMAQtBAyEBCyAbIAw2AgQgGyABNgIAIA9BIGokACAZKAIMIQEgACAZKAIINgIAIAAgATYCBCAZQRBqJAALOwEBfyMAQRBrIgIkACACIAAoAgA2AgwgAUG4vcMAQQpBwr3DAEEFIAJBDGpBqL3DABD2GCACQRBqJAALNgAgAEEINgIAIAAgAiABKAIMIgAgACACSxsiAjYCBCABIAAgAms2AgwgASABKAIQIAJqNgIQC5MBAQR/IAAoAgAEQCMAQRBrIgEkACAAKAIMIgQgACgCBCICa0HIAG4hAyACIARHBEADQCACEMkOIAJByABqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEHIABDgHiABQRBqJAALIAAoAhAEQCAAQRBqEOcgCyAAKAIgBEAgAEEgahDnIAsLMgEBfwJAIABBP3EiAUUNACAAIAAgAWtBQGsiAE0NAEHYls8AQSNB/JbPABDLJAALIAALnAEBA38gACgCCCIDBEAgACgCBCEBA0ACQCABKAIQRQ0AIAEoAhQiAkUNACABQSBqIAEoAhggASgCHCACKAIQEQEACwJAIAEoAiRFDQAgASgCKCICRQ0AIAFBNGogASgCLCABKAIwIAIoAhARAQALIAFBOGoQhTAgAUHEAGoQhTAgAUHQAGohASADQQFrIgMNAAsLIABBCEHQABDgHgs2AQF/IAAoAggiAQRAIAAoAgQhAANAIAAQwxUgAEEEQRQQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsLNgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOQpIABBBEEYEOAeIABBDGohACABQQFrIgENAAsLCzsAIABCKIkgAEIPiYUgAIVCpb7j9NGMh9mff34iAEIjiCABfCAAhUKlvuP00YyH2Z9/fiIAQhyIIACFCzUAIAAgA0H/AXEiACABIAIQqyEgACACSQRAIAEgAEECdGovAQIaDwsgACACQfzl+wAQwyEACzcAIAAgAEEHdkGAAmogAEGAAkkbIgBB/wNNBEAgAEG07/sAai0AAA8LIABBgARBtPP7ABDDIQALMgEBfwJAIABBP3EiAUUNACAAIAAgAWtBQGsiAE0NAEHMx/4AQSNB8Mf+ABDLJAALIAALHwAgABDeOyAAQQxqEOo7IABBGGoQ6TsgAEEkahDpOwsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQcjA/wBBI0HswP8AEMskAAsgAAs3AQJ/IAAoAgghAiAAKAIMIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBBEAgAiABIAAoAggQ+DoLCzIBAX8CQCAAQT9xIgFFDQAgACAAIAFrQUBrIgBNDQBB3OKAAUEjQYDjgAEQyyQACyAACzIBAX8CQCAAQT9xIgFFDQAgACAAIAFrQUBrIgBNDQBB+OuAAUEjQZzsgAEQyyQACyAACzYBAn8gACgCCCICBEAgACgCBCEBA0AgARDOKiABQRBqIQEgAkEBayICDQALCyAAQQRBEBDgHgsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQbzzgQFBI0Hg84EBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQcixggFBI0HssYIBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQfT5ggFBI0GY+oIBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdj3gwFBI0H894MBEMskAAsgAAs5AQF/IwBBEGsiAiQAIAJBCGogASgCABC5JiACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALOQECfyAAKAIEIQEgACgCAEEBRwRAIAEPC0GAgIABIQIgAUGAgIABSQRAIAAgAUEBdCICNgIECyACCzgBAX8gASgCICECIABBBGogAUEkakEAIAEoAiQbEO4lIAAgAkEEdjYCICAAQQA2AhwgACABNgIACzMBAX8gABD7KSAAKAJAQQhqKAIQakHkAGohASAAKAJMIgAEfyABIABBCGooAhBqBSABCwuFAQEEfyAAKAIEIgEgASAAKAIIQQN0aiICRgR/QQAFIAIgAWtBA3YhA0EAIQIDQCABKAIAIAFBBGooAgAiBCgCCEEBa0F4cWpBCGogBCgCUBEEACACaiECIAFBCGohASADQQFrIgMNAAsgAgshASAAKAIcIgAEfyABIABBCGooAhBqBSABCwsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQYiFhwFBI0GshYcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdiKhwFBI0H8iocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQYiYhwFBI0GsmIcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZWehwFBI0G4nocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZSkhwFBI0G4pIcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdSuhwFBI0H4rocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZj8hwFBI0G8/IcBEMskAAsgAAs4AAJAIAJBgIDEAEYNACAAIAIgASgCEBECAEUNAEEBDwsgA0UEQEEADwsgACADIAQgASgCDBEGAAs5AQF/IwBBIGsiBCQAIAQgASACIANCABCnBiAEKQMAIQEgACAEKQMINwMIIAAgATcDACAEQSBqJAALOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDKFAsLQAEBf0GIASEBAkACQAJAAkAgAC0AgAFBA2sOAgABAwsgAC0AlAFBA0cNAUGMASEBCyAAIAFqELwqCyAAENQcCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOcqCws4AQF/IAAoAgAiAEEQahDUJQJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHIAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOkqCws4AQF/IAAoAgAiAEEQahCbJwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHwAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOsqCws4AQF/IAAoAgAiAEEQahD/KAJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHQAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEO0qCws4AQF/IAAoAgAiAEEQahDYEgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHQAkEIEPg6CwswAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkDACACEOYqIAFBEGokALkLMAICfwF+IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQpAxAgAhDqKiABQRBqJAC5CzACAn8BfiMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKQMYIAIQ6iogAUEQaiQAuQtoAgF+A38jAEEQayICJAAgAkEEaiIEIAAQhSMCfkIAIAIoAgQiACgCKCIDRQ0AGiAAKAIkQegBaiEAA0AgACkDACABfCEBIABBwAJqIQAgA0EBayIDDQALIAELIAQQ6iogAkEQaiQAuQsxAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkD4AEgAhDsKiABQRBqJAC5CzECAn8BfiMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKQPoASACEOwqIAFBEGokALkLMQICfwF+IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQpA/ABIAIQ7CogAUEQaiQAuQs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQdynwwAgBEEMakHcp8MAIAIgAxDmDwALOAEBfyMAQRBrIgIkACACIAA2AgwgAUHgtcMAQQpB6rXDAEEFIAJBDGpB0LXDABD2GCACQRBqJAALOAEBfyAAQSRqELscAkAgACgCEEUNACAAKAIUIgFFDQAgAEEgaiAAKAIYIAAoAhwgASgCEBEBAAsLOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDqGQsLNgEBfyMAQRBrIgIkACACQQhqIAEQyScgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQACzYBAX8DQCAAKAAAIQMgACABKAAANgAAIAEgAzYAACAAQQRqIQAgAUEEaiEBIAJBAWsiAg0ACws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEMwjCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEIEfCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEIQmCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEO4mCws2AQF/IAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+CMLIAAQ3iMgAEEEQRQQ4B4LOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDWIgsLOwEBf0EIQQQQrTYiAkUEQEEEQQgQoz0ACyAAQcS+zQA2AgggACACNgIEIABBBTYCACACIAEpAgA3AgALJgAgAEEYakEIEO4oIAAQ3jsgAEEMakEEQQgQ4B4gAEHQAGoQ4zwLNgEBfyMAQRBrIgIkACACQQhqIAEQnSUgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQACy8BAX8gACgCCEGAgICAeEcEfyAAKAIQIAAtABQiAEEDdiAAQQdxQQBHamoFIAELCzIBAX8gACgCACIBBEAgASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQhR0LIABBCGoQkycLCzkBAX8jAEEQayIEJAAgBCABNgIMIAQgADYCCEEAIARBCGpBhOfPACAEQQxqQYTnzwAgAiADEOYPAAs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQZTnzwAgBEEMakGU588AIAIgAxDmDwALMgAgAUGkAmoQhTAgAUGsAmogAkEIaigCADYCACABIAIpAgA3AqQCIAAgAUHAAvwKAAALMgAgAUGwAmoQhTAgAUG4AmogAkEIaigCADYCACABIAIpAgA3ArACIAAgAUHAAvwKAAALMwEBfyAAKAIEIgEEQCAAKAIAIAFBARD4OgsgACgCDCIBBEAgACgCCCABQQJ0QQQQ+DoLCzMBAX8gACgCFCIBBEAgACgCECABQQEQ+DoLIAAoAhwiAQRAIAAoAhggAUEBdEECEPg6Cws5AQF/IAAoAqgCQQFGBEAgACgCxAQgACgC+BJrDwsgACgC0BIgACgCzBJrIgEEfyABBSAAKALEBAsLPAEBfyMAQRBrIgMkACADQeDx0QA2AgwgAyAANgIIQQEgA0EIakGYnuIAIANBDGpBmJ7iACABIAIQ5g8ACzwBAX8jAEEQayIDJAAgA0G8vfsANgIMIAMgADYCCEEAIANBCGpBjLz7ACADQQxqQYy8+wAgASACEOYPAAs6AgF/AX4jAEEQayIBJAAgARCHNyABKQMAIQIgACABKAIINgIIIAAgAjcDACAAQQA2AhAgAUEQaiQACzUAIAAgAUEs/AoAAAJAAkAgAS0ALEEBaw4FAAAAAAABCyABKAIwIgBFDQAgAEEYQQgQ+DoLCzgBAX8jAEEQayICJAAgAiAANgIMIAFB18H7AEENQdTB+wBBAyACQQxqQcTB+wAQ9hggAkEQaiQAC6ECAQV/AkAgAEUNACAAKAIgRQ0AIAAoAiRFDQAgACgCHEUNACMAQRBrIgMkACADQgA3AgggA0IBNwIAIAAoAhwhBANAIAEgA2oiAigCACEFIAIgASAEakEIaiICKAIANgIAIAIgBTYCACABQQRqIgFBEEcNAAsCQCADKAIEIgJBQGpBQUkEQCAAQSBqIQEgAkHBAE8EQCABIAMoAgAgAhCNGQsgAEEANgIcIwBBMGsiACQAIABBATYCDCAAIAQ2AggCQCAERQ0AIAEoAgQiAkGcC0cEQCABKAIIIARBBGsoAAAgAhEAAAwBCyAAQYDxADYCECAAQRBqIAQQ6SQLIABBMGokACADQRBqJAAMAQtB+O/8AEHKAEHE8PwAEJ8pAAsLCzUBAX8gABCmDCAAQQxqEPYkIAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQuyMLC54BAgJ/An4gACgCACAAKAIEIgEoAghBAWtBeHFqQQhqIQIjAEEgayIAJAAgAEEIaiACIAEoAhARAAAgAEEQaiAAKAIIIgEgACgCDCgCDBEAACAAKQMYIQMgACkDECEEIABBIGokACABQQAgBEKGspjZnam3pm6FIANC3a+72du2z9ZmhYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAufAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARC/Ou54rzv+NByhSADQtrjn43Mj+GBqX+FhFAbIgBFBEBB4OGAAUEQQfDhgAEQyyQACyAAC58BAgJ/An4gACgCACAAKAIEIgEoAghBAWtBeHFqQQhqIQIjAEEgayIAJAAgAEEIaiACIAEoAhARAAAgAEEQaiAAKAIIIgEgACgCDCgCDBEAACAAKQMYIQMgACkDECEEIABBIGokACABQQAgBELyyPrD9OmMmPMAhSADQvC4kO3DhNv9ToWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALnwECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQtrOgMmrxer9xwCFIANCm/Tdt5mL044/hYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAueAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARCpJvx8abpgqoQhSADQs272sTrx8SCGIWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALoAECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQsbMuueM6qCFvH+FIANCutKR74r29PjMAIWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALnwECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQvz2+K7xiNShFYUgA0LvytP9o9G+0fAAhYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAueAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARCk5Pu9eiogpZnhSADQpiS4em4iOKWaYWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALNQEBfyAAELQMIABBDGoQ/iQgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELYMIABBDGoQgSUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELcMIABBDGoQgiUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELkMIABBDGoQgyUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAEL4MIABBDGoQhCUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQECfyMAQdAAayIDJAAgA0EMaiIEIAEgAhCvASADIAQQoAEgACADKQMANwMAIANB0ABqJAALMgAgACgCDEEIaigCECAAKAIgIAAoAiQiACgCCEEBa0F4cWpBCGogACgCVBEEAGpBKGoLOQEBfyMAQRBrIgQkACAEIAE2AgwgBCAANgIIQQAgBEEIakH8uocBIARBDGpB/LqHASACIAMQ5g8ACy8AIAFBKGoQzwwgAUEwaiACQQhqKAIANgIAIAEgAikCADcCKCAAIAFByAD8CgAACz0BAX5BACABKAIAEQQAIgFFBEBB7OyHARCYJwALIAAgASkDCDcDCCAAIAEpAwAiAjcDACABIAJCAXw3AwALNgAgACABKQAANwAAIAAgASkAEDcAECAAQQhqIAFBCGopAAA3AAAgAEEYaiABQRhqKQAANwAACzYAIAEoAgBBgICAgHhHBEAgACABKQIANwIAIABBCGogAUEIaigCADYCAA8LIAAgASgCBBDpHQs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQbSmiAEgBEEMakG0pogBIAIgAxDmDwALMAACQCAAKAIARQ0AIABBCGoQrDsEQCAAELwqCyAAQRRqEKw7RQ0AIABBDGoQvCoLCzcBAX8gACgCACIAQQxqEOInAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLegECfyMAQRBrIgMkACADIAE2AgwjAEEQayICJAAgAkEEaiADQQxqEJIfIAIoAgRBgICAgHhGBEBBoq2IAUExEJc9AAsgACACKQIENwIAIABBCGogAkEMaigCADYCACACQRBqJAAgAUGEAU8EQCABEPIfCyADQRBqJAALMgEBfyMAQRBrIgIkACACQQhqIAAgACgCCBDqDCABIAIoAgggAigCDBD7KCACQRBqJAALOQEBfyMAQRBrIgQkACAEIAE2AgwgBCAANgIIQQAgBEEIakGAqIkBIARBDGpBgKiJASACIAMQ5g8ACzkBAX8jAEEQayIEJAAgBCABNgIMIAQgADYCCEEAIARBCGpB7O+JASAEQQxqQezviQEgAiADEOYPAAs5AQF/IwBBEGsiBSQAIAUgAjYCDCAFIAE2AgggACAFQQhqQfzviQEgBUEMakH874kBIAMgBBDmDwALLQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOk7IABBDGohACABQQFrIgENAAsLCzIBAX8gACgCCCIBBEAgACgCBCEAA0AgABCGKSAAEOg7IABBDGohACABQQFrIgENAAsLCzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEPwoDwsgACABENMcDwsgACABENIcCy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCgCMCACEOYqIAFBEGokAAswAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkD2AEgAhDsKiABQRBqJAALLQECfyMAQaABayIAJAAgAEEIahDVEyAAQQA2AgAgABDRKUEIaiAAQaABaiQACzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEL8QDwsgACABELccDwsgACABELQcCy8BAX8jAEEQayICJAAgAARAIAIgATYCDCACIAA2AgggAkEIahC8KgsgAkEQaiQACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFB5PPDAEEKIAJBDGpB1PPDABDQEyACQRBqJAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQzCQPCyAAIAEQ0xwPCyAAIAEQ0hwLMwEBfyAAQQg2AgAgACACIAEoAhAgASgCFCIAayIDIAIgA0kbIgI2AgQgASAAIAJqNgIUCzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEOMoDwsgACABELkcDwsgACABELgcC/4BAgR/An4gABDzLS0AAEEaRgRAIwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAACABKQMYIQUgASkDECEGIAFBIGokACAAQQAgBkKrmJHxlfrV/IB/hSAFQpaU+Kvwsemz4QCFhFAbIgBFBEBBpN7QAEERQbje0AAQyyQACyAAENI8IAAoAiAiAUEQTwRAIAAoAhwhACABQQR2IQEDQCACIAAoAgAiBEEAIARBDEsbaiECIABBEGohACABQQFrIgENAAsLQQR0IAJqQTxqDwsgABD8LQs0AQF/IwBBEGsiASQAIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEIQRAQ4B4gAUEQaiQACzgAIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHQnM4ANgIIIABCBDcCECAAQQhqQdiczgAQ7ywACzgAIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHQnM4ANgIIIABCBDcCECAAQQhqQfSdzgAQ7ywACzcBAX4gACAANQJQEKoSIAAgADUCWBCqEiAAIAA1AkwQqhIgACAAKQMwIgFCAYYgAUI/h4UQqhILOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQcygzgA2AgggAEIENwIQIABBCGpB1KDOABDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQcygzgA2AgggAEIENwIQIABBCGpBhKHOABDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQaCizgA2AgggAEIENwIQIABBCGpB2KLOABDvLAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQxRUPCyAAIAEQtRwPCyAAIAEQthwLNAEBfyMAQRBrIgIkACACIAAoAgA2AgwgAUHc6dAAQQkgAkEMakHM6dAAENATIAJBEGokAAs0AQF/IwBBEGsiAiQAIAIgACgCADYCDCABQYDq0ABBCSACQQxqQfDp0AAQ0BMgAkEQaiQACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFB5enQAEELIAJBDGpBzOnQABDQEyACQRBqJAALMwAgACABKQMANwMAIAFBCTYCACAAQRBqIAFBEGopAwA3AwAgAEEIaiABQQhqKQMANwMACzMBAX8CQAJAAkAgACgCQEEBaw4CAgABC0EBDwsgACgCHEEBRw0AIAAoAhhBAEchAQsgAQstAQF/IAAgAUEBahCGLCIDIAJ2IgJBAk8EfyAAIAEgAmdBH3NBARDjJQUgAwsLOAEBfyAApyEBIABC/////wtWBH8gAUEBdEEBdUGAgICAfHEgAUH/////A3FyQYCAgIB4cwUgAQsLMQAgACgCHCAAKAIYIAAoAhQgACgCECAAKAIMIAAoAgggACgCBCAAKAIAampqampqagtCACAAQgA3AiwgAEEAOgAoIABBADYCJCAAQYCAgIB4NgIYIABBgICAgHg2AgwgAEGAgICAeDYCACAAQTFqQgA3AAALMAAgAiAETwRAIAQEQCABIAMgBPwKAAALIAAgAyAEEOgHDwsgBCACQYDp/AAQsDsACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFBrOX+AEEKIAJBDGpBnOX+ABDQEyACQRBqJAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQwRgPCyAAIAEQtRwPCyAAIAEQthwLMQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAQQFBARDgHiAAQQxqIQAgAUEBayIBDQALCws4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDUHw8LIAAgARCPFg8LIAAgARCOFgs4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARCeJQ8LIAAgARC5HA8LIAAgARC4HAs4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARCcEg8LIAAgARC3HA8LIAAgARC0HAstAQF/IAAoAggiAQRAIAAoAgQhAANAIAAQnTwgAEEMaiEAIAFBAWsiAQ0ACwsLLQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOM8IABBDGohACABQQFrIgENAAsLCy0BAX8gACgCCCIBBEAgACgCBCEAA0AgABDeOyAAQQxqIQAgAUEBayIBDQALCwswACAAQQxqEL0sIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJUEQQAakHIAGoLLwEBfyAAENoqIAAoAkBBCGooAhBqIQEgACgCTCIABH8gASAAQQhqKAIQagUgAQsLMgEBfiAAIAEoAhAgAkEDdGoiAkEIaikDACACKQMAIgN9PgIEIAAgASgCHCADp2o2AgALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyphwE2AgggAEIENwIQIABBCGpB9KmHARDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyphwE2AgggAEIENwIQIABBCGpBhKqHARDvLAALLQEBfyMAQRBrIgMkACAAKAIIIAFJBEAgA0EIaiAAIAEgAhCyAwsgA0EQaiQACzQBAX8jAEEQayIBJAAgASAAKAIANgIMIAEgACgCCDYCCCABQQhqQQRBBBDgHiABQRBqJAALWQEBfyMAQRBrIgMkACADIAI2AgwgAyABNgIIIANBCGohASADQQxqIQICQCAAKAIAIgBBAXEEQCAAQX5xIAEoAgAgAigCABC4KAwBCyAAEJQtCyADQRBqJAALVgEBfyMAQRBrIgMkACADIAI2AgwgAyABNgIIIANBCGohASADQQxqIQICQCAAKAIAIgBBAXEEQCAAIAEoAgAgAigCABC4KAwBCyAAEJQtCyADQRBqJAALJwACQCADRSABIAMQ0TRFcg0AIAAgASADIAIQlzUiAEUNACAADwsACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQaiOigE2AgggAUIENwIQIAFBCGogABDvLAALOwEBf0EBIQICQCAAIAEQ0xANACABKAIAQaztiQFBAiABKAIEKAIMEQYADQAgAEEEaiABENMQIQILIAILOgEBfyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBnPiJATYCCCAAQgQ3AhAgAEEIakGk+IkBEO8sAAszAQJ/QYCAxAAhAiAAKAIAIgEgACgCBEcEfyAAIAFBAWo2AgAgACABQQJ0aigCCAUgAgsLNwEBfyMAQSBrIgEkACABQQA2AhggAUEBNgIMIAFBhO2JATYCCCABQgQ3AhAgAUEIaiAAEO8sAAs3AQF/IwBBIGsiASQAIAFBADYCGCABQQE2AgwgAUHsjooBNgIIIAFCBDcCECABQQhqIAAQ7ywACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQZiPigE2AgggAUIENwIQIAFBCGogABDvLAALMgEBfyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPgjCyAAEMMnIAAQ6jsLMQEBfyMAQRBrIgIkACACIAA2AgwgAUHc1sIAQQ8gAkEMakHM1sIAENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQdTswgBBDyACQQxqQcTswgAQ0BMgAkEQaiQACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEHYgMMANgIACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEH4gMMANgIACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEHogMMANgIACzIBAX8gABCrASAAEPQ7IAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+CMLCzEBAX8jAEEQayICJAAgAiAANgIMIAFB77XDAEEPIAJBDGpB0LXDABDQEyACQRBqJAALLgAgACkDAEICUgRAIABBIGoQhjAgAEEsahCGMCAAQThqEIYwIABBxABqEIYwCwsnAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAIQ+CogAUEQaiQAQQALLQEBfyAALQAAIABBADoAAARAIAFBhAFPBEAgARDyHwsPC0Hs2sMAQRwQlz0ACzEBAX8jAEEQayICJAAgAiAANgIMIAFBiO3DAEEPIAJBDGpB+OzDABDQEyACQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUG88cMAQREQli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHl8cMAQRIQli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHM9sMAQQ4Qli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUGU+MMAQQ0Qli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHc+MMAQREQli0gAhDEISAAQRBqJAALMQEBfyMAQRBrIgIkACACIAA2AgwgAUH0g8QAQQogAkEMakHkg8QAENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQZCExABBDyACQQxqQYCExAAQ0BMgAkEQaiQACzEBAX8jAEEQayICJAAgAiAANgIMIAFBhILOAEEIIAJBDGpB9IHOABDQEyACQRBqJAALLwEBfyAAEJ0sIABB4ABqEJ0sIABBwAFqIgEQ3CUgAUEEQRAQ4B4gAEHQAWoQ3jsLMQEBfyMAQRBrIgIkACACIAA2AgwgAUG0hM4AQREgAkEMakGkhM4AENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQazyzgBBESACQQxqQZzyzgAQ0BMgAkEQaiQACzEBAX8jAEEQayICJAAgAiAANgIMIAFBkJbPAEEIIAJBDGpBgJbPABDQEyACQRBqJAALMgEBfwJAIAAoAgAiAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQRBBBBD4OgsLMgEBfwJAIAAoAgAiAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQQxBBBD4OgsLMgEBfyAAIAAoAgQiAyACajYCBCAAIAAoAgAgAkECdEGw8tAAaigCACABcSADdHI2AgALMgAgAEEAOgAcIAAgACgCCDYCDCAAIAAoAgRBQHE2AhQgACgCJEECTwRAIABBATYCJAsLMgEBfyAAIAAoAgQiAyACajYCBCAAIAAoAgAgAkECdEHgl9EAaigCACABcSADdHI2AgALKAEBfwNAIAEEQCABQQFrIQEgACgCACACaiECIABBBGohAAwBCwsgAgsvAQF/IAAgACgCBCIDIAEgACgCACADdEEAIAJrdkEBdGoiAC0AAGo2AgQgAC0AAQskAQF/QThBBBCtNiIABEAgAEEAQTj8CwAgAA8LQQRBOBCjPQALMQEBfyMAQRBrIgIkACACIAA2AgwgAUG8hv0AQQ8gAkEMakGshv0AENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQcC4/gBBDyACQQxqQbC4/gAQ0BMgAkEQaiQACy0AAkACQAJAIAAoAgBBAmsOAgABAgsgAEEEahDpOw8LIABBBGpBBEEIEOAeCwuZAgIFfwJ+IwBBEGsiBSQAIAVBADYCBCAFIAEoAgA2AggjAEEQayIBJAACQAJAAkACQAJAIAVBBGoiBCgCACIDQQFrDgIBBAALIAFBBGogAiAEKAIEIgIQ+BEgASgCBCIDDQEMAgsgBCgCCCEDIAFBBGoiBiACIAQoAgQiBxD4ESABKQIIIQggASgCBCEEIAYgAiADEPgRIAEoAgQiAkUgBEVyDQEgASkCCCEJIAAgAzYCICAAIAk3AhggACACNgIUIAAgBzYCECAAIAg3AgggACAENgIEQQEhAwwCCyABKQIIIQggACACNgIQIAAgCDcCCCAAIAM2AgRBACEDDAELQQIhAwsgACADNgIAIAFBEGokACAFQRBqJAALLwAgACgCGEUEQEEADwsgACgCICAAKAIkIgAoAghBAWtBeHFqQQhqIAAoAkwRBAALLwAgACgCDEEIaigCECAAKAIgIAAoAiQiACgCCEEBa0F4cWpBCGogACgCUBEEAGoLMQEBfyAAIAEoAhAgAkECdGoiAigCACIDIAEoAhxqNgIAIAAgAkEEaigCACADazYCBAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQfDihgFBDyACQQxqQeDihgEQ0BMgAkEQaiQACzEBAX8CQCAARQRAQQAhAAwBCyAAKAIAIgAgACgCACIBQQFqNgIAIAFBAE4NAAALIAALawEDfyMAQRBrIgEkACABIABBCGo2AgwgASAAKQIANwIEAkAgAUEEaiICKAIAIgBBf0YNACAAIAAoAgQiA0EBazYCBCADQQFHDQAgAigCBEELakF8cSICRQ0AIAAgAkEEEPg6CyABQRBqJAALMAEBfwJAIAAoAgQgASgCBEcNACAAKAIMIAEoAgxHDQAgACgCECABKAIQRiECCyACCygAIAAgAiABIAMgASADSRsQmSciACABIANrIAAbIgBBAEogAEEASGsLLAEBfyMAQRBrIgAkACAAQQhqIgIgAUGIqokBQQsQli0gAhDEISAAQRBqJAALJgEBf0EBIABBAXJnQR9zIgFBAXYgAUEBcWoiAXQgACABdmpBAXYLNAACQAJAAkACQCAALQAZQQNrDgIAAQMLIABBIGoQoikMAQsgAEEgahDFIQsgAEEAOgAYCws0AAJAAkACQAJAIAAtABFBA2sOAgABAwsgAEEUahCjKQwBCyAAQRhqEMUhCyAAQQA6ABALCy0BAX8jAEEQayIBJAAgASAAEJgfIAEgASkDADcCCCABQQhqEMkmIAFBEGokAAs0AQF/QRBBBBCtNiICRQRAQQRBEBCjPQALIAIgATYCDCACIAA2AgggAkKBgICAEDcCACACCysBAX4gACkDAEIGfSIBQgFYBEAgAadBAUcEQCAAQQhqEJEqCw8LIAAQsR4LMQAgACACNgIgIABBADYCCCAAQQA2AgAgACABKQIANwIQIABBGGogAUEIaikCADcCAAsaACAAQQhqEN47IABBIGoQ3jsgAEFAaxDjPAsnAQF/IABBCBDuKCAAQTBqIgEQ3CUgAUEEQRAQ4B4gAEHIAGoQ4zwLLgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEPASIABBwAJqIQAgAUEBayIBDQALCwslAQF/IAFB4ABqIgMQwhggAyACQdgA/AoAACAAIAFBwAL8CgAACzABAX8jAEEQayIBJAAgASAAKAIANgIMIAEgACgCCDYCCCABQQhqEOk7IAFBEGokAAssACAAQQxqEL0sIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJQEQQAagsqACAAKAIsBEAgAEEsahDUHgsgAEEMahD5IyAAQRRqENQeIABBIGoQ1B4LLgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEKUeIABBxABqIQAgAUEBayIBDQALCwsuAQF/IwBBEGsiBSQAIAUgACkCADcCCCAFQQhqIAEgAiADIAQQjRMgBUEQaiQACy4BAX8jAEEQayIFJAAgBSAAKQIANwIIIAVBCGogASACIAMgBBCOEyAFQRBqJAALLgEBfyMAQRBrIgUkACAFIAAoAgA2AgwgBUEMaiABIAIgAyAEENcBIAVBEGokAAspACABBEAgAUECdCEBA0AgACgCABDyHyAAQQRqIQAgAUEEayIBDQALCws4AQF/QQEhASAALQAERQRAIAAoAgAiASgCAEHf8YkBQQEgASgCBCgCDBEGACEBCyAAIAE6AAQgAQvKBAEGfyMAQRBrIgQkACMAQeABayICJAAgAkEQaiAAEPgXAkAgAQRAIAJBIGogARCVGgwBCyACQgI3AyALIAJBuAFqIQEjAEHQAWsiACQAIAJBEGoiAygCDCEGIAMoAgghByADKAIEIQUgACADKAIANgIwIAAgBTYCKCAAIAUgB0EUbGo2AjQgACAFNgIsAkAgAkEgaiIDKQMAQgJSBEAgAEE4aiADQZgB/AoAAAwBCyAAQThqEKISCyAAQRhqIABBKGogBiAAQThqIgUQ0AMgAEEQaiIDIABBJGooAgA2AgAgACAAKQIcNwMIAkAgACgCGCIGQQZHBEAgAEHEAGogAygCADYCACAAIAApAwg3AjwgACAGNgI4IAUQ0xkhAyABQYCAgIB4NgIAIAEgAzYCBAwBCyABIAApAwg3AgAgAUEIaiADKAIANgIACyAAQdABaiQAAn8gAigCuAFBgICAgHhGBEBBASEAIAIoArwBDAELIAJB2AFqIAJBwAFqKAIANgIAIAIgAikCuAE3A9ABIAJBCGogAkHQAWpBjJrDABCQISACIAIoAgggAigCDBC1NiACIAIoAgQ2AswBQQAhACACKAIACyEBIAIgADYCxAEgAiABNgLIAUEAIQMgAkHEAWoiACgCBCEBIAQCfyAAKAIABEBBACEAQQEMAQsgACgCCCEDIAEhAEEAIQFBAAs2AgwgBCABNgIIIAQgAzYCBCAEIAA2AgAgAkHgAWokACAEKAIAIAQoAgQgBCgCCCAEKAIMIARBEGokAAstAAJAAkACQCAALQBEDgQAAgIBAgsgAEE4ahDeOw8LIABBGGoQ3yAgABC9KgsLqQEBA38gACgCACIDQQhqIgFBAToAJCABLQAUIQIgAUEBOgAUAkAgAg0AIAFBADoAFCABKAIMIQIgAUEANgIMIAJFDQAgASgCECACKAIMEQMACyABLQAgIQIgAUEBOgAgAkAgAg0AIAFBADoAICABKAIYIQIgAUEANgIYIAJFDQAgASgCHCACKAIEEQMACyADIAMoAgAiAUEBazYCACABQQFGBEAgABDZIwsLLQEBfyAAKAIAIgFBCGoQsx8gASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQlh8LCy0BAX8gACgCACIBQQhqELMfIAEgASgCACIBQQFrNgIAIAFBAUYEQCAAEO0dCwstAQF/IAAoAgAiAUEIahCTHyABIAEoAgAiAUEBazYCACABQQFGBEAgABDtHQsLqQEBA38gACgCACIDQQhqIgFBAToAKCABLQAYIQIgAUEBOgAYAkAgAg0AIAFBADoAGCABKAIQIQIgAUEANgIQIAJFDQAgASgCFCACKAIMEQMACyABLQAkIQIgAUEBOgAkAkAgAg0AIAFBADoAJCABKAIcIQIgAUEANgIcIAJFDQAgASgCICACKAIEEQMACyADIAMoAgAiAUEBazYCACABQQFGBEAgABDHIQsLLQEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEIUdCyAAQQhqEJMnCzMBAX9BBCEBAkACQAJAIAAoAgBBgICAgHhrDgIBAgALIAAQnTxBDCEBCyAAIAFqEM8vCwszAQF/IAEgACgCACICKAIATQRAIAIgATYCCCAAIAE2AgQPC0H84tAAQSxBqOPQABCfKQALLAECfyAAKAIEIAAoAgBBAnRqIgItAAIgACACLwEAIAEgAi0AAxC1LGo2AgALLQEBfyAAIAAoAgQgAWoiAjYCBCABQQJ0QbDz0ABqKAIAIAAoAgBBACACa3ZxCy0BAX8gACAAKAIEIAFqIgI2AgQgAUECdEGwxdEAaigCACAAKAIAQQAgAmt2cQt8AQN/IwBBEGsiBCQAIARBCGohBUEYQQgQrTYiA0UEQEEIQRgQoz0ACyADIAIpAwA3AwAgA0EQaiACQRBqKQMANwMAIANBCGogAkEIaikDADcDACAFQbTI0QA2AgQgBSADNgIAIAAgASAEKAIIQbTI0QAQySkgBEEQaiQACysBAX8gABCwGiIBQRBJBEAgACABQQJ0aioCABoPCyABQRBBpPXRABDDIQALLAAgAEUEQEMAAADADwsgAEGAAk8EQCAAsxDqEg8LIABBAnRBwIfzAGoqAgALHwAgABDeOyAAQQxqEOk7IAAoAhgEQCAAQRhqEM8vCwsfACAAEN47IABBDGoQ4zwgACgCGARAIABBGGoQzy8LC4UDAQt/IwBBEGsiCSQAIAlBBGohCCMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAEEEQQQQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxBvPyBARD9LwALIAJBEGoiCkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAEoAgQgASgCAGsQ7i0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQsCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCCCEMIAcgBmshByADKAIIIAVBAnRqIQEDQCAGLAAAIgNBAEgNAiAMIANBAnRqIgMgAygCACIDQQFqNgIAIAEgAzYCACAGQQFqIQYgAUEEaiEBIAVBAWohBSAHQQFrIgcNAAsLIAsgBTYCAAwBCyADQYABQdy3ggEQwyEACyAEQRBqJAAgCEEIaiAKKAIANgIAIAggAikCCDcCACACQSBqJAAgACAIEOgYIAlBEGokAAspAQF/IAAoAgxBCGooAhAhASAAKAIYIgAEfyABIABBCGooAhBqBSABCwstACABKAIARQRAIAAgASkCBDcCACAAQQhqIAFBDGopAgA3AgAPCyAAQQA2AgALKQEBfyAAKAIAQQhqKAIQIQEgACgCFCIABH8gASAAQQhqKAIQagUgAQsLMQEBfyMAQRBrIgQkACAEQYWAgIB4NgIAIAQgAzYCBCAAIAEgAiAEEKMBIARBEGokAAsyAQF/QQhBBBCtNiIBRQRAQQRBCBCjPQALIAFCgYCAgBA3AgAgAEEANgIEIAAgATYCAAujBAEGfyMAQRBrIgUkACAFIAApAgQ3AgggBUEIaiEDIwBBMGsiACQAAn8CQCABKAIAIgJB5IOIAUECIAEoAgQiBigCDCIEEQYADQAgAygCBCIHBEAgAygCACEDA0AgACADLQAAIgE6AAsCQAJAAkACQAJAAkACQCABQSFNBEAgAUEJaw4FAwEFBQIECyABQSJHIAFB3ABHcQ0EIABBATYCFCAAQfCDiAE2AhAgAEIBNwIcIABB7xs2AiwgACABNgIMIAAgAEEoajYCGCAAIABBDGo2AihBASACIAYgAEEQahDLCg0KGgwGCyACQeeDiAFBAiAEEQYADQgMBQsgAkHpg4gBQQIgBBEGAA0HDAQLIAJB64OIAUECIAQRBgANBgwDCyABRQ0BCyABQSBrQf8BcUHfAE8EQCAAQQE2AiQgAEGEhIgBNgIgIABBATYCFCAAQfyDiAE2AhAgAEEBNgIcIABBqh02AiwgACAAQShqNgIYIAAgAEELajYCKEEBIAIgBiAAQRBqEMsKDQYaDAILIABBATYCFCAAQZyEiAE2AhAgAEIBNwIcIABB7xs2AiwgACABNgIMIAAgAEEoajYCGCAAIABBDGo2AihBASACIAYgAEEQahDLCg0FGgwBCyACQfiDiAFBAiAEEQYADQMLIANBAWohAyAHQQFrIgcNAAsLIAJB5oOIAUEBIAQRBgAMAQtBAQsgAEEwaiQAIAVBEGokAAstAQF/IAAgACgCECIBQQFrNgIQIAFBAUYEQCAAQQFBARDgHiAAQRRBBBD4OgsLMAEBfyABQQhrIgIgAigCAEEBaiICNgIAIAJFBEAACyAAIAE2AgQgAEHYqogBNgIACygBAX8jAEEQayICJAAgAiAAKAIANgIMIAJBDGogARDTECACQRBqJAALMQAgACABKAIAIAIgAyABKAIEKAIMEQYAOgAIIAAgATYCBCAAIANFOgAJIABBADYCAAujHQIWfwN+IwBBEGsiDiQAIwBBQGoiCCQAIAhBCGogACABEPooIAhBFGoiACAIKAIIIAgoAgwQjzUgCEEgaiENIAJBAEchASMAQbABayIEJAACQCAAKAIIRQRAQeCYwwBBKRCUPiEDIA1BgICAgHg2AgAgDSADNgIEIAFFIAJBhAFJckUEQCACEPIfCyAAEN47DAELIARBOGogAEEIaigCADYCACAEIAApAgA3AzACfwJAIAFFDQAgBEH4AGogAhDHBwJAAkAgBCgCeCIBQQJrDgIAAgELIAQoAnwQgBghACANQYCAgIB4NgIAIA0gADYCBCAEQTBqEN47DAMLIAQoAnwhACAEQcgAaiAEQYABakEw/AoAACAEIAE2AkAgBEHEAGoMAQsgBEGAgICAeDYCYEEAIQAgBEEANgJAIARBgICAgHg2AmwgBEEANgJQIARBADYCSCAEQdgAagsgADYCACAEQRxqIQYgBEFAayEMIwBB4AFrIgEkACABIARBMGoQ5xUgAUEANgI4IAFBADsBPCABQfgAaiICIAEgAUE4ahDRDiABQeAAaiIAIAFBhAFqIgMoAgA2AgAgASABKQJ8NwNYAkACfwJAIAEoAngiCkEIRwRAIAEpA4gBIRkgAyAAKAIANgIAIAEgASkDWDcCfCABIBk3A4gBIAEgCjYCeCAGQQRqIAIQyCYgBkEBNgIADAELIAFBGGogACgCADYCACABIAEpA1g3AxAgAUH4AGogAUEQaiIDEMUKIAEoAoQBIQIgASgCgAEhCiABKAJ8IQAgASgCeCIFQQZHBEAgBiACNgIQIAYgCjYCDCAGIAA2AgggBiAFNgIEIAZBATYCACADELIfDAELIAFBKGogAUEIaikCADcDACABIAEpAgA3AyAgCiAKKAIAIgNBAWo2AgACQAJAIANBAE4EQCABIAo2AjRBgAghAyAMKAIAQQFGBEAgACgCCCIDIAwoAgQiBSADIAVJGyEDCyAMKAIgIhJBgICAgHhHBEAgDCkCJCEZIAFBwAFqIAFBKGopAwA3AgAgAUGAgICAeDYCrAEgAUGAgICAeDYCoAEgAUGAgICAeDYClAEgAUGAgICAeDYCiAEgAUEANgKAASABQQA2AnggASABKQMgNwK4ASABQoCAgICAgICgBjcC2AEgASADNgLUASABIAI2AtABIAEgCjYCzAEgASAANgLIASABQYgBahCXMAsgDCkCCCEaIAwpAhAhGyABQcABaiABQShqKQMANwIAIAFBgICAgHg2AqwBIAFBgICAgHg2AqABIAFBgICAgHg2ApQBIAEgGTcCjAEgASASNgKIASABIBs3AoABIAEgGjcCeCABIAEpAyA3ArgBIAFCgICAgICAgKAGNwLYASABIAM2AtQBIAEgAjYC0AEgASAKNgLMASABIAA2AsgBIAFB2ABqIQMjAEHwAWsiACQAIAFB+ABqIgIoAlAhCyAAIAIoAlg2AhQgAikCFCEZIAIoAhAhBSAAQSBqIAJBJGooAgA2AgAgACACKQIcNwMYIABBMGogAkEwaigCADYCACAAIAIpAig3AyggAigCACETIAIoAgQhFCACKAIIIRUgAigCDCEWIAAgAigCYDYCOCACKAJcIQkgCygCCCEHAkAgBUGAgICAeEcEQCAAIBk3AkAgACAFNgI8DAELIABBPGogC0EIaigCWEGQ0MMAEIo7CwJAAn8CQAJAQRhBBBCtNiIFBEAgBUKBgICAEDcCACAFIAJBQGsiDykCADcCCCAFQRBqIA9BCGopAgA3AgAgAEHQAGogAEHEAGooAgA2AgAgACALNgJYIAAgBTYCVCAAIAApAjw3A0ggACAHIAkgByAJSRs2AsQBIABBgICAgHg2ArgBIABB4ABqIABBuAFqIgsgAkE0ahDrJwJAIAAoAihBgICAgHhGDQAgACgCMCIJRQ0AIAAoAiwiBSAJQQN0aiEXIAtBBHIhCwNAIABB4ABqEJAjRQ0BAkAgBSgCACAFQQRqIgkoAgAoAgwRBAAiBygCAEGAgICAeEcEQCAAQbgBaiAHEOceDAELIABBgICAgHg2ArgBCyAAQfgAaiAAQcABaigCADYCACAAIAApArgBNwNwIABB8ABqIhAgAEEYahCRFCAAQbDWwwA2ApQBIAAoAhQhByAAQQA2ApwBIAAgAEHIAGo2ApABIAAgAEE4ajYCmAEgAEG4AWogAEGQAWogB0EIakEAIAcbIAUoAgAgCSgCACgCDBEEABCUGCAAKALAASEHIAAoArwBIQ8gACgCuAEiGEEIRwRAIAMgACkCxAE3AhQgA0EcaiAAQcwBaigCADYCACADIAc2AhAgAyAPNgIMIAMgGDYCCCADQYGAgIB4NgIAIBAQhjAMBAsgAEGYAWogAEHoAGoiECkCADcDACAAIAApAmA3A5ABIABBuAFqIABBkAFqIA8gByAFKAIAIAkoAgAQrQYgAEHoAWoiCSALQQhqKQIANwMAIAAgCykCADcD4AEgACgCuAEiB0EIRwRAIAAoAswBIQUgAyAAKQPgATcCDCADIAU2AhwgAyAHNgIIIANBgYCAgHg2AgAgA0EUaiAJKQMANwIAIABB8ABqEIYwDAULIBAgCSkDADcDACAAIAApA+ABNwNgIABB8ABqEIYwIAVBCGoiBSAXRw0ACwsgAEGw1sMANgKUASAAKAIUIQUgAEEANgKcASAAIABByABqNgKQASAAIABBOGo2ApgBIABBuAFqIABBkAFqIAVBCGpBACAFGyAAQRhqEJQYIAAoAsABIQsgACgCvAEhCSAAKAK4ASIFQQhHBEAgAyAAKQLEATcCFCADQRxqIABBzAFqKAIANgIAIAMgCzYCECADIAk2AgwgAyAFNgIIIANBgYCAgHg2AgAMAgsgAEHoAWogAEHoAGopAwA3AwAgACAAKQNgNwPgASAAQQhqIAAoAlhBCGoQhDwgACAAKQMINwLAASAAIAAoAkwiBTYCuAEgACAFIAAoAlBBAnRqNgK8ASAAQbgBaiIFIABB4AFqIAUQ3B8QnCwgAEGoAWogAEHQAWopAwA3AwAgAEGwAWogAEHYAWooAgA2AgAgACAWNgK8ASAAIBU2ArgBIAAgACkDyAE3A6ABIAAgFDYCnAEgACATNgKYASAAIAApA7gBNwOQASAFIABBkAFqEMEFIABB/ABqIgcgBRDvDiADIAkgCyAHEPkUIABByABqEKMlAkAgACgCOCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAAQThqEIEsCyAAQShqEJ4vIABBGGoQhjACQCAAKAIUIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIABBFGoQ2x4LIAIoAlQiAyADKAIAIgNBAWs2AgAgA0EBRw0EIAJB1ABqDAMLQQRBGBCjPQALIABB4ABqEI4wCyAAQcgAahCjJQJAIAAoAjgiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAEE4ahCBLAsgAEEoahCeLyAAQRhqEIYwAkAgACgCFCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAAQRRqENseCyACKAJUIgMgAygCACIDQQFrNgIAIANBAUcNASACQdQAagsQ+CMLIABB8AFqJAAgASgCWCIAQYGAgIB4RgRAIAFBzABqIAFB8ABqKQMAIhk3AgAgAUHEAGogAUHoAGopAwAiGjcCACABIAEpA2AiGzcCPCABQYgBaiAZNwMAIAFBgAFqIBo3AwAgASAbNwN4IAZBBGogAhDIJiAGQQE2AgAMAwsgAUHQAGogAUH0AGooAgAiAjYCACABQcgAaiABQewAaikCACIZNwMAIAFBQGsgAUHkAGopAgAiGjcDACABIAEpAlwiGzcDOCABQZQBaiACNgIAIAFBjAFqIBk3AgAgAUGEAWogGjcCACABIBs3AnwgASAANgJ4IAFBADYCQCABQoCAgIDAADcCOCABQdgAaiABQfgAahCHBiABKAJYIgJBAkYNASABQdwAaiEAA0AgAkEBcQRAQRRBBBCtNiICRQRAQQRBFBCjPQALIAZBBGoiAyACNgIEIANBADYCACACIAApAgA3AgAgAkEQaiAAQRBqKAIANgIAIAJBCGogAEEIaikCADcCACAGQQE2AgAgAUH4AGoQ9x8gAUE4aiIAEN4jIAAQ4DsMBAsgASgCQCICIAEoAjhGBEAgAUE4akHg18MAEK8oCyABKAI8IAJBFGxqIgMgACkCADcCACADQQhqIABBCGopAgA3AgAgA0EQaiAAQRBqKAIANgIAIAEgAkEBajYCQCABQdgAaiABQfgAahCHBiABKAJYIgJBAkcNAAsMAQsACyABQfgAahD3HyAGQQxqIAFBQGsoAgA2AgAgBiABKQI4NwIEIAYgCjYCECAGQQA2AgAgAUEQahCyHwwDCyAKIAooAgAiAEEBazYCACAAQQFGBEAgAUE0ahD4IwsgAUEQahCyHyASQYCAgIB4RwwBCyABQQxqIAEoAgQgASgCCCABKAIAKAIQEQEAQQALDQAgDCgCIEGAgICAeEYNACAMQSBqEOk7CyAMQSxqEJgwIAFB4AFqJAAgBEEQaiIAIARBKGopAgA3AwAgBCAEKQIgNwMIIAQoAhxBAUYEQCAEQYABaiAAKQMANwMAIAQgBCkDCDcDeCAEQfgAahDTGSEAIA1BgICAgHg2AgAgDSAANgIEDAELIA0gBCkDCDcCACANQQhqIAApAwA3AgALIARBsAFqJAACfyAIKAIgQYCAgIB4RgRAQQEhESAIKAIkDAELIAhBOGogCEEoaikCADcDACAIIAgpAiA3AzAjAEEgayIAJAAgAEEYaiAIQTBqIgFBCGopAgA3AgAgAEEANgIMIAAgASkCADcCECAAQQxqEJ4nIABBIGokAEEIagshACAOIBEgABCBLSAIQUBrJAAgDigCACAOKAIEIA4oAgggDkEQaiQAC8oCAQZ/IwBBEGsiAiQAIwBBQGoiASQAIAFBEGoiAyAAELIWIwBBEGsiACQAIAMQ8S0hBkEUQQQQrTYiBEUEQEEEQRQQoz0ACyAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAAIAY2AgwgAEEBNgIIIAAgBDYCBCAAQQE2AgAgAUEkaiAAENkHIABBEGokACACAn8gASgCJEGAgICAeEYEQEEAIQAgASgCKCEDQQEMAQsgAUE4aiABQSxqKAIANgIAIAEgASkCJDcDMCABQQhqIAFBMGpB0LjMABCQISABIAEoAgggASgCDBC1NkEAIQMgASgCBCEFIAEoAgAhAEEACzYCDCACIAM2AgggAiAFNgIEIAIgADYCACABQUBrJAAgAigCACACKAIEIAIoAgggAigCDCACQRBqJAALxQUCCn8CfiMAQRBrIgQkACMAQTBrIgEkACABQRRqIQMgABDMISEFIwBBwAFrIgAkACAAIAU2AgAgAEEANgIMIABCgICAgBA3AgQgAEG4AWoiAhC9LyAAQfgAaiIGIABBBGogBUEIaiACEKoVAkACQAJAAkAgACgCoAEiB0GAgICAeEYEQCAAQeAAaiAAQYgBaiICKAIAIgc2AgAgAEHYAGogAEGAAWoiCCkDACILNwMAIAAgACkDeCIMNwNQIAIgBzYCACAIIAs3AwAgACAMNwN4IAYQ1BkhAiADQYCAgIB4NgIAIAMgAjYCBAwBCyAAQdAAaiICIABB+ABqIgZBKPwKAAAgAEHMAGogAEG0AWooAgA2AgAgAEHEAGogAEGsAWopAgA3AgAgACAAKQKkATcCPCAAQRBqIgggAkEo/AoAACAAIAc2AjggAiAIEKsVIABBOGohAiAAKAJQIgdBk4CAgHhGDQEgAEGEAWogAEHcAGopAgA3AgAgACAAKQJUNwJ8IAAgBzYCeCAGENQZIQYgA0GAgICAeDYCACADIAY2AgQgAEEYahDtJiACEOM8CyAAQQRqEN47IAUgBSgCACIDQQFrNgIAIANBAUYNAQwCCyAAQRhqEO0mIAIQ4zwgA0EIaiAAQQxqKAIANgIAIAMgACkCBDcCACAFIAUoAgAiA0EBazYCACADQQFHDQELIAAQ+CMLIABBwAFqJAAgBAJ/IAEoAhRBgICAgHhGBEBBACEAIAEoAhghCUEBDAELIAFBKGogAUEcaigCADYCACABIAEpAhQ3AyAgAUEIaiABQSBqQYDHzAAQkCEgASABKAIIIAEoAgwQtTYgASgCBCEKIAEoAgAhAEEACzYCDCAEIAk2AgggBCAKNgIEIAQgADYCACABQTBqJAAgBCgCACAEKAIEIAQoAgggBCgCDCAEQRBqJAALlwcBDH8jAEEQayIJJAAjAEEgayIEJAAgBEEUaiAAENEkIAQoAhQgBEEIaiABIAIQ+iggBCgCCCINIQEgBCgCDCEAIwBBMGsiBSQAIAVBCGohDCgCAEEIaiEHIwBB4ABrIgIkACACIAA2AhQgAiABNgIQIAcoAgRBAnQhAyAHKAIAQQhqIQZBfyEIIAJBCGoiCgJ/A0BBACADRQ0BGiADQQRrIQMgCEEBaiEIIAYoAgAhCyAGQQRqIQYgCygCQCALKAJEIAEgABDBLkUNAAsgBkEEaws2AgQgCiAINgIAAn8gAigCDEUEQCAHKAIAQQhqIgYgBygCBEECdGohCiMAQSBrIgEkACABQRRqIAogBmtBAnZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYEQCADIAEoAhxB+NyHARD9LwALIAFBEGoiDkEANgIAIAEgASgCHDYCDCABIAM2AgggCiAGa0ECdiIIIAFBCGoiBygCACAHKAIIIgNrSwRAIAcgAyAIQQRBBBDcKCAHKAIIIQMLIAJBLGohCyAHIAYgCkcEfyADIAhqIAcoAgQgA0ECdGohAwNAIAMgBigCAEE8ajYCACAGQQRqIQYgA0EEaiEDIAhBAWsiCA0ACwUgAws2AgggC0EIaiAOKAIANgIAIAsgASkCCDcCACABQSBqJAAgAkECNgI8IAJBxN2HATYCOCACQgI3AkQgAkGDHTYCXCACQccCNgJUIAIgAkHQAGo2AkAgAiALNgJYIAIgAkEQajYCUCACQRxqIAJBOGoQmQ4gC0EEQQQQ4B4gAigCHCEBIAIoAiAhAyAMIAIpAiQ3AgwgDCADNgIIQYWAgIB4DAELIAIoAgghAUGTgICAeAshAyAMIAE2AgQgDCADNgIAIAJB4ABqJAAgBSgCDCECAn8gBSgCCCIBQZOAgIB4RwRAIAVBLGogBUEYaigCADYCACAFIAUpAhA3AiQgBSACNgIgIAUgATYCHCAFQRxqENQZIQJBAQwBC0EACyEBIAQgAjYCBCAEIAE2AgAgBUEwaiQAIAQoAgQhASAEKAIAIQIgAARAIA0gAEEBEPg6CyAEKAIYQQA2AgAgBCgCHCIAIAAoAgBBAWsiADYCACAARQRAIARBHGoQhCYLIAkgAjYCCCAJIAFBACACQQFxIgAbNgIEIAlBACABIAAbNgIAIARBIGokACAJKAIAIAkoAgQgCSgCCCAJQRBqJAAL2AEBBH8jAEEQayICJAAjAEFAaiIBJAAgAUEUaiIDIAAQ+BcgAUEkaiADENkHIAICfyABKAIkQYCAgIB4RgRAQQAhACABKAIoIQNBAQwBCyABQThqIAFBLGooAgA2AgAgASABKQIkNwMwIAFBCGogAUEwakGk0MwAEJAhIAEgASgCCCABKAIMELU2QQAhAyABKAIEIQQgASgCACEAQQALNgIMIAIgAzYCCCACIAQ2AgQgAiAANgIAIAFBQGskACACKAIAIAIoAgQgAigCCCACKAIMIAJBEGokAAslACAAQeAAahDeOyAAQewAahCHMCAAQUBrEPgmIABB+ABqEI4wCzUBAn8jAEEQayIAJAAgABCvPiIBNgIMIABBDGooAgAlAUQAAAAAAAAAABAdIABBEGokACABCyUBAn8jAEEgayIBJAAgAUEMaiICIAAQgBwgAhCSICABQSBqJAALJgEBfyMAQRBrIgEkACABQYEBNgIMIAAgAUEMahCiNiABQRBqJAALKQAgAEEINgIAIAAgAiABKAIMIgAgACACSxsiAjYCBCABIAAgAms2AgwLGgAgAEEIEO4oIABBMGoQ3jsgAEHIAGoQ4zwLGgAgAEEIEO4oIABBMGoQ6TsgAEHIAGoQ4zwLGgAgAEEIEO4oIABBMGoQ4zwgAEHIAGoQ4zwLMAACQAJAAkAgACgC0AFBAWsOAgABAgsgACABQQBBABDxDQ8LIAAgAUEAQQAQywsLCyQAIAEgA0YEQCABBEAgACACIAH8CgAACw8LIAEgAyAEELM7AAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4xUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4BUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4RUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4hUgAkHQAGokAAsnAQJ/IwBBMGsiAiQAIAJBCGoiAyABEJMXIAAgAxD7DCACQTBqJAALJwECfyMAQTBrIgIkACACQQhqIgMgARCTFyAAIAMQ/AwgAkEwaiQACycBAn8jAEEwayICJAAgAkEIaiIDIAEQkxcgACADEPoMIAJBMGokAAstACAAQRA2AgAgACABKAIENgIIIAAgASgCCEEEdDYCDCAAIAEoAgBBBHQ2AgQLLQAgAEEINgIAIAAgASgCBDYCCCAAIAEoAghBA3Q2AgwgACABKAIAQQN0NgIECy0AIABBAjYCACAAIAEoAgQ2AgggACABKAIIQQF0NgIMIAAgASgCAEEBdDYCBAstACAAQQQ2AgAgACABKAIENgIIIAAgASgCCEECdDYCDCAAIAEoAgBBAnQ2AgQLJwECfyMAQUBqIgIkACACQQRqIgMgARCjFCAAIAMQ5xIgAkFAayQACycBAn8jAEFAaiICJAAgAkEEaiIDIAEQpBQgACADEOgSIAJBQGskAAsnAQJ/IwBBQGoiAiQAIAJBCGoiAyABEOcTIAAgAxDrDyACQUBrJAALJwECfyMAQUBqIgIkACACQQhqIgMgARDnEyAAIAMQ7A8gAkFAayQACyoAIAAoAgAiACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAEgACgCDBECAAsnAQJ/IwBBQGoiAiQAIAJBBGoiAyABELUUIAAgAxCYFCACQUBrJAALJwECfyMAQUBqIgIkACACQQRqIgMgARCyFCAAIAMQmBQgAkFAayQACycBAn8jAEFAaiICJAAgAkEEaiIDIAEQsxQgACADEJkUIAJBQGskAAsnAQJ/IwBBQGoiAiQAIAJBBGoiAyABELQUIAAgAxCZFCACQUBrJAALKQECfyMAQeAAayICJAAgAkEEaiIDIAEQ2QEgACADEM0cIAJB4ABqJAALJAEBfyAAIAEgAiADIAQQ9QYEfyAAIAEgAiADIAQQ3gcFIAULCywAIABCADcDKCAAQgA3AyAgAEIANwMYIABCADcDCCAAQgE3AwAgAEICNwMQC1EBAX8jAEEQayIDJAAgAyACNgIMIAMgATYCCCADIAA2AgQjAEEQayIAJAAgACADQQRqIgEpAgA3AgggAEEIakG0tokBIAEoAghBAUEAEPMXAAsnACAAIAEgACgCBEEBcXJBAnI2AgQgACABaiIAIAAoAgRBAXI2AgQL/AECAn8BfiMAQRBrIgIkACACQQE7AQwgAiABNgIIIAIgADYCBCMAQRBrIgEkACACQQRqIgApAgAhBCABIAA2AgwgASAENwIEIwBBEGsiACQAIAFBBGoiASgCACICKAIMIQMCQAJAAkACQCACKAIEDgIAAQILIAMNAUEBIQJBACEDDAILIAMNACACKAIAIgIoAgQhAyACKAIAIQIMAQsgAEGAgICAeDYCACAAIAE2AgwgAEGYtokBIAEoAgQgASgCCCIALQAIIAAtAAkQ8xcACyAAIAM2AgQgACACNgIAIABB/LWJASABKAIEIAEoAggiAC0ACCAALQAJEPMXAAvECQIOfwF+IwBBEGsiCSQAEN8SIgMgASYBIwBB0ANrIgYkACAGIAAQlRogBkGYAWohCyMAQeABayIEJAAgBEEoaiEFIwBBMGsiAiQAIAIgAyIANgIMAkAgAkEMahDPLEUEQCACQRBqIAAQngYgBQJ/IAIoAhBFBEAgBSACKAIUNgIEQQEMAQsgBSACKQMQNwMIIAVBIGogAkEoaikDADcDACAFQRhqIAJBIGopAwA3AwAgBUEQaiACQRhqKQMANwMAQQALNgIADAELIAVBADYCACAFQQA2AgggAEGEAUkNACAAEPIfCyACQTBqJAACQCAEKAIoQQFGBEAgBCgCLBCAGCEAIAtCAjcDACALIAA2AgggBhDMLAwBCyAEQQhqIgAgBEE8aikCADcDACAEQRBqIgMgBEHEAGopAgA3AwAgBEEYaiICIARBzABqKAIANgIAIAQgBCkCNDcDAAJAIAQoAjAiBQRAIARBzAFqIAApAwA3AgAgBEHUAWogAykDADcCACAEQdwBaiACKAIANgIAIAQgBTYCwAEgBCAEKQMANwLEASAEQShqIgMgBEHAAWoiDBD4KCAEQRxqIQUjAEFAaiIAJAAgACADEN0oAkACQAJAAkAgACgCACICRQ0AIAAoAgQhByAAQSBqIgogAhDdICAAQRRqIAcQ3SAgACgCICIIQYCAgIB4Rg0AIAApAiQhECAKQQQgAygCGEEBaiICQX8gAhsiAiACQQRNG0EAQQRBGBCgGCAAKAIkIQcgACgCIEEBRg0CIAAoAigiAiAQNwIEIAIgCDYCACACIAApAhQ3AgwgAkEUaiAAQRxqKAIANgIAIABBEGoiDUEBNgIAIAAgAjYCDCAAIAc2AgggAEE4aiADQRhqKQMANwMAIABBMGogA0EQaikDADcDACAAQShqIANBCGopAwA3AwAgACADKQMANwMgIABBCGohAiMAQTBrIgMkACADQRBqIAoQ3SgCQCADKAIQIgdFDQAgAygCFCEIIANBIGohDgNAIANBJGogBxDdICADQRhqIAgQ3SAgAygCJCIPQYCAgIB4Rg0BIAMpAighECACKAIIIgcgAigCAEYEQCACIAcgCigCGEEBaiIIQX8gCBtBBEEYENAoCyACKAIEIAdBGGxqIgggEDcCBCAIIA82AgAgCCADKQIYNwIMIAhBFGogDigCADYCACACIAdBAWo2AgggA0EIaiAKEN0oIAMoAgwhCCADKAIIIgcNAAsLIANBMGokACAFQQhqIA0oAgA2AgAgBSAAKQIINwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAEFAayQADAELIAcgACgCKEHkgcMAEP0vAAsgDBCTJwwBCyAEQYCAgIB4NgIcCyAEQShqIgAgBkGYAfwKAAAgAEHsAGoQri8gAEH0AGogBEEcaiIDQQhqKAIANgIAIAAgAykCADcCbCALIABBmAH8CgAACyAEQeABaiQAIAkCfyAGKQOYAUICUQRAIAYoAqABIQBBAQwBCyAGQbgCaiAGQZgBakGYAfwKAAAgBkEANgKwAiAGQbACahDRKUEIaiEAQQALIAAQgS0gBkHQA2okACAJKAIAIAkoAgQgCSgCCCAJQRBqJAAL/AgCCn8DfiMAQRBrIgYkACMAQSBrIgQkACAEQQhqIAAgARD6KCAEQRRqIgAgBCgCCCAEKAIMEI81IwBBIGsiAyQAAn8gACgCCEUEQEHgmMMAQSkQlD4hASAAEN47QQEMAQsgA0EIaiAAQQhqKAIANgIAIAMgACkCADcDACADQRBqIQcjAEHQAmsiACQAIABBCGoiBSADEOcVIABBADYCGCAAQQA7ARwgAEGgAWohASMAQSBrIgIkACACQQhqIAUgAEEYahDRDiACKAIUIQggAigCECEJIAIoAgwhCgJAIAIoAggiC0EIRwRAIAEgAikDGDcDGCABIAg2AhQgASAJNgIQIAEgCjYCDCABIAs2AgggAUECNgIAIAVBDGogBSgCBCAFKAIIIAUoAgAoAhARAQAMAQsgAUGAgICAeDYCNCABQYCAgIB4NgIoIAFBgICAgHg2AhwgAUGAgICAeDYCECABQQA2AgggAUEANgIAIAFBgICAMjYCZCABQoAINwJcIAEgCDYCWCABIAk2AlQgASAKNgJQIAEgAikCCDcCOCABQUBrIAUpAgA3AgAgAUHIAGogBUEIaikCADcCAAsgAkEgaiQAAkACQAJAIAAoAqABIgJBAkYEQCAAQZQBaiAAQbgBaikDACIMNwIAIABBjAFqIABBsAFqIgIpAwAiDTcCACAAIAApA6gBIg43AoQBIAIgDDcDACAAQagBaiANNwMAIAAgDjcDoAEgByABEMgmDAELIABBmAFqIgEgAEG8AWooAgA2AgAgAEGQAWoiBSAAQbQBaikCADcDACAAQYgBaiIIIABBrAFqKQIANwMAIAAgACkCpAE3A4ABIABBiAJqIgkgAEHAAWpByAD8CgAAIABBJGogCCkDADcCACAAQSxqIAUpAwA3AgAgAEE0aiABKAIANgIAIAAgAjYCGCAAIAApA4ABNwIcIABBOGogCUHIAPwKAAAgACgCbCIBIAEoAgAiAkEBajYCACACQQBIDQEgB0EGNgIAIAcgATYCBCAAQeQAaiAAKAJcIAAoAmAgACgCWCgCEBEBACAAKAJoIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegAahCXFQsgACgCbCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAGoQ+CMLAkAgACgCcCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfAAahDbHgsgAEEoahCXMCAAQTRqEIYwIABBQGsQni8gAEHMAGoQjjAgACgCeCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfgAahCBLAsgAEHQAmokAAwBCwALIAMoAhQhASADKAIQIgBBBkcEQCADIAMpAhg3AhggAyABNgIUIAMgADYCECAHENMZIQFBAQwBC0EACyEAIAQgATYCBCAEIAA2AgAgA0EgaiQAIAQoAgQhACAGIAQoAgBBAXEEf0EBBSAAEP06IQBBAAsgABCBLSAEQSBqJAAgBigCACAGKAIEIAYoAgggBkEQaiQAC+wJAgR+G38jAEEQayIMJAAjAEEwayIHJAAgB0EYaiIWIAAQhyMgB0EEaiENIAcoAhghCSABEMwhIRAjAEHQAGsiACQAIAkoAgwiASABKAIAIghBAWo2AgACQCAIQQBOBEAgAEE8aiIIIAkQvBUgACABNgJIIAAgCSgCEDYCTCAAQSBqIQkjAEEwayIBJAAgASAQNgIEIAhBDGohDgJAAn8CQCAQQQhqIgYgCCgCDCITQQhqIgoQzxxFDQAgBkEYaiEXIAYoAggiFEEYayEYIAooAggiC0EIaiERIAspAwBCf4VCgIGChIiQoMCAf4MhAiAGKAIMIRIgBigCFCEZIAooAhQhBgNAAkAgBkUhGiAGRQ0AIAJQBEADQCALQcABayELIBEpAwAgEUEIaiERQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAZRQ0AIAZBAWshBiACQgF9IAKDIAsgAnqnQQN2QWhsaiIKQRBrIRsgCkEUayEcIBIgFyAKQRhrEPgLIgKncSEPIAJCGYhC/wCDQoGChIiQoMCAAX4hBUEAIRUDQAJAIA8gFGopAAAiAyAFhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEAgGygCACEdIBwoAgAhHgNAIB4gHSAYIAJ6p0EDdiAPaiAScUFobCIfaiIgKAIEICAoAggQwS4NAiACQgF9IAKDIgJQRQ0ACwsgAyADQgGGg0KAgYKEiJCgwIB/g1BFDQQgDyAVQQhqIhVqIBJxIQ8MAQsLIQIgCkEIaygCACAKQQRrKAIAIBQgH2oiCkEIaygCACAKQQRrKAIAEMEuDQELCyAaDAELQQALRQRAIAFBAjYCDCABQcj/hAE2AgggAUICNwIUIAFB7Bo2AiwgASAONgIoIAFB7Bo2AiQgASABQSBqNgIQIAEgAUEEaiIGNgIgIAlBCGogAUEIahCZDiAJQoGAgIDQgICAgH83AgAgASgCBCILIAsoAgAiC0EBazYCACALQQFGBEAgBhD4IwsgDigCACIGIAYoAgAiBkEBazYCACAGQQFGBEAgDhD4IwsgCBDDJyAIQQRBCBDgHgwBCyAJIBA2AhAgCUEANgIAIAkgCCkCADcCBCAJIAgoAhA2AhQgCUEMaiAIQQhqKAIANgIAIBMgEygCACIIQQFrNgIAIAhBAUcNACAOEPgjCyABQTBqJAAgAEEQaiIBIABBLGopAgA3AwAgAEEYaiIIIABBNGooAgA2AgAgACAAKQIkNwMIAkAgACgCIEEBRgRAIABBMGogCCgCADYCACAAQShqIAEpAwA3AwAgACAAKQMINwMgIAkQ1BkhASANQYCAgIB4NgIAIA0gATYCBAwBCyANIAApAwg3AgAgDUEQaiAIKAIANgIAIA1BCGogASkDADcCAAsgAEHQAGokAAwBCwALIBYQ+yogDAJ/IAcoAgRBgICAgHhGBEAgBygCCCEAQQEMAQsgB0EsaiAHQRRqKAIANgIAIAdBJGogB0EMaikCADcCACAHIAcpAgQ3AhwgB0EANgIYIAdBGGoQnydBCGohAEEACyIBNgIIIAwgAEEAIAEbNgIEIAxBACAAIAEbNgIAIAdBMGokACAMKAIAIAwoAgQgDCgCCCAMQRBqJAALpAQBCn8jAEEQayIFJAAQ3xIiAiABJgEjAEEgayIDJAAgA0EUaiAAENEkIANBCGohBiADKAIUIQQjAEHwAGsiACQAIABByABqIAIQngYgACgCTCECAkACQAJ/IAAoAkgiCEUEQCACEIAYIQJBAQwBCyAAQRhqIgkgAEHgAGopAwA3AwAgAEEQaiIKIABB2ABqKQMANwMAIAAgACkDUDcDCCAEKAIAIgQoAggiByAHKAIAIgtBAWo2AgAgACACNgIEIAAgCDYCACALQQBIDQEgBCgCDCECIABBKGogBEEQahCxLiAAIAI2AiQgACAHNgIgIABBIGoiAkEIahCTJyACQSBqIAkpAwA3AwAgAkEYaiAKKQMANwMAIAJBEGogAEEIaikDADcDACACIAApAwA3AwggAEHIAGoiBCACQSj8CgAAAn9BMEEIEK02IgIEQCACQoGAgIAQNwMAIAJBCGogBEEo/AoAACACDAELQQhBMBCjPQALIQJBAAshBCAGIAI2AgQgBiAENgIAIABB8ABqJAAMAQsACyADKAIMIQAgAygCCCADKAIYQQA2AgAgAygCHCICIAIoAgBBAWsiAjYCACACRQRAIANBHGoQhCYLQQEhAkEBcUUEQEEAIQJBACAAEJosQQhqIQALIAUgAjYCCCAFIABBACACGzYCBCAFQQAgACACGzYCACADQSBqJAAgBSgCACAFKAIEIAUoAgggBUEQaiQAC4QWAg9/An4jAEEQayIJJAAjAEEwayIHJAAgByAAIAEQ+iggB0EMaiEKIAcoAgAiDyEAIAcoAgQiDiECIwBBsAJrIgEkACABQgA3AwggASACNgIEIAEgADYCACABQYCAgIB4NgKAAiABQYABaiECIAFBgAJqIQgjAEGgAmsiACQAIABBCGogAUEIaikDADcDACAAQQA2AhggAEKAgICAEDcDECAAIAEpAwA3AwAgAEH4AWogABClCEEBIQMgAEH8AWohBAJAAkACQAJAIAAoAvgBQQFGBEAgAEHoAGogBEEQaigCACIFNgIAIABB4ABqIARBCGopAgAiETcDACAAIAQpAgAiEjcDWCACQSRqIAU2AgAgAkEcaiARNwIAIAIgEjcCFCACQYCAgIB4NgIQDAELIABBKGoiAyAEQQhqKQIANwMAIABBMGogBEEQaikCADcDACAAQThqIARBGGooAgA2AgAgACAEKQIANwMgIABBLGohDAJ/AkACQAJAAkACQAJAAkACQAJ/AkACQCAAKAIsBEAgAEHIAGogAygCACIDNgIAIAAgACkDICIRNwNAIANBBGohBSADQXtLDQYgBSAAKAJEIgRLDQcgAEH4AWoiBiARpyIFIAQgAyADIAVqIgsoAABrEPY0IAZBBhDMIEH//wNxIgYEQCADIAZqIgYgBEsNCSAFIAZqLQAAQQFGDQILIABB+AFqIgYgBSAEIAMgCygAAGsQ9jQgBkEGEMwgIgZB//8DcQ0CQQAMAwsgAEH4AWpBLEEAQQFBARCgGCAAKAL8ASEDIAAoAvgBQQFGDQ4gACgCgAIiBEGYz8wAQSz8CgAAIAJBLDYCICACIAQ2AhwgAiADNgIYIAJCgICAgMiBgICAfzcDEAwKCyAAQdgAaiAAQUBrELgUIAAoAlgiAw0DIABB+AFqQSpBAEEBQQEQoBggACgC/AEhAyAAKAL4AUEBRw0CDA0LIAMgBkH//wNxaiIDIARLDQYgAyAFai0AAAshAyAAQZoDNgJcIAAgAzoA2AEgAEEBNgL8ASAAQZDPzAA2AvgBIABCATcChAIgACAAQdgBajYCWCAAIABB2ABqNgKAAiACQRhqIABB+AFqEJkOIAJCgICAgMiBgICAfzcDEEEBDAgLIAAoAoACIgRBzM3MAEEq/AoAACACQSo2AiAgAiAENgIcIAIgAzYCGCACQoCAgIDIgICAgH83AxAMBgsgACAAKQJcNwJQIAAgAzYCTCAAQdgAaiIEIABBzABqELcDIABB+AFqIgZBnMnMABClKyAAQYgBakGwycwAKQMANwMAIABBqMnMACkDADcDgAEgACAAKQOAAjcDmAEgACAAKQP4ATcDkAFBgICAgHghAyAIKAIAQYCAgIB4RwRAIABB0AFqIAhBCGooAgAiAzYCACAAIAgpAgA3A8gBIAYgBCAAKALMASADEKcUIABB4AFqIgYgAEGEAmopAgA3AwAgAEHoAWoiAyAAQYwCaigCADYCACAAIAApAvwBNwPYASAAKAL4ASIFRQRAIAIgACkD2AE3AhQgAkGAgICAeDYCECACQSRqIAMoAgA2AgAgAkEcaiAGKQMANwIAIABByAFqEOk7IABBgAFqEOwmIAQQsSxBAAwICyAAQagBaiAAQZgCaikDADcDACAAQbgBaiAAQeABaikDADcDACAAQcABaiADKAIANgIAIAAgACkDkAI3A6ABIAAgACkD2AE3A7ABIAApAswBIREgACgCyAEhAwsgAEHwAWoiCCAAQRhqKQMANwMAIABB6AFqIgYgAEEQaikDADcDACAAQeABaiILIABBCGopAwA3AwAgACAAKQMANwPYASAAQfgBaiINIABB2ABqQSj8CgAAQTBBCBCtNiIERQ0EIARCgYCAgBA3AwAgBEEIaiANQSj8CgAAIAJB8ABqIABBmAFqKQMANwMAIAJB6ABqIABBkAFqKQMANwMAIAJB4ABqIABBiAFqKQMANwMAIAIgACkDgAE3A1ggAiAAKQOwATcCNCACQTxqIABBuAFqKQMANwIAIAJBxABqIABBwAFqKAIANgIAIAIgACkDoAE3A0ggAkHQAGogAEGoAWopAwA3AwAgAkEYaiAIKQMANwMAIAJBEGogBikDADcDACACQQhqIAspAwA3AwAgAiAAKQPYATcDACACQQA7AXwgAiAENgJ4IAIgBTYCMCACIBE3AiQgAiADNgIgIAAoAixFDQggDBDPLwwICyADIAVB0MzMABCxOwALIAUgBEHQzMwAELA7AAsgBiAEQYzJzAAQrzsACyADIARBjMnMABCvOwALQQhBMBCjPQALQQELIQMgACgCLEUNACAMEM8vCyAAQRBqEN47IANFDQAgCCgCAEGAgICAeEYNACAIEOk7CyAAQaACaiQADAELIAMgACgCgAJBsMzMABD9LwALAkAgASgCkAEiA0GAgICAeEYEQCABQagCaiABQaQBaigCACIANgIAIAFBoAJqIAFBnAFqKQIAIhE3AwAgASABKQKUASISNwOYAiABQZABaiAANgIAIAFBiAFqIBE3AwAgASASNwOAASACENQZIQAgCkGAgICAeDYCACAKIAA2AgQMAQsgAUHoAGoiAiABQYgBaiIEKQMANwMAIAFBoAJqIgUgAUGcAWoiCCkCADcDACABQagCaiIMIAFBpAFqIgYoAgA2AgAgASABKQOAATcDYCABIAEpApQBNwOYAiABQRBqIgsgAUGoAWoiDUHQAPwKAAAgASgC/AEhECABKAL4ASEAIAYgDCgCADYCACAIIAUpAwA3AgAgASABKQOYAjcClAEgACAAKAIAIgVBAWo2AgACQCAFQQBOBEAgBCACKQMANwMAIAEgADYCcCABIAEpA2A3A4ABIAEgAzYCkAEgAUEANgJ8IAFCgICAgMAANwJ0IA0gC0HQAPwKAAAgASAQNgL8ASABIAA2AvgBIAFBmAJqIAFBgAFqEO8MIAFBnAJqIQIgASgCmAINAQNAIAEoApwCQYCAgIB4RgRAIAFBgAFqENAbIApBCGogAUH8AGooAgA2AgAgCiABKQJ0NwIAIAogADYCDAwECyABQZACaiIFIAJBEGooAgA2AgAgAUGIAmoiCCACQQhqKQIANwMAIAEgAikCADcDgAIgASgCfCIDIAEoAnRGBEAgAUH0AGpBlNHMABCvKAsgASgCeCADQRRsaiIEIAEpA4ACNwIAIARBCGogCCkDADcCACAEQRBqIAUoAgA2AgAgASADQQFqNgJ8IAFBmAJqIAFBgAFqEO8MIAEoApgCRQ0ACwwBCwALIAFBkAJqIAJBEGooAgAiAzYCACABQYgCaiACQQhqKQIAIhE3AwAgASACKQIAIhI3A4ACIAFBqAJqIAM2AgAgAUGgAmogETcDACABIBI3A5gCIAFBmAJqENQZIQIgCkGAgICAeDYCACAKIAI2AgQgAUGAAWoQ0BsgAUH0AGoiAhDeIyACQQRBFBDgHiAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHwAGoQ+CMLIAFBsAJqJAAgDgRAIA8gDkEBEPg6CwJ/IAcoAgxBgICAgHhGBEBBASEAIAcoAhAMAQsgB0EoaiAHQRRqKQIANwIAIAcgBykCDDcCIEEAIQAgB0EANgIcIAdBHGoQnidBCGoLIQEgCSAANgIIIAkgAUEAIAAbNgIEIAlBACABIAAbNgIAIAdBMGokACAJKAIAIAkoAgQgCSgCCCAJQRBqJAALKgACQAJAAkAgAC0ApAEOBAACAgECCyAAQZgBahDeOw8LIABBCGoQzSILCzQBAX9BECEBAkACQAJAIAAtAPQCDgQBAgIAAgsgAEH4AWoQlyxBkAEhAQsgACABahDSFgsLNAEBf0EQIQECQAJAAkAgAC0A5AIOBAECAgACCyAAQfABahCYLEGIASEBCyAAIAFqENIWCwsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEM0bIAFBEGokAAsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEMwbIAFBEGokAAsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEMsbIAFBEGokAAsoAAJAAkACQCAALQAcDgQAAgIBAgsgAEEIahDeOw8LIABBGGoQsCwLCyYAIAApAwBCA1IEQCAAEPErCyAAKQNoQgNSBEAgAEHoAGoQ8SsLCycBAX8gACABKAIAIgEoAkwiAgR/IAEoAlAFIAELNgIEIAAgAjYCAAsxACAAQQA7ATggAEIENwMwIABCADcDKCAAQoCAgIDAADcDICAAQgI3AxggAEIANwMACywBAX8gAS0ADyICQRBPBEAgAkEPQez2wwAQsDsACyAAIAI2AgQgACABNgIACy4AAkAgAEGBgICAeEcEQCAADQFB7K7MAEERQYCvzAAQnykACw8LIAAgARCjPQALJgAgACABNgIIIAAgAkEAIAFBAXEiARs2AgQgAEEAIAIgARs2AgALJAAgAEEUaiAAKAIMIAAoAhAgACgCCCgCEBEBACAAQShqEN47Cx4AIABBCBDuKCAAQTBqQQRBDBDgHiAAQcgAahDjPAskACAAQRxqIAAoAhQgACgCGCAAKAIQKAIQEQEAIABBQGsQ3jsLjAEBA38gACgCCCICIAFPBEAgACABEPQ0DwsgACABIAJrIgIQ7S0gACgCBCAAKAIIIgFBAXRqIQMCQAJAIAJBAk8EQCACQQFrIQQDQCADQQA7AQAgA0ECaiEDIARBAWsiBA0ACyABIAJqQQFrIQEMAQsgAkUNAQsgA0EAOwEAIAFBAWohAQsgACABNgIICyUBAX8gACgCCCICIAFPBEAgACABEPQ0DwsgACABIAJrQQAQih8LIwEBfyAAKAIIIgIgAU8EQCAAIAEQ9DQPCyAAIAEgAmsQix8LKQEBfyAAKAJYIgIgAU0EQCABIAJB5PfPABDDIQALIAAoAlQgAUEGdGoLKgEBfyAAKAIoIgIgAU0EQCABIAJB9PfPABDDIQALIAAoAiQgAUHAAmxqCzABAX8gACgCDCIBIAAoAgAiACgCBEsEQEGU8dAAQSxBwPHQABCfKQALIAAgATYCCAslAQF/IAAEQCABKAIEIgIEQCABKAIIIAAgAhEAAA8LIAAQ0jULCx0AIAJBAnYgAGytIAFnQSBqQT9zQR5srX1CgA98CyUAIAAgAUGID2ogAUHwDWpBACACIAMQ2gciAARAIAEQsRkLIAALlgEBA38gACgCCCICIAFPBEAgACABNgIIDwsgASACayICIAAoAgAgACgCCCIBa0sEQCAAIAEgAhDPKCAAKAIIIQELIAAoAgQiBCABaiEDAkACQCACQQJPBEAgAkEBayICBEAgA0EAIAL8CwALIAQgASACaiIBaiEDDAELIAJFDQELIANBADoAACABQQFqIQELIAAgATYCCAspAQF/IAAoAggiAiABTQRAIAEgAkHY/4QBEMMhAAsgACgCBCABQQN0agssAQF/QQEhAgJAIAAgARDpEg0AIAFB1AAQgzYNACAAQQRqIAEQkA4hAgsgAgsrAQF/QQEhAgJAIAAgARDpEg0AIAFBIBCDNg0AIABBBGogARCQDiECCyACCykBAX4gACABrcIiAjcDACAAIAJCP4ciAjcDGCAAIAI3AxAgACACNwMICykBAX4gACABrcMiAjcDACAAIAJCP4ciAjcDGCAAIAI3AxAgACACNwMIC2oBA38gACAAKAIIIgFBAWs2AgggAUEBRgRAIwBBEGsiASQAIAAoAgAgACgCBCIDQQEQ0TRFBEBBiIWIAUErIAFBD2pB+ISIAUHwh4gBENUeAAsgA0EBEPg6IAFBEGokACAAQQxBBBD4OgsLIwEBfyAAKAIIIgIgAU8EQCAAIAE2AggPCyAAIAEgAmsQ0xoLLQAgASgCACACIAMgASgCBCgCDBEGACECIABBADoABSAAIAI6AAQgACABNgIACzIBAX8gASgCAEH87okBQQEgASgCBCgCDBEGACECIABBADoABSAAIAI6AAQgACABNgIAC68rBCx/CX4CfQJ8IwBBEGsiHyQAIwBB0AFrIhokACAaQegAaiIpIAAQhSMgGkEIaiEQIBooAmgoAiBBCGohDCMAQdAAayIFJAAgDCkDACEzIAwoAjAhKgJAIAwoAghBgICAgHhHBEAgBUEoaiAMQQhqEN0gDAELIAVBgICAgHg2AigLAkAgDCgCFEGAgICAeEcEQCAFQTRqIAxBFGoQxBAMAQsgBUGAgICAeDYCNAsgDCgCLCImICYoAgAiAEEBajYCAAJAIABBAE4EQAJAIAwoAiBBgICAgHhHBEAgBUFAayAMQSBqENYeDAELIAVBgICAgHg2AkALIAVBGGogBUEwaigCADYCACAFQQhqIAVBPGooAgA2AgAgBSAFKQIoNwMQIAUgBSkCNDcDACAFQRxqIRIjAEFAaiIJJAAgDEHQAGoiACgCBCELIAlBNGogACgCCCIUQQBBCEHAABCgGCAJKAI4IQACQAJAIAkoAjRBAUcEQCAJKAI8IRsCQCAARQ0AIBRBBnQhASAAIREDQCABIAZGDQEgCUEoaiAGIAtqIgdBIGoQwAEgB0EQaikDACEtAkAgB0EsaiIcKAIAQYCAgIB4RwRAIAlBNGogHBCTGAwBCyAJQYCAgIB4NgI0CyAHQRhqKQMAIS4gB0E8aigCACIcIBwoAgAiA0EBajYCACADQQBIDQMgB0E4aigBACEDIAdBCGopAwAhLyAHKQMAITAgCUEgaiAJQTBqKAIAIgQ2AgAgCSAJKQIoIjE3AxggCUEQaiAJQTxqKAIAIgg2AgAgCSAJKQI0IjI3AwggBiAbaiIHQRhqIC43AwAgB0EQaiAtNwMAIAdBCGogLzcDACAHIDA3AwAgB0EgaiAxNwMAIAdBKGogBDYCACAHQSxqIDI3AgAgB0E0aiAINgIAIAdBPGogHDYCACAHQThqIAM2AgAgBkFAayEGIBFBAWsiEQ0ACwsgEiAUNgIIIBIgGzYCBCASIAA2AgAgCUFAayQADAILIAAgCSgCPEHQtcIAEP0vCwALAkAgDCgCOEGAgICAeEcEQCMAQRBrIhUkACAMQThqIgAoAgQhHiAVQQRqIAAoAggiJ0EAQQRBDBCgGCAVKAIIIRQgFSgCBEEBRwRAIAVBKGohICAVKAIMIRwCQCAURQ0AICdBDGwhIiAcIREgFCEJA0AgIkUNASAVQQRqISMjAEEgayIDJAAgHigCBCEIIANBEGogHigCCCIoQQBBBEEUEKAYIAMoAhQhGwJAAkAgAygCEEEBRwRAIAMoAhghCwJAIBtFDQAgKEEUbCEkIANBCGohFiALIRIgGyEHA0AgJEUNAQJAAkACQAJAAkACQAJAAkACQCAIKAIAIitBAWsOCAABAgMEBQYHCAsgA0EQaiEKQQAhBCMAQUBqIgEkACAIQQRqIgAoAgQhFyABQTRqIAAoAggiDUEAQQhBMBCgGCABKAI4IQACQCABKAI0QQFHBEAgASgCPCEOAkAgAEUNACANQTBsIRMgACEGA0AgBCATRg0BIAQgF2oiAkEIaikDACEtIAJBKWotAAAhDyACQShqLQAAIRggAikDACEuAkAgAkEQaiIZKAIAQYCAgIB4RwRAIAFBKGogGRClHQwBCyABQYCAgIB4NgIoCwJAIAJBHGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIhk2AgAgASABKQIoIi83AxggAUEQaiABQTxqKAIAIh02AgAgASABKQI0IjA3AwggBCAOaiICQQhqIC03AwAgAiAuNwMAIAJBEGogLzcDACACQRhqIBk2AgAgAkEcaiAwNwIAIAJBJGogHTYCACACQSlqIA86AAAgAkEoaiAYOgAAIARBMGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwMCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwHCyADQRBqIQpBACEEIwBBQGoiASQAIAhBBGoiACgCBCEXIAFBNGogACgCCCINQQBBCEE4EKAYIAEoAjghAAJAIAEoAjRBAUcEQCABKAI8IQ4CQCAARQ0AIA1BOGwhEyAAIQYDQCAEIBNGDQEgBCAXaiICQQhqKQMAIS0gAkEcaigCACEPIAJBGGooAgAhGCACQRRqKAIAIRkgAkEQaigCACEdIAIpAwAhLgJAIAJBIGoiISgCAEGAgICAeEcEQCABQShqICEQpR0MAQsgAUGAgICAeDYCKAsCQCACQSxqIgIoAgBBgICAgHhHBEAgAUE0aiACEKUdDAELIAFBgICAgHg2AjQLIAFBIGogAUEwaigCACIhNgIAIAEgASkCKCIvNwMYIAFBEGogAUE8aigCACIlNgIAIAEgASkCNCIwNwMIIAQgDmoiAkEcaiAPNgIAIAJBGGogGDYCACACQRRqIBk2AgAgAkEQaiAdNgIAIAJBCGogLTcDACACIC43AwAgAkEgaiAvNwMAIAJBKGogITYCACACQSxqIDA3AgAgAkE0aiAlNgIAIARBOGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwLCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwGCyADQRBqIQpBACEEIwBBQGoiASQAIAhBBGoiACgCBCEXIAFBNGogACgCCCINQQBBCEHIABCgGCABKAI4IQACQCABKAI0QQFHBEAgASgCPCEOAkAgAEUNACANQcgAbCETIAAhBgNAIAQgE0YNASAEIBdqIgJBKGopAwAhLSACQSBqKQMAIS4gAkEYaikDACEvIAJBEGopAwAhMCACQQhqKQMAITEgAikDACEyAkAgAkEwaiIPKAIAQYCAgIB4RwRAIAFBKGogDxClHQwBCyABQYCAgIB4NgIoCwJAIAJBPGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIg82AgAgASABKQIoIjQ3AxggAUEQaiABQTxqKAIAIhg2AgAgASABKQI0IjU3AwggBCAOaiICQShqIC03AwAgAkEgaiAuNwMAIAJBGGogLzcDACACQRBqIDA3AwAgAkEIaiAxNwMAIAIgMjcDACACQTBqIDQ3AwAgAkE4aiAPNgIAIAJBPGogNTcCACACQcQAaiAYNgIAIARByABqIQQgBkEBayIGDQALCyAKIA02AgggCiAONgIEIAogADYCACABQUBrJAAMAQsMCgsgAyAIQRBqKAIANgIcIBYgA0EYaikCADcDACADIAMpAhA3AwAMBQsgA0EQaiEKQQAhBCMAQYABayIBJAAgCEEEaiIAKAIEIRggAUH0AGogACgCCCINQQBBCEHIABCgGCABKAJ4IQACQCABKAJ0QQFHBEAgASgCfCEOAkAgAEUNACANQcgAbCEZIAFB0ABqIRcgACEGA0AgBCAZRg0BQQAhE0EAIQ8gBCAYaiICQRBqKAIAQQFGBEAgFyACQRxqKAIANgIAIAEgAkEUaikCADcDSEEBIQ8LIAJBIGooAgBBAUYEQCABQeAAaiACQSxqKAIANgIAIAEgAkEkaikCADcDWEEBIRMLIAJBCGopAwAhLSACKQMAIS4CQCACQTBqIh0oAgBBgICAgHhHBEAgAUHoAGogHRClHQwBCyABQYCAgIB4NgJoCwJAIAJBPGoiAigCAEGAgICAeEcEQCABQfQAaiACEKUdDAELIAFBgICAgHg2AnQLIAFBQGsiHSAXKAIANgIAIAEgASkDSDcDOCABQTBqIiEgAUHgAGooAgA2AgAgASABKQNYNwMoIAFBIGoiJSABQfAAaigCADYCACABIAEpAmg3AxggAUEQaiIsIAFB/ABqKAIANgIAIAEgASkCdDcDCCAEIA5qIgJBEGogDzYCACACQQhqIC03AwAgAiAuNwMAIAJBIGogEzYCACACQRRqIAEpAzg3AgAgAkEcaiAdKAIANgIAIAJBJGogASkDKDcCACACQSxqICEoAgA2AgAgAkEwaiABKQMYNwMAIAJBOGogJSgCADYCACACQTxqIAEpAwg3AgAgAkHEAGogLCgCADYCACAEQcgAaiEEIAZBAWsiBg0ACwsgCiANNgIIIAogDjYCBCAKIAA2AgAgAUGAAWokAAwBCyAAIAEoAnxB0LXCABD9LwALIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMADAQLIANBEGohCkEAIQQjAEFAaiIBJAAgCEEEaiIAKAIEIRcgAUE0aiAAKAIIIg1BAEEIQTgQoBggASgCOCEAAkAgASgCNEEBRwRAIAEoAjwhDgJAIABFDQAgDUE4bCETIAAhBgNAIAQgE0YNASAEIBdqIgJBCGopAwAhLSACQRxqKgIAITYgAkEYaigCACEPIAJBFGoqAgAhNyACQRBqKAIAIRggAikDACEuAkAgAkEgaiIZKAIAQYCAgIB4RwRAIAFBKGogGRClHQwBCyABQYCAgIB4NgIoCwJAIAJBLGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIhk2AgAgASABKQIoIi83AxggAUEQaiABQTxqKAIAIh02AgAgASABKQI0IjA3AwggBCAOaiICQRxqIDY4AgAgAkEYaiAPNgIAIAJBFGogNzgCACACQRBqIBg2AgAgAkEIaiAtNwMAIAIgLjcDACACQSBqIC83AwAgAkEoaiAZNgIAIAJBLGogMDcCACACQTRqIB02AgAgBEE4aiEEIAZBAWsiBg0ACwsgCiANNgIIIAogDjYCBCAKIAA2AgAgAUFAayQADAELDAgLIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMADAMLIANBEGohCkEAIQQjAEFAaiIBJAAgCEEEaiIAKAIEIRcgAUE0aiAAKAIIIg1BAEEIQcgAEKAYIAEoAjghAAJAIAEoAjRBAUcEQCABKAI8IQ4CQCAARQ0AIA1ByABsIRMgACEGA0AgBCATRg0BIAQgF2oiAkEoaikDACEtIAJBIGopAwAhLiACQRhqKwMAITggAkEQaikDACEvIAJBCGorAwAhOSACKQMAITACQCACQTBqIg8oAgBBgICAgHhHBEAgAUEoaiAPEKUdDAELIAFBgICAgHg2AigLAkAgAkE8aiICKAIAQYCAgIB4RwRAIAFBNGogAhClHQwBCyABQYCAgIB4NgI0CyABQSBqIAFBMGooAgAiDzYCACABIAEpAigiMTcDGCABQRBqIAFBPGooAgAiGDYCACABIAEpAjQiMjcDCCAEIA5qIgJBKGogLTcDACACQSBqIC43AwAgAkEYaiA4OQMAIAJBEGogLzcDACACQQhqIDk5AwAgAiAwNwMAIAJBMGogMTcDACACQThqIA82AgAgAkE8aiAyNwIAIAJBxABqIBg2AgAgBEHIAGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwHCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwCCyADQRBqIAhBBGoQ/gggAyAIQRBqKAIANgIcIBYgA0EYaikCADcDACADIAMpAhA3AwAMAQsgA0EQaiAIQQRqEP4IIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMACyAIQRRqIQggEiArNgIAIBJBBGogAykDADcCACASQQxqIBYpAwA3AgAgEkEUaiESICRBFGshJCAHQQFrIgcNAAsLICMgKDYCCCAjIAs2AgQgIyAbNgIAIANBIGokAAwCCyAbIAMoAhhB0LXCABD9LwALIAAgASgCPEHQtcIAEP0vAAsgEUEIaiAVQQxqKAIANgIAIBEgFSkCBDcCACARQQxqIREgIkEMayEiIB5BDGohHiAJQQFrIgkNAAsLICAgJzYCCCAgIBw2AgQgICAUNgIAIBVBEGokAAwCCyAUIBUoAgxB0LXCABD9LwALIAVBgICAgHg2AigLAkAgDCgCREGAgICAeEcEQCMAQRBrIgMkACAMQcQAaiIAKAIEIQEgA0EEaiAAKAIIIgJBAEEEQQwQoBggAygCCCESIAMoAgRBAUcEQCAFQTRqIQQgAygCDCEbAkAgEkUNACACQQxsIR4gGyEAIBIhBgNAIB5FDQEgA0EEaiEMIwBBMGsiCyQAIAEoAgQhESALIAEoAggiFUEAQQRBGBCgGCALKAIEIRQCQCALKAIAQQFHBEAgCygCCCEcAkAgFEUNACAVQRhsIQggEUEMaiEHIAtBDGohFiAcIREgFCEJA0AgCEUNASALQRhqIAdBDGsQzhUCQCAHKAIAQYCAgIB4RwRAIAtBJGogBxClHQwBCyALQYCAgIB4NgIkCyAWIAspAiQ3AgAgC0EIaiIgIAtBIGooAgA2AgAgFkEIaiALQSxqKAIANgIAIAsgCykCGCItNwMAIBFBEGogC0EQaikDADcCACARQQhqICApAwA3AgAgESAtNwIAIBFBGGohESAIQRhrIQggB0EYaiEHIAlBAWsiCQ0ACwsgDCAVNgIIIAwgHDYCBCAMIBQ2AgAgC0EwaiQADAELIBQgCygCCEHQtcIAEP0vAAsgAEEIaiADQQxqKAIANgIAIAAgAykCBDcCACAAQQxqIQAgHkEMayEeIAFBDGohASAGQQFrIgYNAAsLIAQgAjYCCCAEIBs2AgQgBCASNgIAIANBEGokAAwCCyASIAMoAgxB0LXCABD9LwALIAVBgICAgHg2AjQLIBAgMzcDACAQIAUpAxA3AwggECAFKQMANwIUIBAgBSkDQDcDICAQICo2AjAgECAmNgIsIBAgBSkCHDcCUCAQQRBqIAVBGGooAgA2AgAgEEEcaiAFQQhqKAIANgIAIBBBKGogBUHIAGooAgA2AgAgEEHYAGogBUEkaigCADYCACAQQUBrIAVBMGooAgA2AgAgECAFKQIoNwI4IBBBzABqIAVBPGooAgA2AgAgECAFKQI0NwJEIAVB0ABqJAAMAQsACyApEOQqIB8CfyAaKAJYQYCAgIB4RgRAIBooAgghAEEBDAELIBpB8ABqIBpBCGpB4AD8CgAAIBpBADYCaAJ/QfAAQQgQrTYiAARAIABCgYCAgBA3AwAgAEEIaiAaQegAakHoAPwKAAAgAAwBC0EIQfAAEKM9AAtBCGohAEEACyAAEIEtIBpB0AFqJAAgHygCACAfKAIEIB8oAgggH0EQaiQAC3EBA38jAEEQayIBJAAjAEEQayICJAAgAkEEaiAAEIUjIAIoAgQoAiQiAyADKAIAIgBBAWo2AgAgAEEASARAAAsgAkEEahDkKiABQQAgAxD9OhCBLSACQRBqJAAgASgCACABKAIEIAEoAgggAUEQaiQAC+ECAQd/IwBBEGsiAyQAIwBBIGsiBCQAIARBFGoiByAAEIUjIARBCGohBiAEKAIUIQEjAEEQayIAJAAgABCkNiICNgIEAkAgAUEUakEAIAEoAhRBgICAgHhHGyIBRQ0AIAEoAggiBUUNACAFQRhsIQUgASgCBEEUaiECA0ACQCACQQhrKAIAQYCAgIB4Rg0AIAAgAkEQaygCACACQQxrKAIAEJM+NgIIIAAgAkEEaygCACACKAIAEJM+NgIMIABBBGogAEEIaiAAQQxqEPc1IgFBhAFPBEAgARDyHwsgACgCDCIBQYQBTwRAIAEQ8h8LIAAoAggiAUGEAUkNACABEPIfCyACQRhqIQIgBUEYayIFDQALIAAoAgQhAgsgBiACNgIEIAZBADYCACAAQRBqJAAgBCgCDCEAIAcQ5iogA0EAIAAQgS0gBEEgaiQAIAMoAgAgAygCBCADKAIIIANBEGokAAuXAgEIfyMAQRBrIgMkACMAQSBrIgEkACABQRRqIgUgABCHIyABKAIUIQIjAEEQayIAJAAgAEEEaiIGIAIQkBggACgCDCEEIAAoAgghAiABQQxqIgcgACgCBCIIQYGAgIB4RwR/IAAgBDYCDCAAIAI2AgggACAINgIEQQAhAiAGEPcWBSAECzYCBCAHIAI2AgAgAEEQaiQAIAUQ+yogAwJ/IAEoAgwiAEUEQCABKAIQIQBBAQwBCyABIAEoAhA2AhwgASAANgIYIAFBADYCFCABQRRqENYpQQhqIQBBAAsiAjYCCCADIABBACACGzYCBCADQQAgACACGzYCACABQSBqJAAgAygCACADKAIEIAMoAgggA0EQaiQAC5ECAQd/IwBBEGsiAiQAIwBBMGsiASQAIAFBCGoiBCAAELIWIwBBEGsiACQAIABBBGoiBiAEEJAYIAAoAgwhAyAAKAIIIQUgACgCBCIHQYGAgIB4RwRAIAAgAzYCDCAAIAU2AgggACAHNgIEQQAhBSAGEPcWIQMLIAQQ6SsgAUEcaiIEIAM2AgQgBCAFNgIAIABBEGokACACAn8gASgCHCIARQRAIAEoAiAhAEEBDAELIAEgASgCIDYCLCABIAA2AiggAUEANgIkIAFBJGoQ1ilBCGohAEEACyIDNgIIIAIgAEEAIAMbNgIEIAJBACAAIAMbNgIAIAFBMGokACACKAIAIAIoAgQgAigCCCACQRBqJAALigIBB38jAEEQayICJAAjAEEgayIDJAAgA0EUaiIGIAAQhyMgA0EIaiEEIAMoAhQhASMAQRBrIgAkACAAQQRqIgUgASgCAEEIahD0FSAAKAIIIQECfyAAKAIEIgdBgYCAgHhHBEAgACAAKAIMNgIMIAAgATYCCCAAIAc2AgQgBRD3FiEBQQEMAQtBAAshBSAEIAE2AgQgBCAFNgIAIABBEGokAEEBIQAgAygCCCADKAIMIQEgBhD9KkEBcUUEQEEAIAEQmixBCGohAUEAIQALIAIgADYCCCACIAFBACAAGzYCBCACQQAgASAAGzYCACADQSBqJAAgAigCACACKAIEIAIoAgggAkEQaiQAC7MCAQd/IwBBEGsiAiQAIwBBEGsiBCQAIARBCGohBiAAEMwhIQEjAEEQayIAJAAgACABNgIAIABBBGoiAyABQQhqEPQVIAAoAgghBQJAAkAgACgCBCIHQYGAgIB4RwRAIAAgACgCDDYCDCAAIAU2AgggACAHNgIEIAMQ9xYhBSABIAEoAgAiA0EBazYCAEEBIQEgA0EBRg0BDAILIAEgASgCACIDQQFrNgIAQQAhASADQQFHDQELIAAQ+CMLIAYgBTYCBCAGIAE2AgAgAEEQaiQAQQEhACAEKAIMIQEgBCgCCEEBcUUEQEEAIAEQmixBCGohAUEAIQALIAIgADYCCCACIAFBACAAGzYCBCACQQAgASAAGzYCACAEQRBqJAAgAigCACACKAIEIAIoAgggAkEQaiQAC/4JAg1/AW8jAEEQayIHJAAjAEEgayIJJAAgCUEUaiIMIAAQhyMgCUEIaiEKIAkoAhQjAEEQayIIJAAoAgAhACAIQQA2AgwjAEHwAGsiAiQAIAIgAEEQaiIBKAIMNgI4IAIgASgCACIANgIwIAIgAEEIajYCKCACIAAgASgCBGpBAWo2AiwgAiAAKQMAQn+FQoCBgoSIkKDAgH+DNwMgIAJB2ABqIQECfyAIQQxqIgMtAAFFBEAQpDYhAEEADAELEK8+IQBBAQshBCABIAM2AhAgAUEANgIIIAEgADYCBCABIAQ2AgAgCAJ/AkACQCACKAJYQQJGBEAgAigCXCEADAELIAJB0ABqIAJB6ABqKAIANgIAIAJByABqIAJB4ABqKQIANwMAIAIgAikCWDcDQANAIAJBGGogAkEgahDdKCACKAIYIgBFDQIgAigCHCEBIAIgADYCbCACIAE2AlgjAEEQayIEJAAjAEEQayIAJAAgAEEIaiACQUBrIgEoAhAgAkHsAGooAgAiAygCBCADKAIIEJo1QQEhAyAAKAIMIQUgACgCCEEBcUUEQAJAIAEoAghFDQAgASgCDCIDQYQBSQ0AIAMQ8h8LIAEgBTYCDCABQQE2AghBACEDCyACQRBqIQsgAkHYAGohBiAEQQhqIg0gBTYCBCANIAM2AgAgAEEQaiQAAn8gBCgCCCIAQQFxBEAgBCgCDAwBCyMAQSBrIgMkACABKAIIIQAgAUEANgIIAkACQCAABEAgAyABKAIMIgU2AhQgA0EIaiABKAIQIAYoAgAiACgCBCAAKAIIEJo1QQEhBiADKAIMIQAgAygCCEEBcQRAIAVBhAFJDQIgBRDyHwwCCyADIAA2AhggAUEEaiEGAkACQCABKAIAQQFGBEAgAyAFNgIcIANBHGooAgAlARBtDQFBxMbMAEEzENwbIQEgBUGEAU8EQCAFEPIfCyAAQYQBTwRAIAAQ8h8LQQEhBgwFCyAGIANBFGogA0EYahD3NSIBQYQBTwRAIAEQ8h8gAygCGCEACyAAQYQBTwRAIAAQ8h8LQQAhBiADKAIUIgFBhAFJDQEgARDyHwwBCyAGKAIAJQEgBSUBIAUQ8h8gACUBIAAQ8h8QDUEAIQYLDAILQbDHzABBMRCXPQALIAAhAQsgBCABNgIEIAQgBjYCACADQSBqJAAgBCgCACEAIAQoAgQLIQEgCyAANgIAIAsgATYCBCAEQRBqJAAgAigCEEEBcUUNAAsgAigCFCEAIAIoAkQiAUGEAU8EQCABEPIfCyACKAJIRQ0AIAIoAkwiAUGEAUkNACABEPIfC0EBDAELIAJB6ABqIAJB0ABqKAIANgIAIAJB4ABqIAJByABqKQMANwMAIAIgAikDQDcDWCACQQhqIQAgAkHYAGoiASgCBCEDAkAgASgCCEUNACABKAIMIgFBhAFJDQAgARDyHwsgACADNgIEIABBADYCACACKAIMIQAgAigCCAs2AgAgCCAANgIEIAJB8ABqJABBASEBIAgoAgQhAAJAIAgoAgBBAXFFBEBBACEBDAELIAAQgBghAAsgCiAANgIEIAogATYCACAIQRBqJAAgCSgCDCEAIAkoAgghASAMEP0qIAcgATYCCCAHIABBACABQQFxIgEbNgIEIAdBACAAIAEbNgIAIAlBIGokACAHKAIAIAcoAgQgBygCCCAHQRBqJAALywIBB38jAEEQayICJAAjAEEwayIBJAAgAUEcaiIFIAAQhyMgAUEMaiEDIAEoAhwhBCMAQSBrIgAkACAAQRBqIgYgBBDQCyAAQQhqIgQgAEEcaigCADYCACAAIAApAhQ3AwACQCAAKAIQIgdBgICAgHhGBEAgAEEYaiAEKAIANgIAIAAgACkDADcDECADIAYQ9xY2AgQMAQsgAyAAKQMANwIEIANBDGogBCgCADYCAAsgAyAHNgIAIABBIGokACAFEIArIAICfyABKAIMQYCAgIB4RgRAIAEoAhAhAEEBDAELIAFBKGogAUEUaikCADcCACABIAEpAgw3AiAgAUEANgIcIAFBHGoQnidBCGohAEEACyIDNgIIIAIgAEEAIAMbNgIEIAJBACAAIAMbNgIAIAFBMGokACACKAIAIAIoAgQgAigCCCACQRBqJAALxAIBB38jAEEQayICJAAjAEFAaiIBJAAgAUEMaiIEIAAQ+BcgAUEcaiEDIwBBIGsiACQAIABBEGoiBiAEENALIABBCGoiBSAAQRxqKAIANgIAIAAgACkCFDcDAAJAIAAoAhAiB0GAgICAeEYEQCAAQRhqIAUoAgA2AgAgACAAKQMANwMQIAMgBhD3FjYCBAwBCyADIAApAwA3AgQgA0EMaiAFKAIANgIACyAEEP8qIAMgBzYCACAAQSBqJAAgAgJ/IAEoAhxBgICAgHhGBEAgASgCICEAQQEMAQsgAUE4aiABQSRqKQIANwIAIAEgASkCHDcCMCABQQA2AiwgAUEsahCeJ0EIaiEAQQALIgM2AgggAiAAQQAgAxs2AgQgAkEAIAAgAxs2AgAgAUFAayQAIAIoAgAgAigCBCACKAIIIAJBEGokAAseACAALQB4QQNGBEAgAEEYahDDJiAAQewAahDtOwsLHgAgAC0AfEEDRgRAIABBIGoQxCYgAEHwAGoQ7TsLCxsBAX8DQCAAIAFqEN47IAFBDGoiAUEYRw0ACwsnAAJAIAAoAgBFDQAgAEEEahCSPiAAKAIEIgBBhAFJDQAgABDyHwsLJAAgAC0AAARAIAFBhAFPBEAgARDyHwsPC0Hs2sMAQRwQlz0ACx8AIAAgAhDsEiAAQUBrIAJBQGsQ7BIgAkEIIAEQ/g8LHwAgACACENQWIABBIGogAkEgahDUFiACQQggARD/EQsfACAAIAIQwRUgAEEQaiACQRBqEMEVIAJBCCABEPcQCyEAIAAoAhAgACgCIGogAC0AFCIAQQN2IABBB3FBAEdqagshACAAKAJsIAAoAihqIAAtACwiAEEDdiAAQQdxQQBHamoLJQAgACACIAMQ3BAgAEFAayACQUBrIAMQ3BAgAkEIIAEgAxCsDwszAAJAAkACQCAAKAKk6wFBAWoOAwIAAQALIAAQ/DBBAA8LIABBADYCpOsBCyAAKAKY6wELJAAgAUH/AXFBAUYEQCAAQQQ2AgAgAEECOgAEDwsgACABEKgSCysAIABBADoAECAAIAI7AQ4gAEEAOwEMIAAgASkCBDcCBCAAIAEoAgA2AgALHwAgACACEPESIABBMGogAkEwahDxEiACQQggARCIEAsfACAAEN47IAAoAgwEQCAAQQxqEM8vCyAAQShqEKYMCx8AIAAQnTwgACgCDARAIABBDGoQzy8LIABBKGoQpgwLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahCmDAsfACAAEOM8IAAoAgwEQCAAQQxqEM8vCyAAQShqEKYMCx8AIAAQ5jwgACgCDARAIABBDGoQzy8LIABBKGoQpgwLHwAgABDlPCAAKAIMBEAgAEEMahDPLwsgAEEoahCmDAsfACAAEN47IAAoAgwEQCAAQQxqEM8vCyAAQShqEKkMCx8AIAAQnTwgACgCDARAIABBDGoQzy8LIABBKGoQqQwLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahCpDAsfACAAEOM8IAAoAgwEQCAAQQxqEM8vCyAAQShqEKkMCy4BAX8CQAJAIAAtAABBAWsOAwABAAELIAAoAggiAUUNACAAKAIEIAFBARD4OgsLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahC0DAsqAQF/IAEoAhQhAiAAQQRqIAEQ9zQgACACNgIgIABBADYCHCAAIAE2AgALKgEBfyABEMA8IQIgAEEEaiABEPc0IAAgAjYCICAAQQA2AhwgACABNgIACyoBAX8gARDBPCECIABBBGogARD3NCAAIAI2AiAgAEEANgIcIAAgATYCAAsqAQF/IAEQvzwhAiAAQQRqIAEQ9zQgACACNgIgIABBADYCHCAAIAE2AgALIgAgACgCIARAIABBIGoQ1B4LIABBDGoQ+SMgAEEUahDUHgslACAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogASAAKAIMEQIACyUAIAAgASgCACABKAIEIgAoAghBAWtBeHFqQQhqIAAoAhQRAAALJQAgACABKAIAIAEoAgQiACgCCEEBa0F4cWpBCGogACgCOBEAAAslACAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogASAAKAI8EQIACyUAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiABIAAoAkARAgALIgAgAEEMahDUHiAAQRhqENQeIAAoAiQEQCAAQSRqENQeCwsfACAAIAIQ5Q0gAEEQaiACQRBqEOUNIAJBCCABEOIOCygBAX4gACABrCICNwMAIAAgAkI/hyICNwMYIAAgAjcDECAAIAI3AwgLJgAgASACTQRAIAAgATYCBCAAQQA2AgAPCyABIAJB/JjPABCwOwALKQEBfwJAIAAoAgAiAUUNACABIAEoAgBBAWsiATYCACABDQAgABCyGgsLGwAgACgCACUBIAEEfyABKAIABUGBAQslARAuCxoAIAAoAgAlASABBH8gASgCAAVBAAslARA0Cy0BAX5B2O+KASkDACEBQdjvigFCADcDACAAIAFCIIg+AgQgACABp0EBRjYCAAsfAQJ/IAEgACgCACIDTwR/IAEgAyAAKAIEakkFIAILCx8AIAAoAgAEQCAAEL0rCyAAKAIQBEAgAEEQahC9KwsLLgACQAJAAkAgAC0AyAQOBAECAgACCyAAQbADahDlKiAAQdgBaiEACyAAENQMCwsuAAJAAkACQCAALQDcAQ4EAQICAAILIABB0AFqEOQoIABB6ABqIQALIAAQoSULCyEBAX8gAEEEaiEBIAAoAgBBA0YEQCABELwqDwsgARDeOwslAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQgyALCy4AAkACQAJAIAAtANwBDgQBAgIAAgsgAEHQAWoQ5CggAEHoAGohAAsgABCkKQsLLgACQAJAIAAtACAOBAABAQABCyAAQRBqIAAoAgggACgCDCAAKAIEKAIQEQEACwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBEBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQxSgLCyUBAX8gACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABC7IwsLIwEBfyAAKAIYIgAgACgCACIBQQFqNgIAIAFBAEgEQAALIAALJQEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEIgcCwskAQF/IAAoArwCIgAgACgCACIBQQFqNgIAIAFBAEgEQAALIAALKwACQAJAIAAtAABBAWsOBQAAAAAAAQsgACgCBCIARQ0AIABBGEEIEPg6CwvICQIYfwJ+An8gASESQQQgACgCyAEiASABQQVrQQNPGyEMQQAgAiITKAIAIhQgFCAAIgIoAgQiCSAAKAIMIgEgAyIGIAlrIARqIgBBASACKAK4AXQiA2sgASAAIAFrIANLGyACKAIYIgUbIhVqIhYgBkYgBmoiACAJayIIIAEgCCADayABIAggAWsgA0sbIAUbayIDSyIXGyEBQQAgEygCBCIYIAMgGEkiHBshAyAEIAZqIgpBCGshDUHAACACKALAAWutIR0gAigCvAEhDiACKAJkIQ8gAigCXCELA0ACQAJAAkACQAJAIA0gAEEBaiIETwRAQQAgAWshGSAAQYACaiEIIAkgCyAAKQAAQuPIlb3Lm++NT34gHYinIhBBAnRqKAIAIgVqIQdBASERA0AgDyAAIA4gDBCjHUECdGoiAigCACEaIAIgACAJayIbNgIAIAsgEEECdGogGzYCACABBEAgAEEBaiICIBlqKAAAIAAoAAFGDQQLIAQpAAAiHkLjyJW9y5vvjU9+IB2IpyEQAkAgBSAVTQ0AIAcpAAAgACkAAFINACAAQQhqIAdBCGogChCAFEEIaiEFIAAgB2shCANAIAcgFk0gACAGTXINBiAAQQFrIgItAAAgB0EBayIHLQAARw0GIAVBAWohBSACIQAMAAsACyAJIAsgEEECdGooAgAiBWohByAVIBpJBEAgCSAaaiICKAAAIAAoAABGDQMLIAQgCE8EQCARQQFqIREgCEGAAmohCAsgESAEIgBqIgQgDU0NAAsLIBMgASAUQQAgFxsgARs2AgAgEyADIBQgGEEAIBwbIgAgARsgACAXGyADGzYCBCAKIAZrDAYLAkAgBSAVTQ0AIAcpAAAgHlINACAEQQhqIAdBCGogChCAFEEIaiEFIAQgB2shCCAEIQIDQCAHIBZNIAIgBk1yDQQgAkEBayIALQAAIAdBAWsiBy0AAEcNBCAFQQFqIQUgACECDAALAAsgAEEEaiACQQRqIAoQgBRBBGohBSAAIAJrIQgDQCACIBZNIAAgBk1yDQIgAEEBayIDLQAAIAJBAWsiAi0AAEcNAiAFQQFqIQUgAyEADAALAAsgEiACIAZrIAYgCkEBIABBBWoiACAAIBlqIAoQgBRBBGoiBRCFEgwCCyAAIQILIBFBA00EQCALIBBBAnRqIAQgCWs2AgALIBIgAiAGayAGIAogCEEDaiAFEIUSIAEhAyAIIQELIAIgBWoiACEGIAAgDUsNACALIAkgG0ECaiICaiIEKQAAQuPIlb3Lm++NT34gHYinQQJ0aiACNgIAIAsgAEECayIGKQAAQuPIlb3Lm++NT34gHYinQQJ0aiAGIAlrNgIAIA8gBCAOIAwQox1BAnRqIAI2AgAgDyAAQQFrIgIgDiAMEKMdQQJ0aiACIAlrNgIAA0ACQCAAIA1LDQAgAyICRSAAIAJrKAAAIAAoAABHcg0AIABBBGoiBCAEIAJrIAoQgBQhAyAPIAAgDiAMEKMdQQJ0aiAAIAlrIgQ2AgAgCyAAKQAAQuPIlb3Lm++NT34gHYinQQJ0aiAENgIAIBJBACAAIApBASADQQRqIgMQhRIgACADaiEAIAEhAyACIQEMAQsLIAAhBgwACwALC6kOAh5/BH4CfyABIRggAiEUQQQgACgCyAEiASABQQVrQQNPGyEQIAMiBiAAIgEoAgQiCSAAKAIMIgMgBiAJayAEaiICQQEgACgCuAF0IgBrIAMgAiADayAASxsgASgCGBsiCmoiC2shDUEAIQBBACABKAK0ASIMKAIEIg4gDCgCACIPayAKaiIVayAEIAZqIQggDCgCvAEhAyAOIAwoAgwiGWoiGiAPayEFIAEoAsABIQQgDCgCwAEhEQJAIAEoAtgBRQ0AQQQgEXQhAgNAIAAgAk8EQEEEIAN0IQJBACEAA0AgACACTw0DIABBQGshAAwACwAFIABBQGshAAwBCwALAAsgCEEIayEbIANBCGohISAUKAIEIQIgFCgCACEDIAEoArwBIRYgASgCZCEXIAEoAlwhEiAMKAJkISIgDCgCXCEcIA5qIQwgCkEBayEdIAYgBSANRmohAEE4IBFrrSEmQcAAIARrrSEjA0ACQAJAAkAgACAbSQRAIBcgACAWIBAQox1BAnRqIgcoAgAhASAiIAAgISAQEKMdIg1BBnZB/P//H3FqKAIAIR4gEiAAKQAAIiRC48iVvcub741PfiIlICOIp0ECdGoiBSgCACEfIBwgJSAmiKciBEEGdkH8//8fcWooAgAhICAHIAAgCWsiEzYCACAFIBM2AgACQCAdIBNBAWoiESADayIFa0EDSQ0AIA4gBSAVa2ogBSAJaiAFIApJIgcbIgUoAAAgACgAAUcNACAYIABBAWoiBCAGayAGIAhBASAAQQVqIAVBBGogCCAPIAggBxsgCxDNKEEEaiIHEIUSIAMhAQwECwJAIAogH0kEQCAJIB9qIgQpAAAgJFINASAAQQhqIARBCGogCBCAFEEIaiEHIAAgBGshAQNAIAQgC00gACAGTXINBCAAQQFrIgItAAAgBEEBayIELQAARw0EIAdBAWohByACIQAMAAsACyAEICBzQf8BcQ0AICBBCHYiBCAZTQ0AIAQgDmoiBSkAACAkUg0AIABBCGogBUEIaiAIIA8gCxDNKEEIaiEHIBMgBCAVamshAQNAIAUgGk0gACAGTXINAyAAQQFrIgItAAAgBUEBayIFLQAARw0DIAdBAWohByACIQAMAAsACwJAAkACQCABIApLBEAgASAJaiIEKAAAIAAoAABHDQEMAwsgDSAec0H/AXENACAeQQh2IgEgGU0NACABIA5qIgQoAAAgACgAAEYNAQsgACAAIAZrQQh1akEBaiEADAYLIAEgFWohAQsgHCAAKQABIiRC48iVvcub741PfiIlICaIpyIFQQZ2Qfz//x9xaigCACENIBIgJSAjiKdBAnRqIgIoAgAhByACIBE2AgACQCAHIApLBEAgByAJaiIFKQAAICRSDQEgAEEJaiAFQQhqIAgQgBRBCGohByAAQQFqIAVrIQEDQCAFIAtNIABBAWoiBCAGTXINBSAALQAAIAVBAWsiBS0AAEcNBSAAQQFrIQAgB0EBaiEHDAALAAsgBSANc0H/AXENACANQQh2IgIgGU0NACACIA5qIgUpAAAgJFINACAAQQlqIAVBCGogCCAPIAsQzShBCGohByARIAIgFWprIQEDQCAFIBpNIABBAWoiBCAGTXINBCAALQAAIAVBAWsiBS0AAEcNBCAAQQFrIQAgB0EBaiEHDAALAAsgBEEEaiEFIABBBGohAiABIApJBEAgAiAFIAggDyALEM0oQQRqIQcgEyABayEBA0AgBCAaTSAAIAZNcg0DIABBAWsiAi0AACAEQQFrIgQtAABHDQMgB0EBaiEHIAIhAAwACwALIAIgBSAIEIAUQQRqIQcgACAEayEBA0AgBCALTSAAIAZNcg0CIABBAWsiAi0AACAEQQFrIgQtAABHDQIgB0EBaiEHIAIhAAwACwALIBQgAjYCBCAUIAM2AgAgCCAGawwECyAAIQQLIBggBCAGayAGIAggAUEDaiAHEIUSIAMhAiABIQMLIAQgB2oiBiEAIAYgG0sNACASIAkgE0ECaiIEaiIDKQAAQuPIlb3Lm++NT34gI4inQQJ0aiAENgIAIBIgBkECayIAKQAAQuPIlb3Lm++NT34gI4inQQJ0aiAAIAlrNgIAIBcgAyAWIBAQox1BAnRqIAQ2AgAgFyAGQQFrIgAgFiAQEKMdQQJ0aiAAIAlrNgIAA0ACQCACIQAgBiAbSw0AIAwgCSAGIAlrIgUgAGsiBCAKSSICGyAEaiEDIB0gBGtBA0kNACADKAAAIAYoAABHDQAgGEEAIAYgCEEBIAZBBGogA0EEaiAIIA8gCCACGyALEM0oQQRqIgIQhRIgFyAGIBYgEBCjHUECdGogBTYCACASIAYpAABC48iVvcub741PfiAjiKdBAnRqIAU2AgAgAiAGaiEGIAEhAiAAIQEMAQsLIAAhAiABIQMgBiEADAALAAsLuQoCF38CfgJ/IAEhESACIRJBBCAAKALIASIBIAFBBWtBA08bIRUgACgCECICIAQiASADIgQgACgCBCIJa2oiA0EBIAAoArgBdCIGayACIAMgAmsgBksbIAAoAhgbIgwgACgCDCICSQRAIAAoAggiECACIAwgAiAMSxsiDmohEyAJIA5qIQ0gDCAQaiEYIAEgBGoiB0EIayEZIAAoArwBIRYgACgCZCEXIAAoAlwhFCAOQQFrIRpBwAAgACgCwAFrrSEcIBIoAgAhAiASKAIEIQMDQCAEIQECQAJAAkACQANAIAEgGU8NAyAXIAEgFiAVEKMdQQJ0aiIFKAIAIQAgFCABKQAAIh1C48iVvcub741PfiAciKdBAnRqIgooAgAhBiAKIAEgCWsiCjYCACAFIAo2AgACQCACIApBAWoiDyAMa0sNACAaIA8gAmsiBWtBA0kNACAFIBAgCSAFIA5JIggbaiIFKAAAIAEoAAFHDQAgAUEFaiEAIBEgAUEBaiIBIARrIAQgB0EBIAAgBUEEaiAHIBMgByAIGyANEM0oQQRqIgUQhRIgAiEADAMLAkACQCAGIAxNDQAgECAJIAYgDkkiCxsgBmoiCCkAACAdUg0AIAFBCGogCEEIaiAHIBMgByALGyANEM0oQQhqIQUgGCANIAsbIQsgASAEayEPIAogBmshAANAIAggC00gASAETXINAiABQQFrIgMtAAAgCEEBayIILQAARw0CIA9BAWshDyAFQQFqIQUgAyEBDAALAAsCQCAAIAxNDQAgECAJIAAgDkkiCxsgAGoiBigAACABKAAARw0AIBQgASkAASIdQuPIlb3Lm++NT34gHIinQQJ0aiIDKAIAIQggAyAPNgIAAkACQCAIIAxNDQAgECAJIAggDkkiGxsgCGoiAykAACAdUg0AIAFBCWogA0EIaiAHIBMgByAbGyANEM0oQQhqIQUgGCANIBsbIQsgDyAIayEAIAEhBgNAIAMgC00gBCAGQQFqIgFPcg0CIAYtAAAgA0EBayIDLQAARw0CIAZBAWshBiAFQQFqIQUMAAsACyABQQRqIAZBBGogByATIAcgCxsgDRDNKEEEaiEFIBggDSALGyEIIAogAGshAANAIAYgCE0gASAETXINASABQQFrIgMtAAAgBkEBayIGLQAARw0BIAVBAWohBSADIQEMAAsACyARIAEgBGsgBCAHIABBA2ogBRCFEgwDCyABIAEgBGtBCHVqQQFqIQEMAQsLIBEgDyAEIAcgAEEDaiAFEIUSCyACIQMLIAAhAiABIAVqIgQgGUsNAiAUIAkgCkECaiIBaiICKQAAQuPIlb3Lm++NT34gHIinQQJ0aiABNgIAIBQgBEECayIGKQAAQuPIlb3Lm++NT34gHIinQQJ0aiAGIAlrNgIAIBcgAiAWIBUQox1BAnRqIAE2AgAgFyAEQQFrIgEgFiAVEKMdQQJ0aiABIAlrNgIAA0AgBCAZSw0CIBAgCSAEIAlrIgIgAyIBayIGIA5JIgobIAZqIQUgGiAGa0EDSSABIAIgDGtLcg0CIAUoAAAgBCgAAEcNAiARQQAgBCAHQQEgBEEEaiAFQQRqIAcgEyAHIAobIA0QzShBBGoiAxCFEiAXIAQgFiAVEKMdQQJ0aiACNgIAIBQgBCkAAELjyJW9y5vvjU9+IByIp0ECdGogAjYCACADIARqIQQgACEDIAEhAAwACwALIBIgAzYCBCASIAI2AgAgByAEawwDCyAAIQIMAAsACyAAIBEgEiAEIAEQ3i0LC/cIAR9/An8gASERIAIhEkEEIAAoAsgBIgEgAUEFa0EDTxshCyAAIgIoAswBIgZBAUshASAEIAMiBWohCSACKAK0ASINKALAASEOIA0oAgQiEyANKAIMIiJqIRogDSgCACIUIAUgAigCBCIMIAIoAgwiD2oiFWtqIQRBACATIBRrIA9qIhtrAkAgAigC2AFFDQBBBCAOdCEAA0AgACAHTQ0BIAdBQGshBwwACwALIAZBASABGyEcIAlBCGshFiAOQQhqIR0gEigCBCEBIBIoAgAhACACKALAASEQIAIoAlwhFyANKAJcIR4gE2ohIyAPQQFrIR8gDEECaiENIAUgBCAaRmohAgNAAkACQCAFIBxqIgYgFksNACACIBAgCxCjHSEgIB4gAiAdIAsQox0iA0EGdkH8//8fcWooAgAiCCADcyEhIAJBgAJqIQogHCEEAkADQCAXICBBAnRqIg4oAgAhGSAGIgMgECALEKMdISAgAyAdIAsQox0hByAOIAIgDGsiGDYCAAJAIB8gGCAAa0EBaiIGa0EDSQ0AIBMgBiAba2ogBiAMaiAGIA9JIg4bIgYoAAAgAigAAUcNACACQQVqIQMgESACQQFqIgIgBWsgBSAJQQEgAyAGQQRqIAkgFCAJIA4bIBUQzShBBGoiBxCFEgwCCwJAAkAgIUH/AXENACAIQQh2IgYgIk0NACAGIBNqIggoAAAgAigAAEcgDyAZSXINACACQQRqIAhBBGogCSAUIBUQzShBBGohByACIAVrIQogGCAGIBtqayEDA0AgCCAaTSACIAVNcg0CIAJBAWsiAS0AACAIQQFrIggtAABHDQIgCkEBayEKIAdBAWohByABIQIMAAsACwJAIA8gGU8NACAMIBlqIggoAAAgAigAAEcNACACQQRqIAhBBGogCRCAFEEEaiEHIAIgBWshCiACIAhrIQMDQAJAIAggFU0gAiAFTXINACACQQFrIgEtAAAgCEEBayIILQAARw0AIApBAWshCiAHQQFqIQcgASECDAELCyARIAogBSAJIANBA2ogBxCFEiAAIQEgAyEADAMLIAMgBCADIApPIgJqIgRqIgYgFksNAyAKIAJBCHRqIQogHiAHQQZ2Qfz//x9xaigCACIIIAdzISEgAyECDAELCyARIAogBSAJIANBA2ogBxCFEiAAIQEgAyEACyACIAdqIgUhAiAFIBZLDQIgFyANIBhqIBAgCxCjHUECdGogGEECajYCACAXIAVBAmsiAiAQIAsQox1BAnRqIAIgDGs2AgADQCABIQIgBSAWSw0CICMgDCAFIAxrIgMgAmsiBiAPSSIBGyAGaiEEIB8gBmtBA0kNAiAEKAAAIAUoAABHDQIgEUEAIAUgCUEBIAVBBGogBEEEaiAJIBQgCSABGyAVEM0oQQRqIgEQhRIgFyAFIBAgCxCjHUECdGogAzYCACABIAVqIQUgACEBIAIhAAwACwALIBIgATYCBCASIAA2AgAgCSAFawwCCyACIQEgBSECDAALAAsLoQkBIX8CfyABIRkgAiEVQQQgACgCyAEiASABQQVrQQNPGyENIAAoAhAiASADIgUgACgCBCIHayICIARqIgNBASAAKAK4AXQiCGsgASADIAFrIAhLGyAAKAIYGyISIAAoAgwiFk8EQCAAIBkgFSAFIAQQ3BYMAQsgACgCCCITIBYgEiASIBZJGyIOaiEaIAcgDmohGyASIBNqISEgBCAFaiILQQhrIRdBASAAKALMASIBIAFBAU0bQQFqIR4gACgCwAEhDyAAKAJcIQwgFSgCACIAQQAgACACIBJrIgFJIgMbIQJBACAAIAMbIRwgFSgCBCIAQQAgACABSSIDGyEBQQAgACADGyEfIAdBAmohIgNAAkACQCAXIAUgHmoiEEEBaiIJSwRAIAUgDyANEKMdIQAgBUEBaiIEIA8gDRCjHSEYIBMgByAMIABBAnRqKAIAIgYgDkkbIREgAiAHaiEjIAVBgAFqIR0gHiEKIAUhCANAIAkhFCATIAcgDiAQIgMgI2siCUsiJBshIAJ/IAJFIA4gCWtBBElyRQRAIAkgIGooAAAMAQsgAygAAEEBcwsgDCAAQQJ0aiAIIAdrIhA2AgAgAygAAEYEQEEFQQQgA0EBay0AACAJICBqIghBAWstAABGIgAbIQYgCCAAayEJIAMgAGshCiAaIAsgJBshFEEBIREgBCEDIAIhAAwECwJAIAYgEkkNACAIKAAAIAYgEWooAABHDQAgBCEDDAMLIAwgGEECdGoiCCgCACEGIAMgDyANEKMdIQAgCCAEIAdrIhA2AgACQCAGIBJJDQAgBCgAACATIAcgBiAWSRsiESAGaigAAEcNACAAIRggBCEIDAMLIAwgAEECdGooAgAiBiAOSSEEIBQgDyANEKMdIRggEyAHIAQbIREgCiAUaiEJIAMgCmoiECAdTwRAIB1BgAFqIR0gCkEBaiEKCyAUIQQgAyEIIAkgF0kNAAsLIBUgAiAcIAIbNgIAIBUgASAcIB8gAhsgHyAcGyABGzYCBCALIAVrDAMLIBogCyAGIBZJIgAbIRQgISAbIAAbIQEgBiARaiEEIBAgBmsiAEEDaiERQQAhBgNAAkAgBCAGaiIJIAFNIAYgCGoiCiAFTXINACAKQQFrLQAAIAlBAWstAABHDQAgBkEBayEGDAELC0EEIAZrIQYgAiEBCyAZIAogBWsgBSALIBEgBiAKaiAGIAlqIAsgFCAbEM0oIAZqIgIQhRIgAiAKaiIFIANLBEAgDCAYQQJ0aiADIAdrNgIACyAAIQIgBSAXSw0AIAwgECAiaiAPIA0Qox1BAnRqIBBBAmo2AgAgDCAFQQJrIgIgDyANEKMdQQJ0aiACIAdrNgIAA0ACQCABIQIgBSAXSw0AIBMgByAFIAdrIgQgAmsiASAOSSIIGyABaiEDIAJFIAEgDmtBfEtyDQAgAygAACAFKAAARw0AIBlBACAFIAtBASAFQQRqIANBBGogCyAaIAsgCBsgGxDNKEEEaiIBEIUSIAwgBSAPIA0Qox1BAnRqIAQ2AgAgASAFaiEFIAAhASACIQAMAQsLIAIhASAAIQIMAAsACwsgACAAIAFBA3RBOHGtiEKAgIDo+7SND34gAkE/ca2IpwsgAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABEM8oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQFBARDQKAsLHwAgACgCAARAIAAQ3isLIAAoAhAEQCAAQRBqEN4rCwslAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQhh0LCyUBAX8gACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDyJQsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEIQRAQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEIEN4oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQRBBEBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEIQQgQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBAkECEN4oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBBBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEQQSAQ3igLCyYAIAAgAikCADcCACAAIAEoAgA2AgwgAEEIaiACQQhqKAIANgIACyMBAX8gACgCDCIAIAAoAgAiAUEBajYCACABQQBIBEAACyAACyYBAX8gACgCCCIBQQFNBEBBASABQbD3hQEQwyEACyAAKAIEQQhqCyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIcEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIkEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIoEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIwEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAI0EQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJEEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJIEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJQEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJUEQQACyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEMEN4oCwslAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBxAAQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEIENwoCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBBBDcKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQ3CgLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEMENwoCwsqACAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCAAIAEpAwA3AwALJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQ3igLCyABAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAEQ3ygLC2QBAX8jAEEQayICJAAgAiABNgIMIAIgADYCCCMAQSBrIgAkACAAQQE2AgQgAEGgq4gBNgIAIABCATcCDCAAIAJBCGqtQoCAgIDwKIQ3AxggACAAQRhqNgIIIABBqKuIARDvLAALSQEBfyAAKAIMBEAgAA8LIwBBEGsiAiQAIAJBCGogAUEMaiABKAIUEOoMIAAgAigCCCACKAIMEPsoIAJBEGokACAAQRRBBBD4OgskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQFBARDhKAsLIwAgAiACKAIEQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgAL3QwDEn8FfgFvIwBBEGsiCyQAIwBBQGoiByQAIAdBKGoiDCAAEIUjIAdBIGogBygCKBCEPCAHQTRqIQMgBygCICIAIQggACAHKAIkQQZ0aiEBIwBBIGsiAiQAIAJBFGogASAIa0EGdkEAQQhBwAAQoBggAigCGCEAIAIoAhRBAUYEQCAAIAIoAhxB5IHDABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAA2AggjAEEQayIFJAAgASAIa0EGdiIGIAJBCGoiACgCACAAKAIIIgRrSwRAIAAgBCAGQQhBwAAQ0CggACgCCCEECyAFIAAoAgQ2AgwgBSAENgIIIAUgAEEIajYCBCMAQUBqIgAkACAFQQRqIgYoAgQhBCAGKAIAIQ4CQAJAIAEgCEcEQCAGKAIIIARBBnRqIRAgASAIa0EGdiEJQQAhBgNAIABBKGogBiAIaiIBQSBqEMABIAFBEGopAwAhEwJAIAFBLGoiCigCAEGAgICAeEcEQCAAQTRqIAoQkxgMAQsgAEGAgICAeDYCNAsgAUEYaikDACEUIAFBPGooAgAiCiAKKAIAIg9BAWo2AgAgD0EASA0CIABBIGogAEEwaigCACIPNgIAIABBEGoiESAAQTxqKAIANgIAIAAgACkCKCIVNwMYIAAgACkCNDcDCCABQThqKAEAIRIgAUEIaikDACEWIAEpAwAhFyAGIBBqIgFBGGogFDcDACABQRBqIBM3AwAgAUEIaiAWNwMAIAEgFzcDACABQSBqIBU3AwAgAUEoaiAPNgIAIAFBPGogCjYCACABQThqIBI2AgAgAUEsaiAAKQMINwIAIAFBNGogESgCADYCACAGQUBrIQYgBEEBaiEEIAlBAWsiCQ0ACwsgDiAENgIAIABBQGskAAwBCwALIAVBEGokACADQQhqIA0oAgA2AgAgAyACKQIINwIAIAJBIGokACAMEOgqIwBBEGsiACQAAkACQCAHQRhqIgEgAygCCCICIAMoAgBJBH8gAEEIaiADIAJBCEHAABD0FCAAKAIIIgJBgYCAgHhHDQEgAygCCAUgAgs2AgQgASADKAIENgIAIABBEGokAAwBCyACIAAoAgxB1IHDABD9LwALIAcoAhghACAHKAIcIQEjAEEwayICJAAgAiAANgIYIAIgADYCFCACIAE2AhwgAiAAIAFBBnRqNgIgIAJBJGohCSMAQSBrIgEkACABQRRqIAJBFGoiBCgCDCAEKAIEa0EGdkEAQQRBBBCgGCABKAIYIQAgASgCFEEBRgRAIAAgASgCHEHQtMIAEP0vAAsgAUEQaiIKQQA2AgAgASABKAIcNgIMIAEgADYCCCMAQSBrIgAkACAEKAIMIAQoAgRrQQZ2IgUgAUEIaiIDKAIAIAMoAggiCGtLBEAgAyAIIAVBBEEEENAoIAMoAgghCAsgAygCBCEFIABBCGogBEEIaikCADcDACAAIAQpAgA3AwAgACAFNgIcIAAgCDYCGCAAIANBCGo2AhQgAEEUaiEDIwBB0ABrIggkAAJAIAAoAgQiBSAAKAIMIgxGBEAgAygCBCEEDAELIAMoAgggAygCBCIEQQJ0aiEGIAhBEGohDQNAIA0gBUHAAPwKAAAgACAFQUBrIgU2AgQgCEEANgIIIAhBCGoQ0ClBCGoQASEYEN8SIg4gGCYBIAMgBEEBaiIENgIEIAYgDjYCACAGQQRqIQYgBSAMRw0ACwsgAygCACAENgIAIwBBEGsiBSQAIAAoAgwiBCAAKAIEIgNHBEAgBCADa0EGdiEEIANBPGohAwNAIANBHGsiBhCfLCAGEPM7IANBEGsQjjAgAygCACIGIAYoAgAiBkEBazYCACAGQQFGBEAgAxCGHwsgA0FAayEDIARBAWsiBA0ACwsgBSAAKAIANgIMIAUgACgCCDYCCCAFQQhqQQhBwAAQ4B4gBUEQaiQAIAhB0ABqJAAgAEEgaiQAIAlBCGogCigCADYCACAJIAEpAgg3AgAgAUEgaiQAIAJBCGogCUHEssMAEJghIAIgAigCCCACKAIMELU2IAIoAgQhACAHQRBqIgEgAigCADYCACABIAA2AgQgAkEwaiQAIAdBCGogBygCECAHKAIUELU2IAsgBykDCDcCACAHQUBrJAAgCygCACALKAIEIAtBEGokAAv7AgEJfyMAQRBrIgMkACMAQUBqIgEkACABQTBqIgcgABCFIyABQSRqIQQgASgCMCECIwBBIGsiACQAIABBCGoiBSACKAIQNgIEIAUgAigCDEEAIAIoAghBgICAgHhHGzYCAAJAAkACQCAAKAIIIglFBEAgBEGAgICAeDYCAAwBCyAAQRRqIAAoAgwiAkEAQQFBARCgGCAAKAIYIQUgACgCFEEBRg0BIAAoAhwhCCACBEAgCCAJIAL8CgAACyAEIAI2AgggBCAINgIEIAQgBTYCAAsgAEEgaiQADAELIAUgACgCHEG0gsMAEP0vAAsgBxDmKkEAIQAgASgCJEGAgICAeEcEQCABQThqIAFBLGooAgA2AgAgASABKQIkNwMwIAFBGGogB0HUgcMAEJAhIAFBEGogASgCGCABKAIcELU2IAEoAhAhBiABKAIUIQALIAFBCGogBiAAELU2IAMgASkDCDcCACABQUBrJAAgAygCACADKAIEIANBEGokAAv1IAMsfxd+AW8jAEEQayIXJAAjAEFAaiIJJAAgCUEoaiIhIAAQhSMgCUEgaiAJKAIoEIY8IAlBNGohESAJKAIgIgAhFSAAIAkoAiRBwAJsaiEDIwBBIGsiCCQAIAhBFGogAyAVa0HAAm5BAEEIQcACEKAYIAgoAhghACAIKAIUQQFGBEAgACAIKAIcQeSBwwAQ/S8ACyAIQRBqIiJBADYCACAIIAgoAhw2AgwgCCAANgIIIwBBEGsiFiQAIAMgFWtBwAJuIgEgCEEIaiIAKAIAIAAoAggiAmtLBEAgACACIAFBCEHAAhDQKCAAKAIIIQILIBYgACgCBDYCDCAWIAI2AgggFiAAQQhqNgIEQQAhAiMAQfAAayIBJAAgFkEEaiIAKAIEIRggACgCACADIBVHBEAgACgCCCEkIAMgFWtBwAJuISUgAUHeAGohHwNAIBUgGUHAAmxqIgAoArwCIiAgICgCACIDQQFqNgIAAkACfwJAIANBAE4EQCABQShqIABBgAJqENYeAkAgACgCjAJBgICAgHhHBEAgAUE0aiAAQYwCahDdIAwBCyABQYCAgIB4NgI0CyAAKQP4ASE/IAApA/ABIUAgACkD6AEhQSAAKALUASEmIAAoAtABIScgACkD4AEhQiAAKQPYASFDQgAhOkIAITsgACgCAEEBRgRAQgEhOyAAKQMIITQLIAAoAhBBAUYEQEIBITogACkDGCE1C0IIIS0gACkDYCIzQghRDQMCfgJAAkACQAJAAkACQAJAAkAgM6dBAWsOBwECAwQFBgcACyAALQCKASELIAAtAIkBIQwgAC0AiAEhAiAAKQOAASEwIAApA3ghLiAAKQNwITEgACkDaCEvIAAtAI0BIQYgAC0AjAEhBUIAIS0gAUFAayEOIAAtAIsBDAoLIAEgACgCjAEiBUEIdjoAQCAFQRB2IQ0gACgCiAEhAiAALQCbASEGIAAtAJoBIQMgAC0AmQEhByAALQCYASEEIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS8gACgClAEhDyAAKAKQASEQQgEhLQwICyAAQZoBai0AACEDIAAtAKsBIQYgAC0AqgEhEiAALQCpASETIAAtAKgBIRQgACkDoAEhMiAAKAKcASEKIAAvAY4BIQ0gAC0AjAEhBSAAKQOAASEwIAApA3ghLiAAKQNwITEgACkDaCEvIAApA5ABIS0gAC8BmAEgACgCiAEhAiAALQCNASEHIAEgAC0AmwE6ABggASAHOgBAIAJBEHYhCyACQQh2IQwgA0EQdHIiBEEIdiEHIC1CIIinIQ8gLachEEICIS0gAUEIaiEOIAJBGHYMCAtBACEEQQAhAiAAKAKIAUEBRgRAIAAoApQBIQ8gACgCkAEhECAALwGOASENIAAtAIwBIQUgAC0AjQEhA0EBIQILIAAoApgBQQFGBEAgACkCoAEhMiAAKAKcASEKQQEhBAsgASADOgBAIAFBADoAGCAALQCrASEGIAAtAKoBIRIgAC0AqQEhEyAALQCoASEUIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS9CAyEtIAFBCGohDkEAIQtBACEMQQAhA0EAIQdBAAwHCyABIAAoAowBIgVBCHY6AEAgBUEQdiENIAAoApQBIQ8gACgCiAEhAiAALQCbASEGIAAtAJoBIQMgAC0AmQEhByAALQCYASEEIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS8gACgCkAEhEEIEIS0MBQsgAEGaAWotAAAhAyAALQCrASEGIAAtAKoBIRIgAC0AqQEhEyAALQCoASEUIAApA6ABITIgACgCnAEhCiAALwGOASENIAAtAIwBIQUgACkDgAEhMCAAKQN4IS4gACkDcCExIAApA2ghLyAAKQOQASEtIAAvAZgBIAAoAogBIQIgAC0AjQEhByABIAAtAJsBOgAYIAEgBzoAQCACQRB2IQsgAkEIdiEMIANBEHRyIgRBCHYhByAtQiCIpyEPIC2nIRBCBSEtIAFBCGohDiACQRh2DAULQQAhCkEAIQIgACgCiAFBAUYEQAJAIAAoAowBIgIEQCABQdAAaiAAQZgBaiAAKAKQASAAKAKUASACKAIAEQUADAELIAFBADYCUAtBASECCyAAKAKcAUEBRgRAAkAgACgCoAEiAwRAIAFB4ABqIABBrAFqIAAoAqQBIAAoAqgBIAMoAgARBQAMAQsgAUEANgJgC0EBIQoLQgAhLkIAIS8gACgCaEEBRgRAIAApA3AhMUIBIS8LIAAoAnhBAUYEQCAAKQOAASEwQgEhLgsgASABLQBROgBAIAEgAS0AXzoAGCAALQCzASEGIAAtALIBIRogAC0AsQEhGyAALQCwASEcIB8tAAAhAyABLwFSIQ0gAS0AUCEFIAEoAlQhECABKAJYIQ8gASkDYCEyIAEtAGghFCABLQBpIRMgAS0AaiESIAEvAVwgASABLQBrOgAIIANBEHRyIgRBCHYhByABQc8AaiEOQgYMAQtBACEKQQAhAiAAKAKIAUEBRgRAAkAgACgCjAEiAgRAIAFB0ABqIABBmAFqIAAoApABIAAoApQBIAIoAgARBQAMAQsgAUEANgJQC0EBIQILIAAoApwBQQFGBEACQCAAKAKgASIDBEAgAUHgAGogAEGsAWogACgCpAEgACgCqAEgAygCABEFAAwBCyABQQA2AmALQQEhCgtCACEuQgAhLyAAKAJoQQFGBEAgACkDcCExQgEhLwsgACgCeEEBRgRAIAApA4ABITBCASEuCyABIAEtAFE6AEAgASABLQBfOgAYIAAtALMBIQYgAC0AsgEhGiAALQCxASEbIAAtALABIRwgHy0AACEDIAEvAVIhDSABLQBQIQUgASgCVCEQIAEoAlghDyABKQNgITIgAS0AaCEUIAEtAGkhEyABLQBqIRIgAS8BXCABIAEtAGs6AAggA0EQdHIiBEEIdiEHIAFBzwBqIQ5CBwshLSABKAJsIR5BACELQQAhDEEADAILAAsgAUEYaiEOQQAhC0EAIQxBAAshHSAOIAY6AAAgBEH/AXEgB0H/AXFBCHQgA0EQdHJyIQMgAkH/AXEgC0H/AXFBEHQgHUEYdHIgDEH/AXFBCHRyciEMIAEtAEAhCyABLQAYIQYgAS0ACCEEIAEtAE8hAgsCQCAAKAKYAkGAgICAeEcEQCABQUBrIABBmAJqELUWDAELIAFBgICAgHg2AkALQgAhM0IAITwgACgCIEEBRgRAQgEhPCAAKQMoITYLIAAoArwBIQ4gACgCuAEhHSAAKAIwQQFGBEBCASEzIAApAzghNwsgACgCxAEhByAAKALAASEoQgAhPUIAIT4gACgCQEEBRgRAQgEhPiAAKQNIITgLIAAoAswBISkgACgCyAEhKiAAKAJQQQFGBEBCASE9IAApA1ghOQsCQCAAKAKkAkGAgICAeEcEQCABQdAAaiAAQaQCahClHQwBCyABQYCAgIB4NgJQCwJAIAAoArACQYCAgIB4RwRAIAFB4ABqIABBsAJqEKUdDAELIAFBgICAgHg2AmALIAFBIGoiKyABQTBqKAIANgIAIAFBEGoiLCABQTxqKAIANgIAIAEgASkCKDcDGCABIAEpAjQ3AwggJCAYQcACbGoiAEGaAWogA0EQdjoAACAAIAM7AZgBIAAgPzcD+AEgACBANwPwASAAIEE3A+gBIAAgQjcD4AEgACBDNwPYASAAICY2AtQBIAAgJzYC0AEgACApNgLMASAAICo2AsgBIAAgBzYCxAEgACAoNgLAASAAIA42ArwBIAAgHTYCuAEgACACOgCzASAAIBo6ALIBIAAgGzoAsQEgACAcOgCwASAAIB42AqwBIAAgBDoAqwEgACASOgCqASAAIBM6AKkBIAAgFDoAqAEgACAyNwOgASAAIAo2ApwBIAAgBjoAmwEgACAPNgKUASAAIBA2ApABIAAgDTsBjgEgACALOgCNASAAIAU6AIwBIAAgDDYCiAEgACAwNwOAASAAIC43A3ggACAxNwNwIAAgLzcDaCAAIC03A2AgACA5NwNYIAAgPTcDUCAAIDg3A0ggACA+NwNAIAAgNzcDOCAAIDM3AzAgACA2NwMoIAAgPDcDICAAIDU3AxggACA6NwMQIAAgNDcDCCAAIDs3AwAgAEGIAmogKygCADYCACAAIAEpAxg3A4ACIAAgASkDCDcCjAIgAEGUAmogLCgCADYCACAAIAEpA0A3A5gCIABBoAJqIAFByABqKAIANgIAIAAgASkCUDcCpAIgAEGsAmogAUHYAGooAgA2AgAgAEG4AmogAUHoAGooAgA2AgAgACABKQNgNwOwAiAAICA2ArwCIBhBAWohGCAZQQFqIhkgJUcNAAsLIBg2AgAgAUHwAGokACAWQRBqJAAgEUEIaiAiKAIANgIAIBEgCCkCCDcCACAIQSBqJAAgIRDqKiMAQRBrIgAkAAJAAkAgCUEYaiICIBEoAggiASARKAIASQR/IABBCGogESABQQhBwAIQ9BQgACgCCCIBQYGAgIB4Rw0BIBEoAggFIAELNgIEIAIgESgCBDYCACAAQRBqJAAMAQsgASAAKAIMQdSBwwAQ/S8ACyAJKAIYIQAgCSgCHCECIwBBMGsiASQAIAEgADYCGCABIAA2AhQgASACNgIcIAEgACACQcACbGo2AiAgAUEkaiEHIwBBIGsiAiQAIAJBFGogAUEUaiIDKAIMIAMoAgRrQcACbkEAQQRBBBCgGCACKAIYIQAgAigCFEEBRgRAIAAgAigCHEHQtMIAEP0vAAsgAkEQaiILQQA2AgAgAiACKAIcNgIMIAIgADYCCCMAQSBrIgAkACADKAIMIAMoAgRrQcACbiIGIAJBCGoiBCgCACAEKAIIIgVrSwRAIAQgBSAGQQRBBBDQKCAEKAIIIQULIAQoAgQhBiAAQQhqIANBCGopAgA3AwAgACADKQIANwMAIAAgBjYCHCAAIAU2AhggACAEQQhqNgIUIABBFGohBSMAQdACayIGJAACQCAAKAIEIgMgACgCDCIMRgRAIAUoAgQhBAwBCyAFKAIIIAUoAgQiBEECdGohCCAGQRBqIQoDQCAKIANBwAL8CgAAIAAgA0HAAmoiAzYCBCAGQQA2AgggBkEIahDSKUEIahACIUQQ3xIiDSBEJgEgBSAEQQFqIgQ2AgQgCCANNgIAIAhBBGohCCADIAxHDQALCyAFKAIAIAQ2AgAjAEEQayIFJAAgACgCDCIIIAAoAgQiA2tBwAJuIQQgAyAIRwRAA0AgAxDYEiADQcACaiEDIARBAWsiBA0ACwsgBSAAKAIANgIMIAUgACgCCDYCCCAFQQhqQQhBwAIQ4B4gBUEQaiQAIAZB0AJqJAAgAEEgaiQAIAdBCGogCygCADYCACAHIAIpAgg3AgAgAkEgaiQAIAFBCGogB0HEssMAEJghIAEgASgCCCABKAIMELU2IAEoAgQhACAJQRBqIgIgASgCADYCACACIAA2AgQgAUEwaiQAIAlBCGogCSgCECAJKAIUELU2IBcgCSkDCDcCACAJQUBrJAAgFygCACAXKAIEIBdBEGokAAv9AgEJfyMAQRBrIgMkACMAQUBqIgEkACABQTBqIgcgABCFIyABQSRqIQQgASgCMCECIwBBIGsiACQAIABBCGoiBSACKAKUAjYCBCAFIAIoApACQQAgAigCjAJBgICAgHhHGzYCAAJAAkACQCAAKAIIIgkEQCAAQRRqIAAoAgwiAkEAQQFBARCgGCAAKAIYIQUgACgCFEEBRg0CIAAoAhwhCCACBEAgCCAJIAL8CgAACyAEIAI2AgggBCAINgIEIAQgBTYCAAwBCyAEQYCAgIB4NgIACyAAQSBqJAAMAQsgBSAAKAIcQbSCwwAQ/S8ACyAHEOwqQQAhACABKAIkQYCAgIB4RwRAIAFBOGogAUEsaigCADYCACABIAEpAiQ3AzAgAUEYaiAHQdSBwwAQkCEgAUEQaiABKAIYIAEoAhwQtTYgASgCECEGIAEoAhQhAAsgAUEIaiAGIAAQtTYgAyABKQMINwIAIAFBQGskACADKAIAIAMoAgQgA0EQaiQAC5gHAQ1/IwBBEGsiCyQAIwBBMGsiBSQAIAVBGGoiCiAAEIUjIAVBJGohAyAFKAIYIQAjAEEgayICJAAgAkEIaiAAEIc8ENw7IAIoAgghByACQRRqIAIoAgwiCUEAQQRBDBCgGCACKAIYIQECQCACKAIUQQFHBEAgAigCHCEGAkAgAUUNACAJQQxsIQggBiEAIAEhBANAIAhFDQEgAkEUaiAHEN0gIABBCGogAkEcaigCADYCACAAIAIpAhQ3AgAgAEEMaiEAIAhBDGshCCAHQQxqIQcgBEEBayIEDQALCyADIAk2AgggAyAGNgIEIAMgATYCACACQSBqJAAMAQsgASACKAIcQcSCwwAQ/S8ACyAKEOwqIwBBEGsiACQAAkACQCAFQRBqIgYgAygCCCIBIAMoAgBJBH8gAEEIaiADIAFBBEEMEPQUIAAoAggiAUGBgICAeEcNASADKAIIBSABCzYCBCAGIAMoAgQ2AgAgAEEQaiQADAELIAEgACgCDEHUgcMAEP0vAAsgBSgCECEAIAUoAhQhASMAQRBrIggkACMAQTBrIgIkACACIAA2AiQgAiAANgIgIAIgATYCKCACIAAgAUEMbGo2AiwjAEEQayIJJAAgAkEgaiIEKAIIIQwgBCgCACIKIQAjAEEQayIDJAAgBCgCBCIBIAQoAgwiB0cEQANAIAQgAUEMaiIGNgIEIANBCGogAUEIaigCACINNgIAIAMgASkCADcDACADKAIEIA0QkjUhASADEN47IAAgATYCACAAQQRqIQAgBiIBIAdHDQALCyAJQQhqIgEgADYCBCABIAo2AgAgA0EQaiQAIAkoAgwhAyMAQRBrIgEkACAEQQA2AgggBCgCDCEGIAQoAgQhACAEQQQ2AgAgAUKAgICAwAA3AgggAUEIakEEQQwQ4B4gBEEENgIMIARBBDYCBCAGIABrQQxuIQcgACAGRwRAA0AgABDeOyAAQQxqIQAgB0EBayIHDQALCyABQRBqJAAgAkEUaiIAIAo2AgQgACAMQQNsNgIAIAAgAyAKa0ECdjYCCCAEELogIAlBEGokACACQQhqIABB2K6IARCYISAIQQhqIAIpAwg3AwAgAkEwaiQAIAgoAgwhACAFQQhqIgEgCCgCCDYCACABIAA2AgQgCEEQaiQAIAUgBSgCCCAFKAIMELU2IAsgBSkDADcCACAFQTBqJAAgCygCACALKAIEIAtBEGokAAumBwINfwFvIwBBEGsiCSQAIwBBMGsiBiQAIAZBGGoiByAAEIUjIAYoAhgiASgChAIhACAAIAEoAogCaiEEIwBBIGsiASQAIAFBFGogBCAAa0EAQQFBARCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHkgcMAEP0vAAsgAUEQaiIIQQA2AgAgASABKAIcNgIMIAEgAjYCCCAEIABrIgUgAUEIaiIDKAIAIAMoAggiAmtLBEAgAyACIAVBAUEBENAoIAMoAgghAgsgACAERwRAIAMoAgQhBANAIAIgBGogAC0AADoAACAAQQFqIQAgAkEBaiECIAVBAWsiBQ0ACwsgAyACNgIIIAZBJGoiAEEIaiAIKAIANgIAIAAgASkCCDcCACABQSBqJAAgBxDsKiAGQRBqIABB1IHDABCQISAGKAIQIQAgBigCFCEBIwBBMGsiAiQAIAIgADYCGCACIAA2AhQgAiABNgIcIAIgACABajYCICMAQSBrIgQkACAEQRRqIAJBFGoiACgCDCAAKAIEa0EAQQRBBBCgGCAEKAIYIQEgBCgCFEEBRgRAIAEgBCgCHEHQtMIAEP0vAAsgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgATYCCCMAQSBrIgMkACAAKAIMIAAoAgRrIgcgBEEIaiIBKAIAIAEoAggiBWtLBEAgASAFIAdBBEEEENAoIAEoAgghBQsgAkEkaiEKIAEoAgQhByADQQhqIABBCGopAgA3AwAgAyAAKQIANwMAIAMgBzYCHCADIAU2AhggAyABQQhqNgIUIANBFGohBSMAQRBrIgckAAJAIAMoAgQiACADKAIMIg1GBEAgBSgCBCEIDAELIAUoAgggBSgCBCIIQQJ0aiELA0AgAyAAQQFqIgE2AgQgAC0AALgQeyEOEN8SIgAgDiYBIAUgCEEBaiIINgIEIAsgADYCACALQQRqIQsgASIAIA1HDQALCyAFKAIAIAg2AgAgByADKAIANgIMIAcgAygCCDYCCCAHQQhqQQFBARDgHiAHQRBqJAAgA0EgaiQAIApBCGogDCgCADYCACAKIAQpAgg3AgAgBEEgaiQAIAJBCGogCkHEssMAEJghIAIgAigCCCACKAIMELU2IAIoAgQhACAGQQhqIgEgAigCADYCACABIAA2AgQgAkEwaiQAIAYgBigCCCAGKAIMELU2IAkgBikDADcCACAGQTBqJAAgCSgCACAJKAIEIAlBEGokAAvkAgELfyMAQRBrIgUkACMAQTBrIgEkACABQRhqIgkgABCHIyABQSRqIQYgASgCGCIAKAIEIQIgAiAAKAIIQQZ0aiEDIwBBIGsiACQAIABBFGogAyACa0EGdkEAQQRBBBCgGCAAKAIYIQQgACgCFEEBRgRAIAQgACgCHEHQwMwAEP0vAAsgAEEQaiIKQQA2AgAgACAAKAIcNgIMIAAgBDYCCCAAQQhqIgQgAyACa0EGdiIHEIUuIAQoAgghCCAEIAIgA0cEfyAHIAhqIAQoAgQgCEECdGohAwNAIAMgAjYCACACQUBrIQIgA0EEaiEDIAdBAWsiBw0ACwUgCAs2AgggBkEIaiAKKAIANgIAIAYgACkCCDcCACAAQSBqJAAgCRD8KiABQRBqIAZBwMDMABCYISABQQhqIAEoAhAgASgCFBC1NiAFIAEpAwg3AgAgAUEwaiQAIAUoAgAgBSgCBCAFQRBqJAALoggBDn8jAEEQayIKJAAjAEEwayIGJAAgBkEYaiILIAAQhyMgBigCGCIAKAIEIQIgAiAAKAIIQRRsaiEFIwBBIGsiACQAIABBFGogBSACa0EUbkEAQQRBFBCgGCAAKAIYIQEgACgCFEEBRgRAIAEgACgCHEG00MwAEP0vAAsgAEEQaiIMQQA2AgAgACAAKAIcNgIMIAAgATYCCCMAQRBrIgQkACAFIAJrQRRuIgcgAEEIaiIDKAIAIAMoAggiAWtLBEAgAyABIAdBBEEUEOEoIAMoAgghAQsgBkEkaiEJIAQgAygCBDYCDCAEIAE2AgggBCADQQhqNgIEIwBBIGsiAyQAIARBBGoiASgCBCEHIAEoAgAhDgJAAkAgAiAFRwRAIAEoAgggB0EUbGohASAFIAJrQRRuIQUDQCACQQxqKAIAIgggCCgCACINQQFqNgIAIA1BAEgNAiADQQxqIAIQvBUgAkEQaigCACENIAEgAykCDDcCACABQRBqIA02AgAgAyAINgIYIAFBCGogA0EUaikCADcCACACQRRqIQIgAUEUaiEBIAdBAWohByAFQQFrIgUNAAsLIA4gBzYCACADQSBqJAAMAQsACyAEQRBqJAAgCUEIaiAMKAIANgIAIAkgACkCCDcCACAAQSBqJAAgCxCAKyAGQRBqIAlBpNDMABCZISAGKAIQIQAgBigCFCECIwBBMGsiASQAIAEgADYCJCABIAA2AiAgASACNgIoIAEgACACQRRsajYCLCMAQRBrIgckACABQSBqIgQoAgghCyAEKAIAIgkhAyAEKAIMGiMAQSBrIgUkACAEKAIEIgAgBCgCDCIMRwRAIAVBDGohCANAIAggACkCADcCACAEIABBFGoiAjYCBCAIQRBqIABBEGooAgA2AgAgCEEIaiAAQQhqKQIANwIAIAVBADYCCCADIAVBCGoQnydBCGoQ/TU2AgAgA0EEaiEDIAIiACAMRw0ACwsgB0EIaiIAIAM2AgQgACAJNgIAIAVBIGokACAHKAIMIQgjAEEQayICJAAgBEEANgIIIAQoAgwhAyAEKAIEIQAgBEEENgIAIAJCgICAgMAANwIIIAJBCGpBBEEUEOAeIARBBDYCDCAEQQQ2AgQgAyAAa0EUbiEFIAAgA0cEQANAIAAQ6SsgAEEUaiEAIAVBAWsiBQ0ACwsgAkEQaiQAIAFBFGoiACAJNgIEIAAgC0EFbDYCACAAIAggCWtBAnY2AgggBBDlICAHQRBqJAAgAUEIaiAAQeDAzAAQmCEgASABKAIIIAEoAgwQtTYgASgCBCEAIAZBCGoiAiABKAIANgIAIAIgADYCBCABQTBqJAAgBiAGKAIIIAYoAgwQtTYgCiAGKQMANwIAIAZBMGokACAKKAIAIAooAgQgCkEQaiQACyUAAkACQAJAIAAtABAOBAACAgECCyAAEN47DwsgAEEMahCsLAsLJgACQAJAAkAgAC0AkAEOBAECAgACCyAAEKItCyAAQYQBahDtOwsLJgACQAJAAkAgAC0AkAEOBAECAgACCyAAEKMtCyAAQYQBahDtOwsLJAACQAJAAkAgAC0AOA4EAQICAAILIAAQ+ywLIABBLGoQ3jsLCygAIAEgACgCAC0AAEECdCIAQaj1wwBqKAIAIABB/PTDAGooAgAQ+zULiAEBA38jAEEQayIBJAAgASAAEPcXIwBBEGsiACQAIAEoAgwiAhCINSACQTBBCBD4OiAAQQhqIAFBCGooAgAiAjYCACAAIAEpAgA3AwAgAgRAIAAoAgQhAwNAIAMQhzUgA0FAayEDIAJBAWsiAg0ACwsgAEEIQcAAEOAeIABBEGokACABQRBqJAALIAAgACgCaCAAKAIIIAAoAiBqIAAoAkBBA3RqakHQAWoLGgAgAEFAaxDjPCAAKQMAQgJSBEAgABCRKgsLGgAgAEFAaxDeOyAAKQMAQgJSBEAgABCRKgsLGgAgAEFAaxDpOyAAKQMAQgJSBEAgABCRKgsLKAAgASAAKAIALQAAQQJ0IgBBgIzPAGooAgAgAEGki88AaigCABD7NQsoACABIAAoAgAtAABBAnQiAEH8jM8AaigCACAAQdyMzwBqKAIAEPs1CygAIAEgACgCAC0AAEECdCIAQcCNzwBqKAIAIABBnI3PAGooAgAQ+zULHQAgACABbEEEaiIAQQQQrjYiASAANgIAIAFBBGoLIQEBfyAAIAAoAgQiAiABajYCBCAAKAIAIAJ0QQAgAWt2CxoAIAIgAWsgACAAIAFqIAJLGyAAIAEgAkkbCxwAIAFBCE8EQCABQQggAhDDIQALIAAgAUECdGoLIAEBf0EBIQEgAEH/AXFBAkcEfyAAEIscQf8BcQUgAQsLKAAgASAAKAIALQAAQQJ0IgBB+Kf+AGooAgAgAEG4p/4AaigCABD7NQsiAQF/IwBBMGsiAiQAIAIgARCAFSAAIAIQnBUgAkEwaiQACyIBAX8jAEEwayICJAAgAiABEIAVIAAgAhCeFSACQTBqJAALIgEBfyMAQTBrIgIkACACIAEQgBUgACACEL0VIAJBMGokAAsiAQF/IwBBMGsiAiQAIAIgARCAFSAAIAIQmhUgAkEwaiQACyIBAX8jAEEwayICJAAgAiABEIAVIAAgAhCbFSACQTBqJAALIgEBfyMAQTBrIgIkACACIAEQgBUgACACEJ0VIAJBMGokAAsgACAAKAJMBEAgAEHMAGoQ1B4LIAAQ2ycgAEFAaxDUHgslAQF/IAAgASgCACIBKAI0IgM2AgQgACABKAIQIAIgA2xqNgIACygAIAEgACgCAC0AAEECdCIAQZTOhwFqKAIAIABBiM6HAWooAgAQ+zULKAAgASAAKAIALQAAQQJ0IgBBsM6HAWooAgAgAEGgzocBaigCABD7NQsjAQF/IAAgASgCAEEIaiICNgIAIAAgAiABKAIEQQJ0ajYCBAsjAQF/IAAgASgCAEEIaiICNgIAIAAgAiABKAIEQQN0ajYCBAsnAQJ+IAEpAxAhAiABKQMYIQMgACABEP4iIAAgAzcDGCAAIAI3AxALIwAgACACNwMIIAAgATcDACAAIAJCP4ciATcDGCAAIAE3AxALIwAgACABNwMAIAAgAUI/hyIBNwMYIAAgATcDECAAIAE3AwgLIwAgAEIANwMYIABCADcDECAAQgA3AwggACABrUL/AYM3AwALJAAgAEIANwMYIABCADcDECAAQgA3AwggACABrUL//wODNwMACyABAX9BASEBIAAoAgAiAEEBcQR/IAEFIAAoAghBAUYLCyMAIAAoAghBgICAgHhHBEAgAEEIakEBQQEQ4B4PCyAAELwqCyUAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgBCAFIAEoAhARCQALIAAgAC0AAEEDRgRAIAAoAgQiABC8KiAAQQxBBBD4OgsLHgAgABCdPCAAKAIMQYGAgIB4RwRAIABBDGoQhjALCx0AIAAoAgBBAkcEQCAAQQRqEIYwIABBEGoQhjALCx8AIAAQyykgACgCQCIABEAgABDpJiAAQRBBBBD4OgsLHgAgACgCAEGAgICAeEcEQCAAEPU7IABBDGoQhTALCyUAIAEgAC0AAEECdCIAQfTnwwBqKAIAIABBzOfDAGooAgAQ+zULJQAgAC0AAEECdCIAQYD2wwBqKAIAIABB1PXDAGooAgAgARCpPQsdACAAKAIcIAFLBEAgACABEMEPDwsgACgCFEECawsZAQF/IAEgA0YEfyAAIAIgARCZJ0UFIAQLCygAIAAgASgCkAM2AgQgACABKAKMA0EAIAEoAogDQYCAgIB4Rxs2AgALKAAgACABKAKcAzYCBCAAIAEoApgDQQAgASgClANBgICAgHhHGzYCAAsoACAAIAEoAogDNgIEIAAgASgChANBACABKAKAA0GAgICAeEcbNgIACygAIAAgASgClAM2AgQgACABKAKQA0EAIAEoAowDQYCAgIB4Rxs2AgALIQAgACABKAIINgIEIAAgASgCBEEAIAEoAgBBBUYbNgIACygAIAAgASgCwAI2AgQgACABKAK8AkEAIAEoArgCQYCAgIB4Rxs2AgALKAAgACABKALMAjYCBCAAIAEoAsgCQQAgASgCxAJBgICAgHhHGzYCAAsdACACQSdOBEAgACABIAIQshAPCyAAIAEgAhCxEAsSACAAQRhqEN47IABBCGoQ3jsLGwAgACgCKCAALQAsIgBBA3YgAEEHcUEAR2pqCx4AIABBQGtBBEEMEOAeIAApAwBCAlIEQCAAEJEqCwslACABIAAtAABBAnQiAEHExc4AaigCACAAQYTFzgBqKAIAEPs1CyUAIAEgAC0AAEECdCIAQcTtzgBqKAIAIABBhO3OAGooAgAQ+zULHQAgAEEEaiABIAKnIgEgASADahDSECAAQQg2AgALIAEBfyMAQRBrIgEkACABIAAgACgCDBD4GCABQRBqJAALGwAgACgCACgCACABKAIAIAJBdGxqQQxrEOwMCxsAIAAoAgAoAgAgASgCACACQXRsakEMaxDrDAsdACAAKQMAQgJSBEAgAEEQahCFMCAAQRxqEIUwCwsjACAAKAIAQYGAgIB4SgRAIAAQ0SsgABDoOyAAQQxqEIYwCwsfACAAQSxqEN0tIAAQhjAgAEEMahCGMCAAQRhqEIYwCyUAIAEgAC0AAEECdCIAQfjs0ABqKAIAIABB2OzQAGooAgAQ+zULJQAgASAALQAAQQJ0IgBB9O3QAGooAgAgAEGY7dAAaigCABD7NQshACAAIAEgAi8BABC1LDYCACABEP0YGiAAIAJBBGo2AgQLIAEBfyABKAIAIgIEQCABKAIIIAAgAhECAA8LIAAQhi8LGgEBfyAAKAIAQQFGBH8gASAAKAIMbgUgAgsLIQAgACABIAIoAgQQtiw2AgAgARD9GBogACACQQhqNgIECyEAAkAgAQ0AIAAoAgBBAUcNACACQQI2AgAgAEEANgIACwsfACAAQQEgACgCAEGngwFsIgAgAEEBTRsiADYCACAACyUAIAEgAC0AAEECdCIAQfin/gBqKAIAIABBuKf+AGooAgAQ+zULJQAgASAALQAAQQJ0IgBBpLL+AGooAgAgAEGIsv4AaigCABD7NQslACABIAAtAABBAnQiAEHcsv4AaigCACAAQcCy/gBqKAIAEPs1CyUAIAEgAC0AAEECdCIAQaSz/gBqKAIAIABB+LL+AGooAgAQ+zULHQAgACgCACgCACABKAIAIAJBsH9sakHQAGsQjQ4LJQAgASAALQAAQQJ0IgBBrLSAAWooAgAgAEGctIABaigCABD7NQsbACAAKAIAKAIAIAEoAgAgAkFQbGpBMGsQrQwLCgAgACABEKM9AAslACABIAAtAABBAnQiAEHshIcBaigCACAAQdyEhwFqKAIAEPs1CyUAIAEgAC0AAEECdCIAQbDOhwFqKAIAIABBoM6HAWooAgAQ+zULJQAgASAALQAAQQJ0IgBBrNWHAWooAgAgAEGc1YcBaigCABD7NQslACABIAAtAABBAnQiAEGs54cBaigCACAAQZznhwFqKAIAEPs1CyUAIAEgAC0AAEECdCIAQczshwFqKAIAIABBvOyHAWooAgAQ+zULIwEBfyAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABCYKQsLJAAgAEUEQEHwrIgBQTIQlz0ACyAAIAIgAyAEIAEoAhARgwEACyQAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgBCABKAIQEYUBAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEFAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEKAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEsAAsoAQF/IAAoAgAiAUGAgICAeHJBgICAgHhHBEAgACgCBCABQQEQ+DoLCyUAIAEgAC0AAEECdCIAQfS+iQFqKAIAIABBzL2JAWooAgAQ+zULHgAgACABQQNyNgIEIAAgAWoiACAAKAIEQQFyNgIECxkBAX8gASADTwR/IAIgACADEJknRQUgBAsLHwAgACgCAEGAgICAeEcEQCAAEOkrDwsgAEEEahDuDQsVACAALQAUQQRGBEAgAEEYahDeOwsLFQAgAC0ACEEERgRAIABBDGoQ3jsLCxsAIAApAwBCA1IEQCAAEKkeDwsgAEEIahChKQsVACAAKAIAQQJHBEAgAEEQahDeOwsLHwACQCAAKAIARQ0AIAAoAgQiAEGEAUkNACAAEPIfCwseACAAQQA2AgwgACABNgIIIAAgASgCKEVBAXQ2AgALIAAgAEEBaiABIAAtAABBAnRBoITEAGooAgAoAhARAgALHwAgACkDAEIEUgRAIAAQkiogACgCQEGAEEECEPg6CwsXACAAQTRqEN47IABBKGoQlAwgABCTJwsVACAALQAAQQpGBEAgAEEEahDeOwsLFwAgAEE0ahDeOyAAQShqEJUMIAAQkycLGQAgACgCCEGAgICAeEcEQCAAQQhqEN47CwsfACAAKQMAQgRSBEAgABClISAAKAJAQYAQQQIQ+DoLCxcAIABBNGoQ3jsgAEEoahCdDCAAEJMnCx0BAX8gACgCBCIBBEAgACgCACABQQF0QQIQ+DoLCx0BAX8gACgCBCIBBEAgACgCACABQQJ0QQQQ+DoLCxwBAX8gAEEEaiIAQQQQrTYiASAANgIAIAFBBGoLHQAgACABIAIgAyAEIAVBACAGIAcgCCAJIAoQ2AgLHQAgACABIAIgAyAEIAVBASAGIAcgCCAJIAoQ2AgLGQAgACgCDEGAgICAeEcEQCAAQQxqEN47CwsXACAAEN47IAAoAgwEQCAAQQxqEM8vCwsgAQF/IAAgASgCBCICNgIAIAAgAiABKAIIQWBxajYCBAsgAQF/IAAgASgCBCICNgIAIAAgAiABKAIIQXBxajYCBAscACAAIAFBMGtB/wFxIgE2AgQgACABQQpJNgIACxwAIAAgAUEwa0H/AXEiATsBAiAAIAFBCkk7AQALIAEBfyAAIAEoAgQiAjYCACAAIAIgASgCCEF8cWo2AgQLIAEBfyAAIAEoAgQiAjYCACAAIAIgASgCCEF4cWo2AgQLGgAgAEEMahDUHiAAKAIYBEAgAEEYahDUHgsLGgAgAEEMahD5IyAAKAIUBEAgAEEUahDUHgsLIwAgAUGAzocBQfrNhwEgACgCAC0AACIAG0EFQQYgABsQ+zULHwAgAEIANwMYIABCADcDECAAQgA3AwggACABrTcDAAsgACAAIAEoAgwiACAAIAEoAhBqIAEoAgQgASgCCBC/GAsfACAARQRAQaypiAFBMhCXPQALIAAgAiABKAIQEQAACyEAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgASgCEBEBAAsdACABKAIABEAgAEHstYkBNgIEIAAgATYCAA8LAAscAQF/IAAoAgAiAgRAIAEgAiAAKAIEEPs1DwsACyQAIAAtAABFBEAgAUGE94kBQQUQ1gkPCyABQYn3iQFBBBDWCQsfACAAEN8SIgAgAiYBIAEQ3xIiASADJgEgACABEJcvCxwAIAAtAJQDQQNGBEAgABDIIyAAQYgDahDkKgsLHgAgABD5JSAAKAIUQYGAgIB4RwRAIABBFGoQ9S4LCx8AIAAoAgBBgICAgHhHBEAgABCBIyAAQQRBCBDgHgsLGwAgACgCACIABEAgABD8LCAAQYgCQQgQ+DoLCxwAIAEgAhDoE0UEQCAAIAEQ2RwPCyAAQg03AwALHAAgASACEPMVRQRAIAAgARD3FA8LIABBCTYCAAsdACAARQRAQdjiwwBBMhCXPQALIAAgASgCEBEDAAsbACABQRh0QQAgAUGA/P//A3FBgLADRhsgAHILHgAgACABKAIAIgFBGHY6AAQgACABQf///wdxNgIACxgAIABBAXEEQCABDwtBsMfMAEExEJc9AAsbAQF/IAAgARCtNiICRQRAIAEgABCjPQALIAILGwEBf0EUQQQQrTYiAEUEQEEEQRQQoz0ACyAACx0BAX9BxABBBBCtNiIARQRAQQRBxAAQoz0ACyAACxsBAX9BBEEEEK02IgBFBEBBBEEEEKM9AAsgAAsbAQF/QRxBBBCtNiIARQRAQQRBHBCjPQALIAALGAAgAUEYaiACIANBA3QQoTYgAEEINgIACxgAIAFBGGogAiADQQJ0EKE2IABBCDYCAAsaACAAKAIIIAAoAiBqIAAoAkBBA3RqQeAAagsfACAAKAIAQYCAgIB4RwRAIAAQ4CkgAEEEQRgQ4B4LCxkAIwBBEGskAEHtjc4AQQ9BnI7OABCfKQALGQAjAEEQayQAQe2NzgBBD0H8jc4AEJ8pAAsYACABIAIgAiADQQN0ahC9JiAAQQg2AgALGAAgASACIAIgA0ECdGoQvSYgAEEINgIACxkAIwBBEGskAEHtjc4AQQ9BjI7OABCfKQALGwAgACgCACgCACABKAIAIAJBBHRrQRBrEOcLCxsAIAAoAgAoAgAgASgCACACQQZ0a0FAahDuCwseACAAKAIAQYGAgIB4RwRAIABBDGoQnQwgABDJKAsLIAAgACgCAEGAgICAeEcEQCAAEPcdIABBBEHgABDgHgsLHwAgACgCAEGAgICAeEcEQCAAEMYqIABBBEEMEOAeCwsfACAAKAIAQYCAgIB4RwRAIAAQxyogAEEEQQwQ4B4LCyAAIAAoAgBBgICAgHhHBEAgABD0GyAAQQhB0AAQ4B4LCyIAIABBADsBcCAAQYCAgIB4NgJgIABBADYCCCAAQQA2AgALHAAgASACEKkgRQRAIAAgARDfHA8LIABCDTcDAAsgACAAQQA6AAQgAEGAgAE7AAUgAEEEOwECIABBADoAAAsbACAAKAIAKAIAIAEoAgAgAkEEdGtBEGsQjQ4LIgAgACACNgIUIAAgATYCECAAQgQ3AgggAEKFgICACDcCAAsbACAAKAIAKAIAIAEoAgAgAkEDdGtBCGsQrgwLGwAgACgCACgCACABKAIAIAJBA3RrQQhrEK8MCxsAIAAoAgAoAgAgASgCACACQQN0a0EIaxCrDAsbACAAKAIAKAIAIAEoAgAgAkEEdGtBEGsQrAwLGwAgACgCACgCACABKAIAIAJBBXRrQSBrELAMC4MBAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBEKKos3losKqiWqFIANCi7L53s2au945hYRQGyIARQRAQcjwgwFBDUHY8IMBEMskAAsgAAuFAQIBfwJ+IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAAgAikDGCEDIAIpAxAhBCACQSBqJAAgAEEAIARC/9nrqtfYi4zxAIUgA0KB9OGjqvjW6ot/hYRQGyIARQRAQZDygwFBFUGo8oMBEMskAAsgAAuEAQIBfwJ+IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAAgAikDGCEDIAIpAxAhBCACQSBqJAAgAEEAIARClY2j2tTIv9zGAIUgA0Kzz/m4y5qOxTKFhFAbIgBFBEBB4PKDAUEJQezygwEQyyQACyAAC4QBAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBEK+uaqJmdKNmuAAhSADQsWRgbqRwsPNNIWEUBsiAEUEQEGk9IMBQQxBsPSDARDLJAALIAALHAAgASgCACIBRQRAIABBADYCAA8LIAAgARDlOgscACAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIACxsBAX8gAEEEEK02IgFFBEBBBCAAEKM9AAsgAQsbAQF/QRBBBBCtNiIARQRAQQRBEBCjPQALIAALGwEBf0EMQQQQrTYiAEUEQEEEQQwQoz0ACyAACx4AIABCADcDGCAAQgA3AxAgAEIANwMIIAAgATcDAAsdAQF/IAAoAgQiAQRAIAAoAgggASAAKAIAEPg6CwshACAAQQA2AgwgACADNgIIIAAgAjYCBCAAQdCFiAE2AgALHgAgACABKAIAJQEQPDYCCCAAQQA2AgQgACABNgIACx8AIABFBEBB8KyIAUEyEJc9AAsgACACIAEoAhARAgALHAAgACAALQAEIAFBLkZyOgAEIAAoAgAgARCDNgscACAAQQxqIAAoAgQgACgCCCAAKAIAKAIQEQEACxoAIAAQkT4gACgCACIAQYQBTwRAIAAQ8h8LCxcAIABBAXEEQEHU28MAQTEQlz0ACyABC38CAn8BfkH484oBKAIARQRAIwBBEGsiASQAQYj0igECfgJAIABFDQAgACgCACAAQgA3AwBBAXFFDQAgACkDCCEDIAApAxAMAQsgARDjJiABKQMAIQMgASkDCAs3AwBBgPSKASADNwMAQfjzigFCATcDACABQRBqJAALQYD0igELyAMCA34Gf0G474oBKAIARQRAIwBBMGsiBiQAAn8gAEUEQEH40cwAIQRBAAwBCyAAKAIAIQQgAEEANgIAIABBCGpB+NHMACAEQQFxIgUbIQQgACgCBEEAIAUbCyEFIAZBEGogBEEIaikCACICNwMAIAYgBCkCACIDNwMIIAZBKGpByO+KASkCADcDACAGQSBqIgBBwO+KASkCADcDAEG474oBKQIAIQFBvO+KASAFNgIAQbjvigFBATYCAEHA74oBIAM3AgBByO+KASACNwIAIAYgATcDGCABpwRAAkAgACgCBCIHRQ0AIAAoAgwiCARAIAAoAgAiBEEIaiEFIAQpAwBCf4VCgIGChIiQoMCAf4MhAQNAIAFQBEADQCAEQeAAayEEIAUpAwAgBUEIaiEFQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgAUKAgYKEiJCgwIB/hSEBCyAEIAF6p0EDdkF0bGpBBGsoAgAiCUGEAU8EQCAJEPIfCyABQgF9IAGDIQEgCEEBayIIDQALCyAHIAdBDGxBE2pBeHEiBGpBCWoiBUUNACAAKAIAIARrIAVBCBD4OgsLIAZBMGokAAtBvO+KAQsWACAAEOY8IABBDGoiABDFJyAAEOg7Cw8AIAAQ6TsgAEEMahDeOwsPACAAEOM8IABBDGoQ3jsLGwAgABCdLCAAQeAAaiIAENwlIABBBEEQEOAeCx0AIAEgACgCAC0AAEECdEHkjc8AaigCAEEIEPs1CxwBAX8gARDSPSECIAAgATYCBCAAIAJBAEc2AgALHQAgACABNgIAIAAgASgCCDYCDCAAIAEpAgA3AgQLFgAgACABIAIQmSciAEEASiAAQQBIawsZACAAIAEgAiADIAQgBSAGIAdBAEEDELwCCxkAIAAgASACIAMgBCAFIAYgB0EAQQQQvAILGQAgACABIAIgAyAEIAUgBiAHQQBBBRC8AgsZACAAIAEgAiADIAQgBSAGIAdBAEEGELwCCxkAIAAgASACIAMgBCAFIAYgB0EBQQMQvAILGQAgACABIAIgAyAEIAUgBiAHQQFBBBC8AgsZACAAIAEgAiADIAQgBSAGIAdBAUEFELwCCxkAIAAgASACIAMgBCAFIAYgB0EBQQYQvAILGQAgACABIAIgAyAEIAUgBiAHQQJBAxC8AgsZACAAIAEgAiADIAQgBSAGIAdBAkEEELwCCxkAIAAgASACIAMgBCAFIAYgB0ECQQUQvAILGQAgACABIAIgAyAEIAUgBiAHQQJBBhC8AgsQACABBEAgACACIAH8CwALCxoAIABCADcCCCAAQgU3AgAgAEEQakEAOwEACxoAIABCADcCCCAAQgo3AgAgAEEQakEAOwEACxoAIABCADcCCCAAQgM3AgAgAEEQakEAOwEACxcAIAAQzy8gACgCFARAIABBFGoQzy8LCx0AIABBATYCACAAIAEoAgg2AgwgACABKQIANwIECx0AIAAoAghFBEBBAEEAQbD3hQEQwyEACyAAKAIECx0BAX8gACABKAIEIgI2AgAgACACIAEoAghqNgIECxcAIAAQ1B4gACgCFARAIABBFGoQ1B4LCxkAIAAgASgCACIAQRhqQQAgACgCGBsQ7iULFQAgACABQQN2IAFBB3FBAEdqENIfCxMAIAAgAWpBAWtBACABa3EgAGsLHAAgACgCACIAKAIAIAEgAEEEaigCACgCDBECAAsbACAAKAIIKAIAKAIQBEBB8LKJARCbPgALQQALGgEBfyAAKAIAIgEEQCAAKAIEIAFBARD4OgsLGwAgACgCCCgCACgCEARAQfCyiQEQmz4AC0EAC0IAIAAEQCAAIAEQoz0ACyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBoMGJATYCCCAAQgQ3AhAgAEEIaiACEO8sAAsdAEMAAAAAQwAAAAAgACAAQwAAAABdGyAAIABcGwscAQFvIAAlASAAEPIfEAchARDfEiIAIAEmASAAC5wBAQN/EN8SIgMgACYBIwBB8AJrIgIkACACQQA6AOgCIAIgATYC5AIgAiADNgLgAiMAQYADayIBJAAgAUEIaiIEIAJB8AL8CgAAIAFCATcDACABIAE2AvwCIAFB/AJqQeTHwgAQkz0hAwJAIAEpAwBQDQAgAS0A8AJBA0cNACAEEMopCyABQYADaiQAIAJB8AJqJAAgAyUBIAMQ8h8L4AEBA38Q3xIiAyABJgECfyMAQUBqIgIkACACQQRqIAAQ0SQgAigCBCgCACIAIAAoAgBBAWoiBDYCACAEBEAgAkEAOgA8IAIgAzYCFCACIAA2AhAjAEFAaiIAJAAgAEEMaiIDIAJBEGpBMPwKAAAgAEEBNgIIIAAgAEEIajYCPCAAQTxqQazdwwAQkz0gACgCCARAIAMQ3h8LIABBQGskACACKAIIQQA2AgAgAigCDCIAIAAoAgBBAWsiADYCACAARQRAIAJBDGoQ5yYLIAJBQGskAAwBCwALIgAlASAAEPIfC7wBAQJ/EN8SIgMgASYBIwBBIGsiAiQAIAAQySEhACACQQA6ABwgAiADNgIEIAIgADYCACMAQTBrIgAkACAAQSRqIAJBGGopAgA3AgAgAEEcaiACQRBqKQIANwIAIABBFGogAkEIaikCADcCACAAQQE2AgggACACKQIANwIMIAAgAEEIajYCLCAAQSxqQcDdwwAQkz0hAyAAKAIIBEAgAEEMahDaHAsgAEEwaiQAIAJBIGokACADJQEgAxDyHwu3AgEEfxDfEiIEIAEmAQJ/IwBB4ABrIgIkACACQRBqIAAQ0SQgAigCECIAKAIIIgMgAygCAEEBaiIFNgIAIAUEQCACQQhqEIgdIAJBADoAXCACIAQ2AiQgAiADNgIgIAIgAigCDDYCHCAAQRBqIQMgAigCCCEEAkAgACgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADEOknCyADIAQ2AgAjAEHQAGsiACQAIABBCGoiAyACQRxqQcQA/AoAACAAQQE2AgQgACAAQQRqNgJMIABBzABqQZjdwwAQkz0gACgCBARAIAMQ3xQLIABB0ABqJAAgAigCFEEANgIAIAIoAhgiACAAKAIAQQFrIgA2AgAgAEUEQCACQRhqEOoZCyACQeAAaiQADAELAAsiACUBIAAQ8h8LswIBBH8Q3xIiBCABJgECfyMAQdAAayICJAAgAkEUaiAAENEkIAIoAhQiACgCACIDIAMoAgBBAWoiBTYCACAFBEAgAkEIahCIHSACQQA6AEwgAiAENgIoIAIgAzYCJCACIAIoAgw2AiAgAEEEaiEDIAIoAgghBAJAIAAoAgQiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAxDpJwsgAyAENgIAIwBBQGoiACQAIABBDGoiAyACQSBqQTD8CgAAIABBATYCCCAAIABBCGo2AjwgAEE8akHU3cMAEJM9IAAoAggEQCADENMWCyAAQUBrJAAgAigCGEEANgIAIAIoAhwiACAAKAIAQQFrIgA2AgAgAEUEQCACQRxqEO8dCyACQdAAaiQADAELAAsiACUBIAAQ8h8LFgAgACgCAEGAgICAeEcEQCAAEOM8CwsWACAAKAIAQYCAgIB4RwRAIAAQ3jsLCxsAIAAoAgBBgICAgHhHBEAgABDgKSAAEPI7CwsfACAAQQhqQZzKwgApAgA3AgAgAEGUysIAKQIANwIACx8AIABBCGpBrMrCACkCADcCACAAQaTKwgApAgA3AgALFQAgAC0AGEEDRgRAIABBFGoQriwLCxYAIAAtAIQDQQNGBEAgAEEIahD2LAsLFQAgAC0ALEEDRgRAIABBCGoQoCULCx8AIABBCGpB9N/CACkCADcCACAAQezfwgApAgA3AgALFgAgACgCAEGAgICAeEcEQCAAEOo7CwsbACAAKAIAQYCAgIB4RwRAIAAQ0C4gABDqOwsLHwAgAEEIakGIiMMAKQIANwIAIABBgIjDACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQ6zsLCxsAIAAoAgBBgICAgHhHBEAgABD0GyAAEO87CwsfACAAQQhqQZimwwApAgA3AgAgAEGQpsMAKQIANwIACx8AIABBCGpBqKbDACkCADcCACAAQaCmwwApAgA3AgALHwAgAEEIakG4psMAKQIANwIAIABBsKbDACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQ8DsLCxYAIAAoAgBBgICAgHhHBEAgABDpOwsLGwAgACgCAEGAgICAeEcEQCAAENErIAAQ6DsLCx8AIABBCGpBkNvDACkCADcCACAAQYjbwwApAgA3AgALHwAgAEEIakG848MAKQIANwIAIABBtOPDACkCADcCAAsfACAAQQhqQczjwwApAgA3AgAgAEHE48MAKQIANwIACx8AIABBCGpB3OPDACkCADcCACAAQdTjwwApAgA3AgALHwAgAEEIakHs48MAKQIANwIAIABB5OPDACkCADcCAAsfACAAQQhqQaTowwApAgA3AgAgAEGc6MMAKQIANwIACx8AIABBCGpBrPfDACkCADcCACAAQaT3wwApAgA3AgALHwAgAEEIakG898MAKQIANwIAIABBtPfDACkCADcCAAsfACAAQQhqQcz3wwApAgA3AgAgAEHE98MAKQIANwIACx8AIABBCGpB3PfDACkCADcCACAAQdT3wwApAgA3AgALHwAgAEEIakHs98MAKQIANwIAIABB5PfDACkCADcCAAsfACAAQQhqQfz3wwApAgA3AgAgAEH098MAKQIANwIACx8AIABBCGpBjPjDACkCADcCACAAQYT4wwApAgA3AgALGgAgAEEANgIIIABCATcCACAAIAEpAgA3AhALHwAgAEEIakGYx8wAKQIANwIAIABBkMfMACkCADcCAAsfACAAQQhqQYj8zAApAgA3AgAgAEGA/MwAKQIANwIACx8AIABBCGpBmPzMACkCADcCACAAQZD8zAApAgA3AgALHwAgAEEIakGo/MwAKQIANwIAIABBoPzMACkCADcCAAsfACAAQQhqQbj8zAApAgA3AgAgAEGw/MwAKQIANwIACx8AIABBCGpByPzMACkCADcCACAAQcD8zAApAgA3AgALHwAgAEEIakHY/MwAKQIANwIAIABB0PzMACkCADcCAAsfACAAQQhqQej8zAApAgA3AgAgAEHg/MwAKQIANwIACx8AIABBCGpB+PzMACkCADcCACAAQfD8zAApAgA3AgALHwAgAEEIakGI/cwAKQIANwIAIABBgP3MACkCADcCAAsfACAAQQhqQZj9zAApAgA3AgAgAEGQ/cwAKQIANwIACx8AIABBCGpBqP3MACkCADcCACAAQaD9zAApAgA3AgALHwAgAEEIakG4/cwAKQIANwIAIABBsP3MACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQnTwLCx8AIABBCGpBuK3NACkCADcCACAAQbCtzQApAgA3AgALHwAgAEEIakHIrc0AKQIANwIAIABBwK3NACkCADcCAAsfACAAQQhqQditzQApAgA3AgAgAEHQrc0AKQIANwIACx8AIABBCGpB6K3NACkCADcCACAAQeCtzQApAgA3AgALHwAgAEEIakH4rc0AKQIANwIAIABB8K3NACkCADcCAAsfACAAQQhqQYiuzQApAgA3AgAgAEGArs0AKQIANwIACx8AIABBCGpBmK7NACkCADcCACAAQZCuzQApAgA3AgALHwAgAEEIakGors0AKQIANwIAIABBoK7NACkCADcCAAsfACAAQQhqQbiuzQApAgA3AgAgAEGwrs0AKQIANwIACx8AIABBCGpByK7NACkCADcCACAAQcCuzQApAgA3AgALHwAgAEEIakHYrs0AKQIANwIAIABB0K7NACkCADcCAAsfACAAQQhqQeiuzQApAgA3AgAgAEHgrs0AKQIANwIACx8AIABBCGpB+K7NACkCADcCACAAQfCuzQApAgA3AgALHwAgAEEIakGIr80AKQIANwIAIABBgK/NACkCADcCAAsfACAAQQhqQaitzQApAgA3AgAgAEGgrc0AKQIANwIACx8AIABBCGpBmK/NACkCADcCACAAQZCvzQApAgA3AgALHwAgAEEIakGor80AKQIANwIAIABBoK/NACkCADcCAAsfACAAQQhqQbivzQApAgA3AgAgAEGwr80AKQIANwIACx8AIABBCGpByK/NACkCADcCACAAQcCvzQApAgA3AgALHwAgAEEIakHYr80AKQIANwIAIABB0K/NACkCADcCAAsfACAAQQhqQeivzQApAgA3AgAgAEHgr80AKQIANwIACx8AIABBCGpB+K/NACkCADcCACAAQfCvzQApAgA3AgALHwAgAEEIakGIsM0AKQIANwIAIABBgLDNACkCADcCAAsfACAAQQhqQZiwzQApAgA3AgAgAEGQsM0AKQIANwIACx8AIABBCGpBqLDNACkCADcCACAAQaCwzQApAgA3AgALHwAgAEEIakG4sM0AKQIANwIAIABBsLDNACkCADcCAAsfACAAQQhqQciwzQApAgA3AgAgAEHAsM0AKQIANwIACx8AIABBCGpB2LDNACkCADcCACAAQdCwzQApAgA3AgALHwAgAEEIakGYrc0AKQIANwIAIABBkK3NACkCADcCAAsfACAAQQhqQeiwzQApAgA3AgAgAEHgsM0AKQIANwIACx8AIABBCGpB+LDNACkCADcCACAAQfCwzQApAgA3AgALHwAgAEEIakGIsc0AKQIANwIAIABBgLHNACkCADcCAAsfACAAQQhqQZixzQApAgA3AgAgAEGQsc0AKQIANwIACx8AIABBCGpBqLHNACkCADcCACAAQaCxzQApAgA3AgALHwAgAEEIakG4sc0AKQIANwIAIABBsLHNACkCADcCAAsfACAAQQhqQcixzQApAgA3AgAgAEHAsc0AKQIANwIACx8AIABBCGpB2LHNACkCADcCACAAQdCxzQApAgA3AgALHwAgAEEIakHosc0AKQIANwIAIABB4LHNACkCADcCAAsfACAAQQhqQdCyzQApAgA3AgAgAEHIss0AKQIANwIACx8AIABBCGpB4LLNACkCADcCACAAQdiyzQApAgA3AgALHwAgAEEIakHwss0AKQIANwIAIABB6LLNACkCADcCAAsfACAAQQhqQYCzzQApAgA3AgAgAEH4ss0AKQIANwIACx8AIABBCGpBsPHNACkCADcCACAAQajxzQApAgA3AgALGQAgACgCCCIAQfgAakEAIABBgICAgHhHGwsWACAAQQRqIAEgAqcQ6hQgAEEINgIACx8AIABBCGpBwJzPACkCADcCACAAQbiczwApAgA3AgALHwAgAEEIakHQnM8AKQIANwIAIABByJzPACkCADcCAAsfACAAQQhqQeCczwApAgA3AgAgAEHYnM8AKQIANwIACx8AIABBCGpB8JzPACkCADcCACAAQeiczwApAgA3AgALHwAgAEEIakGAnc8AKQIANwIAIABB+JzPACkCADcCAAsfACAAQQhqQZCdzwApAgA3AgAgAEGInc8AKQIANwIACx8AIABBCGpBoJ3PACkCADcCACAAQZidzwApAgA3AgALHwAgAEEIakGwnc8AKQIANwIAIABBqJ3PACkCADcCAAsfACAAQQhqQcCdzwApAgA3AgAgAEG4nc8AKQIANwIACx8AIABBCGpB0J3PACkCADcCACAAQcidzwApAgA3AgALHwAgAEEIakHgnc8AKQIANwIAIABB2J3PACkCADcCAAsfACAAQQhqQfCdzwApAgA3AgAgAEHonc8AKQIANwIACx8AIABBCGpBgJ7PACkCADcCACAAQfidzwApAgA3AgALHwAgAEEIakGQns8AKQIANwIAIABBiJ7PACkCADcCAAsfACAAQQhqQaCezwApAgA3AgAgAEGYns8AKQIANwIACxcAIAAQnQwgAEEYahC8KiAAQQxqEJ0MCxgAIAAQgSMgAEEEQQgQ4B4gAEEMahCdDAsbACAAKAIAQYCAgIB4RwRAIAAQ1ysgABDoOwsLHwAgAEEIakHEoNAAKQIANwIAIABBvKDQACkCADcCAAsfACAAQQhqQdSg0AApAgA3AgAgAEHMoNAAKQIANwIACx8AIABBCGpB5KDQACkCADcCACAAQdyg0AApAgA3AgALHwAgAEEIakG8otAAKQIANwIAIABBtKLQACkCADcCAAsfACAAQQhqQcyi0AApAgA3AgAgAEHEotAAKQIANwIACx8AIABBCGpBkODQACkCADcCACAAQYjg0AApAgA3AgALHwAgAEEIakHY7tAAKQIANwIAIABB0O7QACkCADcCAAs7ACAAIANBAnRqIgAgAiABQQJ0aigCACIBIAAoAghqNgIIIAAgACgCACABdiABIAFBgH5xIAQbcjYCAAseACAAKAKU6wEQ2iIgAEEANgKk6wEgAEIANwKU6wELFQAgAC0AAEECRgRAIABBBGoQuS4LCx8AIABBCGpB+MbRACkCADcCACAAQfDG0QApAgA3AgALEwBCkJQHIABBDnGtiEIOg0InfAsTACABBEAgACABQQJ0QQQQ+DoLCx8AIABBCGpB9Lv7ACkCADcCACAAQey7+wApAgA3AgALHwAgAEEIakGEvPsAKQIANwIAIABB/Lv7ACkCADcCAAuzBAECfyAAIAAoAhAgAmo2AhAgACAAKQMAIAKtfDcDACAAKAIIQX9zIQMCQCACQcAASQ0AIAFBEGohAQNAIAJBD0sEQCABQRBrLQAAIANB/wFxc0ECdEGQiv4AaigCACABQQ9rLQAAIANBCHZB/wFxc0ECdEGQgv4AaigCACABQQ5rLQAAIANBEHZB/wFxc0ECdEGQ+v0AaigCACABQQ1rLQAAIANBGHZzQQJ0QZDy/QBqKAIAIAFBDGstAABBAnRBkOr9AGooAgAgAUELay0AAEECdEGQ4v0AaigCACABQQprLQAAQQJ0QZDa/QBqKAIAIAFBCWstAABBAnRBkNL9AGooAgAgAUEIay0AAEECdEGQyv0AaigCACABQQdrLQAAQQJ0QZDC/QBqKAIAIAFBBmstAABBAnRBkLr9AGooAgAgAUEFay0AAEECdEGQsv0AaigCACABQQRrLQAAQQJ0QZCq/QBqKAIAIAFBA2stAABBAnRBkKL9AGooAgAgAUECay0AAEECdEGQmv0AaigCACABQQFrLQAAQQJ0QZCS/QBqKAIAc3Nzc3Nzc3Nzc3Nzc3NzIQMgAkEQayECAkAgBEEBaiIEQQRHDQBBACEEIAJBP0sNAAwDCyABQRBqIQEMAQsLQQ8gAkGAkv0AEMMhAAsgAgRAA0AgAS0AACADc0H/AXFBAnRBkJL9AGooAgAgA0EIdnMhAyABQQFqIQEgAkEBayICDQALCyAAIANBf3M2AggLHwAgAEEIakHQov4AKQIANwIAIABByKL+ACkCADcCAAsfACAAQQhqQdiz/gApAgA3AgAgAEHQs/4AKQIANwIACx8AIABBCGpB5NT+ACkCADcCACAAQdzU/gApAgA3AgALHwAgAEEIakH01P4AKQIANwIAIABB7NT+ACkCADcCAAsfACAAQQhqQaie/wApAgA3AgAgAEGgnv8AKQIANwIACx8AIABBCGpByJ7/ACkCADcCACAAQcCe/wApAgA3AgALHwAgAEEIakGYn/8AKQIANwIAIABBkJ//ACkCADcCAAsfACAAQQhqQaif/wApAgA3AgAgAEGgn/8AKQIANwIACx8AIABBCGpBiJ//ACkCADcCACAAQYCf/wApAgA3AgALHwAgAEEIakG4nv8AKQIANwIAIABBsJ7/ACkCADcCAAsfACAAQQhqQeie/wApAgA3AgAgAEHgnv8AKQIANwIACx8AIABBCGpBuJ//ACkCADcCACAAQbCf/wApAgA3AgALHwAgAEEIakHIn/8AKQIANwIAIABBwJ//ACkCADcCAAsfACAAQQhqQdif/wApAgA3AgAgAEHQn/8AKQIANwIACx8AIABBCGpB6J//ACkCADcCACAAQeCf/wApAgA3AgALHwAgAEEIakH4n/8AKQIANwIAIABB8J//ACkCADcCAAsfACAAQQhqQZie/wApAgA3AgAgAEGQnv8AKQIANwIACx8AIABBCGpBiKD/ACkCADcCACAAQYCg/wApAgA3AgALHwAgAEEIakGYoP8AKQIANwIAIABBkKD/ACkCADcCAAsfACAAQQhqQaig/wApAgA3AgAgAEGgoP8AKQIANwIACx8AIABBCGpBuKD/ACkCADcCACAAQbCg/wApAgA3AgALHwAgAEEIakH4nv8AKQIANwIAIABB8J7/ACkCADcCAAsfACAAQQhqQdie/wApAgA3AgAgAEHQnv8AKQIANwIACx8AIABBCGpB+J3/ACkCADcCACAAQfCd/wApAgA3AgALHwAgAEEIakHIoP8AKQIANwIAIABBwKD/ACkCADcCAAsfACAAQQhqQYie/wApAgA3AgAgAEGAnv8AKQIANwIACx8AIABBCGpB8ML/ACkCADcCACAAQejC/wApAgA3AgALHwAgAEEIakGAw/8AKQIANwIAIABB+ML/ACkCADcCAAsfACAAQQhqQZDD/wApAgA3AgAgAEGIw/8AKQIANwIACx8AIABBCGpBoMP/ACkCADcCACAAQZjD/wApAgA3AgALHwAgAEEIakGww/8AKQIANwIAIABBqMP/ACkCADcCAAsfACAAQQhqQcDD/wApAgA3AgAgAEG4w/8AKQIANwIACx8AIABBCGpB0MP/ACkCADcCACAAQcjD/wApAgA3AgALHwAgAEEIakHgw/8AKQIANwIAIABB2MP/ACkCADcCAAsfACAAQQhqQfDD/wApAgA3AgAgAEHow/8AKQIANwIACx8AIABBCGpBgMT/ACkCADcCACAAQfjD/wApAgA3AgALHwAgAEEIakGQxP8AKQIANwIAIABBiMT/ACkCADcCAAsfACAAQQhqQdDC/wApAgA3AgAgAEHIwv8AKQIANwIACx8AIABBCGpBoMT/ACkCADcCACAAQZjE/wApAgA3AgALHwAgAEEIakGwxP8AKQIANwIAIABBqMT/ACkCADcCAAsfACAAQQhqQcDE/wApAgA3AgAgAEG4xP8AKQIANwIACx8AIABBCGpB0MT/ACkCADcCACAAQcjE/wApAgA3AgALHwAgAEEIakHgxP8AKQIANwIAIABB2MT/ACkCADcCAAsfACAAQQhqQfDE/wApAgA3AgAgAEHoxP8AKQIANwIACx8AIABBCGpBgMX/ACkCADcCACAAQfjE/wApAgA3AgALHwAgAEEIakGQwv8AKQIANwIAIABBiML/ACkCADcCAAsfACAAQQhqQZDF/wApAgA3AgAgAEGIxf8AKQIANwIACx8AIABBCGpBoMX/ACkCADcCACAAQZjF/wApAgA3AgALHwAgAEEIakGwxf8AKQIANwIAIABBqMX/ACkCADcCAAsfACAAQQhqQcDF/wApAgA3AgAgAEG4xf8AKQIANwIACx8AIABBCGpB0MX/ACkCADcCACAAQcjF/wApAgA3AgALHwAgAEEIakHgxf8AKQIANwIAIABB2MX/ACkCADcCAAsfACAAQQhqQfDF/wApAgA3AgAgAEHoxf8AKQIANwIACx8AIABBCGpBgMb/ACkCADcCACAAQfjF/wApAgA3AgALHwAgAEEIakGQxv8AKQIANwIAIABBiMb/ACkCADcCAAsfACAAQQhqQaDG/wApAgA3AgAgAEGYxv8AKQIANwIACx8AIABBCGpBwML/ACkCADcCACAAQbjC/wApAgA3AgALHwAgAEEIakGwxv8AKQIANwIAIABBqMb/ACkCADcCAAsfACAAQQhqQbDC/wApAgA3AgAgAEGowv8AKQIANwIACx8AIABBCGpBoML/ACkCADcCACAAQZjC/wApAgA3AgALHwAgAEEIakHAxv8AKQIANwIAIABBuMb/ACkCADcCAAsfACAAQQhqQdDG/wApAgA3AgAgAEHIxv8AKQIANwIACx8AIABBCGpB4Mb/ACkCADcCACAAQdjG/wApAgA3AgALHwAgAEEIakGAwv8AKQIANwIAIABB+MH/ACkCADcCAAsfACAAQQhqQfDG/wApAgA3AgAgAEHoxv8AKQIANwIACx8AIABBCGpBgMf/ACkCADcCACAAQfjG/wApAgA3AgALHwAgAEEIakHgwv8AKQIANwIAIABB2ML/ACkCADcCAAsfACAAQQhqQYD4/wApAgA3AgAgAEH49/8AKQIANwIACx8AIABBCGpBkPj/ACkCADcCACAAQYj4/wApAgA3AgALHwAgAEEIakGg+P8AKQIANwIAIABBmPj/ACkCADcCAAsfACAAQQhqQbD4/wApAgA3AgAgAEGo+P8AKQIANwIACx8AIABBCGpBwPj/ACkCADcCACAAQbj4/wApAgA3AgALHwAgAEEIakHQ+P8AKQIANwIAIABByPj/ACkCADcCAAsfACAAQQhqQeD4/wApAgA3AgAgAEHY+P8AKQIANwIACx8AIABBCGpB8Pj/ACkCADcCACAAQej4/wApAgA3AgALHwAgAEEIakHw9/8AKQIANwIAIABB6Pf/ACkCADcCAAsfACAAQQhqQeD3/wApAgA3AgAgAEHY9/8AKQIANwIACx8AIABBCGpBgPn/ACkCADcCACAAQfj4/wApAgA3AgALHwAgAEEIakGQ+f8AKQIANwIAIABBiPn/ACkCADcCAAsfACAAQQhqQaD5/wApAgA3AgAgAEGY+f8AKQIANwIACx8AIABBCGpBsPn/ACkCADcCACAAQaj5/wApAgA3AgALHwAgAEEIakHA+f8AKQIANwIAIABBuPn/ACkCADcCAAsfACAAQQhqQdD5/wApAgA3AgAgAEHI+f8AKQIANwIACx8AIABBCGpB4Pn/ACkCADcCACAAQdj5/wApAgA3AgALHwAgAEEIakHw+f8AKQIANwIAIABB6Pn/ACkCADcCAAsfACAAQQhqQYD6/wApAgA3AgAgAEH4+f8AKQIANwIACx8AIABBCGpB0Pf/ACkCADcCACAAQcj3/wApAgA3AgALHwAgAEEIakGQ+v8AKQIANwIAIABBiPr/ACkCADcCAAsfACAAQQhqQaD6/wApAgA3AgAgAEGY+v8AKQIANwIACx8AIABBCGpBsPr/ACkCADcCACAAQaj6/wApAgA3AgALHwAgAEEIakHA+v8AKQIANwIAIABBuPr/ACkCADcCAAsfACAAQQhqQdD6/wApAgA3AgAgAEHI+v8AKQIANwIACx8AIABBCGpB4Pr/ACkCADcCACAAQdj6/wApAgA3AgALHwAgAEEIakHw+v8AKQIANwIAIABB6Pr/ACkCADcCAAsfACAAQQhqQbiVgAEpAgA3AgAgAEGwlYABKQIANwIACx8AIABBCGpByJWAASkCADcCACAAQcCVgAEpAgA3AgALHwAgAEEIakHYlYABKQIANwIAIABB0JWAASkCADcCAAsfACAAQQhqQeiVgAEpAgA3AgAgAEHglYABKQIANwIACx8AIABBCGpB+JWAASkCADcCACAAQfCVgAEpAgA3AgALHwAgAEEIakGIloABKQIANwIAIABBgJaAASkCADcCAAsfACAAQQhqQZiWgAEpAgA3AgAgAEGQloABKQIANwIACx8AIABBCGpBqJaAASkCADcCACAAQaCWgAEpAgA3AgALHwAgAEEIakG4loABKQIANwIAIABBsJaAASkCADcCAAsfACAAQQhqQciWgAEpAgA3AgAgAEHAloABKQIANwIACx8AIABBCGpB2JaAASkCADcCACAAQdCWgAEpAgA3AgALHwAgAEEIakHoloABKQIANwIAIABB4JaAASkCADcCAAsfACAAQQhqQfiWgAEpAgA3AgAgAEHwloABKQIANwIACx8AIABBCGpBiJeAASkCADcCACAAQYCXgAEpAgA3AgALHwAgAEEIakG85IABKQIANwIAIABBtOSAASkCADcCAAsfACAAQQhqQczkgAEpAgA3AgAgAEHE5IABKQIANwIACx8AIABBCGpB3OSAASkCADcCACAAQdTkgAEpAgA3AgALHwAgAEEIakHk94ABKQIANwIAIABB3PeAASkCADcCAAsfACAAQQhqQfT1gQEpAgA3AgAgAEHs9YEBKQIANwIACx8AIABBCGpBhPaBASkCADcCACAAQfz1gQEpAgA3AgALHwAgAEEIakGU9oEBKQIANwIAIABBjPaBASkCADcCAAsfACAAQQhqQaT2gQEpAgA3AgAgAEGc9oEBKQIANwIACx8AIABBCGpBtPaBASkCADcCACAAQaz2gQEpAgA3AgALHwAgAEEIakHE9oEBKQIANwIAIABBvPaBASkCADcCAAsfACAAQQhqQdT2gQEpAgA3AgAgAEHM9oEBKQIANwIACx8AIABBCGpB5PaBASkCADcCACAAQdz2gQEpAgA3AgALHwAgAEEIakH09oEBKQIANwIAIABB7PaBASkCADcCAAsfACAAQQhqQYT3gQEpAgA3AgAgAEH89oEBKQIANwIACx8AIABBCGpBlPeBASkCADcCACAAQYz3gQEpAgA3AgALHwAgAEEIakGk94EBKQIANwIAIABBnPeBASkCADcCAAsfACAAQQhqQbT3gQEpAgA3AgAgAEGs94EBKQIANwIACx8AIABBCGpB5PWBASkCADcCACAAQdz1gQEpAgA3AgALHwAgAEEIakHE94EBKQIANwIAIABBvPeBASkCADcCAAsfACAAQQhqQdT3gQEpAgA3AgAgAEHM94EBKQIANwIACx8AIABBCGpB5PeBASkCADcCACAAQdz3gQEpAgA3AgALHwAgAEEIakH094EBKQIANwIAIABB7PeBASkCADcCAAsfACAAQQhqQYT4gQEpAgA3AgAgAEH894EBKQIANwIACx8AIABBCGpBlPiBASkCADcCACAAQYz4gQEpAgA3AgALHwAgAEEIakGk+IEBKQIANwIAIABBnPiBASkCADcCAAsfACAAQQhqQbT4gQEpAgA3AgAgAEGs+IEBKQIANwIACx8AIABBCGpBxPiBASkCADcCACAAQbz4gQEpAgA3AgALHwAgAEEIakHU+IEBKQIANwIAIABBzPiBASkCADcCAAsfACAAQQhqQeT4gQEpAgA3AgAgAEHc+IEBKQIANwIACx8AIABBCGpB9PiBASkCADcCACAAQez4gQEpAgA3AgALHwAgAEEIakGE+YEBKQIANwIAIABB/PiBASkCADcCAAsfACAAQQhqQZT5gQEpAgA3AgAgAEGM+YEBKQIANwIACx8AIABBCGpBpPmBASkCADcCACAAQZz5gQEpAgA3AgALHwAgAEEIakG0+YEBKQIANwIAIABBrPmBASkCADcCAAsfACAAQQhqQcT5gQEpAgA3AgAgAEG8+YEBKQIANwIACx8AIABBCGpB1PmBASkCADcCACAAQcz5gQEpAgA3AgALHwAgAEEIakHk+YEBKQIANwIAIABB3PmBASkCADcCAAsfACAAQQhqQfT5gQEpAgA3AgAgAEHs+YEBKQIANwIACx8AIABBCGpBhPqBASkCADcCACAAQfz5gQEpAgA3AgALHwAgAEEIakGU+oEBKQIANwIAIABBjPqBASkCADcCAAsfACAAQQhqQaT6gQEpAgA3AgAgAEGc+oEBKQIANwIACx8AIABBCGpBtPqBASkCADcCACAAQaz6gQEpAgA3AgALHwAgAEEIakHE9YEBKQIANwIAIABBvPWBASkCADcCAAsfACAAQQhqQcT6gQEpAgA3AgAgAEG8+oEBKQIANwIACx8AIABBCGpB1PqBASkCADcCACAAQcz6gQEpAgA3AgALHwAgAEEIakHk+oEBKQIANwIAIABB3PqBASkCADcCAAsfACAAQQhqQfT6gQEpAgA3AgAgAEHs+oEBKQIANwIACx8AIABBCGpB1PWBASkCADcCACAAQcz1gQEpAgA3AgALHwAgAEEIakG09YEBKQIANwIAIABBrPWBASkCADcCAAsfACAAQQhqQYT7gQEpAgA3AgAgAEH8+oEBKQIANwIACx8AIABBCGpBlPuBASkCADcCACAAQYz7gQEpAgA3AgALHwAgAEEIakGk+4EBKQIANwIAIABBnPuBASkCADcCAAsfACAAQQhqQbT7gQEpAgA3AgAgAEGs+4EBKQIANwIACx8AIABBCGpBxPuBASkCADcCACAAQbz7gQEpAgA3AgALHwAgAEEIakHU+4EBKQIANwIAIABBzPuBASkCADcCAAsfACAAQQhqQeT7gQEpAgA3AgAgAEHc+4EBKQIANwIACx8AIABBCGpB9PuBASkCADcCACAAQez7gQEpAgA3AgALHwAgAEEIakGE/IEBKQIANwIAIABB/PuBASkCADcCAAsfACAAQQhqQZT8gQEpAgA3AgAgAEGM/IEBKQIANwIACx8AIABBCGpBpPyBASkCADcCACAAQZz8gQEpAgA3AgALHwAgAEEIakG0/IEBKQIANwIAIABBrPyBASkCADcCAAsfACAAQQhqQYCzggEpAgA3AgAgAEH4soIBKQIANwIACx8AIABBCGpBlMGCASkCADcCACAAQYzBggEpAgA3AgALHwAgAEEIakGkwYIBKQIANwIAIABBnMGCASkCADcCAAsfACAAQQhqQbTBggEpAgA3AgAgAEGswYIBKQIANwIACx8AIABBCGpBxMGCASkCADcCACAAQbzBggEpAgA3AgALHwAgAEEIakHUwYIBKQIANwIAIABBzMGCASkCADcCAAsfACAAQQhqQeTBggEpAgA3AgAgAEHcwYIBKQIANwIACx8AIABBCGpB9MGCASkCADcCACAAQezBggEpAgA3AgALHwAgAEEIakGEwoIBKQIANwIAIABB/MGCASkCADcCAAsfACAAQQhqQZTCggEpAgA3AgAgAEGMwoIBKQIANwIACx8AIABBCGpBpMKCASkCADcCACAAQZzCggEpAgA3AgALHwAgAEEIakG0woIBKQIANwIAIABBrMKCASkCADcCAAsfACAAQQhqQcTCggEpAgA3AgAgAEG8woIBKQIANwIACx8AIABBCGpB1MKCASkCADcCACAAQczCggEpAgA3AgALHwAgAEEIakHkwoIBKQIANwIAIABB3MKCASkCADcCAAsfACAAQQhqQfTCggEpAgA3AgAgAEHswoIBKQIANwIACx8AIABBCGpBhMOCASkCADcCACAAQfzCggEpAgA3AgALHwAgAEEIakGUw4IBKQIANwIAIABBjMOCASkCADcCAAsfACAAQQhqQaTDggEpAgA3AgAgAEGcw4IBKQIANwIACx8AIABBCGpBtMOCASkCADcCACAAQazDggEpAgA3AgALHwAgAEEIakHEw4IBKQIANwIAIABBvMOCASkCADcCAAsfACAAQQhqQdTDggEpAgA3AgAgAEHMw4IBKQIANwIACx8AIABBCGpB5MOCASkCADcCACAAQdzDggEpAgA3AgALHwAgAEEIakH0w4IBKQIANwIAIABB7MOCASkCADcCAAsfACAAQQhqQYTEggEpAgA3AgAgAEH8w4IBKQIANwIACx8AIABBCGpBlMSCASkCADcCACAAQYzEggEpAgA3AgALHwAgAEEIakGkxIIBKQIANwIAIABBnMSCASkCADcCAAsfACAAQQhqQbTEggEpAgA3AgAgAEGsxIIBKQIANwIACx8AIABBCGpBxMSCASkCADcCACAAQbzEggEpAgA3AgALHwAgAEEIakHUxIIBKQIANwIAIABBzMSCASkCADcCAAsfACAAQQhqQeTEggEpAgA3AgAgAEHcxIIBKQIANwIACx8AIABBCGpB9MSCASkCADcCACAAQezEggEpAgA3AgALHwAgAEEIakGExYIBKQIANwIAIABB/MSCASkCADcCAAsfACAAQQhqQZTFggEpAgA3AgAgAEGMxYIBKQIANwIACx8AIABBCGpBpMWCASkCADcCACAAQZzFggEpAgA3AgALHwAgAEEIakG0xYIBKQIANwIAIABBrMWCASkCADcCAAsfACAAQQhqQcTFggEpAgA3AgAgAEG8xYIBKQIANwIACx8AIABBCGpB1MWCASkCADcCACAAQczFggEpAgA3AgALHwAgAEEIakHkxYIBKQIANwIAIABB3MWCASkCADcCAAsfACAAQQhqQfTFggEpAgA3AgAgAEHsxYIBKQIANwIACx8AIABBCGpBhMaCASkCADcCACAAQfzFggEpAgA3AgALHwAgAEEIakGUxoIBKQIANwIAIABBjMaCASkCADcCAAsfACAAQQhqQaTGggEpAgA3AgAgAEGcxoIBKQIANwIACx8AIABBCGpBtMaCASkCADcCACAAQazGggEpAgA3AgALHwAgAEEIakHExoIBKQIANwIAIABBvMaCASkCADcCAAsfACAAQQhqQdTGggEpAgA3AgAgAEHMxoIBKQIANwIACx8AIABBCGpB5MaCASkCADcCACAAQdzGggEpAgA3AgALHwAgAEEIakH0xoIBKQIANwIAIABB7MaCASkCADcCAAsfACAAQQhqQYTHggEpAgA3AgAgAEH8xoIBKQIANwIACx8AIABBCGpBlMeCASkCADcCACAAQYzHggEpAgA3AgALHwAgAEEIakGkx4IBKQIANwIAIABBnMeCASkCADcCAAsfACAAQQhqQbTHggEpAgA3AgAgAEGsx4IBKQIANwIACx8AIABBCGpBxMeCASkCADcCACAAQbzHggEpAgA3AgALHwAgAEEIakHUx4IBKQIANwIAIABBzMeCASkCADcCAAsfACAAQQhqQej7ggEpAgA3AgAgAEHg+4IBKQIANwIACx8AIABBCGpB+PuCASkCADcCACAAQfD7ggEpAgA3AgALHwAgAEEIakGI/IIBKQIANwIAIABBgPyCASkCADcCAAsfACAAQQhqQZj8ggEpAgA3AgAgAEGQ/IIBKQIANwIACx8AIABBCGpBqPyCASkCADcCACAAQaD8ggEpAgA3AgALHwAgAEEIakG4/IIBKQIANwIAIABBsPyCASkCADcCAAsfACAAQQhqQcj8ggEpAgA3AgAgAEHA/IIBKQIANwIACx8AIABBCGpB2PyCASkCADcCACAAQdD8ggEpAgA3AgALHwAgAEEIakHo/IIBKQIANwIAIABB4PyCASkCADcCAAsfACAAQQhqQfj8ggEpAgA3AgAgAEHw/IIBKQIANwIACx8AIABBCGpBiP2CASkCADcCACAAQYD9ggEpAgA3AgALHwAgAEEIakGY/YIBKQIANwIAIABBkP2CASkCADcCAAsfACAAQQhqQaj9ggEpAgA3AgAgAEGg/YIBKQIANwIACx8AIABBCGpBuP2CASkCADcCACAAQbD9ggEpAgA3AgALHwAgAEEIakHI/YIBKQIANwIAIABBwP2CASkCADcCAAsfACAAQQhqQdj9ggEpAgA3AgAgAEHQ/YIBKQIANwIACx8AIABBCGpB6P2CASkCADcCACAAQeD9ggEpAgA3AgALHwAgAEEIakH4/YIBKQIANwIAIABB8P2CASkCADcCAAsfACAAQQhqQYj+ggEpAgA3AgAgAEGA/oIBKQIANwIACx8AIABBCGpBmP6CASkCADcCACAAQZD+ggEpAgA3AgALHwAgAEEIakGo/oIBKQIANwIAIABBoP6CASkCADcCAAsfACAAQQhqQbj+ggEpAgA3AgAgAEGw/oIBKQIANwIACx8AIABBCGpByP6CASkCADcCACAAQcD+ggEpAgA3AgALHwAgAEEIakHY/oIBKQIANwIAIABB0P6CASkCADcCAAsfACAAQQhqQej+ggEpAgA3AgAgAEHg/oIBKQIANwIACx8AIABBCGpB+P6CASkCADcCACAAQfD+ggEpAgA3AgALHwAgAEEIakGI/4IBKQIANwIAIABBgP+CASkCADcCAAsfACAAQQhqQZj/ggEpAgA3AgAgAEGQ/4IBKQIANwIACx8AIABBCGpBqP+CASkCADcCACAAQaD/ggEpAgA3AgALHwAgAEEIakG4/4IBKQIANwIAIABBsP+CASkCADcCAAsfACAAQQhqQcj/ggEpAgA3AgAgAEHA/4IBKQIANwIACx8AIABBCGpB2P+CASkCADcCACAAQdD/ggEpAgA3AgALHwAgAEEIakHo/4IBKQIANwIAIABB4P+CASkCADcCAAsfACAAQQhqQfj/ggEpAgA3AgAgAEHw/4IBKQIANwIACx8AIABBCGpBiICDASkCADcCACAAQYCAgwEpAgA3AgALHwAgAEEIakGYgIMBKQIANwIAIABBkICDASkCADcCAAsfACAAQQhqQaiAgwEpAgA3AgAgAEGggIMBKQIANwIACx8AIABBCGpBuICDASkCADcCACAAQbCAgwEpAgA3AgALHwAgAEEIakHIgIMBKQIANwIAIABBwICDASkCADcCAAsfACAAQQhqQdiAgwEpAgA3AgAgAEHQgIMBKQIANwIACx8AIABBCGpB2PuCASkCADcCACAAQdD7ggEpAgA3AgALHwAgAEEIakHogIMBKQIANwIAIABB4ICDASkCADcCAAsfACAAQQhqQfiAgwEpAgA3AgAgAEHwgIMBKQIANwIACx8AIABBCGpBiIGDASkCADcCACAAQYCBgwEpAgA3AgALHwAgAEEIakGYgYMBKQIANwIAIABBkIGDASkCADcCAAsfACAAQQhqQaiBgwEpAgA3AgAgAEGggYMBKQIANwIACx8AIABBCGpBuIGDASkCADcCACAAQbCBgwEpAgA3AgALHwAgAEEIakHIgYMBKQIANwIAIABBwIGDASkCADcCAAsfACAAQQhqQdiBgwEpAgA3AgAgAEHQgYMBKQIANwIACx8AIABBCGpB6IGDASkCADcCACAAQeCBgwEpAgA3AgALHwAgAEEIakH4gYMBKQIANwIAIABB8IGDASkCADcCAAsfACAAQQhqQYiCgwEpAgA3AgAgAEGAgoMBKQIANwIACx8AIABBCGpBmIKDASkCADcCACAAQZCCgwEpAgA3AgALHwAgAEEIakHgxYMBKQIANwIAIABB2MWDASkCADcCAAsfACAAQQhqQfDFgwEpAgA3AgAgAEHoxYMBKQIANwIACx8AIABBCGpBgMaDASkCADcCACAAQfjFgwEpAgA3AgALHwAgAEEIakGQxoMBKQIANwIAIABBiMaDASkCADcCAAsfACAAQQhqQaDGgwEpAgA3AgAgAEGYxoMBKQIANwIACx8AIABBCGpBsMaDASkCADcCACAAQajGgwEpAgA3AgALHwAgAEEIakHAxoMBKQIANwIAIABBuMaDASkCADcCAAsfACAAQQhqQdDGgwEpAgA3AgAgAEHIxoMBKQIANwIACx8AIABBCGpB4MaDASkCADcCACAAQdjGgwEpAgA3AgALHwAgAEEIakHwxoMBKQIANwIAIABB6MaDASkCADcCAAsfACAAQQhqQYDHgwEpAgA3AgAgAEH4xoMBKQIANwIACx8AIABBCGpBkMeDASkCADcCACAAQYjHgwEpAgA3AgALHwAgAEEIakGgx4MBKQIANwIAIABBmMeDASkCADcCAAsfACAAQQhqQbDHgwEpAgA3AgAgAEGox4MBKQIANwIACx8AIABBCGpBwMeDASkCADcCACAAQbjHgwEpAgA3AgALHwAgAEEIakHQx4MBKQIANwIAIABByMeDASkCADcCAAsfACAAQQhqQeDHgwEpAgA3AgAgAEHYx4MBKQIANwIACx8AIABBCGpB8MeDASkCADcCACAAQejHgwEpAgA3AgALHwAgAEEIakGAyIMBKQIANwIAIABB+MeDASkCADcCAAsfACAAQQhqQZDIgwEpAgA3AgAgAEGIyIMBKQIANwIACx8AIABBCGpBoMiDASkCADcCACAAQZjIgwEpAgA3AgALHwAgAEEIakGwyIMBKQIANwIAIABBqMiDASkCADcCAAsfACAAQQhqQcDIgwEpAgA3AgAgAEG4yIMBKQIANwIACx8AIABBCGpB0MiDASkCADcCACAAQcjIgwEpAgA3AgALHwAgAEEIakHgyIMBKQIANwIAIABB2MiDASkCADcCAAsfACAAQQhqQfDIgwEpAgA3AgAgAEHoyIMBKQIANwIACx8AIABBCGpBgMmDASkCADcCACAAQfjIgwEpAgA3AgALHwAgAEEIakGQyYMBKQIANwIAIABBiMmDASkCADcCAAsfACAAQQhqQaDJgwEpAgA3AgAgAEGYyYMBKQIANwIACx8AIABBCGpBsMmDASkCADcCACAAQajJgwEpAgA3AgALHwAgAEEIakHAyYMBKQIANwIAIABBuMmDASkCADcCAAsfACAAQQhqQdDJgwEpAgA3AgAgAEHIyYMBKQIANwIACx8AIABBCGpB4MmDASkCADcCACAAQdjJgwEpAgA3AgALHwAgAEEIakHwyYMBKQIANwIAIABB6MmDASkCADcCAAsfACAAQQhqQYDKgwEpAgA3AgAgAEH4yYMBKQIANwIACx8AIABBCGpBkMqDASkCADcCACAAQYjKgwEpAgA3AgALHwAgAEEIakGgyoMBKQIANwIAIABBmMqDASkCADcCAAsfACAAQQhqQbDKgwEpAgA3AgAgAEGoyoMBKQIANwIACx8AIABBCGpBwMqDASkCADcCACAAQbjKgwEpAgA3AgALHwAgAEEIakHQyoMBKQIANwIAIABByMqDASkCADcCAAsfACAAQQhqQeDKgwEpAgA3AgAgAEHYyoMBKQIANwIACx8AIABBCGpB8MqDASkCADcCACAAQejKgwEpAgA3AgALHwAgAEEIakGAy4MBKQIANwIAIABB+MqDASkCADcCAAsfACAAQQhqQZDLgwEpAgA3AgAgAEGIy4MBKQIANwIACx8AIABBCGpBoMuDASkCADcCACAAQZjLgwEpAgA3AgALHwAgAEEIakGwy4MBKQIANwIAIABBqMuDASkCADcCAAsfACAAQQhqQcDLgwEpAgA3AgAgAEG4y4MBKQIANwIACx8AIABBCGpBmIeEASkCADcCACAAQZCHhAEpAgA3AgALHwAgAEEIakGoh4QBKQIANwIAIABBoIeEASkCADcCAAsfACAAQQhqQbiHhAEpAgA3AgAgAEGwh4QBKQIANwIACx8AIABBCGpByIeEASkCADcCACAAQcCHhAEpAgA3AgALHwAgAEEIakHYh4QBKQIANwIAIABB0IeEASkCADcCAAsfACAAQQhqQeiHhAEpAgA3AgAgAEHgh4QBKQIANwIACx8AIABBCGpB+IeEASkCADcCACAAQfCHhAEpAgA3AgALHwAgAEEIakGIiIQBKQIANwIAIABBgIiEASkCADcCAAsfACAAQQhqQZiIhAEpAgA3AgAgAEGQiIQBKQIANwIACx8AIABBCGpBqIiEASkCADcCACAAQaCIhAEpAgA3AgALHwAgAEEIakG4iIQBKQIANwIAIABBsIiEASkCADcCAAsfACAAQQhqQciIhAEpAgA3AgAgAEHAiIQBKQIANwIACx8AIABBCGpBuIaEASkCADcCACAAQbCGhAEpAgA3AgALHwAgAEEIakHYiIQBKQIANwIAIABB0IiEASkCADcCAAsfACAAQQhqQeiIhAEpAgA3AgAgAEHgiIQBKQIANwIACx8AIABBCGpB+IiEASkCADcCACAAQfCIhAEpAgA3AgALHwAgAEEIakGIiYQBKQIANwIAIABBgImEASkCADcCAAsfACAAQQhqQZiJhAEpAgA3AgAgAEGQiYQBKQIANwIACx8AIABBCGpB+IaEASkCADcCACAAQfCGhAEpAgA3AgALHwAgAEEIakGoiYQBKQIANwIAIABBoImEASkCADcCAAsfACAAQQhqQbiJhAEpAgA3AgAgAEGwiYQBKQIANwIACx8AIABBCGpByImEASkCADcCACAAQcCJhAEpAgA3AgALHwAgAEEIakHYiYQBKQIANwIAIABB0ImEASkCADcCAAsfACAAQQhqQeiJhAEpAgA3AgAgAEHgiYQBKQIANwIACx8AIABBCGpB+ImEASkCADcCACAAQfCJhAEpAgA3AgALHwAgAEEIakGIioQBKQIANwIAIABBgIqEASkCADcCAAsfACAAQQhqQZiKhAEpAgA3AgAgAEGQioQBKQIANwIACx8AIABBCGpBqIqEASkCADcCACAAQaCKhAEpAgA3AgALHwAgAEEIakG4ioQBKQIANwIAIABBsIqEASkCADcCAAsfACAAQQhqQciKhAEpAgA3AgAgAEHAioQBKQIANwIACx8AIABBCGpB2IqEASkCADcCACAAQdCKhAEpAgA3AgALHwAgAEEIakHoioQBKQIANwIAIABB4IqEASkCADcCAAsfACAAQQhqQfiKhAEpAgA3AgAgAEHwioQBKQIANwIACx8AIABBCGpBiIuEASkCADcCACAAQYCLhAEpAgA3AgALHwAgAEEIakGYi4QBKQIANwIAIABBkIuEASkCADcCAAsfACAAQQhqQaiLhAEpAgA3AgAgAEGgi4QBKQIANwIACx8AIABBCGpBuIuEASkCADcCACAAQbCLhAEpAgA3AgALHwAgAEEIakHIi4QBKQIANwIAIABBwIuEASkCADcCAAsfACAAQQhqQdiLhAEpAgA3AgAgAEHQi4QBKQIANwIACx8AIABBCGpB6IuEASkCADcCACAAQeCLhAEpAgA3AgALHwAgAEEIakH4i4QBKQIANwIAIABB8IuEASkCADcCAAsfACAAQQhqQYiMhAEpAgA3AgAgAEGAjIQBKQIANwIACx8AIABBCGpBmIyEASkCADcCACAAQZCMhAEpAgA3AgALHwAgAEEIakGojIQBKQIANwIAIABBoIyEASkCADcCAAsfACAAQQhqQYiHhAEpAgA3AgAgAEGAh4QBKQIANwIACx8AIABBCGpBuIyEASkCADcCACAAQbCMhAEpAgA3AgALHwAgAEEIakHIjIQBKQIANwIAIABBwIyEASkCADcCAAsfACAAQQhqQdiMhAEpAgA3AgAgAEHQjIQBKQIANwIACx8AIABBCGpB6IyEASkCADcCACAAQeCMhAEpAgA3AgALHwAgAEEIakH4jIQBKQIANwIAIABB8IyEASkCADcCAAsfACAAQQhqQYiNhAEpAgA3AgAgAEGAjYQBKQIANwIACx8AIABBCGpBmI2EASkCADcCACAAQZCNhAEpAgA3AgALHwAgAEEIakGojYQBKQIANwIAIABBoI2EASkCADcCAAsfACAAQQhqQbiNhAEpAgA3AgAgAEGwjYQBKQIANwIACx8AIABBCGpByI2EASkCADcCACAAQcCNhAEpAgA3AgALHwAgAEEIakHYhoQBKQIANwIAIABB0IaEASkCADcCAAsfACAAQQhqQdiNhAEpAgA3AgAgAEHQjYQBKQIANwIACx8AIABBCGpB6IaEASkCADcCACAAQeCGhAEpAgA3AgALHwAgAEEIakHIhoQBKQIANwIAIABBwIaEASkCADcCAAsfACAAQQhqQeiNhAEpAgA3AgAgAEHgjYQBKQIANwIACx8AIABBCGpBtMSEASkCADcCACAAQazEhAEpAgA3AgALHwAgAEEIakHExIQBKQIANwIAIABBvMSEASkCADcCAAsfACAAQQhqQdTEhAEpAgA3AgAgAEHMxIQBKQIANwIACx8AIABBCGpB5MSEASkCADcCACAAQdzEhAEpAgA3AgALHwAgAEEIakH0xIQBKQIANwIAIABB7MSEASkCADcCAAsfACAAQQhqQYTFhAEpAgA3AgAgAEH8xIQBKQIANwIACx8AIABBCGpBlMWEASkCADcCACAAQYzFhAEpAgA3AgALHwAgAEEIakGkxYQBKQIANwIAIABBnMWEASkCADcCAAsfACAAQQhqQbTFhAEpAgA3AgAgAEGsxYQBKQIANwIACx8AIABBCGpBxMWEASkCADcCACAAQbzFhAEpAgA3AgALHwAgAEEIakHUxYQBKQIANwIAIABBzMWEASkCADcCAAsfACAAQQhqQeTFhAEpAgA3AgAgAEHcxYQBKQIANwIACx8AIABBCGpB9MWEASkCADcCACAAQezFhAEpAgA3AgALHwAgAEEIakGExoQBKQIANwIAIABB/MWEASkCADcCAAsfACAAQQhqQZTGhAEpAgA3AgAgAEGMxoQBKQIANwIACx8AIABBCGpBpMaEASkCADcCACAAQZzGhAEpAgA3AgALHwAgAEEIakG0xoQBKQIANwIAIABBrMaEASkCADcCAAsfACAAQQhqQcTGhAEpAgA3AgAgAEG8xoQBKQIANwIACx8AIABBCGpB1MaEASkCADcCACAAQczGhAEpAgA3AgALHwAgAEEIakHkxoQBKQIANwIAIABB3MaEASkCADcCAAsfACAAQQhqQfTGhAEpAgA3AgAgAEHsxoQBKQIANwIACx8AIABBCGpBhMeEASkCADcCACAAQfzGhAEpAgA3AgALHwAgAEEIakGUx4QBKQIANwIAIABBjMeEASkCADcCAAsfACAAQQhqQaTHhAEpAgA3AgAgAEGcx4QBKQIANwIACx8AIABBCGpBtMeEASkCADcCACAAQazHhAEpAgA3AgALHwAgAEEIakHEx4QBKQIANwIAIABBvMeEASkCADcCAAsfACAAQQhqQdTHhAEpAgA3AgAgAEHMx4QBKQIANwIACx8AIABBCGpB5MeEASkCADcCACAAQdzHhAEpAgA3AgALHwAgAEEIakH0x4QBKQIANwIAIABB7MeEASkCADcCAAsfACAAQQhqQYTIhAEpAgA3AgAgAEH8x4QBKQIANwIACx8AIABBCGpBlMiEASkCADcCACAAQYzIhAEpAgA3AgALHwAgAEEIakGkyIQBKQIANwIAIABBnMiEASkCADcCAAsfACAAQQhqQfjnhAEpAgA3AgAgAEHw54QBKQIANwIACx8AIABBCGpBiOiEASkCADcCACAAQYDohAEpAgA3AgALHwAgAEEIakGY6IQBKQIANwIAIABBkOiEASkCADcCAAsfACAAQQhqQajohAEpAgA3AgAgAEGg6IQBKQIANwIACx8AIABBCGpBuOiEASkCADcCACAAQbDohAEpAgA3AgALHwAgAEEIakHI6IQBKQIANwIAIABBwOiEASkCADcCAAsfACAAQQhqQdjohAEpAgA3AgAgAEHQ6IQBKQIANwIACx8AIABBCGpB6OiEASkCADcCACAAQeDohAEpAgA3AgALHwAgAEEIakHY9YQBKQIANwIAIABB0PWEASkCADcCAAsfACAAQQhqQej1hAEpAgA3AgAgAEHg9YQBKQIANwIACx8AIABBCGpB+PWEASkCADcCACAAQfD1hAEpAgA3AgALGQEBfyAAKAIEIgEgASAAKAIIQQN0ahD7IgsfACAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIACx8AIABBCGpBuMmFASkCADcCACAAQbDJhQEpAgA3AgALHwAgAEEIakHIyYUBKQIANwIAIABBwMmFASkCADcCAAsfACAAQQhqQeTOhQEpAgA3AgAgAEHczoUBKQIANwIACx8AIABBCGpB9M6FASkCADcCACAAQezOhQEpAgA3AgALHwAgAEEIakGEz4UBKQIANwIAIABB/M6FASkCADcCAAsfACAAQQhqQcjqhQEpAgA3AgAgAEHA6oUBKQIANwIACx8AIABBCGpBuOqFASkCADcCACAAQbDqhQEpAgA3AgALHwAgAEEIakHA/4UBKQIANwIAIABBuP+FASkCADcCAAsfACAAQQhqQfiKhgEpAgA3AgAgAEHwioYBKQIANwIACx8AIABBCGpBiIuGASkCADcCACAAQYCLhgEpAgA3AgALHwAgAEEIakGYi4YBKQIANwIAIABBkIuGASkCADcCAAsfACAAQQhqQaiLhgEpAgA3AgAgAEGgi4YBKQIANwIACx8AIABBCGpBuIuGASkCADcCACAAQbCLhgEpAgA3AgALHwAgAEEIakHIi4YBKQIANwIAIABBwIuGASkCADcCAAsfACAAQQhqQaybhgEpAgA3AgAgAEGkm4YBKQIANwIACx8AIABBCGpBvJuGASkCADcCACAAQbSbhgEpAgA3AgALHwAgAEEIakHMm4YBKQIANwIAIABBxJuGASkCADcCAAsZACAAIAEoAgA2AgAgACABKAIEQQlqNgIEC3QBAn8gACgCACIAKAIAQQhqIQIgACgCBCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0ECdCEBA0AgACACNgIMIABBBGogAEEMakGg3ocBEMkUIAJBBGohAiABQQRrIgENAAsLIABBBGoQqSwgAEEQaiQACxkAIAAgASgCBDYCBCAAIAEoAgBBCGo2AgALGQAgACgCACIAKAIAQQhqIAAoAgQgARDcBwsZACAAKAIAIgAoAgBBCGogACgCBCABEKk9CxwAIAAoAgAoAgAiACgCACABIAAoAgQoAhARAgALHwAgAEEIakH07YcBKQIANwIAIABB7O2HASkCADcCAAsbACAAIAEoAgQgASgCCCABKAIMIAEoAhAQvxQLGwAgACABKAIEIAEoAgggASgCDCABKAIQEPoTCxcBAX8gABBTIgE2AgQgACABQQBHNgIACxcBAX8gABBUIgE2AgQgACABQQBHNgIACxcBAX8gABBVIgE2AgQgACABQQBHNgIACxcBAX8gABBWIgE2AgQgACABQQBHNgIACx8AIABBCGpB5KeJASkCADcCACAAQdyniQEpAgA3AgALHwAgAEEIakH0p4kBKQIANwIAIABB7KeJASkCADcCAAsWACAAIAFBAXI2AgQgACABaiABNgIACxUAIAFpQQFGIABBgICAgHggAWtNcQsZAQFvIAAlASABEDshAhDfEiIAIAImASAAC5YBAQR/EN8SIgEgACYBIwBB0ABrIgIkACACQQA6AEwgAiABNgJIIwBB4ABrIgEkACABQRBqIgQgAkEIakHIAPwKAAAgAUIBNwMIIAEgAUEIajYCXCABQdwAakG0yMIAEJM9IQMCQCABKQMIUA0AIAEtAFRBA0cNACAEEIAqCyABQeAAaiQAIAJB0ABqJAAgAyUBIAMQ8h8LFQAgACgCACIAQYQBTwRAIAAQ8h8LCxcAIABB7ABqQQAgACgCbEGAgICAeEcbCxMAIAAoAgAiAARAIABBADoAAAsLFwAgAEHEAGpBACAAKAJEQYCAgIB4RxsLEwAgAEHgAGpBACAAKQNgQghSGwsYACAAQZgCakEAIAAoApgCQYCAgIB4RxsLGAAgAEGkAmpBACAAKAKkAkGAgICAeEcbCxgAIABBsAJqQQAgACgCsAJBgICAgHhHGwsTACACBEAgACABIAL8CgAACyAACxIAIAIEQCAAIAEgAvwLAAsgAAsVACAAIAEgAiADIARBAUECQQAQrQILFQAgACABIAIgAyAEQQBBAkEAEK0CCxUAIAAgASACIAMgBEEAQQFBABCtAgsVACAAIAEgAiADIARBAEEAQQAQrQILFQAgACABIAIgAyAEQQFBAkECEK0CCxUAIAAgASACIAMgBEEAQQJBAhCtAgsVACAAIAEgAiADIARBAEEBQQIQrQILFQAgACABIAIgAyAEQQBBAEECEK0CCxUAIAAgASACIAMgBEEAQQJBAxCtAgsVACAAIAEgAiADIARBAEEBQQMQrQILFQAgACABIAIgAyAEQQBBAEEDEK0CCxUAIAAgASACIAMgBEECQQJBABCtAgsVACAAIAEgAiADIARBAkEBQQAQrQILFQAgACABIAIgAyAEQQJBAEEAEK0CCxUAIAAgASACIAMgBEECQQJBAhCtAgsVACAAIAEgAiADIARBAkEBQQIQrQILFQAgACABIAIgAyAEQQJBAEECEK0CCxUAIAAgASACIAMgBEECQQJBAxCtAgsVACAAIAEgAiADIARBAkEBQQMQrQILFQAgACABIAIgAyAEQQJBAEEDEK0CCxAAIAFBAnatIACtfkKPD3wLEQAgAEEybCABTSACQdQHS3ELFAAgACgCCCABTwRAIAAgATYCCAsLFwAgACACOgAFIAAgAToABCAAIAM2AgALFwAgACADNgIIIAAgAjYCBCAAIAE2AgALFAAgACABQRhqQQAgASgCGBsQ7iULEwAgACgCGEEARyAAKAIsQQBHcQsUACAAIAFBJGpBACABKAIkGxDuJQsTACAAKAIkQQBHIAAoAjhBAEdxCxUAIAAgAUHMAGpBACABKAJMGxDuJQsUACAAIAFBIGpBACABKAIgGxDuJQsTACAAKAIgQQBHIAAoAjRBAEdxCxMAIAAoAkxBAEcgACgCYEEAR3ELFAAgACABQRRqQQAgASgCFBsQ7iULFAAgACABQRxqQQAgASgCHBsQ7iULEwAgACgCHEEARyAAKAIwQQBHcQsTACAAKAIUQQBHIAAoAihBAEdxCxQAIAAgAUEsakEAIAEoAiwbEO4lCxMAIAAoAixBAEcgACgCQEEAR3ELFwEBf0HQ74oBKAIAIgAEfyAABRC1GQsLGQAgACgCACIAKAIAIAEgACgCBCgCDBECAAsVAQF/IAAoAjQiAQRAIAAgAREDAAsLFQEBfyAAKAIoIgEEQCAAIAERAwALCxkAIAAoAgAiACgCACABIAAoAgQoAhARAgALGQAgACgCACgCACIAKAIEIAAoAgggARDcBwsZACAAKAIAKAIAIgAoAgQgACgCCCABEKk9CxkAIAAoAgQgACgCCCABKAIEIAEoAggQwS4LEQAgACABIAEgAkECdGoQniQLFgAgACgCACIAQQE6ABQgAEEIahD5KAsXACAAIAI2AgggACABNgIEIAAgAjYCAAsXACAAQQA2AgggACACNgIEIAAgATYCAAsWACAAIAEQuCpBAWo2AgQgACABNgIACxcBAW8gACABEHohAhDfEiIAIAImASAACxcBAW8gACABEH0hAhDfEiIAIAImASAACxAAIAAgASABIAJqEMAmQQALEwAgAC0A7AJBA0YEQCAAEPcsCwsTACAALQDwAkEDRgRAIAAQ9ywLC/IFAQR/An8CQAJAAkACQAJAAkAgABCaPigCBCIEQXhxIgVBBEEIIARBA3EiBBsgAWpPBEAgBEEAIAFBJ2oiBCAFSRsNAQJAAkAgAkEJTwRAIAIgAxCbEiIHDQFBAAwKCyADQcz/e0sNAUEQIANBC2pBeHEgA0ELSRshASAAEJo+IgIgAigCBEF4cSIEEJg+IQUCQAJAAkAgAigCBCIGQQNxRQRAIAFBgAJJDQEgBkF4cSIEIAFBBHJJIAQgAWtBgYAIT3INAQwDCyABIARNDQFB1POKASgCACAFRwRAQdDzigEoAgAgBUcEQCAFKAIEIgZBAnENAiAGQXhxIgYgBGoiBCABSQ0CIAUgBhCFDyAEIAFrIgBBEE8NDCACIAQQ7iwMDQtByPOKASgCACAEaiIEIAFJDQECQCAEIAFrIgNBD00EQCACIAQQ7ixBACEDQQAhAAwBCyACIAEQmD4iACADEJg+IQQgAiABEO4sIAAgAxDQNCAEIAQoAgRBfnE2AgQLQdDzigEgADYCAEHI84oBIAM2AgAMDAtBzPOKASgCACAEaiIEIAFLDQkLIAMQrAEiAUUNAyADQXxBeCACKAIEIgJBA3EbIAJBeHFqIgIgAiADSxsiAgRAIAEgACAC/AoAAAsgABDwCSABDAsLIAQgAWsiAEEPSw0ICwwICyADIAEgASADSxsiAgRAIAcgACAC/AoAAAsgABCaPigCBCICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgBEsbDQQgABDwCQsgBwwHC0GIqYkBQS5BuKmJARCfKQALQcipiQFBLkH4qYkBEJ8pAAtBiKmJAUEuQbipiQEQnykAC0HIqYkBQS5B+KmJARCfKQALIAIgARCYPiEAIAIgARDuLCAAIAQgAWsiAUEBcjYCBEHM84oBIAE2AgBB1POKASAANgIAIAIQmT4MAgsgAiABEJg+IQMgAiABEO4sIAMgABDuLCADIAAQrg4LIAIQmT4LCxYAIAAoAgAiACgCFCAAKAIYIAEQqT0LEAAgACABIAEgAmoQgSZBAAsVACAAIAIgAxCTPjYCBCAAQQA2AgALsgUBDH8gASgCgAMhCyABKAKEAyEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJEPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApwCIgcEQCAHIAEoAqACRw0BCyADQQhqIAEQ2QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgCnAJFDQYLIANBCGogASACIAZrEJEPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ+BAgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAKAAyELIAEoAoQDIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgCnAIiBwRAIAcgASgCoAJHDQELIANBCGogARDTAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKcAkUNBgsgA0EIaiABIAIgBmsQlw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD6ECAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC54QAhB/AX4gASgCgAMhECABKAKEAyEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgCnAIiAyABKAKgAiIGRgR/IARBGGogASgCkAIgASgClAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENMCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCkAIgASgClAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCoAIhBiABKAKcAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0ApAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKQAiABKAKUAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlELYLDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCoAIgA2oiBzYCoAIgCSAGayEJIAEoApwCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQuhkgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ+hAgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAoADIRAgASgChAMhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApwCIgMgASgCoAIiBkYEfyAEQRhqIAEoApACIAEoApQCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDZAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoApACIAEoApQCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoAqACIQYgASgCnAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAKQCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCkAIgASgClAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRC3CwwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoAqACIANqIgc2AqACIAkgBmshCSABKAKcAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGELoZIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEPgQIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALsgUBDH8gASgCgAMhCyABKAKEAyEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJAPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApwCIgcEQCAHIAEoAqACRw0BCyADQQhqIAEQ0AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgCnAJFDQYLIANBCGogASACIAZrEJAPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ+RAgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAvHFgIYfwF+IAEoAoADIRUgASgChAMhAyMAQTBrIgwkAAJAAkACQCACRQRADAELIAxBDGohEiADKAIMIRYDQCACIBBrIQ9BACEDAkAgASkDAEIFUQ0AIAxBGGohByMAQUBqIgQkAAJAAkACQCAPBEAgAUGgAWohCyABQdAAaiETIARBLWohFCAPIQ0DQAJAAkACQAJAAkAgASgCnAIiAyABKAKgAiIFRgR/IARBGGogASgCkAIgASgClAIoAiARAAAgBC0ALCEFIAQpAiQhGyAEKAIgIQYgBCgCHCEDIAQoAhgiCEEIRwRAIAcgFC8AADsAFSAHQRdqIBRBAmotAAA6AAAgByAFOgAUIAcgGzcCDCAHIAY2AgggByADNgIEIAcgCDYCAAwLCyADQQJGDQIgBUEBcQ0BAkAgA0EBcQR/IAMFIBtCIIinIQYgG6dBACABKQMAQgRRGwtBAXEgBiANTXFFBEAgBEEYaiABENACIAQtABwhAyAEKAIYIgVBCEYNASAHIAQpAB03AAUgB0EUaiAEQSxqKAAANgAAIAdBDWogBEElaikAADcAACAHIAM6AAQgByAFNgIADAwLIARBGGogASgCkAIgASgClAIoAiQRAAAgBCgCGCIDQQhHBEAgByAEKQIcNwIEIAdBFGogBEEsaigCADYCACAHQQxqIARBJGopAgA3AgAgByADNgIADAwLIA0gBmshDQwGCyADQQFxRQRAIAdBCDYCACAHIA8gDWs2AgQMCwsgASgCoAIhBSABKAKcAgUgAwsgBWshAwJAIAEpAwBCBFIEQCAEQRhqIAEgDSADELkSIAQoAiAhBiAEKAIcIQUgBCgCGCIIQQhGDQEgByAEKQIkNwIMIAdBFGogBEEsaigCADYCACAHIAY2AgggByAFNgIEIAcgCDYCAAwLCyANIAMgAyANSxsiBSEDDAQLIAMgBkcEQCAGIQMMBAsgAS0ApAJBAUcNAyAFIA1PDQIgAS0ATCEGIAFBADoATCAFIAZqIQUMAwsgBEEYaiEGIwBBsAJrIgUkACAFQaABaiABKAKQAiABKAKUAigCHBEAACAFQZABaiIDIAVBsAFqKQMANwMAIAVBmAFqIgggBUG4AWopAwA3AwAgBSAFKQOoATcDiAECQCAFKQOgASIbQg1RBEAgBiAFKQOIATcDACAGQRBqIAgpAwA3AwAgBkEIaiADKQMANwMADAELIAVBKGogBUHAAWpB4AD8CgAAIAVBGGogBUGQAWopAwA3AwAgBUEgaiAFQZgBaikDADcDACAFIAUpA4gBNwMQIAUgGzcDCAJAAkACQCAbQgxRIBtCCVRyRQRAQQIhAyAbp0ELRg0BCyAFQaABakEnQQBBAUEBEKAYIAUoAqQBIQMgBSgCoAFBAUcNASADIAUoAqgBQfSOzwAQ/S8ACyAFQagCaiAFQZABaikDADcDACAFIAUpA4gBNwOgAiAGIAFBoAFqIAVBoAJqIAUoAiAgBS0AJCAFLQAlELoLDAELIAUoAqgBIghBpJTPAEEn/AoAACAGQSc2AgwgBiAINgIIIAYgAzYCBCAGQQA2AgAgG0IMUQ0BIBunQQlrIQMLIANBAkYgG0IJWnENACAFQQhqEJ8fCyAFQbACaiQAIAQoAhgiA0EIRg0DIAcgBCkCHDcCBCAHQRRqIARBLGooAgA2AgAgB0EMaiAEQSRqKQIANwIAIAcgAzYCAAwICyAHQQg2AgAgByAPIA1rNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCoAIgA2oiBjYCoAIgDSAFayENIAEoApwCIAZGDQAgAyIFIQYCQCATKQMAQgVRDQAgBEEYaiATIAUQww4gBCgCICEGIAQoAhwhBSAEKAIYIghBCEYNACAHIAQpAiQ3AgwgB0EUaiAEQSxqKAIANgIAIAcgBjYCCCAHIAU2AgQgByAINgIADAYLIAQgBTYCDCAEIAY2AhAgAyAGRw0EIARBGGohCUEAIQMjAEEgayIKJAACQAJAAkACQAJAIAspAwAiG0IGUQRAIApBFGpBDkEAQQFBARCgGCAKKAIYIQYgCigCFEEBRg0QIAooAhwiA0EGakGujM0AKQAANwAAIANBqIzNACkAADcAACAJQQ42AgwgCSADNgIIIAkgBjYCBCAJQQA2AgAMAQsCQAJAAkACQAJAAkBBASAbp0ECayAbQgFYG0EBaw4DAQIDAAsgCygCGCEIIApBCGogC0EIahDcOwJAAkAgCCAFIAUgCEsbIgZFDQAgCygCFCIOIAsoAhAiEU8NACAKKAIMIRcgCigCCCEYIAZBAWshGUEAIQYDQCAOQQRqIgMgF0sNAiAOQXxPDQkgCyAOIBhqKAAAIANqIg42AhQgBkEBaiEDIA4gEU8NASAGIBlHIAMhBg0ACwsgCSADNgIEIAlBCDYCACALIAggA2s2AhgMBgsgCkEUakEXQQBBAUEBEKAYIAooAhghBiAKKAIUQQFGDRQgCigCHCIDQQ9qQduGzQApAAA3AAAgA0EIakHUhs0AKQAANwAAIANBzIbNACkAADcAACAJQRc2AgwgCSADNgIIIAkgBjYCBCAJQQI2AgAMBQsgCygCUEGAgICAeEcNAyAKQRRqQStBAEEBQQEQoBggCigCGCEGIAooAhRBAUcNAgwTCyAFIAsoAhAiBiALKAIkIgNrIgggBSAISRsiCCADaiIRIAhJDQUgBiARSQ0GAkAgCEUEQEEAIQYMAQsgCygCDCADQQJ0aiEOQQAhBiAIIQMDQCAOKAIAIAZqIQYgDkEEaiEOIANBAWsiAw0ACwsgCyARNgIkIAkgCDYCBCAJQQg2AgAgCyALKAIoIAZqNgIoDAMLIAkgC0EIaiAFEKQLDAILIAooAhwiA0GokM0AQSv8CgAAIAlBKzYCDCAJIAM2AgggCSAGNgIEIAlBADYCAAwBCyALKAJYBEAgCSALIAUQkBQMAQsgCUIINwMACyAKQSBqJAAMAwsgDiADQeSQzQAQsTsACyADIBFBxJHNABCxOwALIBEgBkHEkc0AELA7AAsgBCgCHCEDIAQoAhgiBkEIRwRAIAcgBCkDIDcDCCAHQRBqIARBKGopAwA3AwAgByADNgIEIAcgBjYCAAwGCyAEIAM2AhQgAyAFRw0DCyANDQALCyAHQQg2AgAgByAPNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgB0EEaiAEQRhqEJkOIAdBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAdBBGogBEEYahCZDiAHQQA2AgALIARBQGskACAMKAIcIQMgDCgCGCIFQQhGDQAgACAMKQMgNwMIIABBEGogDEEoaikDADcDACAAIAM2AgQgACAFNgIADAMLIAMgEGohEAJAIAMgD08NACAMIBUgFhEAACAMKAIAIgNBCUYNAiAMKAIIIQ8gDCgCBCEFIANBCEcEQCAAIA82AgggACAFNgIEIAAgAzYCACAAIBIpAgA3AgwgAEEUaiASQQhqKAIANgIADAQLIAxBGGogASAFIA8Q+RAgDCgCGCIDQQhGDQAgACAMKQIcNwIEIABBFGogDEEsaigCADYCACAAQQxqIAxBJGopAgA3AgAgACADNgIADAMLIAIgEEsNAAsLIABBCDYCACAAIBA2AgQLIAxBMGokAA8LIAYgCigCHEHU/cwAEP0vAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQkg8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDVAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQkg8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhCLESAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC/0RAhB/AX4gASgC+AIhESABKAL8AiEFIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDiAFKAIMIRIDQCACIA1rIQxBACEFAkAgASkDAEIFUQ0AIAhBGGohBiMAQUBqIgMkAAJAAkACQCAMBEAgAUGgAWohCyABQdAAaiEPIANBLWohECAMIQoDQAJAAkACQAJAAkAgASgClAIiBSABKAKYAiIERgR/IANBGGogASgCiAIgASgCjAIoAiARAAAgAy0ALCEEIAMpAiQhEyADKAIgIQcgAygCHCEFIAMoAhgiCUEIRwRAIAYgEC8AADsAFSAGQRdqIBBBAmotAAA6AAAgBiAEOgAUIAYgEzcCDCAGIAc2AgggBiAFNgIEIAYgCTYCAAwLCyAFQQJGDQIgBEEBcQ0BAkAgBUEBcQR/IAUFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAKTXFFBEAgA0EYaiABENUCIAMtABwhBSADKAIYIgRBCEYNASAGIAMpAB03AAUgBkEUaiADQSxqKAAANgAAIAZBDWogA0ElaikAADcAACAGIAU6AAQgBiAENgIADAwLIANBGGogASgCiAIgASgCjAIoAiQRAAAgAygCGCIFQQhHBEAgBiADKQIcNwIEIAZBFGogA0EsaigCADYCACAGQQxqIANBJGopAgA3AgAgBiAFNgIADAwLIAogB2shCgwGCyAFQQFxRQRAIAZBCDYCACAGIAwgCms2AgQMCwsgASgCmAIhBCABKAKUAgUgBQsgBGshBQJAIAEpAwBCBFIEQCADQRhqIAEgCiAFELkSIAMoAiAhByADKAIcIQQgAygCGCIJQQhGDQEgBiADKQIkNwIMIAZBFGogA0EsaigCADYCACAGIAc2AgggBiAENgIEIAYgCTYCAAwLCyAKIAUgBSAKSxsiBCEFDAQLIAUgB0cEQCAHIQUMBAsgAS0AnAJBAUcNAyAEIApPDQIgAS0ATCEHIAFBADoATCAEIAdqIQQMAwsgA0EYaiEHIwBBsAJrIgQkACAEQaABaiABKAKIAiABKAKMAigCHBEAACAEQZABaiIFIARBsAFqKQMANwMAIARBmAFqIgkgBEG4AWopAwA3AwAgBCAEKQOoATcDiAECQCAEKQOgASITQg1RBEAgByAEKQOIATcDACAHQRBqIAkpAwA3AwAgB0EIaiAFKQMANwMADAELIARBKGogBEHAAWpB4AD8CgAAIARBGGogBEGQAWopAwA3AwAgBEEgaiAEQZgBaikDADcDACAEIAQpA4gBNwMQIAQgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhBSATp0ELRg0BCyAEQaABakEnQQBBAUEBEKAYIAQoAqQBIQUgBCgCoAFBAUcNASAFIAQoAqgBQfSOzwAQ/S8ACyAEQagCaiAEQZABaikDADcDACAEIAQpA4gBNwOgAiAHIAFBoAFqIARBoAJqIAQoAiAgBC0AJCAELQAlEJ8QDAELIAQoAqgBIglBpJTPAEEn/AoAACAHQSc2AgwgByAJNgIIIAcgBTYCBCAHQQA2AgAgE0IMUQ0BIBOnQQlrIQULIAVBAkYgE0IJWnENACAEQQhqEJ8fCyAEQbACaiQAIAMoAhgiBUEIRg0DIAYgAykCHDcCBCAGQRRqIANBLGooAgA2AgAgBkEMaiADQSRqKQIANwIAIAYgBTYCAAwICyAGQQg2AgAgBiAMIAprNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgAyAFNgIIIAEgASgCmAIgBWoiBzYCmAIgCiAEayEKIAEoApQCIAdGDQAgBSIEIQcCQCAPKQMAQgVRDQAgA0EYaiAPIAQQww4gAygCICEHIAMoAhwhBCADKAIYIglBCEYNACAGIAMpAiQ3AgwgBkEUaiADQSxqKAIANgIAIAYgBzYCCCAGIAQ2AgQgBiAJNgIADAYLIAMgBDYCDCADIAc2AhAgBSAHRw0EIANBGGohBQJAIAspAwAiE0IGUgRAAkACQAJAAkBBASATp0ECayATQgFYG0EBaw4DAgADAQsgBSALQQhqIAQQpAsMBAsgCygCYCIHBEAgBUEINgIAIAUgCygCECALKAIYIgVrIAduIgkgBCAEIAlLGyIJNgIEIAsgBSAHIAlsajYCGAwEC0H4ns0AEOIrAAsgBSALIAQQkBQMAgsgCygCYCIHBEAgBUEINgIAIAUgCygCECAHbiALKAIYIgVrIgcgBCAEIAdLGyIHNgIEIAsgBSAHajYCGAwCC0GIn80AEOIrAAtB6J7NABCyOwALIAMoAhwhBSADKAIYIgdBCEcEQCAGIAMpAyA3AwggBkEQaiADQShqKQMANwMAIAYgBTYCBCAGIAc2AgAMBgsgAyAFNgIUIAQgBUcNAwsgCg0ACwsgBkEINgIAIAYgDDYCBAwCCyADQQI2AhwgA0G8k88ANgIYIANCAjcCJCADQTs2AjwgA0E7NgI0IAMgA0EwajYCICADIANBDGo2AjggAyADQRRqNgIwIAZBBGogA0EYahCZDiAGQQA2AgAMAQsgA0EDNgIcIANBjJTPADYCGCADQgI3AiQgA0E7NgI8IANBOzYCNCADIANBMGo2AiAgAyADQRBqNgI4IAMgA0EIajYCMCAGQQRqIANBGGoQmQ4gBkEANgIACyADQUBrJAAgCCgCHCEFIAgoAhgiBEEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACAFNgIEIAAgBDYCAAwDCyAFIA1qIQ0CQCAFIAxPDQAgCCARIBIRAAAgCCgCACIFQQlGDQIgCCgCCCEMIAgoAgQhBCAFQQhHBEAgACAMNgIIIAAgBDYCBCAAIAU2AgAgACAOKQIANwIMIABBFGogDkEIaigCADYCAAwECyAIQRhqIAEgBCAMEIsRIAgoAhgiBUEIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgBTYCAAwDCyACIA1LDQALCyAAQQg2AgAgACANNgIECyAIQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJgPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ1gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJgPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDXAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQlQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCODwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABEOACIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCODyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL0LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKQPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ2AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKQPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQoQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDkAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQoQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCnDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENICIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCnDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJkPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ3gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJkPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQnQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDjAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQnQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC9CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCaDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENwCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCaDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL0LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJQPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ3AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJQPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQoA8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDcAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQoA8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC9CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhClDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABEOICIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxClDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKMPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ0gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKMPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvgsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQkw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDSAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQkw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCfDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENsCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCfDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKYPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ5QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKYPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvgsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDlAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCJCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ3AIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQjAoMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC9CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENICIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI0KDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvgsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDkAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCHCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ2wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQiwkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC+CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENgCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI4JDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDeAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCMCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL0LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ4wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQhQkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC9CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEOACIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEIoJDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDiAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCGCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ1wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQiAkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC+CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENYCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI0JDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQjw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDfAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQjw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEN8CIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEOoHDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQng8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDhAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQng8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoArACIQsgASgCtAIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCbDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKALUASIHBEAgByABKALYAUcNAQsgA0EIaiABENQCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoAtQBRQ0GCyADQQhqIAEgAiAGaxCbDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEPUKIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgCsAIhCyABKAK0AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJwPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoAtQBIgcEQCAHIAEoAtgBRw0BCyADQQhqIAEQ0QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgC1AFFDQYLIANBCGogASACIAZrEJwPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ9QogBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlg8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDaAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQlg8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoArACIQsgASgCtAIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCiDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKALUASIHBEAgByABKALYAUcNAQsgA0EIaiABEN0CIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoAtQBRQ0GCyADQQhqIAEgAiAGaxCiDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEPUKIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALnhACEH8BfiABKAKwAiEQIAEoArQCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKALUASIDIAEoAtgBIgZGBH8gBEEYaiABKALIASABKALMASgCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ0QIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKALIASABKALMASgCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKALYASEGIAEoAtQBBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQDcAUEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAsgBIAEoAswBKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQ7AcMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKALYASADaiIHNgLYASAJIAZrIQkgASgC1AEgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDHECAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChD1CiAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEOECIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlENcHDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoArACIRAgASgCtAIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoAtQBIgMgASgC2AEiBkYEfyAEQRhqIAEoAsgBIAEoAswBKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDdAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAsgBIAEoAswBKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoAtgBIQYgASgC1AEFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtANwBQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCyAEgASgCzAEoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRDrBwwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoAtgBIANqIgc2AtgBIAkgBmshCSABKALUASAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEMcQIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEPUKIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAKwAiEQIAEoArQCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKALUASIDIAEoAtgBIgZGBH8gBEEYaiABKALIASABKALMASgCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ2gIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKALIASABKALMASgCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKALYASEGIAEoAtQBBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQDcAUEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAsgBIAEoAswBKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQ7gcMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKALYASADaiIHNgLYASAJIAZrIQkgASgC1AEgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDHECAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChD1CiAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENQCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEO0HDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAtxAQJ/IAAoAgAiACgCBCECIAAoAgghAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBDGwhAQNAIAAgAjYCDCAAQQRqIABBDGpB+JfPABDJFCACQQxqIQIgAUEMayIBDQALCyAAQQRqEKksIABBEGokAAtxAQJ/IAAoAgAiACgCBCECIAAoAgghAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAnQhAQNAIAAgAjYCDCAAQQRqIABBDGpB6JfPABDJFCACQQRqIQIgAUEEayIBDQALCyAAQQRqEKksIABBEGokAAsWACAAIAEoAgwgAiABKAIQKAIcEQEACxYAIAAgASgCGCACIAEoAhwoAhwRAQALGwAgABCyEiAAQYCAgIB4NgKYASAAQQA6AKQBCw0AIAAgAUHAAvwKAAALEgAgACgCAEEJRwRAIAAQ1icLCxMAIABBBGsiACAAKAIAQQQQ+DoLFgAgACABKAIAIAEoAgwQgywgABCLJgsRACAAIAEgAiADIARBABDMAgsRACAAIAFBP2pBQHFBAhCmJAsWACAAIAEoAgAgASgCDBCFLCAAEIsmCxMAIAAgASACIAMgBEEAQQAQrAMLEwAgACABIAIgAyAEQQBBARCsAwsTACAAIAEgAiADIARBAEECEKwDCxMAIAAgASACIAMgBEEBQQIQrAMLEwAgACABIAIgAyAEQQJBABCsAwsTACAAIAEgAiADIARBAkEBEKwDCxMAIAAgASACIAMgBEECQQIQrAMLEwAgACABIAIgAyAEQQAgBRCwAQsTACAAIAEgAiADIARBAiAFELABCxAAIAIEQCABIAJBARD4OgsLFgAgACgCACIAKAIEIAAoAgggARDFIwsWACAAKAIAIgAoAgQgACgCCCABENwHCxAAIAAgASABIAJqEI4mQQALcQECfyAAKAIAIgAoAgQhAiAAKAIIIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQRRsIQEDQCAAIAI2AgwgAEEEaiAAQQxqQZT0/gAQyRQgAkEUaiECIAFBFGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALEAAgACABIAEgAmoQvSZBAAsVACAAKAIAIgAQqgwgAEEMQQQQ+DoLFAAgACAAKAIIIAFBAUEBIAIQwygLEgAgAEEMahCRLyAAQTxqEPkjCxIAIABBDGoQ1B4gAEEgahD5IwsTACAAIAAgACgCACIAajYCACAACxYAIAAoAgAiACgCBCAAKAIIIAEQqT0LEAAgACABIAEgAmoQuyZBAAsVACAAKAIAIgAQygwgAEEMQQQQ+DoLcQECfyAAKAIAIgAoAgQhAiAAKAIIIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQR0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQey6hwEQyRQgAkEQaiECIAFBEGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALFQAgACgCACIAEM4MIABBDEEEEPg6CxUAIAAoAgAiABDPDCAAQQxBBBD4OgsQACAAIAEgASACahC8JkEAC28BAn8gACgCAEEIaiECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBA3QhAQNAIAAgAjYCDCAAQQRqIABBDGpBkN6HARDJFCACQQhqIQIgAUEIayIBDQALCyAAQQRqEKksIABBEGokAAsVACAAKAIAIgAQ0gwgAEEMQQQQ+DoLEgAgAEEQQRQgACgCABtqKAIACxYAIAAoAgQgACAAKAIAQYCAgIB4RhsLFgAgACABKAIAIAIgASgCBCgCDBEBAAsoAQFvIAAoAgAlASABKAIAJQEgAigCACUBEEkhAxDfEiIAIAMmASAACxAAIAEEQCAAIAEgAhD4OgsLEwBB2O+KASAArUIghkIBhDcDAAsQACAAIAEgASACahC/JkEACxYAIAAoAgAgASACIAAoAgQoAgwRBgALGQAgASgCAEGgj4oBQQUgASgCBCgCDBEGAAsVAQFvIAAQCSEBEN8SIgAgASYBIAALnQECAX8BbyMAQcABayIDJAAgAyABNgK0ASADIAA2ArABIANBADoAuAEgAyACOQMAIwBB0AFrIgAkACAAQQhqIANBwAH8CgAAIABCATcDACAAIAA2AswBIABBzAFqQfjHwgAQkz0hAQJAIAApAwBQDQAgAC0AwAFBA0cNACAAQRBqEPUsCyAAQdABaiQAIANBwAFqJAAgASUBIAEQ8h8LFAAgABDfEiIAIAImASABIAAQli8LEwAgARDGISAAIAFBABCLHBCJGgsTACABEMYhIAAgAUEAEIscEIgaCxQAIAAoAgAgASAAKAIEKAIMEQIACxQAIAAoAgAgASAAKAIEKAIQEQIACxQAIAAoAgAgASAAKAIEKAIUEQAACxMAIABBACAAKAIAQYCAgIB4RxsLEwBC////v4APIAAxAACIp0EBcQsKACAAQQhqEN47CxEAIAAgASACIAMgBEEAEN41CxEAIAAgASACIAMgBEEAEN81CxEAIAAgASACIAMgBEECEN41CxEAIAAgASACIAMgBEECEN81CxEAIAAgASACIAMgBEEBEN41CxEAIAAgASACIAMgBEEBEN81CxIAIABFBEBBAA8LIAAoAqjVAQsRACAAIAEgAxC2LCACajYCAAvDNgIVfwN+IwBBEGsiFyQAIAQoAgghFSAEIAQoAgAiGBCOLSAVIAQoAggiCEsEQCAVIAhBpMH7ABCvOwALIAEpAwghHCAXQQRqIRYgBCgCBCAVaiEZIwBBMGsiEyQAIAEoAhAiB0EANgIYIAcgCCAVazYCECAHIBk2AgwgByADNgIEIAcgAiIDNgIAIAVB/wFxIQVBfiECAkAgB0UNACAHKAIgRQ0AIAcoAiRFDQAgBygCHEUgBUEFS3INACMAQdAAayIKJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBygCDEUNACAHKAIEBEAgBygCAEUNAQsgBygCHCECIAVB/wFxQQRHBEAgAi0AAEEDRg0BCyAHKAIQRQ0cIAIsAAEhCCACIAU6AAEgCkEwaiAHKAIcQdgAahDkJQJAAkACQCAKKAI0BEAgBxDiGCAHKAIQBEAgBygCBEEARyELDAILIAcoAhxB/wE6AAEMFgtBASELIAcoAgRFDQELIAtFIAcoAhwiBi0AACIJQQNHcg0BDB4LIAVB/wFxIgJBBEcEQCAFQQF0QXdBACACQQRLG2rAIAhBAXRBd0EAIAhBBEobasBMDR4LIAcoAhwiBi0AACEJCwJAAkACQCAJQf8BcUEBRw0AIAYtAAJFBEAgBkECOgAAIAcoAhwiBi0AACIJQQFHDQELIAYoAiAhCCAGKAIQIQICf0EAIAYtAANBAUsNABpBACAGLAAEIglBAkgNABpBwAAgCUEGSQ0AGkGAAUHAASAJQQZGGwsgCGhBDHRyIAJBAEdBBXRqIghBgPABa0H/8wNxQR9wIQIgBigCXCIJIAYoAmAgBigCZGoiEGtBAU0NBCAJIBBJDQUgBigCWCAQaiAIIAJrQeHvAWsiAkEIdCACQYD+A3FBCHZyOwAAIAYgBigCZEECajYCZCAHKAIcIgkoAhAEQCAJKAJcIgIgCSgCYCAJKAJkaiIIa0EDTQ0HIAIgCEkNCCAJKAJYIAhqIAcoAjAiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnI2AAAgCSAJKAJkQQRqNgJkIAcoAhwhCQsgB0EBNgIwIAlBAjoAACAHEOIYIApBKGogBygCHEHYAGoQ5CUgBygCHCEGIAooAiwNASAGLQAAIQkLIAlB/wFxQQRGDQEMEwsgBkH/AToAAQwTCyAGQQA2AqABIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBAk0NBSACIAhJDQYgCSgCWCAIaiICQdD6+wAvAAA7AABBAiELIAJBAmpB0vr7AC0AADoAACAJIAkoAmRBA2o2AmQgBygCHCIPLAAEIgJBCUcEQEEEIA8tAANBAUtBAnQgAkECSBshCwsgDygCiAEiAgRAIAIoAixBAEdBAXQgAigCAEEAR3IgAigCEEEAR0ECdHIgAigCHEEAR0EDdHIgAigCJEEAR0EEdHIhAiAPKAJcIgggDygCZCAPKAJgaiIJRg0IIAggCUkNCSAPKAJYIAlqIAI6AAAgDyAPKAJkQQFqNgJkIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBA00NCiACIAhJDQsgCSgCWCAIaiAPKAKIASgCBDYAACAJIAkoAmRBBGo2AmQgBygCHCIJKAJcIgIgCSgCYCAJKAJkaiIIa0EBTQ0MIAIgCEkNDSAJKAJYIAhqIA8oAogBKAIMQQh0IAtyOwAAIAkgCSgCZEECajYCZCAPKAKIASIIKAIQBH8gBygCHCIQKAJcIgIgECgCYCAQKAJkaiIJa0EBTQ0RIAIgCUkNEiAQKAJYIAlqIAgoAhQ7AAAgECAQKAJkQQJqNgJkIA8oAogBBSAICygCLARAIAcoAjAhAiAKQSBqIAcoAhxB2ABqEOQlIAcgAiAKKAIgIAooAiQQ3Qc2AjALIAcoAhxBADYCjAEgBygCHEEFOgAAIAcoAhwhBgwSCyAPKAJcIgIgDygCYCAPKAJkaiIIa0EGTQ0NIAIgCEkNDkEAIQkgDygCWCAIaiICQQA2AAAgAkEDOgAGIAIgCzoABSACQQRqQQA6AAAgDyAPKAJkQQdqNgJkIAcoAhxBAjoAACAHEOIYIApBGGogBygCHEHYAGoQ5CUgBygCHCEGIAooAhxFDREgBkH/AToAAQwdCyAHQeixwgA2AhhBfiEJDBwLIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQbD6+wAQ7ywACyAQIAlBsPr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQcD6+wAQ7ywACyAIIAJBwPr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQdT6+wAQ7ywACyAIIAJB1Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQfT6+wAQ7ywACyAJIAhB9Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQYT7+wAQ7ywACyAIIAJBhPv7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQZT7+wAQ7ywACyAIIAJBlPv7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQeT6+wAQ7ywACyAIIAJB5Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQaT7+wAQ7ywACyAJIAJBpPv7ABCvOwALIAYtAAAiCUEFRgRAAkAgBigCiAEiCUUNACAJKAIQIghFDQAgByAIIAYoAowBIgJqIAkvARQgAmsQwwsiCUEDRw0NIAcoAhwhBgsgBkEGOgAAIAcoAhwiBi0AACEJCwJAAkACQAJAIAlB/wFxQQZGBEAgBigCiAEiAkUNASACKAIcIgIEfyAHIAIgAhC4KkEBahDDCyIJQQNHDREgBygCHAUgBgtBBzoAACAHKAIcIgYtAAAhCQsgCUH/AXFBB0YEfyAGKAKIASICRQ0BIAIoAiQiAgR/IAcgAiACELgqQQFqEMMLIglBA0cNESAHKAIcBSAGC0EIOgAAIAcoAhwiBi0AAAUgCQtB/wFxQQhHDQACQCAGKAKIASICRQ0AIAIoAixFDQAgCiAHKAIwOwE4IAcgCkE4akECEMMLIglBA0cNECAHKAIcIQYLIAZBAjoAACAHEOIYIApBEGogBygCHEHYAGoQ5CUgCigCFA0BCyAHKAIEDQEgBygCHCICKAIkDQEgBUH/AXFFDQMgAi0AAEEDRw0BDAILIAcoAhxB/wE6AAEMAgsCfyAHKAIcIgItAAQiCEUEQCAHIAUQ/QJB/wFxDAELAkACQAJAIAItAANBAmsOAgIBAAsgCMAhAiAIQQpPBEAgAkEKQciA/QAQwyEACyAHIAUgAkEMbEHYgP0AaigCABECAAwCC0EAIQsjAEEgayINJAAgBUH/AXEhDwJAAkACQANAAkACQAJAAkACQAJAAkAgBygCHCIGKAIkIgxBhgJPBEAgBigCECESDAELIAYoAiAiDkEBdCEUIA5BhgJrIRADQAJAIAYoAlAgDCAGKAIQIgJqayEMAkACQAJAAkACQAJAAkACQAJAIBAgBigCIGogAk0EQCAUIAYoAhgiAksNASAOQQBIDQIgDgRAIAYoAhQiAiACIA5qIA78CgAACyAGIAYvAQwiCSAOQf//A3EiCGsiAkEAIAIgCU0bOwEMIAggCU8EQCAGQQA7ATQLIAYgBigCECAOayIINgIQIAYgBigCPCAOazYCPCAGIAggBigCgAEiAiACIAhLGzYCgAEgBhCUFiAMIA5qIQwLIAcoAgRFBEAgBygCHCEGDAoLIAxBAU0NAiAHIAcoAhwiAigCJCACKAIQaiAMEMwTIQIgBygCHCIGIAIgBigCJGoiAjYCJCACIAYoAoABIghqQQNJDQggBigCECICIAhrIQwgBi8BNkGACE0EQCACIAhGDQggDEEBayERIAYtAAZBAUYEQCAGIBEQ2RkaDAkLIAYoAhgiAiARSQ0EIAIgEWsiAkEDTQ0FIAYoAhQgEWooAABBsfPd8XlsQRB2QQF0IgkgBigCMGovAQAiCCARQf//A3FGDQggBigCIEEBayARcSISIAYoAiwiAk8NBiAGKAIoIBJBAXRqIAg7AQAgBigCMCAJaiAROwEADAgLIAYoAhgiAiAMTQRAIAwgAkG07fwAEMMhAAsgDEEBaiIIIAJJDQYgCCACQcTt/AAQwyEACyAUIAJB9Oz8ABCwOwALIA1BADYCGCANQQE2AgwgDUH46PwANgIIIA1CBDcCECANQQhqQYTt/AAQ7ywACyANQQA2AhggDUEBNgIMIA1BnO38ADYCCCANQgQ3AhAgDUEIakGk7fwAEO8sAAsgESACQfTp/AAQrzsAC0EEIAJBhOr8ABCwOwALIBIgAkGU6vwAEMMhAAsgBiAGKAIUIgIgDGotAABBBXQgAiAIai0AACICcyACQbHz3fF5bEEQdiAGLQAGGzYChAELIAYoAoABIAYoAiRBAUZrIgJFDQACQCAGLQAGQQFGBEAgBiAMIAIQ4BMMAQsgBiAMIAIQ6xQLIAYgBigCgAEgAms2AoABCyAHKAIcIgYoAiQiDEGFAksNACAHKAIEDQELCyAGKAIQIhIgBigCUEGGAmtLBEAgDUEANgIYIA1BATYCDCANQfDt/AA2AgggDUIENwIQIA1BCGpB+O38ABDvLAALIAYoAiQiDEGGAk8NACAPRQRAQQAhBgwLCyAMRQRAIAZBADYCgAEgBUH/AXFBBEcEQCAHKAIcKAJIBEBBACEGIAdBABCSASAHKAIQRQ0NC0EBIQYMDAsgB0EBEJIBQQNBAiAHKAIQGyEGDAsLIAxBAk0NAQsgEkUEQEEAIRIMAQsCQAJAIAYoAhgiAiASQQFrIhBPBEAgAiAQayICQYICTQ0BIAYoAhQiAiAQaiIILQAAIgkgAiASaiICLQAARw0CIAkgCC0AAkcNAiAJrUKBgoSIkKDAgAF+IRtBAiELAkADQCACIAtqKQAAIh0gG1EEQEGCAiEIIAtBCGoiC0GCAkcNAQwCCwsgGyAdhXqnQQN2IAtqIQgLQYICIAwgCCAIIAxLGyICIAJBggJPGyELDAILIBAgAkGg6fwAEK87AAtBgwIgAkGw6fwAELA7AAsgCyAQaiAGKAJQQQFrSw0BCyALQQJLDQEgEiAGKAIYIgJJDQIgEiACQeTp/AAQwyEACyANQQA2AhggDUEBNgIMIA1BzOn8ADYCCCANQgQ3AhAgDUEIakHU6fwAEO8sAAsgBigCRCICIAYoAkgiCEkNAiACIAhrIgJBAk0NBCAGKAJAIAhqIgIgC0EDayIIOgACIAJBATsAACAGIAYoAkgiCUEDajYCSCAGQf8BIAYtADpBAWoiAiACQf8BTxs6ADogBigCIEGGAkYNBSAGIAYvAaQTQQFqOwGkEyAGIAhB9Or8AGotAABBAnRqQawJaiICIAIvAQBBAWo7AQAgBigCRCEIIAcoAhwiAiACKAIkIAtrNgIkIAcoAhwiAiACKAIQIAtqNgIQQQAhCyAJIAhBBmtHDQMMAQsgBkFAayAGQaQBaiAGKAIUIBJqLQAAEJYjIAcoAhwiAiACKAIkQQFrNgIkIAcoAhwiAiACKAIQQQFqNgIQRQ0CC0EAIQYgB0EAEJIBIAcoAhANAQwECwsgCCACQaTq/AAQrzsAC0EDIAJBtOr8ABCwOwALIA1BADYCGCANQQE2AgwgDUHc6vwANgIIIA1CBDcCECANQQhqQeTq/AAQ7ywACyANQSBqJAAgBkH/AXEMAQsCfyMAQSBrIg4kAAJAA0ACQAJAIAcoAhwiBigCJARAIAYoAhAhCwwBCyAGKAIgIhFBAXQhEiARQYYCayEQQQAhCwNAAkAgBigCUCALIAYoAhAiAmprIQsCQAJAAkACQAJAAkACQAJAAkAgECAGKAIgaiACTQRAIBIgBigCGCICSw0BIBFBAEgNAiARBEAgBigCFCICIAIgEWogEfwKAAALIAYgBi8BDCIJIBFB//8DcSIIayICQQAgAiAJTRs7AQwgCCAJTwRAIAZBADsBNAsgBiAGKAIQIBFrIgg2AhAgBiAGKAI8IBFrNgI8IAYgCCAGKAKAASICIAIgCEsbNgKAASAGEJQWIAsgEWohCwsgBygCBEUEQCAHKAIcIQYMCgsgC0EBTQ0CIAcgBygCHCICKAIkIAIoAhBqIAsQzBMhAiAHKAIcIgYgAiAGKAIkaiICNgIkIAIgBigCgAEiCGpBA0kNCCAGKAIQIgIgCGshFCAGLwE2QYAITQRAIAIgCEYNCCAUQQFrIQwgBi0ABkEBRgRAIAYgDBDZGRoMCQsgBigCGCICIAxJDQQgAiAMayICQQNNDQUgBigCFCAMaigAAEGx893xeWxBEHZBAXQiCSAGKAIwai8BACIIIAxB//8DcUYNCCAGKAIgQQFrIAxxIg8gBigCLCICTw0GIAYoAiggD0EBdGogCDsBACAGKAIwIAlqIAw7AQAMCAsgBigCGCICIBRNBEAgFCACQdTg/AAQwyEACyAUQQFqIgggAkkNBiAIIAJB5OD8ABDDIQALIBIgAkGU4PwAELA7AAsgDkEANgIYIA5BATYCDCAOQdze/AA2AgggDkIENwIQIA5BCGpBpOD8ABDvLAALIA5BADYCGCAOQQE2AgwgDkG84PwANgIIIA5CBDcCECAOQQhqQcTg/AAQ7ywACyAMIAJB9N78ABCvOwALQQQgAkGE3/wAELA7AAsgDyACQZTf/AAQwyEACyAGIAYoAhQiAiAUai0AAEEFdCACIAhqLQAAIgJzIAJBsfPd8XlsQRB2IAYtAAYbNgKEAQsgBigCgAEgBigCJEEBRmsiAkUNAAJAIAYtAAZBAUYEQCAGIBQgAhDgEwwBCyAGIBQgAhDrFAsgBiAGKAKAASACazYCgAELIAcoAhwiBigCJCILQYUCSw0AIAcoAgQNAQsLIAYoAhAiCyAGKAJQQYYCa0sEQCAOQQA2AhggDkEBNgIMIA5BkOH8ADYCCCAOQgQ3AhAgDkEIakGY4fwAEO8sAAsgBigCJA0AIAVB/wFxIgJFBEBBACEGDAILIAZBADYCgAEgAkEERwRAIAcoAhwoAkgEQEEAIQYgB0EAEJIBIAcoAhBFDQMLQQEhBgwCCyAHQQEQkgFBA0ECIAcoAhAbIQYMAQsgCyAGKAIYIgJPDQIgBkFAayAGQaQBaiAGKAIUIAtqLQAAEJYjIAcoAhwiAiACKAIkQQFrNgIkIAcoAhwiAiACKAIQQQFqNgIQRQ0BQQAhBiAHQQAQkgEgBygCEA0BCwsgDkEgaiQAIAYMAQsgCyACQeTe/AAQwyEAC0H/AXELQf8BcSICQQFLBEAgBygCHEEDOgAACwJAAkAgAkEBaw4DAQACAAtBACEJIAcoAhANDSAHKAIcQf8BOgABDA0LAkACQAJAAkACQAJAIAVB/wFxQQFrDgUEAQIDBQALIApBADYCSCAKQQE2AjwgCkGA/PsANgI4IApCBDcCQCAKQThqQYj8+wAQ7ywACyAHKAIcQQBBAEEAEPgMDAMLIAcoAhxBAEEAQQAQ+AwgBygCHCgCMEEAQYCACPwLACAHKAIcIgIoAiQNAiACQQA2AhAgBygCHEEANgI8IAcoAhxBADYCgAEMAgsgCkEANgJIIApBATYCPCAKQeT8+wA2AjggCkIENwJAIApBOGpB7Pz7ABDvLAALIAcoAhxB2ABqIgJBAUEAEIwmIAJBgAJB/Nz7AEGgAhCrISACEJAVCyAHEOIYIAcoAhANACAHKAIcQf8BOgABDAELIAVB/wFxQQRHDQAgBygCHCIILQACQQFrDgICAQkLQQAhCQwKCyAIKAKgASEFIAhBADYCoAEgByAFNgIwIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBA00NASACIAhJDQIgCSgCWCAIaiAFNgAAIAkgCSgCZEEEajYCZCAHKAIcIggoAlwiAiAIKAJgIAgoAmRqIgVrQQNNDQMgAiAFSQ0EIAgoAlggBWogBygCCDYAACAIIAgoAmRBBGo2AmQMBwsgCCgCXCICIAgoAmAgCCgCZGoiBWtBA00NBCACIAVJDQUgCCgCWCAFaiAHKAIwIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyNgAAIAggCCgCZEEEajYCZAwGCyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akH8/PsAEO8sAAsgCCACQfz8+wAQrzsACyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akGM/fsAEO8sAAsgBSACQYz9+wAQrzsACyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akGc/fsAEO8sAAsgBSACQZz9+wAQrzsACyAHEOIYQQAhCSAKQQhqIAcoAhwiBSwAAiICQQBKBH8gBUEAIAJrOgACIAcoAhwFIAULQdgAahDkJSAKKAIMDQEgBygCHCICLQBwRQRAQQEhCQwCCyAKQgA3AkQgCkKBgICAwAA3AjwgCkHA/fsANgI4IwBBEGsiACQAIABBzLTCADYCDCAAIAJB8ABqNgIIQQAgAEEIakG4gP0AIABBDGpBuID9ACAKQThqQcj9+wAQ5g8ACyAHQduxwgA2AhhBeyEJCyAKQdAAaiQAIAkhAgsgBygCDCEIIAdCADcCDCAHKAIAIQUgB0IANwIAIAEgASkDACAFIANrrXw3AwAgASABKQMIIAggGWutfDcDCAJAAkACQAJAAkACQCACQQVqDgcCAAAEAAEDAAsgEyACNgIMIBNBATYCFCATQei9+wA2AhAgE0IBNwIcIBNBnAM2AiwgEyATQShqNgIYIBMgE0EMajYCKCATQRBqQZC++wAQ7ywACyAWQQA6AAEMAwsgFkEBOgABDAILIBZBAjoAAQwBCyATIAEQpyQgFiATKQMANwIEQQEhGgsgFiAaOgAAIBNBMGokACAAIBcpAgQ3AgAgAEEIaiAXQQxqKAIANgIAIAQgGCAVIAEpAwggHH2naiIAIAAgGEsbEI4tIBdBEGokAAsTAEL8v4CAgA8gADEAAIinQQFxCw8AIABBGGpBACAAKAIYGwsPACAAQSRqQQAgACgCJBsLEgAgACgCBCAAKAIIEMQIQQFzCxIAIAAoAgQgACgCCBC/CUEBcwsTACAAQQA2AgAgACABKAIANgIECw8AIAAoAgwEQCAAEIkgCwsQACAAKAIEIAAoAgBrQQN2Cw8AIABBIGpBACAAKAIgGwsQACAAQcwAakEAIAAoAkwbCw8AIABBFGpBACAAKAIUGwsPACAAQRxqQQAgACgCHBsLDwAgAEEsakEAIAAoAiwbCxAAIAAoAgQgACgCAGtBAnYLEwAgACABIAIoAgQgAigCCBDBLgsTACAAIAEgASgCDCABKAIQELUqCw4AIAAgASABIAJqEL0mCxUAIAAoAgAlASABKAIAJQEQd0EARwuoBwEDfyMAQfAAayIFJAAgBSADNgIMIAUgAjYCCAJ/AkACQAJAAkAgAUGBAk8EQEH9ASEGA0AgACAGaiIHQQNqLAAAQb9/Sg0DIAdBAmosAABBv39KDQIgB0EBaiwAAEG/f0oNBCAHLAAAQb9/Sg0FIAZBBGsiBkF9Rw0AC0EAIQYMBAsgBSABNgIUIAUgADYCEEEBDAQLIAZBAmohBgwCCyAGQQNqIQYMAQsgBkEBaiEGCyAFIAA2AhAgBSAGNgIUQQVBACABIAZLIgYbIQdB5PyJAUEBIAYbCyEGIAUgBzYCHCAFIAY2AhgCQAJAIAUgASACTwR/IAEgA08NASADBSACCzYCKCAFQQM2AjQgBUGs/okBNgIwIAVCAzcCPCAFIAVBGGqtQoCAgIDg4wOENwNYIAUgBUEQaq1CgICAgODjA4Q3A1AgBSAFQShqrUKAgICAsAeENwNIDAELIAIgA00EQCACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCIAJ/AkACQCABIANNDQBBACEHAkAgA0UNAANAIAAgA2osAABBv39KBEAgAyEHDAILIANBAWsiAw0ACwsgASAHRg0AAkACQCAAIAdqIgIsAAAiA0EASARAIAItAAFBP3EhACADQR9xIQEgA0FfSw0BIAFBBnQgAHIhBgwCCyAFIANB/wFxNgIkQQEMBAsgAi0AAkE/cSAAQQZ0ciEAIANBcEkEQCAAIAFBDHRyIQYMAQsgAUESdEGAgPAAcSACLQADQT9xIABBBnRyciIGQYCAxABGDQELIAUgBjYCJCAGQYABTw0BQQEMAgsgBBCyOwALQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIQAgBSAHNgIoIAUgACAHajYCLCAFQQU2AjQgBUHs/YkBNgIwIAVCBTcCPCAFIAVBGGqtQoCAgIDg4wOENwNoIAUgBUEQaq1CgICAgODjA4Q3A2AgBSAFQShqrUKAgICAgOQDhDcDWCAFIAVBJGqtQoCAgICQ5AOENwNQIAUgBUEgaq1CgICAgLAHhDcDSAwBCyAFQQQ2AjQgBUGM/YkBNgIwIAVCBDcCPCAFIAVBGGqtQoCAgIDg4wOENwNgIAUgBUEQaq1CgICAgODjA4Q3A1ggBSAFQQxqrUKAgICAsAeENwNQIAUgBUEIaq1CgICAgLAHhDcDSAsgBSAFQcgAajYCOCAFQTBqIAQQ7ywACxUCAW8BfxA+IQAQ3xIiASAAJgEgAQuWAQICfwFvIwBB4ABrIgIkACACQQA6AFggAiABNgJUIAIgADYCUCMAQfAAayIAJAAgAEEQaiIDIAJBCGpB2AD8CgAAIABCATcDCCAAIABBCGo2AmwgAEHsAGpByMjCABCTPSEBAkAgACkDCFANACAALQBgQQNHDQAgAxCrLAsgAEHwAGokACACQeAAaiQAIAElASABEPIfC48BAgJ/AW8jAEGgA2siAiQAIAJBADoAnAMgAiABNgKMAyACIAA2AogDIwBBsANrIgAkACAAQRBqIgMgAkEIakGYA/wKAAAgAEIBNwMIIAAgAEEIajYCrAMgAEGsA2pBjMjCABCTPSEBIAApAwhQRQRAIAMQnC8LIABBsANqJAAgAkGgA2okACABJQEgARDyHwuAAQICfwFvIwBBMGsiAiQAIAJBADoALCACIAE2AgwgAiAANgIIIwBBMGsiACQAIABBBGoiAyACQQhqQSj8CgAAIABBATYCACAAIAA2AiwgAEEsakGgyMIAEJM9IQEgACgCAARAIAMQ/ykLIABBMGokACACQTBqJAAgASUBIAEQ8h8LgwEBA38Q3xIiAyABJgEjAEEQayICJAAgAkEEaiAAENEkAkAgAigCBCIAKAIARQ0AIAAoAgQiBEGEAUkNACAEEPIfCyAAIAM2AgQgAEEBNgIAIAIoAghBADYCACACKAIMIgAgACgCAEEBayIANgIAIABFBEAgAkEMahDqGQsgAkEQaiQACxMAIABBKDYCBCAAQezJwgA2AgALEAAgABD3JSAAQQRBBBDgHgsTACAAQSg2AgQgAEHopcMANgIACxEAIAAoAgQgACgCCCABENwHCxsAAn8gAUEJTwRAIAEgABCbEgwBCyAAEKwBCwtAAAJAAn8gAUEJTwRAIAEgABCbEgwBCyAAEKwBCyIBRQ0AIAEQmj4tAARBA3FFIABFcg0AIAFBACAA/AsACyABCxMAIABBKDYCBCAAQYrjwwA2AgALEwAgAEEoNgIEIABB/PbDADYCAAuaAgEFfyMAQSBrIgMkACADQRRqIAFBAEECQQQQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhwgAhD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AgggA0EIaiIFKAIAIAUoAggiAmsgAUkEQCAFIAIgAUECQQQQ3iggBSgCCCECCyAFKAIEIAJBAnRqIQQCQAJAIAFBAk8EQCABQQFrIQYDQCAEQf//AzsBACAEQQJqQQA7AQAgBEEEaiEEIAZBAWsiBg0ACyABIAJqQQFrIQIMAQsgAUUNAQsgBEEAOwECIARB//8DOwEAIAJBAWohAgsgBSACNgIIIABBCGogBygCADYCACAAIAMpAgg3AgAgA0EgaiQACxEAIAAoAgAgACgCBCABENwHCxEAIAAoAgAgACgCBCABEKk9CxMAIABB5MfMADYCBCAAIAE2AgALEAAgACACNgIEIAAgATYCAAsTACAAQYD7zAA2AgQgACABNgIACxMAIABBkPvMADYCBCAAIAE2AgALEwAgAEGg+8wANgIEIAAgATYCAAsTACAAQbD7zAA2AgQgACABNgIACxMAIABBwPvMADYCBCAAIAE2AgALEwAgAEHQ+8wANgIEIAAgATYCAAsTACAAQeD7zAA2AgQgACABNgIACxMAIABB8PvMADYCBCAAIAE2AgALEwAgAEH8ic0ANgIEIAAgATYCAAsTACAAQYyKzQA2AgQgACABNgIACxMAIABBmJDNADYCBCAAIAE2AgALEwAgAEHgls0ANgIEIAAgATYCAAsTACAAQeSpzQA2AgQgACABNgIACxMAIABB9KnNADYCBCAAIAE2AgALEwAgAEGEqs0ANgIEIAAgATYCAAsTACAAQZSqzQA2AgQgACABNgIACxMAIABBpKrNADYCBCAAIAE2AgALEwAgAEG0qs0ANgIEIAAgATYCAAsTACAAQcSqzQA2AgQgACABNgIACxMAIABB1KrNADYCBCAAIAE2AgALEwAgAEHkqs0ANgIEIAAgATYCAAsTACAAQfSqzQA2AgQgACABNgIACxMAIABBhKvNADYCBCAAIAE2AgALEwAgAEGUq80ANgIEIAAgATYCAAsTACAAQaSrzQA2AgQgACABNgIACxMAIABBtKvNADYCBCAAIAE2AgALEwAgAEHEq80ANgIEIAAgATYCAAsTACAAQdSrzQA2AgQgACABNgIACxMAIABB5KvNADYCBCAAIAE2AgALEwAgAEH0q80ANgIEIAAgATYCAAsRACAAIAEoAgAgASgCBBDTIwsTACAAQSg2AgQgAEGgss0ANgIACxMAIABBjLzNADYCBCAAIAE2AgALEwAgAEGovM0ANgIEIAAgATYCAAsTACAAQbi8zQA2AgQgACABNgIACxMAIABB5NHNADYCBCAAIAE2AgALEwAgAEH00c0ANgIEIAAgATYCAAsTACAAQYTSzQA2AgQgACABNgIACxMAIABBlNLNADYCBCAAIAE2AgALEwAgAEGk0s0ANgIEIAAgATYCAAsTACAAQbTSzQA2AgQgACABNgIACxMAIABBxNLNADYCBCAAIAE2AgALEwAgAEHU0s0ANgIEIAAgATYCAAsTACAAQeTSzQA2AgQgACABNgIACxMAIABB9NLNADYCBCAAIAE2AgALEwAgAEGE080ANgIEIAAgATYCAAsTACAAQZTTzQA2AgQgACABNgIACxMAIABBpNPNADYCBCAAIAE2AgALEwAgAEG0080ANgIEIAAgATYCAAsTACAAQcTTzQA2AgQgACABNgIACxMAIABB1NPNADYCBCAAIAE2AgALEgAgACgCICAAKAIkKAIQEQQACxMAIABB4NfNADYCBCAAIAE2AgALEwAgAEEoNgIEIABBgPHNADYCAAtsAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQJ0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQcSChAEQyRQgAkEEaiECIAFBBGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALEwAgAEHAm88ANgIEIAAgATYCAAsPACAAQQxqELwqIAAQnQwLEQAgACgCBCAAKAIIIAEQqT0LEwAgAEHUo88ANgIEIAAgATYCAAsTACAAQczJzwA2AgQgACABNgIACxMAIABB3MnPADYCBCAAIAE2AgALEwAgAEGgzc8ANgIEIAAgATYCAAsTACAAQbDNzwA2AgQgACABNgIACxMAIABBsM/PADYCBCAAIAE2AgALEwAgAEGo0M8ANgIEIAAgATYCAAsTACAAQbjQzwA2AgQgACABNgIACxMAIABByNDPADYCBCAAIAE2AgALEwAgAEHY0M8ANgIEIAAgATYCAAsTACAAQejQzwA2AgQgACABNgIACxMAIABB+NDPADYCBCAAIAE2AgALEwAgAEGI0c8ANgIEIAAgATYCAAsTACAAQZjRzwA2AgQgACABNgIACxMAIABB1J7QADYCBCAAIAE2AgALEwAgAEHkntAANgIEIAAgATYCAAsTACAAQSg2AgQgAEGMotAANgIACxMAIABBhMnQADYCBCAAIAE2AgALDwAgACABIAIgAyAEEP0HCxMAIABBKDYCBCAAQbDH0QA2AgALEAAgAEEAOgABIAAgAToAAAsTACAAQSg2AgQgAEHEu/sANgIAC2wBAn8gACgCACECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAXQhAQNAIAAgAjYCDCAAQQRqIABBDGpB+MH7ABDJFCACQQJqIQIgAUECayIBDQALCyAAQQRqEKksIABBEGokAAsQACAAQQA2AgggAEIANwMACxEAIAAoAgQgACgCCCABEMUjCxEAIAAoAgAgACgCBCABEMUjCxMAIABBrNX+ADYCBCAAIAE2AgALEwAgAEG81f4ANgIEIAAgATYCAAsQACAAQQA2AgQgACABNgIACw8AIAAgACgCACABajYCAAsTACAAQbiZ/wA2AgQgACABNgIACxMAIABByJn/ADYCBCAAIAE2AgALEwAgAEHYmf8ANgIEIAAgATYCAAsTACAAQeiZ/wA2AgQgACABNgIACxMAIABB+Jn/ADYCBCAAIAE2AgALEwAgAEGImv8ANgIEIAAgATYCAAsTACAAQZia/wA2AgQgACABNgIACxMAIABBqJr/ADYCBCAAIAE2AgALEwAgAEG4mv8ANgIEIAAgATYCAAsTACAAQcia/wA2AgQgACABNgIACxMAIABB2Jr/ADYCBCAAIAE2AgALEwAgAEHomv8ANgIEIAAgATYCAAsTACAAQfia/wA2AgQgACABNgIACxMAIABBiJv/ADYCBCAAIAE2AgALEwAgAEGYm/8ANgIEIAAgATYCAAsTACAAQaib/wA2AgQgACABNgIACxMAIABBuJv/ADYCBCAAIAE2AgALEwAgAEHIm/8ANgIEIAAgATYCAAsTACAAQdib/wA2AgQgACABNgIACxMAIABB6Jv/ADYCBCAAIAE2AgALEwAgAEH4m/8ANgIEIAAgATYCAAsTACAAQYic/wA2AgQgACABNgIACxMAIABBnLb/ADYCBCAAIAE2AgALEwAgAEGstv8ANgIEIAAgATYCAAsTACAAQby2/wA2AgQgACABNgIACxMAIABBzLb/ADYCBCAAIAE2AgALEwAgAEHctv8ANgIEIAAgATYCAAsTACAAQey2/wA2AgQgACABNgIACxMAIABB/Lb/ADYCBCAAIAE2AgALEwAgAEGMt/8ANgIEIAAgATYCAAsTACAAQZy3/wA2AgQgACABNgIACxMAIABBrLf/ADYCBCAAIAE2AgALEwAgAEG8t/8ANgIEIAAgATYCAAsTACAAQcy3/wA2AgQgACABNgIACxMAIABB3Lf/ADYCBCAAIAE2AgALEwAgAEHst/8ANgIEIAAgATYCAAsTACAAQfy3/wA2AgQgACABNgIACxMAIABBjLj/ADYCBCAAIAE2AgALEwAgAEGcuP8ANgIEIAAgATYCAAsTACAAQay4/wA2AgQgACABNgIACxMAIABBvLj/ADYCBCAAIAE2AgALEwAgAEHMuP8ANgIEIAAgATYCAAsTACAAQdy4/wA2AgQgACABNgIACxMAIABB7Lj/ADYCBCAAIAE2AgALEwAgAEH8uP8ANgIEIAAgATYCAAsTACAAQYy5/wA2AgQgACABNgIACxMAIABBnLn/ADYCBCAAIAE2AgALEwAgAEGsuf8ANgIEIAAgATYCAAsTACAAQby5/wA2AgQgACABNgIACxMAIABBzLn/ADYCBCAAIAE2AgALEwAgAEHcuf8ANgIEIAAgATYCAAsTACAAQey5/wA2AgQgACABNgIACxMAIABB/Ln/ADYCBCAAIAE2AgALEwAgAEGMuv8ANgIEIAAgATYCAAsTACAAQZy6/wA2AgQgACABNgIACxMAIABBrLr/ADYCBCAAIAE2AgALEwAgAEG8uv8ANgIEIAAgATYCAAsTACAAQcy6/wA2AgQgACABNgIACxMAIABB3Lr/ADYCBCAAIAE2AgALEwAgAEHsuv8ANgIEIAAgATYCAAsTACAAQfy6/wA2AgQgACABNgIACxMAIABBnMn/ADYCBCAAIAE2AgALEwAgAEGsyf8ANgIEIAAgATYCAAsTACAAQcDu/wA2AgQgACABNgIACxMAIABB0O7/ADYCBCAAIAE2AgALEwAgAEHg7v8ANgIEIAAgATYCAAsTACAAQfDu/wA2AgQgACABNgIACxMAIABBgO//ADYCBCAAIAE2AgALEwAgAEGQ7/8ANgIEIAAgATYCAAsTACAAQaDv/wA2AgQgACABNgIACxMAIABBsO//ADYCBCAAIAE2AgALEwAgAEHA7/8ANgIEIAAgATYCAAsTACAAQdDv/wA2AgQgACABNgIACxMAIABB4O//ADYCBCAAIAE2AgALEwAgAEHw7/8ANgIEIAAgATYCAAsTACAAQYDw/wA2AgQgACABNgIACxMAIABBkPD/ADYCBCAAIAE2AgALEwAgAEGg8P8ANgIEIAAgATYCAAsTACAAQbDw/wA2AgQgACABNgIACxMAIABBwPD/ADYCBCAAIAE2AgALEwAgAEHQ8P8ANgIEIAAgATYCAAsTACAAQeDw/wA2AgQgACABNgIACxMAIABB8PD/ADYCBCAAIAE2AgALEwAgAEGA8f8ANgIEIAAgATYCAAsTACAAQZDx/wA2AgQgACABNgIACxMAIABBoPH/ADYCBCAAIAE2AgALEwAgAEGw8f8ANgIEIAAgATYCAAsTACAAQcDx/wA2AgQgACABNgIACxMAIABB0PH/ADYCBCAAIAE2AgALEwAgAEG0+/8ANgIEIAAgATYCAAsTACAAQbCPgAE2AgQgACABNgIACxMAIABBwI+AATYCBCAAIAE2AgALEwAgAEHQj4ABNgIEIAAgATYCAAsTACAAQeCPgAE2AgQgACABNgIACxMAIABB8I+AATYCBCAAIAE2AgALEwAgAEGAkIABNgIEIAAgATYCAAsTACAAQZCQgAE2AgQgACABNgIACxMAIABBoJCAATYCBCAAIAE2AgALEwAgAEGwkIABNgIEIAAgATYCAAsTACAAQcCQgAE2AgQgACABNgIACxMAIABB0JCAATYCBCAAIAE2AgALEwAgAEHgkIABNgIEIAAgATYCAAsTACAAQfCQgAE2AgQgACABNgIACxMAIABBgJGAATYCBCAAIAE2AgALDQAgACABIAIQoTZBAAsTACAAQbDhgAE2AgQgACABNgIACxMAIABBwOGAATYCBCAAIAE2AgALEwAgAEHQ4YABNgIEIAAgATYCAAsQACAAQQA6AAQgACABNgIACw8AIAAQvCogAEEIahC8Kgs+AQJ/IAAoAggiAgRAIAAoAgQhAQNAIAEoAgAEQCABEM4qCyABQRBqIQEgAkEBayICDQALCyAAQQRBEBDgHgsTACAAQaiHgQE2AgQgACABNgIACxMAIABBoOqBATYCBCAAIAE2AgALEwAgAEGw6oEBNgIEIAAgATYCAAsTACAAQcDqgQE2AgQgACABNgIACxMAIABB0OqBATYCBCAAIAE2AgALEwAgAEHg6oEBNgIEIAAgATYCAAsTACAAQfDqgQE2AgQgACABNgIACxMAIABBgOuBATYCBCAAIAE2AgALEwAgAEGQ64EBNgIEIAAgATYCAAsTACAAQaDrgQE2AgQgACABNgIACxMAIABBsOuBATYCBCAAIAE2AgALEwAgAEHA64EBNgIEIAAgATYCAAsTACAAQdDrgQE2AgQgACABNgIACxMAIABB4OuBATYCBCAAIAE2AgALEwAgAEHw64EBNgIEIAAgATYCAAsTACAAQYDsgQE2AgQgACABNgIACxMAIABBkOyBATYCBCAAIAE2AgALEwAgAEGg7IEBNgIEIAAgATYCAAsTACAAQbDsgQE2AgQgACABNgIACxMAIABBwOyBATYCBCAAIAE2AgALEwAgAEHQ7IEBNgIEIAAgATYCAAsTACAAQeDsgQE2AgQgACABNgIACxMAIABB8OyBATYCBCAAIAE2AgALEwAgAEGA7YEBNgIEIAAgATYCAAsTACAAQZDtgQE2AgQgACABNgIACxMAIABBoO2BATYCBCAAIAE2AgALEwAgAEGw7YEBNgIEIAAgATYCAAsTACAAQcDtgQE2AgQgACABNgIACxMAIABB0O2BATYCBCAAIAE2AgALEwAgAEHg7YEBNgIEIAAgATYCAAsTACAAQfDtgQE2AgQgACABNgIACxMAIABBgO6BATYCBCAAIAE2AgALEwAgAEGQ7oEBNgIEIAAgATYCAAsTACAAQaDugQE2AgQgACABNgIACxMAIABBsO6BATYCBCAAIAE2AgALEwAgAEHA7oEBNgIEIAAgATYCAAsTACAAQdDugQE2AgQgACABNgIACxMAIABB4O6BATYCBCAAIAE2AgALEwAgAEHw7oEBNgIEIAAgATYCAAsTACAAQYDvgQE2AgQgACABNgIACxMAIABBkO+BATYCBCAAIAE2AgALEwAgAEGg74EBNgIEIAAgATYCAAsTACAAQbDvgQE2AgQgACABNgIACxMAIABBwO+BATYCBCAAIAE2AgALEwAgAEHQ74EBNgIEIAAgATYCAAsTACAAQeDvgQE2AgQgACABNgIACxMAIABB8O+BATYCBCAAIAE2AgALEwAgAEGA8IEBNgIEIAAgATYCAAsTACAAQZDwgQE2AgQgACABNgIACxMAIABBoPCBATYCBCAAIAE2AgALEwAgAEGw8IEBNgIEIAAgATYCAAsTACAAQfj8gQE2AgQgACABNgIACxMAIABBqP2BATYCBCAAIAE2AgALEwAgAEG4/YEBNgIEIAAgATYCAAsTACAAQcj9gQE2AgQgACABNgIACxMAIABB5P2BATYCBCAAIAE2AgALEwAgAEH0/YEBNgIEIAAgATYCAAsTACAAQYT+gQE2AgQgACABNgIACxMAIABB0LCCATYCBCAAIAE2AgALEwAgAEHwuIIBNgIEIAAgATYCAAsTACAAQYC5ggE2AgQgACABNgIACxMAIABBkLmCATYCBCAAIAE2AgALEwAgAEGguYIBNgIEIAAgATYCAAsTACAAQbC5ggE2AgQgACABNgIACxMAIABBwLmCATYCBCAAIAE2AgALEwAgAEHQuYIBNgIEIAAgATYCAAsTACAAQeC5ggE2AgQgACABNgIACxMAIABB8LmCATYCBCAAIAE2AgALEwAgAEGAuoIBNgIEIAAgATYCAAsTACAAQZC6ggE2AgQgACABNgIACxMAIABBoLqCATYCBCAAIAE2AgALEwAgAEGwuoIBNgIEIAAgATYCAAsTACAAQcC6ggE2AgQgACABNgIACxMAIABB0LqCATYCBCAAIAE2AgALEwAgAEHguoIBNgIEIAAgATYCAAsTACAAQfC6ggE2AgQgACABNgIACxMAIABBgLuCATYCBCAAIAE2AgALEwAgAEGQu4IBNgIEIAAgATYCAAsTACAAQaC7ggE2AgQgACABNgIACxMAIABBsLuCATYCBCAAIAE2AgALEwAgAEHAu4IBNgIEIAAgATYCAAsTACAAQdC7ggE2AgQgACABNgIACxMAIABB4LuCATYCBCAAIAE2AgALEwAgAEHwu4IBNgIEIAAgATYCAAsTACAAQYC8ggE2AgQgACABNgIACxMAIABBkLyCATYCBCAAIAE2AgALEwAgAEGgvIIBNgIEIAAgATYCAAsTACAAQbC8ggE2AgQgACABNgIACxMAIABBwLyCATYCBCAAIAE2AgALEwAgAEHQvIIBNgIEIAAgATYCAAsTACAAQeC8ggE2AgQgACABNgIACxMAIABB8LyCATYCBCAAIAE2AgALEwAgAEGAvYIBNgIEIAAgATYCAAsTACAAQZC9ggE2AgQgACABNgIACxMAIABBoL2CATYCBCAAIAE2AgALEwAgAEGwvYIBNgIEIAAgATYCAAsTACAAQcC9ggE2AgQgACABNgIACxMAIABB0L2CATYCBCAAIAE2AgALEwAgAEHgvYIBNgIEIAAgATYCAAsTACAAQfC9ggE2AgQgACABNgIACxMAIABBgL6CATYCBCAAIAE2AgALEwAgAEGQvoIBNgIEIAAgATYCAAsTACAAQaC+ggE2AgQgACABNgIACxMAIABBsL6CATYCBCAAIAE2AgALEwAgAEHAvoIBNgIEIAAgATYCAAsTACAAQdC+ggE2AgQgACABNgIACxMAIABB4L6CATYCBCAAIAE2AgALEwAgAEG0yYIBNgIEIAAgATYCAAsTACAAQcTJggE2AgQgACABNgIACxMAIABB4MmCATYCBCAAIAE2AgALEwAgAEHwyYIBNgIEIAAgATYCAAsTACAAQYDKggE2AgQgACABNgIACxMAIABBhPSCATYCBCAAIAE2AgALEwAgAEGU9IIBNgIEIAAgATYCAAsTACAAQaT0ggE2AgQgACABNgIACxMAIABBtPSCATYCBCAAIAE2AgALEwAgAEHE9IIBNgIEIAAgATYCAAsTACAAQdT0ggE2AgQgACABNgIACxMAIABB5PSCATYCBCAAIAE2AgALEwAgAEH09IIBNgIEIAAgATYCAAsTACAAQYT1ggE2AgQgACABNgIACxMAIABBlPWCATYCBCAAIAE2AgALEwAgAEGk9YIBNgIEIAAgATYCAAsTACAAQbT1ggE2AgQgACABNgIACxMAIABBxPWCATYCBCAAIAE2AgALEwAgAEHU9YIBNgIEIAAgATYCAAsTACAAQeT1ggE2AgQgACABNgIACxMAIABB9PWCATYCBCAAIAE2AgALEwAgAEGE9oIBNgIEIAAgATYCAAsTACAAQZT2ggE2AgQgACABNgIACxMAIABBpPaCATYCBCAAIAE2AgALEwAgAEG09oIBNgIEIAAgATYCAAsTACAAQcT2ggE2AgQgACABNgIACxMAIABB1PaCATYCBCAAIAE2AgALEwAgAEHk9oIBNgIEIAAgATYCAAsTACAAQfT2ggE2AgQgACABNgIACxMAIABBhPeCATYCBCAAIAE2AgALEwAgAEGU94IBNgIEIAAgATYCAAsTACAAQaT3ggE2AgQgACABNgIACxMAIABBtPeCATYCBCAAIAE2AgALEwAgAEHE94IBNgIEIAAgATYCAAsTACAAQdT3ggE2AgQgACABNgIACxMAIABB5PeCATYCBCAAIAE2AgALEwAgAEH094IBNgIEIAAgATYCAAsTACAAQYT4ggE2AgQgACABNgIACxMAIABBlPiCATYCBCAAIAE2AgALEwAgAEGk+IIBNgIEIAAgATYCAAsTACAAQbT4ggE2AgQgACABNgIACxMAIABBxPiCATYCBCAAIAE2AgALEwAgAEHU+IIBNgIEIAAgATYCAAsTACAAQeT4ggE2AgQgACABNgIACxMAIABB9PiCATYCBCAAIAE2AgALEwAgAEGE+YIBNgIEIAAgATYCAAsTACAAQZT5ggE2AgQgACABNgIACxMAIABBpPmCATYCBCAAIAE2AgALEwAgAEG0+YIBNgIEIAAgATYCAAsTACAAQcT5ggE2AgQgACABNgIACxMAIABB1PmCATYCBCAAIAE2AgALEwAgAEHk+YIBNgIEIAAgATYCAAsTACAAQdyCgwE2AgQgACABNgIACxMAIABB7IKDATYCBCAAIAE2AgALEwAgAEH8goMBNgIEIAAgATYCAAsTACAAQZiDgwE2AgQgACABNgIACxMAIABBqIODATYCBCAAIAE2AgALEwAgAEG4g4MBNgIEIAAgATYCAAsTACAAQci/gwE2AgQgACABNgIACxMAIABB2L+DATYCBCAAIAE2AgALEwAgAEHov4MBNgIEIAAgATYCAAsTACAAQfi/gwE2AgQgACABNgIACxMAIABBiMCDATYCBCAAIAE2AgALEwAgAEGYwIMBNgIEIAAgATYCAAsTACAAQajAgwE2AgQgACABNgIACxMAIABBuMCDATYCBCAAIAE2AgALEwAgAEHIwIMBNgIEIAAgATYCAAsTACAAQdjAgwE2AgQgACABNgIACxMAIABB6MCDATYCBCAAIAE2AgALEwAgAEH4wIMBNgIEIAAgATYCAAsTACAAQYjBgwE2AgQgACABNgIACxMAIABBmMGDATYCBCAAIAE2AgALEwAgAEGowYMBNgIEIAAgATYCAAsTACAAQbjBgwE2AgQgACABNgIACxMAIABByMGDATYCBCAAIAE2AgALEwAgAEHYwYMBNgIEIAAgATYCAAsTACAAQejBgwE2AgQgACABNgIACxMAIABB+MGDATYCBCAAIAE2AgALEwAgAEGIwoMBNgIEIAAgATYCAAsTACAAQZjCgwE2AgQgACABNgIACxMAIABBqMKDATYCBCAAIAE2AgALEwAgAEG4woMBNgIEIAAgATYCAAsTACAAQcjCgwE2AgQgACABNgIACxMAIABB2MKDATYCBCAAIAE2AgALEwAgAEHowoMBNgIEIAAgATYCAAsTACAAQfjCgwE2AgQgACABNgIACxMAIABBiMODATYCBCAAIAE2AgALEwAgAEGYw4MBNgIEIAAgATYCAAsTACAAQajDgwE2AgQgACABNgIACxMAIABBuMODATYCBCAAIAE2AgALEwAgAEHIw4MBNgIEIAAgATYCAAsTACAAQdjDgwE2AgQgACABNgIACxMAIABB6MODATYCBCAAIAE2AgALEwAgAEH4w4MBNgIEIAAgATYCAAsTACAAQYjEgwE2AgQgACABNgIACxMAIABBmMSDATYCBCAAIAE2AgALEwAgAEGoxIMBNgIEIAAgATYCAAsTACAAQbjEgwE2AgQgACABNgIACxMAIABByMSDATYCBCAAIAE2AgALEwAgAEHYxIMBNgIEIAAgATYCAAsTACAAQejEgwE2AgQgACABNgIACxMAIABB+MSDATYCBCAAIAE2AgALEwAgAEGIxYMBNgIEIAAgATYCAAsTACAAQZjFgwE2AgQgACABNgIACxMAIABB6MuDATYCBCAAIAE2AgALEQAgACgCACAAKAIEIAEQywoLEwAgAEHojoQBNgIEIAAgATYCAAsTACAAQYSPhAE2AgQgACABNgIACxMAIABBlI+EATYCBCAAIAE2AgALEwAgAEGkj4QBNgIEIAAgATYCAAsTACAAQbSPhAE2AgQgACABNgIACxMAIABBxI+EATYCBCAAIAE2AgALEwAgAEHUj4QBNgIEIAAgATYCAAsTACAAQeSPhAE2AgQgACABNgIACxMAIABB9I+EATYCBCAAIAE2AgALEwAgAEGEkIQBNgIEIAAgATYCAAsTACAAQZSQhAE2AgQgACABNgIACxMAIABBpJCEATYCBCAAIAE2AgALEwAgAEG0kIQBNgIEIAAgATYCAAsTACAAQYSWhAE2AgQgACABNgIACxMAIABBlJaEATYCBCAAIAE2AgALEwAgAEGkloQBNgIEIAAgATYCAAsTACAAQbSWhAE2AgQgACABNgIACxMAIABBxJaEATYCBCAAIAE2AgALEwAgAEHUloQBNgIEIAAgATYCAAsTACAAQdiXhAE2AgQgACABNgIACxMAIABB6JeEATYCBCAAIAE2AgALEwAgAEH4l4QBNgIEIAAgATYCAAsTACAAQYiYhAE2AgQgACABNgIACxMAIABBmJiEATYCBCAAIAE2AgALEwAgAEGomIQBNgIEIAAgATYCAAsTACAAQbiYhAE2AgQgACABNgIACxMAIABByJiEATYCBCAAIAE2AgALEwAgAEHYmIQBNgIEIAAgATYCAAsTACAAQeiYhAE2AgQgACABNgIACxMAIABB+JiEATYCBCAAIAE2AgALEwAgAEGImYQBNgIEIAAgATYCAAsTACAAQZiZhAE2AgQgACABNgIACxMAIABBqJmEATYCBCAAIAE2AgALEwAgAEG4mYQBNgIEIAAgATYCAAsTACAAQciZhAE2AgQgACABNgIACxMAIABB2JmEATYCBCAAIAE2AgALEwAgAEHomYQBNgIEIAAgATYCAAsTACAAQfiZhAE2AgQgACABNgIACxMAIABBiJqEATYCBCAAIAE2AgALEwAgAEGYmoQBNgIEIAAgATYCAAsTACAAQaiahAE2AgQgACABNgIACxMAIABBuJqEATYCBCAAIAE2AgALEwAgAEHImoQBNgIEIAAgATYCAAsTACAAQdiahAE2AgQgACABNgIACxMAIABB6JqEATYCBCAAIAE2AgALEwAgAEH4moQBNgIEIAAgATYCAAsTACAAQYibhAE2AgQgACABNgIACxMAIABBmJuEATYCBCAAIAE2AgALEwAgAEGom4QBNgIEIAAgATYCAAsTACAAQbibhAE2AgQgACABNgIACxMAIABByJuEATYCBCAAIAE2AgALEwAgAEGMnYQBNgIEIAAgATYCAAsTACAAQaSdhAE2AgQgACABNgIACxMAIABBtJ2EATYCBCAAIAE2AgALEwAgAEHEnYQBNgIEIAAgATYCAAsTACAAQdSdhAE2AgQgACABNgIACxMAIABB5J2EATYCBCAAIAE2AgALEwAgAEH0nYQBNgIEIAAgATYCAAsTACAAQYSehAE2AgQgACABNgIACxMAIABBlJ6EATYCBCAAIAE2AgALEwAgAEHYyoQBNgIEIAAgATYCAAsTACAAQejKhAE2AgQgACABNgIACxMAIABB+MqEATYCBCAAIAE2AgALEwAgAEGIy4QBNgIEIAAgATYCAAsTACAAQZjLhAE2AgQgACABNgIACxMAIABBqMuEATYCBCAAIAE2AgALEwAgAEG4y4QBNgIEIAAgATYCAAsTACAAQcjLhAE2AgQgACABNgIACxMAIABB2MuEATYCBCAAIAE2AgALEwAgAEHoy4QBNgIEIAAgATYCAAsTACAAQfjLhAE2AgQgACABNgIACxMAIABBiMyEATYCBCAAIAE2AgALEwAgAEGYzIQBNgIEIAAgATYCAAsTACAAQajMhAE2AgQgACABNgIACxMAIABBuMyEATYCBCAAIAE2AgALEwAgAEHIzIQBNgIEIAAgATYCAAsTACAAQdjMhAE2AgQgACABNgIACxMAIABB6MyEATYCBCAAIAE2AgALEwAgAEH4zIQBNgIEIAAgATYCAAsTACAAQYjNhAE2AgQgACABNgIACxMAIABBmM2EATYCBCAAIAE2AgALEwAgAEGozYQBNgIEIAAgATYCAAsTACAAQbjNhAE2AgQgACABNgIACxMAIABByM2EATYCBCAAIAE2AgALEwAgAEHYzYQBNgIEIAAgATYCAAsTACAAQejNhAE2AgQgACABNgIACxMAIABB+M2EATYCBCAAIAE2AgALEwAgAEGIzoQBNgIEIAAgATYCAAsTACAAQZjOhAE2AgQgACABNgIACxMAIABBqM6EATYCBCAAIAE2AgALEwAgAEG4zoQBNgIEIAAgATYCAAsTACAAQcjOhAE2AgQgACABNgIACw8AIAAoAixBACAAKAIYGwsTACAAQeDshAE2AgQgACABNgIACxMAIABB8OyEATYCBCAAIAE2AgALEwAgAEGA7YQBNgIEIAAgATYCAAsTACAAQZDthAE2AgQgACABNgIACxMAIABBoO2EATYCBCAAIAE2AgALEwAgAEGw7YQBNgIEIAAgATYCAAsTACAAQcDthAE2AgQgACABNgIACxMAIABB0O2EATYCBCAAIAE2AgALDwAgACgCOEEAIAAoAiQbCxMAIABB1PiEATYCBCAAIAE2AgALEwAgAEHk+IQBNgIEIAAgATYCAAsTACAAQfT4hAE2AgQgACABNgIACxMAIABBrMuFATYCBCAAIAE2AgALEwAgAEG8y4UBNgIEIAAgATYCAAsTACAAQYDZhQE2AgQgACABNgIACxMAIABBkNmFATYCBCAAIAE2AgALDQAgACgCHEEDdkEBawsNACAAKAIcQQJ2QQFrCw8AIAAoAjRBACAAKAIgGwsTACAAQaThhQE2AgQgACABNgIACw0AIAAoAkhBAnZBAWsLDwAgACgCYEEAIAAoAkwbC2wBAn8gACgCACECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAnQhAQNAIAAgAjYCDCAAQQRqIABBDGpBsPaEARDJFCACQQRqIQIgAUEEayIBDQALCyAAQQRqEKksIABBEGokAAtlAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQANAIAAgAjYCDCAAQQRqIABBDGpBgPaEARDJFCACQQFqIQIgA0EBayIDDQALCyAAQQRqEKksIABBEGokAAtsAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQF0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQZD2hAEQyRQgAkECaiECIAFBAmsiAQ0ACwsgAEEEahCpLCAAQRBqJAALbAECfyAAKAIAIQIgACgCBCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0EDdCEBA0AgACACNgIMIABBBGogAEEMakGg9oQBEMkUIAJBCGohAiABQQhrIgENAAsLIABBBGoQqSwgAEEQaiQAC5oFAgt/AX4gACgCAEEIaiEAIwBBIGsiBSQAIAAoAgBBCGoiBiAAKAIEQQJ0aiEHIwBBIGsiAiQAIAJBFGogByAGa0ECdkEAQQRBDBCgGCACKAIYIQAgAigCFEEBRgRAIAAgAigCHEH43IcBEP0vAAsgAkEQaiIKQQA2AgAgAiACKAIcNgIMIAIgADYCCCMAQRBrIggkACAHIAZrQQJ2IgQgAkEIaiIAKAIAIAAoAggiA2tLBEAgACADIARBBEEMENwoIAAoAgghAwsgBUEUaiEJIAggACgCBDYCDCAIIAM2AgggCCAAQQhqNgIEIwBBMGsiACQAIAhBBGoiBCgCBCEDIAQoAgAhCwJAAkAgBiAHRwRAIAQoAgggA0EMbGohBCAHIAZrQQJ2IQcDQCAAQQA2AgggAEKAgICAEDcCACAAIAYoAgBBCGo2AgwgAEEBNgIUIABB+M6HATYCECAAQgE3AhwgAEHpHDYCLCAAIABBKGo2AhggACAAQQxqNgIoIABB7NqHASAAQRBqEMsKDQIgAEEYaiAAQQhqKAIAIgw2AgAgACAAKQIAIg03AxAgBEEIaiAMNgIAIAQgDTcCACAGQQRqIQYgBEEMaiEEIANBAWohAyAHQQFrIgcNAAsLIAsgAzYCACAAQTBqJAAMAQtBlNuHAUE3IABBEGpBhNuHAUHM24cBENUeAAsgCEEQaiQAIAlBCGogCigCADYCACAJIAIpAgg3AgAgAkEgaiQAIAVBCGoiAyAFKAIYIgAgBSgCHCICQdTdhwFBAhDxAyABIAUoAgwgBSgCEBD7NSADQQFBARDgHiACBEADQCAAQQFBARDgHiAAQQxqIQAgAkEBayICDQALCyAFQRRqQQRBDBDgHiAFQSBqJAALEwAgAEHA74UBNgIEIAAgATYCAAsPACAAKAIoQQAgACgCFBsLEwAgAEGk+YUBNgIEIAAgATYCAAsPACAAKAIwQQAgACgCHBsLEwAgAEHsh4YBNgIEIAAgATYCAAsTACAAQZiQhgE2AgQgACABNgIACxMAIABBqJCGATYCBCAAIAE2AgALEwAgAEG4kIYBNgIEIAAgATYCAAsTACAAQciQhgE2AgQgACABNgIACw0AIAAoAhRBAnZBAWsLDQAgACgCFEEDdkEBawsTACAAQZSVhgE2AgQgACABNgIACxMAIABBpJWGATYCBCAAIAE2AgALDwAgACgCQEEAIAAoAiwbCxMAIABB5KKGATYCBCAAIAE2AgALEwAgAEGcp4YBNgIEIAAgATYCAAsTACAAQZSphgE2AgQgACABNgIACw8AIAAgASAEIAMgBBCtDwsPACAAIAEgBCADIAQQ6RALDwAgACABIAQgAyAEEOoQCw8AIAAgASAEIAMgBBDrEAsPACAAIAEgBCADIAQQhRELDwAgACABIAQgAyAEEL8OCw8AIAAgASAEIAMgBBDADgsPACAAIAEgAiADIAQQwwoLbAECfyAAKAIEIQIgACgCCCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0ECdCEBA0AgACACNgIMIABBBGogAEEMakGw3ocBEMkUIAJBBGohAiABQQRrIgENAAsLIABBBGoQqSwgAEEQaiQACw8AIAAgASACIAMgBBDxAwuwAQEGfyMAQRBrIgMkACADIAFBA3YgAUEHcUEAR2oQ0h8gAygCBCEGIAMoAgAhByADKAIMIQQgAygCCCEFQRxBBBCtNiICRQRAQQRBHBCjPQALIAIgBjYCGCACIAc2AhQgAkEANgIQIAIgBDYCDCACIAU2AgggAkKBgICAEDcCACAAIAE2AhAgAEEANgIMIAAgBDYCCCAAIAU2AgQgACACNgIAIANBEGokACAAIAE2AhQLEAAgACgCAEUEQCAAEIQNCwsRACAAIAAoAgwgACgCEBDTHwsQACAAIAEoAgAgAiADEI0YCxAAIAAgASgCACACIAMQxhILEAAgACABNgIEIABBADYCAAsQACAAQQA2AgAgAEEANgIICxIAIAAoAgAlASABKAIAJQEQMQsPACAAKAIAJQEgASACEDILDgAgACgCACUBEERBAEcLDwAgACAAKAIUQQFqNgIUCxMAIABB7LWJATYCBCAAIAE2AgALEQAgASAAKAIAIAAoAgQQ+zULEQAgASAAKAIAIAAoAgQQ1gkLEQAgASgCACABKAIEIAAQywoLEQEBfxDfEiIBIAAlASYBIAELgwECA38BbyMAQTBrIgEkACAAEMkhIQAgAUEAOgAsIAEgADYCDCMAQTBrIgAkACAAQQhqIgMgAUEMakEk/AoAACAAQQE2AgQgACAAQQRqNgIsIABBLGpBhN3DABCTPSECIAAoAgQEQCADEOIgCyAAQTBqJAAgAUEwaiQAIAIlASACEPIfCw8AIAAoAgAoAgAgARDbHAsPACAAKAIAKAIAIAEQnhALYgEBfwJAAkAgABCaPigCBCICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABDwCQwCC0GIqYkBQS5BuKmJARCfKQALQcipiQFBLkH4qYkBEJ8pAAsLDQBBACABIAAgARCsHgsNAEEAIAEgACABENgpCxAAIABBgPz//wNxQYCwA0YLCgAgAUEYdCAAcgsMAEEAIAAQmixBCGoLDQAgACgCCCAAKAIYagsOACAAIAFB9KjOABCtFQsNACAAKAIQIAAoAhRrCw0AIAAgASACQQIQ7SALDQAgACABIAJBABC0GwsNACAAKAIEIAAoAgBrCw0AIAAoAhAgACgCBGoLDQAgACkDABogACgCCAsOACAAKAIAQThBBBD4OgsOACAAQbO++wBBNRDLGgsNACAAKAAAIAEoAABGCwsAIAAgASACEIggCwsAIAAgASACEKQaCwwAIAAgARCHJUEBcwsMACAAIAEQiCVBAXMLlgsBDn8gACEHIwBB8ABrIgQkACAEIAE2AiwgBEEgaiABQQhqIgkQwzQCQAJAAkACfwJAAkAgBCgCJCIIIAIoAggiAEYEQCADKAIAIgwNAiAIBEAgAigCBCIAKAIAIAAoAgQiBSgCCEEBa0F4cWpBCGogBSgCJBEEAAwECyAEQTBqQTZBAEEBQQEQoBggBCgCNCEDIAQoAjBBAUcNAQwGCyAEIAA2AlAgBEEYaiAJEMM0IAQgBCgCHDYCVCAEQQM2AjQgBEG4/oQBNgIwIARCAjcCPCAEQTs2AmQgBEE7NgJcIAQgBEHYAGo2AjggBCAEQdQAajYCYCAEIARB0ABqNgJYIAdBCGogBEEwahCZDgwDCyAEKAI4IgBB0P6EAUE2/AoAACAHQTY2AhAgByAANgIMIAcgAzYCCAwCCyACKAIEIQAgAygCBAshESAEQRBqIAkQry4gBCgCECEGIAQgBCgCFDYCNCAEIAY2AjACQCAEQTBqEJ42IgUgCCAFIAhJGyINBEAgACEFA0AgBigCAC0ASEUEQCAFKAIAIAVBBGooAgAiCigCCEEBa0F4cWpBCGogCigCRBEEAA0DCyAGQQRqIQYgBUEIaiEFIA1BAWsiDQ0ACwsgACAIQQN0IgVqIRAgACEGAkADQCAFRQ0BIAVBCGshBSAGKAIEIQ4gBigCACAGQQhqIQYgDigCCEEBa0F4cWpBCGogDigCJBEEACARRg0ACyAEQTBqQT9BNyAMGyIFQQBBAUEBEKAYIAQoAjQhAyAEKAIwQQFGDQQgBCgCOCEAIAUEQCAAQe/8hAFBuPyEASAMGyAF/AoAAAsgByAFNgIQIAcgADYCDCAHIAM2AggMAgsgAy0ACCEFIARBCGogCRDDNCAEKAIMIQMgBCAEKAIIIgo2AlggBCAKIANBAnRqIgM2AlwgBEHYAGoiDxCeNiEGIARBADYCQCAEIAM2AjwgBCAKNgI4IAQgEDYCNCAEIAA2AjAgBCAGIAggBiAISRs2AkQgBEEANgJIQeoaQesaIAUbIRAgBEHIAGohDCMAQRBrIgskAAJAAkAgBEEwaiIIKAIQIgYgCCgCFCIKSQRAIAgoAgAgBkEDdGohCSAIKAIIIAZBAnRqIQ0gDCgCACEFA0AgCCAGQQFqIgY2AhAgCSgCACAJQQRqKAIAIgAoAghBAWtBeHFqQQhqIAAoAhwRBAAhACALIA0oAgBBMGo2AgwgCyAANgIIIAsgBTYCBAJAIAtBBGogEBEEAEUEQCAMIAVBAWo2AgAMAQsgCygCDCEDIAsoAgghDiALKAIEIQAgDCAFQQFqNgIAIA4NAwsgCUEIaiEJIA1BBGohDSAFQQFqIQUgBiAKRw0ACwsgD0EANgIEDAELIA8gAzYCCCAPIA42AgQgDyAANgIACyALQRBqJAAgBCgCXCIDBEAgBCgCYCEAIAQgBCgCWDYCTCAEIAM2AlAgBCAANgJUIARBAzYCXCAEQaD8hAE2AlggBEIDNwJkIARBOzYCRCAEQa8DNgI8IARBrwM2AjQgBCAINgJgIAQgBEHMAGo2AkAgBCAEQdAAajYCOCAEIARB1ABqNgIwIAdBCGogDxCZDgwCCyAHIBE2AhQgByABNgIQIAdBADYCACAHQQxqIAJBCGooAgA2AgAgByACKQIANwIEDAILIAYoAgAhACAEQYQBNgJcIARBAjYCNCAEQez9hAE2AjAgBEIBNwI8IAQgAEE8ajYCVCAEIARB1ABqNgJYIAQgBEHYAGo2AjggB0EIaiAEQTBqEJkOCyAHQoGAgIDQgYCAgH83AgAgAhDDJyACQQRBCBDgHiABIAEoAgAiAEEBazYCACAAQQFHDQAgBEEsahD4IwwACyAEQfAAaiQADwsgAyAEKAI4Qfz2hAEQ/S8ACwkAIABBBBDuKAsMACAAIAEQkSVBAXMLDQAgACgCACgCIEEEdgsMACAAIAEQkyVBAXMLDAAgACABEJIlQQFzCwwAIAAgARCUJUEBcwsMACAAIAEQlSVBAXMLDAAgACABEJYlQQFzCwwAIAAgARCXJUEBcwsMACAAIAEQmyVBAXMLDAAgACABEJolQQFzCw4AIAEgAiAAKAIAEQAACw0AIAMgASADIAMQxRILDQAgACABIAIgAxD1FAsPACAAKAIAKAIAIAEQrhALDQAgACABIAIgAxCwHwsNACAAIAEgAiADEL8jCw0AIAAgASACIAMQwS4LDQAgACgCACgCCEEBRgsNACAAKAIAKAIQQQFGCxIAIAAoAgAlASABKAIAJQEQFAsOACAAKAIAJQEQGEEARwsNACAAKAIAJQEgARAwCw0AIAAoAgAlAUEBEDMLngIBBH8CfyMAQSBrIgAkAAJAAkBB5O6KASgCAEUEQEHs7ooBKAIAIQFB7O6KAUEANgIAIAFFDQEgAREPACEBQeTuigEoAgAiAkUEQAJAIAJFDQBB6O6KASgCACIDQYQBSQ0AIAMQ8h8LQejuigEgATYCAEHk7ooBQQE2AgALIAAgATYCBCAAIAI2AgAgACAAKAIENgIMIAAgACgCACIBNgIIIAENAgsgAEEgaiQAQejuigEMAgsgAEEANgIYIABBATYCDCAAQaCsiAE2AgggAEIENwIQIABBCGpBqKyIARDvLAALIABBCGoiARD6LiAAQQA2AhggAEEBNgIMIABByKyIATYCCCAAQgQ3AhAgAUHQrIgBEO8sAAsoAgAQ9DoLDAAgACgCACABENI0CxwBAW8gACgCACUBQQAQXSEBEN8SIgAgASYBIAALDgAgACgCACUBEGpBAEcLDgAgACgCACUBEGtBAEcLDgAgACgCACUBEGxBAEcLDgAgACgCACUBEHVBAEcLDQAgACABIAIgAxD0LgsNACAAKAIAIAAoAgRqC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Hcj4oBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H8j4oBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0GwkIoBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywACw8AQf3uiQFBKyAAEJ8pAAtrAQF/IwBBMGsiAyQAIAMgADYCBCADIAE2AgAgA0EDNgIMIANBlJGKATYCCCADQgI3AhQgAyADQQRqrUKAgICAsAeENwMoIAMgA61CgICAgLAHhDcDICADIANBIGo2AhAgA0EIaiACEO8sAAuaAgIBfgJ/IAAoAgApAwAhAiMAQYABayIEJAACfwJAIAEoAggiAEGAgIAQcUUEQCAAQYCAgCBxDQEgAUEBQQFBACAEIAIgBEEUEO0QIgBqQRQgAGsQgQkMAgtBACEAA0AgACAEakH/AGogAqdBD3EiA0EwciADQdcAaiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJDAELQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJCyAEQYABaiQACxwCAW8BfxBmIQAQ3xIiASAAJgEgASUBIAEQ8h8LHAIBbwF/EGchABDfEiIBIAAmASABJQEgARDyHwsHACAAEN47Cw4AIAFBy9TCAEEFEPs1Cw4AIAFB69bCAEEIEPs1Cw4AIAFBs+rCAEEFEPs1Cw4AIAFB4+zCAEEIEPs1Cw4AIAFBmPrCAEEFEPs1C0YBAn8jAEEQayIBJAAgASAAQQhrIgA2AgwgAUEMaiICEM0bIAAgACgCACIAQQFrNgIAIABBAUYEQCACELYfCyABQRBqJAALRgECfyMAQRBrIgEkACABIABBCGsiADYCDCABQQxqIgIQyxsgACAAKAIAIgBBAWs2AgAgAEEBRgRAIAIQuB8LIAFBEGokAAtGAQJ/IwBBEGsiASQAIAEgAEEIayIANgIMIAFBDGoiAhDMGyAAIAAoAgAiAEEBazYCACAAQQFGBEAgAhC3HwsgAUEQaiQACwwAIAAoAgAgARCaGAsOACABQYeSwwBBBRD7NQsOACABQbiTwwBBCBD7NQsOACABQdijwwBBFBD7NQsOACABQZykwwBBChD7NQvZBQECfyAAKAIAIQIjAEEQayIAJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgAigCACICKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyAAIAJBBGo2AgwgAUGAwcwAQREgAEEMakHwwMwAENATDBILIAAgAkEEajYCDCABQaTBzABBDSAAQQxqQZTBzAAQ0BMMEQsgACACQQRqNgIMIAFBscHMAEEJIABBDGpB8MDMABDQEwwQCyAAIAJBBGo2AgwgAUG6wcwAQQsgAEEMakHwwMwAENATDA8LIAAgAkEEajYCDCABQcXBzABBCiAAQQxqQfDAzAAQ0BMMDgsgACACQQRqNgIMIAFBz8HMAEELIABBDGpB8MDMABDQEwwNCyAAIAJBBGo2AgwgAUHawcwAQQwgAEEMakHwwMwAENATDAwLIAFB5sHMAEEMEPs1DAsLIAAgAkEEajYCDCABQfLBzABBEiAAQQxqQfDAzAAQ0BMMCgsgACACQQRqNgIMIAFBhMLMAEEIIABBDGpB8MDMABDQEwwJCyAAIAJBBGo2AgwgAUGMwswAQQkgAEEMakHwwMwAENATDAgLIAAgAkEMajYCDCABQbjCzABBByACQZjCzAAgAEEMakGowswAEIMPDAcLIAAgAkEEajYCDCABQb/CzABBCCAAQQxqQfDAzAAQ0BMMBgsgACACQQRqNgIMIAFBx8LMAEEUIABBDGpB8MDMABDQEwwFCyAAIAJBBGo2AgwgAUHbwswAQQwgAEEMakHwwMwAENATDAQLIAAgAkEEajYCDCABQefCzABBDiAAQQxqQfDAzAAQ0BMMAwsgAUH1wswAQRoQ+zUMAgsgAUGPw8wAQRgQ+zUMAQsgACACQQRqNgIMIAFBuMPMAEETIABBDGpBqMPMABDQEwsgAEEQaiQAC+UCAQF/IAAoAgAhAiMAQRBrIgAkAAJ/AkACQAJAAkACQAJAAkACQCACKAIAIgIoAgBBAWsOBwECAwQFBgcACyAAIAJBBGo2AgwgAUGgtMMAQQcgAEEMakGQtMMAENATDAcLIAAgAkEEajYCDCABQae0wwBBAyAAQQxqQZC0wwAQ0BMMBgsgACACQQRqNgIMIAFBqrTDAEEDIABBDGpBkLTDABDQEwwFCyAAIAJBBGo2AgwgAUGttMMAQQogAEEMakGQtMMAENATDAQLIAAgAkEIajYCDCABQdi0wwBBDyACQQRqQbi0wwAgAEEMakHItMMAEIMPDAMLIAAgAkEEajYCDCABQfi0wwBBCCAAQQxqQei0wwAQ0BMMAgsgACACQQRqNgIMIAFBgLXDAEEMIABBDGpByLTDABDQEwwBCyAAIAJBCGo2AgwgAUGctcMAQREgAEEMakGMtcMAENATCyAAQRBqJAALDgAgAUGfssMAQQUQ+zULDgAgAUGItMMAQQgQ+zULDgAgAUH+tcMAQQgQ+zULDgAgAUGcy8MAQRYQ+zULDgAgAUHI38MAQQUQ+zULZwEBfyAAKAIAIQIjAEEQayIAJAAgACACLwEAOwEOAn8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgAEEOaiABEJwSDAILIABBDmogARC3HAwBCyAAQQ5qIAEQtBwLIABBEGokAAujCgEDfyAAKAIAIQAjAEFAaiIDJAAgAyAALwEAOwEmAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAvAQAiBEGPA00EQCAEQeEBTQRAAkAgBEHIAWsOCQYHCAkKCwwNDgALIARB5ABrDgMCAwRACyAEQawCaw4JDg8QERITPxQVDQsCQCAEQZADaw40FhcYGRobHB0eHyAhIiMkJSYnKD8/KSorLC0uPy8wPzE/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/MgALIARB9ANrDgwyMzQ1Njc4OTo+Ozw+C0HA/MMAIQJBCCEADD0LQcj8wwAhAkETIQAMPAtB2/zDACECQQohAAw7C0Hl/MMAIQJBAiEADDoLQef8wwAhAkEHIQAMOQtB7vzDACECQQghAAw4C0H2/MMAIQJBHSEADDcLQZP9wwAhAkEKIQAMNgtBnf3DACECQQ0hAAw1C0Gq/cMAIQJBDyEADDQLQbn9wwAhAkEMIQAMMwtBxf3DACECQRAhAAwyCyAEQeIBRw0xQdX9wwAhAkEHIQAMMQtB3P3DACECQRAhAAwwC0Hs/cMAIQJBESEADC8LQf39wwAhAkEFIQAMLgtBgv7DACECQQkhAAwtC0GL/sMAIQJBDCEADCwLQZf+wwAhAkEJIQAMKwtBoP7DACECQRIhAAwqC0Gy/sMAIQJBEiEADCkLQcT+wwAhAkELIQAMKAtBz/7DACECQQwhAAwnC0Hb/sMAIQJBECEADCYLQev+wwAhAkEJIQAMJQtB9P7DACECQQkhAAwkC0H9/sMAIQJBEiEADCMLQY//wwAhAkEOIQAMIgtBnf/DACECQR0hAAwhC0G6/8MAIQJBDyEADCALQcn/wwAhAkEIIQAMHwtB0f/DACECQQQhAAweC0HV/8MAIQJBDyEADB0LQeT/wwAhAkETIQAMHAtB9//DACECQREhAAwbC0GIgMQAIQJBDCEADBoLQZSAxAAhAkEWIQAMGQtBqoDEACECQRUhAAwYC0G/gMQAIQJBEiEADBcLQdGAxAAhAkEMIQAMFgtB3YDEACECQRMhAAwVC0HwgMQAIQJBFCEADBQLQYSBxAAhAkEGIQAMEwtBioHEACECQREhAAwSC0GbgcQAIQJBCSEADBELQaSBxAAhAkEQIQAMEAtBtIHEACECQRUhAAwPC0HJgcQAIQJBESEADA4LQdqBxAAMDAtB+YHEACECQR0hAAwMC0GWgsQAIQJBFSEADAsLQauCxAAhAkEPIQAMCgtBuoLEACECQQshAAwJC0HFgsQAIQJBEyEADAgLQdiCxAAhAkEPIQAMBwtB54LEACECQRohAAwGC0GBg8QAIQJBFyEADAULQZiDxAAhAkEUIQAMBAtBrIPEACECQQ0hAAwDC0G5g8QAIQJBDCEADAILQcWDxAALIQJBHyEACyADIAA2AgQgAyACNgIAIAMgAygCBEEVIAMoAgAiABs2AiwgAyAAQbT4wwAgABs2AiggA0ECNgIQIANBzPjDADYCDCADQgI3AhggA0HHAjYCPCADQcgCNgI0IAMgA0EwajYCFCADIANBKGo2AjggAyADQSZqNgIwIAEoAgAgASgCBCADQQxqEMsKIANBQGskAAsOACABQcPnwwBBCRD7NQsOACABQazrwwBBExD7NQsOACABQb/rwwBBGRD7NQsdAQFvIABBEGooAgAlARARIQEQ3xIiACABJgEgAAsOACABQc3xwwBBGBD7NQsOACABQffxwwBBHBD7NQsOACABQZPywwBBIRD7NQsLACAAQQRBNBDgHgsOACABQdr2wwBBEBD7NQsMACAAIAEpAgA3AwALDgAgAUGh+MMAQRMQ+zULDgAgAUHt+MMAQRMQ+zULDgAgAUH3hMQAQQUQ+zULDgAgAEGwm8QAIAEQywoLDAAgACABKQIENwMACwgAIAAoAgAaCwsAIABBAUEBEOAeC4gBAQF/IAAoAgAhAiMAQTBrIgAkACAAIAIoAgAiAjYCGCAAIAJoNgIcIABBAzYCBCAAQZTtiQE2AgAgAEICNwIMIAAgAEEcaq1CgICAgJDjA4Q3AyggACAAQRhqrUKAgICAoOMDhDcDICAAIABBIGo2AgggASgCACABKAIEIAAQywogAEEwaiQACwsAIABBBEEUEOAeCw4AIAFBoMXMAEEFEPs1Cw4AIAFBmMbMAEEFEPs1CwwAIAAgASgCABD3IwsOACABQd+7zQBBCxD7NQsMACAAIAEpAmQ3AwALRwEBfyABKAIARQRAQbz8zgAQsjsACyAAIAEgASgCMCIDIAIgAiADSxtBARCzFiICNgIEIABBCDYCACABIAEoAjAgAms2AjALgQIBBH8CQCMAQRBrIgMkAAJAIAEoAiAEQAJAIAEoAjAiBCACIAIgBEsbIgJBDGwiBSABKAIoIAEoAjQiBmtNBEAgACACNgIEIABBCDYCACABIAQgAms2AjAgASAFIAZqNgI0DAELIANBBGpBGEEAQQFBARCgGCADKAIIIQIgAygCBEEBRg0CIAMoAgwiAUEQakG0iM4AKQAANwAAIAFBCGpBrIjOACkAADcAACABQaSIzgApAAA3AAAgAEEYNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyADQRBqJAAMAgtB5IfOAEEgQZSIzgAQyyQACyACIAMoAgxBnIfOABD9LwALCwsAIABBBEEMEOAeCwsAIABBBEEEEOAeCwsAIABBBEEIEOAeCwsAIABBAUEAEOAeCwwAIABBCEHAABDgHgsLACAAQQhBEBDgHgsLACAAQQRBEBDgHgsMACAAQQhB0AAQ4B4LCwAgAEEEQSAQ4B4LDAAgAEEEQeAAEOAeCwsAIABBBEEYEOAeCwwAIABBCEHAAhDgHgsMACAAQQhBuAUQ4B4LCwAgAEEIQRgQ4B4LCgAgACgCCEEFdAvwAQECfyAAKAIAIQMjAEEQayIAJAAgA0EEaiECAn8CQAJAAkACQAJAAkACQAJAIAMoAgBBAWsOBwECAwQFBgcACyABQdj3zgBBDBD7NQwHCyABQeT3zgBBBhD7NQwGCyAAIAI2AgQgAUHq984AQQQgAEEEakHgiM8AENATDAULIAFB7vfOAEEDEPs1DAQLIAAgAjYCCCABQfH3zgBBBiAAQQhqQfCIzwAQ0BMMAwsgAUH3984AQQMQ+zUMAgsgACACNgIMIAFB+vfOAEEEIABBDGpBgInPABDQEwwBCyABQf73zgBBBxD7NQsgAEEQaiQACwwAIAAoAgAgARDTGwsOACABQcyZzwBBCxD7NQsOACABQZChzwBBCxD7NQsKACAAKAIYQQhqCwoAIABBDGoQ2zwLCgAgAEEMahDYPAsKACAAQQxqENk8CwoAIABBDGoQ2jwLCgAgAEEMahDcPAsOACABQaue0ABBDBD7NQsOACABQbee0ABBDBD7NQsOACABQaCe0ABBCxD7NQsMACAAIAEpAlQ3AwALCgAgACgCLEEIagsMACAAIAEpAiQ3AwALCwAgACgCvAJBCGoLDgAgAUH4odAAQQIQ1gkLDgAgAUHLo9AAQQ4Q+zULDgAgAUHZo9AAQQsQ+zULDAAgACgCACABEPwYCwcAIAAQnTwLDgBBnOLQAEEKIAEQ3AcLeAECfyAAKAIAIQAjAEEQayIBJAACQCAARQ0AIAAoAsgFDQACQCAAIAAoApgETwRAIAAoApwEIQIgABCvICAAIAJPDQEMAgsgABCvIAsgAUEIaiAAQcAFaigCADYCACABIAApArgFNwMAIAAgARCLLQsgAUEQaiQAC/gBAQV/IAAoAgAhACMAQSBrIgEkAAJAIABFDQAgACgCkOsBDQAgAUEYaiICIABBhOsBaigCADYCACABIAApAvzqATcDECAAEPwwIAAoArjrASABQQhqIAIoAgA2AgAgASABKQMQNwMAIAEQiy0gAEEANgK46wEgASgCFCECIAAoAqjrASIDBEAgASgCGCEEAkACQAJAAkAgAygCACIFBEAgAkUNAiAEIAUgAhEAAAwBCyACRQ0CCyAEIAMgAhEAAAwCCyAFENI1CyADENI1CyAAQQA2AqjrAQsgAgRAIAEoAhggACACEQAADAELIAAQ0jULIAFBIGokAAsLACAAIAFBAxCmJAsMACAAKAIAIAEQ1g4LDAAgACgCACABEJc+Cw4AIAFB4MzRAEEOEPs1CwwAIAAoAgAgARD8KAsPACABQeDK0QBB4AAQ+zULDgAgAUHGneIAQQIQ1gkLDAAgACgCACABELI2C2cBAX8gACgCACECIwBBEGsiACQAIAAgAigCBDYCCCAAIAIoAgAiAjYCBAJ/IAIEQCAAIABBBGo2AgwgAUGovfsAQQQgAEEMakGYvfsAENATDAELIAFBlL37AEEEEPs1CyAAQRBqJAALDgAgAUH0wfsAQQIQ1gkLzQECA38BfiAAKAIAIQIjAEGAAWsiBCQAAkAgASkCCCIFpyIAQYCAgARxRQ0AIABBgICAwABxBEAgAEGAgIAIciEADAELIAFBCjsBDCAAQYCAgMgAciEACyABIABBgICABHI2AghBACEAA0AgACAEakH/AGogAkEPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFB4POJAUECIAAgBGpBgAFqQQAgAGsQgQkgASAFNwIIIARBgAFqJAALDgAgAUGr9PwAQQsQ+zULDAAgACgCACABEJovCwsAIABBAkECEOAeCw4AIABBuKj+ACABEMsKCw4AIAFB6Kn+AEEFEPs1Cw4AIAFBnMn+AEELEPs1C2gBAX8gACgCACECIwBBMGsiACQAIAAgAjYCDCAAQQE2AhQgAEH4zocBNgIQIABCATcCHCAAQekcNgIsIAAgAEEoajYCGCAAIABBDGo2AiggASgCACABKAIEIABBEGoQywogAEEwaiQACw4AIAFB4P7+AEELEPs1CwoAIABBDGooAggLDgAgAUG8kP8AQQsQ+zULDgAgAUGAyf8AQQsQ+zULDgAgAUGo+/8AQQsQ+zULDgAgAUGYmIABQQsQ+zULDgAgAEHEwYABIAEQywoLDgAgAEHcwYABIAEQywoLDgAgAUHAuIABQQUQ+zULDgAgAUHI5YABQQsQ+zULCgAgAEEQahC8KgsMACAAIAEoAgAQ+TQLDgAgAUGX+YABQQUQ+zULDAAgACgCACABELYcCw4AIAFB3PyBAUELEPs1Cw4AIAFBqLOCAUELEPs1Cw4AIAFB8MiCAUEFEPs1Cw4AIAFBmMmCAUELEPs1CwwAIAAgASgCABDDLQsOACABQcCCgwFBCxD7NQsOACABQbyzgwFBCxD7NQsOACABQbz1gwFBCxD7NQsOACABQaj5gwFBCxD7NQsMACAAIAEoAgAQxC0LDAAgACgCACABEMUtCwwAIAAoAgAgARDGLQsOACABQaOBhAFBCxD7NQsKACAAKAIUQQV2CwoAIAAoAhRBBHYLCgAgACgCFEECdgsKACAAKAIUQQN2CwoAIAAoAhRBAXYLCgAgACgCFEEESQsKACAAKAIUQRBJCwoAIAAoAhRBCEkLCgAgACgCFEEgSQsKACAAKAIUQQJJCwoAIAAQvSxBMGoLDgAgAUGQ6YQBQQsQ+zULCgAgACgCIEECdgsKACAAKAIgQQN2CwoAIAAoAiBBAXYLCgAgACgCIEEESQsKACAAKAIgQQhJCwoAIAAoAiBBAkkLDgAgAUHw9oQBQQsQ+zULDgAgAUHMvYUBQQUQ+zULCwAgAEHcAGoQ9DULCgAgACgCIEEEdgsKACAAKAIgQRBJCwoAIAAQ7x9BPGoLCgAgACgCHEEISQsKACAAKAIcQRBJCwoAIAAoAkhBCEkLCgAgACgCCEEDdgsKACAAKAIIQQF2CwoAIAAoAghBBHYLCgAgACgCCEECdgsKACAAKAIIQQV2C1cBAn8gACgCACECIwBBIGsiACQAIABBDGoiAyABQYDmhQFBDBDGLCAAIAIoAgQ2AhggACACKAIIQQJ2NgIcIAMgAEEYakGM5oUBEOQUENsbIABBIGokAAsKACAAQRhqEPQ1CwwAIAAoAgAgARCzNgsOACABQYfuhQFBCxD7NQsKACAAEL8sQSxqCw4AIAFB+P+FAUELEPs1CwsAIABBCEEIEOAeCwsAIABBEEEwEOAeCwsAIABBEEEgEOAeCwsAIABBEEEQEOAeCwoAIAAQsSpBPGoLCgAgACgCKEECdgsKACAAKAIoQQN2CwoAIAAoAihBBEkLCgAgACgCKEEISQsKACAAEL0sQThqCwoAIAAoAgBBAEcLDgAgAEHMv4YBIAEQywoLDAAgACABKQIQNwMACwwAIAAoAgAgARDdFAsOACABQY6PhwFBCxD7NQujAgECfyAAKAIAIQIjAEEQayIAJAACfwJAAkACQAJAAkBBAiACKAIAIgIoAgAiA0H/////B2ogA0GAgICAeE0bQQFrDgQBAgMEAAsgACACQQRqNgIMIAFBxJ2HAUEGIAJBDGpBpJ2HASAAQQxqQbSdhwEQgw8MBAsgACACQQhqNgIMIAFB3J2HAUEEIAJBBGpBpJ2HASAAQQxqQcydhwEQgw8MAwsgACACNgIMIAFB8J2HAUEGIAJBDGpBpJ2HASAAQQxqQeCdhwEQgw8MAgsgACACQQhqNgIMIAFB9p2HAUEKIAJBBGpBpJ2HASAAQQxqQcydhwEQgw8MAQsgACACQQRqNgIMIAFBkJ6HAUEFIABBDGpBgJ6HARDQEwsgAEEQaiQACw4AIAFBjKaHAUELEPs1CwwAIABBBEHMARDgHgsMACAAQQRBxAAQ4B4LDAAgACgCACABEPYGCwwAIAAoAgAgARCuEAsOACABQfzbhwFBBRD7NQvCCAILfwF+IAAoAgAhAiMAQTBrIgQkACABKAIAQd7xiQFBASABKAIEKAIMEQYAIQMgBEEIaiIAQQE6AAcgAEEAOwAFIAAgAzoABCAAIAE2AgAgBCACKAIMNgIoIAQgAigCACIBNgIgIAQgAUEIajYCGCAEIAEgAigCBGpBAWo2AhwgBCABKQMAQn+FQoCBgoSIkKDAgH+DNwMQAn8jAEEQayIGJAAgBEEQaiIBKAIYIggEQCABKQMAIQ0gASgCCCEHIAEoAhAhBQNAIA1QBEADQCAFQcABayEFIAcpAwAgB0EIaiEHQoCBgoSIkKDAgH+DIg1CgIGChIiQoMCAf1ENAAsgDUKAgYKEiJCgwIB/hSENCyAGIAUgDXqnQQN2QWhsaiIBQRhrNgIIIAYgAUEMazYCDCAGQQhqIQkgBkEMaiEKIwBBMGsiASQAAn8jAEEwayICJABBASELAkAgAC0ABA0AAkACQCAALQAGRQRAIAAtAAUhDCAAKAIAIgMtAApBgAFxRQRAIAxBAXFFDQIgAygCAEHP8YkBQQIgAygCBCgCDBEGAEUNAgwECyAMQQFxRQRAIAMoAgBB3fGJAUEBIAMoAgQoAgwRBgANBAsgAEEBOgAHIAIgAEEHajYCLCACQbDxiQE2AhAgAiADKQIANwIkIAIgAykCCDcCFCACIAJBJGo2AgwgCSACQQxqQYzehwEoAgARAgANAyACKAIMQZzxiQFBAiACKAIQKAIMEQYADQMMAgsgAkEANgIcIAJBATYCECACQajyiQE2AgwgAkIENwIUIAJBDGpBsPKJARDvLAALIAkgA0GM3ocBKAIAEQIADQEgAygCAEGc8YkBQQIgAygCBCgCDBEGAA0BCyAAQQE6AAZBACELCyAAIAs6AAQgAkEwaiQAQQEgAC0ABA0AGgJAAkACQCAALQAGBEAgACgCACICLQAKQYABcUUEQEEBIAogAkGM3ocBKAIAEQIADQUaDAQLIAEgAEEHajYCLCABQbDxiQE2AhAgASACKQIANwIkIAEgAikCCDcCFCABIAFBJGo2AgwgCiABQQxqQYzehwEoAgARAgBFDQEMAgsgAUEANgIcIAFBATYCECABQfDyiQE2AgwgAUIENwIUIAFBDGpB+PKJARDvLAALIAEoAgxB1PGJAUECIAEoAhAoAgwRBgBFDQELQQEMAQsgAEEAOgAGQQALIQIgAEEBOgAFIAAgAjoABCABQTBqJAAgDUIBfSANgyENIAhBAWsiCA0ACwsgBkEQaiQAIwBBIGsiASQAQQEhBQJAIAAtAARFBEAgAC0ABg0BIAAoAgAiAigCAEHW8YkBQQEgAigCBCgCDBEGACEFCyAAIAU6AAQgAUEgaiQAIAUMAQsgAUEANgIYIAFBATYCDCABQbjziQE2AgggAUIENwIQIAFBCGpBwPOJARDvLAALIARBMGokAAsMACAAKAIAIAEQzBkLYQECfyAAKAIAIQMjAEEgayIAJAAgAEEMaiICIAFBAUEAEMYsIAAgAzYCGCAAIANBBGo2AhwgAiAAQRhqQajghwEQ5BQaIAIgAEEcakG44IcBEOQUGiACENsbIABBIGokAAsOACABQZThhwFBCxD7NQsMACAAKAIAIAEQ9wYLDAAgACgCACABEMEYCwwAIAAoAgAgARCeJQsMACAAKAIAIAEQzCQLDAAgACgCACABEMUVCw4AIABB/OyHASABEMsKCw4AIAFB/O2HAUEFEPs1CwwAIAAoAgAgARCBDQsOACABQdv0hwFBCxD7NQsMACAAIAEpAgg3AwALDAAgACgCACABEJo8Cw4AIAFB6PqHAUELEPs1Cw4AIAFB3PyHAUELEPs1CwoAIAAoAgBBEGoLCwAgACABIAIQ/RQLDgAgAUHo/4cBQQsQ+zULDgAgAUGzhYgBQQsQ+zULlAEBAn8CQCMAQRBrIgEkACABQQRqIANBAEEBQQEQoBggASgCCCEEIAEoAgRBAUcEQCABKAIMIQUgAwRAIAUgAiAD/AoAAAsgACAENgIIIAAgAzYCBCAAIAU2AgAgAEEHQSAgBEEKdmdrIgAgAEEHTxtBAnRBAXI2AgwgAUEQaiQADAELIAQgASgCDEGUiIgBEP0vAAsLCwAgACgCACUBEBoLGgEBbyAAKAIAJQEQGyEBEN8SIgAgASYBIAALGgEBbyAAKAIAJQEQHyEBEN8SIgAgASYBIAALDQAgACgCACUBIAEQLwsXAQFvIAAgARBOIQIQ3xIiACACJgEgAAsaAQFvIAAoAgAlARBaIQEQ3xIiACABJgEgAAsXAQFvIAAgARBcIQIQ3xIiACACJgEgAAsKACAAKAIAEJw+CwkAIAAgARB0AAsNAEHTrYgBQRsQlz0ACw4AQe6tiAFBzwAQlz0ACw4AIABB0MWIASABEMsKCw4AIABBpKWJASABEMsKCw4AIABBsKiJASABEMsKCw4AIABB4KiJASABEMsKCw4AIABByKiJASABEMsKCw4AIAFBnMCJAUECENYJCw4AIABB9MCJASABEMsKCw4AIAFB5MCJAUEFEPs1Cw4AIAFB6cCJAUELEPs1CxoAIAAgAUGA8IoBKAIAIgBB8x0gABsRAAAACw4AIAFBtOyJAUEvENYJCw4AIAFByO2JAUEgENYJCw4AIAFB6O2JAUEYENYJCw4AIABBsPGJASABEMsKCw4AIABB/PWJASABEMsKCwsAIAIgACABENYJCwwAIAAoAgAgARDTEAsJACAAQQA2AgALCQAgAEIANwIACw4AIAFBxqeJAUEFEPs1CwkAIAAgARDoEwsJACAAIAEQ8xULCQAgACABEL8uCwcAQQEgAHQLCgAgAEGAgIB4cgsOACABQbyliQFBCBD7NQsJACAAIAEQ3RsLCQAgACABEPg9CwgAIAAoAhhFCwcAIABBDGoLCAAgACgCMEULCQAgACABEPE9CwkAIAAgARDwPQsJACAAIAEQhj4LCQAgACABEO89CwkAIAAgARD+PQsJACAAIAEQ+T0LCAAgAEGgA2oLCAAgAEGYA2oLCQAgACABEPc9CwkAIAAgARD8PQsIACAAKAIARQsJACAAIAEQmi8LCQAgACABEPY9CwkAIAAgARCCPgsHACAAQTRqCwgAIABB0AJqCwoAIAAoAgAQyjwLCgAgACgCABDLPAsKACAAKAIAEMk8CwoAIAAoAgAoAiALCQAgAEEINgIACwkAIAAgARCEPgsJACAAIAEQ8j0LCQAgACABEK4aCwkAIAAgARCpIAsIACAAQYh/SwuYBgIIfgN/QsXP2bLx5brqJyECIAEiCkEgTwRAIAAgAWpBH2shAUL56tDQ58mh5OEAIQJC1uuC7ur9ifXgACEEQs/W077Sx6vZQiEFA0AgACkAAELP1tO+0ser2UJ+IAR8Qh+JIgZCh5Wvr5i23puef34hBCAAQRhqKQAAQs/W077Sx6vZQn4gAnxCH4kiB0KHla+vmLbem55/fiECIABBEGopAABCz9bTvtLHq9lCfiADfEIfiSIIQoeVr6+Ytt6bnn9+IQMgAEEIaikAAELP1tO+0ser2UJ+IAV8Qh+JIglCh5Wvr5i23puef34hBSAAQSBqIgAgAUkNAAsgBUIHiSAEQgGJfCADQgyJfCACQhKJfCAGQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAlCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCEKp2eX7kODW+V5+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAHQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQILIApBGHEhDCAKQR9xIQEgAiAKrXwhAiAAIQsDQCABQQhPBEAgAUEIayEBIAspAABCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAChUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSECIAtBCGohCwwBCwsgACAMaiEBIApBB3EiAEEETwRAIABBBGshACABNQAAQoeVr6+Ytt6bnn9+IAKFQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGohAQsDQCAABEAgAEEBayEAIAExAABCxc/ZsvHluuonfiAChUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwsgAkIhiCAChULP1tO+0ser2UJ+IgJCHYggAoVC+fPd8Zn2masWfiICQiCIIAKFCwgAIABB/wFxCwkAIAAgARCIPgsJACAAIAEQ9T0LCQAgACABEPM9CwkAIAAgARD7PQsJACAAIAEQ/z0LCQAgACABEIM+CwkAIAAgARCFPgsJACAAIAEQ7j0LCQAgACABEPQ9CwoAIAAoAgAQ1DoLCgAgACgCABDTOgsJACAAIAEQgT4LCQAgACABEP09CwkAIAAgARD6PQsJACAAIAEQ1QkLCgAgACgCABD4LQsKACAAKAIAEPotCwoAIAAoAgAQ+S0LCgAgACgCABD8LQsKACAAKAIAEPstCwoAIAAoAgAQ9C0LCgAgACgCABD3LQsKACAAKAIAEPYtCwoAIAAoAgAQ9S0LCgAgACgCABDzLQsJACAAIAEQmRQLCQAgACABEOQVCwkAIAAgARCaFQsJACAAIAEQmxULCQAgACABEOsPCwkAIAAgARDjFQsJACAAIAEQmBQLCQAgACABEOIVCwkAIAAgARD2EQsJACAAIAEQvRULCQAgACABEO8XCwkAIAAgARCcFQsJACAAIAEQ+gwLCQAgACABEOAVCwkAIAAgARCtFgsJACAAIAEQ/AwLCQAgACABEJ0VCwkAIAAgARDoEgsJACAAIAEQ4Q4LCQAgACABEPsMCwkAIAAgARCDEwsJACAAIAEQ5xILCQAgACABEOwPCwkAIAAgARDhFQsJACAAIAEQnhULCQAgACABEOAOCwkAIAAgARDtDQsIACAAKAIURQsIACAAKAIgRQsIACAAKAIQRQsKACAAKAIAKAIwC70FAQl/IwBB0ABrIgIkACABQRhqIQMCQAJAAkACQAJAIAAtABgiBEEhRwRAIARBJ0YNAQwCCyADLQAAQSFHDQFBACEDIAAoAhxBCGogACgCICABKAIcQQhqIAEoAiAQnTtFDQQgAC0AGSABLQAZRg0CDAQLIAMtAABBJ0cNAAJAAkACQAJAAkAgACgCHCIDLQAwQSBHDQAgASgCHCIELQAwQSBHDQAgAkEwaiADQTRqIgMQwzQgAigCNEECRw0AIAJBKGogBEE0aiIFEMM0IAIoAixBAkcNACACQSBqIAMQwzQgAigCJEUNASACKAIgIQYgAkEYaiAFEMM0IAIoAhxFDQIgAigCGCEHIAJBEGogAxDDNCACKAIUIgNBAU0NAyACKAIQIQQgAkEIaiAFEMM0IAIoAgwiA0EBTQ0EIAIoAgghBUEBIQhBASEJIAYoAgBBMGogBygCAEEwahDLCARAIAQoAgRBMGogBSgCBEEwahDLCEEBcyEJCyAHKAIAIgNBCGohByAGKAIAIgZBCGogBi0ASCADLQBIRgRAIAQoAgQtAEggBSgCBC0ASEchCAtBACEDIAcQ5QxFDQggBCgCBEEIaiAFKAIEQQhqEOUMRSAIIAlycg0IIAAtABkgAS0AGUcNCAwGCyACQQA2AkggAkEBNgI8IAJBhMKHATYCOCACQgQ3AkAgAkE4akGMwocBEO8sAAtBAEEAQZDBhwEQwyEAC0EAQQBBoMGHARDDIQALQQEgA0GwwYcBEMMhAAtBASADQcDBhwEQwyEACyAAQRhqIAMQywhFDQELIAAoAiQiBCABKAIkRw0AQQAhAyAAKAJAQQAgACgCLBsgASgCQEEAIAEoAiwbRw0BIAAgAUEAQQAgBBD1BkUNASAAIAFBAEEAIAQQ3gchAwwBC0EAIQMLIAJB0ABqJAAgAwsIACAAKAIERQsKACAAKAIAEJQtCwoAIAAoAgAQwywLCwAgACgCACUBECULCwAgACgCACUBECwLCQAgACABEJI1CxcBAW8gACABEGghAhDfEiIAIAImASAACwkAIAEgABCHLgsHACAAIAFrC8wDAQJ/An8jAEEgayICJAACQAJAAkACQAJAAkAgAC0AAEEBaw4DAQIDAAsgAiAAKAIENgIEIAJBCGoiACABQcWxiQFBAhCWLSAAQdixiQFBBCACQQRqQcixiQEQiBIgAkEpOgATQeyxiQFBBCACQRNqQdyxiQEQiBJBFEEBEK02IgBFDQQgAEEQakH0uokBKAAANgAAIABBCGpB7LqJASkAADcAACAAQeS6iQEpAAA3AAAgAkEUNgIcIAIgADYCGCACQRQ2AhRBgLKJAUEHIAJBFGpB8LGJARCIEhDEISEAIAIoAhQiAUUNAyACKAIYIAFBARD4OgwDCyACIAAtAAE6AAggAkEUaiIAIAFBh7KJAUEEEMYsIAAgAkEIakHcsYkBEOQUENsbIQAMAgsgACgCBCEAIAJBFGoiAyABQYuyiQFBBRCWLSADQeyxiQFBBCAAQQhqQdyxiQEQiBJBgLKJAUEHIABBkLKJARCIEhDEISEADAELIAIgACgCBCIANgIUIAFBsLKJAUEGQeyxiQFBBCAAQQhqQdyxiQFBtrKJAUEFIAJBFGpBoLKJARCOGCEACyACQSBqJAAgAAwBC0EBQRRB+KiJARD9LwALCwcAIAAgAWoLBwAgAEEIagsHACAAQQhrC04BAX8jAEEwayIBJAAgAUEBNgIMIAFBwO2JATYCCCABQgE3AhQgASABQS9qrUKAgICAsOMDhDcDICABIAFBIGo2AhAgAUEIaiAAEO8sAAsIACAAJQEQVwsHACAAKAIYCwcAIAAoAjALBwAgABCVDAsHACAAKAIACwcAIAAQgS8LRgEBfyAAKAIgIgEEQCAAQSxqIAAoAiQgACgCKCABKAIQEQEACyAAKAIAIgEEQCAAQQxqIAAoAgQgACgCCCABKAIQEQEACwsHACAAEJEqCwcAIAAoAkwLBwAgACgCQAsHACAAKAJQCwcAIAAoAjgLBwAgACgCCAsHACAAELwqCwcAIAAoAhQLBwAgACgCIAsHACAAKAIcCwcAIAAoAhALBwAgACgCDAsVAgFvAX8QQyEAEN8SIgEgACYBIAELAgALBAAgAAsEAEEACwcAQZy8zQALBwBByLzNAAsEAEEICwQAQQILBABBBAsEAEEFCwQAQQYLBABBBwsEAEEACwcAQbzJ/wALBwBBxPv/AAsHAEHY/YEBCwcAQdTJggELBwBBjIODAQsEAEIACwcAQfiOhAELBwBB5JaEAQsEAEEACwQAQQELBwBB0O+FAQsHAEGkqYYBCwIACwIACwIACwIACwIACwvhtEacKgBBgIDAAAuByQJpbnZhbGlkIGxpdGVyYWwvbGVuZ3RocyBzZXQAaW52YWxpZCBjb2RlIGxlbmd0aHMgc2V0AHVua25vd24gaGVhZGVyIGZsYWdzIHNldABpbnZhbGlkIGRpc3RhbmNlcyBzZXQAaW52YWxpZCBiaXQgbGVuZ3RoIHJlcGVhdAAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL21hcC9lbnRyeS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV9hcnJheV9kaWN0aW9uYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2VxdWFsL2RpY3Rpb25hcnkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9kaWN0aW9uYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9maXhlZF9iaW5hcnkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvZml4ZWRfYmluYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29udGV4dF9tYXBfZW50cm9weS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvZW1wdHlfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2RpY3Rpb25hcnlfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2ZpeGVkX3NpemVfYmluYXJ5X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9saXN0X3ZpZXdfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2J5dGVfdmlld19hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV92aWV3X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9maXhlZF9zaXplX2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L3N0cnVjdF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvc3RydWN0X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9tYXBfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL21hcF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvcnVuX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS91bmlvbl9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvYm9vbGVhbl9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvbnVsbF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvcHJpbWl0aXZlX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9wcmltaXRpdmVfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL2ZpeGVkX2xlbl9ieXRlX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2RlY29kZXIvZGVsdGFfYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd193cml0ZXIvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9kaXNwbGF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL2dlbmVyYWxfcHVycG9zZS9kZWNvZGVfc3VmZml4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9jb21wbGV4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2RlY29kZXIvZGljdGlvbmFyeV9pbmRleC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9maWxlL3BhZ2VfaW5kZXgvb2Zmc2V0X2luZGV4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvcGFnZV9pbmRleC9pbmRleC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc2xpY2UvaW5kZXgucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9ib3Jyb3cucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9zbG93LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbGV4aWNhbC1wYXJzZS1mbG9hdC0xLjAuNi9zcmMvc2xvdy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2luZmxhdGUvd2luZG93LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS93aW5kb3cucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvYnl0ZV92aWV3LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYmlnaW50L2Rpdi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL3N0cmF0ZWd5L2dyaXN1LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9ieXRlc19tdXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J1Zi9idWZfbXV0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdXJsLTIuNS43L3NyYy9ob3N0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvYml0X2Nvc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9saXRlcmFsX2Nvc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL2ZpeGVkX3NpemVfbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9maXhlZF9saXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctY2FzdC01Ni4yLjAvc3JjL2Nhc3QvbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9saXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy93YXNtL3JlcXVlc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9mYXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9jYXN0LnJzAGxpYnJhcnkvY29yZS9zcmMvc2xpY2Uvc29ydC9zaGFyZWQvc21hbGxzb3J0LnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9zbGljZS9zb3J0L3Vuc3RhYmxlL3F1aWNrc29ydC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc2xpY2Uvc29ydC9zdGFibGUvcXVpY2tzb3J0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvc3RyZWFtL2Z1dHVyZXNfdW5vcmRlcmVkL2Fib3J0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9jb252ZXJ0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlnaW50L2NvbnZlcnQucnMAbGlicmFyeS9hbGxvYy9zcmMvYm94ZWQvY29udmVydC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWlwYy01Ni4yLjAvc3JjL2NvbnZlcnQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLWNoYW5uZWwtMC4zLjMxL3NyYy9vbmVzaG90LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ludGVnZXItZW5jb2RpbmctMy4wLjQvc3JjL3ZhcmludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2xleGljYWwtcGFyc2UtZmxvYXQtMS4wLjYvc3JjL2JpZ2ludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2NvbXByZXNzX2ZyYWdtZW50LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy93YXNtL2NsaWVudC5ycwBsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvdGhyaWZ0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9zaGlmdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ2ludC9zaGlmdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL2J1ZmZlci9vZmZzZXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9pcl9pbnRlcnByZXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9zdGF0aWNfZGljdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Z1dHVyZXMtdXRpbC0wLjMuMzEvc3JjL3N0cmVhbS90cnlfc3RyZWFtL3RyeV9jb2xsZWN0LnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL2luX3BsYWNlX2NvbGxlY3QucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0ZXIvdHJhaXRzL2NvbGxlY3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi90aHJpZnQtMC4xNy4wL3NyYy9wcm90b2NvbC9jb21wYWN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29tcGF0LnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2RpeV9mbG9hdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9mb3JtYXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9jb25jYXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9udW0taW50ZWdlci0wLjEuNDYvc3JjL3Jvb3RzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29uc3RhbnRzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbHo0X2ZsZXgtMC4xMS41L3NyYy9mcmFtZS9kZWNvbXByZXNzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc25hcC0xLjEuMS9zcmMvZGVjb21wcmVzcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvYmxvY2svY29tcHJlc3MucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9zbmFwLTEuMS4xL3NyYy9jb21wcmVzcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2NvbXByZXNzX2ZyYWdtZW50X3R3b19wYXNzLnJzAGxpYnJhcnkvY29yZS9zcmMvZm10L2J1aWxkZXJzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL29wcy5ycwBzcmMvcmVhZF9vcHRpb25zLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9zdGQvc3JjL2lvL2ltcGxzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfY29yZS0xLjAuMjI4L3NyYy9kZS9pbXBscy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vdXRpbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvdXRpbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvcmVjb3JkX3JlYWRlci9kZWZpbml0aW9uX2xldmVscy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvbGV2ZWxzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2Fycm93X3dyaXRlci9sZXZlbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9uYWl2ZS9pbnRlcm5hbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy9wcmltaXRpdmVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc25hcC0xLjEuMS9zcmMvYnl0ZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J5dGVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnl0ZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL3R5cGVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL3NjaGVtYS90eXBlcy5ycwBzcmMvd3JpdGVyX3Byb3BlcnRpZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9wcm9wZXJ0aWVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvaW5mbGF0ZS9pbmZ0cmVlcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIuMTA0L3NyYy9jb252ZXJ0L3NsaWNlcy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvY2hhci9tZXRob2RzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2NoZW1hLTU2LjIuMC9zcmMvZmllbGRzLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9zdGQvc3JjL3N5cy9zeW5jL211dGV4L25vX3RocmVhZHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9zdGF0aXN0aWNzLnJzAGxpYnJhcnkvYWxsb2Mvc3JjL2ZmaS9jX3N0ci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N0ci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvcHRyL2NvbnN0X3B0ci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRidWZmZXJzLTI1LjkuMjMvc3JjL3ZlY3Rvci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL3V0aWwvYml0X2l0ZXJhdG9yLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvdXRpbC9iaXRfY2h1bmtfaXRlcmF0b3IucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0ZXIvdHJhaXRzL2l0ZXJhdG9yLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfanNvbi0xLjAuMTQ1L3NyYy9lcnJvci5ycwBsaWJyYXJ5L2NvcmUvc3JjL3NsaWNlL21lbWNoci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2Jsb2NrX3NwbGl0dGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY2x1c3Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNlbGVjdC01Ni4yLjAvc3JjL2ZpbHRlci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9pby9idWZmZXJlZC9idWZ3cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy92dGFibGVfd3JpdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvenN0ZC0wLjEzLjAvc3JjL3N0cmVhbS96aW8vd3JpdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvaW5mbGF0ZS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbnRlZ2VyLWVuY29kaW5nLTMuMC40L3NyYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1pcGMtNTYuMi4wL3NyYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9tZXRhZGF0YS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL3NsaWNlL2l0ZXIucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9ib3hlZC9pdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdXJsLTIuNS43L3NyYy9wYXJzZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLWNvcmUtMC4zLjMxL3NyYy90YXNrL19faW50ZXJuYWwvYXRvbWljX3dha2VyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGJ1ZmZlcnMtMjUuOS4yMy9zcmMvdmVyaWZpZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYnVmZmVyL2RpY3Rpb25hcnlfYnVmZmVyLnJzAGxpYnJhcnkvY29yZS9zcmMvbmV0L2Rpc3BsYXlfYnVmZmVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2J1ZmZlci92aWV3X2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9idWZmZXIvb2Zmc2V0X2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9yZWNvcmRfcmVhZGVyL2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZW5jb2RpbmcvYnl0ZV9zdHJlYW1fc3BsaXRfZW5jb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZW5jb2RpbmcvZGljdF9lbmNvZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2NvbHVtbi93cml0ZXIvZW5jb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZGVjb2RpbmcvYnl0ZV9zdHJlYW1fc3BsaXRfZGVjb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vcmVhZGVyL2RlY29kZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZml4ZWRfc2l6ZV9iaW5hcnlfZGljdGlvbmFyeV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL2dlbmVyaWNfYnl0ZXNfZGljdGlvbmFyeV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL2ZpeGVkX3NpemVfYmluYXJ5X2J1aWxkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZ2VuZXJpY19ieXRlc192aWV3X2J1aWxkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZ2VuZXJpY19ieXRlc19idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL3ByaW1pdGl2ZV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGJ1ZmZlcnMtMjUuOS4yMy9zcmMvYnVpbGRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvYnVmcmVhZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9jYWNoZWRfYXJyYXlfcmVhZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvc2VyaWFsaXplZF9yZWFkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvY29sdW1uL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ludGVnZXItZW5jb2RpbmctMy4wLjQvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWlwYy01Ni4yLjAvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS1kZWNvbXByZXNzb3ItNS4wLjAvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9maWxlL21ldGFkYXRhL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvZnJhbWUvaGVhZGVyLnJzAGxpYnJhcnkvY29yZS9zcmMvbmV0L2lwX2FkZHIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy9lbmRpYW5fc2NhbGFyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL3NjYWxhci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2JhY2t3YXJkX3JlZmVyZW5jZXMvaHEucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9odHRwLTEuMy4xL3NyYy9oZWFkZXIvbWFwLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvZnV0dXJlL2Z1dHVyZS9tYXAucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0ZTItMS4xLjIvc3JjL3ppby5ycwBsaWJyYXJ5L3N0ZC9zcmMvaW8vc3RkaW8ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWZmZXIvcnVuLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9ydW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvcnVuLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9zdHIvcGF0dGVybi5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvb3B0aW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9hZGRpdGlvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvc2VsZWN0aW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9zdWJ0cmFjdGlvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ3VpbnQvbXVsdGlwbGljYXRpb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvY29tcHJlc3Npb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1pcGMtNTYuMi4wL3NyYy9jb21wcmVzc2lvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ3VpbnQvZGl2aXNpb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL3VuaW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2VxdWFsL3VuaW9uLnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvc3RyYXRlZ3kvZHJhZ29uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy90cnVzdGVkX2xlbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvcmVhZF9wbGFuLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWlsZGVyL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvYm9vbGVhbi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9iaWdudW0ucnMAbGlicmFyeS9jb3JlL3NyYy9mbXQvbnVtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS9hbGdvcml0aG0vbWVkaXVtLnJzAHNyYy93YXNtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLWRlY29tcHJlc3Nvci01LjAuMC9zcmMvdHJhbnNmb3JtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvenN0ZC1zeXMtMi4wLjkrenN0ZC4xLjUuNS9zcmMvd2FzbV9zaGltLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGUyLTEuMS4yL3NyYy9tZW0ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9oaXN0b2dyYW0ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9icm90bGlfYml0X3N0cmVhbS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JhbmdlLXJlYWRlci0wLjIuMC9zcmMvc3RyZWFtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy9pbnRvX3VybC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL2J1ZmZlci9udWxsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVpbGRlci9udWxsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdG9raW8tMS40Ny4xL3NyYy9pby91dGlsL3dyaXRlX2FsbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9idWZmZXIvYml0X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvdXRpbC9iaXRfdXRpbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL3V0aWwvYml0X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy91dGY4X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9vYmplY3Rfc3RvcmUtMC4xMi40L3NyYy91dGlsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvcHJpb3JfZXZhbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL3N0cmlkZV9ldmFsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbGV4aWNhbC1wYXJzZS1mbG9hdC0xLjAuNi9zcmMvdGFibGVfZGVjaW1hbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9jYXN0L2RlY2ltYWwucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvdXRpbC9iaXRfbWFzay5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvd3JpdGFibGUvaW50b191bmRlcmx5aW5nX3NpbmsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sejRfZmxleC0wLjExLjUvc3JjL3NpbmsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLXV0aWwtMC4zLjMxL3NyYy9zdHJlYW0vc3RyZWFtL3BlZWsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9tZXRhYmxvY2sucnMAbGlicmFyeS9zdGQvc3JjL3N5bmMvcmVlbnRyYW50X2xvY2sucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9xdWljay5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy91dGlsL2JpdF9wYWNrLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2ZmaS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNjaGVtYS01Ni4yLjAvc3JjL2ZmaS5ycwBzcmMvY29tbW9uL2ZldGNoLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS9sb25nZXN0X21hdGNoLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9yZWNvcmRfYmF0Y2gucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9mb3JtYXQvZm9ybWF0dGluZy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9jYXN0L3N0cmluZy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZGVjb2RpbmcucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL3BlbmRpbmcucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL3N5bV9idWYucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2lvL2JvcnJvd2VkX2J1Zi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vcmVhZF9idWYucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9odWZmLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDQvc3JjL2V4dGVybnJlZi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vdmFyaWFibGVfc2l6ZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC92YXJpYWJsZV9zaXplLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9wcmltaXRpdmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvcHJpbWl0aXZlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9wcmltaXRpdmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9pbnRlcmxlYXZlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLWZ1dHVyZXMtMC40LjU0L3NyYy9xdWV1ZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvZ3ovd3JpdGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9pbmZsYXRlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL25hdmlnYXRlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvYWxsb2NhdGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sZXhpY2FsLXBhcnNlLWZsb2F0LTEuMC42L3NyYy9wYXJzZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9wYXJzZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JlcXdlc3QtMC4xMi4yMy9zcmMvd2FzbS9yZXNwb25zZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9zdHJ1Y3R1cmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sZXhpY2FsLXBhcnNlLWZsb2F0LTEuMC42L3NyYy9sZW1pcmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZGF0YV90eXBlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy90aW1lem9uZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvY2xvbmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jcmMzMmZhc3QtMS41LjAvc3JjL2Jhc2VsaW5lLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvY2hyb25vLTAuNC40Mi9zcmMvZm9ybWF0L3N0cmZ0aW1lLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2VuY29kaW5ncy9ybGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9ybGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy92dGFibGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWZmZXIvaW1tdXRhYmxlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL211dGFibGUucnMAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvYmxvY2svaGFzaHRhYmxlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9naXQvY2hlY2tvdXRzL2Fycm93LXdhc20tMGM4M2Y1NmFlOWE5M2I4Ni82ZGE5NGVmL3NyYy90YWJsZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vdXRpbC90YWtlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2VsZWN0LTU2LjIuMC9zcmMvdGFrZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ljdV9jb2xsZWN0aW9ucy0yLjAuMC9zcmMvY29kZXBvaW50dHJpZS9jcHRyaWUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL3Jvd19ncm91cF9jYWNoZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vcGFnZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2JhY2t3YXJkX3JlZmVyZW5jZXMvaGFzaF90b19iaW5hcnlfdHJlZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL25vZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pZG5hLTEuMS4wL3NyYy9wdW55Y29kZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2VudHJvcHlfZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL2dlbmVyYWxfcHVycG9zZS9kZWNvZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktZGVjb21wcmVzc29yLTUuMC4wL3NyYy9kZWNvZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9maW5kX3N0cmlkZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvcmVhZGFibGUvaW50b191bmRlcmx5aW5nX3NvdXJjZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvcmVhZGFibGUvaW50b191bmRlcmx5aW5nX2J5dGVfc291cmNlLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAL3J1c3RjLzExNTllNzhjNDc0N2IwMmVmOTk2ZTU1MDgyYjcwNGMwOWI5NzA1ODgvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9pbnRlcmZhY2UucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0ZTItMS4xLjIvc3JjL2d6L21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L21vZC5ycwAvcnVzdC9kZXBzL2hhc2hicm93bi0wLjE1LjQvc3JjL3Jhdy9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9oYXNoYnJvd24tMC4xNi4wL3NyYy9yYXcvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctY2FzdC01Ni4yLjAvc3JjL2Nhc3QvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYmlnaW50L21vZC5ycwBsaWJyYXJ5L2NvcmUvc3JjL2ZtdC9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9iYWNrd2FyZF9yZWZlcmVuY2VzL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc3RyL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvcHRyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9ibG9vbV9maWx0ZXIvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2Fycm93X3dyaXRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXN5bmNfd3JpdGVyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vd3JpdGVyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLWRlY29tcHJlc3Nvci01LjAuMC9zcmMvYml0X3JlYWRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvcmVjb3JkX3JlYWRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXN5bmNfcmVhZGVyL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2JpbmFyeV9oZWFwL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9pby9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktZGVjb21wcmVzc29yLTUuMC4wL3NyYy9odWZmbWFuL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvbnVtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JlcXdlc3QtMC4xMi4yMy9zcmMvd2FzbS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvYWxnb3JpdGhtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3RocmlmdC0wLjE3LjAvc3JjL3Byb3RvY29sL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZW5jb2RpbmdzL2VuY29kaW5nL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL3ZlY19kZXF1ZS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9uYWl2ZS9kYXRlL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jhc2U2NC0wLjIyLjEvc3JjL2VuZ2luZS9nZW5lcmFsX3B1cnBvc2UvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Nocm9uby0wLjQuNDIvc3JjL25haXZlL2RhdGV0aW1lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Nocm9uby0wLjQuNDIvc3JjL2RhdGV0aW1lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvZnJhbWUvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvc3RyZWFtL2Z1dHVyZXNfdW5vcmRlcmVkL21vZC5ycwBsaWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3plcm92ZWMtMC4xMS40L3NyYy96ZXJvdmVjL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAC9ydXN0Yy8xMTU5ZTc4YzQ3NDdiMDJlZjk5NmU1NTA4MmI3MDRjMDliOTcwNTg4L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL21vZC5ycwAvcnVzdGMvMTE1OWU3OGM0NzQ3YjAyZWY5OTZlNTUwODJiNzA0YzA5Yjk3MDU4OC9saWJyYXJ5L2FsbG9jL3NyYy92ZWMvbW9kLnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvbWV0YWRhdGEvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9odHRwLTEuMy4xL3NyYy9tZXRob2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi90b2tpby0xLjQ3LjEvc3JjL2lvL3V0aWwvcmVhZF90b19lbmQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9jb21tYW5kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2NoZW1hLTU2LjIuMC9zcmMvZmllbGQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9jcmMzMi9icmFpZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vdXRpbC92ZWNfd2l0aF9pbml0aWFsaXplZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2JveGVkLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVyX25lc3RlZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvYWxnb3JpdGhtL3N0b3JlZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vZ2l0L2NoZWNrb3V0cy9hcnJvdy13YXNtLTBjODNmNTZhZTlhOTNiODYvNmRhOTRlZi9zcmMvZmZpL2NodW5rZWQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLXV0aWwtMC4zLjMxL3NyYy9zaW5rL2ZlZWQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJpbmRnZW4tZnV0dXJlcy0wLjQuNTQvc3JjL3Rhc2svc2luZ2xldGhyZWFkLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfanNvbi0xLjAuMTQ1L3NyYy9yZWFkLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGUyLTEuMS4yL3NyYy9jcmMucnMAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIuMTAvc3JjL2RsbWFsbG9jLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYWxsb2Mtc3RkbGliLTAuMi4yL3NyYy9oZWFwX2FsbG9jLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYWxsb2Mtc3RkbGliLTAuMi4yL3NyYy9zdGRfYWxsb2MucnMAbGlicmFyeS9zdGQvc3JjL2FsbG9jLnJzAHNyYy93cml0ZXJfYXN5bmMucnMAc3JjL3JlYWRlcl9hc3luYy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N5bmMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2hhc2hfY2FsYy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9iYXNpYy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvZmZpL2MucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi91cmwtMi41Ljcvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLXdhc20tYmluZGdlbi0wLjYuNS9zcmMvbGliLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLWZ1dHVyZXMtMC40LjU0L3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9vbmNlX2NlbGwtMS4yMS4zL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wZXJjZW50LWVuY29kaW5nLTIuMy4yL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hc3luYy1jb21wYXQtMC4yLjIvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2pzLXN5cy0wLjMuODEvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NtYWxsdmVjLTEuMTUuMS9zcmMvbGliLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96c3RkLXNhZmUtNy4wLjAvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ljdV9ub3JtYWxpemVyLTIuMC4wL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hdG9pLTIuMC4wL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy90aW1lX2RlbHRhLnJzAGxpYnJhcnkvY29yZS9zcmMvdW5pY29kZS91bmljb2RlX2RhdGEucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZGF0YS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNjaGVtYS01Ni4yLjAvc3JjL3NjaGVtYS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvY29tcGFyZTI1Ni5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2lkbmEtMS4xLjAvc3JjL3V0czQ2LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvYWRsZXIzMi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3R3b3gtaGFzaC0yLjEuMi9zcmMveHhoYXNoMzIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9jcmMzMi5ycwB0b28gbWFueSBsZW5ndGggb3IgZGlzdGFuY2Ugc3ltYm9scwBpbnZhbGlkIHN0b3JlZCBibG9jayBsZW5ndGhzAGJ1ZmZlciBlcnJvcgBzdHJlYW0gZXJyb3IAaW52YWxpZCBjb2RlIC0tIG1pc3NpbmcgZW5kLW9mLWJsb2NrAGluY29ycmVjdCBoZWFkZXIgY2hlY2sAaW5jb3JyZWN0IGxlbmd0aCBjaGVjawBpbmNvcnJlY3QgZGF0YSBjaGVjawBpbnZhbGlkIGRpc3RhbmNlIHRvbyBmYXIgYmFjawBoZWFkZXIgY3JjIG1pc21hdGNoAGludmFsaWQgd2luZG93IHNpemUAcmVwZWF0ZWQgY2FsbCB3aXRoIGJhZCBzdGF0ZQBpbnZhbGlkIGJsb2NrIHR5cGUAaW52YWxpZCBsaXRlcmFsL2xlbmd0aCBjb2RlAGludmFsaWQgZGlzdGFuY2UgY29kZQB1bmtub3duIGNvbXByZXNzaW9uIG1ldGhvZABFcnJvciBzdHJpbmdzIHN0cmlwcGVkADEuMy4wLXpsaWItcnMtMC41LjEAIAAAAABwixAAfgAAADQAAAAFAAAA1zIQAHgAAADrBwAACQAAANAjEABdAAAA+w4AAAoAAADEShAAagAAAG0IAAAfAAAA2ocQAGgAAABdAwAAEQAAAL99EABtAAAA8gMAABsAAAC/fRAAbQAAAPQDAAAkAAAAv30QAG0AAAACBAAAKAAAAM51EABqAAAApwEAAB8AAADOdRAAagAAAL0BAAAdAAAAHRAQAHMAAAAZAAAAEQAAAI0tEAAYAAAAggAAAC8AAACNLRAAGAAAAIIAAAA/AAAAWHhIYXNoSW50VHlwZWJpdFdpZHRoaXNTaWduZWRNYXBUeXBlQWVzR2NtVjFhYWRfcHJlZml4YWFkX2ZpbGVfdW5pcXVlc3VwcGx5X2FhZF9wcmVmaXhCc29uVHlwZURhdGVUeXBlRW51bVR5cGVKc29uVHlwZUtleVZhbHVla2V5dmFsdWVMaXN0VHlwZU51bGxUeXBlUm93R3JvdXBjb2x1bW5zdG90YWxfYnl0ZV9zaXplbnVtX3Jvd3Nzb3J0aW5nX2NvbHVtbnNmaWxlX29mZnNldHRvdGFsX2NvbXByZXNzZWRfc2l6ZW9yZGluYWxUaW1lVHlwZWlzQWRqdXN0ZWRUb1VUQ3VuaXRUaW1lVW5pdE1JTExJU01JQ1JPU05BTk9TVVVJRFR5cGVTdGF0aXN0aWNzbWF4bWlubnVsbF9jb3VudGRpc3RpbmN0X2NvdW50bWF4X3ZhbHVlbWluX3ZhbHVlaXNfbWF4X3ZhbHVlX2V4YWN0aXNfbWluX3ZhbHVlX2V4YWN0U3RyaW5nVHlwZUFlc0djbUN0clYxQm91bmRpbmdCb3h4bWlueG1heHltaW55bWF4em1pbnptYXhtbWlubW1heENvbHVtbkNodW5rZmlsZV9wYXRobWV0YV9kYXRhb2Zmc2V0X2luZGV4X29mZnNldG9mZnNldF9pbmRleF9sZW5ndGhjb2x1bW5faW5kZXhfb2Zmc2V0Y29sdW1uX2luZGV4X2xlbmd0aGNyeXB0b19tZXRhZGF0YWVuY3J5cHRlZF9jb2x1bW5fbWV0YWRhdGFDb2x1bW5JbmRleG51bGxfcGFnZXNtaW5fdmFsdWVzbWF4X3ZhbHVlc2JvdW5kYXJ5X29yZGVybnVsbF9jb3VudHNyZXBldGl0aW9uX2xldmVsX2hpc3RvZ3JhbXNkZWZpbml0aW9uX2xldmVsX2hpc3RvZ3JhbXNDb2x1bW5PcmRlclRZUEVfT1JERVJEZWNpbWFsVHlwZXNjYWxlcHJlY2lzaW9uRmxvYXQxNlR5cGVMb2dpY2FsVHlwZVNUUklOR01BUExJU1RFTlVNREVDSU1BTERBVEVUSU1FVElNRVNUQU1QSU5URUdFUlVOS05PV05KU09OQlNPTlVVSURGTE9BVDE2VkFSSUFOVEdFT01FVFJZR0VPR1JBUEhZTmFub1NlY29uZHNPZmZzZXRJbmRleHBhZ2VfbG9jYXRpb25zdW5lbmNvZGVkX2J5dGVfYXJyYXlfZGF0YV9ieXRlc1ZhcmlhbnRUeXBlc3BlY2lmaWNhdGlvbl92ZXJzaW9uRmlsZU1ldGFEYXRhdmVyc2lvbnNjaGVtYXJvd19ncm91cHNrZXlfdmFsdWVfbWV0YWRhdGFjcmVhdGVkX2J5Y29sdW1uX29yZGVyc2VuY3J5cHRpb25fYWxnb3JpdGhtZm9vdGVyX3NpZ25pbmdfa2V5X21ldGFkYXRhR2VvbWV0cnlUeXBlY3JzTWljcm9TZWNvbmRzTWlsbGlTZWNvbmRzUGFnZUxvY2F0aW9ub2Zmc2V0Y29tcHJlc3NlZF9wYWdlX3NpemVmaXJzdF9yb3dfaW5kZXhVbmNvbXByZXNzZWRHZW9ncmFwaHlUeXBlYWxnb3JpdGhtU2NoZW1hRWxlbWVudHR5cGV0eXBlX2xlbmd0aHJlcGV0aXRpb25fdHlwZW5hbWVudW1fY2hpbGRyZW5jb252ZXJ0ZWRfdHlwZWZpZWxkX2lkbG9naWNhbFR5cGVTb3J0aW5nQ29sdW1uY29sdW1uX2lkeGRlc2NlbmRpbmdudWxsc19maXJzdFRpbWVzdGFtcFR5cGVDb2x1bW5NZXRhRGF0YWVuY29kaW5nc3BhdGhfaW5fc2NoZW1hY29kZWNudW1fdmFsdWVzdG90YWxfdW5jb21wcmVzc2VkX3NpemVkYXRhX3BhZ2Vfb2Zmc2V0aW5kZXhfcGFnZV9vZmZzZXRkaWN0aW9uYXJ5X3BhZ2Vfb2Zmc2V0c3RhdGlzdGljc2VuY29kaW5nX3N0YXRzYmxvb21fZmlsdGVyX29mZnNldGJsb29tX2ZpbHRlcl9sZW5ndGhzaXplX3N0YXRpc3RpY3NnZW9zcGF0aWFsX3N0YXRpc3RpY3NTaXplU3RhdGlzdGljc3JlcGV0aXRpb25fbGV2ZWxfaGlzdG9ncmFtZGVmaW5pdGlvbl9sZXZlbF9oaXN0b2dyYW1CbG9vbUZpbHRlckhhc2hYWEhBU0hUeXBlRGVmaW5lZE9yZGVyQmxvb21GaWx0ZXJIZWFkZXJudW1CeXRlc2hhc2hjb21wcmVzc2lvblBhZ2VFbmNvZGluZ1N0YXRzcGFnZV90eXBlZW5jb2Rpbmdjb3VudEVuY3J5cHRpb25BbGdvcml0aG1BRVNfR0NNX1YxQUVTX0dDTV9DVFJfVjFTcGxpdEJsb2NrQWxnb3JpdGhtQmxvb21GaWx0ZXJBbGdvcml0aG1CTE9DS0NvbHVtbkNyeXB0b01ldGFEYXRhRU5DUllQVElPTl9XSVRIX0ZPT1RFUl9LRVlFTkNSWVBUSU9OX1dJVEhfQ09MVU1OX0tFWUdlb3NwYXRpYWxTdGF0aXN0aWNzYmJveGdlb3NwYXRpYWxfdHlwZXNCbG9vbUZpbHRlckNvbXByZXNzaW9uVU5DT01QUkVTU0VERW5jcnlwdGlvbldpdGhDb2x1bW5LZXlrZXlfbWV0YWRhdGFFbmNyeXB0aW9uV2l0aEZvb3RlcktleWFscmVhZHkgbG9ja2VkIHRvIGEgcmVhZGVyAAEAAAC4AwAACAAAAAIAAAADAAAAQAMAAAgAAAAEAAAABQAAAJABAAAIAAAABgAAAAcAAAAIBQAACAAAAAgAAAAJAAAAoAAAAAgAAAAKAAAACwAAAMAAAAAIAAAADAAAAA0AAADwAgAACAAAAA4AAAAPAAAAXAAAAAQAAAAQAAAAAAAAAAQAAAAEAAAAEQAAABIAAAAAAAAABAAAAAQAAAATAAAAFAAAAAAAAAAEAAAABAAAABUAAAAWAAAAAAAAAAQAAAAEAAAAFwAAABgAAAAAAAAABAAAAAQAAAAZAAAAGgAAAAAAAAAEAAAABAAAABsAAAAcAAAAx5EQAGcAAADmAAAAFQAAAB0AAAAMAAAABAAAAB4AAAAfAAAAIABBjMnCAAuRAgEAAAAhAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXkfPiLTS+rALQ+04qby6pveHprAvv5ieL98GMLX7yHypwAAAAAAAAAAAQAAACIAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAACMAAAAkAAAAGAAAAAgAAAAlAAAAJgAAAAQAAAAEAAAAJwBBqMvCAAvZEwEAAAAoAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAB0AAAAMAAAABAAAACkAAAAdAAAADAAAAAQAAAAqAAAAKQAAAHCqEAArAAAALAAAAC0AAAAuAAAALwAAAAAAAAAEAAAABAAAADAAAABHZW5lcmFsTllJRU9GQXJyb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZQAAAMRKEABqAAAAbQgAAB8AAAAAAAAABAAAAAQAAAA0AAAAVHJ5RnJvbUludEVycm9yQ2FuY2VsZWQAv30QAG0AAADJAAAAFwAAAJp7EABtAAAABQEAADoAAACaexAAbQAAANkAAABGAAAAmnsQAG0AAAD4AAAAPAAAAJp7EABtAAAAGQEAADAAAAAkAAAAGAAAAAgAAAA1AAAAJAAAABgAAAAIAAAAJQAAADUAAADEqxAANgAAADcAAAA4AAAAOQAAADoAAACeHhAAYwAAAL0AAAA5AAAAdXJsIHBhcnNlaGVhZGVycyB0cnlfaXRlcmhlYWRlcnMgaGF2ZSBhbiBpdGVyYXRvcmhlYWRlcnMgaXRlcmF0b3IgZG9lc24ndCB0aHJvd3NlcmlhbGl6ZWQgaGVhZGVyc2Rlc2VyaWFsaXphYmxlIHNlcmlhbGl6ZWQgaGVhZGVyc0pzVmFsdWUoInJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQiKQAA8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADOdRAAagAAAL0BAAAdAAAALF4QABMAAAAIAAAAUAAAACxeEAATAAAACwAAAB4AAAAsXhAAEwAAAAsAAAAyAAAALF4QABMAAAAOAAAATwAAACxeEAATAAAAFAAAAB8AAAAsXhAAEwAAABAAAAARAAAALF4QABMAAAARAAAAOQAAACxeEAATAAAAEgAAACEAAABujxAAEwAAAPYBAAAoAAAAbo8QABMAAADzAQAAQgAAAEZhaWxlZCB0byBjcmVhdGUgVHJhbnNmb3JtU3RyZWFtWo8QABMAAAAMAAAAOgAAAFqPEAATAAAAPQAAAB4AAABajxAAEwAAAB0AAAAVAAAAbnVsbCBmaXJzdCBiYXRjaG6PEAATAAAAYwAAAEMAAABujxAAEwAAAF8AAAABAAAAbo8QABMAAAB1AAAATgAAAG6PEAATAAAAlQAAAFMAAABujxAAEwAAAJ4AAAA8AAAAbo8QABMAAAC2AAAAQgAAAG6PEAATAAAA0wAAABEAAABMUhAACwAAAPQAAAA+AAAATFIQAAsAAADvAAAAAQAAAExSEAALAAAARQEAAD4AAABMUhAACwAAAEABAAABAAAAPQAAAJgAAAAIAAAAPgAAAD8AAAAwAAAABAAAAEAAAABBAAAAcAEAAAgAAABCAAAAQwAAAJgAAAAIAAAARAAAAEUAAABIAAAACAAAAEYAAABHAAAAiAEAAAgAAABIAAAASQAAACAAAAAIAAAASgAAAPFXEABgAAAAcgAAAAEAAABLAAAAsAMAAAgAAABMAAAATQAAACgAAAAIAAAATgAAAE8AAABIAAAACAAAAFAAAABRAAAADAAAAAQAAABSAAAAUwAAACAAQYzfwgAL6QEBAAAAVAAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAANcyEAB4AAAA6wcAAAkAAAAemsC+/mJ4v3wYwtfvIfKnAAAAAAAAAAABAAAAVQAAAFYAAAAQAAAABAAAAFcAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAFgAAAAEAAAABAAAACcAAABZAAAABAAAAAQAAABaAAAAWwAAABgAAAAIAAAAXABBgOHCAAutGAEAAABdAAAAXgAAAAwAAAAEAAAAXwAAAGFjY2VwdGFjY2VwdC1jaGFyc2V0YWNjZXB0LWVuY29kaW5nYWNjZXB0LWxhbmd1YWdlYWNjZXB0LXJhbmdlc2FjY2Vzcy1jb250cm9sLWFsbG93LWNyZWRlbnRpYWxzYWNjZXNzLWNvbnRyb2wtYWxsb3ctaGVhZGVyc2FjY2Vzcy1jb250cm9sLWFsbG93LW1ldGhvZHNhY2Nlc3MtY29udHJvbC1hbGxvdy1vcmlnaW5hY2Nlc3MtY29udHJvbC1leHBvc2UtaGVhZGVyc2FjY2Vzcy1jb250cm9sLW1heC1hZ2VhY2Nlc3MtY29udHJvbC1yZXF1ZXN0LWhlYWRlcnNhY2Nlc3MtY29udHJvbC1yZXF1ZXN0LW1ldGhvZGFnZWFsbG93YWx0LXN2Y2F1dGhvcml6YXRpb25jYWNoZS1jb250cm9sY2FjaGUtc3RhdHVzY2RuLWNhY2hlLWNvbnRyb2xjb25uZWN0aW9uY29udGVudC1kaXNwb3NpdGlvbmNvbnRlbnQtZW5jb2Rpbmdjb250ZW50LWxhbmd1YWdlY29udGVudC1sZW5ndGhjb250ZW50LWxvY2F0aW9uY29udGVudC1yYW5nZWNvbnRlbnQtc2VjdXJpdHktcG9saWN5Y29udGVudC1zZWN1cml0eS1wb2xpY3ktcmVwb3J0LW9ubHljb250ZW50LXR5cGVjb29raWVkbnRkYXRlZXRhZ2V4cGVjdGV4cGlyZXNmb3J3YXJkZWRmcm9taG9zdGlmLW1hdGNoaWYtbW9kaWZpZWQtc2luY2VpZi1ub25lLW1hdGNoaWYtcmFuZ2VpZi11bm1vZGlmaWVkLXNpbmNlbGFzdC1tb2RpZmllZGxpbmtsb2NhdGlvbm1heC1mb3J3YXJkc29yaWdpbnByYWdtYXByb3h5LWF1dGhlbnRpY2F0ZXByb3h5LWF1dGhvcml6YXRpb25wdWJsaWMta2V5LXBpbnNwdWJsaWMta2V5LXBpbnMtcmVwb3J0LW9ubHlyYW5nZXJlZmVyZXJyZWZlcnJlci1wb2xpY3lyZWZyZXNocmV0cnktYWZ0ZXJzZWMtd2Vic29ja2V0LWFjY2VwdHNlYy13ZWJzb2NrZXQtZXh0ZW5zaW9uc3NlYy13ZWJzb2NrZXQta2V5c2VjLXdlYnNvY2tldC1wcm90b2NvbHNlYy13ZWJzb2NrZXQtdmVyc2lvbnNlcnZlcnNldC1jb29raWVzdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5dGV0cmFpbGVydHJhbnNmZXItZW5jb2Rpbmd1c2VyLWFnZW50dXBncmFkZXVwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHN2YXJ5dmlhd2FybmluZ3d3dy1hdXRoZW50aWNhdGV4LWNvbnRlbnQtdHlwZS1vcHRpb25zeC1kbnMtcHJlZmV0Y2gtY29udHJvbHgtZnJhbWUtb3B0aW9uc3gteHNzLXByb3RlY3Rpb25PUFRJT05TR0VUUE9TVFBVVERFTEVURUhFQURUUkFDRUNPTk5FQ1RQQVRDSEVycm9y4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAABRAAAADAAAAAQAAAApAAAAUQAAAAwAAAAEAAAAKgAAACkAAABYtRAAYAAAAGEAAAAtAAAALgAAAGIAAAAAAAAABAAAAAQAAAAwAAAAR2VuZXJhbE5ZSUVPRkFycm93RXJyb3IAAAAAAAQAAAAEAAAAYwAAAAAAAAAEAAAABAAAADEAAABJbmRleE91dE9mQm91bmQAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsTmVlZE1vcmVEYXRhAAAAAAQAAAAEAAAAMwAAAE5lZWRNb3JlRGF0YVJhbmdlAAAAbhEQAGsAAABYAAAADgAAAAAAAAAEAAAABAAAADQAAABUcnlGcm9tSW50RXJyb3JDYW5jZWxlZGZpbGUgc2l6ZSBvZiAgaXMgbGVzcyB0aGFuIGZvb3Rlcmu2EAANAAAAeLYQABQAAACrRRAAawAAAP4CAAA8AAAAZm9vdGVyIHNpemUgc2hvdWxkIG5ldmVyIGJlIGxhcmdlciB0aGFuIHUzMgCrRRAAawAAAA4DAAAOAAAAq0UQAGsAAAAYAwAAJwAAAG1ldGFkYXRhIGxlbmd0aCBzaG91bGQgbmV2ZXIgYmUgbGFyZ2VyIHRoYW4gdTMyAKtFEABrAAAALwMAABIAAACrRRAAawAAADADAAAgAAAAIGlzIGxlc3MgdGhhbiBmb290ZXIgKyBtZXRhZGF0YSBrthAADQAAAEi3EAAgAAAAbWV0YWRhdGEgcmVxdWlyZXMgIGJ5dGVzLCBidXQgY291bGQgb25seSByZWFkIAAAeLcQABIAAACKtxAAHAAAAKtFEABrAAAAtQEAACIAAACrRRAAawAAAOUBAAAVAAAAq0UQAGsAAAA8AwAAPAAAAKtFEABrAAAAZAMAACAAAAAIAAAAZm9vdGVyIG1ldGFkYXRhIHJlcXVpcmVzIAAAAPy3EAAZAAAAircQABwAAACrRRAAawAAAMQBAAAiAAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IHJlbWFpbmRlci5sZW4oKatFEABrAAAAEAIAABEAAABGb290ZXIgbWV0YWRhdGEgaXMgbm90IHByZXNlbnQAAKtFEABrAAAA/wEAABUAAACrRRAAawAAABgCAAAJAAAAq0UQAGsAAADOAQAAZAAAAJ4eEABjAAAAvQAAADkAAAB1cmwgcGFyc2VoZWFkZXJzIHRyeV9pdGVyaGVhZGVycyBoYXZlIGFuIGl0ZXJhdG9yaGVhZGVycyBpdGVyYXRvciBkb2Vzbid0IHRocm93c2VyaWFsaXplZCBoZWFkZXJzZGVzZXJpYWxpemFibGUgc2VyaWFsaXplZCBoZWFkZXJzSnNWYWx1ZSgicmVxd2VzdDo6ZXJyb3JzOjpUaW1lZE91dCIpAADyfxAAYAAAACIAAAABAAAAcHJvbWlzZSByZXNvbHZlZCB0byB1bmV4cGVjdGVkIHR5cGUAaBgQAGQAAAAAAgAAOAAAAOVoEABlAAAAdQAAADYAAADlaBAAZQAAAIIAAAAZAAAAznUQAGoAAAC9AQAAHQAAAG6PEAATAAAA5gAAAAkAAABujxAAEwAAAPIAAAAOAAAAbo8QABMAAAD+AAAAJQAAAG6PEAATAAAABgEAAAoAAABujxAAEwAAAA0BAAAhAAAAbo8QABMAAAAUAQAACQAAAG6PEAATAAAAFwEAADEAAABujxAAEwAAACMBAAAJAAAAbo8QABMAAABDAQAARQAAAG6PEAATAAAAVAEAABgAAABujxAAEwAAAEsBAAAsAAAAbo8QABMAAABMAQAAKgAAAG6PEAATAAAATgEAABIAAABujxAAEwAAAEgBAAAVAAAAbo8QABMAAABPAQAASAAAAG6PEAATAAAAUQEAACIAAABujxAAEwAAAHYBAAAJAAAAbo8QABMAAAB9AQAAJwAAAG6PEAATAAAAeQEAABkAAABujxAAEwAAAHsBAAAlAAAAbo8QABMAAACHAQAACQAAAG6PEAATAAAAlwEAAAkAAABujxAAEwAAAKYBAAAqAAAAbo8QABMAAAC0AQAAHwAAAFJhbmdlAAAAbo8QABMAAACoAQAAEQAAAG6PEAATAAAArgEAAA4AAABujxAAEwAAALABAAAOAAAAbo8QABMAAACxAQAAKAAAAG6PEAATAAAAsgEAABwAAABhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAbo8QABMAAADMAAAALwAAAGxvc3QgcmVhZGVyIGZhY3RvcnkAv30QAG0AAACfAwAAPQAAAGQAAABQAAAACAAAAGUAAABmAAAAeAEAAAgAAABnAAAAaAAAAIgBAAAIAAAAaQAAAGoAAAA4AAAABAAAAGsAAABsAAAAQAAAAAgAAABtAAAAbgAAANgBAAAIAAAAbwAAAHAAAAAMAAAABAAAAHEAAAByAAAAIABBuPnCAAuhCgEAAABzAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQAAAEVycm9yAAAA4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAAC/fRAAbQAAALEAAAAJAAAAv30QAG0AAACeAAAACQAAAL99EABtAAAAogAAAB4AAABleHBlY3RlZCB0byByZWFkICBieXRlcywgZ290IAAAAHC9EAARAAAAgb0QAAwAAADEShAAagAAAG0IAAAfAAAAq0UQAGsAAADlAQAAFQAAAKtFEABrAAAAPAMAADwAAACrRRAAawAAAGQDAAAgAAAACAAAAGZvb3RlciBtZXRhZGF0YSByZXF1aXJlcyAgYnl0ZXMsIGJ1dCBjb3VsZCBvbmx5IHJlYWQgAAAA5L0QABkAAAD9vRAAHAAAAG1ldGFkYXRhIHJlcXVpcmVzIAAALL4QABIAAAD9vRAAHAAAAKtFEABrAAAAxAEAACIAAABhc3NlcnRpb24gZmFpbGVkOiBlbmQgPD0gcmVtYWluZGVyLmxlbigpq0UQAGsAAAAQAgAAEQAAAEZvb3RlciBtZXRhZGF0YSBpcyBub3QgcHJlc2VudAAAq0UQAGsAAAD/AQAAFQAAAKtFEABrAAAAGAIAAAkAAAC/fRAAbQAAAFwAAAAeAAAAv30QAG0AAABbAAAACQAAAL99EABtAAAAYAAAABgAAAC/fRAAbQAAANwDAAAVAAAAv30QAG0AAAARBAAAJgAAAL99EABtAAAAEwQAADcAAAC/fRAAbQAAABMEAAAgAAAAv30QAG0AAABoAgAAHAAAAL99EABtAAAAUAIAABgAAAB0AAAAIAAAAAQAAAB1AAAAdgAAAL99EABtAAAAWQIAABcAAAC/fRAAbQAAAN4CAAAkAAAAv30QAG0AAADpAgAAJAAAAL99EABtAAAA6gIAACUAAAC/fRAAbQAAAOECAAAdAAAAv30QAG0AAACSAAAACQAAAL99EABtAAAAlAAAABsAAADOdRAAagAAAL0BAAAdAAAAZnV0dXJlIHN0aWxsIGhlcmUgd2hlbiBkcm9wcGluZ2Fzc2VydGlvbiBmYWlsZWQ6IHByZXYAAABAhRAAeAAAANoBAAANAAAAaW5jb25zaXN0ZW50IGluIGRyb3B3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAH8AAACAAAAAgQAAAIIAAABhc3NlcnRpb24gZmFpbGVkOiBzbG90LmlzX25vbmUoKZwcEABmAAAAggAAAA0AAADXMhAAeAAAAOsHAAAJAAAAYXJyb3dfc2NoZW1hdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAADEShAAagAAAG0IAAAfAAAA2ocQAGgAAABdAwAAEQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQAAAM51EABqAAAApwEAAB8AAADOdRAAagAAAK4BAAAmAAAAaW52YWxpZCBlbnVtIHZhbHVlIHBhc3NlZGF0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hpcCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZAAAAAABAAAAAgAAAAcAAAADAAAABAAAAAUAAAAGAEHkg8MACw0GAAAAAQAAAAAAAAABAEGAhMMAC6UDAQAAAAIAAAAEAAAABQAAAAYAAAAHAAAAAwAAAGJvb2wgZmllbGQgc2hvdWxkIGhhdmUgYSBmaWVsZCBpZAAAAOciEABmAAAA6gEAACsAAABzaG91bGQgaGF2ZSBwcmV2aW91cyBmaWVsZCBpZHMAAOciEABmAAAAxAEAAA4AAABzaG91bGQgbm90IGhhdmUgYSBwZW5kaW5nIGJvb2wgd2hpbGUgd3JpdGluZyBhbm90aGVyIGJvb2wgd2l0aCBpZDogAIDCEABDAAAA5yIQAGYAAADMAQAAFQAAAG5vbi1zdG9wIGZpZWxkIHNob3VsZCBoYXZlIGZpZWxkIGlkAOciEABmAAAA1wEAAC4AAADnIhAAZgAAALoBAAAjAAAAiAAAAMgDAAAIAAAAiQAAAO8nEABrAAAA4wEAAA4AAADvJxAAawAAAPgBAAAOAAAA/jQQAHgAAAB6AAAAIQAAAGZhaWxlZCB0byB3cml0ZSB0aGUgYnVmZmVyZWQgZGF0YQAAAGDDEAAhAAAAFwAAAIoAAAAMAAAABAAAAIsAAACMAAAAIABBsIfDAAvdHQEAAACNAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAAHprAvv5ieL98GMLX7yHypwAAAAAAAAAAAQAAAI4AAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAI8AAAAEAAAABAAAACcAAACQAAAADAAAAAQAAABfAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAIoAAAAMAAAABAAAACkAAACKAAAADAAAAAQAAAAqAAAAKQAAACzJEACRAAAAkgAAAC0AAAAuAAAAkwAAAMRKEABqAAAAbQgAAB8AAABwZW5kaW5nIGJvb2wgZmllbGQgIG5vdCB3cml0dGVuAHjJEAATAAAAi8kQAAwAAADnIhAAZgAAAKEBAAANAAAAQ2FuY2VsZWRDb3VsZCBub3Qgd3JpdGUgYmxvb20gZmlsdGVyIGJpdCBzZXQ6IAAAwMkQACYAAABDb3VsZCBub3Qgd3JpdGUgYmxvb20gZmlsdGVyIGhlYWRlcjogAAAA8MkQACUAAACeHhAAYwAAAL0AAAA5AAAAdXJsIHBhcnNlaGVhZGVycyB0cnlfaXRlcmhlYWRlcnMgaGF2ZSBhbiBpdGVyYXRvcmhlYWRlcnMgaXRlcmF0b3IgZG9lc24ndCB0aHJvd3NlcmlhbGl6ZWQgaGVhZGVyc2Rlc2VyaWFsaXphYmxlIHNlcmlhbGl6ZWQgaGVhZGVyc0pzVmFsdWUoInJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQiKQAA8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADlaBAAZQAAAHUAAAA2AAAA5WgQAGUAAACCAAAAGQAAAM51EABqAAAAvQEAAB0AAABQZWVrIHBvbGxlZCBhZnRlciBjb21wbGV0aW9uolsQAG4AAAAKAQAADQAAAGJ5dGVzPS0AeMsQAAYAAAB+yxAAAQAAAGJ5dGVzPS0AkMsQAAcAAABSYW5nZQAAACxeEAATAAAALQAAACYAAAAsXhAAEwAAAD0AAAAfAAAALF4QABMAAABDAAAAHwAAACxeEAATAAAAPwAAABEAAAAsXhAAEwAAAEAAAABJAAAALF4QABMAAABBAAAAIQAAAIoAAAAMAAAABAAAAJQAAACVAAAAlQAAACxeEAATAAAAUgAAABcAAACWAAAAQAAAAAgAAACXAAAALF4QABMAAABVAAAALwAAACxeEAATAAAAVAAAABIAAABFbXB0eSBpbnB1dCBwcm92aWRlZCBvciBub3QgYSBVaW50OEFycmF5LkNvbHVtbiAgbm90IGZvdW5kIGluIHRhYmxlAInMEAAHAAAAkMwQABMAAABIVFRQIGVycm9yOiBgYAAAtMwQAA0AAADBzBAAAQAAAFBsYXRmb3JtIGVycm9yOiBgAAAA1MwQABEAAADBzBAAAQAAAER5biBjYXN0aW5nIGVycm9yAAAAdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAACYAAAAGAAAAAgAAACZAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQCaAAAAEAAAAAQAAACbAAAAQXJjIGNvdW50ZXIgb3ZlcmZsb3d4zRAAFAAAAIKPEABpAAAA2AYAAA0AAACCjxAAaQAAABQMAAANAAAAAAAAAAQAAAAEAAAAMAAAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAJwAAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZQAAAMRKEABqAAAAbQgAAB8AAACdAAAABAAAAAQAAACeAAAAAAAAAAIAAAACAAAAnwAAAAAAAAAEAAAABAAAAKAAAABDb2x1bW5EZXNjcmlwdG9ycHJpbWl0aXZlX3R5cGVtYXhfZGVmX2xldmVsbWF4X3JlcF9sZXZlbHBhdGg1OBAAawAAAGQAAAAuAAAANTgQAGsAAABkAAAASwAAADU4EABrAAAARgAAAC4AAAA1OBAAawAAAEYAAABLAAAAqHcQAGAAAAAkAQAAGAAAAKh3EABgAAAAJgEAABEAAAAAAAAABAAAAAQAAAChAAAAAAAAAAQAAAAEAAAAogAAAFBhcnF1ZXRFcnJvclVua25vd25Db2x1bW4AAAAAAAAABAAAAAQAAACjAAAASFRUUEVycm9yUGxhdGZvcm1TdXBwb3J0RXJyb3IAAAAAAAAABAAAAAQAAACkAAAARHluQ2FzdGluZ0Vycm9yAG6PEAATAAAAxgAAABIAAABujxAAEwAAAMgAAAAdAAAAbo8QABMAAADTAAAAEQAAAExSEAALAAAA+AAAAC8AAABxfBAAbQAAAKUDAAAWAAAA8VcQAGAAAAB/AAAALAAAAPFXEABgAAAAgAAAACcAAADXMhAAeAAAAOsHAAAJAAAAk4oQAHEAAABbAAAAEgAAAJOKEABxAAAAYgAAAAkAAACTihAAcQAAAEAAAAANAAAAZmlsbGVkIG11c3Qgbm90IGJlY29tZSBsYXJnZXIgdGhhbiBpbml0aWFsaXplZAAAbNAQAC4AAAD4YRAAYAAAAIoAAAAWAAAA+GEQAGAAAABBAAAAHgAAAGZpbGxlZCBvdmVyZmxvdwDQIxAAXQAAAPsOAAAKAAAAz4kQAGEAAAAvAAAAEQAAAMRKEABqAAAAbQgAAB8AAADahxAAaAAAAF0DAAARAAAA2ocQAGgAAACwAAAAEQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWUAAAAAbxAAYQAAAF0AAAAJAAAAAG8QAGEAAABlAAAADQAAAJ1FEAANAAAAbwAAABoAAACdRRAADQAAAHsAAAAaAAAAnUUQAA0AAAB1AAAAGgAAAGFuIGFycmF5IG9mIGxlbmd0aCAyeyEQAHkAAAAvAAAAJwAAAKUAAAAMAAAABAAAAKYAAACnAAAAJAAAAAQAAACoAAAAYSBzZXF1ZW5jZQAAWygQAGMAAACKBAAAIgAAAFsoEABjAAAAjQQAABwAAACpAAAAsAMAAAgAAACqAAAAqwAAAEgAAAAIAAAArAAAAK0AAAAoAAAACAAAAK4AAACvAAAADAAAAAQAAACwAAAAsQAAACAAQZilwwALkQIBAAAAsgAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXnPghZ9BrVA9WqugZiyrbuVHprAvv5ieL98GMLX7yHyp2XgL1A6E/FDDdG1P8gtooQAAAAAAAAAAAEAAACzAAAAtAAAABAAAAAEAAAAVwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAtQAAAAQAAAAEAAAAJwAAALYAAAAEAAAABAAAAFoAQbSnwwALBQEAAAC3AEHEp8MAC40LAQAAALgAAAC5AAAADAAAAAQAAABfAAAAAAAAAAQAAAAEAAAAugAAAOBHEABdAAAAuggAABMAAADgRxAAXQAAAK4IAAATAAAA4EcQAF0AAAC0CAAAEgAAAOBHEABdAAAAkAUAAAwAAADgRxAAXQAAAKEFAAA0AAAA4EcQAF0AAACcBQAAEQAAAOBHEABdAAAAZQYAABYAAABzaXplIG92ZXJmbG93cyBNQVhfU0laRQDgRxAAXQAAAGAFAAAOAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAABA5EABvAAAAkAAAAC4AQdyywwALBQEAAAC7AEHsssMACyEBAAAAvAAAALsAAABU2RAAvQAAAL4AAAC/AAAAwAAAAMEAQZizwwALBQEAAADCAEGos8MAC5kEAQAAAMMAAADCAAAAkNkQAL0AAADEAAAAvwAAAMUAAADBAAAArwAAAAwAAAAEAAAAKQAAAK8AAAAMAAAABAAAACoAAAApAAAAzNkQAMYAAADHAAAALQAAAC4AAADIAAAAVGltZWRPdXQAAAAABAAAAAQAAAAwAAAAR2VuZXJhbE5ZSUVPRkFycm93RXJyb3IAAAAAAAQAAAAEAAAAyQAAAAAAAAAEAAAABAAAADEAAABJbmRleE91dE9mQm91bmQAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsTmVlZE1vcmVEYXRhAAAAAAQAAAAEAAAAMwAAAE5lZWRNb3JlRGF0YVJhbmdlAAAAmnsQAG0AAABqAAAACQAAAJp7EABtAAAAcgAAAAkAAAAAAAAABAAAAAQAAAA0AAAAVG9TdHJFcnJvcl9wcml2VHJ5RnJvbUludEVycm9yQ2FuY2VsZWQAAJ4eEABjAAAAvQAAADkAAAB1cmwgcGFyc2VoZWFkZXJzIHRyeV9pdGVyaGVhZGVycyBoYXZlIGFuIGl0ZXJhdG9yaGVhZGVycyBpdGVyYXRvciBkb2Vzbid0IHRocm93c2VyaWFsaXplZCBoZWFkZXJzZGVzZXJpYWxpemFibGUgc2VyaWFsaXplZCBoZWFkZXJzSnNWYWx1ZSgicmVxd2VzdDo6ZXJyb3JzOjpUaW1lZE91dCIpAAABAEHUt8MACwEFAEHot8MAC5UO8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADlaBAAZQAAAHUAAAA2AAAA5WgQAGUAAACCAAAAGQAAAM51EABqAAAAvQEAAB0AAABujxAAEwAAAP4AAAAlAAAAbo8QABMAAABDAQAARQAAAG6PEAATAAAAVAEAABgAAABujxAAEwAAAEsBAAAsAAAAbo8QABMAAABMAQAAKgAAAG6PEAATAAAATgEAABIAAABujxAAEwAAAEgBAAAVAAAAbo8QABMAAABPAQAASAAAAG6PEAATAAAAUQEAACIAAABujxAAEwAAAFsBAAAlAAAAbo8QABMAAABhAQAAHwAAAG6PEAATAAAAXQEAABEAAABujxAAEwAAAF8BAAAdAAAAbo8QABMAAACmAQAAKgAAAG6PEAATAAAAtAEAAB8AAABSYW5nZQAAAG6PEAATAAAAqAEAABEAAABujxAAEwAAAK4BAAAOAAAAbo8QABMAAACwAQAADgAAAG6PEAATAAAAsQEAACgAAABujxAAEwAAALIBAAAcAAAAaW52YWxpZCB2YWx1ZTogLCBleHBlY3RlZCAAAKTdEAAPAAAAs90QAAsAAABpbnZhbGlkIGxlbmd0aCAA0N0QAA8AAACz3RAACwAAAGR1cGxpY2F0ZSBmaWVsZCBgYAAA8N0QABEAAAAB3hAAAQAAANcyEAB4AAAA6wcAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBkc3QubGVuKCkgPj0gc2VsZi5yZXF1aXJlZF9zcGFjZSgpZB0QAGUAAAC9AAAACQAAAGQdEABlAAAAxwAAAAkAAABkHRAAZQAAAMIAAAANAAAADzcQAGUAAAAqAAAAHAAAAMRKEABqAAAAbQgAAB8AAAAAAAAABAAAAAQAAADQAAAAQ29sdW1uUGF0aHBhcnRzANEAAAAEAAAABAAAAJ4AAAAAAAAAAgAAAAIAAADSAAAAAAAAAAQAAAAEAAAAoAAAAENvbHVtbkRlc2NyaXB0b3JwcmltaXRpdmVfdHlwZW1heF9kZWZfbGV2ZWxtYXhfcmVwX2xldmVscGF0aNqHEABoAAAAXQMAABEAAABQQVIxTWlzc2luZyByb3cgZ3JvdXAgb3JkaW5hbAAAAKw2EABiAAAAxgEAAAoAAACsNhAAYgAAANABAAAlAAAArDYQAGIAAADQAQAAQQAAAE5lZ2F0aXZlIHJvdyBncm91cCBvcmRpbmFsOiApAAAAlN8QABwAAACw3xAAAQAAAAAAAAAUAAAABAAAANMAAAAAAAAAFAAAAAQAAADUAAAArDYQAGIAAAAAAQAAHwAAAKw2EABiAAAAAQEAACAAAACsNhAAYgAAAAIBAAAgAAAArDYQAGIAAAAKAQAAGAAAAP9/UGFycXVldCBkb2VzIG5vdCBzdXBwb3J0IG1vcmUgdGhhbiAgcm93IGdyb3VwcyBwZXIgZmlsZSAoY3VycmVudGx5OiAAACbgEAAjAAAASeAQACEAAACw3xAAAQAAAKw2EABiAAAATQEAACwAAABQcmV2aW91cyByb3cgZ3JvdXAgd3JpdGVyIHdhcyBub3QgY2xvc2VkU2VyaWFsaXplZEZpbGVXcml0ZXIgYWxyZWFkeSBmaW5pc2hlZAAAAAAAAAAcAAAABAAAANUAAAAAAAAAHAAAAAQAAADVAAAArDYQAGIAAABFAgAAGwAAAKw2EABiAAAARgIAABsAAACsNhAAYgAAAEcCAAAcAAAArDYQAGIAAABIAgAAHAAAAEluY29ycmVjdCBudW1iZXIgb2Ygcm93cywgZXhwZWN0ZWQgICE9ICByb3dzROEQACMAAABn4RAABAAAAGvhEAAFAAAArDYQAGIAAAC0AgAAMQAAAKw2EABiAAAAxgIAAEsAAABGYWlsZWQgdG8gc3BsaWNlIGNvbHVtbiBkYXRhLCBleHBlY3RlZCB7cmVhZF9sZW5ndGh9IGdvdCB7d3JpdGVfbGVuZ3RofWNvbHVtbiBkZXNjcmlwdG9yIG1pc21hdGNoLCBleHBlY3RlZCAgZ290IAAAAO/hEAAlAAAAFOIQAAUAAABleGhhdXN0ZWQgY29sdW1ucyBpbiBTZXJpYWxpemVkUm93R3JvdXBXcml0ZXJQcmV2aW91cyBjb2x1bW4gd3JpdGVyIHdhcyBub3QgY2xvc2VkAACsNhAAYgAAABsCAAAcAAAArDYQAGIAAAAcAgAAHAAAAKw2EABiAAAAHQIAAB0AAACsNhAAYgAAAB4CAAAdAAAArDYQAGIAAADxAgAAOQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQBBiMbDAAsFAQAAANYAQZjGwwALBQEAAADXAEGoxsMACwUBAAAA2ABBuMbDAAv8AQEAAADYAAAAVEoQAG8AAADlBQAAFAAAAFRKEABvAAAA5QUAACEAAABUShAAbwAAANkFAAAhAAAA1zIQAHgAAADrBwAACQAAAG1pZCA+IGxlbgAAAIDjEAAJAAAALX4QAIAAAACuAgAAEwAAAFRKEABvAAAAaQQAACQAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB9sjDAAszAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwQEBAQEAEG0ycMAC/4BQ291bGRuJ3QgZGVzZXJpYWxpemUgdTY0IGZyb20gYSBCaWdJbnQgb3V0c2lkZSB1NjQ6Ok1JTi4udTY0OjpNQVggYm91bmRz61UQAGYAAAAtAAAAOQAAANsnEAATAAAAUQAAADoAAADbJxAAEwAAAHUAAAA9AAAA2ycQABMAAAB2AAAARgAAAGJhdGNoU2l6ZXJvd0dyb3Vwc2xpbWl0b2Zmc2V0Y29sdW1uc2NvbmN1cnJlbmN5ADzlEAAJAAAAReUQAAkAAABO5RAABQAAAFPlEAAGAAAAWeUQAAcAAABg5RAACwAAAHN0cnVjdCBKc1JlYWRlck9wdGlvbnMAQbzLwwALsQMBAAAA2QAAAKlDEABtAAAAcgMAACYAAABFeHBlY3RlZCB0byByZWFkICBieXRlcyBvZiBwYWdlLCByZWFkIG9ubHkgANTlEAARAAAA5eUQABoAAABhc3NlcnRpb24gZmFpbGVkOiBuIDw9IHNlbGYuYnVmLmluaXQgLSBzZWxmLmJ1Zi5maWxsZWQAAIRhEABzAAAAFQEAAAkAAABmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXIAWOYQABsAAAAlAAAAAgAAAHTmEACufhAAaQAAAEECAAAfAAAABYkQAGgAAABgAAAAEgAAAGZpbGxlZCBtdXN0IG5vdCBiZWNvbWUgbGFyZ2VyIHRoYW4gaW5pdGlhbGl6ZWQAAKjmEAAuAAAA+GEQAGAAAACTAAAADgAAAPhhEABgAAAAQQAAAB4AAABmaWxsZWQgb3ZlcmZsb3didWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCk7IGJ1Zi5sZW4oKSA9ICwgcmVtYWluaW5nKCkgPSAAAA/nEAAvAAAAPucQABAAAADvkhAAXgAAAEoBAAARAEH4zsMAC/UPAQAAANoAAABxfBAAbQAAAK4DAAApAAAA3QAAABwAAAAEAAAA3gAAAN8AAADgAAAA4QAAAOIAAABIAAAACAAAAOMAAADkAAAA5QAAAOYAAADnAAAA6AAAAOkAAADqAAAAUS8QAGIAAACNAAAADgAAAOsAAADAAAAACAAAAOwAAADtAAAA7gAAANAAAAAIAAAA7wAAAPAAAADXMhAAeAAAAOsHAAAJAAAA8QAAABQAAAAEAAAA8gAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAXIIQAH4AAACyBQAAJAAAAM+JEABhAAAALwAAABEAAAAAAAAABAAAAAQAAAAwAAAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAADzAAAADAAAAAQAAAD0AAAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgDEShAAagAAAG0IAAAfAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gU2l6ZSBpcyAgYnV0IG5lZWQgAADo6RAAIAAAAAjqEAAKAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gUmFuZ2UgIGlzIGJleW9uZCBmaWxlIGJvdW5kcyAAAAAk6hAAHgAAAELqEAAXAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gUGFnZSBpbmRleCByYW5nZSAgb3ZlcmxhcHMgd2l0aCBmaWxlIG1ldGFkYXRhIAAAbOoQACkAAACV6hAAHQAAAFRyaWVkIHRvIHJlYWQgcGFnZSBpbmRleGVzIHdpdGhvdXQgUGFycXVldE1ldGFEYXRhIG1ldGFkYXRhAHF8EABtAAAAwwMAABsAAABxfBAAbQAAAMQDAAAfAAAAcXwQAG0AAADEAwAAQAAAAPYAAAAUAAAABAAAAPcAAAD4AAAAcm93IGdyb3VwICBvdXQgb2YgYm91bmRzIDAuLkTrEAAKAAAATusQABIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBNdXN0IGJlIFN0cnVjdCBmb3Igcm9vdCB0eXBlAABw6xAARgAAAL99EABtAAAAEAIAABIAAADOdRAAagAAAL0BAAAdAAAAnUUQAA0AAAAuAAAAEQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU+SBAAbQAAADoAAAAxAAAATWFwIG11c3Qgbm90IGJlIHBvbGxlZCBhZnRlciBpdCByZXR1cm5lZCBgUG9sbDo6UmVhZHlgAAA+SBAAbQAAAD4AAAARAAAAznUQAGoAAAC9AQAAHQAAAFVua25vd24gZXJyb3JhbHJlYWR5IGxvY2tlZCB0byBhIHdyaXRlcmF0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hpcCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWVhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAAAAAAAABAAAAAQAAAPkAAAD6AAAARm5PbmNlIGNhbGxlZCBtb3JlIHRoYW4gb25jZR6awL7+Yni/fBjC1+8h8qf7AAAADAAAAAQAAAApAAAA+wAAAAwAAAAEAAAAKgAAACkAAACY7RAA/AAAAP0AAAAtAAAALgAAAP4AAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwX3Rocm93KClgIG9uIGFuIGBFcnJgIHZhbHVlcG9sbGVkIEZlZWQgYWZ0ZXIgY29tcGxldGlvbgAAALaMEABlAAAAJwAAACUAAAD/AAAAlAAAAAQAAAAAAQAAAQEAAGwAAAAEAAAAAgEAAAMBAABsAAAABAAAAAQBAAAFAQAATAAAAAQAAAAGAQAABwEAAFQAAAAEAAAACAEAAAAAAAAEAAAABAAAAAkBAAAKAQAAAAAAAAQAAAAEAAAACwEAAAwBAAAAAAAABAAAAAQAAAANAQAADgEAAAAAAAAEAAAABAAAAA8BAAAQAQAAAAAAAAQAAAAEAAAAEQEAABIBAADHkRAAZwAAAOYAAAAVAAAAzFoQAHgAAAA+AAAARgAAAMxaEAB4AAAATAAAADYAAADMWhAAeAAAAFAAAABIAAAAzFoQAHgAAAAcAAAAGwAAAMxaEAB4AAAAJQAAABsAAADMWhAAeAAAACwAAAAbAAAAEwEAAAwAAAAEAAAAFAEAABUBAAAgAEH43sMAC+UBAQAAABYBAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAATnUQAH8AAABuAAAAGQAAAE51EAB/AAAAcAAAAC8AAABOdRAAfwAAAGQAAAAjAAAATnUQAH8AAACAAAAALAAAANN0EAB6AAAAUAAAACMAAABOdRAAfwAAADUAAAATAAAA03QQAHoAAAAjAAAAEwBB6ODDAAu+BAEAAACzAAAA4EcQAF0AAACQBAAADAAAAOBHEABdAAAAuwYAACAAAADgRxAAXQAAALsGAAA/AAAA4EcQAF0AAAC8BgAAIAAAAOBHEABdAAAAZQYAABYAAADgRxAAXQAAAMEFAAA9AAAAc2l6ZSBvdmVyZmxvd3MgTUFYX1NJWkUA4EcQAF0AAABoBAAAHQAAAOBHEABdAAAA3AYAAA0AAADgRxAAXQAAANwGAAAsAAAA4EcQAF0AAADgBgAAIQAAAOBHEABdAAAA6gYAABYAAADgRxAAXQAAAMEKAAAhAAAA4EcQAF0AAACnCgAAIAAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBvciBhZnRlciBiZWluZyBkcm9wcGVkZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheQAA9yRbETdq5ez1Dz3bPRfbXLCEy/RX/xQlHL33xG4wOEzTvhCNO6oG2mzL/9GPJJTpcfnzCcyUAxXfG8TTvJ/PfQAAAAACAAAAAQAAABcBAAAAAAAAAgAAAAEAAAAYAQAAFwEAAPTxEAAZAQAAGgEAABsBAAAcAQAAHQEAAB4BAAAEAAAABAAAAB8BAAAeAQAABAAAAAQAAAAnAAAAHwEAADDyEAAgAQAAIQEAACIBAAAjAQAAJAEAAAAAAAABAAAAAQAAACUBAAAAAAAAAQAAAAEAAAAmAQAAJQEAAGzyEAAnAQAAKAEAABsBAAApAQAAHQEAQbDlwwALBgEAAAAqAQBBwOXDAAu5CAEAAAArAQAAKgEAAKjyEAAsAQAALQEAAC4BAAAvAQAAMAEAAEVtcHR5SG9zdElkbmFFcnJvckludmFsaWRQb3J0SW52YWxpZElwdjRBZGRyZXNzSW52YWxpZElwdjZBZGRyZXNzSW52YWxpZERvbWFpbkNoYXJhY3RlclJlbGF0aXZlVXJsV2l0aG91dEJhc2VSZWxhdGl2ZVVybFdpdGhDYW5ub3RCZUFCYXNlQmFzZVNldEhvc3RPbkNhbm5vdEJlQUJhc2VVcmxPdmVyZmxvd2NhbGxlZCBgUmVzdWx0Ojp1bndyYXBfdGhyb3coKWAgb24gYW4gYEVycmAgdmFsdWVCYWRTY2hlbWUJAAAACQAAAAsAAAASAAAAEgAAABYAAAAWAAAAIAAAABkAAAAIAAAA5PIQAO3yEAD28hAAAfMQABPzEAAl8xAAO/MQAFHzEABx8xAAivMQAB6awL7+Yni/fBjC1+8h8qc0AQAADAAAAAQAAAApAAAANAEAAAwAAAAEAAAAKgAAACkAAAAs9BAANQEAADYBAAAtAAAALgAAADcBAAByZXF3ZXN0OjpFcnJvcgAAAAAAAAQAAAACAAAAOAEAAGtpbmQAAAAACAAAAAQAAAA5AQAAdXJsADoBAAAIAAAABAAAADsBAABzb3VyY2VidWlsZGVyIGVycm9yZXJyb3Igc2VuZGluZyByZXF1ZXN0ZXJyb3IgZm9sbG93aW5nIHJlZGlyZWN0SFRUUCBzdGF0dXMgc2VydmVyIGVycm9ySFRUUCBzdGF0dXMgY2xpZW50IGVycm9yICgpAAEAAAAAAAAAIPUQAAIAAAAi9RAAAQAAAHJlcXVlc3Qgb3IgcmVzcG9uc2UgYm9keSBlcnJvcmVycm9yIGRlY29kaW5nIHJlc3BvbnNlIGJvZHllcnJvciB1cGdyYWRpbmcgY29ubmVjdGlvbiBmb3IgdXJsICgAAJD1EAAKAAAAIvUQAAEAAABvcGVyYXRpb24gdGltZWQgb3V0VVJMIHNjaGVtZSBpcyBub3QgYWxsb3dlZEJ1aWxkZXJSZXF1ZXN0UmVkaXJlY3QAAAAAAAAEAAAABAAAADwBAABTdGF0dXNCb2R5RGVjb2RlVXBncmFkZQABAAAAAAAAAFNlcnZpY2VXb3JrZXJHbG9iYWxTY29wZUABAAAIAAAABAAAAEEBAABCAQAARm5PbmNlIGNhbGxlZCBtb3JlIHRoYW4gb25jZQAAAAAAAAAAAQAAAEMBAAAAAAAABAAAAAQAAABEAQAAVHJ5RnJvbUludEVycm9ydGltZW91dAAA8n8QAGAAAABGAAAALAAAAHJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQAAAAMkRAAVQAAAE8LAAALAAAAYmxvYmh0dHC5VBAAYAAAAB0AAAAdAAAAAAAAABgAQYTuwwALtQHOdRAAagAAAKcBAAAfAAAA8VcQAGAAAACTAAAAEwAAAPFXEABgAAAAmAAAACMAAADxVxAAYAAAAJsAAAAWAAAA8VcQAGAAAACnAAAADQAAAMoZEACBAAAAOAAAABsAAAB4FBAAXgAAAJUAAAAcAAAAY2Fubm90IGFkdmFuY2UgcGFzdCBgcmVtYWluaW5nYDogIDw9IAAAAHT3EAAhAAAAlfcQAAQAAAALLBAAWgAAAMcCAAAJAEHd78MAC14hACMkJSYnAAAqKwAtLgAwMTIzNDU2Nzg5AAAAAAAAAGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6AAAAXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoAfAB+AEG88cMAC94HSW52YWxpZEhlYWRlck5hbWVpbnZhbGlkIEhUVFAgaGVhZGVyIG5hbWVJbnZhbGlkSGVhZGVyVmFsdWVmYWlsZWQgdG8gcGFyc2UgaGVhZGVyIHZhbHVlZmFpbGVkIHRvIGNvbnZlcnQgaGVhZGVyIHRvIGEgc3RyaW52YWxpZCB1cmkgY2hhcmFjdGVyaW52YWxpZCBzY2hlbWVpbnZhbGlkIGF1dGhvcml0eWludmFsaWQgcG9ydGludmFsaWQgZm9ybWF0c2NoZW1lIG1pc3NpbmdhdXRob3JpdHkgbWlzc2luZ3BhdGggbWlzc2luZ3VyaSB0b28gbG9uZ2VtcHR5IHN0cmluZ3NjaGVtZSB0b28gbG9uZwAAAAAEAAAABAAAAEYBAABJbnZhbGlkVXJpSW52YWxpZFVyaUNoYXJJbnZhbGlkU2NoZW1lSW52YWxpZEF1dGhvcml0eUludmFsaWRQb3J0SW52YWxpZEZvcm1hdFNjaGVtZU1pc3NpbmdBdXRob3JpdHlNaXNzaW5nUGF0aEFuZFF1ZXJ5TWlzc2luZ1Rvb0xvbmdFbXB0eVNjaGVtZVRvb0xvbmcAAA4AAAANAAAAEAAAAAsAAAANAAAADQAAABAAAAATAAAABwAAAAUAAAANAAAA7vkQAPz5EAAJ+hAAGfoQACT6EAAx+hAAPvoQAE76EABh+hAAaPoQAG36EAAVAAAADgAAABEAAAAMAAAADgAAAA4AAAARAAAADAAAAAwAAAAMAAAADwAAADT5EABJ+RAAV/kQAGj5EAB0+RAAgvkQAJD5EACh+RAArfkQALn5EADF+RAA4EcQAF0AAADZCAAAJgAAAOBHEABdAAAA4QgAADMAAABNYXhTaXplUmVhY2hlZG1heCBzaXplIHJlYWNoZWQAAKuIEABZAAAAUQEAADQAAABkZXNjcmlwdGlvbigpIGlzIGRlcHJlY2F0ZWQ7IHVzZSBEaXNwbGF5/boSq9eohd/PHDuR4FZOoG7m3f3FRzTMBdmXVQomhbWVJ86n0lRsQ88gelqcY4psCs5EZEhwZ1yLNTASwLCTKqGO1Laqqaf9AqPoZ9Hm65WZ4GA+TFRbkrCMdjsJUa9uGOuggV4LXZquasZ1vAzCDEludmFsaWRNZXRob2RpbnZhbGlkIEhUVFAgbWV0aG9kPHVua25vd24gc3RhdHVzIGNvZGU+IAAAAQAAAAAAAABJ/BAAAQAAAEludmFsaWRTdGF0dXNDb2RlaW52YWxpZCBzdGF0dXMgY29kZWh0dHA6OkVycm9yAAAAAAAIAAAABAAAAEkBAEGk+cMACwYBAAAASgEAQbT5wwALIgEAAABLAQAASgEAAJz8EABMAQAATQEAAE4BAABMAQAATwEAQeD5wwALBgEAAABQAQBB8PnDAAuaAQEAAABRAQAAUAEAANj8EABMAQAAUgEAAE4BAABMAQAATwEAAAAAAAABAAAAAQAAAFMBAAAAAAAAAQAAAAEAAABUAQAAUwEAABT9EABVAQAAVgEAAFcBAABYAQAAWQEAAAAAAAABAAAAAQAAAFoBAAAAAAAAAQAAAAEAAABbAQAAWgEAAFD9EABVAQAAXAEAAFcBAABYAQAAWQEAQZT7wwALBgEAAABdAQBBpPvDAAsiAQAAAF4BAABdAQAAjP0QAEwBAABfAQAATgEAAGABAABPAQBB0PvDAAsGAQAAAGEBAEHg+8MACyIBAAAAYgEAAGEBAADI/RAATAEAAGMBAABOAQAAZAEAAE8BAEGM/MMACwYBAAAAZQEAQZz8wwALnwgBAAAAswAAAGUBAAAE/hAATAEAAGYBAABOAQAAZwEAAE8BAABDb250aW51ZVN3aXRjaGluZyBQcm90b2NvbHNQcm9jZXNzaW5nT0tDcmVhdGVkQWNjZXB0ZWROb24gQXV0aG9yaXRhdGl2ZSBJbmZvcm1hdGlvbk5vIENvbnRlbnRSZXNldCBDb250ZW50UGFydGlhbCBDb250ZW50TXVsdGktU3RhdHVzQWxyZWFkeSBSZXBvcnRlZElNIFVzZWRNdWx0aXBsZSBDaG9pY2VzTW92ZWQgUGVybWFuZW50bHlGb3VuZFNlZSBPdGhlck5vdCBNb2RpZmllZFVzZSBQcm94eVRlbXBvcmFyeSBSZWRpcmVjdFBlcm1hbmVudCBSZWRpcmVjdEJhZCBSZXF1ZXN0VW5hdXRob3JpemVkUGF5bWVudCBSZXF1aXJlZEZvcmJpZGRlbk5vdCBGb3VuZE1ldGhvZCBOb3QgQWxsb3dlZE5vdCBBY2NlcHRhYmxlUHJveHkgQXV0aGVudGljYXRpb24gUmVxdWlyZWRSZXF1ZXN0IFRpbWVvdXRDb25mbGljdEdvbmVMZW5ndGggUmVxdWlyZWRQcmVjb25kaXRpb24gRmFpbGVkUGF5bG9hZCBUb28gTGFyZ2VVUkkgVG9vIExvbmdVbnN1cHBvcnRlZCBNZWRpYSBUeXBlUmFuZ2UgTm90IFNhdGlzZmlhYmxlRXhwZWN0YXRpb24gRmFpbGVkSSdtIGEgdGVhcG90TWlzZGlyZWN0ZWQgUmVxdWVzdFVucHJvY2Vzc2FibGUgRW50aXR5TG9ja2VkRmFpbGVkIERlcGVuZGVuY3lUb28gRWFybHlVcGdyYWRlIFJlcXVpcmVkUHJlY29uZGl0aW9uIFJlcXVpcmVkVG9vIE1hbnkgUmVxdWVzdHNSZXF1ZXN0IEhlYWRlciBGaWVsZHMgVG9vIExhcmdlVW5hdmFpbGFibGUgRm9yIExlZ2FsIFJlYXNvbnNJbnRlcm5hbCBTZXJ2ZXIgRXJyb3JOb3QgSW1wbGVtZW50ZWRCYWQgR2F0ZXdheVNlcnZpY2UgVW5hdmFpbGFibGVHYXRld2F5IFRpbWVvdXRIVFRQIFZlcnNpb24gTm90IFN1cHBvcnRlZFZhcmlhbnQgQWxzbyBOZWdvdGlhdGVzSW5zdWZmaWNpZW50IFN0b3JhZ2VMb29wIERldGVjdGVkTm90IEV4dGVuZGVkTmV0d29yayBBdXRoZW50aWNhdGlvbiBSZXF1aXJlZAAAAAAEAAAABAAAAEYBAABJbnZhbGlkVXJpAAAAAAAABAAAAAQAAABoAQAASW52YWxpZFVyaVBhcnRzAKz8EADo/BAAJP0QAGD9EACc/RAA2P0QABT+EABBxITEAAvsCwEAAABqAQAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUVycm9yYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5pc19jaGFyX2JvdW5kYXJ5KGlkeClhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbilhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkoYXQpAFRKEABvAAAAzgEAADcAAABUShAAbwAAAAoCAAA3AAAA4l8QAGsAAABnCQAAKQAAAGh0dHBodHRwc3dzd3NzZnRwZmlsZQAAAIA5EABYAAAAIwEAAC4AAACAORAAWAAAAJ0BAAAxAAAAgDkQAFgAAACcAQAATwAAAIA5EABYAAAAsgEAABwAAACAORAAWAAAAMUBAABEAAAALy8AAIA5EABYAAAA7gEAACAAAABmaWxlOi8vAIA5EABYAAAAEQIAACQAAACAORAAWAAAABwCAAAoAAAAgDkQAFgAAAAkAgAAGgAAAIA5EABYAAAANwIAACQAAACAORAAWAAAAD4CAABGAAAAgDkQAFgAAAA+AgAAVgAAAIA5EABYAAAAQwIAADAAAACAORAAWAAAAEACAAAwAAAAgDkQAFgAAABBAgAAMAAAAIA5EABYAAAAcAIAADsAAACAORAAWAAAAHMCAAAoAAAAgDkQAFgAAACAAgAAKAAAAIA5EABYAAAAkQIAACwAAABmaWxlOi8vL4A5EABYAAAApQIAACwAAACAORAAWAAAAL0CAAAgAAAAgDkQAFgAAADgAgAANwAAAIA5EABYAAAA4wIAACQAAACAORAAWAAAAPACAAAkAAAAgDkQAFgAAAAPAwAAJAAAAIA5EABYAAAAEAMAACQAAACAORAAWAAAAAgDAAAaAAAAgDkQAFgAAAAoAwAAJAAAAIA5EABYAAAAMAMAACgAAACAORAAWAAAAFIDAAAcAAAAgDkQAFgAAABTAwAAHAAAAIA5EABYAAAAtQMAACAAAACAORAAWAAAAJ0DAAAxAAAAgDkQAFgAAACkAwAAKAAAAP////8NgAD8AQAAeAEAALgBAAAAAAAAAIA5EABYAAAAwQMAADMAAAA6AAAAgDkQAFgAAADTAwAAJAAAAIA5EABYAAAA1gMAACQAAACAORAAWAAAANADAAA9AAAAgDkQAFgAAAAIBAAANAAAAGxvY2FsaG9zdAAAAIA5EABYAAAAMQQAAD8AAACAORAAWAAAAFEEAAA0AAAAgDkQAFgAAACfBAAAIAAAAIA5EABYAAAAjgQAACQAAACAORAAWAAAAOsEAAAsAAAAgDkQAFgAAAD6BAAALAAAAIA5EABYAAAADgUAADQAAACAORAAWAAAABkFAAAwAAAAgDkQAFgAAAAjBQAAJAAAAIA5EABYAAAAIQUAACQAAAAuLiUyZSUyZSUyZSUyRSUyRSUyZSUyRSUyRSUyZS4lMkUuLiUyZS4lMkUuJTJlJTJFAAAAgDkQAFgAAABHBQAAMAAAAIA5EABYAAAASAUAADAAAACAORAAWAAAAEkFAAAwAAAAgDkQAFgAAABLBQAANAAAAIA5EABYAAAAOgUAACgAAACAORAAWAAAADwFAAAsAAAAgDkQAFgAAAAqBQAAKAAAAIA5EABYAAAANAUAACwAAACAORAAWAAAAGAFAAArAAAAgDkQAFgAAABhBQAAIAAAAIA5EABYAAAAYgUAACAAAACAORAAWAAAALQEAAAiAAAA/////w0AANAAAAAAAQAAqP////8tgADQAAAAAAEAAKj/////LYAA0AAAABABAACogDkQAFgAAABpBQAAMAAAAIA5EABYAAAAbgUAAEkAAACAORAAWAAAAHwFAABGAAAAgDkQAFgAAACHBQAANAAAAIA5EABYAAAAhwUAAE4AAACAORAAWAAAAIwFAABKAAAAgDkQAFgAAACOBQAAJAAAAP////8AQbuQxAAL6QeAgDkQAFgAAADFBQAAIwAAADovLgCAORAAWAAAAMkFAAAYAAAALwAAAIA5EABYAAAA1AUAABYAAACAORAAWAAAANcFAAAoAAAAOi8vYXNzZXJ0aW9uIGZhaWxlZDogIXNlbGYuc2VyaWFsaXphdGlvbltzY2hlbWVfZW5kX2FzX3VzaXplLi5dLnN0YXJ0c193aXRoKCI6Ly8iKQAAgDkQAFgAAADXBQAADQAAAIA5EABYAAAAyQUAAA0AAACAORAAWAAAAL0FAAAiAAAAgDkQAFgAAADABQAAJAAAAIA5EABYAAAAwwUAACgAAACAORAAWAAAAMMFAAANAAAAgDkQAFgAAAD2BQAAJAAAAIA5EABYAAAAAwYAABwAAABQcm9ncmFtbWluZyBlcnJvci4gcGFyc2VfcXVlcnlfYW5kX2ZyYWdtZW50KCkgY2FsbGVkIHdpdGhvdXQgPyBvciAjAIA5EABYAAAA/wUAABIAAAD/////DQAAUAAAAAAAAACA/////40AAFAAAAAAAAAAgIA5EABYAAAAHwYAACcAAACAORAAWAAAACUGAAAnAAAAAAAAAAgAAAAEAAAAawEAAGwBAABsAQAAgDkQAFgAAABEBgAAJAAAAIA5EABYAAAAYAYAAA4AAACAORAAWAAAAGEGAAAcAAAAgDkQAFgAAABiBgAAHAAAAP////8FAABQAAAAAAEAAICAORAAWAAAAH4GAAAnAAAAgDkQAFgAAAD5BgAAVwAAAIA5EABYAAAAIgcAAAkAAAAMkRAAVQAAAEgLAAALAAAADJEQAFUAAABPCwAACwAAAGVtcHR5IGhvc3RpbnZhbGlkIGludGVybmF0aW9uYWwgZG9tYWluIG5hbWVpbnZhbGlkIHBvcnQgbnVtYmVyaW52YWxpZCBJUHY0IGFkZHJlc3NpbnZhbGlkIElQdjYgYWRkcmVzc2ludmFsaWQgZG9tYWluIGNoYXJhY3RlcnJlbGF0aXZlIFVSTCB3aXRob3V0IGEgYmFzZXJlbGF0aXZlIFVSTCB3aXRoIGEgY2Fubm90LWJlLWEtYmFzZSBiYXNlYSBjYW5ub3QtYmUtYS1iYXNlIFVSTCBkb2VzbuKAmXQgaGF2ZSBhIGhvc3QgdG8gc2V0VVJMcyBtb3JlIHRoYW4gNCBHQiBhcmUgbm90IHN1cHBvcnRlZAAA4l8QAGsAAADoAQAAFwAAAAyREABVAAAAQQsAAAsAAAAMkRAAVQAAAEgLAAALAAAA1zIQAHgAAADrBwAACQAAAFRKEABvAAAACgIAADcAAAA4FRAAVgAAAGEAAAApAAAA/////wBBr5jEAAvBDIA4FRAAVgAAAIAAAAApAAAAW106ADgVEABWAAAA2wAAABsAAAABAAAAAAAAADgVEABWAAAACwEAAB0AAAAweDBYOBUQAFYAAAAoAQAAFwAAADgVEABWAAAAJQEAABcAAABhIG5vbi1lbXB0eSBsaXN0IG9mIG51bWJlcnMAOBUQAFYAAABSAQAAIgAAADgVEABWAAAATQEAACQAAAA4FRAAVgAAAKgBAAAJAAAAOBUQAFYAAADnAQAAGAAAADgVEABWAAAAzgEAABEAAABYehAAawAAACQDAAABAAAA4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobilhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkoc3RhcnQpYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5pc19jaGFyX2JvdW5kYXJ5KGVuZCluAQAADAAAAAQAAABvAQAAcAEAAHEBAADiXxAAawAAAGYJAAAOAAAA4l8QAGsAAABnCQAAKQAAAP4QEABvAAAAWgMAADQAAAD+EBAAbwAAAGEDAAAyAAAA1zIQAHgAAADrBwAACQAAAAAAAAAEAAAABAAAAHIBAAD8hhAAbAAAAOIKAAAkAAAAVEoQAG8AAADOAQAANwAAAAAAAAAIAAAABAAAAHMBAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlQ2FwYWNpdHlPdmVyZmxvdwAAAAAABAAAAAQAAAB0AQAAQWxsb2NFcnJsYXlvdXQAAKiTEABbAAAAVgEAAC4AAABjYXBhY2l0eSBvdmVyZmxvdwAAAKiTEABbAAAA0gQAAA4AAABhc3NlcnRpb24gZmFpbGVkOiBuZXdfY2FwID49IGxlbqiTEABbAAAAnQQAAA0AAADiXxAAawAAANUMAAAOAAAAEHIQAFsAAAAhAAAADgAAABByEABbAAAAsQAAABsAAAAQchAAWwAAAJMBAAAOAAAAEHIQAFsAAAC4AQAAJQAAAGV4cGxpY2l0IHBhbmljAAAQchAAWwAAAM4BAAAOAAAAuZQQAGAAAACkAwAAKwAAAG1pZCA+IGxlbgAAAJgPEQAJAAAATBoQAH8AAABKAAAAHwAAAEwaEAB/AAAARAAAABcAAAAAAEAAAACAAMAA/wA+AXEBsQEAAAAAAADxATECcAKmAuYCIANdA5wDAAAAANYDFgRGBHsEAAC7BOoEKQUAAD4FfAWqBdMFCQZJBoYGpgblBiQHYQeAB70Hpgb1ByEIYAiAB5gIgAfYCO8ILgkAAGQJhAm/CcsJBgouCmsKqwrlCm8GiAaVBqsGywbbBvMGEgeIBogGiAYnBwAAEAAgADAAQABQAGAAcAAAABAAIAAwAIAAkACgALAAwADQAOAA8AD/AA8BHwEvAT4BTgFeAW4BcQGBAZEBoQGxAcEB0QHhAQAAEAAgADAAAAAQACAAMAAAABAAIAAwAPEBAQIRAiECMQJBAlECYQJwAoACkAKgAqYCtgLGAtYC5gL2AgYDFgMgAzADQANQA10DbQN9A40DnAOsA7wDzAMAABAAIAAwAAAAEAAgADAA1gPmA/YDBgQWBCYENgRGBFYEZgR2BHsEiwSbBKsEAAAQACAAMAC7BMsE2wTrBOoE+gQKBRoFKQU5BUkFWQUAABAAIAAwAD4FTgVeBW4FfAWMBZwFrAWqBboFygXaBdMF4wXzBQMGCQYZBikGOQZJBlkGaQZ5BoYGlgamBrYGpga2BsYG1gblBvUGBQcVByQHNAdEB1QHYQdxB4EHkQeAB5AHoAewB70HzQfdB+0Hpga2BsYG1gb1BwUIFQglCCEIMQhBCFEIYAhwCIAIkAiAB5AHoAewB5gIqAi4CMgIgAeQB6AHsAfYCOgI+AgICe8I/wgPCR8JLgk+CU4JXgkAABAAIAAwAGQJdAmECZQJpAm0Cb8JzwnfCe8JywnbCesJ+wkGChYKJgo2Ci4KPgpOCl4Kawp7CosKmwqrCrsKywrbCuUK9QoFCxULAAAAAB8LLgsAAAAAAAAAADkLAEGKpcQACw5IC1ILAAAAAFoLYgtvCwBBwqXEAAsCSQQAQYSmxAALBnsLAABqBwBBnKbEAAsCiQsAQbKmxAALApcLAEHEpsQACwKhCwBB3qbEAAtGrQsAAAAAAAAAAMoHuAsAAAAAAADIC9cLAAAAAAAA5gv1CwAAAQwRDAAAFgxhAwAAAAB1CwAAAAAAAH8GJgwAAAAAAAB+BgBBtqfEAAsGNgxGDFQMAEHUp8QAC0pkDHQM8QF+DI4MngyuDL4MzgzeDO4M/gwODR4NLg0+DU4NXg1uDX4Njg2eDa4Nvg3ODd4N7g3+DQ4OHg4uDj4OTQ5dDm0OfQ6NDgBBtqjEAAsMnQ6sDmQDAAAAALwOAEHOqMQACzTIDtQOAADjDgAAAAAAAPMOAAAADwAADw8AAB8PLw8/DwAASQ8AAAAAAABZDwAAAAAAAGcPAEGcqcQACwJyDwBBwqnEAAsERwRjAwBB1KnEAAsCGwkAQeKpxAALJPEB8QEAAAAAfw8AAI8Pnw+vD78PAADND9wP7A/8DwwQAAAaEABBpqrEAAsIRwQpEAAASAQAQbiqxAALAmMDAEHaqsQACwZoBwAAhwYAQfKqxAALFGoHAADxAWMDAAAAALgFAAAAAMcHAEGQq8QACwSCBsoHAEGqq8QACwo5ECIHAAAAAGgHAEHQq8QAC0aGBgAASRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEFUQAEGgrMQAC0BlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQAEGArcQAC0p1EIUQlRClELUQxRDVEOUQ9RAFERURJRE1EUURVRFlEXURhRGVEaURtRHFEdUR5RH1EQUSFRIlEjUSRRIAAAAAAABPEl8SbxJ/EgBB4K3EAAsCjxIAQZquxAALAp8SAEHarsQACwI5CwBB+K7EAAsCmgQAQYqvxAALAloDAEHEr8QACxCtEgAAuRIAAL4SAAAAAM4SAEHor8QACwLeEgBBjrDEAAsK6hIAAAAAAADyEgBBrbDEAAsdEwAAAAAAAAAAtgUAAAAAAAAAAA0TmgQAAAAAHRMAQdiwxAALOmgHAAAAAC0TAAA9E0oTVhMAAAAAAAAAAGIDAABhE3ETAAAAAAAAggYAAAAAAAAAAIETAAAAAAAAjBMAQaaxxAALLJMTAAAAAAAAAACeE60TWAi7E2ADyBPXEwAA3xPtE8oHAAAAAAAAAAD9ExUHAEHcscQACwQNFBwUAEH6scQACw5QCCIUMhQAAAAAAAAbCQBBlrLEAAsCPBQAQaSyxAALAmMHAEHAssQACwJWEwBB4LLEAAsETBSCBgBB9rLEAAsWygcAAAAAAABqB2cHAAAAAAAAAABlBwBBuLPEAAsCGwkAQdqzxAALDDMLAAAAAAAAAABnBwBBjrTEAAsCNgsAQbK0xAALBFsUahQAQdS0xAALCnoUAAAAAAAAihQAQYq1xAALApMUAEHKtcQACwKjFABB3rXEAAsCpRQAQYy2xAALGrQUxBTSFN8UAADrFPkUCRUAAAAAAAAAABcVAEHctsQACwYnFS8VPRUAQey2xAALAkcEAEGCt8QACwKKFABBnLfEAAsKFQcAAAAAAADlAQBByLfEAAsCSBUAQei3xAALAgwFAEGEuMQACwJYFQBBkrjEAAsCZBUAQaq4xAALRHQVhBWUFaQVtBXEFdQV5BX0FQQWFBYkFjQWRBZUFmQWdBaEFpQWpBa0FsQW1BbkFvQWBBcUFyQXNBdEF1QXZBd0F4QXAEGqucQAC64DTABsAIwAqwDLAOsACwEpAUkBZgF8AYsBqQHIAegBCAIoAkgCfAF8AXwBWwJtAnwBjQJ8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBpwLHAuQCBAMEAwQDBAMEAwQDBAMEAwQDBAMEAwoDKgMqAyoDKgN8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAFKA2oDfAGIA6gDyAPgA3wBfAEABA8EJgRCBF8EfQSaBLcE1gTzBA0FfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAEiBXwBfAF8AXwBNQVJBWAFfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBgAV8AXwBfAF8AXwBfAF8AXwBiwWoBXwBfAF8AXwBfAF8AcgF3gXwBXwBDwZ8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AS8GTwbu/wBB2MDEAAvEA0EAgAFBgIABQQCBAUGAgQFBAIQBQQCFAQAAAABDgJMBRQCAAUWAgAFFAIEBRQCEAUkAgAFJgIABSQCBAUkAhAEAAAAAToCBAU8AgAFPgIABTwCBAU+AgQFPAIQBAAAAAAAAAABVAIABVYCAAVUAgQFVAIQBWYCAAQAAAAAAAAAAYQCAAWGAgAFhAIEBYYCBAWEAhAFhAIUBAAAAAGOAkwFlAIABZYCAAWUAgQFlAIQBaQCAAWmAgAFpAIEBaQCEAQAAAABugIEBbwCAAW+AgAFvAIEBb4CBAW8AhAEAAAAAAAAAAHUAgAF1gIABdQCBAXUAhAF5gIABAAAAAHkAhAFBAIIBYQCCAUEAgwFhAIMBQQCUAWEAlAFDgIABY4CAAUMAgQFjAIEBQ4CDAWOAgwFDAIYBYwCGAUQAhgFkAIYBAAAAAAAAAABFAIIBZQCCAUUAgwFlAIMBRYCDAWWAgwFFAJQBZQCUAUUAhgFlAIYBRwCBAWcAgQFHAIMBZwCDAUeAgwFngIMBR4CTAWeAkwFIAIEBaACBAQAAAAAAAAAASYCBAWmAgQFJAIIBaQCCAUkAgwFpAIMBSQCUAWkAlAFJgIMBAEGoxMQACyxKAIEBagCBAUuAkwFrgJMBAAAAAEyAgAFsgIABTICTAWyAkwFMAIYBbACGAQBB4MTEAAsYToCAAW6AgAFOgJMBboCTAU4AhgFuAIYBAEGExcQAC8wBTwCCAW8AggFPAIMBbwCDAU+AhQFvgIUBAAAAAAAAAABSgIABcoCAAVKAkwFygJMBUgCGAXIAhgFTgIABc4CAAVMAgQFzAIEBU4CTAXOAkwFTAIYBcwCGAVSAkwF0gJMBVACGAXQAhgEAAAAAAAAAAFWAgQF1gIEBVQCCAXUAggFVAIMBdQCDAVUAhQF1AIUBVYCFAXWAhQFVAJQBdQCUAVcAgQF3AIEBWQCBAXkAgQFZAIQBWoCAAXqAgAFagIMBeoCDAVoAhgF6AIYBAEHQx8QACwhPgI0Bb4CNAQBBjMjEAAsIVYCNAXWAjQEAQdDIxAALkAFBAIYBYQCGAUkAhgFpAIYBTwCGAW8AhgFVAIYBdQCGAREAAgMRAP8CEQD8AhEA+QIRAPYCEQDzAhEA8AIRAO0CAAAAABEA6gIRAOcCEQDkAhEA4QLGAIIB5gCCAQAAAAAAAAAARwCGAWcAhgFLAIYBawCGAU8AlAFvAJQBEQDeAhEA2wK3AYYBkgKGAWoAhgEAQezJxAALsAFHgIABZ4CAAQAAAAAAAAAATgCAAW4AgAERANgCEQDVAsaAgAHmgIAB2ICAAfiAgAFBgIcBYYCHAUGAiAFhgIgBRYCHAWWAhwFFgIgBZYCIAUmAhwFpgIcBSYCIAWmAiAFPgIcBb4CHAU+AiAFvgIgBUoCHAXKAhwFSgIgBcoCIAVWAhwF1gIcBVYCIAXWAiAFTAJMBcwCTAVQAkwF0AJMBAAAAAAAAAABIAIYBaACGAQBBtMvEAAs4QYCDAWGAgwFFgJMBZYCTAREA0gIRAM8CEQDMAhEAyQJPgIMBb4CDAREAxgIRAMMCWQCCAXkAggEAQZzMxAALwAPm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA3NgAgNzYAIDc2ACA3NgAgOjYAIDY2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDK2ACAytgAgNzYAIDc2ACA3NgAgNzYAIDK2ACAytgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tkAwObZAMDm2ACA5tkAwObZAMDw2ACA5tgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgNzYAIDc2ACAAAAAAObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA6NgAgNzYAIDc2ACA5tgAgOnYAIDq2ACA6tgAgOnYAIDq2ACA6tgAgOnYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAEHsz8QACwS5AgBAAEGU0MQACwQ7AABAAEGs0MQACy+ogIABkYOAAbcAAECVg4ABl4OAAZmDgAEAAAAAn4OAAQAAAAClg4ABqYOAAREAHgBBwNHEAAsbmQOEAaUDhAGxg4ABtYOAAbeDgAG5g4ABEQAVAEGY0sQACxS5A4QBxQOEAb+DgAHFg4AByYOAAQBBvNLEAAsI0oOAAdIDhAEAQfDTxAALEBUEgAEVBIQBAAAAABOEgAEAQYzUxAALBAYEhAEAQaDUxAALDBqEgAEYBIABIwSDAQBB1NTEAAsEGASDAQBB1NXEAAsEOASDAQBBmNbEAAsQNQSAATUEhAEAAAAAM4SAAQBBtNbEAAsEVgSEAQBByNbEAAsMOoSAATgEgAFDBIMBAEGw18QACwh0hIcBdYSHAQBB2NfEAAsU5tgAgObYAIDm2ACA5tgAgObYAIAAQczZxAALCBYEgwE2BIMBAEGI2sQAC6gBEASDATAEgwEQBIQBMASEAQAAAAAAAAAAFQSDATUEgwEAAAAAAAAAANgEhAHZBIQBFgSEATYEhAEXBIQBNwSEAQAAAAAAAAAAGASCATgEggEYBIQBOASEAR4EhAE+BIQBAAAAAAAAAADoBIQB6QSEAS0EhAFNBIQBIwSCAUMEggEjBIQBQwSEASOEhQFDhIUBJwSEAUcEhAEAAAAAAAAAACsEhAFLBIQBAEH028QAC9wB3NgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA3tgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgN7YAIDk2ACA5tgAgArYAIAL2ACADNgAgA3YAIAO2ACAD9gAgBDYAIAR2ACAEtgAgBPYAIAT2ACAFNgAgBXYAIAW2ACAAAAAABfYAIAAAAAAGNgAgBnYAIAAAAAA5tgAgNzYAIAAAAAAEtgAgABBsN/EAAss5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAe2ACAH9gAgCDYAIAAQfjfxAALFCeGKQMnBioDSAYqAyeGKgNKBioDAEHw4MQAC1Qb2ACAHNgAgB3YAIAe2ACAH9gAgCDYAIAh2ACAItgAgObYAIDm2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIAAQYTixAALBCPYAIAAQcTixAALDNUGKgMAAAAAwQYqAwBBkOPEAAts0gYqAwAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAAAAAAAAAADm2ACA5tgAgAAAAADc2ACA5tgAgObYAIDc2ACAAEHE5MQACwQk2ACAAEHA5cQAC2jm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA5tgAgNzYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA3NgAgObYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgABB/OfEAAsk5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAEHE6MQACwTc2ACAAEGg6cQAC2Dm2ACA5tgAgObYAIDm2ACAAAAAAObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIAAQeTqxAALDNzYAIDc2ACA3NgAgABBgOzEAAsk5tgAgObYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDm2ACAAEGk7cQAC9gB5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAANzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIAb2ACAHNgAgB3YAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACAAEGg8MQACwQoCZ4EAEHA8MQACxAwCZ4EAAAAAAAAAAAzCZ4EAEHs8MQACwQH2ACAAEGk8cQACwQJ2ACAAEG08cQACxDm2ACA3NgAgObYAIDm2ACAAEHQ8cQACyAVCZ5EFgmeRBcJnkQcCZ5EIQmeRCIJnkQrCZ5ELwmeRABB4PPEAAsMB9gAgAAAAAAAAACAAEGa9MQACwrBAgAAvwIJ2ACAAEHL9MQACwGAAEHc9MQACxChCd5EogneRAAAAACvCd5EAEHk9cQACwTm2ACAAEG098QACxAyCh5FAAAAAAAAAAA4Ch5FAEHY98QACwQH2ACAAEGQ+MQACwQJ2ACAAEHA+MQACxgWCh5FFwoeRRwKHkUAAAAAAAAAACsKHkUAQcj6xAALBAfYAIAAQYD7xAALBAnYAIAAQc78xAALAr0CAEHa/MQACwq7AgAAuQIJ2ACAAEGH/cQACwWAAAAAgABBnP3EAAsIIQueRSILnkUAQa7+xAALArcCAEHX/8QACwGAAEGCgMUACw61AgAAswIAALECCdgAgABBt4DFAAsBgABB2IHFAAsERgwrBgBB7IHFAAsECdgAgABBjILFAAsIVNgAgFvYAIAAQbqDxQALCq8CAAAAAAAAAIAAQdaDxQALGq0CAACrAgAAAAAAAKgCAQCoAgAAAAAJ2ACAAEGPhMUACwWAAAAAgABBgIbFAAsQCdgAgAnYAIAAAAAAAAAAgABBuobFAAsOpgIAAKQCAACiAgnYAIAAQe+GxQALAYAAQZCIxQALBAnYAIAAQaeIxQALAYAAQdCIxQALGNkN5QYAAAAAAACfAgEAnwIAAJ0CAAAAgABByIrFAAsMZ9gAgGfYAIAJ2ACAAEH0isUACxBr2ACAa9gAgGvYAIBr2ACAAEHkjMUACwx22ACAdtgAgAnYAIAAQZCNxQALEHrYAIB62ACAetgAgHrYAIAAQfCOxQALCNzYAIDc2ACAAEHkj8UACxTc2ACAAAAAANzYAIAAAAAA2NgAgABBkpDFAAsCm0IAQbqQxQALAplCAEHOkMUACwKXQgBB4pDFAAsClUIAQfaQxQALApNCAEGqkcUACwKRQgBByJHFAAtcgdgAgILYAIAA2QDAhNgAgADZAMCyD8BHAAAAALMPwEcAAAAAgtgAgILYAICC2ACAgtgAgAAAAAAAAAAAgtgAgADZAMDm2ACA5tgAgAnYAIAAAAAA5tgAgObYAIAAQdKSxQALAo9CAEH6ksUACwKNQgBBjpPFAAsCi0IAQaKTxQALAolCAEG2k8UACwKHQgBB6pPFAAsChUIAQYSUxQALBNzYAIAAQe6VxQALAoMCAEGPlsUACwGAAEGslsUACxAH2ACAAAAAAAnYAIAJ2ACAAEHwlsUACwTc2ACAAEH/lsUACzmAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQeOXxQALPYAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQdSYxQALCAnYAIAJ2ACAAEGEmcUACwQJ2ACAAEGwmcUACwTm2ACAAEHYmcUACwTk2ACAAEGAmsUACwze2ACA5tgAgNzYAIAAQaiaxQALCObYAIDc2ACAAEHMmsUAC6QB5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAAAAAAAAAANzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA3NgAgAAAAADc2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgObYAIDm2ACA5tgAgObYAIAAQYqcxQALIoECAAAAAAAAfwIAAAAAAAB9AgAAAAAAAHsCAAAAAAAAeQIAQbacxQALAncCAEHsnMUACwgH2ACAAAAAgABBip3FAAsKdQIAAAAAAABzAgBBnp3FAAsScQIAAG8CAAAAAAAAbQIJ2ACAAEHcncUACyTm2ACA3NgAgObYAIDm2ACA5tgAgAAAAAAAAAAACdgAgAnYAIAAQbCexQALZObYAIDm2ACA5tgAgAAAAAAB2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDm2ACAAAAAAAHYAIAB2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAQaSfxQALBNzYAIAAQbifxQALBObYAIAAQcifxQALCObYAIDm2ACAAEHon8UAC5gG5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgOrYAIDW2ACA3NgAgMrYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA5NgAgOTYAIDc2ACA2tgAgObYAIDp2ACA3NgAgObYAIDc2ACAQYCSAWGAkgFCgIMBYoCDAUKAkQFigJEBQoCYAWKAmAERAGoCEQBnAkSAgwFkgIMBRICRAWSAkQFEgJgBZICYAUSAkwFkgJMBRICWAWSAlgERAGQCEQBhAhEAXgIRAFsCRYCWAWWAlgFFAJgBZQCYAREAWAIRAFUCRoCDAWaAgwFHAIIBZwCCAUiAgwFogIMBSICRAWiAkQFIAIQBaACEAUiAkwFogJMBSACXAWgAlwFJAJgBaQCYAREAUgIRAE8CS4CAAWuAgAFLgJEBa4CRAUuAmAFrgJgBTICRAWyAkQERAEwCEQBJAkyAmAFsgJgBTICWAWyAlgFNgIABbYCAAU2AgwFtgIMBTYCRAW2AkQFOgIMBboCDAU6AkQFugJEBToCYAW6AmAFOgJYBboCWAREARgIRAEMCEQBAAhEAPQIRADoCEQA3AhEANAIRADECUICAAXCAgAFQgIMBcICDAVKAgwFygIMBUoCRAXKAkQERAC4CEQArAlKAmAFygJgBU4CDAXOAgwFTgJEBc4CRAREAKAIRACUCEQAiAhEAHwIRABwCEQAZAlSAgwF0gIMBVICRAXSAkQFUgJgBdICYAVSAlgF0gJYBVQCSAXUAkgFVAJgBdQCYAVWAlgF1gJYBEQAWAhEAEwIRABACEQANAlaAgQF2gIEBVoCRAXaAkQFXAIABdwCAAVeAgAF3gIABVwCEAXcAhAFXgIMBd4CDAVeAkQF3gJEBWICDAXiAgwFYAIQBeACEAVmAgwF5gIMBWgCBAXoAgQFagJEBeoCRAVqAmAF6gJgBaICYAXQAhAF3AIUBeQCFAQAAAAB/gYMBAEGQpsUAC+gCQYCRAWGAkQFBgIQBYYCEAREACgIRAAcCEQAEAhEAAQIRAP4BEQD7AREA+AERAPUBEQDyAREA7wERAOwBEQDpAREA5gERAOMBEQDgAREA3QERANoBEQDXAREA1AERANEBRYCRAWWAkQFFgIQBZYCEAUWAgQFlgIEBEQDOAREAywERAMgBEQDFAREAwgERAL8BEQC8AREAuQERALYBEQCzAUmAhAFpgIQBSYCRAWmAkQFPgJEBb4CRAU+AhAFvgIQBEQCwAREArQERAKoBEQCnAREApAERAKEBEQCeAREAmwERAJgBEQCVAREAkgERAI8BEQCMAREAiQERAIYBEQCDAREAgAERAH0BEQB6AREAdwFVgJEBdYCRAVWAhAF1gIQBEQB0AREAcQERAG4BEQBrAREAaAERAGUBEQBiAREAXwERAFwBEQBZAVkAgAF5AIABWYCRAXmAkQFZgIQBeYCEAVmAgQF5gIEBAEGQqcUAC4QIsYOJAbEDigERAOAAEQDcABEA2AARANQAEQDQABEAzACRg4kBkQOKAREAwgARAL4AEQC6ABEAtgARALIAEQCuALWDiQG1A4oBEQBWAREAUwERAFABEQBNAQAAAAAAAAAAlYOJAZUDigERAEoBEQBHAREARAERAEEBAAAAAAAAAAC3g4kBtwOKAREApAARAKAAEQCcABEAmAARAJQAEQCQAJeDiQGXA4oBEQCGABEAggARAH4AEQB6ABEAdgARAHIAuYOJAbkDigERAD4BEQA7AREAOAERADUBEQAyAREALwGZg4kBmQOKAREALAERACkBEQAmAREAIwERACABEQAdAb+DiQG/A4oBEQAaAREAFwERABQBEQARAQAAAAAAAAAAn4OJAZ8DigERAA4BEQALAREACAERAAUBAAAAAAAAAADFg4kBxQOKAREAAgERAP8AEQD8ABEA+QARAPYAEQDzAAAAAAClA4oBAAAAABEA8AAAAAAAEQDtAAAAAAARAOoAyYOJAckDigERAGgAEQBkABEAYAARAFwAEQBYABEAVACpg4kBqQOKAREASgARAEYAEQBCABEAPgARADoAEQA2ALEDgAGxg4BBtQOAAbWDgEG3A4ABt4OAQbkDgAG5g4BBvwOAAb+DgEHFA4ABxYOAQckDgAHJg4BBAAAAAAAAAAARAOcAEQDkABIA4AASANwAEgDYABIA1AASANAAEgDMABEAyQARAMYAEgDCABIAvgASALoAEgC2ABIAsgASAK4AEQCrABEAqAASAKQAEgCgABIAnAASAJgAEgCUABIAkAARAI0AEQCKABIAhgASAIIAEgB+ABIAegASAHYAEgByABEAbwARAGwAEgBoABIAZAASAGAAEgBcABIAWAASAFQAEQBRABEATgASAEoAEgBGABIAQgASAD4AEgA6ABIANgCxA4MBsQOCAREAMwCxg6IBEQAwAAAAAACxA6EBEQAtAJEDgwGRA4IBkQOAAZGDgEGRg6IBAAAAALkDAEAAAAAAqAChAREAKgC3g6IBEQAnAAAAAAC3A6EBEQAkAJUDgAGVg4BBlwOAAZeDgEGXg6IBvx+AAb+fgAG/H6EBuQODAbkDggERACEAEQAeQAAAAAAAAAAAuQOhAREAGwCZA4MBmQOCAZkDgAGZg4BBAAAAAP4fgAH+n4AB/h+hAcUDgwHFA4IBEQAYABEAFUDBg4kBwQOKAcUDoQERABIApQODAaUDggGlA4ABpYOAQaEDigGoAIABqICAQWAAAEAAAAAAAAAAABEADwDJg6IBEQAMAAAAAADJA6EBEQAJAJ8DgAGfg4BBqQOAAamDgEGpg6IBtAAAQAAAAAAAAAAAAiAAQAMgAEAAQcyxxQALNObYAIDm2ACAAdgAgAHYAIDm2ACA5tgAgObYAIDm2ACAAdgAgAHYAIAB2ACA5tgAgObYAIAAQYyyxQALBObYAIAAQZyyxQALLAHYAIAB2ACA5tgAgNzYAIDm2ACAAdgAgAHYAIDc2ACA3NgAgNzYAIDc2ACAAEHgssUACwSpAwBAAEHwssUACwhLAABAEAAHQABBoLPFAAsIkCGcAZIhnAEAQeCzxQALBJQhnAEAQZi0xQALDNAhnAHUIZwB0iGcAQBBtLTFAAsEAyKcAQBByLTFAAsQCCKcAQAAAAAAAAAACyKcAQBB6LTFAAsMIyKcAQAAAAAlIpwBAEGYtcUACyQ8IpwBAAAAAAAAAABDIpwBAAAAAAAAAABFIpwBAAAAAEginAEAQdS1xQALDD0AnAEAAAAAYSKcAQBBiLbFAAs0TSKcATwAnAE+AJwBZCKcAWUinAEAAAAAAAAAAHIinAFzIpwBAAAAAAAAAAB2IpwBdyKcAQBB1LbFAAsoeiKcAXsinAEAAAAAAAAAAIIinAGDIpwBAAAAAAAAAACGIpwBhyKcAQBBrLfFAAsgoiKcAaginAGpIpwBqyKcAXwinAF9IpwBkSKcAZIinAEAQeS3xQALELIinAGzIpwBtCKcAbUinAEAQZi4xQALCAgwAEAJMABAAEHQuMUACwTdKpxBAEH8uMUACxja2ACA5NgAgOjYAIDe2ACA4NgAgODYAIAAQcS5xQALeEuwTBgAAAAATbBMGAAAAABPsEwYAAAAAFGwTBgAAAAAU7BMGAAAAABVsEwYAAAAAFewTBgAAAAAWbBMGAAAAABbsEwYAAAAAF2wTBgAAAAAX7BMGAAAAABhsEwYAAAAAAAAAABksEwYAAAAAGawTBgAAAAAaLBMGABB1LrFAAs4b7BMGG8wTRgAAAAAcrBMGHIwTRgAAAAAdbBMGHUwTRgAAAAAeLBMGHgwTRgAAAAAe7BMGHswTRgAQZy7xQALBEawTBgAQbC7xQALCAjYAIAI2ACAAEHEu8UACwSdsEwYAEH4u8UAC3irsEwYAAAAAK2wTBgAAAAAr7BMGAAAAACxsEwYAAAAALOwTBgAAAAAtbBMGAAAAAC3sEwYAAAAALmwTBgAAAAAu7BMGAAAAAC9sEwYAAAAAL+wTBgAAAAAwbBMGAAAAAAAAAAAxLBMGAAAAADGsEwYAAAAAMiwTBgAQYi9xQALOM+wTBjPME0YAAAAANKwTBjSME0YAAAAANWwTBjVME0YAAAAANiwTBjYME0YAAAAANuwTBjbME0YAEHQvcUACxymsEwYAAAAAAAAAADvsEwY8LBMGPGwTBjysEwYAEH4vcUACwT9sEwYAEGMvsUAC1Tm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAADm2ACAAAAAAObYAIDm2ACA3NgAgAAAAAAAAAAA5tgAgObYAIAAQfS+xQALRebYAIDm2ACAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQBB7L/FAAvcCf3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMBIjABA9GYAQMqOAEDIjABA0W4AQDJOAEDlUwBAnJ8AQJyfAEBRWQBA0ZEAQIdVAEBIWQBA9mEAQGl2AECFfwBAP4YAQLqHAED4iABAj5AAQAJqAEAbbQBA2XAAQN5zAEA9hABAapEAQPGZAECCTgBAdVMAQARrAEAbcgBALYYAQB6eAEBQXQBA628AQM2FAEBkiQBAyWIAQNiBAEAfiABAyl4AQBdnAEBqbQBA/HIAQM6QAECGTwBAt1EAQN5SAEDEZABA02oAQBByAEDndgBAAYAAQAaGAEBchgBA740AQDKXAEBvmwBA+p0AQIx4AEB/eQBAoH0AQMmDAEAEkwBAf54AQNaKAEDfWABABF8AQGB8AEB+gABAYnIAQMp4AEDCjABA95YAQNhYAEBiXABAE2oAQNptAEAPbwBAL30AQDd+AEBLlgBA0lIAQIuAAEDcUQBAzFEAQBx6AEC+fQBA8YMAQHWWAECAiwBAz2IAQAJqAED+igBAOU4AQOdbAEASYABAh3MAQHB1AEAXUwBA+3gAQL9PAECpXwBADU4AQMxsAEB4ZQBAIn0AQMNTAEBeWABAAXcAQEmEAECqigBAumsAQLCPAECIbABA/mIAQOWCAECgYwBAZXUAQK5OAEBpUQBAyVEAQIFoAEDnfABAb4IAQNKKAEDPkQBA9VIAQEJUAEBzWQBA7F4AQMVlAED+bwBAKnkAQK2VAEBqmgBAl54AQM6eAECbUgBAxmYAQHdrAEBijwBAdF4AQJBhAEAAYgBAmmQAQCNvAEBJcQBAiXQAQMp5AED0fQBAb4AAQCaPAEDuhABAI5AAQEqTAEAXUgBAo1IAQL1UAEDIcABAwogAQKqKAEDJXgBA9V8AQHtjAECuawBAPnwAQHVzAEDkTgBA+VYAQOdbAEC6XQBAHGAAQLJzAEBpdABAmn8AQEaAAEA0kgBA9pYAQEiXAEAYmABAi08AQK55AEC0kQBAuJYAQOFgAECGTgBA2lAAQO5bAEA/XABAmWUAQAJqAEDOcQBAQnYAQPyEAEB8kABAjZ8AQIhmAEAulgBAiVIAQHtnAEDzZwBAQW0AQJxuAEAJdABAWXUAQGt4AEAQfQBAXpgAQG1RAEAuYgBAeJYAQCtQAEAZXQBA6m0AQCqPAECLXwBARGEAQBdoAECHcwBAhpYAQClSAEAPVABAZVwAQBNmAEBOZwBAqGgAQOVsAEAGdABA4nUAQHl/AEDPiABA4YgAQMyRAEDilgBAP1MAQLpuAEAdVABA0HEAQJh0AED6hQBAo5YAQFecAECfngBAl2cAQMttAEDogQBAy3oAQCB7AECSfABAwHIAQJlwAEBYiwBAwE4AQDaDAEA6UgBAB1IAQKZeAEDTYgBA1nwAQIVbAEAebQBAtGYAQDuPAEBMiABATZYAQIuJAEDTXgBAQFEAQMBVAEAAAAAAAAAAAFpYAEAAAAAAdGYAQAAAAAAAAAAA3lEAQCpzAEDKdgBAPHkAQF55AEBleQBAj3kAQFaXAEC+fABAvX8AQAAAAAAShgBAAAAAAPiKAEAAAAAAAAAAADiQAED9kABAAEHUycUAC8AF75gAQPyYAEAomQBAtJ0AQN6QAEC3lgBArk8AQOdQAEBNUQBAyVIAQORSAEBRUwBAnVUAQAZWAEBoVgBAQFgAQKhYAEBkXABAblwAQJRgAEBoYQBAjmEAQPJhAEBPZQBA4mUAQJFmAECFaABAd20AQBpuAEAibwBAbnEAQCtyAEAidABAkXgAQD55AEBJeQBASHkAQFB5AEBWeQBAXXkAQI15AECOeQBAQHoAQIF6AEDAewBA9H0AQAl+AEBBfgBAcn8AQAWAAEDtgQBAeYIAQHmCAEBXhABAEIkAQJaJAEABiwBAOYsAQNOMAEAIjQBAto8AQDiQAEDjlgBA/5cAQDuYAEB1YABAEADHQxiCAEAAAAAAAAAAACZOAEC1UQBAaFEAQIBPAEBFUQBAgFEAQMdSAED6UgBAnVUAQFVVAECZVQBA4lUAQFpYAECzWABARFkAQFRZAEBiWgBAKFsAQNJeAEDZXgBAaV8AQK1fAEDYYABATmEAQAhhAECOYQBAYGEAQPJhAEA0YgBAxGMAQBxkAEBSZABAVmUAQHRmAEAXZwBAG2cAQFZnAEB5awBAumsAQEFtAEDbbgBAy24AQCJvAEAecABAbnEAQKd3AEA1cgBAr3IAQCpzAEBxdABABnUAQDt1AEAddgBAH3YAQMp2AEDbdgBA9HYAQEp3AEBAdwBAzHgAQLF6AEDAewBAe3wAQFt9AED0fQBAPn8AQAWAAEBSgwBA74MAQHmHAEBBiQBAhokAQJaJAEC/igBA+IoAQMuKAEABiwBA/ooAQO2KAEA5iwBAiosAQAiNAEA4jwBAcpAAQJmRAEB2kgBAfJYAQOOWAEBWlwBA25cAQP+XAEALmABAO5gAQBKbAECcnwBAEADGQxAAxUMQAMRDnTsAQBhAAEA5QABAEADDQxAAwkMQAMFDQ58AQI6fAEAAQcjPxQALDNkF2kIa2ACA8oXbQgBB/M/FAAvYAemF4ELpBeFCEQAEQBEAAUDQhdtC0AXcQtAF3kLRBd5C0gXeQtMF3kLUBd5C1QXeQtYF3kIAAAAA2AXeQtkF3kLaBd5C2wXeQtwF3kIAAAAA3gXeQgAAAADgBd5C4QXeQgAAAADjBd5C5AXeQgAAAADmBd5C5wXeQugF3kLpBd5C6gXeQtWF3ELRhd9C24XfQuSF30IAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgABBi9LFAAsBwABBsNLFAAsEEQC/AwBBzNLFAAsEEQC9AwBBhNPFAAsM3NgAgAAAAADm2ACAAEGw08UACwzm2ACAAdgAgNzYAIAAQczTxQALBAnYAIAAQeTTxQALCObYAIDc2ACAAEGQ1MUACxDm2ACA5tgAgObYAIDm2ACAAEHE1MUACxTm2ACA5tgAgObYAIDm2ACA5tgAgABBhNXFAAsI5tgAgObYAIAAQaTVxQALQNzYAIDc2ACA5tgAgObYAIDm2ACA3NgAgObYAIDc2ACA3NgAgNzYAIAAAAAAAAAAAObYAIDc2ACA5tgAgNzYAIAAQYzWxQALBAnYAIAAQcjWxQALBAnYAIAAQfTWxQALDBEAuwMAAAAAEQC5AwBBrNfFAAsEEQC3AwBB1NfFAAsICdgAgAfYAIAAQfvXxQALAYAAQZTYxQALCAEAtQMBALMDAEGo2MUACwgJ2ACACdgAgABB3NjFAAsECdgAgABBhNnFAAsEB9gAgABBnNnFAAsICdgAgAfYAIAAQcjZxQALCAfYAIAJ2ACAAEH82cUACxAH2ACAB9gAgAAAAAAAAACAAEG42sUACwwBALEDAQCvAwnYAIAAQdzaxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQYTbxQALDAEArQMAAAAAAQCrAwBBsNvFAAsMAQCpAwAAAAABAKcDAEH328UACwGAAEGD3MUACwGAAEGX3MUACx2AAAAAAAAAAAABAKWDAAAAAAEAo4MBAKGDAAAAgABBxNzFAAsUCdgAgAnYAIAAAAAAAAAAAAnYAIAAQeTcxQALBAfYAIAAQY/dxQALAYAAQbfdxQALIYABAJ8DAQCdAwAAAIABAJsDAAAAAAAAAAAJ2ACAB9gAgABBiN7FAAsIAQCZAwEAlwMAQZzexQALCAnYAIAH2ACAAEHg3sUACwgJ2ACAB9gAgABBi9/FAAsBgABBqN/FAAsEAQCVAwBBvN/FAAsICdgAgAnYAIAAQf/fxQALKYAAAACAAQCMgwEAj4MBAJODAQCQgwEAjYMCAJKDAgCPgwIAjIMAAACAAEG84MUACxgJ2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAQYDhxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQcPhxQALDYABAIqDAQCJAwIAiQMAQeThxQALCAbYAIAG2ACAAEGk4sUACwQB2ACAAEHg4sUACzARAIdDEQB4QxIAhEMSAIFDEgB+QxIAe0MSAHhD2NgAgNjYAIAB2ACAAdgAgAHYAIAAQZzjxQALEOLYAIDY2ACA2NgAgNjYAIAAQczjxQALONzYAIDc2ACA3NgAgNzYAIDc2ACAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACAAEGs5MUACxDm2ACA5tgAgObYAIDm2ACAAEHo5MUACxgRAG9DEQBsQxIAdUMSAHJDEgBvQxIAbEMAQbzlxQALDObYAIDm2ACA5tgAgABB9OXFAAuEAebYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgABBqOfFAAss6NgAgOjYAIDc2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIAAQfjnxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAfYAIAAQajoxQAL+BA9TgBAOE4AQEFOAEAQAGtDYE8AQK5PAEC7TwBAAlAAQHpQAECZUABA51AAQM9QAECeNABAEABqQ01RAEBUUQBAZFEAQHdRAEAQAGlDuTQAQGdRAECNUQBAEABoQ5dRAECkUQBAzE4AQKxRAEC1UQBAEABnQ/VRAEADUgBA3zQAQDtSAEBGUgBAclIAQHdSAEAVNQBAx1IAQMlSAEDkUgBA+lIAQAVTAEAGUwBAF1MAQElTAEBRUwBAWlMAQHNTAEB9UwBAf1MAQH9TAEB/UwBAEABmQ3BwAEDKUwBA31MAQBAAZUPrUwBA8VMAQAZUAECeVABAOFQAQEhUAEBoVABAolQAQPZUAEAQVQBAU1UAQGNVAECEVQBAhFUAQJlVAECrVQBAs1UAQMJVAEAWVwBABlYAQBdXAEBRVgBAdFYAQAdSAEDuWABAzlcAQPRXAEANWABAi1cAQDJYAEAxWABArFgAQBAAZEPyWABA91gAQAZZAEAaWQBAIlkAQGJZAEAQAGNDEABiQ+xZAEAbWgBAJ1oAQNhZAEBmWgBA7jYAQPw2AEAIWwBAPlsAQD5bAEAQAGFDw1sAQNhbAEDnWwBA81sAQBAAYEP/WwBABlwAQFNfAEAiXABAgTcAQGBcAEBuXABAwFwAQI1cAEAQAF9DQ10AQBAAXkNuXQBAa10AQHxdAEDhXQBA4l0AQC84AED9XQBAKF4AQD1eAEBpXgBAYjgAQBAAXUN8OABAsF4AQLNeAEC2XgBAyl4AQBAAXEP+XgBAEABbQxAAW0MBggBAIl8AQCJfAEDHOABAEABaQxAAWUNiXwBAa18AQOM4AECaXwBAzV8AQNdfAED5XwBAgWAAQDo5AEAcOQBAlGAAQBAAWEPHYABASGEAQExhAEBOYQBATGEAQHphAECOYQBAsmEAQKRhAECvYQBA3mEAQPJhAED2YQBAEGIAQBtiAEBdYgBAsWIAQNRiAEBQYwBAEABXQz1jAED8YgBAaGMAQINjAEDkYwBAEABWQyJkAEDFYwBAqWMAQC46AEBpZABAfmQAQJ1kAEB3ZABAbDoAQE9lAEBsZQBAEABVQ+NlAED4ZgBASWYAQBk7AECRZgBACDsAQOQ6AECSUQBAlVEAQABnAECcZgBArYAAQNlDAEAXZwBAG2cAQCFnAEBeZwBAU2cAQBAAVENJOwBA+mcAQIVnAEBSaABAhWgAQBAAU0OOaABAH2gAQBRpAECdOwBAQmkAQKNpAEDqaQBAqGoAQBAAUkPbagBAGDwAQCFrAEAQAFFDVGsAQE48AEByawBAn2sAQLprAEC7awBAEABQQxAAT0MQAE5DTmwAQBAATUO/bABAzWwAQGdsAEAWbQBAPm0AQHdtAEBBbQBAaW0AQHhtAECFbQBAEABMQzRtAEAvbgBAbm4AQDM9AEDLbgBAx24AQBAAS0P5bQBAbm8AQBAASkMQAElDxm8AQDlwAEAecABAG3AAQJY9AEBKcABAfXAAQHdwAECtcABAEABIQ0VxAEAQAEdDnHEAQBAARkMocgBANXIAQFByAEAQAEVDgHIAQJVyAEAQAERDEABDQ3pzAECLcwBArD4AQKVzAEC4PgBAuD4AQEd0AEBcdABAcXQAQIV0AEDKdABAGz8AQCR1AEAQAEJDPnUAQBAAQUNwdQBAEABAQxB2AEAQAD9DEAA+QxAAPUP8PwBACEAAQPR2AEAQADxDEAA7QxAAOkMQADlDHncAQB93AEAfdwBASncAQDlAAECLdwBARkAAQJZAAEAQADhDTngAQIx4AEDMeABA40AAQBAAN0NWeQBAEAA2QxAANUOPeQBA63kAQC9BAEBAegBASnoAQE96AEAQADRDEAAzQxAAM0PuegBAAkIAQBAAMkPGewBAyXsAQCdCAEAQADFD0nwAQKBCAEDofABA43wAQAB9AEAQADBDY30AQAFDAEDHfQBAAn4AQEV+AEA0QwBAEAAvQxAALkNZQwBAEAAtQ3p/AEAQACxDlX8AQPp/AEAFgABAEAArQxAAKkNggABAEAApQ3CAAEAQAChD1UMAQLKAAEADgQBAC0QAQD6BAEC1WgBAEAAnQxAAJkMQACVDEAAkQwGCAEAEggBAno8AQGtEAECRggBAi4IAQJ2CAECzUgBAsYIAQLOCAEC9ggBA5oIAQBAAI0PlggBAHYMAQGODAECtgwBAI4MAQL2DAEDngwBAV4QAQFODAEDKgwBAzIMAQNyDAEAQACJDEAAhQxAAIEMrRQBA8YQAQPOEAEAWhQBAEAAfQ2SFAEAQAB5DXUUAQGFFAEAQAB1DEAAcQ2tFAEBQhgBAXIYAQGeGAEBphgBAqYYAQIiGAEAOhwBA4oYAQHmHAEAohwBAa4cAQIaHAEDXRQBA4YcAQAGIAED5RQBAYIgAQGOIAEAQABtD14gAQN6IAEA1RgBA+ogAQLs0AEAQABpDEAAZQ75GAEDHRgBAoIoAQO2KAECKiwBAVYwAQBAAGEOrjABAwYwAQBuNAEB3jQBAEAAXQxAAFkPLjQBAvI0AQPCNAEAQABVD1I4AQDiPAEAQABRDEAATQ5SQAEDxkABAEZEAQBAAEkMbkQBAOJIAQNeSAEDYkgBAfJIAQPmTAEAVlABAEAARQ4uVAECVSQBAt5UAQBAAEEPmSQBAw5YAQLJdAEAjlwBAEAAPQxAADkNuSgBAdkoAQOCXAEAQAA1DskoAQBAADEMLmABAC5gAQCmYAEAQAAtD4pgAQDNLAEApmQBAp5kAQMKZAED+mQBAzksAQBAACkMSmwBAQJwAQP2cAEDOTABA7UwAQGedAEAQAAlD+EwAQBAACEMQAAdDEAAGQ7ueAEBWTQBA+Z4AQP6eAEAFnwBAD58AQBafAEA7nwBAEAAFQwBBrPnFAAsbzA8RAEYHAAAAAAAAWB4RAJQXAAAAAAAAAPwCAEHQ+cUAC4kFMAB8AQEAAAAAAwAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogAADcfBEAKgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAAeG4tLVB1bnljb2RlIG92ZXJmbG93cyBzaG91bGQgbm90IGJlIHBvc3NpYmxlIGR1ZSB0byBQVU5ZQ09ERV9FTkNPREVfTUFYX0lOUFVUX0xFTkdUSAAAADR9EQBRAAAAJpcQAFgAAAC7AQAACQAAAC5pbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlAAAAJpcQAFgAAABIAgAAMAAAACaXEABYAAAANAMAAEAAAAAmlxAAWAAAAE4DAAAlAAAAJpcQAFgAAACFAwAAJQAAACaXEABYAAAAmwMAAEQAAAAmlxAAWAAAAHQDAABEAAAAJpcQAFgAAADsBAAALQAAAHgAAABuAAAALQAAAC0AAAAmlxAAWAAAAPAEAAA3AAAAJpcQAFgAAAAXBQAAMgAAACaXEABYAAAAIAUAADsAAAAmlxAAWAAAADsFAAA2AAAAJpcQAFgAAABGBQAAMwAAACaXEABYAAAACgUAACUAAAAmlxAAWAAAANIEAAAvAAAAJpcQAFgAAACYBAAANwAAACaXEABYAAAA7wUAACwAAADOdRAAagAAAF8DAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogY29kZV9wb2ludCA8IHNlbGYuaGVhZGVyLmhpZ2hfc3RhcnQgJiYgc2VsZi5oZWFkZXIuaGlnaF9zdGFydCA+IFNNQUxMX0xJTUlUAAAAw28QAHIAAAAsAQAADQBBgP/FAAuVK/z8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8VFRUVFRUVFRUVFRUVFRUVJSUlJSUlJSUlJSUlJSUlJSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpPz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/PwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQCAgICAgICAgICAgIIAgIQAgICIAEBAQEBAQEBAQEBAAAQAB/AL8A9wD3APcA9wD3APcA/gA8AXwBjAHLAdUB9wD3ABIC9wD3APcASAKGAsYC+wIsA1YDkAPFA98DHwRdBIsEuwTxBC4FbQWsBesFKgZpBioGqAboBiYHZAekB+QHIwisBWIIhAjDCAIJOAlPCY8JngkNAtsJGQpTCqcF2QjzCAEJFwk3CVIJagmJCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCcoJqQmpCaoJqQmpCakJqgmpCakJqQmqCQAAEAAgADAAQABQAGAAcAB/AI8AnwCvAL8AzwDfAO8A9wAHARcBJwH3AAcBFwEnAfcABwEXAScB9wAHARcBJwH+AA4BHgEuATwBTAFcAWwBfAGMAZwBrAGMAZwBrAG8AcsB2wHrAfsB1QHlAfUBBQL3AAcBFwEnAfcABwEXAScBEgIiAjICQgL3AAcBFwEnAfcABwEXAScB9wAHARcBJwFIAlgCaAJ4AoYClgKmArYCxgLWAuYC9gL7AgsDGwMrAywDPANMA1wDVgNmA3YDhgOQA6ADsAPAA8UD1QPlA/UD3wPvA/8DDwQfBC8EPwRPBF0EbQR9BI0EiwSbBKsEuwS7BMsE2wTrBPEEAQURBSEFLgU+BU4FXgVtBX0FjQWdBawFvAXMBdwF6wX7BQsGGwYqBjoGSgZaBmkGeQaJBpkGKgY6BkoGWgaoBrgGyAbYBugG+AYIBxgHJgc2B0YHVgdkB3QHhAeUB6QHtAfEB9QH5Af0BwQIFAgjCDMIQwhTCKwFvAXMBdwFYghyCIIIkgiECJQIpAi0CMMI0wjjCPMIAgkSCSIJMgk4CUgJWAloCU8JXwlvCX8JjwmfCa8JvwmeCa4JvgnOCQ0CHQItAj0C2wnrCfsJCwoZCikKOQpJClMKYwpzCoMKpwW3BccF1wX3APcAPQqTCvcAogobAq8KvQqgBfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcAPQr3APcA9wDNCvcA9wD3APcA9wD3AEAA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDdCiwB9wD3APcA9wD3APcA9wDrCvcAjQX3AI0F9wCNBfcA9wD3APcKegkBC/cAzQoRC/cA9wD3APcA9wD3APcAigX3AKQF9wD3APcA9wD3APcA9wAgCy4LPgv3APcA9wD3APcA9wD3APcATQBrAWsB9wBHC/cA9wD3AFMLYQtuC/cA9wD3AHwBrQH3APcA9wAYAvcA9wB+C6sF9wA/ChgCGgL3AIwL9wD3APcAmgsaAvcA9wA+CqkL9wD3APcA9wD3APcA9wD3APcAaAq5C8IL9wD3APcA9wD3APcA9wD3APcA9wD3APcAfAF8AXwBfAH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDMC9sLTgBOACoB6wtrAfsLCwwXDBwMLAw8DEwM9wBcDFwMXAx8AXwBGwJsDHgMhgwtAZYMawH3APcApAxrAWsBawFrAWsBawFrAbQMawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrATsA9wD3APcAUABrAWUBawFrAWsBawFrAWsBzQr3AFEB9wBrAWsBvAzEDPcA9wD3APcAUQBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsB1AxrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AGsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFIAWsBZAFrAWsBawFrAWsBawH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA5AzzDPcA9wD3APcA9wD3APcAWQX3APcA9wD3APcA9wB8AXwBawFrAWsBawFrAT4B9wD3AGsB/AxrAWsBawFrAWsBPQBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrATsA9wBrAQwNawEbDSsN9wD3APcA9wD3ADsNQAD3APcA9wD3AMsA9wD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAUsN9wAqAfcA9wD3AGsB9wBbDfcA9wD3AGoBTwD3APcA9wD3APcA9wD3APcA9wD3AGoN9wD3APcA9wD3AE0A9wBMAPcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBrAWsBawFrAfcA9wD3APcA9wD3APcA9wD3AGsBawFrAVsI9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBOAPcA9wD3APcA9wBZBXoN9wD/BfcA9wD3APcA9wAaAmsBawE/APcA9wD3APcA9wDOAPcA9wD3APcA9wD3APcAig33AJYNFQb3APcA9wCcDPcA9wD3APcAiwX3AHwBpg33APcAkAn3AEMKGgL3APcAGQL3APcAsg33APcAqAX3APcAwA3PDdwN9wD3AKEF9wD3APcA7A2sBfcAAQanBfcA9wD3APcA9wD3AC0B9wD3APcA9wD3APcA9wD8DfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wAKDhkOjgKOAiwDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDKQ5rASwDLAMsAywDLAMsAywDOQ6FAIUAOw58Ac0KfAFrAWsBSw5bDiwDLAMsAywDLAMsAywDLANrDnsOMABAAFAAQABQADsA9wD3APcA9wD3APcA9wCLDpsO9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDVAPcA9wD3AGsBawFrAWsBTwFPAUAA9wD3APcA9wCgBfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCrDsQM9wD3APcA9wD3APcA9wC7DvcA9wD3APcA9wD3APcA9wCOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4Cyw6OAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4C2w6OAo4C6w6OAo4CjgKOAo4CjgKOAo4CjgKOAvsOjgKOAo4CjgICD44CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CLAMsAxIPIg8yD44CPA+OAo4CjgKOAo4CjgKOAo4CjgJMD00PjgKOAlwPjgIsAywDLAP6Ao4CjgKOAiwDAAPgAiwDjgJqD44CjgKOAo4CjgKOAo4CrAX3APcAQgoVAjwBOwB6DxoC9wD3AIYPqwX3APcA9wAZAvcAkQ8XAvcA9wD3AKoFGgL3APcAoQ+AD/cA9wD3AFkFrg+sBfcA9wD3APcA9wD3APcA9wBZBZMJ9wAaAvcA9wACBhsC9wAPAhcC9wD3APcAPwqnDecGjgX3APcA9wBCCkgJWgX3APcA9wD3APcAvQ8pBvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDKDxsCAQb3APcA9wDaDxsC9wBPAfcA9wD3AF0F4gb3APcA9wD3APcAWwXqD/cA9wD3APcA9wD3APcA9wD3APcA9wD3APcAWQVQCvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APYPqgX3APcA9wD3APcA9wD3APcAhQ8bAvcABRD3APcAEhCmBSEQ9wD3AEAKMRD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AEEQ9wD3APcA9wD3AEgKURBgEPcA9wD3APcA9wD3APcAbxDiBvcA9wD3APcAfhD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCMBRoC9wD3ALsO5wajBfcA9wD3APcA9wD3APcAiRCYED8A9wD3APcA9wCgDxYC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AP8FqBD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wAXAvcA9wD3ABUC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AFkF9wD3APcAWQUZAvcA9wD3APcAuBD3APcA9wD3APcA9wD3APcA9wAABsgQ9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAWsBawFrAWsBawFrAWsBawFrAWsBawE7APcAsQ5rAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAT0A9wD3APcA9wB8AXwBrgF8ARUC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDmCtUQ4hD3AH8P9wD3APcALgH3AGsBawFrAWsB8hD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAWsBawFrAVsI9wD3APcA9wD3APcA9wD3APcA9wD3APcA1QDLAPcAywD3ANEA9wDRAEwA9wBMAPcAzQD3AM0A9wD/EA0RDRENEXwBfAF8AR0RfAF8Aa8BqAWpBT8Kawr3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBkCigRNhH3APcA9wD3APcAWQX3APcA9wD3APcA9wD3APcA9wD3ABUC9wD3APcA9wD3APcA9wD3APcA9wD3APcAWgX3APcA9wA+CkER9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wA+CvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AP8F9wCOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAlERjgKOAo4CjgKOAo4CXRGOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CLAMsAywDLAMsA44CjgKOAo4CLAMsAywDLAMsA44CjgKOAo4CjgKOAo4CjgKOAo4CjgIsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAM3Do4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CawFrAVABawFrAWsBawFrAWsBPQBtEWoBagFqAWsBOwB9EfcATAD3APcA9wBRAPcA9wD3AMkA9wD3APcA9wD3APcAOwD3APcA9wD3APcA9wD3APcA9wBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBiBFPAU8BawFrAWsBawFrAWsBawGJEWsBawFrAWsBawHNClABQABQAWsBawFrARQNzQprAWsBFA1rAT4BUAE/APcA9wD3AGsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBPQA+AU8BUgFrAWsBawGUET8BzQqiEWsBawFrAWsBawFrAWsBawFrAWcBawFrAWsBawFrAbEO9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCrEYUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIQAnAC8ANwA/AAcATwBXAF8AYcBpwG/Ad8B/wEfAj8CXwJ+ApwCsgLSAuICAgMiA0IDYQOBA4EDgQOBA4EDgQOFA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDpQPFA+UDBASBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDIwQ4BFgEeASYBIEDgQO4BNgE7AQGBSYFRAVjBYEFnwW/BdwF9gWBA4EDgQOBA4EDgQOBA4EDgQOBAxYGgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQMlBoEDgQOBA4EDOAaBA0wGgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDawaBA4EDgQOBA4EDgQOLBqAGtQbVBoED6waBAwsHgQOBAysHQQdTB4EDcweIB6EHwQfhB/wHDAgfCD8IWgiBA3oIgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA3oImgi5CLkIuQi5CLkIuQi5CIEDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBAxISEhISEhISEggHCAkHEhISEhISEhISEhISEhIHBwcICQoKBAQECgoKCgoDBgMGBgICAgICAgICAgIGCgoKCgoKAEGvqsYACwYKCgoKCgoAQc+qxgALRAoKCgoSEhISEgcSEhISEhISEhISEhISEhISEhISEhISEhISEgYKBAQEBAoKCgoACgoSCgoEBAICCgAKCgoCAAoKCgoKAEGqq8YACwEKAEHKq8YACwEKAEGLrMYAC5wBCgoAAAAAAAoKCgoKCgoKCgoKCgoKAAAKCgoKCgoKCgoKCgoKCgAAAAAACgoKCgoKCgoKAAoKCgoKCgoKCgoKCgoKCgoKEREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREQAAAAAKCgAAAAAAAAAACgAAAAAKCgAKAEHfrcYACwEKAEHprcYACwcRERERERERAEGmrsYAC98FCgAACgoEAREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREQEREQEREQERAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEFBQUFBQUKCg0EBA0GDQoKERERERERERERERENDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERERERERERERERERBQUFBQUFBQUFBQQFBQ0NDRENDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NEREREREREQUKERERERERDQ0REQoRERERDQ0CAgICAgICAgICDQ0NDQ0NDQ0NDQ0NDQ0NDQ0RDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NEREREREREREREREREREREQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERENDQ0NDQ0NDQ0NDQ0NDQ0BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBERERERERERERAQEKCgoKAQEBEQEBAQEBAQEBAQEBAQEBAQEBAQEBAQERERERAREREREREREREQEREREBEREREREBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBERERAQEBAQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NBQUNDQ0NDREREREREREREQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERERERERERERERERERERBRERERERERERERERERERERERERERERERERERERERAEG8tMYACx0RABEAAAAREREREREREQAAAAARAAAAEREREREREQBB47TGAAsCEREAQYG1xgALAREAQby1xgALEREAAAARERERAAAAAAAAAAARAEHhtcYACwIREQBB8bXGAAsQBAQAAAAAAAAABAAAEQAREQBBurbGAAsVEQAAABERAAAAABERAAAREREAAAARAEHttsYACwYREQAAABEAQf22xgALDRERERERABERAAAAABEAQZ63xgALAhERAEGtt8YACxEEAAAAAAAAAAAREREREREAEQBB+LfGAAsZEQAAEREREQAAAAAAAAAAEQAAAAAAAAAREQBBnLjGAAsCEREAQbq4xgALAREAQfi4xgALAREAQYW5xgALAREAQau5xgALEgoKCgoKCgQKAAAAAAARAAAAEQBB9LnGAAsaEQAREQAAAAAAERERABEREREAAAAAAAAAEREAQZm6xgALAhERAEGvusYACwcKCgoKCgoKAEHCusYACwIREQBB2LrGAAsCEREAQZO7xgALEhERAAAAEREREQAAAAAAAAAAEQBBubvGAAsCEREAQde7xgALAREAQZa8xgALDREAAAAAAAAAERERABEAQdS8xgALHhEAABEREREREREAAAAABAAAAAAAAAAREREREREREQBBo73GAAsMEQAAERERERERERERAEHHvcYACwIREQBB5L3GAAsJEQARABEKCgoKAEGevsYAC2oREREREREREREREREREQAREQAAAAAAEREREREREREREREAERERERERERERERERERERERERERERERERERERERERERERERERAAAAEQAREREREREAEREAABERAAAAAAAAAAAREQAAAAARERERAEGTv8YACx8RAAAREQAAAAAAABEAAAoKCgoKCgoKCgoAAAAAAAAJAEHBv8YACwMREREAQc+/xgALSRERABEREREREREAAAAAAAAABAARAAAKCgoKCgoKCgoKChERERIREREAAAAAEREAAAAAAAAAEQAAAAAAABEREQAAAAAKAAAACgoAQaLAxgALfhERAAARAAAAAAAAEQARERERERERABEAABERERERERERAAAAEREREREREREREQAAEQAAAAARABERERERABEAAAARERERAAAREQAREREAAAAAAAARABERAAAAEQARERERAAAREQAAAAAAAAAAEQARERERERERAAAAABEAAAAREQBBrcHGAAsECgAKCgBBvMHGAAu8AQoKCgkJCQkJCQkJCQkJEhISAAEKCgoKCgoKCgkHCw4QDA8GBAQEBAQKCgoKCgoKCgoKCgYKCgoKCgoKCgoKCgoKCgoJEhISEhISFBUTFhISEhISEgIAAAACAgICAgIDAwoKCgACAgICAgICAgICAwMKCgoABAQEBAQEBAQEBAQEBAQEBAoKAAoKCgoACgoAAAAAAAAKAAoKCgAAAAAACgoKCgAKAAoACgAAAAAEAAoKCgoKAAAAAAAKCgoKAEGBw8YAC28KCgoAAAAACgoDBAoKCgoKCgoKCgoKCgICAgICAgICAgICAgAAAAAKCgoKCgoKCgoKCgoACgoKAAAAAAAKCgoKCgoAAAAAEREAAAAAAAAACgoKCgoKCgoKCgAKCgoKCgkKCgoKAAAACgoKCgoKCgoAQfnDxgALFhEREREAAAoAAAAAAAoKAAAAAAAKCgoAQZjExgALDRERCgoAAAAKCgoKCgoAQa7ExgALAQoAQbvExgALQQoKCgAAAAAAAAAKCgoKAAAAAAAREREKEREREREREREREQoKAAARAAAAEQAAAAARAAAAAAAREQAKCgoKEQAAABERAEGJxcYACwsRAAARERERAAAREQBBncXGAAsNERERERERABERAAAREQBBs8XGAAsrEQAAAAAAAAAAEQAAABEAERERAAAREQAAAAAAEREAAAAAABEAABEAAAAAEQBB68XGAAvoAgERAQEBAQEBAQEBAwEBAQEBAQ0NDQ0NDQ0NDQ0NDQ0NCgoNDQ0NDQ0NDQ0NDQ0NDQ0KCgoGCgYACgYKCgoKCgoKCgoECgoDAwoKCgAKBAQKAAAAAA0NDQ0NDQ0NDQ0NDQ0NDRIACgoEBAQKCgoKCgMGAwYGBAQKCgoEBAAKCgoKCgoKABISEhISEhISEgoKCgoKEhIRAgICAgICAgICAgICAgICAAAAAAAAEREREREAAAAAAAEBAQEBAQEBAQEBAQEBAQoBERERARERAQEBAQERERERAQEBAQEBAQEREREBAQEBEQEBAQEBEREBAQEBAQEBAQEKCgoKCgoKDQ0NDRERERENDQ0NDQ0NDQUFBQUFBQUFBQUNDQ0NDQ0FBQUFBQUFBQUFAQEBAQEBAQEBEREREREKAQUFBQUFBQUFBQUFBQUFBQUBAQEBAQEBAQEBARERAQEBEREREQEBAQEBAQEBAQERAAAREQBB3cjGAAttEREREQAAEREAAAAAAAAAEREREREAERERAAAAAAAAERERERERERERAAARABERAAAAAAAAEQAAABEREREREQARAAAAABEREREAAAAAAAAREQARAAAAEREREREREREAABEAEQAAEREREQAREREREQBB1cnGAAtmEREAEQAREREREREAABERAAAAAAAREREREREAABEREREAERERERERAAAREREAAAAAEREREREREQAREQAAAAAAABEREREREREAERERERERAAAREREREREREQAAERERERERABERABERAEHEysYAC00REREREREAAAARABERABERAAAAEQARAAAAAAAAAAAKCgoKCgoKCgQEBAoKCgoKCgoKCgoKCgoKChEREREREREREREAAAAREREAAAoAEQBBnMvGAAsEEhISEgBBrMvGAAsgEhISEhISEhIREREREQAAEREREREREQAAAAAKChEREQoAQdbLxgALAQoAQeHLxgALNAICAgICAgICAgICAgICAgIRERERERERAAAAABEREREREREREQAAEREREREAEREAEREREREAQaTMxgALWwQRERERERERAQEBAQEBAQEBEREREREREQEBAQEBCgoKCgoKCgoKCgoKCgoKAAICAgICAgICAgICCgoKCgoKCgoAAAAACgoKCgoKCgAAAAAAAAAKCgoKCgoKCgoAQY3NxgALLBISAACBEQDqCQAAAAAAANSUEQC8EQAAAAAAAAAAEQD3AAAAAAAAABABgQMBAEHCzcYAC+1BQAB/AL8A/wAuAW0BrQHlASQCUAKOAs4C3gIeA08DjAO8A/oDOgRKBHsEsgTyBDIFcgWjBc8FDwZEBl4GngbeBh4HVgeNB8oHCQhICIcIxggFCUQJgwnDCQEKPwp/Cr8K/go+C34Lvgv9Cz0MfQy8DPwMOw17DbsN+w07DnkOTAxmDHYMjAysDMsM6AwHDScNJw00DVENcQ2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDaMNgw2DDYMNww3DDcMNxA3DDcMNww3EDQAAEAAgADAAQABQAGAAcAB/AI8AnwCvAL8AzwDfAO8A/wAPAR8BLwEuAT4BTgFeAW0BfQGNAZ0BrQG9Ac0B3QHlAfUBBQIVAiQCNAJEAlQCUAJgAnACgAKOAp4CrgK+As4C3gLuAv4C3gLuAv4CDgMeAy4DPgNOA08DXwNvA38DjAOcA6wDvAO8A8wD3APsA/oDCgQaBCoEOgRKBFoEagRKBFoEagR6BHsEiwSbBKsEsgTCBNIE4gTyBAIFEgUiBTIFQgVSBWIFcgWCBZIFogWjBbMFwwXTBc8F3wXvBf8FDwYfBi8GPwZEBlQGZAZ0Bl4GbgZ+Bo4GngauBr4GzgbeBu4G/gYOBx4HLgc+B04HVgdmB3YHhgeNB50HrQe9B8oH2gfqB/oHCQgZCCkIOQhICFgIaAh4CIcIlwinCLcIxgjWCOYI9ggFCRUJJQk1CUQJVAlkCXQJgwmTCaMJswnDCdMJ4wnzCQEKEQohCjEKPwpPCl8Kbwp/Co8KnwqvCr8KzwrfCu8K/goOCx4LLgs+C04LXgtuC34LjgueC64LvgvOC94L7gv9Cw0MHQwtDD0MTQxdDG0MfQyNDJ0MrQy8DMwM3AzsDPwMDA0cDSwNOw1LDVsNaw17DYsNmw2rDbsNyw3bDesN+w0LDhsOKw47DksOWw5rDnkOiQ6ZDqkOowWjBbkOyA7YDugO9w4GDxQPJA9BAEEANA9hAGEARA+jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBVQPZA+jBaMFVA+jBaMFXA9sD+EKowWjBaMFbA+jBaMFowV0D4QPjQ+jBZ0PQQBBAEEAQQBBAK0PvQ+jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBcAPowXQD9UPowWjBaMFowXlD/QPowUEEKMFExCjBSMQZAgzEKMFowWjBUMQURBdECQLbRB9ECQLowWjBY0QowWjBZQQpBCjBasQowWjBaMFowW7EKMFDgXLENsQ6xCjBQ8F+xCjBaMFEQWjBZMQCxEZERkRowUpEaMFowWjBTkRSRFWESQLJAtmEXYRQAYYDRgNGA3JB6MFowWGEZQR2A6jEa8RywejBb8RngajBaMFzRHcEaMFowXsEfgRCBKeBqMFFRIlEkEAQQA1EkUSVRJkEm0SYQBhAHQCgAKAAoACfRKIEmEAdQKAAoACzgLOAs4CzgL/AP8A/wD/AP8A/wD/AP8A/wCYEv8A/wD/AP8A/wD/AKcStxKnEqcStxLHEqcS1xLnEucS5xL3EgYTFhMmEzYTRhNWE2YTdhOFE5MToxOzE8MT0xPjE+MT8hMCFBEUIBQwFEAUThReFG4UfhSOFI4UmxSrFLsUGRHKFNoUGRHmFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU+hQZEQoVGREZERkRGREVFRkR3xTqFCUVGREpFTcVGREZEZ0PGA08FRgNfhR+FH4UTBUZERkRGREZEVgVfhQZERkRGREZERkRGREZERkRGREZERkRwhTIFBkRGRHiFBkRGREZERkRGREZEWgVGREZERkRGREZERkRGREZERkRGREZERkRGREZERkReBWCFX4UZBUZERkRkhXqFJwV6hQZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZEeoU6hTqFOoU6hTqFOoU6hSfFacV6hTqFOoUsBXqFLwV6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hQZERkRGRHqFMoVGREZEdcVGRHhFRkRGREZERkRGREZEUEAQQBBAGEAYQBhAPEVABb/AP8A/wD/AP8A/wAPFh4WYQBhAC4WowWjBaMFPhZOFqMFXhZqCGoIaghqCM4CzgJuFnwWjBacFqwWvBYYDRgNGRHdFRkRGREZERkRGRHMFhkRGREZERkRGREZERkRGREZERkRGREZERkR3BYYDRkR7Bb6FgoXGhcBBaMFowWjBaMFKhe9D6MFowWjBaMFORf9BKMFowUBBaMFowWjBaMFDgVJF6MFowUZERkRUxejBRkRYhdOFRkRchd9FBkRGRFOFRkRGRF9FBkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGRGjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFGREZERkRGRGjBW0FowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFEAUZERkRGRFSF6MFowUVEqMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFghejBZIXGA3/AP8AoheyF/8AwhejBaMFowWjBdIX4he9AvIXAhj9AP8A/wD/ABIYIBgwGDYYQBhMGFwYGA1qGHgYowWFGJUYowWjBaMFpRi1GKMFowXBGM0YJAvOAt0YngajBe0YowV2Bf0YowUQBcoHowWjBQ0ZHBksGTwZ8RCjBaMFQxlSGWIZchmjBYIZowWjBaMFkhmiGacZtxnHGdYZuhBqCGEAYQDmGfYZYQBhAGEAYQBhAKMFowUGGiQLowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZcNowUWGqMFowURBSYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowUPBaMFowWjBaMFowWjBZMQGA0YDUYaUxpiGmwafBqjBaMFowWjBaMFowWKGpca/wSjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBacaGRGjBaMFowWjBQAFowWjBbcaGA0YDccazgLXGs4C5xrzGgMbEhvjCqMFowWjBaMFowWjBaMFIhsyGzAAQABQAGAAQhtSG2IbowVkG6MFDgXVGXQbhBuTG2UIowXhCqMbDwUPBRgNGA2jBaMFowWjBaMFowWjBT4Hsxt+FH4Ulg+OFI4UjhTDG8wbOhXaGxgNGA0ZERkR6hsYDRgNGA0YDRgNGA0YDRgNowUQBaMFowWjBZMJ+hv+G6MFowUGHKMFFRyjBaMFJRyjBTUcowWjBUUcVRwYDRgNQQBBAEIDYQBhAKMFowWjBaMFDwUkC0EAQQBlHGEAbRyjBaMFfRyjBaMFowWBHDUDNQORHJ8crRyjBaMFowWXDaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFXhajBbsQfRwYDb0cgAKAAsIcGA0YDRgNGA3SHKMFowXcHKMF6xyjBfscowUOBQsdGA0YDRgNowUbHaMFKx2jBTsdGA0YDRgNGA2jBaMFowVLHX4UWx1+FH4Uax1OCaMFex0BHIsdowWbHaMFqx0YDRgNux2jBcYd1h2jBaMFowXmHaMF9h2jBQYeowUWHiMeGA0YDRgNGA0YDaMFowWjBaMFlBAYDRgNGA1BAEEAQQAzHmEAYQBhAEMeowWjBVMeJAtjHkEAcx5hAIMeGA0YDRgNGA0YDRgNGA1+FPsbowWjBZMemQ2hHhgNGA32E6MFqx2xHqMFdwXBHhgNowXRHhgNGA2jBeEeGA2jBV4W8R6jBaMFdQUBH1sdER8hH8sHowWjBTEfPx+jBZQQJAtzB6MFTx+FDV8fowWjBW8fywejBaMFfx+OH54frh+5H6MFVAnJH9gf5x8YDRgNGA33H2MIBiCjBaMFMAYWICQLJiBYCGgINSBFIFUgYyAcFHMgowWjBYMgkiCiILEgGA2jBaMFowXBINEg4SCZDRgNowWjBaMF8SAAISQLGA0YDRgNGA0YDRgNGA0YDRgNGA2jBaMFECEfIS4hNiEYDRgNowWjBaMFRiFVISQLZSEYDaMFowV1IYUhJAuVIaEhGA2jBbEhwSHRIV4WGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowXJH+EhGA0YDRgNGA0YDRgNQQBBAGEAYQAjDPEhACIMIqMFHCIsIiQLGA0YDRgNGA08IqMFowVLIlsiGA1rIqMFowV4IocilyKjBaMFcwWnIrUiowWjBaMFowWUEMUiGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowXVIiQLaAijBRAh5SL1IiMMjQ9QBaMFKg4FIxQjGA0YDRgNGA1uCaMFowUkIzMjJAtDI6MFTSNdIyQLGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFbSN9I1UJowWJIywhmSMYDRgNGA0YDRgNkwl+FKkjuCPGI6MFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFkxAYDRgNGA0YDRgNGA2OFI4UjhSOFI4UjhTWI+YjowWjBaMFowWjBaMFowWjBaMFowWjBaMFlw0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFowWjBaMF9iOjBaMFowUGJBYkGxSjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBT4HowWjBaMFowVeFhgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFMQYdJCQLGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFlBCjBQ4FLBmjBaMFowWjBQ4FJAujBQ8FKiSjBaMFowU6JEokWiRoJEEHowUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNeCSjBX0kJAsYDRgNGA0YDRgNGA0YDRgNQQBBAGEAYQB+FI0kGA0YDRgNGA0YDRgNowWjBaMFowUdDp0kniSeJKYktSQYDRgNGA0YDcMk0ySjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBX0cowWjBaMFowWjBaMFowWjBaMFowWjBaMFowW7EBgNlAmUEBgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgN4ySjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWYDZEJGA3zJP8kowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFEQUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowWjBaMFowWjBT4HEAWUEA8lHyUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0ZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREkCxkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRzBYYDRgNGA0YDc4CzgJBBs4CGhQZERkRGREZERkRGREZEcwWGA0YDRgNGREZERkRGREZERkRGREZERkRGREZERkRGREZERkR3BYZERkRLyUZERkRGRE6JUclVCUZEWAlGREZERkRPBUYDRkRGREZERkRbiUYDRgNGA0YDRgNGA0YDX4UfiV+FH4lGREZERkRGREZEVIXfhQBHBgNGA0YDRgNGA0YDRgNGA1BALIDYQCOJa4DnBynEkEA3ACeJa4lvCWdHEEAsgNhAMkl1iVhAOQl9CUDJgcmQQDYAGEAQQCyA2EAjiWuA2EApxJBANwAByZBANgAYQBBALIDYQAXJkEAJibrAIoDNiZhAEImQQAiJucAMCbHAGEA7QBBAE4mYQBbJpUhlSGVIRkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGRHOAs4CzgJrJs4CzgJ2JoMmjyb3E8IEGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNWgKfJq4mGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA1MDr4mzCaAAoACgALcJhgN8xMYDRgNGA0YDRgNGA0YDaMFowUQBewm/CYYDRgNGA0YDRgNGA0YDRgNGA0YDRgNowUMJxgNowWjBTMGHCcYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFiwckCxgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowUxBiwnGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNPCcOBaMFowWjBaMFowWjBaMFowWjBaMFowWjBUwnGhQYDRgNQQBBANwAYQBcJywZGA0YDRgNGA0YDRgNGA0YDRgNGA2uH34UfhRsJ3wnGA0YDRgNGA2uH34UjCf8GxgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDeQKowWcJ6kntyfHJ9Un3SdnCBEF7CcRBRgNGA0YDfwnGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0ZERkROxUZERkRGREZERkRGRHMFmIXGBEYERgRGRHcFgwoGREZERkRGREZERkRGREZERkRORUYDRgNGA1cFxkR2BsZERkROxVQF9kb3BYYDRgNGA0YDRgNGA0YDRgNGA0ZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZKBkRGREZERkRGREZERkRGREZERkRGREZERkRKSg6FToVGREZERkRGREZERkRGREqKBkRGREZERkRGRGdDzsV2hs7FRkRGREZEVEXnQ8ZERkRURcZETkVOxXZGxgNGA0YDRkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRzBY5FToVNSgZERkRGRFEKFIonQ9QFxkRGREZERkRGREZERkRGREZEWEoGREZERkRGREZESQLowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBRgNGA2jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZMQowWjBaMFowWjBaMFowWjBaMFowWjBaMFDwWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWZDaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZMJowWjBaMFowWjBQ8FGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBT4HowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFGA0YDRgNGA0YDXEoGA0GJAYkBiQGJAYkBiQYDRgNGA0YDRgNGA0YDRgNzgLOAs4CzgLOAs4CzgLOAs4CzgLOAs4CzgLOAs4CGA02GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GoEohACkAMQA5AAEASQBRAFkAYQBoAHAAdoB+gEaAjoCWgJ6ApoCuQLZAvkCGQM5A1kDeQOZA7kDuQO5A7kDuQO5A70DuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQPdA7kD9QMVBDUEVQS5A7kDuQO5A7kDuQO5A7kDuQO5A7kDdQSVBJUElQSVBLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BMUE3wT9BB0FPQVdBX0FnQW9Bd0F/QUXBjcGVwZ3BpcGtwbXBvcGEge5AzIHUgdnB2cHZwdnB24HuQO5A44HuQO5A7kDuQO5A5QHuQO0B2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB8QHZwdnB2cHuQPkB/0HGQi5A7kDuQO5A7kDuQO5A7kDOQi5A7kDWQhnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2oIigihCGcHZwdnB2cHwQhnB2cHZwdnB2cHZwfhCPYIFgk2CVYJdgmWCbYJZwfGCeYJ/QkQCjAKUApnB2kKiQqpCskKlgnpCgkLJAtnB2cHuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A0QLuQO5A7kDuQO5A7kDuQNUC3MLuQO5A7kDuQO5A7kDuQOJC7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDlAu5A7MLZwdnB2cHZwe5A7cLZwdnB7kDuQO5A7kDuQO5A7kDuQO5A9cLuQO5A7kDuQO5A7kDuQPsC2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwcMDGcHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BCwMDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8MFxcXGRcXFxQVFxgXExcXCQkJCQkJCQkJCRcXGBgYFxcBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBARQXFRoWGgICAgICAgICAgICAgICAgICAgICAgICAgICFBgVGA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDBcZGRkZGxcaGwUcGBAbGhsYCwsaAhcXGgsFHQsLCxcBAQEBAQEBAQEBAQEBAQEBAQEBAQEBARgBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICGAICAgICAgICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgEBAgECAQICAQECAQIBAQIBAQECAgEBAQECAQECAQEBAgICAQECAQECAQIBAgEBAgECAgECAQECAQEBAgECAQECAgUBAgICBQUFBQEDAgEDAgEDAgECAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAgEDAgECAQEBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAgICAgICAQECAQECAQIBAQEBAgECAQIBAgECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQICAgICAgICAgICAgICAgICAgICAgICAgICAgQEBAQEBAQEBAQEBAQEBAQaGhoaBAQEBAQEBAQEBAQEGhoaGhoaGhoaGhoaGhoEBAQEBBoaGhoaGhoEGgQaGhoaGhoaGhoaGhoaGhoaGgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYBAgECBBoBAgAABAICAhcBAAAAABoaARcBAQEAAQABAQIBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgECAgEBAQICAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgICAgIBAhgBAgEBAgIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECGwYGBgYGBwcBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAEFxcXFxcXAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIXEwAAGxsZAAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBhMGFwYGFwYGFwYAAAAAAAAAAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAAAAAFBQUFFxcAQbqPxwAL3gIQEBAQEBAYGBgXFxkXFxsbBgYGBgYGBgYGBgYXEBcXFwUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBAUFBQUFBQUFBQUGBgYGBgYGBgYGBgYGBgYGBgYGBgYJCQkJCQkJCQkJFxcXFwUFBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUXBQYGBgYGBgYQGwYGBgYGBgQEBgYbBgYGBgUFCQkJCQkJCQkJCQUFBRsbBRcXFxcXFxcXFxcXFxcXABAFBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgYAAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBQBBppLHAAueBQkJCQkJCQkJCQkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBgYGBgYGBgYEBBsXFxcEAAAGGRkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBgYGBgQGBgYGBgYGBgYEBgYGBAYGBgYGAAAXFxcXFxcXFxcXFxcXFxcABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgAAFwAFBQUFBQUFBQUFBQAAAAAABQUFBQUFBQUFBQUFBQUFBRoFBQUFBQUAEBAAAAAAAAYGBgYGBgYGBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBhAGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBggFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGCAYFCAgGBgYGBgYGBggICAgGCAgFBgYGBgYGBgUFBQUFBQUFBQUGBhcXCQkJCQkJCQkJCRcEBQUFBQUFBQUFBQUFBQUGCAgABQUFBQUFBQUAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQAAAAUFBQUAAAYFCAgGBgYGAAAICAAACAgGBQAAAAAAAAAACAAAAAAFBQAFBQUGBgAACQkJCQkJCQkJCQUFGRkLCwsLCwsbGQUXBgAGBggABQUFBQUFAAAAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQUABQUABQUAAAYACAgGBgAAAAAGBgAABgYGAAAABgAAAAAAAAAFBQUFAAUAAAAAAAAACQkJCQkJCQkJCQYGBQUFBhcAQc2XxwALTwYGCAAFBQUFBQUFBQUABQUFAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQAFBQAFBQUFBQAABgUICAYGBgYGAAYGCAAICAYAAAUAQauYxwAL9AEFBQYGAAAJCQkJCQkJCQkJFxkAAAAAAAAABQYGBgYGBgAGCAgABQUFBQUFBQUAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQUABQUFBQUAAAYFCAYGBgYAAAgIAAAICAYAAAAAAAAABgYIAAAAAAUFAAUFBQYGAAAJCQkJCQkJCQkJGwULCwsLCwsAAAAAAAAAAAYFAAUFBQUFBQAAAAUFBQAFBQUFAAAABQUABQAFBQAAAAUFAAAABQUFAAAABQUFBQUFBQUFBQUFAAAAAAgIBggIAAAACAgIAAgICAYAAAUAAAAAAAAIAEGtmscAC40CCQkJCQkJCQkJCQsLCxsbGxsbGxkbAAAAAAAGCAgIBgUFBQUFBQUFAAUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFAAAGBQYGCAgICAAGBgYABgYGBgAAAAAAAAAGBgAFBQUAAAUAAAUFBgYAAAkJCQkJCQkJCQkAAAAAAAAAFwsLCwsLCwsbBQYICBcFBQUFBQUFBQAFBQUABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQUFBQAFBQUFBQAABgUIBggICAgIAAYICAAICAYGAAAAAAAAAAgIAAAAAAAABQUABQUGBgAACQkJCQkJCQkJCQAFBQgAQcacxwAL9AEGBggIBQUFBQUFBQUFAAUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBQgIBgYGBgAICAgACAgIBgUbAAAAAAUFBQgLCwsLCwsLBQUFBgYAAAkJCQkJCQkJCQkLCwsLCwsLCwsbBQUFBQUFAAYICAAFBQUFBQUFBQUFBQUFBQUFBQUAAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQUFAAUAAAUFBQUFBQUAAAAGAAAAAAgICAYGBgAGAAgICAgICAgIAAAAAAAACQkJCQkJCQkJCQAACAgXAEHFnscAC1sFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBQUGBgYGBgYGAAAAABkFBQUFBQUEBgYGBgYGBgYXCQkJCQkJCQkJCRcXAEHEn8cAC18FBQAFAAUFBQUFAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFAAUFBQUFBQUFBQUGBQUGBgYGBgYGBgYFAAAFBQUFBQAEAAYGBgYGBgYACQkJCQkJCQkJCQAABQUFBQBBw6DHAAvZAQUbGxsXFxcXFxcXFxcXFxcXFxcbFxsbGwYGGxsbGxsbCQkJCQkJCQkJCQsLCwsLCwsLCwsbBhsGGwYUFRQVCAgFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUAAAAABgYGBgYGBgYGBgYGBgYIBgYGBgYXBgYFBQUFBQYGBgYGBgYGBgYGAAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgAbGxsbGxsGGxsbGxsbABsbFxcXFxcbGxsbFxcAQcGixwAL0QIFBQUFBQUFBQUFBQgIBgYGCAYGBgYGBggGBggIBgYFCQkJCQkJCQkJCRcXFxcXFwUFBQUFBQgIBgYFBQUFBgYFCAgIBQUICAgICAgIBQUGBgYGBQUFBQUFBQUFBQUGCAgGBggICAgICAYFCAkJCQkJCQkJCQkICAgGGxsBAQEBAQEAAQAAAAAAAQAAAgICAgICAgICAgIXBAICAgUFBQUFBQUFBQAFBQUFAAAFBQUFBQUFAAUABQUFBQAABQUFBQUFBQUFBQUAAAYGBhcXFxcXFxcXFwsLCwsLCwsLCwsLCwsAAAAbGxsbGxsbGxsbAAAAAAAAAQEBAQEBAAACAgICAgIAABMFBQUFBQUFBQUFBQUFBQUbFwUMBQUFBQUFBQUFBQUFBQUFFBUAAAAFBQUFBQUFBQUFBRcXFwoKBQUFBQUFBQUAAAAAAAAABQUGBgYIAEGbpccACwcFBQYGCBcXAEGrpccACwQFBQYGAEG7pccACwQFAAYGAEHLpccAC34FBQUFBgYIBgYGBgYGBggICAgICAYICAYGBgYGBgYXFxcEFxcXGQUGAAALCwsLCwsLCwsLAAAAAAAAFxcXFxcXExcXFxcGBgYQBgUFBQQFBQUFBQUFBQUFBQUAAAAAAAAABQUFBQUGBgUFBQUFBQUFBQYFAAAAAAAFBQUFBQUAQdOmxwALNQYGBggICAgGBggICAAAAAAICAYICAgICAgGBgYAAAAAGwAAABcXCQkJCQkJCQkJCQUFBQUFAEGTp8cAC+gFCQkJCQkJCQkJCQsAAAAbGxsbGxsbGxsbGxsbGxsbBQUFBQUFBQYGCAgGAAAXFwUFBQUFCAYIBgYGBgYGBgAGCAYICAYGBgYGBgYGCAgIBgYGBgYGBgYGBgAABhcXFxcXFxcEFxcXFxcXAAAGBgYGBgYGBgYGBgYGBgcGBQUFBQYIBgYGBgYIBggICAYICAUFBQUFBQUFABcXGxsbGxsbGxsbGwYGBgYGGxsbGxsbGxsbFxcXBQgGBgYGCAgGBggGBgYFBQUFBQUGCAYGCAgIBggGBggIAAAAAAAAAAAXFxcXBQUFBQgICAgICAgIBgYGBggIBgYAAAAXFxcXFwkJCQkJCQkJCQkAAAAFBQUFBQUFBQQEBAQEBBcXAgICAgICAgICAQIAAAAAAAEBAQEBAQEBAQEBAAABAQEXFxcXFxcXFwAAAAAAAAAABgYGFwYGBgYGBgYGBgYGBggGBgYGBgYGBQUFBQYFBQgGBgUAAAAAAAQEBAQEBAQEBAQEAgICAgICAgIEAgICAgICAgECAQIBAgICAgICAgICAQICAgICAgICAQEBAQEBAQECAgICAgIAAAEBAQEBAQAAAgICAgICAgIAAQABAAEAAQICAgICAgICAgICAgICAAACAgICAgICAgMDAwMDAwMDAgICAgIAAgIBAQEBAxoCGhoCAgIAAgIBAQEBAxoaGgICAgIAAAICAQEBAQAaGhoCAgICAgICAgEBAQEBGhoaAAACAgIAAgIBAQEBAxoaAAwMDAwMDAwMDAwMEBAQEBATExMTExMXFxwdFBwcHRQcFxcXFxcXFxcNDhAQEBAQDBcXFxcXFxcXFxwdFxcXFxYXFxcYFBUXFxcXFxcXFxcYFxYXFxcXFxcXFxcXDBAQEBAQABAQEBAQEBAQEBALBAAACwsLCwsLGBgYFBUECwsLCwsLCwsLCxgYGBQVAAQEBAQEBAQEBAQEBAQAAAAZGRkZGRkZGRkZGRkZGRkZAEGKrccACx8GBgYGBgYGBgYGBgYGBwcHBgcHBwYGBgYGBgYGBgYGAEG4rccAC58EGxsBGxsbGwEbGwIBAQECAgEBAQIbARsbGAEBAQEBGxsbGwEbARsBGwEBAQEbAgEBAQECBQUFBQIbGwICAQEYGBgYGAECAgICGxgbGwIbCwsLCwsLCwsLCwsLCwsLCwoKCgoKCgoKCgoKCgoKCgoBAgoKCgoLGxsAAAAAGBgYGBgbGxsbGxgYGxsbGxgbGxgbGxgbGxsbGxsbGBsbGxsbGxsbGxsbGxsbGBgbGxgbGBsbGxsbGxsbGxsbGBgYGBgYGBgYGBgYGBgYGBsbGxsbGxsbFBUUFRsbGxsYGBsbGxsbGxsUFRsbGxsbGxsbGxsbGxgbGxsYGBgYGxsbGxsbGxsbGxsbGBgYGBsbGxsbGxsbGxsbGxsbAAAAAAALCwsLCwsLCwsLCwsbGxsbGxsbGxsbCwsLCwsLGxsbGxsbGxsbGxsbGxsbGBsbGxsbGxsbFBUUFRQVFBULCwsLCwsLCwsLGBgYGBgUFRgYGBgYGBgYGBQVFBUUFRQVFBUUFRQVGBgYGBgYGBgUFRQVGBgYGBgYGBgYGBgYFBUYGBgYGBsbGBgYGBgYGxsbGwAAGxsbGxsbGxsbGwAbGxsbGxsbGxsBAgEBAQICAQIBAgECAQEBAgECAgECAgICAgIEBAEBAgECAhsbGxsbGwECAQIGBgECAAAAAAAXFxcXCxcXAgICAgICAAIAAAAAAAIAAAUFBQUFBQUFAAAAAAAAAAQXAEHlsccACwgGBQUFBQUFBQBB9rHHAAtiFxccHRwdFxcXHB0XHB0XFxcXFxcXExcXExccHRcXHB0UFRQVFBUUFRcXFxcXBBcXFxcXFxcXFxcTExcXFxcTFxQXFxcXFxcXFxcXFxcXGxsXFxcUFRQVFBUUFRMAABsbGxsAQeSyxwALBhsbGxsbGwBB9LLHAAttDBcXFxsEBQoUFRQVFBUUFRsbFBUUFRQVFBUTFBUVGwoKCgoKCgoKCgYGBgYICBMEBAQEBBsbCgoKBAUXGxsFBQUFBQUFAAAGBhoaBAQFBQUFBQUFBQUFBRcEBAQFGxsLCwsLGxsbGxsbGxsbGwBB6rPHAAufAxsbGxsbGxsbGxsbGxsbGwAbGxsbGxsbGwsLCwsLCwsLBQUFBQUFBQUFBQUFBBcXFwkJCQkJCQkJCQkFBQAAAAABAgECAQIBAgECAQIBAgUGBwcHFwYGBgYGBgYGBgYXBAECAQIBAgECAQIBAgQEBgYFBQUFBQUKCgoKCgoKCgoKBgYXFxcXFxcAAAAAAAAAABoaGhoaGhoEBAQEBAQEBAQaGgECAQIBAgECAQIBAgECBAICAgICAgICAQIBAgEBAgECAQIBAgQaGgECAQIFAQIBAgICAQIBAgECAQIBAgEBAQEBAgECAQIBAgECAQIBAQEBAgECAQECAAABAgACAAIBAgECAQIBAAAABAQEAQIFBAQCBQUFBQUGBQUFBgUFBQUGBQUFBQgIBgYIGxsbGwYAAAALCwsLCwsbGxkbAAAAAAAABQUFBRcXFxcAAAAAAAAAAAgIBQUFBQUFBQUFBQUFBQUICAgICAgICAgICAgGBgAAAAAAAAAAFxcGBgUFBQUFBRcXFwUXBQUGBQUFBQUFBgYGBgYGBgYXFwYGCAgAQZS3xwALTRcFBQUGCAgGBgYGCAgGBggIFxcXFxcXFxcXFxcXFwAECQkJCQkJCQkJCQAAAAAXFwUFBQUFBgQFBQUFBQUFBQUGBgYGBgYIBgYICAYGAEHqt8cAC0MFBQUGBQUFBQUFBQUGCAAACQkJCQkJCQkJCQAAFxcXFwQFBQUFBQUbGxsFCAYIBQUGBQYGBgUFBgYFBQUFBQYGBQYFAEG6uMcACxwFBQQXFwUFBQUFBQUFBQUFCAYGCAgXFwUEBAgGAEHfuMcAC3YFBQUFBQUAAAUFBQUFBQACAgICAgICAgICAhoEBAQEAgICAgICAgICBBoaAAAAAAUFBQgIBggIBggIFwgGAAAFBQUFBQUFAAAAAAUFBQUFEhISEhISEhISEhISEhISEhERERERERERERERERERERECAgICAgICAEHeuccAC0QCAgICAgAAAAAABQYFBQUFBQUFBQUYBQUFBQUFBQAFBQUFBQAFAAUFAAUFAAUFBQUFBQUFBQUaGhoaGhoaGhoaGhoaGgBBr7rHAAvsAQUFBQUFBQUFBQUFBQUFFRQFBQUFBQUFBQAAAAAAAAAbBQUFBQUFBQUFBQUFGRsbGxcXFxcXFxcUFRcAAAAAAAAXExMWFhQVFBUUFRQVFBUUFRcXFBUXFxcXFhYWFxcXABcXFxcTFBUUFRQVFxcYExgYGAAXGRcXAAAAAAUFBQUFBQUFBQUFBQUAABAAFxcXGRcXFxQVFxgXExcXAgICAgICAgICAgIUGBUYFBUXFBUXFwUFBQUFBQUFBQUEBQUFBQUFBQUFBQUFBQUFBAQAAAUFBQUFBQAABQUFAAAAGRkYGhsZGQAbGBgYGBsbAEGkvMcACz8QEBAbGwAABQUFBQUFBQUFBQUABQUABRcXFwAAAAALCwsLCwsLCwsKCgoKCgsLCwsbGxsbGxsbGxsbCwsbGxsAQfK8xwALIBsbGxsbGxsbGxsbGxsGAAAGCwsLCwsLCwsLCwsLCwsLAEGbvccAC0gFBQUKBQUFBQUFBQUKAAAAAAAFBQUFBQUGBgYGBgAAAAAABQUFBQUFBQUFBQUFBQUAFwUFBQUAAAAABQUFBQUFBQUXCgoKCgoAQe29xwALIAEBAQEAAAAAAgICAgICAgICAgICAAAAAAUFBQUFBQUFAEGYvscAC80CFwEBAQABAQACAgICAgICAgIAAgICAgICAgICAgICAgACAgICAgICAAICAAAABAQEBAQEAAQEBAQEBAQEBAAAAAAABQUFBQUFAAAFAAUFBQUFBQAFBQAAAAUAAAUFBQUFBQAXCwsLCwsLCwsFBQUFBQUFGxsLCwsLCwsLAAAAAAAAAAsLCwsLCwsLCwUFBQAFBQAAAAAACwsLCwsFBQUFBQULCwsLCwsAAAAXBQUFBQUFBQUFBQAAAAAAFwUFBQUFBQUFAAAAAAsLBQUAAAsLCwsLCwsLCwsLCwsLBQYGBgAGBgAAAAAABgYGBgUFBQUFBQAABgYGAAAAAAYXFxcXFxcXFxcAAAAAAAAABQUFBQUFBQUFBQUFBQsLFwUFBQUFBQUFBQUFBQULCwsFBQUFBQUFBRsFBQUFBQUFBgYAAAAACwsLCwsXFxcXFxcXAEHuwMcACz0FBQUFBQUAAAAXFxcXFxcXBQUFBQUFAAALCwsLCwsLCwUFBQAAAAAACwsLCwsLCwsFBQAAAAAAAAAXFxcXAEG0wccACwoLCwsLCwsLAQEBAEHLwccAC2MCAgIAAAAAAAAACwsLCwsLBQUFBQYGBgYAAAAAAAAAAAkJCQkJCQkJCQkFBQUFBAUBAQEBAQEAAAAGBgYGBhMEAgICAgICAAAAAAAAAAAYGAUFBQUFBQUFBQUABgYTAAAFBQUAQbnCxwALdgsLCwsLCwsFAAAAAAAAAAAGCwsLCxcXFxcXAAAAAAAABQUGBgYGFxcXFwAAAAAAAAUFBQUFCwsLCwsLCwAAAAAIBggFBQUFBQUFBQUFBQUFBgYGBgYGBhcXFxcXFxcAAAsLCwsLCwkJCQkJCQkJCQkGBQUGBgUAQbjDxwALEgYICAgGBgYGCAgGBhcXEBcXBgBB1MPHAAsqEAAABQUFBQUFBQYGBgYGCAYGBhcXFxcFCAgFAAAAAAAAAAAFBQUGFxcFAEGHxMcACz8FBQUICAgGBgYGBgYGBgYIBQUFBRcXFxcGBgYGFwgGCQkJCQkJCQkJCQUXBRcXFwALCwsLCwsLCwsLCwsLCwsAQdHExwALIAUFBQUFBQUFBQUFBQgICAYGCAgGCAYGFxcXFxcXBgUGAEH/xMcAC70BBQUFBQUFBQAFAAUFBQUABQUFBQUFBQUFFwAAAAAAAAgICAYGBgYGBgYGAAAAAAAGBggIAAUFBQUFBQUFAAAFAAUFAAUFBQUFAAYGBQgIBggICAgAAAgIAAAICAgAAAUAAAAAAAAIAAAAAAAFBQUICAAABgYGBgYGBgAAAAUFBQUFBQUFBQUABQAABQAFBQUFBQUABQgICAYGBgYGAAgAAAgACAgICAAICAYIBgUGBRcXABcXAAAAAAAAAAYGAEHJxscAC5kBBQUFBQUICAgGBgYGBgYGBggIBgYGCAYFBQUFFxcXFxcJCQkJCQkJCQkJFxcAFwYFCAgIBgYGBgYGCAYICAgIBggGBgUFFwUAAAAAAAAAAAUFBQUFBQUFBQUFBQUFBQgIBgYGBgAACAgICAYGCAYXFxcXFxcXFxcXFxcXFxcFBQUFBgYAAAgICAYGBgYGBgYGCAgGCAYXFxcFAEHtx8cAC0AXFxcXFxcXFxcXFxcXAAAABQUFBQUFBQUFBQUGCAYICAYGBgYGBggGBRcAAAAAAAAJCQkJCQkJCQkJCQkJCQkJAEG5yMcAC0MFBQUFBQUFBQUFBQAABggGCAgGBgYGCAYGBgYGAAAAAAkJCQkJCQkJCQkLCxcXFxsGBgYGBgYGBggGBhcAAAAACwsLAEGIyccACzMFBQUFBQUFAAAFAAAFBQUFAAUFAAUFBQUFBQUFCAgICAgIAAgIAAAGBggGBQgFCAYXFxcAQcTJxwALJAUFBQUFBQUFAAAFBQUFBQUICAgGBgYGAAAGBggICAgGBRcFCABB88nHAAtNBQYGBgYGBgYGBgYFBQUFBQYGBgYGBggFBgYGBhcXFxcXFxcGAAAAAAAAAAAFBgYGBgYGCAgGBgYFBQUFBgYGBgYGBggGBhcXFwUXFxcAQc3KxwALEhcXFxcXFxcXFxcAAAAAAAAFFwBB7crHAAsWBgYGBgYGBgAGBgYGBgYIBgUXFxcXFwBBjcvHAAsWBgYGBgYGBgYACAYGBgYGBggGBggGBgBBrMvHAAukAQUGBgYGBgYAAAAGAAYGAAYGBgYGBgUGAAAAAAAAAAAFBQUFBQUABQUABQUFBQUFBQUFBQgICAgIAAYGAAgIBggGBQAAAAAAAAAFBQUGBggIFxcAAAAAAAAABgYFCAUFBQUFBQUFBQUFBQgIBgYGBgYAAAAICAkJCQkJCQkJCQkGAAAAAAALCwsLCxsbGxsbGxsbGRkZGxsbGxsbGxsbGxsbGxsbAEHdzMcACxYXCgoKCgoKCgoKCgoKCgoKABcXFxcXAEH+zMcACwMFFxcAQY7NxwALKhAQEBAQEBAQEBAQEBAQEBAGBQUFBQUFBgYGBgYGBgYGBggICAYGBgYGFwBBws3HAAsWBgYGBgYGBhcXFxcXGxsbGwQEBAQXGwBB4s3HAAtuCQkJCQkJCQkJCQALCwsLCwAFBQUFBQUFBQUFBQUFBAQEBQUFBQUFBQUFBQUFBQQEFxcXCwsLCwsLCxcXFxcAAAAAAAUICAgICAgICAgICAgICAgIAAAAAAAAAAYGBgQEBAQEBAQEBAQEBAQXBAYAQdvOxwALAggIAEHrzscACxYEBAQEAAQEBAQEBAQABAQABQUFAAAFAEGLz8cACyAFBQUFAAAAAAAAAAAFBQUFBQUFBQUFAAAbBgYXEBAQEABBt8/HAAtFGxsbGxsbGwAAGxsbGxsbGwgIBgYGGxsbCAgIEBAQEBAQEBAGBgYGBhsbBgYGBgYGBhsbGxsbGxsbGxsGBgYGGxsGBgYbAEGG0McACwQLCwsLAEGW0McAC/MDAgICAgEBAQEBAQEBAQEBAQICAgICAgICAgICAgEAAQEAAAEAAAEBAAABAQEBAAEBAQEBAQICAgIAAgACAgICAQEAAQEBAQAAAQEBAQEAAQEBAQEBAQACAgICAgICAgEBAAEBAQEAAQEBAQEAAQAAAAEBAQEBAQACAgICAgICAgICAgICAgEBAQECAgICAgIAAAEBAQEBAQEBGAICAgICAgICAgICAgICAQEBAQEBAQEBAQEYAgICAgIYAgICAgICAQEBAQEBAQEBGAICAgICAhgCAgICAgIBAgAACQkGBgYGBgYGGxsbGwYGBgYGBgYGBgYGBgYbGxsbGwYbGxsbGxsbGxsbBhsbFxcXFxcAAAAAAgICAgICAgICAgICAgICAAAAAAACAgICAgIAAAAAAAYGBgYGBgYGBgAABgYGBgYABgYABgYGBgYAAAAAAAQEBAQEBAQEBAQEBAQEAAAGBgYGBgYGBAQEBAQEBAAACQkJCQkJCQkJCQAAAAAFGwUFBQUFBQUFBQUFBQUFBgAJCQkJCQkJCQkJAAAAAAAZBQkJCQkJCQkJCQkAAAAAFwUFBQUFBQUABQUFBQAFBQAFBQUFBQAACwsLCwsLCwsLAgICAgYGBgYGBgYEAAAAAAsLCwsLCwsLCwsLCxsLCwsZCwsLCwBBlNTHAAtyCwsLCwsLCwsLCwsLCwsbCwAFBQAFAAAFAAUFBQUFBQUABQUFBQAFAAUAAAAABQAAAAAFAAUABQAFBQUABQUABQAABQAFAAUABQAFBQAFAAAFBQUFAAUFBQUABQUFBQAFAAUFBQAFBQUFBQAFBQUFBRgYAEGU1ccAC2cLCwsLCwsLCwsLCwsLGxsbGxsbGxsbGxsaGhoaGhsbGxsbGxsbAAAAABsbGxsbGxsbGxsAAAAAABsbGxsbGxsAAAAAAAAAGxsbGxsbGxsbGxsbGwAAGxsbABsbGxsbGxsbGxsbGwAQAEGJ1scACzwREREREREREREREREREQAAAAAAwKYRAOQNAAAAAAAAiMIRAJQoAAAAAAAAAAARABgNAAAAAAAAEAFnBwEAQc7WxwALA0AAUwBB5NbHAAsDkwCjAEHw1scAC68F4AAAAAAAAAAPAU0BfQG9AfUBNQJ1AqoC6gIgA14DngPbAxUEUgSRBNAEDwVOBY0FTgXMBQwGSgaIBsgGCAdHBwwGgQejB+IHIQhXCG4IqQi4CNsA9QgvCWkJywTVBe4F+wURBjEGTAZkBoMG7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4FowYAABAAIAAwAEAAUABgAHAAUwBjAHMAgwAAABAAIAAwAAAAEAAgADAAAAAQACAAMAAAABAAIAAwAAAAEAAgADAAkwCjALMAwwCjALMAwwDTAAAAEAAgADAAAAAQACAAMADgAPAAAAEQAQAAEAAgADAAAAAQACAAMAAAABAAIAAwAA8BHwEvAT8BTQFdAW0BfQGNAZ0BrQG9Ac0B3QHtAfUBBQIVAiUCNQJFAlUCZQJ1AoUClQKlAqoCugLKAtoC6gL6AgoDGgMgAzADQANQA14DbgN+A44DngOuA74DzgPbA+sD+wMLBBUEJQQ1BEUEUgRiBHIEggSRBKEEsQTBBNAE4ATwBAAFDwUfBS8FPwVOBV4FbgV+BY0FnQWtBb0FTgVeBW4FfgXMBdwF7AX8BQwGHAYsBjwGSgZaBmoGegaIBpgGqAa4BsgG2AboBvgGCAcYBygHOAdHB1cHZwd3BwwGHAYsBjwGgQeRB6EHsQejB7MHwwfTB+IH8gcCCBIIIQgxCEEIUQhXCGcIdwiHCG4IfgiOCJ4IqQi5CMkI2Qi4CMgI2AjoCNsA6wD7AAsB9QgFCRUJJQkvCT8JTwlfCWkJeQmJCZkJywTbBOsE+wQAAAAAhgCpCQAAuAmAAMUJ0wlzAEHM3McACwGGAEGO3ccACzThCQAAsQQAALEEAACxBAAAAAAAAO0JmQj3CQAAAAAFCgAADwIPAg8CDwIPAhUKIAoPAicKAEHQ3ccACwQ3CkUKAEHs3ccAC0ZRCgAAAAAAAF0Kawp4CgAAAAAAAJMAxAAAAAAAAADPAAAAAACICn4AAACIAM8A0QAAAJYKAAAAAAAApArRAAAAAACHALMKAEHE3scACwY0BMMKzAoAQeLexwALFpMAkwCTAJMA1goAAMMFAAAAAAAA5AoAQYTfxwALBZMAkwCAAEGq38cACwNxANEAQbzfxwALAXEAQcrfxwALCpMAkwAAAAAA9AoAQeDfxwALAqoEAEGO4McACwdxAAQLAACFAEGg4McACwHRAEHC4McAC10SCwAAHgsAAA8CDwIPAi4LAAAAAAAAAACvBAAAkwA+CwAAAACqCAAAjADRAAAAAADQAAAAAABKCwAAAAB7AAAAAAD9BVULYgsAAAAAdAAAAAAAAAByC38AAAAlBXoAQbzhxwALAoILAEHg4ccACwFyAEH+4ccACwWTAAAAkwBBnOLHAAsBcQBBvOLHAAsCkAsAQfzixwALAXMAQZrjxwALAYAAQazjxwALApwLAEG+48cACwirCwAAAAC7CwBB1uPHAAsGywvZC+gLAEHu48cACwb2CwYMDQwAQZTkxwALDh0MDwIrDAAAAAAAADMMAEG25McAC3EmBQAAQQwAAAAAhwAAAAAAAABRDBkEYQwAAHEMfwwAAAAAjwyfDAAAAAAAAH8AAAAAAIsAzAAAAAAArwzRAAAAAAC7DH4AAAAAAAAA0AAAAMYMzgAAAAAAAAB9ANEAAAAAANYM9QoAAAAAAABxAOMMfwBBuOXHAAsvcQCtCAAA0QAAAAAAJgWAAAAA3QDOAAAAAAAAAIgAPwtSAbIEAAAAAAAAiwBnCHIAQfLlxwALBPIMTQUAQZLmxwALD/8MgAAlBQAAAAAAAA8NgABBrObHAAsEgQQGBgBBuubHAAsEfwQfDQBB2ObHAAsEcQBmCQBB+ubHAAsDKw19AEGO58cACxq6DIAAAAA6DQAAAABHDXkAVg0AAAAAiQBmDQBB1OfHAAsCdg0AQeDnxwALBpEAhQ2UDQBB9OfHAAsOow0GBgAAAAAAAAAAsg0AQaDoxwALDbAE0QAAAAAAnAtSAXYAQcLoxwALBZMA1QzNAEH86McACwSFAMINAEGe6ccACwnOAAAAAAAAAMwAQdDpxwALC3EAAAAAAAAAcQDQAEHk6ccACwF8AEH46ccACwMkBc8AQabqxwALCZMAkwDFAJMAzABB3OrHAAsKkguQAM8NAAD0CgBB8OrHAAsC4QkAQajrxwALFZMAkwCTANQNkwCTAMYAewB8AIgAkgBB6OvHAAsGMATfDe0NAEH468cACwFxAEGO7McACwHMAEGo7McACwlyAAAAAAAAAIcAQdTsxwALAYcAQfTsxwALAYUAQZDtxwALEMwAAAAAAA8CDwIPAg8C/Q0AQbbtxwALD38AAACTAJMAkwCTAJMAkwBB1u3HAAu+A5MAkwCTAJMAkwCTAJMAkwCTAJMAkwCTAJMAkwCTAAAAeQCJAKEAwADgAAABIAFAAWABawGBAZABsAHPAe8BgQEPAoEBgQGBAYEBgQEhAoEBQQKBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBWwJ7ApoCgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAbkCgQHZAvkCGQOBAYEBgQE5A1QDawOLA6kDyAPmAwQEJARBBFsEgQGBAYEBgQGBAYEBgQGBAYEBgQF4BIEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBhwSBAYEBgQGBAZoEgQGuBIEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAc0EgQGBAYEBgQGBAYEBgQHdBPIEDgWBAYEBgQEuBYEBgQFOBWQFdgWBAZUFgQGBAYEBgQGBAYEBgQGBAYEBgQGBAbUFAEGU8scACwEFAEGn8scAC0AFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAEH38scACwcFBQUFBQUFAEG088cACzUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUABQUABQBBofTHAAtQBQUFBQUFBQUFBQUABQAAAAIABAQEBAIEAgQCAgICAgQEBAQCAgICAgICAgICAgICAQICAgICAgIEAgIFBQUFBQUFBQUFBQUFBQUFBQUFBQUAQf/0xwALegICBQQEBAAEBAQCAgICAgICAgQEBAQEBAQEBAQEBAQEBAQEBAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBAICBAQEBAQEBAQEAgQCBAICBAQABAUFBQUFBQUAAAUFBQUFBQAABQUABQUFBQQEAEGD9scACwYCAgIAAAIAQZj2xwALZgUEBQICAgQEBAQEAgICAgQCAgICAgICAgIEAgQCBAICBAUFBQUFBQUFBQUFBQUFBQUAAAQCAgICAgICAgICAgQEBAICAgICAgICAgICAgICAgQEAgICAgQCBAQCAgIEBAICAgICAgBBpPfHAAsLBQUFBQUFBQUFBQUAQb73xwALNAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUFBQUFBQUFBQAAAAAAAAEAAAUAQYj4xwALGAUFBQUABQUFBQUFBQUFAAUFBQAFBQUFBQBBsvjHAAu3AQQCAgICAgQEAgQCAgICAgICAgICBAIEBAQFBQUAAAAAAgACAgICAAQCBAQAAAAAAAQEBAQEBAQEBAQEBAQEBAQBAQECAAACAgICAgQAAAAAAAAAAAUFBQUFBQUFBQICAgICAgICAgIEBAQABAICBAQCAgICAgIEAgICAgICAgICAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQBBoPrHAAsdBQAFAAAABQUFBQUFBQUAAAAABQAAAAUFBQUFBQUAQcf6xwALAgUFAEHl+scACwEFAEGg+8cACxEFAAAABQUFBQAAAAAAAAAABQBBxfvHAAsCBQUAQeH7xwALBAUABQUAQZ78xwALFQUAAAAFBQAAAAAFBQAABQUFAAAABQBB0fzHAAsGBQUAAAAFAEHh/McACw0FBQUFBQAFBQAAAAAFAEGC/ccACwIFBQBBmv3HAAsIBQUFBQUFAAUAQdz9xwALGQUAAAUFBQUAAAAAAAAAAAUAAAAAAAAABQUAQYD+xwALAgUFAEGe/scACwEFAEHc/scACwEFAEHp/scACwEFAEGc/8cACwUFAAAABQBB2P/HAAsaBQAFBQAAAAAABQUFAAUFBQUAAAAAAAAABQUAQf3/xwALAgUFAEGbgMgACwgFAAAAAAAFBQBBt4DIAAsCBQUAQfKAyAALEgUFAAAABQUFBQAAAAAAAAAABQBBmIHIAAsCBQUAQbaByAALAQUAQfWByAALDQUAAAAAAAAABQUFAAUAQbOCyAALGQUAAAUFBQUFBQUAAAAAAAAABQUFBQUFBQUAQf2CyAALDAUAAAUFBQUFBQUFBQBBoYPIAAsCBQUAQb6DyAALBQUABQAFAEH0g8gAC2oFBQUFBQUFBQUFBQUFBQAFBQAAAAAABQUFBQUFBQUFBQUABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAAABQAFBQUFBQUABQUAAAUFAAAAAAAAAAAFBQAAAAAFBQUFAEHphMgACxEFAAAFBQAAAAAAAAUAAAUFBQBBhYXIAAsKBQUABQUFBQUFBQBBmIXIAAvSAQUAAAAAAAAAAgAAAQUFBQAFAgICAgICAgICAAAAAAAAAAUFAgICAgICAgICBQIAAAAAAAUFBQAAAAAFBQAAAAAAAAAFAAAAAAAABQUFAAAAAAAAAAUFAAAFAAAAAAAABQAFBQUFBQUFAAUAAAUFBQUFBQUFAAAABQUFBQUFBQUFBQAABQAAAAAFAAUFBQUFAAUAAAAFBQUFAAAFBQAFBQUAAAAAAAAFAAUFAAAABQAFBQUFAAAFBQAAAAAAAAAABQAFBQUFBQUFAAAAAAUAAAAFBQBB9YbIAAsTBQABBQUFBQUAAAAAAAUFBQUFBQBBkofIAAszBQUFBQAABQUFAAUFBQUFBQUFBQUAAAUAAAAFAAAAAAUAAAAAAAUFAAAAAAAFAAAAAgIDAEHSh8gACwIFBQBB4YfIAAsPBQAABQUFBQAABQUAAAUFAEH5h8gACysFAAAAAAAAAAAFAAAABQAFBQUAAAUFAAAAAAAFBQAAAAAABQAABQAAAAAFAEGtiMgAC28FBQUAAAAAAAAFBQUFBQAAAAAABQUFAAUFAAAAAAAFBQUFAAAAAAAAAAAFBQUAAAAABQICAgICBAAEAAQEAAADBAQEAgICAgMCAgICAgQCAgQAAAQFBQAAAAACAgICBAIEBAQCAgIEAgIEAgQEAgQAQaqJyAALHQQEBAQCAgADAgICAgICAgICAgICAgICBAIFBQUFAEHQicgACwoFBQUFBQAABAICAEHlicgACxUCAgIEAgICAgICAgICAgICBQICAgQAQYWKyAALFAICAgIEBAICAgICAgICAgIFBQUFAEGjisgACyUCAAICBAQEAAIEBAICBAICAAIEBAIAAAAABAIDAAAAAAUAAAUFAEHSisgAC20FBQUFAAAFBQAAAAAAAAAFBQUFBQAFBQUAAAAAAAAFBQUFBQUFBQUAAAUABQUAAAAAAAAFAAAABQUFBQUFAAUAAAAABQUFBQAAAAAAAAUFAAUAAAAFBQUFBQUFBQAABQAFAAAFBQUFAAUFBQUFAEHKi8gAC2UFBQAFAAUFBQUFBQUFBQUAAAAAAAUFBQUFBQAABQUFBQAFBQUFBQUAAAUFBQAAAAAFBQUFBQUFAAUFAAAAAAAABQUFBQUFBQAFBQUFBQUABQUFBQUFBQUAAAUFBQUFBQAFBQAFBQBBuIzIAAuHAQUFBQUFBQAAAAUABQUABQUAAAAFAAUAAAAAAAAAAAUFBQUFBQUFBQUAAAAFBQUAAAUFBQUFBQUAAAAABQUFBQUFBQUFAAAFBQUFBQAFBQAFBQUFBQAAAAAAAgICAgUFBQUFBQUFAAAAAAAAAEzrEQCkBgAAAAAAAJT4EQAQDgAAAAAAAAACDgBByI3IAAuyROEAgQEBAAAAAAAAAEQGSQYgACcGRAZEBkcGIAA5BkQGSgZHBiAASAYzBkQGRQbpBbwFwgXpBbwFwQVBAAoDyQNCA0UDyQMBA0UDyQMAA0UDxQMIA0IDxQMIAwEDxQMIAwADuQMIA0IDuQMIAwEDuQMIAwADtwNCA0UDtwMBA0UDtwMAA0UDsQNCA0UDsQMBA0UDsQMAA0UDqQMUA0IDRQOpAxMDQgNFA6kDFAMBA0UDqQMTAwEDRQOpAxQDAANFA6kDEwMAA0UDqQMUA0UDqQMTA0UDyQMUA0IDRQPJAxMDQgNFA8kDFAMBA0UDyQMTAwEDRQPJAxQDAANFA8kDEwMAA0UDyQMUA0UDyQMTA0UDlwMUA0IDRQOXAxMDQgNFA5cDFAMBA0UDlwMTAwEDRQOXAxQDAANFA5cDEwMAA0UDlwMUA0UDlwMTA0UDtwMUA0IDRQO3AxMDQgNFA7cDFAMBA0UDtwMTAwEDRQO3AxQDAANFA7cDEwMAA0UDtwMUA0UDtwMTA0UDkQMUA0IDRQORAxMDQgNFA5EDFAMBA0UDkQMTAwEDRQORAxQDAANFA5EDEwMAA0UDkQMUA0UDkQMTA0UDsQMUA0IDRQOxAxMDQgNFA7EDFAMBA0UDsQMTAwEDRQOxAxQDAANFA7EDEwMAA0UDsQMUA0UDsQMTA0UDpQMUA0IDpQMUAwEDpQMUAwADxQMUA0IDxQMTA0IDxQMUAwEDxQMTAwEDxQMUAwADxQMTAwADnwMUAwEDnwMTAwEDnwMUAwADnwMTAwADvwMUAwEDvwMTAwEDvwMUAwADvwMTAwADmQMUA0IDmQMTA0IDmQMUAwEDmQMTAwEDmQMUAwADmQMTAwADuQMUA0IDuQMTA0IDuQMUAwEDuQMTAwEDuQMUAwADuQMTAwADlQMUAwEDlQMTAwEDlQMUAwADlQMTAwADtQMUAwEDtQMTAwEDtQMUAwADtQMTAwADdQAbAyMDVQAbAyMDdQAbAwMDVQAbAwMDdQAbAwkDVQAbAwkDdQAbAwADVQAbAwADdQAbAwEDVQAbAwEDbwAbAyMDTwAbAyMDbwAbAwMDTwAbAwMDbwAbAwkDTwAbAwkDbwAbAwADTwAbAwADbwAbAwEDTwAbAwEDbwAjAwIDTwAjAwIDbwACAwMDTwACAwMDbwACAwkDTwACAwkDbwACAwADTwACAwADbwACAwEDTwACAwEDZQAjAwIDRQAjAwIDZQACAwMDRQACAwMDZQACAwkDRQACAwkDZQACAwADRQACAwADZQACAwEDRQACAwEDYQAjAwYDQQAjAwYDYQAGAwMDQQAGAwMDYQAGAwkDQQAGAwkDYQAGAwADQQAGAwADYQAGAwEDQQAGAwEDYQAjAwIDQQAjAwIDYQACAwMDQQACAwMDYQACAwkDQQACAwkDYQACAwADQQACAwADYQACAwEDQQACAwEDdQAEAwgDVQAEAwgDdQADAwEDVQADAwEDcwAjAwcDUwAjAwcDcwAMAwcDUwAMAwcDcwABAwcDUwABAwcDcgAjAwQDUgAjAwQDbwAEAwEDTwAEAwEDbwAEAwADTwAEAwADbwADAwgDTwADAwgDbwADAwEDTwADAwEDbAAjAwQDTAAjAwQDaQAIAwEDSQAIAwEDZQAnAwYDRQAnAwYDZQAEAwEDRQAEAwEDZQAEAwADRQAEAwADYwAnAwEDQwAnAwEDQhs1Gz8bNRs+GzUbPBs1GzobNRsRGzUbDRs1GwsbNRsJGzUbBxs1GwUbNRslEC4QkA+1D6sPtw+mD7cPoQ+3D5wPtw+SD7cPQA+1D1sPtw9WD7cPUQ+3D0wPtw9CD7cP2Q3fDdkNzw3KDUYNVw1HDT4NRg0+DcYMwgzVDMYM1gzGDNUMvwzVDMYL1wvHC74Lxgu+C5IL1wtHC1cLRws+C0cLVgvHCdcJxwm+CW8ABwMEA08ABwMEA28AAwMEA08AAwMEA28ACAMEA08ACAMEA2EACgMBA0EACgMBA28AKAMEA08AKAMEA2EABwMEA0EABwMEA2EACAMEA0EACAMEA3UACAMAA1UACAMAA3UACAMMA1UACAMMA3UACAMBA1UACAMBA3UACAMEA1UACAMEAwCmApGiAg6iAgWhAs6gAjCbAraVApaUAgqUAhqSAkWRAneNAvqLAi6HAu2FAtKFAt4IAgQIAi9/Aqh8AmZ5Aq54Amd2AtJwArFvAixvAspzAtVsAmttAjZsAjxrApwzApMzArVnAqdnAl8zAqhlAiNlAtpkAj5jAtliAkdiAihiAoZfAoBcAqtbAqdaAnxZAsVWAppWAiZWAh1UAjNRAhlRAvJQAvNQAkRQArhPAqFPAp8hApJMAjZMAhRIAjVHAghGAqtDAmNCAiUFAo4/Al4/AtE+Ah49Arw8Avo6AgsdAo06Aqc4AqM2Am00AsMzAgowAvErAgwrAtQmAtphArgyAjEjApKjAoMhAuYdAuQdAhgbAsgZAuoWAqgWAuQUAmMLAiwKAt+RAksFAhwFAjoGAiIBArrRAWXRAW/RAbnRAWXRAW/RAbrRAWXRAW7RAbnRAWXRAW7RAVjRAWXRAXLRAVjRAWXRAXHRAVjRAWXRAXDRAVjRAWXRAW/RAVjRAWXRAW7RAVfRAWXRAWNtAWdtAWdtAR5hAR5hASBhAR5hASlhAR9hAR5hAR5hAR9hATUZATAZAbkVAa8VAbgVAa8VAbkUAb0UAbkUAbAUAbkUAboUAcITAckTAcITAbgTAcITAcITAZATAckTAYsTAcITAYQTAbsTAYITAckTAUcTAVcTAUcTAT4TATIRAScRATERAScRAaUQAboQAZsQAboQAZkQAboQAdoFAQcDANIFAQcDANN+AtBcAklSAtUzAkQoAkooAu5CAgD2BhIABAMAAAAAAAD+DBIAwwAAAAAAAAAUMFdlFTAUMN1SFTAUMNd2FTAUMFNiFTAUMLlwFTAUMIlbFTAUMIxOFTAUMAlOFTAUMCxnFTCzMLMwezBLMEQASgBNAFIATQBEAE0AQwBXAEMAUABQAFYAUwBTAFMARABNAFYASABWAFcAWgBDAEQAFDBTABUwKABaACkAKABZACkAKABYACkAKABXACkAKABWACkAKABVACkAKABUACkAKABTACkAKABSACkAKABRACkAKABQACkAKABPACkAKABOACkAKABNACkAKABMACkAKABLACkAKABKACkAKABJACkAKABIACkAKABHACkAKABGACkAKABFACkAKABEACkAKABDACkAKABCACkAKABBACkAOQAsADgALAA3ACwANgAsADUALAA0ACwAMwAsADIALAAxACwAMAAsADAALgBEBicGRAYnBlUGRAYnBlQGRAYnBlMGLgAuAC4ALgAuADEGzAYnBkQGLAZEBiAALAZEBicGRAZHBjUGRAZJBkgGMwZEBkUGOQZEBkoGRwYxBjMGSAZEBjUGRAY5BkUGRQYtBkUGLwYnBkMGKAYxBicGRAZEBkcGQgZEBtIGNQZEBtIGRgYsBkoGMwYuBkoGNQZFBkUGOQYsBkUGQwZFBkUGKAYtBkoGQQZFBkoGRQYsBkoGLQYsBkoGLAYtBkoGRgYsBi0GRAYsBkUGRQYuBkoGQwZFBkoGOQZFBkoGRAYtBkUGQgZFBi0GRgYtBkoGQgZFBkoGRQZFBkoGSgZFBkoGSgYsBkoGSgYtBkoGRAZFBkoGRAYsBkoGNgYtBkoGNAYtBkoGNQYtBkoGMwYuBkkGLAZFBkkGLAYtBkkGLAZFBkoGKgZFBkkGKgZFBkoGKgYuBkkGKgYuBkoGKgYsBkkGKgYsBkoGKAYuBkoGRgZFBkkGRgZFBkoGRgYsBkkGRgYsBkUGRgYtBkkGRgYtBkUGRwZFBkUGRwZFBiwGRQYsBi4GRQYuBkUGRQYuBiwGRQYsBi0GRQYtBkoGRQYtBiwGRAZFBi0GRAYuBkUGRAYsBiwGRAYtBkkGRAYtBkoGQgZFBkUGQQYuBkUGOgZFBkkGOgZFBkoGOgZFBkUGOQZFBkkGNwZFBkoGNwZFBkUGNwZFBi0GNgYuBkUGNgYtBkkGNAZFBkUGNAZFBi4GNAYsBkoGNAYtBkUGNQYtBi0GMwZFBkUGMwZFBiwGMwZFBi0GMwYsBkkGMwYsBi0GMwYtBiwGLQZFBkkGLQZFBkoGLAZFBi0GKgZFBi4GKgZFBi0GKgZFBiwGKgYuBkUGKgYtBkUGKgYtBiwGKgYsBkUGOAZFBjQGLgY0BkcGMwZHBjYGMQY1BjEGMwYxBjQGMQY2BkoGNgZJBjUGSgY1BkkGNAZKBjQGSQYzBkoGMwZJBjoGSgY6BkkGOQZKBjkGSQY3BkoGNwZJBkAGUAZRBkAGTwZRBkAGTgZRBkYGRwZDBkQGKwZHBisGRQYqBkcGKAZHBigGRQZKBlQGRwZKBlQGRQZKBi4GRwYsBkYGLgZDBi4GQwYtBkMGLAZCBi0GQQYtBkEGLAY6BiwGNwYtBjYGRQY2BiwGNQYuBigGLAZKBlQGLgZKBlQGLQZKBlQGLAZKBkkGSgYyBkoGMQZGBkoGRgZJBkYGRgZGBjIGRgYxBkUGJwZDBkoGQwZJBkMGJwZCBkoGQgZJBkEGSgZBBkkGKwZKBisGSQYrBkYGKwYyBisGMQYqBkoGKgZJBioGRgYqBjIGKgYxBigGSgYoBkkGKAZGBigGMgZKBlQGSgZKBlQGSQZKBlQGRgZKBlQGMgZKBlQGMQYgAFEGcAYgAFAGUQYgAE8GUQYgAE4GUQYgAE0GUQYgAEwGUQZHBkkGLgYtBisGLAZKBlQG0AZKBlQGyAZKBlQGxgZKBlQGxwZKBlQGSAZKBlQG1QZKBlQGJwbHBnQG0AXcBXQFbQV+BXYFdAVrBXQFZQV0BXYFcwB0AGYAZgBsAGYAZgBpAGcAYQBsADMAMQDlZTMAMADlZTIAOQDlZTIAOADlZTIANwDlZTIANgDlZTIANQDlZTIANADlZTIAMwDlZTIAMgDlZTIAMQDlZTIAMADlZTEAOQDlZTEAOADlZTEANwDlZTEANgDlZTEANQDlZTEANADlZTEAMwDlZTEAMgDlZTEAMQDlZTEAMADlZUEAFSJtAFYAFSJtAFcAYgBTAHYAcwByAFAAUgBQAFAATQBwAC4AbQAuAFAASABtAG8AbABtAGkAbABtAGIAbAB4AGwAbwBnAGwAbgBrAHQASwBNAEsASwBpAG4ASABQAGgAYQBHAHkAZABCAEMAbwAuAEMAFSJrAGcAYwBkAGMAYwBCAHEAYQAuAG0ALgBNAKkDawCpA00AVwBrAFcAvANXAG4AVwBwAFcAawBWALwDVgBuAFYAcABWAG0AcwC8A3MAbgBzAHAAcwByAGEAZAAVInMAMgBHAFAAYQBNAFAAYQBrAFAAYQBtABUicwAyAGsAbQAzAGMAbQAzAG0AbQAzAGsAbQAyAGMAbQAyAG0AbQAyALwDbQBuAG0AZgBtAGsAbABkAGwAbQBsALwDbABUAEgAegBHAEgAegBNAEgAegBrAEgAegBtAGcAvANnALwDRgBuAEYAcABGAGsAYwBhAGwARwBCAE0AQgBLAEIAawBBAG0AQQC8A0EAbgBBAHAAQQAqaA9fGk8+eQ5mu2wnWWNrLWaMVHNeEGJJAFUAZABtADMAZABtADIAcABjAG8AVgBiAGEAcgBBAFUAZABhAGgAUABhADIANAC5cDIAMwC5cDIAMgC5cDIAMQC5cDIAMAC5cDEAOQC5cDEAOAC5cDEANwC5cDEANgC5cDEANQC5cDEANAC5cDEAMwC5cDEAMgC5cDEAMQC5cDEAMAC5cO8wwzDIMOww8zDIMLEwmTDzMOww4DDrMPww1TCZMOsw6zDSMJow/DDqMOkw6jDDMMgw6zDmMKIw8zDkMPww6zDkMPwwyDCZMOEw/DDIMOsw4TCrMJkwyDDzMN8w6jDPMJkw/DDrMN8wrzDtMPMw3jDzMLcw5zDzMN4w6zCvMN4wwzDPMN4wpDDrMN4wpDCvMO0w2zD8MPMw2zD8MOsw2zCaMPMwyDCZMNsw8zDbMJkw6zDIMNswmjCkMPMwyDDYMJkw/DC/MNgwmjD8MLcwmTDYMJow8zC5MNgw6zDEMNgwmjDLMNIw2DCaML0w2DCvML8w/DDrMNUw6TDzMNUwmTDDMLcwpzDrMNUwozD8MMgw1TChMOkwwzDIMJkw0jCZMOsw0jCaMLMw0jCaMK8w6zDSMJowojC5MMgw6zDPMJkw/DDsMOswzzCaMPwwxDDPMJow/DC7MPMwyDDPMKQwxDDOMMMwyDDKMM4wyDCZMOswxjCZMLcwvzCZMPwwuTC7MPMwwTC3MOow8zCvMJkwtTDzMMEw/DDgMLUwpDCvMOswszD8MNswmjCzMOswyjCxMPwwuTCvMO0w/DDNMK8w6zC7MJkwpDDtMK8wmTDpMOAwyDDzMK0w7TDvMMMwyDCtMO0w4TD8MMgw6zCtMO0wrzCZMOkw4DCtMJkw6zC/MJkw/DCtMOUw6jD8MK0wmTDLMPwwrTCZMKswmTCrMJkw8zDeMKswmTDtMPMwqzDtMOow/DCrMOkwwzDIMKswpDDqMKow/DDgMKow8zC5MKgw/DCrMPwwqDC5MK8w/DDIMJkwpjCpMPMwpDDzMMEwpDDLMPMwrzCZMKIw/DDrMKIw8zDYMJowojCiMOsw1TChMKIwzzCaMPwwyDDkToxUTABUAEQAZQBWAGUAcgBnAEgAZwAxADIACGcxADEACGcxADAACGc5AAhnOAAIZzcACGc2AAhnNQAIZzQACGczAAhnNQAwADQAOQA0ADgANAA3ADQANgA0ADUANAA0ADQAMwA0ADIANAAxADQAMAAzADkAMwA4ADMANwAzADYACxFuEQwRbhELEXQRDhFhEbcRABFpERIRYREREWEREBFhEQ8RYREMEWERCxFhEQkRYREHEWERBhFhEQURYREDEWERAhFhEQARYREzADUAMwAzADMAMgBQAFQARQAoAPOBKQAoAOqBKQAoABFPKQAoAG15KQAoAFRTKQAoAMeMKQAoAAFPKQAoAON2KQAoAGZbKQAoAHxUKQAoAONOKQAoALRSKQAoAF15KQAoAKGMKQAoAHlyKQAoAA1UKQAoAD55KQAoAAlnKQAoACpoKQAoAOVlKQAoAB9XKQAoANGRKQAoAChnKQAoADRsKQAoAGtwKQAoAAhnKQAoAEFTKQAoAF1OKQAoAGtRKQAoAANOKQAoAG1RKQAoAJROKQAoANtWKQAoAAlOKQAoAIxOKQAoAABOKQAoAAsRaRESEW4RKQAoAAsRaREMEWURqxEpACgADBFuESkAKAASEWERKQAoABERYREpACgAEBFhESkAKAAPEWERKQAoAA4RYREpACgADBFhESkAKAALEWERKQAoAAkRYREpACgABxFhESkAKAAGEWERKQAoAAURYREpACgAAxFhESkAKAACEWERKQAoAAARYREpACgAEhEpACgAEREpACgAEBEpACgADxEpACgADhEpACgADBEpACgACxEpACgACREpACgABxEpACgABhEpACgABREpACgAAxEpACgAAhEpACgAABEpALMwyDCIMIowPQA9AD0AOgA6AD0AKyIrIisiKyIoAHoAKQAoAHkAKQAoAHgAKQAoAHcAKQAoAHYAKQAoAHUAKQAoAHQAKQAoAHMAKQAoAHIAKQAoAHEAKQAoAHAAKQAoAG8AKQAoAG4AKQAoAG0AKQAoAGwAKQAoAGsAKQAoAGoAKQAoAGkAKQAoAGgAKQAoAGcAKQAoAGYAKQAoAGUAKQAoAGQAKQAoAGMAKQAoAGIAKQAoAGEAKQAyADAALgAxADkALgAxADgALgAxADcALgAxADYALgAxADUALgAxADQALgAxADMALgAxADIALgAxADEALgAxADAALgAoADIAMAApACgAMQA5ACkAKAAxADgAKQAoADEANwApACgAMQA2ACkAKAAxADUAKQAoADEANAApACgAMQAzACkAKAAxADIAKQAoADEAMQApACgAMQAwACkAKAA5ACkAKAA4ACkAKAA3ACkAKAA2ACkAKAA1ACkAKAA0ACkAKAAzACkAKAAyACkAKAAxACkALiIuIi4iMABEIDMAeABpAGkAaQB4AHYAaQBpAGkAaQB2AFgASQBJAEkAWABWAEkASQBJAEkAVgAxAEQgNwBEIDgANQBEIDgAMwBEIDgAMQBEIDgANQBEIDYAMQBEIDYANABEIDUAMwBEIDUAMgBEIDUAMQBEIDUAMgBEIDMAMQBEIDMAMQBEIDEAMAAxAEQgOQBGAEEAWABUAE0AVABFAEwAUwBNAE4AbwCwAEYAYwAvAHUAYwAvAG8AsABDAGEALwBzAGEALwBjAFIAcwAyIDIgMiAyICEAPwA/ACEAIQAhADUgNSA1ICAACAMBAyAACAMAAyAAFANCAyAAFAMBAyAAFAMAAyAAEwNCAyAAEwMBAyAAEwMAAyAACANCA2EAvgKzD3EPgA+yD3EPgA+rDqEOqw6ZDs0Osg5NDjIOSgZ0BkgGdAYnBnQGZQWCBWQAegBEAHoARABaAG4AagBOAGoATgBKAGwAagBMAGoATABKAGQAegAMA0QAegAMA0QAWgAMA7wCbgBsALcATAC3AGkAagBJAEoAMwBEIDQAMQBEIDIAMQBEIDQAZABqAG0AcgBtAGQAbQBjAHcAYwBwAHAAdgBzAHMAcwBkAG0AdgBoAHYAdwB6ABQwcwAVMGEAFSJtAHYAFSJtAHcAYgBzAHYAcAByAHAAcABtAHAAaABrAGsAaABwAGcAeQBkAGIAYwAVImsAZwBiAHEAbQDJA2sAyQNrAHcAvAN3AG4AdwBwAHcAawB2ALwDdgBuAHYAZwBwAGEAbQBwAGEAawBwAGEAdABoAHoAZwBoAHoAbQBoAHoAawBoAHoAvANmAG4AZgBwAGYAawBiAGsAYQBtAGEAvANhAG4AYQBpAHUAbwB2AGEAdQBoAHAAYQBsAHQAZABlAHYAaABnAHAAdABlAGYAYQB4AHQAbQB0AGUAbABzAG0AbgBvALAAZgCwAGMAcgBzAMkDuQPJA0IDuQPJAwEDuQPJAwADuQO3A7kDtwNCA7kDtwMBA7kDtwMAA7kDsQO5A7EDQgO5A7EDAQO5A7EDAAO5A8kDFANCA7kDyQMTA0IDuQPJAxQDAQO5A8kDEwMBA7kDyQMUAwADuQPJAxMDAAO5A8kDFAO5A8kDEwO5A7cDFANCA7kDtwMTA0IDuQO3AxQDAQO5A7cDEwMBA7kDtwMUAwADuQO3AxMDAAO5A7cDFAO5A7cDEwO5A7EDFANCA7kDsQMTA0IDuQOxAxQDAQO5A7EDEwMBA7kDsQMUAwADuQOxAxMDAAO5A7EDFAO5A7EDEwO5AyAAuQMe3wEK3wEI3wEG3wEF3wEE3wFD6QFC6QFB6QFA6QE/6QE+6QE96QE86QE76QE66QE56QE46QE36QE26QE16QE06QEz6QEy6QEx6QEw6QEv6QEu6QEt6QEs6QEr6QEq6QEp6QEo6QEn6QEm6QEl6QEk6QEj6QEi6QF/bgF+bgF9bgF8bgF7bgF6bgF5bgF4bgF3bgF2bgF1bgF0bgFzbgFybgFxbgFwbgFvbgFubgFtbgFsbgFrbgFqbgFpbgFobgFnbgFmbgFlbgFkbgFjbgFibgFhbgFgbgHfGAHeGAHdGAHcGAHbGAHaGAHZGAHYGAHXGAHWGAHVGAHUGAHTGAHSGAHRGAHQGAHPGAHOGAHNGAHMGAHLGAHKGAHJGAHIGAHHGAHGGAHFGAHEGAHDGAHCGAHBGAHAGAGFDQGEDQGDDQGCDQGBDQGADQF/DQF+DQF9DQF8DQF7DQF6DQF5DQF4DQF3DQF2DQF1DQF0DQFzDQFyDQFxDQFwDQHyDAHxDAHwDAHvDAHuDAHtDAHsDAHrDAHqDAHpDAHoDAHnDAHmDAHlDAHkDAHjDAHiDAHhDAHgDAHfDAHeDAHdDAHcDAHbDAHaDAHZDAHYDAHXDAHWDAHVDAHUDAHTDAHSDAHRDAHQDAHPDAHODAHNDAHMDAHLDAHKDAHJDAHIDAHHDAHGDAHFDAHEDAHDDAHCDAHBDAHADAG8BQG7BQG5BQG4BQG3BQG2BQG1BQG0BQGzBQGxBQGwBQGvBQGuBQGtBQGsBQGrBQGqBQGpBQGoBQGnBQGmBQGlBQGkBQGjBQGhBQGgBQGfBQGeBQGdBQGcBQGbBQGaBQGZBQGYBQGXBQH7BAH6BAH5BAH4BAH3BAH2BAH1BAH0BAHzBAHyBAHxBAHwBAHvBAHuBAHtBAHsBAHrBAHqBAHpBAHoBAHnBAHmBAHlBAHkBAHjBAHiBAHhBAHgBAHfBAHeBAHdBAHcBAHbBAHaBAHZBAHYBAFPBAFOBAFNBAFMBAFLBAFKBAFJBAFIBAFHBAFGBAFFBAFEBAFDBAFCBAFBBAFABAE/BAE+BAE9BAE8BAE7BAE6BAE5BAE4BAE3BAE2BAE1BAE0BAEzBAEyBAExBAEwBAEvBAEuBAEtBAEsBAErBAEqBAEpBAEoBAEAAGAPEgCHCQAAAAAAAG4iEgAgAQAAAAAAAAAAQACAAMAAAAE/AX8BvAH8ATsCSwKEAsQCBANEA3oDugP0AzQEdAS0BPQELQVtBacF3AUAABwGTgaNBpsG2wYZB1kHigfABwAIPQh5CLgI9wg1CXQJsQnxCTAKbgqtCu0KKgthC6EL4QsgDGAMoAzfDB4NXQ2dDd0NGg5aDpgOkQurC7kLzwvvCw4MKwxKDKsLqwtqDIcMpwy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DEIBAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AAAARABIAEwAT8BTwFfAW8BfwGPAZ8BrwG8AcwB3AHsAfwBDAIcAiwCOwJLAlsCawJLAlsCawJ7AoQClAKkArQCxALUAuQC9AIEAxQDJAM0A0QDVANkA3QDegOKA5oDqgO6A8oD2gPqA/QDBAQUBCQENAREBFQEZAR0BIQElASkBLQExATUBOQE9AQEBRQFJAUtBT0FTQVdBW0FfQWNBZ0FpwW3BccF1wXcBewF/AUMBgAAEAAgADAAHAYsBjwGTAZOBl4GbgZ+Bo0GnQatBr0GmwarBrsGywbbBusG+wYLBxkHKQc5B0kHWQdpB3kHiQeKB5oHqge6B8AH0AfgB/AHAAgQCCAIMAg9CE0IXQhtCHkIiQiZCKkIuAjICNgI6Aj3CAcJFwknCTUJRQlVCWUJdAmECZQJpAmxCcEJ0QnhCfEJAQoRCiEKMApAClAKYApuCn4KjgqeCq0KvQrNCt0K7Qr9Cg0LHQsqCzoLSgtaC2ELcQuBC5ELoQuxC8EL0QvhC/ELAQwRDCAMMAxADFAMYAxwDIAMkAygDLAMwAzQDN8M7wz/DA8NHg0uDT4NTg1dDW0NfQ2NDZ0NrQ29Dc0N3Q3tDf0NDQ4aDioOOg5KDloOag56DooOmA6oDrgOyA4AAAAA2A7nDgAAAAAAAAAA8g4AAAIPEg8iDwAAAAAyDwBBhNLIAAtDPw9OD1gPAAAAAGAPaA91DwAAAAAAAAAAfA+MDwAAAAB8DwAAAACED78LUQcAAAAAAAC/CwAAAAAAAJwPAABzAAAAdgBB0tLIAAsCrA8AQZTTyAALAwwFcwBBotPIAAsldwAAALwPAADLDwAAfABLB9sPAAAAAAAA6w8AAPkPdgB2AAkQdgBB0tPIAAvWAncAAAAAABkQAAAAAAAAAAB6AAAAcQB0ACkQmAoAAHIAewAAAAAAdAAAAHYAbAwAAAAAORAAAAAAAABxAEkQVBB2AHYAcgBkEHMQgQCBAIEAgxCSEAAAnhCuEAAAvBCmBwAAAADMEAAAAAAAADYI2hAAAAAAAADmEG0MAAAAAAAA9hAGERYRJhF4ADYRRhFUEQAAAABkEXQRhBGUEaQRrxEAALgRyBHYEegR+BHEAgISEhIiEjISQhJSEmISchKCEpISohKyEsIS0hLiEvISAhMSEyITMhNCE1ITYhNyE4ITkhOiE7ITwhPSE+IT8hMCFBIUIhQuFD4UTRRXFGcUdxSHFJcUpxQAAH8AtxTGFNYU5hT2FAYVFRUlFTUVRRVFFVUVZRVxFQAAgBUAAAAAAACQFQAAnRWtFbwVAADMFdwV7BUAAPYVAAAAAAAABhYAAAAAAAAUFgBBwtbIAAsadgCBAHUAgQAkFjQWRBZMFlwWbBZLAEEAfBYAQf7WyAALAocWAEGM18gACwKUFgBBmNfIAAsCmxYAQazXyAALBtgIAABSBwBBvtfIAAtAqxa7FssWAAAAAAAA2xbrFvsWCxcbFysXOxdLF1sXahcAAAAAdBcAAAAAAACEF5QXAAB5AJsImwibCJsIxALEAgBBiNjIAAsKcgCBAIEAAACkFwBBnNjIAAuiAbQXxBfUF+QX9BcEGBQYJBg0GEQYVBhkGHQYhBiUGIEAgQCkGAAAqhi6GMoY2hjqGPoYAAAIGRgZKBk4GUgZAABWGXgFAAAAAGYZdhmGGZYZphm2GcYZAAAAAAAAAAB6AAAA1hnmGfYZBhoWGiYaNhpGGlYaZhp2GoYalhqmGrYaxhrWGuYa9hoGGxYbJhs2G0YbVhtmG3YbhhuWG6YbthvGGwBBztnIAAsJcwAAAAAAAAB5AEH+2cgACxB0AIEA1hvmG/YbBhwWHCYcAEGY2sgACzE0HAAAAABEHFMcYxxzHIMckRyhHLEcwRzRHOEc8RyBAP8c9Q8AAAkddgAAAAAAAAB4AEHS2sgACzQZHXYAxAKoBwAAAAAnHQAAAAA1HQAAcwAAAAAAAAA5CEUdjgUAAHEAAAAAAAAAeQByADoMAEGQ28gAC6UDVR1lHaIFAAB1HYQdmwWbCAAAAACUHaQdtB3EHdQd5B30HQAAAAAEHnYAFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHiAeAACRBQAAAAB0AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQAwHkAeUB5gHnAegB6QHqAesB7AHtAe4B7wHgAfEB8gHzAfQB9QH2AfcB+AH5AfoB+wH8Af0B/gH/AfACCBAIEAECAdIC0gPSBNIF0gayB5IIcglSClILUgfQDFINUg5SD1IAUhFSElITUhRSFVIWUhdSGFIZUhpSG1IcUh1SHlIfUhBSIVIiUiAAA1IkQiUyJjInMigyKTIqMigQCBALMiwyLTIuMi8yIDIxMjIyMzI0MjUiNhI3AjfyOOI50jrCO8I8wj3CPsI/wjDCQcJCwktRo8JEwkXCRrJHskiySaJEwHAABRB6okcgByAIEAgQBBxN7IAAtodQC5JAAAAABzDAAAAAAAAAAAcQBzAH8AgQCBAAAAAADAJIEAgQCBAIEAgQCBAIEAgQAAAHMAAAAAAAAAfwD7BXQAAAAAAGgJAAB1AAAAAADQJAAASgcAAAAA4CR6AIEAgQDwJAAlECUAQbjfyAALLXIAdgAgJTAlQCUAAHQAAAAAAHgAAAAAAAAAngVQJWAlcCVWB34ljiUAAJolfABBjODIAAtleQAAAHoAeACBAKkluSXJJdklgQCBAIEAgQDpJQAAAADzJQAAUgcAAAAAAABxAHYFgQCBAIEAAAACJgAAawwAAHoHgQCBAIEAgQAAAAAAAACQBQAACwUAAAAADiZ+CQAAHiZ3AHcAQfrgyAALK4EAgQAAAAAALiZ5AAAAAAAAAHEMAAA+DAAAgQcAADwmpAWBAIEAgQCBAIEAQa7hyAALa3cAgQCBAIEATCZcJmwmfCYAAAAAAADgCQAAAACMJnYAAACcJqwmAABiCoEAgQCBAIEAgQCBAIEAAABxAAAAAAC6Jn4A0AyBAIEAyCYAAAAAeAAAANgm5yaBAAAA9yaBAIEAAAB0AIEAAAB5AEGi4sgAC3cHJwsFAAAXJwAAJyc0J0AnfQAAAHcAdgCnBwAATideJ3gAAAAAAGsnAAAAAAAAAAB7JwAADAV7AAAAVgcAAIYnfgCBAIEAgQCPJ0oHdgAAAAAAAACeJ3YAeQiJCE8Hrie9J80n2ifiJ/InAigAAAwoGygqKDAogQBBouPIAAvNAUAoRx1+AIEAAAAAAAAAUChfKHYAgQCBAIEAgQCBAIEAgQCBAIEAgQAAAAAAbyh/KI8ocgCBAIEAAAAAAAAADQx7AHYAcwCBAAAAAAAAAJkodgAAAHwAgQAAADkMqSgAAHkAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAAAALkogQCBAIEAgQCBAIEAySjZKAAAAAAAANIL6Sj1KAAABSlrJ3YAgQCBAIEAgQA8DAAAAAA8DBMpgQAAAAAAAAAjKSwpAAAAAAAAAADyD30AQfjkyAALmAF3AHYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAB+AHYATwcAAAAAPCl6AAAAcwAAAAAACwVQB3kAgQCBAIEAgQCeCQAAAABMKVspdgBrKQAAcQB5KXYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAdwAAAFcHAABsDO8OdQCBAIEAgQCBAIEAfwAAAAAAAAAxKABBwubIAAsNdgCBAIEAgQCBAIEAgQBB3ObIAAsDcQB7AEH45sgACzN8AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQbjnyAALDX0AAAAAAAAAgQAAAHoAQYToyAALAXUAQY7oyAAL4QF5AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAiSmYKXYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAAAAAAAAdwAAAHEAjgUAAAAAAAAAAHEAdgAAAHIAqCkAAAAAAAC4KXoATgdWB3wHAACBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAAAAAMEpdgCBAIEAgQCBAIEAgQCBAIEA0SnhKQAAAAAAAHUAgQCBAIEAgQCBAIEAQfjpyAALGI0FAAAAAAAA2wkAAIEAgQCBAIEAewDxKQBBzurIAAsBeABB6urIAAtIegCBAMIJdwCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAJkJAEHW68gACwp9AL8JgQABKg0qAEH+68gACyF0AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQazsyAALM3UAcwB3AB0qLSqBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQBB+uzIAAsGOwBLAD0qAEGg7cgACxN8AIEAgQCBAIEAAAAAAHIAAAB5AEHC7cgACwd8AIEAgQCBAEHo7cgACyF6AAAAAAA9DAAAAABNKl0qayp4KgAAhCqSKqIqAAB1AIEAQZLuyAALF7AqgQCBAIEAgQCBAIEAgQAAAHwAAAB8AEG07sgAC5YBeQAAAHcAgQCBAIEAgQCBAIEAgQCBAEEAwCpHAMYq1irmKsIqSQDIKvIqAisSKyIrQQDAKkcALis+K0MAKitOK14r2CpFAMQqSwBBAMAqRwDGKtYqQwDCKkkAyCrYKkUAxCpLAEEAwCpHAG4rfiuOK54rriuEK5QrpCt6K4ormiuqK4ArVQOgK1UDhiuWK74rzivUK9ArAEHa78gAC6MCdACiBQwFgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAABxAOQrgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQD0K/wrCiwaLCosOixKLIEAWCyBAIEAgQCBAIEAgQCBAAAAAABzAGcsjgWBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAADoCIEAAAAAALgCegeBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAdyx2AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAABwBo0FgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAhyxxAEGW8sgAC58BTwqXLIEAgQCnLLcsxywAANMsjgWBAIEAgQCBAIEAgQCBAIEAgQCBAAwFAAAAAAAAewCBAIEAgQCBAAwFAAAAAHIAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEA4yzzLAMtEy0hLTEtQS1RLWEtcS2ALXEtgQCBAIEAfgCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAB0AEHC88gAC018AHEADAUMBQwFAAB6AJAtWBagLUEAsC0AAMAtAAAAANAtcgCBAIEAgQB3BQAA4C3wLQAuEC4gLjAuegCBAIEAgQCBAIEAgQCBAIEAgQBBsPTIAAsFkAVzAHMAQcT0yAALApEFAEHQ9MgACyV2AHQAfwB0AAAAAAAAAHgAdgAAAAAAeAAAAHIAdAB+AIEAgQCBAEGW9cgACxV8AHIAcwB6BwAAAAAAANwJTwZ2AHcAQb71yAALAlUHAEHK9cgACwI9KgBB6PXIAAsDgQCBAEGS9sgACwF2AEGs9sgACwFyAEHq9sgACwF+AEGo98gACwF/AEG098gAC7UBcgCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQC5QLmAucC6ALpAuoC6wLsAu0C7gLvAuAC8QLyAvMC9AL1AvYC9wL4AvkC+gL7AvwC/QL+Av8C8AMBAwIDAwMEAwUDCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQBBkvnIAAsBdQBByvnIAAvSBYEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAwyLDIsMiwyLDIsMiwyLDIsMiwyLDIsMiwyLDIsMigQB5AJkAuQDZAPkAGQE5AVkBeQGWAbYBzgHuAQ0CLQJNAm0CjQKrArYBtgHLAusCCwMrA0sDtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AWsDiQOpA8kD6QPpA+kD6QPpA+kD6QPpA+kD6QPpA+8DtgG2AbYBtgEPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQfBD8EXwR/BJ8EvwTfBP8EHwU/BV8FeQWZBbkF2QX5BRkGOQZZBnQGtgGUBrQGDwQPBA8EDwTJBrYBtgHpBrYBtgG2AbYBtgHvBrYBDwcPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQfBw8EDwQPBLYBPwdYB3QHtgG2AbYBtgG2AbYBtgG2AZQHtgG2AbQHDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwTFB+UH/AcPBA8EDwQPBBwIDwQPBA8EDwQPBA8EPAhRCHEIkQixCNEItgHxCA8EAQkhCTgJSwlrCYsJDwSkCcQJ5AkECrYBFwo3ClIKDwQPBLYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBcgq2AbYBtgG2AbYBtgG2AYIKoQq2AbYBtgG2AbYBtgG2AbcKtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgHCCrYB4QoPBA8EDwQPBAELIQsPBA8EtgG2AbYBtgG2AbYBtgG2AbYBQQu2AbYBtgG2AbYBtgG2AVYLDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBO7/AEGggckAC2hhAABAYgAAQGMAAEBkAABAZQAAQGYAAEBnAABAaAAAQGkAAEBqAABAawAAQGwAAEBtAABAbgAAQG8AAEBwAABAcQAAQHIAAEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQABBnIPJAAuEAf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQABBvITJAAvAByAAhEEAAAAAYQAAQAAAAAAAAAAA/////wAAAAAgAIJBAAAAAAAAAAAyAABAMwAAQCCAgEG8AwBAAAAAAAAAAAAggJNBMQAAQG8AAEAAAAAAAQA6TAEAN0wBADRMAAAAAGEAgEFhgIBBYQCBQWGAgUFhAIRBYQCFQeYAAEBjgJNBZQCAQWWAgEFlAIFBZQCEQWkAgEFpgIBBaQCBQWkAhEHwAABAboCBQW8AgEFvgIBBbwCBQW+AgUFvAIRBAAAAAPgAAEB1AIBBdYCAQXUAgUF1AIRBeYCAQf4AAEAAAAAAYQCAAWGAgAFhAIEBYYCBAWEAhAFhAIUBAAAAAGOAkwFlAIABZYCAAWUAgQFlAIQBaQCAAWmAgAFpAIEBaQCEAQAAAABugIEBbwCAAW+AgAFvAIEBb4CBAW8AhAEAAAAAAAAAAHUAgAF1gIABdQCBAXUAhAF5gIABAAAAAHkAhAFhAIJBYQCCAWEAg0FhAIMBYQCUQWEAlAFjgIBBY4CAAWMAgUFjAIEBY4CDQWOAgwFjAIZBYwCGAWQAhkFkAIYBEQEAQAAAAABlAIJBZQCCAWUAg0FlAIMBZYCDQWWAgwFlAJRBZQCUAWUAhkFlAIYBZwCBQWcAgQFnAINBZwCDAWeAg0FngIMBZ4CTQWeAkwFoAIFBaACBAScBAEAAAAAAaYCBQWmAgQFpAIJBaQCCAWkAg0FpAIMBaQCUQWkAlAFpgINBAAAAAAAAMEwAADBMagCBQWoAgQFrgJNBa4CTAQAAAABsgIBBbICAAWyAk0FsgJMBbACGQWwAhgEAACxMQgEAQAAAAABugIBBboCAAW6Ak0FugJMBbgCGQW4AhgEAACpMSwEAQAAAAABvAIJBbwCCAW8Ag0FvAIMBb4CFQW+AhQFTAQBAAAAAAHKAgEFygIABcoCTQXKAkwFyAIZBcgCGAXOAgEFzgIABcwCBQXMAgQFzgJNBc4CTAXMAhkFzAIYBdICTQXSAkwF0AIZBdACGAWcBAEAAAAAAdYCBQXWAgQF1AIJBdQCCAXUAg0F1AIMBdQCFQXUAhQF1gIVBdYCFAXUAlEF1AJQBdwCBQXcAgQF5AIFBeQCBAXkAhEF6gIBBeoCAAXqAg0F6gIMBegCGQXoAhgFzAABAAAAAAFMCAECDAQBAAAAAAIUBAEAAAAAAVAIAQIgBAEAAAAAAVgIAQFcCAECMAQBAAAAAAAAAAADdAQBAWQIAQFsCAECSAQBAAAAAAGACAEBjAgBAAAAAAGkCAEBoAgBAmQEAQABBiIzJAAt0bwIAQHICAEAAAAAAdQIAQG+AjUFvgI0BowEAQAAAAAClAQBAAAAAAIACAECoAQBAAAAAAIMCAEAAAAAAAAAAAK0BAEAAAAAAiAIAQHWAjUF1gI0BigIAQIsCAEC0AQBAAAAAALYBAEAAAAAAkgIAQLkBAEAAQYiNyQALBL0BAEAAQZyNyQALwAMBACFMAQAhTAEAIUwAABtMAAAbTAAAG0wAABVMAAAVTAAAFUxhAIZBYQCGAWkAhkFpAIYBbwCGQW8AhgF1AIZBdQCGAREA/0IRAP8CEQD5QhEA+QIRAPNCEQDzAhEA7UIRAO0CAAAAABEA50IRAOcCEQDhQhEA4QLmAIJB5gCCAeUBAEAAAAAAZwCGQWcAhgFrAIZBawCGAW8AlEFvAJQBEQDbQhEA2wKSAoZBkgKGAWoAhgEAAA9MAAAPTAAAD0xngIBBZ4CAAZUBAEC/AQBAbgCAQW4AgAERANVCEQDVAuaAgEHmgIAB+ICAQfiAgAFhgIdBYYCHAWGAiEFhgIgBZYCHQWWAhwFlgIhBZYCIAWmAh0FpgIcBaYCIQWmAiAFvgIdBb4CHAW+AiEFvgIgBcoCHQXKAhwFygIhBcoCIAXWAh0F1gIcBdYCIQXWAiAFzAJNBcwCTAXQAk0F0AJMBHQIAQAAAAABoAIZBaACGAZ4BAEAAAAAAIwIAQAAAAAAlAgBAAAAAAGGAg0FhgIMBZYCTQWWAkwERAM9CEQDPAhEAyUIRAMkCb4CDQW+AgwERAMNCEQDDAnkAgkF5AIIBAEH0kMkAC1BlLABAPAIAQAAAAACaAQBAZiwAQAAAAABCAgBAAAAAAIABAECJAgBAjAIAQEcCAEAAAAAASQIAQAAAAABLAgBAAAAAAE0CAEAAAAAATwIAQABBiJPJAAskaAAAQGYCAEBqAABAcgAAQHkCAEB7AgBAgQIAQHcAAEB5AABAAEGMlMkACzQgAINBIICDQSAAhUEgAJRBIICBQSCAhUEAAAAAAAAAAGMCAEBsAABAcwAAQHgAAECVAgBAAEGslckAC+wD5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA6NgAgNzYAIDc2ACA3NgAgNzYAIDo2ACA2NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACAytgAgMrYAIDc2ACA3NgAgNzYAIDc2ACAytgAgMrYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgAHYAIAB2ACAAdgAgAHYAIAB2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObZAMDm2QDA5tgAgObZAMDm2QDAuQMAQObYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDc2ACA3NgAgP/////m2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgOjYAIDc2ACA3NgAgObYAIDp2ACA6tgAgOrYAIDp2ACA6tgAgOrYAIDp2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgHEDAEAAAAAAcwMAQAAAAAC5AgBAAAAAAHcDAEAAAAAA/f8AQP3/AEAAAE1NAEGkmckAC8sBOwAAQPMDAED9/wBA/f8AQP3/AED9/wBAIICAQREA3Euxg4BBtwAAQLWDgEG3g4BBuYOAQf3/AEC/g4BB/f8AQMWDgEHJg4BBEQAeALEDAECyAwBAswMAQLQDAEC1AwBAtgMAQLcDAEC4AwBAuQMAQLoDAEC7AwBAvAMAQL0DAEC+AwBAvwMAQMADAEDBAwBA/f8AQMMDAEDEAwBAxQMAQMYDAEDHAwBAyAMAQMkDAEC5A4RBxQOEQbGDgAG1g4ABt4OAAbmDgAERABUAQaybyQALmAO5A4QBxQOEAb+DgAHFg4AByYOAAdcDAECyAwBAuAMAQMUDAEDFg4BBxQOEQcYDAEDAAwBAAAAAANkDAEAAAAAA2wMAQAAAAADdAwBAAAAAAN8DAEAAAAAA4QMAQAAAAADjAwBAAAAAAOUDAEAAAAAA5wMAQAAAAADpAwBAAAAAAOsDAEAAAAAA7QMAQAAAAADvAwBAAAAAALoDAEDBAwBAwwMAQAAAAAC4AwBAtQMAQAAAAAD4AwBAAAAAAMMDAED7AwBAAAAAAAAAAAB7AwBAfAMAQH0DAEA1BIBBNQSEQVIEAEAzhIBBVAQAQFUEAEBWBABAVgSEQVgEAEBZBABAWgQAQFsEAEA6hIBBOASAQUMEg0FfBABAMAQAQDEEAEAyBABAMwQAQDQEAEA1BABANgQAQDcEAEA4BABAOASDQToEAEA7BABAPAQAQD0EAEA+BABAPwQAQEAEAEBBBABAQgQAQEMEAEBEBABARQQAQEYEAEBHBABASAQAQEkEAEBKBABASwQAQEwEAEBNBABATgQAQE8EAEAAQeieyQALBDgEgwEAQayfyQALEDUEgAE1BIQBAAAAADOEgAEAQcifyQALBFYEhAEAQdyfyQAL9Ac6hIABOASAAUMEgwEAAAAAYQQAQAAAAABjBABAAAAAAGUEAEAAAAAAZwQAQAAAAABpBABAAAAAAGsEAEAAAAAAbQQAQAAAAABvBABAAAAAAHEEAEAAAAAAcwQAQAAAAAB1BABAAAAAAHWEh0F1hIcBeQQAQAAAAAB7BABAAAAAAH0EAEAAAAAAfwQAQAAAAACBBABAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgAAAAAAAAAAAiwQAQAAAAACNBABAAAAAAI8EAEAAAAAAkQQAQAAAAACTBABAAAAAAJUEAEAAAAAAlwQAQAAAAACZBABAAAAAAJsEAEAAAAAAnQQAQAAAAACfBABAAAAAAKEEAEAAAAAAowQAQAAAAAClBABAAAAAAKcEAEAAAAAAqQQAQAAAAACrBABAAAAAAK0EAEAAAAAArwQAQAAAAACxBABAAAAAALMEAEAAAAAAtQQAQAAAAAC3BABAAAAAALkEAEAAAAAAuwQAQAAAAAC9BABAAAAAAL8EAEAAAAAAzwQAQDYEg0E2BIMBxAQAQAAAAADGBABAAAAAAMgEAEAAAAAAygQAQAAAAADMBABAAAAAAM4EAEAAAAAAAAAAADAEg0EwBIMBMASEQTAEhAHVBABAAAAAADUEg0E1BIMB2QQAQAAAAADZBIRB2QSEATYEhEE2BIQBNwSEQTcEhAHhBABAAAAAADgEgkE4BIIBOASEQTgEhAE+BIRBPgSEAekEAEAAAAAA6QSEQekEhAFNBIRBTQSEAUMEgkFDBIIBQwSEQUMEhAFDhIVBQ4SFAUcEhEFHBIQB9wQAQAAAAABLBIRBSwSEAfsEAEAAAAAA/QQAQAAAAAD/BABAAAAAAAEFAEAAAAAAAwUAQAAAAAAFBQBAAAAAAAcFAEAAAAAACQUAQAAAAAALBQBAAAAAAA0FAEAAAAAADwUAQAAAAAARBQBAAAAAABMFAEAAAAAAFQUAQAAAAAAXBQBAAAAAABkFAEAAAAAAGwUAQAAAAAAdBQBAAAAAAB8FAEAAAAAAIQUAQAAAAAAjBQBAAAAAACUFAEAAAAAAJwUAQAAAAAApBQBAAAAAACsFAEAAAAAALQUAQAAAAAAvBQBAAAAAAP3/AEBhBQBAYgUAQGMFAEBkBQBAZQUAQGYFAEBnBQBAaAUAQGkFAEBqBQBAawUAQGwFAEBtBQBAbgUAQG8FAEBwBQBAcQUAQHIFAEBzBQBAdAUAQHUFAEB2BQBAdwUAQHgFAEB5BQBAegUAQHsFAEB8BQBAfQUAQH4FAEB/BQBAgAUAQIEFAECCBQBAgwUAQIQFAECFBQBAhgUAQP3/AED9/wBAAEHuqMkACwINTABB/KjJAAsI/f8AQP3/AEAAQZCpyQALgAL9/wBA3NgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA3tgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgN7YAIDk2ACA5tgAgArYAIAL2ACADNgAgA3YAIAO2ACAD9gAgBDYAIAR2ACAEtgAgBPYAIAT2ACAFNgAgBXYAIAW2ACAAAAAABfYAIAAAAAAGNgAgBnYAIAAAAAA5tgAgNzYAIAAAAAAEtgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEH8q8kACxD9/wBA/f8AQP3/AED9/wBAAEGkrMkACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB+KzJAAs05tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAe2ACAH9gAgCDYAIAAAAAA/f8AQABBwK3JAAsUJ4YpAycGKgNIBioDJ4YqA0oGKgMAQbiuyQALVBvYAIAc2ACAHdgAgB7YAIAf2ACAINgAgCHYAIAi2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgABBzK/JAAsEI9gAgABB4q/JAAsOC0wAAAlMAACeRgAAB0wAQYywyQALDNUGKgMAAAAAwQYqAwBB2LDJAAts0gYqAwAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AEAAAAAA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAAAAAAAAAADm2ACA5tgAgAAAAADc2ACA5tgAgObYAIDc2ACAAEGMsskACxD9/wBA/f8AQAAAAAAk2ACAAEGUs8kAC3Dm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA5tgAgNzYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA3NgAgObYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgP3/AED9/wBAAEHQtckACzj9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABBtLfJAAsk5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAEH0t8kACwz9/wBA/f8AQNzYAIAAQdi4yQALaObYAIDm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBAAEH8uckACwT9/wBAAEHkuskACxzc2ACA3NgAgNzYAID9/wBA/f8AQAAAAAD9/wBAAEGsu8kACxT9/wBA/f8AQP3/AED9/wBA/f8AQABBgLzJAAtE/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEDm2ACA5tgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIAAQcS9yQAL2AHm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgBvYAIAc2ACAHdgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQcDAyQALBCgJngQAQeDAyQALEDAJngQAAAAAAAAAADMJngQAQYzByQALBAfYAIAAQcTByQALBAnYAIAAQdTByQALEObYAIDc2ACA5tgAgObYAIAAQfDByQALIBUJnkQWCZ5EFwmeRBwJnkQhCZ5EIgmeRCsJnkQvCZ5EAEGQw8kACwT9/wBAAEG0w8kACxj9/wBA/f8AQAAAAAAAAAAA/f8AQP3/AEAAQaTEyQALBP3/AEAAQcTEyQALFP3/AEAAAAAA/f8AQP3/AED9/wBAAEHoxMkACxT9/wBA/f8AQAfYAIAAAAAAAAAAgABBkMXJAAts/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAADBAgAAvwIJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAgP3/AED9/wBA/f8AQP3/AEChCd5EogneRP3/AECvCd5EAEGMxskACwj9/wBA/f8AQABB9MbJAAsI5tgAgP3/AEAAQYjHyQALBP3/AEAAQaTHyQALIP3/AED9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAEGcyMkACwT9/wBAAEG8yMkACzT9/wBAAAAAADIKHkX9/wBAAAAAADgKHkX9/wBAAAAAAAAAAAD9/wBA/f8AQAfYAID9/wBAAEH8yMkAC4wB/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQP3/AEAAAAAAAAAAAAnYAID9/wBA/f8AQP3/AEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBYKHkUXCh5FHAoeRQAAAAD9/wBAKwoeRf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQczKyQALJP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB/MrJAAsE/f8AQABBpMvJAAsE/f8AQABBtMvJAAsE/f8AQABBkMzJAAsE/f8AQABBsMzJAAsQ/f8AQAAAAAAAAAAA/f8AQABB1MzJAAsM/f8AQP3/AEAH2ACAAEH4zMkACwT9/wBAAEGIzckAC1j9/wBAAAAAAAAAAAAJ2ACA/f8AQP3/AEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHwzckACwj9/wBA/f8AQABBqM7JAAsc/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB4M7JAAsE/f8AQABB8M7JAAsE/f8AQABBlM/JAAsY/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAEGE0MkACwT9/wBAAEGk0MkACxD9/wBAAAAAAAAAAAD9/wBAAEHI0MkACxT9/wBA/f8AQAfYAIAAAAAAAAAAgABB8NDJAAto/f8AQP3/AEAAAAAAAAC9Av3/AED9/wBAAAC7AgAAuQIJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAACAAAAAgP3/AED9/wBA/f8AQP3/AEAhC55FIgueRf3/AEAAQezRyQALCP3/AED9/wBAAEG80skACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQABBgNPJAAsM/f8AQP3/AED9/wBAAEGY08kACwT9/wBAAEGm08kAC063AgAAAAD9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AEAAAAAA/f8AQAAAAAAAAAAA/f8AQP3/AED9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AEAAQYDUyQALDP3/AED9/wBA/f8AQABBvNTJAAsU/f8AQP3/AED9/wBA/f8AQAAAAIAAQdzUyQALDP3/AED9/wBA/f8AQABB9NTJAAt0/f8AQAAAtQIAALMCAACxAgnYAID9/wBA/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQbzWyQALFP3/AED9/wBA/f8AQP3/AED9/wBAAEGE18kACwT9/wBAAEGU18kACwT9/wBAAEH018kACwT9/wBAAEG42MkACwz9/wBA/f8AQAfYAIAAQdjYyQALFP3/AEAAAAAAAAAAAEYMKwb9/wBAAEH42MkACywJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQFTYAIBb2ACA/f8AQABBsNnJAAsU/f8AQP3/AEAAAAAA/f8AQP3/AEAAQdTZyQALCP3/AED9/wBAAEGE2skACxz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHU2skACwT9/wBAAEHk2skACwT9/wBAAEHE28kACwT9/wBAAEHw28kACwT9/wBAAEGI3MkACwz9/wBA/f8AQAfYAIAAQaLcyQALfq8CAAAAAAAAAIAAAAAAAAAAAP3/AEAAAAAAAACtAgAAqwL9/wBAAACoAgEAqAIAAAAACdgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAACAAAAAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQABBsN3JAAsI/f8AQP3/AEAAQeDdyQALBP3/AEAAQfDdyQALMP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB1N7JAAsE/f8AQABB5N7JAAsE/f8AQABBjODJAAsQCdgAgAnYAIAAAAAAAAAAgABBsODJAAsE/f8AQABBwODJAAss/f8AQAAApgIAAKQCAACiAgnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AEAAQfvgyQALAYAAQazhyQALCP3/AED9/wBAAEGc4skACwT9/wBAAEGs4skACwT9/wBAAEH44skACwz9/wBA/f8AQP3/AEAAQeTjyQALBP3/AEAAQYzkyQALEP3/AEAAAAAA/f8AQP3/AEAAQbjkyQALJP3/AED9/wBA/f8AQAnYAID9/wBA/f8AQP3/AED9/wBAAAAAgABB8OTJAAtE/f8AQAAAAAD9/wBAAAAAAAAAAADZDeUGAAAAAAAAnwIBAJ8CAACdAgAAAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdzlyQALCP3/AED9/wBAAEHw5ckACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB5ufJAAsCBUwAQfjnyQALHGfYAIBn2ACACdgAgP3/AED9/wBA/f8AQP3/AEAAQbToyQALEGvYAIBr2ACAa9gAgGvYAIAAQYTpyQALpAH9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AEAAAAAA/f8AQABBvOrJAAsE/f8AQABBoOvJAAsM/f8AQAAAAAD9/wBAAEHe68kACwIDTABB8OvJAAsMdtgAgHbYAIAJ2ACAAEGI7MkACwj9/wBA/f8AQABBpOzJAAsc/f8AQAAAAAD9/wBAetgAgHrYAIB62ACAetgAgABBzOzJAAsE/f8AQABB+OzJAAuYAf3/AED9/wBAAAABTAAA/0sAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHA7skACwQLDwBAAEHw7skACwjc2ACA3NgAgABB5O/JAAsU3NgAgAAAAADc2ACAAAAAANjYAIAAQZLwyQALAptCAEGk8MkACwT9/wBAAEG68MkACwKZQgBBzvDJAAsCl0IAQeLwyQALApVCAEH28MkACwKTQgBBqvHJAAsCkUIAQbjxyQALbP3/AED9/wBA/f8AQP3/AECB2ACAgtgAgADZAMCE2ACAANkAwLIPwEcRAPxLsw/ARxEA+UuC2ACAgtgAgILYAICC2ACAAAAAAAAAAACC2ACAANkAwObYAIDm2ACACdgAgAAAAADm2ACA5tgAgABB0vLJAAsCj0IAQeTyyQALBP3/AEAAQfryyQALAo1CAEGO88kACwKLQgBBovPJAAsCiUIAQbbzyQALAodCAEHq88kACwKFQgBB+PPJAAsE/f8AQABBlPTJAAsE3NgAgABBsPTJAAsE/f8AQABB6PTJAAuUAf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQZb2yQALAoMCAEG39skACwGAAEHU9skACxAH2ACAAAAAAAnYAIAJ2ACAAEGY98kACwTc2ACAAEGl98kAC78BLQBAAS0AQAItAEADLQBABC0AQAUtAEAGLQBABy0AQAgtAEAJLQBACi0AQAstAEAMLQBADS0AQA4tAEAPLQBAEC0AQBEtAEASLQBAEy0AQBQtAEAVLQBAFi0AQBctAEAYLQBAGS0AQBotAEAbLQBAHC0AQB0tAEAeLQBAHy0AQCAtAEAhLQBAIi0AQCMtAEAkLQBAJS0AQP3/AEAnLQBA/f8AQP3/AED9/wBA/f8AQP3/AEAtLQBA/f8AQP3/AEAAQZT5yQALBNwQAEAAQdT5yQALQP////8AAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQb/6yQALPYAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQbD7yQALBP3/AEAAQcT7yQALCP3/AED9/wBAAEHo+8kACwz9/wBAAAAAAP3/AEAAQYT8yQALCP3/AED9/wBAAEG4/MkACxT9/wBA/f8AQObYAIDm2ACA5tgAgABB5PzJAAso/f8AQP3/AEDwEwBA8RMAQPITAEDzEwBA9BMAQPUTAED9/wBA/f8AQABBnP3JAAssCdgAgAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdj9yQALcAnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAD9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdj+yQALCP//////////AEGI/8kACwQJ2ACAAEG0/8kACwzm2ACA/f8AQP3/AEAAQez/yQALFP//////////////////////////AEGkgMoACxzk2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBAAEHkgMoACxze2ACA5tgAgNzYAID9/wBA/f8AQP3/AED9/wBAAEGcgcoACwjm2ACA3NgAgABBsIHKAAsU/f8AQP3/AEAAAAAAAAAAAAnYAIAAQYCCygALqAHm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDc2ACAAAAAANzYAIDm2ACA5tgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgP3/AEAAQcKDygALIoECAAAAAAAAfwIAAAAAAAB9AgAAAAAAAHsCAAAAAAAAeQIAQe6DygALAncCAEGkhMoACwgH2ACAAAAAgABBwoTKAAsKdQIAAAAAAABzAgBB1oTKAAsScQIAAG8CAAAAAAAAbQIJ2ACAAEGIhcoACwT9/wBAAEG4hcoACxTm2ACA3NgAgObYAIDm2ACA5tgAgABB9IXKAAsICdgAgAnYAIAAQYyGygALKAnYAIAJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdCGygALEAfYAID9/wBA/f8AQP3/AEAAQfSGygAL5AIyBABANAQAQD4EAEBBBABAQgQAQEIEAEBKBABAYwQAQEumAECKHABAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA0BAAQNEQAEDSEABA0xAAQNQQAEDVEABA1hAAQNcQAEDYEABA2RAAQNoQAEDbEABA3BAAQN0QAEDeEABA3xAAQOAQAEDhEABA4hAAQOMQAEDkEABA5RAAQOYQAEDnEABA6BAAQOkQAEDqEABA6xAAQOwQAEDtEABA7hAAQO8QAEDwEABA8RAAQPIQAEDzEABA9BAAQPUQAED2EABA9xAAQPgQAED5EABA+hAAQP3/AED9/wBA/RAAQP4QAED/EABA5tgAgObYAIDm2ACAAAAAAAHYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA3NgAgObYAIAAAAAAAdgAgAHYAIAB2ACAAdgAgAHYAIAB2ACAAdgAgABB6InKAAsE3NgAgABB/InKAAsE5tgAgABBjIrKAAsg5tgAgObYAIAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdyKygAL/AFhAABA5gAAQGIAAEAAAAAAZAAAQGUAAEDdAQBAZwAAQGgAAEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEAAAAAAbwAAQCMCAEBwAABAcgAAQHQAAEB1AABAdwAAQGEAAEBQAgBAUQIAQAIdAEBiAABAZAAAQGUAAEBZAgBAWwIAQFwCAEBnAABAAAAAAGsAAEBtAABASwEAQG8AAEBUAgBAFh0AQBcdAEBwAABAdAAAQHUAAEAdHQBAbwIAQHYAAEAlHQBAsgMAQLMDAEC0AwBAxgMAQMcDAEBpAABAcgAAQHUAAEB2AABAsgMAQLMDAEDBAwBAxgMAQMcDAEAAQfiMygALBD0EAEAAQaiNygALhBNSAgBAYwAAQFUCAEDwAABAXAIAQGYAAEBfAgBAYQIAQGUCAEBoAgBAaQIAQGoCAEB7HQBAnQIAQG0CAECFHQBAnwIAQHECAEBwAgBAcgIAQHMCAEB0AgBAdQIAQHgCAECCAgBAgwIAQKsBAECJAgBAigIAQBwdAECLAgBAjAIAQHoAAECQAgBAkQIAQJICAEC4AwBA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgOrYAIDW2ACA3NgAgMrYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA5NgAgOTYAIDc2ACA2tgAgObYAIDp2ACA3NgAgObYAIDc2ACAYYCSQWGAkgFigINBYoCDAWKAkUFigJEBYoCYQWKAmAERAGdCEQBnAmSAg0FkgIMBZICRQWSAkQFkgJhBZICYAWSAk0FkgJMBZICWQWSAlgERAGFCEQBhAhEAW0IRAFsCZYCWQWWAlgFlAJhBZQCYAREAVUIRAFUCZoCDQWaAgwFnAIJBZwCCAWiAg0FogIMBaICRQWiAkQFoAIRBaACEAWiAk0FogJMBaACXQWgAlwFpAJhBaQCYAREAT0IRAE8Ca4CAQWuAgAFrgJFBa4CRAWuAmEFrgJgBbICRQWyAkQERAElCEQBJAmyAmEFsgJgBbICWQWyAlgFtgIBBbYCAAW2Ag0FtgIMBbYCRQW2AkQFugINBboCDAW6AkUFugJEBboCYQW6AmAFugJZBboCWAREAQ0IRAEMCEQA9QhEAPQIRADdCEQA3AhEAMUIRADECcICAQXCAgAFwgINBcICDAXKAg0FygIMBcoCRQXKAkQERACtCEQArAnKAmEFygJgBc4CDQXOAgwFzgJFBc4CRAREAJUIRACUCEQAfQhEAHwIRABlCEQAZAnSAg0F0gIMBdICRQXSAkQF0gJhBdICYAXSAlkF0gJYBdQCSQXUAkgF1AJhBdQCYAXWAlkF1gJYBEQATQhEAEwIRAA1CEQANAnaAgUF2gIEBdoCRQXaAkQF3AIBBdwCAAXeAgEF3gIABdwCEQXcAhAF3gINBd4CDAXeAkUF3gJEBeICDQXiAgwF4AIRBeACEAXmAg0F5gIMBegCBQXoAgQF6gJFBeoCRAXqAmEF6gJgBaICYAXQAhAF3AIUBeQCFAQAA90tzgINBAAAAAAAAAADfAABAAAAAAGGAkUFhgJEBYYCEQWGAhAERAAdCEQAHAhEAAUIRAAECEQD7QREA+wERAPVBEQD1AREA70ERAO8BEQDpQREA6QERAONBEQDjAREA3UERAN0BEQDXQREA1wERANFBEQDRAWWAkUFlgJEBZYCEQWWAhAFlgIFBZYCBAREAy0ERAMsBEQDFQREAxQERAL9BEQC/AREAuUERALkBEQCzQREAswFpgIRBaYCEAWmAkUFpgJEBb4CRQW+AkQFvgIRBb4CEAREArUERAK0BEQCnQREApwERAKFBEQChAREAm0ERAJsBEQCVQREAlQERAI9BEQCPAREAiUERAIkBEQCDQREAgwERAH1BEQB9AREAd0ERAHcBdYCRQXWAkQF1gIRBdYCEAREAcUERAHEBEQBrQREAawERAGVBEQBlAREAX0ERAF8BEQBZQREAWQF5AIBBeQCAAXmAkUF5gJEBeYCEQXmAhAF5gIFBeYCBAfseAEAAAAAA/R4AQAAAAAD/HgBAAAAAALGDiQGxA4oBEQDgABEA3AARANgAEQDUABEA0AARAMwAsYOJQbEDikERAOBAEQDcQBEA2EARANRAEQDQQBEAzEC1g4kBtQOKAREAVgERAFMBEQBQAREATQH9/wBA/f8AQLWDiUG1A4pBEQBWQREAU0ERAFBBEQBNQf3/AED9/wBAt4OJAbcDigERAKQAEQCgABEAnAARAJgAEQCUABEAkAC3g4lBtwOKQREApEARAKBAEQCcQBEAmEARAJRAEQCQQLmDiQG5A4oBEQA+AREAOwERADgBEQA1AREAMgERAC8BuYOJQbkDikERAD5BEQA7QREAOEERADVBEQAyQREAL0G/g4kBvwOKAREAGgERABcBEQAUAREAEQH9/wBA/f8AQL+DiUG/A4pBEQAaQREAF0ERABRBEQARQf3/AED9/wBAxYOJAcUDigERAAIBEQD/ABEA/AARAPkAEQD2ABEA8wD9/wBAxQOKQf3/AEARAP9A/f8AQBEA+UD9/wBAEQDzQMmDiQHJA4oBEQBoABEAZAARAGAAEQBcABEAWAARAFQAyYOJQckDikERAGhAEQBkQBEAYEARAFxAEQBYQBEAVECxA4ABsYOAQbUDgAG1g4BBtwOAAbeDgEG5A4ABuYOAQb8DgAG/g4BBxQOAAcWDgEHJA4AByYOAQf3/AED9/wBAAQBKTQEAR00CAENNAgA/TQIAO00CADdNAgAzTQIAL00BAEpNAQBHTQIAQ00CAD9NAgA7TQIAN00CADNNAgAvTQEALE0BAClNAgAlTQIAIU0CAB1NAgAZTQIAFU0CABFNAQAsTQEAKU0CACVNAgAhTQIAHU0CABlNAgAVTQIAEU0BAA5NAQALTQIAB00CAANNAgD/TAIA+0wCAPdMAgDzTAEADk0BAAtNAgAHTQIAA00CAP9MAgD7TAIA90wCAPNMsQODAbEDggEBAPBMAADoTAEA7Uz9/wBAsQOhAQEA6kyxA4NBsQOCQbEDgEGxg4BBAADoTCCAiUG5AwBAIICJQSAAoUERAPRLAQDlTAAA3UwBAOJM/f8AQLcDoQEBAN9MtQOAQbWDgEG3A4BBt4OAQQAA3UwRAPFLEQDuSxEA60u5A4MBuQOCAREAIQARAB5A/f8AQP3/AEC5A6EBEQAbALkDg0G5A4JBuQOAQbmDgEH9/wBAEQDoSxEA5UsRAOJLxQODAcUDggERABgAEQAVQMGDiQHBA4oBxQOhAREAEgDFA4NBxQOCQcUDgEHFg4BBwQOKQREA30sRANxLYAAAQP3/AED9/wBAAQDaTAAA0kwBANdM/f8AQMkDoQEBANRMvwOAQb+DgEHJA4BByYOAQQAA0kwggIBBIACKQf3/AEAgAABAIAAAQCAAAEAgAABAIAAAQCAAAEAgAABAIAAAQCAAAEAgAABAIAAAQP////8AAAAAAAAAAP3/AED9/wBAAAAAABAgAEAAQcCgygALBCCAmUEAQeSgygALMP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQABBoqHKAAsSz0sBAM9LAAAAAAAA2UsBANlLAEHGocoACwrWSwAAAAAggIJBAEHuocoACwrUSwAA1UsAANNLAEGUosoACwQCAM9LAEG0osoAC4QCIAAAQP///////////////////////////f8AQP3/AED9/wBA/f8AQP3/AED///////////////////////////////8wAABAaQAAQP3/AED9/wBANAAAQDUAAEA2AABANwAAQDgAAEA5AABAKwAAQBIiAEA9AABAKAAAQCkAAEBuAABAMAAAQDEAAEAyAABAMwAAQDQAAEA1AABANgAAQDcAAEA4AABAOQAAQCsAAEASIgBAPQAAQCgAAEApAABA/f8AQGEAAEBlAABAbwAAQHgAAEBZAgBAaAAAQGsAAEBsAABAbQAAQG4AAEBwAABAcwAAQHQAAED9/wBA/f8AQP3/AEAAQdqkygALAtBMAEH4pMoACzTm2ACA5tgAgAHYAIAB2ACA5tgAgObYAIDm2ACA5tgAgAHYAIAB2ACAAdgAgObYAIDm2ACAAEG4pcoACwTm2ACAAEHIpcoAC+QBAdgAgAHYAIDm2ACA3NgAgObYAIAB2ACAAdgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAQDKSwEAx0tjAABAAADOTAAAAAABAMJLAQC/S1sCAEAAAAAAAADMTGcAAEBoAABAaAAAQGgAAEBoAABAJwEAQGkAAEBpAABAbAAAQGwAAEAAAAAAbgAAQAAAykwAAAAAAAAAAHAAAEBxAABAcgAAQHIAAEByAABAAEG2p8oAC37ITAEAxUwAAMNMAAAAAHoAAEAAAAAAyQMAQAAAAAB6AABAAAAAAGsAAEAQANVCYgAAQGMAAEAAAAAAZQAAQGYAAEBOIQBAbQAAQG8AAEDQBQBA0QUAQNIFAEDTBQBAaQAAQAAAAAABAMBMwAMAQLMDAECzAwBAwAMAQBEiAEAAQcSoygALFGQAAEBkAABAZQAAQGkAAEBqAABAAEHwqMoAC4ABAQCESwEArksCAKpLAQCnSwEApEsBAKFLAQCeSwEAm0sBAJhLAQCVSwEAkksBAI9LAQCMSwEAiUsBAIZLAACES2kAAEAAAG9LAQBvSwAAd0t2AABAAABzSwEAc0sCAHNLAABxS3gAAEAAAG5LAQBuS2wAAEBjAABAZAAAQG0AAEAAQfypygALBIQhAEAAQZSqygALHAEAa0sAAAAAAAAAAP3/AED9/wBA/f8AQP3/AEAAQdiqygALCJAhnAGSIZwBAEGYq8oACwSUIZwBAEHQq8oACwzQIZwB1CGcAdIhnAEAQeyrygALBAMinAEAQYCsygALEAginAEAAAAAAAAAAAsinAEAQaCsygALDCMinAEAAAAAJSKcAQBBwqzKAAsSrkoBAK5KAAAAAAAAaEsBAGhLAEGQrcoACyQ8IpwBAAAAAAAAAABDIpwBAAAAAAAAAABFIpwBAAAAAEginAEAQcytygALDD0AnAEAAAAAYSKcAQBBgK7KAAs0TSKcATwAnAE+AJwBZCKcAWUinAEAAAAAAAAAAHIinAFzIpwBAAAAAAAAAAB2IpwBdyKcAQBBzK7KAAsoeiKcAXsinAEAAAAAAAAAAIIinAGDIpwBAAAAAAAAAACGIpwBhyKcAQBBpK/KAAsgoiKcAaginAGpIpwBqyKcAXwinAF9IpwBkSKcAZIinAEAQdyvygALELIinAGzIpwBtCKcAbUinAEAQZCwygALCAgwAEAJMABAAEGssMoAC4wDMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAAAD2RgAA80YAAPBGAADtRgAA6kYAAOdGAADkRgAA4UYAAN5GAADbRgAA2EYBAGVLAQBiSwEAX0sBAFxLAQBZSwEAVksBAFNLAQBQSwEATUsCAElLAgBFSwIAQUsCAD1LAgA5SwIANUsCADFLAgAtSwIAKUsCACVLAgAhS/3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAEA/UoBAPpKAQD3SgEA9EoBAPFKAQDuSgEA60oBAOhKAQDlSgEA4koBAN9KAQDcSgEA2UoBANZKAQDTSgEA0EoBAM1KAQDKSgEAx0oBAMRKAQDBSgEAvkoBALtKAQC4SgEAtUoBALJKYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQGgAAEBpAABAagAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEAwAABAAEHos8oACwQCAK5KAEH8s8oACwwBAKtKAACoSgEAqEoAQbi0ygALBN0qnEEAQci0ygALmAIwLABAMSwAQDIsAEAzLABANCwAQDUsAEA2LABANywAQDgsAEA5LABAOiwAQDssAEA8LABAPSwAQD4sAEA/LABAQCwAQEEsAEBCLABAQywAQEQsAEBFLABARiwAQEcsAEBILABASSwAQEosAEBLLABATCwAQE0sAEBOLABATywAQFAsAEBRLABAUiwAQFMsAEBULABAVSwAQFYsAEBXLABAWCwAQFksAEBaLABAWywAQFwsAEBdLABAXiwAQF8sAEBhLABAAAAAAGsCAEB9HQBAfQIAQAAAAAAAAAAAaCwAQAAAAABqLABAAAAAAGwsAEAAAAAAUQIAQHECAEBQAgBAUgIAQAAAAABzLABAAAAAAAAAAAB2LABAAEH4tsoAC5wDagAAQHYAAEA/AgBAQAIAQIEsAEAAAAAAgywAQAAAAACFLABAAAAAAIcsAEAAAAAAiSwAQAAAAACLLABAAAAAAI0sAEAAAAAAjywAQAAAAACRLABAAAAAAJMsAEAAAAAAlSwAQAAAAACXLABAAAAAAJksAEAAAAAAmywAQAAAAACdLABAAAAAAJ8sAEAAAAAAoSwAQAAAAACjLABAAAAAAKUsAEAAAAAApywAQAAAAACpLABAAAAAAKssAEAAAAAArSwAQAAAAACvLABAAAAAALEsAEAAAAAAsywAQAAAAAC1LABAAAAAALcsAEAAAAAAuSwAQAAAAAC7LABAAAAAAL0sAEAAAAAAvywAQAAAAADBLABAAAAAAMMsAEAAAAAAxSwAQAAAAADHLABAAAAAAMksAEAAAAAAyywAQAAAAADNLABAAAAAAM8sAEAAAAAA0SwAQAAAAADTLABAAAAAANUsAEAAAAAA1ywAQAAAAADZLABAAAAAANssAEAAAAAA3SwAQAAAAADfLABAAAAAAOEsAEAAAAAA4ywAQABBtLrKAAs07CwAQAAAAADuLABAAAAAAObYAIDm2ACA8ywAQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQABBhLvKAAso/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQABBzLvKAAtg/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQGEtAEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAJ2ACAAEHUvMoACwT9/wBAAEHovMoACwTNawBAAEH4vMoAC8AHn58AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABOAEAoTgBANk4AQD9OAEBZTgBAhU4AQIxOAECgTgBAuk4AQD9RAEBlUQBAa1EAQIJRAECWUQBAq1EAQOBRAED1UQBAAFIAQJtSAED5UgBAFVMAQBpTAEA4UwBAQVMAQFxTAEBpUwBAglMAQLZTAEDIUwBA41MAQNdWAEAfVwBA61gAQAJZAEAKWQBAFVkAQCdZAEBzWQBAUFsAQIBbAED4WwBAD1wAQCJcAEA4XABAblwAQHFcAEDbXQBA5V0AQPFdAED+XQBAcl4AQHpeAEB/XgBA9F4AQP5eAEALXwBAE18AQFBfAEBhXwBAc18AQMNfAEAIYgBANmIAQEtiAEAvZQBANGUAQIdlAECXZQBApGUAQLllAEDgZQBA5WUAQPBmAEAIZwBAKGcAQCBrAEBiawBAeWsAQLNrAEDLawBA1GsAQNtrAEAPbABAFGwAQDRsAEBrcABAKnIAQDZyAEA7cgBAP3IAQEdyAEBZcgBAW3IAQKxyAECEcwBAiXMAQNx0AEDmdABAGHUAQB91AEAodQBAMHUAQIt1AECSdQBAdnYAQH12AECudgBAv3YAQO52AEDbdwBA4ncAQPN3AEA6eQBAuHkAQL55AEB0egBAy3oAQPl6AEBzfABA+HwAQDZ/AEBRfwBAin8AQL1/AEABgABADIAAQBKAAEAzgABAf4AAQImAAEDjgQBA6oEAQPOBAED8gQBADIIAQBuCAEAfggBAboIAQHKCAEB4ggBATYYAQGuGAEBAiABATIgAQGOIAEB+iQBAi4kAQNKJAEAAigBAN4wAQEaMAEBVjABAeIwAQJ2MAEBkjQBAcI0AQLONAECrjgBAyo4AQJuPAECwjwBAtY8AQJGQAEBJkQBAxpEAQMyRAEDRkQBAd5UAQICVAEAclgBAtpYAQLmWAEDolgBAUZcAQF6XAEBilwBAaZcAQMuXAEDtlwBA85cAQAGYAEComABA25gAQN+YAECWmQBAmZkAQKyZAEComgBA2JoAQN+aAEAlmwBAL5sAQDKbAEA8mwBAWpsAQOWcAEB1ngBAf54AQKWeAEC7ngBAw54AQM2eAEDRngBA+Z4AQP2eAEAOnwBAE58AQCCfAEA7nwBASp8AQFKfAECNnwBAnJ8AQKCfAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQAAAAAAuAABAAEHsxMoACxja2ACA5NgAgOjYAIDe2ACA4NgAgODYAIAAQZzFygALFBIwAEAAAAAAQVMAQERTAEBFUwBAAEHExcoACwT9/wBAAEH0xcoAC3hLsEwYAAAAAE2wTBgAAAAAT7BMGAAAAABRsEwYAAAAAFOwTBgAAAAAVbBMGAAAAABXsEwYAAAAAFmwTBgAAAAAW7BMGAAAAABdsEwYAAAAAF+wTBgAAAAAYbBMGAAAAAAAAAAAZLBMGAAAAABmsEwYAAAAAGiwTBgAQYTHygALOG+wTBhvME0YAAAAAHKwTBhyME0YAAAAAHWwTBh1ME0YAAAAAHiwTBh4ME0YAAAAAHuwTBh7ME0YAEHMx8oACzBGsEwYAAAAAAAAAAD9/wBA/f8AQAjYAIAI2ACAIIBMWCAATVgAAAAAnbBMGAAApkoAQazIygALeKuwTBgAAAAArbBMGAAAAACvsEwYAAAAALGwTBgAAAAAs7BMGAAAAAC1sEwYAAAAALewTBgAAAAAubBMGAAAAAC7sEwYAAAAAL2wTBgAAAAAv7BMGAAAAADBsEwYAAAAAAAAAADEsEwYAAAAAMawTBgAAAAAyLBMGABBvMnKAAs4z7BMGM8wTRgAAAAA0rBMGNIwTRgAAAAA1bBMGNUwTRgAAAAA2LBMGNgwTRgAAAAA27BMGNswTRgAQYTKygALHKawTBgAAAAAAAAAAO+wTBjwsEwY8bBMGPKwTBgAQazKygALiAP9sEwYAACkSv3/AEAAEQBAAREAQKoRAMACEQBArBEAwK0RAMADEQBABBEAQAURAECwEQDAsREAwLIRAMCzEQDAtBEAwLURAMAaEQBABhEAQAcRAEAIEQBAIREAQAkRAEAKEQBACxEAQAwRAEANEQBADhEAQA8RAEAQEQBAEREAQBIRAEBhEQDAYhEAwGMRAMBkEQDAZREAwGYRAMBnEQDAaBEAwGkRAMBqEQDAaxEAwGwRAMBtEQDAbhEAwG8RAMBwEQDAcREAwHIRAMBzEQDAdBEAwHURAMD/////FBEAQBURAEDHEQBAyBEAQMwRAEDOEQBA0xEAQNcRAEDZEQBAHBEAQN0RAEDfEQBAHREAQB4RAEAgEQBAIhEAQCMRAEAnEQBAKREAQCsRAEAsEQBALREAQC4RAEAvEQBAMhEAQDYRAEBAEQBARxEAQEwRAEDxEQBA8hEAQFcRAEBYEQBAWREAQIQRAECFEQBAiBEAQJERAECSEQBAlBEAQJ4RAEChEQBA/f8AQABBvc3KAAvXAk4AQIxOAEAJTgBA21YAQApOAEAtTgBAC04AQDJ1AEBZTgBAGU4AQAFOAEApWQBAMFcAQLpOAEABAKFKAQCeSgEAm0oBAJhKAQCVSgEAkkoBAI9KAQCMSgEAiUoBAIZKAQCDSgEAgEoBAH1KAQB6SgIAdkoCAHJKAgBuSgIAakoCAGZKAgBiSgIAXkoCAFpKAgBWSgIAUkoCAE5KAgBKSgIARkoCAEJKAgA+SgUAN0oEADFK/f8AQAEALkoBACtKAQAoSgEAJUoBACJKAQAfSgEAHEoBABlKAQAWSgEAE0oBABBKAQANSgEACkoBAAdKAQAESgEAAUoBAP5JAQD7SQEA+EkBAPVJAQDySQEA70kBAOxJAQDpSQEA5kkBAONJAQDgSQEA3UkBANpJAQDXSQEA1EkBANFJAQDOSQEAy0kBAMhJAQDFSU9VAEB8XgBAh2UAQI97AEAAQbTQygALgA8BAL1MAADVRgAA0kYAAM9GAADMRgAAyUYAAMZGAADDRgAAwEYAAL1GAAC6RgAAt0YAAMBJAAC+SQAAiEkAALxJABEAQAIRAEADEQBABREAQAYRAEAHEQBACREAQAsRAEAMEQBADhEAQA8RAEAQEQBAEREAQBIRAEAAALpJAAC4SQAAtkkAALRJAACySQAAsEkAAK5JAACsSQAAqkkAAJ1JAACoSQAApkkAAKRJAACiSQMAnUkCAJlJAACXSQAAAAAATgBAjE4AQAlOAEDbVgBAlE4AQG1RAEADTgBAa1EAQF1OAEBBUwBACGcAQGtwAEA0bABAKGcAQNGRAEAfVwBA5WUAQCpoAEAJZwBAPnkAQA1UAEB5cgBAoYwAQF15AEC0UgBA2HkAQDd1AEBzWQBAaZAAQCpRAEBwUwBA6GwAQAWYAEARTwBAmVEAQGNrAEAKTgBALU4AQAtOAEDmXQBA81MAQDtTAECXWwBAZlsAQON2AEABTwBAx4wAQFRTAEAcWQBAAACVSQAAk0kAAJFJAACPSQAAjUkAAItJAACJSQAAh0kAAIVJAACDSQAAgUkAAH9JAAB9SQAAe0kAAHlJAABmSQAAY0kAAHdJAAB1SQAAc0kAAHFJAABvSQAAbUkAAGtJAQBoSQEAZUkBAGJJAAC7TAEAXUkAALlMAQC2TKIwAECkMABApjAAQKgwAECqMABAqzAAQK0wAECvMABAsTAAQLMwAEC1MABAtzAAQLkwAEC7MABAvTAAQL8wAEDBMABAxDAAQMYwAEDIMABAyjAAQMswAEDMMABAzTAAQM4wAEDPMABA0jAAQNUwAEDYMABA2zAAQN4wAEDfMABA4DAAQOEwAEDiMABA5DAAQOYwAEDoMABA6TAAQOowAEDrMABA7DAAQO0wAEDvMABA8DAAQPEwAEDyMABAAABWSQMAUUkCAE1JAwBISQEARUkDAEBJAQA9SQEAOkkEADRJAgAwSQEALUkBACpJAQAnSQIAI0kCAB9JAgAbSQIAF0kCABNJAgAPSQIAC0kEAAVJAAD0SAQA/0gEAPlIAwD0SAIA7kgEAO5IBADoSAIA5EgBAOFIAQDeSAIA2kgCANZIAwDRSAMAzEgBAMlIAQC0SAIAxUgBAMJIAQC/SAAANUgAAL1IAQC6SAEAt0gEALFIAgCtSAMAqEgEAKJIAgCeSAEAm0gBAJhIBACSSAIAjkgEAIhIAQCFSAMAgEgBAH1IAgB5SAEAdkgCAHJIAwBtSAIAaUgDAGRIAgBgSAAAXkgDAFlIAQBWSAEAU0gCAE9IAQBMSAEASUgBAEZIAwBBSAIAPUgAADdIBAA3SAEAMkgDADJIAgAuSAIAKkgBACdIAQAkSAIAIEgAAB5IAgAaSAMAFUgAABNIBAANSAEACkgAAOpHAADnRwAA5EcAAOFHAADeRwAA+UcAAPZHAADzRwAA8EcAAO1HAQAHSAEABEgBAAFIAQD+RwEA+0cBAPhHAQD1RwEA8kcBAO9HAQDsRwEA6UcBAOZHAQDjRwEA4EcBAN1HAQCzTAAA2EcAALFMAQDTRwAAr0wAAM9HAADJRwEAzEcBAMlHAACtTAAAxUcAAMNHAADBRwAAv0cCALtHAACJTAAAq0wAAKlMAACnTAAApUwAAKNMAAAWRwAAc0wBAKhHAgCnRwAAoUwAAJ9MAACdTAAAn0cAAJ1HAAA0RwAAkkwBAJpMAQCXTAEAlEwBAJFMAACPRwAAjUcAAItHAACJRwAAh0cAAIVHAACDRwAAd0cAAHRHAABxRwEAgEcBAH1HAAB7RwEAekcBAHdHAQB0RwAAckcBAHFHAQBtRwIAbUcAAIlMAQCOTAEAi0wBAIhMAQBeRwMAXkcEAF5HAABcRwAAWkcAAFhHAABWRwAASEwAAIZMAACETAAATkwAAIJMAABOTAAAgEwAAH5MAAB8TAAAXEwAAHpMAABcTAAAeEwAAHZM/f8AQAAAdEwAADhHAAA2RwIAcEz9/wBAAABuTAAAbEwAAClHAABqTAAAJUcAAGhMAABxRwAAH0cAABJHAAAdRwEAGkcAABhHAAAWRwEAE0cBABBHAABmTP3/AEABAGNMAABhTAAAA0cAAF9MAABdTAEAWkwBAFdMAAC4RgAA00YAANBGAADNRgAAykYAAMdGAADERgAAwUYAAL5GAQD2RgEA80YBAPBGAQDtRgEA6kYBAOdGAQDkRgEA4UYBAN5GAQDbRgEA2EYBANVGAQDSRgEAz0YBAMxGAQDJRgEAxkYBAMNGAQDARgEAvUYBALpGAQC3RgEAtEZBpgBAAAAAAEOmAEAAAAAARaYAQAAAAABHpgBAAAAAAEmmAEAAAAAAS6YAQAAAAABNpgBAAAAAAE+mAEAAAAAAUaYAQAAAAABTpgBAAAAAAFWmAEAAAAAAV6YAQAAAAABZpgBAAAAAAFumAEAAAAAAXaYAQAAAAABfpgBAAAAAAGGmAEAAAAAAY6YAQAAAAABlpgBAAAAAAGemAEAAAAAAaaYAQAAAAABrpgBAAAAAAG2mAEAAAAAAAAAAAObYAIAAQcTfygALsAHm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAACBpgBAAAAAAIOmAEAAAAAAhaYAQAAAAACHpgBAAAAAAImmAEAAAAAAi6YAQAAAAACNpgBAAAAAAI+mAEAAAAAAkaYAQAAAAACTpgBAAAAAAJWmAEAAAAAAl6YAQAAAAACZpgBAAAAAAJumAEAAAAAASgQAQEwEAEDm2ACA5tgAgABBjOHKAAvYAv3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAAAAAAAAjpwBAAAAAACWnAEAAAAAAJ6cAQAAAAAAppwBAAAAAACunAEAAAAAALacAQAAAAAAvpwBAAAAAAAAAAAAzpwBAAAAAADWnAEAAAAAAN6cAQAAAAAA5pwBAAAAAADunAEAAAAAAPacAQAAAAAA/pwBAAAAAAEGnAEAAAAAAQ6cAQAAAAABFpwBAAAAAAEenAEAAAAAASacAQAAAAABLpwBAAAAAAE2nAEAAAAAAT6cAQAAAAABRpwBAAAAAAFOnAEAAAAAAVacAQAAAAABXpwBAAAAAAFmnAEAAAAAAW6cAQAAAAABdpwBAAAAAAF+nAEAAAAAAYacAQAAAAABjpwBAAAAAAGWnAEAAAAAAZ6cAQAAAAABppwBAAAAAAGunAEAAAAAAbacAQAAAAABvpwBAAEGE5MoACzh6pwBAAAAAAHynAEAAAAAAeR0AQH+nAEAAAAAAgacAQAAAAACDpwBAAAAAAIWnAEAAAAAAh6cAQABBzOTKAAsgjKcAQAAAAABlAgBAAAAAAAAAAACRpwBAAAAAAJOnAEAAQfjkygALyAKXpwBAAAAAAJmnAEAAAAAAm6cAQAAAAACdpwBAAAAAAJ+nAEAAAAAAoacAQAAAAACjpwBAAAAAAKWnAEAAAAAAp6cAQAAAAACppwBAAAAAAGYCAEBcAgBAYQIAQGwCAEBqAgBAAAAAAJ4CAECHAgBAnQIAQFOrAEC1pwBAAAAAALenAEAAAAAAuacAQAAAAAC7pwBAAAAAAL2nAEAAAAAAv6cAQAAAAADBpwBAAAAAAMOnAEAAAAAAlKcAQIICAECOHQBAyKcAQAAAAADKpwBAAAAAAGQCAEDNpwBAAAAAAP3/AED9/wBA0acAQAAAAAD9/wBAAAAAAP3/AEAAAAAA16cAQAAAAADZpwBAAAAAANunAEAAAAAAmwEAQP3/AED9/wBA/f8AQGMAAEBmAABAcQAAQPanAEAAAAAAAAAAACcBAEBTAQBAAEHw58oACxAJ2ACA/f8AQP3/AED9/wBAAEGQ6MoACygJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHk6MoACwzc2ACA3NgAgNzYAIAAQfzoygALOAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAJ2ACAAEHo6coACyz9/wBAAAAAAObYAIAAAAAA5tgAgObYAIDc2ACAAAAAAAAAAADm2ACA5tgAgABBqOrKAAtI5tgAgObYAIAAAAAA5tgAgAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEGI68oACygJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHI68oACwj9/wBA/f8AQABB6OvKAAsE/f8AQABBnOzKAAsQJ6cAQDerAEBrAgBAUqsAQABB0OzKAAvcAo0CAEAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AECgEwBAoRMAQKITAECjEwBApBMAQKUTAECmEwBApxMAQKgTAECpEwBAqhMAQKsTAECsEwBArRMAQK4TAECvEwBAsBMAQLETAECyEwBAsxMAQLQTAEC1EwBAthMAQLcTAEC4EwBAuRMAQLoTAEC7EwBAvBMAQL0TAEC+EwBAvxMAQMATAEDBEwBAwhMAQMMTAEDEEwBAxRMAQMYTAEDHEwBAyBMAQMkTAEDKEwBAyxMAQMwTAEDNEwBAzhMAQM8TAEDQEwBA0RMAQNITAEDTEwBA1BMAQNUTAEDWEwBA1xMAQNgTAEDZEwBA2hMAQNsTAEDcEwBA3RMAQN4TAEDfEwBA4BMAQOETAEDiEwBA4xMAQOQTAEDlEwBA5hMAQOcTAEDoEwBA6RMAQOoTAEDrEwBA7BMAQO0TAEDuEwBA7xMAQABB4O/KAAuYCgnYAID9/wBA/f8AQAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEBIjABA9GYAQMqOAEDIjABA0W4AQDJOAEDlUwBAnJ8AQJyfAEBRWQBA0ZEAQIdVAEBIWQBA9mEAQGl2AECFfwBAP4YAQLqHAED4iABAj5AAQAJqAEAbbQBA2XAAQN5zAEA9hABAapEAQPGZAECCTgBAdVMAQARrAEAbcgBALYYAQB6eAEBQXQBA628AQM2FAEBkiQBAyWIAQNiBAEAfiABAyl4AQBdnAEBqbQBA/HIAQM6QAECGTwBAt1EAQN5SAEDEZABA02oAQBByAEDndgBAAYAAQAaGAEBchgBA740AQDKXAEBvmwBA+p0AQIx4AEB/eQBAoH0AQMmDAEAEkwBAf54AQNaKAEDfWABABF8AQGB8AEB+gABAYnIAQMp4AEDCjABA95YAQNhYAEBiXABAE2oAQNptAEAPbwBAL30AQDd+AEBLlgBA0lIAQIuAAEDcUQBAzFEAQBx6AEC+fQBA8YMAQHWWAECAiwBAz2IAQAJqAED+igBAOU4AQOdbAEASYABAh3MAQHB1AEAXUwBA+3gAQL9PAECpXwBADU4AQMxsAEB4ZQBAIn0AQMNTAEBeWABAAXcAQEmEAECqigBAumsAQLCPAECIbABA/mIAQOWCAECgYwBAZXUAQK5OAEBpUQBAyVEAQIFoAEDnfABAb4IAQNKKAEDPkQBA9VIAQEJUAEBzWQBA7F4AQMVlAED+bwBAKnkAQK2VAEBqmgBAl54AQM6eAECbUgBAxmYAQHdrAEBijwBAdF4AQJBhAEAAYgBAmmQAQCNvAEBJcQBAiXQAQMp5AED0fQBAb4AAQCaPAEDuhABAI5AAQEqTAEAXUgBAo1IAQL1UAEDIcABAwogAQKqKAEDJXgBA9V8AQHtjAECuawBAPnwAQHVzAEDkTgBA+VYAQOdbAEC6XQBAHGAAQLJzAEBpdABAmn8AQEaAAEA0kgBA9pYAQEiXAEAYmABAi08AQK55AEC0kQBAuJYAQOFgAECGTgBA2lAAQO5bAEA/XABAmWUAQAJqAEDOcQBAQnYAQPyEAEB8kABAjZ8AQIhmAEAulgBAiVIAQHtnAEDzZwBAQW0AQJxuAEAJdABAWXUAQGt4AEAQfQBAXpgAQG1RAEAuYgBAeJYAQCtQAEAZXQBA6m0AQCqPAECLXwBARGEAQBdoAECHcwBAhpYAQClSAEAPVABAZVwAQBNmAEBOZwBAqGgAQOVsAEAGdABA4nUAQHl/AEDPiABA4YgAQMyRAEDilgBAP1MAQLpuAEAdVABA0HEAQJh0AED6hQBAo5YAQFecAECfngBAl2cAQMttAEDogQBAy3oAQCB7AECSfABAwHIAQJlwAEBYiwBAwE4AQDaDAEA6UgBAB1IAQKZeAEDTYgBA1nwAQIVbAEAebQBAtGYAQDuPAEBMiABATZYAQIuJAEDTXgBAQFEAQMBVAEAAAAAAAAAAAFpYAEAAAAAAdGYAQAAAAAAAAAAA3lEAQCpzAEDKdgBAPHkAQF55AEBleQBAj3kAQFaXAEC+fABAvX8AQAAAAAAShgBAAAAAAPiKAEAAAAAAAAAAADiQAED9kABAAEGE+soAC/QK75gAQPyYAEAomQBAtJ0AQN6QAEC3lgBArk8AQOdQAEBNUQBAyVIAQORSAEBRUwBAnVUAQAZWAEBoVgBAQFgAQKhYAEBkXABAblwAQJRgAEBoYQBAjmEAQPJhAEBPZQBA4mUAQJFmAECFaABAd20AQBpuAEAibwBAbnEAQCtyAEAidABAkXgAQD55AEBJeQBASHkAQFB5AEBWeQBAXXkAQI15AECOeQBAQHoAQIF6AEDAewBA9H0AQAl+AEBBfgBAcn8AQAWAAEDtgQBAeYIAQHmCAEBXhABAEIkAQJaJAEABiwBAOYsAQNOMAEAIjQBAto8AQDiQAEDjlgBA/5cAQDuYAEB1YABAEADHQxiCAED9/wBA/f8AQCZOAEC1UQBAaFEAQIBPAEBFUQBAgFEAQMdSAED6UgBAnVUAQFVVAECZVQBA4lUAQFpYAECzWABARFkAQFRZAEBiWgBAKFsAQNJeAEDZXgBAaV8AQK1fAEDYYABATmEAQAhhAECOYQBAYGEAQPJhAEA0YgBAxGMAQBxkAEBSZABAVmUAQHRmAEAXZwBAG2cAQFZnAEB5awBAumsAQEFtAEDbbgBAy24AQCJvAEAecABAbnEAQKd3AEA1cgBAr3IAQCpzAEBxdABABnUAQDt1AEAddgBAH3YAQMp2AEDbdgBA9HYAQEp3AEBAdwBAzHgAQLF6AEDAewBAe3wAQFt9AED0fQBAPn8AQAWAAEBSgwBA74MAQHmHAEBBiQBAhokAQJaJAEC/igBA+IoAQMuKAEABiwBA/ooAQO2KAEA5iwBAiosAQAiNAEA4jwBAcpAAQJmRAEB2kgBAfJYAQOOWAEBWlwBA25cAQP+XAEALmABAO5gAQBKbAECcnwBAEADGQxAAxUMQAMRDnTsAQBhAAEA5QABAEADDQxAAwkMQAMFDQ58AQI6fAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAK5GAACyRgAAr0YBALFGAQCuRgAArEYAAKxG/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAACqRgAAqEYAAKZGAACkRgAAokb9/wBA/f8AQP3/AED9/wBA/f8AQNkF2kIa2ACA8oXbQuIFAEDQBQBA0wUAQNQFAEDbBQBA3AUAQN0FAEDoBQBA6gUAQCsAAEDpheBC6QXhQhEABEARAAFA0IXbQtAF3ELQBd5C0QXeQtIF3kLTBd5C1AXeQtUF3kLWBd5C/f8AQNgF3kLZBd5C2gXeQtsF3kLcBd5C/f8AQN4F3kL9/wBA4AXeQuEF3kL9/wBA4wXeQuQF3kL9/wBA5gXeQucF3kLoBd5C6QXeQuoF3kLVhdxC0YXfQtuF30Lkhd9CAACgRnEGAEBxBgBAewYAQHsGAEB7BgBAewYAQH4GAEB+BgBAfgYAQH4GAECABgBAgAYAQIAGAECABgBAegYAQHoGAEB/BgBAfwYAQH8GAEB/BgBAeQYAQHkGAEB5BgBAeQYAQKQGAECkBgBApAYAQKQGAECmBgBApgYAQIQGAECEBgBAhAYAQIQGAECDBgBAgwYAQIMGAECDBgBAhgYAQIYGAECGBgBAhgYAQIcGAECHBgBAjQYAQI0GAECMBgBAjAYAQI4GAECOBgBAiAYAQIgGAECYBgBAmAYAQJEGAECRBgBAqQYAQKkGAECvBgBArwYAQK8GAECvBgBAswYAQLMGAECzBgBAswYAQLEGAECxBgBAsQYAQLEGAEC6BgBAugYAQLsGAEC7BgBAuwYAQLsGAEDVBipD1QYqQ8EGAEDBBgBAwQYAQMEGAEC+BgBAvgYAQL4GAEC+BgBA0gYAQNIGAEDSBipD0gYqQwBBsIXLAAvsD/3/AED9/wBA/f8AQK0GAECtBgBArQYAQK0GAEDHBgBAxwYAQMYGAEDGBgBAyAYAQMgGAEAAAJ5GywYAQMsGAEDFBgBAxQYAQMkGAEDJBgBA0AYAQNAGAEDQBgBA0AYAQEkGAEBJBgBAAQCbRgEAm0YBAJhGAQCYRgEAlUYBAJVGAQCSRgEAkkYBAI9GAQCPRgEAjEYBAIxGAQCJRgEAiUYBAIlGAQBlRgEAZUYBAGVGzAYAQMwGAEDMBgBAzAYAQAEAI0YBACBGAQD8RQEAZUYBAGJGAAAbRgAAt0QAABpFAAD3RQAAXEYAAFpGAAAURQAArUUAAA5FAAAIRQAAUkYAAFBGAACHRgAA8UUAAEhGAABGRgAAw0QAALJEAADARAAAl0QAADxFAACFRgAAN0UAAI9FAACVRQAAq0QAAIZFAAD5RAAArkQAABdGAADzRAAAcUUAABVGAAATRgAAaEUAALZFAACxRAAAlEQAABFGAABcRQAAD0YAAA1GAABZRQAAukQAAERGAABCRgAAC0YAANhEAABARgAAPkYAADxGAAAJRgAAB0YAAAVGAADtRQAAtEQAADpGAAA4RgAAekQAANVEAABKRQAAiEQAAIREAACLRAAAvUQAAJZEAADMRAAAlUQAAABFAAC7RAAAqEQAANtEAAADRgAAHUUAAC5GAAAsRgAAAUYAAC9FAACDRgAA+0UAAMJEAAC/RAAA/0UAALxEAAAmRgAA40QwBjhDMQY4Q0kGOEMRAIBGEQB9RhEAekYRAHdGEQB0RhEAcUYBAG5GAQBrRgEA/EUBAGhGAQBlRgEAYkYAAJxEAABgRgAA90UAAF5GAABcRgAAWkYAAFhGAABWRgAACEUAAFRGAABSRgAAUEYAAE5GAABMRgAA8UUAAEpGAABIRgAARkYAAERGAABCRgAAQEYAAD5GAAA8RgAA7UUAALREAAA6RgAAOEYAAIhEAACERAAAi0QAADZGAACVRAAANEYAADJGAAAdRQAAMEYAAC5GAAAsRkkGOEMAACpGAAAoRgAAvEQAAMVEAAAmRgAA40QBACNGAQAgRgEAHUYBAPxFAQD5RQAAG0YAALdEAAAaRQAA90UAAPVFAAAURQAArUUAAA5FAAAIRQAA80UAAPFFAADDRAAAskQAAMBEAACXRAAAPEUAADdFAACPRQAAlUUAAKtEAACGRQAA+UQAABlGAACuRAAAF0YAAPNEAABxRQAAFUYAABNGAAC2RQAAsUQAAJREAAARRgAAXEUAAA9GAAANRgAAWUUAALpEAAALRgAA2EQAAAlGAAAHRgAABUYAAO1FAAC0RAAAekQAANVEAABKRQAAiEQAAIFEAAC9RAAAlkQAAMxEAACVRAAAqEQAANtEAAADRgAAHUUAAOtFAAABRgAAL0VHBjhDAADCRAAAv0QAAP9FAAC8RAAAjEQBAPxFAQD5RQAA90UAAPVFAAAIRQAA80UAAPFFAADvRQAAhkUAALxFAAB3RQAAukUAAO1FAAC0RAAAiEQAAB1FAADrRQAAvEQAAIxEEQDoRREA5UURAOJFAADgRQAA3kUAANxFAADaRQAA2EUAANZFAADURQAA0kUAANBFAADORQAAA0UAALhEAAAVRQAAqUQAAP1EAACsRAAAzEUAAMpFAADIRQAAxkUAAH1FAAD2RAAAuEUAAHdFAADERQAAwkUAAMBFAAC+RQAA4EUAAN5FAADcRQAA2kUAANhFAADWRQAA1EUAANJFAADQRQAAzkUAAANFAAC4RAAAFUUAAKlEAAD9RAAArEQAAMxFAADKRQAAyEUAAMZFAAB9RQAA9kQAALhFAAB3RQAAxEUAAMJFAADARQAAvkUAAH1FAAD2RAAAuEUAAHdFAAC8RQAAukUAAGhFAACPRQAAlUUAAKtEAAB9RQAA9kQAALhFAABoRQAAtkUnhiVDJ4YlQwAAAAAAAAAAAQCzRQEAsEUBALBFAQCtRQEAqkUBAKdFAQCkRQEAoUUBAJ5FAQCeRQEAm0UBAJhFAQCVRQEAkkUBAI9FAQCMRQEAiUUBAIZFAQCGRQEAg0UBAINFAQCuRAEAgEUBAIBFAQB9RQEAekUBAHpFAQB3RQEAd0UBAHRFAQBxRQEAbkUBAG5FAQBrRQEAaEUBALFEAQCURAEAlEQBAGVFAQBiRQEAX0UBAFxFAQBZRQEAWUUBANhEAQBWRQEA1UQBAFNFAQBQRQEATUUBAE1FAQBKRQEASkUBAEdFAQBHRQEAREUBAJZEAQBBRQEAPkUBADNFAQA7RQEAOEX9/wBA/f8AQAEANUUBADJFAQAvRQEALEUBAClFAQAmRQEAJkUBACNFAQAgRQEAHUUBAOBEAQDgRAEAGkUBABdFAQAURQEAEUUBAA5FAQALRQEACEUBAAVFAQACRQEA/0QBAPxEAQD5RAEA9kQBAPNEAQDwRAEA7UQBAOpEAQDnRAEA5EQBAOFEAQDeRAEA20QBANhEAQDVRAEA0kQBAM9EAQDGRAEAzEQBAMlEAQC0RAEAyUQBAMZEAQDDRAEAwEQBAL1EAQC6RAEAt0QBALREAQCxRAEArkQBAKtEAQCoRP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAAAQClRAEAokQCAJ5EAgCaRAIAlkQCAJJEAgCORAIAikQCAIZEAQCDRAEAAEAGAHtEAgB3RABBqJXLAAucD/////////////////////////////////////////////////////////////////////////////////////8sAABAATAAQP3/AEA6AABAOwAAQCEAAEA/AABAFjAAQBcwAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgP3/AEAUIABAEyAAQF8AAEBfAABAKAAAQCkAAEB7AABAfQAAQBQwAEAVMABAEDAAQBEwAEAKMABACzAAQAgwAEAJMABADDAAQA0wAEAOMABADzAAQAAAAAAAAAAAWwAAQF0AAEAggIJBIICCQSCAgkEggIJBXwAAQF8AAEBfAABALAAAQAEwAED9/wBA/f8AQDsAAEA6AABAPwAAQCEAAEAUIABAKAAAQCkAAEB7AABAfQAAQBQwAEAVMABAIwAAQCYAAEAqAABAKwAAQC0AAEA8AABAPgAAQD0AAED9/wBAXAAAQCQAAEAlAABAQAAAQP3/AED9/wBA/f8AQP3/AEAggCVDQIYlQyAAJkMAAAAAIIAmQ/3/AEAgACdDQAYnQyCAJ0NAhidDIAAoQ0AGKEMggChDQIYoQyAAKUNABilDIQYAQCeGKUMnhilDJwYqQycGKkNIBipDSAYqQyeGKkMnhipDSgYqQ0oGKkNKBipDSgYqQycGAEAnBgBAKAYAQCgGAEAoBgBAKQYAQCkGAEAqBgBAKgYAQCoGAEAqBgBAKwYAQCsGAEArBgBAKwYAQCwGAEAsBgBALAYAQC0GAEAtBgBALQYAQC0GAEAuBgBALgYAQC4GAEAuBgBALwYAQC8GAEAwBgBAMAYAQDEGAEAxBgBAMgYAQDMGAEAzBgBAMwYAQDMGAEA0BgBANAYAQDQGAEA0BgBANQYAQDUGAEA1BgBANQYAQDYGAEA2BgBANgYAQDcGAEA3BgBANwYAQDcGAEA4BgBAOAYAQDgGAEA4BgBAOQYAQDkGAEA5BgBAOQYAQDoGAEA6BgBAOgYAQEEGAEBBBgBAQQYAQEEGAEBCBgBAQgYAQEIGAEBCBgBAQwYAQEMGAEBDBgBAQwYAQEQGAEBEBgBARAYAQEUGAEBFBgBARQYAQEUGAEBGBgBARgYAQEYGAEBGBgBARwYAQEcGAEBHBgBARwYAQEgGAEBIBgBASQYAQEoGAEBKBgBASgYAQEoGAEABAG9EAQBvRAEAbEQBAGxEAQBpRAEAaUQAAGdEAABnRP3/AED9/wBA//////3/AEAhAABAIgAAQCMAAEAkAABAJQAAQCYAAEAnAABAKAAAQCkAAEAqAABAKwAAQCwAAEAtAABALgAAQC8AAEAwAABAMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAOgAAQDsAAEA8AABAPQAAQD4AAEA/AABAQAAAQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAbwAAQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAWwAAQFwAAEBdAABAXgAAQF8AAEBgAABAYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQGgAAEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEB7AABAfAAAQH0AAEB+AABAhSkAQIYpAEAuAABADDAAQA0wAEABMABA+zAAQPIwAEChMABAozAAQKUwAECnMABAqTAAQOMwAEDlMABA5zAAQMMwAED8MABAojAAQKQwAECmMABAqDAAQKowAECrMABArTAAQK8wAECxMABAszAAQLUwAEC3MABAuTAAQLswAEC9MABA3zAAQOAwAEDhMABA4jAAQOQwAEDmMABA6DAAQOkwAEDqMABA6zAAQOwwAEDtMABA7zAAQPMwAEAA2QDAANkAwP////8AEQBAAREAQKoRAMACEQBArBEAwK0RAMADEQBABBEAQAURAECwEQDAsREAwLIRAMCzEQDAtBEAwLURAMAaEQBABhEAQAcRAEAIEQBAIREAQAkRAEAKEQBACxEAQAwRAEANEQBADhEAQA8RAEAQEQBAEREAQBIRAED9/wBA/f8AQGERAMBiEQDAYxEAwGQRAMBlEQDAZhEAwP3/AED9/wBAZxEAwGgRAMBpEQDAahEAwGsRAMBsEQDA/f8AQP3/AEBtEQDAbhEAwG8RAMBwEQDAcREAwHIRAMD9/wBA/f8AQHMRAMB0EQDAdREAwP3/AED9/wBA/f8AQKIAAECjAABArAAAQCAAgkGmAABApQAAQKkgAED9/wBAAiUAQJAhAECRIQBAkiEAQJMhAECgJQBAyyUAQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAADA/f8AQP3/AEAAQfCkywALEP3/AEAAAAAAAAAAAP3/AEAAQYylywALEP3/AED9/wBA/f8AQP3/AEAAQdClywALDNzYAID9/wBA/f8AQABB9KXLAAso5tgAgObYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQABBrKbLAAsQ/f8AQP3/AED9/wBA/f8AQABB3KbLAAugARAAbk4QAG1OEABsThAAa04QAGpOEABpThAAaE4QAGdOEABmThAAZU4QAGROEABjThAAYk4QAGFOEABgThAAX04QAF5OEABdThAAXE4QAFtOEABaThAAWU4QAFhOEABXThAAVk4QAFVOEABUThAAU04QAFJOEABRThAAUE4QAE9OEABOThAATU4QAExOEABLThAASk4QAElOEABIThAAR04AQZyoywALoAEQAEZOEABFThAARE4QAENOEABCThAAQU4QAEBOEAA/ThAAPk4QAD1OEAA8ThAAO04QADpOEAA5ThAAOE4QADdOEAA2ThAANU4QADROEAAzThAAMk4QADFOEAAwThAAL04QAC5OEAAtThAALE4QACtOEAAqThAAKU4QAChOEAAnThAAJk4QACVOEAAkThAAI079/wBA/f8AQP3/AED9/wBAAEHcqcsAC5wBEAAiThAAIU4QACBOEAAfThAAHk4QAB1OEAAcThAAG04QABpOEAAZThAAGE79/wBAEAAXThAAFk4QABVOEAAUThAAE04QABJOEAARThAAEE4QAA9OEAAOThAADU4QAAxOEAALThAACk4QAAlO/f8AQBAACE4QAAdOEAAGThAABU4QAAROEAADThAAAk79/wBAEAABThAAAE79/wBAAEGcq8sACwT9/wBAAEG8q8sACxj9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AEAAQfirywALBBEAvwMAQZSsywALBBEAvQMAQcSsywAL/AHQAgBA0QIAQOYAAECZAgBAUwIAQP3/AECjAgBAZqsAQKUCAECkAgBAVgIAQFcCAECRHQBAWAIAQF4CAECpAgBAZAIAQGICAEBgAgBAmwIAQCcBAECcAgBAZwIAQIQCAECqAgBAqwIAQGwCAEAQAFRNjqcAQG4CAEAQAFNNjgIAQBAAUk34AABAdgIAQHcCAEBxAABAegIAQBAAUU19AgBAfgIAQIACAECoAgBApgIAQGerAECnAgBAiAIAQHEsAED9/wBAjwIAQKECAECiAgBAmAIAQMABAEDBAQBAwgEAQBAAUE0QAE9N/f8AQP3/AED9/wBA/f8AQP3/AEAAQdiuywALEP3/AED9/wBAAAAAAP3/AEAAQYCvywALJP3/AEAAAAAAAAAAAP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQABBsK/LAAsg/f8AQAAAAAAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AEAAQeSvywALMP3/AEAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBAAAAAANzYAIAAAAAA5tgAgABBrLDLAAso/f8AQP3/AEDm2ACAAdgAgNzYAID9/wBA/f8AQP3/AED9/wBACdgAgABB6LDLAAsY5tgAgNzYAID9/wBA/f8AQP3/AED9/wBAAEGUscsACxz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHAscsAC4wC/f8AQP3/AED9/wBAEAD/TRAA/k0QAP1NEAD8TRAA+00QAPpNEAD5TRAA+E0QAPdNEAD2TRAA9U0QAPRNEADzTRAA8k0QAPFNEADwTRAA700QAO5NEADtTRAA7E0QAOtNEADqTRAA6U0QAOhNEADnTRAA5k0QAOVNEADkTRAA400QAOJNEADhTRAA4E0QAN9NEADeTRAA3U0QANxNEADbTRAA2k0QANlNEADYTRAA100QANZNEADVTRAA1E0QANNNEADSTRAA0U0QANBNEADPTRAAzk0QAM1N/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB3LPLAAuoAebYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBAAzE0QAMtNEADKTRAAyU0QAMhNEADHTRAAxk0QAMVNEADETRAAw00QAMJNEADBTRAAwE0QAL9NEAC+TRAAvU0QALxNEAC7TRAAuk0QALlNEAC4TRAAt039/wBA/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgABBrLXLAAtQ/f8AQObYAIDm2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAADc2ACA3NgAgNzYAIAAQZS2ywALKNzYAIDc2ACA5tgAgObYAIDm2ACA3NgAgObYAIDc2ACA3NgAgNzYAIAAQeC2ywALMP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA5tgAgNzYAIDm2ACA3NgAgABBoLfLAAsY/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHQt8sACwQJ2ACAAEHwt8sACwz9/wBA/f8AQAnYAIAAQZC4ywALKP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAnYAIAAQeC4ywALDBEAuwMAAAAAEQC5AwBBmLnLAAsEEQC3AwBBwLnLAAsUCdgAgAfYAIAAAAAAAAAAAP3/AEAAQfO5ywALAYAAQYy6ywALCAEAtQMBALMDAEGgussACwwJ2ACACdgAgP3/AEAAQdS6ywALBAfYAIAAQeS6ywALKP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAnYAIAAQbC7ywALBAfYAIAAQci7ywALCAnYAIAH2ACAAEH0u8sACwz9/wBAAAAAAP3/AEAAQZC8ywALBP3/AEAAQbi8ywALMAfYAIAJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAA/f8AQAAAAAAAAAAA/f8AQABB/LzLAAsU/f8AQAfYAIAH2ACAAAAAAAAAAIAAQaS9ywALYP3/AED9/wBAAAAAAAAAAAD9/wBA/f8AQAEAsQMBAK8DCdgAgP3/AED9/wBAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAID9/wBA/f8AQP3/AED9/wBA/f8AQABBlL7LAAtQ/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfC+ywALDAEArQMAAAAAAQCrAwBBjL/LAAsg/f8AQAAAAAD9/wBA/f8AQAEAqQP9/wBAAAAAAAEApwMAQeS/ywALDP3/AEAAAAAAAAAAgABB+7/LAAsBgABBjMDLAAs8/f8AQAAAAID9/wBA/f8AQAEApYP9/wBAAQCjgwEAoYMAAACAAAAAAP3/AEAAAAAAAAAAAAnYAIAJ2ACAAEHcwMsAC0z9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAAAAAAAAJ2ACAAEG0wcsACwQH2ACAAEHfwcsACwGAAEGHwssACyGAAQCfAwEAnQMAAACAAQCbAwAAAAAAAAAACdgAgAfYAIAAQbjCywALIP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEGXw8sACwGAAEGww8sACxj9/wBA/f8AQAAAAAAAAAAAAQCZAwEAlwMAQdTDywALCAnYAIAH2ACAAEGYxMsACygJ2ACAB9gAgAAAAAAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHsxMsACxQJ2ACA/f8AQP3/AED9/wBA/f8AQABBpMXLAAucAQnYAIAH2ACAAAAAAP3/AED9/wBA/f8AQP3/AEAQALZNEAC1TRAAtE0QALNNEACyTRAAsU0QALBNEACvTRAArk0QAK1NEACsTRAAq00QAKpNEACpTRAAqE0QAKdNEACmTRAApU0QAKRNEACjTRAAok0QAKFNEACgTRAAn00QAJ5NEACdTRAAnE0QAJtNEACaTRAAmU0QAJhNEACXTQBB3MbLAAsU/f8AQP3/AEAAAAAA/f8AQP3/AEAAQYDHywALEP3/AEAAAAAAAAAAAP3/AEAAQbPHywALAYAAQcjHywALJP3/AEAAAAAAAQCVA/3/AED9/wBAAAAAAAAAAAAJ2ACACdgAgABB/MfLAAss/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQbjIywALBAnYAIAAQejIywALJAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABBqMnLAAsE/f8AQABByMnLAAsECdgAgABB6MnLAAtg/f8AQP3/AED9/wBAAAAAAP3/AEAAAAAAAAAAAP3/AEAAAAAAAAAAAAfYAIAAAAAACdgAgAnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHgyssACxD9/wBAAAAAAAAAAAD9/wBAAEGIy8sACwT9/wBAAEGcy8sACyQJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfvLywALKYAAAACAAQCMgwEAj4MBAJODAQCQgwEAjYMCAJKDAgCPgwIAjIMAAACAAEG4zMsAC2AJ2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQb/NywALDYABAIqDAQCJAwIAiQMAQeDNywALwAEQAJZNEACVTRAAlE0QAJNNEACSTRAAkU0QAJBNEACPTRAAjk0QAI1NEACMTRAAi00QAIpNEACJTRAAiE0QAIdNEACGTRAAhU0QAIRNEACDTRAAgk0QAIFNEACATRAAf00QAH5NEAB9TRAAfE0QAHtNEAB6TRAAeU0QAHhNEAB3TQbYAIAG2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQazPywALNP3/AED9/wBAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfDPywALIP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEG40MsAC5gB/f8AQP3/AEAAAAAAAAAAAAHYAIAAAAAA//////////////////////3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQDAAAEAxAABAMgAAQDMAAEA0AABANQAAQDYAAEA3AABAOAAAQDkAAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQYjSywALMBEAh0MRAHhDEgCEQxIAgUMSAH5DEgB7QxIAeEPY2ACA2NgAgAHYAIAB2ACAAdgAgABBxNLLAAto4tgAgNjYAIDY2ACA2NgAgP//////////////////////////////////////////3NgAgNzYAIDc2ACA3NgAgNzYAIAAAAAAAAAAAObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgNzYAIAAQdTTywALEObYAIDm2ACA5tgAgObYAIAAQZDUywALGBEAb0MRAGxDEgB1QxIAckMSAG9DEgBsQwBB5NTLAAvcCebYAIDm2ACA5tgAgAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAcQAAQHIAAEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAbwAAQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQP3/AEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEBhAABA/f8AQGMAAEBkAABA/f8AQP3/AEBnAABA/f8AQP3/AEBqAABAawAAQP3/AED9/wBAbgAAQG8AAEBwAABAcQAAQP3/AEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQGEAAEBiAABAYwAAQGQAAED9/wBAZgAAQP3/AEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABA/f8AQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAYQAAQGIAAED9/wBAZAAAQGUAAEBmAABAZwAAQP3/AED9/wBAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAED9/wBAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQP3/AEBhAABAYgAAQGkAAEBqAABAawAAQGwAAEBtAABA/f8AQG8AAED9/wBA/f8AQP3/AEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABA/f8AQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAdwAAQHgAAEB5AABAegAAQDEBAEA3AgBA/f8AQP3/AECxAwBAsgMAQLMDAEC0AwBAtQMAQLYDAEC3AwBAuAMAQLkDAEC6AwBAuwMAQLwDAEC9AwBAvgMAQL8DAEDAAwBAwQMAQLgDAEDDAwBAxAMAQMUDAEDGAwBAxwMAQMgDAEDJAwBAByIAQLEDAECyAwBAswMAQLQDAEC1AwBAtgMAQLcDAEC4AwBAuQMAQLoDAEC7AwBAvAMAQL0DAEC+AwBAvwMAQMADAEDBAwBAwwMAQMMDAEDEAwBAxQMAQMYDAEDHAwBAyAMAQMkDAEACIgBAtQMAQLgDAEC6AwBAxgMAQMEDAEDAAwBAsQMAQLIDAECzAwBAtAMAQLUDAEC2AwBAtwMAQLgDAEC5AwBAugMAQLsDAEC8AwBAvQMAQL4DAEDHAwBAyAMAQMkDAEACIgBAtQMAQLgDAEC6AwBAxgMAQMEDAEDAAwBA3QMAQN0DAED9/wBA/f8AQDAAAEAxAABAMgAAQDMAAEA0AABANQAAQDYAAEA3AABAOAAAQDkAAEAwAABAMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAMAAAQDEAAEAyAABAMwAAQP3/AED9/wBA/f8AQP3/AED9/wBAAEHY3ssAC/wD/f8AQP3/AED9/wBA/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA/f8AQObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA5tgAgObYAID9/wBA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQDAEAEAxBABAMgQAQDMEAEA0BABANQQAQDYEAEA3BABAOAQAQDoEAEA7BABAPAQAQD4EAEA/BABAQAQAQEEEAEBCBABAQwQAQEQEAEBFBABARgQAQEcEAEBIBABASwQAQE0EAEBOBABAiaYAQNkEAEBWBABAWAQAQOkEAECvBABAzwQAQDAEAEAxBABAMgQAQDMEAEA0BABANQQAQDYEAEA3BABAOAQAQDoEAEA7BABAPgQAQD8EAEBBBABAQwQAQEQEAEBFBABARgQAQEcEAEBIBABASgQAQEsEAECRBABAVgQAQFUEAEBfBABAqwQAQFGmAECxBABA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgABB8OLLAAsI/f8AQP3/AEAAQajjywALEOjYAIDo2ACA3NgAgObYAIAAQdTjywALBP3/AEAAQejjywAL2AH9/wBAAAAAAAAAAAD9/wBA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBAAdk0QAHVNEAB0TRAAc00QAHJNEABxTRAAcE0QAG9NEABuTRAAbU0QAGxNEABrTRAAak0QAGlNEABoTRAAZ00QAGZNEABlTRAAZE0QAGNNEABiTRAAYU0QAGBNEABfTRAAXk0QAF1NEABcTRAAW00QAFpNEABZTRAAWE0QAFdNEABWTRAAVU0AQfjlywALkAbm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAH2ACAAAAAAP3/AED9/wBA/f8AQP3/AEAnBgBAKAYAQCwGAEAvBgBA/f8AQEgGAEAyBgBALQYAQDcGAEBKBgBAQwYAQEQGAEBFBgBARgYAQDMGAEA5BgBAQQYAQDUGAEBCBgBAMQYAQDQGAEAqBgBAKwYAQC4GAEAwBgBANgYAQDgGAEA6BgBAbgYAQLoGAEChBgBAbwYAQP3/AEAoBgBALAYAQP3/AEBHBgBA/f8AQP3/AEAtBgBA/f8AQEoGAEBDBgBARAYAQEUGAEBGBgBAMwYAQDkGAEBBBgBANQYAQEIGAED9/wBANAYAQCoGAEArBgBALgYAQP3/AEA2BgBA/f8AQDoGAED9/wBA/f8AQP3/AED9/wBALAYAQP3/AED9/wBA/f8AQP3/AEAtBgBA/f8AQEoGAED9/wBARAYAQP3/AEBGBgBAMwYAQDkGAED9/wBANQYAQEIGAED9/wBANAYAQP3/AED9/wBALgYAQP3/AEA2BgBA/f8AQDoGAED9/wBAugYAQP3/AEBvBgBA/f8AQCgGAEAsBgBA/f8AQEcGAED9/wBA/f8AQC0GAEA3BgBASgYAQEMGAED9/wBARQYAQEYGAEAzBgBAOQYAQEEGAEA1BgBAQgYAQP3/AEA0BgBAKgYAQCsGAEAuBgBA/f8AQDYGAEA4BgBAOgYAQG4GAED9/wBAoQYAQP3/AEAnBgBAKAYAQCwGAEAvBgBARwYAQEgGAEAyBgBALQYAQDcGAEBKBgBA/f8AQEQGAEBFBgBARgYAQDMGAEA5BgBAQQYAQDUGAEBCBgBAMQYAQDQGAEAqBgBAKwYAQC4GAEAwBgBANgYAQDgGAEA6BgBA/f8AQP3/AED9/wBA/f8AQCgGAEAsBgBALwYAQP3/AEBIBgBAMgYAQC0GAEA3BgBASgYAQP3/AEBEBgBARQYAQEYGAEAzBgBAOQYAQP3/AEAAAGNEAABhRAAAX0QAAF1EAABbRAAAWUQAAFdEAABVRAAAU0QAAFFEAEGc7MsAC4ABAQDNSgEAykoBAMdKAQDESgEAwUoBAL5KAQC7SgEAuEoBALVKAQCySgEAVExjAABAcgAAQAAANkcAAFJMAAAAAHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEAAAFBMAABOTAAATEwAAEpMAQBHTAAARUwAQcbtywALCkNMAABBTAAAP0wAQd7tywALAj1MAEGe7ssAC+tN5UMAAONDtTAAQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEBLYgBAV1sAQMxTAEDGsExYjE4AQBpZAEDjiQBAKVkAQKROAEAgZgBAIXEAQJllAEBNUgBAjF8AQI1RAECwZQBAHVIAQEJ9AEAfdQBAqYwAQPBYAEA5VABAFG8AQJViAEBVYwBAAE4AQAlOAEBKkABA5l0AQC1OAEDzUwBAB2MAQHCNAEBTYgBAgXkAQHp6AEAIVABAgG4AQAlnAEAIZwBAM3UAQHJSAEC2VQBATZEAQP3/AED9/wBA/f8AQP3/AEABAOBDAQDdQwEA2kMBANdDAQDUQwEA0UMBAM5DAQDLQwEAyEP9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAl18AQO9TAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQD1OAEA4TgBAQU4AQBAAa0NgTwBArk8AQLtPAEACUABAelAAQJlQAEDnUABAz1AAQJ40AEAQAGpDTVEAQFRRAEBkUQBAd1EAQBAAaUO5NABAZ1EAQI1RAEAQAGhDl1EAQKRRAEDMTgBArFEAQLVRAEAQAGdD9VEAQANSAEDfNABAO1IAQEZSAEByUgBAd1IAQBU1AEDHUgBAyVIAQORSAED6UgBABVMAQAZTAEAXUwBASVMAQFFTAEBaUwBAc1MAQH1TAEB/UwBAf1MAQH9TAEAQAGZDcHAAQMpTAEDfUwBAEABlQ+tTAEDxUwBABlQAQJ5UAEA4VABASFQAQGhUAECiVABA9lQAQBBVAEBTVQBAY1UAQIRVAECEVQBAmVUAQKtVAECzVQBAwlUAQBZXAEAGVgBAF1cAQFFWAEB0VgBAB1IAQO5YAEDOVwBA9FcAQA1YAECLVwBAMlgAQDFYAECsWABAEABkQ/JYAED3WABABlkAQBpZAEAiWQBAYlkAQBAAY0MQAGJD7FkAQBtaAEAnWgBA2FkAQGZaAEDuNgBA/DYAQAhbAEA+WwBAPlsAQBAAYUPDWwBA2FsAQOdbAEDzWwBAEABgQ/9bAEAGXABAU18AQCJcAECBNwBAYFwAQG5cAEDAXABAjVwAQBAAX0NDXQBAEABeQ25dAEBrXQBAfF0AQOFdAEDiXQBALzgAQP1dAEAoXgBAPV4AQGleAEBiOABAEABdQ3w4AECwXgBAs14AQLZeAEDKXgBAEABcQ/5eAEAQAFtDEABbQwGCAEAiXwBAIl8AQMc4AEAQAFpDEABZQ2JfAEBrXwBA4zgAQJpfAEDNXwBA118AQPlfAECBYABAOjkAQBw5AECUYABAEABYQ8dgAEBIYQBATGEAQE5hAEBMYQBAemEAQI5hAECyYQBApGEAQK9hAEDeYQBA8mEAQPZhAEAQYgBAG2IAQF1iAECxYgBA1GIAQFBjAEAQAFdDPWMAQPxiAEBoYwBAg2MAQORjAEAQAFZDImQAQMVjAECpYwBALjoAQGlkAEB+ZABAnWQAQHdkAEBsOgBAT2UAQGxlAEAQAFVD42UAQPhmAEBJZgBAGTsAQJFmAEAIOwBA5DoAQJJRAECVUQBAAGcAQJxmAECtgABA2UMAQBdnAEAbZwBAIWcAQF5nAEBTZwBAEABUQ0k7AED6ZwBAhWcAQFJoAECFaABAEABTQ45oAEAfaABAFGkAQJ07AEBCaQBAo2kAQOppAECoagBAEABSQ9tqAEAYPABAIWsAQBAAUUNUawBATjwAQHJrAECfawBAumsAQLtrAEAQAFBDEABPQxAATkNObABAEABNQ79sAEDNbABAZ2wAQBZtAEA+bQBAd20AQEFtAEBpbQBAeG0AQIVtAEAQAExDNG0AQC9uAEBubgBAMz0AQMtuAEDHbgBAEABLQ/ltAEBubwBAEABKQxAASUPGbwBAOXAAQB5wAEAbcABAlj0AQEpwAEB9cABAd3AAQK1wAEAQAEhDRXEAQBAAR0OccQBAEABGQyhyAEA1cgBAUHIAQBAARUOAcgBAlXIAQBAAREMQAENDenMAQItzAECsPgBApXMAQLg+AEC4PgBAR3QAQFx0AEBxdABAhXQAQMp0AEAbPwBAJHUAQBAAQkM+dQBAEABBQ3B1AEAQAEBDEHYAQBAAP0MQAD5DEAA9Q/w/AEAIQABA9HYAQBAAPEMQADtDEAA6QxAAOUMedwBAH3cAQB93AEBKdwBAOUAAQIt3AEBGQABAlkAAQBAAOENOeABAjHgAQMx4AEDjQABAEAA3Q1Z5AEAQADZDEAA1Q495AEDreQBAL0EAQEB6AEBKegBAT3oAQBAANEMQADNDEAAzQ+56AEACQgBAEAAyQ8Z7AEDJewBAJ0IAQBAAMUPSfABAoEIAQOh8AEDjfABAAH0AQBAAMENjfQBAAUMAQMd9AEACfgBARX4AQDRDAEAQAC9DEAAuQ1lDAEAQAC1Den8AQBAALEOVfwBA+n8AQAWAAEAQACtDEAAqQ2CAAEAQAClDcIAAQBAAKEPVQwBAsoAAQAOBAEALRABAPoEAQLVaAEAQACdDEAAmQxAAJUMQACRDAYIAQASCAECejwBAa0QAQJGCAECLggBAnYIAQLNSAECxggBAs4IAQL2CAEDmggBAEAAjQ+WCAEAdgwBAY4MAQK2DAEAjgwBAvYMAQOeDAEBXhABAU4MAQMqDAEDMgwBA3IMAQBAAIkMQACFDEAAgQytFAEDxhABA84QAQBaFAEAQAB9DZIUAQBAAHkNdRQBAYUUAQBAAHUMQABxDa0UAQFCGAEBchgBAZ4YAQGmGAECphgBAiIYAQA6HAEDihgBAeYcAQCiHAEBrhwBAhocAQNdFAEDhhwBAAYgAQPlFAEBgiABAY4gAQBAAG0PXiABA3ogAQDVGAED6iABAuzQAQBAAGkMQABlDvkYAQMdGAECgigBA7YoAQIqLAEBVjABAEAAYQ6uMAEDBjABAG40AQHeNAEAQABdDEAAWQ8uNAEC8jQBA8I0AQBAAFUPUjgBAOI8AQBAAFEMQABNDlJAAQPGQAEARkQBAEAASQxuRAEA4kgBA15IAQNiSAEB8kgBA+ZMAQBWUAEAQABFDi5UAQJVJAEC3lQBAEAAQQ+ZJAEDDlgBAsl0AQCOXAEAQAA9DEAAOQ25KAEB2SgBA4JcAQBAADUOySgBAEAAMQwuYAEALmABAKZgAQBAAC0PimABAM0sAQCmZAECnmQBAwpkAQP6ZAEDOSwBAEAAKQxKbAEBAnABA/ZwAQM5MAEDtTABAZ50AQBAACUP4TABAEAAIQxAAB0MQAAZDu54AQFZNAED5ngBA/p4AQAWfAEAPnwBAFp8AQDufAEAQAAVD/f8AQP3/AEAAAAAAAAAAAOglEgDaDAAAAAAAAJw/EgBhMAAAAAAAAAACDgCBAAAA/f8AQOEADwQBAAAAQQAAAAAAOgBFA5gC1gyWATUbbQEF2GQABdgSAAbYMAAY2DQAG9gxAGfdG9gCAGPdAcBpbWfdAcBobWndAcBqbQMAsNwOALrcEQC93BQAr90wAAXYAQC43QHAuhW53QHAuxUxAAXYudwBwLwUMQAF2LncAcC7FDEABdi53AHAvhQyADDdBtg13QHAOBkDAB7dCgAf3Q0AIN0aACndMQAY2B7dAcAiYTEAGNge3QHAIWEwABjYAwAe3QHAI2Eh3QHAJmEi3QHAJ2Ep3QHAJGEwABjYAQAe3QHAJWEh3QHAKGE1G1QAmTBtAJow6gAE2AcAuN8mALjfEQC73xQAwt8XAMnfMAAE2AIAgt8BwIMTkN8BwJETwt8BwMgTMQAE2MLfAcDHEzEABNiE3wHAhRMwAATYAQCL3wHAjhPC3wHAxRO63AoAJ90UAD7fGwBX3zEABNhH3wHATBMwAATYAgCZ3AHAmhCb3AHAnBCl3AHAqxAwAATYAQAx3QHALhEy3QHALxExAATYR98BwEsTCgARGw4APhsGAD4bQJs/G0GbQhtDmxEbEps6GzubPBs9mwUbBpsHGwibCRsKmwsbDJsNGw6bLwCtMD4AxjAeANswDgDxMAYA8TD5sPIw+rD9MP6w2zDcsO8w97DwMPiw0jAGANIw07DVMNaw2DDZsMYwx7DIMMmwzzDQsLkwDgC/MAYAvzDAsMEwwrDEMMWwuTC6sLswvLC9ML6wszAGALMwtLC1MLawtzC4sK0wrrCvMLCwsTCysGEwHgB1MA4AnTAGAJ0wnrCmMPSwqzCssHUwdrB4MHmwezB8sGgwBgBoMGmwbzBwsHIwc7BhMGKwZDBlsGYwZ7BVMA4AWzAGAFswXLBdMF6wXzBgsFUwVrBXMFiwWTBasE8wBgBPMFCwUTBSsFMwVLBGMJSwSzBMsE0wTrAJAM8wCgDPMNGw0jDUsNUw17DYMNqw2zDdsG8wcbByMHSwdTB3sHgwerB7MH2wyg0VAMoNCADPDQsA3w0MAC4QMAAlECaQAQDZDdqN3A3djTAA2Q3cjTAA2Q3ejdYMBgA+DQcAVw0wAEYNTI0wAMYMyIwBAEYNSo1HDUuNPgswANcLGQDXCwwAVgwPAMIMEADVDAIAvwzAjMYMx4zKDMuMAQCSC5SLxgvMizAARgxIjDAAxgzKjD4LCgBWCwsAVwsMAL4LAQDGC8qLxwvLizAARwtLizAARwtIizAARwtMi1UGFwBVBggAPAkJAL4JDgDXCTAAxwnMiTAAJwYlhgIAKAkpiTAJMYkzCTSJMADHCcuJRQMSAFMGrgBUBgUAwQYGAMEGwobSBtOG1QbAhicGI4ZIBiSGSgYmhgAAPgAmH04AZh8mAG4fEgB8HwgAfB/yn7Yft5/GH8ef9h/3n24frp9vH6+fcB+yn3Qfwp9qHwgAah+qn2sfq59sH6yfbR+tn2Yfpp9nH6efaB+on2kfqZ8uHxIAYh8IAGIfop9jH6OfZB+kn2UfpZ8uH56fLx+fn2AfoJ9hH6GfKh8IACofmp8rH5ufLB+cny0fnZ8mH5afJx+XnygfmJ8pH5mfBh8mAA4fEgAiHwgAIh+SnyMfk58kH5SfJR+Vnw4fjp8PH4+fIB+QnyEfkZ8KHwgACh+Knwsfi58MH4yfDR+NnwYfhp8HH4efCB+InwkfiZ/JAxIAAh8IAAIfgp8DH4OfBB+EnwUfhZ/JA/OfzgP0nwAfgJ8BH4GfrAMIAKwDtJ+uA8SfsQOzn7cDw5+RA7yflwPMn6kD/J8wACcGIoYTA08CJwNyATAD9wAwA04AMQNbADgDggBCAxwAKB8kAFEfEgBoHwgAaB9un2kfb5+/H8+f/h/fn1EfV59ZH1+fYB9mn2EfZ58xHwgAMR83nzgfPp85Hz+fUB9WnygfLp8pHy+fMB82n8sDEAAIHwgACB8OnwkfD58gHyafIR8nn8sD558AHwafAR8Hn7kDCAC5A9afxQPmn8kD9p/KA9efqADBn7EDtp+3A8afBQBlAAYAZQAbnmkALZ51AHWeRQAankkALJ5VAHSeEABiABQAbAAKAGwAO55uAEmecgBfnnQAb556AJWeYgAHnmQAD55oAJaeawA1nk4ACABOAEieUgBenlQAbp5aAJSeQgAGnkQADp5LADSeTAA6nisAciI2AIciGgCpIg4AsyIGALMi66K0IuyitSLtoqkirqKrIq+isiLqoociiaKRIuKikiLjoqIirKKoIq2ieyIOAIIiBgCCIoSigyKFooYiiKJ7IoGifCLgon0i4aJyInSicyJ1onYieKJ3InmieiKAogsiGgBFIg4AYSIGAGEiYqJkInCiZSJxokUiR6JIIkmiTSJtogsiDKIjIiSiJSImojwiQaJDIkSilCEOANQhBgDUIc6hAyIEoggiCaKUIa6h0CHNodIhz6E8AG6iPQBgoj4Ab6KQIZqhkiGboScDCgAoAz8ALQNUAC4DAQBIACqeaAArnhUAYwAaAGsADgByAAYAcgBXgXMAX4F0AGOBawA3gWwAPIFuAEaBYwDngGQAEZ5lACmCZwAjgWgAKZ5LAA4AUgAGAFIAVoFTAF6BVABigUsANoFMADuBTgBFgUMAx4BEABCeRQAogkcAIoFIACieCQBhAAoAYQAFgWUAGYFpAC+BbwDrgXUAc4FBAASBRQAYgUkALoFPAOqBVQBygQsAZAAOAG4ABgBuAEuedABxnnUAd55kABOeZQAZnmwAPZ5OAAYATgBKnlQAcJ5VAHaeRAASnkUAGJ5MADyeIwOBACMDDgAkA3MAJQN2ACYDAwBTABiCVAAagnMAGYJ0ABuCKQBkADIAcwAaAHkADgChAQYAoQHjnq8B8J6wAfGeeQD1nnoAk56gAeKecwBjnnQAbZ51AOWedgB/nncAiZ5sAAoAbAA3nm0AQ55uAEeebwDNnnIAW55kAA2eZQC5nmgAJZ5pAMueawAznk8AGgBWAA4AWgAGAFoAkp5hAKGeYgAFnlYAfp5XAIieWQD0nk8AzJ5SAFqeUwBinlQAbJ5VAOSeSQAKAEkAyp5LADKeTAA2nk0AQp5OAEaeQQCgnkIABJ5EAAyeRQC4nkgAJJ4BAFUAcp51AHOeAQBBAACeYQABnhMDDAAUAy0AGwMDAE8AoIFVAK+BbwChgXUAsIENALUDEAC/AwgAvwNAn8ED5J/FA1CfyQNgn7UDEJ+3AyCfuQMwn5kDCACZAzifnwNIn6kDaJ+xAwCfkQMIn5UDGJ+XAyifDwCxAxIAvwMIAL8DQZ/BA+WfxQNRn8kDYZ+xAwGftQMRn7cDIZ+5AzGfnwMIAJ8DSZ+hA+yfpQNZn6kDaZ+RAwmflQMZn5cDKZ+ZAzmfCAOSAQsDsQALAyQADAMxAA8DiAARAwsAYQAOAG8ABgBvAA+CcgATgnUAF4JhAAOCZQAHgmkAC4JPAAYATwAOglIAEoJVABaCQQACgkUABoJJAAqCBQB1AAYAdQBxgSME8oRDBPOETwBQgVUAcIFvAFGBJABkACwAbwAWAHoACgB6AH6B3ADZgfwA2oG3Ae6BkgLvgW8A0oFyAFmBcwBhgXQAZYF1ANSBaQAKAGkA0IFqAPCBawDpgWwAPoFuAEiBZAAPgWUAG4FnAOeBaAAfgk4AFABUAAoAVABkgVUA04FaAH2BYQDOgWMADYFOAEeBTwDRgVIAWIFTAGCBRwAKAEcA5oFIAB6CSQDPgUsA6IFMAD2BQQDNgUMADIFEAA6BRQAagQ0AZQAQAHIACAByABGCdQAVgnQEdoR1BHeEZQAFgmkACYJvAA2CTwAIAE8ADIJSABCCVQAUgmEAAYJBAACCRQAEgkkACIIIAxIACQOcAAoDBQB1AAYAdQBvgXcAmJ55AJmeQQDFgFUAboFhAOWAAAA1ANIDRAA1BCIASwQQANgECADYBNqE2QTbhOgE6oTpBOuESwT5hE0E7YRWBFeEOAQIADgE5YQ+BOeEQwTxhEcE9YQ1BFGENgTdhDcE34QYBBAAJwQIACcE9IQrBPiELQTshDAE04QYBOSEHgTmhCME8IQVBAYAFQQBhBYE3IQXBN6E0gPUgwYEB4QQBNKEbwAiAPUAEACZAwgAmQOqg6UDq4O5A8qDxQPLg/UAT55qAXqeawF7nncACAB3AIWeeACNnnkA/4DVAE6ebwD2gHQAl551APyAVwAQAGEACABhAOSAZQDrgGgAJ55pAO+AVwCEnlgAjJ5ZAHiBSQAGAEkAz4BPANaAVQDcgEEAxIBFAMuASAAmnhcAwgAeAAIBDgChAQYAoQHfnq8B7J6wAe2eAgGyngMBs56gAd6e4gAGAOIAqZ7qAMOe9ADVnsIAqJ7KAMKe1ADUnmEADgBvAAYAbwDPnnUA5555APeeYQCjnmUAu55pAMmeTwAGAE8Azp5VAOaeWQD2nkEAop5FALqeSQDIngMDjQEDA4YABAPLAAYDOAEHAy4AZABEAHcAJABgARQAYh4MAGIeaJ5jHmmeAdgBANLdAcDJBdrdAcDkBWABZp5hAWeefwGbnnoABgB6AHyBWgFknlsBZZ53AIeeeACLnnkAj55uAA4AcgAGAHIAWZ5zAGGedABrnm4ARZ5vAC+CcABXnmcABgBnACGBaAAjnm0AQZ5kAAueZQAXgWYAH55PAB4AWAAOAGEABgBhACeCYgADnmMAC4FYAIqeWQCOnloAe4FTAAYAUwBgnlQAap5XAIaeTwAuglAAVp5SAFieRgAOAEkABgBJADCBTQBAnk4ARJ5GAB6eRwAggUgAIp5BACaCQgACnkMACoFEAAqeRQAWgRsAdgAiAPQAEACgAQgAoAHgnqEB4Z6vAe6esAHvnvQA154CAbSeAwG1nsoACADKAMSe1ADWnuIAq57qAMWedgB9nnkA+Z7CAKqeWQAQAGkACABpACmBbgDxgG8A9YB1AGmBWQD4nmEA44BlAL2eTgAIAE4A0YBPANWAVQBogVYAfJ5BAMOARQC8nkkAKIErAPYANgCxAxoAOAQOADceBgA3HjmeWh5cnlseXZ44BOOEQwTvhDYeOJ6xA7GfuQPRn8UD4Z8YBOKEIwTuhCcCDgCRAwYAkQO5n5kD2Z+lA+mfJwLhgS4CMIIvAjGC9gArgvwA1oHqAeyB6wHtgSYC4IFvABoA1QAOAOQABgDkAN+B5gDjgfUALYLVACyC1gAqgtwA1YFvAE2BdQBrgXkAM4LEAN6BxgDigVUADgBlAAYAZQATgWcAIZ5pACuBVQBqgVkAMoJhAAGBQQAAgUUAEoFHACCeSQAqgU8ATIEfAKUDJgAjBBIAOAQIADgEOYRDBF6EoB62nqEet54jBA6EMATRhDUE14Q2BMKEEAQIABAE0IQVBNaEFgTBhBgEGYSlA+ifsQOwn7kD0J/FA+CfZwASACgCCAAoAhyeKQIdnpEDuJ+ZA9ifZwAfgWkALYFvAE+BdQBtgU8ACABPAE6BVQBsgWEAA4FlABWBQQACgUUAFIFHAB6BSQAsgQADUgABAyABAgMfAGcAJgB5ABIAuB4IALgexp65HseezB7Yns0e2Z55AHeBegCRnqAerJ6hHq2ebwAIAG8A9IBzAF2BdQD7gHcAdYFnAB2BaAAlgWkA7oBqADWBUwASAFoACABaAJCeYQDigGMACYFlAOqAUwBcgVUA24BXAHSBWQB2gUgACABIACSBSQDOgEoANIFPANSAQQDCgEMACIFFAMqARwAcgQAAUwCxA2YAIB8yAEgfGgBgHw4AaR8GAGkfa5+/H82f/h/dn2AfYp9hH2OfaB9qn0gfSp9JH0ufUB9Sn1EfU59ZH1ufMR8KADEfM584HzqfOR87n0AfQp9BH0OfIB8inyEfI58oHyqfKR8rnzAfMp8YBBoACB8OABEfBgARHxOfGB8anxkfG58IHwqfCR8LnxAfEp8YBA2ENQRQhDgEXYQAHwKfAR8Dn8UDCgDFA3qfyQN8n8oD0p/LA+KfFQQAhLEDcJ+1A3KftwN0n7kDdp+/A3if4gAyAKABGgCVAw4AnwMGAJ8D+J+lA+qfqQP6n5UDyJ+XA8qfmQPan6AB3J6hAd2erwHqnrAB656RA7qfAwEKAAMBsZ4SARSeEwEVnkwBUJ5NAVGe4gCnnuoAwZ70ANOe/ADcgQIBsJ5pABoAeQAOAMoABgDKAMCe1ADSntwA24F5APOeqADtn8IApp5pAOyAbgD5gW8A8oB1APmAdwCBnlUACgBVANmAVwCAnlkA8p5hAOCAZQDogEEAwIBFAMiASQDMgE4A+IFPANKAAAB0ABMBlAA6BEoAOB8kAFEfEgBoHwgAaB9sn2kfbZ+/H86f/h/en1EfVZ9ZH12fYB9kn2EfZZ9BHwgAQR9Fn0gfTJ9JH02fUB9UnzgfPJ85Hz2fQB9EnxgfEgAoHwgAKB8snykfLZ8wHzSfMR81nxgfHJ8ZHx2fIB8knyEfJZ8IHwgACB8MnwkfDZ8QHxSfER8VnzoEXIQAHwSfAR8Fn6UDJADFAxIA0gMIANID04MTBAOEGgQMhDMEU4TFA82DyQPOg8oDkIPLA7CDtQMIALUDrYO3A66DuQOvg78DzIOlA46DqQOPg7EDrIOvARAAlQMIAJUDiIOXA4mDmQOKg58DjIOvAeiesAHpnpEDhoNoAQgAaAF4nmkBeZ6gAdqeoQHbnhMBF55MAVKeTQFTnnMASADYACQA7wASAPwACAD8ANiBAgGungMBr54SARae7wAvnvQA0Z71AE2e+AD/geUACADlAPuB5gD9gecACZ7qAL+e2AD+gdwA14HiAKWexQAQAMoACADKAL6ezwAuntQA0J7VAEyexQD6gcYA/IHHAAieeQAIAHkA/YB6AHqBqACFg8IApJ5zAFuBdQD6gHcAg55XACQAaQASAG4ACABuAESBbwDzgHAAVZ5yAFWBaQDtgGsAMZ5sADqBbQA/nmEACABhAOGAYwAHgWUA6YBnAPWBVwCCnlkA3YBaAHmBTQAQAFAACABQAFSeUgBUgVMAWoFVANqATQA+nk4AQ4FPANOARwAIAEcA9IFJAM2ASwAwnkwAOYFBAMGAQwAGgUUAyYBUARMAXgoAAAAAAABtaWQgPiBsZW4AAAAcFhMACQAAAEwaEAB/AAAASgAAAB8AAABMGhAAfwAAAEQAAAAXAAAA14UQAGIAAADGAAAAOwAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvZGVfcG9pbnQgPCBzZWxmLmhlYWRlci5oaWdoX3N0YXJ0ICYmIHNlbGYuaGVhZGVyLmhpZ2hfc3RhcnQgPiBTTUFMTF9MSU1JVAAAAMNvEAByAAAALAEAAA0AAADOdRAAagAAAF8DAAAJAAAAznUQAGoAAAC9AQAAHQAAAAAAAAAIAAAABAAAAHUBAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlQ2FwYWNpdHlPdmVyZmxvdwAAAAAABAAAAAQAAAB0AQAAQWxsb2NFcnJsYXlvdXQAAKiTEABbAAAAVgEAAC4AAABjYXBhY2l0eSBvdmVyZmxvdwAAAKiTEABbAAAARQEAADYAAACokxAAWwAAANIEAAAOAAAAYXNzZXJ0aW9uIGZhaWxlZDogc3RhcnQgPD0gZW5kAACokxAAWwAAABAEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IGxlbqiTEABbAAAAEQQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBpbmRleCA8IGxlbgAAAKiTEABbAAAATAUAAA0AAABhc3NlcnRpb24gZmFpbGVkOiBuZXdfY2FwID49IGxlbqiTEABbAAAAnQQAAA0AAAA6hhAAcAAAAC4CAAARAAAAznUQAGoAAAC9AQAAHQAAAG1pZCA+IGxlbgAAAHwYEwAJAAAAOoYQAHAAAAAuAgAAEQAAAM51EABqAAAAvQEAAB0AAAAlMDAlMDElMDIlMDMlMDQlMDUlMDYlMDclMDglMDklMEElMEIlMEMlMEQlMEUlMEYlMTAlMTElMTIlMTMlMTQlMTUlMTYlMTclMTglMTklMUElMUIlMUMlMUQlMUUlMUYlMjAlMjElMjIlMjMlMjQlMjUlMjYlMjclMjglMjklMkElMkIlMkMlMkQlMkUlMkYlMzAlMzElMzIlMzMlMzQlMzUlMzYlMzclMzglMzklM0ElM0IlM0MlM0QlM0UlM0YlNDAlNDElNDIlNDMlNDQlNDUlNDYlNDclNDglNDklNEElNEIlNEMlNEQlNEUlNEYlNTAlNTElNTIlNTMlNTQlNTUlNTYlNTclNTglNTklNUElNUIlNUMlNUQlNUUlNUYlNjAlNjElNjIlNjMlNjQlNjUlNjYlNjclNjglNjklNkElNkIlNkMlNkQlNkUlNkYlNzAlNzElNzIlNzMlNzQlNzUlNzYlNzclNzglNzklN0ElN0IlN0MlN0QlN0UlN0YlODAlODElODIlODMlODQlODUlODYlODclODglODklOEElOEIlOEMlOEQlOEUlOEYlOTAlOTElOTIlOTMlOTQlOTUlOTYlOTclOTglOTklOUElOUIlOUMlOUQlOUUlOUYlQTAlQTElQTIlQTMlQTQlQTUlQTYlQTclQTglQTklQUElQUIlQUMlQUQlQUUlQUYlQjAlQjElQjIlQjMlQjQlQjUlQjYlQjclQjglQjklQkElQkIlQkMlQkQlQkUlQkYlQzAlQzElQzIlQzMlQzQlQzUlQzYlQzclQzglQzklQ0ElQ0IlQ0MlQ0QlQ0UlQ0YlRDAlRDElRDIlRDMlRDQlRDUlRDYlRDclRDglRDklREElREIlREMlREQlREUlREYlRTAlRTElRTIlRTMlRTQlRTUlRTYlRTclRTglRTklRUElRUIlRUMlRUQlRUUlRUYlRjAlRjElRjIlRjMlRjQlRjUlRjYlRjclRjglRjklRkElRkIlRkMlRkQlRkUlRkaMkhAAYgAAAKEAAABHAAAAjJIQAGIAAAAqAQAAMAAAAIySEABiAAAAKwEAABkAAAAAAAAABAAAAAQAAAB2AQAAAAAAAAQAAAAEAAAAdwEAAExheW91dHNpemVhbGlnbmZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgAADxwTABsAAAAlAAAAAgAAACwcEwD1IRAAeQAAAPsAAAABAAAAdC4QAGsAAAAjAQAADgAAAO8nEABrAAAA+AEAAA4AAAB5AQAAFAAAAAQAAAB6AQAAAAAAAAQAAAAEAAAAMAAAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAewEAAAwAAAAEAAAAfAEAAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IArF4QAGcAAADJAAAACgAAAM51EABqAAAAvQEAAB0AAAB1NxAAXwAAAMMFAAAIAEHMvMwAC7EIdTcQAF8AAADfBQAAHgAAAEFycm93IGRhdGEgbm90IGFsaWduZWQAAHU3EABfAAAA9wUAACIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBPcHRpb25zIHdpdGggdGhlIG1ldGFkYXRhIHZlcnNpb24gY2Fubm90IGJlIGNyZWF0ZWQAAACEHhMAXQAAAHU3EABfAAAACgYAAA0AAAD/////VW5zdXBwb3J0ZWQgY3JhdGU6Ok1ldGFkYXRhVmVyc2lvbiAAAB8TACMAAAB1NxAAXwAAABkGAAAOAAAAU3RyZWFtV3JpdGVyIGlzIGNvbmZpZ3VyZWQgdG8gbm90IGVycm9yIG9uIGRpY3Rpb25hcnkgcmVwbGFjZW1lbnQAAAB1NxAAXwAAAFAFAAAOAAAAQ2Fubm90IHdyaXRlIHJlY29yZCBiYXRjaCB0byBzdHJlYW0gd3JpdGVyIGFzIGl0IGlzIGNsb3NlZENhbm5vdCB3cml0ZSBmb290ZXIgdG8gc3RyZWFtIHdyaXRlciBhcyBpdCBpcyBjbG9zZWRhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAAAB0LhAAawAAACMBAAAOAAAA1zIQAHgAAADrBwAACQAAABA5EABvAAAAkAAAAC4AAAAAAAAABAAAAAQAAAAwAAAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAAB9AQAADAAAAAQAAAB+AQAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgCsXhAAZwAAAMkAAAAKAAAAznUQAGoAAAC9AQAAHQAAAK5uEABRAAAAnwAAAB8AAACubhAAUQAAAKEAAAAZAAAASW50ZXJuYWwgZXJyb3I6IGBgAAAMIhMAEQAAAB0iEwABAAAAYXR0ZW1wdGVkIHRvIHRha2Ugb3duZXJzaGlwIG9mIFJ1c3QgdmFsdWUgd2hpbGUgaXQgd2FzIGJvcnJvd2VkAF6MEABXAAAATQAAABUAQYjFzAALBgEAAAB/AQBBmMXMAAslAQAAANoAAABhIG1hcAAAAIABAAAMAAAABAAAAIEBAACCAQAAIABByMXMAAvjAwEAAACDAQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAARXJyb3IAAADiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAIQBAABNYXAga2V5IGlzIG5vdCBhIHN0cmluZyBhbmQgY2Fubm90IGJlIGFuIG9iamVjdCBrZXkA//////////90LhAAawAAACMBAAAOAAAAvpwqkZE2NGDFSEAXEQ6bNKxeEABnAAAAyQAAAAoAAABjYWxsZWQgYE9wdGlvbjo6dW53cmFwX3Rocm93KClgIG9uIGEgYE5vbmVgIHZhbHVlAAAAhQEAADQAAAAEAAAAhgEAAIUBAAA0AAAABAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAI0BAACOAQAAjwEAAJABAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAnEYQAGkAAACjAAAAEwAAAJ0BAAD//////////6AkEwBBvMnMAAu/CAQAAAAEAAAAngEAAAAAAAAEAAAABAAAAJ8BAABVdGY4RXJyb3J2YWxpZF91cF90b2Vycm9yX2xlbgAAAKABAAAMAAAABAAAAKEBAAAAAAAABAAAAAQAAACiAQAATWlzc2luZ1JlcXVpcmVkRmllbGRyZXF1aXJlZGVycm9yX3RyYWNlSW5jb25zaXN0ZW50VW5pb25maWVsZGZpZWxkX3R5cGUAAAAAAAgAAAAEAAAAowEAAAAAAAAIAAAABAAAAKQBAABlcnJvcnJhbmdlTWlzc2luZ051bGxUZXJtaW5hdG9yVW5hbGlnbmVkcG9zaXRpb251bmFsaWduZWRfdHlwZVJhbmdlT3V0T2ZCb3VuZHMAAAAAAAAEAAAABAAAAKUBAABTaWduZWRPZmZzZXRPdXRPZkJvdW5kc3NvZmZzZXRUb29NYW55VGFibGVzQXBwYXJlbnRTaXplVG9vTGFyZ2VEZXB0aExpbWl0UmVhY2hlZM51EABqAAAAvQEAAB0AAABLKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAAEV4cGVjdGVkIGEgcmVjb3JkIGJhdGNoLCBidXQgZm91bmQgYSBzY2hlbWFVbnN1cHBvcnRlZCBtZXNzYWdlIGhlYWRlciB0eXBlIGluIElQQyBzdHJlYW06ICcniyYTADAAAAC7JhMAAQAAAEZhaWxlZCB0byBwYXJzZSBzY2hlbWEgZnJvbSBtZXNzYWdlIGhlYWRlckZhaWxlZCB0byBwYXJzZSBkaWN0aW9uYXJ5IGJhdGNoIGZyb20gbWVzc2FnZSBoZWFkZXJVbmFibGUgdG8gcmVhZCBJUEMgbWVzc2FnZSBhcyByZWNvcmQgYmF0Y2hFeHBlY3RlZCBhIHNjaGVtYSBhcyB0aGUgZmlyc3QgbWVzc2FnZSBpbiB0aGUgc3RyZWFtLCBnb3Q6IABUJxMAOwAAAEV4cGVjdGVkIHNjaGVtYSBtZXNzYWdlLCBmb3VuZCBlbXB0eSBzdHJlYW0u4kQQAF8AAADPBgAAEgAAAFVuYWJsZSB0byBnZXQgcm9vdCBhcyBtZXNzYWdlOiAA1CcTAB8AAAD/////SW52YWxpZCBtZXRhZGF0YSBsZW5ndGg6IAAAAAAoEwAZAAAAdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAACsXhAAZwAAAMkAAAAKAAAAYXR0ZW1wdGVkIHRvIHRha2Ugb3duZXJzaGlwIG9mIFJ1c3QgdmFsdWUgd2hpbGUgaXQgd2FzIGJvcnJvd2VkAK5uEABRAAAAiQAAABUAAABpbnZhbGlkIHR5cGU6ICwgZXhwZWN0ZWQgAAAApCgTAA4AAACyKBMACwAAAPJZEABvAAAAGQEAABkAAADOdRAAagAAAL0BAAAdAAAA///////////wKBMAQYjSzAAL+18BAAAAAAAAAKcBAABikRAAZAAAADUAAAAOAAAAtlgQAGQAAAAUAQAAFgAAALZYEABkAAAAJAEAABMAAADXMhAAeAAAAOsHAAAJAAAAbWlkID4gbGVuAAAAVCkTAAkAAABMGhAAfwAAAEoAAAAfAAAATBoQAH8AAABEAAAAFwAAAKgBAACpAQAAqgEAAKsBAACsAQAAtlgQAGQAAAC1AAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuc2NvcmUuc2xpY2UoKS5sZW4oKSA+IHN0cmlkZV9kYXRhLmxlbigpAAC2WBAAZAAAALYAAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5zY29yZS5zbGljZSgpLmxlbigpID4gKHN0cmlkZV9kYXRhLmxlbigpIDw8IDMpICsgNyArIDgAAAC2WBAAZAAAALcAAAAJAAAAtlgQAGQAAAC8AAAAEgAAALZYEABkAAAAvgAAABIAAAC2WBAAZAAAAO0AAAARAAAAtlgQAGQAAADgAAAAEQAAANIzEABnAAAA8wAAABwAAADSMxAAZwAAAP0AAAAcAAAA0jMQAGcAAAAOAQAAHgAAANIzEABnAAAAEQEAACgAAADSMxAAZwAAAE4BAAAeAAAA0jMQAGcAAABTAQAAEAAAANIzEABnAAAAVQEAACUAAADSMxAAZwAAAFoBAAANAAAA0jMQAGcAAAASAQAAIQAAANIzEABnAAAAGQEAAC0AAADSMxAAZwAAABsBAAAOAAAA0jMQAGcAAAAxAQAADgAAANIzEABnAAAAMwEAAA4AAADSMxAAZwAAADcBAAAiAAAA0jMQAGcAAAA5AQAAGQAAANIzEABnAAAAOgEAACUAAADSMxAAZwAAACMBAAA1AAAA0jMQAGcAAAAjAQAATAAAANIzEABnAAAAJgEAACsAAADSMxAAZwAAAAgBAAARAAAA0jMQAGcAAAAIAQAAKgAAANIzEABnAAAABwEAAA0AAADSMxAAZwAAAAEBAAAjAAAA0jMQAGcAAAABAQAACQAAANIzEABnAAAA+QAAAA0AAADSMxAAZwAAALEAAAAnAAAA0jMQAGcAAACzAAAAJQAAANIzEABnAAAANAIAACUAAADSMxAAZwAAAIACAAAiAAAA0jMQAGcAAACBAgAAEgAAANIzEABnAAAAkwIAACIAAADSMxAAZwAAAKACAAAyAAAA0jMQAGcAAACiAgAAFAAAANIzEABnAAAAogIAADQAAADSMxAAZwAAAKQCAAAxAAAA0jMQAGcAAACkAgAAHgAAANIzEABnAAAApQIAABEAAADSMxAAZwAAAKYCAAARAAAA0jMQAGcAAABTAgAAHwAAANIzEABnAAAAWAIAABEAAADSMxAAZwAAAFoCAAARAAAA0jMQAGcAAABeAgAAFgAAANIzEABnAAAAbAIAAA0AAADSMxAAZwAAAG0CAAAQAAAA0jMQAGcAAABkAgAANgAAANIzEABnAAAAZAIAABoAAADSMxAAZwAAAFQCAAA4AAAA0jMQAGcAAAD5AQAAKgAAANIzEABnAAAA+gEAAEIAAADSMxAAZwAAAA0CAAAqAAAA0jMQAGcAAAAOAgAAQAAAANIzEABnAAAAIAIAADgAAADSMxAAZwAAAB8CAAARAAAA0jMQAGcAAAAYAgAAKAAAANIzEABnAAAAGAIAABUAAADSMxAAZwAAABcCAAARAAAA0jMQAGcAAAAaAgAAPwAAANIzEABnAAAAGgIAABEAAADSMxAAZwAAABwCAAARAAAA0jMQAGcAAADTAQAAJQAAANIzEABnAAAA1AEAACMAAADSMxAAZwAAANcBAAAjAAAA0jMQAGcAAADBAQAAJQAAANIzEABnAAAAxQEAABgAAADSMxAAZwAAAMUBAAAvAAAA0jMQAGcAAADNAgAALAAAANIzEABnAAAA4QIAACYAAADSMxAAZwAAAOICAAAWAAAA0jMQAGcAAAD0AgAAJgAAANIzEABnAAAA/QIAAAkAAADSMxAAZwAAAP4CAAAJAAAA0jMQAGcAAACNAwAAGAAAANIzEABnAAAAjwMAABEAAADSMxAAZwAAAHkDAAANAAAA0jMQAGcAAADEAAAACgAAANIzEABnAAAAygAAAAoAAADSMxAAZwAAANEAAAASAAAA0jMQAGcAAACSAAAAJgAAANIzEABnAAAAlwAAAEEAAADSMxAAZwAAAJwAAAA1AAAA0jMQAGcAAACJAQAAHgAAANIzEABnAAAAiQEAABIAAADSMxAAZwAAAIoBAAAXAAAA0jMQAGcAAABFAAAAIQAAANIzEABnAAAATwAAAAkAAABOIxAAXwAAANUAAAAUAAAATiMQAF8AAADVAAAAHgAAAE4jEABfAAAA1gAAABQAAABOIxAAXwAAANYAAAAeAAAATiMQAF8AAADXAAAAFAAAAE4jEABfAAAA1wAAAB4AAABOIxAAXwAAANgAAAAUAAAATiMQAF8AAADYAAAAHgAAAE4jEABfAAAA2QAAABQAAABOIxAAXwAAANkAAAAeAAAATiMQAF8AAADaAAAAFAAAAE4jEABfAAAA2gAAAB4AAABOIxAAXwAAANsAAAAUAAAATiMQAF8AAADbAAAAHgAAAE4jEABfAAAA3AAAABQAAABOIxAAXwAAANwAAAAeAAAATiMQAF8AAADiAAAAFgAAAE4jEABfAAAA4gAAAB4AAABOIxAAXwAAAOMAAAAWAAAATiMQAF8AAADjAAAAHgAAAE4jEABfAAAA5AAAABYAAABOIxAAXwAAAOQAAAAeAAAATiMQAF8AAADlAAAAFgAAAE4jEABfAAAA5QAAAB4AAABOIxAAXwAAAOYAAAAWAAAATiMQAF8AAADmAAAAHgAAAE4jEABfAAAA5wAAABYAAABOIxAAXwAAAOcAAAAeAAAATiMQAF8AAADoAAAAFgAAAE4jEABfAAAA6AAAAB4AAABOIxAAXwAAAOkAAAAWAAAATiMQAF8AAADpAAAAHgAAADo0EABgAAAALgEAACkAAAA6NBAAYAAAAC4BAAAkAAAAOjQQAGAAAAAuAQAAQQAAADo0EABgAAAAKwEAACIAAAA6NBAAYAAAACsBAAAdAAAAOjQQAGAAAAAXAQAADQAAADo0EABgAAAAGQEAAA0AAAA6NBAAYAAAABwBAAAtAAAAOjQQAGAAAAAcAQAAOgAAADo0EABgAAAAKAEAAAkAAAA6NBAAYAAAACABAAAbAAAAOjQQAGAAAAAgAQAAFgAAADo0EABgAAAAoAAAAAwAAAA6NBAAYAAAAKsAAAAJAAAAOjQQAGAAAACtAAAAGAAAADo0EABgAAAArgAAAB0AAAA6NBAAYAAAALkAAAAUAAAAOjQQAGAAAADoAAAAEQAAADo0EABgAAAAygAAADAAAAA6NBAAYAAAANkAAAAdAAAAOjQQAGAAAADXAAAAHQAAADo0EABgAAAAuwAAADAAAAA6NBAAYAAAALIAAAAQAAAAOjQQAGAAAACUAAAAFQAAADo0EABgAAAAlQAAABUAAAA6NBAAYAAAAGABAAASAAAAOjQQAGAAAABgAQAACQAAADo0EABgAAAAVgEAAB8AAAA6NBAAYAAAAFYBAAAMAAAAOjQQAGAAAABXAQAANgAAADo0EABgAAAAVwEAAA0AAAA6NBAAYAAAAFoBAAAWAAAAOjQQAGAAAABOAQAAHwAAADo0EABgAAAATgEAAAwAAAA6NBAAYAAAAEoBAAAJAAAAOjQQAGAAAACvAQAAJgAAADo0EABgAAAAsAEAADUAAAA6NBAAYAAAAJEBAAAnAAAAOjQQAGAAAACSAQAAKgAAADo0EABgAAAAjAEAABEAAAA6NBAAYAAAAIIBAAASAAAAOjQQAGAAAACCAQAACQAAADo0EABgAAAAhAEAAAkAAAA6NBAAYAAAAH8BAAAJAAAAOjQQAGAAAABQAAAAEQAAADo0EABgAAAAUQAAABEAAAA6NBAAYAAAAFMAAAAYAAAAOjQQAGAAAABUAAAAGAAAADo0EABgAAAAXwAAABEAAAA6NBAAYAAAAGwAAAA8AAAAOjQQAGAAAAB0AAAAEQAAADo0EABgAAAAbwAAABUAAACJUxAAYgAAAJQBAAAWAAAAiVMQAGIAAAB+AQAAFAAAAIlTEABiAAAAgQEAABkAAACJUxAAYgAAALIBAAASAAAAiVMQAGIAAACzAQAAEgAAAIlTEABiAAAAXgEAABoAAACJUxAAYgAAAF8BAAAcAAAAiVMQAGIAAADpAQAAFAAAAIlTEABiAAAA7QEAABIAAACJUxAAYgAAAAkCAAAaAAAAiVMQAGIAAAAKAgAAGQAAAIlTEABiAAAAEAIAABoAAACJUxAAYgAAAPgBAAAZAAAAiVMQAGIAAAD+AQAAGgAAAIlTEABiAAAA/wEAABUAAAARXBAAYgAAAI4BAAAtAAAAEVwQAGIAAACrAQAAJgAAABFcEABiAAAArAEAABYAAAARXBAAYgAAAL8BAAAiAAAAEVwQAGIAAADOAQAAGQAAABFcEABiAAAAVgMAACUAAAARXBAAYgAAAFUDAAANAAAAEVwQAGIAAAAXAQAAHwAAABFcEABiAAAAGAEAABUAAAARXBAAYgAAACQDAAAbAAAAEVwQAGIAAAAzAgAACQAAABFcEABiAAAANAIAAAkAAAARXBAAYgAAADUCAAAuAAAAEVwQAGIAAAA7AgAAIQAAABFcEABiAAAAQAIAAA0AAAARXBAAYgAAAHgCAAAhAAAAEVwQAGIAAAB7AgAADQAAABFcEABiAAAAZwIAAA0AAAARXBAAYgAAAGkCAAARAAAAEVwQAGIAAABoAgAADQAAABFcEABiAAAAbQIAAA0AAAARXBAAYgAAAFcCAAANAAAAEVwQAGIAAABYAgAADQAAABFcEABiAAAAYQIAACUAAAARXBAAYgAAAEwCAAA8AAAAEVwQAGIAAABQBAAADQAAABFcEABiAAAASQQAAA0AAAARXBAAYgAAAEIEAAANAAAAEVwQAGIAAADgAQAALQAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9jb250ZXh0cyA8PSBCUk9UTElfTUFYX1NUQVRJQ19DT05URVhUUxFcEABiAAAA4gEAAAUAAAARXBAAYgAAAOYBAAAmAAAAEVwQAGIAAAD/AQAAJgAAABFcEABiAAAAAAIAABYAAAARXBAAYgAAABQCAAAmAAAAEVwQAGIAAAA3AwAADgAAABFcEABiAAAAowIAAAkAAAARXBAAYgAAAKQCAAAJAAAAEVwQAGIAAACuAgAAIAAAABFcEABiAAAApgIAADIAAAARXBAAYgAAAKcCAAANAAAAEVwQAGIAAAD7AgAAIQAAABFcEABiAAAAAQMAABUAAAARXBAAYgAAAAADAAARAAAAEVwQAGIAAAACAwAAKgAAABFcEABiAAAABAMAABUAAAARXBAAYgAAAAYDAAAlAAAAEVwQAGIAAADmAgAADQAAABFcEABiAAAA5wIAABgAAAARXBAAYgAAAOgCAAANAAAAEVwQAGIAAADvAgAAFQAAABFcEABiAAAA7gIAABEAAAARXBAAYgAAAPACAAARAAAAEVwQAGIAAADyAgAAJQAAABFcEABiAAAA0QIAAA0AAAARXBAAYgAAANICAAANAAAAEVwQAGIAAADeAgAAJAAAABFcEABiAAAA1gIAABEAAAARXBAAYgAAANcCAAAqAAAAEVwQAGIAAAC7AgAAJgAAABFcEABiAAAAuwIAAA0AAAARXBAAYgAAAMECAAAVAAAAEVwQAGIAAADEAgAAHgAAABFcEABiAAAAxgIAABUAAAARXBAAYgAAAKMDAAAcAAAAEVwQAGIAAADOAwAAGgAAABFcEABiAAAAzwMAABkAAAARXBAAYgAAAK8DAAAjAAAAEVwQAGIAAADCAwAAHQAAABFcEABiAAAAcwMAADIAAAC/VhAAZAAAALIAAAAGAAAAv1YQAGQAAADqAAAAOAAAAL9WEABkAAAA6wAAABUAAAC/VhAAZAAAAPgAAAAVAAAAv1YQAGQAAAAnAQAAEgAAAL9WEABkAAAAOQEAABUAAAC/VhAAZAAAAEUBAAAUAAAAED4QAIMAAAA6AAAAFwAAABA+EACDAAAAPQAAACYAAAAQPhAAgwAAAD0AAAANAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmZmVyLmxlbigpID49IG51bGxfY291bnROYBAAaQAAAMwAAAAJAAAATmAQAGkAAADhAAAAGAAAAE51bWJlciBvZiB2YWx1ZXMgcmVhZDogLCBkb2Vzbid0IG1hdGNoIGV4cGVjdGVkOiAAAACUOxMAFwAAAKs7EwAaAAAAYXNzZXJ0aW9uIGZhaWxlZDogYml0X3dpZHRoIDw9IDY0AAAAFGwQAGQAAABXAAAACQAAABRsEABkAAAA8QAAACcAAABiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQUbBAAZAAAAIIBAAA7AAAAFGwQAGQAAACFAQAAIAAAABRsEABkAAAAewEAAEcAAAAUbBAAZAAAAHwBAAAXAAAAFGwQAGQAAACiAQAAOwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSA+PSBtYXhfdmFsdWVzFGwQAGQAAAC+AQAACQAAABRsEABkAAAAzgEAADsAAAAUbBAAZAAAAOEBAAAbAAAAFGwQAGQAAADjAQAAJwAAABRsEABkAAAAxgEAADMAAAAUbBAAZAAAAMcBAAAiAAAAFGwQAGQAAADJAQAAFwAAABRsEABkAAAA5AEAADoAAAAUbBAAZAAAAPUBAAAzAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5jdXJyZW50X3ZhbHVlLmlzX3NvbWUoKQAAFGwQAGQAAAAEAgAAEQAAALIBAAAwAAAABAAAALMBAACyAQAAMAAAAAQAAAC0AQAAsgEAADAAAAAEAAAAtQEAALIBAAAwAAAABAAAALYBAACyAQAAMAAAAAQAAAC3AQAAsgEAADAAAAAEAAAAuAEAALIBAAAwAAAABAAAALkBAAC6AQAAOAAAAAQAAAC7AQAASbCekHpOLC/LbknqMggYfB2y9+s5jHY/bp6hQw4xO1cGFsb1IWxDVWzMGSiQApVawHHNK/WXKix1JwoV9WuZpB+hT8T8IUEh1iLFiOnXsXiCl9us/xj5ogqzS4zEu4wpNZTMQjy9Tcz3+cJcdQSaAv0tEgMJOI1CEVkINR0E9PCH/FZ7jfIxPLY3ukYvCXyWtaHfx+CoTEOS/RHiY2P8o2OYOC6bqJpWsC9YjrdR6IcHIBtNdP6iSb6f5/cakgR4bWlkID4gbGVuAAAAwD4TAAkAAADOdRAAagAAAL0BAAAdAAAAc2V0X2RhdGEgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQeahAAYAAAABcDAAA6AAAAHmoQAGAAAACuAwAAEgAAAB5qEABgAAAAvQMAADUAAAAeahAAYAAAAL4DAAA1AAAAHmoQAGAAAAC/AwAANQAAAE5vdCBlbm91Z2ggYnl0ZXMgdG8gZGVjb2RlAACDTxAAcwAAAHAAAAAeAAAAg08QAHMAAABxAAAAHgAAAEFycm93UHJlZGljYXRlIHByZWRpY2F0ZSByZXR1cm5lZCAgcm93cywgZXhwZWN0ZWQgAACQPxMAIgAAALI/EwAQAAAAAAAAAJlLEABzAAAAdQAAAA0AAACZSxAAcwAAAIEAAAAvAAAAmUsQAHMAAACYAAAAFwAAAG91dCBvZiBvcmRlcghAEwAMAAAAmUsQAHMAAACSAAAAIwAAAJlLEABzAAAAjAAAACcAAACZSxAAcwAAAIsAAABUAAAAmUsQAHMAAACPAAAAHwAAAJlLEABzAAAAkAAAAB8AAACZSxAAcwAAALQAAAAYAAAAmUsQAHMAAADoAAAALAAAAJlLEABzAAAA7wAAABwAAABzZWxlY3Rpb24gZXhjZWVkcyB0aGUgbnVtYmVyIG9mIHNlbGVjdGVkIHJvd3MAAACZSxAAcwAAABoBAAASAAAAmUsQAHMAAAA3AQAAIwAAAJlLEABzAAAAOgEAAB8AAACZSxAAcwAAAEoBAAAXAAAAc2VsZWN0aW9uIGNvbnRhaW5zIGxlc3MgdGhhbiB0aGUgbnVtYmVyIG9mIHNlbGVjdGVkIHJvd3MMQRMAOAAAAJlLEABzAAAAQQEAABEAAACZSxAAcwAAAJEBAAAdAAAAmUsQAHMAAACSAQAAEwAAAJlLEABzAAAAkwEAABMAAACZSxAAcwAAAOcBAAAjAAAAmUsQAHMAAADrAQAAHwAAAJlLEABzAAAA1gEAACEAAACZSxAAcwAAAP4BAAAdAAAAmUsQAHMAAAACAgAAFwAAAJlLEABzAAAACwIAAC0AAACZSxAAcwAAAA8CAAAbAAAAmUsQAHMAAAANAgAASgAAAFQ7EABvAAAAKgAAABYAAABUOxAAbwAAADoAAAAUAAAAVDsQAG8AAABDAAAAFAAAAFVuc3VwcG9ydGVkIGRhdGEgdHlwZTogADxCEwAXAAAAVDsQAG8AAABeAAAAEgAAAJIMEAB1AAAAKQAAACIAAACSDBAAdQAAACoAAAAJAAAAkgwQAHUAAAAwAAAAIgAAAJIMEAB1AAAAMQAAAAkAAACSDBAAdQAAADkAAAAJAAAAaW5jb25zaXN0ZW50IERFTFRBX0JZVEVfQVJSQVkgbGVuZ3RocywgcHJlZml4ZXM6ICwgc3VmZml4ZXM6IAAAALxCEwAxAAAA7UITAAwAAACSDBAAdQAAAFUAAAAnAAAAkgwQAHUAAABXAAAAJgAAAJIMEAB1AAAAZQAAACkAAACSDBAAdQAAAGUAAAASAAAAZW9mIGRlY29kaW5nIGJ5dGUgYXJyYXkAkgwQAHUAAAB0AAAAJwAAAJIMEAB1AAAAdgAAACYAAACSDBAAdQAAAIQAAAApAAAAkgwQAHUAAACEAAAAEgAAAFB9EABuAAAAewAAAEwAAABQfRAAbgAAANQAAAApAAAARGVmaW5pdGlvbiBsZXZlbHMgc2hvdWxkIGV4aXN0IHdoZW4gZGF0YSBpcyBsZXNzIHRoYW4gbGV2ZWxzIQAAAB5qEABgAAAAjAMAAAUAAAAeahAAYAAAAI0DAAAFAAAAHmoQAGAAAACOAwAABQAAAB5qEABgAAAAjwMAAAUAAAC/VhAAZAAAALIAAAAGAAAAZW5jb3VudGVyZWQgbm9uIFVURi04IGRhdGE6IFREEwAcAAAAvAEAALABAAAIAAAAvQEAAL4BAAC/AQAAwAEAAMEBAADCAQAAwwEAAMQBAACwAQAACAAAAMUBAAC+AQAAxgEAAMcBAADIAQAAwgEAAMMBAABpbnZhbGlkIGRhdGEgdHlwZSBmb3IgYnl0ZSBhcnJheSByZWFkZXIgLSAAAMhEEwAqAAAAvAEAALABAAAIAAAAyQEAAMQBAACwAQAACAAAAMoBAADpDRAAdAAAAIAAAABLAAAAsgEAADAAAAAEAAAAywEAAMwBAADNAQAAzgEAAM8BAADQAQAA0QEAANIBAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkNEAB0AAAAjAAAAEsAAACyAQAAMAAAAAQAAADeAQAA3wEAAOABAADhAQAAzwEAAOIBAADjAQAA5AEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAASW52YWxpZC9VbnN1cHBvcnRlZCBlbmNvZGluZyB0eXBlIGZvciBkaWN0aW9uYXJ5OiAAAOxFEwAyAAAAbm8gZGVjb2RlciBzZXR1bnN1cHBvcnRlZCBlbmNvZGluZyBmb3IgYnl0ZSBhcnJheTogADZGEwAlAAAAbWlzc2luZyBkaWN0aW9uYXJ5IHBhZ2UgZm9yIGNvbHVtbgAA6Q0QAHQAAAByAQAAGAAAAOkNEAB0AAAAfgEAABcAAADpDRAAdAAAAIcBAAApAAAA6Q0QAHQAAACQAQAAIQAAAOkNEAB0AAAAewEAABYAAADpDRAAdAAAAKYBAAApAAAA6Q0QAHQAAAC/AQAAGwAAAEluc3VmZmljaWVudCBkZWx0YSBsZW5ndGggYnl0ZSBhcnJheSBieXRlc25lZ2F0aXZlIGRlbHRhIGxlbmd0aCBieXRlIGFycmF5IGxlbmd0aAAAAOkNEAB0AAAA5AEAABgAAADpDRAAdAAAAOYBAAAoAAAA6Q0QAHQAAADpAQAAFwAAAOkNEAB0AAAA7wEAACQAAADpDRAAdAAAAAICAAAoAAAA6Q0QAHQAAAAfAgAAGAAAAOUBAACwAQAACAAAAOYBAAC+AQAA5wEAAOgBAADpAQAAwgEAAMMBAABpbnZhbGlkIGRhdGEgdHlwZSBmb3IgYnl0ZSBhcnJheSByZWFkZXIgcmVhZCB0byB2aWV3IHR5cGUgLSDURxMAPAAAAOUBAACwAQAACAAAAOoBAABkaWN0aW9uYXJ5IHJlcXVpcmVkIGZvciBkaWN0aW9uYXJ5IGVuY29kaW5nAN8FEAB5AAAATgEAABYAAADfBRAAeQAAAJ4BAAApAAAA3wUQAHkAAADPAQAAIAAAAN8FEAB5AAAACwIAABsAAADfBRAAeQAAACoCAAAWAAAA3wUQAHkAAAAsAgAAKAAAAN8FEAB5AAAAQAIAACgAAADfBRAAeQAAAE0CAAAoAAAA3wUQAHkAAABtAgAAFgAAAN8FEAB5AAAAcAIAACkAAADfBRAAeQAAAIkCAAAuAAAA3wUQAHkAAACkAgAACQAAAN8FEAB5AAAAegIAACIAAADfBRAAeQAAAJICAAAsAAAA3wUQAHkAAACQAgAAIgAAAGZsb2F0IDE2IHR5cGUgbXVzdCBiZSAyIGJ5dGVzLCBnb3QgAERJEwAjAAAAaW50ZXJ2YWwgdHlwZSBtdXN0IGNvbnNpc3Qgb2YgMTIgYnl0ZXMgZ290IABwSRMAKwAAAGRlY2ltYWwgMzIgdHlwZSB0b28gbGFyZ2UsIG11c3QgYmUgbGVzcyB0aGVuIDQgYnl0ZXMsIGdvdCAAAKRJEwA6AAAAZGVjaW1hbCA2NCB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoZW4gOCBieXRlcywgZ290IAAA6EkTADoAAABkZWNpbWFsIDEyOCB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoYW4gMTYgYnl0ZXMsIGdvdCAsShMAPAAAAOsBAACoAQAACAAAAOwBAADtAQAA7gEAAO8BAADwAQAA8QEAAPIBAABkZWNpbWFsIDI1NiB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoYW4gMzIgYnl0ZXMsIGdvdCCYShMAPAAAAGludmFsaWQgZGF0YSB0eXBlIGZvciBmaXhlZCBsZW5ndGggYnl0ZSBhcnJheSByZWFkZXIgLSAA3EoTADcAAABpbnZhbGlkIHBoeXNpY2FsIHR5cGUgZm9yIGZpeGVkIGxlbmd0aCBieXRlIGFycmF5IHJlYWRlciAtIAAcSxMAOwAAAOsBAACoAQAACAAAAPMBAACyAQAAMAAAAAQAAAD0AQAA9QEAAPYBAAD3AQAAzwEAAPgBAAD5AQAA+gEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAsgEAADAAAAAEAAAA+wEAAPwBAAD9AQAA/gEAAM8BAAD/AQAAAAIAAAECAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAALIBAAAwAAAABAAAAAICAAADAgAABAIAAAUCAADPAQAABgIAAAcCAAAIAgAA0wEAANQBAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABNb250aERheU5hbm8gaW50ZXJ2YWxzIG5vdCBzdXBwb3J0ZWSyAQAAMAAAAAQAAAAJAgAACgIAAAsCAAAMAgAAzwEAAA0CAAAAAgAAAQIAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAsgEAADAAAAAEAAAADgIAAA8CAAAQAgAAEQIAAM8BAAASAgAABwIAAAgCAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAALoBAAA4AAAABAAAABMCAAAUAgAAFQIAABYCAAAXAgAAGAIAABkCAAAaAgAAGwIAANQBAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAAATDBAAfgAAACgBAAAJAAAAEwwQAH4AAAAqAQAADgAAABMMEAB+AAAANAEAACQAAAATDBAAfgAAADUBAAAnAAAAEwwQAH4AAAA2AQAAIwAAABMMEAB+AAAAPQEAADkAAAATDBAAfgAAAD0BAAAbAAAAdG9vIGZldyBieXRlcyBpbiBkaWN0aW9uYXJ5IHBhZ2UsIGV4cGVjdGVkICBnb3QgFE4TACsAAAA/ThMABQAAAHVuc3VwcG9ydGVkIGVuY29kaW5nIGZvciBmaXhlZCBsZW5ndGggYnl0ZSBhcnJheTogAABUThMAMgAAABMMEAB+AAAAlQEAABgAAAATDBAAfgAAAJkBAAAlAAAAEwwQAH4AAACcAQAAFQAAABMMEAB+AAAAnwEAADUAAAATDBAAfgAAAJ8BAAAWAAAAEwwQAH4AAACkAQAANAAAABMMEAB+AAAAtgEAABwAAAATDBAAfgAAAMgBAAAkAAAAEwwQAH4AAADAAQAAIAAAAGVuY291bnRlcmVkIGFycmF5IHdpdGggaW5jb3JyZWN0IGxlbmd0aCwgZ290ICBleHBlY3RlZCAAIE8TAC0AAABNTxMACgAAABMMEAB+AAAA1QEAACUAAAATDBAAfgAAANcBAAAuAAAAEwwQAH4AAADeAQAAJAAAABMMEAB+AAAA9QEAAAkAAAATDBAAfgAAAPYBAAAbAAAAEwwQAH4AAAD4AQAAGwAAABMMEAB+AAAA+gEAAA0AAACZSxAAcwAAAGMAAAARAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmZmVyLmxlbigpID49IG51bGxfY291bnROYBAAaQAAAMwAAAAJAAAATmAQAGkAAADhAAAAGAAAAE51bWJlciBvZiB2YWx1ZXMgcmVhZDogLCBkb2Vzbid0IG1hdGNoIGV4cGVjdGVkOiAAAAA0UBMAFwAAAEtQEwAaAAAATmAQAGkAAAB3AQAAGQAAAE5gEABpAAAAgQEAABkAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLnJsZV9kZWNvZGVyLmlzX3NvbWUoKU5gEABpAAAAigEAAAkAAABNdXN0IGNhbGwgc2V0X2RpY3QoKSBmaXJzdCEA1FATABsAAABOYBAAaQAAAIsBAAAJAAAATmAQAGkAAACcAQAACQAAAE5gEABpAAAAnQEAAAkAAABCaXQgcmVhZGVyIGlzIG5vdCBpbml0aWFsaXplZAAAAChREwAdAAAATmAQAGkAAAA8AgAACQAAAGluc3VmZmljaWVudCBtaW5pIGJsb2NrIGJpdCB3aWR0aHNOb3QgZW5vdWdoIGRhdGEgdG8gZGVjb2RlICdtaW5fZGVsdGEnJ21pbl9kZWx0YScgdG9vIGxhcmdlTmAQAGkAAACsAgAADAAAACd2YWx1ZXNfcGVyX21pbmlfYmxvY2snIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAzMiBnb3QgAAAAzFETADUAAAAnYmxvY2tfc2l6ZScgbXVzdCBiZSBhIG11bHRpcGxlIG9mICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snIGdvdCAgYW5kIAxSEwA/AAAAS1ITAAUAAAAnYmxvY2tfc2l6ZScgbXVzdCBiZSBhIG11bHRpcGxlIG9mIDEyOCwgZ290IGBSEwAsAAAATm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAnYmxvY2tfc2l6ZSdpbnZhbGlkICdibG9ja19zaXplJ05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ21pbmlfYmxvY2tzX3Blcl9ibG9jaydpbnZhbGlkICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snTm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAndmFsdWVzX2xlZnQnaW52YWxpZCAndmFsdWVzX2xlZnQnTm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAnZmlyc3RfdmFsdWUnZmlyc3QgdmFsdWUgdG9vIGxhcmdlAABOYBAAaQAAAMUCAAAJAAAATmAQAGkAAADZAgAANwAAAE5gEABpAAAA3gIAACcAAABFeHBlY3RlZCB0byByZWFkICB2YWx1ZXMgZnJvbSBtaW5pYmxvY2sgZ290IMhTEwARAAAA2VMTABsAAABOYBAAaQAAABkDAAAfAAAATmAQAGkAAAAfAwAANwAAAE5gEABpAAAAJQMAACwAAABFeHBlY3RlZCB0byBza2lwICB2YWx1ZXMgZnJvbSBtaW5pIGJsb2NrIGdvdCAuAAA0VBMAEQAAAEVUEwAcAAAAYVQTAAEAAABiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQUbBAAZAAAAPUBAAAzAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5jdXJyZW50X3ZhbHVlLmlzX3NvbWUoKQAAFGwQAGQAAAAEAgAAEQAAACwCAAAwAAAABAAAAC0CAAAsAgAAMAAAAAQAAAAuAgAALAIAADAAAAAEAAAALwIAACwCAAAwAAAABAAAADACAAAsAgAAMAAAAAQAAAAxAgAALAIAADAAAAAEAAAAMgIAACwCAAAwAAAABAAAADMCAAAsAgAAMAAAAAQAAAA0AgAALAIAADAAAAAEAAAANQIAACwCAAAwAAAABAAAADYCAAAsAgAAMAAAAAQAAAA3AgAALAIAADAAAAAEAAAAOAIAACwCAAAwAAAABAAAADkCAAAsAgAAMAAAAAQAAAA6AgAALAIAADAAAAAEAAAAOwIAACwCAAAwAAAABAAAADwCAAAsAgAAMAAAAAQAAAA9AgAALAIAADAAAAAEAAAAPgIAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAGJQEABrAAAAuAAAADwAAABiUBAAawAAAL0AAAA8AAAApBddj0p1IC1jlr4w3kLr7I3ResKkGSF32RXbngUX6YzI38/gHY6V+Cw560n3/WZPTJqoXyEsQuR+RYOvg201XDJloBydQ7YeYZGsDLUK81pubCjo7Cqwtv0vbsrQ3pWAH6FPxPwhQSHWIsWI6dexeJSCiwjcagIZQeaoCR/zc2V7O1YNFzc+RhlD6Yd/hRxS5FRR3lWEjTS1ZKKSuuhvGRCfZPHaaP4G7yatjQonws2L2qjMuJ7G9LBR3guMn66EGWL6Rh0Viu4YS3IKpXssrUlI6zz1ZfGccblydT5HjUK+nCqRkTY0YMVIQBcRDps0aqMshJxtVfiTNJy32PbsKziwhsyCKnpMRRJS+jEiJkOmJuXsSwD/GzcFFWtUvOvO4glLZyaNXdZwj6AmoOh7no71r478nL35Zpxe86FyNeCH/FZ7jfIxPLY3ukYvCXyW0fidydGl/c5W4SOD4clHcTX8EWXtUm++JzmV/3oBUuVyfspTfoQ6K9lFQ5fxtd+vtaHfx+CoTEOS/RHiY2P8o2OYOC6bqJpWsC9YjrdR6IetR+fPNHAYPwCyAEDGFTLI7BeAjnZ3GipCNpjMZUnJ/DrxxBg8KB1fOIpReT+M5+xqRqZKJ4y4Jm5AmvMNgeyB87zQDEnzJyLDyjNAJ+6YoVR1LppKF+jONZMioJSSTzvck6FJuSR7lgW4uQDRfsYMKdvkcvmpKCl5lOgRihwXuhNJIe4A56RTQvckt1Iyvvlkm5L1DI4LYM1oZ9Ph41C5ClGzLBKqEuoLWd7b1Oy8Oe6bMrgUntG5cMd4s0FYFxE/AgAAAAAAAP//////////+FgTAEGQss0AC4YB1zIQAHgAAADrBwAACQAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXnUvQwWTYxmnA9FZIsitp6dQooM/ty6wqcqBMgFsqzLt84FA5hqJmElzQK+h5WqMNlLOwZ2P6xfPXMpxYUMHCaTQAIAABQAAAAEAAAAQQIAQaCzzQAL+ggBAAAAQgIAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAgAAAAIAAAAQwIAAAAAAAAEAAAABAAAAEQCAABUb29CaWdnaXZlbm1heEJ1ZmZlclRvb1NtYWxsbWluRW1wdHlIZWFkZXJIZWFkZXJNaXNtYXRjaGV4cGVjdGVkX2xlbmdvdF9sZW5MaXRlcmFsbGVuc3JjX2xlbmRzdF9sZW5Db3B5UmVhZENvcHlXcml0ZU9mZnNldG9mZnNldGRzdF9wb3MAAAAAAAQAAAAEAAAARQIAAFN0cmVhbUhlYWRlcmJ5dGUAAAAABAAAAAQAAABGAgAAU3RyZWFtSGVhZGVyTWlzbWF0Y2hieXRlc1Vuc3VwcG9ydGVkQ2h1bmtUeXBlAAAAAAAAAAQAAAAEAAAARwIAAFVuc3VwcG9ydGVkQ2h1bmtMZW5ndGhoZWFkZXIAAAAABAAAAAQAAABIAgAAAAAAAAQAAAAEAAAASQIAAENoZWNrc3VtZXhwZWN0ZWRnb3QAfgAQAIAAAAChAQAALgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IENBUEFDSVRZYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5oZWlnaHQgLSAxlHEQAHsAAACtAgAACQAAAJRxEAB7AAAAsQIAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBzcmMubGVuKCkgPT0gZHN0LmxlbigplHEQAHsAAABKBwAABQAAAJRxEAB7AAAAxwQAACMAAACUcRAAewAAAAoFAAAkAAAAYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5ub2RlLmhlaWdodCAtIDEAAACUcRAAewAAAPoDAAAJAAAAPmcQAH8AAABYAgAAMAAAAE5vbmUAAAAABAAAAAQAAAAqAgAAU29tZQAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAEsCAAAMAAAABAAAAEwCAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yTGF5b3V0RXJyb3IAALEHEABtAAAATAAAAAoAAADOdRAAagAAAL0BAAAdAAAAAAAAAAQAAAAEAAAATQIAQai8zQALIU4CAAA0AAAABAAAAE8CAABQAgAALAAAAAQAAABRAgAAAQBB1LzNAAuJJlBhcnF1ZXQgZXJyb3I6IABUXhMADwAAAE5ZSTogAAAAbF4TAAUAAABFT0Y6IAAAAHxeEwAFAAAAQXJyb3c6IACMXhMABwAAAEluZGV4ICBvdXQgb2YgYm91bmQ6IAAAAJxeEwAGAAAAol4TAA8AAABFeHRlcm5hbDogAADEXhMACgAAAE5lZWRNb3JlRGF0YTogAADYXhMADgAAAE5lZWRNb3JlRGF0YVJhbmdlOiAuLgAAAPBeEwATAAAAA18TAAIAAABJbnRlZ2VyIG92ZXJmbG93OiAAABhfEwASAAAAUgIAAAgAAAAEAAAAhgAAAFICAAAIAAAABAAAAFMCAACGAAAANF8TAFQCAABVAgAAVgIAAFcCAABYAgAAWQIAACAAAAAIAAAAWgIAAFkCAAAgAAAACAAAAFsCAABaAgAAcF8TAFwCAABdAgAAXgIAAF8CAABgAgAAYQIAABQAAAAEAAAAhwAAAGECAAAUAAAABAAAAGICAACHAAAArF8TAGMCAABkAgAAZQIAAGYCAABYAgAAQAIAABQAAAAEAAAAZwIAAEACAAAUAAAABAAAAEECAABnAgAA6F8TAGgCAABpAgAAZQIAAGoCAABYAgAASW5jb21wYXRpYmxlIHR5cGUuIEZpZWxkICcnIGhhcyB0eXBlICwgYXJyYXkgaGFzIHR5cGUgAAAkYBMAGgAAAD5gEwALAAAASWATABEAAABOAgAANAAAAAQAAACHAQAAawIAAIkBAABsAgAAbQIAAIwBAABuAgAAbwIAAI8BAABwAgAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZXQqEABwAAAA3gAAABoAAABEYXRhdHlwZSAgaXMgbm90IHlldCBzdXBwb3J0ZWQAAARhEwAJAAAADWETABUAAAB0KhAAcAAAAA4BAAAfAAAAdCoQAHAAAAAUAQAAPwAAAHQqEABwAAAAGQEAAC8AAAB0KhAAcAAAACoBAAA7AAAAdCoQAHAAAAArAQAAHAAAAHQqEABwAAAALAEAADsAAAB0KhAAcAAAAC0BAAAcAAAAdCoQAHAAAAAzAQAAOwAAAHQqEABwAAAANAEAABwAAAB0KhAAcAAAADUBAAA7AAAAdCoQAHAAAAA2AQAAHAAAAHQqEABwAAAAZQEAAD8AAAB0KhAAcAAAAGYBAAAgAAAAdCoQAHAAAABpAQAAJAAAAHQqEABwAAAApgEAADsAAAB0KhAAcAAAAMABAAA7AAAAdCoQAHAAAADBAQAAHAAAAHQqEABwAAAAwgEAADsAAAB0KhAAcAAAAMMBAAAcAAAAdCoQAHAAAADdAQAARwAAAHQqEABwAAAA3gEAACgAAAB0KhAAcAAAAN8BAABHAAAAdCoQAHAAAADgAQAAKAAAAHQqEABwAAAADAIAACsAAAB0KhAAcAAAAPQBAAAcAAAAdCoQAHAAAAD1AQAAJwAAAHQqEABwAAAABwIAACQAAAB0KhAAcAAAAAgCAAAvAAAAYXNzZXJ0aW9uIGZhaWxlZDogcmFuZ2UuZW5kIDw9IG51bGxzLmxlbigpAAB0KhAAcAAAAPkBAAAZAAAAdCoQAHAAAAD7AQAAJAAAAHQqEABwAAAAAAIAAC8AAAB0KhAAcAAAABACAAAYAAAAYXNzZXJ0aW9uIGZhaWxlZDogSzo6ZnJvbV91c2l6ZShkaWN0aW9uYXJ5LmxlbigpKS5pc19zb21lKCkAtzoQAHUAAAA7AAAACQAAALc6EAB1AAAAZgAAACQAAAC3OhAAdQAAAGcAAAAjAAAAtzoQAHUAAABrAAAAJQAAALc6EAB1AAAAeAAAABoAAAC3OhAAdQAAAIsAAAA7AAAAZGljdGlvbmFyeSBrZXkgYmV5b25kIGJvdW5kcyBvZiBkaWN0aW9uYXJ5OiAwLi4A/GMTAC8AAABxAgAACAAAAAQAAAByAgAAcwIAAHQCAAB1AgAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAtzoQAHUAAAChAAAAUgAAAGNhc3Qgc2hvdWxkIGJlIGluZmFsbGlibGUAAAC3OhAAdQAAALwAAAAaAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF0Y2hlcyEoZGF0YV90eXBlLCBBcnJvd1R5cGU6OkRpY3Rpb25hcnkoXywgXykpAAC3OhAAdQAAAIQAAAAJAAAAtzoQAHUAAADOAAAAFgAAAJEQEABsAAAAwwAAACAAAACREBAAbAAAAMkAAAAiAAAAkRAQAGwAAADKAAAAHwAAAJEQEABsAAAAzQAAACkAAACREBAAbAAAAM4AAAAZAAAAkRAQAGwAAADSAAAAEQAAAAAAAAAEAAAABAAAAIUCAABNSUxMSVMAAAAAAAAEAAAABAAAAIYCAABNSUNST1MAAAAAAAAEAAAABAAAAIcCAABOQU5PUwAAAIgCAACoAQAACAAAAIkCAACKAgAAiwIAAIwCAACNAgAAjgIAAI8CAACQAgAAqAEAAAgAAACRAgAAigIAAJICAACTAgAAlAIAAI4CAACPAgAAlQIAAKgBAAAIAAAAlgIAAIoCAACXAgAAmAIAAJkCAACOAgAAjwIAAJoCAACoAQAACAAAAJsCAACKAgAAnAIAAJ0CAACeAgAAjgIAAI8CAACfAgAAqAEAAAgAAACgAgAAigIAAKECAACiAgAAowIAAI4CAACPAgAApAIAAKgBAAAIAAAApQIAAIoCAACmAgAApwIAAKgCAACOAgAAjwIAAKkCAACoAQAACAAAAKoCAACKAgAAqwIAAKwCAACtAgAAjgIAAI8CAACuAgAAqAEAAAgAAACvAgAAigIAALACAACxAgAAsgIAAI4CAACPAgAAswIAAKgBAAAIAAAAtAIAAIoCAAC1AgAAtgIAALcCAACOAgAAjwIAALgCAACoAQAACAAAALkCAACKAgAAugIAALsCAAC8AgAAjgIAAI8CAAC9AgAAqAEAAAgAAAC+AgAAigIAAL8CAADAAgAAwQIAAI4CAACPAgAAwgIAAKgBAAAIAAAAwwIAAIoCAADEAgAAxQIAAMYCAACOAgAAjwIAAMcCAACoAQAACAAAAMgCAACKAgAAyQIAAMoCAADLAgAAjgIAAI8CAADMAgAAqAEAAAgAAADNAgAAigIAAM4CAADPAgAA0AIAAI4CAACPAgAA0QIAAKgBAAAIAAAA0gIAAIoCAADTAgAA1AIAANUCAACOAgAAjwIAANYCAACoAQAACAAAANcCAACKAgAA2AIAANkCAADaAgAAjgIAAI8CAAB1bnN1cHBvcnRlZCBkYXRhIHR5cGUgZm9yIGJ5dGUgYXJyYXkgZGljdGlvbmFyeSByZWFkZXIgLSAAAABUaBMAOQAAAGludmFsaWQgbm9uLWRpY3Rpb25hcnkgZGF0YSB0eXBlIGZvciBieXRlIGFycmF5IGRpY3Rpb25hcnkgcmVhZGVyIC0gmGgTAEQAAACpAgAAqAEAAAgAAADbAgAAmgIAAKgBAAAIAAAA3AIAANECAACoAQAACAAAAN0CAADHAgAAqAEAAAgAAADeAgAAlQIAAKgBAAAIAAAA3wIAAJ8CAACoAQAACAAAAOACAADCAgAAqAEAAAgAAADhAgAAiAIAAKgBAAAIAAAA4gIAAL0CAACoAQAACAAAAOMCAACzAgAAqAEAAAgAAADkAgAAkAIAAKgBAAAIAAAA5QIAAK4CAACoAQAACAAAAOYCAAC4AgAAqAEAAAgAAADnAgAA1gIAAKgBAAAIAAAA6AIAAKQCAACoAQAACAAAAOkCAADMAgAAqAEAAAgAAADqAgAAZGljdGlvbmFyeSB0b28gbGFyZ2UgZm9yIGluZGV4IHR5cGVJbnZhbGlkL1Vuc3VwcG9ydGVkIGVuY29kaW5nIHR5cGUgZm9yIGRpY3Rpb25hcnk6IAAAAAdqEwAyAAAA/wAQAH8AAAAlAQAAIQAAAGRlY29kZXIgc2V0AP8AEAB/AAAAOwEAACUAAAD/ABAAfwAAAEoBAAARAAAA/wAQAH8AAABjAQAAKAAAAP8AEAB/AAAAZgEAABkAAAD/ABAAfwAAAGoBAAAsAAAA/wAQAH8AAABrAQAAKwAAAP8AEAB/AAAAbQEAADwAAAD/ABAAfwAAAFcBAAAeAAAA/wAQAH8AAABYAQAAPgAAAG1pc3NpbmcgZGljdGlvbmFyeSBwYWdlIGZvciBjb2x1bW4AAP8AEAB/AAAAdwEAACUAAAArQxAAfQAAAHcAAAASAAAAK0MQAH0AAACGAAAADQAAACtDEAB9AAAAGAEAABsAAABkYXRhIG11c3QgYmUgYWxyZWFkeSBjYWNoZWQgaW4gdGhlIHJlYWRfcmVjb3JkcyBjYWxsLCB0aGlzIGlzIGEgYnVnACtDEAB9AAAANgEAABIAAAArQxAAfQAAADkBAAAdAAAA6wIAABQAAAAEAAAA7AIAAO0CAADuAgAA7wIAAPACAABjAgAAYwIAAOsCAAAUAAAABAAAAPECAACcAxAAdQAAAEYAAAAOAAAAAAAAAAQAAAAEAAAA8gIAAPMCAAD0AgAA9QIAAPYCAAD3AgAA+AIAAPkCAAD6AgAAcAIAAPsCAAD8AgAA/QIAAP4CAAD/AgAA+AIAAAADAABwAgAAAQMAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IElOVDk2IG11c3QgYmUgYSB0aW1lc3RhbXAuWGwTAEQAAACZCxAAeQAAAMgAAAAWAAAAUAIAACwAAAAEAAAAAgMAAAMDAAAEAwAABQMAAAYDAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAACwCAAAwAAAABAAAABUDAAAWAwAAFwMAABgDAAAZAwAAGgMAAAACAAABAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAsAgAAMAAAAAQAAAAbAwAAHAMAAB0DAAAeAwAAGQMAAB8DAAAAAgAAAQIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAACQIAACADAAALAgAAIQMAABkDAAANAgAAAAIAAAECAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAA4wAAABYAAAAsAgAAMAAAAAQAAAAiAwAAIwMAACQDAAAlAwAAGQMAACYDAAAHAgAACAIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAAJwMAACgDAAApAwAAKgMAABkDAAArAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACwCAAAwAAAABAAAAA4CAAAsAwAAEAIAAC0DAAAZAwAAEgIAAAcCAAAIAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACZCxAAeQAAAOkAAAAWAAAALAIAADAAAAAEAAAALgMAAC8DAAAwAwAAMQMAABkDAAAyAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACwCAAAwAAAABAAAADMDAAA0AwAANQMAADYDAAAZAwAANwMAAAcCAAAIAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAsAgAAMAAAAAQAAAA4AwAAOQMAADoDAAA7AwAAGQMAADwDAAAHAgAACAIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAAPQMAAD4DAAA/AwAAQAMAABkDAABBAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAA+gAAABYAAAAsAgAAMAAAAAQAAABCAwAAQwMAAEQDAABFAwAAGQMAAEYDAAAAAgAAAQIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAARwMAAEgDAABJAwAASgMAABkDAABLAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAQAQejizQALoQOZCxAAeQAAACABAAAWAAAALAIAADAAAAAEAAAATAMAAE0DAABOAwAATwMAABkDAABQAwAAUQMAAFIDAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAMAEAABYAAAAsAgAAMAAAAAQAAABTAwAAVAMAAFUDAABWAwAAGQMAAFcDAAD5AQAA+gEAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmQsQAHkAAAAYAQAAFgAAACwCAAAwAAAABAAAAFgDAABZAwAAWgMAAFsDAAAZAwAAXAMAAFEDAABSAwAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACZCxAAeQAAACgBAAAWAAAALAIAADAAAAAEAAAAXQMAAF4DAABfAwAAYAMAABkDAABhAwAA+QEAAPoBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAA4AQZTmzQAL5x2ZCxAAeQAAAIkBAAAeAAAAQ2Fubm90IGNvbnZlcnQgIHRvIGRlY2ltYWwgZGljdGlvbmFyeQAAACRzEwAPAAAAM3MTABYAAACZCxAAeQAAAJwBAAAeAAAAmQsQAHkAAACiAQAAHgAAAJkLEAB5AAAAtQEAAB4AAACZCxAAeQAAALsBAAAeAAAALAIAADAAAAAEAAAAywEAAGIDAADNAQAAYwMAABkDAADQAQAA0QEAANIBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAzgEAAB4AAACZCxAAeQAAANQBAAAeAAAALAIAADAAAAAEAAAA3gEAAGQDAADgAQAAZQMAABkDAADiAQAA4wEAAOQBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAQQEAABoAAAAgdG8gZGVjaW1hbAAkcxMADwAAAHx0EwALAAAAmQsQAHkAAABVAQAAGgAAAJkLEAB5AAAAWwEAABoAAACZCxAAeQAAAG8BAAAaAAAAmQsQAHkAAAB1AQAAGgAAAGFzc2VydGlvbiBmYWlsZWQ6IGV4aXN0aW5nLmlzX25vbmUoKTZwEAB5AAAAZgAAAAkAAADlZBAAbQAAAIIAAAAjAAAAc2NhbGUgY2Fubm90IGJlIG5lZ2F0aXZlOiAAABx1EwAaAAAAcHJlY2lzaW9uIGNhbm5vdCBiZSBuZWdhdGl2ZTogAABAdRMAHgAAAENhbm5vdCBjcmVhdGUgSU5UMzIgcGh5c2ljYWwgdHlwZSBmcm9tIABodRMAJwAAAFVuYWJsZSB0byBjb252ZXJ0IHBhcnF1ZXQgSU5UMzIgbG9naWNhbCB0eXBlICBvciBjb252ZXJ0ZWQgdHlwZSCYdRMALQAAAMV1EwATAAAAVVRDQ2Fubm90IGNyZWF0ZSBJTlQ2NCBmcm9tIE1JTExJUyB0aW1lIHVuaXRVbmFibGUgdG8gY29udmVydCBwYXJxdWV0IElOVDY0IGxvZ2ljYWwgdHlwZSAAAAAUdhMALQAAAMV1EwATAAAAVW5hYmxlIHRvIGNvbnZlcnQgcGFycXVldCBCWVRFX0FSUkFZIGxvZ2ljYWwgdHlwZSAAAFR2EwAyAAAAxXUTABMAAABGTE9BVDE2IGxvZ2ljYWwgdHlwZSBtdXN0IGJlIEZpeGVkIExlbmd0aCBCeXRlIEFycmF5IHdpdGggbGVuZ3RoIDJiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQAABRsEABkAAAA9QEAADMAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmN1cnJlbnRfdmFsdWUuaXNfc29tZSgpAAAUbBAAZAAAAAQCAAARAAAA1TcQAF8AAABAAQAAHgAAANU3EABfAAAAJQEAACoAAADVNxAAXwAAACYBAAA0AAAA1TcQAF8AAAA2AQAAPgAAAGFzc2VydGlvbiBmYWlsZWQ6IG4gPD0gc2VsZi5idWYuaW5pdCAtIHNlbGYuYnVmLmZpbGxlZAAAhGEQAHMAAAAVAQAACQAAAGZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgDMdxMAGwAAACUAAAAAAAAAAgAAAOh3EwCufhAAaQAAALIBAAAxAAAArn4QAGkAAACyAQAAGQAAAGZhaWxlZCB0byB3cml0ZSB3aG9sZSBidWZmZXIgeBMAHAAAABcAAAACAAAAPHgTAK5+EABpAAAAMQcAACQAAADvJxAAawAAAOMBAAAOAAAA7ycQAGsAAAD4AQAADgAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXkfPiLTS+rALQ+04qby6pveZwMAABgAAAAIAAAAaAMAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA4TUQAGUAAAAqAAAAFQAAAGluY29tcGxldGUgZnJhbWVudW1iZXIgb2YgcmVhZCBieXRlcyBleGNlZWRzIGxpbWl0AAAUeRMAIgAAAK5+EABpAAAA4QsAAAkAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEYBYsQAGoAAACLAgAAEgAAAGcDAAAYAAAACAAAADUAAABnAwAAGAAAAAgAAABoAwAANQAAAKB5EwA2AAAAaQMAAGoDAAA5AAAAawMAAFJlYWNoZWQgRU9GSW52YWxpZCBEYXRhTm8gcm9vbSBpbiBvdXRwdXQuAAAA1TcQAF8AAADQAAAAKgAAANU3EABfAAAA0QAAADQAAADVNxAAXwAAAN4AAAA+AAAAJGYQAF0AAABqAAAAJQAAAGNvcnJ1cHQgZGVmbGF0ZSBzdHJlYW0AAKxIEABYAAAAqQAAABIAAACsSBAAWAAAAPcAAAAnAAAArEgQAFgAAADFAAAAGwAAAAAAAAAkZhAAXQAAAJAAAAAdAAAAJGYQAF0AAACNAAAACQAAAM51EABqAAAAvQEAAB0AAAABAAAAAAAAAHVuc3VwcG9ydGVkIGVuY29kaW5nICBmb3IgYnl0ZSBhcnJhecx6EwAVAAAA4XoTAA8AAAB0DRAAdAAAAK8AAAAcAAAAdA0QAHQAAACwAAAAHAAAAHQNEAB0AAAAuAAAADgAAAB0DRAAdAAAALkAAAAcAAAAdA0QAHQAAADSAAAAIAAAAHQNEAB0AAAA1AAAADQAAAB0DRAAdAAAANQAAAAcAAAAdA0QAHQAAADVAAAAQQAAAHQNEAB0AAAA1gAAAEEAAAB0DRAAdAAAAP4AAAAfAAAAdA0QAHQAAAD/AAAAFQAAAHQNEAB0AAAAAAEAABUAAAB0DRAAdAAAAA4BAAAVAAAAdA0QAHQAAAAPAQAAFQAAAHQNEAB0AAAAEAEAABUAAAB0DRAAdAAAABEBAAAVAAAAdA0QAHQAAAA1AQAAHwAAAHQNEAB0AAAANQEAABMAAAB0DRAAdAAAADsBAAATAAAAdA0QAHQAAAA8AQAAEwAAAHQNEAB0AAAAPwEAABMAAAB0DRAAdAAAAEABAAAVAAAAdA0QAHQAAABbAQAAFgAAAHQNEAB0AAAAYAEAABoAAAB0DRAAdAAAAIgBAAAaAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogc2hvdWxkIGNhbGwgd3JpdGVfZ2F0aGVyIGluc3RlYWQAAJB8EwBKAAAAdA0QAHQAAADNAQAACQAAAHQNEAB0AAAA0QEAAAkAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogY2Fubm90IGRvd25jYXN0ICBkaWN0aW9uYXJ5IHZhbHVlIHRvIGJ5dGUgYXJyYXkAAAAsfRMAOgAAAGZ9EwAfAAAAIHRvIGJ5dGUgYXJyYXkAACx9EwA6AAAAmH0TAA4AAABNdXN0IGZsdXNoIGRhdGEgcGFnZXMgYmVmb3JlIGZsdXNoaW5nIGRpY3Rpb25hcnlEYXRhUGFnZSB2MiBoZWFkZXIgY29udGFpbnMgaW1wbGF1c2libGUgdmFsdWVzIGZvciBkZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aCAoKSBhbmQgcmVwZXRpdGlvbl9sZXZlbHNfYnl0ZV9sZW5ndGggKCkgZ2l2ZW4gRGF0YVBhZ2UgaGVhZGVyIHByb3ZpZGVzIHVuY29tcHJlc3NlZF9wYWdlX3NpemUgKCkAAADofRMAUgAAADp+EwAlAAAAX34TADkAAACYfhMAAQAAAKlDEABtAAAAjQEAACQAAACpQxAAbQAAAI4BAAA8AAAAqUMQAG0AAACOAQAAGgAAAKlDEABtAAAAkAEAADIAAABBY3R1YWwgZGVjb21wcmVzc2VkIHNpemUgZG9lc24ndCBtYXRjaCB0aGUgZXhwZWN0ZWQgb25lICggdnMgAAAA/H4TADkAAAA1fxMABAAAAJh+EwABAAAAbm90IGltcGxlbWVudGVkOiBQYWdlIHR5cGUgIGlzIG5vdCBzdXBwb3J0ZWRUfxMAGwAAAG9/EwARAAAAqUMQAG0AAADOAQAADQAAAE1pc3NpbmcgZGljdGlvbmFyeSBwYWdlIGhlYWRlck1pc3NpbmcgVjEgZGF0YSBwYWdlIGhlYWRlck1pc3NpbmcgVjIgZGF0YSBwYWdlIGhlYWRlckludmFsaWQgcGFnZSBoZWFkZXIAqUMQAG0AAAByAwAAJgAAAEV4cGVjdGVkIHRvIHJlYWQgIGJ5dGVzIG9mIHBhZ2UsIHJlYWQgb25seSAAGIATABEAAAApgBMAGgAAAAAAAAAEAAAABAAAAEoCAABHZW5lcmFsTllJRU9GQXJyb3dFcnJvcgAAAAAABAAAAAQAAABsAwAAAAAAAAQAAAAEAAAAMQAAAEluZGV4T3V0T2ZCb3VuZAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxOZWVkTW9yZURhdGEAAAAABAAAAAQAAAAzAAAATmVlZE1vcmVEYXRhUmFuZ2UAAAAAAAAABAAAAAQAAABtAwAAUGFnZVR5cGW/VhAAZAAAAOoAAAA4AAAAv1YQAGQAAADrAAAAFQAAAOpMEABiAAAA3QEAAC0AAAAUbBAAZAAAAJIAAAAJAAAAdo4QAGUAAAAOAAAAFgAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAADvJxAAawAAAPgBAAAOAAAA1zIQAHgAAADrBwAACQAAAMRKEABqAAAA9gcAAB8AAABvAwAAGAAAAAgAAABwAwAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQBBhITOAAuvIQEAAABxAwAATm9uZVNvbWUAAAAABAAAAAQAAABtAwAAAAAAAAQAAAAEAAAANAAAAFRyeUZyb21TbGljZUVycm9yAAAAxEoQAGoAAABtCAAAHwAAAFJYEABjAAAA2QEAACEAAABSWBAAYwAAANoBAAAmAAAAUlgQAGMAAADbAQAAJgAAAFJYEABjAAAA3AEAACYAAABSWBAAYwAAAN0BAAAmAAAAUlgQAGMAAADeAQAAJgAAAFJYEABjAAAA3wEAACYAAABSWBAAYwAAAO0BAAAiAAAAUlgQAGMAAAAPAgAAEQAAAFJYEABjAAAA/gEAABEAAABSWBAAYwAAAPwBAAARAAAAUlgQAGMAAAD4AQAAEQAAAFJYEABjAAAA8wEAABEAAABSWBAAYwAAABcDAAAJAAAAUlgQAGMAAAAYAwAACQAAAAAAAABSWBAAYwAAAFQBAAAcAAAAUlgQAGMAAAAzAAAAGAAAAIR2EABiAAAAlwAAABEAAACEdhAAYgAAAJgAAAAOAAAAdo4QAGUAAAAbAAAAEgAAAM51EABqAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmRhdGEuaXNfc29tZSgpAAAAHmoQAGAAAADeAAAACQAAAHNldF9kYXRhIHNob3VsZCBoYXZlIGJlZW4gY2FsbGVkHmoQAGAAAADtAAAADgAAAB5qEABgAAAAzQMAABIAAABOb3QgZW5vdWdoIGJ5dGVzIHRvIHNraXCnDxAAdQAAAC4AAAAZAAAApw8QAHUAAABRAAAAHgAAAEV4cGVjdGVkIHRvIHdyaXRlICB2YWx1ZXMsIGJ1dCBoYXZlIG9ubHkgAAAAXIQTABIAAABuhBMAFwAAAE11c3QgZmx1c2ggZGF0YSBwYWdlcyBiZWZvcmUgZmx1c2hpbmcgZGljdGlvbmFyeaM9EABsAAAAawEAAEEAAAAAgAAAoz0QAGwAAABtAQAATQAAAAh8EABoAAAAYwUAACsAAAAIfBAAaAAAAGMFAAAzAAAADAAAADEwEABmAAAA1gAAABkAAAAxMBAAZgAAANwAAAAZAAAAU3RhdGlzdGljcyBudWxsIGNvdW50IGlzIG5lZ2F0aXZlIAAAMIUTACIAAABJbnN1ZmZpY2llbnQgYnl0ZXMgdG8gcGFyc2UgbWluIHN0YXRpc3RpY0luc3VmZmljaWVudCBieXRlcyB0byBwYXJzZSBtYXggc3RhdGlzdGljAAAxMBAAZgAAAL8AAAAoAAAAMTAQAGYAAADAAAAAKAAAADEwEABmAAAAxgAAADsAAAAxMBAAZgAAAMcAAAA7AAAAMTAQAGYAAADNAAAAOwAAADEwEABmAAAAzgAAADsAAAAxMBAAZgAAAOQAAAA7AAAAMTAQAGYAAADlAAAAOwAAADEwEABmAAAA6wAAADsAAAAxMBAAZgAAAOwAAAA7AAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAHIDAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZW5vdCBpbXBsZW1lbnRlZB5qEABgAAAAbQIAAAEAAAAeahAAYAAAAG4CAAABAAAAHmoQAGAAAABvAgAAAQAAAGVycm9yIGNvbnZlcnRpbmcgdmFsdWUsIGV4cGVjdGVkICBieXRlcyBnb3QgLIcTACEAAABNhxMACwAAAL9WEABkAAAA6gAAADgAAAC/VhAAZAAAAOsAAAAVAAAAv1YQAGQAAAD4AAAAFQAAAL9WEABkAAAAJwEAABIAAAC/VhAAZAAAADkBAAAVAAAAaW52YWxpZCBrZXk9IGZvciBkaWN0aW9uYXJ5ALiHEwAMAAAAxIcTAA8AAAATDBAAfgAAAKsBAAAgAAAAEwwQAH4AAACuAQAAMQAAABMMEAB+AAAArwEAACQAAAAsPRAAdgAAADAAAAAWAAAALD0QAHYAAAA+AAAAFgAAACw9EAB2AAAAgwAAABoAAAAsPRAAdgAAAIQAAAAQAAAALD0QAHYAAACQAAAAFgAAACw9EAB2AAAAmwAAABYAAABzAwAAKAAAAAgAAAB0AwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAHoDAAB7AwAAfAMAAH0DAAB+AwAAfwMAAHAAAAAIAAAAgAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAACGAwAAhwMAAIgDAACJAwAAigMAAENhbm5vdCBpbml0aWFsaXplIHRoaXMgZW5jb2RpbmcgdGhyb3VnaCB0aGlzIGZ1bmN0aW9uAAAAiwMAAAwAAAAEAAAAjAMAAI0DAACOAwAAjwMAAJADAABFbmNvZGluZyAgaXMgbm90IHN1cHBvcnRlZAAATIkTAAkAAABViRMAEQAAAHMDAAAoAAAACAAAAJEDAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAkgMAAHsDAAB8AwAAfQMAAJMDAACUAwAAYAAAAAgAAACVAwAAlgMAAJcDAACYAwAAmQMAAH8DAABwAAAACAAAAJoDAACBAwAAggMAAIMDAACEAwAAhQMAAOAAAAAIAAAAmwMAAIcDAACIAwAAiQMAAIoDAACLAwAADAAAAAQAAACcAwAAjQMAAI4DAACPAwAAnQMAAHMDAAAoAAAACAAAAJ4DAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAnwMAAHsDAAB8AwAAfQMAAJMDAAB/AwAAcAAAAAgAAACgAwAAgQMAAIIDAACDAwAAhAMAAIUDAADgAAAACAAAAKEDAACHAwAAiAMAAIkDAACKAwAAiwMAAAwAAAAEAAAAogMAAI0DAACOAwAAjwMAAKMDAABzAwAAKAAAAAgAAACkAwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAKUDAAB7AwAAfAMAAH0DAACTAwAAfwMAAHAAAAAIAAAApgMAAIEDAACCAwAAgwMAAKcDAACFAwAA4AAAAAgAAACoAwAAhwMAAIgDAACJAwAAqQMAAIsDAAAMAAAABAAAAKoDAACNAwAAjgMAAI8DAACrAwAAcwMAACgAAAAIAAAArAMAAHUDAAB2AwAAdwMAAHgDAAB5AwAAeAAAAAgAAAClAwAAewMAAHwDAAB9AwAAkwMAAH8DAABwAAAACAAAAK0DAACBAwAAggMAAIMDAACnAwAAhQMAAOAAAAAIAAAArgMAAIcDAACIAwAAiQMAAKkDAACvAwAAEAAAAAQAAACwAwAAjQMAALEDAACyAwAAswMAAHMDAAAoAAAACAAAAJEDAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAkgMAAHsDAAB8AwAAfQMAAJMDAAB/AwAAcAAAAAgAAACaAwAAgQMAAIIDAACDAwAAhAMAAIUDAADgAAAACAAAAJsDAACHAwAAiAMAAIkDAACKAwAAiwMAAAwAAAAEAAAAnAMAAI0DAACOAwAAjwMAAJ0DAABzAwAAKAAAAAgAAAC0AwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAJ8DAAB7AwAAfAMAAH0DAACTAwAAfwMAAHAAAAAIAAAAoAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAAChAwAAhwMAAIgDAACJAwAAigMAAIsDAAAMAAAABAAAALUDAACNAwAAjgMAAI8DAAC2AwAAcwMAACgAAAAIAAAAngMAAHUDAAB2AwAAdwMAAHgDAAB5AwAAeAAAAAgAAACfAwAAewMAAHwDAAB9AwAAkwMAAJQDAABgAAAACAAAALcDAACWAwAAlwMAAJgDAAC4AwAAfwMAAHAAAAAIAAAAoAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAAChAwAAhwMAAIgDAACJAwAAigMAAIsDAAAMAAAABAAAAKIDAACNAwAAjgMAAI8DAACjAwAA7oEQAG0AAACiAAAADgAAAFJsZVZhbHVlRW5jb2RlciBvbmx5IHN1cHBvcnRzIEJvb2xUeXBlAAAojhMAJgAAAO6BEABtAAAA1AAAAAkAAADugRAAbQAAANcAAAAeAAAA7oEQAG0AAADZAAAAFAAAAFJMRSB2YWx1ZSBlbmNvZGVyIGlzIG5vdCBpbml0aWFsaXplZO6BEABtAAAA+gAAAA4AAABzaG91bGQgaGF2ZSBoYWQgcGFkZGluZyBpbnNlcnRlZLyOEwAgAAAA7oEQAG0AAAD+AAAACQAAAO6BEABtAAAA9gAAAAkAAADugRAAbQAAAFsBAAAVAAAARXhwZWN0ZWQgMCB2YWx1ZXMgaW4gYmxvY2ssIGZvdW5kIAAAFI8TACIAAADugRAAbQAAAK0BAAAJAAAA7oEQAG0AAAChAQAAMgAAAO6BEABtAAAAlwEAADwAAADugRAAbQAAAHwBAAA4AAAA7oEQAG0AAADMAQAAGAAAAO6BEABtAAAA6gEAABAAAADugRAAbQAAAOsBAAAQAAAARGVsdGFCaXRQYWNrRGVjb2RlciBvbmx5IHN1cHBvcnRzIEludDMyVHlwZSBhbmQgSW50NjRUeXBlAAAAsI8TADkAAADugRAAbQAAABACAAAJAAAA7oEQAG0AAABlAgAAFwAAAERlbHRhTGVuZ3RoQnl0ZUFycmF5RW5jb2RlciBvbmx5IHN1cHBvcnRzIEJ5dGVBcnJheVR5cGUAFJATADcAAADugRAAbQAAAFYCAAAJAAAA7oEQAG0AAABeAgAAQQAAAO6BEABtAAAAfwIAABUAAADugRAAbQAAAHgCAAAJAAAA7oEQAG0AAACBAgAAGQAAAO6BEABtAAAAxgIAABwAAADugRAAbQAAAMcCAAAWAAAA7oEQAG0AAADKAgAAGwAAAERlbHRhQnl0ZUFycmF5RW5jb2RlciBvbmx5IHN1cHBvcnRzIEJ5dGVBcnJheVR5cGUgYW5kIEZpeGVkTGVuQnl0ZUFycmF5VHlwZQDUkBMASwAAAO6BEABtAAAAuAIAABYAAADugRAAbQAAAOcCAAAdAAAA7oEQAG0AAADqAgAAHQAAAO6BEABtAAAA7wIAABIAAAAUbBAAZAAAAJIAAAAJAAAAYml0X3JlYWRlciBzaG91bGQgYmUgc2V0FGwQAGQAAAD1AQAAMwAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuY3VycmVudF92YWx1ZS5pc19zb21lKCkAABRsEABkAAAABAIAABEAAAAqAAAAOgAAAEoAAABKAAAAOgAAAEoAAABSAAAAUgAAACsAAAA7AAAASwAAAEsAAAA7AAAASwAAAFMAAABTAAAACAAAAAgAAAAoAAAACAAAAAgAAAAoAAAACAAAAAgAAAAQAAAAEAAAADAAAAAQAAAAEAAAADAAAAAQAAAAEAAAABgAAAAYAAAAOAAAABgAAAAYAAAAOAAAABgAAAAYAAAAIAAAACAAAABAAAAAIAAAACAAAABAAAAAIAAAACAAAAC8AwAAAAAAAP//////////qJITAEHApc4AC69K1zIQAHgAAADrBwAACQAAAFN0b3BWb2lkQm9vbEkwOERvdWJsZUkxNkkzMkk2NFN0cmluZ1V0ZjdTdHJ1Y3RNYXBTZXRMaXN0VXRmOFV0ZjE2AAAAxEoQAGoAAABtCAAAHwAAAGNhbm5vdCBwYXJzZSBwYXN0IAAAJJMTABIAAABub24temVybyBzaXplZCBtYXAgc2hvdWxkIGNvbnRhaW4ga2V5IHR5cGUAACeBEABiAAAA8AAAABoAAABub24temVybyBzaXplZCBtYXAgc2hvdWxkIGNvbnRhaW4gdmFsdWUgdHlwZSeBEABiAAAA8wAAABoAAABjYW5ub3Qgc2tpcCBmaWVsZCB0eXBlIAC4kxMAFwAAAM51EABqAAAAvQEAAB0AAAAeahAAYAAAABcDAAA6AAAAc2V0X2RhdGEgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQeahAAYAAAAK4DAAASAAAAHmoQAGAAAAC9AwAANQAAAB5qEABgAAAAvgMAADUAAAAeahAAYAAAAL8DAAA1AAAATm90IGVub3VnaCBieXRlcyB0byBkZWNvZGUAAKh3EABgAAAAGgEAABgAAACodxAAYAAAAIQBAAAlAAAASW52YWxpZC9VbnN1cHBvcnRlZCBlbmNvZGluZyB0eXBlIGZvciBkaWN0aW9uYXJ5OiAAAJSUEwAyAAAAvQMAAEAAAAAIAAAAvgMAAL8DAADAAwAAwQMAAMIDAADDAwAAxAMAAFgAAAAIAAAAxQMAAMYDAADHAwAAyAMAAMkDAADKAwAAQ29sdW1uIGNhbm5vdCBoYXZlIG1vcmUgdGhhbiBvbmUgZGljdGlvbmFyeQC9AwAAQAAAAAgAAADLAwAAzAMAAM0DAADBAwAAwgMAAM4DAADPAwAAWAAAAAgAAADFAwAA0AMAANEDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA0gMAANMDAADBAwAAwgMAANQDAADVAwAAWAAAAAgAAADFAwAA1gMAANcDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA2AMAANkDAADBAwAAwgMAANoDAADbAwAAWAAAAAgAAADFAwAA3AMAAN0DAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA3gMAAN8DAADBAwAAwgMAAOADAADhAwAAWAAAAAgAAADFAwAA4gMAAOMDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA5AMAAOUDAADBAwAAwgMAAOYDAADnAwAAWAAAAAgAAADFAwAA6AMAAOkDAADIAwAAyQMAAMoDAABEZWNvZGVyIGZvciBkaWN0IHNob3VsZCBoYXZlIGJlZW4gc2V0AAAAlD4QAGwAAADPAAAAEgAAAGN1cnJlbnRfZW5jb2Rpbmcgc2hvdWxkIGJlIHNldAAAlD4QAGwAAADjAAAADgAAAJQ+EABsAAAA7AAAAA0AAACUPhAAbAAAAO0AAAAwAAAAZGVjb2RlciBmb3IgZW5jb2RpbmcgIHNob3VsZCBiZSBzZXQANJcTABUAAABJlxMADgAAAJQ+EABsAAAA6AAAACAAAACUPhAAbAAAAPUAAAAOAAAAlD4QAGwAAAD6AAAAIAAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGludmFsaWQgbGV2ZWwgZW5jb2Rpbmc6IAAAmJcTAEIAAACUPhAAbAAAABEBAAASAAAAlD4QAGwAAABBAQAADQAAAJQ+EABsAAAAQgEAADEAAACUPhAAbAAAAEIBAABHAAAAlD4QAGwAAABSAQAAEQAAAJQ+EABsAAAAewEAACoAAACUPhAAbAAAALoBAAAdAAAAlD4QAGwAAAC5AQAAEQAAAHBhcnF1ZXQtcnMgdmVyc2lvbiA1Ni4yLjBDYW5ub3QgaGF2ZSBhIDAgbWF4IHJvdyBncm91cCBzaXplAH2YEwAiAAAApi0QAGYAAABCAgAACQAAAERpY3Rpb25hcnkgZW5jb2RpbmcgY2FuIG5vdCBiZSB1c2VkIGFzIGZhbGxiYWNrIGVuY29kaW5nuJgTADgAAACmLRAAZgAAADsEAAANAAAAGx8QAF0AAABGAAAAIgAAAG5vdCBpbXBsZW1lbnRlZAAbHxAAXQAAAIQAAAAiAAAAc2hvdWxkIGhhdmUgcHJldmlvdXMgZmllbGQgaWRzAAAbHxAAXQAAAI0AAAAOAAAAY2Fubm90IGFkZCAgdG8gAGiZEwALAAAAc5kTAAQAAABjYW5ub3QgY29udmVydCAgaW50byBib29sAAAAiJkTAA8AAACXmRMACgAAABsfEABdAAAA5QAAAB0AAAAbHxAAXQAAAPoAAAAeAAAAGx8QAF0AAAAgAQAAHQAAACBpbnRvIFRUeXBlAIiZEwAPAAAA5JkTAAsAAABVbmV4cGVjdGVkIEVPRgAAHmoQAGAAAACMAwAABQAAAE5vdCBlbm91Z2ggYnl0ZXMgdG8gc2tpcB5qEABgAAAAjQMAAAUAAAAeahAAYAAAAI4DAAAFAAAAHmoQAGAAAACPAwAABQAAAAIAAABlcnJvciBjb252ZXJ0aW5nIHZhbHVlLCBleHBlY3RlZCAgYnl0ZXMgZ290IGyaEwAhAAAAjZoTAAsAAAAEAAAAAQAAAAgAAABhc3NlcnRpb24gZmFpbGVkOiBzaXplIDw9IHNyYy5sZW4oKQC/VhAAZAAAAI4AAAAFAAAAv1YQAGQAAACQAAAAFAAAAL9WEABkAAAAwAAAABUAAAC/VhAAZAAAABcBAAAUAAAAYXNzZXJ0aW9uIGZhaWxlZDogbnVtX2JpdHMgPD0gNjS/VhAAZAAAAJoBAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogbnVtX2JpdHMgPD0gc2l6ZV9vZjo6PFQ+KCkgKiA4v1YQAGQAAACbAQAACQAAAL9WEABkAAAAxgEAAAkAAAC/VhAAZAAAAMwBAAAeAAAAAAAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9iaXRzIDw9IFQ6OkJJVF9DQVBBQ0lUWQAAAL9WEABkAAAA3AEAAAkAAAC/VhAAZAAAAOgBAAAuAAAAv1YQAGQAAADpAQAAKQAAAL9WEABkAAAA9gEAAC4AAAC/VhAAZAAAAPcBAAAqAAAAv1YQAGQAAAAEAgAALgAAAL9WEABkAAAABQIAACoAAAC/VhAAZAAAAB4CAAAiAAAAv1YQAGQAAAAsAgAAIgAAAL9WEABkAAAAOgIAACEAAABleHBlY3RlZCB0byBoYXZlIG1vcmUgZGF0YQAAv1YQAGQAAABKAgAAEgAAAL9WEABkAAAASwIAAA0AAAC/VhAAZAAAAEECAAARAAAAv1YQAGQAAAAzAgAAEQAAAL9WEABkAAAAJQIAABEAAAC/VhAAZAAAABICAAAuAAAAv1YQAGQAAAATAgAAKgAAAL9WEABkAAAA1gEAABYAAAC/VhAAZAAAANQBAAARAAAAv1YQAGQAAABWAgAACQAAAL9WEABkAAAAXAIAABUAAAC/VhAAZAAAAHICAAAfAAAAv1YQAGQAAAB0AgAADQAAAL9WEABkAAAAiwIAADwAAAAKAAAATnVtIG9mIGJ5dGVzIGV4Y2VlZCBNQVhfVkxRX0JZVEVfTEVOICgpAHydEwAmAAAAop0TAAEAAAC/VhAAZAAAAJsCAAANAAAAv1YQAGQAAAC/AgAAPgAAAAldEABkAAAAXAAAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBpbnB1dC5sZW4oKSA+PSBOVU1fQklUUyAqIDEAAAAJXRAAZAAAAF0AAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5wdXQubGVuKCkgPj0gTlVNX0JJVFMgKiAyRW5jb2RpbmcgIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIHR5cGVRnhMACQAAAFqeEwAaAAAAQ2Fubm90IGluaXRpYWxpemUgdGhpcyBlbmNvZGluZyB0aHJvdWdoIHRoaXMgZnVuY3Rpb24gaXMgbm90IHN1cHBvcnRlZAAAUZ4TAAkAAAC5nhMAEQAAAOoDAABIAAAACAAAAOsDAADsAwAA7QMAAO4DAADvAwAA8AMAAPEDAABgAAAACAAAAPIDAADzAwAA9AMAAPUDAAD2AwAA9wMAAPgDAAAYAAAABAAAAPkDAAD6AwAA+wMAAPwDAAD9AwAA/gMAAP8DAABwAAAACAAAAAAEAAABBAAAAgQAAAMEAAD2AwAABAQAAPgDAAAYAAAABAAAAPkDAAAFBAAABgQAAPwDAAD9AwAA/gMAAPgDAAAYAAAABAAAAPkDAAD6AwAABwQAAPwDAAD9AwAA/gMAAPgDAAAYAAAABAAAAPkDAAAFBAAACAQAAPwDAAD9AwAA/gMAAE5gEABpAAAArAIAAAwAAAAndmFsdWVzX3Blcl9taW5pX2Jsb2NrJyBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgMzIgZ290IAAAAOifEwA1AAAAJ2Jsb2NrX3NpemUnIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAnbWluaV9ibG9ja3NfcGVyX2Jsb2NrJyBnb3QgIGFuZCAooBMAPwAAAGegEwAFAAAAJ2Jsb2NrX3NpemUnIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAxMjgsIGdvdCB8oBMALAAAAE5vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ2Jsb2NrX3NpemUnaW52YWxpZCAnYmxvY2tfc2l6ZSdOb3QgZW5vdWdoIGRhdGEgdG8gZGVjb2RlICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snaW52YWxpZCAnbWluaV9ibG9ja3NfcGVyX2Jsb2NrJ05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ3ZhbHVlc19sZWZ0J2ludmFsaWQgJ3ZhbHVlc19sZWZ0J05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ2ZpcnN0X3ZhbHVlJ2ZpcnN0IHZhbHVlIHRvbyBsYXJnZVVuc3VwcG9ydGVkIGVuY29kaW5nIHR5cGUgsqETABoAAAAMKhAAZwAAACQAAAAOAAAADCoQAGcAAAA6AAAAGgAAAAwqEABnAAAAPwAAABgAAAAMKhAAZwAAAFEAAAAWAAAAYml0X3JlYWRlciBzaG91bGQgYmUgc2V0FGwQAGQAAAD1AQAAMwAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuY3VycmVudF92YWx1ZS5pc19zb21lKCkAABRsEABkAAAABAIAABEAAAABAgQIECBAgAQAAAAEAAAABAAAAAMAAAAGAAAAAwAAAAMAAAADAAAABgAAAAQAAAAGAAAAAwAAAAMAAAAEAAAABAAAAAUAAADQkhMA1JITANiSEwDckhMA35ITAOWSEwDokhMA65ITAO6SEwD0khMA+JITAP6SEwABkxMABJMTAAiTEwAMkxMAUlgQAGMAAAAxAwAAEwAAAOciEABmAAAA4wAAABcAAABzaG91bGQgaGF2ZSBwcmV2aW91cyBmaWVsZCBpZHMAAOciEABmAAAAngAAAA4AAADnIhAAZgAAAJUAAAAiAAAAY2Fubm90IGNvbnZlcnQgIGludG8gYm9vbAAAAGSjEwAPAAAAc6MTAAoAAABib29sIGZpZWxkIHNob3VsZCBoYXZlIGEgZmllbGQgaWQAAADnIhAAZgAAAOoBAAArAAAA5yIQAGYAAADEAQAADgAAAHNob3VsZCBub3QgaGF2ZSBhIHBlbmRpbmcgYm9vbCB3aGlsZSB3cml0aW5nIGFub3RoZXIgYm9vbCB3aXRoIGlkOiAA1KMTAEMAAADnIhAAZgAAAMwBAAAVAAAAbm9uLXN0b3AgZmllbGQgc2hvdWxkIGhhdmUgZmllbGQgaWQA5yIQAGYAAADXAQAALgAAAOciEABmAAAAugEAACMAAAB7eRAAcAAAABADAAArAAAAe3kQAHAAAAAUAwAAEgAAAHt5EABwAAAAFgMAABIAAAB7eRAAcAAAABoDAAAlAAAAe3kQAHAAAAAhAwAAJQAAAHt5EABwAAAAKwMAACkAAAB7eRAAcAAAADEDAAAeAAAAe3kQAHAAAABFAwAALQAAAHt5EABwAAAATgMAACYAAAAAAQIDAAAAAAAAAQEBAQEBe3kQAHAAAADuAgAAEgAAAAAAAAD/Af4C/QP/Af4C/QN7eRAAcAAAAPkCAAAUAAAAe3kQAHAAAAD6AgAAGAAAAHt5EABwAAAAAAMAADMAAAB7eRAAcAAAAAADAABFAAAAe3kQAHAAAABfAwAAJQAAAHt5EABwAAAAYQMAACEAAAB7eRAAcAAAAGMDAAAJAAAAe3kQAHAAAABuAQAALAAAAHt5EABwAAAAbwEAACUAAAB7eRAAcAAAAHIBAAAmAAAAe3kQAHAAAAB4AQAAIAAAAHt5EABwAAAAegEAABoAAAB7eRAAcAAAAIUBAAAkAAAAe3kQAHAAAACHAQAAGQAAAHt5EABwAAAAkQEAABcAAAB7eRAAcAAAAJUBAAAgAAAAe3kQAHAAAACcAQAAMwAAAHt5EABwAAAApgEAACcAAAB7eRAAcAAAAKYBAAA/AAAAe3kQAHAAAADTAQAACQAAAHt5EABwAAAAqwEAACQAAAB7eRAAcAAAALIBAAAaAAAAe3kQAHAAAADAAQAAKAAAAHt5EABwAAAAOQEAACUAAAB7eRAAcAAAADwBAAAJAAAAe3kQAHAAAABNAQAALwAAAHt5EABwAAAATwEAADYAAABVTklOVElBTElaRUR7eRAAcAAAAJkIAAAJAAAAe3kQAHAAAAC0CAAACQAAAHt5EABwAAAAnwgAAAkAAAAvAxAAbAAAABICAAATAAAAe3kQAHAAAAAnBgAAIAAAAHt5EABwAAAAKAYAABoAAAB7eRAAcAAAACkGAAAaAAAAe3kQAHAAAAAqBgAAGgAAAHt5EABwAAAAKwYAACAAAAB7eRAAcAAAACwGAAAaAAAAe3kQAHAAAAAtBgAAGgAAAHt5EABwAAAALgYAABoAAAB7eRAAcAAAADAGAAAgAAAAe3kQAHAAAAAxBgAAGgAAAHt5EABwAAAAMgYAABoAAAB7eRAAcAAAADMGAAAaAAAAe3kQAHAAAAA1BgAAIAAAAHt5EABwAAAANgYAABoAAAB7eRAAcAAAADcGAAAaAAAAe3kQAHAAAAA4BgAAGgAAAHt5EABwAAAARgYAACYAAAB7eRAAcAAAAEkGAAAmAAAAe3kQAHAAAABMBgAAJgAAAHt5EABwAAAATwYAACYAAAB7eRAAcAAAAFYGAAAJAAAAe3kQAHAAAABXBgAACQAAAHt5EABwAAAAWAYAAAkAAAB7eRAAcAAAAFkGAAAJAAAAe3kQAHAAAADwBQAAHwAAAHt5EABwAAAA8QUAABoAAAB7eRAAcAAAAPIFAAAaAAAAe3kQAHAAAADzBQAAGgAAAHt5EABwAAAA9AUAABoAAAB7eRAAcAAAAPUFAAAaAAAAe3kQAHAAAAD2BQAAGgAAAHt5EABwAAAA9wUAABoAAAB7eRAAcAAAAPkFAAAfAAAAe3kQAHAAAAD5BQAANgAAAHt5EABwAAAABwYAACYAAAB7eRAAcAAAAAoGAAAmAAAAe3kQAHAAAAANBgAAJgAAAHt5EABwAAAAEAYAACYAAAB7eRAAcAAAABcGAAAJAAAAe3kQAHAAAAAYBgAACQAAAHt5EABwAAAAGQYAAAkAAAB7eRAAcAAAABoGAAAJAAAAe3kQAHAAAACZBgAAHQAAAHt5EABwAAAAvwYAACAAAAB7eRAAcAAAAMQGAAAOAAAAe3kQAHAAAADGBgAADgAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1Y2tldC5sZW4oKSA+IHNlbGYuc3BlY2lhbGl6YXRpb24uYmxvY2tfbWFzaygpIGFzIHVzaXplAAB7eRAAcAAAAMgGAAAJAAAAe3kQAHAAAADRBgAAIwAAAHt5EABwAAAA1gYAABgAAAB7eRAAcAAAANYGAAAuAAAAe3kQAHAAAADgBgAAJgAAAHt5EABwAAAA8AYAAAkAAAB7eRAAcAAAAJsGAAAjAAAAe3kQAHAAAACjBgAAFAAAAHt5EABwAAAAowYAACoAAAB7eRAAcAAAAKcGAAAiAAAAe3kQAHAAAABcBgAAJQAAAHt5EABwAAAAXwYAAA4AAAB7eRAAcAAAAGIGAAAJAAAAe3kQAHAAAABkBgAAHQAAAHt5EABwAAAAzgUAACUAAAB7eRAAcAAAAMkFAAAvAAAAe3kQAHAAAADKBQAAEQAAAO8nEABrAAAA4wEAAA4AAADvJxAAawAAAPgBAAAOAAAAbWlkID4gbGVuAAAAjKsTAAkAAABTdG9wVm9pZEJvb2xJMDhEb3VibGVJMTZJMzJJNjRTdHJpbmdVdGY3U3RydWN0TWFwU2V0TGlzdFV0ZjhVdGYxNgAAAMRKEABqAAAAbQgAAB8AAABudBAAZAAAANYCAAAVAAAAbnQQAGQAAADXAgAAHQAAAG50EABkAAAA0QIAABEAAABudBAAZAAAAJ4BAAAuAAAAbnQQAGQAAACiAQAALgAAAG50EABkAAAAqAEAADEAAABudBAAZAAAAKwBAAAxAAAAbnQQAGQAAADAAQAACQAAAG50EABkAAAA5gAAAA0AAABudBAAZAAAADYAAAAOAAAAbnQQAGQAAABgAAAAGgAAABYhEABkAAAAIwAAAB8AAAAWIRAAZAAAACMAAAALAAAAFiEQAGQAAAAuAAAAHwAAABYhEABkAAAALgAAAAsAAAAzHhAAagAAAL4CAAAJAAAAMx4QAGoAAAD6AwAAHwAAADMeEABqAAAArwMAAC8AAAAzHhAAagAAAOQDAAAjAAAAMx4QAGoAAADHAwAAIwAAADMeEABqAAAA0QIAAB8AAAAzHhAAagAAAOYCAAA4AAAAMx4QAGoAAADoAgAAMgAAADMeEABqAAAA6AIAAEoAAAAzHhAAagAAAO4CAAA+AAAAMx4QAGoAAADwAgAASgAAADMeEABqAAAA6wIAACEAAAAzHhAAagAAAAEDAAAjAAAAMx4QAGoAAAACAwAAIwAAADMeEABqAAAALQMAACMAAAAzHhAAagAAADYDAAAdAAAAMx4QAGoAAAA3AwAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlwX2luZGV4ID49IDMAMx4QAGoAAABZAwAAFQAAADMeEABqAAAAWgMAAE4AAAAzHhAAagAAAF0DAAAVAAAAMx4QAGoAAABgAwAAFQAAADMeEABqAAAAYwMAABUAAAAzHhAAagAAAGUDAAA2AAAAMx4QAGoAAABoAwAARQAAADMeEABqAAAAawMAACcAAAAzHhAAagAAAGwDAAAnAAAAMx4QAGoAAACKAwAAGQAAADMeEABqAAAAiwMAAFIAAAAzHhAAagAAAI4DAAAZAAAAMx4QAGoAAACRAwAAGQAAADMeEABqAAAAlAMAABkAAAAzHhAAagAAAJYDAAA6AAAAMx4QAGoAAACeAwAAJwAAADMeEABqAAAAuAIAACUAAAAzHhAAagAAAE8AAAArAAAAMx4QAGoAAAB7AAAADgAAADMeEABqAAAAdgAAAD0AAAAzHhAAagAAADgAAAAnAAAAE3EQAIAAAAC+AQAAJAAAABNxEACAAAAAwAEAABcAAAATcRAAgAAAANoBAAAWAAAAE3EQAIAAAADbAQAAFgAAABNxEACAAAAA4QEAACMAAAATcRAAgAAAAO0BAAAMAAAAE3EQAIAAAADtAQAANAAAABNxEACAAAAA9wEAABEAAAATcRAAgAAAAPoBAAAXAAAAE3EQAIAAAADwAQAAEQAAABNxEACAAAAA8wEAABcAAAATcRAAgAAAAOcBAAAlAAAAE3EQAIAAAADnAQAAEQAAABNxEACAAAAA6AEAACYAAAATcRAAgAAAAOgBAAARAAAAE3EQAIAAAADQAQAAEQAAABNxEACAAAAA0QEAABEAAAB7eRAAcAAAAAEBAAAjAAAAe3kQAHAAAAABAQAAMQAAAHt5EABwAAAACwEAABEAAAB7eRAAcAAAAAwBAAARAAAAe3kQAHAAAAANAQAAEQAAAHt5EABwAAAADgEAABEAAAB7eRAAcAAAALAJAAAlAAAAe3kQAHAAAACwCQAAFQAAAHt5EABwAAAAuAkAAEoAAAB7eRAAcAAAAJsHAAAfAAAAd29ya2luZyB3aXRoIHVuaW5pdGlhbGl6ZWQgaGFzaCBtYXAAe3kQAHAAAAD/CQAAJQAAAHt5EABwAAAAhQQAAA0AAAB7eRAAcAAAAIYEAAANAAAAe3kQAHAAAACQBAAAJgAAAHt5EABwAAAAkQQAACIAAAB7eRAAcAAAAJIEAAAiAAAAe3kQAHAAAACTBAAAIgAAAHt5EABwAAAAlAQAACIAAAB7eRAAcAAAAJUEAAAiAAAAe3kQAHAAAACWBAAAIgAAAHt5EABwAAAAowQAAC4AAAB7eRAAcAAAAKYEAAAuAAAAe3kQAHAAAACpBAAALgAAAHt5EABwAAAArAQAAC4AAAB7eRAAcAAAALcEAAARAAAAe3kQAHAAAAC4BAAAEQAAAHt5EABwAAAAuQQAABEAAAB7eRAAcAAAALoEAAARAAAAAAABAAEAAQACAAQACAAQABAAIABAAIAAgAAAAoAGgAYvAxAAbAAAAHEBAAARAAAAIAAgAIAAAEAABAAEACAwAAAgABAAQAABAEAAQABAAEAvAxAAbAAAAHUBAAARAAAA3yYQAHMAAABZAgAAGAAAAN8mEABzAAAAXQIAAA0AAADfJhAAcwAAAGoCAAAkAAAA3yYQAHMAAAA0AgAAHQAAAN8mEABzAAAANwIAACEAAADfJhAAcwAAACQCAAAjAAAA3yYQAHMAAACpAgAAIwAAAG6JEABgAAAAMwAAADsAAABuiRAAYAAAADQAAAA7AAAAbokQAGAAAAA9AAAAHwAAAG6JEABgAAAAPwAAAB8AAABjYW5ub3QgcGFyc2UgcGFzdCAAAGizEwASAAAAbm9uLXplcm8gc2l6ZWQgbWFwIHNob3VsZCBjb250YWluIGtleSB0eXBlAAAngRAAYgAAAPAAAAAaAAAAbm9uLXplcm8gc2l6ZWQgbWFwIHNob3VsZCBjb250YWluIHZhbHVlIHR5cGUngRAAYgAAAPMAAAAaAAAAY2Fubm90IHNraXAgZmllbGQgdHlwZSAA/LMTABcAAABwZW5kaW5nIGJvb2wgZmllbGQgIG5vdCB3cml0dGVuABy0EwATAAAAL7QTAAwAAADnIhAAZgAAAKEBAAANAAAA1xQQAGAAAACBBgAADgAAAHsTtkeRTZdEW60kiJ0ot6LHlVRwS0LxLUdJ/J4x+2tcRmFsc2UgcG9zaXRpdmUgcHJvYmFiaWxpdHkgbXVzdCBiZSBiZXR3ZWVuIDAuMCBhbmQgMS4wLCBnb3QgjLQTADwAAAAAAAAAxHoQAGcAAAD5AAAAFgAAAMR6EABnAAAA9wAAAAkAAADEehAAZwAAAIIBAAAPAAAAqDwQAIMAAAAzAAAAIwAAAKg8EACDAAAAMwAAAA0AAACoPBAAgwAAADsAAAASAAAAqDwQAIMAAABAAAAALgAAAKg8EACDAAAAQAAAABEAAACoPBAAgwAAAEkAAAAOAAAAqDwQAIMAAABcAAAAGwAAAGJ5dGUgc3RyZWFtIHNwbGl0IHVuc3VwcG9ydGVkIGZvciBkYXRhIHR5cGVzIG9mIHNpemUgIGJ5dGVzAHS1EwA1AAAAqbUTAAYAAACoPBAAgwAAAI4AAAAMAAAABAAAAE1pc21hdGNoZWQgRml4ZWRMZW5CeXRlQXJyYXkgc2l6ZXM6ICAhPSDUtRMAJAAAAPi1EwAEAAAAqDwQAIMAAACIAAAADQAAAAcAAAACAAAACAAAAAMAAAAGAAAABQAAAKg8EACDAAAAngAAAAwAAACoPBAAgwAAAJgAAAANAAAAqDwQAIMAAACvAAAAFQAAAKg8EACDAAAAswAAACcAAACoPBAAgwAAAM4AAAAbAAAABAAAAAQAAAAEAAAAAwAAAAYAAAADAAAAAwAAAAMAAAAGAAAABAAAAAYAAAADAAAAAwAAAAQAAAAEAAAABQAAAKCrEwCkqxMAqKsTAKyrEwCvqxMAtasTALirEwC7qxMAvqsTAMSrEwDIqxMAzqsTANGrEwDUqxMA2KsTANyrEwAJXRAAZAAAAF4AAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5wdXQubGVuKCkgPj0gTlVNX0JJVFMgKiA0AAAACV0QAGQAAABfAAAAAQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlucHV0LmxlbigpID49IE5VTV9CSVRTICogOAAAAOAuEABwAAAAKAcAAAkAAADXMhAAeAAAAOsHAAAJAAAAEQQAABQAAAAEAAAAEgQAABMEAAAYAAAACAAAABQEAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAEH4784AC6EeAQAAABUEAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiAAAAC4EwAqAAAAqAEAAKkBAACqAQAAFgQAABcEAAByYW5nZSBzdGFydCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gZW5kOiAgPD0gAABIuBMAKgAAAHK4EwAEAAAACywQAFoAAACGAQAACQAAAHJhbmdlIGVuZCBvdXQgb2YgYm91bmRzOiAAAACYuBMAGQAAAHK4EwAEAAAACywQAFoAAACMAQAACQAAABgEAAAMAAAABAAAAF8AAAAAAAAABAAAAAQAAAAZBAAARnJvbVV0ZjhFcnJvcmJ5dGVzZXJyb3IARVsQAFwAAACuAAAAKgAAAAAAAAAEAAAABAAAADQAAABUcnlGcm9tU2xpY2VFcnJvcgAAANRyEABcAAAAUAAAADMAAAB1c2l6ZSBvdmVyZmxvdyB3aGVuIGNhbGN1bGF0aW5nIGI2NCBsZW5ndGgAANRyEABcAAAAVwAAAAoAAACxgxAAYAAAAPoAAAAeAAAAVmVjIGlzIHNpemVkIGNvbnNlcnZhdGl2ZWx5AJy5EwAbAAAAsYMQAGAAAAABAQAAGQAAAGludGVnZXIgb3ZlcmZsb3cgd2hlbiBjYWxjdWxhdGluZyBidWZmZXIgc2l6ZQAAALGDEABgAAAAeQAAABIAAACxgxAAYAAAAHsAAAAbAAAASW52YWxpZCBVVEY4sYMQAGAAAAB/AAAAJAAAAIR2EABiAAAAPQEAABkAAACEdhAAYgAAAD4BAAAaAAAAhHYQAGIAAAA/AQAAFwAAAIR2EABiAAAAQAEAABgAAACEdhAAYgAAACsBAAAZAAAAhHYQAGIAAAAsAQAAGgAAAIR2EABiAAAALQEAABcAAACEdhAAYgAAAC4BAAAYAAAALi4AAM51EABqAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBpbnB1dF9wb3MgPD0gaW5wdXQubGVuKCkAABwmEABmAAAAZQEAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBleHRfZGljdC5pc19lbXB0eSgpAAAAHCYQAGYAAABvAQAACQAAABwmEABmAAAAFQEAACQAAABQTEFJTlBMQUlOX0RJQ1RJT05BUllSTEVCSVRfUEFDS0VEREVMVEFfQklOQVJZX1BBQ0tFRERFTFRBX0xFTkdUSF9CWVRFX0FSUkFZREVMVEFfQllURV9BUlJBWVJMRV9ESUNUSU9OQVJZQllURV9TVFJFQU1fU1BMSVQAAQAAAAAAAABVTkNPTVBSRVNTRURTTkFQUFlHWklQTFpPQlJPVExJTFo0WlNURExaNF9SQVd1bmV4cGVjdGVkIHBhcnF1ZXQgdHlwZTogAAAFvBMAGQAAAHVuZXhwZWN0ZWQgcGFycXVldCBjb252ZXJ0ZWQgdHlwZTogACi8EwAjAAAASW50ZWdlciB0eXBlICBpcyBub3Qgc3VwcG9ydGVkAABUvBMADQAAAGG8EwARAAAAVJAQAFwAAACwAwAAGgAAAHVuZXhwZWN0ZWQgcGFycXVldCByZXBldGl0aW9uIHR5cGU6IJS8EwAkAAAAdW5leHBlY3RlZCBwYXJxdWV0IGVuY29kaW5nOiAAAADAvBMAHQAAAHVuZXhwZWN0ZWQgcGFycXVldCBjb21wcmVzc2lvbiBjb2RlYzogAADovBMAJgAAAHVuZXhwZWN0ZWQgcGFycXVldCBwYWdlIHR5cGU6IAAAGL0TAB4AAABSRVFVSVJFRE9QVElPTkFMUkVQRUFURURCT09MRUFOSU5UMzJJTlQ2NElOVDk2RkxPQVRET1VCTEVCWVRFX0FSUkFZRklYRURfTEVOX0JZVEVfQVJSQVlOT05FVVRGOE1BUE1BUF9LRVlfVkFMVUVMSVNURU5VTURFQ0lNQUxEQVRFVElNRV9NSUxMSVNUSU1FX01JQ1JPU1RJTUVTVEFNUF9NSUxMSVNUSU1FU1RBTVBfTUlDUk9TVUlOVF84VUlOVF8xNlVJTlRfMzJVSU5UXzY0SU5UXzhJTlRfMTZJTlRfMzJJTlRfNjRKU09OQlNPTklOVEVSVkFMAAAeahAAYAAAAB8DAAA6AAAAIAAAAEFycmF5IHRvbyBsYXJnZSwgZXhwZWN0ZWQgbGVzcyB0aGFuIFC+EwAkAAAAUlYQAGwAAAA3AAAABQAAAFJWEABsAAAAOAAAABgAAAAQAAAABAAAAAgAAAAIfBAAaAAAAGwBAAA+AAAACHwQAGgAAABtAQAAOgAAAEluY29uc2lzdGVudCBsZW5ndGggb2YgZGVmaW5pdGlvbiBhbmQgcmVwZXRpdGlvbiBsZXZlbHM6ICAhPSAAAADIvhMAOQAAAAG/EwAEAAAACHwQAGgAAADqAQAAKAAAAAh8EABoAAAA6wEAACgAAAAIfBAAaAAAAJkCAAAiAAAAV3JpdGUgbXVzdCBzdGFydCBhdCBhIHJlY29yZCBib3VuZGFyeSwgZ290IG5vbi16ZXJvIHJlcGV0aXRpb24gbGV2ZWwgb2YgSL8TAEgAAAAIfBAAaAAAALgCAAAiAAAACHwQAGgAAADBAgAAJwAAAERlZmluaXRpb24gbGV2ZWxzIGFyZSByZXF1aXJlZCwgYmVjYXVzZSBtYXggZGVmaW5pdGlvbiBsZXZlbCA9IAC4vxMAPwAAAFJlcGV0aXRpb24gbGV2ZWxzIGFyZSByZXF1aXJlZCwgYmVjYXVzZSBtYXggcmVwZXRpdGlvbiBsZXZlbCA9IAAAwBMAPwAAAAh8EABoAAAAGgMAADIAAAAIfBAAaAAAABsDAAAyAAAACHwQAGgAAABDAwAAMgAAAAh8EABoAAAARAMAADIAAAAIfBAAaAAAADYDAAA2AAAACHwQAGgAAAA7AwAANgAAAAh8EABoAAAAiAMAAB4AAAAIfBAAaAAAAIUDAAAsAAAACHwQAGgAAACnAwAAIwAAAAh8EABoAAAApAMAADEAAAAIfBAAaAAAALYDAAArAAAACHwQAGgAAAC6AwAAKwAAAAh8EABoAAAAzQMAACsAAAAIfBAAaAAAANEDAAArAAAACHwQAGgAAAAXBAAAHAAAAAh8EABoAAAAIQQAABwAAAAIfBAAaAAAACoEAAAYAAAACHwQAGgAAAAuBAAALgAAAAh8EABoAAAARgQAABwAAAAIfBAAaAAAAEwEAAAcAAAACHwQAGgAAABgBAAAIAAAAAh8EABoAAAAWQQAACQAAAAIfBAAaAAAAHcEAAAdAAAACHwQAGgAAACjBAAAOgAAAAh8EABoAAAA6QQAACUAAAAIfBAAaAAAAAcFAAAmAAAACHwQAGgAAAAWBQAAHQAAAERpY3Rpb25hcnkgZW5jb2RlciBpcyBub3Qgc2V0RGljdGlvbmFyeSBvZmZzZXQgaXMgYWxyZWFkeSBzZXQAAAAVwhMAIAAAAAh8EABoAAAAMAUAABEAAAAIfBAAaAAAAGMFAAArAAAACHwQAGgAAABjBQAAMwAAAAh8EABoAAAAzQUAAC0AAAAIfBAAaAAAAM4FAAAtAAAACHwQAGgAAAAHBgAAGQAAAAh8EABoAAAAIgYAADEAAAAIfBAAaAAAACMGAAAyAAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAAsEAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZVN0cmluZ01hcExpc3RFbnVtAAAAAAAABAAAAAQAAAAaBAAAAAAAAAQAAAAEAAAAbQMAAERlY2ltYWxzY2FsZXByZWNpc2lvbkRhdGUAAAAAAAAAAQAAAAEAAAAbBAAAAAAAAAQAAAAEAAAAHAQAAFRpbWVpc19hZGp1c3RlZF90b191X3RfY3VuaXRUaW1lc3RhbXAAAAAAAAAAAQAAAAEAAAAdBAAAAAAAAAQAAAAEAAAARwIAAEludGVnZXJiaXRfd2lkdGhpc19zaWduZWRVbmtub3duSnNvbkJzb25VdWlkRmxvYXQxNlZhcmlhbnRHZW9tZXRyeUdlb2dyYXBoeQAAAAAABAAAAAQAAAAeBAAAAAAAAAQAAAAEAAAAHwQAAAAAAAAEAAAABAAAACAEAAC/VhAAZAAAAOoAAAA4AAAAv1YQAGQAAADrAAAAFQAAAL9WEABkAAAAJwEAABIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbnZhbGlkIG51bV9iaXRzIADAxBMAOwAAAAldEABkAAAAXAAAAAEAAAAJXRAAZAAAAF0AAAABAAAACV0QAGQAAABeAAAAAQAAAAldEABkAAAAXwAAAAEAAADqTBAAYgAAAOoAAAAYAAAA6kwQAGIAAADsAAAANwAAAOpMEABiAAAA8wAAABgAAADqTBAAYgAAAPYAAAA1AAAADCoQAGcAAAB6AAAAHQAAABRsEABkAAAAkgAAAAkAAAAEAAAABAAAAAMAAAANAAAABAAAAAQAAAAHAAAABAAAAAsAAAALAAAAEAAAABAAAAAGAAAABwAAAAcAAAAHAAAABQAAAAYAAAAGAAAABgAAAAQAAAAEAAAACAAAAJe9EwCbvRMAn70TAKK9EwCvvRMAs70TALe9EwC+vRMAwr0TAM29EwDYvRMA6L0TAPi9EwD+vRMABb4TAAy+EwATvhMAGL4TAB6+EwAkvhMAKr4TAC6+EwAyvhMABwAAAAUAAAAFAAAABQAAAAUAAAAGAAAACgAAABQAAABYvRMAX70TAGS9EwBpvRMAbr0TAHO9EwB5vRMAg70TAAUAAAAQAAAAAwAAAAoAAAATAAAAFwAAABAAAAAOAAAAEQAAAFS7EwBZuxMAabsTAGy7EwB2uxMAibsTAKC7EwCwuxMAvrsTAEC9EwBIvRMAUL0TAAAAAQIDBAUGBwgAAAYAAAAGAAAABgAAAAYAAAABAAAABgAAAAEAAAAGAEGtjs8AC9kJAwAAAAAAAAACAAB0AAAAfQAAABwAAABcghAAfgAAALIFAAAkAAAAbWlzc2luZyByZXF1aXJlZCBmaWVsZCAAVMcTABcAAADOdRAAagAAAL0BAAAdAAAAUGFnZSBjb21wcmVzc2VkIHNpemUgb3ZlcmZsb3c6IACExxMAHwAAAFBhZ2UgdW5jb21wcmVzc2VkIHNpemUgb3ZlcmZsb3c6IAAAAKzHEwAhAAAAsHAQAGIAAABgAQAAPgAAALBwEABiAAAAbQEAAEEAAABwYWdlIHR5cGUgIGNhbm5vdCBiZSBjb252ZXJ0ZWQgdG8gUGFnZU1ldGFkYXRhAAD4xxMACgAAAALIEwAkAAAASW5zdWZmaWNpZW50IHJlcGV0aXRpb24gbGV2ZWxzIHJlYWQgZnJvbSBjb2x1bW5hc3NlcnRpb24gZmFpbGVkOiByZWNvcmRzX3JlYWQgPCByZW1haW5pbmdfcmVjb3JkcwAAABdEEABkAAAA6wAAABkAAABpbnN1ZmZpY2llbnQgdmFsdWVzIHJlYWQgZnJvbSBjb2x1bW4gLSBleHBlY3RlZDogLCBnb3Q6IKzIEwAxAAAA3cgTAAcAAABpbnN1ZmZpY2llbnQgZGVmaW5pdGlvbiBsZXZlbHMgcmVhZCBmcm9tIGNvbHVtbiAtIGV4cGVjdGVkIHtsZXZlbHNfdG9fcmVhZH0sIGdvdCB7bGV2ZWxzX3JlYWR9bXVzdCBzcGVjaWZ5IHJlcGV0aXRpb24gbGV2ZWxzbXVzdCBzcGVjaWZ5IGRlZmluaXRpb24gbGV2ZWxzAAAXRBAAZAAAAFABAAAZAAAAc2tpcHBlZCAgdmFsdWVzLCBleHBlY3RlZCAAAKDJEwAIAAAAqMkTABIAAABsZXZlbHMgbWlzbWF0Y2gsIHJlYWQgIHJlcGV0aXRpb24gbGV2ZWxzIGFuZCAgZGVmaW5pdGlvbiBsZXZlbHMAzMkTABYAAADiyRMAFwAAAPnJEwASAAAASW52YWxpZCBwYWdlLiBFeHBlY3RpbmcgZGljdGlvbmFyeSBwYWdlABdEEABkAAAAwwEAACYAAAAXRBAAZAAAANIBAAAmAAAAF0QQAGQAAAD6AQAAQQAAABdEEABkAAAAAwIAAEEAAABtb3JlIG51bGxzIHRoYW4gdmFsdWVzIGluIHBhZ2UsIGNvbnRhaW5lZCAgdmFsdWVzIGFuZCAgbnVsbHOMyhMAKgAAALbKEwAMAAAAwsoTAAYAAABpbnZhbGlkIGxldmVsIGVuY29kaW5nOiDgyhMAGAAAAAAAAAAEAAAABAAAAG0DAABQYWdlVHlwZWAAAABYAAAACAAAAAAAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAHCLEAB+AAAANAAAAAUAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQAAAO8nEABrAAAA+AEAAA4AAAAAAAAABAAAAAQAAAAiBAAAAAAAAAQAAAAEAAAASgIAQZCYzwALgwIBAAAAIwQAAGFzc2VydGlvbiBmYWlsZWQ6IGRzdC5sZW4oKSA+PSBzZWxmLnJlcXVpcmVkX3NwYWNlKClkHRAAZQAAAL0AAAAJAAAAZB0QAGUAAADHAAAACQAAAGQdEABlAAAAwgAAAA0AAAD8hhAAbAAAAOIKAAAkAAAA9SEQAHkAAAD7AAAAAQAAAM51EABqAAAAXwMAAAkAAAAPNxAAZQAAACoAAAAcAAAA8o0QAFgAAABmAAAAHgAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADOdRAAagAAAKcBAAAfAAAAznUQAGoAAACuAQAAJgAAAP//////////CM0TAEGgms8AC4sCNjwQAHEAAAA1AAAADgAAADY8EABxAAAAPQAAACMAAAA2PBAAcQAAAD0AAAARAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogSW52YWxpZCB0YXJnZXRfdHlwZSBmb3IgSW50OTYuUM0TAEgAAACZCxAAeQAAAF8AAAASAAAA2ocQAGgAAABdAwAAEQAAACsEAAA0AAAABAAAACwEAACcRhAAaQAAAKMAAAATAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAAAAAAP//////////IM4TAEG4nM8AC/IB51HfowBlUvxOFPrNbmSQKZI5xUazPs0y+5WJbRIdLyTtA0ifzjw4VLrw3c09UEgQC29pMjKk4R6lrzqBzmZDgPjVTFc7mE2LIvXN/3hfC9MKhZW/IEozSXDxY79wngdrV/CMI74HCC3mkyVvVPH/eZXGSEtF/rhGs2cet9Q4ijL7Dn/dZKwIGe04xkamSdSL/Y6QvO2ptyOVAXsvNSuJ2xOZG0KIJu5t/Uj5ePZkrnH0JZQYRfOIB4x2dfTv2t/lc+0rTZv+6HdM4/H+feiAUv/sWnXFLhhxAXp4pMJb1YsVpshLeyZ5LwFLe1wZZMGGLQQAQbSezwALlUUBAAAALgQAAC8EAAAYAAAACAAAADAEAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAOJfEABrAAAA6AEAABcAAADiXxAAawAAAFQLAAABAAAA+tUy8Ua+bfM61IAWL3iSWKdIDPBnX5Oh8meN+VtzX/0NuNmGge7izitUvNdouZYAN4ELy7Hkxk7fovYO625hGAAAAAAEAAAABAAAADEEAAAAAAAABAAAAAQAAABFAgAASW52YWxpZEJ5dGUAAAAAAAQAAAAEAAAAMQAAAEludmFsaWRMZW5ndGhJbnZhbGlkTGFzdFN5bWJvbEludmFsaWRQYWRkaW5nAAAAAAQAAAAEAAAAMgQAAFV0ZjhFcnJvcnZhbGlkX3VwX3RvZXJyb3JfbGVuAAAAz4kQAGEAAAAvAAAAEQAAAMRKEABqAAAAbQgAAB8AAABMYXlvdXRFcnJvcgAzBAAADAAAAAQAAAChAQAAAAAAAAQAAAAEAAAAogEAAE1pc3NpbmdSZXF1aXJlZEZpZWxkcmVxdWlyZWRlcnJvcl90cmFjZUluY29uc2lzdGVudFVuaW9uZmllbGRmaWVsZF90eXBlAAAAAAAIAAAABAAAADQEAAAAAAAACAAAAAQAAACkAQAAZXJyb3JyYW5nZU1pc3NpbmdOdWxsVGVybWluYXRvclVuYWxpZ25lZHBvc2l0aW9udW5hbGlnbmVkX3R5cGVSYW5nZU91dE9mQm91bmRzAAAAAAAABAAAAAQAAAA1BAAAU2lnbmVkT2Zmc2V0T3V0T2ZCb3VuZHNzb2Zmc2V0VG9vTWFueVRhYmxlc0FwcGFyZW50U2l6ZVRvb0xhcmdlRGVwdGhMaW1pdFJlYWNoZWQ2BAAAZAAAAAQAAAA3BAAAznUQAGoAAAC9AQAAHQAAAEsrEABmAAAAsgAAABkAAABLKxAAZgAAAOUAAAAZAAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAOgQAADsEAAA7BAAAAAAAAAQAAAAEAAAAPAQAAD0EAAA9BAAAAAAAAAQAAAAEAAAAPgQAAD8EAAA/BAAAAAAAAAQAAAAEAAAAQAQAAEEEAABBBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAQgQAAEMEAABDBAAAAAAAAAQAAAAEAAAARAQAAEUEAABFBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAARgQAAEcEAABHBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAASAQAAEkEAABJBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAASgQAAEsEAABLBAAAAAAAAAQAAAAEAAAATAQAAE0EAABNBAAALCBJbmNvbXBhdGlibGUgc3VwcGxpZWQgQXJyb3cgc2NoZW1hOiAAAJbTEwAkAAAAZGF0YSB0eXBlIG1pc21hdGNoIGZvciBmaWVsZCA6IHJlcXVlc3RlZCAgYnV0IGZvdW5kIMTTEwAdAAAA4dMTAAwAAADt0xMACwAAAHF8EABtAAAAgAIAABgAAABudWxsYWJpbGl0eSBtaXNtYXRjaCBmb3IgZmllbGQgOiBleHBlY3RlZCAAACDUEwAfAAAAP9QTAAsAAADt0xMACwAAAHF8EABtAAAAiAIAABgAAABtZXRhZGF0YSBtaXNtYXRjaCBmb3IgZmllbGQgdNQTABwAAAA/1BMACwAAAO3TEwALAAAAcXwQAG0AAACQAgAAGAAAAEluY29tcGF0aWJsZSBzdXBwbGllZCBBcnJvdyBzY2hlbWE6IGV4cGVjdGVkICBjb2x1bW5zIHJlY2VpdmVkIAC41BMALQAAAOXUEwASAAAAcXwQAG0AAAD+AwAANwAAAHF8EABtAAAAGAQAACcAAABmYWlsZWQgdG8gc2tpcCByb3dzLCBleHBlY3RlZCAsIGdvdCAo1RMAHgAAAEbVEwAGAAAAU3RydWN0IGFycmF5IHJlYWRlciBzaG91bGQgcmV0dXJuIHN0cnVjdCBhcnJheWludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IFN0cnVjdCBhcnJheSByZWFkZXIncyBkYXRhIHR5cGUgaXMgbm90IHN0cnVjdCEAAIrVEwBYAAAAcXwQAG0AAABpBAAAEgAAACcpQ2Fubm90IGNhbGwgZ2V0X2ZpZWxkcygpIG9uIGEgbm9uLWdyb3VwIHR5cGUAAP7VEwAsAAAAKS0QAGMAAABwAAAAEgAAAENhbm5vdCBjYWxsIGdldF9waHlzaWNhbF90eXBlKCkgb24gYSBub24tcHJpbWl0aXZlIHR5cGUARNYTADcAAAApLRAAYwAAAH0AAAASAAAAIGNhbm5vdCBiZSBhcHBsaWVkIHRvIGEgcHJpbWl0aXZlIHR5cGUgZm9yIGZpZWxkICcAAAEAAAAAAAAAlNYTADIAAAD81RMAAQAAAERFQ0lNQUwgbG9naWNhbCB0eXBlIHByZWNpc2lvbiAgbXVzdCBtYXRjaCBzZWxmLnByZWNpc2lvbiAgZm9yIGZpZWxkICcAAODWEwAfAAAA/9YTABsAAAAa1xMADAAAAPzVEwABAAAAREVDSU1BTCBsb2dpY2FsIHR5cGUgc2NhbGUgIG11c3QgbWF0Y2ggc2VsZi5zY2FsZSAAAEjXEwAbAAAAY9cTABcAAAAa1xMADAAAAPzVEwABAAAAQ2Fubm90IHVzZSBtaWxsaXNlY29uZCB1bml0IG9uIElOVDY0IHR5cGUgZm9yIGZpZWxkICcAAACc1xMANQAAAPzVEwABAAAAVVVJRCBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBGSVhFRF9MRU5fQllURV9BUlJBWSgxNikgZmllbGTk1xMAHAAAAADYEwA0AAAARkxPQVQxNiBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBGSVhFRF9MRU5fQllURV9BUlJBWSgyKSBmaWVsZAAARNgTAB8AAABj2BMAMwAAAENhbm5vdCBhbm5vdGF0ZSAgZnJvbSAAAKjYEwAQAAAAuNgTAAYAAAAa1xMADAAAAPzVEwABAAAATG9naWNhbCB0eXBlICBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb252ZXJ0ZWQgdHlwZSAAAODYEwANAAAA7dgTACUAAAAa1xMADAAAAPzVEwABAAAARU5VTSBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBCWVRFX0FSUkFZIGZpZWxkAAA02RMAHAAAAFDZEwAmAAAAIGNhbm5vdCBhbm5vdGF0ZSBmaWVsZCAnJyBiZWNhdXNlIGl0IGlzIG5vdCBhIElOVDMyIGZpZWxkAAAAAQAAAAAAAACI2RMAGAAAAKDZEwAhAAAAJyBiZWNhdXNlIGl0IGlzIG5vdCBhIElOVDY0IGZpZWxkAAAAAQAAAAAAAACI2RMAGAAAANzZEwAhAAAAAQAAAAAAAACI2RMAGAAAAFDZEwAmAAAASU5URVJWQUwgY2Fubm90IGFubm90YXRlIGZpZWxkICcnIGJlY2F1c2UgaXQgaXMgbm90IGEgRklYRURfTEVOX0JZVEVfQVJSQVkoMTIpIGZpZWxkMNoTACAAAABQ2hMANAAAACBjYW5ub3QgYmUgYXBwbGllZCB0byBwcmltaXRpdmUgZmllbGQgJwABAAAAAAAAAJTaEwAnAAAA/NUTAAEAAABJbnZhbGlkIEZJWEVEX0xFTl9CWVRFX0FSUkFZIGxlbmd0aDogAAAA1NoTACUAAAAa1xMADAAAAPzVEwABAAAAQ2Fubm90IHJlcHJlc2VudCBJTlQzMiBhcyBERUNJTUFMIHdpdGggcHJlY2lzaW9uIAAAABTbEwAxAAAAQ2Fubm90IHJlcHJlc2VudCBJTlQ2NCBhcyBERUNJTUFMIHdpdGggcHJlY2lzaW9uIAAAAFDbEwAxAAAASW52YWxpZCBsZW5ndGggIGZvciBEZWNpbWFsAIzbEwAPAAAAm9sTAAwAAABDYW5ub3QgcmVwcmVzZW50IEZJWEVEX0xFTl9CWVRFX0FSUkFZIGFzIERFQ0lNQUwgd2l0aCBsZW5ndGggIGFuZCBwcmVjaXNpb24gLiBUaGUgbWF4IHByZWNpc2lvbiBjYW4gb25seSBiZSC42xMAPQAAAPXbEwAPAAAABNwTACAAAABJbnZhbGlkIERFQ0lNQUw6IHNjYWxlICgpIGNhbm5vdCBiZSBncmVhdGVyIHRoYW4gcHJlY2lzaW9uICg83BMAGAAAAFTcEwAkAAAA/dUTAAEAAABJbnZhbGlkIERFQ0lNQUwgc2NhbGU6IACQ3BMAFwAAAEludmFsaWQgREVDSU1BTCBwcmVjaXNpb246IACw3BMAGwAAAERFQ0lNQUwgY2FuIG9ubHkgYW5ub3RhdGUgSU5UMzIsIElOVDY0LCBCWVRFX0FSUkFZIGFuZCBGSVhFRF9MRU5fQllURV9BUlJBWWFzc2VydGlvbiBmYWlsZWQ6IHNlbGYucmVwZXRpdGlvbi5pc19zb21lKCkAACktEABjAAAAuAIAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlkLmlzX3NvbWUoKQApLRAAYwAAAM4CAAAJAAAALkV4cGVjdGVkIHByaW1pdGl2ZSB0eXBlIQAAAJHdEwAYAAAAKS0QAGMAAACSAwAAEgAAACktEABjAAAAmwMAABIAAABTY2hlbWFEZXNjcmlwdG9yIHNob3VsZCB0YWtlIGEgR3JvdXBUeXBl1N0TACgAAAApLRAAYwAAAAYEAAAJAAAASW5kZXggb3V0IG9mIGJvdW5kOiAgbm90IGluIFswLCAU3hMAFAAAACjeEwAMAAAA/dUTAAEAAAApLRAAYwAAADgEAAAJAAAARXhwZWN0ZWQgYSB2YWx1ZSBmb3IgaW5kZXggIGJ1dCBmb3VuZCBOb25lAABc3hMAGwAAAHfeEwAPAAAAKS0QAGMAAABCBAAAIAAAAGFzc2VydGlvbiBmYWlsZWQ6IHRwLmdldF9iYXNpY19pbmZvKCkuaGFzX3JlcGV0aXRpb24oKQAAKS0QAGMAAABiBAAABQAAACktEABjAAAAZAQAABEAAAApLRAAYwAAAHMEAAASAAAAKS0QAGMAAAB0BAAAFAAAACktEABjAAAAegQAABoAAABFeHBlY3RlZCByb290IG5vZGUgdG8gYmUgYSBncm91cCB0eXBlRXhwZWN0ZWQgZXhhY3RseSBvbmUgcm9vdCBub2RlLCBidXQgZm91bmQgAFXfEwAqAAAAKS0QAGMAAACUBAAAFgAAAEJpdCB3aWR0aCBtdXN0IGJlIDgsIDE2LCAzMiwgb3IgNjQgZm9yIEludGVnZXIgbG9naWNhbCB0eXBlACktEABjAAAAxQQAADgAAAApLRAAYwAAAP8EAAA5AAAAUmVwZXRpdGlvbiBsZXZlbCBtdXN0IGJlIGRlZmluZWQgZm9yIGEgcHJpbWl0aXZlIHR5cGUAAAApLRAAYwAAACEFAAA2AAAAKS0QAGMAAAANBQAAGAAAAEluZGV4IG91dCBvZiBib3VuZCwgaW5kZXggPSAsIGxlbiA9IEzgEwAcAAAAaOATAAgAAABSb290IHNjaGVtYSBtdXN0IGJlIEdyb3VwIHR5cGUAACktEABjAAAAVAUAABYAAAApLRAAYwAAAHEFAAAWAAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9ySW5kZXhPdXRPZkJvdW5kAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxOZWVkTW9yZURhdGEAAAAABAAAAAQAAAAzAAAATmVlZE1vcmVEYXRhUmFuZ2UAAABOBAAAWAAAAAgAAABPBAAAUAQAAFEEAABSBAAAUwQAAFQEAABUBAAAbm90IGltcGxlbWVudGVkOiByZWFkaW5nIGdyb3VwIHR5cGUgIG5vdCBpbXBsZW1lbnRlZGjhEwAkAAAAjOETABAAAAD2QRAAcQAAAKIAAAAWAAAAAgAAAPZBEABxAAAAvwAAACUAAAD2QRAAcQAAAMAAAAAlAAAAVQQAACgAAAAEAAAAVgQAAFcEAABYBAAAWQQAAFoEAABbBAAAXAQAAPZBEABxAAAAvAAAAB0AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2Rl9kEQAHEAAADFAAAAHgAAAHBhcnRpYWwgcHJvamVjdGlvbiBvZiBNYXBBcnJheSBpcyBub3Qgc3VwcG9ydGVkAPZBEABxAAAArgAAAAkAAAD2QRAAcQAAAOEAAAApAAAAAQAAAF0EAAAcAAAABAAAAF4EAABfBAAAYAQAAGEEAABiBAAAYwQAAGQEAABdBAAAHAAAAAQAAABlBAAAXwQAAGAEAABmBAAAYgQAAGMEAABkBAAA9kEQAHEAAADvAAAAGgAAAPZBEABxAAAA4gAAAAkAAABnBAAAIAAAAAQAAABoBAAAaQQAAGoEAABrBAAAbAQAAG0EAABuBAAA9kEQAHEAAAAQAQAACQAAAG8EAABgAQAACAAAAHAEAABxBAAAcgQAAHMEAAB0BAAAdQQAAHYEAAB3BAAAYAEAAAgAAAB4BAAAcQQAAHkEAAB6BAAAewQAAHUEAAB2BAAAdwQAAGABAAAIAAAAfAQAAHEEAAB5BAAAfQQAAHsEAAB1BAAAdgQAAH4EAABgAQAACAAAAH8EAABxBAAAgAQAAIEEAACCBAAAdQQAAHYEAACDBAAAYAEAAAgAAACEBAAAcQQAAIUEAACGBAAAhwQAAHUEAAB2BAAAiAQAAGABAAAIAAAAiQQAAHEEAACKBAAAiwQAAIwEAAB1BAAAdgQAAI0EAABgAQAACAAAAI4EAABxBAAAjwQAAJAEAACRBAAAdQQAAHYEAAD2QRAAcQAAADoBAAArAAAA9kEQAHEAAACaAQAACQAAAPZBEABxAAAAnAEAABsAAACSBAAAIAAAAAQAAACTBAAAlAQAAJUEAACWBAAAlwQAAJgEAACZBAAA9kEQAHEAAACkAQAAGQAAAE4EAABYAAAACAAAAJoEAABnBAAAIAAAAAQAAACbBAAAZmlyc3QgcmVwZXRpdGlvbiBsZXZlbCBvZiBiYXRjaCBtdXN0IGJlIDAAAAArBAAANAAAAAQAAACcBAAAnQQAAJ4EAACfBAAAoAQAAKEEAACiBAAAowQAAKQEAAClBAAApgQAAKcEAACoBAAAqQQAAKoEAACrBAAArAQAAK0EAACuBAAAZml4ZWQtc2l6ZSBsaXN0IGxlbmd0aCBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgIGJ1dCBhcnJheSBjb250YWlucyAgZWxlbWVudHMAAHDlEwAtAAAAneUTABQAAACx5RMACQAAAGl0ZW1fcmVhZGVyIGRlZiBsZXZlbHMgYXJlIE5vbmVpdGVtX3JlYWRlciByZXAgbGV2ZWxzIGFyZSBOb25lRW5jb3VudGVyZWQgbWlzYWxpZ25lZCByb3cgd2l0aCBsZW5ndGggIChleHBlY3RlZCBsZW5ndGggABLmEwAnAAAAOeYTABIAAAD91RMAAQAAAEVuY291bnRlcmVkIHJlcGV0aXRpb24gbGV2ZWwgdG9vIGxhcmdlIGZvciBkZWZpbml0aW9uIGxldmVsAF0EAAAcAAAABAAAAK8EAABdBAAAHAAAAAQAAACwBAAAbWFwIHN0cnVjdCBjYW5ub3QgYmUgbnVsbGFibGUAAADA5hMAHQAAAAEJEABzAAAANgAAABUAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBleHBlY3RlZCBzdHJ1Y3Qgd2l0aCB0d28gZmllbGRzAAAA+OYTAEkAAAABCRAAcwAAADkAAAAWAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogZXhwZWN0ZWQgbWFwIHR5cGUAXOcTADsAAAABCRAAcwAAADsAAAASAAAAVQQAACgAAAAEAAAAsQQAAAEJEABzAAAAYgAAADEAAAA2BAAAZAAAAAQAAACyBAAAswQAALQEAAC1BAAAtgQAALcEAAC4BAAAuQQAALoEAAClBAAAuwQAALwEAAC9BAAAvgQAAL8EAADABAAAwQQAAMIEAADDBAAAdwQAAGABAAAIAAAAxAQAAG8EAABgAQAACAAAAMUEAACNBAAAYAEAAAgAAADGBAAAgwQAAGABAAAIAAAAxwQAAH4EAABgAQAACAAAAMgEAACIBAAAYAEAAAgAAADJBAAAdwQAAGABAAAIAAAAygQAAJIEAAAgAAAABAAAAMsEAAA7DxAAawAAAMUAAAAcAAAAOw8QAGsAAADLAAAAIgAAADsPEABrAAAA4wAAABoAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBmaWVsZCBuYW1lZCAgZ290IAAAANjoEwAwAAAACOkTAAUAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCAgc3RydWN0IGZpZWxkcyBnb3QgACDpEwAkAAAAROkTABMAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBzdHJ1Y3QgZ290IABo6RMALwAAADsPEABrAAAA2AAAADYAAAA7DxAAawAAAA0BAAAeAAAAOw8QAGsAAAAgAQAAGAAAADsPEABrAAAAIQEAABoAAAA7DxAAawAAAD4BAAAqAAAAOw8QAGsAAAA+AQAAPQAAAE1hcCBkYXRhIHR5cGUgc2hvdWxkIGNvbnRhaW4gc3RydWN0IHdpdGggdHdvIGNoaWxkcmVuLCBnb3QgAADqEwA7AAAATWFwIGRhdGEgdHlwZSBzaG91bGQgY29udGFpbiBzdHJ1Y3QgZ290IETqEwAoAAAAaW5jb21wYXRpYmxlIGFycm93IHNjaGVtYSwgZXhwZWN0ZWQgbWFwIGdvdCB06hMALAAAAE1hcCB2YWx1ZXMgY2Fubm90IGJlIHJlcGVhdGVkTWFwIGtleXMgY2Fubm90IGJlIHJlcGVhdGVkQ2hpbGQgb2YgbWFwIGZpZWxkIG11c3QgaGF2ZSB0d28gY2hpbGRyZW4sIGZvdW5kIAAAAODqEwAxAAAAQ2hpbGQgb2YgbWFwIGZpZWxkIG11c3QgYmUgcmVwZWF0ZWRNYXAgZmllbGQgbXVzdCBoYXZlIGV4YWN0bHkgb25lIGtleV92YWx1ZSBjaGlsZCwgZm91bmQgAAA/6xMANwAAAE1hcCBjYW5ub3QgYmUgcmVwZWF0ZWRhcnJheV90dXBsZQAAAAEAAAAAAAAAm+sTAAYAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBsaXN0IGdvdCAAAAC06xMALQAAAExpc3QgdHlwZSBjYW5ub3QgYmUgcmVwZWF0ZWRMaXN0IGNoaWxkIG11c3QgYmUgcmVwZWF0ZWRsaXN0IHR5cGUgbXVzdCBoYXZlIGEgc2luZ2xlIGNoaWxkLCBmb3VuZCAAAAAj7BMAKgAAACBpcyBhIGxpc3QgdHlwZSBhbmQgY2FuJ3QgYmUgcHJvY2Vzc2VkIGFzIHByaW1pdGl2ZS4BAAAAAAAAAFjsEwA0AAAAUEFSUVVFVDpmaWVsZF9pZDsPEABrAAAAbAIAADEAAABBUlJPVzpzY2hlbWFDiBAAZwAAAFEAAAAeAAAAQ4gQAGcAAABRAAAAOwAAAEOIEABnAAAAhwAAABIAAAABAAFBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSsv/////////////////////////////////////////////////////////z7///8/NDU2Nzg5Ojs8Pf////////8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGf///////xobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIz//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AvOwTAAwAAABVbmFibGUgdG8gZ2V0IHJvb3QgYXMgbWVzc2FnZSBzdG9yZWQgaW4gOiAAAEjuEwAoAAAAcO4TAAIAAABVbmFibGUgdG8gZGVjb2RlIHRoZSBlbmNvZGVkIHNjaGVtYSBzdG9yZWQgaW4gAACE7hMALgAAAJTTEwACAAAAdGhlIG1lc3NhZ2UgaXMgbm90IEFycm93IFNjaGVtYQBDiBAAZwAAAL8AAAAhAAAAQ4gQAGcAAADAAAAAFwAAAEOIEABnAAAAwQAAABcAAABDiBAAZwAAAMIAAAAXAAAAQ4gQAGcAAADkAAAAEgAAAEOIEABnAAAA4AAAABIAAABDiBAAZwAAAOEAAAASAAAAQ4gQAGcAAABxAQAALgAAAEOIEABnAAAAcQEAAD0AAABhZGp1c3RlZF90b191dGNpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHVuaXQgZm9yIFRpbWUzMjogAACD7xMAQwAAAEOIEABnAAAAPwIAABoAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHVuaXQgZm9yIFRpbWU2NDogAODvEwBDAAAAQ4gQAGcAAABLAgAAGgAAAGVsZW1lbnRsaXN0bm90IGltcGxlbWVudGVkOiBMaXN0Vmlldy9MYXJnZUxpc3RWaWV3IG5vdCBpbXBsZW1lbnRlZAAAR/ATADcAAABDiBAAZwAAAMwCAAANAAAAUGFycXVldCBkb2VzIG5vdCBzdXBwb3J0IHdyaXRpbmcgZW1wdHkgc3RydWN0cwAAmPATAC4AAABub3QgaW1wbGVtZW50ZWQ6IFNlZSBBUlJPVy04ODE3LtDwEwAgAAAAQ4gQAGcAAAADAwAAIgAAAGtleV92YWx1ZQAAAEOIEABnAAAA7wIAAEgAAABrZXkAQ4gQAGcAAADwAgAASgAAAHZhbHVlRGF0YVR5cGU6Ok1hcCBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBmaWVsZCBjaGlsZAAAPfETADEAAABDb252ZXJ0aW5nIFJ1bkVuZEVuY29kZWRUeXBlIHRvIHBhcnF1ZXQgbm90IHN1cHBvcnRlZAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAQAAAAEAQdjjzwALhQUBAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEQAAABIAAAATAAAAFAAAABUAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAAIjyEwAlAAAArfITACEAAAAoCxAAcAAAAOcCAAAJAAAAIGZyb20gYSBUeXBlZERpY3Rpb25hcnlBcnJheSBvZiBsZW5ndGggAIjyEwAlAAAA8PITACcAAAASBBAAcQAAAKwDAAAJAAAA1zIQAHgAAADrBwAACQAAAM0EAAAEAAAABAAAAM4EAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAM8EAAAAAAAABAAAAAQAAADQBAAAAAAAAAwAAAAEAAAA0QQAAAAAAAAEAAAABAAAANIEAABJbnB1dFBhaXIAAADOdRAAagAAADwDAAAQAAAAaW5jb21wbGV0ZSBmcmFtZQAAAAAIAAAABAAAANMEAAAAAAAABAAAAAQAAAAxAAAASW5wdXRSZWZlcmVuY2VkYXRhb3JpZ19vZmZzZXQAAADOdRAAagAAAL0BAAAdAAAAznUQAGoAAACnAQAAHwAAAM51EABqAAAArgEAACYAQejozwAL5QQsexAAbQAAAAMCAAAXAAAALHsQAG0AAAABAgAACQAAACx7EABtAAAAHgIAABQAAAAsexAAbQAAAEsCAAAeAAAALHsQAG0AAABdAgAALgAAACx7EABtAAAAawIAABIAAAAsexAAbQAAAGwCAAASAAAALHsQAG0AAAAZAwAANgAAACx7EABtAAAAUwMAACAAAAAsexAAbQAAAKcDAAAXAAAALHsQAG0AAAAjBAAAfAAAACx7EABtAAAAIwQAAGUAAAAsexAAbQAAACoEAAAuAAAALHsQAG0AAAAqBAAAFQAAACx7EABtAAAARQQAADIAAAAsexAAbQAAAEUEAAAZAAAALHsQAG0AAAA/BAAAMgAAACx7EABtAAAAPwQAABkAAAAsexAAbQAAAEIEAAAyAAAALHsQAG0AAABCBAAAGQAAACx7EABtAAAASAQAADAAAAAsexAAbQAAAEgEAAAZAAAALHsQAG0AAAA4BAAAMgAAACx7EABtAAAAOQQAADIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbnZhbGlkIG1hcCB0eXBlAADo9RMAOgAAACx7EABtAAAAOwQAABYAAABBdHRlbXB0aW5nIHRvIHdyaXRlIGFuIEFycm93IHR5cGUgIHRvIHBhcnF1ZXQgdGhhdCBpcyBub3QgeWV0IGltcGxlbWVudGVkAAAAPPYTACIAAABe9hMAJwAAACx7EABtAAAAIgQAAEkAAAAsexAAbQAAACIEAAAyAAAA1AQAAAQAAAAEAAAA1QQAANYEAAAOAEHY7c8AC1nXBAAACAAAAAQAAAByAgAAcwIAAHQCAADYBAAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAABABBvO7PAAsBBQBByO7PAAvmNGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IEN1cnJlbnRseSB1bnJlYWNoYWJsZSBiZWNhdXNlIGRhdGEgdHlwZSBub3Qgc3VwcG9ydGVkAEj3EwBfAAAALHsQAG0AAAACBQAADQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHNob3VsZCB1c2UgQnl0ZUFycmF5V3JpdGVywPcTAEQAAAAsexAAbQAAAA0FAAANAAAALHsQAG0AAAAWBQAAHgAAACx7EABtAAAAHQUAAB4AAABBdHRlbXB0aW5nIHRvIHdyaXRlIGFuIEFycm93IGludGVydmFsIHR5cGUgADz4EwArAAAAXvYTACcAAAAsexAAbQAAACwFAAAaAAAALHsQAG0AAAA/BQAAGgAAAEF0dGVtcHRpbmcgdG8gd3JpdGUgYW4gQXJyb3cgdHlwZSB0aGF0IGlzIG5vdCB5ZXQgaW1wbGVtZW50ZWQAAAAsexAAbQAAAGIFAAAWAAAALHsQAG0AAABkBQAAEAAAACx7EABtAAAAbwUAABYAAAAsexAAbQAAAHIFAAAaAAAALHsQAG0AAABzBQAADwAAACx7EABtAAAAdAUAABAAAAAsexAAbQAAAH8FAAAWAAAALHsQAG0AAACFBQAAEAAAACx7EABtAAAAjgUAABYAAAAsexAAbQAAAJIFAAAoAAAALHsQAG0AAACTBQAAEAAAACx7EABtAAAAnAUAABYAAAAsexAAbQAAAKAFAAAoAAAALHsQAG0AAAChBQAAEAAAACx7EABtAAAAqgUAABYAAAAsexAAbQAAAK4FAAAoAAAALHsQAG0AAACvBQAAEAAAACx7EABtAAAAuAUAABYAAAAsexAAbQAAALwFAAAoAAAALHsQAG0AAAC9BQAAEAAAACx7EABtAAAAxgUAABYAAAAsexAAbQAAAMkFAAAQAAAALHsQAG0AAADSBQAAFgAAACx7EABtAAAA1QUAABAAAABjb3VsZCBub3QgcGFyc2UgcGFycXVldCBtZXRhZGF0YatFEABrAAAAIQIAAC8AAACrRRAAawAAAGoCAAAvAAAAq0UQAGsAAABtAgAAIwAAAKtFEABrAAAAbwIAAC0AAACrRRAAawAAAI4CAAAdAAAAbWlzc2luZyBvZmZzZXQgaW5kZXirRRAAawAAAHYCAAAnAAAAq0UQAGsAAACBAgAAOAAAAFBBUkVQQVIxSW52YWxpZCBQYXJxdWV0IGZpbGUuIENvcnJ1cHQgZm9vdGVyUGFycXVldCBmaWxlIGhhcyBhbiBlbmNyeXB0ZWQgZm9vdGVyIGJ1dCB0aGUgZW5jcnlwdGlvbiBmZWF0dXJlIGlzIGRpc2FibGVkAKtFEABrAAAALQQAABgAAABDb3VsZCBub3QgcGFyc2UgbWV0YWRhdGE6IAAAhPsTABoAAACrRRAAawAAAEwEAAAhAAAAq0UQAGsAAABTBAAAIQAAAENvbHVtbiBvcmRlciBsZW5ndGggbWlzbWF0Y2jahxAAaAAAAOwAAAAZAAAA2ocQAGgAAAArAgAAFgAAANqHEABoAAAAxAIAABUAAABDb2x1bW4gY291bnQgbWlzbWF0Y2guIFNjaGVtYSBoYXMgIGNvbHVtbnMgd2hpbGUgUm93IEdyb3VwIGhhcyAAFPwTACIAAAA2/BMAHQAAANqHEABoAAAA7QIAABYAAABDb2x1bW4gbGVuZ3RoIG1pc21hdGNoOiAgIT0gdPwTABgAAACM/BMABAAAANqHEABoAAAAawMAABgAAADahxAAaAAAAIoDAAAJAAAA2ocQAGgAAACoAwAAFwAAAGNvbHVtbiBzdGFydCBhbmQgbGVuZ3RoIHNob3VsZCBub3QgYmUgbmVnYXRpdmUAAND8EwAuAAAA2ocQAGgAAAAbBAAACQAAAEV4cGVjdGVkIHRvIGhhdmUgY29sdW1uIG1ldGFkYXRh2ocQAGgAAAAiBgAAGQAAANqHEABoAAAAIwYAABkAAADahxAAaAAAACQGAAAZAAAA2ocQAGgAAAAlBgAAGgAAANqHEABoAAAANAYAABIAAADahxAAaAAAADUGAAASAAAA2ocQAGgAAAA5BgAAEgAAANqHEABoAAAAOgYAABIAAADahxAAaAAAAIMGAAAkAAAA2ocQAGgAAACJBgAAGwAAANqHEABoAAAAigYAACkAAADahxAAaAAAAJUGAAASAAAA0CMQAF0AAAAHAwAAIwAAANAjEABdAAAACgMAABEAAADQIxAAXQAAABEDAAAjAAAA0CMQAF0AAAAUAwAAEQAAAEJvdW5kaW5nQm94LnhtaW5Cb3VuZGluZ0JveC54bWF4Qm91bmRpbmdCb3gueW1pbkJvdW5kaW5nQm94LnltYXhhdXRvLWdlbmVyYXRlZCBjb2RlIHNob3VsZCBoYXZlIGNoZWNrZWQgZm9yIHByZXNlbmNlIG9mIHJlcXVpcmVkIGZpZWxkcwDQIxAAXQAAAKUDAAARAAAA0CMQAF0AAACmAwAAEQAAANAjEABdAAAApwMAABEAAADQIxAAXQAAAKgDAAARAAAA0CMQAF0AAAAABAAAIwAAANAjEABdAAAAAwQAABEAAABTdGF0aXN0aWNzbWF4bWlubnVsbF9jb3VudGRpc3RpbmN0X2NvdW50bWF4X3ZhbHVlbWluX3ZhbHVlaXNfbWF4X3ZhbHVlX2V4YWN0aXNfbWluX3ZhbHVlX2V4YWN0RGVjaW1hbFR5cGUuc2NhbGVEZWNpbWFsVHlwZS5wcmVjaXNpb27QIxAAXQAAAEcGAAASAAAA0CMQAF0AAABIBgAAFgAAAHJlY2VpdmVkIGVtcHR5IHVuaW9uIGZyb20gcmVtb3RlIFRpbWVVbml0cmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBUaW1lVW5pdHJldHVybiB2YWx1ZSBzaG91bGQgaGF2ZSBiZWVuIGNvbnN0cnVjdGVkVGltZXN0YW1wVHlwZS5pc19hZGp1c3RlZF90b191X3RfY1RpbWVzdGFtcFR5cGUudW5pdAAAANAjEABdAAAAYQcAACEAAADQIxAAXQAAAGIHAAARAAAAVGltZVR5cGUuaXNfYWRqdXN0ZWRfdG9fdV90X2NUaW1lVHlwZS51bml0AADQIxAAXQAAAKgHAAAhAAAA0CMQAF0AAACpBwAAEQAAAEludFR5cGUuYml0X3dpZHRoSW50VHlwZS5pc19zaWduZWQAANAjEABdAAAA8QcAABYAAADQIxAAXQAAAPIHAAAWAAAAcmVjZWl2ZWQgZW1wdHkgdW5pb24gZnJvbSByZW1vdGUgTG9naWNhbFR5cGVyZWNlaXZlZCBtdWx0aXBsZSBmaWVsZHMgZm9yIHVuaW9uIGZyb20gcmVtb3RlIExvZ2ljYWxUeXBlU2NoZW1hRWxlbWVudC5uYW1l0CMQAF0AAADKCgAAEQAAAERhdGFQYWdlSGVhZGVyLm51bV92YWx1ZXNEYXRhUGFnZUhlYWRlci5lbmNvZGluZ0RhdGFQYWdlSGVhZGVyLmRlZmluaXRpb25fbGV2ZWxfZW5jb2RpbmdEYXRhUGFnZUhlYWRlci5yZXBldGl0aW9uX2xldmVsX2VuY29kaW5n0CMQAF0AAABfCwAAFwAAANAjEABdAAAAYAsAABUAAADQIxAAXQAAAGELAAAmAAAA0CMQAF0AAABiCwAAJgAAAERhdGFQYWdlSGVhZGVybnVtX3ZhbHVlc2VuY29kaW5nZGVmaW5pdGlvbl9sZXZlbF9lbmNvZGluZ3JlcGV0aXRpb25fbGV2ZWxfZW5jb2RpbmdzdGF0aXN0aWNzSW5kZXhQYWdlSGVhZGVyRGljdGlvbmFyeVBhZ2VIZWFkZXIubnVtX3ZhbHVlc0RpY3Rpb25hcnlQYWdlSGVhZGVyLmVuY29kaW5nANAjEABdAAAA5AsAABcAAADQIxAAXQAAAOULAAAVAAAARGljdGlvbmFyeVBhZ2VIZWFkZXJpc19zb3J0ZWREYXRhUGFnZUhlYWRlclYyLm51bV92YWx1ZXNEYXRhUGFnZUhlYWRlclYyLm51bV9udWxsc0RhdGFQYWdlSGVhZGVyVjIubnVtX3Jvd3NEYXRhUGFnZUhlYWRlclYyLmVuY29kaW5nRGF0YVBhZ2VIZWFkZXJWMi5kZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aERhdGFQYWdlSGVhZGVyVjIucmVwZXRpdGlvbl9sZXZlbHNfYnl0ZV9sZW5ndGjQIxAAXQAAAHAMAAAXAAAA0CMQAF0AAABxDAAAFgAAANAjEABdAAAAcgwAABUAAADQIxAAXQAAAHMMAAAVAAAA0CMQAF0AAAB0DAAAKgAAANAjEABdAAAAdQwAACoAAABEYXRhUGFnZUhlYWRlclYybnVtX251bGxzbnVtX3Jvd3NkZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aHJlcGV0aXRpb25fbGV2ZWxzX2J5dGVfbGVuZ3RoaXNfY29tcHJlc3NlZFBhZ2VIZWFkZXIudHlwZV9QYWdlSGVhZGVyLnVuY29tcHJlc3NlZF9wYWdlX3NpemVQYWdlSGVhZGVyLmNvbXByZXNzZWRfcGFnZV9zaXpl0CMQAF0AAADBDgAAEgAAANAjEABdAAAAwg4AACMAAADQIxAAXQAAAMMOAAAhAAAAUGFnZUhlYWRlcnR5cGV1bmNvbXByZXNzZWRfcGFnZV9zaXplY29tcHJlc3NlZF9wYWdlX3NpemVjcmNkYXRhX3BhZ2VfaGVhZGVyaW5kZXhfcGFnZV9oZWFkZXJkaWN0aW9uYXJ5X3BhZ2VfaGVhZGVyZGF0YV9wYWdlX2hlYWRlcl92MktleVZhbHVlLmtleQAAANAjEABdAAAAJw8AABAAAABTb3J0aW5nQ29sdW1uLmNvbHVtbl9pZHhTb3J0aW5nQ29sdW1uLmRlc2NlbmRpbmdTb3J0aW5nQ29sdW1uLm51bGxzX2ZpcnN0AAAA0CMQAF0AAAB6DwAAFwAAANAjEABdAAAAew8AABcAAADQIxAAXQAAAHwPAAAYAAAAUGFnZUVuY29kaW5nU3RhdHMucGFnZV90eXBlUGFnZUVuY29kaW5nU3RhdHMuZW5jb2RpbmdQYWdlRW5jb2RpbmdTdGF0cy5jb3VudNAjEABdAAAAzg8AABYAAADQIxAAXQAAAM8PAAAVAAAA0CMQAF0AAADQDwAAEgAAANAjEABdAAAAVBAAACgAAADQIxAAXQAAAFcQAAARAAAA0CMQAF0AAABeEAAAJgAAANAjEABdAAAAYRAAABEAAADQIxAAXQAAAHgQAAAoAAAA0CMQAF0AAAB7EAAAEQAAANAjEABdAAAAkhAAADEAAADQIxAAXQAAAJUQAAARAAAAQ29sdW1uTWV0YURhdGEudHlwZV9Db2x1bW5NZXRhRGF0YS5lbmNvZGluZ3NDb2x1bW5NZXRhRGF0YS5wYXRoX2luX3NjaGVtYUNvbHVtbk1ldGFEYXRhLmNvZGVjQ29sdW1uTWV0YURhdGEubnVtX3ZhbHVlc0NvbHVtbk1ldGFEYXRhLnRvdGFsX3VuY29tcHJlc3NlZF9zaXplQ29sdW1uTWV0YURhdGEudG90YWxfY29tcHJlc3NlZF9zaXplQ29sdW1uTWV0YURhdGEuZGF0YV9wYWdlX29mZnNldADQIxAAXQAAALoQAAASAAAA0CMQAF0AAAC7EAAAFgAAANAjEABdAAAAvBAAABsAAADQIxAAXQAAAL0QAAASAAAA0CMQAF0AAAC+EAAAFwAAANAjEABdAAAAvxAAACQAAADQIxAAXQAAAMAQAAAiAAAA0CMQAF0AAADCEAAAHQAAANAjEABdAAAAcxEAACYAAADQIxAAXQAAAHYRAAARAAAARW5jcnlwdGlvbldpdGhDb2x1bW5LZXkucGF0aF9pbl9zY2hlbWEAANAjEABdAAAAiBEAABsAAAByZWNlaXZlZCBlbXB0eSB1bmlvbiBmcm9tIHJlbW90ZSBDb2x1bW5DcnlwdG9NZXRhRGF0YXJlY2VpdmVkIG11bHRpcGxlIGZpZWxkcyBmb3IgdW5pb24gZnJvbSByZW1vdGUgQ29sdW1uQ3J5cHRvTWV0YURhdGFDb2x1bW5DaHVuay5maWxlX29mZnNldADQIxAAXQAAAG8SAAAYAAAA0CMQAF0AAADpEgAAKwAAANAjEABdAAAA7BIAABEAAADQIxAAXQAAAPsSAAAtAAAA0CMQAF0AAAD+EgAAEQAAAFJvd0dyb3VwLmNvbHVtbnNSb3dHcm91cC50b3RhbF9ieXRlX3NpemVSb3dHcm91cC5udW1fcm93cwAAANAjEABdAAAAGhMAABQAAADQIxAAXQAAABsTAAAcAAAA0CMQAF0AAAAcEwAAFQAAAHJlY2VpdmVkIGVtcHR5IHVuaW9uIGZyb20gcmVtb3RlIENvbHVtbk9yZGVycmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBDb2x1bW5PcmRlclBhZ2VMb2NhdGlvbi5vZmZzZXRQYWdlTG9jYXRpb24uY29tcHJlc3NlZF9wYWdlX3NpemVQYWdlTG9jYXRpb24uZmlyc3Rfcm93X2luZGV4AADQIxAAXQAAAP8TAAATAAAA0CMQAF0AAAAAFAAAIQAAANAjEABdAAAAARQAABwAAADQIxAAXQAAAEIUAAAsAAAA0CMQAF0AAABFFAAAEQAAANAjEABdAAAATBQAACMAAADQIxAAXQAAAE8UAAARAAAAT2Zmc2V0SW5kZXgucGFnZV9sb2NhdGlvbnMAANAjEABdAAAAXRQAABsAAADQIxAAXQAAANgUAAAkAAAA0CMQAF0AAADbFAAAEQAAANAjEABdAAAA4hQAACcAAADQIxAAXQAAAOUUAAARAAAA0CMQAF0AAADsFAAAJwAAANAjEABdAAAA7xQAABEAAADQIxAAXQAAAPoUAAAjAAAA0CMQAF0AAAD9FAAAEQAAANAjEABdAAAABBUAACMAAADQIxAAXQAAAAcVAAARAAAA0CMQAF0AAAAOFQAAIwAAANAjEABdAAAAERUAABEAAABDb2x1bW5JbmRleC5udWxsX3BhZ2VzQ29sdW1uSW5kZXgubWluX3ZhbHVlc0NvbHVtbkluZGV4Lm1heF92YWx1ZXNDb2x1bW5JbmRleC5ib3VuZGFyeV9vcmRlctAjEABdAAAAIhUAABcAAADQIxAAXQAAACMVAAAXAAAA0CMQAF0AAAAkFQAAFwAAANAjEABdAAAAJRUAABsAAAByZWNlaXZlZCBlbXB0eSB1bmlvbiBmcm9tIHJlbW90ZSBFbmNyeXB0aW9uQWxnb3JpdGhtcmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBFbmNyeXB0aW9uQWxnb3JpdGhtAADQIxAAXQAAAMcWAAAtAAAA0CMQAF0AAADKFgAAEQAAANAjEABdAAAA1RYAACgAAADQIxAAXQAAANgWAAARAAAA0CMQAF0AAADfFgAAKAAAANAjEABdAAAA4hYAABEAAADQIxAAXQAAAO0WAAArAAAA0CMQAF0AAADwFgAAEQAAAEZpbGVNZXRhRGF0YS52ZXJzaW9uRmlsZU1ldGFEYXRhLnNjaGVtYUZpbGVNZXRhRGF0YS5udW1fcm93c0ZpbGVNZXRhRGF0YS5yb3dfZ3JvdXBzANAjEABdAAAACRcAABQAAADQIxAAXQAAAAoXAAATAAAA0CMQAF0AAAALFwAAFQAAANAjEABdAAAADBcAABcAAAAAAAAABAAAAAQAAACFAgAATUlMTElTAAAAAAAABAAAAAQAAACGAgAATUlDUk9TAAAAAAAABAAAAAQAAACHAgAATkFOT1MAAADahxAAaAAAAF0DAAARAAAATmFub1NlY29uZHNNaWNyb1NlY29uZHNNaWxsaVNlY29uZHMA3I4QAGQAAAAJAAAACAAAANkEAAA4AAAABAAAANoEAADZBAAAOAAAAAQAAADbBAAA7FMQAGoAAACcAAAAEgAAAOxTEABqAAAApQAAAA0AAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAEJFEABoAAAAQAEAAEMAAABJbnZhbGlkIERhdGFCRRAAaAAAAAgBAABBAAAAQkUQAGgAAAAKAQAAOAAAAEJFEABoAAAACgEAACAAAAC+nCqRkTY0YMVIQBcRDps0e7I8HJu1h/yBm9JjW7WZ7uP/1pgFyn5aa9XhHolAKiRtaWQgPiBsZW4AAABsEBQACQAAAGZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgCAEBQAGwAAACUAAAACAAAAnBAUAO8nEABrAAAA4wEAAA4AAABjYW5ub3QgcmVjdXJzaXZlbHkgYWNxdWlyZSBtdXRleMAQFAAgAAAAtC8QAHwAAAATAAAACQAAACgpAADXMhAAeAAAAOsHAAAJAAAAZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheckgGuicZTtMR0lZw82Iv4xV8+nEOaizMm8aTlBX3KIqAAAAAAAAAAABAAAA3AQAAN0EAAAIAAAABAAAAN4EAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAN8EAAAIAAAABAAAAOAEAEG4o9AAC4UGAQAAAOEEAABSZWFjaGVkIEVPRk91dHB1dFRvb1NtYWxsTGF5b3V0RXJyb3IAAAAABAAAAAQAAADiBAAAAAAAAAQAAAAEAAAAMQAAAGV4cGVjdGVkYWN0dWFsTGl0ZXJhbE91dE9mQm91bmRzRXhwZWN0ZWRBbm90aGVyQnl0ZU9mZnNldE91dE9mQm91bmRz7FMQAGoAAAC5AQAABQAAAOxTEABqAAAAvQEAAAUAAADsUxAAagAAAMEBAAAFAAAA7FMQAGoAAADUAQAAEgAAAOxTEABqAAAA2gEAABIAAADsUxAAagAAAHYCAAAiAAAA7FMQAGoAAAAvBwAAHwAAAOxTEABqAAAAMgcAAA0AAADsUxAAagAAABUHAAAkAAAA7FMQAGoAAAAVBwAAGQAAAOxTEABqAAAAEggAABYAAADsUxAAagAAAJIIAAAcAAAA7FMQAGoAAACbCAAALgAAAOxTEABqAAAAuQgAABoAAADsUxAAagAAALoIAAAZAAAA7FMQAGoAAACnCAAAJwAAAOxTEABqAAAA0gkAABIAAADsUxAAagAAANgJAAASAAAA7FMQAGoAAADfCQAADgAAAOxTEABqAAAA5gkAABIAAADsUxAAagAAAOwJAAASAAAA7FMQAGoAAAD1CQAAEgAAAOxTEABqAAAA+wkAABIAAADsUxAAagAAAAIKAAAOAAAA7FMQAGoAAADvAAAACQAAAOxTEABqAAAA9AAAAAkAAADsUxAAagAAAPkAAAAJAAAA7FMQAGoAAAAMAQAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGluc2VydHMubGVuKCkgPD0gbWJfbGVuAAAA7FMQAGoAAAAUAQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvcHlfbGVuID49IDQA7FMQAGoAAAA8AQAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvcHlfbGVuIDwgMjUA7FMQAGoAAAA9AQAADQAAAAAAAAAKCgsLCgoKCgoJCQgHBwgHBwYGBQUAQdWp0AALjAQQAAAAJAAAAFQAAACMAAAArAAAANAAAAD4AAAAJAEAAFQBAABuAQAAigEAAJkBAAChAQCAqQEAgLsBAADFAQAAzwEAQNQBAMDZAQCg3AEA7FMQAGoAAABEAQAALgAAAOxTEABqAAAAZAEAABEAAADsUxAAagAAAFgBAAA0AAAA7FMQAGoAAABVAQAAEQAAAOxTEABqAAAAhQEAACIAAADsUxAAagAAAJMBAAAiAAAA7FMQAGoAAAAnAQAAIgAAAOxTEABqAAAALQoAABYAAADsUxAAagAAAEMKAAAgAAAA7FMQAGoAAABKCgAAMwAAAOxTEABqAAAASAkAABYAAADsUxAAagAAAGkHAAAiAAAA7FMQAGoAAABqBwAAIgAAAOxTEABqAAAAegcAABEAAADsUxAAagAAAHsHAAARAAAA7FMQAGoAAADKBwAAIgAAAOxTEABqAAAAywcAACIAAADsUxAAagAAANkHAAAjAAAA7FMQAGoAAADeBwAAEQAAAOxTEABqAAAA3wcAABEAAADsUxAAagAAAFYHAAAWAAAA7FMQAGoAAABaBwAAMgAAAOxTEABqAAAAWwcAADAAAADsUxAAagAAAIMAAAAkAAAA7FMQAGoAAADwCgAADAAAAOxTEABqAAAA8AoAADYAAADsUxAAagAAAPMKAAAMAAAA7FMQAGoAAADzCgAANgBB9K3QAAvhLOxTEABqAAAAvAMAABwAAADsUxAAagAAAOADAAAVAAAA7FMQAGoAAADhAwAAFQAAAOxTEABqAAAAOQQAAB0AAADsUxAAagAAAD0EAAAiAAAA7FMQAGoAAABGBAAAFQAAAOxTEABqAAAATgQAABkAAADsUxAAagAAAGIEAAAZAAAA7FMQAGoAAABZBAAAHQAAAOxTEABqAAAAKgQAABQAAADsUxAAagAAABcEAAAUAAAA7FMQAGoAAAAXBAAAMQAAAOxTEABqAAAA6AMAACAAAADsUxAAagAAAOkDAAAkAAAA7FMQAGoAAADxAwAAIAAAAOxTEABqAAAA8gMAACQAAADsUxAAagAAAPoDAAAtAAAA7FMQAGoAAAD8AwAALwAAAOxTEABqAAAAAQQAAB0AAADsUxAAagAAAM0DAAAYAAAA7FMQAGoAAADSAwAAHQAAAOxTEABqAAAAzwMAAB0AAADsUxAAagAAALgDAAAJAAAA7FMQAGoAAAC5AwAACQAAAOxTEABqAAAArAMAAAwAAAAAAQIDAAAAAAAAAQEBAQEBAAAAAP8B/gL9A/8B/gL9A3BHEABvAAAAwAIAACQAAABwRxAAbwAAAN0CAAAkAAAAcEcQAG8AAADjAgAAIAAAAHBHEABvAAAA5AIAACAAAABwRxAAbwAAAPACAAAdAAAAcEcQAG8AAAACAwAAKAAAAHBHEABvAAAAJAMAADUAAABwRxAAbwAAAAkCAAAjAAAAcEcQAG8AAABbAgAABQAAAHBHEABvAAAAkwQAAAUAAABwRxAAbwAAAKMEAAARAAAAcEcQAG8AAACkBAAAGQAAAHBHEABvAAAArgQAACIAAABwRxAAbwAAAMYEAABAAAAAcEcQAG8AAABPAgAABQAAAHBHEABvAAAAVwEAAAwAAABwRxAAbwAAAFcBAAAjAAAAcEcQAG8AAABYAQAAEAAAAHBHEABvAAAAWAEAADcAAABwRxAAbwAAAF4BAAAnAAAAcEcQAG8AAABuAQAAFQAAAHBHEABvAAAAegEAABYAAABhc3NlcnRpb24gZmFpbGVkOiBwYXJhbXMudXNlX2RpY3Rpb25hcnkAcEcQAG8AAACAAQAADQAAAHBHEABvAAAAigEAAC8AAABwRxAAbwAAAD4AAAAJAAAAcEcQAG8AAAC3AQAADwAAAHBHEABvAAAAPwIAABMAAABwRxAAbwAAAEYDAAAMAAAAcEcQAG8AAABLAwAAEwAAAHBHEABvAAAATQMAAAkAAABwRxAAbwAAAGECAAAJAAAAcEcQAG8AAABVAgAACQAAAHBHEABvAAAAwQEAAAkAAABwRxAAbwAAAMEBAAArAAAAcEcQAG8AAAB1BAAADQAAAHBHEABvAAAAeAQAACIAAABwRxAAbwAAAHkEAAARAAAAcEcQAG8AAABDBAAAKAAAAHBHEABvAAAASQQAACUAAABwRxAAbwAAAE4EAAAlAAAAcEcQAG8AAABUBAAAGwAAAHBHEABvAAAA7QAAAB8AAABwRxAAbwAAAPkAAAANAAAAcEcQAG8AAADxAAAALQAAAHBHEABvAAAAeQMAAAUAAABwRxAAbwAAAJUDAAAiAAAAcEcQAG8AAABdBQAAGQAAAHBHEABvAAAAEAUAAB4AAABwRxAAbwAAABMFAAAyAAAAcEcQAG8AAAAtBQAAKQAAAHBHEABvAAAANQUAAA0AAABwRxAAbwAAADgFAAAjAAAAcEcQAG8AAAA8BQAAFQAAAHBHEABvAAAASQUAABoAAAAxcxAAXwAAAOcCAAAfAAAAMXMQAF8AAADoAgAAJQAAADFzEABfAAAA6AIAAA4AAAAxcxAAXwAAAO0CAAAJAAAAMXMQAF8AAADxAgAACQAAADFzEABfAAAAAQMAACcAAAAxcxAAXwAAAAEDAABVAAAAMXMQAF8AAAABAwAAPgAAADFzEABfAAAABgMAACMAAAAxcxAAXwAAAAcDAAApAAAAMXMQAF8AAAAHAwAAEgAAADFzEABfAAAA/AIAACMAAAAxcxAAXwAAAPwCAABPAAAAMXMQAF8AAAD8AgAAOAAAADFzEABfAAAACgMAABIAAAAxcxAAXwAAAA4DAAAFAAAAMXMQAF8AAAAPAwAAEgAAADFzEABfAAAAEwMAAAUAAAAxcxAAXwAAANoCAAAfAAAAMXMQAF8AAADaAgAATQAAADFzEABfAAAA2gIAADYAAAAxcxAAXwAAAJEGAAAWAAAAMXMQAF8AAADAAgAAHQAAADFzEABfAAAAwAIAAEkAAAAxcxAAXwAAAMACAAAlAAAAMXMQAF8AAADGAgAABQAAADFzEABfAAAAxwIAAAUAAAAxcxAAXwAAAMkCAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogIXBhcmFtcy5jYXRhYmxlAAAAMXMQAF8AAACaBwAACQAAADFzEABfAAAAwwcAAAsAAAAxcxAAXwAAALIIAAANAAAAMXMQAF8AAACzCAAADQAAADFzEABfAAAAvQgAACQAAAAxcxAAXwAAAL4IAAAZAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5sYXN0X3Byb2Nlc3NlZF9wb3NfIDwgMiB8fCBzZWxmLmN1c3RvbV9kaWN0aW9uYXJ5MXMQAF8AAADLCAAADQAAADFzEABfAAAAzwgAAD4AAAAxcxAAXwAAAN4IAAAkAAAAMXMQAF8AAADfCAAAGQAAADFzEABfAAAA4ggAACMAAAAxcxAAXwAAAOUIAAAnAAAAMXMQAF8AAAAJCQAAPgAAADFzEABfAAAAFAkAACIAAAAxcxAAXwAAACMJAAAiAAAAMXMQAF8AAAAuCQAAJAAAADFzEABfAAAALwkAABkAAAAxcxAAXwAAAEIJAAAtAAAAMXMQAF8AAABDCQAAQgAAADFzEABfAAAATwkAADYAAAAxcxAAXwAAAGYJAAA2AAAAMXMQAF8AAABtCQAALAAAADFzEABfAAAAigkAAA0AAAAxcxAAXwAAAJsJAAA6AAAAMXMQAF8AAACyCQAAIAAAADFzEABfAAAAswkAABUAAAAxcxAAXwAAALkJAAA5AAAAMXMQAF8AAAC8CQAAFQAAADFzEABfAAAAwAkAABUAAAAxcxAAXwAAAFsLAABPAAAAMXMQAF8AAABGCgAAJgAAADFzEABfAAAARwoAACcAAAAxcxAAXwAAAEYKAAA6AAAAMXMQAF8AAAA2CgAAIwAAADFzEABfAAAAOAoAACsAAAAxcxAAXwAAADcKAAAaAAAAMXMQAF8AAABgAQAAIQAAADFzEABfAAAAcgEAABgAAAAxcxAAXwAAAHQBAAAcAAAAMXMQAF8AAAC2CgAAMgAAADFzEABfAAAAvAoAABEAAAAxcxAAXwAAAL0KAAARAAAAMXMQAF8AAADDCgAAKQAAADFzEABfAAAA0goAACkAAAAxcxAAXwAAAOwKAAAkAAAAMXMQAF8AAADtCgAAGQAAADFzEABfAAAA0QkAAAkAAAAxcxAAXwAAANIJAAAJAAAAMXMQAF8AAAAqAwAAPwAAADFzEABfAAAA/gUAADIAAAAxcxAAXwAAAAMGAAAJAAAAMXMQAF8AAAAFBgAADQAAADFzEABfAAAACAYAAA0AAAAxcxAAXwAAAB8GAAAeAAAAMXMQAF8AAAAgBgAANQAAADFzEABfAAAAIAYAABIAAACPFRAAYQAAAF8AAAANAAAAjxUQAGEAAABqAAAAHwAAAI8VEABhAAAAawAAAB8AAACPFRAAYQAAAGwAAAAfAAAAjxUQAGEAAAB2AAAAHAAAAIR2EABiAAAAnQAAABYAAACEdhAAYgAAAIcAAAANAAAAhHYQAGIAAACIAAAADQAAAIR2EABiAAAAfQAAAA0AAACEdhAAYgAAAH8AAAANAAAAhHYQAGIAAACjAAAADQAAAIR2EABiAAAApQAAAA0AAADndhAAWwAAAAcBAAAYAAAAZ3ppcCBoZWFkZXIgZmllbGQgdG9vIGxvbmcAAOd2EABbAAAAogAAADIAAADndhAAWwAAAKoAAAA8AAAAzEIQAF4AAAAoAAAAHQAAAMxCEABeAAAALgAAABYAAADMQhAAXgAAAGIAAAAVAAAAVSUQAGgAAABnAQAAOgAAAM51EABqAAAAvQEAAB0AAABFWxAAXAAAACcAAAANAAAARVsQAFwAAABtAAAAHAAAAEZuEABnAAAAZAAAABQAAABGbhAAZwAAAGUAAAAOAAAARm4QAGcAAABnAAAADgAAAEZuEABnAAAAQwAAABQAAABGbhAAZwAAAEQAAAAOAAAARm4QAGcAAABGAAAADgAAAFUlEABoAAAAvwAAADsAAABVJRAAaAAAABUBAAA5AAAAVSUQAGgAAAApAQAAIgAAAFUlEABoAAAAHAEAADEAAABVJRAAaAAAAB0BAAApAAAAVSUQAGgAAAAhAQAAIgAAAFUlEABoAAAAAgEAACIAAABVJRAAaAAAAFIBAAAhAAAAVSUQAGgAAACHAAAAKAAAAFUlEABoAAAAnwAAABIAAABVJRAAaAAAAKAAAAASAAAAVSUQAGgAAAC9AQAACwAAAFUlEABoAAAAvwEAAAsAAADjBAAANAAAAAQAAADkBAAA3ZcQAGAAAABUAAAAHwAAAN2XEABgAAAAfQAAABsAAADEOxAAcQAAACYAAAARAAAAZW5jb3VudGVyZWQgbm9uIFVURi04IGRhdGEAAMQ7EABxAAAASwAAABUAAADEOxAAcQAAAFAAAAAWAAAAxDsQAHEAAABoAAAAIAAAAMQ7EABxAAAAbAAAACcAAABkaWN0aW9uYXJ5IGtleSBiZXlvbmQgYm91bmRzIG9mIGRpY3Rpb25hcnk6IDAuLgAgJRQALwAAAMQ7EABxAAAAeQAAADEAAADEOxAAcQAAAJUAAAAJAAAAxDsQAHEAAACXAAAADgAAAMQ7EABxAAAAuQAAAB4AAABhc3NlcnRpb24gZmFpbGVkOiBsZXZlbF9wb3MgPj0gdmFsdWVfcG9zxDsQAHEAAACkAAAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxldmVsX3BvcyA8IGxhc3RfcG9zAADEOxAAcQAAAKUAAAANAAAAxDsQAHEAAACnAAAAJQAAAMQ7EABxAAAAqwAAACIAAADEOxAAcQAAALMAAAAUAAAAAQAAAG1heCByZXBldGl0aW9uIGxldmVsIG11c3QgYmUgMCB0byBvbmx5IGNvbXB1dGUgbnVsbCBiaXRtYXNrADwmFAA7AAAAjykQAHwAAABBAAAAEQAAAG1heCBkZWZpbml0aW9uIGxldmVsIG11c3QgYmUgMSB0byBvbmx5IGNvbXB1dGUgbnVsbCBiaXRtYXNrAJAmFAA7AAAAjykQAHwAAAA7AAAAEQAAAI8pEAB8AAAAnQAAABEAAACPKRAAfAAAAKMAAAAhAAAAjykQAHwAAACqAAAAEQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGluY29uc2lzdGVudCBudWxsIG1hc2sUJxQAQAAAAI8pEAB8AAAAsgAAABIAAAB1bmV4cGVjdGVkIGVuZCBvZiBmaWxlIHdoaWxzdCBkZWNvZGluZyBkZWZpbml0aW9uIGxldmVscyBybGUgdmFsdWV0b28gbWFueSBieXRlcyBmb3IgVkxRdW5leHBlY3RlZCBlbmQgb2YgZmlsZSB3aGlsc3QgZGVjb2RpbmcgZGVmaW5pdGlvbiBsZXZlbHMgcmxlIGhlYWRlcmludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGludmFsaWQgbGV2ZWwgZW5jb2Rpbmc6IAAAAAcoFABCAAAAjykQAHwAAAAZAQAAEgAAAGVuY291bnRlcmVkIG5vbiBVVEYtOCBkYXRhOiBkKBQAHAAAAGZpcnN0IHJlcGV0aXRpb24gbGV2ZWwgb2YgYmF0Y2ggbXVzdCBiZSAwAAAAPAcQAHQAAACAAAAAMQAAADwHEAB0AAAAxQAAAD4AAAA8BxAAdAAAAMUAAAAWAAAAPAcQAHQAAADfAAAADQAAANkEAAA4AAAABAAAAOUEAADmBAAA5wQAAOgEAADpBAAA6gQAAOsEAADsBAAA7QQAAO4EAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABGYWlsZWQgdG8gcmVjb25zdHJ1Y3QgbGlzdCBmcm9tIGxldmVsIGRhdGFvZmZzZXQgb2YgIHdvdWxkIG92ZXJmbG93IGxpc3QgYXJyYXkAAHYpFAAKAAAAgCkUABoAAADZBAAAOAAAAAQAAAD4BAAA+QQAAPoEAAD7BAAA6QQAAPwEAAD9BAAA/gQAAO0EAADuBAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAaXRlbV9yZWFkZXIgZGVmIGxldmVscyBhcmUgTm9uZS5pdGVtX3JlYWRlciByZXAgbGV2ZWxzIGFyZSBOb25lLjwHEAB0AAAApgAAAEoAAAA8BxAAdAAAAKYAAAAiAAAARW5jb3VudGVyZWQgcmVwZXRpdGlvbiBsZXZlbCB0b28gbGFyZ2UgZm9yIGRlZmluaXRpb24gbGV2ZWxTdHJ1Y3RBcnJheVJlYWRlciBvdXQgb2Ygc3luYyBpbiByZWFkX3JlY29yZHMsIGV4cGVjdGVkICByZWFkLCBnb3QgAACfKhQAOAAAANcqFAALAAAATm90IGFsbCBjaGlsZHJlbiBhcnJheSBsZW5ndGggYXJlIHRoZSBzYW1lIWNoaWxkIHdpdGggbnVsbGFibGUgcGFyZW50cyBtdXN0IGhhdmUgZGVmaW5pdGlvbiBsZXZlbAAAAB8IEAB2AAAAjwAAABIAAAAfCBAAdgAAAJcAAAAVAAAA4wQAADQAAAAEAAAAhwEAAP8EAACJAQAAAAUAAAEFAACMAQAAAgUAAAMFAACPAQAA7gQAAJEBAACSAQAAkwEAAJQBAACVAQAAlgEAAJcBAACYAQAAmQEAAEZhaWxlZCB0byBkZWNvZGUgbGV2ZWwgZGF0YSBmb3Igc3RydWN0IGFycmF5U3RydWN0IGFycmF5IHJlYWRlciBzaG91bGQgaGF2ZSBhdCBsZWFzdCBvbmUgY2hpbGQhU3RydWN0QXJyYXlSZWFkZXIgb3V0IG9mIHN5bmMsIGV4cGVjdGVkICBza2lwcGVkLCBnb3QgAAAALywUACgAAABXLBQADgAAAExaNFJhd0NvZGVjIHVuc3VwcG9ydGVkIHdpdGhvdXQgdW5jb21wcmVzc19zaXplAOpMEABiAAAAZQIAABgAAADqTBAAYgAAAGYCAABOAAAATFo0UmF3Q29kZWMgdW5jb21wcmVzc19zaXplIGlzIG5vdCB0aGUgZXhwZWN0ZWQgb25lAAAAAAAMAAAABAAAAAQFAAAAAAAADAAAAAQAAAAFBQAABAUAAPwsFAAGBQAABwUAAAgFAAAGBQAACQUAAOpMEABiAAAAdgIAABgAAADqTBAAYgAAAHcCAABMAEHg2tAACwYBAAAACgUAQfDa0AALkg4BAAAACwUAAAoFAABYLRQADAUAAA0FAAAOBQAADAUAAA8FAADqTBAAYgAAALgCAAApAAAA6kwQAGIAAAC7AgAAKQAAAOpMEABiAAAAygIAADEAAABOb3QgYWxsIGlucHV0IGFyZSBjb25zdW1lZAAA6kwQAGIAAADUAgAAJQAAAFVuZXhwZWN0ZWQgZGVjb21wcmVzc2VkIHNpemVOb3QgZW5vdWdoIGJ5dGVzIHRvIGhvbGQgYWR2ZXJ0aXNlZCBvdXRwdXROb3QgZW5vdWdoIGJ5dGVzIGZvciBIYWRvb3AgZnJhbWVMWjRIYWRvb3BDb2RlYyB1bnN1cHBvcnRlZCB3aXRob3V0IHVuY29tcHJlc3Nfc2l6ZQAAAOpMEABiAAAA8AIAABgAAADqTBAAYgAAAPECAABDAAAATFo0SGFkb29wQ29kZWMgdW5jb21wcmVzc19zaXplIGlzIG5vdCB0aGUgZXhwZWN0ZWQgb25lAADqTBAAYgAAAA8DAAAYAAAA6kwQAGIAAAAWAwAALQAAAOpMEABiAAAAGgMAABcAAADqTBAAYgAAABsDAAAXAAAAc3RyaW5nIHZpZXcgYXJyYXkAAAA6GRAAXwAAAG4DAAAhAAAAZml4ZWQgc2l6ZSBsaXN0IGFycmF5AAAAOhkQAF8AAACyAwAADgAAAG1hcCBhcnJheQAAADoZEABfAAAAugMAABsAAABsaXN0IGFycmF5AAA6GRAAXwAAAJgDAAAcAAAAWpYQAGIAAAAyAAAAFQAAAGZhaWxlZCB0byB3cml0ZSB3aG9sZSBidWZmZXK4LxQAHAAAABcAAAACAAAA1C8UAK5+EABpAAAAMQcAACQAAABuERAAawAAAFgAAAAOAAAAHprAvv5ieL98GMLX7yHypwAAAAAEAAAABAAAABEFAAAAAAAABAAAAAQAAABHAgAAPmcQAH8AAADGAAAAJwAAAD5nEAB/AAAAFgIAAC8AAAA+ZxAAfwAAAKEAAAAkAAAAEgUAAAwAAAAEAAAAKQAAABIFAAAMAAAABAAAACoAAAApAAAAaDAUABMFAAAUBQAALQAAABUFAAAWBQAATm9uZQAAAAAEAAAABAAAACoCAABTb21lAAAAAAQAAAAEAAAAFwUAAGxyEABnAAAAZwAAADAAAABschAAZwAAAGgAAABGAAAAbHIQAGcAAABuAAAAFQAAAGxyEABnAAAATwAAACgAAABschAAZwAAAF4AAAANAAAAV291bGRCbG9jawAAznUQAGoAAAC9AQAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYucG9zIDw9IHNlbGYuZHN0LmNhcGFjaXR5KCkAAABdlBAAWwAAALUGAAAJAAAAR2l2ZW4gcG9zaXRpb24gb3V0c2lkZSBvZiB0aGUgYnVmZmVyIGJvdW5kcy5dlBAAWwAAAMkGAAANAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5kYXRhLmlzX3NvbWUoKQAAAB5qEABgAAAA3gAAAAkAAAC/fRAAbQAAAEgEAAAiAAAASW52YWxpZCBjb2x1bW4gaW5kZXggLCBjb2x1bW4gd2FzIG5vdCBmZXRjaGVkAAAAADIUABUAAAAVMhQAGAAAABgFAABIAAAACAAAABkFAAAaBQAAGwUAABwFAAAdBQAAHgUAAB8FAAAgBQAAIQUAABgAAAAIAAAAIgUAABoFAAAjBQAAJAUAAL99EABtAAAAUQQAACIAAAC/fRAAbQAAAFEEAAA6AAAASW52YWxpZCBvZmZzZXQgaW4gc3BhcnNlIGNvbHVtbiBjaHVuayBkYXRhOiCoMhQALAAAAKM9EABsAAAA6QAAADYAAACrRRAAawAAADACAAArAAAAQk9PTEVBTklOVDMySU5UNjRJTlQ5NkZMT0FURE9VQkxFQllURV9BUlJBWUZJWEVEX0xFTl9CWVRFX0FSUkFZTk9ORVVURjhNQVBNQVBfS0VZX1ZBTFVFTElTVEVOVU1ERUNJTUFMREFURVRJTUVfTUlMTElTVElNRV9NSUNST1NUSU1FU1RBTVBfTUlMTElTVElNRVNUQU1QX01JQ1JPU1VJTlRfOFVJTlRfMTZVSU5UXzMyVUlOVF82NElOVF84SU5UXzE2SU5UXzMySU5UXzY0SlNPTkJTT05JTlRFUlZBTAAAEwwQAH4AAADUAAAAQAAAABMMEAB+AAAA2gAAADUAAAATDBAAfgAAANsAAAA1AAAAEwwQAH4AAADmAAAAOAAAACUFAAAMCAAABAAAACYFAAAnBQAAAAAAAAQAAAAEAAAAKAUAACkFAAAAAAAABAAAAAQAAAAqBQAAKwUAAAAAAAABAAAAAQAAACwFAAAtBQAAAAAAAAQAAAAEAAAALgUAAC8FAEGM6dAAC/0IAQAAADAFAAAxBQAAVGhlIGNvZGVjIHR5cGUgIGlzIG5vdCBzdXBwb3J0ZWQgeWV0mDQUAA8AAACnNBQAFQAAAAAAAAAEAAAABAAAAEkCAABHemlwTGV2ZWxCcm90bGlMZXZlbAAAAAAEAAAABAAAAG0DAABac3RkTGV2ZWwAAADugRAAbQAAAF4CAABBAAAAMgUAACQAAAAEAAAAMwUAAAAAAAABAAAAAQAAADQFAAAAAAAABAAAAAQAAAA1BQAAUHJpbWl0aXZlVHlwZWJhc2ljX2luZm9waHlzaWNhbF90eXBldHlwZV9sZW5ndGhzY2FsZXByZWNpc2lvbgAAAAAAAAAEAAAABAAAADYFAABHcm91cFR5cGVmaWVsZHMAEgUAAAwAAAAEAAAANwUAAAAAAAABAAAAAQAAADgFAAAAAAAAAQAAAAEAAAA5BQAAAAAAAAwAAAAEAAAAOgUAAAAAAAAEAAAABAAAADsFAABCYXNpY1R5cGVJbmZvbmFtZXJlcGV0aXRpb25jb252ZXJ0ZWRfdHlwZWxvZ2ljYWxfdHlwZWlkAAAAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAcAAAAFAAAABQAAAAUAAAAFAAAABgAAAAoAAAAUAAAA/DIUAAMzFAAIMxQADTMUABIzFAAXMxQAHTMUACczFAAEAAAABAAAAAMAAAANAAAABAAAAAQAAAAHAAAABAAAAAsAAAALAAAAEAAAABAAAAAGAAAABwAAAAcAAAAHAAAABQAAAAYAAAAGAAAABgAAAAQAAAAEAAAACAAAADszFAA/MxQAQzMUAEYzFABTMxQAVzMUAFszFABiMxQAZjMUAHEzFAB8MxQAjDMUAJwzFACiMxQAqTMUALAzFAC3MxQAvDMUAMIzFADIMxQAzjMUANIzFADWMxQAHprAvv5ieL98GMLX7yHypzwFAAAMAAAABAAAACkAAAA8BQAADAAAAAQAAAAqAAAAKQAAAGA3FAA9BQAAPgUAAC0AAAA9BQAAPwUAAM51EABqAAAAvQEAAB0AAAAAAAAACAAAAAQAAABABQAAAAAAAAQAAAAEAAAAQQUAAAAAAAAEAAAABAAAAEIFAABVdGY4RXJyb3J2YWxpZF91cF90b2Vycm9yX2xlbk5vbmUAAAAAAAAABAAAAAQAAABDBQAAU29tZXpzdGQgcmV0dXJuZWQgbnVsbCBwb2ludGVyIHdoZW4gY3JlYXRpbmcgbmV3IGNvbnRleHRdlBAAWwAAAPMAAAAOAAAAYmFkIGVycm9yIG1lc3NhZ2UgZnJvbSB6c3RkAF2UEABbAAAAOgMAAAoAAABdlBAAWwAAAGcDAAAOAAAAR2l2ZW4gcG9zaXRpb24gb3V0c2lkZSBvZiB0aGUgYnVmZmVyIGJvdW5kcy5dlBAAWwAAABkHAAANAAAAyhkQAIEAAAA4AAAAGwAAAFVuc3VwcG9ydGVkIHFzb3J0IGl0ZW0gc2l6ZQDEUhAAawAAABUAAAASAEGU8tAAC5IDazgHAA2yBwCc8gcAcGQIAGCuCgCwcQsAMKoMAAAAAAABAAAAAwAAAAcAAAAPAAAAHwAAAD8AAAB/AAAA/wAAAP8BAAD/AwAA/wcAAP8PAAD/HwAA/z8AAP9/AAD//wAA//8BAP//AwD//wcA//8PAP//HwD//z8A//9/AP///wD///8B////A////wf///8P////H////z////9/AAAAAAEAAAADAAAABwAAAA8AAAAfAAAAPwAAAH8AAAD/AAAA/wEAAP8DAAD/BwAA/w8AAP8fAAD/PwAA/38AAP//AAD//wEA//8DAP//BwD//w8A//8fAP//PwD//38A////AP///wH///8D////B////w////8f////P////39EBQAARAUAAEUFAABGBQAARwUAAEgFAABJBQAASgUAAEsFAABMBQAATQUAAE0FAABOBQAATwUAAFAFAABRBQAAUgUAAFMFAABUBQAAVAUAAFUFAABVBQAAVgUAAFcFAABYBQAAWQUAAFoFAABbBQAAXAUAAFwFAEG09dAACwpdBQAAXgUAAF8FAEHQ9dAAC+oDYAUAAGEFAABiBQAAYwUAAGQFAABlBQAAZgUAAGcFAABoBQAAaQUAAGoFAABrBQAAAAECAwQFBgcICQoLDA0ODxAQERESEhMTFBQUFBUVFRUWFhYWFhYWFhcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGAABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICAhISIiIyMkJCQkJSUlJSYmJiYmJiYmJycnJycnJycoKCgoKCgoKCgoKCgoKCgoKSkpKSkpKSkpKSkpKSkpKSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqBAADAAIAAgACAAIAAgACAAIAAgACAAIAAgABAAEAAQACAAIAAgACAAIAAgACAAIAAgADAAIAAQABAAEAAQABAP//////////AAAAAAAAAAABAAEAAQABAAEAAQACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD/////////////AAAAAAAAAQAEAAMAAgACAAIAAgACAAIAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD//////////////////wBB0PnQAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQZD60AALFQEBAQECAgMDBAQFBwgJCgsMDQ4PEABBsfrQAAslIAAAACAAAABAAAAAgAAAAIAAAACAAAAAgAAAAIAAAAAgAAAAIABB4PrQAAuNHBMAAAAMAAAADQAAAAEAAAAGAAAAAQAAAAEAAAATAAAADQAAAA4AAAABAAAABwAAAAAAAAABAAAAFAAAAA8AAAAQAAAAAQAAAAYAAAAAAAAAAQAAABUAAAAQAAAAEQAAAAEAAAAFAAAAAAAAAAIAAAAVAAAAEgAAABIAAAABAAAABQAAAAAAAAACAAAAFQAAABIAAAATAAAAAwAAAAUAAAACAAAAAwAAABUAAAASAAAAEwAAAAMAAAAFAAAABAAAAAQAAAAVAAAAEwAAABQAAAAEAAAABQAAAAgAAAAEAAAAFQAAABMAAAAUAAAABAAAAAUAAAAQAAAABQAAABYAAAAUAAAAFQAAAAQAAAAFAAAAEAAAAAUAAAAWAAAAFQAAABYAAAAFAAAABQAAABAAAAAFAAAAFgAAABUAAAAWAAAABgAAAAUAAAAQAAAABQAAABYAAAAWAAAAFwAAAAYAAAAFAAAAIAAAAAUAAAAWAAAAFgAAABYAAAAEAAAABQAAACAAAAAGAAAAFgAAABYAAAAXAAAABQAAAAUAAAAgAAAABgAAABYAAAAXAAAAFwAAAAYAAAAFAAAAIAAAAAYAAAAWAAAAFgAAABYAAAAFAAAABQAAADAAAAAHAAAAFwAAABcAAAAWAAAABQAAAAQAAABAAAAABwAAABcAAAAXAAAAFgAAAAYAAAADAAAAQAAAAAgAAAAXAAAAGAAAABYAAAAHAAAAAwAAAAABAAAJAAAAGQAAABkAAAAXAAAABwAAAAMAAAAAAQAACQAAABoAAAAaAAAAGAAAAAcAAAADAAAAAAIAAAkAAAAbAAAAGwAAABkAAAAJAAAAAwAAAOcDAAAJAAAAEgAAAAwAAAANAAAAAQAAAAUAAAABAAAAAQAAABIAAAANAAAADgAAAAEAAAAGAAAAAAAAAAEAAAASAAAADgAAAA4AAAABAAAABQAAAAAAAAACAAAAEgAAABAAAAAQAAAAAQAAAAQAAAAAAAAAAgAAABIAAAAQAAAAEQAAAAMAAAAFAAAAAgAAAAMAAAASAAAAEQAAABIAAAAFAAAABQAAAAIAAAADAAAAEgAAABIAAAATAAAAAwAAAAUAAAAEAAAABAAAABIAAAASAAAAEwAAAAQAAAAEAAAABAAAAAQAAAASAAAAEgAAABMAAAAEAAAABAAAAAgAAAAFAAAAEgAAABIAAAATAAAABQAAAAQAAAAIAAAABQAAABIAAAASAAAAEwAAAAYAAAAEAAAACAAAAAUAAAASAAAAEgAAABMAAAAFAAAABAAAAAwAAAAGAAAAEgAAABMAAAATAAAABwAAAAQAAAAMAAAABgAAABIAAAASAAAAEwAAAAQAAAAEAAAAEAAAAAcAAAASAAAAEgAAABMAAAAEAAAAAwAAACAAAAAHAAAAEgAAABIAAAATAAAABgAAAAMAAACAAAAABwAAABIAAAATAAAAEwAAAAYAAAADAAAAgAAAAAgAAAASAAAAEwAAABMAAAAIAAAAAwAAAAABAAAIAAAAEgAAABMAAAATAAAABgAAAAMAAACAAAAACQAAABIAAAATAAAAEwAAAAgAAAADAAAAAAEAAAkAAAASAAAAEwAAABMAAAAKAAAAAwAAAAACAAAJAAAAEgAAABMAAAATAAAADAAAAAMAAAAAAgAACQAAABIAAAATAAAAEwAAAA0AAAADAAAA5wMAAAkAAAARAAAADAAAAAwAAAABAAAABQAAAAEAAAABAAAAEQAAAAwAAAANAAAAAQAAAAYAAAAAAAAAAQAAABEAAAANAAAADwAAAAEAAAAFAAAAAAAAAAEAAAARAAAADwAAABAAAAACAAAABQAAAAAAAAACAAAAEQAAABEAAAARAAAAAgAAAAQAAAAAAAAAAgAAABEAAAAQAAAAEQAAAAMAAAAEAAAAAgAAAAMAAAARAAAAEAAAABEAAAADAAAABAAAAAQAAAAEAAAAEQAAABAAAAARAAAAAwAAAAQAAAAIAAAABQAAABEAAAAQAAAAEQAAAAQAAAAEAAAACAAAAAUAAAARAAAAEAAAABEAAAAFAAAABAAAAAgAAAAFAAAAEQAAABAAAAARAAAABgAAAAQAAAAIAAAABQAAABEAAAARAAAAEQAAAAUAAAAEAAAACAAAAAYAAAARAAAAEgAAABEAAAAHAAAABAAAAAwAAAAGAAAAEQAAABIAAAARAAAAAwAAAAQAAAAMAAAABwAAABEAAAASAAAAEQAAAAQAAAADAAAAIAAAAAcAAAARAAAAEgAAABEAAAAGAAAAAwAAAAABAAAHAAAAEQAAABIAAAARAAAABgAAAAMAAACAAAAACAAAABEAAAASAAAAEQAAAAgAAAADAAAAAAEAAAgAAAARAAAAEgAAABEAAAAKAAAAAwAAAAACAAAIAAAAEQAAABIAAAARAAAABQAAAAMAAAAAAQAACQAAABEAAAASAAAAEQAAAAcAAAADAAAAAAIAAAkAAAARAAAAEgAAABEAAAAJAAAAAwAAAAACAAAJAAAAEQAAABIAAAARAAAACwAAAAMAAADnAwAACQAAAA4AAAAMAAAADQAAAAEAAAAFAAAAAQAAAAEAAAAOAAAADgAAAA8AAAABAAAABQAAAAAAAAABAAAADgAAAA4AAAAPAAAAAQAAAAQAAAAAAAAAAQAAAA4AAAAOAAAADwAAAAIAAAAEAAAAAAAAAAIAAAAOAAAADgAAAA4AAAAEAAAABAAAAAIAAAADAAAADgAAAA4AAAAOAAAAAwAAAAQAAAAEAAAABAAAAA4AAAAOAAAADgAAAAQAAAAEAAAACAAAAAUAAAAOAAAADgAAAA4AAAAGAAAABAAAAAgAAAAFAAAADgAAAA4AAAAOAAAACAAAAAQAAAAIAAAABQAAAA4AAAAPAAAADgAAAAUAAAAEAAAACAAAAAYAAAAOAAAADwAAAA4AAAAJAAAABAAAAAgAAAAGAAAADgAAAA8AAAAOAAAAAwAAAAQAAAAMAAAABwAAAA4AAAAPAAAADgAAAAQAAAADAAAAGAAAAAcAAAAOAAAADwAAAA4AAAAFAAAAAwAAACAAAAAIAAAADgAAAA8AAAAPAAAABgAAAAMAAABAAAAACAAAAA4AAAAPAAAADwAAAAcAAAADAAAAAAEAAAgAAAAOAAAADwAAAA8AAAAFAAAAAwAAADAAAAAJAAAADgAAAA8AAAAPAAAABgAAAAMAAACAAAAACQAAAA4AAAAPAAAADwAAAAcAAAADAAAAAAEAAAkAAAAOAAAADwAAAA8AAAAIAAAAAwAAAAABAAAJAAAADgAAAA8AAAAPAAAACAAAAAMAAAAAAgAACQAAAA4AAAAPAAAADwAAAAkAAAADAAAAAAIAAAkAAAAOAAAADwAAAA8AAAAKAAAAAwAAAOcDAAAJAAAAAAAAAAAIAAAABwAAagYAAAAGAACtBQAAagUAADEFAAAABQAA1AQAAK0EAACKBAAAagQAAEwEAAAxBAAAFwQAAAAEAADpAwAA1AMAAMADAACtAwAAmwMAAIoDAAB5AwAAagMAAFsDAABMAwAAPgMAADEDAAAkAwAAFwMAAAsDAAAAAwAA9AIAAOkCAADeAgAA1AIAAMoCAADAAgAAtgIAAK0CAACkAgAAmwIAAJICAACKAgAAggIAAHkCAAByAgAAagIAAGICAABbAgAAUwIAAEwCAABFAgAAPgIAADcCAAAxAgAAKgIAACQCAAAeAgAAFwIAABECAAALAgAABQIAAAACAAD6AQAA9AEAAO8BAADpAQAA5AEAAN4BAADZAQAA1AEAAM8BAADKAQAAxQEAAMABAAC7AQAAtgEAALIBAACtAQAAqAEAAKQBAACfAQAAmwEAAJcBAACSAQAAjgEAAIoBAACGAQAAggEAAH4BAAB5AQAAdQEAAHIBAABuAQAAagEAAGYBAABiAQAAXgEAAFsBAABXAQAAUwEAAFABAABMAQAASQEAAEUBAABCAQAAPgEAADsBAAA3AQAANAEAADEBAAAuAQAAKgEAACcBAAAkAQAAIQEAAB4BAAAaAQAAFwEAABQBAAARAQAADgEAAAsBAAAIAQAABQEAAAIBAAAAAQAA/QAAAPoAAAD3AAAA9AAAAPEAAADvAAAA7AAAAOkAAADmAAAA5AAAAOEAAADeAAAA3AAAANkAAADXAAAA1AAAANEAAADPAAAAzAAAAMoAAADHAAAAxQAAAMIAAADAAAAAvgAAALsAAAC5AAAAtgAAALQAAACyAAAArwAAAK0AAACrAAAAqAAAAKYAAACkAAAAogAAAJ8AAACdAAAAmwAAAJkAAACXAAAAlQAAAJIAAACQAAAAjgAAAIwAAACKAAAAiAAAAIYAAACEAAAAggAAAIAAAAB+AAAAewAAAHkAAAB3AAAAdQAAAHMAAAByAAAAcAAAAG4AAABsAAAAagAAAGgAAABmAAAAZAAAAGIAAABgAAAAXgAAAF0AAABbAAAAWQAAAFcAAABVAAAAUwAAAFIAAABQAAAATgAAAEwAAABKAAAASQAAAEcAAABFAAAAQwAAAEIAAABAAAAAPgAAAD0AAAA7AAAAOQAAADcAAAA2AAAANAAAADIAAAAxAAAALwAAAC4AAAAsAAAAKgAAACkAAAAnAAAAJQAAACQAAAAiAAAAIQAAAB8AAAAeAAAAHAAAABoAAAAZAAAAFwAAABYAAAAUAAAAEwAAABEAAAAQAAAADgAAAA0AAAALAAAACgAAAAgAAAAHAAAABQAAAAQAAAACAAAAAQBBgJfRAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcCX0QALFQEBAQECAgMDBAQFBwgJCgsMDQ4PEABB5JfRAAu2AQEAAAADAAAABwAAAA8AAAAfAAAAPwAAAH8AAAD/AAAA/wEAAP8DAAD/BwAA/w8AAP8fAAD/PwAA/38AAP//AAD//wEA//8DAP//BwD//w8A//8fAP//PwD//38A////AP///wH///8D////B////w////8f////P////38BAAEAAQABAAEAAQACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD/////////////AEGwmdEACxQBAQEBAgIDAwQGBwgJCgsMDQ4PEABB0JnRAAtIBAADAAIAAgACAAIAAgACAAIAAgACAAIAAgABAAEAAQACAAIAAgACAAIAAgACAAIAAgADAAIAAQABAAEAAQABAP//////////AEHAmtEACxUBAQEBAgIDAwQEBQcICQoLDA0ODxAAQeCa0QALrRMBAAQAAwACAAIAAgACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAP//////////////////AAAAAAAAXHd3Xyz3uPUSxHprJl+ThMwMc8qprUe23rFPEUu7ZbDQnzqMfk5YNAVr4mp84ZdOBKaZvEPXAzpPBMQiJATNzp4lJIXFdt52yuqtW/YohZwpdQniBjdWhonYdaNfRwIp5uulOZcqs6855oM42hQnzp7mIheCrx4CKLYghmJ7AwD1yohdRY2aBECBleYR11aFH1xg/HSu9wQgOr1oNAyfgp4XJcaFyP1PG689igTec4SyRlawIogAUV/M0bISXddpvFSRFRlKnYwDQL2r9BDMw5Fzuewc3G3QLjCA7efmSL5HNeDOMduBNBDSodp89sOszJZ/jB13y2XdI1cFd3Gyjr6UzUQNlYnHK7EAN9zqT5OC8b3tEV9IXnp2ZP1GKi4efPou2HHKaSkuurtek+lGnSuC5gV+tlbgoAOdc1U/15QDWpu2vRBwzfSCm9f8+V5FYcFJh0q1nIYl0oVh+qTROLvpu5RvFnW08VkJckg1FKS6Jmu6gEftehIj4DlEJs7QCNV4YHRtNoS+F+1yPJfOqAELQ5qiI8Mh7oCv4xfWYplb94ycHekMq7xNmtHmjg5Tcl0/9QyM9i4GVahAFmg6wGcJMZyfTm5JoBSbtXIEWHh3hTg7wiQ4J1O1XNQ6kr9mhrqSJFoarkdZliKeVgTjNW8Lh0YqGGVHEpQJ6SW2umzBIoVZLpqs3fIkZmZuCHJxN3g7UMoDUN8JPVZ428HAiJ0o/KxlGNVY8SRSxq5xdhfXZ+lBoth5+5qk2coB4eEraxgpbi9oJWZQbsB6RVOVOXS7OsK0/10D3qpUH1mynUIJEH0DqAIoxfMlCx84J8tqO4JP7lElXvT3woCV2aIOi+HhtLycUe07CgG7PYJS9A9n0j1PYe1CnXvFV2LAE5NbQhReiwC4FKFLPcERHDH+wWhVTKM+duhmXfBiwvEqmIu3+3Wq+naI7iq7ctHQpGKKl5pEt6OUPcF8A13Bnbq7bfHgkh0fEIbHm7egB6mBhte5q8liKa8a9tl6y9P8Fv0sIU1iRGdbjIbX3XSciVDmJWN0w6f0KgS6yj5aRjmlsU7K1QU78NsJvrpyVCs2Wk53zYPRKRIioUffovWOoQxLULluReK93/vfNEbjvi8rzUbDmJ2B/viu8mGdWdR2Un8141PEeThIpSS5tJKRiCaACOzbghdnltooqpqOWEB8806zn7xRBrk3iNbl8NNB92TBunBLcApaE7zaKmL3aNicBqvAueCJuje89lI1MgFKwUe7mO6sS3kAT9VpemN93gdxXiXytjt5r4iYtZmHa0bG81k7f6oWxojC/aP8Qs9jyoFLZ6I2zlrYiOeJI3nTawUNLdOdTmw5XOWmwOZxRVD7vszokV4RMquW0TiP3hjLir8GJmcBiOXaZvsXI4cXYDuDZCjJ0fIWfLicZovldGp2274XFMaFn2WJDOoRYIWt2siufv62ZbWkdhJzI/aF0GmkbOmjg1Y28Kq49ySEb3S7TcGs5PRadTgGhkTmvfUHeD05drtbj22+F9w13ETN8AMJbBnx/epytmfxgkztk/92pp09BcUEEB1SApLMnNCaujdR+6x6KU3lhEU0FGp3SwsKjjQL4nHUIAjcRj24PDh0GBzh76HH7u2XqkLcGwvlMLMy4HDOVRnZHdU5KY+4zRSl07kN2T8jkSebeg/FTApne6XfxgUqfcB3+qbQRmaLd+NJZ7VH2o6csyjv261I1D6T9At9q/ZqhK9JbmbrCPJaDmrNNDX3ImZeblvvQsqufSmmOVXT864thqkejo9JIofmctXAPQlTHJj1+4a/v7AJ+hWfIWZh6bEwg/vEvWbU53DpqPI1bnNmWu+6wbfSWdvNlolt0kfSx9ajG97I6jlO6vKvo5+xi5xT2AjVX0wO+QmFM6/7VllOo3XzPh0Vji8uwa4/uOmRNhd5YwG/Vo1auOOKQGcSOIKDbQnAvRuQD7ll7LwzKdNqfJXViiwvXrt2KG30bBqFDzly2sKhTQbmw4lT+hwQDCrFMMX7o4Svjtd+mYso4rmBN8QFPaje9sJz115bTDaOIgQROaQN3z56nVZnaCTa/tyOobOpt6dndl4deUOhnzhPTNzNpz0CwYuwzLEp5Tq+tHr5T+fbMmFOdUXfOahCVGNx3lK+P2Sxby93gXrPQgoeluryntiDXbTzmz5uSs/kPe7nlTIsVEhozS9meExm4c7kxGhMR4tUR5kLi+2ldzfXJfy3NtaxFckA2tKw2XW6wiGhZIpgz11rXwxX+V8lM/Pc7tTOGCSSO2NKswSw4N02wVovS12wg8xY0kKOot0ktF6YzTmXNkffYhfO5IUktOC059Go+cHw4Ra/DlYHZ5HDjrOdzPItbrpiFjrYd//0+cvEvCt90NfZePRBLODhTFXvTfnMfhKBdY0FijzLNjO1qZFPXPQLLMQ4Y4hI9M2TCGRopV5XvDTsgECqjrT1JPM5f1L/jh/t2ekUosWMBfwkkkF3/kywALq6r1LPDxKfmjASYmJl7PNYpS++2nqL7EtCM6SuphMlYkGYp0wy1aKNuKQoVSQ7c4fSw65obX5pRJoou0kvvpMQe62KPS5j7LtQg4Lq4SMH2WzzK7AxdJ57iUdwijPL/Z4hVgZ8ovARAzvnltvAkb8X27KlhU5r/dSMnUCmSwVxsPrZ36kfg/7WQB55fa3rjTWvWD5epiUOjeuAheAU39PLuyurzX7yUfcM9NgTJk+hTStuBQAAbwUAAHAFAABxBQAAcgUAAHMFAAB0BQAAdQUAAHYFAAB3BQAAeAUAAHkFAAAEAAAAAgAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAGAAAAAgAAAAEAAAABAAAAAgAAAAMAAAAEAAAABAAAAAQAAAADAAAAAgAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQBBoK7RAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcGu0QALPwECAwQFBgcICQoLDA0ODxAQERESEhMTFBQUFBUVFRUWFhYWFhYWFhcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGABBoK/RAAsVAQEBAQICAwMEBAUHCAkKCwwNDg8QAEHBr9EAC/IDAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAgISEiIiMjJCQkJCUlJSUmJiYmJiYmJicnJycnJycnKCgoKCgoKCgoKCgoKCgoKCkpKSkpKSkpKSkpKSkpKSkqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgAAAAABAAAAAQAAAAUAAAANAAAAHQAAAD0AAAB9AAAA/QAAAP0BAAD9AwAA/QcAAP0PAAD9HwAA/T8AAP1/AAD9/wAA/f8BAP3/AwD9/wcA/f8PAP3/HwD9/z8A/f9/AP3//wD9//8B/f//A/3//wf9//8P/f//H/3//z/9//9/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8DAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAAEAAAABEAAAASAAAAEwAAABQAAAAVAAAAFgAAABcAAAAYAAAAGQAAABoAAAAbAAAAHAAAAB0AAAAeAAAAHwAAACAAAAAhAAAAIgAAACMAAAAlAAAAJwAAACkAAAArAAAALwAAADMAAAA7AAAAQwAAAFMAAABjAAAAgwAAAAMBAAADAgAAAwQAAAMIAAADEAAAAyAAAANAAAADgAAAAwABAEHgs9EACxUBAQEBAgIDAwQEBQcICQoLDA0ODxAAQYS00QALiwEBAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEgAAABQAAAAWAAAAGAAAABwAAAAgAAAAKAAAADAAAABAAAAAgAAAAAABAAAAAgAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAAABAEGgtdEAC1UBAQEBAgIDAwQGBwgJCgsMDQ4PEAEAAAAEAAAACAAAAAAAAAABAAAAAgAAAAQAAAAAAAAAAgAAAAQAAAAIAAAAAQAAAAIAAAADAAAABAAAAAUAAAAFAEGEttEAC4sBAQAAAAIAAAADAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAAEAAAABIAAAAUAAAAFgAAABgAAAAcAAAAIAAAACgAAAAwAAAAQAAAAIAAAAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAAAAQBBoLfRAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcC30QALhgQBAAEBBgAAAAAAAAQAAAAAEAAABAAAAAAgAAAFAQAAAAAAAAUDAAAAAAAABQQAAAAAAAAFBgAAAAAAAAUHAAAAAAAABQkAAAAAAAAFCgAAAAAAAAUMAAAAAAAABg4AAAAAAAEFEAAAAAAAAQUUAAAAAAABBRYAAAAAAAIFHAAAAAAAAwUgAAAAAAAEBTAAAAAgAAYFQAAAAAAABwWAAAAAAAAIBgABAAAAAAoGAAQAAAAADAYAEAAAIAAABAAAAAAAAAAEAQAAAAAAAAUCAAAAIAAABQQAAAAAAAAFBQAAACAAAAUHAAAAAAAABQgAAAAgAAAFCgAAAAAAAAULAAAAAAAABg0AAAAgAAEFEAAAAAAAAQUSAAAAIAABBRYAAAAAAAIFGAAAACAAAwUgAAAAAAADBSgAAAAAAAYEQAAAABAABgRAAAAAIAAHBYAAAAAAAAkGAAIAAAAACwYACAAAMAAABAAAAAAQAAAEAQAAACAAAAUCAAAAIAAABQMAAAAgAAAFBQAAACAAAAUGAAAAIAAABQgAAAAgAAAFCQAAACAAAAULAAAAIAAABQwAAAAAAAAGDwAAACAAAQUSAAAAIAABBRQAAAAgAAIFGAAAACAAAgUcAAAAIAADBSgAAAAgAAQFMAAAAAAAEAYAAAEAAAAPBgCAAAAAAA4GAEAAAAAADQYAIABB1LvRAAujAwEAAAABAAAABQAAAA0AAAAdAAAAPQAAAH0AAAD9AAAA/QEAAP0DAAD9BwAA/Q8AAP0fAAD9PwAA/X8AAP3/AAD9/wEA/f8DAP3/BwD9/w8A/f8fAP3/PwD9/38A/f//AP3//wH9//8D/f//B/3//w/9//8f/f//P/3//38AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHwEAAQEFAAAAAAAABQAAAAAAAAYEPQAAAAAACQX9AQAAAAAPBf1/AAAAABUF/f8fAAAAAwUFAAAAAAAHBH0AAAAAAAwF/Q8AAAAAEgX9/wMAAAAXBf3/fwAAAAUFHQAAAAAACAT9AAAAAAAOBf0/AAAAABQF/f8PAAAAAgUBAAAAEAAHBH0AAAAAAAsF/QcAAAAAEQX9/wEAAAAWBf3/PwAAAAQFDQAAABAACAT9AAAAAAANBf0fAAAAABMF/f8HAAAAAQUBAAAAEAAGBD0AAAAAAAoF/QMAAAAAEAX9/wAAAAAcBf3//w8AABsF/f//BwAAGgX9//8DAAAZBf3//wEAABgF/f//AEGAv9EAC9MBAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAAAAFQAAABYAAAAXAAAAGAAAABkAAAAaAAAAGwAAABwAAAAdAAAAHgAAAB8AAAAgAAAAIQAAACIAAAAjAAAAJQAAACcAAAApAAAAKwAAAC8AAAAzAAAAOwAAAEMAAABTAAAAYwAAAIMAAAADAQAAAwIAAAMEAAADCAAAAxAAAAMgAAADQAAAA4AAAAMAAQBBgMHRAAsVAQEBAQICAwMEBAUHCAkKCwwNDg8QAEGgwdEAC4YEAQABAQYAAAAAAAAGAwAAAAAAAAQEAAAAIAAABQUAAAAAAAAFBgAAAAAAAAUIAAAAAAAABQkAAAAAAAAFCwAAAAAAAAYNAAAAAAAABhAAAAAAAAAGEwAAAAAAAAYWAAAAAAAABhkAAAAAAAAGHAAAAAAAAAYfAAAAAAAABiIAAAAAAAEGJQAAAAAAAQYpAAAAAAACBi8AAAAAAAMGOwAAAAAABAZTAAAAAAAHBoMAAAAAAAkGAwIAABAAAAQEAAAAAAAABAUAAAAgAAAFBgAAAAAAAAUHAAAAIAAABQkAAAAAAAAFCgAAAAAAAAYMAAAAAAAABg8AAAAAAAAGEgAAAAAAAAYVAAAAAAAABhgAAAAAAAAGGwAAAAAAAAYeAAAAAAAABiEAAAAAAAEGIwAAAAAAAQYnAAAAAAACBisAAAAAAAMGMwAAAAAABAZDAAAAAAAFBmMAAAAAAAgGAwEAACAAAAQEAAAAMAAABAQAAAAQAAAEBQAAACAAAAUHAAAAIAAABQgAAAAgAAAFCgAAACAAAAULAAAAAAAABg4AAAAAAAAGEQAAAAAAAAYUAAAAAAAABhcAAAAAAAAGGgAAAAAAAAYdAAAAAAAABiAAAAAAABAGAwABAAAADwYDgAAAAAAOBgNAAAAAAA0GAyAAAAAADAYDEAAAAAALBgMIAAAAAAoGAwQAQbTF0QALhQcBAAAAAwAAAAcAAAAPAAAAHwAAAD8AAAB/AAAA/wAAAP8BAAD/AwAA/wcAAP8PAAD/HwAA/z8AAP9/AAD//wAA//8BAP//AwD//wcA//8PAP//HwD//z8A//9/AP///wD///8B////A////wf///8P////H////z////9/AAAAAAEAAAACAAAAAQAAAAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAgAAAAHAAAACAAAAAkAAAAKAAAACwAAAAkWP6g+/VMSKY86sfVjroxmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXIAgGMUABsAAAAlAAAAAgAAAJxjFABkZXNjcmlwdGlvbigpIGlzIGRlcHJlY2F0ZWQ7IHVzZSBEaXNwbGF5fAUAAAgAAAAEAAAAfQUAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAfgUAAAgAAAAEAAAAUwIAAH8FAAAYAAAACAAAAIAFAAB/BQAAGAAAAAgAAACBBQAAgAUAACRkFACCBQAAgwUAAIQFAACCBQAAhQUAAN2XEABgAAAAVAAAAB8AAADdlxAAYAAAAH0AAAAbAAAAcHJvdmlkZWQgb3V0cHV0IGlzIHRvbyBzbWFsbCBmb3IgdGhlIGRlY29tcHJlc3NlZCBkYXRhLCBhY3R1YWwgLCBleHBlY3RlZCAAAIBkFAA/AAAAv2QUAAsAAABsaXRlcmFsIGlzIG91dCBvZiBib3VuZHMgb2YgdGhlIGlucHV0ZXhwZWN0ZWQgYW5vdGhlciBieXRlLCBmb3VuZCBub25ldGhlIG9mZnNldCB0byBjb3B5IGlzIG5vdCBjb250YWluZWQgaW4gdGhlIGRlY29tcHJlc3NlZCBidWZmZXJvdXRwdXQgaXMgdG9vIHNtYWxsIGZvciB0aGUgY29tcHJlc3NlZCBkYXRhLCB1c2UgZ2V0X21heGltdW1fb3V0cHV0X3NpemUgdG8gcmVzZXJ2ZSBlbm91Z2ggc3BhY2VpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlF0YQAGQAAABGAAAAIAAAABdGEABkAAAAxAAAADEAAAAXRhAAZAAAAFMBAAArAAAAF0YQAGQAAABlAQAAJQAAAN6EEABhAAAAYwAAAEUAAAABAEHEzNEAC5UEBAAAAAQAAACGBQAAAAAAAAQAAAAEAAAAhwUAAE91dHB1dFRvb1NtYWxsZXhwZWN0ZWRhY3R1YWxMaXRlcmFsT3V0T2ZCb3VuZHNFeHBlY3RlZEFub3RoZXJCeXRlT2Zmc2V0T3V0T2ZCb3VuZHMAAAAAAAAEAAAABAAAAIgFAABDb21wcmVzc2lvbkVycm9yAAAAAAQAAAAEAAAAiQUAAERlY29tcHJlc3Npb25FcnJvcgAAAAAAAAQAAAAEAAAAigUAAElvRXJyb3IAAAAAAAQAAAAEAAAAQwUAAFVuc3VwcG9ydGVkQmxvY2tzaXplVW5zdXBwb3J0ZWRWZXJzaW9uV3JvbmdNYWdpY051bWJlclJlc2VydmVkQml0c1NldEludmFsaWRCbG9ja0luZm9CbG9ja1Rvb0JpZ0hlYWRlckNoZWNrc3VtRXJyb3JCbG9ja0NoZWNrc3VtRXJyb3JDb250ZW50Q2hlY2tzdW1FcnJvcgAAAAAAAAAEAAAABAAAAIsFAABTa2lwcGFibGVGcmFtZURpY3Rpb25hcnlOb3RTdXBwb3J0ZWQAAAAACAAAAAgAAACMBQAAAAAAAAQAAAAEAAAAjQUAAENvbnRlbnRMZW5ndGhFcnJvcgAMGxcqPzgwO0BtaWQgPiBsZW4AAAAsaBQACQAAAAAAAAAKCgsLCgoKCgoJCQgHBwgHBwYGBQUAQfHQ0QALuBQQAAAAJAAAAFQAAACMAAAArAAAANAAAAD4AAAAJAEAAFQBAABuAQAAigEAAJkBAAChAQCAqQEAgLsBAADFAQAAzwEAQNQBAMDZAQCg3AEAQGgUAFxoFACk9BwAFiEQAGQAAAAjAAAAHwAAABYhEABkAAAAIwAAAAsAAAAWIRAAZAAAAC4AAAAfAAAAFiEQAGQAAAAuAAAACwAAABYhEABkAAAAfgAAABwAAAAWIRAAZAAAAH4AAAAzAAAAFiEQAGQAAACHAAAAIgAAABYhEABkAAAAiAAAACIAAAAWIRAAZAAAAKEAAAARAAAAFiEQAGQAAACyAAAAEQAAABYhEABkAAAAwAAAABUAAABhc3NlcnRpb24gZmFpbGVkOiBzMS5sZW4oKSA+PSAobGltaXQgJiA3dXNpemUpAAAWIRAAZAAAAOMAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogczIubGVuKCkgPj0gKGxpbWl0ICYgN3VzaXplKQAAFiEQAGQAAADkAAAABQAAABYhEABkAAAAzgAAABkAAAAWIRAAZAAAAPsAAAAeAAAAFiEQAGQAAAD9AAAAJQAAABYhEABkAAAABQEAABAAAAAWIRAAZAAAAAcBAAAvAAAAFiEQAGQAAAAUAQAAFAAAABYhEABkAAAAGAEAAC0AAAAWIRAAZAAAABUBAAAyAAAAFiEQAGQAAAAkAQAAGAAAABYhEABkAAAAMQEAAC4AAAAWIRAAZAAAAEEBAAAjAAAAFiEQAGQAAABEAQAAJgAAABYhEABkAAAAXAEAAB0AAAAWIRAAZAAAAF0BAAAdAAAAFiEQAGQAAABeAQAAHQAAABYhEABkAAAAXwEAAB0AAAAWIRAAZAAAAIABAAAlAAAAFiEQAGQAAACBAQAAFAAAABYhEABkAAAAhAEAABgAAAAWIRAAZAAAAIUBAAAcAAAAFiEQAGQAAACOAQAAIAAAABYhEABkAAAAmAEAACAAAAAWIRAAZAAAAKIBAAAgAAAAFiEQAGQAAACjAQAAIQAAABYhEABkAAAArgEAABwAAAAWIRAAZAAAAK4BAAA7AAAAFiEQAGQAAAC4AQAAHAAAABYhEABkAAAAuQEAACAAAAAWIRAAZAAAAMIBAABBAAAAFiEQAGQAAADMAQAAHAAAABYhEABkAAAAzQEAACAAAAAWIRAAZAAAAM0BAAA/AAAAFiEQAGQAAADXAQAAIAAAABYhEABkAAAA2AEAACEAAAAWIRAAZAAAANkBAAAhAAAAFiEQAGQAAADkAQAAHAAAABYhEABkAAAA5QEAACAAAAAWIRAAZAAAAO4BAABBAAAAFiEQAGQAAAD4AQAAHAAAABYhEABkAAAA+QEAACEAAAAWIRAAZAAAAPoBAAAhAAAAFiEQAGQAAAAFAgAAHAAAABYhEABkAAAABgIAACAAAAAWIRAAZAAAAAcCAAAkAAAAFiEQAGQAAAARAgAAJAAAABYhEABkAAAAEgIAACUAAAAWIRAAZAAAABwCAABBAAAAFiEQAGQAAAAmAgAAHAAAABYhEABkAAAAJwIAAB0AAAAWIRAAZAAAACgCAAAdAAAAFiEQAGQAAAApAgAAHQAAABYhEABkAAAAOwIAABgAAAAWIRAAZAAAAEwCAAAYAAAAFiEQAGQAAABUAgAAHAAAABYhEABkAAAAVAIAADsAAAAWIRAAZAAAAFUCAAAgAAAAFiEQAGQAAABWAgAAJAAAABYhEABkAAAAYAIAACQAAAAWIRAAZAAAAGECAAAlAAAAFiEQAGQAAAB1AgAAGAAAABYhEABkAAAAhgIAABgAAAAWIRAAZAAAALACAAAYAAAAFiEQAGQAAADCAgAAGAAAABYhEABkAAAAwgIAADcAAAAWIRAAZAAAAMwCAAAYAAAAFiEQAGQAAADNAgAAHAAAABYhEABkAAAA1wIAABwAAAAWIRAAZAAAAOECAAAcAAAAFiEQAGQAAADiAgAAHQAAABYhEABkAAAA7QIAABgAAAAWIRAAZAAAAO4CAAAdAAAAFiEQAGQAAADvAgAAHQAAABYhEABkAAAA+gIAABgAAAAWIRAAZAAAAPsCAAAcAAAAFiEQAGQAAAD7AgAAOwAAABYhEABkAAAABQMAABwAAAAWIRAAZAAAAAYDAAAdAAAAFiEQAGQAAAARAwAAGAAAABYhEABkAAAAEgMAABwAAAAWIRAAZAAAABMDAAAhAAAAFiEQAGQAAAAUAwAAIQAAABYhEABkAAAAHgMAAD0AAAAWIRAAZAAAACgDAAAYAAAAFiEQAGQAAAApAwAAGQAAABYhEABkAAAAKgMAABkAAAAWIRAAZAAAAHQBAAAeAAAAFiEQAGQAAABFAwAAJQAAABYhEABkAAAARgMAABQAAAAWIRAAZAAAAFoDAAAYAAAAFiEQAGQAAABvAwAAGAAAABYhEABkAAAAhAMAABgAAAAWIRAAZAAAAKQDAAAYAAAAFiEQAGQAAADDAwAAIwAAABYhEABkAAAAxgMAACYAAAAWIRAAZAAAAN8DAAAlAAAAFiEQAGQAAADgAwAAFAAAABYhEABkAAAA+QMAABwAAAAWIRAAZAAAAAoEAAAcAAAAFiEQAGQAAAAUBAAAHAAAABYhEABkAAAAPgQAACUAAAAWIRAAZAAAAD8EAAAUAAAAFiEQAGQAAABTBAAAGAAAABYhEABkAAAAaAQAABgAAAAWIRAAZAAAAHQEAAAYAAAAFiEQAGQAAACYBAAAIwAAABYhEABkAAAAmwQAACYAAAAWIRAAZAAAALEEAAAZAAAAFiEQAGQAAADLBAAAEQAAABYhEABkAAAA0AQAABUAAAAWIRAAZAAAANYEAAAjAAAAFiEQAGQAAADZBAAAJgAAABYhEABkAAAA9QQAACkAAAAWIRAAZAAAAPgEAAAdAAAAFiEQAGQAAAD5BAAAHQAAABYhEABkAAAA+gQAAB0AAAAWIRAAZAAAAPsEAAAdAAAAFiEQAGQAAAAFBQAAIQAAABYhEABkAAAABgUAACEAAAAWIRAAZAAAAAcFAAAhAAAAFiEQAGQAAAAIBQAAIQAAAAECAwQABREGEAcICQoLDA0ODwAHAwIBDwIEAwICBE5lZWQgdG8gZnJlZSBlbnRyb3B5X3RhbGx5X3NjcmF0Y2ggYmVmb3JlIGRyb3BwaW5nIENvbW1hbmRRdWV1ZQoAAAEAAAACAAAABQAAAAIAAAAJAAAAAgAAAA0AAAACAAAAEQAAAAMAAAAZAAAAAwAAACEAAAADAAAAKQAAAAMAAAAxAAAABAAAAEEAAAAEAAAAUQAAAAQAAABhAAAABAAAAHEAAAAFAAAAkQAAAAUAAACxAAAABQAAANEAAAAFAAAA8QAAAAYAAAAxAQAABgAAAHEBAAAHAAAA8QEAAAgAAADxAgAACQAAAPEEAAAKAAAA8QgAAAsAAADxEAAADAAAAPEgAAANAAAA8UAAABgAQbjl0QALxQlhc3NlcnRpb24gZmFpbGVkOiBuX2JpdHMgPD0gNTYAAOxTEABqAAAA6AIAAAUAAADsUxAAagAAAOoCAAARAAAA7FMQAGoAAADsAgAABQAAAOxTEABqAAAA5wIAAAUAAAAAAAAA7FMQAGoAAAD5AgAABQAAAOxTEABqAAAA+AIAAAUAAADsUxAAagAAAAoDAAAUAAAA7FMQAGoAAAAgAwAAJgAAAOxTEABqAAAAIAMAABEAAADsUxAAagAAACIDAAANAAAA7FMQAGoAAAA0AwAAGQAAAOxTEABqAAAANgMAAA0AAADsUxAAagAAAF0DAAAwAAAA7FMQAGoAAABdAwAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxlbmd0aCA+IDDsUxAAagAAAAQFAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogbGVuZ3RoIDw9ICgxIDw8IDI0KQAAAOxTEABqAAAABQUAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBsZyA8PSAyNAAA7FMQAGoAAAAGBQAABQAAAOxTEABqAAAAmgUAABAAAADsUxAAagAAAIYFAAAUAAAA7FMQAGoAAACGBQAAKQAAAOxTEABqAAAAtgUAABAAAADsUxAAagAAANAFAAAcAAAA7FMQAGoAAADLBQAACQAAAOxTEABqAAAAzAUAAAkAAADsUxAAagAAAN4FAAAQAAAA7FMQAGoAAAA1BgAAIAAAAOxTEABqAAAANQYAACwAAADsUxAAagAAABEGAABRAAAA7FMQAGoAAAAZBgAARAAAAOxTEABqAAAAGQYAACEAAADsUxAAagAAAF4GAAAJAAAA7FMQAGoAAABzBgAAHQAAAOxTEABqAAAAYQYAAA0AAADsUxAAagAAAIQGAAAQAAAA7FMQAGoAAACOBgAAFQAAAOxTEABqAAAAoAYAABEAAADsUxAAagAAAKwGAAA8AAAA7FMQAGoAAACtBgAADQAAAOxTEABqAAAApwYAAAkAAADsUxAAagAAAKIGAAAMAAAA7FMQAGoAAADUBgAADAAAAOxTEABqAAAA3AYAACMAAADsUxAAagAAAO4GAAAVAAAA7FMQAGoAAADnBgAAFQAAAOxTEABqAAAA1QYAAA0AAADsUxAAagAAAL8GAAAfAAAA7FMQAGoAAADCBgAAHwAAAOxTEABqAAAAjAcAAAUAAADsUxAAagAAAJQHAAAFAAAA7FMQAGoAAADwBwAABQAAAOxTEABqAAAA4wgAABwAAADsUxAAagAAAOkIAAAtAAAA7FMQAGoAAAAFCQAAHAAAAOxTEABqAAAACQkAAA0AAADsUxAAagAAAAoJAAANAAAA7FMQAGoAAAAjCQAAEQAAAOxTEABqAAAAJAkAABEAAADsUxAAagAAABIJAAAjAAAA7FMQAGoAAAAUCQAAFQAAAOxTEABqAAAAFQkAABUAAADsUxAAagAAANQKAAAMAAAA7FMQAGoAAADQCgAAEwAAAOxTEABqAAAA0QoAABMAAADsUxAAagAAAEYLAAAdAAAAAAQEBQYGBwcHBwcICAgICAAAAAQEBAQEBQUGBgYGBwcHBwoKCgoKCgAEBAUFBQYGBwgICQoKCgoKCgoKCgoKCgUAQYzv0QALiQgGBgYGBgYFBQUFBQUEBAQEBAQEBQUFBQUFBgYHBwcICgwMDAwMDAwMDAwMDAAAAAD/d9W/597qnlFd3sZwV7xYWFjY2FjVy4zq4MOHH4PBYBxnsqoGg8FgMBjMoc6IVJRG4bDQTrL3BABtaWQgPiBsZW4AAPV3FAAJAAAALwMQAGwAAAAnAAAACgAAAC8DEABsAAAAKQAAAAoAAAAvAxAAbAAAAC8AAAAKAAAALwMQAGwAAAAxAAAACgAAAC8DEABsAAAANwAAAAoAAAAvAxAAbAAAADkAAAAKAAAALwMQAGwAAAA/AAAACgAAAC8DEABsAAAAQQAAAAoAAAAAAAAALwMQAGwAAABLAAAAEgAAAC8DEABsAAAATQAAABIAAAAvAxAAbAAAAEUAAAAFAAAAAAEAAC8DEABsAAAAbQAAABIAAAAvAxAAbAAAAHUAAAATAAAAAAAAAC8DEABsAAAAfAAAAA0AAAAvAxAAbAAAAH8AAAANAAAALwMQAGwAAABgAAAABQAAAC8DEABsAAAAmQAAABIAAAAvAxAAbAAAAKYAAAANAAAALwMQAGwAAACpAAAADQAAAC8DEABsAAAAjQAAAAUAAAAvAxAAbAAAANUAAAARAAAALwMQAGwAAADZAAAAGwAAAC8DEABsAAAA1wAAABEAAAAgACAAgAAAQAAEAAQAIDAAACAAEABAAAEAQABAAEAAQAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAALwMQAGwAAAC8AAAAEQAAAC8DEABsAAAAwAAAABsAAAAvAxAAbAAAAL4AAAARAAAAAAABAAEAAQACAAQACAAQABAAIABAAIAAgAAAAoAGgAYvAxAAbAAAALQAAAANAAAALwMQAGwAAACwAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGluZGV4IDwgTlVNX1NQRUVEU19UT19UUlkALwMQAGwAAADkAAAABQAAAC8DEABsAAAA4wAAAAUAAAAQAAAALwMQAGwAAAD8AAAABQAAAC8DEABsAAAACQEAABEAAAAvAxAAbAAAAA4BAAAFAAAAMXMQAF8AAAB0AAAAOQAAADFzEABfAAAAdQAAADMAAAAxcxAAXwAAAIACAAAUAAAAMXMQAF8AAACBAgAAEgAAADFzEABfAAAAggIAAA0AAAAxcxAAXwAAAIICAAArAAAAAAAAAAgACQADACMABwBHACcAZwAXAC8ArwBvAO8AHwAAAAAAAAAEAAwAAgAKAAYADQAdAAsAKwAbADsAVwA3AA8ATwA/AT8DvwC/Ar8BvwMAAA4AAQAZAAUAFQATADMAdwCfAF8A3wDfAd8DPwA/An8AfwJ/AX8D/wD/Av8B/wMOAEG099EAC30bADsABwAnABcANwAeAAEAEQAJABkABQAAAAgABAAMAAIACgAGABUADQAdAAMAEwALAA8ALwAfAF8APwB/AP8A/wL/Cv8G/w7/Af8J/wX/Df8D/wv/B/8PAAAAAAAAAAAxcxAAXwAAADAFAAAsAAAAAQAAAAEAAAACAAAAAgBBrPrRAAsFAQAAAAEAQaT80QALDQsAAAALAAAADAAAAAwAQcT80QALgQEBAAAAAQAAAAkAAAAJAAAAAgAAAAIAAAACAAAAAgAAAAEAAAABAAAAAQAAAAEAAAAIAAAAAwAAAAMAAAADAAAAAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAgAAAAIAAAAIAAAABAAAAAQAAAAEAAAACAAAAAcAAAAEAAAABAAAAAgAQdT90QALzQEDAAAAAwAAAAMAAAADAAAABQAAAAUAAAAKAAAABQAAAAUAAAAFAAAACgAAAAUAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAADFzEABfAAAAFAcAAB0AAAAxcxAAXwAAABUHAAAdAAAAMXMQAF8AAAAaBwAAHwAAADFzEABfAAAAGwcAAB8AAAAxcxAAXwAAACAHAAARAAAAMXMQAF8AAABcBwAAKgAAADFzEABfAAAAYQcAACsAAAAxcxAAXwAAAGUHAAAtAEGs/9EAC+kJAQAAAAIAAABtaWQgPiBsZW4AAAC0fxQACQAAAN8mEABzAAAAKwAAAAkAAADfJhAAcwAAACgAAAAJAAAA3yYQAHMAAAAlAAAACQAAAN8mEABzAAAAIgAAAAkAAADfJhAAcwAAABwAAAAJAAAA3yYQAHMAAAAVAAAACQAAAN8mEABzAAAAPAAAAAUAAADfJhAAcwAAAGsAAAAJAAAA3yYQAHMAAABuAAAACQAAAN8mEABzAAAAYgAAAAkAAADfJhAAcwAAAGUAAAAJAAAA3yYQAHMAAABWAAAACQAAAN8mEABzAAAAWQAAAAkAAADfJhAAcwAAAE4AAAAJAAAA3yYQAHMAAABEAAAACQAAAN8mEABzAAAAiwAAAAkAAADfJhAAcwAAAIgAAAAJAAAA3yYQAHMAAACCAAAACQAAAN8mEABzAAAAewAAAAkAAADfJhAAcwAAAJkAAAAdAAAA3yYQAHMAAACZAAAAJgAAAN8mEABzAAAAmQAAAC8AAADfJhAAcwAAAJkAAAA4AAAA3yYQAHMAAAC6AAAAFQAAAN8mEABzAAAA1AAAADYAAADfJhAAcwAAANYAAAAwAAAA3yYQAHMAAADWAAAARgAAAN8mEABzAAAA3gAAACkAAADfJhAAcwAAAOEAAABCAAAA3yYQAHMAAADZAAAAIQAAAN8mEABzAAAA8wAAAB0AAADfJhAAcwAAAPQAAAAdAAAA3yYQAHMAAAD7AAAAHAAAAN8mEABzAAAA/AAAAC8AAADfJhAAcwAAAPwAAAAWAAAA3yYQAHMAAAABAQAAFQAAAN8mEABzAAAAFgEAAEcAAADfJhAAcwAAABkBAAAZAAAA3yYQAHMAAAAbAQAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlwX2luZGV4ID49IDUA3yYQAHMAAAAfAQAAGQAAAN8mEABzAAAAIQEAAEcAAADfJhAAcwAAACMBAAAZAAAA3yYQAHMAAAAlAQAAGQAAAN8mEABzAAAAJwEAABkAAADfJhAAcwAAACwBAAAZAAAA3yYQAHMAAAAuAQAAGQAAAN8mEABzAAAAMAEAACEAAADfJhAAcwAAADYBAAAkAAAA3yYQAHMAAAA2AQAAOgAAAN8mEABzAAAAOgEAAB0AAADfJhAAcwAAADsBAAAdAAAA3yYQAHMAAABKAQAAFQAAAN8mEABzAAAAWQEAAEcAAADfJhAAcwAAAFsBAAAZAAAA3yYQAHMAAABdAQAAGQAAAN8mEABzAAAAXwEAABkAAADfJhAAcwAAAGQBAAAZAAAA3yYQAHMAAABmAQAAGQAAAN8mEABzAAAAUAEAAEcAAADfJhAAcwAAAFMBAAAZAAAA3yYQAHMAAABVAQAAGQAAAN8mEABzAAAAVwEAABkAAADfJhAAcwAAAGgBAAAhAAAA3yYQAHMAAABuAQAAHQAAAN8mEABzAAAAewEAABEAAADfJhAAcwAAAHwBAAAnAAAA3yYQAHMAAAB8AQAADgAAAN8mEABzAAAAjwEAAC8AAADfJhAAcwAAAJkBAAAXAAAA3yYQAHMAAACaAQAAFgAAAN8mEABzAAAAvgEAAAgAAADfJhAAcwAAAL8BAAAfAAAA3yYQAHMAAAC/AQAACgAAAN8mEABzAAAAzQEAABMAAADfJhAAcwAAANEBAAATAEGwidIAC0UBAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABAAAAAUAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAAMAAAADgAAABgAQZiK0gALHQEAAAABAAAAAgAAAAIAAAADAAAAAwAAAAQAAAAEAEHYitIACz0BAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABAAAAAUAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAAYAEHYi9IAC8IPAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAGAAAABwAAAAcAAAAIAAAACAAAAAkAAAAJAAAACgAAAAoAAAALAAAACwAAAAwAAAAMAAAADQAAAA0AAAAOAAAADgAAAA8AAAAPAAAAEAAAABAAAAARAAAAEQAAABIAAAASAAAAEwAAABMAAAAUAAAAFAAAABUAAAAVAAAAFgAAABYAAAAXAAAAFwAAABgAAAAYAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAgAAAAKAAAADgAAABIAAAAaAAAAIgAAADIAAABCAAAAYgAAAIIAAADCAAAAQgEAAEICAABCBAAAQggAAEIYAABCWAAA3yYQAHMAAACBAgAABQAAAN8mEABzAAAA6gIAABkAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAABYhEABkAAAALgAAAB8AAAAWIRAAZAAAAC4AAAALAAAAFiEQAGQAAABEAAAACgAAABYhEABkAAAARAAAABwAAABschAAZwAAACEAAAAMAAAAbHIQAGcAAAAtAAAADQAAAGxyEABnAAAALwAAACEAAABschAAZwAAACYAAAANAAAAbHIQAGcAAABnAAAAMAAAAGxyEABnAAAAaAAAAEYAAABschAAZwAAAG4AAAAVAAAAbHIQAGcAAABPAAAAKAAAAGxyEABnAAAAXgAAAA0AAACEAAAAOQAAABcAAAAKAAAABAAAAAEAAABschAAZwAAAJ4AAAAYAAAAbHIQAGcAAACeAAAAEQAAAGxyEABnAAAApAAAAA0AAABschAAZwAAAKUAAAANAAAAbHIQAGcAAACtAAAAGAAAAGxyEABnAAAArQAAADIAAABschAAZwAAALQAAAAYAAAAbHIQAGcAAAC0AAAAMgAAAGxyEABnAAAAvQAAADYAAABschAAZwAAAL8AAAArAAAAbHIQAGcAAADCAAAAGQAAAGxyEABnAAAAlwAAABQAAABschAAZwAAAJkAAAAVAAAAbHIQAGcAAAAfAQAAMAAAAGxyEABnAAAAHwEAAEgAAABschAAZwAAACUBAAAQAAAAbHIQAGcAAAAnAQAAJwAAAGxyEABnAAAAPwEAABkAAABschAAZwAAAEABAAArAAAAbHIQAGcAAABBAQAAKwAAAGxyEABnAAAATQEAACQAAABschAAZwAAADcBAAAVAAAAbHIQAGcAAAAOAQAAHwAAAGxyEABnAAAAFgEAAB4AAABschAAZwAAABEBAAAZAAAAbHIQAGcAAAD9AAAAGAAAAGxyEABnAAAA3gAAAAwAAABschAAZwAAAGQBAAAZAAAAbHIQAGcAAABoAQAAHgAAAGxyEABnAAAAgQEAAAsAAABschAAZwAAAJABAAAJAAAAbHIQAGcAAACRAQAACQAAAGxyEABnAAAAlgEAAAkAAABschAAZwAAAJcBAAAJAAAAbHIQAGcAAAClAQAADQAAAGxyEABnAAAApgEAAA0AAABschAAZwAAAJ0BAAANAAAAbHIQAGcAAACeAQAADQAAAGxyEABnAAAAugEAAAkAAABschAAZwAAALsBAAAJAAAAbHIQAGcAAADJAQAADQAAAGxyEABnAAAAygEAAA0AAABschAAZwAAAMEBAAANAAAAbHIQAGcAAADCAQAADQAAAGxyEABnAAAA5gEAABAAAABschAAZwAAAPMBAAAZAAAAbHIQAGcAAAD4AQAAJgAAAAAAAAAIAAAABAAAAAwAAAACAAAACgAAAAYAAAAOAAAAAQAAAAkAAAAFAAAADQAAAAMAAAALAAAABwAAAA8AAABschAAZwAAADYCAAAMAAAAbHIQAGcAAAA5AgAAIQAAAGxyEABnAAAANwIAAA0AAABschAAZwAAACwCAAAiAAAAbHIQAGcAAAAsAgAAGQAAAG1pZCA+IGxlbgAAAKCLFAAJAAAAjxUQAGEAAAAXAAAAIAAAAI8VEABhAAAAXwAAAA0AAACPFRAAYQAAAGoAAAAfAAAAjxUQAGEAAABrAAAAHwAAAI8VEABhAAAAbAAAAB8AAACPFRAAYQAAAHYAAAAcAAAAEVwQAGIAAAAwAAAAFwAAABFcEABiAAAASgAAABUAAAARXBAAYgAAAGsAAAAVAAAAbWlkID4gbGVuAAAARIwUAAkAAAB7eRAAcAAAAG8CAAAiAAAAe3kQAHAAAABwAgAACQAAAHt5EABwAAAAcQIAAAkAAAB7eRAAcAAAAHICAAAJAAAAe3kQAHAAAABzAgAACQAAAHt5EABwAAAAdAIAAAkAAAB7eRAAcAAAAHUCAAAJAAAAe3kQAHAAAAB4AgAADQAAAHt5EABwAAAAeQIAAA0AAAB7eRAAcAAAAHoCAAANAAAAe3kQAHAAAAB7AgAADQAAAHt5EABwAAAAfAIAAA0AAAB7eRAAcAAAAH0CAAANAAAAPB4AAKEdAACLHQAAgR0AAKMdAACjHQAAoB0AAKAdAACdHQAAnR0AAJcdAACXHQAAjR0AAI0dAACDHQAAgx0AAHt5EABwAAAAtwIAACEAAAB7eRAAcAAAAGUHAAAKAAAAe3kQAHAAAABpBwAASgAAAEh9AEGqm9IACwJkVQBBupvSAAsCJp4AQcab0gALAuayAEHUm9IACxQMBQAAAAAAAAAAZBMWAaVcAAAETgBBgJzSAAsMTgjmPgAAAAAAAGU4AEGanNIACwpnaM0IAAAAAGRDAEG2nNIACwwmDgAAAAAAAAAAyFkAQc6c0gALBgdBAADHhQBB3pzSAAsCZr0AQfyc0gALAs8JAEHAndIACxBMTAAAAADEXQAAAAAAAGQmAEHundIACwKFeABBsp7SAAsC5nwAQcSe0gALEKpQZAkAACVRjQZHIwAABBkAQfqe0gALAqfKAEGYn9IACxZpGiYcAAAAAOhVx1kAAAAAyQ0AAEgHAEG6n9IACxomKwAAAACpJQAAAAAAAGsZAAAAAEaQSFSn8wBB5p/SAAsCZiAAQfaf0gALDGefAAAAAAAA5pnIHwBBkKDSAAsCqyIAQbqg0gALFgUfAAAAAAlkAAAAAAAAqAOEDo0MRz0AQdqg0gALHifNAADlQwAAAAAAAAAAKAWlFgAAJVIAAAAASBknAwBBjKHSAAsc6TQAAAAAAAAoDgAAAAAAAOpzZHgAAAV6AADEGQBBuqHSAAsCRvoAQdKh0gALGgZXAABGkgAAAAAAAAAASBynAQAAJGDJVOREAEH4odIACxQpBwAAAAAAAEgBhRcAAAAAAAAGTgBBnqLSAAsmp/JSEAAAAAAAAAAARC+pIQAAAAAEQgAARo8AAAAAAAAmigAABsoAQeKi0gALBgZSAACG8gBB8qLSAAsCphUAQYqj0gALECU5yCpHZQAAAAAAAAAAiU0AQaij0gALIOh45gvqN8YyAAAAAAAApDsAAIaeCHam8gAAAAAAAKROAEHSo9IACxrlLgAAAAAAAIbMAAAAAAAAAADKYAAALABHgQBB9qPSAAsCBGcAQYKk0gALCsUOAAAAAAhGByUAQZyk0gALBCl+xW8AQbqk0gALBEa4yy0AQdCk0gALCugJZ9cAAAAAChkAQeqk0gALDObbii4AABECAADodQBBmqXSAAsORSAAAAAAiHDm5WlYxQMAQc6l0gALDof6AAAAAEsBZA4AAEUGAEHwpdIACwwKQSUAAABGXEgMRTwAQZCm0gALA6tXRQBBpKbSAAsCqEUAQbim0gALDGkrAAAAAAAAAACFRwBB1qbSAAsKBmgAAAAAqGMnZQBB9qbSAAsYBUIAAAAAAACmawAAAADKJAAAAAAAALQNAEGep9IACxxmlEkkRSEAAAAAAAAAACoGRAaIXQAAAABEOu0xAEHIp9IACwZJLwAA6UAAQean0gALBmRT6CvGcABBkKjSAAsIjBYAAAAApGwAQaao0gALAoQgAEG8qNIACxJsQYUEAAAAAGpJxD8qZacDjSAAQd6o0gALCkZHAACmRgAABrcAQfSo0gALHlMBAAAAAGRi7DGGLwkZAAAAAAAAAACEQAAAhGnrbgBBoKnSAAsMjAUAAAAAAAAoJufOAEHIqdIACwRLYkQBAEHeqdIACwLm/QBB6qnSAAsChVUAQfap0gALEga5AAAAAAAAZgMAAAAAAABmMQBBrqrSAAsEpGXoPwBB0KrSAAsMEQcAAAAAAADJGQY+AEHmqtIACwakcQAAZG8AQf6q0gALCuRVAAAAAAAAxqcAQZyr0gALBA0UJgUAQbar0gALBMbWSGEAQc6r0gALAkbJAEHaq9IACxplDgAAAAAAAAAATifEJAAAAAAAAOR6TBYlGABBhqzSAAsCxxUAQZys0gALBAhqhuAAQays0gALGKwbAADpVYbPAAAAAAAAAADNIAAAAABlFgBBzqzSAAsKRAgAAKZgAAAHLABB+KzSAAsMbQQAAAkTAAAAAKaVAEGcrdIACxAMRgAAAACFRgAAAAAAAKZjAEHKrdIACwaGRQAAZmYAQeCt0gALB+hZB0SoT6QAQf6t0gALDqcMAAAntAAAAAAAAKRvAEGertIACwLFHQBBvq7SAAsOBqIAAAAAKHkm2EgnhAcAQdau0gALBgaPAABnjwBB8K7SAAsEqjan5wBBkq/SAAsGhWcAAAcWAEGkr9IACwRJNuUEAEGyr9IACwrnEwAAAAAAAMVwAEHer9IACw7GIQAAAAAAAAAAKWSERQBB+q/SAAsIBDRsAqUYKy4AQZSw0gALLogDRwQAAKVeAAAAAEhwJ8IAACVaAAAAAAAAAACIfgAAAAAAAAAAx4kAAERw6hYAQdCw0gALAgkRAEGYsdIACwztHqUiAAAAAAAAZDYAQa6x0gALAuajAEG8sdIACxJuGqU2AAAAAAAAhwMAAAAAyl0AQfax0gALFob7AADEVwAABWUAAAAAAAAAAGhcxRQAQZiy0gALBulZRRWJPgBBrrLSAAsihrvpKAAAAABEOAAAAAAAAMekAAAAAAAARsgAAAAAailEXgBB2rLSAAsSBqsAAAAAqkUAAAAAAADoY0VqAEH8stIACwKKcQBBiLPSAAsGcgLEB2w5AEGms9IACwJG4QBBurPSAAsOpq4AAAAAAAAAAAgPxx0AQd6z0gALAoalAEHws9IACwpISyQZAAAAAIgUAEGWtNIACwLlTABBsrTSAAsMZ5sAAAAAAAAAAAh5AEHKtNIACw5GbgAAAAAAAGRxKimFDABB7rTSAAsOBBZIAycBAAAAACghBiAAQY610gALAmRQAEG0tdIACxDqD0ZMAAAAAAAAAACoeSb6AEHQtdIACwJMQQBB6LXSAAsCKkUAQfa10gALBsbFAABHxQBBkrbSAAsKZmMAAAAAAAAHNgBBqLbSAAsoiArHDwAAAAAAAAAAyGIAACwvBggAACa/AAAAAAAAAABJQifoa0MHigBB6LbSAAsKK3oAAAAAAABJBABBiLfSAAsKCANHAwAAAADKcgBBwLfSAAsE6BZmLwBB0rfSAAsCBWMAQea30gALAgfwAEH6t9IACxBmYAAAAAAAAGf3AACkcM4fAEHQuNIACwKOEQBB3LjSAAsQCDekBAAAhD8AAAAAAAAlQABBoLnSAAsIFAEAAAAApEIAQeS50gALGAxeBXMAAAeDAAAlEwAAAADqMAAAAAAH9ABBkLrSAAsUzg8AAAAAAAAAAAZQAABkPKkIB8oAQa660gALAsdbAEG8utIACwoKPAAA6T0AAAk7AEHWutIACw5EbakcAAAAAAAAAACGdgBB9LrSAAsIK36EXQAAZkUAQYi70gALBigYAACoUQBBorvSAAsKBHsAAAAAAACFFQBBvLvSAAsKbQoGxAAAAAALMABB1LvSAAsEiRQHbgBB7rvSAAsK5i0yDwAAAACEZwBBhrzSAAsCpsAAQZa80gALAuUqAEGovNIACwQpRicHAEG6vNIACxDGcwAAAAAAAAAAaWcAAEgYAEHyvNIACwLHAgBBiL3SAAsEC3AnnABBlr3SAAsKxskAAAAAAACHawBBsL3SAAsEi3jEDABB8r3SAAsSZHAAACRHAAAAAAAAAABoY6b/AEGQvtIACwQJDYYGAEGevtIACwyESwAAAAAAAAAAaGEAQci+0gALEBMEAAAAAAAAAADGPQAAplQAQea+0gALAoc/AEH6vtIACyLGfgAApncAAAAAyk7GJgAAAAAAAEdHAAAAACg4AAAICCdDAEGqv9IACwKEHgBByL/SAAsGyldGzjQGAEH4v9IACwxJKgAAAAAAAAAA5p8AQZLA0gALCAVwAAAAAFIWAEG0wNIACxAJZeZWAAAAAAAAAABoQ6eLAEHUwNIAC1AsIAAAbH0AAAAAAAArAAY4AACFQAAAAAAMeAAArA+FAAAAh57LA4ZdAAAAAItqAAAAAAAAzAAAAAAABGqMHSetyGtm4gAAAAAAAAAASFdlZABBssHSAAsOREwLfAAAAADGbQAA5+YAQc7B0gALFOUvAACGrwAAAAAAAAAASHsAAGorAEH4wdIACwgJSodHAABnsABBpMLSAAsCCwgAQcbC0gALAsdLAEHiwtIACwKm5ABB/MLSAAsEi1eHXQBBjMPSAAsQqi0AAAAA5Q8AAAAAbArGGABBqMPSAAsQCmzmBgAAAAAAAAAAyFoG2wBB0sPSAAs2R4UAAIVfAAAAAAAAAABrVQAAykSmJgAAAABIbYaXAAAAAAAAhqoAAEd7qi9mWgAAAAAAAKfEAEGSxNIACwImgABBusTSAAsa58IAAAAAAAAAAKo9pxAAAAAAAAAAAIoS5g4AQeDE0gALIihDxQGrQwAAaE/EDwAAAAAAAOQ9AAAAAAAAAACpa8R8KH4AQZDF0gALEOssBi4AAAAAAAAAAAomJ8UAQarF0gALAmaKAEG2xdIACx4mdAAAAAAAAMeOAAAAAAAAAAApJOYVAAAFNgAAZxsAQd7F0gALCCdiAAAAAGtKAEGAxtIACwIMCgBBjsbSAAsCZXQAQbbG0gALLmalAAAAAAAAAABNJAAA6EXm2u0PAAAAAAAAy3TnkQAAZ3gAAIYgAAAAAAAApkcAQZTH0gALBIlIJtMAQarH0gALDoaRAAAAAMl6RvAAAOYHAEHCx9IACwIlYwBB3sfSAAsEZQjJYgBB9sfSAAsE5DBpNwBBqsjSAAsC5CEAQcLI0gALEoaOAAAAAAAAAACJKoclAAAncABB6MjSAAsQSm8AAAAAAAAAAEVmKyilBgBBisnSAAsmhDoAAGceAADGbAAAAAAAAKbcNA8AAAAAAACKFsdAAADFZm40RE8AQcLJ0gALDkZwAAAAAAAAAADIOIYEAEH4ydIACwLJZABBksrSAAsGxqUAAAQNAEGqytIACwKHIABBxMrSAAsOyUOnBQAAAADrIIa9TwUAQdzK0gALBoo6AACofQBBhMvSAAsEDiTnCgBBmMvSAAsGyT6He60QAEGqy9IACwqnEQAAAAAIbUbmAEHEy9IACxCpIGRNAAAAAAAAAACoF8UeAEH6y9IACwLFVABBlMzSAAsIqCNlBAAApEAAQbDM0gALEIxDxhpoUwAATAkAAAAApw8AQcrM0gALBCVfahAAQejM0gALAqgpAEGSzdIACwRHp84LAEGuzdIACxUlOAAAxVDoDMcKKlCH/QAAAAAAACYAQdrN0gALCqZs8gqmIq4O5wQAQfTN0gALEEt1JiUAAAAAAAAAAMhFBzoAQZjO0gALAmxbAEG2ztIACwIGyQBBxs7SAAseprIAAAAAq1tHfgAAAABKKgfPAAAAAAAAxoFoekb7AEHyztIACxKmfQAAAAAzDwAAAAAAAGkbhQIAQZDP0gALIgttB7QAAAAAAABnVQAAxoUAAAAAS0EAAAAAAAAAAOQ2qFMAQcLP0gALAqabAEHOz9IACwpGmAAAAABoRCQdAEHqz9IACwJEPABB+s/SAAsCxG4AQaLQ0gALAmVjAEHG0NIACwJnLgBB4tDSAAsgx00AACdOAAAAAAAAZyqvAwAAAABFKgAAAAAAAAAAShAAQZTR0gALAmwmAEGq0dIACwKH/wBBvNHSAAsEiSZGYABBytHSAAsCR54AQd7R0gALAgQyAEGA0tIACwRLVmdcAEGS0tIACwrGewAAAAAAAOfkAEG20tIACwKkTABB0tLSAAsSZV8AAMRtAAAAAAAAJHoAAIQMAEH20tIACyjmOQAAAAAAAAAA603GJwAAAAAIJeU5LhEAAAAAxDgAAAAAAADnvlEHAEGs09IACwRNAgUGAEG609IACxolWwAAAAAAAEU3AAAAAAAAAAAQBSY4AACkagBB4NPSAAsCbBwAQe7T0gALAma6AEGE1NIACxIsFOUGAABFOAAAxpLKBwAA7BkAQabU0gALDqdsAAAAAAAAAAAICqQaAEHI1NIACyxILIdmAAAAAGhdAAAAAAAASHcAAAAAJoYAAIdFAAAAAAAAhVYAAOYXAACEZABBpNXSAAsK6GdGFAAAAAB2BABBvtXSAAsCZ5oAQcrV0gALAkaaAEHg1dIACwINDABB8NXSAAsYshIAAAAAAADJcIQZAAAAAChoAADpI8ctAEGU1tIACwQIfIb8AEGu1tIACwKFLABBztbSAAsYBmIAAAAA6UbHTgAAAAAAAGZDAAAAAG4DAEH61tIACwJmXgBBlNfSAAsCy2UAQbDX0gALEGh7AAAAAOcfKl9EGAAAxocAQczX0gALCAh/AAAAAIeuAEH619IACwZFRukhJnIAQZDY0gALCAsoJhOsBWc7AEGm2NIACwYmWQAA5SgAQbjY0gALFIlLBkVrAOYsAAAAAAAAAACpagUKAEHa2NIACxQG/MgA5W4AAAAAAAAAAOh5AAAqeABB+NjSAAsEiXJm7ABBpNnSAAsUiQylDMowh1gAAAAAAABlSeh6B0AAQc7Z0gALCqZQAAAAAAAAZmoAQeLZ0gALDkQ+iBEnGwAAAAAAAAa1AEGC2tIACwIlcQBBoNrSAAsIaFAnDQAABmMAQcDa0gALAhYHAEHW2tIACwLlQgBB9trSAAsCh9oAQYLb0gALAkVeAEGc29IACyxxCwAAAACmwwAAZgsMY2R1cwBGLgAAAAAAAAAA8AsAAAAAAAAAAOdE7wBnTQBB6tvSAAsCxo8AQYbc0gALAudTAEGS3NIACzIEbwoupBIAAAAAKA3HjQAA53oAAAAASTnkAwAAZlAAAAAAAAAEJwAAhVwAAAAAAABHzQBB0tzSAAsChB0AQeLc0gALBGcHiggAQfDc0gALEGtsZ2MAAAAAAAAAAEx5JvcAQY7d0gALBoaPAADkYABBxN3SAAsCSHkAQdjd0gALDipT5AgAAAAAAAAAAGtnAEH63dIACwLkOwBBjN7SAAsEaAznSwBBnt7SAAsqBvUAAAAAAAAkYwAAAADrbCQFAAAAACwexwsAAAAAAAAAACkaAAAAACa7AEHa3tIACxRFDAAAAAAAAOQ5AAAAAAAAAABuJABBgt/SAAsCBXsAQY7f0gALAqYZAEGc39IACwipGUQFAAAmZABBrt/SAAsIZE8AAAAAq0IAQdLf0gALDmQuAABGoAAAAAAAACVnAEHy39IACwqnLOltZjoAAKcnAEGK4NIACxyGcwAAAAAAAAAAKGpm4AAAAAAAAAAA6m/m4GsFAEG64NIACwKH4wBByuDSAAsCpUEAQfbg0gALDMYNAAClPQAAxBUoNABBjOHSAAsE6UinWwBBnOHSAAsOLTzlGgAAAAAAAAAAqDsAQbrh0gALAoUmAEHM4dIACwwoJcUPAAAAACst58EAQeTh0gALBOhs5uEAQfLh0gALBmejAACkVQBBhuLSAAsKpWMAAEZrAAClRgBBqOLSAAsGSjaEH0lnAEG64tIACxLkYgAAAAAAAAAAqj/lHEoWJ0sAQdzi0gALBHAF58YAQeri0gALDGfSAAAAAAAAAACrBQBBiuPSAAsCB4wAQbDj0gALEIlFxT0AAMQxAAAAAAAAx4AAQczj0gALAg0VAEHi49IACwaneQAARFAAQfrj0gALAubJAEGs5NIACyxNL0dKAACniAAA5FQQDgAAAAAAAAAAhrqIQ8erSVnHuQAAAAAAAAAAKGfmvABB8uTSAAsSBncAAAAACFzlEQAAhFcAAIbAAEGq5dIACxSnwgAAAAAAAIVry3sHAAAAAADrZABByOXSAAsYaRBlQAAAxFAAAAAAAAAAAKkOB1uIPyYPAEHs5dIACwKqLABB+uXSAAsCpR0AQY7m0gALAgffAEGm5tIACwokWYorBsAAAEdcAEG+5tIACwJFNgBBzObSAAsGyi2n6uoEAEHe5tIACwKESABB/ObSAAsYKW0AAAAAAAAAAGcVAAAmTshEZw3sKuR1AEGi59IACwMFYA4AQbLn0gALCuRjAAAAAAAAxG8AQd7n0gALAifRAEH259IACwKGgwBBlujSAAsaBiIAACQ3AAAAAHQAJAEAAAAAAADHkwAARqgAQcDo0gALF0hVAAAAAIZ9DwMAAAAABnkAAAAAAABEAEGU6dIACwwsFwAAAAAAAElIRzsAQbzp0gALBC4ORUIAQerp0gALAoVFAEH46dIACxIIAqakAAAAADIMAAAAAAAA6lcAQZrq0gALFoZvAAAAAAAAZsQAAAAASTVGFwAApokAQcDq0gALBCl1JEkAQeTq0gALGItQZyQAAAAAAAAAAKldAABJFAAAAACkLwBBnuvSAAsCRl8AQdDr0gALBIlOpQIAQeTr0gALAutyAEH469IACwwqTwAAAAAAAAAAhykAQZbs0gALAie6AEHK7NIACxAEaMgxAACoUAAAAAAAALABAEHu7NIACwaGAgAABGQAQY7t0gALFCb5AAAAAAAAAAAoYAAAAAAAACtTAEG27dIACxpGsgAAAAAAAAAAiwcAAAAAAAApUEfqAACGUABB7u3SAAsCp9sAQfrt0gALCid1AACHzgAAxlEAQZLu0gALAudBAEGu7tIACwJFHABBuu7SAAsCxrkAQdLu0gALAqYoAEHi7tIACwwmqAAAAAByCwAAiDIAQYbv0gALAqV5AEGW79IACwYHkwAApEQAQbDv0gALAgh6AEG879IACwKwAgBByO/SAAsMcAYAAAAAAAAAAEcnAEH079IACwGSAEGI8NIACwjJGMcAAACmiABBqvDSAAsCB94AQbbw0gALBga/AABkNABBzPDSAAsQiQlEEQAAAAAAAAAAzE+lAwBB6vDSAAsCR7EAQaLx0gALAsbVAEG88dIACwSMQuUCAEHO8dIACwrFawAAAABKdgZKAEH88dIACwLICABBkPLSAAsciWUAAAAAAACLCQAAAACGewAARjcAAAAAAAAHcABBuPLSAAsMaDwAAAAAAAAAAKbVAEHQ8tIACw7zDgAAAAAAAKwOAACpJgBB6PLSAAsEikoHegBBgvPSAAsCBGAAQZbz0gALAsRAAEG089IACxTpawAAAAAAABADJxKMfwAAAAAG+ABB1vPSAAsCRlIAQezz0gALCEwNZuQAAEV+AEGU9NIACwTKSOUKAEGm9NIACwpkIQAAAAAAAOVXAEHM9NIACwwJPgAAAAAAAAAAJ4wAQfz00gALBCofJEYAQY710gALFgRfAAAAAEkTAAAAAAAA6B8AAGw0ZCgAQa710gALAgQuAEHE9dIACwJIQQBB1PXSAAsE6ERHRgBBjPbSAAsCiQsAQZz20gALBIwjpkEAQcD20gALCMt3AAAAAEVKAEHU9tIACwTNAOY7AEH09tIACwKxBwBBhPfSAAsIiGYmzQAAhsIAQZr30gALAsQlAEGm99IACwiGEgAAAACJVABBuvfSAAsCRtEAQcj30gALAksWAEHY99IACxDKC6YwAAAAAAAAAABoCwYBAEH899IACwIJDgBBkvjSAAsCZl0AQaL40gALAkfaAEGu+NIACxYHAwAABqnKE0e/AAAAAMpZRRALIyavAEHO+NIACw5H8xABAAAAAAAAAADmyABB6PjSAAsCSm4AQZL50gALDiU0AAAAAAAAp8cpTyU2AEHE+dIACwRJAkYdAEHY+dIACw8IVcfzAAAAAAAAAAArH6YAQfr50gALBgaYAACm3QBBnPrSAAsEqD+HFgBBrvrSAAsCRH0AQcr60gALAmR0AEHc+tIACwhsXed1AACn5QBB8vrSAAsTJlAAAAAAAAAAAAkjAAAAAAAAtwBBkPvSAAsECgklRABBpvvSAAsMxFwAAAAAyx/nEgptAEHK+9IACxgmcwAAAACoQCdoAAAH0gAAAACINmcfCEkAQfj70gALBA4DhT4AQYz80gALCHIY5t1IQKcwAEGi/NIACwLkXABBsPzSAAsQiyQAAAAAAABpHGegzGCm4QBB1PzSAAsE7A4lCgBB9PzSAAsOKXLG7gAAAAAAAEfkSz0AQbL90gALGEaRiFfHAwAAAAAAACZa6mgAAAAAAAApTQBB3P3SAAsEKBWGNQBB6v3SAAsWBs6qT6eWAAAAAAAAh8cAAAAAiABEIQBBlv7SAAsCxGsAQaz+0gALAhMCAEHA/tIACxToIqcT6DCGSwAAAAArWSd2qm2keQBB8P7SAAsIaWvkRohOx+YAQYr/0gALGkVfAAAAAO0XAAAAAAAAAABFJQAAAADpX6dxAEGy/9IACw5kYwAAAACrJQAAAABH9gBB0v/SAAsChpoAQeD/0gALDIxQJy7zAQAACBTmCABB9v/SAAsC5rQAQYiA0wALBupb5pyICQBBooDTAAsCRjsAQbiA0wALAippAEHOgNMACwKGaABB2oDTAAsYx8oAAAAA7FsAAAAAAAAAACbIiWTGrU4xAEH+gNMACxoGDAAAJSQAAAAAaAQHVgAAAAAAAGZTAAAkQABBpoHTAAsCRv4AQdKB0wALCgRYAACGvgAAx4YAQfqB0wALAkUmAEGKgtMACxblNQAAh5UAAAAAygYAAOkBB7UAAEaxAEGygtMACwJmcQBBwILTAAsETBjm3ABBzoLTAAsGBWkAAIZwAEHqgtMACw6GswAAAAAAAAAASVAHwwBBhIPTAAsEywtGMABBnIPTAAsMy2cHNAAAAACNAmdbAEG4g9MACwgsVwAAAADEUgBB0oPTAAsCpGsAQeKD0wALGuZs61MFbAAABXTtAAAAiCkAAAAAAAAAAOaDAEGIhNMACwJLewBBlITTAAsEiAWHCQBBrITTAAsCiyUAQbyE0wALFOsVxUDpZ4aKAAAAAAAAhGgAAIfnAEH0hNMACwRoaYbhAEGYhdMACx7KHgAAAAAAAEhMRRkAAAAAiQQAAAAAAAAIHsdRqQEAQcaF0wALBucwAABmMgBB4IXTAAsOawkAAM0t5mUAAAAA6U4AQf6F0wALAiUrAEGehtMACwIHdwBBtobTAAsKJVR1BMZSAADkIwBB3IbTAAsEuABFBABB8IbTAAsa6hIAAGg1AAAAAMYvAAAAAAAAJCkAAAAA6SIAQZ6H0wALHkRxAAAAAMgtZmkAAGa0AACHqwp8AACIBGQPAAAkUQBBxofTAAsG5V8AAEZ/AEHuh9MACwJlfABB/ofTAAsSBgkMLgAAAAAnqAAAAAAAAKVJAEGiiNMACxKG+AAAAACIG6ZDAAAAAAAAxVUAQeSI0wALBA8EhxgAQYKJ0wALAqUvAEGWidMACwqGtQAAAAAYAAdNAEGyidMACwKnmQBByInTAAsEaVMGDwBB2onTAAsCR48AQfKJ0wALAgQsAEH+idMACwKmJABBmorTAAsS5nQAAEaDAABkEgwLAAAAAGdzAEG2itMACwLFdABByIrTAAsCTw4AQYCL0wALBKgqxxsAQZiL0wALAqgkAEGyi9MACwKkTwBB0ovTAAsK5pAAAAAAAADmaQBB6IvTAAsIaVUAAGlsBnYAQfqL0wALAifiAEGQjNMACwRoMUYVAEGojNMACwhITeRCAAAnywBBwIzTAAsC9gIAQeaM0wALAkRhAEHyjNMACxbEBQAAB/4AAAAAtQRHtgAAR3VpLUYEAEGkjdMACwJKJwBBso3TAAsCJ28AQcqN0wALEsQ5AAAAAAAAAACoQQAAAADmAgBB8o3TAAsChFQAQYyO0wALDUg+p1oAAAAAAAAAAPcAQaKO0wALCqdgAAAAAAAAhBQAQbyO0wALHgl15EhrUse2AACFGwAAAAAAAAAAa2QAAAAABET0DgBB8I7TAAsIqxYFFgAAB5UAQaKP0wALAsfqAEHEj9MACwJVAwBB0o/TAAsCB3YAQeKP0wALAiUiAEHuj9MACw7magAAAAAAAAAAqwDmDwBBjJDTAAsECV7GHABBtJDTAAsMiAhFFAAAxFEJBoQTAEHykNMACwIEHgBBqJHTAAsCqRgAQbiR0wALAmp4AEHOkdMACwJHawBB5JHTAAsMiFRH9wAAAADLDId5AEH+kdMACw4kLQAApDkAAAAAAAAEOwBBqJLTAAsMal0mcQAAAAAAAGUTAEHIktMACwToJ2cUAEHektMACwoGagAAAACVBOZOAEHyktMACwIm3QBB/pLTAAsCBBIAQZST0wALAi4uAEG0k9MACxBpReYeAAAAAIh8AAAAAKcXAEHYk9MACwIKIwBB8JPTAAsSyEFHXQAAAAArKwAAAAAAACh/AEGglNMACxxqUYU1AAAAAAAAR5HNHOcoSkQEYwAAAAAAAGaWAEHOlNMACwQFVKoXAEHelNMACwplDAAAAAAAAEclAEH0lNMACwRoRaQxAEGCldMACwKmkABBmJXTAAsWzDFnvgAAxi0AAAAAamIAAAAAAABJIwBBypXTAAsGpBMAAKZ1AEHaldMACwgHpwAAAACIDgBB7pXTAAsCZmIAQYSW0wALCEoVBRQAAObiAEGWltMACwJEbABBqpbTAAsqJFYAAAAAAAAAAIlmAABLPoQNAAAAAAAA5osAAAAAAACFHixMp30AAKVIAEHeltMACwrkbwAAAAAAAEftAEHyltMACwLEcwBBjpfTAAsWREMNPsYkqiUAAAAAAABRAgAAAACkXgBBrpfTAAsK5p0AAIRmAABFWgBB3pfTAAsehv0AAAAAAAAAAIsPZ+oAAAAAAAAnbgAAAAAAAIaoAEGKmNMACxrmcQAARHcAAAAAAAAAAMgzAAAAAAAAAAClQABBrpjTAAsCBGYAQcCY0wALAilZAEHQmNMACwIpBABB/JjTAAsEKUrFEgBBipnTAAsCJkUAQaCZ0wALDIwNAAAAAAAAAACHNABBwpnTAAsWJ94AAAAA8AakPQAAAAArCgAAKCiGegBB9JnTAAsISC0HDgAARAkAQYqa0wALAiROAEGYmtMACwwoLwYCAAAAAKgHJyMAQcCa0wALBAoc54AAQdCa0wALAmkGAEHgmtMACwhsGqUm6gGlDwBBiJvTAAsSqmKlFQAA5TYyAQdRAAAAAM4kAEGom9MACwjJLgQBAABniQBBvpvTAAsS5UcAAAAAAADGQAAAAAAAAMZXAEHcm9MACwroCgAAAAAAAMo2AEGInNMACwwKOkUPAAAAAAAAR+EAQaCc0wALDGs+AAAAAAAA6gqHOwBBypzTAAsOBGluIwAAAAAAAAAAhsoAQfSc0wALBCtMB5EAQaad0wALEgVLbiiGLgAAAAAAAAAA6zpEWgBB2J3TAAsBqQBB8J3TAAsUqjsHowAAxt0AAAAACQsAAMk2hQEAQZSe0wALBOpTpnwAQbSe0wALDOhPxgIAAAAAyGElVQBB1J7TAAsMq34EUwAAxnUAAKaoAEH4ntMACwiLLAAAAAAFBABBrJ/TAAsM7BokJAAA5vaoDUY4AEHMn9MACwgoWAAAAAAFUwBB4p/TAAsIx5oAAAAAzScAQYSg0wALBAl4BuoAQaSg0wALAukMAEG4oNMACwjsHSdhAABGAwBB2KDTAAsU7S7EMwAAJwIAAAAAAADHqAAAZ3cAQfyg0wALBOpuBHgAQZSh0wALBIlYxVgAQbqh0wALKuZyAAAAAAAAAADKPgYj9QClBQAAAAAAAAAAKGEAAAAAAAAAAEQzAADHigBB8KHTAAsEyzOlKgBBmqLTAAsKZ2IAAAAAAACENgBBsqLTAAsSZ9WpTCYvCwwAAAAAAAAAAGQ4AEHeotMACwgGVQAAZzyKcgBB8qLTAAsCJnUAQZaj0wALAmVcAEGoo9MACwhTCgAAAADnUgBB2KPTAAsCEhAAQeqj0wALAuaHAEH6o9MACwLnPgBBiKTTAAsMKQEkDgoNhCgAAIc5AEHCpNMACxLkdMlXRzapPMd+qnbkNAAAh3AAQeKk0wALBEb8zEcAQf6k0wALAsaWAEGQpdMACwLUBABBrqXTAAsMxn8AAAAAAAAAAO4RAEHmpdMACwKn/QBBgKbTAAsCaEEAQY6m0wALEiVOAAAAACg1pwQAAAAAAADn8gBBqqbTAAsCpF8AQcCm0wALAutEAEHaptMACyAEFQAAAABIfgAAAABG+QAAAAAAAGcLAAAAAAAAAACKQgBBlqfTAAsCh+sAQcin0wALEAoe5gEAAAAAAABmmQAAxr8AQfSn0wALAgsxAEGOqNMACxznUUlGZzEAAAAAAACkPmh/AAAAAAAAAACmP2shAEHiqNMACwJmiQBB8KjTAAsCinYAQYCp0wALIM05RA4AAAAATCCGMgAAptYAAAAAAAAAAEgKp4QAAIdaAEGqqdMACwKmjQBBuKnTAAsIrH8maQAApH8AQdSp0wALEAk9py62BAAAAAAAAAAAhEYAQe6p0wALIiZAAAAAAAAAJGcAAAAAaXAAAAAARmEAAAAAmAEnsQAAh4sAQayq0wALB0oOJkQAAKUAQcKq0wALCAcYAAAAAGhfAEHYqtMACwRqXuVeAEHuqtMACwZHLgAAp5oAQYCr0wALBE0l5AoAQbyr0wALAvIDAEHKq9MACwrHZex7AACpXiQHAEHmq9MACwyEQwAAAAAAAAAACEwAQYKs0wALFsR+AAAAAAAAx3AAAAAAAAAAAChFh9AAQaqs0wALBORFkgcAQbis0wALDuo/AAAAAGVUAAAAAIsTAEHSrNMACw6lWAAARlcAAAAAAAAm2gBB8qzTAAsCRVkAQYSt0wALBMgZBwEAQbat0wALAgRhAEHKrdMACwIHnwBB1q3TAAsCZoQAQeSt0wALAsgyAEH6rdMACwJkdgBBiK7TAAsCChUAQZau0wALAsRsAEHErtMACw5MRQAAAAAAAAAABWKIcQBB4K7TAAsEiDHGLABB9K7TAAsEVACHHABBjq/TAAsapGnJAQAAjFmG40hKAAAuCoeyAAAlFAAAxGEAQdCv0wALAhEIAEHcr9MACwLKfABB9q/TAAsGZoIAAAa7AEGMsNMACwKsYQBBnLDTAAsUKWZGiwAAx+LMdwAAAAAAAAAAhGUAQdiw0wALAmgRAEH8sNMACwSIHWdQAEGSsdMACwKGkgBBprHTAAsCRqcAQb6x0wALKsUGAAAAAAAABCAAAAAA6SsAAGx3pusAAKU6AAAAAAAAxp4AAARdAAAmJwBB+LHTAAsESjIneQBBiLLTAAsWSAYAAAAAAAAAAIRHAAAAAAAAAADqaQBBrLLTAAsICB9mBQAAJS4AQc6y0wALBsVfAABlLQBB6rLTAAsOxlQAAAAALDNGIFQKJR8AQZCz0wALMAkEJTEAAIViAAAAAAAAJqCtPwf2AAAAAAAAAADvBGYkAAAAAAAApkkAAAAAzQZnhABBzLPTAAsCCWcAQeKz0wALBqV9AADHxwBB8rPTAAsC5HIAQYS00wALBIoGhhAAQZK00wALDAYpAAAAAAAAAACpFQBBqLTTAAsEMwhmsABBwLTTAAsGTTcAAEtpAEHYtNMACwLIQgBB9LTTAAsEqmlGGgBBiLXTAAskim8AAAAA5hsAAAAAAAAAAChCAAAAAAAA6WQAAC8RRBsAAIa0AEG2tdMACwSGKaxSAEHItdMACwSOCae9AEHitdMACwJFNABB9LXTAAsEKDxnLwBBgrbTAAsEphJKAgBBlrbTAAsGx1wIJsQRAEHYttMACxzpY6dzahhlBgAAAAAAAAAACFYAAAAAAAAAACRXAEGSt9MACyImkuxdAAAAAAAAijgndAAApRsAAKazAAAAAAAAAABod2ecAEHet9MACwYGGAAAhBAAQe630wALAidsAEH+t9MACw7kXwlURgUAAAAAAABHgwBBnLjTAAsECC6GBQBBrrjTAAsEREesAwBBvrjTAAsCZhwAQd640wALAkVBAEHuuNMACwInvwBB/LjTAAsCbFwAQZq50wALAmbQAEGoudMACxiMEOY/AABGEQkahH8AAAAA6AKkRgAABisAQcq50wALAkRzAEHaudMACwoGHgAAAADpM2YVAEGYutMACxJIMgAAAABGXu0DhFkAAMV6aFsAQbi60wALEghvAAAAAAAAamTlaQAAAADpZgBB1rrTAAsHJmIAAAAAWABB7LrTAAsUiEIAAAAAJ1UAAAAATCcAAAgwhFUAQaS70wALHClR5zcAAEbj6H0AACooAABJCActAAAAAAAAJTAAQc670wALEoRwKAnFHwAAAAAAAAAAaFXn9ABBmLzTAAsI0woAAAAApFoAQaq80wALAoYYAEG2vNMACwzlZwAAAAAAAAAAaFoAQcy80wALBEh8Zk4AQeS80wALEIhfRggAAAAAAAAAAKoZhAQAQYK90wALFsZ2AAAAAAAA5G70DQAAAADnZ4owphQAQaK90wALAmcTAEHAvdMACxCKYWdeAAAAAAAAAABJcEYSAEHevdMACwOkBewAQfK90wALAuRLAEGAvtMACwIsCABBlL7TAAsCCwsAQaC+0wALCKlNBEsAAOUtAEG2vtMACwomRgAA5kUAACZJAEHivtMACwLmIwBBlr/TAAsOBlSpEwAAAAAAAAAAR1kAQa6/0wALBgY5AAClcwBBxL/TAAsMaQIAAAAAAAAAACa4AEHkv9MACwIrDgBBgMDTAAsasQjnOQAAAABNCiYYTgDmOgAAAAAAAAAAKE8AQabA0wALCoePLBAHrshDZ2QAQcjA0wALAsg2AEHWwNMACwJkbQBB4sDTAAsCpB0AQfLA0wALAicIAEGYwdMACxRsRgAAAAAAACwBhDcAAAAAagWHnQBBuMHTAAsIankAAAAAZlcAQcrB0wALAoaLAEH2wdMACwqkZ0weAAAAACZKAEGQwtMACwYoGYcEDBwAQaLC0wALGsayAADG4QAAZEEAAAAAkhom7AAAAAAAAGZnAEHGwtMACwZm/woRRh4AQdjC0wALBogjhxJOAQBB6sLTAAsKJpwAAAAAAADkZABBmMPTAAsK0wsAAAAAAADIPQBBssPTAAsCx7wAQcjD0wALDCg/R6MAAAAAil+FIQBBjsTTAAsCBDAAQbLE0wALEOfUAAAAAAAAAADpE4R46EgAQc7E0wALCGRAAAAAAMlqAEHuxNMACwJmjABB/sTTAAsCBBEAQYrF0wALCsbeAAAAAIkF56AAQZ7F0wALHoVbAAAAAAAAAAAoJ+dUAAAAAI4nAAAAAAAAAABmSgBByMXTAAsEKV5mEgBB8MXTAAsQKhEAAAAAAAAAAMUzAABH3ABBlsbTAAsC5koAQarG0wALDqbaAAAAAAAAZssAAAQ9AEHCxtMACxJkCgAAAAAAAAAAjFQAAAAA58wAQebG0wALAsYiAEH0xtMACwgsDAAA0AGmhwBBiMfTAAsMq2GHMAAAJGpoB6ccAEGex9MACxZmiwAAAAAAAAAAkA0AAAAAAAAAAIZXAEHGx9MACwLGsABB4sfTAAsGhFIqXGeBAEH0x9MACwQsQUdWAEGQyNMACwIKIgBBpsjTAAsCBtoAQbTI0wALCg0QpFsAAAAAqiIAQdDI0wALAZMAQezI0wALBgh1pvcWBQBBgsnTAAsC5mAAQZbJ0wALAkcmAEGmydMACwJlegBBssnTAAsCZUwAQb7J0wALCkUWAAAAAAAAJvYAQdbJ0wALAgZTAEH2ydMACwrEMAAAAAAAAMa8AEGWytMACxKnPQAAAACyBAAAAAAAAAAAhloAQdTK0wALIA4MJ8AAAAAACxUlOwAAAAAAACUNAAAAAAAAAABsTsU2AEGIy9MACxp4AQadAAAAAAAAR8sAAGRhAAAAAAAAAAAoAwBBvsvTAAsChCYAQcrL0wALKqdcAADkUwAAAAAAAAAAKFHHEgAAAABpDCZBAAAAAG4AZSoAAAAAAADmQwBBhszTAAsCxqkAQbTM0wALBEwdZhMAQcbM0wALBobLAADEXwBB5szTAAsop2cAAAAAAACntAAAAAAAAMU8AAAAAAAAAABMAGfMAAAAAAAAAADKRQBBos3TAAsCprYAQa7N0wALAuVKAEHCzdMACwIGrABB6M3TAAsCqQsAQfbN0wALCuY3AAAAAE0IB7MAQYzO0wALHG4mAACrMyRMAAAAAAAARHQAAAAAAAAAAK4CZXUAQbLO0wALEkV4iwBlUQAAAAAAAAAA9gFlSABBzs7TAAsCp0oAQdrO0wALCqR6AAAAAAAAJEQAQfLO0wALAsbCAEGQz9MACyQKZCYCAAAAADECAABqcQAAAAAAAMgNAAAAAAAAswZFORIA5/cAQcjP0wALAmo3AEHgz9MACxiKc4bmAAAGmgAAAAAAAAAAygjkQAAAJHwAQYTQ0wALCM4BR0IAAGVxAEGW0NMACwKmWwBBqNDTAAsQ6AYAAIkXZkIMBwAAAACm0wBByNDTAAsILDcAAAoYBnQAQdrQ0wALAiQeAEGC0dMACwanvgAAZCAAQa7R0wALCgVALRcAAAk6Z8gAQc7R0wALDCeLiSMHWgAAAABIWgBB5NHTAAsCtgEAQfTR0wALBpcAJiRuBQBBhtLTAAsWx9MAAAAAAAAAACsYAAAAAAAAAAAnMwBBtNLTAAsIiiYAAAAA5ugAQc7S0wALCsZiAAAAAChdRX0AQerS0wALCCckiwimO7UBAEGG09MACwIlTABBntPTAAsC5C0AQcbT0wALAgZCAEHa09MACwbEVkkHh0QAQezT0wALDOxVAAAAAAAAAACn2gBBiNTTAAsEin2kUgBBmNTTAAsUqTcAAAAAAABUCQAAAAAAAAAApxoAQcbU0wALCkZoAAAAAKsXB9EAQd7U0wALBIbBDxgAQfzU0wALCAwE5F0AAMUJAEGQ1dMACwgLREfIMQ0mOwBBpNXTAAsIjxOm8wAAZ94AQcLV0wALAmZfAEHU1dMACwKuAwBB6tXTAAsCZ24AQfrV0wALFAY9AAAlTQAAAABLBgAAy1bHvSliAEG21tMACwJERABBzNbTAAsU0QIAAAAAAAAAAAZ/AAAAAAAAJUgAQezW0wALDggX53RJDgZaAAAAAI4MAEGM19MACwFwAEGY19MACwjoC8cBAAAkeQBBrtfTAAsG5loAAKV/AEG+19MACwLGlABB2tfTAAsCJBMAQe7X0wALLsVjAABkSQAAAADoVkcFAAAm8awRpXcAACc68gCHcQAAAABIOIUSAAAAAAAAxpEAQbTY0wALBqofAABrfQBB0NjTAAsQyQUAAAAA5G0AAMZkAACH6QBB6tjTAAsKxuYAAAAAAABGWwBBgtnTAAscp3gAAAAAAAAAAEg/AAAAAAAATwEAAAAAAADKAgBBuNnTAAsECngGJQBB0tnTAAsWZkkAAAAAAAAAAJcCAAAAAAAACgTHegBB/NnTAAsMqHUAAAAAAAAAAGU2AEGU2tMACwToCGY0AEGk2tMACxAMVodcyQsnKwAAAADqVMZIAEHC2tMACwImdgBB3NrTAAscaUMAAIhVJ/kAAAAAAABmUgAA5kgAAGRkAAAFWABBgtvTAAsGxRioFmcrAEG+29MACw4nPKoyZRkAAAAAawxGZwBB2tvTAAsGhj0AAAYzAEH029MACwGOAEH+29MACxIkU6krJxEAAAAAAAAAAItMx54AQZrc0wALGmUuAAAAAAAAR2cAAAAAAAAAALcC5r9La8QuAEHA3NMACxjpJgAAAAAAAOp7BvYAAAAAAAAAAMk95s0AQf7c0wALAiZgAEGK3dMACxJGUAAAAACqE2YPAAAAAAAAZ7MAQbDd0wALAvQJAEG+3dMACwImsgBB7N3TAAsITQ0mMcs8R9MAQYze0wALHIpeBRcAAAAAAADGrAAAAAAAAOUVAACmugAA5n0AQb7e0wALEmYbAAAAAAAAAABoQGcMAABlagBB2t7TAAsCxp8AQere0wALCAR9ynoAAEhfAEGU39MACwTKcWbjAEGk39MACwJKcQBBut/TAAsCRtgAQdLf0wALAiaUAEHk39MACwoKBQAAAAAAAGkSAEGI4NMACwJMUQBBqODTAAsUCwfGAwAAJEUAAAAAjgKlSgAAx8kAQcbg0wALBOYoMAYAQdjg0wALFMoJAAAAAEdizxAAAAAAAACLAQc+AEGA4dMACwhIBYcZAADETABBtOHTAAsUchLlHgAAAAAAAAAAyHUAAAAA5vwAQdTh0wALCmkIpSMAAAAAFwEAQYbi0wALAqajAEHU4tMACwQwBYZCAEHm4tMACyCH0wAAAAAAAAAA7wYH1QAAAAAAAAAAiHsAAAAAAADuGwBBlOPTAAsEMAdnjABBouPTAAsCh9wAQcbj0wALCub7AAAAAAAA5scAQYrk0wALAiYQAEGi5NMACwLEQgBBvOTTAAsKDAAGP6tNB5wpKABB7uTTAAsCp64AQZDl0wALBC03ZwkAQajl0wALAilpAEG05dMACwisVgAASlFFJwBB5uXTAAsCJHIAQYTm0wALQApuAABoOwAAAAAFf2gWR0vqDSYpAAAAAAAAB+kAAAAAAAAAAMxpBuwAAAAAiWEAAAAAAABMCgAAAAAAAAAApWYAQdrm0wALDoR3Cg4AAAAAAACqIOU4AEH05tMACwQpKiYwAEGU59MACxgSFybpAAAAAClaBQIAAMQ8AAAAAAAAJiEAQfLn0wALAqVNAEGE6NMACxRJHQAAAADlZQAAAADoXGf4qBmmGABBqujTAAsCRicAQcjo0wALDGobhjiqSQAACRakKQBB4ujTAAsExorrBQBB/OjTAAsMCGwAAAAAhiUAAKaaAEGe6dMACwKm0gBBwOnTAAsG6ADnEGkxAEH66dMACwLnTgBBiOrTAAsQamgAAAAAAADIS2c5AABmegBBwurTAAsChUwAQdTq0wALCMgThC4AAMVqAEHq6tMACwqHugAAAAAAACZoAEGC69MACwJn2QBBruvTAAsCZRgAQcDr0wALBEhbp/kAQdTr0wALArYHAEHk69MACwRIIeVdAEH269MACxanZgAAAAAAAGZZAAAAAAAAhmwAAOZ3AEGi7NMACxyngwAAAAAAAMV2AAAmhwAAZ8cAAAAAAAAAAHQHAEHS7NMACwTnBYlVAEHi7NMACxLGyAAAJmEAAId/AAAAAAAAx4gAQYLt0wALAsQrAEGQ7dMACxZOHofiAAAAAAAA5XgAAAAAFgAkO8ojAEGy7dMACwbEY6hOxBsAQdzt0wALBitAJSpNJgBB9O3TAAsISBIAAAAAx80AQYbu0wALCiQ6AAAAAAAApEEAQZzu0wALBGolpxQAQa7u0wALAgaFAEG67tMACwKESgBB2O7TAAsYyx2n2QAAJ5puOAbkAAAAAAAAAACpW+U9AEH67tMACxKGlgAAAAAAAOVFqioAAAgcpgIAQZzv0wALBCkMx7QAQa7v0wALFiZbAAAAAKhG5FoAAIbzAAAAAAAA5UAAQdbv0wALAiaVAEHk79MACwLMYgBBiPDTAAs0aChHAC4ZAAAAAGUHAAAAAFIEAAAIcCR4AACmoAAAAADUBQAA7TsAAAAAAAAAAKdEAADkUgBBxvDTAAsG5GEoCERVAEHW8NMACwJmAQBB4vDTAAsKREEAAAAAAACEBgBB9vDTAAsC5C8AQYjx0wALAu4PAEGU8dMACwqpMUcYAAAAAGlPAEGy8dMACwLkeQBByPHTAAsUlA4AAG4GAAAAAERrAABmhuhCBTgAQebx0wALAkdMAEH88dMACwLoFwBBpvLTAAsmZyEqVOQnzAuHCwAA5kQAAAAASRvHr6oIBSAAAAAACHeG9wAAJGgAQeTy0wALAvEEAEH08tMACwwyCgAAAAAAAA4sR08AQYrz0wALAkRNAEGY89MACwQxCWQqAEG489MACwQtFeReAEHW89MACwJnhgBB5PPTAAsESDwmUQBB+PPTAAsMSDAFKgAAAAAAAGaBAEGa9NMACwaFcwAAJwkAQar00wALAmf2AEG+9NMACwYHqAAApj4AQdT00wALBMgF5WMAQeb00wALAociAEH29NMACwJFYABBkvXTAAsCxxMAQZ710wALAgazAEG09dMACwg3AwAAAAAn+gBB1vXTAAsCxDsAQeT10wALCGwLp7ZoGkRLAEH+9dMACxKGhQAAAACJD+VGAAAAAAAAx30AQaL20wALEuRbimUAAAAAZygAAAAAAAAFJgBBxvbTAAsChBIAQdr20wALHGVBAAAAABISR1sAAAAAqHoAAAAA5Q0AAAAAihAAQYL30wALAkZvAEGO99MACwaFNwAAZ98AQaj30wALAfAAQbL30wALBCb/iHQAQdr30wALKiV1AABmfAAAAADqHwAAAABFEeprpHgAAAAA7E4AAAAAAAAAAEauFgKEUQBBnvjTAAsGJnAAACUoAEGu+NMACwZHcwAAZU0AQdz40wALAoxpAEHq+NMACxZmzwAAh4kAAAAAAACmkgAARvGIIWUfAEGk+dMACwTIMOVYAEHC+dMACwIGXQBB1vnTAAsKBU4AAAAAAADH+QBBhvrTAAsKpowAAAAAAABESgBBtvrTAAsChCEAQcb60wALAmVGAEHY+tMACwxQAOYEAAAAAAAAhqYAQfL60wALAoY/AEGU+9MACx5MCIdjAAAAAAAAAADpQQAAAAAAAAAARgwAAAAAC0gAQbz70wALCE0PAACJIqYEAEHy+9MACwKlUABBivzTAAsWRCQAAAAASl+HoQAAAAAAAGekAABm9ABBtPzTAAsgSBpnEAAAAAAAAAAAq2MAAM8EAAB2AQc9AAAEdQAAJjcAQd780wALAmdKAEH+/NMACwLmewBBlv3TAAsOpFEAAGdBAAAAAAAA5nAAQbz90wALAhIKAEHQ/dMACxYONgAAAABEJwAAAAAAAAAACB0Hq8lCAEHw/dMACwppAwAAAAAAAI4BAEGM/tMACwgLIQdcAAAmzwBBsv7TAAscposAAOcPAAAAAAAABpcAAMahAAAAAAAAAACILQBB2P7TAAsEqw/HpgBB+P7TAAsCCWMAQYj/0wALBClqZFcAQZb/0wALAgR5AEHK/9MACwbGtIgPpzEAQeb/0wALAiVQAEGAgNQACwzoD0YrAAAAAKlAZQkAQZyA1AALAm4KAEGqgNQACwLmgABBuoDUAAsaxrcAAEV3AAAAACorBiZJMwAAAAAAAAAAxlsAQd6A1AALCsbjAAAAAAAAx+AAQYKB1AALAsYBAEGQgdQACwYrFCfprAgAQaKB1AALAkZzAEG6gdQACwakQwAAZU4AQdKB1AALAscUAEHmgdQACwImagBB9oHUAAsCpVkAQZSC1AALAghLAEGigtQACyrFUQAAAACKFyYiAAAAAAAA5EMAAEcz7QoAAAAApHUAAAAASxdEHwAAJt8AQdaC1AALCmanyDkneAAAhGEAQYKD1AALAiVCAEGQg9QACwRIO4efAEGwg9QACxoUA4V2AAAAAAAAAAAsUiZeAAAAAAAAAACrdQBB7oPUAAsKRVgre6VoAACn6ABBlITUAAsEiCSndABBqoTUAAsC518AQbqE1AALIiRQAAAAAAAAJppRDgAAaW4AAEoiBvsAAEbgrCMAAAAAZEcAQfCE1AALDOhmBXgMAidNAADkNQBBkIXUAAss60YAACkyAABKAKZhCzUlBAAAx/oAAAAASCIAAAAAR+sAAERjAAAAAAAAB+cAQciF1AALDAg45gUAAAAAAADmlQBB5IXUAAsCKTQAQfqF1AALAuYkAEGKhtQACwJlfwBBpobUAAsWhE0AAAAAAAAAAAs6AAAAAAAAAAAGGgBB7IbUAAsGSjcAAEp0AEH8htQACwSIQIYIAEGKh9QACwQGjQwNAEGeh9QACwJlYgBBwIfUAAsCaD0AQc6H1AALDuZYAAAAADABAACrDCU3AEHwh9QACwQKFIcxAEGeiNQACwTlVMkoAEHGiNQACwIHjQBB0ojUAAsGJlwAAIfgAEHwiNQACwRIKsRHAEH+iNQACwYGiWo9pzIAQY6J1AALAieHAEGqidQACwaH0QAA5pYAQbyJ1AALEil5RSwAAAAAAAAAAMhKAAApJQBB3onUAAsOh93qXQAArQQAAAAAhuQAQf6J1AALBiYg6RfESABBkIrUAAsCymIAQZyK1AALAuoFAEGsitQACwYqOEYma34AQbyK1AALAmklAEHKitQACwKkaABB2IrUAAsESgElKQBB5orUAAsCBqUAQfSK1AALCNITJFIAAOeUAEGIi9QACxb4AAAAyHlm8gAAJ9AAAAAAAAAAAA8BAEG4i9QACxQIJEUIAAAAAAAAAADKPecVAABmzQBB3IvUAAsGSEfFXepZAEH8i9QACxCrAQAAAADmmwAAAACoG4csAEGgjNQACwTMVibiAEGyjNQACxZkMwAAhQXvAwAAAAAAAAAAp1MAACdUAEHajNQACxbmogpYZSUAAAAAAABmIgAAAAAIGyfcAEGGjdQACwjnpAAAAACMNQBBoo3UAAsCRUAAQbCN1AALBi4G5AbSDABB0o3UAAsUhS0AAAAAAAAAAGsvAAAqc2R5iQYAQZKO1AALCkadAAAAAAAARoQAQaaO1AALAgRSAEGyjtQACwIHEgBByo7UAAsGp6tNAadLAEHejtQACwbFaAAAhX4AQYCP1AALBEgTpy0AQZaP1AALAoUqAEGij9QACwJGZQBBsI/UAAsC6z0AQcSP1AALDKggAADqQgYfAADELABB7o/UAAsE5kaoNwBBmpDUAAsKJlcAAAAAAAAGpwBBtJDUAAsEqnLGFQBB8pDUAAsChXkAQZKR1AALAuQrAEGukdQACwrEIwAAAAAJB8c2AEHCkdQACwLG8wBB4pHUAAsCRFwAQfiR1AALBCp55v8AQYqS1AALAkZmAEGaktQACwJFbABBqpLUAAsCZrcAQcaS1AALDoR5AABmLAAAAAAAAIUOAEGQk9QACxBoIaYXCw0AAAAAAAAAAKbJAEGuk9QACwKGDgBBzpPUAAsGxm4AAMQKAEH4k9QACwi2BQAAAADmawBBjpTUAAsGJvRKOKfdAEHAlNQACwKuLwBB2pTUAAsOxo4AAKaUAAAAAAAA5VIAQfaU1AALDsVpAAAAAApCAAArMUUvAEGQldQACwyuKGdwCVUH6wAARt0AQaaV1AALAgRRAEG0ldQACwgrF+cUAADG/wBByJXUAAsQKR+nzQAABBMAAAAAAACn2ABB4pXUAAsCxX0AQe6V1AALCoU0AAAAAAAAB2gAQYKW1AALIuUrAAAAAAAAAADRAAUFAAAAAIgHAAAAAAAAAABGqSldhFoAQbSW1AALCohg5/NrIocN6U8AQdCW1AALBIg+x9sAQeqW1AALLsbr6VilGQAAAACoeCZsAAAAAAAAxUIAAAAAAAAAAGlWAAAAAAAAqR1mNwAAx20AQaKX1AALAkawAEG+l9QACwJkfABB2pfUAAsMREgAAAAAAAAAACpuAEH2l9QACwbEZgAAZXMAQaKY1AALCoRzAAAAAAAAJVMAQbaY1AALAqftAEHCmNQACw7Hdk0+pQsAAAAAAABntQBB2pjUAAsOZ12JZ4ZiCzIHFwAAxxgAQf6Y1AALAkd8AEGQmdQACxDoTAUoAAAAAAAARXppaSRxAEGwmdQACw1IasR5AAAAAAAAAADYAEHqmdQACwKkPwBB9pnUAAsCJyIAQZKa1AALEiYZAAAAAAAAJ4IAAAAAAAAGggBBtprUAAsipVZLHcZgAAAEKgAA567UAgAAqGRFZClh5RSpYgAAAAAm1QBB7prUAAseRwG3AWUBAAAAAIgZBCEAAAAACgcAAAAApu8AAMU6AEGim9QACwLHlQBBuJvUAAsC634AQeab1AALEGVZAAAAAEl9AAAAAAAASiUAQZac1AALCGRsAAAAAIhaAEG2nNQACwIHYABBwpzUAAsSRoUAAAAAAAAAAG4IAADSFYR2AEHunNQACxKEXwAAAAAAAAAAaQkmEQAAhF4AQYyd1AALDgh+RGlrUAAAAAAAAGsIAEGwndQACwToEKRmAEHEndQACw4MXAAAqjBnLAAAAABKYgBB3p3UAAsChv8AQYqe1AALCsaAAAAAAAAAZocAQZ6e1AALEkaZAAAAAAAAAACILOYnCgGkMABB1p7UAAsSRTsAAAAAAABkNQAApjMAAERbAEHyntQACwKlLgBBhp/UAAsS52MAAAAAAAAn4AAAAAAAAEQoAEHQn9QACwUxC0ckSwBB6p/UAAsWBFRsV4boAAAAAAAAJVwAAAAAAACGyQBBlqDUAAsGJRKMD4duAEGmoNQACwJkMABBvqDUAAsG5lQAAMdEAEHioNQACwInowBB8qDUAAsCBEgAQYKh1AALDMZVAADmSwAAAAC0BABBoKHUAAsEqAzH1wBBrqHUAAsUxHcAAAAAAADlcAAAAAAAAAAAbBIAQdih1AALGOotAAAAAAAAAABGVgAAJFgtIgAAAADnbgBBhqLUAAsCRgsAQZai1AALAoZxAEGmotQACyamnQAAAAAsPmaaAACnNQAAAAAAAAAACnEAAJcBpg8AAAAAAAAkaQBB1qLUAAsEhmtIdgBBmKPUAAsICmAAAElgBhQAQcij1AALAuwhAEHYo9QACwjrWQAAaVenSABB9KPUAAsUyWsHJgAA5E4AAAAAAAAAAAhuJ70AQZKk1AALAqd6AEGypNQACwJENgBBvqTUAAsYxkQAAAAAijtHdApnJUUAAAAAiDgAAOgSAEHipNQACwiEYAAAhSTqEABB+KTUAAsICT8AAAAAJogAQZal1AALAudhAEGkpdQACwTLGScxAEG4pdQACwQJHQRyAEHGpdQACwomegAAAACIWUcMAEHapdQACwKlWwBB7KXUAAsQagIAAAAAAAAAAIVTAAAELQBBiKbUAAsCDFIAQaim1AALBDgBx1oAQcSm1AALDgkJAAAAAKaeAAAAAOk5AEHeptQACwzHtQAA5qCtHgAAqHsAQfym1AALBGkNhxQAQY6n1AALDqaEAAAAAAAAAABIAIU8AEGqp9QACwLmjABBuqfUAAsChDkAQcan1AALAoR0AEHWp9QACxCGSShOAAAAAAAAAACGCYgLAEGAqNQACwIODQBBnqjUAAtCZF8AAMRNAAAAAAAApR8AAEdEAAAAAMoNAAAKIIdyAAAAAGwEhRoAAAAASV0AAAAAAADKEgAAAABGtwAAAAAAAGaiAEHyqNQACwLGvQBBjqnUAAsKppkAAAAAAAAFZgBBpKnUAAsC7BMAQbCp1AALCMhbpWzND4bWAEHEqdQACw5JGQQdAAAAAAAAAACIGgBB3KnUAAsE6A1nfQBB9qnUAAsSBtYAAAAADhsAAAAAAAAAAIZAAEGSqtQAC0JGUQAAAAAAAAAAMQdmDAAAAAAAAAAAjCXGRwAAAAAAAAAA6H8AAAAAxyUAAOfpAAAEW4kfAAAAAKY5AAAAAAAAZigAQeCq1AALBOhgpzkAQfCq1AALCIsVAAAAAAQ6AEGgq9QACwgyCedaAADkfwBBvKvUAAsCKEgAQc6r1AALAqaBAEHgq9QACwQMI6VUAEH6q9QACxLmYwAAAAAAAAAA6BMAAMs3R9gAQZ6s1AALDGQxAAAAAAAAAAArEgBBuKzUAAsKlQIAAAAARjUKTABBzKzUAAsGKXoAAEofAEHcrNQACwyLDAAAAAAAAAAAxvcAQfKs1AALAoU7AEGArdQACwRKSoUJAEGordQACxToNwAAAAAAAAAAxEEAAAAA1wGHjABB8q3UAAsChxcAQYSu1AALEEktpyUAAAAAAADn2QAARBYAQdau1AALDgRtAADmZwAAAAALGkYZAEHyrtQACzpG9AAAAAAAAAAAikAHbQAAAAApJwQcAAAAAAsDAABoAUVEAAAAAAAAJ/JIHiUe1gUAAAAAAADJZyafAEG6r9QACwYmZ+ooxH0AQcqv1AALBofFiUDELQBB2q/UAAsCBtkAQfKv1AALEubxAABEZwAAAAAAAAAAaxFmKQBBmrDUAAsGByQAAIZyAEGqsNQACwIH7ABBurDUAAsK5rcAAEbEAABEMQBB0rDUAAsMZ/EAAOfWAABEUo0cAEHosNQACwzILgAAAAAAAAAA51sAQYCx1AALEmsoRj4AAOeEAAAAAAAAAABpEwBBorHUAAsCRXEAQcqx1AALAmaOAEH0sdQACwKKDQBBurLUAAsEBE3IcABByLLUAAsCiFYAQday1AALCuZmAAAAAAAAJCYAQe6y1AALECZVAAAAAAAAAAANAMUaiH0AQYyz1AALCO4CAAAAAObUAEGms9QAC0JntAAAAABxAkZZAAAAAAAAAAANCCRcAAAAACkrxtsAAAAAakjlBQAAAABqQ2URAAAAAAAAAACNMAAAAAAAAAAAph8AQfSz1AALBoofAAAsXQBBkLTUAAsQCD9kDQAA5GwAAAAAAACkHABBqrTUAAsS5HAAAAAA7AgAAAAApUTJAOQFAEHOtNQACzaFeihsJVgAAAAAAAAnFAAAAAAAAAAA6BFnpgAAAAAAAIatLASFWgAAAAAAAGUCAAAAAAAAZTEAQY611AALDMRpTBoAAAAAAABJDwBB2rXUAAsG5FYodSc+AEHqtdQACwLGWQBB+rXUAAsCpsUAQYi21AALBCkUJgYAQZ621AALFKRKAAAAAAAAxogAAAAAAABkZYtxAEHGttQACwLntwBB3LbUAAsWTAXn8QAAAAAAAMf7Sgjn+gAAAABLSQBBhLfUAAsSiwOnhgAAAAAAAKaYAAAAAMsHAEGqt9QACwLG3ABBxLfUAAsQNgMAAGo+h60AAAAAKAxFAQBB3rfUAAsCJTwAQfS31AALDKkExhBoE8c8AABGtABBirjUAAsC5UkAQZi41AALIMgmp5IAAAAAAAAAACkzh5AAAAAAAABGPAAAAADoIMdzAEHSuNQACwKGZABB7rjUAAsSJ54AAOQzAACFKwAAAAAAAIR+AEG4udQACwSyFGbhAEHKudQACwIEMwBB2LnUAAsEKSAmpQBBhrrUAAskRo4AAAAAAAAkHwAAAAAAAAVIAAAAAAAAAADuHAAAAAAAAAkkAEG8utQACwgpNue5LEfH0QBB/LrUAAsC7AoAQYi71AALDGxhR0MAAAAAAAClMwBBqLvUAAsC6D0AQbS71AALBOoXxwYAQdy71AALBEhC50YAQeq71AALAoa5AEH4u9QACwTpZSZMAEGGvNQACwKGPABBnLzUAAsQiXAAAAAAAAAAAOemAACG1wBBwrzUAAsCBVAAQdq81AALAubkAEH2vNQACwJEOwBBir3UAAsK5okAAAe87FFGgQBBnr3UAAsCJSYAQbK91AALFoeaAAAAAKg1JhsAAAAAAAAAAGpcxyIAQda91AALAoZYAEHivdQACwQG5iwdAEH2vdQACwIm/ABBgr7UAAsKBroAAAAAAADGxgBBlr7UAAsEBuGQAwBBrL7UAAsOqQUAAJEEAADOAke0SC8AQca+1AALAma8AEHcvtQACxDrBAAAAADGg6haZ/QAAIb+AEGAv9QACwQMcObpAEGYv9QACyKpZAAAAAAAAAAAx/8AAAAAAAAAACsCBVkAACRN6QYGKOghAEHMv9QACwiqNwAACxfnDABB5L/UAAsCaVIAQZLA1AALAoZUAEGwwNQACworKgAAAAAAAEw/AEHEwNQACwhqaaUJAABEOQBB1sDUAAsKh7HKL6YNyxFGKQBB+MDUAAsK8QoAAAAAAACLPQBBpsHUAAsC5poAQbTB1AALAmsaAEHawdQACwYmgwAAJygAQf7B1AALFif4AAAAAEgPAAAAAEQdAAAAAAAARokAQaDC1AALBKhEpx8AQcTC1AALCklBZhAAAAAArhIAQerC1AALFmQ/AAAAAAAAAABpZcZOAAAAAAAA5CoAQYrD1AALCgQ46knnOAAAp6wAQaLD1AALAuZHAEGuw9QACwLmkgBBwsPUAAsaplEAAAAAAAAm3AAAxpUAAAAAAAAAACol54wAQfrD1AALCMRUAAAAAJIUAEGsxNQACwZuBAAArQUAQbzE1AALAioPAEHOxNQACwqkDwAAAAAAAMbKAEHixNQACxYkWigSAAAAAAAAS3kHYwAAAAAAAGRZAEGCxdQACxrn+QAAAABICWVCAAAAADAIAAAAAAAALQ2GGwBBqsXUAAsaBngAAAAAAAAAABQAAACLNWYCAAAAACgyBwwAQc7F1AALCGbHkQ4AAKh/AEHgxdQACwrIXSf1AAAAAIkSAEGExtQACwhuCQAAAADmrABBqMbUAAsCaWEAQbrG1AALBsRKAAAHNQBBzsbUAAsKxpgAAAAAAACEbQBB+sbUAAsQpRAAAAAAAAAAAGgXAAAIAQBBmMfUAAsGqzUAAKhVAEG0x9QACwSIEAY7AEHKx9QACwhGdQAAAABJbQBB3MfUAAsCyGAAQejH1AALApILAEH2x9QACwTEZ6lXAEGEyNQACwRINcUrAEGkyNQACwRpS2YHAEG8yNQACwKtJABB2sjUAAsFJzdoFIcAQfLI1AALAsRkAEGAydQACyQuHQAAAAAAAAAAR/kAAGbZAAAAACgxAAD0BceBAAAAAAAApyYAQdDJ1AALCmgtAAAAAAAA7hUAQejJ1AALFEhTAAAAAGfRAAAGyAAAAAAAAAdlAEGSytQACwQEI8wGAEGmytQACwKkNABBzsrUAAsPJx8AAAAA6gzGHwAAxSAwAEH+ytQACwKmZABBksvUAAsCxssAQa7L1AALBuVTiHmkewBBwsvUAAsKJG8AAAAAAADHrABB2svUAAsC5WAAQfDL1AALJowwRxkAAAAAAAAAAA0CBkYAAAAAAAAnaQAAAADIRgAAAAAAAEh1AEGqzNQACwoFcgAAAAAAACeqAEHAzNQACxRLTYUdAADG5wAAAADIJ8UXAAAHrABB4szUAAsOpysAAAAAAAAAAOh2hvYAQfzM1AALAgkrAEGOzdQACwJEagBBxs3UAAsCxnEAQeTN1AALDG4CAABqFKcKAADkPABBnM7UAAseKhIAAHMKAAAAAKR+AAAAAAAAR/AAAAAAKxWlRUsIAEHWztQACxonlVAKAAAKLMU4MgcAAAAAp6aJMWYNAABFLgBBgs/UAAsChRkAQY7P1AALAkbVAEGoz9QACwRIMYeWAEG2z9QACw7lfQAAAAAAAAfUAADmvQBB4M/UAAsYqXoAAAAAAAAAAAaGAAAAAAAABFkAAKbLAEGG0NQACwIGWwBBrtDUAAsW5p4AAAAAAAAHyRcCAAAAAAAAAAClPABB0NDUAAsEKBNlAwBB/tDUAAsC5vgAQZDR1AALBo4GAAC0AgBBqNHUAAsCaGYAQbTR1AALFqtyAAAAAAAAAAAHYgAAAAAAAAAA7xAAQdTR1AALAso4AEHo0dQACwSJaubWAEH20dQACwKHagBBgtLUAAsMBHcAAAAAAAAAAApHAEGY0tQACwoJOAAAAAAAAGgIAEG+0tQACwpG5CpSAAArW0ZTAEHm0tQACwKkUwBB9tLUAAsSRTIAAAAACxMAAAAAAAAAAAdyAEGU09QACxJoBgcoAACkNwAAAAAAAAAAiyYAQbDT1AALGEswAAAAAOUdAAAAAEgQZwoAAOQRAACHKwBB1tPUAAsCxncAQeLT1AALAkQaAEGS1NQACwLENQBBrNTUAAsE6gClGgBB3tTUAAsCJ2QAQfLU1AALBgZ1AACFDQBBitXUAAsYpG5rSWUbyjGHLQAAp5EAAAAAySomHuklAEG21dQACwLGtQBBzNXUAAsIyR9ERgAARGIAQfLV1AALAsehAEGo1tQACxCoPQYbAAAAAAAAAABrG6cqAEHM1tQACwZLEMfYTBMAQfTW1AALEKhXhUsAAAAA6G0AAGkYRVMAQarX1AALCqbQAAAAAAAA5t8AQdrX1AALAoeZAEHm19QACwLkTQBB9tfUAAsCx2MAQZDY1AALDIoKRw8AAAAAAACmaABBqNjUAAsSqH4AAAAAJkgAAAAAAACGOYp0AEHQ2NQACyboA2UQAAAAAAAApksAAAAAAADGmwAAAAAAAAAAiQjFIqgUZSaoYQBBgtnUAAsCJgQAQarZ1AALDCaLAAAAAAhaJ/RqGQBBxNnUAAsEKTXGKABB3NnUAAsEKx6HpABB6tnUAAsiBTQAAAAAAACGogAA52kAAAAAylLFLAAAAAAAAAAA6Gjm4wBBqNrUAAsEzFFGvgBBuNrUAAsCaxQAQcTa1AALDE0nRHoAAAAAAAAkSwBB2trUAAsORXZINgAAAAAAAEwyZzMAQYzb1AALBqwBZ7dOMwBBrtvUAAsCZjwAQerb1AALAqRUAEGE3NQACwzJCAAAAAAAAAAAp68AQZzc1AALAokNAEG63NQACwIkYQBBxtzUAAsCZV0AQejc1AALAo4IAEGe3dQACxokPwAAxSgAAAAAjxSGTspRAAAAAAAAqAQGBABB4N3UAAsEiVMGEwBB+t3UAAsQpEgAAAAAAAAAAI4Fxg8qCwBBmt7UAAsCZr8AQaze1AALBGwZ5pEAQcDe1AALBGlCB5oAQc7e1AALFuZ1AADFU+scBG4AACbKAAAAAAAAp/QAQfLe1AALAuZ5AEGK39QACwJHHgBBnt/UAAsKpTQAAAAAyAFFaABBwN/UAAsCKjoAQczf1AALEEloBlapM+RqAAAAAAAAxEkAQezf1AALAksOAEGE4NQACwSoBSUVAEGe4NQACwrEGAAAAACrRiVJAEHC4NQACwpmVgAAAAAAACVKAEHe4NQACxYncowOAAAAAAAAAAAGqgAAAAAAAERkAEGg4dQACxgpVIYmAACkWMl95uwAAIQcAAAAAAAAB+YAQd7h1AALAgRMAEHy4dQACwqmxAAA5/4IEYZDAEGK4tQACwokcAAAAABJdcbqAEGm4tQACwqmtwAA5XwAAGQlAEG+4tQACwJFSABByuLUAAsOBTkAAAAAAADn0WwUp1YAQeTi1AALBBIGZF4AQYDj1AALHEsqAAAAAAAAAABmiAAAAAAAAAAA7FYAAAAAB7cAQabj1AALHud5AAAAAO0pAAAAAGb3AAAAAAAAAACoIcfDyU6GMQBB6uPUAAsM5+JKTwUAAAAAAMh4AEGE5NQACyYoAYYzAADHdwAAAABoSMQvAACEGgAAAAAAAAAAqngkVQAAAAAOAgBBwuTUAAsM5VEAAAAAAAAAAHEIAEHa5NQACzLmXQAAAAAAAAAA6DTmHAAAAAAKf4UlAAAAAAAAAACIDKYdAAAAAAAARqsAAAAAAAAHlwBBluXUAAsEZpguEABBtuXUAAsU5RgAAAAAbDUAAAAAAAAAAKZ2KFMAQZLm1AALAgdZAEGe5tQACwJGlABBtObUAAsE7CQGJwBB1ObUAAsN6RIAAAAAAAAAAIRJmABB7ObUAAsYzDMGDQAAAACqXuYgAAAlRgAAAAAAAAQoAEGa59QACxIkHAAAAAAAAAAAsQQnZgAAxXkAQcbn1AALDkb9axBlHQkCAADISaeQAEHk59QACwKqGwBBjOjUAAsEihHHMABBnujUAAsKB48AAAAAAAAGOgBBwOjUAAskixnlMuglR5gAAAAAAAAAAKgApSgAAAAAAAAAAIoBB2QAAOfeAEH46NQACwQNP6ZNAEGO6dQACwYGcwAABC8AQZ7p1AALCkYbjEgAAAhgxzgAQbzp1AALBhAAAACKVABBzunUAAsChhQAQeDp1AALAlYGAEH86dQACwQND6YjAEGg6tQACwRJHOYqAEHA6tQACxi2AwAAAACG4gAAAAAVAQAAAAAAALYCp4wAQYLr1AALDualAAAAAAAAAADpR8bHAEGi69QACwrmbwAAAAAAAOV3AEG269QACxDn26gVAAAAAAAAAABGIa4gAEGK7NQACwpmsgAAAACIJSaBAEGq7NQACxoGSQAAAAAAAAAAiAbFWwAAAAArG+cdAAAmjQBB1OzUAAsEiFuHAgBB7uzUAAsKRjQAAAAAAAClTABBiu3UAAsaBE8AAAAAqAoHewAAAAAAAAAAqHHFVusAp4oAQcLt1AALHuQUAAAAAAAAAAAII8UHAAAAACoEAAAAAOQsTReHegBB9u3UAAsiJ0kAAAAAAABlGgAAAAANKiYSAABGjQAAJ20AAAAACGnkIABBqu7UAAsChHIAQcDu1AALDG8TAAAAAAAAqjknDABB1u7UAAsCh6kAQebu1AALAiRKAEHy7tQACxYGrgAAAAAAAAAA0w8AAAAAAAAAAGaTAEGS79QACwJEFABBnu/UAAsKpl8AAGUXAADHoABBuu/UAAsaZk8AAAAA6wLkGgAAAAAAAEajAAAAAC0Mh1kAQfzv1AALAihSAEGO8NQACwJmJQBBnPDUAAsCzhAAQbTw1AALBExSRocAQcLw1AALAkf6AEHQ8NQACwQraAcfAEHe8NQACwjGzgAAAABqQgBB8vDUAAsCRk8AQYbx1AALBqVqq0cmHwBBnPHUAAsM6kEAAAAAAAAAAGaxAEG08dQACxSIAicGAAAAAAAABXwAAAAAAAAFWwBB4PHUAAsQKD5nxQAAAAAAAAAAyQeGIQBB/vHUAAsCJpYAQZjy1AALGuo9JxgAAAAAAAAAAEoNAAAAAGZrAAAAAO0CAEHA8tQACw6pZaZzAAAAAOgbpkwodwBB3vLUAAsCRFMAQfLy1AALCsRTAAAAAAkFBxsAQYjz1AALDGsgAAAAAAAACjdHiwBBpPPUAAsQSQlmOwAAAACMF2QRAACkYwBB0vPUAAsMhsQAAAAAAAAAAPUEAEH289QACwJGxwBBhvTUAAsMRiQAAAUdAAAAAOluAEG49NQACwQoQcQBAEHG9NQACwqmXAAAAAAAAAZ8AEHg9NQACwjwDQAAAAAkNQBB8vTUAAsep2IAAAAAAAAmxwAABt0AAAAAKx0AAAAAAAAAAOV1AEGe9dQACwZkdygcpR4AQbD11AALFC4eAAAAAAAAAADm8gAAAAAAAIagAEHy9dQACwKnWABBgPbUAAsCSEUAQZL21AALCobDAAAAAAAAZDcAQaj21AALAg4jAEG69tQACwokWwAAAAAAAIQrAEHS9tQACwbGXglqRCUAQfT21AALFqlnxrGuFycPAAAAAAlPh2UAAAAAi0UAQZT31AALDIo2hBVLQoVpDR0GewBBtPfUAAsCahIAQcb31AALAiVDAEHS99QACwhkawAAAABJaQBB7vfUAAsCZ6EAQYb41AALEEa5jEwFMQAAAAAAAMYg7gMAQar41AALBSReqUQEAEG6+NQACwIFVwBByvjUAAsCRGgAQdb41AALAmRgAEHy+NQACwolcwAAAAAAAEVUAEGQ+dQACwSIJoY3AEGg+dQACxirZIYWAAAAAM0i5yEAAAAAzRomPwAA55cAQcT51AALBGgw5iEAQfL51AALEqbNSgWGCwAAZDkAAAAATCmmwgBBlPrUAAsUKg5GAgAAAAAAAMbZAAAAAAAApXgAQcL61AALCMYWAAAAACoIAEHi+tQACwKmeQBB7vrUAAsIBykAAAAAiUkAQar71AALFEbfAAAAAEh4JvgAAAAAAACHJos/AEH8+9QACwKISQBBivzUAAsExUwsYwBBzPzUAAsCTCQAQeL81AALAgaOAEH4/NQACySIY+dZAAAAAMgoRRoAAAAAAACkV8leBTsAAAAAAABn88oi5oYAQaj91AALGik+JwUAAAAASE/FBSh4AABIZYRBAAAAAC0EAEHa/dQACwaFQgAApXwAQfb91AALAqaiAEGe/tQACw5GogAA5lMAAAAAAABEJgBBwP7UAAsMq1bn4wAAAAAAAOdeAEHW/tQACwKH8QBB9P7UAAsMEQvFFgAAAAAAAIf1AEGm/9QACwIkQQBBtP/UAAsUCTUnawAAAAAAAAAA6FMFKQAAJEIAQdL/1AALFoZZAACmvA4KZggAAAAAAAAAAGkHphEAQfT/1AALAuhhAEG2gNUACxRGuwAAAAAAAAAA7irHNWlk55OoVABBwoHVAAsOpqmwBgAAAAAAAAAAxkkAQeqB1QALAicpAEH6gdUACwKkOgBBkILVAAsQjjkAAAAA5tkAAAAAaHiGKgBBqoLVAAsIZsgAAAAATB8AQbyC1QALHMhQRRsAAEfgCwAAAAAAZUcAAOQ4AAAAAAAAhn4AQfCC1QALDKlKJhQAAKQrAACGQQBBlIPVAAsESygGNgBBpIPVAAsEqijlGwBBsoPVAAsmxEYAAAAAAABHris8hjYAAAQGKDlFTIleRU0AAAAAAABlXgAAJ5gAQeKD1QALAqQYAEGAhNUACwgIRIU9bg3HMwBBnoTVAAsS5H0AAAAAAAAAALAAAAAAAIbFAEHKhNUACwIkVABB6oTVAAsCZuYAQf6E1QALAqQUAEGMhdUACwQpZaZuAEGwhdUACwxJPgAAAAAAAEwmJQEAQcqF1QALBqQ2KlpFEgBB5oXVAAsCJhYAQfaF1QALAiasAEGihtUACw4FGQAA5HcAAAAAAAAG8QBB3obVAAsGZrMAACY8AEHwhtUACwTKEYQKAEH+htUACwrlfgAAAAAAAGQnAEGUh9UACwLpXgBBpofVAAsKBlkAAAAAAABG1wBByIfVAAsIyBsAACp7x7AAQYaI1QALBiefSkNHWABBnIjVAAsCbw4AQbKI1QALAqfeAEG+iNUACxjnNSoMJ1NJBacdAAAAAAAAByEAAAAAqBoAQeSI1QALCuk4AAAAAAAASHEAQYyJ1QALBgtOAADIRwBBqonVAAsKRCwAAAAAAADHwgBB0InVAAsUjwhnHWxapuIAAAAAAACndwAAxWcAQfyJ1QALCPICAAAAAAU+AEGSitUACwZmROkdBQsAQaqK1QALAsejAEG8itUACxQJCoeGAAAAAM4OAAAAAAAA6ztHIgBB5orVAAsUJD4AAAAAq1OnIAAAAAAAAAAAqAEAQYaL1QALEuZiSB9HUAAAAAAAAKeyanWkdgBBsovVAAsCRGYAQdyL1QALDsh6RykAAAAAAAAAACpEAEH2i9UACwZmdgAAhpQAQYaM1QALAgRxAEGSjNUACwKGqwBBuozVAAsEpFYrLwBB2ozVAAsW51YAAAAAKllHMAAAAAAAAAAACRDnxABB/IzVAAsEDTWnbwBBqI3VAAsCCHEAQbSN1QALBAlFRigAQdiN1QALEIkDBuIsBgAAAAAAAAAABuUAQZqO1QALEKc0AAAAAEk35jMAAAAAKyQAQbSO1QALBM4ZxA0AQcKO1QALAqcZAEH0jtUACwR3AmfAAEGCj9UACwaGpwAAR5UAQZiP1QALAqxEAEGqj9UACwIG1wBBvo/VAAsO5ScAAAAAAAAAABQOh5MAQeKP1QALAuZ4AEH2j9UACwKH8gBBnJDVAAsC6FsAQbCQ1QALBCtwhRAAQciQ1QALFMoExGgAAAAAAABlL0gbBQGKUiR/AEHokNUACxDtDWYw6VCnbQAAAACqBsdiAEGIkdUACwJOOQBBlpHVAAsORncAAAAAAABHMQAA5qoAQcKR1QALAkRuAEHSkdUACwInsABB9JHVAAsIyASHD8oq5xgAQZCS1QALEIxahE4AAAAAAAAAAIhkRyEAQaqS1QALBgcaAADmCQBBwJLVAAsCqFwAQdaS1QALGsZLAADGuqlmJsIAAAAA7BClMgAAAABIFoYMAEGKk9UACwokPAAAAAAAAEasAEGuk9UACwzlYigEZ5kpawAAaDoAQdqT1QALAuQ3AEHok9UACwTLCgQQAEH4k9UACxBoSQAAAAAAAIpWR38AAGQYAEGWlNUACwJGwQBBrpTVAAsIhlUAAAAAKCsAQcKU1QALEKUtAABm0gAAAAAKOwAALjYAQeCU1QALD5cDAAAAAAAArHwAACpYZQBBgpXVAAsYpRwAAAAAAAAAAMgMAAAAAAAAAABGbMh/AEGsldUACxD2BgAAaA4AAAAAAAAAAKZ0AEHKldUACwLFVwBB2pXVAAsWBthSA4Q8AAAAAAAAJxdKTSY0AABmZABBhpbVAAsCxp0AQaKW1QALAiRPAEG+ltUACwTnO8ogAEHOltUACw7GZwAAAAAAAAAASwPFCABB7JbVAAsQLxsAAAhQZgYAAAAADS1HxgBBhpfVAAsCh1EAQZKX1QALDsdfAAAAAAAAAABIJSdcAEG0l9UAC0bpUcUbSXEAAAAApn7oeyb7AAAAAAAAAADqPgAAAAAAABIbRRMAAAAAAACFWQAAh2kAAAAAAAAAAKhNhh8AAAAAAAAAAIldAEGgmNUACwXuDAAAVwBBwpjVAAsSB0gAAAAAAAAGUQAAAAAAAGUpAEHsmNUACwwMTwAAAAAAAMhAZQ0AQYiZ1QALDGlqAAAAAAAAAAAEPwBBrJnVAAsE9ABlbgBBvpnVAAsCRXMAQdCZ1QALBGkLJXwAQeCZ1QALBggZZBBYAQBBgJrVAAsYqS0nswAAAAAAAAAAigPlDAAAAADIY6V+AEGomtUACyTsBKfwAACmagAAAADqIeZAAAAAAAAAAABOKgAAAACEJck6ZTQAQdia1QALAoloAEHmmtUACwIm8gBB8prVAAsIJDEAAAAAqCwAQYSb1QALAutXAEGym9UACwJlMABBwJvVAAsSaAmFWKs456gAAOQlAAAAAIpgAEHim9UACwKkXQBB/pvVAAsKJoUAAAAAq1lGHABBkpzVAAsaRW/uNUZOAAAAAAAAAABKWAAAAAAAAG0GRFcAQcKc1QALEoZnAAAAACoCAAAAAAAAAAAn8QBB9pzVAAsChgoAQZSd1QALDHMD52xMPgAAqgwm4ABBrJ3VAAsCajYAQbid1QALCMp4AAApEIfNAEHandUACwSnfMg+AEH2ndUACxLkZgAA5/AAAAAAAAAAAEkMh9sAQaCe1QALDBgBAAALFMeCAACHPQBBuJ7VAAsEKBCmBQBByJ7VAAsEKCzHRQBB1p7VAAsWJWIAAAAAAAAmj6kXAAAAAAAAVwMlLABB9p7VAAsKBv0AAAAAAADFSwBBoJ/VAAsEEATnagBBvp/VAAsaZvsAAAAAsgCEAAAAAACrOYdfAAAAAAAAJrUAQfaf1QALEqa0AAAAAAAABpIAAAAAAAAmHQBBqqDVAAsi5h8AAAAACRsAAAAAAADLIwAAAAAAAHcAAAAAAAAAaloEQwBB1qDVAAsKpyMAAAAAAAAHRgBB6qDVAAsCRFYAQfag1QALDMebAAAAAPMHAAArBABBjKHVAAsEDEHH6ABBqKHVAAsMy04AAAAAAAAAAEVFAEG+odUACwIlfQBByqHVAAsCxTcAQdqh1QALCiakAAAAAKlohk8AQYSi1QALAssiAEGWotUACwyEbAAAAAAAAAAASn4AQc6i1QALCueZAAAEJgAARz8AQYSj1QALKFYDAACoCwewSmNkaQtYAACtI0UOqDxHcCkSAABoAmf+AAAAAAAAp/EAQbqj1QALAgfYAEHMo9UACwJIXQBB3KPVAAsEaHyG9QBB9qPVAAsGxsEAAEZtAEGmpNUACxpEfwAAAAAAAMRlyw8AAAAABp4AAAAAyGVldwBBzqTVAAsCpnoAQeCk1QALCmhyBQcAAAAAlAwAQfyk1QALDMtPAAAAAAAAAABFXABBmqXVAAsCxV4AQb6l1QALFgeLAAAAAM4aAAAAAAAAqRAAAI0YBxUAQd6l1QALLAaQAACnmwAAAABIQyYV6mwG4wAAAACoM6YQAAAAAAAARnoAAAAAbAWmC2kuAEGWptUACxTFQSkDAABMXuQpAAAAAAAAAADLFgBBwKbVAAsE6AQlSwBB0qbVAAsMpBZILgAAAACGzsgsAEHwptUACwgNFsYjAACHYgBBgqfVAAsS5piIYccfaH0GcAAAAAAAAOe0AEG4p9UACwIMXQBBxKfVAAsQ0g8AACsFhGIAAAAAAAClTgBB6qfVAAsCpSQAQbKo1QALFIQ0rgSG7QAAAAAAAAAAzENHxKh3AEHUqNUACxCoLucDAAAAAAAAAACqD6QoAEHwqNUACwhqKAAAAABmwQBBkqnVAAsCB5gAQaCp1QALCM8YJu6pTucBAEG0qdUACxWPAmYJ60MnqQAAAAAAAKdCAAAAANUAQdap1QALAkVDAEHuqdUACxpEKgAAAAAAAAAAcQEGAAAAAACKI2VSAAClewBBmqrVAAsIB2oAAAAAaj8AQbKq1QALEoQX63uFbgAAAAAAAAAAkAfndwBBzqrVAAsUps4AAAAASHMnKgAAxE8AAAAAij4AQfiq1QALAswUAEGSq9UACwJHNABBuKvVAAsCCF8AQcar1QALAqafAEH8q9UACwJIYABBjKzVAAsEah4kCwBBoqzVAAsOhq4AAAVGAAAAAGkARs8AQdCs1QALEEpJAAAAAOeeAAAAAAAAJT8AQY6t1QALAqZPAEGyrdUACwZm8yoFpzcAQcit1QALHCgHpBcAAAAAai4AAAAAAAAAAARFAABmbgAAZnMAQaqu1QALDGdtAAAAAAAAh98xBgBBzK7VAAsIqlIAAAAAJ/MAQd6u1QALAkZjAEGOr9UACwrmjQAAAAAAACVdAEGmr9UACwKFCgBBtq/VAAsGRTMAAAR6AEHGr9UACwLmVwBB1K/VAAscahdFKAAAAAAAAGUcAAAAAAAAAAAJRgAA8wNnrgBB+q/VAAsaRzoAAAAAAAAAAGpQ5hQAAAAAAACGsgAAhTMAQaaw1QALBMaLSEYAQbSw1QALAgsgAEHCsNUACwJm3QBBzrDVAAsIx5SJEAAATwgAQeqw1QALCqQnAAAAAAAA5QcAQYKx1QALAma4AEGSsdUACwwEJAAAAAAAAAAACUwAQa6x1QALBiaZAACnlABBwrHVAAsChrcAQc6x1QALBCZWCg8AQeCx1QALEDcAAAAuKQAAAAAAAAAARxwAQfqx1QALEufnAAAAAKk5AAAAAAAAAABHqABBlrLVAAsIpgoAAAAAbiUAQdKy1QALCmaSAAAAAAAAhHoAQeyy1QALBKlP5SIAQfqy1QALF6QkAAAAAAAAAAAJQiUCAAAAAAAAAAC2AEHEs9UACwIWBgBB1LPVAAsCKksAQeKz1QALBmVhAACEGABBkrTVAAsGRqUrXAReAEG2tNUACw6HMw4YBwoAAAAADAHHtwBB1rTVAAsCJG0AQeK01QALEGZoAAAAAAAAAAAIIMYESnsAQYS11QALCGoLJyDIIuVxAEGctdUACwSoXeQSAEG4tdUACxCqewAAAADFewAAAABJC0UYAEHStdUACwIlNQBB3rXVAAsCxGAAQfS11QALFMxQZGcLXgAAAAAAAMlSAADLAqcCAEGUttUACyjqC+YdAAAAAAAA5jUAAAAAAAAAAA8ARW0AAAAAKyEmCAAAAAAAAMaoAEHittUACwLn6wBB8rbVAAsKJGUAAARXAABGhgBBorfVAAscxU4AAAAASGQAAAAAAAATBwdhAABEeQAAAACpYwBByLfVAAsUCjIAAAAA5vMAAAAALQUAAGwBxg4AQey31QALDGof50wAAAAAAACHggBBjrjVAAsCJRwAQbK41QALEEQuAAAAAAAAAAANDQcGKhoAQfq41QALAkZ0AEGSudUACxTGoAAA5l4AAAQPKTAAAAAAAACqNQBBtrnVAAsChWYAQcS51QALEuoYAABXAeYSAAAAAAAAJl+oLQBB6LnVAAsk0QXHhwAAAAAAAAAAawEGy1YHBSsAAAAACX6G6QAAAAAAAAVvAEGqutUACwLkWABByLrVAAsCCTcAQei61QALDElyJu8AAMV3AACnbgBBjrvVAAsW5GmLIgAAySUkCAAAAAAAAMc/AABHvQBBsLvVAAsEDBNkJABBzLvVAAsESyOkSQBB6rvVAAsKRBAAAAAA6zlFBQBB/rvVAAsChS4AQZK81QALAgVVAEGkvNUACwwoeqb5AAAAAAAARGUAQcK81QALEsetAAAAAAAAhFAAAAAAamzEegBB4rzVAAsih0MAAGcPAAAAAAAARvcAAAAAAAAAAKhi5k0AAGbXAACGmABBkr3VAAsCBzwAQaq91QALAgZvAEHEvdUACwRoJWf5AEH0vdUACwSKYmYWAEGEvtUACwTpNYUTAEG+vtUACxamq/YEBgqMGAAAAABmPwAAAAAAAMZQAEHevtUACxbHlwAAAAAAAAAAy3MAAAAAAAApAEcOAEH+vtUACwLENwBBxr/VAAsjRj0AAAAAAABmPQAABsYAAAAAaD9HHwAAAAAAAMQTSQFHLTMAQfy/1QALHAkzhhyKawY8AABmYQAAAAAAAKRFAAAAAMgRpxgAQa7A1QALGka6cAFHL4onJoQAAAAAVwJmSGslR8EAACQWAEHawNUACw5lMwAAAAAAAAAA6lrnNgBB8sDVAAsCB78AQYDB1QALEE8HAABKPAAAAAAAAC4/BvQAQabB1QALAkUeAEG2wdUACwwldwAAAAAAAAAAS2QAQdbB1QALCkUkAAAAAOtihQYAQfbB1QALAgQOAEGCwtUACxKGgAAAAABKEQAAAAAAAAAAZ+IAQaDC1QALGMp0puMAAAAAAAAAAGguxAQAAAAAAAAHogBB1sLVAAsCZVoAQfLC1QALAkamAEGCw9UACwbnnAwlpQ0AQZLD1QALDoZSAAAAAAAAAADJIeZJAEGuw9UACxpGiCkKAAAAAAAAAADmMAAAAAAAAAAAKB9HKABB1sPVAAsChrAAQezD1QALBMpBBU8AQfzD1QALBGgdBhIAQYrE1QALCoZ1AAAAAAAAhwYAQbDE1QALBKgmhRgAQb7E1QALEAfvAABHoQAAxFUAAAAAKk4AQeTE1QALGoszAAAAAAAAAABlBQAAAAAAAAAAbQHneMxeAEGaxdUACwKEGwBBsMXVAAsEKG1nAQBB3sXVAAsHR28AAAAATQBB9sXVAAsGx90qMeUgAEGIxtUACxBJZgc5AAAAAGgfRhYpMSUMAEGixtUACwRGVAwVAEG0xtUACwTyE+bMAEHIxtUACxhzB8d0AADkFwAAAAAAAAAASSulFAAApW0AQfzG1QALAggQAEGKx9UACwInogBBmMfVAAsQjhQAAAAAAAD3AYcQKB4nhgBB2MfVAAsMiByGKLYGAAAAAMdxAEH0x9UACwjJWydYKBskCQBBjMjVAAsIiE+lMAAAJrAAQZ7I1QALDKZvAAAAAAAAAACoAgBBxMjVAAsULFoAAAAAAADodwAAAAAAAAAAJrMAQfDI1QALBMwVpRcAQYjJ1QALIMgCRgAAAAAA62VHLAAAAAAAAAAALDUAAGgzhgezAWfJAEHCydUACw7GuItKAAAAAMYxAABHBgBB9MnVAAsECxjnkABBgsrVAAsEBErqGwBBlMrVAAsaqB4HCAAAAAAAAAAAziIAAIhLAAAAAMa7KiEAQbzK1QALBMwmZ9wAQeLK1QALAiUQAEH2ytUACwKGqQBBiMvVAAsCLT8AQZjL1QALCAt9AAAAAMZ4AEG+y9UACwLmaABB2svVAAsCpU8AQfjL1QALIMlJAAAAAAAAAAAFIwAAAAAAAEatAAAAAAAAJSMAAAeFAEGizNUACyqmcgAAAAD1AWdFAAAAAMl+ZusAAAAAAACmeAAAAACtDicEAAAAAAAAJWQAQdbM1QALBqRtAAAGZwBB8szVAAsCpC0AQYDN1QALEMtg5QAAAMY1AAAAAOocBS0AQaDN1QALDMlmhlwAAAAAKHSnuQBB0s3VAAsMhGoAAAAAAAAAACkCAEHqzdUAC0YmfQAAAAAAAAAAbwTkZwAAAAAMMCc5AAAAAAAA5qgAAGcDAAAAAAh7AAAJIQVFAAAkMgAAAAAAAMZYAABmlwAAAAB3AaQZAEHIztUACw6qAGdIAACkWQAAAABofgBB8s7VAAsCpGQAQYrP1QALCiQ9AAAAAAAABoAAQabP1QALAodvAEHAz9UACwwpOwAAAAAAAGxSBmwAQdjP1QALCAoTZ2YAAGcGAEH0z9UACwJJEABBgNDVAAsMqBwAAAAAAAAAAERUAEGe0NUACxJEYIsG5QkAAAAAAABG0AAAJjMAQb7Q1QALBmYYAAAEVgBB2tDVAAsGJW/IFQQUAEH60NUACxYGbQAAxnIoR4chAAAAAAAABpkAACaqAEGi0dUACwLFLgBBrtHVAAsMZVsAAAAAAAAAAMsXAEHI0dUACwZKGUU/iTcAQYjS1QALCGhoAAA3Ase+AEGa0tUACwynOwAAAABKfMarkgkAQbTS1QALCGgs5yMAAKatAEHI0tUACwzoOAUwAAAAAAAABSEAQezS1QALAih9AEGG09UACw6GAwAAAAAAAGRq7BXnLABBpNPVAAsE6iOEXABBztPVAAsCJmsAQezT1QALBGlmRq8AQfzT1QALBM0VBRwAQa7U1QALAifOAEHU1NUACwToUaRHAEHo1NUACwQLEOcrAEGC1dUACwLFcgBBqtXVAAsC5lUAQb7V1QALCqa+AAAAAAAAJH4AQdbV1QALAoQqAEHs1dUACwaqawAACxYAQYTW1QALCBEMJXsAAORMAEGa1tUACwLn7wBBptbVAAsCZo0AQbbW1QALDuQeAAAAAAAAAABoA+cCAEHU1tUACwLNBABB/tbVAAsC5H4AQYrX1QALAgaIAEGW19UACx4mxgAAAAAAAAAAahwAAAAAAADIOwYtAAAAAAAA5wsAQcDX1QALHGhXAAAAAAAATgMAAAAAAAAAAOeLAAAAAAAAZFwAQfzX1QALBKlcZAgAQYzY1QALAgg6AEG42NUACxBOBQAACgwAAAAAAABQA8UqAEHU2NUACwhoGQAAAAAkOABB8NjVAAsECSDmJgBBgNnVAAsCyl4AQZLZ1QALEmVnAAAAAAAAAACsSAUIAADnggBBrtnVAAsCBiQAQbrZ1QALAuarAEHS2dUACwKnowBB5NnVAAsEDC+GAQBB8tnVAAsORxMAAAa+AAAm2+wLxj4AQY7a1QALBqQhaCSnlQBByNrVAAsQ9AEAAAAAAAAAAKanAAAmfwBB6NrVAAsMKmtG4qhCAAAAAKa1AEGc29UACwSIaGQaAEHA29UACxBwAgAAiBMAAAAAAAAAACV+AEHq29UACwKGZgBB/NvVAAsQFwCFHAAAAAAAAGeNAACGnwBBpNzVAAsMKmoG4AAAAACpMGUkAEH03NUACy6qQQAAAAAAAK44AAAAAAAAAABHUwAAAAAAAMQ0EQBlLAAAAAAAAAAAqxQAAIkgAEHC3dUACwIlbABB0t3VAAsOJssAAAAAAABFHQAA56wAQfDd1QALDEgmAAAAAAAATGQm8ABBiN7VAAsOjRYAAAAAAAAAAAekyWUAQare1QALIGVYAAAAAAAAp7pqAacHrFsAAAAAAACpKgAAAAAAAE4MAEHg3tUACwLIfgBB8N7VAAsgzxHGDAAAAADXAwAAAADnZgAApoIAAAAAAABH8QAABr0AQZ7f1QALCOYKAABmm6keAEG039UACwQIBocIAEHI39UACxzID6cJKU5EdQAAAADqKwAAAAAAAMoVhtAAAGdYAEH639UACwJlMgBBlODVAAsI1wAAAAAARiMAQajg1QALDAkBhAUAAAAAai1nDgBBzODVAAsYKUQnXwAAAABpaMacAAAAAAAAAABIdAbyAEH04NUACwKsUQBBgOHVAAsYCCsAAAAAZrkrVCYXAAAAAIg5pwsoXsU7AEGi4dUACwKFfwBBsuHVAAsK5AwAAAAAAABkPgBByOHVAAsC6hkAQebh1QALBgQMAAAHeQBBjOLVAAsBagBBluLVAAsO5zEAAAAAAAAAAAkcZkYAQa7i1QALAgZYAEHG4tUACwLmwgBB8OLVAAsQqGsAAAAAAAAAAEZ2rClFXQBBjuPVAAsCxHEAQarj1QALAoZRAEHS49UACwImrgBB8uPVAAs6Rr0AAAAAAAAAACoZAADKP6dZAAAAAAhCAAAAAAAAAACEAgAAAAAAAGacAAAAAAAAZpEAAAAAAABmJgBBtuTVAAsCZ4gAQc7k1QALCqU1AAAAAAAAJG4AQeLk1QALAqRNAEHy5NUACygGXAAAhisAAIVsAAAAAAAAAAAoNgAAAAAAAGpg57oAAAAAAAAAAOoaAEGk5dUACwKNDwBBvOXVAAsC7AYAQczl1QALGBMOxwcAAARrzCEAAIhHAAAAAAAAAABmdQBB8uXVAAsCBiwAQYbm1QALDORQAAAAAAAAAABSAQBBoObVAAsCihsAQbzm1QALIA46AAAAAKQNAAAAAAAARtoAAAAAAABmQAAAAAAAAMdGAEHo5tUACxJqCAQFAAAAAElaB3wAAAAAa3MAQYbn1QALAiePAEGe59UACwIHRwBBvOfVAAsS6R4AAAAAAAAAAKRQAAAAAAwpAEHm59UACwJmqgBB8ufVAAsCBqAAQYjo1QALCPYAhQMJLUcUAEGm6NUACw6GXwAAAAApaMZrAAAFawBBwOjVAAsqClyFCwAAAACIdgbzAADmuOoHxUkAAAAAAAAmvgAAAAAAAKZYAAAAALQHAEGc6dUACyBpPAAAAAAAAAAAppcAAAAAAAAAALEDxH8AAAfWAABGOgBB1unVAAsCZFsAQeTp1QALAm4VAEGI6tUACwIqHgBBoOrVAAsEiHim+gBBwurVAAsKhokAAAAAAABHdwBB3urVAAsqx/QAAAAASASmREx8AAAAACc4MhFHagAAAADIU0QSAAAAAAAAAADJQOYTAEGY69UACwjtEgAAAABmgABBtOvVAAsM6noAAAAAAAAAACd8AEHs69UACwSqEac+AEGC7NUACwKFOABBmOzVAAsEKB2lEgBBrOzVAAsKzEgAAAAAAAAoZABBwuzVAAsMxAgAAAAAKi4AAJAEAEHc7NUACwiMGSdayjUnHgBBuu3VAAsOJuMQAsaGqn8AAAAAxTIAQdLt1QALAqYIAEHe7dUACwrH5AAAAAAAAAdnAEH67dUACwJFZwBBoO7VAAsCCWYAQcLu1QALCgV9qFmn5gAA5zQAQdzu1QALIsg/AAAAAAaDAAAAAAAARk0AAAAAAAAEQQAAAAAAAAAAyHsAQa7v1QALAiQoAEG+79UACxLnjQAAAAAocwAAAAAAAAkDpTEAQe7v1QALHgZrAAAAAAAAZxFNI6V6AAAFJAAAAAAAAEfsaFEEBwBBnPDVAAsCrCAAQbTw1QALDihNZq8AAKaWAAAAAGtGAEHS8NUACwKmKQBB3vDVAAsCJC4AQfLw1QALCsZNAAAAAAAA5q8AQZTx1QALCApOBxQAAGQtAEHw8dUACxhpTQAAyxWGJAAAAAAKUgZNAAAAAAAAplUAQaLy1QALCudQAAAAAAAA5U4AQdLy1QALIGaeAAAAAAAApuAAAAAAAACH0gAAAACpOgAAaELHmSsJAEGE89UACwKMIQBBkPPVAAsIyQzGRaoNJQgAQcDz1QALAmhKAEHM89UACwTKLgflAEHc89UACwcLAgAAqTLGAEGG9NUACwYlbgAA5roAQZ701QALAsURAEG09NUACwivAkU67AIlIABByPTVAAsErAmHMgBB2PTVAAsCCFkAQfz01QALHIhrBucAAAAAjFGmTgAAAAAAAAAAuAEkLwAAR+YAQbr11QALCqa7AAAAAAAAR+4AQd711QALEmQ9Sh1kFQAAAAAAAAAA6k5HlABBiPbVAAsGaXQAAEsVAEGi9tUACwJmxgBBxvbVAAsCpV8AQfL21QALEgU1AAAAAEhZAAAAAAAAAACnVQBBkPfVAAsCqiMAQZ731QALAqQ1AEG099UACwTqCEcCAEHM99UACwSODodnAEHc99UACwIqJABB7vfVAAsKZFQAAAAAAAAGsgBBgvjVAAsK5lAAAAAAAADGpgBBqPjVAAsEiwQmGgBBuvjVAAsKxCoAAAAAAAAEdABBzvjVAAsKx+XUDgdry1HEJwBBhPnVAAsQEwBnculvxjgAAAAALEAnsgBBoPnVAAsG6mIAACwTAEGy+dUACwiEY6lxpjctKwBByvnVAAsSRkgAAAAAAABmrQAAAAAAAGVFAEHo+dUACwLIXwBB/vnVAAsCp0MAQZr61QALAgZuAEGm+tUACxZGvAAAAADregAACWAAAAAAAAAAAARJAEHg+tUACwIsXABB/vrVAAsGRBzIA0U1AEGs+9UACwKzDgBB2vvVAAsOxzkAAAAAAAAkMAAAxTEAQfr71QALEmQrAAAAAAAAAACpD2ediFAFEQBBqvzVAAsCpzoAQbb81QALAueqAEHO/NUACwLlWQBB6vzVAAsC5rEAQf781QALDqZdAAAAAAAAAABIRKdQAEGY/dUACwisIgAAAABmnwBBrv3VAAsUpjgIQ2RFAAAAAGp7Z4oAAAAASgsAQdL91QALAoRrAEGC/tUACwYkIAAAB90AQar+1QALAuaFAEHG/tUACwZmCgAAZGgAQdr+1QALAsb6AEGI/9UACwIJVwBBqP/VAAsE6QvH1gBBuv/VAAsGRQMAAMREAEHK/9UACwKmcABB2P/VAAsQyGYAAAAARg8AAAAAAADmZABB8v/VAAsaxyAAAIVNKEtEBAAAAABJFQAAAAAAAAAAJEMAQZ6A1gALFoUpAAAAAA8apu7IFqYgAAAAAAAAJtcAQb6A1gALAqR0AEHigNYACwYmyQAA528AQYaB1gALCoVlAAAAAMl1hu8AQZ6B1gALDkdhAAAAAAAAJBEAAEakAEG6gdYACwKmzwBByoHWAAsC5sYAQdiB1gALAotmAEGEgtYACwspFyULAAAGkcwcxQBBsILWAAsE6wemAwBB3oLWAAsOhtkAAAAAKBZHFQAAJvUAQYSD1gALCGsLAAAsAocFAEGeg9YACwbFIQAABSUAQbKD1gALAma+AEHIg9YACwOrXuQAQeCD1gALBEpCh0kAQfaD1gALAkZiAEGChNYACwqHSGhOBwvpNyYHAEGchNYACwSoaeZbAEGqhNYACxblA+wBAACKOSVBjAEGNQAAAAAAAMeiAEHOhNYACw5lSgAAAAAAAKUBiUQmDABB+oTWAAsGB7iLOOfcAEGUhdYACwJxDgBBooXWAAsi5sAAAOeKAAAAAAAAAAAoAAAA6CwFPQAAZiEAAAAAAADm9wBB0oXWAAsUZpAAAObEAADGs+kDAAAAACUvsQwAQYCG1gALAok7AEGShtYACwLn/ABBnobWAAsOh+UAAAAAAAAAAHAEZWkAQbqG1gALHkRFAAAAAAAABUMrTuUZAABnqwAAAAAAAAQ1KGIHKgBB/obWAAsCBHAAQaCH1gALDmsDx10AAAAAAAAAAMwdAEG4h9YACwLsLwBByofWAAsGZEuqWmQBAEHih9YACwKEOwBB7ofWAAsCBsIAQf6H1gALAgRVAEGgiNYACwJrNgBBwojWAAsQ57IAAAAAtAEFDgAAAACKLABB5ojWAAsMZvUAAAAAAACGm0wCAEH+iNYACwJmbABBjInWAAsMSQaEWCoJB0oAAMQ+AEGkidYACyIqFGYrAAAAAAAAAADIOiQEAADHHmhHRgEAACY6yEwAAKodAEHQidYACwgNA0UCAABGPwBB5InWAAsENgSkJgBB/InWAAsUiREAAAAAAAAAAAaEAAAAAAAABtUAQZ6K1gALAoaBAEGyitYACwpmpAo2xQoIIYVBAEHcitYACwJqDQBB6IrWAAsMag/kcwAAAACqd6ePAEH+itYACxJFYQAAxT6IGAAAAAAAAAAABqQAQZ6L1gALAuVqAEG0i9YACwyqBQevAAAAAAAAZH0AQcqL1gALAiaJAEHci9YACwQoRIdMAEH4i9YACxTLBgAAAAAAAAAAhxUAAAAAAACmgABBnozWAAsYBEcAAAAAAACEWypNAAAAAMZ5zQune6hbAEHCjNYACwqn3wAAAAAsU+f7AEHYjNYACwTKZOUjAEHmjNYACwJmwABB/IzWAAsEzRZnwwBBko3WAAsChzwAQZ6N1gALAubKAEGwjdYACwjIbSblAAAmxABByI3WAAsIrAsAAGhZRHwAQdqN1gALBuQHAADkSQBB7o3WAAsWpV0AAAAAAAAAAGxExS0AAAAAAABn2gBBko7WAAsCJwsAQbaO1gALIua2AACGYKpvAAAAAAAAFAYAAAAApXUAAAAASlYn30sNBzcAQeyO1gALCBEEAACJKQQbAEHCj9YACyiFagAAAAAKNIdGAADEcgAAhtwAAAAAeAAAAAAARSIAAAAAAAAAAKg+AEH4j9YACxJqauVcAAAkBgAA5m0AAAAA6AUAQZaQ1gALBiRsAABGlgBBqJDWAAsE6QUFIgBBwpDWAAsO5rUAAAAAAAAAAGlv5+4AQfKQ1gALAiRfAEGGkdYACwzkMgAA5xYAAAAATT0AQaCR1gALBGsEZlsAQbKR1gALAmRmAEHOkdYACy7kRwAAAAAAAAAAsQVHZgAAAACrCcYbAAAAAAAAAAAsagbrAAAAAAAAJk8AAIajAEGQktYACwLKCgBBrpLWAAsCJGYAQcKS1gALCkVuAAAAAAAARnIAQeCS1gALDCpsAAAAAEQ16DFGBwBB+JLWAAsESUPHDABBnpPWAAsCh20AQdCT1gALCmkRxUYAAOcHkgEAQfST1gALBGgARg4AQYiU1gALAghIAEGalNYACwKldABB0pTWAAsChlYAQeyU1gALAgpeAEH+lNYACwzkLgAAZn4AAAAACQwAQZyV1gALAo0SAEG0ldYACwwoKgcHSlMAAMgeRTEAQdCV1gALHKk2AAAAAAAASj8AAAAAAAAAAGZ9AABnkQAABCkAQfyV1gALAgh9AEGIltYACwQIXaQMAEGWltYACw7FWgAAAAAKFgAATBImAQBBypbWAAsC5GgAQdiW1gALAuwbAEGMl9YACwzSHmbxqwMAAAAAZ90AQaKX1gALBsZpygClEwBBupfWAAsOZW0AAAAAqTulYCwW5E8AQeaX1gALEmbaAAAAAAAAAADNEyZtAABkUgBBnpjWAAsC5TAAQbiY1gALCohTZG4AAMYJjE4AQdqY1gALBoa2AABGeABB6pjWAAsChTkAQYiZ1gALGEsE5BgAAAAAAACGME47AADrIQAAqSkGTABBrJnWAAsMNgYAAIx7AABoWCZNAEHGmdYACwKGXgBB0pnWAAsC5sUAQeiZ1gALAqsjAEGGmtYACwIHKwBBmJrWAAsEakCn1QBBrJrWAAsMiTIAAAAAAAAAAIQ+AEHKmtYACwSFCAsbAEHcmtYACxQIPSYsAAAAACkWhx0AAAAATDlEPQBB/JrWAAsUjF4GvAAApl4AAOfYAAAAAIgNxUoAQZqb1gALtwcBAG50EABkAAAADwAAAAUAAACJUxAAYgAAAGsBAAAZAAAA8RUQAGUAAAAcAAAAHAAAAPEVEABlAAAAWgAAABUAAADxFRAAZQAAAGMAAAAVAAAA8RUQAGUAAABtAAAAGgAAAPEVEABlAAAAdwAAACAAAADxFRAAZQAAAHwAAAAlAAAA8RUQAGUAAACFAAAAGgAAAPEVEABlAAAAkgAAABUAAADxFRAAZQAAAJcAAAAVAAAA8RUQAGUAAACbAAAAPAAAAPEVEABlAAAAqwAAABEAAADxFRAAZQAAAEIAAAAgAAAA8RUQAGUAAADOAAAAHgAAAPEVEABlAAAA1wAAAB4AAADxFRAAZQAAANwAAAAjAAAA8RUQAGUAAADpAAAAFQAAAPEVEABlAAAAwwAAACcAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAAI5XEABiAAAABAAAAAkAAACOVxAAYgAAAAkAAAAyAAAAjlcQAGIAAAARAAAADQAAAI5XEABiAAAAEgAAAA0AAACOVxAAYgAAAB0AAAANAAAAjlcQAGIAAAAeAAAADQAAAI5XEABiAAAAHwAAAA0AAACOVxAAYgAAADcAAAA3AAAAbWlkID4gbGVuAAAAbI8VAAkAAABwRxAAbwAAAGwAAAAhAAAAcEcQAG8AAAB1AAAAJgAAAHBHEABvAAAAhwAAABEAAABwRxAAbwAAAI8AAAAlAAAAcEcQAG8AAACPAAAAFQAAAHBHEABvAAAAzAEAAB4AAABwRxAAbwAAAOEBAAA6AAAAcEcQAG8AAADgAQAADQAAAHBHEABvAAAA0QEAABwAAABwRxAAbwAAANQBAAAJAAAAcEcQAG8AAADZAQAAEwAAAHBHEABvAAAAGwQAABAAAABwRxAAbwAAACMEAAAMAAAAcEcQAG8AAAAkBAAADQAAAHBHEABvAAAAJgQAAA0AAABwRxAAbwAAABQEAAAqAAAA0jMQAGcAAABYAAAAMgAAANIzEABnAAAAaAAAACUAAADSMxAAZwAAAGsAAAAVAAAA0jMQAGcAAABsAAAAKAAAANIzEABnAAAAbAAAABIAAADSMxAAZwAAAHIAAAAVAAAA0jMQAGcAAABzAAAAKAAAANIzEABnAAAAcwAAABIAAADSMxAAZwAAAHUBAAAgAAAA0jMQAGcAAAB1AQAAGAAAANIzEABnAAAAbAEAABQAAADSMxAAZwAAAGwBAAAMAAAA0jMQAGcAAABpAQAACQAAAAEAQeKi1gALAwMABgBB8KLWAAsNFAAAAAAAAAAVAAAAFgBBjqPWAAsPFwAAAAAAGQAAAB0AAAA1AEGqo9YACwE3AEG4o9YACws9AEwAAAAAAAAAXgBB0KPWAAsJYAAAAGEAAABiAEHoo9YACwdjAGUAagBsAEH6o9YACw9uAAAAbwBwAAAAcQB2AHwAQZSk1gALA30AgABBoKTWAAsHgQAAAAAAgwBBtKTWAAsPhAAAAAAAhwAAAAAAAACJAEHOpNYACwOKAIsAQeCk1gALBY4AjwCQAEHwpNYACxWRAAAAAAAAAJIAlQCXAJgAAAAAAJkAQaSl1gALAZoAQbKl1gALAZsAQbyl1gALA6AAtgBBzKXWAAsRtwAAAAAAAAC8AL0AAAAAAMAAQeql1gALAcIAQfyl1gALF8UAygDRAAAAAADSAAAA4AAAAAAAAADhAEGoptYACxPnAAAAAAAAAOgAAADwAAAAAADyAEHSptYACxP0AAAAAAAAAPYAAAAAAPkA+wD9AEHwptYACxwCAQAAAAAFAQcBAAAAAAAACwEAAAAADAEAAA0BAEGep9YACwIPAQBBrKfWAAsyEAEAABEBAAAVAQAAFgEeAQAAAAAAAAAAHwEAACEBIgEjAQAAAAAAACcBAAAAACgBKQEAQfKn1gALFCoBAAAAAAAAKwEAAAAAMQEAAEQBAEGQqNYACypHAQAASAFJAQAAAAAAAAAAUAEAAAAAVAEAAFUBVgFXAQAAAABaAQAAXAEAQcao1gALHF0BXwEAAAAAYwEAAGsBAABsAQAAcAFxAQAAcgEAQfCo1gALAnQBAEGIqdYACzx1AQAAdwEAAAAAAAAAAHgBeQEAAAAAigGLAYwBAAAAAI4BAAAAAAAAAACQAQAAAACYAQAAAAAAAAAApAEAQdCp1gALKqUBAAAAAKYBpwEAAAAArQGzAbQBugEAAAAAuwEAALwBvQHFAcgBAADJAQBBhKrWAAsaygEAAAAAAADLAQAAAAAAAMwBAADOAc8B0QEAQaqq1gALBNIB1QEAQbqq1gALaNYBAAAAAAAA2gEAANwBAAAAAAAAAADjAQAA5QEAAAAAAADmAQAAAADoAesB7AEAAAAA8QHzAfQBAAD1AQAAAAAAAPkBAAAAAPoBAAAAAAAA+wEAAAAAAAD9AQAAAAAAAAAA/wEAAgcCAEGuq9YACxYRAhICAAAAAAAAFgIAAAAAAAAAAB8CAEHWq9YACw4pAgAAAAAAAAAALQIwAgBB8KvWAAsGMQIAADQCAEGCrNYACzw1AjYCAAA/AgAAawIAAGwCAAAAAG8CcAIAAAAAAABxAgAAAAByAnMCAAAAAHQCAAAAAAAAAAB2AgAAdwIAQdCs1gALIIECAAAAAAAAAACDApACnAIAAAAAAAChAgAAAAAAAKICAEGArdYACxKqAgAArwIAALICAAC1ArsCvAIAQZ6t1gALLsACwQIAAAAAAAAAAMMCxgIAAMcCAAAAAAAAAADWAgAAAADZAgAAAAAAANoC2wIAQdat1gALJPACAAAAAAAA+gIAAPsCAAAAAP8CAAAAAAAAAgMGAwAAAAAHAwBBjq7WAAtmCAMAAAAAAAAJAw8DAAAAAAAAEQMUAwAAAAAAAAAAFgMAAAAAAAAZAwAAAAAAAAAAGgMAAAAAJAMzAzUDAAA7AwAAAAAAAEIDAAAAAEMDAAAAAAAASQMAAEwDAABSA1MDWwMAAFwDAEGCr9YACwxqAwAAbAMAAG0DegMAQZ6v1gALBn0DfgOCAwBBwq/WAAsqgwMAAAAAAACEA4gDigMAAAAAAACLAwAAjAONAwAAjgMAAAAAAAAAAI8DAEH2r9YACxSUAwAAAAAAAJoDnQMAAKIDAACmAwBBlLDWAAsOrwMAAAAAsAMAALkDugMAQa6w1gALOLsDAADCA8MDAAAAANADAAAAANED0gPTA9QDAADVAwAAAAAAAAAA2AMAAAAA2QMAAAAA2wPdA98DAEH4sNYACwrgAwAAAAAAAOEDAEGOsdYACwrkAwAAAAAAAOgDAEGisdYACx7qAwAAAAAAAAAA7QPvAwAAAAAAAPEDAAAAAAAA8gMAQcyx1gALMPMDAAD0AwAAAAAAAAAA9gP4AwAAAAAAAPwDAAD9AwAAAAAAAAAA/gMAAAAAAAAABABBiLLWAAsKAQQAAAAAAgQDBABBnLLWAAtCBwQAAAkEAAAAAAAAAAAKBAAAAAAAAA0EEAQAAAAAAAASBBMEAAAAAB0EAAAeBAAAAAAhBAAAAAAAACIEAAAAACQEAEHsstYACxwlBAAAAAAmBAAAAAAAAAAAJwQAAAAAAAAAACgEAEGSs9YACxopBAAAAAAAAAAAKgQrBAAAAAAAAC0ELgQwBABBuLPWAAsGMQQAADMEAEHKs9YACw44BDwEAAAAAAAAAABABABB5LPWAAsqRgQAAEcEAABTBAAAAAAAAFgEWgQAAF8EAABiBAAAAABmBAAAaQQAAGoEAEGYtNYACwJsBABBprTWAAsmeAQAAAAAeQR6BAAAfAR9BAAAAAB+BH8EAAAAAAAAAACABAAAgQQAQda01gALDoIEAACLBAAAAAAAAIwEAEHutNYACwqNBAAAjwQAAJIEAEGCtdYACwSTBJQEAEGWtdYACwqVBJcEmQQAAKIEAEG0tdYACxSrBAAAAADFBAAAAADIBAAAAADLBABB0rXWAAsKzATNBAAAAADOBABB7rXWAAtEzwQAAAAAAADRBAAAAADbBNwE3gTgBAAAAAAAAAAA5gTnBOoE6wQAAAAAAADsBAAAAADtBAAAAAAAAO4E8AQAAAAA8QQAQcq21gALOPIEAADzBAAAAAAAAAAA+QT6BPwECQUAAAAACwUMBQ0FAAAAAA4FDwUQBQAAAAAAAAAAFgUAABgFAEGUt9YACxAfBSAFAAAiBQAAJAUoBSkFAEGyt9YACywqBSsFLAUAADcFAAA4BQAAAAAAAAAAPQU+BQAAQgUAAE0FAAAAAAAATgVQBQBB6rfWAAsQUQUAAAAAAABSBVUFAABWBQBBiLjWAAsCYwUAQaK41gALBmoFAABsBQBBxLjWAAsWcwUAAAAAAAAAAHsFAAB9BQAAAAB/BQBB5LjWAAsigAWBBQAAggUAAAAAAACEBYUFiAUAAAAAlQWrBQAAAACuBQBBlLnWAAsCrwUAQaS51gALErAFAAAAAAAAAACzBbQFtQXDBQBBwrnWAAtgxQUAAMgFAADJBQAAAADOBQAAAADXBQAAAAAAANgFAAAAANoF2wXdBfAF8QUAAAAAAAD2BQAAAAAAAAAA+AX5BQAA/QUABgAAAAAAAAEGAgYNBgAADgYWBhcGJAYAACUGAEG0utYACwInBgBBwLrWAAsSKwYAAD8GAABDBgAARAYAAEUGAEHcutYACzxIBkoGAAAAAAAAAABLBgAATwYAAFAGUgYAAFMGAAAAAFYGAAAAAAAAAABiBgAAAAAAAGMGAAAAAAAAaQYAQaq71gALEGsGAAAAAAAAcgYAAAAAdAYAQcS71gALNHUGAAAAAAAAdgYAAAAAAAAAAHcGAAB+BgAAAAB/BoAGAAAAAIQGAAAAAIUGhgYAAIgGiQYAQYK81gALGIoGAAAAAAAAiwaMBpAGAACSBgAAAACXBgBBpLzWAAs0qAYAAAAAqQYAAAAAuQYAAAAAAAAAAMYGxwYAAAAAAAAAAMkGAAAAAAAAAADLBgAAAADMBgBB7LzWAAsezQbPBgAAAAAAAAAA0QYAAAAAAADVBgAAAAAAANcGAEGWvdYACwzgBgAAAAAAAAAA5QYAQay91gALTPgGAAD5BvsGAAAAAAAAAAD8Bv0GAAAAAAAAAAD+Bv8GAQcAAAYHBwcAAAAAAAAAAAkHAAALBw0HAAAAAAAADgcTBwAAFAcWBwAAHQcAQYK+1gALBB4HKQcAQZK+1gALAjgHAEGgvtYACxRBBwAAAAAAAEMHAAAAAAAAAABFBwBBwr7WAAsSSgcAAIEHhQcAAAAAAACJB4oHAEHmvtYACxSLBwAAAAAAAAAAjAcAAAAAAACOBwBBir/WAAsamgcAAAAAnAcAAAAAAAAAAJ4HAAClBwAApgcAQa6/1gALGK0HrwcAAAAAAAAAALAHAACxBwAAswe0BwBB5L/WAAtAtQcAAAAAAAAAALcHAAAAAAAAAAC4B7sHAAC+BwAAAAAAAAAAwAfEBwAAAAAAAAAAxgfUB9gHAAAAAAAA3AfdBwBBuMDWAAsY3wcAAOAH4QcAAAAAAAAAAOUHAAAAAOkHAEHawNYACwrtB/QH+AcAAPoHAEGAwdYACwL7BwBBjMHWAAsC/QcAQZzB1gALIP4H/wcAAAAIAQgAAAsIAAAAAA8IAAAQCBEIAAAAABIIAEHIwdYACyIVCAAAAAAAAAAAFggAABcIAAAYCAAAAAAAAAAAIAgiCCMIAEH0wdYACyglCAAAJggoCCkIOQgAAAAAAAAAADsIAAAAAEQIRQgAAEgIAAAAAEoIAEGmwtYACyJLCAAAAABNCE8IUAgAAAAAAABSCAAAAAAAAFkIWwhcCF0IAEHawtYACyZgCGEIAAAAAGIIZQgAAAAAAAAAAGYIAAAAAGcIbggAAG8IAABwCABBjMPWAAsMcQhyCAAAAACSCJoIAEGkw9YACxydCKkIAACsCAAArQgAAK4IsAgAAAAAAAAAAL0IAEHKw9YACw6+CAAAvwjBCAAAAADCCABB4sPWAAsCwwgAQfDD1gALGswIAAAAAM0IAAAAAAAA0QjSCAAAAAAAANQIAEGYxNYACwbWCAAA2AgAQajE1gALBN0I3ggAQb7E1gALLN8IAADhCAAAAAAAAAAA5QgAAAAAAAAAAOYIAAAAAAAAAADnCAAA6AgAAOsIAEGOxdYACwLvCABBnsXWAAse8QjyCAAAAAAAAAAA8wgAAPQIAAAAAAAA9Qj3CPgIAEHKxdYACwL6CABB1sXWAAsQ/wgAAAEJAAAAAAIJAAADCQBB/sXWAAskCQkKCQsJDAkAAAAADgkAAA8JAAASCQAAAAATCQAAFAkAABYJAEGwxtYACzgfCQAAIAkiCSMJAAAkCQAAAAAAADMJAABHCQAATglSCQAAUwkAAAAAWgkAAAAAAAAAAFsJAABdCQBB8sbWAAsCXgkAQYLH1gALEl8JYglkCWgJawkAAAAAAABtCQBBsMfWAAsQbwkAAAAAcAlxCXMJAAB0CQBBysfWAAsKeQkAAAAAAAB6CQBB7MfWAAsUewl8CQAAfQkAAAAAfgmCCQAAhAkAQYzI1gALUIkJigkAAI0JAAAAAI4JmQkAAJsJAAAAAJ4JAACgCQAArQkAAK4JtgkAAAAAAAC7CQAAAAC9CQAAAAC+CQAAvwkAANEJ2wkAAAAAAAAAANwJAEHoyNYACzLgCeEJ4gkAAAAA4wkAAOUJAAAAAOYJ5wkAAOgJ6QkAAOoJAADrCewJAAAAAAAA8QnyCQBBqMnWAAsO9AkAAAAA9QkAAPYJ+wkAQcDJ1gALBv0JAAAACgBB3MnWAAsGAQoAABAKAEH0ydYACwwRChIKAAAAAAAAEwoAQY7K1gALYBQKAAAAAAAAAAAVCgAAAAAAAAAAFwoAABgKAAAcCh4KAAAAAAAAHwoAAAAAAAAAACEKIgoAACMKAAApCioKAAAAACsKAAAtCgAAAAAAAC4KLwozCgAANwoAAAAAAAA5CgBBiMvWAAtKOwoAAAAAPAoAAAAAAAA9CgAAPwoAAEEKAAAAAEQKRQoAAAAASwpMCk0KAAAAAE8KAAAAAAAAUgoAAAAAAAAAAFMKAABUCgAAWQoAQd7L1gALCl8KYAoAAAAAYQoAQfLL1gALAmIKAEH+y9YAC2RjCgAAAAAAAAAAaAp9CgAAfwoAAIAKAAAAAIEKAAAAAIYKAACHCgAAAACKCgAAjQqSCgAAAAAAAJMKAACVCpYKlwoAAAAAAACgCqoKrwoAAAAAAAAAALIKtAoAAAAAAAAAALsKAEHuzNYACwi8CgAAAAC9CgBBgM3WAAsKvgoAAAAAwArCCgBBlM3WAAsWxgoAAAAAAAAAAMoKAAAAAAAAAADLCgBBuM3WAAsUzArPCgAAAAAAAAAA0AoAAAAA0goAQdrN1gALAtMKAEHuzdYACwLUCgBB+s3WAAsg1QrYCgAAAADfCgAAAADgCgAA5QoAAOYKAAAAAAAA6AoAQa7O1gALBOkK6woAQb7O1gALAuwKAEHMztYACyLtCu8KAAAAAAAAAADzCgAAAAAAAAAA9goAAPcK+AoBCwMLAEH4ztYACw4FCwAAAAAAAAAABgsHCwBBlM/WAAsMCAsAAAAADAsAABILAEGsz9YACwwUCwAAFgsAAAAAFwsAQdrP1gALChkLAAAAAAAAGgsAQe7P1gALHBsLHAsAAAAAAAAAAB4LAAAAAB8LAAAhCwAAJQsAQZTQ1gALUikLAAAAAAAAAAAqCwAAKwsAAAAALAsAAC4LNAsAAAAAAAAAADsLAAA8CwAAAAA9Cz4LRAtJC0oLAAAAAEsLAAAAAEwLAAAAAAAAWgtgCwAAYQsAQfbQ1gALBmQLAAB2CwBBhtHWAAsQdwsAAAAAAAAAAHsLAAB8CwBBpNHWAAssfQsAAAAAAACCCwAAhQsAAAAAhguKC4sLAAAAAAAAjwuRCwAAAACSCwAAkwsAQdzR1gALCJQLlQuWC5cLAEHy0dYACwKZCwBB/tHWAAsMmgufCwAApgunC6gLAEGU0tYACwitCwAAAACuCwBBqtLWAAsCrwsAQbzS1gALWLYLAAC4C7kLAAAAALoLAAAAAAAAuwsAAAAAxAsAAAAAzgsAAAAA0AsAAAAA0QvTCwAAAAAAANYLAAAAAAAAAADaC9sLAAAAANwLAADfCwAA6QsAAAAA6gsAQaDT1gALFOsLAADtCwAAAAAAAAAA8QsAAPILAEHE09YACxT3CwAAAAABDAIMBgwHDAAACAwODABB6NPWAAssDwwAABQMAAAXDAAAGwwAAAAAAAAcDAAAHQweDAAAMgwAAAAAAAA0DAAANQwAQaDU1gALCjwMPgwAAAAAQAwAQbjU1gALCEsMAAAAAE0MAEHK1NYACzhODE8MUAwAAAAAAAAAAFYMAAAAAFgMAAAAAFkMAAAAAFoMAABbDF4MYAwAAAAAYQxiDAAAAABjDABBkNXWAAsSbgwAAHAMAAAAAHQMAAAAAHoMAEGu1dYACwyEDAAAAAAAAAAAiQwAQdDV1gALBJAMkQwAQeLV1gALOJMMAAAAAJQMlgwAAJcMAAAAAAAAAACYDAAAmQyaDAAAnAyhDAAApwypDKoMAAAAALMMtAy1DLcMAEGq1tYACxC8DAAAAAC9DAAAAAAAAMMMAEHK1tYACyDHDAAAAAAAAM4MAADSDAAAAAAAANQMAAAAAAAA1QzWDABB+NbWAAse1wzcDAAAAAAAAAAA3gzgDAAAAADjDOQM5QwAAOYMAEGg19YACwToDOoMAEGw19YACwLsDABBxNfWAAsC7wwAQdbX1gALCvAM8gzzDAAA9gwAQfDX1gALAvcMAEH819YACwL5DABBkNjWAAtE+gwAAAAA/Az9DAAAAAD+DAAAAAAADQENAw0AAAAABw0AAAAACQ0AAAoNAAAAAAAAAAAPDRMNAAAAAAAAFA0AAAAAFw0AQeDY1gALAhoNAEH22NYACwwbDQAAAAAlDSYNJw0AQY7Z1gALICgNKQ0AACoNAAAAAC0NAAAAADANAAAAADENAAAzDTsNAEG42dYACwI+DQBByNnWAAsoSg0AAEsNbA1tDW8NAAAAAHENAAAAAAAAcg0AAAAAeQ0AAAAAAAB6DQBB/tnWAAscew0AAAAAfA0AAH0NgA0AAIENAAAAAIINAACDDQBBrNrWAAt6hA0AAAAAjQ2ODQAAAACTDQAAAAAAAJgNnw2hDQAAog0AAAAAow2rDQAArA0AAAAArQ0AAAAAAACuDQAAug0AAAAAAAC8Db0NAAAAAAAAvg0AAAAAAAAAAMANwQ3CDQAAAADGDcoNAAAAAAAAAADLDQAAAAAAAAAA0A0AQbTb1gALHNMN1Q0AAAAA1g3YDQAA2w3cDQAAAADeDQAA4Q0AQd7b1gALDuINAADjDQAA5g0AAOcNAEH829YACy7rDQAA/Q0AAAAAAAAPDgAAAAAAABAOAAARDgAAEg4TDgAAAAAWDhgOAAAaDhsOAEG83NYACwYcDiAOIw4AQdzc1gALDCgOLA4AAC0OMg4zDgBB9NzWAAsONA4AADUOAAAAADYOQw4AQY7d1gALEEQORQ4AAAAAAAAAAEgOSQ4AQajd1gALJkoOAAAAAAAAAABLDgAATQ5PDlAOAABRDgAAbA4AAAAAAABuDnAOAEHm3dYACwJyDgBBht7WAAscdA4AAAAAdQ4AAAAAAAB8Dn0OAAAAAAAAfw6ADgBBrN7WAAsOiw4AAIwOjQ4AAAAAjg4AQcbe1gALSpAOkQ4AAJYOlw6ZDgAAAAAAAJ8OAAChDgAAAACiDgAAAACjDqQOAACtDgAArw62DrcOAAC4DgAAAAAAAAAAuQ4AAAAAuw4AAL4OAEGc39YACwK/DgBBqt/WAAsOwA4AAMEOyg4AAMwOzQ4AQcrf1gALBs8OAADjDgBB2t/WAAsI5g7nDugO7A4AQfDf1gALOO0OAAAAAPEOAAAAAAAAAAD7DgAAAAAIDwkPAAAAAAAAAAAKDwsPDQ8AAAAAAAAAABMPAAAUDxYPAEGy4NYACwIXDwBBxODWAAtKIQ8AACIPAAAjDy4PAAAvDwAAAAAAAAAANA9JDwAASg8AAAAAAABVD1sPAAAAAAAAAABeD2UPZg8AAAAAAAAAAGcPAAAAAAAAaA8AQZjh1gALEGkPAABrDwAAAAAAAHQPdQ8AQbrh1gALJHYPAAB3D30PAAAAAAAAAAB+DwAAAAAAAH8PAAAAAAAAgA+GDwBB6OHWAAsUhw+JD4oPAAAAAAAAAACMDwAAkQ8AQYzi1gALCpIPqw8AAAAAsQ8AQazi1gALGrIPAAAAAAAAAACzDwAAtw8AAAAAAAC7D7wPAEHW4tYACxC/D8IPAAAAAMMPxQ/HD8gPAEHw4tYACxbbDwAA3A/dDwAA3g/fD+IPAAAAAOgPAEGg49YACwL4DwBBrOPWAAsU+w8AAAAAAAAAAP4P/w8AAAAAABAAQcrj1gALMAIQAxAAAAAAAAAFEAAACBAAAAAAAAAJEAwQAAAREAAAAAATEBQQAAAeEAAAAAAfEABBiOTWAAu+ASAQJBAlEAAAJhAAAAAAAAApEAAAAAAtEAAAAAAAAAAAMBAyEDMQAAAAAAAAAAA0EAAAAADXEAAAAAAAANoQ6RAAAOsQ7BAAAO0QAADuEAAAAAAAAO8QAADwEAAAAAAAAPEQAAAAAAAA9hD5EPoQ/hAAAP8QABEAAAIRAxEAAAAADBEAAAAAAAAAABERAAAAAAAAFREAABYRAAAAAAAAAAAZEQAAAAAAAAAAGhEAAAAAAAAcEQAAAAAAAB0RHhEAQdTl1gALUiARAAAAAAAAAAAhEQAAAAAAACIRAAAAAAAAJxEuEQAAAAAAAAAANxE5EQAAAAAAAAAAOhEAAAAAOxEAAD4RPxFCEQAASxFMEU4RAABPEQAAYBEAQbDm1gALFmERAAAAAAAAYxFkEQAAZRFmEQAAaBEAQdTm1gALBmsRAABvEQBB5ObWAAsKchEAAHMRAAB1EQBBiOfWAAssdhF3EQAAeREAAAAAexEAAAAAAAAAAH0RfhEAAAAAAAB/EYERAACCEQAAhBEAQcLn1gALToYRAAAAAIgRAAAAAJERAACcEQAAAACeEZ8RAACoEasRAACsEQAArREAAK8RAAAAALARAAAAAAAAAACyEQAAsxEAAAAAtBEAAAAAAAC1EQBBmujWAAsKtxEAAAAAAAC4EQBBrujWAAtOvRG/EcARwRHDEQAAxBEAAAAAAAAAAMYRxxEAAMkRAAAAAAAAAADSEQAAAADbEQAAAAAAAN4RAAAAAAAA3xEAAOARAADhEQAAAAAAAOURAEGG6dYAC0LmEQAAAADqEQAAAAAAAOwRAAAAAPURAAD2EQAAAAAAAAAACBIJEgAAChIAAAAAAAAAAAsSAAAMEgAAAAANEgAAEBIAQdLp1gALIhESAAAAAAAAAAAxEgAAMxIAADsSAAAAAAAAPBI+EgAAQBIAQf7p1gALSEESRBIAAAAAAAAAAE8SAAAAAAAAAABZEgAAAAAAAAAAWxIAAF0SAAAAAAAAAABeEgAAAABiEgAAAABpEgAAAAAAAGoSaxJsEgBB3urWAAswbRIAAAAAcBIAAHESeRJ/EgAAAAAAAIESAAAAAAAAgxIAAAAAAACEEgAAAAAAAIUSAEGY69YACwqGEgAAiRKKEosSAEGy69YACwqMEgAAAAAAAI0SAEHm69YACyqPErISAACzEgAAtBK8EgAAAAC9Er4SAAC/EsYSxxIAAAAAAAAAAMkSyhIAQZzs1gALAssSAEGo7NYACxzMEgAAzRIAAAAAzxIAANUS1hIAAAAAAAAAANcSAEHY7NYACy7YEgAAAAAAAAAA2hIAAAAAAADcEgAA3RIAAAAAAADrEgAAAADvEgAA9RL3EvoSAEGQ7dYACyT7EgAAABMAAAAADxMAAAAAAAAAABATAAAAAAAAAAAREwAAEhMAQcbt1gALDBMTAAAAAAAAAAAUEwBB3O3WAAsaFhMXExgTHhMgEwAAJhMAAAAAKRMAAAAAMxMAQYTu1gALCDQTNRM3EzkTAEGW7tYACww+EwAAAAAAAAAAPxMAQbLu1gALGkETAABCE0MTAABKEwAAWBMAAFkTXRNgE2QTAEHa7tYACwabE5wTnhMAQeru1gALLp8TAAAAAAAAoBMAAAAAAAChEwAAAAAAAAAApBMAAAAAAAAAAKUTphOnEwAAqRMAQarv1gALRqoTqxMAAKwTAAAAAK0TAAAAAAAAAACuEwAAAACvEwAAAAAAALETshMAAAAAAAAAALQTuRO+EwAAvxMAAMETAAAAAAAAxBMAQfrv1gALFMcTAADIE8kTAADLEwAAAAAAAMwTAEG28NYACwLUEwBBxvDWAAsQ1RMAAAAA1hPYEwAAAADbEwBB5vDWAAsC3RMAQfTw1gALEuoT6xPtE/ET8xMAAPQTAAD1EwBBlPHWAAsC9hMAQaDx1gALIv0T/hMAAAEUAAACFAAAAAAKFAAAAAAAABEUAAAAAAAAHBQAQdDx1gALMB8UIhQAAAAAAAAjFAAAAAAkFCcUKRQAAAAAAAAAACoUAAAAAAAAAAArFCwUAAAuFABBlPLWAAsKLxQAAAAAAAA0FABBqvLWAAscOhQ7FAAAAABGFAAAAABHFEgUShQAAAAAThRRFABB0PLWAAsIUxQAAFYUWRQAQeTy1gALCF0UAABeFGAUAEH28tYACwJhFABBiPPWAAseYhRjFAAAbxQAAAAAfBSBFAAAhhQAAIcUAAAAAIkUAEGw89YACwyKFAAAjBSWFAAAnRQAQcjz1gALCKAUoRSiFKMUAEHa89YACwakFAAApRQAQerz1gALBKcUqBQAQYL01gALEKkUqxQAAAAArhQAAAAArxQAQaD01gALJrgUAAAAALoUuxS8FAAAvRQAAAAAvhQAAAAAAAAAAL8UwBQAAMEUAEHQ9NYACwrEFAAAAAAAAMUUAEHs9NYACwLNFABB+vTWAAsWzhQAAM8U0RQAANQUAAAAAAAAAADaFABBoPXWAAsc3BQAAAAA3RQAAAAAAADeFAAA3xTgFAAAAADhFABByPXWAAsE4xTkFABB3vXWAAtK5RQAAOYUAADqFAAAAAAAAAAA7hQAAAAA7xQAAAAA8RQAAAAA9RQAAPcUAAD9FAAAAAAAAAMVAAAAAAAABBUAAAAAAAAGFQAACBUAQbT21gALDAkVAAAAAAAAAAALFQBBzPbWAAsGDBUOFREVAEHo9tYACw4UFQAAAAAAAAAAFRUaFQBBgPfWAAsMGxUAAAAAAAAcFR0VAEGk99YACyIeFQAAAAAAAAAAIhUAAAAAIxUAACcVAAAAAAAAAAAoFToVAEHc99YACwY+FQAAQBUAQe731gALNEEVQhUAAAAAAABDFUQVRxUAAAAASBVJFUsVAAAAAAAAUBVRFQAAAAAAAFMVAAAAAAAAVRUAQb741gALIlgVAABaFQAAAABbFQAAXhUAAAAAYRUAAAAAYhUAAAAAZBUAQfb41gALAmUVAEGG+dYACwpsFQAAAABtFW4VAEGa+dYACwJwFQBBqvnWAAsCcRUAQbb51gALMoMVAAAAAAAAhhUAAIcVAAAAAIgVAAAAAAAAiRUAAIsVAAAAAIwVjRUAAI4VAAAAAJIVAEHy+dYAC16eFZ8VAAAAAKAVAACiFQAAAACnFQAAqBUAAAAAqRUAAKsVAAC1FQAAAAC2FQAAuBW/FQAAAAAAAAAAwBUAAAAAAADDFcUVAADGFQAAxxUAAAAAAAAAAMkVAAAAAN4VAEHi+tYACy7gFekVAAAAAAAAAADqFQAAAADsFQAA+BUAAPkVAAAAAAAA/RUAAAkWAAAKFgsWAEGc+9YACyQTFgAAAAAAABQWFRYAAB0WHhYuFgAALxYAAAAAAAAAADUWNhYAQcr71gALCDoWPBYAAEcWAEHc+9YACwxKFgAAAAAAAAAASxYAQfT71gALJkwWAAAAAE0WAABOFgAAAAAAAFAWAABlFgAAZhZnFgAAAABwFncWAEGy/NYACwZ4FgAAehYAQcT81gALTH0WfhYAAIAWgRYAAAAAAAAAAIMWhBaFFgAAhhYAAIcWiBYAAIoWAAAAAAAAAACQFpQWAAAAAAAAAACWFgAAAAAAAAAAmBYAAAAAnBYAQab91gALAqUWAEHG/dYACxCnFgAAAACpFgAAAAAAALMWAEHi/dYACwi4FgAAAADDFgBB+v3WAAscxhbHFgAAAADIFgAAAADJFgAAyxbUFtUWAADWFgBBoP7WAAsC2hYAQaz+1gALRtwWAADfFuEWAAAAAOMWAADlFgAAAADnFgAA6RYAAAAAAADxFvMWAAAAAAAA9RYAAPcWAAAAAAAAABcAAAAAARcDFwAABhcAQf7+1gALBgcXAAAJFwBBkP/WAAs6ExcAABcXAAAAABgXAAAZFyIXJBcAACcXKBcAAAAAAAAAACkXKhcAAC0XAAAAAAAAAAA9FwAAAAA/FwBB2v/WAAsiQRcAAAAAQhcAAEcXSBdJFwAATBcAAAAAAABYF1oXYxdmFwBBhoDXAAsoZxcAAGgXAAAAAAAAahdrFwAAAABsFwAAAABxF3MXAAAAAAAAAAB3FwBBuIDXAAsieBcAAAAAeRcAAHoXAAAAAAAAexd/FwAAgRcAAIMXAACHFwBB6IDXAAsCiRcAQf6A1wALOIoXAACOFwAAAACQFwAAAAAAAJEXlheYFwAAAAAAAJkXnRcAAAAAnhcAAAAApRcAAAAAphcAAKcXAEHCgdcACxapFwAArxcAAAAAAACwFwAAshe3F7gXAEHkgdcACwq7F7wXAAAAAL0XAEGAgtcACwS+F78XAEGUgtcACwbAFwAAwxcAQaSC1wALRsQXAAAAAMgXAADJFwAAAADNF9kXAAAAANsXAADeFwAAAAAAAN8X7RfuFwAAAAAAAPEXAAAAAAAAAADyFwAAAAAAAPMX9hcAQfaC1wALAv4XAEGDg9cACxkYAAAAAAIYBxgJGAAADBgAABMYAAAkGCUYAEGmg9cACzYmGAAAAAAAAAAAKBgzGAAAAAA+GAAAQBgAAAAARBhFGEYYAABHGAAAAAAAAFQYAAAAAAAAWhgAQeiD1wALElsYYBgAAGIYYxhkGAAAahhvGABBhITXAAsYcRgAAAAAAAByGIYYAACMGAAAAAAAAI0YAEGshNcACxKOGAAAAAAAALAYAAAAALIYvBgAQc6E1wALAr4YAEHehNcACyy/GAAAAADBGAAAwhgAAMMYxBgAAAAA1BjVGOEYAAAAAAAA4hjjGOQYAADlGABBlIXXAAsC6BgAQaCF1wALHu4Y7xjwGAAAAAAAAAAA8hgAAPUY/RgAGQsZAAAOGQBBzIXXAAsEDxkQGQBB3IXXAAsMERkAAAAAAAAAABIZAEH2hdcACxYUGQAAFRkXGRkZAAAdGR4ZAAAhGSYZAEGghtcACz4nGSgZAAAAACkZAAAAACwZAAAAAAAAAAAuGQAAAAAAAAAALxkwGQAAAAAyGQAAAAAAADYZAAAAADcZAAA9GQBB6obXAAsgPhkAAAAAPxkAAEAZAABBGUMZAAAAAAAARBkAAE8ZUBkAQZiH1wALClEZAAAAAFUZVxkAQa6H1wALAl0ZAEHAh9cACwZeGV8ZYBkAQdCH1wALDGIZAAAAAAAAaxlsGQBB8IfXAAsWbxlwGQAAAAAAAAAAcRkAAAAAAAByGQBBkIjXAAtUdBkAAAAAdRl2GQAAAAAAAHcZeBl5GQAAexkAAAAAAAAAAHwZgBkAAIIZAAAAAIQZAACyGQAAAAAAALcZAAC4GQAAAAAAALsZAAAAAAAAvhkAAL8ZAEHuiNcACw7AGQAAAAAAAAAAwRnCGQBBhonXAAsOxxnIGQAAAADJGcoZzBkAQbCJ1wALAtAZAEHCidcAC0zSGdMZAADXGQAA2BnaGdwZAADtGQAAAAAAAAAA7xkAAAAAAAAAAPEZAADyGQAAAAAAAPcZAAAEGgcaAAAIGgAAChoNGgAAExoUGhUaAEGgitcACw4WGgAAAAAAABcaAAAYGgBBvIrXAAsCJRoAQdCK1wALDjAaMRoyGgAAAAA3GjkaAEHoitcACxA8GgAAAAAAAD0aAAA/GkQaAEGIi9cACwRFGkYaAEGWi9cACyBIGkkaTxoAAFEaVhoAAAAAVxpeGgAAXxoAAAAAYBphGgBBwovXAAsCYhoAQc6L1wALAmQaAEHci9cACyxrGgAAAABsGm0aAAAAAAAAchoAAAAAAAB4GnwaAAB9GgAAAAAAAH8aAACAGgBBrozXAAsYgRoAAAAAAACIGgAAAAAAAIkaAAAAAJIaAEHQjNcACzSTGgAAAAAAAJQaAAAAAAAAnBoAAAAApxoAAKgatxoAAAAAAAAAAMQaAAAAAMYaAADIGskaAEGWjdcACxTTGgAA1BrWGtgaAAAAAAAA2RraGgBBtI3XAAsI2xoAAAAA3RoAQcqN1wALDt4aAAAAAAAA3xoAAOAaAEHsjdcACw7nGgAA6BrrGu0aAADvGgBBio7XAAs68xoAAAAAAAAAAPUaAAAAAAAAAAD+GgAA/xoAAAAAABsAAAAAARsCGwAAAAAAAAMbAAAAAAAABBsHGwBB0I7XAAs0DBsAAA0bAAAAAAAADhsPGxAbAAARGwAAEhsAAAAAExsXGwAAGBsAAAAAAAAAABsbHBsdGwBBoo/XAAsGHhskGyUbAEG2j9cACxIoGyobMxs1GzYbAAAAADcbOBsAQdqP1wALFjkbAAAAADobQxsAAAAARBsAAAAARxsAQfqP1wALAkgbAEGKkNcACwZMG04bUBsAQZ6Q1wALClMbAAAAAAAAZBsAQbqQ1wALAmsbAEHMkNcACxJtGwAAAABuG28bdBsAAHYbeRsAQeqQ1wALAn4bAEGAkdcACwJ/GwBBjJHXAAsGhhsAAIcbAEGokdcACwSIG4wbAEG2kdcAC06OGwAAlBsAAAAAAAAAAJUbAACZGwAAAAAAAAAAmxudGwAAnhufG6AbAAAAAKYbAACoG6kbAACrGwAAAAAAAKwbrxuwGwAAAACyGwAAtRsAQaKS1wALCMMbAAAAAMQbAEG6ktcACwbGGwAAyhsAQc6S1wALBssbAADMGwBB3pLXAAsizRsAAAAAzhsAAAAA1BsAANUbAAAAANYbAAAAAAAAAADYGwBBipPXAAs02RsAANobAADcG90bAAAAAN4bAAAAAOMbAADsG+4bAAAAAAAAAADwGwAAAAAAAPEb9Bv1GwBByJPXAAsC9hsAQd6T1wALCvsb/RsBHAAAAxwAQfqT1wALCAQcAAAFHA0cAEGMlNcACxQOHBEcAAAAAAAAAAATHAAAIRwkHABBqpTXAAtIJhwnHAAAAAAAAAAAKxwwHAAAMhwAAAAAAAAAADocPBw+HEAcQRxDHEUcAAAAAAAAAABGHEkcAABKHAAAAABPHAAAAAAAAGIcAEGAldcACxR5HAAAAAB6HHscAAAAAHwcAACBHABBqJXXAAsGhBwAAIUcAEHGldcACyKGHAAAAAAAAAAAiRwAAAAAAAAAAIscAACMHAAAjhwAAKccAEH2ldcACwipHAAArxyzHABBiJbXAAswtBwAALUcthy4HLocAAAAAAAAAAC9HAAAvhzGHAAAxxzIHAAAAADNHAAAAAAAAM4cAEHGltcACwrQHAAAAAAAANEcAEHaltcACwjSHAAA0xzUHABB7JbXAAsg1xwAAAAA2hwAAAAAAAAAAOYcAAAAAAAA5xzoHAAA6RwAQZqX1wALAuocAEGml9cACwLtHABBspfXAAsC7hwAQcSX1wALHP0cAx0FHQAAAAAAAAsdAAAAAAwdAAAAAAAADR0AQeyX1wALDA4dEx0AABYdAAAYHQBBjJjXAAsCIB0AQZiY1wALCCEdAAAAACUdAEGqmNcACwImHQBByJjXAAsqJx0qHTAdAAA0HQAAAABCHQAAQx0AAAAARR0AAAAAAABKHUsdAAAAAFQdAEH8mNcAC0xYHQAAAAAAAFkdWh1cHQAAAAAAAAAAXh0AAAAAXx1hHWIdAAAAAAAAZh0AAAAAaR0AAAAAax0AAHAdAAByHQAAcx0AAAAAdR12HXodAEHSmdcACwZ7HQAAfB0AQeKZ1wALCn4dAAAAAIAdgR0AQYCa1wALCIIdix0AAJUdAEGUmtcACxiWHZgdAACaHZ0dnx0AAAAAAACgHQAAox0AQbaa1wALGqUdAAAAAAAAqh0AAAAAqx0AAAAAsB2yHbodAEHamtcAC0C8HQAAvR2+HQAAAAC/HQAAAADAHQAAxB0AAMUdxh0AAMcdAAAAAAAAAADKHQAAAAAAAAAAyx3NHc8dAAAAANEdAEGkm9cACxjXHQAA2B3aHQAAAADbHQAAAAAAAAAA3B0AQcqb1wALAt0dAEHWm9cACxztHe4d7x3xHQAA8h0AAPMdAAAEHggeCh4AAAseAEH+m9cACyQMHgAAAAAUHgAAGx4AABweAAAdHgAAKR4AAAAAAAAqHgAALB4AQa6c1wALDjEeMx4AADQeAAA1HjceAEHKnNcACx47HgAAAAA9HkEeAABEHgAAAAAAAEceAAAAAAAASB4AQfac1wALPkkeAAAAAEweAABNHgAATx4AAFAeAAAAAAAAAABRHlgeAAAAAFkeAAAAAFoeAAAAAFseAAAAAFweAAAAAF0eAEG+ndcACwRiHmceAEHMndcACxZoHmkeAABuHgAAAAAAAAAAcB4AAHYeAEHsndcACz53HgAAgh4AAAAAhR4AAIYeAACIHgAAih6QHpEekh4AAJQelh4AAAAAAACgHgAAoh4AAKMeAAAAAAAAAACkHgBBuJ7XAAsCph4AQcSe1wALMrAesR6yHrYeAAC5HgAAAAC6HgAAAADpHgAAAAAAAAAA6h4AAAAA6x7tHu4e7x4AAPAeAEGUn9cACyDxHvIeAAD0HgAAAAD1HgAAAAD3HgAA+h7/HgAAAAABHwBBwJ/XAAsGAx8AAAQfAEHQn9cACxYFHwAAAAAAAAAACR8AAAAAAAAAAA0fAEH2n9cACwYOHwAAER8AQYqg1wALFCAfAAAAAAAAAAAhHyQfOB8AADkfAEG0oNcACw46HwAAAAAAAAAARx9IHwBB2qDXAAsKSh8AAAAAAABMHwBB9KDXAAseUh8AAFwfXR8AAAAAXh8AAAAAYB9hHwAAAABiH2QfAEGmodcACzplHwAAAAAAAGsfdB97H3wfAAAAAH0fAAAAAAAAfh8AAH8fAACAHwAAgh+EHwAAAAAAAJAfkR8AAJkfAEHqodcACwKcHwBB+KHXAAsEnR+uHwBBiqLXAAsCrx8AQZai1wALCLAfsx8AALUfAEG+otcACyi4H7kfuh/AH8Efwh/DHwAAAADLHwAAAADQHwAAAAAAAAAA0R/SH9kfAEH2otcAC0DaHwAA3R/gH+IfAADkH+UfAAAAAAAAAADmH+cfAAAAAPMfAAAAAAAA+R8AAAAAAAD6HwAAAAD7HwAAAAAAAPwfAEHAo9cACwwMIAAAAAAAAAAAEiAAQdaj1wALDBUgAAAWIAAAAAAXIABB7qPXAAsCGiAAQYKk1wALDBsgAAAdIAAAAAAeIABBrqTXAAsQISAAAAAAAAApIAAAAAAyIABB1KTXAAssNyAAADggPCAAAEAgQSAAAAAARSAAAEggSSAAAAAAAAAAAEsgAAAAAAAATSAAQZKl1wALLk4gAAAAAAAAViAAAFcgWyAAAAAAXSBeIGEgZCAAAAAAAAAAAGUgZyBrIGwgbSAAQcyl1wALBHAgcyAAQd6l1wALIIEgAAAAAAAAgiCDIIUghiCHIAAAAACMIJIgAAAAAJQgAEGIptcACw6eIAAAAACfIAAAoiCjIABBsqbXAAsEqCC0IABBxqbXAAsquSAAAAAAAAAAALwgAAAAAAAAvyAAAMAgAAAAAAAAAADCIMggAAAAAMogAEH+ptcACwzMIM0gAADOIAAAzyAAQZSn1wALLNAgAADRINog2yAAANwg3SDmIAAAAAAAAAAA5yAAAAAAAAAAAOggAAAAAOkgAEHOp9cACwT5IPogAEHep9cAC0T7IAAAAAD8IAAA/yAAAAAAAAAAAAMhAAAKIQAADiEAAAAAFCEAABUhAAAAAAAAFiEAABkhHyEgIQAAAAAAAAAAISEjIQBBtKjXAAsIJCEAAAAAKiEAQcio1wALCishLSEuIQAAUCEAQeCo1wALAlIhAEHyqNcACzhWIVohXCEAAAAAXSEAAAAAYSEAAG0hAAAAAHkheiEAAAAAeyF+IX8hgyEAAIchAAAAAAAAAACPIQBBuqnXAAsGniEAAJ8hAEHSqdcACzKgIQAAAAChIQAAAAAAAKIhAAAAAAAAoyEAAAAApSGpIa0hAAAAAK4hAACvIQAAsCGxIQBBlqrXAAsWvSG+Ib8hyiEAAAAAAAAAAMwhziHPIQBBwKrXAAsC0CEAQcyq1wALAtEhAEHgqtcACwjSIQAAAADTIQBBkKvXAAsC1CEAQZ6r1wALFNUh1yHYIQAAAAAAAAAA2SEAAN0hAEHAq9cACyDfIeIhAADsIQAA7iEAAAAAAADxIQAAAAAAAPIhAAACIgBB9qvXAAs0BiIAAAciCSIKIhQiFyIYIh0iICIAACEiIyIAAAAAAAAAACYiJyIpIjIiAAAAAAAAAAA0IgBBtqzXAAsENSI4IgBBxKzXAAsuOiI7IjwiAAA+IkEiQiJFIgAARiIAAEsiAAAAAAAAAABMIgAAAABNIgAAAABPIgBBnq3XAAsCUCIAQbCt1wALJlEiAAAAAAAAAABSIgAAAAAAAAAAVCJWIgAAAAAAAGMiAABtIm4iAEHgrdcAC0ZvInAiAAAAAAAAAAByIgAAAAAAAAAAdiJ8In0iAAB/IgAAAAAAAAAAgSIAAAAAAACCIgAAAAAAAIMiAACEIgAAAAAAAIUiAEGyrtcACwSGIociAEHMrtcACxaIIgAAAAAAAIkiAACKIgAAAAAAAI4iAEHwrtcACyKPIgAAkCIAAAAAoCIAAAAAoiIAAAAApiKoIgAAAACpIqoiAEGer9cACxyrIgAArCIAAAAAAAAAAMAixCIAAAAAAAAAAMUiAEHEr9cACyDIIgAAyyIAAAAAAAAAAM8i0CLRIgAAAAAAANIiAADTIgBB/K/XAAsK1CIAAAAAAADhIgBBmrDXAAtc4iIAAOQiAADvIgAAAAAAAPEi8yIAAAAAAAAAAPUiAAD2IgAA+iL9IgAAAAAKIwAAAAAAAAAACyMAACQjAAAAAAAAAAAlIygjAAAAAAAAAAApIyojAAAsIzEjQCMAQY6x1wALDEMjeiMAAAAAeyOBIwBBprHXAAsggiMAAAAAAACEIwAAAACFIwAAhyMAAAAAiCOJI40jjiMAQdax1wALApgjAEHksdcAC0iaIwAAAACgIwAAoSOiIwAAAAAAAKMjpCMAAAAApSMAAAAApiMAAKcjAAAAAKkjqyMAAAAAAACsIwAAAACwIwAAuCMAAAAAvCMAQbiy1wALDr0jAADAI8sjAAAAAM0jAEHgstcACwbOIwAA0SMAQfSy1wALGNIjAAAAAAAAAADUIwAA1iPXI9gjAADZIwBBnLPXAAs+4iMAAOMjAAAAAAAA5CPlIwAAAADmIwAAAAAAAAAA5yMAAAAAAADpIwAAAAAAAAAA7SPuIwAAAAAAAPgj+yMAQeOz1wALNSQBJAAABCQAAAAAAAAAAAUkBiQHJAAACCQJJAAAAAALJAAADCQNJAAAAAAOJAAAECQAABEkAEGitNcACwoSJBMkAAAAABUkAEG8tNcACx4WJBgkAAAAABkkAAAAAAAAAAAcJAAAAAAAAAAAHyQAQe601wALCiAkAAAAAAAAISQAQYK11wALHCIkAAAAAAAAAAAjJAAAAAAkJCckAAAAAAAAKCQAQay11wALCCkkAAAAACokAEHAtdcACwIrJABBzLXXAAsMLiQvJAAAAAAxJDIkAEHotdcACwQ0JDckAEH+tdcACw45JAAAAAAAADwkPSQ/JABBmrbXAAsIQCQAAAAATSQAQay21wALBFEkVSQAQca21wALMFwkXSRhJGkkaiQAAG4kbyQAAAAABSUAAAclAAAAAAAAAAAKJQAAAAAAAAslAAAMJQBBiLfXAAssDSUAAAAADiUAAAAAAAARJQAAAAAAAAAAEiUTJQAAAAAAAAAAFSUAABclGCUAQcS31wALBhwlAAAeJQBB1LfXAAsSICUjJQAAJSUAACclAAAAACklAEH2t9cACwIrJQBBhLjXAAsyLCUtJQAAAAAAAAAAPCUAAAAAPSUAAAAAQiUAAEMlRCUAAAAAAAAAAEUlAAAAAAAARiUAQca41wALCEglSSUAAEolAEHauNcAC0ZLJUwlAAAAAAAATiUAAFUlAABWJQAAWSUAAFslYiUAAGQlZiVnJQAAAAAAAGkleCUAAAAAfCUAAAAAAAB+JQAAgCUAAIElAEGsudcACwiIJQAApiWnJQBBwrnXAAsWqSUAAAAAqyWsJa0lriUAAAAAAACwJQBB5rnXAAsEsiW2JQBB+rnXAAsCtyUAQYa61wALKLglAAC5JQAAAAAAAAAAuiUAAAAAuyUAAAAAwCUAAAAAwSUAAMMlxSUAQca61wALaMclAADJJdElAAAAAAAAAADSJdMl1CUAAAAAAAAAANYl4iUAAAAA5CXlJeYlAADnJfUlAAAAAAAAAAD2JQAA/iUAAAAAAAAAAP8lAAAAAAAAACYAAA4mAAAQJgAAAAAAABYmAAAaJhsmAEG4u9cAC04cJgAAHSYoJgAAKSYAAAAAAAAqJismAAAtJgAALiYAAC8mAAAAAAAAMCYxJjgmAAAAAAAAOiYAAD0mAAAAAAAAAABBJkImAAAAAAAAUCYAQZC81wALAlMmAEGqvNcAC0pUJgAAXCYAAF8mAABkJgAAAAAAAAAAZiYAAAAAaSZsJgAAAAAAAHAmAAAAAAAAcSYAAAAAciYAAHUmAAAAAAAAdyZ4JgAAAAB/JgBBgL3XAAsGgCaHJokmAEGWvdcACwqKJosmjCaRJpMmAEGsvdcACxSYJgAAniYAAAAAAACfJgAAAACjJgBBzr3XAAsOsiazJrQmAAAAAAAAtSYAQei91wALFrYmAAAAAAAAAAC5JgAAAAAAAAAAuiYAQYi+1wALDsImAAAAAAAAAADDJsUmAEGivtcACwrKJgAAAAAAAMsmAEHKvtcACyzMJgAA0yYAAAAA1CbqJu4mAADxJvImAAAAAPYmAAD7Jv0m/iYAAAAAAAABJwBBgr/XAAsCAycAQZK/1wALFgQnCScAAAAACicAAAAAAAANJwAAFCcAQbK/1wALEBcnIyckJyYnAAAAAAAALycAQcy/1wALIDAnAAAAADInAAA0JwAAAAAAAAAANicAADcnOCc5JzonAEH2v9cACwI7JwBBgsDXAAsWPSdGJwAAAAAAAAAARycAAAAASSdKJwBBpMDXAAsCSycAQbTA1wALAkwnAEHEwNcACzJPJwAAUicAAAAAAABWJwAAWCcAAAAAXCddJwAAAABkJwAAZydqJ2snAAAAAAAAbidxJwBBgsHXAAsCcicAQZDB1wALCncnAAB4JwAAfCcAQarB1wALmAGIJwAAAAAAAIonAAAAAI0nAAAAAAAAAACPJ5AnAAAAAJYnAACXJ5gnAACZJwAAAACjJwAApSemJwAAAACsJwAArievJ7AnuCcAAAAAuycAAL0nAAAAAAAAwCcAAAAAAAAAAMEnAAAAAAAAAADCJwAAAAAAAAAA0icAANonAAAAANsn3CcAAN0n3icAAN8nAAAAAAAAAADhJwBB0MLXAAsC5ScAQd7C1wALHOknAAD1JwAA9if3JwAAAAD4JwAAAAD9J/4nBCgAQYTD1wALBgooAAAMKABBlsPXAAsIDygAAAAAESgAQarD1wALBhIoAAATKABBwMPXAAsCFCgAQdDD1wALEiwoMCgxKAAAAAAAADIoAAA4KABB7MPXAAsCOSgAQfrD1wALDjooAAAAAAAAAAA7KD8oAEGSxNcACxhCKAAAAAAAAEMoAABEKAAAAAAAAAAARygAQbjE1wALLksoTSgAAAAAAABOKE8oAABRKAAAVigAAFgoAAAAAAAAAABZKAAAAABbKAAAXCgAQfLE1wALCl4oAAAAAF8oYigAQYbF1wALBGMobSgAQZbF1wALBm8oAABxKABBqMXXAAsUeigAAIAoAACBKAAAAAAAAIQohSgAQcbF1wALGIYoAAAAAAAAhygAAIgoAAAAAJIolCiWKABB7MXXAAsYlygAAAAAmCiaKAAAAACcKAAAnSgAAKMoAEGUxtcACxKkKAAApSiqKAAAAACrKAAArCgAQbTG1wALBrUotii3KABBzMbXAAsOuSgAAAAAuygAAAAAvigAQeTG1wALIsAoAADBKMIoAAAAAAAAAADEKMUoAADGKAAAxygAAMwozigAQZDH1wALAtAoAEGcx9cACwLRKABBrMfXAAsa0ygAANUoAAAAAAAA1ijZKAAAAADbKAAA5SgAQdDH1wALBOgo8SgAQd7H1wALCPIo8ygAAPwoAEH6x9cACyADKQAAAAAAAAYpAAAAAA4pAAAZKRwpAAAAAB0pHikgKQBBqsjXAAsQIikAAAAAAAAAACUpAAAmKQBBzsjXAAsWJykoKQAAAAAwKQAAOSk8KQAAPSk/KQBB7sjXAAsqQilDKUQpAABFKQAAAAAAAEYpAABHKQAAAAAAAAAATykAAAAAUCkAAFIpAEGsydcACxJZKVopWyldKQAAXikAAAAAYikAQcjJ1wALKmYpAAAAAGkpAAAAAAAAaikAAGspAABsKQAAbSkAAAAAbykAAIIpAACDKQBB/MnXAAtChSmGKYcpAAAAAAAAlikAAAAAAACXKQAAmikAAJspAAAAAAAAnCmdKZ8pAACiKQAAAACjKQAAqykAAAAAAAAAAK0pAEHQytcACyKuKQAAAAAAAK8pAAAAAAAAAACwKbEpAACyKQAAAAAAALQpAEH+ytcACyK2KQAAuikAAAAAxCkAAMkpAAAAAAAAAADKKQAAAAAAAMwpAEGqy9cACwbPKQAA0CkAQb7L1wALENEpAADbKd4p4CkAAAAA4ikAQd7L1wALDOMpAAAAAAAAAADmKQBB9MvXAAsG5ynqKfcpAEGGzNcACwj4KQAAAAD5KQBBmszXAAsc/CkAAAAAAAAAAP4pAAAAAAAqASoAAAAAAAAEKgBBwszXAAsUBioAAAAAAAAHKgAAESoAAAAAFCoAQeLM1wALEBUqAAAAAAAAGSoAAAAAGyoAQYLN1wALFBwqICoAAAAAAAAlKgAAAAAAACcqAEGozdcACyYrKgAAAAAsKgAAOCoAADkqAAAAAAAAOioAAAAAAAA8KgAAAAA+KgBB4M3XAAtWPyoAAAAAAAAAAEAqQSoAAAAAAAAAAEMqAABEKgAAAAAAAAAARSpGKkcqAABKKmEqAAAAAAAAAABiKgAAAABkKgAAZSoAAAAAaCoAAAAAaSpqKmsqbCoAQcLO1wALFG8qAAByKnMqeCqKKgAAAACLKowqAEHgztcACxSNKgAAAAAAAJAqkyoAAAAAlCqWKgBB/s7XAAsClyoAQZjP1wALHJkqAACaKgAAAAAAAAAAnCqfKgAAoCoAAAAApCoAQb7P1wALDqUqAACmKgAAAAAAAKsqAEHWz9cACzasKgAAAACwKrEqAAAAALIqAAAAAAAAtCoAAAAAAAAAALsqAAAAAMEqAAAAAAAAwyoAAAAAxCoAQaTQ1wALFs4qAADQKtIqAAAAANQqAAAAAAAA1ioAQc7Q1wALEtcqAAAAAAAA2CoAAAAAAADdKgBB6tDXAAtW3yoAAAAAAADgKuIqAAAAAOYq6CrrKgAAAADsKgAA7SoAAAAA7yoAAAAAAAAAAPAqAAAAAAAA8SoAAPMqAAAAAAAA9Cr1KgAAAAAAAPYqAAD3KgAA+SoAQczR1wALFgIrBCsAAAUrCCsJKwAAAAALKwwrDSsAQfrR1wALJg4rAAAAAA8rFSsAAAAAAAAAABcrAAAAAAAAGisAAAAAAAAAAC8rAEGq0tcACwQwKzQrAEG60tcACxY1KwAAAAA4KzkrAAA6KwAAPSsAAE0rAEHa0tcACxxOKwAAAAAAAFArAAAAAAAAVisAAAAAAABXK1grAEGC09cACwRZK1orAEGS09cACzJbKwAAAABeK2QrAAAAAAAAZSsAAGorbysAAHsrAAAAAAAAhisAAAAAhysAAIorAACLKwBB4tPXAAskjCsAAI0rkCuRK5IrAACUKwAAlSsAAAAAAACWKwAAAACXK5grAEGe1NcACxybKwAAAACcK54rAAAAAAAApCumKwAAAAAAAKgrAEHE1NcACxauK68rAAAAAAAAsCuzKwAAAAC0K7UrAEHm1NcACwK6KwBB9tTXAAsEwCvCKwBBhtXXAAsGwysAAMQrAEGW1dcAC3DFKwAAAAAAAMYrAADHKwAAAADJKwAAyysAAM4rAAAAAN8rAAAAAAAAHSwfLAAAAAAgLCEsJiwAAAAAAAArLAAAAAAAAAAALSwuLAAALywAAAAAAAAxLAAAMiwAAAAAAAAAAEYsAABKLAAAAAAAAEssAEGQ1tcACyhMLAAATSxOLAAAUCwAAFEsAAAAAAAAVCxVLAAAAABWLAAAAAAAAFssAEHE1tcAC1xcLAAAXSxqLAAAAABrLAAAbixwLAAAAAAAAHEsAAAAAHIsdywAAHoshywAAIgsjiwAAAAAAACQLAAAAACRLJQsAAAAAAAAAACZLAAAAAAAAJosAACdLAAAoiylLABBqtfXAAsKpiwAAK0sAACuLABBvtfXAAsEsCy9LABBztfXAAtQviwAAAAAAAAAAL8sAAAAAMAsxCzFLMcsAADNLAAA0SwAAAAAAAAAANIsAAAAAAAA0ywAANQs1SzYLAAAAAAAAAAA2SwAAAAA3CwAAAAA3ywAQbLY1wALFuksAAAAAO4sAAD1LAAAAAD2LPcs+SwAQdzY1wALEvssAAAAAAAAAAD8LAAAAC0BLQBBhNnXAAsOCS0KLQstDi0AAAAAFy0AQZzZ1wALBhstAAAcLQBBrNnXAAsSIC0kLQAAJS0AAAAAJy0AACgtAEHK2dcAC0gpLQAAAAArLSwtAAAtLQAAAAAAAAAALy0AAAAAAAAxLQAANi0AADctAAAAAAAAOS0AADotAAAAAAAAPC09LQAAAAAAAD4tQC0AQaDa1wALDEMtAABELUctAABLLQBBvNrXAAsaTC0AAE0tAAAAAAAAAABOLVEtAAAAAAAAUi0AQfra1wALSlMtVC0AAFYtAAAAAFgtAAAAAAAAAABaLQAAAABbLQAAAAAAAAAAXS0AAGYtAAAAAAAAZy0AAAAAAAAAAGktAAAAAGotay1sLW4tAEHQ29cACxJ3LQAAAAB+LQAAgC2BLQAAgi0AQfTb1wALKIMtAAAAAIQthS2ILQAAAACdLZ8tAAAAAAAAAACgLQAAAAChLQAApS0AQazc1wALDqgtAAAAAAAAxC0AAMctAEHE3NcACwrJLQAAAADMLd8tAEHe3NcACwbhLeQt5i0AQe7c1wALEOctAAAAAAAA6C3qLQAA6y0AQYzd1wALAu8tAEGa3dcACwrwLQAAAAAAAPEtAEGw3dcACxj2LfctAAD8Lf0tAAD+LQAAAAD/LQAAAS4AQe7d1wALBAIuBC4AQYDe1wALagcuAAAILgAAAAAAAAkuAAAAAAAACi4AAAAAAAAAAAwuAAAAAA0uDy4QLgAAAAAAAAAAEy46LjsuPC4AAAAAPS4AAAAAAAA+LgAAAABGLksuAABMLgAAXS4AAAAAAABfLgAAAAAAAGAuYi4AQfbe1wALCGMuAABkLmUuAEGS39cACwJrLgBBot/XAAtAbC4AAG0uAABuLgAAAABvLgAAdi53LnkuhS6GLgAAiC6OLgAAAACQLgAAki6ULpcumC4AAAAAAAAAAJkuAACeLgBB7N/XAAsspS6nLqguAACpLgAAAAAAAAAArC6tLgAAAAAAAAAAsS4AALIuAACzLgAAtC4AQaLg1wALCLUuAAAAALcuAEG64NcACwK5LgBBxuDXAAsUyi4AAAAAAADLLswu0i7TLgAA2C4AQeTg1wALFNkuAAAAAAAA2i4AAN8u5C7lLuYuAEGC4dcACzzrLgAAAADsLu4uAAAAAO8uAAAAAPMu/C4AAAAA/S4AAAAAAC8BLwAAAAAAAAAAAi8AAAkvCy8AAAAADC8AQczh1wALAg4vAEHc4dcACxIWLxcvAAAYLwAAAAAAABwvIC8AQfjh1wALBiEvIy8kLwBBjuLXAAs6Ki8AAAAAAAArLywvAAAAAAAALy8AADEvNi83LwAAAAA4LwAAAAAAAAAAOS8AADwvAAAAAAAAAABBLwBB2OLXAAsCQi8AQfTi1wALLkYvRy9IL08vAAAAAFIvVC8AAAAAAABWLwAAAAAAAFcvWC9gLwAAAAAAAAAAYi8AQa7j1wALLGMvAAAAAAAAZC9mLwAAAAAAAAAAaS8AAGsvAABtLwAAAABuLwAAAAAAAHAvAEHk49cACypxLwAAdC8AAHkvAAAAAAAAAAB6L4svjS8AAAAAAACPLwAAAAAAAAAAki8AQZzk1wALApcvAEGu5NcACwqYLwAAAAAAAJovAEHC5NcAC0CbL5wvAAAAAJ0vAACkLwAApS8AAAAApi8AAKkvAAAAAAAAAACrLwAAsS8AAAAAAAAAALIvsy+0L7UvAAC5L7ovAEGU5dcACwK+LwBBpOXXAAtGvy8AAAAAxS8AAAAAAAAAAMkvAAAAAAAAAADKLwAAAADML9IvAAAAAAAA0y8AAAAAAADUL90vAADeL+AvAADhLwAAAADzLwBB9OXXAAsC9S8AQYDm1wALNPYvAAABMAAAAAACMAAABDAFMAAAAAAGMAAABzAAAAAACDAAAAkwAAAKMAAAAAAAAAAADTAAQc7m1wALEhUwAAAyMDQwAAAAAAAAAAA1MABB8ObXAAsINjA3MAAAODAAQYrn1wALAjkwAEGc59cACww6MAAAAAAAAAAAPDAAQcDn1wALAj4wAEHg59cACxQ/MAAAQzBEMEUwAAAAAE8wUjBTMABB/ufXAAsEVDBYMABBkujXAAsyWzAAAF4wAABfMAAAAABgMAAAAAAAAAAAaTAAAAAAajAAAAAAAAAAAG4wczAAAAAAdDAAQd7o1wALIHowAAAAAAAAezAAAAAAAAB8MAAAAAAAAAAAhDAAAIUwAEGI6dcACxKHMAAAiTCNMAAAAAAAAI8wkDAAQbLp1wALApIwAEG+6dcACwSTMJQwAEHS6dcACwKVMABB3unXAAsCljAAQfDp1wALDJ0wAAAAAAAAojCjMABBjOrXAAtQpDC7MAAAAADNMM4wAAAAAAAAzzAAAAAAAAAAANAw1jDdMAAAAAAAAAAA3jAAAOAw4TAAAAAAAAAAAOIwAAAAAAAA4zAAAOgwAAAAAAAA7DAAQfzq1wALEu8wAAAAAAAA8DAAAAAAAADxMABBmOvXAAsQ8jAAAPcwAAAAAPgwAAD6MABBwOvXAAsG/DAAAAQxAEHQ69cACxQGMQAAAAAAAAcxCDEAAAAAAAAKMQBB9OvXAAsQCzEAAAAAEjEAABUxAAAWMQBBnOzXAAsMGTEAAAAAAAAbMR4xAEG27NcACwIhMQBBxuzXAAsyIjEjMTsxAABAMQAAAABDMQAARDEAAEcxAABRMQAAAAAAAAAAUzFmMQAAaDEAAAAAcTEAQZTt1wALDn4xAAAAAH8xAACBMYUxAEG47dcAC0KHMQAAiTEAAIoxlTEAAJYxAACZMQAAnTEAAAAAAACfMaAxAAAAAAAAAACjMcExAAAAAMMxAAAAAMQxAAAAAMYxxzEAQYzu1wALJMkxAADKMcsxAADMMQAAAADXMd8xAAAAAAAAAADlMQAA5jHqMQBBvu7XAAsC6zEAQcru1wALHuwx+TEAABgyAAAZMgAAJDIAAAAAAAAAACcyAAAqMgBBgO/XAAtQKzItMgAALjIAAAAAAAAAAC8yAAAAADIyNDI1MgAAAAAAADYyAAAAAAAANzIAADgyAAA6MgAAAAA7MgAAPjIAAD8yAAAAAEIyAABFMkgySTIAQeLv1wALDEsyAABNMgAAAABOMgBBgPDXAAsgVDJVMlgyAABZMgAAAAAAAAAAXTIAAAAAAABfMmAyYjIAQa7w1wALLGYyAABtMm4yAAB+MgAAgDIAAAAAAACBMgAAgjIAAAAAAAAAAIMyAACEMoUyAEH68NcACxCGMgAAjjIAAAAAAAAAAJAyAEGa8dcACzaSMgAAAACUMgAAAACVMgAAAAAAAAAAljIAAAAAAAAAAJcyAACYMgAAmTIAAAAAAACaMp4ynzIAQdrx1wALBKAypDIAQejx1wALAqYyAEH68dcACwaqMgAAqzIAQYzy1wALRqwyAAAAALYyAAAAAAAAuDK5MgAAujLEMsUyyTLKMgAAAAAAAAAAzDIAAAAAzTIAAAAAzzLRMgAA2TIAAAAAAADcMgAA3TIAQeby1wALAt4yAEH48tcACwTgMuMyAEGG89cACwjkMgAAAADlMgBBnPPXAAsG6DIAAO0yAEGu89cACx7wMgAAAADxMgAAAAAAAPMy9DL2MgAAAAAAAAAA9zIAQdrz1wALEPky/jIAAAAzAAAAAAQzBTMAQfTz1wALDAszAAAAAAwzAAAPMwBBivTXAAsEFTMWMwBBmPTXAAsSFzMYMxkzAAAaMwAAAAAAAB0zAEG49NcACwgeMwAAHzMgMwBByvTXAAsmJjMAACszAAAsMwAAAAAAAC0zAABFM0YzSDNJMwAAAABKMwAASzMAQfz01wALAk4zAEGU9dcACwZeMwAAcDMAQaz11wALGnEzAAAAAHIzAAAAAAAAAAB2MwAAAAAAAHgzAEHQ9dcACyx5MwAAejN/M4MzAAAAAAAAhTMAAAAAhjMAAAAAhzMAAAAAljMAAAAAAACXMwBBkPbXAAsYnDMAAAAAozOwMwAAAAAAALkzAADBM8UzAEGy9tcAC17HM8szAADMM80zAADOMwAA2DMAAAAAAAAAANwzAAAAAAAAAADdM/MzAAAAAPUz9jMAAAAA9zMAAAAA+TMAAP4zAAAAAAAA/zMAAAAAAAAAAA00AAAQNAAAAAAAABE0AEGc99cACxISNAAAAAATNAAAFzQAAAAAHjQAQbj31wALOh80AAAqNAAAMjQAADY0NzQ5NAAAAAA7NDw0AAA9ND40AABANAAARDRFNEo0AABLNEw0AABNNE80UzQAQfz31wALElk0YTQAAGI0AAAAAAAAAABsNABBmPjXAAsWbjQAAAAAAAAAAG80AAAAAAAAAABxNABBuPjXAAsgczQAAAAAAAB0NAAAAAB2NH40AAB/NAAAhTQAAIg0iTQAQeT41wALXos0AACRNAAAAAAAAAAAkjSTNAAAlDQAAAAAAAAAAJg0mTSaNJ40AACfNKA0ojSjNAAApDQAAAAApjSnNAAAqTQAAAAAAAAAAK80AACyNAAAtTQAAAAAtjQAAAAAtzQAQd751wALNLg0uTQAALw0AAAAAMw00jQAAAAA1TTYNAAAAAAAANo03zQAAOE04zQAAOQ0AADnNAAA6DQAQZ761wALAuk0AEGs+tcACxbrNAAAAAAAAO008zQAAAAAAAD0NPU0AEHQ+tcACxD2NAAA+zQAAAAAAAAAAPw0AEHw+tcACwL+NABB/vrXAAsSATUAAAAAAzUAAAAAAAAAAAU1AEGc+9cACwIKNQBBsvvXAAsODTUAABI1AAAbNQAAIDUAQdD71wALFiE1IzUAACQ1JTUmNSc1AAAAADE1MjUAQfT71wALCDc1AAA5NTs1AEGM/NcACxI9NQAAAAAAAEI1AAAAAAAARjUAQa781wALAlY1AEHE/NcACx5YNQAAWzUAAAAAXDUAAAAAXjUAAAAAAABfNQAAYDUAQez81wALDmQ1AABlNWc1AAAAAGg1AEGG/dcACyRrNXU1AAB2NQAAAAAAAHc1AAAAAAAAfDV+NYE1AAAAAAAAhjUAQbT91wALFIk1AAAAAAAAAACLNQAAAAAAAJI1AEHa/dcACxSTNQAAlDWVNQAAAACXNZw1ojWjNQBB/v3XAAsCpDUAQY7+1wALRqY1AACoNQAAAACpNao1szUAALc1AAAAALg1AAAAAAAAuTUAAL01AAAAAMI1wzUAAMQ1xTUAAMY1AAAAAMc1AAAAAAAAyDUAQeL+1wALDMk1AAAAAMw1AADPNQBBkv/XAAso0DXSNds1AAAAAAAA5TUAAOY1AADpNQAA7DXuNQAAAAAAAAAA+DX5NQBB1P/XAAsgCjYAAAw2AAAAAA42AAAAAA82AAAQNgAAAAAAAAAAEjYAQYCA2AALAhM2AEGUgNgACwIVNgBBoIDYAAsgIjYAAAAAJDYAAAAAJTYAAAAAJjYnNgAALDYAAC02LjYAQdSA2AALDjA2AAAAAAAAAAAxNjY2AEH2gNgACzo+NgAAQDZBNkI2AAAAAEM2RjYAAEk2SzZMNlA2AAAAAFI2AAAAAAAAVTYAAAAAAABWNgAAAAAAAFc2AEG6gdgACyZYNl02AAAAAAAAAABeNgAAXzYAAAAAYDYAAAAAAABhNgAAAABiNgBB7oHYAAsGZDYAAGc2AEH+gdgACzZsNgAAbTYAAG42AAAAAG82AAB4NgAAAAAAAII2AAAAAIM2AAAAAAAAAACENgAAhTYAAI82kTYAQcyC2AALLpI2pjYAAKc2qjYAAKs2AAAAAAAAAACsNgAAAACvNgAAAAAAAMI2AADDNgAAxTYAQYaD2AALAtk2AEGYg9gACxbbNgAAAAAAAAAA3jYAAAAAAADgNuE2AEHCg9gACxrjNgAAAADkNug2AADvNgAA8DbyNgAAAADzNgBB7oPYAAso9DYAAAAAAAD4NgAA+jb7NgAA/Db/NgU3BjcHNw03AAAAAAAAAAAPNwBBooTYAAsEEDcRNwBBtITYAAsGEjcAABY3AEHEhNgACyAXNwAAAAAAABg3AAAAABk3AAAAAAAAGzccNwAAAAAdNwBB9ITYAAtkJTcAAAAAAAAAACY3AAAAAAAAAAAnNwAAAAAoNwAAAAApNwAAKjcvNwAAMDc4NwAAAAA6NwAAPDcAAAAAAAA9Nz43AAAAAAAAAABCNwAAAABFNwAARzcAAAAAAABINwAAAABJNwBB6oXYAAscSjcAAEw3TTcAAAAATzcAAFE3AAAAAAAAAABSNwBBkobYAAsIUzcAAAAAXTcAQaaG2AALKl43AAAAAGA3AAAAAGI3AAAAAGM3ZTcAAAAAZjdpN2s3AABuNwAAAAB1NwBB6IbYAAsCdjcAQfaG2AALEnc3eDcAAAAAAAB8NwAAAACANwBBnofYAAsClzcAQbKH2AALqgGaNwAAAACbNwAAAAAAAKA3oTcAAAAAAACmNwAAAAAAAKc3AACqNwAAAACrNwAAAACuNwAAAACwNwAAAAAAALQ3AAC1NwAAAAAAAAAAtje7N703AAAAAMU3AAAAAMY3AADHN8o3AAAAAAAAyzcAAAAAAADMN803AAAAAAAAAADONwAAAAAAANA3AAAAAAAA0TcAANI3AADVN9033jfgN+E3AADjNwAA5DflNwBB8ojYAAsK5zfoNwAAAADtNwBBionYAAsY7jcAAAAAAAAAAPA3AAAAAAAAAADxN/I3AEGsidgACwT2N/k3AEHMidgACzj6N/s3AAAAAAAAAAD8NwAAAAAAAP03AAAAAAE4BDgAAAU4AAAAAAY4AAAJOAo4AAAAAAs4AAAaOABBjorYAAsYHDgdOCM4AAAlOAAAAAAmOAAAKzgAAEA4AEGwitgACyBBOAAAAABFOAAARjgAAEg4STgAAAAAAABROAAAAABYOABB4orYAAsUXjgAAAAAAABfOAAAAABjOAAAaDgAQYKL2AALCGo4AAAAAGs4AEGUi9gACwJuOABBpIvYAAsQdjgAAHk4AAB8OAAAAACCOABBvovYAAsCgzgAQcyL2AALBoU4AACNOABB3ovYAAs2jjiSOAAAAAAAAJM4AAAAAAAAlTiWOAAAAAAAAJc4mDiZOJw4nTieOJ84oDihOAAAozgAAKU4AEGojNgACwymOAAAqziwOLE4sjgAQcqM2AALQrM4vjjCOAAAyTgAANA4AADTOAAAAADUONY41zgAAAAA2DgAAAAAAADZOAAA2jgAAAAAAAAAANw45DgAAAAA5TjmOABBmI3YAAss6DgAAAAA6TgAAAAAAADrOPA4AAAAAPE48jjzOAAAAAD0OAAAAAAAAAAA9jgAQdyN2AALAvc4AEHojdgACwz7OAAA/DgAAAAACDkAQZyO2AALGgk5AAAAAAw5DTkTOQAAFTkAAAAAAAAAABc5AEHCjtgACyAjOQAAJDkAAAAAAAAAACc5AAApOSo5AAAAAAAAAAArOQBB8o7YAAtCLDkAAAAALzkyOQAAAAAAAAAANDkAAAAAAAAAADU5NjkAAD05AAAAAD45AABCOQAARTkAAAAAAABJOQAAAAAAAEw5AEHGj9gACxZNOQAAAABOOQAAAAAAAFg5AAAAAFk5AEHmj9gACyhaOVs5AAAAAAAAAABeOQAAAAAAAAAAXzlpOQAAAAAAAAAAazlxOXc5AEGikNgACzB4OQAAAAAAAHk5AAAAAAAAAAB/OQAAgDmBOYY5AAAAAAAAiDmJOQAAAAAAAAAAizkAQeCQ2AALJo05kDmROQAAAACUOZY5AAAAAAAAmDmhOQAAAAAAAAAAozmmOag5AEGQkdgACzypOao5rTmzOQAAtDkAALU5tjkAAAAAtzkAAAAAuDkAAAAAAAAAALk5AAC7OQAAAAC+OQAAAADBOcI5xDkAQdaR2AALAss5AEHkkdgACxLOOQAA0znUOdY5AAAAAAAA2TkAQYKS2AALENo5AAAAAAAAAADbOQAA3DkAQZyS2AALAt85AEGuktgACwbgOQAA4jkAQcCS2AALGuM5AADkOQAA5zkAAAAAAADoOQAAAADqOes5AEHyktgACwLuOQBB/pLYAAsG8TkAAP05AEGOk9gACxr+OQAAAAD/ORc6AAAZOgAAHDoAAB06HjogOgBBspPYAAsaIToAACI6LjoAAAAAAAAAAC86AAA7OgAAPDoAQdqT2AALJD86AAAAAAAAAABIOgAAAABTOgAAVDpWOlc6AAAAAFg6AABhOgBBjJTYAAs8YzoAAAAAZDplOmc6AAAAAGg6AAAAAAAAdDp9OgAAAACOOgAAAAAAAAAAkzoAAAAAljqZOgAAAACaOqw6AEHUlNgACyqtOgAArjoAAAAAAAAAAK86AAAAALE6tTq5OgAAAAAAALo6AAAAAAAAuzoAQYiV2AALMsM6xDoAAAAAAADFOsY6yDrKOgAA2ToAAAAAAAAAANo6AAAAAOM66jrsOgAAAADtOu46AEHKldgACybwOgAAAAAAAPE6AAAAAAAAAAD2OgAA+DoAAPk6AAD8OgAAAAD+OgBBgJbYAAsaATsAAAAAAjsAAAU7CTsAAAAAAAALOwAADjsAQaaW2AALCA87AAAAABA7AEG4ltgACyQTOxk7AAAAAAAAGjsAABs7AAAAAB47AAAfOwAAAAAAACE7IjsAQeiW2AALAiM7AEH0ltgACxQkOwAAAAAyOzo7AABBO0I7AABHOwBBppfYAAsISTsAAEo7SzsAQbiX2AALAk87AEHSl9gACwxRO1M7AABaO1s7XDsAQeyX2AALDGQ7AAAAAAAAAABmOwBBgpjYAAsCZzsAQZaY2AALBm07AABuOwBBqpjYAAsigDsAAAAAAAAAAII7AACGO4g7AACQOwAAAAAAAAAAkjuTOwBB2pjYAAsslDsAAAAAAACXO547ojsAAAAAAACjOwAAAAAAAK07rzsAAAAAAACwO7E7sjsAQZCZ2AALErU7AAAAAAAAAAC5OwAAAAC7OwBBsJnYAAsUwDvBOwAAAADIOwAAAAAAAAAAyjsAQdCZ2AALFss7zDsAAM07AAAAAM87AAAAANA70TsAQf6Z2AALGNI71TsAAAAAAADWO9c7AAAAAAAAAADYOwBBtprYAAsC2TsAQcKa2AALTtw7AADdO947AADiOwAAAAAAAAAA5jsAAOc7AADtOwAAAADuOwAAAADvO/A7AAAAAAAAAADxOwAAAAAAAAAA8zsAAAAA9Dv1O/Y7AAD8OwBBsJvYAAsG/TsAAP47AEHEm9gACwr/OwA8BDwAABQ8AEHYm9gACwwgPAAAAAAhPAAAIzwAQfSb2AALCiQ8AAAAACU8JjwAQZCc2AALKic8AAAoPAAAAAAAACo8AAAtPDI8AAAAAAAAAAAzPAAAAAAAADQ8AAA4PABByJzYAAsqRDwAAEs8AAAAAE48AAAAAAAAAABPPAAAAAAAAFA8AAAAAAAAUTxZPFs8AEGAndgACxxcPAAAAABfPAAAAAAAAGA8AAAAAGI8AABkPGU8AEGmndgACxRmPGg8AABpPAAAAABqPAAAAABrPABBxJ3YAAsgbDwAAAAAAAAAAHk8AAAAAHw8AAB9PH48AAAAAAAAfzwAQe6d2AALbIA8AACEPIo8AAAAAAAAizwAAAAAAACMPAAAjTwAAAAAmDwAAKI8AAAAAAAApDwAAKU8pjwAAAAApzwAAAAAuTy6PAAAvDzAPAAAwTwAAAAAAADCPAAAwzwAAMU8zTzVPNk82jwAAN48AADfPABB9J7YAAsC4jwAQZKf2AALAuQ8AEGen9gACwLlPABBrp/YAAsO6TzqPAAAAAAAAAAA6zwAQcif2AALJuw8AAAAAAAA7TwAAAAAAAAAAPA8AAAAAPE8AAAAAAAAAADyPPM8AEH6n9gACy70PAAA+TwAAAAA/DwAAAAA/TwAAAAA/zwBPQI9AAAAAAQ9AAAUPRU9AAAAACE9AEG2oNgACygiPQAAAAAjPQAAAAAAACg9AAAqPQAAAAAAADA9AAAAADE9AAAAADQ9AEHooNgACxg1PQAAAAA6PQAAAAA7PQAAAAAAAAAAPD0AQZah2AALDD09AAAAAAAAAAA+PQBBrKHYAAsuPz0AAAAAQT0AAEY9AAAAAAAAAABHPQAASD0AAAAASj0AAAAAAABRPQAAUz1UPQBB7KHYAAsoVT0AAFY9Vz0AAFg9AABZPQAAWz0AAF09AABgPWQ9AABlPQAAZj1oPQBBnqLYAAsmbD0AAAAAAABtPQAAbj0AAAAAAAB8PQAAgT2CPQAAAACDPQAAhD0AQc6i2AALDoU9AAAAAAAAiD0AAIk9AEHootgACwqPPQAAAAAAAJU9AEGEo9gACzCXPQAAAAAAAJs9AAAAAKg9AAAAAAAAAACpPa49rz0AAAAAsD0AAAAAAAC/PQAAwz0AQcyj2AALFMo9AAAAAAAAyz0AAAAAAAAAAM09AEHqo9gACybOPdA9AAAAANM9AAAAANU91z0AANg9AAAAANk9AADbPd493z3jPQBBpqTYAAsQ5D0AAAAAAAAAAOU96z3wPQBBxKTYAAsa8j30PQAA9T0AAAAAAAD4PQAAAAAAAAAA+T0AQeqk2AALIvo9AAAAPgAAAAAEPgAAAAAAAAAABT4GPgs+DT4AAAAAED4AQZal2AALBBE+Ej4AQaql2AALAhQ+AEG6pdgACzIVPgAAAAAWPgAAAAAAABc+AAAYPhk+AAAaPh0+Hj4AACc+Kz4AACw+AAA0Pj8+AABBPgBB9qXYAAsCTj4AQYam2AALKlY+AAAAAAAAWT4AAAAAXj4AAF8+AAAAAGk+AAAAAGo+AAAAAG0+bj5vPgBBvqbYAAskcj4AAAAAAAB2PgAAdz57Pn4+AAB/PgAAgD4AAAAAAAAAAIg+AEGIp9gACwiJPos+AACNPgBBoKfYAAsgjj4AAAAAjz6XPpg+mT4AAAAAmj4AAJ4+AACgPgAAoT4AQcyn2AALBqM+pD6lPgBB3KfYAAsMpz4AAAAAAAAAAKk+AEHyp9gACxyrPqw+AAAAAK8+AAAAAAAAsD4AAAAAsT6yPrQ+AEGYqNgACwK3PgBBqqjYAAsCuD4AQbqo2AALQLo+vD69PgAAAAC/PgAAAADAPgAAAAAAAMM+xD4AAAAAxT7OPgAAAAAAAM8+AAAAAAAA0D4AANE+AAAAAAAA2D4AQZCp2AALHtk+3T4AAOE+AADnPgAA6D7pPgAAAACAPwAAAACDPwBBvKnYAAsUhD+FPwAAAACGPwAAAACHPwAAjD8AQd6p2AALNI0/AAAAAI4/kT8AAJI/AAAAAAAAAACTP5Q/lT+YPwAAAAAAAJk/nD8AAAAAAACePwAAoT8AQaSq2AALDKI/AAAAAAAAAACjPwBBvqrYAAsCpD8AQdCq2AALFqU/pz+pPwAArj8AALA/AACxPwAAsj8AQf6q2AALBrM/tD+4PwBBkKvYAAsQuT+7PwAAvj8AAAAAAADBPwBBrqvYAAsSxj/NP9A/AAAAAAAAAADRP9Q/AEHKq9gACwjZPwAAAADaPwBB5KvYAAtS2z8AAAAA3D8AAAAAAAAAAN0/AAAAAAAA3j8AAOU/AAAAAAAAAADnP+g/AAAAAAAAAADqP+s/7D/tPwAAAADuPwAAAAAAAAAA7z/wPwAA8T/2PwBBxKzYAAsc+D8AAAAAAAAAAPo/+z8AAPw/AAAAAAAA/T//PwBB6qzYAAswBkAAAAAAAAAPQAAAEkAUQBZAF0AAAAAAAAAZQBtAAAAAAAAAAAAcQAAAHUAfQCdAAEGkrdgACx4oQAAAAAAAACxAMkAzQEFAAABCQENAAAAAAAAARUAAQeCt2AALKkZAAAAAAEhASkAAAAAAS0AAAAAATEAAAAAAAAAAAE5AAABPQAAAAABSQABBlK7YAAsOX0AAAAAAYEAAAGFAZEAAQbau2AALAmVAAEHErtgACwJpQABB0K7YAAsSa0AAAAAAckAAAAAAd0AAAHlAAEHyrtgACwx6QAAAAAAAAHxAfUAAQY6v2AALHn9AgUAAAAAAAACEQAAAhUAAAIdAAACRQAAAAACTQABBuK/YAAsKlkAAAAAAnUCeQABB1K/YAAtWn0CjQKRAAAAAAAAAp0AAAKhAAAAAAAAAqUAAAAAArkAAAAAAskC1QAAAAAAAALpAAAAAAAAAvUDJQAAAAAAAAMpAy0DTQAAA1EAAANZAAAAAAAAA2EAAQcSw2AALDNlAAAAAAAAAAADbQABB3rDYAAsg3EDkQAAAAAAAAAAA5UAAAOpAAAAAAAAAAEEAAAAAAUEAQYqx2AALDAVBAAAAAAAAAAAGQQBBorHYAAs0C0EAAAAAAAAAAA1BDkEAAAAAAAAPQQAAAAAQQRtBAAAAAAAAAAAfQQAAIEEAAAAAAAAhQQBB4LHYAAssJEEAAC5BAAAAAAAAAAAxQQAAMkEAADRBAAA1QQAANkEAADhBAAAAAAAAQUEAQZiy2AALLENBAAAAAAAARUEAAAAAAAAAAEdBAABIQUlBAAAAAAAAS0EAAAAAAAAAAExBAEHWstgACwxOQVRBAAAAAFZBV0EAQfCy2AALDFhBAABZQQAAAABaQQBBhrPYAAsWW0EAAAAAAABcQQAAAAAAAAAAXkFiQQBBrLPYAAsIZ0EAAAAAaUEAQb6z2AALGm1BAABwQQAAAAAAAAAAdEEAAAAAdkEAAHdBAEHis9gACwJ4QQBB8rPYAAsYekEAAIFBAACCQQAAhEEAAAAAAACJQYxBAEGWtNgACziNQQAAAACOQQAAkEEAAAAAkUGTQZhBAAAAAJpBAAAAAAAAnkEAAAAAqUEAAAAArkGwQbFBAACzQQBB4rTYAAsitEEAAAAAxEHHQQAAAADJQdNB2UEAAAAA2kHbQQAAAADcQQBBlLXYAAsG3kEAAN9BAEGotdgACwLgQQBBuLXYAAsc7EEAAPFB8kEAAPVB9kEAAPdBAAAAAAAA+UH7QQBB3rXYAAsE/kH/QQBB+LXYAAsGAUIAAAJCAEGIttgAC5ABEUIAAAAAHEIdQh5CAAAAAB9CAAAAAAAAKUIqQgAAAAAAACxCLUIAAAAAAAAuQjFCAAAyQjVCNkIAAAAAAAA4QjtCAAAAAAAARUIAAElCAAAAAE9CAAAAAFBCAAAAAAAAAABSQgAAAABVQgAAV0JdQgAAAAAAAAAAXkIAAAAAX0IAAAAAAABhQgAAYkJkQmhCAEGit9gACxxqQmxCAABuQgAAAABvQgAAAAAAAAAAcEJ1QnZCAEHQt9gACwZ9QgAAh0IAQeC32AALOIlCjEIAAI5CAAAAAI9CAACVQgAAAACWQpdCAAAAAAAAAACYQgAAmUKaQgAAm0KdQgAAnkIAAJ9CAEGiuNgACwinQgAAAACoQgBBuLjYAAsIqUIAAAAArEIAQcq42AALArBCAEHYuNgACwKxQgBB/rjYAAsGskIAALhCAEGuudgACxi5QrtCvEIAAAAAAAC9QgAAAAAAAAAAxEIAQdi52AALCMVCAADHQs5CAEHsudgACxbPQgAAAADRQgAA00IAAAAAAAAAANpCAEGMutgACxrbQuVC50IAAAAA6EIAAAAAAADpQupCAADrQgBBsLrYAAsG7ELvQvlCAEHGutgACwr6QgAA+0IAAPxCAEHcutgACzD9Qv5CAAD/QgFDAAADQwAAAAAAAAAAC0MTQwAAFkMAAAAAAAAAABtDAAAAAB5DIUMAQZa72AALCCJDAAAAACRDAEGsu9gACwglQydDAAAqQwBBxrvYAAsQK0MsQzNDNEMAAAAANUNBQwBB4LvYAAsaQkMAAAAAAAAAAENDAABEQwAARUMAAAAATkMAQYS82AALXFRDAABWQ1dDAAAAAAAAWUNcQwAAAABdQwAAYEMAAAAAY0MAAGRDAAAAAHBDAAByQwAAAAAAAHRDAAAAAAAAAAB3Q3hDAAB5QwAAj0MAAJZDAACZQwAAAAAAAJpDAEHuvNgACwKcQwBBkL3YAAsinUMAAJ5DoUMAAAAAAAAAAKJDo0MAAKVDAAAAAAAAAACmQwBBwL3YAAsCqEMAQc692AALHrZDAADAQ8RDAAAAAAAAxkPHQwAAAADJQwAAAADKQwBB/r3YAAsCy0MAQYy+2AALKMxDzUMAAAAAz0MAAAAAAADbQwAA3EMAAAAAAADxQwAAAAAAAAAA8kMAQb6+2AALGvNDAAAAAPdDAAAAAAAA+UMJRAAACkQAAAtEAEHivtgACwQORA9EAEHwvtgACwIQRABB/L7YAAsgFEQVRBlEAAAAAAAAHUQAAAAAIUQAAAAAIkQAAAAALUQAQay/2AALJi5EMEQ2RAAAAAA6RAAAAAA8RAAAAAA9RAAAAAAAAAAAPkQAAENEAEHcv9gACz5HRAAAAAAAAEtETEQAAE1EAABORAAAU0RURAAAAABVRAAAVkRXRAAAAAAAAFhEAAAAAAAAWUQAAAAAAABeRABBpMDYAAsyX0QAAGFEAABjRAAAAAAAAGhEaURqRAAAAABrRAAAAAAAAG9EAAAAAAAAckQAAAAAc0QAQejA2AALLHdEAAAAAAAAeEQAAAAAAAB+RAAAAAAAAAAAgEQAAAAAAACDRAAAhESHRI1EAEG0wdgACxqURAAAAACWRAAAl0QAAAAAmEQAAAAAAACbRABB2sHYAAsOnEQAAAAAnUSeRAAAn0QAQfTB2AALCKFEokQAAKdEAEGSwtgACxatRAAAAAAAAK5Er0QAALJEAAAAALNEAEG2wtgACxa0RAAAAAAAAAAAvES9RAAAAAC+RMBEAEHYwtgACxbBRAAAAAAAAMREAAAAAMVEAAAAAMdEAEGUw9gACy7MRAAAAADSRAAA1UTWRAAAAAAAAAAA10QAAAAA2EQAAAAA3kQAAAAA30ThROJEAEHQw9gACxbjRAAAAADkRAAAAADlRAAA5kQAAOhEAEH6w9gACwLpRABBkMTYAAsM60QAAAAAAAAAAO1EAEGsxNgACwTuRP5EAEHCxNgACxr/RABFAAABRQJFAAAAAAAABUUHRQlFAAAPRQBB6sTYAAuKARRFAAAAAAAAFkUAADJFAAAAADhFOkU+RQAAAABARQAAAABBRQAAAAAAAERFAABFRQAARkUAAAAAAABHRQAAAAAAAAAASUUAAAAAAAAAAEtFAAAAAAAATUVORQAAAAAAAAAAT0VQRVFFAAAAAAAAVUUAAFZFV0VYRVpFYUViRQAAY0UAAGZFAABsRQBB/sXYAAsCb0UAQY7G2AALFnBFAAAAAHFFAAAAAHJFc0UAAHZFd0UAQbjG2AALAnhFAEHIxtgACxSdRQAAAAAAAJ5FAAAAAAAAn0WhRQBB5sbYAAssokWnRahFqUUAAAAAtUUAAAAAAAC2RQAAAAAAALhFukW+RQAAv0UAAAAAw0UAQZ7H2AALBMRFxUUAQcjH2AALBM5Fz0UAQdjH2AALRtBFAAAAAAAA10UAAAAAAADZRdtFAADcRQAA3UUAAAAA3kUAAAAA30XjRSFGAAAAAAAAAAAiRgAAAAAjRgAAMEYAAAAANEYAQajI2AALHjZGAAAAAAAAAAA4RjpGAAAAAD9GAAAAAAAAAABTRgBB0MjYAAsCV0YAQdzI2AALAllGAEHsyNgACwJaRgBB+sjYAAskXEYAAAAAXkYAAAAAAABfRgAAAAAAAGBGAABhRgAAAAAAAG5GAEGsydgACx5vRgAAAAB0RnVGdkYAAAAAgUaIRgAAiUaKRgAAi0YAQdrJ2AALDI5GAAAAAAAAAACQRgBB9snYAAsak0YAAAAAAACURgAAAACbRgAAAACeRq1GrkYAQaDK2AALArFGAEGsytgACzqyRrRGAAAAAAAAvEYAAL9GAAAAAMBGAADBRgAAAADDRsRGAADGRgAAAAAAAAAAyUYAAAAAAAAAAMtGAEH4ytgACxrMRgAAAAAAAAAAzUbORgAAz0YAAAAA0EbXRgBBpMvYAAsC5kYAQbDL2AALEudG6EYAAAAA7Eb0RgAA9kb7RgBB1MvYAAsW/EYHRwAACEcAAAAAAAAAAAlHAAALRwBB9MvYAAsCDEcAQYbM2AALXA1HAAAAAA5HAAAAAA9HEEcAAAAAEkcTRxRHAAAAAAAAFUcAABtHAAAcRwAAAAAAAAAAHUcAAAAAAAAfRyBHAAAAACZHAAAAAAAAJ0coRwAAAAAAACxHAAAAAC5HAEHszNgACyIvRwAAMUc3RwAAOkcAADtHAAAAAAAAAABARwAAAABBR0JHAEGYzdgACxRDR0tHAABNRwAATkcAAAAAAABaRwBBuM3YAAsKXUdeR19HYUdpRwBB2s3YAAsKakcAAGtHAABsRwBB8M3YAAsgbUcAAG9HcUcAAAAAckcAAAAAAAAAAIRHAAAAAAAAhkcAQajO2AALLodHAACIR4lHAACLRwAAAACMR5BHAACbRwAAnEcAAKBHAAAAAAAAAAChRwAApEcAQejO2AALDKVHAACoR6lHAACqRwBB/s7YAAsMrEcAAK9HAAAAALRHAEGWz9gACwK1RwBBos/YAAsev0cAAAAAAADARwAAwUcAAMJHw0cAAAAAAAAFSAxIAEHcz9gACxoNSBJIAAAAAAAAAAATSAAAFEgAAAAAAAAVSABBgNDYAAsYF0gAAAAAAAAYSAAAGUgAABxIAAAAAB1IAEGo0NgACzoiSAAAAAAjSAAAAAAAAAAAKUgAAAAAAAAsSAAALUgAAAAAAAAuSC9IMEgAAAAAAAA1SAAAAAAAADZIAEHu0NgACwQ4SDpIAEH+0NgACwI7SABBitHYAAsIP0gAAAAAQEgAQZ7R2AALFklIAABZSAAAWkhbSAAAAAAAAF1IXkgAQb7R2AALEl9IAAAAAAAAAABkSGVIAABmSABB3NHYAAsIZ0hpSAAAakgAQfDR2AALPGxIbUhuSG9IAABySAAAAAAAAAAAeUh8SAAAAAB+SAAAAACJSItIAAAAAAAAjEgAAI5IAAAAAAAAAACaSABBttLYAAsInEgAAAAAnUgAQcrS2AALTp5IAACgSAAAAAAAAAAAokgAAAAAAACkSAAAAAClSKZIAAAAAKlIAAAAAAAAAACqSAAAAAAAAKtIrEgAAK1IAAAAAAAAAACwSAAAAACzSABBqtPYAAsktEgAALhIAAAAALlIu0gAAAAAAADESAAAAAAAAMVIAAAAAMZIAEHc09gACw7HSAAAyEgAAAAAy0jNSABB9tPYAAtA0UjTSNhIAADcSAAAAADdSAAA30jgSAAAAAAAAOFIAAAAAOpI8kgAAAAAAAAAAPVI/Ej9SAAAAAD+SAAAAAACSQBBxNTYAAsEB0kISQBB3NTYAAsICUkAAAAADEkAQfDU2AALIA5JAAAUSQAAAAAVSQAAFkkAAAAAF0kAABpJAAAAAB5JAEGc1dgACwwfSQAAAAAiSQAAJkkAQcLV2AALAitJAEHO1dgACzYzSTVJAAAAADZJAAA3SThJOkk8SQAAQElBSQAAAABCSUtJAABNSQAAAAAAAE5JAAAAAAAAUUkAQY7W2AALGFVJWklbSV1JAAAAAGBJY0kAAGRJAABpSQBBstbYAAsIa0kAAAAAcEkAQcTW2AALBHFJdEkAQdbW2AALWnZJAAAAAAAAe0l/SYBJAAAAAAAAAACJSQAAAACLSY1JAAAAAI5JAAAAAAAAAACPSQAAAACQSQAAAAAAAAAAkUkAAJhJAACZSQAAmkkAAAAAAAAAAJtJAACcSQBBvNfYAAsEnUmeSQBB5tfYAAsmoEkAAAAAAAClSaxJAAAAAK5JskkAAAAAs0m1SQAAAAC6ScFJy0kAQaDY2AALAsxJAEGy2NgACx7PSQAA0EkAAAAAAADUSQAAAAAAANVJAADWSeNJ5EkAQeDY2AALAudJAEHs2NgACxboSQAAAAAAAOlJ8UkAAAAAAAAAAPJJAEGO2dgAC1L0SQAAAAAAAAAA9kn+SQAAAAAAAAdKDUoAAAAAAAAAAA5KAAAAAAAAAAAPShBKAAAAABFKAAAAABJKAAAAAAAAAAATShRKAAAAAAAAFUoAABdKAEHy2dgACw4YSgAAGUoAABpKHUogSgBBjNrYAAsWIUoAAAAAAAAlSgAAAAAAAC5KAAA2SgBBrNrYAAsSN0o7SgAAAAA9SgAAAAAAAD5KAEHK2tgAC3BASkNKAAAAAEpKAAAAAEtKAABQSgAAV0pYSgAAX0oAAGFKakoAAAAAAABrSm9KcEoAAHNKd0p4SgAAAACQSgAAAAAAAJVKlkoAAAAAAAAAAJdKAACYSgAAAAAAAJlKAAAAAJpKAACbSpxKAAAAAJ9KAEHI29gACwKnSgBB1tvYAAsSqEoAAAAAAACsSq1KAACxSrJKAEGU3NgACwSzSrRKAEGm3NgACwi1SrZKAAC4SgBBwtzYAAsYuUq6SrtKvEoAAAAAykoAAAAAy0rUStZKAEHq3NgACxLuSvFKAAAAAPNKAAAAAAAA+UoAQYbd2AALEPpKAAD9SgAAAAAAAAAA/koAQard2AALAgJLAEHc3dgACzADSwAABUsKSwAAAAAAAA1LAAASSwAAAAAAABdLHUsAAAAAHksAAAAAH0sgSyFLJ0sAQZbe2AALNChLAAAwSzFLAAAAAAAAAAA2SwAAOEs6SztLAAAAAD1LAABCSwAAAAAAAEhLAABOS1FLUksAQeLe2AALEFNLAAAAAFRLAAAAAFVLV0sAQY7f2AALRFhLW0sAAFxLAAAAAAAAAABhSwAAYksAAAAAAAAAAGZLZ0sAAAAAAAAAAGhLaUsAAAAAAAAAAHJLAAAAAHNLAAAAAHlLAEHg39gACxJ6SwAAhUsAAIZLh0sAAIhLiUsAQYjg2AALJpJLAAAAAJlLAACaS6JLAACmS6dLAAAAAKlLAACvSwAAsUu0S7xLAEG44NgACw69S75LAAAAAAAAAADASwBB0ODYAAsCyksAQeLg2AALKNRLAAAAANVL3ksAAOBLAAAAAAAA4UsAAAAAAADkSwAAAAAAAAAA50sAQZTh2AALAuhLAEGg4dgACyz4SwNMAAAAAAVMAAAGTAdMAAALTBJMGkwAAAAAAAAAACZMAAAAAAAAAAAtTABB4OHYAAsELkwwTABB8uHYAAsuMUwAAAAAAAAAADJMM0wAAAAAAAA0TAAAAAA3TAAAAAA6TAAAO0wAADxMAAA+TABBxOLYAAsUSkwAAFFMUkwAAFdMWkwAAFtMX0wAQeTi2AALBGBMYUwAQYDj2AALCGNMAAAAAGRMAEGg49gACwpoTGlMAAAAAGpMAEG249gACyxtTG9MAABwTAAAAAAAAHFMckwAAHpMAAAAAAAAAAB8TAAAAAAAAAAAfUyATABB8OPYAAsSgUyCTAAAAAAAAINMhEwAAIVMAEGO5NgACySITIlMj0wAAJBMAAAAAJRMAAAAAJVMAACWTJhMmkwAAJ1MnkwAQb7k2AALMqBMoUwAAAAAokwAAAAAo0wAAAAAAACkTKVMr0wAAAAAsEyyTLRMAAC7TAAAAAC8TMpMAEGY5dgACwLLTABBsOXYAAsW20zdTAAAAAAAAAAA30wAAONMAADkTABB0uXYAAsC50wAQeTl2AALBuhM6UzsTABB+OXYAAsE70zxTABBhubYAAsU8kzzTAAAAAD0TAAA9kwAAAAA90wAQabm2AALHvhM/EwAAP5MAAABTQAAAAAAAANNAAAAAAAAAAAGTQBB0ubYAAsMCE0AAApNAAAAAA1NAEH45tgACwISTQBBhOfYAAsmE00AABZNF00bTQAAAAAcTQAAHU0AAAAAAAAiTQAAAAAjTQAAO00AQbrn2AALBDxNP00AQcrn2AALAkJNAEHW59gAC1RDTQAAAABETU5NAABPTQAAAABQTQAAAAAAAFFNAAAAAFRNVU0AAAAAAABXTQAAAAAAAFlNAAAAAAAAAABbTQAAXE0AAF1NAAAAAF9NAAAAAAAAYE0AQbbo2AALAmFNAEHa6NgACxZoTQAAbU0AAG5Ndk13TQAAAAAAAHlNAEGE6dgACzB+TQAAAAAAAAAAf00AAAAAg00AAAAAAAAAAIVNAAAAAAAAAACHTQAAAACITQAAiU0AQcLp2AALCotNAAAAAAAAjk0AQd7p2AALCphNAACZTQAAmk0AQfbp2AALKpxNAAAAAJ5NAAAAAJ9NAAAAAKBNoU2jTQAAqE2qTaxNAAAAAK1Nrk2wTQBBuOrYAAtKsk20TbVNAAAAALZNAAAAAAAAt00AALhNvk0AAAAAv00AAAAAwU0AAAAAAADCTQAAxE0AAMVNx00AAAAAAADJTdBNAADiTeNN5E0AQZDr2AALIOZNAADnTQAA6U0AAAAAAADvTfBN8k34TQAA/U0AAANOAEG669gACzAHTgAACE4AABZOAAAAABdOAAAZTgAAG04AAAAAAAAeTh9OIU4AACNOJU4AACtOLE4AQfbr2AALEC5OAAA0TgAAAAAAAAAANU4AQZDs2AALBDdOOE4AQZ7s2AALODlOAAAAADtOAAAAAD1OAAAAAEBOAAAAAAAAAABMTk1OAABQTlFOAAAAAFJOAABUTgAAAABWTllOAEHo7NgACyZbTgAAAABdTgAAXk4AAGBOAAAAAGJOAAAAAGNOAAAAAAAAAABlTgBBmu3YAAsEZk5nTgBBtO3YAAsKaE4AAAAAaU5qTgBByO3YAAsUa04AAG5OAAAAAAAAAABwTgAAcU4AQejt2AALBn9OAACCTgBB/O3YAAsCi04AQY7u2AALXJBOAAAAAAAAkU6STgAAAAAAAJNOm06cTgAAAAAAAKNOpU6mTgAAAAAAAAAAqE4AAAAAqU6qTrZOAAC4TgAAAAAAALlOAAAAALpOAAAAAAAAvk4AAMNOAAAAAMROAEH47tgACx7GTgAAyE4AAMpOAADPTgAAAADSTgAAAAAAAAAA/04AQZ/v2AALKU8AAAJPAAAAAAZPAAAHTwAAAAAAAAAACE8AAAAACU8KTwAAFE8AABdPAEHU79gAC0YZTwAAAAAAABpPAAAAAAAAAAAbTwAAHU8AAB5PAAAAAAAAAAAgTwAAAAAoTwAAAAAAAAAAKk8AAAAAAAA2TwAAAAA3TzpPAEGk8NgACyY7TwAAPE8AAD1PAAA/T0JPAAAAAAAAAABETwAAAAAAAAAARU9JTwBB1vDYAAsIS08AAExPT08AQerw2AALEFNPAAAAAFRPAABVTwAAVk8AQYbx2AALGlhPAAAAAAAAWk8AAAAAAAAAAFtPXE8AAGJPAEGs8dgACxRzTwAAAAAAAHZPAAAAAAAAAACATwBB1PHYAAsOik8AAAAAjU8AAJdPmU8AQfjx2AALGppPm08AAJxPAAAAAJ1PAACeTwAAn08AAKRPAEGu8tgACwymT6hPqU8AAAAAq08AQcTy2AALAqxPAEHW8tgACzauT79PAAAAAAAAwU8AAAAAxE8AAAAAyk/MTwAAz08AAAAA0E8AANFP0k/TTwAAAAAAAAAA2E8AQZbz2AALGNpPAADbTwAA3k8AAAAAAAAAAOBPAADjTwBBwPPYAAsK5E/lTwAAAADmTwBB1vPYAAsO6U8AAOpPAAAAAAAA8U8AQe7z2AALDvVPAAAAAAAA+U8AAPxPAEGM9NgACyL9TwAAAAAFUAAAAAAGUAAAAAAHUAAAEFAAABFQAAAAABJQAEHC9NgACwgTUBRQAAAVUABB1PTYAAsoKFAvUAAAMVAAAAAAAAAAADtQAAAAADxQAAAAAAAAP1AAAAAAAABCUABBhvXYAAsSRFAAAAAAU1AAAAAAVFAAAFZQAEGi9dgAC0JtUAAAAAAAAAAAblAAAAAAcVByUAAAAAAAAAAAc1AAAHVQdlAAAAAAAACKUIxQAAAAAAAAAACNUAAAAAAAAAAAk1AAQe712AALFJRQAAAAAAAAlVAAAJZQAAAAAJ9QAEGM9tgACxLjUAAAAADlUAAAAAAAAOlQ6lAAQaj22AALOPRQ9VAAAAAAAAAAAPZQ+FD5UAAA/VAAAP5QAAD/UABRAAABUQAAAAAIUQAACVEAAAxRAAAAAA1RAEHw9tgACxoOUQAAAAAAAAAAElEAAAAAAAAZUQAAAAAbUQBBmPfYAAsCHlEAQbb32AALEh9RAAAAAAAAAAAgUQAAIVEpUQBB1PfYAAssMVEAAAAAAAAyUTtRQVEAAEJRAABHUQAAAABIUQAAAABKUQAAAABLUQAATFEAQYr42AALIE1RAAAAAFJRVFFVUQAAAAAAAFZRAABXUQAAAAAAAFpRAEG4+NgAC0ZdUV5RX1EAAGBRZFEAAAAAZ1EAAAAAaFFqUQAAa1EAAGxRAAB2UQAAAAAAAHdRAAAAAAAAAAB4UQAAAAAAAIVRAAAAAIdRAEGM+dgACwKJUQBBmPnYAAsCjFEAQaT52AALGpBRAAAAAJJRAAAAAAAAAACTUZRRAAAAAJpRAEHQ+dgACwKbUQBB3PnYAAsQqVEAAKpRrlEAAAAAsFGzUQBB9vnYAAs+tFEAALVRAAC3UbhRulEAAL9RAADAUcFRwlEAAAAAx1EAAAAAy1EAAAAAzVEAAAAAAADPUQAAAAAAANJR01EAQb762AALFNZRAADaUQAAAADbUeRRAAAAAOdRAEHc+tgACxLtUe9RAAAAAAAA+FEAAPtR/FEAQfj62AALOv1RAAAAAAAAA1IAAAZSAAAHUgAAAAAAAAAACFIJUgAAAAAAAAAAEFIAABJSAAAYUgAAAAAAABlSGlIAQbz72AALDh1SIlIjUiRSAAAAACVSAEHU+9gACwImUgBB8PvYAAsEJ1IoUgBB/vvYAAsILVIAAAAALlIAQZj82AALaC9SAAAxUgAANlI3UgAAAAAAADlSPVIAAAAAQVJIUklSAAAAAEpSS1IAAAAAAABNUgAAAAAAAE9SUFIAAAAAUVIAAFJSAAAAAFZSAAAAAAAAAABXUgAAAABYUllSAAAAAF5SX1IAAGFSAEGO/dgACwpjUgAAZVIAAGZSAEGo/dgACwJnUgBBtP3YAAsGaFIAAGpSAEHI/dgACwxrUgAAAABsUm1SblIAQd792AALBm9SAABwUgBB7v3YAAsOcVJ0UnVSAAAAAHhSeVIAQYj+2AALBntSglKDUgBBmP7YAAsChVIAQar+2AALNolSi1IAAAAAjlIAAAAAAACRUpZSAACXUgAAAACYUgAAmVKaUgAAoFKiUqNSpFIAAAAAAACoUgBB7P7YAAssqVIAAKxSAACuUgAAAAAAAAAAslIAAAAAAAAAALNSAAAAALRSAAC2UgAAt1IAQaL/2AALNLhSu1LEUgAAAAAAAMVSAAAAAMZSAAAAAAAAyFIAAAAAyVIAAAAAAADOUgAA3FIAAAAA3VIAQeL/2AALLt9S4FIAAAAA51LpUgAA6lIAAAAAAAAAAOtS7FIAAAAA7VIAAAAAAAAAAO5S9FIAQaqA2QALFPVSAAAAAPZS91IAAAAAAAAAAAhTAEHIgNkACwIJUwBB2IDZAAsWC1MAAAAAAAAPUwAAGFMAABpTAAAiUwBB/oDZAAsCI1MAQZCB2QALTi5TAAAAADFTAAAAAAAAAAAyUwAAAAAAADNTAAA0UzZTAABEUwAARlNKU0tTAABMUwAATlMAAAAAAABPU1BTAAAAAAAAaFMAAAAAalNxUwBB+IHZAAsKclMAAAAAAABzUwBBlILZAAsidlMAAAAAd1N8U35TAAAAAAAAf1OBUwAAglMAAAAAAACEUwBByoLZAAsChVMAQdiC2QALHoZTAACHUwAAAACIUwAAAACJUwAAAAAAAAAAjVOOUwBBkIPZAAsElVOWUwBBqIPZAAsol1MAAJhTAAAAAAAAAACaUwAAAAAAAJtTnFMAAJ1TnlMAAAAAAACfUwBB6IPZAAsooFMAAAAAAAAAAKFTAACtUwAArlMAAAAAAACxU7RTAAAAAAAAAAC1UwBBmoTZAAsCuVMAQbCE2QALTLpTAADDUwAAxFPJUwAAzFMAAM1TzlMAAAAAAADRUwAAAADSUwAAAAAAANRT1VMAAAAA2FMAAAAAAADhU+ZTAAAAAOdTAAAAAOlT61MAQYyF2QALEOxTAAAAAO1T7lMAAAAA8FMAQaiF2QALCBNUAAAAABVUAEG+hdkACwIWVABBzIXZAAscGVQaVAAAAAAbVAAAAAAdVAAAAAAjVDxUAAA/VABB+IXZAAsMR1QAAAAAAAAAAElUAEGOhtkACwhXVAAAAABkVABBqIbZAAsSZVQAAGZUAAAAAHFUclRzVHRUAEHUhtkAC0B3VAAAAAAAAAAAf1QAAINUAAAAAAAAAACHVI5UlVSeVAAAAACfVKBUAACiVAAAAACjVAAAplSoVKlUAACqVLNUAEGeh9kACyi0VAAAvlQAAAAAAAAAAL9UxFQAAMdUAADIVAAAAADNVAAAAAAAAM5UAEHWh9kACzbPVAAAAAAAANBUAADVVAAA4lQAAAAAAADjVOVUAAAAAAAAAADpVO1U7lQAAPNUAAAAAAAA9VQAQaaI2QALAvZUAEGyiNkACwz4VAAAAAAAAAAA+VQAQcqI2QALCPtU/FQAAP1UAEHfiNkACwdVAAAAAANVAEH4iNkACw4EVQAAAAAGVQAAAAAHVQBBmInZAAscDVUAAA5VAAAAAA9VAAAAAAAAAAAQVQAAAAARVQBBxonZAAsQFFUbVRxVH1UAAAAAAAAlVQBB4InZAAs2LVUAAAAAAAAAAC5VAAAvVTFVAAAyVTNVAAA5VTtVPFUAAD9VAABAVQAAAABBVQAAAABCVUhVAEGgitkACxpJVVhVWVUAAAAAa1VuVW9VcVUAAAAAAAByVQBBzIrZAAtYc1UAAHZVAAAAAAAAd1UAAHlVflUAAAAAAAAAAH9VAAAAAIBVhlWHVYlVAACNVQAAkFUAAAAAklUAAAAAAACVVZZVl1UAAAAAmFUAAAAAmVWaVZtVAACfVQBBsovZAAsMoVUAAAAAolWtVbNVAEHUi9kACwK4VQBB4IvZAAsGuVUAALtVAEH6i9kACwq9VQAAAAAAAL5VAEGejNkACwa/VQAAwFUAQbaM2QALEsJVxVUAAAAAAAAAAMZVAADHVQBB1IzZAAsEylXLVQBB6IzZAAsgzFXNVQAAAADRVdJVAAAAAAAA1lUAAAAA3FXdVQAA3lUAQZKN2QALDuFVAADkVQAA6FUAAO9VAEGsjdkACwbxVQAA8lUAQb6N2QALAvNVAEHKjdkACyD0VQAAAAAAAPhVAAD5Vf9VAAAAAABWAAAAAAAAAVYDVgBB/I3ZAAsCBFYAQZKO2QALPgVWFVYAABdWAAAAAAAAGFYAAAAAAAAgViFWAAAAACVWJ1YoVitWAAAAACxWLVYAAAAAMFYAAAAAAAAAADJWAEHejtkACww5VgAAAAAAADpWO1YAQfiO2QALEDxWAAAAAAAAAAA9VkRWU1YAQZaP2QALFFhWAAAAAFtWAABcVgAAXVYAAF5WAEG4j9kACx5fVmdWAABoVmpWAAAAAAAAAABtVgAAAAAAAHBWcVYAQeKP2QALSH1WAAAAAAAAflYAAAAAgFaCVgAAhFaFVodWilYAAAAAAACSVgAAAAAAAAAAlFahVgAAAAAAAAAAo1YAAKZWp1YAAAAAqFasVgBBupDZAAs8rlYAALJWuVYAAAAAwFYAAMFWAADEVgAAAADHVgAAz1bXVgAAAADYVgAA2lYAAAAA21bcVgAA3VYAAOBWAEGAkdkACxzhVgAAAAAAAOJW5lbnVgAAAAAAAPNW/FYAAP1WAEGqkdkACxT+VgAAAAAAAAAA/1YAAABXAAAFVwBByJHZAAsaBlcIVwtXDlcAAAAAD1cRVwAAAAASVwAAFVcAQfaR2QALFBdXAAAdVx5XAAAAAAAAIVcAACRXAEGektkACxYrVwAAAAAAAC1XAAA+VwAAAAAAAD9XAEG+ktkACxJAVwAAQldIVwAAS1dNVwAATlcAQd6S2QALAlVXAEHqktkACwJWVwBBgJPZAAsEV1dYVwBBlJPZAAsQWVdeVwAAAABhVwAAYldlVwBBrpPZAAsGZ1cAAGlXAEG+k9kACxpqVwAAAAAAAAAAbVcAAAAAAAAAAG5XAABvVwBB6pPZAAsOd1cAAAAAeFd7V3xXglcAQZKU2QALFoVXAAAAAIZXAAAAAIhXAAAAAIlXilcAQbSU2QALLphXAAAAAAAAAACaVwAAAAAAAJtXAACcVwAAoFcAAKNXqlerVwAAAAAAAAAArFcAQeyU2QALQq5XAAC2VwAAt1cAAAAAAADBVwAAxlcAAMdXAAAAAAAAAADIV8lXAADXVwAAAAAAANhXAAAAAAAAAADZVwAAAADjVwBBupXZAAsI8lcAAAAA81cAQdCV2QALOvRXAAAAAAAA9Vf4VwAAAAAAAAZYAAAAAAdYAAAAAAhYAAAMWBlYAAAbWAAAAAAAAAAAIVgAAAAAIlgAQaCW2QALICZYAAAAAAAAAAAnWChYAAAAAC9YAAAzWAAANlg3WDlYAEHKltkACw46WAAAAAA7WAAAAAA+WABB4pbZAAsGP1gAAEBYAEHyltkACxhBWAAASlgAAAAATFgAAAAAUVgAAAAAWlgAQZaX2QALDltYAABgWGFYAAAAAG5YAEGul9kACwhvWAAAAABwWABBxJfZAAsodFgAAHVYd1gAAAAAAAAAAHxYfVgAAAAAAAB+WAAAf1gAAAAAAACAWABBgJjZAAsSkViTWJRYAAAAAJZYl1gAAKNYAEGgmNkACxClWAAAAACoWAAAq1izWLRYAEHAmNkACxq+WAAAv1gAAAAAAAAAAMNYAAAAAAAAxFjFWABB9pjZAAsExljIWABBipnZAAsqyVgAAAAAy1gAAAAAAAAAAMxYz1jQWAAAAAAAAAAA01gAAN1YAAAAAN9YAEHKmdkACwLmWABB1pnZAAsC6FgAQeKZ2QALCuxY7VjuWAAA8FgAQfaZ2QALBPFY8lgAQYaa2QALJPNYAAAAAPRY91gAAPhY+Vj8WAAAAAD+WABZAAADWQAABVkMWQBBtJrZAAsCDlkAQcKa2QALCBJZAAATWRRZAEHemtkACxoVWQAAAAAaWRtZHlkgWQAAKVkqWQAAL1kxWQBBipvZAAsMMlkAADRZNlkAADdZAEGgm9kACwY4WQAAP1kAQbCb2QALIEhZSVkAAEpZS1kAAAAATlkAAAAAUFkAAAAAAAAAAFFZAEHmm9kACyZSWQAAU1lUWQAAAAAAAAAAVVkAAFdZAABYWQAAWVlhWWJZZFllWQBBmpzZAAtqZllnWQAAblkAAG9ZAAAAAAAAdFkAAHVZAAAAAAAAAAB4WQAAAAAAAAAAeVl7WQAAAAAAAINZhVkAAAAAhlkAAAAAAACIWQAAAAAAAJFZklkAAAAAAACdWZ5ZAAAAAAAAn1kAAAAAAACgWQBBkp3ZAAsWolkAAKNZAAAAAKpZAACsWQAAAACyWQBBtp3ZAAsIs1kAAAAAtFkAQcyd2QALDrVZAAC4WQAAAAAAALlZAEHkndkACwa6WQAAu1kAQfSd2QALEsJZAAAAAMNZAADLWQAAAADNWQBBkp7ZAAsGzlkAAN1ZAEGmntkACxreWd9Z4FkAAAAA71nwWfVZAAAAAAAAAAD2WQBByp7ZAAsC+FkAQdae2QALRvtZAAAAAAAAAAD+WQAAAAAAAAhaAAAJWgxaDVoUWhVaAAAXWgAAAAAAAAAAG1ocWgAAAAAAAB1aIVoAAAAAAABXWgAAWFoAQaaf2QALGllaAABiWmVaAABtWgAAAABuWgAAAAAAAHBaAEHQn9kACxByWgAAAAAAAAAAdVp3WnhaAEH4n9kACxaMWgAAAAAAAAAAjVoAAAAAlFoAAJVaAEGmoNkACwqbWgAAAACcWp9aAEHCoNkACxCiWgAApFoAAKdaAACpWqpaAEHeoNkACy67Wr1aAAAAAL5awlrGWgAAAAAAAM1azlrQWgAAAAAAAAAA0VrWWgAAAAAAAOFaAEGaodkAC2jkWgAA7FoAAAAAAAAAAO1aAAABWwAAAlsAAAAAAAAAAANbAAAGWwAAAAAHWxBbAAAAABJbAAAYWwAAAAAAAAAAHFsAAB1bAAAgWwAAJlsAAAAAAAApWwAAAAAAAAAAL1swWzJbAAA0WwBBkqLZAAs6OVsAAAAAAAAAADtbAAA8Wz5bAAAAAAAAP1tAWwAAQVsAAEdbAABJWwAAAABNWwAAUltTWwAAVltXWwBB6KLZAAsCW1sAQfai2QALLlxbXlsAAAAAYVtmWwAAAAAAAGdbAAAAAAAAaFsAAAAAAAAAAGlbAAAAAAAAd1sAQbSj2QALGnhbAAB+WwAAk1uUWwAAAAAAAAAAmFsAAJ5bAEHao9kACwqgWwAAAACiW6hbAEHwo9kACxypWwAAAAAAAK5br1sAAAAAsFsAAAAAAACxW8hbAEGcpNkACz7JWwAAy1sAAAAAzlsAAAAAz1sAAAAA2VsAAAAA21sAAAAAAADdWwAAAAAAAAAA3lvfW+Fb5FsAAOVb6FvzWwBB5KTZAAsU9VsAAAAA+FsAAAAABFwAAAAABVwAQZKl2QALEgdcAAAIXAAAAAAJXAAAAAAOXABBrqXZAAsUEFwRXBJcAAAAAAAAAAATXAAAFlwAQdil2QALDBdcAAAbXAAAAAAdXABB8KXZAAsCI1wAQYCm2QALJCxcLlwAAAAAAAAAADJcNlwAAAAAN1wAADhcAAAAAAAAPlxAXABBrqbZAAsYQlwAAAAAQ1wAAAAAAAAAAEVcSlwAAEtcAEHUptkACxRNXAAATlwAAAAAAAAAAFJcAABUXABB9KbZAAsaVlwAAAAAAAAAAFhcc1wAAHVcAAAAAAAAgVwAQZyn2QALBoJcAACDXABBrKfZAAschFwAAAAAAACFXIlcAACNXI5clFwAAJZcAACdXABB1qfZAAsCoFwAQeKn2QALQKJcAAAAAKNcAAAAAAAAAACmXAAAAACoXAAAAAAAAAAAqlwAAAAAAACuXLFcAAC9XMJcAADEXAAAAAAAAAAAxVwAQayo2QALJMZcAAAAAAAAAADHXAAAyVwAAAAAAAAAAM1c1VwAAAAAAADaXABB3qjZAAtQ21wAANxc5VwAAAAA9FwAAAAAAAAAAPZcAAD3XAAAAAAAAPpcAAAAAP5cAAD/XAAAAAAAXQAAAV0AAAtdAAAAAAAADV0AABNdAAAAAAAAFV0AQbyp2QALAhZdAEHKqdkACxQYXRldGl0bXQAAAAAAAAAAHV0eXQBB6KnZAAsCJl0AQfap2QALAiddAEGCqtkACxxHXUldAAAAAEpdS11XXQAAW10AAAAAAAAAAF1dAEGqqtkACwJeXQBBtqrZAAsuX11hXQAAYl0AAGNdbl1vXXBdAAByXQAAdF0AAHddAAB+XQAAgV2FXQAAhl2KXQBB7qrZAAsGk12UXZZdAEGAq9kACzKXXQAAml2dXQAAnl0AAAAAAAAAAJ9doF0AAAAApV0AAAAApl0AAAAAAAAAAKddAACoXQBBzKvZAAsCqV0AQd6r2QALHKxdAAAAALBdAACxXQAAAACzXQAAAAC0XbZdt10AQYas2QALArhdAEGYrNkACwq6XQAAAAAAAL5dAEG0rNkACx6/XQAAAADDXQAAxF0AAMZdAAAAAAAAx10AAAAAyF0AQeCs2QALKsldAAAAAMpdAAAAAMtdAAAAAM1dzl0AAAAAz13QXdtdAADcXd1dAADeXQBBlK3ZAAto4V3iXQAA410AAAAA5F0AAAAA7F0AAPBd8V3/XQNeAAAEXgZeAAAAAAdeDl4XXgAAGl4AAAAAAAAfXgAAIl4lXiheKl4AACteAAAAAAAALF4AAAAAAAAAAC5eL14AADFeAAAAADNeOF4AQYiu2QALDjxeAAA9XgAAPl4AAD9eAEGgrtkACzBHXgAAAABIXgAASV5OXgAAAAAAAFJeAAAAAFNeVV5aXgAAY14AAAAAAABlXmZeZ14AQeSu2QALJmleal5vXgAAAAAAAHJeAAAAAHNeAAAAAHVeAAB4XoVeAACJXoxeAEGWr9kACw6OXpRenF4AAAAAAACgXgBBtK/ZAAsGol4AAKpeAEHar9kACwarXgAArF4AQeqv2QALFq9esF6xXgAAAAC4XgAAAAC5XgAAu14AQYyw2QALKr1eAADMXgAAAAAAAM1eAADPXtBeAAAAAAAAAADRXgAAAADSXgAAAADXXgBBxLDZAAsI2F4AAOVe5l4AQdiw2QALOOheAAAAAANfAAAAAAAACV8KXwtfE18AAB9fAAAAADFfMl8AAAAAAAAzXwAAAAAAAAAANF81XzZfAEGasdkAC0Y6XwAAAAAAAAAAO18AAD1fAAA/X0VfAABGXwAAAABKX0tfUF8AAAAAAABRX1JfAABWXwAAAAAAAFtfAAAAAAAAX18AAGBfAEHqsdkAC1BhXwAAY18AAGZfAABnX2xfAABzXwAAAAAAAHdfAAAAAAAAeF96X35fAAAAAAAAf1+AX4FfhF8AAAAAAAAAAIVfiV8AAAAAil+LX4xfAACRXwBByLLZAAsCll8AQe6y2QALGpdfAACZX5pfm1+cXwAAnl8AAAAAAAAAAKBfAEGcs9kACwKhXwBBsrPZAAtOol+lXwAAAAAAAAAApl8AAAAAAACoXwAAAAAAAK5fAAAAAAAAAACxXwAAAACyXwAAAAAAALNful8AAAAAAAC7XwAAAAC/XwAAAADBX8JfAEGKtNkACxLFXwAAxl8AAMhfAADJX8xfzV8AQaa02QALAs9fAEHEtNkACwLQXwBB5rTZAAsQ2V/bXwAA3F8AAAAAAADkXwBBgLXZAAsa5V/mXwAAAAAAAOlf6l8AAOtfAADsXwAA7l8AQaS12QALCvBfAAAAAAAA8V8AQbi12QALAvJfAEHUtdkACwL3XwBB4LXZAAsO+V8AAAAAAAD+XwAA/18AQYS22QALCAFgBWAAAAhgAEGWttkACwIJYABBorbZAAsMCmAAAAAAC2AAAAxgAEHCttkACw4OYA9gAAAAAAAAAAAQYABB3rbZAAsCEmAAQe622QALXhRgFWAAAAAAAAAAABpgG2AAAAAAAAAAABxgAAAAAB1gAAAiYAAAAAAjYAAAAAAAAAAAJGAnYChgMGAAAAAAAAAzYAAAPmA/YAAAAAAAAAAAQGAAAAAAAABPYFBgUWAAQdy32QALCFZgAABXYFhgAEHut9kACwxZYAAAAAAAAAAAW2AAQYa42QALUFxgXWAAAF5gYmAAAAAAAABjYAAAZmAAAAAAZ2AAAAAAAABpYAAAa2AAAAAAAAAAAGxgAABtYAAAAABuYAAAAABwYHFgAAAAAAAAAAByYHNgAEHkuNkACwZ5YAAAemAAQfq42QALAoVgAEGGudkACwaGYAAAiGAAQZi52QALRolgimAAAItgAACMYI5gAACPYAAAAAAAAAAAkGAAAAAAlWAAAAAAomAAAK1grmAAAAAAAACwYAAAAAAAALFgAAAAAAAAtmAAQei52QALBrpgAAC7YABB/LnZAAsCvGAAQYi62QALHr1gv2DAYAAAxGAAAAAAAAAAAMVgAAAAAAAAAADJYABBsLrZAAs80WAAANJg1GAAAAAAAADVYAAAAAAAAAAA2mDeYAAA32DgYAAAAAAAAONgAADkYOZgAADnYAAAAAAAAOpgAEH4utkACwj7YPxgAAADYQBBjLvZAAsCBGEAQZi72QALCAdhAAALYQxhAEG0u9kACwgPYQAAAAAQYQBByLvZAAsUEWEAABJhE2EAAAAAAAAUYQAAFWEAQe672QALIhZhAAAXYQAAAAAkYQAAAAAAADNhAAAAAAAANGEAAD9hQWEAQZq82QALAkNhAEGmvNkACwZEYQAAUWEAQbi82QALIFJhAAAAAFVhYmFjYQAAAAAAAGRhAAAAAGthAAAAAG5hAEHqvNkACzJxYXZhAAB3YQAAAAB5YQAAAAAAAHphAAB/YQAAAAAAAIFhAAAAAIJhAACEYYhhimGMYQBBpr3ZAAtYkGEAAAAAAACRYQAAlmEAAAAAl2EAAAAAmGEAAAAAAAChYQAAAAAAAKJhAAAAAKlhAAAAAAAAq2EAAAAAumEAAAAAv2EAAAAAAADKYQAAAADLYcxhAADNYQBBjL7ZAAsCz2EAQZi+2QALAtBhAEGovtkACwrSYQAAAADTYdVhAEG+vtkAC1TZYQAAAADbYQAA3GHdYQAAAADeYQAAAAAAAN9hAAAAAAAAAADhYeNhAAAAAORh6GEAAOlh7WHuYQAAAAAAAAAA8GEAAPFhAAACYgAAAAAEYgViDWIAQZ6/2QALEhFiFGIAAAAAGWIAAAAAG2IcYgBBvL/ZAAsMHWIAAAAAAAAgYiFiAEHWv9kACyQlYgAAAAAAACZiAAAqYi5iAAAzYgAAN2IAAAAAAAA/YgAASWIAQaDA2QALAktiAEGwwNkAC0BWYgAAV2IAAHdiAAAAAAAAeWIAAAAAAAAAAH1iAACDYgAAh2IAAIliAAAAAAAAi2IAAAAAAACMYgAAAAAAAI1iAEH+wNkAC0aPYpFiAAAAAAAAAACVYpdiAAAAAAAAm2IAAAAAAACkYgAAqWKqYgAAAAAAAAAArGKxYgAAtGIAAAAAuWLsYgAA7WIAAO5iAEHUwdkACwLvYgBB4MHZAAsC8GIAQe7B2QALIPRiAAAAAAAA9WIAAAAAAAD4Yvli+mIAAAAA/2IAAAZjAEGcwtkACxgIYwAACmMAAB9jAAAjYwAAAAAAAAAAKGMAQcbC2QALJipjAAAsYwAALmMAAAAAN2MAAAAAOWMAAAAAAAA6YwAAAAAAAD9jAEGCw9kACwpFY0djAAAAAEljAEGaw9kACxxLYwAAAAAAAE1jAAAAAAAAUGMAAAAAAAAAAFljAEHIw9kACwJbYwBB1sPZAAsQXGMAAAAAAABdYwAAAABgYwBB8sPZAAtIYmMAAAAAY2MAAGZjAAAAAGljAAAAAAAAamMAAAAAAAAAAGxjAABtY25jb2MAAAAAAABwYwAAcWMAAAAAAABzYwAAdWMAAHxjAEHKxNkACwJ9YwBB1sTZAAsCf2MAQeLE2QALAoJjAEH0xNkACxaDYwAAAAAAAAAAhWMAAAAAAAAAAItjAEGUxdkACwKMYwBBrsXZAAsgjWMAAJljAAAAAJpjAACgYwAApmMAAKhjAAAAAKljqmMAQdrF2QALCq1jrmOvYwAAsGMAQfLF2QALJLFjAACyY7djvmMAAMBjAADBYwAAAADMY85jAAAAAM9jAADQYwBBoMbZAAsY0mMAANNjAADUY9Vj4GMAAAAAAADiY+NjAEHExtkACxzmYwAAAAAAAAAA62MAAAAAAADtYwAAAAAAAO5jAEHyxtkACzD0YwAAAAAAAAAA9WMAAAAAAAAAAPZjAAD3Y/hj+WMAAPpjAAAAAAAA/GMAAP1jD2QAQazH2QALVBJkAAAAAAAAAAATZBdkAAAAAB1kAAAAAB9kAAAAAAAAI2QkZAAAAAAxZAAAAAAAAAAANmQAAAAAAAA9ZD9kAAAAAEdkAAAAAE5kYmQAAGNkZmRnZABBkMjZAAsCaGQAQZzI2QALKmpkAAAAAG5kAABvZAAAcGQAAHNkdGR1ZAAAAAB2ZIBkhGQAAAAAAACGZABB2MjZAAsiiWQAAAAAi2QAAAAAAACMZAAAjWSRZAAAkmQAAJRkrGSyZABBhMnZAAsctGQAAAAAAAAAALVkAAC2ZLhkuWQAAAAAAAC9ZABBrMnZAAsexWTJZAAAAAAAANBk0WQAAAAA02TWZNdkAAAAANlkAEHaydkACyDcZAAAAAAAAAAA6GTpZAAAAAAAAPZkAAAAAAAA92T4ZABBjMrZAAse+WT6ZAAAAAD7ZAAAAAD8ZAAABmUAAAAAAAAHZQllAEG4ytkACyALZQxlAAANZRJlAAATZQAAFGUVZQAAAAAAAAAAFmUuZQBB5srZAAsaL2UwZTFlAAAAAAAANGU1ZQAAAAAAAAAANmUAQY7L2QALBjhlAAA5ZQBBpMvZAAsIOmUAAAAAPGUAQbbL2QALJD1lR2UAAAAAAAAAAEhlAAAAAEplAAAAAAAATWUAAAAAUmVWZQBB6MvZAAsgWWUAAF5lAABkZQAAAABpZWplAAAAAGtlAABsZW1lbmUAQZLM2QALFm9lAAAAAAAAAABwZQAAAAAAAHFlc2UAQbLM2QALBHVld2UAQcTM2QALFnplAAB9ZQAAAAAAAH5lAAAAAAAAgGUAQejM2QALAollAEGEzdkACx6SZQAAAAAAAJVlAAAAAAAAlmWXZQAAAACeZZ9loGUAQa7N2QALIKFlomWkZQAApmWnZQAAAAAAAKhlrGUAAK1lsWWyZbxlAEHYzdkACxa+ZQAAAAC/ZQAAAADBZQAAwmUAAMNlAEH4zdkACw7FZQAAAAAAAAAAxmXLZQBBks7ZAAsGzGUAANJlAEGwztkACzbTZQAA1WUAAAAA12UAAAAAAADZZQAA2mXdZQAAAAAAAAAA3mUAAAAAAADfZQAA6mUAAAAA7mUAQfbO2QALAu9lAEGOz9kACxTwZfVlAAD7ZQpmAAAMZgAAAAANZgBBrs/ZAAsGGGYdZitmAEHGz9kACx40ZjZmAAAAAAAAN2YAADpmO2YAAAAAPGYAAAAAPmYAQf7P2QALHD9mAAAAAAAAQGZBZgAA0WbSZgAA02YAAAAA1GYAQajQ2QALBtVmAADbZgBButDZAAsu32YAAAAAAADuZgAAAAAAAAtnAAAAAA5nD2cRZwAAAAAYZyZnAAAAAAAAAAArZwBB8tDZAAsWLGcAAAAANGcAAAAAN2cAADhnOmdAZwBBqNHZAAsGQ2cAAERnAEG40dkAC05JZwAATGcAAAAAAABOZwAAAAAAAAAAT2cAAAAAAAAAAFFnAABSZ1RnAABVZ1ZnAAAAAAAAV2cAAAAAAABYZwAAAABaZwAAAABcZwAAX2cAQZbS2QALBGBnZmcAQazS2QALCGlnAAAAAGpnAEHC0tkACwJrZwBB0tLZAAsobWcAAHVnAAAAAHZnAAB3ZwAAAAB4Z31nfmcAAAAAf2cAAIFniGeKZwBBhNPZAAsCi2cAQZDT2QALCI1nAAAAAI5nAEGy09kAC1CQZwAAkWeTZwAAAAAAAJZnAAAAAAAAl2cAAJxnnmcAAAAAAACfZwAApGcAAKVnqWe+ZwAAAAAAAL9nAAAAAAAAy2cAAAAAzWcAANxnAADhZwBBjtTZAAsG62cAAOxnAEGo1NkACwLuZwBBuNTZAAsW72fxZ/Nn9mcAAAAAAAD4Z/xnAAD9ZwBB2NTZAAscA2gAAAVoAAAAAAZoAAAAAAhoE2gAAAAAAAAUaABBhtXZAAtqFmgXaAAAAAAAABpoAAAAACBoAAAAAAAAAAAnaC5oL2gAAAAAAAA9aD5oP2gAAEFoAAAAAAAAAAB4aAAAeWgAAHtofGgAAH1ofmh/aAAAAAAAAAAAgGiDaAAAAAAAAIRokWgAAAAAAACWaABB+tXZAAsUl2gAAJlommgAAKJoAAAAAAAAo2gAQajW2QALCKRoAAAAAKVoAEG61tkACyinaAAAqGipaAAAAAAAAKpoAACtaK5oAAAAAAAAsGgAAAAAs2gAALRoAEH01tkACw61aAAAAAC4aAAAAAC5aABBkNfZAAsGvGgAAMloAEGk19kACyDKaAAAAADLaM1o0mgAAAAAAAAAANNoAAAAAOFoAADjaABB1tfZAAsQ5GgAAOVo6WgAAOpoAADraABB9NfZAAsi/GgAAP5oAmkDaQAAAAAAAAAACmkOaQAAAAAAAAAAD2kQaQBBoNjZAAsCFGkAQbDY2QALOB9pIWkiaSNpJGknaQAAAAAAAClpKmkAAAAALWkAAAAAAAAwaQAAAAAxaTJpAAAAAAAAM2kAADRpAEHy2NkACwI1aQBBgNnZAAsWOWkAAAAAP2kAAAAAQGkAAAAAAABCaQBBpNnZAAsMTGkAAE5pAAAAAFNpAEG+2dkACwpVaQAAWWlaaVxpAEHS2dkACw5daQAAXmkAAGJpAABkaQBB7NnZAAskZmkAAGppa2kAAG5pAAAAAAAAAAB7aX5pAAAAAH9pgmmEaYVpAEGg2tkACwqGaYdpimkAAItpAEG02tkACzSRaQAAAAAAAJJpAAAAAAAAAACVaZZpl2maaQAAAACcaZ1pAAAAAAAAnmmiaQAAAAAAAKRpAEGE29kACwKlaQBBlNvZAAsCpmkAQaTb2QALFqdpqWkAAKppAAAAAAAAq2msaQAAr2kAQeDb2QALDrBpsmmzaQAAtWkAALhpAEH429kACwi9aQAAAAC+aQBBjtzZAAsCwGkAQaDc2QALAsRpAEGs3NkACw7GaQAAx2kAAAAAAADJaQBBxtzZAAsSymkAAMtpzmkAAAAAAAAAAM9pAEHi3NkACy7QadJpAADWaQAAAADXaQAA22neaQAAAAAAAN9pAAAAAAAAAADhaQAAAAAAAOJpAEGc3dkACyrjaQAAAAAAAAAA5GntaQAAAAAAAAAA7mkAAAAA9GkAAPZpAAAAAPpp+2kAQdLd2QALKgtqAAAAAAAAAAAMag1qAAAAAAAAAAAOag9qAAAQagAAF2oAAAAAAAAcagBBit7ZAAsYJ2oAADVqAAAAADdqAAA5agAAO2oAAD5qAEGs3tkAC2hAagAAAAAAAAAAQmoAAAAAAAAAAENqAAAAAERqAAAAAEZqAABHagAAAAAAAAAASWoAAAAAAABNagAAAABQalNqVGpWaldqAABYagAAWWpaagAAAABhagAAAAAAAAAAY2oAAGVqAABmagBBsN/ZAAsYZ2oAAGpqa2oAAHJqAAAAAAAAc2oAAHVqAEHy39kACw52andqemoAAAAAAAB7agBBjODZAAsIg2oAAIxqjmoAQabg2QALBqBqoWqlagBBuODZAAsCpmoAQcbg2QALBLBqsWoAQdTg2QALJrZqAAC4agAAwWoAAMJqw2oAAMRqAAAAAAAAAADMagAAAAAAANRqAEGG4dkACzLWagAA12oAAAAAAAAAANtqAAAAAN5q32rhagAAAAAAAOVqAADnagAA8GryagAAAADzagBBxOHZAAsIBGsAAAVrDGsAQdbh2QALHBBrAAAAAAAAAAA9awAAAAAAAEBrAAAAAAAAQmsAQYDi2QALKkNrAAAAAAAARGsAAAAARWsAAElrS2sAAAAATWsAAE5rAABPawAAVWtaawBBtuLZAAsCXGsAQcTi2QALAl1rAEHQ4tkACwhlawAAZmtuawBB8OLZAAsWd2uMawAAAAAAAI1rmWsAAAAAAACaawBBmuPZAAsOm2sAAAAAnWueawAAn2sAQbbj2QALHqNrAAAAALNrAAC1a7Zrt2u5awAAumsAAAAAu2vBawBB3uPZAAsawmsAAAAAxGvFawAAAAAAAAAAzGsAAAAA0GsAQY7k2QALAthrAEGm5NkACzTaawAAAAAAAOJrAAAAAORrAAAAAAAA72sAAAAA8GvyawAA9Gv2awAAAAAAAPtrAAD8awFsAEH05NkACwgDbAxsAAANbABBiuXZAAtGDmwAAAAAEGwAABFsAAAAAAAAFWwAABdsAAAAAAAAGWwabAAAAAAAACJsAAAAAAAAP2wAAEBsQWxHbEhsAAAAAFBsAABRbABB4uXZAAsiU2wAAAAAVGwAAFVsAABabAAAAAAAAF5sAAAAAAAAX2xgbABBkObZAAtOYWxibAAAAAAAAGNsZGxnbGhsAAAAAAAAeGx6bAAAAAAAAH5sf2wAAIBsgWwAAAAAhWwAAIhsAACKbAAAAACPbAAAkGyRbJxsAACkbKVsAEHu5tkACy6mbAAAsWwAALNsAAAAAAAAAAC0bNVs1mwAAAAAAADYbAAAAAAAANls7GwAAPFsAEGm59kACw7ybAAA82wAAAAAAAD0bABBvufZAAsu+Wz6bAAAAAD7bAAAAAAAAP1sAW0AAAAAEG0AAAAAEW0AABJtAAAAAAAAG20ebQBBgOjZAAscJW0AACZtAAApbQAAK20ybQAAAAAAAAAAOG07bQBBrOjZAAskPG09bQAAAAAAAD9tAABBbUdtAABIbUltAABNbQAAT22TbZRtAEHa6NkACwKYbQBB6OjZAAsKmm2bbQAAAACdbQBBgOnZAAsCn20AQY7p2QALAqJtAEGc6dkACxqlbaZtqG0AAKltAAAAAKptAAAAAAAAAACrbQBBxOnZAAsWrm0AAAAAAAAAALVtAAAAAAAAAAC2bQBB5unZAAsCuG0AQfjp2QALCrptAADBbdJt020AQZDq2QALAtRtAEGc6tkAC0jWbQAA4W0AAONtAAAAAOdtAAAAAAAA7G3tbQAAAAAAAPJtAAAAAAAAAAD4bQAAAAAAAAAA+239bQFuAAAAAAAAAAAGbgAAB24AQfrq2QALAgxuAEGI69kACwgNbgAAAAAPbgBBouvZAAsIEm4cbgAAHm4AQbTr2QALPh9uAAAhbi5uAAAAAC9uMW4AADNuAAA1bgAAAAAAADduOG45bgAAPm4AAD9uQW4AAAAAAABCbgAAQ25FbkhuAEGE7NkACy5LbgAAUW4AAAAAUm4AAAAAAAAAAFNuAAAAAAAAVW4AAAAAAABYblpuAABbblxuAEG+7NkACxZdbgAAAABebl9uAAAAAGBuAAAAAGJuAEHe7NkAC2JjbgAAAABkbgAAAABlbgAAAAAAAAAAZm5nbgAAAABobgAAAAAAAGpuAABsbm1uAABubnBucm4AAHVudm4AAAAAAAB3bgAAeG55bntuAACEbgAAhm4AAIluAAAAAAAAAACLbgBByu3ZAAsCjG4AQdrt2QALAo1uAEH27dkACx6Obo9uAAAAAAAAAACQbgAAAACRbgAAmG4AAJlumm4AQaDu2QALJptuAAAAAAAAoG6hbgAAAACobgAAAAAAAKlusm4AALNuAAAAALhuAEHW7tkACwK7bgBB6O7ZAAsCvG4AQfTu2QALFPtuAAD8bv1uAAAAbwAAAAAAAARvAEGS79kACxoFbwAAAAAAAAAAB28AAAAAAAAIbwAAAAAMbwBBtu/ZAAsQDW8AAAAAAAAPbxJvAAAqbwBB3O/ZAAsQMG8AAAAAAAAAADFvAAAzbwBB+O/ZAAuoATdvAAAAAAAAAAA6bwAAQG8AAEFvAAAAAEVvAAAAAAAAAABGb0hvAAAAAElvAAAAAAAAAABMbwAAAAAAAE9vAABRbwAAU28AAAAAAAAAAFRvAAAAAFZvV28AAAAAAABcbwAAAAAAAF5vAAAAAGBvYW9ib2lvAABubwAAb29wbwAAAAAAAAAAcW8AAAAAdG8AAAAAeW96bwAAAAAAAHtvAACEbwAAiW+KbwBBuPHZAAsUkG+TbwAAAACUbwAAAAAAAAAAlW8AQdrx2QALBJZvmG8AQerx2QALVplvAAAAAAAAmm8AAJxvnW8AAAAAAAAAAJ9vAAAAAAAAAACgb6VvrG8AAAAArW8AAAAAAACub7NvAAC2bwAAAAC5bwAAAAC9bwAAAAAAAAAAxm/Hb8tvAEHM8tkACxTMbwAA0m8AAAAA1G8AANdvAADYbwBB7PLZAAsM228AAAAAAADdb95vAEGi89kACxrfbwAA428AAAAA7G8AAAAAAAD2bwAA/m//bwBBz/PZAAsHcAFwA3AEcABB5PPZAAskE3AAAAAAAAAXcAAAAAAAABhwAAAZcBpwAAAhcAAAI3AkcCZwAEGW9NkACxQncDhwAAAAAAAAQHAAAAAAAABBcABBvPTZAAsQQnAAAENwAABFcAAAAABGcABB4vTZAAsCSXAAQfD02QALGk1wTnBQcFJwVHAAAFVwAAAAAAAAAABXcFhwAEGW9dkACwpacAAAAAAAAFxwAEGs9dkACxRecAAAX3BgcAAAAAAAAAAAYXBicABB2vXZAAsCY3AAQfr12QALCmRwAABlcAAAbnAAQZD22QALGnBwAABxcAAAcnAAAAAAAABzcAAAAAAAAH1wAEG29tkACyJ/cAAAAACBcAAAAAAAAAAAgnAAAIVwAAAAAIZwAAAAAIdwAEHm9tkACwKIcABB8vbZAAtUinCMcAAAAACQcJNwAAAAAJVwAACacAAAAAAAAKpwtHAAAAAAtXAAALZwt3AAAAAAAAC5cAAAAAAAALpwAADDcMRwxXAAAAAAAADKcNBw0nDacNxwAEHU99kACyjfcAAAAAAAAOJw43AAAAAAAADkcAAAAADocAAA6nAAAAAAAAAAAOtwAEGI+NkACw7scAAAAAAAAO5wAADycABBpPjZAAsQ83D0cPdwAAAAAPhwAAD5cABBxPjZAAso/HAAAAAAAAAAAP5wAXEAAAAAAAACcQAACHEAAAtxAAAAAAAAAAAOcQBB+PjZAAsUHHEAAAAAAAAmcQAAAAAAAAAAJ3EAQZ752QALIChxAAArcQAAL3EwcQAANnE3cQAAAAA4cT1xRHFFcUZxAEHK+dkACwJHcQBB1vnZAAsoSHEAAElxAAAAAAAAUXEAAAAAU3EAAAAAXXEAAAAAAAAAAGBxAABhcQBBiPrZAAskYnEAAAAAAABscQAAAAAAAG1xAAAAAAAAAABucQAAdXEAAHdxAEG++tkACxx7cQAAAAAAAH5xgHGGcQAAjnGacQAAAAAAAJtxAEH6+tkACw6ccQAAAAAAAAAAnXGgcQBBlvvZAAsMonGpcQAAAAAAAK9xAEGy+9kACwKxcQBBvvvZAAscs3EAALVxAAAAAAAAu3EAAAAAwHEAAAAA0nHUcQBB7PvZAAsW4HEAAOhx9nEAAPhxAAAAAPxxAAD9cQBBkvzZAAsOLHIAAAAALXIAAAAALnIAQbT82QALHjJyAAAAAAAAOXIAAD1yAABAcgAAQnJIcmByAABicgBB8PzZAAsaZXIAAAAAZnJrcmxyAAAAAAAAAABucgAAb3IAQZT92QALNHBycXJycnRyAAB2cgAAAAB4cntyAACAcgAAAAAAAIpyAAAAAItyAAAAAIxyjnKQcgAAl3IAQdb92QALBJpym3IAQeT92QALDp1yn3IAAAAAAAAAAKByAEH8/dkACwyhcgAAAAAAAAAAonIAQaj+2QALEqNypHKlcgAAAACqcgAAAACrcgBByv7ZAAsQrXIAAAAAAAAAALRyAAC1cgBB6P7ZAAsItnIAAAAAuHIAQYD/2QALBsJyAADFcgBBlv/ZAAsCynIAQaT/2QALHs1yAAAAAAAAznIAAAAAz3LVcgAA1nLkcuZy6nLrcgBB0P/ZAAsC7HIAQeD/2QALLu9yAAAAAAAA+3IAAAAAAAD9cgAAAAD/cgAAAXMAAAAAAAAAAANzAAAGcwpzDHMAQZiA2gALAhBzAEGkgNoACwoVcwAAAAAAABhzAEG+gNoAC1QccwAAIXMAAAAAAAAucwAAAAAAADJzAAAAAAAAM3M0cwAAAAA5cwAAAAAAADpzAAA7cwAAPnNBcwAARXMAAAAAAABGcwAAAAAAAEhzAAAAAAAATHMAQaKB2gALBk5zAABPcwBBsoHaAAsGUHNRc1lzAEHIgdoAC1hacwAAAABbc2JzAABkcwAAAAAAAGZzAABnc2hza3MAAAAAbHMAAAAAAABtcwAAAAAAAG5zAAAAAHBzAAAAAAAAAAB2c3lzAAB6c3xzAAAAAH1zAAAAAH5zAEG0gtoAC0KKc5BzknOXcwAAAAAAAAAAmXOacwAAAACdcwAAAACtcwAArnMAAK9zAAAAAAAAAACwc7FzAAAAALlzAAAAAAAAwHMAQYSD2gALAsFzAEGQg9oACxDCc8NzxXMAAMZzAADJc8tzAEGsg9oACxbMcwAAzXMAANFzAAAAAAAA0nMAANVzAEHeg9oACxLYc9tzAAAAANxzAAAAAAAA3XMAQfqD2gALDOBzAAAAAAAA53PpcwBBlITaAAsO63MAAO1z73MAAAAA9HMAQayE2gALKvVzAAAAAAAA93MAAAAAAAD4cwAA+XP6cwR0AAAFdAAAAAAAAAZ0AAAKdABB5ITaAAsaGHQAABl0AAAfdAAAJXQmdAAANnRBdAAAQ3QAQYiF2gALEER0AAAAAEV0AAAAAAAAS3QAQbCF2gALDkx0AAAAAAAATXROdE90AEHUhdoACw5+dAAAAAAAAIB0AACBdABB7IXaAAsCg3QAQf6F2gALFoV0AACIdIp0AAAAAIt0AAAAAI10jnQAQbiG2gALDpN0AAAAAAAAAACUdJV0AEHYhtoACw6ZdAAAAACtdLB0wnTRdABB8IbaAAsU03ThdAAA4nQAAAAA43TmdPh0+nQAQZKH2gALDPt0/HQAAAAAAAD/dABBqIfaAAskAXUAAAAABHUAAAV1AAAAAAp1AAAAAAAAAAATdQAAAAAAABR1AEHWh9oACyIadQAAG3UodTd1OHU6dQAAAAAAAD11AAAAAAAAAAA+dUB1AEGOiNoACwJBdQBBmojaAAsKR3VPdQAAAABRdQBBuIjaAAsOUnUAAFZ1AABXdQAAWHUAQdKI2gALInN1dHUAAAAAAAB1dQAAeHUAAAAAAAB5dQAAAAAAAAAAe3UAQYCJ2gALCH91AAAAAIB1AEGSidoACwKCdQBBqonaAAsghHWKdQAAAACLdQAAAAAAAAAAknWmdQAAp3UAAKl1snUAQeSJ2gALBrN1tHW1dQBB9onaAAsCt3UAQY6K2gALFLh1AAAAALl1unUAAAAAAAC7dcJ1AEGsitoACxjDdQAAAADEdcd1AAAAAAAA2HUAANx13XUAQdSK2gALCOR15XUAAPB1AEHqitoACxrydfR1AAAAAPd1AAAAAPp1AAAAAAAAAAD7dQBBmIvaAAssBXYAAAAAAAAIdgAAAAAJdgAAAAAAAAp2AAAAAAAAAAALdgAADHYAAA52E3YAQc6L2gALVhd2AAAAABl2G3YAAAAAAAAAAB52AAAgdiN2JXYAACp2LHYAAAAAAAA9dgAAAAA/dkB2AAAAAAAARnZIdgAAAABKdgAATHYAAFZ2AAAAAAAAAABXdlh2AEGujNoACwpadlt2XnZgdmJ2AEHEjNoACxxsdm12AAAAAAAAbnYAAAAAAABvdgAAcHZydnZ2AEHqjNoACxB3dgAAfHaMdo12AAAAAJR2AEGKjdoAC0KVdgAAlnYAAJd2mHYAAAAAnXaedqp2AAAAAAAAAACrdgAAAACtdgAAsXYAALR2vXYAAAAAAADBdgAAAAAAAAAAw3YAQdaN2gALOsR2AAAAAMV2AADGdsh2AADJdgAAynYAAAAAAADRdgAAAADSdtN2AADUdgAA2HYAAAAAAADbdt524HYAQbaO2gALAuF2AEHGjtoACzDkdgAA5XbmdgAA6XbqdgAAAAAAAO12AAAAAAAAAAD0dvh2+XYAAAAAAAD6dgAAAHcAQYKP2gALBgN3AAAFdwBBko/aAAsIDXcAAAAAFHcAQaSP2gALAhV3AEGwj9oACwgWdxd3IXcidwBBzI/aAAsWKXcAACx3AAAAAAAALXcudwAAMnc0dwBB+I/aAAsaO3cAADx3AAA9dwAAAAAAAAAASXcAAAAASncAQZyQ2gALGll3AAAAAFt3XHded193YHcAAAAAYXcAAGJ3AEHGkNoAC0pjd2p3a3cAAHp3e3cAAAAAfncAAAAAgncAAAAAAAAAAJN3lHefd6p3AAAAAKx3sHe/d8B3AADBdwAAAADCd813AADOdwAA1HfWdwBBnpHaAAsC13cAQbaR2gALPud3AAAAAOp3AAAAAAAAAADsdwAAAAAAAAAA7XcAAO5373cAAAAAAAAAAPN3AAAAAAAA9XcAAAAA9nf/dwl4AEGGktoACxALeAAAAAANeAAAAAAAAA54AEGgktoACzYQeBF4AAAAAAAAFHgAAAAAAAAXeAAAGngAABt4HHgAAAAAH3ggeCF4AAAAAAAAIngAAAAAKHgAQeSS2gALPit4AAAseAAAAAAueAAAMXgyeDN4Nng5eAAAAAA7eDx4PXgAAAAAAAAAAEZ4AAAAAAAASHgAAAAAAAAAAFp4AEGwk9oACxRceGN4AAAAAGd4aHgAAGl4AABreABB0JPaAAsebHgAAAAAbngAAAAAAAByeAAAc3gAAHV4dngAAH14AEH4k9oACw5+eH94AAAAAIF4AACDeABBkJTaAAsqhHiKeAAAAACLeAAAkXgAAAAAkngAAAAAlHgAAAAAlXgAAAAAAACheKN4AEHElNoACyqpeAAAq3gAAAAAAAAAAK54AACveAAAsXgAALJ4AAAAAAAAuHi6eAAAvXgAQfqU2gALHr54AAAAAAAAw3jVeN54AAAAAAAAAADfeAAAAADheABBpJXaAAs84ngAAAAA43gAAAAA63jseAAAAADweAAAAADxePJ49ngAAAAA+Xj+eAAAAAAAAAB5AAAAAAF5AAACeQZ5AEHuldoAC0ASeRN5FnkAABh5AAAAABl5AAAAABt5HXkAAAAAHnkjeQAAAAAmeQAAKHkAAAAAAAAAACp5AAAAACx5L3kweTF5AEHKltoACwYzeTR5NXkAQdyW2gALAjh5AEH0ltoACzQ8eT15PnkAAAAAAABBeUN5RXkAAEd5AAAAAAAASHkAAEl5AAAAAAAATXlOeU95AAAAAFd5AEGyl9oACzBaeQAAXHlfeQAAAAAAAGB5YXkAAAAAAAAAAGN5AAAAAGR5AAAAAAAAZXlneQAAaHkAQfaX2gALFG95AACmeQAAqHkAAAAAqXmqeat5AEGmmNoACwiteQAAr3mweQBBvJjaAAsQunnDecZ5x3kAAAAAAADIeQBB2pjaAAsay3kAAAAAAADSeQAAAAAAANh523kAAAAA3HkAQYSZ2gALAt55AEGQmdoACyTfeQAAAAAAAOV5AAAAAAAAAADree95AAAAAAAAAAD/eQAAAHoAQciZ2gALCgF6BHoVegAAFnoAQd6Z2gALCBd6AAAAABl6AEH4mdoACw4aeht6AAAAABx6AAAdegBBkJraAAsSHnofegAAAAAgegAAInoAACN6AEGsmtoACywxegAAMnoAADR6AAAAADV6N3o4egAAAAA6egAAAAAAADx6P3oAAEN6AABEegBB4praAAsMRnoAAAAAAAAAAEd6AEH6mtoACwJIegBBhpvaAAsMSXpMek16U3oAAFV6AEGcm9oACwZbegAAXHoAQayb2gALCl16X3oAAAAAY3oAQcCb2gALAmV6AEHMm9oACwhoegAAAABpegBB4JvaAAsCanoAQfqb2gALAmt6AEGKnNoACwxuegAAAAAAAAAAcXoAQaac2gALAnN6AEG0nNoACyR0egAAAAB2end6AAB4egAAAAB6egAAAAAAAAAAe3oAAAAAfHoAQeyc2gALDIN6AACMegAAAACNegBBip3aAAsekHoAAJx6AACdegAAoHoAAKl6AACteq96sHoAALF6AEG0ndoACw61erd6AAAAAAAAuHq6egBBzp3aAAsQvnq/egAAAADAegAAwXrIegBB8J3aAAsCyXoAQYKe2gALAsp6AEGQntoACwzLegAAAAAAAAAAznoAQcCe2gALTNJ6AADUegAA2HoAAAAA23oAAAAAAAAAANx6AADleul6AAAAAOp6AAAAAOt6AAAAAOx6AAAAAAAA7XrxegAA9HoAAAAAAAAAAAF7AnsAQZqf2gALFAR7BXsGewAAAAAAAAAADXsQexF7AEHAn9oACxgVewAAAAAAAAAAFnsAAAAAF3sAAAAAGXsAQeqf2gALEBp7AAAiezB7M3s0ewAANXsAQYag2gALMDp7QXtHewAAAAAAAEh7SXtKewAAAABMe097AABRewAAAAAAAFJ7AAAAAAAAAABTewBBwqDaAAtUVHtWe1x7XXsAAAAAXntge2F7YntrewAAbHsAAAAAAAAAAG17AABvewAAcHtxewAAAABze3R7AAAAAHh7ensAAAAAAAB7ewAAf3sAAAAAAAAAAIB7AEGiodoACwKBewBBrqHaAAsCgnsAQbyh2gALAoV7AEHQodoACx6Ge4l7AAAAAAAAAACLewAAmXsAAAAAmnsAAAAAm3sAQYCi2gALJpx7AACeewAAAAAAAAAAoHsAAAAAAACkewAAAAAAAKl7AAAAALx7AEG0otoAC4DhB8l7y3vMewAAznsAAAAAAADQewAA1nsAANd7AAAAAAAACADqA4gA9wMEAKsCBApFAYoKfQAHCzwCCQtQAgsLqAILC0oDCwucAwwLZAEMCyYCDQs9AQ0LcgENC9UBDQvXAQ4LjQESC0UAkguRAIYA8QSICxYChgCXBQsAigCMACgABACbAAcAmQYECs4ChwrABAQA9QAFAJcABQDlAgYAewQHAPIBBwBmAwcABgYMANUADgAkAA4AhwERAG8AEgAGABIALgASAJcAEwAkABQAIAAUADgAFABFABQAZgAVAAQAFgAIABYACgAWAA4AlgAfAAQAcAKHANgGBQp8AAUKkAAGCiQCBwoPAAcKmQCJCnUCBgD3AQkASgINANQBDgBCABAAOgAHCvsFCAqgAQkKEwEKCmQACwqSAgsK0wMMClYADgrPAA8KFACPChkABQBbAgcAvAQJADUCDgAtAQUKkwMGCvcGBwrTAAcKSQUJClMACgp4AQoKrwELCh8CDAqYAg0KGAENCqwBDgqAABEKNACRClEABADsAYUAwwGHAEMDjQBGAIQAGwIHC+wCiwu8AgcL7QULC1UCDgtMAA4LTwGUCyEABgBxAIcAtAEEClIBhQqQAYgAzgKFC38AhQuiAQYA4QUHAAgCBgvGAAsKfAOMC1MABArdAAUKkwIFCt0DBwq5AgcKuwSKChwBhwAuBAULFAEGCzcAhwtZBYYA6wUGC9gGiAvWAooK+wEPAE4ABAq8AIcKJQMFCnQDiwrfA4UL/AKGCnUGBgs1AQcLSwGKCyYChwtFB4QLXAGHC9oDhwslBgwAYgINAK8BkAA7AAkLHwOMCqYAhgD6BYQA7gKEADMBhQDEAwYLwgAHC4UACgvtAQoLOgKLC5gCBQsYAAULOQIGCwMABgt3AAYLjwAGC7gBBwsnAQcLVwIHC5YGBws+BwgLqAEJCysACQtIAgkL+AIKC5QACgtIAQsLnwALC/0ACwv6AQwL5wEMCxMCkAshAIgK+AIFCw4ABQt8AwYLGwEHC+oAiAsZAocL4wQEC34ACAt7ApMLIgAECzwBhwsZBgYA5wMGAB4FiQtdAwQLQAAFC2ABBQvQAgYLcAGLC2cBBABLAAUAtAAGAPQBBwA6AAcAxgIKAIUCiAoCA4UAiQIGABQBBwAaAQcAbwMHAJwDCADLAQkAVwIJAPICCwA+AgwAgAAMAO4BDQA0AA0ALQEPAB4AjwCEAIQAyAAEClkABQrpAQYKOwEHCikCBwrRBooK8wCHCxoEBwBVBgYKegYJCgMACgqaAAsKgQINClUADQrJAI0KWgEGC68AiQshAQULsAGFC5EDBgDhAIkA0wAHAM4CCACvAosAdgEECqYAhQr5AQkAbgCGCoYGCAA6AAkA1AILACkDDQBxAJEASAAGAFkBBwDfBJALUgAFC6MDhguiBggA/wIIACMDCQAtAYkAhwOLAMsAhgCCBAcAnQeIAKIChgADAYcA+wQFCwYDBgtlBgYLlgaGC9cGhgDPBAcKvQEICjMBCArAAgoKKQAKCrcBCwrtAAsKbgKMCskAiAD+AAYLBAGHC8wFiwAVAYcKuQcECr0ABQrJAgYLPQKICjkAigpzAYQKKAKGC1gBhQD4AAkAIAMKALUCCwDiAQsA3gILABUDhgvwAAQAdAAFAF8ABQC9AQcAmAYIAB0ACQAQAQsA/QELAJMDBAskAQQL4AIFC2cDBgurAAYLmQYHCywFBwuYBwkLnwEJC0QCDgvmAJILRAAHAOoBDQBkAI8ASwCHAGkGhQAfAgcL0QAIC5UCCgsqAAsLOgAMCzoADAt2AI0LIAAFALUACAApAAYLPwCHC5gDhQCRAoULGQOKAMUCBwAZAAgAygCKABgCBQuZAocK/AaRCjEACQCnAYwAWQAFC0MABgs+AAYLdgGHC28FCABxAAkAbQMKACoCCwBTAAwAiAATAG0ACQsWA4wLLwCKCpUCBADDAwoAnwMOALoBhwqZB4UA0AOEAM4ABAuHAYcLkQSGANIHBgC4AoYA8AOGAJIEhAsPAQcADQAIAOIACgAZAgsAOgILAF0CCwAfAwsAJAMMAFUADAAEAgwAbwINAHAADQBpAQ4ATQAOAE4AEQAcABMAbgCMCzoBhAABA4YACAYEACcCiQCmAgUKVACGCqMACQA5AAkAywEKAKkBCwB3AAwAuAAMAHMBDQBmAZEAMwAFALwABQAuAwgACgAJAKUBCQDZAgoAYQILALECBAv9AAUKmgEFCyACBwssAYkLVAGGAHACigtBAYcAlQcSAIIABQpCAQgKugAJCgYBCgq7AI4K0AAFCzUABQsdAgYLXgAGC/MBBwvmAIsLQQGFCuMABAB6AQQLmAMFCxkABQsWAwYLyQGHC1UDiQANAYQAEAKGAHoEBwpzBQgK5gEJCuwACQpuAwoK2gALCl8AEwoRAJMKHwAHCvsHCAqgAo0KwAGGAFEEhgBQBoYL5QaMC6MABQqcAYULNgOEC3oCBgCQAoYLwgaGAJQHBQBoAAYArQCHAF8GiAoyAgYLJAAHC5ICCAvGAZMLVgAFAMkBhgrrBgcAKgMIAIoACABWAQkAVAAKAMEACwBzA4wAZwEJAGwChwqmBIkKhAAHC88DiQsVAwYAXwAGAI4HiADHA40LTwEGAJYBCgCZAQoAvwELACwAjABkAAQKPQGHCv8EhADdAYYA9AQGAJUHCACwAwUKPwCFCv0BhAB1AoQLaAAEAPYAhQB3AQYAZAaECiABhwtOBgkAMQAKAAYDCApZAAgKbAILCnQCDApCAY8KfAAEABoBBwAKBAsAjgELAHoCDAABAAwATwAMACACDgDtABEACgCSABQAhAA4AwcLLQAJCx4CCQs2AooL2AIFAHYABQDzAQYA3AEGAJkCBgCYBAYArAQHAFgCBwB4A4cASAQHACgBBwBUAggAMAIIAEoCCQBkAgsAMAEMAC4ADQBZAA4AcACRAHoABQB+AwYA7AYJAPEDigp4AAULFQIHC/MCigsMA5cKAQAGAMIFBwtXAI4LIAGLAG4BiQrNAQcL3AMHC5MHCQtAAAkL9gEMCwcADAsiAA0LDAANC+oAkwtNAAcAPwYHALsGCABPAAgAagAIAL4ACAAuAQgAfwEIAMkCCQB3AAkA6QAJAKMBCQDXAQoAtQAKAJYBCwA5AAsAVQALAHgACwCxAAsAKAELAH4BCwDGAQsA9gILAOcDDAAbAAwAYgAMAIMADAD1AAwAOAEMAL4BDADGAQ0AGQANAGIADQCqAQ0A/AEOAEYADgCjAA4AEAEOABUBDgByAQ8AXwAPAIoADwCnABEAJgCUAGAAhwpCBQoAyAATAAIAlwAWAIcLjQCGClUAhgDfBooAdAGRABAACACvA4QLawKLC1gABQv2AAgLvQAJC2MBCQsAAgoLfAAKC8UBCwuPAAsLoAELC1sDjQtVAQUAAgGGAM8CBgAGBwYALwcIAIQDCgBqAwoAdgMMALoCDADcAgwAAgMQAGoAEgCjABIAqgASAKsAmAAUAAkAwwILAEYBCwBTAQwApwEMAPYBFAA+AAkLwwILC0YBCwtTAQwLpwEMC/YBlAs+AAUAHgAHAO8BCACGAAkAFAOMALYBhQumAgUKFwEGCusABwrUAQgKvgEJCn0CCgrNAgsK4gKMCgICBQsjAAYLHwEHC14DBwteB4oLswAHAJwHBwDUB4QLBQIFChEABgpzAYkKEAIEAHMABQCdAgYAlwEIADcBCwAKAI0ABQCJAH0BBQAyAAYAtwEHAAwDhwAQBIgLmwILC5MBkgtTAAUAAQAGAFEAigAIAoYA4gIFAOIBCABiAAkArAAKAGgBCgC8AgoANgMLAC4BCwAKAwwAMgAMAH8ADACMAQ0APgANAEgBDgB6AJMASAAJC50ACguDAIwLSACHC8oChwsbAgUAAgAGAAACBwAdAwcA1gUIAP0ACABNAgkATQAKAAEACgCBAAoA4QALAHYACwDiAAsA+wALAK4BCwC9AgsAzgMLANYDDABAAAwABAEMAOgBjACyAgULigEHC28BBwvnAQcLWQMHC7EGCAv2AAkLGQIKC6UADAvbAIwLMQKIAC0CBQoLAwUKJwMGCncGhgqMBgQKxAAFCi4ChQq1AwsLOwMMCzgADgsiAI8LlACJAFsBhQA8AoYAQAMEAAwABwD4AQcACgIHACkDCAAdA40AWAAECvAChQvBAQcLVgAIC2cAkQtFAAcL7AeKC4ECBQAQAgYLAQCOCwIAhgBdAwoAJgEECuMABQqfAAUKmQEHClAACgrfAQwKogEOCjIADgr5AI4KJwEHCr4FCApCAAgKiQAICvkCCQp+AgsKUAALCtQACwpwAQsKogEMCggADQoPABAKPQARCjsAEwocAJQKVAAUAG0Ahwt8BAYLFQEHC/oEBwtqBQcLcAUMC4EAkgtXAAYLuwAHCycABwuzBAgLfAEICx4CDgt1AJULHACGAKMEBQAKAQkAIgEJAGwBCgAlAQsAXgKOAC0ABgspAQcLGQOLC6oDBAAyAAYAUgIJAHkACgAxAAoAnAGLAEIDiADsAgcL0AEIC7YBCwtpAAsLawEMC+cADguCAQ8LZgCUC0sAhADSAQ0AjwEOAFEBBgomAAcKxAQICrkACAoAAQkKFgAJCksBCgriAgsKzQALChwCCwrqAg0K0QGOCsIACQB6AY0AogCJAAcCBAqfAAYKcwAHCvwABwoBAQcKiAcICkUACQqAAQoKWwAKCmcCDAp3AQ4K6wASCnUAkwp7AAULXAIFCo8DiAoWAYQAmwIIAF8BCQBCAQQKlwCHCh8GhgCGA4UK3gMMALQABQrCAAcKfgaJCloABABlA4YAzAeGAC0DhQqpAYkL+QKEAAQBhQrLAwULFAAGCyoBBwuTAgcLVgWJC9sABAAnAAUAJAAHADMHCACXAQsAkACMAAsCBAD+AQoASwKLCvACBwAdAAcAQgAHALwHCgDnAYoAKQMNAAQBDgBSABIAPwCJCpYCBQpIAAYKCAEHChUABwouAAcK3QcICtcACAoBAgoKCgGLChYAhgA6AgYANQIHAIMGBAu3AQoKXwALClsCDAvyAA0KuwEOCqAAjwoEAIYAuAWGCq8BCQB0AQ8AAgATAAoAEwASAAUKagMGCo0GjwoAAIQAEwMGAHwBDACPARUAEwAHCqsDBwqUBAcKhwYJChwCCgq4AgsKCQELCtwCCwqgAwsKqQONCrYBiQDIAIQL6QCEAAQChgtBAoQATAMLAHcDDgBtAY4AdwGEC+IBCAA1A4wALAAHAHcGiAAxAQUKqgKHCl8HhwtaAYQKuAIEAAoABwCVA4sAEgMFCxsDBgvNBggLoQGJCw4DBAD4A4YA7wcFAKwCBArWAoUKdgIGAP0DhgDIBQgKIgOICkYDhgAbAIYAiwGHC24CBwtxAocL1gYEC8sAhwuQBwYKdgAHCtcABwrxBYwKCwCEAC0DiAD/AQcKZwKKCvsAhwoUBJEAOACFCuEABgBWAQYA8AEIABMBiQDOAAQAjQOFAKwDhAB7AwcLNwEJCzQBjAv/AAQKcgEFCvQChwouBQQArwKGADwGhgA+BQYKfgYHCjAACAoDAwoKdAANCmgADgppAA4KuAAPCqgAEwpcAJQKRACKCtEABAuQAQULCwGHC+gAlwsMAAYAKQCNAKAAjQs6AYYAtgaIAAoDjgsFAYYASgaFAHMAhAAmAQ4AOgGECngAhADXAwUAwQCMALIAigqtAQUKNAOHCqMDBgDiAwYAGwQGAJ8FBwCuAIUL3AIEC2QABwunAggLOQGKCscABgqXAAYKiwYHCn8BlwoKAAYABAcIAFADCABjAwgAiwMKAFcDjAC/AowA3QAEAHoABQAcAwUAuAMGAHwGBgCHBggANwIJAK8CCQDmAgoArgILAKoCCwCNA4wAGQEFC2oBBQu7AQYLPgEHC/sDiwtvAgULzwGICygBCwBHAg0ABgEGClgGDAqmAY4KaAEFALMABwBHBIcAvQQECisABAvGAQUKWAGFCmUBBABCAAcA0gKHAIgDhgAFAwcAYAGFCngDBQswAAULlAEGCy0CBwvKAQgLVQIKC8cBCgteAgsLMQALCyQCDAvcAQ0LEgCNC8IBhguiAYQKxwIFC7oBhwvAB40AIwCJAJgAhgCtBIcLRQSJC8sAiQq4AQoAUAIKAPECDAA9AQwAYwEMANEBDADVAQwAMAIMAEICjQDzAIUANAKGAB0DBQq+A4UK2wMFCzcABwt4AYwLoQCFC8IBhgAsAoYAMwMLChQBjgolAQcAIAKKAD0ACADPAgQKQQAFCt8BBQrsAwcKeQcICj0BCQouAQoKZAKNChYABAAFAAUA8gEIAH0CCQAJAgQL1QAECgUBBwvfAAcK/gGIC1AABQCfAwcAZQAECiMBBwt9AQcLJgMHCzQDCAtiAQgLtQEICxMDCQoDAgkLkQIKCzoACgtTAQoL7QILC5IDDAqYAAwLogAMCrsBDQtLAA0KiAEOC2oADgvGAA4LQAEOCmUBDgudAZILKwAGAIEEBwChBYgL6wIEAH0DBQAMA4UAfQOKC44ChQu0AoUA7gCGC78ABAqCAIcKSwMGABAFBQoqAAUKbwMHCvUABwpEAQcK/AULCs8BCwrYAQ0KawGQCjQAhgDBBgYAzweIAMkDBAqGAIUKdAEEADwABwCtAwcACAcIADoBCQC8AosA5wGGAHgEBguiAAcLqAeICz8DhAvCAocAewSKC6oBigtZAAcAPQeKALUBiACjAYcKYgaFADwDBQAmAwcAsAAHALIABwDYBAcAuAeECoQChwtVBwULpAGHC6kFBAAzAAUAJwAGAAQABwBPAgcAUQMHALcDBwBNBgcA4AYHAMQHCQCyAQoA8gILABkAiwAlAAoLOQCKCxUBhwocAoQLzACHAJ8AiwvnAIUAhgMHAKADBwtuAQkLHwEMC8cADAssAowLQQIGCm8CiAoVAwQKjAMFCmcBBQr8AQYKuwYHClcBBwrMB4cK6geGAA4BBApVAYcK4AEFC2QBhwvgAAsLTAILC2ADCwvIA48LoACEACwCiQAhA4QAoAGOAHQBBQCYAAUAxQAHAFQBBwBjAwoAJAIKAEUCCwAGAAwAAwAMABMADgBuAI4AIQGLAHEBBwt2AgkLNwILC5YACwu8AY0LdwCGCxsCBwrLBwgKKwELCnoDjAqiAgcAIgAHAL4ACAAcAAgAjQAIALwBCAArAwkA1AELAE4BDAAYAAwAggGMAEAChQD1AgcAEQaIAIIDhQDRAogA9AMEABUDBQCHAocATgSEAIIDCgC3AAQK7gAFCvcBBgqzAAcK0wcICn0BCArZAQkKlQAKChQDDwotAA8KVgAUCm4Algo5AAkAiAATAGsABAp5AAUKnAAFCl0BCgpdAo4KVgEEC+sAhwv/AAQLwgAFC0gCBguAAQcLRwIKC/kCCwv4AosLUwMGClAABgqeBgcKrQAHCrYHCQojAgoK2gIOChIAlgonAAQKmwOGCq8GBQAVAY0A9wCEALMBhQsyAoYAHwUFC78AiQsPAYQKUwIHCwEGDgtgAI8LSQAFALUBBwD2AQcABwIHAGIEBwDXBg4A0wAGCssBBwrZBgcKDQcICpICCQoBAAsKvwONCr4BBgAuAwQL1gEFC9kBBguZAAcL3wUHC4MHCgu9AgsLhAALC6gACwvjAAsLQAELC7QBCwsNAgsLVwMMCykADAseAQ0LZwANCxwBDgv/AA4LBgEPC3UAjwt/AAUACQEGANQAhwAcAIoA7gKFC0cBBgsoAgcL2gaJC1wChgDcB4QAvgIFC1AABguVAQcLkwEHC94FBwtaBggLyAEJC+cBCQtVAwkLeQMKCzUBCwvRAgsL4gMMC64BjQulAAUAKAOHAP0HBQCmAAgA4wKMAP8BhgrqAQQLxQEFC3cDBgsXAggLBgCICx8CBAB3AAUAqgAFAL8BBwCsBgcAYQcJAGUBCQDPAgwA5gGMAFQCiQD0AQcK+gCICvsBhAqeAAYAKQOGANwFCQBHAQsAXgELAD8DDQBgAQQKjAAHCmoBCArRAAkKCgAJCvcBCQpmAgoKsQILCkcBCwrVAgwK/AAMCkcCDQrAAA4KDQEOCmQBlAoyAIcL5QIEAMIBBwCGBBMKAQATChoAlgoJAAYAVQKHACYFhgBCBgYK5AAHCj0FCQqYAYoKVwEHAF8FBwC6BYoASwGEAPIChAotAgULZQAGC1gABgsfAgcLjQYJC2QACgulAg4LqQAOCy4BDgs5AQ8LMACPC1QAhgBYBQQLNgEJCxsDCgvdAgsLwwEMC/kADgtzAA4LHgGPC2QAhAokAgoALQIHCsUACAqOAAgKRQEJCpYACQpUAgoKYQELCkoACwo7AQwKlgIMCqkCDgqnAY8KjQCFC0sCBQBSA4gAHwMKAIwDDAC9AgwA9QKOANIBBAA+AAUAEwESABMABgqPAQYKQwIHCrQCBwpOAwcK9wMHCgcHCAqTAQkKigEKCoUADAoEAAwKKQEMCsQBEApRABIKGQAVCg4AFgoMAJcKEgAMAMsBBwoKBgsKKwGOCpcBhAqxAIQL8gEHC9kACAuMAIoLYgIFCpsBhwqNAoYACgcHCrcBCgrXAgsKBAGLCqwChQuJAwsLRAKOC8kAhgB1BQUK0AAHCvEChwr4BQcA7gAHAPEHCAB4AAgAvAAIAJMCCQBWAgoA0gEMAFYBDABMAg0A9wEOAPYAjwBcAIcLEQQEC8gBBwtpAAcLZgEHC2UGCAuDAosL4wEGACYFhgAsBQQAyQAHANAGCABaAgsA9wALADoDEQBBAIUK8gAIAKQAkgA+AIUKuQOLCiIDhQBnAgcLHgYICw0BCQvUAAkLzgIOCw8ADguEAI4L4wCFCiIBhAp8AQUKNAAHChUBCQpwAYsKFwOHANsEhQsbAgsLlwONC5kBiADIA4UL1gGGAHIDhACLAwUAZAAKAEkBDACgAZUAHQAKCooAiwrcAQUK1QIFCtcCBgtbAAcLswGHChMHBAsQAAULPAEFC0oDBgtyAQYL8gYIC6YACwssAwwLzgAMC18BDguiARALDwAQCyIAEgsDABMLAwATCwcAFAsEAJULFQCEALAABQB8AgUA5gMHAAkABwDkBQgAGgAJAD0BCQBmAQoA0gAKACQBCgAVAgsAKwIMAA4CDABfAg0ABwENAMsBjgAPAQYAAAEIAAkBBAomAAcKMwEHCucDBwrJBQcKxAYHCsoGCQqeAQsKPAEMCjQADQqkAZMKZACHChAFBAtjAoULXgIEAIMCjgsVAIULywKFCtMCBgBiAocLVQIKAH8AjQAbAAYAywcGANEHCAB3AIgAzQMEC5UAigtwAQwACgIEC5oABQptAAYK+AYHC24EBwpnBwgLaQAMCigBjAouAQQLHwAGC60BBwvCAwkLygGLC7MCCgApAgsAbAMNAMEADQCnAQ4ApgATAFQABAs4AQUK2AAHClcHCQqNAAkKDgEJCqcCCgqfAAsKxQAMChoCDAovAg4KkAAOCqcAjwpDAIYALgYHACoGhwsqBokKUQCEC+wAhgqHAYYAGwMHCkIBiAr5AAULRAMFC1kDBguQBgcLOwCTCzUAhwCwAQoLRACLC+4BBAtRAIsLYwMHAH4AiABUAI4LGAEFCxoBCAuKAgkLJwEJC4sDigu7AYgAFgMFCngCigoOAgYAQAAMAHkBDQA1AQ4AjQAOAK0BDguNAI4LrQGGAPkFBgBBAQcAQQcJABICEwBjAAcKtAMHChIECArrAAgKzQEJCsUBCgpiAZEKTQAHAFAECwANAQsAGwILAHMCCwDCAgsAzwMMAPgADACyAQwAWAIMAG4CDQApAQ0A5QEOAEUADgCZAY8AbAAECmoBBwo0AAcKLwEKC0YADAsaAA4LEQAOC7IADwsiAJULDAALANEDjQD7AQkAIgCLAOQBBQrEAAYK5gEHCtQACAo1AYgKWgEGAKQGBwAaAAcAJQEHAH4BBwACBAcAPwQHAOsHCAAYAAgAcgAIAPwACADXAggA2QIJAB4ACQDHAAkA5wAJAPsACQBOAQkAaQEJAMgCCgA3AAoAPAAKAOgACgBMAQoAgAEKAIwBCgD4AQoAHgIKAIwCCwAUAAsAMAALAM8ACwAjAQsAKgELAFYBCwBtAQsAigELAGwCCwDBAgsA+QMMAHsADABUAQwAlgEMAIMCDQA9AA0ADQENADcBDQA/AQ0A5gEOAOoADwA+AA8AVQAQAEcAEgB3ABQAaQCHCngHBAtHAAULeAEHC3cAiguZAgoAlgMKAJ4DBAquAogLNwCKCnECiArCAoQL3wEECh4AhQorAAYAewEHAA4BCACwAAgAtwAJALABCQCVAgwA9wAMAGkCEgB9AAcLXwIIC2MAmAsEAAUAGAOFAIQDBAtkAoULMQIECykABArcAAULSgAHCv8FBwtbBgsLZwOMC2sChwCABwcLXgALC0kBCwvFAwwL8QAOC2IBDwsWAJQLPwAJC9EAiQssAYYAAwOHALsHBACFA4UACAOOAP4AhQtiAAkLEACNC4IBhQvYAwQLtgAGC80AhwvcAAcKvQYHCu4GigqJAQUKBwGGCp4BBAsqAAkLzQAJCxIDiguTAg4AjACUACkACAC4AQoAZwEGCrIABgshAQYK1gYHC4YGCQqyAgoKmwAKCnUBCwq6AgwLOQANCpsAFApdAJcLBAAEACUABQBOAQcA5QSXCxkABAD8AQQLewIFCmEAiQqJAYsLFQIEAIAChQABAoYKZwaEC3MBBAsQAQcLRAMHC3MGkQtZAAULOQMGC7wBBgtoBogLNAEECr8ABwqmAwgKhwKRCmEADAD2AA8AogATAEAAFAAIABQAXwAWABgAmAARAAQAFQIFCqUACQpaAYoKjwIFC+ECiwp1A4UKbQMICoAAiwqzAIkLMwGMAPAChQCYA4cAGAQFAJkABgBEAgYKfwYHCoQABwqCBAcKhwUHCuMFDArtAQ8KaQCXCg8ABQrLAQcKMQQICvEAiApOAYoAhwGHAKAHhQsNAggLgQILC4QBjAtEAo4AfgCGAIAChADjAQcAUAYJAEUABgpEAQYKCAIHClIBBwrBBggK5ACLCu4CBQvtAYYLEAKHAN4CBAuuAIcLjwOKAOABCQDvAZIAaACHCsECCQDYAQQKSQAGCmQCBwqfAwcKMgUHCh4HCArZAAkK/QIJCv4CCgqYAQsKMwALChkDDAoKAQ8KngAUClkAlgogAAcLJAKJCzoABAsgAAUL1wAGCw0BBwv2BgcLZAcKCxAACws2AwsLugONC+EBhABqAwkA5QAFCoUBiAp8AgcL1QaIC90BhgC0AwULNAGHC0AEBADsAosA8QOIChUABgArAocA5QEFC34ACAspAQkLbgEJC70BDAs1AAwLdgGNC+wBBwsPBosLaQGIAMEAiADYAQgAjQINAF0AkwAOAIQA2AOEC68ABQCsAAYAsweEC60ClQsIAIULHQMNAFMABQq9AAcKugEHCrsBCAoZAQwKrgCNCgUBhgAgBoULNQKLAIABhQAEAQcA9gIHAHADBwBPBQkApAAJAKcACgCcAAoATAIMAGUADgAwAA8ARgAGCgIABwruBAcKyQYIChYACAoOAQgKZAIJCjgBCQq0AQoKNwEKCm8CCwpIAAsKSgELCscBDApBAQwK+AEMChICDAofAg0KEQANCpwADQpOAREKPACUCkAABAv8AAcLLAQKC7IBCwvkAAsLqgENC+cAEgtqAJQLVwAHCmIBCgqaAYsKLwMGAG8BBwqeAgcKLwUICpsBCAqzAQkKjQIJCuQCCgqBAQsK3gALCkQBCwo9A4wKYwIHAJYEBgqmAIcKdgGSAHkAhAA8AwUL5wCKC/0BBwtZAgkLFQEJC6ICCguyAAoLAQEKC6IBCwsTAgsLIAILC0kCDAtxAAwL2wENC2MAjgusAYYABQaHC/MGBQBXAYYKjgGHCjIAhwuTBgQAuAEHADkACACnAAgAdwEJAFIACQAxAgkA6AIKAGwCiQvoAoYAngMGCgUCBwqHBAoKbQKLCsAAiQA7AwgAwgCIAPQCCgrfAIsKhQIHCkAAiAr1AAQLjwEFC3cABQvuAQcL7wKJCywChAAoA4cAFgAHCuMGjAo2AQUAfwIHAOEECwCAA4YLSAKGAE4GhwBcA4cLYQQFCoEABgo9AIcKswMEAGYABwAvAwcAowaLAMQDDQr5AY0K+gGLCugDhAunAoQAgwOEADkCBQu2AokLygKIABsDBgD9B4sLBwAGADQACQBoAAkALwIMADQBkwBXAAQALQGEAFwChQp9AogACwMFC48ABQsBAwYL4AYHC6oCBwvIB4gL4AKJCk4CkwAgAIkLDwIFChgBhwrKBIYA7gEGAKUCBgCqAoYAFASFChkBhwooBAcA/AGFC1wDBgumAQcLAAAHCwgGCQtBAgsL3gMMC40ADAvFAQ0LLwCNCwoBhgD2AwULAwKJC4MAhgC9A4QLhgIGADYBBwA5BwgASAAIABABCACvAQkADAAJAHgBCgAzAgoAdgIKABwDCgAqAwsAbwELAFcCCwCuAowAoAIHADoCBAuMAQcKeAAHC9gCCArpAQkLdQAJCj8BCgo0AwsK7AMMCnsBDAqnAg0KdQANC8oADQqcAQ4KGQAPCjQADwqhABAKLwAUCzMAlQoCAAYLeQAGC3wABgtlAQcLcgQHCw8FCAuiAIsLjwIIAMEBBAqpAwUKIQOIC8EBiwu+AwYAtQAHABkCCABAAAkAfwAKAPABDAD+AY0AgAGKC/0ABAD0AIcA6QCFC+0AhAptAQYAcgYKAL4CiwD1AAUKBwCLCgYDDQDPARQAMQANC88BlAsxAAQK3gIFCpYChgquAQQK6gKHCkIEBQpoAYgK7QCJAFIBjwsKAAcLOwKKC24BhgD/BAkLAQIKCxYACgsnAAwLegCMC7sAhQCAA5IAsgCGALcCiQAoA4YLSwIHC2sABwtGAwgLJgKKC5EBBwBdBIgAGwIEChUBBQpgAgYK7QEHCskBjAqAAYULAAMMAAEBBwobAIcKPAGMAOsDBADPAAUASgIFAKQCBgDAAQgA9AALAAEADQADABAANgARAAQAEgANAIUKKAIECpEBiQoIAQUABAIHAFsHhwtbBwwAwAOEC34DBQAEAAUAKgMGAA0ABgAaAgYAmgYGAL4GBwDzAQcAGwcIAJQACAC4AggAFwMMAH0AjwAJAIcA9AQLAB4ADgA7AQkKHwIKCgwCDAoMAhAKEgAUChoAlApBAAYA7AIECs0ABQpvAgcKaACICgcCCwAeAosAVAOMAAYAhABQAwcAaQULAEYCCwCKAgsAhQMLALUDDADoAAwA7AANAJ0BDQD1ARIAdAAHCkMCCQopAAkK9AAJCp0CCgoFAAsKXQMLCrcDiwrUAwQAsQMGABMHBgA1BwYAPQcGAEIHCABeAwwADgMMABQDEgCgAJQAdQCECs0CBACdAwUAIwMIALoCigA8A4YAiAWEAGICiwDgAwYAbgOGAMUFhwA3B4oLEwKJCxsChgsQAYUAfwGGAHwFhArpAQQLCQAFC4AABwtwAQsL4AGUCwMAiADaAwkAlAKKAFsBhwp8A4gLqgIHADwCCQBQAgsAqAIMAGQBjAAmAgcAgwWKCw8CBAsCAAcLIQKHC34DiQrZAQsAQAAHC+EBBwozAwkKGgAJCogBCQsYAwoKmAAKCuIADAoUAQwKqgEMCk0CDQrMAQ8KYQATCjAAlApoAIcKMwCIC70BiAuGAocAXgKECqICBgAlB4YAJgeECgIDBQpPAAcKAwQHCsUFiwo0AAULEgKOC3EAhgqCBgcA7AKLALwChgrDAIUKFQMJAFcACgBtAQQK+wAECrACBwoBAocKBAWIC28AhQB/AAYAxgCMAFMAhQssAoUKeQMECqAABQpKAQcKmgWICq4ABQAUAQYANwAHAFkFigBgAwgLEACMCzgCBgDYBogA1gKHACoEhQD8AgYLugCJC6oBCwCrAosLqwIGADUBBwBLAYoAJgKFCnYBBgC8BAYAPAcHACYECABqAwgAcgOKAKgDhAtJAoYAVAUHANoDhQrbAgYA0wIGAIAFigB9AYcAJQaGAAEEBApyAgUKggIGCqkBCgrKAIsKjQAEC10ABQv8AAYL5QAHCyMBCQsmAosLhAKJC+0CiQuiAIQLfQGHABcGBgDCAAcAhQAKAO0BCgA6AosAmAIFABgABQA5AgYAAwAGAHcABgCPAAYAuAEHACcBBwBXAgcAlgYHAD4HCACoAQkAKwAJAEgCCQD4AgoAlAAKAEgBCwCfAAsA/QALAPoBDADnAYwAEwIGAJUChgDtBYgKQwOXChEABQAOAAUAfAMGABsBBwDqAIgAGQKLAB0CBAB+AAgAewKTACIABAA8AQQA7wGHABkGBAu7AAULuAAFC7ICBwtNB4oL9AKLCw8DBADmA4kAXQOIAPEDiwskAQULFQAGC00ABgudAAcLzgMHCxUFBws7BQcL0gUHC1EHiQt0AgcLAwUJC+MACQvzAQoLVQELC0UBCwuYAQ4LtAAPC5AAEgsvAJMLMQAEAEAABQBgAQUA0AIGAHABiwBnAQUKgAEICscBjAowAAUKCAGGCrgABwApBgoAMAEKACUCDABtAQ0A3AANAPAAjgAhAIYAUwSGAKEDhwB2BAYArwCJACEBBQCwAYUAkQMGABcBBwDbAAUKeQKHCisFBwARAwcKZwEICvMAjAqvAIsAUwKECmkACAuOAQkLqQKLC3gCjABQAAUAowOGAKIGjgvxAIYLFACGACsFCwAOAgsAqwONACIBBQAGAwYADAMGAGUGBgCWBgYA1wYIAC8CjQBtAI0AfwAHAI8ECwCmAw0AhwERAEwAhwvFAocAwwMGAAQBhwDMBYYAPQIECvYCiwutA4cKcQaRCyQABAAkAYkARAIEAOACBQBnAwYAmQaHAJgHBwuxAwsLyQKLC+gChgCMBIcLqQMGAIIHCQDWAw8ArQAPALIADwDIABIAvQASAM8AFQAvAIcLdAYHAJ8GiwqAAAYAPwCHAJgDhQAZA48LhgCFCpYDBQBDAAYAPgAGAHYBhwBvBQkAFgMMAC8ABAtDAgUL4gAFC0MBhwvAAwoLEAONC78ABACHAYcAkQSJALsBDQvoAJILIwCEClQBhAAPAYkLOQEFC80DiQuTAoYAdAQGC4cAhwuYBAQA/QAFACACBwAsAYkAVAEHAIEDBQrZAwcK/QGRCmAAigvfAocKfweKAHoDBQAyA4YAYgQFADUABQAdAgYAXgAGAPMBBwDmAIsAQQEEAJgDBQAZAAUAFgMGAMkBBwBVAwgAFAOOCx8AhAr3AIcLOgGEANQBBwDzAAYKUQEHCu4BCAobAAgKVwKKCpkABAq4AAUKhgEHCmoCBwqwBYsKxgKGAGYDhgDWBIYA5QYKAFUDCgCvAw4AtQEOALcBDgC7AQ4AvgEOAMQBDgDVAQ4A1wEOANkBEABdABAAZgAQAG4AlAB5AAQAXQIHAAYCBwACBQcAfgcKALQAiwDaAIUANgMEAHoCCwCUA44AowEGCxkBBwsGAAgLGgEIC+ABCAvzAQkLxgAKC48ACgupAAoL0wAKC6EBCgs+AgsLkwALC4sBDAtLAAwLlwEMC2ACDQv0AY4L+wCGAIIDBgAkAAcAkgIIAMYBlgswAIULogKHC/AGBAujAQoK4wALCvEBCwrFAowKnwEGCmgBBwqABogK3gGJACYDDAv8AQ4LZgAOC+IAkAs5AIcLYwQEC4oABwv0AwcLAAWJC0wABQsdAIwLfgKICrsChgAuBYQAaACHC98ChArjAoYAMwUHAAQBhwsEAYcLJwQHAC0ACQAeAgkANgIKANgCiQplAwQKQwAFCqYBBwoNBAcKCQUHChMGCQrlApEKbACLAAcBhgDsBQ4AkgAPACoAEAAXABEAVgCSABEAigDUAYgA7QMECxEABQsXAAcL4wMLC38BCwu1AQwLzAGMCxQCBwBXAI4AIAGKCmAAhwtyApAKGgAHANwDBwCTBwkAQAAJAPYBDAAWAAwAIgANAAwADQDqAJMATQANAIUACArLAAsKNwMLCk4DDAriAQ0KFQENCi4BDQrQAQ4KzQCOCt0ABArBAYUKzgKHAI0ABgAyB4gAaAMIC0YADAurAI0LEAEECmMBBgo3AQkKAAGKCpQBhABrAokABQEKC+kACgr2AosLTAAFAPYACAC9AAkAYwEJAAACCgB8AAoAxQELAI8ACwCgAQsAWwONAFUBhgu6AYUKOwMFCkAAjApFAgQKugEHChcEBwpIBYcKawaGC60GBQCmAgYAMQEHAAcDBwApBIUK0QMLC0UADAtpAAwLdQANC9UADgsNAA4LPgAOC7EADgulAQ8LEwCSC40AiQs1AQUAIwAHAF4DBwBeB4oAswCIAB0BhAAFAgcL0AMJC5IACgvOAAoLVAINC9oAjguZAIQK/gAGANYADAAcAgQKEwEHCsMEjAp4AQgAmwILAJMBkgBTAAwASgAKC4gCCwufAo8LLgCHAH0AhgrZBoUA+QIGAJADBAsGAgYKcQEGCvYBBwoMBAcLcAQIClwBCQrEAQoKGgALCuAACwqDAQsKBAMMCl8ADAp1Ag0KwwANCs8ADQrxAA4KBAEOCg4BjwqMAAoAgwCMAEgAhAoNAQUK4AEHChQCBwqtBAcKTgUICiMBCwpdAY4KjAEIC7ECiQtfAwgATQGKALYABAsSAAcLkQAHC7wBBwv+BAgLMQAIC5ABCQtHAAkL+gAKC8sBDAugAJALGAAOCyMAjgu/AIcLSAeHADoFlAoPAA4AXgAPAEEAEAAEABAATQAQAFAAkQAFAAwLUgCPCyQAhQvyA4UAwQGFAIYCBwBWAAgAZwCHCpECBwDsB4oAgQKIChUChgABAIsLygMFC1cABws5AQcLTwQKC3AACgtGAgsLhQELCy0DDAuBAQ0LHgEOC3wAkgtsAAYAZQOECwsBBgAVAQcA+gQHAGoFkgBXAAYAuwAHACcABwCzBAgAfAEOAHUAlQAcAAQK0wAECkwBBQpPAQYK7gAHCg0BBworAwcKBQcICkQDCQr7AY0K8gAEABEDBQBwAQYAKQEHABkDiwCqAwcA0AEIAC4CCwBpAAwA5wAOAIIBDwBmAJQASwCFCvEDCABtA4wA2wKLCyEBCgv5AIsL0QCECzEChgBIBoQL+AKGAJUFCQuaAIwL5QEFCuQABgrLAAcKnAAIClsBiQoJAQcA8gMLAN0CCwD3Ag0AIgAOAKsBkgAtAAcKawSHCrwFiAv/AAcAeAYJAHEBCgBSAQoA6gELAJoACwAhAgsABwMNAE0AjQASAYULbQKGAA4EBAtwAYcLgQIGANoHCADTAwgA2QMKALcDigDzA4YA7QMTAHkABQojAQUKPgEHCv0CCQqFAYwKJAIFABQABgAqAQcAkwKJANsABwCgBQsAVgMLAGgDCwCZAwwAJwINANgBjgBvAQUA6gEGAGcCBgBsAocAqwIGAC4EhgA9BosACgKEALcBiACdAgYA/gIGAHcEBgDdBAoKDQKLClIACQtcAJMLWwAGAJwChgDCBAYLDQIJC2wDjAscAYQA6QCIACMChAqmAQUKYwGRCgAABgssAYcL6wUEAOIBiQqJAwQAdgMHAFoBhQtSAoUKYQMFCpIDhgpZBocATgEFABsDBgDNBoUK6gCHCmcFBgtpBogLNAOHAHMBBwshBYoLlAKHCiAFhwBuAgcAcQKHANYGhwBTAQQAywCHAJAHDwAdABAAJgAPCx0AkAsmAAUAUgGHAOgEhwrVBQoAggAGCqUBBwo9AAcKBAaKCvUBBguFAQcLlQAJC44AigteAIkKVQELAKYCDAAzAY4KYgAGCwgABwtZB4gLWwCHAPwHBgACAwYAIgMGACwDBwA3AQkANAEMAP8ABgpmAAcKSAAPCo4AkwpDAJcKHgCHCjcDhwDyBIcL0gaHCk4HBACQAQUACwGHAOgABwsYAAsLHgKLC1QDhwvLBgQL9wGHC30GBQuCAAcLIgUJC2ICCgvOAgsLWQILCzMDCwuyA4wLGAIKC5UACwsYAY4LUAEHAOMCCwCyAgcLmgcICjAACApYAAgKRgIICqkCCQp1AQkKYAMLCp0ACwpLA5QKGwCGAN4DBApYAAUKiQAFCq4ABQoJAwYKgAYGCr0GBwpNAAcKqgEHCiUFBwpLBQgKfgAICjMCCQoLAgkK7gIKCjYBCgpEAwsKKgALCj4BCwrbAgwKRAAMClwADAr7AQwKtAINClEADQruAA0KdgEOCrQBEgqKABMKTgATCm8AFAo3ABQKTQCUClwAjQqiAQcAJweECqoDBgAIA4YAkwOKCl8BBQtcAQYLCgIGCoQGBwrbBQgKdQAJCjoBigquAIcKwwKEAGUChQqTAYQLiAEFC7EBCQt5AosLdQKFAPsChABuA4QA0QOEAGQABgDPAQQKLAAFCjcBBwp/AgcK+gIHCiMHCQoIAAkKzgGUClMAhgvqAAQKWgEHCnMACQq0AAkKyAGKCmsBBQBqAQUAuwEGAD4BBwD7A4sAbwIFAM8BCAAoAQcLjAAHC54HCAuoAgsLMQOTC1gABwvGBIoLggGOAIkAhADGAQcAegcGCwUABwobBAkKIQILC/kADAs5ARALQgCRCxoAhwD3BZEAOgCUCzsABQAwAAUAlAEGAC0CBwDKAQgAVQIKAMcBCgBeAgsAMQALACQCDADcAQ0AEgCNAMIBBQvDA4YL7QaFANkCigtKAgUAugGHAMAHhgDBAZAAKAAEAFUDBwu0AAgL/QGICxgDBgq5AAcKawcJCmsDiwqhAoYLDAIMAOMABApHAQUK3gEHCjQFiArxAgYA0wUFCvwDhQr+AwQKZwCFCpEBhAujAwQK8wGHCo0FBQA3AAcAeAGMAKEAhQDCAQYAlgSGABoGCgA+AA0AkAGHCy0HjADPAIcAZQMECwUDBQtqAokL9AKECmAABADVAAcA3wAIAFAAhwrIAwQLWgAFC1EBBQshAgcL8gIJC7oACgtIAAoLDgMLCwECCwtBAgsLYgILC3kDCwvBAwwLYgEMC2oBDAvNAQwLUwINC08Ajwt5AAcAfQEHACYDBwA0AwgAYgEIALUBCAATAwkAkQIKADoACgBTAQoA7QILAJIDDACiAA0ASwAOAGoADgDGAA4AQAEOAJ0BkgArAIgA6wKIALoDhgAxBIcALAIHC5cACQtJAYsL/gAFALQChgBzBQYKMwKJCuAAhgC/AIQAJAMJC7sACgskABELLACSC0AABwulAAcLlwOICwUCBAv6AQULJwEHC5AGDwsOAJALBQAEAMICBgCiAAcAqAeIAD8DhwtgBQcL2wMJC7ACCgsKAgsLFAOMCzYClgAjAIoAqgGHANMEhwvNBgcLhQEHC7wCBwusAwgLAgIJC3QACQsXAgoLdgALC2sACwuUAAsLmgMMC/4ADAulAY4L7gCGANIEhAvnAgQKjgMFCkADhws3BY0AYACHC7kAkgCVAAQAzACJAIYDBAsQA4UL6QKIAEEDiAC1AwcAbgEJAB8BDADHAAwALAIMAEECBQtRAAcLkgAHCz4FBwumBQgLNQAICzECCAu2AggL8gIJC2EACQtzAAkLfgMKC84BCgstAwsL5gALC5ECCwu7AgsL7AIMC3cADAvIAAwLGwEOCxEBkQsPAAULmAGJC+sCCQvyAYwLtQAGAOQHiADgAwUAZAGHAOAAhgAQAwcAdgIJADcCCwCWAAsAvAENAHcACAoQAokKXAGGABsCBAoUAIUKaAKOABsABwseAAgLVgAICzsBCAu8AgkLQAIJC1oDCws2AQsLeAMLC4gDDAtpAY0L+ACKC0cDhgDzAoYAJwQHCkMEhwrlBoYLrAEHCwwCCAupAAgL6gAJC+ABiguGAosALgMHC7YFiwuTAgQKGgAFCq0BBgr1AAcKwAIHCmMFhwrCBQcLtQSKC30CiwsjA4QKbQKIANsDBAsKAQgLBAAJCycACgumAAsLlgMMC3sCFAsKABYLGwCWCysABADrAIcA/wAEAMIABQBIAgYAgAEHAEcCCgD5AgsA+AKLAFMDhQoeAoYAPgSFCmQDCAD4A4gA+gMHAHQFBwt0BYgKsQGHCtcFigrXAI0KfAAHC50ACAsXAQkL9wIQCx8AEAsnABALSwASCxgAFAsqAJgLAQAFADIChgtcAoYAkQMFAL8AiQAPAQQA1gEGAJkABwDfBQcAgwcKAL0CCwCEAAsA4wALAEABCwC0AQsADQILAFcDCwBpAwwAKQAMAB4BDQBnAA0AHAEOAP8ADgAGAQ8AdQCPAH8ABwDbAQwALQCTCnAAhAs3AokLWwMGAMkCBgDJAwYACgWGAA8GhQBHAQYAKAIGAAwFBwDaBokAXAIEAN8ABgBnAQsAAwANAGwADgBZABAAFgAFC/oCBwtYBwkLqAKLCx4DBQBQAAYAlQEHAJMBBwDeBQgAyAEJAOcBCQBVAwkAeQMKADUBCwDRAgsA4gMMAK4BjQClAIULKgGECocChgDgBxIKCgCSCwoABADFAQUAdwMGABcCCAAGAAgAHwKIADoDiADPAwoAwQOKAMIDigrcAAYAYwcGAGUHCQCUAwkAxQMJAMwDDAAhAwwAWwMMAHMDDwDiAJUAMwCECm0AhwsLAQcLXAAHC7YACAvFAQkLzAALC7YDDAteAAwLhAIQCxQAEAtGABALWgCTCzcAhgrSBgYLRwAHC00DBwscBQgLoACJCz4BBQBlAAYAWAAHAAcBBwB0AgcAjQYIAF0BCQBkAAoApQIOAKkADgAuAQ4AOQEPADAADwBUAAcL7QAIC5gCCQsqAAkLCgEJC3wBCQuFAgoLsQCKCxQBigtFAAQANgEHAMQCBwDkAwkAGwMKAIYBCgDdAgsAwwEMAPkADgBzAA4AHgGPAGQABQBLAgQKKAAKCkMACwp1AAsKAAOLCqcDBgCWBwcAAAKIANcDBwrgAwgKLQEJCtICDAo/AA0KHQAOCqEAjwoSAIgLTACLCpsDhgCFAoYAUwMEAPIBhAslAQcA2QAIAIwACgBiAg4LYAERCzUAEguSABILmAATCwsAlgs2AIYAqAWKC0kDhQCJAwQLXQIHCwYCBwsCBQcLfgcKC7QAiwvaAIsLlQOHCjkDjApIAQQAyAEHAGkABwBmAQcAZQYIAIMCiwDjAYYAGAMGC2AAhwuSBYkLswIEC4sChQshAQcLsAIICyMACQv/AQoL/wKTC3YAlgA4AAUA8wAFABcCBgrMAAoKQAEKCkcCDQr2AQ4KSAAOChIBDgo4AQ4KWAEPCp8AEAo+ABAKRQARCh4AEgoqABIKNQASClQAEgqMABMKRAATClUAFAoFABQKLQAUCmUAFgoHAJYKFAAECi4CBgqGAQcKogAHCrECCQpoAYoKjQKSCxcAhwDUBgUKWAMGCogGBgrdBoYK9QYFABsCBQDyAgYAbAOEC8AChws2BAUKXAAKCuACjApmABEAWwAFCk4CiQrVAIYAHQYGAFsAhwCzAQQAqwOMABgDhgB3BQQAEAAFADwBBQBKAwYAcgEGAPIGCACmAAsALAMMAM4ADABfAQ4AogEQAA8AEAAiABIAAwATAAMAEwAHABQABAAVABUABAvQAoULMgGQAF8AhQuvAYQL6gCHACcCBADnAwYArgeGAPoHBwBrAgoAIwILAHoADABZAg8ABwCUABQABQvQAQYL7AAHCxQBBwu4AgcLkgMHC1QEBwuoBQkLDwAJCzQCCgsOAAwLNQINC8EBDgs1AA8LDQAQC0AAkQspAAYAdAMGAPsDhgB+BAYL5wYMC8IAkQtrAIgK9wGFC0gDBwCfAoYK0gGEAHgDBACVAIoAcAEEAJoABwBuBIgAaQCHANcDCQuCAgsL7ACOC8EABAAfAAYArQEHAMIDCQDKAYsAswIGAIMChgBOBIQAOAEEC0QABQt6AgYLggEHCxoDCAsRAQkLMwIKC2kACgurAAsLXgCLC2IBhQDkAocAagYEC18ABwugAQgL0wCLCz4DhADsAIoK8QAHC9sCDQsUAI8LCwAFAEQDBQBZAwYAkAaHADsACgBEAAsA7gGYCwYABABRAIsAYwOHABsDhQuxAgQA6QMFABoBBgCMBwYAuQcGAMMHBgDIBwgAigIIAJcDCACYAwgAmwMIAJ4DCACfAwgAowMIAKsDCACzAwgAvAMIAOUDCQCLAwoAtgMKALkDCgC6AwoAvAMKAL4DCgC/AwoAxAMKAMoDCgDMAwoAzQMKAM8DCgDQAwoA1AMKANUDCgDYAwoA3AMKAN4DCgDjAwoA5wMKAOoDCgDrAwoA7QMKAO4DCgDwAwoA8QMKAPQDCgD2AwoA9wMKAPsDCgD8AwoA/gMMAL8DDADBAwwAwgMMAMMDDADEAwwAxQMMAMcDDADIAwwAyQMMAMoDDADLAwwAzAMMAM0DDADOAwwAzwMMANADDADRAwwA0wMMANUDDADWAwwA1wMMANgDDADZAwwA2gMMANsDDADdAwwA3gMMAOADDADhAwwA4wMMAOYDDADnAwwA6AMMAOkDDADqAwwA7AMMAO0DDADuAwwA7wMMAPADDADxAwwA8gMMAPMDDAD0AwwA9gMMAPcDDAD4AwwA+QMMAPoDDAD7AwwA/gMMAP8DDgDbAQ4A3QEOAN4BDgDfAQ4A4AEOAOIBDgDjAQ4A5AEOAOUBDgDmAQ4A5wEOAOgBDgDpAQ4A6gEOAOsBDgDsAQ4A7QEOAO4BDgDvAQ4A8AEOAPEBDgDyAQ4A8wEOAPQBDgD1AQ4A9gEOAPcBDgD4AQ4A+gEOAPsBDgD8AQ4A/QEOAP4BDgD/ARAAcQAQAHIAEABzABAAdQAQAHYAEAB3ABAAeQAQAHoAEAB7ABAAfAAQAH0AEAB+ABAAfwASAPIAEgDzABIA9AASAPUAEgD4ABIA+QASAPoAEgD7ABIA/AASAP0AEgD+ABIA/wAUAH0AFAB+AJQAfwAHC7UGBwvpBooLIgIHC2cEBwskBgoLKQEKC6YBCwv8AgsLKgMMCwgBDQtmAA0LLAENC+QBDguTAA4L5QARC0cAEgt2AJMLeAAGAHwEhgAyBoQABwOHCroDhQtgA4ULoAOKC70AhwqmBwYKJQIICiIACAobAQkKpQCKCtsBBQqMAgUKvQKHCsEBhwu3AgQKjwIHClIDEQpLAJIKiQCMC6oChQsLAggAygOICp4CiAsrAgcLTAAICywACQt0AwoLRAILC48BCwt+Aw8LegASC5AAkws9AAYKnwAGCmwBBwoEAgcKnwWJCgYCBABHAAUAeAEHAHcAigCZAo0KlwALADsDDgAiAI8AlACFCwYCBADfAYcL+waHCzwHhwrhAwcAXwKIAGMAhgCoB4QAGQMEACkABQBKAAcAWwYLAGcDjABrAgcAXgALAEkBCwDFAwwA8QAOAGIBDwAWAJQAPwAHCvUBCQpvAAoKjQALCkwBDQorAA0KrQEOCoIADgqfAZEKZgAJANEAiQAsAYYA2QWKC/8ABAumAwULigCIC2IChQBiAAYAJAUKCyQDigtAAwgLYAAJCyQACgtfAgsLpwELC7oBDAs1AQ4LxwAPC1oAkQtuAIQAzwEFCpUAiArpAIUKpwMEC4wCCAtAAQkLDQAJC44BCQvXAgoLSwAKC7gACgvmAAoLNAIKCzkCCwvNAwwLRgAMC70ADQs5AA0LAQEWCwYAlgsQAI4AIwEMCkYCkgqDAIgKIQOFANgDkQt0AAQLtAKFC0EBBAC2AAYAzQCHANwABAAqAAkAzQAJABIDigCTAgYAIQMLC4IAjAthAoQAewIFC1kBhwv4A4sAFQKEAHMBBAAQAYcARAMGAAIFhwtMBAUAOQOGAGgGhwstBYULoQIECx8BhQv6A4cAZQEGANMBiQBvAwcAPQGHADkCBgCcA4YANAYFCyIABQqWAQoL1AIMC7wBDQtiARILIAAXCxgAFwsfAJgLBQAGAAMHBgArBwYALAcGAEAHCABMAwgAUQMIAFYDCABmAwgAdwMKAFQDigCuAwYKRQCHCnUAiQAzAQQAsAMGAAcHBgAhBwoAUAMKAGsDCgB/AwoAgwMKAIYDjAAFAwsAKwANAEgAjQCOAIcKJgeGC34BBAqwAYcKOAOEC0kBBwAcB4sLfACFCjoDhQANAoQLigMHC5QHiAtuAYoLCgAEC3sABAuJAgULXQIHC+UFiAskAAYAbgCHAJEGhQDtAYUL/wIEAK4AhwCPA4oLEgMIAKEBiQAOA4UK6AMHAN0CiQBHAgQKKQEGChECBwqYAAcKyQIHCjUHCArGAggKzQIMCn8CjAqtAgQAIAAFANcABgANAQcA9gYHAGQHCgAQAAsANgMLALoDjQDhAQQLEQEFC5IChQvjA4gA3QGGC0gAhwtBBQUANAEHAEAEBAoIAocKPwKFC00CBQB+AAgAKQEJAG4BjAB2AQcADwaLAGkBBQt1AAYLAgIGCx0CBwuMBAcLnAUIC9wACAuIAgoLsAKLCzAChQuuAgQAsgMGAA8HCABnAwoAVgMKAGYDCgB4AwoAgQMKAJgDDADSAgwA+QIMAPsCDAD8Ag4AxgEOANEBEABrABIApwASAKgAkgCsAIQArwCHABsFhACtAocLKgeFAB0DBgDpAgYAWgOGAMMDhQA1AgUKjQEGCpoABwvEAAcKpAIICrsBCAphAgkKGAAJCkUBCgojAAoL/QILC1sBCwoXAgsLKAILC0ACCwqgAgsLFgMLCvoDDAsHAQwKfQINC/YADQsOAQ0LiwEOC0oADguwAA4LvgAOC44BDgucAQ8LIAAPCz8AEAoeABALWACTC2kADQtUAI0LegAEAPwABwAsBAoAsgELAOQACwCqAQ0A5wASAGoAlABXAIkAOgMEC00CiwsaAQULfQGHCwAHhAAXAwUA5wAKAP0BhQrVAwcAWQIJABUBCQCiAgoAsgAKAKIBCgA7AgsAEwIMAHEADADbAQ0AYwCOAKwBBAo4AAcLaAIHCv8GCApfAggKiwIKC50BCwrRAQsKQwMMClEBjQrgAQcANwaQACsACQqeAIoKmwGHAJMGCAAhAQsALQAMABYBjAAZAgYLeAAHC6QEBwuuBggLHgEJC5sCCwtQAosL2gKICmkChwBgBIcLegSLCjMCBAtgAQQKcQGHC68CjwsmAAQAjwEFAHcABQDuAQcA7wIJACwCDguzAA8LlwCWCwsABAvAAAULMQAGC8gABgslAQYLoAaHC+gBBACOAYUAlAIHAAYEhgpuAocLUwKNAKgAhAuTAAcAzQMKCnACjgoXAYQKawGEAIIChQumA4YATwYHC/kBhwsLAgcAUgIHAFMDBwBCBwkAmwEJAD4CCQCaAgkA4QIKAFoBCgDIAgsA9gALALABCwAFAgsAhwILAKcCCwDXAgwAMAEMADEBDABDAQwA4wEMADwCDABRAgwAWgINAF8ADQBlAA0AqwANADsBDQB6AQ0AqQENANsBDgA/AA4AfAEOAIABDwCFABIAcACUAEgAhwBFBIQApwIIAJEDCgCHAwoAkwMMAIgCDACJAg4AxwEQAHAAigu2AYkAywCGCiQBhgDUBQcAXgUIABwCBQqxAAYKaAIHCjsDCQoNAooKkAKHAM4FCQDKAooKHwCIADkDhgDnBYQLfQKGALgDBAqhAIUKdwIFAI8ABQABAwYA4AYHAKoCBwDIB4gA4AKEALwChgAEBoQLCQMJC2MDigtFAwcAFQaHCpQGhQBcAwYApgEHAAAABwAIBgkAXQILAN4DDADrAAwAxQENAC8ADQAKAQkK1QEJCsUCDAoAAg4KQQCRCgwACwAnAwoK5QALCkkAiwp4AQYLqgAHCzgECAuLAQgL5wELC30AjQuTAAUAAwKJAIMABwBFBgsAwgOSAIsAhACGAgQAjAEHANgCCQB1AA0AygCUADMABgB5AAYAfAAGAGUBBwByBAcADwUIAKIACAD8AQsAjwIECxcCBgouAgcKiwIIC2oCCQoAAAoKIgCLCvADhwvdBIoAZQGWCxcAhQDtAIcA+AYHCigHigp2AYQAyQKECy4ABgAABgoAXAEFCysDBguPBgYLsgaHC/AHCwu2AI4LwwAGAAsCBwDiAgcKAwMHCsMGCQqVAYoKpQEHC7IFCQuXAYsLDwAGCyIABwtFAAcLgAIHC0EECAvEAggL0QIJC2sBCQuDAgoLdAKUC2IAhQCyAYcAVQcHADsCigBuAQUKcQOFCnUDCQABAgoAGQAKACcADAB6AIwAuwCEAEQCBQqOAIYKIgKEC84BiQBpAwUK0gELCjsCDArGAA0KGwEOCroADwoVAI8KZwAHAKsABAq5AAUKAQEFCkcDBQqoAwkKjwEKCgIBCgqLAQoK3gILCvYDDAoXAA0KXgEOCpYAkwoGAIYAcQIHAGsABwBGAwgAJgKKAJEBBQtJAAYLFwCGC1IBBACvAwYAOgcMAMkCjgCyAQsATAILAGADCwCoAwsAyAMMAEkADABXAQwAigENABMBDgABAQ8AoAAHCpQBBwphBQcKlgUHCuEHCAqVAAgK7wAICgACCAoZAwgKMgMJCtoBCQpTAgoKegAKCjUCCgqJAgoKDwMLCu8ACwonAQsKvwELChACCwp/AgsKIAMMChkADAqdAAwKPAEMCoYBDAqHAQwKiwEMCt4BDAr3AQwKUAIMCqgCDQoyAA0KNQANCoQADQrGAA0KQgENCp8BDQr/AQ4KRwAOCosBDwpHAA8KiAARCnsAEgpdAJMKOgCFAAADCwBnAI4AAACICsgChAAfA4QAfgMHC9UCCAvyAYsLDAGHCwYHhwsFA40LaAEECnkBmAoNAIcAiQaEC0cChgAcBIUL3ACMC0UAhAsgAgQKtACHCnIHhgAQAQQAuQGGAI0FBAAJAAUAgAAHAHABCwDgAZQAAwAFC7AABgu1AQYLNAILC7UAjQu3AIQK6wEHAJ4EjQtDAAYAQgUECqsAigrqAAQKSgIHCqIEigp3AogAqgKGAOwDDwAYAI8LGACGAMgDBAACAAYA5gIGABkDBwAhAgcAfgMJCqMDCgpOAZQKRwCIC1gChQr9AgkAAQOMALkABAsWAwULEQGGC4oBBwDaAYkAQgIEC4cABgt/AAcLoQQHC+cFCAtlAgsLBQAMC4UADAvvAQwLSgIOC4EBDwt2ABELFACSC2IAhQqoAQUAEgKOAHEABgvmAAcLwQMHCz0EiAvOAQcLogeJC3wCiArKApULBgCHCq0CCQqkAQoKDQEKCh0BCgpAAgsKjQENCq8AkQpaAIQKrQEFACwCBQuiAIgLRACEC44CBAucAAcL5gMHCxUEBwtEBwkLMAAJC7QCCwujAYsLWgIGACUFCAAQAAkAOQMMADgCBwv8BAgL2gGJC4wCEgBhAAcKEgAHCrsCBwquBwgK8AIJChEBCQqcAQkKvwIKCkcACgqrAYoK/AEKAL8CBwuuBYoLvwIECjUABQq6AIcK8AKGAHwDhgAjBggKPwIKCiEBiwo/AQYAugCJAKoBhgBNBIQKowKEAEkCBgBOB4kAqQOYCwoACQvFAAoLLAEMC9kBDQtaAI0LlQEEAF0ABQD8AAYA5QAHACMBCQAmAosAhAKJAO0CCQCiAAYK0QAICtQBCQrSAAsKJAAMChwADAp2Ag0KFQANCl0BDgoHAJEKDQCEAH0BhAteAgQKVgGHCpsEBwszBgcLqwYKCxACiwv4AQwLJwANCwkBjQu3AQQKoAOFCo4DBwouBwcLugeIC6QCBgD6AgYAHAOGALwDBAo+AQQK8AEHClgDiwqOAokL8gAEC2kBhQs7AYQLzQGEC9gBhABZAwUAFQAGAE0ABgCdAAcAzgMHABUFBwA7BQcA0gUHAFEHCQB0AgcKkwMICvcAkwoAAAQKygAFCn4BBgrGAQcKqAMHCgsHCAr2AgkKdwEJCn8DCgrnAgoKGAMLCtIDCwr0A44KbQAHC2kCCgvyAQsL9QEMCxAAjAuWAAcKfgQHCpEFBwqtBQoL6wKMCgEChQubAAsAlwONAJkBigoXAwoAeQKLC9kCBwujAAgLPwEJC5IBCgsYAAoLqQILC8gACws3AgwL/QAMC5oBjgvbAAUL2wEHC/QGCQvmAAsLKQELCy4CDgtCAZMLTAAHAEwBBgq9AYkKjQOHC6QHiAsSAYYKQgKHANEFhws4BwULsAOGC+kGhAuQAIgK/gIEAEADhwodAggAjgEJAKkCiwB4AogAhQIJABcDCgBdABAADQARABcAEgCHABMADAAUAAEAFAAMAJQADgAGC/cAiQsrAoYAFACEACADhwAxB4sK1wOJCgADhApIAo0LMwAGAMkHBAtsAooLGAGIAAEDCwAiAQsAmQIHCxIHCwtiAwwLZwANC+8BEQtDAJMLSgCGAJIFiwA8AAQKRgGHCuoGBwBSBwkAgQKECuIABgCEAgUKqgEICh4ACQoCAAsKJQKTCnoABQusAYoLugGHC08HhwDdBpMKdQCHAKkDhwB0BgYAjgKGAMQFhQtjAIcADwKEClkBBAqBAQQLjQEHCgkBhwpLAgQAQwIFAOIABQBDAYcAwAOGAM4FCAv2AZALCQAEClsBBQqnAQUK5AOHCjEFBwvXApILSQAEC+UBBwthAQcK6wQHC/MFCQp9AIsKQQAGAEUBBQqIAAYLbgEHC2gFBwtBBogKhAKKC6AABgBBBYkLGgESAFsAkwBGAIgAlAEEC50AhQvXAYUAzQMGAIcAhwCYBAgLdAALCycCjgufAAQAJQIECrEBhQrPAogA0AMFC6AABwtrAQcLTQIKC6oAjQs3AJAAFQCQADMAhwA6AYcKUwUEC2wABwuVAQoL6wGLC/IBkgAEAAQKKwIIChgCCgogAYsK7QOHC+0DBgAZAQcABgAIABoBCADgAQgA8wEJAMYACgCPAAoAqQAKANMACgChAQoAPgILAJMACwCLAQwASwAMAJcBDABgAg0A9AGOAPsABgBFBAYAfQUJCnIBigpaAAQLngOFC9cDhwDwBoYA+AWEAKMBhAsaAgYLJgEHC/MEiAtwAocL7AaKCy0BBAoBAYcK7wcEAIoABwD0AwcAAAUJAEwAhwroBoQL9QIFAB0AjAB+AgcLjwKHCzQHBwCKBQYLAQGHC/IFCAvVAYoLLwCOCxYBBgpTAAYKxQaHCm0FCwvMAAsL8wCMCyUBhwtTBwYArgaHAPYHiQsrAQQAEQAFABcABwDjAwsAfwELALUBDADMAYwAFAKFAF4DiQq4AgYAUAKKALIDigtXAgcKtgYJCl8ACQoSAQoKFwEKCj0BCgqkAQsKLwELCigDDAqGAAwKbwENCpUADQpbAQ4KXQEOCpYBEgoWABIKWQASCnoAkwovAAgARgAMAKsAjQAQAYUKGgCECiYCiQAsAwoA6QCLAEwAhgDcA4YAugGICjYDBwCAAwQKhgMFCikDhgp6AAULlgAHC2oACAtbAgkLUQIJC3oCCgssAAoLrQALC84BCwsDAg0L2AANCyABjguQAYgA4wGHCgYBBgCtBoUKbAIECiIABQo+AgcKFwEHClgGiApZAokKqgCTAHcADAtsAI0LIwELAEUADABpAAwAdQANANUADgANAA4APgAOALEADgClAQ8AEwCSAI0AiQA1AQsLFgGOC0kABwBgAgcA0AMJAJIACgDOAAoAVAINANoAjgCZAIUKTAEGCgUBCAq2AIsKrwMEC+0BkAs3AIYKuQaEAAADBAqlA4UKcAMHCysCBwskBQcLhAUHCy8HCQvAAAkLTQILC/EACwukAgsLKwMLC3sDDAuMAAwLWgEMC98BDQseAA0LMQANC30BDgu8AA8LlgAQC0wAEgseAJQLNAAEAAYChwBwBAYLOAIHC3AABwsMBwgLagEIC5oBCAs+AwkLAgILC4kCjgudAIcLoQIIALECiQBfAwQAEgAHAJEABwC8AQcA/gQIADEACACQAQkARwAJAPoACgDLAQwAoAAQABgAhAtxAowA/AMEAOUDBgCaBwYAwAeGAM4HBgsQAAYLngAHCysABwuBAAcLtQAICxQBCAt5AQoLCwILCzADDAvHAQ0LLwGOC4cAhQosA4YAkgIECwEABwt3BAcLtwUICz0ACQvPAAkLhgEJC9MBiwtEA5YLGgCMAGoABgAjBwoAowMSAKYAFAByAAQKiQAHCpoEBwsnBYcK8AWFAPIDBAvTAgULfwMHCwcECAvHAAgLVAEJC5kACQvXAAoLFQAKCzsACgtQAAoL4AALC+UACwuMAgwLwAANC5IAjgtbAIQLJwEGC2sCBwuCAwcLRAQIC+UBEgscAJMLdACJCzMABgp9BgcKtwcHCtkHhwrbBwULNQGMC9MABQBXAAcAOQEHAE8ECgDQAAoARgILAIUBCwAtAwwAgQENAB4BDgB8AJIAbAAFC30ACAtNAIoLDwCEAAsBhQC/AokLmwCFC7cBCwukAIwLTAAJAPABBQpZAAcKewcJCrkACQrrAAoKQAAKCg4BCgqTAQoK1QEKChECCgpOAgsKjAALClwDDQoBAA0KpgEOClUBDgpsAREKXQASCnEAEwphAJMKcQCFCrcChwBhBAUKBgAGCrcABwqoAgcK0gMHCvUDBwofBAwK5gANCqwAkgodAAQLCAAHC4AEBwuBBAcLswYJC3YBCgveAYsLiAKHC0sEBgodAIsKPwAEADECCgD5AIsA0QCEAPgCBwsfA4oL/wGIC1cACQCaAIwA5QGIAP8AhABDAYwAowGECjcBhgrMBgQAcAGHAIECBwqqAAgKWgAICrEACAqfAQsKygKOChkBBAtFAAULegAJC5ACigvQAQULUQOGC2EGCAAKAo4ASAELClsADQqBAA8KZQCRCn0ABwAyAggAJwIECu4BBgpKAAcKLAALC/MBDAoRAA8KBQCUCgsABAoUAYUKKAEJAFwAkwBbAAQKBwAFCloABQqeAAYKHgIHCt0ABwomBgkK6gEKChwCCwq7AYsK9QIGAA0CBgC4BwgAJgMJAGwDjAAcAQULWwMHCkwCBwuIBAgLawAJCq8ACQsjAQkLtwEKChICCguXAgsLYQKMC8UABwuoAA0LxACNC+0AiwC+A4UAUgKHCkQCBwpYAIgKcwIGAN8BBgAyAgcAJAQNAAYABQpoAwYKOQAHCtcBCQq/AYkKxgGIC50BkQsTAAQLdQAGC3QBBwtxB44LQwEEC9ICiwvXAREAPQAFCh8AhgpmAggKSgGMCt0BBwqwBIoKzAEGCqgBhwpKBwYAaQaIADQDBgAUBoYAUgYJCwUADAvYAAwLJgEMCyoBDAuQAQwLBgINC+UAjwuLAA8LmwCQC08ABAAuAYcA5gYFCg0AhgqOAAYAlAAHACEFBwp0AAgKQgEICvMCCQokAgoKygILCnQDjQpEAYkApAIJC1gAiwsOAQULDAAHC3cBiQu2AYYAigYHCsAFhwoSBgsAsgAHCi8EBwoFBgcK5wYHCg4HCwqiAAsK8gAMCl0CDwoaAJAKLAAGAIUBBwCVAAkAjgCKAF4AjAtHAJEKcwAGAAgABwBZBwgAWwALC8YDDAsfAQ0LVgENC5IBDwtuAI8LowAECwIBiAt/AgYLFgAHC4cDigtBAoULqQKHClcEhwsGBQkAcAAICgEAigpGAQUK6AEGCg8CBwrpAQcKZAYICnkACAqQAAgKZwEJCsEACQrxAAkKUAEJCnIDCwoKAQsKdAELCrADDAqRAYwKgQIEC5gChQskAwYA6wKGAPcDhwDSBgkKHwAKCvQACgq7AgwKlQCNCvEBhQp5AYcAGAAGAEgFBQsgAJEKZQAHAPoFCgCeAA0ADQANAIkADQACAQ4AbwAOAOEADgD9AA4AMAEOAFMBDgChAZIAIQAEAPcBhwB9BgUAggAGAE0DBwAiBQkAYgIKAM4CCwBZAgsAMwMLALIDjAAYAgoAlQALABgBjgBQAYYAeQWHAJoHCACXApAACACGAEcGhwrnBwQLIQEHC3UCBwuiBgcLrwaMC9cABgvCAYgLbQAKAHIDCgBzAwoAkgOKAKADhQpLA4gLwQKECioChQoYAgUAoQEJCk8ACwpxApEKBwAHC9YEjgslAAQAiAGHAD0GBQCxAQkAeQILAHUChAqoAQcKUAGIChEDhgtjAQYA6gAHAAEDCQASAIoAZgEECoADhgrxBooLQwEHAIwABwCeBwgAqAILADEDkwBYAAcAxgSKAIIBiwuMAwsA+QAMADkBEABCAJEAGgCGAAUABwruAgkK3wALChsACwrSAQwKcAIOCgkBkgo9AIYLGgCGAMAEBQDDA4YA7QYEC54BBQvTAQkLjgIKC8MBDAs7AI0LdwGHCxEABApbAoUKlQIECgsABgqAAAcK5wAHCv0FigrVAocLuwMHALQACAD9AYgAGAOECtwBhADqA4ULGgKHCg8HhACjAwcArwMLAGYCjADrAocALQcJChQACgpEAQoKJwOLCugBhgCBAgYLGAEKC/YBCwtYAYwLJgAFCy0ABwuJBAsLwAELC3ADDQuLAA0LlwEPCxAAEQtfABILQgASC1gAEgt7AJULBwAJABgBigCGABYAFgAXAAUAlwAdAIgLCQMEAFoABQAhAgcA8gIJALoACgBIAAoADgMLAEECCwBiAgsAwAMMAGIBDABqAQwAUwIEC5oBhwsJAocL8gYFCnAABgpnAIYKlgCKCmQBhADmAgcAlwAJAEkBiwD+AAgAVQMIAHEDCACPAwgAkAMKAGgDDADlAgwA5gKYABIABAs9AogLjwIGAJkDhgCmAwkAuwAKACQACwD4AxEALACSAEAABwBBA4gABQIEAPoBBQAnAYcAkAYECsQCCAoPAAkKMgAJCoIBCwoSAAsKEQKMCuQABwD7AAcApQYIALQBBAozAgcKUAIHCn0CBwoCAwgKzwEJCjwACQpPAQkKiAMKCkkACwqyAQwKSQINCksBEgpuAJQKPACECvYBiABIAgYKWwGKCqEABwDbAwkAsAIKAAoCCwAUAwwAiQAMADYCDgAJAA4AGAAOAEAABwuDA44LRQEEANYABQD0AQUKZgAGChwBBwo3BAcKjwUHCqYGCArWAQkKKgIJCtMCiwpNAQcK9gCHCkgDBgoKAAgKOwIJCuMCjwpbAIUKcgKSAMMAhgDvBgcAhQEHALwCBwCsAwgAAgIJAHQACQAXAgoAdgALAGsACwCUAAsAmgMMAP4ADAClAY4A7gAFChIABgoOAg0KGAANCm4AEwoFAJMKLACEAOcCCwAkAQQKNQEFCs4BBwrKA4cKSQQWCh4AlgohAIsLUgGHCz4GBwADBQkA4wALAEUBCwCYAQ4AtACSAC8ABAC5AwYADQcGABYHBgBGB4wABgMGC2MChwvFBocLuAUFAFEABwCSAAcAPgUIADUACAAxAggAtgIIAPICCQBzAAkAswAJAH4DCgDOAQoALQMLAOYACwCRAgsAuwILAOwCDAB3AAwAyAAMABsBjgARAQUAmAEGABUDBgBtAwYA5QQGAIUFiQDrAoYKqAaHC5cCBgB2BwYAewcGAIMHCQCRAwkAoAMJALYDCQC6AwkA0gMJAOEDDAAsAwwAMwMMAD8DDABBAwwARgMMAI0DDACgAwwAowMMALYDDwC6AA8AuwAPAMMADwDEAA8A0QAPANcADwDsAA8A8QAPAPkADwD9ABIAtAASAN0AEgDgABIA4wASAOUAlQA8AAcAIgeHAJIHCwDqARIAjwAFClYABwrnAgkKVQAKChkBCgqwAQwK+wANCnYAjgp6AQUKDAKFCugCjQu6AQoKawCMCrQBhwv3AYYAigSECp8DBwAeAAgAVgAIADsBCAC8AgkAQAIJAFoDCgCeAQsANgELAHgDCwCIAwwAaQENAPgADQBzAQ4AjgAMCp4CkgpeAIYA0QIEC3EABQujAAUL3wIHC/EDBwp9BAkLCQAJCpwACQsDAwwLWgANC4oADQuaAY8LgACKAEcDhQoKA4kAaQKFCvYBCArEAAoKGwGLCpYBBgCsAQcADAIIAKkACADqAAkA4AGKAIYChQpXA4YAcAYHALUEigB9AgcAPAYEC6cDhQs3AwULDQEHC7IBBwt7AwgLUwEJC74CCwtSAgsLzgKRC2QABwtuAwkL5QGNCwgBBAAKAQgABAAJACcACgCmAAsAlgMMAHsCFAAKABYAGwAWACsAFgA0AIYLsQYHCngFCQq+AYoKLQCHC4QDhABeA4YAEgaHCwkEEwAQAJMLEACHC7gEBwCdAIgAFwEGAFwCiACHAQ0KxwEPCmMADwqBAJAKRACHCqwABwCxAwsAyQKLAOgCBADNAwoAbQMKAKkDCgCqA4wAxwKLAP4DhAo4Ao4LjwAEADcCCQBbA4QK3AIHADYHiAB0AogK3QKFAPoCBAqsAYcK/QYKABADDQC/AAcK3weMCpkChQAqAQcAeQIHAIkDBwCNAwcAAgYJAP8CjAB8AooKJgOEABsDiwAtAYcAsgcFC3EChwtRBocLEwEHCyUACAupAQgLtQIJC9ACCgt8AQoLfgILCxEBCwszAQsL2QEMCz0AjwsrAIcLxgCGANQEBwBxAQwAhAIMAIUCkABaABMADwCVABsABgBHAAcATQMIAKAACQA+AQYKVwaGCpEGhgCnBYYA5wSKAN8CCABMAIQLqAAGCtQGCArLAgkKIgMKCi4ACgozAw0KNAEOCl8BDgprAZIKQwCHC1sABgDaAQQKPwCFClsBhQrtAooASQOFCm4BBgBEA4QL4QCHAFYGhwpZAIwA3wKGAEEGiguRAAYAbgWJACQDjgCKAQYLDwAHC0YACgvwAJMLXQAGAGAAhwCSBQQAiwKFACEBBwu8AwcK0QMHC4UEBwviBQcLRgYHC08GBwtTBgcLyAYHC+8GCAtOAgkLRAEJC+ACCQsGAwkLCAMJCxADCgs3AgoLxAILCwYCCwtlAgsLtwILC8wCCwvjAgsLAgMLCwMDCwtQAwsLWQMLC6MDCwuzAwwLRgEMC4MBDAvkAQwLEAIMCygCDAtlAg0LvQANCwABDQtUAQ0LsAENC7QBDQu4AQ0LxgEOC64ADgvcAA4LHAEOC4YBkQt5AAcAsAIIACMACQD/AQoA/wKTAHYAhgCbAgQAAQIFCjgDhQqtAwcKuAEICuYAiwpqAIYA8geHC3cFjwtCAIcL+QUEC5EABguwAAcLiwEJCzICkAscAIQL9QGEAMAChgD0BQcANgSGC9ABBgv9AQoLUgAUC1sAlwsNAAQA0AKFADIBhQCvAQcArAQECpIDBQogA4UKVAOHC6UECgA2AI0KcwAHCjQCjgqoAAUA0AEGAOwABwC4AgcAkgMHAFQEBwCoBQkADwAJADQCCgAOAAwANQINAMEBDgA1AA8ADQAQAEAAEQApAAQKlgOFCmwDBgCKBYYK5AYEClwAhQoSAYYAiwMEC3IACAr1AQkL7AENC84BjgvXAAQLTQAFC2kBBguLAAYLkQEGC5QBBwudAQcLywIHC7QGCwsXAQwLswAMCwIBDQv0AI4LZgEGAOcGDADCAJEAawCGC7UGBQrnAo4LSQEECjEABwoYAYcKYQYFAEgDBwslBAgLUgALC/oADAukAY0LuACHC9QChgCEA4gKLwCGAJwFkAsAAAYAowIHAPADBwAYBgkAggILAOwADgDBAAUKEAEFCowDBQquAwgKxQAJCi8ACwoaAosK5gIEAEQABQB0AgUAegIGAIIBBwAaAwgAEQEJADMCCgBpAAoAqwALAF4AiwBiAYcKdweJCnsDBABfAAYAEQUGAEQGBwCgAYsAPgMGCwEChwscBAcA2wINABQAjwALAIkLgwMKAFIDjAC5AgQAlgIHC4kFDAt+ARELMACYCwwAhQDgAoQAXQMECpcBhAowAo0K6gEGCyECBws1AgcLhQYKC3IACwuCAowLagIGAGcDhgDoAwUAYAMKAIgCCwCfAg8ALgCFCwUAhQCgAwsAWgANAAcABArbAQsKIwANCkcADQqxAI4KpgGIAEwBhwvAAIYAHwSIC/sCCwDaA4wAqgIHAEwACAAsAAkAdAMKAEQCCwCPAQsAfgOPAHoAhwvVBIcKfAILACwBBgreAAcKVAYICpkBiQq1AgQLVwAFC/oACgtZAg0LKgENC2EBjQt4AQUABgIKAFQBCwCvAJUAEACMAAMDBgBUBIkAPwOEAEQDhwA8BwQAvQMGAAwHCABKAwgASwMIAFMDCABXA4wA/wKHCy4DBAs5AAcLqwQHC54FBwsMBgcLKwcHC3AHCQv1AgoLXAKLCwcChQpyA4oA9gAEAKYDBQDKAAgAYgIHC2kHDAsiAQ0LUAANC7UBkQtKAAgAYAAJACQACgBfAgoAJAMKAEADCwCnAQsAugEMADUBDgDHAA8AWgCRAG4AhAqqAQcAjgIIAPAABgo6AAcK6QIHCrEHCAqjAgkK3wEJCtsCCgpKAQoKUQIKCjEDCwogAAsKhQALCt0AkQpEAAkADQAJAI4BCQDXAgoASwAKALgACgDmAAoANAIKADkCCwDNAwwARgAMAL0ADQA5AI0AAQEEC9EAhwuGAwcAhwGJChoChgCTAQYLLwEHC08BBwudBQcLhAYICykCCAuMAggLkAIJCy4CCwvnApULEgCECy8CCwBLAI4ACwEGAC8DjQsCAI0AbgGJAHcChQv5AwUAWQGHAPgDhQvFAoYL0QaFCjYCBwC4AwYKMAAJCosACgqPAQsK1QEMCnoCjQrfAIUAoQIJAFIDBwsIAIgLzgAGAJYClQAjAAQAHwGFAPoDBgpyAAcKyAQHChQGiAoDAAgKQAKJCgsBBAB0AwUAIgAKANQCDAC8AQ0AYgESACAAFwAYABcAHwCYAAUAhQqlA4QLCAOKAJcAiACrAYYAfgGEAEkBCQBOAwoAOwOKCyEACQAXAQoAlwEOAFQAFgASAIcLEQWIC5YBhACKA4gAbgGGAEsDhgCjBYcAXAWKAOADBAB7AAUAXQIHAOUFiAAkAIQAiQIIC68ACguoAIoLPQKFAP8ChgD6A4cLGQUMCh4ADQqUAA4KVwAOCrYAEAoqAJQKRgCGC18CBAARAQUAkgKFAOMDBgBIAIsLrgAKAOMBDABwAQcKOAAHCsUHCApRAQgK4gIJClgCDQq/AY4KXAAFCxADigqaAocAQQWLC3IDhgANBYUATQKGAMQHBQB1AAYAAgIGAB0CBwCMBAcAnAUIANwACACIAgoAsAKLADACiAB7AQUArgIHCmIDhwqLBIQKSAEJCw4ACQu5AQoLMgGLCwkABAplAIcKkwQFCkEDiAroAgULoQAHC0cDhwt3AwcAxAAKAP0CCwBbAQsAKAILABYDDAAHAQ0A9gANAA4BDQCLAQ4AsAAOAL4ADgCOAQ4AnAEPACAADwA/ABAAWACTAGkABgoJAAYKjQEHCjUABwrOBgoKeAILCjwDjAqSAAUAfQGHAAAHhgCsBYcLrQEIAG8BCgD4Ag4ATwAUABEAmAAAAAcAaAKKAJ0BCwqhAQwK3wCMCgkBBwtLBg0LDgAPCywAEwsNAJQLTACHAM0EBgB4AAcApAQHAK4GCAAeAQkAmwILAFACiwDaAocLFgeHAHoEBAq6AAUKnQAICqgAigoGAAQAYAGHAK8CBADAAAUAMQAGAMgABgAlAQYAoAaHAH8EhQprAwUKBQMFCt8DBgpjBoYK/AYHCm8AiApFAgYApwOGAH8EhgAaBIQAigKEAJMACwDCAAwAPgAMAFgACwvCAAwLPgCMC1gABgBTAYcAmwOGCtMGBwuDAogL7ACFAKYDBwpUBQcKcweNCp4AhAqTAgQKlAGHCqMCBwtFAgkLhAKJC7sCDQDTAA4AhQAOAMwADwBAAA8ARQAPAHIAEAAKABMAFwATACMAEwAnABMAMwATAEcAEwBLAJgADwCFCocBBQs2AIcL6QUHAN4ACABVAQUKHAKGCqEGhgpOAIQL6AKIACUBiQu9AgcLogMKC5IBCgvcAQ0LxAESCzcAkwtoAIQAfQKFCswBCAsyAIkLcAKECzwChgCHBAQKxwCLCiIAhgBPA4YKhAEGCysABwsmAAgL+AAJC/gBigsBAgkAqwIECv8BBgpgAgkKTQEKCloCCwq5AQsK0wILCtADjAplAQkAYwOKAEUDBgCwA4cLRgGHABEHBQqqAwcLDwOICsMChQv+AoULawEGAKoABwA4BAgAiwEIAOcBjQCTAAYLAgGMC5kBBAAXAggAagIFC/kAlAtSAAYAYwWVCw8AhwBZBpYAFwAFC4kBBgt6AQcLvQcJCyAACQtPAgoLrQIKC+UCjgt+AYULFAMHC7AHCgsTAIsLjwMHC3kFhwvEBQQLPQAFCzoABQurAAULewIFC6sCBQu8AgYLIwEGCzYCBwtyBgsLCwIMCxEBDAsvAQ8LJwCPC28ABgrVAQcKrQaKCgMCBAAKA4YLTQKEAC4ABQArAwYAjwYGALIGhwDwBwcAsgUJAJcBCwAPAAwAiwKVACUABwCqA4QK9AEGACIABwBFAAcAQQQHAAEFCADEAggA0QIJAGsBlABiAAoL5wCTC3wABwvWApgLCQAFCkQAhgp/AYgLRwIEC5UDhQvtAwsK2ACLClQBhwuLBggAuQEKADoBjwADAIQLlwMEClEBBgphAQcKjgcICugBiQqtAQcAeQMHCgMHCAoDAQkKhwAJCrEACQpcAwoKOQMLCnMACwpyAQsKlQELClwCDAoKAAwKmwIMCp0CDQpMAA4KNgEPCkwADwqTAJQKFwAECg8ABAv/AAUKFgAFCy4BBguEAAYK9AAHCigABwuAAAcKyAAHCxsBBwqKAwcKrwQHCxMFCQpoAgoLNAAKCwICCgrMAgsKewILCiEDCwudAwwKygENC1wAjgs1AYQAzgGJC60AhwrHBggADQIFClYCBwoXAwgKbACJCnsABQBJAAYAFwCGAFIBhACkAoQKqwIHANUCCADyAYsADAEMABUAlwAHAIcABQMECpsAhwqZBgQApAAFANoCBQqXAAUK5QIGC9IABwryAQcKZgMHCgYGDArVAA4KJAAOCocBEQpvABIKBgASCi4AEgqXABMKJAAUCiAAFAo4ABQKRQAUCmYAFQoEABYKCAAWCgoAFgoOAJYKHwAECnAChwrYBgQARwIJAKgDDwDWABIAxwAYABoAhgtMAgcAtgULAJMCBAscAYYL3wCFANwAiwAjA4QAIAIECuwBhQrDARAAYgCUAHcABAvaAAcLDgKPC4kAhwpDAwQLDgEFC8AABgtMAQcLKgUNCwkADQpGAA4LaACOCzcBhAobAowLlQIFALAABgC1AQYANAILALUAjQC3AIcAqAQGCnEAhwq0AYgKzgKHCggChwBWB4wLxAAHC3sBCAvhAYkLeQEFC+sDBguVAIkL6gIICwYBCQtzAgoLEgALC9YACwuUAQsLyQELCwwDCwtRAwsLkQMNC0oBDQuRAY4LyACVABoAiAswAYQLjgCHALADBAAWAwUAEQGGAIoBhgBXAwQAhwAGAH8ABwChBAcA5wUIAGUCCwAFAAwAUAEMAO8BDABKAgwAlAIMAJwCDgCBAQ8AdgARABQAkgBiAAYA5gAJAPACEgBtAAwKYgINCq8BkAo7AAcAogeHC50DBAvXAQULMwAGC1oCCAvkAQoLwwCMC58AhAozAYgLsAKEC7kCBwssAwcL7QQHC1AFCQt4AowLYAEFAKIACABEAIUKxAMEAI4CiAvUAAQAnAAHAOYDBwAVBAcARAcJADAACQC0AgsAowGLAFoChQvdAAQLdQEFCxsBBgvgAYcLYQKOC9gAhADwAAYLwAAJCxkDkQs3AAQKSwAFCrQABgr0AQcKOgAHCsYCigqFAgQLhAAFC0UABQqJAocL2gQGChQBBwoaAQcKbwMHCpwDCArLAQkKVwIJCvICCwo+AgwKgAAMCu4BDQo0AA0KLQEPCh4AjwqEAIQKyAAEC28AhwsuAQkAxQAKACwBDADZAQ0AWgCNAJUBhAv/AgYLKgAHC4gFBws2BgcL1QcIC4MACAvSAQkLoAINC/wAlAtnAAgAvgMIAOcDCgDDA4oA6QOHClUGhwBaAwQAXgKJC7wBBgssAIgLcAGLC6wABAs6AoULeACLC3ACBwC6BwgApAIGCuEAiQrTAAcAzAMLAGYAiAqvAgYL4wCHCzUGCAo6AAkK1AILCikDDQpxAJEKSAAEAGkBhQA7AYQAzQEGClkBhwrfBIQA2AEICv8CCAojAwkKLQGJCocDhws1BYcL3QEHCp0HiAqiAgYAiQOKAOsChQCbAIYKAwEHAKMACAA/AQkAkgEKABgACgCpAgsAyAAMAP0ADACaAY4A2wAFANsBBwD0BgkA5gALACkBCwAuAg4AQgETAEwABguDBgcL9AeKC1gCiAr+AAYAUAOHAKQHBgv/AYwLhAAFCzgCBguKAIcLDQUGAHcCiQBGA5UAJAAECzUCCAsXAIgLOwMFALADhgDpBgQAkAAGAEoDBgB4BQQLmgOFC/8DhQr4AAkKIAMKCrUCCwriAQsK3gKLChUDBwvqA4sLkQAECnQABQpfAAUKvQEHCpgGCAodAAkKEAELCv0BiwqTAw4AcQGSAEgAhwppBoQL5AKFCh8CjAt0AAYA9wAJACsCBQq1AIgKKQCFCpECiADkA4oKxQIHAL0ACArKAIoKGAKIC5IBBAvMAo0LHwAKABgBigAdAwkKpwGMClkACApxAAkKbQMKCioCCwpTAAwKiACTCm0AhQrQAwcA6gKECs4AiAAOAosAWQGIAPkDCAuYAAkLNQAJCwwBCQuFAwoLBgIKCz0DCwu8AA0LSgAOCy4ADwsRAA8LIQARCygAEgskABMLFAAWCwEAmAsCAIUL4AKICxQCBQCsAYoAiwKHC6kChwCKBAcARwENAOYAEQBxAAgK4gAKChkCCwo6AgsKXQILCh8DCwokAwwKVQAMCgQCDApvAgwLpQINCmkBDgpNAA4KTgCTCm4ABAAYAwcAtQYKACIChAoBAwQLrAKIC4ABhAonAoYAswQJCjkACQrLAQoKqQELCncADAq4AAwKcwENCmYBkQozAAUAoAIFCi4DCAoKAAkKpQEJCtkCCgphAosKsQKKAL0AhgpwAgcLbgAHC7wACAsiAQgLTwIJC34BCQuJAgsLRwALC5sACws5AQwLBQANC0UBjgsfAYUAYwAGAB0EhwAqAQcLaAEHC6kBCQtCAAkLFgGKC4QCBACNAYgAKwKJCg0BhAoQAgQLhAOFC10DBgCFBAUL/gAHC9kDiAtJAAcLpweIC6sCDACOARQAJwAVAAsAlgApAAQA5QEHAGEBhwDzBQYAbgEHAGgFhwBBBooAEwOJABoBBQpoAAYKrQCHCl8GiwuSAAQAnQCFANcBhgCtA4QL1QIHADgFCAqKAAgKVgEJClQACgrBAAsKcwOMCmcBhgvEAIgAdACFCz8DhgATA4YKXwAGCpYBCgqZAQoKvwELCiwAjApkAAUAoAAHAGsBBwBNAgoAqgCNADcAhgAXB4QAYgMGAHkDBgArBAYAnwQEC0EBhgs5AgULUAOGC0IABAskAAYKZAYHC2sFCgvNAAsL8wKNCw8BhACxAgkANAMEChoBBwoKBAsKjgELCnoCDAoBAAwKTwAMCiACDgrtABEKCgCSChQABABsAAcAJAOLAPIBhAt3AwYAXwSHC2wCBgulAIoLhAEFAPQABQrzAQYK3AEHClgCBwp4A4cKSASMAGEChwDtAwQAnAGFAEUCBAvPAocLmwAHCigBBwpUAggKMAIICkoCCQpkAgsKMAEMCi4ADQpZAA4KcACRCnoABAB/A4UABAOOCzMBhwBqBwQAngOFANcDBAthAQYLkgAGC/0GBwsgAQcL3gMHC0QFCQuZAgkLggMLC30DjgvUAIQAGgKFCxQCBgAmAQcA8wQIAHACjQDwAQcALQUECy0AhwvpBIoALQEJACoBDAAjAQ0AFAEOAAYAEQASABUAIAAHCj8GBwq7BggKTwAICmoACAq+AAgKLgEICn8BCArJAgkKdwAJCukACQqjAQkK1wEKCrUACgqWAQsKOQALClUACwp4AAsKsQALCigBCwp+AQsKxgELCvYCCwrnAwwKGwAMCoMADAr1AAwKOAEMCr4BDArGAQ0KYgANCqoBDQr8AQ4KowAOChABDgoVAQ4KcgEPCl8ADwqKAA8KpwARCiYAlApgAIQA9QKGAO8EBAA0A4YK3waFANICiAswA4oKdAGRChAAhgAPBAQA3wOGAOwHhQoCAQcAUweLAHwABgsvAgYLmwaHC0oCBQBEAQcAcQMICoYACQoUA4wKtgEHCx8Hiwu1AgYARAWGAAkGhgCPA4QAugMIAEkBCACeAQcKnAeHCtQHBQAFAgYKtwEHCgwDhwoQBIQAMAMFCgEABgpRAIoKCAIJAMkCCgDeAAUK4gEICmIACgq8AgoKNgMLCi4BCwoKAwwKMgAMCn8ADAqMAQ0KPgANCkgBDgp6AJMKSACJACEABQoCAAcK1gWICk0CBgoAAgcKHQMICv0ACQpNAAoKAQAKC2wACgqBAAoK4QALC3QACwp2AAsK4gALCvsACwquAQsKvQILCs4DCwrWAwwKQAAMCgQBDAroAYwKsgKGC8gBhQudAwUAlgAHAGoABwAGAwgAWwIJAFECCQB6AgoALAAKAK0ACwDOAQsAAwINANgADQAgAY4AkAGJClsBBQDsAoYAKQIMAGwAjQAjAQcApAEECgwABwoKAgcKKQMICh0DjQpYAAYLwQAHC/AABwuSBgoLMwAKC4ACCwuaAQ0LUgAOC/cADgtLAY4LeQGFChAChwDxBgQA7QGQADcAiAt5AosAUQAGANQDiABBAZQKbQAFCgoBCQoiAQkKbAEKCiUBCwpeAo4KLQAGADgCBwBwAAcADAcIAGoBCACaAQgAPgMJAAICCwCJAo4AnQAEAEoABgD+AQYKUgIJCnkACgoxAAoKnAGLCkIDhgBGA4gK7AKECtIBhABxAocLowUEC+0AhwsCAgkKegGNCqIABgAQAAYAngAHACsABwCBAAcAtQAIABQBCAB5AQoACwILADADDADHAQ0ALwGOAIcAhwAZAQQAAQAHAHcEBwC3BQgAPQAJAM8ACQCGAQkA0wGLAEQDBguIAQcLQQCHC+MHhAqbAgQA0wIFAH8DBwAHBAgAxwAIAFQBCQCZAAkA1wAKABUACgA7AAoAUAAKAOAACgBGAwsA5QALAIwCDADAAA0AkgCOAFsAhAAnAYkAMwAJC94ACgsrAIsLhAMFADUBjADTAAUAfQAIAE0AigAPAIgLXAKKABUDBQCtAAQKJwAHCjMHCAqXAQsKkACMCgsCigsJAYUAtwGECv4BBwCIAgcAagMLAKQADABMABIACQAHCrwHCgrnAYoKKQMMAG8ADgAmARMALQANCgQBkgo/AIULJQKGCjoCBAAIAAcAgAQHAIEEBwCzBgkAdgEKAN4BiwCIAocASwQFAD8CBgBiAYcAvQIHCyQACAvJAIgLXQIEChMDiAucAAYABgKVCw0AjAvgAIYAvgKECgQCBQvUAgoLMQELC5cADAshAAwLeQAMC30BEQsDABELGwARC04AEgsSABMLNgCVCwUACABXAAQLCwIFC34CCwp3Aw4KbQGOCncBigC2AYgKNQOHC3QHBgvyAAcL4wAHCy0GCAtoAAkLcQAJC9wACQurAQoLSgAKC+8ACwtDAgsL/wMNCwQADQvMAA0LPAESC18AlAtWAAQARQAFAHoABQBRAwYAYQYJAJACigDQAQcACgcECgoAiwoSA4cLXQOLAPMBBwDcAQcAOAaKAFcAhQqsAgQASAOGChsAjgAbAQYAVAYHCzAFiAvuAQUAWwMHAIgECABrAAkAIwEJALcBCgCXAgsAYQKMAMUABwsaBQgL+QEJC+IBCgt+AAsL4QAMC1sBDAvBAQ0LEwCOC9oABQsMAQoL/AIMC3gADQsnAJELfwCRCjgABwuIBgoL2AELC70AjwszAAYKVgEGCvABCAoTAYkKzgCFAFgCBAB1AAYAdAEHAHEHjgBDAQQKjQMFCqwDhwu/BYQKewMEANICiwDXAQQLgAGHC/4DhAqvAgkABQAMANgADAAmAQwAKgEMAJABDAAGAg0A5QCPAIsAhwunBgcLQgYKC7oCDAvUAI0LMwEGCikAjQqgAIcLNQQJC58ACwscAIwLWwIEAAICBwAYBYoA3QGGAO4GCQBYAIsADgEFAAwABwB3AQkAtgGGCrYGhAsDAogKCgMIC3gCCAu5AokLVgMGAGoBBgDlA5IAMwAHADADBwDZBAkAGwEJAAgCCgDVAAoAMwEKAM8BCgCfAgoA6gILAJEBCwAaAwwABQISAGsAkwBzAIUKcwCWCxwABAuIAIULJwKOCjoBhAACAQYAFgAHAIcDBwCrBwgAfwKKAEECBQCpAggADgMNAIIAEQBUAAUKwQCMCrIACQsRAIoLIwEHCwcFCQssAAoLKAIKC4ICCwtHAwwLEgEMCxMBDAt0AQ0LWwCOC30AhwquAAQAmAIFACQDiwD1A4YArgMGAEUFBgBJBQYAqgUHC+4Fiwu2AgsAZAEECnoABQocAwUKuAMGCnwGBgqHBggKNwIJCq8CCQrmAgoKrgILCqoCjAoZAQUAIAAGC5MABwt2AwkL8QKKCwwBBQqzAAcKRwSHCr0EBApCAAcK0gKHCogDhwpgAQkL9QCKC4kABAAhAQcAdQIHAKIGBwCvBgwA1wCFC54BBgC3B4cL4gYGAMIBiABtAI0KIwCGC1cCiADBAoUAmAKGC9UGCwuSAQwLbQAMC68BDQuzAA0LzgAOC68ADgvZABALAwCUCzUAhwDWBIYLWwaEC+gBDQA+AQoKUAIKCvECDAo9AQwKYwEMCtEBDArVAQwKMAKMCkIChQo0AoQLUwCMC6QCBgBQBwYAcgcGAHMHCQCmAwkAvAMJAMADCQDkAwwAGgMMAGwDDABwAwwAlgMPAOYAEgDqABIA7gAVACYAlQA+AIYKLAKGCxYBiQBnAAcKIAIICs8Cigo9AAQKBQAFCvIBCAp9AokKCQIHAAkDDADlAAwA7wAPAAwADAvlAAwL7wCPCwwABgAaAAcLhAEHC4QCiwsNAwcL5QAICzsACQu+AAkLAQEKC3oBjAu/AIUKnwOHCqEFBAp9AwUKDAOFCn0DBACeAQUA0wEJAI4CCgDDAQwAOwCNAHcBjgCtAIcAEQAHAEYFhQruAIcAuwMEAMADCgB3AwwA8QISAKEAEgCiAJgAEwCIC1gBBgrBBokLIAGEC5QCBADZAAUAxgIHAPgCBwCGBwkArAEJAMQCCgD+AAoAKAEKANACCwBtAAsA/wAMAKUADAA7AQ0AawANAMsADgA2AA4AYwAOAHIADgCEARAAVQARAAkAEQAhABQAGQAUABwAFAAdABUACQAVAAoAFQAiABYAEQAECjwABwoIBwgKOgEJCrwCiwrnAQcLCwSKC+ECBwuyAgkL2QAJC0sCjAsJAgYAlwMHC8ICBwsiBIoLGgIHCj0Higq1AYgKowEGABgBCgD2AQsAWAGMACYABQAtAAcAiQQLAMABCwBwAw0AiwANAJcBDwAQABEAXwASAEIAEgBYABIAewCVAAcACwtcAAsLxAALC5kBCwvCAQsLmgILCwkDDAsGAQ0LgQENC4kBDwtzABALLQCRC1IAiAAJA4YL0AYEAJoBBwAJAoUKPAOGAKECBwBWBAcA8gYHCrAAhwqyAAUKJgMHCwwBBwq4B4gLOQIEC90CCQvCAAoLXAALC8YADAtUAAwLVwANC4AAkAtKAAUAVQEHAGkECwCeAQQKMwAGCgQABwpPAgcKUQMHCrcDBwpNBgcK4AYHCsQHCQqyAQoK8gILChkAiwolAIUKhgOHCqADhwATA4QAtAGGCg4BBwAzBocAqwYGAHkBBwABBAkAZQKRAGgABwvWAwcLUQUKCyAAjws4AIsAYACEAMMBhAqgAY4KdAEFCpgABQrFAAcLMgEHClQBBwpjAwoKJAIKCkUCCwoGAAwKAwAMChMADgpuAI4KIQGGAKgChgthAgcA4wEHCr4ACAocAAgKjQAICrwBCAorAwkK1AELCk4BDAoYAAwKggGMCkACCgCUA4UK9QIFCtEChwoRBoULsgCGAKkDhAqCA4UA4wKTAFIAhwCXApIAgAAFChUBjQr3AIYAPwSECrMBBgt9AQcLhQIHC7YCiAsiAgcA9wGHAF0HBgCtBwgAnQOKALsDBABxAAUAowAFAN8CBwDxAwkACQAJAAMDDABaAA0AigANAJoBjwCAAAQARAGKAGgABwDMAQUKCQGGCtQAhQtpAAcLBQEHC1MEBwtbBAcLSgUHCzQGBwupBgcLbgcJC9EBCgv4AAoLXQEKC4cCCwsPAgsLlAILC50CDAsRAo0LMQEFC7YBCQu2AgwLcwKNC9IAmAsLAAQApwOFADcDhAq+AgUADQEHALIBBwB7AwgAUwEJAL4CCwBSAgsAzgIRAGQABQooA4cK/QcHAPYDCQDlAY0ACAGGALEGBwASBwsAYgMMAGcADQDvAYwL6QAEAKcBCgC1A4oA9QOHAIQDCAsZAIoLOgMFCqYACArjAowK/wGGAOIHBwv2BIsLZAIECncABQqqAAUKvwEHCqwGBwphBwkKZQEJCs8CDArmAYwKVAIMAD4CjAs+AoQLNAEGAMQDBgC2BIYAFgUECsIBhwqGBIcLlgCIC4kCDgDVAJQAJgAJCy0ACQs3AY0LKgCGCwkCBwpfBQcKugWKCksBhAryAgULUwEHC6IFDgsDAA8LKQCTC0IAiAt6AYYA/gMFClIDiAofA44AjwCHAO0HhgtcBggACwKWACIABQBxAocAUQYHABMBBwruAAcK8QcICngACAq8AAgKkwIJClYCCgrSAQwKVgEMCkwCDQr3AQ4K9gCPClwABwAlAAgAqQEIALUCCQDQAgoAfAEKAH4CCwARAQsA2QEMAD0AjwArAIcLPQOHAJcHhAD9AgUL5gGHC0UFBwtjBggLEQAKC9kAigsnAQQKyQAHCtAGCApaAgsK9wALCjoDkQpBAIoLLgILACcCjgCfAAgKpACSCj4AiwuwAIQAqACIAPIDhgDKB4cAWwCKABQChwrbBIcAXAeECosDBQpkAAoKSQEMCqABlQodAIYLvwGECrAABQp8AgUK5gMHCgkABwrkBQgKGgAJCj0BCQpmAQoK0gAKCiQBCgoVAgsKKwIMCg4CDApfAg0KBwENCssBjgoPAQQLYQKHC/QCBgAPAAcARgAKAPAAkwBdAAQLogOFC7MDhgDLBIYA/gWFC6sDhQvCAwULiwIIC6oACQs9AAkLPwAKCxcACgslAAoLQgMLCwQACwu7AAsLGQELC/cBCwulAgwLYAAMC4IADAv0AA4LBQAOCygADguiAA4LygCSC4UABAuWAQULQwIMC+wBlgsPAIsAiAEGCmICCgp/AI0KGwAHAI8CBwA0B4gKdwAEAJEABgCwAAcAiwGJADIChAD1AYwLkQCIAPsDhgD9AYsACwEGCxEABwsQAAcL6QMHC74HCQt2AwoL6QEKCyADCwsOAwwLQAENC9MBDguRAA4LgwGPC3cAkQsRAAYASwSFC8oBBwu/BwgLAAAIC6sACQt4AAkL3AIKC9kBCwuQAgsL5gMSCwAAEgsCAJMLFQAMC6sBkgsmAAoAtAOKAMgDBwp+AIgKVACIChYDBAByAAkA7AENAM4BjgDXAAYKQAAMCnkBjQo1AQQATQAFAGkBBgCLAAYAkQEGAJQBBwCdAQcAywIHALQGCwAXAQwAswAMAAIBDQD0AI4AZgGGALUGBwAEAwcAJQQHAG8GCABSAAsA+gALAF8CDAA3AQwApAENALgADQBvAQcKUAQLCg0BCwobAgsKcwILCsICCwrPAwwK+AAMCrIBDApYAgwKbgINCikBDQrlAQ4KRQAOCpkBjwpsAIcA1AIECwACBAsHAoULVgGGAG0EkQsdAAsK0QONCvsBBgBJAwYAEgQGAKoECgDhA4wA/QMGCx8ABwvrAQcLEgIIC1ACCQoiAAsLNQALCuQBCwsLAwwLpwAMC5sBDgsOAA4LiAAPC0gAEAsRAJALSAAEAP0DBgD1B4ULiwMHAHUBCABPAQgAVAIJAOgBBgqkBgcKJQEHCn4BBwoCBAcKPwQHCusHCAr8AAgK1wIICtkCCQoeAAkKxwAJCucACQr7AAkKTgEJCmkBCQrIAgoKNwAKCjwACgroAAoKTAEKCoABCgqMAQoK+AEKCh4CCgqMAgsKFAALCjAACwrPAAsKIwELCioBCwpWAQsKbQELCooBCwpsAgsKwQILCvkDDAp7AAwKVAEMCpYBDAqDAg0KPQANCg0BDQo3AQ0KPwENCuYBDgrqAA8KPgAPClUAEApHABIKdwCUCmkAlgAlAAQL0AAFC2oABgsTAggLmAEJC7wAigs8AoQANAIGAAEChwAcBIQAOQMJAIMDjAu5AYYACgOFC3sBBwCJBQwAfgERADAAmAAMAIQL8QAHAFwEBgp7AQcKDgEICrAACAq3AAkKsAEJCpUCDAr3AAwKaQKSCn0ABQoYA4UKhAMGACECBwA1AgcAhQYKAHIACwCCAowAagKFAAUAigsHAIQLAwGHAMAAhgC9AogA+wKHCrsHBAqFA4UKCAMKAPMCkwAdAIUA9wIEC60ABQs4AQULAAKHCwUFBwtDBgcLmwYJC9ABCwvDAAwLFwEMC8ABDgsLAJMLZgAHAHIBBwDvAwcAmQSHAB0GhwDVBAQAVwAFAPoAjQAqAQQLxAEFC0cCBQsxAwYLsQEHC1ECBwvQAgcLYgUIC6EACQscAQoLOQGLC3YDBAsjAocLgQWIC9ICBAolAAUKTgGHCuUEhAr8AQwAawCSAB8ACAukAYsLwQCHAC4DhwuZAYwA3wMEADkABwCrBAcAngUHAAwGBwArBwcAcAcJAPUCCgBcAosABwKEABwCigs0AYQKFQKIAGACkAtBAAQA9gOGAO0HBADRAAcAhgMFC+oDiAvpAoYA7gcGAC8BBwBPAQcAnQUHAIQGCAApAggAjAIIAJACCQAuAgsA5wKVABIABQs/AgYLYgGHC70CBAvvAAYL3QEHC0cGCwtEAIsLaQKEAC8CCAAPAhIAPACTABgAhQqYA4oA/wGFAPkDhQCjAooKhwELAJwAhwqgB4oLcQGEC28BhQDFAgYAugKGAHcDjgp+AIYA0QaECuMBDQsrAY4LSwCFAMoCBwAIAIgAzgCKCuABBAu2AgkK7wGSCmgABwvgBAsLbQKLC74CjAuvAoQACAOLCvEDhwD4BIYAIwQICo0CDQpdAJMKDgCHC9UAiACWAYUKrACEALMDCACvAAoAqACKAD0ChABmAwYAHwaXCxwAhgvYAQUKBAGIC4QABAvvAgsLhgGMCyAABAuZAYULTgAMACoCBgvZAZELaQCFABADCACMA4gLMgGLAHIDBgBmAQcAcQUIAIwBCgAHAQ4AmgAQADAAEQAIAAcL3wYIC4wBCgsHAQ4LmgAQCzAAkQsIAA0LowANC7QAEgtOAJQLIwAOACAAEgBVABQAAgCYABAABwDkAAoAAgMICqcACAp3AQkKUgAJCjECigpsAoQATQMJAA4ACQC5AQoAMgGLAAkACwDGAwwAHwENAFYBDQCSAQ8AbgAPAKMACArCAIgK9AKGACoGBADHAwYAHAcGADcHjADMAogAUgIHAJQFBwBoBgcASwcJAKkACQC2AAkAbwEJAN4BCQD6AQkAJwIJAC0CCQCIAgkAuQIJAMECCQDVAgkAEwMJABoDCgDGAAoA1gAKAAsBCgATAQoAyAEKACcCCgAxAgoAZQIKAHMCCgCcAgoAowIKALMCCgC3AgoAwwIKAMsCCwC3AAsAyQALAPQACwAGAQsAYAELALcBCwDtAQsAPAILAE8CCwBgAgsAYwILAIYCCwCiAgsAxwILAO8CCwD5AgsACAMLABEDCwBSAwsAVQMLAF4DCwBhAwsAZAMLAGsDCwCCAwsAhgMLAIcDCwCOAwsApAMLAK4DCwC9AwsAxwMLAMwDDACUAAwAwwAMANwADADtAAwAPgEMAFMBDACJAQwAvQEMAMIBDADaAQwA+QEMAP0BDAAVAgwATwIMAFICDABVAgwAbQIMAHkCDACCAg0AOwANADwADQCRAA0A7wANAPoADQBJAQ0AWAENAG0BDQB0AQ0AgwENAJMBDQCeAQ0AyAENANYBDQDeAQ0A4wENAOkBDgA3AA4AOQAOAFEADgBaAA4AlAAOAO8ADgAKAQ4AQQEOAEYBDgBHAQ4ASgEOAFsBDgBjAQ4AkQEOAJQBDgCbAQ4AngEOAKABDgCkAQ8APQAPAEoADwBXAA8AWAAPAF4ADwBgAA8AdAAPAJUADwCaABAAMgAQAD8AEABJABEAAgARAEIAEQBcABEAZwARAHAAEQB4ABIAMgASADYAEgBSABIAVgASAFoAEgBvABIAcwASAJwAEwAoABMATwAUAE4AFQAWAIcLcwMFAKEAhwBHAwQADgMNCyUBjgs4AIULaQKLCzIAhwoWAJEAQAAFCn8CBwrhBIsKgAOKAOYDhwv6BwQLIgKOC+kABgATBIYAJgaGANgFBApmAAcKLwMHCqMGiwrEAwwADQOOAM0BBAs5AYULQQIGAH8CBgBaBIkAMQMIC7gAjQuxAQcAFgeHC6cDCgDlA4wAvgMEACwDiQtxAoQKgwOIChsDBQt2AwYLLgAGC/4GBwsOAAcL3AIHC3YGCAtfAAgLRwEIC2gCCgtWAgoLAQMLC4YACwvrAgwLegGOC2EAiACLAAYKNAAJCmgACQovAgwKNAGTClcAhQv9A4QKXAKECi0BiAoLAwcAgwKIAOwAhAuZAIYAlASTCiAAhQseAwYAOgWEC0sCBgtWAgcLKgAIC7cCCgvUAAsLngAOC8QAkQtVAIcK/AEFC70DBQvwA4cL+QAEC4EAhwvRAQUANgAHC9YBBwshBAcLsQQJC/MCCwuKA4wLDwIHC4wDkgsHAAULlACIC8IBkAsBAAQAAAGHANAFCQBfAQYKNgEHCjkHCApIAAgKEAEICq8BCQoMAAoKMwIKCnYCCgocAwoKKgMLCm8BCwpXAgsKrgKMCqACBgBdBwYAagcGAGsHjAC7AwQAygKFANUBBgD2BIYAsAWEAOgCBgA5AQcKGQIICkAACQp/AAoK8AEMCv4BjQqAAQQL2QAECvQABQvGAgcK6QAHC4YHCQusAQkLxAIKC/4ACgsoAQoL0AILC20ACwv/AAwLpQAMCzsBDQtrAA0LywAOCzYADgtjAA4LcgAOC4QBEAtVABELCQARCyEAFAsZABQLHAAUCx0AFQsJABULCgAVCyIAlgsRAIoAkgEHAMkDkgA3AAgAMgCJAHAChgBLBYQAPAKGCnIGCgq+AosK9QAKAE8DjgC9AQYAKwAHACYACAD4AIoAAQKFAHEBiQpSAYUA/gKFAGsBhQqAAwgLiAELCzYADQutAA0LJgGUCwcAhgCmAgcLzgSICxMCBgACAYwAmQEFAPkAlABSAAcKXQSIChsCBQCJAQYAegEHAL0HCQAgAAkATwIKAK0CCgDlAo4AfgGFABQDhgABBYYADwUHALAHjQD9AQQAPQAFADoABQCrAAUAqwIGACMBBgA2AgcAcgYLAAsCDAARAQwALwEPACcAjwBvAAYAwgKGAAMFhgBNAocLmQWFC7MBBwAjBA0ANgAFCgQABQoqAwYKDQAGChoCBgqaBgYKvgYHChsHCAqUAAgKuAIIChcDDAp9AI8KCQCHCvQEBQtVAAYLowEHC4YABwsxAQcLaQEHCzkFCAtHAIwLBwKJADgDjAuwAgULswIHC1kBBwppBQkLXgALCkYCCwqKAgsKhQMLCrUDDAupAAwK6AAMCuwADQqdAQ0K9QGSCnQABACVA4UA7QMHAD4GBQu3AAYLRgIJC1gBCgunAowLswEECp0DBQojAwgKugKKCjwDhACXA4cL/wGLCuADBAD/AAUALgEGAIQABwCAAAcAGwEHABMFCgA0AAoAAgILAJ0DDQBcAI4ANQGGAFkFhwo3B4YASAEHC8kHiAusAoUKfwGJAK0AhgtHAoYAgwUTAEEABQvAAggLZQEKC+kCDguqARELXgCTCzkACQqUAooKWwEEC7MABQvGAIULuQIHC1sBBwvLAwgLtQCKC8cCjQC6AQsASgMLAJwDDQA9AQ0AcgENANUBDQDXAQ4AjQESAEUAEgCRAAcKPAIJClACCwqoAgwKZAGMCiYCDgsTAA4LHACQCx0AiAAWAgQL8wAFC8sABwsTAAcLRwAHC3EACguVAQsLZQGOC/AABgDSAAoATQOKAF4DBwtHBQkLRQIKC38CCwvFAYwLSAIHC6oFiwtjAAoAfAMMAM8CkABpAAQAHAEGAN8AhgvsAQULhgAGC5gBBgvvAYcLOQaIABECiQAnAwQA2gAHAA4CjwCJAAYApAWOCwQAhAuZAgQADgEFAMAABgBMAQcAKgUEC/gABwuJAIkLXQGMAJUCBwDtBQsAVQIOAEwADgBPARQAIQAHCuwCiwq8AgULcwGHCzMCkgs5AIUKfwCFAKIBBAt2AQcLIwIHC6QGBwspB4sLWgMGCsYAjApTAAcLFAcNCwMBDQtkAQ4L8gCTC3IABwB7AQgA4QEJAHkBBQoUAQYKNwCHClkFigseAQUA6wMGAJUABgrYBogK1gIIAAYBCQBzAgoAEgALANYACwCUAQsAyQELAAwDCwCRAw0AkQEOAMgABgtvBgcLEAYHC9oHCQvuAYkL/QGHAOYCiAAwAYQAjgCFCvwCBgo1AQcKSwGKCiYChwomBAYLewAHC9YABwraAwkL2AIKC50ACwtaAQsLlgKPC2oAhwolBgcAnQOJAB8DBADXAQUAMwAGAFoCCADkAYoAwwCIALAChAC5AgYAkQQGANkEBgrCAAcKhQAKCu0BCgo6AosKmAKMAO8CBwChAwoAxAELAG4DEAAhAAUKGAAFCjkCBgoDAAYKdwAGCo8ABgq4AQcKVwIHCpYGBwo+BwgKqAEJCisACQpIAgkK+AIKCkgBCwqfAAsK/QAMCucBjAoTAgQLwwINC2oAEgsxAJMLKQAFAN0ABQtMAoYLiQGGAJ0FBgvTAAcLmgYLC+YBjAtxAQUKDgAFCnwDBgobAQcK6gCIChkCBADcA4gAuwOHAOMEBAp+AAgKewKTCiIABAo8AYcKGQaJCl0DBApAAAUKYAEFCtACBgpwAYsKZwGGAMAABACEAAUARQCHANoEBwopBgoKMAEKCiUCDAptAQ0K3AANCvAAjgohAAQAbwAHAGEDhgvbAAULRgIGC24GBwtjAAcLqgcHC8IHCAsDAggLBQMJCxcACQvrAQwLbAIOCzQAkQsyAIQA/wIHCzgClAsVAAYAKgAHAIgFBwDVBwgAgwAIANIBCQCgAg0A/AAUAGcAhQtTA4cAGgQGCq8AiQohAQUKsAGFCpEDBgAsAIgAcAGHCxADhAA6AoUAeACLClMCjAAdAAYA4wCHADUGBAtiAAcLVQUJC6YBCQueAgoLBwMLC9IADQsaAA0LyQGNC9wBjApQAAUKowOGCqIGhQAKAoYAYASHAPkFDADjAg4AwAGOANMBCwoOAgsKqwONCiIBBQoGAwYKZQYGCpYGhgrXBgYAgwaHAPQHBwqPBAsKpgMNCocBkQpMAIkLkwAGCgQBBwrMBQsLNQMMC24ADAuZABILKQCWCxMABgD/AQwAhACGCj0CBQA4AgYAigCHAA0FhAD8AwgAAgEJANAAiQBnAQQANQIIABcAiAA7A4YAWAEEAJoDBQD/Aw0L3QEOC3gAlAs9AIYA8AAFC9EABgseAAsLOACLCzEBBgCrAAcA6gMHACwFCQCfAQ4A5gASAEQABAokAQQK4AIFCmcDBgqZBgcKmAeJCkQCCQt7AosLLwIEC5YABQsvAYYLRwEGCj8AhwqYA4UKGQMIC8AACgtOAAoLKwILCzQBDQtnAZMLXwCHCxIDhwuwBogAkgEGAPICBgtmBgcLTwAHC/ABCQuKAAoLUAELCwwADAucAQwLuAGOCzEBBADMAo0AHwCFANYDCACzAggA2wIFCkMABgo+AAYKdgGHCm8FCQoWA4wKLwCLCywClwsBAAcLzAAHC58BCAsqAAoLVQALCyEACws0AgwLOwKVCwEACAB4AwcLYgKHC90FBAqHAYcKkQQFAE8DCQBIA4oAIwOJADcDhgARAwgAmAAJADUACQAMAQkAhQMKAAYCCgA9AwsAvAANAEoADgAuAA8AEQAPACEAEQAoABIAJAATABQAFgABAJgAAgAECwMABQv3AAULhAIHC+gCBwu3BAcLyQQHC3UHkguTAIgAFAKHAKkChAoPAYwAOgGMAKUCBACsAogAgAEFCx0BCQtDAA0L2QGPC1IABAr9AAUKIAIHCiwBiQpUAQcAbgAHAL8BCAAiAQgATwIJAH4BCQCJAgsARwALAJsACwA5AQwABQANAEUBjgAfAYYAGgeIAO8DigBBAQcAaAEHAKkBCQBCAAkAFgGKAIQChQoyAwUAgQEFCh0CBgpeAAYK8wEHCuYAiwpBAQQKmAMFChkABQoWAwYKyQEHClUDiAoUAwQAhAOFAF0DBQD+AAcA2QOIAEkABwCnB4gAqwKGCuUGhQo2A4QKegIECx0ABgsUAgcLXAYHC3AGCQsvAQkLXgEKC7EBCwthAAsLLQILC+kCDAshAQwLTwEMC1wBDAteAg0LdAANC+kADQvSAQ4LtQAOC9EADgvoAA4L7AAOCywBEAspAJQLYQATAFYABgokAAcKkgKICsYBhwucBoQA1QIFC/UBBwuoBgkLKQILCwgCDAstAo0L+QCGAMQAhQA/A4gA0wIHAGkHDQBQAA0AtQGRAEoABADgAwYAcwKIAOIDhwsOBYQKaAAFAFADBgBCAIgA/AIEACQABwBrBQoAzQCLAPMCBgAWBIYAzQWGALYDhAB3Aw4AwgGUAG8ABwBsAgcAPwMJCh4CCQo2AooK2AIGAKUAigCEAYsKBwEEAM8ChwCbAIoK1AEGC8UBkAskAIYLgQAFABUCBwDzAooADAOGALkFBABhAQYAkgAGAP0GBwCrAQcA3gMHAEQFCQCZAgkAggMLAH0DjgDUAAcKVwCOCiABBAAtAIcA6QQMAAcABwrcAwcKkwcJCkAACQr2AQwKIgANCgwADQrqAJMKTQAEAF8CBQs8AAYL+AEHC2YCBwuDBIwLAACHCo0ACAvGAAsLHQCMCxYCjABBAIgAMAOECmsCiwBYAAUK9gAICr0ACQpjAQkKAAIKCnwACgrFAQsKjwALCqABCwpbA40KVQEEC3sBhwt1BQQAWAKJAG0ChQBvAYYAMQIGAC8ChgCbBgYASQKGC0kChwvMBAQLdgAFCqYCBgsSAQYLaQEHC0sAjQu5AYcLGgeJC0kDBQA9AgYAHwEHCl4DBwpeB4oKswCECgUCjAu1AgULOgEGC90ABwujAQoLigILC4wBDAucAA0LcQEOC00BkQsvAIwKHAKICpsCCwqTAZIKUwAGAKAChQr5AgkAnQAKCoMAjApIAAcAygKGC8wBhgDIAYUAnQMFC6oChwtfB4gL/gGIC9sBhQv4AwkAEwAHC1oCCAuzAAoLDQOMC34ABgtJAYoLbwAGADYDhgDBBZALVgALAHEAiwtxAAULNQOGC5cGhQrBAQcAzwERAEUAiApnAAcK7AeKCoECBgDBAAcA8AAHAJIGCgAzAAoAgAILAJoBDQBSAA4A9wAOAEsBjgB5AQYA1wELAJsBjgACAAULRwAHC38FCQuEAQkLwAIKCwUBCgtrAgsLIwILC2sCjwudAIgAeQKHAHwEBgAqAgcAcAUMAIEABwr6BAcKagUHC9gHCQtRAQoLBQKSClcABwAjAwgAHgIGCrsABwqzBAgKfAEOCnUAlQocAAYKKQEHChkDiwqqAwgAtgELAGsBBwrQAQsKaQAMCucADgqCAQ8KZgCUCksABQsQAAYLVgAGC1sCBwskAQcLMQIICwEBCAt+AQkL0QIJCwoDCwtFAowL0gEGAM0CBAvmAYUL6wGEAGsDhAtIAAYLCQGHC08DBADtAIcAAgIGAIgBBwBBAIcA4weMCwUBhwuaA4kLlAEMADMCDgBlABIAgQAHCvIDCwrdAgsK9wINCiIAkgotAAcKeAYJCnEBCgpSAQoK6gELCpoACwohAgsKBwMNCk0AjQoSAQQAvAEKAJIAjAAJAIsLowAHAOwEhwD+BgkA3gAKACsAiwCEA4kL6gCKAMsDiQD5AoYAuwKIC7IBBgBcBAcAVgUFChQABgvFAAYKKgEHCpMCCAvNAIkK2wCEC+oBCws0A5YLMwAHCqAFCwpWAwsKaAMLCpkDDAonAg0K2AGOCm8BjAsNAIQAPQMMAPIAhAq3AYgKnQIGAFECBgvEAQcLOAGKC9sABAtNAQkLsAAMC2EBjQu7AAcAJAAIAMkAiABdAowA4ACECukAhgCWBYYADgcEAAsChQB+AgYAYQcJAL4DCQDLAwkA0AMMABwDDAAfAwwAKAMMAEMDDABEAwwAkgMMALIDDwDYAA8A6AASALcAEgC7ABIAwgASANQAEgDoAJUAMQCECuIBBgA7A4YAmgWHCloBhgD7BwYA8gAHAOMABwAtBggAaAAJAHEACQDcAAkAqwEKAIgACgDvAAsAQwILAP8DDQAEAA0AzAANADwBlABWAIYLlQYHAJQACAAcAY0APwCOAAoAhwtIAoYA4QQHAF0DhwpOAQUKGwMGCs0GiQtGAIQAJwMHC4cACAsHAAgLPgAJC/MACguSAgoLuQILC8gBiwv0AgkLiwGKC08AiQtsAJMAXgCIAO4Bhwt3AocKbgIHAOYFhwrWBgQKywCHCpAHBwuWAQcLywEIC14CiwvWAgcAGgUIAPkBCQDiAQoAfgALAOEADABbAQwAwQENABMADgDaAI4AswEFAAwBCgD8AgwAeAANACcAkQB/AI4LRAALCqYCjAozAQwLDAEMC4ACjgt3AIcK/AeFC2QCBAt0AQcL4gEIC54ACQtaAgkLZwIKC/UACgumAgoL6AILC/gAiwsmAwcKNwEJCjQBjAr/AAQAgAGHAP4DBQtWA4cLxweHCvIEBAqQAQUKCwGHCugAhwCnBgkAnwALAJUCjABbAgQAxAMOALYBDgC8AQ4AyAEWADwAFgA/AAkLagAJC6MACQsoAQoLpwAKC6wACgsJA4sLEACIAEcChAADAggAeAIIALkCiQBWAwULwwCHC5UGBgBjBIYAVQWGC0gBBwvNBwgL2gKLC+4DBACIAIUAJwKGAPYGBwAHBQkALAAKACgCCgCCAgsARwMMABIBDAATAQwAdAENAFsAjgB9AAUL7wILCx0DjAvLAIUA3AIHAKcCCAA5AQQKZACHCzUDCgBpAY4APAGGAFMCBgCTAAcAdgMJAPECigAMAQUKagEFCrsBBgo+AQcK+wOLCm8CBQrPAYgKKAEECsYBBQu2AwUL4gOGC18BigCJAAUKMAAFCpQBBgotAgcKygEIClUCCgrHAQoKXgILCjEACwokAgwK3AENChIAjQrCAYUAngGHAOIGBQulAYcLLwAFCroBhwrAB4YAVwKGANUGhgBbBgQA6AGEC14BiQvvAoQAUwCMAKQChQvHAwcAZwYFCjcAjAqhAAQL2QEHC28CCAsoAwkLZwMJC30DCwsmAAsLrwEMC3AADAvZAAwL8wAMCzICDAurAg0LjQANC8UADQvjAA0LlgENC+cBDgucAA4LywAOC+AADgsAARILOgCWCwAAhQrCAQcL4AKLCwgBhgAWAQQL3gAHCx4BiAt1AocKZQOMAGEAkAAOAIYAPQQECtUABwrfAIgKUAAHAIQBBwCEAosADQOEAFEDBwDlAAgAOwAJAL4ACgB6AYwAvwAHCn0BBwomAwcKNAMICmIBCAq1AQgKEwMJCpECCgo6AAoKUwEKCu0CCwqSAwwKogANCksADgpqAA4KxgAOCkABDgqdAZIKKwCNCzIBiArrAoYAWwQQAF4AEABsAIgLkgAGALwCBgAxA4YA6gOFCrQCBAvRAYcLfwaGCr8ABgCGBYcLkQOEAJQCBwALBIoA4QIGCqIABwqoB4gKPwOECsICBwCyAgkA2QAJAEsCjAAJAooKqgGHCtMEBgtSAAcLigAHCwUCCQuhAosL7gCKABABBQvvAQcLQgMJC90Ciwt6AYYA0AaEAPMDBws8A44LdAAEAN0CCQDCAAoAXAALAMYADABUAA0AgACFCy8CCgA5AAoAFQEGCxUABgvJBgcLpAWIC+AABArMAIkKhgOICkEDCwBcAQwAYwASAAEAEgALABMABAAHCm4BCQofAQwKxwAMCiwCjApBAgYAvQeIAKgDFQAhAJYAKAAFCwcCigvMAAUKZAGHCuAAhgAHA4cAMgEHCnYCCQo3AgsKlgALCrwBjQp3AAUA0wOGChsChQBjAgQLkgGHC48GBQCyAAcLAgAIC0MBiAvfAQULOwCHC6ACBADyAwYAsQeKC+0AhQucAZILIgAHC8wGkgswAIYAmAKLCi4DBAtVAIcLJQKFC14AhQvJAYQAhgGGAOYFBArrAIcK/wAECsIABQpIAgYLCwAGCoABBwu7AAcKRwIKCvkCCwr4AosKUwMECwoCiwsiA4cA7QEKCwgDDQtZAY4LqQGSACUABAs0AIcLlQKGANQChgA9A4ULCAKFCjICBAsZAQULJgAHC8IABwucAgcLZQeJC40BBQq/AIkKDwEHAAEGDgBgAI8ASQAFANkBCwCoAAQK1gEGCpkABwrfBQcKgwcKCr0CCwqEAAsK4wALCkABCwq0AQsKDQILClcDDAopAAwKHgENCmcADQocAQ4K/wAOCgYBDwp1AI8KfwCFAGkABQC2AQkAtgIMAHMCjQDSAIUKRwEGCigCBwraBokKXAKGAOgEmAALAAULwAELC2IAiwsMAgcAWgYFClAABgqVAQcKkwEHCt4FCArIAQkK5wEJClUDCQp5AwoKNQELCtECCwriAwwKrgENCqUADgsQAJILLACEAAsDCAAZAIoAOgMECsUBBQp3AwYKFwIICgYACAofAogKOgOJC80BjAt4AoQANAGHAOUChACfAgcAlgAIAIkCiAD8AwkAYwAGC1ABCAsoAgkLHQEKC2MAiws4AoYACQIFAFMBDgADAA8AKQAPAKYAkwBCAAYLpwEHC5kCBwu6BAkL2gCNC94ABgAfAgUKZQAFCwABBgpYAAcKjQYJCmQACgqlAg4KqQAOCi4BDgo5AQ8KMACPClQABAo2AQcKxAIHCuQDCQobAwoKhgEKCt0CCwrDAQwK+QAOCnMADgoeAY8KZACFCksCDQuhAQ4LgQCPCw8AhgBOBYgLKgKECvIBBwrZAAgKjACKCmIChwvdA4cLegIGAJsAjADqAIcLzgGEC2oChgBcBoQA/gIEC1MBBQqJA4cLAwGHAD0DBAv3Ao0LqQAHAKUFBArIAQcKZgEHCmUGCAqDAosK4wEFAOYBhwBFBQULsAKHC8gCBwBjBggAEQAKANkACgAnAQwAAgCMCwIAigAuApYKOAAECxYBBQvRAYcLVwWIC+IBhQoXAgYAUgUGALUFCgsSAQoLcQKLCxICBQBXAgULUAEGC1UBBgveAQYL4waIC4IBBwrUBokLlwCGAGAFhQobAocLSQCHC7MHiwsbAQkAXQCLANoBBgpbAIcKswEGAL8BBQuMAYYL9QEEChAABQo8AQUKSgMGCnIBBgryBggKpgALCiwDDArOAAwKXwEOCqIBEAoPABAKIgASCgMAEwoDABMKBwAUCgQAlQoVAAcAQQIHAJgFCQDbAQkA+QEJAA4CCQBhAgkAsQIJANYCCQDfAgkA4gIKACwCCgCiAgoArAILAFkACwDKAAsAEAELAHwBCwCfAQsA+QELABkCCwAmAgsAMgILAIACCwCbAgsAsAILAE8DCwCfAwsAogMLAKwDDACQAAwARQEMAEkBDACFAQwAkwEMAMMBDAADAgwAXAIMAGgCDAByAg0AQgANAIMADQCnAA0A7AANAHABDQCbAQ0AsgENAMUBDQDNAQ0A2gEOADsADgA8AA4AiwAOAJgADgAUAQ4AYQEOAJIBDwAcAA8AUQAPAHsADwCYABIAiACUAFgABAuhA4ULHwOICy4AjgAzAQQAYQIHAPQCCQAgAgsAnQGQABkACgCvAgcKawIKCiMCCwp6AIwKWQIEAKIDhQCzA4UAqwOOABUABAt8A4ULAgOFAMIDBQCLAggAqgAJAD0ACQA/AAoAFwAKACUACgBCAwsABAALALsACwAZAQsA9wELAKUCDABgAAwAggAMAPQADgAFAA4AKAAOAKIADgDKAJIAhQAEAJYBBQBDAgwA7AGWAA8AhwueAIcAVQKEANUDhAp4AwQKlQCKCnABhAAhAgQKmgAHCm4EiAppAIcL0QeGABYGBAofAAYKrQEHCsIDCQrKAYsKswKECjgBhwpqBgYAEQAGABgFBwAQAAcA6QMJAHYDCgDpAQoAIAMLAA4DDABAAQ0A0wEOAJEADgCDAY8AdwCHAL4HEQARAAcLtQWMC1sABArsAIQLWgKKAIsDiABuAAcAEAETADUABQpEAwUKWQOGCpAGBQDKAQcLwgSICy8BBwC/BwgAAAAIAKsACQB4AAkA3AIKANkBCwCQAgsA5gMSAAAAEgACABMAFQAKCkQAiwruAYkLlgIECw0ABQs3AgcL2gUJC3wACwsJAowLlQEEClEAiwpjA4cL7gMHCyADBwv3BooLDAAJACcBCgC7AQUKGgEICooCiQqLA4QL3wIEC6oABAoHA4cLQwEGADQHCgCcAwsLTAMMC2gAjAtxAgULMAEHC3sFjAvyAYYA0AQEAAcCCgBGAAwAGgAOABEADgCyAA8AIgCVAAwAhADhAwQLlACFC+YCBgAfAAcA6wEHABICCABQAgsANQALAAsDDACnAAwAmwEOAA4ADgCIAA8ASAAQABEAkABIAIUAiwOGAN0ChQtvAAQKRwAFCngBBwp3AIoKmQKIADcACACuAYgLrgEEANAABQBqAAYAEwIIAJgBCQC8AIoAPAIMADgACwo7Aw4KIgCPCpQAhgCdBoULvAGECt8BjAC5AQkAwQEKAMAAigDkAoYAoAMEAPEABwpfAogKYwAIC3sADwsGAJALBwAGCx0BCAuOAgsL7QIMC74ADAtHAQ0LeAANC3kADQtHAQ8LLwCSCygABAopAAUKSgAHClsGCwpnA4wKawIHAPUFCwpJAQsKxQMMCvEADgpiAQ8KFgCUCj8AhAADAYcLtwAJCtEAiQosAQULqQOHC2QAhQpiAAQArQAFADgBBQAAAocABQWNALkABwBDBgcAmwYJANABCwDDAAwAFwEMAMABDgALAJMAZgCHAFkEhQrYAwQAxAEFAEcChwDQAgQAIwIFADEDBgCxAQcAUQIHAGIFCAChAAkAHAEKADkBiwB2AwgA0gIECrYABgrNAIcK3ACWAA0ABAoqAAkKzQAJChIDigqTAgYAIQEHAIYGDAA5AJcABACECnsCDgArAJIAFQCLChUChwCeBggApAGLAMEAhwCZAYQKcwEEChABhwpEAwUKOQOGCmgGBQv7AAULvAMICwwBCQvWAJILjgCKADQBBgBHB40LJQCJCm8DBwo9AYcKOQKECyYBhgAWAwUA6gOIAOkCBQtaAQULxwKIC4YBhwAhAQUA+AELAEQAiQozAQQA7wAGAN0BBwBHBosAaQKVAA0AhQBhAoULcAIFCw8DBwvOB4cL/weFCg0ChABvAYQLUgIGABAChQrtAQQKrgCHCo8DCAqhAYkKDgOEALYCBwAkAokAOgAECiAABQrXAAYKDQEHCvYGBwpkBwoKEAALCjYDCwq6A40K4QGMAK8CBwDVBogK3QGECzkChQo0AYcKQAQEAJUCigDsAwULJQAGCycABgvDAQcL2gAHC5sCBwuOBAcLlwYIC5YCkAsCAAkAvQEMADUADQDsAQUKfgAICikBCQpuAYwKdgEHCg8GiwppAZQASgCGC/wBhwDVAIQKrwCECq0CBgD4AgYAQgOGAOAEBwvFAQcLewIHCxwDCAtLAQkLSAEJC0oBCQthAwoLdwAKC+sACwtvAAsLgQALC/AADAsfAAwLQgAMC94ADAsNAQwLVwIMC7ECDQu6AA0LbAGOC1kBBwCIBosAvQCFCh0DhQo1AgYADAYGC2IABwtJAocLvgIJAMgDDwDAAJUAOAAECvwABgslAAcLKwEHCiwEBwuCBggLwwAICzwBCQuyAAkLFAEJC1MBCQsYAgoLZgAKC2oBCgqyAQoLEQMLCzcACwuVAAsK5AALCqoBCwsFAw0K5wANC6ABDQujAQ4LJgAOCykADgvSABIKagCUClcABADvAgsAhgGMACAABACZAYUATgALC8oBDAsPAIwLsAEHAEIGCgABAQoAugILACACCwBJAgwA1AANADMBBQrnAAcKWQIJChUBCQqiAgoKsgAKCqIBCgr9AQsKEwIMCnEADArbAQ0KYwCOCqwBBgDZAZEAaQAGAJ0HDwCcAIULhQIHCjcGkAorAIcA8waHCpMGBAsiAYcLTAWGAPsCBgtGAAcLDAUKC/oCiwsgAY4AHQCMC6wBBwBzAwcLgwAHC6YBCAvSAIwLPQKGAOgBBAqPAQUKdwAFCu4BBwrvAokKLAKFAGkChAuoA4sAMgAHAO4FiwC2AokAEQMEACIChwD6BwcLzAINC2EAjQv7AIQLjQKRABYAhgD4AwQAOQGFAEECiAuRAggAuACNALEBhwCnAwYA0AIJAHIAkgtQAAwAugAMACQBDgBkABIARgAHClICBwpTAwcKQgcJCpsBCQo+AgkKmgIJCuECCgpaAQoKyAILCvYACwqwAQsKBQILCocCCwqnAgsK1wIMCjABDAoxAQwKQwEMCuMBDAo8AgwKUQIMCloCDQpfAA0KZQANCqsADQo7AQ0KegENCqkBDQrbAQ4KPwAOCnwBDgqAAQ8KhQASCnAAlApIAIcKRQSHCywHhAqnAokKywALAJIBDABtAAwArwENALMADQDOAA4A2QAQAAMAlAA1AAcLWAUIC+gACAtpAQoLqgKKC+YCiQrKAgUAdgMGAC4ABgD+BgcADgAHANwCBwB2BggAXwAIAEcBCABoAgkAfAMKAFYCCgABAwsAhgALAOsCDAB6AQ4AYQCJCxYCBADJA4gKOQOJCxsABgDXAo4LDACFAP0DhgCmBIYLeQYFCo8ABQoBAwYK4AYHCqoCBwrIB4gK4AKEAJkAhwt/AIUAHgOEAEsCBgBWAgcAKgAIALcCCgDUAAsAngAOAMQAkQBVAIUKXAMGAIkHhgCNBwUAvQMFAPADCQBBAgwAjQAGCqYBBwoAAAcKCAYIC2wBCwreAwwKxQENCi8AjQoKAYYAJwUEAIEAhwDRAQcA1gEHACEEBwCxBAkA8wILAIoDjAAPAgcAjAOSAAcABQCUAIgAwgEFCgMCiQqDAAcKRQYLCsIDkgqLAIQKhgKGAI4EBAqMAQcK2AIJCnUADQrKAJQKMwAGCnkABgp8AAYKZQEHCnIEBwoPBQgKogCLCo8CDgB2AY4LdgGKAP0AiwDrAwULjQMJC1EDigslA4UK7QAHCw0CBwsrBggL8QGICz0CiQAuAIQAbwOGACYDhwBMBwYALQeGADYHBgDaAoYAcQMHAMUDBwC0BQcARAYHC8EABwuNAQcLUQQIC3wACAtrAgkLMQEKCwgBCwsoAAwLXQENC4YADQsnAQ4LmwAPC3gAkgtpAIgA+gGPAAoABAsGAQcLVgEHCjsCBwpVBwoKbgGNCxcAhQuBAgoAFgAJCgECCgonAAwKegCMCrsAhwuXBZYLMQAEC2MABgv6AAYLWgEIC38AigtRAAYA3gcIAKADCgDAAwoA0wOMAOQDhgAoAYQLkwMFC0sACQsFAgoL1gEMC5sAjQvgAIkKaQMEAFYDjAsSAIYASwIHCmsABwpGAwgKJgKKCpEBCwB8Ag8AkQARACIAEwAyABcAFAALCkwCCwpgAwsKyAOPCqAAhwvYAAcA1gMKACAAjwA4AIUKAAOFC7oDBgswAQcLWgQIC6IBCgtZAQsLVQELC6MCjQsoAAkLmgGLC6kBiACtAwUAswGECn4DBQBVAAYAowEHAIYABwAxAQcAaQEHADkFCABHAIwABwKMALAChwDkAgUAswIHAFkBCQBeAIwAqQAFALcABgBGAgoApwKMALMBhgsOAAYAsQOHAP8BhgusBgULcQAGC/MABwtJBwsLoQAQCyUAkQtjAIQLEgGJABsCBwDJBwgArAKGChABBgCTAoYA1gMECgkABQqAAAcKcAELCuABlAoDAIYARwKEACMDhQDAAgQAswAFAMYAhQC5AgcAWwEHAMsDCAC1AAoAxwKHC6YAiAqqAgQKAgAHCiECBwp+A4gLCQKHAOEBhADzAAUAywAHABMABwBHAAcAcQAKAJUBCwBlAY4A8AAFC9UCBQvXAocLEwcGADoDiQswAQcAqgWLAGMAhQuOAoYA7AEFAIYABgCYAQYA7wEHADkGBgsRAQoLvAANC3kBkgtNAAkKAQOMCrkAhwuaAY4ABAAEAJkChgv5BgQA+AAHAIkAiQBdAQUKEgKOCnEABwD2BIsAZAKECwwDBQBzAYcAMwKHADoDBgD/BRcAFQCXABcABAB2AQcAIwIHAKQGBwApB4sAWgOFCiwCBwtkAggLIQIICzgCCAuCAgkLzQIKCx0CCgv7AgsLwQEMC+kBDQuZAA0LKAEOC4oADguIAQ8LMgAQCwYAEAsMAJQLCQAJADcBjQAqAAgKEACMCjgCBgCwBwYA6weKAN8DBgBvBgcAEAYHANoHCQDuAYkA/QGFC7QDBgq6AIkKqgGGAAEDhgCCAoQKSQIGAHsABwDWAAkA2AIKAJ0ACwBaAQsAlgKPAGoAjgt9AYcAmwUECxQCBQvCAocLlgIFC0UDhgtzBgQKXQAFCvwABgrlAAcKIwEJCiYCiwqEApQATwCJCu0ChgCRBYkKogAEC2oBBws0AAcLLwGMC6YAhAp9AQQLSgEHC6UDBwvcB4gLJAGHC/8CBADDAgUATAIGAIkBDQBqABIAMQCTACkABgDTAAcAmgYLAOYBjABxAYkLcwMEC78ChwvPAAQAuwAFALgABQCyAgcATQcKAPQCiwAPA4QLOwKGAGYFBQCvAAYKTQAGCp0ABwrOAwcKFQUHCjsFBwrSBQcKUQeJCnQChgDVBQULaQOFC8ADhgDvAwwLXQAMC/UBDQtqAQ4LlwAPCygADws7ABALLgARCxkAEgsOABILhgATCxkAEwtFABQLEAAUCxMAFAtCABULFwAVCxkAlgsqAAsKlwONCpkBhgDbAAUARgIGAG4GBwBjAAcAqgcHAMIHCAADAggABQMJABcACQDrAQwAbAKOAF0AhQBTAwULIQCGC9YBhwsLBYYA/gSHC1oHhwrRBYQA6AOKANYDCAD6AggALAOJAI4DBgsvAAcLWgAHC5gCBws+AwcLZAUHC+kHCAvAAYgLPAMEAGIABACsAwYAGwcGACoHBgAxBwcAVQUIAFsDCACBAwgAlgMJAKYBCQCeAgoABwMKAH4DCgCNAwoAjgMKAKcDCwDSAAwA7gIMAPMCDQAaAA0AyQENANwBEABkABAAbQASAK0AEgCvAAgKjgEJCqkCiwp4AgkLoQGJC+0BiAqFAooAigOGAMIGhgoUAIUL+wOGAKEECgAoAIgKAQMJAJMAhgvQAIwAigIFANEABgAeAAsAOACLADEBhAApAooLWAEGC0QABwuOAQcLwAEHC10GBwsVBwgLgwEIC7oBCQvGAgoLGgGKC9ICBQBVAg4AFACOCxQAhwBOBocK3QYEAJYABQAvAQYARwGHCqkDEAAxAAcKdAaQCzEACADAAAoATgCNAGcBhwASA48AhgAGAGYGBwBPAAcA8AEJAIoACgBQAQsADAAMAJwBDAC4AY4AMQGIC+sBBApDAgUK4gAFCkMBhwrAAwcAzAAHAJ8BCAAqAAoAVQCLADQChABmAgQLkwEFC7kBBwvCAQsLZQAMC8EAjQuuAYcLhweHCzIFBAADAAUA9wAFAIQCBwDoAgcAtwQHAMkEBwB1B5IAkwCIAK4DBAD7A4YA5wcFC6cChQrNAwUAHQEJAEMADQDZAY8AUgAHC0gBiQtGAZcACAAGCocAhwqYBIcLaASGAB0FhwsEB4cKOgEECz4CBwteAQcLAAQIC1IBCQulAgoLKAOLC/wBBwsyAxELDgARCy0AEgtLAJQLEgCSCgQAhws5BAQAHQAGABQCBwBcBgcAcAYJAF4BCgCxAQsAYQALAC0CCwDpAgwAIQEMAE8BDABcAQwAXgINAHQADQDpAA0A0gEOALUADgDRAA4A6AAOAOwADgAsARAAKQCUAGEABwA+AQYKGQEIChoBCArgAQgK8wEJCsYACgqPAAoKqQAKCtMACgqhAQoKPgILCpMACwqLAQwKSwAMCpcBDApgAg0K9AGOCvsAhwuMBocL9QeHAJwGBQD1AQcAqAYJACkCCwAIAgwALQKNAPkABgD3BQ4ARAEPADcADwBQAA4LRAEPCzcAjwtQAIcK8AYIANwDiQspAYQKowGOAN8AiwvqAAcAYwQMAPwBDgBmAA4A4gCQADkABAqKAAcK9AMHCgAFiQpMAAcA5AYFCh0AjAp+AoYA3weGAD8Gigs4AAYLMgEHC3QEBws8BQgLhQCKC8EBiwvzAwYKrgaHCvYHBwvjBowLNgEGAIEABAoRAAUKFwAHCuMDCwp/AQsKtQEMCswBjAoUAgULSQGICwQBhQpeA4QAFgIGACsDhwByAoQLkQIEABkABQA8AAYA+AEHAGYCBwCDBAwAAACYCwcABwDgBAsAbQKLAL4CiQBBAQgKRgAMCqsAjQoQAQoK6QCLCkwABAB7AQcAdQWGCroBBQtCAAcLaAeICyABhgtrBoYKrQYECxUABQtbAAULOgIFC4gCBQvuAgULDQMGCzYABgtwAAYLkgEGC8QGBws7AQcL7QIHC0MFBwtsBwkLTgAJC/wBCgtjAgsL/gELC9gCDQskAA4LJwAQC1MAEQt8AJQLHgAEAHYABgASAQYAaQEHAEsAjQC5AQoLQgEKC88CiwuXAZMKdwAMCyUCDgtDAJMLPAALCkUADAppAAwKdQANCtUADgoNAA4KPgAOCrEADgqlAQ8KEwCSCo0ACQBJA4kKNQEHCmACBwrQAwgLfQAIC3EBCAsMAgkKkgAKCs4ACgvmAQoKVAILCw0ACwt9AQsL4AILC/4CCwtNAw0LcgANCtoADQskAQ4LLwCOCpkADAC1AocL9wIFADoBBgDdAAcAowEKAIoCCwCMAQwAnAANAHEBDgBNAZEALwAGC5QGBgvDBgcLZAEHC4wHCAs2AAgL3QAJC+EACQtkAQoLTQAKC74BCgvbAgwLlAGNC+sBhAt3AQQKBgKHCnAEBACRAwQLmwELC4MCjAtzAAQLUACFCywACAqxAokKXwOKAHADBAoSAAcKkQAHCrwBBwr+BAgKMQAICpABCQpHAAkK+gAKCssBDAqgAJAKGACIANsBBQD4AwULKwGHCzsEBwBaAggAswAKAA0DjAB+AAYASQGKAG8AhwBIBwQL2wAHC+EGiQtWAAYAYAcGAGQHBgBtBwYAcAcJALkDCQDZAwkA3wMJAOkDDAAyAwwATgMMAE8DDABdAwwAXgMMAGkDDABrAwwAbQMMAG8DDABxAwwAdAMMAIcDDACTAwwAngMMAKsDDwC2AA8A2wAPAP8AEgC/ABIA0QASANMAlQApAAULSAGHC5YDiQAMAwwAUgCPACQAhQryAwUANQOGAJcGhQsCAoQAvAOGAJwECgBwAAUKVwAHCjkBBwpPBAoKRgILCoUBCwotAwwKgQENCh4BDgp8AJIKbAAFAEcABwB/BQkAwAIKAAUBCgBrAgsAIwILAGsCjwCdAAQAEwIFAMcBBQstAQYLOwIOCzEAkgtmAIQKCwEGAIEBBwDYBwkAUQGKAAUChQvWAoULbAEEC0wABwsOBgkLMgEJC64BCQuXAgoLqwILC6sBCwvxAgwLTgEMC7oBDgsCAQ4LbgGPC4MABgBJBwYAVwcGAFkHBgBmBwYAdAcJAJMDCQCeAwkArAMJAK8DCQDGAwkA1AMJAN0DCQDtAwkA8gMMAC0DDAAxAwwASAMMAEsDDABXAwwAYAMMAGcDDABoAwwAgwMMAIkDDACcAw8AqwAPALUADwDgAA8A6wAPAPsAkgC4AIkLNAAFABAABgBWAAYAWwIHACQBBwAxAggAAQEIAH4BCQDRAgkACgMLAEUCjADSAQQA5gEFAOsBhwphBAQASAAGAAkBhwAUBYcLnwQKCvkAiwrRAIQKMQKJCwcCBAuQAgQK+AKHCwsDCQqaAIwK5QGHCwEHhwuQAIgK/wCFAG0CBApwAYcKgQKHC10FBwsqAgcLXQKNCwoAiQDqAAUALwMGAJgGhgDbBgULRgMFC0kDhgtxBgcAwwcHAPgHiADnAoUL9AMGAMUAiADNAAYAOgGGCzoBkAs1AAYL+wAHC20BBwtNBQcL2QUIC5oAjQsZAYULVAEGAMQBBwA4AYoA2wCKAE0CBABNAQkAsAAMAGEBjQC7AAkKXACTClsAhgBWBAsALwCLC+8BBgoNAggKJgMJCmwDjAocAQgLBQEJC5AACQvSAQoLcgEMC9YBDQuQAI4LXAGJC4EDCABfAwgAYAMIAGQDCAB0AwoAYgMKAGQDCgBpAwoAjwMKAJADCgCwAwwA1wIGC/gACQsiAgoLFwILC6kCjQuHAAYALAGHAOsFhgDVBIsKvgOFClICjAv6AIYAlQaGCzcCBwCHAAgABwAIAD4ACQDzAAoAkgIKALkCCwDIAYsA9AIJAIsBigBPAAYKaQaICjQDBAouAYcK5gaGC64AhwohBYcAdwKGCooGhguLAYoAQwMHAJYBBwDLAQgAXgKLANYChgtpAoYA0wMGCoUBBwqVAAkKjgCKCl4ABQtuA4ULzAMGCggABwpZBwgKWwCIC/8BhQBkAoQLXwEEAHQBBwDiAQgAngAJAFoCCQBnAgoA9QAKAKYCCgDoAgsA+ACLACYDBQBWA4cAxweECx4BhwtYAQcLtgEHC3MCBwvsBQgLKAAJCzgACQsmAQoLHgAKCwMBCwvJA5ILlACHANQFBQsDAQcLngEHC1YDjgtrAIcK0gYGAEEDhgDmA4cKGAAGAO4ChwDLBgQK9wGHCn0GBQqCAAcKIgUJCmICCgrOAgsKWQILCjMDCwqyA4wKGAIKCpUACwoYAY4KUAGEC+IChwqaBwUAwwCHAJUGBwDNBwgA2gKLAO4DlwsRAIULYgMOAM8BDgDWAZYAPQAFAO8CCAAKAQsAQgIECogBhwo9BgUKsQEJCnkCiwp1AocANQMGAMsChgAtBYULdAAGAGQDhAvJAYYAvwMGCuoAigvHAAcAHQQHCp4HCAqoAgsKMQOTClgABwrGBIoKggEFALYDBQDiAwYAXwGGAGQEhgA5BAcAOwYGCgUACwr5AAwKOQEQCkIAkQoaAJQAOwAFCw8CBgu9AIcLWwMFCsMDBgrtBgsLaAALCyoCDws8AI8LfQCHAC8AiQCsAoYLdACGAEYGhgAJAwcA/AMICv0BiAoYA4cARgSEAF4BhQvnAQQLVgAFC5sCBQvxAgYLPAEGC8cBhwuyAwcAFAcNAAMBDQBkAQ4A8gCTAHIAhAqjA4UAxwMEANkBBwBvAggAKAMJAGcDCQB9AwsAJgALAK8BDABwAAwA2QAMAPMADAAyAgwAlwIMAKsCDQCNAA0AxQANAOMADQCWAQ0A5wEOAJwADgDLAA4A4AAOAAABEgA6AJYAAACKAB4BBwqvA4sKZgKHCi0HlgstAIQAHgMEAN4ABwAeAYgAdQIEC08ABwvtBgoLwgELC00CDQtMAQ0L7QEOC7cADgtOAQ4LagEOC3ABDgt4AQ4LewETC1oAEwtnABMLfwCUC1oABQBRAQsAAQILAHkDCwDBAwwAzQENAE8ADwB5AAQKWgAFCiECBwryAgkKugAKCkgACgoOAwsKQQILCmICDApiAQwKagGMClMCjQAyAYgAkgAHAG4GCQpJAQsK/gCNC3wABADRAYcAfwaEAA0ChQuXAgoAKwESAEoACQq7AAsK+AORCiwABwClAAcAlwMECvoBiAoFAgUKJwGHCpAGhQtOA4YAKAQFC3oBBwt6BQcLhgUIC9EBCQseAQoLuQAKCzICCgt7AgsLHwALC4kBDAvIAQ0LOAESC0EAEgtgAJMLWQCEAFQCBwrbAwkKsAIKCgoCCwoUA4wKNgIGAFIABwCKAAcABQIHAM0GCwDuAAQLiAKGCu8GBwDRBAcKvAIHCqwDCAoCAgkKdAAJChcCCgp2AAsKawALCpQACwqaAwwK/gAMCqUBjgruAAQAwgMGACAHCAB+AwwAxAIMANUCDgDDARQAXgAWADsAlgA+AAULsQMGC3gGBgv7BgcLpwAICzgDCQuHAQoLdwGLC7kABQDvAQcAQgMJAN0CiwB6AQQK5wKHC/kEBgC0BAcLbQYIC2ABiQv5AIsKJAGFAC8ChAuYAAkA8wEKAFUBDwCQABMAMQAHCgMFCQrjAAsKRQELCpgBDgq0AJIKLwAGABUABgDJBgcApAWIAOAAhQvuAwcApgUJAGEAEQAPAAUKUQAHCpIABwo+BQgKNQAICjECCAq2AggK8gIJCnMACQp+AwoKzgEKCi0DCwrmAAsKkQILCrsCCwrsAgwKdwAMCsgADAobAY4KEQEFCpgBiQrrAocLrwGHC0ADBgDZAoYAuQMEANcCCAA1AgULXwEHCwgBiAs1AoYAnAcFAAcCBQsoAAcLVgIHC2YGCAtOAAkLpgAJC4ACCQutAgkLBQMLC9cADQtBAA4LrAAOCz0BkQsGAAgLPAAJC1cBiwsBA4kLxwGGAKkEjAAWAwcLnwcIC/0CCAsEA4wLnwIHC2wACAvbAAgLhAEJC38CCQsHAwsLEwGMC9ABhAvUAQcKHgAIClYACAo7AQgKvAIJCkACCQpaAwsKNgELCngDCwqIAwwKaQGNCvgABQsPAAYLOAAHC94GCAv0AQkL2gILC0sBDQuWAI4LGgEEAJIBBwACAAgAQwGIAN8BigpHAwsARAKOAMkABQA7AIcAoAKJCmkCkgAiAIYLXgcEAMEDiACAAwYABQUFC80ABgu2AYkLxwKGCqwBBwoMAggKqQAICuoACQrgAYoKhgKUAC4AjQDfAYULFgIGAOMHhgpwBgQAVQAHACUCBwq1BIoKfQIEAJcCBQBeAAcL6wAHC8MFDwtEAJILeAAGC7sBCQvtAAkLOwIJC7cCCguLAAsLywIMC6EBjQulAYQADwMEAKoCCABBAAkKJwAKCqYACwqWAwwKewIUCgoAFgobABYKKwCWCjQABgALAIcAuwCEAAoCBAA0AIcAlQIEAH8BhQAIAocLIgILAFcBjgB/AAQLQgIHCp0ABwtwAgcLlAMIChcBCgsAAQsLVwCLC78ChgpcAgQAGQEFACYABwDCAAcAnAIHAGUHiQCNAQcKsQMLCskCiwroAosK/gMJAHsCiwAvAgULmwMHC+oBDAspAg0LZAAOC3YAjwtLAIQAzwOECjcCiQpbAwcKNgcHCzYHCAp0AogLdAKUAHQAigvuAg4AMwAOCzMADwsHAJQLFACEAFoDhgAzBAQLnAOFCvoCiAAXAoUAwAEKChADjQq/AIUKKgEHAGIChwDdBQcKeQIHCokDBwqNAwcKAgYJCv8CjAp8AgQLCQEHCycDhwu2AwULXQAMCwsBkAsaAIgAvwCLCi0BhwqyB4cACwEEAD8BBQC7AooAoQIGAFABBwBcAAcAtgAIAMUBCAAoAgkAzAAJAB0BCgBjAAsAOAILALYDDABeABAAFAAQAEYAEwA3AAwKhAKQCloABgAnAgcAHAUHCk0DBwviAwgKoACJCj4BEwsBABMLGgCWCwkABwB+BQkA2gCNAN4ABQAAAYoARQAFC+kABQtAAQYLjAAHC0oBiAsnAQYAvAeIALgDBABBA4kLpgKFC9IDBAuJAwYLpQaJC0sDigrfAogKTAARACcAlAAkABIAUQCSC1EADgBgAREANQASAJIAEgCYABMACwCWADYAhwB6AooKSQOEAGoCBABTAQcAAwERAEkABAsTAYwLeAGEC/0BBwsRAYsLeQEEAPcCDQCpAIkKJAMGCmAAhwqSBQQKiwKFCiEBBwAzBAgKIwAJCv8BCgr/ApMKdgAGAIkCBgCeAogA4gEFAFABBgBVAQYA3gEGAOMGiACCAQULIgMHC+UHCAslAw4LXgAPC0EAEAsEABALTQAQC1AAkQsFAAYACwQFC6cABQuDAwYLmgGJCwkDhgupBgUAnAOFAMkDhArAAocASQCHCwoAhwo2BAULCwAGC3UABgvlAQcLbQQJC0YCCQtSAgsLFQALCzIDDAsXAo0LVgCHALMHBAsIAQcLKwQIC8wACAuBAYsLuQMGALIFhwBABQUAjAGGAPUBBArQAoUKMgEEAKEDBQAfAwgALgAIAOQChQqvAQcLhgIHC8IGCwu+AY0LsgAHABQBBQrQAQYK7AAHCrgCBwqSAwcKVAQHCqgFCQoPAAkKNAIKCg4ADAo1Ag0KwQEOCjUADwoNABAKQACRCikABAB8A4UAAgMGCucGDArCAJEKawCHAJ4ABQpIA4oLYAKGAJgFigv6AAgLGgMJC5ABCgsqAY4L5ACXABkABwtrBIcLvAWHANEHCQqCAgsK7ACOCsEABApEAAUKegIGCoIBBwoaAwgKEQEJCjMCCgppAAoKqwALCl4AiwpiAYgL1AKEAN4BCwsAAg0LzQATCx4AFgskAJcLEwAHALUFjABbAAYLvgAHCwADhwuSBAQAWgIIANMABApfAAcKoAGLCj4DBwrbAg0KFACPCgsABgAsBIcAUAcEAA0ABQA3AgcA2gUJAHwACwAJAgwAlQGHC/8DhwDuA4QA3wKKACwDBACqAIcAQwEGC4kACQtLAAkL/QAKC8IAigu8AQUAMAEHAHsFBQpgAwoKiAILCp8CjwouAIcLnASFCqADBACUAIUA5gILCtoDjAqqAoUACwKHC88GBwDaAhIAkAATAD0ACAosAAkKdAMKCkQCCwqPAQsKfgOPCnoABQv4AgcLHgIIC4cAiAvwAYgA1QOFAG8ACgCEAAsAvwALAGYBiwDMAQcLPwEHC2MBBwv7AgoLhQGRCysAhgB6A4YAjAWICy0ChQoGAoUAvAGHAPsGhwo8BwgAewAPAAYAkAAHAAYA+QcKCyYAiwsQA4gApAMFAKkDhwBkAAYA4wMECzoABQseAQYLPwEHC5IBBwvmBAcLbwcIC2QBjAuYAQQLhQEJC7UACQv/AAoLCAAKCx0ACgswAwsLNwELCzECDAtDAI0LtQCKAP8ABQCKAAQKpgOICmICBADFAwoAXwOKAIIDCgokA4oKQAMMAHcCCApgAAkKJAAKCl8CCwqnAQsKugEMCjUBDgrHAA8KWgCRCm4AhgByBQQAjAIIAEABFgAGABYAEAAJCg0ACQqOAQkK1wIKCksACgq4AAoK5gAKCjQCCgo5AgsKzQMMCkYADAq9AA0KOQCNCgEBBgCBA4YANQUEALQChQBBAYULdQGHAJoDBQBrAoUAugKJCncCBQpZAYcK+AMJAL0DCQD6AwwAPAMMAEwDDACBAwwAhQMMAK8DDwC0ABIAxQASAMgAEgDVABIA1gCSAOIABQCVA4YAewaHAEwEhgCVBIYAigcFAPsABQC8AwgADAEJANYAkgCOAIUKoQKJClIDBAofAYUK+gOEC6ACBQBaAQUAxwIIAIYBCwvwAosLdQMFCiIACgrUAgwKvAENCmIBEgogABcKGAAXCh8AmAoFAAQLxgKGC14ChgDoAoYKfgGFC5EABApJAQcLdAOMC3wABAvTAQULlQGGCyACCQpOA4oKOwOFAHACCQt0AQ8LAgATCwoAkwsSAAQLgwGHCwgFBQAPAwcAzgeHAP8HhAqKA4gKbgGHCyYCBAp7AAQKiQIFCl0CBwrlBYgKJACGAGUEhABSAoUK/wKHC8sEiAvTAQQLQAKHC+8EBAAMAQcA/gWHC/4FBAoRAQUKkgIFC5cDBQrjA4YLiQaFADMChgpIAIcKQQUEC1IABQtNAQULiAMGC88ABwtFAQcLvgYIC2UACgsKA4sL3AAFACUABgAnAAYAwwEHANoABwCbAgcAjgQHAJcGCACWAhAAAgCFCk0ChgA0BYULhwOGAPwBBQp1AAYKAgIGCh0CBwqMBAcKnAUICtwACAqIAgoKsAILCjACjAuTAAYLKwKHC+UBhQquAgcAxQEHAHsCBwAcAwgASwEJAEoBCQBhAwoAdwAKAOsACwBvAAsAgQALAPAADAAfAAwAQgAMAN4ADAANAQwAVwIMAKwCDACxAgwAswKOAFkBhwAqBwQLwQIHC2cCigv7AIgLWQGJAA8CBgBiAAcAvgKHAN8DCwBAAg4ASgAHCsQACgr9AgsKWwELCigCCwoWAwwKBwENCvYADQoOAQ0KiwEOCrAADgq+AA4KjgEOCpwBDwogAA8KPwAQClgAkwppAIYLWgANAFQAjQB6AAYAJQAHACsBBwCCBggAwwAIADwBCQCyAAkAFAEJAFMBCQAYAgoAZgAKAGoBCgARAwsANwALAJUACwAFAw0AoAENAKMBDgAmAA4AKQCOANIABQp9AYcKAAcHCy0DDAvxAY0LOAAHCmgCigqdAYUAhQIGC30Ahwv9BIQAIgEGAEYABwAMBQoA+gKLACABBgp4AAcKpAQHCq4GCAoeAQkKmwILClACiwraAocL+AYHACMFhwsjBYYAoweHCnoEBwCDAAcApgEIANIAjAA9AgQKYAGHCq8CiwAdA48AJgAOALMADwCXAJYACwAHAOgBBArAAAUKMQAGCsgABgolAYYKoAaEAKgDhwu/AgYLoAAHC1IECQsCAwoLagILC3AAjAudAQUAxQGGALkBhwBTAoQKigKECpMABgDfAwYAngQMCw8BkQttAIUKpgOMC90AhACNAgcA+QGHAAsChgCHA4cL3wEHCzABCQuGAgkLXgMKCwYBCwu4AgwL0AAPC08AkwtsAJIAUACHC9UDjgCwAYQAOgGJC5gABwBYBQgA6AAIAGkBCgCqAooA5gKHCzIGCQAWAgQLsgELC5cCDAvSAA0LpgANCzYBDgt1AZMLKwAHC0MEhwvlBgYLJgKHC4wCiQAbAI4ADAAECn0CBQspAgcL/gKKCzgDBwvhAggLKgGIC8QBBwDgAosACAGGAHkGhQskAYoLhwAGAEwDhgBdBIcAfwAJCmMDigpFAwYAoASGALgEhgAOBYgAbAEGAIcFBwA2BQsAfQAGCqoABwuJAQgKiwEICucBCgtbAgsLzgCNCpMAiQvsAgQLkAOJC+gABAoXAogKagKJABgDBwu1B4gLzAKHC2IABQCNAwkAUQOKACUDBAB2AoQAuwIFC90CDgtnAJYKFwAMC54AEgsIABMLPgAUCwYAFgsEABcLAgCXCwkAhADIA4QKCgOECi4ABQorAwYKjwYGCrIGhwrwBwYApgUHCrIFCQqXAYsKDwAHAM4ABwCNAQcAbQIHAIACCAB8AAgAawIJADEBCQCDAgoACAEKAHQCCwAoAAwAXQENAIYADQAnAQ4AmwAPAHgAEgBpAAYKIgAHCkEECArEAggK0QIJCmsBlApiAAQABgEFAIEChwBWAYkLSAAEAGMABgD6AAYAWgEIAH8AigBRAIQAkwMFAEsACQAFAgoA1gEMAJsAjQDgAIQKzgELC1gCCwueAo0L9QCOAFMABQpJAAYKFwCGClIBBgAHBIsLmwMHC6QABwsjBgkLawCMC+EAhgC+BYUAugMGADABCACiAQoAWQELAFUBiwCjAgkAmgGLAKkBBAsbAAUL5AEFC/4BBguyAQcL6AMHC0oECAsCAIgLyACGAN4CjAsBAQcK1QIICvIBiwoMAYYAHgeHAAYHhwoFA4QLzAEEC6QDhQt7A4YADgCECkcCBwq2BQgLcQKLCpMCBQBxAAYA8wAGAKwGBwBJBwsAoQAQACUAEQBjAIUK3ACGC0wABQvNAYcLhQeMAEUACAtcAIkL3QCLCiMDhAogAgQAEgGGAJoDhAAdAgUAcwIGCrUBBgo0AgsKtQCNCrcAhwqoBAcApgCEC/sChQv9AIYAUQMJC0kACgtuAA4LuQCRC3cABQvUAAwLIwCNC34BhQDNAokAMAGIAFgChQCOAgYAEQEKALwADQB5AZIATQAEChYDBQoRAYYKigGEAB8ChwCaAQsAYgALAAwCjQBXAIQArQOHC5cEBAD6AAcATAYLALoADACFAAYKfwAHCucFCAplAgwK7wEMCkoCDAqUAgwKnAIOCoEBDwp2ABEKFACSCmIABgD5BoULMAOGADsFBwDBAwcAPQQHAL8GCADOAQYK5gCHC78GCQB8AocKogeEAAwDBQtlAwULyAMGC1oGCAveAogLEAMECx4CBgu0BgYLvwYHCzoEBwsJBggLOAAIC3YACAucAQgLNAIJC3gDCQuMAwoLMgAKC6cBCwutAgsLuQILC6UDDAsrAQ0LfgANC4gADQuqAI0LvgCGC+IABAvoAAkLygAKC9oBjAuxAYkL9AEFABECiApEAIQKjgIECpwABwrmAwcKFQQHCkQHCQowAAkKtAILCqMBiwpaAgcA/AQIANoBCQCMAgYLbAAHC+sDBwudBIgLVwEHC/AEBwuOBgsLsQMMC1UBDAvXAYwLOQKGC7AGBQC0AwwA1AETAGAAlAAYAAQLhQAHC8cCBwsSBQcLMQaHC4kHBgDxAowAkQKLAK0DBgtjAAcLEAeRCzkABgs+AgcLrAEHC+IECgudAgsL5QELC0gDDAssAY4L+gAEABQCBQDCAocAlgIFAEUDBgBzBosA2QMHAEUHCQrFAAoKLAEMCtkBDQpaAI0KlQGJC/wABgtDAYcLHAYEAEoBBABfAwcApQMHANwHCAAkAQcLzQEICwcDiguzAYQKXgIEC48CBwtSAxELSwCSC4kAhwD/AgcKugeICqQChACBAocLFwaGANEEiQDyABEAcgAECmkBhQo7AYkAcwOECs0BigASAYYA2AeGAAIHBAC/AocAzwAMAB0BhArYAYQAOwIFAGkDBQDAAwgANwMJAHEDiAtBAgcAaQIKAPIBCwD1AQwAEACMAJYAigrrAoQArwGFCpsACwAbAQsANwIHCqMACAo/AQkKkgEKChgACgqpAgsKyAAMCv0ADAqaAY4K2wAEC50BBQulAggLsAGMCxgBCQCRAQUK2wEHCvQGCwopAQsKLgIOCkIBkwpMAAYADQMJAIYACgACAAoAGwAKAE0BCwDSAo8AAQAFACEABgDWAYsAqAGHANYHDAAPA4cKpAeIABIBhwBaB4QAGgOHADgHBQqwA4YK6QYGAC8ABwBaAAcAmAIHAD4DBwBkBQcA6QcIAMABiAA8A4QKkACGAK8EBAuLAYsL+gKHC+AFCQChAYkA7QEJC64ACgukAAsLuAELC0kDjwtiAIYLqgGLC+oDhgAnAYYAMAMGCvcAiQorAoUA+wMEAGwCBQvcAQoKGAGKCh0DiwDQAQULTAAGC8oBBgvxAQcL/AIHC2QDCQuSAgoLUgILC60ACws2AgwLFAAMC1IBjQvIAIYA0AAECw4CBwsFBIcLHgSEC3wCBgvpAAcLlAIHC2QEEQsfABMLFgCXCw4ACgC6AYUKrAEKAKIDjAAKAwYARAAHAMABBwBdBgcA6QYHABUHCAC6AQgABAIJAMYCCgAaAQoA0gIHCrUGigoiAoYAaAQLAEwDDABoAIwAcQIEC7ABhws4A4oKvQCFABMDhQpjAAQLFwEHCy0BiQtqAQgA6wEECo0BiAorAgQLsgCFC48BhgDHApAACQAEAJMBBQC5AQcAwgEKAEgDCwBlAAwAwQCNAK4BhwveBAwKjgEUCicAFQoLAJYKKQAECuUBBwphAYcK8wUGCm4BBwpoBQcKQQaHC3gHBwCMAQoAoACHC4wBiQoaAYYLnAYECp0ABQrXAQYLygAKC8ABCwvQAAwLaAERC3UAEQt2ABILGwCUC0MAhQCnAokARgGICnQABwtoAwoLBAKLC6cAhAvgAAULIgIHCyMACAsLAAgLDAAJCzsBCQsVAgoLIgMLC6YADAsNAo4L8wAHAGgEhwuABwUL8QAIC/IACQvDAQoLmwILC1YCjAutAQYA4QIFCqAABwprAQcKTQIKCqoAjQo3AIcABAeOC/4ABAA+AgcAXgEHAAAECABSAQkApQKKACgDhgBIBIkLBAIHAJUBCgDrAQQKbAAEC24BiwryAQsLUQGOCy8BhgvIBgcAOQSMC2wBBwrtA4wKYQIHAIwGBAp/A4UKBAOHAPUHBgC3BAsLlAOOC6MBDguMAJQLKQAGC0sBiAtvAgkAsAMJAMkDCQD+AwwAkQMMAKgDDwCxAA8AwQAECp4DhQrXAwUAYgGHC/oBCABWAgkAmAKKALkBBAuAAoULAQKJACkBhAoaAgYKJgEHCvMEiApwAgcA7AYHC2AHCAshAQsLLQAMCxYBjAsZAocKLQWKAO8CjQAlAIYAJAeECvUChAuKAQYAAQGHAPIFBABGAgkAvwCHC4sHBws+AgcLtwaJC5EAhAuSAgoAFgOEC3EBCQsNAwoLkAALC4EBDQuhAA0L5AANCwwBlAtrAAgA1QEKAC8AiAt2AQYAMgEHAHQEBwA8BQgAhQCKAMEBiwDzAwcKUweLCnwABAtYAQYL8gGLC0MBiQArAYQARQOFC4oDBQBJAQgABAGKAAoAhgAoBQQAkQKSAJ4AhwCnBJgABwAGAJMHCADOA4oA5AOHAIEGCwt+AIsLHwGPAAgADguVAA4LjwGPCzkABQBCAAcAaAeIACABBwCvAAoA7gEFCpYACApbAgkKUQIJCnoCCgqtAAsKzgELCgMCDQrYAA0KIAGOCpABhgBrBogLFQAEABUABQBbAAUAiAIFAO4CBQANAwYANgAGAHAABgCSAQYAxAYHADsBBwDtAgcAkwUHAGwHCQBOAAkA/AEKAGMCCgArAwsA/gELANgCDQAkAA4AJwAQAFMAEQB8AJQAHgAEAJwCiAA6AgoAQgEKAM8CiwCXAYcLZQWIC8EADApsAI0KIwGEC2gCiAu0AggAfQAIAHEBCAAMAgoA5gELAA0ACwB9AQsA4AILAP4CCwBNAw0AcgANACQBjgAvAIYA3wQGAJQGBgDDBgcAZAEIADYACADdAAkA4QAJAGQBCgBNAAoAvgEKANsCDACUAY0A6wGHCvEGBAsxAQQK7QGQCjcABAC3AwYAEQcGADkHCABOAwgAYgMIAIMDCgCAAwwAtgKOANQBBQvWAAcLWwIIC2MCCQuuAgoLWAALC8sBCwvwAQwLzwEMC04CDQsAAI4L1gCEAJsBBABQAIUALACMC0oAjwAfAAcAnQIGCjgCBwoMBwgKagEICpoBCAo+AwkKAgILCokCjgqdAAcAoQKGC6cGhApxAoYAFwUFACsBhwA7BIoAwAIGABMBBwCYAQYKngAHCoEABwq1AAgKFAEICnkBCgoLAgsKMAMMCscBDQovAY4KhwAEANsABwBvAQcAsQYHAOEGCQBWAAkAGQIKAKUADADbAIwAMQIIANgABAoBAAQL4QIGCz0BBwp3BAcKtwUJCs8ACQqGAQkK0wEKC2IACwsmAQsKRAMMCzwADAu1AQ0LQAANC3wBjguuAQYL3gYICwgCCQtZAQkLkwGOC14BBQsvAAoL8gCKC0MCBQuLAAcLkASKCxsChwAnBQQKJwEECtMCBQp/AwcKBwQICscACApUAQkKmQAJCtcACgoVAAoKOwAKClAACgrgAAoKRgMLCuUACwqMAgwKwAANCpIAjgpbAIwArAGJCjMAhQACAgUKNQGMCtMABgDyAwUKfQAICk0AigoPAAQANwAFAC0BBgA7Ao4AMQCSAGYAiAtyAQQLawAHC2UCCAtmAQgLtwEIC/gBCQv1AQoLfwGLC90BhAvlAIUAbAGFCrcBBAuHA4cLGAcLAHsBjApMAAQATAAEAMsDBwAOBgkAMgEJAK4BCQCXAgoAqwIKAJkDCwCrAQsA8QIMAE4BDAC6AQ4AAgEOAG4BjwCDAIkANAAECy8ABgt1AQcLxAEHCx8CBwuyBgcLQAcJCwYACwsBAYsLhwEECggABwqABAcKgQQHCrMGCQp2AQoK3gGLCogCBAsRA4ULcAGHCksEhwtcAwUL1AOGC9oGhgDqBAYAIgQGAE8FBwsYAgcLMwWIC48ABACQAocACwOIClcABQsTAAYLFQKSC34ABwCQAIoKtgEFC4sBBQu3A4YL8AaHAF0FBwAqAgcAXQKNAAoABApFAAUKegAJCpACigrQAQUKUQOGCmEGBQBGAwUASQOGAHEGhQD0A4sK8wEHCtwBBwo4BooKVwAGAPsABwBtAQcATQUHANkFCACaAI0AGQGEC7kBhAu3AgcL8QEJC4MBkwtRAIUAVAEOChsBjgsbAYYAKgOHC2YHiwDvAQULHAEGCzEABgteAQcLAQAHC3kBBwudBggLEgAIC6YCCQuhAAkLSQIJC58CCQtHAwsLkAONC6sBBQpbAwcKiAQICmsACQojAQkKtwEKCpcCCwphAowKxQAIAAUBCQCQAAkA0gEKAHIBDADWAQ0AkACOAFwBiQCBAwYA+AAJACICCgAXAgsAqQKNAIcABABmAYcA2AWGADcCiAC9AQQKdQAGCnQBBwpxB44KQwEECtICiwrXAQYAuQKGAOQDBwvXBwkLZQAJC8IBCgtCAAoLSgMLCxgCjAtLAoQAQQKGADgFCQoFAAwK2AAMCiYBDAoqAQwKkAEMCgYCDQrlAI8KiwAGAK4AigCVA4YK7gYFCgwABwp3AQkKWAAJCrYBCws+AIsKDgGGC+YGBgsAAAcLVAAHCjADBwrZBAkKGwEJCggCCgrVAAoKMwEKCs8BCgqfAgoK6gILCpEBCwoaAwsLfwMMCgUCEQsLABIKawCTCnMABQBuA4UAzAMGC4EGBwsAAQcLbAWKC/MBBAoCAYgKfwIECxYABQsKAAYKFgAHC1ADBwqHAwcKqwcIC2EAigpBAgUKqQKICg4DhQvhAYQAXwEECpgCBQokA4sK9QMGC4YABwu1AQcLvwMJCyUADgsdAQ4LcwGQCzwABwvmAQgLmwALC10AjAukAIQAHgEHALYBBwBzAgcA7AUIACgACQA4AAkAJgEKAB4ACwDJAwsA4wOSAJQABQtPAocLUQGGAJ4HhQogAIoL9AEFC3wBBQuKAogLNgEEC2wBBwuEBAcLowSJC5kBBADiAoYL4gEECw0DBgvnAQcLngMICwcBiwv0AYcLogEGAP8HCgDJAwQKIQEHCnUCBwqiBgcKrwaMCtcABgrCAYgKbQCGADIDiArBAoUAYgMEC14AhwvxBIQLoQGGALsFhwrWBAQAzAMGADsHhgBBB4YAYwGFAHQAhADJAYcLgwUEC5gBBAvlAocL9AGGChoAjguJAAUADwIGAL0ABwBbA4gACwELAGgACwAqAg8APACPAH0AhgBNBgQKngEFCtMBCQqOAgoKwwEMCjsAjQp3AYcKEQCGAHQAhwsdAocKuwMGC0kAhwuxAIULQAKGAHYDhQDnAQQAVgAFAJsCBQDxAgYAPAEGAMcBhwCyA44L5wCWAC0AhgBfA4YAoQcGChgBCgr2AQsKWAGMCiYABABPAAcA7QYKAMIBCwBNAg0ATAENAO0BDgC3AA4ATgEOAGoBDgBwAQ4AeAEOAHsBEwBaABMAZwATAH8AlABaAAUKLQAHCokECwrAAQsKcAMNCosADQqXAQ8KEAARCl8AEgpCABIKWAASCnsAlQoHAIgKCQMECpoBhwoJAocK8gaHCxoCjgB9AYULnQGGAHYEBgClBIgL7wEFAJcCBgCqB4YA0wcHCzYACAs4AQoLvwAKC2YCjAs3AoQKtAGFAE4DCgAQAgsA+AEHCjMGhwqrBgUAegEIANEBCQAeAQoAuQAKADICCgB7AgsAHwALAIkBDQA4ARIAQQASAGAAkwBZAAcAgwMOAEUBBgvUAQcLNwIHC8YFCAsSAo4LIgEHAFgHCQCoAosAHgOGAOoGhACIApYLIwAFALEDBgB4BgYA+wYHAKcACAA4AwkAhwEKAHcBiwC5AAYL5AGHCzYDhgD+BwcAbQYIAGABiQD5AIQAmAAGAGMChwDFBgYLvAaHC+YHhQDuA40LYAAFAKQBhwCpBZILlQCHAEADhwqXAoUAXwEFACgABwBWAgcAZgYIAE4ACQCmAAkAgAIJAK0CCQAFAwsA1wANAEEADgCsAA4APQGRAAYACAA8AAkAVwGLAAEDhgBKBYQA1AKJAOkChAvaAQcAnwcIAP0CCAAEA4wAnwIHAGwACADbAAgAhAEJAAcDCwATAYwA0AGJAH8Chwr3AYULbgEFAA8ABgA4AAcA3gYIAPQBCQDaAgsASwENAJYADgAaAQULMQEJCzACjQvQAAQKcQAFCqMABQrfAgcK8QMJCgkACQoDAwwKWgANCooADQqaAY8KgAAECkQBigpoAIcL0gGOCxsAhgBeBwUAzQAGALYBCQDHAgQL4AEGC6cABgsuAQYLagYHC4IABwuQAgcLRQMHCwsGBwt5BggLrQEJC+QACguDAg0LIQENC1cBkwtlAIYAYQMGAOkHiADFAwcLFgEKC+MCCwvEAo0LXAGFABYChwuCB4kAswIECqcDhQo3AwYAuwEJAO0ACQA7AgkAtwIKAIsACwDLAgwAoQGNAKUBBQoNAQcKsgEHCnsDCApTAQkKvgILClICCwrOApEKZAAGABMGBwBuAwkK5QGNCggBhgqxBgcKEgcLCmIDDApnAI0K7wGHCoQDBgCCBQkLPAGLCwABBADjA4cACQSEAEICCgBxAwwA5AIMAOcCjAD3AoQANgOFAJsDjgqPAIcLoAYGC2sBBwujB4gL1QKEAJwDhQCZAocK7QeHAG0HBAAJAQYARAQGAIkFBwAnA4cAtgMFAF0ADAALAY0A8gGHAKsFBQstA4cL/gcFCnEChwpRBocA6wIGABQDiQA8AwcAuAALADMBCwCQAQ8AggAFC8gCBws/BwgKqQEICrUCCQrQAgoKfAEKCn4CCwsRAAsK2QEMCj0ADQtBAZALQwCHAMYABgtAAQcLDQMHC4EHCQs3AAoLugAKCxEBCguYAgoLIQMLC+QDCwvlAw0LnQCOC6oAiAsPAYcA4gMHC2cABwtfAwsLuAAOCysBkQs+AAsKJwKOCp8ABQDpAAUAQAEGAIwACAAnAQgAZwKIC2cChQDSAwQAiQMGAKUGiQBLA4QKqAAEAM4DCABSAwwAxQIMAAADjAASA4cKWwCYAAYAigoUAocKXAeEAP0BBgAbBYcAEQEFC00ABwuvBQoLSwMTC0kAlgsFAIQLygGHC4wFBgttAIoLfgEGAMkABgtKAQcKRgAHCzwECgrwAAsLjgCTCl0ABwARBIwLSAGFC2IBhgAQBIUAtQKGAAYDiwDqAIQAUAEHAHcFiwqIARQAFgCUCxYABQAiAwcA5QeIACUDBQCnAAUAgwMGAJoBiQAJA4kAFQOGAKkGBwqPAocKNAcECpEABgqwAAcKiwGJCjIChAr1AYcACgAFAAsABgB1AAYA5QEHAG0ECQBGAgkAUgIKAFIACwAVAAsAMgMMABcCDQBWABQAWwAXAA0Ahgr9AQQACAEHACsECADMAAgAgQGLALkDiwvhAooAOACGAH0HhQDWAQoLkQIOCykBjgtpAYcLnAEHAK4EBwuuBAgLLAIOC3sADgvAAI8LGwAHC8EHDguSAA8LKgAQCxcAEQtWAJILEQALAPcDiAt6AAQKcgAJCuwBDQrOAY4K1wAECk0ABQppAQYKiwAGCpEBBgqUAQcKnQEHCssCBwq0BgsKFwEMCrMADAoCAQ0K9ACOCmYBhgq1BgcKJQQIClIACwr6AAwKpAGNCrgAhQDLAocK1AIJAJcDCQCaAwkAnwMJAKUDCQDCAwkA6AMJAOoDCQD9AwwAegMMAIsDDACiAw8AzwAPAOQADwDuAJUAPQAIABoDCQCQAQoAKgGOAOQABQuuAQULpAMGC4MABwuhAQkLCgILCzoBjQuGAYQAYwMIANQChAv7AYkLBQEEC1cBhQv/AQYAvgAHAAADhwCSBAYKAQKHChwEBwvHAYoLTwKGACoEiQqDAw4AQwCTADwABAC0AxIArgCSALAAhwD/AwcKiQUMCn4BEQowAJgKDACGCz8ChAD8AgYKIQIHCjUCBwqFBgoKcgALCoICjApqAgYAiQAJAEsACQD9AAoAwgCKALwBBAD0AoUKBQAIAPADhwrAAIQASgMLAIMCDABzAIgK+wKLAEMAhQr3AgQANQMFAPgCBwAeAggAhwAIAPABhwtEAgcKcgEHCu8DBwqZBIcKHQaHCtUEjADgAgcAPwEHAGMBBwD7AgoAhQGRACsACAtNAYoLtgAEClcABQr6AI0KKgGKABIDhgD8BwgLSgGMC90Bhws6BYQLfQCGAAYEhgA7BIQL0QKHCi4DBwsIAwgLkQCTCzgAhgDKBAQKOQAHCqsEBwqeBQcKDAYHCisHBwpwBwkK9QIKClwCiwoHAgcLGAMIC5MACgs1A4sL/QOJCx0DBAA6AAUAHgEGAD8BBwCSAQcA5gQHAG8HCABkAYwAmAEEAIUBBAAvAwkAtQAJAP8ACgAIAAoAHQAKADADCwA3AQsAMQIMAEMAjQC1AAcLwAWHCxIGBwsvBAcLBQYHC+cGBwsOBwcLzwcJC/gACguQAQsLogALC7IACwvyAAwLXQIPCxoAkAssAAULqAAFC6IDCAtKAAkLbwIMC/QBDAtDAg0LKQCPC10ABgvcAAcLTQSNC2kABQDaAQcA+wEECtEABwv7AYcKhgOEAKsBBgCdAQcKTwEHCp0FBwqEBggKKQIICowCCAqQAgkKLgILCucClQoSAIQA2gIGCxMABwuFBYsLrAGFAHUBhAovAgcLYAAIC5EBiQuAAwcAHwMHALQHBQr5A4oK/wGHAAEHBwupBwcLrQcIC74CiAvuAggLlgAIC+ECjAtuAYQAQgGFCsUCCAsgAwkLlAAJC2gDCQt6AwsLNQELC+kDDQsLAY0LQwGGCtEGBwAiAYgKzgAHAHMGkQBZAIsAAgCEAKACBgBEBwgAiQMKAEwDCgBOAwoAWgMMALsCDADqAowABAOHC6gBhQsjAoUA4QIFC+oBBgtnAgYLbAKHC6sCBgDqAoYATAaECggDCQuBAZULEQCFAJEAhwr4BAcAdAOMAHwABACDAYcACAUFC4UAiAqWAYgLuwAGAKcCCAsIAIoLAACHACYChwseA4gLrQIHCz4EkQsuAAgKrwAKCqgAigo9AocAGQUEAEAChwDvBAYArgKGABsGhgBfAgUAlwOGAIkGlAAlAAgLBgMKC54CjAszAIUKEAOLCnIDBABSAAUATQEFAIgDBgDPAAcARQEHAL4GCABlAAoACgOLANwAhwtzAYQAvgOFAIcDBAt/AAULXgEGC2QBCAuqAQkLPAIKC/cAiws4AYwAkwAGCzsABwt1AwkLWwKNC40BCgBvAQkKDgAJCrkBiwoJAAsKxgMMCh8BDQpWAQ0KkgEPCm4AjwqjAIYAsgKEAMECCQCLAgsAywMNABEBBwqUBQcKaAYHCksHCQqpAAkKtgAJCm8BCQreAQkK+gEJCicCCQotAgkKiAIJCrkCCQrBAgkK1QIJChMDCQoaAwoKxgAKCtYACgoLAQoKEwEKCsgBCgonAgoKMQIKCmUCCgpzAgoKnAIKCqMCCgqzAgoKtwIKCsMCCgrLAgsKtwALCskACwoGAQsKYAELCrcBCwrtAQsKPAILCk8CCwpgAgsKYwILCoYCCwqiAgsKxwILCu8CCwr5AgsKCAMLChEDCwpSAwsKVQMLCl4DCwphAwsKZAMLCmsDCwqCAwsKhgMLCocDCwqOAwsKpAMLCq4DCwq9AwsKxwMLCswDDAqUAAwKwwAMCtwADArtAAwKPgEMClMBDAqJAQwKvQEMCsIBDAraAQwK+QEMCv0BDAoVAgwKTwIMClICDApVAgwKbQIMCnkCDAqCAg0KOwANCjwADQqRAA0K7wANCvoADQpJAQ0KWAENCm0BDQp0AQ0KgwENCpMBDQqeAQ0KyAENCtYBDQreAQ0K4wENCukBDgo3AA4KOQAOClEADgpaAA4KlAAOCu8ADgoKAQ4KQQEOCkYBDgpHAQ4KSgEOClsBDgpjAQ4KkQEOCpQBDgqbAQ4KngEOCqABDgqkAQ8KPQAPCkoADwpXAA8KWAAPCl4ADwpgAA8KdAAPCpUADwqaABAKMgAQCj8AEApJABEKAgARCkIAEQpcABEKZwARCnAAEQp4ABIKMgASCjYAEgpSABIKVgASCloAEgpvABIKcwASCpwAEwooABMKTwAUCk4AlQoWAAcAdwMFCqEAhwpHA44LYgCGAFoAigtkAYcLuQEGC28ABwsEAAgLowAICwgDigs2AoYAjAOGAO0EBwAtAwwA8QGNADgAhgDTBIcArQGHC8oHigCIAwYAfQAHAP0EiQAEA5cADAAEAEkDBQCCAYULggEFCykBhwsOBAYAXAMGAC0Ehws1AYgAsgOHChYHjQuiAYgLawEKAAADiwATAxYLHgCWCyEABgCgAAcAUgQJAAIDCwBwAIwAnQELC9gAiwtUAYgKiwCHC24FhwsoA4QLGAEMAA8BEQBtAAcKgwKICuwAjAs2AAQLpQGFCyQCCwDPAgwAJACNAFEBBwBFAgkAhAKJALsCCwv/AQ0LigEOCyoBDgs+AZILZwAHADABCQCGAgkAXgMLALgCDADQAA8ATwCTAGwABAB3AgcAZgSHAAAGhwv3BQgAcAMKAGUDigCRAwcA6QUFCjYABgv+AAkLbQCKC2cAhwDVA4UL2QKECugChACyAYYAJgIHAKIDCgDcAQ0AxAETAGgABgteBgoKkgGSCjcABQApAooAOAOIAMQBCACXAIkKcAKECjwChAAEA4ULnwKFACQBigCHAIQLeQOMC88ACQD4AQYKKwAHCiYACAr4AIoKAQIGAEEEhwt2BwQLcwKFCwcDhwAPA4UK/gKFCmsBBwCDAYcLgwEHAIkBCgBbAgsAzgAHC8oACwtqAQsLtAOMC4QBBgv7AQcLwwEIC4UBDAvqAQ0LEAANC9cADQtfARILhACTC30ABACQAwkA6ACHC0kDBgoCAYwKmQEFCvkAlApSAIgLNgIGANEDhwu+BAcAtQeIAMwChwBiAIUA3QIFC5ADhgufBgUKiQEGCnoBBwq9BwkKIAAJCk8CCgqtAgoK5QKOCn4BhQoUAwoAEwALAI8DBwqwB40K/QEFAJwCBQvsAAYLPAIIC+wBCwtqApALOACHC/0GBABoAQUAewIFALwCBQo6AAUKqwAFCqsCBgojAQYKNgIHCnIGCwoLAgwKEQEMCi8BDwonAI8KbwCFAIUDhgpNAgULvgCICz4BjACQAgcA1gKYAAkABAqVA4UK7QOHCj4GhgvrAQQKlwOFC7IBiQBIAAYA9QQGAB4GhgBVBgkAzwEKAFMCBAr/AAUKLgEGCoQABwqAAAcKGwEHChMFCgo0AAoKAgILCp0DDQpcAI4KNQGHAK4FhgAHBQsAWAINAPUAiQqtAIgA3QMHAKQABwAjBgkAawCMAOEABgAlBI0KugEEABsABQDkAQUA/gEGALIBBwDoAwcASgSIAAIABwtVAAcL9wAIC0kCCgujAIoLPAELC2cAjgsAAIYAZwQEAMwBhgBUA4YK0gAEAKQDhQB7AwYATAKTC1MACABxAgQKHAGGCt8AhgBMAAgAXACJAN0ABAt8AAoLyQELC3kACwupAAsLpgELC2YDDAvWAA0LhQEOC7sAjwtNAAkLagKKC+IBBAraAAcKDgKPCokADQAJAA4AaAAOADcBBAoOAQUKwAAGCkwBhwoqBYwKlQKHC6kEBgtrAAcLfgIHC2AGiQuMAYQA+wIEAG4CBQtyAYYL3AaFAP0AhwAiAgkASQAKAG4ADgC5ABEAdwCFC8wABwBwAgcAlAMKAAABiwBXAAcKewEICuEBiQp5AQUA1AAMACMADQB+AQULygOGC6oGCQDqAgUK6wOGCpUACgCWAAsAUQMNAEoBCAoGAQkKcwILCtYACwqUAQsKyQELCgwDCwqRAw0KkQGOCsgAhgC6BYcLAwAGABMFBAsjAAULeQAFC+MBBQutAgYL6QEHC7QEiAuKAYcK5gIECo4AiAowAQQLmQOFC+8DhgDuBQYAzQSHAJcEhQAwAwwAnwAECtcBBAvIAgUKMwAGCloCBwqdAwgK5AGKCsMAhgtdBgUAZQMFAMgDBgBaBggA3gKIABADBAAeAgYAtAYGAL8GBwA6BAcACQYIADgACAB2AAgAnAEIADQCCQB4AwkAjAMKADIACgCnAQsArQILALkCCwClAwwAKwENAH4ADQCIAA0AqgANAL4AiAqwAoQKuQIEAOgACQDKAAoA2gGMALEBiADUAAYAbAAHAOsDBwCdBAgAbwCIAFcBBQrdAIcL5wSFC+UBhgCwBo4A2AAFAIMCBgAEAgQLHQEFCz0BBgstAQcLBwAIC5kACgv+AgsL1AEMC9MBjQuPAAQAhQAHAMcCBwASBYcAMQaGAIoChwsAAgYAYwAHABAHkQA5AAYA9gAGAD4CBwCsAQkAGQMKAJ0CCwDlAQsASAMMACwBDgD6AJEANwAECoQABQpFAIcK2gSIAP8DBwAuAYQKbwCHAE8HhADYAgkA/ACECv8CBgDNAQcANgYHCogFBwrVBwgKgwAICtIBCQqgAg0K/ACUCmcABgBDAYcAHAYHAM0BiAAHAwYKLACICnABiwCsAIQA0AEECjoChQp4AIkLDQEGCuMAhwo1BgYLtwYGC8cGBwvgBwcL5AcIC0UDiQtUAwcA1wKSAEkAhAD/A4cLVAOHCvkFiABBAooLOAKGAA0ECAtDAIoLowEEAJ0BBQClAggAsAGMABgBCgBYAgYKgwYHC8cDBwr0B40LCwAGCv8BjAqEAAYAHwMFCjgCBgqKAIcKDQUIAJ8ABAo1AogKOwMHAIYCBwDCBgsAvgGNALIABAqaA4UK/wOHCwsAhACLAQsAkQCHCuoDCQCuAAoApAALALgBCwACAgsASQMPAGIAlQAUAIYAqgEKAGACiwDqAwcLQAEICzMADAvhAQwLOgKUC2oACQDRAwkA1wOEC70BigD6AIsAZAAGAL4HiAqSAYUL7wAECswCjQofAAUA3AEHC1MABwvGBwgLggCLC9ACCAqzAogK2wIFC3sABgsSAgcLXAGHC4sFBQBMAAYAygEGAPEBBwBkAwkAkgIKAFICCwCtAAsANgIMABQADABSAY0AyAAJC4sACguPAQsL1QEMC3oCjQvfAAkKSAOKCiMDhQpPAwsL3wCMC6gAhAvSAAgAvwEJCjUACQoMAQkKhQMKCgYCCgo9AwsKvAANCkoADgouAA8KEQAPCiEAEQooABIKJAATChQAFgoBAJgKAgAEAA4CBwAFBIcAHgQTCzsAlgsCAAQAfAIGAFMHBgCABwkA5wMMACcDDAA5Aw8AswAPAL4AEgC2AIgKFAIGAKMGBwCUAgcAZAQRAB8AEwAWAJcADgCHCqkChAuuAYwKpQIECqwCiAqAAYQL9AKFC9UABwC8AAcKbgAICiIBCApPAgkKfgEJCokCCwpHAAsKmwALCjkBDAoFAA0KRQGOCh8BBwpoAQcKqQEJCkIACQoWAYoKhAKOC6QABAAXAQcALQGJAGoBhgtKAocAzwYEALIAhQCPAQQKhAOFCl0DBQr+AAcK2QOICkkAhQtsAAcKpweICqsChQvbAAQLwQAFC5QDBwtsAQoLjgEKC9YCCws9AQsLcgIMC44ADAsgAQwLpgINCzkBDwtxABILcgAVCx4Algs1AAYL8QAHC4sDCAtAAwkLVgEKC9kCCwscAQsLvQELC4sCCwtfAw0LjgGSC2MAhABoA4YAPwOGAJwGBgDKAAYA7gMJAEADCgB8AgsA0AAMAGgBEQB2ABIAGwAUAEMAiQveAoQK1QIHC+EDiguaAoYAogeGCsQABwBoAwoABAKLAKcAhQo/AwQLMgIJC/4AiwtvA4kAOQEEAOAAhAsSAwsAGAAMAKoAiArTAgUAIgIHACMACAALAAgADAAJADsBCQAVAgoAIgMLAKYADAANAo4A8wAHAJEHDQpQAA0KtQGRCkoABQDxAAgA8gAJAMMBCgCbAgsAVgKMAK0BlgAuAAYA+QSJAD4DBQpQAwYKQgCICvwCBgA5A4YA4QMEAO4DCgBHAQ0ADwEECiQABwprBYsK8wKGAP8DhwAsBgQAbgGJAAQChAp3AwYAyAaHAGMHBgvYAAcLhQMHCz8FiAvtAQYKpQCKCoQBBwtVAYsL2wAECs8ChwqbAIYAjweEADoDBgBLAQYARQYIAG8CCwCLAIsAqwCHC8YGCgtzAAsLpAEMC5oADQuUAQ4LWgEPCzYAjwtwAAcAIAEECmEBBgqSAAYK/QYHCt4DBwpEBQkKmQIJCoIDCwp9A44K1AAGAJQDhgA4BgcAYAcECi0AhwrpBAUL8wOIC70CiwtUAgQLNgAFC5oCBwsPBAcLagQJC8MAigsuAYYAvwWGACIGhACKAYwKQQCICjADhwCLBwcAPgKHALcGhgvTAYQAkgIJAA0DCgCQAAsAgQENAKEADQDkAA0ADAEUAGsAhguFBogAdgGHAN8CBABYAQYA8gGLAEMBBwBKAgcAJwQGCi8ChgqbBokAmwCFAIoDBwt6AAkLAwEKC1QACwvWAQwLHQKNC3sBhgBzBAoAbACLAHQAhgrIAYUKnQMFC1IABQuDAAcL2wYICx8ACQuoAAkL/AKLC2UDhgtdAgULFgGJC0QABAujAAULyQAFCzMBBQs2AQYLTwEHCxwBiAulAIcLfAYGCyEAhwvcBAQAaAKIC+MBCABZAwgAhgMIAI4DCgBvAwwA1gIEC8cAiwsiAIgAtAIGCsEABwrwAAcKkgYKCjMACgqAAgsKmgENClIADgr3AA4KSwGOCnkBBgA3A4YA1wOLCpsBhAAxAYgKeQKKC8sAhgCpAgYLRgEHC6UCiQupAQUA1gAHAFsCCABjAgkArgIKAFgACwDLAQsA8AEMAM8BDABOAo0AAACIAOwDjgAXAIYApwaTCwgAkQs4AIcAowUECu0AhwoCAgYAygKRABMABQtmAQcL2QEHC6AECguWAg0L1AANCzABDQtNAZELYgAEAOECCgBiAAsAJgEMADwADAC1AQ0AQAANAHwBjgCuAQYKiAEHCkEAhwrjBwYA3gYIAAgCCQBZAQkAkwGOAF4BBQAvAAoA8gCKAEMCBQCLAAcAkASKABsChgCzBQ0AhAGNC4QBhgD9AAcK7ASHCv4GCgD8AAkK3gCLCoQDjADpAoULsgMEAGsABwBlAggAtwEIAPgBCQD1AQoAfwGLAN0BhwvNBYQAZwMHC5sBBwtOAggLdwIJC0MBCgtjAQsL6wEMC48ADAuSAQ0LSQAOC5gBDwtrAJILRwCEAOUAhACHA4wARwCFACUCBAAvAAYAdQEHAMQBBwAfAgcAJAcHAEAHCQAGAAsAAQGLAIcBBwu7BQgLSAEKCyACCwu7Aw0LQAGRC1MABQDUA4YA2gaIAGEDBQDBAokAXgIHAKEACArJAIgKXQKPCyMABQtDAwYL4wGMCuAABwAYAgcAMwWIAI8AhgBsBQUA1AIKADEBCwCXAAwAIQAMAHkADAB9AREAAwARABsAEQBOABIAEgATADYAlQAFAAQKCwKFCn4CBQATAIYAFQIFAIsBBQC3A4YA8AaHAHQHhABOAwoASgALAJcCDADSAA0ApgANADYBDgB1ARIAXwATACsABgryAAcK4wAHCi0GCApoAAkKcQAJCtwACQqrAQoK7wALCkMCCwr/Aw0KBAANCswADQo8AZQKVgAJC8wCCwtsAA0LewAOC/wAEwsmABULAwCXCwsACAB0AQkAegCKAK8AhAulAgcLXgWICxwChwpdA4QAtwIHAPEBCQCDAZMAUQCIAKkDhgDOAgcAMAWICu4BhAtLAQYALQaFC+sCBQAcAQYAMQAGAF4BBwABAAcAeQEHAJ0GCAASAAgApgIJAKEACQBJAgkAnwIJAEcDCwCQA40AqwEHChoFCAr5AQkK4gEKCn4ACwrhAAwKWwEMCsEBDQoTAA4K2gCOCrMBCgr8AgwKeAANCicAkQp/AAQAVQKFCgwBhgBGBAQA8AOGALUHhAArA4sAjAOHAL8FhQtGAQQKgAGHCv4DBwCPBwgARAEMACoABAuzAgcLjwcIC0QBCQsjAAoLqAILC2wBDAsqAA0LZQGSCxAAhwDeBwcA1wcJAGUACQDCAQoAQgAKAEoDCwAYAgwASwIGCyAABwuBAQcL9QIHC3wHCAslAAgLXgAIC8cCCQsdAgoLogAKCxsDCwvdAwsL8gMMCw4Ajgs0AYsASgKHCqcGBwA1BAsAHAAJCp8AjApbAgYAxQSICkcCBguYAAYLXQEGC5IGBwvkBAgLcAAJC7MBCQucAgoLIgEKCz8BCgsvAwsLtAALC0UDDAvwAA0LmAANC9sAjgueAIsAPgCECgMCCAp4AggKuQKJClYDhgDmBoQLRQIGC34ABws9AggLjQGOCywAlgAcAAsAngIWABkABAqIAIUKJwIGAIEGBwAAAQcAbAWKAPMBBAAWAAUACgAHACgGiABhAIYK9gYFAOEBBwoHBQkKLAAKCigCCgqCAgsKRwMMChIBDAoTAQwKdAENClsAjgp9AIULngMHC9AEiQsTAgYAhgAHALUBBwAgBwkAJQAOAB0BjgBzAQcA5gEIAJsACwBdAIwApAAGAG8FhgCiBYULngKFAE8CBgqTAAcKdgMHC6UHCQrxAooKDAEFAHwBBQCKAgcAlQSIADYBBABsAQcAhAQHAKMEiQCZAYcLVQaGAOIBhQv6AQQADQMGAOcBBwCeAwgABwGLAPQBigqJAIcL8gCLC2AAhQqeAYcK4gaGACQDBQtCAwcLsgQICw4ACQvhAYkLcAOGClcCBABeAIcA8QQEAJ8BhAChAQUAXAEGAAoCBgrVBgcL9gWKC9EBhgpbBoQA9AOECugBBAtlAQYLrAAHC48AiQudAQQKUwAEC04CkgtMAIwKpAIHCx8BCAtjAQkLJQGJC+cChgoWAQYACwcSAKUAGAAVAAULqQAHC00BiAstAAwKYQCMC2EABACYAQQA5QKHAPQBhAvGAAcKhAEHCoQCiwoNAwQLGAAFC4wABQu5AAcL3AULCzUCiwtGAwYAKQUJAAEBBwrlAAgKOwAJCr4ACgp6AYwKvwAEC04BhQtRAocLXQeGAHIEBAD5AAYASQCHALEAhQBAAo4A5wCJACABhAqUAgcKCwSKCuEChwDPBQYA3QMJALEBBwqyAgkKSwKMCgkCBwDwBAcAjgYLALEDDABVAQwA1wGMADkChAvFAoULgQMFC+AADQuuAJILNACHCzAHhgrQBgwAVwAQAEoABArdAgkKwgAKClwACwrGAAwKVACNCoAAjAALA4cAGgIEC2AChQvxAYUAnQEHC18FBwu6BYoLSwGIAO8BBgscAogLiAAHADYACAA4AQoAvwAKAGYCjAA3AgYA1AEHADcCBwDGBQgAEgIOACIBhQvnAwQLKwEHCjIBhwvsA44LKAGGAMwFhQrTAwYAYQIJAC8DDAuJAA4LCQAOCxgAjgtAAIULyAEGAOQBhwA2A4UKsgCIC7QAhAvzAokAhAOHADcFBgC8BocA5geHC3MEBQCAAoQKhgEGACcHigt5AocLNgIEC3oDBQslAwULMwMFC8EDBguMAQYLXwYGC44GBwuvBwcL+QcJC3YCCwsIAAsL+wMMC7AADQvhAA4LJAGVCxgAhADaAYYATwSHAOAFhgAoBgYAwQMGAAoEjACPAgsLAgKVCxQABQAxAYcLFwcHC+EFCgu+AAoLegILCxgDDAtmAYwLvwEFCwAABgsYAgcLXAINC70BkQt+AAcA1ASFCmkABADgAQYA2QAGAC4BBgBqBgcAggAHAEUDBwApBQcACwYHAHkGCACtAQkA5AANACEBDQBXARMAZQAGC+gABgucAQcLMgQICwkACAudAAgLEgMJC8QACQtgAQkLyQEKC1EBCwvoAAsLbQMMC+ABjAsiAgUKtgEHC74DCQq2AgwKcwINCyYAjQrSAAQLfgGIC0MCBwAWAQoA4wILAMQCjQBcAQQL1ACHC7YEhwtqBwYAxAIGAEAFmAoLAIkLAAOGADAHjADpAAgKGQCKCjoDBgDhB4ULjwIGANAFiwsiAYQKNAGGADYGhgAIB4YA6wQQABwABgvnAAcLXwCIC6cBhQssAYcKlgCICokCBwtSB4kLgQIGC+0ABwtjAggLZAAJC6ABCwtPAQwLrQCSC2UAiQAtAIYKCQIRACQADgsaAJILlgAHAKIFDgAWAAUKUwEPCikADwqmAJMKQgAIAHoBBgtFAocLXwSGAOMFkwt1AIsAJwCGAB4EBgBrAQcAoweIANUChgD0B4ULxwAGAE8HCQCnAwkAwQMJAOwDCQD4AwwAJQMMAFQDDABVAwwAZQMMAHIDDACAAwwAigMMAJUDDACsAw8AqgAPALAADwC8AA8AyQAPAM0ADwDUAA8A6gAPAPQAEgC1ABIAwQASAMQAEgDJABIAygASANIAEgDZABIA6wASAOwAEgDtABUANgAVADcAFQA6ABUAOwCYABYAhgpcBokAJQMFAC0DhwD+B44LKgAFAMgCBgDYBAsAEQANAEEBkABDAIQAaQKHCj0DBgBAAQcADQMHAIEHCQA3AAoAugAKABEBCgCYAgoAIQMLAOQDCwDlAw0AnQCOAKoAiAAPAQUK5gGHCkUFEgtbAJMLRgAKAL0BBwpjBggKEQCKCicBiAuUAQcAZwAHAF8DCwC4AJEAPgCKCi4CiQCTAgYLOAEGC7MGCgtIAgsLIgILC7QCDAsDAQwLJwENCy4AjQuaAIYApAKEC0wCBAvnAAULPQAGC2gABwvZAgcLxAMHC3oGjAueAQYLBwGKC/UCCwBRAY4ALwGHC1MFhAtAAYwA+gGGCr8BBQBNAAcArwUKAEsDkwBJAAcKQQIHCpgFCQrbAQkK+QEJCg4CCQphAgkKsQIJCtYCCQrfAgkK4gIKCiwCCgqiAgoKrAILClkACwrKAAsKEAELCnwBCwqfAQsK+QELChkCCwomAgsKMgILCoACCwqbAgsKsAILCk8DCwqfAwsKogMLCqwDDAqQAAwKRQEMCkkBDAqFAQwKkwEMCsMBDAoDAgwKXAIMCmgCDApyAg0KQgANCoMADQqnAA0K7AANCnABDQqbAQ0KsgENCsUBDQrNAQ0K2gEOCjsADgo8AA4KiwAOCpgADgoUAQ4KYQEOCpIBDwocAA8KUQAPCnsADwqYABIKiACUClgAhADKAYcAjAUGAG0ACgB+AQQLlQEECmECBwr0AgcLMQMJCiACCwqdAQ4LOgAOCjMBEAoZABELJQCSC3wABgBKAQcAPAQLAI4AhQvOAwQKogOFCrMDBQqrA44LigEQAFsAkQBXAAUL6wAFCsIDBwvXBAsLgwCMC3IBCwDsAQUKiwIICqoACQo9AAkKPwAKChcACgolAAoKQgMLCgQACwoZAQsK9wELCqUCDApgAAwKggAMCvQADgoFAA4KKAAOCqIADgrKAJIKhQAECpYBBQpDAgwK7AGWCg8ACQuJAIoL3QCGANcECwDTAIwAkQAHC4YBiguMAIcLigWHC3gEhgAZBAcAQQEGChEABwrpAwcKvgcJCnYDCgrpAQoKIAMLCg4DDApAAQ0K0wEOCpEADgqDAY8KdwCRChEABQuXAQsL6QETCyUAFAtJAJYLJgCFCsoBhwDBBwcKvwcICgAACAqrAAkKeAAJCtwCCgrZAQsKkAILCuYDEgoAABIKAgCTChUABQtFAQcLywUICwUACAvjAAkLaQAKC0kCjAtmAogAegCEAOoAhwusBAYA0AMGAEoEhgChBQcA/QCIACUCBgttAg0L+AGQCxMAhAoHAgUArgEFAKQDBgCDAAcAoQEJAAoCCwA6AY0AhgEOAJUADgCPAY8AOQAFCosDBgofAAYL2gAHCusBBwoSAggKUAILCjUACwoLAwwKpwAMCpsBDgoOAA4KiAAPCkgAEAoRAJAKSACMC0oBBwvGAQcLDgOICwADhAD7AQoLpAKMC84BBgB2AgkAKwMECtAABQpqAAYKEwIICpgBCQq8AIoKPAIEAFcBBQD/AYYKnQaGC6QAhADAAQcAxwGKAE8ChwBlBQwKuQGWCzIACQrBAQoKwACKCuQCBgA/AoQK8QCGAJcEhgCNAoYA4QaGAK4EhAoDAQYLVwEHC8MACQviAAoLxQAKCz8CCwv2AYsLgwMHAGcEBwAkBgoAKQEKAKYBCwD8AgsAKgMMAAgBDQBmAA0ALAENAOQBDgCTAA4A5QARAEcAEgB2AJMAeACHC5oChACmAgQKrQAFCjgBBQoAAocKBQUHCkMGBwqbBgkK0AELCsMADAoXAQwKwAEOCgsAkwpmABAAYwCSAKQABwtlBAkLjwALCz0ADguVAZYLFQCJCwQBBArEAQUKRwIFCjEDBgqxAQcKUQIHCtACBwpiBQgKoQAJChwBCgo5AYsKdgOECiMCiArSAg4AIwCOAL8AjQAtAIoAeQCEAH0AhgBWBoULvwMICqQBiwrBAIQA0QKHCpkBiACRAAcAGAMIAJMACgA1AwsAygMLAP0DiAutAIYLCgGEAMsCBwDPB4oKNAGFABMCBQCoAAUAogMIAEoACQBvAgwA9AGMAEMCkABBAIoL9gAGANwABwBNBA0AaQCOCzoBBQrqA4gK6QKGAMADFAAAAJQLAAAEAO0DBArvAAYK3QEHCkcGCwpEAIsKaQIGABMABwCFBYsArAGVCg0ABwBgAAgAkQEIAL8CCQCAA4gLLAGGADsGkQB0AIgA/QMHAKkHBwCtBwcA7gcIAJYACAC+AggA4QIIAO4CjABuAQsLSwCOCwsBhApvAQgAIAMJAJQACQBoAwkAegMLADUBCwDpAw0ACwENAEMBBQurAQUL3gIHC94BiAs0AAcL7wALC9kAjgulAIQLQwGMC6MBDQArAY4ASwAGC1cABgvGBgcLFAAHCyAECAvcAgkLlgEJC48Digu2AoYAZwWECrYChQtlAokACwMEAFYCjAqvAgYAygOHAKgBhQAjAgcLIAAHC9gDCAtVAAgLxQIJC0MCCQtPAwkLWAMKCx8DCwsCAQsL7wMMC0sBDAtnAg0LvAANC7MBDgsIAA8LpQAQCxsAlAsoAAYAxgSGAGkFhABsA4oLlwCHCtUABAunAIcLUgCFAIUABgsYAAcLSgAHC6YCiQsCAQULPgAGCxYCBwusAgcLEwQHCzAECAsYAQgLHQIIC64CCgsHAgsL/ACMCxoBiAC7AAgACAAKAAAACgAyA4sA3AOEC2cBCwCtAQ8AMwCHCogGiACtAgUL0wAHC1gAiAtzAoYA2AGIAIQABguRAI0LUAEECu8CCwqGAYwKIAAGAKoDBgAkBAQLBwEECpkBhQpOAIkAagMIAAYDCgCeAgwAMwAEC5QDBgrZAQcKQgYKCroCDArUAA0KMwGRCmkAkgBcAI8KnACEAD4DiQC9AgQLVwIGC2IGBwsFAAcLNwAHC0MABwthAAcLswIHC9MDBwuhBggLzwAIC9YACAvnAAgLJgEIC1ABCAusAQgLwwEIC8wBCAvXAQgLbgIIC3ICCAunAggL9wIICz0DCQsLAAkL9gAJC+QBCQs9AgkLwgIJC/oCCQseAwkLVwMJC2YDCQuQAwoLLwEKC08BCguoAQoLzQEKCx8CCgv3AgoLLgMLCzsACwvHAAsL6wALC9sBCwtOAgsLoQMLC8MDDAtyAAwLtgAMC+IADAtMAQwLtwEMCz8CDAtWAg0LCAANC30ADQvCAA0LHwEOC8UADgt/AQ8LNQARCz8AEwsuABMLYgATC2oAlAtVAAQAfwAFAF4BBgBkAQgAqgEJADwCCgD3AIsAOAGGAL8EBgA7AAkAWwINAI0BBws9B4oLtQGGAOIGkwt+AIcKcwMNACUBjgA4AIUKaQKLCjIABQu7AAcK7gWLCrYChwC5AQYAbwAHAAQACACjAAgACAOKADYChAAmAwQL1wAJCyYACgsDAAsLFwALC38AiwscAw4A6QAECiIChwr6B4cAygeGAMsGhwv6BYgAiQEFACkBBwAOBA4AZwETADQAlAAvAIcANQEECjkBhQpBAggKuACNCrEBhwqnAwwKugAMCiQBDgpkAJIKRgCIAGsBDgCvAAsKkgEMCm0ADAqvAQ0KswANCs4ADgrZABAKAwCUCjUABQp2AwYKLgAGCv4GBwoOAAcK3AIHCnYGCApfAAgKRwEICmgCCQp8AwoKVgIKCgEDCwqGAAsK6wIMCnoBjgphAIgAmgKHAIsGBgCPAoYAQAaHACgDhQr9AwQLHAAFC7gBBwv4AAsLQQOMC1gBhgt2BoQAGAGMADYABAClAYUAJAKECpkABgtTAYcLmwOFC1UDhQoeA4QKSwIGC/kABwvSBIsLPQIGClYCBwoqAAgKtwIKCtQACwqeAA4KxACRClUABwD5AAUKvQOFCvADBAqBAIcK0QEGAP4ABwBKAwcAewYJAG0ACgBnAAcKjAMHCrEECQrzAgsKigMMCg8CkgoHAAUABgGICsIBkAABAAoLyQCOCz8BBwsxAAcLiAEICxQACAusAAgLsgIJC38BCQtNAwoLMAALCyUBCwtAAwsLmAONC90ABQtaA4UL4AOGACUDiwrrAwYAXgaGCzMBBwvoBYcLAgcGCwwBiQs+AIcKTAeFAJ8CBADdAwgAzAOIAOYDhAunAYQAeQOHAGYFhwB2BwcKxQMHCrQFhwpEBgQAcwIFAAcDigtqAIYLXAEHAMoACwBqAQsAtAOMAIQBigsDAwYLZQKIC98ABgAwAgcAwwEIAIUBDADqAQ0AEAANANcADQBfARIAhACTAH0AhwBJA4gANgKIAKoDhAueAgUAkAMGAJ8GjAs3AAkLKACLC4gABwBRBQcK1gMKCiAAjwo4AAsLAwGMCw4BBQDsAAYAPAIIAOwBCwBqApAAOAAICzwCCQs2AQkLqgKJC7oChgA+BwUAvgCIAD4BhQqzAYcAYAUECygBBgtgAQcLkQEHC4IFBws6BgcLigYICz8ACAuUAokLSgAHAF0BBQpVAAYKowEHCjEBBwppAQcKOQUICkcAjAoHAgQLiwAEC4QBjAu8AAYAtAcGAN0HCAC3AwoAswMKAM4DCgD6A44A3AGMCrAChwrkAgUKswIHClkBCQpeAIwKqQAJAFgBBQq3AAYKRgIKCqcCjAqzAYcK/wGEAFIDCAu5AQoLOgGPCwMABwrJB4gKrAIEC+sCBgsiAQYKRwIHC4kCBwvHBYcLLwaFC+gAhQrAAoYAjgMECrMABQrGAIUKuQIHClsBBwrLAwgKtQCKCscCiAsNAg4AEwAOABwAkAAdAAcAVQAHAPcACABJAooAowAEAOcBBwvYAQcLCQcKC+wCjQvKAQQK8wAFCssABwoTAAcKRwAHCnEACgqVAQsKZQGOCvAABwqqBYsKYwCEC6kBigCRAJMAUwAGCuwBiQv3AAQA9QOGAPEHBQqGAAYKmAEGCu8Bhwo5BocAggeGC+gGBAB8AAoAyQELAHkACwCpAAsAZgMLAGoDDADWAA4AuwCPAE0ABQAtAocAsQWLAEIABQuvAwYL8waOCgQABAr4AAQKmQIHCokAiQpdAQcAqQQFC/UABgtAAgcLRgKIC+EAkABSAAcK9gSLCmQCBQDGAQoAYAGKC2ABEgA5AAUKcwGHCjMChwA1BQYAawAHAH4CBwBgBgkAjAGGC2ICBQByAYYA3AYECnYBBwojAgcKpAYHCikHiwpaA4UAzAAGABkFCQo3AY0KKgAFAMoDhgCqBgYKbwYHChAGBwraBwkK7gGJCv0BDQvHAQ8LYwAPC4EAkAtEAIcAAwAEACMABQB5AAUA4wEFAK0CBgDpAQYADgMGAAgEBwC0BIgAigEEAJkDhQDvAwgLaAGKCz8AhwCgBoYA7wWEC7sBhwuwAwYKewAHCtYACQrYAgoKnQALCloBCwqWAo8KagCJANUDhwqbBYYAMASEAMgChgBdBoYA2AIECyoBiQvjAQYAmQQGAPcEBQukAAcLeQCOC70ABwBIBgQKwwIFCkwCBgqJAQ0KagASCjEAkwopABcAEACXCxAABgrTAAcKmgYLCuYBjApxAYUA5QETCw8AlQsbAAQLrAAJC2MCCgu0AQwLoQKNC/8ABQtMAwoL5AELC/ICDAvJAQ4LqwAOC4UBkguZAAQAHQEFABsABQA9AQYALQEHAAcACACZAAoA/gILANQBDADTAY0AjwCGALYFCQsHAQoLkwCKC+wBhQsZAgYAmQcGAMIHBgDHB4YA9geGCtsAiQtKAw4ANAARADIABQpGAgYKbgYHCmMABwqqBwcKwgcICgMCCAoFAwkKFwAJCusBDApsAo4KXQCKC2EAFAAVABQALACFClMDiAAzA4sAlQMFC+YABQuIAQYLpAEICvoCCAosAwkLOAIJCo4DjAtkAocAEAMPAIcAjwuHAAoAxgGMAEQBBAsAAAULKQAHC7MFBwu9BQcLUgYHC0MHCQslAosLiQMECmIABwpVBQkKpgEJCp4CCgoHAwsK0gANChoADQrJAY0K3AEGALcGBgDHBgcA4AcHAOQHCABFA4kAVAOFC7gChwBUA4QAuAOGCsIGhAsDA4oAOAKJAMABiwCSAAgAQwCKAKMBhQuZA4kKkwCGACIHCgCRAg4AKQGOAGkBBgCaAgYA/wKGAAYGiwDZAgYLtAAHC3EECAvvAosLJQMEC7cABwsPAQsLOAMLC7gDDQsWAQ0LUwENC+IBDguoAZQLYwAEAJ0CBQvdAQULVAIGC/kBBwvFBAsLiwMMC9EAjQvWAIcLvwQFAJIBBgoeAAsKOACLCjEBBws0Ao4LqACLAJgABwCQA4cKTgYECpYABQovAYYKRwEHAEABCAAzAAkAZAMKAEEDDADhAQwAOgKUAGoAhAC9AQcLEgELCwcBCwvfAQsL+wGMCxUBCgArAgsANAETAF8ABgttBggKwAAKCk4AjQpnAYcKEgMGC1wABgu8AAcL9QQHC/QFBwtUBwoL5ACLC/wDBAvLAYULxgMLAIIBBgpmBgcKTwAHCvABCQqKAAoKUAEMCpwBDAq4AY4KMQGFAO8ABwBTAAcAxgcIAIIAiwDQAooLxQIEAI8ABQAmAoUA8AIFAHsABgASAgcAXAGHAIsFhwDoBwYLEgAHC7MABwvRAgcLpAMICyQCCAv1AgkLNgAJC0EACQsUAgkLTAMKC3EACgt1AAoL7AAKCzsBCguuAQoLHgMLC5kACwtfAQsLdwEMC04ADAuXAAwLiAEOC/gAjwsXAAcKzAAHCp8BCAoqAAoKVQCLCjQChgC+A4ULxQOEANIAhwuVBYoL4AGGC7YAiwtZAQoLQQAKC+gBigvxAQQKAwAFCvcABQqEAgcK6AIHCrcEBwrJBAcKdQeSCpMAhACuAQUKHQEJCkMADQrZAY8KUgCQCxAABwuKBAkLTAIKCwQBlwoIAIUA1QCKAAcAhwAhA4YL+gaHCzQBBgCoA4YACQWFAGwAhAB1A4UA2wCLAEsCBADBAAUAlAMGABEEBwBsAQoAjgEKANYCCwA9AQsAcgIMAI4ADAAgAQwApgINADkBDwBxAJIAcgCHAI0EBgDxAAkAVgEKANkCCwAcAQsAvQELAIsCCwBfAw0AjgGSAGMABwCLA4gAQAMJAC8BBAodAAYKFAIHClwGBwpwBgkKXgEKCrEBCwphAAsKLQILCukCDAohAQwKTwEMClwBDApeAg0KdAANCukADQrSAQ4KtQAOCtEADgroAA4K7AAOCiwBEAopAJQKYQAHC6cBBwqcBogLTAIGAKMDhgCuBQUK9QEHCqgGCQopAgsKCAIMCi0CjQr5AIgLHwEEADICCQD+AIsAbwOEABIDDgsgABILVQAUCwIAmAsQAIcADgUHC9MChwtvBAYA2AAHAIUDBwA/BQgA7QGGC5MBBwvPAggLKQOIC0IDBQvSAAYL1QAHCzwACgtsAYsLhwAHAFUBCwDbAAULXwIIC0YBiAvqAQQLvQIFC9gBBQt/AgcL4QQJC/YCiwuAA4cLfAGHC5sHiwCCAIcAxgYKAHMACwCkAQwAmgANAJQBDgBaAY8ANgCGCoEABAuCAQcLKQAIC5UBCQvxAQsLbgALC2gBDwslAJALVACNCxoBBQsuAAcLrAUHC8gFCAt6AowL2AEECwwCiAsqAwoL7gCNCyEAhQBcAgUA8wOIAL0CCABYAwgAWgMIAG8DDAC+Ao4AvwEEADYABQCaAgcADwQHAGoECQDDAIoALgEEChkABQo8AAYK+AEHCmYCBwqDBIwKAAAHCuAECwptAosKvgKFC+UDiQpBAYYAhQaGAP8GBAp7AYcKdQWKC3QBBQsOAwULPQOGC8oGhwDMBAQKdgAGChIBBgppAQcKSwCNCrkBhABvAgkLFwEKC5cBDgtUAJYLEgCJCkkDhwAeA4wKtQIFCjoBBgrdAAcKowEKCooCCwqMAQwKnAANCnEBDgpNAZEKLwCHC1wFBwB6AAkAAwEKAFQACwDWAQwAHQKNAHsBhgBFAwgA9QMEC04ABQtgAAULtgAHC7wGBwshBwoLigEKC9cBCwsUAg4LVAGRC1gAhgBBAocLrAeECpEDhgDMAQgAewMKAIUDCgCXAwoApAMMAMsCDADYAgwACQMOAMkBkABnAAUAUgAFAIMABwDbBggAHwAJAKgACQD8AosAZQOICtsBBgBdAgUK+AMJC1kCCQtrAgoL+QEKC9wCCwtjAYwLiwAHCloCCAqzAAoKDQOMCn4AhgDeBAYKSQGKCm8ABgvXAAcLBAQHC8EFBwu5BgkLqAGKCwsDBQAWAYkARAAGAKQDBgA8BJAAVgAEAKMABQDJAAUAMwEFADYBBgBPAQcAHAEHAHwGiAClAIgADQOGAMMCBgAhAIcA3AQFCjUDBgtDAAYKlwYHCwIBBwteBgkLYgEJC6MCCgs+Aw4LUACRC1AABguNAAcL4QAJCzsACQtfAgoLOAELC68CDAsrAg0LdQENC+4BlAs6AIYAWQQJAIQBBQpHAAcKfwUJCsACCgoFAQoKawILCiMCCwprAo8KnQAHAKEHiADQAooAywAHCtgHCQpRAYoKBQIGAEYBBwClAokAqQGLC1EABwAkBQcAhAUHAC8HCQBNAgsA8QALAKQCCwArAwsAewMMAIwADABaAQwA3wENAIwADQB9AQ4AvAASAB4AlABsAAUAoAEGClYABgpbAgcKJAEHCjECCAoBAQgKfgEJCtECCQoKAwsKRQKMCtIBBArmAYUK6wGGABQFhApIAAcATwMGCgkBBwuuAYsLLgAFC1oCBgtqAAcL+gYHCx0HBwviBwkLogGJC/sCBQBmAQcAFwIHAKAECgCWAg0A1AANADABDQBNAZEAYgAFC0EABgugAQcLuAYHC4QHCAulAgoLbQALCw4ACwtGAAsLOQILC98CDwuZAJQLUAAGAB8HCABHAwgAVAMIAIcDCgCsAwwAwwKMAAcDhwvNBAYA8gWMAI4CiAtTAosAowCNADoBhADSAwQAWQIGAPMHiQrqAAUKLwMGCpgGhgrbBoUAsgOIALIBBgrFAIgKzQAHAJsBBwBOAggAdwIJAEMBCgBjAQsA6wEMAI8ADACSAQ0ASQAOAJgBDwBrAJIARwAHALsFCABIAQoAIAILALsDDAANAA0AQAGRAFMAjgCaAQsA/wENAIoBDgAqAQ4APgGSAGcABgrEAQcKOAGKCtsAigpNAgQKTQEJCrAADAphAY0KuwCHC0kBhAvVAQUAQwOGAOMBhgvPBgULoQMGC1QBCAt4AYgLJwOGCpUGhAClAgUL2gAHC0oGigtTAAULOwKHCzIHhAvHAYkARgCHAH0FBwqHAAgKBwAICj4ACQrzAAoKkgIKCrkCCwrIAYsK9AIJCosBigpPAIkAbAAGC6EABwt0AYkLVQKEC10BhAAJA4QASwGHCncChQDrAgYLsAEGC2ACiwtCAYoKQwMFC9QBBwsRBwoLRQELC1gDDAtZAY8LaACFC98ABwqWAQcKywEICl4CiwrWAoQLNgKOAEQABAs7AIcLcgUGC7QBiwvhAQQLMAAFCw8Bhwu5A4sLqgAFC2ICiAvJAYUL8wKHC8EEhQpkAoQLxQCEAPkBBAp0AQcK4gEICp4ACQpaAgkKZwIKCvUACgqmAgoK6AILCvgAiwomA4UARgEFClYDhwrHBwQAswKSABAABgB0AgkAIwAKAKgCCgAZAwsAbAENAGUBjwCkAIoAjgIGACAABwCBAQcA9QIHAHwHCAAlAAgAXgAIAMcCCQAdAgoAogAKABsDCwDdAwsA8gMMAA4AjgA0AYUL2QAGAJgABgBdAQYAkgYHAOQECABwAAkAswEJAJwCCgAiAQoAPwEKAC8DCwC0AAsARQMMAPAADQCYAA0A2wCOAJ4ABABFAoYA1gIFCsMAhwqVBgYAfgAHAD0CCACNAY4ALACKAFkABwrNBwgK2gKLCu4DhgD7BYYAjwQFAJ4DDADLAIUK7wIEC6UABwt2BYcLJQcHANAEiQATAocKNQOGAK8DhQCeAgQAcAOLAOcAhgBRBocApQcFCwkABwspAQcLxgOMCzIBBgDPA4YA2QMFCrYDBQriA4YKXwEMCxUAlwsHAAULkgAGC5sBigvRAgcA8gCHAJYHBguxAIcL0wEFAKUBBwovAIkKrAIFAEIDBwCyBAgADgAJAOEBiQBwA4oA0QEGALACCQBCA4QKXgGEAFcDBABlAQYArAAHAI8AiQCdAYULyACEAE4CBwoUBw0KAwENCmQBDgryAJMKcgCFCscDCwByAAQK2QEHCm8CCAooAwkKZwMJCn0DCwqvAQwKcAAMCtkADArzAAwKMgIMCpcCDAqrAg0KjQANCsUADQrjAA0KlgENCucBDgqcAA4KywAOCuAADgoAARIKOgCWCgAAigoeAQQK3gAHCh4BiAp1AgUAqQAHAE0BiAAtAIYL4QGEAMYABAAYAAUAjAAFALkABwDcBQsANQILAEYDBAtUAAcLygUKC0wAiguOAIUASQKNCjIBhQv3AwQLOwEFC/sBhwtaBYgKkgAGALMChgDfBQQATgGFAFECBArRAYcKfwaOC60AhwCRAwwAdACGC7oGhgBQBYQAIgMIC94ACAvcAQkL7gALCwQCCws/Ag8LbQCSC2QABgA0AQkAoQIHCooABwoFAosK7gCEAMUCBgBUBwYAZwcJAOIDCQDuAwwAPQMMAHgDDAB7A5IAuQCUCl4ABADkAIUAgQMHADAHBQrvAQcKQgMJCt0Ciwp6AYUKLwIGChUABgrJBgcKpAWICuAABABgAoUA8QEGCygAhwv1BoYAJQaHAPcHBgAcAogAiAAEAIEDBQASA4UKBwIGAFYHBgBcBwkAqgMJALQDCQC7AwkAzQMJAPQDDAB/AwwAnwOPAP4AhgC9BYUA5wMEACsBhwDsAwQA6QKFAEICiAs+AoUAyAGGALEFBwCPBoQKkgEHALUCCAC0AAwAowAICkMBiArfAQsKRAKOCskABQo7AIcKoAKEC2IBkgoiAAQA8wKHCxYGBwDMBpIAMAAEClUAhwolAosAUgGFCl4AhgBDBIcL1QEMALcCDADAAhQAcQAFCz4DDgtSAZQLUQCHALgFBgoLAIcKuwCHAM8DDQBPAYQKCgKGALsHBQvwAYcLywAECjQAhwqVAgcAHgYIAA0BCQDUAAkAzgIOAA8ADgCEAI4A4wAEAHoDBQAlAwUAMwMFAMEDBgCMAQYAXwYGAI4GBwCvBwcA+QcJAHYCCwAIAAsA+wMMALAADQDhAA4AJAEVABgABAp/AYUKCAKGCyMChwvUBgULWACJC+8AkguAAAcLigKHCx4FBAoZAQUKJgAHCsIABwqcAgcKZQeJCo0BhwAXBwkKewKLCi8CBwDhBQoAvgAKAHoCCwAYAwwAZgGMAL8BBQAAAAYAGAIHAFwCDQC9AZEAfgAHCzQECQtQAAsLTgALC6UBCwsWAowLIQIIAMYDCgD/Aw4LcQGSC0gAhwtpBgYA6AAGAJwBBwAyBAgACQAIAJ0ACAASAwkAxAAJAGABCQDJAQoAUQELAOgACwBtAwwA4AGMACIChwC+AwQAfgGIAEMCBADUAIcAtgQEC/EBBQuRAocLMAaEAKkCCADLA4oAxQMFCsABiAoXAg4AEACSACwACwBIAgsAaAIOABMBCwtIAgsLaAKOCxMBiAsNAAcKYgKHCt0FBwuCAggL+gALC3sACwuJAA0LMACOC18AhQCPAhEAQwCTAEoAhgDvAoYArwcGAOcAiACnAQUALAGKAPgDBAo/AQUKuwKKCqECBgDtAAcAYwIIAGQACQCgAQsATwEMAK0AEgBlAAYKUAEICigCCQodAQoKYwCLCjgChgBaBQcKfgUJCtoAjQreAIUKAAGHALgEDgvVAJQLJgAGAMMEhwtqBg0AoQEOAIEAjwAPAAoLIQKMCy0BEQonAJQKJACFAMcABAuIA4ULGgMMAKsBkgAmAIYAtQMIAJkChwp6AoQKagKHCgMBhApTAYUL+QKNCqkAhAr3AgUAsAIHABsChwDIAgcLggGKC8kChgCiBAYLBwAGCyMABwuTAAcLLQQHCyAGBwsnBgcLfQcICysACAvQAAkLgAAJC2IDCgsUAAsL1QOTCyEABwt9AwgK4gGNC6gBBgA4AQYAswYKAEgCCwAiAgsAtAIMAAMBDAAnAQ0ALgCNAJoABQpQAQYKVQEGCt4BBgrjBogKggGJAJcAhABMApgABAAGC0IBCQsoAgsLEgENC9EADQvzAQ4LVQAPC34AkQtGAIcKSQAEAOcABQA9AAYAaAAHANkCBwDEAwcAegaMAJ4BBgAHAYoA9QKHCrMHBABkAoUAMQKEAEABhwpABQgLUwAICzEDCQscAAkLHQAJC3UDCguDAQsLeQILC+QCDQvrAA0L/gAPC48AjwuSAAUKjAGGCvUBjAsxAIQA4QAECqEDBQofAwgKLgCICuQCBACVAQcAMQMOADoAEQAlAJIAfACFAM4DBAucAYULRQIECnwDhQoCAwQA5AOGAOoHBAAPAgUA6wAHANcECwCDAIwAcgEJABAADQCCAYcLpQEHALwDBwCFBAcA4gUHAEYGBwBPBgcAUwYHAMgGBwDvBggATgIJAEQBCQDgAgkABgMJAAgDCQAQAwoANwIKAMQCCwAGAgsAZQILALcCCwDMAgsA4wILAAIDCwADAwsAUAMLAFkDCwCjAwsAswMMAEYBDACDAQwA5AEMABACDAAoAgwAZQINAL0ADQAAAQ0AVAENALABDQC0AQ0AuAENAMYBDgCuAA4A3AAOABwBDgCGAZEAeQCHCp4ACQCJAIoA3QAEC24ACgufAQoLVQKOC84AjQvwAYcLzQCXChkAhwsKAwcLeAYHCtEHCQtxAQoLUgEKC+oBCwuaAAsLIQILCwcDDQtNAI0LEgEEC7wBCguSAIwLCQAHAIYBigCMAIcAeASGANABBwq1BYwKWwCECloCBAsbAYcLqgQFAJcBCwDMAAsA8wALAOkBDAAlARMAJQAUAEkAlgAmAAcAwgSIAC8BBQBFAQgABQAIAOMACQBpAAoASQIMAGYCBAoNAAUKNwIHCtoFCQp8AAsKCQKMCpUBhwruAwcAIAMKAAwAhgu4BocA9waECt8CigosAwQKqgCHCkMBBgBtAg0A+AGQAFkABQowAYcKewWJC9gABgCYAwYAUAQJC7cAiwseAQQAeAGFCuYChgDaAAgAgQILAIQBjABEAgcAxgEHAA4DCAAAA4wArgKJCyEAhQpvAJAAAAAKAKQCjADOAQYApACIC98ChQq8AZYAMgAHC0YHDAvrAQwLCAINC38BDgv0AJILDAAFC4QACQvmAQkLywIKC8oBCwt1AQsLnAILCxsDCwuBAwwLEAEMC6gBDAsbAgwLLgIOC/UADgsHAQ4LCAEOC4kBjguTAQgKewAPCgYAkAoHAAYAHQEIAI4CCwDtAgwAvgAMAEcBDQB4AA0AeQANAEcBDwAvAJIAKAAFCwgABgtZAAYLkAEHCyEGBwtXBgcLOgcIC9oACAumAQkLOgKKC3ICBguDAQcLcgONC28ABgBXAQcAwwAJAOIACgDFAAoAPwILAPYBCwCDAwYL4AAHC20DiQuHAgUKqQOHCmQAhwsWA5YAHQCTAAgAhgAUB5UACACHC4oBBwBlBAkAjwALAD0ADgCVAZYAFQAKC/MCkwsdAAkLegGNC6IAhwqaAwUKawKFCroChgAvBQYAPgaJAD8CCQs5AgwLDAAMC1EADAs/AQ0LRQAOCwMBEAtXABELAQARCxUAEQsYABILDwASCzgAEgs7ABILfwASC5oAEwsTAJQLHwAGAH8DhwvPBAUAvwMHC3wAiAsmAAULBQEHC04ABwvHAAgLLwMJC34AigtWAQUKlQOGCnsGBwDfBgULUwKHC0cHiACtAIYACgGOAAUBhAt0AgUK+wAFCrwDCAoMAQkK1gCSCo4ABwsKAYgLJAOHC9AABgtPAAcL/QOHC+8FCwvAAo0LjAEFCloBBQrHAogKhgGIC+UChgt4AYYAkwUGAAkEBgDBBIgALAGFCnACBgtkAAcL9AAHC3gCBwtJBggLsgAIC34CjQs6AAYASAIFCg8DBwrOB4cK/wcFAKsBBQDeAgcA3gGIADQABwDvAAsA2QCOAKUAhgBpBAYAqAAGAMYGBwAUAAcAIAQIANwCCQCWAQkAjwOKALYChApSAoULFwMHC64CCAshAAgL7gAKC2gCCwvTAQsLcQMNC9kADQv9AI4LDAGJC9wBhgCiAYUAZQKEAHgChAu/AQcAIAAHANgDCABVAAgAxQIJAEMCCQBPAwkAWAMKAB8DCwACAQsA7wMMAEsBDABnAg0AvAANALMBDgAIAA8ApQAQABsAFAAoAJALIwAEC4AABQufAQYLzgEHCyYBBwtCAgoLxgKLC1YABQC2AogAjQMHAFUECwAHAAUKJQAGCicABgrDAQcK2gAHCo4EBwqXBggKlgKQCgIAiAtLAgYLqwEHC/oDigu0AgQLwwAGCvwBhwsiAwQApwCHAFIABQA+AAYAGAAGABYCBwBKAAcApgIHAKwCBwATBAcAMAQIABgBCAAdAggArgIJAAIBCgAHAgsA/ACMABoBigAhAAQAZwGFC+ICBwDUAwkASAENALoADQBsAQcKewIHChwDCApLAQkKSgEJCmEDCgp3AAoK6wALCm8ACwqBAAsK8AAMCh8ADApCAAwK3gAMCg0BDApXAgwKrAIMCrECDAqzAo4KWQGJCg8CBgBUAgcASQKHCr4ChguTBoUA0wAGAJEAjQBQAYYAagQHAGkDBgolAAcKggYICsMACAo8AQkKsgAJChQBCQpTAQkKGAIKCmYACgpqAQoKEQMLCjcACwqVAAsKBQMNCqABDQqjAQ4KJgAOCikAjgrSAAgASAOIAEkDhAAHAQULAwAIC0ICCQt2AAoLwQIMC38BjQsXAYQAlAOFC+UAhQqFAg8AmwAQAE8ACAtmAAoLQgIKC6ACDAvwAQ0LmAEOC3kAkQtqAAQAVwIFAFACBgBiBgcABQAHADcABwBDAAcAYQAHALMCBwDTAwcAQAYHAKEGCADPAAgA1gAIAOcACAAmAQgAUAEIAKwBCADXAQgAbgIIAHICCACnAggA9wIIAD0DCQALAAkA9gAJAOQBCQA9AgkAwgIJAPoCCQAeAwkAVwMJAGYDCQCQAwoALwEKAE8BCgCoAQoAzQEKAB8CCgD3AgoALgMLADsACwDHAAsA6wALAE4CCwB3AgsAoQMLAMMDCwDbAwwAcgAMALYADADiAAwATAEMALcBDAA/AgwAVgIMAKMCDQAIAA0AfQANAMIADQAfAQ4AxQAOAH8BDwA1ABEAPwATAC4AEwBiABMAagCUAFUABwBMBYQKIgEGCkYABwoMBQoK+gKLCiABlgs3AAQAUQIIC3MACAteAQkL6QEKC4AACwsyAQwLdQEOCx4AEQtPAJMLUACHC9MEhgBwBQQL5gCFC74CkwB+AAcKgwAHCqYBCArSAIwKPQKGAJsEiwuzAYsKHQOGC8AGBACiABILGgATCyoAFAsrABULAAAXCxsAmAsOAIQKqAMGAP0CBQrFAYYKuQGFALsAhwAGBQYAewIGAIgDBgC6BIYA0QUEANcACAB6AwkAJgAKAJsDCwAXAAsAfwCLABwDBgCNBIYAGgUHAMwCDQBhAI0A+wCECo0CiACRApIKUAAFC24CBwsIBAsLGgALC9UACwvDAgwLfAENC+IAjQtjAQYAKwEFC0YABgtOAQkLqwALC30CDAvKAA4L3gCRCyoAjgCGAAQLFwAFCzkBBQv2AwYLMgAGCzMABwuOAAcLgAEJCw8DiwvlAgQLjQAHCy8CCAuAAgkLzAEMC7cAjQvoAYgLZgIHClgFCAroAAgKaQEKCqoCigrmAokKFgIGADoEjACSAokKGwCHANIHjgoMAAQAHAAFALgBBwD4AAsAQQOMAFgBBwrgAosKCAGGCnkGhgB2BooAEwIFC94ACQuMAIoLFgIGAHoCBgAeA4YASAOKC/cBhwp/AIUAVQMFC5oABwvTBQoLewGKC+UBBgD5AAcA0gSLAD0ChQvMAgcLIgaMCx4CiApsAYoADwIEC1sABQuEAQULTQMGC84ABgv8AAYLbQEHC4gABwsTAggLCAGIC20ChgCLBYcLoQUHADEABwCIAQgAFAAIAKwACACyAgkAfwEJAE0DCgAwAAsAJQELAEADCwCYAwsA2AONAN0ABQBaA4UA4AMFANgCiQoYAwUKjQMJClEDigolAwcADQIHACsGCADxAYgAPQIGAAwBiQA+AIcLQAKGALEEBQsDAwULXwMFC4IDBgtgBgYLbAaGC/QGhQtLAQcAwQAHAFEECgDvAQcKjQEICnwACAprAgkKMQELCigADApdAQ0KhgANCicBDgqbAA8KeACSCmkAigBqAAYAWwMFC2sABwvJAIgLBgIGC74BhwsZBw0AFwAECgYBhwpWAYUKgQKJC1MDBgCdA4kALQOEC/gBBgBlAogA3wAECmMABgr6AAYKWgEICn8AigpRAIgAuQOECpMDiwt8AwUKSwAJCgUCCgrWAQwKmwCNCuAABACaAgcA+QMHC+QDiguGAQULcwOFC88DDgpTAI4LUwAEAJ4CBQuaA4YLqwaHANgACQAoAAsAiACHCxMDBQq6AwUL4QMHCwMCiQtbAIsAAwEHAFoECQA2AQkAqgIKALgBDQAoAAYKMAEICqIBCwpVAYsKowIOACgBCQqaAYsKqQEKC3kBDAtrAQ0LRAANC14ADgtsAI4LMgEHAHkFhwDEBQQAKAEGANsBBwCRAQcAggUHADoGBwCKBggAPwAIAJQCiQBKAAQAiwAEAIQBjAC8AIQAHQOEC/4CBQtnAAcLmQMIC0QCCAtRAggLdgKKCxwABAuPAwULYwOFC/UDhgoOAIYAJAaGCqwGFQAnAAUKcQAGCvMABwpJBwsKoQAQCiUAkQpjAAcLGwaNC7YABQuHAAYLBwIHC7oGCgsPAQsLBQGRCzYAhAoSAYYAOgYECywBBQu0AYcL5AEEAOsCBgAiAQcAiQIHAMcFhwAvBoULFwKTC1IAhQDoAIkAdwOHCqYAiAAJAgQADgAHANgBBwAJBwoA7AKNAMoBhgDlAoYA4AMQAG8AiQowAQQAqQEFC4MBBwstAgwLIwKOC1YAhwvTBgUKjgKHC9EFBwAVAwQLBgAFC8QCiAtLAAYKEQEKCrwADQp5AZIKTQAGADkGBAsvAQcLawIKCyMCCguvAgsLegCMC1kChgDoBocKmgGKCwQDCwDpAIsKDAIFAK8DhgDzBoYK+QaICxEChAC7AwUA9QAGAEACBwBGAogA4QCECgwDjgDxAIYAlwcEC2oABws2AQcL+QYKC7ICiwvNAoYABAUFC3oDhQvcAwYLcgKOC68BCgvCApELIACJC0wBhAu6AocAxQIFCrQDigsRAIgAKgKGABwGiwqtA4QAuwGGAI0DhgtUAI4AGAEEChQCBQrCAocKlgKEANkCBQpFAwYKcwaLCtkDhwpFBwQAXAGYCwMABQvaAwYLggAHCy4GCAvKAQoLZQAKCz4Bigs3A4YA9gIEACoBiQBQAwQKSgEHCqUDBwrcB4gKJAEHC2wGiQuBAAYAjgUJAD0Dhwr/AgUApAAHAHkAjgC9AAcALAMHAO0EBwBQBQkAeAKMAGABhwv8BosALAKHC+UDkQpyAAQArAAJAGMCCgC0AQwAoQINAP8AiQpzAwsAEgKKChIBhQBMA4YA2AMNAOgAEgAjAAQKvwKHCs8AhAo7AgkABwEKAJMAigDsAQcL3AaJC2IABQppAwUKwAMICjcDiQpxA4UAGQKEAFsDBwsWBIsLoACJAEoDiwobAQUKIQAGCtYBiwqoAQYLLQAHC7EBCAuBAAkLFQAKC4gBCwtPAAwL8wENC8cAjQvDAYcACwWHCloHBwsuAogLYQGGAMoFBQDmAAUAiAEGAKQBCQA4AowAZAIGAAYBBwpaAAcKmAIHCj4DBwpkBQcK6QcIC1EACArAAQgKPAMJC70ACQvJAAsL3gELC8gCjQtSAY4AHwAFC2EBlwsaAIQA8QIEAAAABQApAAcAswUHAL0FBwBDBwkAJQKLAIkDCQqhAYkK7QGHC1kEhQC4Ao0LwAGGCicBhABCAwQAAwMFCvsDBgsZAAcLVwMHC+oEkAsgAIYANASFAJkDhQCiAgQLBAAHC14EBwsoBQcLqgYICxUBCQtuAgoLCQALC9QCDAteAQwLjQENCxwADQufAA8LWQASCwUAEwsJABQLIgCWCy8AhgrQAAYAvAGIADQBBgC0AAcAcQQIAO8CiwAlAwQAtwAHAA8BCwA4AwsAuAMNABYBDQBTAQ0A4gEOAKgBlABjAAcLPQGHCzkCBAATAAUA3QEFAFQCBgD5AQcAxQQLAIsDDADRAI0A1gCHAL8EBgAPAQcAjgEIAIMBCgBYAQcKwAEHCl0GBwoVBwgKugEJCsYCCgoaAYoK0gILCkwDDApoAIwKcQKGC/8AhQoTA4YAbQYLC7wDlwsDAAYAXAAGALwABwDRAAcA9QQHAPQFBwBUBwgAlQIKACoACgDkAAsAOgALAPwDDAA6AAwAdgCNACAABADLAYUAxgMECxgCBwt1BAoL0wKLC3MBjABKAYYAFQYHCx0BhwtsA4gK6wGHCzACBgASAAcAswAHAKQDCAAkAggA9QIJADYACQBBAAkAFAIJAEwDCgBxAAoAdQAKADsBCgAwAgoAbgIKAB4DCwCZAAsAXwELAHcBDABOAAwAlwAMAIgBDACaAg4A+ACPABcABgDOBoQLsgIECpMBBQq5AQcKwgEKCkgDCwplAAwKwQCNCq4BhQDFA4YAtgAKAEEACgDoAYoA8QGHC0IFBgDNAwYAhgQKC8gAEwsCAJcLFgAEC74AhQsqAoUKpwIHAEgBiQpGAYUL6QMJAEwCigAEAYULvgGHCmgEhwoEB5MLdwCGAPoGBgAwBQYAwQcIAMIDigD5A4cANAELAPwBBAo+AgcKXgEHCgAECApSAQkKpQKKCigDigvwAocKOQSJC2AABwqMBocK9QeIAEwChAswAYUAZgKMABkDiAAfAYkKKQGNCiUABgs1AAYLxwAHC4AFCAsgAAgLXQAJC7UBCguNAQoLdQILC1ECCwv7Ag0LRgGRCyMAhgtpAAkLQAEKC/oBigsaAwULcgAFC/8AjQsdAYwAIgEHC/MHCAsTAAkLWQCKCz8DhgBwBAcAzwIIABwDCAApAwgAQgMGCjIBBwp0BAcKPAUICoUAigrBAYsK8wMFANIABgDVAAcAPAAKAGwBiwCHAAUAXwIIAEYBiADqAYoLsACEAL0CBQDYAQcAfAGJAPYChwCbBwYANwSKABYBiguHAQUKSQEICgQBiwucAAQAggEHACkACACVAQgA2AIJAPEBCwBuAAsAaAEPACUAkABUAAUALgAHAKwFBwDIBQgAegKMANgBiADBAwQADAKIACoDCgDuAI0AIQCECpECmAoHAIUAFAIFAOUDhwqBBgcLUgIHC1MDBwtCBwkLmwEJCz4CCQuaAgkL4QIKC1oBCgvIAgsL9gALC7ABCwsFAgsLhwILC6cCCwvXAgwLMAEMCzEBDAtDAQwL4wEMCzwCDAtRAgwLWgINC18ADQtlAA0LqwANCzsBDQt6AQ0LqQENC9sBDgs/AA4LfAEOC4ABDwuFABILcACUC0gABQu7A4gLLgOGABUFBQpCAAcKaAeICiABhQs4AIYKawYGABIFlAtkAAUADgMFAD0DBgCfAgYAhAQGAMoGiQttAgQAMgEFADoCBwBDBQUKWwAFCogCBQruAgUKDQMGCjYABgpwAAYKkgEGCsQGBwo7AQcK7QIHCmwHCQpOAAkK/AEKCmMCCgorAwsK/gELCtgCDQokAA4KJwAQClMAEQp8AJQKHgAICjoCCQvdAY0LTgAEC38CCgsEAAoKQgEKCs8CCwqXAQsLfgIMC7EAlAs5AAcAHweLALUCBwD3AgUL9gIICn0ACApxAQgKDAIKCuYBCwoNAAsKfQELCuACCwr+AgsKTQMNCnIADQokAY4KLwAHAIwHBgqUBgYKwwYHCmQBCAo2AAgK3QAJCuEACQpkAQoKTQAKCr4BCgrbAgwKlAGNCusBhwsoAocLWAQEAE4ABQBgAAUAtgAGAOkEBwC8BgcAIQcKAIoBCgDXAQsAFAIOAFQBkQBYAIsLSAGHAKwHhAqbAQQKUAAFCiwAiQuFAAULbgAGC6kABgumBgcLkAEICxoCCQu4AAkLDAKMC9oABAAJAgUKKwEHCjsEjAsqAgYLhQAJC2EBDAt0ApILTwAGANcABwBIAgcABAQHAMEFBwC5BgkAqAGKAAsDBwBZAwcAuQQHCrEGCQoZAgoKpQAMCtsAjAoxAgQK2wAGC10ABwuOBQcK4QYHCzsHCAuhAgkKVgAJCxECjAsrAIkLcwGIAJ8CBQBIAYcAlgOEABECCQsZAAoL0wGKCy8CBAtPAYcLrgOGAMwChgDlBQYAQwAHAAIBBwBeBgkAYgEJAKMCCgA+Aw4AUAARAFAAjAqsAYYAWAQGAI0ABwDhAAkAOwAJAF8CCgA4AQsArwIMACsCDQB1AQ0A7gGUADoAhQoCAggLJwAKCwUDCwtUAAwLzQCOCwEACAAPAwULWQKFC2YDiAtSAgQKNwAFCi0BBgo7Ag4KMQCSCmYAhAu1AIYLdAaFCmwBBAthAAULkwAGCx4BBwtSBY0LsAAECkwABwoOBgkKMgEJCq4BCQqXAgoKqwILCqsBCwrxAgwKTgEMCroBDgoCAQ4KbgGPCoMAiQo0AAYAuwOGANoFBgt3AQcLqQAHC/4AiAsMAwcArgELAC4ADgBXAY4LVwGHAJ8EBQBaAgcA4gcJAKIBCQAjA4cLpwUIAKUChwsUBIsLHQEECpAChwoLA4cKkAAFC3UChwsNBocKXQWKC9EABwoqAgcKXQKNCgoABQpGAwUKSQOGCnEGhQr0AwYATQWGAGQFkAA1AAYATgIHCm0BBwpNBQcK2QUICpoAjQoZAYUKVAGEC6QBhwBJAZMLIAAEANUBCgutAYsK7wEICgUBCQqQAAkK0gEKCnIBDArWAQ0KkACOClwBjgDMAQQLRQEJCoEDigt9AAYAzwYGCvgACQoiAgoKFwILCqkCjQqHAAQA3gMFAKEDBgBUAQgAeAEIACcDCADDAwgA1AOKAO8DhgBDBowA+gAEC8oChQvVAYYKNwKICr0BBQDaAAcASgYIAIYCCgBTAAsLigCMCygABwDoBYcAAgeHC8AECwAAABAATgCEC84ChQA7AoQAxwGGAPQDBQt8AAULkAAGCyQCBwsPAAcLmQCJC3UCjgsKAAYLSwAHC/sFCAugAQkL8AAJCxMBCgtkAAsLkgILC9MDDAtWAA0L1AEOC0IADgvPAA8LFAAPCxkAkAs6AIQKQQIFC40ABQuTAwYL9wYHC9MABwu6AgcLSQUJC1MACQsZAQoLeAEKC68BCwsfAgwLmAINCxgBDQusAQ4LPQAOC4AAEQs0AJELUQAGAKEABwB0AYkAVQKEAF0BCgu+AosL9QCGAAwChgquAAYAsAEJAO8CiwBCAZMLXgAEC1IBhQuQAQUA1AEKAEUBCwBYAwwAWQGPAGgAhQDfAIQANgIEC90ABQuTAgUL3QMHC7kCBwu7BIoLHAGHCy4EBAA7AIcAcgUGALQBCwDhAQUKbgOFCswDBAAwAAUADwGHALkDBQBiAogAyQEEAAUDBQBqAokA9AKFAPMChwDBBIoL+wGECl8BhADFAI8LTgAEC7wABwslAwsLFAGOCyUBBQt0A4sL3wOECh4BCgADAQoArAEHCrYBBwpzAgcK7AUICigACQo4AAkKJgELCskDCwrjA5IKlAAEAGQBBQDZAAUA7AEFAJACCAAgAogLIAIFAAMBBgDOBAcAngEHAFYDjgBrAIQA7wMPAA4AkAAFAAYALAaECuIChAtUAoQAoQKFCmIDBgAzB4cLNwcEAKUABwB2BYcAJQeHC2IGkwtBAAYAdQMGAPEDiQApA4UKdACECskBiAsCAwkA8gEMALUACgtpAY4LPAGGC1MCBQAJAAcAKQEHAMYDjAAyAQQLWQAFC+kBBgs7AQcLKQIHC9EGigvzAIYAzwWEALUBBQCSAAYAmwGKANECBQoPAgYKvQCHClsDCwpoAAsKKgIPCjwAjwp9AAYLegYJCwMACguaAAsLgQINC1UADQvJAI0LWgEGALEAhwDTAYYAYQWGCnQAiAuFAgQLpgAFC/kBBguGBokLbgCFCucBBApWAAUKmwIFCvECBgo8AQYKxwGHCrIDhQDIAIQAvwMGAIgHhgClB4sLywCWCi0ABApPAAcK7QYKCsIBCwpNAg0KTAENCu0BDgq3AA4KTgEOCmoBDgpwAQ4KeAEOCnsBEwpaABMKZwATCn8AlApaAAYAmwWHC/sEhgDhAQcLvQEICzMBCAvAAgoLKQAKC7cBCwvtAAsLbgKMC8kAhwtlAwQAVAAHAMoFCgBMAIoAjgALCxUBkAsOAIcLuQcEC70ABQvJAogLOQCFAPcDigtzAQQAOwEFAPsBhwBaBQQLKAKOCn0BCQD3AhAAHwAQACcAEABLABIAGAAUACoAmAABAIYAyAKGALoGhQqXAoUKTgMIAN4ACADcAQkA7gALAAQCCwA/Ag8AbQCSAGQABwB6BQcAhgUMAMgBBQp6AQgK0QEJCh4BCgq5AAoKMgIKCnsCCwofAAsKiQENCjgBEgpBABIKYACTClkABADaAwYApgcGAPAHCACmA4oA2QMHClgHCQqoAosKHgOGCuoGkQsxAIQLZgKECogCBQqxAwYKeAYGCvsGBwqnAAgKOAMJCocBCgp3AYsKuQCKC5UCBwD5BIcLmQcHAMICBwAiBIoAGgIHCm0GCApgAYkK+QCECpgACwBcAAsAxAALAJkBCwDCAQsAmgILAAkDDAAGAQ0AgQENAIkBDwBzABAALQCRAFIAhQruAwYAKACHAPUGCQtmAosLRwEFCqQBhwqpBYcArwEKAGEAhwpAAwYApwEHAJkChwC6BAcA7QAIAJgCCQAqAAkACgEJAHwBCQCFAgoAsQCKABQBBwAIAYUKXwEIANUABQooAAcKVgIHCmYGCQqmAAkKgAIJCq0CCQoFAwsK1wANCkEADgqsAA4KPQGRCgYABQtUAIYLowAICjwACQpXAYsKAQOJAMcBhQuaAQgAigMMALwCDADCAowA2QIVCyEAlgsoAAcKnwcICv0CCAoEA4wKnwIHCmwACArbAAgKhAEJCn8CCQoHAwsKEwGMCtABBQtCAQcLlQcIC7oACQsGAQoLuwAOC9AAkguCAIsAcAIIAD4CBQvjAIwLHQAHCwoGCwsrAY4LlwEFCg8ABgo4AAcK3gYICvQBCQraAgsKSwENCpYAjgoaAQcLcwUIC+YBCQvsAAkLbgMKC9oACwtfABMLEQCTCx8Ahwv7BwQAYgGSCwQAjAtQAIcAFgaGCl4HBQrNAAYKtgGJCscChQsKAoUKFgIHAOsABwDDBQ8ARACSAHgAiQqzAgQArgMGABUHCACVAwoAdAMMALgCDADNAgwA0wIMAOICDADtAgwADAMQAGEAkgCpAAYKuwEICzICCQrtAAkKOwIJCrcCCgqLAAsKywIMCqEBjQqlAYcAvQOFAD4DhgvrBpIAFwAFAPABBgC2AgcAywAHC6YEiQtsAokLhAAGACMChgANBggLAgEJC9AAiQtnAQQAYAMFAFgAiQDvAIcL7QEECz0Bhwv/BIQL3QEECkICBQs/AIUL/QEHAIoChwAeBQcANAQJAFAACwBOAAsApQELABYCjAAhAoQLIAEMACkCDgB2AIUKmwMHABIBCwDfAYsA+wEIC1kACAtsAgkLMQAKCwYDCwt0AgwLQgGPC3wABADxAYcAMAYHAAUBBwBbBAcASgUHAHwFBwA0BgcAqQYHAG4HCQDRAQoA+AAKAF0BCgCHAgsADwILAJQCCwCdAgwAEQINADEBhAqcA4UKmQKIAA0ABgAXA4oLeAAHAIICCAD6AAsAewALAIkADQAwAI4AXwAECgkBBwonA4cKtgMFCl0AjAoLAYcAlQUEALUDCgB1AwoAewMKAIQDCgCrAwwA+AKOAMEBiwtuAYQAMgOGC1UAhwriAwcASgEFCukABQpAAQYKjACICicBBADsAwgA1gOIAOEDhQrSAwQKiQMGCqUGiQpLAwoAIQKMAC0BBgCzA4YAJgSGAKQEBACIAwUAGgOYCgYAhgBcBYcLYAIFCxcBBgvrAAcL1AEIC74BCQt9AgoLzQILC+ICjAsCAoQK/QEFCxEABgtzAYkLEAKEALUCBAtzAAULnQIGC5cBCAs3AQsLCgCNCwUACwB5AQcKEQGJC30BhwC3AgcAggGKAMkChwoRBIYACwUGAAcABgAjAAcAkwAHAC0EBwAgBgcAJwYHAH0HCAArAAgA0AAJAIAACQBiAwoAFAALANUDkwAhAAcAfQONAKgBiwrqAJYLOAAFCwsDBQsnAwYLdwaGC4wGBQoiAwcK5QeICiUDBAvEAAUKpwAFCy4CBQqDAwULtQMGCpoBiQoJA4kKFQOGCqkGCACIA4wAEwMGAEIBCQAoAgsAEgENANEADQDzAQ4AVQAPAH4AkQBGAIcKCgAFCgsABgp1AAYK5QEHCm0ECQpGAgkKUgILChUACwoyAwwKFwKNClYABAoIAQcKKwQICswACAqBAYsKuQOEC/ACigo4AIUK1gEGABAHCABTAAgA5gIIADEDCQAcAAkAHQAJAHUDCgCDAQsAeQILAOQCDQDrAA0A/gAPAI8AjwCSAIwAMQCGACgHBAvjAAULnwAFC5kBBwtQAAoLJgEKC98BDAuiAQ4LMgAOC/kAjgsnAQcLvgUIC0IACAuJAAgL+QIJC34CCwtQAAsL1AALC3ABCwuiAQwLCAANCw8AEAs9ABELOwATCxwAlAtUAIsK9wOKC9QBhwClAQYAnwEHABkEiQC6AQYLJgAHC8QECAu5AAgLAAEJCxYACQtLAQoL4gILC80ACwscAgsL6gINC48BDQvRAQ4LWACOC8IAiwAhAYUKywIEAG4ACgCfAQoAVQKOAM4ABAufAAYLcwAHC/wABwsBAQcLiAcIC0UACQuAAQoLWwAKC2cCDAt3AQ4L6wASC3UAkwt7AAULjwOICxYBBwDNAAcA0AcIChoDCQqQAQoKKgGOCuQAhwvuBgQLlwAHCx8GCAtfAYkLQgGICtQChQveAwcAAwYLAAACDQDNABMAHgAWACQAFwATAIcLAwYFC8IABwt+BgkLWgCMC7QABgq+AAcKAAOHCpIEhgA8BQQAGwGHAKoEhQupAYULywMMACUCDgpDAJMKPACHCv8DhgC4BooLSwIFC0gABgsIAQcLFQAHCy4ABwvdBwgL1wAICwECCgsKAYsLFgAFAD8BhwAWAgYKiQAJCksACQr9AAoKwgCKCrwBBwCcBBQAcAAGC+8ABwt2AAoLXwALC1sCDQu7AQ4LoACPCwQAhguvAQULagMGC40GCwqDAgwKcwCPCwAAhgDHAwYLQQAHC6sDBwuUBAcLhwYJCxwCCgu4AgsLCQELC9wCCwugAwsLqQMMC48BDQu2AZULEwCJC8gAhwCUBwUK+AIHCh4CCAqHAIgK8AGMCywABwt3BogLMQEHCj8BBwpjAQcK+wIKCoUBkQorAIgA3wKKChIDiQsTAIQLuAIFAIQACQDmAQkAywIKAMoBCwB1AQsAnAILABsDCwCBAwwAEAEMAKgBDAAbAgwALgIOAPUADgAHAQ4ACAEOAIkBjgCTAQoAJgCLABADhABGAwQLLgGHC+YGhQB7AQUACAAGAFkABgCQAQcAIQYHAFcGBwA6BwgA2gAIAKYBCQA6AgoAcgIEC9YChQt2AgQA+QOKAJQCBgCDAQcAcgONAG8ABgDgAAcAbQOJAIcCBAo6AAUKHgEGCj8BBwqSAQcK5gQHCm8HCApkAYwKmAGHABYDCQD+AQoANQAECoUBCQq1AAoKHQAKCjADCwo3AQsKMQIMCkMAjQq1AI4AygEGC3YABwvXAAcL8QWMCwsAhgC6A4cAigGGAFcFBQvhAIUKdQGEAHIDBwCBBYcKtAeHCgEHBAtyAQUL9AKHCy4FlgsNAAcLYgEKC5oBiwsvAwYLfgYHCzAACAsDAwoLdAANC2gADgtpAA4LuAAPC6gAEwtcAJQLRAAHAHwAiAAmAAUABQEHAE4ABwDHAAgALwMJAH4ACgBWAYwAhwIEAHQCjADUAgcACgEIACQDBwpzBpEKWQCHANAAhgCaBAYATwCHAO8FhAqgAoUK4QKIAOUChAt4AAQAxgIGAHgBhgBeAoYAQwWGANYFBgBSAwYAEQaJADUDBQqRAIYLUQIHAB8FjACHAAQA0wEFAJUBhgAgAgULNAOHC6MDBgBkAAcA9AAHAHgCBwBJBggAsgAIAH4CjQA6AAQKgwGHCggFBguXAAYLiwYHC38BlwsKAIQA4QGHCiYChgBiBQYLWAYLCwsADAumAQ0LBgGOC2gBhQAXAwQLKwAFC1gBhQtlAQcAywSMANIDBwCuAggAIQAIAO4ACgBoAgsA0wELAHEDDQDZAA0A/QCOAAwBiQBZAwgA0wEIAO4DBwuUAAgLHAGNCz8ABApAAocK7wSFC3gDBQqXA4YKiQYUCiUAlAslAIQAvwGEC8cCBACAAAUAnwEGAM4BBwAmAQcAQgIKAMYCiwBWAAQKUgAFCk0BBQqIAwYKzwAHCkUBBwq+BggKZQAKCgoDiwrcAIgASwKJC7gBhQqHAwYAqwEHAPoDigC0AgQAwwCHACIDjAqTAIYACgaGAKwChArBAogAWQELC6YCjAszAYUAbQGGAJMGBAtBAAUL3wEFC+wDBwt5BwgLPQEJCy4BCgtkAo0LFgCKANgBBAsFAYcL/gGGCloAjgCxAZcAHAAECyMBBwtlAAkLAwIMC5gADAu7AQ0LiAGOC2UBjADlAwUAAwAIAEICCQB2AAoAwQKNABcBhwvyBAcKLQMMCvEBjQo4AIUA5QAGCn0Ahwr9BAgAZgAKAEICCgCgAgwA8AENAJgBDgB5ABEAagCXCgwABgBiA4YAOASIAP4DBAuCAIcLSwMFCyoABQtvAwcL9QAHC0QBBwv8BQsLzwELC9gBDQtrAZALNACWADcACABzAAgAXgEJAOkBCgCAAAsAMgEMAHUBDgAeABEATwATAFAABAuGAIULdAGGAJEChgClA4cLewQEAOYAhQC+AoYAwAYEAOQBEgAaABMAKgAUACsAFQAAABcAGwCYAA4ABwC5AIcAvwIGAKEBCgBqAgcKUgQJCgIDCwpwAIwKnQGGACMDhAuEAoYA7gQHCxwCDAoPAZEKbQCHC3sAhAB5AoYLbwIEC4wDBQtnAQUL/AEGC7sGBwtXAQcLzAeHC+oHhwDfAQoABgEHCjABCQqGAgkKXgMLCrgCDArQAA8KTwCTCmwABAtVAYcL4AGGAD4DBQBGAAUAbgIGAE4BBwAIBAkAqwALABoACwDVAAsAfQILAMMCDADKAAwAfAENAOIADQBjAQ4A3gCRACoAhwrVA48A2QCJC3IABAAXAAQAjQAFADkBBQD2AwYAMgAGADMABwCOAAcAgAEHAC8CCACAAgkAzAEJAA8DCwDlAgwAtwCNAOgBjQBoAQcAMgYHC8sHCAsrAQsLegOMC6IChAqyAQcAjAKGCiYCBwD+AgUKKQKKCjgDBwDhAggAKgGICsQBBAvuAAUL9wEGC7MABwvTBwgLfQEIC9kBCQuVAAoLtwAPCy0AjwtWAIUKJAEFAN4ACQCPAooAFgKKCocABAt5AAULnAAFC10BCQuIAAoLXQIOC1YBkwtrAIkAigMGAPUDhgDiBAYApAcGANkHCADfA5AAeACHC6gEigD3AQUAmgAHANMFCgB7AYoA5QEGAEsHBgB6BwYAhQcJAJUDCQCdAwkApAMJALcDCQDvAwkA9QMMACYDDAAqAwwALgMMADADDAA4AwwAQAMMAEUDDABfAwwAZAMMAGYDDAB5AwwAfAMMAIQDDACGAwwAjAMMAKUDDACuAwwAtQMMALoDDwCvAA8AywAPANUADwDaAA8A4QAPAOcADwDvAA8A+AAPAPwAEgC+ABIAzAASANcAEgDYABIA3gASAOEAEgDmABIA7wASAPEAFQAqABUAKwAVACwAFQAtABUALgAVADUAGAAbAJgAHwCFAMwChwBMAwQAWwAFAIQBBQBNAwYAzgAGAPwABgBtAQcAiAAHABMCiABtAgcKiQEKClsCiwrOAAYLUAAGC54GBwutAAcLtgcJCyMCCgvaAg4LEgCWCycAiQDsAgQLmwOGC68GBAqQA4kK6AAHCmIABwq1B4gKzAIOAGcAhQrdAoQLUwIMAJ4AEgAIABMAPgAUAAYAFgAEABcAAgAXAAkABQvwAAYLywEHCwwABwtyAAcL9gEHC9cGBwvZBgcLDQcIC5ICCQsBAAsLvwMNC74BjgvTAIcAQAIFAAMDBQBfAwUAggMGAIgCBgBgBgYAbAaGAPQGhQBLAQcLeQIHC4kDBwuNAwcLAgYJC/8CjAt8AowAeAIFAGsABwDJAIgABgIGAL4BBwAZB4YL6gEJAFMDjQD+AQcL+gAIC/oBiAv7AQQA+AGJCkgAhAueAAQLjAAHC2oBCAvRAAkLCgAJC6AACQv3AQoLsQILC14BCwspAgsL1QIMC/wADAtHAg0LwAANC2ABDgsNAQ4LZAGUCzIABgtVAocLJgWHCq4FBQBzAwUAzwMIAIgBlAAHAAYL5AAHCz0FCQuYAYoLVwELC1wBCwpYAgwLYwANCvUAEgsBABILCwCTCwQAhgsoAQUAmgOGAKsGhAstAgQLJAIHCqQABwojBgkKawCMCuEABwvFAAgLjgAIC0UBCQuWAAkLVAIKC14BCgthAQsLSgALCzsBDgunAY8LjQAFAOEDBwADAokAWwAEAIMACADIAAUK5AEFCv4BBgqyAQcK6AMHCkoEiAoCAJgACgAECz4ABQtTAAYLjwEGC0MCBwu0AgcLTgMHC/cDBwsHBwgLkwEJC4oBCguFAAwLBAAMCykBDAvEARALUQASCxMAEgsZABULDgAWCwwAlwsSAIwLywGEC7EABwCZBQkAbQGJC20BhArMAQUAZwAGANQHBwCZAwgARAIIAFECCAB2AgoAHAAFC5sBhwuNAgQKpAOFCnsDBACPAwUAYwMFAPUDBwDyBwgAHgOIAC0DBwu3AQoL1wILCwQBiwusAogKcQIFC9AABwvxAocL+AUFAM0BBwCFBwwAJwANAAkBDQC3AYYKTAAGAFUDCApcAIkK3QAFAIcABgAHAgcAugYKAA8BCwAFAZEANgCLCy4DDgBSAZQAUQAEACwBhQC0AQUAowEFAK8CBwBgAwkA1gGHC2ADCQBEA4UL8gCGAJEHBAr7AoULuQOECm4ChACJAYUK/QAIAGUBCgDpAg4AqgERAF4AEwA5AIcKIgIFC2cCkgslAAkKSQAKCm4ADgq5AJEKdwALAL8CBwpwAgcKlAMKCgABiwpXAIULIgEFCtQADAojAI0KfgGEC3wBBQs0AAcLFQEJC3ABiwsXA4UAgwEKC4oAiwvcAQQABgAFAMQCiABLAAcARwUJAEUCCgB/AgsAxQGMAEgChAAvAYoABAOHCpcEBADtAgUKMAMGCwABBwszAQcL5wMHC8kFBwvEBgcLygYICwkBCQueAQsLPAEMCzQADQukAZMLZACHCxAFBgApBAUKZQMFCsgDBgpaBggK3gKIChADBAoeAgYKtAYGCr8GBwo6BAcKCQYICjgACAp2AAgKnAEICjQCCQp4AwkKjAMKCjIACgqnAQsKrQILCrkCCwqlAwwKKwENCn4ADQqIAA0KqgCNCr4AhgDiAAQAagAHADYBCwDNAoUL0wIFAHoDBQDcAwQK6AAJCsoACgraAYwKsQEGAHICjgCvAQoAwgKWACwADQAzAAYKbAAHCusDBwqdBAgKbwCIClcBhAC6AgULbQAGC/gGBwtnBwwLKAGMCy4BhgA8A4YKsAaKABEABwCJBwQKhQAFC9gABwrHAgcKEgUHCjEGBwtXBwkLjQAJCw4BCQunAgoLnwAKCykCCwvFAAsLtgEMCxoCDAsvAg0LwQANC6cBDguQAA4LpgAOC6cADwtDAJMLVACNC38ABwtQB4kLUQAGCmMABwoQB5EKOQCGC4cBBQCxAgYAVAAHAOIEBgo+AgcKrAEKCp0CCwrlAQsKSAMMCiwBjgr6AAcLQgGIC/kABwuwAYcLcQaHCk8HiQr8AAYLmwCMC+oABwBnAxMAGwCTCxsAjADyAQUA2gMGAIIAigA3AwYAAQcHAC4GCADKAQoAZQAKAD4BCgCxAwwA3gIQAGgAEgCxAAYKQwGHChwGBQt4AooLDgIKALMBBwrNAYgKBwMGC5AABwu0AwcLEgQHC0EHCAvrAAgLzQEJC8UBCQsSAgoLYgERC00AEwtjAJQLTwCKAMYDBwBsBokAgQCHAOUDiAD2AQULxAAGC+YBBwvUAAgLNQGIC1oBBwrXApIKSQCEADcDhAuuAocAhwcEAPoCBwDcBokAYgCICkECGAAIAAQLHgAFCysAmAsIAAcAFgSLAKAABwDsAQQKnQEFCqUCBwvsAQgKsAGMChgBBgAtAAcAsQEIAIEACQAVAAoAiAELAE8ADADzAQ0AxwCNAMMBBwAuAogAYQEEC9wABwv/BQkLXQCLC9oBBwqGAgcKwgYLCr4BjQqyAIUAEQOGAHkECABRAAkAvQAJAMkACwDeAQsAyAKNAFIBBQBhAZcAGgALAPoChAqLAYYA6AcEAGMChQBeAgkKrgAKCqQACwq4AQsKSQOPCmIAhgqqAQoKYAKLCuoDigr6AAYAGQAHAFcDBwDqBJAAIAAHC70GiguJAQULBwGGC54BBgDbB4UK3AEEAAQABwBeBAcAKAUHAKoGCAAVAQkAbgIKAAkACwDUAgwAXgEMAI0BDQAcAA0AnwAPAFkAEgAFABMACQAUACIAFgAvAAYLsgAGC9YGCAv7AAkLsgIKC5sACgvEAAoLdQELC7oCDQubAJQLXQAFC2EAiQuJAQcA/AILAM0BDACsAAUKTAAGCsoBBgrxAQcKZAMJCpICCgpSAgsKNgIMClIBjQrIAIYAqQWKCygAhgtnBoYApQUGAJAEBAoOAgcKBQSHCh4EBAu/AAcLpgMIC4cCkQthAIQKfAIGAOkABwqUAgcKZAQRCh8AEwoWAJcKDgAGCqMGiAtuAAwL9gAPC6IAEwtAABQLCAAUC18AFgsYAJgLEQAFC6UACQtaAYoLjwIFCz8BhwsWAoYA/wAJANgACAuAAIsLswAJALcAiwAeAQsAvAOXAAMABAAYAgcAdQQKANMCiwBzAQQKFwEHCi0BiQpqAQcAHQEFCzkABgtlAAYLfwYHC4QABwsYBAcLggQHC4cFBwvjBQwL7QEPC2kAlwsPAAULywEHCzEEBwrPBggL8QCIC04BBAqyAIUKjwGHADAChACyAocA3gQSAJ0AkwA/AAoAVwILACEADAA7ApUAAQAGC0QBBgsIAgcLUgEHC1AGBwvBBggL5AAJC0UAiwvuAgcARgcMAOsBDAAIAg0AfwGOAPQAhwveAoYKnAYKAMABCwB2AhEAdQAGCsoABwvBAgwKaAERCnYAEgobAJQKQwAEC0kABgtkAgcLnwMHCx4HCAvZAAkL2AEJC/0CCQv+AgoLmAELCzMACwsZAwwLCgEPC54AFAtZAJYLIAAEAL4AhQAqAoUA6QMFC4UBCAt8AokL5QAFAL4BBwpoAwoKBAKLCqcAiQo5AYQK4ACGACEFBQoiAgcKIwAICgsACAoMAAkKOwEJChUCCgoiAwsKpgAMCg0CjgrzAAYAfAKJAEUDBQrxAAgK8gAJCsMBCgqbAgsKVgKMCq0BFgouAJYLLgCIC9gBCwAWAY4ASQCNC7kAhABkA4YAzAMECm4BiQoEAooA8gMFC70ABgrIBgcLugEHC7sBCAsZAQwLrgANC1MAjQsFAYsLgAEGCwIABwu/AAcLvgEHC/YCBwvuBAcLyQYICxYACAsOAQgLZAIJCwQACQunAAkLOAEJC7QBCgucAAoL2AAKCzcBCgtvAgsLSAALC0oBCwvHAQwLZQAMC0EBDAv4AQwLEgIMCx8CDQsRAA0LnAANC04BDgswAA8LRgARCzwAlAtAAAYKSwGICm8ChwDPBIQAMAEGCzwABwueAgcLLwUIC5sBCAuzAQkLjQIJC+QCCguBAQsL3gALC0QBCws9A4wLYwIHAPoBBgumAAcLdgGHC5YEDgsrAJILFQCHC54GhwpgBwULzgCGC44BhwsyAJYAGgAGADUABgDHAAcAgAUIACAACABdAAoAjQEKAHUCCwBRAgsA+wINAEYBkQAjAIYAaQCECooBBABLA4oAGgMLAMACjQCMAQUAcgAFAP8AjQAdAQYAawIHAIIDBwBEBAgA5QESABwAEwB0AIcKiwcJAJEABwo+AocKtwYHAPMHCAATAAkAWQCKAD8DhAqSAgYLBQIHC4cECgttAosLwAAHAI0HBwuNBwkKDQMKCpAACwqBAQ0KoQANCuQADQoMAZQKawCICnYBCgvfAIsLhQKHAMAGBwtAAAcLIQGIC/UABApYAQYK8gGLCkMBiADqAocKJwSJCpsABADbAwYArAcGALYHBgDGB4gA4wOFC2EChQqKA4YADgaGAGoDBQuBAAYLPQCHC7MDBAD6AwYAkgcGAOUHhgD3B4QALgMLAH4AiwAfAYYA8AQFALsDiAAuA40L+gGECzoBBgDVA4sL6AMFADgACAB8AwgAkwOMAAgDlABkAAoABAAKAA0ACwB+ApQAOQCUC0oABQDiAoQKaAKFC30CiAq0AoUA9gKECjEBiQtOAgULGAGHC8oEhgvuAYcAWASFCxkBDQAsAA4A1gAFCtYABwpbAggKYwIJCq4CCgpYAAsKywELCvABDArPAYwKTgKLAEgBhwsoBIkAhQAHAKgADQDEAI0A7QCGCqcGhgCABIcA3QQFAG4ABgCpAAYApgYHAJABCAAaAgkAuAAJAAwCjADaAAYAGAcKAGcDDAABA4wAEQOEC3YCBwshAAcLeAAIC+kBCQs/AQoLNAMLC+wDDAt7AQ0LdQANC5wBDgsZAA8LNAAPC6EAEAsvAJULAgAGAIUACACdAQkAYQGLAOEDkQoTAAQLqQOFCyEDhgDSAwYAXQAGAOQFBwCOBQcAOwcIAKECCQARAowAKwAGAD0BCgAAAgQK4QILCiYBDAo8AAwKtQENCkAADQp8AY4KrgEJAHMBBws3BpALKwAGCt4GCAoIAgkKWQEJCpMBjgpeAQUADgIKCvIAigpDAgkAGQAKANMBigAvAgUKiwAHCpAEigobAgQATwGHAK4DjADyAoQLbQELALYAjgDDAI4LHQAFCwcAiwsGAwQL6gKHC0IECAAnAAoABQMLAFQADADNAI4AAQAFAFkCBQBmAwULaAGIC+0AhAC1AIgAcgGGAHQGCABmAQQKawAHCmUCCAq3AQgK+AEJCvUBCgp/AYsK3QGECuUAiQsRAwQAYQAFAJMABgAeAQcAUgWNALAABgAZAgcAFAMHABgHhAqHA4wKRwAGAOcChgDHBAYAdwEHAKkABwD+AAgADAOHC9UFBwCyBgQKLwAGCnUBBwrEAQcKHwIHCkAHCQoGAAsKAQGLCocBBgCAA4gA6wOHAKcFiQtVAQUK1AOGCtoGkQsWAAQLFQEFC2ACBgvtAQcLyQGMC4ABBwoYAgcKMwWICo8AjADoAgcLGwCHCzwBEgB+AAUKEwCGChUCBAAUAwsAKQAFCygCBQtKAgULpAIGC8ABCAv0AAsLAQALCykADQsDABALNgARCwQAkgsNAAQA2QMGAAkHBAuRAYkLCAEFCosBBQq3A4YK8AYFAHUChwANBgsKlwIMCtIADQqmAA0KNgEOCnUBkworAAkLHwIKCwwCCwseAAwLDAIOCzsBEAsSABQLGgCUC0EABAvNAAULbwIHC2gAiAsHAgUAJQGGAFkCBwtDAgkLKQAJC/QACQudAgoLBQALC10DCwu3A4sL1AOEC80ChAq3AgcK8QEJCoMBkwpRAIQApAGOACUABgBuBAYAbAcMAD4DDABuAwwAfgMPAN0AjwD1AIQL6QEHACIGjAAeAggApQOIAL0DBgBbBQcAHwAIAHUBBQocAQYKMQAGCl4BBwp5AQcKnQYICqYCCQqhAAkKSQIJCp8CCQpHAwsKkAONCqsBhwt8AwQARQGKAH0AiwsvAIQKVQKKAEMBBgALBgcLRQYJC9kBCwvCA5ILiwCLCowDBwszAwkLGgAJC4gBCguYAAoL4gALCxMADAsUAQwLqgEMC00CDQvMAQ8LYQATCzAAlAtoAIcLMwAEAM4ChwDABAYAaAcGAHEHBgB4BwkAswMJAM4DDAApAwwAUgMMAFoDDABqAwwAdwMMAIgDDAChAwwAtAMMALgDDwDGAA8AzgAPANwADwDjAA8A9wASALwAFQAwABUAMgAYABkAGAAdAAcL+QIHCxsEiQshAgUAfAAFAJAABgAkAgcADwAHAJkAiQB1AocLXgKHCt4HBwrXBwkLLgAJCmUACQrCAQoKQgAKCkoDCwoYAowKSwIGAEsABwD7BQgAoAEJAPAACQATAQoAZAALAJICCwDTAwwAVgAOAM8ADwAUAI8AGQAFAI0ABQCTAwYA9wYHANMABwC6AgcASQUJAFMACQAZAQoAeAEKAK8BCwAfAgwAmAINABgBDQCsAQ4APQAOAIAAEQA0AJEAUQCEC6IChwAVApUABgCECwIDhQAaAgULTwAHCwMEBwvFBYsLNACLCj4ABABSAYUAkAEFCxUDhgvDAAQL+wAEC7ACBwsBAgcLBAUJC1cAigttAYYK5gYGAAAABwBUAAsAfwORAAsAiwB8AwQA3QAFAJMCBwC5AgcAuwSKABwBhQDdA4ULeQMEC6AABQtKAQcLmgWIC64ABgqBBgcKAAEHCmwFCgrzAYsKngIHAFADBAoWAAUKCgCICmEAigD7AYUK4QEEALwAhwAlAwUAdAMGANwCiwDfA4cLyAMLC3wCDwuRABELIgATCzIAlwsUAAcAvwMQADwABgqGAAcKtQEJCiUADgodAY4KcwEHCuYBCAqbAAsKXQCMCqQAhgB1BgcAUQGFCk8CBgDFBwgAmgMIANIDhQt2AYQAfgKKAPQBhQvbAgUKfAEFCooCiAo2AYoLfQEECmwBBwqEBAcKowSJCpkBiQvgAIwApgCGCuIBBAtyAgULggIGC6kBCgvKAIsLjQAECg0DBgrnAQcKngMICgcBiwr0AYcAogEECl4AhwrxBIgA+AKECqEBiAtDAwUKXAGGCgoCBgD9BIYAAgaLCx0Chws9BgULgAEIC8cBjAswAIgAAgMFCwgBhgu4AAQAWQAFAOkBBgA7AQcAKQIHANEGigDzAAQKmAEECuUChwr0AYYAdAWFADACBgB6BgkAAwAKAJoACwCBAg0AVQANAMkAjQBaAYcLOwYFC3kCBgscAAcL2wCHCysFCQsBA4wLuQCHCxEDBwtnAQgL8wCMC68AigBKAgcA9wSGCkkAhAtpAAQApgAFAPkBhgCGBoUKQAIEC0QBigtoAI4K5wAGAH0CBwrwBAcKjgYLCrEDDApVAQwK1wEMCjkCFwsVAJcLFwAICy8CjQttAIYAmwcHAL0BCAAzAQgAwAIKACkACgC3AQsA7QALAG4CjADJAIcLwwOHALkHBAC9AAUAyQKIADkAigBzAYcKGgKEACgCBgBzA4UKnQEGAJsDhAv2AooL1wCICu8BBwo2AAgKOAEKCr8ACgpmAowKNwIHC18BiwuAAAcAawMGCtQBBwrGBQgKEgKOCiIBhwD8BhEAMQCFC5YDDAuOARQLJwAVCwsAlgspAAoAlQIGCuQBhwo2A4cAmQeGABoDiQqEA4cKNwUGCrwGhwrmB4QLVAGGAG8EBAAQA4UA6QIFAFQAhgCjAIUAmgEEANADBQvZAwcL/QEHCxECkQtgAIQK2gGGAL8Chwt/BwUAQgEIALoACQAGAQoAuwCOANAAhwrgBYUA4wAJADACDQDQAIUKMQGEC/cABwBzBQgA5gEJAOwACQBuAwoA2gALAF8AEwARAJMAHwAHAPsHCACgAo0AwAEEC7gABQuGAQYLUQEHCxcABwvuAQcLagIHC7AFCAsbAAgLVwIKC5kAiwvGAocA0gGHCtQEBgCnAAcAugAHAJACCgCDAgQK4AEGCi4BBgpqBgcKRQMHCgsGBwp5BggKrQEJCuQADQohAQ0KVwGTCmUAhgCUBYYAoAUFAJwBBwoWAQoK4wILCsQCjQpcAYYAXgSIADIClAsuAAkAPAGLAAABhgDrBocApgSJAIQACgvjAAsL8QELC8UCjAufAY8AQgAGC2gBBwuABogL3gGQChwABAA9AYcA/wQFAD8AhQD9AYgLuwKRCiQAhgDDBQsLVwGOC38AhAvjAoQAIAGHC90GCABZAAgAbAIJAGACCwB0AgwAQgGPAHwAhgDJBAcApQQEC0MABQumAQYKawEHCw0EBwsJBQcLEwYHCqMHCArVAgkL5QKRC2wAhgC8BQYAsQKGAKsFigB4AJcAAQCJCiUDjgBJAQUKLQOHCv4HhwDiAIoLYAAHAD8HBQrIAgsKEQANCkEBkApDAAkAzQEGCkABBwoNAwcKgQcJCjcACgq6AAoKEQEKCpgCCgohAwsK5AMLCuUDDQqdAI4KqgAIC8sACAoPAQsLNwMLC04DDAviAQ0LhQANCxUBDQsuAQ0L0AEOC80AjgvdAIcAQgUEC8EBhQvOAoYAVQAOACsBBwpnAAcKXwMLCrgAkQo+AAQLYwEGCzcBCQsAAYoLlAGJCpMCigv2AoULOwMFC0AAjAtFAoYAkwQEC7oBBwsXBAcLSAWHC2sGhADUAwUL0QMGCyABBwsQAocLKQQFABcBBgDrAAcA1AEIAL4BCQB9AgoAzQILAOICjAACAoQAJQELClEBjgovAYgLHQEFABEABgBzAQkAEAIMAGwBhAv+AAUKTQAHCq8FCgpLA5MKSQCWAAUAhArKAQYLDAAHC8MEkQtJAIcKjAUGCm0Aigp+AYcLfQAGCkoBBwo8BIsKjgAGC3EBBgv2AQcLDAQIC1wBCQvEAQoLGgALC+AACwuDAQsLBAMMC18ADAt1Ag0LwwANC88ADQvxAA4LBAEOCw4BjwuMAIQLDQEFC+ABBwsUAgcLrQQHC04FCAsjAQsLXQGOC4wBlgAwAAoAWQINAGEBjQB4AQUACwMFACcDBgB3BoYAjAaOC98ABADEAAUALgKFALUDlAsPAIcL5AaGACoFhADwAosA4QKHC5ECiAsVAocAnAEEAOMABQCfAAUAmQEHAFAACAAsAgoA3wEMAKIBDgAyAA4AewAOAMAADgD5AA4AJwGPABsABwC+BQgAQgAIAIkACAD5AgkAfgILAFAACwDUAAsAcAELAKIBDAAIAA0ADwAQAD0AEQA7ABMAHACUAFQAhwrBBwQL0wAEC0wBBQtPAQYL7gAHCw0BBwsrAwcLBQcICnoACAtEAwkL+wGNC/IABgCrAoYA5AQEAGkDhArqAIYAQwMGACYABwDEBAgAuQAIAAABCQAWAAkASwEKAOICCwDNAAsAHAILAOoCDQDRAQ4AWACOAMIAigDaAwUL8QMMC0YCkguDAAQAnwAGAHMABwD8AAcAAQEHAIgHCABFAAkAgAEKAFsACgBnAgwAdwEOAOsAEgB1AJMAewCFAI8DiAAWAQUKrgEFCqQDBgqDAAcKoQEJCgoCCwo6AY0KhgEOCpUADgqPAY8KOQAEAJcABwAfBogA7QIFC+QABgvLAAcLnAAIC1sBiQsJAYQK+wEKAN0DjAC8A4UA3gMFAMIABgCfAwcAfgYJAFoAjAA0AgQKVwGFCv8BhQCpAQcKxwGKCk8CBAAGAwcL3AEHCzgGigtXAAUAywOHCmUFBQs+AZMLeQAFCyMBBwv9AgkLhQGMCyQChgo/AgQAOwMMAIYCDADBAgwAyAKMAMoCiwDwAokAlgIFAEgABgAIAQcAFQAHAC4ABwDdBwgA1wAIAAECCgAKAYsAFgCLCwoCBgDvAAcAdgAKAF8ACwBbAg0AuwEOAKAAjwAEAAYArwGGAJ0CBwpnBAcKJAYKCikBCgqmAQsK/AILCioDDAoIAQ0KZgANCiwBDQrkAQ4KkwAOCuUAEQpHABIKdgCTCngABQBqAwYAjQYPAAAACgsNAosLUgAGAEEABwCrAwcAlAQHAIcGCQAcAgoAuAILAAkBCwDcAgsAoAMLAKkDjQC2AYYARgWICyMChAumAQULYwGRCwAAiQuJAwUAqgKHAF8HhAApAwQAuAKFC2EDBgAyBAYAwAUOCiMAjgq/AAULkgOGC1kGhQvqAIcLZwWJCwwDhAp9AAQA1gKFAHYCCAAiA4gARgOECtECBgA5BQcACAMTADgAiAqRAIQAygMHChgDCAqTAAoKNQOLCv0DiwrKAwgArAOJAB0DhwsgBQkA+AAKAJABBwswAwcL2QQHCs8HCQsbAQkLCAIKC9UACgszAQoLzwEKC58CCgvqAgsLkQELCxoDDAsFAhILawCTC3MABgCfB4YA+AeHC1MBDQApAA8AXQAFCqgABQqiAwgKSgAJCm8CDAr0AYwKQwIGAHYABwDXAAcA8QWMAAsABgrcAAcKTQSNCmkABgulAQcLPQAHCwQGCgsLAIoL9QEHAGcCigD7AIwLdwKHABQEBgoTAAcKhQWLCqwBhQDhAAcKYAAICpEBCAq/AokKgAORCnQABgtmAAcLSAAPC44AkwtDAAcKqQcHCq0HCAq+AogK7gIHCu4HCAqWAAgK4QIMCm4BlwseAAQAcgEFAPQCBwAuBYcLNwMICiADCQqUAAkKaAMJCnoDCwo1AQsK6QMNCgsBjQpDAQYAfgYHADAACAADAwoAdAANAGgADgBpAA4AuAAPAKgAEwBcAJQARAAKANEAhwtOBwcLRAAICzAACAtYAAgLRgIIC6kCCQt1AQkLYAMLC50ACwtQAQsLSwOUCxsAhgCiAwQLWAAFC4kABQuuAAULCQMGC4AGBgu9BgcLTQAHC6oBBwslBQcLSwUIC34ACAszAgkLCwIJC+4CCgs2AQoLRAMLCyoACws+AQsL2wIMC0QADAtcAAwL+wEMC7QCDQtRAA0L7gANC3YBEguKABMLTgATC28AFAs3ABQLTQCUC1wABAuqA4cLJwcFCiMCBwqoAQgLaQKKC18BBgAGBQYLhAYHC9sFCAt1AAkLOgGKC64ABgD3AgYAfgMHC8MCiwszAgQAeACHAGYHCQCBAZUAEQCKAK0BhQuTAQUANAOHAKMDCgDHAIUKhQAGAJcABgCLBgcAfwGXAAoABgD5AogKuwAIAG0BCgoAAAoKMgOLCtwDBAssAAULNwEGC5wABwt/AgcL+gIHCyMHCQsIAAkLzgGUC1MABAtaAQcLcwAJC7QACQvIAYoLawGICq0CBwA+BJEALgAGAFgGCwALAAwApgENALwBjgBoAQYA/AMGAOwEhgA1BgQAKwAFAFgBBQBlAQ4A2AGWADoABgBIBwYASgcGAEwHBgBNBwYAUgcGAFUHBgBvBwYAdwcJAJgDCQCZAwkAnAMJALIDCQC/AwkAwwMJAMoDCQDlAwkA8AMJAPkDDAAbAwwAHQMMAB4DDAAgAwwAIwMMACsDDAA0AwwANQMMAEcDDABJAwwAUAMMAI8DDACZAwwAmgMMAJ0DDACpAwwAsAMMALEDDAC5Aw8AuAAPAL8ADwDHAA8A7QAPAPAADwDzAA8A9gASAMsAFQAoABUANAAVADkAGAAXABgAHACYAB4AhgDVApELOgCFAHgDiQpqAwQAxwIICgYDCgqeAowKMwCQCygABgu5AAcLaweLC6ECiQq9AokAuAEEC0cBBQveAQcLNAUIC/ECjAvjAAQKfwAFCl4BBgpkAQgKqgEJCjwCCgr3AIsKOAEFC/wDhQv+AwQLZwCFC5EBBgB5BwYAhgcGAKcHCQCSAwkAqwMJALgDCQDTAwkA3gMJAOYDCQDrAwkA/wMMADsDDABCAwwATQMMAJADDACnAwwAtwMPAKwADwCuABIAxgCVAD8ABQC+AwUA2wMEC/MBhwuNBQcAdQMGCjsABgriBgkKWwKNCo0BCgs+AI0LpAAEAE8DhwBGAQsAFAGOACUBBABBAAUA3wEFAOwDBwB5BwgAPQEJAC4BCgBkAg0AFgCEC2AABAAFAYcA/gGHAOoFBgpvAAcKBAAICqMACAoIA4oKNgIEACMBCQADAgwAmAAMALsBDQCIAY4AZQEHC48BhwvUBQQATQKLABoBBgszAocKygcFCikBhwoOBAQAggAHAEsDhwAaBgUAKgAFAG8DBwD1AAcARAEHAPwFCwDPAQsA2AENAGsBkAA0AAQAhgCFAHQBhQCoAogKawEGAM0HCACnA4gA0QMEACoDhwBiBocKiwYHAG4FBAuOA4ULQAMHCigDCAsKAYsLQgKEAIQCBADWA4oAYwOEChgBhwAcAowKNgCHAHsAhgC6BwQKpQGFCiQCBgBvAogAFQMEAIwDBQBnAQUA/AEGALsGBwBXAQcAzAeHAOoHhgDEBAQAVQGHAOABBgr+AAkKbQCKCmcAhgB4AwgLEAKJC1wBBwDLBwgAKwELAHoDDACiAgQLFACFC2gChwtGBIYKXgYEAO4ABQD3AQYAswAHANMHCAB9AQgA2QEJAJUACgAUAw8ALQAPAFYAFABuAJYAOQCFCp8CBAsaAAULrQEGC/UABwvAAgcLYwWHC8IFBAB5AAUAnAAFAF0BCQCvAQoAXQKOAFYBBwuvA4sLZgKECnkDhAttAgcKZgUHC2YFhwp2B4QKcwKFCgcDhQseAoULZAOIC7EBBgBdBQcA8wMLCmoBCwq0A4wKhAEGAFAABwCtAAkAIwIKANoCDgASABYAJwCHC9cFBgCeBocAtgeMAMQABACbAwYA+wEGAK8GBwrDAQgKhQEMCuoBDQoQAA0K1wANCl8BEgqEAJMKfQAGAIYChgAXBIcKSQOICjYCBgBLBocAvgSLAJ4DhAsNAoQAUwIFAPAABgDLAQcADAAHAHIABwC1AwcA2QYHAA0HCACSAgkAAQALAL8DjQC+AQUKkAOGCp8GhAC+AQcLPgAMCy0AkwtwAAUK7AAGCjwCCArsAQsKagKQCjgABQq+AIgKPgGHCmAFBAvfAAYLZwELCwMADQtsAA4LWQCQCxYAhAuHAoYA6gGGAOsBhgAwBocLrQKKC9wABwD6AIgA+wGEAJ4ABACMAAcAagEIANEACQAKAAkAoAAJAPcBCQBmAgoAsQILAEcBCwApAgsA1QILAP8CDAD8AAwARwINAMAADgANAQ4AZAGUADIAEwABABMAGgCWAAkAhAttAAYA5AAHAD0FCQCYAYoAVwEEAHUBBQAbAQYA4AEHAGECCgBcA4oAbgMGAAsDhgC5BAQALQIHCwcBBwt0AogLXQGEACQCBwDFAAgAjgAIAEUBCQCWAAkAVAIKAF4BCgBhAQsASgALADsBDACWAgwAqQIOAKcBjwCNAAQLKAAKC0MACwt1AAsLAAOLC6cDBwvgAwgLLQEJC9ICDAs/AA0LHQAOC6EAjwsSAAYA0gWKCxQCBQBEAgcAegEHAKICBwCQBQ8AUwAQAAsADwtTAJALCwAGACEEBgA3BQoAPAEHClUABwr3AAgKSQKKCqMABACpAAUAUwAGAI8BBgBDAgYA6QUHALQCBwBOAwcA9wMHAAcHCACTAQkAigEKAIUADAAEAAwAKQEMAMQBEABRABIAGQAVAA4AFgAMAJcAEgCGAFIEBwAKBgsAKwGOAJcBhgCoBIQAsQAFAJsBhwCNAgcAtwEKANcCCwAEAYsArAKKCpEAkwpTAAUA0AAHAPEChwD4BYkLaQKHCoIHhws5AwsApgENAIUBBAp8AAoKyQELCnkACwqpAAsKZgMMCtYADgq7AI8KTQALAGcCDwA6AAsLZwKPCzoACQBqAooA4gEGAKAHBgCyB44A+QEHCqkEhwsuB4UA8gCHCjUFBgprAAcKfgIHCmAGiQqMAYUAuQMFCnIBhgrcBgULHAAGC8wACgtAAQoLRwINC/YBDgtIAA4LEgEOCzgBDgtYAQ8LnwAQCz4AEAtFABELHgASCyoAEgs1ABILVAASC4wAEwtEABMLVQAUCwUAFAstABQLZQAWCwcAlgsUAAQLLgIGC4YBBwuiAAcLsQIJC2gBiguNAgsAIgONAEMAhQrMAIUAIgEFCsoDhgqqBoQAfAEFADQABwAVAQkAcAGLABcDBQtYAwYLiAYGC90GBgv1BgcLfgQHC5EFBwutBYwLAQIFC1wABwoDAAoL4AKMC2YABABwAAUAjQIFCuMBBQqtAgYK6QEHCrQEiAqKAYQKmQMGAAQEhQrvAwULTgIJC9UAkQtbAIcKoAYKAIoAiwDcAQUA1QIFANcChwATBwQA0wMGAB0HBgAuBwgAbAMIAHMDCAB5AwgAfQMIAH8DCgCmAwwA0AIOAMsBlAB7AIcLJwIEACYABgCzAQcAMwEHAOcDBwDJBQcAxAYHAMoGCABzAQkAngELADwBDAA0AA0ApAGTAGQAhwAQBYQKyAKGCl0GhQDTAoYAiwKIC78ACQsXAwoLXQALCy0BEAsNABELFwASC4cAEwsMABQLAQAUCwwAlAsOAIgL9wEGC9IBhwufAgYAsASGADIFhwDnBIYA2gMFAG0ABgD4BgcAZwcMACgBjAAuAYcL1wOFCuUBhgCUAoYAIAMFANgABQAmAQYATwIHAFcHCQCNAAkADgEJAKcCCgCfAAsAxQALALYBDAAaAgwALwIOAJAADgCnAA8AQwAECh0BBQo9AQYKLQEHCgcACAqZAAoK/gILCtQBDArTAY0KjwCIALEDhgBCBIkAUQAMC9QBEwtgAJQLGACGAIcBigvxAAcAQgGIAPkAhgCEBYcLGwMFAHgCigAOAogKMwMGAJAABwC0AwcAEgQIAOsACADNAQkAxQEJABwDCgBiAREATQCHC7oDiwqVAwYArAOGAMwEBABqAQcANACHAC8BBgslAggLIgAICxsBCQulAIoL2wEHC3IBBwvvAwcLmQSHCx0GBQuMAgULvQKHC8EBBQDEAAYA5gEHANQACAA1AYgAWgEGCrcGBgrHBgcK4AcHCuQHCApFA4kKVAMGC58ABgtsAQcLBAIHC58FiQsGAocAeAeHAAoFhACuAo0LlwCKAHECiADCAooKOAKLAJwBBAAeAIUAKwAICkMAigqjAQcAxwONAAsADAD2Ag4AuQGOAM4BCgqRAg4KKQGOCmkBiwrZAgQA3ACHAP8FBwv1AQkLbwAKC40ACwtMAQ0LKwANC60BDguCAA4LnwGRC2YABAC2AwYAQwcHAAsACABpAwwAxgIMAM4CDADsAgwA/QKUAHwABQuVAAULpwOIC+kAjgsjAYYAKwYHAHoDCAozAAkKZAMKCkEDDArhAQwKOgKUCmoAjQACAIQKvQGICyEDhwDuBgcAvQaKAIkBBQAHAYYAngGEC0IBhQrvAAcAyAEHCsYHCAqCAIsK0AKJADIDBQp7AAYKEgIHClwBhwqLBYcK6AcGALIABgDWBggA+wAJALICCgCbAAoAxAAKAHUBCwC6Ag0AmwCUAF0ABQBhAIkAiQGGAKICCwDfAIwAqACECtIAiwvQAQYAZwaSAJ8AiwsCAAcApgMIAIcCEQBhABMAOwCWAAIAhAC/AAUApQAJAFoBCgCPAgsAdQMECq4BhwtlAYUAbQMFCtUAhQuWAQgAgACLALMABgtFAIcLdQCHABEFCwsrAA0LSACNC44AhwsmB44ApAAFADkABgBlAAYASgIGAH8GBwCEAAcAggQHAIcFBwDjBQwA7QEPAGkAlwAPAAUAywEHADEECADxAIgATgGFCzoDhQpsAAUK2wAKC4QACwu/AAsLZgGLC8wBBgBEAQYACAIHAFIBBwDBBggA5ACLAO4CFQAeABYANQAECsEABQqUAwcKbAEKCo4BCgrWAgsKPQELCnICDAqOAAwKIAEMCqYCDQo5AQ8KcQCSCnIABgtuAIcLkQaHAI4DBgrxAAcKiwMICkADCQpWAQoK2QILChwBCwq9AQsKiwILCl8DDQqOAZIKYwAHAMECCQDeAgUL6AMHC90CiQtHAgQASQAGAGQCBwCfAwcAHgcIANkACQD9AgkA/gIKAJgBCwAzAAsAGQMMAAoBDwCeABQAWQCWACAABwAyBQQLKQEGCxECBwuYAAcLyQIHCzUHCAvGAggLzQKMC38CBQCFAYgAfAKGAIEFBAoyAgkK/gCLCm8DhgB9A4QKEgMECwgChws/AogAFQCMANECiAC/AwcLlAUHC2gGCQupAAkLtgAJC28BCQveAQkL+gEJCycCCQuIAgkLiwIJC7kCCQvBAgkL1QIJCxMDCQsaAwoLxgAKC9YACgsLAQoLEwEKC8gBCgsnAgoLMQIKC2UCCgtzAgoLnAIKC6MCCguzAgoLtwIKC8MCCgvLAgsLtwALC8kACwv0AAsLBgELC2ABCwu3AQsL7QELCzwCCwtPAgsLYAILC2MCCwuGAgsLogILC8cCCwvvAgsL+QILCwgDCwsRAwsLUgMLC1UDCwteAwsLYQMLC2QDCwuCAwsLhgMLC4cDCwuOAwsLpAMLC64DCwu9AwsLxwMLC8wDDAuUAAwLwwAMC9wADAvtAAwLPgEMC1MBDAuJAQwLvQEMC8IBDAvaAQwL/QEMCxUCDAtPAgwLUgIMC1UCDAttAgwLeQIMC4ICDQs7AA0LPAANC5EADQvvAA0L+gANCxEBDQtJAQ0LWAENC20BDQt0AQ0LgwENC5MBDQueAQ0LyAENC94BDQvjAQ0L6QEOCzcADgs5AA4LUQAOC1oADguUAA4L7wAOCwoBDgtBAQ4LRgEOC0cBDgtKAQ4LWwEOC2MBDguRAQ4LmwEOC54BDgugAQ4LpAEPCz0ADwtKAA8LVwAPC1gADwteAA8LYAAPC3QADwuVAA8LmgAQCzIAEAs/ABALSQARCwIAEQtCABELXAARC2cAEQtwABILMgASCzYAEgtSABILVgASC1oAEgtvABILcwASC5wAEwsoABMLTwAUC04AlQsWAIkLqgCGAJkFhwsbBYsLmwEFAL0ABwC6AQcAuwEIABkBDACuAI0ABQEGCtgABwqFAwcKPwWICu0BBQuNAQYLmgAHClUBBwukAggLuwEIC2ECCQsYAAkLRQEKCyMACwrbAAsLFwILC6ACCwv6AwwLfQKQCx4ABgACAAcAvwAHAL4BBwDuBAcAyQYIABYACAAOAQgAZAIJAAQACQA4AQkAtAEJAHICCgDYAAoANwEKAAkCCgBvAgsASAALAEoBCwDHAQwAQQEMAPgBDAASAgwAHwINABEADQCcAA0ATgEOAIMAEQA8AJQAQAAHAGIBCgCaAYsALwOLCoIABwrGBokLdwIMAKkBDwBwAAoKcwALCqQBDQqUAQ4KWgGPCjYABgA8AAYApgAHAHYBBwCeAgcALwUIAJsBCACzAQkAjQIJAOQCCgCBAQsA3gALAEQBCwA9A4wAYwIHAEsGDQAOAA8ALAATAA0AlABMAIUL1QMECzgABwv/BggLXwIIC4sCCwvRAQsLQwMMC1EBjQvgAQYAxgUFCvMDiAq9AosAVAIFAM4AhgCOAQQKNgAFCpoCBwoPBAcKagQJCsMAigouAQcAMgAJC54AigubAYcLYAQGAAUCBwCHBAoAbQILAMAAhgqFBgQAUAIGAFgChwB1BgoA3wCLAIUCiAuLAAcAQACIAPUAjgAWAQYLbgKHCwYEiABcAoYA3gWKAAkBjQuoAAcA4waMADYBBwoeA4sLzwIHC6AACgtwAo4LFwGEC2sBBwp6AAkKAwEKClQACwrWAQwKHQKNCnsBBQCBAAYAPQCHALMDhgBMBYcLpwQNAPkBjQD6AQsA6AMFClIABQqDAAcK2wYICh8ACQqoAAkK/AKLCmUDhgDGA4YKXQKGCyQBBQuxAAYLaAIHCzsDCQsNAooLkAKHC84FigsfAAUKFgGJCkQABAqjAAUKyQAFCjMBBQo2AQYKTwEHChwBiAqlAAYARwOHCnwGiAoNAwYKIQCHCtwEhQB9AgQLoQCFC3cCiQBOAgcKoQeICtACBQAYAQcAygSKCssAhgBqBQUAGQEGAAIEBgpGAQcKpQKJCqkBBwsVBocLlAaHACgECQvVAQkLxQIMCwACDgtBAJELDACGAJUDCgvlAAsLSQALC3gBiwuxAQcAKwIJAMAADQAeAA0AMQAPAJYAEABMABQANAAHCiQFBwqEBQcKLwcJCk0CCwrxAAsKpAILCisDCwp7AwwKjAAMCloBDArfAQ0KfQEOCrwAkgoeAJUADwAGAFoHBgBbBwYAaQcJALEDCQD2AwkA/AMMADcDDABKAwwAYgMMAKYDDwDyAJIA0AAGAMUDhgDbBQcAIQAHAHgACADpAQkAPwEKADQDCwDsAwwAewEMAKcCDQB1AA0AnAEOABkADwA0AA8AoQAQAC8AlQACAAYLLgIHC4sCCAulAQkLAACKCyIABACpAwUAIQMHANkBBQpmAQcKoAQKCpYCDQrUAA0KMAENCk0BkQpiAIQAbQMGALUChgA4A4QAbQEHCygHigt2AQUABwCLAAYDBADeAgUAlgKGAK4BBADqAocAQgQFAGgBCADtAAoA5wCTAHwAigtcAQYLBgAHC1EABwsDAwcLwwYJC5UBigulAQYA5AKJADYDhQqyAwcAzQWIAKEDBwqbAQgKdwIJCkMBCgpjAQsK6wEMCo8ADAqSAQ0KSQAOCpgBDwprAJIKRwCHCk4CBQtxA4ULdQOWCxkABABUAwULjgCGCyICBwq7BQgKSAEKCiACCwq7Aw0KQAGRClMACQARAAoAIwELCv8BDQqKAQ4KKgEOCj4BkgpnAAUL0gELCzsCDAvGAA0LGwEOC7oADwsVAI8LZwCGAOkDBAu5AAULAQEFC0cDBQuoAwcLqwAJC48BCgsCAQoLiwEKC94CCwv2AwwLFwANC14BDguWAJMLBgCPACMAhAA/AwUKQwOGCuMBBAAVAQUAYAIGAO0BBwDJAQwAgAEHC5QBBwthBQcLlgUHC+EHCAuVAAgL7wAICwACCAsZAwgLMgMJC9oBCQtTAgoLegAKCzUCCguJAgoLDwMLC+8ACwsnAQsLvwELCxACCwt/AgsLIAMLC6gDDAsZAAwLSQAMC00ADAudAAwLPAEMC4YBDAuHAQwLigEMC4sBDAveAQwL9wEMC1ACDAuoAg0LMgANCzUADQuEAA0LxgANCxMBDQtCAQ0LnwEOC0cADgsBAQ4LiwEPC0cADwuIABELewASC10Akws6AIYARwUHABsAhwA8AYgLyAKIANgDhQAoAokACAGEAJEBBgDGAgYAVwSGAD8FhgC7BAkAHwIKAAwCCwBsAAsAjQIMAAwCDQB7AA4A/AAQABIAEwAmABQAGgAUAEEAFQADAJcACwAEAM0ABQBvAgcAaAAIAAcCiQDMAoQKpQIEC3kBmAsNAIcLiQYHAEMCCQApAAkA9AAJAJ0CCgAFAAsAXQMLALcDiwDUA4QAzQKIAPMDhAAlAwQLtACHC3IHhAoJA4QKSwGEAOkBBgAABAQL6wGFCusChwueBAQLqwCKC+oABAtKAgcLogSKC3cChwB8A4cLUAEJC6MDCgtOAZQLRwCJANkBBgBgAwwAkwKLC54DBwAzAwkAGgAJAIgBCgCYAAoA4gALABMADAAUAQwAqgEMAE0CDQDMAQ8AYQATADAAlABoAIcAMwCFCkYBBAqzApIKEAAJAIIACwD9AgoKqAIKChkDjQplAYUL/QIIAOUABgogAAcKgQEHCvUCBwp8BwgKXgAICscCCQodAgoKogAKChsDCwrdAwsK8gMMCg4Ajgo0AQcL2gGJC0IChACiAoQAAgMFAE8ABwADBAcAxQWLADQAhQuoAYYAggYGAJkBBgpdAQYKkgYHCuQECApwAAgLygIJCrMBCQqcAgoKIgEKCj8BCgovAwsKtAALCkUDDArwAA0KmAANCtsAjgqeAAUAFQOGAMMABAD7AAQAsAIHAAEChwAEBYQKRQIJC6QBCgsNAQoLHQEKC0ACCwuNAQ0LrwCRC1oABgp+AAcKPQIICo0BjgosAIQLrQGFAHkDBACgAAUASgEHAJoFiACuAAcLEgAHC7sCBwuuBwgL8AIJCxEBCQucAQkLvwIKC0cACgurAQoL/AGSC2EABgBoA4YAgwOFCp4DhgBmBIYAlgMECzUABQu6AIcL8AIHAAwBiAA5AoYAyAQGAFEFBwrQBIkKEwIICz8CCgshAYsLPwGFCp4ChAujAoUAdgGHCqUHhQDbAgsAvgAPADEACwu+AI8LMQAEAHICBQD6AQUAggIGAKkBCgDKAIsAjQCJALwBBwryAIcKlgcGC9EACAvUAQkL0gALCyQADAscAAwLdgINCxUADQtdAQ4LBwCRCw0ABAtWAYcLmwQFCkIDBwqyBAgKDgAJCuEBiQpwAwQLoAOFC44DBAs+AQQL8AEHC1gDiwuOAogAQwMHAPYFigrRAZcAEQCHAN0BBAplAQYKrAAHCo8AiQqdAQYAXgWKAOIDEgBMAIQKTgIHAB8BCABjAQkAJQGJAOcChgBtBQcLkwMIC/cAkwsAAAQLygAFC34BBgvGAQcLqAMHCwsHCAv2AgkLdwEJC38DCgvnAgoLGAMLC9IDCwv0A44LbQAFAIABCADHAYwAMACEC4YBBQqpAAcKTQGICi0ABQAIAYYAuACKCxcDhQvNAoQKxgAGC70BBwtMAYkLjQOIAOkDBAoYAAUKjAAFCrkABwrcBQsKNQKLCkYDhgtCAgUAeQIGABwAhwArBYQAUwOICwsBBwBnAQgA8wCMAK8ABApOAYUKUQKNC1cAiAv+AgoAHwEMAIoACgsfAYwLigAEAGkAhADkAowKdACGAFkDhwsxBwYAegWJADMDhAtIAoQKxQKFCoEDBQDgAA0ArgCSADQAhwowBwQKYAKFCvEBiws8AAQA9gKHAHEGBAviAAQLRgGHC+oGBQuqAQgLHgAJCwIACwslApMLegCHCvcHBgocAogKiAAEAD0CCACPAgQKgQOFChIDBwBfAYsAgACFCucDBAorAYcK7AOFAJYDhAtZAQQLgQEHCwkBhwtLAoUKyAGICrQABgCvAoYAAQYEC1sBBQunAQUL5AOHCzEFhArzAgcL6wQJC30ACwtBAIwLHQEFC4gABguIAIgLhAKGAPUFBADxA4cAcwSLClIBhABUAYcKuAUIAE8DCgBdAwoAbAMKAHkDCgCaAwoAoQMKAKUDDAAQA4wAFwOLALAACQuGAAoLAgAKCxsACgtNAQsL0gKPCwEABAuxAYULzwIFANkDBwD9AQcAEQKRAGAAhABnAgQKegMFCiUDBQozAwUKwQMGCowBBgpfBgYKjgYHCq8HBwr5BwkKdgILCggACwr7AwwKsAANCuEADgokAZUKGACHAH8HhgBrBJALFQCQCzMAhwoXBwQA9wAHCuEFCgq+AAoKegILChgDDApmAYwKvwEFCgAABgoYAgcKXAINCr0BkQp+AAQAuAAFAIYBBgBRAQcAFwAHAO4BBwBqAgcAsAUIABsACABXAgoAmQCLAMYCBgroAAYKnAEHCjIECAoJAAgKnQAIChIDCQrEAAkKYAEJCskBCgpRAQsK6AALCm0DDArgAYwKIgINACYAhwq+AwQKfgGICkMCBArUAIcKtgQECysCCAsYAooLIAELC4sAiwurAAkLcgGKC1oAhAD3A4YAQAQFCo8ChwvRA4YAMQYRCkMAkwpKAAoA4wALAPEBCwDFAowAnwEGAGgBBwCABogA3gEHAF8ABgrnAIgKpwGMC0EABAsBAYcL7weHC+gGhQosAYsL0wCIALsCBgrtAAcKYwIICmQACQqgAQsKTwEMCq0AkgplAA4AGgCSAJYABgBFAocAXwSHCrgEhADjAgYLUwAGC8UGhwttBYkAZQMEAEMABQCmAQcADQQHAAkFBwATBgkA5QKRAGwAhQrHAAwKqwGSCiYAiADQAY4AKgAKAGAACAv1AYkLuAKGC1ACBAAAAgQAxgMFAFYBBgA/BwgAZQMIAGsDCACFA5AAGgAIAMsACwA3AwsATgMMAOIBDQAVAQ0ALgENANABDgDNAI4A3QAEAMEBhQDOAgcLtgYJC18ACQsSAQoLFwEKCz0BCgukAQsLLwELCygDDAuGAAwLbwENC5UADQtbAQ4LXQEOC5YBEgsWABILWQASC3oAkwsvAIULGgAEAGMBBgA3AQkAAAGKAJQBhAsmAgoA9gIGCjgBBgqzBgoKSAILCiICCwq0AgwKAwEMCicBDQouAI0KmgCICzYDBQA7AwQLhgMFCykDBgt6AIcLgAMFAEAAjABFAgQAugEGAOMCBwAXBAcASAUHAGsGBwt3BwkLwQEKC8AAigvkAocLBgGECkwChQtsAgUA0QMGACABBwAQAgQLIgAFCz4CBwsXAQcLWAaIC1kCBgBfBQQK5wAFCj0ABgpoAAcK2QIHCsQDBwp6BowKngEGCgcBigr1AoQKQAEEAP4ABwAdBQULTAGHCx0FBgsFAQgLtgCLC68DhArhAAYADACHAMMEBAATAQwAeAEGC7kGjQvqAQQLpQOFC3ADBgC3AwYAVQQGAJ0EBwCaAAQKlQEHCjEDDgo6ABEKJQCSCnwABgDwBYUKzgOGANkGBgBxAQYA9gEHAAwECABcAQkAxAEKABoACwDgAAsAgwELAAQDDABfAAwAdQINAMMADQDPAA0A8QAOAAQBDgAOAY8AjACEAA0BBQDgAQcAFAIHAK0EBwBOBQgAIwELAF0BjgCMAQUK6wAHCtcECwqDAIwKcgEHCrwDBwqFBAcK4gUHCkYGBwpPBgcKUwYHCsgGBwrvBggKTgIJCkQBCQrgAgkKBgMJCggDCQoQAwoKNwIKCsQCCwoGAgsKZQILCrcCCwrMAgsK4wILCgIDCwoDAwsKUAMLClkDCwqjAwsKswMMCkYBDAqDAQwK5AEMChACDAooAgwKZQINCr0ADQoAAQ0KVAENCrABDQq0AQ0KuAENCsYBDgquAA4K3AAOChwBDgqGAZEKeQAIC1YCCQuYAooLuQEJCokAigrdAIULLAOUAA8AhgA9BQYA+QMEC4kABwuaBIcL8AUHCoYBigqMAAcL7ASHC/4GiQu/AIcKeAQGABIHBwCRAggAdgMKAFkDDgC4AZAAYAAIABUCBgt9BgcLtwcHC9kHhwvbBwYArQWGCtABhAvLAgUKlwELCswACwrzAAsK6QEMCiUBEwolABQKSQCWCiYAhQu/AgQA0wAHAMsFBQpFAQgKBQAICuMACQppAAoKSQKMCmYCBABMAQUATwEGAO4ABwANAQcAKwMHAAUHCABEAwkA+wGNAPIABQtZAAcLewcJC7kACQvrAAkL8AEKC0AACgsOAQoLkwEKC9UBCgsRAgoLTgILC4wACwtcAw0LAQANC6YBDgtVAQ4LbAERC10AEgtxABMLYQCTC3EAhQu3AhAAEwAFCwYABgu3AAYKbQIHC6gCBwvSAwcL9QMHCx8EDAvmAA0LrAANCvgBkgsdAIgAnACFAPEDBgsdAIsLPwCGADQDhgraAAcKxgEHCg4DCAoAA4wKrgIFAOQABgDLAAcAnAAIAFsBCQAJARIAJwAUADYAFQAfABYAAwAXAAAADwsIABILJwAUCzYAFQsfABYLAwCXCwAABwBrBIcAvAWQCgAAhgD8BAoKpAKMCs4BhAs3AYYLzAYHC6oACAtaAAgLsQAIC58BCwvKAo4LGQGGCqQABgAAB4oAUQOWCjIABQAjAQUAPgEHAP0CCQCFAQwAJAIICwoCjgtIAQsLWwANC4EADwtlAJELfQAEC+4BBgtKAAcLLAAHC5cBCAsnAgwLEQAPCwUAlAsLAAQLFAGFCygBBgpXAQcKwwAHC/EGCQriAAoKxQAKCj8CCwr2AYsKgwMKAA0CiwBSAA4AxQEECwcABQtaAAULngAGCx4CBwvdAAcLJgYJC+oBCgscAgsLuwGLC/UChwCaAhYKHQCWCx0ABACmAZMKCAAFAGMBkQAAAAYAUQcJAJYDBwtMAgkLrwCKCxICjwsfAAsApQAHCmUECQqPAA4KlQGWChUACQAEAYkAiQMFC2gDBgs5AAYL3wEGCzICBwvXAQcLJAQJC78BCQvGAY0LBgCKC8AChQBhAwUAkgOGAFkGhQDqAAcAZwUFCx8ABgtmApELPQAHC7AEigvMAQYLqAGHC0oHiAAyAQUKvwMMCx4ADQuUAA4LVwAOC7YAEAsqABILXACUC0YABgB/BwYAgQcJAJsDCQCiAwkArQMJALUDCQDbAwkA3AMJAOADDAAiAwwALwMMAFgDDAB1AwwAfQMMAIIDDACXAwwAmAMMAK0DDACzAw8AtwAPALkADwC9AA8AxQAPAMoADwDpABIA2gASANsAEgDpAI8LnACHCt8GiAqtAA0AowANALQAEgBOABQAIwAFCw0AhguOAIYKCgEGC2EABwt0AAgLQgEIC/MCCQskAgoLygILC3QDjQtEAYcAIAUJAC4DiQukAoUAwwKHANUFBgClAQcAPQAHAAQGCgALAIoA9QEMAN0CDAD+AgcLYgOHC4sEiQBVAY4AYgCRC3MAhwtXBIgKLAGIAPYDCAsBAAkLcACKC0YBhAvaAgUL6AEGCw8CBwvpAQcLZAYIC3kACAuQAAgLZwEJC8EACQvxAAkLUAEJC3IDCwsKAQsLdAELC7ADDAuRAYwLgQIGAMsDhgBhBAYAZgAHAEgADwCOAJMAQwCXAB4AhwA3A4YAFQQFCqsBBQreAgcK3gGICjQABwCKBwsK2QCOCqUABgDoBYcATgcJCx8ACgv0AAoLuwIMC5UAjQvxAYULeQGRC2UACgueAA0LDQANC4kADQsCAQ4LbwAOC+EADgv9AA4LMAEOC1MBDguhAZILIQAGAFcABgrGBgcKFAAHCiAECArcAgkKlgEJCo8Digq2AoYA2wSJAPUABwBEAAgAMAAIAFgACABGAggAqQIJAHUBCQBgAwsAnQALAFABCwBLA5QAGwAIC5cCkAsIAIUKZQIEAFgABQCJAAUArgAFAAkDBgCABgYAvQYHAE0ABwCqAQcAJQUHAEsFCAB+AAgAMwIJAAsCCQDuAgoANgEKAEQDCwAqAAsAPgELANsCDABEAAwAXAAMAPsBDAC0Ag0AUQANAO4ADQB2AQ4AtAESAIoAEwBOABMAbwAUADcAFABNAJQAXACNAKIBBACqA4kAcQKKAF8BBQtLAwcKIAAHCtgDCApVAAgKxQIJCkMCCQpPAwkKWAMKCh8DCwoCAQsK7wMMCksBDApnAg0KvAANCrMBDgoIAA8KpQAQChsAlAooAAYAhAYHANsFCAB1AAkAOgGKAK4AhwDDAoQLKgKFCxgCBQCTAQULzwAJC08ACwtxApELBwCEC6gBiAsRAwQKpwCHClIACQAHABcABgAJCwcAlwsGAAYAGgEFCj4ABgoWAgcKSgAHCqYCBwqsAgcKEwQHCjAECAoYAQgKHQIICq4CCQoCAQoKBwILCvwAjAoaAYoKIQCECmcBBAAsAAUANwEGAJwABwB/AgcA+gIHACMHCQAIAAkAzgGUAFMABwsBAwkLEgCKC2YBBABaAQcAcwAJALQACQDIAQoAawEEC4ADhgvxBoUK0wAHAPkCBwAbBIkAIQIGCpEAjQpQAQcL7gIJC98ACwsbAAsL0gEMC3ACDgsJAZILPQAGAPACBgAAAwYAqwQGAOYEBgBTBokAQwMGAJAHCACiA4gAwAOECgcBhAv5AAwAjQKECpQDBAtbAoULlQIIAFgBBAsLAAYLgAAHC+cABwv9BYoL1QKGAMsFhgBrAwYAuQAHAGsHCQBrA4sAoQIPCpsAkApPAAcAXQAHANIABwDHBAgAwwEIAMwBCwBhAQsA2wEEClcCBgpiBgcKQwAHCrMCBwrTAwcKoQYICs8ACArWAAgK5wAICiYBCApQAQgKrAEICtcBCApuAggKcgIICqcCCAr3AggKPQMJCgsACQr2AAkK5AEJCj0CCQrCAgkK+gIJCh4DCQpXAwkKZgMJCpADCgovAQoKTwEKCqgBCgrNAQoKHwIKCvcCCgouAwsKOwALCusACwpOAgsKoQMLCsMDCwrbAwwKcgAMCrYADAriAAwKTAEMCrcBDAo/AgwKVgIMCqMCDQoIAA0KfQANCsIADQofAQ4KxQAOCn8BDwo1ABEKPwATCi4AEwpiABMKagCUClUAhAvcAQQARwEFAN4BBwA0BYgA8QIFAPwDhQD+A4cLDwcEAGcAhQCRAQQA8wGHAI0FCgDPAA0ApACTCn4ACQsUAAoLRAGLC+gBhABgAAkLGAGKC4YAhwDIA4UKuwCHCgYFBQtwAAYLZwCGC5YACACSAwoAAwAECtcACQomAAsKFwALCn8AiwocA4cAjwEGADMCiQDgAAYAwAKGAL4EBAvEAggLDwAJCzIACQuCAQsLEgALCxECjAvkAAQLMwIHC20ABwtQAgcLfQIHCwIDBwulBggLtAEIC88BCQs8AAkLTwEJC4gDCgtJAAsLsgEMC0kCDQtLARILbgCUCzwAhgAXBoQL9gEGC1sBiguhAAQLIQAFC2YABQv0AQYLHAEHCzcEBwuPBQcLpgYIC9YBCQsqAgkL0wKLC00BBwv2AIcLSAMGCwoACAs7AgkL4wKPC1sACABdAwoAiQMMANoCDAAVA4ULcgKGALIDBQDqAgwATQEOAEwBDAtNAY4LTAEFCxIABgsOAg0LGAANC24AEwsFAJMLLAAEAI4DBQBAA4cK0gcKCwADiwsTAwQLNQEFC84BBwvKA4cLSQQEChwABQq4AQcK+AALCkEDjApYAYYKdgYGAHgCBgCMAgYA+AQGAGgFhgAYBoYLqAYGAHEFhQpVAwYK+QAHCtIEiwo9AgULVgAHC+cCCQtVAAoLGQEKC7ABCwvqAQwL+wANC3YADgt6AZILjwAFCwwChQvoAoYA6gUKAMkAjgA/AQcAzQIKAP4BBwqIAQgKFAAICqwACAqyAgkKfwEJCk0DCwolAQsKQAMLCpgDCwrYA40K3QCGAGUFBQpaA4UK4AMIABACiQBcAQoLawCMC7QBBAAUAIUAaAKGAOMEhAufAwoLewAMC54CDQtzAQ4LjgCSC14AhgCLBAcLfQSJC5wAhgAzAYULCgMHAEMEhwDlBgUL9gEGCgwBiQo+AAgLxAAKCxsBiwuWAQQAGgAFAK0BBgD1AAcAwAIHAGMFhwDCBYULVwOEAHEDBABtAocLPAYHC3gFCQu+AYoLLQAGAOACigpqAIUAHgKGAFwBhQBkA4gAsQGHANcFigADAwYKZQKICt8AigDXAI0AfACIC4cBhwusAIQKngKMADcACQooAIsKiAAHAD4AkwBwAIQAWAOECzgCDAAOAYsKAwEIADwCiQC6AgQL3AIJCjYBiQqqAo4KKAGGAKsDiAvdAocLmwUHCnkFhwrEBQYAYAEECigBBwqRAQcKggUHCjoGBwqKBggKPwAICpQCiQpKAAQLrAGFC5wCBAqLAAQKhAGMCrwABwvfB4wLmQKEAIcCkgAKAIoA3ACOANABhABtAIYA0gYGAAMCBArrAgYLVwYGC5EGBwqJAgcKxwWHCi8GhQroAIcANgKJCncDBAAoAAoAQwALAHUACwAAA4sApwOEACEDBwDgAwgALQEJANICDAA/AA0AHQAOAKEAjwASAIsAmwMGC9QGCAvLAgkLIgMKCy4ACgszAw0LNAEOC18BDgtrAZILQwCJC+kCBwB5BAQKDgAHCgkHCgrsAo0KygEECz8ABQtbAYYL2gGHADgCBAqpAQcLQQIHC5gFCQvbAQkL+QEJCw4CCQthAgkLsQIJC9YCCQvfAgkL4gIKCywCCguiAgoLrAILC1kACwvKAAsLEAELC3wBCwufAQsL+QELCxkCCwsmAgsLMgILC4ACCwubAgsLsAILC08DCwufAwsLogMLC6wDDAuQAAwLRQEMC0kBDAuFAQwLkwEMC8MBDAsDAgwLXAIMC2gCDAtyAg0LQgANC4MADQunAA0L7AANC3ABDQubAQ0LsgENC8UBDQvNAQ0L2gEOCzsADgs8AA4LiwAOC5gADgsUAQ4LYQEOC5IBDwscAA8LUQAPC3sADwuYABILiACUC1gAiQD3AIcLVgYJCyACCwudAZALGQAEAIUCBwA5AwYK6AaHC1kAjABIAQUKrwOGCvMGhgBTBQUK9QAGCkACBwpGAogK4QCGAAAFBQs4A4ULrQMHC7gBCAvmAIsLagAFABwABgDMAAoAQAEKAEcCDQD2AQ4ASAAOABIBDgA4AQ4AWAEPAJ8AEAA+ABAARQARAB4AEgAqABIANQASAFQAEgCMABMARAATAFUAFAAFABQALQAUAGUAFgAHAJYAFAAEAC4CBgCGAQcAogAHALECCQBoAYoAjQKGAPwCBgBeA4kAQQMFAFgDBgCIBgYA3QaGAPUGBQBcAAoA4AKMAGYABgCHBwYAmAcIAJwDCAC0AwoAxwOKANIDhgDHBQUATgIIAGgBCQDVAIoAPwCGAPEFBgDFAoYAewOECrsBDQDdAQ4AeACUAD0ABAuSAwULIAOFC1QDCgs2AI0LcwAEC5YDhQtsA4sLmAAEC1wAhQsSAYcLbQcJCyADCgu1AgsL4gELC94CiwsVAwkA4wGECioBBgC9BI0L8gGHC6sFhQvnAgQA/gMKAOgDDAC9AwwA1AMMAPUDDgDhAZAAdAAIAPcBEQAdAAQLMQAHCxgBhwthBocAsAaGANIBiAsvAAUKpAAHCnkAjgq9AAcKLAMHCu0EBwpQBQkKeAKMCmABiwosAoQA2wIFCxABBQuMAwULrgMHC/ADBwsYBggLxQAJCy8ACwsaAosL5gIECqwACQpjAgoKtAEMCqECjQr/AIUKTAMKAOQBCwDyAgwAyQEOAKsADgCFAZIAmQAJCgcBCgqTAIoK7AGJC3sDigDxAIUKGQIGANUHiADEA4kKSgOXCwgABAuXAYQLMAKHC1wHBgBMBIYA2gSHALoDBQrmAAUKiAEGCqQBCQo4AowKZAIEC9sBCwsjAAsLWgANCwcADQtHAA0LsQCOC6YBiAtMAYcApgcGACUCCAAiAAgAGwEJAKUAigDbAQoAuAMMAMYDjADiAwUAjAIFAL0ChwDBAQQAjwIHAFIDEQBLAJIAiQAEAJIABwBSBggAngIFCikABwqzBQcKvQUHCkMHCQolAosKiQOFCrgCBgCfAAYAbAEHAAQCiQAGAocAnwUGC94ABwt8AgcLVAYIC5kBCQu1AosLTQANAJcAjQstAAYAAwQEC1ABhAoDA4sLiAEKC3kACwuvAJULEAAIALYDigDXA4UKmQOHAOEDBgq0AAcKcQQICu8CiwolAwcA9QEJAG8ACgCNAAsATAENACsADQCtAQ4AggAOAJ8BkQBmAAQKtwAFC3IDBwoPAQsKOAMLCrgDDQoWAQ0KUwENCuIBDgqoAZQKYwAEChMABQrdAQUKVAIGCvkBBwrFBAsKiwMMCtEAjQrWAIcKvwSFAMQBhAuqAQUAlQCIAOkAhQCnAwYLOgAHC44CBwvpAgcLsQcIC/AACAujAgkL3wEJC9sCCgtKAQoLUQIKCzEDCwsgAAsLhQALC90AkQtEAAwARgISAIMABwtmAIkLGgKIACEDhgptBoQARgAGClwABgq8AAcK9QQHCvQFBwpUBwoK5ACLCvwDBArLAYUKxgOKAHEBEAAkAIwKSgGNC24BBwDRAgoA7AAMAMwABgoSAAcKpAMICvUCCQo2AAkKQQAJCkwDCgpxAAoKOwEKCh4DCwqZAAwKlwAMCogBDAqaAo4K+AAHAPEACgCuAQgKJAIJChQCCgp1AAsKXwELCncBjwoXAIYKzgaFCsUDhQs2AgYLMACHCz8Ahgq2AAoKQQAKCugBigrxAQYLcgAHC8gEBwsUBogLAwCGABkHCAtAAokLCwEGADYEkAAQAAkKTAKKCgQBigD9AwUAlgGGAOYHhQulAwYARQCHAHUABwAmB4gLqwEEALABhwA4A4YK+gaFADoDiwtDAIUL9wKHCjQBiQAwA4UA6AMEACkBBgARAgcAmAAHAMkCBwA1BwgAxgIIAM0CDAB/AowArQIHAKcBiApMAogKHwGIAP4BhgAYBAYAagIHCzgABwvFBwgLUQEIC+ICCQtYAgoL4wEMCyUADQu/AY4LXAAEAAgChwA/AggA3gOKANEDhwsGAwkLWwELCxgAjAuqAIgLewGMCiIBhAtIAQQAQQGGADkCBAtlAIcLkwQHANMCBwBvBAULQQOIC+gCBwrPAggKKQOICkIDCACZA4gKHAMFCtIABgrVAAcKPAAKCmwBiwqHAAUAjQEGAJoABwCkAggAuwEIAGECCQAYAAkARQEKACMACwAXAgsAoAILAPoDDAB9AhAAHgAFCl8CCApGAYgK6gEECr0CBQrYAQYLCQAGC40BBws1AAcLzgYJCvYCCgt4AgsLPAOMC5IAhwp8AYcKmweUC20ACgoWAYoLFgGGAFgDBwCLAAQKggEICpUBCArYAgkK8QELCm4ACwpoAQ8KJQCQClQAjQAaAYUA1QMFACABBwqsBQcKyAUICnoCjArYAQcAYgcIC28BCgv4Ag4LTwAUCxEAmAsAAAQKDAKICioDBAA4AAcA/wYIAF8CCACLAgsA0QELAEMDDABRAY0A4AEKCu4AjQohAAsLoQEMC98AjAsJAQkAngAKAJsBjAAFAYUKFAKFCuUDDAu6AAwLJAEOC2QAkgtGAAYAewWIAGkChgC1BIsAMwIEAPIAhgBNAQQLugAFC50ACAuoAIoLBgCEAHEBhQtrAwUKDgMFCj0DhgrKBoYAbgKHC/gEBgB/BQcLbwCIC0UCBwofB4sKtQIHAKAACgBwAo4AFwGEAGsBCgtNAgwLbwANCwQBDgtSABILPwCTCy0ABwtUBQcLcweNC54ABAuUAQQLkwKHC6MCDQvTAA4LhQAOC8wADwtAAA8LRQAPC3IAEAsKABMLFwATCyMAEwsnABMLMwATC0cAEwtLAJgLDwAECk4ABQpgAAUKtgAHCrwGBwohBwoKigEKCtcBCwoUAg4KVAGRClgAhwqsB4ULhwELC3cDDgttAY4LdwEFCxwCBguhBgcL3gCIC1UBhgtOAAkAWQIJAGsCCgD5AQoA3AILAGMBjACLAIYAJAGLAK4ABQCxAAYAaAIHADsDCQANAooAkAIKAB8ABgrXAAcKBAQHCsEFBwq5BgkKqAGKCgsDhwpIAogLJQGGAK0ChwtMB4ULzAEHAIcCBgpDAAcKXgYJCmIBCQqjAgoKPgMOClAAkQpQAAQAoQCFAHcCBgqNAAcK4QAJCjsACQpfAgoKOAELCq8CDAorAg0KdQENCu4BlAo6AAcLxQMHC7QFhwtEBogKDwOGC4QBBgDSAgYA8wQEC/8BCQtNAQkLewEKC1oCCwu5AQsL0wILC9ADjAtlAYYABQeHAJQGCQDVAQkAxQIMAAACDgBBABEADAAFC6oDiAvDAgcAzgSIABMCCgDlAAsASQALAHgBiwCxAQwADAEMAIACjgB3AAcKrgGLCi4ABgAuAgcAiwIIAKUBCQAAAAoAIgCLAPADBgBqAAcA+gYHAB0HCQBmAAkA+wIFCloCBwriB4kKogEFAEEABgCgAQcAuAYHAIQHCgBtAAsADgALAEYACwA5AgsA3wIPAJkAFABQAIgKpQKHC1kGiQsEA4gAUwIGC9UBBwutBooLAwIHACgHigB2AQkAagAJAKMACQAoAQoApwAKAKwACgAJA4sAEAAGAAYABwBRAAcAAwMHAMMGCQCVAYoApQEEC/QBhwuqAwULRACGC38BBQBxA4UAdQMGAFYDBgBsBAYA1wUGAPYFBgD9BYYAKQYEC1EBBgthAQcLjgcIC+gBiQutAQcL7AAHCwMHCAsDAQkLhwAJC7EACgs5AwsLcwALC3IBCwuVAQsLXAIMCwoADAubAgwLnQINC0wADgs2AQ8LTAAPC5MAlAsXAAUAjgCGACICBAsPAAULFgAGC/QABwsoAAcLyAAHC4oDBwuvBAkLaAIKC8wCCwt7AgsLIQOMC8oBBQDSAQsAOwIMAMYADQAbAQ4AugAPABUADwBnAIcKSQEEALkABQABAQUARwMFAKgDCQCPAQoAAgEKAIsBCgDeAgsA9gMMABcADQBeAQ4AlgATAAYAhwvHBgwLJACNC1EBBQtWAgcLFwMIC2wAiQt7AIQK1QEHAJQBBwBhBQcAlgUHAOEHCACVAAgA7wAIAAACCAAZAwgAMgMJANoBCQBTAgoAegAKADUCCgCJAgoADwMLAO8ACwAnAQsAvwELABACCwB/AgsAIAMMABkADABNAAwAnQAMAAABDAA8AQwAhgEMAIcBDACLAQwA3gEMAPcBDABQAgwAqAINADIADQA1AA0AhAANAMYADQBCAQ0AnwENAP8BDgBHAA4AiwEPAEcADwCIABEAewASAF0AkwA6AIgAyAKGCs8GBQqhAwYKVAEICngBiAonAwYAOAcIAFwDCgBYAwoAWwMKAJ0DCgCtA4wA+gIGAHUCBgCKAwkAKgOMAIwCBQraAAcKSgaKClMABwroBYcKAgcEAHkBGAANAAQLmwAHC5kGCwoAAJAKTgAEC6QABQuXAAUL2gIFC+UCBwvyAQcLZgMHCwYGDAvVAA4LJAAOC4cBEQtvABILBgASCy4AEguXABMLJAAUCyAAFAs4ABQLRQAUC2YAFQsEABYLCAAWCwoAFgsOAJYLHwAHADIHhQo7AgQKxwEEC3AChwvYBoYA3QUEC+wBBQvDAQYKoQAHCnQBiQpVAoQKXQEEALQAhwByB4cLQwONC0YAhADrAYkK7wIGCrABiwpCAQQAqwCKAOoABgtxAIcLtAEEAEoCBwCiBIoAdwIFCtQBCgpFAQsKWAMMClkBjwpoAAUK3wAKC1ACCgvxAgwLPQEMC2MBDAvRAQwL1QEMCzACDAtCAo0L8wCECjYChwsIAgQKOwCHCnIFBgq0AYsK4QEJAKMDCgBOARQARwAECjAABQoPAQcKuQOHC1YHCwCqAAUKYgKICskBhQrzAgYAMwaHCsEEBArFAJULGgCFC0kCiQsJAoUA/QKFCtkAiwtKAoUAqAEJC/ACDAtiAg0LrwEQCzsAkgttAIgAygIHAK0ChAszAQkApAEKAA0BCgAdAQoAQAILAI0BDQCvAJEAWgCEAK0BhQvEAwkLzwGKC1MCBwASAAcAuwIHAK4HCADwAgkAEQEJAJwBCQC/AgoARwAKAKsBigD8AQQKpQAHCnYFhwolBwQANQAFALoABwDwAgcAPAOOAHQACAA/AgoAIQGLAD8BhACjAoYAkAUEC0sABQu0AAYL9AEHCzoABwvGAooLhQKFC4kCBgsUAQcLGgEHC28DBwucAwgLywEJC1cCCQvyAgsLPgIMC4AADAvuAQ0LNAANCy0BDwseAI8LhAAGAIcChgBHBAUKCQAHCikBBwrGA4wKMgGEC8gAhgA2BQUKkgAGCpsBigrRAgYA0QAGAHUEBgAIBQgA1AEJANIACwAkAAwAHAAMAHYCDQAVAA0AXQEOAAcAkQANAAYKsQCHCtMBBABWAYcAmwQKC8YBjAtEAQQAoAOFAI4DBwAuBwYL4QCJC9MAEABlABQAcwAUAHYAlAB6AAQA8AGHAFgDBAA+AQsAjgIHC84CiwtmAAgLOgAJC9QCCwspAw0LcQCRC0gABQrIAAYLWQGHC98ECAv/AggLIwMJCy0BiQuHAwcAkwMIAPcAEwAAAAcLnQeIC6ICBADKAAUAfgEGAMYBBwCoAwcACwcIAPYCCQB3AQkAfwMKAOcCCgAYAwsA0gMLAPQDjgBtAAcAfgQHAJEFBwCtBYwAAQKGCwMBigAXAwsANQMMAG4ADACZABIAKQCWABMAhgrhAYQAHAMGAL0BCQCNA4gL/gAKAAgDDQBZAY4AqQEEClQABwrKBQoKTACKCo4AhwvmAgYAQgKFCvcDBgBrBQQKOwEFCvsBhwpaBQQAtgGFACsCiAD+AoUL+ACGCroGBAt0AAULXwAFC70BBwuYBggLHQAJCxABCwv9AYsLkwOHAB0ChQsfAggK3gAICtwBCQruAAsKBAILCj8CDwptAJIKZAAGAHADhgCnBAULtQCICykAhgDiBYQLqQIHCxkACAvKAIoLGAKLANcDiQAAA4QASAIJC6cBjAtZAAgLcQAJC20DCgsqAgsLUwAMC4gAkwttAAcKwgIHCiIEigoaAoUL0AMEC84AhwvqAogLDgKMAOECCwpcAAsKxAALCpkBCwrCAQsKmgILCgkDDAoGAQ0KgQENCokBDwpzABAKLQCRClIABADiAAQARgEHAOoGBAs/AQULuwKKC6ECBgooAIcK9QYFAKoBCAAeAAkAAgALACUCkwB6AAYAiQSGADEFigphAAYKpwEHCpkChwq6BAcLDQAIC+IACgsZAgsLOgILC10CCwsfAwsLJAMMC1UADAsEAgwLbwINC3AADQtpAQ4LTQAOC04AEQscAJMLbgCECwEDhAsnAoQL2AKTAHUACQs5AAkLywEKC6kBCwt3AAwLuAAMC3MBDQtmAZELMwAFC7wABQsuAwgLCgAJC6UBCQvZAgoLYQKLC7EChgtwAocLKgGHAM4BBABZAYsKcAKICj4CBACBAQcACQGHAEsCBgAoA4QLEAKFAI4BhApiAQQAWwEFAKcBBQDkA4cAMQWHChYGBwDrBAkAfQCLAEEABQCIAAYAiACIAIQCBQtoAAYLrQCHC18GhwDVAYUKPgMEABYBBQDRAYcAVwUHCyoDCAuKAAgLVgEJC1QACgvBAAsLcwOMC2cBBQrwAYcKywAEALEBhQDPAgYLXwCGCiMCBQpYAIkK7wAGC5YBCguZAQoLvwELCywAjAtkAIYAjwUHCooChwoeBYYA7QKHC9sEhwBTBQYAfQEHAIUCBwC2AggAIgIHCjQECQpQAAsKTgALCqUBCwoWAowKIQKGC2QGhwtABQwAFQEHChIBCwrfAYsK+wEGAMECBgAPAwYA+wQGAMkFBAsaAQcLCgQLC44BCwt6AgwLAQAMC08ADAsgAg4L7QARCwoAkgsUAIYAxQEEACsCCAAYAgoAIAELAO0DBArxAYcKMAYFC3YABQvzAQYL3AEHC1gCBwt4A4cLSASKANsDBwBTBAcKBQEHClsEBwpKBQcKNAYHCqkGBwpuBwkK0QEKCvgACgpdAQoKhwILCg8CCwqUAgsKnQIMChECjQoxAQcLKAEHC1QCCAswAggLSgIJC2QCCwtkAAsLMAEMCy4ADQtZAA4LcACRC3oACQByAYoAWgCICg0AhABcAwcKggIICvoACwp7AAsKiQANCjAAjgpfAIcKlQWJC0EBhAABAYcA7wcHAOgGBws/BgcLuwYIC08ACAtqAAgLvgAICy4BCAt/AQkLdwAJC+kACQsqAQkLowEJC9cBCgu1AAoLlgELCzkACwtVAAsLeAALC7EACwsoAQsLfgELC8YBCwv2AgsL5wMMCxsADAtiAAwLgwAMC/UADAs4AQwLvgEMC8YBDQsZAA0LYgANC6oBDQv8AQ4LBgAOC6MADgsQAQ4LFQEOC3IBDwtfAA8LigAPC6cAEQsSABELJgAUC2AAlQsgAAUL0gKGC98GkQsQAAYALwSGABkGCgohAowKLQEGAFMABgDFBocAbQUEAEMDhwAaB4ULAgEECogDhQoaA4YA1gcFCx4ABwvvAQgLhgAJCxQDjAu2AYcL1AeJALgCBQsyAAYLtwEHCwwDhwsQBAcLBAMHC1AEBwtvBgsLDQELCxsCCwtfAgsLcwILC8ICCwvPAwwL+AAMCzcBDAuyAQwLWAIMC24CDQspAQ0LbwENC+UBDgtFAA4LmQGPC2wABQsBAAYLUQCKCwgCBwC2BgkAXwAJABIBCgAXAQoAPQEKAKQBCwAvAQsAKAMMAIYADABvAQ0AlQANAFsBDgBdAQ4AlgESABYAEgBZABIAegCTAC8ABQviAQgLYgAJC6wACgveAAoLvAIKCzYDCwsuAQsLCgMMCzIADAt/AAwLjAENCz4ADQtIAQ4LegCTC0gABwqCAYoKyQIGCgcABgojAAcKkwAHCi0EBwogBgcKJwYHCn0HCAorAAgK0AAJCoAACQpiAwoKFAALCtUDkwohAIUAGgCEACYCBQsCAAcL1gWIC00CBgsAAgcLHQMIC/0ACQtNAAoLAQAKC4EACgvhAAsLdgALC+IACwv7AAsLrgELC70CCwvOAwsL1gMMC0AADAsEAQwL6AGMC7ICBwp9A40KqAGGAIUDiAA2AwQAhgMFACkDhgB6AAYAJwOGAFYFBwAGAQUL7AKGCykChQBsAgQAIgAFAD4CBwAXAQcAWAaIAFkCCQCqAAYKQgEJCigCCwoSAQ0K0QANCvMBDgpVAA8KfgCRCkYAhAAZAgQLDAAHC6QBBwsKAgcLKQMICx0DjQtYAIUATAEIClMACArmAggKMQMJChwACQodAAkKdQMKCoMBCwp5AgsK5AINCusADQr+AA8KjwCPCpIABgB1BwkAxAMMADYDDABWAwwAYQMMAI4DDACqAw8AqQAPANAADwDTABIAzQASAM4AEgDcABIA3wCYABgAjAoxAAULEAKHCywGBgAFAQgAtgCLAK8DhgC5BgQApQOFAHADiAtBAQULCgEJCyIBCQtsAQoLJQELC14CjgstAAYASQYECzIABgv+AQYLUgIJC3kACgsxAAoLnAGLC0IDBwB/A4gL7AKEC9IBBApuAAoKnwEKClUCjgrOAIUALAOHCxkBBgBiBwYAbgcGAHwHCQChAwkArgMJAM8DCQDYAwkA2gMJAPMDCQD7AwwAJAMMAFMDDABjAwwAlAMMAJsDDwDCAA8AzAAPANIADwDeAA8A3wAPAOUADwD6ABIAswASALoAEgDAAAcKzQCHCtAHhAubAocACgMEAIkABwCaBIcA8AWGACIFBAvyAIYLTQEGAH0GBwC3BwcA2QeHANsHhgA3BgQKGwGHCqoECwA0A5YAMwAECycABQskAAcLMwcIC5cBCwuQAIwLCwKGCrgGBAv+AQcLHQAHC0IABwu8BwoL5wEKCykDkgsJAAUAWQAHAHsHCQC5AAkA6wAKAEAACgAOAQoAkwEKANUBCgARAgoATgILAIwACwBcAw0AAQANAKYBDgBVAQ4AbAERAF0AEgBxABMAYQCTAHEAhQC3AgYA2wOGAIgEBQAGAAYAtwAHAKgCBwDSAwcA9QMHAB8EDADmAA0ArACSAB0Ahgs6AoQLEwOGCwYCBgAdAIsAPwCECwQCiAs1A4QANwGGAMwGBwCqAAgAWgAIALEACACfAQsAygIOABkBiArfAoYAqQeHC30FBAsKAAcLlQOLCxIDBQqEAAkK5gEJCssCCgrKAQsKdQELCpwCCwobAwsKgQMMChABDAqoAQwKGwIMCi4CDgr1AA4KBwEOCggBDgqJAY4KkwELAFsADQCBAA8AZQCRAH0AhwBsBAQA7gEGAEoABwAsAAcAlwEMABEADwAFAJQACwCFCnsBBQAOAQULrAIGClkABgqQAQcKIQYHClcGBwo6BwgK2gAICqYBCQo6AooKcgIEABQBhQAoAQYA8wWGCxsABgqDAQcKcgONCm8ABgrgAAcKbQOJCocChwoWAwQABwAFAFoABQCeAAYAHgIHAN0ABwAmBgkA6gEKABwCCwC7AYsA9QIHAEwCCQCvAIoAEgKHCooBjgsXAIYAEgOHAEQCBwBYAIgAcwIFAGgDBgA5AAcA1wEJAL8BiQDGAQYLVgEGC/ABCAsTAYkLzgAEC40DhQusAwYA3wKEC3sDCABNAwgAlAOHCoEFBQAfAIYAZgILAMoBDAAPAIwAsAEIAEoBjADdAQQAEgIFAAkCBwCwBAoAzAGEC68CBgCoAYcASgcJADkCDAAMAAwAUQAMAD8BDQBFAA4AAwEQAFcAEQABABEAFQARABgAEgAPABIAOAASADsAEgB/ABIAmgATABMAlAAfAAcAFgWICiYAhgv9AAUKBQEHCk4ABwrHAAgKLwMJCn4AigpWAQUAUwKHAEcHBgspAI0LoAAFAA0AhgCOAAYAYQAHAHQACABCAQgA8wIJACQCCgDKAgsAdAMNAEQBBwsYBYoL3QGECnQChgu2BgcKCgGICiQDhwrQAAcA/QMGCk8AhwrvBQcAwAWHABIGBgtqAZILMwAHAC8EBwAFBgcA5wYHAA4HCwCiAAsA8gALAMQBDABdAg8AGgCQACwAiArlAoULcwCRAHMAhgp4AQYAfgWGAAcGBQvBAAwLsgANC4IAkQtUAIcAVwQIAAEACQCKAgoARgEFC8ECiQteAgUA6AEGAA8CBwDpAQcAZAYIAHkACACQAAgAZwEJAMEACQDxAAkAUAEJAHIDCwAKAQsAdAELALADDACRAYwAgQKHC64ABgALAQcK9AAHCngCBwpJBggKsgAICn4CjQo6AIYAvweGAIMEhgAnBoYAngUJAB8ACgD0AAoAuwIMAJUAjQDxAYUAeQEEC3oABQscAwULuAMGC3wGBguHBggLNwIJC68CCQvmAgoLrgILC2QBCwuqAowLGQGRAGUACwsAAJALTgAFC7MABQoXAwcLRwSHC70ECAt0AQkLegCKC68ABwquAggKIQAICu4ACgpoAgsK0wELCnEDDQrZAA0K/QCOCgwBCQDcAQQLQgAHC9IChwuIAwcLYAGJC6wChwDnB4cALAeECr8BBQBLA5AAIwCJCwsDjQsjAAQKgAAFCp8BBgrOAQcKJgEHCkICCgrGAosKVgCEACoChQAYAogKSwIFAM8ACQBPAAsAcQKRAAcABwBbBQYKqwGKCrQCBACoAQQKwwCHCiIDCAARA4ULNAKHAFABBACAAwYA8QaGCywCiQtnAIYKkwYHCyACCAvPAooLPQCKCtgBBAsFAAUL8gGIC30CBwDuAgkA3wALABsACwDSAQwAcAIOAAkBkgA9AAwA7gASAJsADAvuAJILmwCXChwAhQufAwwAfwEFCgMACApCAgkKdgAKCsECjQoXAQQLfQMFCwwDhQt9AwQAWwKFAJUCBAALAAYAgAAHAOcABwD9BQoA1QIFCuUABQvuAIcLRgUICmYACgpCAgoKoAIMCvABDQqYAQ4KeQCRCmoAhADcAYYAEAaGC8EGCApzAAgKXgEJCukBCgqAAAsKMgEMCnUBDgoeABEKTwATClAAlgo3AIcADwcEAKgCBAs8AAcL+AIHCwgHCAs6AQkLvAKLC+cBBArmAAUKvgKUC14AhAvkAIsAswEJABQACgBEAQoAJwOLAOgBBgrABogLowEECuQBEgoaABMKKgAUCisAFQoAABcKGwCYCg4AhwCXBYULPAMFAHAABgBnAAYAlgAHABcFCQAkAQoA4QEUAA0ABwuwAAcLsgAHC1YECgvhAZQLDQCKAGQBBAszAAULJwAGCwQABwtPAgcLUQMHC7cDBwtpBAcLTQYHC+AGBwvEBwkLsgEKC/ICCwsZAAsLJQCLC54BBgCrB4YA0AeECnkCBgDcBIULhgOHC6ADjAASAIoAzACHC5UEhgBjAwQAxAIIAA8ACQAyAAkAggELABIACwARAowA5ACGCw4BBAAzAgcAbQAHAFACBwB9AgcAAgMIAM8BCQA8AAkATwEJAIgDCgBJAAsAsgEMAEkCDQBLARIAbgCUADwAhAD2AQ4LZwETCzQAlAsvAAYLeQEHCwEECQtlApELaAAGAFsBCgChAAUKRgAFCm4CBgpOAQcKCAQJCqsACwoaAAsK1QALCn0CCwrDAgwKygAMCnwBDQriAA0KYwEOCt4AkQoqAIQLoAEEACEABQBmAAYAHAEHADcEBwCPBQcApgYIANYBCQAqAgkA0wILAE0Bjgt0AQULmAAFC8UABwtUAQcLYwMKCyQCCgtFAgsLBgAMCwMADAsTAA4LbgCOCyEBBwD2AIcASAMGAAoACAA7AgkA4wKPAFsABgDRAQcAuQUEChcABAqNAAUKOQEFCvYDBgoyAAcKjgAHCi8CCAqAAgkKzAEJCg8DCwrlAgwKtwCNCugBhQByAogAZgKKAO0ABwsiAAcLvgAICxwACAuNAAgLvAEICysDCQvUAQsLTgEMCxgADAuCAYwLQAKFC/UCBQASAAYADgINABgADQBuABMABQCTACwABgD6AYYL+gGHCxEGBAA1AQUAzgEHAMoDBwBJBBYAHgAWACEABwtpBQsLRgILC4oCCwuFAwsLtQMMC+gADAvsAA0LnQENC/UBkgt0AAkAjAAFCt4AigoWAgYAIASJCooDhgCoBooK9wGGAAwEBQqaAAcK0wUKCnsBigrlAQQLfwGFCswChgAjBQUAVgAHAOcCCQBVAAoAGQEKALABCwA5AwwA+wANAHYAjgB6AQgACAEEClsABQqEAQUKTQMGCs4ABgr8AAYKbQEHCogABwoTAogKbQIFAAwChQDoAgULFQGNC/cAhAuzAQoAawCMALQBhACfAwoAewAMAJ4CkgBeAAcAfQQJAJwAigC9AwULCQEGC9QAhwscAIUACgOFAPYBCADEAAoAGwGLAJYBhwpAAogLFwKGACAFBQoDAwUKXwMFCoIDBgpgBgYKbAaGCvQGBQBXAwUKSwGHC88FhAu+AgULKAOHC/0HBwB4BQkAvgGKAC0AjAp4AoQA6wMFC6YACAvjAowL/wEFCmsABwrJAIgKBgIGCr4BhwoZB4YA/AWGAEkEBAt3AAULqgAFC78BBwusBgcLYQcJC2UBCQvPAgwL5gGMC1QCCQpTA40K/gEHAGQCCAAhAggAOAIIAIICCQDNAgoAHQIKAPsCCwDBAQwA6QENAJkADQAoAQ4AigAOAIgBDwAyABAABgAQAAwAFAAJAIQK+AEEC8IBhwuGBAsANgANAK0ADQAmAQUKcwMFCs8DCAqIAZQKBwANAMcBDwBjAA8AgQCQAEQAhwCsAIQL8gIFCpoDhgqrBoYABQQRCycAlAskAAQAOAIFCuEDBwoDAokKWwCEANwCCgBpAooLaQKGAM4DBwDdAwoAeQEMAGsBDQBEAA0AXgAOAGwAjgAyAYgA3QKEAKwBBwD9BocLJgQHAN8HjACZAocKmQUFAB8BBwqZAwgKRAIIClECCAp2AooKHACKACYDBAqPAwUKYwMFCvUDBwryBwgKHgOICi0DhgADBggLCwKWCyIAhwvkAgcL7gAHC/EHCAt4AAgLvAAIC5MCCQtWAgoL0gEMC1YBDAtMAg0L9wEOC/YAjwtcAAcAGwaNALYABQqHAAYKBwIHCroGCgoPAQsKBQGRCjYADgpSAZQKUQAHAOQBBAosAYUKtAGRC3IABgBXBoYAkQaFC4ACBAvJAAcL0AYIC1oCCwv3AAsLOgORC0EACAukAJILPgAGACkHBgBFB4gAbgOGACEGCAplAQoK6QIOCqoBEQpeAJMKOQAMAF0ADAD1AQ0AagEOAJcADwAoAA8AOwAQAC4AEQAZABIADgASAIYAEwAZABMARQAUABAAFAATABQAQgAVABcAFQAZAJYAKgAGANQGCADLAgkAIgMKAC4ACgAzAw0ANAEOAF8BDgBrAZIAQwCEAOIDBAA/AIUAWwGEAE8ChQDtAgcLKQYKCzABCgslAgsLqAEMC20BDQvcAA0L8ACOCyEAhQBuAQcALQIMACMCDgBWAIUKgwGHANMGhAuLAwULZAAKC0kBDAugAZULHQAECgYABQrEAogKSwAHCkcFCQpFAgoKfwILCsUBjApIAgcAWQCECi8BigoEA4QLsAAFC3wCBQvmAwgLGgCJC2YBBwsJAAcL5AUJCz0BCgvSAAoLJAEKCxUCCwsrAgwLDgIMC18CDQsHAQ0LywGOCw8BhgC3BQYABAMGAHEEiwtTAgcA0QOLC0IAigB9AxQAMACUCzAABQA4A4UArQOGCycBBwAHBgcA+QYKALICBApqAIsKzQIHALgBCADmAIsAagAFCnoDhQrcAwYKcgKOCq8BCgt/AI0LGwARACAACgrCApYKLACEANgAiQBMAQQKugKIC3cAiwsLAYoKEQALCw4CCwurA40LIgEHC48ECwumAw0LhwGRC0wAiwsnAIYKVAAEAJIDBQAgA4UAVAMKAKABjQBzAAcANAKOAKgABACWA4UAbAOGAOQGmAADAAQAXAAFABIBBwt+AIgLVACMCvIBiAsWAwgA9QEFCtoDBgqCAAcKLgYICsoBCgplAAoKPgGKCjcDBgtAAAwLeQGNCzUBBQDnAooAUwMEADEABwAYAYcAYQaGAG8DiAAvAAcKbAaJCoEAhABhA4YAsgQJCyIAiwvkAYcK5QMFABABBQCMAwUArgMIAMUACQAvAAsAGgKLAOYCBgukBgcLGgAHCyUBBwt+AQcLAgQHCz8EBwvrBwgLGAAIC3IACAv8AAgL1wIIC9kCCQseAAkLxwAJC+cACQv7AAkLTgEJC2kBCQvoAQkLyAIKCzcACgs8AAoL6AAKC0wBCguAAQoLjAEKC/gBCgseAgoLjAILCxQACwswAAsLzwALCyMBCwsqAQsLVgELC20BCwuKAQsLbAILC8ECCwv5AwwLewAMC1QBDAuWAQwLgwINCz0ADQsNAQ0LNwENCz8BDQvmAQ4L6gAPCz4ADwtVABALRwASC3cAlAtpAAYArwWWCyUAhwqHB4cAdweJAHsDBwrcBokKYgAHChYEiwqgAIQA+QIGC3sBBwsOAQcLXAQIC7AACAu3AAkLsAEJC5UCDAv3AAwLaQKSC30ABgotAAcKsQEICoEACQoVAAoKiAELCk8ADArzAQ0KxwCNCsMBBACXAQULGAOFC4QDhAAwAocAtwANAOoBBwouAogKYQEEANsBBgDbAgsAIwANAEcADQCxAA4ApgGFChEDCApRAAkKvQAJCskACwreAQsKyAKNClIBBACiAQQAMwOFCmEBlwoaAAQLhQOFCwgDhAA/AgcAMgMQAFwAEQAOABEALQASAEsAlAASAAYA3gAHAHwCBwBUBggAmQEJALUCiwBNAAYKGQAHClcDBwrqBJAKIAAGAFgHBgBfBwYAfgcGAIQHCQDHAwkA4wMJAPcDDAA6AwwAUQMMAFkDDABcAwwAdgMMAKQDEgDkABIA5wCSAPAAhgB5AoYAHAUECyUABQtOAYcL5QQKAFYABAoEAAcKXgQHCigFBwqqBggKFQEJCm4CCwrUAgwKXgEMCo0BDQocAA0KnwAPClkAEgoFABMKCQAUCiIAlgovAIQL/AGJC8ABDAtrAJILHwCEADEDhgCXAoUAcgOGAJIDhAscAoQLFQKIC2ACCAB1A4oAYQOEAKoBBgA6AAcA6QIHALEHCACPAQgAowIJAN8BCQDbAgoASgEKAFECCgAxAwsAIAALAIUACwDdAJEARACGCv8ABwBmAIkAGgKJCtgABwv9AIgLJQKHC5ADCQq3AIsKHgELCrwDlwoDAAgLDwISCzwAkwsYAAQKGAIHCnUECgrTAosKcwGFC5gDBwBsA4cKHQGHCjAChAqyAo4LfgALCiEADAo7ApUKAQCFADYCCQCLAAoAjwELANUBDAB6Ag0A3wCEC+MBBgAwAIcAPwASAAwABwpGBwwK6wEMCggCDQp/AY4K9ACHC4EGhAvAAQkL7wGSC2gABgByAAcAyAQHABQGiAADAAQKvgCFCioCCABAAgkACwGFCukDhQq+AYUApQOLC/EDCAuNAg0LXQCTCw4ABgC0AgYANQOGADUEBQusAIcLIQOKAPACBAB3AYYAfgKGAPMDjAscAgkAYACFCwQBiwtLAocKzwQMAB4ADQCUAA4AVwAOALYAEAAqABQARgCECjABBgB2BQcAOAAHAMUHCABRAQgA4gIJAFgCDAAlAA0AvwGOAFwAigCaAgUAigEHAOcBiAD2AAkAtQEGCjUABgrHAAcKgAUICiAACApdAAoKjQEKCnUCCwpRAgsK+wINCkYBkQojAIYKaQAJAEABCgD6AYoKGgMHCzkACAunAAgLdwEJC1IACQsxAgoLbAIKCwIDCwrAAo0KjAEGAOsDBQpyAAUK/wCNCh0BBwBiA4cAiwSFCxMChABIAQcK8wcIChMACQpZAIoKPwMIC8IAiAv0AogA6AMFC8UBhgu5AQQAZQAFAEEDBwCTBIgA6AKFANYCiArqAooAsAAGAAkABgCNAQcANQAHAM4GCgB4AgsAPAOMAJIAhwsWAJELQACEAEcDCwChAQwA3wCMAAkBBAtmAAcLLwMHC6MGiwvEAwUKuwOICi4DBgCLBwYA1wcSAPYAkgD3AAgAxgALAB0AjAAWAocA6wYGAE4DBwvyAwsL3QILC/cCDAszAg0LIgAOC2UAEgstAJILgQAEALoABQCdAAgAqACKAAYAhAuDA4UKOACUCmQAhQBrAwUABQMFAN8DBgBjBoYA/AYGAPoECQDdAY0ATgAEAH8CBwBvAAgARQIMALEABgs0AAkLaAAJCy8CCgoEAAoKDQALCn4CDAs0ARMLVwCUCjkAhAtcAgQLLQGFCuIChQr2AoYA0wYHC6AFCwtWAwsLaAMLC5kDDAsnAg0L2AGOC28BBwBUBQcAcweNAJ4AhgBpAwQAlAEEAJMCBwAoAocAowKHClgEiwpIAQcL/AGJCoUAhQCHAQUKbgAGCqkABgqmBgcKkAEIChoCCQq4AAkKDAKMCtoABgs2AQcLOQcIC0gACAsQAQgLrwEJCwwACQtfAQoLMwIKC3YCCgsqAwsLbwELC1cCCwuuAowLoAIFABwCBgChBogAnAKEAHMDhgBOAAwAdAISAE8ABgqFAAkKYQGLCuEDBgu1AAcLGQIIC0AACQt/AAoL8AEMC/4BjQuAAQYKXQAHCo4FBwo7BwgKoQIJChECjAorAIkKcwGGALQFhgDCAwQL9ACHC+kACQoZAAoK0wGKCi8CBApPAYcKrgOFAMwBhwtOAYYLcgYEAMcAiwAiAAUKWQIICicACgoFAwsKVAAMCs0AjgoBAIUKZgOGAIQBDgDaAZQAeACFC3EBiwAPAQQA/wEJAE0BCQB7AQoAWgILALkBCwDTAgsA0AMMAGUBhAq1AIYAYAKGCnQGFgAxAIkLUgGMANwDhgBpAgUAqgOIAMMChAphAAUKkwAGCh4BBwpSBY0KsAAGAPQChgB9BIULgAMGCncBBwqpAAcK/gCICgwDhgAvBocKpwWLAB0BBwtdBAgLiQGICxsChwBYAQYA1QEHAK0GigADAgUKdQKHCg0GBQsEAAULKgMGCw0ABgsaAgYLmgYGC74GBwvzAQcLGwcIC5QACAu4AggLFwMMC30ADQs2AI8LCQCHC/QEiQCUAYQA9AEFAEQAhgB/AQsA2ACLAFQBBAudAwULIwMIC7oCigs8AwQAUQEGAGEBBwCOBwgA6AGJAK0BBwDsAAcAAwcIAAMBCQCHAAkAsQAJAFwDCgA5AwsAcwALAHIBCwCVAQsAXAIMAAoADACbAgwAnQINAEwADgA2AQ8ATAAPAJMAlAAXAAQADwAEAOoBBQAWAAYA9AAHACgABwDIAAcAigMHAK8ECQBoAgoAzAILAHsCCwAhA4wAygEMAPQChAqkAYYA4AUGAPUChQt/AQYA8gSHAMcGBQBWAgcAFwMIAGwACQB7AAcKIgaMCh4CjguaAQkLlAKKC1sBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwBBuIXiAAv8AQEBAQECAgICAwMDAwQEBAQFBQUFBgYGBgcHBwcICAgICQkJCQoKCgoLCwsLDAwMDA0NDQ0ODg4ODw8PDxAQEBAREREREhISEhMTExMUFBQUFRUVFRYWFhYXFxcXGBgYGBkZGRkaGhoaGxsbGxwcHBwdHR0dHh4eHh8fHx8gICAgISEhISIiIiIjIyMjJCQkJCUlJSUmJiYmJycnJygoKCgpKSkpKioqKisrKyssLCwsLS0tLS4uLi4vLy8vMDAwMDExMTEyMjIyMzMzMzQ0NDQ1NTU1NjY2Njc3Nzc4ODg4OTk5OTo6Ojo7Ozs7PDw8PD09PT0+Pj4+Pz8/PwBBvYniAAsFBAQAAAQAQdSJ4gAL4AEIDBAMDBQMEBgcDAwgDCQMLCwsLCwsLCwsLCAgGCgcDAwwNDQ0MDQ0NDA0NDQ0NDA0NDQ0NDA0NDQ0NBgMHAwMDDg8PDw4PDw8ODw8PDw8ODw8PDw8ODw8PDw8GAwcDAAAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwBB1YviAAteAQEBAQEBAQEBAQEBAQEBAgICAgICAgICAgEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgEBAQEBAQMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAQEBAQBBlI3iAAugBAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAgICAgICAgICAgICAgICBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoMDAwMDAwMDAwMDAwMDAwOAABAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgcAQb2R4gALBQQEAAAEAEHUkeIAC+ABCAwQDAwUDBAYHAwMIAwkDCwsLCwsLCwsLCwgIBgoHAwMMDQ0NDA0NDQwNDQ0NDQwNDQ0NDQwNDQ0NDQYDBwMDAw4PDw8ODw8PDg8PDw8PDg8PDw8PDg8PDw8PBgMHAwAAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAQdWT4gALXgEBAQEBAQEBAQEBAQEBAQICAgICAgICAgIBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgIBAQEBAQEDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwEBAQEAQZSV4gALxQgCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgABAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgcEBAQEBAQEBAQEBAQEBQUABAQGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsoKW1pZCA+IGxlbgAAAMiOGAAJAEHkneIAC6IBAQAAAI4FAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAI8FAAAAAAAAAQAAAAIAAAADAAAABAAAAAUAAAAGAAAACAAAAAoAAAAOAAAAEgAAABoAAAAiAAAAMgAAAEIAAABiAAAAggAAAMIAAABCAQAAQgIAAEIEAABCCAAAQhgAAEJYAEGgn+IAC6YBAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAADAAAAA4AAAAYAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAADAAAAA4AAAASAAAAFgAAAB4AAAAmAAAANgAAAEYAAABmAAAAhgAAAMYAAABGAQAARgIAAEYEAABGCABB6KDiAAtdAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAAGAAAAPIkEABiAAAAdgAAAAUAAADyJBAAYgAAAHYAAAAaAEHUoeIAC/VkBwAAABcAAAAnAAAANwAAAEcAAABXAAAAZwAAAHcAAABwBwAAhwsAAIcTAACHGwAAhyMAAIcrAACHMwAAhzsAAJcDAACXCwAAlxMAAJcbAACXIwAAlysAAJczAACXOwAApwMAAKcLAACnEwAApxsAAKcjAACnKwAApzMAAKc7AAC3AwAAtwsAALcTAAC3GwAAtyMAALcrAAC3MwAAtzsAAMcDAADHCwAAxxMAAMcbAADHIwAAxysAAMczAADHOwAA1wMAANcLAADXEwAA1xsAANcjAADXKwAA1zMAANc7AADnAwAA5wsAAOcTAADnGwAA5yMAAOcrAADnMwAA5zsAAPcDAAD3CwAA9xMAAPcbAAD3IwAA9ysAAPczAAD3OwAAh8MBAIfDBQCHwwkAh8MNAIfDEQCHwxUAh8MZAIfDHQCHywEAh8sFAIfLCQCHyw0Ah8sRAIfLFQCHyxkAh8sdAIfTAQCH0wUAh9MJAIfTDQCH0xEAh9MVAIfTGQCH0x0Ah9sBAIfbBQCH2wkAh9sNAIfbEQCH2xUAh9sZAIfbHQCH4wEAh+MFAIfjCQCH4w0Ah+MRAIfjFQCH4xkAh+MdAIfrAQCH6wUAh+sJAIfrDQCH6xEAh+sVAIfrGQCH6x0Ah/MBAIfzBQCH8wkAh/MNAIfzEQCH8xUAh/MZAIfzHQCH+wEAh/sFAIf7CQCH+w0Ah/sRAIf7FQCH+xkAh/sdAJfDAQCXwwUAl8MJAJfDDQCXwxEAl8MVAJfDGQCXwx0Al8sBAJfLBQCXywkAl8sNAJfLEQCXyxUAl8sZAJfLHQCX0wEAl9MFAJfTCQCX0w0Al9MRAJfTFQCX0xkAl9MdAJfbAQCX2wUAl9sJAJfbDQCX2xEAl9sVAJfbGQCX2x0Al+MBAJfjBQCX4wkAl+MNAJfjEQCX4xUAl+MZAJfjHQCX6wEAl+sFAJfrCQCX6w0Al+sRAJfrFQCX6xkAl+sdAJfzAQCX8wUAl/MJAJfzDQCX8xEAl/MVAJfzGQCX8x0Al/sBAJf7BQCX+wkAl/sNAJf7EQCX+xUAl/sZAJf7HQCnwwEAp8MFAKfDCQCnww0Ap8MRAKfDFQCnwxkAp8MdAKfLAQCnywUAp8sJAKfLDQCnyxEAp8sVAKfLGQCnyx0Ap9MBAKfTBQCn0wkAp9MNAKfTEQCn0xUAp9MZAKfTHQCn2wEAp9sFAKfbCQCn2w0Ap9sRAKfbFQCn2xkAp9sdAKfjAQCn4wUAp+MJAKfjDQCn4xEAp+MVAKfjGQCn4x0Ap+sBAKfrBQCn6wkAp+sNAKfrEQCn6xUAp+sZAKfrHQCn8wEAp/MFAKfzCQCn8w0Ap/MRAKfzFQCn8xkAp/MdAKf7AQCn+wUAp/sJAKf7DQCn+xEAp/sVAKf7GQCn+x0At8MBALfDBQC3wwkAt8MNALfDEQC3wxUAt8MZALfDHQC3ywEAt8sFALfLCQC3yw0At8sRALfLFQC3yxkAt8sdALfTAQC30wUAt9MJALfTDQC30xEAt9MVALfTGQC30x0At9sBALfbBQC32wkAt9sNALfbEQC32xUAt9sZALfbHQC34wEAt+MFALfjCQC34w0At+MRALfjFQC34xkAt+MdALfrAQC36wUAt+sJALfrDQC36xEAt+sVALfrGQC36x0At/MBALfzBQC38wkAt/MNALfzEQC38xUAt/MZALfzHQC3+wEAt/sFALf7CQC3+w0At/sRALf7FQC3+xkAt/sdAMfDAQDHwwUAx8MJAMfDDQDHwxEAx8MVAMfDGQDHwx0Ax8sBAMfLBQDHywkAx8sNAMfLEQDHyxUAx8sZAMfLHQDH0wEAx9MFAMfTCQDH0w0Ax9MRAMfTFQDH0xkAx9MdAMfbAQDH2wUAx9sJAMfbDQDH2xEAx9sVAMfbGQDH2x0Ax+MBAMfjBQDH4wkAx+MNAMfjEQDH4xUAx+MZAMfjHQDH6wEAx+sFAMfrCQDH6w0Ax+sRAMfrFQDH6xkAx+sdAMfzAQDH8wUAx/MJAMfzDQDH8xEAx/MVAMfzGQDH8x0Ax/sBAMf7BQDH+wkAx/sNAMf7EQDH+xUAx/sZAMf7HQDXwwEA18MFANfDCQDXww0A18MRANfDFQDXwxkA18MdANfLAQDXywUA18sJANfLDQDXyxEA18sVANfLGQDXyx0A19MBANfTBQDX0wkA19MNANfTEQDX0xUA19MZANfTHQDX2wEA19sFANfbCQDX2w0A19sRANfbFQDX2xkA19sdANfjAQDX4wUA1+MJANfjDQDX4xEA1+MVANfjGQDX4x0A1+sBANfrBQDX6wkA1+sNANfrEQDX6xUA1+sZANfrHQDX8wEA1/MFANfzCQDX8w0A1/MRANfzFQDX8xkA1/MdANf7AQDX+wUA1/sJANf7DQDX+xEA1/sVANf7GQDX+x0A58MBAOfDBQDnwwkA58MNAOfDEQDnwxUA58MZAOfDHQDnywEA58sFAOfLCQDnyw0A58sRAOfLFQDnyxkA58sdAOfTAQDn0wUA59MJAOfTDQDn0xEA59MVAOfTGQDn0x0A59sBAOfbBQDn2wkA59sNAOfbEQDn2xUA59sZAOfbHQDn4wEA5+MFAOfjCQDn4w0A5+MRAOfjFQDn4xkA5+MdAOfrAQDn6wUA5+sJAOfrDQDn6xEA5+sVAOfrGQDn6x0A5/MBAOfzBQDn8wkA5/MNAOfzEQDn8xUA5/MZAOfzHQDn+wEA5/sFAOf7CQDn+w0A5/sRAOf7FQDn+xkA5/sdAPfDAQD3wwUA98MJAPfDDQD3wxEA98MVAPfDGQD3wx0A98sBAPfLBQD3ywkA98sNAPfLEQD3yxUA98sZAPfLHQD30wEA99MFAPfTCQD30w0A99MRAPfTFQD30xkA99MdAPfbAQD32wUA99sJAPfbDQD32xEA99sVAPfbGQD32x0A9+MBAPfjBQD34wkA9+MNAPfjEQD34xUA9+MZAPfjHQD36wEA9+sFAPfrCQD36w0A9+sRAPfrFQD36xkA9+sdAPfzAQD38wUA9/MJAPfzDQD38xEA9/MVAPfzGQD38x0A9/sBAPf7BQD3+wkA9/sNAPf7EQD3+xUA9/sZAPf7HQCHw+EAh8PhAofD4QSHw+EGh8PhCIfD4QqHw+EMh8PhDofD5QCHw+UCh8PlBIfD5QaHw+UIh8PlCofD5QyHw+UOh8PpAIfD6QKHw+kEh8PpBofD6QiHw+kKh8PpDIfD6Q6Hw+0Ah8PtAofD7QSHw+0Gh8PtCIfD7QqHw+0Mh8PtDofD8QCHw/ECh8PxBIfD8QaHw/EIh8PxCofD8QyHw/EOh8P1AIfD9QKHw/UEh8P1BofD9QiHw/UKh8P1DIfD9Q6Hw/kAh8P5AofD+QSHw/kGh8P5CIfD+QqHw/kMh8P5DofD/QCHw/0Ch8P9BIfD/QaHw/0Ih8P9CofD/QyHw/0Oh8vhAIfL4QKHy+EEh8vhBofL4QiHy+EKh8vhDIfL4Q6Hy+UAh8vlAofL5QSHy+UGh8vlCIfL5QqHy+UMh8vlDofL6QCHy+kCh8vpBIfL6QaHy+kIh8vpCofL6QyHy+kOh8vtAIfL7QKHy+0Eh8vtBofL7QiHy+0Kh8vtDIfL7Q6Hy/EAh8vxAofL8QSHy/EGh8vxCIfL8QqHy/EMh8vxDofL9QCHy/UCh8v1BIfL9QaHy/UIh8v1CofL9QyHy/UOh8v5AIfL+QKHy/kEh8v5BofL+QgAAAAABAAAAAgAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAsAAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAAAAAAIAAAABAAAAAwAAAACAAAACgAAAAYAAAAOAAAAAQAAAAkAAAAFAAAADQAAAAMAAAAPAAAAHwAAAAAAAAALAAAABwAAAAsAAAAbAAAAKwAAADsAAADLAgAAywYAAMsKAADLDgAA2wIAANsGAADbCgAA2w4AAOsCAADrBgAA6woAAOsOAAD7AgAA+wYAAPsKAAD7DgAAy7IAAMuyAQDLsgIAy7IDAMu2AADLtgEAy7YCAMu2AwDLugAAy7oBAMu6AgDLugMAy74AAMu+AQDLvgIAy74DANuyAADbsgEA27ICANuyAwDbtgAA27YBANu2AgDbtgMA27oAANu6AQDbugIA27oDANu+AADbvgEA274CANu+AwDrsgAA67IBAOuyAgDrsgMA67YAAOu2AQDrtgIA67YDAOu6AADrugEA67oCAOu6AwDrvgAA674BAOu+AgDrvgMA+7IAAPuyAQD7sgIA+7IDAPu2AAD7tgEA+7YCAPu2AwD7ugAA+7oBAPu6AgD7ugMA+74AAPu+AQD7vgIA+74DAMuyLADLsmwAy7KsAMuy7ADLsi0Ay7JtAMuyrQDLsu0Ay7IuAMuybgDLsq4Ay7LuAMuyLwDLsm8Ay7KvAMuy7wDLtiwAy7ZsAMu2rADLtuwAy7YtAMu2bQDLtq0Ay7btAMu2LgDLtm4Ay7auAMu27gDLti8Ay7ZvAMu2rwDLtu8Ay7osAMu6bADLuqwAy7rsAMu6LQDLum0Ay7qtAMu67QDLui4Ay7puAMu6rgDLuu4Ay7ovAMu6bwDLuq8Ay7rvAMu+LADLvmwAy76sAMu+7ADLvi0Ay75tAMu+rQDLvu0Ay74uAMu+bgDLvq4Ay77uAMu+LwDLvm8Ay76vAMu+7wDbsiwA27JsANuyrADbsuwA27ItANuybQDbsq0A27LtANuyLgDbsm4A27KuANuy7gDbsi8A27JvANuyrwDbsu8A27YsANu2bADbtqwA27bsANu2LQDbtm0A27atANu27QDbti4A27ZuANu2rgDbtu4A27YvANu2bwDbtq8A27bvANu6LADbumwA27qsANu67ADbui0A27ptANu6rQDbuu0A27ouANu6bgDbuq4A27ruANu6LwDbum8A27qvANu67wDbviwA275sANu+rADbvuwA274tANu+bQDbvq0A277tANu+LgDbvm4A276uANu+7gDbvi8A275vANu+rwDbvu8A67IsAOuybADrsqwA67LsAOuyLQDrsm0A67KtAOuy7QDrsi4A67JuAOuyrgDrsu4A67IvAOuybwDrsq8A67LvAOu2LADrtmwA67asAOu27ADrti0A67ZtAOu2rQDrtu0A67YuAOu2bgDrtq4A67buAOu2LwDrtm8A67avAOu27wDruiwA67psAOu6rADruuwA67otAOu6bQDruq0A67rtAOu6LgDrum4A67quAOu67gDrui8A67pvAOu6rwDruu8A674sAOu+bADrvqwA677sAOu+LQDrvm0A676tAOu+7QDrvi4A675uAOu+rgDrvu4A674vAOu+bwDrvq8A677vAPuyLAD7smwA+7KsAPuy7AD7si0A+7JtAPuyrQD7su0A+7IuAPuybgD7sq4A+7LuAPuyLwD7sm8A+7KvAPuy7wD7tiwA+7ZsAPu2rAD7tuwA+7YtAPu2bQD7tq0A+7btAPu2LgD7tm4A+7auAPu27gD7ti8A+7ZvAPu2rwD7tu8A+7osAPu6bAD7uqwA+7rsAPu6LQD7um0A+7qtAPu67QD7ui4A+7puAPu6rgD7uu4A+7ovAPu6bwD7uq8A+7rvAPu+LAD7vmwA+76sAPu+7AD7vi0A+75tAPu+rQD7vu0A+74uAPu+bgD7vq4A+77uAPu+LwD7vm8A+76vAPu+7wDLsiwLy7IsG8uyLCvLsiw7y7JsC8uybBvLsmwry7JsO8uyrAvLsqwby7KsK8uyrDvLsuwLy7LsG8uy7CvLsuw7y7ItC8uyLRvLsi0ry7ItO8uybQvLsm0by7JtK8uybTvLsq0Ly7KtG8uyrSvLsq07y7LtC8uy7RvLsu0ry7LtO8uyLgvLsi4by7IuK8uyLjvLsm4Ly7JuG8uybivLsm47y7KuC8uyrhvLsq4ry7KuO8uy7gvLsu4by7LuK8uy7jvLsi8Ly7IvG8uyLyvLsi87y7JvC8uybxvLsm8ry7JvO8uyrwvLsq8by7KvK8uyrzvLsu8Ly7LvG8uy7yvLsu87y7YsC8u2LBvLtiwry7YsO8u2bAvLtmwby7ZsK8u2bDvLtqwLy7asG8u2rCvLtqw7y7bsC8u27BvLtuwry7bsO8u2LQvLti0by7YtK8u2LTvLtm0Ly7ZtG8u2bSvLtm07y7atC8u2rRvLtq0ry7atO8u27QvLtu0by7btK8u27TvLti4Ly7YuG8u2LivLti47y7ZuC8u2bhvLtm4ry7ZuO8u2rgvLtq4by7auK8u2rjvLtu4Ly7buG8u27ivLtu47y7YvC8u2LxvLti8ry7YvO8u2bwvLtm8by7ZvK8u2bzvLtq8Ly7avG8u2ryvLtq87y7bvC8u27xvLtu8ry7bvO8u6LAvLuiwby7osK8u6LDvLumwLy7psG8u6bCvLumw7y7qsC8u6rBvLuqwry7qsO8u67AvLuuwby7rsK8u67DvLui0Ly7otG8u6LSvLui07y7ptC8u6bRvLum0ry7ptO8u6rQvLuq0by7qtK8u6rTvLuu0Ly7rtG8u67SvLuu07y7ouC8u6LhvLui4ry7ouO8u6bgvLum4by7puK8u6bjvLuq4Ly7quG8u6rivLuq47y7ruC8u67hvLuu4ry7ruO8u6LwvLui8by7ovK8u6LzvLum8Ly7pvG8u6byvLum87y7qvC8u6rxvLuq8ry7qvO8u67wvLuu8by7rvK8u67zvLviwLy74sG8u+LCvLviw7y75sC8u+bBvLvmwry75sO8u+rAvLvqwby76sK8u+rDvLvuwLy77sG8u+7CvLvuw7y74tC8u+LRvLvi0ry74tO8u+bQvLvm0by75tK8u+bTvLvq0Ly76tG8u+rSvLvq07y77tC8u+7RvLvu0ry77tO8u+LgvLvi4by74uK8u+LjvLvm4Ly75uG8u+bivLvm47y76uC8u+rhvLvq4ry76uO8u+7gvLvu4by77uK8u+7jvLvi8Ly74vG8u+LyvLvi87y75vC8u+bxvLvm8ry75vO8u+rwvLvq8by76vK8u+rzvLvu8Ly77vG8u+7yvLvu8727IsC9uyLBvbsiwr27IsO9uybAvbsmwb27JsK9uybDvbsqwL27KsG9uyrCvbsqw727LsC9uy7Bvbsuwr27LsO9uyLQvbsi0b27ItK9uyLTvbsm0L27JtG9uybSvbsm0727KtC9uyrRvbsq0r27KtO9uy7Qvbsu0b27LtK9uy7Tvbsi4L27IuG9uyLivbsi4727JuC9uybhvbsm4r27JuO9uyrgvbsq4b27KuK9uyrjvbsu4L27LuG9uy7ivbsu4727IvC9uyLxvbsi8r27IvO9uybwvbsm8b27JvK9uybzvbsq8L27KvG9uyryvbsq8727LvC9uy7xvbsu8r27LvO9u2LAvbtiwb27YsK9u2LDvbtmwL27ZsG9u2bCvbtmw727asC9u2rBvbtqwr27asO9u27Avbtuwb27bsK9u27Dvbti0L27YtG9u2LSvbti0727ZtC9u2bRvbtm0r27ZtO9u2rQvbtq0b27atK9u2rTvbtu0L27btG9u27Svbtu0727YuC9u2Lhvbti4r27YuO9u2bgvbtm4b27ZuK9u2bjvbtq4L27auG9u2rivbtq47BgAAAAYAAAAGAAAABgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAAACAAEAAwAAgAKAAYADgABAAkABQANAAMACwAHAA8AAIAIgASADIACgAqABoAOgAGACYAFgA2AA4ALgAeAD4AAQAhABEAMQAJACkAGQA5AAUAJQAVADUADQAtAB0APQADACMAEwAzAAsAKwAbADsABwAnABcANwAPAC8AHwA/AAAAAAGAAIABQABAAcAAwAEgACABoACgAWAAYAHgAOABEAAQAZAAkAFQAFAB0ADQATAAMAGwALABcABwAfAA8AEIAAgBiACIAUgASAHIAMgBKAAoAagAqAFoAGgB6ADoARgAGAGYAJgBWABYAdgA2AE4ADgBuAC4AXgAeAH4APgBBAAEAYQAhAFEAEQBxADEASQAJAGkAKQBZABkAeQA5AEUABQBlACUAVQAVAHUANQBNAA0AbQAtAF0AHQB9AD0AQwADAGMAIwBTABMAcwAzAEsACwBrACsAWwAbAHsAOwBHAAcAZwAnAFcAFwB3ADcATwAPAG8ALwBfAB8AfwA/AECAAIBggCCAUIAQgHCAMIBIgAiAaIAogFiAGIB4gDiARIAEgGSAJIBUgBSAdIA0gEyADIBsgCyAXIAcgHyAPIBCgAKAYoAigFKAEoBygDKASoAKgGqAKoBagBqAeoA6gEaABoBmgCaAVoAWgHaANoBOgA6AboAugF6AHoB+gD6AQYABgGGAIYBRgBGAcYAxgEmACYBpgCmAWYAZgHmAOYBFgAWAZYAlgFWAFYB1gDWATYANgG2ALYBdgB2AfYA9gEOAA4BjgCOAU4ATgHOAM4BLgAuAa4ArgFuAG4B7gDuAR4AHgGeAJ4BXgBeAd4A3gE+AD4BvgC+AX4AfgH+AP4BAQABAYEAgQFBAEEBwQDBASEAIQGhAKEBYQBhAeEA4QERABEBkQCRAVEAUQHRANEBMQAxAbEAsQFxAHEB8QDxAQkACQGJAIkBSQBJAckAyQEpACkBqQCpAWkAaQHpAOkBGQAZAZkAmQFZAFkB2QDZATkAOQG5ALkBeQB5AfkA+QEFAAUBhQCFAUUARQHFAMUBJQAlAaUApQFlAGUB5QDlARUAFQGVAJUBVQBVAdUA1QE1ADUBtQC1AXUAdQH1APUBDQANAY0AjQFNAE0BzQDNAS0ALQGtAK0BbQBtAe0A7QEdAB0BnQCdAV0AXQHdAN0BPQA9Ab0AvQF9AH0B/QD9AQMAAwGDAIMBQwBDAcMAwwEjACMBowCjAWMAYwHjAOMBEwATAZMAkwFTAFMB0wDTATMAMwGzALMBcwBzAfMA8wELAAsBiwCLAUsASwHLAMsBKwArAasAqwFrAGsB6wDrARsAGwGbAJsBWwBbAdsA2wE7ADsBuwC7AXsAewH7APsBBwAHBAcCBwYHAQcFBwMHB4cAhwSHAocGhwGHBYcDhwdHAEcERwJHBkcBRwVHA0cHxwDHBMcCxwbHAccFxwPHBycAJwQnAicGJwEnBScDJwenAKcEpwKnBqcBpwWnA6cHZwBnBGcCZwZnAWcFZwNnB+cA5wTnAucG5wHnBecD5wcXABcEFwIXBhcBFwUXAxcHlwCXBJcClwaXAZcFlwOXB1cAVwRXAlcGVwFXBVcDVwfXANcE1wLXBtcB1wXXA9cHNwA3BDcCNwY3ATcFNwM3B7cAtwS3ArcGtwG3BbcDtwd3AHcEdwJ3BncBdwV3A3cH9wD3BPcC9wb3AfcF9wP3Bw8ADwQPAg8GDwEPBQ8DDwePAI8EjwKPBo8BjwWPA48HTwBPBE8CTwZPAU8FTwNPB88AzwTPAs8GzwHPBc8DzwcvAC8ELwIvBi8BLwUvAy8HrwCvBK8CrwavAa8FrwOvB28AbwRvAm8GbwFvBW8DbwfvAO8E7wLvBu8B7wXvA+8HHwAfBB8CHwYfAR8FHwMfB58AnwSfAp8GnwGfBZ8DnwdfAF8EXwJfBl8BXwVfA18H3wDfBN8C3wbfAd8F3wPfBz8APwQ/Aj8GPwE/BT8DPwe/AL8EvwK/Br8BvwW/A78HfwB/BH8CfwZ/AX8FfwN/B/8A/wT/Av8G/wH/Bf8D/wewIBAAZQAAAGAAAAArAAAAYXNzZXJ0aW9uIGZhaWxlZDogcHJpb3IgPCA2NLAgEABlAAAAYgAAAAUAQdaG4wAL54AQgD8N4Mo/AAAAQHiaFEAHcCVAtKszQAAAQEAN4EpAeJpUQFRnXUAHcGVAAdRsQLSrc0B/CnpAAACAQH/MgkAHcIVABu+HQDxNikDdjYxAqrOOQAXBkEADuJJAeJqUQAFqlkAKKJhA2tWZQJV0m0A/BZ1Ax4ieQAAAoECta6FAf8yiQBYjpEAHcKVA2LOmQAbvp0AEIqlAPE2qQBFxq0DdjaxA9qOtQKqzrkBDva9ABcGwQDG/sUADuLJAtKuzQHiatECChLVAAWq2QCBLt0AKKLhA5gC5QNrVuUAJp7pAlXS7QJ0+vEA/Bb1Amsi9QMeIvkDhRb9AAADAQD23wECta8FAZx3CQH/MwkAIecNAFiPEQLrKxEAHcMVACxPGQNizxkB8UsdABu/HQISJyEAEIslAkrjJQDxNykAN4MpAEXHLQFMAzEDdjcxAuxnNQPajzUCYLM5AqrPOQDU5z0BDvc9A2z/QQAXB0EDKQNFAMb/RQEI80kADuNJAfDLTQLSr00CwI9RAeJrUQBIQ1UCChNVA0PfVQAFq1kAZ29ZAIEvXQBm610AKKNhA95TYQOYA2UDba9lA2tXZQOg+2kAJp9pAQQ7bQJV020AH2ttAnT7cQFmi3EA/Bd1AVGfdQJrI3UAUKd5Ax4jeQLTn3kDhRd9ATqPfQAAA4ED5W+BAPbfgQM0R4UCta+FA4MThQGcd4kBGdeJAf8ziQBQj40AIeeNAXs7jQBYj5EA0d+RAusrkQKod5UAHcOVA0cHlQAsT5kC3Y+ZA2LPmQG4D50B8UudAA6HnQAbv50CFPOhAhInoQAPW6EAEIulAiG3pQJK46UAjA+pAPE3qQN+W6kAN4OpAyCjrQBFx60DpuOtAUwDsQE5H7EDdjexAAdTsQLsZ7UAMX+1A9qPtQHno7UCYLO5AUnDuQKqz7kCg9u5ANTnvQGt770BDve9Avf7vQNs/8ECdgPBABcHwQBQB8UDKQPFAKYDxQDG/8UDk/fFAQjzyQEx68kADuPJAaPXyQHwy80BAb/NAtKvzQNnn80CwI/RAO1/0QHia9EBq1fRAEhD1QG9K9UCChPVATb71QND39UAMMfZAAWr2QLCi9kAZ2/ZAPxP3QCBL90C+gvdAGbr3QDLx90AKKPhAoV74QPeU+EAOy/hA5gD5QH82+UDba/lA+aD5QNrV+UB/CvpA6D76QBZz+kAJp/pAwtr6QEEO+0CHQftAlXT7QGqn+0AH2vtAbQz8QJ0+/ECWcPxAWaL8QOfT/EA/Bf1AZDb9QFRn/UAQmP1Amsj9QPD4/UAUKf5ABln+QMeI/kBWuP5AtOf+QOMW/0DhRf9Ar3T/QE6j/0C+0f9AAAAAQQoXAEH9LQBB2UQAQZ5bAEFOcgBB54gAQWqfAEHXtQBBLswAQXDiAEGc+ABBtA4BQbYkAUGjOgFBfFABQT9mAUHvewFBipEBQRGnAUGEvAFB49EBQS/nAUFn/AFBixECQZwmAkGaOwJBhVACQV1lAkEjegJB1Y4CQXWjAkEDuAJBf8wCQejgAkFA9QJBhQkDQbkdA0HcMQNB7EUDQexZA0HabQNBt4EDQYOVA0E+qQNB6LwDQYHQA0EK5ANBg/cDQesKBEFDHgRBijEEQcJEBEHqVwRBAWsEQQl+BEECkQRB66MEQcS2BEGOyQRBSdwEQfXuBEGSAQVBHxQFQZ4mBUEOOQVBb0sFQcJdBUEHcAVBPIIFQWSUBUF9pgVBiLgFQYbKBUF13AVBVu4FQSkABkHvEQZBpyMGQVI1BkHvRgZBflgGQQFqBkF2ewZB3owGQTieBkGGrwZBx8AGQfvRBkEi4wZBPfQGQUsFB0FMFgdBQScHQSk4B0EFSQdB1VkHQZlqB0FQewdB+4sHQZucB0EurQdBtr0HQTHOB0Gh3gdBBu8HQV7/B0GsDwhB7R8IQSQwCEFOQAhBblAIQYNgCEGMcAhBioAIQX2QCEFloAhBQrAIQRTACEHczwhBmd8IQUvvCEHy/ghBjw4JQSEeCUGpLQlBJj0JQZlMCUECXAlBYGsJQbR6CUH+iQlBPpkJQXSoCUGgtwlBwsYJQdrVCUHo5AlB7fMJQecCCkHYEQpBwCAKQZ0vCkFxPgpBPE0KQf1bCkG1agpBZHkKQQmICkGllgpBN6UKQcGzCkFBwgpBuNAKQSffCkGM7QpB6PsKQTsKC0GGGAtBxyYLQQA1C0EwQwtBWFELQXdfC0GNbQtBmnsLQZ+JC0GclwtBkKULQXyzC0FfwQtBOs8LQQzdC0HX6gtBmfgLQVMGDEEFFAxBryEMQVAvDEHqPAxBfEoMQQVYDEGHZQxBAXMMQXOADEHdjQxBQJsMQZqoDEHttQxBOcMMQXzQDEG43QxB7eoMQRr4DEE/BQ1BXRINQXQfDUGDLA1BizkNQYtGDUGEUw1BdmANQWFtDUFEeg1BIYcNQfaTDUHEoA1Biq0NQUq6DUEDxw1BtdMNQWDgDUEE7Q1BofkNQTcGDkHGEg5BTh8OQdArDkFLOA5Bv0QOQSxRDkGTXQ5B82kOQU12DkGggg5B7I4OQTKbDkFxpw5BqrMOQdy/DkEIzA5BLtgOQU3kDkFm8A5BePwOQYQID0GKFA9BiiAPQYMsD0F2OA9BY0QPQUpQD0ErXA9BBmgPQdpzD0Gpfw9BcYsPQTSXD0Hwog9Bp64PQVe6D0ECxg9Bp9EPQUbdD0Hf6A9BcvQPQQAAEEGICxBBChcQQYYiEEH9LRBBbjkQQdlEEEE+UBBBnlsQQflmEEFOchBBnX0QQeeIEEErlBBBap8QQaOqEEHXtRBBBcEQQS7MEEFS1xBBcOIQQYntEEGc+BBBqwMRQbQOEUG3GRFBtiQRQa8vEUGjOhFBkkURQXxQEUFgWxFBP2YRQRpxEUHvexFBv4YRQYqREUFQnBFBEacRQc2xEUGEvBFBNscRQePREUGL3BFBL+cRQc3xEUFn/BFB+wYSQYsREkEWHBJBnCYSQR4xEkGaOxJBEkYSQYVQEkH0WhJBXWUSQcJvEkEjehJBfoQSQdWOEkEomRJBdaMSQb+tEkEDuBJBQ8ISQX/MEkG21hJB6OASQRbrEkFA9RJBZf8SQYUJE0GiExNBuR0TQc0nE0HcMRNB5jsTQexFE0HuTxNB7FkTQeVjE0HabRNBy3cTQbeBE0GfixNBg5UTQWKfE0E+qRNBFbMTQei8E0G3xhNBgdATQUjaE0EK5BNBye0TQYP3E0E5ARRB6woUQZkUFEFDHhRB6ScUQYoxFEEoOxRBwkQUQVhOFEHqVxRBd2EUQQFrFEGHdBRBCX4UQYiHFEECkRRBeJoUQeujFEFZrRRBxLYUQSvAFEGOyRRB7tIUQUncFEGh5RRB9e4UQUX4FEGSARVB2goVQR8UFUFhHRVBniYVQdgvFUEOORVBQUIVQW9LFUGbVBVBwl0VQeZmFUEHcBVBI3kVQTyCFUFSixVBZJQVQXKdFUF9phVBha8VQYi4FUGJwRVBhsoVQX/TFUF13BVBZ+UVQVbuFUFB9xVBKQAWQQ4JFkHvERZBzRoWQacjFkF+LBZBUjUWQSI+FkHvRhZBuE8WQX5YFkFBYRZBAWoWQb1yFkF2exZBK4QWQd6MFkGNlRZBOJ4WQeGmFkGGrxZBKLgWQcfAFkFjyRZB+9EWQZDaFkEi4xZBsesWQT30FkHF/BZBSwUXQc0NF0FMFhdByB4XQUEnF0G2LxdBKTgXQZlAF0EFSRdBb1EXQdVZF0E4YhdBmWoXQfZyF0FQexdBp4MXQfuLF0FMlBdBm5wXQeakF0EurRdBc7UXQba9F0H1xRdBMc4XQWvWF0Gh3hdB1eYXQQbvF0Ez9xdBXv8XQYYHGEGsDxhBzhcYQe0fGEEKKBhBJDAYQTo4GEFOQBhBYEgYQW5QGEF6WBhBg2AYQYloGEGMcBhBjHgYQYqAGEGFiBhBfZAYQXKYGEFloBhBVagYQUKwGEEtuBhBFMAYQfnHGEHczxhBvNcYQZnfGEFz5xhBS+8YQSD3GEHy/hhBwgYZQY8OGUFZFhlBIR4ZQeYlGUGpLRlBaTUZQSY9GUHhRBlBmUwZQU9UGUECXBlBsmMZQWBrGUELcxlBtHoZQVuCGUH+iRlBn5EZQT6ZGUHaoBlBdKgZQQuwGUGgtxlBMr8ZQcLGGUFPzhlB2tUZQWLdGUHo5BlBbOwZQe3zGUFr+xlB5wIaQWEKGkHYERpBTRkaQcAgGkEwKBpBnS8aQQk3GkFxPhpB2EUaQTxNGkGeVBpB/VsaQVpjGkG1ahpBDnIaQWR5GkG3gBpBCYgaQViPGkGllhpB750aQTelGkF9rBpBwbMaQQK7GkFBwhpBfskaQbjQGkHx1xpBJ98aQVrmGkGM7RpBu/QaQej7GkETAxtBOwobQWIRG0GGGBtBqB8bQccmG0HlLRtBADUbQRk8G0EwQxtBRUobQVhRG0FoWBtBd18bQYNmG0GNbRtBlXQbQZp7G0GeghtBn4kbQZ+QG0GclxtBl54bQZClG0GHrBtBfLMbQW66G0FfwRtBTcgbQTrPG0Ek1htBDN0bQfPjG0HX6htBufEbQZn4G0F3/xtBUwYcQS0NHEEFFBxB2xocQa8hHEGBKBxBUC8cQR42HEHqPBxBtEMcQXxKHEFBURxBBVgcQcdeHEGHZRxBRWwcQQFzHEG7eRxBc4AcQSmHHEHdjRxBj5QcQUCbHEHuoRxBmqgcQUWvHEHttRxBlLwcQTnDHEHcyRxBfNAcQRvXHEG43RxBVOQcQe3qHEGE8RxBGvgcQa7+HEE/BR1BzwsdQV0SHUHqGB1BdB8dQfwlHUGDLB1BCDMdQYs5HUEMQB1Bi0YdQQlNHUGEUx1B/lkdQXZgHUHtZh1BYW0dQdRzHUFEeh1Bs4AdQSGHHUGMjR1B9pMdQV6aHUHEoB1BKKcdQYqtHUHrsx1BSrodQajAHUEDxx1BXc0dQbXTHUEL2h1BYOAdQbLmHUEE7R1BU/MdQaH5HUHs/x1BNwYeQX8MHkHGEh5BCxkeQU4fHkGQJR5B0CseQQ4yHkFLOB5Bhj4eQb9EHkH3Sh5BLFEeQWFXHkGTXR5BxGMeQfNpHkEhcB5BTXYeQXd8HkGggh5Bx4geQeyOHkEQlR5BMpseQVKhHkFxpx5Bjq0eQaqzHkHEuR5B3L8eQfPFHkEIzB5BHNIeQS7YHkE+3h5BTeQeQVrqHkFm8B5BcPYeQXj8HkF/Ah9BhAgfQYgOH0GKFB9BixofQYogH0GHJh9BgywfQX0yH0F2OB9Bbj4fQWNEH0FYSh9BSlAfQTtWH0ErXB9BGWIfQQZoH0HxbR9B2nMfQcJ5H0Gpfx9BjoUfQXGLH0FTkR9BNJcfQROdH0Hwoh9BzKgfQaeuH0GAtB9BV7ofQS7AH0ECxh9B1csfQafRH0F31x9BRt0fQRPjH0Hf6B9Bqu4fQXL0H0E6+h9BAAAgQcUFIEGICyBBSREgQQoXIEHJHCBBhiIgQUIoIEH9LSBBtjMgQW45IEEkPyBB2UQgQYxKIEE+UCBB71UgQZ5bIEFMYSBB+WYgQaRsIEFOciBB9ncgQZ19IEFCgyBB54ggQYmOIEErlCBBy5kgQWqfIEEHpSBBo6ogQT2wIEHXtSBBbrsgQQXBIEGaxiBBLswgQcDRIEFS1yBB4dwgQXDiIEH95yBBie0gQRPzIEGc+CBBJP4gQasDIUEwCSFBtA4hQTYUIUG3GSFBNx8hQbYkIUEzKiFBry8hQSo1IUGjOiFBG0AhQZJFIUEHSyFBfFAhQe5VIUFgWyFB0GAhQT9mIUGtayFBGnEhQYV2IUHveyFBWIEhQb+GIUEljCFBipEhQe6WIUFQnCFBsaEhQRGnIUFwrCFBzbEhQSm3IUGEvCFB3sEhQTbHIUGNzCFB49EhQTjXIUGL3CFB3uEhQS/nIUF/7CFBzfEhQRr3IUFn/CFBsgEiQfsGIkFEDCJBixEiQdEWIkEWHCJBWiEiQZwmIkHeKyJBHjEiQVw2IkGaOyJB10AiQRJGIkFMSyJBhVAiQb1VIkH0WiJBKWAiQV1lIkGQaiJBwm8iQfN0IkEjeiJBUX8iQX6EIkGqiSJB1Y4iQf+TIkEomSJBT54iQXWjIkGbqCJBv60iQeKyIkEDuCJBJL0iQUPCIkFixyJBf8wiQZvRIkG21iJB0NsiQejgIkEA5iJBFusiQSzwIkFA9SJBU/oiQWX/IkF2BCNBhQkjQZQOI0GiEyNBrhgjQbkdI0HEIiNBzScjQdUsI0HcMSNB4TYjQeY7I0HqQCNB7EUjQe5KI0HuTyNB7lQjQexZI0HpXiNB5WMjQeBoI0HabSNB03IjQct3I0HBfCNBt4EjQauGI0GfiyNBkZAjQYOVI0FzmiNBYp8jQVGkI0E+qSNBKq4jQRWzI0H/tyNB6LwjQdDBI0G3xiNBncsjQYHQI0Fl1SNBSNojQSrfI0EK5CNB6ugjQcntI0Gm8iNBg/cjQV78I0E5ASRBEgYkQesKJEHCDyRBmRQkQW4ZJEFDHiRBFiMkQeknJEG6LCRBijEkQVo2JEEoOyRB9j8kQcJEJEGNSSRBWE4kQSFTJEHqVyRBsVwkQXdhJEE9ZiRBAWskQcVvJEGHdCRBSXkkQQl+JEHJgiRBiIckQUWMJEECkSRBvpUkQXiaJEEynyRB66MkQaOoJEFZrSRBD7IkQcS2JEF4uyRBK8AkQd3EJEGOySRBPs4kQe7SJEGc1yRBSdwkQfbgJEGh5SRBS+okQfXuJEGd8yRBRfgkQez8JEGSASVBNgYlQdoKJUF9DyVBHxQlQcAYJUFhHSVBACIlQZ4mJUE7KyVB2C8lQXM0JUEOOSVBqD0lQUFCJUHZRiVBb0slQQZQJUGbVCVBL1klQcJdJUFVYiVB5mYlQXdrJUEHcCVBlXQlQSN5JUGwfSVBPIIlQciGJUFSiyVB248lQWSUJUHsmCVBcp0lQfihJUF9piVBAaslQYWvJUEHtCVBiLglQQm9JUGJwSVBCMYlQYbKJUEDzyVBf9MlQfrXJUF13CVB7uAlQWflJUHf6SVBVu4lQczyJUFB9yVBtvslQSkAJkGcBCZBDgkmQX8NJkHvESZBXhYmQc0aJkE6HyZBpyMmQRMoJkF+LCZB6DAmQVI1JkG6OSZBIj4mQYlCJkHvRiZBVEsmQbhPJkEcVCZBflgmQeBcJkFBYSZBoWUmQQFqJkFfbiZBvXImQRp3JkF2eyZB0X8mQSuEJkGFiCZB3owmQTWRJkGNlSZB45kmQTieJkGNoiZB4aYmQTSrJkGGryZB2LMmQSi4JkF4vCZBx8AmQRXFJkFjySZBr80mQfvRJkFG1iZBkNomQdreJkEi4yZBaucmQbHrJkH37yZBPfQmQYH4JkHF/CZBCAEnQUsFJ0GMCSdBzQ0nQQ0SJ0FMFidBihonQcgeJ0EFIydBQScnQXwrJ0G2LydB8DMnQSk4J0FhPCdBmUAnQc9EJ0EFSSdBOk0nQW9RJ0GiVSdB1VknQQdeJ0E4YidBaWYnQZlqJ0HIbidB9nInQSN3J0FQeydBfH8nQaeDJ0HShydB+4snQSSQJ0FMlCdBdJgnQZucJ0HBoCdB5qQnQQqpJ0EurSdBUbEnQXO1J0GVuSdBtr0nQdbBJ0H1xSdBFMonQTHOJ0FO0idBa9YnQYbaJ0Gh3idBvOInQdXmJ0Hu6idBBu8nQR3zJ0Ez9ydBSfsnQV7/J0FzAyhBhgcoQZkLKEGsDyhBvRMoQc4XKEHeGyhB7R8oQfwjKEEKKChBFywoQSQwKEEvNChBOjgoQUU8KEFOQChBV0QoQWBIKEFnTChBblAoQXRUKEF6WChBflwoQYNgKEGGZChBiWgoQYpsKEGMcChBjHQoQYx4KEGLfChBioAoQYiEKEGFiChBgYwoQX2QKEF4lChBcpgoQWycKEFloChBXaQoQVWoKEFMrChBQrAoQTi0KEEtuChBIbwoQRTAKEEHxChB+ccoQevLKEHczyhBzNMoQbzXKEGq2yhBmd8oQYbjKEFz5yhBX+soQUvvKEE18yhBIPcoQQn7KEHy/ihB2gIpQcIGKUGoCilBjw4pQXQSKUFZFilBPRopQSEeKUEEIilB5iUpQcgpKUGpLSlBiTEpQWk1KUFIOSlBJj0pQQRBKUHhRClBvUgpQZlMKUF0UClBT1QpQShYKUECXClB2l8pQbJjKUGJZylBYGspQTZvKUELcylB4HYpQbR6KUGIfilBW4IpQS2GKUH+iSlBz40pQZ+RKUFvlSlBPpkpQQ2dKUHaoClBqKQpQXSoKUFArClBC7ApQdazKUGgtylBabspQTK/KUH6wilBwsYpQYnKKUFPzilBFdIpQdrVKUGe2SlBYt0pQSbhKUHo5ClBqugpQWzsKUEs8ClB7fMpQaz3KUFr+ylBKv8pQecCKkGkBipBYQoqQR0OKkHYESpBkxUqQU0ZKkEHHSpBwCAqQXgkKkEwKCpB5ysqQZ0vKkFTMypBCTcqQb06KkFxPipBJUIqQdhFKkGKSSpBPE0qQe1QKkGeVCpBTlgqQf1bKkGsXypBWmMqQQhnKkG1aipBYm4qQQ5yKkG5dSpBZHkqQQ59KkG3gCpBYIQqQQmIKkGxiypBWI8qQf+SKkGllipBSpoqQe+dKkGToSpBN6UqQdqoKkF9rCpBH7AqQcGzKkFitypBArsqQaK+KkFBwipB4MUqQX7JKkEbzSpBuNAqQVXUKkHx1ypBjNsqQSffKkHB4ipBWuYqQfPpKkGM7SpBJPEqQbv0KkFS+CpB6PsqQX7/KkETAytBpwYrQTsKK0HPDStBYhErQfQUK0GGGCtBFxwrQagfK0E4IytBxyYrQVYqK0HlLStBczErQQA1K0GNOCtBGTwrQaU/K0EwQytBu0YrQUVKK0HPTStBWFErQeBUK0FoWCtB8FsrQXdfK0H9YitBg2YrQQhqK0GNbStBEXErQZV0K0EYeCtBmnsrQRx/K0GegitBH4YrQZ+JK0EfjStBn5ArQR2UK0GclytBGpsrQZeeK0EUoitBkKUrQQypK0GHrCtBAbArQXyzK0H1titBbrorQee9K0FfwStB1sQrQU3IK0HEyytBOs8rQa/SK0Ek1itBmdkrQQzdK0GA4CtB8+MrQWXnK0HX6itBSO4rQbnxK0Ep9StBmfgrQQj8K0F3/ytB5QIsQVMGLEHACSxBLQ0sQZkQLEEFFCxBcBcsQdsaLEFFHixBryEsQRglLEGBKCxB6SssQVAvLEG4MixBHjYsQYQ5LEHqPCxBT0AsQbRDLEEYRyxBfEosQd9NLEFBUSxBpFQsQQVYLEFnWyxBx14sQSdiLEGHZSxB5mgsQUVsLEGjbyxBAXMsQV52LEG7eSxBF30sQXOALEHOgyxBKYcsQYOKLEHdjSxBN5EsQY+ULEHolyxBQJssQZeeLEHuoSxBRKUsQZqoLEHwqyxBRa8sQZmyLEHttSxBQbksQZS8LEHnvyxBOcMsQYrGLEHcySxBLM0sQXzQLEHM0yxBG9csQWraLEG43SxBBuEsQVTkLEGh5yxB7eosQTnuLEGE8SxBz/QsQRr4LEFk+yxBrv4sQfcBLUE/BS1BiAgtQc8LLUEXDy1BXRItQaQVLUHqGC1BLxwtQXQfLUG4Ii1B/CUtQUApLUGDLC1Bxi8tQQgzLUFKNi1BizktQcw8LUEMQC1BTEMtQYtGLUHKSS1BCU0tQUdQLUGEUy1BwlYtQf5ZLUE7XS1BdmAtQbJjLUHtZi1BJ2otQWFtLUGacC1B1HMtQQx3LUFEei1BfH0tQbOALUHqgy1BIYctQVeKLUGMjS1BwZAtQfaTLUEqly1BXpotQZGdLUHEoC1B9qMtQSinLUFZqi1Biq0tQbuwLUHrsy1BG7ctQUq6LUF5vS1BqMAtQdbDLUEDxy1BMMotQV3NLUGJ0C1BtdMtQeDWLUEL2i1BNt0tQWDgLUGJ4y1BsuYtQdvpLUEE7S1BK/AtQVPzLUF69i1BofktQcf8LUHs/y1BEgMuQTcGLkFbCS5BfwwuQaMPLkHGEi5B6RUuQQsZLkEtHC5BTh8uQW8iLkGQJS5BsCguQdArLkHvLi5BDjIuQS01LkFLOC5BaTsuQYY+LkGjQS5Bv0QuQdtHLkH3Si5BEk4uQSxRLkFHVC5BYVcuQXpaLkGTXS5BrGAuQcRjLkHcZi5B82kuQQptLkEhcC5BN3MuQU12LkFieS5Bd3wuQYx/LkGggi5Bs4UuQceILkHaiy5B7I4uQf6RLkEQlS5BIZguQTKbLkFCni5BUqEuQWKkLkFxpy5BgKouQY6tLkGcsC5BqrMuQbe2LkHEuS5B0LwuQdy/LkHowi5B88UuQf7ILkEIzC5BEs8uQRzSLkEl1S5BLtguQTbbLkE+3i5BRuEuQU3kLkFU5y5BWuouQWDtLkFm8C5Ba/MuQXD2LkF0+S5BePwuQXz/LkF/Ai9BggUvQYQIL0GGCy9BiA4vQYkRL0GKFC9BixcvQYsaL0GKHS9BiiAvQYkjL0GHJi9BhSkvQYMsL0GALy9BfTIvQXo1L0F2OC9BcjsvQW4+L0FpQS9BY0QvQV5HL0FYSi9BUU0vQUpQL0FDUy9BO1YvQTNZL0ErXC9BIl8vQRliL0EQZS9BBmgvQftqL0HxbS9B5nAvQdpzL0HOdi9BwnkvQbZ8L0Gpfy9Bm4IvQY6FL0GAiC9BcYsvQWKOL0FTkS9BRJQvQTSXL0Ejmi9BE50vQQKgL0Hwoi9B3qUvQcyoL0G6qy9Bp64vQZSxL0GAtC9BbLcvQVe6L0FDvS9BLsAvQRjDL0ECxi9B7MgvQdXLL0G+zi9Bp9EvQY/UL0F31y9BX9ovQUbdL0Et4C9BE+MvQfnlL0Hf6C9BxesvQaruL0GO8S9BcvQvQVb3L0E6+i9BHf0vQQAAMEHiAjBBxQUwQaYIMEGICzBBaQ4wQUkRMEEqFDBBChcwQekZMEHJHDBBqB8wQYYiMEFkJTBBQigwQSArMEH9LTBB2TAwQbYzMEGSNjBBbjkwQUk8MEEkPzBB/kEwQdlEMEGzRzBBjEowQWVNMEE+UDBBF1MwQe9VMEHHWDBBnlswQXVeMEFMYTBBI2QwQflmMEHOaTBBpGwwQXlvMEFOcjBBInUwQfZ3MEHKejBBnX0wQXCAMEFCgzBBFYYwQeeIMEG4izBBiY4wQVqRMEErlDBB+5YwQcuZMEGanDBBap8wQTiiMEEHpTBB1acwQaOqMEFwrTBBPbAwQQqzMEHXtTBBo7gwQW67MEE6vjBBBcEwQdDDMEGaxjBBZMkwQS7MMEH3zjBBwNEwQYnUMEFS1zBBGtowQeHcMEGp3zBBcOIwQTflMEH95zBBw+owQYntMEFO8DBBE/MwQdj1MEGc+DBBYPswQST+MEHnADFBqwMxQW0GMUEwCTFB8gsxQbQOMUF1ETFBNhQxQfcWMUG3GTFBdxwxQTcfMUH3ITFBtiQxQXUnMUEzKjFB8SwxQa8vMUFsMjFBKjUxQeY3MUGjOjFBXz0xQRtAMUHXQjFBkkUxQU1IMUEHSzFBwk0xQXxQMUE1UzFB7lUxQadYMUFgWzFBGF4xQdBgMUGIYzFBP2YxQfZoMUGtazFBZG4xQRpxMUHPczFBhXYxQTp5MUHvezFBo34xQViBMUELhDFBv4YxQXKJMUEljDFB2I4xQYqRMUE8lDFB7pYxQZ+ZMUFQnDFBAZ8xQbGhMUFhpDFBEacxQcGpMUFwrDFBH68xQc2xMUF7tDFBKbcxQde5MUGEvDFBMb8xQd7BMUGKxDFBNscxQeLJMUGNzDFBOM8xQePRMUGO1DFBONcxQeLZMUGL3DFBNd8xQd7hMUGG5DFBL+cxQdfpMUF/7DFBJu8xQc3xMUF09DFBGvcxQcH5MUFn/DFBDP8xQbIBMkFXBDJB+wYyQaAJMkFEDDJB6A4yQYsRMkEuFDJB0RYyQXQZMkEWHDJBuB4yQVohMkH7IzJBnCYyQT0pMkHeKzJBfi4yQR4xMkG9MzJBXDYyQfs4MkGaOzJBOT4yQddAMkF1QzJBEkYyQa9IMkFMSzJB6U0yQYVQMkEhUzJBvVUyQVhYMkH0WjJBjl0yQSlgMkHDYjJBXWUyQfdnMkGQajJBKW0yQcJvMkFbcjJB83QyQYt3MkEjejJBunwyQVF/MkHogTJBfoQyQRSHMkGqiTJBQIwyQdWOMkFqkTJB/5MyQZOWMkEomTJBvJsyQU+eMkHioDJBdaMyQQimMkGbqDJBLasyQb+tMkFQsDJB4rIyQXO1MkEDuDJBlLoyQSS9MkG0vzJBQ8IyQdPEMkFixzJB8MkyQX/MMkENzzJBm9EyQSnUMkG21jJBQ9kyQdDbMkFc3jJB6OAyQXTjMkEA5jJBi+gyQRbrMkGh7TJBLPAyQbbyMkFA9TJByvcyQVP6MkHc/DJBZf8yQe0BM0F2BDNB/gYzQYUJM0ENDDNBlA4zQRsRM0GiEzNBKBYzQa4YM0E0GzNBuR0zQT8gM0HEIjNBSCUzQc0nM0FRKjNB1SwzQVgvM0HcMTNBXzQzQeE2M0FkOTNB5jszQWg+M0HqQDNBa0MzQexFM0FtSDNB7kozQW5NM0HuTzNBblIzQe5UM0FtVzNB7FkzQWpcM0HpXjNBZ2EzQeVjM0FjZjNB4GgzQV1rM0HabTNBVnAzQdNyM0FPdTNBy3czQUZ6M0HBfDNBPH8zQbeBM0ExhDNBq4YzQSWJM0GfizNBGI4zQZGQM0EKkzNBg5UzQfuXM0FzmjNB65wzQWKfM0HaoTNBUaQzQcemM0E+qTNBtKszQSquM0GgsDNBFbMzQYq1M0H/tzNBdLozQei8M0FcvzNB0MEzQUTEM0G3xjNBKskzQZ3LM0EPzjNBgdAzQfTSM0Fl1TNB19czQUjaM0G53DNBKt8zQZrhM0EK5DNBeuYzQeroM0FZ6zNBye0zQTjwM0Gm8jNBFfUzQYP3M0Hx+TNBXvwzQcz+M0E5ATRBpgM0QRIGNEF/CDRB6wo0QVcNNEHCDzRBLhI0QZkUNEEEFzRBbhk0QdkbNEFDHjRBrSA0QRYjNEF/JTRB6Sc0QVEqNEG6LDRBIi80QYoxNEHyMzRBWjY0QcE4NEEoOzRBjz00QfY/NEFcQjRBwkQ0QShHNEGNSTRB80s0QVhONEG9UDRBIVM0QYZVNEHqVzRBTVo0QbFcNEEUXzRBd2E0QdpjNEE9ZjRBn2g0QQFrNEFjbTRBxW80QSZyNEGHdDRB6HY0QUl5NEGpezRBCX40QWmANEHJgjRBKIU0QYiHNEHniTRBRYw0QaSONEECkTRBYJM0Qb6VNEEbmDRBeJo0QdWcNEEynzRBj6E0QeujNEFHpjRBo6g0Qf6qNEFZrTRBta80QQ+yNEFqtDRBxLY0QR65NEF4uzRB0r00QSvANEGEwjRB3cQ0QTbHNEGOyTRB58s0QT7ONEGW0DRB7tI0QUXVNEGc1zRB89k0QUncNEGf3jRB9uA0QUvjNEGh5TRB9uc0QUvqNEGg7DRB9e40QUnxNEGd8zRB8fU0QUX4NEGZ+jRB7Pw0QT//NEGSATVB5AM1QTYGNUGICDVB2go1QSwNNUF9DzVBzhE1QR8UNUFwFjVBwBg1QREbNUFhHTVBsB81QQAiNUFPJDVBniY1Qe0oNUE7KzVBii01QdgvNUEmMjVBczQ1QcE2NUEOOTVBWzs1Qag9NUH0PzVBQUI1QY1ENUHZRjVBJEk1QW9LNUG7TTVBBlA1QVBSNUGbVDVB5VY1QS9ZNUF5WzVBwl01QQxgNUFVYjVBnmQ1QeZmNUEvaTVBd2s1Qb9tNUEHcDVBTnI1QZV0NUHcdjVBI3k1QWp7NUGwfTVB9n81QTyCNUGChDVByIY1QQ2JNUFSizVBl401QduPNUEgkjVBZJQ1QaiWNUHsmDVBL5s1QXKdNUG1nzVB+KE1QTukNUF9pjVBv6g1QQGrNUFDrTVBha81QcaxNUEHtDVBSLY1QYi4NUHJujVBCb01QUm/NUGJwTVByMM1QQjGNUFHyDVBhso1QcTMNUEDzzVBQdE1QX/TNUG91TVB+tc1QTjaNUF13DVBst41Qe7gNUEr4zVBZ+U1QaPnNUHf6TVBG+w1QVbuNUGR8DVBzPI1QQf1NUFB9zVBfPk1Qbb7NUHw/TVBKQA2QWMCNkGcBDZB1QY2QQ4JNkFHCzZBfw02QbcPNkHvETZBJxQ2QV4WNkGWGDZBzRo2QQQdNkE6HzZBcSE2QacjNkHdJTZBEyg2QUkqNkF+LDZBsy42QegwNkEdMzZBUjU2QYY3NkG6OTZB7js2QSI+NkFVQDZBiUI2QbxENkHvRjZBIUk2QVRLNkGGTTZBuE82QepRNkEcVDZBTVY2QX5YNkGvWjZB4Fw2QRFfNkFBYTZBcWM2QaFlNkHRZzZBAWo2QTBsNkFfbjZBjnA2Qb1yNkHrdDZBGnc2QUh5NkF2ezZBo302QdF/NkH+gTZBK4Q2QViGNkGFiDZBsYo2Qd6MNkEKjzZBNZE2QWGTNkGNlTZBuJc2QeOZNkEOnDZBOJ42QWOgNkGNojZBt6Q2QeGmNkEKqTZBNKs2QV2tNkGGrzZBr7E2QdizNkEAtjZBKLg2QVC6NkF4vDZBoL42QcfANkHuwjZBFcU2QTzHNkFjyTZBics2Qa/NNkHVzzZB+9E2QSHUNkFG1jZBa9g2QZDaNkG13DZB2t42Qf7gNkEi4zZBRuU2QWrnNkGO6TZBses2QdTtNkH37zZBGvI2QT30NkFf9jZBgfg2QaP6NkHF/DZB5/42QQgBN0EqAzdBSwU3QWsHN0GMCTdBrQs3Qc0NN0HtDzdBDRI3QSwUN0FMFjdBaxg3QYoaN0GpHDdByB43QeYgN0EFIzdBIyU3QUEnN0FeKTdBfCs3QZktN0G2LzdB0zE3QfAzN0ENNjdBKTg3QUU6N0FhPDdBfT43QZlAN0G0QjdBz0Q3QepGN0EFSTdBIEs3QTpNN0FVTzdBb1E3QYhTN0GiVTdBvFc3QdVZN0HuWzdBB143QSBgN0E4YjdBUWQ3QWlmN0GBaDdBmWo3QbBsN0HIbjdB33A3QfZyN0ENdTdBI3c3QTp5N0FQezdBZn03QXx/N0GSgTdBp4M3QbyFN0HShzdB54k3QfuLN0EQjjdBJJA3QTiSN0FMlDdBYJY3QXSYN0GHmjdBm5w3Qa6eN0HBoDdB06I3QeakN0H4pjdBCqk3QRyrN0EurTdBQK83QVGxN0FiszdBc7U3QYS3N0GVuTdBpbs3Qba9N0HGvzdB1sE3QeXDN0H1xTdBBMg3QRTKN0EjzDdBMc43QUDQN0FO0jdBXdQ3QWvWN0F52DdBhto3QZTcN0Gh3jdBr+A3QbziN0HI5DdB1eY3QeHoN0Hu6jdB+uw3QQbvN0ER8TdBHfM3QSj1N0Ez9zdBPvk3QUn7N0FU/TdBXv83QWkBOEFzAzhBfQU4QYYHOEGQCThBmQs4QaMNOEGsDzhBtBE4Qb0TOEHGFThBzhc4QdYZOEHeGzhB5h04Qe0fOEH1IThB/CM4QQMmOEEKKDhBESo4QRcsOEEdLjhBJDA4QSoyOEEvNDhBNTY4QTo4OEFAOjhBRTw4QUo+OEFOQDhBU0I4QVdEOEFcRjhBYEg4QWRKOEFnTDhBa044QW5QOEFxUjhBdFQ4QXdWOEF6WDhBfFo4QX5cOEGBXjhBg2A4QYRiOEGGZDhBh2Y4QYloOEGKajhBimw4QYtuOEGMcDhBjHI4QYx0OEGMdjhBjHg4QYx6OEGLfDhBi344QYqAOEGJgjhBiIQ4QYaGOEGFiDhBg4o4QYGMOEF/jjhBfZA4QXuSOEF4lDhBdZY4QXKYOEFvmjhBbJw4QWmeOEFloDhBYaI4QV2kOEFZpjhBVag4QVCqOEFMrDhBR644QUKwOEE9sjhBOLQ4QTK2OEEtuDhBJ7o4QSG8OEEbvjhBFMA4QQ7COEEHxDhBAMY4QfnHOEHyyThB68s4QeTNOEHczzhB1NE4QczTOEHE1ThBvNc4QbPZOEGq2zhBot04QZnfOEGP4ThBhuM4QX3lOEFz5zhBaek4QV/rOEFV7ThBS+84QUDxOEE18zhBK/U4QSD3OEEU+ThBCfs4Qf78OEHy/jhB5gA5QdoCOUHOBDlBwgY5QbUIOUGoCjlBnAw5QY8OOUGCEDlBdBI5QWcUOUFZFjlBSxg5QT0aOUEvHDlBIR45QRIgOUEEIjlB9SM5QeYlOUHXJzlByCk5QbgrOUGpLTlBmS85QYkxOUF5MzlBaTU5QVg3OUFIOTlBNzs5QSY9OUEVPzlBBEE5QfJCOUHhRDlBz0Y5Qb1IOUGrSjlBmUw5QYdOOUF0UDlBYVI5QU9UOUE8VjlBKFg5QRVaOUECXDlB7l05QdpfOUHGYTlBsmM5QZ5lOUGJZzlBdWk5QWBrOUFLbTlBNm85QSFxOUELczlB9nQ5QeB2OUHKeDlBtHo5QZ58OUGIfjlBcYA5QVuCOUFEhDlBLYY5QRaIOUH+iTlB54s5Qc+NOUG3jzlBn5E5QYeTOUFvlTlBV5c5QT6ZOUElmzlBDZ05QfSeOUHaoDlBwaI5QaikOUGOpjlBdKg5QVqqOUFArDlBJq45QQuwOUHxsTlB1rM5Qbu1OUGgtzlBhbk5QWm7OUFOvTlBMr85QRbBOUH6wjlB3sQ5QcLGOUGlyDlBico5QWzMOUFPzjlBMtA5QRXSOUH40zlB2tU5QbzXOUGe2TlBgNs5QWLdOUFE3zlBJuE5QQfjOUHo5DlByeY5QaroOUGL6jlBbOw5QUzuOUEs8DlBDfI5Qe3zOUHM9TlBrPc5QYz5OUFr+zlBSv05QSr/OUEIATpB5wI6QcYEOkGkBjpBgwg6QWEKOkE/DDpBHQ46QfsPOkHYETpBthM6QZMVOkFwFzpBTRk6QSobOkEHHTpB4x46QcAgOkGcIjpBeCQ6QVQmOkEwKDpBCyo6QecrOkHCLTpBnS86QXgxOkFTMzpBLjU6QQk3OkHjODpBvTo6QZc8OkFxPjpBS0A6QSVCOkH/QzpB2EU6QbFHOkGKSTpBY0s6QTxNOkEVTzpB7VA6QcZSOkGeVDpBdlY6QU5YOkEmWjpB/Vs6QdVdOkGsXzpBg2E6QVpjOkExZTpBCGc6Qd9oOkG1ajpBi2w6QWJuOkE4cDpBDnI6QeNzOkG5dTpBjnc6QWR5OkE5ezpBDn06QeN+OkG3gDpBjII6QWCEOkE1hjpBCYg6Qd2JOkGxizpBhI06QViPOkErkTpB/5I6QdKUOkGlljpBd5g6QUqaOkEdnDpB7506QcGfOkGToTpBZaM6QTelOkEJpzpB2qg6QayqOkF9rDpBTq46QR+wOkHwsTpBwbM6QZG1OkFitzpBMrk6QQK7OkHSvDpBor46QXLAOkFBwjpBEMQ6QeDFOkGvxzpBfsk6QU3LOkEbzTpB6s46QbjQOkGH0jpBVdQ6QSPWOkHx1zpBvtk6QYzbOkFZ3TpBJ986QfTgOkHB4jpBjuQ6QVrmOkEn6DpB8+k6QcDrOkGM7TpBWO86QSTxOkHv8jpBu/Q6QYb2OkFS+DpBHfo6Qej7OkGz/TpBfv86QUgBO0ETAztB3QQ7QacGO0FxCDtBOwo7QQUMO0HPDTtBmA87QWIRO0ErEztB9BQ7Qb0WO0GGGDtBTho7QRccO0HfHTtBqB87QXAhO0E4IztBACU7QccmO0GPKDtBVio7QR4sO0HlLTtBrC87QXMxO0E6MztBADU7Qcc2O0GNODtBUzo7QRk8O0HfPTtBpT87QWtBO0EwQztB9kQ7QbtGO0GASDtBRUo7QQpMO0HPTTtBk087QVhRO0EcUztB4FQ7QaRWO0FoWDtBLFo7QfBbO0GzXTtBd187QTphO0H9YjtBwGQ7QYNmO0FFaDtBCGo7QcprO0GNbTtBT287QRFxO0HTcjtBlXQ7QVZ2O0EYeDtB2Xk7QZp7O0FbfTtBHH87Qd2AO0GegjtBXoQ7QR+GO0HfhztBn4k7QV+LO0EfjTtB3447QZ+QO0FekjtBHZQ7Qd2VO0GclztBW5k7QRqbO0HYnDtBl547QVWgO0EUojtB0qM7QZClO0FOpztBDKk7QcmqO0GHrDtBRK47QQGwO0G/sTtBfLM7QTi1O0H1tjtBsrg7QW66O0ErvDtB5707QaO/O0FfwTtBG8M7QdbEO0GSxjtBTcg7QQnKO0HEyztBf807QTrPO0H10DtBr9I7QWrUO0Ek1jtB3tc7QZnZO0FT2ztBDN07QcbeO0GA4DtBOeI7QfPjO0Gs5TtBZec7QR7pO0HX6jtBkOw7QUjuO0EB8DtBufE7QXHzO0Ep9TtB4fY7QZn4O0FR+jtBCPw7QcD9O0F3/ztBLgE8QeUCPEGcBDxBUwY8QQoIPEHACTxBdws8QS0NPEHjDjxBmRA8QU8SPEEFFDxBuxU8QXAXPEEmGTxB2xo8QZAcPEFFHjxB+h88Qa8hPEFjIzxBGCU8QcwmPEGBKDxBNSo8QekrPEGdLTxBUC88QQQxPEG4MjxBazQ8QR42PEHRNzxBhDk8QTc7PEHqPDxBnT48QU9APEECQjxBtEM8QWZFPEEYRzxBykg8QXxKPEEtTDxB3008QZBPPEFBUTxB81I8QaRUPEFVVjxBBVg8QbZZPEFnWzxBF108QcdePEF3YDxBJ2I8QddjPEGHZTxBN2c8QeZoPEGWajxBRWw8QfRtPEGjbzxBUnE8QQFzPEGwdDxBXnY8QQ14PEG7eTxBaXs8QRd9PEHFfjxBc4A8QSGCPEHOgzxBfIU8QSmHPEHWiDxBg4o8QTCMPEHdjTxBio88QTeRPEHjkjxBj5Q8QTyWPEHolzxBlJk8QUCbPEHrnDxBl548QUOgPEHuoTxBmaM8QUSlPEHwpjxBmqg8QUWqPEHwqzxBmq08QUWvPEHvsDxBmbI8QUO0PEHttTxBl7c8QUG5PEHrujxBlLw8QT2+PEHnvzxBkME8QTnDPEHixDxBisY8QTPIPEHcyTxBhMs8QSzNPEHUzjxBfNA8QSTSPEHM0zxBdNU8QRvXPEHD2DxBato8QRHcPEG43TxBX988QQbhPEGt4jxBVOQ8QfrlPEGh5zxBR+k8Qe3qPEGT7DxBOe48Qd/vPEGE8TxBKvM8Qc/0PEF19jxBGvg8Qb/5PEFk+zxBCf08Qa7+PEFSAD1B9wE9QZsDPUE/BT1B5AY9QYgIPUEsCj1Bzws9QXMNPUEXDz1BuhA9QV0SPUEBFD1BpBU9QUcXPUHqGD1BjBo9QS8cPUHSHT1BdB89QRYhPUG4Ij1BWyQ9QfwlPUGeJz1BQCk9QeIqPUGDLD1BJS49QcYvPUFnMT1BCDM9Qak0PUFKNj1B6jc9QYs5PUErOz1BzDw9QWw+PUEMQD1BrEE9QUxDPUHsRD1Bi0Y9QStIPUHKST1Baks9QQlNPUGoTj1BR1A9QeZRPUGEUz1BI1U9QcJWPUFgWD1B/lk9QZxbPUE7XT1B2V49QXZgPUEUYj1BsmM9QU9lPUHtZj1Bimg9QSdqPUHEaz1BYW09Qf5uPUGacD1BN3I9QdRzPUFwdT1BDHc9Qah4PUFEej1B4Hs9QXx9PUEYfz1Bs4A9QU+CPUHqgz1BhYU9QSGHPUG8iD1BV4o9QfGLPUGMjT1BJ489QcGQPUFbkj1B9pM9QZCVPUEqlz1BxJg9QV6aPUH3mz1BkZ09QSqfPUHEoD1BXaI9QfajPUGPpT1BKKc9QcGoPUFZqj1B8qs9QYqtPUEjrz1Bu7A9QVOyPUHrsz1Bg7U9QRu3PUGzuD1BSro9QeK7PUF5vT1BEL89QajAPUE/wj1B1sM9QWzFPUEDxz1Bmsg9QTDKPUHHyz1BXc09QfPOPUGJ0D1BH9I9QbXTPUFL1T1B4NY9QXbYPUEL2j1BoNs9QTbdPUHL3j1BYOA9QfXhPUGJ4z1BHuU9QbLmPUFH6D1B2+k9QW/rPUEE7T1BmO49QSvwPUG/8T1BU/M9Qeb0PUF69j1BDfg9QaH5PUE0+z1Bx/w9QVr+PUHs/z1BfwE+QRIDPkGkBD5BNwY+QckHPkFbCT5B7Qo+QX8MPkERDj5Bow8+QTQRPkHGEj5BVxQ+QekVPkF6Fz5BCxk+QZwaPkEtHD5Bvh0+QU4fPkHfID5BbyI+QQAkPkGQJT5BICc+QbAoPkFAKj5B0Cs+QWAtPkHvLj5BfzA+QQ4yPkGeMz5BLTU+Qbw2PkFLOD5B2jk+QWk7PkH3PD5Bhj4+QRRAPkGjQT5BMUM+Qb9EPkFNRj5B20c+QWlJPkH3Sj5BhEw+QRJOPkGfTz5BLFE+QbpSPkFHVD5B1FU+QWFXPkHtWD5Belo+QQdcPkGTXT5BIF8+QaxgPkE4Yj5BxGM+QVBlPkHcZj5BaGg+QfNpPkF/az5BCm0+QZZuPkEhcD5BrHE+QTdzPkHCdD5BTXY+Qdh3PkFieT5B7Xo+QXd8PkEBfj5BjH8+QRaBPkGggj5BKoQ+QbOFPkE9hz5Bx4g+QVCKPkHaiz5BY40+QeyOPkF1kD5B/pE+QYeTPkEQlT5BmJY+QSGYPkGpmT5BMps+QbqcPkFCnj5Byp8+QVKhPkHaoj5BYqQ+QeqlPkFxpz5B+ag+QYCqPkEHrD5Bjq0+QRWvPkGcsD5BI7I+QaqzPkExtT5Bt7Y+QT64PkHEuT5BSrs+QdC8PkFWvj5B3L8+QWLBPkHowj5BbsQ+QfPFPkF4xz5B/sg+QYPKPkEIzD5Bjc0+QRLPPkGX0D5BHNI+QaDTPkEl1T5BqdY+QS7YPkGy2T5BNts+QbrcPkE+3j5Bwt8+QUbhPkHJ4j5BTeQ+QdDlPkFU5z5B1+g+QVrqPkHd6z5BYO0+QePuPkFm8D5B6PE+QWvzPkHt9D5BcPY+QfL3PkF0+T5B9vo+QXj8PkH6/T5BfP8+Qf0AP0F/Aj9BAAQ/QYIFP0EDBz9BhAg/QQUKP0GGCz9BBw0/QYgOP0EJED9BiRE/QQoTP0GKFD9BChY/QYsXP0ELGT9Bixo/QQscP0GKHT9BCh8/QYogP0EJIj9BiSM/QQglP0GHJj9BBig/QYUpP0EEKz9Bgyw/QQIuP0GALz9B/zA/QX0yP0H8Mz9BejU/Qfg2P0F2OD9B9Dk/QXI7P0HwPD9Bbj4/Qes/P0FpQT9B5kI/QWNEP0HhRT9BXkc/QdtIP0FYSj9B1Es/QVFNP0HOTj9BSlA/QcdRP0FDUz9Bv1Q/QTtWP0G3Vz9BM1k/Qa9aP0ErXD9Bp10/QSJfP0GeYD9BGWI/QZRjP0EQZT9Bi2Y/QQZoP0GBaT9B+2o/QXZsP0HxbT9Ba28/QeZwP0Fgcj9B2nM/QVR1P0HOdj9BSHg/QcJ5P0E8ez9Btnw/QS9+P0Gpfz9BIoE/QZuCP0EVhD9BjoU/QQeHP0GAiD9B+Yk/QXGLP0HqjD9BYo4/QduPP0FTkT9BzJI/QUSUP0G8lT9BNJc/QayYP0Ejmj9Bm5s/QROdP0GKnj9BAqA/QXmhP0Hwoj9BZ6Q/Qd6lP0FVpz9BzKg/QUOqP0G6qz9BMK0/QaeuP0EdsD9BlLE/QQqzP0GAtD9B9rU/QWy3P0HiuD9BV7o/Qc27P0FDvT9BuL4/QS7AP0GjwT9BGMM/QY3EP0ECxj9Bd8c/QezIP0Fhyj9B1cs/QUrNP0G+zj9BM9A/QafRP0Eb0z9Bj9Q/QQPWP0F31z9B69g/QV/aP0HS2z9BRt0/QbneP0Et4D9BoOE/QRPjP0GG5D9B+eU/QWznP0Hf6D9BUuo/QcXrP0E37T9Bqu4/QRzwP0GO8T9BAPM/QXL0P0Hk9T9BVvc/Qcj4P0E6+j9BrPs/QR39P0GP/j9BAABAQXEBQEHiAkBBVARAQcUFQEE2B0BBpghAQRcKQEGIC0BB+AxAQWkOQEHZD0BBSRFAQboSQEEqFEBBmhVAQQoXQEF6GEBB6RlAQVkbQEHJHEBBOB5AQagfQEEXIUBBhiJAQfUjQEFkJUBB0yZAQUIoQEGxKUBBICtAQY4sQEH9LUBBay9AQdkwQEFIMkBBtjNAQSQ1QEGSNkBBADhAQW45QEHbOkBBSTxAQbY9QEEkP0BBkUBAQf5BQEFsQ0BB2URAQUZGQEGzR0BBIElAQYxKQEH5S0BBZU1AQdJOQEE+UEBBq1FAQRdTQEGDVEBB71VAQVtXQEHHWEBBM1pAQZ5bQEEKXUBBdV5AQeFfQEFMYUBBt2JAQSNkQEGOZUBB+WZAQWRoQEHOaUBBOWtAQaRsQEEObkBBeW9AQeNwQEFOckBBuHNAQSJ1QEGMdkBB9ndAQWB5QEHKekBBM3xAQZ19QEEGf0BBcIBAQdmBQEFCg0BBrIRAQRWGQEF+h0BB54hAQU+KQEG4i0BBIY1AQYmOQEHyj0BBWpFAQcOSQEErlEBBk5VAQfuWQEFjmEBBy5lAQTObQEGanEBBAp5AQWqfQEHRoEBBOKJAQaCjQEEHpUBBbqZAQdWnQEE8qUBBo6pAQQqsQEFwrUBB165AQT2wQEGksUBBCrNAQXC0QEHXtUBBPbdAQaO4QEEJukBBbrtAQdS8QEE6vkBBn79AQQXBQEFqwkBB0MNAQTXFQEGaxkBB/8dAQWTJQEHJykBBLsxAQZPNQEH3zkBBXNBAQcDRQEEl00BBidRAQe3VQEFS10BBtthAQRraQEF+20BB4dxAQUXeQEGp30BBDOFAQXDiQEHT40BBN+VAQZrmQEH950BBYOlAQcPqQEEm7EBBie1AQevuQEFO8EBBsfFAQRPzQEF29EBB2PVAQTr3QEGc+EBB/vlAQWD7QEHC/EBBJP5AQYb/QEHnAEFBSQJBQasDQUEMBUFBbQZBQc8HQUEwCUFBkQpBQfILQUFTDUFBtA5BQRQQQUF1EUFB1hJBQTYUQUGWFUFB9xZBQVcYQUG3GUFBFxtBQXccQUHXHUFBNx9BQZcgQUH3IUFBViNBQbYkQUEVJkFBdSdBQdQoQUEzKkFBkitBQfEsQUFQLkFBry9BQQ4xQUFsMkFByzNBQSo1QUGINkFB5jdBQUU5QUGjOkFBATxBQV89QUG9PkFBG0BBQXlBQUHXQkFBNERBQZJFQUHvRkFBTUhBQapJQUEHS0FBZExBQcJNQUEfT0FBfFBBQdhRQUE1U0FBklRBQe5VQUFLV0FBp1hBQQRaQUFgW0FBvFxBQRheQUF0X0FB0GBBQSxiQUGIY0FB5GRBQT9mQUGbZ0FB9mhBQVJqQUGta0FBCG1BQWRuQUG/b0FBGnFBQXVyQUHPc0FBKnVBQYV2QUHgd0FBOnlBQZV6QUHve0FBSX1BQaN+QUH+f0FBWIFBQbKCQUELhEFBZYVBQb+GQUEZiEFBcolBQcyKQUEljEFBf41BQdiOQUExkEFBipFBQeOSQUE8lEFBlZVBQe6WQUFGmEFBn5lBQfiaQUFQnEFBqZ1BQQGfQUFZoEFBsaFBQQmjQUFhpEFBuaVBQRGnQUFpqEFBwalBQRirQUFwrEFBx61BQR+vQUF2sEFBzbFBQSSzQUF7tEFB0rVBQSm3QUGAuEFB17lBQS67QUGEvEFB271BQTG/QUGHwEFB3sFBQTTDQUGKxEFB4MVBQTbHQUGMyEFB4slBQTjLQUGNzEFB481BQTjPQUGO0EFB49FBQTnTQUGO1EFB49VBQTjXQUGN2EFB4tlBQTfbQUGL3EFB4N1BQTXfQUGJ4EFB3uFBQTLjQUGG5EFB2+VBQS/nQUGD6EFB1+lBQSvrQUF/7EFB0u1BQSbvQUF68EFBzfFBQSHzQUF09EFBx/VBQRr3QUFu+EFBwflBQRT7QUFn/EFBuf1BQQz/QUFfAEJBsgFCQQQDQkFXBEJBqQVCQfsGQkFOCEJBoAlCQfIKQkFEDEJBlg1CQegOQkE5EEJBixFCQd0SQkEuFEJBgBVCQdEWQkEiGEJBdBlCQcUaQkEWHEJBZx1CQbgeQkEJIEJBWiFCQaoiQkH7I0JBTCVCQZwmQkHtJ0JBPSlCQY0qQkHeK0JBLi1CQX4uQkHOL0JBHjFCQW0yQkG9M0JBDTVCQVw2QkGsN0JB+zhCQUs6QkGaO0JB6TxCQTk+QkGIP0JB10BCQSZCQkF1Q0JBw0RCQRJGQkFhR0JBr0hCQf5JQkFMS0JBm0xCQelNQkE3T0JBhVBCQdNRQkEhU0JBb1RCQb1VQkELV0JBWFhCQaZZQkH0WkJBQVxCQY5dQkHcXkJBKWBCQXZhQkHDYkJBEGRCQV1lQkGqZkJB92dCQURpQkGQakJB3WtCQSltQkF2bkJBwm9CQQ9xQkFbckJBp3NCQfN0QkE/dkJBi3dCQdd4QkEjekJBbntCQbp8QkEFfkJBUX9CQZyAQkHogUJBM4NCQX6EQkHJhUJBFIdCQV+IQkGqiUJB9YpCQUCMQkGLjUJB1Y5CQSCQQkFqkUJBtZJCQf+TQkFJlUJBk5ZCQd6XQkEomUJBcppCQbybQkEFnUJBT55CQZmfQkHioEJBLKJCQXWjQkG/pEJBCKZCQVGnQkGbqEJB5KlCQS2rQkF2rEJBv61CQQevQkFQsEJBmbFCQeKyQkEqtEJBc7VCQbu2QkEDuEJBTLlCQZS6QkHcu0JBJL1CQWy+QkG0v0JB/MBCQUPCQkGLw0JB08RCQRrGQkFix0JBqchCQfDJQkE4y0JBf8xCQcbNQkENz0JBVNBCQZvRQkHi0kJBKdRCQW/VQkG21kJB/NdCQUPZQkGJ2kJB0NtCQRbdQkFc3kJBot9CQejgQkEu4kJBdONCQbrkQkEA5kJBRudCQYvoQkHR6UJBFutCQVzsQkGh7UJB5u5CQSzwQkFx8UJBtvJCQfvzQkFA9UJBhfZCQcr3QkEO+UJBU/pCQZj7QkHc/EJBIf5CQWX/QkGpAENB7QFDQTIDQ0F2BENBugVDQf4GQ0FCCENBhQlDQckKQ0ENDENBUQ1DQZQOQ0HYD0NBGxFDQV4SQ0GiE0NB5RRDQSgWQ0FrF0NBrhhDQfEZQ0E0G0NBdxxDQbkdQ0H8HkNBPyBDQYEhQ0HEIkNBBiRDQUglQ0GLJkNBzSdDQQ8pQ0FRKkNBkytDQdUsQ0EXLkNBWC9DQZowQ0HcMUNBHTNDQV80Q0GgNUNB4TZDQSM4Q0FkOUNBpTpDQeY7Q0EnPUNBaD5DQak/Q0HqQENBK0JDQWtDQ0GsRENB7EVDQS1HQ0FtSENBrklDQe5KQ0EuTENBbk1DQa5OQ0HuT0NBLlFDQW5SQ0GuU0NB7lRDQS1WQ0FtV0NBrFhDQexZQ0ErW0NBalxDQapdQ0HpXkNBKGBDQWdhQ0GmYkNB5WNDQSRlQ0FjZkNBoWdDQeBoQ0EfakNBXWtDQZxsQ0HabUNBGG9DQVZwQ0GVcUNB03JDQRF0Q0FPdUNBjXZDQct3Q0EIeUNBRnpDQYR7Q0HBfENB/31DQTx/Q0F6gENBt4FDQfSCQ0ExhENBboVDQauGQ0Hoh0NBJYlDQWKKQ0Gfi0NB3IxDQRiOQ0FVj0NBkZBDQc6RQ0EKk0NBR5RDQYOVQ0G/lkNB+5dDQTeZQ0FzmkNBr5tDQeucQ0EnnkNBYp9DQZ6gQ0HaoUNBFaNDQVGkQ0GMpUNBx6ZDQQOoQ0E+qUNBeapDQbSrQ0HvrENBKq5DQWWvQ0GgsENB2rFDQRWzQ0FQtENBirVDQcW2Q0H/t0NBOblDQXS6Q0Guu0NB6LxDQSK+Q0Fcv0NBlsBDQdDBQ0EKw0NBRMRDQX3FQ0G3xkNB8MdDQSrJQ0FjykNBnctDQdbMQ0EPzkNBSM9DQYHQQ0G70UNB9NJDQSzUQ0Fl1UNBntZDQdfXQ0EP2UNBSNpDQYHbQ0G53ENB8d1DQSrfQ0Fi4ENBmuFDQdLiQ0EK5ENBQuVDQXrmQ0Gy50NB6uhDQSLqQ0FZ60NBkexDQcntQ0EA70NBOPBDQW/xQ0Gm8kNB3vNDQRX1Q0FM9kNBg/dDQbr4Q0Hx+UNBKPtDQV78Q0GV/UNBzP5DQQIAREE5AURBbwJEQaYDREHcBERBEgZEQUkHREF/CERBtQlEQesKREEhDERBVw1EQY0OREHCD0RB+BBEQS4SREFjE0RBmRREQc4VREEEF0RBORhEQW4ZREGjGkRB2RtEQQ4dREFDHkRBeB9EQa0gREHhIURBFiNEQUskREF/JURBtCZEQeknREEdKURBUSpEQYYrREG6LERB7i1EQSIvREFWMERBijFEQb4yREHyM0RBJjVEQVo2REGNN0RBwThEQfU5REEoO0RBXDxEQY89REHCPkRB9j9EQSlBREFcQkRBj0NEQcJEREH1RURBKEdEQVtIREGNSURBwEpEQfNLREElTURBWE5EQYpPREG9UERB71FEQSFTREFTVERBhlVEQbhWREHqV0RBHFlEQU1aREF/W0RBsVxEQeNdREEUX0RBRmBEQXdhREGpYkRB2mNEQQxlREE9ZkRBbmdEQZ9oREHQaURBAWtEQTJsREFjbURBlG5EQcVvREH2cERBJnJEQVdzREGHdERBuHVEQeh2REEZeERBSXlEQXl6REGpe0RB2XxEQQl+REE5f0RBaYBEQZmBREHJgkRB+YNEQSiFREFYhkRBiIdEQbeIREHniURBFotEQUWMREF1jURBpI5EQdOPREECkURBMZJEQWCTREGPlERBvpVEQeyWREEbmERBSplEQXiaREGnm0RB1ZxEQQSeREEyn0RBYKBEQY+hREG9okRB66NEQRmlREFHpkRBdadEQaOoREHQqURB/qpEQSysREFZrURBh65EQbWvREHisERBD7JEQT2zREFqtERBl7VEQcS2REHxt0RBHrlEQUu6REF4u0RBpbxEQdK9REH/vkRBK8BEQVjBREGEwkRBscNEQd3EREEKxkRBNsdEQWLIREGOyURBuspEQefLREETzURBPs5EQWrPREGW0ERBwtFEQe7SREEZ1ERBRdVEQXDWREGc10RBx9hEQfPZREEe20RBSdxEQXTdREGf3kRBy99EQfbgREEg4kRBS+NEQXbkREGh5URBzOZEQfbnREEh6URBS+pEQXbrREGg7ERBy+1EQfXuREEf8ERBSfFEQXPyREGd80RBx/REQfH1REEb90RBRfhEQW/5REGZ+kRBwvtEQez8REEV/kRBP/9EQWgARUGSAUVBuwJFQeQDRUENBUVBNgZFQV8HRUGICEVBsQlFQdoKRUEDDEVBLA1FQVUORUF9D0VBphBFQc4RRUH3EkVBHxRFQUgVRUFwFkVBmBdFQcAYRUHoGUVBERtFQTkcRUFhHUVBiB5FQbAfRUHYIEVBACJFQScjRUFPJEVBdyVFQZ4mRUHGJ0VB7ShFQRQqRUE7K0VBYyxFQYotRUGxLkVB2C9FQf8wRUEmMkVBTTNFQXM0RUGaNUVBwTZFQeg3RUEOOUVBNTpFQVs7RUGBPEVBqD1FQc4+RUH0P0VBG0FFQUFCRUFnQ0VBjURFQbNFRUHZRkVB/kdFQSRJRUFKSkVBb0tFQZVMRUG7TUVB4E5FQQZQRUErUUVBUFJFQXZTRUGbVEVBwFVFQeVWRUEKWEVBL1lFQVRaRUF5W0VBnlxFQcJdRUHnXkVBDGBFQTBhRUFVYkVBeWNFQZ5kRUHCZUVB5mZFQQpoRUEvaUVBU2pFQXdrRUGbbEVBv21FQeNuRUEHcEVBKnFFQU5yRUFyc0VBlXRFQbl1RUHcdkVBAHhFQSN5RUFHekVBantFQY18RUGwfUVB035FQfZ/RUEZgUVBPIJFQV+DRUGChEVBpYVFQciGRUHqh0VBDYlFQS+KRUFSi0VBdIxFQZeNRUG5jkVB249FQf6QRUEgkkVBQpNFQWSURUGGlUVBqJZFQcqXRUHsmEVBDZpFQS+bRUFRnEVBcp1FQZSeRUG1n0VB16BFQfihRUEao0VBO6RFQVylRUF9pkVBnqdFQb+oRUHgqUVBAatFQSKsRUFDrUVBZK5FQYWvRUGlsEVBxrFFQeayRUEHtEVBJ7VFQUi2RUFot0VBiLhFQam5RUHJukVB6btFQQm9RUEpvkVBSb9FQWnARUGJwUVBqcJFQcjDRUHoxEVBCMZFQSfHRUFHyEVBZslFQYbKRUGly0VBxMxFQePNRUEDz0VBItBFQUHRRUFg0kVBf9NFQZ7URUG91UVB29ZFQfrXRUEZ2UVBONpFQVbbRUF13EVBk91FQbLeRUHQ30VB7uBFQQ3iRUEr40VBSeRFQWflRUGF5kVBo+dFQcHoRUHf6UVB/epFQRvsRUE47UVBVu5FQXTvRUGR8EVBr/FFQczyRUHp80VBB/VFQST2RUFB90VBX/hFQXz5RUGZ+kVBtvtFQdP8RUHw/UVBDf9FQSkARkFGAUZBYwJGQX8DRkGcBEZBuQVGQdUGRkHyB0ZBDglGQSoKRkFHC0ZBYwxGQX8NRkGbDkZBtw9GQdMQRkHvEUZBCxNGQScURkFDFUZBXhZGQXoXRkGWGEZBsRlGQc0aRkHoG0ZBBB1GQR8eRkE6H0ZBViBGQXEhRkGMIkZBpyNGQcIkRkHdJUZB+CZGQRMoRkEuKUZBSSpGQWMrRkF+LEZBmS1GQbMuRkHOL0ZB6DBGQQMyRkEdM0ZBNzRGQVI1RkFsNkZBhjdGQaA4RkG6OUZB1DpGQe47RkEIPUZBIj5GQTw/RkFVQEZBb0FGQYlCRkGiQ0ZBvERGQdVFRkHvRkZBCEhGQSFJRkE7SkZBVEtGQW1MRkGGTUZBn05GQbhPRkHRUEZB6lFGQQNTRkEcVEZBNFVGQU1WRkFmV0ZBflhGQZdZRkGvWkZByFtGQeBcRkH4XUZBEV9GQSlgRkFBYUZBWWJGQXFjRkGJZEZBoWVGQblmRkHRZ0ZB6WhGQQFqRkEYa0ZBMGxGQUhtRkFfbkZBd29GQY5wRkGlcUZBvXJGQdRzRkHrdEZBAnZGQRp3RkExeEZBSHlGQV96RkF2e0ZBjHxGQaN9RkG6fkZB0X9GQeeARkH+gUZBFYNGQSuERkFChUZBWIZGQW6HRkGFiEZBm4lGQbGKRkHHi0ZB3oxGQfSNRkEKj0ZBIJBGQTWRRkFLkkZBYZNGQXeURkGNlUZBopZGQbiXRkHNmEZB45lGQfiaRkEOnEZBI51GQTieRkFOn0ZBY6BGQXihRkGNokZBoqNGQbekRkHMpUZB4aZGQfanRkEKqUZBH6pGQTSrRkFJrEZBXa1GQXKuRkGGr0ZBm7BGQa+xRkHDskZB2LNGQey0RkEAtkZBFLdGQSi4RkE8uUZBULpGQWS7RkF4vEZBjL1GQaC+RkGzv0ZBx8BGQdvBRkHuwkZBAsRGQRXFRkEpxkZBPMdGQU/IRkFjyUZBdspGQYnLRkGczEZBr81GQcLORkHVz0ZB6NBGQfvRRkEO00ZBIdRGQTPVRkFG1kZBWddGQWvYRkF+2UZBkNpGQaPbRkG13EZBx91GQdreRkHs30ZB/uBGQRDiRkEi40ZBNORGQUblRkFY5kZBaudGQXzoRkGO6UZBn+pGQbHrRkHD7EZB1O1GQebuRkH370ZBCfFGQRryRkEr80ZBPfRGQU71RkFf9kZBcPdGQYH4RkGS+UZBo/pGQbT7RkHF/EZB1v1GQef+RkH4/0ZBCAFHQRkCR0EqA0dBOgRHQUsFR0FbBkdBawdHQXwIR0GMCUdBnApHQa0LR0G9DEdBzQ1HQd0OR0HtD0dB/RBHQQ0SR0EdE0dBLBRHQTwVR0FMFkdBXBdHQWsYR0F7GUdBihpHQZobR0GpHEdBuR1HQcgeR0HXH0dB5iBHQfYhR0EFI0dBFCRHQSMlR0EyJkdBQSdHQVAoR0FeKUdBbSpHQXwrR0GLLEdBmS1HQaguR0G2L0dBxTBHQdMxR0HiMkdB8DNHQf80R0ENNkdBGzdHQSk4R0E3OUdBRTpHQVM7R0FhPEdBbz1HQX0+R0GLP0dBmUBHQaZBR0G0QkdBwkNHQc9ER0HdRUdB6kZHQfhHR0EFSUdBE0pHQSBLR0EtTEdBOk1HQUdOR0FVT0dBYlBHQW9RR0F8UkdBiFNHQZVUR0GiVUdBr1ZHQbxXR0HIWEdB1VlHQeJaR0HuW0dB+1xHQQdeR0ETX0dBIGBHQSxhR0E4YkdBRGNHQVFkR0FdZUdBaWZHQXVnR0GBaEdBjWlHQZlqR0Gka0dBsGxHQbxtR0HIbkdB029HQd9wR0HqcUdB9nJHQQF0R0ENdUdBGHZHQSN3R0EueEdBOnlHQUV6R0FQe0dBW3xHQWZ9R0FxfkdBfH9HQYeAR0GSgUdBnIJHQaeDR0GyhEdBvIVHQceGR0HSh0dB3IhHQeeJR0HxikdB+4tHQQaNR0EQjkdBGo9HQSSQR0EukUdBOJJHQUKTR0FMlEdBVpVHQWCWR0Fql0dBdJhHQX6ZR0GHmkdBkZtHQZucR0GknUdBrp5HQbefR0HBoEdByqFHQdOiR0Hdo0dB5qRHQe+lR0H4pkdBAahHQQqpR0ETqkdBHKtHQSWsR0EurUdBN65HQUCvR0FIsEdBUbFHQVqyR0Fis0dBa7RHQXO1R0F8tkdBhLdHQY24R0GVuUdBnbpHQaW7R0GtvEdBtr1HQb6+R0HGv0dBzsBHQdbBR0HewkdB5cNHQe3ER0H1xUdB/cZHQQTIR0EMyUdBFMpHQRvLR0EjzEdBKs1HQTHOR0E5z0dBQNBHQUfRR0FO0kdBVtNHQV3UR0Fk1UdBa9ZHQXLXR0F52EdBgNlHQYbaR0GN20dBlNxHQZvdR0Gh3kdBqN9HQa/gR0G14UdBvOJHQcLjR0HI5EdBz+VHQdXmR0Hb50dB4ehHQejpR0Hu6kdB9OtHQfrsR0EA7kdBBu9HQQzwR0ER8UdBF/JHQR3zR0Ej9EdBKPVHQS72R0Ez90dBOfhHQT75R0FE+kdBSftHQU/8R0FU/UdBWf5HQV7/R0FkAEhBaQFIQW4CSEFzA0hBeARIQX0FSEGCBkhBhgdIQYsISEGQCUhBlQpIQZkLSEGeDEhBow1IQacOSEGsD0hBsBBIQbQRSEG5EkhBvRNIQcEUSEHGFUhByhZIQc4XSEHSGEhB1hlIQdoaSEHeG0hB4hxIQeYdSEHqHkhB7R9IQfEgSEH1IUhB+CJIQfwjSEH/JEhBAyZIQQYnSEEKKEhBDSlIQREqSEEUK0hBFyxIQRotSEEdLkhBIC9IQSQwSEEnMUhBKjJIQSwzSEEvNEhBMjVIQTU2SEE4N0hBOjhIQT05SEFAOkhBQjtIQUU8SEFHPUhBSj5IQUw/SEFOQEhBUUFIQVNCSEFVQ0hBV0RIQVpFSEFcRkhBXkdIQWBISEFiSUhBZEpIQWVLSEFnTEhBaU1IQWtOSEFsT0hBblBIQXBRSEFxUkhBc1NIQXRUSEF2VUhBd1ZIQXhXSEF6WEhBe1lIQXxaSEF9W0hBflxIQYBdSEGBXkhBgl9IQYNgSEGDYUhBhGJIQYVjSEGGZEhBh2VIQYdmSEGIZ0hBiWhIQYlpSEGKakhBimtIQYpsSEGLbUhBi25IQYtvSEGMcEhBjHFIQYxySEGMc0hBjHRIQYx1SEGMdkhBjHdIQYx4SEGMeUhBjHpIQYx7SEGLfEhBi31IQYt+SEGKf0hBioBIQYmBSEGJgkhBiINIQYiESEGHhUhBhoZIQYaHSEGFiEhBhIlIQYOKSEGCi0hBgYxIQYCNSEF/jkhBfo9IQX2QSEF8kUhBe5JIQXmTSEF4lEhBd5VIQXWWSEF0l0hBcphIQXGZSEFvmkhBbptIQWycSEFqnUhBaZ5IQWefSEFloEhBY6FIQWGiSEFfo0hBXaRIQVulSEFZpkhBV6dIQVWoSEFTqUhBUKpIQU6rSEFMrEhBSa1IQUeuSEFFr0hBQrBIQUCxSEE9skhBOrNIQTi0SEE1tUhBMrZIQS+3SEEtuEhBKrlIQSe6SEEku0hBIbxIQR69SEEbvkhBGL9IQRTASEERwUhBDsJIQQvDSEEHxEhBBMVIQQDGSEH9xkhB+cdIQfbISEHyyUhB78pIQevLSEHnzEhB5M1IQeDOSEHcz0hB2NBIQdTRSEHQ0khBzNNIQcjUSEHE1UhBwNZIQbzXSEG32EhBs9lIQa/aSEGq20hBptxIQaLdSEGd3khBmd9IQZTgSEGP4UhBi+JIQYbjSEGB5EhBfeVIQXjmSEFz50hBbuhIQWnpSEFk6khBX+tIQVrsSEFV7UhBUO5IQUvvSEFF8EhBQPFIQTvySEE180hBMPRIQSv1SEEl9khBIPdIQRr4SEEU+UhBD/pIQQn7SEED/EhB/vxIQfj9SEHy/khB7P9IQeYASUHgAUlB2gJJQdQDSUHOBElByAVJQcIGSUG7B0lBtQhJQa8JSUGoCklBogtJQZwMSUGVDUlBjw5JQYgPSUGCEElBexFJQXQSSUFuE0lBZxRJQWAVSUFZFklBUhdJQUsYSUFEGUlBPRpJQTYbSUEvHElBKB1JQSEeSUEaH0lBEiBJQQshSUEEIklB/CJJQfUjSUHuJElB5iVJQd8mSUHXJ0lBzyhJQcgpSUHAKklBuCtJQbAsSUGpLUlBoS5JQZkvSUGRMElBiTFJQYEySUF5M0lBcTRJQWk1SUFgNklBWDdJQVA4SUFIOUlBPzpJQTc7SUEuPElBJj1JQR0+SUEVP0lBDEBJQQRBSUH7QUlB8kJJQepDSUHhRElB2EVJQc9GSUHGR0lBvUhJQbRJSUGrSklBoktJQZlMSUGQTUlBh05JQX1PSUF0UElBa1FJQWFSSUFYU0lBT1RJQUVVSUE8VklBMldJQShYSUEfWUlBFVpJQQtbSUECXElB+FxJQe5dSUHkXklB2l9JQdBgSUHGYUlBvGJJQbJjSUGoZElBnmVJQZRmSUGJZ0lBf2hJQXVpSUFqaklBYGtJQVZsSUFLbUlBQW5JQTZvSUErcElBIXFJQRZySUELc0lBAXRJQfZ0SUHrdUlB4HZJQdV3SUHKeElBv3lJQbR6SUGpe0lBnnxJQZN9SUGIfklBfH9JQXGASUFmgUlBW4JJQU+DSUFEhElBOIVJQS2GSUEhh0lBFohJQQqJSUH+iUlB84pJQeeLSUHbjElBz41JQcOOSUG3j0lBq5BJQZ+RSUGTkklBh5NJQXuUSUFvlUlBY5ZJQVeXSUFLmElBPplJQTKaSUElm0lBGZxJQQ2dSUEAnklB9J5JQeefSUHaoElBzqFJQcGiSUG0o0lBqKRJQZulSUGOpklBgadJQXSoSUFnqUlBWqpJQU2rSUFArElBM61JQSauSUEZr0lBC7BJQf6wSUHxsUlB47JJQdazSUHJtElBu7VJQa62SUGgt0lBkrhJQYW5SUF3uklBabtJQVy8SUFOvUlBQL5JQTK/SUEkwElBFsFJQQjCSUH6wklB7MNJQd7ESUHQxUlBwsZJQbTHSUGlyElBl8lJQYnKSUF7y0lBbMxJQV7NSUFPzklBQc9JQTLQSUEk0UlBFdJJQQbTSUH400lB6dRJQdrVSUHL1klBvNdJQa3YSUGe2UlBj9pJQYDbSUFx3ElBYt1JQVPeSUFE30lBNeBJQSbhSUEW4klBB+NJQfjjSUHo5ElB2eVJQcnmSUG650lBquhJQZvpSUGL6klBe+tJQWzsSUFc7UlBTO5JQTzvSUEs8ElBHfFJQQ3ySUH98klB7fNJQd30SUHM9UlBvPZJQaz3SUGc+ElBjPlJQXv6SUFr+0lBW/xJQUr9SUE6/klBKv9JQRkASkEIAUpB+AFKQecCSkHXA0pBxgRKQbUFSkGkBkpBlAdKQYMISkFyCUpBYQpKQVALSkE/DEpBLg1KQR0OSkEMD0pB+w9KQekQSkHYEUpBxxJKQbYTSkGkFEpBkxVKQYIWSkFwF0pBXxhKQU0ZSkE8GkpBKhtKQRgcSkEHHUpB9R1KQeMeSkHRH0pBwCBKQa4hSkGcIkpBiiNKQXgkSkFmJUpBVCZKQUInSkEwKEpBHSlKQQsqSkH5KkpB5ytKQdQsSkHCLUpBsC5KQZ0vSkGLMEpBeDFKQWYySkFTM0pBQTRKQS41SkEbNkpBCTdKQfY3SkHjOEpB0DlKQb06SkGqO0pBlzxKQYQ9SkFxPkpBXj9KQUtASkE4QUpBJUJKQRJDSkH/Q0pB60RKQdhFSkHFRkpBsUdKQZ5ISkGKSUpBd0pKQWNLSkFQTEpBPE1KQSlOSkEVT0pBAVBKQe1QSkHaUUpBxlJKQbJTSkGeVEpBilVKQXZWSkFiV0pBTlhKQTpZSkEmWkpBEltKQf1bSkHpXEpB1V1KQcFeSkGsX0pBmGBKQYNhSkFvYkpBWmNKQUZkSkExZUpBHWZKQQhnSkHzZ0pB32hKQcppSkG1akpBoGtKQYtsSkF3bUpBYm5KQU1vSkE4cEpBI3FKQQ5ySkH4ckpB43NKQc50SkG5dUpBpHZKQY53SkF5eEpBZHlKQU56SkE5e0pBI3xKQQ59SkH4fUpB435KQc1/SkG3gEpBooFKQYyCSkF2g0pBYIRKQUuFSkE1hkpBH4dKQQmISkHziEpB3YlKQceKSkGxi0pBmoxKQYSNSkFujkpBWI9KQUKQSkErkUpBFZJKQf+SSkHok0pB0pRKQbuVSkGllkpBjpdKQXeYSkFhmUpBSppKQTObSkEdnEpBBp1KQe+dSkHYnkpBwZ9KQaqgSkGToUpBfKJKQWWjSkFOpEpBN6VKQSCmSkEJp0pB8qdKQdqoSkHDqUpBrKpKQZWrSkF9rEpBZq1KQU6uSkE3r0pBH7BKQQixSkHwsUpB2LJKQcGzSkGptEpBkbVKQXm2SkFit0pBSrhKQTK5SkEaukpBArtKQeq7SkHSvEpBur1KQaK+SkGKv0pBcsBKQVnBSkFBwkpBKcNKQRDESkH4xEpB4MVKQcfGSkGvx0pBlshKQX7JSkFlykpBTctKQTTMSkEbzUpBA85KQerOSkHRz0pBuNBKQZ/RSkGH0kpBbtNKQVXUSkE81UpBI9ZKQQrXSkHx10pB19hKQb7ZSkGl2kpBjNtKQXPcSkFZ3UpBQN5KQSffSkEN4EpB9OBKQdrhSkHB4kpBp+NKQY7kSkF05UpBWuZKQUHnSkEn6EpBDelKQfPpSkHZ6kpBwOtKQabsSkGM7UpBcu5KQVjvSkE+8EpBJPFKQQrySkHv8kpB1fNKQbv0SkGh9UpBhvZKQWz3SkFS+EpBN/lKQR36SkEC+0pB6PtKQc38SkGz/UpBmP5KQX7/SkFjAEtBSAFLQS4CS0ETA0tB+ANLQd0ES0HCBUtBpwZLQYwHS0FxCEtBVglLQTsKS0EgC0tBBQxLQeoMS0HPDUtBtA5LQZgPS0F9EEtBYhFLQUYSS0ErE0tBDxRLQfQUS0HYFUtBvRZLQaEXS0GGGEtBahlLQU4aS0EzG0tBFxxLQfscS0HfHUtBxB5LQagfS0GMIEtBcCFLQVQiS0E4I0tBHCRLQQAlS0HkJUtBxyZLQasnS0GPKEtBcylLQVYqS0E6K0tBHixLQQEtS0HlLUtByC5LQawvS0GPMEtBczFLQVYyS0E6M0tBHTRLQQA1S0HkNUtBxzZLQao3S0GNOEtBcDlLQVM6S0E2O0tBGTxLQfw8S0HfPUtBwj5LQaU/S0GIQEtBa0FLQU5CS0EwQ0tBE0RLQfZES0HYRUtBu0ZLQZ5HS0GASEtBY0lLQUVKS0EoS0tBCkxLQexMS0HPTUtBsU5LQZNPS0F2UEtBWFFLQTpSS0EcU0tB/lNLQeBUS0HCVUtBpFZLQYZXS0FoWEtBSllLQSxaS0EOW0tB8FtLQdFcS0GzXUtBlV5LQXdfS0FYYEtBOmFLQRtiS0H9YktB3mNLQcBkS0GhZUtBg2ZLQWRnS0FFaEtBJ2lLQQhqS0HpaktBymtLQaxsS0GNbUtBbm5LQU9vS0EwcEtBEXFLQfJxS0HTcktBtHNLQZV0S0F1dUtBVnZLQTd3S0EYeEtB+HhLQdl5S0G6ektBmntLQXt8S0FbfUtBPH5LQRx/S0H9f0tB3YBLQb6BS0GegktBfoNLQV6ES0E/hUtBH4ZLQf+GS0Hfh0tBv4hLQZ+JS0F/iktBX4tLQT+MS0EfjUtB/41LQd+OS0G/j0tBn5BLQX6RS0FekktBPpNLQR2US0H9lEtB3ZVLQbyWS0Gcl0tBe5hLQVuZS0E6mktBGptLQfmbS0HYnEtBuJ1LQZeeS0F2n0tBVaBLQTWhS0EUoktB86JLQdKjS0GxpEtBkKVLQW+mS0FOp0tBLahLQQypS0HqqUtByapLQairS0GHrEtBZq1LQUSuS0Ejr0tBAbBLQeCwS0G/sUtBnbJLQXyzS0FatEtBOLVLQRe2S0H1tktB1LdLQbK4S0GQuUtBbrpLQUy7S0ErvEtBCb1LQee9S0HFvktBo79LQYHAS0FfwUtBPcJLQRvDS0H5w0tB1sRLQbTFS0GSxktBcMdLQU3IS0EryUtBCcpLQebKS0HEy0tBocxLQX/NS0FczktBOs9LQRfQS0H10EtB0tFLQa/SS0GN00tBatRLQUfVS0Ek1ktBAddLQd7XS0G82EtBmdlLQXbaS0FT20tBMNxLQQzdS0Hp3UtBxt5LQaPfS0GA4EtBXeFLQTniS0EW40tB8+NLQc/kS0Gs5UtBieZLQWXnS0FC6EtBHulLQfrpS0HX6ktBs+tLQZDsS0Fs7UtBSO5LQSTvS0EB8EtB3fBLQbnxS0GV8ktBcfNLQU30S0Ep9UtBBfZLQeH2S0G990tBmfhLQXX5S0FR+ktBLftLQQj8S0Hk/EtBwP1LQZv+S0F3/0tBUwBMQS4BTEEKAkxB5QJMQcEDTEGcBExBeAVMQVMGTEEuB0xBCghMQeUITEHACUxBnApMQXcLTEFSDExBLQ1MQQgOTEHjDkxBvg9MQZkQTEF0EUxBTxJMQSoTTEEFFExB4BRMQbsVTEGVFkxBcBdMQUsYTEEmGUxBABpMQdsaTEG1G0xBkBxMQWodTEFFHkxBHx9MQfofTEHUIExBryFMQYkiTEFjI0xBPiRMQRglTEHyJUxBzCZMQaYnTEGBKExBWylMQTUqTEEPK0xB6StMQcMsTEGdLUxBdi5MQVAvTEEqMExBBDFMQd4xTEG4MkxBkTNMQWs0TEFFNUxBHjZMQfg2TEHRN0xBqzhMQYQ5TEFeOkxBNztMQRE8TEHqPExBwz1MQZ0+TEF2P0xBT0BMQShBTEECQkxB20JMQbRDTEGNRExBZkVMQT9GTEEYR0xB8UdMQcpITEGjSUxBfEpMQVRLTEEtTExBBk1MQd9NTEG4TkxBkE9MQWlQTEFBUUxBGlJMQfNSTEHLU0xBpFRMQXxVTEFVVkxBLVdMQQVYTEHeWExBtllMQY5aTEFnW0xBP1xMQRddTEHvXUxBx15MQZ9fTEF3YExBT2FMQSdiTEH/YkxB12NMQa9kTEGHZUxBX2ZMQTdnTEEPaExB5mhMQb5pTEGWakxBbWtMQUVsTEEdbUxB9G1MQcxuTEGjb0xBe3BMQVJxTEEqckxBAXNMQdhzTEGwdExBh3VMQV52TEE1d0xBDXhMQeR4TEG7eUxBknpMQWl7TEFAfExBF31MQe59TEHFfkxBnH9MQXOATEFKgUxBIYJMQfiCTEHOg0xBpYRMQXyFTEFShkxBKYdMQQCITEHWiExBrYlMQYOKTEFai0xBMIxMQQeNTEHdjUxBtI5MQYqPTEFgkExBN5FMQQ2STEHjkkxBuZNMQY+UTEFmlUxBPJZMQRKXTEHol0xBvphMQZSZTEFqmkxBQJtMQRacTEHrnExBwZ1MQZeeTEFtn0xBQ6BMQRihTEHuoUxBxKJMQZmjTEFvpExBRKVMQRqmTEHwpkxBxadMQZqoTEFwqUxBRapMQRurTEHwq0xBxaxMQZqtTEFwrkxBRa9MQRqwTEHvsExBxLFMQZmyTEFus0xBQ7RMQRi1TEHttUxBwrZMQZe3TEFsuExBQblMQRa6TEHrukxBv7tMQZS8TEFpvUxBPb5MQRK/TEHnv0xBu8BMQZDBTEFkwkxBOcNMQQ3ETEHixExBtsVMQYrGTEFfx0xBM8hMQQfJTEHcyUxBsMpMQYTLTEFYzExBLM1MQQDOTEHUzkxBqM9MQXzQTEFQ0UxBJNJMQfjSTEHM00xBoNRMQXTVTEFI1kxBG9dMQe/XTEHD2ExBl9lMQWraTEE+20xBEdxMQeXcTEG43UxBjN5MQV/fTEEz4ExBBuFMQdrhTEGt4kxBgONMQVTkTEEn5UxB+uVMQc3mTEGh50xBdOhMQUfpTEEa6kxB7epMQcDrTEGT7ExBZu1MQTnuTEEM70xB3+9MQbLwTEGE8UxBV/JMQSrzTEH980xBz/RMQaL1TEF19kxBR/dMQRr4TEHt+ExBv/lMQZL6TEFk+0xBNvxMQQn9TEHb/UxBrv5MQYD/TEFSAE1BJQFNQfcBTUHJAk1BmwNNQW0ETUE/BU1BEgZNQeQGTUG2B01BiAhNQVoJTUEsCk1B/QpNQc8LTUGhDE1Bcw1NQUUOTUEXD01B6A9NQboQTUGMEU1BXRJNQS8TTUEBFE1B0hRNQaQVTUF1Fk1BRxdNQRgYTUHqGE1BuxlNQYwaTUFeG01BLxxNQQAdTUHSHU1Box5NQXQfTUFFIE1BFiFNQechTUG4Ik1BiiNNQVskTUEsJU1B/CVNQc0mTUGeJ01BbyhNQUApTUERKk1B4ipNQbIrTUGDLE1BVC1NQSUuTUH1Lk1Bxi9NQZYwTUFnMU1BNzJNQQgzTUHYM01BqTRNQXk1TUFKNk1BGjdNQeo3TUG7OE1BizlNQVs6TUErO01B/DtNQcw8TUGcPU1BbD5NQTw/TUEMQE1B3EBNQaxBTUF8Qk1BTENNQRxETUHsRE1BvEVNQYtGTUFbR01BK0hNQftITUHKSU1BmkpNQWpLTUE5TE1BCU1NQdhNTUGoTk1Bd09NQUdQTUEWUU1B5lFNQbVSTUGEU01BVFRNQSNVTUHyVU1BwlZNQZFXTUFgWE1BL1lNQf5ZTUHNWk1BnFtNQWxcTUE7XU1BCl5NQdleTUGnX01BdmBNQUVhTUEUYk1B42JNQbJjTUGAZE1BT2VNQR5mTUHtZk1Bu2dNQYpoTUFYaU1BJ2pNQfZqTUHEa01BkmxNQWFtTUEvbk1B/m5NQcxvTUGacE1BaXFNQTdyTUEFc01B1HNNQaJ0TUFwdU1BPnZNQQx3TUHad01BqHhNQXZ5TUFEek1BEntNQeB7TUGufE1BfH1NQUp+TUEYf01B5n9NQbOATUGBgU1BT4JNQR2DTUHqg01BuIRNQYWFTUFThk1BIYdNQe6HTUG8iE1BiYlNQVeKTUEki01B8YtNQb+MTUGMjU1BWY5NQSePTUH0j01BwZBNQY6RTUFbkk1BKZNNQfaTTUHDlE1BkJVNQV2WTUEql01B95dNQcSYTUGRmU1BXppNQSqbTUH3m01BxJxNQZGdTUFenk1BKp9NQfefTUHEoE1BkKFNQV2iTUEpo01B9qNNQcOkTUGPpU1BW6ZNQSinTUH0p01BwahNQY2pTUFZqk1BJqtNQfKrTUG+rE1Biq1NQVeuTUEjr01B769NQbuwTUGHsU1BU7JNQR+zTUHrs01Bt7RNQYO1TUFPtk1BG7dNQee3TUGzuE1BfrlNQUq6TUEWu01B4rtNQa28TUF5vU1BRb5NQRC/TUHcv01BqMBNQXPBTUE/wk1BCsNNQdbDTUGhxE1BbMVNQTjGTUEDx01BzsdNQZrITUFlyU1BMMpNQfvKTUHHy01BksxNQV3NTUEozk1B885NQb7PTUGJ0E1BVNFNQR/STUHq0k1BtdNNQYDUTUFL1U1BFdZNQeDWTUGr101BdthNQUDZTUEL2k1B1tpNQaDbTUFr3E1BNt1NQQDeTUHL3k1Bld9NQWDgTUEq4U1B9eFNQb/iTUGJ401BVORNQR7lTUHo5U1BsuZNQX3nTUFH6E1BEelNQdvpTUGl6k1Bb+tNQTrsTUEE7U1Bzu1NQZjuTUFi701BK/BNQfXwTUG/8U1BifJNQVPzTUEd9E1B5vRNQbD1TUF69k1BRPdNQQ34TUHX+E1BoflNQWr6TUE0+01B/ftNQcf8TUGQ/U1BWv5NQSP/TUHs/01BtgBOQX8BTkFIAk5BEgNOQdsDTkGkBE5BbQVOQTcGTkEAB05ByQdOQZIITkFbCU5BJApOQe0KTkG2C05BfwxOQUgNTkERDk5B2g5OQaMPTkFsEE5BNBFOQf0RTkHGEk5BjxNOQVcUTkEgFU5B6RVOQbEWTkF6F05BQhhOQQsZTkHTGU5BnBpOQWQbTkEtHE5B9RxOQb4dTkGGHk5BTh9OQRcgTkHfIE5BpyFOQW8iTkE4I05BACROQcgkTkGQJU5BWCZOQSAnTkHoJ05BsChOQXgpTkFAKk5BCCtOQdArTkGYLE5BYC1OQSguTkHvLk5Bty9OQX8wTkFHMU5BDjJOQdYyTkGeM05BZTROQS01TkH0NU5BvDZOQYM3TkFLOE5BEjlOQdo5TkGhOk5BaTtOQTA8TkH3PE5Bvj1OQYY+TkFNP05BFEBOQdtATkGjQU5BakJOQTFDTkH4Q05Bv0ROQYZFTkFNRk5BFEdOQdtHTkGiSE5BaUlOQTBKTkH3Sk5BvUtOQYRMTkFLTU5BEk5OQdhOTkGfT05BZlBOQSxRTkHzUU5BulJOQYBTTkFHVE5BDVVOQdRVTkGaVk5BYVdOQSdYTkHtWE5BtFlOQXpaTkFAW05BB1xOQc1cTkGTXU5BWV5OQSBfTkHmX05BrGBOQXJhTkE4Yk5B/mJOQcRjTkGKZE5BUGVOQRZmTkHcZk5BomdOQWhoTkEuaU5B82lOQblqTkF/a05BRWxOQQptTkHQbU5Blm5OQVtvTkEhcE5B5nBOQaxxTkFyck5BN3NOQf1zTkHCdE5Bh3VOQU12TkESd05B2HdOQZ14TkFieU5BJ3pOQe16TkGye05Bd3xOQTx9TkEBfk5Bx35OQYx/TkFRgE5BFoFOQduBTkGggk5BZYNOQSqETkHvhE5Bs4VOQXiGTkE9h05BAohOQceITkGLiU5BUIpOQRWLTkHai05BnoxOQWONTkEnjk5B7I5OQbGPTkF1kE5BOpFOQf6RTkHDkk5Bh5NOQUuUTkEQlU5B1JVOQZiWTkFdl05BIZhOQeWYTkGpmU5BbppOQTKbTkH2m05BupxOQX6dTkFCnk5BBp9OQcqfTkGOoE5BUqFOQRaiTkHaok5BnqNOQWKkTkEmpU5B6qVOQa2mTkFxp05BNahOQfmoTkG8qU5BgKpOQUSrTkEHrE5By6xOQY6tTkFSrk5BFa9OQdmvTkGcsE5BYLFOQSOyTkHnsk5BqrNOQW20TkExtU5B9LVOQbe2TkF6t05BPrhOQQG5TkHEuU5Bh7pOQUq7TkENvE5B0LxOQZO9TkFWvk5BGb9OQdy/TkGfwE5BYsFOQSXCTkHowk5Bq8NOQW7ETkEwxU5B88VOQbbGTkF4x05BO8hOQf7ITkHAyU5Bg8pOQUbLTkEIzE5By8xOQY3NTkFQzk5BEs9OQdXPTkGX0E5BWdFOQRzSTkHe0k5BoNNOQWPUTkEl1U5B59VOQanWTkFs105BLthOQfDYTkGy2U5BdNpOQTbbTkH4205ButxOQXzdTkE+3k5BAN9OQcLfTkGE4E5BRuFOQQfiTkHJ4k5Bi+NOQU3kTkEP5U5B0OVOQZLmTkFU505BFehOQdfoTkGY6U5BWupOQRzrTkHd605Bn+xOQWDtTkEh7k5B4+5OQaTvTkFm8E5BJ/FOQejxTkGq8k5Ba/NOQSz0TkHt9E5BrvVOQXD2TkEx905B8vdOQbP4TkF0+U5BNfpOQfb6TkG3+05BePxOQTn9TkH6/U5Bu/5OQXz/TkE9AE9B/QBPQb4BT0F/Ak9BQANPQQAET0HBBE9BggVPQUIGT0EDB09BxAdPQYQIT0FFCU9BBQpPQcYKT0GGC09BRwxPQQcNT0HIDU9BiA5PQUgPT0EJEE9ByRBPQYkRT0FJEk9BChNPQcoTT0GKFE9BShVPQQoWT0HKFk9BixdPQUsYT0ELGU9ByxlPQYsaT0FLG09BCxxPQcscT0GKHU9BSh5PQQofT0HKH09BiiBPQUkhT0EJIk9BySJPQYkjT0FIJE9BCCVPQcglT0GHJk9BRydPQQYoT0HGKE9BhSlPQUUqT0EEK09BxCtPQYMsT0FCLU9BAi5PQcEuT0GAL09BQDBPQf8wT0G+MU9BfTJPQT0zT0H8M09BuzRPQXo1T0E5Nk9B+DZPQbc3T0F2OE9BNTlPQfQ5T0GzOk9BcjtPQTE8T0HwPE9Brz1PQW4+T0EsP09B6z9PQapAT0FpQU9BJ0JPQeZCT0GlQ09BY0RPQSJFT0HhRU9Bn0ZPQV5HT0EcSE9B20hPQZlJT0FYSk9BFktPQdRLT0GTTE9BUU1PQQ9OT0HOTk9BjE9PQUpQT0EIUU9Bx1FPQYVST0FDU09BAVRPQb9UT0F9VU9BO1ZPQflWT0G3V09BdVhPQTNZT0HxWU9Br1pPQW1bT0ErXE9B6VxPQaddT0FkXk9BIl9PQeBfT0GeYE9BW2FPQRliT0HXYk9BlGNPQVJkT0EQZU9BzWVPQYtmT0FIZ09BBmhPQcNoT0GBaU9BPmpPQftqT0G5a09BdmxPQTNtT0HxbU9Brm5PQWtvT0EocE9B5nBPQaNxT0Fgck9BHXNPQdpzT0GXdE9BVHVPQRF2T0HOdk9Bi3dPQUh4T0EFeU9BwnlPQX96T0E8e09B+XtPQbZ8T0FyfU9BL35PQex+T0Gpf09BZYBPQSKBT0HfgU9Bm4JPQViDT0EVhE9B0YRPQY6FT0FKhk9BB4dPQcOHT0GAiE9BPIlPQfmJT0G1ik9BcYtPQS6MT0HqjE9Bpo1PQWKOT0Efj09B249PQZeQT0FTkU9BD5JPQcyST0GIk09BRJRPQQCVT0G8lU9BeJZPQTSXT0Hwl09BrJhPQWiZT0Ejmk9B35pPQZubT0FXnE9BE51PQc+dT0GKnk9BRp9PQQKgT0G9oE9BeaFPQTWiT0Hwok9BrKNPQWekT0EjpU9B3qVPQZqmT0FVp09BEahPQcyoT0GIqU9BQ6pPQf6qT0G6q09BdaxPQTCtT0HsrU9Bp65PQWKvT0EdsE9B2LBPQZSxT0FPsk9BCrNPQcWzT0GAtE9BO7VPQfa1T0Gxtk9BbLdPQSe4T0HiuE9BnblPQVe6T0ESu09BzbtPQYi8T0FDvU9B/b1PQbi+T0Fzv09BLsBPQejAT0GjwU9BXcJPQRjDT0HTw09BjcRPQUjFT0ECxk9BvcZPQXfHT0EyyE9B7MhPQabJT0Fhyk9BG8tPQdXLT0GQzE9BSs1PQQTOT0G+zk9Bec9PQTPQT0Ht0E9Bp9FPQWHST0Eb009B1dNPQY/UT0FJ1U9BA9ZPQb3WT0F3109BMdhPQevYT0Gl2U9BX9pPQRnbT0HS209BjNxPQUbdT0EA3k9Bud5PQXPfT0Et4E9B5uBPQaDhT0Fa4k9BE+NPQc3jT0GG5E9BQOVPQfnlT0Gz5k9BbOdPQSboT0Hf6E9BmelPQVLqT0EL609BxetPQX7sT0E37U9B8O1PQaruT0Fj709BHPBPQdXwT0GO8U9BR/JPQQDzT0G5809BcvRPQSv1T0Hk9U9BnfZPQVb3T0EP+E9ByPhPQYH5T0E6+k9B8/pPQaz7T0Fk/E9BHf1PQdb9T0GP/k9BR/9PQQAAUEG5AFBBcQFQQSoCUEHiAlBBmwNQQVQEUEEMBVBBxQVQQX0GUEE2B1BB7gdQQaYIUEFfCVBBFwpQQc8KUEGIC1BBQAxQQfgMUEGxDVBBaQ5QQSEPUEHZD1BBkRBQQUkRUEECElBBuhJQQXITUEEqFFBB4hRQQZoVUEFSFlBBChdQQcIXUEF6GFBBMhlQQekZUEGhGlBBWRtQQREcUEHJHFBBgB1QQTgeUEHwHlBBqB9QQV8gUEEXIVBBziFQQYYiUEE+I1BB9SNQQa0kUEFkJVBBHCZQQdMmUEGLJ1BBQihQQfkoUEGxKVBBaCpQQSArUEHXK1BBjixQQUUtUEH9LVBBtC5QQWsvUEEiMFBB2TBQQZExUEFIMlBB/zJQQbYzUEFtNFBBJDVQQds1UEGSNlBBSTdQQQA4UEG3OFBBbjlQQSQ6UEHbOlBBkjtQQUk8UEEAPVBBtj1QQW0+UEEkP1BB2z9QQZFAUEFIQVBB/kFQQbVCUEFsQ1BBIkRQQdlEUEGPRVBBRkZQQfxGUEGzR1BBaUhQQSBJUEHWSVBBjEpQQUNLUEH5S1BBr0xQQWVNUEEcTlBB0k5QQYhPUEE+UFBB9VBQQatRUEFhUlBBF1NQQc1TUEGDVFBBOVVQQe9VUEGlVlBBW1dQQRFYUEHHWFBBfVlQQTNaUEHpWlBBnltQQVRcUEEKXVBBwF1QQXVeUEErX1BB4V9QQZdgUEFMYVBBAmJQQbdiUEFtY1BBI2RQQdhkUEGOZVBBQ2ZQQflmUEGuZ1BBZGhQQRlpUEHOaVBBhGpQQTlrUEHva1BBpGxQQVltUEEOblBBxG5QQXlvUEEucFBB43BQQZhxUEFOclBBA3NQQbhzUEFtdFBBInVQQdd1UEGMdlBBQXdQQfZ3UEGreFBBYHlQQRV6UEHKelBBfntQQTN8UEHofFBBnX1QQVJ+UEEGf1BBu39QQXCAUEEkgVBB2YFQQY6CUEFCg1BB94NQQayEUEFghVBBFYZQQcmGUEF+h1BBMohQQeeIUEGbiVBBT4pQQQSLUEG4i1BBbIxQQSGNUEHVjVBBiY5QQT6PUEHyj1BBppBQQVqRUEEOklBBw5JQQXeTUEErlFBB35RQQZOVUEFHllBB+5ZQQa+XUEFjmFBBF5lQQcuZUEF/mlBBM5tQQeebUEGanFBBTp1QQQKeUEG2nlBBap9QQR2gUEHRoFBBhaFQQTiiUEHsolBBoKNQQVOkUEEHpVBBuqVQQW6mUEEhp1BB1adQQYioUEE8qVBB76lQQaOqUEFWq1BBCqxQQb2sUEFwrVBBJK5QQdeuUEGKr1BBPbBQQfGwUEGksVBBV7JQQQqzUEG9s1BBcLRQQSS1UEHXtVBBirZQQT23UEHwt1BBo7hQQVa5UEEJulBBvLpQQW67UEEhvFBB1LxQQYe9UEE6vlBB7b5QQZ+/UEFSwFBBBcFQQbjBUEFqwlBBHcNQQdDDUEGCxFBBNcVQQejFUEGaxlBBTcdQQf/HUEGyyFBBZMlQQRfKUEHJylBBfMtQQS7MUEHgzFBBk81QQUXOUEH3zlBBqs9QQVzQUEEO0VBBwNFQQXPSUEEl01BB19NQQYnUUEE71VBB7dVQQaDWUEFS11BBBNhQQbbYUEFo2VBBGtpQQczaUEF+21BBL9xQQeHcUEGT3VBBRd5QQffeUEGp31BBW+BQQQzhUEG+4VBBcOJQQSLjUEHT41BBheRQQTflUEHo5VBBmuZQQUvnUEH951BBruhQQWDpUEES6lBBw+pQQXTrUEEm7FBB1+xQQYntUEE67lBB6+5QQZ3vUEFO8FBB//BQQbHxUEFi8lBBE/NQQcTzUEF29FBBJ/VQQdj1UEGJ9lBBOvdQQev3UEGc+FBBTflQQf75UEGv+lBBYPtQQRH8UEHC/FBBc/1QQST+UEHV/lBBhv9QQTcAUUHnAFFBmAFRQUkCUUH6AlFBqwNRQVsEUUEMBVFBvQVRQW0GUUEeB1FBzwdRQX8IUUEwCVFB4AlRQZEKUUFBC1FB8gtRQaIMUUFTDVFBAw5RQbQOUUFkD1FBFBBRQcUQUUF1EVFBJRJRQdYSUUGGE1FBNhRRQeYUUUGWFVFBRxZRQfcWUUGnF1FBVxhRQQcZUUG3GVFBZxpRQRcbUUHHG1FBdxxRQScdUUHXHVFBhx5RQTcfUUHnH1FBlyBRQUchUUH3IVFBpiJRQVYjUUEGJFFBtiRRQWUlUUEVJlFBxSZRQXUnUUEkKFFB1ChRQYMpUUEzKlFB4ypRQZIrUUFCLFFB8SxRQaEtUUFQLlFBAC9RQa8vUUFeMFFBDjFRQb0xUUFsMlFBHDNRQcszUUF6NFFBKjVRQdk1UUGINlFBNzdRQeY3UUGWOFFBRTlRQfQ5UUGjOlFBUjtRQQE8UUGwPFFBXz1RQQ4+UUG9PlFBbD9RQRtAUUHKQFFBeUFRQShCUUHXQlFBhUNRQTREUUHjRFFBkkVRQUFGUUHvRlFBnkdRQU1IUUH7SFFBqklRQVlKUUEHS1FBtktRQWRMUUETTVFBwk1RQXBOUUEfT1FBzU9RQXxQUUEqUVFB2FFRQYdSUUE1U1FB41NRQZJUUUFAVVFB7lVRQZ1WUUFLV1FB+VdRQadYUUFWWVFBBFpRQbJaUUFgW1FBDlxRQbxcUUFqXVFBGF5RQcZeUUF0X1FBImBRQdBgUUF+YVFBLGJRQdpiUUGIY1FBNmRRQeRkUUGSZVFBP2ZRQe1mUUGbZ1FBSWhRQfZoUUGkaVFBUmpRQQBrUUGta1FBW2xRQQhtUUG2bVFBZG5RQRFvUUG/b1FBbHBRQRpxUUHHcVFBdXJRQSJzUUHPc1FBfXRRQSp1UUHYdVFBhXZRQTJ3UUHgd1FBjXhRQTp5UUHneVFBlXpRQUJ7UUHve1FBnHxRQUl9UUH2fVFBo35RQVB/UUH+f1FBq4BRQViBUUEFglFBsoJRQV+DUUELhFFBuIRRQWWFUUEShlFBv4ZRQWyHUUEZiFFBxYhRQXKJUUEfilFBzIpRQXiLUUEljFFB0oxRQX+NUUErjlFB2I5RQYSPUUExkFFB3pBRQYqRUUE3klFB45JRQZCTUUE8lFFB6ZRRQZWVUUFBllFB7pZRQZqXUUFGmFFB85hRQZ+ZUUFLmlFB+JpRQaSbUUFQnFFB/JxRQamdUUFVnlFBAZ9RQa2fUUFZoFFBBaFRQbGhUUFdolFBCaNRQbWjUUFhpFFBDaVRQbmlUUFlplFBEadRQb2nUUFpqFFBFalRQcGpUUFsqlFBGKtRQcSrUUFwrFFBG61RQcetUUFzrlFBH69RQcqvUUF2sFFBIrFRQc2xUUF5slFBJLNRQdCzUUF7tFFBJ7VRQdK1UUF+tlFBKbdRQdW3UUGAuFFBK7lRQde5UUGCulFBLrtRQdm7UUGEvFFBL71RQdu9UUGGvlFBMb9RQdy/UUGHwFFBM8FRQd7BUUGJwlFBNMNRQd/DUUGKxFFBNcVRQeDFUUGLxlFBNsdRQeHHUUGMyFFBN8lRQeLJUUGNylFBOMtRQePLUUGNzFFBOM1RQePNUUGOzlFBOM9RQePPUUGO0FFBOdFRQePRUUGO0lFBOdNRQePTUUGO1FFBONVRQePVUUGN1lFBONdRQePXUUGN2FFBN9lRQeLZUUGM2lFBN9tRQeHbUUGL3FFBNt1RQeDdUUGK3lFBNd9RQd/fUUGJ4FFBNOFRQd7hUUGI4lFBMuNRQdzjUUGG5FFBMeVRQdvlUUGF5lFBL+dRQdnnUUGD6FFBLelRQdfpUUGB6lFBK+tRQdXrUUF/7FFBKO1RQdLtUUF87lFBJu9RQdDvUUF68FFBI/FRQc3xUUF38lFBIfNRQcrzUUF09FFBHvVRQcf1UUFx9lFBGvdRQcT3UUFu+FFBF/lRQcH5UUFq+lFBFPtRQb37UUFn/FFBEP1RQbn9UUFj/lFBDP9RQbb/UUFfAFJBCAFSQbIBUkFbAlJBBANSQa0DUkFXBFJBAAVSQakFUkFSBlJB+wZSQaQHUkFOCFJB9whSQaAJUkFJClJB8gpSQZsLUkFEDFJB7QxSQZYNUkE/DlJB6A5SQZAPUkE5EFJB4hBSQYsRUkE0ElJB3RJSQYUTUkEuFFJB1xRSQYAVUkEoFlJB0RZSQXoXUkEiGFJByxhSQXQZUkEcGlJBxRpSQW0bUkEWHFJBvxxSQWcdUkEQHlJBuB5SQWAfUkEJIFJBsSBSQVohUkECIlJBqiJSQVMjUkH7I1JBoyRSQUwlUkH0JVJBnCZSQUQnUkHtJ1JBlShSQT0pUkHlKVJBjSpSQTUrUkHeK1JBhixSQS4tUkHWLVJBfi5SQSYvUkHOL1JBdjBSQR4xUkHGMVJBbTJSQRUzUkG9M1JBZTRSQQ01UkG1NVJBXDZSQQQ3UkGsN1JBVDhSQfs4UkGjOVJBSzpSQfM6UkGaO1JBQjxSQek8UkGRPVJBOT5SQeA+UkGIP1JBL0BSQddAUkF+QVJBJkJSQc1CUkF1Q1JBHERSQcNEUkFrRVJBEkZSQblGUkFhR1JBCEhSQa9IUkFXSVJB/klSQaVKUkFMS1JB80tSQZtMUkFCTVJB6U1SQZBOUkE3T1JB3k9SQYVQUkEsUVJB01FSQXpSUkEhU1JByFNSQW9UUkEWVVJBvVVSQWRWUkELV1JBsldSQVhYUkH/WFJBpllSQU1aUkH0WlJBmltSQUFcUkHoXFJBjl1SQTVeUkHcXlJBgl9SQSlgUkHQYFJBdmFSQR1iUkHDYlJBamNSQRBkUkG3ZFJBXWVSQQRmUkGqZlJBUWdSQfdnUkGdaFJBRGlSQeppUkGQalJBN2tSQd1rUkGDbFJBKW1SQdBtUkF2blJBHG9SQcJvUkFocFJBD3FSQbVxUkFbclJBAXNSQadzUkFNdFJB83RSQZl1UkE/dlJB5XZSQYt3UkExeFJB13hSQX15UkEjelJByHpSQW57UkEUfFJBunxSQWB9UkEFflJBq35SQVF/UkH3f1JBnIBSQUKBUkHogVJBjYJSQTODUkHZg1JBfoRSQSSFUkHJhVJBb4ZSQRSHUkG6h1JBX4hSQQWJUkGqiVJBUIpSQfWKUkGbi1JBQIxSQeWMUkGLjVJBMI5SQdWOUkF7j1JBIJBSQcWQUkFqkVJBD5JSQbWSUkFak1JB/5NSQaSUUkFJlVJB7pVSQZOWUkE5l1JB3pdSQYOYUkEomVJBzZlSQXKaUkEXm1JBvJtSQWCcUkEFnVJBqp1SQU+eUkH0nlJBmZ9SQT6gUkHioFJBh6FSQSyiUkHRolJBdaNSQRqkUkG/pFJBZKVSQQimUkGtplJBUadSQfanUkGbqFJBP6lSQeSpUkGIqlJBLatSQdGrUkF2rFJBGq1SQb+tUkFjrlJBB69SQayvUkFQsFJB9bBSQZmxUkE9slJB4rJSQYazUkEqtFJBzrRSQXO1UkEXtlJBu7ZSQV+3UkEDuFJBp7hSQUy5UkHwuVJBlLpSQTi7UkHcu1JBgLxSQSS9UkHIvVJBbL5SQRC/UkG0v1JBWMBSQfzAUkGfwVJBQ8JSQefCUkGLw1JBL8RSQdPEUkF2xVJBGsZSQb7GUkFix1JBBchSQanIUkFNyVJB8MlSQZTKUkE4y1JB28tSQX/MUkEizVJBxs1SQWrOUkENz1JBsc9SQVTQUkH30FJBm9FSQT7SUkHi0lJBhdNSQSnUUkHM1FJBb9VSQRPWUkG21lJBWddSQfzXUkGg2FJBQ9lSQebZUkGJ2lJBLdtSQdDbUkFz3FJBFt1SQbndUkFc3lJB/95SQaLfUkFF4FJB6OBSQYvhUkEu4lJB0eJSQXTjUkEX5FJBuuRSQV3lUkEA5lJBo+ZSQUbnUkHo51JBi+hSQS7pUkHR6VJBdOpSQRbrUkG561JBXOxSQf7sUkGh7VJBRO5SQebuUkGJ71JBLPBSQc7wUkFx8VJBE/JSQbbyUkFY81JB+/NSQZ30UkFA9VJB4vVSQYX2UkEn91JByvdSQWz4UkEO+VJBsflSQVP6UkH1+lJBmPtSQTr8UkHc/FJBfv1SQSH+UkHD/lJBZf9SQQcAU0GpAFNBSwFTQe0BU0GQAlNBMgNTQdQDU0F2BFNBGAVTQboFU0FcBlNB/gZTQaAHU0FCCFNB5AhTQYUJU0EnClNByQpTQWsLU0ENDFNBrwxTQVENU0HyDVNBlA5TQTYPU0HYD1NBeRBTQRsRU0G9EVNBXhJTQQATU0GiE1NBQxRTQeUUU0GGFVNBKBZTQcoWU0FrF1NBDRhTQa4YU0FQGVNB8RlTQZIaU0E0G1NB1RtTQXccU0EYHVNBuR1TQVseU0H8HlNBnR9TQT8gU0HgIFNBgSFTQSIiU0HEIlNBZSNTQQYkU0GnJFNBSCVTQeklU0GLJlNBLCdTQc0nU0FuKFNBDylTQbApU0FRKlNB8ipTQZMrU0E0LFNB1SxTQXYtU0EXLlNBty5TQVgvU0H5L1NBmjBTQTsxU0HcMVNBfDJTQR0zU0G+M1NBXzRTQf80U0GgNVNBQTZTQeE2U0GCN1NBIzhTQcM4U0FkOVNBBTpTQaU6U0FGO1NB5jtTQYc8U0EnPVNByD1TQWg+U0EJP1NBqT9TQUlAU0HqQFNBikFTQStCU0HLQlNBa0NTQQxEU0GsRFNBTEVTQexFU0GNRlNBLUdTQc1HU0FtSFNBDUlTQa5JU0FOSlNB7kpTQY5LU0EuTFNBzkxTQW5NU0EOTlNBrk5TQU5PU0HuT1NBjlBTQS5RU0HOUVNBblJTQQ5TU0GuU1NBTlRTQe5UU0GNVVNBLVZTQc1WU0FtV1NBDVhTQaxYU0FMWVNB7FlTQYtaU0ErW1NBy1tTQWpcU0EKXVNBql1TQUleU0HpXlNBiF9TQShgU0HIYFNBZ2FTQQdiU0GmYlNBRmNTQeVjU0GEZFNBJGVTQcNlU0FjZlNBAmdTQaFnU0FBaFNB4GhTQX9pU0EfalNBvmpTQV1rU0H8a1NBnGxTQTttU0HabVNBeW5TQRhvU0G3b1NBVnBTQfZwU0GVcVNBNHJTQdNyU0Fyc1NBEXRTQbB0U0FPdVNB7nVTQY12U0Esd1NBy3dTQWl4U0EIeVNBp3lTQUZ6U0HlelNBhHtTQSJ8U0HBfFNBYH1TQf99U0GdflNBPH9TQdt/U0F6gFNBGIFTQbeBU0FVglNB9IJTQZODU0ExhFNB0IRTQW6FU0ENhlNBq4ZTQUqHU0Hoh1NBh4hTQSWJU0HEiVNBYopTQQGLU0Gfi1NBPYxTQdyMU0F6jVNBGI5TQbeOU0FVj1NB849TQZGQU0EwkVNBzpFTQWySU0EKk1NBqJNTQUeUU0HllFNBg5VTQSGWU0G/llNBXZdTQfuXU0GZmFNBN5lTQdWZU0FzmlNBEZtTQa+bU0FNnFNB65xTQYmdU0EnnlNBxZ5TQWKfU0EAoFNBnqBTQTyhU0HaoVNBd6JTQRWjU0Gzo1NBUaRTQe6kU0GMpVNBKqZTQcemU0Flp1NBA6hTQaCoU0E+qVNB26lTQXmqU0EWq1NBtKtTQVGsU0HvrFNBjK1TQSquU0HHrlNBZa9TQQKwU0GgsFNBPbFTQdqxU0F4slNBFbNTQbKzU0FQtFNB7bRTQYq1U0EntlNBxbZTQWK3U0H/t1NBnLhTQTm5U0HWuVNBdLpTQRG7U0Guu1NBS7xTQei8U0GFvVNBIr5TQb++U0Fcv1NB+b9TQZbAU0EzwVNB0MFTQW3CU0EKw1NBp8NTQUTEU0HgxFNBfcVTQRrGU0G3xlNBVMdTQfDHU0GNyFNBKslTQcfJU0FjylNBAMtTQZ3LU0E5zFNB1sxTQXPNU0EPzlNBrM5TQUjPU0Hlz1NBgdBTQR7RU0G70VNBV9JTQfTSU0GQ01NBLNRTQcnUU0Fl1VNBAtZTQZ7WU0E611NB19dTQXPYU0EP2VNBrNlTQUjaU0Hk2lNBgdtTQR3cU0G53FNBVd1TQfHdU0GO3lNBKt9TQcbfU0Fi4FNB/uBTQZrhU0E24lNB0uJTQW7jU0EK5FNBpuRTQULlU0He5VNBeuZTQRbnU0Gy51NBTuhTQeroU0GG6VNBIupTQb7qU0FZ61NB9etTQZHsU0Et7VNBye1TQWTuU0EA71NBnO9TQTjwU0HT8FNBb/FTQQvyU0Gm8lNBQvNTQd7zU0F59FNBFfVTQbD1U0FM9lNB5/ZTQYP3U0Ee+FNBuvhTQVX5U0Hx+VNBjPpTQSj7U0HD+1NBXvxTQfr8U0GV/VNBMP5TQcz+U0Fn/1NBAgBUQZ4AVEE5AVRB1AFUQW8CVEELA1RBpgNUQUEEVEHcBFRBdwVUQRIGVEGuBlRBSQdUQeQHVEF/CFRBGglUQbUJVEFQClRB6wpUQYYLVEEhDFRBvAxUQVcNVEHyDVRBjQ5UQSgPVEHCD1RBXRBUQfgQVEGTEVRBLhJUQckSVEFjE1RB/hNUQZkUVEE0FVRBzhVUQWkWVEEEF1RBnhdUQTkYVEHUGFRBbhlUQQkaVEGjGlRBPhtUQdkbVEFzHFRBDh1UQagdVEFDHlRB3R5UQXgfVEESIFRBrSBUQUchVEHhIVRBfCJUQRYjVEGwI1RBSyRUQeUkVEF/JVRBGiZUQbQmVEFOJ1RB6SdUQYMoVEEdKVRBtylUQVEqVEHsKlRBhitUQSAsVEG6LFRBVC1UQe4tVEGILlRBIi9UQbwvVEFWMFRB8DBUQYoxVEEkMlRBvjJUQVgzVEHyM1RBjDRUQSY1VEHANVRBWjZUQfQ2VEGNN1RBJzhUQcE4VEFbOVRB9TlUQY46VEEoO1RBwjtUQVw8VEH1PFRBjz1UQSk+VEHCPlRBXD9UQfY/VEGPQFRBKUFUQcJBVEFcQlRB9UJUQY9DVEEoRFRBwkRUQVtFVEH1RVRBjkZUQShHVEHBR1RBW0hUQfRIVEGNSVRBJ0pUQcBKVEFZS1RB80tUQYxMVEElTVRBv01UQVhOVEHxTlRBik9UQSNQVEG9UFRBVlFUQe9RVEGIUlRBIVNUQbpTVEFTVFRB7FRUQYZVVEEfVlRBuFZUQVFXVEHqV1RBg1hUQRxZVEG1WVRBTVpUQeZaVEF/W1RBGFxUQbFcVEFKXVRB411UQXxeVEEUX1RBrV9UQUZgVEHfYFRBd2FUQRBiVEGpYlRBQmNUQdpjVEFzZFRBDGVUQaRlVEE9ZlRB1mZUQW5nVEEHaFRBn2hUQThpVEHQaVRBaWpUQQFrVEGaa1RBMmxUQctsVEFjbVRB/G1UQZRuVEEtb1RBxW9UQV1wVEH2cFRBjnFUQSZyVEG/clRBV3NUQe9zVEGHdFRBIHVUQbh1VEFQdlRB6HZUQYB3VEEZeFRBsXhUQUl5VEHheVRBeXpUQRF7VEGpe1RBQXxUQdl8VEFxfVRBCX5UQaF+VEE5f1RB0X9UQWmAVEEBgVRBmYFUQTGCVEHJglRBYYNUQfmDVEGRhFRBKIVUQcCFVEFYhlRB8IZUQYiHVEEfiFRBt4hUQU+JVEHniVRBfopUQRaLVEGui1RBRYxUQd2MVEF1jVRBDI5UQaSOVEE7j1RB049UQWqQVEECkVRBmZFUQTGSVEHIklRBYJNUQfeTVEGPlFRBJpVUQb6VVEFVllRB7JZUQYSXVEEbmFRBsphUQUqZVEHhmVRBeJpUQRCbVEGnm1RBPpxUQdWcVEFsnVRBBJ5UQZueVEEyn1RByZ9UQWCgVEH3oFRBj6FUQSaiVEG9olRBVKNUQeujVEGCpFRBGaVUQbClVEFHplRB3qZUQXWnVEEMqFRBo6hUQTqpVEHQqVRBZ6pUQf6qVEGVq1RBLKxUQcOsVEFZrVRB8K1UQYeuVEEer1RBta9UQUuwVEHisFRBebFUQQ+yVEGmslRBPbNUQdOzVEFqtFRBAbVUQZe1VEEutlRBxLZUQVu3VEHxt1RBiLhUQR65VEG1uVRBS7pUQeK6VEF4u1RBD7xUQaW8VEE7vVRB0r1UQWi+VEH/vlRBlb9UQSvAVEHCwFRBWMFUQe7BVEGEwlRBG8NUQbHDVEFHxFRB3cRUQXPFVEEKxlRBoMZUQTbHVEHMx1RBYshUQfjIVEGOyVRBJMpUQbrKVEFRy1RB58tUQX3MVEETzVRBqc1UQT7OVEHUzlRBas9UQQDQVEGW0FRBLNFUQcLRVEFY0lRB7tJUQYTTVEEZ1FRBr9RUQUXVVEHb1VRBcNZUQQbXVEGc11RBMthUQcfYVEFd2VRB89lUQYjaVEEe21RBtNtUQUncVEHf3FRBdN1UQQreVEGf3lRBNd9UQcvfVEFg4FRB9uBUQYvhVEEg4lRBtuJUQUvjVEHh41RBduRUQQzlVEGh5VRBNuZUQczmVEFh51RB9udUQYzoVEEh6VRBtulUQUvqVEHh6lRBdutUQQvsVEGg7FRBNe1UQcvtVEFg7lRB9e5UQYrvVEEf8FRBtPBUQUnxVEHe8VRBc/JUQQjzVEGd81RBMvRUQcf0VEFc9VRB8fVUQYb2VEEb91RBsPdUQUX4VEHa+FRBb/lUQQT6VEGZ+lRBLftUQcL7VEFX/FRB7PxUQYH9VEEV/lRBqv5UQT//VEHU/1RBaABVQf0AVUGSAVVBJgJVQbsCVUFPA1VB5ANVQXkEVUENBVVBogVVQTYGVUHLBlVBXwdVQfQHVUGICFVBHQlVQbEJVUFGClVB2gpVQW8LVUEDDFVBlwxVQSwNVUHADVVBVQ5VQekOVUF9D1VBEhBVQaYQVUE6EVVBzhFVQWMSVUH3ElVBixNVQR8UVUGzFFVBSBVVQdwVVUFwFlVBBBdVQZgXVUEsGFVBwBhVQVQZVUHoGVVBfRpVQREbVUGlG1VBORxVQc0cVUFhHVVB9B1VQYgeVUEcH1VBsB9VQUQgVUHYIFVBbCFVQQAiVUGUIlVBJyNVQbsjVUFPJFVB4yRVQXclVUEKJlVBniZVQTInVUHGJ1VBWShVQe0oVUGBKVVBFCpVQagqVUE7K1VBzytVQWMsVUH2LFVBii1VQR0uVUGxLlVBRC9VQdgvVUFrMFVB/zBVQZIxVUEmMlVBuTJVQU0zVUHgM1VBczRVQQc1VUGaNVVBLjZVQcE2VUFUN1VB6DdVQXs4VUEOOVVBoTlVQTU6VUHIOlVBWztVQe47VUGBPFVBFT1VQag9VUE7PlVBzj5VQWE/VUH0P1VBh0BVQRtBVUGuQVVBQUJVQdRCVUFnQ1VB+kNVQY1EVUEgRVVBs0VVQUZGVUHZRlVBa0dVQf5HVUGRSFVBJElVQbdJVUFKSlVB3UpVQW9LVUECTFVBlUxVQShNVUG7TVVBTU5VQeBOVUFzT1VBBlBVQZhQVUErUVVBvlFVQVBSVUHjUlVBdlNVQQhUVUGbVFVBLVVVQcBVVUFSVlVB5VZVQXdXVUEKWFVBnFhVQS9ZVUHBWVVBVFpVQeZaVUF5W1VBC1xVQZ5cVUEwXVVBwl1VQVVeVUHnXlVBeV9VQQxgVUGeYFVBMGFVQcJhVUFVYlVB52JVQXljVUELZFVBnmRVQTBlVUHCZVVBVGZVQeZmVUF4Z1VBCmhVQZ1oVUEvaVVBwWlVQVNqVUHlalVBd2tVQQlsVUGbbFVBLW1VQb9tVUFRblVB425VQXVvVUEHcFVBmHBVQSpxVUG8cVVBTnJVQeByVUFyc1VBBHRVQZV0VUEndVVBuXVVQUt2VUHcdlVBbndVQQB4VUGSeFVBI3lVQbV5VUFHelVB2HpVQWp7VUH8e1VBjXxVQR99VUGwfVVBQn5VQdN+VUFlf1VB9n9VQYiAVUEZgVVBq4FVQTyCVUHOglVBX4NVQfGDVUGChFVBFIVVQaWFVUE2hlVByIZVQVmHVUHqh1VBfIhVQQ2JVUGeiVVBL4pVQcGKVUFSi1VB44tVQXSMVUEGjVVBl41VQSiOVUG5jlVBSo9VQduPVUFtkFVB/pBVQY+RVUEgklVBsZJVQUKTVUHTk1VBZJRVQfWUVUGGlVVBF5ZVQaiWVUE5l1VBypdVQVuYVUHsmFVBfZlVQQ2aVUGemlVBL5tVQcCbVUFRnFVB4pxVQXKdVUEDnlVBlJ5VQSWfVUG1n1VBRqBVQdegVUFooVVB+KFVQYmiVUEao1VBqqNVQTukVUHMpFVBXKVVQe2lVUF9plVBDqdVQZ6nVUEvqFVBv6hVQVCpVUHgqVVBcapVQQGrVUGSq1VBIqxVQbOsVUFDrVVB1K1VQWSuVUH0rlVBha9VQRWwVUGlsFVBNrFVQcaxVUFWslVB5rJVQXezVUEHtFVBl7RVQSe1VUG4tVVBSLZVQdi2VUFot1VB+LdVQYi4VUEZuVVBqblVQTm6VUHJulVBWbtVQem7VUF5vFVBCb1VQZm9VUEpvlVBub5VQUm/VUHZv1VBacBVQfnAVUGJwVVBGcJVQanCVUE4w1VByMNVQVjEVUHoxFVBeMVVQQjGVUGXxlVBJ8dVQbfHVUFHyFVB1shVQWbJVUH2yVVBhspVQRXLVUGly1VBNcxVQcTMVUFUzVVB481VQXPOVUEDz1VBks9VQSLQVUGx0FVBQdFVQdDRVUFg0lVB79JVQX/TVUEO1FVBntRVQS3VVUG91VVBTNZVQdvWVUFr11VB+tdVQYrYVUEZ2VVBqNlVQTjaVUHH2lVBVttVQeXbVUF13FVBBN1VQZPdVUEi3lVBst5VQUHfVUHQ31VBX+BVQe7gVUF94VVBDeJVQZziVUEr41VBuuNVQUnkVUHY5FVBZ+VVQfblVUGF5lVBFOdVQaPnVUEy6FVBwehVQVDpVUHf6VVBbupVQf3qVUGM61VBG+xVQansVUE47VVBx+1VQVbuVUHl7lVBdO9VQQLwVUGR8FVBIPFVQa/xVUE98lVBzPJVQVvzVUHp81VBePRVQQf1VUGV9VVBJPZVQbP2VUFB91VB0PdVQV/4VUHt+FVBfPlVQQr6VUGZ+lVBJ/tVQbb7VUFE/FVB0/xVQWH9VUHw/VVBfv5VQQ3/VUGb/1VBKQBWQbgAVkFGAVZB1AFWQWMCVkHxAlZBfwNWQQ4EVkGcBFZBKgVWQbkFVkFHBlZB1QZWQWMHVkHyB1ZBgAhWQQ4JVkGcCVZBKgpWQbgKVkFHC1ZB1QtWQWMMVkHxDFZBfw1WQQ0OVkGbDlZBKQ9WQbcPVkFFEFZB0xBWQWERVkHvEVZBfRJWQQsTVkGZE1ZBJxRWQbUUVkFDFVZB0BVWQV4WVkHsFlZBehdWQQgYVkGWGFZBIxlWQbEZVkE/GlZBzRpWQVsbVkHoG1ZBdhxWQQQdVkGRHVZBHx5WQa0eVkE6H1ZByB9WQVYgVkHjIFZBcSFWQf4hVkGMIlZBGiNWQacjVkE1JFZBwiRWQVAlVkHdJVZBayZWQfgmVkGGJ1ZBEyhWQaAoVkEuKVZBuylWQUkqVkHWKlZBYytWQfErVkF+LFZBCy1WQZktVkEmLlZBsy5WQUEvVkHOL1ZBWzBWQegwVkF1MVZBAzJWQZAyVkEdM1ZBqjNWQTc0VkHENFZBUjVWQd81VkFsNlZB+TZWQYY3VkETOFZBoDhWQS05VkG6OVZBRzpWQdQ6VkFhO1ZB7jtWQXs8VkEIPVZBlT1WQSI+VkGvPlZBPD9WQcg/VkFVQFZB4kBWQW9BVkH8QVZBiUJWQRVDVkGiQ1ZBL0RWQbxEVkFIRVZB1UVWQWJGVkHvRlZBe0dWQQhIVkGVSFZBIUlWQa5JVkE7SlZBx0pWQVRLVkHgS1ZBbUxWQfpMVkGGTVZBE05WQZ9OVkEsT1ZBuE9WQUVQVkHRUFZBXlFWQepRVkF2UlZBA1NWQY9TVkEcVFZBqFRWQTRVVkHBVVZBTVZWQdlWVkFmV1ZB8ldWQX5YVkELWVZBl1lWQSNaVkGvWlZBO1tWQchbVkFUXFZB4FxWQWxdVkH4XVZBhV5WQRFfVkGdX1ZBKWBWQbVgVkFBYVZBzWFWQVliVkHlYlZBcWNWQf1jVkGJZFZBFWVWQaFlVkEtZlZBuWZWQUVnVkHRZ1ZBXWhWQeloVkF1aVZBAWpWQYxqVkEYa1ZBpGtWQTBsVkG8bFZBSG1WQdNtVkFfblZB625WQXdvVkECcFZBjnBWQRpxVkGlcVZBMXJWQb1yVkFIc1ZB1HNWQWB0VkHrdFZBd3VWQQJ2VkGOdlZBGndWQaV3VkExeFZBvHhWQUh5VkHTeVZBX3pWQep6VkF2e1ZBAXxWQYx8VkEYfVZBo31WQS9+VkG6flZBRX9WQdF/VkFcgFZB54BWQXOBVkH+gVZBiYJWQRWDVkGgg1ZBK4RWQbaEVkFChVZBzYVWQViGVkHjhlZBbodWQfqHVkGFiFZBEIlWQZuJVkEmilZBsYpWQTyLVkHHi1ZBUoxWQd6MVkFpjVZB9I1WQX+OVkEKj1ZBlY9WQSCQVkGqkFZBNZFWQcCRVkFLklZB1pJWQWGTVkHsk1ZBd5RWQQKVVkGNlVZBF5ZWQaKWVkEtl1ZBuJdWQUOYVkHNmFZBWJlWQeOZVkFumlZB+JpWQYObVkEOnFZBmJxWQSOdVkGunVZBOJ5WQcOeVkFOn1ZB2J9WQWOgVkHtoFZBeKFWQQKiVkGNolZBGKNWQaKjVkEtpFZBt6RWQUGlVkHMpVZBVqZWQeGmVkFrp1ZB9qdWQYCoVkEKqVZBlalWQR+qVkGqqlZBNKtWQb6rVkFJrFZB06xWQV2tVkHnrVZBcq5WQfyuVkGGr1ZBELBWQZuwVkElsVZBr7FWQTmyVkHDslZBTbNWQdizVkFitFZB7LRWQXa1VkEAtlZBirZWQRS3VkGet1ZBKLhWQbK4VkE8uVZBxrlWQVC6VkHaulZBZLtWQe67VkF4vFZBAr1WQYy9VkEWvlZBoL5WQSm/VkGzv1ZBPcBWQcfAVkFRwVZB28FWQWTCVkHuwlZBeMNWQQLEVkGLxFZBFcVWQZ/FVkEpxlZBssZWQTzHVkHGx1ZBT8hWQdnIVkFjyVZB7MlWQXbKVkH/ylZBictWQRPMVkGczFZBJs1WQa/NVkE5zlZBws5WQUzPVkHVz1ZBX9BWQejQVkFy0VZB+9FWQYTSVkEO01ZBl9NWQSHUVkGq1FZBM9VWQb3VVkFG1lZBz9ZWQVnXVkHi11ZBa9hWQfTYVkF+2VZBB9pWQZDaVkEZ21ZBo9tWQSzcVkG13FZBPt1WQcfdVkFQ3lZB2t5WQWPfVkHs31ZBdeBWQf7gVkGH4VZBEOJWQZniVkEi41ZBq+NWQTTkVkG95FZBRuVWQc/lVkFY5lZB4eZWQWrnVkHz51ZBfOhWQQXpVkGO6VZBF+pWQZ/qVkEo61ZBsetWQTrsVkHD7FZBS+1WQdTtVkFd7lZB5u5WQW/vVkH371ZBgPBWQQnxVkGR8VZBGvJWQaPyVkEr81ZBtPNWQT30VkHF9FZBTvVWQdf1VkFf9lZB6PZWQXD3VkH591ZBgfhWQQr5VkGS+VZBG/pWQaP6VkEs+1ZBtPtWQT38VkHF/FZBTv1WQdb9VkFe/lZB5/5WQW//VkH4/1ZBgABXQQgBV0GRAVdBGQJXQaECV0EqA1dBsgNXQToEV0HCBFdBSwVXQdMFV0FbBldB4wZXQWsHV0H0B1dBfAhXQQQJV0GMCVdBFApXQZwKV0EkC1dBrQtXQTUMV0G9DFdBRQ1XQc0NV0FVDldB3Q5XQWUPV0HtD1dBdRBXQf0QV0GFEVdBDRJXQZUSV0EdE1dBpRNXQSwUV0G0FFdBPBVXQcQVV0FMFldB1BZXQVwXV0HjF1dBaxhXQfMYV0F7GVdBAxpXQYoaV0ESG1dBmhtXQSEcV0GpHFdBMR1XQbkdV0FAHldByB5XQVAfV0HXH1dBXyBXQeYgV0FuIVdB9iFXQX0iV0EFI1dBjCNXQRQkV0GbJFdBIyVXQaolV0EyJldBuSZXQUEnV0HIJ1dBUChXQdcoV0FeKVdB5ilXQW0qV0H1KldBfCtXQQMsV0GLLFdBEi1XQZktV0EhLldBqC5XQS8vV0G2L1dBPjBXQcUwV0FMMVdB0zFXQVsyV0HiMldBaTNXQfAzV0F3NFdB/zRXQYY1V0ENNldBlDZXQRs3V0GiN1dBKThXQbA4V0E3OVdBvjlXQUU6V0HMOldBUztXQdo7V0FhPFdB6DxXQW89V0H2PVdBfT5XQQQ/V0GLP1dBEkBXQZlAV0EgQVdBpkFXQS1CV0G0QldBO0NXQcJDV0FJRFdBz0RXQVZFV0HdRVdBZEZXQepGV0FxR1dB+EdXQX9IV0EFSVdBjElXQRNKV0GZSldBIEtXQaZLV0EtTFdBtExXQTpNV0HBTVdBR05XQc5OV0FVT1dB209XQWJQV0HoUFdBb1FXQfVRV0F8UldBAlNXQYhTV0EPVFdBlVRXQRxVV0GiVVdBKVZXQa9WV0E1V1dBvFdXQUJYV0HIWFdBT1lXQdVZV0FbWldB4lpXQWhbV0HuW1dBdFxXQftcV0GBXVdBB15XQY1eV0ETX1dBml9XQSBgV0GmYFdBLGFXQbJhV0E4YldBvmJXQURjV0HLY1dBUWRXQddkV0FdZVdB42VXQWlmV0HvZldBdWdXQftnV0GBaFdBB2lXQY1pV0ETaldBmWpXQR5rV0Gka1dBKmxXQbBsV0E2bVdBvG1XQUJuV0HIbldBTW9XQdNvV0FZcFdB33BXQWVxV0HqcVdBcHJXQfZyV0F7c1dBAXRXQYd0V0ENdVdBknVXQRh2V0GedldBI3dXQal3V0EueFdBtHhXQTp5V0G/eVdBRXpXQcp6V0FQe1dB1XtXQVt8V0HhfFdBZn1XQex9V0FxfldB9n5XQXx/V0EBgFdBh4BXQQyBV0GSgVdBF4JXQZyCV0Eig1dBp4NXQSyEV0GyhFdBN4VXQbyFV0FChldBx4ZXQUyHV0HSh1dBV4hXQdyIV0FhiVdB54lXQWyKV0HxildBdotXQfuLV0GAjFdBBo1XQYuNV0EQjldBlY5XQRqPV0Gfj1dBJJBXQamQV0EukVdBs5FXQTiSV0G9kldBQpNXQceTV0FMlFdB0ZRXQVaVV0HblVdBYJZXQeWWV0Fql1dB75dXQXSYV0H5mFdBfplXQQOaV0GHmldBDJtXQZGbV0EWnFdBm5xXQR+dV0GknVdBKZ5XQa6eV0Eyn1dBt59XQTygV0HBoFdBRaFXQcqhV0FPoldB06JXQVijV0Hdo1dBYaRXQeakV0FqpVdB76VXQXSmV0H4pldBfadXQQGoV0GGqFdBCqlXQY+pV0ETqldBmKpXQRyrV0Ghq1dBJaxXQaqsV0EurVdBsq1XQTeuV0G7rldBQK9XQcSvV0FIsFdBzbBXQVGxV0HVsVdBWrJXQd6yV0Fis1dB57NXQWu0V0HvtFdBc7VXQfi1V0F8tldBALdXQYS3V0EIuFdBjbhXQRG5V0GVuVdBGbpXQZ26V0Ehu1dBpbtXQSm8V0GtvFdBMr1XQba9V0E6vldBvr5XQUK/V0HGv1dBSsBXQc7AV0FSwVdB1sFXQVrCV0HewldBYcNXQeXDV0FpxFdB7cRXQXHFV0H1xVdBecZXQf3GV0GBx1dBBMhXQYjIV0EMyVdBkMlXQRTKV0GXyldBG8tXQZ/LV0EjzFdBpsxXQSrNV0GuzVdBMc5XQbXOV0E5z1dBvM9XQUDQV0HE0FdBR9FXQcvRV0FO0ldB0tJXQVbTV0HZ01dBXdRXQeDUV0Fk1VdB59VXQWvWV0Hu1ldBctdXQfXXV0F52FdB/NhXQYDZV0ED2ldBhtpXQQrbV0GN21dBEdxXQZTcV0EX3VdBm91XQR7eV0Gh3ldBJd9XQajfV0Er4FdBr+BXQTLhV0G14VdBOOJXQbziV0E/41dBwuNXQUXkV0HI5FdBTOVXQc/lV0FS5ldB1eZXQVjnV0Hb51dBXuhXQeHoV0Fl6VdB6OlXQWvqV0Hu6ldBcetXQfTrV0F37FdB+uxXQX3tV0EA7ldBg+5XQQbvV0GJ71dBDPBXQY7wV0ER8VdBlPFXQRfyV0Ga8ldBHfNXQaDzV0Ej9FdBpfRXQSj1V0Gr9VdBLvZXQbH2V0Ez91dBtvdXQTn4V0G8+FdBPvlXQcH5V0FE+ldBx/pXQUn7V0HM+1dBT/xXQdH8V0FU/VdB1/1XQVn+V0Hc/ldBXv9XQeH/V0FkAFhB5gBYQWkBWEHrAVhBbgJYQfACWEFzA1hB9QNYQXgEWEH6BFhBfQVYQf8FWEGCBlhBBAdYQYYHWEEJCFhBiwhYQQ4JWEGQCVhBEgpYQZUKWEEXC1hBmQtYQRwMWEGeDFhBIA1YQaMNWEElDlhBpw5YQSkPWEGsD1hBLhBYQbAQWEEyEVhBtBFYQTcSWEG5ElhBOxNYQb0TWEE/FFhBwRRYQUMVWEHGFVhBSBZYQcoWWEFMF1hBzhdYQVAYWEHSGFhBVBlYQdYZWEFYGlhB2hpYQVwbWEHeG1hBYBxYQeIcWEFkHVhB5h1YQWgeWEHqHlhBax9YQe0fWEFvIFhB8SBYQXMhWEH1IVhBdyJYQfgiWEF6I1hB/CNYQX4kWEH/JFhBgSVYQQMmWEGFJlhBBidYQYgnWEEKKFhBjChYQQ0pWEGPKVhBESpYQZIqWEEUK1hBlStYQRcsWEGZLFhBGi1YQZwtWEEdLlhBny5YQSAvWEGiL1hBJDBYQaUwWEEnMVhBqDFYQSoyWEGrMlhBLDNYQa4zWEEvNFhBsTRYQTI1WEG0NVhBNTZYQbY2WEE4N1hBuTdYQTo4WEG8OFhBPTlYQb45WEFAOlhBwTpYQUI7WEHEO1hBRTxYQcY8WEFHPVhByT1YQUo+WEHLPlhBTD9YQc0/WEFOQFhB0EBYQVFBWEHSQVhBU0JYQdRCWEFVQ1hB1kNYQVdEWEHZRFhBWkVYQdtFWEFcRlhB3UZYQV5HWEHfR1hBYEhYQeFIWEFiSVhB40lYQWRKWEHlSlhBZUtYQeZLWEFnTFhB6ExYQWlNWEHqTVhBa05YQexOWEFsT1hB7U9YQW5QWEHvUFhBcFFYQfBRWEFxUlhB8lJYQXNTWEH0U1hBdFRYQfVUWEF2VVhB9lVYQXdWWEH4VlhBeFdYQflXWEF6WFhB+lhYQXtZWEH8WVhBfFpYQf1aWEF9W1hB/ltYQX5cWEH/XFhBgF1YQQBeWEGBXlhBAV9YQYJfWEECYFhBg2BYQQNhWEGDYVhBBGJYQYRiWEEFY1hBhWNYQQVkWEGGZFhBBmVYQYdlWEEHZlhBh2ZYQQhnWEGIZ1hBCGhYQYloWEEJaVhBiWlYQQlqWEGKalhBCmtYQYprWEEKbFhBimxYQQttWEGLbVhBC25YQYtuWEELb1hBi29YQQxwWEGMcFhBDHFYQYxxWEEMclhBjHJYQQxzWEGMc1hBDHRYQYx0WEEMdVhBjHVYQQx2WEGMdlhBDHdYQYx3WEEMeFhBjHhYQQx5WEGMeVhBDHpYQYx6WEEMe1hBjHtYQQt8WEGLfFhBC31YQYt9WEELflhBi35YQQp/WEGKf1hBCoBYQYqAWEEKgVhBiYFYQQmCWEGJglhBCYNYQYiDWEEIhFhBiIRYQQeFWEGHhVhBB4ZYQYaGWEEGh1hBhodYQQWIWEGFiFhBBIlYQYSJWEEDilhBg4pYQQOLWEGCi1hBAoxYQYGMWEEBjVhBgI1YQQCOWEF/jlhB/45YQX6PWEH9j1hBfZBYQfyQWEF8kVhB+5FYQXuSWEH6klhBeZNYQfmTWEF4lFhB95RYQXeVWEH2lVhBdZZYQfWWWEF0l1hB85dYQXKYWEHymFhBcZlYQfCZWEFvmlhB7ppYQW6bWEHtm1hBbJxYQeucWEFqnVhB6Z1YQWmeWEHonlhBZ59YQeafWEFloFhB5KBYQWOhWEHioVhBYaJYQeCiWEFfo1hB3qNYQV2kWEHcpFhBW6VYQdqlWEFZplhB2KZYQVenWEHWp1hBVahYQdSoWEFTqVhB0qlYQVCqWEHPqlhBTqtYQc2rWEFMrFhBy6xYQUmtWEHIrVhBR65YQcauWEFFr1hBw69YQUKwWEHBsFhBQLFYQb6xWEE9slhBvLJYQTqzWEG5s1hBOLRYQba0WEE1tVhBtLVYQTK2WEGxtlhBL7dYQa63WEEtuFhBq7hYQSq5WEGouVhBJ7pYQaW6WEEku1hBortYQSG8WEGfvFhBHr1YQZy9WEEbvlhBmb5YQRi/WEGWv1hBFMBYQZPAWEERwVhBkMFYQQ7CWEGMwlhBC8NYQYnDWEEHxFhBhsRYQQTFWEGCxVhBAMZYQX/GWEH9xlhBe8dYQfnHWEF4yFhB9shYQXTJWEHyyVhBccpYQe/KWEFty1hB68tYQWnMWEHnzFhBZc1YQeTNWEFizlhB4M5YQV7PWEHcz1hBWtBYQdjQWEFW0VhB1NFYQVLSWEHQ0lhBTtNYQczTWEFK1FhByNRYQUbVWEHE1VhBQtZYQcDWWEE+11hBvNdYQTnYWEG32FhBNdlYQbPZWEEx2lhBr9pYQS3bWEGq21hBKNxYQabcWEEk3VhBot1YQR/eWEGd3lhBG99YQZnfWEEW4FhBlOBYQRLhWEGP4VhBDeJYQYviWEEI41hBhuNYQQTkWEGB5FhB/+RYQX3lWEH65VhBeOZYQfXmWEFz51hB8OdYQW7oWEHs6FhBaelYQefpWEFk6lhB4upYQV/rWEHd61hBWuxYQdfsWEFV7VhB0u1YQVDuWEHN7lhBS+9YQcjvWEFF8FhBw/BYQUDxWEG98VhBO/JYQbjyWEE181hBs/NYQTD0WEGt9FhBK/VYQaj1WEEl9lhBovZYQSD3WEGd91hBGvhYQZf4WEEU+VhBkvlYQQ/6WEGM+lhBCftYQYb7WEED/FhBgPxYQf78WEF7/VhB+P1YQXX+WEHy/lhBb/9YQez/WEFpAFlB5gBZQWMBWUHgAVlBXQJZQdoCWUFXA1lB1ANZQVEEWUHOBFlBSwVZQcgFWUFFBllBwgZZQT8HWUG7B1lBOAhZQbUIWUEyCVlBrwlZQSwKWUGoCllBJQtZQaILWUEfDFlBnAxZQRgNWUGVDVlBEg5ZQY8OWUELD1lBiA9ZQQUQWUGCEFlB/hBZQXsRWUH4EVlBdBJZQfESWUFuE1lB6hNZQWcUWUHjFFlBYBVZQd0VWUFZFllB1hZZQVIXWUHPF1lBSxhZQcgYWUFEGVlBwRlZQT0aWUG6GllBNhtZQbMbWUEvHFlBrBxZQSgdWUGlHVlBIR5ZQZ0eWUEaH1lBlh9ZQRIgWUGPIFlBCyFZQYghWUEEIllBgCJZQfwiWUF5I1lB9SNZQXEkWUHuJFlBaiVZQeYlWUFiJllB3yZZQVsnWUHXJ1lBUyhZQc8oWUFMKVlByClZQUQqWUHAKllBPCtZQbgrWUE0LFlBsCxZQS0tWUGpLVlBJS5ZQaEuWUEdL1lBmS9ZQRUwWUGRMFlBDTFZQYkxWUEFMllBgTJZQf0yWUF5M1lB9TNZQXE0WUHtNFlBaTVZQeU1WUFgNllB3DZZQVg3WUHUN1lBUDhZQcw4WUFIOVlBwzlZQT86WUG7OllBNztZQbM7WUEuPFlBqjxZQSY9WUGiPVlBHT5ZQZk+WUEVP1lBkT9ZQQxAWUGIQFlBBEFZQX9BWUH7QVlBd0JZQfJCWUFuQ1lB6kNZQWVEWUHhRFlBXEVZQdhFWUFURllBz0ZZQUtHWUHGR1lBQkhZQb1IWUE5SVlBtElZQTBKWUGrSllBJ0tZQaJLWUEeTFlBmUxZQRRNWUGQTVlBC05ZQYdOWUECT1lBfU9ZQflPWUF0UFlB71BZQWtRWUHmUVlBYVJZQd1SWUFYU1lB01NZQU9UWUHKVFlBRVVZQcBVWUE8VllBt1ZZQTJXWUGtV1lBKFhZQaRYWUEfWVlBmllZQRVaWUGQWllBC1tZQYdbWUECXFlBfVxZQfhcWUFzXVlB7l1ZQWleWUHkXllBX19ZQdpfWUFVYFlB0GBZQUthWUHGYVlBQWJZQbxiWUE3Y1lBsmNZQS1kWUGoZFlBI2VZQZ5lWUEZZllBlGZZQQ9nWUGJZ1lBBGhZQX9oWUH6aFlBdWlZQfBpWUFqallB5WpZQWBrWUHba1lBVmxZQdBsWUFLbVlBxm1ZQUFuWUG7bllBNm9ZQbFvWUErcFlBpnBZQSFxWUGbcVlBFnJZQZFyWUELc1lBhnNZQQF0WUF7dFlB9nRZQXB1WUHrdVlBZnZZQeB2WUFbd1lB1XdZQVB4WUHKeFlBRXlZQb95WUE6ellBtHpZQS97WUGpe1lBJHxZQZ58WUEYfVlBk31ZQQ1+WUGIfllBAn9ZQXx/WUH3f1lBcYBZQeyAWUFmgVlB4IFZQVuCWUHVgllBT4NZQcmDWUFEhFlBvoRZQTiFWUGyhVlBLYZZQaeGWUEhh1lBm4dZQRaIWUGQiFlBColZQYSJWUH+iVlBeIpZQfOKWUFti1lB54tZQWGMWUHbjFlBVY1ZQc+NWUFJjllBw45ZQT2PWUG3j1lBMZBZQauQWUElkVlBn5FZQRmSWUGTkllBDZNZQYeTWUEBlFlBe5RZQfWUWUFvlVlB6ZVZQWOWWUHdlllBV5dZQdGXWUFLmFlBxJhZQT6ZWUG4mVlBMppZQayaWUElm1lBn5tZQRmcWUGTnFlBDZ1ZQYadWUEAnllBep5ZQfSeWUFtn1lB559ZQWGgWUHaoFlBVKFZQc6hWUFHollBwaJZQTujWUG0o1lBLqRZQaikWUEhpVlBm6VZQRSmWUGOpllBB6dZQYGnWUH7p1lBdKhZQe6oWUFnqVlB4alZQVqqWUHUqllBTatZQcerWUFArFlBuaxZQTOtWUGsrVlBJq5ZQZ+uWUEZr1lBkq9ZQQuwWUGFsFlB/rBZQXexWUHxsVlBarJZQeOyWUFds1lB1rNZQU+0WUHJtFlBQrVZQbu1WUE0tllBrrZZQSe3WUGgt1lBGbhZQZK4WUEMuVlBhblZQf65WUF3ullB8LpZQWm7WUHju1lBXLxZQdW8WUFOvVlBx71ZQUC+WUG5vllBMr9ZQau/WUEkwFlBncBZQRbBWUGPwVlBCMJZQYHCWUH6wllBc8NZQezDWUFlxFlB3sRZQVfFWUHQxVlBScZZQcLGWUE7x1lBtMdZQS3IWUGlyFlBHslZQZfJWUEQyllBicpZQQLLWUF7y1lB88tZQWzMWUHlzFlBXs1ZQdbNWUFPzllByM5ZQUHPWUG5z1lBMtBZQavQWUEk0VlBnNFZQRXSWUGO0llBBtNZQX/TWUH401lBcNRZQenUWUFh1VlB2tVZQVPWWUHL1llBRNdZQbzXWUE12FlBrdhZQSbZWUGe2VlBF9pZQY/aWUEI21lBgNtZQfnbWUFx3FlB6txZQWLdWUHb3VlBU95ZQczeWUFE31lBvN9ZQTXgWUGt4FlBJuFZQZ7hWUEW4llBj+JZQQfjWUF/41lB+ONZQXDkWUHo5FlBYOVZQdnlWUFR5llByeZZQULnWUG651lBMuhZQaroWUEi6VlBm+lZQRPqWUGL6llBA+tZQXvrWUHz61lBbOxZQeTsWUFc7VlB1O1ZQUzuWUHE7llBPO9ZQbTvWUEs8FlBpPBZQR3xWUGV8VlBDfJZQYXyWUH98llBdfNZQe3zWUFl9FlB3fRZQVX1WUHM9VlBRPZZQbz2WUE091lBrPdZQST4WUGc+FlBFPlZQYz5WUEE+llBe/pZQfP6WUFr+1lB4/tZQVv8WUHT/FlBSv1ZQcL9WUE6/llBsv5ZQSr/WUGh/1lBGQBaQZEAWkEIAVpBgAFaQfgBWkFwAlpB5wJaQV8DWkHXA1pBTgRaQcYEWkE+BVpBtQVaQS0GWkGkBlpBHAdaQZQHWkELCFpBgwhaQfoIWkFyCVpB6QlaQWEKWkHYClpBUAtaQcgLWkE/DFpBtwxaQS4NWkGlDVpBHQ5aQZQOWkEMD1pBgw9aQfsPWkFyEFpB6RBaQWERWkHYEVpBUBJaQccSWkE+E1pBthNaQS0UWkGkFFpBHBVaQZMVWkEKFlpBghZaQfkWWkFwF1pB5xdaQV8YWkHWGFpBTRlaQcQZWkE8GlpBsxpaQSobWkGhG1pBGBxaQY8cWkEHHVpBfh1aQfUdWkFsHlpB4x5aQVofWkHRH1pBSCBaQcAgWkE3IVpBriFaQSUiWkGcIlpBEyNaQYojWkEBJFpBeCRaQe8kWkFmJVpB3SVaQVQmWkHLJlpBQidaQbknWkEwKFpBpyhaQR0pWkGUKVpBCypaQYIqWkH5KlpBcCtaQecrWkFeLFpB1CxaQUstWkHCLVpBOS5aQbAuWkEnL1pBnS9aQRQwWkGLMFpBAjFaQXgxWkHvMVpBZjJaQd0yWkFTM1pByjNaQUE0WkG3NFpBLjVaQaU1WkEbNlpBkjZaQQk3WkF/N1pB9jdaQWw4WkHjOFpBWjlaQdA5WkFHOlpBvTpaQTQ7WkGqO1pBITxaQZc8WkEOPVpBhD1aQfs9WkFxPlpB6D5aQV4/WkHVP1pBS0BaQcJAWkE4QVpBr0FaQSVCWkGbQlpBEkNaQYhDWkH/Q1pBdURaQetEWkFiRVpB2EVaQU5GWkHFRlpBO0daQbFHWkEoSFpBnkhaQRRJWkGKSVpBAUpaQXdKWkHtSlpBY0taQdpLWkFQTFpBxkxaQTxNWkGyTVpBKU5aQZ9OWkEVT1pBi09aQQFQWkF3UFpB7VBaQWNRWkHaUVpBUFJaQcZSWkE8U1pBslNaQShUWkGeVFpBFFVaQYpVWkEAVlpBdlZaQexWWkFiV1pB2FdaQU5YWkHEWFpBOllaQbBZWkEmWlpBnFpaQRJbWkGHW1pB/VtaQXNcWkHpXFpBX11aQdVdWkFLXlpBwV5aQTZfWkGsX1pBImBaQZhgWkEOYVpBg2FaQflhWkFvYlpB5WJaQVpjWkHQY1pBRmRaQbxkWkExZVpBp2VaQR1mWkGSZlpBCGdaQX5nWkHzZ1pBaWhaQd9oWkFUaVpBymlaQUBqWkG1alpBK2taQaBrWkEWbFpBi2xaQQFtWkF3bVpB7G1aQWJuWkHXblpBTW9aQcJvWkE4cFpBrXBaQSNxWkGYcVpBDnJaQYNyWkH4clpBbnNaQeNzWkFZdFpBznRaQUR1WkG5dVpBLnZaQaR2WkEZd1pBjndaQQR4WkF5eFpB7nhaQWR5WkHZeVpBTnpaQcR6WkE5e1pBrntaQSN8WkGZfFpBDn1aQYN9WkH4fVpBbX5aQeN+WkFYf1pBzX9aQUKAWkG3gFpBLYFaQaKBWkEXglpBjIJaQQGDWkF2g1pB64NaQWCEWkHVhFpBS4VaQcCFWkE1hlpBqoZaQR+HWkGUh1pBCYhaQX6IWkHziFpBaIlaQd2JWkFSilpBx4paQTyLWkGxi1pBJoxaQZqMWkEPjVpBhI1aQfmNWkFujlpB445aQViPWkHNj1pBQpBaQbaQWkErkVpBoJFaQRWSWkGKklpB/5JaQXOTWkHok1pBXZRaQdKUWkFGlVpBu5VaQTCWWkGlllpBGZdaQY6XWkEDmFpBd5haQeyYWkFhmVpB1ZlaQUqaWkG/mlpBM5taQaibWkEdnFpBkZxaQQadWkF7nVpB751aQWSeWkHYnlpBTZ9aQcGfWkE2oFpBqqBaQR+hWkGToVpBCKJaQXyiWkHxolpBZaNaQdqjWkFOpFpBw6RaQTelWkGspVpBIKZaQZWmWkEJp1pBfadaQfKnWkFmqFpB2qhaQU+pWkHDqVpBOKpaQayqWkEgq1pBlataQQmsWkF9rFpB8axaQWatWkHarVpBTq5aQcOuWkE3r1pBq69aQR+wWkGTsFpBCLFaQXyxWkHwsVpBZLJaQdiyWkFNs1pBwbNaQTW0WkGptFpBHbVaQZG1WkEFtlpBebZaQe62WkFit1pB1rdaQUq4WkG+uFpBMrlaQaa5WkEaulpBjrpaQQK7WkF2u1pB6rtaQV68WkHSvFpBRr1aQbq9WkEuvlpBor5aQRa/WkGKv1pB/r9aQXLAWkHlwFpBWcFaQc3BWkFBwlpBtcJaQSnDWkGdw1pBEMRaQYTEWkH4xFpBbMVaQeDFWkFUxlpBx8ZaQTvHWkGvx1pBI8haQZbIWkEKyVpBfslaQfLJWkFlylpB2cpaQU3LWkHAy1pBNMxaQajMWkEbzVpBj81aQQPOWkF2zlpB6s5aQV7PWkHRz1pBRdBaQbjQWkEs0VpBn9FaQRPSWkGH0lpB+tJaQW7TWkHh01pBVdRaQcjUWkE81VpBr9VaQSPWWkGW1lpBCtdaQX3XWkHx11pBZNhaQdfYWkFL2VpBvtlaQTLaWkGl2lpBGNtaQYzbWkH/21pBc9xaQebcWkFZ3VpBzd1aQUDeWkGz3lpBJ99aQZrfWkEN4FpBgOBaQfTgWkFn4VpB2uFaQU3iWkHB4lpBNONaQafjWkEa5FpBjuRaQQHlWkF05VpB5+VaQVrmWkHN5lpBQedaQbTnWkEn6FpBmuhaQQ3pWkGA6VpB8+laQWbqWkHZ6lpBTetaQcDrWkEz7FpBpuxaQRntWkGM7VpB/+1aQXLuWkHl7lpBWO9aQcvvWkE+8FpBsfBaQSTxWkGX8VpBCvJaQXzyWkHv8lpBYvNaQdXzWkFI9FpBu/RaQS71WkGh9VpBFPZaQYb2WkH59lpBbPdaQd/3WkFS+FpBxfhaQTf5WkGq+VpBHfpaQZD6WkEC+1pBdftaQej7WkFb/FpBzfxaQUD9WkGz/VpBJv5aQZj+WkEL/1pBfv9aQfD/WkFjAFtB1gBbQUgBW0G7AVtBLgJbQaACW0ETA1tBhQNbQfgDW0FrBFtB3QRbQVAFW0HCBVtBNQZbQacGW0EaB1tBjAdbQf8HW0FxCFtB5AhbQVYJW0HJCVtBOwpbQa4KW0EgC1tBkwtbQQUMW0F4DFtB6gxbQVwNW0HPDVtBQQ5bQbQOW0EmD1tBmA9bQQsQW0F9EFtB7xBbQWIRW0HUEVtBRhJbQbkSW0ErE1tBnRNbQQ8UW0GCFFtB9BRbQWYVW0HYFVtBSxZbQb0WW0EvF1tBoRdbQRQYW0GGGFtB+BhbQWoZW0HcGVtBThpbQcEaW0EzG1tBpRtbQRccW0GJHFtB+xxbQW0dW0HfHVtBUh5bQcQeW0E2H1tBqB9bQRogW0GMIFtB/iBbQXAhW0HiIVtBVCJbQcYiW0E4I1tBqiNbQRwkW0GOJFtBACVbQXIlW0HkJVtBViZbQccmW0E5J1tBqydbQR0oW0GPKFtBASlbQXMpW0HlKVtBVipbQcgqW0E6K1tBrCtbQR4sW0GQLFtBAS1bQXMtW0HlLVtBVy5bQcguW0E6L1tBrC9bQR4wW0GPMFtBATFbQXMxW0HlMVtBVjJbQcgyW0E6M1tBqzNbQR00W0GPNFtBADVbQXI1W0HkNVtBVTZbQcc2W0E4N1tBqjdbQRw4W0GNOFtB/zhbQXA5W0HiOVtBUzpbQcU6W0E2O1tBqDtbQRk8W0GLPFtB/DxbQW49W0HfPVtBUT5bQcI+W0E0P1tBpT9bQRdAW0GIQFtB+UBbQWtBW0HcQVtBTkJbQb9CW0EwQ1tBokNbQRNEW0GERFtB9kRbQWdFW0HYRVtBSkZbQbtGW0EsR1tBnkdbQQ9IW0GASFtB8UhbQWNJW0HUSVtBRUpbQbZKW0EoS1tBmUtbQQpMW0F7TFtB7ExbQV5NW0HPTVtBQE5bQbFOW0EiT1tBk09bQQRQW0F2UFtB51BbQVhRW0HJUVtBOlJbQatSW0EcU1tBjVNbQf5TW0FvVFtB4FRbQVFVW0HCVVtBM1ZbQaRWW0EVV1tBhldbQfdXW0FoWFtB2VhbQUpZW0G7WVtBLFpbQZ1aW0EOW1tBf1tbQfBbW0FhXFtB0VxbQUJdW0GzXVtBJF5bQZVeW0EGX1tBd19bQedfW0FYYFtByWBbQTphW0GrYVtBG2JbQYxiW0H9YltBbmNbQd5jW0FPZFtBwGRbQTFlW0GhZVtBEmZbQYNmW0HzZltBZGdbQdVnW0FFaFtBtmhbQSdpW0GXaVtBCGpbQXlqW0HpaltBWmtbQcprW0E7bFtBrGxbQRxtW0GNbVtB/W1bQW5uW0HebltBT29bQb9vW0EwcFtBoHBbQRFxW0GBcVtB8nFbQWJyW0HTcltBQ3NbQbRzW0EkdFtBlXRbQQV1W0F1dVtB5nVbQVZ2W0HHdltBN3dbQad3W0EYeFtBiHhbQfh4W0FpeVtB2XlbQUl6W0G6eltBKntbQZp7W0ELfFtBe3xbQet8W0FbfVtBzH1bQTx+W0GsfltBHH9bQY1/W0H9f1tBbYBbQd2AW0FNgVtBvoFbQS6CW0GegltBDoNbQX6DW0Hug1tBXoRbQc+EW0E/hVtBr4VbQR+GW0GPhltB/4ZbQW+HW0Hfh1tBT4hbQb+IW0EviVtBn4lbQQ+KW0F/iltB74pbQV+LW0HPi1tBP4xbQa+MW0EfjVtBj41bQf+NW0FvjltB345bQU+PW0G/j1tBL5BbQZ+QW0EPkVtBfpFbQe6RW0FekltBzpJbQT6TW0Guk1tBHZRbQY2UW0H9lFtBbZVbQd2VW0FNlltBvJZbQSyXW0Gcl1tBDJhbQXuYW0HrmFtBW5lbQcuZW0E6mltBqppbQRqbW0GJm1tB+ZtbQWmcW0HYnFtBSJ1bQbidW0EnnltBl55bQQefW0F2n1tB5p9bQVWgW0HFoFtBNaFbQaShW0EUoltBg6JbQfOiW0Fio1tB0qNbQUGkW0GxpFtBIKVbQZClW0H/pVtBb6ZbQd6mW0FOp1tBvadbQS2oW0GcqFtBDKlbQXupW0HqqVtBWqpbQcmqW0E5q1tBqKtbQResW0GHrFtB9qxbQWatW0HVrVtBRK5bQbSuW0Ejr1tBkq9bQQGwW0FxsFtB4LBbQU+xW0G/sVtBLrJbQZ2yW0EMs1tBfLNbQeuzW0FatFtBybRbQTi1W0GotVtBF7ZbQYa2W0H1tltBZLdbQdS3W0FDuFtBsrhbQSG5W0GQuVtB/7lbQW66W0HdultBTLtbQby7W0ErvFtBmrxbQQm9W0F4vVtB571bQVa+W0HFvltBNL9bQaO/W0ESwFtBgcBbQfDAW0FfwVtBzsFbQT3CW0GswltBG8NbQYrDW0H5w1tBZ8RbQdbEW0FFxVtBtMVbQSPGW0GSxltBAcdbQXDHW0Hfx1tBTchbQbzIW0EryVtBmslbQQnKW0F4yltB5spbQVXLW0HEy1tBM8xbQaHMW0EQzVtBf81bQe7NW0FczltBy85bQTrPW0Gpz1tBF9BbQYbQW0H10FtBY9FbQdLRW0FB0ltBr9JbQR7TW0GN01tB+9NbQWrUW0HY1FtBR9VbQbbVW0Ek1ltBk9ZbQQHXW0Fw11tB3tdbQU3YW0G82FtBKtlbQZnZW0EH2ltBdtpbQeTaW0FT21tBwdtbQTDcW0Ge3FtBDN1bQXvdW0Hp3VtBWN5bQcbeW0E131tBo99bQRHgW0GA4FtB7uBbQV3hW0HL4VtBOeJbQajiW0EW41tBhONbQfPjW0Fh5FtBz+RbQT7lW0Gs5VtBGuZbQYnmW0H35ltBZedbQdPnW0FC6FtBsOhbQR7pW0GM6VtB+ulbQWnqW0HX6ltBRetbQbPrW0Eh7FtBkOxbQf7sW0Fs7VtB2u1bQUjuW0G27ltBJO9bQZPvW0EB8FtBb/BbQd3wW0FL8VtBufFbQSfyW0GV8ltBA/NbQXHzW0Hf81tBTfRbQbv0W0Ep9VtBl/VbQQX2W0Fz9ltB4fZbQU/3W0G991tBK/hbQZn4W0EH+VtBdflbQeP5W0FR+ltBv/pbQS37W0Ga+1tBCPxbQXb8W0Hk/FtBUv1bQcD9W0Eu/ltBm/5bQQn/W0F3/1tB5f9bQVMAXEHAAFxBLgFcQZwBXEEKAlxBeAJcQeUCXEFTA1xBwQNcQS8EXEGcBFxBCgVcQXgFXEHlBVxBUwZcQcEGXEEuB1xBnAdcQQoIXEF3CFxB5QhcQVMJXEHACVxBLgpcQZwKXEEJC1xBdwtcQeQLXEFSDFxBvwxcQS0NXEGbDVxBCA5cQXYOXEHjDlxBUQ9cQb4PXEEsEFxBmRBcQQcRXEF0EVxB4hFcQU8SXEG9ElxBKhNcQZcTXEEFFFxBchRcQeAUXEFNFVxBuxVcQSgWXEGVFlxBAxdcQXAXXEHdF1xBSxhcQbgYXEEmGVxBkxlcQQAaXEFtGlxB2xpcQUgbXEG1G1xBIxxcQZAcXEH9HFxBah1cQdgdXEFFHlxBsh5cQR8fXEGNH1xB+h9cQWcgXEHUIFxBQSFcQa8hXEEcIlxBiSJcQfYiXEFjI1xB0CNcQT4kXEGrJFxBGCVcQYUlXEHyJVxBXyZcQcwmXEE5J1xBpidcQRMoXEGBKFxB7ihcQVspXEHIKVxBNSpcQaIqXEEPK1xBfCtcQekrXEFWLFxBwyxcQTAtXEGdLVxBCi5cQXYuXEHjLlxBUC9cQb0vXEEqMFxBlzBcQQQxXEFxMVxB3jFcQUsyXEG4MlxBJDNcQZEzXEH+M1xBazRcQdg0XEFFNVxBsTVcQR42XEGLNlxB+DZcQWU3XEHRN1xBPjhcQas4XEEYOVxBhDlcQfE5XEFeOlxByzpcQTc7XEGkO1xBETxcQX08XEHqPFxBVz1cQcM9XEEwPlxBnT5cQQk/XEF2P1xB4z9cQU9AXEG8QFxBKEFcQZVBXEECQlxBbkJcQdtCXEFHQ1xBtENcQSBEXEGNRFxB+URcQWZFXEHSRVxBP0ZcQatGXEEYR1xBhEdcQfFHXEFdSFxBykhcQTZJXEGjSVxBD0pcQXxKXEHoSlxBVEtcQcFLXEEtTFxBmkxcQQZNXEFyTVxB301cQUtOXEG4TlxBJE9cQZBPXEH9T1xBaVBcQdVQXEFBUVxBrlFcQRpSXEGGUlxB81JcQV9TXEHLU1xBN1RcQaRUXEEQVVxBfFVcQehVXEFVVlxBwVZcQS1XXEGZV1xBBVhcQXJYXEHeWFxBSllcQbZZXEEiWlxBjlpcQfpaXEFnW1xB01tcQT9cXEGrXFxBF11cQYNdXEHvXVxBW15cQcdeXEEzX1xBn19cQQtgXEF3YFxB42BcQU9hXEG7YVxBJ2JcQZNiXEH/YlxBa2NcQddjXEFDZFxBr2RcQRtlXEGHZVxB82VcQV9mXEHLZlxBN2dcQaNnXEEPaFxBemhcQeZoXEFSaVxBvmlcQSpqXEGWalxBAmtcQW1rXEHZa1xBRWxcQbFsXEEdbVxBiG1cQfRtXEFgblxBzG5cQThvXEGjb1xBD3BcQXtwXEHmcFxBUnFcQb5xXEEqclxBlXJcQQFzXEFtc1xB2HNcQUR0XEGwdFxBG3VcQYd1XEHzdVxBXnZcQcp2XEE1d1xBoXdcQQ14XEF4eFxB5HhcQU95XEG7eVxBJ3pcQZJ6XEH+elxBaXtcQdV7XEFAfFxBrHxcQRd9XEGDfVxB7n1cQVp+XEHFflxBMX9cQZx/XEEIgFxBc4BcQd6AXEFKgVxBtYFcQSGCXEGMglxB+IJcQWODXEHOg1xBOoRcQaWEXEEQhVxBfIVcQeeFXEFShlxBvoZcQSmHXEGUh1xBAIhcQWuIXEHWiFxBQolcQa2JXEEYilxBg4pcQe+KXEFai1xBxYtcQTCMXEGcjFxBB41cQXKNXEHdjVxBSI5cQbSOXEEfj1xBio9cQfWPXEFgkFxBy5BcQTeRXEGikVxBDZJcQXiSXEHjklxBTpNcQbmTXEEklFxBj5RcQfuUXEFmlVxB0ZVcQTyWXEGnllxBEpdcQX2XXEHol1xBU5hcQb6YXEEpmVxBlJlcQf+ZXEFqmlxB1ZpcQUCbXEGrm1xBFpxcQYGcXEHrnFxBVp1cQcGdXEEsnlxBl55cQQKfXEFtn1xB2J9cQUOgXEGtoFxBGKFcQYOhXEHuoVxBWaJcQcSiXEEvo1xBmaNcQQSkXEFvpFxB2qRcQUSlXEGvpVxBGqZcQYWmXEHwplxBWqdcQcWnXEEwqFxBmqhcQQWpXEFwqVxB26lcQUWqXEGwqlxBG6tcQYWrXEHwq1xBW6xcQcWsXEEwrVxBmq1cQQWuXEFwrlxB2q5cQUWvXEGvr1xBGrBcQYWwXEHvsFxBWrFcQcSxXEEvslxBmbJcQQSzXEFus1xB2bNcQUO0XEGutFxBGLVcQYO1XEHttVxBWLZcQcK2XEEtt1xBl7dcQQK4XEFsuFxB17hcQUG5XEGruVxBFrpcQYC6XEHrulxBVbtcQb+7XEEqvFxBlLxcQf68XEFpvVxB071cQT2+XEGovlxBEr9cQXy/XEHnv1xBUcBcQbvAXEElwVxBkMFcQfrBXEFkwlxBzsJcQTnDXEGjw1xBDcRcQXfEXEHixFxBTMVcQbbFXEEgxlxBisZcQfXGXEFfx1xBycdcQTPIXEGdyFxBB8lcQXHJXEHcyVxBRspcQbDKXEEay1xBhMtcQe7LXEFYzFxBwsxcQSzNXEGWzVxBAM5cQWrOXEHUzlxBPs9cQajPXEES0FxBfNBcQebQXEFQ0VxButFcQSTSXEGO0lxB+NJcQWLTXEHM01xBNtRcQaDUXEEK1VxBdNVcQd7VXEFI1lxBstZcQRvXXEGF11xB79dcQVnYXEHD2FxBLdlcQZfZXEEA2lxBatpcQdTaXEE+21xBqNtcQRHcXEF73FxB5dxcQU/dXEG43VxBIt5cQYzeXEH23lxBX99cQcnfXEEz4FxBneBcQQbhXEFw4VxB2uFcQUPiXEGt4lxBF+NcQYDjXEHq41xBVORcQb3kXEEn5VxBkeVcQfrlXEFk5lxBzeZcQTfnXEGh51xBCuhcQXToXEHd6FxBR+lcQbDpXEEa6lxBg+pcQe3qXEFX61xBwOtcQSrsXEGT7FxB/excQWbtXEHP7VxBOe5cQaLuXEEM71xBde9cQd/vXEFI8FxBsvBcQRvxXEGE8VxB7vFcQVfyXEHB8lxBKvNcQZPzXEH981xBZvRcQc/0XEE59VxBovVcQQv2XEF19lxB3vZcQUf3XEGx91xBGvhcQYP4XEHt+FxBVvlcQb/5XEEo+lxBkvpcQfv6XEFk+1xBzftcQTb8XEGg/FxBCf1cQXL9XEHb/VxBRP5cQa7+XEEX/1xBgP9cQen/XEFSAF1BuwBdQSUBXUGOAV1B9wFdQWACXUHJAl1BMgNdQZsDXUEEBF1BbQRdQdYEXUE/BV1BqAVdQRIGXUF7Bl1B5AZdQU0HXUG2B11BHwhdQYgIXUHxCF1BWgldQcMJXUEsCl1BlQpdQf0KXUFmC11BzwtdQTgMXUGhDF1BCg1dQXMNXUHcDV1BRQ5dQa4OXUEXD11Bfw9dQegPXUFREF1BuhBdQSMRXUGMEV1B9RFdQV0SXUHGEl1BLxNdQZgTXUEBFF1BaRRdQdIUXUE7FV1BpBVdQQ0WXUF1Fl1B3hZdQUcXXUGvF11BGBhdQYEYXUHqGF1BUhldQbsZXUEkGl1BjBpdQfUaXUFeG11BxhtdQS8cXUGYHF1BAB1dQWkdXUHSHV1BOh5dQaMeXUELH11BdB9dQd0fXUFFIF1BriBdQRYhXUF/IV1B5yFdQVAiXUG4Il1BISNdQYojXUHyI11BWyRdQcMkXUEsJV1BlCVdQfwlXUFlJl1BzSZdQTYnXUGeJ11BByhdQW8oXUHYKF1BQCldQagpXUERKl1BeSpdQeIqXUFKK11BsitdQRssXUGDLF1B6yxdQVQtXUG8LV1BJS5dQY0uXUH1Ll1BXS9dQcYvXUEuMF1BljBdQf8wXUFnMV1BzzFdQTcyXUGgMl1BCDNdQXAzXUHYM11BQTRdQak0XUERNV1BeTVdQeE1XUFKNl1BsjZdQRo3XUGCN11B6jddQVI4XUG7OF1BIzldQYs5XUHzOV1BWzpdQcM6XUErO11BkztdQfw7XUFkPF1BzDxdQTQ9XUGcPV1BBD5dQWw+XUHUPl1BPD9dQaQ/XUEMQF1BdEBdQdxAXUFEQV1BrEFdQRRCXUF8Ql1B5EJdQUxDXUG0Q11BHERdQYREXUHsRF1BVEVdQbxFXUEjRl1Bi0ZdQfNGXUFbR11Bw0ddQStIXUGTSF1B+0hdQWJJXUHKSV1BMkpdQZpKXUECS11BaktdQdFLXUE5TF1BoUxdQQlNXUFxTV1B2E1dQUBOXUGoTl1BEE9dQXdPXUHfT11BR1BdQa9QXUEWUV1BflFdQeZRXUFNUl1BtVJdQR1TXUGEU11B7FNdQVRUXUG7VF1BI1VdQYtVXUHyVV1BWlZdQcJWXUEpV11BkVddQfhXXUFgWF1ByFhdQS9ZXUGXWV1B/lldQWZaXUHNWl1BNVtdQZxbXUEEXF1BbFxdQdNcXUE7XV1Bol1dQQpeXUFxXl1B2V5dQUBfXUGnX11BD2BdQXZgXUHeYF1BRWFdQa1hXUEUYl1Be2JdQeNiXUFKY11BsmNdQRlkXUGAZF1B6GRdQU9lXUG3ZV1BHmZdQYVmXUHtZl1BVGddQbtnXUEjaF1BimhdQfFoXUFYaV1BwGldQSdqXUGOal1B9mpdQV1rXUHEa11BK2xdQZJsXUH6bF1BYW1dQchtXUEvbl1Bl25dQf5uXUFlb11BzG9dQTNwXUGacF1BAnFdQWlxXUHQcV1BN3JdQZ5yXUEFc11BbHNdQdRzXUE7dF1BonRdQQl1XUFwdV1B13VdQT52XUGldl1BDHddQXN3XUHad11BQXhdQah4XUEPeV1BdnldQd15XUFEel1Bq3pdQRJ7XUF5e11B4HtdQUd8XUGufF1BFX1dQXx9XUHjfV1BSn5dQbF+XUEYf11Bf39dQeZ/XUFMgF1Bs4BdQRqBXUGBgV1B6IFdQU+CXUG2gl1BHYNdQYODXUHqg11BUYRdQbiEXUEfhV1BhYVdQeyFXUFThl1BuoZdQSGHXUGHh11B7oddQVWIXUG8iF1BIoldQYmJXUHwiV1BV4pdQb2KXUEki11Bi4tdQfGLXUFYjF1Bv4xdQSWNXUGMjV1B841dQVmOXUHAjl1BJ49dQY2PXUH0j11BWpBdQcGQXUEokV1BjpFdQfWRXUFbkl1BwpJdQSmTXUGPk11B9pNdQVyUXUHDlF1BKZVdQZCVXUH2lV1BXZZdQcOWXUEql11BkJddQfeXXUFdmF1BxJhdQSqZXUGRmV1B95ldQV6aXUHEml1BKptdQZGbXUH3m11BXpxdQcScXUEqnV1BkZ1dQfedXUFenl1BxJ5dQSqfXUGRn11B959dQV2gXUHEoF1BKqFdQZChXUH3oV1BXaJdQcOiXUEpo11BkKNdQfajXUFcpF1Bw6RdQSmlXUGPpV1B9aVdQVumXUHCpl1BKKddQY6nXUH0p11BW6hdQcGoXUEnqV1BjaldQfOpXUFZql1BwKpdQSarXUGMq11B8qtdQVisXUG+rF1BJK1dQYqtXUHxrV1BV65dQb2uXUEjr11Bia9dQe+vXUFVsF1Bu7BdQSGxXUGHsV1B7bFdQVOyXUG5sl1BH7NdQYWzXUHrs11BUbRdQbe0XUEdtV1Bg7VdQem1XUFPtl1BtbZdQRu3XUGBt11B57ddQU24XUGzuF1BGbldQX65XUHkuV1BSrpdQbC6XUEWu11BfLtdQeK7XUFIvF1BrbxdQRO9XUF5vV1B371dQUW+XUGrvl1BEL9dQXa/XUHcv11BQsBdQajAXUENwV1Bc8FdQdnBXUE/wl1BpMJdQQrDXUFww11B1sNdQTvEXUGhxF1BB8VdQWzFXUHSxV1BOMZdQZ3GXUEDx11BacddQc7HXUE0yF1BmshdQf/IXUFlyV1By8ldQTDKXUGWyl1B+8pdQWHLXUHHy11BLMxdQZLMXUH3zF1BXc1dQcLNXUEozl1Bjc5dQfPOXUFZz11Bvs9dQSTQXUGJ0F1B79BdQVTRXUG60V1BH9JdQYTSXUHq0l1BT9NdQbXTXUEa1F1BgNRdQeXUXUFL1V1BsNVdQRXWXUF71l1B4NZdQUbXXUGr111BENhdQXbYXUHb2F1BQNldQabZXUEL2l1BcNpdQdbaXUE7211BoNtdQQbcXUFr3F1B0NxdQTbdXUGb3V1BAN5dQWXeXUHL3l1BMN9dQZXfXUH6311BYOBdQcXgXUEq4V1Bj+FdQfXhXUFa4l1Bv+JdQSTjXUGJ411B7uNdQVTkXUG55F1BHuVdQYPlXUHo5V1BTeZdQbLmXUEY511BfeddQeLnXUFH6F1BrOhdQRHpXUF26V1B2+ldQUDqXUGl6l1BCutdQW/rXUHU611BOuxdQZ/sXUEE7V1Bae1dQc7tXUEz7l1BmO5dQf3uXUFi711Bxu9dQSvwXUGQ8F1B9fBdQVrxXUG/8V1BJPJdQYnyXUHu8l1BU/NdQbjzXUEd9F1BgvRdQeb0XUFL9V1BsPVdQRX2XUF69l1B3/ZdQUT3XUGo911BDfhdQXL4XUHX+F1BPPldQaH5XUEF+l1BavpdQc/6XUE0+11BmPtdQf37XUFi/F1Bx/xdQSv9XUGQ/V1B9f1dQVr+XUG+/l1BI/9dQYj/XUHs/11BUQBeQbYAXkEaAV5BfwFeQeQBXkFIAl5BrQJeQRIDXkF2A15B2wNeQUAEXkGkBF5BCQVeQW0FXkHSBV5BNwZeQZsGXkEAB15BZAdeQckHXkEtCF5BkgheQfcIXkFbCV5BwAleQSQKXkGJCl5B7QpeQVILXkG2C15BGwxeQX8MXkHkDF5BSA1eQa0NXkERDl5BdQ5eQdoOXkE+D15Bow9eQQcQXkFsEF5B0BBeQTQRXkGZEV5B/RFeQWISXkHGEl5BKhNeQY8TXkHzE15BVxReQbwUXkEgFV5BhBVeQekVXkFNFl5BsRZeQRYXXkF6F15B3hdeQUIYXkGnGF5BCxleQW8ZXkHTGV5BOBpeQZwaXkEAG15BZBteQckbXkEtHF5BkRxeQfUcXkFZHV5Bvh1eQSIeXkGGHl5B6h5eQU4fXkGyH15BFyBeQXsgXkHfIF5BQyFeQachXkELIl5BbyJeQdMiXkE4I15BnCNeQQAkXkFkJF5ByCReQSwlXkGQJV5B9CVeQVgmXkG8Jl5BICdeQYQnXkHoJ15BTCheQbAoXkEUKV5BeCleQdwpXkFAKl5BpCpeQQgrXkFsK15B0CteQTQsXkGYLF5B/CxeQWAtXkHELV5BKC5eQYsuXkHvLl5BUy9eQbcvXkEbMF5BfzBeQeMwXkFHMV5BqjFeQQ4yXkFyMl5B1jJeQTozXkGeM15BATReQWU0XkHJNF5BLTVeQZE1XkH0NV5BWDZeQbw2XkEgN15BgzdeQec3XkFLOF5BrzheQRI5XkF2OV5B2jleQT06XkGhOl5BBTteQWk7XkHMO15BMDxeQZQ8XkH3PF5BWz1eQb49XkEiPl5Bhj5eQek+XkFNP15BsT9eQRRAXkF4QF5B20BeQT9BXkGjQV5BBkJeQWpCXkHNQl5BMUNeQZRDXkH4Q15BW0ReQb9EXkEjRV5BhkVeQepFXkFNRl5BsUZeQRRHXkF4R15B20deQT5IXkGiSF5BBUleQWlJXkHMSV5BMEpeQZNKXkH3Sl5BWkteQb1LXkEhTF5BhExeQehMXkFLTV5Brk1eQRJOXkF1Tl5B2E5eQTxPXkGfT15BAlBeQWZQXkHJUF5BLFFeQZBRXkHzUV5BVlJeQbpSXkEdU15BgFNeQeNTXkFHVF5BqlReQQ1VXkFxVV5B1FVeQTdWXkGaVl5B/VZeQWFXXkHEV15BJ1heQYpYXkHtWF5BUVleQbRZXkEXWl5BelpeQd1aXkFAW15BpFteQQdcXkFqXF5BzVxeQTBdXkGTXV5B9l1eQVleXkG8Xl5BIF9eQYNfXkHmX15BSWBeQaxgXkEPYV5BcmFeQdVhXkE4Yl5Bm2JeQf5iXkFhY15BxGNeQSdkXkGKZF5B7WReQVBlXkGzZV5BFmZeQXlmXkHcZl5BP2deQaJnXkEFaF5BaGheQctoXkEuaV5BkGleQfNpXkFWal5BuWpeQRxrXkF/a15B4mteQUVsXkGnbF5BCm1eQW1tXkHQbV5BM25eQZZuXkH4bl5BW29eQb5vXkEhcF5BhHBeQeZwXkFJcV5BrHFeQQ9yXkFycl5B1HJeQTdzXkGac15B/XNeQV90XkHCdF5BJXVeQYd1XkHqdV5BTXZeQbB2XkESd15BdXdeQdh3XkE6eF5BnXheQQB5XkFieV5BxXleQSd6XkGKel5B7XpeQU97XkGye15BFHxeQXd8XkHafF5BPH1eQZ99XkEBfl5BZH5eQcd+XkEpf15BjH9eQe5/XkFRgF5Bs4BeQRaBXkF4gV5B24FeQT2CXkGggl5BAoNeQWWDXkHHg15BKoReQYyEXkHvhF5BUYVeQbOFXkEWhl5BeIZeQduGXkE9h15BoIdeQQKIXkFkiF5Bx4heQSmJXkGLiV5B7oleQVCKXkGzil5BFYteQXeLXkHai15BPIxeQZ6MXkEBjV5BY41eQcWNXkEnjl5Bio5eQeyOXkFOj15BsY9eQROQXkF1kF5B15BeQTqRXkGckV5B/pFeQWCSXkHDkl5BJZNeQYeTXkHpk15BS5ReQa6UXkEQlV5BcpVeQdSVXkE2ll5BmJZeQfuWXkFdl15Bv5deQSGYXkGDmF5B5ZheQUeZXkGpmV5BDJpeQW6aXkHQml5BMpteQZSbXkH2m15BWJxeQbqcXkEcnV5Bfp1eQeCdXkFCnl5BpJ5eQQafXkFon15Byp9eQSygXkGOoF5B8KBeQVKhXkG0oV5BFqJeQXiiXkHaol5BPKNeQZ6jXkEApF5BYqReQcSkXkEmpV5BiKVeQeqlXkFLpl5BraZeQQ+nXkFxp15B06deQTWoXkGXqF5B+aheQVqpXkG8qV5BHqpeQYCqXkHiql5BRKteQaWrXkEHrF5BaaxeQcusXkEtrV5Bjq1eQfCtXkFSrl5BtK5eQRWvXkF3r15B2a9eQTuwXkGcsF5B/rBeQWCxXkHBsV5BI7JeQYWyXkHnsl5BSLNeQaqzXkEMtF5BbbReQc+0XkExtV5BkrVeQfS1XkFWtl5Bt7ZeQRm3XkF6t15B3LdeQT64XkGfuF5BAbleQWK5XkHEuV5BJbpeQYe6XkHpul5BSrteQay7XkENvF5Bb7xeQdC8XkEyvV5Bk71eQfW9XkFWvl5BuL5eQRm/XkF7v15B3L9eQT7AXkGfwF5BAcFeQWLBXkHEwV5BJcJeQYbCXkHowl5BScNeQavDXkEMxF5BbsReQc/EXkEwxV5BksVeQfPFXkFUxl5BtsZeQRfHXkF4x15B2sdeQTvIXkGcyF5B/sheQV/JXkHAyV5BIspeQYPKXkHkyl5BRsteQafLXkEIzF5BacxeQcvMXkEszV5Bjc1eQe7NXkFQzl5Bsc5eQRLPXkFzz15B1c9eQTbQXkGX0F5B+NBeQVnRXkG70V5BHNJeQX3SXkHe0l5BP9NeQaDTXkEC1F5BY9ReQcTUXkEl1V5BhtVeQefVXkFI1l5BqdZeQQrXXkFs115BzddeQS7YXkGP2F5B8NheQVHZXkGy2V5BE9peQXTaXkHV2l5BNtteQZfbXkH4215BWdxeQbrcXkEb3V5BfN1eQd3dXkE+3l5Bn95eQQDfXkFh315Bwt9eQSPgXkGE4F5B5eBeQUbhXkGn4V5BB+JeQWjiXkHJ4l5BKuNeQYvjXkHs415BTeReQa7kXkEP5V5Bb+VeQdDlXkEx5l5BkuZeQfPmXkFU515BtOdeQRXoXkF26F5B1+heQTjpXkGY6V5B+eleQVrqXkG76l5BHOteQXzrXkHd615BPuxeQZ/sXkH/7F5BYO1eQcHtXkEh7l5Bgu5eQePuXkFE715BpO9eQQXwXkFm8F5BxvBeQSfxXkGI8V5B6PFeQUnyXkGq8l5BCvNeQWvzXkHL815BLPReQY30XkHt9F5BTvVeQa71XkEP9l5BcPZeQdD2XkEx915BkfdeQfL3XkFS+F5Bs/heQRT5XkF0+V5B1fleQTX6XkGW+l5B9vpeQVf7XkG3+15BGPxeQXj8XkHZ/F5BOf1eQZn9XkH6/V5BWv5eQbv+XkEb/15BfP9eQdz/XkE9AF9BnQBfQf0AX0FeAV9BvgFfQR8CX0F/Al9B3wJfQUADX0GgA19BAARfQWEEX0HBBF9BIQVfQYIFX0HiBV9BQgZfQaMGX0EDB19BYwdfQcQHX0EkCF9BhAhfQeQIX0FFCV9BpQlfQQUKX0FmCl9BxgpfQSYLX0GGC19B5gtfQUcMX0GnDF9BBw1fQWcNX0HIDV9BKA5fQYgOX0HoDl9BSA9fQagPX0EJEF9BaRBfQckQX0EpEV9BiRFfQekRX0FJEl9BqhJfQQoTX0FqE19ByhNfQSoUX0GKFF9B6hRfQUoVX0GqFV9BChZfQWoWX0HKFl9BKxdfQYsXX0HrF19BSxhfQasYX0ELGV9BaxlfQcsZX0ErGl9BixpfQesaX0FLG19BqxtfQQscX0FrHF9ByxxfQSodX0GKHV9B6h1fQUoeX0GqHl9BCh9fQWofX0HKH19BKiBfQYogX0HqIF9BSSFfQakhX0EJIl9BaSJfQckiX0EpI19BiSNfQegjX0FIJF9BqCRfQQglX0FoJV9ByCVfQScmX0GHJl9B5yZfQUcnX0GnJ19BBihfQWYoX0HGKF9BJilfQYUpX0HlKV9BRSpfQaUqX0EEK19BZCtfQcQrX0EjLF9BgyxfQeMsX0FCLV9Boi1fQQIuX0FiLl9BwS5fQSEvX0GAL19B4C9fQUAwX0GfMF9B/zBfQV8xX0G+MV9BHjJfQX0yX0HdMl9BPTNfQZwzX0H8M19BWzRfQbs0X0EbNV9BejVfQdo1X0E5Nl9BmTZfQfg2X0FYN19BtzdfQRc4X0F2OF9B1jhfQTU5X0GVOV9B9DlfQVQ6X0GzOl9BEztfQXI7X0HSO19BMTxfQZA8X0HwPF9BTz1fQa89X0EOPl9Bbj5fQc0+X0EsP19BjD9fQes/X0FLQF9BqkBfQQlBX0FpQV9ByEFfQSdCX0GHQl9B5kJfQUVDX0GlQ19BBERfQWNEX0HDRF9BIkVfQYFFX0HhRV9BQEZfQZ9GX0H+Rl9BXkdfQb1HX0EcSF9Be0hfQdtIX0E6SV9BmUlfQfhJX0FYSl9Bt0pfQRZLX0F1S19B1EtfQTRMX0GTTF9B8kxfQVFNX0GwTV9BD05fQW9OX0HOTl9BLU9fQYxPX0HrT19BSlBfQalQX0EIUV9BaFFfQcdRX0EmUl9BhVJfQeRSX0FDU19BolNfQQFUX0FgVF9Bv1RfQR5VX0F9VV9B3FVfQTtWX0GaVl9B+VZfQVhXX0G3V19BFlhfQXVYX0HUWF9BM1lfQZJZX0HxWV9BUFpfQa9aX0EOW19BbVtfQcxbX0ErXF9BilxfQelcX0FIXV9Bp11fQQZeX0FkXl9Bw15fQSJfX0GBX19B4F9fQT9gX0GeYF9B/WBfQVthX0G6YV9BGWJfQXhiX0HXYl9BNmNfQZRjX0HzY19BUmRfQbFkX0EQZV9BbmVfQc1lX0EsZl9Bi2ZfQelmX0FIZ19Bp2dfQQZoX0FkaF9Bw2hfQSJpX0GBaV9B32lfQT5qX0Gdal9B+2pfQVprX0G5a19BF2xfQXZsX0HVbF9BM21fQZJtX0HxbV9BT25fQa5uX0ENb19Ba29fQcpvX0EocF9Bh3BfQeZwX0FEcV9Bo3FfQQFyX0Fgcl9Bv3JfQR1zX0F8c19B2nNfQTl0X0GXdF9B9nRfQVR1X0GzdV9BEXZfQXB2X0HOdl9BLXdfQYt3X0Hqd19BSHhfQad4X0EFeV9BZHlfQcJ5X0Ehel9Bf3pfQd56X0E8e19BmntfQfl7X0FXfF9BtnxfQRR9X0FyfV9B0X1fQS9+X0GOfl9B7H5fQUp/X0Gpf19BB4BfQWWAX0HEgF9BIoFfQYCBX0HfgV9BPYJfQZuCX0H6gl9BWINfQbaDX0EVhF9Bc4RfQdGEX0EvhV9BjoVfQeyFX0FKhl9BqYZfQQeHX0Flh19Bw4dfQSGIX0GAiF9B3ohfQTyJX0GaiV9B+YlfQVeKX0G1il9BE4tfQXGLX0HPi19BLoxfQYyMX0HqjF9BSI1fQaaNX0EEjl9BYo5fQcGOX0Efj19BfY9fQduPX0E5kF9Bl5BfQfWQX0FTkV9BsZFfQQ+SX0Ftkl9BzJJfQSqTX0GIk19B5pNfQUSUX0GilF9BAJVfQV6VX0G8lV9BGpZfQXiWX0HWll9BNJdfQZKXX0Hwl19BTphfQayYX0EKmV9BaJlfQcaZX0Ejml9BgZpfQd+aX0E9m19Bm5tfQfmbX0FXnF9BtZxfQROdX0FxnV9Bz51fQSyeX0GKnl9B6J5fQUafX0Gkn19BAqBfQWCgX0G9oF9BG6FfQXmhX0HXoV9BNaJfQZKiX0Hwol9BTqNfQayjX0EKpF9BZ6RfQcWkX0EjpV9BgaVfQd6lX0E8pl9BmqZfQfimX0FVp19Bs6dfQRGoX0FvqF9BzKhfQSqpX0GIqV9B5alfQUOqX0Ghql9B/qpfQVyrX0G6q19BF6xfQXWsX0HTrF9BMK1fQY6tX0HsrV9BSa5fQaeuX0EEr19BYq9fQcCvX0EdsF9Be7BfQdiwX0E2sV9BlLFfQfGxX0FPsl9BrLJfQQqzX0Fns19BxbNfQSK0X0GAtF9B3bRfQTu1X0GYtV9B9rVfQVO2X0Gxtl9BDrdfQWy3X0HJt19BJ7hfQYS4X0HiuF9BP7lfQZ25X0H6uV9BV7pfQbW6X0ESu19BcLtfQc27X0ErvF9BiLxfQeW8X0FDvV9BoL1fQf29X0Fbvl9BuL5fQRa/X0Fzv19B0L9fQS7AX0GLwF9B6MBfQUbBX0GjwV9BAMJfQV3CX0G7wl9BGMNfQXXDX0HTw19BMMRfQY3EX0HqxF9BSMVfQaXFX0ECxl9BX8ZfQb3GX0Eax19Bd8dfQdTHX0EyyF9Bj8hfQezIX0FJyV9BpslfQQTKX0Fhyl9BvspfQRvLX0F4y19B1ctfQTLMX0GQzF9B7cxfQUrNX0GnzV9BBM5fQWHOX0G+zl9BG89fQXnPX0HWz19BM9BfQZDQX0Ht0F9BStFfQafRX0EE0l9BYdJfQb7SX0Eb019BeNNfQdXTX0Ey1F9Bj9RfQezUX0FJ1V9BptVfQQPWX0Fg1l9BvdZfQRrXX0F3119B1NdfQTHYX0GO2F9B69hfQUjZX0Gl2V9BAtpfQV/aX0G82l9BGdtfQXbbX0HS219BL9xfQYzcX0Hp3F9BRt1fQaPdX0EA3l9BXd5fQbneX0EW319Bc99fQdDfX0Et4F9BiuBfQebgX0FD4V9BoOFfQf3hX0Fa4l9Bt+JfQRPjX0Fw419BzeNfQSrkX0GG5F9B4+RfQUDlX0Gd5V9B+eVfQVbmX0Gz5l9BEOdfQWznX0HJ519BJuhfQYLoX0Hf6F9BPOlfQZnpX0H16V9BUupfQa/qX0EL619BaOtfQcXrX0Eh7F9BfuxfQdrsX0E37V9BlO1fQfDtX0FN7l9Bqu5fQQbvX0Fj719Bv+9fQRzwX0F48F9B1fBfQTLxX0GO8V9B6/FfQUfyX0Gk8l9BAPNfQV3zX0G5819BFvRfQXL0X0HP9F9BK/VfQYj1X0Hk9V9BQfZfQZ32X0H69l9BVvdfQbP3X0EP+F9BbPhfQcj4X0El+V9BgflfQd75X0E6+l9BlvpfQfP6X0FP+19BrPtfQQj8X0Fk/F9BwfxfQR39X0F6/V9B1v1fQTL+X0GP/l9B6/5fQUf/X0Gk/19BAABgQVwAYEG5AGBBFQFgQXEBYEHOAWBBKgJgQYYCYEHiAmBBPwNgQZsDYEH3A2BBVARgQbAEYEEMBWBBaAVgQcUFYEEhBmBBfQZgQdkGYEE2B2BBkgdgQe4HYEFKCGBBpghgQQMJYEFfCWBBuwlgQRcKYEFzCmBBzwpgQSwLYEGIC2BB5AtgQUAMYEGcDGBB+AxgQVQNYEGxDWBBDQ5gQWkOYEHFDmBBIQ9gQX0PYEHZD2BBNRBgQZEQYEHtEGBBSRFgQaYRYEECEmBBXhJgQboSYEEWE2BBchNgQc4TYEEqFGBBhhRgQeIUYEE+FWBBmhVgQfYVYEFSFmBBrhZgQQoXYEFmF2BBwhdgQR4YYEF6GGBB1hhgQTIZYEGNGWBB6RlgQUUaYEGhGmBB/RpgQVkbYEG1G2BBERxgQW0cYEHJHGBBJR1gQYAdYEHcHWBBOB5gQZQeYEHwHmBBTB9gQagfYEEDIGBBXyBgQbsgYEEXIWBBcyFgQc4hYEEqImBBhiJgQeIiYEE+I2BBmSNgQfUjYEFRJGBBrSRgQQglYEFkJWBBwCVgQRwmYEF3JmBB0yZgQS8nYEGLJ2BB5idgQUIoYEGeKGBB+ShgQVUpYEGxKWBBDSpgQWgqYEHEKmBBICtgQXsrYEHXK2BBMixgQY4sYEHqLGBBRS1gQaEtYEH9LWBBWC5gQbQuYEEPL2BBay9gQccvYEEiMGBBfjBgQdkwYEE1MWBBkTFgQewxYEFIMmBBozJgQf8yYEFaM2BBtjNgQRE0YEFtNGBByDRgQSQ1YEF/NWBB2zVgQTY2YEGSNmBB7TZgQUk3YEGkN2BBADhgQVs4YEG3OGBBEjlgQW45YEHJOWBBJDpgQYA6YEHbOmBBNztgQZI7YEHtO2BBSTxgQaQ8YEEAPWBBWz1gQbY9YEESPmBBbT5gQck+YEEkP2BBfz9gQds/YEE2QGBBkUBgQe1AYEFIQWBBo0FgQf5BYEFaQmBBtUJgQRBDYEFsQ2BBx0NgQSJEYEF+RGBB2URgQTRFYEGPRWBB60VgQUZGYEGhRmBB/EZgQVdHYEGzR2BBDkhgQWlIYEHESGBBIElgQXtJYEHWSWBBMUpgQYxKYEHnSmBBQ0tgQZ5LYEH5S2BBVExgQa9MYEEKTWBBZU1gQcFNYEEcTmBBd05gQdJOYEEtT2BBiE9gQeNPYEE+UGBBmVBgQfVQYEFQUWBBq1FgQQZSYEFhUmBBvFJgQRdTYEFyU2BBzVNgQShUYEGDVGBB3lRgQTlVYEGUVWBB71VgQUpWYEGlVmBBAFdgQVtXYEG2V2BBEVhgQWxYYEHHWGBBIllgQX1ZYEHYWWBBM1pgQY5aYEHpWmBBQ1tgQZ5bYEH5W2BBVFxgQa9cYEEKXWBBZV1gQcBdYEEbXmBBdV5gQdBeYEErX2BBhl9gQeFfYEE8YGBBl2BgQfFgYEFMYWBBp2FgQQJiYEFdYmBBt2JgQRJjYEFtY2BByGNgQSNkYEF9ZGBB2GRgQTNlYEGOZWBB6WVgQUNmYEGeZmBB+WZgQVNnYEGuZ2BBCWhgQWRoYEG+aGBBGWlgQXRpYEHOaWBBKWpgQYRqYEHfamBBOWtgQZRrYEHva2BBSWxgQaRsYEH+bGBBWW1gQbRtYEEObmBBaW5gQcRuYEEeb2BBeW9gQdNvYEEucGBBiXBgQeNwYEE+cWBBmHFgQfNxYEFOcmBBqHJgQQNzYEFdc2BBuHNgQRJ0YEFtdGBBx3RgQSJ1YEF8dWBB13VgQTF2YEGMdmBB5nZgQUF3YEGbd2BB9ndgQVB4YEGreGBBBXlgQWB5YEG6eWBBFXpgQW96YEHKemBBJHtgQX57YEHZe2BBM3xgQY58YEHofGBBQn1gQZ19YEH3fWBBUn5gQax+YEEGf2BBYX9gQbt/YEEVgGBBcIBgQcqAYEEkgWBBf4FgQdmBYEEzgmBBjoJgQeiCYEFCg2BBnYNgQfeDYEFRhGBBrIRgQQaFYEFghWBBuoVgQRWGYEFvhmBByYZgQSOHYEF+h2BB2IdgQTKIYEGMiGBB54hgQUGJYEGbiWBB9YlgQU+KYEGqimBBBItgQV6LYEG4i2BBEoxgQWyMYEHHjGBBIY1gQXuNYEHVjWBBL45gQYmOYEHjjmBBPo9gQZiPYEHyj2BBTJBgQaaQYEEAkWBBWpFgQbSRYEEOkmBBaJJgQcOSYEEdk2BBd5NgQdGTYEErlGBBhZRgQd+UYEE5lWBBk5VgQe2VYEFHlmBBoZZgQfuWYEFVl2BBr5dgQQmYYEFjmGBBvZhgQReZYEFxmWBBy5lgQSWaYEF/mmBB2ZpgQTObYEGNm2BB55tgQUCcYEGanGBB9JxgQU6dYEGonWBBAp5gQVyeYEG2nmBBEJ9gQWqfYEHDn2BBHaBgQXegYEHRoGBBK6FgQYWhYEHfoWBBOKJgQZKiYEHsomBBRqNgQaCjYEH5o2BBU6RgQa2kYEEHpWBBYaVgQbqlYEEUpmBBbqZgQcimYEEhp2BBe6dgQdWnYEEvqGBBiKhgQeKoYEE8qWBBlqlgQe+pYEFJqmBBo6pgQfyqYEFWq2BBsKtgQQqsYEFjrGBBvaxgQRetYEFwrWBByq1gQSSuYEF9rmBB165gQTCvYEGKr2BB5K9gQT2wYEGXsGBB8bBgQUqxYEGksWBB/bFgQVeyYEGxsmBBCrNgQWSzYEG9s2BBF7RgQXC0YEHKtGBBJLVgQX21YEHXtWBBMLZgQYq2YEHjtmBBPbdgQZa3YEHwt2BBSbhgQaO4YEH8uGBBVrlgQa+5YEEJumBBYrpgQby6YEEVu2BBbrtgQci7YEEhvGBBe7xgQdS8YEEuvWBBh71gQeG9YEE6vmBBk75gQe2+YEFGv2BBn79gQfm/YEFSwGBBrMBgQQXBYEFewWBBuMFgQRHCYEFqwmBBxMJgQR3DYEF2w2BB0MNgQSnEYEGCxGBB3MRgQTXFYEGOxWBB6MVgQUHGYEGaxmBB88ZgQU3HYEGmx2BB/8dgQVnIYEGyyGBBC8lgQWTJYEG9yWBBF8pgQXDKYEHJymBBIstgQXzLYEHVy2BBLsxgQYfMYEHgzGBBOs1gQZPNYEHszWBBRc5gQZ7OYEH3zmBBUc9gQarPYEED0GBBXNBgQbXQYEEO0WBBZ9FgQcDRYEEa0mBBc9JgQczSYEEl02BBftNgQdfTYEEw1GBBidRgQeLUYEE71WBBlNVgQe3VYEFG1mBBoNZgQfnWYEFS12BBq9dgQQTYYEFd2GBBtthgQQ/ZYEFo2WBBwdlgQRraYEFz2mBBzNpgQSXbYEF+22BB19tgQS/cYEGI3GBB4dxgQTrdYEGT3WBB7N1gQUXeYEGe3mBB995gQVDfYEGp32BBAuBgQVvgYEGz4GBBDOFgQWXhYEG+4WBBF+JgQXDiYEHJ4mBBIuNgQXrjYEHT42BBLORgQYXkYEHe5GBBN+VgQY/lYEHo5WBBQeZgQZrmYEHz5mBBS+dgQaTnYEH952BBVuhgQa7oYEEH6WBBYOlgQbnpYEES6mBBaupgQcPqYEEc62BBdOtgQc3rYEEm7GBBf+xgQdfsYEEw7WBBie1gQeHtYEE67mBBk+5gQevuYEFE72BBne9gQfXvYEFO8GBBp/BgQf/wYEFY8WBBsfFgQQnyYEFi8mBBu/JgQRPzYEFs82BBxPNgQR30YEF29GBBzvRgQSf1YEF/9WBB2PVgQTD2YEGJ9mBB4vZgQTr3YEGT92BB6/dgQUT4YEGc+GBB9fhgQU35YEGm+WBB/vlgQVf6YEGv+mBBCPtgQWD7YEG5+2BBEfxgQWr8YEHC/GBBG/1gQXP9YEHM/WBBJP5gQX3+YEHV/mBBLf9gQYb/YEHe/2BBNwBhQY8AYUHnAGFBQAFhQZgBYUHxAWFBSQJhQaECYUH6AmFBUgNhQasDYUEDBGFBWwRhQbQEYUEMBWFBZAVhQb0FYUEVBmFBbQZhQcYGYUEeB2FBdgdhQc8HYUEnCGFBfwhhQdcIYUEwCWFBiAlhQeAJYUE5CmFBkQphQekKYUFBC2FBmgthQfILYUFKDGFBogxhQfoMYUFTDWFBqw1hQQMOYUFbDmFBtA5hQQwPYUFkD2FBvA9hQRQQYUFsEGFBxRBhQR0RYUF1EWFBzRFhQSUSYUF9EmFB1hJhQS4TYUGGE2FB3hNhQTYUYUGOFGFB5hRhQT4VYUGWFWFB7xVhQUcWYUGfFmFB9xZhQU8XYUGnF2FB/xdhQVcYYUGvGGFBBxlhQV8ZYUG3GWFBDxphQWcaYUG/GmFBFxthQW8bYUHHG2FBHxxhQXccYUHPHGFBJx1hQX8dYUHXHWFBLx5hQYceYUHfHmFBNx9hQY8fYUHnH2FBPyBhQZcgYUHvIGFBRyFhQZ8hYUH3IWFBTyJhQaYiYUH+ImFBViNhQa4jYUEGJGFBXiRhQbYkYUEOJWFBZSVhQb0lYUEVJmFBbSZhQcUmYUEdJ2FBdSdhQcwnYUEkKGFBfChhQdQoYUEsKWFBgylhQdspYUEzKmFBiyphQeMqYUE6K2FBkithQeorYUFCLGFBmSxhQfEsYUFJLWFBoS1hQfgtYUFQLmFBqC5hQQAvYUFXL2FBry9hQQcwYUFeMGFBtjBhQQ4xYUFlMWFBvTFhQRUyYUFsMmFBxDJhQRwzYUFzM2FByzNhQSM0YUF6NGFB0jRhQSo1YUGBNWFB2TVhQTA2YUGINmFB4DZhQTc3YUGPN2FB5jdhQT44YUGWOGFB7ThhQUU5YUGcOWFB9DlhQUs6YUGjOmFB+zphQVI7YUGqO2FBATxhQVk8YUGwPGFBCD1hQV89YUG3PWFBDj5hQWY+YUG9PmFBFT9hQWw/YUHEP2FBG0BhQXNAYUHKQGFBIUFhQXlBYUHQQWFBKEJhQX9CYUHXQmFBLkNhQYVDYUHdQ2FBNERhQYxEYUHjRGFBOkVhQZJFYUHpRWFBQUZhQZhGYUHvRmFBR0dhQZ5HYUH1R2FBTUhhQaRIYUH7SGFBU0lhQapJYUEBSmFBWUphQbBKYUEHS2FBX0thQbZLYUENTGFBZExhQbxMYUETTWFBak1hQcJNYUEZTmFBcE5hQcdOYUEfT2FBdk9hQc1PYUEkUGFBfFBhQdNQYUEqUWFBgVFhQdhRYUEwUmFBh1JhQd5SYUE1U2FBjFNhQeNTYUE7VGFBklRhQelUYUFAVWFBl1VhQe5VYUFGVmFBnVZhQfRWYUFLV2FBoldhQflXYUFQWGFBp1hhQf5YYUFWWWFBrVlhQQRaYUFbWmFBslphQQlbYUFgW2FBt1thQQ5cYUFlXGFBvFxhQRNdYUFqXWFBwV1hQRheYUFvXmFBxl5hQR1fYUF0X2FBy19hQSJgYUF5YGFB0GBhQSdhYUF+YWFB1WFhQSxiYUGDYmFB2mJhQTFjYUGIY2FB32NhQTZkYUGNZGFB5GRhQTtlYUGSZWFB6WVhQT9mYUGWZmFB7WZhQURnYUGbZ2FB8mdhQUloYUGgaGFB9mhhQU1pYUGkaWFB+2lhQVJqYUGpamFBAGthQVZrYUGta2FBBGxhQVtsYUGybGFBCG1hQV9tYUG2bWFBDW5hQWRuYUG6bmFBEW9hQWhvYUG/b2FBFXBhQWxwYUHDcGFBGnFhQXBxYUHHcWFBHnJhQXVyYUHLcmFBInNhQXlzYUHPc2FBJnRhQX10YUHUdGFBKnVhQYF1YUHYdWFBLnZhQYV2YUHcdmFBMndhQYl3YUHgd2FBNnhhQY14YUHjeGFBOnlhQZF5YUHneWFBPnphQZV6YUHremFBQnthQZh7YUHve2FBRXxhQZx8YUHzfGFBSX1hQaB9YUH2fWFBTX5hQaN+YUH6fmFBUH9hQad/YUH+f2FBVIBhQauAYUEBgWFBWIFhQa6BYUEFgmFBW4JhQbKCYUEIg2FBX4NhQbWDYUELhGFBYoRhQbiEYUEPhWFBZYVhQbyFYUEShmFBaYZhQb+GYUEVh2FBbIdhQcKHYUEZiGFBb4hhQcWIYUEciWFBcolhQcmJYUEfimFBdYphQcyKYUEii2FBeIthQc+LYUEljGFBfIxhQdKMYUEojWFBf41hQdWNYUErjmFBgY5hQdiOYUEuj2FBhI9hQduPYUExkGFBh5BhQd6QYUE0kWFBipFhQeCRYUE3kmFBjZJhQeOSYUE5k2FBkJNhQeaTYUE8lGFBkpRhQemUYUE/lWFBlZVhQeuVYUFBlmFBmJZhQe6WYUFEl2FBmpdhQfCXYUFGmGFBnZhhQfOYYUFJmWFBn5lhQfWZYUFLmmFBopphQfiaYUFOm2FBpJthQfqbYUFQnGFBppxhQfycYUFSnWFBqZ1hQf+dYUFVnmFBq55hQQGfYUFXn2FBrZ9hQQOgYUFZoGFBr6BhQQWhYUFboWFBsaFhQQeiYUFdomFBs6JhQQmjYUFfo2FBtaNhQQukYUFhpGFBt6RhQQ2lYUFjpWFBuaVhQQ+mYUFlpmFBu6ZhQRGnYUFnp2FBvadhQROoYUFpqGFBv6hhQRWpYUFrqWFBwalhQRaqYUFsqmFBwqphQRirYUFuq2FBxKthQRqsYUFwrGFBxqxhQRutYUFxrWFBx61hQR2uYUFzrmFBya5hQR+vYUF0r2FByq9hQSCwYUF2sGFBzLBhQSKxYUF3sWFBzbFhQSOyYUF5smFBzrJhQSSzYUF6s2FB0LNhQSa0YUF7tGFB0bRhQSe1YUF9tWFB0rVhQSi2YUF+tmFB1LZhQSm3YUF/t2FB1bdhQSq4YUGAuGFB1rhhQSu5YUGBuWFB17lhQS26YUGCumFB2LphQS67YUGDu2FB2bthQS68YUGEvGFB2rxhQS+9YUGFvWFB271hQTC+YUGGvmFB3L5hQTG/YUGHv2FB3L9hQTLAYUGHwGFB3cBhQTPBYUGIwWFB3sFhQTPCYUGJwmFB3sJhQTTDYUGKw2FB38NhQTXEYUGKxGFB4MRhQTXFYUGLxWFB4MVhQTbGYUGLxmFB4cZhQTbHYUGMx2FB4cdhQTfIYUGMyGFB4shhQTfJYUGMyWFB4slhQTfKYUGNymFB4sphQTjLYUGNy2FB48thQTjMYUGNzGFB48xhQTjNYUGOzWFB481hQTjOYUGOzmFB485hQTjPYUGOz2FB489hQTnQYUGO0GFB49BhQTnRYUGO0WFB49FhQTnSYUGO0mFB49JhQTnTYUGO02FB49NhQTnUYUGO1GFB49RhQTjVYUGO1WFB49VhQTjWYUGN1mFB49ZhQTjXYUGN12FB49dhQTjYYUGN2GFB4thhQTfZYUGN2WFB4tlhQTfaYUGM2mFB4tphQTfbYUGM22FB4dthQTbcYUGL3GFB4dxhQTbdYUGL3WFB4N1hQTXeYUGK3mFB4N5hQTXfYUGK32FB399hQTTgYUGJ4GFB3uBhQTThYUGJ4WFB3uFhQTPiYUGI4mFB3eJhQTLjYUGH42FB3ONhQTHkYUGG5GFB2+RhQTHlYUGG5WFB2+VhQTDmYUGF5mFB2uZhQS/nYUGE52FB2edhQS7oYUGD6GFB2OhhQS3pYUGC6WFB1+lhQSzqYUGB6mFB1uphQSvrYUGA62FB1ethQSrsYUF/7GFB0+xhQSjtYUF97WFB0u1hQSfuYUF87mFB0e5hQSbvYUF772FB0O9hQSXwYUF68GFBzvBhQSPxYUF48WFBzfFhQSLyYUF38mFBzPJhQSHzYUF182FByvNhQR/0YUF09GFByfRhQR71YUFy9WFBx/VhQRz2YUFx9mFBxvZhQRr3YUFv92FBxPdhQRn4YUFu+GFBwvhhQRf5YUFs+WFBwflhQRX6YUFq+mFBv/phQRT7YUFo+2FBvfthQRL8YUFn/GFBu/xhQRD9YUFl/WFBuf1hQQ7+YUFj/mFBuP5hQQz/YUFh/2FBtv9hQQoAYkFfAGJBtABiQQgBYkFdAWJBsgFiQQYCYkFbAmJBrwJiQQQDYkFZA2JBrQNiQQIEYkFXBGJBqwRiQQAFYkFUBWJBqQViQf4FYkFSBmJBpwZiQfsGYkFQB2JBpAdiQfkHYkFOCGJBoghiQfcIYkFLCWJBoAliQfQJYkFJCmJBnQpiQfIKYkFGC2JBmwtiQe8LYkFEDGJBmAxiQe0MYkFBDWJBlg1iQeoNYkE/DmJBkw5iQegOYkE8D2JBkA9iQeUPYkE5EGJBjhBiQeIQYkE3EWJBixFiQd8RYkE0EmJBiBJiQd0SYkExE2JBhRNiQdoTYkEuFGJBgxRiQdcUYkErFWJBgBViQdQVYkEoFmJBfRZiQdEWYkElF2JBehdiQc4XYkEiGGJBdxhiQcsYYkEfGWJBdBliQcgZYkEcGmJBcRpiQcUaYkEZG2JBbRtiQcIbYkEWHGJBahxiQb8cYkETHWJBZx1iQbsdYkEQHmJBZB5iQbgeYkEMH2JBYB9iQbUfYkEJIGJBXSBiQbEgYkEGIWJBWiFiQa4hYkECImJBViJiQaoiYkH/ImJBUyNiQacjYkH7I2JBTyRiQaMkYkH4JGJBTCViQaAlYkH0JWJBSCZiQZwmYkHwJmJBRCdiQZknYkHtJ2JBQShiQZUoYkHpKGJBPSliQZEpYkHlKWJBOSpiQY0qYkHhKmJBNStiQYkrYkHeK2JBMixiQYYsYkHaLGJBLi1iQYItYkHWLWJBKi5iQX4uYkHSLmJBJi9iQXovYkHOL2JBIjBiQXYwYkHKMGJBHjFiQXIxYkHGMWJBGTJiQW0yYkHBMmJBFTNiQWkzYkG9M2JBETRiQWU0YkG5NGJBDTViQWE1YkG1NWJBCTZiQVw2YkGwNmJBBDdiQVg3YkGsN2JBADhiQVQ4YkGoOGJB+zhiQU85YkGjOWJB9zliQUs6YkGfOmJB8zpiQUY7YkGaO2JB7jtiQUI8YkGWPGJB6TxiQT09YkGRPWJB5T1iQTk+YkGMPmJB4D5iQTQ/YkGIP2JB2z9iQS9AYkGDQGJB10BiQSpBYkF+QWJB0kFiQSZCYkF5QmJBzUJiQSFDYkF1Q2JByENiQRxEYkFwRGJBw0RiQRdFYkFrRWJBvkViQRJGYkFmRmJBuUZiQQ1HYkFhR2JBtEdiQQhIYkFcSGJBr0hiQQNJYkFXSWJBqkliQf5JYkFRSmJBpUpiQflKYkFMS2JBoEtiQfNLYkFHTGJBm0xiQe5MYkFCTWJBlU1iQelNYkE8TmJBkE5iQeNOYkE3T2JBi09iQd5PYkEyUGJBhVBiQdlQYkEsUWJBgFFiQdNRYkEnUmJBelJiQc5SYkEhU2JBdVNiQchTYkEcVGJBb1RiQcNUYkEWVWJBaVViQb1VYkEQVmJBZFZiQbdWYkELV2JBXldiQbJXYkEFWGJBWFhiQaxYYkH/WGJBU1liQaZZYkH5WWJBTVpiQaBaYkH0WmJBR1tiQZpbYkHuW2JBQVxiQZRcYkHoXGJBO11iQY5dYkHiXWJBNV5iQYheYkHcXmJBL19iQYJfYkHWX2JBKWBiQXxgYkHQYGJBI2FiQXZhYkHJYWJBHWJiQXBiYkHDYmJBF2NiQWpjYkG9Y2JBEGRiQWRkYkG3ZGJBCmViQV1lYkGwZWJBBGZiQVdmYkGqZmJB/WZiQVFnYkGkZ2JB92diQUpoYkGdaGJB8GhiQURpYkGXaWJB6mliQT1qYkGQamJB42piQTdrYkGKa2JB3WtiQTBsYkGDbGJB1mxiQSltYkF9bWJB0G1iQSNuYkF2bmJByW5iQRxvYkFvb2JBwm9iQRVwYkFocGJBu3BiQQ9xYkFicWJBtXFiQQhyYkFbcmJBrnJiQQFzYkFUc2JBp3NiQfpzYkFNdGJBoHRiQfN0YkFGdWJBmXViQex1YkE/dmJBknZiQeV2YkE4d2JBi3diQd53YkExeGJBhHhiQdd4YkEqeWJBfXliQdB5YkEjemJBdXpiQch6YkEbe2JBbntiQcF7YkEUfGJBZ3xiQbp8YkENfWJBYH1iQbN9YkEFfmJBWH5iQat+YkH+fmJBUX9iQaR/YkH3f2JBSoBiQZyAYkHvgGJBQoFiQZWBYkHogWJBO4JiQY2CYkHggmJBM4NiQYaDYkHZg2JBK4RiQX6EYkHRhGJBJIViQXeFYkHJhWJBHIZiQW+GYkHChmJBFIdiQWeHYkG6h2JBDYhiQV+IYkGyiGJBBYliQViJYkGqiWJB/YliQVCKYkGiimJB9YpiQUiLYkGbi2JB7YtiQUCMYkGTjGJB5YxiQTiNYkGLjWJB3Y1iQTCOYkGDjmJB1Y5iQSiPYkF7j2JBzY9iQSCQYkFykGJBxZBiQRiRYkFqkWJBvZFiQQ+SYkFikmJBtZJiQQeTYkFak2JBrJNiQf+TYkFSlGJBpJRiQfeUYkFJlWJBnJViQe6VYkFBlmJBk5ZiQeaWYkE5l2JBi5diQd6XYkEwmGJBg5hiQdWYYkEomWJBepliQc2ZYkEfmmJBcppiQcSaYkEXm2JBaZtiQbybYkEOnGJBYJxiQbOcYkEFnWJBWJ1iQaqdYkH9nWJBT55iQaKeYkH0nmJBRp9iQZmfYkHrn2JBPqBiQZCgYkHioGJBNaFiQYehYkHaoWJBLKJiQX6iYkHRomJBI6NiQXWjYkHIo2JBGqRiQW2kYkG/pGJBEaViQWSlYkG2pWJBCKZiQVqmYkGtpmJB/6ZiQVGnYkGkp2JB9qdiQUioYkGbqGJB7ahiQT+pYkGRqWJB5KliQTaqYkGIqmJB26piQS2rYkF/q2JB0atiQSSsYkF2rGJByKxiQRqtYkFsrWJBv61iQRGuYkFjrmJBta5iQQevYkFar2JBrK9iQf6vYkFQsGJBorBiQfWwYkFHsWJBmbFiQeuxYkE9smJBj7JiQeKyYkE0s2JBhrNiQdizYkEqtGJBfLRiQc60YkEgtWJBc7ViQcW1YkEXtmJBabZiQbu2YkENt2JBX7diQbG3YkEDuGJBVbhiQae4YkH5uGJBTLliQZ65YkHwuWJBQrpiQZS6YkHmumJBOLtiQYq7YkHcu2JBLrxiQYC8YkHSvGJBJL1iQXa9YkHIvWJBGr5iQWy+YkG+vmJBEL9iQWK/YkG0v2JBBsBiQVjAYkGqwGJB/MBiQU7BYkGfwWJB8cFiQUPCYkGVwmJB58JiQTnDYkGLw2JB3cNiQS/EYkGBxGJB08RiQSXFYkF2xWJByMViQRrGYkFsxmJBvsZiQRDHYkFix2JBtMdiQQXIYkFXyGJBqchiQfvIYkFNyWJBn8liQfDJYkFCymJBlMpiQebKYkE4y2JBictiQdvLYkEtzGJBf8xiQdHMYkEizWJBdM1iQcbNYkEYzmJBas5iQbvOYkENz2JBX89iQbHPYkEC0GJBVNBiQabQYkH30GJBSdFiQZvRYkHt0WJBPtJiQZDSYkHi0mJBM9NiQYXTYkHX02JBKdRiQXrUYkHM1GJBHtViQW/VYkHB1WJBE9ZiQWTWYkG21mJBCNdiQVnXYkGr12JB/NdiQU7YYkGg2GJB8dhiQUPZYkGV2WJB5tliQTjaYkGJ2mJB29piQS3bYkF+22JB0NtiQSHcYkFz3GJBxNxiQRbdYkFo3WJBud1iQQveYkFc3mJBrt5iQf/eYkFR32JBot9iQfTfYkFF4GJBl+BiQejgYkE64WJBi+FiQd3hYkEu4mJBgOJiQdHiYkEj42JBdONiQcbjYkEX5GJBaeRiQbrkYkEM5WJBXeViQa7lYkEA5mJBUeZiQaPmYkH05mJBRudiQZfnYkHo52JBOuhiQYvoYkHd6GJBLuliQX/pYkHR6WJBIupiQXTqYkHF6mJBFutiQWjrYkG562JBCuxiQVzsYkGt7GJB/uxiQVDtYkGh7WJB8u1iQUTuYkGV7mJB5u5iQTjvYkGJ72JB2u9iQSzwYkF98GJBzvBiQSDxYkFx8WJBwvFiQRPyYkFl8mJBtvJiQQfzYkFY82JBqvNiQfvzYkFM9GJBnfRiQe/0YkFA9WJBkfViQeL1YkE09mJBhfZiQdb2YkEn92JBePdiQcr3YkEb+GJBbPhiQb34YkEO+WJBX/liQbH5YkEC+mJBU/piQaT6YkH1+mJBRvtiQZj7YkHp+2JBOvxiQYv8YkHc/GJBLf1iQX79YkHP/WJBIf5iQXL+YkHD/mJBFP9iQWX/YkG2/2JBBwBjQVgAY0GpAGNB+gBjQUsBY0GcAWNB7QFjQT8CY0GQAmNB4QJjQTIDY0GDA2NB1ANjQSUEY0F2BGNBxwRjQRgFY0FpBWNBugVjQQsGY0FcBmNBrQZjQf4GY0FPB2NBoAdjQfEHY0FCCGNBkwhjQeQIY0E1CWNBhQljQdYJY0EnCmNBeApjQckKY0EaC2NBawtjQbwLY0ENDGNBXgxjQa8MY0EADWNBUQ1jQaENY0HyDWNBQw5jQZQOY0HlDmNBNg9jQYcPY0HYD2NBKBBjQXkQY0HKEGNBGxFjQWwRY0G9EWNBDhJjQV4SY0GvEmNBABNjQVETY0GiE2NB8hNjQUMUY0GUFGNB5RRjQTYVY0GGFWNB1xVjQSgWY0F5FmNByhZjQRoXY0FrF2NBvBdjQQ0YY0FdGGNBrhhjQf8YY0FQGWNBoBljQfEZY0FCGmNBkhpjQeMaY0E0G2NBhRtjQdUbY0EmHGNBdxxjQcccY0EYHWNBaR1jQbkdY0EKHmNBWx5jQaseY0H8HmNBTR9jQZ0fY0HuH2NBPyBjQY8gY0HgIGNBMSFjQYEhY0HSIWNBIiJjQXMiY0HEImNBFCNjQWUjY0G1I2NBBiRjQVckY0GnJGNB+CRjQUglY0GZJWNB6SVjQTomY0GLJmNB2yZjQSwnY0F8J2NBzSdjQR0oY0FuKGNBvihjQQ8pY0FfKWNBsCljQQAqY0FRKmNBoSpjQfIqY0FCK2NBkytjQeMrY0E0LGNBhCxjQdUsY0ElLWNBdi1jQcYtY0EXLmNBZy5jQbcuY0EIL2NBWC9jQakvY0H5L2NBSjBjQZowY0HqMGNBOzFjQYsxY0HcMWNBLDJjQXwyY0HNMmNBHTNjQW4zY0G+M2NBDjRjQV80Y0GvNGNB/zRjQVA1Y0GgNWNB8DVjQUE2Y0GRNmNB4TZjQTI3Y0GCN2NB0jdjQSM4Y0FzOGNBwzhjQRQ5Y0FkOWNBtDljQQU6Y0FVOmNBpTpjQfU6Y0FGO2NBljtjQeY7Y0E2PGNBhzxjQdc8Y0EnPWNBdz1jQcg9Y0EYPmNBaD5jQbg+Y0EJP2NBWT9jQak/Y0H5P2NBSUBjQZpAY0HqQGNBOkFjQYpBY0HaQWNBK0JjQXtCY0HLQmNBG0NjQWtDY0G7Q2NBDERjQVxEY0GsRGNB/ERjQUxFY0GcRWNB7EVjQT1GY0GNRmNB3UZjQS1HY0F9R2NBzUdjQR1IY0FtSGNBvUhjQQ1JY0FeSWNBrkljQf5JY0FOSmNBnkpjQe5KY0E+S2NBjktjQd5LY0EuTGNBfkxjQc5MY0EeTWNBbk1jQb5NY0EOTmNBXk5jQa5OY0H+TmNBTk9jQZ5PY0HuT2NBPlBjQY5QY0HeUGNBLlFjQX5RY0HOUWNBHlJjQW5SY0G+UmNBDlNjQV5TY0GuU2NB/lNjQU5UY0GeVGNB7lRjQT1VY0GNVWNB3VVjQS1WY0F9VmNBzVZjQR1XY0FtV2NBvVdjQQ1YY0FcWGNBrFhjQfxYY0FMWWNBnFljQexZY0E8WmNBi1pjQdtaY0ErW2NBe1tjQctbY0EbXGNBalxjQbpcY0EKXWNBWl1jQapdY0H6XWNBSV5jQZleY0HpXmNBOV9jQYhfY0HYX2NBKGBjQXhgY0HIYGNBF2FjQWdhY0G3YWNBB2JjQVZiY0GmYmNB9mJjQUZjY0GVY2NB5WNjQTVkY0GEZGNB1GRjQSRlY0F0ZWNBw2VjQRNmY0FjZmNBsmZjQQJnY0FSZ2NBoWdjQfFnY0FBaGNBkGhjQeBoY0EwaWNBf2ljQc9pY0EfamNBbmpjQb5qY0ENa2NBXWtjQa1rY0H8a2NBTGxjQZxsY0HrbGNBO21jQYptY0HabWNBKW5jQXluY0HJbmNBGG9jQWhvY0G3b2NBB3BjQVZwY0GmcGNB9nBjQUVxY0GVcWNB5HFjQTRyY0GDcmNB03JjQSJzY0Fyc2NBwXNjQRF0Y0FgdGNBsHRjQf90Y0FPdWNBnnVjQe51Y0E9dmNBjXZjQdx2Y0Esd2NBe3djQct3Y0EaeGNBaXhjQbl4Y0EIeWNBWHljQad5Y0H3eWNBRnpjQZV6Y0HlemNBNHtjQYR7Y0HTe2NBInxjQXJ8Y0HBfGNBEX1jQWB9Y0GvfWNB/31jQU5+Y0GdfmNB7X5jQTx/Y0GMf2NB239jQSqAY0F6gGNByYBjQRiBY0FogWNBt4FjQQaCY0FVgmNBpYJjQfSCY0FDg2NBk4NjQeKDY0ExhGNBgYRjQdCEY0EfhWNBboVjQb6FY0ENhmNBXIZjQauGY0H7hmNBSodjQZmHY0Hoh2NBOIhjQYeIY0HWiGNBJYljQXWJY0HEiWNBE4pjQWKKY0GximNBAYtjQVCLY0Gfi2NB7otjQT2MY0GMjGNB3IxjQSuNY0F6jWNByY1jQRiOY0FnjmNBt45jQQaPY0FVj2NBpI9jQfOPY0FCkGNBkZBjQeGQY0EwkWNBf5FjQc6RY0EdkmNBbJJjQbuSY0EKk2NBWZNjQaiTY0H3k2NBR5RjQZaUY0HllGNBNJVjQYOVY0HSlWNBIZZjQXCWY0G/lmNBDpdjQV2XY0Gsl2NB+5djQUqYY0GZmGNB6JhjQTeZY0GGmWNB1ZljQSSaY0FzmmNBwppjQRGbY0Fgm2NBr5tjQf6bY0FNnGNBnJxjQeucY0E6nWNBiZ1jQdidY0EnnmNBdp5jQcWeY0ETn2NBYp9jQbGfY0EAoGNBT6BjQZ6gY0HtoGNBPKFjQYuhY0HaoWNBKaJjQXeiY0HGomNBFaNjQWSjY0Gzo2NBAqRjQVGkY0GfpGNB7qRjQT2lY0GMpWNB26VjQSqmY0F5pmNBx6ZjQRanY0Flp2NBtKdjQQOoY0FRqGNBoKhjQe+oY0E+qWNBjaljQdupY0EqqmNBeapjQciqY0EWq2NBZatjQbSrY0EDrGNBUaxjQaCsY0HvrGNBPq1jQYytY0HbrWNBKq5jQXmuY0HHrmNBFq9jQWWvY0Gzr2NBArBjQVGwY0GgsGNB7rBjQT2xY0GMsWNB2rFjQSmyY0F4smNBxrJjQRWzY0Fks2NBsrNjQQG0Y0FQtGNBnrRjQe20Y0E7tWNBirVjQdm1Y0EntmNBdrZjQcW2Y0ETt2NBYrdjQbC3Y0H/t2NBTrhjQZy4Y0HruGNBObljQYi5Y0HWuWNBJbpjQXS6Y0HCumNBEbtjQV+7Y0Guu2NB/LtjQUu8Y0GZvGNB6LxjQTe9Y0GFvWNB1L1jQSK+Y0FxvmNBv75jQQ6/Y0Fcv2NBq79jQfm/Y0FIwGNBlsBjQeXAY0EzwWNBgcFjQdDBY0EewmNBbcJjQbvCY0EKw2NBWMNjQafDY0H1w2NBRMRjQZLEY0HgxGNBL8VjQX3FY0HMxWNBGsZjQWjGY0G3xmNBBcdjQVTHY0Gix2NB8MdjQT/IY0GNyGNB3MhjQSrJY0F4yWNBx8ljQRXKY0FjymNBsspjQQDLY0FOy2NBnctjQevLY0E5zGNBiMxjQdbMY0EkzWNBc81jQcHNY0EPzmNBXs5jQazOY0H6zmNBSM9jQZfPY0Hlz2NBM9BjQYHQY0HQ0GNBHtFjQWzRY0G70WNBCdJjQVfSY0Gl0mNB9NJjQULTY0GQ02NB3tNjQSzUY0F71GNBydRjQRfVY0Fl1WNBs9VjQQLWY0FQ1mNBntZjQezWY0E612NBiddjQdfXY0El2GNBc9hjQcHYY0EP2WNBXtljQazZY0H62WNBSNpjQZbaY0Hk2mNBMttjQYHbY0HP22NBHdxjQWvcY0G53GNBB91jQVXdY0Gj3WNB8d1jQT/eY0GO3mNB3N5jQSrfY0F432NBxt9jQRTgY0Fi4GNBsOBjQf7gY0FM4WNBmuFjQejhY0E24mNBhOJjQdLiY0Eg42NBbuNjQbzjY0EK5GNBWORjQabkY0H05GNBQuVjQZDlY0He5WNBLOZjQXrmY0HI5mNBFudjQWTnY0Gy52NBAOhjQU7oY0Gc6GNB6uhjQTjpY0GG6WNB1OljQSLqY0Fw6mNBvupjQQzrY0FZ62NBp+tjQfXrY0FD7GNBkexjQd/sY0Et7WNBe+1jQcntY0EX7mNBZO5jQbLuY0EA72NBTu9jQZzvY0Hq72NBOPBjQYXwY0HT8GNBIfFjQW/xY0G98WNBC/JjQVjyY0Gm8mNB9PJjQULzY0GQ82NB3vNjQSv0Y0F59GNBx/RjQRX1Y0Fi9WNBsPVjQf71Y0FM9mNBmvZjQef2Y0E192NBg/djQdH3Y0Ee+GNBbPhjQbr4Y0EI+WNBVfljQaP5Y0Hx+WNBPvpjQYz6Y0Ha+mNBKPtjQXX7Y0HD+2NBEfxjQV78Y0Gs/GNB+vxjQUf9Y0GV/WNB4/1jQTD+Y0F+/mNBzP5jQRn/Y0Fn/2NBtf9jQQIAZEFQAGRBngBkQesAZEE5AWRBhwFkQdQBZEEiAmRBbwJkQb0CZEELA2RBWANkQaYDZEHzA2RBQQRkQY8EZEHcBGRBKgVkQXcFZEHFBWRBEgZkQWAGZEGuBmRB+wZkQUkHZEGWB2RB5AdkQTEIZEF/CGRBzAhkQRoJZEFnCWRBtQlkQQIKZEFQCmRBnQpkQesKZEE4C2RBhgtkQdMLZEEhDGRBbgxkQbwMZEEJDWRBVw1kQaQNZEHyDWRBPw5kQY0OZEHaDmRBKA9kQXUPZEHCD2RBEBBkQV0QZEGrEGRB+BBkQUYRZEGTEWRB4BFkQS4SZEF7EmRByRJkQRYTZEFjE2RBsRNkQf4TZEFLFGRBmRRkQeYUZEE0FWRBgRVkQc4VZEEcFmRBaRZkQbYWZEEEF2RBURdkQZ4XZEHsF2RBORhkQYYYZEHUGGRBIRlkQW4ZZEG8GWRBCRpkQVYaZEGjGmRB8RpkQT4bZEGLG2RB2RtkQSYcZEFzHGRBwBxkQQ4dZEFbHWRBqB1kQfUdZEFDHmRBkB5kQd0eZEEqH2RBeB9kQcUfZEESIGRBXyBkQa0gZEH6IGRBRyFkQZQhZEHhIWRBLyJkQXwiZEHJImRBFiNkQWMjZEGwI2RB/iNkQUskZEGYJGRB5SRkQTIlZEF/JWRBzSVkQRomZEFnJmRBtCZkQQEnZEFOJ2RBmydkQeknZEE2KGRBgyhkQdAoZEEdKWRBailkQbcpZEEEKmRBUSpkQZ4qZEHsKmRBOStkQYYrZEHTK2RBICxkQW0sZEG6LGRBBy1kQVQtZEGhLWRB7i1kQTsuZEGILmRB1S5kQSIvZEFvL2RBvC9kQQkwZEFWMGRBozBkQfAwZEE9MWRBijFkQdcxZEEkMmRBcTJkQb4yZEELM2RBWDNkQaUzZEHyM2RBPzRkQYw0ZEHZNGRBJjVkQXM1ZEHANWRBDTZkQVo2ZEGnNmRB9DZkQUE3ZEGNN2RB2jdkQSc4ZEF0OGRBwThkQQ45ZEFbOWRBqDlkQfU5ZEFCOmRBjjpkQds6ZEEoO2RBdTtkQcI7ZEEPPGRBXDxkQag8ZEH1PGRBQj1kQY89ZEHcPWRBKT5kQXU+ZEHCPmRBDz9kQVw/ZEGpP2RB9j9kQUJAZEGPQGRB3EBkQSlBZEF2QWRBwkFkQQ9CZEFcQmRBqUJkQfVCZEFCQ2RBj0NkQdxDZEEoRGRBdURkQcJEZEEPRWRBW0VkQahFZEH1RWRBQkZkQY5GZEHbRmRBKEdkQXVHZEHBR2RBDkhkQVtIZEGnSGRB9EhkQUFJZEGNSWRB2klkQSdKZEFzSmRBwEpkQQ1LZEFZS2RBpktkQfNLZEE/TGRBjExkQdlMZEElTWRBck1kQb9NZEELTmRBWE5kQaROZEHxTmRBPk9kQYpPZEHXT2RBI1BkQXBQZEG9UGRBCVFkQVZRZEGiUWRB71FkQTxSZEGIUmRB1VJkQSFTZEFuU2RBulNkQQdUZEFTVGRBoFRkQexUZEE5VWRBhlVkQdJVZEEfVmRBa1ZkQbhWZEEEV2RBUVdkQZ1XZEHqV2RBNlhkQYNYZEHPWGRBHFlkQWhZZEG1WWRBAVpkQU1aZEGaWmRB5lpkQTNbZEF/W2RBzFtkQRhcZEFlXGRBsVxkQf1cZEFKXWRBll1kQeNdZEEvXmRBfF5kQcheZEEUX2RBYV9kQa1fZEH6X2RBRmBkQZJgZEHfYGRBK2FkQXdhZEHEYWRBEGJkQV1iZEGpYmRB9WJkQUJjZEGOY2RB2mNkQSdkZEFzZGRBv2RkQQxlZEFYZWRBpGVkQfFlZEE9ZmRBiWZkQdZmZEEiZ2RBbmdkQbpnZEEHaGRBU2hkQZ9oZEHsaGRBOGlkQYRpZEHQaWRBHWpkQWlqZEG1amRBAWtkQU5rZEGaa2RB5mtkQTJsZEF/bGRBy2xkQRdtZEFjbWRBsG1kQfxtZEFIbmRBlG5kQeBuZEEtb2RBeW9kQcVvZEERcGRBXXBkQalwZEH2cGRBQnFkQY5xZEHacWRBJnJkQXJyZEG/cmRBC3NkQVdzZEGjc2RB73NkQTt0ZEGHdGRB1HRkQSB1ZEFsdWRBuHVkQQR2ZEFQdmRBnHZkQeh2ZEE0d2RBgHdkQc13ZEEZeGRBZXhkQbF4ZEH9eGRBSXlkQZV5ZEHheWRBLXpkQXl6ZEHFemRBEXtkQV17ZEGpe2RB9XtkQUF8ZEGNfGRB2XxkQSV9ZEFxfWRBvX1kQQl+ZEFVfmRBoX5kQe1+ZEE5f2RBhX9kQdF/ZEEdgGRBaYBkQbWAZEEBgWRBTYFkQZmBZEHlgWRBMYJkQX2CZEHJgmRBFYNkQWGDZEGtg2RB+YNkQUWEZEGRhGRB3YRkQSiFZEF0hWRBwIVkQQyGZEFYhmRBpIZkQfCGZEE8h2RBiIdkQdSHZEEfiGRBa4hkQbeIZEEDiWRBT4lkQZuJZEHniWRBMopkQX6KZEHKimRBFotkQWKLZEGui2RB+YtkQUWMZEGRjGRB3YxkQSmNZEF1jWRBwI1kQQyOZEFYjmRBpI5kQfCOZEE7j2RBh49kQdOPZEEfkGRBapBkQbaQZEECkWRBTpFkQZmRZEHlkWRBMZJkQX2SZEHIkmRBFJNkQWCTZEGsk2RB95NkQUOUZEGPlGRB2pRkQSaVZEFylWRBvpVkQQmWZEFVlmRBoZZkQeyWZEE4l2RBhJdkQc+XZEEbmGRBZ5hkQbKYZEH+mGRBSplkQZWZZEHhmWRBLZpkQXiaZEHEmmRBEJtkQVubZEGnm2RB8ptkQT6cZEGKnGRB1ZxkQSGdZEFsnWRBuJ1kQQSeZEFPnmRBm55kQeaeZEEyn2RBfp9kQcmfZEEVoGRBYKBkQaygZEH3oGRBQ6FkQY+hZEHaoWRBJqJkQXGiZEG9omRBCKNkQVSjZEGfo2RB66NkQTakZEGCpGRBzaRkQRmlZEFkpWRBsKVkQfulZEFHpmRBkqZkQd6mZEEpp2RBdadkQcCnZEEMqGRBV6hkQaOoZEHuqGRBOqlkQYWpZEHQqWRBHKpkQWeqZEGzqmRB/qpkQUqrZEGVq2RB4KtkQSysZEF3rGRBw6xkQQ6tZEFZrWRBpa1kQfCtZEE8rmRBh65kQdKuZEEer2RBaa9kQbWvZEEAsGRBS7BkQZewZEHisGRBLbFkQXmxZEHEsWRBD7JkQVuyZEGmsmRB8bJkQT2zZEGIs2RB07NkQR+0ZEFqtGRBtbRkQQG1ZEFMtWRBl7VkQeK1ZEEutmRBebZkQcS2ZEEQt2RBW7dkQaa3ZEHxt2RBPbhkQYi4ZEHTuGRBHrlkQWq5ZEG1uWRBALpkQUu6ZEGXumRB4rpkQS27ZEF4u2RBw7tkQQ+8ZEFavGRBpbxkQfC8ZEE7vWRBh71kQdK9ZEEdvmRBaL5kQbO+ZEH/vmRBSr9kQZW/ZEHgv2RBK8BkQXbAZEHCwGRBDcFkQVjBZEGjwWRB7sFkQTnCZEGEwmRBz8JkQRvDZEFmw2RBscNkQfzDZEFHxGRBksRkQd3EZEEoxWRBc8VkQb/FZEEKxmRBVcZkQaDGZEHrxmRBNsdkQYHHZEHMx2RBF8hkQWLIZEGtyGRB+MhkQUPJZEGOyWRB2clkQSTKZEFvymRBuspkQQXLZEFRy2RBnMtkQefLZEEyzGRBfcxkQcjMZEETzWRBXs1kQanNZEH0zWRBPs5kQYnOZEHUzmRBH89kQWrPZEG1z2RBANBkQUvQZEGW0GRB4dBkQSzRZEF30WRBwtFkQQ3SZEFY0mRBo9JkQe7SZEE502RBhNNkQc7TZEEZ1GRBZNRkQa/UZEH61GRBRdVkQZDVZEHb1WRBJtZkQXDWZEG71mRBBtdkQVHXZEGc12RB59dkQTLYZEF82GRBx9hkQRLZZEFd2WRBqNlkQfPZZEE+2mRBiNpkQdPaZEEe22RBadtkQbTbZEH+22RBSdxkQZTcZEHf3GRBKt1kQXTdZEG/3WRBCt5kQVXeZEGf3mRB6t5kQTXfZEGA32RBy99kQRXgZEFg4GRBq+BkQfbgZEFA4WRBi+FkQdbhZEEg4mRBa+JkQbbiZEEB42RBS+NkQZbjZEHh42RBK+RkQXbkZEHB5GRBDOVkQVblZEGh5WRB7OVkQTbmZEGB5mRBzOZkQRbnZEFh52RBrOdkQfbnZEFB6GRBjOhkQdboZEEh6WRBbOlkQbbpZEEB6mRBS+pkQZbqZEHh6mRBK+tkQXbrZEHA62RBC+xkQVbsZEGg7GRB6+xkQTXtZEGA7WRBy+1kQRXuZEFg7mRBqu5kQfXuZEE/72RBiu9kQdXvZEEf8GRBavBkQbTwZEH/8GRBSfFkQZTxZEHe8WRBKfJkQXPyZEG+8mRBCPNkQVPzZEGd82RB6PNkQTL0ZEF99GRBx/RkQRL1ZEFc9WRBp/VkQfH1ZEE89mRBhvZkQdH2ZEEb92RBZvdkQbD3ZEH792RBRfhkQZD4ZEHa+GRBJPlkQW/5ZEG5+WRBBPpkQU76ZEGZ+mRB4/pkQS37ZEF4+2RBwvtkQQ38ZEFX/GRBofxkQez8ZEE2/WRBgf1kQcv9ZEEV/mRBYP5kQar+ZEH0/mRBP/9kQYn/ZEHU/2RBHgBlQWgAZUGzAGVB/QBlQUcBZUGSAWVB3AFlQSYCZUFxAmVBuwJlQQUDZUFPA2VBmgNlQeQDZUEuBGVBeQRlQcMEZUENBWVBWAVlQaIFZUHsBWVBNgZlQYEGZUHLBmVBFQdlQV8HZUGqB2VB9AdlQT4IZUGICGVB0whlQR0JZUFnCWVBsQllQfwJZUFGCmVBkAplQdoKZUEkC2VBbwtlQbkLZUEDDGVBTQxlQZcMZUHiDGVBLA1lQXYNZUHADWVBCg5lQVUOZUGfDmVB6Q5lQTMPZUF9D2VBxw9lQRIQZUFcEGVBphBlQfAQZUE6EWVBhBFlQc4RZUEYEmVBYxJlQa0SZUH3EmVBQRNlQYsTZUHVE2VBHxRlQWkUZUGzFGVB/hRlQUgVZUGSFWVB3BVlQSYWZUFwFmVBuhZlQQQXZUFOF2VBmBdlQeIXZUEsGGVBdhhlQcAYZUEKGWVBVBllQZ4ZZUHoGWVBMhplQX0aZUHHGmVBERtlQVsbZUGlG2VB7xtlQTkcZUGDHGVBzRxlQRcdZUFhHWVBqh1lQfQdZUE+HmVBiB5lQdIeZUEcH2VBZh9lQbAfZUH6H2VBRCBlQY4gZUHYIGVBIiFlQWwhZUG2IWVBACJlQUoiZUGUImVB3iJlQScjZUFxI2VBuyNlQQUkZUFPJGVBmSRlQeMkZUEtJWVBdyVlQcAlZUEKJmVBVCZlQZ4mZUHoJmVBMidlQXwnZUHGJ2VBDyhlQVkoZUGjKGVB7ShlQTcpZUGBKWVByillQRQqZUFeKmVBqCplQfIqZUE7K2VBhStlQc8rZUEZLGVBYyxlQawsZUH2LGVBQC1lQYotZUHULWVBHS5lQWcuZUGxLmVB+y5lQUQvZUGOL2VB2C9lQSIwZUFrMGVBtTBlQf8wZUFJMWVBkjFlQdwxZUEmMmVBcDJlQbkyZUEDM2VBTTNlQZYzZUHgM2VBKjRlQXM0ZUG9NGVBBzVlQVE1ZUGaNWVB5DVlQS42ZUF3NmVBwTZlQQs3ZUFUN2VBnjdlQeg3ZUExOGVBezhlQcQ4ZUEOOWVBWDllQaE5ZUHrOWVBNTplQX46ZUHIOmVBETtlQVs7ZUGlO2VB7jtlQTg8ZUGBPGVByzxlQRU9ZUFePWVBqD1lQfE9ZUE7PmVBhT5lQc4+ZUEYP2VBYT9lQas/ZUH0P2VBPkBlQYdAZUHRQGVBG0FlQWRBZUGuQWVB90FlQUFCZUGKQmVB1EJlQR1DZUFnQ2VBsENlQfpDZUFDRGVBjURlQdZEZUEgRWVBaUVlQbNFZUH8RWVBRkZlQY9GZUHZRmVBIkdlQWtHZUG1R2VB/kdlQUhIZUGRSGVB20hlQSRJZUFuSWVBt0llQQBKZUFKSmVBk0plQd1KZUEmS2VBb0tlQblLZUECTGVBTExlQZVMZUHeTGVBKE1lQXFNZUG7TWVBBE5lQU1OZUGXTmVB4E5lQSlPZUFzT2VBvE9lQQZQZUFPUGVBmFBlQeJQZUErUWVBdFFlQb5RZUEHUmVBUFJlQZpSZUHjUmVBLFNlQXZTZUG/U2VBCFRlQVFUZUGbVGVB5FRlQS1VZUF3VWVBwFVlQQlWZUFSVmVBnFZlQeVWZUEuV2VBd1dlQcFXZUEKWGVBU1hlQZxYZUHmWGVBL1llQXhZZUHBWWVBC1plQVRaZUGdWmVB5lplQTBbZUF5W2VBwltlQQtcZUFUXGVBnlxlQedcZUEwXWVBeV1lQcJdZUELXmVBVV5lQZ5eZUHnXmVBMF9lQXlfZUHCX2VBDGBlQVVgZUGeYGVB52BlQTBhZUF5YWVBwmFlQQxiZUFVYmVBnmJlQediZUEwY2VBeWNlQcJjZUELZGVBVGRlQZ5kZUHnZGVBMGVlQXllZUHCZWVBC2ZlQVRmZUGdZmVB5mZlQS9nZUF4Z2VBwWdlQQpoZUFUaGVBnWhlQeZoZUEvaWVBeGllQcFpZUEKamVBU2plQZxqZUHlamVBLmtlQXdrZUHAa2VBCWxlQVJsZUGbbGVB5GxlQS1tZUF2bWVBv21lQQhuZUFRbmVBmm5lQeNuZUEsb2VBdW9lQb5vZUEHcGVBUHBlQZhwZUHhcGVBKnFlQXNxZUG8cWVBBXJlQU5yZUGXcmVB4HJlQSlzZUFyc2VBu3NlQQR0ZUFMdGVBlXRlQd50ZUEndWVBcHVlQbl1ZUECdmVBS3ZlQZR2ZUHcdmVBJXdlQW53ZUG3d2VBAHhlQUl4ZUGSeGVB2nhlQSN5ZUFseWVBtXllQf55ZUFHemVBj3plQdh6ZUEhe2VBantlQbN7ZUH8e2VBRHxlQY18ZUHWfGVBH31lQWh9ZUGwfWVB+X1lQUJ+ZUGLfmVB035lQRx/ZUFlf2VBrn9lQfZ/ZUE/gGVBiIBlQdGAZUEZgWVBYoFlQauBZUH0gWVBPIJlQYWCZUHOgmVBF4NlQV+DZUGog2VB8YNlQTmEZUGChGVBy4RlQRSFZUFchWVBpYVlQe6FZUE2hmVBf4ZlQciGZUEQh2VBWYdlQaKHZUHqh2VBM4hlQXyIZUHEiGVBDYllQVaJZUGeiWVB54llQS+KZUF4imVBwYplQQmLZUFSi2VBm4tlQeOLZUEsjGVBdIxlQb2MZUEGjWVBTo1lQZeNZUHfjWVBKI5lQXGOZUG5jmVBAo9lQUqPZUGTj2VB249lQSSQZUFtkGVBtZBlQf6QZUFGkWVBj5FlQdeRZUEgkmVBaJJlQbGSZUH5kmVBQpNlQYqTZUHTk2VBG5RlQWSUZUGslGVB9ZRlQT2VZUGGlWVBzpVlQReWZUFflmVBqJZlQfCWZUE5l2VBgZdlQcqXZUESmGVBW5hlQaOYZUHsmGVBNJllQX2ZZUHFmWVBDZplQVaaZUGemmVB55plQS+bZUF4m2VBwJtlQQicZUFRnGVBmZxlQeKcZUEqnWVBcp1lQbudZUEDnmVBTJ5lQZSeZUHcnmVBJZ9lQW2fZUG1n2VB/p9lQUagZUGPoGVB16BlQR+hZUFooWVBsKFlQfihZUFBomVBiaJlQdGiZUEao2VBYqNlQaqjZUHzo2VBO6RlQYOkZUHMpGVBFKVlQVylZUGkpWVB7aVlQTWmZUF9pmVBxqZlQQ6nZUFWp2VBnqdlQeenZUEvqGVBd6hlQb+oZUEIqWVBUKllQZipZUHgqWVBKaplQXGqZUG5qmVBAatlQUqrZUGSq2VB2qtlQSKsZUFrrGVBs6xlQfusZUFDrWVBi61lQdStZUEcrmVBZK5lQayuZUH0rmVBPK9lQYWvZUHNr2VBFbBlQV2wZUGlsGVB7bBlQTaxZUF+sWVBxrFlQQ6yZUFWsmVBnrJlQeayZUEvs2VBd7NlQb+zZUEHtGVBT7RlQZe0ZUHftGVBJ7VlQXC1ZUG4tWVBALZlQUi2ZUGQtmVB2LZlQSC3ZUFot2VBsLdlQfi3ZUFAuGVBiLhlQdG4ZUEZuWVBYbllQam5ZUHxuWVBObplQYG6ZUHJumVBEbtlQVm7ZUGhu2VB6btlQTG8ZUF5vGVBwbxlQQm9ZUFRvWVBmb1lQeG9ZUEpvmVBcb5lQbm+ZUEBv2VBSb9lQZG/ZUHZv2VBIcBlQWnAZUGxwGVB+cBlQUHBZUGJwWVB0cFlQRnCZUFhwmVBqcJlQfDCZUE4w2VBgMNlQcjDZUEQxGVBWMRlQaDEZUHoxGVBMMVlQXjFZUHAxWVBCMZlQU/GZUGXxmVB38ZlQSfHZUFvx2VBt8dlQf/HZUFHyGVBj8hlQdbIZUEeyWVBZsllQa7JZUH2yWVBPsplQYbKZUHNymVBFctlQV3LZUGly2VB7ctlQTXMZUF8zGVBxMxlQQzNZUFUzWVBnM1lQePNZUErzmVBc85lQbvOZUEDz2VBSs9lQZLPZUHaz2VBItBlQWrQZUGx0GVB+dBlQUHRZUGJ0WVB0NFlQRjSZUFg0mVBqNJlQe/SZUE302VBf9NlQcfTZUEO1GVBVtRlQZ7UZUHl1GVBLdVlQXXVZUG91WVBBNZlQUzWZUGU1mVB29ZlQSPXZUFr12VBs9dlQfrXZUFC2GVBithlQdHYZUEZ2WVBYdllQajZZUHw2WVBONplQX/aZUHH2mVBD9tlQVbbZUGe22VB5dtlQS3cZUF13GVBvNxlQQTdZUFM3WVBk91lQdvdZUEi3mVBat5lQbLeZUH53mVBQd9lQYjfZUHQ32VBGOBlQV/gZUGn4GVB7uBlQTbhZUF94WVBxeFlQQ3iZUFU4mVBnOJlQePiZUEr42VBcuNlQbrjZUEB5GVBSeRlQZDkZUHY5GVBIOVlQWflZUGv5WVB9uVlQT7mZUGF5mVBzeZlQRTnZUFc52VBo+dlQevnZUEy6GVBeuhlQcHoZUEI6WVBUOllQZfpZUHf6WVBJuplQW7qZUG16mVB/eplQUTrZUGM62VB0+tlQRvsZUFi7GVBqexlQfHsZUE47WVBgO1lQcftZUEP7mVBVu5lQZ3uZUHl7mVBLO9lQXTvZUG772VBAvBlQUrwZUGR8GVB2PBlQSDxZUFn8WVBr/FlQfbxZUE98mVBhfJlQczyZUET82VBW/NlQaLzZUHp82VBMfRlQXj0ZUG/9GVBB/VlQU71ZUGV9WVB3fVlQST2ZUFr9mVBs/ZlQfr2ZUFB92VBifdlQdD3ZUEX+GVBX/hlQab4ZUHt+GVBNPllQXz5ZUHD+WVBCvplQVH6ZUGZ+mVB4PplQSf7ZUFv+2VBtvtlQf37ZUFE/GVBjPxlQdP8ZUEa/WVBYf1lQaj9ZUHw/WVBN/5lQX7+ZUHF/mVBDf9lQVT/ZUGb/2VB4v9lQSkAZkFxAGZBuABmQf8AZkFGAWZBjQFmQdQBZkEcAmZBYwJmQaoCZkHxAmZBOANmQX8DZkHHA2ZBDgRmQVUEZkGcBGZB4wRmQSoFZkFxBWZBuQVmQQAGZkFHBmZBjgZmQdUGZkEcB2ZBYwdmQaoHZkHyB2ZBOQhmQYAIZkHHCGZBDglmQVUJZkGcCWZB4wlmQSoKZkFxCmZBuApmQf8KZkFHC2ZBjgtmQdULZkEcDGZBYwxmQaoMZkHxDGZBOA1mQX8NZkHGDWZBDQ5mQVQOZkGbDmZB4g5mQSkPZkFwD2ZBtw9mQf4PZkFFEGZBjBBmQdMQZkEaEWZBYRFmQagRZkHvEWZBNhJmQX0SZkHEEmZBCxNmQVITZkGZE2ZB4BNmQScUZkFuFGZBtRRmQfwUZkFDFWZBihVmQdAVZkEXFmZBXhZmQaUWZkHsFmZBMxdmQXoXZkHBF2ZBCBhmQU8YZkGWGGZB3RhmQSMZZkFqGWZBsRlmQfgZZkE/GmZBhhpmQc0aZkEUG2ZBWxtmQaEbZkHoG2ZBLxxmQXYcZkG9HGZBBB1mQUsdZkGRHWZB2B1mQR8eZkFmHmZBrR5mQfQeZkE6H2ZBgR9mQcgfZkEPIGZBViBmQZwgZkHjIGZBKiFmQXEhZkG4IWZB/iFmQUUiZkGMImZB0yJmQRojZkFgI2ZBpyNmQe4jZkE1JGZBeyRmQcIkZkEJJWZBUCVmQZYlZkHdJWZBJCZmQWsmZkGxJmZB+CZmQT8nZkGGJ2ZBzCdmQRMoZkFaKGZBoChmQecoZkEuKWZBdSlmQbspZkECKmZBSSpmQY8qZkHWKmZBHStmQWMrZkGqK2ZB8StmQTcsZkF+LGZBxSxmQQstZkFSLWZBmS1mQd8tZkEmLmZBbS5mQbMuZkH6LmZBQS9mQYcvZkHOL2ZBFDBmQVswZkGiMGZB6DBmQS8xZkF1MWZBvDFmQQMyZkFJMmZBkDJmQdYyZkEdM2ZBZDNmQaozZkHxM2ZBNzRmQX40ZkHENGZBCzVmQVI1ZkGYNWZB3zVmQSU2ZkFsNmZBsjZmQfk2ZkE/N2ZBhjdmQc03ZkETOGZBWjhmQaA4ZkHnOGZBLTlmQXQ5ZkG6OWZBATpmQUc6ZkGOOmZB1DpmQRs7ZkFhO2ZBqDtmQe47ZkE1PGZBezxmQcE8ZkEIPWZBTj1mQZU9ZkHbPWZBIj5mQWg+ZkGvPmZB9T5mQTw/ZkGCP2ZByD9mQQ9AZkFVQGZBnEBmQeJAZkEpQWZBb0FmQbVBZkH8QWZBQkJmQYlCZkHPQmZBFUNmQVxDZkGiQ2ZB6UNmQS9EZkF1RGZBvERmQQJFZkFIRWZBj0VmQdVFZkEcRmZBYkZmQahGZkHvRmZBNUdmQXtHZkHCR2ZBCEhmQU5IZkGVSGZB20hmQSFJZkFoSWZBrklmQfRJZkE7SmZBgUpmQcdKZkENS2ZBVEtmQZpLZkHgS2ZBJ0xmQW1MZkGzTGZB+kxmQUBNZkGGTWZBzE1mQRNOZkFZTmZBn05mQeVOZkEsT2ZBck9mQbhPZkH+T2ZBRVBmQYtQZkHRUGZBF1FmQV5RZkGkUWZB6lFmQTBSZkF2UmZBvVJmQQNTZkFJU2ZBj1NmQdVTZkEcVGZBYlRmQahUZkHuVGZBNFVmQXtVZkHBVWZBB1ZmQU1WZkGTVmZB2VZmQSBXZkFmV2ZBrFdmQfJXZkE4WGZBflhmQcRYZkELWWZBUVlmQZdZZkHdWWZBI1pmQWlaZkGvWmZB9VpmQTtbZkGCW2ZByFtmQQ5cZkFUXGZBmlxmQeBcZkEmXWZBbF1mQbJdZkH4XWZBPl5mQYVeZkHLXmZBEV9mQVdfZkGdX2ZB419mQSlgZkFvYGZBtWBmQftgZkFBYWZBh2FmQc1hZkETYmZBWWJmQZ9iZkHlYmZBK2NmQXFjZkG3Y2ZB/WNmQUNkZkGJZGZBz2RmQRVlZkFbZWZBoWVmQedlZkEtZmZBc2ZmQblmZkH/ZmZBRWdmQYtnZkHRZ2ZBF2hmQV1oZkGjaGZB6WhmQS9pZkF1aWZBu2lmQQFqZkFGamZBjGpmQdJqZkEYa2ZBXmtmQaRrZkHqa2ZBMGxmQXZsZkG8bGZBAm1mQUhtZkGNbWZB021mQRluZkFfbmZBpW5mQetuZkExb2ZBd29mQbxvZkECcGZBSHBmQY5wZkHUcGZBGnFmQWBxZkGlcWZB63FmQTFyZkF3cmZBvXJmQQNzZkFIc2ZBjnNmQdRzZkEadGZBYHRmQaV0ZkHrdGZBMXVmQXd1ZkG9dWZBAnZmQUh2ZkGOdmZB1HZmQRp3ZkFfd2ZBpXdmQet3ZkExeGZBdnhmQbx4ZkECeWZBSHlmQY15ZkHTeWZBGXpmQV96ZkGkemZB6npmQTB7ZkF2e2ZBu3tmQQF8ZkFHfGZBjHxmQdJ8ZkEYfWZBXn1mQaN9ZkHpfWZBL35mQXR+ZkG6fmZBAH9mQUV/ZkGLf2ZB0X9mQRaAZkFcgGZBooBmQeeAZkEtgWZBc4FmQbiBZkH+gWZBRIJmQYmCZkHPgmZBFYNmQVqDZkGgg2ZB5oNmQSuEZkFxhGZBtoRmQfyEZkFChWZBh4VmQc2FZkEShmZBWIZmQZ6GZkHjhmZBKYdmQW6HZkG0h2ZB+odmQT+IZkGFiGZByohmQRCJZkFViWZBm4lmQeGJZkEmimZBbIpmQbGKZkH3imZBPItmQYKLZkHHi2ZBDYxmQVKMZkGYjGZB3oxmQSONZkFpjWZBro1mQfSNZkE5jmZBf45mQcSOZkEKj2ZBT49mQZWPZkHaj2ZBIJBmQWWQZkGqkGZB8JBmQTWRZkF7kWZBwJFmQQaSZkFLkmZBkZJmQdaSZkEck2ZBYZNmQaeTZkHsk2ZBMZRmQXeUZkG8lGZBApVmQUeVZkGNlWZB0pVmQReWZkFdlmZBopZmQeiWZkEtl2ZBcpdmQbiXZkH9l2ZBQ5hmQYiYZkHNmGZBE5lmQViZZkGdmWZB45lmQSiaZkFummZBs5pmQfiaZkE+m2ZBg5tmQcibZkEOnGZBU5xmQZicZkHenGZBI51mQWidZkGunWZB851mQTieZkF+nmZBw55mQQifZkFOn2ZBk59mQdifZkEdoGZBY6BmQaigZkHtoGZBM6FmQXihZkG9oWZBAqJmQUiiZkGNomZB0qJmQRijZkFdo2ZBoqNmQeejZkEtpGZBcqRmQbekZkH8pGZBQaVmQYelZkHMpWZBEaZmQVamZkGcpmZB4aZmQSanZkFrp2ZBsKdmQfanZkE7qGZBgKhmQcWoZkEKqWZBUKlmQZWpZkHaqWZBH6pmQWSqZkGqqmZB76pmQTSrZkF5q2ZBvqtmQQOsZkFJrGZBjqxmQdOsZkEYrWZBXa1mQaKtZkHnrWZBLa5mQXKuZkG3rmZB/K5mQUGvZkGGr2ZBy69mQRCwZkFVsGZBm7BmQeCwZkElsWZBarFmQa+xZkH0sWZBObJmQX6yZkHDsmZBCLNmQU2zZkGSs2ZB2LNmQR20ZkFitGZBp7RmQey0ZkExtWZBdrVmQbu1ZkEAtmZBRbZmQYq2ZkHPtmZBFLdmQVm3ZkGet2ZB47dmQSi4ZkFtuGZBsrhmQfe4ZkE8uWZBgblmQca5ZkELumZBULpmQZW6ZkHaumZBH7tmQWS7ZkGpu2ZB7rtmQTO8ZkF4vGZBvbxmQQK9ZkFHvWZBjL1mQdG9ZkEWvmZBW75mQaC+ZkHlvmZBKb9mQW6/ZkGzv2ZB+L9mQT3AZkGCwGZBx8BmQQzBZkFRwWZBlsFmQdvBZkEgwmZBZMJmQanCZkHuwmZBM8NmQXjDZkG9w2ZBAsRmQUfEZkGLxGZB0MRmQRXFZkFaxWZBn8VmQeTFZkEpxmZBbcZmQbLGZkH3xmZBPMdmQYHHZkHGx2ZBCshmQU/IZkGUyGZB2chmQR7JZkFjyWZBp8lmQezJZkExymZBdspmQbvKZkH/ymZBRMtmQYnLZkHOy2ZBE8xmQVfMZkGczGZB4cxmQSbNZkFqzWZBr81mQfTNZkE5zmZBfc5mQcLOZkEHz2ZBTM9mQZDPZkHVz2ZBGtBmQV/QZkGj0GZB6NBmQS3RZkFy0WZBttFmQfvRZkFA0mZBhNJmQcnSZkEO02ZBU9NmQZfTZkHc02ZBIdRmQWXUZkGq1GZB79RmQTPVZkF41WZBvdVmQQHWZkFG1mZBi9ZmQc/WZkEU12ZBWddmQZ3XZkHi12ZBJ9hmQWvYZkGw2GZB9NhmQTnZZkF+2WZBwtlmQQfaZkFM2mZBkNpmQdXaZkEZ22ZBXttmQaPbZkHn22ZBLNxmQXDcZkG13GZB+txmQT7dZkGD3WZBx91mQQzeZkFQ3mZBld5mQdreZkEe32ZBY99mQaffZkHs32ZBMOBmQXXgZkG54GZB/uBmQUPhZkGH4WZBzOFmQRDiZkFV4mZBmeJmQd7iZkEi42ZBZ+NmQavjZkHw42ZBNORmQXnkZkG95GZBAuVmQUblZkGL5WZBz+VmQRTmZkFY5mZBneZmQeHmZkEm52ZBaudmQa7nZkHz52ZBN+hmQXzoZkHA6GZBBelmQUnpZkGO6WZB0ulmQRfqZkFb6mZBn+pmQeTqZkEo62ZBbetmQbHrZkH162ZBOuxmQX7sZkHD7GZBB+1mQUvtZkGQ7WZB1O1mQRnuZkFd7mZBoe5mQebuZkEq72ZBb+9mQbPvZkH372ZBPPBmQYDwZkHE8GZBCfFmQU3xZkGR8WZB1vFmQRryZkFe8mZBo/JmQefyZkEr82ZBcPNmQbTzZkH482ZBPfRmQYH0ZkHF9GZBCvVmQU71ZkGS9WZB1/VmQRv2ZkFf9mZBo/ZmQej2ZkEs92ZBcPdmQbX3ZkH592ZBPfhmQYH4ZkHG+GZBCvlmQU75ZkGS+WZB1/lmQRv6ZkFf+mZBo/pmQej6ZkEs+2ZBcPtmQbT7ZkH5+2ZBPfxmQYH8ZkHF/GZBCf1mQU79ZkGS/WZB1v1mQRr+ZkFe/mZBo/5mQef+ZkEr/2ZBb/9mQbP/ZkH4/2ZBPABnQYAAZ0HEAGdBCAFnQUwBZ0GRAWdB1QFnQRkCZ0FdAmdBoQJnQeUCZ0EqA2dBbgNnQbIDZ0H2A2dBOgRnQX4EZ0HCBGdBBgVnQUsFZ0GPBWdB0wVnQRcGZ0FbBmdBnwZnQeMGZ0EnB2dBawdnQbAHZ0H0B2dBOAhnQXwIZ0HACGdBBAlnQUgJZ0GMCWdB0AlnQRQKZ0FYCmdBnApnQeAKZ0EkC2dBaQtnQa0LZ0HxC2dBNQxnQXkMZ0G9DGdBAQ1nQUUNZ0GJDWdBzQ1nQREOZ0FVDmdBmQ5nQd0OZ0EhD2dBZQ9nQakPZ0HtD2dBMRBnQXUQZ0G5EGdB/RBnQUERZ0GFEWdByRFnQQ0SZ0FREmdBlRJnQdkSZ0EdE2dBYRNnQaUTZ0HoE2dBLBRnQXAUZ0G0FGdB+BRnQTwVZ0GAFWdBxBVnQQgWZ0FMFmdBkBZnQdQWZ0EYF2dBXBdnQZ8XZ0HjF2dBJxhnQWsYZ0GvGGdB8xhnQTcZZ0F7GWdBvxlnQQMaZ0FGGmdBihpnQc4aZ0ESG2dBVhtnQZobZ0HeG2dBIRxnQWUcZ0GpHGdB7RxnQTEdZ0F1HWdBuR1nQfwdZ0FAHmdBhB5nQcgeZ0EMH2dBUB9nQZMfZ0HXH2dBGyBnQV8gZ0GjIGdB5iBnQSohZ0FuIWdBsiFnQfYhZ0E5ImdBfSJnQcEiZ0EFI2dBSCNnQYwjZ0HQI2dBFCRnQVgkZ0GbJGdB3yRnQSMlZ0FnJWdBqiVnQe4lZ0EyJmdBdiZnQbkmZ0H9JmdBQSdnQYQnZ0HIJ2dBDChnQVAoZ0GTKGdB1yhnQRspZ0FeKWdBoilnQeYpZ0EqKmdBbSpnQbEqZ0H1KmdBOCtnQXwrZ0HAK2dBAyxnQUcsZ0GLLGdBzixnQRItZ0FWLWdBmS1nQd0tZ0EhLmdBZC5nQaguZ0HsLmdBLy9nQXMvZ0G2L2dB+i9nQT4wZ0GBMGdBxTBnQQkxZ0FMMWdBkDFnQdMxZ0EXMmdBWzJnQZ4yZ0HiMmdBJTNnQWkzZ0GtM2dB8DNnQTQ0Z0F3NGdBuzRnQf80Z0FCNWdBhjVnQck1Z0ENNmdBUDZnQZQ2Z0HXNmdBGzdnQV83Z0GiN2dB5jdnQSk4Z0FtOGdBsDhnQfQ4Z0E3OWdBezlnQb45Z0ECOmdBRTpnQYk6Z0HMOmdBEDtnQVM7Z0GXO2dB2jtnQR48Z0FhPGdBpTxnQeg8Z0EsPWdBbz1nQbM9Z0H2PWdBOj5nQX0+Z0HBPmdBBD9nQUc/Z0GLP2dBzj9nQRJAZ0FVQGdBmUBnQdxAZ0EgQWdBY0FnQaZBZ0HqQWdBLUJnQXFCZ0G0QmdB+EJnQTtDZ0F+Q2dBwkNnQQVEZ0FJRGdBjERnQc9EZ0ETRWdBVkVnQZlFZ0HdRWdBIEZnQWRGZ0GnRmdB6kZnQS5HZ0FxR2dBtEdnQfhHZ0E7SGdBf0hnQcJIZ0EFSWdBSUlnQYxJZ0HPSWdBE0pnQVZKZ0GZSmdB3UpnQSBLZ0FjS2dBpktnQepLZ0EtTGdBcExnQbRMZ0H3TGdBOk1nQX5NZ0HBTWdBBE5nQUdOZ0GLTmdBzk5nQRFPZ0FVT2dBmE9nQdtPZ0EeUGdBYlBnQaVQZ0HoUGdBK1FnQW9RZ0GyUWdB9VFnQThSZ0F8UmdBv1JnQQJTZ0FFU2dBiFNnQcxTZ0EPVGdBUlRnQZVUZ0HZVGdBHFVnQV9VZ0GiVWdB5VVnQSlWZ0FsVmdBr1ZnQfJWZ0E1V2dBeFdnQbxXZ0H/V2dBQlhnQYVYZ0HIWGdBDFlnQU9ZZ0GSWWdB1VlnQRhaZ0FbWmdBnlpnQeJaZ0ElW2dBaFtnQatbZ0HuW2dBMVxnQXRcZ0G3XGdB+1xnQT5dZ0GBXWdBxF1nQQdeZ0FKXmdBjV5nQdBeZ0ETX2dBVl9nQZpfZ0HdX2dBIGBnQWNgZ0GmYGdB6WBnQSxhZ0FvYWdBsmFnQfVhZ0E4YmdBe2JnQb5iZ0EBY2dBRGNnQYhjZ0HLY2dBDmRnQVFkZ0GUZGdB12RnQRplZ0FdZWdBoGVnQeNlZ0EmZmdBaWZnQaxmZ0HvZmdBMmdnQXVnZ0G4Z2dB+2dnQT5oZ0GBaGdBxGhnQQdpZ0FKaWdBjWlnQdBpZ0ETamdBVmpnQZlqZ0HbamdBHmtnQWFrZ0Gka2dB52tnQSpsZ0FtbGdBsGxnQfNsZ0E2bWdBeW1nQbxtZ0H/bWdBQm5nQYVuZ0HIbmdBCm9nQU1vZ0GQb2dB029nQRZwZ0FZcGdBnHBnQd9wZ0EicWdBZXFnQadxZ0HqcWdBLXJnQXByZ0GzcmdB9nJnQTlzZ0F7c2dBvnNnQQF0Z0FEdGdBh3RnQcp0Z0ENdWdBT3VnQZJ1Z0HVdWdBGHZnQVt2Z0GedmdB4HZnQSN3Z0Fmd2dBqXdnQex3Z0EueGdBcXhnQbR4Z0H3eGdBOnlnQXx5Z0G/eWdBAnpnQUV6Z0GIemdBynpnQQ17Z0FQe2dBk3tnQdV7Z0EYfGdBW3xnQZ58Z0HhfGdBI31nQWZ9Z0GpfWdB7H1nQS5+Z0FxfmdBtH5nQfZ+Z0E5f2dBfH9nQb9/Z0EBgGdBRIBnQYeAZ0HKgGdBDIFnQU+BZ0GSgWdB1IFnQReCZ0FagmdBnIJnQd+CZ0Eig2dBZINnQaeDZ0Hqg2dBLIRnQW+EZ0GyhGdB9IRnQTeFZ0F6hWdBvIVnQf+FZ0FChmdBhIZnQceGZ0EKh2dBTIdnQY+HZ0HSh2dBFIhnQVeIZ0GZiGdB3IhnQR+JZ0FhiWdBpIlnQeeJZ0EpimdBbIpnQa6KZ0HximdBNItnQXaLZ0G5i2dB+4tnQT6MZ0GAjGdBw4xnQQaNZ0FIjWdBi41nQc2NZ0EQjmdBUo5nQZWOZ0HYjmdBGo9nQV2PZ0Gfj2dB4o9nQSSQZ0FnkGdBqZBnQeyQZ0EukWdBcZFnQbORZ0H2kWdBOJJnQXuSZ0G9kmdBAJNnQUKTZ0GFk2dBx5NnQQqUZ0FMlGdBj5RnQdGUZ0EUlWdBVpVnQZmVZ0HblWdBHpZnQWCWZ0GjlmdB5ZZnQSiXZ0Fql2dBrZdnQe+XZ0ExmGdBdJhnQbaYZ0H5mGdBO5lnQX6ZZ0HAmWdBA5pnQUWaZ0GHmmdByppnQQybZ0FPm2dBkZtnQdObZ0EWnGdBWJxnQZucZ0HdnGdBH51nQWKdZ0GknWdB551nQSmeZ0FrnmdBrp5nQfCeZ0Eyn2dBdZ9nQbefZ0H6n2dBPKBnQX6gZ0HBoGdBA6FnQUWhZ0GIoWdByqFnQQyiZ0FPomdBkaJnQdOiZ0EWo2dBWKNnQZqjZ0Hdo2dBH6RnQWGkZ0GkpGdB5qRnQSilZ0FqpWdBraVnQe+lZ0ExpmdBdKZnQbamZ0H4pmdBOqdnQX2nZ0G/p2dBAahnQUSoZ0GGqGdByKhnQQqpZ0FNqWdBj6lnQdGpZ0ETqmdBVqpnQZiqZ0HaqmdBHKtnQV+rZ0Ghq2dB46tnQSWsZ0FnrGdBqqxnQeysZ0EurWdBcK1nQbKtZ0H1rWdBN65nQXmuZ0G7rmdB/a5nQUCvZ0GCr2dBxK9nQQawZ0FIsGdBi7BnQc2wZ0EPsWdBUbFnQZOxZ0HVsWdBGLJnQVqyZ0GcsmdB3rJnQSCzZ0Fis2dBpLNnQeezZ0EptGdBa7RnQa20Z0HvtGdBMbVnQXO1Z0G1tWdB+LVnQTq2Z0F8tmdBvrZnQQC3Z0FCt2dBhLdnQca3Z0EIuGdBSrhnQY24Z0HPuGdBEblnQVO5Z0GVuWdB17lnQRm6Z0FbumdBnbpnQd+6Z0Ehu2dBY7tnQaW7Z0Hnu2dBKbxnQWu8Z0GtvGdB8LxnQTK9Z0F0vWdBtr1nQfi9Z0E6vmdBfL5nQb6+Z0EAv2dBQr9nQYS/Z0HGv2dBCMBnQUrAZ0GMwGdBzsBnQRDBZ0FSwWdBlMFnQdbBZ0EYwmdBWsJnQZzCZ0HewmdBIMNnQWHDZ0Gjw2dB5cNnQSfEZ0FpxGdBq8RnQe3EZ0EvxWdBccVnQbPFZ0H1xWdBN8ZnQXnGZ0G7xmdB/cZnQT/HZ0GBx2dBwsdnQQTIZ0FGyGdBiMhnQcrIZ0EMyWdBTslnQZDJZ0HSyWdBFMpnQVXKZ0GXymdB2cpnQRvLZ0Fdy2dBn8tnQeHLZ0EjzGdBZMxnQabMZ0HozGdBKs1nQWzNZ0GuzWdB8M1nQTHOZ0FzzmdBtc5nQffOZ0E5z2dBe89nQbzPZ0H+z2dBQNBnQYLQZ0HE0GdBBdFnQUfRZ0GJ0WdBy9FnQQ3SZ0FO0mdBkNJnQdLSZ0EU02dBVtNnQZfTZ0HZ02dBG9RnQV3UZ0Ge1GdB4NRnQSLVZ0Fk1WdBptVnQefVZ0Ep1mdBa9ZnQa3WZ0Hu1mdBMNdnQXLXZ0G012dB9ddnQTfYZ0F52GdButhnQfzYZ0E+2WdBgNlnQcHZZ0ED2mdBRdpnQYbaZ0HI2mdBCttnQUzbZ0GN22dBz9tnQRHcZ0FS3GdBlNxnQdbcZ0EX3WdBWd1nQZvdZ0Hc3WdBHt5nQWDeZ0Gh3mdB495nQSXfZ0Fm32dBqN9nQerfZ0Er4GdBbeBnQa/gZ0Hw4GdBMuFnQXPhZ0G14WdB9+FnQTjiZ0F64mdBvOJnQf3iZ0E/42dBgONnQcLjZ0EE5GdBReRnQYfkZ0HI5GdBCuVnQUzlZ0GN5WdBz+VnQRDmZ0FS5mdBk+ZnQdXmZ0EX52dBWOdnQZrnZ0Hb52dBHehnQV7oZ0Gg6GdB4ehnQSPpZ0Fl6WdBpulnQejpZ0Ep6mdBa+pnQazqZ0Hu6mdBL+tnQXHrZ0Gy62dB9OtnQTXsZ0F37GdBuOxnQfrsZ0E77WdBfe1nQb7tZ0EA7mdBQe5nQYPuZ0HE7mdBBu9nQUfvZ0GJ72dByu9nQQzwZ0FN8GdBjvBnQdDwZ0ER8WdBU/FnQZTxZ0HW8WdBF/JnQVnyZ0Ga8mdB3PJnQR3zZ0Fe82dBoPNnQeHzZ0Ej9GdBZPRnQaX0Z0Hn9GdBKPVnQWr1Z0Gr9WdB7fVnQS72Z0Fv9mdBsfZnQfL2Z0Ez92dBdfdnQbb3Z0H492dBOfhnQXr4Z0G8+GdB/fhnQT75Z0GA+WdBwflnQQP6Z0FE+mdBhfpnQcf6Z0EI+2dBSftnQYv7Z0HM+2dBDfxnQU/8Z0GQ/GdB0fxnQRP9Z0FU/WdBlf1nQdf9Z0EY/mdBWf5nQZv+Z0Hc/mdBHf9nQV7/Z0Gg/2dB4f9nQSIAaEFkAGhBpQBoQeYAaEEnAWhBaQFoQaoBaEHrAWhBLAJoQW4CaEGvAmhB8AJoQTIDaEFzA2hBtANoQfUDaEE3BGhBeARoQbkEaEH6BGhBOwVoQX0FaEG+BWhB/wVoQUAGaEGCBmhBwwZoQQQHaEFFB2hBhgdoQcgHaEEJCGhBSghoQYsIaEHMCGhBDgloQU8JaEGQCWhB0QloQRIKaEFUCmhBlQpoQdYKaEEXC2hBWAtoQZkLaEHbC2hBHAxoQV0MaEGeDGhB3wxoQSANaEFhDWhBow1oQeQNaEElDmhBZg5oQacOaEHoDmhBKQ9oQWoPaEGsD2hB7Q9oQS4QaEFvEGhBsBBoQfEQaEEyEWhBcxFoQbQRaEH2EWhBNxJoQXgSaEG5EmhB+hJoQTsTaEF8E2hBvRNoQf4TaEE/FGhBgBRoQcEUaEECFWhBQxVoQYUVaEHGFWhBBxZoQUgWaEGJFmhByhZoQQsXaEFMF2hBjRdoQc4XaEEPGGhBUBhoQZEYaEHSGGhBExloQVQZaEGVGWhB1hloQRcaaEFYGmhBmRpoQdoaaEEbG2hBXBtoQZ0baEHeG2hBHxxoQWAcaEGhHGhB4hxoQSMdaEFkHWhBpR1oQeYdaEEnHmhBaB5oQakeaEHqHmhBKh9oQWsfaEGsH2hB7R9oQS4gaEFvIGhBsCBoQfEgaEEyIWhBcyFoQbQhaEH1IWhBNiJoQXciaEG3ImhB+CJoQTkjaEF6I2hBuyNoQfwjaEE9JGhBfiRoQb8kaEH/JGhBQCVoQYElaEHCJWhBAyZoQUQmaEGFJmhBxiZoQQYnaEFHJ2hBiCdoQcknaEEKKGhBSyhoQYwoaEHMKGhBDSloQU4paEGPKWhB0CloQREqaEFRKmhBkipoQdMqaEEUK2hBVStoQZUraEHWK2hBFyxoQVgsaEGZLGhB2SxoQRotaEFbLWhBnC1oQd0taEEdLmhBXi5oQZ8uaEHgLmhBIC9oQWEvaEGiL2hB4y9oQSQwaEFkMGhBpTBoQeYwaEEnMWhBZzFoQagxaEHpMWhBKjJoQWoyaEGrMmhB7DJoQSwzaEFtM2hBrjNoQe8zaEEvNGhBcDRoQbE0aEHxNGhBMjVoQXM1aEG0NWhB9DVoQTU2aEF2NmhBtjZoQfc2aEE4N2hBeDdoQbk3aEH6N2hBOjhoQXs4aEG8OGhB/DhoQT05aEF+OWhBvjloQf85aEFAOmhBgDpoQcE6aEECO2hBQjtoQYM7aEHEO2hBBDxoQUU8aEGFPGhBxjxoQQc9aEFHPWhBiD1oQck9aEEJPmhBSj5oQYo+aEHLPmhBDD9oQUw/aEGNP2hBzT9oQQ5AaEFOQGhBj0BoQdBAaEEQQWhBUUFoQZFBaEHSQWhBEkJoQVNCaEGUQmhB1EJoQRVDaEFVQ2hBlkNoQdZDaEEXRGhBV0RoQZhEaEHZRGhBGUVoQVpFaEGaRWhB20VoQRtGaEFcRmhBnEZoQd1GaEEdR2hBXkdoQZ5HaEHfR2hBH0hoQWBIaEGgSGhB4UhoQSFJaEFiSWhBokloQeNJaEEjSmhBZEpoQaRKaEHlSmhBJUtoQWVLaEGmS2hB5ktoQSdMaEFnTGhBqExoQehMaEEpTWhBaU1oQalNaEHqTWhBKk5oQWtOaEGrTmhB7E5oQSxPaEFsT2hBrU9oQe1PaEEuUGhBblBoQa9QaEHvUGhBL1FoQXBRaEGwUWhB8FFoQTFSaEFxUmhBslJoQfJSaEEyU2hBc1NoQbNTaEH0U2hBNFRoQXRUaEG1VGhB9VRoQTVVaEF2VWhBtlVoQfZVaEE3VmhBd1ZoQbdWaEH4VmhBOFdoQXhXaEG5V2hB+VdoQTlYaEF6WGhBulhoQfpYaEE7WWhBe1loQbtZaEH8WWhBPFpoQXxaaEG8WmhB/VpoQT1baEF9W2hBvltoQf5baEE+XGhBflxoQb9caEH/XGhBP11oQYBdaEHAXWhBAF5oQUBeaEGBXmhBwV5oQQFfaEFBX2hBgl9oQcJfaEECYGhBQmBoQYNgaEHDYGhBA2FoQUNhaEGDYWhBxGFoQQRiaEFEYmhBhGJoQcRiaEEFY2hBRWNoQYVjaEHFY2hBBWRoQUZkaEGGZGhBxmRoQQZlaEFGZWhBh2VoQcdlaEEHZmhBR2ZoQYdmaEHHZmhBCGdoQUhnaEGIZ2hByGdoQQhoaEFIaGhBiWhoQcloaEEJaWhBSWloQYlpaEHJaWhBCWpoQUlqaEGKamhBympoQQpraEFKa2hBimtoQcpraEEKbGhBSmxoQYpsaEHLbGhBC21oQUttaEGLbWhBy21oQQtuaEFLbmhBi25oQctuaEELb2hBS29oQYtvaEHMb2hBDHBoQUxwaEGMcGhBzHBoQQxxaEFMcWhBjHFoQcxxaEEMcmhBTHJoQYxyaEHMcmhBDHNoQUxzaEGMc2hBzHNoQQx0aEFMdGhBjHRoQcx0aEEMdWhBTHVoQYx1aEHMdWhBDHZoQUx2aEGMdmhBzHZoQQx3aEFMd2hBjHdoQcx3aEEMeGhBTHhoQYx4aEHMeGhBDHloQUx5aEGMeWhBzHloQQx6aEFMemhBjHpoQcx6aEEMe2hBTHtoQYx7aEHMe2hBC3xoQUt8aEGLfGhBy3xoQQt9aEFLfWhBi31oQct9aEELfmhBS35oQYt+aEHLfmhBCn9oQUp/aEGKf2hByn9oQQqAaEFKgGhBioBoQcqAaEEKgWhBSYFoQYmBaEHJgWhBCYJoQUmCaEGJgmhByYJoQQmDaEFIg2hBiINoQciDaEEIhGhBSIRoQYiEaEHHhGhBB4VoQUeFaEGHhWhBx4VoQQeGaEFGhmhBhoZoQcaGaEEGh2hBRodoQYaHaEHFh2hBBYhoQUWIaEGFiGhBxYhoQQSJaEFEiWhBhIloQcSJaEEDimhBQ4poQYOKaEHDimhBA4toQUKLaEGCi2hBwotoQQKMaEFBjGhBgYxoQcGMaEEBjWhBQI1oQYCNaEHAjWhBAI5oQT+OaEF/jmhBv45oQf+OaEE+j2hBfo9oQb6PaEH9j2hBPZBoQX2QaEG9kGhB/JBoQTyRaEF8kWhBu5FoQfuRaEE7kmhBe5JoQbqSaEH6kmhBOpNoQXmTaEG5k2hB+ZNoQTiUaEF4lGhBuJRoQfeUaEE3lWhBd5VoQbaVaEH2lWhBNpZoQXWWaEG1lmhB9ZZoQTSXaEF0l2hBs5doQfOXaEEzmGhBcphoQbKYaEHymGhBMZloQXGZaEGwmWhB8JloQTCaaEFvmmhBr5poQe6aaEEum2hBbptoQa2baEHtm2hBLJxoQWycaEGsnGhB65xoQSudaEFqnWhBqp1oQemdaEEpnmhBaZ5oQaieaEHonmhBJ59oQWefaEGmn2hB5p9oQSWgaEFloGhBpaBoQeSgaEEkoWhBY6FoQaOhaEHioWhBIqJoQWGiaEGhomhB4KJoQSCjaEFfo2hBn6NoQd6jaEEepGhBXaRoQZ2kaEHcpGhBHKVoQVulaEGbpWhB2qVoQRqmaEFZpmhBmaZoQdimaEEYp2hBV6doQZenaEHWp2hBFahoQVWoaEGUqGhB1KhoQROpaEFTqWhBkqloQdKpaEERqmhBUKpoQZCqaEHPqmhBD6toQU6raEGOq2hBzatoQQysaEFMrGhBi6xoQcusaEEKrWhBSa1oQYmtaEHIrWhBCK5oQUeuaEGGrmhBxq5oQQWvaEFFr2hBhK9oQcOvaEEDsGhBQrBoQYKwaEHBsGhBALFoQUCxaEF/sWhBvrFoQf6xaEE9smhBfLJoQbyyaEH7smhBOrNoQXqzaEG5s2hB+LNoQTi0aEF3tGhBtrRoQfa0aEE1tWhBdLVoQbS1aEHztWhBMrZoQXK2aEGxtmhB8LZoQS+3aEFvt2hBrrdoQe23aEEtuGhBbLhoQau4aEHquGhBKrloQWm5aEGouWhB6LloQSe6aEFmumhBpbpoQeW6aEEku2hBY7toQaK7aEHiu2hBIbxoQWC8aEGfvGhB37xoQR69aEFdvWhBnL1oQdu9aEEbvmhBWr5oQZm+aEHYvmhBGL9oQVe/aEGWv2hB1b9oQRTAaEFUwGhBk8BoQdLAaEERwWhBUMFoQZDBaEHPwWhBDsJoQU3CaEGMwmhBy8JoQQvDaEFKw2hBicNoQcjDaEEHxGhBRsRoQYbEaEHFxGhBBMVoQUPFaEGCxWhBwcVoQQDGaEFAxmhBf8ZoQb7GaEH9xmhBPMdoQXvHaEG6x2hB+cdoQTnIaEF4yGhBt8hoQfbIaEE1yWhBdMloQbPJaEHyyWhBMcpoQXHKaEGwymhB78poQS7LaEFty2hBrMtoQevLaEEqzGhBacxoQajMaEHnzGhBJs1oQWXNaEGkzWhB5M1oQSPOaEFizmhBoc5oQeDOaEEfz2hBXs9oQZ3PaEHcz2hBG9BoQVrQaEGZ0GhB2NBoQRfRaEFW0WhBldFoQdTRaEET0mhBUtJoQZHSaEHQ0mhBD9NoQU7TaEGN02hBzNNoQQvUaEFK1GhBidRoQcjUaEEH1WhBRtVoQYXVaEHE1WhBA9ZoQULWaEGB1mhBwNZoQf/WaEE+12hBfddoQbzXaEH612hBOdhoQXjYaEG32GhB9thoQTXZaEF02WhBs9loQfLZaEEx2mhBcNpoQa/aaEHu2mhBLdtoQWvbaEGq22hB6dtoQSjcaEFn3GhBptxoQeXcaEEk3WhBY91oQaLdaEHg3WhBH95oQV7eaEGd3mhB3N5oQRvfaEFa32hBmd9oQdffaEEW4GhBVeBoQZTgaEHT4GhBEuFoQVHhaEGP4WhBzuFoQQ3iaEFM4mhBi+JoQcriaEEI42hBR+NoQYbjaEHF42hBBORoQUPkaEGB5GhBwORoQf/kaEE+5WhBfeVoQbvlaEH65WhBOeZoQXjmaEG35mhB9eZoQTTnaEFz52hBsudoQfDnaEEv6GhBbuhoQa3oaEHs6GhBKuloQWnpaEGo6WhB5+loQSXqaEFk6mhBo+poQeLqaEEg62hBX+toQZ7raEHd62hBG+xoQVrsaEGZ7GhB1+xoQRbtaEFV7WhBlO1oQdLtaEER7mhBUO5oQY7uaEHN7mhBDO9oQUvvaEGJ72hByO9oQQfwaEFF8GhBhPBoQcPwaEEB8WhBQPFoQX/xaEG98WhB/PFoQTvyaEF58mhBuPJoQffyaEE182hBdPNoQbPzaEHx82hBMPRoQW/0aEGt9GhB7PRoQSv1aEFp9WhBqPVoQeb1aEEl9mhBZPZoQaL2aEHh9mhBIPdoQV73aEGd92hB2/doQRr4aEFZ+GhBl/hoQdb4aEEU+WhBU/loQZL5aEHQ+WhBD/poQU36aEGM+mhByvpoQQn7aEFI+2hBhvtoQcX7aEED/GhBQvxoQYD8aEG//GhB/vxoQTz9aEF7/WhBuf1oQfj9aEE2/mhBdf5oQbP+aEHy/mhBMP9oQW//aEGt/2hB7P9oQSsAaUFpAGlBqABpQeYAaUElAWlBYwFpQaIBaUHgAWlBHwJpQV0CaUGcAmlB2gJpQRkDaUFXA2lBlgNpQdQDaUETBGlBUQRpQY8EaUHOBGlBDAVpQUsFaUGJBWlByAVpQQYGaUFFBmlBgwZpQcIGaUEAB2lBPwdpQX0HaUG7B2lB+gdpQTgIaUF3CGlBtQhpQfQIaUEyCWlBcAlpQa8JaUHtCWlBLAppQWoKaUGoCmlB5wppQSULaUFkC2lBogtpQeALaUEfDGlBXQxpQZwMaUHaDGlBGA1pQVcNaUGVDWlB1A1pQRIOaUFQDmlBjw5pQc0OaUELD2lBSg9pQYgPaUHGD2lBBRBpQUMQaUGCEGlBwBBpQf4QaUE9EWlBexFpQbkRaUH4EWlBNhJpQXQSaUGzEmlB8RJpQS8TaUFuE2lBrBNpQeoTaUEoFGlBZxRpQaUUaUHjFGlBIhVpQWAVaUGeFWlB3RVpQRsWaUFZFmlBlxZpQdYWaUEUF2lBUhdpQZEXaUHPF2lBDRhpQUsYaUGKGGlByBhpQQYZaUFEGWlBgxlpQcEZaUH/GWlBPRppQXwaaUG6GmlB+BppQTYbaUF1G2lBsxtpQfEbaUEvHGlBbRxpQawcaUHqHGlBKB1pQWYdaUGlHWlB4x1pQSEeaUFfHmlBnR5pQdweaUEaH2lBWB9pQZYfaUHUH2lBEiBpQVEgaUGPIGlBzSBpQQshaUFJIWlBiCFpQcYhaUEEImlBQiJpQYAiaUG+ImlB/CJpQTsjaUF5I2lBtyNpQfUjaUEzJGlBcSRpQa8kaUHuJGlBLCVpQWolaUGoJWlB5iVpQSQmaUFiJmlBoCZpQd8maUEdJ2lBWydpQZknaUHXJ2lBFShpQVMoaUGRKGlBzyhpQQ0paUFMKWlBiilpQcgpaUEGKmlBRCppQYIqaUHAKmlB/ippQTwraUF6K2lBuCtpQfYraUE0LGlBcixpQbAsaUHvLGlBLS1pQWstaUGpLWlB5y1pQSUuaUFjLmlBoS5pQd8uaUEdL2lBWy9pQZkvaUHXL2lBFTBpQVMwaUGRMGlBzzBpQQ0xaUFLMWlBiTFpQccxaUEFMmlBQzJpQYEyaUG/MmlB/TJpQTszaUF5M2lBtzNpQfUzaUEzNGlBcTRpQa80aUHtNGlBKzVpQWk1aUGnNWlB5TVpQSM2aUFgNmlBnjZpQdw2aUEaN2lBWDdpQZY3aUHUN2lBEjhpQVA4aUGOOGlBzDhpQQo5aUFIOWlBhjlpQcM5aUEBOmlBPzppQX06aUG7OmlB+TppQTc7aUF1O2lBsztpQfE7aUEuPGlBbDxpQao8aUHoPGlBJj1pQWQ9aUGiPWlB4D1pQR0+aUFbPmlBmT5pQdc+aUEVP2lBUz9pQZE/aUHPP2lBDEBpQUpAaUGIQGlBxkBpQQRBaUFCQWlBf0FpQb1BaUH7QWlBOUJpQXdCaUG1QmlB8kJpQTBDaUFuQ2lBrENpQepDaUEnRGlBZURpQaNEaUHhRGlBH0VpQVxFaUGaRWlB2EVpQRZGaUFURmlBkUZpQc9GaUENR2lBS0dpQYhHaUHGR2lBBEhpQUJIaUF/SGlBvUhpQftIaUE5SWlBdklpQbRJaUHySWlBMEppQW1KaUGrSmlB6UppQSdLaUFkS2lBoktpQeBLaUEeTGlBW0xpQZlMaUHXTGlBFE1pQVJNaUGQTWlBzk1pQQtOaUFJTmlBh05pQcROaUECT2lBQE9pQX1PaUG7T2lB+U9pQTZQaUF0UGlBslBpQe9QaUEtUWlBa1FpQahRaUHmUWlBJFJpQWFSaUGfUmlB3VJpQRpTaUFYU2lBllNpQdNTaUERVGlBT1RpQYxUaUHKVGlBB1VpQUVVaUGDVWlBwFVpQf5VaUE8VmlBeVZpQbdWaUH0VmlBMldpQXBXaUGtV2lB61dpQShYaUFmWGlBpFhpQeFYaUEfWWlBXFlpQZpZaUHYWWlBFVppQVNaaUGQWmlBzlppQQtbaUFJW2lBh1tpQcRbaUECXGlBP1xpQX1caUG6XGlB+FxpQTVdaUFzXWlBsF1pQe5daUEsXmlBaV5pQadeaUHkXmlBIl9pQV9faUGdX2lB2l9pQRhgaUFVYGlBk2BpQdBgaUEOYWlBS2FpQYlhaUHGYWlBBGJpQUFiaUF/YmlBvGJpQfpiaUE3Y2lBdWNpQbJjaUHwY2lBLWRpQWtkaUGoZGlB5WRpQSNlaUFgZWlBnmVpQdtlaUEZZmlBVmZpQZRmaUHRZmlBD2dpQUxnaUGJZ2lBx2dpQQRoaUFCaGlBf2hpQb1oaUH6aGlBN2lpQXVpaUGyaWlB8GlpQS1qaUFqamlBqGppQeVqaUEja2lBYGtpQZ1raUHba2lBGGxpQVZsaUGTbGlB0GxpQQ5taUFLbWlBiG1pQcZtaUEDbmlBQW5pQX5uaUG7bmlB+W5pQTZvaUFzb2lBsW9pQe5vaUErcGlBaXBpQaZwaUHjcGlBIXFpQV5xaUGbcWlB2XFpQRZyaUFTcmlBkXJpQc5yaUELc2lBSXNpQYZzaUHDc2lBAXRpQT50aUF7dGlBuXRpQfZ0aUEzdWlBcHVpQa51aUHrdWlBKHZpQWZ2aUGjdmlB4HZpQR13aUFbd2lBmHdpQdV3aUESeGlBUHhpQY14aUHKeGlBCHlpQUV5aUGCeWlBv3lpQf15aUE6emlBd3ppQbR6aUHxemlBL3tpQWx7aUGpe2lB5ntpQSR8aUFhfGlBnnxpQdt8aUEYfWlBVn1pQZN9aUHQfWlBDX5pQUp+aUGIfmlBxX5pQQJ/aUE/f2lBfH9pQbp/aUH3f2lBNIBpQXGAaUGugGlB7IBpQSmBaUFmgWlBo4FpQeCBaUEdgmlBW4JpQZiCaUHVgmlBEoNpQU+DaUGMg2lByYNpQQeEaUFEhGlBgYRpQb6EaUH7hGlBOIVpQXWFaUGyhWlB8IVpQS2GaUFqhmlBp4ZpQeSGaUEhh2lBXodpQZuHaUHYh2lBFohpQVOIaUGQiGlBzYhpQQqJaUFHiWlBhIlpQcGJaUH+iWlBO4ppQXiKaUG1imlB84ppQTCLaUFti2lBqotpQeeLaUEkjGlBYYxpQZ6MaUHbjGlBGI1pQVWNaUGSjWlBz41pQQyOaUFJjmlBho5pQcOOaUEAj2lBPY9pQXqPaUG3j2lB9I9pQTGQaUFukGlBq5BpQeiQaUElkWlBYpFpQZ+RaUHckWlBGZJpQVaSaUGTkmlB0JJpQQ2TaUFKk2lBh5NpQcSTaUEBlGlBPpRpQXuUaUG4lGlB9ZRpQTKVaUFvlWlBrJVpQemVaUEmlmlBY5ZpQaCWaUHdlmlBGpdpQVeXaUGUl2lB0ZdpQQ6YaUFLmGlBh5hpQcSYaUEBmWlBPplpQXuZaUG4mWlB9ZlpQTKaaUFvmmlBrJppQemaaUElm2lBYptpQZ+baUHcm2lBGZxpQVacaUGTnGlB0JxpQQ2daUFKnWlBhp1pQcOdaUEAnmlBPZ5pQXqeaUG3nmlB9J5pQTCfaUFtn2lBqp9pQeefaUEkoGlBYaBpQZ6gaUHaoGlBF6FpQVShaUGRoWlBzqFpQQuiaUFHomlBhKJpQcGiaUH+omlBO6NpQXijaUG0o2lB8aNpQS6kaUFrpGlBqKRpQeSkaUEhpWlBXqVpQZulaUHYpWlBFKZpQVGmaUGOpmlBy6ZpQQenaUFEp2lBgadpQb6naUH7p2lBN6hpQXSoaUGxqGlB7qhpQSqpaUFnqWlBpKlpQeGpaUEdqmlBWqppQZeqaUHUqmlBEKtpQU2raUGKq2lBx6tpQQOsaUFArGlBfaxpQbmsaUH2rGlBM61pQXCtaUGsrWlB6a1pQSauaUFirmlBn65pQdyuaUEZr2lBVa9pQZKvaUHPr2lBC7BpQUiwaUGFsGlBwbBpQf6waUE7sWlBd7FpQbSxaUHxsWlBLbJpQWqyaUGnsmlB47JpQSCzaUFds2lBmbNpQdazaUETtGlBT7RpQYy0aUHJtGlBBbVpQUK1aUF+tWlBu7VpQfi1aUE0tmlBcbZpQa62aUHqtmlBJ7dpQWO3aUGgt2lB3bdpQRm4aUFWuGlBkrhpQc+4aUEMuWlBSLlpQYW5aUHBuWlB/rlpQTu6aUF3umlBtLppQfC6aUEtu2lBabtpQaa7aUHju2lBH7xpQVy8aUGYvGlB1bxpQRG9aUFOvWlBir1pQce9aUEEvmlBQL5pQX2+aUG5vmlB9r5pQTK/aUFvv2lBq79pQei/aUEkwGlBYcBpQZ3AaUHawGlBFsFpQVPBaUGPwWlBzMFpQQjCaUFFwmlBgcJpQb7CaUH6wmlBN8NpQXPDaUGww2lB7MNpQSnEaUFlxGlBosRpQd7EaUEbxWlBV8VpQZTFaUHQxWlBDcZpQUnGaUGFxmlBwsZpQf7GaUE7x2lBd8dpQbTHaUHwx2lBLchpQWnIaUGlyGlB4shpQR7JaUFbyWlBl8lpQdTJaUEQymlBTMppQYnKaUHFymlBAstpQT7LaUF7y2lBt8tpQfPLaUEwzGlBbMxpQanMaUHlzGlBIc1pQV7NaUGazWlB1s1pQRPOaUFPzmlBjM5pQcjOaUEEz2lBQc9pQX3PaUG5z2lB9s9pQTLQaUFu0GlBq9BpQefQaUEk0WlBYNFpQZzRaUHZ0WlBFdJpQVHSaUGO0mlBytJpQQbTaUFD02lBf9NpQbvTaUH402lBNNRpQXDUaUGs1GlB6dRpQSXVaUFh1WlBntVpQdrVaUEW1mlBU9ZpQY/WaUHL1mlBB9dpQUTXaUGA12lBvNdpQfnXaUE12GlBcdhpQa3YaUHq2GlBJtlpQWLZaUGe2WlB29lpQRfaaUFT2mlBj9ppQczaaUEI22lBRNtpQYDbaUG922lB+dtpQTXcaUFx3GlBrtxpQercaUEm3WlBYt1pQZ/daUHb3WlBF95pQVPeaUGP3mlBzN5pQQjfaUFE32lBgN9pQbzfaUH532lBNeBpQXHgaUGt4GlB6eBpQSbhaUFi4WlBnuFpQdrhaUEW4mlBUuJpQY/iaUHL4mlBB+NpQUPjaUF/42lBu+NpQfjjaUE05GlBcORpQazkaUHo5GlBJOVpQWDlaUGd5WlB2eVpQRXmaUFR5mlBjeZpQcnmaUEF52lBQudpQX7naUG652lB9udpQTLoaUFu6GlBquhpQeboaUEi6WlBX+lpQZvpaUHX6WlBE+ppQU/qaUGL6mlBx+ppQQPraUE/62lBe+tpQbfraUHz62lBMOxpQWzsaUGo7GlB5OxpQSDtaUFc7WlBmO1pQdTtaUEQ7mlBTO5pQYjuaUHE7mlBAO9pQTzvaUF472lBtO9pQfDvaUEs8GlBaPBpQaTwaUHh8GlBHfFpQVnxaUGV8WlB0fFpQQ3yaUFJ8mlBhfJpQcHyaUH98mlBOfNpQXXzaUGx82lB7fNpQSn0aUFl9GlBofRpQd30aUEZ9WlBVfVpQZD1aUHM9WlBCPZpQUT2aUGA9mlBvPZpQfj2aUE092lBcPdpQaz3aUHo92lBJPhpQWD4aUGc+GlB2PhpQRT5aUFQ+WlBjPlpQcj5aUEE+mlBQPppQXv6aUG3+mlB8/ppQS/7aUFr+2lBp/tpQeP7aUEf/GlBW/xpQZf8aUHT/GlBD/1pQUr9aUGG/WlBwv1pQf79aUE6/mlBdv5pQbL+aUHu/mlBKv9pQWX/aUGh/2lB3f9pQRkAakFVAGpBkQBqQc0AakEIAWpBRAFqQYABakG8AWpB+AFqQTQCakFwAmpBqwJqQecCakEjA2pBXwNqQZsDakHXA2pBEgRqQU4EakGKBGpBxgRqQQIFakE+BWpBeQVqQbUFakHxBWpBLQZqQWkGakGkBmpB4AZqQRwHakFYB2pBlAdqQc8HakELCGpBRwhqQYMIakG/CGpB+ghqQTYJakFyCWpBrglqQekJakElCmpBYQpqQZ0KakHYCmpBFAtqQVALakGMC2pByAtqQQMMakE/DGpBewxqQbcMakHyDGpBLg1qQWoNakGlDWpB4Q1qQR0OakFZDmpBlA5qQdAOakEMD2pBSA9qQYMPakG/D2pB+w9qQTYQakFyEGpBrhBqQekQakElEWpBYRFqQZ0RakHYEWpBFBJqQVASakGLEmpBxxJqQQMTakE+E2pBehNqQbYTakHxE2pBLRRqQWkUakGkFGpB4BRqQRwVakFXFWpBkxVqQc8VakEKFmpBRhZqQYIWakG9FmpB+RZqQTQXakFwF2pBrBdqQecXakEjGGpBXxhqQZoYakHWGGpBERlqQU0ZakGJGWpBxBlqQQAaakE8GmpBdxpqQbMaakHuGmpBKhtqQWYbakGhG2pB3RtqQRgcakFUHGpBjxxqQcscakEHHWpBQh1qQX4dakG5HWpB9R1qQTAeakFsHmpBqB5qQeMeakEfH2pBWh9qQZYfakHRH2pBDSBqQUggakGEIGpBwCBqQfsgakE3IWpBciFqQa4hakHpIWpBJSJqQWAiakGcImpB1yJqQRMjakFOI2pBiiNqQcUjakEBJGpBPCRqQXgkakGzJGpB7yRqQSolakFmJWpBoSVqQd0lakEYJmpBVCZqQY8makHLJmpBBidqQUInakF9J2pBuSdqQfQnakEwKGpBayhqQacoakHiKGpBHSlqQVkpakGUKWpB0ClqQQsqakFHKmpBgipqQb4qakH5KmpBNCtqQXArakGrK2pB5ytqQSIsakFeLGpBmSxqQdQsakEQLWpBSy1qQYctakHCLWpB/i1qQTkuakF0LmpBsC5qQesuakEnL2pBYi9qQZ0vakHZL2pBFDBqQU8wakGLMGpBxjBqQQIxakE9MWpBeDFqQbQxakHvMWpBKjJqQWYyakGhMmpB3TJqQRgzakFTM2pBjzNqQcozakEFNGpBQTRqQXw0akG3NGpB8zRqQS41akFpNWpBpTVqQeA1akEbNmpBVzZqQZI2akHNNmpBCTdqQUQ3akF/N2pBuzdqQfY3akExOGpBbDhqQag4akHjOGpBHjlqQVo5akGVOWpB0DlqQQs6akFHOmpBgjpqQb06akH5OmpBNDtqQW87akGqO2pB5jtqQSE8akFcPGpBlzxqQdM8akEOPWpBST1qQYQ9akHAPWpB+z1qQTY+akFxPmpBrT5qQeg+akEjP2pBXj9qQZo/akHVP2pBEEBqQUtAakGHQGpBwkBqQf1AakE4QWpBc0FqQa9BakHqQWpBJUJqQWBCakGbQmpB10JqQRJDakFNQ2pBiENqQcNDakH/Q2pBOkRqQXVEakGwRGpB60RqQSZFakFiRWpBnUVqQdhFakETRmpBTkZqQYlGakHFRmpBAEdqQTtHakF2R2pBsUdqQexHakEoSGpBY0hqQZ5IakHZSGpBFElqQU9JakGKSWpBxUlqQQFKakE8SmpBd0pqQbJKakHtSmpBKEtqQWNLakGeS2pB2ktqQRVMakFQTGpBi0xqQcZMakEBTWpBPE1qQXdNakGyTWpB7U1qQSlOakFkTmpBn05qQdpOakEVT2pBUE9qQYtPakHGT2pBAVBqQTxQakF3UGpBslBqQe1QakEoUWpBY1FqQZ5RakHaUWpBFVJqQVBSakGLUmpBxlJqQQFTakE8U2pBd1NqQbJTakHtU2pBKFRqQWNUakGeVGpB2VRqQRRVakFPVWpBilVqQcVVakEAVmpBO1ZqQXZWakGxVmpB7FZqQSdXakFiV2pBnVdqQdhXakETWGpBTlhqQYlYakHEWGpB/1hqQTpZakF1WWpBsFlqQetZakEmWmpBYVpqQZxaakHXWmpBEltqQU1bakGHW2pBwltqQf1bakE4XGpBc1xqQa5cakHpXGpBJF1qQV9dakGaXWpB1V1qQRBeakFLXmpBhl5qQcFeakH7XmpBNl9qQXFfakGsX2pB519qQSJgakFdYGpBmGBqQdNgakEOYWpBSWFqQYNhakG+YWpB+WFqQTRiakFvYmpBqmJqQeViakEgY2pBWmNqQZVjakHQY2pBC2RqQUZkakGBZGpBvGRqQfZkakExZWpBbGVqQadlakHiZWpBHWZqQVhmakGSZmpBzWZqQQhnakFDZ2pBfmdqQblnakHzZ2pBLmhqQWloakGkaGpB32hqQRppakFUaWpBj2lqQcppakEFampBQGpqQXpqakG1ampB8GpqQStrakFma2pBoGtqQdtrakEWbGpBUWxqQYtsakHGbGpBAW1qQTxtakF3bWpBsW1qQextakEnbmpBYm5qQZxuakHXbmpBEm9qQU1vakGHb2pBwm9qQf1vakE4cGpBcnBqQa1wakHocGpBI3FqQV1xakGYcWpB03FqQQ5yakFIcmpBg3JqQb5yakH4cmpBM3NqQW5zakGpc2pB43NqQR50akFZdGpBk3RqQc50akEJdWpBRHVqQX51akG5dWpB9HVqQS52akFpdmpBpHZqQd52akEZd2pBVHdqQY53akHJd2pBBHhqQT54akF5eGpBtHhqQe54akEpeWpBZHlqQZ55akHZeWpBFHpqQU56akGJempBxHpqQf56akE5e2pBc3tqQa57akHpe2pBI3xqQV58akGZfGpB03xqQQ59akFIfWpBg31qQb59akH4fWpBM35qQW1+akGofmpB435qQR1/akFYf2pBkn9qQc1/akEIgGpBQoBqQX2AakG3gGpB8oBqQS2BakFngWpBooFqQdyBakEXgmpBUYJqQYyCakHGgmpBAYNqQTyDakF2g2pBsYNqQeuDakEmhGpBYIRqQZuEakHVhGpBEIVqQUuFakGFhWpBwIVqQfqFakE1hmpBb4ZqQaqGakHkhmpBH4dqQVmHakGUh2pBzodqQQmIakFDiGpBfohqQbiIakHziGpBLYlqQWiJakGiiWpB3YlqQReKakFSimpBjIpqQceKakEBi2pBPItqQXaLakGxi2pB64tqQSaMakFgjGpBmoxqQdWMakEPjWpBSo1qQYSNakG/jWpB+Y1qQTSOakFujmpBqY5qQeOOakEdj2pBWI9qQZKPakHNj2pBB5BqQUKQakF8kGpBtpBqQfGQakErkWpBZpFqQaCRakHbkWpBFZJqQU+SakGKkmpBxJJqQf+SakE5k2pBc5NqQa6TakHok2pBIpRqQV2UakGXlGpB0pRqQQyVakFGlWpBgZVqQbuVakH2lWpBMJZqQWqWakGllmpB35ZqQRmXakFUl2pBjpdqQciXakEDmGpBPZhqQXeYakGymGpB7JhqQSaZakFhmWpBm5lqQdWZakEQmmpBSppqQYSaakG/mmpB+ZpqQTObakFum2pBqJtqQeKbakEdnGpBV5xqQZGcakHMnGpBBp1qQUCdakF7nWpBtZ1qQe+dakEpnmpBZJ5qQZ6eakHYnmpBE59qQU2fakGHn2pBwZ9qQfyfakE2oGpBcKBqQaqgakHloGpBH6FqQVmhakGToWpBzqFqQQiiakFCompBfKJqQbeiakHxompBK6NqQWWjakGgo2pB2qNqQRSkakFOpGpBiaRqQcOkakH9pGpBN6VqQXGlakGspWpB5qVqQSCmakFapmpBlaZqQc+makEJp2pBQ6dqQX2nakG4p2pB8qdqQSyoakFmqGpBoKhqQdqoakEVqWpBT6lqQYmpakHDqWpB/alqQTiqakFyqmpBrKpqQeaqakEgq2pBWqtqQZWrakHPq2pBCaxqQUOsakF9rGpBt6xqQfGsakEsrWpBZq1qQaCtakHarWpBFK5qQU6uakGIrmpBw65qQf2uakE3r2pBca9qQauvakHlr2pBH7BqQVmwakGTsGpBzrBqQQixakFCsWpBfLFqQbaxakHwsWpBKrJqQWSyakGesmpB2LJqQROzakFNs2pBh7NqQcGzakH7s2pBNbRqQW+0akGptGpB47RqQR21akFXtWpBkbVqQcu1akEFtmpBP7ZqQXm2akG0tmpB7rZqQSi3akFit2pBnLdqQda3akEQuGpBSrhqQYS4akG+uGpB+LhqQTK5akFsuWpBprlqQeC5akEaumpBVLpqQY66akHIumpBArtqQTy7akF2u2pBsLtqQeq7akEkvGpBXrxqQZi8akHSvGpBDL1qQUa9akGAvWpBur1qQfS9akEuvmpBaL5qQaK+akHcvmpBFr9qQVC/akGKv2pBxL9qQf6/akE4wGpBcsBqQavAakHlwGpBH8FqQVnBakGTwWpBzcFqQQfCakFBwmpBe8JqQbXCakHvwmpBKcNqQWPDakGdw2pB18NqQRDEakFKxGpBhMRqQb7EakH4xGpBMsVqQWzFakGmxWpB4MVqQRrGakFUxmpBjcZqQcfGakEBx2pBO8dqQXXHakGvx2pB6cdqQSPIakFcyGpBlshqQdDIakEKyWpBRMlqQX7JakG4yWpB8slqQSvKakFlympBn8pqQdnKakETy2pBTctqQYfLakHAy2pB+stqQTTMakFuzGpBqMxqQeLMakEbzWpBVc1qQY/NakHJzWpBA85qQTzOakF2zmpBsM5qQerOakEkz2pBXs9qQZfPakHRz2pBC9BqQUXQakF/0GpBuNBqQfLQakEs0WpBZtFqQZ/RakHZ0WpBE9JqQU3SakGH0mpBwNJqQfrSakE002pBbtNqQafTakHh02pBG9RqQVXUakGO1GpByNRqQQLVakE81WpBddVqQa/VakHp1WpBI9ZqQVzWakGW1mpB0NZqQQrXakFD12pBfddqQbfXakHx12pBKthqQWTYakGe2GpB19hqQRHZakFL2WpBhdlqQb7ZakH42WpBMtpqQWvaakGl2mpB39pqQRjbakFS22pBjNtqQcbbakH/22pBOdxqQXPcakGs3GpB5txqQSDdakFZ3WpBk91qQc3dakEG3mpBQN5qQXreakGz3mpB7d5qQSffakFg32pBmt9qQdPfakEN4GpBR+BqQYDgakG64GpB9OBqQS3hakFn4WpBoeFqQdrhakEU4mpBTeJqQYfiakHB4mpB+uJqQTTjakFu42pBp+NqQeHjakEa5GpBVORqQY7kakHH5GpBAeVqQTrlakF05WpBreVqQeflakEh5mpBWuZqQZTmakHN5mpBB+dqQUHnakF652pBtOdqQe3nakEn6GpBYOhqQZroakHU6GpBDelqQUfpakGA6WpBuulqQfPpakEt6mpBZupqQaDqakHZ6mpBE+tqQU3rakGG62pBwOtqQfnrakEz7GpBbOxqQabsakHf7GpBGe1qQVLtakGM7WpBxe1qQf/takE47mpBcu5qQavuakHl7mpBHu9qQVjvakGR72pBy+9qQQTwakE+8GpBd/BqQbHwakHq8GpBJPFqQV3xakGX8WpB0PFqQQryakFD8mpBfPJqQbbyakHv8mpBKfNqQWLzakGc82pB1fNqQQ/0akFI9GpBgvRqQbv0akH09GpBLvVqQWf1akGh9WpB2vVqQRT2akFN9mpBhvZqQcD2akH59mpBM/dqQWz3akGm92pB3/dqQRj4akFS+GpBi/hqQcX4akH++GpBN/lqQXH5akGq+WpB5PlqQR36akFW+mpBkPpqQcn6akEC+2pBPPtqQXX7akGv+2pB6PtqQSH8akFb/GpBlPxqQc38akEH/WpBQP1qQXr9akGz/WpB7P1qQSb+akFf/mpBmP5qQdL+akEL/2pBRP9qQX7/akG3/2pB8P9qQSoAa0FjAGtBnABrQdYAa0EPAWtBSAFrQYIBa0G7AWtB9AFrQS4Ca0FnAmtBoAJrQdkCa0ETA2tBTANrQYUDa0G/A2tB+ANrQTEEa0FrBGtBpARrQd0Ea0EWBWtBUAVrQYkFa0HCBWtB/AVrQTUGa0FuBmtBpwZrQeEGa0EaB2tBUwdrQYwHa0HGB2tB/wdrQTgIa0FxCGtBqwhrQeQIa0EdCWtBVglrQZAJa0HJCWtBAgprQTsKa0F1CmtBrgprQecKa0EgC2tBWQtrQZMLa0HMC2tBBQxrQT4Ma0F4DGtBsQxrQeoMa0EjDWtBXA1rQZYNa0HPDWtBCA5rQUEOa0F6DmtBtA5rQe0Oa0EmD2tBXw9rQZgPa0HRD2tBCxBrQUQQa0F9EGtBthBrQe8Qa0EoEWtBYhFrQZsRa0HUEWtBDRJrQUYSa0F/EmtBuRJrQfISa0ErE2tBZBNrQZ0Ta0HWE2tBDxRrQUkUa0GCFGtBuxRrQfQUa0EtFWtBZhVrQZ8Va0HYFWtBEhZrQUsWa0GEFmtBvRZrQfYWa0EvF2tBaBdrQaEXa0HaF2tBFBhrQU0Ya0GGGGtBvxhrQfgYa0ExGWtBahlrQaMZa0HcGWtBFRprQU4aa0GIGmtBwRprQfoaa0EzG2tBbBtrQaUba0HeG2tBFxxrQVAca0GJHGtBwhxrQfsca0E0HWtBbR1rQaYda0HfHWtBGB5rQVIea0GLHmtBxB5rQf0ea0E2H2tBbx9rQagfa0HhH2tBGiBrQVMga0GMIGtBxSBrQf4ga0E3IWtBcCFrQakha0HiIWtBGyJrQVQia0GNImtBxiJrQf8ia0E4I2tBcSNrQaoja0HjI2tBHCRrQVUka0GOJGtBxyRrQQAla0E5JWtBciVrQasla0HkJWtBHSZrQVYma0GOJmtBxyZrQQAna0E5J2tBcidrQasna0HkJ2tBHShrQVYoa0GPKGtByChrQQEpa0E6KWtBcylrQawpa0HlKWtBHiprQVYqa0GPKmtByCprQQEra0E6K2tBcytrQawra0HlK2tBHixrQVcsa0GQLGtByCxrQQEta0E6LWtBcy1rQawta0HlLWtBHi5rQVcua0GQLmtByC5rQQEva0E6L2tBcy9rQawva0HlL2tBHjBrQVcwa0GPMGtByDBrQQExa0E6MWtBczFrQawxa0HlMWtBHTJrQVYya0GPMmtByDJrQQEza0E6M2tBcjNrQasza0HkM2tBHTRrQVY0a0GPNGtBxzRrQQA1a0E5NWtBcjVrQas1a0HkNWtBHDZrQVU2a0GONmtBxzZrQQA3a0E4N2tBcTdrQao3a0HjN2tBHDhrQVQ4a0GNOGtBxjhrQf84a0E3OWtBcDlrQak5a0HiOWtBGzprQVM6a0GMOmtBxTprQf46a0E2O2tBbztrQag7a0HhO2tBGTxrQVI8a0GLPGtBxDxrQfw8a0E1PWtBbj1rQac9a0HfPWtBGD5rQVE+a0GKPmtBwj5rQfs+a0E0P2tBbD9rQaU/a0HeP2tBF0BrQU9Aa0GIQGtBwUBrQflAa0EyQWtBa0FrQaRBa0HcQWtBFUJrQU5Ca0GGQmtBv0JrQfhCa0EwQ2tBaUNrQaJDa0HaQ2tBE0RrQUxEa0GERGtBvURrQfZEa0EuRWtBZ0VrQaBFa0HYRWtBEUZrQUpGa0GCRmtBu0ZrQfRGa0EsR2tBZUdrQZ5Ha0HWR2tBD0hrQUhIa0GASGtBuUhrQfFIa0EqSWtBY0lrQZtJa0HUSWtBDUprQUVKa0F+SmtBtkprQe9Ka0EoS2tBYEtrQZlLa0HRS2tBCkxrQUNMa0F7TGtBtExrQexMa0ElTWtBXk1rQZZNa0HPTWtBB05rQUBOa0F5TmtBsU5rQepOa0EiT2tBW09rQZNPa0HMT2tBBFBrQT1Qa0F2UGtBrlBrQedQa0EfUWtBWFFrQZBRa0HJUWtBAVJrQTpSa0FzUmtBq1JrQeRSa0EcU2tBVVNrQY1Ta0HGU2tB/lNrQTdUa0FvVGtBqFRrQeBUa0EZVWtBUVVrQYpVa0HCVWtB+1VrQTNWa0FsVmtBpFZrQd1Wa0EVV2tBTldrQYZXa0G/V2tB91drQTBYa0FoWGtBoVhrQdlYa0ESWWtBSllrQYNZa0G7WWtB9FlrQSxaa0FlWmtBnVprQdVaa0EOW2tBRltrQX9ba0G3W2tB8FtrQShca0FhXGtBmVxrQdFca0EKXWtBQl1rQXtda0GzXWtB7F1rQSRea0FcXmtBlV5rQc1ea0EGX2tBPl9rQXdfa0GvX2tB519rQSBga0FYYGtBkWBrQclga0EBYWtBOmFrQXJha0GrYWtB42FrQRtia0FUYmtBjGJrQcVia0H9YmtBNWNrQW5ja0GmY2tB3mNrQRdka0FPZGtBiGRrQcBka0H4ZGtBMWVrQWlla0GhZWtB2mVrQRJma0FKZmtBg2ZrQbtma0HzZmtBLGdrQWRna0GcZ2tB1WdrQQ1oa0FFaGtBfmhrQbZoa0HuaGtBJ2lrQV9pa0GXaWtB0GlrQQhqa0FAamtBeWprQbFqa0HpamtBImtrQVpra0GSa2tBymtrQQNsa0E7bGtBc2xrQaxsa0HkbGtBHG1rQVRta0GNbWtBxW1rQf1ta0E2bmtBbm5rQaZua0HebmtBF29rQU9va0GHb2tBv29rQfhva0EwcGtBaHBrQaBwa0HZcGtBEXFrQUlxa0GBcWtBunFrQfJxa0EqcmtBYnJrQZtya0HTcmtBC3NrQUNza0F7c2tBtHNrQexza0EkdGtBXHRrQZV0a0HNdGtBBXVrQT11a0F1dWtBrnVrQeZ1a0EedmtBVnZrQY52a0HHdmtB/3ZrQTd3a0Fvd2tBp3drQeB3a0EYeGtBUHhrQYh4a0HAeGtB+HhrQTF5a0FpeWtBoXlrQdl5a0ERemtBSXprQYJ6a0G6emtB8nprQSp7a0Fie2tBmntrQdJ7a0ELfGtBQ3xrQXt8a0GzfGtB63xrQSN9a0FbfWtBk31rQcx9a0EEfmtBPH5rQXR+a0GsfmtB5H5rQRx/a0FUf2tBjX9rQcV/a0H9f2tBNYBrQW2Aa0GlgGtB3YBrQRWBa0FNgWtBhYFrQb6Ba0H2gWtBLoJrQWaCa0GegmtB1oJrQQ6Da0FGg2tBfoNrQbaDa0Hug2tBJoRrQV6Ea0GWhGtBz4RrQQeFa0E/hWtBd4VrQa+Fa0HnhWtBH4ZrQVeGa0GPhmtBx4ZrQf+Ga0E3h2tBb4drQaeHa0Hfh2tBF4hrQU+Ia0GHiGtBv4hrQfeIa0EviWtBZ4lrQZ+Ja0HXiWtBD4prQUeKa0F/imtBt4prQe+Ka0Eni2tBX4trQZeLa0HPi2tBB4xrQT+Ma0F3jGtBr4xrQeeMa0EfjWtBV41rQY+Na0HHjWtB/41rQTeOa0FvjmtBp45rQd+Oa0EXj2tBT49rQYePa0G/j2tB949rQS+Qa0FnkGtBn5BrQdeQa0EPkWtBRpFrQX6Ra0G2kWtB7pFrQSaSa0FekmtBlpJrQc6Sa0EGk2tBPpNrQXaTa0Guk2tB5pNrQR2Ua0FVlGtBjZRrQcWUa0H9lGtBNZVrQW2Va0GllWtB3ZVrQRWWa0FNlmtBhJZrQbyWa0H0lmtBLJdrQWSXa0Gcl2tB1JdrQQyYa0FDmGtBe5hrQbOYa0HrmGtBI5lrQVuZa0GTmWtBy5lrQQKaa0E6mmtBcpprQaqaa0HimmtBGptrQVGba0GJm2tBwZtrQfmba0ExnGtBaZxrQaGca0HYnGtBEJ1rQUida0GAnWtBuJ1rQe+da0EnnmtBX55rQZeea0HPnmtBB59rQT6fa0F2n2tBrp9rQeafa0EeoGtBVaBrQY2ga0HFoGtB/aBrQTWha0FsoWtBpKFrQdyha0EUomtBS6JrQYOia0G7omtB86JrQSuja0Fio2tBmqNrQdKja0EKpGtBQaRrQXmka0GxpGtB6aRrQSCla0FYpWtBkKVrQcila0H/pWtBN6ZrQW+ma0GnpmtB3qZrQRana0FOp2tBhqdrQb2na0H1p2tBLahrQWSoa0GcqGtB1KhrQQypa0FDqWtBe6lrQbOpa0HqqWtBIqprQVqqa0GSqmtByaprQQGra0E5q2tBcKtrQaira0Hgq2tBF6xrQU+sa0GHrGtBvqxrQfasa0EurWtBZq1rQZ2ta0HVrWtBDa5rQUSua0F8rmtBtK5rQeuua0Ejr2tBWq9rQZKva0HKr2tBAbBrQTmwa0FxsGtBqLBrQeCwa0EYsWtBT7FrQYexa0G/sWtB9rFrQS6ya0FlsmtBnbJrQdWya0EMs2tBRLNrQXyza0Gzs2tB67NrQSK0a0FatGtBkrRrQcm0a0EBtWtBOLVrQXC1a0GotWtB37VrQRe2a0FOtmtBhrZrQb62a0H1tmtBLbdrQWS3a0Gct2tB1LdrQQu4a0FDuGtBerhrQbK4a0HpuGtBIblrQVi5a0GQuWtByLlrQf+5a0E3umtBbrprQaa6a0HdumtBFbtrQUy7a0GEu2tBvLtrQfO7a0ErvGtBYrxrQZq8a0HRvGtBCb1rQUC9a0F4vWtBr71rQee9a0EevmtBVr5rQY2+a0HFvmtB/L5rQTS/a0Frv2tBo79rQdq/a0ESwGtBScBrQYHAa0G4wGtB8MBrQSfBa0FfwWtBlsFrQc7Ba0EFwmtBPcJrQXTCa0GswmtB48JrQRvDa0FSw2tBisNrQcHDa0H5w2tBMMRrQWfEa0GfxGtB1sRrQQ7Fa0FFxWtBfcVrQbTFa0HsxWtBI8ZrQVvGa0GSxmtBycZrQQHHa0E4x2tBcMdrQafHa0Hfx2tBFshrQU3Ia0GFyGtBvMhrQfTIa0EryWtBYslrQZrJa0HRyWtBCcprQUDKa0F4ymtBr8prQebKa0Eey2tBVctrQYzLa0HEy2tB+8trQTPMa0FqzGtBocxrQdnMa0EQzWtBSM1rQX/Na0G2zWtB7s1rQSXOa0FczmtBlM5rQcvOa0ECz2tBOs9rQXHPa0Gpz2tB4M9rQRfQa0FP0GtBhtBrQb3Qa0H10GtBLNFrQWPRa0Gb0WtB0tFrQQnSa0FB0mtBeNJrQa/Sa0Hn0mtBHtNrQVXTa0GN02tBxNNrQfvTa0Ey1GtBatRrQaHUa0HY1GtBENVrQUfVa0F+1WtBttVrQe3Va0Ek1mtBW9ZrQZPWa0HK1mtBAddrQTnXa0Fw12tBp9drQd7Xa0EW2GtBTdhrQYTYa0G82GtB89hrQSrZa0Fh2WtBmdlrQdDZa0EH2mtBPtprQXbaa0Gt2mtB5NprQRvba0FT22tBittrQcHba0H422tBMNxrQWfca0Ge3GtB1dxrQQzda0FE3WtBe91rQbLda0Hp3WtBId5rQVjea0GP3mtBxt5rQf3ea0E132tBbN9rQaPfa0Ha32tBEeBrQUnga0GA4GtBt+BrQe7ga0El4WtBXeFrQZTha0HL4WtBAuJrQTnia0Fx4mtBqOJrQd/ia0EW42tBTeNrQYTja0G842tB8+NrQSrka0Fh5GtBmORrQc/ka0EH5WtBPuVrQXXla0Gs5WtB4+VrQRrma0FR5mtBieZrQcDma0H35mtBLudrQWXna0Gc52tB0+drQQroa0FC6GtBeehrQbDoa0Hn6GtBHulrQVXpa0GM6WtBw+lrQfrpa0Ey6mtBaeprQaDqa0HX6mtBDutrQUXra0F862tBs+trQerra0Eh7GtBWexrQZDsa0HH7GtB/uxrQTXta0Fs7WtBo+1rQdrta0ER7mtBSO5rQX/ua0G27mtB7e5rQSTva0Fc72tBk+9rQcrva0EB8GtBOPBrQW/wa0Gm8GtB3fBrQRTxa0FL8WtBgvFrQbnxa0Hw8WtBJ/JrQV7ya0GV8mtBzPJrQQPza0E682tBcfNrQajza0Hf82tBFvRrQU30a0GE9GtBu/RrQfL0a0Ep9WtBYPVrQZf1a0HO9WtBBfZrQTz2a0Fz9mtBqvZrQeH2a0EY92tBT/drQYb3a0G992tB9PdrQSv4a0Fi+GtBmfhrQdD4a0EH+WtBPvlrQXX5a0Gs+WtB4/lrQRr6a0FR+mtBiPprQb/6a0H2+mtBLftrQWT7a0Ga+2tB0ftrQQj8a0E//GtBdvxrQa38a0Hk/GtBG/1rQVL9a0GJ/WtBwP1rQff9a0Eu/mtBZf5rQZv+a0HS/mtBCf9rQUD/a0F3/2tBrv9rQeX/a0EcAGxBUwBsQYoAbEHAAGxB9wBsQS4BbEFlAWxBnAFsQdMBbEEKAmxBQQJsQXgCbEGuAmxB5QJsQRwDbEFTA2xBigNsQcEDbEH4A2xBLwRsQWUEbEGcBGxB0wRsQQoFbEFBBWxBeAVsQa8FbEHlBWxBHAZsQVMGbEGKBmxBwQZsQfgGbEEuB2xBZQdsQZwHbEHTB2xBCghsQUEIbEF3CGxBrghsQeUIbEEcCWxBUwlsQYkJbEHACWxB9wlsQS4KbEFlCmxBnApsQdIKbEEJC2xBQAtsQXcLbEGuC2xB5AtsQRsMbEFSDGxBiQxsQb8MbEH2DGxBLQ1sQWQNbEGbDWxB0Q1sQQgObEE/DmxBdg5sQawObEHjDmxBGg9sQVEPbEGHD2xBvg9sQfUPbEEsEGxBYhBsQZkQbEHQEGxBBxFsQT0RbEF0EWxBqxFsQeIRbEEYEmxBTxJsQYYSbEG9EmxB8xJsQSoTbEFhE2xBlxNsQc4TbEEFFGxBPBRsQXIUbEGpFGxB4BRsQRYVbEFNFWxBhBVsQbsVbEHxFWxBKBZsQV8WbEGVFmxBzBZsQQMXbEE5F2xBcBdsQacXbEHdF2xBFBhsQUsYbEGCGGxBuBhsQe8YbEEmGWxBXBlsQZMZbEHKGWxBABpsQTcabEFtGmxBpBpsQdsabEERG2xBSBtsQX8bbEG1G2xB7BtsQSMcbEFZHGxBkBxsQcccbEH9HGxBNB1sQWodbEGhHWxB2B1sQQ4ebEFFHmxBfB5sQbIebEHpHmxBHx9sQVYfbEGNH2xBwx9sQfofbEEwIGxBZyBsQZ4gbEHUIGxBCyFsQUEhbEF4IWxBryFsQeUhbEEcImxBUiJsQYkibEHAImxB9iJsQS0jbEFjI2xBmiNsQdAjbEEHJGxBPiRsQXQkbEGrJGxB4SRsQRglbEFOJWxBhSVsQbwlbEHyJWxBKSZsQV8mbEGWJmxBzCZsQQMnbEE5J2xBcCdsQaYnbEHdJ2xBEyhsQUoobEGBKGxBtyhsQe4obEEkKWxBWylsQZEpbEHIKWxB/ilsQTUqbEFrKmxBoipsQdgqbEEPK2xBRStsQXwrbEGyK2xB6StsQR8sbEFWLGxBjCxsQcMsbEH5LGxBMC1sQWYtbEGdLWxB0y1sQQoubEFALmxBdi5sQa0ubEHjLmxBGi9sQVAvbEGHL2xBvS9sQfQvbEEqMGxBYTBsQZcwbEHOMGxBBDFsQToxbEFxMWxBpzFsQd4xbEEUMmxBSzJsQYEybEG4MmxB7jJsQSQzbEFbM2xBkTNsQcgzbEH+M2xBNDRsQWs0bEGhNGxB2DRsQQ41bEFFNWxBezVsQbE1bEHoNWxBHjZsQVU2bEGLNmxBwTZsQfg2bEEuN2xBZTdsQZs3bEHRN2xBCDhsQT44bEF0OGxBqzhsQeE4bEEYOWxBTjlsQYQ5bEG7OWxB8TlsQSc6bEFeOmxBlDpsQcs6bEEBO2xBNztsQW47bEGkO2xB2jtsQRE8bEFHPGxBfTxsQbQ8bEHqPGxBID1sQVc9bEGNPWxBwz1sQfo9bEEwPmxBZj5sQZ0+bEHTPmxBCT9sQUA/bEF2P2xBrD9sQeM/bEEZQGxBT0BsQYVAbEG8QGxB8kBsQShBbEFfQWxBlUFsQctBbEECQmxBOEJsQW5CbEGkQmxB20JsQRFDbEFHQ2xBfkNsQbRDbEHqQ2xBIERsQVdEbEGNRGxBw0RsQflEbEEwRWxBZkVsQZxFbEHSRWxBCUZsQT9GbEF1RmxBq0ZsQeJGbEEYR2xBTkdsQYRHbEG7R2xB8UdsQSdIbEFdSGxBlEhsQcpIbEEASWxBNklsQW1JbEGjSWxB2UlsQQ9KbEFFSmxBfEpsQbJKbEHoSmxBHktsQVRLbEGLS2xBwUtsQfdLbEEtTGxBY0xsQZpMbEHQTGxBBk1sQTxNbEFyTWxBqU1sQd9NbEEVTmxBS05sQYFObEG4TmxB7k5sQSRPbEFaT2xBkE9sQcZPbEH9T2xBM1BsQWlQbEGfUGxB1VBsQQtRbEFBUWxBeFFsQa5RbEHkUWxBGlJsQVBSbEGGUmxBvFJsQfNSbEEpU2xBX1NsQZVTbEHLU2xBAVRsQTdUbEFuVGxBpFRsQdpUbEEQVWxBRlVsQXxVbEGyVWxB6FVsQR5WbEFVVmxBi1ZsQcFWbEH3VmxBLVdsQWNXbEGZV2xBz1dsQQVYbEE7WGxBclhsQahYbEHeWGxBFFlsQUpZbEGAWWxBtllsQexZbEEiWmxBWFpsQY5abEHEWmxB+lpsQTBbbEFnW2xBnVtsQdNbbEEJXGxBP1xsQXVcbEGrXGxB4VxsQRddbEFNXWxBg11sQbldbEHvXWxBJV5sQVtebEGRXmxBx15sQf1ebEEzX2xBaV9sQZ9fbEHVX2xBC2BsQUFgbEF3YGxBrWBsQeNgbEEZYWxBT2FsQYVhbEG7YWxB8WFsQSdibEFdYmxBk2JsQclibEH/YmxBNWNsQWtjbEGhY2xB12NsQQ1kbEFDZGxBeWRsQa9kbEHlZGxBG2VsQVFlbEGHZWxBvWVsQfNlbEEpZmxBX2ZsQZVmbEHLZmxBAWdsQTdnbEFtZ2xBo2dsQdlnbEEPaGxBRWhsQXpobEGwaGxB5mhsQRxpbEFSaWxBiGlsQb5pbEH0aWxBKmpsQWBqbEGWamxBzGpsQQJrbEE3a2xBbWtsQaNrbEHZa2xBD2xsQUVsbEF7bGxBsWxsQedsbEEdbWxBU21sQYhtbEG+bWxB9G1sQSpubEFgbmxBlm5sQcxubEECb2xBOG9sQW1vbEGjb2xB2W9sQQ9wbEFFcGxBe3BsQbFwbEHmcGxBHHFsQVJxbEGIcWxBvnFsQfRxbEEqcmxBX3JsQZVybEHLcmxBAXNsQTdzbEFtc2xBo3NsQdhzbEEOdGxBRHRsQXp0bEGwdGxB5nRsQRt1bEFRdWxBh3VsQb11bEHzdWxBKHZsQV52bEGUdmxBynZsQQB3bEE1d2xBa3dsQaF3bEHXd2xBDXhsQUJ4bEF4eGxBrnhsQeR4bEEaeWxBT3lsQYV5bEG7eWxB8XlsQSd6bEFcemxBknpsQch6bEH+emxBM3tsQWl7bEGfe2xB1XtsQQp8bEFAfGxBdnxsQax8bEHifGxBF31sQU19bEGDfWxBuX1sQe59bEEkfmxBWn5sQY9+bEHFfmxB+35sQTF/bEFmf2xBnH9sQdJ/bEEIgGxBPYBsQXOAbEGpgGxB3oBsQRSBbEFKgWxBgIFsQbWBbEHrgWxBIYJsQVaCbEGMgmxBwoJsQfiCbEEtg2xBY4NsQZmDbEHOg2xBBIRsQTqEbEFvhGxBpYRsQduEbEEQhWxBRoVsQXyFbEGxhWxB54VsQR2GbEFShmxBiIZsQb6GbEHzhmxBKYdsQV+HbEGUh2xByodsQQCIbEE1iGxBa4hsQaGIbEHWiGxBDIlsQUKJbEF3iWxBrYlsQeOJbEEYimxBTopsQYOKbEG5imxB74psQSSLbEFai2xBkItsQcWLbEH7i2xBMIxsQWaMbEGcjGxB0YxsQQeNbEE8jWxBco1sQaiNbEHdjWxBE45sQUiObEF+jmxBtI5sQemObEEfj2xBVI9sQYqPbEHAj2xB9Y9sQSuQbEFgkGxBlpBsQcuQbEEBkWxBN5FsQWyRbEGikWxB15FsQQ2SbEFCkmxBeJJsQa6SbEHjkmxBGZNsQU6TbEGEk2xBuZNsQe+TbEEklGxBWpRsQY+UbEHFlGxB+5RsQTCVbEFmlWxBm5VsQdGVbEEGlmxBPJZsQXGWbEGnlmxB3JZsQRKXbEFHl2xBfZdsQbKXbEHol2xBHZhsQVOYbEGImGxBvphsQfOYbEEpmWxBXplsQZSZbEHJmWxB/5lsQTSabEFqmmxBn5psQdWabEEKm2xBQJtsQXWbbEGrm2xB4JtsQRacbEFLnGxBgZxsQbacbEHrnGxBIZ1sQVadbEGMnWxBwZ1sQfedbEEsnmxBYp5sQZeebEHNnmxBAp9sQTefbEFtn2xBop9sQdifbEENoGxBQ6BsQXigbEGtoGxB46BsQRihbEFOoWxBg6FsQbmhbEHuoWxBI6JsQVmibEGOomxBxKJsQfmibEEvo2xBZKNsQZmjbEHPo2xBBKRsQTqkbEFvpGxBpKRsQdqkbEEPpWxBRKVsQXqlbEGvpWxB5aVsQRqmbEFPpmxBhaZsQbqmbEHwpmxBJadsQVqnbEGQp2xBxadsQfqnbEEwqGxBZahsQZqobEHQqGxBBalsQTqpbEFwqWxBpalsQdupbEEQqmxBRapsQXuqbEGwqmxB5apsQRurbEFQq2xBhatsQburbEHwq2xBJaxsQVusbEGQrGxBxaxsQfqsbEEwrWxBZa1sQZqtbEHQrWxBBa5sQTqubEFwrmxBpa5sQdqubEEQr2xBRa9sQXqvbEGvr2xB5a9sQRqwbEFPsGxBhbBsQbqwbEHvsGxBJLFsQVqxbEGPsWxBxLFsQfqxbEEvsmxBZLJsQZmybEHPsmxBBLNsQTmzbEFus2xBpLNsQdmzbEEOtGxBQ7RsQXm0bEGutGxB47RsQRi1bEFOtWxBg7VsQbi1bEHttWxBI7ZsQVi2bEGNtmxBwrZsQfi2bEEtt2xBYrdsQZe3bEHMt2xBArhsQTe4bEFsuGxBobhsQde4bEEMuWxBQblsQXa5bEGruWxB4blsQRa6bEFLumxBgLpsQbW6bEHrumxBILtsQVW7bEGKu2xBv7tsQfS7bEEqvGxBX7xsQZS8bEHJvGxB/rxsQTS9bEFpvWxBnr1sQdO9bEEIvmxBPb5sQXO+bEGovmxB3b5sQRK/bEFHv2xBfL9sQbG/bEHnv2xBHMBsQVHAbEGGwGxBu8BsQfDAbEElwWxBW8FsQZDBbEHFwWxB+sFsQS/CbEFkwmxBmcJsQc7CbEEEw2xBOcNsQW7DbEGjw2xB2MNsQQ3EbEFCxGxBd8RsQa3EbEHixGxBF8VsQUzFbEGBxWxBtsVsQevFbEEgxmxBVcZsQYrGbEG/xmxB9cZsQSrHbEFfx2xBlMdsQcnHbEH+x2xBM8hsQWjIbEGdyGxB0shsQQfJbEE8yWxBcclsQabJbEHcyWxBEcpsQUbKbEF7ymxBsMpsQeXKbEEay2xBT8tsQYTLbEG5y2xB7stsQSPMbEFYzGxBjcxsQcLMbEH3zGxBLM1sQWHNbEGWzWxBy81sQQDObEE1zmxBas5sQZ/ObEHUzmxBCc9sQT7PbEFzz2xBqM9sQd3PbEES0GxBR9BsQXzQbEGx0GxB5tBsQRvRbEFQ0WxBhdFsQbrRbEHv0WxBJNJsQVnSbEGO0mxBw9JsQfjSbEEt02xBYtNsQZfTbEHM02xBAdRsQTbUbEFr1GxBoNRsQdXUbEEK1WxBP9VsQXTVbEGp1WxB3tVsQRPWbEFI1mxBfdZsQbLWbEHm1mxBG9dsQVDXbEGF12xButdsQe/XbEEk2GxBWdhsQY7YbEHD2GxB+NhsQS3ZbEFi2WxBl9lsQcvZbEEA2mxBNdpsQWrabEGf2mxB1NpsQQnbbEE+22xBc9tsQajbbEHc22xBEdxsQUbcbEF73GxBsNxsQeXcbEEa3WxBT91sQYTdbEG43WxB7d1sQSLebEFX3mxBjN5sQcHebEH23mxBK99sQV/fbEGU32xByd9sQf7fbEEz4GxBaOBsQZ3gbEHR4GxBBuFsQTvhbEFw4WxBpeFsQdrhbEEP4mxBQ+JsQXjibEGt4mxB4uJsQRfjbEFM42xBgONsQbXjbEHq42xBH+RsQVTkbEGJ5GxBveRsQfLkbEEn5WxBXOVsQZHlbEHF5WxB+uVsQS/mbEFk5mxBmeZsQc3mbEEC52xBN+dsQWznbEGh52xB1edsQQrobEE/6GxBdOhsQanobEHd6GxBEulsQUfpbEF86WxBsOlsQeXpbEEa6mxBT+psQYPqbEG46mxB7epsQSLrbEFX62xBi+tsQcDrbEH162xBKuxsQV7sbEGT7GxByOxsQf3sbEEx7WxBZu1sQZvtbEHP7WxBBO5sQTnubEFu7mxBou5sQdfubEEM72xBQe9sQXXvbEGq72xB3+9sQRPwbEFI8GxBffBsQbLwbEHm8GxBG/FsQVDxbEGE8WxBufFsQe7xbEEj8mxBV/JsQYzybEHB8mxB9fJsQSrzbEFf82xBk/NsQcjzbEH982xBMfRsQWb0bEGb9GxBz/RsQQT1bEE59WxBbfVsQaL1bEHX9WxBC/ZsQUD2bEF19mxBqfZsQd72bEET92xBR/dsQXz3bEGx92xB5fdsQRr4bEFP+GxBg/hsQbj4bEHt+GxBIflsQVb5bEGK+WxBv/lsQfT5bEEo+mxBXfpsQZL6bEHG+mxB+/psQS/7bEFk+2xBmftsQc37bEEC/GxBNvxsQWv8bEGg/GxB1PxsQQn9bEE9/WxBcv1sQaf9bEHb/WxBEP5sQUT+bEF5/mxBrv5sQeL+bEEX/2xBS/9sQYD/bEG1/2xB6f9sQR4AbUFSAG1BhwBtQbsAbUHwAG1BJQFtQVkBbUGOAW1BwgFtQfcBbUErAm1BYAJtQZQCbUHJAm1B/gJtQTIDbUFnA21BmwNtQdADbUEEBG1BOQRtQW0EbUGiBG1B1gRtQQsFbUE/BW1BdAVtQagFbUHdBW1BEgZtQUYGbUF7Bm1BrwZtQeQGbUEYB21BTQdtQYEHbUG2B21B6gdtQR8IbUFTCG1BiAhtQbwIbUHxCG1BJQltQVoJbUGOCW1BwwltQfcJbUEsCm1BYAptQZUKbUHJCm1B/QptQTILbUFmC21BmwttQc8LbUEEDG1BOAxtQW0MbUGhDG1B1gxtQQoNbUE/DW1Bcw1tQacNbUHcDW1BEA5tQUUObUF5Dm1Brg5tQeIObUEXD21BSw9tQX8PbUG0D21B6A9tQR0QbUFREG1BhhBtQboQbUHvEG1BIxFtQVcRbUGMEW1BwBFtQfURbUEpEm1BXRJtQZISbUHGEm1B+xJtQS8TbUFjE21BmBNtQcwTbUEBFG1BNRRtQWkUbUGeFG1B0hRtQQcVbUE7FW1BbxVtQaQVbUHYFW1BDRZtQUEWbUF1Fm1BqhZtQd4WbUESF21BRxdtQXsXbUGvF21B5BdtQRgYbUFNGG1BgRhtQbUYbUHqGG1BHhltQVIZbUGHGW1BuxltQe8ZbUEkGm1BWBptQYwabUHBGm1B9RptQSkbbUFeG21BkhttQcYbbUH7G21BLxxtQWMcbUGYHG1BzBxtQQAdbUE1HW1BaR1tQZ0dbUHSHW1BBh5tQToebUFuHm1Box5tQdcebUELH21BQB9tQXQfbUGoH21B3R9tQREgbUFFIG1BeSBtQa4gbUHiIG1BFiFtQUshbUF/IW1BsyFtQechbUEcIm1BUCJtQYQibUG4Im1B7SJtQSEjbUFVI21BiiNtQb4jbUHyI21BJiRtQVskbUGPJG1BwyRtQfckbUEsJW1BYCVtQZQlbUHIJW1B/CVtQTEmbUFlJm1BmSZtQc0mbUECJ21BNidtQWonbUGeJ21B0ydtQQcobUE7KG1BbyhtQaMobUHYKG1BDCltQUApbUF0KW1BqCltQd0pbUERKm1BRSptQXkqbUGtKm1B4iptQRYrbUFKK21BfittQbIrbUHnK21BGyxtQU8sbUGDLG1BtyxtQessbUEgLW1BVC1tQYgtbUG8LW1B8C1tQSUubUFZLm1BjS5tQcEubUH1Lm1BKS9tQV0vbUGSL21Bxi9tQfovbUEuMG1BYjBtQZYwbUHKMG1B/zBtQTMxbUFnMW1BmzFtQc8xbUEDMm1BNzJtQWwybUGgMm1B1DJtQQgzbUE8M21BcDNtQaQzbUHYM21BDTRtQUE0bUF1NG1BqTRtQd00bUERNW1BRTVtQXk1bUGtNW1B4TVtQRY2bUFKNm1BfjZtQbI2bUHmNm1BGjdtQU43bUGCN21BtjdtQeo3bUEeOG1BUjhtQYc4bUG7OG1B7zhtQSM5bUFXOW1BizltQb85bUHzOW1BJzptQVs6bUGPOm1BwzptQfc6bUErO21BXzttQZM7bUHIO21B/DttQTA8bUFkPG1BmDxtQcw8bUEAPW1BND1tQWg9bUGcPW1B0D1tQQQ+bUE4Pm1BbD5tQaA+bUHUPm1BCD9tQTw/bUFwP21BpD9tQdg/bUEMQG1BQEBtQXRAbUGoQG1B3EBtQRBBbUFEQW1BeEFtQaxBbUHgQW1BFEJtQUhCbUF8Qm1BsEJtQeRCbUEYQ21BTENtQYBDbUG0Q21B6ENtQRxEbUFQRG1BhERtQbhEbUHsRG1BIEVtQVRFbUGIRW1BvEVtQe9FbUEjRm1BV0ZtQYtGbUG/Rm1B80ZtQSdHbUFbR21Bj0dtQcNHbUH3R21BK0htQV9IbUGTSG1Bx0htQftIbUEvSW1BYkltQZZJbUHKSW1B/kltQTJKbUFmSm1BmkptQc5KbUECS21BNkttQWpLbUGeS21B0UttQQVMbUE5TG1BbUxtQaFMbUHVTG1BCU1tQT1NbUFxTW1BpE1tQdhNbUEMTm1BQE5tQXRObUGoTm1B3E5tQRBPbUFET21Bd09tQatPbUHfT21BE1BtQUdQbUF7UG1Br1BtQeJQbUEWUW1BSlFtQX5RbUGyUW1B5lFtQRpSbUFNUm1BgVJtQbVSbUHpUm1BHVNtQVFTbUGEU21BuFNtQexTbUEgVG1BVFRtQYhUbUG7VG1B71RtQSNVbUFXVW1Bi1VtQb9VbUHyVW1BJlZtQVpWbUGOVm1BwlZtQfVWbUEpV21BXVdtQZFXbUHFV21B+FdtQSxYbUFgWG1BlFhtQchYbUH7WG1BL1ltQWNZbUGXWW1By1ltQf5ZbUEyWm1BZlptQZpabUHNWm1BAVttQTVbbUFpW21BnFttQdBbbUEEXG1BOFxtQWxcbUGfXG1B01xtQQddbUE7XW1Bbl1tQaJdbUHWXW1BCl5tQT1ebUFxXm1BpV5tQdlebUEMX21BQF9tQXRfbUGnX21B219tQQ9gbUFDYG1BdmBtQapgbUHeYG1BEWFtQUVhbUF5YW1BrWFtQeBhbUEUYm1BSGJtQXtibUGvYm1B42JtQRdjbUFKY21BfmNtQbJjbUHlY21BGWRtQU1kbUGAZG1BtGRtQehkbUEbZW1BT2VtQYNlbUG3ZW1B6mVtQR5mbUFSZm1BhWZtQblmbUHtZm1BIGdtQVRnbUGIZ21Bu2dtQe9nbUEjaG1BVmhtQYpobUG9aG1B8WhtQSVpbUFYaW1BjGltQcBpbUHzaW1BJ2ptQVtqbUGOam1BwmptQfZqbUEpa21BXWttQZBrbUHEa21B+GttQStsbUFfbG1BkmxtQcZsbUH6bG1BLW1tQWFtbUGVbW1ByG1tQfxtbUEvbm1BY25tQZdubUHKbm1B/m5tQTFvbUFlb21BmW9tQcxvbUEAcG1BM3BtQWdwbUGacG1BznBtQQJxbUE1cW1BaXFtQZxxbUHQcW1BBHJtQTdybUFrcm1BnnJtQdJybUEFc21BOXNtQWxzbUGgc21B1HNtQQd0bUE7dG1BbnRtQaJ0bUHVdG1BCXVtQTx1bUFwdW1Bo3VtQdd1bUELdm1BPnZtQXJ2bUGldm1B2XZtQQx3bUFAd21Bc3dtQad3bUHad21BDnhtQUF4bUF1eG1BqHhtQdx4bUEPeW1BQ3ltQXZ5bUGqeW1B3XltQRF6bUFEem1BeHptQat6bUHfem1BEnttQUZ7bUF5e21BrXttQeB7bUEUfG1BR3xtQXt8bUGufG1B4nxtQRV9bUFJfW1BfH1tQbB9bUHjfW1BFn5tQUp+bUF9fm1BsX5tQeR+bUEYf21BS39tQX9/bUGyf21B5n9tQRmAbUFMgG1BgIBtQbOAbUHngG1BGoFtQU6BbUGBgW1BtYFtQeiBbUEbgm1BT4JtQYKCbUG2gm1B6YJtQR2DbUFQg21Bg4NtQbeDbUHqg21BHoRtQVGEbUGEhG1BuIRtQeuEbUEfhW1BUoVtQYWFbUG5hW1B7IVtQSCGbUFThm1BhoZtQbqGbUHthm1BIYdtQVSHbUGHh21Bu4dtQe6HbUEhiG1BVYhtQYiIbUG8iG1B74htQSKJbUFWiW1BiYltQbyJbUHwiW1BI4ptQVeKbUGKim1BvYptQfGKbUEki21BV4ttQYuLbUG+i21B8YttQSWMbUFYjG1Bi4xtQb+MbUHyjG1BJY1tQVmNbUGMjW1Bv41tQfONbUEmjm1BWY5tQY2ObUHAjm1B845tQSePbUFaj21BjY9tQcGPbUH0j21BJ5BtQVqQbUGOkG1BwZBtQfSQbUEokW1BW5FtQY6RbUHCkW1B9ZFtQSiSbUFbkm1Bj5JtQcKSbUH1km1BKZNtQVyTbUGPk21BwpNtQfaTbUEplG1BXJRtQY+UbUHDlG1B9pRtQSmVbUFdlW1BkJVtQcOVbUH2lW1BKpZtQV2WbUGQlm1Bw5ZtQfeWbUEql21BXZdtQZCXbUHEl21B95dtQSqYbUFdmG1BkJhtQcSYbUH3mG1BKpltQV2ZbUGRmW1BxJltQfeZbUEqmm1BXpptQZGabUHEmm1B95ptQSqbbUFem21BkZttQcSbbUH3m21BKpxtQV6cbUGRnG1BxJxtQfecbUEqnW1BXp1tQZGdbUHEnW1B951tQSqebUFenm1BkZ5tQcSebUH3nm1BKp9tQV2fbUGRn21BxJ9tQfefbUEqoG1BXaBtQZCgbUHEoG1B96BtQSqhbUFdoW1BkKFtQcOhbUH3oW1BKqJtQV2ibUGQom1Bw6JtQfaibUEpo21BXaNtQZCjbUHDo21B9qNtQSmkbUFcpG1Bj6RtQcOkbUH2pG1BKaVtQVylbUGPpW1BwqVtQfWlbUEopm1BW6ZtQY+mbUHCpm1B9aZtQSinbUFbp21BjqdtQcGnbUH0p21BJ6htQVuobUGOqG1BwahtQfSobUEnqW1BWqltQY2pbUHAqW1B86ltQSaqbUFZqm1BjKptQcCqbUHzqm1BJqttQVmrbUGMq21Bv6ttQfKrbUElrG1BWKxtQYusbUG+rG1B8axtQSStbUFXrW1Biq1tQb6tbUHxrW1BJK5tQVeubUGKrm1Bva5tQfCubUEjr21BVq9tQYmvbUG8r21B769tQSKwbUFVsG1BiLBtQbuwbUHusG1BIbFtQVSxbUGHsW1BurFtQe2xbUEgsm1BU7JtQYaybUG5sm1B7LJtQR+zbUFSs21BhbNtQbizbUHrs21BHrRtQVG0bUGEtG1Bt7RtQeq0bUEdtW1BULVtQYO1bUG2tW1B6bVtQRy2bUFPtm1BgrZtQbW2bUHotm1BG7dtQU63bUGBt21BtLdtQee3bUEauG1BTbhtQYC4bUGzuG1B5rhtQRm5bUFMuW1BfrltQbG5bUHkuW1BF7ptQUq6bUF9um1BsLptQeO6bUEWu21BSbttQXy7bUGvu21B4rttQRW8bUFIvG1Be7xtQa28bUHgvG1BE71tQUa9bUF5vW1BrL1tQd+9bUESvm1BRb5tQXi+bUGrvm1B3b5tQRC/bUFDv21Bdr9tQam/bUHcv21BD8BtQULAbUF1wG1BqMBtQdrAbUENwW1BQMFtQXPBbUGmwW1B2cFtQQzCbUE/wm1BccJtQaTCbUHXwm1BCsNtQT3DbUFww21Bo8NtQdbDbUEIxG1BO8RtQW7EbUGhxG1B1MRtQQfFbUE6xW1BbMVtQZ/FbUHSxW1BBcZtQTjGbUFrxm1BncZtQdDGbUEDx21BNsdtQWnHbUGcx21BzsdtQQHIbUE0yG1BZ8htQZrIbUHMyG1B/8htQTLJbUFlyW1BmMltQcvJbUH9yW1BMMptQWPKbUGWym1BycptQfvKbUEuy21BYcttQZTLbUHHy21B+cttQSzMbUFfzG1BksxtQcTMbUH3zG1BKs1tQV3NbUGQzW1Bws1tQfXNbUEozm1BW85tQY3ObUHAzm1B885tQSbPbUFZz21Bi89tQb7PbUHxz21BJNBtQVbQbUGJ0G1BvNBtQe/QbUEh0W1BVNFtQYfRbUG60W1B7NFtQR/SbUFS0m1BhNJtQbfSbUHq0m1BHdNtQU/TbUGC021BtdNtQejTbUEa1G1BTdRtQYDUbUGy1G1B5dRtQRjVbUFL1W1BfdVtQbDVbUHj1W1BFdZtQUjWbUF71m1BrtZtQeDWbUET121BRtdtQXjXbUGr121B3tdtQRDYbUFD2G1BdthtQajYbUHb2G1BDtltQUDZbUFz2W1BptltQdjZbUEL2m1BPtptQXDabUGj2m1B1tptQQjbbUE7221BbtttQaDbbUHT221BBtxtQTjcbUFr3G1BntxtQdDcbUED3W1BNt1tQWjdbUGb3W1Bzt1tQQDebUEz3m1BZd5tQZjebUHL3m1B/d5tQTDfbUFj321Bld9tQcjfbUH6321BLeBtQWDgbUGS4G1BxeBtQfjgbUEq4W1BXeFtQY/hbUHC4W1B9eFtQSfibUFa4m1BjOJtQb/ibUHy4m1BJONtQVfjbUGJ421BvONtQe7jbUEh5G1BVORtQYbkbUG55G1B6+RtQR7lbUFR5W1Bg+VtQbblbUHo5W1BG+ZtQU3mbUGA5m1BsuZtQeXmbUEY521BSudtQX3nbUGv521B4udtQRTobUFH6G1BeehtQazobUHf6G1BEeltQUTpbUF26W1BqeltQdvpbUEO6m1BQOptQXPqbUGl6m1B2OptQQrrbUE9621Bb+ttQaLrbUHU621BB+xtQTrsbUFs7G1Bn+xtQdHsbUEE7W1BNu1tQWntbUGb7W1Bzu1tQQDubUEz7m1BZe5tQZjubUHK7m1B/e5tQS/vbUFi721BlO9tQcbvbUH5721BK/BtQV7wbUGQ8G1Bw/BtQfXwbUEo8W1BWvFtQY3xbUG/8W1B8vFtQSTybUFX8m1BifJtQbzybUHu8m1BIPNtQVPzbUGF821BuPNtQerzbUEd9G1BT/RtQYL0bUG09G1B5vRtQRn1bUFL9W1BfvVtQbD1bUHj9W1BFfZtQUj2bUF69m1BrPZtQd/2bUER921BRPdtQXb3bUGo921B2/dtQQ34bUFA+G1BcvhtQaX4bUHX+G1BCfltQTz5bUFu+W1BofltQdP5bUEF+m1BOPptQWr6bUGd+m1Bz/ptQQH7bUE0+21BZvttQZj7bUHL+21B/fttQTD8bUFi/G1BlPxtQcf8bUH5/G1BK/1tQV79bUGQ/W1Bw/1tQfX9bUEn/m1BWv5tQYz+bUG+/m1B8f5tQSP/bUFV/21BiP9tQbr/bUHs/21BHwBuQVEAbkGDAG5BtgBuQegAbkEaAW5BTQFuQX8BbkGxAW5B5AFuQRYCbkFIAm5BewJuQa0CbkHfAm5BEgNuQUQDbkF2A25BqQNuQdsDbkENBG5BQARuQXIEbkGkBG5B1wRuQQkFbkE7BW5BbQVuQaAFbkHSBW5BBAZuQTcGbkFpBm5BmwZuQc4GbkEAB25BMgduQWQHbkGXB25ByQduQfsHbkEtCG5BYAhuQZIIbkHECG5B9whuQSkJbkFbCW5BjQluQcAJbkHyCW5BJApuQVYKbkGJCm5BuwpuQe0KbkEfC25BUgtuQYQLbkG2C25B6AtuQRsMbkFNDG5BfwxuQbEMbkHkDG5BFg1uQUgNbkF6DW5BrQ1uQd8NbkERDm5BQw5uQXUObkGoDm5B2g5uQQwPbkE+D25BcQ9uQaMPbkHVD25BBxBuQTkQbkFsEG5BnhBuQdAQbkECEW5BNBFuQWcRbkGZEW5ByxFuQf0RbkEvEm5BYhJuQZQSbkHGEm5B+BJuQSoTbkFcE25BjxNuQcETbkHzE25BJRRuQVcUbkGJFG5BvBRuQe4UbkEgFW5BUhVuQYQVbkG2FW5B6RVuQRsWbkFNFm5BfxZuQbEWbkHjFm5BFhduQUgXbkF6F25BrBduQd4XbkEQGG5BQhhuQXUYbkGnGG5B2RhuQQsZbkE9GW5BbxluQaEZbkHTGW5BBhpuQTgabkFqGm5BnBpuQc4abkEAG25BMhtuQWQbbkGXG25ByRtuQfsbbkEtHG5BXxxuQZEcbkHDHG5B9RxuQScdbkFZHW5BjB1uQb4dbkHwHW5BIh5uQVQebkGGHm5BuB5uQeoebkEcH25BTh9uQYAfbkGyH25B5R9uQRcgbkFJIG5BeyBuQa0gbkHfIG5BESFuQUMhbkF1IW5BpyFuQdkhbkELIm5BPSJuQW8ibkGhIm5B0yJuQQYjbkE4I25BaiNuQZwjbkHOI25BACRuQTIkbkFkJG5BliRuQcgkbkH6JG5BLCVuQV4lbkGQJW5BwiVuQfQlbkEmJm5BWCZuQYombkG8Jm5B7iZuQSAnbkFSJ25BhCduQbYnbkHoJ25BGihuQUwobkF+KG5BsChuQeIobkEUKW5BRiluQXgpbkGqKW5B3CluQQ4qbkFAKm5BcipuQaQqbkHWKm5BCCtuQTorbkFsK25BnituQdArbkECLG5BNCxuQWYsbkGYLG5ByixuQfwsbkEuLW5BYC1uQZItbkHELW5B9i1uQSgubkFZLm5Biy5uQb0ubkHvLm5BIS9uQVMvbkGFL25Bty9uQekvbkEbMG5BTTBuQX8wbkGxMG5B4zBuQRUxbkFHMW5BeDFuQaoxbkHcMW5BDjJuQUAybkFyMm5BpDJuQdYybkEIM25BOjNuQWwzbkGeM25BzzNuQQE0bkEzNG5BZTRuQZc0bkHJNG5B+zRuQS01bkFfNW5BkTVuQcI1bkH0NW5BJjZuQVg2bkGKNm5BvDZuQe42bkEgN25BUTduQYM3bkG1N25B5zduQRk4bkFLOG5BfThuQa84bkHgOG5BEjluQUQ5bkF2OW5BqDluQdo5bkEMOm5BPTpuQW86bkGhOm5B0zpuQQU7bkE3O25BaTtuQZo7bkHMO25B/jtuQTA8bkFiPG5BlDxuQcU8bkH3PG5BKT1uQVs9bkGNPW5Bvj1uQfA9bkEiPm5BVD5uQYY+bkG4Pm5B6T5uQRs/bkFNP25Bfz9uQbE/bkHiP25BFEBuQUZAbkF4QG5BqkBuQdtAbkENQW5BP0FuQXFBbkGjQW5B1EFuQQZCbkE4Qm5BakJuQZxCbkHNQm5B/0JuQTFDbkFjQ25BlENuQcZDbkH4Q25BKkRuQVtEbkGNRG5Bv0RuQfFEbkEjRW5BVEVuQYZFbkG4RW5B6kVuQRtGbkFNRm5Bf0ZuQbFGbkHiRm5BFEduQUZHbkF4R25BqUduQdtHbkENSG5BPkhuQXBIbkGiSG5B1EhuQQVJbkE3SW5BaUluQZtJbkHMSW5B/kluQTBKbkFhSm5Bk0puQcVKbkH3Sm5BKEtuQVpLbkGMS25BvUtuQe9LbkEhTG5BUkxuQYRMbkG2TG5B6ExuQRlNbkFLTW5BfU1uQa5NbkHgTW5BEk5uQUNObkF1Tm5Bp05uQdhObkEKT25BPE9uQW1PbkGfT25B0U9uQQJQbkE0UG5BZlBuQZdQbkHJUG5B+1BuQSxRbkFeUW5BkFFuQcFRbkHzUW5BJVJuQVZSbkGIUm5BulJuQetSbkEdU25BT1NuQYBTbkGyU25B41NuQRVUbkFHVG5BeFRuQapUbkHcVG5BDVVuQT9VbkFxVW5BolVuQdRVbkEFVm5BN1ZuQWlWbkGaVm5BzFZuQf1WbkEvV25BYVduQZJXbkHEV25B9VduQSdYbkFZWG5BilhuQbxYbkHtWG5BH1luQVFZbkGCWW5BtFluQeVZbkEXWm5BSVpuQXpabkGsWm5B3VpuQQ9bbkFAW25BcltuQaRbbkHVW25BB1xuQThcbkFqXG5Bm1xuQc1cbkH/XG5BMF1uQWJdbkGTXW5BxV1uQfZdbkEoXm5BWV5uQYtebkG8Xm5B7l5uQSBfbkFRX25Bg19uQbRfbkHmX25BF2BuQUlgbkF6YG5BrGBuQd1gbkEPYW5BQGFuQXJhbkGjYW5B1WFuQQdibkE4Ym5BamJuQZtibkHNYm5B/mJuQTBjbkFhY25Bk2NuQcRjbkH2Y25BJ2RuQVlkbkGKZG5BvGRuQe1kbkEfZW5BUGVuQYJlbkGzZW5B5WVuQRZmbkFHZm5BeWZuQapmbkHcZm5BDWduQT9nbkFwZ25BomduQdNnbkEFaG5BNmhuQWhobkGZaG5By2huQfxobkEuaW5BX2luQZBpbkHCaW5B82luQSVqbkFWam5BiGpuQblqbkHram5BHGtuQU1rbkF/a25BsGtuQeJrbkETbG5BRWxuQXZsbkGnbG5B2WxuQQptbkE8bW5BbW1uQZ9tbkHQbW5BAW5uQTNubkFkbm5Blm5uQcdubkH4bm5BKm9uQVtvbkGNb25Bvm9uQe9vbkEhcG5BUnBuQYRwbkG1cG5B5nBuQRhxbkFJcW5Be3FuQaxxbkHdcW5BD3JuQUBybkFycm5Bo3JuQdRybkEGc25BN3NuQWhzbkGac25By3NuQf1zbkEudG5BX3RuQZF0bkHCdG5B83RuQSV1bkFWdW5Bh3VuQbl1bkHqdW5BG3ZuQU12bkF+dm5BsHZuQeF2bkESd25BRHduQXV3bkGmd25B2HduQQl4bkE6eG5BbHhuQZ14bkHOeG5BAHluQTF5bkFieW5Bk3luQcV5bkH2eW5BJ3puQVl6bkGKem5Bu3puQe16bkEee25BT3tuQYF7bkGye25B43tuQRR8bkFGfG5Bd3xuQah8bkHafG5BC31uQTx9bkFufW5Bn31uQdB9bkEBfm5BM35uQWR+bkGVfm5Bx35uQfh+bkEpf25BWn9uQYx/bkG9f25B7n9uQR+AbkFRgG5BgoBuQbOAbkHkgG5BFoFuQUeBbkF4gW5BqYFuQduBbkEMgm5BPYJuQW6CbkGggm5B0YJuQQKDbkEzg25BZYNuQZaDbkHHg25B+INuQSqEbkFbhG5BjIRuQb2EbkHvhG5BIIVuQVGFbkGChW5Bs4VuQeWFbkEWhm5BR4ZuQXiGbkGphm5B24ZuQQyHbkE9h25BboduQaCHbkHRh25BAohuQTOIbkFkiG5BlohuQceIbkH4iG5BKYluQVqJbkGLiW5BvYluQe6JbkEfim5BUIpuQYGKbkGzim5B5IpuQRWLbkFGi25Bd4tuQaiLbkHai25BC4xuQTyMbkFtjG5BnoxuQc+MbkEBjW5BMo1uQWONbkGUjW5BxY1uQfaNbkEnjm5BWY5uQYqObkG7jm5B7I5uQR2PbkFOj25Bf49uQbGPbkHij25BE5BuQUSQbkF1kG5BppBuQdeQbkEJkW5BOpFuQWuRbkGckW5BzZFuQf6RbkEvkm5BYJJuQZGSbkHDkm5B9JJuQSWTbkFWk25Bh5NuQbiTbkHpk25BGpRuQUuUbkF8lG5BrpRuQd+UbkEQlW5BQZVuQXKVbkGjlW5B1JVuQQWWbkE2lm5BZ5ZuQZiWbkHKlm5B+5ZuQSyXbkFdl25BjpduQb+XbkHwl25BIZhuQVKYbkGDmG5BtJhuQeWYbkEWmW5BR5luQXiZbkGpmW5B25luQQyabkE9mm5BbppuQZ+abkHQmm5BAZtuQTKbbkFjm25BlJtuQcWbbkH2m25BJ5xuQVicbkGJnG5BupxuQeucbkEcnW5BTZ1uQX6dbkGvnW5B4J1uQRGebkFCnm5Bc55uQaSebkHVnm5BBp9uQTefbkFon25BmZ9uQcqfbkH7n25BLKBuQV2gbkGOoG5Bv6BuQfCgbkEhoW5BUqFuQYOhbkG0oW5B5aFuQRaibkFHom5BeKJuQamibkHaom5BC6NuQTyjbkFto25BnqNuQc+jbkEApG5BMaRuQWKkbkGTpG5BxKRuQfWkbkEmpW5BV6VuQYilbkG5pW5B6qVuQRumbkFLpm5BfKZuQa2mbkHepm5BD6duQUCnbkFxp25BoqduQdOnbkEEqG5BNahuQWaobkGXqG5ByKhuQfmobkEqqW5BWqluQYupbkG8qW5B7aluQR6qbkFPqm5BgKpuQbGqbkHiqm5BE6tuQUSrbkF0q25BpatuQdarbkEHrG5BOKxuQWmsbkGarG5By6xuQfysbkEtrW5BXa1uQY6tbkG/rW5B8K1uQSGubkFSrm5Bg65uQbSubkHlrm5BFa9uQUavbkF3r25BqK9uQdmvbkEKsG5BO7BuQWuwbkGcsG5BzbBuQf6wbkEvsW5BYLFuQZGxbkHBsW5B8rFuQSOybkFUsm5BhbJuQbaybkHnsm5BF7NuQUizbkF5s25BqrNuQduzbkEMtG5BPLRuQW20bkGetG5Bz7RuQQC1bkExtW5BYbVuQZK1bkHDtW5B9LVuQSW2bkFWtm5BhrZuQbe2bkHotm5BGbduQUq3bkF6t25Bq7duQdy3bkENuG5BPrhuQW64bkGfuG5B0LhuQQG5bkEyuW5BYrluQZO5bkHEuW5B9bluQSW6bkFWum5Bh7puQbi6bkHpum5BGbtuQUq7bkF7u25BrLtuQdy7bkENvG5BPrxuQW+8bkGgvG5B0LxuQQG9bkEyvW5BY71uQZO9bkHEvW5B9b1uQSa+bkFWvm5Bh75uQbi+bkHpvm5BGb9uQUq/bkF7v25BrL9uQdy/bkENwG5BPsBuQW7AbkGfwG5B0MBuQQHBbkExwW5BYsFuQZPBbkHEwW5B9MFuQSXCbkFWwm5BhsJuQbfCbkHowm5BGcNuQUnDbkF6w25Bq8NuQdvDbkEMxG5BPcRuQW7EbkGexG5Bz8RuQQDFbkEwxW5BYcVuQZLFbkHCxW5B88VuQSTGbkFUxm5BhcZuQbbGbkHmxm5BF8duQUjHbkF4x25BqcduQdrHbkEKyG5BO8huQWzIbkGcyG5BzchuQf7IbkEuyW5BX8luQZDJbkHAyW5B8cluQSLKbkFSym5Bg8puQbTKbkHkym5BFctuQUbLbkF2y25Bp8tuQdjLbkEIzG5BOcxuQWnMbkGazG5By8xuQfvMbkEszW5BXc1uQY3NbkG+zW5B7s1uQR/ObkFQzm5BgM5uQbHObkHizm5BEs9uQUPPbkFzz25BpM9uQdXPbkEF0G5BNtBuQWbQbkGX0G5ByNBuQfjQbkEp0W5BWdFuQYrRbkG70W5B69FuQRzSbkFM0m5BfdJuQa7SbkHe0m5BD9NuQT/TbkFw025BoNNuQdHTbkEC1G5BMtRuQWPUbkGT1G5BxNRuQfTUbkEl1W5BVdVuQYbVbkG31W5B59VuQRjWbkFI1m5BedZuQanWbkHa1m5BCtduQTvXbkFs125BnNduQc3XbkH9125BLthuQV7YbkGP2G5Bv9huQfDYbkEg2W5BUdluQYHZbkGy2W5B4tluQRPabkFE2m5BdNpuQaXabkHV2m5BBttuQTbbbkFn225Bl9tuQcjbbkH4225BKdxuQVncbkGK3G5ButxuQevcbkEb3W5BTN1uQXzdbkGt3W5B3d1uQQ7ebkE+3m5Bb95uQZ/ebkHQ3m5BAN9uQTDfbkFh325Bkd9uQcLfbkHy325BI+BuQVPgbkGE4G5BtOBuQeXgbkEV4W5BRuFuQXbhbkGn4W5B1+FuQQfibkE44m5BaOJuQZnibkHJ4m5B+uJuQSrjbkFb425Bi+NuQbzjbkHs425BHORuQU3kbkF95G5BruRuQd7kbkEP5W5BP+VuQW/lbkGg5W5B0OVuQQHmbkEx5m5BYuZuQZLmbkHC5m5B8+ZuQSPnbkFU525BhOduQbTnbkHl525BFehuQUbobkF26G5BpuhuQdfobkEH6W5BOOluQWjpbkGY6W5ByeluQfnpbkEq6m5BWupuQYrqbkG76m5B6+puQRzrbkFM625BfOtuQa3rbkHd625BDexuQT7sbkFu7G5Bn+xuQc/sbkH/7G5BMO1uQWDtbkGQ7W5Bwe1uQfHtbkEh7m5BUu5uQYLubkGz7m5B4+5uQRPvbkFE725BdO9uQaTvbkHV725BBfBuQTXwbkFm8G5BlvBuQcbwbkH38G5BJ/FuQVfxbkGI8W5BuPFuQejxbkEZ8m5BSfJuQXnybkGq8m5B2vJuQQrzbkE7825Ba/NuQZvzbkHL825B/PNuQSz0bkFc9G5BjfRuQb30bkHt9G5BHvVuQU71bkF+9W5BrvVuQd/1bkEP9m5BP/ZuQXD2bkGg9m5B0PZuQQD3bkEx925BYfduQZH3bkHC925B8vduQSL4bkFS+G5Bg/huQbP4bkHj+G5BFPluQUT5bkF0+W5BpPluQdX5bkEF+m5BNfpuQWX6bkGW+m5BxvpuQfb6bkEm+25BV/tuQYf7bkG3+25B5/tuQRj8bkFI/G5BePxuQaj8bkHZ/G5BCf1uQTn9bkFp/W5Bmf1uQcr9bkH6/W5BKv5uQVr+bkGL/m5Bu/5uQev+bkEb/25BS/9uQXz/bkGs/25B3P9uQQwAb0E9AG9BbQBvQZ0Ab0HNAG9B/QBvQS4Bb0FeAW9BjgFvQb4Bb0HuAW9BHwJvQU8Cb0F/Am9BrwJvQd8Cb0EPA29BQANvQXADb0GgA29B0ANvQQAEb0ExBG9BYQRvQZEEb0HBBG9B8QRvQSEFb0FSBW9BggVvQbIFb0HiBW9BEgZvQUIGb0FzBm9BowZvQdMGb0EDB29BMwdvQWMHb0GTB29BxAdvQfQHb0EkCG9BVAhvQYQIb0G0CG9B5AhvQRUJb0FFCW9BdQlvQaUJb0HVCW9BBQpvQTUKb0FmCm9BlgpvQcYKb0H2Cm9BJgtvQVYLb0GGC29BtgtvQeYLb0EXDG9BRwxvQXcMb0GnDG9B1wxvQQcNb0E3DW9BZw1vQZcNb0HIDW9B+A1vQSgOb0FYDm9BiA5vQbgOb0HoDm9BGA9vQUgPb0F4D29BqA9vQdkPb0EJEG9BORBvQWkQb0GZEG9ByRBvQfkQb0EpEW9BWRFvQYkRb0G5EW9B6RFvQRkSb0FJEm9BehJvQaoSb0HaEm9BChNvQToTb0FqE29BmhNvQcoTb0H6E29BKhRvQVoUb0GKFG9BuhRvQeoUb0EaFW9BShVvQXoVb0GqFW9B2hVvQQoWb0E6Fm9BahZvQZoWb0HKFm9B+xZvQSsXb0FbF29BixdvQbsXb0HrF29BGxhvQUsYb0F7GG9BqxhvQdsYb0ELGW9BOxlvQWsZb0GbGW9ByxlvQfsZb0ErGm9BWxpvQYsab0G7Gm9B6xpvQRsbb0FLG29BextvQasbb0HbG29BCxxvQTscb0FrHG9BmxxvQcscb0H6HG9BKh1vQVodb0GKHW9Buh1vQeodb0EaHm9BSh5vQXoeb0GqHm9B2h5vQQofb0E6H29Bah9vQZofb0HKH29B+h9vQSogb0FaIG9BiiBvQbogb0HqIG9BGiFvQUkhb0F5IW9BqSFvQdkhb0EJIm9BOSJvQWkib0GZIm9BySJvQfkib0EpI29BWSNvQYkjb0G5I29B6CNvQRgkb0FIJG9BeCRvQagkb0HYJG9BCCVvQTglb0FoJW9BmCVvQcglb0H3JW9BJyZvQVcmb0GHJm9BtyZvQecmb0EXJ29BRydvQXcnb0GnJ29B1idvQQYob0E2KG9BZihvQZYob0HGKG9B9ihvQSYpb0FVKW9BhSlvQbUpb0HlKW9BFSpvQUUqb0F1Km9BpSpvQdQqb0EEK29BNCtvQWQrb0GUK29BxCtvQfQrb0EjLG9BUyxvQYMsb0GzLG9B4yxvQRMtb0FCLW9Bci1vQaItb0HSLW9BAi5vQTIub0FiLm9BkS5vQcEub0HxLm9BIS9vQVEvb0GAL29BsC9vQeAvb0EQMG9BQDBvQXAwb0GfMG9BzzBvQf8wb0EvMW9BXzFvQY4xb0G+MW9B7jFvQR4yb0FOMm9BfTJvQa0yb0HdMm9BDTNvQT0zb0FsM29BnDNvQcwzb0H8M29BLDRvQVs0b0GLNG9BuzRvQes0b0EbNW9BSjVvQXo1b0GqNW9B2jVvQQk2b0E5Nm9BaTZvQZk2b0HINm9B+DZvQSg3b0FYN29BiDdvQbc3b0HnN29BFzhvQUc4b0F2OG9BpjhvQdY4b0EGOW9BNTlvQWU5b0GVOW9BxTlvQfQ5b0EkOm9BVDpvQYM6b0GzOm9B4zpvQRM7b0FCO29BcjtvQaI7b0HSO29BATxvQTE8b0FhPG9BkDxvQcA8b0HwPG9BID1vQU89b0F/PW9Brz1vQd49b0EOPm9BPj5vQW4+b0GdPm9BzT5vQf0+b0EsP29BXD9vQYw/b0G7P29B6z9vQRtAb0FLQG9BekBvQapAb0HaQG9BCUFvQTlBb0FpQW9BmEFvQchBb0H4QW9BJ0JvQVdCb0GHQm9BtkJvQeZCb0EWQ29BRUNvQXVDb0GlQ29B1ENvQQREb0E0RG9BY0RvQZNEb0HDRG9B8kRvQSJFb0FSRW9BgUVvQbFFb0HhRW9BEEZvQUBGb0FvRm9Bn0ZvQc9Gb0H+Rm9BLkdvQV5Hb0GNR29BvUdvQe1Hb0EcSG9BTEhvQXtIb0GrSG9B20hvQQpJb0E6SW9BaklvQZlJb0HJSW9B+ElvQShKb0FYSm9Bh0pvQbdKb0HmSm9BFktvQUZLb0F1S29BpUtvQdRLb0EETG9BNExvQWNMb0GTTG9BwkxvQfJMb0EiTW9BUU1vQYFNb0GwTW9B4E1vQQ9Ob0E/Tm9Bb05vQZ5Ob0HOTm9B/U5vQS1Pb0FcT29BjE9vQbxPb0HrT29BG1BvQUpQb0F6UG9BqVBvQdlQb0EIUW9BOFFvQWhRb0GXUW9Bx1FvQfZRb0EmUm9BVVJvQYVSb0G0Um9B5FJvQRNTb0FDU29Bc1NvQaJTb0HSU29BAVRvQTFUb0FgVG9BkFRvQb9Ub0HvVG9BHlVvQU5Vb0F9VW9BrVVvQdxVb0EMVm9BO1ZvQWtWb0GaVm9BylZvQflWb0EpV29BWFdvQYhXb0G3V29B51dvQRZYb0FGWG9BdVhvQaVYb0HUWG9BBFlvQTNZb0FjWW9BkllvQcJZb0HxWW9BIVpvQVBab0GAWm9Br1pvQd9ab0EOW29BPltvQW1bb0GdW29BzFtvQfxbb0ErXG9BWlxvQYpcb0G5XG9B6VxvQRhdb0FIXW9Bd11vQaddb0HWXW9BBl5vQTVeb0FkXm9BlF5vQcNeb0HzXm9BIl9vQVJfb0GBX29BsV9vQeBfb0EPYG9BP2BvQW5gb0GeYG9BzWBvQf1gb0EsYW9BW2FvQYthb0G6YW9B6mFvQRlib0FIYm9BeGJvQadib0HXYm9BBmNvQTZjb0FlY29BlGNvQcRjb0HzY29BI2RvQVJkb0GBZG9BsWRvQeBkb0EQZW9BP2VvQW5lb0GeZW9BzWVvQfxlb0EsZm9BW2ZvQYtmb0G6Zm9B6WZvQRlnb0FIZ29BeGdvQadnb0HWZ29BBmhvQTVob0FkaG9BlGhvQcNob0HyaG9BImlvQVFpb0GBaW9BsGlvQd9pb0EPam9BPmpvQW1qb0Gdam9BzGpvQftqb0Era29BWmtvQYlrb0G5a29B6GtvQRdsb0FHbG9BdmxvQaVsb0HVbG9BBG1vQTNtb0FjbW9Bkm1vQcFtb0HxbW9BIG5vQU9ub0F/bm9Brm5vQd1ub0ENb29BPG9vQWtvb0Gbb29Bym9vQflvb0EocG9BWHBvQYdwb0G2cG9B5nBvQRVxb0FEcW9BdHFvQaNxb0HScW9BAXJvQTFyb0Fgcm9Bj3JvQb9yb0Hucm9BHXNvQUxzb0F8c29Bq3NvQdpzb0EJdG9BOXRvQWh0b0GXdG9Bx3RvQfZ0b0EldW9BVHVvQYR1b0GzdW9B4nVvQRF2b0FBdm9BcHZvQZ92b0HOdm9B/nZvQS13b0Fcd29Bi3dvQbt3b0Hqd29BGXhvQUh4b0F4eG9Bp3hvQdZ4b0EFeW9BNXlvQWR5b0GTeW9BwnlvQfF5b0Ehem9BUHpvQX96b0Guem9B3npvQQ17b0E8e29Ba3tvQZp7b0HKe29B+XtvQSh8b0FXfG9BhnxvQbZ8b0HlfG9BFH1vQUN9b0FyfW9Bon1vQdF9b0EAfm9BL35vQV5+b0GOfm9BvX5vQex+b0Ebf29BSn9vQXp/b0Gpf29B2H9vQQeAb0E2gG9BZYBvQZWAb0HEgG9B84BvQSKBb0FRgW9BgIFvQbCBb0HfgW9BDoJvQT2Cb0Fsgm9Bm4JvQcuCb0H6gm9BKYNvQViDb0GHg29BtoNvQeWDb0EVhG9BRIRvQXOEb0GihG9B0YRvQQCFb0EvhW9BX4VvQY6Fb0G9hW9B7IVvQRuGb0FKhm9BeYZvQamGb0HYhm9BB4dvQTaHb0Flh29BlIdvQcOHb0Hyh29BIYhvQVGIb0GAiG9Br4hvQd6Ib0ENiW9BPIlvQWuJb0GaiW9ByYlvQfmJb0Eoim9BV4pvQYaKb0G1im9B5IpvQROLb0FCi29BcYtvQaCLb0HPi29B/4tvQS6Mb0FdjG9BjIxvQbuMb0HqjG9BGY1vQUiNb0F3jW9Bpo1vQdWNb0EEjm9BM45vQWKOb0GSjm9BwY5vQfCOb0Efj29BTo9vQX2Pb0Gsj29B249vQQqQb0E5kG9BaJBvQZeQb0HGkG9B9ZBvQSSRb0FTkW9BgpFvQbGRb0HgkW9BD5JvQT6Sb0Ftkm9BnJJvQcySb0H7km9BKpNvQVmTb0GIk29Bt5NvQeaTb0EVlG9BRJRvQXOUb0GilG9B0ZRvQQCVb0EvlW9BXpVvQY2Vb0G8lW9B65VvQRqWb0FJlm9BeJZvQaeWb0HWlm9BBZdvQTSXb0Fjl29BkpdvQcGXb0Hwl29BH5hvQU6Yb0F9mG9BrJhvQduYb0EKmW9BOZlvQWiZb0GXmW9BxplvQfSZb0Ejmm9BUppvQYGab0Gwmm9B35pvQQ6bb0E9m29BbJtvQZubb0HKm29B+ZtvQSicb0FXnG9BhpxvQbWcb0HknG9BE51vQUKdb0FxnW9BoJ1vQc+db0H9nW9BLJ5vQVueb0GKnm9BuZ5vQeieb0EXn29BRp9vQXWfb0Gkn29B059vQQKgb0ExoG9BYKBvQY6gb0G9oG9B7KBvQRuhb0FKoW9BeaFvQaihb0HXoW9BBqJvQTWib0Fkom9BkqJvQcGib0Hwom9BH6NvQU6jb0F9o29BrKNvQdujb0EKpG9BOaRvQWekb0GWpG9BxaRvQfSkb0EjpW9BUqVvQYGlb0GwpW9B3qVvQQ2mb0E8pm9Ba6ZvQZqmb0HJpm9B+KZvQSenb0FVp29BhKdvQbOnb0Hip29BEahvQUCob0FvqG9BnahvQcyob0H7qG9BKqlvQVmpb0GIqW9Bt6lvQeWpb0EUqm9BQ6pvQXKqb0Ghqm9B0KpvQf6qb0Etq29BXKtvQYurb0G6q29B6atvQResb0FGrG9BdaxvQaSsb0HTrG9BAq1vQTCtb0FfrW9Bjq1vQb2tb0HsrW9BGq5vQUmub0F4rm9Bp65vQdaub0EEr29BM69vQWKvb0GRr29BwK9vQe6vb0EdsG9BTLBvQXuwb0GqsG9B2LBvQQexb0E2sW9BZbFvQZSxb0HCsW9B8bFvQSCyb0FPsm9BfbJvQayyb0Hbsm9BCrNvQTmzb0Fns29BlrNvQcWzb0H0s29BIrRvQVG0b0GAtG9Br7RvQd20b0EMtW9BO7VvQWq1b0GYtW9Bx7VvQfa1b0Eltm9BU7ZvQYK2b0Gxtm9B4LZvQQ63b0E9t29BbLdvQZu3b0HJt29B+LdvQSe4b0FWuG9BhLhvQbO4b0HiuG9BELlvQT+5b0FuuW9BnblvQcu5b0H6uW9BKbpvQVe6b0GGum9BtbpvQeS6b0ESu29BQbtvQXC7b0Geu29BzbtvQfy7b0ErvG9BWbxvQYi8b0G3vG9B5bxvQRS9b0FDvW9Bcb1vQaC9b0HPvW9B/b1vQSy+b0Fbvm9Bir5vQbi+b0Hnvm9BFr9vQUS/b0Fzv29Bor9vQdC/b0H/v29BLsBvQVzAb0GLwG9BusBvQejAb0EXwW9BRsFvQXTBb0GjwW9B0sFvQQDCb0Evwm9BXcJvQYzCb0G7wm9B6cJvQRjDb0FHw29BdcNvQaTDb0HTw29BAcRvQTDEb0FfxG9BjcRvQbzEb0HqxG9BGcVvQUjFb0F2xW9BpcVvQdTFb0ECxm9BMcZvQV/Gb0GOxm9BvcZvQevGb0Eax29BScdvQXfHb0Gmx29B1MdvQQPIb0EyyG9BYMhvQY/Ib0G9yG9B7MhvQRvJb0FJyW9BeMlvQabJb0HVyW9BBMpvQTLKb0Fhym9Bj8pvQb7Kb0Hsym9BG8tvQUrLb0F4y29Bp8tvQdXLb0EEzG9BMsxvQWHMb0GQzG9BvsxvQe3Mb0EbzW9BSs1vQXjNb0GnzW9B1s1vQQTOb0Ezzm9BYc5vQZDOb0G+zm9B7c5vQRvPb0FKz29Bec9vQafPb0HWz29BBNBvQTPQb0Fh0G9BkNBvQb7Qb0Ht0G9BG9FvQUrRb0F50W9Bp9FvQdbRb0EE0m9BM9JvQWHSb0GQ0m9BvtJvQe3Sb0Eb029BStNvQXjTb0Gn029B1dNvQQTUb0Ey1G9BYdRvQY/Ub0G+1G9B7NRvQRvVb0FJ1W9BeNVvQabVb0HV1W9BA9ZvQTLWb0Fg1m9Bj9ZvQb3Wb0Hs1m9BGtdvQUnXb0F3129BptdvQdTXb0ED2G9BMdhvQWDYb0GO2G9BvdhvQevYb0Ea2W9BSNlvQXbZb0Gl2W9B09lvQQLab0Ew2m9BX9pvQY3ab0G82m9B6tpvQRnbb0FH229BdttvQaTbb0HS229BAdxvQS/cb0Fe3G9BjNxvQbvcb0Hp3G9BGN1vQUbdb0F03W9Bo91vQdHdb0EA3m9BLt5vQV3eb0GL3m9Bud5vQejeb0EW329BRd9vQXPfb0Gi329B0N9vQf7fb0Et4G9BW+BvQYrgb0G44G9B5uBvQRXhb0FD4W9BcuFvQaDhb0HP4W9B/eFvQSvib0Fa4m9BiOJvQbfib0Hl4m9BE+NvQULjb0Fw429BnuNvQc3jb0H7429BKuRvQVjkb0GG5G9BteRvQePkb0ES5W9BQOVvQW7lb0Gd5W9By+VvQfnlb0Eo5m9BVuZvQYXmb0Gz5m9B4eZvQRDnb0E+529BbOdvQZvnb0HJ529B9+dvQSbob0FU6G9BguhvQbHob0Hf6G9BDelvQTzpb0Fq6W9BmelvQcfpb0H16W9BJOpvQVLqb0GA6m9Br+pvQd3qb0EL629BOutvQWjrb0GW629BxetvQfPrb0Eh7G9BT+xvQX7sb0Gs7G9B2uxvQQntb0E37W9BZe1vQZTtb0HC7W9B8O1vQR/ub0FN7m9Be+5vQarub0HY7m9BBu9vQTTvb0Fj729Bke9vQb/vb0Hu729BHPBvQUrwb0F48G9Bp/BvQdXwb0ED8W9BMvFvQWDxb0GO8W9BvPFvQevxb0EZ8m9BR/JvQXbyb0Gk8m9B0vJvQQDzb0Ev829BXfNvQYvzb0G5829B6PNvQRb0b0FE9G9BcvRvQaH0b0HP9G9B/fRvQSv1b0Fa9W9BiPVvQbb1b0Hk9W9BE/ZvQUH2b0Fv9m9BnfZvQcz2b0H69m9BKPdvQVb3b0GF929Bs/dvQeH3b0EP+G9BPvhvQWz4b0Ga+G9ByPhvQfb4b0El+W9BU/lvQYH5b0Gv+W9B3vlvQQz6b0E6+m9BaPpvQZb6b0HF+m9B8/pvQSH7b0FP+29BfftvQaz7b0Ha+29BCPxvQTb8b0Fk/G9Bk/xvQcH8b0Hv/G9BHf1vQUv9b0F6/W9BqP1vQdb9b0EE/m9BMv5vQWD+b0GP/m9Bvf5vQev+b0EZ/29BR/9vQXX/b0Gk/29B0v9vQQAAcEEuAHBBXABwQYoAcEG5AHBB5wBwQRUBcEFDAXBBcQFwQZ8BcEHOAXBB/AFwQSoCcEFYAnBBhgJwQbQCcEHiAnBBEQNwQT8DcEFtA3BBmwNwQckDcEH3A3BBJQRwQVQEcEGCBHBBsARwQd4EcEEMBXBBOgVwQWgFcEGWBXBBxQVwQfMFcEEhBnBBTwZwQX0GcEGrBnBB2QZwQQcHcEE2B3BBZAdwQZIHcEHAB3BB7gdwQRwIcEFKCHBBeAhwQaYIcEHUCHBBAwlwQTEJcEFfCXBBjQlwQbsJcEHpCXBBFwpwQUUKcEFzCnBBoQpwQc8KcEH+CnBBLAtwQVoLcEGIC3BBtgtwQeQLcEESDHBBQAxwQW4McEGcDHBBygxwQfgMcEEmDXBBVA1wQYMNcEGxDXBB3w1wQQ0OcEE7DnBBaQ5wQZcOcEHFDnBB8w5wQSEPcEFPD3BBfQ9wQasPcEHZD3BBBxBwQTUQcEFjEHBBkRBwQb8QcEHtEHBBGxFwQUkRcEF4EXBBphFwQdQRcEECEnBBMBJwQV4ScEGMEnBBuhJwQegScEEWE3BBRBNwQXITcEGgE3BBzhNwQfwTcEEqFHBBWBRwQYYUcEG0FHBB4hRwQRAVcEE+FXBBbBVwQZoVcEHIFXBB9hVwQSQWcEFSFnBBgBZwQa4WcEHcFnBBChdwQTgXcEFmF3BBlBdwQcIXcEHwF3BBHhhwQUwYcEF6GHBBqBhwQdYYcEEEGXBBMhlwQV8ZcEGNGXBBuxlwQekZcEEXGnBBRRpwQXMacEGhGnBBzxpwQf0acEErG3BBWRtwQYcbcEG1G3BB4xtwQREccEE/HHBBbRxwQZsccEHJHHBB9xxwQSUdcEFSHXBBgB1wQa4dcEHcHXBBCh5wQTgecEFmHnBBlB5wQcIecEHwHnBBHh9wQUwfcEF6H3BBqB9wQdUfcEEDIHBBMSBwQV8gcEGNIHBBuyBwQekgcEEXIXBBRSFwQXMhcEGhIXBBziFwQfwhcEEqInBBWCJwQYYicEG0InBB4iJwQRAjcEE+I3BBbCNwQZkjcEHHI3BB9SNwQSMkcEFRJHBBfyRwQa0kcEHbJHBBCCVwQTYlcEFkJXBBkiVwQcAlcEHuJXBBHCZwQUomcEF3JnBBpSZwQdMmcEEBJ3BBLydwQV0ncEGLJ3BBuCdwQeYncEEUKHBBQihwQXAocEGeKHBBzChwQfkocEEnKXBBVSlwQYMpcEGxKXBB3ylwQQ0qcEE6KnBBaCpwQZYqcEHEKnBB8ipwQSArcEFNK3BBeytwQakrcEHXK3BBBSxwQTIscEFgLHBBjixwQbwscEHqLHBBGC1wQUUtcEFzLXBBoS1wQc8tcEH9LXBBKi5wQVgucEGGLnBBtC5wQeIucEEPL3BBPS9wQWsvcEGZL3BBxy9wQfQvcEEiMHBBUDBwQX4wcEGsMHBB2TBwQQcxcEE1MXBBYzFwQZExcEG+MXBB7DFwQRoycEFIMnBBdTJwQaMycEHRMnBB/zJwQSwzcEFaM3BBiDNwQbYzcEHkM3BBETRwQT80cEFtNHBBmzRwQcg0cEH2NHBBJDVwQVI1cEF/NXBBrTVwQds1cEEJNnBBNjZwQWQ2cEGSNnBBwDZwQe02cEEbN3BBSTdwQXc3cEGkN3BB0jdwQQA4cEEtOHBBWzhwQYk4cEG3OHBB5DhwQRI5cEFAOXBBbjlwQZs5cEHJOXBB9zlwQSQ6cEFSOnBBgDpwQa46cEHbOnBBCTtwQTc7cEFkO3BBkjtwQcA7cEHtO3BBGzxwQUk8cEF3PHBBpDxwQdI8cEEAPXBBLT1wQVs9cEGJPXBBtj1wQeQ9cEESPnBBPz5wQW0+cEGbPnBByT5wQfY+cEEkP3BBUj9wQX8/cEGtP3BB2z9wQQhAcEE2QHBBZEBwQZFAcEG/QHBB7UBwQRpBcEFIQXBBdkFwQaNBcEHRQXBB/kFwQSxCcEFaQnBBh0JwQbVCcEHjQnBBEENwQT5DcEFsQ3BBmUNwQcdDcEH1Q3BBIkRwQVBEcEF+RHBBq0RwQdlEcEEGRXBBNEVwQWJFcEGPRXBBvUVwQetFcEEYRnBBRkZwQXNGcEGhRnBBz0ZwQfxGcEEqR3BBV0dwQYVHcEGzR3BB4EdwQQ5IcEE8SHBBaUhwQZdIcEHESHBB8khwQSBJcEFNSXBBe0lwQahJcEHWSXBBBEpwQTFKcEFfSnBBjEpwQbpKcEHnSnBBFUtwQUNLcEFwS3BBnktwQctLcEH5S3BBJ0xwQVRMcEGCTHBBr0xwQd1McEEKTXBBOE1wQWVNcEGTTXBBwU1wQe5NcEEcTnBBSU5wQXdOcEGkTnBB0k5wQQBPcEEtT3BBW09wQYhPcEG2T3BB409wQRFQcEE+UHBBbFBwQZlQcEHHUHBB9VBwQSJRcEFQUXBBfVFwQatRcEHYUXBBBlJwQTNScEFhUnBBjlJwQbxScEHpUnBBF1NwQURTcEFyU3BBn1NwQc1TcEH6U3BBKFRwQVZUcEGDVHBBsVRwQd5UcEEMVXBBOVVwQWdVcEGUVXBBwlVwQe9VcEEdVnBBSlZwQXhWcEGlVnBB01ZwQQBXcEEuV3BBW1dwQYlXcEG2V3BB41dwQRFYcEE+WHBBbFhwQZlYcEHHWHBB9FhwQSJZcEFPWXBBfVlwQapZcEHYWXBBBVpwQTNacEFgWnBBjlpwQbtacEHpWnBBFltwQUNbcEFxW3BBnltwQcxbcEH5W3BBJ1xwQVRccEGCXHBBr1xwQd1ccEEKXXBBN11wQWVdcEGSXXBBwF1wQe1dcEEbXnBBSF5wQXVecEGjXnBB0F5wQf5ecEErX3BBWV9wQYZfcEGzX3BB4V9wQQ5gcEE8YHBBaWBwQZdgcEHEYHBB8WBwQR9hcEFMYXBBemFwQadhcEHUYXBBAmJwQS9icEFdYnBBimJwQbdicEHlYnBBEmNwQUBjcEFtY3BBmmNwQchjcEH1Y3BBI2RwQVBkcEF9ZHBBq2RwQdhkcEEGZXBBM2VwQWBlcEGOZXBBu2VwQellcEEWZnBBQ2ZwQXFmcEGeZnBBy2ZwQflmcEEmZ3BBU2dwQYFncEGuZ3BB3GdwQQlocEE2aHBBZGhwQZFocEG+aHBB7GhwQRlpcEFGaXBBdGlwQaFpcEHOaXBB/GlwQSlqcEFXanBBhGpwQbFqcEHfanBBDGtwQTlrcEFna3BBlGtwQcFrcEHva3BBHGxwQUlscEF3bHBBpGxwQdFscEH+bHBBLG1wQVltcEGGbXBBtG1wQeFtcEEObnBBPG5wQWlucEGWbnBBxG5wQfFucEEeb3BBTG9wQXlvcEGmb3BB029wQQFwcEEucHBBW3BwQYlwcEG2cHBB43BwQRFxcEE+cXBBa3FwQZhxcEHGcXBB83FwQSBycEFOcnBBe3JwQahycEHVcnBBA3NwQTBzcEFdc3BBinNwQbhzcEHlc3BBEnRwQUB0cEFtdHBBmnRwQcd0cEH1dHBBInVwQU91cEF8dXBBqnVwQdd1cEEEdnBBMXZwQV92cEGMdnBBuXZwQeZ2cEEUd3BBQXdwQW53cEGbd3BByXdwQfZ3cEEjeHBBUHhwQX54cEGreHBB2HhwQQV5cEEzeXBBYHlwQY15cEG6eXBB53lwQRV6cEFCenBBb3pwQZx6cEHKenBB93pwQSR7cEFRe3BBfntwQax7cEHZe3BBBnxwQTN8cEFgfHBBjnxwQbt8cEHofHBBFX1wQUJ9cEFwfXBBnX1wQcp9cEH3fXBBJH5wQVJ+cEF/fnBBrH5wQdl+cEEGf3BBNH9wQWF/cEGOf3BBu39wQeh/cEEVgHBBQ4BwQXCAcEGdgHBByoBwQfeAcEEkgXBBUoFwQX+BcEGsgXBB2YFwQQaCcEEzgnBBYYJwQY6CcEG7gnBB6IJwQRWDcEFCg3BBcINwQZ2DcEHKg3BB94NwQSSEcEFRhHBBfoRwQayEcEHZhHBBBoVwQTOFcEFghXBBjYVwQbqFcEHohXBBFYZwQUKGcEFvhnBBnIZwQcmGcEH2hnBBI4dwQVGHcEF+h3BBq4dwQdiHcEEFiHBBMohwQV+IcEGMiHBBuYhwQeeIcEEUiXBBQYlwQW6JcEGbiXBByIlwQfWJcEEiinBBT4pwQXyKcEGqinBB14pwQQSLcEExi3BBXotwQYuLcEG4i3BB5YtwQRKMcEE/jHBBbIxwQZqMcEHHjHBB9IxwQSGNcEFOjXBBe41wQaiNcEHVjXBBAo5wQS+OcEFcjnBBiY5wQbaOcEHjjnBBEY9wQT6PcEFrj3BBmI9wQcWPcEHyj3BBH5BwQUyQcEF5kHBBppBwQdOQcEEAkXBBLZFwQVqRcEGHkXBBtJFwQeGRcEEOknBBO5JwQWiScEGWknBBw5JwQfCScEEdk3BBSpNwQXeTcEGkk3BB0ZNwQf6TcEErlHBBWJRwQYWUcEGylHBB35RwQQyVcEE5lXBBZpVwQZOVcEHAlXBB7ZVwQRqWcEFHlnBBdJZwQaGWcEHOlnBB+5ZwQSiXcEFVl3BBgpdwQa+XcEHcl3BBCZhwQTaYcEFjmHBBkJhwQb2YcEHqmHBBF5lwQUSZcEFxmXBBnplwQcuZcEH4mXBBJZpwQVKacEF/mnBBrJpwQdmacEEGm3BBM5twQWCbcEGNm3BBuptwQeebcEETnHBBQJxwQW2ccEGanHBBx5xwQfSccEEhnXBBTp1wQXudcEGonXBB1Z1wQQKecEEvnnBBXJ5wQYmecEG2nnBB455wQRCfcEE9n3BBap9wQZafcEHDn3BB8J9wQR2gcEFKoHBBd6BwQaSgcEHRoHBB/qBwQSuhcEFYoXBBhaFwQbKhcEHfoXBBC6JwQTiicEFlonBBkqJwQb+icEHsonBBGaNwQUajcEFzo3BBoKNwQc2jcEH5o3BBJqRwQVOkcEGApHBBraRwQdqkcEEHpXBBNKVwQWGlcEGOpXBBuqVwQeelcEEUpnBBQaZwQW6mcEGbpnBByKZwQfWmcEEhp3BBTqdwQXuncEGop3BB1adwQQKocEEvqHBBXKhwQYiocEG1qHBB4qhwQQ+pcEE8qXBBaalwQZapcEHDqXBB76lwQRyqcEFJqnBBdqpwQaOqcEHQqnBB/KpwQSmrcEFWq3BBg6twQbCrcEHdq3BBCqxwQTascEFjrHBBkKxwQb2scEHqrHBBF61wQUOtcEFwrXBBna1wQcqtcEH3rXBBJK5wQVCucEF9rnBBqq5wQdeucEEEr3BBMK9wQV2vcEGKr3BBt69wQeSvcEERsHBBPbBwQWqwcEGXsHBBxLBwQfGwcEEdsXBBSrFwQXexcEGksXBB0bFwQf2xcEEqsnBBV7JwQYSycEGxsnBB3bJwQQqzcEE3s3BBZLNwQZGzcEG9s3BB6rNwQRe0cEFEtHBBcLRwQZ20cEHKtHBB97RwQSS1cEFQtXBBfbVwQaq1cEHXtXBBA7ZwQTC2cEFdtnBBirZwQba2cEHjtnBBELdwQT23cEFpt3BBlrdwQcO3cEHwt3BBHLhwQUm4cEF2uHBBo7hwQc+4cEH8uHBBKblwQVa5cEGCuXBBr7lwQdy5cEEJunBBNbpwQWK6cEGPunBBvLpwQei6cEEVu3BBQrtwQW67cEGbu3BByLtwQfW7cEEhvHBBTrxwQXu8cEGovHBB1LxwQQG9cEEuvXBBWr1wQYe9cEG0vXBB4b1wQQ2+cEE6vnBBZ75wQZO+cEHAvnBB7b5wQRm/cEFGv3BBc79wQZ+/cEHMv3BB+b9wQSbAcEFSwHBBf8BwQazAcEHYwHBBBcFwQTLBcEFewXBBi8FwQbjBcEHkwXBBEcJwQT7CcEFqwnBBl8JwQcTCcEHwwnBBHcNwQUrDcEF2w3BBo8NwQdDDcEH8w3BBKcRwQVbEcEGCxHBBr8RwQdzEcEEIxXBBNcVwQWLFcEGOxXBBu8VwQejFcEEUxnBBQcZwQW7GcEGaxnBBx8ZwQfPGcEEgx3BBTcdwQXnHcEGmx3BB08dwQf/HcEEsyHBBWchwQYXIcEGyyHBB3shwQQvJcEE4yXBBZMlwQZHJcEG9yXBB6slwQRfKcEFDynBBcMpwQZ3KcEHJynBB9spwQSLLcEFPy3BBfMtwQajLcEHVy3BBAcxwQS7McEFbzHBBh8xwQbTMcEHgzHBBDc1wQTrNcEFmzXBBk81wQb/NcEHszXBBGM5wQUXOcEFyznBBns5wQcvOcEH3znBBJM9wQVHPcEF9z3BBqs9wQdbPcEED0HBBL9BwQVzQcEGJ0HBBtdBwQeLQcEEO0XBBO9FwQWfRcEGU0XBBwNFwQe3RcEEa0nBBRtJwQXPScEGf0nBBzNJwQfjScEEl03BBUdNwQX7TcEGr03BB19NwQQTUcEEw1HBBXdRwQYnUcEG21HBB4tRwQQ/VcEE71XBBaNVwQZTVcEHB1XBB7dVwQRrWcEFG1nBBc9ZwQaDWcEHM1nBB+dZwQSXXcEFS13BBftdwQavXcEHX13BBBNhwQTDYcEFd2HBBidhwQbbYcEHi2HBBD9lwQTvZcEFo2XBBlNlwQcHZcEHt2XBBGtpwQUbacEFz2nBBn9pwQczacEH42nBBJdtwQVHbcEF+23BBqttwQdfbcEED3HBBL9xwQVzccEGI3HBBtdxwQeHccEEO3XBBOt1wQWfdcEGT3XBBwN1wQezdcEEZ3nBBRd5wQXLecEGe3nBBy95wQffecEEj33BBUN9wQXzfcEGp33BB1d9wQQLgcEEu4HBBW+BwQYfgcEGz4HBB4OBwQQzhcEE54XBBZeFwQZLhcEG+4XBB6+FwQRficEFD4nBBcOJwQZzicEHJ4nBB9eJwQSLjcEFO43BBeuNwQafjcEHT43BBAORwQSzkcEFY5HBBheRwQbHkcEHe5HBBCuVwQTflcEFj5XBBj+VwQbzlcEHo5XBBFeZwQUHmcEFt5nBBmuZwQcbmcEHz5nBBH+dwQUvncEF453BBpOdwQdHncEH953BBKehwQVbocEGC6HBBruhwQdvocEEH6XBBNOlwQWDpcEGM6XBBuelwQeXpcEES6nBBPupwQWrqcEGX6nBBw+pwQe/qcEEc63BBSOtwQXTrcEGh63BBzetwQfrrcEEm7HBBUuxwQX/scEGr7HBB1+xwQQTtcEEw7XBBXO1wQYntcEG17XBB4e1wQQ7ucEE67nBBZu5wQZPucEG/7nBB6+5wQRjvcEFE73BBcO9wQZ3vcEHJ73BB9e9wQSLwcEFO8HBBevBwQafwcEHT8HBB//BwQSzxcEFY8XBBhPFwQbHxcEHd8XBBCfJwQTbycEFi8nBBjvJwQbvycEHn8nBBE/NwQT/zcEFs83BBmPNwQcTzcEHx83BBHfRwQUn0cEF29HBBovRwQc70cEH69HBBJ/VwQVP1cEF/9XBBrPVwQdj1cEEE9nBBMPZwQV32cEGJ9nBBtfZwQeL2cEEO93BBOvdwQWb3cEGT93BBv/dwQev3cEEX+HBBRPhwQXD4cEGc+HBByfhwQfX4cEEh+XBBTflwQXr5cEGm+XBB0vlwQf75cEEr+nBBV/pwQYP6cEGv+nBB3PpwQQj7cEE0+3BBYPtwQY37cEG5+3BB5ftwQRH8cEE+/HBBavxwQZb8cEHC/HBB7vxwQRv9cEFH/XBBc/1wQZ/9cEHM/XBB+P1wQST+cEFQ/nBBff5wQan+cEHV/nBBAf9wQS3/cEFa/3BBhv9wQbL/cEHe/3BBCgBxQTcAcUFjAHFBjwBxQbsAcUHnAHFBFAFxQUABcUFsAXFBmAFxQcQBcUHxAXFBHQJxQUkCcUF1AnFBoQJxQc4CcUH6AnFBJgNxQVIDcUF+A3FBqwNxQdcDcUEDBHFBLwRxQVsEcUGHBHFBtARxQeAEcUEMBXFBOAVxQWQFcUGQBXFBvQVxQekFcUEVBnFBQQZxQW0GcUGZBnFBxgZxQfIGcUEeB3FBSgdxQXYHcUGiB3FBzwdxQfsHcUEnCHFBUwhxQX8IcUGrCHFB1whxQQQJcUEwCXFBXAlxQYgJcUG0CXFB4AlxQQwKcUE5CnFBZQpxQZEKcUG9CnFB6QpxQRULcUFBC3FBbQtxQZoLcUHGC3FB8gtxQR4McUFKDHFBdgxxQaIMcUHODHFB+gxxQScNcUFTDXFBfw1xQasNcUHXDXFBAw5xQS8OcUFbDnFBhw5xQbQOcUHgDnFBDA9xQTgPcUFkD3FBkA9xQbwPcUHoD3FBFBBxQUAQcUFsEHFBmRBxQcUQcUHxEHFBHRFxQUkRcUF1EXFBoRFxQc0RcUH5EXFBJRJxQVEScUF9EnFBqRJxQdYScUECE3FBLhNxQVoTcUGGE3FBshNxQd4TcUEKFHFBNhRxQWIUcUGOFHFBuhRxQeYUcUESFXFBPhVxQWoVcUGWFXFBwxVxQe8VcUEbFnFBRxZxQXMWcUGfFnFByxZxQfcWcUEjF3FBTxdxQXsXcUGnF3FB0xdxQf8XcUErGHFBVxhxQYMYcUGvGHFB2xhxQQcZcUEzGXFBXxlxQYsZcUG3GXFB4xlxQQ8acUE7GnFBZxpxQZMacUG/GnFB6xpxQRcbcUFDG3FBbxtxQZsbcUHHG3FB8xtxQR8ccUFLHHFBdxxxQaMccUHPHHFB+xxxQScdcUFTHXFBfx1xQasdcUHXHXFBAx5xQS8ecUFbHnFBhx5xQbMecUHfHnFBCx9xQTcfcUFjH3FBjx9xQbsfcUHnH3FBEyBxQT8gcUFrIHFBlyBxQcMgcUHvIHFBGyFxQUchcUFzIXFBnyFxQcshcUH3IXFBIyJxQU8icUF6InFBpiJxQdIicUH+InFBKiNxQVYjcUGCI3FBriNxQdojcUEGJHFBMiRxQV4kcUGKJHFBtiRxQeIkcUEOJXFBOiVxQWUlcUGRJXFBvSVxQeklcUEVJnFBQSZxQW0mcUGZJnFBxSZxQfEmcUEdJ3FBSSdxQXUncUGgJ3FBzCdxQfgncUEkKHFBUChxQXwocUGoKHFB1ChxQQApcUEsKXFBWClxQYMpcUGvKXFB2ylxQQcqcUEzKnFBXypxQYsqcUG3KnFB4ypxQQ4rcUE6K3FBZitxQZIrcUG+K3FB6itxQRYscUFCLHFBbixxQZkscUHFLHFB8SxxQR0tcUFJLXFBdS1xQaEtcUHMLXFB+C1xQSQucUFQLnFBfC5xQagucUHULnFBAC9xQSsvcUFXL3FBgy9xQa8vcUHbL3FBBzBxQTMwcUFeMHFBijBxQbYwcUHiMHFBDjFxQToxcUFlMXFBkTFxQb0xcUHpMXFBFTJxQUEycUFsMnFBmDJxQcQycUHwMnFBHDNxQUgzcUFzM3FBnzNxQcszcUH3M3FBIzRxQU80cUF6NHFBpjRxQdI0cUH+NHFBKjVxQVU1cUGBNXFBrTVxQdk1cUEFNnFBMDZxQVw2cUGINnFBtDZxQeA2cUELN3FBNzdxQWM3cUGPN3FBuzdxQeY3cUESOHFBPjhxQWo4cUGWOHFBwThxQe04cUEZOXFBRTlxQXE5cUGcOXFByDlxQfQ5cUEgOnFBSzpxQXc6cUGjOnFBzzpxQfs6cUEmO3FBUjtxQX47cUGqO3FB1TtxQQE8cUEtPHFBWTxxQYQ8cUGwPHFB3DxxQQg9cUEzPXFBXz1xQYs9cUG3PXFB4j1xQQ4+cUE6PnFBZj5xQZE+cUG9PnFB6T5xQRU/cUFAP3FBbD9xQZg/cUHEP3FB7z9xQRtAcUFHQHFBc0BxQZ5AcUHKQHFB9kBxQSFBcUFNQXFBeUFxQaVBcUHQQXFB/EFxQShCcUFTQnFBf0JxQatCcUHXQnFBAkNxQS5DcUFaQ3FBhUNxQbFDcUHdQ3FBCURxQTREcUFgRHFBjERxQbdEcUHjRHFBD0VxQTpFcUFmRXFBkkVxQb5FcUHpRXFBFUZxQUFGcUFsRnFBmEZxQcRGcUHvRnFBG0dxQUdHcUFyR3FBnkdxQcpHcUH1R3FBIUhxQU1IcUF4SHFBpEhxQdBIcUH7SHFBJ0lxQVNJcUF+SXFBqklxQdZJcUEBSnFBLUpxQVlKcUGESnFBsEpxQdxKcUEHS3FBM0txQV9LcUGKS3FBtktxQeJLcUENTHFBOUxxQWRMcUGQTHFBvExxQedMcUETTXFBP01xQWpNcUGWTXFBwk1xQe1NcUEZTnFBRE5xQXBOcUGcTnFBx05xQfNOcUEfT3FBSk9xQXZPcUGhT3FBzU9xQflPcUEkUHFBUFBxQXxQcUGnUHFB01BxQf5QcUEqUXFBVlFxQYFRcUGtUXFB2FFxQQRScUEwUnFBW1JxQYdScUGyUnFB3lJxQQpTcUE1U3FBYVNxQYxTcUG4U3FB41NxQQ9UcUE7VHFBZlRxQZJUcUG9VHFB6VRxQRVVcUFAVXFBbFVxQZdVcUHDVXFB7lVxQRpWcUFGVnFBcVZxQZ1WcUHIVnFB9FZxQR9XcUFLV3FBd1dxQaJXcUHOV3FB+VdxQSVYcUFQWHFBfFhxQadYcUHTWHFB/lhxQSpZcUFWWXFBgVlxQa1ZcUHYWXFBBFpxQS9acUFbWnFBhlpxQbJacUHdWnFBCVtxQTVbcUFgW3FBjFtxQbdbcUHjW3FBDlxxQTpccUFlXHFBkVxxQbxccUHoXHFBE11xQT9dcUFqXXFBll1xQcFdcUHtXXFBGF5xQURecUFvXnFBm15xQcZecUHyXnFBHV9xQUlfcUF0X3FBoF9xQctfcUH3X3FBImBxQU5gcUF5YHFBpWBxQdBgcUH8YHFBJ2FxQVNhcUF+YXFBqmFxQdVhcUEBYnFBLGJxQVhicUGDYnFBr2JxQdpicUEGY3FBMWNxQV1jcUGIY3FBtGNxQd9jcUEKZHFBNmRxQWFkcUGNZHFBuGRxQeRkcUEPZXFBO2VxQWZlcUGSZXFBvWVxQellcUEUZnFBP2ZxQWtmcUGWZnFBwmZxQe1mcUEZZ3FBRGdxQXBncUGbZ3FBxmdxQfJncUEdaHFBSWhxQXRocUGgaHFBy2hxQfZocUEiaXFBTWlxQXlpcUGkaXFB0GlxQftpcUEmanFBUmpxQX1qcUGpanFB1GpxQQBrcUEra3FBVmtxQYJrcUGta3FB2WtxQQRscUEvbHFBW2xxQYZscUGybHFB3WxxQQhtcUE0bXFBX21xQYttcUG2bXFB4W1xQQ1ucUE4bnFBZG5xQY9ucUG6bnFB5m5xQRFvcUE9b3FBaG9xQZNvcUG/b3FB6m9xQRVwcUFBcHFBbHBxQZhwcUHDcHFB7nBxQRpxcUFFcXFBcHFxQZxxcUHHcXFB83FxQR5ycUFJcnFBdXJxQaBycUHLcnFB93JxQSJzcUFNc3FBeXNxQaRzcUHPc3FB+3NxQSZ0cUFSdHFBfXRxQah0cUHUdHFB/3RxQSp1cUFWdXFBgXVxQax1cUHYdXFBA3ZxQS52cUFadnFBhXZxQbB2cUHcdnFBB3dxQTJ3cUFed3FBiXdxQbR3cUHgd3FBC3hxQTZ4cUFieHFBjXhxQbh4cUHjeHFBD3lxQTp5cUFleXFBkXlxQbx5cUHneXFBE3pxQT56cUFpenFBlXpxQcB6cUHrenFBFntxQUJ7cUFte3FBmHtxQcR7cUHve3FBGnxxQUV8cUFxfHFBnHxxQcd8cUHzfHFBHn1xQUl9cUF0fXFBoH1xQct9cUH2fXFBIn5xQU1+cUF4fnFBo35xQc9+cUH6fnFBJX9xQVB/cUF8f3FBp39xQdJ/cUH+f3FBKYBxQVSAcUF/gHFBq4BxQdaAcUEBgXFBLIFxQViBcUGDgXFBroFxQdmBcUEFgnFBMIJxQVuCcUGGgnFBsoJxQd2CcUEIg3FBM4NxQV+DcUGKg3FBtYNxQeCDcUELhHFBN4RxQWKEcUGNhHFBuIRxQeSEcUEPhXFBOoVxQWWFcUGRhXFBvIVxQeeFcUEShnFBPYZxQWmGcUGUhnFBv4ZxQeqGcUEVh3FBQYdxQWyHcUGXh3FBwodxQe2HcUEZiHFBRIhxQW+IcUGaiHFBxYhxQfGIcUEciXFBR4lxQXKJcUGdiXFByYlxQfSJcUEfinFBSopxQXWKcUGhinFBzIpxQfeKcUEii3FBTYtxQXiLcUGki3FBz4txQfqLcUEljHFBUIxxQXyMcUGnjHFB0oxxQf2McUEojXFBU41xQX+NcUGqjXFB1Y1xQQCOcUErjnFBVo5xQYGOcUGtjnFB2I5xQQOPcUEuj3FBWY9xQYSPcUGwj3FB249xQQaQcUExkHFBXJBxQYeQcUGykHFB3pBxQQmRcUE0kXFBX5FxQYqRcUG1kXFB4JFxQQuScUE3knFBYpJxQY2ScUG4knFB45JxQQ6TcUE5k3FBZJNxQZCTcUG7k3FB5pNxQRGUcUE8lHFBZ5RxQZKUcUG9lHFB6ZRxQRSVcUE/lXFBapVxQZWVcUHAlXFB65VxQRaWcUFBlnFBbJZxQZiWcUHDlnFB7pZxQRmXcUFEl3FBb5dxQZqXcUHFl3FB8JdxQRuYcUFGmHFBcphxQZ2YcUHImHFB85hxQR6ZcUFJmXFBdJlxQZ+ZcUHKmXFB9ZlxQSCacUFLmnFBdppxQaKacUHNmnFB+JpxQSObcUFOm3FBeZtxQaSbcUHPm3FB+ptxQSWccUFQnHFBe5xxQaaccUHRnHFB/JxxQSedcUFSnXFBfZ1xQamdcUHUnXFB/51xQSqecUFVnnFBgJ5xQauecUHWnnFBAZ9xQSyfcUFXn3FBgp9xQa2fcUHYn3FBA6BxQS6gcUFZoHFBhKBxQa+gcUHaoHFBBaFxQTChcUFboXFBhqFxQbGhcUHcoXFBB6JxQTKicUFdonFBiKJxQbOicUHeonFBCaNxQTSjcUFfo3FBiqNxQbWjcUHgo3FBC6RxQTakcUFhpHFBjKRxQbekcUHipHFBDaVxQTilcUFjpXFBjqVxQbmlcUHkpXFBD6ZxQTqmcUFlpnFBkKZxQbumcUHmpnFBEadxQTyncUFnp3FBkqdxQb2ncUHop3FBE6hxQT6ocUFpqHFBlKhxQb+ocUHqqHFBFalxQUCpcUFrqXFBlqlxQcGpcUHsqXFBFqpxQUGqcUFsqnFBl6pxQcKqcUHtqnFBGKtxQUOrcUFuq3FBmatxQcSrcUHvq3FBGqxxQUWscUFwrHFBm6xxQcascUHxrHFBG61xQUatcUFxrXFBnK1xQcetcUHyrXFBHa5xQUiucUFzrnFBnq5xQcmucUH0rnFBH69xQUqvcUF0r3FBn69xQcqvcUH1r3FBILBxQUuwcUF2sHFBobBxQcywcUH3sHFBIrFxQUyxcUF3sXFBorFxQc2xcUH4sXFBI7JxQU6ycUF5snFBpLJxQc6ycUH5snFBJLNxQU+zcUF6s3FBpbNxQdCzcUH7s3FBJrRxQVC0cUF7tHFBprRxQdG0cUH8tHFBJ7VxQVK1cUF9tXFBp7VxQdK1cUH9tXFBKLZxQVO2cUF+tnFBqbZxQdS2cUH+tnFBKbdxQVS3cUF/t3FBqrdxQdW3cUEAuHFBKrhxQVW4cUGAuHFBq7hxQda4cUEBuXFBK7lxQVa5cUGBuXFBrLlxQde5cUECunFBLbpxQVe6cUGCunFBrbpxQdi6cUEDu3FBLrtxQVi7cUGDu3FBrrtxQdm7cUEEvHFBLrxxQVm8cUGEvHFBr7xxQdq8cUEFvXFBL71xQVq9cUGFvXFBsL1xQdu9cUEFvnFBML5xQVu+cUGGvnFBsb5xQdy+cUEGv3FBMb9xQVy/cUGHv3FBsr9xQdy/cUEHwHFBMsBxQV3AcUGHwHFBssBxQd3AcUEIwXFBM8FxQV3BcUGIwXFBs8FxQd7BcUEJwnFBM8JxQV7CcUGJwnFBtMJxQd7CcUEJw3FBNMNxQV/DcUGKw3FBtMNxQd/DcUEKxHFBNcRxQV/EcUGKxHFBtcRxQeDEcUEKxXFBNcVxQWDFcUGLxXFBtcVxQeDFcUELxnFBNsZxQWDGcUGLxnFBtsZxQeHGcUELx3FBNsdxQWHHcUGMx3FBtsdxQeHHcUEMyHFBN8hxQWHIcUGMyHFBt8hxQeLIcUEMyXFBN8lxQWLJcUGMyXFBt8lxQeLJcUENynFBN8pxQWLKcUGNynFBuMpxQeLKcUENy3FBOMtxQWLLcUGNy3FBuMtxQePLcUENzHFBOMxxQWPMcUGNzHFBuMxxQePMcUENzXFBOM1xQWPNcUGOzXFBuM1xQePNcUEOznFBOM5xQWPOcUGOznFBuM5xQePOcUEOz3FBOM9xQWPPcUGOz3FBuc9xQePPcUEO0HFBOdBxQWPQcUGO0HFBudBxQePQcUEO0XFBOdFxQWPRcUGO0XFBudFxQePRcUEO0nFBOdJxQWPScUGO0nFBudJxQePScUEO03FBOdNxQWPTcUGO03FBudNxQePTcUEO1HFBOdRxQWPUcUGO1HFBuNRxQePUcUEO1XFBONVxQWPVcUGO1XFBuNVxQePVcUEO1nFBONZxQWPWcUGN1nFBuNZxQePWcUEN13FBONdxQWPXcUGN13FBuNdxQePXcUEN2HFBONhxQWLYcUGN2HFBuNhxQeLYcUEN2XFBN9lxQWLZcUGN2XFBt9lxQeLZcUEN2nFBN9pxQWLacUGM2nFBt9pxQeLacUEM23FBN9txQWHbcUGM23FBt9txQeHbcUEM3HFBNtxxQWHccUGL3HFBttxxQeHccUEL3XFBNt1xQWDdcUGL3XFBtt1xQeDdcUEL3nFBNd5xQWDecUGK3nFBtd5xQeDecUEK33FBNd9xQV/fcUGK33FBtN9xQd/fcUEK4HFBNOBxQV/gcUGJ4HFBtOBxQd7gcUEJ4XFBNOFxQV7hcUGJ4XFBs+FxQd7hcUEI4nFBM+JxQV3icUGI4nFBsuJxQd3icUEI43FBMuNxQV3jcUGH43FBsuNxQdzjcUEH5HFBMeRxQVzkcUGG5HFBseRxQdvkcUEG5XFBMeVxQVvlcUGG5XFBsOVxQdvlcUEF5nFBMOZxQVrmcUGF5nFBr+ZxQdrmcUEE53FBL+dxQVnncUGE53FBrudxQdnncUED6HFBLuhxQVjocUGD6HFBrehxQdjocUEC6XFBLelxQVfpcUGC6XFBrOlxQdfpcUEB6nFBLOpxQVbqcUGB6nFBq+pxQdbqcUEA63FBK+txQVXrcUGA63FBqutxQdXrcUH/63FBKuxxQVTscUF/7HFBqexxQdPscUH+7HFBKO1xQVPtcUF97XFBqO1xQdLtcUH97XFBJ+5xQVLucUF87nFBp+5xQdHucUH87nFBJu9xQVDvcUF773FBpe9xQdDvcUH673FBJfBxQU/wcUF68HFBpPBxQc7wcUH58HFBI/FxQU7xcUF48XFBo/FxQc3xcUH48XFBIvJxQUzycUF38nFBofJxQczycUH28nFBIfNxQUvzcUF183FBoPNxQcrzcUH183FBH/RxQUr0cUF09HFBnvRxQcn0cUHz9HFBHvVxQUj1cUFy9XFBnfVxQcf1cUHy9XFBHPZxQUb2cUFx9nFBm/ZxQcb2cUHw9nFBGvdxQUX3cUFv93FBmvdxQcT3cUHu93FBGfhxQUP4cUFu+HFBmPhxQcL4cUHt+HFBF/lxQUL5cUFs+XFBlvlxQcH5cUHr+XFBFfpxQUD6cUFq+nFBlfpxQb/6cUHp+nFBFPtxQT77cUFo+3FBk/txQb37cUHo+3FBEvxxQTz8cUFn/HFBkfxxQbv8cUHm/HFBEP1xQTr9cUFl/XFBj/1xQbn9cUHk/XFBDv5xQTn+cUFj/nFBjf5xQbj+cUHi/nFBDP9xQTf/cUFh/3FBi/9xQbb/cUHg/3FBCgByQTUAckFfAHJBiQByQbQAckHeAHJBCAFyQTMBckFdAXJBhwFyQbIBckHcAXJBBgJyQTECckFbAnJBhQJyQa8CckHaAnJBBANyQS4DckFZA3JBgwNyQa0DckHYA3JBAgRyQSwEckFXBHJBgQRyQasEckHVBHJBAAVyQSoFckFUBXJBfwVyQakFckHTBXJB/gVyQSgGckFSBnJBfAZyQacGckHRBnJB+wZyQSYHckFQB3JBegdyQaQHckHPB3JB+QdyQSMIckFOCHJBeAhyQaIIckHMCHJB9whyQSEJckFLCXJBdQlyQaAJckHKCXJB9AlyQR4KckFJCnJBcwpyQZ0KckHICnJB8gpyQRwLckFGC3JBcQtyQZsLckHFC3JB7wtyQRoMckFEDHJBbgxyQZgMckHDDHJB7QxyQRcNckFBDXJBaw1yQZYNckHADXJB6g1yQRQOckE/DnJBaQ5yQZMOckG9DnJB6A5yQRIPckE8D3JBZg9yQZAPckG7D3JB5Q9yQQ8QckE5EHJBZBByQY4QckG4EHJB4hByQQwRckE3EXJBYRFyQYsRckG1EXJB3xFyQQoSckE0EnJBXhJyQYgSckGzEnJB3RJyQQcTckExE3JBWxNyQYUTckGwE3JB2hNyQQQUckEuFHJBWBRyQYMUckGtFHJB1xRyQQEVckErFXJBVhVyQYAVckGqFXJB1BVyQf4VckEoFnJBUxZyQX0WckGnFnJB0RZyQfsWckElF3JBUBdyQXoXckGkF3JBzhdyQfgXckEiGHJBTRhyQXcYckGhGHJByxhyQfUYckEfGXJBShlyQXQZckGeGXJByBlyQfIZckEcGnJBRxpyQXEackGbGnJBxRpyQe8ackEZG3JBQxtyQW0bckGYG3JBwhtyQewbckEWHHJBQBxyQWocckGUHHJBvxxyQekcckETHXJBPR1yQWcdckGRHXJBux1yQeUdckEQHnJBOh5yQWQeckGOHnJBuB5yQeIeckEMH3JBNh9yQWAfckGLH3JBtR9yQd8fckEJIHJBMyByQV0gckGHIHJBsSByQdsgckEGIXJBMCFyQVohckGEIXJBriFyQdghckECInJBLCJyQVYickGAInJBqiJyQdUickH/InJBKSNyQVMjckF9I3JBpyNyQdEjckH7I3JBJSRyQU8kckF5JHJBoyRyQc0kckH4JHJBIiVyQUwlckF2JXJBoCVyQcolckH0JXJBHiZyQUgmckFyJnJBnCZyQcYmckHwJnJBGidyQUQnckFuJ3JBmSdyQcMnckHtJ3JBFyhyQUEockFrKHJBlShyQb8ockHpKHJBEylyQT0pckFnKXJBkSlyQbspckHlKXJBDypyQTkqckFjKnJBjSpyQbcqckHhKnJBCytyQTUrckFfK3JBiStyQbMrckHeK3JBCCxyQTIsckFcLHJBhixyQbAsckHaLHJBBC1yQS4tckFYLXJBgi1yQawtckHWLXJBAC5yQSouckFULnJBfi5yQaguckHSLnJB/C5yQSYvckFQL3JBei9yQaQvckHOL3JB+C9yQSIwckFMMHJBdjByQaAwckHKMHJB9DByQR4xckFIMXJBcjFyQZwxckHGMXJB7zFyQRkyckFDMnJBbTJyQZcyckHBMnJB6zJyQRUzckE/M3JBaTNyQZMzckG9M3JB5zNyQRE0ckE7NHJBZTRyQY80ckG5NHJB4zRyQQ01ckE3NXJBYTVyQYs1ckG1NXJB3zVyQQk2ckEzNnJBXDZyQYY2ckGwNnJB2jZyQQQ3ckEuN3JBWDdyQYI3ckGsN3JB1jdyQQA4ckEqOHJBVDhyQX44ckGoOHJB0jhyQfs4ckElOXJBTzlyQXk5ckGjOXJBzTlyQfc5ckEhOnJBSzpyQXU6ckGfOnJByTpyQfM6ckEcO3JBRjtyQXA7ckGaO3JBxDtyQe47ckEYPHJBQjxyQWw8ckGWPHJBwDxyQek8ckETPXJBPT1yQWc9ckGRPXJBuz1yQeU9ckEPPnJBOT5yQWI+ckGMPnJBtj5yQeA+ckEKP3JBND9yQV4/ckGIP3JBsj9yQds/ckEFQHJBL0ByQVlAckGDQHJBrUByQddAckEBQXJBKkFyQVRBckF+QXJBqEFyQdJBckH8QXJBJkJyQVBCckF5QnJBo0JyQc1CckH3QnJBIUNyQUtDckF1Q3JBnkNyQchDckHyQ3JBHERyQUZEckFwRHJBmURyQcNEckHtRHJBF0VyQUFFckFrRXJBlUVyQb5FckHoRXJBEkZyQTxGckFmRnJBkEZyQblGckHjRnJBDUdyQTdHckFhR3JBi0dyQbRHckHeR3JBCEhyQTJIckFcSHJBhUhyQa9IckHZSHJBA0lyQS1JckFXSXJBgElyQapJckHUSXJB/klyQShKckFRSnJBe0pyQaVKckHPSnJB+UpyQSJLckFMS3JBdktyQaBLckHKS3JB80tyQR1MckFHTHJBcUxyQZtMckHETHJB7kxyQRhNckFCTXJBa01yQZVNckG/TXJB6U1yQRNOckE8TnJBZk5yQZBOckG6TnJB405yQQ1PckE3T3JBYU9yQYtPckG0T3JB3k9yQQhQckEyUHJBW1ByQYVQckGvUHJB2VByQQJRckEsUXJBVlFyQYBRckGpUXJB01FyQf1RckEnUnJBUFJyQXpSckGkUnJBzlJyQfdSckEhU3JBS1NyQXVTckGeU3JByFNyQfJTckEcVHJBRVRyQW9UckGZVHJBw1RyQexUckEWVXJBQFVyQWlVckGTVXJBvVVyQedVckEQVnJBOlZyQWRWckGOVnJBt1ZyQeFWckELV3JBNFdyQV5XckGIV3JBsldyQdtXckEFWHJBL1hyQVhYckGCWHJBrFhyQdZYckH/WHJBKVlyQVNZckF8WXJBpllyQdBZckH5WXJBI1pyQU1ackF2WnJBoFpyQcpackH0WnJBHVtyQUdbckFxW3JBmltyQcRbckHuW3JBF1xyQUFcckFrXHJBlFxyQb5cckHoXHJBEV1yQTtdckFlXXJBjl1yQbhdckHiXXJBC15yQTVeckFfXnJBiF5yQbJeckHcXnJBBV9yQS9fckFZX3JBgl9yQaxfckHWX3JB/19yQSlgckFTYHJBfGByQaZgckHQYHJB+WByQSNhckFNYXJBdmFyQaBhckHJYXJB82FyQR1ickFGYnJBcGJyQZpickHDYnJB7WJyQRdjckFAY3JBamNyQZNjckG9Y3JB52NyQRBkckE6ZHJBZGRyQY1kckG3ZHJB4GRyQQplckE0ZXJBXWVyQYdlckGwZXJB2mVyQQRmckEtZnJBV2ZyQYFmckGqZnJB1GZyQf1mckEnZ3JBUWdyQXpnckGkZ3JBzWdyQfdnckEhaHJBSmhyQXRockGdaHJBx2hyQfBockEaaXJBRGlyQW1pckGXaXJBwGlyQeppckEUanJBPWpyQWdqckGQanJBumpyQeNqckENa3JBN2tyQWBrckGKa3JBs2tyQd1rckEGbHJBMGxyQVpsckGDbHJBrWxyQdZsckEAbXJBKW1yQVNtckF9bXJBpm1yQdBtckH5bXJBI25yQUxuckF2bnJBn25yQcluckHzbnJBHG9yQUZvckFvb3JBmW9yQcJvckHsb3JBFXByQT9wckFocHJBknByQbtwckHlcHJBD3FyQThxckFicXJBi3FyQbVxckHecXJBCHJyQTFyckFbcnJBhHJyQa5yckHXcnJBAXNyQSpzckFUc3JBfXNyQadzckHQc3JB+nNyQSN0ckFNdHJBdnRyQaB0ckHJdHJB83RyQRx1ckFGdXJBb3VyQZl1ckHCdXJB7HVyQRV2ckE/dnJBaHZyQZJ2ckG7dnJB5XZyQQ53ckE4d3JBYXdyQYt3ckG0d3JB3ndyQQd4ckExeHJBWnhyQYR4ckGteHJB13hyQQB5ckEqeXJBU3lyQX15ckGmeXJB0HlyQfl5ckEjenJBTHpyQXV6ckGfenJByHpyQfJ6ckEbe3JBRXtyQW57ckGYe3JBwXtyQet7ckEUfHJBPnxyQWd8ckGQfHJBunxyQeN8ckENfXJBNn1yQWB9ckGJfXJBs31yQdx9ckEFfnJBL35yQVh+ckGCfnJBq35yQdV+ckH+fnJBKH9yQVF/ckF6f3JBpH9yQc1/ckH3f3JBIIByQUqAckFzgHJBnIByQcaAckHvgHJBGYFyQUKBckFrgXJBlYFyQb6BckHogXJBEYJyQTuCckFkgnJBjYJyQbeCckHggnJBCoNyQTODckFcg3JBhoNyQa+DckHZg3JBAoRyQSuEckFVhHJBfoRyQaiEckHRhHJB+oRyQSSFckFNhXJBd4VyQaCFckHJhXJB84VyQRyGckFGhnJBb4ZyQZiGckHChnJB64ZyQRSHckE+h3JBZ4dyQZGHckG6h3JB44dyQQ2IckE2iHJBX4hyQYmIckGyiHJB24hyQQWJckEuiXJBWIlyQYGJckGqiXJB1IlyQf2JckEminJBUIpyQXmKckGiinJBzIpyQfWKckEfi3JBSItyQXGLckGbi3JBxItyQe2LckEXjHJBQIxyQWmMckGTjHJBvIxyQeWMckEPjXJBOI1yQWGNckGLjXJBtI1yQd2NckEHjnJBMI5yQVmOckGDjnJBrI5yQdWOckH/jnJBKI9yQVGPckF7j3JBpI9yQc2PckH2j3JBIJByQUmQckFykHJBnJByQcWQckHukHJBGJFyQUGRckFqkXJBlJFyQb2RckHmkXJBD5JyQTmSckFiknJBi5JyQbWSckHeknJBB5NyQTGTckFak3JBg5NyQayTckHWk3JB/5NyQSiUckFSlHJBe5RyQaSUckHNlHJB95RyQSCVckFJlXJBc5VyQZyVckHFlXJB7pVyQRiWckFBlnJBapZyQZOWckG9lnJB5pZyQQ+XckE5l3JBYpdyQYuXckG0l3JB3pdyQQeYckEwmHJBWZhyQYOYckGsmHJB1ZhyQf6YckEomXJBUZlyQXqZckGjmXJBzZlyQfaZckEfmnJBSJpyQXKackGbmnJBxJpyQe2ackEXm3JBQJtyQWmbckGSm3JBvJtyQeWbckEOnHJBN5xyQWCcckGKnHJBs5xyQdycckEFnXJBL51yQVidckGBnXJBqp1yQdOdckH9nXJBJp5yQU+eckF4nnJBop5yQcueckH0nnJBHZ9yQUafckFwn3JBmZ9yQcKfckHrn3JBFKByQT6gckFnoHJBkKByQbmgckHioHJBDKFyQTWhckFeoXJBh6FyQbChckHaoXJBA6JyQSyickFVonJBfqJyQaiickHRonJB+qJyQSOjckFMo3JBdaNyQZ+jckHIo3JB8aNyQRqkckFDpHJBbaRyQZakckG/pHJB6KRyQRGlckE6pXJBZKVyQY2lckG2pXJB36VyQQimckExpnJBWqZyQYSmckGtpnJB1qZyQf+mckEop3JBUadyQXunckGkp3JBzadyQfanckEfqHJBSKhyQXGockGbqHJBxKhyQe2ockEWqXJBP6lyQWipckGRqXJBu6lyQeSpckENqnJBNqpyQV+qckGIqnJBsapyQduqckEEq3JBLatyQVarckF/q3JBqKtyQdGrckH6q3JBJKxyQU2sckF2rHJBn6xyQcisckHxrHJBGq1yQUOtckFsrXJBlq1yQb+tckHorXJBEa5yQTquckFjrnJBjK5yQbWuckHernJBB69yQTGvckFar3JBg69yQayvckHVr3JB/q9yQSewckFQsHJBebByQaKwckHMsHJB9bByQR6xckFHsXJBcLFyQZmxckHCsXJB67FyQRSyckE9snJBZrJyQY+yckG4snJB4rJyQQuzckE0s3JBXbNyQYazckGvs3JB2LNyQQG0ckEqtHJBU7RyQXy0ckGltHJBzrRyQfe0ckEgtXJBSbVyQXO1ckGctXJBxbVyQe61ckEXtnJBQLZyQWm2ckGStnJBu7ZyQeS2ckENt3JBNrdyQV+3ckGIt3JBsbdyQdq3ckEDuHJBLLhyQVW4ckF+uHJBp7hyQdC4ckH5uHJBI7lyQUy5ckF1uXJBnrlyQce5ckHwuXJBGbpyQUK6ckFrunJBlLpyQb26ckHmunJBD7tyQTi7ckFhu3JBirtyQbO7ckHcu3JBBbxyQS68ckFXvHJBgLxyQam8ckHSvHJB+7xyQSS9ckFNvXJBdr1yQZ+9ckHIvXJB8b1yQRq+ckFDvnJBbL5yQZW+ckG+vnJB575yQRC/ckE5v3JBYr9yQYu/ckG0v3JB3b9yQQbAckEvwHJBWMByQYHAckGqwHJB08ByQfzAckElwXJBTsFyQXfBckGfwXJByMFyQfHBckEawnJBQ8JyQWzCckGVwnJBvsJyQefCckEQw3JBOcNyQWLDckGLw3JBtMNyQd3DckEGxHJBL8RyQVjEckGBxHJBqsRyQdPEckH8xHJBJcVyQU3FckF2xXJBn8VyQcjFckHxxXJBGsZyQUPGckFsxnJBlcZyQb7GckHnxnJBEMdyQTnHckFix3JBi8dyQbTHckHcx3JBBchyQS7IckFXyHJBgMhyQanIckHSyHJB+8hyQSTJckFNyXJBdslyQZ/JckHIyXJB8MlyQRnKckFCynJBa8pyQZTKckG9ynJB5spyQQ/LckE4y3JBYctyQYnLckGyy3JB28tyQQTMckEtzHJBVsxyQX/MckGozHJB0cxyQfrMckEizXJBS81yQXTNckGdzXJBxs1yQe/NckEYznJBQc5yQWrOckGSznJBu85yQeTOckENz3JBNs9yQV/PckGIz3JBsc9yQdnPckEC0HJBK9ByQVTQckF90HJBptByQc/QckH30HJBINFyQUnRckFy0XJBm9FyQcTRckHt0XJBFtJyQT7SckFn0nJBkNJyQbnSckHi0nJBC9NyQTPTckFc03JBhdNyQa7TckHX03JBANRyQSnUckFR1HJBetRyQaPUckHM1HJB9dRyQR7VckFG1XJBb9VyQZjVckHB1XJB6tVyQRPWckE71nJBZNZyQY3WckG21nJB39ZyQQjXckEw13JBWddyQYLXckGr13JB1NdyQfzXckEl2HJBTthyQXfYckGg2HJByNhyQfHYckEa2XJBQ9lyQWzZckGV2XJBvdlyQebZckEP2nJBONpyQWHackGJ2nJBstpyQdvackEE23JBLdtyQVXbckF+23JBp9tyQdDbckH423JBIdxyQUrcckFz3HJBnNxyQcTcckHt3HJBFt1yQT/dckFo3XJBkN1yQbndckHi3XJBC95yQTPeckFc3nJBhd5yQa7eckHW3nJB/95yQSjfckFR33JBet9yQaLfckHL33JB9N9yQR3gckFF4HJBbuByQZfgckHA4HJB6OByQRHhckE64XJBY+FyQYvhckG04XJB3eFyQQbickEu4nJBV+JyQYDickGp4nJB0eJyQfrickEj43JBTONyQXTjckGd43JBxuNyQe7jckEX5HJBQORyQWnkckGR5HJBuuRyQePkckEM5XJBNOVyQV3lckGG5XJBruVyQdflckEA5nJBKeZyQVHmckF65nJBo+ZyQcvmckH05nJBHedyQUbnckFu53JBl+dyQcDnckHo53JBEehyQTrockFj6HJBi+hyQbTockHd6HJBBelyQS7pckFX6XJBf+lyQajpckHR6XJB+ulyQSLqckFL6nJBdOpyQZzqckHF6nJB7upyQRbrckE/63JBaOtyQZDrckG563JB4utyQQrsckEz7HJBXOxyQYTsckGt7HJB1uxyQf7sckEn7XJBUO1yQXjtckGh7XJByu1yQfLtckEb7nJBRO5yQWzuckGV7nJBvu5yQebuckEP73JBOO9yQWDvckGJ73JBsu9yQdrvckED8HJBLPByQVTwckF98HJBpvByQc7wckH38HJBIPFyQUjxckFx8XJBmfFyQcLxckHr8XJBE/JyQTzyckFl8nJBjfJyQbbyckHf8nJBB/NyQTDzckFY83JBgfNyQarzckHS83JB+/NyQST0ckFM9HJBdfRyQZ30ckHG9HJB7/RyQRf1ckFA9XJBaPVyQZH1ckG69XJB4vVyQQv2ckE09nJBXPZyQYX2ckGt9nJB1vZyQf/2ckEn93JBUPdyQXj3ckGh93JByvdyQfL3ckEb+HJBQ/hyQWz4ckGU+HJBvfhyQeb4ckEO+XJBN/lyQV/5ckGI+XJBsflyQdn5ckEC+nJBKvpyQVP6ckF8+nJBpPpyQc36ckH1+nJBHvtyQUb7ckFv+3JBmPtyQcD7ckHp+3JBEfxyQTr8ckFi/HJBi/xyQbP8ckHc/HJBBf1yQS39ckFW/XJBfv1yQaf9ckHP/XJB+P1yQSH+ckFJ/nJBcv5yQZr+ckHD/nJB6/5yQRT/ckE8/3JBZf9yQY3/ckG2/3JB3/9yQQcAc0EwAHNBWABzQYEAc0GpAHNB0gBzQfoAc0EjAXNBSwFzQXQBc0GcAXNBxQFzQe0Bc0EWAnNBPwJzQWcCc0GQAnNBuAJzQeECc0EJA3NBMgNzQVoDc0GDA3NBqwNzQdQDc0H8A3NBJQRzQU0Ec0F2BHNBngRzQccEc0HvBHNBGAVzQUAFc0FpBXNBkQVzQboFc0HiBXNBCwZzQTMGc0FcBnNBhAZzQa0Gc0HVBnNB/gZzQSYHc0FPB3NBdwdzQaAHc0HIB3NB8QdzQRkIc0FCCHNBaghzQZMIc0G7CHNB5AhzQQwJc0E1CXNBXQlzQYUJc0GuCXNB1glzQf8Jc0EnCnNBUApzQXgKc0GhCnNByQpzQfIKc0EaC3NBQwtzQWsLc0GUC3NBvAtzQeQLc0ENDHNBNQxzQV4Mc0GGDHNBrwxzQdcMc0EADXNBKA1zQVENc0F5DXNBoQ1zQcoNc0HyDXNBGw5zQUMOc0FsDnNBlA5zQb0Oc0HlDnNBDQ9zQTYPc0FeD3NBhw9zQa8Pc0HYD3NBABBzQSgQc0FREHNBeRBzQaIQc0HKEHNB8xBzQRsRc0FDEXNBbBFzQZQRc0G9EXNB5RFzQQ4Sc0E2EnNBXhJzQYcSc0GvEnNB2BJzQQATc0EoE3NBURNzQXkTc0GiE3NByhNzQfITc0EbFHNBQxRzQWwUc0GUFHNBvBRzQeUUc0ENFXNBNhVzQV4Vc0GGFXNBrxVzQdcVc0EAFnNBKBZzQVAWc0F5FnNBoRZzQcoWc0HyFnNBGhdzQUMXc0FrF3NBkxdzQbwXc0HkF3NBDRhzQTUYc0FdGHNBhhhzQa4Yc0HWGHNB/xhzQScZc0FQGXNBeBlzQaAZc0HJGXNB8RlzQRkac0FCGnNBahpzQZIac0G7GnNB4xpzQQsbc0E0G3NBXBtzQYUbc0GtG3NB1RtzQf4bc0EmHHNBThxzQXccc0GfHHNBxxxzQfAcc0EYHXNBQB1zQWkdc0GRHXNBuR1zQeIdc0EKHnNBMh5zQVsec0GDHnNBqx5zQdQec0H8HnNBJB9zQU0fc0F1H3NBnR9zQcYfc0HuH3NBFiBzQT8gc0FnIHNBjyBzQbggc0HgIHNBCCFzQTEhc0FZIXNBgSFzQakhc0HSIXNB+iFzQSIic0FLInNBcyJzQZsic0HEInNB7CJzQRQjc0E8I3NBZSNzQY0jc0G1I3NB3iNzQQYkc0EuJHNBVyRzQX8kc0GnJHNBzyRzQfgkc0EgJXNBSCVzQXElc0GZJXNBwSVzQeklc0ESJnNBOiZzQWImc0GLJnNBsyZzQdsmc0EDJ3NBLCdzQVQnc0F8J3NBpCdzQc0nc0H1J3NBHShzQUUoc0FuKHNBlihzQb4oc0HnKHNBDylzQTcpc0FfKXNBiClzQbApc0HYKXNBACpzQSkqc0FRKnNBeSpzQaEqc0HKKnNB8ipzQRorc0FCK3NBaytzQZMrc0G7K3NB4ytzQQwsc0E0LHNBXCxzQYQsc0GsLHNB1SxzQf0sc0ElLXNBTS1zQXYtc0GeLXNBxi1zQe4tc0EXLnNBPy5zQWcuc0GPLnNBty5zQeAuc0EIL3NBMC9zQVgvc0GBL3NBqS9zQdEvc0H5L3NBITBzQUowc0FyMHNBmjBzQcIwc0HqMHNBEzFzQTsxc0FjMXNBizFzQbMxc0HcMXNBBDJzQSwyc0FUMnNBfDJzQaUyc0HNMnNB9TJzQR0zc0FFM3NBbjNzQZYzc0G+M3NB5jNzQQ40c0E2NHNBXzRzQYc0c0GvNHNB1zRzQf80c0EoNXNBUDVzQXg1c0GgNXNByDVzQfA1c0EZNnNBQTZzQWk2c0GRNnNBuTZzQeE2c0EKN3NBMjdzQVo3c0GCN3NBqjdzQdI3c0H7N3NBIzhzQUs4c0FzOHNBmzhzQcM4c0HsOHNBFDlzQTw5c0FkOXNBjDlzQbQ5c0HcOXNBBTpzQS06c0FVOnNBfTpzQaU6c0HNOnNB9TpzQR47c0FGO3NBbjtzQZY7c0G+O3NB5jtzQQ48c0E2PHNBXzxzQYc8c0GvPHNB1zxzQf88c0EnPXNBTz1zQXc9c0GgPXNByD1zQfA9c0EYPnNBQD5zQWg+c0GQPnNBuD5zQeA+c0EJP3NBMT9zQVk/c0GBP3NBqT9zQdE/c0H5P3NBIUBzQUlAc0FyQHNBmkBzQcJAc0HqQHNBEkFzQTpBc0FiQXNBikFzQbJBc0HaQXNBAkJzQStCc0FTQnNBe0JzQaNCc0HLQnNB80JzQRtDc0FDQ3NBa0NzQZNDc0G7Q3NB40NzQQxEc0E0RHNBXERzQYREc0GsRHNB1ERzQfxEc0EkRXNBTEVzQXRFc0GcRXNBxEVzQexFc0EURnNBPUZzQWVGc0GNRnNBtUZzQd1Gc0EFR3NBLUdzQVVHc0F9R3NBpUdzQc1Hc0H1R3NBHUhzQUVIc0FtSHNBlUhzQb1Ic0HlSHNBDUlzQTVJc0FeSXNBhklzQa5Jc0HWSXNB/klzQSZKc0FOSnNBdkpzQZ5Kc0HGSnNB7kpzQRZLc0E+S3NBZktzQY5Lc0G2S3NB3ktzQQZMc0EuTHNBVkxzQX5Mc0GmTHNBzkxzQfZMc0EeTXNBRk1zQW5Nc0GWTXNBvk1zQeZNc0EOTnNBNk5zQV5Oc0GGTnNBrk5zQdZOc0H+TnNBJk9zQU5Pc0F2T3NBnk9zQcZPc0HuT3NBFlBzQT5Qc0FmUHNBjlBzQbZQc0HeUHNBBlFzQS5Rc0FWUXNBflFzQaZRc0HOUXNB9lFzQR5Sc0FGUnNBblJzQZZSc0G+UnNB5lJzQQ5Tc0E2U3NBXlNzQYZTc0GuU3NB1lNzQf5Tc0EmVHNBTlRzQXZUc0GeVHNBxlRzQe5Uc0EWVXNBPVVzQWVVc0GNVXNBtVVzQd1Vc0EFVnNBLVZzQVVWc0F9VnNBpVZzQc1Wc0H1VnNBHVdzQUVXc0FtV3NBlVdzQb1Xc0HlV3NBDVhzQTVYc0FcWHNBhFhzQaxYc0HUWHNB/FhzQSRZc0FMWXNBdFlzQZxZc0HEWXNB7FlzQRRac0E8WnNBZFpzQYtac0GzWnNB21pzQQNbc0ErW3NBU1tzQXtbc0GjW3NBy1tzQfNbc0EbXHNBQ1xzQWpcc0GSXHNBulxzQeJcc0EKXXNBMl1zQVpdc0GCXXNBql1zQdJdc0H6XXNBIV5zQUlec0FxXnNBmV5zQcFec0HpXnNBEV9zQTlfc0FhX3NBiF9zQbBfc0HYX3NBAGBzQShgc0FQYHNBeGBzQaBgc0HIYHNB72BzQRdhc0E/YXNBZ2FzQY9hc0G3YXNB32FzQQdic0EuYnNBVmJzQX5ic0GmYnNBzmJzQfZic0EeY3NBRmNzQW1jc0GVY3NBvWNzQeVjc0ENZHNBNWRzQV1kc0GEZHNBrGRzQdRkc0H8ZHNBJGVzQUxlc0F0ZXNBm2VzQcNlc0HrZXNBE2ZzQTtmc0FjZnNBimZzQbJmc0HaZnNBAmdzQSpnc0FSZ3NBeWdzQaFnc0HJZ3NB8WdzQRloc0FBaHNBaGhzQZBoc0G4aHNB4GhzQQhpc0EwaXNBV2lzQX9pc0GnaXNBz2lzQfdpc0EfanNBRmpzQW5qc0GWanNBvmpzQeZqc0ENa3NBNWtzQV1rc0GFa3NBrWtzQdRrc0H8a3NBJGxzQUxsc0F0bHNBnGxzQcNsc0HrbHNBE21zQTttc0FjbXNBim1zQbJtc0HabXNBAm5zQSluc0FRbnNBeW5zQaFuc0HJbnNB8G5zQRhvc0FAb3NBaG9zQZBvc0G3b3NB329zQQdwc0EvcHNBVnBzQX5wc0GmcHNBznBzQfZwc0EdcXNBRXFzQW1xc0GVcXNBvHFzQeRxc0EMcnNBNHJzQVtyc0GDcnNBq3JzQdNyc0H6cnNBInNzQUpzc0Fyc3NBmnNzQcFzc0Hpc3NBEXRzQTl0c0FgdHNBiHRzQbB0c0HYdHNB/3RzQSd1c0FPdXNBdnVzQZ51c0HGdXNB7nVzQRV2c0E9dnNBZXZzQY12c0G0dnNB3HZzQQR3c0Esd3NBU3dzQXt3c0Gjd3NBy3dzQfJ3c0EaeHNBQnhzQWl4c0GReHNBuXhzQeF4c0EIeXNBMHlzQVh5c0F/eXNBp3lzQc95c0H3eXNBHnpzQUZ6c0FuenNBlXpzQb16c0HlenNBDXtzQTR7c0Fce3NBhHtzQat7c0HTe3NB+3tzQSJ8c0FKfHNBcnxzQZp8c0HBfHNB6XxzQRF9c0E4fXNBYH1zQYh9c0GvfXNB131zQf99c0EmfnNBTn5zQXZ+c0GdfnNBxX5zQe1+c0EUf3NBPH9zQWR/c0GMf3NBs39zQdt/c0EDgHNBKoBzQVKAc0F6gHNBoYBzQcmAc0HxgHNBGIFzQUCBc0FogXNBj4FzQbeBc0HfgXNBBoJzQS6Cc0FVgnNBfYJzQaWCc0HMgnNB9IJzQRyDc0FDg3NBa4NzQZODc0G6g3NB4oNzQQqEc0ExhHNBWYRzQYGEc0GohHNB0IRzQfeEc0EfhXNBR4VzQW6Fc0GWhXNBvoVzQeWFc0ENhnNBNYZzQVyGc0GEhnNBq4ZzQdOGc0H7hnNBIodzQUqHc0Fyh3NBmYdzQcGHc0Hoh3NBEIhzQTiIc0FfiHNBh4hzQa6Ic0HWiHNB/ohzQSWJc0FNiXNBdYlzQZyJc0HEiXNB64lzQROKc0E7inNBYopzQYqKc0GxinNB2YpzQQGLc0Eoi3NBUItzQXeLc0Gfi3NBx4tzQe6Lc0EWjHNBPYxzQWWMc0GMjHNBtIxzQdyMc0EDjXNBK41zQVKNc0F6jXNBoo1zQcmNc0HxjXNBGI5zQUCOc0FnjnNBj45zQbeOc0HejnNBBo9zQS2Pc0FVj3NBfI9zQaSPc0HMj3NB849zQRuQc0FCkHNBapBzQZGQc0G5kHNB4ZBzQQiRc0EwkXNBV5FzQX+Rc0GmkXNBzpFzQfWRc0EdknNBRJJzQWySc0GUknNBu5JzQeOSc0EKk3NBMpNzQVmTc0GBk3NBqJNzQdCTc0H3k3NBH5RzQUeUc0FulHNBlpRzQb2Uc0HllHNBDJVzQTSVc0FblXNBg5VzQaqVc0HSlXNB+ZVzQSGWc0FIlnNBcJZzQZeWc0G/lnNB5pZzQQ6Xc0E2l3NBXZdzQYWXc0Gsl3NB1JdzQfuXc0EjmHNBSphzQXKYc0GZmHNBwZhzQeiYc0EQmXNBN5lzQV+Zc0GGmXNBrplzQdWZc0H9mXNBJJpzQUyac0FzmnNBm5pzQcKac0HqmnNBEZtzQTmbc0Fgm3NBiJtzQa+bc0HXm3NB/ptzQSWcc0FNnHNBdJxzQZycc0HDnHNB65xzQRKdc0E6nXNBYZ1zQYmdc0GwnXNB2J1zQf+dc0EnnnNBTp5zQXaec0GdnnNBxZ5zQeyec0ETn3NBO59zQWKfc0GKn3NBsZ9zQdmfc0EAoHNBKKBzQU+gc0F3oHNBnqBzQcWgc0HtoHNBFKFzQTyhc0FjoXNBi6FzQbKhc0HaoXNBAaJzQSmic0FQonNBd6JzQZ+ic0HGonNB7qJzQRWjc0E9o3NBZKNzQYujc0Gzo3NB2qNzQQKkc0EppHNBUaRzQXikc0GfpHNBx6RzQe6kc0EWpXNBPaVzQWWlc0GMpXNBs6VzQdulc0ECpnNBKqZzQVGmc0F5pnNBoKZzQcemc0HvpnNBFqdzQT6nc0Flp3NBjKdzQbSnc0Hbp3NBA6hzQSqoc0FRqHNBeahzQaCoc0HIqHNB76hzQRapc0E+qXNBZalzQY2pc0G0qXNB26lzQQOqc0EqqnNBUqpzQXmqc0GgqnNByKpzQe+qc0EWq3NBPqtzQWWrc0GNq3NBtKtzQdurc0EDrHNBKqxzQVGsc0F5rHNBoKxzQcisc0HvrHNBFq1zQT6tc0FlrXNBjK1zQbStc0HbrXNBA65zQSquc0FRrnNBea5zQaCuc0HHrnNB765zQRavc0E9r3NBZa9zQYyvc0Gzr3NB269zQQKwc0EqsHNBUbBzQXiwc0GgsHNBx7BzQe6wc0EWsXNBPbFzQWSxc0GMsXNBs7FzQdqxc0ECsnNBKbJzQVCyc0F4snNBn7JzQcayc0HusnNBFbNzQTyzc0Fks3NBi7NzQbKzc0Has3NBAbRzQSi0c0FQtHNBd7RzQZ60c0HGtHNB7bRzQRS1c0E7tXNBY7VzQYq1c0GxtXNB2bVzQQC2c0EntnNBT7ZzQXa2c0GdtnNBxbZzQey2c0ETt3NBO7dzQWK3c0GJt3NBsLdzQdi3c0H/t3NBJrhzQU64c0F1uHNBnLhzQcO4c0HruHNBErlzQTm5c0FhuXNBiLlzQa+5c0HWuXNB/rlzQSW6c0FMunNBdLpzQZu6c0HCunNB6bpzQRG7c0E4u3NBX7tzQYe7c0Guu3NB1btzQfy7c0EkvHNBS7xzQXK8c0GZvHNBwbxzQei8c0EPvXNBN71zQV69c0GFvXNBrL1zQdS9c0H7vXNBIr5zQUm+c0FxvnNBmL5zQb++c0HmvnNBDr9zQTW/c0Fcv3NBg79zQau/c0HSv3NB+b9zQSDAc0FIwHNBb8BzQZbAc0G9wHNB5cBzQQzBc0EzwXNBWsFzQYHBc0GpwXNB0MFzQffBc0EewnNBRsJzQW3Cc0GUwnNBu8JzQePCc0EKw3NBMcNzQVjDc0F/w3NBp8NzQc7Dc0H1w3NBHMRzQUTEc0FrxHNBksRzQbnEc0HgxHNBCMVzQS/Fc0FWxXNBfcVzQaTFc0HMxXNB88VzQRrGc0FBxnNBaMZzQZDGc0G3xnNB3sZzQQXHc0Esx3NBVMdzQXvHc0Gix3NBycdzQfDHc0EYyHNBP8hzQWbIc0GNyHNBtMhzQdzIc0EDyXNBKslzQVHJc0F4yXNBn8lzQcfJc0HuyXNBFcpzQTzKc0FjynNBispzQbLKc0HZynNBAMtzQSfLc0FOy3NBdstzQZ3Lc0HEy3NB68tzQRLMc0E5zHNBYMxzQYjMc0GvzHNB1sxzQf3Mc0EkzXNBS81zQXPNc0GazXNBwc1zQejNc0EPznNBNs5zQV7Oc0GFznNBrM5zQdPOc0H6znNBIc9zQUjPc0Fwz3NBl89zQb7Pc0Hlz3NBDNBzQTPQc0Fa0HNBgdBzQanQc0HQ0HNB99BzQR7Rc0FF0XNBbNFzQZPRc0G70XNB4tFzQQnSc0Ew0nNBV9JzQX7Sc0Gl0nNBzNJzQfTSc0Eb03NBQtNzQWnTc0GQ03NBt9NzQd7Tc0EF1HNBLNRzQVTUc0F71HNBotRzQcnUc0Hw1HNBF9VzQT7Vc0Fl1XNBjNVzQbPVc0Hb1XNBAtZzQSnWc0FQ1nNBd9ZzQZ7Wc0HF1nNB7NZzQRPXc0E613NBYtdzQYnXc0Gw13NB19dzQf7Xc0El2HNBTNhzQXPYc0Ga2HNBwdhzQejYc0EP2XNBNtlzQV7Zc0GF2XNBrNlzQdPZc0H62XNBIdpzQUjac0Fv2nNBltpzQb3ac0Hk2nNBC9tzQTLbc0FZ23NBgdtzQajbc0HP23NB9ttzQR3cc0FE3HNBa9xzQZLcc0G53HNB4NxzQQfdc0Eu3XNBVd1zQXzdc0Gj3XNByt1zQfHdc0EY3nNBP95zQWfec0GO3nNBtd5zQdzec0ED33NBKt9zQVHfc0F433NBn99zQcbfc0Ht33NBFOBzQTvgc0Fi4HNBieBzQbDgc0HX4HNB/uBzQSXhc0FM4XNBc+FzQZrhc0HB4XNB6OFzQQ/ic0E24nNBXeJzQYTic0Gr4nNB0uJzQfnic0Eg43NBR+NzQW7jc0GV43NBvONzQePjc0EK5HNBMeRzQVjkc0F/5HNBpuRzQc3kc0H05HNBG+VzQULlc0Fp5XNBkOVzQbflc0He5XNBBeZzQSzmc0FT5nNBeuZzQaHmc0HI5nNB7+ZzQRbnc0E953NBZOdzQYvnc0Gy53NB2edzQQDoc0En6HNBTuhzQXXoc0Gc6HNBw+hzQeroc0ER6XNBOOlzQV/pc0GG6XNBrelzQdTpc0H76XNBIupzQUnqc0Fw6nNBl+pzQb7qc0Hl6nNBDOtzQTPrc0FZ63NBgOtzQafrc0HO63NB9etzQRzsc0FD7HNBauxzQZHsc0G47HNB3+xzQQbtc0Et7XNBVO1zQXvtc0Gi7XNBye1zQfDtc0EX7nNBPe5zQWTuc0GL7nNBsu5zQdnuc0EA73NBJ+9zQU7vc0F173NBnO9zQcPvc0Hq73NBEfBzQTjwc0Ff8HNBhfBzQazwc0HT8HNB+vBzQSHxc0FI8XNBb/FzQZbxc0G98XNB5PFzQQvyc0Ey8nNBWPJzQX/yc0Gm8nNBzfJzQfTyc0Eb83NBQvNzQWnzc0GQ83NBt/NzQd7zc0EE9HNBK/RzQVL0c0F59HNBoPRzQcf0c0Hu9HNBFfVzQTz1c0Fi9XNBifVzQbD1c0HX9XNB/vVzQSX2c0FM9nNBc/ZzQZr2c0HA9nNB5/ZzQQ73c0E193NBXPdzQYP3c0Gq93NB0fdzQff3c0Ee+HNBRfhzQWz4c0GT+HNBuvhzQeH4c0EI+XNBLvlzQVX5c0F8+XNBo/lzQcr5c0Hx+XNBGPpzQT76c0Fl+nNBjPpzQbP6c0Ha+nNBAftzQSj7c0FO+3NBdftzQZz7c0HD+3NB6vtzQRH8c0E4/HNBXvxzQYX8c0Gs/HNB0/xzQfr8c0Eh/XNBR/1zQW79c0GV/XNBvP1zQeP9c0EK/nNBMP5zQVf+c0F+/nNBpf5zQcz+c0Hz/nNBGf9zQUD/c0Fn/3NBjv9zQbX/c0Hc/3NBAgB0QSkAdEFQAHRBdwB0QZ4AdEHEAHRB6wB0QRIBdEE5AXRBYAF0QYcBdEGtAXRB1AF0QfsBdEEiAnRBSQJ0QW8CdEGWAnRBvQJ0QeQCdEELA3RBMQN0QVgDdEF/A3RBpgN0Qc0DdEHzA3RBGgR0QUEEdEFoBHRBjwR0QbUEdEHcBHRBAwV0QSoFdEFRBXRBdwV0QZ4FdEHFBXRB7AV0QRIGdEE5BnRBYAZ0QYcGdEGuBnRB1AZ0QfsGdEEiB3RBSQd0QW8HdEGWB3RBvQd0QeQHdEEKCHRBMQh0QVgIdEF/CHRBpgh0QcwIdEHzCHRBGgl0QUEJdEFnCXRBjgl0QbUJdEHcCXRBAgp0QSkKdEFQCnRBdwp0QZ0KdEHECnRB6wp0QRILdEE4C3RBXwt0QYYLdEGtC3RB0wt0QfoLdEEhDHRBSAx0QW4MdEGVDHRBvAx0QeMMdEEJDXRBMA10QVcNdEF+DXRBpA10QcsNdEHyDXRBGA50QT8OdEFmDnRBjQ50QbMOdEHaDnRBAQ90QSgPdEFOD3RBdQ90QZwPdEHCD3RB6Q90QRAQdEE3EHRBXRB0QYQQdEGrEHRB0RB0QfgQdEEfEXRBRhF0QWwRdEGTEXRBuhF0QeARdEEHEnRBLhJ0QVQSdEF7EnRBohJ0QckSdEHvEnRBFhN0QT0TdEFjE3RBihN0QbETdEHXE3RB/hN0QSUUdEFLFHRBchR0QZkUdEHAFHRB5hR0QQ0VdEE0FXRBWhV0QYEVdEGoFXRBzhV0QfUVdEEcFnRBQhZ0QWkWdEGQFnRBthZ0Qd0WdEEEF3RBKhd0QVEXdEF4F3RBnhd0QcUXdEHsF3RBEhh0QTkYdEFgGHRBhhh0Qa0YdEHUGHRB+hh0QSEZdEFIGXRBbhl0QZUZdEG8GXRB4hl0QQkadEEwGnRBVhp0QX0adEGjGnRByhp0QfEadEEXG3RBPht0QWUbdEGLG3RBsht0QdkbdEH/G3RBJhx0QU0cdEFzHHRBmhx0QcAcdEHnHHRBDh10QTQddEFbHXRBgh10QagddEHPHXRB9R10QRwedEFDHnRBaR50QZAedEG3HnRB3R50QQQfdEEqH3RBUR90QXgfdEGeH3RBxR90QewfdEESIHRBOSB0QV8gdEGGIHRBrSB0QdMgdEH6IHRBICF0QUchdEFuIXRBlCF0QbshdEHhIXRBCCJ0QS8idEFVInRBfCJ0QaIidEHJInRB8CJ0QRYjdEE9I3RBYyN0QYojdEGwI3RB1yN0Qf4jdEEkJHRBSyR0QXEkdEGYJHRBvyR0QeUkdEEMJXRBMiV0QVkldEF/JXRBpiV0Qc0ldEHzJXRBGiZ0QUAmdEFnJnRBjSZ0QbQmdEHbJnRBASd0QSgndEFOJ3RBdSd0QZsndEHCJ3RB6Sd0QQ8odEE2KHRBXCh0QYModEGpKHRB0Ch0QfYodEEdKXRBRCl0QWopdEGRKXRBtyl0Qd4pdEEEKnRBKyp0QVEqdEF4KnRBnip0QcUqdEHsKnRBEit0QTkrdEFfK3RBhit0QawrdEHTK3RB+St0QSAsdEFGLHRBbSx0QZMsdEG6LHRB4Cx0QQctdEEuLXRBVC10QXstdEGhLXRByC10Qe4tdEEVLnRBOy50QWIudEGILnRBry50QdUudEH8LnRBIi90QUkvdEFvL3RBli90QbwvdEHjL3RBCTB0QTAwdEFWMHRBfTB0QaMwdEHKMHRB8DB0QRcxdEE9MXRBZDF0QYoxdEGxMXRB1zF0Qf4xdEEkMnRBSzJ0QXEydEGYMnRBvjJ0QeUydEELM3RBMjN0QVgzdEF/M3RBpTN0QcwzdEHyM3RBGTR0QT80dEFmNHRBjDR0QbM0dEHZNHRBADV0QSY1dEFMNXRBczV0QZk1dEHANXRB5jV0QQ02dEEzNnRBWjZ0QYA2dEGnNnRBzTZ0QfQ2dEEaN3RBQTd0QWc3dEGNN3RBtDd0Qdo3dEEBOHRBJzh0QU44dEF0OHRBmzh0QcE4dEHoOHRBDjl0QTQ5dEFbOXRBgTl0Qag5dEHOOXRB9Tl0QRs6dEFCOnRBaDp0QY46dEG1OnRB2zp0QQI7dEEoO3RBTzt0QXU7dEGbO3RBwjt0Qeg7dEEPPHRBNTx0QVw8dEGCPHRBqDx0Qc88dEH1PHRBHD10QUI9dEFpPXRBjz10QbU9dEHcPXRBAj50QSk+dEFPPnRBdT50QZw+dEHCPnRB6T50QQ8/dEE2P3RBXD90QYI/dEGpP3RBzz90QfY/dEEcQHRBQkB0QWlAdEGPQHRBtkB0QdxAdEECQXRBKUF0QU9BdEF2QXRBnEF0QcJBdEHpQXRBD0J0QTVCdEFcQnRBgkJ0QalCdEHPQnRB9UJ0QRxDdEFCQ3RBaUN0QY9DdEG1Q3RB3EN0QQJEdEEoRHRBT0R0QXVEdEGcRHRBwkR0QehEdEEPRXRBNUV0QVtFdEGCRXRBqEV0Qc9FdEH1RXRBG0Z0QUJGdEFoRnRBjkZ0QbVGdEHbRnRBAUd0QShHdEFOR3RBdUd0QZtHdEHBR3RB6Ed0QQ5IdEE0SHRBW0h0QYFIdEGnSHRBzkh0QfRIdEEaSXRBQUl0QWdJdEGNSXRBtEl0QdpJdEEASnRBJ0p0QU1KdEFzSnRBmkp0QcBKdEHmSnRBDUt0QTNLdEFZS3RBgEt0QaZLdEHMS3RB80t0QRlMdEE/THRBZkx0QYxMdEGyTHRB2Ux0Qf9MdEElTXRBTE10QXJNdEGYTXRBv010QeVNdEELTnRBMU50QVhOdEF+TnRBpE50QctOdEHxTnRBF090QT5PdEFkT3RBik90QbFPdEHXT3RB/U90QSNQdEFKUHRBcFB0QZZQdEG9UHRB41B0QQlRdEEvUXRBVlF0QXxRdEGiUXRByVF0Qe9RdEEVUnRBPFJ0QWJSdEGIUnRBrlJ0QdVSdEH7UnRBIVN0QUdTdEFuU3RBlFN0QbpTdEHhU3RBB1R0QS1UdEFTVHRBelR0QaBUdEHGVHRB7FR0QRNVdEE5VXRBX1V0QYZVdEGsVXRB0lV0QfhVdEEfVnRBRVZ0QWtWdEGRVnRBuFZ0Qd5WdEEEV3RBKld0QVFXdEF3V3RBnVd0QcNXdEHqV3RBEFh0QTZYdEFcWHRBg1h0QalYdEHPWHRB9Vh0QRxZdEFCWXRBaFl0QY5ZdEG1WXRB21l0QQFadEEnWnRBTVp0QXRadEGaWnRBwFp0QeZadEENW3RBM1t0QVlbdEF/W3RBplt0QcxbdEHyW3RBGFx0QT5cdEFlXHRBi1x0QbFcdEHXXHRB/Vx0QSRddEFKXXRBcF10QZZddEG9XXRB4110QQledEEvXnRBVV50QXxedEGiXnRByF50Qe5edEEUX3RBO190QWFfdEGHX3RBrV90QdNfdEH6X3RBIGB0QUZgdEFsYHRBkmB0QblgdEHfYHRBBWF0QSthdEFRYXRBd2F0QZ5hdEHEYXRB6mF0QRBidEE2YnRBXWJ0QYNidEGpYnRBz2J0QfVidEEbY3RBQmN0QWhjdEGOY3RBtGN0QdpjdEEBZHRBJ2R0QU1kdEFzZHRBmWR0Qb9kdEHmZHRBDGV0QTJldEFYZXRBfmV0QaRldEHKZXRB8WV0QRdmdEE9ZnRBY2Z0QYlmdEGvZnRB1mZ0QfxmdEEiZ3RBSGd0QW5ndEGUZ3RBumd0QeFndEEHaHRBLWh0QVNodEF5aHRBn2h0QcVodEHsaHRBEml0QThpdEFeaXRBhGl0QappdEHQaXRB92l0QR1qdEFDanRBaWp0QY9qdEG1anRB22p0QQFrdEEoa3RBTmt0QXRrdEGaa3RBwGt0QeZrdEEMbHRBMmx0QVlsdEF/bHRBpWx0QctsdEHxbHRBF210QT1tdEFjbXRBiW10QbBtdEHWbXRB/G10QSJudEFIbnRBbm50QZRudEG6bnRB4G50QQZvdEEtb3RBU290QXlvdEGfb3RBxW90QetvdEERcHRBN3B0QV1wdEGDcHRBqXB0QdBwdEH2cHRBHHF0QUJxdEFocXRBjnF0QbRxdEHacXRBAHJ0QSZydEFMcnRBcnJ0QZlydEG/cnRB5XJ0QQtzdEExc3RBV3N0QX1zdEGjc3RByXN0Qe9zdEEVdHRBO3R0QWF0dEGHdHRBrXR0QdR0dEH6dHRBIHV0QUZ1dEFsdXRBknV0Qbh1dEHedXRBBHZ0QSp2dEFQdnRBdnZ0QZx2dEHCdnRB6HZ0QQ53dEE0d3RBWnd0QYB3dEGnd3RBzXd0QfN3dEEZeHRBP3h0QWV4dEGLeHRBsXh0Qdd4dEH9eHRBI3l0QUl5dEFveXRBlXl0Qbt5dEHheXRBB3p0QS16dEFTenRBeXp0QZ96dEHFenRB63p0QRF7dEE3e3RBXXt0QYN7dEGpe3RBz3t0QfV7dEEbfHRBQXx0QWd8dEGNfHRBs3x0Qdl8dEH/fHRBJX10QUt9dEFxfXRBl310Qb19dEHjfXRBCX50QS9+dEFVfnRBe350QaF+dEHHfnRB7X50QRN/dEE5f3RBX390QYV/dEGrf3RB0X90Qfd/dEEdgHRBQ4B0QWmAdEGPgHRBtYB0QduAdEEBgXRBJ4F0QU2BdEFzgXRBmYF0Qb+BdEHlgXRBC4J0QTGCdEFXgnRBfYJ0QaOCdEHJgnRB74J0QRWDdEE7g3RBYYN0QYeDdEGtg3RB04N0QfmDdEEfhHRBRYR0QWuEdEGRhHRBt4R0Qd2EdEEDhXRBKIV0QU6FdEF0hXRBmoV0QcCFdEHmhXRBDIZ0QTKGdEFYhnRBfoZ0QaSGdEHKhnRB8IZ0QRaHdEE8h3RBYod0QYiHdEGuh3RB1Id0QfmHdEEfiHRBRYh0QWuIdEGRiHRBt4h0Qd2IdEEDiXRBKYl0QU+JdEF1iXRBm4l0QcGJdEHniXRBDYp0QTKKdEFYinRBfop0QaSKdEHKinRB8Ip0QRaLdEE8i3RBYot0QYiLdEGui3RB1It0QfmLdEEfjHRBRYx0QWuMdEGRjHRBt4x0Qd2MdEEDjXRBKY10QU+NdEF1jXRBmo10QcCNdEHmjXRBDI50QTKOdEFYjnRBfo50QaSOdEHKjnRB8I50QRWPdEE7j3RBYY90QYePdEGtj3RB0490QfmPdEEfkHRBRZB0QWqQdEGQkHRBtpB0QdyQdEECkXRBKJF0QU6RdEF0kXRBmZF0Qb+RdEHlkXRBC5J0QTGSdEFXknRBfZJ0QaOSdEHIknRB7pJ0QRSTdEE6k3RBYJN0QYaTdEGsk3RB0ZN0QfeTdEEdlHRBQ5R0QWmUdEGPlHRBtZR0QdqUdEEAlXRBJpV0QUyVdEFylXRBmJV0Qb6VdEHjlXRBCZZ0QS+WdEFVlnRBe5Z0QaGWdEHHlnRB7JZ0QRKXdEE4l3RBXpd0QYSXdEGql3RBz5d0QfWXdEEbmHRBQZh0QWeYdEGNmHRBsph0QdiYdEH+mHRBJJl0QUqZdEFwmXRBlZl0QbuZdEHhmXRBB5p0QS2adEFSmnRBeJp0QZ6adEHEmnRB6pp0QRCbdEE1m3RBW5t0QYGbdEGnm3RBzZt0QfKbdEEYnHRBPpx0QWScdEGKnHRBr5x0QdWcdEH7nHRBIZ10QUeddEFsnXRBkp10QbiddEHenXRBBJ50QSmedEFPnnRBdZ50QZuedEHBnnRB5p50QQyfdEEyn3RBWJ90QX6fdEGjn3RByZ90Qe+fdEEVoHRBO6B0QWCgdEGGoHRBrKB0QdKgdEH3oHRBHaF0QUOhdEFpoXRBj6F0QbShdEHaoXRBAKJ0QSaidEFLonRBcaJ0QZeidEG9onRB4qJ0QQijdEEuo3RBVKN0QXqjdEGfo3RBxaN0QeujdEERpHRBNqR0QVykdEGCpHRBqKR0Qc2kdEHzpHRBGaV0QT+ldEFkpXRBiqV0QbCldEHWpXRB+6V0QSGmdEFHpnRBbaZ0QZKmdEG4pnRB3qZ0QQSndEEpp3RBT6d0QXWndEGap3RBwKd0QeandEEMqHRBMah0QVeodEF9qHRBo6h0QciodEHuqHRBFKl0QTqpdEFfqXRBhal0QaupdEHQqXRB9ql0QRyqdEFCqnRBZ6p0QY2qdEGzqnRB2Kp0Qf6qdEEkq3RBSqt0QW+rdEGVq3RBu6t0QeCrdEEGrHRBLKx0QVKsdEF3rHRBnax0QcOsdEHorHRBDq10QTStdEFZrXRBf610QaWtdEHLrXRB8K10QRaudEE8rnRBYa50QYeudEGtrnRB0q50QfiudEEer3RBQ690QWmvdEGPr3RBta90QdqvdEEAsHRBJrB0QUuwdEFxsHRBl7B0QbywdEHisHRBCLF0QS2xdEFTsXRBebF0QZ6xdEHEsXRB6rF0QQ+ydEE1snRBW7J0QYCydEGmsnRBzLJ0QfGydEEXs3RBPbN0QWKzdEGIs3RBrrN0QdOzdEH5s3RBH7R0QUS0dEFqtHRBkLR0QbW0dEHbtHRBAbV0QSa1dEFMtXRBcbV0QZe1dEG9tXRB4rV0QQi2dEEutnRBU7Z0QXm2dEGftnRBxLZ0Qeq2dEEQt3RBNbd0QVu3dEGAt3RBprd0Qcy3dEHxt3RBF7h0QT24dEFiuHRBiLh0Qa24dEHTuHRB+bh0QR65dEFEuXRBarl0QY+5dEG1uXRB2rl0QQC6dEEmunRBS7p0QXG6dEGXunRBvLp0QeK6dEEHu3RBLbt0QVO7dEF4u3RBnrt0QcO7dEHpu3RBD7x0QTS8dEFavHRBf7x0QaW8dEHLvHRB8Lx0QRa9dEE7vXRBYb10QYe9dEGsvXRB0r10Qfe9dEEdvnRBQ750QWi+dEGOvnRBs750Qdm+dEH/vnRBJL90QUq/dEFvv3RBlb90Qbq/dEHgv3RBBsB0QSvAdEFRwHRBdsB0QZzAdEHCwHRB58B0QQ3BdEEywXRBWMF0QX3BdEGjwXRBycF0Qe7BdEEUwnRBOcJ0QV/CdEGEwnRBqsJ0Qc/CdEH1wnRBG8N0QUDDdEFmw3RBi8N0QbHDdEHWw3RB/MN0QSHEdEFHxHRBbcR0QZLEdEG4xHRB3cR0QQPFdEEoxXRBTsV0QXPFdEGZxXRBv8V0QeTFdEEKxnRBL8Z0QVXGdEF6xnRBoMZ0QcXGdEHrxnRBEMd0QTbHdEFbx3RBgcd0QafHdEHMx3RB8sd0QRfIdEE9yHRBYsh0QYjIdEGtyHRB08h0QfjIdEEeyXRBQ8l0QWnJdEGOyXRBtMl0QdnJdEH/yXRBJMp0QUrKdEFvynRBlcp0QbrKdEHgynRBBct0QSvLdEFRy3RBdst0QZzLdEHBy3RB58t0QQzMdEEyzHRBV8x0QX3MdEGizHRByMx0Qe3MdEETzXRBOM10QV7NdEGDzXRBqc10Qc7NdEH0zXRBGc50QT7OdEFkznRBic50Qa/OdEHUznRB+s50QR/PdEFFz3RBas90QZDPdEG1z3RB2890QQDQdEEm0HRBS9B0QXHQdEGW0HRBvNB0QeHQdEEH0XRBLNF0QVLRdEF30XRBnNF0QcLRdEHn0XRBDdJ0QTLSdEFY0nRBfdJ0QaPSdEHI0nRB7tJ0QRPTdEE503RBXtN0QYTTdEGp03RBztN0QfTTdEEZ1HRBP9R0QWTUdEGK1HRBr9R0QdXUdEH61HRBH9V0QUXVdEFq1XRBkNV0QbXVdEHb1XRBANZ0QSbWdEFL1nRBcNZ0QZbWdEG71nRB4dZ0QQbXdEEs13RBUdd0QXbXdEGc13RBwdd0QefXdEEM2HRBMth0QVfYdEF82HRBoth0QcfYdEHt2HRBEtl0QTjZdEFd2XRBgtl0QajZdEHN2XRB89l0QRjadEE+2nRBY9p0QYjadEGu2nRB09p0QfnadEEe23RBQ9t0QWnbdEGO23RBtNt0QdnbdEH+23RBJNx0QUncdEFv3HRBlNx0QbncdEHf3HRBBN10QSrddEFP3XRBdN10QZrddEG/3XRB5d10QQredEEv3nRBVd50QXredEGf3nRBxd50QeredEEQ33RBNd90QVrfdEGA33RBpd90QcvfdEHw33RBFeB0QTvgdEFg4HRBheB0QavgdEHQ4HRB9uB0QRvhdEFA4XRBZuF0QYvhdEGw4XRB1uF0QfvhdEEg4nRBRuJ0QWvidEGR4nRBtuJ0QdvidEEB43RBJuN0QUvjdEFx43RBluN0QbvjdEHh43RBBuR0QSvkdEFR5HRBduR0QZzkdEHB5HRB5uR0QQzldEEx5XRBVuV0QXzldEGh5XRBxuV0QezldEER5nRBNuZ0QVzmdEGB5nRBpuZ0QczmdEHx5nRBFud0QTzndEFh53RBhud0QazndEHR53RB9ud0QRzodEFB6HRBZuh0QYzodEGx6HRB1uh0QfzodEEh6XRBRul0QWzpdEGR6XRBtul0QdvpdEEB6nRBJup0QUvqdEFx6nRBlup0QbvqdEHh6nRBBut0QSvrdEFR63RBdut0QZvrdEHA63RB5ut0QQvsdEEw7HRBVux0QXvsdEGg7HRBxux0QevsdEEQ7XRBNe10QVvtdEGA7XRBpe10QcvtdEHw7XRBFe50QTrudEFg7nRBhe50QarudEHQ7nRB9e50QRrvdEE/73RBZe90QYrvdEGv73RB1e90QfrvdEEf8HRBRPB0QWrwdEGP8HRBtPB0QdrwdEH/8HRBJPF0QUnxdEFv8XRBlPF0QbnxdEHe8XRBBPJ0QSnydEFO8nRBc/J0QZnydEG+8nRB4/J0QQjzdEEu83RBU/N0QXjzdEGd83RBw/N0QejzdEEN9HRBMvR0QVj0dEF99HRBovR0Qcf0dEHt9HRBEvV0QTf1dEFc9XRBgvV0Qaf1dEHM9XRB8fV0QRf2dEE89nRBYfZ0QYb2dEGs9nRB0fZ0Qfb2dEEb93RBQfd0QWb3dEGL93RBsPd0QdX3dEH793RBIPh0QUX4dEFq+HRBkPh0QbX4dEHa+HRB//h0QST5dEFK+XRBb/l0QZT5dEG5+XRB3/l0QQT6dEEp+nRBTvp0QXP6dEGZ+nRBvvp0QeP6dEEI+3RBLft0QVP7dEF4+3RBnft0QcL7dEHn+3RBDfx0QTL8dEFX/HRBfPx0QaH8dEHH/HRB7Px0QRH9dEE2/XRBW/10QYH9dEGm/XRBy/10QfD9dEEV/nRBO/50QWD+dEGF/nRBqv50Qc/+dEH0/nRBGv90QT//dEFk/3RBif90Qa7/dEHU/3RB+f90QR4AdUFDAHVBaAB1QY0AdUGzAHVB2AB1Qf0AdUEiAXVBRwF1QWwBdUGSAXVBtwF1QdwBdUEBAnVBJgJ1QUsCdUFxAnVBlgJ1QbsCdUHgAnVBBQN1QSoDdUFPA3VBdQN1QZoDdUG/A3VB5AN1QQkEdUEuBHVBVAR1QXkEdUGeBHVBwwR1QegEdUENBXVBMgV1QVgFdUF9BXVBogV1QccFdUHsBXVBEQZ1QTYGdUFcBnVBgQZ1QaYGdUHLBnVB8AZ1QRUHdUE6B3VBXwd1QYUHdUGqB3VBzwd1QfQHdUEZCHVBPgh1QWMIdUGICHVBrgh1QdMIdUH4CHVBHQl1QUIJdUFnCXVBjAl1QbEJdUHWCXVB/Al1QSEKdUFGCnVBawp1QZAKdUG1CnVB2gp1Qf8KdUEkC3VBSgt1QW8LdUGUC3VBuQt1Qd4LdUEDDHVBKAx1QU0MdUFyDHVBlwx1Qb0MdUHiDHVBBw11QSwNdUFRDXVBdg11QZsNdUHADXVB5Q11QQoOdUEvDnVBVQ51QXoOdUGfDnVBxA51QekOdUEOD3VBMw91QVgPdUF9D3VBog91QccPdUHsD3VBEhB1QTcQdUFcEHVBgRB1QaYQdUHLEHVB8BB1QRURdUE6EXVBXxF1QYQRdUGpEXVBzhF1QfMRdUEYEnVBPhJ1QWMSdUGIEnVBrRJ1QdISdUH3EnVBHBN1QUETdUFmE3VBixN1QbATdUHVE3VB+hN1QR8UdUFEFHVBaRR1QY4UdUGzFHVB2BR1Qf4UdUEjFXVBSBV1QW0VdUGSFXVBtxV1QdwVdUEBFnVBJhZ1QUsWdUFwFnVBlRZ1QboWdUHfFnVBBBd1QSkXdUFOF3VBcxd1QZgXdUG9F3VB4hd1QQcYdUEsGHVBURh1QXYYdUGbGHVBwBh1QeUYdUEKGXVBLxl1QVQZdUF5GXVBnhl1QcMZdUHoGXVBDRp1QTIadUFYGnVBfRp1QaIadUHHGnVB7Bp1QREbdUE2G3VBWxt1QYAbdUGlG3VByht1Qe8bdUEUHHVBORx1QV4cdUGDHHVBqBx1Qc0cdUHyHHVBFx11QTwddUFhHXVBhh11QaoddUHPHXVB9B11QRkedUE+HnVBYx51QYgedUGtHnVB0h51QfcedUEcH3VBQR91QWYfdUGLH3VBsB91QdUfdUH6H3VBHyB1QUQgdUFpIHVBjiB1QbMgdUHYIHVB/SB1QSIhdUFHIXVBbCF1QZEhdUG2IXVB2yF1QQAidUElInVBSiJ1QW8idUGUInVBuSJ1Qd4idUECI3VBJyN1QUwjdUFxI3VBliN1QbsjdUHgI3VBBSR1QSokdUFPJHVBdCR1QZkkdUG+JHVB4yR1QQgldUEtJXVBUiV1QXcldUGcJXVBwCV1QeUldUEKJnVBLyZ1QVQmdUF5JnVBniZ1QcMmdUHoJnVBDSd1QTIndUFXJ3VBfCd1QaEndUHGJ3VB6id1QQ8odUE0KHVBWSh1QX4odUGjKHVByCh1Qe0odUESKXVBNyl1QVwpdUGBKXVBpSl1QcopdUHvKXVBFCp1QTkqdUFeKnVBgyp1QagqdUHNKnVB8ip1QRcrdUE7K3VBYCt1QYUrdUGqK3VBzyt1QfQrdUEZLHVBPix1QWMsdUGILHVBrCx1QdEsdUH2LHVBGy11QUAtdUFlLXVBii11Qa8tdUHULXVB+C11QR0udUFCLnVBZy51QYwudUGxLnVB1i51QfsudUEgL3VBRC91QWkvdUGOL3VBsy91QdgvdUH9L3VBIjB1QUcwdUFrMHVBkDB1QbUwdUHaMHVB/zB1QSQxdUFJMXVBbjF1QZIxdUG3MXVB3DF1QQEydUEmMnVBSzJ1QXAydUGUMnVBuTJ1Qd4ydUEDM3VBKDN1QU0zdUFyM3VBljN1QbszdUHgM3VBBTR1QSo0dUFPNHVBczR1QZg0dUG9NHVB4jR1QQc1dUEsNXVBUTV1QXU1dUGaNXVBvzV1QeQ1dUEJNnVBLjZ1QVI2dUF3NnVBnDZ1QcE2dUHmNnVBCzd1QS83dUFUN3VBeTd1QZ43dUHDN3VB6Dd1QQw4dUExOHVBVjh1QXs4dUGgOHVBxDh1Qek4dUEOOXVBMzl1QVg5dUF9OXVBoTl1QcY5dUHrOXVBEDp1QTU6dUFZOnVBfjp1QaM6dUHIOnVB7Tp1QRE7dUE2O3VBWzt1QYA7dUGlO3VByjt1Qe47dUETPHVBODx1QV08dUGBPHVBpjx1Qcs8dUHwPHVBFT11QTk9dUFePXVBgz11Qag9dUHNPXVB8T11QRY+dUE7PnVBYD51QYU+dUGpPnVBzj51QfM+dUEYP3VBPD91QWE/dUGGP3VBqz91QdA/dUH0P3VBGUB1QT5AdUFjQHVBh0B1QaxAdUHRQHVB9kB1QRtBdUE/QXVBZEF1QYlBdUGuQXVB0kF1QfdBdUEcQnVBQUJ1QWVCdUGKQnVBr0J1QdRCdUH4QnVBHUN1QUJDdUFnQ3VBi0N1QbBDdUHVQ3VB+kN1QR5EdUFDRHVBaER1QY1EdUGxRHVB1kR1QftEdUEgRXVBREV1QWlFdUGORXVBs0V1QddFdUH8RXVBIUZ1QUZGdUFqRnVBj0Z1QbRGdUHZRnVB/UZ1QSJHdUFHR3VBa0d1QZBHdUG1R3VB2kd1Qf5HdUEjSHVBSEh1QW1IdUGRSHVBtkh1QdtIdUH/SHVBJEl1QUlJdUFuSXVBkkl1QbdJdUHcSXVBAEp1QSVKdUFKSnVBb0p1QZNKdUG4SnVB3Up1QQFLdUEmS3VBS0t1QW9LdUGUS3VBuUt1Qd5LdUECTHVBJ0x1QUxMdUFwTHVBlUx1QbpMdUHeTHVBA011QShNdUFNTXVBcU11QZZNdUG7TXVB3011QQROdUEpTnVBTU51QXJOdUGXTnVBu051QeBOdUEFT3VBKU91QU5PdUFzT3VBmE91QbxPdUHhT3VBBlB1QSpQdUFPUHVBdFB1QZhQdUG9UHVB4lB1QQZRdUErUXVBUFF1QXRRdUGZUXVBvlF1QeJRdUEHUnVBLFJ1QVBSdUF1UnVBmlJ1Qb5SdUHjUnVBCFN1QSxTdUFRU3VBdlN1QZpTdUG/U3VB41N1QQhUdUEtVHVBUVR1QXZUdUGbVHVBv1R1QeRUdUEJVXVBLVV1QVJVdUF3VXVBm1V1QcBVdUHkVXVBCVZ1QS5WdUFSVnVBd1Z1QZxWdUHAVnVB5VZ1QQpXdUEuV3VBU1d1QXdXdUGcV3VBwVd1QeVXdUEKWHVBL1h1QVNYdUF4WHVBnFh1QcFYdUHmWHVBCll1QS9ZdUFUWXVBeFl1QZ1ZdUHBWXVB5ll1QQtadUEvWnVBVFp1QXhadUGdWnVBwlp1QeZadUELW3VBMFt1QVRbdUF5W3VBnVt1QcJbdUHnW3VBC1x1QTBcdUFUXHVBeVx1QZ5cdUHCXHVB51x1QQtddUEwXXVBVV11QXlddUGeXXVBwl11QedddUELXnVBMF51QVVedUF5XnVBnl51QcJedUHnXnVBDF91QTBfdUFVX3VBeV91QZ5fdUHCX3VB5191QQxgdUEwYHVBVWB1QXlgdUGeYHVBwmB1QedgdUEMYXVBMGF1QVVhdUF5YXVBnmF1QcJhdUHnYXVBDGJ1QTBidUFVYnVBeWJ1QZ5idUHCYnVB52J1QQtjdUEwY3VBVWN1QXljdUGeY3VBwmN1QedjdUELZHVBMGR1QVRkdUF5ZHVBnmR1QcJkdUHnZHVBC2V1QTBldUFUZXVBeWV1QZ1ldUHCZXVB5mV1QQtmdUEwZnVBVGZ1QXlmdUGdZnVBwmZ1QeZmdUELZ3VBL2d1QVRndUF4Z3VBnWd1QcFndUHmZ3VBCmh1QS9odUFUaHVBeGh1QZ1odUHBaHVB5mh1QQppdUEvaXVBU2l1QXhpdUGcaXVBwWl1QeVpdUEKanVBLmp1QVNqdUF3anVBnGp1QcBqdUHlanVBCWt1QS5rdUFSa3VBd2t1QZtrdUHAa3VB5Gt1QQlsdUEtbHVBUmx1QXZsdUGbbHVBv2x1QeRsdUEIbXVBLW11QVFtdUF2bXVBmm11Qb9tdUHjbXVBCG51QSxudUFRbnVBdW51QZpudUG+bnVB4251QQdvdUEsb3VBUG91QXVvdUGZb3VBvm91QeJvdUEHcHVBK3B1QVBwdUF0cHVBmHB1Qb1wdUHhcHVBBnF1QSpxdUFPcXVBc3F1QZhxdUG8cXVB4XF1QQVydUEqcnVBTnJ1QXNydUGXcnVBu3J1QeBydUEEc3VBKXN1QU1zdUFyc3VBlnN1QbtzdUHfc3VBBHR1QSh0dUFMdHVBcXR1QZV0dUG6dHVB3nR1QQN1dUEndXVBTHV1QXB1dUGUdXVBuXV1Qd11dUECdnVBJnZ1QUt2dUFvdnVBlHZ1Qbh2dUHcdnVBAXd1QSV3dUFKd3VBbnd1QZN3dUG3d3VB23d1QQB4dUEkeHVBSXh1QW14dUGSeHVBtnh1Qdp4dUH/eHVBI3l1QUh5dUFseXVBkXl1QbV5dUHZeXVB/nl1QSJ6dUFHenVBa3p1QY96dUG0enVB2Hp1Qf16dUEhe3VBRnt1QWp7dUGOe3VBs3t1Qdd7dUH8e3VBIHx1QUR8dUFpfHVBjXx1QbJ8dUHWfHVB+nx1QR99dUFDfXVBaH11QYx9dUGwfXVB1X11Qfl9dUEdfnVBQn51QWZ+dUGLfnVBr351QdN+dUH4fnVBHH91QUF/dUFlf3VBiX91Qa5/dUHSf3VB9n91QRuAdUE/gHVBZIB1QYiAdUGsgHVB0YB1QfWAdUEZgXVBPoF1QWKBdUGHgXVBq4F1Qc+BdUH0gXVBGIJ1QTyCdUFhgnVBhYJ1QaqCdUHOgnVB8oJ1QReDdUE7g3VBX4N1QYSDdUGog3VBzIN1QfGDdUEVhHVBOYR1QV6EdUGChHVBp4R1QcuEdUHvhHVBFIV1QTiFdUFchXVBgYV1QaWFdUHJhXVB7oV1QRKGdUE2hnVBW4Z1QX+GdUGjhnVByIZ1QeyGdUEQh3VBNYd1QVmHdUF9h3VBood1QcaHdUHqh3VBD4h1QTOIdUFXiHVBfIh1QaCIdUHEiHVB6Yh1QQ2JdUExiXVBVol1QXqJdUGeiXVBw4l1QeeJdUELinVBL4p1QVSKdUF4inVBnIp1QcGKdUHlinVBCYt1QS6LdUFSi3VBdot1QZuLdUG/i3VB44t1QQiMdUEsjHVBUIx1QXSMdUGZjHVBvYx1QeGMdUEGjXVBKo11QU6NdUFzjXVBl411QbuNdUHfjXVBBI51QSiOdUFMjnVBcY51QZWOdUG5jnVB3Y51QQKPdUEmj3VBSo91QW+PdUGTj3VBt491QduPdUEAkHVBJJB1QUiQdUFtkHVBkZB1QbWQdUHZkHVB/pB1QSKRdUFGkXVBapF1QY+RdUGzkXVB15F1QfyRdUEgknVBRJJ1QWiSdUGNknVBsZJ1QdWSdUH5knVBHpN1QUKTdUFmk3VBipN1Qa+TdUHTk3VB95N1QRuUdUFAlHVBZJR1QYiUdUGslHVB0ZR1QfWUdUEZlXVBPZV1QWKVdUGGlXVBqpV1Qc6VdUHzlXVBF5Z1QTuWdUFflnVBhJZ1QaiWdUHMlnVB8JZ1QRWXdUE5l3VBXZd1QYGXdUGml3VBypd1Qe6XdUESmHVBNph1QVuYdUF/mHVBo5h1QceYdUHsmHVBEJl1QTSZdUFYmXVBfZl1QaGZdUHFmXVB6Zl1QQ2adUEymnVBVpp1QXqadUGemnVBwpp1QeeadUELm3VBL5t1QVObdUF4m3VBnJt1QcCbdUHkm3VBCJx1QS2cdUFRnHVBdZx1QZmcdUG9nHVB4px1QQaddUEqnXVBTp11QXKddUGXnXVBu511Qd+ddUEDnnVBJ551QUyedUFwnnVBlJ51QbiedUHcnnVBAZ91QSWfdUFJn3VBbZ91QZGfdUG1n3VB2p91Qf6fdUEioHVBRqB1QWqgdUGPoHVBs6B1QdegdUH7oHVBH6F1QUOhdUFooXVBjKF1QbChdUHUoXVB+KF1QRyidUFBonVBZaJ1QYmidUGtonVB0aJ1QfWidUEao3VBPqN1QWKjdUGGo3VBqqN1Qc6jdUHzo3VBF6R1QTukdUFfpHVBg6R1QaekdUHMpHVB8KR1QRSldUE4pXVBXKV1QYCldUGkpXVByaV1Qe2ldUERpnVBNaZ1QVmmdUF9pnVBoaZ1QcamdUHqpnVBDqd1QTKndUFWp3VBeqd1QZ6ndUHDp3VB56d1QQuodUEvqHVBU6h1QXeodUGbqHVBv6h1QeSodUEIqXVBLKl1QVCpdUF0qXVBmKl1QbypdUHgqXVBBap1QSmqdUFNqnVBcap1QZWqdUG5qnVB3ap1QQGrdUEmq3VBSqt1QW6rdUGSq3VBtqt1QdqrdUH+q3VBIqx1QUasdUFrrHVBj6x1QbOsdUHXrHVB+6x1QR+tdUFDrXVBZ611QYutdUGvrXVB1K11QfitdUEcrnVBQK51QWSudUGIrnVBrK51QdCudUH0rnVBGK91QTyvdUFhr3VBha91QamvdUHNr3VB8a91QRWwdUE5sHVBXbB1QYGwdUGlsHVBybB1Qe2wdUESsXVBNrF1QVqxdUF+sXVBorF1QcaxdUHqsXVBDrJ1QTKydUFWsnVBerJ1QZ6ydUHCsnVB5rJ1QQuzdUEvs3VBU7N1QXezdUGbs3VBv7N1QeOzdUEHtHVBK7R1QU+0dUFztHVBl7R1Qbu0dUHftHVBA7V1QSe1dUFLtXVBcLV1QZS1dUG4tXVB3LV1QQC2dUEktnVBSLZ1QWy2dUGQtnVBtLZ1Qdi2dUH8tnVBILd1QUS3dUFot3VBjLd1QbC3dUHUt3VB+Ld1QRy4dUFAuHVBZLh1QYi4dUGsuHVB0bh1QfW4dUEZuXVBPbl1QWG5dUGFuXVBqbl1Qc25dUHxuXVBFbp1QTm6dUFdunVBgbp1QaW6dUHJunVB7bp1QRG7dUE1u3VBWbt1QX27dUGhu3VBxbt1Qem7dUENvHVBMbx1QVW8dUF5vHVBnbx1QcG8dUHlvHVBCb11QS29dUFRvXVBdb11QZm9dUG9vXVB4b11QQW+dUEpvnVBTb51QXG+dUGVvnVBub51Qd2+dUEBv3VBJb91QUm/dUFtv3VBkb91QbW/dUHZv3VB/b91QSHAdUFFwHVBacB1QY3AdUGxwHVB1cB1QfnAdUEdwXVBQcF1QWXBdUGJwXVBrcF1QdHBdUH1wXVBGcJ1QT3CdUFhwnVBhcJ1QanCdUHNwnVB8MJ1QRTDdUE4w3VBXMN1QYDDdUGkw3VByMN1QezDdUEQxHVBNMR1QVjEdUF8xHVBoMR1QcTEdUHoxHVBDMV1QTDFdUFUxXVBeMV1QZzFdUHAxXVB5MV1QQjGdUEsxnVBT8Z1QXPGdUGXxnVBu8Z1Qd/GdUEDx3VBJ8d1QUvHdUFvx3VBk8d1QbfHdUHbx3VB/8d1QSPIdUFHyHVBa8h1QY/IdUGyyHVB1sh1QfrIdUEeyXVBQsl1QWbJdUGKyXVBrsl1QdLJdUH2yXVBGsp1QT7KdUFiynVBhsp1QanKdUHNynVB8cp1QRXLdUE5y3VBXct1QYHLdUGly3VByct1Qe3LdUERzHVBNcx1QVjMdUF8zHVBoMx1QcTMdUHozHVBDM11QTDNdUFUzXVBeM11QZzNdUHAzXVB4811QQfOdUErznVBT851QXPOdUGXznVBu851Qd/OdUEDz3VBJ891QUrPdUFuz3VBks91QbbPdUHaz3VB/s91QSLQdUFG0HVBatB1QY3QdUGx0HVB1dB1QfnQdUEd0XVBQdF1QWXRdUGJ0XVBrdF1QdDRdUH00XVBGNJ1QTzSdUFg0nVBhNJ1QajSdUHM0nVB79J1QRPTdUE303VBW9N1QX/TdUGj03VBx9N1QerTdUEO1HVBMtR1QVbUdUF61HVBntR1QcLUdUHl1HVBCdV1QS3VdUFR1XVBddV1QZnVdUG91XVB4NV1QQTWdUEo1nVBTNZ1QXDWdUGU1nVBuNZ1QdvWdUH/1nVBI9d1QUfXdUFr13VBj9d1QbPXdUHW13VB+td1QR7YdUFC2HVBZth1QYrYdUGt2HVB0dh1QfXYdUEZ2XVBPdl1QWHZdUGE2XVBqNl1QczZdUHw2XVBFNp1QTjadUFb2nVBf9p1QaPadUHH2nVB69p1QQ/bdUEy23VBVtt1QXrbdUGe23VBwtt1QeXbdUEJ3HVBLdx1QVHcdUF13HVBmNx1QbzcdUHg3HVBBN11QSjddUFM3XVBb911QZPddUG33XVB2911Qf/ddUEi3nVBRt51QWredUGO3nVBst51QdXedUH53nVBHd91QUHfdUFl33VBiN91QazfdUHQ33VB9N91QRjgdUE74HVBX+B1QYPgdUGn4HVBy+B1Qe7gdUES4XVBNuF1QVrhdUF94XVBoeF1QcXhdUHp4XVBDeJ1QTDidUFU4nVBeOJ1QZzidUG/4nVB4+J1QQfjdUEr43VBT+N1QXLjdUGW43VBuuN1Qd7jdUEB5HVBJeR1QUnkdUFt5HVBkOR1QbTkdUHY5HVB/OR1QSDldUFD5XVBZ+V1QYvldUGv5XVB0uV1QfbldUEa5nVBPuZ1QWHmdUGF5nVBqeZ1Qc3mdUHw5nVBFOd1QTjndUFc53VBf+d1QaPndUHH53VB6+d1QQ7odUEy6HVBVuh1QXrodUGd6HVBweh1QeXodUEI6XVBLOl1QVDpdUF06XVBl+l1QbvpdUHf6XVBA+p1QSbqdUFK6nVBbup1QZLqdUG16nVB2ep1Qf3qdUEg63VBROt1QWjrdUGM63VBr+t1QdPrdUH363VBG+x1QT7sdUFi7HVBhux1QansdUHN7HVB8ex1QRXtdUE47XVBXO11QYDtdUGj7XVBx+11QevtdUEP7nVBMu51QVbudUF67nVBne51QcHudUHl7nVBCO91QSzvdUFQ73VBdO91QZfvdUG773VB3+91QQLwdUEm8HVBSvB1QW3wdUGR8HVBtfB1QdjwdUH88HVBIPF1QUTxdUFn8XVBi/F1Qa/xdUHS8XVB9vF1QRrydUE98nVBYfJ1QYXydUGo8nVBzPJ1QfDydUET83VBN/N1QVvzdUF+83VBovN1QcbzdUHp83VBDfR1QTH0dUFU9HVBePR1QZz0dUG/9HVB4/R1QQf1dUEq9XVBTvV1QXL1dUGV9XVBufV1Qd31dUEA9nVBJPZ1QUj2dUFr9nVBj/Z1QbP2dUHW9nVB+vZ1QR73dUFB93VBZfd1QYn3dUGs93VB0Pd1QfT3dUEX+HVBO/h1QV/4dUGC+HVBpvh1Qcn4dUHt+HVBEfl1QTT5dUFY+XVBfPl1QZ/5dUHD+XVB5/l1QQr6dUEu+nVBUfp1QXX6dUGZ+nVBvPp1QeD6dUEE+3VBJ/t1QUv7dUFv+3VBkvt1Qbb7dUHZ+3VB/ft1QSH8dUFE/HVBaPx1QYz8dUGv/HVB0/x1Qfb8dUEa/XVBPv11QWH9dUGF/XVBqP11Qcz9dUHw/XVBE/51QTf+dUFb/nVBfv51QaL+dUHF/nVB6f51QQ3/dUEw/3VBVP91QXf/dUGb/3VBv/91QeL/dUEGAHZBKQB2QU0AdkFxAHZBlAB2QbgAdkHbAHZB/wB2QSMBdkFGAXZBagF2QY0BdkGxAXZB1AF2QfgBdkEcAnZBPwJ2QWMCdkGGAnZBqgJ2Qc4CdkHxAnZBFQN2QTgDdkFcA3ZBfwN2QaMDdkHHA3ZB6gN2QQ4EdkExBHZBVQR2QXgEdkGcBHZBwAR2QeMEdkEHBXZBKgV2QU4FdkFxBXZBlQV2QbkFdkHcBXZBAAZ2QSMGdkFHBnZBagZ2QY4GdkGyBnZB1QZ2QfkGdkEcB3ZBQAd2QWMHdkGHB3ZBqgd2Qc4HdkHyB3ZBFQh2QTkIdkFcCHZBgAh2QaMIdkHHCHZB6gh2QQ4JdkExCXZBVQl2QXkJdkGcCXZBwAl2QeMJdkEHCnZBKgp2QU4KdkFxCnZBlQp2QbgKdkHcCnZB/wp2QSMLdkFHC3ZBagt2QY4LdkGxC3ZB1Qt2QfgLdkEcDHZBPwx2QWMMdkGGDHZBqgx2Qc0MdkHxDHZBFA12QTgNdkFbDXZBfw12QaINdkHGDXZB6Q12QQ0OdkEwDnZBVA52QXgOdkGbDnZBvw52QeIOdkEGD3ZBKQ92QU0PdkFwD3ZBlA92QbcPdkHbD3ZB/g92QSIQdkFFEHZBaRB2QYwQdkGwEHZB0xB2QfcQdkEaEXZBPhF2QWERdkGFEXZBqBF2QcwRdkHvEXZBExJ2QTYSdkFaEnZBfRJ2QaASdkHEEnZB5xJ2QQsTdkEuE3ZBUhN2QXUTdkGZE3ZBvBN2QeATdkEDFHZBJxR2QUoUdkFuFHZBkRR2QbUUdkHYFHZB/BR2QR8VdkFDFXZBZhV2QYoVdkGtFXZB0BV2QfQVdkEXFnZBOxZ2QV4WdkGCFnZBpRZ2QckWdkHsFnZBEBd2QTMXdkFXF3ZBehd2QZ0XdkHBF3ZB5Bd2QQgYdkErGHZBTxh2QXIYdkGWGHZBuRh2Qd0YdkEAGXZBIxl2QUcZdkFqGXZBjhl2QbEZdkHVGXZB+Bl2QRwadkE/GnZBYhp2QYYadkGpGnZBzRp2QfAadkEUG3ZBNxt2QVsbdkF+G3ZBoRt2QcUbdkHoG3ZBDBx2QS8cdkFTHHZBdhx2QZkcdkG9HHZB4Bx2QQQddkEnHXZBSx12QW4ddkGRHXZBtR12QdgddkH8HXZBHx52QUIedkFmHnZBiR52Qa0edkHQHnZB9B52QRcfdkE6H3ZBXh92QYEfdkGlH3ZByB92QesfdkEPIHZBMiB2QVYgdkF5IHZBnCB2QcAgdkHjIHZBByF2QSohdkFNIXZBcSF2QZQhdkG4IXZB2yF2Qf4hdkEiInZBRSJ2QWkidkGMInZBryJ2QdMidkH2InZBGiN2QT0jdkFgI3ZBhCN2QacjdkHKI3ZB7iN2QREkdkE1JHZBWCR2QXskdkGfJHZBwiR2QeYkdkEJJXZBLCV2QVAldkFzJXZBliV2QboldkHdJXZBASZ2QSQmdkFHJnZBayZ2QY4mdkGxJnZB1SZ2QfgmdkEbJ3ZBPyd2QWIndkGGJ3ZBqSd2QcwndkHwJ3ZBEyh2QTYodkFaKHZBfSh2QaAodkHEKHZB5yh2QQopdkEuKXZBUSl2QXUpdkGYKXZBuyl2Qd8pdkECKnZBJSp2QUkqdkFsKnZBjyp2QbMqdkHWKnZB+Sp2QR0rdkFAK3ZBYyt2QYcrdkGqK3ZBzSt2QfErdkEULHZBNyx2QVssdkF+LHZBoSx2QcUsdkHoLHZBCy12QS8tdkFSLXZBdS12QZktdkG8LXZB3y12QQMudkEmLnZBSS52QW0udkGQLnZBsy52QdcudkH6LnZBHS92QUEvdkFkL3ZBhy92QaovdkHOL3ZB8S92QRQwdkE4MHZBWzB2QX4wdkGiMHZBxTB2QegwdkEMMXZBLzF2QVIxdkF1MXZBmTF2QbwxdkHfMXZBAzJ2QSYydkFJMnZBbTJ2QZAydkGzMnZB1jJ2QfoydkEdM3ZBQDN2QWQzdkGHM3ZBqjN2Qc0zdkHxM3ZBFDR2QTc0dkFbNHZBfjR2QaE0dkHENHZB6DR2QQs1dkEuNXZBUjV2QXU1dkGYNXZBuzV2Qd81dkECNnZBJTZ2QUk2dkFsNnZBjzZ2QbI2dkHWNnZB+TZ2QRw3dkE/N3ZBYzd2QYY3dkGpN3ZBzTd2QfA3dkETOHZBNjh2QVo4dkF9OHZBoDh2QcM4dkHnOHZBCjl2QS05dkFQOXZBdDl2QZc5dkG6OXZB3Tl2QQE6dkEkOnZBRzp2QWo6dkGOOnZBsTp2QdQ6dkH3OnZBGzt2QT47dkFhO3ZBhDt2Qag7dkHLO3ZB7jt2QRE8dkE1PHZBWDx2QXs8dkGePHZBwTx2QeU8dkEIPXZBKz12QU49dkFyPXZBlT12Qbg9dkHbPXZB/z12QSI+dkFFPnZBaD52QYs+dkGvPnZB0j52QfU+dkEYP3ZBPD92QV8/dkGCP3ZBpT92Qcg/dkHsP3ZBD0B2QTJAdkFVQHZBeUB2QZxAdkG/QHZB4kB2QQVBdkEpQXZBTEF2QW9BdkGSQXZBtUF2QdlBdkH8QXZBH0J2QUJCdkFlQnZBiUJ2QaxCdkHPQnZB8kJ2QRVDdkE5Q3ZBXEN2QX9DdkGiQ3ZBxUN2QelDdkEMRHZBL0R2QVJEdkF1RHZBmUR2QbxEdkHfRHZBAkV2QSVFdkFIRXZBbEV2QY9FdkGyRXZB1UV2QfhFdkEcRnZBP0Z2QWJGdkGFRnZBqEZ2QctGdkHvRnZBEkd2QTVHdkFYR3ZBe0d2QZ5HdkHCR3ZB5Ud2QQhIdkErSHZBTkh2QXJIdkGVSHZBuEh2QdtIdkH+SHZBIUl2QURJdkFoSXZBi0l2Qa5JdkHRSXZB9El2QRdKdkE7SnZBXkp2QYFKdkGkSnZBx0p2QepKdkENS3ZBMUt2QVRLdkF3S3ZBmkt2Qb1LdkHgS3ZBBEx2QSdMdkFKTHZBbUx2QZBMdkGzTHZB1kx2QfpMdkEdTXZBQE12QWNNdkGGTXZBqU12QcxNdkHvTXZBE052QTZOdkFZTnZBfE52QZ9OdkHCTnZB5U52QQhPdkEsT3ZBT092QXJPdkGVT3ZBuE92QdtPdkH+T3ZBIVB2QUVQdkFoUHZBi1B2Qa5QdkHRUHZB9FB2QRdRdkE6UXZBXlF2QYFRdkGkUXZBx1F2QepRdkENUnZBMFJ2QVNSdkF2UnZBmVJ2Qb1SdkHgUnZBA1N2QSZTdkFJU3ZBbFN2QY9TdkGyU3ZB1VN2QflTdkEcVHZBP1R2QWJUdkGFVHZBqFR2QctUdkHuVHZBEVV2QTRVdkFXVXZBe1V2QZ5VdkHBVXZB5FV2QQdWdkEqVnZBTVZ2QXBWdkGTVnZBtlZ2QdlWdkH8VnZBIFd2QUNXdkFmV3ZBiVd2QaxXdkHPV3ZB8ld2QRVYdkE4WHZBW1h2QX5YdkGhWHZBxFh2QedYdkELWXZBLll2QVFZdkF0WXZBl1l2QbpZdkHdWXZBAFp2QSNadkFGWnZBaVp2QYxadkGvWnZB0lp2QfVadkEYW3ZBO1t2QV9bdkGCW3ZBpVt2QchbdkHrW3ZBDlx2QTFcdkFUXHZBd1x2QZpcdkG9XHZB4Fx2QQNddkEmXXZBSV12QWxddkGPXXZBsl12QdVddkH4XXZBG152QT5edkFiXnZBhV52QahedkHLXnZB7l52QRFfdkE0X3ZBV192QXpfdkGdX3ZBwF92QeNfdkEGYHZBKWB2QUxgdkFvYHZBkmB2QbVgdkHYYHZB+2B2QR5hdkFBYXZBZGF2QYdhdkGqYXZBzWF2QfBhdkETYnZBNmJ2QVlidkF8YnZBn2J2QcJidkHlYnZBCGN2QStjdkFOY3ZBcWN2QZRjdkG3Y3ZB2mN2Qf1jdkEgZHZBQ2R2QWZkdkGJZHZBrGR2Qc9kdkHyZHZBFWV2QThldkFbZXZBfmV2QaFldkHEZXZB52V2QQpmdkEtZnZBUGZ2QXNmdkGWZnZBuWZ2QdxmdkH/ZnZBImd2QUVndkFoZ3ZBi2d2Qa5ndkHRZ3ZB9Gd2QRdodkE6aHZBXWh2QYBodkGjaHZBxmh2QelodkEMaXZBL2l2QVJpdkF1aXZBmGl2QbtpdkHeaXZBAWp2QSRqdkFGanZBaWp2QYxqdkGvanZB0mp2QfVqdkEYa3ZBO2t2QV5rdkGBa3ZBpGt2QcdrdkHqa3ZBDWx2QTBsdkFTbHZBdmx2QZlsdkG8bHZB32x2QQJtdkElbXZBSG12QWptdkGNbXZBsG12QdNtdkH2bXZBGW52QTxudkFfbnZBgm52QaVudkHIbnZB6252QQ5vdkExb3ZBVG92QXdvdkGZb3ZBvG92Qd9vdkECcHZBJXB2QUhwdkFrcHZBjnB2QbFwdkHUcHZB93B2QRpxdkE9cXZBYHF2QYJxdkGlcXZByHF2QetxdkEOcnZBMXJ2QVRydkF3cnZBmnJ2Qb1ydkHgcnZBA3N2QSVzdkFIc3ZBa3N2QY5zdkGxc3ZB1HN2QfdzdkEadHZBPXR2QWB0dkGDdHZBpXR2Qch0dkHrdHZBDnV2QTF1dkFUdXZBd3V2QZp1dkG9dXZB4HV2QQJ2dkEldnZBSHZ2QWt2dkGOdnZBsXZ2QdR2dkH3dnZBGnd2QTx3dkFfd3ZBgnd2QaV3dkHId3ZB63d2QQ54dkExeHZBVHh2QXZ4dkGZeHZBvHh2Qd94dkECeXZBJXl2QUh5dkFreXZBjXl2QbB5dkHTeXZB9nl2QRl6dkE8enZBX3p2QYJ6dkGkenZBx3p2Qep6dkENe3ZBMHt2QVN7dkF2e3ZBmHt2Qbt7dkHee3ZBAXx2QSR8dkFHfHZBanx2QYx8dkGvfHZB0nx2QfV8dkEYfXZBO312QV59dkGAfXZBo312QcZ9dkHpfXZBDH52QS9+dkFSfnZBdH52QZd+dkG6fnZB3X52QQB/dkEjf3ZBRX92QWh/dkGLf3ZBrn92QdF/dkH0f3ZBFoB2QTmAdkFcgHZBf4B2QaKAdkHFgHZB54B2QQqBdkEtgXZBUIF2QXOBdkGWgXZBuIF2QduBdkH+gXZBIYJ2QUSCdkFngnZBiYJ2QayCdkHPgnZB8oJ2QRWDdkE4g3ZBWoN2QX2DdkGgg3ZBw4N2QeaDdkEIhHZBK4R2QU6EdkFxhHZBlIR2QbaEdkHZhHZB/IR2QR+FdkFChXZBZIV2QYeFdkGqhXZBzYV2QfCFdkEShnZBNYZ2QViGdkF7hnZBnoZ2QcCGdkHjhnZBBod2QSmHdkFMh3ZBbod2QZGHdkG0h3ZB14d2QfqHdkEciHZBP4h2QWKIdkGFiHZBqIh2QcqIdkHtiHZBEIl2QTOJdkFViXZBeIl2QZuJdkG+iXZB4Yl2QQOKdkEminZBSYp2QWyKdkGOinZBsYp2QdSKdkH3inZBGot2QTyLdkFfi3ZBgot2QaWLdkHHi3ZB6ot2QQ2MdkEwjHZBUox2QXWMdkGYjHZBu4x2Qd6MdkEAjXZBI412QUaNdkFpjXZBi412Qa6NdkHRjXZB9I12QRaOdkE5jnZBXI52QX+OdkGhjnZBxI52QeeOdkEKj3ZBLI92QU+PdkFyj3ZBlY92QbePdkHaj3ZB/Y92QSCQdkFCkHZBZZB2QYiQdkGqkHZBzZB2QfCQdkETkXZBNZF2QViRdkF7kXZBnpF2QcCRdkHjkXZBBpJ2QSmSdkFLknZBbpJ2QZGSdkGzknZB1pJ2QfmSdkEck3ZBPpN2QWGTdkGEk3ZBp5N2QcmTdkHsk3ZBD5R2QTGUdkFUlHZBd5R2QZqUdkG8lHZB35R2QQKVdkEklXZBR5V2QWqVdkGNlXZBr5V2QdKVdkH1lXZBF5Z2QTqWdkFdlnZBf5Z2QaKWdkHFlnZB6JZ2QQqXdkEtl3ZBUJd2QXKXdkGVl3ZBuJd2QdqXdkH9l3ZBIJh2QUOYdkFlmHZBiJh2QauYdkHNmHZB8Jh2QROZdkE1mXZBWJl2QXuZdkGdmXZBwJl2QeOZdkEGmnZBKJp2QUuadkFumnZBkJp2QbOadkHWmnZB+Jp2QRubdkE+m3ZBYJt2QYObdkGmm3ZByJt2QeubdkEOnHZBMJx2QVOcdkF2nHZBmJx2QbucdkHenHZBAJ12QSOddkFGnXZBaJ12QYuddkGunXZB0J12QfOddkEWnnZBOJ52QVuedkF+nnZBoJ52QcOedkHmnnZBCJ92QSufdkFOn3ZBcJ92QZOfdkG2n3ZB2J92QfufdkEdoHZBQKB2QWOgdkGFoHZBqKB2QcugdkHtoHZBEKF2QTOhdkFVoXZBeKF2QZuhdkG9oXZB4KF2QQKidkElonZBSKJ2QWqidkGNonZBsKJ2QdKidkH1onZBGKN2QTqjdkFdo3ZBf6N2QaKjdkHFo3ZB56N2QQqkdkEtpHZBT6R2QXKkdkGUpHZBt6R2QdqkdkH8pHZBH6V2QUGldkFkpXZBh6V2QamldkHMpXZB76V2QRGmdkE0pnZBVqZ2QXmmdkGcpnZBvqZ2QeGmdkEDp3ZBJqd2QUmndkFrp3ZBjqd2QbCndkHTp3ZB9qd2QRiodkE7qHZBXah2QYCodkGjqHZBxah2QeiodkEKqXZBLal2QVCpdkFyqXZBlal2QbepdkHaqXZB/al2QR+qdkFCqnZBZKp2QYeqdkGqqnZBzKp2Qe+qdkERq3ZBNKt2QVardkF5q3ZBnKt2Qb6rdkHhq3ZBA6x2QSasdkFJrHZBa6x2QY6sdkGwrHZB06x2QfWsdkEYrXZBO612QV2tdkGArXZBoq12QcWtdkHnrXZBCq52QS2udkFPrnZBcq52QZSudkG3rnZB2a52QfyudkEer3ZBQa92QWSvdkGGr3ZBqa92QcuvdkHur3ZBELB2QTOwdkFVsHZBeLB2QZuwdkG9sHZB4LB2QQKxdkElsXZBR7F2QWqxdkGMsXZBr7F2QdGxdkH0sXZBF7J2QTmydkFcsnZBfrJ2QaGydkHDsnZB5rJ2QQizdkErs3ZBTbN2QXCzdkGSs3ZBtbN2QdizdkH6s3ZBHbR2QT+0dkFitHZBhLR2Qae0dkHJtHZB7LR2QQ61dkExtXZBU7V2QXa1dkGYtXZBu7V2Qd21dkEAtnZBIrZ2QUW2dkFotnZBirZ2Qa22dkHPtnZB8rZ2QRS3dkE3t3ZBWbd2QXy3dkGet3ZBwbd2QeO3dkEGuHZBKLh2QUu4dkFtuHZBkLh2QbK4dkHVuHZB97h2QRq5dkE8uXZBX7l2QYG5dkGkuXZBxrl2Qem5dkELunZBLrp2QVC6dkFzunZBlbp2Qbi6dkHaunZB/bp2QR+7dkFCu3ZBZLt2QYe7dkGpu3ZBzLt2Qe67dkERvHZBM7x2QVW8dkF4vHZBmrx2Qb28dkHfvHZBAr12QSS9dkFHvXZBab12QYy9dkGuvXZB0b12QfO9dkEWvnZBOL52QVu+dkF9vnZBoL52QcK+dkHlvnZBB792QSm/dkFMv3ZBbr92QZG/dkGzv3ZB1r92Qfi/dkEbwHZBPcB2QWDAdkGCwHZBpcB2QcfAdkHpwHZBDMF2QS7BdkFRwXZBc8F2QZbBdkG4wXZB28F2Qf3BdkEgwnZBQsJ2QWTCdkGHwnZBqcJ2QczCdkHuwnZBEcN2QTPDdkFWw3ZBeMN2QZrDdkG9w3ZB38N2QQLEdkEkxHZBR8R2QWnEdkGLxHZBrsR2QdDEdkHzxHZBFcV2QTjFdkFaxXZBfMV2QZ/FdkHBxXZB5MV2QQbGdkEpxnZBS8Z2QW3GdkGQxnZBssZ2QdXGdkH3xnZBGsd2QTzHdkFex3ZBgcd2QaPHdkHGx3ZB6Md2QQrIdkEtyHZBT8h2QXLIdkGUyHZBt8h2QdnIdkH7yHZBHsl2QUDJdkFjyXZBhcl2QafJdkHKyXZB7Ml2QQ/KdkExynZBU8p2QXbKdkGYynZBu8p2Qd3KdkH/ynZBIst2QUTLdkFny3ZBict2QavLdkHOy3ZB8Mt2QRPMdkE1zHZBV8x2QXrMdkGczHZBv8x2QeHMdkEDzXZBJs12QUjNdkFqzXZBjc12Qa/NdkHSzXZB9M12QRbOdkE5znZBW852QX3OdkGgznZBws52QeXOdkEHz3ZBKc92QUzPdkFuz3ZBkM92QbPPdkHVz3ZB+M92QRrQdkE80HZBX9B2QYHQdkGj0HZBxtB2QejQdkEK0XZBLdF2QU/RdkFy0XZBlNF2QbbRdkHZ0XZB+9F2QR3SdkFA0nZBYtJ2QYTSdkGn0nZBydJ2QevSdkEO03ZBMNN2QVPTdkF103ZBl9N2QbrTdkHc03ZB/tN2QSHUdkFD1HZBZdR2QYjUdkGq1HZBzNR2Qe/UdkER1XZBM9V2QVbVdkF41XZBmtV2Qb3VdkHf1XZBAdZ2QSTWdkFG1nZBaNZ2QYvWdkGt1nZBz9Z2QfLWdkEU13ZBNtd2QVnXdkF713ZBndd2QcDXdkHi13ZBBNh2QSfYdkFJ2HZBa9h2QY7YdkGw2HZB0th2QfTYdkEX2XZBOdl2QVvZdkF+2XZBoNl2QcLZdkHl2XZBB9p2QSnadkFM2nZBbtp2QZDadkGz2nZB1dp2QffadkEZ23ZBPNt2QV7bdkGA23ZBo9t2QcXbdkHn23ZBCtx2QSzcdkFO3HZBcNx2QZPcdkG13HZB19x2QfrcdkEc3XZBPt12QWDddkGD3XZBpd12QcfddkHq3XZBDN52QS7edkFQ3nZBc952QZXedkG33nZB2t52QfzedkEe33ZBQN92QWPfdkGF33ZBp992QcrfdkHs33ZBDuB2QTDgdkFT4HZBdeB2QZfgdkG54HZB3OB2Qf7gdkEg4XZBQ+F2QWXhdkGH4XZBqeF2QczhdkHu4XZBEOJ2QTLidkFV4nZBd+J2QZnidkG74nZB3uJ2QQDjdkEi43ZBRON2QWfjdkGJ43ZBq+N2Qc3jdkHw43ZBEuR2QTTkdkFW5HZBeeR2QZvkdkG95HZB3+R2QQLldkEk5XZBRuV2QWjldkGL5XZBreV2Qc/ldkHx5XZBFOZ2QTbmdkFY5nZBeuZ2QZ3mdkG/5nZB4eZ2QQPndkEm53ZBSOd2QWrndkGM53ZBrud2QdHndkHz53ZBFeh2QTfodkFa6HZBfOh2QZ7odkHA6HZB4+h2QQXpdkEn6XZBSel2QWvpdkGO6XZBsOl2QdLpdkH06XZBF+p2QTnqdkFb6nZBfep2QZ/qdkHC6nZB5Op2QQbrdkEo63ZBSut2QW3rdkGP63ZBset2QdPrdkH163ZBGOx2QTrsdkFc7HZBfux2QaDsdkHD7HZB5ex2QQftdkEp7XZBS+12QW7tdkGQ7XZBsu12QdTtdkH27XZBGe52QTvudkFd7nZBf+52QaHudkHE7nZB5u52QQjvdkEq73ZBTO92QW/vdkGR73ZBs+92QdXvdkH373ZBGfB2QTzwdkFe8HZBgPB2QaLwdkHE8HZB5/B2QQnxdkEr8XZBTfF2QW/xdkGR8XZBtPF2QdbxdkH48XZBGvJ2QTzydkFe8nZBgfJ2QaPydkHF8nZB5/J2QQnzdkEr83ZBTvN2QXDzdkGS83ZBtPN2QdbzdkH483ZBG/R2QT30dkFf9HZBgfR2QaP0dkHF9HZB6PR2QQr1dkEs9XZBTvV2QXD1dkGS9XZBtPV2Qdf1dkH59XZBG/Z2QT32dkFf9nZBgfZ2QaP2dkHG9nZB6PZ2QQr3dkEs93ZBTvd2QXD3dkGS93ZBtfd2Qdf3dkH593ZBG/h2QT34dkFf+HZBgfh2QaT4dkHG+HZB6Ph2QQr5dkEs+XZBTvl2QXD5dkGS+XZBtfl2Qdf5dkH5+XZBG/p2QT36dkFf+nZBgfp2QaP6dkHG+nZB6Pp2QQr7dkEs+3ZBTvt2QXD7dkGS+3ZBtPt2Qdb7dkH5+3ZBG/x2QT38dkFf/HZBgfx2QaP8dkHF/HZB5/x2QQn9dkEs/XZBTv12QXD9dkGS/XZBtP12Qdb9dkH4/XZBGv52QTz+dkFe/nZBgf52QaP+dkHF/nZB5/52QQn/dkEr/3ZBTf92QW//dkGR/3ZBs/92Qdb/dkH4/3ZBGgB3QTwAd0FeAHdBgAB3QaIAd0HEAHdB5gB3QQgBd0EqAXdBTAF3QW8Bd0GRAXdBswF3QdUBd0H3AXdBGQJ3QTsCd0FdAndBfwJ3QaECd0HDAndB5QJ3QQcDd0EqA3dBTAN3QW4Dd0GQA3dBsgN3QdQDd0H2A3dBGAR3QToEd0FcBHdBfgR3QaAEd0HCBHdB5AR3QQYFd0EpBXdBSwV3QW0Fd0GPBXdBsQV3QdMFd0H1BXdBFwZ3QTkGd0FbBndBfQZ3QZ8Gd0HBBndB4wZ3QQUHd0EnB3dBSQd3QWsHd0GOB3dBsAd3QdIHd0H0B3dBFgh3QTgId0FaCHdBfAh3QZ4Id0HACHdB4gh3QQQJd0EmCXdBSAl3QWoJd0GMCXdBrgl3QdAJd0HyCXdBFAp3QTYKd0FYCndBegp3QZwKd0G+CndB4Ap3QQILd0EkC3dBRgt3QWkLd0GLC3dBrQt3Qc8Ld0HxC3dBEwx3QTUMd0FXDHdBeQx3QZsMd0G9DHdB3wx3QQENd0EjDXdBRQ13QWcNd0GJDXdBqw13Qc0Nd0HvDXdBEQ53QTMOd0FVDndBdw53QZkOd0G7DndB3Q53Qf8Od0EhD3dBQw93QWUPd0GHD3dBqQ93QcsPd0HtD3dBDxB3QTEQd0FTEHdBdRB3QZcQd0G5EHdB2xB3Qf0Qd0EfEXdBQRF3QWMRd0GFEXdBpxF3QckRd0HrEXdBDRJ3QS8Sd0FREndBcxJ3QZUSd0G3EndB2RJ3QfsSd0EdE3dBPxN3QWETd0GDE3dBpRN3QccTd0HoE3dBChR3QSwUd0FOFHdBcBR3QZIUd0G0FHdB1hR3QfgUd0EaFXdBPBV3QV4Vd0GAFXdBohV3QcQVd0HmFXdBCBZ3QSoWd0FMFndBbhZ3QZAWd0GyFndB1BZ3QfYWd0EYF3dBOhd3QVwXd0F+F3dBnxd3QcEXd0HjF3dBBRh3QScYd0FJGHdBaxh3QY0Yd0GvGHdB0Rh3QfMYd0EVGXdBNxl3QVkZd0F7GXdBnRl3Qb8Zd0HhGXdBAxp3QSQad0FGGndBaBp3QYoad0GsGndBzhp3QfAad0ESG3dBNBt3QVYbd0F4G3dBmht3Qbwbd0HeG3dBABx3QSEcd0FDHHdBZRx3QYccd0GpHHdByxx3Qe0cd0EPHXdBMR13QVMdd0F1HXdBlx13Qbkdd0HaHXdB/B13QR4ed0FAHndBYh53QYQed0GmHndByB53Qeoed0EMH3dBLh93QVAfd0FxH3dBkx93QbUfd0HXH3dB+R93QRsgd0E9IHdBXyB3QYEgd0GjIHdBxCB3QeYgd0EIIXdBKiF3QUwhd0FuIXdBkCF3QbIhd0HUIXdB9iF3QRcid0E5IndBWyJ3QX0id0GfIndBwSJ3QeMid0EFI3dBJyN3QUgjd0FqI3dBjCN3Qa4jd0HQI3dB8iN3QRQkd0E2JHdBWCR3QXkkd0GbJHdBvSR3Qd8kd0EBJXdBIyV3QUUld0FnJXdBiCV3Qaold0HMJXdB7iV3QRAmd0EyJndBVCZ3QXYmd0GXJndBuSZ3Qdsmd0H9JndBHyd3QUEnd0FjJ3dBhCd3QaYnd0HIJ3dB6id3QQwod0EuKHdBUCh3QXEod0GTKHdBtSh3Qdcod0H5KHdBGyl3QT0pd0FeKXdBgCl3QaIpd0HEKXdB5il3QQgqd0EqKndBSyp3QW0qd0GPKndBsSp3QdMqd0H1KndBFit3QTgrd0FaK3dBfCt3QZ4rd0HAK3dB4it3QQMsd0ElLHdBRyx3QWksd0GLLHdBrSx3Qc4sd0HwLHdBEi13QTQtd0FWLXdBeC13QZktd0G7LXdB3S13Qf8td0EhLndBQi53QWQud0GGLndBqC53Qcoud0HsLndBDS93QS8vd0FRL3dBcy93QZUvd0G2L3dB2C93Qfovd0EcMHdBPjB3QWAwd0GBMHdBozB3QcUwd0HnMHdBCTF3QSoxd0FMMXdBbjF3QZAxd0GyMXdB0zF3QfUxd0EXMndBOTJ3QVsyd0F8MndBnjJ3QcAyd0HiMndBBDN3QSUzd0FHM3dBaTN3QYszd0GtM3dBzjN3QfAzd0ESNHdBNDR3QVY0d0F3NHdBmTR3Qbs0d0HdNHdB/zR3QSA1d0FCNXdBZDV3QYY1d0GnNXdByTV3Qes1d0ENNndBLzZ3QVA2d0FyNndBlDZ3QbY2d0HXNndB+TZ3QRs3d0E9N3dBXzd3QYA3d0GiN3dBxDd3QeY3d0EHOHdBKTh3QUs4d0FtOHdBjjh3QbA4d0HSOHdB9Dh3QRU5d0E3OXdBWTl3QXs5d0GdOXdBvjl3QeA5d0ECOndBJDp3QUU6d0FnOndBiTp3Qas6d0HMOndB7jp3QRA7d0EyO3dBUzt3QXU7d0GXO3dBuTt3Qdo7d0H8O3dBHjx3QUA8d0FhPHdBgzx3QaU8d0HHPHdB6Dx3QQo9d0EsPXdBTT13QW89d0GRPXdBsz13QdQ9d0H2PXdBGD53QTo+d0FbPndBfT53QZ8+d0HBPndB4j53QQQ/d0EmP3dBRz93QWk/d0GLP3dBrT93Qc4/d0HwP3dBEkB3QTRAd0FVQHdBd0B3QZlAd0G6QHdB3EB3Qf5Ad0EgQXdBQUF3QWNBd0GFQXdBpkF3QchBd0HqQXdBDEJ3QS1Cd0FPQndBcUJ3QZJCd0G0QndB1kJ3QfhCd0EZQ3dBO0N3QV1Dd0F+Q3dBoEN3QcJDd0HjQ3dBBUR3QSdEd0FJRHdBakR3QYxEd0GuRHdBz0R3QfFEd0ETRXdBNEV3QVZFd0F4RXdBmUV3QbtFd0HdRXdB/0V3QSBGd0FCRndBZEZ3QYVGd0GnRndByUZ3QepGd0EMR3dBLkd3QU9Hd0FxR3dBk0d3QbRHd0HWR3dB+Ed3QRlId0E7SHdBXUh3QX9Id0GgSHdBwkh3QeRId0EFSXdBJ0l3QUlJd0FqSXdBjEl3Qa5Jd0HPSXdB8Ul3QRNKd0E0SndBVkp3QXhKd0GZSndBu0p3Qd1Kd0H+SndBIEt3QUFLd0FjS3dBhUt3QaZLd0HIS3dB6kt3QQtMd0EtTHdBT0x3QXBMd0GSTHdBtEx3QdVMd0H3THdBGU13QTpNd0FcTXdBfk13QZ9Nd0HBTXdB4013QQROd0EmTndBR053QWlOd0GLTndBrE53Qc5Od0HwTndBEU93QTNPd0FVT3dBdk93QZhPd0G5T3dB2093Qf1Pd0EeUHdBQFB3QWJQd0GDUHdBpVB3QcZQd0HoUHdBClF3QStRd0FNUXdBb1F3QZBRd0GyUXdB01F3QfVRd0EXUndBOFJ3QVpSd0F8UndBnVJ3Qb9Sd0HgUndBAlN3QSRTd0FFU3dBZ1N3QYhTd0GqU3dBzFN3Qe1Td0EPVHdBMVR3QVJUd0F0VHdBlVR3QbdUd0HZVHdB+lR3QRxVd0E9VXdBX1V3QYFVd0GiVXdBxFV3QeVVd0EHVndBKVZ3QUpWd0FsVndBjVZ3Qa9Wd0HRVndB8lZ3QRRXd0E1V3dBV1d3QXhXd0GaV3dBvFd3Qd1Xd0H/V3dBIFh3QUJYd0FkWHdBhVh3QadYd0HIWHdB6lh3QQxZd0EtWXdBT1l3QXBZd0GSWXdBs1l3QdVZd0H3WXdBGFp3QTpad0FbWndBfVp3QZ5ad0HAWndB4lp3QQNbd0ElW3dBRlt3QWhbd0GJW3dBq1t3Qc1bd0HuW3dBEFx3QTFcd0FTXHdBdFx3QZZcd0G3XHdB2Vx3Qftcd0EcXXdBPl13QV9dd0GBXXdBol13QcRdd0HlXXdBB153QSled0FKXndBbF53QY1ed0GvXndB0F53QfJed0ETX3dBNV93QVZfd0F4X3dBml93Qbtfd0HdX3dB/l93QSBgd0FBYHdBY2B3QYRgd0GmYHdBx2B3Qelgd0EKYXdBLGF3QU5hd0FvYXdBkWF3QbJhd0HUYXdB9WF3QRdid0E4YndBWmJ3QXtid0GdYndBvmJ3QeBid0EBY3dBI2N3QURjd0FmY3dBiGN3Qaljd0HLY3dB7GN3QQ5kd0EvZHdBUWR3QXJkd0GUZHdBtWR3Qddkd0H4ZHdBGmV3QTtld0FdZXdBfmV3QaBld0HBZXdB42V3QQRmd0EmZndBR2Z3QWlmd0GKZndBrGZ3Qc1md0HvZndBEGd3QTJnd0FTZ3dBdWd3QZZnd0G4Z3dB2Wd3Qftnd0EcaHdBPmh3QV9od0GBaHdBomh3QcRod0HlaHdBB2l3QShpd0FKaXdBa2l3QY1pd0GuaXdB0Gl3QfFpd0ETandBNGp3QVZqd0F3andBmWp3Qbpqd0HbandB/Wp3QR5rd0FAa3dBYWt3QYNrd0Gka3dBxmt3Qedrd0EJbHdBKmx3QUxsd0FtbHdBj2x3QbBsd0HSbHdB82x3QRVtd0E2bXdBV213QXltd0GabXdBvG13Qd1td0H/bXdBIG53QUJud0FjbndBhW53QaZud0HIbndB6W53QQpvd0Esb3dBTW93QW9vd0GQb3dBsm93QdNvd0H1b3dBFnB3QThwd0FZcHdBenB3QZxwd0G9cHdB33B3QQBxd0EicXdBQ3F3QWVxd0GGcXdBp3F3Qclxd0HqcXdBDHJ3QS1yd0FPcndBcHJ3QZFyd0GzcndB1HJ3QfZyd0EXc3dBOXN3QVpzd0F7c3dBnXN3Qb5zd0Hgc3dBAXR3QSN0d0FEdHdBZXR3QYd0d0GodHdBynR3Qet0d0ENdXdBLnV3QU91d0FxdXdBknV3QbR1d0HVdXdB93V3QRh2d0E5dndBW3Z3QXx2d0GedndBv3Z3QeB2d0ECd3dBI3d3QUV3d0Fmd3dBh3d3Qal3d0HKd3dB7Hd3QQ14d0EueHdBUHh3QXF4d0GTeHdBtHh3QdV4d0H3eHdBGHl3QTp5d0FbeXdBfHl3QZ55d0G/eXdB4Xl3QQJ6d0EjendBRXp3QWZ6d0GIendBqXp3Qcp6d0HsendBDXt3QS97d0FQe3dBcXt3QZN7d0G0e3dB1Xt3Qfd7d0EYfHdBOnx3QVt8d0F8fHdBnnx3Qb98d0HhfHdBAn13QSN9d0FFfXdBZn13QYd9d0GpfXdByn13Qex9d0ENfndBLn53QVB+d0FxfndBkn53QbR+d0HVfndB9n53QRh/d0E5f3dBW393QXx/d0Gdf3dBv393QeB/d0EBgHdBI4B3QUSAd0FlgHdBh4B3QaiAd0HKgHdB64B3QQyBd0EugXdBT4F3QXCBd0GSgXdBs4F3QdSBd0H2gXdBF4J3QTiCd0FagndBe4J3QZyCd0G+gndB34J3QQCDd0Eig3dBQ4N3QWSDd0GGg3dBp4N3QciDd0Hqg3dBC4R3QSyEd0FOhHdBb4R3QZCEd0GyhHdB04R3QfSEd0EWhXdBN4V3QViFd0F6hXdBm4V3QbyFd0HehXdB/4V3QSCGd0FChndBY4Z3QYSGd0GmhndBx4Z3QeiGd0EKh3dBK4d3QUyHd0Fuh3dBj4d3QbCHd0HSh3dB84d3QRSId0E2iHdBV4h3QXiId0GZiHdBu4h3QdyId0H9iHdBH4l3QUCJd0FhiXdBg4l3QaSJd0HFiXdB54l3QQiKd0EpindBSop3QWyKd0GNindBrop3QdCKd0HxindBEot3QTSLd0FVi3dBdot3QZeLd0G5i3dB2ot3QfuLd0EdjHdBPox3QV+Md0GAjHdBoox3QcOMd0HkjHdBBo13QSeNd0FIjXdBaY13QYuNd0GsjXdBzY13Qe+Nd0EQjndBMY53QVKOd0F0jndBlY53QbaOd0HYjndB+Y53QRqPd0E7j3dBXY93QX6Pd0Gfj3dBwI93QeKPd0EDkHdBJJB3QUaQd0FnkHdBiJB3QamQd0HLkHdB7JB3QQ2Rd0EukXdBUJF3QXGRd0GSkXdBs5F3QdWRd0H2kXdBF5J3QTiSd0FakndBe5J3QZySd0G9kndB35J3QQCTd0Ehk3dBQpN3QWSTd0GFk3dBppN3QceTd0Hpk3dBCpR3QSuUd0FMlHdBbpR3QY+Ud0GwlHdB0ZR3QfOUd0EUlXdBNZV3QVaVd0F4lXdBmZV3QbqVd0HblXdB/ZV3QR6Wd0E/lndBYJZ3QYKWd0GjlndBxJZ3QeWWd0EGl3dBKJd3QUmXd0Fql3dBi5d3Qa2Xd0HOl3dB75d3QRCYd0ExmHdBU5h3QXSYd0GVmHdBtph3QdiYd0H5mHdBGpl3QTuZd0FcmXdBfpl3QZ+Zd0HAmXdB4Zl3QQOad0EkmndBRZp3QWaad0GHmndBqZp3Qcqad0HrmndBDJt3QS2bd0FPm3dBcJt3QZGbd0Gym3dB05t3QfWbd0EWnHdBN5x3QVicd0F5nHdBm5x3Qbycd0HdnHdB/px3QR+dd0FBnXdBYp13QYOdd0GknXdBxZ13Qeedd0EInndBKZ53QUqed0FrnndBjZ53Qa6ed0HPnndB8J53QRGfd0Eyn3dBVJ93QXWfd0GWn3dBt593Qdifd0H6n3dBG6B3QTygd0FdoHdBfqB3QZ+gd0HBoHdB4qB3QQOhd0EkoXdBRaF3QWahd0GIoXdBqaF3Qcqhd0HroXdBDKJ3QS6id0FPondBcKJ3QZGid0GyondB06J3QfSid0EWo3dBN6N3QVijd0F5o3dBmqN3Qbujd0Hdo3dB/qN3QR+kd0FApHdBYaR3QYKkd0GkpHdBxaR3Qeakd0EHpXdBKKV3QUmld0FqpXdBjKV3Qa2ld0HOpXdB76V3QRCmd0ExpndBUqZ3QXSmd0GVpndBtqZ3Qdemd0H4pndBGad3QTqnd0Fcp3dBfad3QZ6nd0G/p3dB4Kd3QQGod0EiqHdBRKh3QWWod0GGqHdBp6h3Qciod0HpqHdBCql3QSupd0FNqXdBbql3QY+pd0GwqXdB0al3QfKpd0ETqndBNKp3QVaqd0F3qndBmKp3Qbmqd0HaqndB+6p3QRyrd0E9q3dBX6t3QYCrd0Ghq3dBwqt3QeOrd0EErHdBJax3QUasd0FnrHdBiax3Qaqsd0HLrHdB7Kx3QQ2td0EurXdBT613QXCtd0GRrXdBsq13QdStd0H1rXdBFq53QTeud0FYrndBea53QZqud0G7rndB3K53Qf2ud0Efr3dBQK93QWGvd0GCr3dBo693QcSvd0Hlr3dBBrB3QSewd0FIsHdBabB3QYuwd0GssHdBzbB3Qe6wd0EPsXdBMLF3QVGxd0FysXdBk7F3QbSxd0HVsXdB9rF3QRiyd0E5sndBWrJ3QXuyd0GcsndBvbJ3Qd6yd0H/sndBILN3QUGzd0Fis3dBg7N3QaSzd0HFs3dB57N3QQi0d0EptHdBSrR3QWu0d0GMtHdBrbR3Qc60d0HvtHdBELV3QTG1d0FStXdBc7V3QZS1d0G1tXdB1rV3Qfi1d0EZtndBOrZ3QVu2d0F8tndBnbZ3Qb62d0HftndBALd3QSG3d0FCt3dBY7d3QYS3d0Glt3dBxrd3Qee3d0EIuHdBKbh3QUq4d0FruHdBjbh3Qa64d0HPuHdB8Lh3QRG5d0EyuXdBU7l3QXS5d0GVuXdBtrl3Qde5d0H4uXdBGbp3QTq6d0FbundBfLp3QZ26d0G+undB37p3QQC7d0Ehu3dBQrt3QWO7d0GEu3dBpbt3Qca7d0Hnu3dBCLx3QSm8d0FKvHdBa7x3QYy8d0GtvHdBz7x3QfC8d0ERvXdBMr13QVO9d0F0vXdBlb13Qba9d0HXvXdB+L13QRm+d0E6vndBW753QXy+d0GdvndBvr53Qd++d0EAv3dBIb93QUK/d0Fjv3dBhL93QaW/d0HGv3dB5793QQjAd0EpwHdBSsB3QWvAd0GMwHdBrcB3Qc7Ad0HvwHdBEMF3QTHBd0FSwXdBc8F3QZTBd0G1wXdB1sF3QffBd0EYwndBOcJ3QVrCd0F7wndBnMJ3Qb3Cd0HewndB/8J3QSDDd0FAw3dBYcN3QYLDd0Gjw3dBxMN3QeXDd0EGxHdBJ8R3QUjEd0FpxHdBisR3QavEd0HMxHdB7cR3QQ7Fd0EvxXdBUMV3QXHFd0GSxXdBs8V3QdTFd0H1xXdBFsZ3QTfGd0FYxndBecZ3QZrGd0G7xndB3MZ3Qf3Gd0Eex3dBP8d3QWDHd0GBx3dBocd3QcLHd0Hjx3dBBMh3QSXId0FGyHdBZ8h3QYjId0GpyHdBysh3QevId0EMyXdBLcl3QU7Jd0FvyXdBkMl3QbHJd0HSyXdB88l3QRTKd0E0yndBVcp3QXbKd0GXyndBuMp3QdnKd0H6yndBG8t3QTzLd0Fdy3dBfst3QZ/Ld0HAy3dB4ct3QQLMd0EjzHdBQ8x3QWTMd0GFzHdBpsx3QcfMd0HozHdBCc13QSrNd0FLzXdBbM13QY3Nd0GuzXdBz813QfDNd0EQzndBMc53QVLOd0FzzndBlM53QbXOd0HWzndB9853QRjPd0E5z3dBWs93QXvPd0Gbz3dBvM93Qd3Pd0H+z3dBH9B3QUDQd0Fh0HdBgtB3QaPQd0HE0HdB5dB3QQXRd0Em0XdBR9F3QWjRd0GJ0XdBqtF3QcvRd0Hs0XdBDdJ3QS7Sd0FO0ndBb9J3QZDSd0Gx0ndB0tJ3QfPSd0EU03dBNdN3QVbTd0F303dBl9N3QbjTd0HZ03dB+tN3QRvUd0E81HdBXdR3QX7Ud0Ge1HdBv9R3QeDUd0EB1XdBItV3QUPVd0Fk1XdBhdV3QabVd0HG1XdB59V3QQjWd0Ep1ndBStZ3QWvWd0GM1ndBrdZ3Qc3Wd0Hu1ndBD9d3QTDXd0FR13dBctd3QZPXd0G013dB1Nd3QfXXd0EW2HdBN9h3QVjYd0F52HdBmth3QbrYd0Hb2HdB/Nh3QR3Zd0E+2XdBX9l3QYDZd0Gg2XdBwdl3QeLZd0ED2ndBJNp3QUXad0Fm2ndBhtp3Qafad0HI2ndB6dp3QQrbd0Er23dBTNt3QWzbd0GN23dBrtt3Qc/bd0Hw23dBEdx3QTHcd0FS3HdBc9x3QZTcd0G13HdB1tx3Qffcd0EX3XdBON13QVndd0F63XdBm913Qbzdd0Hc3XdB/d13QR7ed0E/3ndBYN53QYHed0Gh3ndBwt53QePed0EE33dBJd93QUXfd0Fm33dBh993Qajfd0HJ33dB6t93QQrgd0Er4HdBTOB3QW3gd0GO4HdBr+B3Qc/gd0Hw4HdBEeF3QTLhd0FT4XdBc+F3QZThd0G14XdB1uF3Qffhd0EX4ndBOOJ3QVnid0F64ndBm+J3Qbzid0Hc4ndB/eJ3QR7jd0E/43dBYON3QYDjd0Gh43dBwuN3QePjd0EE5HdBJOR3QUXkd0Fm5HdBh+R3Qajkd0HI5HdB6eR3QQrld0Er5XdBTOV3QWzld0GN5XdBruV3Qc/ld0Hv5XdBEOZ3QTHmd0FS5ndBc+Z3QZPmd0G05ndB1eZ3Qfbmd0EX53dBN+d3QVjnd0F553dBmud3Qbrnd0Hb53dB/Od3QR3od0E+6HdBXuh3QX/od0Gg6HdBweh3QeHod0EC6XdBI+l3QUTpd0Fl6XdBhel3Qabpd0HH6XdB6Ol3QQjqd0Ep6ndBSup3QWvqd0GL6ndBrOp3Qc3qd0Hu6ndBDut3QS/rd0FQ63dBcet3QZHrd0Gy63dB0+t3QfTrd0EV7HdBNex3QVbsd0F37HdBmOx3Qbjsd0HZ7HdB+ux3QRvtd0E77XdBXO13QX3td0Ge7XdBvu13Qd/td0EA7ndBIO53QUHud0Fi7ndBg+53QaPud0HE7ndB5e53QQbvd0Em73dBR+93QWjvd0GJ73dBqe93Qcrvd0Hr73dBDPB3QSzwd0FN8HdBbvB3QY7wd0Gv8HdB0PB3QfHwd0ER8XdBMvF3QVPxd0F08XdBlPF3QbXxd0HW8XdB9vF3QRfyd0E48ndBWfJ3QXnyd0Ga8ndBu/J3Qdzyd0H88ndBHfN3QT7zd0Fe83dBf/N3QaDzd0HB83dB4fN3QQL0d0Ej9HdBQ/R3QWT0d0GF9HdBpfR3Qcb0d0Hn9HdBCPV3QSj1d0FJ9XdBavV3QYr1d0Gr9XdBzPV3Qe31d0EN9ndBLvZ3QU/2d0Fv9ndBkPZ3QbH2d0HR9ndB8vZ3QRP3d0Ez93dBVPd3QXX3d0GW93dBtvd3Qdf3d0H493dBGPh3QTn4d0Fa+HdBevh3QZv4d0G8+HdB3Ph3Qf34d0Ee+XdBPvl3QV/5d0GA+XdBofl3QcH5d0Hi+XdBA/p3QSP6d0FE+ndBZfp3QYX6d0Gm+ndBx/p3Qef6d0EI+3dBKft3QUn7d0Fq+3dBi/t3Qav7d0HM+3dB7ft3QQ38d0Eu/HdBT/x3QW/8d0GQ/HdBsfx3QdH8d0Hy/HdBE/13QTP9d0FU/XdBdf13QZX9d0G2/XdB1/13Qff9d0EY/ndBOf53QVn+d0F6/ndBm/53Qbv+d0Hc/ndB/P53QR3/d0E+/3dBXv93QX//d0Gg/3dBwP93QeH/d0ECAHhBIgB4QUMAeEFkAHhBhAB4QaUAeEHFAHhB5gB4QQcBeEEnAXhBSAF4QWkBeEGJAXhBqgF4QcsBeEHrAXhBDAJ4QSwCeEFNAnhBbgJ4QY4CeEGvAnhB0AJ4QfACeEERA3hBMgN4QVIDeEFzA3hBkwN4QbQDeEHVA3hB9QN4QRYEeEE3BHhBVwR4QXgEeEGYBHhBuQR4QdoEeEH6BHhBGwV4QTsFeEFcBXhBfQV4QZ0FeEG+BXhB3wV4Qf8FeEEgBnhBQAZ4QWEGeEGCBnhBogZ4QcMGeEHjBnhBBAd4QSUHeEFFB3hBZgd4QYYHeEGnB3hByAd4QegHeEEJCHhBKQh4QUoIeEFrCHhBiwh4QawIeEHMCHhB7Qh4QQ4JeEEuCXhBTwl4QW8JeEGQCXhBsQl4QdEJeEHyCXhBEgp4QTMKeEFUCnhBdAp4QZUKeEG1CnhB1gp4QfYKeEEXC3hBOAt4QVgLeEF5C3hBmQt4QboLeEHbC3hB+wt4QRwMeEE8DHhBXQx4QX0MeEGeDHhBvwx4Qd8MeEEADXhBIA14QUENeEFhDXhBgg14QaMNeEHDDXhB5A14QQQOeEElDnhBRQ54QWYOeEGHDnhBpw54QcgOeEHoDnhBCQ94QSkPeEFKD3hBag94QYsPeEGsD3hBzA94Qe0PeEENEHhBLhB4QU4QeEFvEHhBjxB4QbAQeEHREHhB8RB4QRIReEEyEXhBUxF4QXMReEGUEXhBtBF4QdUReEH2EXhBFhJ4QTcSeEFXEnhBeBJ4QZgSeEG5EnhB2RJ4QfoSeEEaE3hBOxN4QVsTeEF8E3hBnRN4Qb0TeEHeE3hB/hN4QR8UeEE/FHhBYBR4QYAUeEGhFHhBwRR4QeIUeEECFXhBIxV4QUMVeEFkFXhBhRV4QaUVeEHGFXhB5hV4QQcWeEEnFnhBSBZ4QWgWeEGJFnhBqRZ4QcoWeEHqFnhBCxd4QSsXeEFMF3hBbBd4QY0XeEGtF3hBzhd4Qe4XeEEPGHhBLxh4QVAYeEFwGHhBkRh4QbEYeEHSGHhB8hh4QRMZeEEzGXhBVBl4QXQZeEGVGXhBtRl4QdYZeEH2GXhBFxp4QTcaeEFYGnhBeBp4QZkaeEG5GnhB2hp4QfoaeEEbG3hBOxt4QVwbeEF8G3hBnRt4Qb0beEHeG3hB/ht4QR8ceEE/HHhBYBx4QYAceEGhHHhBwRx4QeIceEECHXhBIx14QUMdeEFkHXhBhB14QaUdeEHFHXhB5h14QQYeeEEnHnhBRx54QWgeeEGIHnhBqR54QckeeEHqHnhBCh94QSofeEFLH3hBax94QYwfeEGsH3hBzR94Qe0feEEOIHhBLiB4QU8geEFvIHhBkCB4QbAgeEHRIHhB8SB4QREheEEyIXhBUiF4QXMheEGTIXhBtCF4QdQheEH1IXhBFSJ4QTYieEFWInhBdyJ4QZcieEG3InhB2CJ4QfgieEEZI3hBOSN4QVojeEF6I3hBmyN4QbsjeEHbI3hB/CN4QRwkeEE9JHhBXSR4QX4keEGeJHhBvyR4Qd8keEH/JHhBICV4QUAleEFhJXhBgSV4QaIleEHCJXhB4yV4QQMmeEEjJnhBRCZ4QWQmeEGFJnhBpSZ4QcYmeEHmJnhBBid4QScneEFHJ3hBaCd4QYgneEGpJ3hBySd4QekneEEKKHhBKih4QUsoeEFrKHhBjCh4QawoeEHMKHhB7Sh4QQ0peEEuKXhBTil4QW4peEGPKXhBryl4QdApeEHwKXhBESp4QTEqeEFRKnhBcip4QZIqeEGzKnhB0yp4QfMqeEEUK3hBNCt4QVUreEF1K3hBlSt4QbYreEHWK3hB9yt4QRcseEE3LHhBWCx4QXgseEGZLHhBuSx4QdkseEH6LHhBGi14QTsteEFbLXhBey14QZwteEG8LXhB3S14Qf0teEEdLnhBPi54QV4ueEF/LnhBny54Qb8ueEHgLnhBAC94QSAveEFBL3hBYS94QYIveEGiL3hBwi94QeMveEEDMHhBJDB4QUQweEFkMHhBhTB4QaUweEHFMHhB5jB4QQYxeEEnMXhBRzF4QWcxeEGIMXhBqDF4QcgxeEHpMXhBCTJ4QSoyeEFKMnhBajJ4QYsyeEGrMnhByzJ4QewyeEEMM3hBLDN4QU0zeEFtM3hBjjN4Qa4zeEHOM3hB7zN4QQ80eEEvNHhBUDR4QXA0eEGQNHhBsTR4QdE0eEHxNHhBEjV4QTI1eEFTNXhBczV4QZM1eEG0NXhB1DV4QfQ1eEEVNnhBNTZ4QVU2eEF2NnhBljZ4QbY2eEHXNnhB9zZ4QRc3eEE4N3hBWDd4QXg3eEGZN3hBuTd4Qdk3eEH6N3hBGjh4QTo4eEFbOHhBezh4QZs4eEG8OHhB3Dh4Qfw4eEEdOXhBPTl4QV05eEF+OXhBnjl4Qb45eEHfOXhB/zl4QR86eEFAOnhBYDp4QYA6eEGhOnhBwTp4QeE6eEECO3hBIjt4QUI7eEFjO3hBgzt4QaM7eEHEO3hB5Dt4QQQ8eEEkPHhBRTx4QWU8eEGFPHhBpjx4QcY8eEHmPHhBBz14QSc9eEFHPXhBaD14QYg9eEGoPXhByT14Qek9eEEJPnhBKT54QUo+eEFqPnhBij54Qas+eEHLPnhB6z54QQw/eEEsP3hBTD94QWw/eEGNP3hBrT94Qc0/eEHuP3hBDkB4QS5AeEFOQHhBb0B4QY9AeEGvQHhB0EB4QfBAeEEQQXhBMEF4QVFBeEFxQXhBkUF4QbJBeEHSQXhB8kF4QRJCeEEzQnhBU0J4QXNCeEGUQnhBtEJ4QdRCeEH0QnhBFUN4QTVDeEFVQ3hBdkN4QZZDeEG2Q3hB1kN4QfdDeEEXRHhBN0R4QVdEeEF4RHhBmER4QbhEeEHZRHhB+UR4QRlFeEE5RXhBWkV4QXpFeEGaRXhBukV4QdtFeEH7RXhBG0Z4QTtGeEFcRnhBfEZ4QZxGeEG8RnhB3UZ4Qf1GeEEdR3hBPUd4QV5HeEF+R3hBnkd4Qb5HeEHfR3hB/0d4QR9IeEE/SHhBYEh4QYBIeEGgSHhBwEh4QeFIeEEBSXhBIUl4QUFJeEFiSXhBgkl4QaJJeEHCSXhB40l4QQNKeEEjSnhBQ0p4QWRKeEGESnhBpEp4QcRKeEHlSnhBBUt4QSVLeEFFS3hBZUt4QYZLeEGmS3hBxkt4QeZLeEEHTHhBJ0x4QUdMeEFnTHhBh0x4QahMeEHITHhB6Ex4QQhNeEEpTXhBSU14QWlNeEGJTXhBqU14QcpNeEHqTXhBCk54QSpOeEFLTnhBa054QYtOeEGrTnhBy054QexOeEEMT3hBLE94QUxPeEFsT3hBjU94Qa1PeEHNT3hB7U94QQ1QeEEuUHhBTlB4QW5QeEGOUHhBr1B4Qc9QeEHvUHhBD1F4QS9ReEFQUXhBcFF4QZBReEGwUXhB0FF4QfBReEERUnhBMVJ4QVFSeEFxUnhBkVJ4QbJSeEHSUnhB8lJ4QRJTeEEyU3hBU1N4QXNTeEGTU3hBs1N4QdNTeEH0U3hBFFR4QTRUeEFUVHhBdFR4QZRUeEG1VHhB1VR4QfVUeEEVVXhBNVV4QVZVeEF2VXhBllV4QbZVeEHWVXhB9lV4QRdWeEE3VnhBV1Z4QXdWeEGXVnhBt1Z4QdhWeEH4VnhBGFd4QThXeEFYV3hBeFd4QZlXeEG5V3hB2Vd4QflXeEEZWHhBOVh4QVpYeEF6WHhBmlh4QbpYeEHaWHhB+lh4QRpZeEE7WXhBW1l4QXtZeEGbWXhBu1l4QdtZeEH8WXhBHFp4QTxaeEFcWnhBfFp4QZxaeEG8WnhB3Vp4Qf1aeEEdW3hBPVt4QV1beEF9W3hBnVt4Qb5beEHeW3hB/lt4QR5ceEE+XHhBXlx4QX5ceEGfXHhBv1x4Qd9ceEH/XHhBH114QT9deEFfXXhBgF14QaBdeEHAXXhB4F14QQBeeEEgXnhBQF54QWBeeEGBXnhBoV54QcFeeEHhXnhBAV94QSFfeEFBX3hBYV94QYJfeEGiX3hBwl94QeJfeEECYHhBImB4QUJgeEFiYHhBg2B4QaNgeEHDYHhB42B4QQNheEEjYXhBQ2F4QWNheEGDYXhBpGF4QcRheEHkYXhBBGJ4QSRieEFEYnhBZGJ4QYRieEGkYnhBxGJ4QeVieEEFY3hBJWN4QUVjeEFlY3hBhWN4QaVjeEHFY3hB5WN4QQVkeEEmZHhBRmR4QWZkeEGGZHhBpmR4QcZkeEHmZHhBBmV4QSZleEFGZXhBZmV4QYdleEGnZXhBx2V4QedleEEHZnhBJ2Z4QUdmeEFnZnhBh2Z4QadmeEHHZnhB6GZ4QQhneEEoZ3hBSGd4QWhneEGIZ3hBqGd4QchneEHoZ3hBCGh4QShoeEFIaHhBaGh4QYloeEGpaHhByWh4QeloeEEJaXhBKWl4QUlpeEFpaXhBiWl4QalpeEHJaXhB6Wl4QQlqeEEpanhBSWp4QWpqeEGKanhBqmp4QcpqeEHqanhBCmt4QSpreEFKa3hBamt4QYpreEGqa3hBymt4QepreEEKbHhBKmx4QUpseEFqbHhBimx4QatseEHLbHhB62x4QQtteEErbXhBS214QWtteEGLbXhBq214QctteEHrbXhBC254QStueEFLbnhBa254QYtueEGrbnhBy254QetueEELb3hBK294QUtveEFrb3hBi294QaxveEHMb3hB7G94QQxweEEscHhBTHB4QWxweEGMcHhBrHB4QcxweEHscHhBDHF4QSxxeEFMcXhBbHF4QYxxeEGscXhBzHF4QexxeEEMcnhBLHJ4QUxyeEFscnhBjHJ4QaxyeEHMcnhB7HJ4QQxzeEEsc3hBTHN4QWxzeEGMc3hBrHN4QcxzeEHsc3hBDHR4QSx0eEFMdHhBbHR4QYx0eEGsdHhBzHR4Qex0eEEMdXhBLHV4QUx1eEFsdXhBjHV4Qax1eEHMdXhB7HV4QQx2eEEsdnhBTHZ4QWx2eEGMdnhBrHZ4Qcx2eEHsdnhBDHd4QSx3eEFMd3hBbHd4QYx3eEGsd3hBzHd4Qex3eEEMeHhBLHh4QUx4eEFseHhBjHh4Qax4eEHMeHhB7Hh4QQx5eEEseXhBTHl4QWx5eEGMeXhBrHl4Qcx5eEHseXhBDHp4QSx6eEFMenhBbHp4QYx6eEGsenhBzHp4Qex6eEEMe3hBLHt4QUx7eEFse3hBjHt4Qax7eEHMe3hB7Ht4QQt8eEErfHhBS3x4QWt8eEGLfHhBq3x4Qct8eEHrfHhBC314QSt9eEFLfXhBa314QYt9eEGrfXhBy314Qet9eEELfnhBK354QUt+eEFrfnhBi354Qat+eEHLfnhB6354QQp/eEEqf3hBSn94QWp/eEGKf3hBqn94Qcp/eEHqf3hBCoB4QSqAeEFKgHhBaoB4QYqAeEGqgHhByoB4QeqAeEEKgXhBKoF4QUmBeEFpgXhBiYF4QamBeEHJgXhB6YF4QQmCeEEpgnhBSYJ4QWmCeEGJgnhBqYJ4QcmCeEHpgnhBCYN4QSiDeEFIg3hBaIN4QYiDeEGog3hByIN4QeiDeEEIhHhBKIR4QUiEeEFohHhBiIR4QaiEeEHHhHhB54R4QQeFeEEnhXhBR4V4QWeFeEGHhXhBp4V4QceFeEHnhXhBB4Z4QSeGeEFGhnhBZoZ4QYaGeEGmhnhBxoZ4QeaGeEEGh3hBJod4QUaHeEFmh3hBhod4QaWHeEHFh3hB5Yd4QQWIeEEliHhBRYh4QWWIeEGFiHhBpYh4QcWIeEHkiHhBBIl4QSSJeEFEiXhBZIl4QYSJeEGkiXhBxIl4QeSJeEEDinhBI4p4QUOKeEFjinhBg4p4QaOKeEHDinhB44p4QQOLeEEii3hBQot4QWKLeEGCi3hBoot4QcKLeEHii3hBAox4QSKMeEFBjHhBYYx4QYGMeEGhjHhBwYx4QeGMeEEBjXhBIY14QUCNeEFgjXhBgI14QaCNeEHAjXhB4I14QQCOeEEgjnhBP454QV+OeEF/jnhBn454Qb+OeEHfjnhB/454QR6PeEE+j3hBXo94QX6PeEGej3hBvo94Qd6PeEH9j3hBHZB4QT2QeEFdkHhBfZB4QZ2QeEG9kHhB3JB4QfyQeEEckXhBPJF4QVyReEF8kXhBnJF4QbuReEHbkXhB+5F4QRuSeEE7knhBW5J4QXuSeEGaknhBupJ4QdqSeEH6knhBGpN4QTqTeEFZk3hBeZN4QZmTeEG5k3hB2ZN4QfmTeEEYlHhBOJR4QViUeEF4lHhBmJR4QbiUeEHXlHhB95R4QReVeEE3lXhBV5V4QXeVeEGWlXhBtpV4QdaVeEH2lXhBFpZ4QTaWeEFVlnhBdZZ4QZWWeEG1lnhB1ZZ4QfWWeEEUl3hBNJd4QVSXeEF0l3hBlJd4QbOXeEHTl3hB85d4QROYeEEzmHhBU5h4QXKYeEGSmHhBsph4QdKYeEHymHhBEZl4QTGZeEFRmXhBcZl4QZGZeEGwmXhB0Jl4QfCZeEEQmnhBMJp4QU+aeEFvmnhBj5p4Qa+aeEHPmnhB7pp4QQ6beEEum3hBTpt4QW6beEGNm3hBrZt4Qc2beEHtm3hBDZx4QSyceEFMnHhBbJx4QYyceEGsnHhBy5x4QeuceEELnXhBK514QUudeEFqnXhBip14QaqdeEHKnXhB6Z14QQmeeEEpnnhBSZ54QWmeeEGInnhBqJ54QcieeEHonnhBB594QSefeEFHn3hBZ594QYefeEGmn3hBxp94QeafeEEGoHhBJaB4QUWgeEFloHhBhaB4QaWgeEHEoHhB5KB4QQSheEEkoXhBQ6F4QWOheEGDoXhBo6F4QcKheEHioXhBAqJ4QSKieEFBonhBYaJ4QYGieEGhonhBwaJ4QeCieEEAo3hBIKN4QUCjeEFfo3hBf6N4QZ+jeEG/o3hB3qN4Qf6jeEEepHhBPqR4QV2keEF9pHhBnaR4Qb2keEHcpHhB/KR4QRyleEE8pXhBW6V4QXuleEGbpXhBuqV4QdqleEH6pXhBGqZ4QTmmeEFZpnhBeaZ4QZmmeEG4pnhB2KZ4QfimeEEYp3hBN6d4QVeneEF3p3hBl6d4QbaneEHWp3hB9qd4QRWoeEE1qHhBVah4QXWoeEGUqHhBtKh4QdSoeEH0qHhBE6l4QTOpeEFTqXhBcql4QZKpeEGyqXhB0ql4QfGpeEERqnhBMap4QVCqeEFwqnhBkKp4QbCqeEHPqnhB76p4QQ+reEEuq3hBTqt4QW6reEGOq3hBrat4Qc2reEHtq3hBDKx4QSyseEFMrHhBbKx4QYuseEGrrHhBy6x4QeqseEEKrXhBKq14QUmteEFprXhBia14QamteEHIrXhB6K14QQiueEEnrnhBR654QWeueEGGrnhBpq54QcaueEHmrnhBBa94QSWveEFFr3hBZK94QYSveEGkr3hBw694QeOveEEDsHhBIrB4QUKweEFisHhBgrB4QaGweEHBsHhB4bB4QQCxeEEgsXhBQLF4QV+xeEF/sXhBn7F4Qb6xeEHesXhB/rF4QR2yeEE9snhBXbJ4QXyyeEGcsnhBvLJ4QduyeEH7snhBG7N4QTqzeEFas3hBerN4QZmzeEG5s3hB2bN4QfizeEEYtHhBOLR4QVe0eEF3tHhBl7R4Qba0eEHWtHhB9rR4QRW1eEE1tXhBVbV4QXS1eEGUtXhBtLV4QdO1eEHztXhBE7Z4QTK2eEFStnhBcrZ4QZG2eEGxtnhB0bZ4QfC2eEEQt3hBL7d4QU+3eEFvt3hBjrd4Qa63eEHOt3hB7bd4QQ24eEEtuHhBTLh4QWy4eEGMuHhBq7h4Qcu4eEHquHhBCrl4QSq5eEFJuXhBabl4QYm5eEGouXhByLl4Qei5eEEHunhBJ7p4QUa6eEFmunhBhrp4QaW6eEHFunhB5bp4QQS7eEEku3hBQ7t4QWO7eEGDu3hBort4QcK7eEHiu3hBAbx4QSG8eEFAvHhBYLx4QYC8eEGfvHhBv7x4Qd+8eEH+vHhBHr14QT29eEFdvXhBfb14QZy9eEG8vXhB2714Qfu9eEEbvnhBOr54QVq+eEF6vnhBmb54Qbm+eEHYvnhB+L54QRi/eEE3v3hBV794QXa/eEGWv3hBtr94QdW/eEH1v3hBFMB4QTTAeEFUwHhBc8B4QZPAeEGywHhB0sB4QfLAeEERwXhBMcF4QVDBeEFwwXhBkMF4Qa/BeEHPwXhB7sF4QQ7CeEEuwnhBTcJ4QW3CeEGMwnhBrMJ4QcvCeEHrwnhBC8N4QSrDeEFKw3hBacN4QYnDeEGpw3hByMN4QejDeEEHxHhBJ8R4QUbEeEFmxHhBhsR4QaXEeEHFxHhB5MR4QQTFeEEjxXhBQ8V4QWPFeEGCxXhBosV4QcHFeEHhxXhBAMZ4QSDGeEFAxnhBX8Z4QX/GeEGexnhBvsZ4Qd3GeEH9xnhBHcd4QTzHeEFcx3hBe8d4QZvHeEG6x3hB2sd4QfnHeEEZyHhBOch4QVjIeEF4yHhBl8h4QbfIeEHWyHhB9sh4QRXJeEE1yXhBVcl4QXTJeEGUyXhBs8l4QdPJeEHyyXhBEsp4QTHKeEFRynhBccp4QZDKeEGwynhBz8p4Qe/KeEEOy3hBLst4QU3LeEFty3hBjMt4QazLeEHLy3hB68t4QQvMeEEqzHhBSsx4QWnMeEGJzHhBqMx4QcjMeEHnzHhBB814QSbNeEFGzXhBZc14QYXNeEGkzXhBxM14QeTNeEEDznhBI854QULOeEFiznhBgc54QaHOeEHAznhB4M54Qf/OeEEfz3hBPs94QV7PeEF9z3hBnc94QbzPeEHcz3hB+894QRvQeEE60HhBWtB4QXnQeEGZ0HhBuNB4QdjQeEH30HhBF9F4QTbReEFW0XhBdtF4QZXReEG10XhB1NF4QfTReEET0nhBM9J4QVLSeEFy0nhBkdJ4QbHSeEHQ0nhB8NJ4QQ/TeEEv03hBTtN4QW7TeEGN03hBrdN4QczTeEHs03hBC9R4QSvUeEFK1HhBatR4QYnUeEGo1HhByNR4QefUeEEH1XhBJtV4QUbVeEFl1XhBhdV4QaTVeEHE1XhB49V4QQPWeEEi1nhBQtZ4QWHWeEGB1nhBoNZ4QcDWeEHf1nhB/9Z4QR7XeEE+13hBXdd4QX3XeEGc13hBvNd4QdvXeEH613hBGth4QTnYeEFZ2HhBeNh4QZjYeEG32HhB19h4QfbYeEEW2XhBNdl4QVXZeEF02XhBlNl4QbPZeEHT2XhB8tl4QRHaeEEx2nhBUNp4QXDaeEGP2nhBr9p4Qc7aeEHu2nhBDdt4QS3beEFM23hBa9t4QYvbeEGq23hBytt4QenbeEEJ3HhBKNx4QUjceEFn3HhBh9x4QabceEHF3HhB5dx4QQTdeEEk3XhBQ914QWPdeEGC3XhBot14QcHdeEHg3XhBAN54QR/eeEE/3nhBXt54QX7eeEGd3nhBvd54QdzeeEH73nhBG994QTrfeEFa33hBed94QZnfeEG433hB1994QfffeEEW4HhBNuB4QVXgeEF14HhBlOB4QbPgeEHT4HhB8uB4QRLheEEx4XhBUeF4QXDheEGP4XhBr+F4Qc7heEHu4XhBDeJ4QSzieEFM4nhBa+J4QYvieEGq4nhByuJ4QenieEEI43hBKON4QUfjeEFn43hBhuN4QaXjeEHF43hB5ON4QQTkeEEj5HhBQ+R4QWLkeEGB5HhBoeR4QcDkeEHg5HhB/+R4QR7leEE+5XhBXeV4QX3leEGc5XhBu+V4QdvleEH65XhBGuZ4QTnmeEFY5nhBeOZ4QZfmeEG35nhB1uZ4QfXmeEEV53hBNOd4QVTneEFz53hBkud4QbLneEHR53hB8Od4QRDoeEEv6HhBT+h4QW7oeEGN6HhBreh4QczoeEHs6HhBC+l4QSrpeEFK6XhBael4QYjpeEGo6XhBx+l4QefpeEEG6nhBJep4QUXqeEFk6nhBg+p4QaPqeEHC6nhB4up4QQHreEEg63hBQOt4QV/reEF+63hBnut4Qb3reEHd63hB/Ot4QRvseEE77HhBWux4QXnseEGZ7HhBuOx4QdfseEH37HhBFu14QTbteEFV7XhBdO14QZTteEGz7XhB0u14QfLteEER7nhBMO54QVDueEFv7nhBju54Qa7ueEHN7nhB7e54QQzveEEr73hBS+94QWrveEGJ73hBqe94QcjveEHn73hBB/B4QSbweEFF8HhBZfB4QYTweEGj8HhBw/B4QeLweEEB8XhBIfF4QUDxeEFf8XhBf/F4QZ7xeEG98XhB3fF4QfzxeEEb8nhBO/J4QVryeEF58nhBmfJ4QbjyeEHX8nhB9/J4QRbzeEE183hBVfN4QXTzeEGT83hBs/N4QdLzeEHx83hBEfR4QTD0eEFP9HhBb/R4QY70eEGt9HhBzfR4Qez0eEEL9XhBK/V4QUr1eEFp9XhBifV4Qaj1eEHH9XhB5vV4QQb2eEEl9nhBRPZ4QWT2eEGD9nhBovZ4QcL2eEHh9nhBAPd4QSD3eEE/93hBXvd4QX33eEGd93hBvPd4Qdv3eEH793hBGvh4QTn4eEFZ+HhBePh4QZf4eEG3+HhB1vh4QfX4eEEU+XhBNPl4QVP5eEFy+XhBkvl4QbH5eEHQ+XhB7/l4QQ/6eEEu+nhBTfp4QW36eEGM+nhBq/p4Qcr6eEHq+nhBCft4QSj7eEFI+3hBZ/t4QYb7eEGl+3hBxft4QeT7eEED/HhBI/x4QUL8eEFh/HhBgPx4QaD8eEG//HhB3vx4Qf78eEEd/XhBPP14QVv9eEF7/XhBmv14Qbn9eEHY/XhB+P14QRf+eEE2/nhBVv54QXX+eEGU/nhBs/54QdP+eEHy/nhBEf94QTD/eEFQ/3hBb/94QY7/eEGt/3hBzf94Qez/eEELAHlBKwB5QUoAeUFpAHlBiAB5QagAeUHHAHlB5gB5QQUBeUElAXlBRAF5QWMBeUGCAXlBogF5QcEBeUHgAXlB/wF5QR8CeUE+AnlBXQJ5QXwCeUGcAnlBuwJ5QdoCeUH5AnlBGQN5QTgDeUFXA3lBdgN5QZYDeUG1A3lB1AN5QfMDeUETBHlBMgR5QVEEeUFwBHlBjwR5Qa8EeUHOBHlB7QR5QQwFeUEsBXlBSwV5QWoFeUGJBXlBqQV5QcgFeUHnBXlBBgZ5QSUGeUFFBnlBZAZ5QYMGeUGiBnlBwgZ5QeEGeUEAB3lBHwd5QT8HeUFeB3lBfQd5QZwHeUG7B3lB2wd5QfoHeUEZCHlBOAh5QVcIeUF3CHlBlgh5QbUIeUHUCHlB9Ah5QRMJeUEyCXlBUQl5QXAJeUGQCXlBrwl5Qc4JeUHtCXlBDAp5QSwKeUFLCnlBagp5QYkKeUGoCnlByAp5QecKeUEGC3lBJQt5QUQLeUFkC3lBgwt5QaILeUHBC3lB4At5QQAMeUEfDHlBPgx5QV0MeUF8DHlBnAx5QbsMeUHaDHlB+Qx5QRgNeUE4DXlBVw15QXYNeUGVDXlBtA15QdQNeUHzDXlBEg55QTEOeUFQDnlBbw55QY8OeUGuDnlBzQ55QewOeUELD3lBKw95QUoPeUFpD3lBiA95QacPeUHGD3lB5g95QQUQeUEkEHlBQxB5QWIQeUGCEHlBoRB5QcAQeUHfEHlB/hB5QR0ReUE9EXlBXBF5QXsReUGaEXlBuRF5QdgReUH4EXlBFxJ5QTYSeUFVEnlBdBJ5QZMSeUGzEnlB0hJ5QfESeUEQE3lBLxN5QU4TeUFuE3lBjRN5QawTeUHLE3lB6hN5QQkUeUEoFHlBSBR5QWcUeUGGFHlBpRR5QcQUeUHjFHlBAxV5QSIVeUFBFXlBYBV5QX8VeUGeFXlBvRV5Qd0VeUH8FXlBGxZ5QToWeUFZFnlBeBZ5QZcWeUG3FnlB1hZ5QfUWeUEUF3lBMxd5QVIXeUFxF3lBkRd5QbAXeUHPF3lB7hd5QQ0YeUEsGHlBSxh5QWoYeUGKGHlBqRh5QcgYeUHnGHlBBhl5QSUZeUFEGXlBYxl5QYMZeUGiGXlBwRl5QeAZeUH/GXlBHhp5QT0aeUFcGnlBfBp5QZsaeUG6GnlB2Rp5QfgaeUEXG3lBNht5QVUbeUF1G3lBlBt5QbMbeUHSG3lB8Rt5QRAceUEvHHlBThx5QW0ceUGNHHlBrBx5QcsceUHqHHlBCR15QSgdeUFHHXlBZh15QYUdeUGlHXlBxB15QeMdeUECHnlBIR55QUAeeUFfHnlBfh55QZ0eeUG8HnlB3B55QfseeUEaH3lBOR95QVgfeUF3H3lBlh95QbUfeUHUH3lB8x95QRIgeUEyIHlBUSB5QXAgeUGPIHlBriB5Qc0geUHsIHlBCyF5QSoheUFJIXlBaCF5QYgheUGnIXlBxiF5QeUheUEEInlBIyJ5QUIieUFhInlBgCJ5QZ8ieUG+InlB3SJ5QfwieUEcI3lBOyN5QVojeUF5I3lBmCN5QbcjeUHWI3lB9SN5QRQkeUEzJHlBUiR5QXEkeUGQJHlBryR5Qc8keUHuJHlBDSV5QSwleUFLJXlBaiV5QYkleUGoJXlBxyV5QeYleUEFJnlBJCZ5QUMmeUFiJnlBgSZ5QaAmeUHAJnlB3yZ5Qf4meUEdJ3lBPCd5QVsneUF6J3lBmSd5QbgneUHXJ3lB9id5QRUoeUE0KHlBUyh5QXIoeUGRKHlBsCh5Qc8oeUHuKHlBDSl5QS0peUFMKXlBayl5QYopeUGpKXlByCl5QecpeUEGKnlBJSp5QUQqeUFjKnlBgip5QaEqeUHAKnlB3yp5Qf4qeUEdK3lBPCt5QVsreUF6K3lBmSt5QbgreUHXK3lB9it5QRUseUE0LHlBUyx5QXIseUGRLHlBsCx5QdAseUHvLHlBDi15QS0teUFMLXlBay15QYoteUGpLXlByC15QecteUEGLnlBJS55QUQueUFjLnlBgi55QaEueUHALnlB3y55Qf4ueUEdL3lBPC95QVsveUF6L3lBmS95QbgveUHXL3lB9i95QRUweUE0MHlBUzB5QXIweUGRMHlBsDB5Qc8weUHuMHlBDTF5QSwxeUFLMXlBajF5QYkxeUGoMXlBxzF5QeYxeUEFMnlBJDJ5QUMyeUFiMnlBgTJ5QaAyeUG/MnlB3jJ5Qf0yeUEcM3lBOzN5QVozeUF5M3lBmDN5QbczeUHWM3lB9TN5QRQ0eUEzNHlBUjR5QXE0eUGQNHlBrzR5Qc40eUHtNHlBDDV5QSs1eUFKNXlBaTV5QYg1eUGnNXlBxjV5QeU1eUEENnlBIzZ5QUE2eUFgNnlBfzZ5QZ42eUG9NnlB3DZ5Qfs2eUEaN3lBOTd5QVg3eUF3N3lBljd5QbU3eUHUN3lB8zd5QRI4eUExOHlBUDh5QW84eUGOOHlBrTh5Qcw4eUHrOHlBCjl5QSk5eUFIOXlBZzl5QYY5eUGlOXlBwzl5QeI5eUEBOnlBIDp5QT86eUFeOnlBfTp5QZw6eUG7OnlB2jp5Qfk6eUEYO3lBNzt5QVY7eUF1O3lBlDt5QbM7eUHSO3lB8Tt5QRA8eUEuPHlBTTx5QWw8eUGLPHlBqjx5Qck8eUHoPHlBBz15QSY9eUFFPXlBZD15QYM9eUGiPXlBwT15QeA9eUH/PXlBHT55QTw+eUFbPnlBej55QZk+eUG4PnlB1z55QfY+eUEVP3lBND95QVM/eUFyP3lBkT95QbA/eUHPP3lB7T95QQxAeUErQHlBSkB5QWlAeUGIQHlBp0B5QcZAeUHlQHlBBEF5QSNBeUFCQXlBYEF5QX9BeUGeQXlBvUF5QdxBeUH7QXlBGkJ5QTlCeUFYQnlBd0J5QZZCeUG1QnlB00J5QfJCeUERQ3lBMEN5QU9DeUFuQ3lBjUN5QaxDeUHLQ3lB6kN5QQhEeUEnRHlBRkR5QWVEeUGERHlBo0R5QcJEeUHhRHlBAEV5QR9FeUE9RXlBXEV5QXtFeUGaRXlBuUV5QdhFeUH3RXlBFkZ5QTVGeUFURnlBckZ5QZFGeUGwRnlBz0Z5Qe5GeUENR3lBLEd5QUtHeUFqR3lBiEd5QadHeUHGR3lB5Ud5QQRIeUEjSHlBQkh5QWFIeUF/SHlBnkh5Qb1IeUHcSHlB+0h5QRpJeUE5SXlBWEl5QXZJeUGVSXlBtEl5QdNJeUHySXlBEUp5QTBKeUFPSnlBbUp5QYxKeUGrSnlBykp5QelKeUEIS3lBJ0t5QUZLeUFkS3lBg0t5QaJLeUHBS3lB4Et5Qf9LeUEeTHlBPEx5QVtMeUF6THlBmUx5QbhMeUHXTHlB9kx5QRRNeUEzTXlBUk15QXFNeUGQTXlBr015Qc5NeUHsTXlBC055QSpOeUFJTnlBaE55QYdOeUGlTnlBxE55QeNOeUECT3lBIU95QUBPeUFfT3lBfU95QZxPeUG7T3lB2k95QflPeUEYUHlBNlB5QVVQeUF0UHlBk1B5QbJQeUHRUHlB71B5QQ5ReUEtUXlBTFF5QWtReUGKUXlBqFF5QcdReUHmUXlBBVJ5QSRSeUFDUnlBYVJ5QYBSeUGfUnlBvlJ5Qd1SeUH8UnlBGlN5QTlTeUFYU3lBd1N5QZZTeUG1U3lB01N5QfJTeUERVHlBMFR5QU9UeUFtVHlBjFR5QatUeUHKVHlB6VR5QQdVeUEmVXlBRVV5QWRVeUGDVXlBolV5QcBVeUHfVXlB/lV5QR1WeUE8VnlBWlZ5QXlWeUGYVnlBt1Z5QdZWeUH0VnlBE1d5QTJXeUFRV3lBcFd5QY5XeUGtV3lBzFd5QetXeUEKWHlBKFh5QUdYeUFmWHlBhVh5QaRYeUHCWHlB4Vh5QQBZeUEfWXlBPll5QVxZeUF7WXlBmll5QblZeUHYWXlB9ll5QRVaeUE0WnlBU1p5QXFaeUGQWnlBr1p5Qc5aeUHtWnlBC1t5QSpbeUFJW3lBaFt5QYdbeUGlW3lBxFt5QeNbeUECXHlBIFx5QT9ceUFeXHlBfVx5QZxceUG6XHlB2Vx5QfhceUEXXXlBNV15QVRdeUFzXXlBkl15QbBdeUHPXXlB7l15QQ1eeUEsXnlBSl55QWleeUGIXnlBp155QcVeeUHkXnlBA195QSJfeUFAX3lBX195QX5feUGdX3lBu195QdpfeUH5X3lBGGB5QTZgeUFVYHlBdGB5QZNgeUGxYHlB0GB5Qe9geUEOYXlBLGF5QUtheUFqYXlBiWF5QadheUHGYXlB5WF5QQRieUEiYnlBQWJ5QWBieUF/YnlBnWJ5QbxieUHbYnlB+mJ5QRhjeUE3Y3lBVmN5QXVjeUGTY3lBsmN5QdFjeUHwY3lBDmR5QS1keUFMZHlBa2R5QYlkeUGoZHlBx2R5QeVkeUEEZXlBI2V5QUJleUFgZXlBf2V5QZ5leUG9ZXlB22V5QfpleUEZZnlBN2Z5QVZmeUF1ZnlBlGZ5QbJmeUHRZnlB8GZ5QQ9neUEtZ3lBTGd5QWtneUGJZ3lBqGd5QcdneUHmZ3lBBGh5QSNoeUFCaHlBYGh5QX9oeUGeaHlBvWh5QdtoeUH6aHlBGWl5QTdpeUFWaXlBdWl5QZRpeUGyaXlB0Wl5QfBpeUEOanlBLWp5QUxqeUFqanlBiWp5QahqeUHHanlB5Wp5QQRreUEja3lBQWt5QWBreUF/a3lBnWt5QbxreUHba3lB+mt5QRhseUE3bHlBVmx5QXRseUGTbHlBsmx5QdBseUHvbHlBDm15QSxteUFLbXlBam15QYhteUGnbXlBxm15QeVteUEDbnlBIm55QUFueUFfbnlBfm55QZ1ueUG7bnlB2m55QflueUEXb3lBNm95QVVveUFzb3lBkm95QbFveUHPb3lB7m95QQ1weUErcHlBSnB5QWlweUGHcHlBpnB5QcVweUHjcHlBAnF5QSFxeUE/cXlBXnF5QX1xeUGbcXlBunF5QdlxeUH3cXlBFnJ5QTVyeUFTcnlBcnJ5QZFyeUGvcnlBznJ5Qe1yeUELc3lBKnN5QUlzeUFnc3lBhnN5QaVzeUHDc3lB4nN5QQF0eUEfdHlBPnR5QV10eUF7dHlBmnR5Qbl0eUHXdHlB9nR5QRR1eUEzdXlBUnV5QXB1eUGPdXlBrnV5Qcx1eUHrdXlBCnZ5QSh2eUFHdnlBZnZ5QYR2eUGjdnlBwXZ5QeB2eUH/dnlBHXd5QTx3eUFbd3lBeXd5QZh3eUG3d3lB1Xd5QfR3eUESeHlBMXh5QVB4eUFueHlBjXh5Qax4eUHKeHlB6Xh5QQh5eUEmeXlBRXl5QWN5eUGCeXlBoXl5Qb95eUHeeXlB/Xl5QRt6eUE6enlBWHp5QXd6eUGWenlBtHp5QdN6eUHxenlBEHt5QS97eUFNe3lBbHt5QYt7eUGpe3lByHt5QeZ7eUEFfHlBJHx5QUJ8eUFhfHlBf3x5QZ58eUG9fHlB23x5Qfp8eUEYfXlBN315QVZ9eUF0fXlBk315QbF9eUHQfXlB7315QQ1+eUEsfnlBSn55QWl+eUGIfnlBpn55QcV+eUHjfnlBAn95QSF/eUE/f3lBXn95QXx/eUGbf3lBun95Qdh/eUH3f3lBFYB5QTSAeUFTgHlBcYB5QZCAeUGugHlBzYB5QeyAeUEKgXlBKYF5QUeBeUFmgXlBhIF5QaOBeUHCgXlB4IF5Qf+BeUEdgnlBPIJ5QVuCeUF5gnlBmIJ5QbaCeUHVgnlB84J5QRKDeUExg3lBT4N5QW6DeUGMg3lBq4N5QcmDeUHog3lBB4R5QSWEeUFEhHlBYoR5QYGEeUGfhHlBvoR5Qd2EeUH7hHlBGoV5QTiFeUFXhXlBdYV5QZSFeUGyhXlB0YV5QfCFeUEOhnlBLYZ5QUuGeUFqhnlBiIZ5QaeGeUHFhnlB5IZ5QQOHeUEhh3lBQId5QV6HeUF9h3lBm4d5QbqHeUHYh3lB94d5QRaIeUE0iHlBU4h5QXGIeUGQiHlBroh5Qc2IeUHriHlBCol5QSiJeUFHiXlBZol5QYSJeUGjiXlBwYl5QeCJeUH+iXlBHYp5QTuKeUFainlBeIp5QZeKeUG1inlB1Ip5QfOKeUERi3lBMIt5QU6LeUFti3lBi4t5QaqLeUHIi3lB54t5QQWMeUEkjHlBQox5QWGMeUF/jHlBnox5Qb2MeUHbjHlB+ox5QRiNeUE3jXlBVY15QXSNeUGSjXlBsY15Qc+NeUHujXlBDI55QSuOeUFJjnlBaI55QYaOeUGljnlBw455QeKOeUEAj3lBH495QT2PeUFcj3lBeo95QZmPeUG3j3lB1o95QfSPeUETkHlBMZB5QVCQeUFukHlBjZB5QauQeUHKkHlB6JB5QQeReUElkXlBRJF5QWKReUGBkXlBn5F5Qb6ReUHckXlB+5F5QRmSeUE4knlBVpJ5QXWSeUGTknlBspJ5QdCSeUHvknlBDZN5QSyTeUFKk3lBaZN5QYeTeUGmk3lBxJN5QeOTeUEBlHlBIJR5QT6UeUFdlHlBe5R5QZqUeUG4lHlB15R5QfWUeUEUlXlBMpV5QVGVeUFvlXlBjpV5QayVeUHLlXlB6ZV5QQiWeUEmlnlBRZZ5QWOWeUGBlnlBoJZ5Qb6WeUHdlnlB+5Z5QRqXeUE4l3lBV5d5QXWXeUGUl3lBspd5QdGXeUHvl3lBDph5QSyYeUFLmHlBaZh5QYeYeUGmmHlBxJh5QeOYeUEBmXlBIJl5QT6ZeUFdmXlBe5l5QZqZeUG4mXlB15l5QfWZeUETmnlBMpp5QVCaeUFvmnlBjZp5QayaeUHKmnlB6Zp5QQebeUElm3lBRJt5QWKbeUGBm3lBn5t5Qb6beUHcm3lB+5t5QRmceUE4nHlBVpx5QXSceUGTnHlBsZx5QdCceUHunHlBDZ15QSudeUFKnXlBaJ15QYadeUGlnXlBw515QeKdeUEAnnlBH555QT2eeUFbnnlBep55QZieeUG3nnlB1Z55QfSeeUESn3lBMJ95QU+feUFtn3lBjJ95QaqfeUHJn3lB5595QQWgeUEkoHlBQqB5QWGgeUF/oHlBnqB5QbygeUHaoHlB+aB5QReheUE2oXlBVKF5QXOheUGRoXlBr6F5Qc6heUHsoXlBC6J5QSmieUFHonlBZqJ5QYSieUGjonlBwaJ5Qd+ieUH+onlBHKN5QTujeUFZo3lBeKN5QZajeUG0o3lB06N5QfGjeUEQpHlBLqR5QUykeUFrpHlBiaR5QaikeUHGpHlB5KR5QQOleUEhpXlBQKV5QV6leUF8pXlBm6V5QbmleUHYpXlB9qV5QRSmeUEzpnlBUaZ5QXCmeUGOpnlBrKZ5QcumeUHppnlBB6d5QSaneUFEp3lBY6d5QYGneUGfp3lBvqd5QdyneUH7p3lBGah5QTeoeUFWqHlBdKh5QZKoeUGxqHlBz6h5Qe6oeUEMqXlBKql5QUmpeUFnqXlBhql5QaSpeUHCqXlB4al5Qf+peUEdqnlBPKp5QVqqeUF5qnlBl6p5QbWqeUHUqnlB8qp5QRCreUEvq3lBTat5QWureUGKq3lBqKt5QcereUHlq3lBA6x5QSKseUFArHlBXqx5QX2seUGbrHlBuax5QdiseUH2rHlBFa15QTOteUFRrXlBcK15QY6teUGsrXlBy615QemteUEHrnlBJq55QUSueUFirnlBga55QZ+ueUG9rnlB3K55QfqueUEZr3lBN695QVWveUF0r3lBkq95QbCveUHPr3lB7a95QQuweUEqsHlBSLB5QWaweUGFsHlBo7B5QcGweUHgsHlB/rB5QRyxeUE7sXlBWbF5QXexeUGWsXlBtLF5QdKxeUHxsXlBD7J5QS2yeUFMsnlBarJ5QYiyeUGnsnlBxbJ5QeOyeUECs3lBILN5QT6zeUFds3lBe7N5QZmzeUG4s3lB1rN5QfSzeUETtHlBMbR5QU+0eUFutHlBjLR5Qaq0eUHJtHlB57R5QQW1eUEjtXlBQrV5QWC1eUF+tXlBnbV5Qbu1eUHZtXlB+LV5QRa2eUE0tnlBU7Z5QXG2eUGPtnlBrrZ5Qcy2eUHqtnlBCLd5QSe3eUFFt3lBY7d5QYK3eUGgt3lBvrd5Qd23eUH7t3lBGbh5QTi4eUFWuHlBdLh5QZK4eUGxuHlBz7h5Qe24eUEMuXlBKrl5QUi5eUFmuXlBhbl5QaO5eUHBuXlB4Ll5Qf65eUEcunlBO7p5QVm6eUF3unlBlbp5QbS6eUHSunlB8Lp5QQ+7eUEtu3lBS7t5QWm7eUGIu3lBprt5QcS7eUHju3lBAbx5QR+8eUE9vHlBXLx5QXq8eUGYvHlBt7x5QdW8eUHzvHlBEb15QTC9eUFOvXlBbL15QYq9eUGpvXlBx715QeW9eUEEvnlBIr55QUC+eUFevnlBfb55QZu+eUG5vnlB1755Qfa+eUEUv3lBMr95QVC/eUFvv3lBjb95Qau/eUHKv3lB6L95QQbAeUEkwHlBQ8B5QWHAeUF/wHlBncB5QbzAeUHawHlB+MB5QRbBeUE1wXlBU8F5QXHBeUGPwXlBrsF5QczBeUHqwXlBCMJ5QSfCeUFFwnlBY8J5QYHCeUGgwnlBvsJ5QdzCeUH6wnlBGcN5QTfDeUFVw3lBc8N5QZLDeUGww3lBzsN5QezDeUELxHlBKcR5QUfEeUFlxHlBhMR5QaLEeUHAxHlB3sR5QfzEeUEbxXlBOcV5QVfFeUF1xXlBlMV5QbLFeUHQxXlB7sV5QQ3GeUErxnlBScZ5QWfGeUGFxnlBpMZ5QcLGeUHgxnlB/sZ5QR3HeUE7x3lBWcd5QXfHeUGWx3lBtMd5QdLHeUHwx3lBDsh5QS3IeUFLyHlBach5QYfIeUGlyHlBxMh5QeLIeUEAyXlBHsl5QT3JeUFbyXlBecl5QZfJeUG1yXlB1Ml5QfLJeUEQynlBLsp5QUzKeUFrynlBicp5QafKeUHFynlB48p5QQLLeUEgy3lBPst5QVzLeUF7y3lBmct5QbfLeUHVy3lB88t5QRLMeUEwzHlBTsx5QWzMeUGKzHlBqcx5QcfMeUHlzHlBA815QSHNeUE/zXlBXs15QXzNeUGazXlBuM15QdbNeUH1zXlBE855QTHOeUFPznlBbc55QYzOeUGqznlByM55QebOeUEEz3lBIs95QUHPeUFfz3lBfc95QZvPeUG5z3lB2M95QfbPeUEU0HlBMtB5QVDQeUFu0HlBjdB5QavQeUHJ0HlB59B5QQXReUEk0XlBQtF5QWDReUF+0XlBnNF5QbrReUHZ0XlB99F5QRXSeUEz0nlBUdJ5QW/SeUGO0nlBrNJ5QcrSeUHo0nlBBtN5QSTTeUFD03lBYdN5QX/TeUGd03lBu9N5QdnTeUH403lBFtR5QTTUeUFS1HlBcNR5QY7UeUGs1HlBy9R5QenUeUEH1XlBJdV5QUPVeUFh1XlBgNV5QZ7VeUG81XlB2tV5QfjVeUEW1nlBNNZ5QVPWeUFx1nlBj9Z5Qa3WeUHL1nlB6dZ5QQfXeUEm13lBRNd5QWLXeUGA13lBntd5QbzXeUHa13lB+dd5QRfYeUE12HlBU9h5QXHYeUGP2HlBrdh5QczYeUHq2HlBCNl5QSbZeUFE2XlBYtl5QYDZeUGe2XlBvdl5QdvZeUH52XlBF9p5QTXaeUFT2nlBcdp5QY/aeUGu2nlBzNp5QeraeUEI23lBJtt5QUTbeUFi23lBgNt5QZ/beUG923lB29t5QfnbeUEX3HlBNdx5QVPceUFx3HlBkNx5Qa7ceUHM3HlB6tx5QQjdeUEm3XlBRN15QWLdeUGA3XlBn915Qb3deUHb3XlB+d15QRfeeUE13nlBU955QXHeeUGP3nlBrt55QczeeUHq3nlBCN95QSbfeUFE33lBYt95QYDfeUGe33lBvN95QdvfeUH533lBF+B5QTXgeUFT4HlBceB5QY/geUGt4HlBy+B5QengeUEH4XlBJuF5QUTheUFi4XlBgOF5QZ7heUG84XlB2uF5QfjheUEW4nlBNOJ5QVLieUFx4nlBj+J5Qa3ieUHL4nlB6eJ5QQfjeUEl43lBQ+N5QWHjeUF/43lBneN5QbvjeUHa43lB+ON5QRbkeUE05HlBUuR5QXDkeUGO5HlBrOR5QcrkeUHo5HlBBuV5QSTleUFC5XlBYOV5QX/leUGd5XlBu+V5QdnleUH35XlBFeZ5QTPmeUFR5nlBb+Z5QY3meUGr5nlByeZ5QefmeUEF53lBI+d5QULneUFg53lBfud5QZzneUG653lB2Od5QfbneUEU6HlBMuh5QVDoeUFu6HlBjOh5QaroeUHI6HlB5uh5QQTpeUEi6XlBQOl5QV/peUF96XlBm+l5QbnpeUHX6XlB9el5QRPqeUEx6nlBT+p5QW3qeUGL6nlBqep5QcfqeUHl6nlBA+t5QSHreUE/63lBXet5QXvreUGZ63lBt+t5QdXreUHz63lBEux5QTDseUFO7HlBbOx5QYrseUGo7HlBxux5QeTseUEC7XlBIO15QT7teUFc7XlBeu15QZjteUG27XlB1O15QfLteUEQ7nlBLu55QUzueUFq7nlBiO55QabueUHE7nlB4u55QQDveUEe73lBPO95QVrveUF473lBlu95QbTveUHS73lB8O95QQ7weUEs8HlBSvB5QWjweUGG8HlBpPB5QcLweUHh8HlB//B5QR3xeUE78XlBWfF5QXfxeUGV8XlBs/F5QdHxeUHv8XlBDfJ5QSvyeUFJ8nlBZ/J5QYXyeUGj8nlBwfJ5Qd/yeUH98nlBG/N5QTnzeUFX83lBdfN5QZPzeUGx83lBz/N5Qe3zeUEL9HlBKfR5QUf0eUFl9HlBg/R5QaH0eUG/9HlB3fR5Qfv0eUEZ9XlBN/V5QVX1eUFz9XlBkPV5Qa71eUHM9XlB6vV5QQj2eUEm9nlBRPZ5QWL2eUGA9nlBnvZ5Qbz2eUHa9nlB+PZ5QRb3eUE093lBUvd5QXD3eUGO93lBrPd5Qcr3eUHo93lBBvh5QST4eUFC+HlBYPh5QX74eUGc+HlBuvh5Qdj4eUH2+HlBFPl5QTL5eUFQ+XlBbvl5QYz5eUGq+XlByPl5Qeb5eUEE+nlBIvp5QUD6eUFe+nlBe/p5QZn6eUG3+nlB1fp5QfP6eUER+3lBL/t5QU37eUFr+3lBift5Qaf7eUHF+3lB4/t5QQH8eUEf/HlBPfx5QVv8eUF5/HlBl/x5QbX8eUHT/HlB8fx5QQ/9eUEs/XlBSv15QWj9eUGG/XlBpP15QcL9eUHg/XlB/v15QRz+eUE6/nlBWP55QXb+eUGU/nlBsv55QdD+eUHu/nlBDP95QSr/eUFH/3lBZf95QYP/eUGh/3lBv/95Qd3/eUH7/3lBGQB6QTcAekFVAHpBcwB6QZEAekGvAHpBzQB6QesAekEIAXpBJgF6QUQBekFiAXpBgAF6QZ4BekG8AXpB2gF6QfgBekEWAnpBNAJ6QVICekFwAnpBjgJ6QasCekHJAnpB5wJ6QQUDekEjA3pBQQN6QV8DekF9A3pBmwN6QbkDekHXA3pB9QN6QRIEekEwBHpBTgR6QWwEekGKBHpBqAR6QcYEekHkBHpBAgV6QSAFekE+BXpBWwV6QXkFekGXBXpBtQV6QdMFekHxBXpBDwZ6QS0GekFLBnpBaQZ6QYcGekGkBnpBwgZ6QeAGekH+BnpBHAd6QToHekFYB3pBdgd6QZQHekGyB3pBzwd6Qe0HekELCHpBKQh6QUcIekFlCHpBgwh6QaEIekG/CHpB3Ah6QfoIekEYCXpBNgl6QVQJekFyCXpBkAl6Qa4JekHMCXpB6Ql6QQcKekElCnpBQwp6QWEKekF/CnpBnQp6QbsKekHYCnpB9gp6QRQLekEyC3pBUAt6QW4LekGMC3pBqgt6QcgLekHlC3pBAwx6QSEMekE/DHpBXQx6QXsMekGZDHpBtwx6QdQMekHyDHpBEA16QS4NekFMDXpBag16QYgNekGlDXpBww16QeENekH/DXpBHQ56QTsOekFZDnpBdg56QZQOekGyDnpB0A56Qe4OekEMD3pBKg96QUgPekFlD3pBgw96QaEPekG/D3pB3Q96QfsPekEZEHpBNhB6QVQQekFyEHpBkBB6Qa4QekHMEHpB6RB6QQcRekElEXpBQxF6QWERekF/EXpBnRF6QboRekHYEXpB9hF6QRQSekEyEnpBUBJ6QW0SekGLEnpBqRJ6QccSekHlEnpBAxN6QSETekE+E3pBXBN6QXoTekGYE3pBthN6QdQTekHxE3pBDxR6QS0UekFLFHpBaRR6QYcUekGkFHpBwhR6QeAUekH+FHpBHBV6QToVekFXFXpBdRV6QZMVekGxFXpBzxV6QewVekEKFnpBKBZ6QUYWekFkFnpBghZ6QZ8WekG9FnpB2xZ6QfkWekEXF3pBNBd6QVIXekFwF3pBjhd6QawXekHKF3pB5xd6QQUYekEjGHpBQRh6QV8YekF8GHpBmhh6QbgYekHWGHpB9Bh6QREZekEvGXpBTRl6QWsZekGJGXpBpxl6QcQZekHiGXpBABp6QR4aekE8GnpBWRp6QXcaekGVGnpBsxp6QdEaekHuGnpBDBt6QSobekFIG3pBZht6QYMbekGhG3pBvxt6Qd0bekH7G3pBGBx6QTYcekFUHHpBchx6QY8cekGtHHpByxx6QekcekEHHXpBJB16QUIdekFgHXpBfh16QZwdekG5HXpB1x16QfUdekETHnpBMB56QU4eekFsHnpBih56QageekHFHnpB4x56QQEfekEfH3pBPR96QVofekF4H3pBlh96QbQfekHRH3pB7x96QQ0gekErIHpBSCB6QWYgekGEIHpBoiB6QcAgekHdIHpB+yB6QRkhekE3IXpBVCF6QXIhekGQIXpBriF6QcshekHpIXpBByJ6QSUiekFDInpBYCJ6QX4iekGcInpBuiJ6QdciekH1InpBEyN6QTEjekFOI3pBbCN6QYojekGoI3pBxSN6QeMjekEBJHpBHyR6QTwkekFaJHpBeCR6QZYkekGzJHpB0SR6Qe8kekENJXpBKiV6QUglekFmJXpBhCV6QaElekG/JXpB3SV6QfslekEYJnpBNiZ6QVQmekFyJnpBjyZ6Qa0mekHLJnpB6SZ6QQYnekEkJ3pBQid6QV8nekF9J3pBmyd6QbknekHWJ3pB9Cd6QRIoekEwKHpBTSh6QWsoekGJKHpBpyh6QcQoekHiKHpBACl6QR0pekE7KXpBWSl6QXcpekGUKXpBsil6QdApekHuKXpBCyp6QSkqekFHKnpBZCp6QYIqekGgKnpBvip6QdsqekH5KnpBFyt6QTQrekFSK3pBcCt6QY4rekGrK3pBySt6QecrekEELHpBIix6QUAsekFeLHpBeyx6QZksekG3LHpB1Cx6QfIsekEQLXpBLi16QUstekFpLXpBhy16QaQtekHCLXpB4C16Qf4tekEbLnpBOS56QVcuekF0LnpBki56QbAuekHNLnpB6y56QQkvekEnL3pBRC96QWIvekGAL3pBnS96QbsvekHZL3pB9i96QRQwekEyMHpBTzB6QW0wekGLMHpBqTB6QcYwekHkMHpBAjF6QR8xekE9MXpBWzF6QXgxekGWMXpBtDF6QdExekHvMXpBDTJ6QSoyekFIMnpBZjJ6QYMyekGhMnpBvzJ6Qd0yekH6MnpBGDN6QTYzekFTM3pBcTN6QY8zekGsM3pByjN6QegzekEFNHpBIzR6QUE0ekFeNHpBfDR6QZo0ekG3NHpB1TR6QfM0ekEQNXpBLjV6QUw1ekFpNXpBhzV6QaU1ekHCNXpB4DV6Qf41ekEbNnpBOTZ6QVc2ekF0NnpBkjZ6QbA2ekHNNnpB6zZ6QQk3ekEmN3pBRDd6QWI3ekF/N3pBnTd6Qbs3ekHYN3pB9jd6QRM4ekExOHpBTzh6QWw4ekGKOHpBqDh6QcU4ekHjOHpBATl6QR45ekE8OXpBWjl6QXc5ekGVOXpBszl6QdA5ekHuOXpBCzp6QSk6ekFHOnpBZDp6QYI6ekGgOnpBvTp6Qds6ekH5OnpBFjt6QTQ7ekFSO3pBbzt6QY07ekGqO3pByDt6QeY7ekEDPHpBITx6QT88ekFcPHpBejx6QZc8ekG1PHpB0zx6QfA8ekEOPXpBLD16QUk9ekFnPXpBhD16QaI9ekHAPXpB3T16Qfs9ekEZPnpBNj56QVQ+ekFxPnpBjz56Qa0+ekHKPnpB6D56QQY/ekEjP3pBQT96QV4/ekF8P3pBmj96Qbc/ekHVP3pB8j96QRBAekEuQHpBS0B6QWlAekGHQHpBpEB6QcJAekHfQHpB/UB6QRtBekE4QXpBVkF6QXNBekGRQXpBr0F6QcxBekHqQXpBB0J6QSVCekFDQnpBYEJ6QX5CekGbQnpBuUJ6QddCekH0QnpBEkN6QS9DekFNQ3pBa0N6QYhDekGmQ3pBw0N6QeFDekH/Q3pBHER6QTpEekFXRHpBdUR6QZNEekGwRHpBzkR6QetEekEJRXpBJkV6QURFekFiRXpBf0V6QZ1FekG6RXpB2EV6QfZFekETRnpBMUZ6QU5GekFsRnpBiUZ6QadGekHFRnpB4kZ6QQBHekEdR3pBO0d6QVlHekF2R3pBlEd6QbFHekHPR3pB7Ed6QQpIekEoSHpBRUh6QWNIekGASHpBnkh6QbtIekHZSHpB90h6QRRJekEySXpBT0l6QW1JekGKSXpBqEl6QcVJekHjSXpBAUp6QR5KekE8SnpBWUp6QXdKekGUSnpBskp6QdBKekHtSnpBC0t6QShLekFGS3pBY0t6QYFLekGeS3pBvEt6QdpLekH3S3pBFUx6QTJMekFQTHpBbUx6QYtMekGoTHpBxkx6QeRMekEBTXpBH016QTxNekFaTXpBd016QZVNekGyTXpB0E16Qe1NekELTnpBKU56QUZOekFkTnpBgU56QZ9OekG8TnpB2k56QfdOekEVT3pBMk96QVBPekFtT3pBi096QahPekHGT3pB5E96QQFQekEfUHpBPFB6QVpQekF3UHpBlVB6QbJQekHQUHpB7VB6QQtRekEoUXpBRlF6QWNRekGBUXpBnlF6QbxRekHaUXpB91F6QRVSekEyUnpBUFJ6QW1SekGLUnpBqFJ6QcZSekHjUnpBAVN6QR5TekE8U3pBWVN6QXdTekGUU3pBslN6Qc9TekHtU3pBClR6QShUekFFVHpBY1R6QYBUekGeVHpBu1R6QdlUekH2VHpBFFV6QTFVekFPVXpBbFV6QYpVekGnVXpBxVV6QeNVekEAVnpBHlZ6QTtWekFZVnpBdlZ6QZRWekGxVnpBz1Z6QexWekEKV3pBJ1d6QUVXekFiV3pBf1d6QZ1XekG6V3pB2Fd6QfVXekETWHpBMFh6QU5YekFrWHpBiVh6QaZYekHEWHpB4Vh6Qf9YekEcWXpBOll6QVdZekF1WXpBkll6QbBZekHNWXpB61l6QQhaekEmWnpBQ1p6QWFaekF+WnpBnFp6QblaekHXWnpB9Fp6QRJbekEvW3pBTVt6QWpbekGHW3pBpVt6QcJbekHgW3pB/Vt6QRtcekE4XHpBVlx6QXNcekGRXHpBrlx6QcxcekHpXHpBB116QSRdekFCXXpBX116QXxdekGaXXpBt116QdVdekHyXXpBEF56QS1eekFLXnpBaF56QYZeekGjXnpBwV56Qd5eekH7XnpBGV96QTZfekFUX3pBcV96QY9fekGsX3pByl96QedfekEFYHpBImB6QT9gekFdYHpBemB6QZhgekG1YHpB02B6QfBgekEOYXpBK2F6QUlhekFmYXpBg2F6QaFhekG+YXpB3GF6QflhekEXYnpBNGJ6QVFiekFvYnpBjGJ6QapiekHHYnpB5WJ6QQJjekEgY3pBPWN6QVpjekF4Y3pBlWN6QbNjekHQY3pB7mN6QQtkekEoZHpBRmR6QWNkekGBZHpBnmR6QbxkekHZZHpB9mR6QRRlekExZXpBT2V6QWxlekGKZXpBp2V6QcRlekHiZXpB/2V6QR1mekE6ZnpBWGZ6QXVmekGSZnpBsGZ6Qc1mekHrZnpBCGd6QSZnekFDZ3pBYGd6QX5nekGbZ3pBuWd6QdZnekHzZ3pBEWh6QS5oekFMaHpBaWh6QYZoekGkaHpBwWh6Qd9oekH8aHpBGml6QTdpekFUaXpBcml6QY9pekGtaXpByml6QedpekEFanpBImp6QUBqekFdanpBemp6QZhqekG1anpB02p6QfBqekENa3pBK2t6QUhrekFma3pBg2t6QaBrekG+a3pB22t6QflrekEWbHpBM2x6QVFsekFubHpBi2x6QalsekHGbHpB5Gx6QQFtekEebXpBPG16QVltekF3bXpBlG16QbFtekHPbXpB7G16QQpuekEnbnpBRG56QWJuekF/bnpBnG56QbpuekHXbnpB9W56QRJvekEvb3pBTW96QWpvekGHb3pBpW96QcJvekHgb3pB/W96QRpwekE4cHpBVXB6QXJwekGQcHpBrXB6QctwekHocHpBBXF6QSNxekFAcXpBXXF6QXtxekGYcXpBtXF6QdNxekHwcXpBDnJ6QStyekFIcnpBZnJ6QYNyekGgcnpBvnJ6QdtyekH4cnpBFnN6QTNzekFRc3pBbnN6QYtzekGpc3pBxnN6QeNzekEBdHpBHnR6QTt0ekFZdHpBdnR6QZN0ekGxdHpBznR6Qet0ekEJdXpBJnV6QUR1ekFhdXpBfnV6QZx1ekG5dXpB1nV6QfR1ekERdnpBLnZ6QUx2ekFpdnpBhnZ6QaR2ekHBdnpB3nZ6Qfx2ekEZd3pBNnd6QVR3ekFxd3pBjnd6Qax3ekHJd3pB5nd6QQR4ekEheHpBPnh6QVx4ekF5eHpBlnh6QbR4ekHReHpB7nh6QQx5ekEpeXpBRnl6QWR5ekGBeXpBnnl6Qbx5ekHZeXpB9nl6QRR6ekExenpBTnp6QWx6ekGJenpBpnp6QcR6ekHhenpB/np6QRt7ekE5e3pBVnt6QXN7ekGRe3pBrnt6Qct7ekHpe3pBBnx6QSN8ekFBfHpBXnx6QXt8ekGZfHpBtnx6QdN8ekHwfHpBDn16QSt9ekFIfXpBZn16QYN9ekGgfXpBvn16Qdt9ekH4fXpBFn56QTN+ekFQfnpBbX56QYt+ekGofnpBxX56QeN+ekEAf3pBHX96QTt/ekFYf3pBdX96QZJ/ekGwf3pBzX96Qep/ekEIgHpBJYB6QUKAekFfgHpBfYB6QZqAekG3gHpB1YB6QfKAekEPgXpBLYF6QUqBekFngXpBhIF6QaKBekG/gXpB3IF6QfqBekEXgnpBNIJ6QVGCekFvgnpBjIJ6QamCekHGgnpB5IJ6QQGDekEeg3pBPIN6QVmDekF2g3pBk4N6QbGDekHOg3pB64N6QQmEekEmhHpBQ4R6QWCEekF+hHpBm4R6QbiEekHVhHpB84R6QRCFekEthXpBS4V6QWiFekGFhXpBooV6QcCFekHdhXpB+oV6QReGekE1hnpBUoZ6QW+GekGMhnpBqoZ6QceGekHkhnpBAYd6QR+HekE8h3pBWYd6QXaHekGUh3pBsYd6Qc6HekHsh3pBCYh6QSaIekFDiHpBYYh6QX6IekGbiHpBuIh6QdaIekHziHpBEIl6QS2JekFLiXpBaIl6QYWJekGiiXpBwIl6Qd2JekH6iXpBF4p6QTSKekFSinpBb4p6QYyKekGpinpBx4p6QeSKekEBi3pBHot6QTyLekFZi3pBdot6QZOLekGxi3pBzot6QeuLekEIjHpBJox6QUOMekFgjHpBfYx6QZqMekG4jHpB1Yx6QfKMekEPjXpBLY16QUqNekFnjXpBhI16QaKNekG/jXpB3I16QfmNekEWjnpBNI56QVGOekFujnpBi456QamOekHGjnpB4456QQCPekEdj3pBO496QViPekF1j3pBko96QbCPekHNj3pB6o96QQeQekEkkHpBQpB6QV+QekF8kHpBmZB6QbaQekHUkHpB8ZB6QQ6RekErkXpBSJF6QWaRekGDkXpBoJF6Qb2RekHbkXpB+JF6QRWSekEyknpBT5J6QW2SekGKknpBp5J6QcSSekHhknpB/5J6QRyTekE5k3pBVpN6QXOTekGRk3pBrpN6QcuTekHok3pBBZR6QSKUekFAlHpBXZR6QXqUekGXlHpBtJR6QdKUekHvlHpBDJV6QSmVekFGlXpBZJV6QYGVekGelXpBu5V6QdiVekH2lXpBE5Z6QTCWekFNlnpBapZ6QYeWekGllnpBwpZ6Qd+WekH8lnpBGZd6QTeXekFUl3pBcZd6QY6XekGrl3pByJd6QeaXekEDmHpBIJh6QT2YekFamHpBd5h6QZWYekGymHpBz5h6QeyYekEJmXpBJpl6QUSZekFhmXpBfpl6QZuZekG4mXpB1Zl6QfOZekEQmnpBLZp6QUqaekFnmnpBhJp6QaKaekG/mnpB3Jp6QfmaekEWm3pBM5t6QVGbekFum3pBi5t6QaibekHFm3pB4pt6QQCcekEdnHpBOpx6QVecekF0nHpBkZx6Qa6cekHMnHpB6Zx6QQadekEjnXpBQJ16QV2dekF7nXpBmJ16QbWdekHSnXpB7516QQyeekEpnnpBR556QWSeekGBnnpBnp56QbueekHYnnpB9Z56QROfekEwn3pBTZ96QWqfekGHn3pBpJ96QcGfekHen3pB/J96QRmgekE2oHpBU6B6QXCgekGNoHpBqqB6QcigekHloHpBAqF6QR+hekE8oXpBWaF6QXahekGToXpBsaF6Qc6hekHroXpBCKJ6QSWiekFConpBX6J6QXyiekGaonpBt6J6QdSiekHxonpBDqN6QSujekFIo3pBZaN6QYOjekGgo3pBvaN6QdqjekH3o3pBFKR6QTGkekFOpHpBa6R6QYmkekGmpHpBw6R6QeCkekH9pHpBGqV6QTelekFUpXpBcaV6QY+lekGspXpByaV6QealekEDpnpBIKZ6QT2mekFapnpBd6Z6QZWmekGypnpBz6Z6QeymekEJp3pBJqd6QUOnekFgp3pBfad6QZqnekG4p3pB1ad6QfKnekEPqHpBLKh6QUmoekFmqHpBg6h6QaCoekG9qHpB2qh6QfioekEVqXpBMql6QU+pekFsqXpBial6QaapekHDqXpB4Kl6Qf2pekEaqnpBOKp6QVWqekFyqnpBj6p6QayqekHJqnpB5qp6QQOrekEgq3pBPat6QVqrekF3q3pBlat6QbKrekHPq3pB7Kt6QQmsekEmrHpBQ6x6QWCsekF9rHpBmqx6QbesekHUrHpB8ax6QQ+tekEsrXpBSa16QWatekGDrXpBoK16Qb2tekHarXpB9616QRSuekExrnpBTq56QWuuekGIrnpBpa56QcOuekHgrnpB/a56QRqvekE3r3pBVK96QXGvekGOr3pBq696QcivekHlr3pBArB6QR+wekE8sHpBWbB6QXawekGTsHpBsbB6Qc6wekHrsHpBCLF6QSWxekFCsXpBX7F6QXyxekGZsXpBtrF6QdOxekHwsXpBDbJ6QSqyekFHsnpBZLJ6QYGyekGesnpBu7J6QdiyekH1snpBE7N6QTCzekFNs3pBarN6QYezekGks3pBwbN6Qd6zekH7s3pBGLR6QTW0ekFStHpBb7R6QYy0ekGptHpBxrR6QeO0ekEAtXpBHbV6QTq1ekFXtXpBdLV6QZG1ekGutXpBy7V6Qei1ekEFtnpBIrZ6QT+2ekFctnpBebZ6QZe2ekG0tnpB0bZ6Qe62ekELt3pBKLd6QUW3ekFit3pBf7d6QZy3ekG5t3pB1rd6QfO3ekEQuHpBLbh6QUq4ekFnuHpBhLh6QaG4ekG+uHpB27h6Qfi4ekEVuXpBMrl6QU+5ekFsuXpBibl6Qaa5ekHDuXpB4Ll6Qf25ekEaunpBN7p6QVS6ekFxunpBjrp6Qau6ekHIunpB5bp6QQK7ekEfu3pBPLt6QVm7ekF2u3pBk7t6QbC7ekHNu3pB6rt6QQe8ekEkvHpBQbx6QV68ekF7vHpBmLx6QbW8ekHSvHpB77x6QQy9ekEpvXpBRr16QWO9ekGAvXpBnb16Qbq9ekHXvXpB9L16QRG+ekEuvnpBS756QWi+ekGFvnpBor56Qb++ekHcvnpB+b56QRa/ekEzv3pBUL96QW2/ekGKv3pBp796QcS/ekHhv3pB/r96QRvAekE4wHpBVcB6QXLAekGPwHpBq8B6QcjAekHlwHpBAsF6QR/BekE8wXpBWcF6QXbBekGTwXpBsMF6Qc3BekHqwXpBB8J6QSTCekFBwnpBXsJ6QXvCekGYwnpBtcJ6QdLCekHvwnpBDMN6QSnDekFGw3pBY8N6QYDDekGdw3pBusN6QdfDekH0w3pBEMR6QS3EekFKxHpBZ8R6QYTEekGhxHpBvsR6QdvEekH4xHpBFcV6QTLFekFPxXpBbMV6QYnFekGmxXpBw8V6QeDFekH9xXpBGsZ6QTfGekFUxnpBcMZ6QY3GekGqxnpBx8Z6QeTGekEBx3pBHsd6QTvHekFYx3pBdcd6QZLHekGvx3pBzMd6QenHekEGyHpBI8h6QUDIekFcyHpBech6QZbIekGzyHpB0Mh6Qe3IekEKyXpBJ8l6QUTJekFhyXpBfsl6QZvJekG4yXpB1cl6QfLJekEOynpBK8p6QUjKekFlynpBgsp6QZ/KekG8ynpB2cp6QfbKekETy3pBMMt6QU3LekFqy3pBh8t6QaPLekHAy3pB3ct6QfrLekEXzHpBNMx6QVHMekFuzHpBi8x6QajMekHFzHpB4sx6Qf7MekEbzXpBOM16QVXNekFyzXpBj816QazNekHJzXpB5s16QQPOekEgznpBPM56QVnOekF2znpBk856QbDOekHNznpB6s56QQfPekEkz3pBQc96QV7PekF6z3pBl896QbTPekHRz3pB7s96QQvQekEo0HpBRdB6QWLQekF/0HpBm9B6QbjQekHV0HpB8tB6QQ/RekEs0XpBSdF6QWbRekGD0XpBn9F6QbzRekHZ0XpB9tF6QRPSekEw0npBTdJ6QWrSekGH0npBo9J6QcDSekHd0npB+tJ6QRfTekE003pBUdN6QW7TekGL03pBp9N6QcTTekHh03pB/tN6QRvUekE41HpBVdR6QXLUekGO1HpBq9R6QcjUekHl1HpBAtV6QR/VekE81XpBWdV6QXXVekGS1XpBr9V6QczVekHp1XpBBtZ6QSPWekFA1npBXNZ6QXnWekGW1npBs9Z6QdDWekHt1npBCtd6QSfXekFD13pBYNd6QX3XekGa13pBt9d6QdTXekHx13pBDdh6QSrYekFH2HpBZNh6QYHYekGe2HpBu9h6QdfYekH02HpBEdl6QS7ZekFL2XpBaNl6QYXZekGh2XpBvtl6QdvZekH42XpBFdp6QTLaekFP2npBa9p6QYjaekGl2npBwtp6Qd/aekH82npBGNt6QTXbekFS23pBb9t6QYzbekGp23pBxtt6QeLbekH/23pBHNx6QTncekFW3HpBc9x6QY/cekGs3HpBydx6QebcekED3XpBIN16QTzdekFZ3XpBdt16QZPdekGw3XpBzd16QendekEG3npBI956QUDeekFd3npBet56QZbeekGz3npB0N56Qe3eekEK33pBJ996QUPfekFg33pBfd96QZrfekG333pB0996QfDfekEN4HpBKuB6QUfgekFk4HpBgOB6QZ3gekG64HpB1+B6QfTgekEQ4XpBLeF6QUrhekFn4XpBhOF6QaHhekG94XpB2uF6QffhekEU4npBMeJ6QU3iekFq4npBh+J6QaTiekHB4npB3eJ6QfriekEX43pBNON6QVHjekFu43pBiuN6QafjekHE43pB4eN6Qf7jekEa5HpBN+R6QVTkekFx5HpBjuR6QarkekHH5HpB5OR6QQHlekEe5XpBOuV6QVflekF05XpBkeV6Qa3lekHK5XpB5+V6QQTmekEh5npBPeZ6QVrmekF35npBlOZ6QbHmekHN5npB6uZ6QQfnekEk53pBQed6QV3nekF653pBl+d6QbTnekHQ53pB7ed6QQroekEn6HpBROh6QWDoekF96HpBmuh6QbfoekHU6HpB8Oh6QQ3pekEq6XpBR+l6QWPpekGA6XpBnel6QbrpekHW6XpB8+l6QRDqekEt6npBSup6QWbqekGD6npBoOp6Qb3qekHZ6npB9up6QRPrekEw63pBTet6QWnrekGG63pBo+t6QcDrekHc63pB+et6QRbsekEz7HpBT+x6QWzsekGJ7HpBpux6QcLsekHf7HpB/Ox6QRntekE17XpBUu16QW/tekGM7XpBqO16QcXtekHi7XpB/+16QRvuekE47npBVe56QXLuekGP7npBq+56QcjuekHl7npBAu96QR7vekE773pBWO96QXTvekGR73pBru96QcvvekHn73pBBPB6QSHwekE+8HpBWvB6QXfwekGU8HpBsfB6Qc3wekHq8HpBB/F6QSTxekFA8XpBXfF6QXrxekGX8XpBs/F6QdDxekHt8XpBCvJ6QSbyekFD8npBYPJ6QXzyekGZ8npBtvJ6QdPyekHv8npBDPN6QSnzekFG83pBYvN6QX/zekGc83pBuPN6QdXzekHy83pBD/R6QSv0ekFI9HpBZfR6QYL0ekGe9HpBu/R6Qdj0ekH09HpBEfV6QS71ekFL9XpBZ/V6QYT1ekGh9XpBvfV6Qdr1ekH39XpBFPZ6QTD2ekFN9npBavZ6QYb2ekGj9npBwPZ6Qd32ekH59npBFvd6QTP3ekFP93pBbPd6QYn3ekGm93pBwvd6Qd/3ekH893pBGPh6QTX4ekFS+HpBbvh6QYv4ekGo+HpBxfh6QeH4ekH++HpBG/l6QTf5ekFU+XpBcfl6QY35ekGq+XpBx/l6QeT5ekEA+npBHfp6QTr6ekFW+npBc/p6QZD6ekGs+npByfp6Qeb6ekEC+3pBH/t6QTz7ekFZ+3pBdft6QZL7ekGv+3pBy/t6Qej7ekEF/HpBIfx6QT78ekFb/HpBd/x6QZT8ekGx/HpBzfx6Qer8ekEH/XpBI/16QUD9ekFd/XpBev16QZb9ekGz/XpB0P16Qez9ekEJ/npBJv56QUL+ekFf/npBfP56QZj+ekG1/npB0v56Qe7+ekEL/3pBKP96QUT/ekFh/3pBfv96QZr/ekG3/3pB1P96QfD/ekENAHtBKgB7QUYAe0FjAHtBgAB7QZwAe0G5AHtB1gB7QfIAe0EPAXtBLAF7QUgBe0FlAXtBggF7QZ4Be0G7AXtB2AF7QfQBe0ERAntBLgJ7QUoCe0FnAntBgwJ7QaACe0G9AntB2QJ7QfYCe0ETA3tBLwN7QUwDe0FpA3tBhQN7QaIDe0G/A3tB2wN7QfgDe0EVBHtBMQR7QU4Ee0FrBHtBhwR7QaQEe0HABHtB3QR7QfoEe0EWBXtBMwV7QVAFe0FsBXtBiQV7QaYFe0HCBXtB3wV7QfwFe0EYBntBNQZ7QVEGe0FuBntBiwZ7QacGe0HEBntB4QZ7Qf0Ge0EaB3tBNgd7QVMHe0FwB3tBjAd7QakHe0HGB3tB4gd7Qf8He0EcCHtBOAh7QVUIe0FxCHtBjgh7QasIe0HHCHtB5Ah7QQEJe0EdCXtBOgl7QVYJe0FzCXtBkAl7QawJe0HJCXtB5Ql7QQIKe0EfCntBOwp7QVgKe0F1CntBkQp7Qa4Ke0HKCntB5wp7QQQLe0EgC3tBPQt7QVkLe0F2C3tBkwt7Qa8Le0HMC3tB6At7QQUMe0EiDHtBPgx7QVsMe0F4DHtBlAx7QbEMe0HNDHtB6gx7QQcNe0EjDXtBQA17QVwNe0F5DXtBlg17QbINe0HPDXtB6w17QQgOe0ElDntBQQ57QV4Oe0F6DntBlw57QbQOe0HQDntB7Q57QQkPe0EmD3tBQw97QV8Pe0F8D3tBmA97QbUPe0HRD3tB7g97QQsQe0EnEHtBRBB7QWAQe0F9EHtBmhB7QbYQe0HTEHtB7xB7QQwRe0EoEXtBRRF7QWIRe0F+EXtBmxF7QbcRe0HUEXtB8RF7QQ0Se0EqEntBRhJ7QWMSe0F/EntBnBJ7QbkSe0HVEntB8hJ7QQ4Te0ErE3tBRxN7QWQTe0GBE3tBnRN7QboTe0HWE3tB8xN7QQ8Ue0EsFHtBSRR7QWUUe0GCFHtBnhR7QbsUe0HXFHtB9BR7QREVe0EtFXtBShV7QWYVe0GDFXtBnxV7QbwVe0HYFXtB9RV7QRIWe0EuFntBSxZ7QWcWe0GEFntBoBZ7Qb0We0HaFntB9hZ7QRMXe0EvF3tBTBd7QWgXe0GFF3tBoRd7Qb4Xe0HaF3tB9xd7QRQYe0EwGHtBTRh7QWkYe0GGGHtBohh7Qb8Ye0HbGHtB+Bh7QRUZe0ExGXtBThl7QWoZe0GHGXtBoxl7QcAZe0HcGXtB+Rl7QRUae0EyGntBThp7QWsae0GIGntBpBp7QcEae0HdGntB+hp7QRYbe0EzG3tBTxt7QWwbe0GIG3tBpRt7QcEbe0HeG3tB+ht7QRcce0E0HHtBUBx7QW0ce0GJHHtBphx7QcIce0HfHHtB+xx7QRgde0E0HXtBUR17QW0de0GKHXtBph17QcMde0HfHXtB/B17QRgee0E1HntBUh57QW4ee0GLHntBpx57QcQee0HgHntB/R57QRkfe0E2H3tBUh97QW8fe0GLH3tBqB97QcQfe0HhH3tB/R97QRoge0E2IHtBUyB7QW8ge0GMIHtBqCB7QcUge0HhIHtB/iB7QRohe0E3IXtBUyF7QXAhe0GMIXtBqSF7QcUhe0HiIXtB/iF7QRsie0E3IntBVCJ7QXAie0GNIntBqSJ7QcYie0HiIntB/yJ7QRsje0E4I3tBVCN7QXEje0GNI3tBqiN7QcYje0HjI3tB/yN7QRwke0E4JHtBVSR7QXEke0GOJHtBqiR7Qccke0HjJHtBACV7QRwle0E5JXtBVSV7QXIle0GOJXtBqyV7Qccle0HkJXtBACZ7QR0me0E5JntBViZ7QXIme0GOJntBqyZ7Qccme0HkJntBACd7QR0ne0E5J3tBVid7QXIne0GPJ3tBqyd7Qcgne0HkJ3tBASh7QR0oe0E6KHtBVih7QXMoe0GPKHtBqyh7Qcgoe0HkKHtBASl7QR0pe0E6KXtBVil7QXMpe0GPKXtBrCl7Qcgpe0HlKXtBASp7QR4qe0E6KntBVip7QXMqe0GPKntBrCp7Qcgqe0HlKntBASt7QR4re0E6K3tBVyt7QXMre0GPK3tBrCt7Qcgre0HlK3tBASx7QR4se0E6LHtBVyx7QXMse0GQLHtBrCx7Qcgse0HlLHtBAS17QR4te0E6LXtBVy17QXMte0GQLXtBrC17Qckte0HlLXtBAS57QR4ue0E6LntBVy57QXMue0GQLntBrC57Qcgue0HlLntBAS97QR4ve0E6L3tBVy97QXMve0GQL3tBrC97Qcgve0HlL3tBATB7QR4we0E6MHtBVzB7QXMwe0GPMHtBrDB7Qcgwe0HlMHtBATF7QR4xe0E6MXtBVjF7QXMxe0GPMXtBrDF7Qcgxe0HlMXtBATJ7QR0ye0E6MntBVjJ7QXMye0GPMntBrDJ7Qcgye0HkMntBATN7QR0ze0E6M3tBVjN7QXIze0GPM3tBqzN7Qcgze0HkM3tBATR7QR00e0E5NHtBVjR7QXI0e0GPNHtBqzR7Qcc0e0HkNHtBADV7QR01e0E5NXtBVjV7QXI1e0GONXtBqzV7Qcc1e0HkNXtBADZ7QRw2e0E5NntBVTZ7QXI2e0GONntBqjZ7Qcc2e0HjNntBADd7QRw3e0E4N3tBVTd7QXE3e0GON3tBqjd7QcY3e0HjN3tB/zd7QRw4e0E4OHtBVDh7QXE4e0GNOHtBqjh7QcY4e0HiOHtB/zh7QRs5e0E3OXtBVDl7QXA5e0GNOXtBqTl7QcU5e0HiOXtB/jl7QRs6e0E3OntBUzp7QXA6e0GMOntBqDp7QcU6e0HhOntB/jp7QRo7e0E2O3tBUzt7QW87e0GMO3tBqDt7QcQ7e0HhO3tB/Tt7QRk8e0E2PHtBUjx7QW88e0GLPHtBpzx7QcQ8e0HgPHtB/Dx7QRk9e0E1PXtBUj17QW49e0GKPXtBpz17QcM9e0HfPXtB/D17QRg+e0E0PntBUT57QW0+e0GKPntBpj57QcI+e0HfPntB+z57QRc/e0E0P3tBUD97QWw/e0GJP3tBpT97QcI/e0HeP3tB+j97QRdAe0EzQHtBT0B7QWxAe0GIQHtBpEB7QcFAe0HdQHtB+UB7QRZBe0EyQXtBT0F7QWtBe0GHQXtBpEF7QcBBe0HcQXtB+UF7QRVCe0ExQntBTkJ7QWpCe0GGQntBo0J7Qb9Ce0HbQntB+EJ7QRRDe0EwQ3tBTUN7QWlDe0GFQ3tBokN7Qb5De0HaQ3tB90N7QRNEe0EvRHtBTER7QWhEe0GERHtBoUR7Qb1Ee0HZRHtB9kR7QRJFe0EuRXtBS0V7QWdFe0GDRXtBoEV7QbxFe0HYRXtB9UV7QRFGe0EtRntBSkZ7QWZGe0GCRntBn0Z7QbtGe0HXRntB9EZ7QRBHe0EsR3tBSUd7QWVHe0GBR3tBnkd7QbpHe0HWR3tB80d7QQ9Ie0ErSHtBSEh7QWRIe0GASHtBnUh7QblIe0HVSHtB8Uh7QQ5Je0EqSXtBRkl7QWNJe0F/SXtBm0l7QbhJe0HUSXtB8El7QQ1Ke0EpSntBRUp7QWFKe0F+SntBmkp7QbZKe0HTSntB70p7QQtLe0EoS3tBREt7QWBLe0F9S3tBmUt7QbVLe0HRS3tB7kt7QQpMe0EmTHtBQ0x7QV9Me0F7THtBmEx7QbRMe0HQTHtB7Ex7QQlNe0ElTXtBQU17QV5Ne0F6TXtBlk17QbJNe0HPTXtB6017QQdOe0EkTntBQE57QVxOe0F5TntBlU57QbFOe0HNTntB6k57QQZPe0EiT3tBP097QVtPe0F3T3tBk097QbBPe0HMT3tB6E97QQRQe0EhUHtBPVB7QVlQe0F2UHtBklB7Qa5Qe0HKUHtB51B7QQNRe0EfUXtBPFF7QVhRe0F0UXtBkFF7Qa1Re0HJUXtB5VF7QQFSe0EeUntBOlJ7QVZSe0FzUntBj1J7QatSe0HHUntB5FJ7QQBTe0EcU3tBOFN7QVVTe0FxU3tBjVN7QalTe0HGU3tB4lN7Qf5Te0EaVHtBN1R7QVNUe0FvVHtBjFR7QahUe0HEVHtB4FR7Qf1Ue0EZVXtBNVV7QVFVe0FuVXtBilV7QaZVe0HCVXtB31V7QftVe0EXVntBM1Z7QVBWe0FsVntBiFZ7QaRWe0HBVntB3VZ7QflWe0EVV3tBMld7QU5Xe0FqV3tBhld7QaNXe0G/V3tB21d7QfdXe0EUWHtBMFh7QUxYe0FoWHtBhVh7QaFYe0G9WHtB2Vh7QfVYe0ESWXtBLll7QUpZe0FmWXtBg1l7QZ9Ze0G7WXtB11l7QfRZe0EQWntBLFp7QUhae0FlWntBgVp7QZ1ae0G5WntB1Vp7QfJae0EOW3tBKlt7QUZbe0FjW3tBf1t7QZtbe0G3W3tB01t7QfBbe0EMXHtBKFx7QURce0FhXHtBfVx7QZlce0G1XHtB0Vx7Qe5ce0EKXXtBJl17QUJde0FfXXtBe117QZdde0GzXXtBz117Qexde0EIXntBJF57QUBee0FcXntBeV57QZVee0GxXntBzV57Qepee0EGX3tBIl97QT5fe0FaX3tBd197QZNfe0GvX3tBy197Qedfe0EEYHtBIGB7QTxge0FYYHtBdGB7QZFge0GtYHtByWB7QeVge0EBYXtBHmF7QTphe0FWYXtBcmF7QY5he0GrYXtBx2F7QeNhe0H/YXtBG2J7QThie0FUYntBcGJ7QYxie0GoYntBxWJ7QeFie0H9YntBGWN7QTVje0FRY3tBbmN7QYpje0GmY3tBwmN7Qd5je0H7Y3tBF2R7QTNke0FPZHtBa2R7QYhke0GkZHtBwGR7Qdxke0H4ZHtBFGV7QTFle0FNZXtBaWV7QYVle0GhZXtBvWV7Qdple0H2ZXtBEmZ7QS5me0FKZntBZ2Z7QYNme0GfZntBu2Z7Qddme0HzZntBEGd7QSxne0FIZ3tBZGd7QYBne0GcZ3tBuWd7QdVne0HxZ3tBDWh7QSloe0FFaHtBYmh7QX5oe0GaaHtBtmh7QdJoe0HuaHtBC2l7QSdpe0FDaXtBX2l7QXtpe0GXaXtBtGl7QdBpe0HsaXtBCGp7QSRqe0FAantBXGp7QXlqe0GVantBsWp7Qc1qe0HpantBBWt7QSJre0E+a3tBWmt7QXZre0GSa3tBrmt7Qcpre0Hna3tBA2x7QR9se0E7bHtBV2x7QXNse0GPbHtBrGx7Qchse0HkbHtBAG17QRxte0E4bXtBVG17QXFte0GNbXtBqW17QcVte0HhbXtB/W17QRlue0E2bntBUm57QW5ue0GKbntBpm57QcJue0HebntB+m57QRdve0Ezb3tBT297QWtve0GHb3tBo297Qb9ve0Hcb3tB+G97QRRwe0EwcHtBTHB7QWhwe0GEcHtBoHB7Qb1we0HZcHtB9XB7QRFxe0EtcXtBSXF7QWVxe0GBcXtBnnF7Qbpxe0HWcXtB8nF7QQ5ye0EqcntBRnJ7QWJye0F+cntBm3J7Qbdye0HTcntB73J7QQtze0Enc3tBQ3N7QV9ze0F7c3tBmHN7QbRze0HQc3tB7HN7QQh0e0EkdHtBQHR7QVx0e0F4dHtBlXR7QbF0e0HNdHtB6XR7QQV1e0EhdXtBPXV7QVl1e0F1dXtBkXV7Qa51e0HKdXtB5nV7QQJ2e0EedntBOnZ7QVZ2e0FydntBjnZ7Qap2e0HHdntB43Z7Qf92e0Ebd3tBN3d7QVN3e0Fvd3tBi3d7Qad3e0HDd3tB4Hd7Qfx3e0EYeHtBNHh7QVB4e0FseHtBiHh7QaR4e0HAeHtB3Hh7Qfh4e0EUeXtBMXl7QU15e0FpeXtBhXl7QaF5e0G9eXtB2Xl7QfV5e0ERentBLXp7QUl6e0FlentBgnp7QZ56e0G6entB1np7QfJ6e0EOe3tBKnt7QUZ7e0Fie3tBfnt7QZp7e0G2e3tB0nt7Qe57e0ELfHtBJ3x7QUN8e0FffHtBe3x7QZd8e0GzfHtBz3x7Qet8e0EHfXtBI317QT99e0FbfXtBd317QZN9e0GwfXtBzH17Qeh9e0EEfntBIH57QTx+e0FYfntBdH57QZB+e0GsfntByH57QeR+e0EAf3tBHH97QTh/e0FUf3tBcH97QY1/e0Gpf3tBxX97QeF/e0H9f3tBGYB7QTWAe0FRgHtBbYB7QYmAe0GlgHtBwYB7Qd2Ae0H5gHtBFYF7QTGBe0FNgXtBaYF7QYWBe0GhgXtBvoF7QdqBe0H2gXtBEoJ7QS6Ce0FKgntBZoJ7QYKCe0GegntBuoJ7QdaCe0HygntBDoN7QSqDe0FGg3tBYoN7QX6De0Gag3tBtoN7QdKDe0Hug3tBCoR7QSaEe0FChHtBXoR7QXqEe0GWhHtBs4R7Qc+Ee0HrhHtBB4V7QSOFe0E/hXtBW4V7QXeFe0GThXtBr4V7QcuFe0HnhXtBA4Z7QR+Ge0E7hntBV4Z7QXOGe0GPhntBq4Z7QceGe0HjhntB/4Z7QRuHe0E3h3tBU4d7QW+He0GLh3tBp4d7QcOHe0Hfh3tB+4d7QReIe0EziHtBT4h7QWuIe0GHiHtBo4h7Qb+Ie0HbiHtB94h7QROJe0EviXtBS4l7QWeJe0GDiXtBn4l7QbuJe0HXiXtB84l7QQ+Ke0ErintBR4p7QWOKe0F/intBm4p7QbeKe0HTintB74p7QQuLe0Eni3tBQ4t7QV+Le0F7i3tBl4t7QbOLe0HPi3tB64t7QQeMe0EjjHtBP4x7QVuMe0F3jHtBk4x7Qa+Me0HLjHtB54x7QQONe0EfjXtBO417QVeNe0FzjXtBj417QauNe0HHjXtB4417Qf+Ne0EbjntBN457QVOOe0FvjntBi457QaeOe0HDjntB3457QfuOe0EXj3tBM497QU+Pe0Frj3tBh497QaOPe0G/j3tB2497QfePe0ETkHtBL5B7QUuQe0FnkHtBg5B7QZ+Qe0G7kHtB15B7QfOQe0EPkXtBKpF7QUaRe0FikXtBfpF7QZqRe0G2kXtB0pF7Qe6Re0EKkntBJpJ7QUKSe0FekntBepJ7QZaSe0GykntBzpJ7QeqSe0EGk3tBIpN7QT6Te0Fak3tBdpN7QZKTe0Guk3tBypN7QeaTe0EClHtBHZR7QTmUe0FVlHtBcZR7QY2Ue0GplHtBxZR7QeGUe0H9lHtBGZV7QTWVe0FRlXtBbZV7QYmVe0GllXtBwZV7Qd2Ve0H5lXtBFZZ7QTGWe0FNlntBaJZ7QYSWe0GglntBvJZ7QdiWe0H0lntBEJd7QSyXe0FIl3tBZJd7QYCXe0Gcl3tBuJd7QdSXe0Hwl3tBDJh7QSiYe0FDmHtBX5h7QXuYe0GXmHtBs5h7Qc+Ye0HrmHtBB5l7QSOZe0E/mXtBW5l7QXeZe0GTmXtBr5l7QcuZe0HmmXtBApp7QR6ae0E6mntBVpp7QXKae0GOmntBqpp7Qcaae0HimntB/pp7QRqbe0E2m3tBUZt7QW2be0GJm3tBpZt7QcGbe0Hdm3tB+Zt7QRWce0ExnHtBTZx7QWmce0GFnHtBoZx7Qbyce0HYnHtB9Jx7QRCde0EsnXtBSJ17QWSde0GAnXtBnJ17Qbide0HUnXtB7517QQuee0EnnntBQ557QV+ee0F7nntBl557QbOee0HPnntB6557QQefe0Ein3tBPp97QVqfe0F2n3tBkp97Qa6fe0HKn3tB5p97QQKge0EeoHtBOaB7QVWge0FxoHtBjaB7Qamge0HFoHtB4aB7Qf2ge0EZoXtBNaF7QVChe0FsoXtBiKF7QaShe0HAoXtB3KF7Qfihe0EUontBMKJ7QUuie0FnontBg6J7QZ+ie0G7ontB16J7QfOie0EPo3tBK6N7QUaje0Fio3tBfqN7QZqje0G2o3tB0qN7Qe6je0EKpHtBJqR7QUGke0FdpHtBeaR7QZWke0GxpHtBzaR7Qemke0EFpXtBIKV7QTyle0FYpXtBdKV7QZCle0GspXtByKV7QeSle0H/pXtBG6Z7QTeme0FTpntBb6Z7QYume0GnpntBw6Z7Qd6me0H6pntBFqd7QTKne0FOp3tBaqd7QYane0Ghp3tBvad7Qdmne0H1p3tBEah7QS2oe0FJqHtBZKh7QYCoe0GcqHtBuKh7QdSoe0HwqHtBDKl7QSepe0FDqXtBX6l7QXupe0GXqXtBs6l7Qc+pe0HqqXtBBqp7QSKqe0E+qntBWqp7QXaqe0GSqntBrap7Qcmqe0HlqntBAat7QR2re0E5q3tBVat7QXCre0GMq3tBqKt7QcSre0Hgq3tB/Kt7QRese0EzrHtBT6x7QWuse0GHrHtBo6x7Qb6se0HarHtB9qx7QRKte0EurXtBSq17QWate0GBrXtBna17Qbmte0HVrXtB8a17QQ2ue0EorntBRK57QWCue0F8rntBmK57QbSue0HPrntB6657QQeve0Ejr3tBP697QVqve0F2r3tBkq97Qa6ve0HKr3tB5q97QQGwe0EdsHtBObB7QVWwe0FxsHtBjbB7Qaiwe0HEsHtB4LB7Qfywe0EYsXtBM7F7QU+xe0FrsXtBh7F7QaOxe0G/sXtB2rF7Qfaxe0ESsntBLrJ7QUqye0FlsntBgbJ7QZ2ye0G5sntB1bJ7QfGye0EMs3tBKLN7QUSze0Fgs3tBfLN7QZeze0Gzs3tBz7N7Qeuze0EHtHtBIrR7QT60e0FatHtBdrR7QZK0e0GttHtBybR7QeW0e0EBtXtBHbV7QTi1e0FUtXtBcLV7QYy1e0GotXtBw7V7Qd+1e0H7tXtBF7Z7QTO2e0FOtntBarZ7QYa2e0GitntBvrZ7Qdm2e0H1tntBEbd7QS23e0FJt3tBZLd7QYC3e0Gct3tBuLd7QdS3e0Hvt3tBC7h7QSe4e0FDuHtBXrh7QXq4e0GWuHtBsrh7Qc64e0HpuHtBBbl7QSG5e0E9uXtBWLl7QXS5e0GQuXtBrLl7Qci5e0HjuXtB/7l7QRu6e0E3untBUrp7QW66e0GKuntBprp7QcK6e0HduntB+bp7QRW7e0Exu3tBTLt7QWi7e0GEu3tBoLt7Qby7e0HXu3tB87t7QQ+8e0ErvHtBRrx7QWK8e0F+vHtBmrx7QbW8e0HRvHtB7bx7QQm9e0ElvXtBQL17QVy9e0F4vXtBlL17Qa+9e0HLvXtB5717QQO+e0EevntBOr57QVa+e0FyvntBjb57Qam+e0HFvntB4b57Qfy+e0EYv3tBNL97QVC/e0Frv3tBh797QaO/e0G/v3tB2r97Qfa/e0ESwHtBLsB7QUnAe0FlwHtBgcB7QZ3Ae0G4wHtB1MB7QfDAe0EMwXtBJ8F7QUPBe0FfwXtBe8F7QZbBe0GywXtBzsF7QerBe0EFwntBIcJ7QT3Ce0FZwntBdMJ7QZDCe0GswntBx8J7QePCe0H/wntBG8N7QTbDe0FSw3tBbsN7QYrDe0Glw3tBwcN7Qd3De0H5w3tBFMR7QTDEe0FMxHtBZ8R7QYPEe0GfxHtBu8R7QdbEe0HyxHtBDsV7QSrFe0FFxXtBYcV7QX3Fe0GYxXtBtMV7QdDFe0HsxXtBB8Z7QSPGe0E/xntBW8Z7QXbGe0GSxntBrsZ7QcnGe0HlxntBAcd7QR3He0E4x3tBVMd7QXDHe0GLx3tBp8d7QcPHe0Hfx3tB+sd7QRbIe0EyyHtBTch7QWnIe0GFyHtBoch7QbzIe0HYyHtB9Mh7QQ/Je0EryXtBR8l7QWLJe0F+yXtBmsl7QbbJe0HRyXtB7cl7QQnKe0EkyntBQMp7QVzKe0F4yntBk8p7Qa/Ke0HLyntB5sp7QQLLe0Eey3tBOct7QVXLe0Fxy3tBjMt7QajLe0HEy3tB4Mt7QfvLe0EXzHtBM8x7QU7Me0FqzHtBhsx7QaHMe0G9zHtB2cx7QfTMe0EQzXtBLM17QUjNe0FjzXtBf817QZvNe0G2zXtB0s17Qe7Ne0EJzntBJc57QUHOe0FczntBeM57QZTOe0GvzntBy857QefOe0ECz3tBHs97QTrPe0FWz3tBcc97QY3Pe0Gpz3tBxM97QeDPe0H8z3tBF9B7QTPQe0FP0HtBatB7QYbQe0Gi0HtBvdB7QdnQe0H10HtBENF7QSzRe0FI0XtBY9F7QX/Re0Gb0XtBttF7QdLRe0Hu0XtBCdJ7QSXSe0FB0ntBXNJ7QXjSe0GU0ntBr9J7QcvSe0Hn0ntBAtN7QR7Te0E603tBVdN7QXHTe0GN03tBqNN7QcTTe0Hg03tB+9N7QRfUe0Ey1HtBTtR7QWrUe0GF1HtBodR7Qb3Ue0HY1HtB9NR7QRDVe0Er1XtBR9V7QWPVe0F+1XtBmtV7QbbVe0HR1XtB7dV7QQnWe0Ek1ntBQNZ7QVvWe0F31ntBk9Z7Qa7We0HK1ntB5tZ7QQHXe0Ed13tBOdd7QVTXe0Fw13tBjNd7QafXe0HD13tB3td7QfrXe0EW2HtBMdh7QU3Ye0Fp2HtBhNh7QaDYe0G82HtB19h7QfPYe0EO2XtBKtl7QUbZe0Fh2XtBfdl7QZnZe0G02XtB0Nl7QevZe0EH2ntBI9p7QT7ae0Fa2ntBdtp7QZHae0Gt2ntByNp7QeTae0EA23tBG9t7QTfbe0FT23tBbtt7QYrbe0Gl23tBwdt7Qd3be0H423tBFNx7QTDce0FL3HtBZ9x7QYLce0Ge3HtButx7QdXce0Hx3HtBDN17QSjde0FE3XtBX917QXvde0GX3XtBst17Qc7de0Hp3XtBBd57QSHee0E83ntBWN57QXPee0GP3ntBq957Qcbee0Hi3ntB/d57QRnfe0E133tBUN97QWzfe0GH33tBo997Qb/fe0Ha33tB9t97QRHge0Et4HtBSeB7QWTge0GA4HtBm+B7Qbfge0HT4HtB7uB7QQrhe0El4XtBQeF7QV3he0F44XtBlOF7Qa/he0HL4XtB5+F7QQLie0Ee4ntBOeJ7QVXie0Fx4ntBjOJ7Qajie0HD4ntB3+J7Qfrie0EW43tBMuN7QU3je0Fp43tBhON7QaDje0G843tB1+N7QfPje0EO5HtBKuR7QUXke0Fh5HtBfeR7QZjke0G05HtBz+R7Qevke0EH5XtBIuV7QT7le0FZ5XtBdeV7QZDle0Gs5XtByOV7QePle0H/5XtBGuZ7QTbme0FR5ntBbeZ7QYnme0Gk5ntBwOZ7Qdvme0H35ntBEud7QS7ne0FJ53tBZed7QYHne0Gc53tBuOd7QdPne0Hv53tBCuh7QSboe0FC6HtBXeh7QXnoe0GU6HtBsOh7Qcvoe0Hn6HtBAul7QR7pe0E66XtBVel7QXHpe0GM6XtBqOl7QcPpe0Hf6XtB+ul7QRbqe0Ey6ntBTep7QWnqe0GE6ntBoOp7Qbvqe0HX6ntB8up7QQ7re0Eq63tBRet7QWHre0F863tBmOt7QbPre0HP63tB6ut7QQbse0Eh7HtBPex7QVnse0F07HtBkOx7Qavse0HH7HtB4ux7Qf7se0EZ7XtBNe17QVDte0Fs7XtBh+17QaPte0G/7XtB2u17Qfbte0ER7ntBLe57QUjue0Fk7ntBf+57QZvue0G27ntB0u57Qe3ue0EJ73tBJO97QUDve0Fc73tBd+97QZPve0Gu73tByu97QeXve0EB8HtBHPB7QTjwe0FT8HtBb/B7QYrwe0Gm8HtBwfB7Qd3we0H48HtBFPF7QS/xe0FL8XtBZvF7QYLxe0Gd8XtBufF7QdXxe0Hw8XtBDPJ7QSfye0FD8ntBXvJ7QXrye0GV8ntBsfJ7Qczye0Ho8ntBA/N7QR/ze0E683tBVvN7QXHze0GN83tBqPN7QcTze0Hf83tB+/N7QRb0e0Ey9HtBTfR7QWn0e0GE9HtBoPR7Qbv0e0HX9HtB8vR7QQ71e0Ep9XtBRfV7QWD1e0F89XtBl/V7QbP1e0HO9XtB6vV7QQX2e0Eh9ntBPPZ7QVj2e0Fz9ntBj/Z7Qar2e0HG9ntB4fZ7Qf32e0EY93tBNPd7QU/3e0Fr93tBhvd7QaL3e0G993tB2fd7QfT3e0EQ+HtBK/h7QUf4e0Fi+HtBfvh7QZn4e0G1+HtB0Ph7Qez4e0EH+XtBIvl7QT75e0FZ+XtBdfl7QZD5e0Gs+XtBx/l7QeP5e0H++XtBGvp7QTX6e0FR+ntBbPp7QYj6e0Gj+ntBv/p7Qdr6e0H2+ntBEft7QS37e0FI+3tBZPt7QX/7e0Ga+3tBtvt7QdH7e0Ht+3tBCPx7QST8e0E//HtBW/x7QXb8e0GS/HtBrfx7Qcn8e0Hk/HtBAP17QRv9e0E2/XtBUv17QW39e0GJ/XtBpP17QcD9e0Hb/XtB9/17QRL+e0Eu/ntBSf57QWX+e0GA/ntBm/57Qbf+e0HS/ntB7v57QQn/e0El/3tBQP97QVz/e0F3/3tBk/97Qa7/e0HJ/3tB5f97QQAAfEEcAHxBNwB8QVMAfEFuAHxBigB8QaUAfEHAAHxB3AB8QfcAfEETAXxBLgF8QUoBfEFlAXxBgQF8QZwBfEG3AXxB0wF8Qe4BfEEKAnxBJQJ8QUECfEFcAnxBeAJ8QZMCfEGuAnxBygJ8QeUCfEEBA3xBHAN8QTgDfEFTA3xBbwN8QYoDfEGlA3xBwQN8QdwDfEH4A3xBEwR8QS8EfEFKBHxBZQR8QYEEfEGcBHxBuAR8QdMEfEHvBHxBCgV8QSUFfEFBBXxBXAV8QXgFfEGTBXxBrwV8QcoFfEHlBXxBAQZ8QRwGfEE4BnxBUwZ8QW4GfEGKBnxBpQZ8QcEGfEHcBnxB+AZ8QRMHfEEuB3xBSgd8QWUHfEGBB3xBnAd8QbcHfEHTB3xB7gd8QQoIfEElCHxBQQh8QVwIfEF3CHxBkwh8Qa4IfEHKCHxB5Qh8QQAJfEEcCXxBNwl8QVMJfEFuCXxBiQl8QaUJfEHACXxB3Al8QfcJfEETCnxBLgp8QUkKfEFlCnxBgAp8QZwKfEG3CnxB0gp8Qe4KfEEJC3xBJQt8QUALfEFbC3xBdwt8QZILfEGuC3xByQt8QeQLfEEADHxBGwx8QTYMfEFSDHxBbQx8QYkMfEGkDHxBvwx8QdsMfEH2DHxBEg18QS0NfEFIDXxBZA18QX8NfEGbDXxBtg18QdENfEHtDXxBCA58QSMOfEE/DnxBWg58QXYOfEGRDnxBrA58QcgOfEHjDnxB/w58QRoPfEE1D3xBUQ98QWwPfEGHD3xBow98Qb4PfEHaD3xB9Q98QRAQfEEsEHxBRxB8QWIQfEF+EHxBmRB8QbUQfEHQEHxB6xB8QQcRfEEiEXxBPRF8QVkRfEF0EXxBkBF8QasRfEHGEXxB4hF8Qf0RfEEYEnxBNBJ8QU8SfEFqEnxBhhJ8QaESfEG9EnxB2BJ8QfMSfEEPE3xBKhN8QUUTfEFhE3xBfBN8QZcTfEGzE3xBzhN8QeoTfEEFFHxBIBR8QTwUfEFXFHxBchR8QY4UfEGpFHxBxBR8QeAUfEH7FHxBFhV8QTIVfEFNFXxBaRV8QYQVfEGfFXxBuxV8QdYVfEHxFXxBDRZ8QSgWfEFDFnxBXxZ8QXoWfEGVFnxBsRZ8QcwWfEHnFnxBAxd8QR4XfEE5F3xBVRd8QXAXfEGLF3xBpxd8QcIXfEHdF3xB+Rd8QRQYfEEvGHxBSxh8QWYYfEGCGHxBnRh8QbgYfEHUGHxB7xh8QQoZfEEmGXxBQRl8QVwZfEF4GXxBkxl8Qa4ZfEHKGXxB5Rl8QQAafEEcGnxBNxp8QVIafEFtGnxBiRp8QaQafEG/GnxB2xp8QfYafEERG3xBLRt8QUgbfEFjG3xBfxt8QZobfEG1G3xB0Rt8QewbfEEHHHxBIxx8QT4cfEFZHHxBdRx8QZAcfEGrHHxBxxx8QeIcfEH9HHxBGR18QTQdfEFPHXxBah18QYYdfEGhHXxBvB18QdgdfEHzHXxBDh58QSoefEFFHnxBYB58QXwefEGXHnxBsh58Qc4efEHpHnxBBB98QR8ffEE7H3xBVh98QXEffEGNH3xBqB98QcMffEHfH3xB+h98QRUgfEEwIHxBTCB8QWcgfEGCIHxBniB8QbkgfEHUIHxB8CB8QQshfEEmIXxBQSF8QV0hfEF4IXxBkyF8Qa8hfEHKIXxB5SF8QQEifEEcInxBNyJ8QVIifEFuInxBiSJ8QaQifEHAInxB2yJ8QfYifEERI3xBLSN8QUgjfEFjI3xBfyN8QZojfEG1I3xB0CN8QewjfEEHJHxBIiR8QT4kfEFZJHxBdCR8QY8kfEGrJHxBxiR8QeEkfEH9JHxBGCV8QTMlfEFOJXxBaiV8QYUlfEGgJXxBvCV8QdclfEHyJXxBDSZ8QSkmfEFEJnxBXyZ8QXomfEGWJnxBsSZ8QcwmfEHoJnxBAyd8QR4nfEE5J3xBVSd8QXAnfEGLJ3xBpid8QcInfEHdJ3xB+Cd8QRMofEEvKHxBSih8QWUofEGBKHxBnCh8QbcofEHSKHxB7ih8QQkpfEEkKXxBPyl8QVspfEF2KXxBkSl8QawpfEHIKXxB4yl8Qf4pfEEZKnxBNSp8QVAqfEFrKnxBhip8QaIqfEG9KnxB2Cp8QfMqfEEPK3xBKit8QUUrfEFgK3xBfCt8QZcrfEGyK3xBzSt8QekrfEEELHxBHyx8QTosfEFWLHxBcSx8QYwsfEGnLHxBwyx8Qd4sfEH5LHxBFC18QTAtfEFLLXxBZi18QYEtfEGdLXxBuC18QdMtfEHuLXxBCi58QSUufEFALnxBWy58QXYufEGSLnxBrS58QcgufEHjLnxB/y58QRovfEE1L3xBUC98QWwvfEGHL3xBoi98Qb0vfEHYL3xB9C98QQ8wfEEqMHxBRTB8QWEwfEF8MHxBlzB8QbIwfEHOMHxB6TB8QQQxfEEfMXxBOjF8QVYxfEFxMXxBjDF8QacxfEHDMXxB3jF8QfkxfEEUMnxBLzJ8QUsyfEFmMnxBgTJ8QZwyfEG4MnxB0zJ8Qe4yfEEJM3xBJDN8QUAzfEFbM3xBdjN8QZEzfEGsM3xByDN8QeMzfEH+M3xBGTR8QTQ0fEFQNHxBazR8QYY0fEGhNHxBvTR8Qdg0fEHzNHxBDjV8QSk1fEFFNXxBYDV8QXs1fEGWNXxBsTV8Qc01fEHoNXxBAzZ8QR42fEE5NnxBVTZ8QXA2fEGLNnxBpjZ8QcE2fEHdNnxB+DZ8QRM3fEEuN3xBSTd8QWU3fEGAN3xBmzd8QbY3fEHRN3xB7Td8QQg4fEEjOHxBPjh8QVk4fEF0OHxBkDh8Qas4fEHGOHxB4Th8Qfw4fEEYOXxBMzl8QU45fEFpOXxBhDl8QaA5fEG7OXxB1jl8QfE5fEEMOnxBJzp8QUM6fEFeOnxBeTp8QZQ6fEGvOnxByzp8QeY6fEEBO3xBHDt8QTc7fEFSO3xBbjt8QYk7fEGkO3xBvzt8Qdo7fEH1O3xBETx8QSw8fEFHPHxBYjx8QX08fEGYPHxBtDx8Qc88fEHqPHxBBT18QSA9fEE7PXxBVz18QXI9fEGNPXxBqD18QcM9fEHePXxB+j18QRU+fEEwPnxBSz58QWY+fEGBPnxBnT58Qbg+fEHTPnxB7j58QQk/fEEkP3xBQD98QVs/fEF2P3xBkT98Qaw/fEHHP3xB4z98Qf4/fEEZQHxBNEB8QU9AfEFqQHxBhUB8QaFAfEG8QHxB10B8QfJAfEENQXxBKEF8QURBfEFfQXxBekF8QZVBfEGwQXxBy0F8QeZBfEECQnxBHUJ8QThCfEFTQnxBbkJ8QYlCfEGkQnxBwEJ8QdtCfEH2QnxBEUN8QSxDfEFHQ3xBYkN8QX5DfEGZQ3xBtEN8Qc9DfEHqQ3xBBUR8QSBEfEE8RHxBV0R8QXJEfEGNRHxBqER8QcNEfEHeRHxB+UR8QRVFfEEwRXxBS0V8QWZFfEGBRXxBnEV8QbdFfEHSRXxB7kV8QQlGfEEkRnxBP0Z8QVpGfEF1RnxBkEZ8QatGfEHHRnxB4kZ8Qf1GfEEYR3xBM0d8QU5HfEFpR3xBhEd8QaBHfEG7R3xB1kd8QfFHfEEMSHxBJ0h8QUJIfEFdSHxBeUh8QZRIfEGvSHxBykh8QeVIfEEASXxBG0l8QTZJfEFRSXxBbUl8QYhJfEGjSXxBvkl8QdlJfEH0SXxBD0p8QSpKfEFFSnxBYUp8QXxKfEGXSnxBskp8Qc1KfEHoSnxBA0t8QR5LfEE5S3xBVEt8QXBLfEGLS3xBpkt8QcFLfEHcS3xB90t8QRJMfEEtTHxBSEx8QWNMfEF/THxBmkx8QbVMfEHQTHxB60x8QQZNfEEhTXxBPE18QVdNfEFyTXxBjk18QalNfEHETXxB3018QfpNfEEVTnxBME58QUtOfEFmTnxBgU58QZxOfEG4TnxB0058Qe5OfEEJT3xBJE98QT9PfEFaT3xBdU98QZBPfEGrT3xBxk98QeFPfEH9T3xBGFB8QTNQfEFOUHxBaVB8QYRQfEGfUHxBulB8QdVQfEHwUHxBC1F8QSZRfEFBUXxBXVF8QXhRfEGTUXxBrlF8QclRfEHkUXxB/1F8QRpSfEE1UnxBUFJ8QWtSfEGGUnxBoVJ8QbxSfEHYUnxB81J8QQ5TfEEpU3xBRFN8QV9TfEF6U3xBlVN8QbBTfEHLU3xB5lN8QQFUfEEcVHxBN1R8QVJUfEFuVHxBiVR8QaRUfEG/VHxB2lR8QfVUfEEQVXxBK1V8QUZVfEFhVXxBfFV8QZdVfEGyVXxBzVV8QehVfEEDVnxBHlZ8QTpWfEFVVnxBcFZ8QYtWfEGmVnxBwVZ8QdxWfEH3VnxBEld8QS1XfEFIV3xBY1d8QX5XfEGZV3xBtFd8Qc9XfEHqV3xBBVh8QSBYfEE7WHxBVlh8QXJYfEGNWHxBqFh8QcNYfEHeWHxB+Vh8QRRZfEEvWXxBSll8QWVZfEGAWXxBm1l8QbZZfEHRWXxB7Fl8QQdafEEiWnxBPVp8QVhafEFzWnxBjlp8QalafEHEWnxB31p8QfpafEEVW3xBMFt8QUtbfEFnW3xBglt8QZ1bfEG4W3xB01t8Qe5bfEEJXHxBJFx8QT9cfEFaXHxBdVx8QZBcfEGrXHxBxlx8QeFcfEH8XHxBF118QTJdfEFNXXxBaF18QYNdfEGeXXxBuV18QdRdfEHvXXxBCl58QSVefEFAXnxBW158QXZefEGRXnxBrF58QcdefEHiXnxB/V58QRhffEEzX3xBTl98QWlffEGEX3xBn198QbpffEHVX3xB8F98QQtgfEEmYHxBQWB8QVxgfEF3YHxBkmB8Qa1gfEHIYHxB42B8Qf5gfEEZYXxBNGF8QU9hfEFqYXxBhWF8QaBhfEG7YXxB1mF8QfFhfEEMYnxBJ2J8QUJifEFdYnxBeGJ8QZNifEGuYnxByWJ8QeRifEH/YnxBGmN8QTVjfEFQY3xBa2N8QYZjfEGhY3xBvGN8QddjfEHyY3xBDWR8QShkfEFDZHxBXmR8QXlkfEGUZHxBr2R8QcpkfEHlZHxBAGV8QRtlfEE2ZXxBUWV8QWxlfEGHZXxBomV8Qb1lfEHYZXxB82V8QQ5mfEEpZnxBRGZ8QV9mfEF6ZnxBlWZ8QbBmfEHLZnxB5mZ8QQFnfEEcZ3xBN2d8QVJnfEFtZ3xBiGd8QaNnfEG+Z3xB2Wd8QfRnfEEPaHxBKmh8QUVofEFfaHxBemh8QZVofEGwaHxBy2h8QeZofEEBaXxBHGl8QTdpfEFSaXxBbWl8QYhpfEGjaXxBvml8QdlpfEH0aXxBD2p8QSpqfEFFanxBYGp8QXtqfEGWanxBsWp8QcxqfEHnanxBAmt8QR1rfEE3a3xBUmt8QW1rfEGIa3xBo2t8Qb5rfEHZa3xB9Gt8QQ9sfEEqbHxBRWx8QWBsfEF7bHxBlmx8QbFsfEHMbHxB52x8QQJtfEEdbXxBOG18QVNtfEFtbXxBiG18QaNtfEG+bXxB2W18QfRtfEEPbnxBKm58QUVufEFgbnxBe258QZZufEGxbnxBzG58QedufEECb3xBHW98QThvfEFSb3xBbW98QYhvfEGjb3xBvm98QdlvfEH0b3xBD3B8QSpwfEFFcHxBYHB8QXtwfEGWcHxBsXB8QcxwfEHmcHxBAXF8QRxxfEE3cXxBUnF8QW1xfEGIcXxBo3F8Qb5xfEHZcXxB9HF8QQ9yfEEqcnxBRXJ8QV9yfEF6cnxBlXJ8QbByfEHLcnxB5nJ8QQFzfEEcc3xBN3N8QVJzfEFtc3xBiHN8QaNzfEG9c3xB2HN8QfNzfEEOdHxBKXR8QUR0fEFfdHxBenR8QZV0fEGwdHxBy3R8QeZ0fEEAdXxBG3V8QTZ1fEFRdXxBbHV8QYd1fEGidXxBvXV8Qdh1fEHzdXxBDnZ8QSh2fEFDdnxBXnZ8QXl2fEGUdnxBr3Z8Qcp2fEHldnxBAHd8QRt3fEE1d3xBUHd8QWt3fEGGd3xBoXd8Qbx3fEHXd3xB8nd8QQ14fEEoeHxBQnh8QV14fEF4eHxBk3h8Qa54fEHJeHxB5Hh8Qf94fEEaeXxBNXl8QU95fEFqeXxBhXl8QaB5fEG7eXxB1nl8QfF5fEEMenxBJ3p8QUF6fEFcenxBd3p8QZJ6fEGtenxByHp8QeN6fEH+enxBGXt8QTN7fEFOe3xBaXt8QYR7fEGfe3xBunt8QdV7fEHwe3xBCnx8QSV8fEFAfHxBW3x8QXZ8fEGRfHxBrHx8Qcd8fEHifHxB/Hx8QRd9fEEyfXxBTX18QWh9fEGDfXxBnn18Qbl9fEHTfXxB7n18QQl+fEEkfnxBP358QVp+fEF1fnxBj358Qap+fEHFfnxB4H58Qft+fEEWf3xBMX98QUx/fEFmf3xBgX98QZx/fEG3f3xB0n98Qe1/fEEIgHxBIoB8QT2AfEFYgHxBc4B8QY6AfEGpgHxBxIB8Qd6AfEH5gHxBFIF8QS+BfEFKgXxBZYF8QYCBfEGagXxBtYF8QdCBfEHrgXxBBoJ8QSGCfEE8gnxBVoJ8QXGCfEGMgnxBp4J8QcKCfEHdgnxB+IJ8QRKDfEEtg3xBSIN8QWODfEF+g3xBmYN8QbODfEHOg3xB6YN8QQSEfEEfhHxBOoR8QVWEfEFvhHxBioR8QaWEfEHAhHxB24R8QfaEfEEQhXxBK4V8QUaFfEFhhXxBfIV8QZeFfEGxhXxBzIV8QeeFfEEChnxBHYZ8QTiGfEFShnxBbYZ8QYiGfEGjhnxBvoZ8QdmGfEHzhnxBDod8QSmHfEFEh3xBX4d8QXqHfEGUh3xBr4d8QcqHfEHlh3xBAIh8QRuIfEE1iHxBUIh8QWuIfEGGiHxBoYh8QbyIfEHWiHxB8Yh8QQyJfEEniXxBQol8QVyJfEF3iXxBkol8Qa2JfEHIiXxB44l8Qf2JfEEYinxBM4p8QU6KfEFpinxBg4p8QZ6KfEG5inxB1Ip8Qe+KfEEKi3xBJIt8QT+LfEFai3xBdYt8QZCLfEGqi3xBxYt8QeCLfEH7i3xBFox8QTCMfEFLjHxBZox8QYGMfEGcjHxBtox8QdGMfEHsjHxBB418QSKNfEE8jXxBV418QXKNfEGNjXxBqI18QcKNfEHdjXxB+I18QROOfEEujnxBSI58QWOOfEF+jnxBmY58QbSOfEHOjnxB6Y58QQSPfEEfj3xBOo98QVSPfEFvj3xBio98QaWPfEHAj3xB2o98QfWPfEEQkHxBK5B8QUaQfEFgkHxBe5B8QZaQfEGxkHxBy5B8QeaQfEEBkXxBHJF8QTeRfEFRkXxBbJF8QYeRfEGikXxBvZF8QdeRfEHykXxBDZJ8QSiSfEFCknxBXZJ8QXiSfEGTknxBrpJ8QciSfEHjknxB/pJ8QRmTfEEzk3xBTpN8QWmTfEGEk3xBn5N8QbmTfEHUk3xB75N8QQqUfEEklHxBP5R8QVqUfEF1lHxBj5R8QaqUfEHFlHxB4JR8QfuUfEEVlXxBMJV8QUuVfEFmlXxBgJV8QZuVfEG2lXxB0ZV8QeuVfEEGlnxBIZZ8QTyWfEFWlnxBcZZ8QYyWfEGnlnxBwpZ8QdyWfEH3lnxBEpd8QS2XfEFHl3xBYpd8QX2XfEGYl3xBspd8Qc2XfEHol3xBA5h8QR2YfEE4mHxBU5h8QW6YfEGImHxBo5h8Qb6YfEHZmHxB85h8QQ6ZfEEpmXxBRJl8QV6ZfEF5mXxBlJl8Qa+ZfEHJmXxB5Jl8Qf+ZfEEamnxBNJp8QU+afEFqmnxBhZp8QZ+afEG6mnxB1Zp8Qe+afEEKm3xBJZt8QUCbfEFam3xBdZt8QZCbfEGrm3xBxZt8QeCbfEH7m3xBFpx8QTCcfEFLnHxBZpx8QYGcfEGbnHxBtpx8QdGcfEHrnHxBBp18QSGdfEE8nXxBVp18QXGdfEGMnXxBp518QcGdfEHcnXxB9518QRGefEEsnnxBR558QWKefEF8nnxBl558QbKefEHNnnxB5558QQKffEEdn3xBN598QVKffEFtn3xBiJ98QaKffEG9n3xB2J98QfKffEENoHxBKKB8QUOgfEFdoHxBeKB8QZOgfEGtoHxByKB8QeOgfEH+oHxBGKF8QTOhfEFOoXxBaKF8QYOhfEGeoXxBuaF8QdOhfEHuoXxBCaJ8QSOifEE+onxBWaJ8QXSifEGOonxBqaJ8QcSifEHeonxB+aJ8QRSjfEEvo3xBSaN8QWSjfEF/o3xBmaN8QbSjfEHPo3xB6aN8QQSkfEEfpHxBOqR8QVSkfEFvpHxBiqR8QaSkfEG/pHxB2qR8QfSkfEEPpXxBKqV8QUSlfEFfpXxBeqV8QZWlfEGvpXxByqV8QeWlfEH/pXxBGqZ8QTWmfEFPpnxBaqZ8QYWmfEGfpnxBuqZ8QdWmfEHwpnxBCqd8QSWnfEFAp3xBWqd8QXWnfEGQp3xBqqd8QcWnfEHgp3xB+qd8QRWofEEwqHxBSqh8QWWofEGAqHxBmqh8QbWofEHQqHxB6qh8QQWpfEEgqXxBOql8QVWpfEFwqXxBi6l8QaWpfEHAqXxB26l8QfWpfEEQqnxBK6p8QUWqfEFgqnxBe6p8QZWqfEGwqnxBy6p8QeWqfEEAq3xBG6t8QTWrfEFQq3xBa6t8QYWrfEGgq3xBu6t8QdWrfEHwq3xBC6x8QSWsfEFArHxBW6x8QXWsfEGQrHxBq6x8QcWsfEHgrHxB+qx8QRWtfEEwrXxBSq18QWWtfEGArXxBmq18QbWtfEHQrXxB6q18QQWufEEgrnxBOq58QVWufEFwrnxBiq58QaWufEHArnxB2q58QfWufEEQr3xBKq98QUWvfEFgr3xBeq98QZWvfEGvr3xByq98QeWvfEH/r3xBGrB8QTWwfEFPsHxBarB8QYWwfEGfsHxBurB8QdWwfEHvsHxBCrF8QSSxfEE/sXxBWrF8QXSxfEGPsXxBqrF8QcSxfEHfsXxB+rF8QRSyfEEvsnxBSbJ8QWSyfEF/snxBmbJ8QbSyfEHPsnxB6bJ8QQSzfEEfs3xBObN8QVSzfEFus3xBibN8QaSzfEG+s3xB2bN8QfSzfEEOtHxBKbR8QUO0fEFetHxBebR8QZO0fEGutHxBybR8QeO0fEH+tHxBGLV8QTO1fEFOtXxBaLV8QYO1fEGetXxBuLV8QdO1fEHttXxBCLZ8QSO2fEE9tnxBWLZ8QXK2fEGNtnxBqLZ8QcK2fEHdtnxB+LZ8QRK3fEEtt3xBR7d8QWK3fEF9t3xBl7d8QbK3fEHMt3xB57d8QQK4fEEcuHxBN7h8QVK4fEFsuHxBh7h8QaG4fEG8uHxB17h8QfG4fEEMuXxBJrl8QUG5fEFcuXxBdrl8QZG5fEGruXxBxrl8QeG5fEH7uXxBFrp8QTC6fEFLunxBZrp8QYC6fEGbunxBtbp8QdC6fEHrunxBBbt8QSC7fEE6u3xBVbt8QXC7fEGKu3xBpbt8Qb+7fEHau3xB9Lt8QQ+8fEEqvHxBRLx8QV+8fEF5vHxBlLx8Qa+8fEHJvHxB5Lx8Qf68fEEZvXxBNL18QU69fEFpvXxBg718QZ69fEG4vXxB0718Qe69fEEIvnxBI758QT2+fEFYvnxBc758QY2+fEGovnxBwr58Qd2+fEH3vnxBEr98QS2/fEFHv3xBYr98QXy/fEGXv3xBsb98Qcy/fEHnv3xBAcB8QRzAfEE2wHxBUcB8QWvAfEGGwHxBocB8QbvAfEHWwHxB8MB8QQvBfEElwXxBQMF8QVvBfEF1wXxBkMF8QarBfEHFwXxB38F8QfrBfEEVwnxBL8J8QUrCfEFkwnxBf8J8QZnCfEG0wnxBzsJ8QenCfEEEw3xBHsN8QTnDfEFTw3xBbsN8QYjDfEGjw3xBvsN8QdjDfEHzw3xBDcR8QSjEfEFCxHxBXcR8QXfEfEGSxHxBrcR8QcfEfEHixHxB/MR8QRfFfEExxXxBTMV8QWbFfEGBxXxBm8V8QbbFfEHRxXxB68V8QQbGfEEgxnxBO8Z8QVXGfEFwxnxBisZ8QaXGfEG/xnxB2sZ8QfXGfEEPx3xBKsd8QUTHfEFfx3xBecd8QZTHfEGux3xBycd8QePHfEH+x3xBGMh8QTPIfEFOyHxBaMh8QYPIfEGdyHxBuMh8QdLIfEHtyHxBB8l8QSLJfEE8yXxBV8l8QXHJfEGMyXxBpsl8QcHJfEHcyXxB9sl8QRHKfEErynxBRsp8QWDKfEF7ynxBlcp8QbDKfEHKynxB5cp8Qf/KfEEay3xBNMt8QU/LfEFpy3xBhMt8QZ7LfEG5y3xB08t8Qe7LfEEJzHxBI8x8QT7MfEFYzHxBc8x8QY3MfEGozHxBwsx8Qd3MfEH3zHxBEs18QSzNfEFHzXxBYc18QXzNfEGWzXxBsc18QcvNfEHmzXxBAM58QRvOfEE1znxBUM58QWrOfEGFznxBn858QbrOfEHUznxB7858QQnPfEEkz3xBPs98QVnPfEFzz3xBjs98QajPfEHDz3xB3c98QfjPfEES0HxBLdB8QUfQfEFi0HxBfNB8QZfQfEGx0HxBzNB8QebQfEEB0XxBG9F8QTbRfEFQ0XxBa9F8QYXRfEGg0XxButF8QdXRfEHv0XxBCtJ8QSTSfEE/0nxBWdJ8QXTSfEGO0nxBqdJ8QcPSfEHe0nxB+NJ8QRPTfEEt03xBSNN8QWLTfEF903xBl9N8QbLTfEHM03xB59N8QQHUfEEc1HxBNtR8QVHUfEFr1HxBhtR8QaDUfEG61HxB1dR8Qe/UfEEK1XxBJNV8QT/VfEFZ1XxBdNV8QY7VfEGp1XxBw9V8Qd7VfEH41XxBE9Z8QS3WfEFI1nxBYtZ8QX3WfEGX1nxBstZ8QczWfEHm1nxBAdd8QRvXfEE213xBUNd8QWvXfEGF13xBoNd8QbrXfEHV13xB79d8QQrYfEEk2HxBP9h8QVnYfEFz2HxBjth8QajYfEHD2HxB3dh8QfjYfEES2XxBLdl8QUfZfEFi2XxBfNl8QZfZfEGx2XxBy9l8QebZfEEA2nxBG9p8QTXafEFQ2nxBatp8QYXafEGf2nxButp8QdTafEHu2nxBCdt8QSPbfEE+23xBWNt8QXPbfEGN23xBqNt8QcLbfEHc23xB99t8QRHcfEEs3HxBRtx8QWHcfEF73HxBltx8QbDcfEHL3HxB5dx8Qf/cfEEa3XxBNN18QU/dfEFp3XxBhN18QZ7dfEG43XxB0918Qe3dfEEI3nxBIt58QT3efEFX3nxBct58QYzefEGm3nxBwd58QdvefEH23nxBEN98QSvffEFF33xBX998QXrffEGU33xBr998QcnffEHk33xB/t98QRjgfEEz4HxBTeB8QWjgfEGC4HxBneB8QbfgfEHR4HxB7OB8QQbhfEEh4XxBO+F8QVbhfEFw4XxBiuF8QaXhfEG/4XxB2uF8QfThfEEP4nxBKeJ8QUPifEFe4nxBeOJ8QZPifEGt4nxBx+J8QeLifEH84nxBF+N8QTHjfEFM43xBZuN8QYDjfEGb43xBteN8QdDjfEHq43xBBOR8QR/kfEE55HxBVOR8QW7kfEGJ5HxBo+R8Qb3kfEHY5HxB8uR8QQ3lfEEn5XxBQeV8QVzlfEF25XxBkeV8QavlfEHF5XxB4OV8QfrlfEEV5nxBL+Z8QUnmfEFk5nxBfuZ8QZnmfEGz5nxBzeZ8QejmfEEC53xBHed8QTfnfEFR53xBbOd8QYbnfEGh53xBu+d8QdXnfEHw53xBCuh8QSXofEE/6HxBWeh8QXTofEGO6HxBqeh8QcPofEHd6HxB+Oh8QRLpfEEs6XxBR+l8QWHpfEF86XxBlul8QbDpfEHL6XxB5el8QQDqfEEa6nxBNOp8QU/qfEFp6nxBg+p8QZ7qfEG46nxB0+p8Qe3qfEEH63xBIut8QTzrfEFX63xBcet8QYvrfEGm63xBwOt8QdrrfEH163xBD+x8QSrsfEFE7HxBXux8QXnsfEGT7HxBrex8QcjsfEHi7HxB/ex8QRftfEEx7XxBTO18QWbtfEGA7XxBm+18QbXtfEHP7XxB6u18QQTufEEf7nxBOe58QVPufEFu7nxBiO58QaLufEG97nxB1+58QfHufEEM73xBJu98QUHvfEFb73xBde98QZDvfEGq73xBxO98Qd/vfEH573xBE/B8QS7wfEFI8HxBY/B8QX3wfEGX8HxBsvB8QczwfEHm8HxBAfF8QRvxfEE18XxBUPF8QWrxfEGE8XxBn/F8QbnxfEHT8XxB7vF8QQjyfEEj8nxBPfJ8QVfyfEFy8nxBjPJ8QabyfEHB8nxB2/J8QfXyfEEQ83xBKvN8QUTzfEFf83xBefN8QZPzfEGu83xByPN8QeLzfEH983xBF/R8QTH0fEFM9HxBZvR8QYD0fEGb9HxBtfR8Qc/0fEHq9HxBBPV8QR71fEE59XxBU/V8QW31fEGI9XxBovV8Qbz1fEHX9XxB8fV8QQv2fEEm9nxBQPZ8QVr2fEF19nxBj/Z8Qan2fEHE9nxB3vZ8Qfj2fEET93xBLfd8QUf3fEFi93xBfPd8QZb3fEGx93xBy/d8QeX3fEEA+HxBGvh8QTT4fEFP+HxBafh8QYP4fEGe+HxBuPh8QdL4fEHt+HxBB/l8QSH5fEE7+XxBVvl8QXD5fEGK+XxBpfl8Qb/5fEHZ+XxB9Pl8QQ76fEEo+nxBQ/p8QV36fEF3+nxBkvp8Qaz6fEHG+nxB4Pp8Qfv6fEEV+3xBL/t8QUr7fEFk+3xBfvt8QZn7fEGz+3xBzft8Qej7fEEC/HxBHPx8QTb8fEFR/HxBa/x8QYX8fEGg/HxBuvx8QdT8fEHv/HxBCf18QSP9fEE9/XxBWP18QXL9fEGM/XxBp/18QcH9fEHb/XxB9v18QRD+fEEq/nxBRP58QV/+fEF5/nxBk/58Qa7+fEHI/nxB4v58Qf3+fEEX/3xBMf98QUv/fEFm/3xBgP98QZr/fEG1/3xBz/98Qen/fEEDAH1BHgB9QTgAfUFSAH1BbQB9QYcAfUGhAH1BuwB9QdYAfUHwAH1BCgF9QSUBfUE/AX1BWQF9QXMBfUGOAX1BqAF9QcIBfUHcAX1B9wF9QRECfUErAn1BRgJ9QWACfUF6An1BlAJ9Qa8CfUHJAn1B4wJ9Qf4CfUEYA31BMgN9QUwDfUFnA31BgQN9QZsDfUG1A31B0AN9QeoDfUEEBH1BHwR9QTkEfUFTBH1BbQR9QYgEfUGiBH1BvAR9QdYEfUHxBH1BCwV9QSUFfUE/BX1BWgV9QXQFfUGOBX1BqAV9QcMFfUHdBX1B9wV9QRIGfUEsBn1BRgZ9QWAGfUF7Bn1BlQZ9Qa8GfUHJBn1B5AZ9Qf4GfUEYB31BMgd9QU0HfUFnB31BgQd9QZsHfUG2B31B0Ad9QeoHfUEECH1BHwh9QTkIfUFTCH1BbQh9QYgIfUGiCH1BvAh9QdYIfUHxCH1BCwl9QSUJfUE/CX1BWgl9QXQJfUGOCX1BqAl9QcMJfUHdCX1B9wl9QREKfUEsCn1BRgp9QWAKfUF6Cn1BlQp9Qa8KfUHJCn1B4wp9Qf0KfUEYC31BMgt9QUwLfUFmC31BgQt9QZsLfUG1C31Bzwt9QeoLfUEEDH1BHgx9QTgMfUFTDH1BbQx9QYcMfUGhDH1Buwx9QdYMfUHwDH1BCg19QSQNfUE/DX1BWQ19QXMNfUGNDX1Bpw19QcINfUHcDX1B9g19QRAOfUErDn1BRQ59QV8OfUF5Dn1BlA59Qa4OfUHIDn1B4g59QfwOfUEXD31BMQ99QUsPfUFlD31Bfw99QZoPfUG0D31Bzg99QegPfUEDEH1BHRB9QTcQfUFREH1BaxB9QYYQfUGgEH1BuhB9QdQQfUHvEH1BCRF9QSMRfUE9EX1BVxF9QXIRfUGMEX1BphF9QcARfUHaEX1B9RF9QQ8SfUEpEn1BQxJ9QV0SfUF4En1BkhJ9QawSfUHGEn1B4BJ9QfsSfUEVE31BLxN9QUkTfUFjE31BfhN9QZgTfUGyE31BzBN9QeYTfUEBFH1BGxR9QTUUfUFPFH1BaRR9QYQUfUGeFH1BuBR9QdIUfUHsFH1BBxV9QSEVfUE7FX1BVRV9QW8VfUGKFX1BpBV9Qb4VfUHYFX1B8hV9QQ0WfUEnFn1BQRZ9QVsWfUF1Fn1BjxZ9QaoWfUHEFn1B3hZ9QfgWfUESF31BLRd9QUcXfUFhF31Bexd9QZUXfUGvF31Byhd9QeQXfUH+F31BGBh9QTIYfUFNGH1BZxh9QYEYfUGbGH1BtRh9Qc8YfUHqGH1BBBl9QR4ZfUE4GX1BUhl9QW0ZfUGHGX1BoRl9QbsZfUHVGX1B7xl9QQoafUEkGn1BPhp9QVgafUFyGn1BjBp9QacafUHBGn1B2xp9QfUafUEPG31BKRt9QUQbfUFeG31BeBt9QZIbfUGsG31Bxht9QeEbfUH7G31BFRx9QS8cfUFJHH1BYxx9QX4cfUGYHH1Bshx9QcwcfUHmHH1BAB19QRodfUE1HX1BTx19QWkdfUGDHX1BnR19QbcdfUHSHX1B7B19QQYefUEgHn1BOh59QVQefUFuHn1BiR59QaMefUG9Hn1B1x59QfEefUELH31BJh99QUAffUFaH31BdB99QY4ffUGoH31Bwh99Qd0ffUH3H31BESB9QSsgfUFFIH1BXyB9QXkgfUGUIH1BriB9QcggfUHiIH1B/CB9QRYhfUEwIX1BSyF9QWUhfUF/IX1BmSF9QbMhfUHNIX1B5yF9QQIifUEcIn1BNiJ9QVAifUFqIn1BhCJ9QZ4ifUG4In1B0yJ9Qe0ifUEHI31BISN9QTsjfUFVI31BbyN9QYojfUGkI31BviN9QdgjfUHyI31BDCR9QSYkfUFAJH1BWyR9QXUkfUGPJH1BqSR9QcMkfUHdJH1B9yR9QRElfUEsJX1BRiV9QWAlfUF6JX1BlCV9Qa4lfUHIJX1B4iV9QfwlfUEXJn1BMSZ9QUsmfUFlJn1BfyZ9QZkmfUGzJn1BzSZ9QegmfUECJ31BHCd9QTYnfUFQJ31Baid9QYQnfUGeJ31BuCd9QdMnfUHtJ31BByh9QSEofUE7KH1BVSh9QW8ofUGJKH1Boyh9Qb4ofUHYKH1B8ih9QQwpfUEmKX1BQCl9QVopfUF0KX1Bjil9QagpfUHDKX1B3Sl9QfcpfUERKn1BKyp9QUUqfUFfKn1BeSp9QZMqfUGtKn1ByCp9QeIqfUH8Kn1BFit9QTArfUFKK31BZCt9QX4rfUGYK31Bsit9QcwrfUHnK31BASx9QRssfUE1LH1BTyx9QWksfUGDLH1BnSx9QbcsfUHRLH1B6yx9QQYtfUEgLX1BOi19QVQtfUFuLX1BiC19QaItfUG8LX1B1i19QfAtfUEKLn1BJS59QT8ufUFZLn1Bcy59QY0ufUGnLn1BwS59QdsufUH1Ln1BDy99QSkvfUFDL31BXS99QXgvfUGSL31BrC99QcYvfUHgL31B+i99QRQwfUEuMH1BSDB9QWIwfUF8MH1BljB9QbAwfUHKMH1B5TB9Qf8wfUEZMX1BMzF9QU0xfUFnMX1BgTF9QZsxfUG1MX1BzzF9QekxfUEDMn1BHTJ9QTcyfUFRMn1BbDJ9QYYyfUGgMn1BujJ9QdQyfUHuMn1BCDN9QSIzfUE8M31BVjN9QXAzfUGKM31BpDN9Qb4zfUHYM31B8jN9QQ00fUEnNH1BQTR9QVs0fUF1NH1BjzR9Qak0fUHDNH1B3TR9Qfc0fUERNX1BKzV9QUU1fUFfNX1BeTV9QZM1fUGtNX1BxzV9QeE1fUH8NX1BFjZ9QTA2fUFKNn1BZDZ9QX42fUGYNn1BsjZ9Qcw2fUHmNn1BADd9QRo3fUE0N31BTjd9QWg3fUGCN31BnDd9QbY3fUHQN31B6jd9QQQ4fUEeOH1BODh9QVI4fUFtOH1Bhzh9QaE4fUG7OH1B1Th9Qe84fUEJOX1BIzl9QT05fUFXOX1BcTl9QYs5fUGlOX1Bvzl9Qdk5fUHzOX1BDTp9QSc6fUFBOn1BWzp9QXU6fUGPOn1BqTp9QcM6fUHdOn1B9zp9QRE7fUErO31BRTt9QV87fUF5O31Bkzt9Qa07fUHIO31B4jt9Qfw7fUEWPH1BMDx9QUo8fUFkPH1Bfjx9QZg8fUGyPH1BzDx9QeY8fUEAPX1BGj19QTQ9fUFOPX1BaD19QYI9fUGcPX1Btj19QdA9fUHqPX1BBD59QR4+fUE4Pn1BUj59QWw+fUGGPn1BoD59Qbo+fUHUPn1B7j59QQg/fUEiP31BPD99QVY/fUFwP31Bij99QaQ/fUG+P31B2D99QfI/fUEMQH1BJkB9QUBAfUFaQH1BdEB9QY5AfUGoQH1BwkB9QdxAfUH2QH1BEEF9QSpBfUFEQX1BXkF9QXhBfUGSQX1BrEF9QcZBfUHgQX1B+kF9QRRCfUEuQn1BSEJ9QWJCfUF8Qn1BlkJ9QbBCfUHKQn1B5EJ9Qf5CfUEYQ31BMkN9QUxDfUFmQ31BgEN9QZpDfUG0Q31BzkN9QehDfUECRH1BHER9QTZEfUFQRH1BakR9QYREfUGeRH1BuER9QdJEfUHsRH1BBkV9QSBFfUE6RX1BVEV9QW5FfUGIRX1BokV9QbxFfUHWRX1B70V9QQlGfUEjRn1BPUZ9QVdGfUFxRn1Bi0Z9QaVGfUG/Rn1B2UZ9QfNGfUENR31BJ0d9QUFHfUFbR31BdUd9QY9HfUGpR31Bw0d9Qd1HfUH3R31BEUh9QStIfUFFSH1BX0h9QXlIfUGTSH1BrUh9QcdIfUHhSH1B+0h9QRVJfUEvSX1BSUl9QWJJfUF8SX1Blkl9QbBJfUHKSX1B5El9Qf5JfUEYSn1BMkp9QUxKfUFmSn1BgEp9QZpKfUG0Sn1Bzkp9QehKfUECS31BHEt9QTZLfUFQS31Bakt9QYRLfUGeS31Bt0t9QdFLfUHrS31BBUx9QR9MfUE5TH1BU0x9QW1MfUGHTH1BoUx9QbtMfUHVTH1B70x9QQlNfUEjTX1BPU19QVdNfUFxTX1Bi019QaRNfUG+TX1B2E19QfJNfUEMTn1BJk59QUBOfUFaTn1BdE59QY5OfUGoTn1Bwk59QdxOfUH2Tn1BEE99QSpPfUFET31BXU99QXdPfUGRT31Bq099QcVPfUHfT31B+U99QRNQfUEtUH1BR1B9QWFQfUF7UH1BlVB9Qa9QfUHJUH1B4lB9QfxQfUEWUX1BMFF9QUpRfUFkUX1BflF9QZhRfUGyUX1BzFF9QeZRfUEAUn1BGlJ9QTRSfUFNUn1BZ1J9QYFSfUGbUn1BtVJ9Qc9SfUHpUn1BA1N9QR1TfUE3U31BUVN9QWtTfUGEU31BnlN9QbhTfUHSU31B7FN9QQZUfUEgVH1BOlR9QVRUfUFuVH1BiFR9QaJUfUG7VH1B1VR9Qe9UfUEJVX1BI1V9QT1VfUFXVX1BcVV9QYtVfUGlVX1Bv1V9QdhVfUHyVX1BDFZ9QSZWfUFAVn1BWlZ9QXRWfUGOVn1BqFZ9QcJWfUHcVn1B9VZ9QQ9XfUEpV31BQ1d9QV1XfUF3V31BkVd9QatXfUHFV31B31d9QfhXfUESWH1BLFh9QUZYfUFgWH1Belh9QZRYfUGuWH1ByFh9QeJYfUH7WH1BFVl9QS9ZfUFJWX1BY1l9QX1ZfUGXWX1BsVl9QctZfUHkWX1B/ll9QRhafUEyWn1BTFp9QWZafUGAWn1Bmlp9QbRafUHNWn1B51p9QQFbfUEbW31BNVt9QU9bfUFpW31Bg1t9QZxbfUG2W31B0Ft9QepbfUEEXH1BHlx9QThcfUFSXH1BbFx9QYVcfUGfXH1BuVx9QdNcfUHtXH1BB119QSFdfUE7XX1BVF19QW5dfUGIXX1Bol19QbxdfUHWXX1B8F19QQpefUEjXn1BPV59QVdefUFxXn1Bi159QaVefUG/Xn1B2V59QfJefUEMX31BJl99QUBffUFaX31BdF99QY5ffUGnX31BwV99QdtffUH1X31BD2B9QSlgfUFDYH1BXGB9QXZgfUGQYH1BqmB9QcRgfUHeYH1B+GB9QRFhfUErYX1BRWF9QV9hfUF5YX1Bk2F9Qa1hfUHGYX1B4GF9QfphfUEUYn1BLmJ9QUhifUFiYn1Be2J9QZVifUGvYn1ByWJ9QeNifUH9Yn1BF2N9QTBjfUFKY31BZGN9QX5jfUGYY31BsmN9QcxjfUHlY31B/2N9QRlkfUEzZH1BTWR9QWdkfUGAZH1BmmR9QbRkfUHOZH1B6GR9QQJlfUEbZX1BNWV9QU9lfUFpZX1Bg2V9QZ1lfUG3ZX1B0GV9QeplfUEEZn1BHmZ9QThmfUFSZn1Ba2Z9QYVmfUGfZn1BuWZ9QdNmfUHtZn1BBmd9QSBnfUE6Z31BVGd9QW5nfUGIZ31BoWd9QbtnfUHVZ31B72d9QQlofUEjaH1BPGh9QVZofUFwaH1Bimh9QaRofUG9aH1B12h9QfFofUELaX1BJWl9QT9pfUFYaX1Bcml9QYxpfUGmaX1BwGl9QdppfUHzaX1BDWp9QSdqfUFBan1BW2p9QXRqfUGOan1BqGp9QcJqfUHcan1B9mp9QQ9rfUEpa31BQ2t9QV1rfUF3a31BkGt9QaprfUHEa31B3mt9QfhrfUERbH1BK2x9QUVsfUFfbH1BeWx9QZJsfUGsbH1Bxmx9QeBsfUH6bH1BFG19QS1tfUFHbX1BYW19QXttfUGVbX1Brm19QchtfUHibX1B/G19QRZufUEvbn1BSW59QWNufUF9bn1Bl259QbBufUHKbn1B5G59Qf5ufUEYb31BMW99QUtvfUFlb31Bf299QZlvfUGyb31BzG99QeZvfUEAcH1BGnB9QTNwfUFNcH1BZ3B9QYFwfUGacH1BtHB9Qc5wfUHocH1BAnF9QRtxfUE1cX1BT3F9QWlxfUGDcX1BnHF9QbZxfUHQcX1B6nF9QQRyfUEdcn1BN3J9QVFyfUFrcn1BhHJ9QZ5yfUG4cn1B0nJ9QexyfUEFc31BH3N9QTlzfUFTc31BbHN9QYZzfUGgc31BunN9QdRzfUHtc31BB3R9QSF0fUE7dH1BVHR9QW50fUGIdH1BonR9Qbx0fUHVdH1B73R9QQl1fUEjdX1BPHV9QVZ1fUFwdX1BinV9QaN1fUG9dX1B13V9QfF1fUELdn1BJHZ9QT52fUFYdn1BcnZ9QYt2fUGldn1Bv3Z9Qdl2fUHydn1BDHd9QSZ3fUFAd31BWXd9QXN3fUGNd31Bp3d9QcF3fUHad31B9Hd9QQ54fUEoeH1BQXh9QVt4fUF1eH1Bj3h9Qah4fUHCeH1B3Hh9QfZ4fUEPeX1BKXl9QUN5fUFdeX1Bdnl9QZB5fUGqeX1BxHl9Qd15fUH3eX1BEXp9QSt6fUFEen1BXnp9QXh6fUGSen1Bq3p9QcV6fUHfen1B+Xp9QRJ7fUEse31BRnt9QWB7fUF5e31Bk3t9Qa17fUHHe31B4Ht9Qfp7fUEUfH1BLXx9QUd8fUFhfH1Be3x9QZR8fUGufH1ByHx9QeJ8fUH7fH1BFX19QS99fUFJfX1BYn19QXx9fUGWfX1BsH19Qcl9fUHjfX1B/X19QRZ+fUEwfn1BSn59QWR+fUF9fn1Bl359QbF+fUHLfn1B5H59Qf5+fUEYf31BMn99QUt/fUFlf31Bf399QZh/fUGyf31BzH99QeZ/fUH/f31BGYB9QTOAfUFMgH1BZoB9QYCAfUGagH1Bs4B9Qc2AfUHngH1BAYF9QRqBfUE0gX1BToF9QWeBfUGBgX1Bm4F9QbWBfUHOgX1B6IF9QQKCfUEbgn1BNYJ9QU+CfUFpgn1BgoJ9QZyCfUG2gn1Bz4J9QemCfUEDg31BHYN9QTaDfUFQg31BaoN9QYODfUGdg31Bt4N9QdCDfUHqg31BBIR9QR6EfUE3hH1BUYR9QWuEfUGEhH1BnoR9QbiEfUHShH1B64R9QQWFfUEfhX1BOIV9QVKFfUFshX1BhYV9QZ+FfUG5hX1B04V9QeyFfUEGhn1BIIZ9QTmGfUFThn1BbYZ9QYaGfUGghn1BuoZ9QdOGfUHthn1BB4d9QSGHfUE6h31BVId9QW6HfUGHh31BoYd9QbuHfUHUh31B7od9QQiIfUEhiH1BO4h9QVWIfUFviH1BiIh9QaKIfUG8iH1B1Yh9Qe+IfUEJiX1BIol9QTyJfUFWiX1Bb4l9QYmJfUGjiX1BvIl9QdaJfUHwiX1BCYp9QSOKfUE9in1BV4p9QXCKfUGKin1BpIp9Qb2KfUHXin1B8Yp9QQqLfUEki31BPot9QVeLfUFxi31Bi4t9QaSLfUG+i31B2It9QfGLfUELjH1BJYx9QT6MfUFYjH1Bcox9QYuMfUGljH1Bv4x9QdiMfUHyjH1BDI19QSWNfUE/jX1BWY19QXKNfUGMjX1Bpo19Qb+NfUHZjX1B8419QQyOfUEmjn1BQI59QVmOfUFzjn1BjY59QaaOfUHAjn1B2o59QfOOfUENj31BJ499QUCPfUFaj31BdI99QY2PfUGnj31BwY99QdqPfUH0j31BDZB9QSeQfUFBkH1BWpB9QXSQfUGOkH1Bp5B9QcGQfUHbkH1B9JB9QQ6RfUEokX1BQZF9QVuRfUF1kX1BjpF9QaiRfUHCkX1B25F9QfWRfUEOkn1BKJJ9QUKSfUFbkn1BdZJ9QY+SfUGokn1BwpJ9QdySfUH1kn1BD5N9QSmTfUFCk31BXJN9QXWTfUGPk31BqZN9QcKTfUHck31B9pN9QQ+UfUEplH1BQ5R9QVyUfUF2lH1Bj5R9QamUfUHDlH1B3JR9QfaUfUEQlX1BKZV9QUOVfUFdlX1BdpV9QZCVfUGplX1Bw5V9Qd2VfUH2lX1BEJZ9QSqWfUFDln1BXZZ9QXaWfUGQln1BqpZ9QcOWfUHdln1B95Z9QRCXfUEql31BQ5d9QV2XfUF3l31BkJd9QaqXfUHEl31B3Zd9QfeXfUEQmH1BKph9QUSYfUFdmH1Bd5h9QZCYfUGqmH1BxJh9Qd2YfUH3mH1BEZl9QSqZfUFEmX1BXZl9QXeZfUGRmX1Bqpl9QcSZfUHdmX1B95l9QRGafUEqmn1BRJp9QV6afUF3mn1BkZp9QaqafUHEmn1B3pp9QfeafUERm31BKpt9QUSbfUFem31Bd5t9QZGbfUGqm31BxJt9Qd6bfUH3m31BEZx9QSqcfUFEnH1BXpx9QXecfUGRnH1Bqpx9QcScfUHenH1B95x9QRGdfUEqnX1BRJ19QV6dfUF3nX1BkZ19QaqdfUHEnX1B3p19QfedfUERnn1BKp59QUSefUFenn1Bd559QZGefUGqnn1BxJ59Qd2efUH3nn1BEZ99QSqffUFEn31BXZ99QXeffUGRn31Bqp99QcSffUHdn31B9599QRGgfUEqoH1BRKB9QV2gfUF3oH1BkKB9QaqgfUHEoH1B3aB9QfegfUEQoX1BKqF9QUShfUFdoX1Bd6F9QZChfUGqoX1Bw6F9Qd2hfUH3oX1BEKJ9QSqifUFDon1BXaJ9QXaifUGQon1BqqJ9QcOifUHdon1B9qJ9QRCjfUEpo31BQ6N9QV2jfUF2o31BkKN9QamjfUHDo31B3KN9QfajfUEQpH1BKaR9QUOkfUFcpH1BdqR9QY+kfUGppH1Bw6R9QdykfUH2pH1BD6V9QSmlfUFCpX1BXKV9QXWlfUGPpX1BqaV9QcKlfUHcpX1B9aV9QQ+mfUEopn1BQqZ9QVumfUF1pn1Bj6Z9QaimfUHCpn1B26Z9QfWmfUEOp31BKKd9QUGnfUFbp31Bdad9QY6nfUGop31Bwad9QdunfUH0p31BDqh9QSeofUFBqH1BW6h9QXSofUGOqH1Bp6h9QcGofUHaqH1B9Kh9QQ2pfUEnqX1BQKl9QVqpfUF0qX1Bjal9QaepfUHAqX1B2ql9QfOpfUENqn1BJqp9QUCqfUFZqn1Bc6p9QYyqfUGmqn1BwKp9QdmqfUHzqn1BDKt9QSarfUE/q31BWat9QXKrfUGMq31Bpat9Qb+rfUHYq31B8qt9QQysfUElrH1BP6x9QVisfUFyrH1Bi6x9QaWsfUG+rH1B2Kx9QfGsfUELrX1BJK19QT6tfUFXrX1Bca19QYqtfUGkrX1Bvq19QdetfUHxrX1BCq59QSSufUE9rn1BV659QXCufUGKrn1Bo659Qb2ufUHWrn1B8K59QQmvfUEjr31BPK99QVavfUFvr31Bia99QaKvfUG8r31B1a99Qe+vfUEIsH1BIrB9QTywfUFVsH1Bb7B9QYiwfUGisH1Bu7B9QdWwfUHusH1BCLF9QSGxfUE7sX1BVLF9QW6xfUGHsX1BobF9QbqxfUHUsX1B7bF9QQeyfUEgsn1BOrJ9QVOyfUFtsn1BhrJ9QaCyfUG5sn1B07J9QeyyfUEGs31BH7N9QTmzfUFSs31BbLN9QYWzfUGfs31BuLN9QdKzfUHrs31BBbR9QR60fUE4tH1BUbR9QWu0fUGEtH1BnrR9Qbe0fUHRtH1B6rR9QQS1fUEdtX1BN7V9QVC1fUFqtX1Bg7V9QZ21fUG2tX1B0LV9Qem1fUEDtn1BHLZ9QTa2fUFPtn1BabZ9QYK2fUGctn1BtbZ9Qc+2fUHotn1BArd9QRu3fUE0t31BTrd9QWe3fUGBt31Bmrd9QbS3fUHNt31B57d9QQC4fUEauH1BM7h9QU24fUFmuH1BgLh9QZm4fUGzuH1BzLh9Qea4fUH/uH1BGbl9QTK5fUFMuX1BZbl9QX65fUGYuX1Bsbl9Qcu5fUHkuX1B/rl9QRe6fUExun1BSrp9QWS6fUF9un1Bl7p9QbC6fUHKun1B47p9Qf26fUEWu31BMLt9QUm7fUFiu31BfLt9QZW7fUGvu31ByLt9QeK7fUH7u31BFbx9QS68fUFIvH1BYbx9QXu8fUGUvH1Brbx9Qce8fUHgvH1B+rx9QRO9fUEtvX1BRr19QWC9fUF5vX1Bk719Qay9fUHGvX1B3719Qfi9fUESvn1BK759QUW+fUFevn1BeL59QZG+fUGrvn1BxL59Qd2+fUH3vn1BEL99QSq/fUFDv31BXb99QXa/fUGQv31Bqb99QcO/fUHcv31B9b99QQ/AfUEowH1BQsB9QVvAfUF1wH1BjsB9QajAfUHBwH1B2sB9QfTAfUENwX1BJ8F9QUDBfUFawX1Bc8F9QY3BfUGmwX1Bv8F9QdnBfUHywX1BDMJ9QSXCfUE/wn1BWMJ9QXHCfUGLwn1BpMJ9Qb7CfUHXwn1B8cJ9QQrDfUEkw31BPcN9QVbDfUFww31BicN9QaPDfUG8w31B1sN9Qe/DfUEIxH1BIsR9QTvEfUFVxH1BbsR9QYjEfUGhxH1BusR9QdTEfUHtxH1BB8V9QSDFfUE6xX1BU8V9QWzFfUGGxX1Bn8V9QbnFfUHSxX1B68V9QQXGfUEexn1BOMZ9QVHGfUFrxn1BhMZ9QZ3GfUG3xn1B0MZ9QerGfUEDx31BHMd9QTbHfUFPx31Bacd9QYLHfUGcx31Btcd9Qc7HfUHox31BAch9QRvIfUE0yH1BTch9QWfIfUGAyH1Bmsh9QbPIfUHMyH1B5sh9Qf/IfUEZyX1BMsl9QUzJfUFlyX1Bfsl9QZjJfUGxyX1By8l9QeTJfUH9yX1BF8p9QTDKfUFKyn1BY8p9QXzKfUGWyn1Br8p9QcnKfUHiyn1B+8p9QRXLfUEuy31BSMt9QWHLfUF6y31BlMt9Qa3LfUHHy31B4Mt9QfnLfUETzH1BLMx9QUbMfUFfzH1BeMx9QZLMfUGrzH1BxMx9Qd7MfUH3zH1BEc19QSrNfUFDzX1BXc19QXbNfUGQzX1Bqc19QcLNfUHczX1B9c19QQ/OfUEozn1BQc59QVvOfUF0zn1Bjc59QafOfUHAzn1B2s59QfPOfUEMz31BJs99QT/PfUFZz31Bcs99QYvPfUGlz31Bvs99QdfPfUHxz31BCtB9QSTQfUE90H1BVtB9QXDQfUGJ0H1BotB9QbzQfUHV0H1B79B9QQjRfUEh0X1BO9F9QVTRfUFt0X1Bh9F9QaDRfUG60X1B09F9QezRfUEG0n1BH9J9QTjSfUFS0n1Ba9J9QYTSfUGe0n1Bt9J9QdHSfUHq0n1BA9N9QR3TfUE2031BT9N9QWnTfUGC031Bm9N9QbXTfUHO031B6NN9QQHUfUEa1H1BNNR9QU3UfUFm1H1BgNR9QZnUfUGy1H1BzNR9QeXUfUH/1H1BGNV9QTHVfUFL1X1BZNV9QX3VfUGX1X1BsNV9QcnVfUHj1X1B/NV9QRXWfUEv1n1BSNZ9QWHWfUF71n1BlNZ9Qa7WfUHH1n1B4NZ9QfrWfUET131BLNd9QUbXfUFf131BeNd9QZLXfUGr131BxNd9Qd7XfUH3131BENh9QSrYfUFD2H1BXNh9QXbYfUGP2H1BqNh9QcLYfUHb2H1B9Nh9QQ7ZfUEn2X1BQNl9QVrZfUFz2X1BjNl9QabZfUG/2X1B2Nl9QfLZfUEL2n1BJNp9QT7afUFX2n1BcNp9QYrafUGj2n1BvNp9QdbafUHv2n1BCNt9QSLbfUE7231BVNt9QW7bfUGH231BoNt9QbrbfUHT231B7Nt9QQbcfUEf3H1BONx9QVLcfUFr3H1BhNx9QZ7cfUG33H1B0Nx9QercfUED3X1BHN19QTbdfUFP3X1BaN19QYLdfUGb3X1BtN19Qc7dfUHn3X1BAN59QRnefUEz3n1BTN59QWXefUF/3n1BmN59QbHefUHL3n1B5N59Qf3efUEX331BMN99QUnffUFj331BfN99QZXffUGv331ByN99QeHffUH6331BFOB9QS3gfUFG4H1BYOB9QXngfUGS4H1BrOB9QcXgfUHe4H1B+OB9QRHhfUEq4X1BQ+F9QV3hfUF24X1Bj+F9QanhfUHC4X1B2+F9QfXhfUEO4n1BJ+J9QUDifUFa4n1Bc+J9QYzifUGm4n1Bv+J9QdjifUHy4n1BC+N9QSTjfUE9431BV+N9QXDjfUGJ431Bo+N9QbzjfUHV431B7uN9QQjkfUEh5H1BOuR9QVTkfUFt5H1BhuR9QZ/kfUG55H1B0uR9QevkfUEF5X1BHuV9QTflfUFR5X1BauV9QYPlfUGc5X1BtuV9Qc/lfUHo5X1BAuZ9QRvmfUE05n1BTeZ9QWfmfUGA5n1BmeZ9QbLmfUHM5n1B5eZ9Qf7mfUEY531BMed9QUrnfUFj531Bfed9QZbnfUGv531Byed9QeLnfUH7531BFOh9QS7ofUFH6H1BYOh9QXnofUGT6H1BrOh9QcXofUHf6H1B+Oh9QRHpfUEq6X1BROl9QV3pfUF26X1Bj+l9QanpfUHC6X1B2+l9QfXpfUEO6n1BJ+p9QUDqfUFa6n1Bc+p9QYzqfUGl6n1Bv+p9QdjqfUHx6n1BCut9QSTrfUE9631BVut9QW/rfUGJ631Bout9QbvrfUHU631B7ut9QQfsfUEg7H1BOux9QVPsfUFs7H1Bhex9QZ/sfUG47H1B0ex9QersfUEE7X1BHe19QTbtfUFP7X1Bae19QYLtfUGb7X1BtO19Qc7tfUHn7X1BAO59QRnufUEz7n1BTO59QWXufUF+7n1BmO59QbHufUHK7n1B4+59Qf3ufUEW731BL+99QUjvfUFi731Be+99QZTvfUGt731Bxu99QeDvfUH5731BEvB9QSvwfUFF8H1BXvB9QXfwfUGQ8H1BqvB9QcPwfUHc8H1B9fB9QQ/xfUEo8X1BQfF9QVrxfUF08X1BjfF9QabxfUG/8X1B2PF9QfLxfUEL8n1BJPJ9QT3yfUFX8n1BcPJ9QYnyfUGi8n1BvPJ9QdXyfUHu8n1BB/N9QSDzfUE6831BU/N9QWzzfUGF831Bn/N9QbjzfUHR831B6vN9QQP0fUEd9H1BNvR9QU/0fUFo9H1BgvR9QZv0fUG09H1BzfR9Qeb0fUEA9X1BGfV9QTL1fUFL9X1BZfV9QX71fUGX9X1BsPV9Qcn1fUHj9X1B/PV9QRX2fUEu9n1BSPZ9QWH2fUF69n1Bk/Z9Qaz2fUHG9n1B3/Z9Qfj2fUER931BKvd9QUT3fUFd931Bdvd9QY/3fUGo931Bwvd9Qdv3fUH0931BDfh9QSb4fUFA+H1BWfh9QXL4fUGL+H1Bpfh9Qb74fUHX+H1B8Ph9QQn5fUEj+X1BPPl9QVX5fUFu+X1Bh/l9QaH5fUG6+X1B0/l9Qez5fUEF+n1BH/p9QTj6fUFR+n1Bavp9QYP6fUGd+n1Btvp9Qc/6fUHo+n1BAft9QRr7fUE0+31BTft9QWb7fUF/+31BmPt9QbL7fUHL+31B5Pt9Qf37fUEW/H1BMPx9QUn8fUFi/H1Be/x9QZT8fUGu/H1Bx/x9QeD8fUH5/H1BEv19QSv9fUFF/X1BXv19QXf9fUGQ/X1Bqf19QcP9fUHc/X1B9f19QQ7+fUEn/n1BQP59QVr+fUFz/n1BjP59QaX+fUG+/n1B2P59QfH+fUEK/31BI/99QTz/fUFV/31Bb/99QYj/fUGh/31Buv99QdP/fUHs/31BBgB+QR8AfkE4AH5BUQB+QWoAfkGDAH5BnQB+QbYAfkHPAH5B6AB+QQEBfkEaAX5BNAF+QU0BfkFmAX5BfwF+QZgBfkGxAX5BywF+QeQBfkH9AX5BFgJ+QS8CfkFIAn5BYgJ+QXsCfkGUAn5BrQJ+QcYCfkHfAn5B+QJ+QRIDfkErA35BRAN+QV0DfkF2A35BkAN+QakDfkHCA35B2wN+QfQDfkENBH5BJgR+QUAEfkFZBH5BcgR+QYsEfkGkBH5BvQR+QdcEfkHwBH5BCQV+QSIFfkE7BX5BVAV+QW0FfkGHBX5BoAV+QbkFfkHSBX5B6wV+QQQGfkEdBn5BNwZ+QVAGfkFpBn5BggZ+QZsGfkG0Bn5BzgZ+QecGfkEAB35BGQd+QTIHfkFLB35BZAd+QX0HfkGXB35BsAd+QckHfkHiB35B+wd+QRQIfkEtCH5BRwh+QWAIfkF5CH5Bkgh+QasIfkHECH5B3Qh+QfcIfkEQCX5BKQl+QUIJfkFbCX5BdAl+QY0JfkGmCX5BwAl+QdkJfkHyCX5BCwp+QSQKfkE9Cn5BVgp+QXAKfkGJCn5Bogp+QbsKfkHUCn5B7Qp+QQYLfkEfC35BOQt+QVILfkFrC35BhAt+QZ0LfkG2C35Bzwt+QegLfkECDH5BGwx+QTQMfkFNDH5BZgx+QX8MfkGYDH5BsQx+QcoMfkHkDH5B/Qx+QRYNfkEvDX5BSA1+QWENfkF6DX5Bkw1+Qa0NfkHGDX5B3w1+QfgNfkERDn5BKg5+QUMOfkFcDn5BdQ5+QY8OfkGoDn5BwQ5+QdoOfkHzDn5BDA9+QSUPfkE+D35BVw9+QXEPfkGKD35Bow9+QbwPfkHVD35B7g9+QQcQfkEgEH5BORB+QVIQfkFsEH5BhRB+QZ4QfkG3EH5B0BB+QekQfkECEX5BGxF+QTQRfkFNEX5BZxF+QYARfkGZEX5BshF+QcsRfkHkEX5B/RF+QRYSfkEvEn5BSBJ+QWISfkF7En5BlBJ+Qa0SfkHGEn5B3xJ+QfgSfkERE35BKhN+QUMTfkFcE35BdhN+QY8TfkGoE35BwRN+QdoTfkHzE35BDBR+QSUUfkE+FH5BVxR+QXAUfkGJFH5BoxR+QbwUfkHVFH5B7hR+QQcVfkEgFX5BORV+QVIVfkFrFX5BhBV+QZ0VfkG2FX5B0BV+QekVfkECFn5BGxZ+QTQWfkFNFn5BZhZ+QX8WfkGYFn5BsRZ+QcoWfkHjFn5B/BZ+QRYXfkEvF35BSBd+QWEXfkF6F35Bkxd+QawXfkHFF35B3hd+QfcXfkEQGH5BKRh+QUIYfkFbGH5BdRh+QY4YfkGnGH5BwBh+QdkYfkHyGH5BCxl+QSQZfkE9GX5BVhl+QW8ZfkGIGX5BoRl+QboZfkHTGX5B7Rl+QQYafkEfGn5BOBp+QVEafkFqGn5Bgxp+QZwafkG1Gn5Bzhp+QecafkEAG35BGRt+QTIbfkFLG35BZBt+QX0bfkGXG35BsBt+QckbfkHiG35B+xt+QRQcfkEtHH5BRhx+QV8cfkF4HH5BkRx+QaocfkHDHH5B3Bx+QfUcfkEOHX5BJx1+QUAdfkFZHX5Bch1+QYwdfkGlHX5Bvh1+QdcdfkHwHX5BCR5+QSIefkE7Hn5BVB5+QW0efkGGHn5Bnx5+QbgefkHRHn5B6h5+QQMffkEcH35BNR9+QU4ffkFnH35BgB9+QZkffkGyH35BzB9+QeUffkH+H35BFyB+QTAgfkFJIH5BYiB+QXsgfkGUIH5BrSB+QcYgfkHfIH5B+CB+QREhfkEqIX5BQyF+QVwhfkF1IX5BjiF+QachfkHAIX5B2SF+QfIhfkELIn5BJCJ+QT0ifkFWIn5BbyJ+QYgifkGhIn5BuiJ+QdMifkHsIn5BBiN+QR8jfkE4I35BUSN+QWojfkGDI35BnCN+QbUjfkHOI35B5yN+QQAkfkEZJH5BMiR+QUskfkFkJH5BfSR+QZYkfkGvJH5ByCR+QeEkfkH6JH5BEyV+QSwlfkFFJX5BXiV+QXclfkGQJX5BqSV+QcIlfkHbJX5B9CV+QQ0mfkEmJn5BPyZ+QVgmfkFxJn5BiiZ+QaMmfkG8Jn5B1SZ+Qe4mfkEHJ35BICd+QTknfkFSJ35Bayd+QYQnfkGdJ35Btid+Qc8nfkHoJ35BASh+QRoofkEzKH5BTCh+QWUofkF+KH5Blyh+QbAofkHJKH5B4ih+QfsofkEUKX5BLSl+QUYpfkFfKX5BeCl+QZEpfkGqKX5Bwyl+QdwpfkH1KX5BDip+QScqfkFAKn5BWSp+QXIqfkGLKn5BpCp+Qb0qfkHWKn5B7yp+QQgrfkEhK35BOit+QVMrfkFsK35BhSt+QZ4rfkG3K35B0Ct+QekrfkECLH5BGyx+QTQsfkFNLH5BZix+QX8sfkGYLH5BsSx+QcosfkHjLH5B/Cx+QRUtfkEuLX5BRy1+QWAtfkF5LX5Bki1+QastfkHELX5B3S1+QfYtfkEPLn5BKC5+QUAufkFZLn5Bci5+QYsufkGkLn5BvS5+QdYufkHvLn5BCC9+QSEvfkE6L35BUy9+QWwvfkGFL35Bni9+QbcvfkHQL35B6S9+QQIwfkEbMH5BNDB+QU0wfkFmMH5BfzB+QZgwfkGxMH5ByjB+QeMwfkH8MH5BFTF+QS4xfkFHMX5BYDF+QXgxfkGRMX5BqjF+QcMxfkHcMX5B9TF+QQ4yfkEnMn5BQDJ+QVkyfkFyMn5BizJ+QaQyfkG9Mn5B1jJ+Qe8yfkEIM35BITN+QTozfkFTM35BbDN+QYUzfkGeM35BtzN+Qc8zfkHoM35BATR+QRo0fkEzNH5BTDR+QWU0fkF+NH5BlzR+QbA0fkHJNH5B4jR+Qfs0fkEUNX5BLTV+QUY1fkFfNX5BeDV+QZE1fkGpNX5BwjV+Qds1fkH0NX5BDTZ+QSY2fkE/Nn5BWDZ+QXE2fkGKNn5BozZ+Qbw2fkHVNn5B7jZ+QQc3fkEgN35BOTd+QVE3fkFqN35Bgzd+QZw3fkG1N35Bzjd+Qec3fkEAOH5BGTh+QTI4fkFLOH5BZDh+QX04fkGWOH5Brzh+Qcg4fkHgOH5B+Th+QRI5fkErOX5BRDl+QV05fkF2OX5Bjzl+Qag5fkHBOX5B2jl+QfM5fkEMOn5BJTp+QT06fkFWOn5Bbzp+QYg6fkGhOn5Bujp+QdM6fkHsOn5BBTt+QR47fkE3O35BUDt+QWk7fkGBO35Bmjt+QbM7fkHMO35B5Tt+Qf47fkEXPH5BMDx+QUk8fkFiPH5Bezx+QZQ8fkGsPH5BxTx+Qd48fkH3PH5BED1+QSk9fkFCPX5BWz1+QXQ9fkGNPX5Bpj1+Qb49fkHXPX5B8D1+QQk+fkEiPn5BOz5+QVQ+fkFtPn5Bhj5+QZ8+fkG4Pn5B0D5+Qek+fkECP35BGz9+QTQ/fkFNP35BZj9+QX8/fkGYP35BsT9+Qco/fkHiP35B+z9+QRRAfkEtQH5BRkB+QV9AfkF4QH5BkUB+QapAfkHDQH5B20B+QfRAfkENQX5BJkF+QT9BfkFYQX5BcUF+QYpBfkGjQX5Bu0F+QdRBfkHtQX5BBkJ+QR9CfkE4Qn5BUUJ+QWpCfkGDQn5BnEJ+QbRCfkHNQn5B5kJ+Qf9CfkEYQ35BMUN+QUpDfkFjQ35Be0N+QZRDfkGtQ35BxkN+Qd9DfkH4Q35BEUR+QSpEfkFDRH5BW0R+QXREfkGNRH5BpkR+Qb9EfkHYRH5B8UR+QQpFfkEjRX5BO0V+QVRFfkFtRX5BhkV+QZ9FfkG4RX5B0UV+QepFfkECRn5BG0Z+QTRGfkFNRn5BZkZ+QX9GfkGYRn5BsUZ+QclGfkHiRn5B+0Z+QRRHfkEtR35BRkd+QV9HfkF4R35BkEd+QalHfkHCR35B20d+QfRHfkENSH5BJkh+QT5IfkFXSH5BcEh+QYlIfkGiSH5Bu0h+QdRIfkHtSH5BBUl+QR5JfkE3SX5BUEl+QWlJfkGCSX5Bm0l+QbNJfkHMSX5B5Ul+Qf5JfkEXSn5BMEp+QUlKfkFhSn5Bekp+QZNKfkGsSn5BxUp+Qd5KfkH3Sn5BD0t+QShLfkFBS35BWkt+QXNLfkGMS35BpUt+Qb1LfkHWS35B70t+QQhMfkEhTH5BOkx+QVJMfkFrTH5BhEx+QZ1MfkG2TH5Bz0x+QehMfkEATX5BGU1+QTJNfkFLTX5BZE1+QX1NfkGVTX5Brk1+QcdNfkHgTX5B+U1+QRJOfkErTn5BQ05+QVxOfkF1Tn5Bjk5+QadOfkHATn5B2E5+QfFOfkEKT35BI09+QTxPfkFVT35BbU9+QYZPfkGfT35BuE9+QdFPfkHqT35BAlB+QRtQfkE0UH5BTVB+QWZQfkF/UH5Bl1B+QbBQfkHJUH5B4lB+QftQfkEUUX5BLFF+QUVRfkFeUX5Bd1F+QZBRfkGpUX5BwVF+QdpRfkHzUX5BDFJ+QSVSfkE+Un5BVlJ+QW9SfkGIUn5BoVJ+QbpSfkHSUn5B61J+QQRTfkEdU35BNlN+QU9TfkFnU35BgFN+QZlTfkGyU35By1N+QeNTfkH8U35BFVR+QS5UfkFHVH5BYFR+QXhUfkGRVH5BqlR+QcNUfkHcVH5B9FR+QQ1VfkEmVX5BP1V+QVhVfkFxVX5BiVV+QaJVfkG7VX5B1FV+Qe1VfkEFVn5BHlZ+QTdWfkFQVn5BaVZ+QYFWfkGaVn5Bs1Z+QcxWfkHlVn5B/VZ+QRZXfkEvV35BSFd+QWFXfkF5V35Bkld+QatXfkHEV35B3Vd+QfVXfkEOWH5BJ1h+QUBYfkFZWH5BcVh+QYpYfkGjWH5BvFh+QdVYfkHtWH5BBll+QR9ZfkE4WX5BUVl+QWlZfkGCWX5Bm1l+QbRZfkHNWX5B5Vl+Qf5ZfkEXWn5BMFp+QUlafkFhWn5Belp+QZNafkGsWn5BxFp+Qd1afkH2Wn5BD1t+QShbfkFAW35BWVt+QXJbfkGLW35BpFt+QbxbfkHVW35B7lt+QQdcfkEfXH5BOFx+QVFcfkFqXH5Bg1x+QZtcfkG0XH5BzVx+QeZcfkH/XH5BF11+QTBdfkFJXX5BYl1+QXpdfkGTXX5BrF1+QcVdfkHeXX5B9l1+QQ9efkEoXn5BQV5+QVlefkFyXn5Bi15+QaRefkG8Xn5B1V5+Qe5efkEHX35BIF9+QThffkFRX35Bal9+QYNffkGbX35BtF9+Qc1ffkHmX35B/l9+QRdgfkEwYH5BSWB+QWJgfkF6YH5Bk2B+QaxgfkHFYH5B3WB+QfZgfkEPYX5BKGF+QUBhfkFZYX5BcmF+QYthfkGjYX5BvGF+QdVhfkHuYX5BB2J+QR9ifkE4Yn5BUWJ+QWpifkGCYn5Bm2J+QbRifkHNYn5B5WJ+Qf5ifkEXY35BMGN+QUhjfkFhY35BemN+QZNjfkGrY35BxGN+Qd1jfkH2Y35BDmR+QSdkfkFAZH5BWWR+QXFkfkGKZH5Bo2R+QbxkfkHUZH5B7WR+QQZlfkEfZX5BN2V+QVBlfkFpZX5BgmV+QZplfkGzZX5BzGV+QeVlfkH9ZX5BFmZ+QS9mfkFHZn5BYGZ+QXlmfkGSZn5BqmZ+QcNmfkHcZn5B9WZ+QQ1nfkEmZ35BP2d+QVhnfkFwZ35BiWd+QaJnfkG7Z35B02d+QexnfkEFaH5BHWh+QTZofkFPaH5BaGh+QYBofkGZaH5Bsmh+QctofkHjaH5B/Gh+QRVpfkEuaX5BRml+QV9pfkF4aX5BkGl+QalpfkHCaX5B22l+QfNpfkEMan5BJWp+QT1qfkFWan5Bb2p+QYhqfkGgan5BuWp+QdJqfkHran5BA2t+QRxrfkE1a35BTWt+QWZrfkF/a35BmGt+QbBrfkHJa35B4mt+QfprfkETbH5BLGx+QUVsfkFdbH5Bdmx+QY9sfkGnbH5BwGx+QdlsfkHybH5BCm1+QSNtfkE8bX5BVG1+QW1tfkGGbX5Bn21+QbdtfkHQbX5B6W1+QQFufkEabn5BM25+QUxufkFkbn5BfW5+QZZufkGubn5Bx25+QeBufkH4bn5BEW9+QSpvfkFDb35BW29+QXRvfkGNb35BpW9+Qb5vfkHXb35B729+QQhwfkEhcH5BOnB+QVJwfkFrcH5BhHB+QZxwfkG1cH5BznB+QeZwfkH/cH5BGHF+QTFxfkFJcX5BYnF+QXtxfkGTcX5BrHF+QcVxfkHdcX5B9nF+QQ9yfkEncn5BQHJ+QVlyfkFycn5BinJ+QaNyfkG8cn5B1HJ+Qe1yfkEGc35BHnN+QTdzfkFQc35BaHN+QYFzfkGac35BsnN+QctzfkHkc35B/XN+QRV0fkEudH5BR3R+QV90fkF4dH5BkXR+Qal0fkHCdH5B23R+QfN0fkEMdX5BJXV+QT11fkFWdX5Bb3V+QYd1fkGgdX5BuXV+QdF1fkHqdX5BA3Z+QRt2fkE0dn5BTXZ+QWV2fkF+dn5Bl3Z+QbB2fkHIdn5B4XZ+Qfp2fkESd35BK3d+QUR3fkFcd35BdXd+QY53fkGmd35Bv3d+Qdh3fkHwd35BCXh+QSJ4fkE6eH5BU3h+QWx4fkGEeH5BnXh+QbZ4fkHOeH5B53h+QQB5fkEYeX5BMXl+QUl5fkFieX5Be3l+QZN5fkGseX5BxXl+Qd15fkH2eX5BD3p+QSd6fkFAen5BWXp+QXF6fkGKen5Bo3p+Qbt6fkHUen5B7Xp+QQV7fkEee35BN3t+QU97fkFoe35BgXt+QZl7fkGye35By3t+QeN7fkH8e35BFHx+QS18fkFGfH5BXnx+QXd8fkGQfH5BqHx+QcF8fkHafH5B8nx+QQt9fkEkfX5BPH1+QVV9fkFufX5Bhn1+QZ99fkG3fX5B0H1+Qel9fkEBfn5BGn5+QTN+fkFLfn5BZH5+QX1+fkGVfn5Brn5+Qcd+fkHffn5B+H5+QRB/fkEpf35BQn9+QVp/fkFzf35BjH9+QaR/fkG9f35B1n9+Qe5/fkEHgH5BH4B+QTiAfkFRgH5BaYB+QYKAfkGbgH5Bs4B+QcyAfkHkgH5B/YB+QRaBfkEugX5BR4F+QWCBfkF4gX5BkYF+QamBfkHCgX5B24F+QfOBfkEMgn5BJYJ+QT2CfkFWgn5BboJ+QYeCfkGggn5BuIJ+QdGCfkHqgn5BAoN+QRuDfkEzg35BTIN+QWWDfkF9g35BloN+Qa+DfkHHg35B4IN+QfiDfkERhH5BKoR+QUKEfkFbhH5Bc4R+QYyEfkGlhH5BvYR+QdaEfkHvhH5BB4V+QSCFfkE4hX5BUYV+QWqFfkGChX5Bm4V+QbOFfkHMhX5B5YV+Qf2FfkEWhn5BLoZ+QUeGfkFghn5BeIZ+QZGGfkGphn5BwoZ+QduGfkHzhn5BDId+QSWHfkE9h35BVod+QW6HfkGHh35BoId+QbiHfkHRh35B6Yd+QQKIfkEbiH5BM4h+QUyIfkFkiH5BfYh+QZaIfkGuiH5Bx4h+Qd+IfkH4iH5BEIl+QSmJfkFCiX5BWol+QXOJfkGLiX5BpIl+Qb2JfkHViX5B7ol+QQaKfkEfin5BOIp+QVCKfkFpin5BgYp+QZqKfkGzin5By4p+QeSKfkH8in5BFYt+QS2LfkFGi35BX4t+QXeLfkGQi35BqIt+QcGLfkHai35B8ot+QQuMfkEjjH5BPIx+QVSMfkFtjH5Bhox+QZ6MfkG3jH5Bz4x+QeiMfkEBjX5BGY1+QTKNfkFKjX5BY41+QXuNfkGUjX5BrY1+QcWNfkHejX5B9o1+QQ+OfkEnjn5BQI5+QVmOfkFxjn5Bio5+QaKOfkG7jn5B045+QeyOfkEFj35BHY9+QTaPfkFOj35BZ49+QX+PfkGYj35BsY9+QcmPfkHij35B+o9+QROQfkErkH5BRJB+QV2QfkF1kH5BjpB+QaaQfkG/kH5B15B+QfCQfkEJkX5BIZF+QTqRfkFSkX5Ba5F+QYORfkGckX5BtJF+Qc2RfkHmkX5B/pF+QReSfkEvkn5BSJJ+QWCSfkF5kn5BkZJ+QaqSfkHDkn5B25J+QfSSfkEMk35BJZN+QT2TfkFWk35BbpN+QYeTfkGgk35BuJN+QdGTfkHpk35BApR+QRqUfkEzlH5BS5R+QWSUfkF8lH5BlZR+Qa6UfkHGlH5B35R+QfeUfkEQlX5BKJV+QUGVfkFZlX5BcpV+QYqVfkGjlX5BvJV+QdSVfkHtlX5BBZZ+QR6WfkE2ln5BT5Z+QWeWfkGAln5BmJZ+QbGWfkHKln5B4pZ+QfuWfkETl35BLJd+QUSXfkFdl35BdZd+QY6XfkGml35Bv5d+QdeXfkHwl35BCJh+QSGYfkE6mH5BUph+QWuYfkGDmH5BnJh+QbSYfkHNmH5B5Zh+Qf6YfkEWmX5BL5l+QUeZfkFgmX5BeJl+QZGZfkGpmX5Bwpl+QduZfkHzmX5BDJp+QSSafkE9mn5BVZp+QW6afkGGmn5Bn5p+QbeafkHQmn5B6Jp+QQGbfkEZm35BMpt+QUqbfkFjm35Be5t+QZSbfkGsm35BxZt+Qd2bfkH2m35BD5x+QSecfkFAnH5BWJx+QXGcfkGJnH5Bopx+QbqcfkHTnH5B65x+QQSdfkEcnX5BNZ1+QU2dfkFmnX5Bfp1+QZedfkGvnX5ByJ1+QeCdfkH5nX5BEZ5+QSqefkFCnn5BW55+QXOefkGMnn5BpJ5+Qb2efkHVnn5B7p5+QQaffkEfn35BN59+QVCffkFon35BgZ9+QZmffkGyn35Byp9+QeOffkH7n35BFKB+QSygfkFFoH5BXaB+QXagfkGOoH5Bp6B+Qb+gfkHYoH5B8KB+QQmhfkEhoX5BOqF+QVKhfkFroX5Bg6F+QZyhfkG0oX5BzaF+QeWhfkH+oX5BFqJ+QS+ifkFHon5BYKJ+QXiifkGRon5BqaJ+QcKifkHaon5B86J+QQujfkEko35BPKN+QVWjfkFto35BhqN+QZ6jfkG3o35Bz6N+QeijfkEApH5BGKR+QTGkfkFJpH5BYqR+QXqkfkGTpH5Bq6R+QcSkfkHcpH5B9aR+QQ2lfkEmpX5BPqV+QVelfkFvpX5BiKV+QaClfkG5pX5B0aV+QeqlfkECpn5BG6Z+QTOmfkFLpn5BZKZ+QXymfkGVpn5BraZ+QcamfkHepn5B96Z+QQ+nfkEop35BQKd+QVmnfkFxp35Biqd+QaKnfkG7p35B06d+QeunfkEEqH5BHKh+QTWofkFNqH5BZqh+QX6ofkGXqH5Br6h+QciofkHgqH5B+ah+QRGpfkEqqX5BQql+QVqpfkFzqX5Bi6l+QaSpfkG8qX5B1al+Qe2pfkEGqn5BHqp+QTeqfkFPqn5BZ6p+QYCqfkGYqn5Bsap+QcmqfkHiqn5B+qp+QROrfkErq35BRKt+QVyrfkF0q35Bjat+QaWrfkG+q35B1qt+Qe+rfkEHrH5BIKx+QTisfkFRrH5Baax+QYGsfkGarH5Bsqx+QcusfkHjrH5B/Kx+QRStfkEtrX5BRa1+QV2tfkF2rX5Bjq1+QaetfkG/rX5B2K1+QfCtfkEJrn5BIa5+QTmufkFSrn5Baq5+QYOufkGbrn5BtK5+QcyufkHlrn5B/a5+QRWvfkEur35BRq9+QV+vfkF3r35BkK9+QaivfkHAr35B2a9+QfGvfkEKsH5BIrB+QTuwfkFTsH5Ba7B+QYSwfkGcsH5BtbB+Qc2wfkHmsH5B/rB+QRaxfkEvsX5BR7F+QWCxfkF4sX5BkbF+QamxfkHBsX5B2rF+QfKxfkELsn5BI7J+QTyyfkFUsn5BbLJ+QYWyfkGdsn5BtrJ+Qc6yfkHnsn5B/7J+QRezfkEws35BSLN+QWGzfkF5s35BkrN+QaqzfkHCs35B27N+QfOzfkEMtH5BJLR+QTy0fkFVtH5BbbR+QYa0fkGetH5Bt7R+Qc+0fkHntH5BALV+QRi1fkExtX5BSbV+QWG1fkF6tX5BkrV+Qau1fkHDtX5B27V+QfS1fkEMtn5BJbZ+QT22fkFWtn5BbrZ+QYa2fkGftn5Bt7Z+QdC2fkHotn5BALd+QRm3fkExt35BSrd+QWK3fkF6t35Bk7d+Qau3fkHEt35B3Ld+QfS3fkENuH5BJbh+QT64fkFWuH5Bbrh+QYe4fkGfuH5BuLh+QdC4fkHouH5BAbl+QRm5fkEyuX5BSrl+QWK5fkF7uX5Bk7l+Qay5fkHEuX5B3Ll+QfW5fkENun5BJbp+QT66fkFWun5Bb7p+QYe6fkGfun5BuLp+QdC6fkHpun5BAbt+QRm7fkEyu35BSrt+QWO7fkF7u35Bk7t+Qay7fkHEu35B3Lt+QfW7fkENvH5BJrx+QT68fkFWvH5Bb7x+QYe8fkGgvH5BuLx+QdC8fkHpvH5BAb1+QRm9fkEyvX5BSr1+QWO9fkF7vX5Bk71+Qay9fkHEvX5B3L1+QfW9fkENvn5BJr5+QT6+fkFWvn5Bb75+QYe+fkGfvn5BuL5+QdC+fkHpvn5BAb9+QRm/fkEyv35BSr9+QWK/fkF7v35Bk79+Qay/fkHEv35B3L9+QfW/fkENwH5BJcB+QT7AfkFWwH5BbsB+QYfAfkGfwH5BuMB+QdDAfkHowH5BAcF+QRnBfkExwX5BSsF+QWLBfkF6wX5Bk8F+QavBfkHEwX5B3MF+QfTBfkENwn5BJcJ+QT3CfkFWwn5BbsJ+QYbCfkGfwn5Bt8J+QdDCfkHown5BAMN+QRnDfkExw35BScN+QWLDfkF6w35BksN+QavDfkHDw35B28N+QfTDfkEMxH5BJMR+QT3EfkFVxH5BbsR+QYbEfkGexH5Bt8R+Qc/EfkHnxH5BAMV+QRjFfkEwxX5BScV+QWHFfkF5xX5BksV+QarFfkHCxX5B28V+QfPFfkELxn5BJMZ+QTzGfkFUxn5BbcZ+QYXGfkGdxn5BtsZ+Qc7GfkHmxn5B/8Z+QRfHfkEvx35BSMd+QWDHfkF4x35Bkcd+QanHfkHBx35B2sd+QfLHfkEKyH5BI8h+QTvIfkFTyH5BbMh+QYTIfkGcyH5Btch+Qc3IfkHlyH5B/sh+QRbJfkEuyX5BR8l+QV/JfkF3yX5BkMl+QajJfkHAyX5B2cl+QfHJfkEJyn5BIsp+QTrKfkFSyn5Ba8p+QYPKfkGbyn5BtMp+QczKfkHkyn5B/cp+QRXLfkEty35BRst+QV7LfkF2y35Bj8t+QafLfkG/y35B2Mt+QfDLfkEIzH5BIcx+QTnMfkFRzH5Bacx+QYLMfkGazH5Bssx+QcvMfkHjzH5B+8x+QRTNfkEszX5BRM1+QV3NfkF1zX5Bjc1+QabNfkG+zX5B1s1+Qe7NfkEHzn5BH85+QTfOfkFQzn5BaM5+QYDOfkGZzn5Bsc5+QcnOfkHizn5B+s5+QRLPfkEqz35BQ89+QVvPfkFzz35BjM9+QaTPfkG8z35B1c9+Qe3PfkEF0H5BHtB+QTbQfkFO0H5BZtB+QX/QfkGX0H5Br9B+QcjQfkHg0H5B+NB+QRHRfkEp0X5BQdF+QVnRfkFy0X5BitF+QaLRfkG70X5B09F+QevRfkED0n5BHNJ+QTTSfkFM0n5BZdJ+QX3SfkGV0n5BrtJ+QcbSfkHe0n5B9tJ+QQ/TfkEn035BP9N+QVjTfkFw035BiNN+QaDTfkG5035B0dN+QenTfkEC1H5BGtR+QTLUfkFK1H5BY9R+QXvUfkGT1H5BrNR+QcTUfkHc1H5B9NR+QQ3VfkEl1X5BPdV+QVXVfkFu1X5BhtV+QZ7VfkG31X5Bz9V+QefVfkH/1X5BGNZ+QTDWfkFI1n5BYdZ+QXnWfkGR1n5BqdZ+QcLWfkHa1n5B8tZ+QQrXfkEj135BO9d+QVPXfkFs135BhNd+QZzXfkG0135Bzdd+QeXXfkH9135BFdh+QS7YfkFG2H5BXth+QXfYfkGP2H5Bp9h+Qb/YfkHY2H5B8Nh+QQjZfkEg2X5BOdl+QVHZfkFp2X5Bgdl+QZrZfkGy2X5Bytl+QeLZfkH72X5BE9p+QSvafkFE2n5BXNp+QXTafkGM2n5Bpdp+Qb3afkHV2n5B7dp+QQbbfkEe235BNtt+QU7bfkFn235Bf9t+QZfbfkGv235ByNt+QeDbfkH4235BENx+QSncfkFB3H5BWdx+QXHcfkGK3H5Botx+QbrcfkHS3H5B69x+QQPdfkEb3X5BM91+QUzdfkFk3X5BfN1+QZTdfkGt3X5Bxd1+Qd3dfkH13X5BDt5+QSbefkE+3n5BVt5+QW/efkGH3n5Bn95+QbfefkHQ3n5B6N5+QQDffkEY335BMN9+QUnffkFh335Bed9+QZHffkGq335Bwt9+QdrffkHy335BC+B+QSPgfkE74H5BU+B+QWzgfkGE4H5BnOB+QbTgfkHM4H5B5eB+Qf3gfkEV4X5BLeF+QUbhfkFe4X5BduF+QY7hfkGn4X5Bv+F+QdfhfkHv4X5BB+J+QSDifkE44n5BUOJ+QWjifkGB4n5BmeJ+QbHifkHJ4n5B4uJ+QfrifkES435BKuN+QULjfkFb435Bc+N+QYvjfkGj435BvON+QdTjfkHs435BBOR+QRzkfkE15H5BTeR+QWXkfkF95H5BleR+Qa7kfkHG5H5B3uR+QfbkfkEP5X5BJ+V+QT/lfkFX5X5Bb+V+QYjlfkGg5X5BuOV+QdDlfkHo5X5BAeZ+QRnmfkEx5n5BSeZ+QWLmfkF65n5BkuZ+QarmfkHC5n5B2+Z+QfPmfkEL535BI+d+QTvnfkFU535BbOd+QYTnfkGc535BtOd+Qc3nfkHl535B/ed+QRXofkEt6H5BRuh+QV7ofkF26H5Bjuh+QabofkG/6H5B1+h+Qe/ofkEH6X5BH+l+QTjpfkFQ6X5BaOl+QYDpfkGY6X5Bsel+QcnpfkHh6X5B+el+QRHqfkEq6n5BQup+QVrqfkFy6n5Biup+QaPqfkG76n5B0+p+QevqfkED635BHOt+QTTrfkFM635BZOt+QXzrfkGU635Bret+QcXrfkHd635B9et+QQ3sfkEm7H5BPux+QVbsfkFu7H5Bhux+QZ/sfkG37H5Bz+x+QefsfkH/7H5BF+1+QTDtfkFI7X5BYO1+QXjtfkGQ7X5Bqe1+QcHtfkHZ7X5B8e1+QQnufkEh7n5BOu5+QVLufkFq7n5Bgu5+QZrufkGz7n5By+5+QePufkH77n5BE+9+QSvvfkFE735BXO9+QXTvfkGM735BpO9+QbzvfkHV735B7e9+QQXwfkEd8H5BNfB+QU3wfkFm8H5BfvB+QZbwfkGu8H5BxvB+Qd7wfkH38H5BD/F+QSfxfkE/8X5BV/F+QW/xfkGI8X5BoPF+QbjxfkHQ8X5B6PF+QQDyfkEZ8n5BMfJ+QUnyfkFh8n5BefJ+QZHyfkGq8n5BwvJ+QdryfkHy8n5BCvN+QSLzfkE7835BU/N+QWvzfkGD835Bm/N+QbPzfkHL835B5PN+QfzzfkEU9H5BLPR+QUT0fkFc9H5BdfR+QY30fkGl9H5BvfR+QdX0fkHt9H5BBfV+QR71fkE29X5BTvV+QWb1fkF+9X5BlvV+Qa71fkHH9X5B3/V+Qff1fkEP9n5BJ/Z+QT/2fkFX9n5BcPZ+QYj2fkGg9n5BuPZ+QdD2fkHo9n5BAPd+QRn3fkEx935BSfd+QWH3fkF5935Bkfd+Qan3fkHC935B2vd+QfL3fkEK+H5BIvh+QTr4fkFS+H5Ba/h+QYP4fkGb+H5Bs/h+Qcv4fkHj+H5B+/h+QRT5fkEs+X5BRPl+QVz5fkF0+X5BjPl+QaT5fkG8+X5B1fl+Qe35fkEF+n5BHfp+QTX6fkFN+n5BZfp+QX36fkGW+n5Brvp+Qcb6fkHe+n5B9vp+QQ77fkEm+35BPvt+QVf7fkFv+35Bh/t+QZ/7fkG3+35Bz/t+Qef7fkH/+35BGPx+QTD8fkFI/H5BYPx+QXj8fkGQ/H5BqPx+QcD8fkHZ/H5B8fx+QQn9fkEh/X5BOf1+QVH9fkFp/X5Bgf1+QZn9fkGy/X5Byv1+QeL9fkH6/X5BEv5+QSr+fkFC/n5BWv5+QXL+fkGL/n5Bo/5+Qbv+fkHT/n5B6/5+QQP/fkEb/35BM/9+QUv/fkFk/35BfP9+QZT/fkGs/35BxP9+Qdz/fkH0/35BDAB/QSQAf0E9AH9BVQB/QW0Af0GFAH9BnQB/QbUAf0HNAH9B5QB/Qf0Af0EVAX9BLgF/QUYBf0FeAX9BdgF/QY4Bf0GmAX9BvgF/QdYBf0HuAX9BBgJ/QR8Cf0E3An9BTwJ/QWcCf0F/An9BlwJ/Qa8Cf0HHAn9B3wJ/QfcCf0EPA39BKAN/QUADf0FYA39BcAN/QYgDf0GgA39BuAN/QdADf0HoA39BAAR/QRgEf0ExBH9BSQR/QWEEf0F5BH9BkQR/QakEf0HBBH9B2QR/QfEEf0EJBX9BIQV/QToFf0FSBX9BagV/QYIFf0GaBX9BsgV/QcoFf0HiBX9B+gV/QRIGf0EqBn9BQgZ/QVoGf0FzBn9BiwZ/QaMGf0G7Bn9B0wZ/QesGf0EDB39BGwd/QTMHf0FLB39BYwd/QXsHf0GTB39BrAd/QcQHf0HcB39B9Ad/QQwIf0EkCH9BPAh/QVQIf0FsCH9BhAh/QZwIf0G0CH9BzAh/QeQIf0H9CH9BFQl/QS0Jf0FFCX9BXQl/QXUJf0GNCX9BpQl/Qb0Jf0HVCX9B7Ql/QQUKf0EdCn9BNQp/QU0Kf0FmCn9Bfgp/QZYKf0GuCn9Bxgp/Qd4Kf0H2Cn9BDgt/QSYLf0E+C39BVgt/QW4Lf0GGC39Bngt/QbYLf0HOC39B5gt/Qf8Lf0EXDH9BLwx/QUcMf0FfDH9Bdwx/QY8Mf0GnDH9Bvwx/QdcMf0HvDH9BBw1/QR8Nf0E3DX9BTw1/QWcNf0F/DX9Blw1/QbANf0HIDX9B4A1/QfgNf0EQDn9BKA5/QUAOf0FYDn9BcA5/QYgOf0GgDn9BuA5/QdAOf0HoDn9BAA9/QRgPf0EwD39BSA9/QWAPf0F4D39BkA9/QagPf0HAD39B2Q9/QfEPf0EJEH9BIRB/QTkQf0FREH9BaRB/QYEQf0GZEH9BsRB/QckQf0HhEH9B+RB/QRERf0EpEX9BQRF/QVkRf0FxEX9BiRF/QaERf0G5EX9B0RF/QekRf0EBEn9BGRJ/QTESf0FJEn9BYRJ/QXoSf0GSEn9BqhJ/QcISf0HaEn9B8hJ/QQoTf0EiE39BOhN/QVITf0FqE39BghN/QZoTf0GyE39ByhN/QeITf0H6E39BEhR/QSoUf0FCFH9BWhR/QXIUf0GKFH9BohR/QboUf0HSFH9B6hR/QQIVf0EaFX9BMhV/QUoVf0FiFX9BehV/QZIVf0GqFX9BwhV/QdoVf0HyFX9BChZ/QSIWf0E6Fn9BUhZ/QWoWf0GCFn9BmhZ/QbIWf0HKFn9B4xZ/QfsWf0ETF39BKxd/QUMXf0FbF39Bcxd/QYsXf0GjF39Buxd/QdMXf0HrF39BAxh/QRsYf0EzGH9BSxh/QWMYf0F7GH9Bkxh/QasYf0HDGH9B2xh/QfMYf0ELGX9BIxl/QTsZf0FTGX9Baxl/QYMZf0GbGX9Bsxl/QcsZf0HjGX9B+xl/QRMaf0ErGn9BQxp/QVsaf0FzGn9Bixp/QaMaf0G7Gn9B0xp/Qesaf0EDG39BGxt/QTMbf0FLG39BYxt/QXsbf0GTG39Bqxt/QcMbf0HbG39B8xt/QQscf0EjHH9BOxx/QVMcf0FrHH9Bgxx/QZscf0GzHH9Byxx/QeIcf0H6HH9BEh1/QSodf0FCHX9BWh1/QXIdf0GKHX9Boh1/Qbodf0HSHX9B6h1/QQIef0EaHn9BMh5/QUoef0FiHn9Beh5/QZIef0GqHn9Bwh5/Qdoef0HyHn9BCh9/QSIff0E6H39BUh9/QWoff0GCH39Bmh9/QbIff0HKH39B4h9/Qfoff0ESIH9BKiB/QUIgf0FaIH9BciB/QYogf0GiIH9BuiB/QdIgf0HqIH9BAiF/QRohf0EyIX9BSSF/QWEhf0F5IX9BkSF/Qakhf0HBIX9B2SF/QfEhf0EJIn9BISJ/QTkif0FRIn9BaSJ/QYEif0GZIn9BsSJ/Qckif0HhIn9B+SJ/QREjf0EpI39BQSN/QVkjf0FxI39BiSN/QaEjf0G5I39B0SN/Qegjf0EAJH9BGCR/QTAkf0FIJH9BYCR/QXgkf0GQJH9BqCR/QcAkf0HYJH9B8CR/QQglf0EgJX9BOCV/QVAlf0FoJX9BgCV/QZglf0GwJX9ByCV/QeAlf0H3JX9BDyZ/QScmf0E/Jn9BVyZ/QW8mf0GHJn9BnyZ/Qbcmf0HPJn9B5yZ/Qf8mf0EXJ39BLyd/QUcnf0FfJ39Bdyd/QY8nf0GnJ39Bvid/QdYnf0HuJ39BBih/QR4of0E2KH9BTih/QWYof0F+KH9Blih/Qa4of0HGKH9B3ih/QfYof0EOKX9BJil/QT4pf0FVKX9BbSl/QYUpf0GdKX9BtSl/Qc0pf0HlKX9B/Sl/QRUqf0EtKn9BRSp/QV0qf0F1Kn9BjSp/QaUqf0G8Kn9B1Cp/Qewqf0EEK39BHCt/QTQrf0FMK39BZCt/QXwrf0GUK39BrCt/QcQrf0HcK39B9Ct/QQssf0EjLH9BOyx/QVMsf0FrLH9Bgyx/QZssf0GzLH9Byyx/QeMsf0H7LH9BEy1/QSstf0FCLX9BWi1/QXItf0GKLX9Boi1/Qbotf0HSLX9B6i1/QQIuf0EaLn9BMi5/QUouf0FiLn9BeS5/QZEuf0GpLn9BwS5/Qdkuf0HxLn9BCS9/QSEvf0E5L39BUS9/QWkvf0GAL39BmC9/QbAvf0HIL39B4C9/Qfgvf0EQMH9BKDB/QUAwf0FYMH9BcDB/QYgwf0GfMH9BtzB/Qc8wf0HnMH9B/zB/QRcxf0EvMX9BRzF/QV8xf0F3MX9BjjF/QaYxf0G+MX9B1jF/Qe4xf0EGMn9BHjJ/QTYyf0FOMn9BZjJ/QX0yf0GVMn9BrTJ/QcUyf0HdMn9B9TJ/QQ0zf0ElM39BPTN/QVUzf0FsM39BhDN/QZwzf0G0M39BzDN/QeQzf0H8M39BFDR/QSw0f0FENH9BWzR/QXM0f0GLNH9BozR/Qbs0f0HTNH9B6zR/QQM1f0EbNX9BMjV/QUo1f0FiNX9BejV/QZI1f0GqNX9BwjV/Qdo1f0HyNX9BCTZ/QSE2f0E5Nn9BUTZ/QWk2f0GBNn9BmTZ/QbE2f0HINn9B4DZ/Qfg2f0EQN39BKDd/QUA3f0FYN39BcDd/QYg3f0GfN39Btzd/Qc83f0HnN39B/zd/QRc4f0EvOH9BRzh/QV44f0F2OH9Bjjh/QaY4f0G+OH9B1jh/Qe44f0EGOX9BHTl/QTU5f0FNOX9BZTl/QX05f0GVOX9BrTl/QcU5f0HcOX9B9Dl/QQw6f0EkOn9BPDp/QVQ6f0FsOn9Bgzp/QZs6f0GzOn9Byzp/QeM6f0H7On9BEzt/QSs7f0FCO39BWjt/QXI7f0GKO39Bojt/Qbo7f0HSO39B6Tt/QQE8f0EZPH9BMTx/QUk8f0FhPH9BeTx/QZA8f0GoPH9BwDx/Qdg8f0HwPH9BCD1/QSA9f0E4PX9BTz1/QWc9f0F/PX9Blz1/Qa89f0HHPX9B3j1/QfY9f0EOPn9BJj5/QT4+f0FWPn9Bbj5/QYU+f0GdPn9BtT5/Qc0+f0HlPn9B/T5/QRU/f0EsP39BRD9/QVw/f0F0P39BjD9/QaQ/f0G7P39B0z9/Qes/f0EDQH9BG0B/QTNAf0FLQH9BYkB/QXpAf0GSQH9BqkB/QcJAf0HaQH9B8UB/QQlBf0EhQX9BOUF/QVFBf0FpQX9BgUF/QZhBf0GwQX9ByEF/QeBBf0H4QX9BEEJ/QSdCf0E/Qn9BV0J/QW9Cf0GHQn9Bn0J/QbZCf0HOQn9B5kJ/Qf5Cf0EWQ39BLkN/QUVDf0FdQ39BdUN/QY1Df0GlQ39BvUN/QdRDf0HsQ39BBER/QRxEf0E0RH9BTER/QWNEf0F7RH9Bk0R/QatEf0HDRH9B2kR/QfJEf0EKRX9BIkV/QTpFf0FSRX9BaUV/QYFFf0GZRX9BsUV/QclFf0HhRX9B+EV/QRBGf0EoRn9BQEZ/QVhGf0FvRn9Bh0Z/QZ9Gf0G3Rn9Bz0Z/QedGf0H+Rn9BFkd/QS5Hf0FGR39BXkd/QXVHf0GNR39BpUd/Qb1Hf0HVR39B7Ud/QQRIf0EcSH9BNEh/QUxIf0FkSH9Be0h/QZNIf0GrSH9Bw0h/QdtIf0HySH9BCkl/QSJJf0E6SX9BUkl/QWpJf0GBSX9BmUl/QbFJf0HJSX9B4Ul/QfhJf0EQSn9BKEp/QUBKf0FYSn9Bb0p/QYdKf0GfSn9Bt0p/Qc9Kf0HmSn9B/kp/QRZLf0EuS39BRkt/QV1Lf0F1S39BjUt/QaVLf0G9S39B1Et/QexLf0EETH9BHEx/QTRMf0FLTH9BY0x/QXtMf0GTTH9Bq0x/QcJMf0HaTH9B8kx/QQpNf0EiTX9BOU1/QVFNf0FpTX9BgU1/QZhNf0GwTX9ByE1/QeBNf0H4TX9BD05/QSdOf0E/Tn9BV05/QW9Of0GGTn9Bnk5/QbZOf0HOTn9B5U5/Qf1Of0EVT39BLU9/QUVPf0FcT39BdE9/QYxPf0GkT39BvE9/QdNPf0HrT39BA1B/QRtQf0EyUH9BSlB/QWJQf0F6UH9BklB/QalQf0HBUH9B2VB/QfFQf0EIUX9BIFF/QThRf0FQUX9BaFF/QX9Rf0GXUX9Br1F/QcdRf0HeUX9B9lF/QQ5Sf0EmUn9BPlJ/QVVSf0FtUn9BhVJ/QZ1Sf0G0Un9BzFJ/QeRSf0H8Un9BE1N/QStTf0FDU39BW1N/QXNTf0GKU39BolN/QbpTf0HSU39B6VN/QQFUf0EZVH9BMVR/QUhUf0FgVH9BeFR/QZBUf0GnVH9Bv1R/QddUf0HvVH9BB1V/QR5Vf0E2VX9BTlV/QWZVf0F9VX9BlVV/Qa1Vf0HFVX9B3FV/QfRVf0EMVn9BJFZ/QTtWf0FTVn9Ba1Z/QYNWf0GaVn9BslZ/QcpWf0HiVn9B+VZ/QRFXf0EpV39BQVd/QVhXf0FwV39BiFd/QaBXf0G3V39Bz1d/QedXf0H/V39BFlh/QS5Yf0FGWH9BXlh/QXVYf0GNWH9BpVh/Qb1Yf0HUWH9B7Fh/QQRZf0EcWX9BM1l/QUtZf0FjWX9Be1l/QZJZf0GqWX9Bwll/QdpZf0HxWX9BCVp/QSFaf0E5Wn9BUFp/QWhaf0GAWn9Bl1p/Qa9af0HHWn9B31p/QfZaf0EOW39BJlt/QT5bf0FVW39BbVt/QYVbf0GdW39BtFt/Qcxbf0HkW39B/Ft/QRNcf0ErXH9BQ1x/QVpcf0FyXH9Bilx/QaJcf0G5XH9B0Vx/Qelcf0EBXX9BGF1/QTBdf0FIXX9BX11/QXddf0GPXX9Bp11/Qb5df0HWXX9B7l1/QQZef0EdXn9BNV5/QU1ef0FkXn9BfF5/QZRef0GsXn9Bw15/Qdtef0HzXn9BC19/QSJff0E6X39BUl9/QWlff0GBX39BmV9/QbFff0HIX39B4F9/Qfhff0EPYH9BJ2B/QT9gf0FXYH9BbmB/QYZgf0GeYH9BtWB/Qc1gf0HlYH9B/WB/QRRhf0EsYX9BRGF/QVthf0FzYX9Bi2F/QaNhf0G6YX9B0mF/Qephf0EBYn9BGWJ/QTFif0FIYn9BYGJ/QXhif0GQYn9Bp2J/Qb9if0HXYn9B7mJ/QQZjf0EeY39BNmN/QU1jf0FlY39BfWN/QZRjf0GsY39BxGN/Qdtjf0HzY39BC2R/QSNkf0E6ZH9BUmR/QWpkf0GBZH9BmWR/QbFkf0HIZH9B4GR/Qfhkf0EQZX9BJ2V/QT9lf0FXZX9BbmV/QYZlf0GeZX9BtWV/Qc1lf0HlZX9B/GV/QRRmf0EsZn9BRGZ/QVtmf0FzZn9Bi2Z/QaJmf0G6Zn9B0mZ/Qelmf0EBZ39BGWd/QTBnf0FIZ39BYGd/QXhnf0GPZ39Bp2d/Qb9nf0HWZ39B7md/QQZof0EdaH9BNWh/QU1of0FkaH9BfGh/QZRof0GraH9Bw2h/Qdtof0HyaH9BCml/QSJpf0E6aX9BUWl/QWlpf0GBaX9BmGl/QbBpf0HIaX9B32l/Qfdpf0EPan9BJmp/QT5qf0FWan9BbWp/QYVqf0Gdan9BtGp/Qcxqf0Hkan9B+2p/QRNrf0Era39BQmt/QVprf0Fya39BiWt/QaFrf0G5a39B0Gt/Qehrf0EAbH9BF2x/QS9sf0FHbH9BXmx/QXZsf0GObH9BpWx/Qb1sf0HVbH9B7Gx/QQRtf0EcbX9BM21/QUttf0FjbX9Bem1/QZJtf0GqbX9BwW1/Qdltf0HxbX9BCG5/QSBuf0E4bn9BT25/QWduf0F/bn9Blm5/Qa5uf0HGbn9B3W5/QfVuf0ENb39BJG9/QTxvf0FUb39Ba29/QYNvf0Gbb39Bsm9/Qcpvf0Hhb39B+W9/QRFwf0EocH9BQHB/QVhwf0FvcH9Bh3B/QZ9wf0G2cH9BznB/QeZwf0H9cH9BFXF/QS1xf0FEcX9BXHF/QXRxf0GLcX9Bo3F/Qbpxf0HScX9B6nF/QQFyf0EZcn9BMXJ/QUhyf0Fgcn9BeHJ/QY9yf0Gncn9Bv3J/QdZyf0Hucn9BBXN/QR1zf0E1c39BTHN/QWRzf0F8c39Bk3N/Qatzf0HDc39B2nN/QfJzf0EJdH9BIXR/QTl0f0FQdH9BaHR/QYB0f0GXdH9Br3R/Qcd0f0HedH9B9nR/QQ11f0EldX9BPXV/QVR1f0FsdX9BhHV/QZt1f0GzdX9By3V/QeJ1f0H6dX9BEXZ/QSl2f0FBdn9BWHZ/QXB2f0GIdn9Bn3Z/Qbd2f0HOdn9B5nZ/Qf52f0EVd39BLXd/QUV3f0Fcd39BdHd/QYt3f0Gjd39Bu3d/QdJ3f0Hqd39BAnh/QRl4f0ExeH9BSHh/QWB4f0F4eH9Bj3h/Qad4f0G+eH9B1nh/Qe54f0EFeX9BHXl/QTV5f0FMeX9BZHl/QXt5f0GTeX9Bq3l/QcJ5f0HaeX9B8Xl/QQl6f0Ehen9BOHp/QVB6f0Foen9Bf3p/QZd6f0Guen9Bxnp/Qd56f0H1en9BDXt/QSR7f0E8e39BVHt/QWt7f0GDe39Bmnt/QbJ7f0HKe39B4Xt/Qfl7f0EQfH9BKHx/QUB8f0FXfH9Bb3x/QYZ8f0GefH9Btnx/Qc18f0HlfH9B/Hx/QRR9f0EsfX9BQ31/QVt9f0FyfX9Bin1/QaJ9f0G5fX9B0X1/Qeh9f0EAfn9BGH5/QS9+f0FHfn9BXn5/QXZ+f0GOfn9BpX5/Qb1+f0HUfn9B7H5/QQR/f0Ebf39BM39/QUp/f0Fif39Ben9/QZF/f0Gpf39BwH9/Qdh/f0Hwf39BB4B/QR+Af0E2gH9BToB/QWWAf0F9gH9BlYB/QayAf0HEgH9B24B/QfOAf0ELgX9BIoF/QTqBf0FRgX9BaYF/QYCBf0GYgX9BsIF/QceBf0HfgX9B9oF/QQ6Cf0Emgn9BPYJ/QVWCf0Fsgn9BhIJ/QZuCf0Gzgn9By4J/QeKCf0H6gn9BEYN/QSmDf0FAg39BWIN/QXCDf0GHg39Bn4N/QbaDf0HOg39B5YN/Qf2Df0EVhH9BLIR/QUSEf0FbhH9Bc4R/QYuEf0GihH9BuoR/QdGEf0HphH9BAIV/QRiFf0EvhX9BR4V/QV+Ff0F2hX9BjoV/QaWFf0G9hX9B1IV/QeyFf0EEhn9BG4Z/QTOGf0FKhn9BYoZ/QXmGf0GRhn9BqYZ/QcCGf0HYhn9B74Z/QQeHf0Eeh39BNod/QU2Hf0Flh39BfYd/QZSHf0Gsh39Bw4d/QduHf0Hyh39BCoh/QSGIf0E5iH9BUYh/QWiIf0GAiH9Bl4h/Qa+If0HGiH9B3oh/QfWIf0ENiX9BJYl/QTyJf0FUiX9Ba4l/QYOJf0GaiX9Bsol/QcmJf0HhiX9B+Yl/QRCKf0Eoin9BP4p/QVeKf0Fuin9Bhop/QZ2Kf0G1in9BzIp/QeSKf0H8in9BE4t/QSuLf0FCi39BWot/QXGLf0GJi39BoIt/QbiLf0HPi39B54t/Qf+Lf0EWjH9BLox/QUWMf0FdjH9BdIx/QYyMf0GjjH9Bu4x/QdKMf0HqjH9BAY1/QRmNf0ExjX9BSI1/QWCNf0F3jX9Bj41/QaaNf0G+jX9B1Y1/Qe2Nf0EEjn9BHI5/QTOOf0FLjn9BYo5/QXqOf0GSjn9BqY5/QcGOf0HYjn9B8I5/QQePf0Efj39BNo9/QU6Pf0Flj39BfY9/QZSPf0Gsj39Bw49/QduPf0Hyj39BCpB/QSGQf0E5kH9BUZB/QWiQf0GAkH9Bl5B/Qa+Qf0HGkH9B3pB/QfWQf0ENkX9BJJF/QTyRf0FTkX9Ba5F/QYKRf0GakX9BsZF/QcmRf0HgkX9B+JF/QQ+Sf0Enkn9BPpJ/QVaSf0Ftkn9BhZJ/QZySf0G0kn9BzJJ/QeOSf0H7kn9BEpN/QSqTf0FBk39BWZN/QXCTf0GIk39Bn5N/QbeTf0HOk39B5pN/Qf2Tf0EVlH9BLJR/QUSUf0FblH9Bc5R/QYqUf0GilH9BuZR/QdGUf0HolH9BAJV/QReVf0EvlX9BRpV/QV6Vf0F1lX9BjZV/QaSVf0G8lX9B05V/QeuVf0ECln9BGpZ/QTGWf0FJln9BYJZ/QXiWf0GPln9Bp5Z/Qb6Wf0HWln9B7ZZ/QQWXf0Ecl39BNJd/QUuXf0Fjl39Bepd/QZKXf0Gpl39BwZd/QdiXf0Hwl39BB5h/QR+Yf0E2mH9BTph/QWWYf0F9mH9BlJh/QayYf0HDmH9B25h/QfKYf0EKmX9BIZl/QTmZf0FQmX9BaJl/QX+Zf0GXmX9Brpl/QcaZf0HdmX9B9Jl/QQyaf0Ejmn9BO5p/QVKaf0Fqmn9BgZp/QZmaf0Gwmn9ByJp/Qd+af0H3mn9BDpt/QSabf0E9m39BVZt/QWybf0GEm39Bm5t/QbObf0HKm39B4pt/Qfmbf0ERnH9BKJx/QT+cf0FXnH9Bbpx/QYacf0GdnH9BtZx/Qcycf0HknH9B+5x/QROdf0EqnX9BQp1/QVmdf0FxnX9BiJ1/QaCdf0G3nX9Bz51/Qeadf0H9nX9BFZ5/QSyef0FEnn9BW55/QXOef0GKnn9Bop5/Qbmef0HRnn9B6J5/QQCff0EXn39BL59/QUaff0Fdn39BdZ9/QYyff0Gkn39Bu59/QdOff0Hqn39BAqB/QRmgf0ExoH9BSKB/QWCgf0F3oH9BjqB/Qaagf0G9oH9B1aB/Qeygf0EEoX9BG6F/QTOhf0FKoX9BYqF/QXmhf0GQoX9BqKF/Qb+hf0HXoX9B7qF/QQaif0Edon9BNaJ/QUyif0Fkon9Be6J/QZKif0Gqon9BwaJ/Qdmif0Hwon9BCKN/QR+jf0E3o39BTqN/QWajf0F9o39BlKN/Qayjf0HDo39B26N/QfKjf0EKpH9BIaR/QTmkf0FQpH9BZ6R/QX+kf0GWpH9BrqR/QcWkf0HdpH9B9KR/QQylf0EjpX9BOqV/QVKlf0FppX9BgaV/QZilf0GwpX9Bx6V/Qd6lf0H2pX9BDaZ/QSWmf0E8pn9BVKZ/QWumf0GDpn9BmqZ/QbGmf0HJpn9B4KZ/Qfimf0EPp39BJ6d/QT6nf0FVp39Bbad/QYSnf0Gcp39Bs6d/Qcunf0Hip39B+ad/QRGof0EoqH9BQKh/QVeof0FvqH9Bhqh/QZ2of0G1qH9BzKh/QeSof0H7qH9BE6l/QSqpf0FBqX9BWal/QXCpf0GIqX9Bn6l/Qbepf0HOqX9B5al/Qf2pf0EUqn9BLKp/QUOqf0Faqn9Bcqp/QYmqf0Ghqn9BuKp/QdCqf0Hnqn9B/qp/QRarf0Etq39BRat/QVyrf0F0q39Bi6t/QaKrf0G6q39B0at/Qemrf0EArH9BF6x/QS+sf0FGrH9BXqx/QXWsf0GMrH9BpKx/Qbusf0HTrH9B6qx/QQKtf0EZrX9BMK1/QUitf0FfrX9Bd61/QY6tf0GlrX9Bva1/QdStf0HsrX9BA65/QRquf0Eyrn9BSa5/QWGuf0F4rn9Bj65/Qaeuf0G+rn9B1q5/Qe2uf0EEr39BHK9/QTOvf0FLr39BYq9/QXmvf0GRr39BqK9/QcCvf0HXr39B7q9/QQawf0EdsH9BNbB/QUywf0FjsH9Be7B/QZKwf0GqsH9BwbB/Qdiwf0HwsH9BB7F/QR+xf0E2sX9BTbF/QWWxf0F8sX9BlLF/Qauxf0HCsX9B2rF/QfGxf0EJsn9BILJ/QTeyf0FPsn9BZrJ/QX2yf0GVsn9BrLJ/QcSyf0Hbsn9B8rJ/QQqzf0Ehs39BObN/QVCzf0Fns39Bf7N/QZazf0Gts39BxbN/Qdyzf0H0s39BC7R/QSK0f0E6tH9BUbR/QWm0f0GAtH9Bl7R/Qa+0f0HGtH9B3bR/QfW0f0EMtX9BJLV/QTu1f0FStX9BarV/QYG1f0GYtX9BsLV/Qce1f0HftX9B9rV/QQ22f0Eltn9BPLZ/QVO2f0Frtn9BgrZ/QZq2f0Gxtn9ByLZ/QeC2f0H3tn9BDrd/QSa3f0E9t39BVLd/QWy3f0GDt39Bm7d/QbK3f0HJt39B4bd/Qfi3f0EPuH9BJ7h/QT64f0FWuH9Bbbh/QYS4f0GcuH9Bs7h/Qcq4f0HiuH9B+bh/QRC5f0EouX9BP7l/QVe5f0FuuX9Bhbl/QZ25f0G0uX9By7l/QeO5f0H6uX9BEbp/QSm6f0FAun9BV7p/QW+6f0GGun9Bnrp/QbW6f0HMun9B5Lp/Qfu6f0ESu39BKrt/QUG7f0FYu39BcLt/QYe7f0Geu39Btrt/Qc27f0Hku39B/Lt/QRO8f0ErvH9BQrx/QVm8f0FxvH9BiLx/QZ+8f0G3vH9Bzrx/QeW8f0H9vH9BFL1/QSu9f0FDvX9BWr1/QXG9f0GJvX9BoL1/Qbe9f0HPvX9B5r1/Qf29f0EVvn9BLL5/QUO+f0Fbvn9Bcr5/QYq+f0Ghvn9BuL5/QdC+f0Hnvn9B/r5/QRa/f0Etv39BRL9/QVy/f0Fzv39Bir9/QaK/f0G5v39B0L9/Qei/f0H/v39BFsB/QS7Af0FFwH9BXMB/QXTAf0GLwH9BosB/QbrAf0HRwH9B6MB/QQDBf0EXwX9BLsF/QUbBf0FdwX9BdMF/QYzBf0GjwX9BusF/QdLBf0HpwX9BAMJ/QRfCf0Evwn9BRsJ/QV3Cf0F1wn9BjMJ/QaPCf0G7wn9B0sJ/QenCf0EBw39BGMN/QS/Df0FHw39BXsN/QXXDf0GNw39BpMN/QbvDf0HTw39B6sN/QQHEf0EZxH9BMMR/QUfEf0FfxH9BdsR/QY3Ef0GkxH9BvMR/QdPEf0HqxH9BAsV/QRnFf0EwxX9BSMV/QV/Ff0F2xX9BjsV/QaXFf0G8xX9B1MV/QevFf0ECxn9BGsZ/QTHGf0FIxn9BX8Z/QXfGf0GOxn9BpcZ/Qb3Gf0HUxn9B68Z/QQPHf0Eax39BMcd/QUnHf0Fgx39Bd8d/QY7Hf0Gmx39Bvcd/QdTHf0Hsx39BA8h/QRrIf0EyyH9BSch/QWDIf0F3yH9Bj8h/QabIf0G9yH9B1ch/QezIf0EDyX9BG8l/QTLJf0FJyX9BYMl/QXjJf0GPyX9Bpsl/Qb7Jf0HVyX9B7Ml/QQTKf0Ebyn9BMsp/QUnKf0Fhyn9BeMp/QY/Kf0Gnyn9Bvsp/QdXKf0Hsyn9BBMt/QRvLf0Eyy39BSst/QWHLf0F4y39Bj8t/QafLf0G+y39B1ct/Qe3Lf0EEzH9BG8x/QTLMf0FKzH9BYcx/QXjMf0GQzH9Bp8x/Qb7Mf0HVzH9B7cx/QQTNf0EbzX9BM81/QUrNf0FhzX9BeM1/QZDNf0GnzX9Bvs1/QdbNf0HtzX9BBM5/QRvOf0Ezzn9BSs5/QWHOf0F5zn9BkM5/QafOf0G+zn9B1s5/Qe3Of0EEz39BG89/QTPPf0FKz39BYc9/QXnPf0GQz39Bp89/Qb7Pf0HWz39B7c9/QQTQf0Eb0H9BM9B/QUrQf0Fh0H9BedB/QZDQf0Gn0H9BvtB/QdbQf0Ht0H9BBNF/QRvRf0Ez0X9BStF/QWHRf0F50X9BkNF/QafRf0G+0X9B1tF/Qe3Rf0EE0n9BG9J/QTPSf0FK0n9BYdJ/QXjSf0GQ0n9Bp9J/Qb7Sf0HV0n9B7dJ/QQTTf0Eb039BMtN/QUrTf0Fh039BeNN/QZDTf0Gn039BvtN/QdXTf0Ht039BBNR/QRvUf0Ey1H9BStR/QWHUf0F41H9Bj9R/QafUf0G+1H9B1dR/QezUf0EE1X9BG9V/QTLVf0FJ1X9BYdV/QXjVf0GP1X9BptV/Qb7Vf0HV1X9B7NV/QQPWf0Eb1n9BMtZ/QUnWf0Fg1n9BeNZ/QY/Wf0Gm1n9BvdZ/QdXWf0Hs1n9BA9d/QRrXf0Ey139BSdd/QWDXf0F3139Bjtd/QabXf0G9139B1Nd/QevXf0ED2H9BGth/QTHYf0FI2H9BYNh/QXfYf0GO2H9Bpdh/Qb3Yf0HU2H9B69h/QQLZf0Ea2X9BMdl/QUjZf0Ff2X9Bdtl/QY7Zf0Gl2X9BvNl/QdPZf0Hr2X9BAtp/QRnaf0Ew2n9BSNp/QV/af0F22n9Bjdp/QaXaf0G82n9B09p/Qeraf0EB239BGdt/QTDbf0FH239BXtt/QXbbf0GN239BpNt/Qbvbf0HS239B6tt/QQHcf0EY3H9BL9x/QUfcf0Fe3H9Bddx/QYzcf0Gj3H9Bu9x/QdLcf0Hp3H9BAN1/QRjdf0Ev3X9BRt1/QV3df0F03X9BjN1/QaPdf0G63X9B0d1/Qendf0EA3n9BF95/QS7ef0FF3n9BXd5/QXTef0GL3n9Bot5/Qbnef0HR3n9B6N5/Qf/ef0EW339BLt9/QUXff0Fc339Bc99/QYrff0Gi339Bud9/QdDff0Hn339B/t9/QRbgf0Et4H9BROB/QVvgf0Fy4H9BiuB/QaHgf0G44H9Bz+B/Qebgf0H+4H9BFeF/QSzhf0FD4X9BW+F/QXLhf0GJ4X9BoOF/Qbfhf0HP4X9B5uF/Qf3hf0EU4n9BK+J/QUPif0Fa4n9BceJ/QYjif0Gf4n9Bt+J/Qc7if0Hl4n9B/OJ/QRPjf0Er439BQuN/QVnjf0Fw439Bh+N/QZ7jf0G2439BzeN/QeTjf0H7439BEuR/QSrkf0FB5H9BWOR/QW/kf0GG5H9BnuR/QbXkf0HM5H9B4+R/Qfrkf0ES5X9BKeV/QUDlf0FX5X9BbuV/QYXlf0Gd5X9BtOV/Qcvlf0Hi5X9B+eV/QRHmf0Eo5n9BP+Z/QVbmf0Ft5n9BheZ/QZzmf0Gz5n9ByuZ/QeHmf0H45n9BEOd/QSfnf0E+539BVed/QWznf0GE539Bm+d/QbLnf0HJ539B4Od/Qffnf0EP6H9BJuh/QT3of0FU6H9Ba+h/QYLof0Ga6H9Bseh/Qcjof0Hf6H9B9uh/QQ3pf0El6X9BPOl/QVPpf0Fq6X9Bgel/QZnpf0Gw6X9Bx+l/Qd7pf0H16X9BDOp/QSTqf0E76n9BUup/QWnqf0GA6n9Bl+p/Qa/qf0HG6n9B3ep/QfTqf0EL639BIut/QTrrf0FR639BaOt/QX/rf0GW639Bret/QcXrf0Hc639B8+t/QQrsf0Eh7H9BOOx/QU/sf0Fn7H9Bfux/QZXsf0Gs7H9Bw+x/Qdrsf0Hy7H9BCe1/QSDtf0E37X9BTu1/QWXtf0F97X9BlO1/Qavtf0HC7X9B2e1/QfDtf0EH7n9BH+5/QTbuf0FN7n9BZO5/QXvuf0GS7n9Bqu5/QcHuf0HY7n9B7+5/QQbvf0Ed739BNO9/QUzvf0Fj739Beu9/QZHvf0Go739Bv+9/Qdbvf0Hu739BBfB/QRzwf0Ez8H9BSvB/QWHwf0F48H9BkPB/Qafwf0G+8H9B1fB/Qezwf0ED8X9BGvF/QTLxf0FJ8X9BYPF/QXfxf0GO8X9BpfF/Qbzxf0HU8X9B6/F/QQLyf0EZ8n9BMPJ/QUfyf0Fe8n9BdvJ/QY3yf0Gk8n9Bu/J/QdLyf0Hp8n9BAPN/QRjzf0Ev839BRvN/QV3zf0F0839Bi/N/QaLzf0G5839B0fN/Qejzf0H/839BFvR/QS30f0FE9H9BW/R/QXL0f0GK9H9BofR/Qbj0f0HP9H9B5vR/Qf30f0EU9X9BK/V/QUP1f0Fa9X9BcfV/QYj1f0Gf9X9BtvV/Qc31f0Hk9X9B/PV/QRP2f0Eq9n9BQfZ/QVj2f0Fv9n9BhvZ/QZ32f0G19n9BzPZ/QeP2f0H69n9BEfd/QSj3f0E/939BVvd/QW73f0GF939BnPd/QbP3f0HK939B4fd/Qfj3f0EP+H9BJvh/QT74f0FV+H9BbPh/QYP4f0Ga+H9Bsfh/Qcj4f0Hf+H9B9vh/QQ75f0El+X9BPPl/QVP5f0Fq+X9Bgfl/QZj5f0Gv+X9Bxvl/Qd75f0H1+X9BDPp/QSP6f0E6+n9BUfp/QWj6f0F/+n9Blvp/Qa36f0HF+n9B3Pp/QfP6f0EK+39BIft/QTj7f0FP+39BZvt/QX37f0GV+39BrPt/QcP7f0Ha+39B8ft/QQj8f0Ef/H9BNvx/QU38f0Fk/H9Be/x/QZP8f0Gq/H9Bwfx/Qdj8f0Hv/H9BBv1/QR39f0E0/X9BS/1/QWL9f0F6/X9Bkf1/Qaj9f0G//X9B1v1/Qe39f0EE/n9BG/5/QTL+f0FJ/n9BYP5/QXj+f0GP/n9Bpv5/Qb3+f0HU/n9B6/5/QQL/f0EZ/39BMP9/QUf/f0Fe/39Bdf9/QY3/f0Gk/39Bu/9/QdL/f0Hp/39BtlgQAGQAAAA4AAAAGAAAALZYEABkAAAAOAAAAC4AAAAQAAAAtlgQAGQAAABCAAAAFAAAALZYEABkAAAAPgAAAAkAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQALZYEABkAAAARwAAAAkAQcqH8wALxwiAPw3gyj8AAABAeJoUQAdwJUC0qzNAAABAQA3gSkB4mlRAVGddQAdwZUAB1GxAtKtzQH8KekAAAIBAf8yCQAdwhUAG74dAPE2KQN2NjECqs45ABcGQQAO4kkB4mpRAAWqWQAoomEDa1ZlAlXSbQD8FnUDHiJ5AAACgQK1roUB/zKJAFiOkQAdwpUDYs6ZABu+nQAQiqUA8TapAEXGrQN2NrED2o61AqrOuQEO9r0AFwbBAMb+xQAO4skC0q7NAeJq0QIKEtUABarZAIEu3QAoouEDmALlA2tW5QAmnukCVdLtAnT68QD8FvUCayL1Ax4i+QOFFv0AAAMBAPbfAQK1rwUBnHcJAf8zCQAh5w0AWI8RAusrEQAdwxUALE8ZA2LPGQHxSx0AG78dAhInIQAQiyUCSuMlAPE3KQA3gykARcctAUwDMQN2NzEC7Gc1A9qPNQJgszkCqs85ANTnPQEO9z0DbP9BABcHQQMpA0UAxv9FAQjzSQAO40kB8MtNAtKvTQLAj1EB4mtRAEhDVQIKE1UDQ99VAAWrWQBnb1kAgS9dAGbrXQAoo2ED3lNhA5gDZQNtr2UDa1dlA6D7aQAmn2kBBDttAlXTbQAfa20CdPtxAWaLcQD8F3UBUZ91AmsjdQBQp3kDHiN5AtOfeQOFF30BOo99AAADgQPlb4EA9t+BAzRHhQK1r4UDgxOFAZx3iQEZ14kB/zOJAFCPjQAh540BezuNAFiPkQDR35EC6yuRAqh3lQAdw5UDRweVACxPmQLdj5kDYs+ZAbgPnQHxS50ADoedABu/nQIU86ECEiehAA9boQAQi6UCIbelAkrjpQCMD6kA8TepA35bqQA3g6kDIKOtAEXHrQOm460BTAOxATkfsQN2N7EAB1OxAuxntQAxf7UD2o+1AeejtQJgs7kBScO5AqrPuQKD27kA1Oe9Aa3vvQEO970C9/u9A2z/wQJ2A8EAFwfBAFAHxQMpA8UApgPFAMb/xQOT98UBCPPJATHryQAO48kBo9fJAfDLzQEBv80C0q/NA2efzQLAj9EA7X/RAeJr0QGrV9EASEPVAb0r1QIKE9UBNvvVA0Pf1QAwx9kABavZAsKL2QBnb9kA/E/dAIEv3QL6C90AZuvdAMvH3QAoo+EChXvhA95T4QA7L+EDmAPlAfzb5QNtr+UD5oPlA2tX5QH8K+kDoPvpAFnP6QAmn+kDC2vpAQQ77QIdB+0CVdPtAaqf7QAfa+0BtDPxAnT78QJZw/EBZovxA59P8QD8F/UBkNv1AVGf9QBCY/UCayP1A8Pj9QBQp/kAGWf5Ax4j+QFa4/kC05/5A4xb/QOFF/0CvdP9ATqP/QL7R/0BtaWQgPiBsZW4AAADAxxwACQAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAQaCQ8wALtQEBAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAEGUkvMAC60BAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAQdST8wALjUIzHhAAagAAACYAAABEAAAAMx4QAGoAAAAmAAAAVAAAADMeEABqAAAAyAAAABkAAAAzHhAAagAAAMgAAAAtAAAAMx4QAGoAAADRAAAAHQAAADMeEABqAAAAtwAAAA0AAAAzHhAAagAAALgAAAANAAAAMx4QAGoAAADEAAAAHQAAADMeEABqAAAAogAAAA0AAAAzHhAAagAAAKMAAAANAAAAMx4QAGoAAACvAAAAHQAAADMeEABqAAAAkAAAAA0AAAAzHhAAagAAAJEAAAANAAAAMx4QAGoAAACXAAAAHQAAADMeEABqAAAA5gAAABkAAAAzHhAAagAAAPgAAAAFAAAAMx4QAGoAAAARAQAAGQAAADMeEABqAAAAEQEAAC0AAAAzHhAAagAAABoBAAAdAAAAMx4QAGoAAAAEAQAAGQAAADMeEABqAAAABAEAAC0AAAAzHhAAagAAAA0BAAAdAAAAMx4QAGoAAAApAQAAFwAAADMeEABqAAAAKwEAAA0AAAAzHhAAagAAACwBAAANAAAAMx4QAGoAAABDAQAACQAAADMeEABqAAAARAEAAAkAAAAzHhAAagAAAEsBAAAZAAAAMx4QAGoAAACrAQAAGQAAADMeEABqAAAAqwEAAC0AAAAzHhAAagAAALIBAAAZAAAAMx4QAGoAAACyAQAALQAAADMeEABqAAAAtQEAAB0AAAAzHhAAagAAALoBAAAdAAAAMx4QAGoAAACUAQAADQAAADMeEABqAAAAlQEAAA0AAAAzHhAAagAAAJ8BAAAZAAAAMx4QAGoAAACfAQAALQAAADMeEABqAAAAogEAAB0AAAAzHhAAagAAAKcBAAAdAAAAMx4QAGoAAAB+AQAADQAAADMeEABqAAAAfwEAAA0AAAAzHhAAagAAAIQBAAAZAAAAMx4QAGoAAACEAQAALQAAADMeEABqAAAAhwEAAB0AAAAzHhAAagAAAIwBAAAdAAAAMx4QAGoAAABqAQAADQAAADMeEABqAAAAawEAAA0AAAAzHhAAagAAAHcBAAAdAAAAMx4QAGoAAABaAQAADQAAADMeEABqAAAAWwEAAA0AAAAzHhAAagAAAGEBAAAdAAAAMx4QAGoAAAAHAgAAGQAAADMeEABqAAAABwIAAC0AAAAzHhAAagAAABACAAAdAAAAMx4QAGoAAAD2AQAADQAAADMeEABqAAAA9wEAAA0AAAAzHhAAagAAAAMCAAAdAAAAMx4QAGoAAADhAQAADQAAADMeEABqAAAA4gEAAA0AAAAzHhAAagAAAO4BAAAdAAAAMx4QAGoAAADPAQAADQAAADMeEABqAAAA0AEAAA0AAAAzHhAAagAAANYBAAAdAAAAMx4QAGoAAAAqAgAAKwAAADMeEABqAAAAHgIAACMAAAAzHhAAagAAADgCAAAjAAAAMx4QAGoAAABOAgAAEwAAADMeEABqAAAAUgIAABMAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAABYhEABkAAAALgAAAB8AAAAWIRAAZAAAAC4AAAALAAAAbWlkID4gbGVuAAAAZM4cAAkAAAAAAAAAAQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwD//x8A//8/AP//fwD///8A////Af///wP///8H////D////x////8/////f//////ffBAAcAAAACAAAAAFAAAA33wQAHAAAAB0AAAAHgAAAN98EABwAAAAfQAAAB8AAAAFdBAAaAAAAHwBAAAbAAAABXQQAGgAAACBAQAAFQAAAAV0EABoAAAAmAEAAAkAAAAFdBAAaAAAAKABAAAXAAAABXQQAGgAAACxAQAAGwAAAAV0EABoAAAA1QEAAAUAAAAFdBAAaAAAAOkBAAAPAAAABXQQAGgAAAAOAgAAHQAAAAV0EABoAAAAIAIAABwAAAAFdBAAaAAAACECAAAXAAAABXQQAGgAAABBAgAAHgAAAAV0EABoAAAAQAIAAAUAAAAFdBAAaAAAAEYCAAAFAAAABXQQAGgAAACAAgAAGQAAAAV0EABoAAAAggIAAAcAAAAFdBAAaAAAAIwCAAAIAAAAAQIDBAAFEQYQBwgJCgsMDQ4PAAAFdBAAaAAAACoDAAAHAAAAAgICAwICAgQCAgIDAgICBAAEAwIABAMBAAQDAgAEAwUFdBAAaAAAAEIDAAAFAAAABXQQAGgAAABHAwAABwAAAAV0EABoAAAAqwMAAEcAAAAFdBAAaAAAAMoDAAALAAAABXQQAGgAAADmAwAANwAAAAV0EABoAAAA/QMAAAsAAAABAAIABQACAAkAAgANAAIAEQADABkAAwAhAAMAKQADADEABABBAAQAUQAEAGEABABxAAUAkQAFALEABQDRAAUA8QAGADEBBgBxAQcA8QEIAPECCQDxBAoA8QgLAPEQDADxIA0A8UAYAAV0EABoAAAAIQQAAA8AAAAFdBAAaAAAAEwEAAAUAAAABXQQAGgAAABSBAAADgAAAAV0EABoAAAAnAQAAAcAAAAFdBAAaAAAAFIFAAAPAAAABXQQAGgAAABYBQAADwAAAAV0EABoAAAAbgUAAA8AAAAFdBAAaAAAAJ4FAAA3AAAAAQAAAAV0EABoAAAAnwUAADcAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlBXQQAGgAAACgBQAACgAAAAV0EABoAAAAwQUAABgAAAAFdBAAaAAAAMoFAAAdAAAABXQQAGgAAADMBQAAFwAAAAV0EABoAAAAzwUAABkAAAAFdBAAaAAAANkFAAAuAAAABXQQAGgAAAD+BQAAGQAAAAV0EABoAAAACwYAAAcAAAAFdBAAaAAAAAEGAAAQAAAABXQQAGgAAAADBgAAEAAAAAV0EABoAAAABQYAABAAAAAFdBAAaAAAAAcGAAAQAAAABXQQAGgAAAAZBgAAEQAAAAV0EABoAAAAHAYAABsAAAAFdBAAaAAAAB4GAAAcAAAABXQQAGgAAAB1BgAAGAAAAAV0EABoAAAArwYAAA8AAAAFdBAAaAAAALEGAAAFAAAABXQQAGgAAADQBgAASQAAAAV0EABoAAAA0gYAABcAAAAFdBAAaAAAANIGAABMAAAABXQQAGgAAADuBgAAJQAAAAV0EABoAAAAMAcAAAcAAAAFdBAAaAAAACwHAAAQAAAABXQQAGgAAABFBwAABQAAAAV0EABoAAAARgcAAAUAAAAFdBAAaAAAAEkHAAAHAAAABXQQAGgAAABJBwAAXAAAAAV0EABoAAAAXQcAABwAAAAFdBAAaAAAAPEHAAAbAAAABXQQAGgAAAD2BwAAGQAAAAAAAgAAAAAAAAADAAAAAAEAAAQAAAAAAgAABQAAAAADAAAGAAAAAAMAAAcAAAAAAwAACAAAAAADAAAJAAAAAAMBAAIAAAAAAAEAAwAAAAABAQAEAAAAAAIBAAUAAAAAAwEABgAAAAADAQAHAAAAAAMBAAgAAAAAAwEACQAAAAADAgACAAAAAAACAAMAAAAAAQIABAAAAAACAgAFAAAAAAMCAAYAAAAAAwIABwAAAAADAgAIAAAAAAMCAAkAAAAAAwMAAgAAAAAAAwADAAAAAAEDAAQAAAAAAgMABQAAAAADAwAGAAAAAAMDAAcAAAAAAwMACAAAAAADAwAJAAAAAAMEAAIAAAAAAAQAAwAAAAABBAAEAAAAAAIEAAUAAAAAAwQABgAAAAADBAAHAAAAAAMEAAgAAAAAAwQACQAAAAADBQACAAAAAAAFAAMAAAAAAQUABAAAAAACBQAFAAAAAAMFAAYAAAAAAwUABwAAAAADBQAIAAAAAAMFAAkAAAAAAwYAAgABAAAABgADAAEAAAEGAAQAAQAAAgYABQABAAADBgAGAAEAAAMGAAcAAQAAAwYACAABAAADBgAJAAEAAAMIAAIAAQAAAAgAAwABAAABCAAEAAEAAAIIAAUAAQAAAwgABgABAAADCAAHAAEAAAMIAAgAAQAAAwgACQABAAADAAAKAAABAAMAAAwAAAEAAwAADgAAAgADAAASAAACAAMAABYAAAMAAwAAHgAAAwADAAAmAAAEAAMAADYAAAQAAwEACgAAAQADAQAMAAABAAMBAA4AAAIAAwEAEgAAAgADAQAWAAADAAMBAB4AAAMAAwEAJgAABAADAQA2AAAEAAMCAAoAAAEAAwIADAAAAQADAgAOAAACAAMCABIAAAIAAwIAFgAAAwADAgAeAAADAAMCACYAAAQAAwIANgAABAADAwAKAAABAAMDAAwAAAEAAwMADgAAAgADAwASAAACAAMDABYAAAMAAwMAHgAAAwADAwAmAAAEAAMDADYAAAQAAwQACgAAAQADBAAMAAABAAMEAA4AAAIAAwQAEgAAAgADBAAWAAADAAMEAB4AAAMAAwQAJgAABAADBAA2AAAEAAMFAAoAAAEAAwUADAAAAQADBQAOAAACAAMFABIAAAIAAwUAFgAAAwADBQAeAAADAAMFACYAAAQAAwUANgAABAADBgAKAAEBAAMGAAwAAQEAAwYADgABAgADBgASAAECAAMGABYAAQMAAwYAHgABAwADBgAmAAEEAAMGADYAAQQAAwgACgABAQADCAAMAAEBAAMIAA4AAQIAAwgAEgABAgADCAAWAAEDAAMIAB4AAQMAAwgAJgABBAADCAA2AAEEAAMAAAIAAAD/AAAAAwAAAP8BAAAEAAAA/wIAAAUAAAD/AwAABgAAAP8DAAAHAAAA/wMAAAgAAAD/AwAACQAAAP8DAQACAAAA/wABAAMAAAD/AQEABAAAAP8CAQAFAAAA/wMBAAYAAAD/AwEABwAAAP8DAQAIAAAA/wMBAAkAAAD/AwIAAgAAAP8AAgADAAAA/wECAAQAAAD/AgIABQAAAP8DAgAGAAAA/wMCAAcAAAD/AwIACAAAAP8DAgAJAAAA/wMDAAIAAAD/AAMAAwAAAP8BAwAEAAAA/wIDAAUAAAD/AwMABgAAAP8DAwAHAAAA/wMDAAgAAAD/AwMACQAAAP8DBAACAAAA/wAEAAMAAAD/AQQABAAAAP8CBAAFAAAA/wMEAAYAAAD/AwQABwAAAP8DBAAIAAAA/wMEAAkAAAD/AwUAAgAAAP8ABQADAAAA/wEFAAQAAAD/AgUABQAAAP8DBQAGAAAA/wMFAAcAAAD/AwUACAAAAP8DBQAJAAAA/wMGAAIAAQD/AAYAAwABAP8BBgAEAAEA/wIGAAUAAQD/AwYABgABAP8DBgAHAAEA/wMGAAgAAQD/AwYACQABAP8DCAACAAEA/wAIAAMAAQD/AQgABAABAP8CCAAFAAEA/wMIAAYAAQD/AwgABwABAP8DCAAIAAEA/wMIAAkAAQD/AwAACgAAAf8DAAAMAAAB/wMAAA4AAAL/AwAAEgAAAv8DAAAWAAAD/wMAAB4AAAP/AwAAJgAABP8DAAA2AAAE/wMBAAoAAAH/AwEADAAAAf8DAQAOAAAC/wMBABIAAAL/AwEAFgAAA/8DAQAeAAAD/wMBACYAAAT/AwEANgAABP8DAgAKAAAB/wMCAAwAAAH/AwIADgAAAv8DAgASAAAC/wMCABYAAAP/AwIAHgAAA/8DAgAmAAAE/wMCADYAAAT/AwMACgAAAf8DAwAMAAAB/wMDAA4AAAL/AwMAEgAAAv8DAwAWAAAD/wMDAB4AAAP/AwMAJgAABP8DAwA2AAAE/wMEAAoAAAH/AwQADAAAAf8DBAAOAAAC/wMEABIAAAL/AwQAFgAAA/8DBAAeAAAD/wMEACYAAAT/AwQANgAABP8DBQAKAAAB/wMFAAwAAAH/AwUADgAAAv8DBQASAAAC/wMFABYAAAP/AwUAHgAAA/8DBQAmAAAE/wMFADYAAAT/AwYACgABAf8DBgAMAAEB/wMGAA4AAQL/AwYAEgABAv8DBgAWAAED/wMGAB4AAQP/AwYAJgABBP8DBgA2AAEE/wMIAAoAAQH/AwgADAABAf8DCAAOAAEC/wMIABIAAQL/AwgAFgABA/8DCAAeAAED/wMIACYAAQT/AwgANgABBP8DCgACAAIA/wAKAAMAAgD/AQoABAACAP8CCgAFAAIA/wMKAAYAAgD/AwoABwACAP8DCgAIAAIA/wMKAAkAAgD/Aw4AAgACAP8ADgADAAIA/wEOAAQAAgD/Ag4ABQACAP8DDgAGAAIA/wMOAAcAAgD/Aw4ACAACAP8DDgAJAAIA/wMSAAIAAwD/ABIAAwADAP8BEgAEAAMA/wISAAUAAwD/AxIABgADAP8DEgAHAAMA/wMSAAgAAwD/AxIACQADAP8DGgACAAMA/wAaAAMAAwD/ARoABAADAP8CGgAFAAMA/wMaAAYAAwD/AxoABwADAP8DGgAIAAMA/wMaAAkAAwD/AyIAAgAEAP8AIgADAAQA/wEiAAQABAD/AiIABQAEAP8DIgAGAAQA/wMiAAcABAD/AyIACAAEAP8DIgAJAAQA/wMyAAIABAD/ADIAAwAEAP8BMgAEAAQA/wIyAAUABAD/AzIABgAEAP8DMgAHAAQA/wMyAAgABAD/AzIACQAEAP8DQgACAAUA/wBCAAMABQD/AUIABAAFAP8CQgAFAAUA/wNCAAYABQD/A0IABwAFAP8DQgAIAAUA/wNCAAkABQD/A2IAAgAFAP8AYgADAAUA/wFiAAQABQD/AmIABQAFAP8DYgAGAAUA/wNiAAcABQD/A2IACAAFAP8DYgAJAAUA/wMKAAoAAgH/AwoADAACAf8DCgAOAAIC/wMKABIAAgL/AwoAFgACA/8DCgAeAAID/wMKACYAAgT/AwoANgACBP8DDgAKAAIB/wMOAAwAAgH/Aw4ADgACAv8DDgASAAIC/wMOABYAAgP/Aw4AHgACA/8DDgAmAAIE/wMOADYAAgT/AxIACgADAf8DEgAMAAMB/wMSAA4AAwL/AxIAEgADAv8DEgAWAAMD/wMSAB4AAwP/AxIAJgADBP8DEgA2AAME/wMaAAoAAwH/AxoADAADAf8DGgAOAAMC/wMaABIAAwL/AxoAFgADA/8DGgAeAAMD/wMaACYAAwT/AxoANgADBP8DIgAKAAQB/wMiAAwABAH/AyIADgAEAv8DIgASAAQC/wMiABYABAP/AyIAHgAEA/8DIgAmAAQE/wMiADYABAT/AzIACgAEAf8DMgAMAAQB/wMyAA4ABAL/AzIAEgAEAv8DMgAWAAQD/wMyAB4ABAP/AzIAJgAEBP8DMgA2AAQE/wNCAAoABQH/A0IADAAFAf8DQgAOAAUC/wNCABIABQL/A0IAFgAFA/8DQgAeAAUD/wNCACYABQT/A0IANgAFBP8DYgAKAAUB/wNiAAwABQH/A2IADgAFAv8DYgASAAUC/wNiABYABQP/A2IAHgAFA/8DYgAmAAUE/wNiADYABQT/AwAARgAABf8DAABmAAAF/wMAAIYAAAb/AwAAxgAAB/8DAABGAQAI/wMAAEYCAAn/AwAARgQACv8DAABGCAAY/wMBAEYAAAX/AwEAZgAABf8DAQCGAAAG/wMBAMYAAAf/AwEARgEACP8DAQBGAgAJ/wMBAEYEAAr/AwEARggAGP8DAgBGAAAF/wMCAGYAAAX/AwIAhgAABv8DAgDGAAAH/wMCAEYBAAj/AwIARgIACf8DAgBGBAAK/wMCAEYIABj/AwMARgAABf8DAwBmAAAF/wMDAIYAAAb/AwMAxgAAB/8DAwBGAQAI/wMDAEYCAAn/AwMARgQACv8DAwBGCAAY/wMEAEYAAAX/AwQAZgAABf8DBACGAAAG/wMEAMYAAAf/AwQARgEACP8DBABGAgAJ/wMEAEYEAAr/AwQARggAGP8DBQBGAAAF/wMFAGYAAAX/AwUAhgAABv8DBQDGAAAH/wMFAEYBAAj/AwUARgIACf8DBQBGBAAK/wMFAEYIABj/AwYARgABBf8DBgBmAAEF/wMGAIYAAQb/AwYAxgABB/8DBgBGAQEI/wMGAEYCAQn/AwYARgQBCv8DBgBGCAEY/wMIAEYAAQX/AwgAZgABBf8DCACGAAEG/wMIAMYAAQf/AwgARgEBCP8DCABGAgEJ/wMIAEYEAQr/AwgARggBGP8DggACAAYA/wCCAAMABgD/AYIABAAGAP8CggAFAAYA/wOCAAYABgD/A4IABwAGAP8DggAIAAYA/wOCAAkABgD/A8IAAgAHAP8AwgADAAcA/wHCAAQABwD/AsIABQAHAP8DwgAGAAcA/wPCAAcABwD/A8IACAAHAP8DwgAJAAcA/wNCAQIACAD/AEIBAwAIAP8BQgEEAAgA/wJCAQUACAD/A0IBBgAIAP8DQgEHAAgA/wNCAQgACAD/A0IBCQAIAP8DQgICAAkA/wBCAgMACQD/AUICBAAJAP8CQgIFAAkA/wNCAgYACQD/A0ICBwAJAP8DQgIIAAkA/wNCAgkACQD/A0IEAgAKAP8AQgQDAAoA/wFCBAQACgD/AkIEBQAKAP8DQgQGAAoA/wNCBAcACgD/A0IECAAKAP8DQgQJAAoA/wNCCAIADAD/AEIIAwAMAP8BQggEAAwA/wJCCAUADAD/A0IIBgAMAP8DQggHAAwA/wNCCAgADAD/A0IICQAMAP8DQhgCAA4A/wBCGAMADgD/AUIYBAAOAP8CQhgFAA4A/wNCGAYADgD/A0IYBwAOAP8DQhgIAA4A/wNCGAkADgD/A0JYAgAYAP8AQlgDABgA/wFCWAQAGAD/AkJYBQAYAP8DQlgGABgA/wNCWAcAGAD/A0JYCAAYAP8DQlgJABgA/wMKAEYAAgX/AwoAZgACBf8DCgCGAAIG/wMKAMYAAgf/AwoARgECCP8DCgBGAgIJ/wMKAEYEAgr/AwoARggCGP8DDgBGAAIF/wMOAGYAAgX/Aw4AhgACBv8DDgDGAAIH/wMOAEYBAgj/Aw4ARgICCf8DDgBGBAIK/wMOAEYIAhj/AxIARgADBf8DEgBmAAMF/wMSAIYAAwb/AxIAxgADB/8DEgBGAQMI/wMSAEYCAwn/AxIARgQDCv8DEgBGCAMY/wMaAEYAAwX/AxoAZgADBf8DGgCGAAMG/wMaAMYAAwf/AxoARgEDCP8DGgBGAgMJ/wMaAEYEAwr/AxoARggDGP8DIgBGAAQF/wMiAGYABAX/AyIAhgAEBv8DIgDGAAQH/wMiAEYBBAj/AyIARgIECf8DIgBGBAQK/wMiAEYIBBj/AzIARgAEBf8DMgBmAAQF/wMyAIYABAb/AzIAxgAEB/8DMgBGAQQI/wMyAEYCBAn/AzIARgQECv8DMgBGCAQY/wNCAEYABQX/A0IAZgAFBf8DQgCGAAUG/wNCAMYABQf/A0IARgEFCP8DQgBGAgUJ/wNCAEYEBQr/A0IARggFGP8DYgBGAAUF/wNiAGYABQX/A2IAhgAFBv8DYgDGAAUH/wNiAEYBBQj/A2IARgIFCf8DYgBGBAUK/wNiAEYIBRj/A4IACgAGAf8DggAMAAYB/wOCAA4ABgL/A4IAEgAGAv8DggAWAAYD/wOCAB4ABgP/A4IAJgAGBP8DggA2AAYE/wPCAAoABwH/A8IADAAHAf8DwgAOAAcC/wPCABIABwL/A8IAFgAHA/8DwgAeAAcD/wPCACYABwT/A8IANgAHBP8DQgEKAAgB/wNCAQwACAH/A0IBDgAIAv8DQgESAAgC/wNCARYACAP/A0IBHgAIA/8DQgEmAAgE/wNCATYACAT/A0ICCgAJAf8DQgIMAAkB/wNCAg4ACQL/A0ICEgAJAv8DQgIWAAkD/wNCAh4ACQP/A0ICJgAJBP8DQgI2AAkE/wNCBAoACgH/A0IEDAAKAf8DQgQOAAoC/wNCBBIACgL/A0IEFgAKA/8DQgQeAAoD/wNCBCYACgT/A0IENgAKBP8DQggKAAwB/wNCCAwADAH/A0IIDgAMAv8DQggSAAwC/wNCCBYADAP/A0IIHgAMA/8DQggmAAwE/wNCCDYADAT/A0IYCgAOAf8DQhgMAA4B/wNCGA4ADgL/A0IYEgAOAv8DQhgWAA4D/wNCGB4ADgP/A0IYJgAOBP8DQhg2AA4E/wNCWAoAGAH/A0JYDAAYAf8DQlgOABgC/wNCWBIAGAL/A0JYFgAYA/8DQlgeABgD/wNCWCYAGAT/A0JYNgAYBP8DggBGAAYF/wOCAGYABgX/A4IAhgAGBv8DggDGAAYH/wOCAEYBBgj/A4IARgIGCf8DggBGBAYK/wOCAEYIBhj/A8IARgAHBf8DwgBmAAcF/wPCAIYABwb/A8IAxgAHB/8DwgBGAQcI/wPCAEYCBwn/A8IARgQHCv8DwgBGCAcY/wNCAUYACAX/A0IBZgAIBf8DQgGGAAgG/wNCAcYACAf/A0IBRgEICP8DQgFGAggJ/wNCAUYECAr/A0IBRggIGP8DQgJGAAkF/wNCAmYACQX/A0IChgAJBv8DQgLGAAkH/wNCAkYBCQj/A0ICRgIJCf8DQgJGBAkK/wNCAkYICRj/A0IERgAKBf8DQgRmAAoF/wNCBIYACgb/A0IExgAKB/8DQgRGAQoI/wNCBEYCCgn/A0IERgQKCv8DQgRGCAoY/wNCCEYADAX/A0IIZgAMBf8DQgiGAAwG/wNCCMYADAf/A0IIRgEMCP8DQghGAgwJ/wNCCEYEDAr/A0IIRggMGP8DQhhGAA4F/wNCGGYADgX/A0IYhgAOBv8DQhjGAA4H/wNCGEYBDgj/A0IYRgIOCf8DQhhGBA4K/wNCGEYIDhj/A0JYRgAYBf8DQlhmABgF/wNCWIYAGAb/A0JYxgAYB/8DQlhGARgI/wNCWEYCGAn/A0JYRgQYCv8DQlhGCBgY/wMFdBAAaAAAAP0HAAAHAAAABXQQAGgAAAAACAAAGAAAAAV0EABoAAAAPAgAACAAAAAFdBAAaAAAAD0IAAADAAAABXQQAGgAAABKCAAAGwAAAAV0EABoAAAASwgAABUAAAAFdBAAaAAAAEwIAAAFAAAABXQQAGgAAABGCAAAGwAAAAV0EABoAAAARwgAABUAAAAFdBAAaAAAAEgIAAAFAAAABXQQAGgAAAAtCQAAGgAAAAV0EABoAAAALgkAABoAAAAFdBAAaAAAAFcJAAAZAAAABXQQAGgAAABmCQAADwAAAAV0EABoAAAABAkAABEAAAAFdBAAaAAAAA0JAAARAEH51fMAC8vXBxAAAAAkAAAAVAAAAIwAAACsAAAA0AAAAPgAAAAkAQAAVAEAAG4BAACKAQAAmQEAAKEBAICpAQCAuwEAAMUBAADPAQBA1AEAwNkBAKDcAQAAAAAACgoLCwoKCgoKCQkIBwcIBwcGBgUFAAAABXQQAGgAAAC+CQAAHAAAAAV0EABoAAAAwAkAABMAAAAFdBAAaAAAAMMJAAAxAAAABXQQAGgAAAAVCgAADwAAAAV0EABoAAAAFAoAAA0AAAAFdBAAaAAAAF8KAAARAAAABXQQAGgAAACQCgAABwAAAAV0EABoAAAAkQoAABsAAAAFdBAAaAAAAHgLAAAmAAAABXQQAGgAAAB/CwAACwAAAAV0EABoAAAAgQsAAA4AAAAFdBAAaAAAAI0LAAAfAAAABXQQAGgAAAC5CwAALgAAAAV0EABoAAAAxQsAAAsAAAAFdBAAaAAAANUKAABDAAAABXQQAGgAAADVCgAAEQAAAAV0EABoAAAAuwoAACAAAAAFdBAAaAAAALwKAAARAAAABXQQAGgAAAC/CgAAHAAAAAV0EABoAAAAvwoAABEAAAA6hhAAcAAAAC4CAAARAAAAWFIQAGsAAADRAgAABwAAAFhSEABrAAAA3QIAAAMAAABYUhAAawAAANkCAAAFAAAAAAAAAAABAQABAAwAAAoBAAAJAQAAFAABAAAPAAoAAAAZAA0AAAEAAwABAAADAQoBAAAfAAAmDAABAAAkAAAXAAArAAAuAAMAAAAzAAA1AA4AAAIAAAA7AAA/AQoAAAAwFwAAAQADAA8AAABIAABGAABPAABWABAAABEACQAAAAQAAABdAAsAAABkAABpAABuAAcAAAFzAAB4AAB7AQAwAAB9ABQAABIAAAYAAABbAAoDAAgAAACEAACJCQAPAAUAAAkAAQoDAAokFwBbAAsBAAorAACBAQAXkgAACQAGAApGAACYAACNFwABAApbAAoXAACgAQCBAACmAQsBAACqAQsAAACPAAskAAowAQBbAACuAQowAACzAAC4AAtGAAC+AQoXAAsrAQCPAAqNAADDAAsXyAAAAQCNAAqBAAuBAADLAAsDAAqPAQqNAQuBAQsDAAuNAAtbAAswAQsXAAuPAQswAQqBAQuPAQqPAFhSEABrAAAA6QIAAB4AAAAAIAAsIAAgb2YgdGhlIAAgb2YgAHMgAC4AIGFuZCAAIGluIAAiACB0byAAIj4ACgAuIABdACBmb3IgACBhIAAgdGhhdCAAJwAgd2l0aCAAIGZyb20gACBieSAAKAAuIFRoZSAAIG9uIAAgYXMgACBpcyAAaW5nIAAKCQA6AGVkIAA9IgAgYXQgAGx5IAAsAD0nAC5jb20vAC4gVGhpcyAAIG5vdCAAZXIgAGFsIABmdWwgAGl2ZSAAbGVzcyAAZXN0IABpemUgAMKgAG91cyAAWFIQAGsAAADpAgAACAAAAFhSEABrAAAA6gIAAAwAAABYUhAAawAAAPoCAAAMAAAAWFIQAGsAAAAEAwAAGgAAAFhSEABrAAAACgMAACUAAABYUhAAawAAABIDAAAIAAAAWFIQAGsAAAAUAwAADAAAAFhSEABrAAAAFQMAAAcAAABYUhAAawAAAAADAAAoAAAAWFIQAGsAAAAAAwAABwAAAFhSEABrAAAA6wIAAAcAAAAYfxAAbQAAAG4AAAAYAAAAGH8QAG0AAABuAAAACwAAAACAQMAgoGDgEJBQ0DCwcPAIiEjIKKho6BiYWNg4uHj4BIRExCSkZOQUlFTUNLR09AyMTMwsrGzsHJxc3Dy8fPwCgkLCIqJi4hKSUtIysnLyCopKyiqqauoamlraOrp6+gaGRsYmpmbmFpZW1ja2dvYOjk7OLq5u7h6eXt4+vn7+AYFBwSGhYeERkVHRMbFx8QmJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5RWVVdU1tXX1DY1NzS2tbe0dnV3dPb19/QODQ8Mjo2PjE5NT0zOzc/MLi0vLK6tr6xubW9s7u3v7B4dHxyenZ+cXl1fXN7d39w+PT88vr2/vH59f3z+/f/8YfxAAbQAAAKAAAAADAAAAGH8QAG0AAACsAAAABQAAABh/EABtAAAAuQAAAA0AAAAYfxAAbQAAAO4AAAAQAAAAGH8QAG0AAAD/AAAAHwAAABh/EABtAAAAAgEAABQAAAAYfxAAbQAAAN0AAAAiAAAAGH8QAG0AAADdAAAAEwAAABh/EABtAAAA3wAAAAcAAAAYfxAAbQAAANEAAAAPAAAAYXNzZXJ0aW9uIGZhaWxlZDogcm9vdF9iaXRzIGFzIGlzaXplIDw9IEJST1RMSV9SRVZFUlNFX0JJVFNfTUFYIGFzIGlzaXplGH8QAG0AAAAdAQAAAwAAAGFzc2VydGlvbiBmYWlsZWQ6IEJST1RMSV9IVUZGTUFOX01BWF9DT0RFX0xFTkdUSCBhcyBpc2l6ZSAtIHJvb3RfYml0cyBhcyBpc2l6ZSA8PQogICAgQlJPVExJX1JFVkVSU0VfQklUU19NQVggYXMgaXNpemUAABh/EABtAAAAHgEAAAMAAAAYfxAAbQAAACEBAAAJAAAAGH8QAG0AAAA6AQAAHwAAABh/EABtAAAAZAEAAAsAAAAYfxAAbQAAAGwBAAAJAAAAGH8QAG0AAABzAQAACQAAABh/EABtAAAAVQEAAAkAAAAYfxAAbQAAAFQBAAAHAAAAGH8QAG0AAAA9AQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9zeW1ib2xzIDw9IDQAABh/EABtAAAAjQEAAAMAAAAYfxAAbQAAAI8BAAAFAAAAGH8QAG0AAACQAQAAIwAAABh/EABtAAAAkgEAAAUAAAAYfxAAbQAAAJMBAAAFAAAAGH8QAG0AAACUAQAACAAAABh/EABtAAAAnQEAAAUAAAAYfxAAbQAAAJ4BAAAjAAAAGH8QAG0AAACfAQAABQAAABh/EABtAAAAoQEAAAgAAAAYfxAAbQAAAKYBAAAHAAAAGH8QAG0AAACjAQAABwAAABh/EABtAAAArQEAAB8AAAAYfxAAbQAAAK0BAAAwAAAAGH8QAG0AAACtAQAAQQAAABh/EABtAAAAtgEAAAcAAAAYfxAAbQAAAL4BAAAfAAAAGH8QAG0AAAC+AQAAMAAAABh/EABtAAAAvgEAAEEAAAAYfxAAbQAAAL4BAABSAAAAGH8QAG0AAADJAQAABQAAABh/EABtAAAA0gEAADsAAAAYfxAAbQAAANIBAAAHAAAAGH8QAG0AAADDAQAABwAAAHRpbWVkb3dubGlmZWxlZnRiYWNrY29kZWRhdGFzaG93b25seXNpdGVjaXR5b3Blbmp1c3RsaWtlZnJlZXdvcmt0ZXh0eWVhcm92ZXJib2R5bG92ZWZvcm1ib29rcGxheWxpdmVsaW5laGVscGhvbWVzaWRlbW9yZXdvcmRsb25ndGhlbXZpZXdmaW5kcGFnZWRheXNmdWxsaGVhZHRlcm1lYWNoYXJlYWZyb210cnVlbWFya2FibGV1cG9uaGlnaGRhdGVsYW5kbmV3c2V2ZW5uZXh0Y2FzZWJvdGhwb3N0dXNlZG1hZGVoYW5kaGVyZXdoYXRuYW1lTGlua2Jsb2dzaXplYmFzZWhlbGRtYWtlbWFpbnVzZXInKSAraG9sZGVuZHN3aXRoTmV3c3JlYWR3ZXJlc2lnbnRha2VoYXZlZ2FtZXNlZW5jYWxscGF0aHdlbGxwbHVzbWVudWZpbG1wYXJ0am9pbnRoaXNsaXN0Z29vZG5lZWR3YXlzd2VzdGpvYnNtaW5kYWxzb2xvZ29yaWNodXNlc2xhc3R0ZWFtYXJteWZvb2RraW5nd2lsbGVhc3R3YXJkYmVzdGZpcmVQYWdla25vd2F3YXkucG5nbW92ZXRoYW5sb2FkZ2l2ZXNlbGZub3RlbXVjaGZlZWRtYW55cm9ja2ljb25vbmNlbG9va2hpZGVkaWVkSG9tZXJ1bGVob3N0YWpheGluZm9jbHVibGF3c2xlc3NoYWxmc29tZXN1Y2h6b25lMTAwJW9uZXNjYXJlVGltZXJhY2VibHVlZm91cndlZWtmYWNlaG9wZWdhdmVoYXJkbG9zdHdoZW5wYXJra2VwdHBhc3NzaGlwcm9vbUhUTUxwbGFuVHlwZWRvbmVzYXZla2VlcGZsYWdsaW5rc29sZGZpdmV0b29rcmF0ZXRvd25qdW1wdGh1c2RhcmtjYXJkZmlsZWZlYXJzdGF5a2lsbHRoYXRmYWxsYXV0b2V2ZXIuY29tdGFsa3Nob3B2b3RlZGVlcG1vZGVyZXN0dHVybmJvcm5iYW5kZmVsbHJvc2V1cmwoc2tpbnJvbGVjb21lYWN0c2FnZXNtZWV0Z29sZC5qcGdpdGVtdmFyeWZlbHR0aGVuc2VuZGRyb3BWaWV3Y29weTEuMCI8L2E+c3RvcGVsc2VsaWVzdG91cnBhY2suZ2lmcGFzdGNzcz9ncmF5bWVhbiZndDtyaWRlc2hvdGxhdGVzYWlkcm9hZHZhciBmZWVsam9obnJpY2twb3J0ZmFzdCdVQS1kZWFkPC9iPnBvb3JiaWxsdHlwZVUuUy53b29kbXVzdDJweDtJbmZvcmFua3dpZGV3YW50d2FsbGxlYWRbMF07cGF1bHdhdmVzdXJlJCgnI3dhaXRtYXNzYXJtc2dvZXNnYWlubGFuZ3BhaWQhLS0gbG9ja3VuaXRyb290d2Fsa2Zpcm13aWZleG1sInNvbmd0ZXN0MjBweGtpbmRyb3dzdG9vbGZvbnRtYWlsc2FmZXN0YXJtYXBzY29yZXJhaW5mbG93YmFieXNwYW5zYXlzNHB4OzZweDthcnRzZm9vdHJlYWx3aWtpaGVhdHN0ZXB0cmlwb3JnL2xha2V3ZWFrdG9sZEZvcm1jYXN0ZmFuc2Jhbmt2ZXJ5cnVuc2p1bHl0YXNrMXB4O2dvYWxncmV3c2xvd2VkZ2VpZD0ic2V0czVweDsuanM/NDBweGlmIChzb29uc2VhdG5vbmV0dWJlemVyb3NlbnRyZWVkZmFjdGludG9naWZ0aGFybTE4cHhjYW1laGlsbGJvbGR6b29tdm9pZGVhc3lyaW5nZmlsbHBlYWtpbml0Y29zdDNweDtqYWNrdGFnc2JpdHNyb2xsZWRpdGtuZXduZWFyPCEtLWdyb3dKU09OZHV0eU5hbWVzYWxleW91IGxvdHNwYWluamF6emNvbGRleWVzZmlzaHd3dy5yaXNrdGFic3ByZXYxMHB4cmlzZTI1cHhCbHVlZGluZzMwMCxiYWxsZm9yZGVhcm53aWxkYm94LmZhaXJsYWNrdmVyc3BhaXJqdW5ldGVjaGlmKCFwaWNrZXZpbCQoIiN3YXJtbG9yZGRvZXNwdWxsLDAwMGlkZWFkcmF3aHVnZXNwb3RmdW5kYnVybmhyZWZjZWxsa2V5c3RpY2tob3VybG9zc2Z1ZWwxMnB4c3VpdGRlYWxSU1MiYWdlZGdyZXlHRVQiZWFzZWFpbXNnaXJsYWlkczhweDtuYXZ5Z3JpZHRpcHMjOTk5d2Fyc2xhZHljYXJzKTsgfXBocD9oZWxsdGFsbHdob216aDrlKi8NCiAxMDBoYWxsLgoKQTdweDtwdXNoY2hhdDBweDtjcmV3Ki88L2hhc2g3NXB4ZmxhdHJhcmUgJiYgdGVsbGNhbXBvbnRvbGFpZG1pc3Nza2lwdGVudGZpbmVtYWxlZ2V0c3Bsb3Q0MDAsDQoNCmNvb2xmZWV0LnBocDxicj5lcmljbW9zdGd1aWRiZWxsZGVzY2hhaXJtYXRoYXRvbS9pbWcmIzgybHVja2NlbnQwMDA7dGlueWdvbmVodG1sc2VsbGRydWdGUkVFbm9kZW5pY2s/aWQ9bG9zZW51bGx2YXN0d2luZFJTUyB3ZWFycmVseWJlZW5zYW1lZHVrZW5hc2FjYXBld2lzaGd1bGZUMjM6aGl0c3Nsb3RnYXRla2lja2JsdXJ0aGV5MTVweCcnKTspOyI+bXNpZXdpbnNiaXJkc29ydGJldGFzZWVrVDE4Om9yZHN0cmVlbWFsbDYwcHhmYXJt4oCZc2JveXNbMF0uJyk7IlBPU1RiZWFya2lkcyk7fX1tYXJ5dGVuZChVSylxdWFkemg65i1zaXotLS0tcHJvcCcpOw1saWZ0VDE5OnZpY2VhbmR5ZGVidD5SU1Nwb29sbmVja2Jsb3dUMTY6ZG9vcmV2YWxUMTc6bGV0c2ZhaWxvcmFscG9sbG5vdmFjb2xzZ2VuZSDigJRzb2Z0cm9tZXRpbGxyb3NzPGgzPnBvdXJmYWRlcGluazx0cj5taW5pKXwhKG1pbmV6aDroYmFyc2hlYXIwMCk7bWlsayAtLT5pcm9uZnJlZGRpc2t3ZW50c29pbHB1dHMvanMvaG9seVQyMjpJU0JOVDIwOmFkYW1zZWVzPGgyPmpzb24nLCAnY29udFQyMTogUlNTbG9vcGFzaWFtb29uPC9wPnNvdWxMSU5FZm9ydGNhcnRUMTQ6PGgxPjgwcHghLS08OXB4O1QwNDptaWtlOjQ2Wm5pY2VpbmNoWW9ya3JpY2V6aDrkJykpO3B1cmVtYWdlcGFyYXRvbmVib25kOjM3Wl9vZl8nXSk7MDAwLHpoOud0YW5reWFyZGJvd2xidXNoOjU2WkphdmEzMHB4Cnx9CiVDMyU6MzRaamVmZkVYUEljYXNodmlzYWdvbGZzbm93emg66XF1ZXIuY3Nzc2lja21lYXRtaW4uYmluZGRlbGxoaXJlcGljc3JlbnQ6MzZaSFRUUC0yMDFmb3Rvd29sZkVORCB4Ym94OjU0WkJPRFlkaWNrOwp9CmV4aXQ6MzVadmFyc2JlYXQnfSk7ZGlldDk5OTthbm5lfX08L1tpXS5MYW5na23CsndpcmV0b3lzYWRkc3NlYWxhbGV4OwoJfWVjaG9uaW5lLm9yZzAwNSl0b255amV3c3NhbmRsZWdzcm9vZjAwMCkgMjAwd2luZWdlYXJkb2dzYm9vdGdhcnljdXRzdHlsZXRlbXB0aW9uLnhtbGNvY2tnYW5nJCgnLjUwcHhQaC5EbWlzY2FsYW5sb2FuZGVza21pbGVyeWFudW5peGRpc2MpO30KZHVzdGNsaXApLgoKNzBweC0yMDBEVkRzN10+PHRhcGVkZW1vaSsrKXdhZ2VldXJvcGhpbG9wdHNob2xlRkFRc2FzaW4tMjZUbGFic3BldHNVUkwgYnVsa2Nvb2s7fQ0KSEVBRFswXSlhYmJyanVhbigxOThsZXNodHdpbjwvaT5zb255Z3V5c2Z1Y2twaXBlfC0KITAwMiluZG93WzFdO1tdOwpMb2cgc2FsdA0KCQliYW5ndHJpbWJhdGgpew0KMDBweAp9KTtrbzrsZmVlc2FkPg1zOi8vIFtdO3RvbGxwbHVnKCl7CnsNCiAuanMnMjAwcGR1YWxib2F0LkpQRyk7Cn1xdW90KTsKCicpOwoNCn0NMjAxNDIwMTUyMDE2MjAxNzIwMTgyMDE5MjAyMDIwMjEyMDIyMjAyMzIwMjQyMDI1MjAyNjIwMjcyMDI4MjAyOTIwMzAyMDMxMjAzMjIwMzMyMDM0MjAzNTIwMzYyMDM3MjAxMzIwMTIyMDExMjAxMDIwMDkyMDA4MjAwNzIwMDYyMDA1MjAwNDIwMDMyMDAyMjAwMTIwMDAxOTk5MTk5ODE5OTcxOTk2MTk5NTE5OTQxOTkzMTk5MjE5OTExOTkwMTk4OTE5ODgxOTg3MTk4NjE5ODUxOTg0MTk4MzE5ODIxOTgxMTk4MDE5NzkxOTc4MTk3NzE5NzYxOTc1MTk3NDE5NzMxOTcyMTk3MTE5NzAxOTY5MTk2ODE5NjcxOTY2MTk2NTE5NjQxOTYzMTk2MjE5NjExOTYwMTk1OTE5NTgxOTU3MTk1NjE5NTUxOTU0MTk1MzE5NTIxOTUxMTk1MDEwMDAxMDI0MTM5NDAwMDA5OTk5Y29tb23DoXNlc3RlZXN0YXBlcm90b2RvaGFjZWNhZGFhw7FvYmllbmTDrWFhc8OtdmlkYWNhc29vdHJvZm9yb3NvbG9vdHJhY3VhbGRpam9zaWRvZ3JhbnRpcG90ZW1hZGViZWFsZ29xdcOpZXN0b25hZGF0cmVzcG9jb2Nhc2FiYWpvdG9kYXNpbm9hZ3VhcHVlc3Vub3NhbnRlZGljZWx1aXNlbGxhbWF5b3pvbmFhbW9ycGlzb29icmFjbGljZWxsb2Rpb3Nob3JhY2FzadC30LDQvdCw0L7QvNGA0LDRgNGD0YLQsNC90LXQv9C+0L7RgtC40LfQvdC+0LTQvtGC0L7QttC10L7QvdC40YXQndCw0LXQtdCx0YvQvNGL0JLRi9GB0L7QstGL0LLQvtCd0L7QvtCx0J/QvtC70LjQvdC40KDQpNCd0LXQnNGL0YLRi9Ce0L3QuNC80LTQsNCX0LDQlNCw0J3Rg9Ce0LHRgtC10JjQt9C10LnQvdGD0LzQvNCi0YvRg9C22YHZitij2YbZhdin2YXYudmD2YTYo9mI2LHYr9mK2KfZgdmJ2YfZiNmE2YXZhNmD2KfZiNmE2YfYqNiz2KfZhNil2YbZh9mK2KPZitmC2K/Zh9mE2KvZhdio2YfZhNmI2YTZitio2YTYp9mK2KjZg9i02YrYp9mF2KPZhdmG2KrYqNmK2YTZhtit2KjZh9mF2YXYtNmI2LRmaXJzdHZpZGVvbGlnaHR3b3JsZG1lZGlhd2hpdGVjbG9zZWJsYWNrcmlnaHRzbWFsbGJvb2tzcGxhY2VtdXNpY2ZpZWxkb3JkZXJwb2ludHZhbHVlbGV2ZWx0YWJsZWJvYXJkaG91c2Vncm91cHdvcmtzeWVhcnNzdGF0ZXRvZGF5d2F0ZXJzdGFydHN0eWxlZGVhdGhwb3dlcnBob25lbmlnaHRlcnJvcmlucHV0YWJvdXR0ZXJtc3RpdGxldG9vbHNldmVudGxvY2FsdGltZXNsYXJnZXdvcmRzZ2FtZXNzaG9ydHNwYWNlZm9jdXNjbGVhcm1vZGVsYmxvY2tndWlkZXJhZGlvc2hhcmV3b21lbmFnYWlubW9uZXlpbWFnZW5hbWVzeW91bmdsaW5lc2xhdGVyY29sb3JncmVlbmZyb250JmFtcDt3YXRjaGZvcmNlcHJpY2VydWxlc2JlZ2luYWZ0ZXJ2aXNpdGlzc3VlYXJlYXNiZWxvd2luZGV4dG90YWxob3Vyc2xhYmVscHJpbnRwcmVzc2J1aWx0bGlua3NzcGVlZHN0dWR5dHJhZGVmb3VuZHNlbnNldW5kZXJzaG93bmZvcm1zcmFuZ2VhZGRlZHN0aWxsbW92ZWR0YWtlbmFib3ZlZmxhc2hmaXhlZG9mdGVub3RoZXJ2aWV3c2NoZWNrbGVnYWxyaXZlcml0ZW1zcXVpY2tzaGFwZWh1bWFuZXhpc3Rnb2luZ21vdmlldGhpcmRiYXNpY3BlYWNlc3RhZ2V3aWR0aGxvZ2luaWRlYXN3cm90ZXBhZ2VzdXNlcnNkcml2ZXN0b3JlYnJlYWtzb3V0aHZvaWNlc2l0ZXNtb250aHdoZXJlYnVpbGR3aGljaGVhcnRoZm9ydW10aHJlZXNwb3J0cGFydHlDbGlja2xvd2VybGl2ZXNjbGFzc2xheWVyZW50cnlzdG9yeXVzYWdlc291bmRjb3VydHlvdXIgYmlydGhwb3B1cHR5cGVzYXBwbHlJbWFnZWJlaW5ndXBwZXJub3Rlc2V2ZXJ5c2hvd3NtZWFuc2V4dHJhbWF0Y2h0cmFja2tub3duZWFybHliZWdhbnN1cGVycGFwZXJub3J0aGxlYXJuZ2l2ZW5uYW1lZGVuZGVkVGVybXNwYXJ0c0dyb3VwYnJhbmR1c2luZ3dvbWFuZmFsc2VyZWFkeWF1ZGlvdGFrZXN3aGlsZS5jb20vbGl2ZWRjYXNlc2RhaWx5Y2hpbGRncmVhdGp1ZGdldGhvc2V1bml0c25ldmVyYnJvYWRjb2FzdGNvdmVyYXBwbGVmaWxlc2N5Y2xlc2NlbmVwbGFuc2NsaWNrd3JpdGVxdWVlbnBpZWNlZW1haWxmcmFtZW9sZGVycGhvdG9saW1pdGNhY2hlY2l2aWxzY2FsZWVudGVydGhlbWV0aGVyZXRvdWNoYm91bmRyb3lhbGFza2Vkd2hvbGVzaW5jZXN0b2NrIG5hbWVmYWl0aGhlYXJ0ZW1wdHlvZmZlcnNjb3Blb3duZWRtaWdodGFsYnVtdGhpbmtibG9vZGFycmF5bWFqb3J0cnVzdGNhbm9udW5pb25jb3VudHZhbGlkc3RvbmVTdHlsZUxvZ2luaGFwcHlvY2N1cmxlZnQ6ZnJlc2hxdWl0ZWZpbG1zZ3JhZGVuZWVkc3VyYmFuZmlnaHRiYXNpc2hvdmVyYXV0bztyb3V0ZS5odG1sbWl4ZWRmaW5hbFlvdXIgc2xpZGV0b3BpY2Jyb3duYWxvbmVkcmF3bnNwbGl0cmVhY2hSaWdodGRhdGVzbWFyY2hxdW90ZWdvb2RzTGlua3Nkb3VidGFzeW5jdGh1bWJhbGxvd2NoaWVmeW91dGhub3ZlbDEwcHg7c2VydmV1bnRpbGhhbmRzQ2hlY2tTcGFjZXF1ZXJ5amFtZXNlcXVhbHR3aWNlMCwwMDBTdGFydHBhbmVsc29uZ3Nyb3VuZGVpZ2h0c2hpZnR3b3J0aHBvc3RzbGVhZHN3ZWVrc2F2b2lkdGhlc2VtaWxlc3BsYW5lc21hcnRhbHBoYXBsYW50bWFya3NyYXRlc3BsYXlzY2xhaW1zYWxlc3RleHRzc3RhcnN3cm9uZzwvaDM+dGhpbmcub3JnL211bHRpaGVhcmRQb3dlcnN0YW5kdG9rZW5zb2xpZCh0aGlzYnJpbmdzaGlwc3N0YWZmdHJpZWRjYWxsc2Z1bGx5ZmFjdHNhZ2VudFRoaXMgLy8tLT5hZG1pbmVneXB0RXZlbnQxNXB4O0VtYWlsdHJ1ZSJjcm9zc3NwZW50YmxvZ3Nib3giPm5vdGVkbGVhdmVjaGluYXNpemVzZ3Vlc3Q8L2g0PnJvYm90aGVhdnl0cnVlLHNldmVuZ3JhbmRjcmltZXNpZ25zYXdhcmVkYW5jZXBoYXNlPjwhLS1lbl9VUyYjMzk7MjAwcHhfbmFtZWxhdGluZW5qb3lhamF4LmF0aW9uc21pdGhVLlMuIGhvbGRzcGV0ZXJpbmRpYW5hdiI+Y2hhaW5zY29yZWNvbWVzZG9pbmdwcmlvclNoYXJlMTk5MHNyb21hbmxpc3RzamFwYW5mYWxsc3RyaWFsb3duZXJhZ3JlZTwvaDI+YWJ1c2VhbGVydG9wZXJhIi0vL1djYXJkc2hpbGxzdGVhbXNQaG90b3RydXRoY2xlYW4ucGhwP3NhaW50bWV0YWxsb3Vpc21lYW50cHJvb2ZicmllZnJvdyI+Z2VucmV0cnVja2xvb2tzVmFsdWVGcmFtZS5uZXQvLS0+Cjx0cnkgewp2YXIgbWFrZXNjb3N0c3BsYWluYWR1bHRxdWVzdHRyYWlubGFib3JoZWxwc2NhdXNlbWFnaWNtb3RvcnRoZWlyMjUwcHhsZWFzdHN0ZXBzQ291bnRjb3VsZGdsYXNzc2lkZXNmdW5kc2hvdGVsYXdhcmRtb3V0aG1vdmVzcGFyaXNnaXZlc2R1dGNodGV4YXNmcnVpdG51bGwsfHxbXTt0b3AiPgo8IS0tUE9TVCJvY2Vhbjxici8+Zmxvb3JzcGVha2RlcHRoIHNpemViYW5rc2NhdGNoY2hhcnQyMHB4O2FsaWduZGVhbHN3b3VsZDUwcHg7dXJsPSJwYXJrc21vdXNlTW9zdCAuLi48L2Ftb25nYnJhaW5ib2R5IG5vbmU7YmFzZWRjYXJyeWRyYWZ0cmVmZXJwYWdlX2hvbWUubWV0ZXJkZWxheWRyZWFtcHJvdmVqb2ludDwvdHI+ZHJ1Z3M8IS0tIGFwcmlsaWRlYWxhbGxlbmV4YWN0Zm9ydGhjb2Rlc2xvZ2ljVmlldyBzZWVtc2JsYW5rcG9ydHMgKDIwMHNhdmVkX2xpbmtnb2Fsc2dyYW50Z3JlZWtob21lc3JpbmdzcmF0ZWQzMHB4O3dob3NlcGFyc2UoKTsiIEJsb2NrbGludXhqb25lc3BpeGVsJyk7Ij4pO2lmKC1sZWZ0ZGF2aWRob3JzZUZvY3VzcmFpc2Vib3hlc1RyYWNrZW1lbnQ8L2VtPmJhciI+LnNyYz10b3dlcmFsdD0iY2FibGVoZW5yeTI0cHg7c2V0dXBpdGFseXNoYXJwbWlub3J0YXN0ZXdhbnRzdGhpcy5yZXNldHdoZWVsZ2lybHMvY3NzLzEwMCU7Y2x1YnNzdHVmZmJpYmxldm90ZXMgMTAwMGtvcmVhfSk7DQpiYW5kc3F1ZXVlPSB7fTs4MHB4O2NraW5new0KCQlhaGVhZGNsb2NraXJpc2hsaWtlIHJhdGlvc3RhdHNGb3JtInlhaG9vKVswXTtBYm91dGZpbmRzPC9oMT5kZWJ1Z3Rhc2tzVVJMID1jZWxsc30pKCk7MTJweDtwcmltZXRlbGxzdHVybnMweDYwMC5qcGcic3BhaW5iZWFjaHRheGVzbWljcm9hbmdlbC0tPjwvZ2lmdHNzdGV2ZS1saW5rYm9keS59KTsKCW1vdW50ICgxOTlGQVE8L3JvZ2VyZnJhbmtDbGFzczI4cHg7ZmVlZHM8aDE+PHNjb3R0dGVzdHMyMnB4O2RyaW5rKSB8fCBsZXdpc3NoYWxsIzAzOTsgZm9yIGxvdmVkd2FzdGUwMHB4O2phOuOCc2ltb248Zm9udHJlcGx5bWVldHN1bnRlcmNoZWFwdGlnaHRCcmFuZCkgIT0gZHJlc3NjbGlwc3Jvb21zb25rZXltb2JpbG1haW4uTmFtZSBwbGF0ZWZ1bm55dHJlZXNjb20vIjEuanBnd21vZGVwYXJhbVNUQVJUbGVmdCBpZGRlbiwgMjAxKTsKfQpmb3JtLnZpcnVzY2hhaXJ0cmFuc3dvcnN0UGFnZXNpdGlvbnBhdGNoPCEtLQpvLWNhY2Zpcm1zdG91cnMsMDAwIGFzaWFuaSsrKXthZG9iZScpWzBdaWQ9MTBib3RoO21lbnUgLjIubWkucG5nImtldmluY29hY2hDaGlsZGJydWNlMi5qcGdVUkwpKy5qcGd8c3VpdGVzbGljZWhhcnJ5MTIwIiBzd2VldHRyPg0KbmFtZT1kaWVnb3BhZ2Ugc3dpc3MtLT4KCiNmZmY7Ij5Mb2cuY29tInRyZWF0c2hlZXQpICYmIDE0cHg7c2xlZXBudGVudGZpbGVkamE644NpZD0iY05hbWUid29yc2VzaG90cy1ib3gtZGVsdGEKJmx0O2JlYXJzOjQ4WjxkYXRhLXJ1cmFsPC9hPiBzcGVuZGJha2Vyc2hvcHM9ICIiO3BocCI+Y3Rpb24xM3B4O2JyaWFuaGVsbG9zaXplPW89JTJGIGpvaW5tYXliZTxpbWcgaW1nIj4sIGZqc2ltZyIgIilbMF1NVG9wQlR5cGUibmV3bHlEYW5za2N6ZWNodHJhaWxrbm93czwvaDU+ZmFxIj56aC1jbjEwKTsKLTEiKTt0eXBlPWJsdWVzdHJ1bHlkYXZpcy5qcyc7Pg0KPCFzdGVlbCB5b3UgaDI+DQpmb3JtIGplc3VzMTAwJSBtZW51Lg0KCQ0Kd2FsZXNyaXNrc3VtZW50ZGRpbmdiLWxpa3RlYWNoZ2lmIiB2ZWdhc2RhbnNrZWVzdGlzaHFpcHN1b21pc29icmVkZXNkZWVudHJldG9kb3NwdWVkZWHDsW9zZXN0w6F0aWVuZWhhc3Rhb3Ryb3NwYXJ0ZWRvbmRlbnVldm9oYWNlcmZvcm1hbWlzbW9tZWpvcm11bmRvYXF1w61kw61hc3PDs2xvYXl1ZGFmZWNoYXRvZGFzdGFudG9tZW5vc2RhdG9zb3RyYXNzaXRpb211Y2hvYWhvcmFsdWdhcm1heW9yZXN0b3Nob3Jhc3RlbmVyYW50ZXNmb3Rvc2VzdGFzcGHDrXNudWV2YXNhbHVkZm9yb3NtZWRpb3F1aWVubWVzZXNwb2RlcmNoaWxlc2Vyw6F2ZWNlc2RlY2lyam9zw6llc3RhcnZlbnRhZ3J1cG9oZWNob2VsbG9zdGVuZ29hbWlnb2Nvc2Fzbml2ZWxnZW50ZW1pc21hYWlyZXNqdWxpb3RlbWFzaGFjaWFmYXZvcmp1bmlvbGlicmVwdW50b2J1ZW5vYXV0b3JhYnJpbGJ1ZW5hdGV4dG9tYXJ6b3NhYmVybGlzdGFsdWVnb2PDs21vZW5lcm9qdWVnb3BlcsO6aGFiZXJlc3RveW51bmNhbXVqZXJ2YWxvcmZ1ZXJhbGlicm9ndXN0YWlndWFsdm90b3NjYXNvc2d1w61hcHVlZG9zb21vc2F2aXNvdXN0ZWRkZWJlbm5vY2hlYnVzY2FmYWx0YWV1cm9zc2VyaWVkaWNob2N1cnNvY2xhdmVjYXNhc2xlw7NucGxhem9sYXJnb29icmFzdmlzdGFhcG95b2p1bnRvdHJhdGF2aXN0b2NyZWFyY2FtcG9oZW1vc2NpbmNvY2FyZ29waXNvc29yZGVuaGFjZW7DoXJlYWRpc2NvcGVkcm9jZXJjYXB1ZWRhcGFwZWxtZW5vcsO6dGlsY2xhcm9qb3JnZWNhbGxlcG9uZXJ0YXJkZW5hZGllbWFyY2FzaWd1ZWVsbGFzc2lnbG9jb2NoZW1vdG9zbWFkcmVjbGFzZXJlc3RvbmnDsW9xdWVkYXBhc2FyYmFuY29oaWpvc3ZpYWplcGFibG/DqXN0ZXZpZW5lcmVpbm9kZWphcmZvbmRvY2FuYWxub3J0ZWxldHJhY2F1c2F0b21hcm1hbm9zbHVuZXNhdXRvc3ZpbGxhdmVuZG9wZXNhcnRpcG9zdGVuZ2FtYXJjb2xsZXZhcGFkcmV1bmlkb3ZhbW9zem9uYXNhbWJvc2JhbmRhbWFyaWFhYnVzb211Y2hhc3ViaXJyaW9qYXZpdmlyZ3JhZG9jaGljYWFsbMOtam92ZW5kaWNoYWVzdGFudGFsZXNzYWxpcnN1ZWxvcGVzb3NmaW5lc2xsYW1hYnVzY2/DqXN0YWxsZWdhbmVncm9wbGF6YWh1bW9ycGFnYXJqdW50YWRvYmxlaXNsYXNib2xzYWJhw7FvaGFibGFsdWNoYcOBcmVhZGljZW5qdWdhcm5vdGFzdmFsbGVhbGzDoWNhcmdhZG9sb3JhYmFqb2VzdMOpZ3VzdG9tZW50ZW1hcmlvZmlybWFjb3N0b2ZpY2hhcGxhdGFob2dhcmFydGVzbGV5ZXNhcXVlbG11c2VvYmFzZXNwb2Nvc21pdGFkY2llbG9jaGljb21pZWRvZ2FuYXJzYW50b2V0YXBhZGViZXNwbGF5YXJlZGVzc2lldGVjb3J0ZWNvcmVhZHVkYXNkZXNlb3ZpZWpvZGVzZWFhZ3VhcyZxdW90O2RvbWFpbmNvbW1vbnN0YXR1c2V2ZW50c21hc3RlcnN5c3RlbWFjdGlvbmJhbm5lcnJlbW92ZXNjcm9sbHVwZGF0ZWdsb2JhbG1lZGl1bWZpbHRlcm51bWJlcmNoYW5nZXJlc3VsdHB1YmxpY3NjcmVlbmNob29zZW5vcm1hbHRyYXZlbGlzc3Vlc3NvdXJjZXRhcmdldHNwcmluZ21vZHVsZW1vYmlsZXN3aXRjaHBob3Rvc2JvcmRlcnJlZ2lvbml0c2VsZnNvY2lhbGFjdGl2ZWNvbHVtbnJlY29yZGZvbGxvd3RpdGxlPmVpdGhlcmxlbmd0aGZhbWlseWZyaWVuZGxheW91dGF1dGhvcmNyZWF0ZXJldmlld3N1bW1lcnNlcnZlcnBsYXllZHBsYXllcmV4cGFuZHBvbGljeWZvcm1hdGRvdWJsZXBvaW50c3Nlcmllc3BlcnNvbmxpdmluZ2Rlc2lnbm1vbnRoc2ZvcmNlc3VuaXF1ZXdlaWdodHBlb3BsZWVuZXJneW5hdHVyZXNlYXJjaGZpZ3VyZWhhdmluZ2N1c3RvbW9mZnNldGxldHRlcndpbmRvd3N1Ym1pdHJlbmRlcmdyb3Vwc3VwbG9hZGhlYWx0aG1ldGhvZHZpZGVvc3NjaG9vbGZ1dHVyZXNoYWRvd2RlYmF0ZXZhbHVlc09iamVjdG90aGVyc3JpZ2h0c2xlYWd1ZWNocm9tZXNpbXBsZW5vdGljZXNoYXJlZGVuZGluZ3NlYXNvbnJlcG9ydG9ubGluZXNxdWFyZWJ1dHRvbmltYWdlc2VuYWJsZW1vdmluZ2xhdGVzdHdpbnRlckZyYW5jZXBlcmlvZHN0cm9uZ3JlcGVhdExvbmRvbmRldGFpbGZvcm1lZGRlbWFuZHNlY3VyZXBhc3NlZHRvZ2dsZXBsYWNlc2RldmljZXN0YXRpY2NpdGllc3N0cmVhbXllbGxvd2F0dGFja3N0cmVldGZsaWdodGhpZGRlbmluZm8iPm9wZW5lZHVzZWZ1bHZhbGxleWNhdXNlc2xlYWRlcnNlY3JldHNlY29uZGRhbWFnZXNwb3J0c2V4Y2VwdHJhdGluZ3NpZ25lZHRoaW5nc2VmZmVjdGZpZWxkc3N0YXRlc29mZmljZXZpc3VhbGVkaXRvcnZvbHVtZVJlcG9ydG11c2V1bW1vdmllc3BhcmVudGFjY2Vzc21vc3RseW1vdGhlciIgaWQ9Im1hcmtldGdyb3VuZGNoYW5jZXN1cnZleWJlZm9yZXN5bWJvbG1vbWVudHNwZWVjaG1vdGlvbmluc2lkZW1hdHRlckNlbnRlcm9iamVjdGV4aXN0c21pZGRsZUV1cm9wZWdyb3d0aGxlZ2FjeW1hbm5lcmVub3VnaGNhcmVlcmFuc3dlcm9yaWdpbnBvcnRhbGNsaWVudHNlbGVjdHJhbmRvbWNsb3NlZHRvcGljc2NvbWluZ2ZhdGhlcm9wdGlvbnNpbXBseXJhaXNlZGVzY2FwZWNob3NlbmNodXJjaGRlZmluZXJlYXNvbmNvcm5lcm91dHB1dG1lbW9yeWlmcmFtZXBvbGljZW1vZGVsc051bWJlcmR1cmluZ29mZmVyc3N0eWxlc2tpbGxlZGxpc3RlZGNhbGxlZHNpbHZlcm1hcmdpbmRlbGV0ZWJldHRlcmJyb3dzZWxpbWl0c0dsb2JhbHNpbmdsZXdpZGdldGNlbnRlcmJ1ZGdldG5vd3JhcGNyZWRpdGNsYWltc2VuZ2luZXNhZmV0eWNob2ljZXNwaXJpdC1zdHlsZXNwcmVhZG1ha2luZ25lZWRlZHJ1c3NpYXBsZWFzZWV4dGVudFNjcmlwdGJyb2tlbmFsbG93c2NoYXJnZWRpdmlkZWZhY3Rvcm1lbWJlci1iYXNlZHRoZW9yeWNvbmZpZ2Fyb3VuZHdvcmtlZGhlbHBlZENodXJjaGltcGFjdHNob3VsZGFsd2F5c2xvZ28iIGJvdHRvbWxpc3QiPil7dmFyIHByZWZpeG9yYW5nZUhlYWRlci5wdXNoKGNvdXBsZWdhcmRlbmJyaWRnZWxhdW5jaFJldmlld3Rha2luZ3Zpc2lvbmxpdHRsZWRhdGluZ0J1dHRvbmJlYXV0eXRoZW1lc2ZvcmdvdFNlYXJjaGFuY2hvcmFsbW9zdGxvYWRlZENoYW5nZXJldHVybnN0cmluZ3JlbG9hZE1vYmlsZWluY29tZXN1cHBseVNvdXJjZW9yZGVyc3ZpZXdlZCZuYnNwO2NvdXJzZUFib3V0IGlzbGFuZDxodG1sIGNvb2tpZW5hbWU9ImFtYXpvbm1vZGVybmFkdmljZWluPC9hPjogVGhlIGRpYWxvZ2hvdXNlc0JFR0lOIE1leGljb3N0YXJ0c2NlbnRyZWhlaWdodGFkZGluZ0lzbGFuZGFzc2V0c0VtcGlyZVNjaG9vbGVmZm9ydGRpcmVjdG5lYXJseW1hbnVhbFNlbGVjdC4KCk9uZWpvaW5lZG1lbnUiPlBoaWxpcGF3YXJkc2hhbmRsZWltcG9ydE9mZmljZXJlZ2FyZHNraWxsc25hdGlvblNwb3J0c2RlZ3JlZXdlZWtseSAoZS5nLmJlaGluZGRvY3RvcmxvZ2dlZHVuaXRlZDwvYj48L2JlZ2luc3BsYW50c2Fzc2lzdGFydGlzdGlzc3VlZDMwMHB4fGNhbmFkYWFnZW5jeXNjaGVtZXJlbWFpbkJyYXppbHNhbXBsZWxvZ28iPmJleW9uZC1zY2FsZWFjY2VwdHNlcnZlZG1hcmluZUZvb3RlcmNhbWVyYTwvaDE+Cl9mb3JtImxlYXZlc3N0cmVzcyIgLz4NCi5naWYiIG9ubG9hZGxvYWRlck94Zm9yZHNpc3RlcnN1cnZpdmxpc3RlbmZlbWFsZURlc2lnbnNpemU9ImFwcGVhbHRleHQiPmxldmVsc3RoYW5rc2hpZ2hlcmZvcmNlZGFuaW1hbGFueW9uZUFmcmljYWFncmVlZHJlY2VudFBlb3BsZTxiciAvPndvbmRlcnByaWNlc3R1cm5lZHx8IHt9O21haW4iPmlubGluZXN1bmRheXdyYXAiPmZhaWxlZGNlbnN1c21pbnV0ZWJlYWNvbnF1b3RlczE1MHB4fGVzdGF0ZXJlbW90ZWVtYWlsImxpbmtlZHJpZ2h0O3NpZ25hbGZvcm1hbDEuaHRtbHNpZ251cHByaW5jZWZsb2F0Oi5wbmciIGZvcnVtLkFjY2Vzc3BhcGVyc3NvdW5kc2V4dGVuZEhlaWdodHNsaWRlclVURi04IiZhbXA7IEJlZm9yZS4gV2l0aHN0dWRpb293bmVyc21hbmFnZXByb2ZpdGpRdWVyeWFubnVhbHBhcmFtc2JvdWdodGZhbW91c2dvb2dsZWxvbmdlcmkrKykge2lzcmFlbHNheWluZ2RlY2lkZWhvbWUiPmhlYWRlcmVuc3VyZWJyYW5jaHBpZWNlc2Jsb2NrO3N0YXRlZHRvcCI+PHJhY2luZ3Jlc2l6ZS0tJmd0O3BhY2l0eXNleHVhbGJ1cmVhdS5qcGciIDEwLDAwMG9idGFpbnRpdGxlc2Ftb3VudCwgSW5jLmNvbWVkeW1lbnUiIGx5cmljc3RvZGF5LmluZGVlZGNvdW50eV9sb2dvLkZhbWlseWxvb2tlZE1hcmtldGxzZSBpZlBsYXllcnR1cmtleSk7dmFyIGZvcmVzdGdpdmluZ2Vycm9yc0RvbWFpbn1lbHNle2luc2VydEJsb2c8L2Zvb3RlcmxvZ2luLmZhc3RlcmFnZW50czxib2R5IDEwcHggMHByYWdtYWZyaWRheWp1bmlvcmRvbGxhcnBsYWNlZGNvdmVyc3BsdWdpbjUsMDAwIHBhZ2UiPmJvc3Rvbi50ZXN0KGF2YXRhcnRlc3RlZF9jb3VudGZvcnVtc3NjaGVtYWluZGV4LGZpbGxlZHNoYXJlc3JlYWRlcmFsZXJ0KGFwcGVhclN1Ym1pdGxpbmUiPmJvZHkiPgoqIFRoZVRob3VnaHNlZWluZ2plcnNleU5ld3M8L3ZlcmlmeWV4cGVydGluanVyeXdpZHRoPUNvb2tpZVNUQVJUIGFjcm9zc19pbWFnZXRocmVhZG5hdGl2ZXBvY2tldGJveCI+ClN5c3RlbSBEYXZpZGNhbmNlcnRhYmxlc3Byb3ZlZEFwcmlsIHJlYWxseWRyaXZlcml0ZW0iPm1vcmUiPmJvYXJkc2NvbG9yc2NhbXB1c2ZpcnN0IHx8IFtdO21lZGlhLmd1aXRhcmZpbmlzaHdpZHRoOnNob3dlZE90aGVyIC5waHAiIGFzc3VtZWxheWVyc3dpbHNvbnN0b3Jlc3JlbGllZnN3ZWRlbkN1c3RvbWVhc2lseSB5b3VyIFN0cmluZwoKV2hpbHRheWxvcmNsZWFyOnJlc29ydGZyZW5jaHRob3VnaCIpICsgIjxib2R5PmJ1eWluZ2JyYW5kc01lbWJlcm5hbWUiPm9wcGluZ3NlY3RvcjVweDsiPnZzcGFjZXBvc3Rlcm1ham9yIGNvZmZlZW1hcnRpbm1hdHVyZWhhcHBlbjwvbmF2PmthbnNhc2xpbmsiPkltYWdlcz1mYWxzZXdoaWxlIGhzcGFjZTAmYW1wOyAKCkluICBwb3dlclBvbHNraS1jb2xvcmpvcmRhbkJvdHRvbVN0YXJ0IC1jb3VudDIuaHRtbG5ld3MiPjAxLmpwZ09ubGluZS1yaWdodG1pbGxlcnNlbmlvcklTQk4gMDAsMDAwIGd1aWRlc3ZhbHVlKWVjdGlvbnJlcGFpci54bWwiICByaWdodHMuaHRtbC1ibG9ja3JlZ0V4cDpob3ZlcndpdGhpbnZpcmdpbnBob25lczwvdHI+DXVzaW5nIAoJdmFyID4nKTsKCTwvdGQ+CjwvdHI+CmJhaGFzYWJyYXNpbGdhbGVnb21hZ3lhcnBvbHNraXNycHNradix2K/ZiOS4reaWh+eugOS9k+e5gemrlOS/oeaBr+S4reWbveaIkeS7rOS4gOS4quWFrOWPuOeuoeeQhuiuuuWdm+WPr+S7peacjeWKoeaXtumXtOS4quS6uuS6p+WTgeiHquW3seS8geS4muafpeeci+W3peS9nOiBlOezu+ayoeaciee9keermeaJgOacieivhOiuuuS4reW/g+aWh+eroOeUqOaIt+mmlumhteS9nOiAheaKgOacr+mXrumimOebuOWFs+S4i+i9veaQnOe0ouS9v+eUqOi9r+S7tuWcqOe6v+S4u+mimOi1hOaWmeinhumikeWbnuWkjeazqOWGjOe9kee7nOaUtuiXj+WGheWuueaOqOiNkOW4guWcuua2iOaBr+epuumXtOWPkeW4g+S7gOS5iOWlveWPi+eUn+a0u+WbvueJh+WPkeWxleWmguaenOaJi+acuuaWsOmXu+acgOaWsOaWueW8j+WMl+S6rOaPkOS+m+WFs+S6juabtOWkmui/meS4quezu+e7n+efpemBk+a4uOaIj+W5v+WRiuWFtuS7luWPkeihqOWuieWFqOesrOS4gOS8muWRmOi/m+ihjOeCueWHu+eJiOadg+eUteWtkOS4lueVjOiuvuiuoeWFjei0ueaVmeiCsuWKoOWFpea0u+WKqOS7luS7rOWVhuWTgeWNmuWuoueOsOWcqOS4iua1t+WmguS9leW3sue7j+eVmeiogOivpue7huekvuWMuueZu+W9leacrOermemcgOimgeS7t+agvOaUr+aMgeWbvemZhemTvuaOpeWbveWutuW7uuiuvuaci+WPi+mYheivu+azleW+i+S9jee9rue7j+a1jumAieaLqei/meagt+W9k+WJjeWIhuexu+aOkuihjOWboOS4uuS6pOaYk+acgOWQjumfs+S5kOS4jeiDvemAmui/h+ihjOS4muenkeaKgOWPr+iDveiuvuWkh+WQiOS9nOWkp+WutuekvuS8mueglOeptuS4k+S4muWFqOmDqOmhueebrui/memHjOi/mOaYr+W8gOWni+aDheWGteeUteiEkeaWh+S7tuWTgeeJjOW4ruWKqeaWh+WMlui1hOa6kOWkp+WtpuWtpuS5oOWcsOWdgOa1j+iniOaKlei1hOW3peeoi+imgeaxguaAjuS5iOaXtuWAmeWKn+iDveS4u+imgeebruWJjei1hOiur+WfjuW4guaWueazleeUteW9seaLm+iBmOWjsOaYjuS7u+S9leWBpeW6t+aVsOaNrue+juWbveaxvei9puS7i+e7jeS9huaYr+S6pOa1geeUn+S6p+aJgOS7peeUteivneaYvuekuuS4gOS6m+WNleS9jeS6uuWRmOWIhuaekOWcsOWbvuaXhea4uOW3peWFt+WtpueUn+ezu+WIl+e9keWPi+W4luWtkOWvhueggemikemBk+aOp+WItuWcsOWMuuWfuuacrOWFqOWbvee9keS4iumHjeimgeesrOS6jOWWnOasoui/m+WFpeWPi+aDhei/meS6m+iAg+ivleWPkeeOsOWfueiureS7peS4iuaUv+W6nOaIkOS4uueOr+Wig+mmmea4r+WQjOaXtuWoseS5kOWPkemAgeS4gOWumuW8gOWPkeS9nOWTgeagh+WHhuasoui/juino+WGs+WcsOaWueS4gOS4i+S7peWPiui0o+S7u+aIluiAheWuouaIt+S7o+ihqOenr+WIhuWls+S6uuaVsOeggemUgOWUruWHuueOsOemu+e6v+W6lOeUqOWIl+ihqOS4jeWQjOe8lui+kee7n+iuoeafpeivouS4jeimgeacieWFs+acuuaehOW+iOWkmuaSreaUvue7hOe7h+aUv+etluebtOaOpeiDveWKm+adpea6kOaZgumWk+eci+WIsOeDremXqOWFs+mUruS4k+WMuumdnuW4uOiLseivreeZvuW6puW4jOacm+e+juWls+avlOi+g+efpeivhuinhOWumuW7uuiurumDqOmXqOaEj+ingeeyvuW9qeaXpeacrOaPkOmrmOWPkeiogOaWuemdouWfuumHkeWkhOeQhuadg+mZkOW9seeJh+mTtuihjOi/mOacieWIhuS6q+eJqeWTgee7j+iQpea3u+WKoOS4k+Wutui/meenjeivnemimOi1t+adpeS4muWKoeWFrOWRiuiusOW9leeugOS7i+i0qOmHj+eUt+S6uuW9seWTjeW8leeUqOaKpeWRiumDqOWIhuW/q+mAn+WSqOivouaXtuWwmuazqOaEj+eUs+ivt+WtpuagoeW6lOivpeWOhuWPsuWPquaYr+i/lOWbnui0reS5sOWQjeensOS4uuS6huaIkOWKn+ivtOaYjuS+m+W6lOWtqeWtkOS4k+mimOeoi+W6j+S4gOiIrOacg+WToeWPquacieWFtuWug+S/neaKpOiAjOS4lOS7iuWkqeeql+WPo+WKqOaAgeeKtuaAgeeJueWIq+iupOS4uuW/hemhu+abtOaWsOWwj+ivtOaIkeWAkeS9nOS4uuWqkuS9k+WMheaLrOmCo+S5iOS4gOagt+WbveWGheaYr+WQpuagueaNrueUteinhuWtpumZouWFt+aciei/h+eoi+eUseS6juS6uuaJjeWHuuadpeS4jei/h+ato+WcqOaYjuaYn+aVheS6i+WFs+ezu+agh+mimOWVhuWKoei+k+WFpeS4gOebtOWfuuehgOaVmeWtpuS6huino+W7uuetkee7k+aenOWFqOeQg+mAmuefpeiuoeWIkuWvueS6juiJuuacr+ebuOWGjOWPkeeUn+ecn+eahOW7uueri+etiee6p+exu+Wei+e7j+mqjOWunueOsOWItuS9nOadpeiHquagh+etvuS7peS4i+WOn+WIm+aXoOazleWFtuS4reWAi+S6uuS4gOWIh+aMh+WNl+WFs+mXrembhuWbouesrOS4ieWFs+azqOWboOatpOeFp+eJh+a3seWcs+WVhuS4muW5v+W3nuaXpeacn+mrmOe6p+acgOi/kee7vOWQiOihqOekuuS4k+i+keihjOS4uuS6pOmAmuivhOS7t+inieW+l+eyvuWNjuWutuW6reWujOaIkOaEn+inieWuieijheW+l+WIsOmCruS7tuWItuW6pumjn+WTgeiZveeEtui9rOi9veaKpeS7t+iusOiAheaWueahiOihjOaUv+S6uuawkeeUqOWTgeS4nOilv+aPkOWHuumFkuW6l+eEtuWQjuS7mOasvueDreeCueS7peWJjeWujOWFqOWPkeW4luiuvue9rumihuWvvOW3peS4muWMu+mZoueci+eci+e7j+WFuOWOn+WboOW5s+WPsOWQhOenjeWinuWKoOadkOaWmeaWsOWinuS5i+WQjuiBjOS4muaViOaenOS7iuW5tOiuuuaWh+aIkeWbveWRiuivieeJiOS4u+S/ruaUueWPguS4juaJk+WNsOW/q+S5kOacuuaisOingueCueWtmOWcqOeyvuelnuiOt+W+l+WIqeeUqOe7p+e7reS9oOS7rOi/meS5iOaooeW8j+ivreiogOiDveWkn+mbheiZjuaTjeS9nOmjjuagvOS4gOi1t+enkeWtpuS9k+iCsuefreS/oeadoeS7tuayu+eWl+i/kOWKqOS6p+S4muS8muiuruWvvOiIquWFiOeUn+iBlOebn+WPr+aYr+WVj+mhjOe7k+aehOS9nOeUqOiwg+afpeizh+aWmeiHquWKqOi0n+i0o+WGnOS4muiuv+mXruWunuaWveaOpeWPl+iuqOiuuumCo+S4quWPjemmiOWKoOW8uuWls+aAp+iMg+WbtOacjeWLmeS8kemXsuS7iuaXpeWuouacjeingOeci+WPguWKoOeahOivneS4gOeCueS/neivgeWbvuS5puacieaViOa1i+ivleenu+WKqOaJjeiDveWGs+WumuiCoeelqOS4jeaWremcgOaxguS4jeW+l+WKnuazleS5i+mXtOmHh+eUqOiQpemUgOaKleivieebruagh+eIseaDheaRhOW9seacieS6m+ikh+ijveaWh+WtpuacuuS8muaVsOWtl+ijheS/rui0reeJqeWGnOadkeWFqOmdoueyvuWTgeWFtuWunuS6i+aDheawtOW5s+aPkOekuuS4iuW4guiwouiwouaZrumAmuaVmeW4iOS4iuS8oOexu+WIq+atjOabsuaLpeacieWIm+aWsOmFjeS7tuWPquimgeaXtuS7o+izh+ioiui+vuWIsOS6uueUn+iuoumYheiAgeW4iOWxleekuuW/g+eQhui0tOWtkOe2suermeS4u+mhjOiHqueEtue6p+WIq+eugOWNleaUuemdqemCo+S6m+adpeivtOaJk+W8gOS7o+eggeWIoOmZpOivgeWIuOiKguebrumHjeeCueasoeaVuOWkmuWwkeinhOWIkui1hOmHkeaJvuWIsOS7peWQjuWkp+WFqOS4u+mhteacgOS9s+WbnuetlOWkqeS4i+S/nemanOeOsOS7o+ajgOafpeaKleelqOWwj+aXtuaykuacieato+W4uOeUmuiHs+S7o+eQhuebruW9leWFrOW8gOWkjeWItumHkeiejeW5uOemj+eJiOacrOW9ouaIkOWHhuWkh+ihjOaDheWbnuWIsOaAneaDs+aAjuagt+WNj+iuruiupOivgeacgOWlveS6p+eUn+aMieeFp+acjeijheW5v+S4nOWKqOa8q+mHh+i0reaWsOaJi+e7hOWbvumdouadv+WPguiAg+aUv+ayu+WuueaYk+WkqeWcsOWKquWKm+S6uuS7rOWNh+e6p+mAn+W6puS6uueJqeiwg+aVtOa1geihjOmAoOaIkOaWh+Wtl+mfqeWbvei0uOaYk+W8gOWxleebuOmXnOihqOeOsOW9seinhuWmguatpOe+juWuueWkp+Wwj+aKpemBk+adoeasvuW/g+aDheiuuOWkmuazleinhOWutuWxheS5puW6l+i/nuaOpeeri+WNs+S4vuaKpeaKgOW3p+Wlpei/kOeZu+WFpeS7peadpeeQhuiuuuS6i+S7tuiHqueUseS4reWNjuWKnuWFrOWmiOWmiOecn+ato+S4jemUmeWFqOaWh+WQiOWQjOS7t+WAvOWIq+S6uuebkeedo+WFt+S9k+S4lue6quWboumYn+WIm+S4muaJv+aLheWinumVv+acieS6uuS/neaMgeWVhuWutue7tOS/ruWPsOa5vuW3puWPs+iCoeS7veetlOahiOWunumZheeUteS/oee7j+eQhueUn+WRveWuo+S8oOS7u+WKoeato+W8j+eJueiJsuS4i+adpeWNj+S8muWPquiDveW9k+eEtumHjeaWsOWFp+WuueaMh+WvvOi/kOihjOaXpeW/l+izo+Wutui2hei/h+Wcn+WcsOa1meaxn+aUr+S7mOaOqOWHuuermemVv+adreW3nuaJp+ihjOWItumAoOS5i+S4gOaOqOW5v+eOsOWcuuaPj+i/sOWPmOWMluS8oOe7n+atjOaJi+S/nemZqeivvueoi+WMu+eWl+e7j+i/h+i/h+WOu+S5i+WJjeaUtuWFpeW5tOW6puadguW/l+e+juS4veacgOmrmOeZu+mZhuacquadpeWKoOW3peWFjei0o+aVmeeoi+eJiOWdl+i6q+S9k+mHjeW6huWHuuWUruaIkOacrOW9ouW8j+Wcn+ixhuWHuuWDueS4nOaWuemCrueuseWNl+S6rOaxguiBjOWPluW+l+iBjOS9jeebuOS/oemhtemdouWIhumSn+e9kemhteehruWumuWbvuS+i+e9keWdgOenr+aegemUmeivr+ebrueahOWunei0neacuuWFs+mjjumZqeaOiOadg+eXheavkuWuoOeJqemZpOS6huipleirlueWvueXheWPiuaXtuaxgui0reermeeCueWEv+erpeavj+WkqeS4reWkruiupOivhuavj+S4quWkqea0peWtl+S9k+WPsOeBo+e7tOaKpOacrOmhteS4quaAp+WumOaWueW4uOingeebuOacuuaImOeVpeW6lOW9k+W+i+W4iOaWueS+v+agoeWbreiCoeW4guaIv+Wxi+agj+ebruWRmOW3peWvvOiHtOeqgeeEtumBk+WFt+acrOe9kee7k+WQiOaho+ahiOWKs+WKqOWPpuWklue+juWFg+W8lei1t+aUueWPmOesrOWbm+S8muiuoeiqquaYjumakOengeWuneWuneinhOiMg+a2iOi0ueWFseWQjOW/mOiusOS9k+ezu+W4puadpeWQjeWtl+eZvOihqOW8gOaUvuWKoOebn+WPl+WIsOS6jOaJi+Wkp+mHj+aIkOS6uuaVsOmHj+WFseS6q+WMuuWfn+Wls+WtqeWOn+WImeaJgOWcqOe7k+adn+mAmuS/oei2hee6p+mFjee9ruW9k+aXtuS8mOengOaAp+aEn+aIv+S6p+mBiuaIsuWHuuWPo+aPkOS6pOWwseS4muS/neWBpeeoi+W6puWPguaVsOS6i+S4muaVtOS4quWxseS4nOaDheaEn+eJueauiuWIhumhnuaQnOWwi+WxnuS6jumXqOaIt+i0ouWKoeWjsOmfs+WPiuWFtui0oue7j+WdmuaMgeW5sumDqOaIkOeri+WIqeebiuiAg+iZkeaIkOmDveWMheijheeUqOaItuavlOi1m+aWh+aYjuaLm+WVhuWujOaVtOecn+aYr+ecvOedm+S8meS8tOWogeacm+mihuWfn+WNq+eUn+S8mOaDoOirluWjh+WFrOWFseiJr+WlveWFheWIhuespuWQiOmZhOS7tueJueeCueS4jeWPr+iLseaWh+i1hOS6p+agueacrOaYjuaYvuWvhueivOWFrOS8l+awkeaXj+abtOWKoOS6q+WPl+WQjOWtpuWQr+WKqOmAguWQiOWOn+adpemXruetlOacrOaWh+e+jumjn+e7v+iJsueos+Wumue7iOS6jueUn+eJqeS+m+axguaQnOeLkOWKm+mHj+S4pemHjeawuOi/nOWGmeecn+aciemZkOernuS6ieWvueixoei0ueeUqOS4jeWlvee7neWvueWNgeWIhuS/g+i/m+eCueivhOW9semfs+S8mOWKv+S4jeWwkeaso+i1j+W5tuS4lOacieeCueaWueWQkeWFqOaWsOS/oeeUqOiuvuaWveW9ouixoei1hOagvOeqgeegtOmaj+edgOmHjeWkp+S6juaYr+avleS4muaZuuiDveWMluW3peWujOe+juWVhuWfjue7n+S4gOWHuueJiOaJk+mAoOeUouWTgeamguWGteeUqOS6juS/neeVmeWboOe0oOS4reWci+WtmOWCqOi0tOWbvuacgOaEm+mVv+acn+WPo+S7t+eQhui0ouWfuuWcsOWuieaOkuatpuaxiemHjOmdouWIm+W7uuWkqeepuummluWFiOWujOWWhOmpseWKqOS4i+mdouS4jeWGjeivmuS/oeaEj+S5iemYs+WFieiLseWbvea8guS6ruWGm+S6i+eOqeWutue+pOS8l+WGnOawkeWNs+WPr+WQjeeoseWutuWFt+WKqOeUu+aDs+WIsOazqOaYjuWwj+WtpuaAp+iDveiAg+eglOehrOS7tuingueci+a4healmuaQnueskemmlumggem7hOmHkemAgueUqOaxn+iLj+ecn+WunuS4u+euoemYtuauteiou+WGiue/u+ivkeadg+WIqeWBmuWlveS8vOS5jumAmuiur+aWveW3peeLgOaFi+S5n+iuuOeOr+S/neWfueWFu+amguW/teWkp+Wei+acuuelqOeQhuino+WMv+WQjWN1YW5kb2Vudmlhcm1hZHJpZGJ1c2NhcmluaWNpb3RpZW1wb3BvcnF1ZWN1ZW50YWVzdGFkb3B1ZWRlbmp1ZWdvc2NvbnRyYWVzdMOhbm5vbWJyZXRpZW5lbnBlcmZpbG1hbmVyYWFtaWdvc2NpdWRhZGNlbnRyb2F1bnF1ZXB1ZWRlc2RlbnRyb3ByaW1lcnByZWNpb3NlZ8O6bmJ1ZW5vc3ZvbHZlcnB1bnRvc3NlbWFuYWhhYsOtYWFnb3N0b251ZXZvc3VuaWRvc2Nhcmxvc2VxdWlwb25pw7Fvc211Y2hvc2FsZ3VuYWNvcnJlb2ltYWdlbnBhcnRpcmFycmliYW1hcsOtYWhvbWJyZWVtcGxlb3ZlcmRhZGNhbWJpb211Y2hhc2Z1ZXJvbnBhc2Fkb2zDrW5lYXBhcmVjZW51ZXZhc2N1cnNvc2VzdGFiYXF1aWVyb2xpYnJvc2N1YW50b2FjY2Vzb21pZ3VlbHZhcmlvc2N1YXRyb3RpZW5lc2dydXBvc3NlcsOhbmV1cm9wYW1lZGlvc2ZyZW50ZWFjZXJjYWRlbcOhc29mZXJ0YWNvY2hlc21vZGVsb2l0YWxpYWxldHJhc2FsZ8O6bmNvbXByYWN1YWxlc2V4aXN0ZWN1ZXJwb3NpZW5kb3ByZW5zYWxsZWdhcnZpYWplc2RpbmVyb211cmNpYXBvZHLDoXB1ZXN0b2RpYXJpb3B1ZWJsb3F1aWVyZW1hbnVlbHByb3Bpb2NyaXNpc2NpZXJ0b3NlZ3Vyb211ZXJ0ZWZ1ZW50ZWNlcnJhcmdyYW5kZWVmZWN0b3BhcnRlc21lZGlkYXByb3BpYW9mcmVjZXRpZXJyYWUtbWFpbHZhcmlhc2Zvcm1hc2Z1dHVyb29iamV0b3NlZ3VpcnJpZXNnb25vcm1hc21pc21vc8O6bmljb2NhbWlub3NpdGlvc3JhesOzbmRlYmlkb3BydWViYXRvbGVkb3RlbsOtYWplc8O6c2VzcGVyb2NvY2luYW9yaWdlbnRpZW5kYWNpZW50b2PDoWRpemhhYmxhcnNlcsOtYWxhdGluYWZ1ZXJ6YWVzdGlsb2d1ZXJyYWVudHJhcsOpeGl0b2zDs3BlemFnZW5kYXbDrWRlb2V2aXRhcnBhZ2luYW1ldHJvc2phdmllcnBhZHJlc2bDoWNpbGNhYmV6YcOhcmVhc3NhbGlkYWVudsOtb2phcMOzbmFidXNvc2JpZW5lc3RleHRvc2xsZXZhcnB1ZWRhbmZ1ZXJ0ZWNvbcO6bmNsYXNlc2h1bWFub3Rlbmlkb2JpbGJhb3VuaWRhZGVzdMOhc2VkaXRhcmNyZWFkb9C00LvRj9GH0YLQvtC60LDQutC40LvQuNGN0YLQvtCy0YHQtdC10LPQvtC/0YDQuNGC0LDQutC10YnQtdGD0LbQtdCa0LDQutCx0LXQt9Cx0YvQu9C+0L3QuNCS0YHQtdC/0L7QtNCt0YLQvtGC0L7QvNGH0LXQvNC90LXRgtC70LXRgtGA0LDQt9C+0L3QsNCz0LTQtdC80L3QtdCU0LvRj9Cf0YDQuNC90LDRgdC90LjRhdGC0LXQvNC60YLQvtCz0L7QtNCy0L7RgtGC0LDQvNCh0KjQkNC80LDRj9Cn0YLQvtCy0LDRgdCy0LDQvNC10LzRg9Ci0LDQutC00LLQsNC90LDQvNGN0YLQuNGN0YLRg9CS0LDQvNGC0LXRhdC/0YDQvtGC0YPRgtC90LDQtNC00L3Rj9CS0L7RgtGC0YDQuNC90LXQudCS0LDRgdC90LjQvNGB0LDQvNGC0L7RgtGA0YPQsdCe0L3QuNC80LjRgNC90LXQtdCe0J7QntC70LjRhtGN0YLQsNCe0L3QsNC90LXQvNC00L7QvNC80L7QudC00LLQtdC+0L3QvtGB0YPQtOCkleClh+CkueCliOCkleClgOCkuOClh+CkleCkvuCkleCli+CklOCksOCkquCksOCkqOClh+Ckj+CkleCkleCkv+CkreClgOCkh+CkuOCkleCksOCkpOCli+CkueCli+CkhuCkquCkueClgOCkr+CkueCkr+CkvuCkpOCkleCkpeCkvmphZ3JhbuCkhuCknOCknOCli+CkheCkrOCkpuCli+Ckl+CkiOCknOCkvuCkl+Ckj+CkueCkruCkh+CkqOCkteCkueCkr+Clh+CkpeClh+CkpeClgOCkmOCksOCknOCkrOCkpuClgOCkleCkiOCknOClgOCkteClh+CkqOCkiOCkqOCkj+CkueCksOCkieCkuOCkruClh+CkleCkruCkteCli+CksuClh+CkuOCkrOCkruCkiOCkpuClh+Ckk+CksOCkhuCkruCkrOCkuOCkreCksOCkrOCkqOCkmuCksuCkruCkqOCkhuCkl+CkuOClgOCksuClgNi52YTZidil2YTZidmH2LDYp9ii2K7Ysdi52K/Yr9in2YTZidmH2LDZh9i12YjYsdi62YrYsdmD2KfZhtmI2YTYp9io2YrZhti52LHYttiw2YTZg9mH2YbYp9mK2YjZhdmC2KfZhNi52YTZitin2YbYp9mE2YPZhtit2KrZidmC2KjZhNmI2K3Yqdin2K7YsdmB2YLYt9i52KjYr9ix2YPZhtil2LDYp9mD2YXYp9in2K3Yr9il2YTYp9mB2YrZh9io2LnYttmD2YrZgdio2K3Yq9mI2YXZhtmI2YfZiNij2YbYp9is2K/Yp9mE2YfYp9iz2YTZhdi52YbYr9mE2YrYs9i52KjYsdi12YTZidmF2YbYsNio2YfYp9ij2YbZh9mF2KvZhNmD2YbYqtin2YTYp9it2YrYq9mF2LXYsdi02LHYrdit2YjZhNmI2YHZitin2LDYp9mE2YPZhNmF2LHYqdin2YbYqtin2YTZgdij2KjZiNiu2KfYtdij2YbYqtin2YbZh9in2YTZiti52LbZiNmI2YLYr9in2KjZhtiu2YrYsdio2YbYqtmE2YPZhdi02KfYodmI2YfZitin2KjZiNmC2LXYtdmI2YXYp9ix2YLZhdij2K3Yr9mG2K3Zhti52K/Zhdix2KPZitin2K3YqdmD2KrYqNiv2YjZhtmK2KzYqNmF2YbZh9iq2K3Yqtis2YfYqdiz2YbYqdmK2KrZhdmD2LHYqdi62LLYqdmG2YHYs9io2YrYqtmE2YTZh9mE2YbYp9iq2YTZg9mC2YTYqNmE2YXYp9i52YbZh9ij2YjZhNi02YrYodmG2YjYsdij2YXYp9mB2YrZg9io2YPZhNiw2KfYqtix2KrYqNio2KPZhtmH2YXYs9in2YbZg9io2YrYudmB2YLYr9it2LPZhtmE2YfZhdi02LnYsdij2YfZhNi02YfYsdmC2LfYsdi32YTYqHByb2ZpbGVzZXJ2aWNlZGVmYXVsdGhpbXNlbGZkZXRhaWxzY29udGVudHN1cHBvcnRzdGFydGVkbWVzc2FnZXN1Y2Nlc3NmYXNoaW9uPHRpdGxlPmNvdW50cnlhY2NvdW50Y3JlYXRlZHN0b3JpZXNyZXN1bHRzcnVubmluZ3Byb2Nlc3N3cml0aW5nb2JqZWN0c3Zpc2libGV3ZWxjb21lYXJ0aWNsZXVua25vd25uZXR3b3JrY29tcGFueWR5bmFtaWNicm93c2VycHJpdmFjeXByb2JsZW1TZXJ2aWNlcmVzcGVjdGRpc3BsYXlyZXF1ZXN0cmVzZXJ2ZXdlYnNpdGVoaXN0b3J5ZnJpZW5kc29wdGlvbnN3b3JraW5ndmVyc2lvbm1pbGxpb25jaGFubmVsd2luZG93LmFkZHJlc3N2aXNpdGVkd2VhdGhlcmNvcnJlY3Rwcm9kdWN0ZWRpcmVjdGZvcndhcmR5b3UgY2FucmVtb3ZlZHN1YmplY3Rjb250cm9sYXJjaGl2ZWN1cnJlbnRyZWFkaW5nbGlicmFyeWxpbWl0ZWRtYW5hZ2VyZnVydGhlcnN1bW1hcnltYWNoaW5lbWludXRlc3ByaXZhdGVjb250ZXh0cHJvZ3JhbXNvY2lldHludW1iZXJzd3JpdHRlbmVuYWJsZWR0cmlnZ2Vyc291cmNlc2xvYWRpbmdlbGVtZW50cGFydG5lcmZpbmFsbHlwZXJmZWN0bWVhbmluZ3N5c3RlbXNrZWVwaW5nY3VsdHVyZSZxdW90Oyxqb3VybmFscHJvamVjdHN1cmZhY2VzJnF1b3Q7ZXhwaXJlc3Jldmlld3NiYWxhbmNlRW5nbGlzaENvbnRlbnR0aHJvdWdoUGxlYXNlIG9waW5pb25jb250YWN0YXZlcmFnZXByaW1hcnl2aWxsYWdlU3BhbmlzaGdhbGxlcnlkZWNsaW5lbWVldGluZ21pc3Npb25wb3B1bGFycXVhbGl0eW1lYXN1cmVnZW5lcmFsc3BlY2llc3Nlc3Npb25zZWN0aW9ud3JpdGVyc2NvdW50ZXJpbml0aWFscmVwb3J0c2ZpZ3VyZXNtZW1iZXJzaG9sZGluZ2Rpc3B1dGVlYXJsaWVyZXhwcmVzc2RpZ2l0YWxwaWN0dXJlQW5vdGhlcm1hcnJpZWR0cmFmZmljbGVhZGluZ2NoYW5nZWRjZW50cmFsdmljdG9yeWltYWdlcy9yZWFzb25zc3R1ZGllc2ZlYXR1cmVsaXN0aW5nbXVzdCBiZXNjaG9vbHNWZXJzaW9udXN1YWxseWVwaXNvZGVwbGF5aW5nZ3Jvd2luZ29idmlvdXNvdmVybGF5cHJlc2VudGFjdGlvbnM8L3VsPg0Kd3JhcHBlcmFscmVhZHljZXJ0YWlucmVhbGl0eXN0b3JhZ2Vhbm90aGVyZGVza3RvcG9mZmVyZWRwYXR0ZXJudW51c3VhbERpZ2l0YWxjYXBpdGFsV2Vic2l0ZWZhaWx1cmVjb25uZWN0cmVkdWNlZEFuZHJvaWRkZWNhZGVzcmVndWxhciAmYW1wOyBhbmltYWxzcmVsZWFzZUF1dG9tYXRnZXR0aW5nbWV0aG9kc25vdGhpbmdQb3B1bGFyY2FwdGlvbmxldHRlcnNjYXB0dXJlc2NpZW5jZWxpY2Vuc2VjaGFuZ2VzRW5nbGFuZD0xJmFtcDtIaXN0b3J5ID0gbmV3IENlbnRyYWx1cGRhdGVkU3BlY2lhbE5ldHdvcmtyZXF1aXJlY29tbWVudHdhcm5pbmdDb2xsZWdldG9vbGJhcnJlbWFpbnNiZWNhdXNlZWxlY3RlZERldXRzY2hmaW5hbmNld29ya2Vyc3F1aWNrbHliZXR3ZWVuZXhhY3RseXNldHRpbmdkaXNlYXNlU29jaWV0eXdlYXBvbnNleGhpYml0Jmx0OyEtLUNvbnRyb2xjbGFzc2VzY292ZXJlZG91dGxpbmVhdHRhY2tzZGV2aWNlcyh3aW5kb3dwdXJwb3NldGl0bGU9Ik1vYmlsZSBraWxsaW5nc2hvd2luZ0l0YWxpYW5kcm9wcGVkaGVhdmlseWVmZmVjdHMtMSddKTsKY29uZmlybUN1cnJlbnRhZHZhbmNlc2hhcmluZ29wZW5pbmdkcmF3aW5nYmlsbGlvbm9yZGVyZWRHZXJtYW55cmVsYXRlZDwvZm9ybT5pbmNsdWRld2hldGhlcmRlZmluZWRTY2llbmNlY2F0YWxvZ0FydGljbGVidXR0b25zbGFyZ2VzdHVuaWZvcm1qb3VybmV5c2lkZWJhckNoaWNhZ29ob2xpZGF5R2VuZXJhbHBhc3NhZ2UsJnF1b3Q7YW5pbWF0ZWZlZWxpbmdhcnJpdmVkcGFzc2luZ25hdHVyYWxyb3VnaGx5LgoKVGhlIGJ1dCBub3RkZW5zaXR5QnJpdGFpbkNoaW5lc2VsYWNrIG9mdHJpYnV0ZUlyZWxhbmQiIGRhdGEtZmFjdG9yc3JlY2VpdmV0aGF0IGlzTGlicmFyeWh1c2JhbmRpbiBmYWN0YWZmYWlyc0NoYXJsZXNyYWRpY2FsYnJvdWdodGZpbmRpbmdsYW5kaW5nOmxhbmc9InJldHVybiBsZWFkZXJzcGxhbm5lZHByZW1pdW1wYWNrYWdlQW1lcmljYUVkaXRpb25dJnF1b3Q7TWVzc2FnZW5lZWQgdG92YWx1ZT0iY29tcGxleGxvb2tpbmdzdGF0aW9uYmVsaWV2ZXNtYWxsZXItbW9iaWxlcmVjb3Jkc3dhbnQgdG9raW5kIG9mRmlyZWZveHlvdSBhcmVzaW1pbGFyc3R1ZGllZG1heGltdW1oZWFkaW5ncmFwaWRseWNsaW1hdGVraW5nZG9tZW1lcmdlZGFtb3VudHNmb3VuZGVkcGlvbmVlcmZvcm11bGFkeW5hc3R5aG93IHRvIFN1cHBvcnRyZXZlbnVlZWNvbm9teVJlc3VsdHNicm90aGVyc29sZGllcmxhcmdlbHljYWxsaW5nLiZxdW90O0FjY291bnRFZHdhcmQgc2VnbWVudFJvYmVydCBlZmZvcnRzUGFjaWZpY2xlYXJuZWR1cCB3aXRoaGVpZ2h0OndlIGhhdmVBbmdlbGVzbmF0aW9uc19zZWFyY2hhcHBsaWVkYWNxdWlyZW1hc3NpdmVncmFudGVkOiBmYWxzZXRyZWF0ZWRiaWdnZXN0YmVuZWZpdGRyaXZpbmdTdHVkaWVzbWluaW11bXBlcmhhcHNtb3JuaW5nc2VsbGluZ2lzIHVzZWRyZXZlcnNldmFyaWFudCByb2xlPSJtaXNzaW5nYWNoaWV2ZXByb21vdGVzdHVkZW50c29tZW9uZWV4dHJlbWVyZXN0b3JlYm90dG9tOmV2b2x2ZWRhbGwgdGhlc2l0ZW1hcGVuZ2xpc2h3YXkgdG8gIEF1Z3VzdHN5bWJvbHNDb21wYW55bWF0dGVyc211c2ljYWxhZ2FpbnN0c2VydmluZ30pKCk7DQpwYXltZW50dHJvdWJsZWNvbmNlcHRjb21wYXJlcGFyZW50c3BsYXllcnNyZWdpb25zbW9uaXRvciAnJ1RoZSB3aW5uaW5nZXhwbG9yZWFkYXB0ZWRHYWxsZXJ5cHJvZHVjZWFiaWxpdHllbmhhbmNlY2FyZWVycykuIFRoZSBjb2xsZWN0U2VhcmNoIGFuY2llbnRleGlzdGVkZm9vdGVyIGhhbmRsZXJwcmludGVkY29uc29sZUVhc3Rlcm5leHBvcnRzd2luZG93c0NoYW5uZWxpbGxlZ2FsbmV1dHJhbHN1Z2dlc3RfaGVhZGVyc2lnbmluZy5odG1sIj5zZXR0bGVkd2VzdGVybmNhdXNpbmctd2Via2l0Y2xhaW1lZEp1c3RpY2VjaGFwdGVydmljdGltc1Rob21hcyBtb3ppbGxhcHJvbWlzZXBhcnRpZXNlZGl0aW9ub3V0c2lkZTpmYWxzZSxodW5kcmVkT2x5bXBpY19idXR0b25hdXRob3JzcmVhY2hlZGNocm9uaWNkZW1hbmRzc2Vjb25kc3Byb3RlY3RhZG9wdGVkcHJlcGFyZW5laXRoZXJncmVhdGx5Z3JlYXRlcm92ZXJhbGxpbXByb3ZlY29tbWFuZHNwZWNpYWxzZWFyY2gud29yc2hpcGZ1bmRpbmd0aG91Z2h0aGlnaGVzdGluc3RlYWR1dGlsaXR5cXVhcnRlckN1bHR1cmV0ZXN0aW5nY2xlYXJseWV4cG9zZWRCcm93c2VybGliZXJhbH0gY2F0Y2hQcm9qZWN0ZXhhbXBsZWhpZGUoKTtGbG9yaWRhYW5zd2Vyc2FsbG93ZWRFbXBlcm9yZGVmZW5zZXNlcmlvdXNmcmVlZG9tU2V2ZXJhbC1idXR0b25GdXJ0aGVyb3V0IG9mICE9IG51bGx0cmFpbmVkRGVubWFya3ZvaWQoMCkvYWxsLmpzcHJldmVudFJlcXVlc3RTdGVwaGVuCgpXaGVuIG9ic2VydmU8L2gyPg0KTW9kZXJuIHByb3ZpZGUiIGFsdD0iYm9yZGVycy4KCkZvciAKCk1hbnkgYXJ0aXN0c3Bvd2VyZWRwZXJmb3JtZmljdGlvbnR5cGUgb2ZtZWRpY2FsdGlja2V0c29wcG9zZWRDb3VuY2lsd2l0bmVzc2p1c3RpY2VHZW9yZ2UgQmVsZ2l1bS4uLjwvYT50d2l0dGVybm90YWJseXdhaXRpbmd3YXJmYXJlIE90aGVyIHJhbmtpbmdwaHJhc2VzbWVudGlvbnN1cnZpdmVzY2hvbGFyPC9wPg0KIENvdW50cnlpZ25vcmVkbG9zcyBvZmp1c3QgYXNHZW9yZ2lhc3RyYW5nZTxoZWFkPjxzdG9wcGVkMSddKTsNCmlzbGFuZHNub3RhYmxlYm9yZGVyOmxpc3Qgb2ZjYXJyaWVkMTAwLDAwMDwvaDM+CiBzZXZlcmFsYmVjb21lc3NlbGVjdCB3ZWRkaW5nMDAuaHRtbG1vbmFyY2hvZmYgdGhldGVhY2hlcmhpZ2hseSBiaW9sb2d5bGlmZSBvZm9yIGV2ZW5yaXNlIG9mJnJhcXVvO3BsdXNvbmVodW50aW5nKHRob3VnaERvdWdsYXNqb2luaW5nY2lyY2xlc0ZvciB0aGVBbmNpZW50VmlldG5hbXZlaGljbGVzdWNoIGFzY3J5c3RhbHZhbHVlID1XaW5kb3dzZW5qb3llZGEgc21hbGxhc3N1bWVkPGEgaWQ9ImZvcmVpZ24gQWxsIHJpaG93IHRoZURpc3BsYXlyZXRpcmVkaG93ZXZlcmhpZGRlbjtiYXR0bGVzc2Vla2luZ2NhYmluZXR3YXMgbm90bG9vayBhdGNvbmR1Y3RnZXQgdGhlSmFudWFyeWhhcHBlbnN0dXJuaW5nYTpob3Zlck9ubGluZSBGcmVuY2ggbGFja2luZ3R5cGljYWxleHRyYWN0ZW5lbWllc2V2ZW4gaWZnZW5lcmF0ZGVjaWRlZGFyZSBub3Qvc2VhcmNoYmVsaWVmcy1pbWFnZTpsb2NhdGVkc3RhdGljLmxvZ2luIj5jb252ZXJ0dmlvbGVudGVudGVyZWRmaXJzdCI+Y2lyY3VpdEZpbmxhbmRjaGVtaXN0c2hlIHdhczEwcHg7Ij5hcyBzdWNoZGl2aWRlZDwvc3Bhbj53aWxsIGJlbGluZSBvZmEgZ3JlYXRteXN0ZXJ5L2luZGV4LmZhbGxpbmdkdWUgdG8gcmFpbHdheWNvbGxlZ2Vtb25zdGVyZGVzY2VudGl0IHdpdGhudWNsZWFySmV3aXNoIHByb3Rlc3RCcml0aXNoZmxvd2Vyc3ByZWRpY3RyZWZvcm1zYnV0dG9uIHdobyB3YXNsZWN0dXJlaW5zdGFudHN1aWNpZGVnZW5lcmljcGVyaW9kc21hcmtldHNTb2NpYWwgZmlzaGluZ2NvbWJpbmVncmFwaGljd2lubmVyczxiciAvPjxieSB0aGUgTmF0dXJhbFByaXZhY3ljb29raWVzb3V0Y29tZXJlc29sdmVTd2VkaXNoYnJpZWZseVBlcnNpYW5zbyBtdWNoQ2VudHVyeWRlcGljdHNjb2x1bW5zaG91c2luZ3NjcmlwdHNuZXh0IHRvYmVhcmluZ21hcHBpbmdyZXZpc2VkalF1ZXJ5KC13aWR0aDp0aXRsZSI+dG9vbHRpcFNlY3Rpb25kZXNpZ25zVHVya2lzaHlvdW5nZXIubWF0Y2gofSkoKTsKCmJ1cm5pbmdvcGVyYXRlZGVncmVlc3NvdXJjZT1SaWNoYXJkY2xvc2VseXBsYXN0aWNlbnRyaWVzPC90cj4NCmNvbG9yOiN1bCBpZD0icG9zc2Vzc3JvbGxpbmdwaHlzaWNzZmFpbGluZ2V4ZWN1dGVjb250ZXN0bGluayB0b0RlZmF1bHQ8YnIgLz4KOiB0cnVlLGNoYXJ0ZXJ0b3VyaXNtY2xhc3NpY3Byb2NlZWRleHBsYWluPC9oMT4NCm9ubGluZS4/eG1sIHZlaGVscGluZ2RpYW1vbmR1c2UgdGhlYWlybGluZWVuZCAtLT4pLmF0dHIocmVhZGVyc2hvc3RpbmcjZmZmZmZmcmVhbGl6ZVZpbmNlbnRzaWduYWxzIHNyYz0iL1Byb2R1Y3RkZXNwaXRlZGl2ZXJzZXRlbGxpbmdQdWJsaWMgaGVsZCBpbkpvc2VwaCB0aGVhdHJlYWZmZWN0czxzdHlsZT5hIGxhcmdlZG9lc24ndGxhdGVyLCBFbGVtZW50ZmF2aWNvbmNyZWF0b3JIdW5nYXJ5QWlycG9ydHNlZSB0aGVzbyB0aGF0TWljaGFlbFN5c3RlbXNQcm9ncmFtcywgYW5kICB3aWR0aD1lJnF1b3Q7dHJhZGluZ2xlZnQiPgpwZXJzb25zR29sZGVuIEFmZmFpcnNncmFtbWFyZm9ybWluZ2Rlc3Ryb3lpZGVhIG9mY2FzZSBvZm9sZGVzdCB0aGlzIGlzLnNyYyA9IGNhcnRvb25yZWdpc3RyQ29tbW9uc011c2xpbXNXaGF0IGlzaW4gbWFueW1hcmtpbmdyZXZlYWxzSW5kZWVkLGVxdWFsbHkvc2hvd19hb3V0ZG9vcmVzY2FwZShBdXN0cmlhZ2VuZXRpY3N5c3RlbSxJbiB0aGUgc2l0dGluZ0hlIGFsc29Jc2xhbmRzQWNhZGVteQoJCTwhLS1EYW5pZWwgYmluZGluZ2Jsb2NrIj5pbXBvc2VkdXRpbGl6ZUFicmFoYW0oZXhjZXB0e3dpZHRoOnB1dHRpbmcpLmh0bWwofHwgW107CkRBVEFbICpraXRjaGVubW91bnRlZGFjdHVhbCBkaWFsZWN0bWFpbmx5IF9ibGFuaydpbnN0YWxsZXhwZXJ0c2lmKHR5cGVJdCBhbHNvJmNvcHk7ICI+VGVybXNib3JuIGluT3B0aW9uc2Vhc3Rlcm50YWxraW5nY29uY2VybmdhaW5lZCBvbmdvaW5nanVzdGlmeWNyaXRpY3NmYWN0b3J5aXRzIG93bmFzc2F1bHRpbnZpdGVkbGFzdGluZ2hpcyBvd25ocmVmPSIvIiByZWw9ImRldmVsb3Bjb25jZXJ0ZGlhZ3JhbWRvbGxhcnNjbHVzdGVycGhwP2lkPWFsY29ob2wpO30pKCk7dXNpbmcgYT48c3Bhbj52ZXNzZWxzcmV2aXZhbEFkZHJlc3NhbWF0ZXVyYW5kcm9pZGFsbGVnZWRpbGxuZXNzd2Fsa2luZ2NlbnRlcnNxdWFsaWZ5bWF0Y2hlc3VuaWZpZWRleHRpbmN0RGVmZW5zZWRpZWQgaW4KCTwhLS0gY3VzdG9tc2xpbmtpbmdMaXR0bGUgQm9vayBvZmV2ZW5pbmdtaW4uanM/YXJlIHRoZWtvbnRha3R0b2RheSdzLmh0bWwiIHRhcmdldD13ZWFyaW5nQWxsIFJpZzsKfSkoKTtyYWlzaW5nIEFsc28sIGNydWNpYWxhYm91dCI+ZGVjbGFyZS0tPgo8c2NmaXJlZm94YXMgbXVjaGFwcGxpZXNpbmRleCwgcywgYnV0IHR5cGUgPSAKDQo8IS0tdG93YXJkc1JlY29yZHNQcml2YXRlRm9yZWlnblByZW1pZXJjaG9pY2VzVmlydHVhbHJldHVybnNDb21tZW50UG93ZXJlZGlubGluZTtwb3ZlcnR5Y2hhbWJlckxpdmluZyB2b2x1bWVzQW50aG9ueWxvZ2luIiBSZWxhdGVkRWNvbm9teXJlYWNoZXNjdXR0aW5nZ3Jhdml0eWxpZmUgaW5DaGFwdGVyLXNoYWRvd05vdGFibGU8L3RkPg0KIHJldHVybnN0YWRpdW13aWRnZXRzdmFyeWluZ3RyYXZlbHNoZWxkIGJ5d2hvIGFyZXdvcmsgaW5mYWN1bHR5YW5ndWxhcndobyBoYWRhaXJwb3J0dG93biBvZgoKU29tZSAnY2xpY2snY2hhcmdlc2tleXdvcmRpdCB3aWxsY2l0eSBvZih0aGlzKTtBbmRyZXcgdW5pcXVlIGNoZWNrZWRvciBtb3JlMzAwcHg7IHJldHVybjtyc2lvbj0icGx1Z2luc3dpdGhpbiBoZXJzZWxmU3RhdGlvbkZlZGVyYWx2ZW50dXJlcHVibGlzaHNlbnQgdG90ZW5zaW9uYWN0cmVzc2NvbWUgdG9maW5nZXJzRHVrZSBvZnBlb3BsZSxleHBsb2l0d2hhdCBpc2hhcm1vbnlhIG1ham9yIjoiaHR0cGluIGhpcyBtZW51Ij4KbW9udGhseW9mZmljZXJjb3VuY2lsZ2FpbmluZ2V2ZW4gaW5TdW1tYXJ5ZGF0ZSBvZmxveWFsdHlmaXRuZXNzYW5kIHdhc2VtcGVyb3JzdXByZW1lU2Vjb25kIGhlYXJpbmdSdXNzaWFubG9uZ2VzdEFsYmVydGFsYXRlcmFsc2V0IG9mIHNtYWxsIj4uYXBwZW5kZG8gd2l0aGZlZGVyYWxiYW5rIG9mYmVuZWF0aERlc3BpdGVDYXBpdGFsZ3JvdW5kcyksIGFuZCBwZXJjZW50aXQgZnJvbWNsb3Npbmdjb250YWluSW5zdGVhZGZpZnRlZW5hcyB3ZWxsLnlhaG9vLnJlc3BvbmRmaWdodGVyb2JzY3VyZXJlZmxlY3RvcmdhbmljPSBNYXRoLmVkaXRpbmdvbmxpbmUgcGFkZGluZ2Egd2hvbGVvbmVycm9yeWVhciBvZmVuZCBvZiBiYXJyaWVyd2hlbiBpdGhlYWRlciBob21lIG9mcmVzdW1lZHJlbmFtZWRzdHJvbmc+aGVhdGluZ3JldGFpbnNjbG91ZGZyd2F5IG9mIE1hcmNoIDFrbm93aW5naW4gcGFydEJldHdlZW5sZXNzb25zY2xvc2VzdHZpcnR1YWxsaW5rcyI+Y3Jvc3NlZEVORCAtLT5mYW1vdXMgYXdhcmRlZExpY2Vuc2VIZWFsdGggZmFpcmx5IHdlYWx0aHltaW5pbWFsQWZyaWNhbmNvbXBldGVsYWJlbCI+c2luZ2luZ2Zhcm1lcnNCcmFzaWwpZGlzY3Vzc3JlcGxhY2VHcmVnb3J5Zm9udCBjb3B1cnN1ZWRhcHBlYXJzbWFrZSB1cHJvdW5kZWRib3RoIG9mYmxvY2tlZHNhdyB0aGVvZmZpY2VzY29sb3Vyc2lmKGRvY3V3aGVuIGhlZW5mb3JjZXB1c2goZnVBdWd1c3QgVVRGLTgiPkZhbnRhc3lpbiBtb3N0aW5qdXJlZFVzdWFsbHlmYXJtaW5nY2xvc3VyZW9iamVjdCBkZWZlbmNldXNlIG9mIE1lZGljYWw8Ym9keT4KZXZpZGVudGJlIHVzZWRrZXlDb2Rlc2l4dGVlbklzbGFtaWMjMDAwMDAwZW50aXJlIHdpZGVseSBhY3RpdmUgKHR5cGVvZm9uZSBjYW5jb2xvciA9c3BlYWtlcmV4dGVuZHNQaHlzaWNzdGVycmFpbjx0Ym9keT5mdW5lcmFsdmlld2luZ21pZGRsZSBjcmlja2V0cHJvcGhldHNoaWZ0ZWRkb2N0b3JzUnVzc2VsbCB0YXJnZXRjb21wYWN0YWxnZWJyYXNvY2lhbC1idWxrIG9mbWFuIGFuZDwvdGQ+CiBoZSBsZWZ0KS52YWwoKWZhbHNlKTtsb2dpY2FsYmFua2luZ2hvbWUgdG9uYW1pbmcgQXJpem9uYWNyZWRpdHMpOwp9KTsKZm91bmRlcmluIHR1cm5Db2xsaW5zYmVmb3JlIEJ1dCB0aGVjaGFyZ2VkVGl0bGUiPkNhcHRhaW5zcGVsbGVkZ29kZGVzc1RhZyAtLT5BZGRpbmc6YnV0IHdhc1JlY2VudCBwYXRpZW50YmFjayBpbj1mYWxzZSZMaW5jb2xud2Uga25vd0NvdW50ZXJKdWRhaXNtc2NyaXB0IGFsdGVyZWQnXSk7CiAgaGFzIHRoZXVuY2xlYXJFdmVudCcsYm90aCBpbm5vdCBhbGwKCjwhLS0gcGxhY2luZ2hhcmQgdG8gY2VudGVyc29ydCBvZmNsaWVudHNzdHJlZXRzQmVybmFyZGFzc2VydHN0ZW5kIHRvZmFudGFzeWRvd24gaW5oYXJib3VyRnJlZWRvbWpld2VscnkvYWJvdXQuLnNlYXJjaGxlZ2VuZHNpcyBtYWRlbW9kZXJuIG9ubHkgb25vbmx5IHRvaW1hZ2UiIGxpbmVhciBwYWludGVyYW5kIG5vdHJhcmVseSBhY3JvbnltZGVsaXZlcnNob3J0ZXIwMCZhbXA7YXMgbWFueXdpZHRoPSIvKiA8IVtDdGl0bGUgPW9mIHRoZSBsb3dlc3QgcGlja2VkIGVzY2FwZWR1c2VzIG9mcGVvcGxlcyBQdWJsaWNNYXR0aGV3dGFjdGljc2RhbWFnZWR3YXkgZm9ybGF3cyBvZmVhc3kgdG8gd2luZG93c3Ryb25nICBzaW1wbGV9Y2F0Y2goc2V2ZW50aGluZm9ib3h3ZW50IHRvcGFpbnRlZGNpdGl6ZW5JIGRvbid0cmV0cmVhdC4gU29tZSB3dy4iKTsKYm9tYmluZ21haWx0bzptYWRlIGluLiBNYW55IGNhcnJpZXN8fHt9O3dpd29yayBvZnN5bm9ueW1kZWZlYXRzZmF2b3JlZG9wdGljYWxwYWdlVHJhdW5sZXNzIHNlbmRpbmdsZWZ0Ij48Y29tU2NvckFsbCB0aGVqUXVlcnkudG91cmlzdENsYXNzaWNmYWxzZSIgV2lsaGVsbXN1YnVyYnNnZW51aW5lYmlzaG9wcy5zcGxpdChnbG9iYWwgZm9sbG93c2JvZHkgb2Zub21pbmFsQ29udGFjdHNlY3VsYXJsZWZ0IHRvY2hpZWZseS1oaWRkZW4tYmFubmVyPC9saT4KCi4gV2hlbiBpbiBib3RoZGlzbWlzc0V4cGxvcmVhbHdheXMgdmlhIHRoZXNwYcOxb2x3ZWxmYXJlcnVsaW5nIGFycmFuZ2VjYXB0YWluaGlzIHNvbnJ1bGUgb2ZoZSB0b29raXRzZWxmLD0wJmFtcDsoY2FsbGVkc2FtcGxlc3RvIG1ha2Vjb20vcGFnTWFydGluIEtlbm5lZHlhY2NlcHRzZnVsbCBvZmhhbmRsZWRCZXNpZGVzLy8tLT48L2FibGUgdG90YXJnZXRzZXNzZW5jZWhpbSB0byBpdHMgYnkgY29tbW9uLm1pbmVyYWx0byB0YWtld2F5cyB0b3Mub3JnL2xhZHZpc2VkcGVuYWx0eXNpbXBsZTppZiB0aGV5TGV0dGVyc2Egc2hvcnRIZXJiZXJ0c3RyaWtlcyBncm91cHMubGVuZ3RoZmxpZ2h0c292ZXJsYXBzbG93bHkgbGVzc2VyIHNvY2lhbCA8L3A+CgkJaXQgaW50b3JhbmtlZCByYXRlIG9mdWw+DQogIGF0dGVtcHRwYWlyIG9mbWFrZSBpdEtvbnRha3RBbnRvbmlvaGF2aW5nIHJhdGluZ3MgYWN0aXZlc3RyZWFtc3RyYXBwZWQiKS5jc3MoaG9zdGlsZWxlYWQgdG9saXR0bGUgZ3JvdXBzLFBpY3R1cmUtLT4NCg0KIHJvd3M9IiBvYmplY3RpbnZlcnNlPGZvb3RlckN1c3RvbVY+PFwvc2Nyc29sdmluZ0NoYW1iZXJzbGF2ZXJ5d291bmRlZHdoZXJlYXMhPSAndW5kZm9yIGFsbHBhcnRseSAtcmlnaHQ6QXJhYmlhbmJhY2tlZCBjZW50dXJ5dW5pdCBvZm1vYmlsZS1FdXJvcGUsaXMgaG9tZXJpc2sgb2ZkZXNpcmVkQ2xpbnRvbmNvc3Qgb2ZhZ2Ugb2YgYmVjb21lIG5vbmUgb2ZwJnF1b3Q7TWlkZGxlIGVhZCcpWzBDcml0aWNzc3R1ZGlvcz4mY29weTtncm91cCI+YXNzZW1ibG1ha2luZyBwcmVzc2Vkd2lkZ2V0LnBzOiIgPyByZWJ1aWx0Ynkgc29tZUZvcm1lciBlZGl0b3JzZGVsYXllZENhbm9uaWNoYWQgdGhlcHVzaGluZ2NsYXNzPSJidXQgYXJlcGFydGlhbEJhYnlsb25ib3R0b20gY2FycmllckNvbW1hbmRpdHMgdXNlQXMgd2l0aGNvdXJzZXNhIHRoaXJkZGVub3Rlc2Fsc28gaW5Ib3VzdG9uMjBweDsiPmFjY3VzZWRkb3VibGUgZ29hbCBvZkZhbW91cyApLmJpbmQocHJpZXN0cyBPbmxpbmVpbiBKdWx5c3QgKyAiZ2NvbnN1bHRkZWNpbWFsaGVscGZ1bHJldml2ZWRpcyB2ZXJ5cicrJ2lwdGxvc2luZyBmZW1hbGVzaXMgYWxzb3N0cmluZ3NkYXlzIG9mYXJyaXZhbGZ1dHVyZSA8b2JqZWN0Zm9yY2luZ1N0cmluZygiIC8+CgkJaGVyZSBpc2VuY29kZWQuICBUaGUgYmFsbG9vbmRvbmUgYnkvY29tbW9uYmdjb2xvcmxhdyBvZiBJbmRpYW5hYXZvaWRlZGJ1dCB0aGUycHggM3B4anF1ZXJ5LmFmdGVyIGFwb2xpY3kubWVuIGFuZGZvb3Rlci09IHRydWU7Zm9yIHVzZXNjcmVlbi5JbmRpYW4gaW1hZ2UgPWZhbWlseSxodHRwOi8vICZuYnNwO2RyaXZlcnNldGVybmFsc2FtZSBhc25vdGljZWR2aWV3ZXJzfSkoKTsKIGlzIG1vcmVzZWFzb25zZm9ybWVyIHRoZSBuZXdpcyBqdXN0Y29uc2VudCBTZWFyY2h3YXMgdGhld2h5IHRoZXNoaXBwZWRicj48YnI+d2lkdGg6IGhlaWdodD1tYWRlIG9mY3Vpc2luZWlzIHRoYXRhIHZlcnkgQWRtaXJhbCBmaXhlZDtub3JtYWwgTWlzc2lvblByZXNzLCBvbnRhcmlvY2hhcnNldHRyeSB0byBpbnZhZGVkPSJ0cnVlInNwYWNpbmdpcyBtb3N0YSBtb3JlIHRvdGFsbHlmYWxsIG9mfSk7DQogIGltbWVuc2V0aW1lIGluc2V0IG91dHNhdGlzZnl0byBmaW5kZG93biB0b2xvdCBvZiBQbGF5ZXJzaW4gSnVuZXF1YW50dW1ub3QgdGhldGltZSB0b2Rpc3RhbnRGaW5uaXNoc3JjID0gKHNpbmdsZSBoZWxwIG9mR2VybWFuIGxhdyBhbmRsYWJlbGVkZm9yZXN0c2Nvb2tpbmdzcGFjZSI+aGVhZGVyLXdlbGwgYXNTdGFubGV5YnJpZGdlcy9nbG9iYWxDcm9hdGlhIEFib3V0IFswXTsKICBpdCwgYW5kZ3JvdXBlZGJlaW5nIGEpe3Rocm93aGUgbWFkZWxpZ2h0ZXJldGhpY2FsRkZGRkZGImJvdHRvbSJsaWtlIGEgZW1wbG95c2xpdmUgaW5hcyBzZWVucHJpbnRlcm1vc3Qgb2Z1Yi1saW5rcmVqZWN0c2FuZCB1c2VpbWFnZSI+c3VjY2VlZGZlZWRpbmdOdWNsZWFyaW5mb3JtYXRvIGhlbHBXb21lbidzTmVpdGhlck1leGljYW5wcm90ZWluPHRhYmxlIGJ5IG1hbnloZWFsdGh5bGF3c3VpdGRldmlzZWQucHVzaCh7c2VsbGVyc3NpbXBseSBUaHJvdWdoLmNvb2tpZSBJbWFnZShvbGRlciI+dXMuanMiPiBTaW5jZSB1bml2ZXJzbGFyZ2VyIG9wZW4gdG8hLS0gZW5kbGllcyBpbiddKTsNCiAgbWFya2V0d2hvIGlzICgiRE9NQ29tYW5hZ2Vkb25lIGZvcnR5cGVvZiBLaW5nZG9tcHJvZml0c3Byb3Bvc2V0byBzaG93Y2VudGVyO21hZGUgaXRkcmVzc2Vkd2VyZSBpbm1peHR1cmVwcmVjaXNlYXJpc2luZ3NyYyA9ICdtYWtlIGEgc2VjdXJlZEJhcHRpc3R2b3RpbmcgCgkJdmFyIE1hcmNoIDJncmV3IHVwQ2xpbWF0ZS5yZW1vdmVza2lsbGVkd2F5IHRoZTwvaGVhZD5mYWNlIG9mYWN0aW5nIHJpZ2h0Ij50byB3b3JrcmVkdWNlc2hhcyBoYWRlcmVjdGVkc2hvdygpO2FjdGlvbj1ib29rIG9mYW4gYXJlYT09ICJodHQ8aGVhZGVyCjxodG1sPmNvbmZvcm1mYWNpbmcgY29va2llLnJlbHkgb25ob3N0ZWQgLmN1c3RvbWhlIHdlbnRidXQgZm9yc3ByZWFkIEZhbWlseSBhIG1lYW5zb3V0IHRoZWZvcnVtcy5mb290YWdlIj5Nb2JpbENsZW1lbnRzIiBpZD0iYXMgaGlnaGludGVuc2UtLT48IS0tZmVtYWxlIGlzIHNlZW5pbXBsaWVkc2V0IHRoZWEgc3RhdGVhbmQgaGlzZmFzdGVzdGJlc2lkZXNidXR0b25fYm91bmRlZCI+PGltZyBJbmZvYm94ZXZlbnRzLGEgeW91bmdhbmQgYXJlTmF0aXZlIGNoZWFwZXJUaW1lb3V0YW5kIGhhc2VuZ2luZXN3b24gdGhlKG1vc3RseXJpZ2h0OiBmaW5kIGEgLWJvdHRvbVByaW5jZSBhcmVhIG9mbW9yZSBvZnNlYXJjaF9uYXR1cmUsbGVnYWxseXBlcmlvZCxsYW5kIG9mb3Igd2l0aGluZHVjZWRwcm92aW5nbWlzc2lsZWxvY2FsbHlBZ2FpbnN0dGhlIHdheWsmcXVvdDtweDsiPg0KcHVzaGVkIGFiYW5kb25udW1lcmFsQ2VydGFpbkluIHRoaXNtb3JlIGlub3Igc29tZW5hbWUgaXNhbmQsIGluY3Jvd25lZElTQk4gMC1jcmVhdGVzT2N0b2Jlcm1heSBub3RjZW50ZXIgbGF0ZSBpbkRlZmVuY2VlbmFjdGVkd2lzaCB0b2Jyb2FkbHljb29saW5nb25sb2FkPWl0LiBUaGVyZWNvdmVyTWVtYmVyc2hlaWdodCBhc3N1bWVzPGh0bWw+CnBlb3BsZS5pbiBvbmUgPXdpbmRvd2Zvb3Rlcl9hIGdvb2QgcmVrbGFtYW90aGVycyx0byB0aGlzX2Nvb2tpZXBhbmVsIj5Mb25kb24sZGVmaW5lc2NydXNoZWRiYXB0aXNtY29hc3RhbHN0YXR1cyB0aXRsZSIgbW92ZSB0b2xvc3QgaW5iZXR0ZXIgaW1wbGllc3JpdmFscnlzZXJ2ZXJzIFN5c3RlbVBlcmhhcHNlcyBhbmQgY29udGVuZGZsb3dpbmdsYXN0ZWQgcmlzZSBpbkdlbmVzaXN2aWV3IG9mcmlzaW5nIHNlZW0gdG9idXQgaW4gYmFja2luZ2hlIHdpbGxnaXZlbiBhZ2l2aW5nIGNpdGllcy5mbG93IG9mIExhdGVyIGFsbCBidXRIaWdod2F5b25seSBieXNpZ24gb2ZoZSBkb2VzZGlmZmVyc2JhdHRlcnkmYW1wO2xhc2luZ2xlc3RocmVhdHNpbnRlZ2VydGFrZSBvbnJlZnVzZWRjYWxsZWQgPVVTJmFtcFNlZSB0aGVuYXRpdmVzYnkgdGhpc3N5c3RlbS5oZWFkIG9mOmhvdmVyLGxlc2JpYW5zdXJuYW1lYW5kIGFsbGNvbW1vbi9oZWFkZXJfX3BhcmFtc0hhcnZhcmQvcGl4ZWwucmVtb3ZhbHNvIGxvbmdyb2xlIG9mam9pbnRseXNreXNjcmFVbmljb2RlYnIgLz4NCkF0bGFudGFudWNsZXVzQ291bnR5LHB1cmVseSBjb3VudCI+ZWFzaWx5IGJ1aWxkIGFvbmNsaWNrYSBnaXZlbnBvaW50ZXJoJnF1b3Q7ZXZlbnRzIGVsc2UgewpkaXRpb25zbm93IHRoZSwgd2l0aCBtYW4gd2hvb3JnL1dlYm9uZSBhbmRjYXZhbHJ5SGUgZGllZHNlYXR0bGUwMCwwMDAge3dpbmRvd2hhdmUgdG9pZih3aW5kYW5kIGl0c3NvbGVseSBtJnF1b3Q7cmVuZXdlZERldHJvaXRhbW9uZ3N0ZWl0aGVyIHRoZW0gaW5TZW5hdG9yVXM8L2E+PEtpbmcgb2ZGcmFuY2lzLXByb2R1Y2hlIHVzZWRhcnQgYW5kaGltIGFuZHVzZWQgYnlzY29yaW5nYXQgaG9tZXRvIGhhdmVyZWxhdGVzaWJpbGl0eWZhY3Rpb25CdWZmYWxvbGluayI+PHdoYXQgaGVmcmVlIHRvQ2l0eSBvZmNvbWUgaW5zZWN0b3JzY291bnRlZG9uZSBkYXluZXJ2b3Vzc3F1YXJlIH07aWYoZ29pbiB3aGF0aW1nIiBhbGlzIG9ubHlzZWFyY2gvdHVlc2RheWxvb3NlbHlTb2xvbW9uc2V4dWFsIC0gPGEgaHJtZWRpdW0iRE8gTk9UIEZyYW5jZSx3aXRoIGEgd2FyIGFuZHNlY29uZCB0YWtlIGEgPg0KDQoNCm1hcmtldC5oaWdod2F5ZG9uZSBpbmN0aXZpdHkibGFzdCI+b2JsaWdlZHJpc2UgdG8idW5kZWZpbWFkZSB0byBFYXJseSBwcmFpc2VkaW4gaXRzIGZvciBoaXNhdGhsZXRlSnVwaXRlcllhaG9vISB0ZXJtZWQgc28gbWFueXJlYWxseSBzLiBUaGUgYSB3b21hbj92YWx1ZT1kaXJlY3QgcmlnaHQiIGJpY3ljbGVhY2luZz0iZGF5IGFuZHN0YXRpbmdSYXRoZXIsaGlnaGVyIE9mZmljZSBhcmUgbm93dGltZXMsIHdoZW4gYSBwYXkgZm9yb24gdGhpcy1saW5rIj47Ym9yZGVyYXJvdW5kIGFubnVhbCB0aGUgTmV3cHV0IHRoZS5jb20iIHRha2luIHRvYSBicmllZihpbiB0aGVncm91cHMuOyB3aWR0aGVuenltZXNzaW1wbGUgaW4gbGF0ZXtyZXR1cm50aGVyYXB5YSBwb2ludGJhbm5pbmdpbmtzIj4KKCk7IiByZWEgcGxhY2VcdTAwM0NhYWJvdXQgYXRyPg0KCQljY291bnQgZ2l2ZXMgYTxTQ1JJUFRSYWlsd2F5dGhlbWVzL3Rvb2xib3hCeUlkKCJ4aHVtYW5zLHdhdGNoZXNpbiBzb21lIGlmICh3aWNvbWluZyBmb3JtYXRzIFVuZGVyIGJ1dCBoYXNoYW5kZWQgbWFkZSBieXRoYW4gaW5mZWFyIG9mZGVub3RlZC9pZnJhbWVsZWZ0IGludm9sdGFnZWluIGVhY2hhJnF1b3Q7YmFzZSBvZkluIG1hbnl1bmRlcmdvcmVnaW1lc2FjdGlvbiA8L3A+DQo8dXN0b21WYTsmZ3Q7PC9pbXBvcnRzb3IgdGhhdG1vc3RseSAmYW1wO3JlIHNpemU9IjwvYT48L2hhIGNsYXNzcGFzc2l2ZUhvc3QgPSBXaGV0aGVyZmVydGlsZVZhcmlvdXM9W107KGZ1Y2FtZXJhcy8+PC90ZD5hY3RzIGFzSW4gc29tZT4NCg0KPCFvcmdhbmlzIDxiciAvPkJlaWppbmdjYXRhbMOgZGV1dHNjaGV1cm9wZXVldXNrYXJhZ2FlaWxnZXN2ZW5za2Flc3Bhw7FhbWVuc2FqZXVzdWFyaW90cmFiYWpvbcOpeGljb3DDoWdpbmFzaWVtcHJlc2lzdGVtYW9jdHVicmVkdXJhbnRlYcOxYWRpcmVtcHJlc2Ftb21lbnRvbnVlc3Ryb3ByaW1lcmF0cmF2w6lzZ3JhY2lhc251ZXN0cmFwcm9jZXNvZXN0YWRvc2NhbGlkYWRwZXJzb25hbsO6bWVyb2FjdWVyZG9tw7pzaWNhbWllbWJyb29mZXJ0YXNhbGd1bm9zcGHDrXNlc2VqZW1wbG9kZXJlY2hvYWRlbcOhc3ByaXZhZG9hZ3JlZ2FyZW5sYWNlc3Bvc2libGVob3RlbGVzc2V2aWxsYXByaW1lcm/Dumx0aW1vZXZlbnRvc2FyY2hpdm9jdWx0dXJhbXVqZXJlc2VudHJhZGFhbnVuY2lvZW1iYXJnb21lcmNhZG9ncmFuZGVzZXN0dWRpb21lam9yZXNmZWJyZXJvZGlzZcOxb3R1cmlzbW9jw7NkaWdvcG9ydGFkYWVzcGFjaW9mYW1pbGlhYW50b25pb3Blcm1pdGVndWFyZGFyYWxndW5hc3ByZWNpb3NhbGd1aWVuc2VudGlkb3Zpc2l0YXN0w610dWxvY29ub2NlcnNlZ3VuZG9jb25zZWpvZnJhbmNpYW1pbnV0b3NzZWd1bmRhdGVuZW1vc2VmZWN0b3Ntw6FsYWdhc2VzacOzbnJldmlzdGFncmFuYWRhY29tcHJhcmluZ3Jlc29nYXJjw61hYWNjacOzbmVjdWFkb3JxdWllbmVzaW5jbHVzb2RlYmVyw6FtYXRlcmlhaG9tYnJlc211ZXN0cmFwb2Ryw61hbWHDsWFuYcO6bHRpbWFlc3RhbW9zb2ZpY2lhbHRhbWJpZW5uaW5nw7puc2FsdWRvc3BvZGVtb3NtZWpvcmFycG9zaXRpb25idXNpbmVzc2hvbWVwYWdlc2VjdXJpdHlsYW5ndWFnZXN0YW5kYXJkY2FtcGFpZ25mZWF0dXJlc2NhdGVnb3J5ZXh0ZXJuYWxjaGlsZHJlbnJlc2VydmVkcmVzZWFyY2hleGNoYW5nZWZhdm9yaXRldGVtcGxhdGVtaWxpdGFyeWluZHVzdHJ5c2VydmljZXNtYXRlcmlhbHByb2R1Y3Rzei1pbmRleDpjb21tZW50c3NvZnR3YXJlY29tcGxldGVjYWxlbmRhcnBsYXRmb3JtYXJ0aWNsZXNyZXF1aXJlZG1vdmVtZW50cXVlc3Rpb25idWlsZGluZ3BvbGl0aWNzcG9zc2libGVyZWxpZ2lvbnBoeXNpY2FsZmVlZGJhY2tyZWdpc3RlcnBpY3R1cmVzZGlzYWJsZWRwcm90b2NvbGF1ZGllbmNlc2V0dGluZ3NhY3Rpdml0eWVsZW1lbnRzbGVhcm5pbmdhbnl0aGluZ2Fic3RyYWN0cHJvZ3Jlc3NvdmVydmlld21hZ2F6aW5lZWNvbm9taWN0cmFpbmluZ3ByZXNzdXJldmFyaW91cyA8c3Ryb25nPnByb3BlcnR5c2hvcHBpbmd0b2dldGhlcmFkdmFuY2VkYmVoYXZpb3Jkb3dubG9hZGZlYXR1cmVkZm9vdGJhbGxzZWxlY3RlZExhbmd1YWdlZGlzdGFuY2VyZW1lbWJlcnRyYWNraW5ncGFzc3dvcmRtb2RpZmllZHN0dWRlbnRzZGlyZWN0bHlmaWdodGluZ25vcnRoZXJuZGF0YWJhc2VmZXN0aXZhbGJyZWFraW5nbG9jYXRpb25pbnRlcm5ldGRyb3Bkb3ducHJhY3RpY2VldmlkZW5jZWZ1bmN0aW9ubWFycmlhZ2VyZXNwb25zZXByb2JsZW1zbmVnYXRpdmVwcm9ncmFtc2FuYWx5c2lzcmVsZWFzZWRiYW5uZXIiPnB1cmNoYXNlcG9saWNpZXNyZWdpb25hbGNyZWF0aXZlYXJndW1lbnRib29rbWFya3JlZmVycmVyY2hlbWljYWxkaXZpc2lvbmNhbGxiYWNrc2VwYXJhdGVwcm9qZWN0c2NvbmZsaWN0aGFyZHdhcmVpbnRlcmVzdGRlbGl2ZXJ5bW91bnRhaW5vYnRhaW5lZD0gZmFsc2U7Zm9yKHZhciBhY2NlcHRlZGNhcGFjaXR5Y29tcHV0ZXJpZGVudGl0eWFpcmNyYWZ0ZW1wbG95ZWRwcm9wb3NlZGRvbWVzdGljaW5jbHVkZXNwcm92aWRlZGhvc3BpdGFsdmVydGljYWxjb2xsYXBzZWFwcHJvYWNocGFydG5lcnNsb2dvIj48YWRhdWdodGVyYXV0aG9yIiBjdWx0dXJhbGZhbWlsaWVzL2ltYWdlcy9hc3NlbWJseXBvd2VyZnVsdGVhY2hpbmdmaW5pc2hlZGRpc3RyaWN0Y3JpdGljYWxjZ2ktYmluL3B1cnBvc2VzcmVxdWlyZXNlbGVjdGlvbmJlY29taW5ncHJvdmlkZXNhY2FkZW1pY2V4ZXJjaXNlYWN0dWFsbHltZWRpY2luZWNvbnN0YW50YWNjaWRlbnRNYWdhemluZWRvY3VtZW50c3RhcnRpbmdib3R0b20iPm9ic2VydmVkOiAmcXVvdDtleHRlbmRlZHByZXZpb3VzU29mdHdhcmVjdXN0b21lcmRlY2lzaW9uc3RyZW5ndGhkZXRhaWxlZHNsaWdodGx5cGxhbm5pbmd0ZXh0YXJlYWN1cnJlbmN5ZXZlcnlvbmVzdHJhaWdodHRyYW5zZmVycG9zaXRpdmVwcm9kdWNlZGhlcml0YWdlc2hpcHBpbmdhYnNvbHV0ZXJlY2VpdmVkcmVsZXZhbnRidXR0b24iIHZpb2xlbmNlYW55d2hlcmViZW5lZml0c2xhdW5jaGVkcmVjZW50bHlhbGxpYW5jZWZvbGxvd2VkbXVsdGlwbGVidWxsZXRpbmluY2x1ZGVkb2NjdXJyZWRpbnRlcm5hbCQodGhpcykucmVwdWJsaWM+PHRyPjx0ZGNvbmdyZXNzcmVjb3JkZWR1bHRpbWF0ZXNvbHV0aW9uPHVsIGlkPSJkaXNjb3ZlckhvbWU8L2E+d2Vic2l0ZXNuZXR3b3Jrc2FsdGhvdWdoZW50aXJlbHltZW1vcmlhbG1lc3NhZ2VzY29udGludWVhY3RpdmUiPnNvbWV3aGF0dmljdG9yaWFXZXN0ZXJuICB0aXRsZT0iTG9jYXRpb25jb250cmFjdHZpc2l0b3JzRG93bmxvYWR3aXRob3V0IHJpZ2h0Ij4KbWVhc3VyZXN3aWR0aCA9IHZhcmlhYmxlaW52b2x2ZWR2aXJnaW5pYW5vcm1hbGx5aGFwcGVuZWRhY2NvdW50c3N0YW5kaW5nbmF0aW9uYWxSZWdpc3RlcnByZXBhcmVkY29udHJvbHNhY2N1cmF0ZWJpcnRoZGF5c3RyYXRlZ3lvZmZpY2lhbGdyYXBoaWNzY3JpbWluYWxwb3NzaWJseWNvbnN1bWVyUGVyc29uYWxzcGVha2luZ3ZhbGlkYXRlYWNoaWV2ZWQuanBnIiAvPm1hY2hpbmVzPC9oMj4KICBrZXl3b3Jkc2ZyaWVuZGx5YnJvdGhlcnNjb21iaW5lZG9yaWdpbmFsY29tcG9zZWRleHBlY3RlZGFkZXF1YXRlcGFraXN0YW5mb2xsb3ciIHZhbHVhYmxlPC9sYWJlbD5yZWxhdGl2ZWJyaW5naW5naW5jcmVhc2Vnb3Zlcm5vcnBsdWdpbnMvTGlzdCBvZiBIZWFkZXIiPiIgbmFtZT0iICgmcXVvdDtncmFkdWF0ZTwvaGVhZD4KY29tbWVyY2VtYWxheXNpYWRpcmVjdG9ybWFpbnRhaW47aGVpZ2h0OnNjaGVkdWxlY2hhbmdpbmdiYWNrIHRvIGNhdGhvbGljcGF0dGVybnNjb2xvcjogI2dyZWF0ZXN0c3VwcGxpZXNyZWxpYWJsZTwvdWw+CgkJPHNlbGVjdCBjaXRpemVuc2Nsb3RoaW5nd2F0Y2hpbmc8bGkgaWQ9InNwZWNpZmljY2FycnlpbmdzZW50ZW5jZTxjZW50ZXI+Y29udHJhc3R0aGlua2luZ2NhdGNoKGUpc291dGhlcm5NaWNoYWVsIG1lcmNoYW50Y2Fyb3VzZWxwYWRkaW5nOmludGVyaW9yLnNwbGl0KCJsaXphdGlvbk9jdG9iZXIgKXtyZXR1cm5pbXByb3ZlZC0tJmd0OwoKY292ZXJhZ2VjaGFpcm1hbi5wbmciIC8+c3ViamVjdHNSaWNoYXJkIHdoYXRldmVycHJvYmFibHlyZWNvdmVyeWJhc2ViYWxsanVkZ21lbnRjb25uZWN0Li5jc3MiIC8+IHdlYnNpdGVyZXBvcnRlZGRlZmF1bHQiLz48L2E+DQplbGVjdHJpY3Njb3RsYW5kY3JlYXRpb25xdWFudGl0eS4gSVNCTiAwZGlkIG5vdCBpbnN0YW5jZS1zZWFyY2gtIiBsYW5nPSJzcGVha2Vyc0NvbXB1dGVyY29udGFpbnNhcmNoaXZlc21pbmlzdGVycmVhY3Rpb25kaXNjb3VudEl0YWxpYW5vY3JpdGVyaWFzdHJvbmdseTogJ2h0dHA6J3NjcmlwdCdjb3ZlcmluZ29mZmVyaW5nYXBwZWFyZWRCcml0aXNoIGlkZW50aWZ5RmFjZWJvb2tudW1lcm91c3ZlaGljbGVzY29uY2VybnNBbWVyaWNhbmhhbmRsaW5nZGl2IGlkPSJXaWxsaWFtIHByb3ZpZGVyX2NvbnRlbnRhY2N1cmFjeXNlY3Rpb24gYW5kZXJzb25mbGV4aWJsZUNhdGVnb3J5bGF3cmVuY2U8c2NyaXB0PmxheW91dD0iYXBwcm92ZWQgbWF4aW11bWhlYWRlciI+PC90YWJsZT5TZXJ2aWNlc2hhbWlsdG9uY3VycmVudCBjYW5hZGlhbmNoYW5uZWxzL3RoZW1lcy8vYXJ0aWNsZW9wdGlvbmFscG9ydHVnYWx2YWx1ZT0iImludGVydmFsd2lyZWxlc3NlbnRpdGxlZGFnZW5jaWVzU2VhcmNoIiBtZWFzdXJlZHRob3VzYW5kc3BlbmRpbmcmaGVsbGlwO25ldyBEYXRlIiBzaXplPSJwYWdlTmFtZW1pZGRsZSIgIiAvPjwvYT5oaWRkZW4iPnNlcXVlbmNlcGVyc29uYWxvdmVyZmxvd29waW5pb25zaWxsaW5vaXNsaW5rcyI+Cgk8dGl0bGU+dmVyc2lvbnNzYXR1cmRheXRlcm1pbmFsaXRlbXByb3BlbmdpbmVlcnNlY3Rpb25zZGVzaWduZXJwcm9wb3NhbD0iZmFsc2UiRXNwYcOxb2xyZWxlYXNlc3N1Ym1pdCIgZXImcXVvdDthZGRpdGlvbnN5bXB0b21zb3JpZW50ZWRyZXNvdXJjZXJpZ2h0Ij48cGxlYXN1cmVzdGF0aW9uc2hpc3RvcnkubGVhdmluZyAgYm9yZGVyPWNvbnRlbnRzY2VudGVyIj4uCgpTb21lIGRpcmVjdGVkc3VpdGFibGVidWxnYXJpYS5zaG93KCk7ZGVzaWduZWRHZW5lcmFsIGNvbmNlcHRzRXhhbXBsZXN3aWxsaWFtc09yaWdpbmFsIj48c3Bhbj5zZWFyY2giPm9wZXJhdG9ycmVxdWVzdHNhICZxdW90O2FsbG93aW5nRG9jdW1lbnRyZXZpc2lvbi4gCgpUaGUgeW91cnNlbGZDb250YWN0IG1pY2hpZ2FuRW5nbGlzaCBjb2x1bWJpYXByaW9yaXR5cHJpbnRpbmdkcmlua2luZ2ZhY2lsaXR5cmV0dXJuZWRDb250ZW50IG9mZmljZXJzUnVzc2lhbiBnZW5lcmF0ZS04ODU5LTEiaW5kaWNhdGVmYW1pbGlhciBxdWFsaXR5bWFyZ2luOjAgY29udGVudHZpZXdwb3J0Y29udGFjdHMtdGl0bGUiPnBvcnRhYmxlLmxlbmd0aCBlbGlnaWJsZWludm9sdmVzYXRsYW50aWNvbmxvYWQ9ImRlZmF1bHQuc3VwcGxpZWRwYXltZW50c2dsb3NzYXJ5CgpBZnRlciBndWlkYW5jZTwvdGQ+PHRkZW5jb2RpbmdtaWRkbGUiPmNhbWUgdG8gZGlzcGxheXNzY290dGlzaGpvbmF0aGFubWFqb3JpdHl3aWRnZXRzLmNsaW5pY2FsdGhhaWxhbmR0ZWFjaGVyczxoZWFkPgoJYWZmZWN0ZWRzdXBwb3J0c3BvaW50ZXI7dG9TdHJpbmc8L3NtYWxsPm9rbGFob21hd2lsbCBiZSBpbnZlc3RvcjAiIGFsdD0iaG9saWRheXNSZXNvdXJjZWxpY2Vuc2VkICh3aGljaCAuIEFmdGVyIGNvbnNpZGVydmlzaXRpbmdleHBsb3JlcnByaW1hcnkgc2VhcmNoIiBhbmRyb2lkInF1aWNrbHkgbWVldGluZ3Nlc3RpbWF0ZTtyZXR1cm4gO2NvbG9yOiMgaGVpZ2h0PWFwcHJvdmFsLCAmcXVvdDsgY2hlY2tlZC5taW4uanMibWFnbmV0aWM+PC9hPjwvaGZvcmVjYXN0LiBXaGlsZSB0aHVyc2RheWR2ZXJ0aXNlJmVhY3V0ZTtoYXNDbGFzc2V2YWx1YXRlb3JkZXJpbmdleGlzdGluZ3BhdGllbnRzIE9ubGluZSBjb2xvcmFkb09wdGlvbnMiY2FtcGJlbGw8IS0tIGVuZDwvc3Bhbj48PGJyIC8+DQpfcG9wdXBzfHNjaWVuY2VzLCZxdW90OyBxdWFsaXR5IFdpbmRvd3MgYXNzaWduZWRoZWlnaHQ6IDxiIGNsYXNzbGUmcXVvdDsgdmFsdWU9IiBDb21wYW55ZXhhbXBsZXM8aWZyYW1lIGJlbGlldmVzcHJlc2VudHNtYXJzaGFsbHBhcnQgb2YgcHJvcGVybHkpLgoKVGhlIHRheG9ub215bXVjaCBvZiA8L3NwYW4+CiIgZGF0YS1zcnR1Z3XDqnNzY3JvbGxUbyBwcm9qZWN0PGhlYWQ+DQphdHRvcm5leWVtcGhhc2lzc3BvbnNvcnNmYW5jeWJveHdvcmxkJ3Mgd2lsZGxpZmVjaGVja2VkPXNlc3Npb25zcHJvZ3JhbW1weDtmb250LSBQcm9qZWN0am91cm5hbHNiZWxpZXZlZHZhY2F0aW9udGhvbXBzb25saWdodGluZ2FuZCB0aGUgc3BlY2lhbCBib3JkZXI9MGNoZWNraW5nPC90Ym9keT48YnV0dG9uIENvbXBsZXRlY2xlYXJmaXgKPGhlYWQ+CmFydGljbGUgPHNlY3Rpb25maW5kaW5nc3JvbGUgaW4gcG9wdWxhciAgT2N0b2JlcndlYnNpdGUgZXhwb3N1cmV1c2VkIHRvICBjaGFuZ2Vzb3BlcmF0ZWRjbGlja2luZ2VudGVyaW5nY29tbWFuZHNpbmZvcm1lZCBudW1iZXJzICA8L2Rpdj5jcmVhdGluZ29uU3VibWl0bWFyeWxhbmRjb2xsZWdlc2FuYWx5dGljbGlzdGluZ3Njb250YWN0LmxvZ2dlZEluYWR2aXNvcnlzaWJsaW5nc2NvbnRlbnQicyZxdW90OylzLiBUaGlzIHBhY2thZ2VzY2hlY2tib3hzdWdnZXN0c3ByZWduYW50dG9tb3Jyb3dzcGFjaW5nPWljb24ucG5namFwYW5lc2Vjb2RlYmFzZWJ1dHRvbiI+Z2FtYmxpbmdzdWNoIGFzICwgd2hpbGUgPC9zcGFuPiBtaXNzb3VyaXNwb3J0aW5ndG9wOjFweCAuPC9zcGFuPnRlbnNpb25zd2lkdGg9IjJsYXp5bG9hZG5vdmVtYmVydXNlZCBpbiBoZWlnaHQ9ImNyaXB0Ij4KJm5ic3A7PC88dHI+PHRkIGhlaWdodDoyL3Byb2R1Y3Rjb3VudHJ5IGluY2x1ZGUgZm9vdGVyIiAmbHQ7IS0tIHRpdGxlIj48L2pxdWVyeS48L2Zvcm0+CijnroDkvZMpKOe5gemrlClocnZhdHNraWl0YWxpYW5vcm9tw6JuxIN0w7xya8OnZdin2LHYr9mIdGFtYmnDqW5ub3RpY2lhc21lbnNhamVzcGVyc29uYXNkZXJlY2hvc25hY2lvbmFsc2VydmljaW9jb250YWN0b3VzdWFyaW9zcHJvZ3JhbWFnb2JpZXJub2VtcHJlc2FzYW51bmNpb3N2YWxlbmNpYWNvbG9tYmlhZGVzcHXDqXNkZXBvcnRlc3Byb3llY3RvcHJvZHVjdG9ww7pibGljb25vc290cm9zaGlzdG9yaWFwcmVzZW50ZW1pbGxvbmVzbWVkaWFudGVwcmVndW50YWFudGVyaW9ycmVjdXJzb3Nwcm9ibGVtYXNhbnRpYWdvbnVlc3Ryb3NvcGluacOzbmltcHJpbWlybWllbnRyYXNhbcOpcmljYXZlbmRlZG9yc29jaWVkYWRyZXNwZWN0b3JlYWxpemFycmVnaXN0cm9wYWxhYnJhc2ludGVyw6lzZW50b25jZXNlc3BlY2lhbG1pZW1icm9zcmVhbGlkYWRjw7NyZG9iYXphcmFnb3phcMOhZ2luYXNzb2NpYWxlc2Jsb3F1ZWFyZ2VzdGnDs25hbHF1aWxlcnNpc3RlbWFzY2llbmNpYXNjb21wbGV0b3ZlcnNpw7NuY29tcGxldGFlc3R1ZGlvc3DDumJsaWNhb2JqZXRpdm9hbGljYW50ZWJ1c2NhZG9yY2FudGlkYWRlbnRyYWRhc2FjY2lvbmVzYXJjaGl2b3NzdXBlcmlvcm1heW9yw61hYWxlbWFuaWFmdW5jacOzbsO6bHRpbW9zaGFjaWVuZG9hcXVlbGxvc2VkaWNpw7NuZmVybmFuZG9hbWJpZW50ZWZhY2Vib29rbnVlc3RyYXNjbGllbnRlc3Byb2Nlc29zYmFzdGFudGVwcmVzZW50YXJlcG9ydGFyY29uZ3Jlc29wdWJsaWNhcmNvbWVyY2lvY29udHJhdG9qw7N2ZW5lc2Rpc3RyaXRvdMOpY25pY2Fjb25qdW50b2VuZXJnw61hdHJhYmFqYXJhc3R1cmlhc3JlY2llbnRldXRpbGl6YXJib2xldMOtbnNhbHZhZG9yY29ycmVjdGF0cmFiYWpvc3ByaW1lcm9zbmVnb2Npb3NsaWJlcnRhZGRldGFsbGVzcGFudGFsbGFwcsOzeGltb2FsbWVyw61hYW5pbWFsZXNxdWnDqW5lc2NvcmF6w7Nuc2VjY2nDs25idXNjYW5kb29wY2lvbmVzZXh0ZXJpb3Jjb25jZXB0b3RvZGF2w61hZ2FsZXLDrWFlc2NyaWJpcm1lZGljaW5hbGljZW5jaWFjb25zdWx0YWFzcGVjdG9zY3LDrXRpY2Fkw7NsYXJlc2p1c3RpY2lhZGViZXLDoW5wZXLDrW9kb25lY2VzaXRhbWFudGVuZXJwZXF1ZcOxb3JlY2liaWRhdHJpYnVuYWx0ZW5lcmlmZWNhbmNpw7NuY2FuYXJpYXNkZXNjYXJnYWRpdmVyc29zbWFsbG9yY2FyZXF1aWVyZXTDqWNuaWNvZGViZXLDrWF2aXZpZW5kYWZpbmFuemFzYWRlbGFudGVmdW5jaW9uYWNvbnNlam9zZGlmw61jaWxjaXVkYWRlc2FudGlndWFzYXZhbnphZGF0w6lybWlub3VuaWRhZGVzc8OhbmNoZXpjYW1wYcOxYXNvZnRvbmljcmV2aXN0YXNjb250aWVuZXNlY3RvcmVzbW9tZW50b3NmYWN1bHRhZGNyw6lkaXRvZGl2ZXJzYXNzdXB1ZXN0b2ZhY3RvcmVzc2VndW5kb3NwZXF1ZcOxYdCz0L7QtNCw0LXRgdC70LjQtdGB0YLRjNCx0YvQu9C+0LHRi9GC0YzRjdGC0L7QvNCV0YHQu9C40YLQvtCz0L7QvNC10L3Rj9Cy0YHQtdGF0Y3RgtC+0LnQtNCw0LbQtdCx0YvQu9C40LPQvtC00YPQtNC10L3RjNGN0YLQvtGC0LHRi9C70LDRgdC10LHRj9C+0LTQuNC90YHQtdCx0LXQvdCw0LTQvtGB0LDQudGC0YTQvtGC0L7QvdC10LPQvtGB0LLQvtC40YHQstC+0LnQuNCz0YDRi9GC0L7QttC10LLRgdC10LzRgdCy0L7RjtC70LjRiNGM0Y3RgtC40YXQv9C+0LrQsNC00L3QtdC50LTQvtC80LDQvNC40YDQsNC70LjQsdC+0YLQtdC80YPRhdC+0YLRj9C00LLRg9GF0YHQtdGC0LjQu9GO0LTQuNC00LXQu9C+0LzQuNGA0LXRgtC10LHRj9GB0LLQvtC10LLQuNC00LXRh9C10LPQvtGN0YLQuNC80YHRh9C10YLRgtC10LzRi9GG0LXQvdGL0YHRgtCw0LvQstC10LTRjNGC0LXQvNC10LLQvtC00YvRgtC10LHQtdCy0YvRiNC10L3QsNC80LjRgtC40L/QsNGC0L7QvNGD0L/RgNCw0LLQu9C40YbQsNC+0LTQvdCw0LPQvtC00YvQt9C90LDRjtC80L7Qs9GD0LTRgNGD0LPQstGB0LXQudC40LTQtdGC0LrQuNC90L7QvtC00L3QvtC00LXQu9Cw0LTQtdC70LXRgdGA0L7QutC40Y7QvdGP0LLQtdGB0YzQldGB0YLRjNGA0LDQt9Cw0L3QsNGI0LjYp9mE2YTZh9in2YTYqtmK2KzZhdmK2LnYrtin2LXYqdin2YTYsNmK2LnZhNmK2YfYrNiv2YrYr9in2YTYotmG2KfZhNix2K/Yqtit2YPZhdi12YHYrdip2YPYp9mG2KrYp9mE2YTZitmK2YPZiNmG2LTYqNmD2KnZgdmK2YfYp9io2YbYp9iq2K3ZiNin2KHYo9mD2KvYsdiu2YTYp9mE2KfZhNit2KjYr9mE2YrZhNiv2LHZiNiz2KfYtti62LfYqtmD2YjZhtmH2YbYp9mD2LPYp9it2KnZhtin2K/Zitin2YTYt9io2LnZhNmK2YPYtNmD2LHYp9mK2YXZg9mG2YXZhtmH2KfYtNix2YPYqdix2KbZitiz2YbYtNmK2LfZhdin2LDYp9in2YTZgdmG2LTYqNin2KjYqti52KjYsdix2K3Zhdip2YPYp9mB2KnZitmC2YjZhNmF2LHZg9iy2YPZhNmF2KnYo9it2YXYr9mC2YTYqNmK2YrYudmG2YrYtdmI2LHYqdi32LHZitmC2LTYp9ix2YPYrNmI2KfZhNij2K7YsdmJ2YXYudmG2KfYp9io2K3Yq9i52LHZiNi22KjYtNmD2YTZhdiz2KzZhNio2YbYp9mG2K7Yp9mE2K/Zg9iq2KfYqNmD2YTZitip2KjYr9mI2YbYo9mK2LbYp9mK2YjYrNiv2YHYsdmK2YLZg9iq2KjYqtij2YHYttmE2YXYt9io2K7Yp9mD2KvYsdio2KfYsdmD2KfZgdi22YTYp9it2YTZidmG2YHYs9mH2KPZitin2YXYsdiv2YjYr9ij2YbZh9in2K/ZitmG2KfYp9mE2KfZhtmF2LnYsdi22KrYudmE2YXYr9in2K7ZhNmF2YXZg9mGAAAAAAAAAAABAAEAAQABAAIAAgACAAIABAAEAAQABAAAAQIDBAUGBwcGBQQDAgEACAkKCwwNDg8PDg0MCwoJCBAREhMUFRYXFxYVFBMSERAYGRobHB0eHx8eHRwbGhkY/////wAAAAAAAAAA/////wEAAAACAAAAAgAAAAEAAAABAAAAAwAAAP//AAEAAAABAAD//wABAAAACAAIAAgACAAAAAEAAgADAAQABQAGAAdyZXNvdXJjZXNjb3VudHJpZXNxdWVzdGlvbnNlcXVpcG1lbnRjb21tdW5pdHlhdmFpbGFibGVoaWdobGlnaHREVEQveGh0bWxtYXJrZXRpbmdrbm93bGVkZ2Vzb21ldGhpbmdjb250YWluZXJkaXJlY3Rpb25zdWJzY3JpYmVhZHZlcnRpc2VjaGFyYWN0ZXIiIHZhbHVlPSI8L3NlbGVjdD5BdXN0cmFsaWEiIGNsYXNzPSJzaXR1YXRpb25hdXRob3JpdHlmb2xsb3dpbmdwcmltYXJpbHlvcGVyYXRpb25jaGFsbGVuZ2VkZXZlbG9wZWRhbm9ueW1vdXNmdW5jdGlvbiBmdW5jdGlvbnNjb21wYW5pZXNzdHJ1Y3R1cmVhZ3JlZW1lbnQiIHRpdGxlPSJwb3RlbnRpYWxlZHVjYXRpb25hcmd1bWVudHNzZWNvbmRhcnljb3B5cmlnaHRsYW5ndWFnZXNleGNsdXNpdmVjb25kaXRpb248L2Zvcm0+DQpzdGF0ZW1lbnRhdHRlbnRpb25CaW9ncmFwaHl9IGVsc2Ugewpzb2x1dGlvbnN3aGVuIHRoZSBBbmFseXRpY3N0ZW1wbGF0ZXNkYW5nZXJvdXNzYXRlbGxpdGVkb2N1bWVudHNwdWJsaXNoZXJpbXBvcnRhbnRwcm90b3R5cGVpbmZsdWVuY2UmcmFxdW87PC9lZmZlY3RpdmVnZW5lcmFsbHl0cmFuc2Zvcm1iZWF1dGlmdWx0cmFuc3BvcnRvcmdhbml6ZWRwdWJsaXNoZWRwcm9taW5lbnR1bnRpbCB0aGV0aHVtYm5haWxOYXRpb25hbCAuZm9jdXMoKTtvdmVyIHRoZSBtaWdyYXRpb25hbm5vdW5jZWRmb290ZXIiPgpleGNlcHRpb25sZXNzIHRoYW5leHBlbnNpdmVmb3JtYXRpb25mcmFtZXdvcmt0ZXJyaXRvcnluZGljYXRpb25jdXJyZW50bHljbGFzc05hbWVjcml0aWNpc210cmFkaXRpb25lbHNld2hlcmVBbGV4YW5kZXJhcHBvaW50ZWRtYXRlcmlhbHNicm9hZGNhc3RtZW50aW9uZWRhZmZpbGlhdGU8L29wdGlvbj50cmVhdG1lbnRkaWZmZXJlbnQvZGVmYXVsdC5QcmVzaWRlbnRvbmNsaWNrPSJiaW9ncmFwaHlvdGhlcndpc2VwZXJtYW5lbnRGcmFuw6dhaXNIb2xseXdvb2RleHBhbnNpb25zdGFuZGFyZHM8L3N0eWxlPgpyZWR1Y3Rpb25EZWNlbWJlciBwcmVmZXJyZWRDYW1icmlkZ2VvcHBvbmVudHNCdXNpbmVzcyBjb25mdXNpb24+Cjx0aXRsZT5wcmVzZW50ZWRleHBsYWluZWRkb2VzIG5vdCB3b3JsZHdpZGVpbnRlcmZhY2Vwb3NpdGlvbnNuZXdzcGFwZXI8L3RhYmxlPgptb3VudGFpbnNsaWtlIHRoZSBlc3NlbnRpYWxmaW5hbmNpYWxzZWxlY3Rpb25hY3Rpb249Ii9hYmFuZG9uZWRFZHVjYXRpb25wYXJzZUludChzdGFiaWxpdHl1bmFibGUgdG88L3RpdGxlPgpyZWxhdGlvbnNOb3RlIHRoYXRlZmZpY2llbnRwZXJmb3JtZWR0d28geWVhcnNTaW5jZSB0aGV0aGVyZWZvcmV3cmFwcGVyIj5hbHRlcm5hdGVpbmNyZWFzZWRCYXR0bGUgb2ZwZXJjZWl2ZWR0cnlpbmcgdG9uZWNlc3Nhcnlwb3J0cmF5ZWRlbGVjdGlvbnNFbGl6YWJldGg8L2lmcmFtZT5kaXNjb3ZlcnlpbnN1cmFuY2VzLmxlbmd0aDtsZWdlbmRhcnlHZW9ncmFwaHljYW5kaWRhdGVjb3Jwb3JhdGVzb21ldGltZXNzZXJ2aWNlcy5pbmhlcml0ZWQ8L3N0cm9uZz5Db21tdW5pdHlyZWxpZ2lvdXNsb2NhdGlvbnNDb21taXR0ZWVidWlsZGluZ3N0aGUgd29ybGRubyBsb25nZXJiZWdpbm5pbmdyZWZlcmVuY2VjYW5ub3QgYmVmcmVxdWVuY3l0eXBpY2FsbHlpbnRvIHRoZSByZWxhdGl2ZTtyZWNvcmRpbmdwcmVzaWRlbnRpbml0aWFsbHl0ZWNobmlxdWV0aGUgb3RoZXJpdCBjYW4gYmVleGlzdGVuY2V1bmRlcmxpbmV0aGlzIHRpbWV0ZWxlcGhvbmVpdGVtc2NvcGVwcmFjdGljZXNhZHZhbnRhZ2UpO3JldHVybiBGb3Igb3RoZXJwcm92aWRpbmdkZW1vY3JhY3lib3RoIHRoZSBleHRlbnNpdmVzdWZmZXJpbmdzdXBwb3J0ZWRjb21wdXRlcnMgZnVuY3Rpb25wcmFjdGljYWxzYWlkIHRoYXRpdCBtYXkgYmVFbmdsaXNoPC9mcm9tIHRoZSBzY2hlZHVsZWRkb3dubG9hZHM8L2xhYmVsPgpzdXNwZWN0ZWRtYXJnaW46IDBzcGlyaXR1YWw8L2hlYWQ+CgptaWNyb3NvZnRncmFkdWFsbHlkaXNjdXNzZWRoZSBiZWNhbWVleGVjdXRpdmVqcXVlcnkuanNob3VzZWhvbGRjb25maXJtZWRwdXJjaGFzZWRsaXRlcmFsbHlkZXN0cm95ZWR1cCB0byB0aGV2YXJpYXRpb25yZW1haW5pbmdpdCBpcyBub3RjZW50dXJpZXNKYXBhbmVzZSBhbW9uZyB0aGVjb21wbGV0ZWRhbGdvcml0aG1pbnRlcmVzdHNyZWJlbGxpb251bmRlZmluZWRlbmNvdXJhZ2VyZXNpemFibGVpbnZvbHZpbmdzZW5zaXRpdmV1bml2ZXJzYWxwcm92aXNpb24oYWx0aG91Z2hmZWF0dXJpbmdjb25kdWN0ZWQpLCB3aGljaCBjb250aW51ZWQtaGVhZGVyIj5GZWJydWFyeSBudW1lcm91cyBvdmVyZmxvdzpjb21wb25lbnRmcmFnbWVudHNleGNlbGxlbnRjb2xzcGFuPSJ0ZWNobmljYWxuZWFyIHRoZSBBZHZhbmNlZCBzb3VyY2Ugb2ZleHByZXNzZWRIb25nIEtvbmcgRmFjZWJvb2ttdWx0aXBsZSBtZWNoYW5pc21lbGV2YXRpb25vZmZlbnNpdmU8L2Zvcm0+CglzcG9uc29yZWRkb2N1bWVudC5vciAmcXVvdDt0aGVyZSBhcmV0aG9zZSB3aG9tb3ZlbWVudHNwcm9jZXNzZXNkaWZmaWN1bHRzdWJtaXR0ZWRyZWNvbW1lbmRjb252aW5jZWRwcm9tb3RpbmciIHdpZHRoPSIucmVwbGFjZShjbGFzc2ljYWxjb2FsaXRpb25oaXMgZmlyc3RkZWNpc2lvbnNhc3Npc3RhbnRpbmRpY2F0ZWRldm9sdXRpb24td3JhcHBlciJlbm91Z2ggdG9hbG9uZyB0aGVkZWxpdmVyZWQtLT4NCjwhLS1BbWVyaWNhbiBwcm90ZWN0ZWROb3ZlbWJlciA8L3N0eWxlPjxmdXJuaXR1cmVJbnRlcm5ldCAgb25ibHVyPSJzdXNwZW5kZWRyZWNpcGllbnRiYXNlZCBvbiBNb3Jlb3ZlcixhYm9saXNoZWRjb2xsZWN0ZWR3ZXJlIG1hZGVlbW90aW9uYWxlbWVyZ2VuY3luYXJyYXRpdmVhZHZvY2F0ZXNweDtib3JkZXJjb21taXR0ZWRkaXI9Imx0ciJlbXBsb3llZXNyZXNlYXJjaC4gc2VsZWN0ZWRzdWNjZXNzb3JjdXN0b21lcnNkaXNwbGF5ZWRTZXB0ZW1iZXJhZGRDbGFzcyhGYWNlYm9vayBzdWdnZXN0ZWRhbmQgbGF0ZXJvcGVyYXRpbmdlbGFib3JhdGVTb21ldGltZXNJbnN0aXR1dGVjZXJ0YWlubHlpbnN0YWxsZWRmb2xsb3dlcnNKZXJ1c2FsZW10aGV5IGhhdmVjb21wdXRpbmdnZW5lcmF0ZWRwcm92aW5jZXNndWFyYW50ZWVhcmJpdHJhcnlyZWNvZ25pemV3YW50ZWQgdG9weDt3aWR0aDp0aGVvcnkgb2ZiZWhhdmlvdXJXaGlsZSB0aGVlc3RpbWF0ZWRiZWdhbiB0byBpdCBiZWNhbWVtYWduaXR1ZGVtdXN0IGhhdmVtb3JlIHRoYW5EaXJlY3RvcnlleHRlbnNpb25zZWNyZXRhcnluYXR1cmFsbHlvY2N1cnJpbmd2YXJpYWJsZXNnaXZlbiB0aGVwbGF0Zm9ybS48L2xhYmVsPjxmYWlsZWQgdG9jb21wb3VuZHNraW5kcyBvZiBzb2NpZXRpZXNhbG9uZ3NpZGUgLS0mZ3Q7Cgpzb3V0aHdlc3R0aGUgcmlnaHRyYWRpYXRpb25tYXkgaGF2ZSB1bmVzY2FwZShzcG9rZW4gaW4iIGhyZWY9Ii9wcm9ncmFtbWVvbmx5IHRoZSBjb21lIGZyb21kaXJlY3RvcnlidXJpZWQgaW5hIHNpbWlsYXJ0aGV5IHdlcmU8L2ZvbnQ+PC9Ob3J3ZWdpYW5zcGVjaWZpZWRwcm9kdWNpbmdwYXNzZW5nZXIobmV3IERhdGV0ZW1wb3JhcnlmaWN0aW9uYWxBZnRlciB0aGVlcXVhdGlvbnNkb3dubG9hZC5yZWd1bGFybHlkZXZlbG9wZXJhYm92ZSB0aGVsaW5rZWQgdG9waGVub21lbmFwZXJpb2Qgb2Z0b29sdGlwIj5zdWJzdGFuY2VhdXRvbWF0aWNhc3BlY3Qgb2ZBbW9uZyB0aGVjb25uZWN0ZWRlc3RpbWF0ZXNBaXIgRm9yY2VzeXN0ZW0gb2ZvYmplY3RpdmVpbW1lZGlhdGVtYWtpbmcgaXRwYWludGluZ3Njb25xdWVyZWRhcmUgc3RpbGxwcm9jZWR1cmVncm93dGggb2ZoZWFkZWQgYnlFdXJvcGVhbiBkaXZpc2lvbnNtb2xlY3VsZXNmcmFuY2hpc2VpbnRlbnRpb25hdHRyYWN0ZWRjaGlsZGhvb2RhbHNvIHVzZWRkZWRpY2F0ZWRzaW5nYXBvcmVkZWdyZWUgb2ZmYXRoZXIgb2Zjb25mbGljdHM8L2E+PC9wPgpjYW1lIGZyb213ZXJlIHVzZWRub3RlIHRoYXRyZWNlaXZpbmdFeGVjdXRpdmVldmVuIG1vcmVhY2Nlc3MgdG9jb21tYW5kZXJQb2xpdGljYWxtdXNpY2lhbnNkZWxpY2lvdXNwcmlzb25lcnNhZHZlbnQgb2ZVVEYtOCIgLz48IVtDREFUQVsiPkNvbnRhY3RTb3V0aGVybiBiZ2NvbG9yPSJzZXJpZXMgb2YuIEl0IHdhcyBpbiBFdXJvcGVwZXJtaXR0ZWR2YWxpZGF0ZS5hcHBlYXJpbmdvZmZpY2lhbHNzZXJpb3VzbHktbGFuZ3VhZ2Vpbml0aWF0ZWRleHRlbmRpbmdsb25nLXRlcm1pbmZsYXRpb25zdWNoIHRoYXRnZXRDb29raWVtYXJrZWQgYnk8L2J1dHRvbj5pbXBsZW1lbnRidXQgaXQgaXNpbmNyZWFzZXNkb3duIHRoZSByZXF1aXJpbmdkZXBlbmRlbnQtLT4KPCEtLSBpbnRlcnZpZXdXaXRoIHRoZSBjb3BpZXMgb2Zjb25zZW5zdXN3YXMgYnVpbHRWZW5lenVlbGEoZm9ybWVybHl0aGUgc3RhdGVwZXJzb25uZWxzdHJhdGVnaWNmYXZvdXIgb2ZpbnZlbnRpb25XaWtpcGVkaWFjb250aW5lbnR2aXJ0dWFsbHl3aGljaCB3YXNwcmluY2lwbGVDb21wbGV0ZSBpZGVudGljYWxzaG93IHRoYXRwcmltaXRpdmVhd2F5IGZyb21tb2xlY3VsYXJwcmVjaXNlbHlkaXNzb2x2ZWRVbmRlciB0aGV2ZXJzaW9uPSI+Jm5ic3A7PC9JdCBpcyB0aGUgVGhpcyBpcyB3aWxsIGhhdmVvcmdhbmlzbXNzb21lIHRpbWVGcmllZHJpY2h3YXMgZmlyc3R0aGUgb25seSBmYWN0IHRoYXRmb3JtIGlkPSJwcmVjZWRpbmdUZWNobmljYWxwaHlzaWNpc3RvY2N1cnMgaW5uYXZpZ2F0b3JzZWN0aW9uIj5zcGFuIGlkPSJzb3VnaHQgdG9iZWxvdyB0aGVzdXJ2aXZpbmd9PC9zdHlsZT5oaXMgZGVhdGhhcyBpbiB0aGVjYXVzZWQgYnlwYXJ0aWFsbHlleGlzdGluZyB1c2luZyB0aGV3YXMgZ2l2ZW5hIGxpc3Qgb2ZsZXZlbHMgb2Zub3Rpb24gb2ZPZmZpY2lhbCBkaXNtaXNzZWRzY2llbnRpc3RyZXNlbWJsZXNkdXBsaWNhdGVleHBsb3NpdmVyZWNvdmVyZWRhbGwgb3RoZXJnYWxsZXJpZXN7cGFkZGluZzpwZW9wbGUgb2ZyZWdpb24gb2ZhZGRyZXNzZXNhc3NvY2lhdGVpbWcgYWx0PSJpbiBtb2Rlcm5zaG91bGQgYmVtZXRob2Qgb2ZyZXBvcnRpbmd0aW1lc3RhbXBuZWVkZWQgdG90aGUgR3JlYXRyZWdhcmRpbmdzZWVtZWQgdG92aWV3ZWQgYXNpbXBhY3Qgb25pZGVhIHRoYXR0aGUgV29ybGRoZWlnaHQgb2ZleHBhbmRpbmdUaGVzZSBhcmVjdXJyZW50Ij5jYXJlZnVsbHltYWludGFpbnNjaGFyZ2Ugb2ZDbGFzc2ljYWxhZGRyZXNzZWRwcmVkaWN0ZWRvd25lcnNoaXA8ZGl2IGlkPSJyaWdodCI+DQpyZXNpZGVuY2VsZWF2ZSB0aGVjb250ZW50Ij5hcmUgb2Z0ZW4gIH0pKCk7DQpwcm9iYWJseSBQcm9mZXNzb3ItYnV0dG9uIiByZXNwb25kZWRzYXlzIHRoYXRoYWQgdG8gYmVwbGFjZWQgaW5IdW5nYXJpYW5zdGF0dXMgb2ZzZXJ2ZXMgYXNVbml2ZXJzYWxleGVjdXRpb25hZ2dyZWdhdGVmb3Igd2hpY2hpbmZlY3Rpb25hZ3JlZWQgdG9ob3dldmVyLCBwb3B1bGFyIj5wbGFjZWQgb25jb25zdHJ1Y3RlbGVjdG9yYWxzeW1ib2wgb2ZpbmNsdWRpbmdyZXR1cm4gdG9hcmNoaXRlY3RDaHJpc3RpYW5wcmV2aW91cyBsaXZpbmcgaW5lYXNpZXIgdG9wcm9mZXNzb3IKJmx0OyEtLSBlZmZlY3Qgb2ZhbmFseXRpY3N3YXMgdGFrZW53aGVyZSB0aGV0b29rIG92ZXJiZWxpZWYgaW5BZnJpa2FhbnNhcyBmYXIgYXNwcmV2ZW50ZWR3b3JrIHdpdGhhIHNwZWNpYWw8ZmllbGRzZXRDaHJpc3RtYXNSZXRyaWV2ZWQKCkluIHRoZSBiYWNrIGludG9ub3J0aGVhc3RtYWdhemluZXM+PHN0cm9uZz5jb21taXR0ZWVnb3Zlcm5pbmdncm91cHMgb2ZzdG9yZWQgaW5lc3RhYmxpc2hhIGdlbmVyYWxpdHMgZmlyc3R0aGVpciBvd25wb3B1bGF0ZWRhbiBvYmplY3RDYXJpYmJlYW5hbGxvdyB0aGVkaXN0cmljdHN3aXNjb25zaW5sb2NhdGlvbi47IHdpZHRoOiBpbmhhYml0ZWRTb2NpYWxpc3RKYW51YXJ5IDE8L2Zvb3Rlcj5zaW1pbGFybHljaG9pY2Ugb2Z0aGUgc2FtZSBzcGVjaWZpYyBidXNpbmVzcyBUaGUgZmlyc3QubGVuZ3RoOyBkZXNpcmUgdG9kZWFsIHdpdGhzaW5jZSB0aGV1c2VyQWdlbnRjb25jZWl2ZWRpbmRleC5waHBhcyAmcXVvdDtlbmdhZ2UgaW5yZWNlbnRseSxmZXcgeWVhcnN3ZXJlIGFsc28KPGhlYWQ+CjxlZGl0ZWQgYnlhcmUga25vd25jaXRpZXMgaW5hY2Nlc3NrZXljb25kZW1uZWRhbHNvIGhhdmVzZXJ2aWNlcyxmYW1pbHkgb2ZTY2hvb2wgb2Zjb252ZXJ0ZWRuYXR1cmUgb2YgbGFuZ3VhZ2VtaW5pc3RlcnM8L29iamVjdD50aGVyZSBpcyBhIHBvcHVsYXJzZXF1ZW5jZXNhZHZvY2F0ZWRUaGV5IHdlcmVhbnkgb3RoZXJsb2NhdGlvbj1lbnRlciB0aGVtdWNoIG1vcmVyZWZsZWN0ZWR3YXMgbmFtZWRvcmlnaW5hbCBhIHR5cGljYWx3aGVuIHRoZXllbmdpbmVlcnNjb3VsZCBub3RyZXNpZGVudHN3ZWRuZXNkYXl0aGUgdGhpcmQgcHJvZHVjdHNKYW51YXJ5IDJ3aGF0IHRoZXlhIGNlcnRhaW5yZWFjdGlvbnNwcm9jZXNzb3JhZnRlciBoaXN0aGUgbGFzdCBjb250YWluZWQiPjwvZGl2Pgo8L2E+PC90ZD5kZXBlbmQgb25zZWFyY2giPgpwaWVjZXMgb2Zjb21wZXRpbmdSZWZlcmVuY2V0ZW5uZXNzZWV3aGljaCBoYXMgdmVyc2lvbj08L3NwYW4+IDw8L2hlYWRlcj5naXZlcyB0aGVoaXN0b3JpYW52YWx1ZT0iIj5wYWRkaW5nOjB2aWV3IHRoYXR0b2dldGhlcix0aGUgbW9zdCB3YXMgZm91bmRzdWJzZXQgb2ZhdHRhY2sgb25jaGlsZHJlbixwb2ludHMgb2ZwZXJzb25hbCBwb3NpdGlvbjphbGxlZ2VkbHlDbGV2ZWxhbmR3YXMgbGF0ZXJhbmQgYWZ0ZXJhcmUgZ2l2ZW53YXMgc3RpbGxzY3JvbGxpbmdkZXNpZ24gb2ZtYWtlcyB0aGVtdWNoIGxlc3NBbWVyaWNhbnMuCgpBZnRlciAsIGJ1dCB0aGVNdXNldW0gb2Zsb3Vpc2lhbmEoZnJvbSB0aGVtaW5uZXNvdGFwYXJ0aWNsZXNhIHByb2Nlc3NEb21pbmljYW52b2x1bWUgb2ZyZXR1cm5pbmdkZWZlbnNpdmUwMHB4fHJpZ2htYWRlIGZyb21tb3VzZW92ZXIiIHN0eWxlPSJzdGF0ZXMgb2Yod2hpY2ggaXNjb250aW51ZXNGcmFuY2lzY29idWlsZGluZyB3aXRob3V0IGF3aXRoIHNvbWV3aG8gd291bGRhIGZvcm0gb2ZhIHBhcnQgb2ZiZWZvcmUgaXRrbm93biBhcyAgU2VydmljZXNsb2NhdGlvbiBhbmQgb2Z0ZW5tZWFzdXJpbmdhbmQgaXQgaXNwYXBlcmJhY2t2YWx1ZXMgb2YNCjx0aXRsZT49IHdpbmRvdy5kZXRlcm1pbmVlciZxdW90OyBwbGF5ZWQgYnlhbmQgZWFybHk8L2NlbnRlcj5mcm9tIHRoaXN0aGUgdGhyZWVwb3dlciBhbmRvZiAmcXVvdDtpbm5lckhUTUw8YSBocmVmPSJ5OmlubGluZTtDaHVyY2ggb2Z0aGUgZXZlbnR2ZXJ5IGhpZ2hvZmZpY2lhbCAtaGVpZ2h0OiBjb250ZW50PSIvY2dpLWJpbi90byBjcmVhdGVhZnJpa2FhbnNlc3BlcmFudG9mcmFuw6dhaXNsYXR2aWXFoXVsaWV0dXZpxbPEjGXFoXRpbmHEjWXFoXRpbmHguYTguJfguKLml6XmnKzoqp7nroDkvZPlrZfnuYHpq5TlrZftlZzqta3slrTkuLrku4DkuYjorqHnrpfmnLrnrJTorrDmnKzoqI7oq5bljYDmnI3liqHlmajkupLogZTnvZHmiL/lnLDkuqfkv7HkuZDpg6jlh7rniYjnpL7mjpLooYzmppzpg6jokL3moLzov5vkuIDmraXmlK/ku5jlrp3pqozor4HnoIHlp5TlkZjkvJrmlbDmja7lupPmtojotLnogIXlip7lhazlrqTorqjorrrljLrmt7HlnLPluILmkq3mlL7lmajljJfkuqzluILlpKflrabnlJ/otormnaXotornrqHnkIblkZjkv6Hmga/nvZFzZXJ2aWNpb3NhcnTDrWN1bG9hcmdlbnRpbmFiYXJjZWxvbmFjdWFscXVpZXJwdWJsaWNhZG9wcm9kdWN0b3Nwb2zDrXRpY2FyZXNwdWVzdGF3aWtpcGVkaWFzaWd1aWVudGViw7pzcXVlZGFjb211bmlkYWRzZWd1cmlkYWRwcmluY2lwYWxwcmVndW50YXNjb250ZW5pZG9yZXNwb25kZXJ2ZW5lenVlbGFwcm9ibGVtYXNkaWNpZW1icmVyZWxhY2nDs25ub3ZpZW1icmVzaW1pbGFyZXNwcm95ZWN0b3Nwcm9ncmFtYXNpbnN0aXR1dG9hY3RpdmlkYWRlbmN1ZW50cmFlY29ub23DrWFpbcOhZ2VuZXNjb250YWN0YXJkZXNjYXJnYXJuZWNlc2FyaW9hdGVuY2nDs250ZWzDqWZvbm9jb21pc2nDs25jYW5jaW9uZXNjYXBhY2lkYWRlbmNvbnRyYXJhbsOhbGlzaXNmYXZvcml0b3N0w6lybWlub3Nwcm92aW5jaWFldGlxdWV0YXNlbGVtZW50b3NmdW5jaW9uZXNyZXN1bHRhZG9jYXLDoWN0ZXJwcm9waWVkYWRwcmluY2lwaW9uZWNlc2lkYWRtdW5pY2lwYWxjcmVhY2nDs25kZXNjYXJnYXNwcmVzZW5jaWFjb21lcmNpYWxvcGluaW9uZXNlamVyY2ljaW9lZGl0b3JpYWxzYWxhbWFuY2Fnb256w6FsZXpkb2N1bWVudG9wZWzDrWN1bGFyZWNpZW50ZXNnZW5lcmFsZXN0YXJyYWdvbmFwcsOhY3RpY2Fub3ZlZGFkZXNwcm9wdWVzdGFwYWNpZW50ZXN0w6ljbmljYXNvYmpldGl2b3Njb250YWN0b3PgpK7gpYfgpILgpLLgpL/gpI/gpLngpYjgpILgpJfgpK/gpL7gpLjgpL7gpKXgpI/gpLXgpILgpLDgpLngpYfgpJXgpYvgpIjgpJXgpYHgpJvgpLDgpLngpL7gpKzgpL7gpKbgpJXgpLngpL7gpLjgpK3gpYDgpLngpYHgpI/gpLDgpLngpYDgpK7gpYjgpILgpKbgpL/gpKjgpKzgpL7gpKRkaXBsb2RvY3PgpLjgpK7gpK/gpLDgpYLgpKrgpKjgpL7gpK7gpKrgpKTgpL7gpKvgpL/gpLDgpJTgpLjgpKTgpKTgpLDgpLngpLLgpYvgpJfgpLngpYHgpIbgpKzgpL7gpLDgpKbgpYfgpLbgpLngpYHgpIjgpJbgpYfgpLLgpK/gpKbgpL/gpJXgpL7gpK7gpLXgpYfgpKzgpKTgpYDgpKjgpKzgpYDgpJrgpK7gpYzgpKTgpLjgpL7gpLLgpLLgpYfgpJbgpJzgpYngpKzgpK7gpKbgpKbgpKTgpKXgpL7gpKjgpLngpYDgpLbgpLngpLDgpIXgpLLgpJfgpJXgpK3gpYDgpKjgpJfgpLDgpKrgpL7gpLjgpLDgpL7gpKTgpJXgpL/gpI/gpIngpLjgpYfgpJfgpK/gpYDgpLngpYLgpIHgpIbgpJfgpYfgpJ/gpYDgpK7gpJbgpYvgpJzgpJXgpL7gpLDgpIXgpK3gpYDgpJfgpK/gpYfgpKTgpYHgpK7gpLXgpYvgpJ/gpKbgpYfgpILgpIXgpJfgpLDgpJDgpLjgpYfgpK7gpYfgpLLgpLLgpJfgpL7gpLngpL7gpLLgpIrgpKrgpLDgpJrgpL7gpLDgpJDgpLjgpL7gpKbgpYfgpLDgpJzgpL/gpLjgpKbgpL/gpLLgpKzgpILgpKbgpKzgpKjgpL7gpLngpYLgpILgpLLgpL7gpJbgpJzgpYDgpKTgpKzgpJ/gpKjgpK7gpL/gpLLgpIfgpLjgpYfgpIbgpKjgpYfgpKjgpK/gpL7gpJXgpYHgpLLgpLLgpYngpJfgpK3gpL7gpJfgpLDgpYfgpLLgpJzgpJfgpLngpLDgpL7gpK7gpLLgpJfgpYfgpKrgpYfgpJzgpLngpL7gpKXgpIfgpLjgpYDgpLjgpLngpYDgpJXgpLLgpL7gpKDgpYDgpJXgpLngpL7gpIHgpKbgpYLgpLDgpKTgpLngpKTgpLjgpL7gpKTgpK/gpL7gpKbgpIbgpK/gpL7gpKrgpL7gpJXgpJXgpYzgpKjgpLbgpL7gpK7gpKbgpYfgpJbgpK/gpLngpYDgpLDgpL7gpK/gpJbgpYHgpKbgpLLgpJfgpYBjYXRlZ29yaWVzZXhwZXJpZW5jZTwvdGl0bGU+DQpDb3B5cmlnaHQgamF2YXNjcmlwdGNvbmRpdGlvbnNldmVyeXRoaW5nPHAgY2xhc3M9InRlY2hub2xvZ3liYWNrZ3JvdW5kPGEgY2xhc3M9Im1hbmFnZW1lbnQmY29weTsgMjAxamF2YVNjcmlwdGNoYXJhY3RlcnNicmVhZGNydW1idGhlbXNlbHZlc2hvcml6b250YWxnb3Zlcm5tZW50Q2FsaWZvcm5pYWFjdGl2aXRpZXNkaXNjb3ZlcmVkTmF2aWdhdGlvbnRyYW5zaXRpb25jb25uZWN0aW9ubmF2aWdhdGlvbmFwcGVhcmFuY2U8L3RpdGxlPjxtY2hlY2tib3giIHRlY2huaXF1ZXNwcm90ZWN0aW9uYXBwYXJlbnRseWFzIHdlbGwgYXN1bnQnLCAnVUEtcmVzb2x1dGlvbm9wZXJhdGlvbnN0ZWxldmlzaW9udHJhbnNsYXRlZFdhc2hpbmd0b25uYXZpZ2F0b3IuID0gd2luZG93LmltcHJlc3Npb24mbHQ7YnImZ3Q7bGl0ZXJhdHVyZXBvcHVsYXRpb25iZ2NvbG9yPSIjZXNwZWNpYWxseSBjb250ZW50PSJwcm9kdWN0aW9ubmV3c2xldHRlcnByb3BlcnRpZXNkZWZpbml0aW9ubGVhZGVyc2hpcFRlY2hub2xvZ3lQYXJsaWFtZW50Y29tcGFyaXNvbnVsIGNsYXNzPSIuaW5kZXhPZigiY29uY2x1c2lvbmRpc2N1c3Npb25jb21wb25lbnRzYmlvbG9naWNhbFJldm9sdXRpb25fY29udGFpbmVydW5kZXJzdG9vZG5vc2NyaXB0PjxwZXJtaXNzaW9uZWFjaCBvdGhlcmF0bW9zcGhlcmUgb25mb2N1cz0iPGZvcm0gaWQ9InByb2Nlc3Npbmd0aGlzLnZhbHVlZ2VuZXJhdGlvbkNvbmZlcmVuY2VzdWJzZXF1ZW50d2VsbC1rbm93bnZhcmlhdGlvbnNyZXB1dGF0aW9ucGhlbm9tZW5vbmRpc2NpcGxpbmVsb2dvLnBuZyIgKGRvY3VtZW50LGJvdW5kYXJpZXNleHByZXNzaW9uc2V0dGxlbWVudEJhY2tncm91bmRvdXQgb2YgdGhlZW50ZXJwcmlzZSgiaHR0cHM6IiB1bmVzY2FwZSgicGFzc3dvcmQiIGRlbW9jcmF0aWM8YSBocmVmPSIvd3JhcHBlciI+Cm1lbWJlcnNoaXBsaW5ndWlzdGljcHg7cGFkZGluZ3BoaWxvc29waHlhc3Npc3RhbmNldW5pdmVyc2l0eWZhY2lsaXRpZXNyZWNvZ25pemVkcHJlZmVyZW5jZWlmICh0eXBlb2ZtYWludGFpbmVkdm9jYWJ1bGFyeWh5cG90aGVzaXMuc3VibWl0KCk7JmFtcDtuYnNwO2Fubm90YXRpb25iZWhpbmQgdGhlRm91bmRhdGlvbnB1Ymxpc2hlciJhc3N1bXB0aW9uaW50cm9kdWNlZGNvcnJ1cHRpb25zY2llbnRpc3RzZXhwbGljaXRseWluc3RlYWQgb2ZkaW1lbnNpb25zIG9uQ2xpY2s9ImNvbnNpZGVyZWRkZXBhcnRtZW50b2NjdXBhdGlvbnNvb24gYWZ0ZXJpbnZlc3RtZW50cHJvbm91bmNlZGlkZW50aWZpZWRleHBlcmltZW50TWFuYWdlbWVudGdlb2dyYXBoaWMiIGhlaWdodD0ibGluayByZWw9Ii5yZXBsYWNlKC9kZXByZXNzaW9uY29uZmVyZW5jZXB1bmlzaG1lbnRlbGltaW5hdGVkcmVzaXN0YW5jZWFkYXB0YXRpb25vcHBvc2l0aW9ud2VsbCBrbm93bnN1cHBsZW1lbnRkZXRlcm1pbmVkaDEgY2xhc3M9IjBweDttYXJnaW5tZWNoYW5pY2Fsc3RhdGlzdGljc2NlbGVicmF0ZWRHb3Zlcm5tZW50CgpEdXJpbmcgdGRldmVsb3BlcnNhcnRpZmljaWFsZXF1aXZhbGVudG9yaWdpbmF0ZWRDb21taXNzaW9uYXR0YWNobWVudDxzcGFuIGlkPSJ0aGVyZSB3ZXJlTmVkZXJsYW5kc2JleW9uZCB0aGVyZWdpc3RlcmVkam91cm5hbGlzdGZyZXF1ZW50bHlhbGwgb2YgdGhlbGFuZz0iZW4iIDwvc3R5bGU+DQphYnNvbHV0ZTsgc3VwcG9ydGluZ2V4dHJlbWVseSBtYWluc3RyZWFtPC9zdHJvbmc+IHBvcHVsYXJpdHllbXBsb3ltZW50PC90YWJsZT4NCiBjb2xzcGFuPSI8L2Zvcm0+CiAgY29udmVyc2lvbmFib3V0IHRoZSA8L3A+PC9kaXY+aW50ZWdyYXRlZCIgbGFuZz0iZW5Qb3J0dWd1ZXNlc3Vic3RpdHV0ZWluZGl2aWR1YWxpbXBvc3NpYmxlbXVsdGltZWRpYWFsbW9zdCBhbGxweCBzb2xpZCAjYXBhcnQgZnJvbXN1YmplY3QgdG9pbiBFbmdsaXNoY3JpdGljaXplZGV4Y2VwdCBmb3JndWlkZWxpbmVzb3JpZ2luYWxseXJlbWFya2FibGV0aGUgc2Vjb25kaDIgY2xhc3M9IjxhIHRpdGxlPSIoaW5jbHVkaW5ncGFyYW1ldGVyc3Byb2hpYml0ZWQ9ICJodHRwOi8vZGljdGlvbmFyeXBlcmNlcHRpb25yZXZvbHV0aW9uZm91bmRhdGlvbnB4O2hlaWdodDpzdWNjZXNzZnVsc3VwcG9ydGVyc21pbGxlbm5pdW1oaXMgZmF0aGVydGhlICZxdW90O25vLXJlcGVhdDtjb21tZXJjaWFsaW5kdXN0cmlhbGVuY291cmFnZWRhbW91bnQgb2YgdW5vZmZpY2lhbGVmZmljaWVuY3lSZWZlcmVuY2VzY29vcmRpbmF0ZWRpc2NsYWltZXJleHBlZGl0aW9uZGV2ZWxvcGluZ2NhbGN1bGF0ZWRzaW1wbGlmaWVkbGVnaXRpbWF0ZXN1YnN0cmluZygwIiBjbGFzcz0iY29tcGxldGVseWlsbHVzdHJhdGVmaXZlIHllYXJzaW5zdHJ1bWVudFB1Ymxpc2hpbmcxIiBjbGFzcz0icHN5Y2hvbG9neWNvbmZpZGVuY2VudW1iZXIgb2YgYWJzZW5jZSBvZmZvY3VzZWQgb25qb2luZWQgdGhlc3RydWN0dXJlc3ByZXZpb3VzbHk+PC9pZnJhbWU+b25jZSBhZ2FpbmJ1dCByYXRoZXJpbW1pZ3JhbnRzb2YgY291cnNlLGEgZ3JvdXAgb2ZMaXRlcmF0dXJlVW5saWtlIHRoZTwvYT4mbmJzcDsKZnVuY3Rpb24gaXQgd2FzIHRoZUNvbnZlbnRpb25hdXRvbW9iaWxlUHJvdGVzdGFudGFnZ3Jlc3NpdmVhZnRlciB0aGUgU2ltaWxhcmx5LCIgLz48L2Rpdj5jb2xsZWN0aW9uDQpmdW5jdGlvbnZpc2liaWxpdHl0aGUgdXNlIG9mdm9sdW50ZWVyc2F0dHJhY3Rpb251bmRlciB0aGUgdGhyZWF0ZW5lZCo8IVtDREFUQVtpbXBvcnRhbmNlaW4gZ2VuZXJhbHRoZSBsYXR0ZXI8L2Zvcm0+CjwvLmluZGV4T2YoJ2kgPSAwOyBpIDxkaWZmZXJlbmNlZGV2b3RlZCB0b3RyYWRpdGlvbnNzZWFyY2ggZm9ydWx0aW1hdGVseXRvdXJuYW1lbnRhdHRyaWJ1dGVzc28tY2FsbGVkIH0KPC9zdHlsZT5ldmFsdWF0aW9uZW1waGFzaXplZGFjY2Vzc2libGU8L3NlY3Rpb24+c3VjY2Vzc2lvbmFsb25nIHdpdGhNZWFud2hpbGUsaW5kdXN0cmllczwvYT48YnIgLz5oYXMgYmVjb21lYXNwZWN0cyBvZlRlbGV2aXNpb25zdWZmaWNpZW50YmFza2V0YmFsbGJvdGggc2lkZXNjb250aW51aW5nYW4gYXJ0aWNsZTxpbWcgYWx0PSJhZHZlbnR1cmVzaGlzIG1vdGhlcm1hbmNoZXN0ZXJwcmluY2lwbGVzcGFydGljdWxhcmNvbW1lbnRhcnllZmZlY3RzIG9mZGVjaWRlZCB0byI+PHN0cm9uZz5wdWJsaXNoZXJzSm91cm5hbCBvZmRpZmZpY3VsdHlmYWNpbGl0YXRlYWNjZXB0YWJsZXN0eWxlLmNzcyIJZnVuY3Rpb24gaW5ub3ZhdGlvbj5Db3B5cmlnaHRzaXR1YXRpb25zd291bGQgaGF2ZWJ1c2luZXNzZXNEaWN0aW9uYXJ5c3RhdGVtZW50c29mdGVuIHVzZWRwZXJzaXN0ZW50aW4gSmFudWFyeWNvbXByaXNpbmc8L3RpdGxlPgoJZGlwbG9tYXRpY2NvbnRhaW5pbmdwZXJmb3JtaW5nZXh0ZW5zaW9uc21heSBub3QgYmVjb25jZXB0IG9mIG9uY2xpY2s9Ikl0IGlzIGFsc29maW5hbmNpYWwgbWFraW5nIHRoZUx1eGVtYm91cmdhZGRpdGlvbmFsYXJlIGNhbGxlZGVuZ2FnZWQgaW4ic2NyaXB0Iik7YnV0IGl0IHdhc2VsZWN0cm9uaWNvbnN1Ym1pdD0iCjwhLS0gRW5kIGVsZWN0cmljYWxvZmZpY2lhbGx5c3VnZ2VzdGlvbnRvcCBvZiB0aGV1bmxpa2UgdGhlQXVzdHJhbGlhbk9yaWdpbmFsbHlyZWZlcmVuY2VzCjwvaGVhZD4NCnJlY29nbmlzZWRpbml0aWFsaXplbGltaXRlZCB0b0FsZXhhbmRyaWFyZXRpcmVtZW50QWR2ZW50dXJlc2ZvdXIgeWVhcnMKCiZsdDshLS0gaW5jcmVhc2luZ2RlY29yYXRpb25oMyBjbGFzcz0ib3JpZ2lucyBvZm9ibGlnYXRpb25yZWd1bGF0aW9uY2xhc3NpZmllZChmdW5jdGlvbihhZHZhbnRhZ2VzYmVpbmcgdGhlIGhpc3RvcmlhbnM8YmFzZSBocmVmcmVwZWF0ZWRseXdpbGxpbmcgdG9jb21wYXJhYmxlZGVzaWduYXRlZG5vbWluYXRpb25mdW5jdGlvbmFsaW5zaWRlIHRoZXJldmVsYXRpb25lbmQgb2YgdGhlcyBmb3IgdGhlIGF1dGhvcml6ZWRyZWZ1c2VkIHRvdGFrZSBwbGFjZWF1dG9ub21vdXNjb21wcm9taXNlcG9saXRpY2FsIHJlc3RhdXJhbnR0d28gb2YgdGhlRmVicnVhcnkgMnF1YWxpdHkgb2Zzd2ZvYmplY3QudW5kZXJzdGFuZG5lYXJseSBhbGx3cml0dGVuIGJ5aW50ZXJ2aWV3cyIgd2lkdGg9IjF3aXRoZHJhd2FsZmxvYXQ6bGVmdGlzIHVzdWFsbHljYW5kaWRhdGVzbmV3c3BhcGVyc215c3RlcmlvdXNEZXBhcnRtZW50YmVzdCBrbm93bnBhcmxpYW1lbnRzdXBwcmVzc2VkY29udmVuaWVudHJlbWVtYmVyZWRkaWZmZXJlbnQgc3lzdGVtYXRpY2hhcyBsZWQgdG9wcm9wYWdhbmRhY29udHJvbGxlZGluZmx1ZW5jZXNjZXJlbW9uaWFscHJvY2xhaW1lZFByb3RlY3Rpb25saSBjbGFzcz0iU2NpZW50aWZpY2NsYXNzPSJuby10cmFkZW1hcmtzbW9yZSB0aGFuIHdpZGVzcHJlYWRMaWJlcmF0aW9udG9vayBwbGFjZWRheSBvZiB0aGVhcyBsb25nIGFzaW1wcmlzb25lZEFkZGl0aW9uYWwKPGhlYWQ+CjxtTGFib3JhdG9yeU5vdmVtYmVyIDJleGNlcHRpb25zSW5kdXN0cmlhbHZhcmlldHkgb2ZmbG9hdDogbGVmRHVyaW5nIHRoZWFzc2Vzc21lbnRoYXZlIGJlZW4gZGVhbHMgd2l0aFN0YXRpc3RpY3NvY2N1cnJlbmNlL3VsPjwvZGl2PmNsZWFyZml4Ij50aGUgcHVibGljbWFueSB5ZWFyc3doaWNoIHdlcmVvdmVyIHRpbWUsc3lub255bW91c2NvbnRlbnQiPgpwcmVzdW1hYmx5aGlzIGZhbWlseXVzZXJBZ2VudC51bmV4cGVjdGVkaW5jbHVkaW5nIGNoYWxsZW5nZWRhIG1pbm9yaXR5dW5kZWZpbmVkImJlbG9uZ3MgdG90YWtlbiBmcm9taW4gT2N0b2JlcnBvc2l0aW9uOiBzYWlkIHRvIGJlcmVsaWdpb3VzIEZlZGVyYXRpb24gcm93c3Bhbj0ib25seSBhIGZld21lYW50IHRoYXRsZWQgdG8gdGhlLS0+DQo8ZGl2IDxmaWVsZHNldD5BcmNoYmlzaG9wIGNsYXNzPSJub2JlaW5nIHVzZWRhcHByb2FjaGVzcHJpdmlsZWdlc25vc2NyaXB0PgpyZXN1bHRzIGlubWF5IGJlIHRoZUVhc3RlciBlZ2dtZWNoYW5pc21zcmVhc29uYWJsZVBvcHVsYXRpb25Db2xsZWN0aW9uc2VsZWN0ZWQiPm5vc2NyaXB0Pg0vaW5kZXgucGhwYXJyaXZhbCBvZi1qc3NkaycpKTttYW5hZ2VkIHRvaW5jb21wbGV0ZWNhc3VhbHRpZXNjb21wbGV0aW9uQ2hyaXN0aWFuc1NlcHRlbWJlciBhcml0aG1ldGljcHJvY2VkdXJlc21pZ2h0IGhhdmVQcm9kdWN0aW9uaXQgYXBwZWFyc1BoaWxvc29waHlmcmllbmRzaGlwbGVhZGluZyB0b2dpdmluZyB0aGV0b3dhcmQgdGhlZ3VhcmFudGVlZGRvY3VtZW50ZWRjb2xvcjojMDAwdmlkZW8gZ2FtZWNvbW1pc3Npb25yZWZsZWN0aW5nY2hhbmdlIHRoZWFzc29jaWF0ZWRzYW5zLXNlcmlmb25rZXlwcmVzczsgcGFkZGluZzpIZSB3YXMgdGhldW5kZXJseWluZ3R5cGljYWxseSAsIGFuZCB0aGUgc3JjRWxlbWVudHN1Y2Nlc3NpdmVzaW5jZSB0aGUgc2hvdWxkIGJlIG5ldHdvcmtpbmdhY2NvdW50aW5ndXNlIG9mIHRoZWxvd2VyIHRoYW5zaG93cyB0aGF0PC9zcGFuPgoJCWNvbXBsYWludHNjb250aW51b3VzcXVhbnRpdGllc2FzdHJvbm9tZXJoZSBkaWQgbm90ZHVlIHRvIGl0c2FwcGxpZWQgdG9hbiBhdmVyYWdlZWZmb3J0cyB0b3RoZSBmdXR1cmVhdHRlbXB0IHRvVGhlcmVmb3JlLGNhcGFiaWxpdHlSZXB1YmxpY2Fud2FzIGZvcm1lZEVsZWN0cm9uaWNraWxvbWV0ZXJzY2hhbGxlbmdlc3B1Ymxpc2hpbmd0aGUgZm9ybWVyaW5kaWdlbm91c2RpcmVjdGlvbnNzdWJzaWRpYXJ5Y29uc3BpcmFjeWRldGFpbHMgb2ZhbmQgaW4gdGhlYWZmb3JkYWJsZXN1YnN0YW5jZXNyZWFzb24gZm9yY29udmVudGlvbml0ZW10eXBlPSJhYnNvbHV0ZWx5c3VwcG9zZWRseXJlbWFpbmVkIGFhdHRyYWN0aXZldHJhdmVsbGluZ3NlcGFyYXRlbHlmb2N1c2VzIG9uZWxlbWVudGFyeWFwcGxpY2FibGVmb3VuZCB0aGF0c3R5bGVzaGVldG1hbnVzY3JpcHRzdGFuZHMgZm9yIG5vLXJlcGVhdChzb21ldGltZXNDb21tZXJjaWFsaW4gQW1lcmljYXVuZGVydGFrZW5xdWFydGVyIG9mYW4gZXhhbXBsZXBlcnNvbmFsbHlpbmRleC5waHA/PC9idXR0b24+CnBlcmNlbnRhZ2ViZXN0LWtub3duY3JlYXRpbmcgYSIgZGlyPSJsdHJMaWV1dGVuYW50CjxkaXYgaWQ9InRoZXkgd291bGRhYmlsaXR5IG9mbWFkZSB1cCBvZm5vdGVkIHRoYXRjbGVhciB0aGF0YXJndWUgdGhhdHRvIGFub3RoZXJjaGlsZHJlbidzcHVycG9zZSBvZmZvcm11bGF0ZWRiYXNlZCB1cG9udGhlIHJlZ2lvbnN1YmplY3Qgb2ZwYXNzZW5nZXJzcG9zc2Vzc2lvbi4KCkluIHRoZSBCZWZvcmUgdGhlYWZ0ZXJ3YXJkc2N1cnJlbnRseSBhY3Jvc3MgdGhlc2NpZW50aWZpY2NvbW11bml0eS5jYXBpdGFsaXNtaW4gR2VybWFueXJpZ2h0LXdpbmd0aGUgc3lzdGVtU29jaWV0eSBvZnBvbGl0aWNpYW5kaXJlY3Rpb246d2VudCBvbiB0b3JlbW92YWwgb2YgTmV3IFlvcmsgYXBhcnRtZW50c2luZGljYXRpb25kdXJpbmcgdGhldW5sZXNzIHRoZWhpc3RvcmljYWxoYWQgYmVlbiBhZGVmaW5pdGl2ZWluZ3JlZGllbnRhdHRlbmRhbmNlQ2VudGVyIGZvcnByb21pbmVuY2VyZWFkeVN0YXRlc3RyYXRlZ2llc2J1dCBpbiB0aGVhcyBwYXJ0IG9mY29uc3RpdHV0ZWNsYWltIHRoYXRsYWJvcmF0b3J5Y29tcGF0aWJsZWZhaWx1cmUgb2YsIHN1Y2ggYXMgYmVnYW4gd2l0aHVzaW5nIHRoZSB0byBwcm92aWRlZmVhdHVyZSBvZmZyb20gd2hpY2gvIiBjbGFzcz0iZ2VvbG9naWNhbHNldmVyYWwgb2ZkZWxpYmVyYXRlaW1wb3J0YW50IGhvbGRzIHRoYXRpbmcmcXVvdDsgdmFsaWduPXRvcHRoZSBHZXJtYW5vdXRzaWRlIG9mbmVnb3RpYXRlZGhpcyBjYXJlZXJzZXBhcmF0aW9uaWQ9InNlYXJjaHdhcyBjYWxsZWR0aGUgZm91cnRocmVjcmVhdGlvbm90aGVyIHRoYW5wcmV2ZW50aW9ud2hpbGUgdGhlIGVkdWNhdGlvbixjb25uZWN0aW5nYWNjdXJhdGVseXdlcmUgYnVpbHR3YXMga2lsbGVkYWdyZWVtZW50c211Y2ggbW9yZSBEdWUgdG8gdGhld2lkdGg6IDEwMHNvbWUgb3RoZXJLaW5nZG9tIG9mdGhlIGVudGlyZWZhbW91cyBmb3J0byBjb25uZWN0b2JqZWN0aXZlc3RoZSBGcmVuY2hwZW9wbGUgYW5kZmVhdHVyZWQiPmlzIHNhaWQgdG9zdHJ1Y3R1cmFscmVmZXJlbmR1bW1vc3Qgb2Z0ZW5hIHNlcGFyYXRlLT4KPGRpdiBpZCBPZmZpY2lhbCB3b3JsZHdpZGUuYXJpYS1sYWJlbHRoZSBwbGFuZXRhbmQgaXQgd2FzZCIgdmFsdWU9Imxvb2tpbmcgYXRiZW5lZmljaWFsYXJlIGluIHRoZW1vbml0b3JpbmdyZXBvcnRlZGx5dGhlIG1vZGVybndvcmtpbmcgb25hbGxvd2VkIHRvd2hlcmUgdGhlIGlubm92YXRpdmU8L2E+PC9kaXY+c291bmR0cmFja3NlYXJjaEZvcm10ZW5kIHRvIGJlaW5wdXQgaWQ9Im9wZW5pbmcgb2ZyZXN0cmljdGVkYWRvcHRlZCBieWFkZHJlc3Npbmd0aGVvbG9naWFubWV0aG9kcyBvZnZhcmlhbnQgb2ZDaHJpc3RpYW4gdmVyeSBsYXJnZWF1dG9tb3RpdmVieSBmYXIgdGhlcmFuZ2UgZnJvbXB1cnN1aXQgb2Zmb2xsb3cgdGhlYnJvdWdodCB0b2luIEVuZ2xhbmRhZ3JlZSB0aGF0YWNjdXNlZCBvZmNvbWVzIGZyb21wcmV2ZW50aW5nZGl2IHN0eWxlPWhpcyBvciBoZXJ0cmVtZW5kb3VzZnJlZWRvbSBvZmNvbmNlcm5pbmcwIDFlbSAxZW07QmFza2V0YmFsbC9zdHlsZS5jc3NhbiBlYXJsaWVyZXZlbiBhZnRlci8iIHRpdGxlPSIuY29tL2luZGV4dGFraW5nIHRoZXBpdHRzYnVyZ2hjb250ZW50Ij4NPHNjcmlwdD4oZnR1cm5lZCBvdXRoYXZpbmcgdGhlPC9zcGFuPg0KIG9jY2FzaW9uYWxiZWNhdXNlIGl0c3RhcnRlZCB0b3BoeXNpY2FsbHk+PC9kaXY+CiAgY3JlYXRlZCBieUN1cnJlbnRseSwgYmdjb2xvcj0idGFiaW5kZXg9ImRpc2FzdHJvdXNBbmFseXRpY3MgYWxzbyBoYXMgYT48ZGl2IGlkPSI8L3N0eWxlPgo8Y2FsbGVkIGZvcnNpbmdlciBhbmQuc3JjID0gIi8vdmlvbGF0aW9uc3RoaXMgcG9pbnRjb25zdGFudGx5aXMgbG9jYXRlZHJlY29yZGluZ3NkIGZyb20gdGhlbmVkZXJsYW5kc3BvcnR1Z3XDqnPXoteR16jXmdeq2YHYp9ix2LPbjGRlc2Fycm9sbG9jb21lbnRhcmlvZWR1Y2FjacOzbnNlcHRpZW1icmVyZWdpc3RyYWRvZGlyZWNjacOzbnViaWNhY2nDs25wdWJsaWNpZGFkcmVzcHVlc3Rhc3Jlc3VsdGFkb3NpbXBvcnRhbnRlcmVzZXJ2YWRvc2FydMOtY3Vsb3NkaWZlcmVudGVzc2lndWllbnRlc3JlcMO6YmxpY2FzaXR1YWNpw7NubWluaXN0ZXJpb3ByaXZhY2lkYWRkaXJlY3RvcmlvZm9ybWFjacOzbnBvYmxhY2nDs25wcmVzaWRlbnRlY29udGVuaWRvc2FjY2Vzb3Jpb3N0ZWNobm9yYXRpcGVyc29uYWxlc2NhdGVnb3LDrWFlc3BlY2lhbGVzZGlzcG9uaWJsZWFjdHVhbGlkYWRyZWZlcmVuY2lhdmFsbGFkb2xpZGJpYmxpb3RlY2FyZWxhY2lvbmVzY2FsZW5kYXJpb3BvbMOtdGljYXNhbnRlcmlvcmVzZG9jdW1lbnRvc25hdHVyYWxlemFtYXRlcmlhbGVzZGlmZXJlbmNpYWVjb27Ds21pY2F0cmFuc3BvcnRlcm9kcsOtZ3VlenBhcnRpY2lwYXJlbmN1ZW50cmFuZGlzY3VzacOzbmVzdHJ1Y3R1cmFmdW5kYWNpw7NuZnJlY3VlbnRlc3Blcm1hbmVudGV0b3RhbG1lbnRl0LzQvtC20L3QvtCx0YPQtNC10YLQvNC+0LbQtdGC0LLRgNC10LzRj9GC0LDQutC20LXRh9GC0L7QsdGL0LHQvtC70LXQtdC+0YfQtdC90YzRjdGC0L7Qs9C+0LrQvtCz0LTQsNC/0L7RgdC70LXQstGB0LXQs9C+0YHQsNC50YLQtdGH0LXRgNC10LfQvNC+0LPRg9GC0YHQsNC50YLQsNC20LjQt9C90LjQvNC10LbQtNGD0LHRg9C00YPRgtCf0L7QuNGB0LrQt9C00LXRgdGM0LLQuNC00LXQvtGB0LLRj9C30LjQvdGD0LbQvdC+0YHQstC+0LXQudC70Y7QtNC10LnQv9C+0YDQvdC+0LzQvdC+0LPQvtC00LXRgtC10LnRgdCy0L7QuNGF0L/RgNCw0LLQsNGC0LDQutC+0LnQvNC10YHRgtC+0LjQvNC10LXRgtC20LjQt9C90YzQvtC00L3QvtC50LvRg9GH0YjQtdC/0LXRgNC10LTRh9Cw0YHRgtC40YfQsNGB0YLRjNGA0LDQsdC+0YLQvdC+0LLRi9GF0L/RgNCw0LLQvtGB0L7QsdC+0LnQv9C+0YLQvtC80LzQtdC90LXQtdGH0LjRgdC70LXQvdC+0LLRi9C10YPRgdC70YPQs9C+0LrQvtC70L7QvdCw0LfQsNC00YLQsNC60L7QtdGC0L7Qs9C00LDQv9C+0YfRgtC40J/QvtGB0LvQtdGC0LDQutC40LXQvdC+0LLRi9C50YHRgtC+0LjRgtGC0LDQutC40YXRgdGA0LDQt9GD0KHQsNC90LrRgtGE0L7RgNGD0LzQmtC+0LPQtNCw0LrQvdC40LPQuNGB0LvQvtCy0LDQvdCw0YjQtdC50L3QsNC50YLQuNGB0LLQvtC40LzRgdCy0Y/Qt9GM0LvRjtCx0L7QudGH0LDRgdGC0L7RgdGA0LXQtNC40JrRgNC+0LzQtdCk0L7RgNGD0LzRgNGL0L3QutC10YHRgtCw0LvQuNC/0L7QuNGB0LrRgtGL0YHRj9GH0LzQtdGB0Y/RhtGG0LXQvdGC0YDRgtGA0YPQtNCw0YHQsNC80YvRhdGA0YvQvdC60LDQndC+0LLRi9C50YfQsNGB0L7QstC80LXRgdGC0LDRhNC40LvRjNC80LzQsNGA0YLQsNGB0YLRgNCw0L3QvNC10YHRgtC10YLQtdC60YHRgtC90LDRiNC40YXQvNC40L3Rg9GC0LjQvNC10L3QuNC40LzQtdGO0YLQvdC+0LzQtdGA0LPQvtGA0L7QtNGB0LDQvNC+0LzRjdGC0L7QvNGD0LrQvtC90YbQtdGB0LLQvtC10LzQutCw0LrQvtC50JDRgNGF0LjQstmF2YbYqtiv2YnYpdix2LPYp9mE2LHYs9in2YTYqdin2YTYudin2YXZg9iq2KjZh9in2KjYsdin2YXYrNin2YTZitmI2YXYp9mE2LXZiNix2KzYr9mK2K/Yqdin2YTYudi22YjYpdi22KfZgdip2KfZhNmC2LPZhdin2YTYudin2KjYqtit2YXZitmE2YXZhNmB2KfYqtmF2YTYqtmC2YnYqti52K/ZitmE2KfZhNi02LnYsdij2K7YqNin2LHYqti32YjZitix2LnZhNmK2YPZhdil2LHZgdin2YLYt9mE2KjYp9iq2KfZhNmE2LrYqdiq2LHYqtmK2KjYp9mE2YbYp9iz2KfZhNi02YrYrtmF2YbYqtiv2YrYp9mE2LnYsdio2KfZhNmC2LXYtdin2YHZhNin2YXYudmE2YrZh9in2KrYrdiv2YrYq9in2YTZhNmH2YXYp9mE2LnZhdmE2YXZg9iq2KjYqdmK2YXZg9mG2YPYp9mE2LfZgdmE2YHZitiv2YrZiNil2K/Yp9ix2KnYqtin2LHZitiu2KfZhNi12K3Yqdiq2LPYrNmK2YTYp9mE2YjZgtiq2LnZhtiv2YXYp9mF2K/ZitmG2KnYqti12YXZitmF2KPYsdi02YrZgdin2YTYsNmK2YbYudix2KjZitip2KjZiNin2KjYqdij2YTYudin2KjYp9mE2LPZgdix2YXYtNin2YPZhNiq2LnYp9mE2YnYp9mE2KPZiNmE2KfZhNiz2YbYqdis2KfZhdi52KnYp9mE2LXYrdmB2KfZhNiv2YrZhtmD2YTZhdin2KrYp9mE2K7Yp9i12KfZhNmF2YTZgdij2LnYttin2KHZg9iq2KfYqNip2KfZhNiu2YrYsdix2LPYp9im2YTYp9mE2YLZhNio2KfZhNij2K/YqNmF2YLYp9i32LnZhdix2KfYs9mE2YXZhti32YLYqdin2YTZg9iq2KjYp9mE2LHYrNmE2KfYtNiq2LHZg9in2YTZgtiv2YXZiti52LfZitmDc0J5VGFnTmFtZSguanBnIiBhbHQ9IjFweCBzb2xpZCAjLmdpZiIgYWx0PSJ0cmFuc3BhcmVudGluZm9ybWF0aW9uYXBwbGljYXRpb24iIG9uY2xpY2s9ImVzdGFibGlzaGVkYWR2ZXJ0aXNpbmcucG5nIiBhbHQ9ImVudmlyb25tZW50cGVyZm9ybWFuY2VhcHByb3ByaWF0ZSZhbXA7bWRhc2g7aW1tZWRpYXRlbHk8L3N0cm9uZz48L3JhdGhlciB0aGFudGVtcGVyYXR1cmVkZXZlbG9wbWVudGNvbXBldGl0aW9ucGxhY2Vob2xkZXJ2aXNpYmlsaXR5OmNvcHlyaWdodCI+MCIgaGVpZ2h0PSJldmVuIHRob3VnaHJlcGxhY2VtZW50ZGVzdGluYXRpb25Db3Jwb3JhdGlvbjx1bCBjbGFzcz0iQXNzb2NpYXRpb25pbmRpdmlkdWFsc3BlcnNwZWN0aXZlc2V0VGltZW91dCh1cmwoaHR0cDovL21hdGhlbWF0aWNzbWFyZ2luLXRvcDpldmVudHVhbGx5IGRlc2NyaXB0aW9uKSBuby1yZXBlYXRjb2xsZWN0aW9ucy5KUEd8dGh1bWJ8cGFydGljaXBhdGUvaGVhZD48Ym9keWZsb2F0OmxlZnQ7PGxpIGNsYXNzPSJodW5kcmVkcyBvZgoKSG93ZXZlciwgY29tcG9zaXRpb25jbGVhcjpib3RoO2Nvb3BlcmF0aW9ud2l0aGluIHRoZSBsYWJlbCBmb3I9ImJvcmRlci10b3A6TmV3IFplYWxhbmRyZWNvbW1lbmRlZHBob3RvZ3JhcGh5aW50ZXJlc3RpbmcmbHQ7c3VwJmd0O2NvbnRyb3ZlcnN5TmV0aGVybGFuZHNhbHRlcm5hdGl2ZW1heGxlbmd0aD0ic3dpdHplcmxhbmREZXZlbG9wbWVudGVzc2VudGlhbGx5CgpBbHRob3VnaCA8L3RleHRhcmVhPnRodW5kZXJiaXJkcmVwcmVzZW50ZWQmYW1wO25kYXNoO3NwZWN1bGF0aW9uY29tbXVuaXRpZXNsZWdpc2xhdGlvbmVsZWN0cm9uaWNzCgk8ZGl2IGlkPSJpbGx1c3RyYXRlZGVuZ2luZWVyaW5ndGVycml0b3JpZXNhdXRob3JpdGllc2Rpc3RyaWJ1dGVkNiIgaGVpZ2h0PSJzYW5zLXNlcmlmO2NhcGFibGUgb2YgZGlzYXBwZWFyZWRpbnRlcmFjdGl2ZWxvb2tpbmcgZm9yaXQgd291bGQgYmVBZmdoYW5pc3RhbndhcyBjcmVhdGVkTWF0aC5mbG9vcihzdXJyb3VuZGluZ2NhbiBhbHNvIGJlb2JzZXJ2YXRpb25tYWludGVuYW5jZWVuY291bnRlcmVkPGgyIGNsYXNzPSJtb3JlIHJlY2VudGl0IGhhcyBiZWVuaW52YXNpb24gb2YpLmdldFRpbWUoKWZ1bmRhbWVudGFsRGVzcGl0ZSB0aGUiPjxkaXYgaWQ9Imluc3BpcmF0aW9uZXhhbWluYXRpb25wcmVwYXJhdGlvbmV4cGxhbmF0aW9uPGlucHV0IGlkPSI8L2E+PC9zcGFuPnZlcnNpb25zIG9maW5zdHJ1bWVudHNiZWZvcmUgdGhlICA9ICdodHRwOi8vRGVzY3JpcHRpb25yZWxhdGl2ZWx5IC5zdWJzdHJpbmcoZWFjaCBvZiB0aGVleHBlcmltZW50c2luZmx1ZW50aWFsaW50ZWdyYXRpb25tYW55IHBlb3BsZWR1ZSB0byB0aGUgY29tYmluYXRpb25kbyBub3QgaGF2ZU1pZGRsZSBFYXN0PG5vc2NyaXB0Pjxjb3B5cmlnaHQiIHBlcmhhcHMgdGhlaW5zdGl0dXRpb25pbiBEZWNlbWJlcmFycmFuZ2VtZW50bW9zdCBmYW1vdXNwZXJzb25hbGl0eWNyZWF0aW9uIG9mbGltaXRhdGlvbnNleGNsdXNpdmVseXNvdmVyZWlnbnR5LWNvbnRlbnQiPgo8dGQgY2xhc3M9InVuZGVyZ3JvdW5kcGFyYWxsZWwgdG9kb2N0cmluZSBvZm9jY3VwaWVkIGJ5dGVybWlub2xvZ3lSZW5haXNzYW5jZWEgbnVtYmVyIG9mc3VwcG9ydCBmb3JleHBsb3JhdGlvbnJlY29nbml0aW9ucHJlZGVjZXNzb3I8aW1nIHNyYz0iLzxoMSBjbGFzcz0icHVibGljYXRpb25tYXkgYWxzbyBiZXNwZWNpYWxpemVkPC9maWVsZHNldD5wcm9ncmVzc2l2ZW1pbGxpb25zIG9mc3RhdGVzIHRoYXRlbmZvcmNlbWVudGFyb3VuZCB0aGUgb25lIGFub3RoZXIucGFyZW50Tm9kZWFncmljdWx0dXJlQWx0ZXJuYXRpdmVyZXNlYXJjaGVyc3Rvd2FyZHMgdGhlTW9zdCBvZiB0aGVtYW55IG90aGVyIChlc3BlY2lhbGx5PHRkIHdpZHRoPSI7d2lkdGg6MTAwJWluZGVwZW5kZW50PGgzIGNsYXNzPSIgb25jaGFuZ2U9IikuYWRkQ2xhc3MoaW50ZXJhY3Rpb25PbmUgb2YgdGhlIGRhdWdodGVyIG9mYWNjZXNzb3JpZXNicmFuY2hlcyBvZg0KPGRpdiBpZD0idGhlIGxhcmdlc3RkZWNsYXJhdGlvbnJlZ3VsYXRpb25zSW5mb3JtYXRpb250cmFuc2xhdGlvbmRvY3VtZW50YXJ5aW4gb3JkZXIgdG8iPgo8aGVhZD4KPCIgaGVpZ2h0PSIxYWNyb3NzIHRoZSBvcmllbnRhdGlvbik7PC9zY3JpcHQ+aW1wbGVtZW50ZWRjYW4gYmUgc2VlbnRoZXJlIHdhcyBhZGVtb25zdHJhdGVjb250YWluZXIiPmNvbm5lY3Rpb25zdGhlIEJyaXRpc2h3YXMgd3JpdHRlbiFpbXBvcnRhbnQ7cHg7IG1hcmdpbi1mb2xsb3dlZCBieWFiaWxpdHkgdG8gY29tcGxpY2F0ZWRkdXJpbmcgdGhlIGltbWlncmF0aW9uYWxzbyBjYWxsZWQ8aDQgY2xhc3M9ImRpc3RpbmN0aW9ucmVwbGFjZWQgYnlnb3Zlcm5tZW50c2xvY2F0aW9uIG9maW4gTm92ZW1iZXJ3aGV0aGVyIHRoZTwvcD4KPC9kaXY+YWNxdWlzaXRpb25jYWxsZWQgdGhlIHBlcnNlY3V0aW9uZGVzaWduYXRpb257Zm9udC1zaXplOmFwcGVhcmVkIGluaW52ZXN0aWdhdGVleHBlcmllbmNlZG1vc3QgbGlrZWx5d2lkZWx5IHVzZWRkaXNjdXNzaW9uc3ByZXNlbmNlIG9mIChkb2N1bWVudC5leHRlbnNpdmVseUl0IGhhcyBiZWVuaXQgZG9lcyBub3Rjb250cmFyeSB0b2luaGFiaXRhbnRzaW1wcm92ZW1lbnRzY2hvbGFyc2hpcGNvbnN1bXB0aW9uaW5zdHJ1Y3Rpb25mb3IgZXhhbXBsZW9uZSBvciBtb3JlcHg7IHBhZGRpbmd0aGUgY3VycmVudGEgc2VyaWVzIG9mYXJlIHVzdWFsbHlyb2xlIGluIHRoZXByZXZpb3VzbHkgZGVyaXZhdGl2ZXNldmlkZW5jZSBvZmV4cGVyaWVuY2VzY29sb3JzY2hlbWVzdGF0ZWQgdGhhdGNlcnRpZmljYXRlPC9hPjwvZGl2Pgogc2VsZWN0ZWQ9ImhpZ2ggc2Nob29scmVzcG9uc2UgdG9jb21mb3J0YWJsZWFkb3B0aW9uIG9mdGhyZWUgeWVhcnN0aGUgY291bnRyeWluIEZlYnJ1YXJ5c28gdGhhdCB0aGVwZW9wbGUgd2hvIHByb3ZpZGVkIGJ5PHBhcmFtIG5hbWVhZmZlY3RlZCBieWluIHRlcm1zIG9mYXBwb2ludG1lbnRJU08tODg1OS0xIndhcyBib3JuIGluaGlzdG9yaWNhbCByZWdhcmRlZCBhc21lYXN1cmVtZW50aXMgYmFzZWQgb24gYW5kIG90aGVyIDogZnVuY3Rpb24oc2lnbmlmaWNhbnRjZWxlYnJhdGlvbnRyYW5zbWl0dGVkL2pzL2pxdWVyeS5pcyBrbm93biBhc3RoZW9yZXRpY2FsIHRhYmluZGV4PSJpdCBjb3VsZCBiZTxub3NjcmlwdD4KaGF2aW5nIGJlZW4NCjxoZWFkPg0KPCAmcXVvdDtUaGUgY29tcGlsYXRpb25oZSBoYWQgYmVlbnByb2R1Y2VkIGJ5cGhpbG9zb3BoZXJjb25zdHJ1Y3RlZGludGVuZGVkIHRvYW1vbmcgb3RoZXJjb21wYXJlZCB0b3RvIHNheSB0aGF0RW5naW5lZXJpbmdhIGRpZmZlcmVudHJlZmVycmVkIHRvZGlmZmVyZW5jZXNiZWxpZWYgdGhhdHBob3RvZ3JhcGhzaWRlbnRpZnlpbmdIaXN0b3J5IG9mIFJlcHVibGljIG9mbmVjZXNzYXJpbHlwcm9iYWJpbGl0eXRlY2huaWNhbGx5bGVhdmluZyB0aGVzcGVjdGFjdWxhcmZyYWN0aW9uIG9mZWxlY3RyaWNpdHloZWFkIG9mIHRoZXJlc3RhdXJhbnRzcGFydG5lcnNoaXBlbXBoYXNpcyBvbm1vc3QgcmVjZW50c2hhcmUgd2l0aCBzYXlpbmcgdGhhdGZpbGxlZCB3aXRoZGVzaWduZWQgdG9pdCBpcyBvZnRlbiI+PC9pZnJhbWU+YXMgZm9sbG93czptZXJnZWQgd2l0aHRocm91Z2ggdGhlY29tbWVyY2lhbCBwb2ludGVkIG91dG9wcG9ydHVuaXR5dmlldyBvZiB0aGVyZXF1aXJlbWVudGRpdmlzaW9uIG9mcHJvZ3JhbW1pbmdoZSByZWNlaXZlZHNldEludGVydmFsIj48L3NwYW4+PC9pbiBOZXcgWW9ya2FkZGl0aW9uYWwgY29tcHJlc3Npb24KCjxkaXYgaWQ9ImluY29ycG9yYXRlOzwvc2NyaXB0PjxhdHRhY2hFdmVudGJlY2FtZSB0aGUgIiB0YXJnZXQ9Il9jYXJyaWVkIG91dFNvbWUgb2YgdGhlc2NpZW5jZSBhbmR0aGUgdGltZSBvZkNvbnRhaW5lciI+bWFpbnRhaW5pbmdDaHJpc3RvcGhlck11Y2ggb2YgdGhld3JpdGluZ3Mgb2YiIGhlaWdodD0iMnNpemUgb2YgdGhldmVyc2lvbiBvZiBtaXh0dXJlIG9mIGJldHdlZW4gdGhlRXhhbXBsZXMgb2ZlZHVjYXRpb25hbGNvbXBldGl0aXZlIG9uc3VibWl0PSJkaXJlY3RvciBvZmRpc3RpbmN0aXZlL0RURCBYSFRNTCByZWxhdGluZyB0b3RlbmRlbmN5IHRvcHJvdmluY2Ugb2Z3aGljaCB3b3VsZGRlc3BpdGUgdGhlc2NpZW50aWZpYyBsZWdpc2xhdHVyZS5pbm5lckhUTUwgYWxsZWdhdGlvbnNBZ3JpY3VsdHVyZXdhcyB1c2VkIGluYXBwcm9hY2ggdG9pbnRlbGxpZ2VudHllYXJzIGxhdGVyLHNhbnMtc2VyaWZkZXRlcm1pbmluZ1BlcmZvcm1hbmNlYXBwZWFyYW5jZXMsIHdoaWNoIGlzIGZvdW5kYXRpb25zYWJicmV2aWF0ZWRoaWdoZXIgdGhhbnMgZnJvbSB0aGUgaW5kaXZpZHVhbCBjb21wb3NlZCBvZnN1cHBvc2VkIHRvY2xhaW1zIHRoYXRhdHRyaWJ1dGlvbmZvbnQtc2l6ZToxZWxlbWVudHMgb2ZIaXN0b3JpY2FsIGhpcyBicm90aGVyYXQgdGhlIHRpbWVhbm5pdmVyc2FyeWdvdmVybmVkIGJ5cmVsYXRlZCB0byB1bHRpbWF0ZWx5IGlubm92YXRpb25zaXQgaXMgc3RpbGxjYW4gb25seSBiZWRlZmluaXRpb25zdG9HTVRTdHJpbmdBIG51bWJlciBvZmltZyBjbGFzcz0iRXZlbnR1YWxseSx3YXMgY2hhbmdlZG9jY3VycmVkIGlubmVpZ2hib3JpbmdkaXN0aW5ndWlzaHdoZW4gaGUgd2FzaW50cm9kdWNpbmd0ZXJyZXN0cmlhbE1hbnkgb2YgdGhlYXJndWVzIHRoYXRhbiBBbWVyaWNhbmNvbnF1ZXN0IG9md2lkZXNwcmVhZCB3ZXJlIGtpbGxlZHNjcmVlbiBhbmQgSW4gb3JkZXIgdG9leHBlY3RlZCB0b2Rlc2NlbmRhbnRzYXJlIGxvY2F0ZWRsZWdpc2xhdGl2ZWdlbmVyYXRpb25zIGJhY2tncm91bmRtb3N0IHBlb3BsZXllYXJzIGFmdGVydGhlcmUgaXMgbm90aGUgaGlnaGVzdGZyZXF1ZW50bHkgdGhleSBkbyBub3Rhcmd1ZWQgdGhhdHNob3dlZCB0aGF0cHJlZG9taW5hbnR0aGVvbG9naWNhbGJ5IHRoZSB0aW1lY29uc2lkZXJpbmdzaG9ydC1saXZlZDwvc3Bhbj48L2E+Y2FuIGJlIHVzZWR2ZXJ5IGxpdHRsZW9uZSBvZiB0aGUgaGFkIGFscmVhZHlpbnRlcnByZXRlZGNvbW11bmljYXRlZmVhdHVyZXMgb2Znb3Zlcm5tZW50LDwvbm9zY3JpcHQ+ZW50ZXJlZCB0aGUiIGhlaWdodD0iM0luZGVwZW5kZW50cG9wdWxhdGlvbnNsYXJnZS1zY2FsZS4gQWx0aG91Z2ggdXNlZCBpbiB0aGVkZXN0cnVjdGlvbnBvc3NpYmlsaXR5c3RhcnRpbmcgaW50d28gb3IgbW9yZWV4cHJlc3Npb25zc3Vib3JkaW5hdGVsYXJnZXIgdGhhbmhpc3RvcnkgYW5kPC9vcHRpb24+DQpDb250aW5lbnRhbGVsaW1pbmF0aW5nd2lsbCBub3QgYmVwcmFjdGljZSBvZmluIGZyb250IG9mc2l0ZSBvZiB0aGVlbnN1cmUgdGhhdHRvIGNyZWF0ZSBhbWlzc2lzc2lwcGlwb3RlbnRpYWxseW91dHN0YW5kaW5nYmV0dGVyIHRoYW53aGF0IGlzIG5vd3NpdHVhdGVkIGlubWV0YSBuYW1lPSJUcmFkaXRpb25hbHN1Z2dlc3Rpb25zVHJhbnNsYXRpb250aGUgZm9ybSBvZmF0bW9zcGhlcmljaWRlb2xvZ2ljYWxlbnRlcnByaXNlc2NhbGN1bGF0aW5nZWFzdCBvZiB0aGVyZW1uYW50cyBvZnBsdWdpbnNwYWdlL2luZGV4LnBocD9yZW1haW5lZCBpbnRyYW5zZm9ybWVkSGUgd2FzIGFsc293YXMgYWxyZWFkeXN0YXRpc3RpY2FsaW4gZmF2b3Igb2ZNaW5pc3RyeSBvZm1vdmVtZW50IG9mZm9ybXVsYXRpb25pcyByZXF1aXJlZDxsaW5rIHJlbD0iVGhpcyBpcyB0aGUgPGEgaHJlZj0iL3BvcHVsYXJpemVkaW52b2x2ZWQgaW5hcmUgdXNlZCB0b2FuZCBzZXZlcmFsbWFkZSBieSB0aGVzZWVtcyB0byBiZWxpa2VseSB0aGF0UGFsZXN0aW5pYW5uYW1lZCBhZnRlcml0IGhhZCBiZWVubW9zdCBjb21tb250byByZWZlciB0b2J1dCB0aGlzIGlzY29uc2VjdXRpdmV0ZW1wb3JhcmlseUluIGdlbmVyYWwsY29udmVudGlvbnN0YWtlcyBwbGFjZXN1YmRpdmlzaW9udGVycml0b3JpYWxvcGVyYXRpb25hbHBlcm1hbmVudGx5d2FzIGxhcmdlbHlvdXRicmVhayBvZmluIHRoZSBwYXN0Zm9sbG93aW5nIGEgeG1sbnM6b2c9Ij48YSBjbGFzcz0iY2xhc3M9InRleHRDb252ZXJzaW9uIG1heSBiZSB1c2VkbWFudWZhY3R1cmVhZnRlciBiZWluZ2NsZWFyZml4Ij4KcXVlc3Rpb24gb2Z3YXMgZWxlY3RlZHRvIGJlY29tZSBhYmVjYXVzZSBvZiBzb21lIHBlb3BsZWluc3BpcmVkIGJ5c3VjY2Vzc2Z1bCBhIHRpbWUgd2hlbm1vcmUgY29tbW9uYW1vbmdzdCB0aGVhbiBvZmZpY2lhbHdpZHRoOjEwMCU7dGVjaG5vbG9neSx3YXMgYWRvcHRlZHRvIGtlZXAgdGhlc2V0dGxlbWVudHNsaXZlIGJpcnRoc2luZGV4Lmh0bWwiQ29ubmVjdGljdXRhc3NpZ25lZCB0byZhbXA7dGltZXM7YWNjb3VudCBmb3JhbGlnbj1yaWdodHRoZSBjb21wYW55YWx3YXlzIGJlZW5yZXR1cm5lZCB0b2ludm9sdmVtZW50QmVjYXVzZSB0aGV0aGlzIHBlcmlvZCIgbmFtZT0icSIgY29uZmluZWQgdG9hIHJlc3VsdCBvZnZhbHVlPSIiIC8+aXMgYWN0dWFsbHlFbnZpcm9ubWVudA0KPC9oZWFkPg0KQ29udmVyc2VseSw+CjxkaXYgaWQ9IjAiIHdpZHRoPSIxaXMgcHJvYmFibHloYXZlIGJlY29tZWNvbnRyb2xsaW5ndGhlIHByb2JsZW1jaXRpemVucyBvZnBvbGl0aWNpYW5zcmVhY2hlZCB0aGVhcyBlYXJseSBhczpub25lOyBvdmVyPHRhYmxlIGNlbGx2YWxpZGl0eSBvZmRpcmVjdGx5IHRvb25tb3VzZWRvd253aGVyZSBpdCBpc3doZW4gaXQgd2FzbWVtYmVycyBvZiByZWxhdGlvbiB0b2FjY29tbW9kYXRlYWxvbmcgd2l0aCBJbiB0aGUgbGF0ZXRoZSBFbmdsaXNoZGVsaWNpb3VzIj50aGlzIGlzIG5vdHRoZSBwcmVzZW50aWYgdGhleSBhcmVhbmQgZmluYWxseWEgbWF0dGVyIG9mDQoJPC9kaXY+DQoNCjwvc2NyaXB0PmZhc3RlciB0aGFubWFqb3JpdHkgb2ZhZnRlciB3aGljaGNvbXBhcmF0aXZldG8gbWFpbnRhaW5pbXByb3ZlIHRoZWF3YXJkZWQgdGhlZXIiIGNsYXNzPSJmcmFtZWJvcmRlcnJlc3RvcmF0aW9uaW4gdGhlIHNhbWVhbmFseXNpcyBvZnRoZWlyIGZpcnN0RHVyaW5nIHRoZSBjb250aW5lbnRhbHNlcXVlbmNlIG9mZnVuY3Rpb24oKXtmb250LXNpemU6IHdvcmsgb24gdGhlPC9zY3JpcHQ+CjxiZWdpbnMgd2l0aGphdmFzY3JpcHQ6Y29uc3RpdHVlbnR3YXMgZm91bmRlZGVxdWlsaWJyaXVtYXNzdW1lIHRoYXRpcyBnaXZlbiBieW5lZWRzIHRvIGJlY29vcmRpbmF0ZXN0aGUgdmFyaW91c2FyZSBwYXJ0IG9mb25seSBpbiB0aGVzZWN0aW9ucyBvZmlzIGEgY29tbW9udGhlb3JpZXMgb2ZkaXNjb3Zlcmllc2Fzc29jaWF0aW9uZWRnZSBvZiB0aGVzdHJlbmd0aCBvZnBvc2l0aW9uIGlucHJlc2VudC1kYXl1bml2ZXJzYWxseXRvIGZvcm0gdGhlYnV0IGluc3RlYWRjb3Jwb3JhdGlvbmF0dGFjaGVkIHRvaXMgY29tbW9ubHlyZWFzb25zIGZvciAmcXVvdDt0aGUgY2FuIGJlIG1hZGV3YXMgYWJsZSB0b3doaWNoIG1lYW5zYnV0IGRpZCBub3Rvbk1vdXNlT3ZlcmFzIHBvc3NpYmxlb3BlcmF0ZWQgYnljb21pbmcgZnJvbXRoZSBwcmltYXJ5YWRkaXRpb24gb2Zmb3Igc2V2ZXJhbHRyYW5zZmVycmVkYSBwZXJpb2Qgb2ZhcmUgYWJsZSB0b2hvd2V2ZXIsIGl0c2hvdWxkIGhhdmVtdWNoIGxhcmdlcgoJPC9zY3JpcHQ+YWRvcHRlZCB0aGVwcm9wZXJ0eSBvZmRpcmVjdGVkIGJ5ZWZmZWN0aXZlbHl3YXMgYnJvdWdodGNoaWxkcmVuIG9mUHJvZ3JhbW1pbmdsb25nZXIgdGhhbm1hbnVzY3JpcHRzd2FyIGFnYWluc3RieSBtZWFucyBvZmFuZCBtb3N0IG9mc2ltaWxhciB0byBwcm9wcmlldGFyeW9yaWdpbmF0aW5ncHJlc3RpZ2lvdXNncmFtbWF0aWNhbGV4cGVyaWVuY2UudG8gbWFrZSB0aGVJdCB3YXMgYWxzb2lzIGZvdW5kIGluY29tcGV0aXRvcnNpbiB0aGUgVS5TLnJlcGxhY2UgdGhlYnJvdWdodCB0aGVjYWxjdWxhdGlvbmZhbGwgb2YgdGhldGhlIGdlbmVyYWxwcmFjdGljYWxseWluIGhvbm9yIG9mcmVsZWFzZWQgaW5yZXNpZGVudGlhbGFuZCBzb21lIG9ma2luZyBvZiB0aGVyZWFjdGlvbiB0bzFzdCBFYXJsIG9mY3VsdHVyZSBhbmRwcmluY2lwYWxseTwvdGl0bGU+CiAgdGhleSBjYW4gYmViYWNrIHRvIHRoZXNvbWUgb2YgaGlzZXhwb3N1cmUgdG9hcmUgc2ltaWxhcmZvcm0gb2YgdGhlYWRkRmF2b3JpdGVjaXRpemVuc2hpcHBhcnQgaW4gdGhlcGVvcGxlIHdpdGhpbiBwcmFjdGljZXRvIGNvbnRpbnVlJmFtcDttaW51czthcHByb3ZlZCBieSB0aGUgZmlyc3QgYWxsb3dlZCB0aGVhbmQgZm9yIHRoZWZ1bmN0aW9uaW5ncGxheWluZyB0aGVzb2x1dGlvbiB0b2hlaWdodD0iMCIgaW4gaGlzIGJvb2ttb3JlIHRoYW4gYWZvbGxvd3MgdGhlY3JlYXRlZCB0aGVwcmVzZW5jZSBpbiZuYnNwOzwvdGQ+bmF0aW9uYWxpc3R0aGUgaWRlYSBvZmEgY2hhcmFjdGVyd2VyZSBmb3JjZWQgY2xhc3M9ImJ0bmRheXMgb2YgdGhlZmVhdHVyZWQgaW5zaG93aW5nIHRoZWludGVyZXN0IGluaW4gcGxhY2Ugb2Z0dXJuIG9mIHRoZXRoZSBoZWFkIG9mTG9yZCBvZiB0aGVwb2xpdGljYWxseWhhcyBpdHMgb3duRWR1Y2F0aW9uYWxhcHByb3ZhbCBvZnNvbWUgb2YgdGhlZWFjaCBvdGhlcixiZWhhdmlvciBvZmFuZCBiZWNhdXNlYW5kIGFub3RoZXJhcHBlYXJlZCBvbnJlY29yZGVkIGluYmxhY2smcXVvdDttYXkgaW5jbHVkZXRoZSB3b3JsZCdzY2FuIGxlYWQgdG9yZWZlcnMgdG8gYWJvcmRlcj0iMCIgZ292ZXJubWVudCB3aW5uaW5nIHRoZXJlc3VsdGVkIGluIHdoaWxlIHRoZSBXYXNoaW5ndG9uLHRoZSBzdWJqZWN0Y2l0eSBpbiB0aGU+PC9kaXY+DQoJCXJlZmxlY3QgdGhldG8gY29tcGxldGViZWNhbWUgbW9yZXJhZGlvYWN0aXZlcmVqZWN0ZWQgYnl3aXRob3V0IGFueWhpcyBmYXRoZXIsd2hpY2ggY291bGRjb3B5IG9mIHRoZXRvIGluZGljYXRlYSBwb2xpdGljYWxhY2NvdW50cyBvZmNvbnN0aXR1dGVzd29ya2VkIHdpdGhlcjwvYT48L2xpPm9mIGhpcyBsaWZlYWNjb21wYW5pZWRjbGllbnRXaWR0aHByZXZlbnQgdGhlTGVnaXNsYXRpdmVkaWZmZXJlbnRseXRvZ2V0aGVyIGluaGFzIHNldmVyYWxmb3IgYW5vdGhlcnRleHQgb2YgdGhlZm91bmRlZCB0aGVlIHdpdGggdGhlIGlzIHVzZWQgZm9yY2hhbmdlZCB0aGV1c3VhbGx5IHRoZXBsYWNlIHdoZXJld2hlcmVhcyB0aGU+IDxhIGhyZWY9IiI+PGEgaHJlZj0idGhlbXNlbHZlcyxhbHRob3VnaCBoZXRoYXQgY2FuIGJldHJhZGl0aW9uYWxyb2xlIG9mIHRoZWFzIGEgcmVzdWx0cmVtb3ZlQ2hpbGRkZXNpZ25lZCBieXdlc3Qgb2YgdGhlU29tZSBwZW9wbGVwcm9kdWN0aW9uLHNpZGUgb2YgdGhlbmV3c2xldHRlcnN1c2VkIGJ5IHRoZWRvd24gdG8gdGhlYWNjZXB0ZWQgYnlsaXZlIGluIHRoZWF0dGVtcHRzIHRvb3V0c2lkZSB0aGVmcmVxdWVuY2llc0hvd2V2ZXIsIGlucHJvZ3JhbW1lcnNhdCBsZWFzdCBpbmFwcHJveGltYXRlYWx0aG91Z2ggaXR3YXMgcGFydCBvZmFuZCB2YXJpb3VzR292ZXJub3Igb2Z0aGUgYXJ0aWNsZXR1cm5lZCBpbnRvPjxhIGhyZWY9Ii90aGUgZWNvbm9teWlzIHRoZSBtb3N0bW9zdCB3aWRlbHl3b3VsZCBsYXRlcmFuZCBwZXJoYXBzcmlzZSB0byB0aGVvY2N1cnMgd2hlbnVuZGVyIHdoaWNoY29uZGl0aW9ucy50aGUgd2VzdGVybnRoZW9yeSB0aGF0aXMgcHJvZHVjZWR0aGUgY2l0eSBvZmluIHdoaWNoIGhlc2VlbiBpbiB0aGV0aGUgY2VudHJhbGJ1aWxkaW5nIG9mbWFueSBvZiBoaXNhcmVhIG9mIHRoZWlzIHRoZSBvbmx5bW9zdCBvZiB0aGVtYW55IG9mIHRoZXRoZSBXZXN0ZXJuVGhlcmUgaXMgbm9leHRlbmRlZCB0b1N0YXRpc3RpY2FsY29sc3Bhbj0yIHxzaG9ydCBzdG9yeXBvc3NpYmxlIHRvdG9wb2xvZ2ljYWxjcml0aWNhbCBvZnJlcG9ydGVkIHRvYSBDaHJpc3RpYW5kZWNpc2lvbiB0b2lzIGVxdWFsIHRvcHJvYmxlbXMgb2ZUaGlzIGNhbiBiZW1lcmNoYW5kaXNlZm9yIG1vc3Qgb2ZubyBldmlkZW5jZWVkaXRpb25zIG9mZWxlbWVudHMgaW4mcXVvdDsuIFRoZWNvbS9pbWFnZXMvd2hpY2ggbWFrZXN0aGUgcHJvY2Vzc3JlbWFpbnMgdGhlbGl0ZXJhdHVyZSxpcyBhIG1lbWJlcnRoZSBwb3B1bGFydGhlIGFuY2llbnRwcm9ibGVtcyBpbnRpbWUgb2YgdGhlZGVmZWF0ZWQgYnlib2R5IG9mIHRoZWEgZmV3IHllYXJzbXVjaCBvZiB0aGV0aGUgd29yayBvZkNhbGlmb3JuaWEsc2VydmVkIGFzIGFnb3Zlcm5tZW50LmNvbmNlcHRzIG9mbW92ZW1lbnQgaW4JCTxkaXYgaWQ9Iml0IiB2YWx1ZT0ibGFuZ3VhZ2Ugb2ZhcyB0aGV5IGFyZXByb2R1Y2VkIGluaXMgdGhhdCB0aGVleHBsYWluIHRoZWRpdj48L2Rpdj4KSG93ZXZlciB0aGVsZWFkIHRvIHRoZQk8YSBocmVmPSIvd2FzIGdyYW50ZWRwZW9wbGUgaGF2ZWNvbnRpbnVhbGx5d2FzIHNlZW4gYXNhbmQgcmVsYXRlZHRoZSByb2xlIG9mcHJvcG9zZWQgYnlvZiB0aGUgYmVzdGVhY2ggb3RoZXIuQ29uc3RhbnRpbmVwZW9wbGUgZnJvbWRpYWxlY3RzIG9mdG8gcmV2aXNpb253YXMgcmVuYW1lZGEgc291cmNlIG9mdGhlIGluaXRpYWxsYXVuY2hlZCBpbnByb3ZpZGUgdGhldG8gdGhlIHdlc3R3aGVyZSB0aGVyZWFuZCBzaW1pbGFyYmV0d2VlbiB0d29pcyBhbHNvIHRoZUVuZ2xpc2ggYW5kY29uZGl0aW9ucyx0aGF0IGl0IHdhc2VudGl0bGVkIHRvdGhlbXNlbHZlcy5xdWFudGl0eSBvZnJhbnNwYXJlbmN5dGhlIHNhbWUgYXN0byBqb2luIHRoZWNvdW50cnkgYW5kdGhpcyBpcyB0aGVUaGlzIGxlZCB0b2Egc3RhdGVtZW50Y29udHJhc3QgdG9sYXN0SW5kZXhPZnRocm91Z2ggaGlzaXMgZGVzaWduZWR0aGUgdGVybSBpc2lzIHByb3ZpZGVkcHJvdGVjdCB0aGVuZzwvYT48L2xpPlRoZSBjdXJyZW50dGhlIHNpdGUgb2ZzdWJzdGFudGlhbGV4cGVyaWVuY2UsaW4gdGhlIFdlc3R0aGV5IHNob3VsZHNsb3ZlbsSNaW5hY29tZW50YXJpb3N1bml2ZXJzaWRhZGNvbmRpY2lvbmVzYWN0aXZpZGFkZXNleHBlcmllbmNpYXRlY25vbG9nw61hcHJvZHVjY2nDs25wdW50dWFjacOzbmFwbGljYWNpw7NuY29udHJhc2XDsWFjYXRlZ29yw61hc3JlZ2lzdHJhcnNlcHJvZmVzaW9uYWx0cmF0YW1pZW50b3JlZ8Otc3RyYXRlc2VjcmV0YXLDrWFwcmluY2lwYWxlc3Byb3RlY2Npw7NuaW1wb3J0YW50ZXNpbXBvcnRhbmNpYXBvc2liaWxpZGFkaW50ZXJlc2FudGVjcmVjaW1pZW50b25lY2VzaWRhZGVzc3VzY3JpYmlyc2Vhc29jaWFjacOzbmRpc3BvbmlibGVzZXZhbHVhY2nDs25lc3R1ZGlhbnRlc3Jlc3BvbnNhYmxlcmVzb2x1Y2nDs25ndWFkYWxhamFyYXJlZ2lzdHJhZG9zb3BvcnR1bmlkYWRjb21lcmNpYWxlc2ZvdG9ncmFmw61hYXV0b3JpZGFkZXNpbmdlbmllcsOtYXRlbGV2aXNpw7NuY29tcGV0ZW5jaWFvcGVyYWNpb25lc2VzdGFibGVjaWRvc2ltcGxlbWVudGVhY3R1YWxtZW50ZW5hdmVnYWNpw7NuY29uZm9ybWlkYWRsaW5lLWhlaWdodDpmb250LWZhbWlseToiIDogImh0dHA6Ly9hcHBsaWNhdGlvbnNsaW5rIiBocmVmPSJzcGVjaWZpY2FsbHkvLzwhW0NEQVRBWwpPcmdhbml6YXRpb25kaXN0cmlidXRpb24wcHg7IGhlaWdodDpyZWxhdGlvbnNoaXBkZXZpY2Utd2lkdGg8ZGl2IGNsYXNzPSI8bGFiZWwgZm9yPSJyZWdpc3RyYXRpb248L25vc2NyaXB0PgovaW5kZXguaHRtbCJ3aW5kb3cub3BlbiggIWltcG9ydGFudDthcHBsaWNhdGlvbi9pbmRlcGVuZGVuY2UvL3d3dy5nb29nbGVvcmdhbml6YXRpb25hdXRvY29tcGxldGVyZXF1aXJlbWVudHNjb25zZXJ2YXRpdmU8Zm9ybSBuYW1lPSJpbnRlbGxlY3R1YWxtYXJnaW4tbGVmdDoxOHRoIGNlbnR1cnlhbiBpbXBvcnRhbnRpbnN0aXR1dGlvbnNhYmJyZXZpYXRpb248aW1nIGNsYXNzPSJvcmdhbmlzYXRpb25jaXZpbGl6YXRpb24xOXRoIGNlbnR1cnlhcmNoaXRlY3R1cmVpbmNvcnBvcmF0ZWQyMHRoIGNlbnR1cnktY29udGFpbmVyIj5tb3N0IG5vdGFibHkvPjwvYT48L2Rpdj5ub3RpZmljYXRpb24ndW5kZWZpbmVkJylGdXJ0aGVybW9yZSxiZWxpZXZlIHRoYXRpbm5lckhUTUwgPSBwcmlvciB0byB0aGVkcmFtYXRpY2FsbHlyZWZlcnJpbmcgdG9uZWdvdGlhdGlvbnNoZWFkcXVhcnRlcnNTb3V0aCBBZnJpY2F1bnN1Y2Nlc3NmdWxQZW5uc3lsdmFuaWFBcyBhIHJlc3VsdCw8aHRtbCBsYW5nPSImbHQ7L3N1cCZndDtkZWFsaW5nIHdpdGhwaGlsYWRlbHBoaWFoaXN0b3JpY2FsbHkpOzwvc2NyaXB0PgpwYWRkaW5nLXRvcDpleHBlcmltZW50YWxnZXRBdHRyaWJ1dGVpbnN0cnVjdGlvbnN0ZWNobm9sb2dpZXNwYXJ0IG9mIHRoZSA9ZnVuY3Rpb24oKXtzdWJzY3JpcHRpb25sLmR0ZCI+DQo8aHRnZW9ncmFwaGljYWxDb25zdGl0dXRpb24nLCBmdW5jdGlvbihzdXBwb3J0ZWQgYnlhZ3JpY3VsdHVyYWxjb25zdHJ1Y3Rpb25wdWJsaWNhdGlvbnNmb250LXNpemU6IDFhIHZhcmlldHkgb2Y8ZGl2IHN0eWxlPSJFbmN5Y2xvcGVkaWFpZnJhbWUgc3JjPSJkZW1vbnN0cmF0ZWRhY2NvbXBsaXNoZWR1bml2ZXJzaXRpZXNEZW1vZ3JhcGhpY3MpOzwvc2NyaXB0PjxkZWRpY2F0ZWQgdG9rbm93bGVkZ2Ugb2ZzYXRpc2ZhY3Rpb25wYXJ0aWN1bGFybHk8L2Rpdj48L2Rpdj5FbmdsaXNoIChVUylhcHBlbmRDaGlsZCh0cmFuc21pc3Npb25zLiBIb3dldmVyLCBpbnRlbGxpZ2VuY2UiIHRhYmluZGV4PSJmbG9hdDpyaWdodDtDb21tb253ZWFsdGhyYW5naW5nIGZyb21pbiB3aGljaCB0aGVhdCBsZWFzdCBvbmVyZXByb2R1Y3Rpb25lbmN5Y2xvcGVkaWE7Zm9udC1zaXplOjFqdXJpc2RpY3Rpb25hdCB0aGF0IHRpbWUiPjxhIGNsYXNzPSJJbiBhZGRpdGlvbixkZXNjcmlwdGlvbitjb252ZXJzYXRpb25jb250YWN0IHdpdGhpcyBnZW5lcmFsbHlyIiBjb250ZW50PSJyZXByZXNlbnRpbmcmbHQ7bWF0aCZndDtwcmVzZW50YXRpb25vY2Nhc2lvbmFsbHk8aW1nIHdpZHRoPSJuYXZpZ2F0aW9uIj5jb21wZW5zYXRpb25jaGFtcGlvbnNoaXBtZWRpYT0iYWxsIiB2aW9sYXRpb24gb2ZyZWZlcmVuY2UgdG9yZXR1cm4gdHJ1ZTtTdHJpY3QvL0VOIiB0cmFuc2FjdGlvbnNpbnRlcnZlbnRpb252ZXJpZmljYXRpb25JbmZvcm1hdGlvbiBkaWZmaWN1bHRpZXNDaGFtcGlvbnNoaXBjYXBhYmlsaXRpZXM8IVtlbmRpZl0tLT59Cjwvc2NyaXB0PgpDaHJpc3RpYW5pdHlmb3IgZXhhbXBsZSxQcm9mZXNzaW9uYWxyZXN0cmljdGlvbnNzdWdnZXN0IHRoYXR3YXMgcmVsZWFzZWQoc3VjaCBhcyB0aGVyZW1vdmVDbGFzcyh1bmVtcGxveW1lbnR0aGUgQW1lcmljYW5zdHJ1Y3R1cmUgb2YvaW5kZXguaHRtbCBwdWJsaXNoZWQgaW5zcGFuIGNsYXNzPSIiPjxhIGhyZWY9Ii9pbnRyb2R1Y3Rpb25iZWxvbmdpbmcgdG9jbGFpbWVkIHRoYXRjb25zZXF1ZW5jZXM8bWV0YSBuYW1lPSJHdWlkZSB0byB0aGVvdmVyd2hlbG1pbmdhZ2FpbnN0IHRoZSBjb25jZW50cmF0ZWQsCi5ub250b3VjaCBvYnNlcnZhdGlvbnM8L2E+CjwvZGl2PgpmIChkb2N1bWVudC5ib3JkZXI6IDFweCB7Zm9udC1zaXplOjF0cmVhdG1lbnQgb2YwIiBoZWlnaHQ9IjFtb2RpZmljYXRpb25JbmRlcGVuZGVuY2VkaXZpZGVkIGludG9ncmVhdGVyIHRoYW5hY2hpZXZlbWVudHNlc3RhYmxpc2hpbmdKYXZhU2NyaXB0IiBuZXZlcnRoZWxlc3NzaWduaWZpY2FuY2VCcm9hZGNhc3Rpbmc+Jm5ic3A7PC90ZD5jb250YWluZXIiPgpzdWNoIGFzIHRoZSBpbmZsdWVuY2Ugb2ZhIHBhcnRpY3VsYXJzcmM9J2h0dHA6Ly9uYXZpZ2F0aW9uIiBoYWxmIG9mIHRoZSBzdWJzdGFudGlhbCAmbmJzcDs8L2Rpdj5hZHZhbnRhZ2Ugb2ZkaXNjb3Zlcnkgb2ZmdW5kYW1lbnRhbCBtZXRyb3BvbGl0YW50aGUgb3Bwb3NpdGUiIHhtbDpsYW5nPSJkZWxpYmVyYXRlbHlhbGlnbj1jZW50ZXJldm9sdXRpb24gb2ZwcmVzZXJ2YXRpb25pbXByb3ZlbWVudHNiZWdpbm5pbmcgaW5KZXN1cyBDaHJpc3RQdWJsaWNhdGlvbnNkaXNhZ3JlZW1lbnR0ZXh0LWFsaWduOnIsIGZ1bmN0aW9uKClzaW1pbGFyaXRpZXNib2R5PjwvaHRtbD5pcyBjdXJyZW50bHlhbHBoYWJldGljYWxpcyBzb21ldGltZXN0eXBlPSJpbWFnZS9tYW55IG9mIHRoZSBmbG93OmhpZGRlbjthdmFpbGFibGUgaW5kZXNjcmliZSB0aGVleGlzdGVuY2Ugb2ZhbGwgb3ZlciB0aGV0aGUgSW50ZXJuZXQJPHVsIGNsYXNzPSJpbnN0YWxsYXRpb25uZWlnaGJvcmhvb2Rhcm1lZCBmb3JjZXNyZWR1Y2luZyB0aGVjb250aW51ZXMgdG9Ob25ldGhlbGVzcyx0ZW1wZXJhdHVyZXMKCQk8YSBocmVmPSJjbG9zZSB0byB0aGVleGFtcGxlcyBvZiBpcyBhYm91dCB0aGUoc2VlIGJlbG93KS4iIGlkPSJzZWFyY2hwcm9mZXNzaW9uYWxpcyBhdmFpbGFibGV0aGUgb2ZmaWNpYWwJCTwvc2NyaXB0PgoKCQk8ZGl2IGlkPSJhY2NlbGVyYXRpb250aHJvdWdoIHRoZSBIYWxsIG9mIEZhbWVkZXNjcmlwdGlvbnN0cmFuc2xhdGlvbnNpbnRlcmZlcmVuY2UgdHlwZT0ndGV4dC9yZWNlbnQgeWVhcnNpbiB0aGUgd29ybGR2ZXJ5IHBvcHVsYXJ7YmFja2dyb3VuZDp0cmFkaXRpb25hbCBzb21lIG9mIHRoZSBjb25uZWN0ZWQgdG9leHBsb2l0YXRpb25lbWVyZ2VuY2Ugb2Zjb25zdGl0dXRpb25BIEhpc3Rvcnkgb2ZzaWduaWZpY2FudCBtYW51ZmFjdHVyZWRleHBlY3RhdGlvbnM+PG5vc2NyaXB0PjxjYW4gYmUgZm91bmRiZWNhdXNlIHRoZSBoYXMgbm90IGJlZW5uZWlnaGJvdXJpbmd3aXRob3V0IHRoZSBhZGRlZCB0byB0aGUJPGxpIGNsYXNzPSJpbnN0cnVtZW50YWxTb3ZpZXQgVW5pb25hY2tub3dsZWRnZWR3aGljaCBjYW4gYmVuYW1lIGZvciB0aGVhdHRlbnRpb24gdG9hdHRlbXB0cyB0byBkZXZlbG9wbWVudHNJbiBmYWN0LCB0aGU8bGkgY2xhc3M9ImFpbXBsaWNhdGlvbnNzdWl0YWJsZSBmb3JtdWNoIG9mIHRoZSBjb2xvbml6YXRpb25wcmVzaWRlbnRpYWxjYW5jZWxCdWJibGUgSW5mb3JtYXRpb25tb3N0IG9mIHRoZSBpcyBkZXNjcmliZWRyZXN0IG9mIHRoZSBtb3JlIG9yIGxlc3NpbiBTZXB0ZW1iZXJJbnRlbGxpZ2VuY2VzcmM9Imh0dHA6Ly9weDsgaGVpZ2h0OiBhdmFpbGFibGUgdG9tYW51ZmFjdHVyZXJodW1hbiByaWdodHNsaW5rIGhyZWY9Ii9hdmFpbGFiaWxpdHlwcm9wb3J0aW9uYWxvdXRzaWRlIHRoZSBhc3Ryb25vbWljYWxodW1hbiBiZWluZ3NuYW1lIG9mIHRoZSBhcmUgZm91bmQgaW5hcmUgYmFzZWQgb25zbWFsbGVyIHRoYW5hIHBlcnNvbiB3aG9leHBhbnNpb24gb2Zhcmd1aW5nIHRoYXRub3cga25vd24gYXNJbiB0aGUgZWFybHlpbnRlcm1lZGlhdGVkZXJpdmVkIGZyb21TY2FuZGluYXZpYW48L2E+PC9kaXY+DQpjb25zaWRlciB0aGVhbiBlc3RpbWF0ZWR0aGUgTmF0aW9uYWw8ZGl2IGlkPSJwYWdyZXN1bHRpbmcgaW5jb21taXNzaW9uZWRhbmFsb2dvdXMgdG9hcmUgcmVxdWlyZWQvdWw+CjwvZGl2Pgp3YXMgYmFzZWQgb25hbmQgYmVjYW1lIGEmbmJzcDsmbmJzcDt0IiB2YWx1ZT0iIiB3YXMgY2FwdHVyZWRubyBtb3JlIHRoYW5yZXNwZWN0aXZlbHljb250aW51ZSB0byA+DQo8aGVhZD4NCjx3ZXJlIGNyZWF0ZWRtb3JlIGdlbmVyYWxpbmZvcm1hdGlvbiB1c2VkIGZvciB0aGVpbmRlcGVuZGVudCB0aGUgSW1wZXJpYWxjb21wb25lbnQgb2Z0byB0aGUgbm9ydGhpbmNsdWRlIHRoZSBDb25zdHJ1Y3Rpb25zaWRlIG9mIHRoZSB3b3VsZCBub3QgYmVmb3IgaW5zdGFuY2VpbnZlbnRpb24gb2Ztb3JlIGNvbXBsZXhjb2xsZWN0aXZlbHliYWNrZ3JvdW5kOiB0ZXh0LWFsaWduOiBpdHMgb3JpZ2luYWxpbnRvIGFjY291bnR0aGlzIHByb2Nlc3NhbiBleHRlbnNpdmVob3dldmVyLCB0aGV0aGV5IGFyZSBub3RyZWplY3RlZCB0aGVjcml0aWNpc20gb2ZkdXJpbmcgd2hpY2hwcm9iYWJseSB0aGV0aGlzIGFydGljbGUoZnVuY3Rpb24oKXtJdCBzaG91bGQgYmVhbiBhZ3JlZW1lbnRhY2NpZGVudGFsbHlkaWZmZXJzIGZyb21BcmNoaXRlY3R1cmViZXR0ZXIga25vd25hcnJhbmdlbWVudHNpbmZsdWVuY2Ugb25hdHRlbmRlZCB0aGVpZGVudGljYWwgdG9zb3V0aCBvZiB0aGVwYXNzIHRocm91Z2h4bWwiIHRpdGxlPSJ3ZWlnaHQ6Ym9sZDtjcmVhdGluZyB0aGVkaXNwbGF5Om5vbmVyZXBsYWNlZCB0aGU8aW1nIHNyYz0iL2lodHRwczovL3d3dy5Xb3JsZCBXYXIgSUl0ZXN0aW1vbmlhbHNmb3VuZCBpbiB0aGVyZXF1aXJlZCB0byBhbmQgdGhhdCB0aGViZXR3ZWVuIHRoZSB3YXMgZGVzaWduZWRjb25zaXN0cyBvZiBjb25zaWRlcmFibHlwdWJsaXNoZWQgYnl0aGUgbGFuZ3VhZ2VDb25zZXJ2YXRpb25jb25zaXN0ZWQgb2ZyZWZlciB0byB0aGViYWNrIHRvIHRoZSBjc3MiIG1lZGlhPSJQZW9wbGUgZnJvbSBhdmFpbGFibGUgb25wcm92ZWQgdG8gYmVzdWdnZXN0aW9ucyJ3YXMga25vd24gYXN2YXJpZXRpZXMgb2ZsaWtlbHkgdG8gYmVjb21wcmlzZWQgb2ZzdXBwb3J0IHRoZSBoYW5kcyBvZiB0aGVjb3VwbGVkIHdpdGhjb25uZWN0IGFuZCBib3JkZXI6bm9uZTtwZXJmb3JtYW5jZXNiZWZvcmUgYmVpbmdsYXRlciBiZWNhbWVjYWxjdWxhdGlvbnNvZnRlbiBjYWxsZWRyZXNpZGVudHMgb2ZtZWFuaW5nIHRoYXQ+PGxpIGNsYXNzPSJldmlkZW5jZSBmb3JleHBsYW5hdGlvbnNlbnZpcm9ubWVudHMiPjwvYT48L2Rpdj53aGljaCBhbGxvd3NJbnRyb2R1Y3Rpb25kZXZlbG9wZWQgYnlhIHdpZGUgcmFuZ2VvbiBiZWhhbGYgb2Z2YWxpZ249InRvcCJwcmluY2lwbGUgb2ZhdCB0aGUgdGltZSw8L25vc2NyaXB0Pg1zYWlkIHRvIGhhdmVpbiB0aGUgZmlyc3R3aGlsZSBvdGhlcnNoeXBvdGhldGljYWxwaGlsb3NvcGhlcnNwb3dlciBvZiB0aGVjb250YWluZWQgaW5wZXJmb3JtZWQgYnlpbmFiaWxpdHkgdG93ZXJlIHdyaXR0ZW5zcGFuIHN0eWxlPSJpbnB1dCBuYW1lPSJ0aGUgcXVlc3Rpb25pbnRlbmRlZCBmb3JyZWplY3Rpb24gb2ZpbXBsaWVzIHRoYXRpbnZlbnRlZCB0aGV0aGUgc3RhbmRhcmR3YXMgcHJvYmFibHlsaW5rIGJldHdlZW5wcm9mZXNzb3Igb2ZpbnRlcmFjdGlvbnNjaGFuZ2luZyB0aGVJbmRpYW4gT2NlYW4gY2xhc3M9Imxhc3R3b3JraW5nIHdpdGgnaHR0cDovL3d3dy55ZWFycyBiZWZvcmVUaGlzIHdhcyB0aGVyZWNyZWF0aW9uYWxlbnRlcmluZyB0aGVtZWFzdXJlbWVudHNhbiBleHRyZW1lbHl2YWx1ZSBvZiB0aGVzdGFydCBvZiB0aGUKPC9zY3JpcHQ+CgphbiBlZmZvcnQgdG9pbmNyZWFzZSB0aGV0byB0aGUgc291dGhzcGFjaW5nPSIwIj5zdWZmaWNpZW50bHl0aGUgRXVyb3BlYW5jb252ZXJ0ZWQgdG9jbGVhclRpbWVvdXRkaWQgbm90IGhhdmVjb25zZXF1ZW50bHlmb3IgdGhlIG5leHRleHRlbnNpb24gb2ZlY29ub21pYyBhbmRhbHRob3VnaCB0aGVhcmUgcHJvZHVjZWRhbmQgd2l0aCB0aGVpbnN1ZmZpY2llbnRnaXZlbiBieSB0aGVzdGF0aW5nIHRoYXRleHBlbmRpdHVyZXM8L3NwYW4+PC9hPgp0aG91Z2h0IHRoYXRvbiB0aGUgYmFzaXNjZWxscGFkZGluZz1pbWFnZSBvZiB0aGVyZXR1cm5pbmcgdG9pbmZvcm1hdGlvbixzZXBhcmF0ZWQgYnlhc3Nhc3NpbmF0ZWRzIiBjb250ZW50PSJhdXRob3JpdHkgb2Zub3J0aHdlc3Rlcm48L2Rpdj4KPGRpdiAiPjwvZGl2Pg0KICBjb25zdWx0YXRpb25jb21tdW5pdHkgb2Z0aGUgbmF0aW9uYWxpdCBzaG91bGQgYmVwYXJ0aWNpcGFudHMgYWxpZ249ImxlZnR0aGUgZ3JlYXRlc3RzZWxlY3Rpb24gb2ZzdXBlcm5hdHVyYWxkZXBlbmRlbnQgb25pcyBtZW50aW9uZWRhbGxvd2luZyB0aGV3YXMgaW52ZW50ZWRhY2NvbXBhbnlpbmdoaXMgcGVyc29uYWxhdmFpbGFibGUgYXRzdHVkeSBvZiB0aGVvbiB0aGUgb3RoZXJleGVjdXRpb24gb2ZIdW1hbiBSaWdodHN0ZXJtcyBvZiB0aGVhc3NvY2lhdGlvbnNyZXNlYXJjaCBhbmRzdWNjZWVkZWQgYnlkZWZlYXRlZCB0aGVhbmQgZnJvbSB0aGVidXQgdGhleSBhcmVjb21tYW5kZXIgb2ZzdGF0ZSBvZiB0aGV5ZWFycyBvZiBhZ2V0aGUgc3R1ZHkgb2Y8dWwgY2xhc3M9InNwbGFjZSBpbiB0aGV3aGVyZSBoZSB3YXM8bGkgY2xhc3M9ImZ0aGVyZSBhcmUgbm93aGljaCBiZWNhbWVoZSBwdWJsaXNoZWRleHByZXNzZWQgaW50byB3aGljaCB0aGVjb21taXNzaW9uZXJmb250LXdlaWdodDp0ZXJyaXRvcnkgb2ZleHRlbnNpb25zIj5Sb21hbiBFbXBpcmVlcXVhbCB0byB0aGVJbiBjb250cmFzdCxob3dldmVyLCBhbmRpcyB0eXBpY2FsbHlhbmQgaGlzIHdpZmUoYWxzbyBjYWxsZWQ+PHVsIGNsYXNzPSJlZmZlY3RpdmVseSBldm9sdmVkIGludG9zZWVtIHRvIGhhdmV3aGljaCBpcyB0aGV0aGVyZSB3YXMgbm9hbiBleGNlbGxlbnRhbGwgb2YgdGhlc2VkZXNjcmliZWQgYnlJbiBwcmFjdGljZSxicm9hZGNhc3RpbmdjaGFyZ2VkIHdpdGhyZWZsZWN0ZWQgaW5zdWJqZWN0ZWQgdG9taWxpdGFyeSBhbmR0byB0aGUgcG9pbnRlY29ub21pY2FsbHlzZXRUYXJnZXRpbmdhcmUgYWN0dWFsbHl2aWN0b3J5IG92ZXIoKTs8L3NjcmlwdD5jb250aW51b3VzbHlyZXF1aXJlZCBmb3Jldm9sdXRpb25hcnlhbiBlZmZlY3RpdmVub3J0aCBvZiB0aGUsIHdoaWNoIHdhcyBmcm9udCBvZiB0aGVvciBvdGhlcndpc2Vzb21lIGZvcm0gb2ZoYWQgbm90IGJlZW5nZW5lcmF0ZWQgYnlpbmZvcm1hdGlvbi5wZXJtaXR0ZWQgdG9pbmNsdWRlcyB0aGVkZXZlbG9wbWVudCxlbnRlcmVkIGludG90aGUgcHJldmlvdXNjb25zaXN0ZW50bHlhcmUga25vd24gYXN0aGUgZmllbGQgb2Z0aGlzIHR5cGUgb2ZnaXZlbiB0byB0aGV0aGUgdGl0bGUgb2Zjb250YWlucyB0aGVpbnN0YW5jZXMgb2ZpbiB0aGUgbm9ydGhkdWUgdG8gdGhlaXJhcmUgZGVzaWduZWRjb3Jwb3JhdGlvbnN3YXMgdGhhdCB0aGVvbmUgb2YgdGhlc2Vtb3JlIHBvcHVsYXJzdWNjZWVkZWQgaW5zdXBwb3J0IGZyb21pbiBkaWZmZXJlbnRkb21pbmF0ZWQgYnlkZXNpZ25lZCBmb3Jvd25lcnNoaXAgb2ZhbmQgcG9zc2libHlzdGFuZGFyZGl6ZWRyZXNwb25zZVRleHR3YXMgaW50ZW5kZWRyZWNlaXZlZCB0aGVhc3N1bWVkIHRoYXRhcmVhcyBvZiB0aGVwcmltYXJpbHkgaW50aGUgYmFzaXMgb2ZpbiB0aGUgc2Vuc2VhY2NvdW50cyBmb3JkZXN0cm95ZWQgYnlhdCBsZWFzdCB0d293YXMgZGVjbGFyZWRjb3VsZCBub3QgYmVTZWNyZXRhcnkgb2ZhcHBlYXIgdG8gYmVtYXJnaW4tdG9wOjEvXlxzK3xccyskL2dlKXt0aHJvdyBlfTt0aGUgc3RhcnQgb2Z0d28gc2VwYXJhdGVsYW5ndWFnZSBhbmR3aG8gaGFkIGJlZW5vcGVyYXRpb24gb2ZkZWF0aCBvZiB0aGVyZWFsIG51bWJlcnMJPGxpbmsgcmVsPSJwcm92aWRlZCB0aGV0aGUgc3Rvcnkgb2Zjb21wZXRpdGlvbnNlbmdsaXNoIChVSyllbmdsaXNoIChVUynQnNC+0L3Qs9C+0LvQodGA0L/RgdC60LjRgdGA0L/RgdC60LjRgdGA0L/RgdC60L7ZhNi52LHYqNmK2KnmraPpq5TkuK3mlofnroDkvZPkuK3mlofnuYHkvZPkuK3mlofmnInpmZDlhazlj7jkurrmsJHmlL/lupzpmL/ph4zlt7Tlt7TnpL7kvJrkuLvkuYnmk43kvZzns7vnu5/mlL/nrZbms5Xop4RpbmZvcm1hY2nDs25oZXJyYW1pZW50YXNlbGVjdHLDs25pY29kZXNjcmlwY2nDs25jbGFzaWZpY2Fkb3Njb25vY2ltaWVudG9wdWJsaWNhY2nDs25yZWxhY2lvbmFkYXNpbmZvcm3DoXRpY2FyZWxhY2lvbmFkb3NkZXBhcnRhbWVudG90cmFiYWphZG9yZXNkaXJlY3RhbWVudGVheXVudGFtaWVudG9tZXJjYWRvTGlicmVjb250w6FjdGVub3NoYWJpdGFjaW9uZXNjdW1wbGltaWVudG9yZXN0YXVyYW50ZXNkaXNwb3NpY2nDs25jb25zZWN1ZW5jaWFlbGVjdHLDs25pY2FhcGxpY2FjaW9uZXNkZXNjb25lY3RhZG9pbnN0YWxhY2nDs25yZWFsaXphY2nDs251dGlsaXphY2nDs25lbmNpY2xvcGVkaWFlbmZlcm1lZGFkZXNpbnN0cnVtZW50b3NleHBlcmllbmNpYXNpbnN0aXR1Y2nDs25wYXJ0aWN1bGFyZXNzdWJjYXRlZ29yaWHRgtC+0LvRjNC60L7QoNC+0YHRgdC40LjRgNCw0LHQvtGC0YvQsdC+0LvRjNGI0LXQv9GA0L7RgdGC0L7QvNC+0LbQtdGC0LXQtNGA0YPQs9C40YXRgdC70YPRh9Cw0LXRgdC10LnRh9Cw0YHQstGB0LXQs9C00LDQoNC+0YHRgdC40Y/QnNC+0YHQutCy0LXQtNGA0YPQs9C40LXQs9C+0YDQvtC00LDQstC+0L/RgNC+0YHQtNCw0L3QvdGL0YXQtNC+0LvQttC90YvQuNC80LXQvdC90L7QnNC+0YHQutCy0YvRgNGD0LHQu9C10LnQnNC+0YHQutCy0LDRgdGC0YDQsNC90YvQvdC40YfQtdCz0L7RgNCw0LHQvtGC0LXQtNC+0LvQttC10L3Rg9GB0LvRg9Cz0LjRgtC10L/QtdGA0YzQntC00L3QsNC60L7Qv9C+0YLQvtC80YPRgNCw0LHQvtGC0YPQsNC/0YDQtdC70Y/QstC+0L7QsdGJ0LXQvtC00L3QvtCz0L7RgdCy0L7QtdCz0L7RgdGC0LDRgtGM0LjQtNGA0YPQs9C+0LnRhNC+0YDRg9C80LXRhdC+0YDQvtGI0L7Qv9GA0L7RgtC40LLRgdGB0YvQu9C60LDQutCw0LbQtNGL0LnQstC70LDRgdGC0LjQs9GA0YPQv9C/0YvQstC80LXRgdGC0LXRgNCw0LHQvtGC0LDRgdC60LDQt9Cw0LvQv9C10YDQstGL0LnQtNC10LvQsNGC0YzQtNC10L3RjNCz0LjQv9C10YDQuNC+0LTQsdC40LfQvdC10YHQvtGB0L3QvtCy0LXQvNC+0LzQtdC90YLQutGD0L/QuNGC0YzQtNC+0LvQttC90LDRgNCw0LzQutCw0YXQvdCw0YfQsNC70L7QoNCw0LHQvtGC0LDQotC+0LvRjNC60L7RgdC+0LLRgdC10LzQstGC0L7RgNC+0LnQvdCw0YfQsNC70LDRgdC/0LjRgdC+0LrRgdC70YPQttCx0YvRgdC40YHRgtC10LzQv9C10YfQsNGC0LjQvdC+0LLQvtCz0L7Qv9C+0LzQvtGJ0LjRgdCw0LnRgtC+0LLQv9C+0YfQtdC80YPQv9C+0LzQvtGJ0YzQtNC+0LvQttC90L7RgdGB0YvQu9C60LjQsdGL0YHRgtGA0L7QtNCw0L3QvdGL0LXQvNC90L7Qs9C40LXQv9GA0L7QtdC60YLQodC10LnRh9Cw0YHQvNC+0LTQtdC70LjRgtCw0LrQvtCz0L7QvtC90LvQsNC50L3Qs9C+0YDQvtC00LXQstC10YDRgdC40Y/RgdGC0YDQsNC90LXRhNC40LvRjNC80YvRg9GA0L7QstC90Y/RgNCw0LfQvdGL0YXQuNGB0LrQsNGC0YzQvdC10LTQtdC70Y7Rj9C90LLQsNGA0Y/QvNC10L3RjNGI0LXQvNC90L7Qs9C40YXQtNCw0L3QvdC+0LnQt9C90LDRh9C40YLQvdC10LvRjNC30Y/RhNC+0YDRg9C80LDQotC10L/QtdGA0YzQvNC10YHRj9GG0LDQt9Cw0YnQuNGC0YvQm9GD0YfRiNC40LXgpKjgpLngpYDgpILgpJXgpLDgpKjgpYfgpIXgpKrgpKjgpYfgpJXgpL/gpK/gpL7gpJXgpLDgpYfgpILgpIXgpKjgpY3gpK/gpJXgpY3gpK/gpL7gpJfgpL7gpIfgpKHgpKzgpL7gpLDgpYfgpJXgpL/gpLjgpYDgpKbgpL/gpK/gpL7gpKrgpLngpLLgpYfgpLjgpL/gpILgpLngpK3gpL7gpLDgpKTgpIXgpKrgpKjgpYDgpLXgpL7gpLLgpYfgpLjgpYfgpLXgpL7gpJXgpLDgpKTgpYfgpK7gpYfgpLDgpYfgpLngpYvgpKjgpYfgpLjgpJXgpKTgpYfgpKzgpLngpYHgpKTgpLjgpL7gpIfgpJ/gpLngpYvgpJfgpL7gpJzgpL7gpKjgpYfgpK7gpL/gpKjgpJ/gpJXgpLDgpKTgpL7gpJXgpLDgpKjgpL7gpIngpKjgpJXgpYfgpK/gpLngpL7gpIHgpLjgpKzgpLjgpYfgpK3gpL7gpLfgpL7gpIbgpKrgpJXgpYfgpLLgpL/gpK/gpYfgpLbgpYHgpLDgpYLgpIfgpLjgpJXgpYfgpJjgpILgpJ/gpYfgpK7gpYfgpLDgpYDgpLjgpJXgpKTgpL7gpK7gpYfgpLDgpL7gpLLgpYfgpJXgpLDgpIXgpKfgpL/gpJXgpIXgpKrgpKjgpL7gpLjgpK7gpL7gpJzgpK7gpYHgpJ3gpYfgpJXgpL7gpLDgpKPgpLngpYvgpKTgpL7gpJXgpKHgpLzgpYDgpK/gpLngpL7gpILgpLngpYvgpJ/gpLLgpLbgpKzgpY3gpKbgpLLgpL/gpK/gpL7gpJzgpYDgpLXgpKjgpJzgpL7gpKTgpL7gpJXgpYjgpLjgpYfgpIbgpKrgpJXgpL7gpLXgpL7gpLLgpYDgpKbgpYfgpKjgpYfgpKrgpYLgpLDgpYDgpKrgpL7gpKjgpYDgpIngpLjgpJXgpYfgpLngpYvgpJfgpYDgpKzgpYjgpKDgpJXgpIbgpKrgpJXgpYDgpLXgpLDgpY3gpLfgpJfgpL7gpILgpLXgpIbgpKrgpJXgpYvgpJzgpL/gpLLgpL7gpJzgpL7gpKjgpL7gpLjgpLngpK7gpKTgpLngpK7gpYfgpILgpIngpKjgpJXgpYDgpK/gpL7gpLngpYLgpKbgpLDgpY3gpJzgpLjgpYLgpJrgpYDgpKrgpLjgpILgpKbgpLjgpLXgpL7gpLLgpLngpYvgpKjgpL7gpLngpYvgpKTgpYDgpJzgpYjgpLjgpYfgpLXgpL7gpKrgpLjgpJzgpKjgpKTgpL7gpKjgpYfgpKTgpL7gpJzgpL7gpLDgpYDgpJjgpL7gpK/gpLLgpJzgpL/gpLLgpYfgpKjgpYDgpJrgpYfgpJzgpL7gpILgpJrgpKrgpKTgpY3gpLDgpJfgpYLgpJfgpLLgpJzgpL7gpKTgpYfgpKzgpL7gpLngpLDgpIbgpKrgpKjgpYfgpLXgpL7gpLngpKjgpIfgpLjgpJXgpL7gpLjgpYHgpKzgpLngpLDgpLngpKjgpYfgpIfgpLjgpLjgpYfgpLjgpLngpL/gpKTgpKzgpKHgpLzgpYfgpJjgpJ/gpKjgpL7gpKTgpLLgpL7gpLbgpKrgpL7gpILgpJrgpLbgpY3gpLDgpYDgpKzgpKHgpLzgpYDgpLngpYvgpKTgpYfgpLjgpL7gpIjgpJ/gpLbgpL7gpK/gpKbgpLjgpJXgpKTgpYDgpJzgpL7gpKTgpYDgpLXgpL7gpLLgpL7gpLngpJzgpL7gpLDgpKrgpJ/gpKjgpL7gpLDgpJbgpKjgpYfgpLjgpKHgpLzgpJXgpK7gpL/gpLLgpL7gpIngpLjgpJXgpYDgpJXgpYfgpLXgpLLgpLLgpJfgpKTgpL7gpJbgpL7gpKjgpL7gpIXgpLDgpY3gpKXgpJzgpLngpL7gpILgpKbgpYfgpJbgpL7gpKrgpLngpLLgpYDgpKjgpL/gpK/gpK7gpKzgpL/gpKjgpL7gpKzgpYjgpILgpJXgpJXgpLngpYDgpILgpJXgpLngpKjgpL7gpKbgpYfgpKTgpL7gpLngpK7gpLLgpYfgpJXgpL7gpKvgpYDgpJzgpKzgpJXgpL/gpKTgpYHgpLDgpKTgpK7gpL7gpILgpJfgpLXgpLngpYDgpILgpLDgpYvgpJzgpLzgpK7gpL/gpLLgpYDgpIbgpLDgpYvgpKrgpLjgpYfgpKjgpL7gpK/gpL7gpKbgpLXgpLLgpYfgpKjgpYfgpJbgpL7gpKTgpL7gpJXgpLDgpYDgpKzgpIngpKjgpJXgpL7gpJzgpLXgpL7gpKzgpKrgpYLgpLDgpL7gpKzgpKHgpLzgpL7gpLjgpYzgpKbgpL7gpLbgpYfgpK/gpLDgpJXgpL/gpK/gpYfgpJXgpLngpL7gpILgpIXgpJXgpLjgpLDgpKzgpKjgpL7gpI/gpLXgpLngpL7gpILgpLjgpY3gpKXgpLLgpK7gpL/gpLLgpYfgpLLgpYfgpJbgpJXgpLXgpL/gpLfgpK/gpJXgpY3gpLDgpILgpLjgpK7gpYLgpLngpKXgpL7gpKjgpL7Yqtiz2KrYt9mK2LnZhdi02KfYsdmD2KnYqNmI2KfYs9i32KnYp9mE2LXZgdit2KnZhdmI2KfYttmK2LnYp9mE2K7Yp9i12KnYp9mE2YXYstmK2K/Yp9mE2LnYp9mF2KnYp9mE2YPYp9iq2KjYp9mE2LHYr9mI2K/YqNix2YbYp9mF2KzYp9mE2K/ZiNmE2KnYp9mE2LnYp9mE2YXYp9mE2YXZiNmC2LnYp9mE2LnYsdio2YrYp9mE2LPYsdmK2LnYp9mE2KzZiNin2YTYp9mE2LDZh9in2KjYp9mE2K3Zitin2KnYp9mE2K3ZgtmI2YLYp9mE2YPYsdmK2YXYp9mE2LnYsdin2YLZhdit2YHZiNi42KnYp9mE2KvYp9mG2YrZhdi02KfZh9iv2KnYp9mE2YXYsdij2KnYp9mE2YLYsdii2YbYp9mE2LTYqNin2KjYp9mE2K3ZiNin2LHYp9mE2KzYr9mK2K/Yp9mE2KPYs9ix2KnYp9mE2LnZhNmI2YXZhdis2YXZiNi52KnYp9mE2LHYrdmF2YbYp9mE2YbZgtin2LfZgdmE2LPYt9mK2YbYp9mE2YPZiNmK2KrYp9mE2K/ZhtmK2KfYqNix2YPYp9iq2YfYp9mE2LHZitin2LbYqtit2YrYp9iq2YrYqNiq2YjZgtmK2KrYp9mE2KPZiNmE2YnYp9mE2KjYsdmK2K/Yp9mE2YPZhNin2YXYp9mE2LHYp9io2LfYp9mE2LTYrti12YrYs9mK2KfYsdin2KrYp9mE2KvYp9mE2KvYp9mE2LXZhNin2KnYp9mE2K3Yr9mK2KvYp9mE2LLZiNin2LHYp9mE2K7ZhNmK2KzYp9mE2KzZhdmK2LnYp9mE2LnYp9mF2YfYp9mE2KzZhdin2YTYp9mE2LPYp9i52KnZhdi02KfZh9iv2YfYp9mE2LHYptmK2LPYp9mE2K/YrtmI2YTYp9mE2YHZhtmK2KnYp9mE2YPYqtin2KjYp9mE2K/ZiNix2YrYp9mE2K/YsdmI2LPYp9iz2KrYutix2YLYqti12KfZhdmK2YXYp9mE2KjZhtin2KrYp9mE2LnYuNmK2YVlbnRlcnRhaW5tZW50dW5kZXJzdGFuZGluZyA9IGZ1bmN0aW9uKCkuanBnIiB3aWR0aD0iY29uZmlndXJhdGlvbi5wbmciIHdpZHRoPSI8Ym9keSBjbGFzcz0iTWF0aC5yYW5kb20oKWNvbnRlbXBvcmFyeSBVbml0ZWQgU3RhdGVzY2lyY3Vtc3RhbmNlcy5hcHBlbmRDaGlsZChvcmdhbml6YXRpb25zPHNwYW4gY2xhc3M9IiI+PGltZyBzcmM9Ii9kaXN0aW5ndWlzaGVkdGhvdXNhbmRzIG9mIGNvbW11bmljYXRpb25jbGVhciI+PC9kaXY+aW52ZXN0aWdhdGlvbmZhdmljb24uaWNvIiBtYXJnaW4tcmlnaHQ6YmFzZWQgb24gdGhlIE1hc3NhY2h1c2V0dHN0YWJsZSBib3JkZXI9aW50ZXJuYXRpb25hbGFsc28ga25vd24gYXNwcm9udW5jaWF0aW9uYmFja2dyb3VuZDojZnBhZGRpbmctbGVmdDpGb3IgZXhhbXBsZSwgbWlzY2VsbGFuZW91cyZsdDsvbWF0aCZndDtwc3ljaG9sb2dpY2FsaW4gcGFydGljdWxhcmVhcmNoIiB0eXBlPSJmb3JtIG1ldGhvZD0iYXMgb3Bwb3NlZCB0b1N1cHJlbWUgQ291cnRvY2Nhc2lvbmFsbHkgQWRkaXRpb25hbGx5LE5vcnRoIEFtZXJpY2FweDtiYWNrZ3JvdW5kb3Bwb3J0dW5pdGllc0VudGVydGFpbm1lbnQudG9Mb3dlckNhc2UobWFudWZhY3R1cmluZ3Byb2Zlc3Npb25hbCBjb21iaW5lZCB3aXRoRm9yIGluc3RhbmNlLGNvbnNpc3Rpbmcgb2YiIG1heGxlbmd0aD0icmV0dXJuIGZhbHNlO2NvbnNjaW91c25lc3NNZWRpdGVycmFuZWFuZXh0cmFvcmRpbmFyeWFzc2Fzc2luYXRpb25zdWJzZXF1ZW50bHkgYnV0dG9uIHR5cGU9InRoZSBudW1iZXIgb2Z0aGUgb3JpZ2luYWwgY29tcHJlaGVuc2l2ZXJlZmVycyB0byB0aGU8L3VsPgo8L2Rpdj4KcGhpbG9zb3BoaWNhbGxvY2F0aW9uLmhyZWZ3YXMgcHVibGlzaGVkU2FuIEZyYW5jaXNjbyhmdW5jdGlvbigpewo8ZGl2IGlkPSJtYWluc29waGlzdGljYXRlZG1hdGhlbWF0aWNhbCAvaGVhZD4NCjxib2R5c3VnZ2VzdHMgdGhhdGRvY3VtZW50YXRpb25jb25jZW50cmF0aW9ucmVsYXRpb25zaGlwc21heSBoYXZlIGJlZW4oZm9yIGV4YW1wbGUsVGhpcyBhcnRpY2xlIGluIHNvbWUgY2FzZXNwYXJ0cyBvZiB0aGUgZGVmaW5pdGlvbiBvZkdyZWF0IEJyaXRhaW4gY2VsbHBhZGRpbmc9ZXF1aXZhbGVudCB0b3BsYWNlaG9sZGVyPSI7IGZvbnQtc2l6ZToganVzdGlmaWNhdGlvbmJlbGlldmVkIHRoYXRzdWZmZXJlZCBmcm9tYXR0ZW1wdGVkIHRvIGxlYWRlciBvZiB0aGVjcmlwdCIgc3JjPSIvKGZ1bmN0aW9uKCkge2FyZSBhdmFpbGFibGUKCTxsaW5rIHJlbD0iIHNyYz0naHR0cDovL2ludGVyZXN0ZWQgaW5jb252ZW50aW9uYWwgIiBhbHQ9IiIgLz48L2FyZSBnZW5lcmFsbHloYXMgYWxzbyBiZWVubW9zdCBwb3B1bGFyIGNvcnJlc3BvbmRpbmdjcmVkaXRlZCB3aXRodHlsZT0iYm9yZGVyOjwvYT48L3NwYW4+PC8uZ2lmIiB3aWR0aD0iPGlmcmFtZSBzcmM9InRhYmxlIGNsYXNzPSJpbmxpbmUtYmxvY2s7YWNjb3JkaW5nIHRvIHRvZ2V0aGVyIHdpdGhhcHByb3hpbWF0ZWx5cGFybGlhbWVudGFyeW1vcmUgYW5kIG1vcmVkaXNwbGF5Om5vbmU7dHJhZGl0aW9uYWxseXByZWRvbWluYW50bHkmbmJzcDt8Jm5ic3A7Jm5ic3A7PC9zcGFuPiBjZWxsc3BhY2luZz08aW5wdXQgbmFtZT0ib3IiIGNvbnRlbnQ9ImNvbnRyb3ZlcnNpYWxwcm9wZXJ0eT0ib2c6L3gtc2hvY2t3YXZlLWRlbW9uc3RyYXRpb25zdXJyb3VuZGVkIGJ5TmV2ZXJ0aGVsZXNzLHdhcyB0aGUgZmlyc3Rjb25zaWRlcmFibGUgQWx0aG91Z2ggdGhlIGNvbGxhYm9yYXRpb25zaG91bGQgbm90IGJlcHJvcG9ydGlvbiBvZjxzcGFuIHN0eWxlPSJrbm93biBhcyB0aGUgc2hvcnRseSBhZnRlcmZvciBpbnN0YW5jZSxkZXNjcmliZWQgYXMgL2hlYWQ+Cjxib2R5IHN0YXJ0aW5nIHdpdGhpbmNyZWFzaW5nbHkgdGhlIGZhY3QgdGhhdGRpc2N1c3Npb24gb2ZtaWRkbGUgb2YgdGhlYW4gaW5kaXZpZHVhbGRpZmZpY3VsdCB0byBwb2ludCBvZiB2aWV3aG9tb3NleHVhbGl0eWFjY2VwdGFuY2Ugb2Y8L3NwYW4+PC9kaXY+bWFudWZhY3R1cmVyc29yaWdpbiBvZiB0aGVjb21tb25seSB1c2VkaW1wb3J0YW5jZSBvZmRlbm9taW5hdGlvbnNiYWNrZ3JvdW5kOiAjbGVuZ3RoIG9mIHRoZWRldGVybWluYXRpb25hIHNpZ25pZmljYW50IiBib3JkZXI9IjAiPnJldm9sdXRpb25hcnlwcmluY2lwbGVzIG9maXMgY29uc2lkZXJlZHdhcyBkZXZlbG9wZWRJbmRvLUV1cm9wZWFudnVsbmVyYWJsZSB0b3Byb3BvbmVudHMgb2ZhcmUgc29tZXRpbWVzY2xvc2VyIHRvIHRoZU5ldyBZb3JrIENpdHkgbmFtZT0ic2VhcmNoYXR0cmlidXRlZCB0b2NvdXJzZSBvZiB0aGVtYXRoZW1hdGljaWFuYnkgdGhlIGVuZCBvZmF0IHRoZSBlbmQgb2YiIGJvcmRlcj0iMCIgdGVjaG5vbG9naWNhbC5yZW1vdmVDbGFzcyhicmFuY2ggb2YgdGhlZXZpZGVuY2UgdGhhdCFbZW5kaWZdLS0+DQpJbnN0aXR1dGUgb2YgaW50byBhIHNpbmdsZXJlc3BlY3RpdmVseS5hbmQgdGhlcmVmb3JlcHJvcGVydGllcyBvZmlzIGxvY2F0ZWQgaW5zb21lIG9mIHdoaWNoVGhlcmUgaXMgYWxzb2NvbnRpbnVlZCB0byBhcHBlYXJhbmNlIG9mICZhbXA7bmRhc2g7IGRlc2NyaWJlcyB0aGVjb25zaWRlcmF0aW9uYXV0aG9yIG9mIHRoZWluZGVwZW5kZW50bHllcXVpcHBlZCB3aXRoZG9lcyBub3QgaGF2ZTwvYT48YSBocmVmPSJjb25mdXNlZCB3aXRoPGxpbmsgaHJlZj0iL2F0IHRoZSBhZ2Ugb2ZhcHBlYXIgaW4gdGhlVGhlc2UgaW5jbHVkZXJlZ2FyZGxlc3Mgb2Zjb3VsZCBiZSB1c2VkIHN0eWxlPSZxdW90O3NldmVyYWwgdGltZXNyZXByZXNlbnQgdGhlYm9keT4KPC9odG1sPnRob3VnaHQgdG8gYmVwb3B1bGF0aW9uIG9mcG9zc2liaWxpdGllc3BlcmNlbnRhZ2Ugb2ZhY2Nlc3MgdG8gdGhlYW4gYXR0ZW1wdCB0b3Byb2R1Y3Rpb24gb2ZqcXVlcnkvanF1ZXJ5dHdvIGRpZmZlcmVudGJlbG9uZyB0byB0aGVlc3RhYmxpc2htZW50cmVwbGFjaW5nIHRoZWRlc2NyaXB0aW9uIiBkZXRlcm1pbmUgdGhlYXZhaWxhYmxlIGZvckFjY29yZGluZyB0byB3aWRlIHJhbmdlIG9mCTxkaXYgY2xhc3M9Im1vcmUgY29tbW9ubHlvcmdhbmlzYXRpb25zZnVuY3Rpb25hbGl0eXdhcyBjb21wbGV0ZWQgJmFtcDttZGFzaDsgcGFydGljaXBhdGlvbnRoZSBjaGFyYWN0ZXJhbiBhZGRpdGlvbmFsYXBwZWFycyB0byBiZWZhY3QgdGhhdCB0aGVhbiBleGFtcGxlIG9mc2lnbmlmaWNhbnRseW9ubW91c2VvdmVyPSJiZWNhdXNlIHRoZXkgYXN5bmMgPSB0cnVlO3Byb2JsZW1zIHdpdGhzZWVtcyB0byBoYXZldGhlIHJlc3VsdCBvZiBzcmM9Imh0dHA6Ly9mYW1pbGlhciB3aXRocG9zc2Vzc2lvbiBvZmZ1bmN0aW9uICgpIHt0b29rIHBsYWNlIGluYW5kIHNvbWV0aW1lc3N1YnN0YW50aWFsbHk8c3Bhbj48L3NwYW4+aXMgb2Z0ZW4gdXNlZGluIGFuIGF0dGVtcHRncmVhdCBkZWFsIG9mRW52aXJvbm1lbnRhbHN1Y2Nlc3NmdWxseSB2aXJ0dWFsbHkgYWxsMjB0aCBjZW50dXJ5LHByb2Zlc3Npb25hbHNuZWNlc3NhcnkgdG8gZGV0ZXJtaW5lZCBieWNvbXBhdGliaWxpdHliZWNhdXNlIGl0IGlzRGljdGlvbmFyeSBvZm1vZGlmaWNhdGlvbnNUaGUgZm9sbG93aW5nbWF5IHJlZmVyIHRvOkNvbnNlcXVlbnRseSxJbnRlcm5hdGlvbmFsYWx0aG91Z2ggc29tZXRoYXQgd291bGQgYmV3b3JsZCdzIGZpcnN0Y2xhc3NpZmllZCBhc2JvdHRvbSBvZiB0aGUocGFydGljdWxhcmx5YWxpZ249ImxlZnQiIG1vc3QgY29tbW9ubHliYXNpcyBmb3IgdGhlZm91bmRhdGlvbiBvZmNvbnRyaWJ1dGlvbnNwb3B1bGFyaXR5IG9mY2VudGVyIG9mIHRoZXRvIHJlZHVjZSB0aGVqdXJpc2RpY3Rpb25zYXBwcm94aW1hdGlvbiBvbm1vdXNlb3V0PSJOZXcgVGVzdGFtZW50Y29sbGVjdGlvbiBvZjwvc3Bhbj48L2E+PC9pbiB0aGUgVW5pdGVkZmlsbSBkaXJlY3Rvci1zdHJpY3QuZHRkIj5oYXMgYmVlbiB1c2VkcmV0dXJuIHRvIHRoZWFsdGhvdWdoIHRoaXNjaGFuZ2UgaW4gdGhlc2V2ZXJhbCBvdGhlcmJ1dCB0aGVyZSBhcmV1bnByZWNlZGVudGVkaXMgc2ltaWxhciB0b2VzcGVjaWFsbHkgaW53ZWlnaHQ6IGJvbGQ7aXMgY2FsbGVkIHRoZWNvbXB1dGF0aW9uYWxpbmRpY2F0ZSB0aGF0cmVzdHJpY3RlZCB0bwk8bWV0YSBuYW1lPSJhcmUgdHlwaWNhbGx5Y29uZmxpY3Qgd2l0aEhvd2V2ZXIsIHRoZSBBbiBleGFtcGxlIG9mY29tcGFyZWQgd2l0aHF1YW50aXRpZXMgb2ZyYXRoZXIgdGhhbiBhY29uc3RlbGxhdGlvbm5lY2Vzc2FyeSBmb3JyZXBvcnRlZCB0aGF0c3BlY2lmaWNhdGlvbnBvbGl0aWNhbCBhbmQmbmJzcDsmbmJzcDs8cmVmZXJlbmNlcyB0b3RoZSBzYW1lIHllYXJHb3Zlcm5tZW50IG9mZ2VuZXJhdGlvbiBvZmhhdmUgbm90IGJlZW5zZXZlcmFsIHllYXJzY29tbWl0bWVudCB0bwkJPHVsIGNsYXNzPSJ2aXN1YWxpemF0aW9uMTl0aCBjZW50dXJ5LHByYWN0aXRpb25lcnN0aGF0IGhlIHdvdWxkYW5kIGNvbnRpbnVlZG9jY3VwYXRpb24gb2ZpcyBkZWZpbmVkIGFzY2VudHJlIG9mIHRoZXRoZSBhbW91bnQgb2Y+PGRpdiBzdHlsZT0iZXF1aXZhbGVudCBvZmRpZmZlcmVudGlhdGVicm91Z2h0IGFib3V0bWFyZ2luLWxlZnQ6IGF1dG9tYXRpY2FsbHl0aG91Z2h0IG9mIGFzU29tZSBvZiB0aGVzZQo8ZGl2IGNsYXNzPSJpbnB1dCBjbGFzcz0icmVwbGFjZWQgd2l0aGlzIG9uZSBvZiB0aGVlZHVjYXRpb24gYW5kaW5mbHVlbmNlZCBieXJlcHV0YXRpb24gYXMKPG1ldGEgbmFtZT0iYWNjb21tb2RhdGlvbjwvZGl2Pgo8L2Rpdj5sYXJnZSBwYXJ0IG9mSW5zdGl0dXRlIGZvcnRoZSBzby1jYWxsZWQgYWdhaW5zdCB0aGUgSW4gdGhpcyBjYXNlLHdhcyBhcHBvaW50ZWRjbGFpbWVkIHRvIGJlSG93ZXZlciwgdGhpc0RlcGFydG1lbnQgb2Z0aGUgcmVtYWluaW5nZWZmZWN0IG9uIHRoZXBhcnRpY3VsYXJseSBkZWFsIHdpdGggdGhlCjxkaXYgc3R5bGU9ImFsbW9zdCBhbHdheXNhcmUgY3VycmVudGx5ZXhwcmVzc2lvbiBvZnBoaWxvc29waHkgb2Zmb3IgbW9yZSB0aGFuY2l2aWxpemF0aW9uc29uIHRoZSBpc2xhbmRzZWxlY3RlZEluZGV4Y2FuIHJlc3VsdCBpbiIgdmFsdWU9IiIgLz50aGUgc3RydWN0dXJlIC8+PC9hPjwvZGl2Pk1hbnkgb2YgdGhlc2VjYXVzZWQgYnkgdGhlb2YgdGhlIFVuaXRlZHNwYW4gY2xhc3M9Im1jYW4gYmUgdHJhY2VkaXMgcmVsYXRlZCB0b2JlY2FtZSBvbmUgb2ZpcyBmcmVxdWVudGx5bGl2aW5nIGluIHRoZXRoZW9yZXRpY2FsbHlGb2xsb3dpbmcgdGhlUmV2b2x1dGlvbmFyeWdvdmVybm1lbnQgaW5pcyBkZXRlcm1pbmVkdGhlIHBvbGl0aWNhbGludHJvZHVjZWQgaW5zdWZmaWNpZW50IHRvZGVzY3JpcHRpb24iPnNob3J0IHN0b3JpZXNzZXBhcmF0aW9uIG9mYXMgdG8gd2hldGhlcmtub3duIGZvciBpdHN3YXMgaW5pdGlhbGx5ZGlzcGxheTpibG9ja2lzIGFuIGV4YW1wbGV0aGUgcHJpbmNpcGFsY29uc2lzdHMgb2YgYXJlY29nbml6ZWQgYXMvYm9keT48L2h0bWw+YSBzdWJzdGFudGlhbHJlY29uc3RydWN0ZWRoZWFkIG9mIHN0YXRlcmVzaXN0YW5jZSB0b3VuZGVyZ3JhZHVhdGVUaGVyZSBhcmUgdHdvZ3Jhdml0YXRpb25hbGFyZSBkZXNjcmliZWRpbnRlbnRpb25hbGx5c2VydmVkIGFzIHRoZWNsYXNzPSJoZWFkZXJvcHBvc2l0aW9uIHRvZnVuZGFtZW50YWxseWRvbWluYXRlZCB0aGVhbmQgdGhlIG90aGVyYWxsaWFuY2Ugd2l0aHdhcyBmb3JjZWQgdG9yZXNwZWN0aXZlbHksYW5kIHBvbGl0aWNhbGluIHN1cHBvcnQgb2ZwZW9wbGUgaW4gdGhlMjB0aCBjZW50dXJ5LmFuZCBwdWJsaXNoZWRsb2FkQ2hhcnRiZWF0dG8gdW5kZXJzdGFuZG1lbWJlciBzdGF0ZXNlbnZpcm9ubWVudGFsZmlyc3QgaGFsZiBvZmNvdW50cmllcyBhbmRhcmNoaXRlY3R1cmFsYmUgY29uc2lkZXJlZGNoYXJhY3Rlcml6ZWRjbGVhckludGVydmFsYXV0aG9yaXRhdGl2ZUZlZGVyYXRpb24gb2Z3YXMgc3VjY2VlZGVkYW5kIHRoZXJlIGFyZWEgY29uc2VxdWVuY2V0aGUgUHJlc2lkZW50YWxzbyBpbmNsdWRlZGZyZWUgc29mdHdhcmVzdWNjZXNzaW9uIG9mZGV2ZWxvcGVkIHRoZXdhcyBkZXN0cm95ZWRhd2F5IGZyb20gdGhlOwo8L3NjcmlwdD4KPGFsdGhvdWdoIHRoZXlmb2xsb3dlZCBieSBhbW9yZSBwb3dlcmZ1bHJlc3VsdGVkIGluIGFVbml2ZXJzaXR5IG9mSG93ZXZlciwgbWFueXRoZSBwcmVzaWRlbnRIb3dldmVyLCBzb21laXMgdGhvdWdodCB0b3VudGlsIHRoZSBlbmR3YXMgYW5ub3VuY2VkYXJlIGltcG9ydGFudGFsc28gaW5jbHVkZXM+PGlucHV0IHR5cGU9dGhlIGNlbnRlciBvZiBETyBOT1QgQUxURVJ1c2VkIHRvIHJlZmVydGhlbWVzLz9zb3J0PXRoYXQgaGFkIGJlZW50aGUgYmFzaXMgZm9yaGFzIGRldmVsb3BlZGluIHRoZSBzdW1tZXJjb21wYXJhdGl2ZWx5ZGVzY3JpYmVkIHRoZXN1Y2ggYXMgdGhvc2V0aGUgcmVzdWx0aW5naXMgaW1wb3NzaWJsZXZhcmlvdXMgb3RoZXJTb3V0aCBBZnJpY2FuaGF2ZSB0aGUgc2FtZWVmZmVjdGl2ZW5lc3NpbiB3aGljaCBjYXNlOyB0ZXh0LWFsaWduOnN0cnVjdHVyZSBhbmQ7IGJhY2tncm91bmQ6cmVnYXJkaW5nIHRoZXN1cHBvcnRlZCB0aGVpcyBhbHNvIGtub3duc3R5bGU9Im1hcmdpbmluY2x1ZGluZyB0aGViYWhhc2EgTWVsYXl1bm9yc2sgYm9rbcOlbG5vcnNrIG55bm9yc2tzbG92ZW7FocSNaW5haW50ZXJuYWNpb25hbGNhbGlmaWNhY2nDs25jb211bmljYWNpw7NuY29uc3RydWNjacOzbiI+PGRpdiBjbGFzcz0iZGlzYW1iaWd1YXRpb25Eb21haW5OYW1lJywgJ2FkbWluaXN0cmF0aW9uc2ltdWx0YW5lb3VzbHl0cmFuc3BvcnRhdGlvbkludGVybmF0aW9uYWwgbWFyZ2luLWJvdHRvbTpyZXNwb25zaWJpbGl0eTwhW2VuZGlmXS0tPgo8Lz48bWV0YSBuYW1lPSJpbXBsZW1lbnRhdGlvbmluZnJhc3RydWN0dXJlcmVwcmVzZW50YXRpb25ib3JkZXItYm90dG9tOjwvaGVhZD4KPGJvZHk+PWh0dHAlM0ElMkYlMkY8Zm9ybSBtZXRob2Q9Im1ldGhvZD0icG9zdCIgL2Zhdmljb24uaWNvIiB9KTsKPC9zY3JpcHQ+Ci5zZXRBdHRyaWJ1dGUoQWRtaW5pc3RyYXRpb249IG5ldyBBcnJheSgpOzwhW2VuZGlmXS0tPg0KZGlzcGxheTpibG9jaztVbmZvcnR1bmF0ZWx5LCI+Jm5ic3A7PC9kaXY+L2Zhdmljb24uaWNvIj49J3N0eWxlc2hlZXQnIGlkZW50aWZpY2F0aW9uLCBmb3IgZXhhbXBsZSw8bGk+PGEgaHJlZj0iL2FuIGFsdGVybmF0aXZlYXMgYSByZXN1bHQgb2ZwdCI+PC9zY3JpcHQ+CnR5cGU9InN1Ym1pdCIgCihmdW5jdGlvbigpIHtyZWNvbW1lbmRhdGlvbmZvcm0gYWN0aW9uPSIvdHJhbnNmb3JtYXRpb25yZWNvbnN0cnVjdGlvbi5zdHlsZS5kaXNwbGF5IEFjY29yZGluZyB0byBoaWRkZW4iIG5hbWU9ImFsb25nIHdpdGggdGhlZG9jdW1lbnQuYm9keS5hcHByb3hpbWF0ZWx5IENvbW11bmljYXRpb25zcG9zdCIgYWN0aW9uPSJtZWFuaW5nICZxdW90Oy0tPCFbZW5kaWZdLS0+UHJpbWUgTWluaXN0ZXJjaGFyYWN0ZXJpc3RpYzwvYT4gPGEgY2xhc3M9dGhlIGhpc3Rvcnkgb2Ygb25tb3VzZW92ZXI9InRoZSBnb3Zlcm5tZW50aHJlZj0iaHR0cHM6Ly93YXMgb3JpZ2luYWxseXdhcyBpbnRyb2R1Y2VkY2xhc3NpZmljYXRpb25yZXByZXNlbnRhdGl2ZWFyZSBjb25zaWRlcmVkPCFbZW5kaWZdLS0+CgpkZXBlbmRzIG9uIHRoZVVuaXZlcnNpdHkgb2YgaW4gY29udHJhc3QgdG8gcGxhY2Vob2xkZXI9ImluIHRoZSBjYXNlIG9maW50ZXJuYXRpb25hbCBjb25zdGl0dXRpb25hbHN0eWxlPSJib3JkZXItOiBmdW5jdGlvbigpIHtCZWNhdXNlIG9mIHRoZS1zdHJpY3QuZHRkIj4KPHRhYmxlIGNsYXNzPSJhY2NvbXBhbmllZCBieWFjY291bnQgb2YgdGhlPHNjcmlwdCBzcmM9Ii9uYXR1cmUgb2YgdGhlIHRoZSBwZW9wbGUgaW4gaW4gYWRkaXRpb24gdG9zKTsganMuaWQgPSBpZCIgd2lkdGg9IjEwMCUicmVnYXJkaW5nIHRoZSBSb21hbiBDYXRob2xpY2FuIGluZGVwZW5kZW50Zm9sbG93aW5nIHRoZSAuZ2lmIiB3aWR0aD0iMXRoZSBmb2xsb3dpbmcgZGlzY3JpbWluYXRpb25hcmNoYWVvbG9naWNhbHByaW1lIG1pbmlzdGVyLmpzIj48L3NjcmlwdD5jb21iaW5hdGlvbiBvZiBtYXJnaW53aWR0aD0iY3JlYXRlRWxlbWVudCh3LmF0dGFjaEV2ZW50KDwvYT48L3RkPjwvdHI+c3JjPSJodHRwczovL2FJbiBwYXJ0aWN1bGFyLCBhbGlnbj0ibGVmdCIgQ3plY2ggUmVwdWJsaWNVbml0ZWQgS2luZ2RvbWNvcnJlc3BvbmRlbmNlY29uY2x1ZGVkIHRoYXQuaHRtbCIgdGl0bGU9IihmdW5jdGlvbiAoKSB7Y29tZXMgZnJvbSB0aGVhcHBsaWNhdGlvbiBvZjxzcGFuIGNsYXNzPSJzYmVsaWV2ZWQgdG8gYmVlbWVudCgnc2NyaXB0JzwvYT4KPC9saT4KPGxpdmVyeSBkaWZmZXJlbnQ+PHNwYW4gY2xhc3M9Im9wdGlvbiB2YWx1ZT0iKGFsc28ga25vd24gYXMJPGxpPjxhIGhyZWY9Ij48aW5wdXQgbmFtZT0ic2VwYXJhdGVkIGZyb21yZWZlcnJlZCB0byBhcyB2YWxpZ249InRvcCI+Zm91bmRlciBvZiB0aGVhdHRlbXB0aW5nIHRvIGNhcmJvbiBkaW94aWRlCgo8ZGl2IGNsYXNzPSJjbGFzcz0ic2VhcmNoLS9ib2R5Pgo8L2h0bWw+b3Bwb3J0dW5pdHkgdG9jb21tdW5pY2F0aW9uczwvaGVhZD4NCjxib2R5IHN0eWxlPSJ3aWR0aDpUaeG6v25nIFZp4buHdGNoYW5nZXMgaW4gdGhlYm9yZGVyLWNvbG9yOiMwIiBib3JkZXI9IjAiIDwvc3Bhbj48L2Rpdj48d2FzIGRpc2NvdmVyZWQiIHR5cGU9InRleHQiICk7Cjwvc2NyaXB0PgoKRGVwYXJ0bWVudCBvZiBlY2NsZXNpYXN0aWNhbHRoZXJlIGhhcyBiZWVucmVzdWx0aW5nIGZyb208L2JvZHk+PC9odG1sPmhhcyBuZXZlciBiZWVudGhlIGZpcnN0IHRpbWVpbiByZXNwb25zZSB0b2F1dG9tYXRpY2FsbHkgPC9kaXY+Cgo8ZGl2IGl3YXMgY29uc2lkZXJlZHBlcmNlbnQgb2YgdGhlIiAvPjwvYT48L2Rpdj5jb2xsZWN0aW9uIG9mIGRlc2NlbmRlZCBmcm9tc2VjdGlvbiBvZiB0aGVhY2NlcHQtY2hhcnNldHRvIGJlIGNvbmZ1c2VkbWVtYmVyIG9mIHRoZSBwYWRkaW5nLXJpZ2h0OnRyYW5zbGF0aW9uIG9maW50ZXJwcmV0YXRpb24gaHJlZj0naHR0cDovL3doZXRoZXIgb3Igbm90VGhlcmUgYXJlIGFsc290aGVyZSBhcmUgbWFueWEgc21hbGwgbnVtYmVyb3RoZXIgcGFydHMgb2ZpbXBvc3NpYmxlIHRvICBjbGFzcz0iYnV0dG9ubG9jYXRlZCBpbiB0aGUuIEhvd2V2ZXIsIHRoZWFuZCBldmVudHVhbGx5QXQgdGhlIGVuZCBvZiBiZWNhdXNlIG9mIGl0c3JlcHJlc2VudHMgdGhlPGZvcm0gYWN0aW9uPSIgbWV0aG9kPSJwb3N0Iml0IGlzIHBvc3NpYmxlbW9yZSBsaWtlbHkgdG9hbiBpbmNyZWFzZSBpbmhhdmUgYWxzbyBiZWVuY29ycmVzcG9uZHMgdG9hbm5vdW5jZWQgdGhhdGFsaWduPSJyaWdodCI+bWFueSBjb3VudHJpZXNmb3IgbWFueSB5ZWFyc2VhcmxpZXN0IGtub3duYmVjYXVzZSBpdCB3YXNwdCI+PC9zY3JpcHQ+DSB2YWxpZ249InRvcCIgaW5oYWJpdGFudHMgb2Zmb2xsb3dpbmcgeWVhcg0KPGRpdiBjbGFzcz0ibWlsbGlvbiBwZW9wbGVjb250cm92ZXJzaWFsIGNvbmNlcm5pbmcgdGhlYXJndWUgdGhhdCB0aGVnb3Zlcm5tZW50IGFuZGEgcmVmZXJlbmNlIHRvdHJhbnNmZXJyZWQgdG9kZXNjcmliaW5nIHRoZSBzdHlsZT0iY29sb3I6YWx0aG91Z2ggdGhlcmViZXN0IGtub3duIGZvcnN1Ym1pdCIgbmFtZT0ibXVsdGlwbGljYXRpb25tb3JlIHRoYW4gb25lIHJlY29nbml0aW9uIG9mQ291bmNpbCBvZiB0aGVlZGl0aW9uIG9mIHRoZSAgPG1ldGEgbmFtZT0iRW50ZXJ0YWlubWVudCBhd2F5IGZyb20gdGhlIDttYXJnaW4tcmlnaHQ6YXQgdGhlIHRpbWUgb2ZpbnZlc3RpZ2F0aW9uc2Nvbm5lY3RlZCB3aXRoYW5kIG1hbnkgb3RoZXJhbHRob3VnaCBpdCBpc2JlZ2lubmluZyB3aXRoIDxzcGFuIGNsYXNzPSJkZXNjZW5kYW50cyBvZjxzcGFuIGNsYXNzPSJpIGFsaWduPSJyaWdodCI8L2hlYWQ+Cjxib2R5IGFzcGVjdHMgb2YgdGhlaGFzIHNpbmNlIGJlZW5FdXJvcGVhbiBVbmlvbnJlbWluaXNjZW50IG9mbW9yZSBkaWZmaWN1bHRWaWNlIFByZXNpZGVudGNvbXBvc2l0aW9uIG9mcGFzc2VkIHRocm91Z2htb3JlIGltcG9ydGFudGZvbnQtc2l6ZToxMXB4ZXhwbGFuYXRpb24gb2Z0aGUgY29uY2VwdCBvZndyaXR0ZW4gaW4gdGhlCTxzcGFuIGNsYXNzPSJpcyBvbmUgb2YgdGhlIHJlc2VtYmxhbmNlIHRvb24gdGhlIGdyb3VuZHN3aGljaCBjb250YWluc2luY2x1ZGluZyB0aGUgZGVmaW5lZCBieSB0aGVwdWJsaWNhdGlvbiBvZm1lYW5zIHRoYXQgdGhlb3V0c2lkZSBvZiB0aGVzdXBwb3J0IG9mIHRoZTxpbnB1dCBjbGFzcz0iPHNwYW4gY2xhc3M9InQoTWF0aC5yYW5kb20oKW1vc3QgcHJvbWluZW50ZGVzY3JpcHRpb24gb2ZDb25zdGFudGlub3BsZXdlcmUgcHVibGlzaGVkPGRpdiBjbGFzcz0ic2VhcHBlYXJzIGluIHRoZTEiIGhlaWdodD0iMSIgbW9zdCBpbXBvcnRhbnR3aGljaCBpbmNsdWRlc3doaWNoIGhhZCBiZWVuZGVzdHJ1Y3Rpb24gb2Z0aGUgcG9wdWxhdGlvbgoJPGRpdiBjbGFzcz0icG9zc2liaWxpdHkgb2Zzb21ldGltZXMgdXNlZGFwcGVhciB0byBoYXZlc3VjY2VzcyBvZiB0aGVpbnRlbmRlZCB0byBiZXByZXNlbnQgaW4gdGhlc3R5bGU9ImNsZWFyOmINCjwvc2NyaXB0Pg0KPHdhcyBmb3VuZGVkIGluaW50ZXJ2aWV3IHdpdGhfaWQiIGNvbnRlbnQ9ImNhcGl0YWwgb2YgdGhlDQo8bGluayByZWw9InNyZWxlYXNlIG9mIHRoZXBvaW50IG91dCB0aGF0eE1MSHR0cFJlcXVlc3RhbmQgc3Vic2VxdWVudHNlY29uZCBsYXJnZXN0dmVyeSBpbXBvcnRhbnRzcGVjaWZpY2F0aW9uc3N1cmZhY2Ugb2YgdGhlYXBwbGllZCB0byB0aGVmb3JlaWduIHBvbGljeV9zZXREb21haW5OYW1lZXN0YWJsaXNoZWQgaW5pcyBiZWxpZXZlZCB0b0luIGFkZGl0aW9uIHRvbWVhbmluZyBvZiB0aGVpcyBuYW1lZCBhZnRlcnRvIHByb3RlY3QgdGhlaXMgcmVwcmVzZW50ZWREZWNsYXJhdGlvbiBvZm1vcmUgZWZmaWNpZW50Q2xhc3NpZmljYXRpb25vdGhlciBmb3JtcyBvZmhlIHJldHVybmVkIHRvPHNwYW4gY2xhc3M9ImNwZXJmb3JtYW5jZSBvZihmdW5jdGlvbigpIHsNaWYgYW5kIG9ubHkgaWZyZWdpb25zIG9mIHRoZWxlYWRpbmcgdG8gdGhlcmVsYXRpb25zIHdpdGhVbml0ZWQgTmF0aW9uc3N0eWxlPSJoZWlnaHQ6b3RoZXIgdGhhbiB0aGV5cGUiIGNvbnRlbnQ9IkFzc29jaWF0aW9uIG9mCjwvaGVhZD4KPGJvZHlsb2NhdGVkIG9uIHRoZWlzIHJlZmVycmVkIHRvKGluY2x1ZGluZyB0aGVjb25jZW50cmF0aW9uc3RoZSBpbmRpdmlkdWFsYW1vbmcgdGhlIG1vc3R0aGFuIGFueSBvdGhlci8+CjxsaW5rIHJlbD0iIHJldHVybiBmYWxzZTt0aGUgcHVycG9zZSBvZnRoZSBhYmlsaXR5IHRvO2NvbG9yOiNmZmZ9Ci4KPHNwYW4gY2xhc3M9InRoZSBzdWJqZWN0IG9mZGVmaW5pdGlvbnMgb2Y+DQo8bGluayByZWw9ImNsYWltIHRoYXQgdGhlaGF2ZSBkZXZlbG9wZWQ8dGFibGUgd2lkdGg9ImNlbGVicmF0aW9uIG9mRm9sbG93aW5nIHRoZSB0byBkaXN0aW5ndWlzaDxzcGFuIGNsYXNzPSJidGFrZXMgcGxhY2UgaW51bmRlciB0aGUgbmFtZW5vdGVkIHRoYXQgdGhlPjwhW2VuZGlmXS0tPgpzdHlsZT0ibWFyZ2luLWluc3RlYWQgb2YgdGhlaW50cm9kdWNlZCB0aGV0aGUgcHJvY2VzcyBvZmluY3JlYXNpbmcgdGhlZGlmZmVyZW5jZXMgaW5lc3RpbWF0ZWQgdGhhdGVzcGVjaWFsbHkgdGhlL2Rpdj48ZGl2IGlkPSJ3YXMgZXZlbnR1YWxseXRocm91Z2hvdXQgaGlzdGhlIGRpZmZlcmVuY2Vzb21ldGhpbmcgdGhhdHNwYW4+PC9zcGFuPjwvc2lnbmlmaWNhbnRseSA+PC9zY3JpcHQ+DQoNCmVudmlyb25tZW50YWwgdG8gcHJldmVudCB0aGVoYXZlIGJlZW4gdXNlZGVzcGVjaWFsbHkgZm9ydW5kZXJzdGFuZCB0aGVpcyBlc3NlbnRpYWxseXdlcmUgdGhlIGZpcnN0aXMgdGhlIGxhcmdlc3RoYXZlIGJlZW4gbWFkZSIgc3JjPSJodHRwOi8vaW50ZXJwcmV0ZWQgYXNzZWNvbmQgaGFsZiBvZmNyb2xsaW5nPSJubyIgaXMgY29tcG9zZWQgb2ZJSSwgSG9seSBSb21hbmlzIGV4cGVjdGVkIHRvaGF2ZSB0aGVpciBvd25kZWZpbmVkIGFzIHRoZXRyYWRpdGlvbmFsbHkgaGF2ZSBkaWZmZXJlbnRhcmUgb2Z0ZW4gdXNlZHRvIGVuc3VyZSB0aGF0YWdyZWVtZW50IHdpdGhjb250YWluaW5nIHRoZWFyZSBmcmVxdWVudGx5aW5mb3JtYXRpb24gb25leGFtcGxlIGlzIHRoZXJlc3VsdGluZyBpbiBhPC9hPjwvbGk+PC91bD4gY2xhc3M9ImZvb3RlcmFuZCBlc3BlY2lhbGx5dHlwZT0iYnV0dG9uIiA8L3NwYW4+PC9zcGFuPndoaWNoIGluY2x1ZGVkPgo8bWV0YSBuYW1lPSJjb25zaWRlcmVkIHRoZWNhcnJpZWQgb3V0IGJ5SG93ZXZlciwgaXQgaXNiZWNhbWUgcGFydCBvZmluIHJlbGF0aW9uIHRvcG9wdWxhciBpbiB0aGV0aGUgY2FwaXRhbCBvZndhcyBvZmZpY2lhbGx5d2hpY2ggaGFzIGJlZW50aGUgSGlzdG9yeSBvZmFsdGVybmF0aXZlIHRvZGlmZmVyZW50IGZyb210byBzdXBwb3J0IHRoZXN1Z2dlc3RlZCB0aGF0aW4gdGhlIHByb2Nlc3MgIDxkaXYgY2xhc3M9InRoZSBmb3VuZGF0aW9uYmVjYXVzZSBvZiBoaXNjb25jZXJuZWQgd2l0aHRoZSB1bml2ZXJzaXR5b3Bwb3NlZCB0byB0aGV0aGUgY29udGV4dCBvZjxzcGFuIGNsYXNzPSJwdGV4dCIgbmFtZT0icSIJCTxkaXYgY2xhc3M9InRoZSBzY2llbnRpZmljcmVwcmVzZW50ZWQgYnltYXRoZW1hdGljaWFuc2VsZWN0ZWQgYnkgdGhldGhhdCBoYXZlIGJlZW4+PGRpdiBjbGFzcz0iY2RpdiBpZD0iaGVhZGVyaW4gcGFydGljdWxhcixjb252ZXJ0ZWQgaW50byk7Cjwvc2NyaXB0Pgo8cGhpbG9zb3BoaWNhbCBzcnBza29ocnZhdHNraXRp4bq/bmcgVmnhu4d00KDRg9GB0YHQutC40LnRgNGD0YHRgdC60LjQuWludmVzdGlnYWNpw7NucGFydGljaXBhY2nDs27QutC+0YLQvtGA0YvQtdC+0LHQu9Cw0YHRgtC40LrQvtGC0L7RgNGL0LnRh9C10LvQvtCy0LXQutGB0LjRgdGC0LXQvNGL0J3QvtCy0L7RgdGC0LjQutC+0YLQvtGA0YvRhdC+0LHQu9Cw0YHRgtGM0LLRgNC10LzQtdC90LjQutC+0YLQvtGA0LDRj9GB0LXQs9C+0LTQvdGP0YHQutCw0YfQsNGC0YzQvdC+0LLQvtGB0YLQuNCj0LrRgNCw0LjQvdGL0LLQvtC/0YDQvtGB0YvQutC+0YLQvtGA0L7QudGB0LTQtdC70LDRgtGM0L/QvtC80L7RidGM0Y7RgdGA0LXQtNGB0YLQstC+0LHRgNCw0LfQvtC80YHRgtC+0YDQvtC90YvRg9GH0LDRgdGC0LjQtdGC0LXRh9C10L3QuNC10JPQu9Cw0LLQvdCw0Y/QuNGB0YLQvtGA0LjQuNGB0LjRgdGC0LXQvNCw0YDQtdGI0LXQvdC40Y/QodC60LDRh9Cw0YLRjNC/0L7RjdGC0L7QvNGD0YHQu9C10LTRg9C10YLRgdC60LDQt9Cw0YLRjNGC0L7QstCw0YDQvtCy0LrQvtC90LXRh9C90L7RgNC10YjQtdC90LjQtdC60L7RgtC+0YDQvtC10L7RgNCz0LDQvdC+0LLQutC+0YLQvtGA0L7QvNCg0LXQutC70LDQvNCw2KfZhNmF2YbYqtiv2YnZhdmG2KrYr9mK2KfYqtin2YTZhdmI2LbZiNi52KfZhNio2LHYp9mF2KzYp9mE2YXZiNin2YLYudin2YTYsdiz2KfYptmE2YXYtNin2LHZg9in2KrYp9mE2KPYudi22KfYodin2YTYsdmK2KfYttip2KfZhNiq2LXZhdmK2YXYp9mE2KfYudi22KfYodin2YTZhtiq2KfYptis2KfZhNij2YTYudin2KjYp9mE2KrYs9is2YrZhNin2YTYo9mC2LPYp9mF2KfZhNi22LrYt9in2KrYp9mE2YHZitiv2YrZiNin2YTYqtix2K3Zitio2KfZhNis2K/Zitiv2KnYp9mE2KrYudmE2YrZhdin2YTYo9iu2KjYp9ix2KfZhNin2YHZhNin2YXYp9mE2KPZgdmE2KfZhdin2YTYqtin2LHZitiu2KfZhNiq2YLZhtmK2KnYp9mE2KfZhNi52KfYqNin2YTYrtmI2KfYt9ix2KfZhNmF2KzYqtmF2LnYp9mE2K/ZitmD2YjYsdin2YTYs9mK2KfYrdip2LnYqNiv2KfZhNmE2YfYp9mE2KrYsdio2YrYqdin2YTYsdmI2KfYqNi32KfZhNij2K/YqNmK2KnYp9mE2KfYrtio2KfYsdin2YTZhdiq2K3Yr9ip2KfZhNin2LrYp9mG2YpjdXJzb3I6cG9pbnRlcjs8L3RpdGxlPgo8bWV0YSAiIGhyZWY9Imh0dHA6Ly8iPjxzcGFuIGNsYXNzPSJtZW1iZXJzIG9mIHRoZSB3aW5kb3cubG9jYXRpb252ZXJ0aWNhbC1hbGlnbjovYT4gfCA8YSBocmVmPSI8IWRvY3R5cGUgaHRtbD5tZWRpYT0ic2NyZWVuIiA8b3B0aW9uIHZhbHVlPSJmYXZpY29uLmljbyIgLz4KCQk8ZGl2IGNsYXNzPSJjaGFyYWN0ZXJpc3RpY3MiIG1ldGhvZD0iZ2V0IiAvYm9keT4KPC9odG1sPgpzaG9ydGN1dCBpY29uIiBkb2N1bWVudC53cml0ZShwYWRkaW5nLWJvdHRvbTpyZXByZXNlbnRhdGl2ZXNzdWJtaXQiIHZhbHVlPSJhbGlnbj0iY2VudGVyIiB0aHJvdWdob3V0IHRoZSBzY2llbmNlIGZpY3Rpb24KICA8ZGl2IGNsYXNzPSJzdWJtaXQiIGNsYXNzPSJvbmUgb2YgdGhlIG1vc3QgdmFsaWduPSJ0b3AiPjx3YXMgZXN0YWJsaXNoZWQpOw0KPC9zY3JpcHQ+DQpyZXR1cm4gZmFsc2U7Ij4pLnN0eWxlLmRpc3BsYXliZWNhdXNlIG9mIHRoZSBkb2N1bWVudC5jb29raWU8Zm9ybSBhY3Rpb249Ii99Ym9keXttYXJnaW46MDtFbmN5Y2xvcGVkaWEgb2Z2ZXJzaW9uIG9mIHRoZSAuY3JlYXRlRWxlbWVudChuYW1lIiBjb250ZW50PSI8L2Rpdj4KPC9kaXY+CgphZG1pbmlzdHJhdGl2ZSA8L2JvZHk+CjwvaHRtbD5oaXN0b3J5IG9mIHRoZSAiPjxpbnB1dCB0eXBlPSJwb3J0aW9uIG9mIHRoZSBhcyBwYXJ0IG9mIHRoZSAmbmJzcDs8YSBocmVmPSJvdGhlciBjb3VudHJpZXMiPgo8ZGl2IGNsYXNzPSI8L3NwYW4+PC9zcGFuPjxJbiBvdGhlciB3b3JkcyxkaXNwbGF5OiBibG9jaztjb250cm9sIG9mIHRoZSBpbnRyb2R1Y3Rpb24gb2YvPgo8bWV0YSBuYW1lPSJhcyB3ZWxsIGFzIHRoZSBpbiByZWNlbnQgeWVhcnMNCgk8ZGl2IGNsYXNzPSI8L2Rpdj4KCTwvZGl2PgppbnNwaXJlZCBieSB0aGV0aGUgZW5kIG9mIHRoZSBjb21wYXRpYmxlIHdpdGhiZWNhbWUga25vd24gYXMgc3R5bGU9Im1hcmdpbjouanMiPjwvc2NyaXB0PjwgSW50ZXJuYXRpb25hbCB0aGVyZSBoYXZlIGJlZW5HZXJtYW4gbGFuZ3VhZ2Ugc3R5bGU9ImNvbG9yOiNDb21tdW5pc3QgUGFydHljb25zaXN0ZW50IHdpdGhib3JkZXI9IjAiIGNlbGwgbWFyZ2luaGVpZ2h0PSJ0aGUgbWFqb3JpdHkgb2YiIGFsaWduPSJjZW50ZXJyZWxhdGVkIHRvIHRoZSBtYW55IGRpZmZlcmVudCBPcnRob2RveCBDaHVyY2hzaW1pbGFyIHRvIHRoZSAvPgo8bGluayByZWw9InN3YXMgb25lIG9mIHRoZSB1bnRpbCBoaXMgZGVhdGh9KSgpOwo8L3NjcmlwdD5vdGhlciBsYW5ndWFnZXNjb21wYXJlZCB0byB0aGVwb3J0aW9ucyBvZiB0aGV0aGUgTmV0aGVybGFuZHN0aGUgbW9zdCBjb21tb25iYWNrZ3JvdW5kOnVybChhcmd1ZWQgdGhhdCB0aGVzY3JvbGxpbmc9Im5vIiBpbmNsdWRlZCBpbiB0aGVOb3J0aCBBbWVyaWNhbiB0aGUgbmFtZSBvZiB0aGVpbnRlcnByZXRhdGlvbnN0aGUgdHJhZGl0aW9uYWxkZXZlbG9wbWVudCBvZiBmcmVxdWVudGx5IHVzZWRhIGNvbGxlY3Rpb24gb2Z2ZXJ5IHNpbWlsYXIgdG9zdXJyb3VuZGluZyB0aGVleGFtcGxlIG9mIHRoaXNhbGlnbj0iY2VudGVyIj53b3VsZCBoYXZlIGJlZW5pbWFnZV9jYXB0aW9uID1hdHRhY2hlZCB0byB0aGVzdWdnZXN0aW5nIHRoYXRpbiB0aGUgZm9ybSBvZiBpbnZvbHZlZCBpbiB0aGVpcyBkZXJpdmVkIGZyb21uYW1lZCBhZnRlciB0aGVJbnRyb2R1Y3Rpb24gdG9yZXN0cmljdGlvbnMgb24gc3R5bGU9IndpZHRoOiBjYW4gYmUgdXNlZCB0byB0aGUgY3JlYXRpb24gb2Ztb3N0IGltcG9ydGFudCBpbmZvcm1hdGlvbiBhbmRyZXN1bHRlZCBpbiB0aGVjb2xsYXBzZSBvZiB0aGVUaGlzIG1lYW5zIHRoYXRlbGVtZW50cyBvZiB0aGV3YXMgcmVwbGFjZWQgYnlhbmFseXNpcyBvZiB0aGVpbnNwaXJhdGlvbiBmb3JyZWdhcmRlZCBhcyB0aGVtb3N0IHN1Y2Nlc3NmdWxrbm93biBhcyAmcXVvdDthIGNvbXByZWhlbnNpdmVIaXN0b3J5IG9mIHRoZSB3ZXJlIGNvbnNpZGVyZWRyZXR1cm5lZCB0byB0aGVhcmUgcmVmZXJyZWQgdG9VbnNvdXJjZWQgaW1hZ2U+Cgk8ZGl2IGNsYXNzPSJjb25zaXN0cyBvZiB0aGVzdG9wUHJvcGFnYXRpb25pbnRlcmVzdCBpbiB0aGVhdmFpbGFiaWxpdHkgb2ZhcHBlYXJzIHRvIGhhdmVlbGVjdHJvbWFnbmV0aWNlbmFibGVTZXJ2aWNlcyhmdW5jdGlvbiBvZiB0aGVJdCBpcyBpbXBvcnRhbnQ8L3NjcmlwdD48L2Rpdj5mdW5jdGlvbigpe3ZhciByZWxhdGl2ZSB0byB0aGVhcyBhIHJlc3VsdCBvZiB0aGUgcG9zaXRpb24gb2ZGb3IgZXhhbXBsZSwgaW4gbWV0aG9kPSJwb3N0IiB3YXMgZm9sbG93ZWQgYnkmYW1wO21kYXNoOyB0aGV0aGUgYXBwbGljYXRpb25qcyI+PC9zY3JpcHQ+DQp1bD48L2Rpdj48L2Rpdj5hZnRlciB0aGUgZGVhdGh3aXRoIHJlc3BlY3QgdG9zdHlsZT0icGFkZGluZzppcyBwYXJ0aWN1bGFybHlkaXNwbGF5OmlubGluZTsgdHlwZT0ic3VibWl0IiBpcyBkaXZpZGVkIGludG/kuK3mlocgKOeugOS9kylyZXNwb25zYWJpbGlkYWRhZG1pbmlzdHJhY2nDs25pbnRlcm5hY2lvbmFsZXNjb3JyZXNwb25kaWVudGXgpIngpKrgpK/gpYvgpJfgpKrgpYLgpLDgpY3gpLXgpLngpK7gpL7gpLDgpYfgpLLgpYvgpJfgpYvgpILgpJrgpYHgpKjgpL7gpLXgpLLgpYfgpJXgpL/gpKjgpLjgpLDgpJXgpL7gpLDgpKrgpYHgpLLgpL/gpLjgpJbgpYvgpJzgpYfgpILgpJrgpL7gpLngpL/gpI/gpK3gpYfgpJzgpYfgpILgpLbgpL7gpK7gpL/gpLLgpLngpK7gpL7gpLDgpYDgpJzgpL7gpJfgpLDgpKPgpKzgpKjgpL7gpKjgpYfgpJXgpYHgpK7gpL7gpLDgpKzgpY3gpLLgpYngpJfgpK7gpL7gpLLgpL/gpJXgpK7gpLngpL/gpLLgpL7gpKrgpYPgpLfgpY3gpKDgpKzgpKLgpLzgpKTgpYfgpK3gpL7gpJzgpKrgpL7gpJXgpY3gpLLgpL/gpJXgpJ/gpY3gpLDgpYfgpKjgpJbgpL/gpLLgpL7gpKvgpKbgpYzgpLDgpL7gpKjgpK7gpL7gpK7gpLLgpYfgpK7gpKTgpKbgpL7gpKjgpKzgpL7gpJzgpL7gpLDgpLXgpL/gpJXgpL7gpLjgpJXgpY3gpK/gpYvgpILgpJrgpL7gpLngpKTgpYfgpKrgpLngpYHgpIHgpJrgpKzgpKTgpL7gpK/gpL7gpLjgpILgpLXgpL7gpKbgpKbgpYfgpJbgpKjgpYfgpKrgpL/gpJvgpLLgpYfgpLXgpL/gpLbgpYfgpLfgpLDgpL7gpJzgpY3gpK/gpIngpKTgpY3gpKTgpLDgpK7gpYHgpILgpKzgpIjgpKbgpYvgpKjgpYvgpILgpIngpKrgpJXgpLDgpKPgpKrgpKLgpLzgpYfgpILgpLjgpY3gpKXgpL/gpKTgpKvgpL/gpLLgpY3gpK7gpK7gpYHgpJbgpY3gpK/gpIXgpJrgpY3gpJvgpL7gpJvgpYLgpJ/gpKTgpYDgpLjgpILgpJfgpYDgpKTgpJzgpL7gpI/gpJfgpL7gpLXgpL/gpK3gpL7gpJfgpJjgpKPgpY3gpJ/gpYfgpKbgpYLgpLjgpLDgpYfgpKbgpL/gpKjgpYvgpILgpLngpKTgpY3gpK/gpL7gpLjgpYfgpJXgpY3gpLjgpJfgpL7gpILgpKfgpYDgpLXgpL/gpLbgpY3gpLXgpLDgpL7gpKTgpYfgpILgpKbgpYjgpJ/gpY3gpLjgpKjgpJXgpY3gpLbgpL7gpLjgpL7gpK7gpKjgpYfgpIXgpKbgpL7gpLLgpKTgpKzgpL/gpJzgpLLgpYDgpKrgpYHgpLDgpYLgpLfgpLngpL/gpILgpKbgpYDgpK7gpL/gpKTgpY3gpLDgpJXgpLXgpL/gpKTgpL7gpLDgpYHgpKrgpK/gpYfgpLjgpY3gpKXgpL7gpKjgpJXgpLDgpYvgpKHgpLzgpK7gpYHgpJXgpY3gpKTgpK/gpYvgpJzgpKjgpL7gpJXgpYPgpKrgpK/gpL7gpKrgpYvgpLjgpY3gpJ/gpJjgpLDgpYfgpLLgpYLgpJXgpL7gpLDgpY3gpK/gpLXgpL/gpJrgpL7gpLDgpLjgpYLgpJrgpKjgpL7gpK7gpYLgpLLgpY3gpK/gpKbgpYfgpJbgpYfgpILgpLngpK7gpYfgpLbgpL7gpLjgpY3gpJXgpYLgpLLgpK7gpYjgpILgpKjgpYfgpKTgpYjgpK/gpL7gpLDgpJzgpL/gpLjgpJXgpYdyc3MreG1sIiB0aXRsZT0iLXR5cGUiIGNvbnRlbnQ9InRpdGxlIiBjb250ZW50PSJhdCB0aGUgc2FtZSB0aW1lLmpzIj48L3NjcmlwdD4KPCIgbWV0aG9kPSJwb3N0IiA8L3NwYW4+PC9hPjwvbGk+dmVydGljYWwtYWxpZ246dC9qcXVlcnkubWluLmpzIj4uY2xpY2soZnVuY3Rpb24oIHN0eWxlPSJwYWRkaW5nLX0pKCk7Cjwvc2NyaXB0Pgo8L3NwYW4+PGEgaHJlZj0iPGEgaHJlZj0iaHR0cDovLyk7IHJldHVybiBmYWxzZTt0ZXh0LWRlY29yYXRpb246IHNjcm9sbGluZz0ibm8iIGJvcmRlci1jb2xsYXBzZTphc3NvY2lhdGVkIHdpdGggQmFoYXNhIEluZG9uZXNpYUVuZ2xpc2ggbGFuZ3VhZ2U8dGV4dCB4bWw6c3BhY2U9LmdpZiIgYm9yZGVyPSIwIjwvYm9keT4KPC9odG1sPgpvdmVyZmxvdzpoaWRkZW47aW1nIHNyYz0iaHR0cDovL2FkZEV2ZW50TGlzdGVuZXJyZXNwb25zaWJsZSBmb3Igcy5qcyI+PC9zY3JpcHQ+Ci9mYXZpY29uLmljbyIgLz5vcGVyYXRpbmcgc3lzdGVtIiBzdHlsZT0id2lkdGg6MXRhcmdldD0iX2JsYW5rIj5TdGF0ZSBVbml2ZXJzaXR5dGV4dC1hbGlnbjpsZWZ0Owpkb2N1bWVudC53cml0ZSgsIGluY2x1ZGluZyB0aGUgYXJvdW5kIHRoZSB3b3JsZCk7DQo8L3NjcmlwdD4NCjwiIHN0eWxlPSJoZWlnaHQ6O292ZXJmbG93OmhpZGRlbm1vcmUgaW5mb3JtYXRpb25hbiBpbnRlcm5hdGlvbmFsYSBtZW1iZXIgb2YgdGhlIG9uZSBvZiB0aGUgZmlyc3RjYW4gYmUgZm91bmQgaW4gPC9kaXY+CgkJPC9kaXY+CmRpc3BsYXk6IG5vbmU7Ij4iIC8+CjxsaW5rIHJlbD0iCiAgKGZ1bmN0aW9uKCkge3RoZSAxNXRoIGNlbnR1cnkucHJldmVudERlZmF1bHQobGFyZ2UgbnVtYmVyIG9mIEJ5emFudGluZSBFbXBpcmUuanBnfHRodW1ifGxlZnR8dmFzdCBtYWpvcml0eSBvZm1ham9yaXR5IG9mIHRoZSAgYWxpZ249ImNlbnRlciI+VW5pdmVyc2l0eSBQcmVzc2RvbWluYXRlZCBieSB0aGVTZWNvbmQgV29ybGQgV2FyZGlzdHJpYnV0aW9uIG9mIHN0eWxlPSJwb3NpdGlvbjp0aGUgcmVzdCBvZiB0aGUgY2hhcmFjdGVyaXplZCBieSByZWw9Im5vZm9sbG93Ij5kZXJpdmVzIGZyb20gdGhlcmF0aGVyIHRoYW4gdGhlIGEgY29tYmluYXRpb24gb2ZzdHlsZT0id2lkdGg6MTAwRW5nbGlzaC1zcGVha2luZ2NvbXB1dGVyIHNjaWVuY2Vib3JkZXI9IjAiIGFsdD0idGhlIGV4aXN0ZW5jZSBvZkRlbW9jcmF0aWMgUGFydHkiIHN0eWxlPSJtYXJnaW4tRm9yIHRoaXMgcmVhc29uLC5qcyI+PC9zY3JpcHQ+CglzQnlUYWdOYW1lKHMpWzBdanMiPjwvc2NyaXB0Pg0KPC5qcyI+PC9zY3JpcHQ+DQpsaW5rIHJlbD0iaWNvbiIgJyBhbHQ9JycgY2xhc3M9J2Zvcm1hdGlvbiBvZiB0aGV2ZXJzaW9ucyBvZiB0aGUgPC9hPjwvZGl2PjwvZGl2Pi9wYWdlPgogIDxwYWdlPgo8ZGl2IGNsYXNzPSJjb250YmVjYW1lIHRoZSBmaXJzdGJhaGFzYSBJbmRvbmVzaWFlbmdsaXNoIChzaW1wbGUpzpXOu867zrfOvc65zrrOrNGF0YDQstCw0YLRgdC60LjQutC+0LzQv9Cw0L3QuNC40Y/QstC70Y/QtdGC0YHRj9CU0L7QsdCw0LLQuNGC0YzRh9C10LvQvtCy0LXQutCw0YDQsNC30LLQuNGC0LjRj9CY0L3RgtC10YDQvdC10YLQntGC0LLQtdGC0LjRgtGM0L3QsNC/0YDQuNC80LXRgNC40L3RgtC10YDQvdC10YLQutC+0YLQvtGA0L7Qs9C+0YHRgtGA0LDQvdC40YbRi9C60LDRh9C10YHRgtCy0LXRg9GB0LvQvtCy0LjRj9GF0L/RgNC+0LHQu9C10LzRi9C/0L7Qu9GD0YfQuNGC0YzRj9Cy0LvRj9GO0YLRgdGP0L3QsNC40LHQvtC70LXQtdC60L7QvNC/0LDQvdC40Y/QstC90LjQvNCw0L3QuNC10YHRgNC10LTRgdGC0LLQsNin2YTZhdmI2KfYttmK2LnYp9mE2LHYptmK2LPZitip2KfZhNin2YbYqtmC2KfZhNmF2LTYp9ix2YPYp9iq2YPYp9mE2LPZitin2LHYp9iq2KfZhNmF2YPYqtmI2KjYqdin2YTYs9i52YjYr9mK2KnYp9it2LXYp9im2YrYp9iq2KfZhNi52KfZhNmF2YrYqdin2YTYtdmI2KrZitin2KrYp9mE2KfZhtiq2LHZhtiq2KfZhNiq2LXYp9mF2YrZhdin2YTYpdiz2YTYp9mF2YrYp9mE2YXYtNin2LHZg9ip2KfZhNmF2LHYptmK2KfYqnJvYm90cyIgY29udGVudD0iPGRpdiBpZD0iZm9vdGVyIj50aGUgVW5pdGVkIFN0YXRlczxpbWcgc3JjPSJodHRwOi8vLmpwZ3xyaWdodHx0aHVtYnwuanMiPjwvc2NyaXB0Pg0KPGxvY2F0aW9uLnByb3RvY29sZnJhbWVib3JkZXI9IjAiIHMiIC8+CjxtZXRhIG5hbWU9IjwvYT48L2Rpdj48L2Rpdj48Zm9udC13ZWlnaHQ6Ym9sZDsmcXVvdDsgYW5kICZxdW90O2RlcGVuZGluZyBvbiB0aGUgbWFyZ2luOjA7cGFkZGluZzoiIHJlbD0ibm9mb2xsb3ciIFByZXNpZGVudCBvZiB0aGUgdHdlbnRpZXRoIGNlbnR1cnlldmlzaW9uPgogIDwvcGFnZUludGVybmV0IEV4cGxvcmVyYS5hc3luYyA9IHRydWU7DQppbmZvcm1hdGlvbiBhYm91dDxkaXYgaWQ9ImhlYWRlciI+IiBhY3Rpb249Imh0dHA6Ly88YSBocmVmPSJodHRwczovLzxkaXYgaWQ9ImNvbnRlbnQiPC9kaXY+DQo8L2Rpdj4NCjxkZXJpdmVkIGZyb20gdGhlIDxpbWcgc3JjPSdodHRwOi8vYWNjb3JkaW5nIHRvIHRoZSAKPC9ib2R5Pgo8L2h0bWw+CnN0eWxlPSJmb250LXNpemU6c2NyaXB0IGxhbmd1YWdlPSJBcmlhbCwgSGVsdmV0aWNhLDwvYT48c3BhbiBjbGFzcz0iPC9zY3JpcHQ+PHNjcmlwdCBwb2xpdGljYWwgcGFydGllc3RkPjwvdHI+PC90YWJsZT48aHJlZj0iaHR0cDovL3d3dy5pbnRlcnByZXRhdGlvbiBvZnJlbD0ic3R5bGVzaGVldCIgZG9jdW1lbnQud3JpdGUoJzxjaGFyc2V0PSJ1dGYtOCI+CmJlZ2lubmluZyBvZiB0aGUgcmV2ZWFsZWQgdGhhdCB0aGV0ZWxldmlzaW9uIHNlcmllcyIgcmVsPSJub2ZvbGxvdyI+IHRhcmdldD0iX2JsYW5rIj5jbGFpbWluZyB0aGF0IHRoZWh0dHAlM0ElMkYlMkZ3d3cubWFuaWZlc3RhdGlvbnMgb2ZQcmltZSBNaW5pc3RlciBvZmluZmx1ZW5jZWQgYnkgdGhlY2xhc3M9ImNsZWFyZml4Ij4vZGl2Pg0KPC9kaXY+DQoNCnRocmVlLWRpbWVuc2lvbmFsQ2h1cmNoIG9mIEVuZ2xhbmRvZiBOb3J0aCBDYXJvbGluYXNxdWFyZSBraWxvbWV0cmVzLmFkZEV2ZW50TGlzdGVuZXJkaXN0aW5jdCBmcm9tIHRoZWNvbW1vbmx5IGtub3duIGFzUGhvbmV0aWMgQWxwaGFiZXRkZWNsYXJlZCB0aGF0IHRoZWNvbnRyb2xsZWQgYnkgdGhlQmVuamFtaW4gRnJhbmtsaW5yb2xlLXBsYXlpbmcgZ2FtZXRoZSBVbml2ZXJzaXR5IG9maW4gV2VzdGVybiBFdXJvcGVwZXJzb25hbCBjb21wdXRlclByb2plY3QgR3V0ZW5iZXJncmVnYXJkbGVzcyBvZiB0aGVoYXMgYmVlbiBwcm9wb3NlZHRvZ2V0aGVyIHdpdGggdGhlPjwvbGk+PGxpIGNsYXNzPSJpbiBzb21lIGNvdW50cmllc21pbi5qcyI+PC9zY3JpcHQ+b2YgdGhlIHBvcHVsYXRpb25vZmZpY2lhbCBsYW5ndWFnZTxpbWcgc3JjPSJpbWFnZXMvaWRlbnRpZmllZCBieSB0aGVuYXR1cmFsIHJlc291cmNlc2NsYXNzaWZpY2F0aW9uIG9mY2FuIGJlIGNvbnNpZGVyZWRxdWFudHVtIG1lY2hhbmljc05ldmVydGhlbGVzcywgdGhlbWlsbGlvbiB5ZWFycyBhZ288L2JvZHk+DQo8L2h0bWw+Dc6VzrvOu863zr3Ouc66zqwKdGFrZSBhZHZhbnRhZ2Ugb2ZhbmQsIGFjY29yZGluZyB0b2F0dHJpYnV0ZWQgdG8gdGhlTWljcm9zb2Z0IFdpbmRvd3N0aGUgZmlyc3QgY2VudHVyeXVuZGVyIHRoZSBjb250cm9sZGl2IGNsYXNzPSJoZWFkZXJzaG9ydGx5IGFmdGVyIHRoZW5vdGFibGUgZXhjZXB0aW9udGVucyBvZiB0aG91c2FuZHNzZXZlcmFsIGRpZmZlcmVudGFyb3VuZCB0aGUgd29ybGQucmVhY2hpbmcgbWlsaXRhcnlpc29sYXRlZCBmcm9tIHRoZW9wcG9zaXRpb24gdG8gdGhldGhlIE9sZCBUZXN0YW1lbnRBZnJpY2FuIEFtZXJpY2Fuc2luc2VydGVkIGludG8gdGhlc2VwYXJhdGUgZnJvbSB0aGVtZXRyb3BvbGl0YW4gYXJlYW1ha2VzIGl0IHBvc3NpYmxlYWNrbm93bGVkZ2VkIHRoYXRhcmd1YWJseSB0aGUgbW9zdHR5cGU9InRleHQvY3NzIj4KdGhlIEludGVybmF0aW9uYWxBY2NvcmRpbmcgdG8gdGhlIHBlPSJ0ZXh0L2NzcyIgLz4KY29pbmNpZGUgd2l0aCB0aGV0d28tdGhpcmRzIG9mIHRoZUR1cmluZyB0aGlzIHRpbWUsZHVyaW5nIHRoZSBwZXJpb2Rhbm5vdW5jZWQgdGhhdCBoZXRoZSBpbnRlcm5hdGlvbmFsYW5kIG1vcmUgcmVjZW50bHliZWxpZXZlZCB0aGF0IHRoZWNvbnNjaW91c25lc3MgYW5kZm9ybWVybHkga25vd24gYXNzdXJyb3VuZGVkIGJ5IHRoZWZpcnN0IGFwcGVhcmVkIGlub2NjYXNpb25hbGx5IHVzZWRwb3NpdGlvbjphYnNvbHV0ZTsiIHRhcmdldD0iX2JsYW5rIiBwb3NpdGlvbjpyZWxhdGl2ZTt0ZXh0LWFsaWduOmNlbnRlcjtqYXgvbGlicy9qcXVlcnkvMS5iYWNrZ3JvdW5kLWNvbG9yOiN0eXBlPSJhcHBsaWNhdGlvbi9hbmd1YWdlIiBjb250ZW50PSI8bWV0YSBodHRwLWVxdWl2PSJQcml2YWN5IFBvbGljeTwvYT5lKCIlM0NzY3JpcHQgc3JjPSciIHRhcmdldD0iX2JsYW5rIj5PbiB0aGUgb3RoZXIgaGFuZCwuanBnfHRodW1ifHJpZ2h0fDI8L2Rpdj48ZGl2IGNsYXNzPSI8ZGl2IHN0eWxlPSJmbG9hdDpuaW5ldGVlbnRoIGNlbnR1cnk8L2JvZHk+DQo8L2h0bWw+DQo8aW1nIHNyYz0iaHR0cDovL3M7dGV4dC1hbGlnbjpjZW50ZXJmb250LXdlaWdodDogYm9sZDsgQWNjb3JkaW5nIHRvIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4iIGZyYW1lYm9yZGVyPSIwIiAiIHN0eWxlPSJwb3NpdGlvbjpsaW5rIGhyZWY9Imh0dHA6Ly9odG1sNC9sb29zZS5kdGQiPgpkdXJpbmcgdGhpcyBwZXJpb2Q8L3RkPjwvdHI+PC90YWJsZT5jbG9zZWx5IHJlbGF0ZWQgdG9mb3IgdGhlIGZpcnN0IHRpbWU7Zm9udC13ZWlnaHQ6Ym9sZDtpbnB1dCB0eXBlPSJ0ZXh0IiA8c3BhbiBzdHlsZT0iZm9udC1vbnJlYWR5c3RhdGVjaGFuZ2UJPGRpdiBjbGFzcz0iY2xlYXJkb2N1bWVudC5sb2NhdGlvbi4gRm9yIGV4YW1wbGUsIHRoZSBhIHdpZGUgdmFyaWV0eSBvZiA8IURPQ1RZUEUgaHRtbD4NCjwmbmJzcDsmbmJzcDsmbmJzcDsiPjxhIGhyZWY9Imh0dHA6Ly9zdHlsZT0iZmxvYXQ6bGVmdDtjb25jZXJuZWQgd2l0aCB0aGU9aHR0cCUzQSUyRiUyRnd3dy5pbiBwb3B1bGFyIGN1bHR1cmV0eXBlPSJ0ZXh0L2NzcyIgLz5pdCBpcyBwb3NzaWJsZSB0byBIYXJ2YXJkIFVuaXZlcnNpdHl0eWxlc2hlZXQiIGhyZWY9Ii90aGUgbWFpbiBjaGFyYWN0ZXJPeGZvcmQgVW5pdmVyc2l0eSAgbmFtZT0ia2V5d29yZHMiIGNzdHlsZT0idGV4dC1hbGlnbjp0aGUgVW5pdGVkIEtpbmdkb21mZWRlcmFsIGdvdmVybm1lbnQ8ZGl2IHN0eWxlPSJtYXJnaW4gZGVwZW5kaW5nIG9uIHRoZSBkZXNjcmlwdGlvbiBvZiB0aGU8ZGl2IGNsYXNzPSJoZWFkZXIubWluLmpzIj48L3NjcmlwdD5kZXN0cnVjdGlvbiBvZiB0aGVzbGlnaHRseSBkaWZmZXJlbnRpbiBhY2NvcmRhbmNlIHdpdGh0ZWxlY29tbXVuaWNhdGlvbnNpbmRpY2F0ZXMgdGhhdCB0aGVzaG9ydGx5IHRoZXJlYWZ0ZXJlc3BlY2lhbGx5IGluIHRoZSBFdXJvcGVhbiBjb3VudHJpZXNIb3dldmVyLCB0aGVyZSBhcmVzcmM9Imh0dHA6Ly9zdGF0aWNzdWdnZXN0ZWQgdGhhdCB0aGUiIHNyYz0iaHR0cDovL3d3dy5hIGxhcmdlIG51bWJlciBvZiBUZWxlY29tbXVuaWNhdGlvbnMiIHJlbD0ibm9mb2xsb3ciIHRIb2x5IFJvbWFuIEVtcGVyb3JhbG1vc3QgZXhjbHVzaXZlbHkiIGJvcmRlcj0iMCIgYWx0PSJTZWNyZXRhcnkgb2YgU3RhdGVjdWxtaW5hdGluZyBpbiB0aGVDSUEgV29ybGQgRmFjdGJvb2t0aGUgbW9zdCBpbXBvcnRhbnRhbm5pdmVyc2FyeSBvZiB0aGVzdHlsZT0iYmFja2dyb3VuZC08bGk+PGVtPjxhIGhyZWY9Ii90aGUgQXRsYW50aWMgT2NlYW5zdHJpY3RseSBzcGVha2luZyxzaG9ydGx5IGJlZm9yZSB0aGVkaWZmZXJlbnQgdHlwZXMgb2Z0aGUgT3R0b21hbiBFbXBpcmU+PGltZyBzcmM9Imh0dHA6Ly9BbiBJbnRyb2R1Y3Rpb24gdG9jb25zZXF1ZW5jZSBvZiB0aGVkZXBhcnR1cmUgZnJvbSB0aGVDb25mZWRlcmF0ZSBTdGF0ZXNpbmRpZ2Vub3VzIHBlb3BsZXNQcm9jZWVkaW5ncyBvZiB0aGVpbmZvcm1hdGlvbiBvbiB0aGV0aGVvcmllcyBoYXZlIGJlZW5pbnZvbHZlbWVudCBpbiB0aGVkaXZpZGVkIGludG8gdGhyZWVhZGphY2VudCBjb3VudHJpZXNpcyByZXNwb25zaWJsZSBmb3JkaXNzb2x1dGlvbiBvZiB0aGVjb2xsYWJvcmF0aW9uIHdpdGh3aWRlbHkgcmVnYXJkZWQgYXNoaXMgY29udGVtcG9yYXJpZXNmb3VuZGluZyBtZW1iZXIgb2ZEb21pbmljYW4gUmVwdWJsaWNnZW5lcmFsbHkgYWNjZXB0ZWR0aGUgcG9zc2liaWxpdHkgb2ZhcmUgYWxzbyBhdmFpbGFibGV1bmRlciBjb25zdHJ1Y3Rpb25yZXN0b3JhdGlvbiBvZiB0aGV0aGUgZ2VuZXJhbCBwdWJsaWNpcyBhbG1vc3QgZW50aXJlbHlwYXNzZXMgdGhyb3VnaCB0aGVoYXMgYmVlbiBzdWdnZXN0ZWRjb21wdXRlciBhbmQgdmlkZW9HZXJtYW5pYyBsYW5ndWFnZXMgYWNjb3JkaW5nIHRvIHRoZSBkaWZmZXJlbnQgZnJvbSB0aGVzaG9ydGx5IGFmdGVyd2FyZHNocmVmPSJodHRwczovL3d3dy5yZWNlbnQgZGV2ZWxvcG1lbnRCb2FyZCBvZiBEaXJlY3RvcnM8ZGl2IGNsYXNzPSJzZWFyY2h8IDxhIGhyZWY9Imh0dHA6Ly9JbiBwYXJ0aWN1bGFyLCB0aGVNdWx0aXBsZSBmb290bm90ZXNvciBvdGhlciBzdWJzdGFuY2V0aG91c2FuZHMgb2YgeWVhcnN0cmFuc2xhdGlvbiBvZiB0aGU8L2Rpdj4NCjwvZGl2Pg0KDQo8YSBocmVmPSJpbmRleC5waHB3YXMgZXN0YWJsaXNoZWQgaW5taW4uanMiPjwvc2NyaXB0PgpwYXJ0aWNpcGF0ZSBpbiB0aGVhIHN0cm9uZyBpbmZsdWVuY2VzdHlsZT0ibWFyZ2luLXRvcDpyZXByZXNlbnRlZCBieSB0aGVncmFkdWF0ZWQgZnJvbSB0aGVUcmFkaXRpb25hbGx5LCB0aGVFbGVtZW50KCJzY3JpcHQiKTtIb3dldmVyLCBzaW5jZSB0aGUvZGl2Pgo8L2Rpdj4KPGRpdiBsZWZ0OyBtYXJnaW4tbGVmdDpwcm90ZWN0aW9uIGFnYWluc3QwOyB2ZXJ0aWNhbC1hbGlnbjpVbmZvcnR1bmF0ZWx5LCB0aGV0eXBlPSJpbWFnZS94LWljb24vZGl2Pgo8ZGl2IGNsYXNzPSIgY2xhc3M9ImNsZWFyZml4Ij48ZGl2IGNsYXNzPSJmb290ZXIJCTwvZGl2PgoJCTwvZGl2Pgp0aGUgbW90aW9uIHBpY3R1cmXQkdGK0LvQs9Cw0YDRgdC60LjQsdGK0LvQs9Cw0YDRgdC60LjQpNC10LTQtdGA0LDRhtC40LjQvdC10YHQutC+0LvRjNC60L7RgdC+0L7QsdGJ0LXQvdC40LXRgdC+0L7QsdGJ0LXQvdC40Y/Qv9GA0L7Qs9GA0LDQvNC80YvQntGC0L/RgNCw0LLQuNGC0YzQsdC10YHQv9C70LDRgtC90L7QvNCw0YLQtdGA0LjQsNC70YvQv9C+0LfQstC+0LvRj9C10YLQv9C+0YHQu9C10LTQvdC40LXRgNCw0LfQu9C40YfQvdGL0YXQv9GA0L7QtNGD0LrRhtC40LjQv9GA0L7Qs9GA0LDQvNC80LDQv9C+0LvQvdC+0YHRgtGM0Y7QvdCw0YXQvtC00LjRgtGB0Y/QuNC30LHRgNCw0L3QvdC+0LXQvdCw0YHQtdC70LXQvdC40Y/QuNC30LzQtdC90LXQvdC40Y/QutCw0YLQtdCz0L7RgNC40LjQkNC70LXQutGB0LDQvdC00YDgpKbgpY3gpLXgpL7gpLDgpL7gpK7gpYjgpKjgpYHgpIXgpLLgpKrgpY3gpLDgpKbgpL7gpKjgpK3gpL7gpLDgpKTgpYDgpK/gpIXgpKjgpYHgpKbgpYfgpLbgpLngpL/gpKjgpY3gpKbgpYDgpIfgpILgpKHgpL/gpK/gpL7gpKbgpL/gpLLgpY3gpLLgpYDgpIXgpKfgpL/gpJXgpL7gpLDgpLXgpYDgpKHgpL/gpK/gpYvgpJrgpL/gpJ/gpY3gpKDgpYfgpLjgpK7gpL7gpJrgpL7gpLDgpJzgpILgpJXgpY3gpLbgpKjgpKbgpYHgpKjgpL/gpK/gpL7gpKrgpY3gpLDgpK/gpYvgpJfgpIXgpKjgpYHgpLjgpL7gpLDgpJHgpKjgpLLgpL7gpIfgpKjgpKrgpL7gpLDgpY3gpJ/gpYDgpLbgpLDgpY3gpKTgpYvgpILgpLLgpYvgpJXgpLjgpK3gpL7gpKvgpLzgpY3gpLLgpYjgpLbgpLbgpLDgpY3gpKTgpYfgpILgpKrgpY3gpLDgpKbgpYfgpLbgpKrgpY3gpLLgpYfgpK/gpLDgpJXgpYfgpILgpKbgpY3gpLDgpLjgpY3gpKXgpL/gpKTgpL/gpIngpKTgpY3gpKrgpL7gpKbgpIngpKjgpY3gpLngpYfgpILgpJrgpL/gpJ/gpY3gpKDgpL7gpK/gpL7gpKTgpY3gpLDgpL7gpJzgpY3gpK/gpL7gpKbgpL7gpKrgpYHgpLDgpL7gpKjgpYfgpJzgpYvgpKHgpLzgpYfgpILgpIXgpKjgpYHgpLXgpL7gpKbgpLbgpY3gpLDgpYfgpKPgpYDgpLbgpL/gpJXgpY3gpLfgpL7gpLjgpLDgpJXgpL7gpLDgpYDgpLjgpILgpJfgpY3gpLDgpLngpKrgpLDgpL/gpKPgpL7gpK7gpKzgpY3gpLDgpL7gpILgpKHgpKzgpJrgpY3gpJrgpYvgpILgpIngpKrgpLLgpKzgpY3gpKfgpK7gpILgpKTgpY3gpLDgpYDgpLjgpILgpKrgpLDgpY3gpJXgpIngpK7gpY3gpK7gpYDgpKbgpK7gpL7gpKfgpY3gpK/gpK7gpLjgpLngpL7gpK/gpKTgpL7gpLbgpKzgpY3gpKbgpYvgpILgpK7gpYDgpKHgpL/gpK/gpL7gpIbgpIjgpKrgpYDgpI/gpLLgpK7gpYvgpKzgpL7gpIfgpLLgpLjgpILgpJbgpY3gpK/gpL7gpIbgpKrgpLDgpYfgpLbgpKjgpIXgpKjgpYHgpKzgpILgpKfgpKzgpL7gpJzgpLzgpL7gpLDgpKjgpLXgpYDgpKjgpKTgpK7gpKrgpY3gpLDgpK7gpYHgpJbgpKrgpY3gpLDgpLbgpY3gpKjgpKrgpLDgpL/gpLXgpL7gpLDgpKjgpYHgpJXgpLjgpL7gpKjgpLjgpK7gpLDgpY3gpKXgpKjgpIbgpK/gpYvgpJzgpL/gpKTgpLjgpYvgpK7gpLXgpL7gpLDYp9mE2YXYtNin2LHZg9in2KrYp9mE2YXZhtiq2K/Zitin2KrYp9mE2YPZhdio2YrZiNiq2LHYp9mE2YXYtNin2YfYr9in2KrYudiv2K/Yp9mE2LLZiNin2LHYudiv2K/Yp9mE2LHYr9mI2K/Yp9mE2KXYs9mE2KfZhdmK2KnYp9mE2YHZiNiq2YjYtNmI2KjYp9mE2YXYs9in2KjZgtin2KrYp9mE2YXYudmE2YjZhdin2KrYp9mE2YXYs9mE2LPZhNin2KrYp9mE2KzYsdin2YHZitmD2LPYp9mE2KfYs9mE2KfZhdmK2KnYp9mE2KfYqti12KfZhNin2KprZXl3b3JkcyIgY29udGVudD0idzMub3JnLzE5OTkveGh0bWwiPjxhIHRhcmdldD0iX2JsYW5rIiB0ZXh0L2h0bWw7IGNoYXJzZXQ9IiB0YXJnZXQ9Il9ibGFuayI+PHRhYmxlIGNlbGxwYWRkaW5nPSJhdXRvY29tcGxldGU9Im9mZiIgdGV4dC1hbGlnbjogY2VudGVyO3RvIGxhc3QgdmVyc2lvbiBieSBiYWNrZ3JvdW5kLWNvbG9yOiAjIiBocmVmPSJodHRwOi8vd3d3Li9kaXY+PC9kaXY+PGRpdiBpZD08YSBocmVmPSIjIiBjbGFzcz0iIj48aW1nIHNyYz0iaHR0cDovL2NyaXB0IiBzcmM9Imh0dHA6Ly8KPHNjcmlwdCBsYW5ndWFnZT0iLy9FTiIgImh0dHA6Ly93d3cud2VuY29kZVVSSUNvbXBvbmVudCgiIGhyZWY9ImphdmFzY3JpcHQ6PGRpdiBjbGFzcz0iY29udGVudGRvY3VtZW50LndyaXRlKCc8c2Nwb3NpdGlvbjogYWJzb2x1dGU7c2NyaXB0IHNyYz0iaHR0cDovLyBzdHlsZT0ibWFyZ2luLXRvcDoubWluLmpzIj48L3NjcmlwdD4KPC9kaXY+CjxkaXYgY2xhc3M9InczLm9yZy8xOTk5L3hodG1sIiAKDQo8L2JvZHk+DQo8L2h0bWw+ZGlzdGluY3Rpb24gYmV0d2Vlbi8iIHRhcmdldD0iX2JsYW5rIj48bGluayBocmVmPSJodHRwOi8vZW5jb2Rpbmc9InV0Zi04Ij8+CncuYWRkRXZlbnRMaXN0ZW5lcj9hY3Rpb249Imh0dHA6Ly93d3cuaWNvbiIgaHJlZj0iaHR0cDovLyBzdHlsZT0iYmFja2dyb3VuZDp0eXBlPSJ0ZXh0L2NzcyIgLz4KbWV0YSBwcm9wZXJ0eT0ib2c6dDxpbnB1dCB0eXBlPSJ0ZXh0IiAgc3R5bGU9InRleHQtYWxpZ246dGhlIGRldmVsb3BtZW50IG9mIHR5bGVzaGVldCIgdHlwZT0idGVodG1sOyBjaGFyc2V0PXV0Zi04aXMgY29uc2lkZXJlZCB0byBiZXRhYmxlIHdpZHRoPSIxMDAlIiBJbiBhZGRpdGlvbiB0byB0aGUgY29udHJpYnV0ZWQgdG8gdGhlIGRpZmZlcmVuY2VzIGJldHdlZW5kZXZlbG9wbWVudCBvZiB0aGUgSXQgaXMgaW1wb3J0YW50IHRvIDwvc2NyaXB0PgoKPHNjcmlwdCAgc3R5bGU9ImZvbnQtc2l6ZToxPjwvc3Bhbj48c3BhbiBpZD1nYkxpYnJhcnkgb2YgQ29uZ3Jlc3M8aW1nIHNyYz0iaHR0cDovL2ltRW5nbGlzaCB0cmFuc2xhdGlvbkFjYWRlbXkgb2YgU2NpZW5jZXNkaXYgc3R5bGU9ImRpc3BsYXk6Y29uc3RydWN0aW9uIG9mIHRoZS5nZXRFbGVtZW50QnlJZChpZClpbiBjb25qdW5jdGlvbiB3aXRoRWxlbWVudCgnc2NyaXB0Jyk7IDxtZXRhIHByb3BlcnR5PSJvZzrQkdGK0LvQs9Cw0YDRgdC60LgKIHR5cGU9InRleHQiIG5hbWU9Ij5Qcml2YWN5IFBvbGljeTwvYT5hZG1pbmlzdGVyZWQgYnkgdGhlZW5hYmxlU2luZ2xlUmVxdWVzdHN0eWxlPSZxdW90O21hcmdpbjo8L2Rpdj48L2Rpdj48L2Rpdj48PjxpbWcgc3JjPSJodHRwOi8vaSBzdHlsZT0mcXVvdDtmbG9hdDpyZWZlcnJlZCB0byBhcyB0aGUgdG90YWwgcG9wdWxhdGlvbiBvZmluIFdhc2hpbmd0b24sIEQuQy4gc3R5bGU9ImJhY2tncm91bmQtYW1vbmcgb3RoZXIgdGhpbmdzLG9yZ2FuaXphdGlvbiBvZiB0aGVwYXJ0aWNpcGF0ZWQgaW4gdGhldGhlIGludHJvZHVjdGlvbiBvZmlkZW50aWZpZWQgd2l0aCB0aGVmaWN0aW9uYWwgY2hhcmFjdGVyIE94Zm9yZCBVbml2ZXJzaXR5IG1pc3VuZGVyc3RhbmRpbmcgb2ZUaGVyZSBhcmUsIGhvd2V2ZXIsc3R5bGVzaGVldCIgaHJlZj0iL0NvbHVtYmlhIFVuaXZlcnNpdHlleHBhbmRlZCB0byBpbmNsdWRldXN1YWxseSByZWZlcnJlZCB0b2luZGljYXRpbmcgdGhhdCB0aGVoYXZlIHN1Z2dlc3RlZCB0aGF0YWZmaWxpYXRlZCB3aXRoIHRoZWNvcnJlbGF0aW9uIGJldHdlZW5udW1iZXIgb2YgZGlmZmVyZW50PjwvdGQ+PC90cj48L3RhYmxlPlJlcHVibGljIG9mIElyZWxhbmQKPC9zY3JpcHQ+CjxzY3JpcHQgdW5kZXIgdGhlIGluZmx1ZW5jZWNvbnRyaWJ1dGlvbiB0byB0aGVPZmZpY2lhbCB3ZWJzaXRlIG9maGVhZHF1YXJ0ZXJzIG9mIHRoZWNlbnRlcmVkIGFyb3VuZCB0aGVpbXBsaWNhdGlvbnMgb2YgdGhlaGF2ZSBiZWVuIGRldmVsb3BlZEZlZGVyYWwgUmVwdWJsaWMgb2ZiZWNhbWUgaW5jcmVhc2luZ2x5Y29udGludWF0aW9uIG9mIHRoZU5vdGUsIGhvd2V2ZXIsIHRoYXRzaW1pbGFyIHRvIHRoYXQgb2YgY2FwYWJpbGl0aWVzIG9mIHRoZWFjY29yZGFuY2Ugd2l0aCB0aGVwYXJ0aWNpcGFudHMgaW4gdGhlZnVydGhlciBkZXZlbG9wbWVudHVuZGVyIHRoZSBkaXJlY3Rpb25pcyBvZnRlbiBjb25zaWRlcmVkaGlzIHlvdW5nZXIgYnJvdGhlcjwvdGQ+PC90cj48L3RhYmxlPjxhIGh0dHAtZXF1aXY9IlgtVUEtcGh5c2ljYWwgcHJvcGVydGllc29mIEJyaXRpc2ggQ29sdW1iaWFoYXMgYmVlbiBjcml0aWNpemVkKHdpdGggdGhlIGV4Y2VwdGlvbnF1ZXN0aW9ucyBhYm91dCB0aGVwYXNzaW5nIHRocm91Z2ggdGhlMCIgY2VsbHBhZGRpbmc9IjAiIHRob3VzYW5kcyBvZiBwZW9wbGVyZWRpcmVjdHMgaGVyZS4gRm9yaGF2ZSBjaGlsZHJlbiB1bmRlciUzRSUzQy9zY3JpcHQlM0UiKSk7PGEgaHJlZj0iaHR0cDovL3d3dy48bGk+PGEgaHJlZj0iaHR0cDovL3NpdGVfbmFtZSIgY29udGVudD0idGV4dC1kZWNvcmF0aW9uOm5vbmVzdHlsZT0iZGlzcGxheTogbm9uZTxtZXRhIGh0dHAtZXF1aXY9IlgtbmV3IERhdGUoKS5nZXRUaW1lKCkgdHlwZT0iaW1hZ2UveC1pY29uIjwvc3Bhbj48c3BhbiBjbGFzcz0ibGFuZ3VhZ2U9ImphdmFzY3JpcHR3aW5kb3cubG9jYXRpb24uaHJlZjxhIGhyZWY9ImphdmFzY3JpcHQ6LS0+DQo8c2NyaXB0IHR5cGU9InQ8YSBocmVmPSdodHRwOi8vd3d3LmhvcnRjdXQgaWNvbiIgaHJlZj0iPC9kaXY+DQo8ZGl2IGNsYXNzPSI8c2NyaXB0IHNyYz0iaHR0cDovLyIgcmVsPSJzdHlsZXNoZWV0IiB0PC9kaXY+CjxzY3JpcHQgdHlwZT0vYT4gPGEgaHJlZj0iaHR0cDovLyBhbGxvd1RyYW5zcGFyZW5jeT0iWC1VQS1Db21wYXRpYmxlIiBjb25yZWxhdGlvbnNoaXAgYmV0d2Vlbgo8L3NjcmlwdD4NCjxzY3JpcHQgPC9hPjwvbGk+PC91bD48L2Rpdj5hc3NvY2lhdGVkIHdpdGggdGhlIHByb2dyYW1taW5nIGxhbmd1YWdlPC9hPjxhIGhyZWY9Imh0dHA6Ly88L2E+PC9saT48bGkgY2xhc3M9ImZvcm0gYWN0aW9uPSJodHRwOi8vPGRpdiBzdHlsZT0iZGlzcGxheTp0eXBlPSJ0ZXh0IiBuYW1lPSJxIjx0YWJsZSB3aWR0aD0iMTAwJSIgYmFja2dyb3VuZC1wb3NpdGlvbjoiIGJvcmRlcj0iMCIgd2lkdGg9InJlbD0ic2hvcnRjdXQgaWNvbiIgaDY+PHVsPjxsaT48YSBocmVmPSIgIDxtZXRhIGh0dHAtZXF1aXY9ImNzcyIgbWVkaWE9InNjcmVlbiIgcmVzcG9uc2libGUgZm9yIHRoZSAiIHR5cGU9ImFwcGxpY2F0aW9uLyIgc3R5bGU9ImJhY2tncm91bmQtaHRtbDsgY2hhcnNldD11dGYtOCIgYWxsb3d0cmFuc3BhcmVuY3k9InN0eWxlc2hlZXQiIHR5cGU9InRlDQo8bWV0YSBodHRwLWVxdWl2PSI+PC9zcGFuPjxzcGFuIGNsYXNzPSIwIiBjZWxsc3BhY2luZz0iMCI+Owo8L3NjcmlwdD4KPHNjcmlwdCBzb21ldGltZXMgY2FsbGVkIHRoZWRvZXMgbm90IG5lY2Vzc2FyaWx5Rm9yIG1vcmUgaW5mb3JtYXRpb25hdCB0aGUgYmVnaW5uaW5nIG9mIDwhRE9DVFlQRSBodG1sPjxodG1scGFydGljdWxhcmx5IGluIHRoZSB0eXBlPSJoaWRkZW4iIG5hbWU9ImphdmFzY3JpcHQ6dm9pZCgwKTsiZWZmZWN0aXZlbmVzcyBvZiB0aGUgYXV0b2NvbXBsZXRlPSJvZmYiIGdlbmVyYWxseSBjb25zaWRlcmVkPjxpbnB1dCB0eXBlPSJ0ZXh0IiAiPjwvc2NyaXB0Pg0KPHNjcmlwdHRocm91Z2hvdXQgdGhlIHdvcmxkY29tbW9uIG1pc2NvbmNlcHRpb25hc3NvY2lhdGlvbiB3aXRoIHRoZTwvZGl2Pgo8L2Rpdj4KPGRpdiBjZHVyaW5nIGhpcyBsaWZldGltZSxjb3JyZXNwb25kaW5nIHRvIHRoZXR5cGU9ImltYWdlL3gtaWNvbiIgYW4gaW5jcmVhc2luZyBudW1iZXJkaXBsb21hdGljIHJlbGF0aW9uc2FyZSBvZnRlbiBjb25zaWRlcmVkbWV0YSBjaGFyc2V0PSJ1dGYtOCIgPGlucHV0IHR5cGU9InRleHQiIGV4YW1wbGVzIGluY2x1ZGUgdGhlIj48aW1nIHNyYz0iaHR0cDovL2lwYXJ0aWNpcGF0aW9uIGluIHRoZXRoZSBlc3RhYmxpc2htZW50IG9mCjwvZGl2Pgo8ZGl2IGNsYXNzPSImYW1wO25ic3A7JmFtcDtuYnNwO3RvIGRldGVybWluZSB3aGV0aGVycXVpdGUgZGlmZmVyZW50IGZyb21tYXJrZWQgdGhlIGJlZ2lubmluZ2Rpc3RhbmNlIGJldHdlZW4gdGhlY29udHJpYnV0aW9ucyB0byB0aGVjb25mbGljdCBiZXR3ZWVuIHRoZXdpZGVseSBjb25zaWRlcmVkIHRvd2FzIG9uZSBvZiB0aGUgZmlyc3R3aXRoIHZhcnlpbmcgZGVncmVlc2hhdmUgc3BlY3VsYXRlZCB0aGF0KGRvY3VtZW50LmdldEVsZW1lbnRwYXJ0aWNpcGF0aW5nIGluIHRoZW9yaWdpbmFsbHkgZGV2ZWxvcGVkZXRhIGNoYXJzZXQ9InV0Zi04Ij4gdHlwZT0idGV4dC9jc3MiIC8+CmludGVyY2hhbmdlYWJseSB3aXRobW9yZSBjbG9zZWx5IHJlbGF0ZWRzb2NpYWwgYW5kIHBvbGl0aWNhbHRoYXQgd291bGQgb3RoZXJ3aXNlcGVycGVuZGljdWxhciB0byB0aGVzdHlsZSB0eXBlPSJ0ZXh0L2Nzc3R5cGU9InN1Ym1pdCIgbmFtZT0iZmFtaWxpZXMgcmVzaWRpbmcgaW5kZXZlbG9waW5nIGNvdW50cmllc2NvbXB1dGVyIHByb2dyYW1taW5nZWNvbm9taWMgZGV2ZWxvcG1lbnRkZXRlcm1pbmF0aW9uIG9mIHRoZWZvciBtb3JlIGluZm9ybWF0aW9ub24gc2V2ZXJhbCBvY2Nhc2lvbnNwb3J0dWd1w6pzIChFdXJvcGV1KdCj0LrRgNCw0ZfQvdGB0YzQutCw0YPQutGA0LDRl9C90YHRjNC60LDQoNC+0YHRgdC40LnRgdC60L7QudC80LDRgtC10YDQuNCw0LvQvtCy0LjQvdGE0L7RgNC80LDRhtC40LjRg9C/0YDQsNCy0LvQtdC90LjRj9C90LXQvtCx0YXQvtC00LjQvNC+0LjQvdGE0L7RgNC80LDRhtC40Y/QmNC90YTQvtGA0LzQsNGG0LjRj9Cg0LXRgdC/0YPQsdC70LjQutC40LrQvtC70LjRh9C10YHRgtCy0L7QuNC90YTQvtGA0LzQsNGG0LjRjtGC0LXRgNGA0LjRgtC+0YDQuNC40LTQvtGB0YLQsNGC0L7Rh9C90L7Yp9mE2YXYqtmI2KfYrNiv2YjZhtin2YTYp9i02KrYsdin2YPYp9iq2KfZhNin2YLYqtix2KfYrdin2KpodG1sOyBjaGFyc2V0PVVURi04IiBzZXRUaW1lb3V0KGZ1bmN0aW9uKClkaXNwbGF5OmlubGluZS1ibG9jazs8aW5wdXQgdHlwZT0ic3VibWl0IiB0eXBlID0gJ3RleHQvamF2YXNjcmk8aW1nIHNyYz0iaHR0cDovL3d3dy4iICJodHRwOi8vd3d3LnczLm9yZy9zaG9ydGN1dCBpY29uIiBocmVmPSIiIGF1dG9jb21wbGV0ZT0ib2ZmIiA8L2E+PC9kaXY+PGRpdiBjbGFzcz08L2E+PC9saT4KPGxpIGNsYXNzPSJjc3MiIHR5cGU9InRleHQvY3NzIiA8Zm9ybSBhY3Rpb249Imh0dHA6Ly94dC9jc3MiIGhyZWY9Imh0dHA6Ly9saW5rIHJlbD0iYWx0ZXJuYXRlIiANCjxzY3JpcHQgdHlwZT0idGV4dC8gb25jbGljaz0iamF2YXNjcmlwdDoobmV3IERhdGUpLmdldFRpbWUoKX1oZWlnaHQ9IjEiIHdpZHRoPSIxIiBQZW9wbGUncyBSZXB1YmxpYyBvZiAgPGEgaHJlZj0iaHR0cDovL3d3dy50ZXh0LWRlY29yYXRpb246dW5kZXJ0aGUgYmVnaW5uaW5nIG9mIHRoZSA8L2Rpdj4KPC9kaXY+CjwvZGl2Pgplc3RhYmxpc2htZW50IG9mIHRoZSA8L2Rpdj48L2Rpdj48L2Rpdj48L2Qjdmlld3BvcnR7bWluLWhlaWdodDoKPHNjcmlwdCBzcmM9Imh0dHA6Ly9vcHRpb24+PG9wdGlvbiB2YWx1ZT1vZnRlbiByZWZlcnJlZCB0byBhcyAvb3B0aW9uPgo8b3B0aW9uIHZhbHU8IURPQ1RZUEUgaHRtbD4KPCEtLVtJbnRlcm5hdGlvbmFsIEFpcnBvcnQ+CjxhIGhyZWY9Imh0dHA6Ly93d3c8L2E+PGEgaHJlZj0iaHR0cDovL3fguKDguLLguKnguLLguYTguJfguKLhg6Xhg5Dhg6Dhg5fhg6Phg5rhg5jmraPpq5TkuK3mlocgKOe5gemrlCngpKjgpL/gpLDgpY3gpKbgpYfgpLbgpKHgpL7gpIngpKjgpLLgpYvgpKHgpJXgpY3gpLfgpYfgpKTgpY3gpLDgpJzgpL7gpKjgpJXgpL7gpLDgpYDgpLjgpILgpKzgpILgpKfgpL/gpKTgpLjgpY3gpKXgpL7gpKrgpKjgpL7gpLjgpY3gpLXgpYDgpJXgpL7gpLDgpLjgpILgpLjgpY3gpJXgpLDgpKPgpLjgpL7gpK7gpJfgpY3gpLDgpYDgpJrgpL/gpJ/gpY3gpKDgpYvgpILgpLXgpL/gpJzgpY3gpJ7gpL7gpKjgpIXgpK7gpYfgpLDgpL/gpJXgpL7gpLXgpL/gpK3gpL/gpKjgpY3gpKjgpJfgpL7gpKHgpL/gpK/gpL7gpIHgpJXgpY3gpK/gpYvgpILgpJXgpL/gpLjgpYHgpLDgpJXgpY3gpLfgpL7gpKrgpLngpYHgpIHgpJrgpKTgpYDgpKrgpY3gpLDgpKzgpILgpKfgpKjgpJ/gpL/gpKrgpY3gpKrgpKPgpYDgpJXgpY3gpLDgpL/gpJXgpYfgpJ/gpKrgpY3gpLDgpL7gpLDgpILgpK3gpKrgpY3gpLDgpL7gpKrgpY3gpKTgpK7gpL7gpLLgpL/gpJXgpYvgpILgpLDgpKvgpLzgpY3gpKTgpL7gpLDgpKjgpL/gpLDgpY3gpK7gpL7gpKPgpLLgpL/gpK7gpL/gpJ/gpYfgpKFkZXNjcmlwdGlvbiIgY29udGVudD0iZG9jdW1lbnQubG9jYXRpb24ucHJvdC5nZXRFbGVtZW50c0J5VGFnTmFtZSg8IURPQ1RZUEUgaHRtbD4KPGh0bWwgPG1ldGEgY2hhcnNldD0idXRmLTgiPjp1cmwiIGNvbnRlbnQ9Imh0dHA6Ly8uY3NzIiByZWw9InN0eWxlc2hlZXQic3R5bGUgdHlwZT0idGV4dC9jc3MiPnR5cGU9InRleHQvY3NzIiBocmVmPSJ3My5vcmcvMTk5OS94aHRtbCIgeG1sdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBtZXRob2Q9ImdldCIgYWN0aW9uPSJsaW5rIHJlbD0ic3R5bGVzaGVldCIgID0gZG9jdW1lbnQuZ2V0RWxlbWVudHR5cGU9ImltYWdlL3gtaWNvbiIgLz5jZWxscGFkZGluZz0iMCIgY2VsbHNwLmNzcyIgdHlwZT0idGV4dC9jc3MiIDwvYT48L2xpPjxsaT48YSBocmVmPSIiIHdpZHRoPSIxIiBoZWlnaHQ9IjEiIj48YSBocmVmPSJodHRwOi8vd3d3LnN0eWxlPSJkaXNwbGF5Om5vbmU7Ij5hbHRlcm5hdGUiIHR5cGU9ImFwcGxpLS8vVzNDLy9EVEQgWEhUTUwgMS4wIGVsbHNwYWNpbmc9IjAiIGNlbGxwYWQgdHlwZT0iaGlkZGVuIiB2YWx1ZT0iL2E+Jm5ic3A7PHNwYW4gcm9sZT0icwo8aW5wdXQgdHlwZT0iaGlkZGVuIiBsYW5ndWFnZT0iSmF2YVNjcmlwdCIgIGRvY3VtZW50LmdldEVsZW1lbnRzQmc9IjAiIGNlbGxzcGFjaW5nPSIwIiB5cGU9InRleHQvY3NzIiBtZWRpYT0idHlwZT0ndGV4dC9qYXZhc2NyaXB0J3dpdGggdGhlIGV4Y2VwdGlvbiBvZiB5cGU9InRleHQvY3NzIiByZWw9InN0IGhlaWdodD0iMSIgd2lkdGg9IjEiID0nK2VuY29kZVVSSUNvbXBvbmVudCg8bGluayByZWw9ImFsdGVybmF0ZSIgCmJvZHksIHRyLCBpbnB1dCwgdGV4dG1ldGEgbmFtZT0icm9ib3RzIiBjb25tZXRob2Q9InBvc3QiIGFjdGlvbj0iPgo8YSBocmVmPSJodHRwOi8vd3d3LmNzcyIgcmVsPSJzdHlsZXNoZWV0IiA8L2Rpdj48L2Rpdj48ZGl2IGNsYXNzbGFuZ3VhZ2U9ImphdmFzY3JpcHQiPmFyaWEtaGlkZGVuPSJ0cnVlIj7CtzxyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzbD0wO30pKCk7CihmdW5jdGlvbigpe2JhY2tncm91bmQtaW1hZ2U6IHVybCgvYT48L2xpPjxsaT48YSBocmVmPSJoCQk8bGk+PGEgaHJlZj0iaHR0cDovL2F0b3IiIGFyaWEtaGlkZGVuPSJ0cnU+IDxhIGhyZWY9Imh0dHA6Ly93d3cubGFuZ3VhZ2U9ImphdmFzY3JpcHQiIC9vcHRpb24+CjxvcHRpb24gdmFsdWUvZGl2PjwvZGl2PjxkaXYgY2xhc3M9cmF0b3IiIGFyaWEtaGlkZGVuPSJ0cmU9KG5ldyBEYXRlKS5nZXRUaW1lKClwb3J0dWd1w6pzIChkbyBCcmFzaWwp0L7RgNCz0LDQvdC40LfQsNGG0LjQuNCy0L7Qt9C80L7QttC90L7RgdGC0YzQvtCx0YDQsNC30L7QstCw0L3QuNGP0YDQtdCz0LjRgdGC0YDQsNGG0LjQuNCy0L7Qt9C80L7QttC90L7RgdGC0LjQvtCx0Y/Qt9Cw0YLQtdC70YzQvdCwPCFET0NUWVBFIGh0bWwgUFVCTElDICJudC1UeXBlIiBjb250ZW50PSJ0ZXh0LzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDo8aHRtbCB4bWxucz0iaHR0cDovL3d3dy0vL1czQy8vRFREIFhIVE1MIDEuMCBURFREL3hodG1sMS10cmFuc2l0aW9uYWwvL3d3dy53My5vcmcvVFIveGh0bWwxL3BlID0gJ3RleHQvamF2YXNjcmlwdCc7PG1ldGEgbmFtZT0iZGVzY3JpcHRpb25wYXJlbnROb2RlLmluc2VydEJlZm9yZTxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hanMiIHR5cGU9InRleHQvamF2YXNjcmkoZG9jdW1lbnQpLnJlYWR5KGZ1bmN0aXNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzaW1hZ2UiIGNvbnRlbnQ9Imh0dHA6Ly9VQS1Db21wYXRpYmxlIiBjb250ZW50PXRtbDsgY2hhcnNldD11dGYtOCIgLz4KbGluayByZWw9InNob3J0Y3V0IGljb248bGluayByZWw9InN0eWxlc2hlZXQiIDwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9PSBkb2N1bWVudC5jcmVhdGVFbGVtZW48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCaW5wdXQgdHlwZT0idGV4dCIgbmFtZT1hLnR5cGUgPSAndGV4dC9qYXZhc2NyaW5wdXQgdHlwZT0iaGlkZGVuIiBuYW1laHRtbDsgY2hhcnNldD11dGYtOCIgLz5kdGQiPgo8aHRtbCB4bWxucz0iaHR0cC0vL1czQy8vRFREIEhUTUwgNC4wMSBUZW50c0J5VGFnTmFtZSgnc2NyaXB0JylpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhcyIgc3R5bGU9ImRpc3BsYXk6bm9uZTsiPmRvY3VtZW50LmdldEVsZW1lbnRCeUlkKD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCcgdHlwZT0ndGV4dC9qYXZhc2NyaXB0J2lucHV0IHR5cGU9InRleHQiIG5hbWU9ImQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoc25pY2FsIiBocmVmPSJodHRwOi8vd3d3LkMvL0RURCBIVE1MIDQuMDEgVHJhbnNpdDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+Cgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPmlvbmFsLmR0ZCI+CjxodG1sIHhtbG5zPWh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZWRpbmc9IjAiIGNlbGxzcGFjaW5nPSIwImh0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+CiBzdHlsZT0iZGlzcGxheTpub25lOyI+PDxsaT48YSBocmVmPSJodHRwOi8vd3d3LiB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPtC00LXRj9GC0LXQu9GM0L3QvtGB0YLQuNGB0L7QvtGC0LLQtdGC0YHRgtCy0LjQuNC/0YDQvtC40LfQstC+0LTRgdGC0LLQsNCx0LXQt9C+0L/QsNGB0L3QvtGB0YLQuOCkquClgeCkuOCljeCkpOCkv+CkleCkvuCkleCkvuCkguCkl+CljeCksOClh+CkuOCkieCkqOCljeCkueCli+CkguCkqOClh+CkteCkv+Ckp+CkvuCkqOCkuOCkreCkvuCkq+Ckv+CkleCljeCkuOCkv+CkguCkl+CkuOClgeCksOCkleCljeCkt+Ckv+CkpOCkleClieCkquClgOCksOCkvuCkh+Ckn+CkteCkv+CknOCljeCknuCkvuCkquCkqOCkleCkvuCksOCljeCksOCkteCkvuCkiOCkuOCkleCljeCksOCkv+Ckr+CkpOCkvtyOEABkAAAACQAAAAgAAAB2jhAAZQAAAA4AAAAWAAAAAAAAAAQAAAAEAAAAQwUAAHaOEABlAAAAGwAAABIAAAAAAAAAAQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwD//x8A//8/AP//fwD///8A////Af///wP///8H////D////x////8/////f//////ffBAAcAAAACAAAAAFAAAA33wQAHAAAAB0AAAAHgAAAN98EABwAAAAfQAAAB8AAADffBAAcAAAAOoAAAARAAAA33wQAHAAAACPAQAADAAAAGFzc2VydGlvbiBmYWlsZWQ6IChhdmFpbGFibGVfYml0cyAmIDcpID09IDAA33wQAHAAAACJAQAAAwAAAN98EABwAAAAoQEAAAcAAADffBAAcAAAAKABAAAFAAAA33wQAHAAAACaAQAABQAAAAABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AQciv+wAL/AEBAQEBAgICAgMDAwMEBAQEBQUFBQYGBgYHBwcHCAgICAkJCQkKCgoKCwsLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQERERERISEhITExMTFBQUFBUVFRUWFhYWFxcXFxgYGBgZGRkZGhoaGhsbGxscHBwcHR0dHR4eHh4fHx8fICAgICEhISEiIiIiIyMjIyQkJCQlJSUlJiYmJicnJycoKCgoKSkpKSoqKiorKysrLCwsLC0tLS0uLi4uLy8vLzAwMDAxMTExMjIyMjMzMzM0NDQ0NTU1NTY2NjY3Nzc3ODg4ODk5OTk6Ojo6Ozs7Ozw8PDw9PT09Pj4+Pj8/Pz8AQc2z+wALBQQEAAAEAEHks/sAC+ABCAwQDAwUDBAYHAwMIAwkDCwsLCwsLCwsLCwgIBgoHAwMMDQ0NDA0NDQwNDQ0NDQwNDQ0NDQwNDQ0NDQYDBwMDAw4PDw8ODw8PDg8PDw8PDg8PDw8PDg8PDw8PBgMHAwAAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAQeW1+wALXgEBAQEBAQEBAQEBAQEBAQICAgICAgICAgIBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgIBAQEBAQEDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwEBAQEAQaS3+wALuQsCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgAICAgICAgICAgICAgICAgQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKDAwMDAwMDAwMDAwMDAwMDgAAQEBAQEBAQEBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBgYGBgYGBgYGBgYGBgYHZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheR6awL7+Yni/fBjC1+8h8qdgbcIt3IHsR+1/k2HRzC+7AAAAAAQAAAAEAAAAkAUAAAAAAAAIAAAABAAAAJEFAAAAAAAACAAAAAQAAACSBQAAkQUAABzeHgCTBQAAlAUAAJUFAACTBQAAlgUAAJcFAAAMAAAABAAAACkAAACXBQAADAAAAAQAAAAqAAAAKQAAAFjeHgCTBQAAmAUAAC0AAACTBQAAlgUAAE5vbmUAAAAABAAAAAQAAACZBQAAU29tZc51EABqAAAAvQEAAB0AAAAAAAAAsZAQAFoAAADxAAAADQAAAHVua25vd24gcmV0dXJuIGNvZGU6IAAAANDeHgAVAAAAsZAQAFoAAAAkAQAAFgAAALGQEABaAAAAWAEAAA0AAACxkBAAWgAAAIYBAAAWAAAAaW52YWxpZCBnemlwIGhlYWRlcmNvcnJ1cHQgZ3ppcCBzdHJlYW0gZG9lcyBub3QgaGF2ZSBhIG1hdGNoaW5nIGNoZWNrc3Vt53YQAFsAAACSAQAAGgAAAOd2EABbAAAAlQEAABQAAADndhAAWwAAAJYBAAAUAAAA53YQAFsAAACaAQAAFAAAAOd2EABbAAAAngEAABQAAADndhAAWwAAAKABAAAPAAAA53YQAFsAAAChAQAADwAAAOd2EABbAAAAogEAAA8AAADndhAAWwAAAKMBAAAPAAAA53YQAFsAAACkAQAADwAAAOd2EABbAAAApQEAAA8AAADndhAAWwAAAKYBAAAPAAAA53YQAFsAAACnAQAADwAAAOd2EABbAAAAqAEAAA8AAADndhAAWwAAALQBAAAPAAAAZGVmbGF0ZSBjb21wcmVzc2lvbiBlcnJvcmRlZmxhdGUgY29tcHJlc3Npb24gZXJyb3I6IHHgHgAbAAAAMFMQAFgAAABOAgAADAAAADBTEABYAAAATwIAADIAAAAwUxAAWAAAAFICAAAMAAAAAAAAAAQAAAAEAAAAmgUAAG1zZ0NvbXByZXNzRXJyb3I6hhAAcAAAAC4CAAARAAAAKCkAAAAAAAAEAAAABAAAAJsFAABidWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCkAAAAI4R4AIQAAAB5hEABlAAAADwAAABwAAAAeYRAAZQAAAC4AAAAJAAAAAgAAAAAAAAABAEHwwvsACwNU4R4AQYDV+wALA1ThHgBB/Nb7AAsDVOEeAEGg2PsAC7EC4GYQAF0AAAA3AwAAHAAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxxiYWQgbF9jb2RlAAAw7R4ACgAAAOBmEABdAAAArgMAAAUAQdza+wALnRkBAQEBAgICAgMDAwMEBAQEBQUFBQAAAQIDBAUGBwgKDA4QFBgcICgwOEBQYHCAoMDgAGJhZCBkX2NvZGWO7R4ACgAAAOBmEABdAAAAwgMAAAUAAAAAAAAAAQECAgMDBAQFBQYGBwcICAkJCgoLCwwMDQ0AAAEAAgADAAQABgAIAAwAEAAYACAAMABAAGAAgADAAAABgAEAAgADAAQABgAIAAwAEAAYACAAMABAAGAAAOBmEABdAAAA6QMAACEAAADgZhAAXQAAAOkDAAAWAAAA4GYQAF0AAADzAwAAIQAAAOBmEABdAAAA8wMAABYAAADgZhAAXQAAADQEAAAaAAAA4GYQAF0AAAAvBAAAGgAAAOBmEABdAAAAOwQAABQAAAAMAAgAjAAIAEwACADMAAgALAAIAKwACABsAAgA7AAIABwACACcAAgAXAAIANwACAA8AAgAvAAIAHwACAD8AAgAAgAIAIIACABCAAgAwgAIACIACACiAAgAYgAIAOIACAASAAgAkgAIAFIACADSAAgAMgAIALIACAByAAgA8gAIAAoACACKAAgASgAIAMoACAAqAAgAqgAIAGoACADqAAgAGgAIAJoACABaAAgA2gAIADoACAC6AAgAegAIAPoACAAGAAgAhgAIAEYACADGAAgAJgAIAKYACABmAAgA5gAIABYACACWAAgAVgAIANYACAA2AAgAtgAIAHYACAD2AAgADgAIAI4ACABOAAgAzgAIAC4ACACuAAgAbgAIAO4ACAAeAAgAngAIAF4ACADeAAgAPgAIAL4ACAB+AAgA/gAIAAEACACBAAgAQQAIAMEACAAhAAgAoQAIAGEACADhAAgAEQAIAJEACABRAAgA0QAIADEACACxAAgAcQAIAPEACAAJAAgAiQAIAEkACADJAAgAKQAIAKkACABpAAgA6QAIABkACACZAAgAWQAIANkACAA5AAgAuQAIAHkACAD5AAgABQAIAIUACABFAAgAxQAIACUACAClAAgAZQAIAOUACAAVAAgAlQAIAFUACADVAAgANQAIALUACAB1AAgA9QAIAA0ACACNAAgATQAIAM0ACAAtAAgArQAIAG0ACADtAAgAHQAIAJ0ACABdAAgA3QAIAD0ACAC9AAgAfQAIAP0ACAATAAkAEwEJAJMACQCTAQkAUwAJAFMBCQDTAAkA0wEJADMACQAzAQkAswAJALMBCQBzAAkAcwEJAPMACQDzAQkACwAJAAsBCQCLAAkAiwEJAEsACQBLAQkAywAJAMsBCQArAAkAKwEJAKsACQCrAQkAawAJAGsBCQDrAAkA6wEJABsACQAbAQkAmwAJAJsBCQBbAAkAWwEJANsACQDbAQkAOwAJADsBCQC7AAkAuwEJAHsACQB7AQkA+wAJAPsBCQAHAAkABwEJAIcACQCHAQkARwAJAEcBCQDHAAkAxwEJACcACQAnAQkApwAJAKcBCQBnAAkAZwEJAOcACQDnAQkAFwAJABcBCQCXAAkAlwEJAFcACQBXAQkA1wAJANcBCQA3AAkANwEJALcACQC3AQkAdwAJAHcBCQD3AAkA9wEJAA8ACQAPAQkAjwAJAI8BCQBPAAkATwEJAM8ACQDPAQkALwAJAC8BCQCvAAkArwEJAG8ACQBvAQkA7wAJAO8BCQAfAAkAHwEJAJ8ACQCfAQkAXwAJAF8BCQDfAAkA3wEJAD8ACQA/AQkAvwAJAL8BCQB/AAkAfwEJAP8ACQD/AQkAAAAHAEAABwAgAAcAYAAHABAABwBQAAcAMAAHAHAABwAIAAcASAAHACgABwBoAAcAGAAHAFgABwA4AAcAeAAHAAQABwBEAAcAJAAHAGQABwAUAAcAVAAHADQABwB0AAcAAwAIAIMACABDAAgAwwAIACMACACjAAgAYwAIAOMACADgZhAAXQAAAGsEAAAJAAAAQAAHACAABwBgAAcAEAAHAFAABwAwAAcAcAAHAAgABwBIAAgAyAAIACgACACoAAgAaAAIAOgACAAYAAgAmAAIAFgACQDYAAkAWAEJANgBCQA4AAkAuAAJADgBCQC4AQkAeAAJAPgACQB4AQkA+AEJAAQACQCEAAkABAEJAIQBCQBEAAoAxAAKAEQBCgDEAQoARAIKAMQCCgBEAwoAxAMKACQACgCkAAoAJAEKAKQBCgAkAgoApAIKACQDCgCkAwoAZAAKAOQACgBkAQoA5AEKAGQCCgDkAgoAZAMKAOQDCgAUAAoAlAAKABQBCgCUAQoAFAIKAJQCCgAUAwoAlAMKAFQACwDUAAsAVAELANQBCwBUAgsA1AILAFQDCwDUAwsAVAQLANQECwBUBQsA1AULAFQGCwDUBgsAVAcLANQHCwA0AAsAtAALADQBCwC0AQsANAILALQCCwA0AwsAtAMLADQECwC0BAsANAULALQFCwA0BgsAtAYLADQHCwC0BwsAdAALAPQACwB0AQsA9AELAHQCCwD0AgsAdAMLAPQDCwB0BAsA9AQLAHQFCwD0BQsAdAYLAPQGCwB0BwsA9AcLAAMADAADAQwAAwIMAAMDDAADBAwAAwUMAAMGDAADBwwAAwgMAAMJDAADCgwAAwsMAAMMDAADDQwAAw4MAAMPDACDAA0AgwENAIMCDQCDAw0AgwQNAIMFDQCDBg0AgwcNAIMIDQCDCQ0AgwoNAIMLDQCDDA0Agw0NAIMODQCDDw0AgxANAIMRDQCDEg0AgxMNAIMUDQCDFQ0AgxYNAIMXDQCDGA0AgxkNAIMaDQCDGw0AgxwNAIMdDQCDHg0Agx8NAEMADQBDAQ0AQwINAEMDDQBDBA0AQwUNAEMGDQBDBw0AQwgNAEMJDQBDCg0AQwsNAEMMDQBDDQ0AQw4NAEMPDQBDEA0AQxENAEMSDQBDEw0AQxQNAEMVDQBDFg0AQxcNAEMYDQBDGQ0AQxoNAEMbDQBDHA0AQx0NAEMeDQBDHw0AwwANAMMBDQDDAg0AwwMNAMMEDQDDBQ0AwwYNAMMHDQDDCA0AwwkNAMMKDQDDCw0AwwwNAMMNDQDDDg0Aww8NAMMQDQDDEQ0AwxINAMMTDQDDFA0AwxUNAMMWDQDDFw0AwxgNAMMZDQDDGg0AwxsNAMMcDQDDHQ0Awx4NAMMfDQAjAA0AIwENACMCDQAjAw0AIwQNACMFDQAjBg0AIwcNACMIDQAjCQ0AIwoNACMLDQAjDA0AIw0NACMODQAjDw0AIxANACMRDQAjEg0AIxMNACMUDQAjFQ0AIxYNACMXDQAjGA0AIxkNACMaDQAjGw0AIxwNACMdDQAjHg0AowAIAAAABQAQAAUACAAFABgABQAEAAUAFAAFAAwABQAcAAUAAgAFABIABQAKAAUAGgAFAAYABQAWAAUADgAFAB4ABQABAAUAEQAFAAkABQAZAAUABQAFABUABQANAAUAHQAFAAMABQATAAUACwAFABsABQAHAAUAFwAFAOBmEABdAAAArwQAABcAAAAgM182PwAAAJT3HgAFAAAA4GYQAF0AAADBBAAAEQAAAAABAgMEBAUFBgYGBgcHBwcICAgICAgICAkJCQkJCQkJCgoKCgoKCgoKCgoKCgoKCgsLCwsLCwsLCwsLCwsLCwsMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8AABAREhITExQUFBQVFRUVFhYWFhYWFhYXFxcXFxcXFxgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhobGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwdHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0d4GYQAF0AAADPBQAACQAAAHzuHgAgAQAAVO0eAB0AAAABAQAAHgEAAA8AAAAM9x4AHgAAALDtHgAeAAAAAAAAAB4AAAAPAEGM9PsAC7kLAgMHAAIAAAAAAAAA/PkeABMAAAAAAAAAEwAAAAcAAADgZhAAXQAAAJoGAAAxAAAA4GYQAF0AAACaBgAAOwAAAOBmEABdAAAAowYAADEAAADgZhAAXQAAAKMGAAA7AAAA4GYQAF0AAADEBgAANAAAAOBmEABdAAAAxwYAAB4AAADgZhAAXQAAAMsGAAAKAAAA4GYQAF0AAADQBgAAIgAAAOBmEABdAAAAjgcAADEAAADgZhAAXQAAAKEHAAAKAAAA4GYQAF0AAAClBwAAIQAAAOBmEABdAAAA0AcAAAsAAADgZhAAXQAAANAHAAAGAAAA4GYQAF0AAAD7BwAADwAAAOBmEABdAAAA/wcAAAkAAADgZhAAXQAAAAAIAAAJAAAA4GYQAF0AAAAUCAAAFQAAAOBmEABdAAAAGQgAABAAAADgZhAAXQAAANcHAAAdAAAA4GYQAF0AAADXBwAAGAAAAOBmEABdAAAA5gcAAAkAAADgZhAAXQAAAOkHAAAVAAAA4GYQAF0AAADwBwAAJgAAAOBmEABdAAAARggAABMAAABjb2RlIGxlbmd0aCBtdXN0IGJlIDEtMTWs+x4AGAAAAOBmEABdAAAATAgAAAkAAABpbmNvbnNpc3RlbnQgYml0IGNvdW50cwDc+x4AFwAAAOBmEABdAAAAPggAAAUAAADgZhAAXQAAAHkIAAAGAAAA4GYQAF0AAAB/CAAAEwAAAOBmEABdAAAAhwgAABIAAADgZhAAXQAAAIQIAAAOAAAAbm90IGVub3VnaCBjb2Rlc0z8HgAQAAAA4GYQAF0AAAChCAAABQAAAHRvbyBtYW55IGNvZGVzAAB0/B4ADgAAAOBmEABdAAAApQgAAAUAAAAQERIACAcJBgoFCwQMAw0CDgEPAOBmEABdAAAAsggAAA0AAADgZhAAXQAAAOkIAAAMAAAAbG9zdCBidWbQ/B4ACAAAAOBmEABdAAAARQkAAAkAAADgZhAAXQAAAJ0JAAAeAAAA4GYQAF0AAAChCQAALAAAAOBmEABdAAAAiAkAACIAAADgZhAAXQAAAIwJAAAwAAAA4GYQAF0AAADoCQAADgAAAOBmEABdAAAA7QkAAC0AAAAfiwgA4GYQAF0AAAABCgAAKQAAAOBmEABdAAAADgoAADEAAADgZhAAXQAAABkKAAAxAAAA4GYQAF0AAAAbCgAAMQAAAOBmEABdAAAAIAoAABYAAADgZhAAXQAAACQKAAA1AAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogY29uZGl0aW9uIG9mIGlubmVyIHN1cnJvdW5kaW5nIGlmALT9HgBLAAAA4GYQAF0AAACYCgAALgAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGNvbmRpdGlvbiBvZiBvdXRlciBzdXJyb3VuZGluZyBpZgAY/h4ASwAAAOBmEABdAAAAsQoAAC0AAADgZhAAXQAAAMkKAAApAAAA4GYQAF0AAADQCgAADgAAAOBmEABdAAAA0woAACkAAABiaV9idWYgbm90IGZsdXNoZWQAAKz+HgASAAAA4GYQAF0AAADeCgAACQAAAOBmEABdAAAApgsAABEAAADgZhAAXQAAAMILAAARAAAA4GYQAF0AAADDCwAAFQAAAOBmEABdAAAAyAsAAC0AAADgZhAAXQAAAMgLAAAdAAAA4GYQAF0AAADKCwAALgAAAOBmEABdAAAAygsAAB4AAADgZhAAXQAAAOULAAAlAAAA4GYQAF0AAAD0CwAADQAAAOBmEABdAAAA9gsAAA0AAADgZhAAXQAAAPkLAAAmAAAA4GYQAF0AAAD5CwAANwAAAOBmEABdAAAA+QsAAA4AAADgZhAAXQAAAAsMAAAJAAAARzYQAGQAAABQAAAAIABBzv/7AAvHFmAHUAAACBAAAAhzABQIHwASB3AAAAgwAAAIwAAACQoAEAdgAAAIIAAACKAAAAkAAAAIgAAACEAAAAjgAAAJBgAQB1gAAAgYAAAIkAAACTsAEwd4AAAIOAAACNAAAAkRABEHaAAACCgAAAiwAAAJCAAACIgAAAhIAAAI8AAACQQAEAdUAAAIFAAACOMAFQgrABMHdAAACDQAAAjIAAAJDQARB2QAAAgkAAAIqAAACQQAAAiEAAAIRAAACOgAAAkIABAHXAAACBwAAAiYAAAJUwAUB3wAAAg8AAAI2AAACRcAEgdsAAAILAAACLgAAAkMAAAIjAAACEwAAAj4AAAJAwAQB1IAAAgSAAAIowAVCCMAEwdyAAAIMgAACMQAAAkLABEHYgAACCIAAAikAAAJAgAACIIAAAhCAAAI5AAACQcAEAdaAAAIGgAACJQAAAlDABQHegAACDoAAAjUAAAJEwASB2oAAAgqAAAItAAACQoAAAiKAAAISgAACPQAAAkFABAHVgAACBYAAAgAAEAIMwATB3YAAAg2AAAIzAAACQ8AEQdmAAAIJgAACKwAAAkGAAAIhgAACEYAAAjsAAAJCQAQB14AAAgeAAAInAAACWMAFAd+AAAIPgAACNwAAAkbABIHbgAACC4AAAi8AAAJDgAACI4AAAhOAAAI/AAACQAAYAdRAAAIEQAACIMAFQgfABIHcQAACDEAAAjCAAAJCgAQB2EAAAghAAAIogAACQEAAAiBAAAIQQAACOIAAAkGABAHWQAACBkAAAiSAAAJOwATB3kAAAg5AAAI0gAACREAEQdpAAAIKQAACLIAAAkJAAAIiQAACEkAAAjyAAAJBAAQB1UAAAgVAAAIAgEQCCsAEwd1AAAINQAACMoAAAkNABEHZQAACCUAAAiqAAAJBQAACIUAAAhFAAAI6gAACQgAEAddAAAIHQAACJoAAAlTABQHfQAACD0AAAjaAAAJFwASB20AAAgtAAAIugAACQ0AAAiNAAAITQAACPoAAAkDABAHUwAACBMAAAjDABUIIwATB3MAAAgzAAAIxgAACQsAEQdjAAAIIwAACKYAAAkDAAAIgwAACEMAAAjmAAAJBwAQB1sAAAgbAAAIlgAACUMAFAd7AAAIOwAACNYAAAkTABIHawAACCsAAAi2AAAJCwAACIsAAAhLAAAI9gAACQUAEAdXAAAIFwAACAAAQAgzABMHdwAACDcAAAjOAAAJDwARB2cAAAgnAAAIrgAACQcAAAiHAAAIRwAACO4AAAkJABAHXwAACB8AAAieAAAJYwAUB38AAAg/AAAI3gAACRsAEgdvAAAILwAACL4AAAkPAAAIjwAACE8AAAj+AAAJAABgB1AAAAgQAAAIcwAUCB8AEgdwAAAIMAAACMEAAAkKABAHYAAACCAAAAihAAAJAAAACIAAAAhAAAAI4QAACQYAEAdYAAAIGAAACJEAAAk7ABMHeAAACDgAAAjRAAAJEQARB2gAAAgoAAAIsQAACQgAAAiIAAAISAAACPEAAAkEABAHVAAACBQAAAjjABUIKwATB3QAAAg0AAAIyQAACQ0AEQdkAAAIJAAACKkAAAkEAAAIhAAACEQAAAjpAAAJCAAQB1wAAAgcAAAImQAACVMAFAd8AAAIPAAACNkAAAkXABIHbAAACCwAAAi5AAAJDAAACIwAAAhMAAAI+QAACQMAEAdSAAAIEgAACKMAFQgjABMHcgAACDIAAAjFAAAJCwARB2IAAAgiAAAIpQAACQIAAAiCAAAIQgAACOUAAAkHABAHWgAACBoAAAiVAAAJQwAUB3oAAAg6AAAI1QAACRMAEgdqAAAIKgAACLUAAAkKAAAIigAACEoAAAj1AAAJBQAQB1YAAAgWAAAIAABACDMAEwd2AAAINgAACM0AAAkPABEHZgAACCYAAAitAAAJBgAACIYAAAhGAAAI7QAACQkAEAdeAAAIHgAACJ0AAAljABQHfgAACD4AAAjdAAAJGwASB24AAAguAAAIvQAACQ4AAAiOAAAITgAACP0AAAkAAGAHUQAACBEAAAiDABUIHwASB3EAAAgxAAAIwwAACQoAEAdhAAAIIQAACKMAAAkBAAAIgQAACEEAAAjjAAAJBgAQB1kAAAgZAAAIkwAACTsAEwd5AAAIOQAACNMAAAkRABEHaQAACCkAAAizAAAJCQAACIkAAAhJAAAI8wAACQQAEAdVAAAIFQAACAIBEAgrABMHdQAACDUAAAjLAAAJDQARB2UAAAglAAAIqwAACQUAAAiFAAAIRQAACOsAAAkIABAHXQAACB0AAAibAAAJUwAUB30AAAg9AAAI2wAACRcAEgdtAAAILQAACLsAAAkNAAAIjQAACE0AAAj7AAAJAwAQB1MAAAgTAAAIwwAVCCMAEwdzAAAIMwAACMcAAAkLABEHYwAACCMAAAinAAAJAwAACIMAAAhDAAAI5wAACQcAEAdbAAAIGwAACJcAAAlDABQHewAACDsAAAjXAAAJEwASB2sAAAgrAAAItwAACQsAAAiLAAAISwAACPcAAAkFABAHVwAACBcAAAgAAEAIMwATB3cAAAg3AAAIzwAACQ8AEQdnAAAIJwAACK8AAAkHAAAIhwAACEcAAAjvAAAJCQAQB18AAAgfAAAInwAACWMAFAd/AAAIPwAACN8AAAkbABIHbwAACC8AAAi/AAAJDwAACI8AAAhPAAAI/wAACQEAEAUBARcFEQATBQEQGwUFABEFAQQZBUEAFQUBQB0FAwAQBQECGAUhABQFASAcBQkAEgUBCBoFgQAWBQAAQAUCABAFgQEXBRkAEwUBGBsFBwARBQEGGQVhABUFAWAdBQQAEAUBAxgFMQAUBQEwHAUNABIFAQwaBcEAFgUAAEAFgmYQAF0AAADnAQAACQAAAIJmEABdAAAA6wEAAAkAAACCZhAAXQAAAEwCAAAkAAAAgmYQAF0AAABcAgAAKAAAAIJmEABdAAAAuAIAACQAAACCZhAAXQAAAMkCAAAlAAAASU5GTEFURV9BTExPV19JTlZBTElEX0RJU1RBTkNFX1RPT0ZBUl9BUlJSAACsCB8AKgAAAIJmEABdAAAAIgMAACEAAACCZhAAXQAAACoEAABEAAAAbmFtZSBvdXQgb2YgYm91bmRzAACCZhAAXQAAAFMEAAAqAAAAY29tbSBvdXQgb2YgYm91bmRzAACCZhAAXQAAAIwEAAAqAAAAgmYQAF0AAADuBQAAJQAAABAREgAIBwkGCgULBAwDDQIOAQ8AgmYQAF0AAAAvBgAAMwAAAIJmEABdAAAArwYAACcAAACCZhAAXQAAAGoGAAAvAAAAgmYQAF0AAABzBgAAOwAAAIJmEABdAAAAgQYAAC4AAACCZhAAXQAAAIEGAAA7AAAAgmYQAF0AAACPBgAALgAAAIJmEABdAAAAjwYAADsAAACCZhAAXQAAAF8GAAAlAAAAbm90IHlldCBpbXBsZW1lbnRlZACCZhAAXQAAABMGAAAjAAAAgmYQAF0AAACJBwAAEQAAAIJmEABdAAAAhwcAABEAAACCZhAAXQAAAJAHAAAUAAAAgmYQAF0AAACVBwAAGAAAAIJmEABdAAAAGAgAABgAAACCZhAAXQAAAKQHAAAYAAAAgmYQAF0AAAAMCAAAIAAAAIJmEABdAAAAzwcAACEAAABpbnZhbGlkIHdpbmRvd0JpdHMKAKAKHwATAAAAgmYQAF0AAACxCAAACQAAAIJmEABdAAAAMwkAACcAAABhc3NlcnRpb24gZmFpbGVkOiBtc2cuZW5kc193aXRoKCdcMCcpAAAAgmYQAF0AAAA9CQAACQAAAIAAQaGW/AALzF0BAAAAAAAAAAEAAAAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd4AAAAAN2rCAW7UhANZvkYC3KgJB+vCywayfI0EhRZPBbhREw6PO9EP1oWXDeHvVQxk+RoJU5PYCAotngo9R1wLcKMmHEfJ5B0ed6IfKR1gHqwLLxubYe0awt+rGPW1aRnI8jUS/5j3E6YmsRGRTHMQFFo8FSMw/hR6jrgWTeR6F+BGTTjXLI85jpLJO7n4Czo87kQ/C4SGPlI6wDxlUAI9WBdeNm99nDc2w9o1AakYNIS/VzGz1ZUw6mvTMt0BETOQ5Wskp4+pJf4x7yfJWy0mTE1iI3snoCIimeYgFfMkISi0eCof3rorRmD8KXEKPij0HHEtw3azLJrI9S6tojcvwI2acPfnWHGuWR5zmTPcchwlk3crT1F2cvEXdEWb1XV43Il+T7ZLfxYIDX0hYs98pHSAeZMeQnjKoAR6/crGe7AuvGyHRH5t3vo4b+mQ+m5shrVrW+x3agJSMWg1OPNpCH+vYj8VbWNmqythUcHpYNTXpmXjvWRkugMiZo1p4Gcgy9dIF6EVSU4fU0t5dZFK/GPeT8sJHE6St1pMpd2YTZiaxEav8AZH9k5ARcEkgkREMs1Bc1gPQCrmSUIdjItDUGjxVGcCM1U+vHVXCda3VozA+FO7qjpS4hR8UNV+vlHoOeJa31MgW4btZlmxh6RYNJHrXQP7KVxaRW9ebS+tX4AbNeG3cffg7s+x4tmlc+Ncszzma9n+5zJnuOUFDXrkOEom7w8g5O5WnqLsYfRg7eTiL+jTiO3pijar671caerwuBP9x9LR/J5sl/6pBlX/LBAa+ht62PtCxJ75da5c+EjpAPN/g8LyJj2E8BFXRvGUQQn0oyvL9fqVjffN/0/2YF142Vc3utgOifzaOeM+27z1cd6Ln7Pf0iH13eVLN9zYDGvX72ap1rbY79SBsi3VBKRi0DPOoNFqcObTXRok0hD+XsUnlJzEfiraxklAGMfMVlfC+zyVw6KC08GV6BHAqK9Ny5/Fj8rGe8nI8RELyXQHRMxDbYbNGtPAzy25As5Alq+Rd/xtkC5CK5IZKOmTnD6mlqtUZJfy6iKVxYDglPjHvJ/PrX6elhM4nKF5+p0kb7WYEwV3mUq7MZt90fOaMDWJjQdfS4xe4Q2OaYvPj+ydgIrb90KLgkkEibUjxoiIZJqDvw5YguawHoDR2tyBVMyThGOmUYU6GBeHDXLVhqDQ4qmXuiCozgRmqvlupKt8eOuuSxIprxKsb60lxq2sGIHxpy/rM6Z2VXWkQT+3pcQp+KDzQzqhqv18o52XvqLQc8S15xkGtL6nQLaJzYK3DNvNsjuxD7NiD0mxVWWLsGgi17tfSBW6BvZTuDGckbm0it68g+AcvdpeWr/tNJi+AAAAAEExGxmCYjYyw1MtKwTFbGRF9Hd9hqdaVseWQU8IitnISbvC0Yro7/rL2fTjDE+1rE1+rrWOLYOezxyYh1ESwkoQI9lT03D0eJJB72FV164uFOa1N9e1mByWhIMFWZgbghipAJvb+i2wmss2qV1dd+YcbGz/3z9B1J4OWs2iJISV4xWfjCBGsqdhd6m+puHo8efQ8+gkg97DZbLF2qquXV3rn0ZEKMxrb2n9cHauazE571oqICwJBwttOBwS8zZG37IHXcZxVHDtMGVr9PfzKru2wjGidZEciTSgB5D7vJ8Xuo2EDnneqSU477I8/3nzc75I6Gp9G8VBPCreWAVPefBEfmLphy1PwsYcVNsBihWUQLsOjYPoI6bC2Ti/DcWgOEz0uyGPp5YKzpaNEwkAzFxIMddFi2L6bspT4XdUXbu6FWygo9Y/jYiXDpaRUJjX3hGpzMfS+uHsk8v69VzXYnId5nlr3rVUQJ+ET1lYEg4WGSMVD9pwOCSbQSM9p2v9ZeZa5nwlCctXZDjQTqOukQHin4oYIcynM2D9vCqv4SSt7tA/tC2DEp9ssgmGqyRIyeoVU9ApRn77aHdl4vZ5Py+3SCQ2dBsJHTUqEgTyvFNLs41IUnDeZXkx735g/vPm57/C/f58kdDVPaDLzPo2ioO7B5GaeFS8sTllp6hLmIM7CqmYIsn6tQmIy64QT13vXw5s9EbNP9ltjA7CdEMSWvMCI0HqwXBswYBBd9hH1zaXBuYtjsW1AKWEhBu8GopBcVu7WmiY6HdD2dlsWh5PLRVffjYMnC0bJ90cAD4SAJi5UzGDoJBirovRU7WSFsX03Vf078SUp8Lv1ZbZ9um8B66ojRy3a94xnCrvKoXteWvKrEhw028bXfguKkbh4TbeZqAHxX9jVOhUImXzTeXzsgKkwqkbZ5GEMCagnym4rsXk+Z/e/TrM89Z7/ejPvGupgP1aspk+CZ+yfziEq7AkHCzxFQc1MkYqHnN3MQe04XBI9dBrUTaDRnp3sl1jTtf6yw/m4dLMtcz5jYTX4EoSlq8LI422yHCgnYlBu4RGXSMDB2w4GsQ/FTGFDg4oQphPZwOpVH7A+nlVgctiTB/FOIFe9COYnacOs9yWFaobAFTlWjFP/JliYtfYU3nOF0/hSVZ++lCVLdd71BzMYhOKjS1Su5Y0kei7H9DZoAbs835ercJlR26RSGwvoFN16DYSOqkHCSNqVCQIK2U/EeR5p5alSLyPZhuRpCcqir3gvMvyoY3Q62Le/cAj7+bZveG8FPzQpw0/g4omfrKRP7kk0HD4FctpO0bmQnp3/Vu1a2Xc9Fp+xTcJU+52OEj3sa4JuPCfEqEzzD+Kcv0kkwAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAMYoQAGEAAAB0AAAAJwAAADGKEABhAAAAawAAADMAAAAAAAAARjtnZYx2zsrKTamvWevtTh/QiivVnSOEk6ZE4bLW25307bz4PqAVV3ibcjLrPTbTrQZRtmdL+BkhcJ98JavG4GOQoYWp3Qgq7+ZvT3xAK646e0zL8DblZLYNggGXfR190UZ6GBsL07ddMLTSzpbwM4itl1ZC4D75BNtZnAtQ/BpNa5t/hyYy0MEdVbVSuxFUFIB2Md7N356Y9rj7uYYnh/+9QOI18OlNc8uOKOBtysmmVq2sbBsEAyogY2Yu+zr6aMBdn6KN9DDktpNVdxDXtDErsNH7Zhl+vV1+G5wt4WfaFoYCEFsvrVZgSMjFxgwpg/1rTEmwwuMPi6WGFqD4NVCbn1Ca1jb/3O1Rmk9LFXsJcHIewz3bsYUGvNSkdiOo4k1EzSgA7WJuO4oH/Z3O5rumqYNx6wAsN9BnSTMLPtV1MFmwv33wH/lGl3pq4NObLNu0/uaWHVGgrXo0gd3lSMfmgi0NqyuCS5BM59g2CAaeDW9jVEDGzBJ7oakd8AQvW8tjSpGGyuXXva2ARBvpYQIgjgTIbSerjlZAzq8m37LpHbjXI1AReGVrdh32zTL8sPZVmXq7/DY8gJtTOFvCz35gpaq0LQwF8hZrYGGwL4Eni0jk7cbhS6v9hi6KjRlSzLZ+Nwb715hAwLD902b0HJVdk3lfEDrWGStdsyxA8Wtqe5YOoDY/oeYNWMR1qxwlM5B7QPnd0u+/5rWKnpYq9titTZMS4OQ8VNuDWcd9x7iBRqDdSwsJcg0wbhcJ6zeLT9BQ7oWd+UHDpp4kUADaxRY7vaDcdhQPmk1zars97Bb9BotzN0si3HFwRbni1gFYpO1mPW6gz5Iom6j3JxANcWErahSrZsO77V2k3n774D84wIda8o0u9bS2SZCVxtbs0/2xiRmwGCZfi39DzC07oooWXMdAW/VoBmCSDQK7y5FEgKz0js0FW8j2Yj5bUCbfHWtButcm6BWRHY9wsG0QDPZWd2k8G97GeiC5o+mG/UKvvZonZfAziCPLVO064AlefNtuO7aWx5TwraDxYwvkECUwg3XvfSraqUZNv4g20sPODbWmBEAcCUJ7e2zR3T+Nl+ZY6F2r8UcbkJYiH0vPvllwqNuTPQF01QZmEUagIvAAm0WVytbsOozti1+tnRQj66ZzRiHr2uln0L2M9Hb5bbJNngh4ADenPjtQwjGw9UR3i5IhvcY7jvv9XOtoWxgKLmB/b+Qt1sCiFrGlg2Yu2cVdSbwPEOATSSuHdtqNw5ectqTyVvsNXRDAajgUGzOkUiBUwZht/W7eVpoLTfDe6gvLuY/BhhAgh713RabN6Dng9o9cKrsm82yAQZb/JgV3uR1iEnNQy701a6zYAAAAAFiA4tfxBrR0qYZWo+INaOm6jYo+EwvcnUuLPkqFHaEJ3Z1D3nQbFX0sm/eqZxDJ4D+QKzeWFn2UzpafQwo7QhNSu6DE+z32Z6O9FLDoNir6sLbILRkwno5BsHxZjybjGtemAc1+IFduJqC1uW0ri/M1q2kknC0/h8St3VAUdoQmTPZm8eVwMFK98NKF9nvsz677DhgHfVi7X/26bJFrJS/J68f4YG2RWzjtc4xzZk3GK+avEYJg+bLa4BtlHk3GNUbNJOLvS3JBt8uQlvxArtykwEwLDUYaqFXG+H+bUGc8w9CF62pW00gy1jGfeV0P1SHd7QKIW7uh0NtZdijsCE1wbOqa2eq8OYFqXu7K4WCkkmGCczvn1NBjZzYHrfGpRPVxS5Nc9x0wBHf/50/8wa0XfCN6vvp12eZ6lw4i10peeleoidPR/iqLURz9wNoit5hawGAx3JbDaVx0FKfK61f/SgmAVsxfIw5MvfRFx4O+HUdhabTBN8rsQdUdPJqMa2QabrzNnDgflRzayN6X5IKGFwZVL5FQ9ncRsiG5hy1i4QfPtUiBmRYQAXvBW4pFiwMKp1yqjPH/8gwTKDahznhuISyvx6d6DJ8nmNvUrKaRjCxERiWqEuV9KvAys7xvces8jaZCutsFGjo50lGxB5gJMeVPoLez7Pg3UTtQ2BGaCFjzTaHepe75Xkc5stV5c+pVm6RD080HG1Mv0NXFsJONRVJEJMME53xD5jA3yNh6b0g6rcbObA6eTo7ZWuNTiQJjsV6r5ef982UFKrjuO2Dgbtm3SeiPFBFobcPf/vKAh34QVy74RvR2eKQjPfOaaWVzeL7M9S4dlHXMykSulbwcLndrtaghyO0owx+mo/1V/iMfglelSSEPJav2wbM0tZkz1mIwtYDBaDViFiO+XFx7Pr6L0rjoKIo4Cv9OldevFhU1eL+TY9vnE4EMrJi/RvQYXZFdngsyBR7p5cuIdqaTCJRxOo7C0mIOIAUphR5PcQX8mNiDqjuAA0jseDQZ1yC0+wCJMq2j0bJPdJo5cT7CuZPpaz/FSjO/J539KbjepalaCQwvDKpUr+59HyTQN0ekMuDuImRDtqKGlHIPW8Qqj7kTgwnvsNuJDWeQAjMtyILR+mEEh1k5hGWO9xL6za+SGBoGFE65XpSsbhUfkiRNn3Dz5BkmULyZxIdsQp3xNMJ/Jp1EKYXFxMtSjk/1GNbPF89/SUFsJ8mju+lfPPix394vGFmIjEDZalsLUlQRU9K2xvpU4GWi1AKyZnnf4j75PTWXf2uWz/+JQYR0twvc9FXcdXIDfy3y4ajjZH7ru+ScPBJiyp9K4ihIAWkWAlnp9NXwb6J2qO9AoQAAAADhtlLvg2vUBWLdhuoG16gL52H65IW8fA5kCi7hDK5RF+0YA/iPxYUSbnPX/Qp5+Rzrz6vziRItGWikf/YYXKMu+erxwZs3dyt6gSXEHosLJf89Wcqd4N8gfFaNzxTy8jn1RKDWl5kmPHYvdNMSJVoy85MI3ZFOjjdw+NzYMLhGXdEOFLKz05JYUmXAtzZv7lbX2by5tQQ6U1SyaLw8FhdK3aBFpb99w09ey5GgOsG/Qdt37a65qmtEWBw5qyjk5XPJUrecq48xdko5Y5kuM014z4Ufl61YmX1M7suSJEq0ZMX85ounIWBhRpcyjiKdHG/DK06AofbIakBAmoVgcI26gcbfVeMbWb8CrQtQZqclsYcRd17lzPG0BHqjW2ze3K2NaI5C77UIqA4DWkdqCXSmi78mSelioKMI1PJMeCwulJmafHv7R/qRGvGofn77hp+fTdRw/ZBSmhwmAHV0gn+DlTQtbPfpq4YWX/lpclXXiJPjhWfxPgONEIhRYlDIy+exfpkI06Mf4jIVTQ1WH2Pst6kxA9V0t+k0wuUGXGaa8L3QyB/fDU71PrscGlqxMvu7B2AU2drm/jhstBFIlGjJqSI6Jsv/vMwqSe4jTkPAwq/1ki3NKBTHLJ5GKEQ6Od6ljGsxx1Ht2ybnvzRC7ZHVo1vDOsGGRdAgMBc/geZrrmBQOUECjb+r4zvtRIcxw6Vmh5FKBFoXoOXsRU+NSDq5bP5oVg4j7rzvlbxTi5+SsmopwF0I9Ea36UIUWJm6yIB4DJpvGtEchftnTmqfbWCLftsyZBwGtI79sOZhlRSZl3Siy3gWf02S98kffZPDMZxydWNzEKjlmfEet3axXi3zUOh/HDI1+fbTg6sZt4mF+FY/1xc04lH91VQDEr3wfORcRi4LPpuo4d8t+g67J9TvWpGGADhMAOrZ+lIFqQKO3Ui03DIqaVrYy98IN6/VJtZOY3Q5LL7y080IoDylrN/KRBqNJSbHC8/HcVkgo3t3wULNJS4gEKPEwabxK+GW5hQAILT7Yv0yEYNLYP7nQU4fBvcc8GQqmhqFnMj17Ti3AwyO5exuU2MGj+Ux6evvHwgKWU3naITLDYkymeL5ykU6GHwX1XqhkT+bF8PQ/x3tMR6rv958djk0ncBr2/VkFC0U0kbCdg/AKJe5ksfzs7wmEgXuyXDYaCORbjrM0S6gSTCY8qZSRXRMs/Mmo9f5CEI2T1qtVJLcR7UkjqjdgPFePDajsV7rJVu/XXe021dZVTrhC7pYPI1QuYrfv8lyA2coxFGIShnXYquvhY3PpatsLhP5g0zOf2mteC2GxdxScCRqAJ9Gt4Z1pwHUmsML+nsivaiUQGAufqHWfJEAAAAAQ8umh8eQPNSEW5pTzycIc4zsrvQItzSnS3ySIJ5PEObdhLZhWd8sMhoUirVRaBiVEqO+Epb4JEHVM4LGfZlRFz5S95C6CW3D+cLLRLK+WWTxdf/jdS5lsDblwzfj1kHxoB3ndiRGfSVnjduiLPFJgm867wXrYXVWqKrT0foyoy65+QWpPaKf+n5pOX01Fatddt4N2vKFl4mxTjEOZH2zyCe2FU+j7Y8c4CYpm6tau7vokR08bMqHby8BIeiHq/I5xGBUvkA7zu0D8GhqSIz6SgtHXM2PHMaezNdgGRnk4t9aL0RY3nTeC52/eIzWw+qslQhMKxFT1nhSmHD/9GVGXbeu4Noz9XqJcD7cDjtCTi54ieip/NJy+r8Z1H1qKla7KeHwPK26am/ucczopQ1eyObG+E9inWIcIVbEm4n8F0rKN7HNTmwrng2njRlG2x85BRC5voFLI+3CgIVqF7MHrFR4oSvQIzt4k+id/9iUD9+bX6lYHwQzC1zPlYwOV+VzTZxD9MnH2aeKDH8gwXDtAIK7S4cG4NHURSt3U5AY9ZXT01MSV4jJQRRDb8ZfP/3mHPRbYZivwTLbZGe1c860ZDAFEuO0Xoiw95UuN7zpvBf/IhqQe3mAwziyJkTtgaSCrkoCBSoRmFZp2j7RIqas8WFtCnblNpAlpv02oujLjLqrACo9L1uwbmyQFukn7ITJZCciTuB8uB2jtx6adoScXDVPOtuxFKCI8t8GD7mjlC/6aDKofjOo+z34DnyVUt2t1pl7KlLC4XkRCUf+WnXV3hm+c1md5ekK3i5PjQsdzUtI1mvMzI3xn49GVxjEOsU4h/FjvwOq+exAYV9rEvkvlFEyiRPVaRNAlqK1x93eJ+eeFYFgGk4bM1mFvbSMtj9yz32Z9UsmA6YI7aUhQ5E3AQBakYaEAQvVx8qtUm9gfoMsq9gEqPBCV+s75NCgR3bw44zQd2fXSiQkHOyj8S9uZbLkyOI2v1KxdXT0Nj4IZhZ9w8CR+ZhawrpT/EUcrsrnX2VsYNs+9jOY9VC004nClJBCZBMUGf5AV9JYx4Lh2gHBKnyGRXHm1Qa6QFJNxtJyDg109YpW7qbJnUghYTeb8CL8PXemp6ck5WwBo64Qk4Pt2zUEaYCvVypLCdD/eIsWvLMtkTjot8J7IxFFMF+DZXOUJeL3z7+xtAQZNuacacmlV89OIQxVHWLH85opu2G6anDHPe4rXW6t4PvpeNN5LzsY36i/Q0X7/IjjfLf0cVz0P9fbcGRNiDOv6w+bBTje2M6eWVyVBAofXqKNVCIwrRfpliqTsgx50Hmq/gVKKDhGgY6/wtoU7IERsmvKbSBLiaaGzA39HJ9ONroYAAAAAJYwB3csYQ7uulEJmRnEbQeP9GpwNaVj6aOVZJ4yiNsOpLjceR7p1eCI2dKXK0y2Cb18sX4HLbjnkR2/kGQQtx3yILBqSHG5895BvoR91Noa6+TdbVG11PTHhdODVphsE8Coa2R6+WL97Mllik9cARTZbAZjYz0P+vUNCI3IIG47XhBpTORBYNVycWei0eQDPEfUBEv9hQ3Sa7UKpfqotTVsmLJC1sm720D5vKzjbNgydVzfRc8N1txZPdGrrDDZJjoA3lGAUdfIFmHQv7X0tCEjxLNWmZW6zw+lvbieuAIoCIgFX7LZDMYk6Quxh3xvLxFMaFirHWHBPS1mtpBB3HYGcdsBvCDSmCoQ1e+JhbFxH7W2BqXkv58z1LjooskHeDT5AA+OqAmWGJgO4bsNan8tPW0Il2xkkQFcY+b0UWtrYmFsHNgwZYVOAGLy7ZUGbHulARvB9AiCV8QP9cbZsGVQ6bcS6ri+i3yIufzfHd1iSS3aFfN804xlTNT7WGGyTc5RtTp0ALyj4jC71EGl30rXldg9bcTRpPv01tNq6WlD/NluNEaIZ63QuGDacy0EROUdAzNfTAqqyXwN3TxxBVCqQQInEBALvoYgDMkltWhXs4VvIAnUZrmf5GHODvneXpjJ2SkimNCwtKjXxxc9s1mBDbQuO1y9t61susAgg7jttrO/mgzitgOa0rF0OUfV6q930p0VJtsEgxbccxILY+OEO2SUPmptDahaanoLzw7knf8JkyeuAAqxngd9RJMP8NKjCIdo8gEe/sIGaV1XYvfLZ2WAcTZsGecGa252G9T+4CvTiVp62hDMSt1nb9+5+fnvvo5DvrcX1Y6wYOij1tZ+k9GhxMLYOFLy30/xZ7vRZ1e8pt0GtT9LNrJI2isN2EwbCq/2SgM2YHoEQcPvYN9V32eo745uMXm+aUaMs2HLGoNmvKDSbyU24mhSlXcMzANHC7u5FgIiLyYFVb47usUoC72yklq0KwRqs1yn/9fCMc/QtYue2Swdrt5bsMJkmybyY+yco2p1CpNtAqkGCZw/Ng7rhWcHchNXAAWCSr+VFHq44q4rsXs4G7YMm47Skg2+1eW379x8Id/bC9TS04ZC4tTx+LPdaG6D2h/NFr6BWya59uF3sG93R7cY5loIiHBqD//KOwZmXAsBEf+eZY9prmL40/9rYUXPbBZ44gqg7tIN11SDBE7CswM5YSZnp/cWYNBNR2lJ23duPkpq0a7cWtbZZgvfQPA72DdTrrypxZ673n/Pskfp/7UwHPK9vYrCusowk7NTpqO0JAU20LqTBtfNKVfeVL9n2SMuemazuEphxAIbaF2UK28qN74LtKGODMMb3wVaje8CLW1pZCA+IGxlbgAAAFAvHwAJAAAAWWIQAGwAAAAYAAAAEgAAAOyPEABnAAAAKQAAACsAAADsjxAAZwAAACoAAAArAAAA7I8QAGcAAAA1AAAADQAAAOyPEABnAAAAPQAAACsAAADsjxAAZwAAAE0AAAARAAAA7I8QAGcAAABlAAAAEwAAAOyPEABnAAAAbgAAAA0AAADsjxAAZwAAAHYAAAArAAAA7I8QAGcAAAB2AAAATgAAAOyPEABnAAAAggAAABEAAADgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAyNDAfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAAdDAfABoAAADgZhAAXQAAADAHAAAFAAAAQF4QAGsAAAAYAAAAFwAAAEBeEABrAAAARgAAAB8AAABAXhAAawAAAIMAAAAeAAAAbmVlZCBsb29rYWhlYWQAANgwHwAOAAAAQF4QAGsAAACFAAAABQAAAEBeEABrAAAA5AAAABUAAABAXhAAawAAANwAAAAVAAAAQF4QAGsAAAD1AAAAQwAAAHdpbGQgc2NhbgAAADAxHwAJAAAAQF4QAGsAAAD5AAAACQAAAEBeEABrAAAAEgEAAB4AAABAXhAAawAAAFIBAAAJAAAAQF4QAGsAAAAyAQAANQAAAGluZGV4IG91dCBvZiBib3VuZHMAhDEfABMAAABAXhAAawAAADMBAAAVAAAAQF4QAGsAAAAgAQAAGwAAAGludmFsaWQgc2NhbsAxHwAMAAAAQF4QAGsAAABfAAAAEQAAAG1pZCA+IGxlbgAAAOQxHwAJAAAA2hEQAGwAAACPAAAAEgAAANoREABsAAAAcwAAABYAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAAGgyHwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAN4FAAAVAAAA4GYQAF0AAADhBQAACgAAAOBmEABdAAAA7gYAADcAAADgZhAAXQAAAO4GAABFAAAAbW9yZSA8IDLYMx8ACAAAAOBmEABdAAAADQcAAAkAAADgZhAAXQAAABgHAAAaAAAA4GYQAF0AAAAZBwAAGgAAAG5vdCBlbm91Z2ggcm9vbSBmb3Igc2VhcmNoAAAYNB8AGgAAAOBmEABdAAAAMAcAAAUAAABkZXN0IGlzIG91dCBvZiBib3VuZHMAAABMNB8AFQAAAG1pZCA+IGxlbgAAAGw0HwAJAAAAf5cQAF0AAAAhAAAACAAAAD6YEABbAAAAUQAAAAwAAAB5bBAAawAAACEAAAAuAAAAeWwQAGsAAAAhAAAARAAAAHdpbGQgc2NhbgAAAMA0HwAJAAAAeWwQAGsAAAArAAAADQAAAHlsEABrAAAAPAAAABYAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAAEQ1HwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAylDYfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAA1DYfABoAAADgZhAAXQAAADAHAAAFAAAA74sQAG4AAABDAAAAKQAAAO+LEABuAAAASAAAAA4AAADvixAAbgAAAE0AAAAOAAAA74sQAG4AAABbAAAANAAAAO+LEABuAAAAkAAAABYAAADvixAAbgAAAMAAAAAOAAAAuGAQAGUAAAAXAAAAKQAAALhgEABlAAAAFwAAADUAAAByZXdpbmRpbmcgcGFzdCB0aGVuIHN0YXJ0AAAAiDcfABkAAABidWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCkAAACsNx8AIQAAAL2WEABoAAAABQAAACwAAAC9lhAAaAAAAAYAAAAsAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5idWYuaXNfZW1wdHkoKSB8fCBzZWxmLmJ1Zi5sZW4oKSA+PSBTZWxmOjpwYWRkaW5nKCkAAK4SEABkAAAAIQAAAAkAAACuEhAAZAAAAD0AAAAdAAAArhIQAGQAAAB2AAAAKAAAAK4SEABkAAAAdgAAADUAAACuEhAAZAAAAG8AAAA3AAAArhIQAGQAAABvAAAARAAAAK4SEABkAAAAegAAADcAAABHNhAAZAAAAEcAAAAJAAAARzYQAGQAAACgAAAAKQAAAEc2EABkAAAAoQAAACQAAABHNhAAZAAAAKEAAAAzAAAARzYQAGQAAADrAAAAIwAAAEc2EABkAAAA7AAAABgAAABHNhAAZAAAAOwAAAAjAAAARzYQAGQAAADzAAAALAAAAEc2EABkAAAA8wAAABkAAABpbiBib3VuZHMAAABHNhAAZAAAAAQBAAA6AAAARzYQAGQAAAAMAQAAEQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAAEuOEAAqAAAAsQQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsgbWF4X292ZXJoZWFkAABLjhAAKgAAALcEAAANAEH48/wAC+IMAQAAAKMFAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlTGF5b3V0RXJyb3IAAL5nEABeAAAAYAAAAD4AAAC+ZxAAXgAAAHMAAAA+AAAAvmcQAF4AAACNAAAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxheW91dC5hbGlnbigpIDw9IEFMSUdOLmludG8oKb5nEABeAAAAwQAAAAkAAAC+ZxAAXgAAABcBAAAJAAAAAAAAAGludmFsaWQgc2l6ZSBmb3IgAAAAvDofABEAAAC+ZxAAXgAAAFgBAAARAAAAbWlkID4gbGVuAAAA6DofAAkAAADNGBAAbAAAAFYAAAASAAAAzRgQAGwAAAAjAAAAJgAAAOyPEABnAAAAKQAAACsAAADsjxAAZwAAACoAAAArAAAA7I8QAGcAAAA1AAAADQAAAB5hEABlAAAANQAAAC8AAAAeYRAAZQAAADUAAAA+AAAAdGFsbHlfZGlzdDogYmFkIG1hdGNoAAAAbDsfABUAAADgZhAAXQAAANkFAAAJAAAAAAECAwQFBgcICAkJCgoLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQEBAQEBEREREREREREhISEhISEhITExMTExMTExQUFBQUFBQUFBQUFBQUFBQVFRUVFRUVFRUVFRUVFRUVFhYWFhYWFhYWFhYWFhYWFhcXFxcXFxcXFxcXFxcXFxcYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhobGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbHOBmEABdAAAA3gUAABUAAADgZhAAXQAAAOEFAAAKAAAA4GYQAF0AAADuBgAANwAAAOBmEABdAAAA7gYAAEUAAABtb3JlIDwgMtw8HwAIAAAA4GYQAF0AAAANBwAACQAAAOBmEABdAAAAGAcAABoAAADgZhAAXQAAABkHAAAaAAAAbm90IGVub3VnaCByb29tIGZvciBzZWFyY2gAABw9HwAaAAAA4GYQAF0AAAAwBwAABQAAAG1pZCA+IGxlbgAAAFA9HwAJAAAA3VEQAG4AAADBAAAAKQAAAN1REABuAAAAwQAAADsAAADdURAAbgAAABkBAAAUAAAA3VEQAG4AAAAaAQAAFwAAAN1REABuAAAAHQEAAAgAAADdURAAbgAAAB0BAAAQAAAA3VEQAG4AAAAnAQAAFAAAAN1REABuAAAAKAEAABcAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAADQ+HwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAN4FAAAVAAAA4GYQAF0AAADhBQAACgAAAOBmEABdAAAA7gYAADcAAADgZhAAXQAAAO4GAABFAAAAbW9yZSA8IDKkPx8ACAAAAOBmEABdAAAADQcAAAkAAADgZhAAXQAAABgHAAAaAAAA4GYQAF0AAAAZBwAAGgAAAG5vdCBlbm91Z2ggcm9vbSBmb3Igc2VhcmNoAADkPx8AGgAAAOBmEABdAAAAMAcAAAUAAABkZXN0IGlzIG91dCBvZiBib3VuZHMAAAAYQB8AFQAAAAAAAAAEAAAABAAAAEMFAAC7gBAAawAAACQAAAAOAAAApAUAQeSA/QALAqUFAEHwgP0AC6sFpgUAAAQABAAIAAQApwUAAAQABgAQAAYApwUAAAQADAAgABgApwUAAAgAEAAgACAApwUAAAgAEACAAIAAqAUAAAgAIACAAAABqAUAACAAgAACAQAEqAUAACAAAgECAQAQExMQAGQAAABHAAAAKgAAAA0uEABmAAAASQAAABQAAAANLhAAZgAAAFsAAAAJAAAADS4QAGYAAABcAAAACQAAAAMABAAFAAYABwAIAAkACgALAA0ADwARABMAFwAbAB8AIwArADMAOwBDAFMAYwBzAIMAowDDAOMAAgEAAAAAEAAQABAAEAAQABAAEAAQABEAEQARABEAEgASABIAEgATABMAEwATABQAFAAUABQAFQAVABUAFQAQAE0AygABAAIAAwAEAAUABwAJAA0AEQAZACEAMQBBAGEAgQDBAAEBgQEBAgEDAQQBBgEIAQwBEAEYASABMAFAAWAAAAAAEAAQABAAEAARABEAEgASABMAEwAUABQAFQAVABYAFgAXABcAGAAYABkAGQAaABoAGwAbABwAHAAdAB0AQABAAA0uEABmAAAAogAAABcAAAANLhAAZgAAAKUAAAAVAAAADS4QAGYAAAC6AAAAHgAAAA0uEABmAAAAxQAAAAkAAAANLhAAZgAAAMoAAAAYAAAADS4QAGYAAADKAAAAEwAAAA0uEABmAAAAAgEAAA4AAAANLhAAZgAAAAIBAAAJAAAADS4QAGYAAADwAAAADQAAAA0uEABmAAAAvAAAAA0AAAANLhAAZgAAAH4AAAAaAAAADS4QAGYAAACAAAAADQAAAA0uEABmAAAASgAAAAkAAABtaWQgPiBsZW4AAADcQh8ACQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAQaSG/QAL6qIBAQAAAKkFAAAAAAAABAAAAAQAAABEAQAAVHJ5RnJvbUludEVycm9yAAwACACMAAgATAAIAMwACAAsAAgArAAIAGwACADsAAgAHAAIAJwACABcAAgA3AAIADwACAC8AAgAfAAIAPwACAACAAgAggAIAEIACADCAAgAIgAIAKIACABiAAgA4gAIABIACACSAAgAUgAIANIACAAyAAgAsgAIAHIACADyAAgACgAIAIoACABKAAgAygAIACoACACqAAgAagAIAOoACAAaAAgAmgAIAFoACADaAAgAOgAIALoACAB6AAgA+gAIAAYACACGAAgARgAIAMYACAAmAAgApgAIAGYACADmAAgAFgAIAJYACABWAAgA1gAIADYACAC2AAgAdgAIAPYACAAOAAgAjgAIAE4ACADOAAgALgAIAK4ACABuAAgA7gAIAB4ACACeAAgAXgAIAN4ACAA+AAgAvgAIAH4ACAD+AAgAAQAIAIEACABBAAgAwQAIACEACAChAAgAYQAIAOEACAARAAgAkQAIAFEACADRAAgAMQAIALEACABxAAgA8QAIAAkACACJAAgASQAIAMkACAApAAgAqQAIAGkACADpAAgAGQAIAJkACABZAAgA2QAIADkACAC5AAgAeQAIAPkACAAFAAgAhQAIAEUACADFAAgAJQAIAKUACABlAAgA5QAIABUACACVAAgAVQAIANUACAA1AAgAtQAIAHUACAD1AAgADQAIAI0ACABNAAgAzQAIAC0ACACtAAgAbQAIAO0ACAAdAAgAnQAIAF0ACADdAAgAPQAIAL0ACAB9AAgA/QAIABMACQATAQkAkwAJAJMBCQBTAAkAUwEJANMACQDTAQkAMwAJADMBCQCzAAkAswEJAHMACQBzAQkA8wAJAPMBCQALAAkACwEJAIsACQCLAQkASwAJAEsBCQDLAAkAywEJACsACQArAQkAqwAJAKsBCQBrAAkAawEJAOsACQDrAQkAGwAJABsBCQCbAAkAmwEJAFsACQBbAQkA2wAJANsBCQA7AAkAOwEJALsACQC7AQkAewAJAHsBCQD7AAkA+wEJAAcACQAHAQkAhwAJAIcBCQBHAAkARwEJAMcACQDHAQkAJwAJACcBCQCnAAkApwEJAGcACQBnAQkA5wAJAOcBCQAXAAkAFwEJAJcACQCXAQkAVwAJAFcBCQDXAAkA1wEJADcACQA3AQkAtwAJALcBCQB3AAkAdwEJAPcACQD3AQkADwAJAA8BCQCPAAkAjwEJAE8ACQBPAQkAzwAJAM8BCQAvAAkALwEJAK8ACQCvAQkAbwAJAG8BCQDvAAkA7wEJAB8ACQAfAQkAnwAJAJ8BCQBfAAkAXwEJAN8ACQDfAQkAPwAJAD8BCQC/AAkAvwEJAH8ACQB/AQkA/wAJAP8BCQAAAAcAQAAHACAABwBgAAcAEAAHAFAABwAwAAcAcAAHAAgABwBIAAcAKAAHAGgABwAYAAcAWAAHADgABwB4AAcABAAHAEQABwAkAAcAZAAHABQABwBUAAcANAAHAHQABwADAAgAgwAIAEMACADDAAgAIwAIAKMACABjAAgA4wAIAJtcEABtAAAAjgAAABIAAACbXBAAbQAAAGkAAAA3AAAAm1wQAG0AAABqAAAAEQAAAJtcEABtAAAAcAAAADkAAACbXBAAbQAAAHIAAAAfAAAAm1wQAG0AAAB0AAAALwAAAJtcEABtAAAAgQAAADgAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAADgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAyjEgfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAAzEgfABoAAADgZhAAXQAAADAHAAAFAAAATWsQAGAAAAAmAAAAJAAAAAAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAQTEbGYJiNjLDUy0rBMVsZEX0d32Gp1pWx5ZBTwiK2chJu8LRiujv+svZ9OMMT7WsTX6utY4tg57PHJiHURLCShAj2VPTcPR4kkHvYVXXri4U5rU317WYHJaEgwVZmBuCGKkAm9v6LbCayzapXV135hxsbP/fP0HUng5azaIkhJXjFZ+MIEayp2F3qb6m4ejx59Dz6CSD3sNlssXaqq5dXeufRkQozGtvaf1wdq5rMTnvWiogLAkHC204HBLzNkbfsgddxnFUcO0wZWv09/Mqu7bCMaJ1kRyJNKAHkPu8nxe6jYQOed6pJTjvsjz/efNzvkjoan0bxUE8Kt5YBU958ER+YumHLU/CxhxU2wGKFZRAuw6Ng+gjpsLZOL8NxaA4TPS7IY+nlgrOlo0TCQDMXEgx10WLYvpuylPhd1Rdu7oVbKCj1j+NiJcOlpFQmNfeEanMx9L64eyTy/r1XNdich3meWvetVRAn4RPWVgSDhYZIxUP2nA4JJtBIz2na/1l5lrmfCUJy1dkONBOo66RAeKfihghzKczYP28Kq/hJK3u0D+0LYMSn2yyCYarJEjJ6hVT0ClGfvtod2Xi9nk/L7dIJDZ0GwkdNSoSBPK8U0uzjUhScN5leTHvfmD+8+bnv8L9/nyR0NU9oMvM+jaKg7sHkZp4VLyxOWWnqEuYgzsKqZgiyfq1CYjLrhBPXe9fDmz0Rs0/2W2MDsJ0QxJa8wIjQerBcGzBgEF32EfXNpcG5i2OxbUApYSEG7waikFxW7taaJjod0PZ2WxaHk8tFV9+NgycLRsn3RwAPhIAmLlTMYOgkGKui9FTtZIWxfTdV/TvxJSnwu/Vltn26bwHrqiNHLdr3jGcKu8qhe15a8qsSHDTbxtd+C4qRuHhNt5moAfFf2NU6FQiZfNN5fOyAqTCqRtnkYQwJqCfKbiuxeT5n979Oszz1nv96M+8a6mA/VqymT4Jn7J/OISrsCQcLPEVBzUyRioec3cxB7ThcEj10GtRNoNGeneyXWNO1/rLD+bh0sy1zPmNhNfgShKWrwsjjbbIcKCdiUG7hEZdIwMHbDgaxD8VMYUODihCmE9nA6lUfsD6eVWBy2JMH8U4gV70I5idpw6z3JYVqhsAVOVaMU/8mWJi19hTec4XT+FJVn76UJUt13vUHMxiE4qNLVK7ljSR6Lsf0NmgBuzzfl6twmVHbpFIbC+gU3XoNhI6qQcJI2pUJAgrZT8R5HmnlqVIvI9mG5GkJyqKveC8y/KhjdDrYt79wCPv5tm94bwU/NCnDT+DiiZ+spE/uSTQcPgVy2k7RuZCenf9W7VrZdz0Wn7FNwlT7nY4SPexrgm48J8SoTPMP4py/SSTAAAAADdqwgFu1IQDWb5GAtyoCQfrwssGsnyNBIUWTwW4URMOjzvRD9aFlw3h71UMZPkaCVOT2AgKLZ4KPUdcC3CjJhxHyeQdHneiHykdYB6sCy8bm2HtGsLfqxj1tWkZyPI1Ev+Y9xOmJrERkUxzEBRaPBUjMP4Ueo64Fk3kehfgRk041yyPOY6SyTu5+As6PO5EPwuEhj5SOsA8ZVACPVgXXjZvfZw3NsPaNQGpGDSEv1cxs9WVMOpr0zLdAREzkOVrJKePqSX+Me8nyVstJkxNYiN7J6AiIpnmIBXzJCEotHgqH966K0Zg/ClxCj4o9BxxLcN2syyayPUuraI3L8CNmnD351hxrlkec5kz3HIcJZN3K09RdnLxF3RFm9V1eNyJfk+2S38WCA19IWLPfKR0gHmTHkJ4yqAEev3KxnuwLrxsh0R+bd76OG/pkPpubIa1a1vsd2oCUjFoNTjzaQh/r2I/FW1jZqsrYVHB6WDU16Zl471kZLoDImaNaeBnIMvXSBehFUlOH1NLeXWRSvxj3k/LCRxOkrdaTKXdmE2YmsRGr/AGR/ZOQEXBJIJERDLNQXNYD0Aq5klCHYyLQ1Bo8VRnAjNVPrx1VwnWt1aMwPhTu6o6UuIUfFDVfr5R6DniWt9TIFuG7WZZsYekWDSR610D+ylcWkVvXm0vrV+AGzXht3H34O7PseLZpXPjXLM85mvZ/ucyZ7jlBQ165DhKJu8PIOTuVp6i7GH0YO3k4i/o04jt6Yo2q+u9XGnq8LgT/cfS0fyebJf+qQZV/ywQGvobetj7QsSe+XWuXPhI6QDzf4PC8iY9hPARV0bxlEEJ9KMry/X6lY33zf9P9mBdeNlXN7rYDon82jnjPtu89XHei5+z39Ih9d3lSzfc2Axr1+9mqda22O/UgbIt1QSkYtAzzqDRanDm010aJNIQ/l7FJ5ScxH4q2sZJQBjHzFZXwvs8lcOigtPBlegRwKivTcufxY/KxnvJyPERC8l0B0TMQ22GzRrTwM8tuQLOQJavkXf8bZAuQiuSGSjpk5w+pparVGSX8uoilcWA4JT4x7yfz61+npYTOJyhefqdJG+1mBMFd5lKuzGbfdHzmjA1iY0HX0uMXuENjmmLz4/snYCK2/dCi4JJBIm1I8aIiGSag78OWILmsB6A0drcgVTMk4RjplGFOhgXhw1y1Yag0OKpl7ogqM4EZqr5bqSrfHjrrksSKa8SrG+tJcatrBiB8acv6zOmdlV1pEE/t6XEKfig80M6oar9fKOdl76i0HPEtecZBrS+p0C2ic2CtwzbzbI7sQ+zYg9JsVVli7BoIte7X0gVugb2U7gxnJG5tIrevIPgHL3aXlq/7TSYvgAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd4AAAAAsClgPWBTwHrQeqBHwKaA9XCP4Mig9UCPENwgssFLcDBxYhANoRiwShEx0HcB7fDFscSQ+GG+ML/Rl1CCgpfgYDK+gF3ixCAaUu1AJ0IxYJXyGACoImKg75JLwNJD3JBQ8/XwbSOPUCqTpjAXg3oQpTNTcJjjKdDfUwCw4gQvwcG0BqH8ZHwBu9RVYYbEiUE0dKAhCaTagU4U8+FzxWSx8XVN0cylN3GLFR4RtgXCMQS161E5ZZHxftW4kUOGuCGhNpFBnObr4dtWwoHmRh6hVPY3wWkmTWEulmQBE0fzUZH32jGsJ6CR65eJ8daHVdFkN3yxWecGER5XL3EjSVjzWPlxk2UpCzMimSJTH4n+c6051xOQ6a2z11mE0+qIE4NoODrjVehAQxJYaSMvSLUDnficY6Ao5sPnmM+j2svPEzh75nMFq5zTQhu1s38LaZPNu0Dz8Gs6U7fbEzOKCoRjCLqtAzVq16Ny2v7DT8oi4/16C4PAqnEjhxpYQ7pNdzKZ/V5SpC0k8uOdDZLejdGybD340lHtgnIWXasSK4w8Qqk8FSKU7G+C01xG4u5MmsJc/LOiYSzJAiac4GIbz+DS+X/JssSvsxKDH5pyvg9GUgy/bzIxbxWSdt888ksOq6LJvoLC9G74YrPe0QKOzg0iPH4kQgGuXuJGHneCe5Kw5rEimYaM8uMmy0LKRvZSFmZE4j8GeTJFpj6CbMYDU/uWgePS9rwzqFb7g4E2xpNdFnQjdHZJ8w7WDkMntjMQJwbRoA5m7HB0xqvAXaaW0IGGJGCo5hmw0kZeAPsmY9FsduFhRRbcsT+2mwEW1qYRyvYUoeOWKXGZNm7BsFZTlp8ncCa2R032zOcKRuWHN1Y5p4XmEMe4Nmpn/4ZDB8JX1FdA5/03fTeHlzqHrvcHl3LXtSdbt4j3IRfPRwh38hQIxxCkIactdFsHasRyZ1fUrkflZIcn2LT9h58E1Oei1UO3IGVq1x21EHdaBTkXZxXlN9WlzFfodbb3r8Wfl5Lb6BXpa8F11Lu71ZMLkrWuG06VHKtn9SF7HVVmyzQ1WxqjZdmqigXkevClo8rZxZ7aBeUsaiyFEbpWJVYKf0VrWX/1ielWlbQ5LDXziQVVzpnZdXwp8BVB+Yq1Bkmj1TuYNIW5KB3lhPhnRcNITiX+WJIFTOi7ZXE4wcU2iOilC9/H1Chv7rQVv5QUUg+9dG8fYVTdr0g04H8ylKfPG/SaHoykGK6lxCV+32RizvYEX94qJO1uA0TQvnnklw5QhKpdUDRI7XlUdT0D9DKNKpQPnfa0vS3f1ID9pXTHTYwU+pwbRHgsMiRF/EiEAkxh5D9cvcSN7JSksDzuBPeMx2TKAAAAAKXTXMsLochNrnKUhhZCkZuzkc1QHeNZ1rgwBR1tglPsyFEPJ2Yjm6HD8Mdqe8DCd94TnrxwYQo61bJW8ZsC1gM+0YrIkKMeTjVwQoWNQEeYKJMbU4bhj9UjMtMe9oCF71NT2ST9IU2iWPIRaeDCFHRFEUi/62PcOU6wgPI2BawHk9bwzD2kZEqYdziBIEc9nIWUYVcr5vXRjjWpGluH/+v+VKMgUCY3pvX1a21NxW5w6BYyu0Zkpj3jt/r2rQd6BAjUJs+mprJJA3XugrtF658elrdUsOQj0hU3fxnAhSnoZVZ1I8sk4aVu971u1se4c3MU5LjdZnA+eLUs9WwKWA/J2QTEZ6uQQsJ4zIl6SMmU35uVX3HpAdnUOl0SAYgL46RbVygKKcOur/qfZRfKmniyGcazHGtSNbm4Dv73CI4MUtvSx/ypRkFZehqK4Uofl0SZQ1zq69faTziLEZqK3eA/WYErkSsVrTT4SWaMyEx7KRsQsIdphDYiutj9Wg/0CP/cqMNRrjxF9H1gjkxNZZPpnjlYR+yt3uI/8RU3jafkkl77Lzwsb6mZ/zNiIc82f4QcarQqbv4yj72i+cENIgtk3n7AyqzqRm9/to3XT7OQcpzvW9zue915PScWrI9x5wlcLSynLrmqAv3lYbrN4HwfHry3sWwoMRS/dPrYFLAefcfs1dO1eFN2ZiSYzlYhhWuFfU7F9+nIYCS1A7WW4/IQRb85vjcrvxvkd3Sj1HJpBgcuoqh1uiQNpubvQxZmHebFOtZIt65Q7WTym1VU94bwh6tNXvU/y/smYwAulDXxi0dpOiU1/byA5qF3ONakap0F+KEzd2wnlqQw7O4RHBlLwkDS5bDUVEBjiJ/4U42CXYDRSfPyRc9WIRkEg5NP9SZAEz6IMoe4LeHbc5XR3m4wAoKlnnAWIzujSuh1E8oa0MCW0X6yAlfbYV6cY1FbgcaCB0po8JPMzSPPBxiRmfa9QsU9EzBRu7bjDXAO0whtqwBUpgVywCCgoZzrtB7oERHNtNq/vyBcGmx8l6JceYoHjyVBqf2xxwwu7QzZnLv9fE/nNtI9c7B37i97z94qZmoNdq3Ef+IrYay+4C8cPhKKz2LZJL32X4FuqpQ5Xq+JnI3zQjL/Z8SXLDsPQp5t/udNMTVJP6Wz7Oz5eFTc/GXxD6CuX300KPquaOOCG0QWJ8gY3Ym6jFssadCQlFnVjTGKiUaf+B3AOitBC++ZF/pKSksx5Djft0Hrg3z524ZhXAjaqvJ6TixXqRLnGRmSFbzKzt4SuFpYt2sGkw9bA46qiF9FBPrLw6Eplwh0m8H50UidMn86CbTa6VV/YtlQYscKDKlpeJgvzKvE5AAAAAC0C3emKRGfl50a6DETJE/0py84Ujo10GOOPqfFZ07vM9NFmJVOX3Ck+lQHAnRqoMfAYddhXXs/UOlwSPbOnN5nepepweeNQfBThjZW3biRk2mz5jX0qQ4EQKJ5oqnSMVQd2UbygMOuwzTI2WW69n6gDv0JBpPn4Tcn7JaRnDm9zygyymm1KCJYASNV/o8d8js7FoWdpgxtrBIHGgr7d1L8T3wlWtJmzWtmbbrN6FMdCFxYaq7BQoKfdUn1OVKlY6jmrhQOe7T8P8+/i5lBgSxc9Ypb+miQs8vcm8RtNeuMm4Hg+z0c+hMMqPFkqibPw2+SxLTJD95c+LvVK155dQtEzX584lBklNPkb+N1alFEsN5aMxZDQNsn90usgR475HeqMJPRNyp74IMhDEYNH6uDuRTcJSQONBSQBUOyt+nVIwPiooWe+Eq0KvM9EqTNmtcQxu1xjdwFQDnXcubQpzoQZKxNtvm2pYdNvdIhw4N15HeIAkLqkupzXpmd1eVMtotRR8EtzF0pHHhWXrr2aPl/QmOO2d95ZuhrchFOggJZuDYJLh6rE8YvHxixiZEmFkwlLWHquDeJ2ww8/n0r0Gjsn9sfSgLB93u2yoDdOPQnGIz/UL4R5biPpe7PKUyeh9/4lfB5ZY8YSNGEb+5fusgr67G/jXarV7zCoCAa8uoWiEbhYS7b+4kfb/D+ueHOWXxVxS7ayN/G63zUsU2VpPm7Ia+OHby1ZiwIvhGKhoC2TzKLwemvkSnYG5pefjx2yO+Ifb9JFWdXeKFsIN4vUocbm1nwvQZDGIyySG8qWzgn3O8zUHpyKbhLxiLP7UgcaCj8Fx+OYQ33v9UGgBlu06tH2tjc4UfCNNDzyUN2fffks8n8kxVU5nsk4O0MggmdRHS9ljPSIIzb45SHrEUauQuArrJ8JjOolBeHo+OxoE91IBREAoaJXuq3PVWdEbNrOtQHYE1ymnqlQy5x0uXHAZoTcwrtte4QBYRaG3Ii1CXV52AuokH9NEpwST891oufHcw/lGpqoo6CWxaF9f2Yu1I4LLAlnrGqza8FoboJ7NHy/1jahVnFwG1occsazv/1vQtL/sqt1uQinGLvVTpFA8Or8Qi0DWwSXDzYGSuaVieMX+Is+/l/NhPIyz1kbiJNLJiWRls+C1yzD79XxKkxaWNshWIUyhh4/Pusc4tdF6agA6Ot16U+tz+UirxIMgSC7/ewiZhRLZNwYJmYB8Zw6E8wxOM4lln50Kft8qcBY8wAxNfHd2JK3Z9T/tbo9dk6fmRtMQnC8Cvh80QgllXKHjGQfhVGNuMPrgdXBNmhvnSRVwp/5vGXZQ7AI255Zq1Q3qMZW6kFhEFBNDBKNpIAAAAAngCqzH0HJULjB4+O+g5KhGQO4EiHCW/GGQnFCrUb5dMrG08fyBzAkVYcal1PFa9X0RUFmzISihWsEiDZKzG7fLUxEbBWNp4+yDY08tE/8fhPP1s0rDjUujI4fnaeKl6vACr0Y+Mte+19LdEhZCQUK/okvucZIzFphyObpVZidvnIYtw1K2VTu7Vl+XesbDx9MmyWsdFrGT9Pa7Pz43mTKn15OeaefrZoAH4cpBl32a6Hd3NiZHD87PpwViB9U82F41NnSQBU6MeeVEILh12HARldLc36WqJDZFoIj8hIKFZWSIKatU8NFCtPp9gyRmLSrEbIHk9BR5DRQe1c7cKdKXPCN+WQxbhrDsUSpxfM162JzH1hasvy7/TLWCNY2Xj6xtnSNiXeXbi73vd0otcyfjzXmLLf0Bc8QdC98MbzJlVY84yZu/QDFyX0qds8/WzRov3GHUH6SZPf+uNfc+jDhu3oaUoO7+bEkO9MCInmiQIX5iPO9OGsQGrhBoy7oOvQJaBBHManzpJYp2ReQa6hVN+uC5g8qYQWoqku2g67DgOQu6TPc7wrQe28gY30tUSHarXuS4myYcUXsssJkJFQrA6R+mDtlnXuc5bfImqfGij0n7DkF5g/aomYlaYlirV/u4ofs1iNkD3GjTrx34T/+0GEVTeig9q5PINwddqFO1NEhZGfp4IeETmCtN0gi3HXvovbG12MVJXDjP5Zb57egPGedEwSmfvCjJlRDpWQlAQLkD7I6JexRnaXG4rxtIAvb7Qq44yzpW0Ssw+hC7rKq5W6YGd2ve/p6L1FJUSvZfzar88wOahAvqeo6nK+oS94IKGFtMOmCjpdpqD2jOdNqhLn52bx4Gjob+DCJHbpBy7o6a3iC+4ibJXuiKA5/Kh5p/wCtUT7jTva+yf3w/Li/V3ySDG+9ce/IPVtc6fW9tY51lwa2tHTlETReVhd2LxSw9gWniDfmRC+3zPcEs0TBYzNuclvyjZH8cqci+jDWYF2w/NNlcR8wwvE1g83R6Z6qUcMtkpAgzjUQCn0zUns/lNJRjKwTsm8Lk5jcIJcQ6kcXOll/1tm62FbzCd4Ugkt5lKj4QVVLG+bVYajHHYdBoJ2t8phcThE/3GSiOZ4V4J4eP1Om39ywAV/2AypbfjVN21SGdRq3ZdKandbU2OyUc1jGJ0uZJcTsGQ932El0IP/JXpPHCL1wYIiXw2bK5oHBSswy+Ysv0V4LBWJ1D41UEo+n5ypORASNzm63i4wf9SwMNUYUzdals038FpKFGv/1BTBMzcTTr2pE+RxsBohey4ai7fNHQQ5Ux2u9f8PjixhDyTgggirbhwIAaIFAcSomwFuZHgG4ermBksmAAAAAEMUexeGKPYuxTyNOQxR7F1PRZdKinkac8ltYWQYoti7W7ajrJ6KLpXdnlWCFPM05lfnT/GS28LI0c+533FCwKwyVru792o2grR+TZV9EyzxPgdX5vs72t+4L6HIaeAYFyr0YwDvyO45rNyVLmWx9EompY9d45kCZKCNeXOjgvGC4JaKlSWqB6xmvny7r9Md3+zHZsgp++vxau+Q5rsgKTn4NFIuPQjfF34cpAC3ccVk9GW+czFZM0pyTUhd0sAxLpHUSjlU6McAF/y8F96R3XOdhaZkWLkrXRutUErKYumViXaSgkxKH7sPXmSsxjMFyIUnft9AG/PmAw+I8QcDkt5EF+nJgStk8MI/H+cLUn6DSEYFlI16iK3ObvO6H6FKZVy1MXKZibxL2p3HXBPwpjhQ5N0vldhQFtbMKwF2QVJyNVUpZfBppFyzfd9LehC+LzkExTj8OEgBvywzFm7jiskt9/He6Mt856vfB/BismaUIaYdg+SakLqnjuutpIFjXOeVGEsiqZVyYb3uZajQjwHrxPQWLvh5L23sAji8I7vn/zfA8DoLTcl5HzbesHJXuvNmLK02WqGUdU7ag9XDo/CW19jnU+tV3hD/LsnZkk+tmoY0ul+6uYMcrsKUzWF7S451AFxLSY1lCF32csEwlxaCJOwBRxhhOAQMGi9PAFVmDBQucckoo0iKPNhfQ1G5OwBFwizFeU8Vhm00Aleijd0UtvbK0Yp785KeAORb82GAGOcal93bl66ez+y5PkKVyn1W7t24amPk+34Y8zITeZdxBwKAtDuPufcv9K4m4E1xZfQ2ZqDIu1/j3MBIKrGhLGml2jusmVcC740sFeyCpOSvlt/zaqpSyim+Kd3g00i5o8czrmb7vpcl78WA9CB8X7c0B0hyCIpxMRzxZvhxkAK7ZesVfllmLD1NHTudwGRI3tQfXxvokmZY/OlxkZGIFdKF8wIXuX47VK0FLIVivPPGdsfkA0pK3UBeMcqJM1CuyicruQ8bpoBMD92XSAPHuAsXvK/OKzGWjT9KgURSK+UHRlDywnrdy4FuptxQoR8DE7VkFNaJ6S2VnZI6XPDzXh/kiEna2AVwmcx+ZzlBBxR6VXwDv2nxOvx9ii01EOtJdgSQXrM4HWfwLGZwIePfr2L3pLinyymB5N9Sli2yM/Jupkjlq5rF3OiOvsvrgTY6qJVNLW2pwBQuvbsD59DaZ6TEoXBh+CxJIuxXXvMj7oGwN5WWdQsYrzYfY7j/cgLcvGZ5y3la9PI6To/lmsP2ltnXjYEc6wC4X/97r5aSGsvVhmHcELrs5VOul/KCYS4twXVVOgRJ2ANHXaMUjjDCcM0kuWcIGDReSwxPSQAAAAA+a8LvPdD1BAO7N+t6oOsJRMsp5kdwHg15G9zi9EDXE8orFfzJkCIX9/vg+I7gPBqwi/71szDJHo1bC/Hoga4n1upsyNVRWyPrOpnMkiFFLqxKh8Gv8bAqkZpyxRzBeTQiqrvbIRGMMB96Tt9mYZI9WApQ0luxZzll2qXW0ANdT+5on6Dt06hL07hqpKqjtkaUyHSpl3NDQqkYga0kQ4pcGihIsxmTf1gn+L23XuNhVWCIo7pjM5RRXVhWvjiC82gG6TGHBVIGbDs5xINCIhhhfEnajn/y7WVBmS+KzMIke/Kp5pTxEtF/z3kTkLZiz3KICQ2di7I6drXZ+JmgB7qenmx4cZ3XT5qjvI112qdRl+TMk3jnd6ST2RxmfFRHbY1qLK9iaZeYiVf8WmYu54aEEIxEaxM3c4AtXLFvSIYUuXbt1lZ1VuG9Sz0jUjIm/7AMTT1fD/YKtDGdyFu8xsOqgq0BRYEWNq6/ffRBxmYoo/gN6kz7tt2nxd0fSHAE59FObyU+TdQS1XO/0DoKpAzYNM/ONzd0+dwJHzszhEQwwrov8i25lMXGh/8HKf7k28vAjxkkwzQuz/1f7CCYhUn2pu6LGaVVvPKbPn4d4iWi/9xOYBDf9Vf74Z6VFGzFnuVSrlwKURVr4W9+qQ4WZXXsKA63Ayu1gOgV3kIHAQkF5j9ixwk82fDiArIyDXup7u9FwiwARnkb63gS2QT1SdL1yyIQGsiZJ/H28uUej+k5/LGC+xOyOcz4jFIOF+mIq8HX42ku1FhexeoznCqTKEDIrUOCJ674tcyQk3cjHch80iOjvj0gGInWHnNLOWdol9tZA1U0Wrhi32TToDDRClip72GaRuzara3SsW9Cq6qzoJXBcU+WekakqBGESyVKj7obIU1VGJp6vibxuFFf6mSzYYGmXGI6kbdcUVNYOYv2jgfgNGEEWwOKOjDBZUMrHYd9QN9ofvvog0CQKmzNyyGd86DjcvAb1JnOcBZ2t2vKlIkACHuKuz+QtND9f6EOv3ifZX2XnN5KfKK1iJPbrlRx5cWWnuZ+oXXYFWOaVU5oa2slqoRonp1vVvVfgC/ug2IRhUGNEj52ZixVtIlJjxFfd+TTsHRf5FtKNCa0My/6Vg1EOLkO/w9SMJTNvb3PxkyDpASjgB8zSL508afHby1F+QTvqvq/2EHE1BqucQ3iN09mINhM3RczcrbV3AutCT41xsvRNn38OggWPtWFTTUkuyb3y7idwCCG9gLP/+3eLcGGHMLCPSsp/FbpxpmMTBCn547/pFy5FJo3e/vjLKcZ3Udl9t78Uh3gl5DybcybA1OnWexQHG4Hbnes6BdscAopB7LlKryFDhTXR+EAAAAAwN+OwcG5bFgBZuKZgnPZsEKsV3FDyrXogxU7KUXhw7qFPk17hFiv4kSHISPHkhoKB02UywYrdlLG9PiTy8T2rgsbeG8KfZr2yqIUN0m3Lx6JaKHfiA5DRkjRzYeOJTUUTvq71U+cWUyPQ9eNDFbspMyJYmXN74D8DTAOPdePnIYXUBJHFjbw3tbpfh9V/EU2lSPL95RFKW5Umqevkm5fPFKx0f1T1zNkkwi9pRAdhozQwghN0aTq1BF7ZBUcS2oo3JTk6d3yBnAdLYixnjizmF7nPVlfgd/An15RAVmqqZKZdSdTmBPFyljMSwvb2XAiGwb+4xpgHHrav5K77xlI1i/GxhcuoCSO7n+qT21qkWattR+nrNP9PmwMc/+q+ItsaicFrWtB5zSrnmn1KItS3OhU3B3pMj6EKe2wRSTdvnjkAjC55WTSICW7XOGmrmfIZnHpCWcXC5CnyIVRYTx9wqHj8wOghRGaYFqfW+NPpHIjkCqzIvbIKuIpRus4ltRQ+ElakfkvuAg58DbJuuUN4Ho6gyF7XGG4u4PveX13F+q9qJkrvM57snwR9XP/BM5aP9tAmz69ogL+YizD81Ii/jONrD8y606m8jTAZ3Eh+06x/nWPsJiXFnBHGde2s+FEdmxvhXcKjRy31QPdNMA49PQftjX1eVSsNababZ814Xdf6m+2XoyNL55TA+4dRjjH3Zm2Btz/VJ8cINpe2tQizRoLrAwbbU6V27LAVFin+32YeHW8mR6XJVnBGeRU8RfZlC6ZGJVIe4FVl/VA1oLOaRZdQKgXO6Ix1+Qs8BEQ1GPRz1qi0Km4OxB2NvqTYw3TU7yDElLaYYuSBe9KSLp98Yhl8zCJAxGpSdyfaMrJpEEKFiqAC3DIGcuvRtgNW75LzYQwiszi0hMMPVzSjyhn+0/36TpOkQujjk6FYoN+i19DoQWeQsfnB4IYacYBDVLvwdLcLsC0PrcAa7B2xp9I5QZAxiQHJiS9x/mqfETskVWEMx+UhVX9DUWKc8xwLKmhsPMnYLGVxflxSks48l9wETKA/tAz5hxJ8zmSiDXNahv1EuTa9HQGQzSriIK3vrOrd2E9anYH3/O22FEyu+hfD3s30c56UTNXuo69ljmbhr/5RAh++CLq5zj9ZCb+CZy1PtYSdD+w8O3/b34sfHpFBbyly8S9wyldfRynnKejNSdnfLvmZhpZf6bF174l0OyX5Q9iVuRpgM8ktg4O4kL2nSKdeFwj+5rF4yQUBGAxLy2g7qHsoYhDdWFXzbRsZ8OJrLhNSK3er9FtASEQ7hQaOS7LlPgvrXZh73L4oCmGADPpWY7y6D9sayjg4qqr9dmDaypXQmpMtduqkzsaAAAAAG9MpZufnjvs8NKed387BgMQd6OY4KU974/pmHT+dgwGkTqpnWHoN+oOpJJxgU0KBe4Br54e0zHpcZ+UcvztGAyTob2XY3Mj4Aw/hnuD1h4P7Jq7lBxIJeNzBIB4ApsUCm3XsZGdBS/m8kmKfX2gEgkS7LeS4j4p5Y1yjH742zEYl5eUg2dFCvQICa9vh+A3G+iskoAYfgz3dzKpbAatPR5p4ZiFmTMG8vZ/o2l5ljsdFtqehuYIAPGJRKVqBDYpFGt6jI+bqBL49OS3Y3sNLxcUQYqM5JMU+4vfsWD6QCUSlQyAiWXeHv4KkrtlhXsjEeo3hooa5Rj9dam9ZvC3YzCf+8arbylY3ABl/UePjGUz4MDAqBASXt9/XvtEDsFvNmGNyq2RX1Ta/hPxQXH6aTUetsyu7mRS2YEo90IMWns8Yxbep5PEQND8iOVLc2F9Pxwt2KTs/0bTg7PjSPIsdzqdYNKhbbJM1gL+6U2NF3E54lvUohKJStV9xe9OCGxSKGcg97OX8mnE+L7MX3dXVCsYG/Gw6Mlvx4eFylz2Gl4umVb7tWmEZcIGyMBZiSFYLeZt/bYWv2PBefPGWvSBSiSbze+/ax9xyART1FOLukwn5PbpvBQkd8t7aNJQCvdGImW747mVaX3O+iXYVXXMQCEagOW66lJ7zYUe3lbgb8dgjyNi+3/x/IwQvVkXn1TBY/AYZPgAyvqPb4ZfFB4Zy2ZxVW79gYfwiu7LVRFhIs1lDm5o/v689omR8FMSHILfbHPOeveDHOSA7FBBG2O52W8M9Xz0/Cfig5NrRxji9NNqjbh28X1q6IYSJk0dnc/VafKDcPICUe6FbR1LHhi09nh3+FPjhyrNlOhmaA9nj/B7CMNV4PgRy5eXXW4M5sL6fomOX+V5XMGSFhBkCZn5/H32tVnmBmfHkWkrYgrkWe50ixVL73vH1ZgUi3ADm2Lod/QuTewE/NOba7B2ABov4nJ1Y0fphbHZnur9fAVlFORxClhB6vqK352VxnoGENikUH+UAcuPRp+84Ao6J2/jolMArwfI8H2Zv58xPCTurqhWgeINzXEwk7oefDYhkZWuVf7ZC84OC5W5YUcwIuw1vFyDeRnHc6uHsBznIiuTDrpf/EIfxAyQgbNj3CQoEkOwWn0PFcGN3Yu24pEuLW14tlkCNBPC8uaNtZ2qKC7oA5VIh08w03edrqQY0Qs/lziTS/h0NtAIpqinZ+oNPBZ1mU55OTzVieuiouanBzlpTp9NBgI61vbQpKGZnAE6FO6NRHuiKN+LcLao5DwTM2vVi0cEmS7c9Euwq5sHFTDqmIFChdQk2XUGuq4aSh81laOHQfrvItoKPbytZXEZNgAAAACF2ZbdS7VcYM5syr2WarnAE7MvHd3f5aBYBnN9bdMDWugKlYcmZl86o7/J5/u5upp+YCxHsAzm+jXVcCfapge0X3+RaZETW9QUys0JTMy+dMkVKKkHeeIUgqB0ybd1BO4yrJIz/MBYjnkZzlMhH70upMYr82qq4U7vc3eT9Ut+s3CS6G6+/iLTOye0DmMhx3Pm+FGuKJSbE61NDc6YmH3pHUHrNNMtIYlW9LdUDvLEKYsrUvRFR5hJwJ4OlC/teQeqNO/aZFglZ+GBs7q5h8DHPF5WGvIynKd36wp6Qj56Xcfn7IAJiyY9jFKw4NRUw51RjVVAn+Gf/Ro4CSCrkY29LkgbYOAk0d1l/UcAPfs0fbgioqB2Tmgd85f+wMZCjudDmxg6jffShwguRFpQKDcn1fGh+huda0eeRP2acTeKCfTuHNQ6gtZpv1tAtOddM8lihKUUrOhvqSkx+XQc5IlTmT0fjldR1TPSiEPuio4wkw9Xpk7BO2zzROL6Ll7a8w7bA2XTFW+vbpC2ObPIsErOTWncE4MFFq4G3IBzMwnwVLbQZol4vKw0/WU66aVjSZQgut9J7tYV9GsPgymEfPS6AaViZ8/JqNpKED4HEhZNepfP26dZoxEa3HqHx+mv9+BsdmE9ohqrgCfDPV1/xU4g+hzY/TRwEkCxqYSdFyVqoJL8/H1ckDbA2UmgHYFP02AElkW9yvqPAE8jGd169mn6/y//JzFDNZq0mqNH7JzQOmlFRuenKYxaIvAah82DbRRIWvvJhjYxdAPvp6lb6dTU3jBCCRBciLSVhR5poFBuTiWJ+JPr5TIubjyk8zY6146z40FTfY+L7vhWHTPibhQTZ7eCzqnbSHMsAt6udASt0/HdOw4/sfGzumhnbo+9F0kKZIGUxAhLKUHR3fQZ166JnA44VFJi8unXu2Q0OMgTp70RhXpzfU/H9qTZGq6iqmcrezy65Rf2B2DOYNpVGxD90MKGIB6uTJ2bd9pAw3GpPUaoP+CIxPVdDR1jgLy05x05bXHA9wG7fXLYLaAq3l7drwfIAGFrAr3kspRg0WfkR1S+cpqa0rgnHwsu+kcNXYfC1MtaDLgB54lhlzpmEuCp48t2dC2nvMmofioU8HhZaXWhz7S7zQUJPhST1AvB4/OOGHUuQHS/k8WtKU6dq1ozGHLM7tYeBlNTx5COSf+ZrswmD3MCSsXOh5NTE9+VIG5aTLazlCB8DhH56tMkLJr0ofUMKW+ZxpTqQFBJskYjNDeften5839UfCrpiZNZnhoWgAjH2OzCel01VKcFMyfagOqxB06Ge7rLX+1n/oqdQHtTC521P8EgMOZX/WjgJIDtObJdI1V44KaM7j0AAAAAduEPna3EbuHbJWF8G4+sGW1uo4S2S8L4wKrNZTYeWTNA/1aum9o30u07OE8tkfUqW3D6t4BVm8v2tJRWbDyyZhrdvfvB+NyHtxnTGnezHn8BUhHi2ndwnqyWfwNaIutVLMPkyPfmhbSBB4opQa1HTDdMSNHsaSmtmogmMNh4ZM2umWtQdbwKLANdBbHD98jUtRbHSW4zpjUY0qmo7mY9/piHMmNDolMfNUNcgvXpkeeDCJ56WC3/Bi7M8Ju0RNarwqXZNhmAuEpvYbfXr8t6stkqdS8CDxRTdO4bzoJaj5j0u4AFL57heVl/7uSZ1SOB7zQsHDQRTWBC8EL98fe5QYcWttxcM9egKtLYPep4FVicmRrFR7x7uTFddCTH6eBysQjv72otjpMczIEO3GZMa6qHQ/ZxoiKKB0MtF53LCyfrKgS6MA9lxkbualuGRKc+8KWooyuAyd9dYcZCq9VSFN00XYkGETz1cPAzaLBa/g3Gu/GQHZ6Q7Gt/n3Epj92MX27SEYRLs23yqrzwMgBxlUThfgifxB906SUQ6R+RhL9pcIsislXqXsS05cMEHiimcv8nO6naRkffO0naRbNv6jNSYHfodwELnpYOll48w/Mo3cxu8/itEoUZoo9zrTbZBUw5RN5pWDioiFelaCKawB7DlV3F5vQhswf7vOLvc4OUDnweTysdYjnKEv/5YN+aj4HQB1SksXsiRb7m1PEqsKIQJS15NURRD9RLzM9+hqm5n4k0YrroSBRb59WO08Hl+DLOeCMXrwRV9qCZlVxt/OO9YmE4mAMdTnkMgLjNmNbOLJdLFQn2N2Po+aqjQjTP1aM7Ug6GWi54Z1WzOpcXTkx2GNOXU3mv4bJ2MiEYu1dX+bTKjNzVtvo92isMiU59emhB4KFNIJzXrC8BFwbiZGHn7fm6woyFzCODGFarpSggSqq1+2/LyY2OxFRNJAkxO8UGrODgZ9CWAWhNYLX8GxZU84bNcZL6u5CdZ3s6UAIN21+f1v4+46AfMX4TGMrCZfnFX77cpCPIPau+CJdm2352aUalUwg607IHpyUGk/FT55xsiML9EP4j8o0+iT/oSGgwdZNNUQnlrF6UfyR4pAnFdznS4BZFpAEZ2GSr1L0SStsgyW+6XL+OtcFJOiGXP9suCuT+T3aSH0DrUrWNjiRUghP/ceNviZDs8stgrg+9gaGSZqTA7hBFz3PQ7wIWpg4Ni30rbPcLymNq/X73PIuf+KFQupndJluWQObxWyWQEFS4SzU1xD3UOlmnXBxp0b0T9AqYcoh8eX0VvNOwcMoyv+0RF96RZ/bRDJFCRVrno0rHPIYru0pnJCaKzelD/Czm3icJh6JR6Ig/AAAAAOjb+7mRsYaoeWp9EWNlfIqLvocz8tT6IhoPAZuHzInPbxdydhZ9D2f+pvTe5Kn1RQxyDvx1GHPtncOIVE+fYkSnRJn93i7k7Db1H1Us+h7OxCHld71LmGZVkGPfyFPriyCIEDJZ4m0jsTmWmqs2lwFD7Wy4OocRqdJc6hCePsWIduU+MQ+PQyDnVLiZ/Vu5AhWAQrts6j+qhDHEExnyTEfxKbf+iEPK72CYMVZ6lzDNkkzLdOsmtmUD/U3c0aGnzDl6XHVAECFkqMva3bLE20ZaHyD/I3Vd7suupldWbS4DvrbVusfcqKsvB1MSNQhSid3TqTCkudQhTGIvmH17+8qVoABz7Mp9YgQRhtseHodA9sV8+Y+vAehndPpR+rdyBRJsibxrBvStg90PFJnSDo9xCfU2CGOIJ+C4c54y5JmO2j9iN6NVHyZLjuSfUYHlBLlaHr3AMGOsKOuYFbUoEEFd8+v4JJmW6cxCbVDWTWzLPpaXckf86mOvJxHa40U+Qguexfty9Ljqmi9DU4AgQsho+7lxEZHEYPlKP9lkibeNjFJMNPU4MSUd48qcB+zLB+83ML6WXU2vfoa2FqzaXAZEAae/PWvartWwIRfPvyCMJ2TbNV4OpiS21V2dKxbVycPNLnC6p1NhUnyo2EhzqUOgqFL62cIv6zEZ1FK78IdOUyt89ypBAebCmvpf2JX7xDBOAH1JJH1sof+G1Tw8DoHU5/U4rY2IKUVWc5BfWXILt4KJss7o9KMmMw8a9G/lChy0HrNl3mOijQWYG5cKmYB/0WI5BrsfKO5g5JFzo2zFm3iXfOIS6m0KyRHUEMYQT/gd6/aBd5bnaaxtXiXOQsbNFbl/tH/EblykP9dGqz5MrnDF9dcauOQ/wUNdogLLCUrZMLAzs02h22i2GMFnt4MpvEw6UNYxK7gNypJqUSCCgorbO/vgpioTO12TCTRcCOHvp7GYhdqgcF4hGe2dqU0FRlL0fCwv5ZT31FyO+NXHZiMufh9JU2/3kqjWxot8hC5Qhz1XOvosv+EBlaXuAA5NNfu3NF+GptyEfR9BR/VLqZwO8tD2c+M4LYhaIiKJwcr5cnizkw9pW0j00IkUHsBhz+V5GKWYaPB+Y9HqcWJKAqqZ83vA5OKTGx9bDtiXD+YDbLafaRGnd7LqHm2964WFZhA8/AxtLRTXlpRYtbkMsG5CtckEP6Qh38QdO9DFhtMLPj+qYUMuQrq4l995MMM3ost6Tsi2a6YTTdK8HExJVMe38C2tyuHFdjFYFyrbSP/xIPGGm13gbkCmWXRPp8KclFx75f4hag0l2tOQ5lKHeD2pPgFX1C/pjC+W84MuDRtY1bRiMqiliulTHAAAAACRkWiuYyWgh/K0yCmHTDHUFt1ZeuRpkVN1+Pn9T58Tc94Oe90surP0vSvbWsjTIqdZQkoJq/aCIDpn6o6ePifmD69PSP0bh2Fsiu/PGXIWMojjfpx6V7a168beG9GhNJVAMFw7soSUEiMV/LxW7QVBx3xt7zXIpcakWc1ofXs/F+zqV7keXp+Qj8/3Pvo3DsNrpmZtmRKuRAiDxuoy5Cxko3VEylHBjOPAUORNtagdsCQ5dR7Wjb03RxzVmeNFGPFy1HBfgGC4dhHx0NhkCSkl9ZhBiwcsiaKWveEMrNoLgj1LYyzP/6sFXm7DqyuWOla6B1L4SLOa0dki8n/69n4ua2cWgJnT3qkIQrYHfbpP+uwrJ1Qen+99jw6H07VpbV0k+AXz1kzN2kfdpXQyJVyJo7Q0J1EA/A7AkZSgZMhZyPVZMWYH7flPlnyR4eOEaBxyFQCygKHImxEwoDUrV0q7usYiFUhy6jzZ44KSrBt7bz2KE8HPPtvoXq+zRoeNQTkWHCmX5KjhvnU5iRAAwXDtkVAYQ2Pk0GrydbjEyBJSSlmDOuSrN/LNOqaaY09eY57ezwswLHvDGb3qq7cZs2bfiCIOcXqWxljrB672nv9XCw9uP6X92veMbEufIlYsdazHvR0CNQnVK6SYvYXRYER4QPEs1rJF5P8j1IxR9O39XGV8lfKXyF3bBlk1dXOhzIjiMKQmEIRsD4EVBKG7cu4vKuOGgdhXTqhJxiYGPD7f+62vt1VfG398zooX0mrT2rr7QrIUCfZ6PZhnEpPtn+tufA6DwI66S+kfKyNHJUzJybTdoWdGaWlO1/gB4KIA+B0zkZCzwSVYmlC0MDSJlsJLGAeq5eqzYsx7IgpiDtrzn59LmzFt/1MY/G47tsYJ0ThXmLmWpSxxvzS9GRFBReDs0NSIQiJgQGuz8SjFF6jlrYY5jQN0jUUq5RwthJDk1HkBdbzX88F0/mJQHFBYN/beyaaecDsSVlmqgz7333vHCk7qr6S8XmeNLc8PIw4bg3KfiuvcbT4j9fyvS1uJV7KmGMbaCOpyEiF743qPQYSQAdAV+K8ioTCGszBYKMbIodVXWcl7pe0BUjR8afyQJaSUAbTMOvMABBNikWy9F2mVQIb4/e50TDXH5d1dad+6t+dOK99JvJ8XYC0Of85Y9oYzyWfunTvTJrSqQk4ac2C8ZeLx1MsQRRzigdR0TPQsjbFlveUflwktNgaYRZg8/68WrW7HuF/aD5HOS2c/u7Oewioi9mzYlj5FSQdW6+1em4N8z/Mtjns7BB/qU6pqEqpX+4PC+Qk3CtCYpmJ+osGI8DNQ4F7B5Ch3UHVA2SWNuSS0HNGKRqgZo9c5cQ2DJhAAWwAAAF0BAAANAAAAgyYQAFsAAABgAQAADQAAAIMmEABbAAAAbgEAAAkAAACDJhAAWwAAAJgBAAA+AAAAgyYQAFsAAAC0AQAAJAAAAIMmEABbAAAAzAEAAA0AAACDJhAAWwAAAMgBAAANAAAAgyYQAFsAAADJAQAADQAAAIMmEABbAAAAtgEAAA0AAACDJhAAWwAAAP4BAAAcAAAAgyYQAFsAAAAAAgAAGgAAAHNuYXBweTogaW5wdXQgYnVmZmVyIChzaXplID0gKSBpcyBsYXJnZXIgdGhhbiBhbGxvd2VkIChzaXplID0gKQDAiR8AHQAAAN2JHwAhAAAA/okfAAEAAABzbmFwcHk6IG91dHB1dCBidWZmZXIgKHNpemUgPSApIGlzIHNtYWxsZXIgdGhhbiByZXF1aXJlZCAoc2l6ZSA9IAAAABiKHwAeAAAANoofACMAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZW1wdHkpc25hcHB5OiBjb3JydXB0IGlucHV0IChpbnZhbGlkIGhlYWRlcilzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGhlYWRlciBtaXNtYXRjaDsgZXhwZWN0ZWQgIGRlY29tcHJlc3NlZCBieXRlcyBidXQgZ290ILeKHwAxAAAA6IofABwAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZXhwZWN0ZWQgbGl0ZXJhbCByZWFkIG9mIGxlbmd0aCA7IHJlbWFpbmluZyBzcmM6IDsgcmVtYWluaW5nIGRzdDogAAAAHIsfADcAAABTix8AEQAAAGSLHwARAAAA/okfAAEAAABzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGV4cGVjdGVkIGNvcHkgcmVhZCBvZiBsZW5ndGggmIsfADQAAABTix8AEQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChleHBlY3RlZCBjb3B5IHdyaXRlIG9mIGxlbmd0aCAAAADkix8ANQAAAGSLHwARAAAA/okfAAEAAABzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGV4cGVjdGVkIHZhbGlkIG9mZnNldCBidXQgZ290IG9mZnNldCA7IGRzdCBwb3NpdGlvbjogNIwfADwAAABwjB8AEAAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChleHBlY3RlZCBzdHJlYW0gaGVhZGVyIGJ1dCBnb3QgdW5leHBlY3RlZCBjaHVuayB0eXBlIGJ5dGUgAAAAmIwfAFEAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZXhwZWN0ZWQgc05hUHBZIHN0cmVhbSBoZWFkZXIgYnV0IGdvdCAAAAD8jB8APQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0ICh1bnN1cHBvcnRlZCBjaHVuayB0eXBlOiAATI0fAC8AAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAodW5zdXBwb3J0ZWQgY2h1bmsgbGVuZ3RoOiAAAACMjR8AMQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChpbnZhbGlkIHN0cmVhbSBoZWFkZXIgbGVuZ3RoOiAAAADQjR8ANQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChiYWQgY2hlY2tzdW07IGV4cGVjdGVkOiAsIGdvdDogAAAYjh8ALwAAAEeOHwAHAAAA/okfAAEAAACyKxAAWAAAAAcAAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2xpY2UubGVuKCkgPj0gMgAAsisQAFgAAAAiAAAABQAAALIrEABYAAAARAAAAAUAAACyKxAAWAAAAEAAAAAJAAAAviUQAF0AAABcAAAAJQAAAAAAAAD/AAAA//8AAP///wD/////AQAECAEQASACAAUIAhACIAMABggDEAMgBAAHCAQQBCAFAAgIBRAFIAYACQgGEAYgBwAKCAcQByAIAAsICBAIIAkABAkJEAkgCgAFCQoQCiALAAYJCxALIAwABwkMEAwgDQAICQ0QDSAOAAkJDhAOIA8ACgkPEA8gEAALCRAQECARAAQKERARIBIABQoSEBIgEwAGChMQEyAUAAcKFBAUIBUACAoVEBUgFgAJChYQFiAXAAoKFxAXIBgACwoYEBggGQAECxkQGSAaAAULGhAaIBsABgsbEBsgHAAHCxwQHCAdAAgLHRAdIB4ACQseEB4gHwAKCx8QHyAgAAsLIBAgICEABAwhECEgIgAFDCIQIiAjAAYMIxAjICQABwwkECQgJQAIDCUQJSAmAAkMJhAmICcACgwnECcgKAALDCgQKCApAAQNKRApICoABQ0qECogKwAGDSsQKyAsAAcNLBAsIC0ACA0tEC0gLgAJDS4QLiAvAAoNLxAvIDAACw0wEDAgMQAEDjEQMSAyAAUOMhAyIDMABg4zEDMgNAAHDjQQNCA1AAgONRA1IDYACQ42EDYgNwAKDjcQNyA4AAsOOBA4IDkABA85EDkgOgAFDzoQOiA7AAYPOxA7IDwABw88EDwgAAgIDz0QPSAAEAkPPhA+IAAYCg8/ED8gACALD0AQQCC+JRAAXQAAAFEBAAAkAAAAviUQAF0AAABRAQAAEQAAAL4lEABdAAAAwQEAADcAAAA6hhAAcAAAAC4CAAARAAAATm9uZQAAAAAEAAAABAAAAEMFAABTb21lHprAvv5ieL98GMLX7yHyp6sFAAAMAAAABAAAACkAAACrBQAADAAAAAQAAAAqAAAAKQAAAFiRHwAVBQAArAUAAC0AAAAVBQAArQUAAAAAAAAEAAAABAAAAK4FAAAAAAAABAAAAAQAAACvBQAAVXRmOEVycm9ydmFsaWRfdXBfdG9lcnJvcl9sZW4AAADOdRAAagAAAL0BAAAdAAAA+GEQAGAAAABBAAAAHgAAAPhhEABgAAAAXQAAAB4AAABjYW5ub3QgY29udmVydCBzaG91bGQgbm90IGhhdmUgYXR0ZW1wdGVkIHRvIGNvbnZlcnQgIHRvIHU4AAATkh8AJQAAADiSHwAGAAAA5yIQAGYAAACBAgAADgAAACBpbnRvIFRUeXBlAASSHwAPAAAAYJIfAAsAAAAAAAADBwQFBggADAsKCQAAOoYQAHAAAAAuAgAAEQAAAE5vbmUAAAAABAAAAAQAAACxBQAAU29tZc51EABqAAAAvQEAAB0AAABTVE9Qdm9pZGJvb2xpMDhkb3VibGVpMTZpMzJpNjRzdHJpbmdVVEY3c3RydWN0bWFwc2V0bGlzdFVURjhVVEYxNm1pc3NpbmcgZmllbGQgaW4gaW4gAAAABZMfABQAAACyBQAADAAAAAQAAACzBQAAAAAAAAEAAAABAAAAtAUAAAAAAAAEAAAABAAAALUFAABURmllbGRJZGVudGlmaWVybmFtZWZpZWxkX3R5cGVpZFN0b3BWb2lkQm9vbEkwOERvdWJsZUkxNkkzMkk2NFN0cmluZ1V0ZjdTdHJ1Y3RNYXBTZXRMaXN0VXRmOFV0ZjE2AAAABAAAAAQAAAAEAAAAAwAAAAYAAAADAAAAAwAAAAMAAAAGAAAABAAAAAYAAAADAAAAAwAAAAQAAAAEAAAABQAAAHSTHwB4kx8AfJMfAICTHwCDkx8AiZMfAIyTHwCPkx8AkpMfAJiTHwCckx8AopMfAKWTHwCokx8ArJMfALCTHwC2BQAADAAAAAQAAAC3BQAAuAUAALkFAAB8RBAAZQAAAD8AAAAmAAAATm9uZQAAAAAEAAAABAAAANAEAABTb21lugUAAAwAAAAEAAAAuwUAALwFAAC5BQBBmKn+AAvZDgEAAAC9BQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAARXJyb3IAAADiXxAAawAAAM8MAAAOAAAAznUQAGoAAAC9AQAAHQAAAG1lc3NhZ2V0cmFuc3BvcnQgZXJyb3Jub3Qgb3BlbmFscmVhZHkgb3BlbnRpbWVkIG91dGVuZCBvZiBmaWxlbmVnYXRpdmUgc2l6ZSBtZXNzYWdlbWVzc2FnZSB0b28gbG9uZwABAAAAAAAAAHByb3RvY29sIGVycm9yYmFkIGRhdGFuZWdhdGl2ZSBtZXNzYWdlIHNpemVpbnZhbGlkIHRocmlmdCB2ZXJzaW9ubm90IGltcGxlbWVudGVkbWF4aW11bSBza2lwIGRlcHRoIHJlYWNoZWRzZXJ2aWNlIGVycm9ydW5rbm93biBzZXJ2aWNlIG1ldGhvZHdyb25nIG1lc3NhZ2UgdHlwZSByZWNlaXZlZHVua25vd24gbWV0aG9kIHJlcGx5IHJlY2VpdmVkb3V0IG9mIG9yZGVyIHNlcXVlbmNlIGlkbWlzc2luZyBtZXRob2QgcmVzdWx0cmVtb3RlIHNlcnZpY2UgdGhyZXcgZXhjZXB0aW9uaW52YWxpZCB0cmFuc2Zvcm1pbnZhbGlkIHByb3RvY29sIHJlcXVlc3RlZHVuc3VwcG9ydGVkIHByb3RvY29sIGNsaWVudAAAAAAAAAEAAAABAAAAvgUAAAAAAAAEAAAABAAAALEFAABUcmFuc3BvcnRFcnJvcmtpbmRVbmtub3duTm90T3BlbkFscmVhZHlPcGVuVGltZWRPdXRFbmRPZkZpbGVOZWdhdGl2ZVNpemVTaXplTGltaXQAAAAAAAAAAQAAAAEAAAC/BQAAUHJvdG9jb2xFcnJvckludmFsaWREYXRhQmFkVmVyc2lvbk5vdEltcGxlbWVudGVkRGVwdGhMaW1pdAAAAAAAAAEAAAABAAAAwAUAAEFwcGxpY2F0aW9uRXJyb3JVbmtub3duTWV0aG9kSW52YWxpZE1lc3NhZ2VUeXBlV3JvbmdNZXRob2ROYW1lQmFkU2VxdWVuY2VJZE1pc3NpbmdSZXN1bHRJbnRlcm5hbEVycm9ySW52YWxpZFRyYW5zZm9ybUludmFsaWRQcm90b2NvbFVuc3VwcG9ydGVkQ2xpZW50VHlwZQAAABeVHwAmlR8ALpUfADqVHwBDlR8ATpUfAGOVHwAPAAAACAAAAAwAAAAJAAAACwAAABUAAAAQAAAAfJUfAIqVHwCSlR8AY5UfAKeVHwC9lR8AzJUfAA4AAAAIAAAAFQAAABAAAAAWAAAADwAAABoAAADmlR8A85UfAAmWHwAklh8AQZYfAFmWHwBulh8AfJUfAIyWHwCdlh8At5YfAA0AAAAWAAAAGwAAAB0AAAAYAAAAFQAAAB4AAAAOAAAAEQAAABoAAAAbAAAABwAAAAcAAAALAAAACAAAAAkAAAAMAAAACQAAAAaXHwANlx8AFJcfAB+XHwAnlx8AMJcfADyXHwAHAAAACwAAAAwAAAAJAAAACgAAAA4AAAAKAAAABpcfAGWXHwAwlx8APJcfAHCXHwB6lx8AiJcfAAcAAAANAAAAEgAAAA8AAAANAAAADQAAAA0AAAANAAAAEAAAAA8AAAAVAAAABpcfALSXHwDBlx8A05cfAOKXHwDvlx8A/JcfAFiXHwAJmB8AGZgfACiYHwAemsC+/mJ4v3wYwtfvIfKnwQUAAAwAAAAEAAAAKQAAAMEFAAAMAAAABAAAACoAAAApAAAA4JkfAMIFAADDBQAALQAAAMIFAADEBQAAznUQAGoAAAC9AQAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IGRzdC5sZW4oKSA+PSBzZWxmLnJlcXVpcmVkX3NwYWNlKClkHRAAZQAAAJ4AAAAJAAAAZB0QAGUAAACoAAAACQAAAGQdEABlAAAAowAAAA0AAABkHRAAZQAAAL0AAAAJAAAAZB0QAGUAAADHAAAACQAAAGQdEABlAAAAwgAAAA0AAAB8RBAAZQAAADcAAAAJAAAAVW50ZXJtaW5hdGVkIHZhcmludAB8RBAAZQAAADwAAAAYAAAAnEYQAGkAAACjAAAAEwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVuKCkAAJIxEABiAAAAXgAAAAkAAABoQhAAYwAAACUCAAAZAAAAaEIQAGMAAACoAQAAJgAAAGNhbm5vdCBncm93IGJ1ZmZlciBiZXlvbmQgMiBnaWdhYnl0ZXMAAABoQhAAYwAAAPgCAAAJAAAAaEIQAGMAAADnAgAAFwAAAGhCEABjAAAA5wIAADEAAABoQhAAYwAAAPgAAAAtAAAAaEIQAGMAAAD4AAAASAAAANcyEAB4AAAA6wcAAAkAAABtaWQgPiBsZW4AAADgmx8ACQBB/Lf+AAt3AQAAAMwFAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAEQBAABUcnlGcm9tSW50RXJyb3IAzQUAAM51EABqAAAAvQEAAB0AAAAAAAAA//////////9onB8AQYC5/gALyw9LKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAADscEABgAAAAxgAAACAAAABub3QgaW1wbGVtZW50ZWQ6IEJpZyBFbmRpYW4gaXMgbm90IHN1cHBvcnRlZCBmb3IgRGVjaW1hbCEAAACwnB8AOQAAADscEABgAAAAzAAAABEAAAA7HBAAYAAAANAAAAAQAAAAOxwQAGAAAAArAQAALgAAAFVuZXhwZWN0ZWQgYml0d2lkdGggYW5kIHNpZ25lZAAAJJ0fAB4AAAA7HBAAYAAAADUBAAAWAAAAOxwQAGAAAABCAQAAKwAAAEludCB0eXBlIHdpdGggYml0IHdpZHRoIG9mICBhbmQgc2lnbmVkIG9mICBub3Qgc3VwcG9ydGVkbJ0fABsAAACHnR8ADwAAAJadHwAOAAAAOxwQAGAAAABMAQAAFgAAADscEABgAAAAWQEAADkAAAA7HBAAYAAAAF0BAAA4AAAARmxvYXRpbmdQb2ludCB0eXBlIHdpdGggcHJlY2lzaW9uIG9mIAAAAOydHwAlAAAAlp0fAA4AAAA7HBAAYAAAAGIBAAAWAAAAOxwQAGAAAABmAQAALQAAAERhdGUgdHlwZSB3aXRoIHVuaXQgb2YgAESeHwAXAAAAlp0fAA4AAAA7HBAAYAAAAGoBAAAWAAAAOxwQAGAAAABuAQAALQAAAFRpbWUgdHlwZSB3aXRoIGJpdCB3aWR0aCBvZiAgYW5kIHVuaXQgb2YgAAAAjJ4fABwAAAConh8ADQAAAJadHwAOAAAAOxwQAGAAAAB0AQAAFgAAADscEABgAAAAewEAADcAAABUaW1lc3RhbXAgdHlwZSB3aXRoIHVuaXQgb2Yg8J4fABwAAACWnR8ADgAAADscEABgAAAAhgEAABYAAAA7HBAAYAAAAIoBAAA1AAAASW50ZXJ2YWwgdHlwZSB3aXRoIHVuaXQgb2YgIHVuc3VwcG9ydGVkADyfHwAbAAAAV58fAAwAAAA7HBAAYAAAAJEBAAAWAAAAOxwQAGAAAACVAQAANQAAAER1cmF0aW9uIHR5cGUgd2l0aCB1bml0IG9mIACUnx8AGwAAAFefHwAMAAAAOxwQAGAAAACbAQAAFgAAADscEABgAAAAnwEAAC0AAABleHBlY3QgYSBsaXN0IHRvIGhhdmUgb25lIGNoaWxkAOCfHwAfAAAAOxwQAGAAAAChAQAAEQAAADscEABgAAAApgEAAC0AAABleHBlY3QgYSBsYXJnZSBsaXN0IHRvIGhhdmUgb25lIGNoaWxkAAAAKKAfACUAAAA7HBAAYAAAAKgBAAARAAAAOxwQAGAAAACtAQAALQAAADscEABgAAAAsQEAADcAAAA7HBAAYAAAAK8BAAARAAAAOxwQAGAAAAC8AQAALQAAAFJ1bkVuZEVuY29kZWQgdHlwZSBzaG91bGQgaGF2ZSBleGFjdGx5IHR3byBjaGlsZHJlbi4gRm91bmQgAKigHwA7AAAAOxwQAGAAAAC+AQAAEQAAADscEABgAAAAyAEAACsAAAA7HBAAYAAAAMkBAAAtAAAAZXhwZWN0IGEgbWFwIHRvIGhhdmUgb25lIGNoaWxkAAAcoR8AHgAAADscEABgAAAAywEAABEAAAA7HBAAYAAAANABAAAvAAAAOxwQAGAAAADSAQAAPAAAADscEABgAAAA0wEAADQAAABVbmV4cGVjdGVkIGRlY2ltYWwgYml0IHdpZHRoIAAAAIShHwAdAAAAOxwQAGAAAADZAQAAFgAAADscEABgAAAA3QEAAC8AAAA7HBAAYAAAAOgBAAAcAAAAVW5leHBlY3RlZCB1bmlvbiBtb2RlOiAA3KEfABcAAAA7HBAAYAAAAOIBAAAZAAAAbm90IGltcGxlbWVudGVkOiBUeXBlIAAADKIfABYAAACWnR8ADgAAADscEABgAAAA8wEAAA4AAABJUEMgbXVzdCBubyBsb25nZXIgYmUgdXNlZCB3aXRob3V0IGRpY3Rpb25hcnkgdHJhY2tlcgAAAESiHwA1AAAAOxwQAGAAAAAWAgAAFQAAAG5vdCBpbXBsZW1lbnRlZDogTGlzdFZpZXcvTGFyZ2VMaXN0VmlldyBub3QgaW1wbGVtZW50ZWQAlKIfADcAAAA7HBAAYAAAAAMDAAArAAAAOxwQAGAAAAAaAwAAGgAAADscEABgAAAAbQMAABoAAAAIAAAAEAAAACAAAABAAAAACAAAABAAAAAgAAAAQAAAAAgAAAAQAAAAIAAAAEAAAAAgAAAAIAAAAEAAAABAAAAAaEIQAGMAAAAlAgAAGQAAAGhCEABjAAAAqAEAACYAAABoQhAAYwAAAOABAAAYAAAAY2Fubm90IGdyb3cgYnVmZmVyIGJleW9uZCAyIGdpZ2FieXRlcwAAAGhCEABjAAAA+AIAAAkAAABoQhAAYwAAAPgAAAAtAAAAaEIQAGMAAAD4AAAASAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADOBQAA//////////9ApB8AQdjI/gALIdcyEAB4AAAA6wcAAAkAAABtaWQgPiBsZW4AAABopB8ACQBBhMn+AAv1AwEAAADPBQAA+5UQAF4AAADMAAAAEQAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADQBQAACAAAAAQAAAByAgAAcwIAAHQCAADRBQAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIGZpeGVkIHNpemUgbGlzdCBhcnJheQB1NxAAXwAAACcBAAAWAAAAdTcQAF8AAAA1AQAASAAAAHU3EABfAAAANQEAAFQAAABJbmNvcnJlY3QgZmllbGQgZGF0YSB0eXBlIAAAbKUfABoAAAB1NxAAXwAAADYBAAAaAAAAdTcQAF8AAAADAQAALwAAAFRoZSBydW4gZW5jb2RlZCBhcnJheSBzaG91bGQgaGF2ZSBleGFjdGx5IHR3byBjaGlsZCBhcnJheXMuIEZvdW5kIAAAsKUfAEIAAAB1NxAAXwAAAG0BAAAkAAAAdTcQAF8AAABvAQAAKQAAAHU3EABfAAAAhwEAAC4AAAB1NxAAXwAAAI8BAAAuAAAAbm8gZGljdCBpZCBmb3IgZmllbGQgAAAAPKYfABUAAAB1NxAAXwAAAK4BAAAoAAAAdTcQAF8AAACwAQAANwBBvM3+AAv3KHU3EABfAAAA8gEAAC4AAAB1NxAAXwAAAPIBAAAUAAAAdTcQAF8AAABLAgAALgAAAHU3EABfAAAASwIAABQAAAB1NxAAXwAAAIQCAAAUAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogVW5leHBlY3RlZCBkYXRhIHR5cGUgAAynHwA/AAAAdTcQAF8AAACeAgAAEgAAAFRoZSBnaXZlbiBhcnJheSBpcyBub3QgYSBydW4gYXJyYXkuIERhdGEgdHlwZSBvZiBnaXZlbiBhcnJheTogAABkpx8APgAAAHU3EABfAAAAuwIAACwAAAB1NxAAXwAAAL4CAAA7AAAAdTcQAF8AAAAfAwAAFwAAAERpY3Rpb25hcnkgcmVwbGFjZW1lbnQgZGV0ZWN0ZWQgd2hlbiB3cml0aW5nIElQQyBmaWxlIGZvcm1hdC4gQXJyb3cgSVBDIGZpbGVzIG9ubHkgc3VwcG9ydCBhIHNpbmdsZSBkaWN0aW9uYXJ5IGZvciBhIGdpdmVuIGZpZWxkIGFjcm9zcyBhbGwgYmF0Y2hlcy51NxAAXwAAAGYDAAAbAAAAdTcQAF8AAABwAwAAGwAAAHU3EABfAAAASgYAACYAAAB1NxAAXwAAAEwGAAAtAAAAdTcQAF8AAABNBgAAKgAAAHU3EABfAAAAZwYAAEgAAAB1NxAAXwAAAGgGAAASAAAAdTcQAF8AAAB2BgAASAAAAHU3EABfAAAAdwYAABYAAAB1NxAAXwAAAHIGAAANAAAAdTcQAF8AAACOBgAADwAAAHU3EABfAAAAigYAAA8AAAABAAAAdTcQAF8AAAD1BgAAFwAAAHU3EABfAAAA8wYAAAkAAAB1NxAAXwAAACcHAAAaAAAAdTcQAF8AAAAiBwAACQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGV1NxAAXwAAAAsHAAASAAAAdTcQAF8AAAAEBwAACQAAAHU3EABfAAAAAwcAAAkAAAB1NxAAXwAAANsGAAAXAAAAdTcQAF8AAADdBgAAIwAAAHU3EABfAAAA5AYAAB8AAAB1NxAAXwAAANkGAAAJAAAAdTcQAF8AAACDBwAAGAAAAHU3EABfAAAAjQcAAA0AAAB1NxAAXwAAAJAHAAAqAAAAdTcQAF8AAACQBwAAEAAAAJxGEABpAAAAowAAABMAAADnTFBqiLKas2VJ+LFNtFzSvpwqkZE2NGDFSEAXEQ6bNNcyEAB4AAAA6wcAAAkAAADOdRAAagAAAKcBAAAfAAAAznUQAGoAAAC9AQAAHQAAANMFAAAwAAAABAAAANQFAADVBQAANAAAAAQAAADWBQAASysQAGYAAACyAAAAGQAAAEsrEABmAAAA5QAAABkAAABGaWVsZCAgb2YgTnVsbEFycmF5IGhhcyB1bmVxdWFsIG51bGxfY291bnQgIGFuZCBsZW4g7KofAAYAAADyqh8AJQAAABerHwAJAAAATWlzc2luZyB2YXJpYWRpYyBjb3VudCBmb3IgIGNvbHVtbgAAOKsfABsAAABTqx8ABwAAAOJEEABfAAAAjQAAACMAAADiRBAAXwAAAM0AAAAkAAAA0wUAADAAAAAEAAAA1wUAANgFAADZBQAA2gUAANsFAADcBQAA3QUAAN4FAADfBQAA4AUAAOEFAADiBQAA4wUAAOQFAADlBQAA5gUAAOcFAADoBQAA6QUAAOJEEABfAAAA0QAAAB4AAAAgZG9lcyBub3QgaGF2ZSBkaWN0IGlkAADsqh8ABgAAAPSrHwAWAAAAQ2Fubm90IGZpbmQgYSBkaWN0aW9uYXJ5IGJhdGNoIHdpdGggZGljdCBpZDogAAAAHKwfAC0AAADiRBAAXwAAAP8AAABDAAAA4kQQAF8AAAAFAQAAJQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IERhdGEgdHlwZSAgZWl0aGVyIHVuc3VwcG9ydGVkIG9yIG5vdCBwcmltaXRpdmV0rB8ANAAAAKisHwAkAAAA4kQQAF8AAAATAQAAEgAAAOJEEABfAAAAEAEAACEAAADiRBAAXwAAADQBAAAdAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogQ2Fubm90IGNyZWF0ZSBsaXN0IG9yIG1hcCBhcnJheSBmcm9tIAAMrR8ATwAAAOJEEABfAAAAPQEAABIAAABudWxsX2NvdW50IHZhbHVlICgpIGRvZXNuJ3QgbWF0Y2ggYWN0dWFsIG51bWJlciBvZiBudWxscyBpbiBhcnJheSAoKXStHwASAAAAhq0fADEAAAC3rR8AAQAAANUFAAA0AAAABAAAAIcBAADqBQAAiQEAAOsFAADsBQAAjAEAAO0FAADuBQAAjwEAAOAFAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBDYW5ub3QgY3JlYXRlIGRpY3Rpb25hcnkgYXJyYXkgZnJvbSAAACiuHwBOAAAA4kQQAF8AAACKAQAADQAAAFVuYWJsZSB0byBnZXQgYnVmZmVycyBmcm9tIElQQyBSZWNvcmRCYXRjaFVuYWJsZSB0byBnZXQgZmllbGQgbm9kZXMgZnJvbSBJUEMgUmVjb3JkQmF0Y2hhc3NlcnRpb24gZmFpbGVkOiB2YXJpYWRpY19jb3VudHMuaXNfZW1wdHkoKeJEEABfAAAAIAIAABEAAADiRBAAXwAAAAsCAAAcAAAA4kQQAF8AAAA1AgAAEQAAAOJEEABfAAAAKAIAABoAAADiRBAAXwAAADwCAAApAAAA4kQQAF8AAABAAgAAHQAAAEludmFsaWQgZGF0YSBmb3Igc2NoZW1hLiAgcmVmZXJzIHRvIG5vZGUgbm90IGZvdW5kIGluIHNjaGVtYXSvHwAZAAAAja8fACMAAADvBQAACAAAAAQAAAByAgAAcwIAAHQCAADwBQAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAATm8gZXhpc3RpbmcgZGljdGlvbmFyeSBmb3IgZGVsdGEgZGljdGlvbmFyeSB3aXRoIGlkICcnAAAYsB8ANQAAAE2wHwABAAAARmFpbGVkIHRvIGNvbmNhdCBkZWx0YSBkaWN0aW9uYXJ5OiAAYLAfACMAAADiRBAAXwAAACADAAAeAAAAZGljdGlvbmFyeSBpZCAgbm90IGZvdW5kIGluIHNjaGVtYQAAnLAfAA4AAACqsB8AFAAAAJxGEABpAAAAowAAABMAAABSOhAAZAAAANkAAAAbAAAAUjoQAGQAAABRAQAADQAAAFI6EABkAAAAUgEAAA0AAABSOhAAZAAAAFMBAAANAAAAUjoQAGQAAABUAQAADQAAAFI6EABkAAAAWwEAAA0AAABSOhAAZAAAAFwBAAANAAAAUjoQAGQAAABdAQAADQAAAFI6EABkAAAAXgEAAA0AAABSOhAAZAAAAEsBAAAyAAAAYXJyb3dfaXBjOjpnZW46OlNjaGVtYTo6RmVhdHVyZWZsYXRidWZmZXJzOjpwcmltaXRpdmVzOjpGb3J3YXJkc1VPZmZzZXQ8YXJyb3dfaXBjOjpnZW46OlNjaGVtYTo6RmllbGQ+ZmxhdGJ1ZmZlcnM6OnByaW1pdGl2ZXM6OkZvcndhcmRzVU9mZnNldDxhcnJvd19pcGM6Omdlbjo6U2NoZW1hOjpLZXlWYWx1ZT5pNjR1MTZ1MzJpMTZpMzJmbGF0YnVmZmVyczo6cHJpbWl0aXZlczo6Rm9yd2FyZHNVT2Zmc2V0PGFycm93X2lwYzo6Z2VuOjpUZW5zb3I6OlRlbnNvckRpbT4AAFI6EABkAAAATgIAAC8AAAAAAAAABAAAAAQAAADxBQAARXJyb3JUcmFjZQAAAAAAAAQAAAAEAAAA8gUAAAAAAAAEAAAABAAAADEAAABWZWN0b3JFbGVtZW50aW5kZXhwb3NpdGlvbgAA8wUAAAwAAAAEAAAAoQEAAFRhYmxlRmllbGRmaWVsZF9uYW1lVW5pb25WYXJpYW50dmFyaWFudGNvZGVjbWV0aG9kbGVuZ3Robm9kZXNidWZmZXJzY29tcHJlc3Npb252YXJpYWRpY0J1ZmZlckNvdW50c2lkZGF0YWlzRGVsdGFsaXN0U2l6ZWtleXNTb3J0ZWRtb2RldHlwZUlkc2JpdFdpZHRoaXNfc2lnbmVkcHJlY2lzaW9uYnl0ZVdpZHRoc2NhbGV1bml0dGltZXpvbmVrZXl2YWx1ZWluZGV4VHlwZWlzT3JkZXJlZGRpY3Rpb25hcnlLaW5kbmFtZW51bGxhYmxldHlwZV90eXBldHlwZV9kaWN0aW9uYXJ5Y2hpbGRyZW5jdXN0b21fbWV0YWRhdGFUeXBlOjpOdWxsVHlwZTo6SW50VHlwZTo6RmxvYXRpbmdQb2ludFR5cGU6OkJpbmFyeVR5cGU6OlV0ZjhUeXBlOjpCb29sVHlwZTo6RGVjaW1hbFR5cGU6OkRhdGVUeXBlOjpUaW1lVHlwZTo6VGltZXN0YW1wVHlwZTo6SW50ZXJ2YWxUeXBlOjpMaXN0VHlwZTo6U3RydWN0X1R5cGU6OlVuaW9uVHlwZTo6Rml4ZWRTaXplQmluYXJ5VHlwZTo6Rml4ZWRTaXplTGlzdFR5cGU6Ok1hcFR5cGU6OkR1cmF0aW9uVHlwZTo6TGFyZ2VCaW5hcnlUeXBlOjpMYXJnZVV0ZjhUeXBlOjpMYXJnZUxpc3RUeXBlOjpSdW5FbmRFbmNvZGVkVHlwZTo6QmluYXJ5Vmlld1R5cGU6OlV0ZjhWaWV3VHlwZTo6TGlzdFZpZXdUeXBlOjpMYXJnZUxpc3RWaWV3ZW5kaWFubmVzc2ZpZWxkc2ZlYXR1cmVzaW5kaWNlc1R5cGVpbmRpY2VzU3RyaWRlc2luZGljZXNCdWZmZXJpc0Nhbm9uaWNhbGNvbXByZXNzZWRBeGlzaW5kcHRyVHlwZWluZHB0ckJ1ZmZlcmluZHB0ckJ1ZmZlcnNpbmRpY2VzQnVmZmVyc2F4aXNPcmRlcnNoYXBlbm9uX3plcm9fbGVuZ3Roc3BhcnNlSW5kZXhfdHlwZXNwYXJzZUluZGV4U3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZVRlbnNvckluZGV4Q09PU3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZU1hdHJpeEluZGV4Q1NYU3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZVRlbnNvckluZGV4Q1NGc2l6ZV9zdHJpZGVzAJxGEABpAAAAowAAABMAAABkdXBsaWNhdGUgdHlwZSBpZDogAOC2HwATAAAAUS8QAGIAAABwAQAAFQAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAF8DAAAJAAAAznUQAGoAAAC9AQAAHQAAAEsrEABmAAAAsgAAABkAAABWMVYyVjNWNFY1PFVOS05PV04gPla3HwAJAAAAX7cfAAEAAABTcGFyc2VEZW5zZUhBTEZTSU5HTEVET1VCTEVEQVlNSUxMSVNFQ09ORFNFQ09ORE1JQ1JPU0VDT05ETkFOT1NFQ09ORFlFQVJfTU9OVEhEQVlfVElNRU1PTlRIX0RBWV9OQU5PTk9ORU51bGxJbnRGbG9hdGluZ1BvaW50QmluYXJ5VXRmOEJvb2xEZWNpbWFsRGF0ZVRpbWVUaW1lc3RhbXBJbnRlcnZhbExpc3RTdHJ1Y3RfVW5pb25GaXhlZFNpemVCaW5hcnlGaXhlZFNpemVMaXN0TWFwRHVyYXRpb25MYXJnZUJpbmFyeUxhcmdlVXRmOExhcmdlTGlzdFJ1bkVuZEVuY29kZWRCaW5hcnlWaWV3VXRmOFZpZXdMaXN0Vmlld0xhcmdlTGlzdFZpZXcAAEy3HwBOtx8AULcfAFK3HwBUtx8ABAAAAAYAAAAGAAAAe7cfAH+3HwCFtx8ABgAAAAsAAAALAAAACgAAAJm3HwCOtx8An7cfAKq3HwAKAAAACAAAAA4AAAC0tx8AvrcfAMa3HwAEAAAABAAAAAMAAAANAAAABgAAAAQAAAAEAAAABwAAAAQAAAAEAAAACQAAAAgAAAAEAAAABwAAAAUAAAAPAAAADQAAAAMAAAAIAAAACwAAAAkAAAAJAAAADQAAAAoAAAAIAAAACAAAAA0AAADUtx8A2LcfANy3HwDftx8A7LcfAPK3HwD2tx8A+rcfAAG4HwAFuB8ACbgfABK4HwAauB8AHrgfACW4HwAquB8AObgfAEa4HwBJuB8AUbgfAFy4HwBluB8AbrgfAHu4HwCFuB8AjbgfAJW4HwBtaWQgPiBsZW4AAADguR8ACQAAAEwaEAB/AAAASgAAAB8AAABMGhAAfwAAAEQAAAAXAAAAAAAAAAQAAAAEAAAA9wUAAAAAAAAEAAAABAAAAPgFAAD5BQAA+QUAAAAAAAAEAAAABAAAAPoFAAD7BQAA+wUAAFyCEAB+AAAAsgUAACQAAAChOBAAbgAAACMIAAARAAAAnEYQAGkAAACjAAAAEwAAAFI6EABkAAAAUQEAAA0AAABSOhAAZAAAAFIBAAANAAAAUjoQAGQAAABTAQAADQAAAFI6EABkAAAAVAEAAA0AAABSOhAAZAAAAFsBAAANAAAAUjoQAGQAAABcAQAADQAAAFI6EABkAAAAXQEAAA0AAABSOhAAZAAAAF4BAAANAAAAUjoQAGQAAABLAQAAMgAAANcyEAB4AAAA6wcAAAkAAAD8BQAA//////////8oux8AQcD2/gALjQhpNjR1MTZ1MzJpMTZpMzIAUjoQAGQAAABOAgAALwAAAM51EABqAAAAvQEAAB0AAABLKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAADscEABgAAAAqAAAAB4AAAA7HBAAYAAAALAAAAAeAAAAdmVyc2lvbmhlYWRlcl90eXBlaGVhZGVyYm9keUxlbmd0aGN1c3RvbV9tZXRhZGF0YU1lc3NhZ2VIZWFkZXI6OlNjaGVtYU1lc3NhZ2VIZWFkZXI6OkRpY3Rpb25hcnlCYXRjaE1lc3NhZ2VIZWFkZXI6OlJlY29yZEJhdGNoTWVzc2FnZUhlYWRlcjo6VGVuc29yTWVzc2FnZUhlYWRlcjo6U3BhcnNlVGVuc29ya2V5dmFsdWUAAM51EABqAAAAvQEAAB0AAABjb21wcmVzc2lvbiB0eXBlICBub3Qgc3VwcG9ydGVkIHi8HwARAAAAibwfAA8AAABNTRAAZAAAAEUAAAAUAAAATU0QAGQAAABpAAAAJAAAAEludmFsaWQgdW5jb21wcmVzc2VkIGxlbmd0aDogAAAAyLwfAB0AAABsejQgSVBDIGNvbXByZXNzaW9uIHJlcXVpcmVzIHRoZSBsejQgZmVhdHVyZWx6NCBJUEMgZGVjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgbHo0IGZlYXR1cmV6c3RkIElQQyBjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgenN0ZCBmZWF0dXJlenN0ZCBJUEMgZGVjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgenN0ZCBmZWF0dXJlTU0QAGQAAADZAAAAHQAAAEhtEABsAAAASwIAABMAAABVbmFibGUgdG8gZG93bmNhc3QgdG8gbGlzdCBhcnJheToZEABfAAAApwIAAAoAAAB3NRAAaQAAAEYAAAAgAAAAdzUQAGkAAAA3AAAAIAAAAHc1EABpAAAAKwAAACAAAABoQhAAYwAAAGkCAAA8AAAAaEIQAGMAAABzAgAAKwAAAGhCEABjAAAAfgIAADcAAABoQhAAYwAAAIACAAArAAAAaEIQAGMAAACFAgAALAAAAGhCEABjAAAAlAIAACYAAABjYW5ub3QgZ3JvdyBidWZmZXIgYmV5b25kIDIgZ2lnYWJ5dGVzAAAAaEIQAGMAAAD4AgAACQAAAGhCEABjAAAA5wIAABcAAABoQhAAYwAAAOcCAAAxAAAAaEIQAGMAAAD4AAAALQAAAGhCEABjAAAA+AAAAEgAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABtaWQgPiBsZW4AAAA8vx8ACQBB2P7+AAuVBAEAAAD+BQAATGF5b3V0RXJyb3IAkjEQAGIAAACRAAAAEwAAAExaNF9GUkFNRVpTVEQ8VU5LTk9XTiA+AIm/HwAJAAAAkr8fAAEAAABOT05FU2NoZW1hRGljdGlvbmFyeUJhdGNoUmVjb3JkQmF0Y2hUZW5zb3JTcGFyc2VUZW5zb3IAAAQAAAAGAAAADwAAAAsAAAAGAAAADAAAAKS/HwCovx8Arr8fAL2/HwDIvx8Azr8fANcyEAB4AAAA6wcAAAkAAABoQhAAYwAAACUCAAAZAAAAY2Fubm90IGdyb3cgYnVmZmVyIGJleW9uZCAyIGdpZ2FieXRlcwAAAGhCEABjAAAA+AIAAAkAAABoQhAAYwAAAOcCAAAXAAAAaEIQAGMAAADnAgAAMQAAAGhCEABjAAAA+AAAAC0AAABoQhAAYwAAAPgAAABIAAAAbWlkID4gbGVuAAAApMAfAAkAAAA7HBAAYAAAAI0AAAAlAAAAdTE2bWlkID4gbGVuy8AfAAkAAAA6hhAAcAAAAC4CAAARAAAAaEIQAGMAAABkAAAAMQAAAGhCEABjAAAAZQAAABMAAABoQhAAYwAAAKEAAAAYAAAAnEYQAGkAAACjAAAAEwAAAJIxEABiAAAAnAAAABkAAABSOhAAZAAAAEsBAAAgAAAAUjoQAGQAAABLAQAAMgAAAOVsEABiAAAAXAAAABIAAAAFAEH4gv8ACwEPAEGEg/8ACwENAEGQg/8ACwISAgBBnIP/AAsCEQIAQaiD/wALAhIBAEG0g/8ACwEEAEHAg/8ACwESAEHMg/8ACwIQAQBB2IP/AAsCEQMAQeSD/wALARAAQfCD/wALARMAQfyD/wALAhIDAEGIhP8ACwEOAEGUhP8ACwINAgBBoIT/AAsCDQEAQayE/wALAg0DAEG4hP8AC7ELaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogRGVjaW1hbDY0QXJyYXkgZGF0YXR5cGUgaXMgbm90IERhdGFUeXBlOjpEZWNpbWFsNjQgYnV0IAAAADjCHwBhAAAAKAsQAHAAAACYBgAAFQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IERlY2ltYWwxMjhBcnJheSBkYXRhdHlwZSBpcyBub3QgRGF0YVR5cGU6OkRlY2ltYWwxMjggYnV0IAC0wh8AYwAAACgLEABwAAAAogYAABUAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBEZWNpbWFsMzJBcnJheSBkYXRhdHlwZSBpcyBub3QgRGF0YVR5cGU6OkRlY2ltYWwzMiBidXQgAAAAMMMfAGEAAAAoCxAAcAAAAI4GAAAVAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogRGVjaW1hbDI1NkFycmF5IGRhdGF0eXBlIGlzIG5vdCBEYXRhVHlwZTo6RGVjaW1hbDI1NiBidXQgAKzDHwBjAAAAKAsQAHAAAACsBgAAFQAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAACjEHwAlAAAATcQfACEAAAAoCxAAcAAAAOcCAAAJAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZSgLEABwAAAACQYAABIAAAAoCxAAcAAAAF8GAAAVAAAAKAsQAHAAAABzBgAAFQAAACgLEABwAAAAfQYAABUAAAAoCxAAcAAAAGkGAAAVAAAAYE5haXZlRGF0ZVRpbWUgLSBGaXhlZE9mZnNldGAgb3V0IG9mIHJhbmdlAAAShBAAaAAAAGcHAAAmAAAA9TEQAG0AAAA/AQAAJQAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAAEkAAAAFAAAAYXR0ZW1wdCB0byBkaXZpZGUgYnkgemVybwAAAJjFHwAZAAAA+HgQAGYAAADoAQAALwAAAPh4EABmAAAA+AEAAC8AAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAADAwMDEwMjAzMDQwNTA2MDcwODA5MTAxMTEyMTMxNDE1MTYxNzE4MTkyMDIxMjIyMzI0MjUyNjI3MjgyOTMwMzEzMjMzMzQzNTM2MzczODM5NDA0MTQyNDM0NDQ1NDY0NzQ4NDk1MDUxNTI1MzU0NTU1NjU3NTg1OTYwNjE2MjYzNjQ2NTY2Njc2ODY5NzA3MTcyNzM3NDc1NzY3Nzc4Nzk4MDgxODI4Mzg0ODU4Njg3ODg4OTkwOTE5MjkzOTQ5NTk2OTc5ODk5YXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBNaWxsaXNlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcE1pY3Jvc2Vjb25kVHlwZWFycm93X2FycmF5Ojp0eXBlczo6VGltZXN0YW1wTmFub3NlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcFNlY29uZFR5cGUAAIZ/EABrAAAAJwEAAAUAAACGfxAAawAAAD8BAAAFAAAAhn8QAGsAAABXAQAABQAAANcyEAB4AAAA6wcAAAkAQfSP/wALrQYBAAAAFgYAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgLyAAAAD8xx8AFgAAABLIHwADAAAAICogAPzHHwAWAAAAKMgfAAMAAABMYXlvdXRFcnJvckxvY2FsIHRpbWUgb3V0IG9mIHJhbmdlIGZvciBgTmFpdmVEYXRlVGltZWAAAHuEEABiAAAAQwIAAA4AAADOdRAAagAAAL0BAAAdAAAARGVjaW1hbDEyOAAAlMgfAAoAAABDYW5ub3QgY2FzdCB0byAoLCApLiBPdmVyZmxvd2luZyBvbiCoyB8ADwAAALfIHwABAAAAuMgfAAIAAAC6yB8AEgAAAERlY2ltYWwzMgAAAOzIHwAJAAAARGVjaW1hbDI1NgAAAMkfAAoAAABEZWNpbWFsNjQAAAAUyR8ACQAAAENhbm5vdCBjb252ZXJ0ICAgdG8gZGF0ZXRpbWUoyR8ADwAAADfJHwABAAAAOMkfAAwAAABDYW4ndCBjYXN0IHZhbHVlICB0byB0eXBlIAAAXMkfABEAAABtyR8ACQAAAENhbm5vdCBjYXN0IHRpbWV6b25lIHRvIGRpZmZlcmVudCB0aW1lem9uZQAAAQAAAAAAAAAgeWVhcnMgIG1vbnMBAAAAAAAAALzJHwAHAAAAw8kfAAUAAAAgZGF5cwAAAAEAAAAAAAAAAQAAAAAAAADgyR8ABQAAAAEAAAAAAAAAAQAAAAAAAADDyR8ABQAAAF4OEABhAAAA7AEAAAEAAABeDhAAYQAAACECAAABAAAARmFpbGVkIHRvIGNvbnZlcnQgIHRvIGRhdGV0aW1lIGZvciAAOMofABIAAABKyh8AEQAAACB0byB0ZW1wb3JhbCBmb3IgAAAAOMofABIAAABsyh8AEQAAADxpbnZhbGlkPgAAAJDKHwAJAAAAIGRheXMgIGhvdXJzICBtaW5zICBzZWNzAQAAAAAAAACkyh8ABgAAAKrKHwAHAAAAscofAAYAAAC3yh8ABQAAAC4AAAABAAAAAAAAAKTKHwAGAAAAqsofAAcAAACxyh8ABgAAAOTKHwABAAAAt8ofAAUAAAACAAAAAAAAAAIAQayW/wALTSAAAOACAAAAAAAAAAIAAAAAAAAAAQAAACAAAOACAAAAAAAAAAIAAAAAAAAAAgAAACAAAOACAAAAAAAAAAIAAAAAAAAAAwAAACAAAOACAEGCl/8AC08DAAAAAAAEAAAAIAAA6SBtaW5zIC0AAQAAAAAAAACkyh8ABgAAAKrKHwAHAAAAkMsfAAcAAADkyh8AAQAAALfKHwAFAAAAAgAAAAAAAAACAEHcl/8AC00gAADgAgAAAAAAAAACAAAAAAAAAAEAAAAgAADgAgAAAAAAAAACAAAAAAAAAAIAAAAgAADgAgAAAAAAAAACAAAAAAAAAAMAAAAgAADgAgBBspj/AAsXBgAAAAAABAAAACAAAOkCAAAAAAAAAAIAQdSY/wALTSAAAOACAAAAAAAAAAIAAAAAAAAAAQAAACAAAOACAAAAAAAAAAIAAAAAAAAAAgAAACAAAOACAAAAAAAAAAIAAAAAAAAAAwAAACAAAOACAEGqmf8AC6sXCQAAAAAABAAAACAAAOkYBgAAMAAAAAQAAAAZBgAAGAYAADAAAAAEAAAAGgYAABgGAAAwAAAABAAAABsGAAAYBgAAMAAAAAQAAAAcBgAAGAYAADAAAAAEAAAAHQYAABgGAAAwAAAABAAAAB4GAAAYBgAAMAAAAAQAAAAfBgAAGAYAADAAAAAEAAAAIAYAABgGAAAwAAAABAAAACEGAAAYBgAAMAAAAAQAAAAiBgAAGAYAADAAAAAEAAAAIwYAABgGAAAwAAAABAAAACQGAAAlBgAASAAAAAQAAAAmBgAAJQYAAEgAAAAEAAAAJwYAACUGAABIAAAABAAAACgGAAAlBgAASAAAAAQAAAApBgAAJQYAAEgAAAAEAAAAKgYAACUGAABIAAAABAAAACsGAAAlBgAASAAAAAQAAAAsBgAAJQYAAEgAAAAEAAAALQYAAC4GAAA8AAAABAAAAC8GAAAuBgAAPAAAAAQAAAAwBgAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAGM4fACUAAAA9zh8AIQAAACgLEABwAAAA5wIAAAkAAACBQRAAdAAAANwAAAAdAAAAgUEQAHQAAADOAAAAHQAAAIpAEAB9AAAAgQEAABsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAACCVRAAaAAAAIYAAAAmAAAARqbuzFCDCrw6aeStsNPxTKRNPG5KC1QQzZ2WuD4SBRhaJyC5Kqr7Rxt695ZZTB0//HVOzHvjofLa8afBfIQDqStMJF7RV/mAFgp+BY+lZ2GTibuORgks5xhJOI1DiC3pcqR+SE8zMHNwHKQ9JGz7zq85BEvhHPczoFKR3oRGSY18O94VR1BDFW/ltD+K+qJwBhkm20ndTO7d1y67tT2t5klI6zz1ZfGccblydT5HjUK1od/H4KhMQ5L9EeJjY/yjH6FPxPwhQSHWIsWI6dexeKQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyyt3JOhSbkke5YFuLkA0X7GDHJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM0fidydGl/c5W4SOD4clHcWOYOC6bqJpWsC9YjrdR6Id7O1YNFzc+RhlD6Yd/hRxSh/xWe43yMTy2N7pGLwl8ls51EABqAAAAvQEAAB0AAAAuBgAAPAAAAAQAAAAxBgAAMgYAADMGAAA0BgAANQYAADYGAAA3BgAAOAYAADkGAAA6BgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAALgYAADwAAAAEAAAARAYAAEUGAABGBgAARwYAADUGAABIBgAANwYAADgGAAA5BgAAOgYAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAABgGAAAwAAAABAAAAF0DAABJBgAAXwMAAEoGAABLBgAAYQMAAPkBAAD6AQAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABMBgAACAAAAAQAAAByAgAAcwIAAHQCAABNBgAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAJQYAAEgAAAAEAAAATgYAAE8GAABQBgAAUQYAAFIGAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAACUGAABIAAAABAAAAGEGAABiBgAAYwYAAGQGAABSBgAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAAAlBgAASAAAAAQAAABuBgAAbwYAAHAGAABxBgAAUgYAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAJQYAAEgAAAAEAAAAewYAAHwGAAB9BgAAfgYAAFIGAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAACUGAABIAAAABAAAAIgGAACJBgAAigYAAIsGAABSBgAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAAlBgAASAAAAAQAAACSBgAAkwYAAJQGAACVBgAAUgYAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAJQYAAEgAAAAEAAAAnAYAAJ0GAACeBgAAnwYAAFIGAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAACUGAABIAAAABAAAAKQGAAClBgAApgYAAKcGAABSBgAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABVbnN1cHBvcnRlZCB0eXBlICBmb3IgZGljdGlvbmFyeSBpbmRleAAAgNQfABEAAACR1B8AFQAAAENvdWxkIG5vdCBjb252ZXJ0ICBkaWN0aW9uYXJ5IGluZGV4ZXMgZnJvbSAgdG8gALjUHwASAAAAytQfABkAAADj1B8ABAAAABgGAAAwAAAABAAAABsDAACsBgAAHQMAAK0GAABLBgAAHwMAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAABMAwAArgYAAE4DAACvBgAASwYAAFADAABRAwAAUgMAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAAJwMAALAGAAApAwAAsQYAAEsGAAArAwAABwIAAAgCAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAABUDAACyBgAAFwMAALMGAABLBgAAGgMAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAAAiAwAAtAYAACQDAAC1BgAASwYAACYDAAAHAgAACAIAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAAWAMAALYGAABaAwAAtwYAAEsGAABcAwAAUQMAAFIDAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAAFMDAAC4BgAAVQMAALkGAABLBgAAVwMAAPkBAAD6AQAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgZGljdGlvbmFyeSB0byBEaWN0aW9uYXJ5QXJyYXkgb2YgZXhwZWN0ZWQgdHlwZUludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCBVdGY4VmlldyB0byBTdHJpbmdBcnJheSBvZiBleHBlY3RlZCB0eXBlSW50ZXJuYWwgRXJyb3I6IENhbm5vdCBjYXN0IEJpbmFyeVZpZXcgdG8gQmluYXJ5QXJyYXkgb2YgZXhwZWN0ZWQgdHlwZUludmFsaWQgZGljdGlvbmFyeSBpbmRleBcAQeCw/wALARoAQeyw/wAL7QpVbnN1cHBvcnRlZCBvdXRwdXQgdHlwZSBmb3IgZGljdGlvbmFyeSBwYWNraW5nOiBs2B8AMAAAABgGAAAwAAAABAAAAA4CAAC6BgAAEAIAALsGAABLBgAAEgIAAAcCAAAIAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAADLAQAAvAYAAM0BAAC9BgAASwYAANABAADRAQAA0gEAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAA3gEAAL4GAADgAQAAvwYAAEsGAADiAQAA4wEAAOQBAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAAAkCAADABgAACwIAAMEGAABLBgAADQIAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABEZWNpbWFsMzIAAAAE2h8ACQAAAEludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCBkaWN0IHRvIEFycmF5AAAAGNofACQAAAA82h8ABQAAAERlY2ltYWw2NAAAAFTaHwAJAAAARGVjaW1hbDI1NgAAaNofAAoAAABEZWNpbWFsMTI4AAB82h8ACgAAAEludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCB0byBTdHJpbmdWaWV3QXJyYXlJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgdG8gQmluYXJ5Vmlld0FycmF5SW50ZXJuYWwgRXJyb3I6IENhbm5vdCBjYXN0IHRvIEdlbmVyaWNCeXRlQXJyYXkAxwYAADwAAAAEAAAAyAYAAMcGAAA8AAAABAAAAMkGAADHBgAAPAAAAAQAAADKBgAAxwYAADwAAAAEAAAAywYAAMwGAAAwAAAABAAAAM0GAADMBgAAMAAAAAQAAADOBgAAzAYAADAAAAAEAAAAzwYAAMwGAAAwAAAABAAAANAGAADMBgAAMAAAAAQAAADRBgAAzAYAADAAAAAEAAAA0gYAAMwGAAAwAAAABAAAANMGAADMBgAAMAAAAAQAAADUBgAAzAYAADAAAAAEAAAA1QYAAMwGAAAwAAAABAAAANYGAADMBgAAMAAAAAQAAADXBgAAzAYAADAAAAAEAAAA2AYAAMwGAAAwAAAABAAAANkGAADMBgAAMAAAAAQAAADaBgAAzAYAADAAAAAEAAAA2wYAAMwGAAAwAAAABAAAANwGAADMBgAAMAAAAAQAAADdBgAAzAYAADAAAAAEAAAA3gYAAMwGAAAwAAAABAAAAN8GAADMBgAAMAAAAAQAAADgBgAAzAYAADAAAAAEAAAA4QYAAMwGAAAwAAAABAAAAOIGAADMBgAAMAAAAAQAAADjBgAAzAYAADAAAAAEAAAA5AYAAMwGAAAwAAAABAAAAOUGAADMBgAAMAAAAAQAAADmBgAAzAYAADAAAAAEAAAA5wYAAMwGAAAwAAAABAAAAOgGAADMBgAAMAAAAAQAAADpBgAAzAYAADAAAAAEAAAA6gYAAMwGAAAwAAAABAAAAOsGAADsBgAANAAAAAQAAADtBgAA7gYAADgAAAAEAAAA7wYAAPAGAAA8AAAABAAAAPEGAADwBgAAPAAAAAQAAADyBgAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAIzdHwAzAAAAHE8QAGYAAAAzAAAABQAAABIAQeS7/wALAhMCAEHwu/8ACwEIAEH8u/8ACwISAQBBiLz/AAsCEgMAQZS8/wALAQoAQaC8/wALAQIAQay8/wALAQsAQbi8/wALAQkAQcS8/wALAhICAEHQvP8ACwEFAEHcvP8ACwEHAEHovP8ACwEGAEH0vP8ACwEMAEGAvf8ACwEEAEGMvf8ACwEDAEGYvf8AC6kLVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAmN4fACUAAAC93h8AIQAAACgLEABwAAAA5wIAAAkAAAAIQRAAeAAAAIIAAAAeAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAAANQBAAfAAAAFwAAAAOAAAADUAQAHwAAABSAAAAIQAAAEJ5dGUgc2xpY2UgZG9lcyBub3QgaGF2ZSB0aGUgc2FtZSBsZW5ndGggYXMgRml4ZWRTaXplQmluYXJ5QnVpbGRlciB2YWx1ZSBsZW5ndGhzikAQAH0AAACBAQAAGwAAAIpAEAB9AAAAUwEAAD0AAACKQBAAfQAAAFMBAAAnAAAAikAQAH0AAABlAQAAHgAAAIpAEAB9AAAAaAEAABoAAACKQBAAfQAAAHABAAAbAAAAikAQAH0AAAA7AQAAHwAAAEJsb2NrIHRvbyBsYXJnZQAQ4B8ADwAAAIpAEAB9AAAAEgEAAAkAAACKQBAAfQAAABQBAAAYAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAIJVEABoAAAAhgAAACYAAAB/HWoqIlT2wIb23M7m7swAwHHNK/WXKix1JwoV9WuZpO2i5dR7gLHU18EfJ15f4lz/7Fp1xS4YcQF6eKTCW9WLeoxNLzEphhwjoC5rNYdVJgpRsywSqhLqC1ne29TsvDkofOLr7ovvGQKEKFjGuf0W7psyuBSe0blwx3izQVgXEcEjCpXN1iiwgxZfat9rzN9JSOs89WXxnHG5cnU+R41CEM/MnaU1JGkI+ioAjhXJQjX8EWXtUm++JzmV/3oBUuW1od/H4KhMQ5L9EeJjY/yji9qozLiexvSwUd4LjJ+uhEyaqF8hLELkfkWDr4NtNVxJsJ6Qek4sL8tuSeoyCBh8xyz97CXaOPcNmZPCUErMpytMJF7RV/mAFgp+BY+lZ2GvOQRL4Rz3M6BSkd6ERkmNH6FPxPwhQSHWIsWI6dexeKQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyytZJuS9QyOC2DNaGfT4eNQudyToUm5JHuWBbi5ANF+xgxyfspTfoQ6K9lFQ5fxtd+v4qn8OK0OOH7FbC6gMU1KgIYAFII7TEaZo+oYpJXtP/triAXRBZEN4LnG7yT5gwThU+wU3zfbJcgirAcRBqnTTMX88h9xhUtzbrpM08+4KMKN0XrCpBkhd9kV254FF+mM0fidydGl/c5W4SOD4clHcQcgG010/qJJvp/n9xqSBHhjmDgum6iaVrAvWI63UeiHeztWDRc3PkYZQ+mHf4UcUuRUUd5VhI00tWSikrrobxlCxt2uXnKjhOUJHZN/4dGoPvMwG5AYZta8X2XUZ8lrN5cobNP94yrZfNHsgUDHsHa+nCqRkTY0YMVIQBcRDps0h/xWe43yMTy2N7pGLwl8lmFycm93X2FycmF5Ojp0eXBlczo6VGltZXN0YW1wTWlsbGlzZWNvbmRUeXBlYXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBNaWNyb3NlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcE5hbm9zZWNvbmRUeXBlYXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBTZWNvbmRUeXBlAADXMhAAeAAAAOsHAAAJAEHMyP8AC3EBAAAA8wYAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgXiAAAABU5B8AFgAAAGrkHwADAAAATGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAPQGAAA0AAAABAAAAPUGAAD2BgAALAAAAAQAAAD3BgAAAQBByMn/AAuJGcwGAAAwAAAABAAAAA4CAAD4BgAAEAIAAPkGAAD6BgAAEgIAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAADLAQAA/AYAAM0BAAD9BgAA+gYAANABAADRAQAA0gEAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAA3gEAAP4GAADgAQAA/wYAAPoGAADiAQAA4wEAAOQBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAAkCAAAABwAACwIAAAEHAAD6BgAADQIAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABEZWNpbWFsMzIAAAAo5h8ACQAAAENhbm5vdCBjYXN0IHRvICgsICkuIFRoZSBzY2FsZSBjYXVzZXMgb3ZlcmZsb3cuADzmHwAPAAAAS+YfAAEAAABM5h8AAgAAAE7mHwAdAAAARGVjaW1hbDI1NgAAjOYfAAoAAABEZWNpbWFsNjQAAACg5h8ACQAAAERlY2ltYWwxMjgAALTmHwAKAAAAzAYAADAAAAAEAAAAAgcAAAMHAAAEBwAABQcAAPoGAAAGBwAA0QEAANIBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAAcHAAAIBwAACQcAAAoHAAD6BgAACwcAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlzAYAADAAAAAEAAAADAcAAA0HAAAOBwAADwcAAPoGAAAQBwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAABEHAAASBwAAEwcAABQHAAD6BgAAFQcAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAWBwAAFwcAABgHAAAZBwAA+gYAABoHAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAlXgQAGIAAAC7AQAARQAAAJV4EABiAAAA6AEAAA4AAABJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgZHVyYXRpb24gdG8gRHVyYXRpb25BcnJheSBvZiBleHBlY3RlZCB0eXBlAADMBgAAMAAAAAQAAAAVAwAAGwcAABcDAAAcBwAA+gYAABoDAAAAAgAAAQIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAIgMAAB0HAAAkAwAAHgcAAPoGAAAmAwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAPsBAAAfBwAA/QEAACAHAAD6BgAA/wEAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAhBwAAIgcAACMHAAAkBwAA+gYAACUHAAAAAgAAAQIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAJgcAACcHAAAoBwAAKQcAAPoGAAAqBwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAACsHAAAsBwAALQcAAC4HAAD6BgAALwcAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAwBwAAMQcAADIHAAAzBwAA+gYAADQHAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAANQcAADYHAAA3BwAAOAcAAPoGAAA5BwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAADoHAAA7BwAAPAcAAD0HAAD6BgAAPgcAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAuAwAAPwcAADADAABABwAA+gYAADIDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAMwMAAEEHAAA1AwAAQgcAAPoGAAA3AwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAADgDAABDBwAAOgMAAEQHAAD6BgAAPAMAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAA9AwAARQcAAD8DAABGBwAA+gYAAEEDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAARmFpbGVkIHRvIGNyZWF0ZSBuYWl2ZSB0aW1lIHdpdGggIAAAiO0fACEAAACp7R8AAQAAAENhc3RpbmcgZnJvbSBkaWN0aW9uYXJ5IHR5cGUgIHRvICBub3Qgc3VwcG9ydGVkALztHwAdAAAA2e0fAAQAAADd7R8ADgAAAENhc3RpbmcgZnJvbSB0eXBlICB0byBkaWN0aW9uYXJ5IHR5cGUgAAAE7h8AEgAAABbuHwAUAAAA3e0fAA4AAACVeBAAYgAAAF4DAABNAAAARwcAAAgAAAAEAAAAcgIAAHMCAAB0AgAASAcAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAOwGAAA0AAAABAAAAJwEAABJBwAAngQAAEoHAABLBwAAoQQAAEwHAABNBwAApAQAAPsGAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAABjYW5ub3QgY2FzdCBmaXhlZC1zaXplLWxpc3QgdG8gZml4ZWQtc2l6ZS1saXN0IHdpdGggZGlmZmVyZW50IHNpemVDYW5ub3QgY2FzdCBsaXN0IHRvIG5vbi1saXN0IGRhdGEgdHlwZXMAAAD0BgAANAAAAAQAAACHAQAATgcAAIkBAABPBwAAUAcAAIwBAABRBwAAUgcAAI8BAAD7BgAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAQ2FzdGluZyBmcm9tIAAAAMjvHwANAAAA2e0fAAQAAADd7R8ADgAAAPAGAAA8AAAABAAAADEGAABTBwAAMwYAAFQHAABVBwAANgYAADcGAAA4BgAAOQYAAPsGAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAADwBgAAPAAAAAQAAABEBgAAVgcAAEYGAABXBwAAVQcAAEgGAAA3BgAAOAYAADkGAAD7BgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAxwYAADwAAAAEAAAAWAcAAFkHAABaBwAAWwcAAFwHAABdBwAAXgcAAF8HAABgBwAA+wYAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAMcGAAA8AAAABAAAAGoHAABrBwAAbAcAAG0HAABcBwAAbgcAAG8HAABwBwAAYAcAAPsGAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAAOAEHc4v8ACwEPAEHo4v8AC8UPzAYAADAAAAAEAAAA9AEAAHEHAAD2AQAAcgcAAPoGAAD4AQAA+QEAAPoBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAEIDAABzBwAARAMAAHQHAAD6BgAARgMAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABdAwAAdQcAAF8DAAB2BwAA+gYAAGEDAAD5AQAA+gEAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAJwMAAHcHAAApAwAAeAcAAPoGAAArAwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAFgDAAB5BwAAWgMAAHoHAAD6BgAAXAMAAFEDAABSAwAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABMAwAAewcAAE4DAAB8BwAA+gYAAFADAABRAwAAUgMAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAUwMAAH0HAABVAwAAfgcAAPoGAABXAwAA+QEAAPoBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAABsDAAB/BwAAHQMAAIAHAAD6BgAAHwMAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABHAwAAgQcAAEkDAACCBwAA+gYAAEsDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA9gYAACwAAAAEAAAAAgMAAIMHAAAEAwAAhAcAAIUHAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAAJV4EABiAAAAlgkAADYAAADuBgAAOAAAAAQAAAATAgAAhgcAABUCAACHBwAAiAcAABgCAACJBwAAigcAABsCAAD7BgAAHAIAAB0CAAAeAgAAHwIAACACAAAhAgAAIgIAACMCAAAkAgAAlXgQAGIAAADUCQAACgAAAEZpeGVkU2l6ZUJpbmFyeSBhcnJheSB0b28gbGFyZ2UgdG8gY2FzdCB0byBCaW5hcnkgYXJyYXkAlXgQAGIAAAD3CQAACgAAAJV4EABiAAAADwoAAAUAAACVeBAAYgAAABAKAAAaAAAAlXgQAGIAAAARCgAAEwAAAMcGAAA8AAAABAAAAIsHAACMBwAAjQcAAI4HAABcBwAAjwcAAF4HAABfBwAAYAcAAPsGAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADHBgAAPAAAAAQAAACQBwAAkQcAAJIHAACTBwAAXAcAAJQHAABvBwAAcAcAAGAHAAD7BgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAAQAAAAAAAABTdHJpbmcAAID2HwAGAAAATGFyZ2UAAACQ9h8ABQAAACBhcnJheSB0b28gbGFyZ2UgdG8gY2FzdCB0byAgYXJyYXkAAAEAAAAAAAAAAQAAAAAAAACg9h8AHAAAAAEAAAAAAAAAvPYfAAYAAABCaW5hcnkAAOz2HwAGAAAAAAAAAADKmjsAAAAAQEIPAAAAAADoAwAAAAAAAAEAAAAAAAAAAQAAAAAAAADoAwAAAAAAAEBCDwAAAAAAAMqaOwAAAACVBwAAPAAAAAQAAACWBwAAlQcAADwAAAAEAAAAlwcAAJgHAAAwAAAABAAAAJkHAACYBwAAMAAAAAQAAACaBwAAmAcAADAAAAAEAAAAmwcAAJgHAAAwAAAABAAAAJwHAACYBwAAMAAAAAQAAACdBwAAmAcAADAAAAAEAAAAngcAAJgHAAAwAAAABAAAAJ8HAACYBwAAMAAAAAQAAACgBwAAmAcAADAAAAAEAAAAoQcAAJgHAAAwAAAABAAAAKIHAACYBwAAMAAAAAQAAACjBwAAmAcAADAAAAAEAAAApAcAAJgHAAAwAAAABAAAAKUHAACYBwAAMAAAAAQAAACmBwAAmAcAADAAAAAEAAAApwcAAJgHAAAwAAAABAAAAKgHAACYBwAAMAAAAAQAAACpBwAAmAcAADAAAAAEAAAAqgcAAJgHAAAwAAAABAAAAKsHAACYBwAAMAAAAAQAAACsBwAAmAcAADAAAAAEAAAArQcAAJgHAAAwAAAABAAAAK4HAACYBwAAMAAAAAQAAACvBwAAsAcAADwAAAAEAAAAsQcAAFRydXN0ZWQgaXRlcmF0b3IgbGVuZ3RoIHdhcyBub3QgYWNjdXJhdGVseSByZXBvcnRlZADg+B8AMwAAABxPEABmAAAAMwAAAAUAAAAQAEG48v8ACwEIAEHE8v8ACwINAQBB0PL/AAsCEwIAQdzy/wALAg0CAEHo8v8ACwEPAEH08v8ACwECAEGA8/8ACwENAEGM8/8ACwELAEGY8/8ACwEDAEGk8/8ACwIQAQBBsPP/AAsBBwBBvPP/AAsCDQMAQcjz/wALAQQAQdTz/wALAQwAQeDz/wALAQYAQezz/wALAQ4AQfjz/wALARMAQYT0/wALAhMBAEGQ9P8ACwIRAgBBnPT/AAsBCQBBqPT/AAsCEQMAQbT0/wALAQUAQcD0/wALhQcIQRAAeAAAAIIAAAAeAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAACKQBAAfQAAAIEBAAAbAAAAikAQAH0AAABTAQAAPQAAAIpAEAB9AAAAUwEAACcAAACKQBAAfQAAAGUBAAAeAAAAikAQAH0AAABoAQAAGgAAAIpAEAB9AAAAcAEAABsAAACKQBAAfQAAADsBAAAfAAAAQmxvY2sgdG9vIGxhcmdlAOD6HwAPAAAAikAQAH0AAAASAQAACQAAAIpAEAB9AAAAFAEAABgAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAACGAAAAJgAAAFPsFN832yXIIqwHEQap00wrTCRe0Vf5gBYKfgWPpWdhxyz97CXaOPcNmZPCUErMp+6bMrgUntG5cMd4s0FYFxE1lMxCPL1NzPf5wlx1BJoCwSMKlc3WKLCDFl9q32vM30lI6zz1ZfGccblydT5HjUI1/BFl7VJvvic5lf96AVLli9qozLiexvSwUd4LjJ+uhEyaqF8hLELkfkWDr4NtNVxJsJ6Qek4sL8tuSeoyCBh8ClGzLBKqEuoLWd7b1Oy8OaQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyytZJuS9QyOC2DNaGfT4eNQudyToUm5JHuWBbi5ANF+xgxyfspTfoQ6K9lFQ5fxtd+v4qn8OK0OOH7FbC6gMU1KgIYAFII7TEaZo+oYpJXtP/triAXRBZEN4LnG7yT5gwThxfzyH3GFS3NuukzTz7gowo3ResKkGSF32RXbngUX6YzR+J3J0aX9zlbhI4PhyUdxeztWDRc3PkYZQ+mHf4UcUuRUUd5VhI00tWSikrrobxk+8zAbkBhm1rxfZdRnyWs3lyhs0/3jKtl80eyBQMewdgAAAAAAAAAAAQAAALIHAADiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAExheW91dEVycm9yALMHAAAsAAAABAAAALQHAAABAEHQ+/8AC48WlQcAADwAAAAEAAAAiwcAALUHAACNBwAAtgcAALcHAACPBwAAXgcAAF8HAABgBwAAuAcAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAALkHAAA0AAAABAAAALoHAAC7BwAAvAcAAJUHAAA8AAAABAAAAJAHAAC9BwAAkgcAAL4HAAC3BwAAlAcAAG8HAABwBwAAYAcAALgHAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAC/BwAANAAAAAQAAAC6BwAAuwcAAMAHAACwBwAAPAAAAAQAAABEBgAAwQcAAEYGAADCBwAAwwcAAEgGAAA3BgAAOAYAADkGAAC4BwAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAxAcAAAwAAAAEAAAAxQcAAMYHAADHBwAAmAcAADAAAAAEAAAAMAcAAMgHAAAyBwAAyQcAAMoHAAA0BwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAABsDAADLBwAAHQMAAMwHAADKBwAAHwMAAAACAAABAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABCAwAAzQcAAEQDAADOBwAAygcAAEYDAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAWAMAAM8HAABaAwAA0AcAAMoHAABcAwAAUQMAAFIDAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAFMDAADRBwAAVQMAANIHAADKBwAAVwMAAPkBAAD6AQAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABHAwAA0wcAAEkDAADUBwAAygcAAEsDAAAHAgAACAIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAJwMAANUHAAApAwAA1gcAAMoHAAArAwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAADUHAADXBwAANwcAANgHAADKBwAAOQcAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAA6BwAA2QcAADwHAADaBwAAygcAAD4HAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAIQcAANsHAAAjBwAA3AcAAMoHAAAlBwAAAAIAAAECAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAACYHAADdBwAAKAcAAN4HAADKBwAAKgcAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABdAwAA3wcAAF8DAADgBwAAygcAAGEDAAD5AQAA+gEAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAKwcAAOEHAAAtBwAA4gcAAMoHAAAvBwAAAAIAAAECAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAEwDAADjBwAATgMAAOQHAADKBwAAUAMAAFEDAABSAwAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAAVAwAA5QcAABcDAADmBwAAygcAABoDAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAIgMAAOcHAAAkAwAA6AcAAMoHAAAmAwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAC4DAADpBwAAMAMAAOoHAADKBwAAMgMAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAA9AwAA6wcAAD8DAADsBwAAygcAAEEDAAAHAgAACAIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAMwMAAO0HAAA1AwAA7gcAAMoHAAA3AwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAADgDAADvBwAAOgMAAPAHAADKBwAAPAMAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAB8XxAAZQAAAN0AAAAKAAAAfF8QAGUAAAAPAQAATgAAAJgHAAAwAAAABAAAAAIHAADxBwAABAcAAPIHAADKBwAABgcAANEBAADSAQAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAD7AQAA8wcAAP0BAAD0BwAAygcAAP8BAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAAgIAAPUHAAAEAgAA9gcAAMoHAAAGAgAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAHxfEABlAAAAXQEAAAoAAACzBwAALAAAAAQAAAACAwAA9wcAAAQDAAD4BwAA+QcAAAcDAAAIAwAACQMAAAoDAAALAwAADAMAAA0DAAAOAwAADwMAABADAAARAwAAEgMAABMDAAAUAwAAfF8QAGUAAACbAQAACgAAAHxfEABlAAAApAEAAEEAAAAACAAAMAAAAAQAAAABCAAAAAgAADAAAAAEAAAAAggAAAAIAAAwAAAABAAAAAMIAAAACAAAMAAAAAQAAAAECAAAAAgAADAAAAAEAAAABQgAAAAIAAAwAAAABAAAAAYIAAAACAAAMAAAAAQAAAAHCAAAAAgAADAAAAAEAAAACAgAAAAIAAAwAAAABAAAAAkIAAAACAAAMAAAAAQAAAAKCAAAAAgAADAAAAAEAAAACwgAAAAIAAAwAAAABAAAAAwIAAAACAAAMAAAAAQAAAANCAAAAAgAADAAAAAEAAAADggAAFRydXN0ZWQgaXRlcmF0b3IgbGVuZ3RoIHdhcyBub3QgYWNjdXJhdGVseSByZXBvcnRlZACQCCAAMwAAABxPEABmAAAAMwAAAAUAAAAkEgYAQeiRgAELAyZMCgBB9JGAAQsDJSYKAEGAkoABCwMjCQIAQYySgAELuQFUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBQcmltaXRpdmVBcnJheSBvZiBsZW5ndGggAAAMCSAAJQAAADEJIAAhAAAAKAsQAHAAAADnAgAACQAAAIFBEAB0AAAA3AAAAB0AAACBQRAAdAAAAM4AAAAdAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgBB8JOAAQvVA2F0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAADwCSAAGQAAAPh4EABmAAAA6AEAAC8AAAD4eBAAZgAAAPgBAAAvAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAACGAAAAJgAAAO6bMrgUntG5cMd4s0FYFxFJSOs89WXxnHG5cnU+R41CtaHfx+CoTEOS/RHiY2P8o0yaqF8hLELkfkWDr4NtNVwfoU/E/CFBIdYixYjp17F4pBddj0p1IC1jlr4w3kLr7Bli+kYdFYruGEtyCqV7LK3ck6FJuSR7lgW4uQDRfsYMcn7KU36EOivZRUOX8bXfr43ResKkGSF32RXbngUX6YzR+J3J0aX9zlbhI4PhyUdxY5g4LpuomlawL1iOt1Hoh3s7Vg0XNz5GGUPph3+FHFKH/FZ7jfIxPLY3ukYvCXyWRm9ybWF0dGluZyBhcmd1bWVudCBvdXQgb2YgcmFuZ2WQCyAAIAAAANcyEAB4AAAA6wcAAAkAQdCXgAELwxYBAAAADwgAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgLyAAAADYCyAAFgAAAO4LIAADAAAAIF4gANgLIAAWAAAABAwgAAMAAABMYXlvdXRFcnJvcgCLWRAAZgAAAMMAAAA6AAAAAAgAADAAAAAEAAAAywEAABAIAADNAQAAEQgAABIIAADQAQAA0QEAANIBAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAAN4BAAAUCAAA4AEAABUIAAASCAAA4gEAAOMBAADkAQAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAAAJAgAAFggAAAsCAAAXCAAAEggAAA0CAAAAAgAAAQIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAADgIAABgIAAAQAgAAGQgAABIIAAASAgAABwIAAAgCAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAItZEABmAAAAdgEAACoAAACLWRAAZgAAAHoBAAAlAAAAi1kQAGYAAAB7AQAAJgAAAEludmFsaWQgZGVjaW1hbCBmb3JtYXQ6IMQNIAAYAAAAi1kQAGYAAAC0AQAAGAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAwAACIAQAAAAAAAAABAAAAAAAAAItZEABmAAAAuQEAABkAAABDYW5ub3QgcGFyc2UgZGVjaW1hbCBmb3JtYXQ6IAAAADQOIAAdAAAARGVjaW1hbDY0AAAAXA4gAAkAAABDYW5ub3QgY29udmVydCAgdG8gOiBPdmVyZmxvdwAAAHAOIAAPAAAAfw4gAAQAAACDDiAACgAAAERlY2ltYWwyNTYAAKgOIAAKAAAARGVjaW1hbDEyOAAAvA4gAAoAAABEZWNpbWFsMzIAAADQDiAACQAAAHAOIAAPAAAAfw4gAAQAAACLWRAAZgAAAD8CAAASAAAAi1kQAGYAAAA3AgAAPQAAAENhbm5vdCBjYXN0ICB0byBkZWNpbWFsABQPIAAMAAAAIA8gAAsAAABMQ2Fubm90IGNhc3Qgc3RyaW5nIHRvIGRlY2ltYWwgZ3JlYXRlciB0aGFuIG1heGltdW0gc2NhbGUgAAA9DyAAOQAAAENhbm5vdCBjYXN0IHN0cmluZyB0byBkZWNpbWFsIHdpdGggbmVnYXRpdmUgc2NhbGUgAACADyAAMgAAAAkmEgAACAAAMAAAAAQAAABdAwAAGggAAF8DAAAbCAAAEggAAGEDAAD5AQAA+gEAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAUwMAABwIAABVAwAAHQgAABIIAABXAwAA+QEAAPoBAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAACIDAAAeCAAAJAMAAB8IAAASCAAAJgMAAAcCAAAIAgAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAAAbAwAAIAgAAB0DAAAhCAAAEggAAB8DAAAAAgAAAQIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAJwMAACIIAAApAwAAIwgAABIIAAArAwAABwIAAAgCAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAABUDAAAkCAAAFwMAACUIAAASCAAAGgMAAAACAAABAgAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAABMAwAAJggAAE4DAAAnCAAAEggAAFADAABRAwAAUgMAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAWAMAACgIAABaAwAAKQgAABIIAABcAwAAUQMAAFIDAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAENhbm5vdCBjYXN0IHRvIC4gVGhlIHNjYWxlICBjYXVzZXMgb3ZlcmZsb3cugBIgAA8AAACPEiAADAAAAJsSIAARAAAAdmFsdWUgb2YgIGlzIG91dCBvZiByYW5nZSAAAMQSIAAJAAAAzRIgABEAAAAACAAAMAAAAAQAAABHAwAAKggAAEkDAAArCAAAEggAAEsDAAAHAgAACAIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAQgMAACwIAABEAwAALQgAABIIAABGAwAAAAIAAAECAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACRXEABpAAAAOAAAAAUAAABhdHRlbXB0IHRvIGRpdmlkZSBieSB6ZXJvAAAAsBMgABkAAAD4eBAAZgAAAOgBAAAvAAAA+HgQAGYAAAD4AQAALwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIZ/EABrAAAAJwEAAAUAAACGfxAAawAAAD8BAAAFAAAAhn8QAGsAAABXAQAABQAAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgKiAAAABUFCAAFgAAAGoUIAADAAAATnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAABAAAAAQAAADAIAAAAAAAABAAAAAQAAAAyCAAAVGltZXN0YW1wRGF0ZTMyRGF0ZTY0AAAAAAAAAAQAAAAEAAAAKgQAAFRpbWUzMlRpbWU2NER1cmF0aW9uAAAAAAQAAAAEAAAAzAQAAEludGVydmFsQmluYXJ5AAAAAAAABAAAAAQAAABtAwAARml4ZWRTaXplQmluYXJ5TGFyZ2VCaW5hcnlCaW5hcnlWaWV3VXRmOExhcmdlVXRmOFV0ZjhWaWV3AAAAAAAAAAQAAAAEAAAAMwgAAExpc3RMaXN0VmlldzQIAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AAA3CAAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAOggAAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAAA8CAAAAAAAAAQAAAAEAAAAEQUAAERlY2ltYWwzMkRlY2ltYWw2NERlY2ltYWwxMjhEZWNpbWFsMjU2AAAAAAAABAAAAAQAAAA9CAAATWFwUnVuRW5kRW5jb2RlZFNlY29uZE1pbGxpc2Vjb25kTWljcm9zZWNvbmROYW5vc2Vjb25kAADOdRAAagAAAL0BAAAdAAAAi1kQAGYAAADXAAAAJQAAAItZEABmAAAABQEAADAAAAAmTAoAQZyugAELQ0Nhbm5vdCBjYXN0IHN0cmluZyAnJyB0byB2YWx1ZSBvZiAgdHlwZQAcFyAAFAAAADAXIAAOAAAAPhcgAAUAAAAkEgYAQeiugAELAyUmCgBB9K6AAQsDIwkCAEGAr4ABCwIRAwBBjK+AAQsCEAEAQZivgAELARAAQaSvgAELAhECAEGwr4ABC44DT3ZlcmZsb3cgY29udmVydGluZyAgdG8gTmFub3NlY29uZC4gVGhlIGRhdGVzIHRoYXQgY2FuIGJlIHJlcHJlc2VudGVkIGFzIG5hbm9zZWNvbmRzIGhhdmUgdG8gYmUgYmV0d2VlbiAxNjc3LTA5LTIxVDAwOjEyOjQ0LjAgYW5kIDIyNjItMDQtMTFUMjM6NDc6MTYuODU0Nzc1ODA0ALAXIAAUAAAAxBcgAIsAAAACIHRvIAAAALAXIAAUAAAAYRggAAQAAAABdHRydHJ1dHJ1ZXl5ZXllc29uMWZmYWZhbGZhbHNmYWxzZW5ub29mb2ZmMENhbm5vdCBjYXN0IHZhbHVlICcnIHRvIHZhbHVlIG9mIEJvb2xlYW4gdHlwZQAAAKQYIAATAAAAtxggABoAAACVeBAAYgAAAMUBAAAgAAAAQ2Fubm90IGNvbnZlcnQgaW50ZXJ2YWwgY29udGFpbmluZyBub24temVybyBtb250aHMgb3IgZGF5cyB0byBkdXJhdGlvbgAAEwIAQciygAEL5QVDYW5ub3QgY2FzdCB0byAuIE92ZXJmbG93aW5nIG9uIEgZIAAPAAAAVxkgABEAAABBbGwgaTI1NiB2YWx1ZXMgZml0IGluIGY2NAAAlXgQAGIAAAA9BAAAJgAAAD4IAAAIAAAABAAAAHICAABzAgAAdAIAAD8IAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAACVeBAAYgAAANUGAAA6AAAAlXgQAGIAAABCCAAAOgAAAAYAAAALAAAACwAAAAoAAAC4FiAAvhYgAMkWIADUFiAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAVEoQAG8AAADOAQAANwAAAEl0ZXJhdG9yIG11c3QgYmUgc2l6ZWQAAE0KEABuAAAAuwEAACEAAABACAAA//////////8BAAAAAAAAANcyEAB4AAAA6wcAAAkAAACBQRAAdAAAAM4AAAAdAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAAANQBAAfAAAAFIAAAAhAAAAQnl0ZSBzbGljZSBkb2VzIG5vdCBoYXZlIHRoZSBzYW1lIGxlbmd0aCBhcyBGaXhlZFNpemVCaW5hcnlCdWlsZGVyIHZhbHVlIGxlbmd0aHNJbnZhbGlkIGlucHV0IGxlbmd0aCBwYXNzZWQgdG8gRml4ZWRTaXplQmluYXJ5QnVpbGRlci4gRXhwZWN0ZWQgIGdvdCAAAABYGyAAQAAAAJgbIAAFAAAARiAQAGkAAAB7AAAAFwAAAEYgEABpAAAAfAAAAA0AAABvZmZzZXQgb3ZlcmZsb3cARiAQAGkAAACEAAAAHAAAAHVzaXplIG92ZXJmbG93AABGIBAAaQAAAIAAAAArAAAARiAQAGkAAACBAAAAEQAAAAhBEAB4AAAAWQEAABwAQbi4gAEL6QYBAAAAQQgAAEVycm9yAAAA4l8QAGsAAADVDAAADgAAAPrVMvFGvm3zOtSAFi94klinSAzwZ1+TofJnjflbc1/9DbjZhoHu4s4rVLzXaLmWADeBC8ux5MZO36L2DutuYRjiXxAAawAAAOgBAAAXAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpITEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5SUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxgXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5kYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYgAAAOUqEABlAAAACAEAABsAAAABAAAAAAAAAAIAQaq/gAELAQUAQbS/gAELESAAIOkuAAAAuB8gAAEAAAACAEHOv4ABCwEDAEHYv4ABCwUgAADpAgBB5r+AAQsBBgBB8L+AAQsFIAAA6QIAQf6/gAELAQkAQYjAgAEL6SQgAADpaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZRRfEABnAAAAKQIAACsAAABMb2NhbCB0aW1lIG91dCBvZiByYW5nZSBmb3IgYE5haXZlRGF0ZVRpbWVgAHuEEABiAAAAQwIAAA4AAAB3cml0aW5nIHJmYzMzMzkgZGF0ZXRpbWUgdG8gc3RyaW5nIHNob3VsZCBuZXZlciBmYWlse4QQAGIAAACnAgAADgAAAEIIAAA0AAAABAAAALoHAAC7BwAAwAcAAEMIAAA0AAAABAAAALoHAAC7BwAAvAcAAM51EABqAAAAvQEAAB0AAADseRAAawAAAEEDAAAVAAAA1zIQAHgAAADrBwAACQAAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgKyAAAAAkISAAFgAAADohIAADAAAAICogACQhIAAWAAAAUCEgAAMAAABMb2NhbCB0aW1lIG91dCBvZiByYW5nZSBmb3IgYE5haXZlRGF0ZVRpbWVgAHuEEABiAAAAQwIAAA4AAABUShAAbwAAAM4BAAA3AAAAznUQAGoAAAC9AQAAHQAAAIVoEABfAAAAIQAAAAsAAABpbnZhbGlkIHRpbWVzdGFtcCBzZXBhcmF0b3IAhWgQAF8AAADdAAAAGgAAAHRpbWVzdGFtcCBtdXN0IGNvbnRhaW4gYXQgbGVhc3QgMTAgY2hhcmFjdGVyc0Vycm9yIHBhcnNpbmcgdGltZXN0YW1wIGZyb20gJyc6IAAAKSIgAB4AAABHIiAAAwAAAGVycm9yIHBhcnNpbmcgZGF0ZWVycm9yIGNvbXB1dGluZyB0aW1lem9uZSBvZmZzZXRlcnJvciBwYXJzaW5nIHRpbWVGYWlsZWQgdG8gcGFyc2UgJycgYXMgdGltZQAAAJ8iIAARAAAAsCIgAAkAAACFaBAAXwAAAFcCAAAbAAAAhWgQAF8AAABeAgAAHwAAAIVoEABfAAAAYAIAAB8AAABDYW5ub3QgY2FzdCAgdG8gSW50ZXJ2YWxZZWFyTW9udGguIE9ubHkgeWVhciBhbmQgbW9udGggZmllbGRzIGFyZSBhbGxvd2VkLgAA/CIgAAwAAAAIIyAAPgAAACB0byBJbnRlcnZhbERheVRpbWUgYmVjYXVzZSB0aGUgbmFub3MgcGFydCBpc24ndCBtdWx0aXBsZSBvZiBtaWxsaXNlY29uZHMAAAD8IiAADAAAAFgjIABJAAAAY2NlbnRjZW50c2NlbnR1cnljZW50dXJpZXNkZWNkZWNzZGVjYWRlZGVjYWRlc3l5cnlyc3llYXJ5ZWFyc21vbm1vbnNtb250aG1vbnRoc3d3ZWVrd2Vla3NkZGF5ZGF5c2hocmhyc2hvdXJob3Vyc21taW5taW5zbWludXRlbWludXRlc3NzZWNzZWNzc2Vjb25kc2Vjb25kc21zbXNlY21zZWNzbXNlY29uZG1zZWNvbmRzbWlsbGlzZWNvbmRtaWxsaXNlY29uZHN1c3VzZWN1c2Vjc3VzZWNvbmR1c2Vjb25kc21pY3Jvc2Vjb25kbWljcm9zZWNvbmRzbmFub3NlY29uZG5hbm9zZWNvbmRzVW5rbm93biBpbnRlcnZhbCB0eXBlOiDFJCAAFwAAAC0gZXhjZWVkcyB0aGUgcHJlY2lzaW9uIGF2YWlsYWJsZSBmb3IgaW50ZXJ2YWwgYW1vdW50AAAAAQAAAAAAAADlJCAANAAAAEZhaWxlZCB0byBwYXJzZSAgYXMgaW50ZXJ2YWwgYW1vdW50ACwlIAAQAAAAPCUgABMAAABVbmFibGUgdG8gcmVwcmVzZW50IGludGVydmFsIHdpdGggZGF5cyBhbmQgbmFub3MgYXMgeWVhci1tb250aHM6IAAAAGAlIABBAAAAVW5hYmxlIHRvIHJlcHJlc2VudCAgYXMgbWlsbGlzZWNvbmRzrCUgABQAAADAJSAAEAAAACBuYW5vcyBhcyBtaWxsaXNlY29uZHMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIAAACsJSAAFAAAAOAlIAAxAAAAIGNlbnR1cmllcyBhcyBtb250aHMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIArCUgABQAAAAkJiAALwAAACBkZWNhZGVzIGFzIG1vbnRocyBpbiBhIHNpZ25lZCAzMi1iaXQgaW50ZWdlcgAAAKwlIAAUAAAAZCYgAC0AAAAgeWVhcnMgYXMgbW9udGhzIGluIGEgc2lnbmVkIDMyLWJpdCBpbnRlZ2VyAKwlIAAUAAAApCYgACsAAAAgbW9udGhzIGluIGEgc2lnbmVkIDMyLWJpdCBpbnRlZ2VyAACsJSAAFAAAAOAmIAAiAAAAIHdlZWtzIGFzIGRheXMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIAAACsJSAAFAAAABQnIAApAAAAIGRheXMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXKsJSAAFAAAAFAnIAAgAAAASW52YWxpZCBpbnB1dCBzeW50YXggZm9yIHR5cGUgaW50ZXJ2YWw6IC4gUmVwZWF0ZWQgdHlwZSAnJwAAgCcgACgAAACoJyAAEQAAALknIAABAAAAgCcgACgAAACFaBAAXwAAAM8FAAAUAAAAhWgQAF8AAADRBQAAFAAAAIVoEABfAAAA0wUAABQAAAAAAAAABAAAAAQAAABFCAAAAAAAAAQAAAAEAAAASAgAAEludGVydmFsbmFub3MAAADILBAAYAAAAIgGAAApAAAATWF4aW11bSBvZmZzZXQgb2YgIGlzIGxhcmdlciB0aGFuIHZhbHVlcyBvZiBsZW5ndGggAEwoIAASAAAAXiggACEAAABPZmZzZXQgb2YgIGV4Y2VlZHMgbGVuZ3RoIG9mIHZhbHVlcyCQKCAACgAAAJooIAAaAAAAU3BsaXQgVVRGLTggY29kZXBvaW50IGF0IG9mZnNldCDEKCAAIAAAAEVuY291bnRlcmVkIG5vbiBVVEYtOCBkYXRhOiDsKCAAHAAAACZwcmVjaXNpb24gY2Fubm90IGJlIDAsIGhhcyB0byBiZSBiZXR3ZWVuIFsxLCBdABEpIAAtAAAAPikgAAEAAABzY2FsZSAgaXMgZ3JlYXRlciB0aGFuIHByZWNpc2lvbiAAAABQKSAABgAAAFYpIAAbAAAAIGlzIGdyZWF0ZXIgdGhhbiBtYXggAAAAUCkgAAYAAACEKSAAFQAAAHByZWNpc2lvbiAAAKwpIAAKAAAAhCkgABUAAAASCUwAAAAAAAEAAAAAAAAACgAAAAAAAABkAAAAAAAAAOgDAAAAAAAAECcAAAAAAACghgEAAAAAAEBCDwAAAAAAgJaYAAAAAAAA4fUFAAAAAADKmjsAAAAAAOQLVAIAAAAA6HZIFwAAAAAQpdToAAAAAKByThgJAAAAQHoQ81oAAACAxqR+jQMAAADBb/KGIwAAAIpdeEVjAQAAZKeztuANAADoiQQjx4obWRAAbwAAAD8AAAAFAAAARxIQAGYAAADIAQAADQAAAEcSEABmAAAAvgEAAA0AAABHEhAAZgAAAL8BAAANAAAARxIQAGYAAADCAQAAEQAAAEcSEABmAAAA6gEAABEAAABHEhAAZgAAAOQBAAARAAAARxIQAGYAAADlAQAAEQAAAEcSEABmAAAA8gEAAAUAAABHEhAAZgAAAOgAAAA7AAAARxIQAGYAAADwAAAAMgAAAEcSEABmAAAA7gAAADAAAABHEhAAZgAAAIcAAAAyAAAAHWgQAGcAAAAkAwAAMAAAALVpEABoAAAA3QAAABYAAABOYU5pbmZpbmZpbml0eVVuYWJsZSB0byBkb3duY2FzdCB0byBsaXN0IGFycmF5AAA6GRAAXwAAAKcCAAAKAAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAUQgAAFIIAABSCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAUwgAAFQIAABUCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAAVQgAAFYIAABWCAAAAAAAAAQAAAAEAAAAVwgAAFgIAABYCAAAAAAAAAQAAAAEAAAAWQgAAFoIAABaCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAXQgAAF4IAABeCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAXwgAAGAIAABgCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAYQgAAGIIAABiCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAYwgAAGQIAABkCAAAAAAAAAQAAAAEAAAAZQgAAGYIAABmCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAZwgAAGgIAABoCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAaQgAAGoIAABqCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAawgAAGwIAABsCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAbQgAAG4IAABuCAAAbwgAADQAAAAEAAAAcAgAAHEIAAA4AAAABAAAAHIIAABxCAAAOAAAAAQAAABzCAAAZGljdGlvbmFyeSBhcnJheToZEABfAAAAwgMAACIAAABzdHJpbmcgYXJyYXk6GRAAXwAAAFoDAAAdAAAAgUEQAHQAAADOAAAAHQAAAIk/EACDAAAABwIAABYAAACJPxAAgwAAAAgCAAAYAAAAiT8QAIMAAAAKAgAADAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAAEkAAAAFAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2Rl0AYQAGsAAADQAQAAEgAAAHuyPBybtYf8gZvSY1u1me7/7Fp1xS4YcQF6eKTCW9WL4//WmAXKflpr1eEeiUAqJNcyEAB4AAAA6wcAAAkAQfzkgAEL8AoBAAAAdAgAAAAAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEYTGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAHEIAAA4AAAABAAAAPgEAAB1CAAA+gQAAHYIAAB3CAAA/AQAAP0EAAD+BAAA7QQAAHgIAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABxCAAAOAAAAAQAAADlBAAAeQgAAOcEAAB6CAAAdwgAAOoEAADrBAAA7AQAAO0EAAB4CAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAbwgAADQAAAAEAAAAnAQAAHsIAACeBAAAfAgAAH0IAAChBAAAfggAAH8IAACkBAAAeAgAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAIAIAAAIAAAABAAAAHICAABzAgAAdAIAAIEIAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABDYW5ub3QgY2FzdCB0byBGaXhlZFNpemVMaXN0KCk6IHZhbHVlIGF0IGluZGV4ICBoYXMgbGVuZ3RoIABENCAAHQAAAGE0IAASAAAAczQgAAwAAAA2FxAAYwAAAHMAAAAgAAAATGFyZ2VMaXN0IHRvbyBsYXJnZSB0byBjYXN0IHRvIExpc3QAXg4QAGEAAACHAwAAGQAAAF4OEABhAAAAswMAABMAAABeDhAAYQAAALQDAAAVAAAAikAQAH0AAACBAQAAGwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSA8IHUzMjo6TUFYIGFzIHVzaXplAACKQBAAfQAAALAAAAAJAAAAikAQAH0AAABTAQAAPQAAAIpAEAB9AAAAUwEAACcAAACKQBAAfQAAAGUBAAAeAAAAikAQAH0AAABoAQAAGgAAAIpAEAB9AAAAcAEAABsAAACKQBAAfQAAADsBAAAfAAAAQmxvY2sgdG9vIGxhcmdlALA1IAAPAAAAikAQAH0AAAASAQAACQAAAIpAEAB9AAAAFAEAABgAAACKQBAAfQAAAMUAAAAbAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIJVEABoAAAAhgAAACYAAABuBRAAcAAAAKEDAAANAAAALRcb/xzXoRMXdqDvPS1of8CQjP/nMQE//rncP3cBe5GnB8QWnWvAAmludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGUbWRAAbwAAABYAAAAOAAAAAAAAAAEAAAAAAAAABQAAAAAAAAAZAAAAAAAAAH0AAAAAAAAAcQIAAAAAAAA1DAAAAAAAAAk9AAAAAAAALTEBAAAAAADh9QUAAAAAAGXNHQAAAAAA+QKVAAAAAADdDukCAAAAAFFKjQ4AAAAAlXPCSAAAAADpQcxrAQAAAI1J/RoHAAAAwW/yhiMAAADFLryisQAAANnprC14AwAAPZFg5FgRAAAx1uJ1vFYAAPUubk2usQEAyeomg2d4CADtlcKPBVoqAKHtzM4bwtMAJaQACovKIgS5NAMyt/StFJ0HEPqTx2VnAACAPwAAIEEAAMhCAAB6RABAHEYAUMNHACR0SYCWGEsgvL5MKGtuTvkCFVAAQYbwgAELsgHwPwAAAAAAACRAAAAAAAAAWUAAAAAAAECPQAAAAAAAiMNAAAAAAABq+EAAAAAAgIQuQQAAAADQEmNBAAAAAITXl0EAAAAAZc3NQQAAACBfoAJCAAAA6HZIN0IAAACilBptQgAAQOWcMKJCAACQHsS81kIAADQm9WsMQwCA4Dd5w0FDAKDYhVc0dkMAyE5nbcGrQwA9kWDkWOFDQIy1eB2vFURQ7+LW5BpLRJLVTQbP8IBEAEGA8oABC/kBAQAAAAAAAAAKAAAAAAAAAGQAAAAAAAAA6AMAAAAAAAAQJwAAAAAAAKCGAQAAAAAAQEIPAAAAAACAlpgAAAAAAADh9QUAAAAAAMqaOwAAAAAA5AtUAgAAAADodkgXAAAAABCl1OgAAAAAoHJOGAkAAABAehDzWgAAAIDGpH6NAwAAAMFv8oYjAAAAil14RWMBAABkp7O24A0AAOiJBCPHitcyEAB4AAAA6wcAAAkAAAAalRAAVgAAAMYBAAA+AAAAGpUQAFYAAADRAQAAOQAAABqVEABWAAAA3wEAAD4AAAAalRAAVgAAAOoBAAA5AAAAAQAAAAAAAAACAEGC9IABCwECAEGM9IABC8UBIAAA6V4OEABhAAAA0gMAABIAAAA6IAAAAQAAAAAAAAAgOiAAAgAAACwgAAA0OiAAAgAAACA6IAACAAAAXg4QAGEAAAD6AwAAEwAAAF4OEABhAAAA+wMAABUAAAAgOiAAAgAAADQ6IAACAAAAXg4QAGEAAAAhBAAAEAAAAF4OEABhAAAAGgQAABIAAABeDhAAYQAAACwEAAAgAAAAXg4QAGEAAAAsBAAANwAAAHs9AAC4OiAAAQAAALk6IAABAAAAAAAAAAEAQaD2gAELpQEIDRAAawAAAHcAAAAvAAAATGFyZ2UAAAAwOyAABQAAAFN0cmluZwAAQDsgAAYAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBBcnJheSwgZXhwZWN0ZWQgIGdvdCAAAABQOyAAJAAAAAEAAAAAAAAAdDsgABAAAACEOyAABQAAAAEAAAAAAAAAQmluYXJ5AAC0OyAABgAAABQAQdD3gAELARYAQdz3gAELJpXGSEtF/rhGs2cet9Q4ijKGCAAADAAAAAQAAACHCAAAiAgAAMcHAEGM+IABC/kJAQAAAIkIAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAACKCAAAFAAAAAQAAACLCAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUVycm9y4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAAAAAAAABAAAAAQAAABKAgAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAACGCAAADAAAAAQAAACMCAAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSExKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGLlKhAAZQAAAAgBAAAbAAAAAgBBjoKBAQsBBQBBmIKBAQsRIAAg6S4AAAAcQSAAAQAAAAIAQbKCgQELAQMAQbyCgQELBSAAAOkCAEHKgoEBCwEGAEHUgoEBCwUgAADpAgBB4oKBAQsBCQBB7IKBAQvNESAAAOlpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlFF8QAGcAAADkAAAAHQAAABRfEABnAAAA5wAAAB0AAABKYW51YXJ5RmVicnVhcnlNYXJjaEFwcmlsTWF5SnVuZUp1bHlBdWd1c3RTZXB0ZW1iZXJPY3RvYmVyTm92ZW1iZXJEZWNlbWJlcgAAuEEgAAcAAAC/QSAACAAAAMdBIAAFAAAAzEEgAAUAAADRQSAAAwAAANRBIAAEAAAA2EEgAAQAAADcQSAABgAAAOJBIAAJAAAA60EgAAcAAADyQSAACAAAAPpBIAAIAAAASmFuRmViTWFyQXBySnVuSnVsQXVnU2VwT2N0Tm92RGVjAAAAZEIgAAMAAABnQiAAAwAAAGpCIAADAAAAbUIgAAMAAADRQSAAAwAAAHBCIAADAAAAc0IgAAMAAAB2QiAAAwAAAHlCIAADAAAAfEIgAAMAAAB/QiAAAwAAAIJCIAADAAAAU3VuZGF5TW9uZGF5VHVlc2RheVdlZG5lc2RheVRodXJzZGF5RnJpZGF5U2F0dXJkYXkAAOhCIAAGAAAA7kIgAAYAAAD0QiAABwAAAPtCIAAJAAAABEMgAAgAAAAMQyAABgAAABJDIAAIAAAAU3VuTW9uVHVlV2VkVGh1RnJpU2F0AAAAVEMgAAMAAABXQyAAAwAAAFpDIAADAAAAXUMgAAMAAABgQyAAAwAAAGNDIAADAAAAZkMgAAMAAABBTVBNjQgAAGQAAAAEAAAAjggAAM51EABqAAAAvQEAAB0AAABtYXAgaXMgbWlzc2luZyBrZXkgZmllbGRtYXAgaXMgbWlzc2luZyB2YWx1ZSBmaWVsZAAAjwgAAAgAAAAEAAAAcgIAAHMCAAB0AgAAkAgAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAI0IAABkAAAABAAAALIEAACRCAAAtAQAAJIIAACTCAAAtwQAALgEAAC5BAAAugQAAJQIAAC7BAAAvAQAAL0EAAC+BAAAvwQAAMAEAADBBAAAwgQAAMMEAABJbnRlcm5hbCBFcnJvcjogdG9fZGF0YV90eXBlIGlzIG5vdCBhIG1hcCB0eXBlLkZvcm1hdCBlcnJvcgBeDhAAYQAAADYBAABLAAAAXg4QAGEAAABAAQAASQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHVuc3VwcG9ydGVkIGRpY3Rpb25hcnkga2V5IHR5cGU6IAAIRSAASwAAAF4OEABhAAAAOQEAACcAAABeDhAAYQAAADsBAAASAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgcnVuIGVuZCBpbmRleCB0eXBlOiAAAHxFIABKAAAAXg4QAGEAAABGAQAAKgAAAF4OEABhAAAASAEAABIAAABmb3JtYXR0aW5nICBpcyBub3QgeWV0IHN1cHBvcnRlZPBFIAALAAAA+0UgABUAAACVCAAAHAAAAAQAAACWCAAAAAAAAAwAAAAEAAAAlwgAAAAAAAAMAAAABAAAAJgIAAAAAAAADAAAAAQAAACZCAAAAAAAABAAAAAEAAAAmggAAJsIAAAUAAAABAAAAJwIAAAAAAAADAAAAAQAAACdCAAAAAAAABQAAAAEAAAAnggAAJsIAAAUAAAABAAAAJ8IAAAAAAAADAAAAAQAAACgCAAAmwgAABQAAAAEAAAAoQgAAAAAAAAQAAAABAAAAKIIAACbCAAAFAAAAAQAAACjCAAAAAAAAAwAAAAEAAAApAgAAAAAAAAMAAAABAAAAKUIAAAAAAAAHAAAAAQAAACmCAAAAAAAAAwAAAAEAAAApwgAAAAAAAAMAAAABAAAAKgIAAAAAAAAFAAAAAQAAACpCAAAmwgAABQAAAAEAAAAqggAAJsIAAAUAAAABAAAAKsIAAAAAAAADAAAAAQAAACsCAAAAAAAABwAAAAEAAAArQgAAAAAAAAQAAAABAAAAK4IAAAAAAAADAAAAAQAAACvCAAAAAAAAAwAAAAEAAAAsAgAAAAAAAAMAAAABAAAALEIAAAAAAAAEAAAAAQAAACyCAAAmwgAABQAAAAEAAAAswgAAAAAAAAMAAAABAAAALQIAAAAAAAAHAAAAAQAAAC1CAAAAAAAABAAAAAEAAAAtggAALcIAAAYAAAABAAAALgIAAAAAAAADAAAAAQAAAC5CAAAuggAABgAAAAEAAAAuwgAAJsIAAAUAAAABAAAALwIAAAAAAAAFAAAAAQAAAC9CAAAAAAAAAwAAAAEAAAAvggAAJsIAAAUAAAABAAAAL8IAAAAAAAADAAAAAQAAADACAAAmwgAABQAAAAEAAAAwQgAAAAAAAAUAAAABAAAAMIIAADDCAAAHAAAAAQAAADECAAAmwgAABQAAAAEAAAAxQgAAAAAAAAQAAAABAAAAMYIAAAAAAAADAAAAAQAAADHCAAAAAAAABQAAAAEAAAAyAgAAAAAAAAMAAAABAAAAMkIAAAAAAAAFAAAAAQAAADKCAAAAAAAABQAAAAEAAAAywgAAJsIAAAUAAAABAAAAMwIAAAAAAAAEAAAAAQAAADNCAAAAAAAAAwAAAAEAAAAzggAAAAAAAAMAAAABAAAAM8IAACbCAAAFAAAAAQAAADQCAAAAAAAABAAAAAEAAAA0QgAAAAAAAAcAAAABAAAANIIAAAAAAAADAAAAAQAAADTCAAAIGhvdXJzAAABAAAAAAAAAAEAAAAAAAAAwEkgAAYAAAAgIG1pbnMAAAEAAAAAAAAAAQAAAAAAAADhSSAABQAAAC0gc2VjcwAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAHEEgAAEAAAABSiAABQAAAAIAAAAAAAAAAgBBxJSBAQs1IAAA4AIAAAAAAAAAAgAAAAAAAAABAAAAIAAA4AIAAAAAAAAAAgAAAAAAAAACAAAAIAAA4AIAQYKVgQELFwkAAAAAAAMAAAAgAADpAgAAAAAAAAACAEGklYEBCzUgAADgAgAAAAAAAAACAAAAAAAAAAEAAAAgAADgAgAAAAAAAAACAAAAAAAAAAIAAAAgAADgAgBB4pWBAQsPAwAAAAAAAwAAACAAAOkCAEH6lYEBCwECAEGEloEBC9QtIAAA6SwgAAAISyAAAgAAAE5vbmUAAAAABAAAAAQAAABDBQAAU29tZZFzEABzAAAAjQAAABkAAADADhAAegAAAB8AAAAmAAAAwA4QAHoAAABUAAAACQAAANRyEABcAAAAigAAAAkAAACRcxAAcwAAADgAAAAmAAAAkXMQAHMAAABeAAAALgAAAJFzEABzAAAAYQAAAA0AAACRcxAAcwAAAGUAAAA4AAAAkXMQAHMAAAA9AAAAJwAAAECDEABwAAAAlgAAAA0AAABAgxAAcAAAAJgAAABAAAAAQIMQAHAAAACXAAAADQAAAECDEABwAAAAmgAAAA0AAABAgxAAcAAAAJ4AAAANAAAAQIMQAHAAAACfAAAADQAAAECDEABwAAAAhwAAACUAAABAgxAAcAAAAIgAAAArAAAAQIMQAHAAAABAAAAAGwAAAECDEABwAAAAQgAAACAAAADKHRAAaAAAAGsEAAAXAAAAAAAAAFrWO5LWU/TuPzuhBimqPxH4ZWUbZrRYlQfFJKRZysdKdr8+on/hrrpJ9i0N8Lx5XVNvzorfmVrp3HN5ECws2PSUBcG2K6DYkWnoS4qbGwd5+UZxpDbITraE4t5sguJIl7eYjU1EeuLjJZsWCCMbG/1yf3iwaoxtjvcgDuX18DD+T5+WXIXvCLI1qVFeMy29vSNHvLNmK4veghPmNYB4LK12rFUwIPsWizHMryFQyztMkxdrPOi53K09vxsqJL5K33jdhUti6FPZDa+iNK1tHddrqjNvPXHUh2it5UCMZHKGBpUAy4yNyanCGB9Rr/0OaEi6wP3v8DvU8t5mJRu9EgJtdJj+lXalhFdLYPcwtksBiJE+fjvUzqUtXjg1vaOeQeo1zl1KiULPuXWGgqxMBlKy4aB6zpWJgZMJlNHr70NzHxpJGUL766H4C/nF5usUEKZgm58S+mbK9k53d+AmGtTQOIJHl7gA/bQiVZWYsCCJgmOxjF5zIJ6wNVVdX260VWK83S82kKjFHYOqNPeJIet7K9W7Q7QS9+Qj1QF17OmlLTtlVaqwa5puNiUhyTOyR/iJvurUnAbBCoRuabvAnpl2LG4lCkRI8Q0lykPqcAbAyttkV4YqzZYoV15qkgYEOLwSPu0ndYC88uz1BDcIBcZrl43ocZKg6y5oM8ZESob3o35YMYdbRJMdIeD7au6zekyerv1ochW4ZCnYugXqYFnfRRo9A88a5r0zjimHJLlvq2swBmLB0I9W4Ph51LbTpZaGvIe68cSzbBh3mImkSI88qKspKS624IfelP6rzRozJUkLutnccYwUCx1/i8Dwn28bjigQVI6v2U3kXq7w7AdKorEyFOlx21BhnfbZLOjJbgWvn6wxJ4nSXCI6CBwxvsrGmscX/nCrBvSqSApjvW19eIG5nT1N1gix1drMuywJTuvwk4JG8IWljsUIYPW7JSEm7TgjWGynTvL2CrjyKq+qbygHLG5H0eGutA1mr/UaykV5hNukzIJN7ZDIn43ZUDyXl2USzn+joCi1ugfxD+UMff3+lsFfzMhyYqlJ7VMeT9y8vvyxd/96D7sTnOjoJbEJNvc9z6qfrOlUjGGRsXcdjAN1DYOVxxckau+59Z3VJW9E0tDjevkdrURrKHMFS3fFaoNizuybMuwKQ/ln407VdkUk+wHowj+nzZP3QZwiitRW7XkCovMPEcF4dVJDa9ZEVjSMQUWYqap4a4kTCoMM1mtB75FWvlPVVsZrmMwjj8vGEWs27O2oiuy3hr6/LDk/HOsCorOUqdbzMhTX93sHT+Olg4rguVPMsD/ZzPXaySJcjyStWOho/5yPD0Cz0b6Vmdk2bDeRoR/CuQkIECMt+/+PREeFtYqnMigMCtSr+fn/sxWZ5uJsUT8yjwzJFjv8f5CtH9CN45Jnf9mnPa5K+5/0mCdEsZx3Qd/PEc2ZHfrHMX8xld2D1RHXQ1ZAQFL8HH/vPn2KciVrZuo1KEhmO+Req44crc/uBQBlQzLaQEqdNlayY9iCagdAPtS+kGhOIuJ1Tz6HkaIE6KZEd1oC4qpaU+MNqTbLBaLQFRVxg5pVMShcUdMDPofKRFtaDZGA1R6Z2RKEwoaU/gp5WOi24Ipm/48XpXKoOb5Nl25i45gtQP9zXc6PEsgtIT0K+45/HIh/aPqAmQudvDRm5nxynyNqnwI5oYBOxOvB/x8cToesREdDh8kgYrVmsv8noyKp1xUZFOn7qLpiAJ//8Uu1yaatj6xxnam0PWDDP3dvInwQmbMXzsTTIU04tA9VyyubVH+gnQH2SGpgRqFTKn774JRPhALBmW1C/MtEdNouORl6YyVDMcAIU/v+VRGR+oifWLzukz3wyie6fqtVNXm1Y7c1dXwmlt5YNC+LVcFLojwlg5IbsLsWbwH77aqxnsuL7iN3Ipzq3MrBeakVXkZfF3V2ipWhkskeGeyJzfoLNl0SFO36Sbd7Zh9n7ID5zoT0FlmoeRzlGkDngCfht4LSWK43CcwxjxCIkLC47LLRB++ZhQs//rIVqrTc5qcfhslqAGfOzr3fmtThk+CRp2e9QmAAQaHWi+AkbVwsu8jgbVN4QJFJzK4Ybohz9+n6WEholpD1W3/anolqUHWkOa8tAV56eZmPiAOWQlLJBoRteIH12Nd/s6qDO9OmewjlyNbhMs/NX2DVZAqIkJpKHvsmzX+h4DtchX8GVZqg7vJcb8DfydhKs6YeSOrASKov9IuwV/yOHWDQJtok8dqUO/FXzrZdeRI8glgIt9YIPcV27YEktRcXy6JuymQMS4x2VGiibaLd3H3LCf19z10vlKkCCwkLFVRd/kx8XUM1O/nT4ablJo1U+p6vbRpKAcV7xJoQn3Cw6bjGGwmhnEG2mjXA1MaMHCRn+GJLyQPSYwHD+ET815F2QJsdz11CY97geTZW+002lBDC5EL1EvwVWZjEK3rhQ7mU8p2Tshd7W28+WlvsbMrznJdCnM/uLJkFpzFyJwi9MIS9U4ODKnj/xlC9TjFK7Dzl7ChkJDVWv/ikNtFerhNGD5SZvjbhlXcbh4SF9pmYFxO5P26EWXtV4ijlJnTAft1X58+J5S/a6hozT5hIOG/qlpAhdu9dyNLwP2O+WgYLpby0qVNrdXoH7Q/7bfHHTc7r4ZQoxhJZSejTveT2nPBgM41c2bur1y1xZOydNMQsOYCws8+qlk15jb1nxUH1d0eg3KCDVfyg1/DsYBtJ+aos5IlEcrWdxIYW9Dlim7fVN12s1c4ixXUoHDHHOoIly4V014uCazaTMmN9vGRx957TqIaXMQMCnP9druu9TbWGCFOo/P2DAoN/9dlmLaFiqMpn0nv9JMNj33LQYLykPanegINtHvdZnstHQnjrDY1TFmGkCOZ08IW+2VJWZlFw6Ft5zYsfkmwnLpBn9t8yRnHZa4C2U9uj2By6APOXv5fNz4agpCjSzA6k6IDwfa/9wIOoyM2yBoASzSJhbF0bPbGk0vqBXwggV4BreWMaMcbupsOcsDsFdDYw48v8YL13qpD0w5yKBhFE/Nu+O7msFdW08fRELUgVVfuS7sXziy0FEReZShxNLRXdG3W28O54RtVcv11joHha1GLS5KwqF5gKNO80fMgWcYn7hg6seg6fhoCVoE09ruY1XdQSVxnSRqjgugmhzFlgg3SJ16yfhljSmOlLyT9wOKTRKwbMI1R3g/+Rz90nRqMGY3sIvywpVWR/tkLVsRdMyDsayu53c2o9H+STSp4dX7rKID71KohihpOOnO6Ccnu0flSNsjUq+2c4skOqI0+aYZ7pMR/D9PmBxt7UlOziAPoFZH7z+Tg8ETyLBN3TjUC8g95ecDhHixULrkXUSLFQqySWdowGGe7ajdlXCZvdJNatO8kXpM/UqPiH1uWACtelTOW8HY0DCtP2qUwfIc1Mz59eK2VwhMyHdNQfZ2kAIMNHdjs/xtLf1MiEc+BBAPTZ7CkJz3fHFwr7pZBYUgBxEGj0zMJVuZ3Mec+07mZAjRSCcb+Z1ZPiH6yBMFVASNhM8cYvAMs42ycXonxqUFoOoK24O8D9BtLxnMocheTwEQjZpkowvYhGLkT9Y6YdbRZKj5AuPnYV7JxKnv6HMgROjlmaus3TGidE3cX9KT+F4fHvQCjBiOEwlVT3fPSO5lnuK9G5ePWMPt2Ums5YGTD4dLuC59YyMI4UOsEBrx88NlJq46GMP7yxmYjxwZony8PmRNzlt6cVD2D1lrnA+F46EKsp3qUR2xK4srzn8Lb2SNQVdFYP1pEXZt/rIa1kNFtJGxGVySW7zp9rkzTsvgDZDbHK+zvvacKHRrhCp+5AT1FdPfoKawSzKVjmElEqEaOltAzc5sLiDxr3j6tyuuqF5/BHk6Bz25Pg9LNWD2llZyHtWbiIUNK4GPLgLFPDPsFpaDBzVXKDc0+XjPsTOscYQkEez+pOZFAjva/6mAj5npLR5YOlYn0kbKzbOb9Kt0b3Rd9yp13OlsNLiYO3jjKMuotrTxH1gXy0nqtkZTI/L6luBqJVcqKbYYbWvf7+DntTCsiFdYdFAf0ThjZfX+ksdAa951LplkH8mKcEN7cjOBFILKCno/xRO3/RxQSlLIYVWvfESOY9E4Xvgvsi59tzTZia9dpfDVhmq6O66+DS0GA+wbPRtxDuP5bMqCaZBwX5jTEfxuWU6c+7/1Jwf0lGd/H905sP/fFh1Z8zpu/ti+q2/siCU3xuusrHwI9r6S6lZP57Y2gbCmm9+bBzxqN6zv09LT4hUaZhFpxOCFymDKG+BriNaeUP+hvDYgrzz09Jbkgm8cPek/ji8/rM78Oj24lat3Y6a1zbbZgc4HVaRimW+GUUCYYzUom+I1gT8Zezu/Z/WYtnwKYr7iwuWO19oGp07xe3QDhI25TcHFe0TqTCqOvd5FBGGhK6E+RsYWJN85JmFR7l16CW6BcdyPm6ILB3YM0y74YkXpEuEh3cdBTOCriA/6qorbW1ulYkE5KZgQ3mYL/VEhkj42ls7Zf2/+EQj5yXxavv9Y3BY/Qe+j+NyrOD/baWa3OxsnyxpviPML2g5LxkfEbQ3d7bXdD2s3ys5A72vg0sooprqTpCevDNa52Ssy4Rt0qtxlPJ0phswYZEd2B61WSd2Leoewe/x3Hoi0p8bAVfYodySa1k1xxHES1dm8fG9jqpz5vYPQ3kmNV5NIJ5eLSJ08PCTo0QHf9Ky2DxS8sQNoS6OVFYKnLfzv647R7+lEOlKIhl7rROl8I+J6mmPXqUzjLq/iliIj1zh7gpiGbMHIFfUj9afTUGCKgmNCqA/2Oh9ybPsNzCB8pSMME0YP+8ybXwAt2Ts4n8Z3zxQTg/LPzirEPUeCCsu8DtNimDp5udDUyqhEuUS9UxqYTzY5ECxRHf1GVeeZ4KfdNl8Lw1Q/bVFkr/tRdGTS6kPxaWAeqZRU6Ov9HOS1A5jc+b+4FkwNbhcS+Gwl7kiHDDgnqiffBMWk67J3N2XVUmupGMhU6Wb/gQ1fgHajrqryi27ybiu4s2VQr3iQSJ5duyo6uw2uouhOrMdKxFK2/JT0ZrrsiSnZISAMmLCzvLu+MXBtp6t0Q3F0C7bs4JvarcnYeQWeUVBR0QagpCzLbqqcJU+lePLSMSSoJGqZ9kZVTz6fgts/mrltwimJNHvX4pcCR3+d/3VryTK354WTbvGcZ26vuLWrZVPNtO61cDa6B3FOX6rvEjawuSIubtxIWIlVmeudrt7EWONqtf6ZtTdf33ArSIFLTrGALL2xGBqNL8tQPhqhmhJp/CvVLWolIHfKNEmdVfSfBGM23nS6WThC3myn+F2y1WDECkcG+OuOW4n73fplK5aw9QzUzLsiYfpwetl9Cnp0YTpAAgfi94c8gkzF6CyCgMjGYA1I47VpD6LX/2ovoyDy+AAIlyyms0efketMu5/9I6oEArT7yGgde3JqH+qL+HScgQ9uI29LDmMrgkn8nX9C19ytkNQzFdoD/m7ca7DXJ5HD1QkZR9dIjPX6n4KpHOl2NMpHV8zki14dtpm7oa4T6+r4bJGwKbItpSRMJoYZnOrVvo+6LCQauQZ9Xyw7k/Qply4vqlGQlrumDFlxrUZ8mfh83cD2DLBem4tr0gycG7h+kAVBM4PkcjZyTtaDuyqukjASkL44YMdsA2lCFlrwpytqD5zpuoj5NwRLlpPluNDuQI+MLCknO4jJXnBA6yMBIdC7a5uTtI83e9kMJIb14r8saxKKhKGvDV7LTzGgs2tq44HjJS3SBsCyjisOGNw2PaxiVfU4qUIwdZjQ6tOFp+SJxXN+iseexIr7BR2MbwnVqDLUQiGJgnG9vcZY74bEUx5PhrFQ+/+PAIiv9YG2TLno4bxdrS7jYti6w/LyI9fkZy4neRh6qE+K3XD7tqzB3YDlvqupTqUrvMhum0wp8SR+mYpek5pSfqf6gkYrNH15gjPw5kiI6x5J/SrTqgGQ1/7I6JPhX57u6jg6wkBDBoz1MZK45at6rqjKTXLQU8QsOoX7YxMWVVJbDNTXkGyxL0kjcRvz5fVReOgNAL5L6L2Lvi1m4OtyqdsaDEDp2urs5qW4sK0mR1BN7IdVJEWlqCRfIujQa+koUV+xJn1fDw4tbuPRjEtntz7ZxrYIWW1k1GVUwedaRa0CjEhrgmPEzhl6rfZZJNcQQz9ahmMEuf2T3Vq3970MbiP5kpQP6OA6hG5ZZfmoR424+/M9C9cgRSmN5898ClVtJz70BEbY+FZj6WrZqYJ3ZjqJWoSqR5EwDn3VnBfrFTfBK7Ul0NWBjAYFWvcd6daBvX6aa0EG4e8LiqDQerYiFxJpLocMoEE5azytHIVbtpDbC2Ig39xZd7YD0FOysqxBBc5GpQfLd9mriM4wRbmnqKuY5Csq2SjmDzdxzG8UAZ7Wey0x5ZN7I48FWjNy6RX+gB34hmL8XeRmxrxuK8ujsxYYsVoD07S6wjI3cbbKmKfTmuGggNCl6X7KtVIsdT7dzH2SFKkIw1veeWdXVcVBTqHIhULtp3QdZQftKSc2mZJCSq6bnQ1dEL5d2Hd9DDvy2t1GToREvGTl6VtEpi2pc87IQ+EQvvO/FavWHd+tC9SyemjtXN6oqtsey6lDlFrR6xz/JKgaXtGN5n9PxDSyyzzoHXznCHlM/qgDH8FF73X0KijQJNqXmDJaE+O5o19ffSyjBDoBNY5G4JDcoAg/K1h/38U4gYbp3Ki0h+4JG30XSefjRVz2SiXnfanVh2JQYSxp6BKgP+SjaVUcXu066HlvcFIvWDvd2DOlI7dUTNFL6aQzV5cpZqksQnipKVAJptwZSCFw88Bbd1sSz3uoAAyfE5Y90Si8YkU+572nRQoB2XBF7K6xb89tPqGhGSZAjlvIX1vKYcu/SIpWGVtn1KHuzmMmzQ4+kxKwddHZKO7pKT0J9DYi4y/zpJtKQ2Mqp3uMOH1Pq5/r4JW+FNxL6Ulea0qYl5aL4uTNmssDr3fB2QEQr2SwE3nQ8P2FwJNdwktJWM857BhIRTEw60S0ITLuG6b7AG8qVlKMuIUG8JzLyM1EUuRLeHP/n+qiTLC//rr0nXORWlaY/3vtXtvc7+5tscTYhaDkRztZeltDZBX3CJMTCV+IgKaDH8zmGEEXfMqz58ujYrDcL9vEJ65dWUv9ZNG2kEdpAyPbVpbK8FvTeGELHBwkmaP6YjhEcbR6zFp1QdcjPcgM8PK2UZ4lgXt9GppE5AE2HD0zvfT42XbhKD6iYxCKwcWmQK16NwPQrXo6RwPQrXo3A9zMzMzMzMzMzNzMzMzMzMzAAAAAAAAACAAEHnw4EBCwGgAEH3w4EBCwHIAEGHxIEBCwH6AEGWxIEBCwJAnABBpsSBAQsCUMMAQbbEgQELAiT0AEHFxIEBCwOAlpgAQdXEgQELAyC8vgBB5cSBAQsDKGvuAEH1xIEBCwP5ApUAQYTFgQELBEC3Q7oAQZTFgQELBBCl1OgAQaTFgQELBCrnhJEAQbPFgQELBYD0IOa1AEHDxYEBCwWgMalf4wBB08WBAQsFBL/JG44AQePFgQELBcUuvKKxAEHyxYEBCwZAdjprC94AQYLGgQELBuiJBCPHigBBksaBAQsGYqzF63itAEGhxoEBCweAehe3JtfYAEGxxoEBCweQrG4yeIaHAEHBxoEBCwe0Vwo/FmipAEHRxoEBC/g1oe3MzhvC0wAAAAAAAAAAoIQUQGFRWYQAAAAAAAAAAMilGZC5pW+lAAAAAAAAAAA6DyD0J4/LzgAAAAAAAAAAhAmU+Hg5P4EAAAAAAAAAQOULuTbXB4+hAAAAAAAAAFDeTmcEzcnyyQAAAAAAAACkliKBRUB8b/wAAAAAAAAATZ21cCuorcWdAAAAAAAAIPAF40w2Ehk3xQAAAAAAAChsxhvgw1bfhPYAAAAAAAAyx1wRbDqWCxOaAAAAAABAfzyzFQfJe86XwAAAAAAAEJ9LINtIuxrCvfAAAAAAANSGHvSIDbVQmXaWAAAAAIBEFBMx61DipD8UvAAAAACgVdkX/SXlGo5PGesAAAAACKvPXb43z9C40e+SAAAAAOXKoVqtBQMFJ8artwAAAECePUrxGcdDxrC3luUAAADQBc2cbW9c6nvOMn6PAAAAoiMAguSL8+Qagr9dswAAgIosgKLdbjCeoWIvNeAAACCtNyAL1UXeAqWdPSGMAAA0zCL0JkXWlUMOBY0prwAAQX8rsXCWTHvUUUbw89oAQBFfdt0MPA/NJPMrdtiIAMhq+2kKiKVTAO7vtpMOqwB6RXoEDeqOaIDpq6Q40tWA2NaYRZCkckHwcetmY6OFUEeGfyvapkdRbE6mQDwMpyTZZ1+2kJCZZQfiz1BLz9Btz0H347T0/59E7YESj4GCpCGJeg7x+L/HlWgi1/Ihow1qKxlSLfevObsC64xv6suQRHafpvj0mwhqwyVwC+X+tNVTR9A28gJFIpoXJidPn5BllCxCYtcB1qqAne/wIsf1frm30jpNQovV4IQrrev4st6nZYeJ4NJ3hQwzO0yTmy/riJ/0Vcxj1abP/0kfeML7JWvHcWu/PIqQw38cJxbzeu9FOU5G74tWOtrPcdjtl6y1y+Pwi3WX7MjQQ45O6b0Xo74c7e5SPSf7xNQxomPt3UvuY6iqp0z4HPskX0VelGrvdD6pyuiPNuQ57rbWdblEKxKOU/3is0RdyKlkTNPnFraWcai822BKOh3qvg/kkM0x/kbpVYm83YikpK4THbVBvr2YY6uraxSrzU2aWGTi0S3tfjyWlsbsiqBwYLd+jaI8VM/lHR78qK3IjDhl3rDLSylDX6UlOxLZ+q+G/hXdvp7zE7cO70mrx/wtFL8tijdDeGwyaTVulvl7OdkuuawEVJYHf8PCSfv32oePeufXBul7yV50M9z92ui0mazwhqNx7T27KKBpvBEjIsDXrKgMzmgN6jIIxCvWqyqwDdjSkAHDkKQ/CvXbZasajgjHg/rgedrGZyZ5Uj9WobHKuKQ4WRiRuAFwVybPqwle/ebNhm9etSYCTO14YQvGWl6wgLQFWzFYgU9U1jmOd/F13KAhx7E9rmFjaUzIcdVtkxPJ6TgezRk6vANfOs5KSXhY+yPHZUCgSKsEe+TAzi1LF512nD8oZA3rYpodcUL5HV3ElINPMr3QpTsAZQ2Td2V09Xlk437sRI/KIF/ou2q/aJnLHk7PE4uZfuh24mpF78K/fqYhw9jtP56iFJvFFquz7x4Q6vNO6c/F5eyAO+5K0JUSSnJY0fGhux8oYcqpXUS7l9yOrkVuiiomcvk8FHUV6r2TMhrXCS31WOcbpixpTZJWnF9wJiY8WS7hos93w+C2bIN3DLAvi296mYvDVfSY5EdklQ+c+20L7D83mrWY346sXr2JQb0kR+cPxQDjfpeyV7Ys7JHs7VjhU/bAm1493+3jN2e2ZykvbPSZWCFbhot07oIA0uB5vYdxwK7p8WeuEaqjgAZZ2OzpjXAaZO4B2pWUzCBIbw7osliGkP40QYjd3H8UjQUJMd7upzQ+glGqFdSfWfBGS72W6tHBzeLl1BrJB3CsGJ5snjIjmcCtD4Ww3QTGa8/iA0X/a78wmVOmHBWGt0aD24QW/0bvfH/oz2OaZ2UYZBLmbl+MFa5P8YF+wGA/j37LT0l375qZo22infA4DzNevuMcVasBgAwJy8UsB9O/9a1cYyoWAqBPy/3298jHL3PZc37aTQHEEZ+e+prd3P3nZygdUaEBNdZGxrgBFVT94YGyZaUJQsKL2PcmQhqpfFoiH18HRmlZV+eaWGmw6Y14dTM3iZfDLy2hwa6DHGSx1lIAhGt9tHt4CfKapCO9XYxnwDJjzlBN60WX4EY2lrq3QPj/+wGlIGYXvZjYwzup5VC2/3pCzqg/Xey+zrSKEx/lo9+M6YDJR7qTNwGxNmwzb8YX8CPhu9mouIRBXURHAAu4Hexs2SoQ0+blkXQVWcANppIT5Mca6kOQL9torTeYyId3GN15oeRUtPsRw5hFvroplF5U2MkdauF61vP+1m0p9B27NCeeUuKMDGZYX6bkmRjk6QGxRecasI9/LvfPXcBeXWRCHRehIdxzH/r0Q3Vwdrp+SXKuBJWJqFMceUpJBmpp3tsO2kX6q5JoYxed24cEA9aSklDX+Na2QjxdhNKpRcLFm1uShluGsqlFupIjigsyt4LyNmjypx4U12h3rGyO/2Qjr0QC79Em2QxDldcHMh8fdu1qYTWDuAfoSb3mRH/nptOoxbkCpKYJYpxsIBZfoZAIEzdoA80PjHrDh6jbNmRa5WsiISKAiZcs2lRJScL9sN4Ga6kqoGy9txCqm9vyPV2WyMVTNcjHrOWUlIKSb4z0uzq3qEL6+Rcfujkjd8vXeLWEcqlpnPtuUxQEdir/DdfiJc8ThMO6SmgZhRP1/tGMW+/CGGX0aV3CX2ZYsn4COJnVeS+/mGF62fs/dy/vA4b/Slj77r762M/6D1X7qoRnv10uuqruOM+D+VMqupWyoJf6XLQqlYNh8nt0WpTd34g9OXRhdbrk+e6aEXH5lBfrjEfRuRLpXbiqAVbNN3ruErjMIrSrkTqzCsFV4GKsqhfmfyuhFrYJYE0xa5h7V5Sd3192SZzjC7ig/YV+Wu19wuv76a1BjgdzhL4Tj1gUHLPmemQZ0rHIjyWu2LJuWeNfoJm9n0beu/Ou2Y5fym/uOwSA1iPsilRYDUi5e94l6UoFIMwsp61qrhCapxpWr6SdBij/9xDZBNqUgFGhKxuGIgR5/5qqh0IIXfDSRPuQKCtFV79BlalTSnSsBxY6NfJ1Fi0vkvrT6FyRl4mbiEK3CS58XZt8hBHauv41YZVpJYw52zTCm6WVkGl+g7n6Qy7vBxLCsgLPu/QDXuRn+ZR99URLua9hgfV4wrru4Bsd3DIWnqcbuqEyF3NpKtliZJO/m4WRoijK/tzPA3WPe314rwLnNcuy/D7Uw0RSc9pcq61hsAG/752nZPpqE4gIOhYZehzCrmvF0P24RRiqighbn5ijcprG9kU9J1eeVK2KmWM/pocgPJpLhnj24lSsNn88z4+pKMvA3acWtBtqV4SfC8Pz0/L98NVRHKGiRG1lQ+dZeMS3npYls7Gk5UpknxRhcJa1ZUa87h/eDZ9dPYdZeQz8Iv9X6+qnVdEGtQyp2MuH3XX/FpPyiNVCJPGnCc6+6VRTv9y3L+uKU23tEQyBLiQqKO/T5fqlbajIaBaPEJ1WGnl1pI+8h0RpfQFu+VVE7GDXko2zrKmVw9yByTdqVSc5jfdw4BcUe/RT4ruFYpW4Q7iaRoyO7Mx4dG2Vk7u6plRmQVivsicAl9HIejhqadDpv1Eu254xwPwFe5kG4kEi8hfz/IgDH/i94+wfRFrSqu7dLzyrwyZ2rRzoJ9XxhlVq1TsL1nSw09gj4nGKVnR1YmUFx4VJToRnVi2H9mzREru+xjin22FlAaz4KLTHhddpbvgG0VK6vgHXNjPhnLMmAkVbpIJzNBdhRgLA7IRgsEIWck2jkAFd+dcC8CeleFzTm84gzPRBtPeNA+wxzpYzyEICKf9xUqF1cQRnfkE+IL1poXmfhtOE6cZiAA/RTWgsxAlYx2gI5qN4e8BSRWGCNzUMLvmCit/MVppwp8t8sUKhx7ybkbYLQHZgpoj+212TifmrwjWkDtCT+M9q/lI1+Ov3VvNDTRLEuPaDBd5TIXvzWhaYSnCLejN6csPWqOlZsPEbvlxMLlnAGE90DBNkcBzuou1z33lv8N5iEeeLPsbR1IWUqCusRVbL3YrhLs43BkqnuZI2F9crPpVtmbrBxYccEeg3BN3Mto36yKAUmdvUsQqRoiIKQJKYnB3IWX8SSl5NtUurDNC2vgMlOjAfl9y1oOId1g+EZK5ELiR+c96pcaSN0uWJ0v7s6lytXRBWFI4NsUdfLIc+qCV0GHWUa5nxUN0Zd/coThIv0S/JPOP/llKKb6qa2XBrvYJ7+wvcvzznrAtVARBNxmxjWvoO0+8LIdhOqgFU4PdHPHhc6eN1pxSHcQqBNOz6rGWWs+NcU9HZqA1NoUGnORh/fKAcNKhFENNQoAkSEUjeHk3kkSCJK+qDMgRGqwrtSpNgXbZoa7bkpD+FF1ZNqB34ufTjQgbkHc6OZp2rYBIlNvN4zumDrtKAGWBCa3wr18EwF0LkJFoHoR/4EoZb9kyy/JxSHa4wSckntpdn8jPg3jxEp6TZfJv7saN9Ae9AmBaliugGCC5BnU6G7mCVKB+OTq2iCIp5kcTiJyq5uvKm8aJYy4rs17X127F0Z2mvEK5lF7/W86aRmSnvqOChbcqsP91uzLAQ9r/zKtNYCgn9F46Uiv/clPPvsPUH70xL/N3ZnLYfCj34lY75ZBUQr71KD0Skp0xMdrvxN74a1BptnRNVjdFf31Pq7cVtIYlhyIQsVfjim2t0krSb5LT1PP0yd2q224KGEbehwh0iM4y8PxUFpJIj6NXkSjOl6j+vqw8tg6Y7FrEFjw5Ap/KHTcsp+COQylsdx7ISEFHv6SA+dPYsNL2y5HjfFlQlaySpTZEanEC2746ri45U98K2idAaIMPQo6tylq6xKbVzJKyEoejzxIxWDzzaHnSikC3X5clxGPsXlolliJKIZXp8pi9+jd75nfvrfqq36v6YG5C73TFWeIX6ph7VZaU+fyJ0KlXeNWuTXCgzhV8nh4+ViDrVVgNGuHPyf6Y38WjzuiqJiiyEV6YQ7x/QhS1DsGl1Ky2bsvZnavUTgnP8KQ5iKTucQl/0AcXymKKPe7SRuvNJgxN3cUJ2Lz/Lc5ohNqlwHCTX1A3TU/sO/hABqoPTjCPtBqXoYxRdyZ6qQEoyBDg29EjO4nxZtHvG1dDcPgXGQ7HagRvcb6Ea+AoFlI6Gt5TdKDGR6eWkEJsmgxwZtPJ8ynJ99WMfztTB8KNjH2EvHP3P3PI8pwFK8uyMPGc5O2O8AcoXhghBbpcT2IXgAwW+1YK8nadK0Um9GE6n2ESGLUuiK4VRnUWc7J4h0Q7W5/jdRTvzUoKr4ZMDtULJ5ZC7yhcKsOdiFtq4Q2KTOx91aj2dDJyh+5sQ59Q6eApnEsUM4ocBRX1hapDFJItmgCv7J9rpQZbc+YS09u0tgGD2+bFRZNK7Uzim4XNpOaD4c3hesn5jVTTjB43o4SNke0gL219evGoB3EmwYtosPZoazpH3dWvFAVNc3PsQeMxAoUF2uiljG+GzuYmdCst/yATpqSn0O2LZICisRM29n/pFY1Qz8cq6Dyky15VArUd5F3ypwNa+1KlZf4ZdSMzMq47tSXCM7kkUMB+odFr/v1byaFyML2pcGfwm0hEx/2/sLoNzt13C2Y9dWIOrfv/FU/0xyCX1MtDzdC6kVV5/t6h8Prpvsj/EMBI6zes1X+XSG84ohc+nel5LRICzgVvPY9GAeWbDURk2XlWgH2Iyw7wF4ddANKafw7VqyKf6/vMrR9mNUMGPhzRjhfpRuf7w9phPsdLYudQAXpOc0zOfVpq/0W4HT+gJgTW4w8gAR+yAL4YKyGJiTOFCpvT6wFgnYbsnzb19vc/M6eeYnHiXuBzVOIAs3awDQOQhv8NWveZjCkfgeBSYBFBd6u50rGzg/MxYGMsM3wJSelKVyOtDDB6ANw/9z5aD5hinurrmVI8lYAXT/YN8JCDfUOlpICrzLrjGR37SzRZ0i9KRQVT6Vx0z3EwdR4EcUS5HtlLp+K3kPxPg5ZihY+X52OOmI3fZ3Q8YWI//RF4vnGeOSHbqp+oJD1fUCAAAPAAAAAQAAADVCAAA1AgAADwAAAAEAAAA1ggAANQIAAA8AAAABAAAANcIAADUCAAAPAAAAAQAAADYCAAA2QgAADAAAAAEAAAA2ggAANkIAAAwAAAABAAAANsIAADZCAAAMAAAAAQAAADcCAAA2QgAADAAAAAEAAAA3QgAANkIAAAwAAAABAAAAN4IAADZCAAAMAAAAAQAAADfCAAA2QgAADAAAAAEAAAA4AgAANkIAAAwAAAABAAAAOEIAADZCAAAMAAAAAQAAADiCAAA2QgAADAAAAAEAAAA4wgAANkIAAAwAAAABAAAAOQIAADZCAAAMAAAAAQAAADlCAAA2QgAADAAAAAEAAAA5ggAANkIAAAwAAAABAAAAOcIAADZCAAAMAAAAAQAAADoCAAA2QgAADAAAAAEAAAA6QgAANkIAAAwAAAABAAAAOoIAADZCAAAMAAAAAQAAADrCAAA2QgAADAAAAAEAAAA7AgAANkIAAAwAAAABAAAAO0IAADZCAAAMAAAAAQAAADuCAAA2QgAADAAAAAEAAAA7wgAANkIAAAwAAAABAAAAPAIAADZCAAAMAAAAAQAAADxCAAA2QgAADAAAAAEAAAA8ggAANkIAAAwAAAABAAAAPMIAADZCAAAMAAAAAQAAAD0CAAA2QgAADAAAAAEAAAA9QgAANkIAAAwAAAABAAAAPYIAADZCAAAMAAAAAQAAAD3CAAA2QgAADAAAAAEAAAA+AgAANkIAAAwAAAABAAAAPkIAAD6CAAANAAAAAQAAAD7CAAA/AgAAEgAAAAEAAAA/QgAAPwIAABIAAAABAAAAP4IAAD8CAAASAAAAAQAAAD/CAAA/AgAAEgAAAAEAAAAAAkAAPwIAABIAAAABAAAAAEJAAD8CAAASAAAAAQAAAACCQAA/AgAAEgAAAAEAAAAAwkAAPwIAABIAAAABAAAAAQJAAAFCQAAOAAAAAQAAAAGCQAABwkAADwAAAAEAAAACAkAAAcJAAA8AAAABAAAAAkJAAAKCQAAOAAAAAQAAAALCQAACgkAADgAAAAEAAAADAkAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAAEB4IAAlAAAAZXggACEAAAAoCxAAcAAAAOcCAAAJAAAAdQkQAGoAAADPAAAATQAAAHUJEABqAAAAzwAAACUAAAB1CRAAagAAANkAAAAkAAAAdQkQAGoAAADuAAAAQAAAAHUJEABqAAAA7gAAACEAAABDYW5ub3QgY29udmVydCBhbGwgbG9naWNhbCBpbmRpY2VzIHRvIHBoeXNpY2FsIGluZGljZXMuIFRoZSBsb2dpY2FsIGluZGV4IGNhbm5vdCBiZSBjb252ZXJ0ZWQgaXMgLgAA+HggAGEAAABZeSAAAQAAAHUJEABqAAAA5AAAADMAAAB1CRAAagAAAOQAAAAUAAAAdQkQAGoAAADmAAAAIQAAAIFBEAB0AAAA5AAAAA4AAACBQRAAdAAAACsBAAAdAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAOAAAAAUAAAAkVxAAaQAAAEkAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAAB+AAAAJgAAAGJQEABrAAAAuAAAADwAAABiUBAAawAAAL0AAAA8AAAAwHHNK/WXKix1JwoV9WuZpP/sWnXFLhhxAXp4pMJb1YsKUbMsEqoS6gtZ3tvU7Lw550xQaoiymrNlSfixTbRc0u2i5dR7gLHU18EfJ15f4lzHLP3sJdo49w2Zk8JQSsynpBddj0p1IC1jlr4w3kLr7FPsFN832yXIIqwHEQap00w1/BFl7VJvvic5lf96AVLltaHfx+CoTEOS/RHiY2P8o/x1Tsx746Hy2vGnwXyEA6lh4Uw58D9xxI2UeLFznFnnZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoCUZ972aqE6KmHG/D5dJSpk4YAFII7TEaZo+oYpJXtP/vkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7r6cKpGRNjRgxUhAFxEOmzTBIwqVzdYosIMWX2rfa8zfEM/MnaU1JGkI+ioAjhXJQih84uvui+8ZAoQoWMa5/RaXKGzT/eMq2XzR7IFAx7B2H6FPxPwhQSHWIsWI6dexeEyaqF8hLELkfkWDr4NtNVxGpu7MUIMKvDpp5K2w0/FMk4m7jkYJLOcYSTiNQ4gt6XJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM4//WmAXKflpr1eEeiUAqJElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6cqR+SE8zMHNwHKQ9JGz7zovaqMy4nsb0sFHeC4yfroRriAXRBZEN4LnG7yT5gwTh7psyuBSe0blwx3izQVgXEULG3a5ecqOE5Qkdk3/h0aikTTxuSgtUEM2dlrg+EgUYeztWDRc3PkYZQ+mHf4UcUpXGSEtF/rhGs2cet9Q4ijJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh1zIQAHgAAADrBwAACQBB1PyBAQuFAQEAAAANCQAATGF5b3V0RXJyb3IAsQcQAG0AAABMAAAACgAAAA4JAABkAAAABAAAAA8JAADOdRAAagAAAL0BAAAdAAAAznUQAGoAAACnAQAAHwAAABAJAAAwAAAABAAAABEJAAASCQAANAAAAAQAAAATCQAAFAkAACwAAAAEAAAAFQkAAAEAQeT9gQEL3hAWCQAAKAAAAAQAAAAXCQAAFgkAACgAAAAEAAAAGAkAABYJAAAoAAAABAAAABkJAABUYWtlIG9ubHkgc3VwcG9ydGVkIGZvciBpbnRlZ2VycywgZ290IAAAFH8gACYAAABBcnJheSBpbmRleCBvdXQgb2YgYm91bmRzLCBjYW5ub3QgZ2V0IGl0ZW0gYXQgaW5kZXggIGZyb20gIGVudHJpZXMAAER/IAA0AAAAeH8gAAYAAAB+fyAACAAAAENhc3QgdG8gdXNpemUgZmFpbGVk2QgAADAAAAAEAAAATAMAABoJAABOAwAAGwkAABwJAABQAwAAUQMAAFIDAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAFMDAAAeCQAAVQMAAB8JAAAcCQAAVwMAAPkBAAD6AQAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAVAwAAIAkAABcDAAAhCQAAHAkAABoDAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAIgMAACIJAAAkAwAAIwkAABwJAAAmAwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAFgDAAAkCQAAWgMAACUJAAAcCQAAXAMAAFEDAABSAwAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAABdAwAAJgkAAF8DAAAnCQAAHAkAAGEDAAD5AQAA+gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAGwMAACgJAAAdAwAAKQkAABwJAAAfAwAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAACcDAAAqCQAAKQMAACsJAAAcCQAAKwMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAD0AQAALAkAAPYBAAAtCQAAHAkAAPgBAAD5AQAA+gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAQgMAAC4JAABEAwAALwkAABwJAABGAwAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAEcDAAAwCQAASQMAADEJAAAcCQAASwMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAMBwAAMgkAAA4HAAAzCQAAHAkAABAHAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAFgcAADQJAAAYBwAANQkAABwJAAAaBwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAAcHAAA2CQAACQcAADcJAAAcCQAACwcAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAARBwAAOAkAABMHAAA5CQAAHAkAABUHAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAA+wEAADoJAAD9AQAAOwkAABwJAAD/AQAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAAICAAA8CQAABAIAAD0JAAAcCQAABgIAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAACBwAAPgkAAAQHAAA/CQAAHAkAAAYHAADRAQAA0gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAACQIAAEAJAAALAgAAQQkAABwJAAANAgAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAA4CAABCCQAAEAIAAEMJAAAcCQAAEgIAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAADLAQAARAkAAM0BAABFCQAAHAkAANABAADRAQAA0gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAA3gEAAEYJAADgAQAARwkAABwJAADiAQAA4wEAAOQBAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAQdCOggELxSRibxAAYAAAAMsAAABJAAAAFAkAACwAAAAEAAAAAgMAAEgJAAAEAwAASQkAAEoJAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAANkIAAAwAAAABAAAAC4DAABLCQAAMAMAAEwJAAAcCQAAMgMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAzAwAATQkAADUDAABOCQAAHAkAADcDAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAOAMAAE8JAAA6AwAAUAkAABwJAAA8AwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAD0DAABRCQAAPwMAAFIJAAAcCQAAQQMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAArBwAAUwkAAC0HAABUCQAAHAkAAC8HAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAJgcAAFUJAAAoBwAAVgkAABwJAAAqBwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAACEHAABXCQAAIwcAAFgJAAAcCQAAJQcAAAACAAABAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAA6BwAAWQkAADwHAABaCQAAHAkAAD4HAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAMAcAAFsJAAAyBwAAXAkAABwJAAA0BwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAADUHAABdCQAANwcAAF4JAAAcCQAAOQcAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADUCAAAPAAAAAQAAABYBwAAXwkAAFoHAABgCQAAYQkAAF0HAABeBwAAXwcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAYm8QAGAAAAAgAQAAEgAAAAUJAAA4AAAABAAAABMCAABiCQAAFQIAAGMJAABkCQAAGAIAAGUJAABmCQAAGwIAAB0JAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAADUCAAAPAAAAAQAAABqBwAAZwkAAGwHAABoCQAAYQkAAG4HAABvBwAAcAcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAABwkAADwAAAAEAAAAMQYAAGkJAAAzBgAAagkAAGsJAAA2BgAANwYAADgGAAA5BgAAHQkAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAANQIAAA8AAAABAAAAIsHAABsCQAAjQcAAG0JAABhCQAAjwcAAF4HAABfBwAAYAcAAB0JAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADUCAAAPAAAAAQAAACQBwAAbgkAAJIHAABvCQAAYQkAAJQHAABvBwAAcAcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAABwkAADwAAAAEAAAARAYAAHAJAABGBgAAcQkAAGsJAABIBgAANwYAADgGAAA5BgAAHQkAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAAoJAAA4AAAABAAAAOUEAAByCQAA5wQAAHMJAABkCQAA6gQAAOsEAADsBAAA7QQAAB0JAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABibxAAYAAAAOEAAAASAAAA+ggAADQAAAAEAAAAnAQAAHQJAACeBAAAdQkAAHYJAAChBAAAdwkAAHgJAACkBAAAHQkAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAAoJAAA4AAAABAAAAPgEAAB5CQAA+gQAAHoJAABkCQAA/AQAAP0EAAD+BAAA7QQAAB0JAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAASCQAANAAAAAQAAACHAQAAewkAAIkBAAB8CQAAfQkAAIwBAAB+CQAAfwkAAI8BAAAdCQAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAYm8QAGAAAAAvAQAAIAAAAGJvEABgAAAAMAEAAEcAAAAQCQAAMAAAAAQAAADXBQAAgAkAANkFAACBCQAAggkAANwFAADdBQAA3gUAAN8FAAAdCQAAgwkAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAAhAkAAAgAAAAEAAAAcgIAAHMCAAB0AgAAhQkAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAGJvEABgAAAANQEAABoAAABibxAAYAAAADsBAABHAAAAYm8QAGAAAAA+AQAAWQAAAPwIAABIAAAABAAAAE4GAACGCQAAUAYAAIcJAACICQAAUwYAAFQGAABVBgAAVgYAAFcGAABYBgAAWQYAAFoGAABbBgAAXAYAAF0GAABeBgAAXwYAAGAGAAD8CAAASAAAAAQAAABhBgAAiQkAAGMGAACKCQAAiAkAAGUGAABmBgAAZwYAAGgGAABXBgAAWAYAAGkGAABaBgAAWwYAAFwGAABqBgAAawYAAGwGAABtBgAA/AgAAEgAAAAEAAAAbgYAAIsJAABwBgAAjAkAAIgJAAByBgAAcwYAAHQGAAB1BgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAAB5BgAAegYAAPwIAABIAAAABAAAAHsGAACNCQAAfQYAAI4JAACICQAAfwYAAIAGAACBBgAAggYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAhgYAAIcGAAD8CAAASAAAAAQAAACIBgAAjwkAAIoGAACQCQAAiAkAAIwGAABUBgAAVQYAAI0GAABXBgAAWAYAAI4GAABaBgAAWwYAAFwGAACPBgAAXgYAAJAGAACRBgAA/AgAAEgAAAAEAAAAkgYAAJEJAACUBgAAkgkAAIgJAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAPwIAABIAAAABAAAAJwGAACTCQAAngYAAJQJAACICQAAoAYAAHMGAAB0BgAAoQYAAFcGAABYBgAAdgYAAFoGAABbBgAAXAYAAHcGAAB4BgAAogYAAKMGAAD8CAAASAAAAAQAAACkBgAAlQkAAKYGAACWCQAAiAkAAKgGAACABgAAgQYAAKkGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAKoGAACrBgAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgZGljdGlvbmFyeSBrZXkgdHlwZTogANCSIABLAAAAYm8QAGAAAAALAQAAJwAAAG5vdCBpbXBsZW1lbnRlZDogVGFrZSBub3Qgc3VwcG9ydGVkIGZvciBkaWN0aW9uYXJ5IHR5cGUgNJMgADgAAABibxAAYAAAAA0BAAASAAAADgkAAGQAAAAEAAAAsgQAAJcJAAC0BAAAmAkAAJkJAAC3BAAAuAQAALkEAAC6BAAAHQkAALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAMEEAADCBAAAwwQAABYJAAAoAAAABAAAAJoJAACbCQAAnAkAAJ0JAACeCQAAnwkAAKAJAAChCQAAogkAAKMJAACDCQAApAkAAKUJAACmCQAApwkAAKgJAACpCQAAqgkAAKsJAAAWCQAAKAAAAAQAAACsCQAArQkAAK4JAACvCQAAngkAALAJAACgCQAAoQkAAKIJAACjCQAAgwkAALEJAAClCQAApgkAAKcJAACyCQAAqQkAAKoJAACrCQAAFgkAACgAAAAEAAAAswkAALQJAAC1CQAAtgkAAJ4JAAC3CQAAoAkAAKEJAACiCQAAowkAAIMJAAC4CQAApQkAAKYJAACnCQAAuQkAAKkJAACqCQAAqwkAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHVuc3VwcG9ydGVkIHJ1biBlbmQgaW5kZXggdHlwZTogAADklCAASgAAAGJvEABgAAAADwEAACoAAABub3QgaW1wbGVtZW50ZWQ6IFRha2Ugbm90IHN1cHBvcnRlZCBmb3IgcnVuIHR5cGUgAAAASJUgADEAAABibxAAYAAAABEBAAASAAAAbm90IGltcGxlbWVudGVkOiBUYWtlIG5vdCBzdXBwb3J0ZWQgZm9yIGRhdGEgdHlwZSAAAJSVIAAyAAAAYm8QAGAAAABfAQAADgAAAGJvEABgAAAA2wEAABcAAABibxAAYAAAANwBAAANAAAAYm8QAGAAAADjAQAAEQAAAGJvEABgAAAA7AEAABoAAABibxAAYAAAAO8BAAAUAAAAYm8QAGAAAADmAQAAGQAAAGJvEABgAAAA5gEAAD8AAABibxAAYAAAAOcBAAAVAAAAYm8QAGAAAADzAQAAEQAAAGJvEABgAAAA/gEAABoAAABibxAAYAAAAAMCAAAYAAAAYm8QAGAAAAD3AQAAHQAAAGJvEABgAAAA9wEAAEMAAABibxAAYAAAAPkBAAAVAAAAYm8QAGAAAAAIAgAAEQAAAGJvEABgAAAAEwIAABoAAABibxAAYAAAABcCAAAYAAAAYm8QAGAAAAAMAgAAHQAAAGJvEABgAAAADAIAAEMAAABibxAAYAAAAA4CAAAVAAAAYm8QAGAAAAAcAgAAJAAAAGJvEABgAAAAHQIAABEAAABibxAAYAAAACgCAAAaAAAAYm8QAGAAAAAvAgAAGAAAAGJvEABgAAAAIQIAAB0AAABibxAAYAAAACECAABDAAAAYm8QAGAAAAAjAgAAFQAAAGJvEABgAAAA1wIAADcAAABibxAAYAAAANcCAABVAAAAYm8QAGAAAADYAgAATwAAAGJvEABgAAAA0QIAAFcAAABibxAAYAAAANICAABDAAAAYm8QAGAAAAAWAwAAGwAAAGJvEABgAAAAGgMAABEAAABibxAAYAAAADkDAAAZAAAAYm8QAGAAAAAoAwAAGQAAAGJvEABgAAAAKQMAABcAAABibxAAYAAAACsDAAAZAAAAYm8QAGAAAAAxAwAAGAAAALwJAAAwAAAABAAAAL0JAABUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBQcmltaXRpdmVBcnJheSBvZiBsZW5ndGggAABgmCAAJQAAAIWYIAAhAAAAKAsQAHAAAADnAgAACQAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAADgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAApBddj0p1IC1jlr4w3kLr7NcyEAB4AAAA6wcAAAkAQaCzggEL1hQBAAAAvgkAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADqARAAZgAAAAcBAAAfAAAA6gEQAGYAAAAKAQAAGAAAAL8JAAAIAAAABAAAAHICAABzAgAAdAIAAMAJAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAACbNBAAYgAAACQCAAAvAAAAmzQQAGIAAAD7AgAAGAAAAJs0EABiAAAABAMAABgAAABTZRAAZgAAAIEAAAArAAAAU2UQAGYAAACdAAAAKQAAAFNlEABmAAAArgAAACMAAABTZRAAZgAAAK8AAAAbAAAAU2UQAGYAAACvAAAAMgAAAG92ZXJmbG93U2UQAGYAAACxAAAAKQAAAFNlEABmAAAAAgEAACsAAABTZRAAZgAAAAMBAAA2AAAAU2UQAGYAAAAKAQAALAAAAFNlEABmAAAADAEAACUAAABTZRAAZgAAAA0BAAAiAAAAU2UQAGYAAAANAQAAHQAAAENhc3QgdG8gdXNpemUgZmFpbGVkT3V0LW9mLWJvdW5kcyBpbmRleCBImyAAFAAAAGJvEABgAAAApQEAAB4AAABibxAAYAAAAKwBAAAaAAAAvAkAADAAAAAEAAAAFQMAAMEJAAAXAwAAwgkAAMMJAAAaAwAAAAIAAAECAADTAQAAxAkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAGJvEABgAAAAUQEAACIAAAAuJBAAYgAAAJ8AAAAgAAAALiQQAGIAAACgAAAAJwAAAC4kEABiAAAANAEAAEkAAAAuJBAAYgAAAEABAAA8AAAAmzQQAGIAAABzAgAAGQAAAJs0EABiAAAAdAIAABcAAABpbGxlZ2FsIG9mZnNldCByYW5nZZs0EABiAAAAdQIAADsAAADGCQAAPAAAAAQAAADHCQAAxgkAADwAAAAEAAAAyAkAAMYJAAA8AAAABAAAAMkJAADGCQAAPAAAAAQAAADKCQAAywkAADAAAAAEAAAAzAkAAMsJAAAwAAAABAAAAM0JAADLCQAAMAAAAAQAAADOCQAAywkAADAAAAAEAAAAzwkAAMsJAAAwAAAABAAAANAJAADLCQAAMAAAAAQAAADRCQAAywkAADAAAAAEAAAA0gkAAMsJAAAwAAAABAAAANMJAADLCQAAMAAAAAQAAADUCQAAywkAADAAAAAEAAAA1QkAAMsJAAAwAAAABAAAANYJAADLCQAAMAAAAAQAAADXCQAAywkAADAAAAAEAAAA2AkAAMsJAAAwAAAABAAAANkJAADLCQAAMAAAAAQAAADaCQAAywkAADAAAAAEAAAA2wkAAMsJAAAwAAAABAAAANwJAADLCQAAMAAAAAQAAADdCQAAywkAADAAAAAEAAAA3gkAAMsJAAAwAAAABAAAAN8JAADLCQAAMAAAAAQAAADgCQAAywkAADAAAAAEAAAA4QkAAMsJAAAwAAAABAAAAOIJAADLCQAAMAAAAAQAAADjCQAAywkAADAAAAAEAAAA5AkAAMsJAAAwAAAABAAAAOUJAADLCQAAMAAAAAQAAADmCQAAywkAADAAAAAEAAAA5wkAAMsJAAAwAAAABAAAAOgJAADLCQAAMAAAAAQAAADpCQAAywkAADAAAAAEAAAA6gkAAMsJAAAwAAAABAAAAOsJAADsCQAASAAAAAQAAADtCQAA7AkAAEgAAAAEAAAA7gkAAOwJAABIAAAABAAAAO8JAADsCQAASAAAAAQAAADwCQAA7AkAAEgAAAAEAAAA8QkAAOwJAABIAAAABAAAAPIJAADsCQAASAAAAAQAAADzCQAA7AkAAEgAAAAEAAAA9AkAAPUJAAA8AAAABAAAAPYJAAD1CQAAPAAAAAQAAAD3CQAA+AkAADgAAAAEAAAA+QkAAPgJAAA4AAAABAAAAPoJAABhcnJheSBkYXRhIHR5cGUgbWlzbWF0Y2hwnyAAGAAAAIFBEAB0AAAADwEAAAkAAACBQRAAdAAAABUBAAAdAAAACEEQAHgAAACaAAAAIgAAAAhBEAB4AAAAowAAACQAAAAIQRAAeAAAAKkAAAAiAAAACEEQAHgAAACmAAAAHgAAAAhBEAB4AAAAmwAAACIAAAAIQRAAeAAAAK4AAAA/AAAACEEQAHgAAACuAAAAJwAAAAhBEAB4AAAArQAAABwAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAO2i5dR7gLHU18EfJ15f4lzHLP3sJdo49w2Zk8JQSsynpBddj0p1IC1jlr4w3kLr7FPsFN832yXIIqwHEQap00w1/BFl7VJvvic5lf96AVLltaHfx+CoTEOS/RHiY2P8o/x1Tsx746Hy2vGnwXyEA6lh4Uw58D9xxI2UeLFznFnnZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoCUZ972aqE6KmHG/D5dJSpk4YAFII7TEaZo+oYpJXtP/vkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7r6cKpGRNjRgxUhAFxEOmzTBIwqVzdYosIMWX2rfa8zfEM/MnaU1JGkI+ioAjhXJQih84uvui+8ZAoQoWMa5/RaXKGzT/eMq2XzR7IFAx7B2H6FPxPwhQSHWIsWI6dexeEyaqF8hLELkfkWDr4NtNVxGpu7MUIMKvDpp5K2w0/FMk4m7jkYJLOcYSTiNQ4gt6XJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM4//WmAXKflpr1eEeiUAqJElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6ClGzLBKqEuoLWd7b1Oy8OXKkfkhPMzBzcBykPSRs+86L2qjMuJ7G9LBR3guMn66Ea4gF0QWRDeC5xu8k+YME4e6bMrgUntG5cMd4s0FYFxFCxt2uXnKjhOUJHZN/4dGopE08bkoLVBDNnZa4PhIFGHs7Vg0XNz5GGUPph3+FHFJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh+wkAAPwJAAAMAAAABAAAAP0JAAD+CQAAxwcAQYDIggELXQEAAAD/CQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQBB6MiCAQttAQAAAAAKAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAATGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAAEKAAA0AAAABAAAAAIKAAADCgAALAAAAAQAAAAECgAAAQBB4MmCAQvNOAUKAAAoAAAABAAAAAYKAAAFCgAAKAAAAAQAAAAHCgAABQoAACgAAAAEAAAACAoAAC4kEABiAAAANgAAABsAAAD1CQAAPAAAAAQAAAAxBgAACQoAADMGAAAKCgAACwoAADYGAAA3BgAAOAYAADkGAAAMCgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAA9QkAADwAAAAEAAAARAYAAA0KAABGBgAADgoAAAsKAABIBgAANwYAADgGAAA5BgAADAoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAC4kEABiAAAAcwAAABoAAAAuJBAAYgAAAIsAAAAFAAAA7AkAAEgAAAAEAAAAkgYAAA8KAACUBgAAEAoAABEKAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAC4kEABiAAAAegAAABgAAADsCQAASAAAAAQAAACkBgAAEgoAAKYGAAATCgAAEQoAAKgGAACABgAAgQYAAKkGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAKoGAACrBgAA7AkAAEgAAAAEAAAATgYAABQKAABQBgAAFQoAABEKAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAOwJAABIAAAABAAAAIgGAAAWCgAAigYAABcKAAARCgAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAADsCQAASAAAAAQAAABuBgAAGAoAAHAGAAAZCgAAEQoAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAA7AkAAEgAAAAEAAAAnAYAABoKAACeBgAAGwoAABEKAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAOwJAABIAAAABAAAAGEGAAAcCgAAYwYAAB0KAAARCgAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAADsCQAASAAAAAQAAAB7BgAAHgoAAH0GAAAfCgAAEQoAAH8GAACABgAAgQYAAIIGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAIYGAACHBgAALiQQAGIAAACzAAAAGQAAAPgJAAA4AAAABAAAAPgEAAAgCgAA+gQAACEKAAAiCgAA/AQAAP0EAAD+BAAA7QQAAAwKAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAAuJBAAYgAAALgAAAAgAAAALiQQAGIAAAC5AAAALQAAAC4kEABiAAAAugAAABsAAAD4CQAAOAAAAAQAAADlBAAAIwoAAOcEAAAkCgAAIgoAAOoEAADrBAAA7AQAAO0EAAAMCgAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAywkAADAAAAAEAAAAywEAACUKAADNAQAAJgoAACcKAADQAQAA0QEAANIBAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAF0DAAAoCgAAXwMAACkKAAAnCgAAYQMAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAnAwAAKgoAACkDAAArCgAAJwoAACsDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAIgMAACwKAAAkAwAALQoAACcKAAAmAwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADoHAAAuCgAAPAcAAC8KAAAnCgAAPgcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAARBwAAMAoAABMHAAAxCgAAJwoAABUHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAWAMAADIKAABaAwAAMwoAACcKAABcAwAAUQMAAFIDAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAEIDAAA0CgAARAMAADUKAAAnCgAARgMAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAOAgAANgoAABACAAA3CgAAJwoAABICAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAFgcAADgKAAAYBwAAOQoAACcKAAAaBwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAPQBAAA6CgAA9gEAADsKAAAnCgAA+AEAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAA9AwAAPAoAAD8DAAA9CgAAJwoAAEEDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAA+wEAAD4KAAD9AQAAPwoAACcKAAD/AQAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAACEHAABACgAAIwcAAEEKAAAnCgAAJQcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAACBwAAQgoAAAQHAABDCgAAJwoAAAYHAADRAQAA0gEAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAGwMAAEQKAAAdAwAARQoAACcKAAAfAwAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADAHAABGCgAAMgcAAEcKAAAnCgAANAcAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAmBwAASAoAACgHAABJCgAAJwoAACoHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAFQMAAEoKAAAXAwAASwoAACcKAAAaAwAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADgDAABMCgAAOgMAAE0KAAAnCgAAPAMAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAHBwAATgoAAAkHAABPCgAAJwoAAAsHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAA3gEAAFAKAADgAQAAUQoAACcKAADiAQAA4wEAAOQBAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAC4DAABSCgAAMAMAAFMKAAAnCgAAMgMAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAMBwAAVAoAAA4HAABVCgAAJwoAABAHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAANQcAAFYKAAA3BwAAVwoAACcKAAA5BwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAACsHAABYCgAALQcAAFkKAAAnCgAALwcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAACAgAAWgoAAAQCAABbCgAAJwoAAAYCAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAACQIAAFwKAAALAgAAXQoAACcKAAANAgAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAEwDAABeCgAATgMAAF8KAAAnCgAAUAMAAFEDAABSAwAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAABHAwAAYAoAAEkDAABhCgAAJwoAAEsDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAMwMAAGIKAAA1AwAAYwoAACcKAAA3AwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAFMDAABkCgAAVQMAAGUKAAAnCgAAVwMAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAADCgAALAAAAAQAAAACAwAAZgoAAAQDAABnCgAAaAoAAAcDAAAIAwAACQMAAAoDAAALAwAADAMAAA0DAAAOAwAADwMAABADAAARAwAAEgMAABMDAAAUAwAAxgkAADwAAAAEAAAAWAcAAGkKAABaBwAAagoAAGsKAABdBwAAXgcAAF8HAABgBwAADAoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGUuJBAAYgAAAOkAAAAOAAAAxgkAADwAAAAEAAAAiwcAAGwKAACNBwAAbQoAAGsKAACPBwAAXgcAAF8HAABgBwAADAoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAMYJAAA8AAAABAAAAGoHAABuCgAAbAcAAG8KAABrCgAAbgcAAG8HAABwBwAAYAcAAAwKAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADGCQAAPAAAAAQAAACQBwAAcAoAAJIHAABxCgAAawoAAJQHAABvBwAAcAcAAGAHAAAMCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAAQoAADQAAAAEAAAAhwEAAHIKAACJAQAAcwoAAHQKAACMAQAAdQoAAHYKAACPAQAADAoAAJEBAACSAQAAkwEAAJQBAACVAQAAlgEAAJcBAACYAQAAmQEAAC4kEABiAAAAOwEAADcAAAAuJBAAYgAAAFABAAAzAAAABQoAACgAAAAEAAAArAkAAHcKAACuCQAAeAoAAHkKAACwCQAAoAkAAKEJAACiCQAAowkAAHoKAACxCQAApQkAAKYJAACnCQAAsgkAAKkJAACqCQAAqwkAAAUKAAAoAAAABAAAALMJAAB7CgAAtQkAAHwKAAB5CgAAtwkAAKAJAAChCQAAogkAAKMJAAB6CgAAuAkAAKUJAACmCQAApwkAALkJAACpCQAAqgkAAKsJAAAFCgAAKAAAAAQAAACaCQAAfQoAAJwJAAB+CgAAeQoAAJ8JAACgCQAAoQkAAKIJAACjCQAAegoAAKQJAAClCQAApgkAAKcJAACoCQAAqQkAAKoJAACrCQAAfwoAAAgAAAAEAAAAcgIAAHMCAAB0AgAAgAoAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGlsbGVnYWwgZGljdGlvbmFyeSBrZXkgdHlwZSAAAHi4IABGAAAALiQQAGIAAACkAQAAFgAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IFVuc3VwcG9ydGVkIHJ1biBlbmQgaW5kZXggdHlwZTogAADYuCAASgAAAC4kEABiAAAAtQEAABYAAABJdCBpcyBub3QgcG9zc2libGUgdG8gY29uY2F0ZW5hdGUgYXJyYXlzIG9mIGRpZmZlcmVudCBkYXRhIHR5cGVzICgAADy5IABCAAAALCAuLi4AAAAuJBAAYgAAAIwBAAAjAAAAKS4AAC4kEABiAAAAlgEAABsAAAAsIAAALiQQAGIAAACRAQAAIwAAAC4kEABiAAAAkgEAACMAAABjb25jYXQgcmVxdWlyZXMgaW5wdXQgb2YgYXQgbGVhc3Qgb25lIGFycmF5AIEKAAA8AAAABAAAAIIKAACBCgAAPAAAAAQAAACDCgAAgQoAADwAAAAEAAAAhAoAAIEKAAA8AAAABAAAAIUKAACGCgAAMAAAAAQAAACHCgAAhgoAADAAAAAEAAAAiAoAAIYKAAAwAAAABAAAAIkKAACGCgAAMAAAAAQAAACKCgAAhgoAADAAAAAEAAAAiwoAAIYKAAAwAAAABAAAAIwKAACGCgAAMAAAAAQAAACNCgAAhgoAADAAAAAEAAAAjgoAAIYKAAAwAAAABAAAAI8KAACGCgAAMAAAAAQAAACQCgAAhgoAADAAAAAEAAAAkQoAAIYKAAAwAAAABAAAAJIKAACGCgAAMAAAAAQAAACTCgAAhgoAADAAAAAEAAAAlAoAAIYKAAAwAAAABAAAAJUKAACGCgAAMAAAAAQAAACWCgAAhgoAADAAAAAEAAAAlwoAAIYKAAAwAAAABAAAAJgKAACGCgAAMAAAAAQAAACZCgAAhgoAADAAAAAEAAAAmgoAAIYKAAAwAAAABAAAAJsKAACGCgAAMAAAAAQAAACcCgAAhgoAADAAAAAEAAAAnQoAAIYKAAAwAAAABAAAAJ4KAACGCgAAMAAAAAQAAACfCgAAhgoAADAAAAAEAAAAoAoAAIYKAAAwAAAABAAAAKEKAACGCgAAMAAAAAQAAACiCgAAhgoAADAAAAAEAAAAowoAAIYKAAAwAAAABAAAAKQKAACGCgAAMAAAAAQAAAClCgAAhgoAADAAAAAEAAAApgoAAKcKAABIAAAABAAAAKgKAACnCgAASAAAAAQAAACpCgAApwoAAEgAAAAEAAAAqgoAAKcKAABIAAAABAAAAKsKAACnCgAASAAAAAQAAACsCgAApwoAAEgAAAAEAAAArQoAAKcKAABIAAAABAAAAK4KAACnCgAASAAAAAQAAACvCgAAsAoAADgAAAAEAAAAsQoAALIKAAA8AAAABAAAALMKAACyCgAAPAAAAAQAAAC0CgAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAJwAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABUcnVzdGVkIGl0ZXJhdG9yIGxlbmd0aCB3YXMgbm90IGFjY3VyYXRlbHkgcmVwb3J0ZWQAdL0gADMAAAC1bRAAagAAAIYCAAAJAAAAtW0QAGoAAAClAgAANQAAAApRsywSqhLqC1ne29TsvDntouXUe4Cx1NfBHydeX+Jcxyz97CXaOPcNmZPCUErMp6QXXY9KdSAtY5a+MN5C6+xT7BTfN9slyCKsBxEGqdNMNfwRZe1Sb74nOZX/egFS5bWh38fgqExDkv0R4mNj/KP8dU7Me+Oh8trxp8F8hAOpYeFMOfA/ccSNlHixc5xZ52SbkvUMjgtgzWhn0+HjULmvOQRL4Rz3M6BSkd6ERkmN4qn8OK0OOH7FbC6gMU1KgBli+kYdFYruGEtyCqV7LK1/HWoqIlT2wIb23M7m7swA50xQaoiymrNlSfixTbRc0jWUzEI8vU3M9/nCXHUEmgJRn3vZqoToqYcb8Pl0lKmThgAUgjtMRpmj6hikle0/++RUUd5VhI00tWSikrrobxm+nCqRkTY0YMVIQBcRDps0wSMKlc3WKLCDFl9q32vM3xDPzJ2lNSRpCPoqAI4VyUIofOLr7ovvGQKEKFjGuf0Wlyhs0/3jKtl80eyBQMewdh+hT8T8IUEh1iLFiOnXsXhMmqhfISxC5H5Fg6+DbTVcRqbuzFCDCrw6aeStsNPxTJOJu45GCSznGEk4jUOILelyfspTfoQ6K9lFQ5fxtd+vjdF6wqQZIXfZFdueBRfpjElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6wHHNK/WXKix1JwoV9WuZpHKkfkhPMzBzcBykPSRs+86L2qjMuJ7G9LBR3guMn66Ea4gF0QWRDeC5xu8k+YME4e6bMrgUntG5cMd4s0FYFxFCxt2uXnKjhOUJHZN/4dGopE08bkoLVBDNnZa4PhIFGHs7Vg0XNz5GGUPph3+FHFJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh1zIQAHgAAADrBwAACQBBuIKDAQtVAQAAALUKAABMYXlvdXRFcnJvcgDOdRAAagAAAKcBAAAfAAAAtgoAADAAAAAEAAAAtwoAALgKAAA0AAAABAAAALkKAAC6CgAALAAAAAQAAAC7CgAAAQBBmIODAQuRMLwKAAAoAAAABAAAAL0KAAC8CgAAKAAAAAQAAAC+CgAAvAoAACgAAAAEAAAAvwoAAAAAAACbNBAAYgAAAFQAAAAJAAAASW5kZXhJdGVyYXRvciBleGhhdXN0ZWQgZWFybHkAAACbNBAAYgAAAGEAAAApAAAAmzQQAGIAAAB1AAAAIAAAAJs0EABiAAAAoAAAAEYAAACGCgAAMAAAAAQAAABMAwAAwAoAAE4DAADBCgAAwgoAAFADAABRAwAAUgMAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAUwMAAMQKAABVAwAAxQoAAMIKAABXAwAA+QEAAPoBAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAABUDAADGCgAAFwMAAMcKAADCCgAAGgMAAAACAAABAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAiAwAAyAoAACQDAADJCgAAwgoAACYDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAWAMAAMoKAABaAwAAywoAAMIKAABcAwAAUQMAAFIDAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAF0DAADMCgAAXwMAAM0KAADCCgAAYQMAAPkBAAD6AQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAbAwAAzgoAAB0DAADPCgAAwgoAAB8DAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAJwMAANAKAAApAwAA0QoAAMIKAAArAwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAPQBAADSCgAA9gEAANMKAADCCgAA+AEAAPkBAAD6AQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAABCAwAA1AoAAEQDAADVCgAAwgoAAEYDAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAARwMAANYKAABJAwAA1woAAMIKAABLAwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAAwHAADYCgAADgcAANkKAADCCgAAEAcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAWBwAA2goAABgHAADbCgAAwgoAABoHAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAABwcAANwKAAAJBwAA3QoAAMIKAAALBwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAABEHAADeCgAAEwcAAN8KAADCCgAAFQcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAD7AQAA4AoAAP0BAADhCgAAwgoAAP8BAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAAgIAAOIKAAAEAgAA4woAAMIKAAAGAgAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAAIHAADkCgAABAcAAOUKAADCCgAABgcAANEBAADSAQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAJAgAA5goAAAsCAADnCgAAwgoAAA0CAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAADgIAAOgKAAAQAgAA6QoAAMIKAAASAgAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAMsBAADqCgAAzQEAAOsKAADCCgAA0AEAANEBAADSAQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAADeAQAA7AoAAOABAADtCgAAwgoAAOIBAADjAQAA5AEAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmzQQAGIAAABFAQAATQAAALoKAAAsAAAABAAAAAIDAADuCgAABAMAAO8KAADwCgAABwMAAAgDAAAJAwAACgMAAAsDAAAMAwAADQMAAA4DAAAPAwAAEAMAABEDAAASAwAAEwMAABQDAACGCgAAMAAAAAQAAAAuAwAA8QoAADADAADyCgAAwgoAADIDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAMwMAAPMKAAA1AwAA9AoAAMIKAAA3AwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAADgDAAD1CgAAOgMAAPYKAADCCgAAPAMAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAA9AwAA9woAAD8DAAD4CgAAwgoAAEEDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAKwcAAPkKAAAtBwAA+goAAMIKAAAvBwAAAAIAAAECAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAACYHAAD7CgAAKAcAAPwKAADCCgAAKgcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAhBwAA/QoAACMHAAD+CgAAwgoAACUHAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAOgcAAP8KAAA8BwAAAAsAAMIKAAA+BwAAAAIAAAECAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAADAHAAABCwAAMgcAAAILAADCCgAANAcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAA1BwAAAwsAADcHAAAECwAAwgoAADkHAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAgQoAADwAAAAEAAAAWAcAAAULAABaBwAABgsAAAcLAABdBwAAXgcAAF8HAABgBwAAwwoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAALAKAAA4AAAABAAAABMCAAAICwAAFQIAAAkLAAAKCwAAGAIAAAsLAAAMCwAAGwIAAMMKAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAACBCgAAPAAAAAQAAABqBwAADQsAAGwHAAAOCwAABwsAAG4HAABvBwAAcAcAAGAHAADDCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAsgoAADwAAAAEAAAAMQYAAA8LAAAzBgAAEAsAABELAAA2BgAANwYAADgGAAA5BgAAwwoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAIEKAAA8AAAABAAAAIsHAAASCwAAjQcAABMLAAAHCwAAjwcAAF4HAABfBwAAYAcAAMMKAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAACBCgAAPAAAAAQAAACQBwAAFAsAAJIHAAAVCwAABwsAAJQHAABvBwAAcAcAAGAHAADDCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAsgoAADwAAAAEAAAARAYAABYLAABGBgAAFwsAABELAABIBgAANwYAADgGAAA5BgAAwwoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAALgKAAA0AAAABAAAAIcBAAAYCwAAiQEAABkLAAAaCwAAjAEAABsLAAAcCwAAjwEAAMMKAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAAC2CgAAMAAAAAQAAADXBQAAHQsAANkFAAAeCwAAHwsAANwFAADdBQAA3gUAAN8FAADDCgAAIAsAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAApwoAAEgAAAAEAAAATgYAACELAABQBgAAIgsAACMLAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAKcKAABIAAAABAAAAGEGAAAkCwAAYwYAACULAAAjCwAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAACnCgAASAAAAAQAAABuBgAAJgsAAHAGAAAnCwAAIwsAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAApwoAAEgAAAAEAAAAewYAACgLAAB9BgAAKQsAACMLAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAKcKAABIAAAABAAAAIgGAAAqCwAAigYAACsLAAAjCwAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAACnCgAASAAAAAQAAACSBgAALAsAAJQGAAAtCwAAIwsAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAApwoAAEgAAAAEAAAAnAYAAC4LAACeBgAALwsAACMLAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAKcKAABIAAAABAAAAKQGAAAwCwAApgYAADELAAAjCwAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiB1bnN1cHBvcnRlZCBkaWN0aW9uYXJ5IGtleSB0eXBlOiAAbNMgAEsAAACbNBAAYgAAAGMBAAArAAAAbm90IGltcGxlbWVudGVkOiBGaWx0ZXIgbm90IHN1cHBvcnRlZCBmb3IgZGljdGlvbmFyeSB0eXBlIAAA0NMgADoAAACbNBAAYgAAAGUBAAAWAAAAvAoAACgAAAAEAAAAmgkAADILAACcCQAAMwsAADQLAACfCQAAoAkAAKEJAACiCQAAowkAACALAACkCQAApQkAAKYJAACnCQAAqAkAAKkJAACqCQAAqwkAALwKAAAoAAAABAAAAKwJAAA1CwAArgkAADYLAAA0CwAAsAkAAKAJAAChCQAAogkAAKMJAAAgCwAAsQkAAKUJAACmCQAApwkAALIJAACpCQAAqgkAAKsJAAC8CgAAKAAAAAQAAACzCQAANwsAALUJAAA4CwAANAsAALcJAACgCQAAoQkAAKIJAACjCQAAIAsAALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgcnVuIGVuZCBpbmRleCB0eXBlOiAAACzVIABKAAAAmzQQAGIAAABeAQAAEQAAAG5vdCBpbXBsZW1lbnRlZDogRmlsdGVyIG5vdCBzdXBwb3J0ZWQgZm9yIFJ1bkVuZEVuY29kZWQgdHlwZSAAAACQ1SAAPQAAAJs0EABiAAAAYAEAABoAAABGaWx0ZXIgcHJlZGljYXRlIG9mIGxlbmd0aCAgaXMgbGFyZ2VyIHRoYW4gdGFyZ2V0IGFycmF5IG9mIGxlbmd0aCAAAOjVIAAbAAAAA9YgACcAAACbNBAAYgAAAJMBAAAcAAAAAAAAAAQAAAAEAAAAOQsAADoLAAA7CwAAPAsAAD0LAAA+CwAAPwsAAEALAABBCwAAQgsAAEMLAABECwAARQsAAEYLAABHCwAASAsAAEkLAABKCwAASwsAAEwLAAAIAAAABAAAAHICAABzAgAAdAIAAE0LAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlmzQQAGIAAAD2AQAAPQAAAGFzc2VydGlvbiBmYWlsZWQ6IHZhbHVlcy5sZW4oKSA+PSBwcmVkaWNhdGUuZmlsdGVyLmxlbigpmzQQAGIAAAAMAgAABQAAAJs0EABiAAAAEAIAAB4AAACbNBAAYgAAABICAAAxAAAAmzQQAGIAAAASAgAAGAAAAJs0EABiAAAAFwIAAB4AAACbNBAAYgAAABkCAAAxAAAAmzQQAGIAAAAZAgAAGAAAAJs0EABiAAAAJwIAAD0AAACbNBAAYgAAAB4CAABXAAAAmzQQAGIAAABTAgAAMAAAAJs0EABiAAAAVgIAABUAAACbNBAAYgAAAGQCAAAJAAAAaWxsZWdhbCBvZmZzZXQgcmFuZ2WbNBAAYgAAAG0CAAA3AAAAmzQQAGIAAAByAgAAGgAAAJs0EABiAAAAfgIAABkAAACbNBAAYgAAAIECAAAZAAAAmzQQAGIAAACCAgAAFwAAAJs0EABiAAAAhAIAADQAAACbNBAAYgAAAIQCAAASAAAAmzQQAGIAAACJAgAAGgAAAJs0EABiAAAAjwIAACIAAACbNBAAYgAAAJYCAAAZAAAAmzQQAGIAAACcAgAANAAAAJs0EABiAAAAnAIAABIAAACbNBAAYgAAALwCAAA9AAAAmzQQAGIAAADrAgAAHAAAAJs0EABiAAAA9AIAABwAAACbNBAAYgAAAAsDAAA9AAAAmzQQAGIAAABNAwAACQAAACRXEABpAAAAOAAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADXMhAAeAAAAOsHAAAJAEG0s4MBC/4CAQAAAE8LAABMYXlvdXRFcnJvcgDqARAAZgAAAIQAAAAjAAAA6gEQAGYAAAC2AAAAGAAAAOoBEABmAAAA4gAAAB0AAADqARAAZgAAAOMAAAAcAAAA6gEQAGYAAAD+AAAAFwAAAOoBEABmAAAA9wAAABYAAADqARAAZgAAAPgAAAAXAAAA6gEQAGYAAAANAQAAJQAAAOoBEABmAAAAKgEAAC0AAADqARAAZgAAADoBAAATAAAA6gEQAGYAAAA/AQAAKwAAAOoBEABmAAAAPQEAAA0AAABub3QgaW1wbGVtZW50ZWQ6IERpY3Rpb25hcnkgbWVyZ2luZyBmb3IgdHlwZSAgaXMgbm90IGltcGxlbWVudGVkiNogAC0AAAC12iAAEwAAAOoBEABmAAAAVgEAAA4AAADqARAAZgAAAGEBAAATAAAA6gEQAGYAAABjAQAADQAAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB0LaDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBjLeDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB5LeDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBoLiDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB+LiDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBtLmDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBjLqDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBByLqDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBoLuDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBB3LuDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBtLyDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBB8LyDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBByL2DAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBhL6DAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB3L6DAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBmL+DAQuRNk4LAABOCwAATgsAAE4LAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAFQLAAA8AAAABAAAAFULAABUCwAAPAAAAAQAAABWCwAAVAsAADwAAAAEAAAAVwsAAFQLAAA8AAAABAAAAFgLAABZCwAAMAAAAAQAAABaCwAAWQsAADAAAAAEAAAAWwsAAFkLAAAwAAAABAAAAFwLAABZCwAAMAAAAAQAAABdCwAAWQsAADAAAAAEAAAAXgsAAFkLAAAwAAAABAAAAF8LAABZCwAAMAAAAAQAAABgCwAAWQsAADAAAAAEAAAAYQsAAFkLAAAwAAAABAAAAGILAABZCwAAMAAAAAQAAABjCwAAWQsAADAAAAAEAAAAZAsAAFkLAAAwAAAABAAAAGULAABZCwAAMAAAAAQAAABmCwAAWQsAADAAAAAEAAAAZwsAAFkLAAAwAAAABAAAAGgLAABZCwAAMAAAAAQAAABpCwAAWQsAADAAAAAEAAAAagsAAFkLAAAwAAAABAAAAGsLAABZCwAAMAAAAAQAAABsCwAAWQsAADAAAAAEAAAAbQsAAFkLAAAwAAAABAAAAG4LAABZCwAAMAAAAAQAAABvCwAAWQsAADAAAAAEAAAAcAsAAFkLAAAwAAAABAAAAHELAABZCwAAMAAAAAQAAAByCwAAWQsAADAAAAAEAAAAcwsAAFkLAAAwAAAABAAAAHQLAABZCwAAMAAAAAQAAAB1CwAAWQsAADAAAAAEAAAAdgsAAFkLAAAwAAAABAAAAHcLAABZCwAAMAAAAAQAAAB4CwAAWQsAADAAAAAEAAAAeQsAAHoLAABIAAAABAAAAHsLAAB6CwAASAAAAAQAAAB8CwAAegsAAEgAAAAEAAAAfQsAAHoLAABIAAAABAAAAH4LAAB6CwAASAAAAAQAAAB/CwAAegsAAEgAAAAEAAAAgAsAAHoLAABIAAAABAAAAIELAAB6CwAASAAAAAQAAACCCwAAgwsAADwAAAAEAAAAhAsAAIMLAAA8AAAABAAAAIULAACBQRAAdAAAANwAAAAdAAAAgUEQAHQAAADOAAAAHQAAAIJVEABoAAAAhgAAACYAAADtouXUe4Cx1NfBHydeX+Jcxyz97CXaOPcNmZPCUErMp6QXXY9KdSAtY5a+MN5C6+xT7BTfN9slyCKsBxEGqdNMNfwRZe1Sb74nOZX/egFS5bWh38fgqExDkv0R4mNj/KP8dU7Me+Oh8trxp8F8hAOpZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoChgAUgjtMRpmj6hikle0/++RUUd5VhI00tWSikrrobxm+nCqRkTY0YMVIQBcRDps0wSMKlc3WKLCDFl9q32vM3xDPzJ2lNSRpCPoqAI4VyUIofOLr7ovvGQKEKFjGuf0Wlyhs0/3jKtl80eyBQMewdh+hT8T8IUEh1iLFiOnXsXhMmqhfISxC5H5Fg6+DbTVcRqbuzFCDCrw6aeStsNPxTJOJu45GCSznGEk4jUOILelyfspTfoQ6K9lFQ5fxtd+vjdF6wqQZIXfZFdueBRfpjElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMJypH5ITzMwc3AcpD0kbPvOi9qozLiexvSwUd4LjJ+uhGuIBdEFkQ3gucbvJPmDBOHumzK4FJ7RuXDHeLNBWBcRQsbdrl5yo4TlCR2Tf+HRqKRNPG5KC1QQzZ2WuD4SBRh7O1YNFzc+RhlD6Yd/hRxSfDveFUdQQxVv5bQ/ivqicEmwnpB6Tiwvy25J6jIIGHzR+J3J0aX9zlbhI4PhyUdxK0wkXtFX+YAWCn4Fj6VnYdcyEAB4AAAA6wcAAAkAAADOdRAAagAAAL0BAAAdAAAAhgsAADQAAAAEAAAAhwsAAIgLAAAIAAAABAAAAHICAABzAgAAdAIAAIkLAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbGxlZ2FsIGRpY3Rpb25hcnkga2V5IHR5cGUgAABQ5iAARgAAAFNlEABmAAAAaQAAABIAAABJdCBpcyBub3QgcG9zc2libGUgdG8gaW50ZXJsZWF2ZSBhcnJheXMgb2YgZGlmZmVyZW50IGRhdGEgdHlwZXMgKCBhbmQgKQCw5iAAQQAAAPHmIAAFAAAA9uYgAAEAAABpbnRlcmxlYXZlIHJlcXVpcmVzIGlucHV0IG9mIGF0IGxlYXN0IG9uZSBhcnJheQBZCwAAMAAAAAQAAAA4AwAAigsAADoDAACLCwAAjAsAADwDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAFQMAAI4LAAAXAwAAjwsAAIwLAAAaAwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAD0DAACQCwAAPwMAAJELAACMCwAAQQMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAArBwAAkgsAAC0HAACTCwAAjAsAAC8HAAAAAgAAAQIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAXQMAAJQLAABfAwAAlQsAAIwLAABhAwAA+QEAAPoBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAFMDAACWCwAAVQMAAJcLAACMCwAAVwMAAPkBAAD6AQAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAwBwAAmAsAADIHAACZCwAAjAsAADQHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAIQcAAJoLAAAjBwAAmwsAAIwLAAAlBwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAADMDAACcCwAANQMAAJ0LAACMCwAANwMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAOAgAAngsAABACAACfCwAAjAsAABICAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAADAcAAKALAAAOBwAAoQsAAIwLAAAQBwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAFgDAACiCwAAWgMAAKMLAACMCwAAXAMAAFEDAABSAwAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAABHAwAApAsAAEkDAAClCwAAjAsAAEsDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAALgMAAKYLAAAwAwAApwsAAIwLAAAyAwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAADoHAACoCwAAPAcAAKkLAACMCwAAPgcAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAJAgAAqgsAAAsCAACrCwAAjAsAAA0CAAAAAgAAAQIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAA9AEAAKwLAAD2AQAArQsAAIwLAAD4AQAA+QEAAPoBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAACIDAACuCwAAJAMAAK8LAACMCwAAJgMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAADeAQAAsAsAAOABAACxCwAAjAsAAOIBAADjAQAA5AEAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAFgcAALILAAAYBwAAswsAAIwLAAAaBwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAPsBAAC0CwAA/QEAALULAACMCwAA/wEAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAnAwAAtgsAACkDAAC3CwAAjAsAACsDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAATAMAALgLAABOAwAAuQsAAIwLAABQAwAAUQMAAFIDAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAAcHAAC6CwAACQcAALsLAACMCwAACwcAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAA1BwAAvAsAADcHAAC9CwAAjAsAADkHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAGwMAAL4LAAAdAwAAvwsAAIwLAAAfAwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAEIDAADACwAARAMAAMELAACMCwAARgMAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAmBwAAwgsAACgHAADDCwAAjAsAACoHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAAgcAAMQLAAAEBwAAxQsAAIwLAAAGBwAA0QEAANIBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAABEHAADGCwAAEwcAAMcLAACMCwAAFQcAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAACAgAAyAsAAAQCAADJCwAAjAsAAAYCAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAywEAAMoLAADNAQAAywsAAIwLAADQAQAA0QEAANIBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFNlEABmAAAAqwAAABcAAABTZRAAZgAAAKwAAAANAAAAU2UQAGYAAACtAAAADQAAAFNlEABmAAAAtAAAABYAAABUCwAAPAAAAAQAAABYBwAAzAsAAFoHAADNCwAAzgsAAF0HAABeBwAAXwcAAGAHAACNCwAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAU2UQAGYAAAC2AAAANAAAAFNlEABmAAAAtgAAABAAAABUCwAAPAAAAAQAAACQBwAAzwsAAJIHAADQCwAAzgsAAJQHAABvBwAAcAcAAGAHAACNCwAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAVAsAADwAAAAEAAAAiwcAANELAACNBwAA0gsAAM4LAACPBwAAXgcAAF8HAABgBwAAjQsAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFQLAAA8AAAABAAAAGoHAADTCwAAbAcAANQLAADOCwAAbgcAAG8HAABwBwAAYAcAAI0LAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAB6CwAASAAAAAQAAACSBgAA1QsAAJQGAADWCwAA1wsAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAU2UQAGYAAADfAAAAOAAAAFNlEABmAAAA4gAAAB8AAABTZRAAZgAAAOMAAAA2AAAAU2UQAGYAAADjAAAAOgAAAHoLAABIAAAABAAAAHsGAADYCwAAfQYAANkLAADXCwAAfwYAAIAGAACBBgAAggYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAhgYAAIcGAAB6CwAASAAAAAQAAABOBgAA2gsAAFAGAADbCwAA1wsAAFMGAABUBgAAVQYAAFYGAABXBgAAWAYAAFkGAABaBgAAWwYAAFwGAABdBgAAXgYAAF8GAABgBgAAegsAAEgAAAAEAAAApAYAANwLAACmBgAA3QsAANcLAACoBgAAgAYAAIEGAACpBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACqBgAAqwYAAHoLAABIAAAABAAAAIgGAADeCwAAigYAAN8LAADXCwAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAB6CwAASAAAAAQAAABuBgAA4AsAAHAGAADhCwAA1wsAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAegsAAEgAAAAEAAAAYQYAAOILAABjBgAA4wsAANcLAABlBgAAZgYAAGcGAABoBgAAVwYAAFgGAABpBgAAWgYAAFsGAABcBgAAagYAAGsGAABsBgAAbQYAAHoLAABIAAAABAAAAJwGAADkCwAAngYAAOULAADXCwAAoAYAAHMGAAB0BgAAoQYAAFcGAABYBgAAdgYAAFoGAABbBgAAXAYAAHcGAAB4BgAAogYAAKMGAABTZRAAZgAAAPQAAAAXAAAAU2UQAGYAAAD9AAAAIwAAAIMLAAA8AAAABAAAAEQGAADmCwAARgYAAOcLAADoCwAASAYAADcGAAA4BgAAOQYAAI0LAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAABTZRAAZgAAAPkAAAARAAAAgwsAADwAAAAEAAAAMQYAAOkLAAAzBgAA6gsAAOgLAAA2BgAANwYAADgGAAA5BgAAjQsAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAIYLAAA0AAAABAAAAIcBAADrCwAAiQEAAOwLAADtCwAAjAEAAO4LAADvCwAAjwEAAI0LAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABTZRAAZgAAACoBAAAdAAAAYm9vbGVhbiBhcnJheQAAADoZEABfAAAAQAMAAB8AAABieXRlIHZpZXcgYXJyYXkAOhkQAF8AAACAAwAAIQAAAHByaW1pdGl2ZSBhcnJheQA6GRAAXwAAAEgDAAAhAAAAZGljdGlvbmFyeSBhcnJheToZEABfAAAAwgMAACIAAABiaW5hcnkgdmlldyBhcnJheQAAADoZEABfAAAAeAMAACEAAABzdHJpbmcgdmlldyBhcnJheQAAADoZEABfAAAAbgMAACEAAABmaXhlZCBzaXplIGxpc3QgYXJyYXkAAAA6GRAAXwAAALIDAAAOAAAAZml4ZWQgc2l6ZSBiaW5hcnkgYXJyYXkAOhkQAF8AAACpAwAADgAAAG1hcCBhcnJheQAAADoZEABfAAAAugMAABsAAABydW4gYXJyYXkAAAA6GRAAXwAAAMoDAAAbAAAAbGlzdCBhcnJheQAAOhkQAF8AAACYAwAAHAAAAGJ5dGUgYXJyYXkAADoZEABfAAAAUAMAAB0AAAB1bmlvbiBhcnJheQA6GRAAXwAAAJADAAAdAAAAYmluYXJ5IGFycmF5OhkQAF8AAABkAwAAHQAAAHN0cmluZyBhcnJheToZEABfAAAAWgMAAB0AAABzdHJ1Y3QgYXJyYXk6GRAAXwAAAIgDAAAeAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAEG09YMBC+EDAQAAAPALAABMYXlvdXRFcnJvcgCbNBAAYgAAAJ0BAAAXAAAAmzQQAGIAAACnAQAAFQAAAFNlEABmAAAAiAAAACIAAABTZRAAZgAAAIkAAAAbAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHJ1biBhcnJheQA6GRAAXwAAAGECAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHByaW1pdGl2ZSBhcnJheQAAADoZEABfAAAA9QEAAAoAAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAE5lc3RlZCBhcnJheSBzaXplIG1pc21hdGNoOiBvbmUgaXMgLCBhbmQgdGhlIG90aGVyIGlzIAAAkPsgACMAAACz+yAAEwAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAADgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQBBoPmDAQupAQEAAADxCwAATGF5b3V0RXJyb3IAYm8QAGAAAAD9AAAAOQAAAHByaW1pdGl2ZSBhcnJheQA6GRAAXwAAAEgDAAAhAAAAKAsQAHAAAABeAgAAJgAAAEluY29ycmVjdCBsZW5ndGggb2YgbnVsbCBidWZmZXIgZm9yIFByaW1pdGl2ZUFycmF5LCBleHBlY3RlZCAgZ290IAAA9PwgAD0AAAAx/SAABQAAAA0AQdT6gwELAhABAEHg+oMBCwIRAwBB7PqDAQsCEwEAQfj6gwELARMAQYT7gwELAyUmCgBBkPuDAQsCDQIAQZz7gwELAhIDAEGo+4MBCwINAwBBtPuDAQsCEwIAQcD7gwELARAAQcz7gwELAhICAEHY+4MBCwMjCQIAQeT7gwELAyQSBgBB8PuDAQsCDQEAQfz7gwELARIAQYj8gwELAhIBAEGU/IMBCwMmTAoAQaD8gwELAhECAEGs/IMBC80BaW5jb21wYXRpYmxlIGRhdGEgdHlwZSBmb3IgYnVpbGRlciwgZXhwZWN0ZWQgAAAALP4gAC0AAAAx/SAABQAAAIFBEAB0AAAAvAAAAAkAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQBBhP6DAQv1EAEAAADyCwAA8wsAABQAAAAEAAAA9AsAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAA9QsAAAwAAAAEAAAA9gsAAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3JMYXlvdXRFcnJvcgAAmzQQAGIAAABzAgAAGQAAAJs0EABiAAAAdAIAABcAAABpbGxlZ2FsIG9mZnNldCByYW5nZZs0EABiAAAAdQIAADsAAABJbnZhbGlkIGRpY3Rpb25hcnkga2V5ICBhdCBpbmRleCAsIGV4cGVjdGVkIDAgPD0ga2V5IDwgAPQAIQAXAAAACwEhAAoAAAAVASEAFgAAAAAAAAAEAAAABAAAALsJAADXMhAAeAAAAOsHAAAJAAAAa2V5IHZhbGlkAAAAz4kQAGEAAACCAAAAIgAAAPuVEABeAAAAswcAABYAAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAMoZEACBAAAAOAAAABsAAABIbRAAbAAAAEsCAAATAAAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAA0AEhACUAAAD1ASEAIQAAACgLEABwAAAA5wIAAAkAAABydW5fZW5kc3ZhbHVlcwAAikAQAH0AAADSAAAAGAAAAEJsb2NrIHRvbyBsYXJnZQBYAiEADwAAAIpAEAB9AAAAEgEAAAkAAACKQBAAfQAAABQBAAAYAAAARiAQAGkAAAB7AAAAFwAAAEYgEABpAAAAfAAAAA0AAABvZmZzZXQgb3ZlcmZsb3cARiAQAGkAAACEAAAAHAAAAHVzaXplIG92ZXJmbG93AABGIBAAaQAAAIAAAAArAAAARiAQAGkAAACBAAAAEQAAAEYgEABpAAAApQAAACMAAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAOdMUGqIspqzZUn4sU20XNK+nCqRkTY0YMVIQBcRDps0lcZIS0X+uEazZx631DiKMsBxzSv1lyosdScKFfVrmaQKUbMsEqoS6gtZ3tvU7Lw5/+xadcUuGHEBenikwlvVi+Kp/DitDjh+xWwuoDFNSoBMmqhfISxC5H5Fg6+DbTVcQsbdrl5yo4TlCR2Tf+HRqBli+kYdFYruGEtyCqV7LK2vOQRL4Rz3M6BSkd6ERkmNByAbTXT+okm+n+f3GpIEeHJ+ylN+hDor2UVDl/G136/umzK4FJ7RuXDHeLNBWBcRwSMKlc3WKLCDFl9q32vM34f8VnuN8jE8tje6Ri8JfJZJsJ6Qek4sL8tuSeoyCBh8PuS0Nl7vxuIsRThA2rQhugDAv/LBP/58nWC8YVXFZwGeBGqkGE5i3Xwyy2GHuwfHxyz97CXaOPcNmZPCUErMp1onILkqqvtHG3r3lllMHT/F/PIfcYVLc266TNPPuCjCtaHfx+CoTEOS/RHiY2P8o+P/1pgFyn5aa9XhHolAKiQofOLr7ovvGQKEKFjGuf0WPvMwG5AYZta8X2XUZ8lrN1Gfe9mqhOiphxvw+XSUqZMQz8ydpTUkaQj6KgCOFclCU+wU3zfbJcgirAcRBqnTTDWUzEI8vU3M9/nCXHUEmgLkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7tyToUm5JHuWBbi5ANF+xgx7O1YNFzc+RhlD6Yd/hRxSjdF6wqQZIXfZFdueBRfpjIYAFII7TEaZo+oYpJXtP/uTibuORgks5xhJOI1DiC3p7aLl1HuAsdTXwR8nXl/iXElI6zz1ZfGccblydT5HjUKkTTxuSgtUEM2dlrg+EgUYZJuS9QyOC2DNaGfT4eNQuWuIBdEFkQ3gucbvJPmDBOFypH5ITzMwc3AcpD0kbPvOlyhs0/3jKtl80eyBQMewdovaqMy4nsb0sFHeC4yfroTR+J3J0aX9zlbhI4PhyUdxK0wkXtFX+YAWCn4Fj6VnYR+hT8T8IUEh1iLFiOnXsXikF12PSnUgLWOWvjDeQuvsEJ9k8dpo/gbvJq2NCifCzWOYOC6bqJpWsC9YjrdR6Id/HWoqIlT2wIb23M7m7swAeoxNLzEphhwjoC5rNYdVJmHhTDnwP3HEjZR4sXOcWed8O94VR1BDFW/ltD+K+qJwNfwRZe1Sb74nOZX/egFS5Uam7sxQgwq8OmnkrbDT8UwGGSbbSd1M7t3XLru1Pa3m/HVOzHvjofLa8afBfIQDqQAAAAAEAAAABAAAAPsLAAAAAAAABAAAAAQAAABtAwAASW50ZXJ2YWxEYXlUaW1lZGF5c21pbGxpc2Vjb25kcwAAAAAABAAAAAQAAABICAAASW50ZXJ2YWxNb250aERheU5hbm9tb250aHNuYW5vc2Vjb25kcwAAAPwLAAAsAAAABAAAAP0LAAABAEGEj4QBC94H/gsAADwAAAAEAAAA/wsAAP4LAAA8AAAABAAAAAAMAAD+CwAAPAAAAAQAAAABDAAA/gsAADwAAAAEAAAAAgwAAAMMAABIAAAABAAAAAQMAAADDAAASAAAAAQAAAAFDAAAAwwAAEgAAAAEAAAABgwAAAMMAABIAAAABAAAAAcMAAADDAAASAAAAAQAAAAIDAAAAwwAAEgAAAAEAAAACQwAAAMMAABIAAAABAAAAAoMAAADDAAASAAAAAQAAAALDAAADAwAADAAAAAEAAAAUwMAAA0MAABVAwAADgwAAA8MAABXAwAA+QEAAPoBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAFgDAAARDAAAWgMAABIMAAAPDAAAXAMAAFEDAABSAwAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAABdAwAAEwwAAF8DAAAUDAAADwwAAGEDAAD5AQAA+gEAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAFQMAABUMAAAXAwAAFgwAAA8MAAAaAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAEwDAAAXDAAATgMAABgMAAAPDAAAUAMAAFEDAABSAwAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAnAwAAGQwAACkDAAAaDAAADwwAACsDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAGwMAABsMAAAdAwAAHAwAAA8MAAAfAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAACIDAAAdDAAAJAMAAB4MAAAPDAAAJgMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAfDAAAOAAAAAQAAAAgDAAAIQwAADQAAAAEAAAAIgwAACMMAAA4AAAABAAAACQMAAAjDAAAOAAAAAQAAAAlDAAAJgwAAGQAAAAEAAAAJwwAAAAAAAAEAAAABAAAACgMAEHwloQBC74xVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAcAshACUAAACVCyEAIQAAACgLEABwAAAA5wIAAAkAAAAMDAAAMAAAAAQAAAApDAAADAwAADAAAAAEAAAAKgwAAAwMAAAwAAAABAAAACsMAAAMDAAAMAAAAAQAAAAsDAAADAwAADAAAAAEAAAALQwAAAwMAAAwAAAABAAAAC4MAAAMDAAAMAAAAAQAAAAvDAAADAwAADAAAAAEAAAAMAwAAAwMAAAwAAAABAAAADEMAAAMDAAAMAAAAAQAAAAyDAAADAwAADAAAAAEAAAAMwwAAAwMAAAwAAAABAAAADQMAAAMDAAAMAAAAAQAAAA1DAAADAwAADAAAAAEAAAANgwAAAwMAAAwAAAABAAAADcMAAAMDAAAMAAAAAQAAAA4DAAADAwAADAAAAAEAAAAOQwAAAwMAAAwAAAABAAAADoMAAAMDAAAMAAAAAQAAAA7DAAADAwAADAAAAAEAAAAPAwAAAwMAAAwAAAABAAAAD0MAAAMDAAAMAAAAAQAAAA+DAAADAwAADAAAAAEAAAAPwwAAAwMAAAwAAAABAAAAEAMAAAMDAAAMAAAAAQAAABBDAAADAwAADAAAAAEAAAAQgwAAAwMAAAwAAAABAAAAEMMAAAMDAAAMAAAAAQAAABEDAAADAwAADAAAAAEAAAARQwAAAwMAAAwAAAABAAAAEYMAAAMDAAAMAAAAAQAAABHDAAADAwAADAAAAAEAAAASAwAACgLEABwAAAAKAUAADQAAABudWxs6A0hAAQAAAABAAAAAAAAACAoVW5rbm93biBUaW1lIFpvbmUgJycpAAEAAAAAAAAA/A0hABUAAAARDiEAAgAAACgLEABwAAAAEAUAADQAAABDYXN0IGVycm9yOiBGYWlsZWQgdG8gY29udmVydCAgdG8gdGVtcG9yYWwgZm9yIAA8DiEAHgAAAFoOIQARAAAAKAsQAHAAAAAcBQAANAAAAEkMAAA0AAAABAAAAEoMAAB2YWxpZAAAAEsMAAAwAAAABAAAAEwMAABNDAAAKAAAAAQAAABODAAATQwAACgAAAAEAAAATwwAAE0MAAAoAAAABAAAAFAMAABRDAAAPAAAAAQAAABSDAAAUQwAADwAAAAEAAAAUwwAAFQMAABEAAAABAAAAFUMAABUDAAARAAAAAQAAABWDAAAAAAAAAQAAAAEAAAA8gIAAFcMAAD0AgAAWAwAAFkMAAD3AgAAWgwAAFsMAABcDAAAEAwAAF0MAAD8AgAA/QIAAP4CAAD/AgAAWgwAAAADAAAQDAAAAQMAAPwLAAAsAAAABAAAAAIDAABeDAAABAMAAF8MAABgDAAABwMAAAgDAAAJAwAACgMAAAsDAAAMAwAADQMAAA4DAAAPAwAAEAMAABEDAAASAwAAEwMAABQDAAAMDAAAMAAAAAQAAAD0AQAAYQwAAPYBAABiDAAADwwAAPgBAAD5AQAA+gEAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAQgMAAGMMAABEAwAAZAwAAA8MAABGAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAEcDAABlDAAASQMAAGYMAAAPDAAASwMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAuAwAAZwwAADADAABoDAAADwwAADIDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAMwMAAGkMAAA1AwAAagwAAA8MAAA3AwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAADgDAABrDAAAOgMAAGwMAAAPDAAAPAMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAA9AwAAbQwAAD8DAABuDAAADwwAAEEDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAKwcAAG8MAAAtBwAAcAwAAA8MAAAvBwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAACYHAABxDAAAKAcAAHIMAAAPDAAAKgcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAhBwAAcwwAACMHAAB0DAAADwwAACUHAAAAAgAAAQIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAOgcAAHUMAAA8BwAAdgwAAA8MAAA+BwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAADAHAAB3DAAAMgcAAHgMAAAPDAAANAcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAA1BwAAeQwAADcHAAB6DAAADwwAADkHAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAVW5leHBlY3RlZCBkYXRhIHR5cGUgAAAATBQhABUAAABDdxAAZAAAAEgDAAAPAAAADAwAADAAAAAEAAAADAcAAHsMAAAOBwAAfAwAAA8MAAAQBwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAABYHAAB9DAAAGAcAAH4MAAAPDAAAGgcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAHBwAAfwwAAAkHAACADAAADwwAAAsHAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAEQcAAIEMAAATBwAAggwAAA8MAAAVBwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAPsBAACDDAAA/QEAAIQMAAAPDAAA/wEAAAACAAABAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAACAgAAhQwAAAQCAACGDAAADwwAAAYCAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAAgcAAIcMAAAEBwAAiAwAAA8MAAAGBwAA0QEAANIBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAP4LAAA8AAAABAAAAFgHAACJDAAAWgcAAIoMAACLDAAAXQcAAF4HAABfBwAAYAcAABAMAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAAfDAAAOAAAAAQAAAATAgAAjAwAABUCAACNDAAAjgwAABgCAACPDAAAkAwAABsCAAAQDAAAHAIAAB0CAAAeAgAAHwIAACACAAAhAgAAIgIAACMCAAAkAgAA/gsAADwAAAAEAAAAagcAAJEMAABsBwAAkgwAAIsMAABuBwAAbwcAAHAHAABgBwAAEAwAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFEMAAA8AAAABAAAADEGAACTDAAAMwYAAJQMAACVDAAANgYAADcGAAA4BgAAOQYAABAMAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAAD+CwAAPAAAAAQAAACLBwAAlgwAAI0HAACXDAAAiwwAAI8HAABeBwAAXwcAAGAHAAAQDAAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAA/gsAADwAAAAEAAAAkAcAAJgMAACSBwAAmQwAAIsMAACUBwAAbwcAAHAHAABgBwAAEAwAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFEMAAA8AAAABAAAAEQGAACaDAAARgYAAJsMAACVDAAASAYAADcGAAA4BgAAOQYAABAMAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAAAjDAAAOAAAAAQAAADlBAAAnAwAAOcEAACdDAAAjgwAAOoEAADrBAAA7AQAAO0EAAAQDAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAVAwAAEQAAAAEAAAAngwAAJ8MAACgDAAAoQwAAKIMAACjDAAApAwAAKUMAACmDAAAEAwAAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAACEMAAA0AAAABAAAAJwEAACwDAAAngQAALEMAACyDAAAoQQAALMMAAC0DAAApAQAABAMAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAAAjDAAAOAAAAAQAAAD4BAAAtQwAAPoEAAC2DAAAjgwAAPwEAAD9BAAA/gQAAO0EAAAQDAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAVAwAAEQAAAAEAAAAtwwAALgMAAC5DAAAugwAAKIMAAC7DAAAvAwAAL0MAACmDAAAEAwAAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAAEkMAAA0AAAABAAAAIcBAAC+DAAAiQEAAL8MAADADAAAjAEAAMEMAADCDAAAjwEAABAMAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABLDAAAMAAAAAQAAADXBQAAwwwAANkFAADEDAAAxQwAANwFAADdBQAA3gUAAN8FAAAQDAAAXQwAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAAAwwAAEgAAAAEAAAATgYAAMYMAABQBgAAxwwAAMgMAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAAMMAABIAAAABAAAAGEGAADJDAAAYwYAAMoMAADIDAAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAAADDAAASAAAAAQAAABuBgAAywwAAHAGAADMDAAAyAwAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAAwwAAEgAAAAEAAAAewYAAM0MAAB9BgAAzgwAAMgMAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAAMMAABIAAAABAAAAIgGAADPDAAAigYAANAMAADIDAAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAADDAAASAAAAAQAAACSBgAA0QwAAJQGAADSDAAAyAwAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAAwwAAEgAAAAEAAAAnAYAANMMAACeBgAA1AwAAMgMAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAAMMAABIAAAABAAAAKQGAADVDAAApgYAANYMAADIDAAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABVbmV4cGVjdGVkIGRpY3Rpb25hcnkga2V5IHR5cGUgAHQeIQAfAAAAQ3cQAGQAAAA7AwAAEwAAAAwMAAAwAAAABAAAAAkCAADXDAAACwIAANgMAAAPDAAADQIAAAACAAABAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAOAgAA2QwAABACAADaDAAADwwAABICAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAywEAANsMAADNAQAA3AwAAA8MAADQAQAA0QEAANIBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAN4BAADdDAAA4AEAAN4MAAAPDAAA4gEAAOMBAADkAQAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAmDAAAZAAAAAQAAACyBAAA3wwAALQEAADgDAAA4QwAALcEAAC4BAAAuQQAALoEAAAQDAAAuwQAALwEAAC9BAAAvgQAAL8EAADABAAAwQQAAMIEAADDBAAATQwAACgAAAAEAAAAmgkAAOIMAACcCQAA4wwAAOQMAACfCQAAoAkAAKEJAACiCQAAowkAAF0MAACkCQAApQkAAKYJAACnCQAAqAkAAKkJAACqCQAAqwkAAE0MAAAoAAAABAAAAKwJAADlDAAArgkAAOYMAADkDAAAsAkAAKAJAAChCQAAogkAAKMJAABdDAAAsQkAAKUJAACmCQAApwkAALIJAACpCQAAqgkAAKsJAABNDAAAKAAAAAQAAACzCQAA5wwAALUJAADoDAAA5AwAALcJAACgCQAAoQkAAKIJAACjCQAAXQwAALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAVW5leHBlY3RlZCBkYXRhIHR5cGUgZm9yIHJ1bl9lbmRzIGFycmF5IGwhIQAoAAAAQ3cQAGQAAABBAwAAEwAAAEN3EABkAAAAdAMAAB4AAABDdxAAZAAAAHgDAAAjAAAAICAuLi4gZWxlbWVudHMuLi4sCgDMISEABQAAANEhIQAOAAAAICAsCiAgbnVsbCwKYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAA4qn8OK0OOH7FbC6gMU1KgEyaqF8hLELkfkWDr4NtNVwZYvpGHRWK7hhLcgqleyytByAbTXT+okm+n+f3GpIEeHJ+ylN+hDor2UVDl/G136/umzK4FJ7RuXDHeLNBWBcRwSMKlc3WKLCDFl9q32vM34f8VnuN8jE8tje6Ri8JfJZJsJ6Qek4sL8tuSeoyCBh8xfzyH3GFS3NuukzTz7gowrWh38fgqExDkv0R4mNj/KMofOLr7ovvGQKEKFjGuf0WPvMwG5AYZta8X2XUZ8lrNzWUzEI8vU3M9/nCXHUEmgLkVFHeVYSNNLVkopK66G8Z3JOhSbkke5YFuLkA0X7GDHs7Vg0XNz5GGUPph3+FHFKN0XrCpBkhd9kV254FF+mMhgAUgjtMRpmj6hikle0/++2i5dR7gLHU18EfJ15f4lxJSOs89WXxnHG5cnU+R41CZJuS9QyOC2DNaGfT4eNQuWuIBdEFkQ3gucbvJPmDBOGXKGzT/eMq2XzR7IFAx7B2i9qozLiexvSwUd4LjJ+uhNH4ncnRpf3OVuEjg+HJR3EfoU/E/CFBIdYixYjp17F4pBddj0p1IC1jlr4w3kLr7GOYOC6bqJpWsC9YjrdR6Id/HWoqIlT2wIb23M7m7swAeoxNLzEphhwjoC5rNYdVJjX8EWXtUm++JzmV/3oBUuUTAgBBuMiEAQtJUHJpbWl0aXZlQXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBnb3QgADgkIQAiAAAAWiQhAAUAAAAoCxAAcAAAAKICAAAJAAAAEgBBjMmEAQsCEAEAQZjJhAELAyMJAgBBpMmEAQsBEwBBsMmEAQsBDQBBvMmEAQsDJkwKAEHIyYQBCwISAQBB1MmEAQsCDQMAQeDJhAELAyQSBgBB7MmEAQsCEQMAQfjJhAELAg0CAEGEyoQBCwITAQBBkMqEAQsBEABBnMqEAQsCDQEAQajKhAELAhIDAEG0yoQBCwISAgBBwMqEAQsDJSYKAEHMyoQBCwIRAgBB2MqEAQvFHukMAAAwAAAABAAAAOoMAADpDAAAMAAAAAQAAADrDAAA6QwAADAAAAAEAAAA7AwAAOkMAAAwAAAABAAAAO0MAADpDAAAMAAAAAQAAADuDAAA6QwAADAAAAAEAAAA7wwAAOkMAAAwAAAABAAAAPAMAADpDAAAMAAAAAQAAADxDAAA6QwAADAAAAAEAAAA8gwAAOkMAAAwAAAABAAAAPMMAADpDAAAMAAAAAQAAAD0DAAA6QwAADAAAAAEAAAA9QwAAOkMAAAwAAAABAAAAPYMAADpDAAAMAAAAAQAAAD3DAAA6QwAADAAAAAEAAAA+AwAAOkMAAAwAAAABAAAAPkMAADpDAAAMAAAAAQAAAD6DAAA6QwAADAAAAAEAAAA+wwAAOkMAAAwAAAABAAAAPwMAADpDAAAMAAAAAQAAAD9DAAA6QwAADAAAAAEAAAA/gwAAOkMAAAwAAAABAAAAP8MAADpDAAAMAAAAAQAAAAADQAA6QwAADAAAAAEAAAAAQ0AAOkMAAAwAAAABAAAAAINAADpDAAAMAAAAAQAAAADDQAA6QwAADAAAAAEAAAABA0AAOkMAAAwAAAABAAAAAUNAADpDAAAMAAAAAQAAAAGDQAA6QwAADAAAAAEAAAABw0AAOkMAAAwAAAABAAAAAgNAADpDAAAMAAAAAQAAAAJDQAA6QwAADAAAAAEAAAACQIAAAoNAAALAgAACw0AAAwNAAANAgAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAADMDAAAODQAANQMAAA8NAAAMDQAANwMAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAARBwAAEA0AABMHAAARDQAADA0AABUHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAIgMAABINAAAkAwAAEw0AAAwNAAAmAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAA4CAAAUDQAAEAIAABUNAAAMDQAAEgIAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAD0AQAAFg0AAPYBAAAXDQAADA0AAPgBAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAJwMAABgNAAApAwAAGQ0AAAwNAAArAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAADAHAAAaDQAAMgcAABsNAAAMDQAANAcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAAMBwAAHA0AAA4HAAAdDQAADA0AABAHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAAgcAAB4NAAAEBwAAHw0AAAwNAAAGBwAA0QEAANIBAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAAcHAAAgDQAACQcAACENAAAMDQAACwcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABdAwAAIg0AAF8DAAAjDQAADA0AAGEDAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAPQMAACQNAAA/AwAAJQ0AAAwNAABBAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAN4BAAAmDQAA4AEAACcNAAAMDQAA4gEAAOMBAADkAQAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABTAwAAKA0AAFUDAAApDQAADA0AAFcDAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAFQMAACoNAAAXAwAAKw0AAAwNAAAaAwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAABsDAAAsDQAAHQMAAC0NAAAMDQAAHwMAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAADLAQAALg0AAM0BAAAvDQAADA0AANABAADRAQAA0gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAOgcAADANAAA8BwAAMQ0AAAwNAAA+BwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAACsHAAAyDQAALQcAADMNAAAMDQAALwcAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAAWBwAANA0AABgHAAA1DQAADA0AABoHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAAgIAADYNAAAEAgAANw0AAAwNAAAGAgAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAEIDAAA4DQAARAMAADkNAAAMDQAARgMAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABYAwAAOg0AAFoDAAA7DQAADA0AAFwDAABRAwAAUgMAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAIQcAADwNAAAjBwAAPQ0AAAwNAAAlBwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAPsBAAA+DQAA/QEAAD8NAAAMDQAA/wEAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABHAwAAQA0AAEkDAABBDQAADA0AAEsDAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAALgMAAEINAAAwAwAAQw0AAAwNAAAyAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAEwDAABEDQAATgMAAEUNAAAMDQAAUAMAAFEDAABSAwAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAA4AwAARg0AADoDAABHDQAADA0AADwDAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAANQcAAEgNAAA3BwAASQ0AAAwNAAA5BwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAACYHAABKDQAAKAcAAEsNAAAMDQAAKgcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABQcmltaXRpdmVBcnJheTw+ClsKAFgyIQAPAAAAZzIhAAQAAABdAAAAAQAAACgLEABwAAAAKgYAACgAAABQcmltaXRpdmVBcnJheSBkYXRhIHNob3VsZCBjb250YWluIGEgc2luZ2xlIGJ1ZmZlciBvbmx5ICh2YWx1ZXMgYnVmZmVyKQCUMiEARwAAACgLEABwAAAAJAYAAAkAAAD7lRAAXgAAAMwAAAARAAAA4AkQAGwAAACkAQAAPgAAAOAJEABsAAAA0gIAACcAAADgCRAAbAAAANICAAA9AAAAcIsQAH4AAAA0AAAABQAAAM51EABqAAAApwEAAB8AAAAkVxAAaQAAAEkAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAABaJyC5Kqr7Rxt695ZZTB0/k4m7jkYJLOcYSTiNQ4gt6aRNPG5KC1QQzZ2WuD4SBRhypH5ITzMwc3AcpD0kbPvOfDveFUdQQxVv5bQ/ivqicEam7sxQgwq8OmnkrbDT8UwGGSbbSd1M7t3XLru1Pa3m/HVOzHvjofLa8afBfIQDqQAAAAAAAAAAAQAAAEwNAAD7lRAAXgAAAMwAAAARAAAATGF5b3V0RXJyb3IABABBqOmEAQsBCABBtOmEAQsBCQBBwOmEAQsBBQBBzOmEAQsBBgBB2OmEAQsBAgBB5OmEAQsBBwBB8OmEAQsBAwBB/OmEAQvRDAEAAABEaWN0aW9uYXJ5QXJyYXkncyBkYXRhIHR5cGUgbXVzdCBtYXRjaCwgZXhwZWN0ZWQgIGdvdCAAAAA1IQAxAAAAMTUhAAUAAAASBBAAcQAAAFYCAAANAAAAEgQQAHEAAABeAgAAJQAAAERpY3Rpb25hcnlBcnJheSBtdXN0IGhhdmUgRGljdGlvbmFyeSBkYXRhIHR5cGUuAGg1IQAvAAAAEgQQAHEAAABzAgAADQAAAERpY3Rpb25hcnlBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzKS4AAACwNSEAPQAAABIEEABxAAAATwIAAAkAAABEaWN0aW9uYXJ5QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAoa2V5cykuCDYhAEAAAAASBBAAcQAAAEoCAAAJAAAATQ0AAEgAAAAEAAAATg0AAE0NAABIAAAABAAAAE8NAABNDQAASAAAAAQAAABQDQAATQ0AAEgAAAAEAAAAUQ0AAE0NAABIAAAABAAAAFINAABNDQAASAAAAAQAAABTDQAATQ0AAEgAAAAEAAAAVA0AAE0NAABIAAAABAAAAFUNAABNDQAASAAAAAQAAABuBgAAVg0AAHAGAABXDQAAWA0AAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAATQ0AAEgAAAAEAAAAewYAAFkNAAB9BgAAWg0AAFgNAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAE0NAABIAAAABAAAAIgGAABbDQAAigYAAFwNAABYDQAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAABNDQAASAAAAAQAAABhBgAAXQ0AAGMGAABeDQAAWA0AAGUGAABmBgAAZwYAAGgGAABXBgAAWAYAAGkGAABaBgAAWwYAAFwGAABqBgAAawYAAGwGAABtBgAATQ0AAEgAAAAEAAAAkgYAAF8NAACUBgAAYA0AAFgNAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAE0NAABIAAAABAAAAKQGAABhDQAApgYAAGINAABYDQAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABNDQAASAAAAAQAAACcBgAAYw0AAJ4GAABkDQAAWA0AAKAGAABzBgAAdAYAAKEGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAKIGAACjBgAATQ0AAEgAAAAEAAAATgYAAGUNAABQBgAAZg0AAFgNAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAERpY3Rpb25hcnlBcnJheSB7a2V5czogIHZhbHVlczogfQoAAKA5IQAXAAAAtzkhAAkAAADAOSEAAgAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBSdW5FbmRCdWZmZXIgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3Ro3DkhAFAAAAAhSRAAZgAAAMEAAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAAA+5LQ2Xu/G4ixFOEDatCG6UZ972aqE6KmHG/D5dJSpk2HhTDnwP3HEjZR4sXOcWecAAAAABAAAAAQAAAARBQAAAAAAAAQAAAAEAAAA9wsAAAAAAAAEAAAABAAAAEgIAAAAAAAABAAAAAQAAABtAwAA1zIQAHgAAADrBwAACQBB2PaEAQvJCwEAAABtDQAA+5UQAF4AAADMAAAAEQAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAAB1CRAAagAAAAwBAAAWAAAASW5jb3JyZWN0IHJ1biBlbmRzIHR5cGUAnDshABcAAAB1CRAAagAAAA0BAAAJAAAAdQkQAGoAAAAPAQAAGgAAAHUJEABqAAAAEwEAACEAAABJbnZhbGlkIGRhdGEgdHlwZSBmb3IgUnVuQXJyYXkuIFRoZSBkYXRhIHR5cGUgc2hvdWxkIGJlIERhdGFUeXBlOjpSdW5FbmRFbmNvZGVkAOw7IQBPAAAAdQkQAGoAAAAGAQAAEQAAAG4NAAAoAAAABAAAAG8NAABuDQAAKAAAAAQAAABwDQAAbg0AACgAAAAEAAAAcQ0AAG4NAAAoAAAABAAAAJoJAAByDQAAnAkAAHMNAAB0DQAAnwkAAKAJAAChCQAAogkAAKMJAAB1DQAApAkAAKUJAACmCQAApwkAAKgJAACpCQAAqgkAAKsJAABuDQAAKAAAAAQAAACzCQAAdg0AALUJAAB3DQAAdA0AALcJAACgCQAAoQkAAKIJAACjCQAAdQ0AALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAbg0AACgAAAAEAAAArAkAAHgNAACuCQAAeQ0AAHQNAACwCQAAoAkAAKEJAACiCQAAowkAAHUNAACxCQAApQkAAKYJAACnCQAAsgkAAKkJAACqCQAAqwkAAHUJEABqAAAAdwEAAAkAAABSdW5BcnJheSB7cnVuX2VuZHM6ICwgdmFsdWVzOiB9Cpw9IQAUAAAAsD0hAAoAAAC6PSEAAgAAAGNvbHVtbiB0eXBlcyBtdXN0IG1hdGNoIHNjaGVtYSB0eXBlcywgZXhwZWN0ZWQgIGJ1dCBmb3VuZCAgYXQgY29sdW1uIGluZGV4IADUPSEALwAAAAM+IQALAAAADj4hABEAAABhbGwgY29sdW1ucyBpbiBhIHJlY29yZCBiYXRjaCBtdXN0IGhhdmUgdGhlIHNhbWUgbGVuZ3RoYWxsIGNvbHVtbnMgaW4gYSByZWNvcmQgYmF0Y2ggbXVzdCBoYXZlIHRoZSBzcGVjaWZpZWQgcm93IGNvdW50Q29sdW1uICcnIGlzIGRlY2xhcmVkIGFzIG5vbi1udWxsYWJsZSBidXQgY29udGFpbnMgbnVsbCB2YWx1ZXOuPiEACAAAALY+IQA2AAAAbnVtYmVyIG9mIGNvbHVtbnMoKSBtdXN0IG1hdGNoIG51bWJlciBvZiBmaWVsZHMoKSBpbiBzY2hlbWEA/D4hABIAAAAOPyEAHgAAACw/IQALAAAAbXVzdCBlaXRoZXIgc3BlY2lmeSBhIHJvdyBjb3VudCBvciBhdCBsZWFzdCBvbmUgY29sdW1udGFyZ2V0IHNjaGVtYSBpcyBub3Qgc3VwZXJzZXQgb2YgY3VycmVudCBzY2hlbWEgdGFyZ2V0PSBjdXJyZW50PQAAhj8hADcAAAC9PyEACQAAAKxeEABnAAAAYQIAABYAAABhc3NlcnRpb24gZmFpbGVkOiAob2Zmc2V0ICsgbGVuZ3RoKSA8PSBzZWxmLm51bV9yb3dzKCkAAKxeEABnAAAAmQIAAAkAAAAAAAAAQ2Fubm90IGNvbnZlcnQgbnVsbGFibGUgU3RydWN0QXJyYXkgdG8gUmVjb3JkQmF0Y2gsIHNlZSBTdHJ1Y3RBcnJheSBkb2N1bWVudGF0aW9uAAAANEAhAFEAAACsXhAAZwAAADoDAAAJAAAAAT8QAIcAAABjAQAADAAAAEludmFsaWQgdGltZXpvbmUgIiI6IG9ubHkgb2Zmc2V0IGJhc2VkIHRpbWV6b25lcyBzdXBwb3J0ZWQgd2l0aG91dCBjaHJvbm8tdHogZmVhdHVyZbBAIQASAAAAwkAhAEIAAACxBxAAbQAAAEwAAAAKAEHAgoUBCwEJAEHQgoUBCwFjAEHggoUBCwLnAwBB8IKFAQsCDycAQYCDhQELA5+GAQBBkIOFAQsDP0IPAEGgg4UBCwN/lpgAQbCDhQELBP/g9QUAQcCDhQELBP/JmjsAQdCDhQELBf/jC1QCAEHgg4UBCwX/53ZIFwBB8IOFAQsF/w+l1OgAQYCEhQELBv+fck4YCQBBkISFAQsG/z96EPNaAEGghIUBCwf/f8akfo0DAEGwhIUBCwf//8Bv8oYjAEHAhIUBC+AC//+JXXhFYwEAAAAAAAAAAP//Y6eztuANAAAAAAAAAAD//+eJBCPHigAAAAAAAAAA//8PYy1ex2sFAAAAAAAAAP//n97Frck1NgAAAAAAAAD//z+yusngGR4CAAAAAAAA//9/9krhxwItFQAAAAAAAP///6DtzM4bwtMAAAAAAAD///9JSAEUFpVFCAAAAAAA////49IMyNzSt1IAAAAAAP///+c8gNCfPC47AwAAAAD///8PYQIlPl7OTyAAAAAA////n8oXcm2uDx5DAQAAAP///z/q7XRG0JwsnwwAAAD///9/JkuRwCIgvjd+AAAA/////4DvrIVbQW0t7gQAAP////8JW8E4k41Exk0xAAD/////Y46NN8CHrb4J7QEA/////+ePhyuCTcdyYUITAP////8Pn0uzFQfJe86XwAD/////nzb0ANlG2tUQ7oUH/////z8iigl6xIZaqEw7SwBBsIeFAQvlCPf///////////////////+d////////////////////Gfz///////////////////HY//////////////////9hef7/////////////////wb3w/////////////////4FpZ/////////////////8BHwr6////////////////ATZlxP///////////////wEc9Kv9//////////////8BGIm36P//////////////AfBaKxf//////////////wFgjbHn9v////////////8BwIXvDKX/////////////AYA5W4Fy/P///////////wEAP5ANedz///////////8BAHaih7qc/v//////////AQCcWExJH/L//////////wEAGHb73Dh1//////////8BAPCc0qE4lPr/////////AQBgITpSNsrJ/////////wEAwE1FNh/m4f3///////8BAIAJtR44/dLq////////AQAAXxIzMeQ9LP///////wEAALa3/uvparr3//////8BAAAcLfM3Iy1Irf//////AQAAGMN/L2DD0cT8/////wEAAPCe/drBoTGw3/////8BAABgNeiNklHw4bz+////AQAAwBUSi7kvY9Ng8////wEAAIDZtG4/3d9ByIH///8BAAAAfxBTeqS+ktIR+///AQAAAPakPsdscrs5ss7//wEAAACccXLIP3hSQfYS/v8BAAAAGHB41H2yOI2evez/AQAAAPBgtEzq+DaEMWg//wEAAABgyQv/JrklKu8RevgBAAAAwN119oU7eaVXs8S0IGlzIHRvbyBzbWFsbCB0byBzdG9yZSBpbiBhIERlY2ltYWwxMjggb2YgcHJlY2lzaW9uIC4gTWluIGlzIAAAAAEAAAAAAAAAEEYhADQAAABERiEACQAAACBpcyB0b28gbGFyZ2UgdG8gc3RvcmUgaW4gYSBEZWNpbWFsMTI4IG9mIHByZWNpc2lvbiAuIE1heCBpcyAAAAABAAAAAAAAAGhGIQA0AAAAnEYhAAkAAAAmTWF4IHByZWNpc2lvbiBvZiBhIERlY2ltYWwxMjggaXMgLCBidXQgZ290IMFGIQAhAAAA4kYhAAoAAAAAAAAACQAAAGMAAADnAwAADycAAJ+GAQA/Qg8Af5aYAP/g9QX/yZo7AAAAAPf///+d////Gfz///HY//9hef7/wb3w/4FpZ/8BHwr6ATZlxCBpcyB0b28gc21hbGwgdG8gc3RvcmUgaW4gYSBEZWNpbWFsMzIgb2YgcHJlY2lzaW9uIAABAAAAAAAAAExHIQAzAAAAREYhAAkAAAAgaXMgdG9vIGxhcmdlIHRvIHN0b3JlIGluIGEgRGVjaW1hbDMyIG9mIHByZWNpc2lvbiAAAQAAAAAAAACYRyEAMwAAAJxGIQAJAAAACU1heCBwcmVjaXNpb24gb2YgYSBEZWNpbWFsMzIgaXMgAAAA5UchACAAAADiRiEACgBBoJCFAQvxAwkAAAAAAAAAYwAAAAAAAADnAwAAAAAAAA8nAAAAAAAAn4YBAAAAAAA/Qg8AAAAAAH+WmAAAAAAA/+D1BQAAAAD/yZo7AAAAAP/jC1QCAAAA/+d2SBcAAAD/D6XU6AAAAP+fck4YCQAA/z96EPNaAAD/f8akfo0DAP//wG/yhiMA//+JXXhFYwH//2Ons7bgDQAAAAAAAAAA9/////////+d/////////xn8////////8dj///////9hef7//////8G98P//////gWln//////8BHwr6/////wE2ZcT/////ARz0q/3///8BGIm36P///wHwWisX////AWCNsef2//8BwIXvDKX//wGAOVuBcvz/AQA/kA153P8BAHaih7qc/gEAnFhMSR/yIGlzIHRvbyBzbWFsbCB0byBzdG9yZSBpbiBhIERlY2ltYWw2NCBvZiBwcmVjaXNpb24gAAEAAAAAAAAASEkhADMAAABERiEACQAAACBpcyB0b28gbGFyZ2UgdG8gc3RvcmUgaW4gYSBEZWNpbWFsNjQgb2YgcHJlY2lzaW9uIAABAAAAAAAAAJRJIQAzAAAAnEYhAAkAAAASTWF4IHByZWNpc2lvbiBvZiBhIERlY2ltYWw2NCBpcyAAAADhSSEAIAAAAOJGIQAKAEHAlIUBCwEJAEHglIUBCwFjAEGAlYUBCwLnAwBBoJWFAQsCDycAQcCVhQELA5+GAQBB4JWFAQsDP0IPAEGAloUBCwN/lpgAQaCWhQELBP/g9QUAQcCWhQELBP/JmjsAQeCWhQELBf/jC1QCAEGAl4UBCwX/53ZIFwBBoJeFAQsF/w+l1OgAQcCXhQELBv+fck4YCQBB4JeFAQsG/z96EPNaAEGAmIUBCwf/f8akfo0DAEGgmIUBCwf//8Bv8oYjAEHAmIUBCwj//4ldeEVjAQBB4JiFAQsI//9jp7O24A0AQYCZhQELCP//54kEI8eKAEGgmYUBCwn//w9jLV7HawUAQcCZhQELCf//n97Frck1NgBB4JmFAQsK//8/srrJ4BkeAgBBgJqFAQsK//9/9krhxwItFQBBoJqFAQsK////oO3MzhvC0wBBwJqFAQsL////SUgBFBaVRQgAQeCahQELC////+PSDMjc0rdSAEGAm4UBCwz////nPIDQnzwuOwMAQaCbhQELDP///w9hAiU+Xs5PIABBwJuFAQsN////n8oXcm2uDx5DAQBB4JuFAQsN////P+rtdEbQnCyfDABBgJyFAQsN////fyZLkcAiIL43fgBBoJyFAQsO/////4DvrIVbQW0t7gQAQcCchQELDv////8JW8E4k41Exk0xAEHgnIUBCw//////Y46NN8CHrb4J7QEAQYCdhQELD//////nj4crgk3HcmFCEwBBoJ2FAQsP/////w+fS7MVB8l7zpfAAEHAnYUBCxD/////nzb0ANlG2tUQ7oUHAEHgnYUBCxD/////PyKKCXrEhlqoTDtLAEGAnoUBCxH/////f1ZlX8SsQ4mT/lDwAgBBoJ6FAQsR//////9g9bmrv6Rcw/EpYx0AQcCehQELEv//////yZVDtXxvnqFxo98lAQBB4J6FAQsS///////j2aMU31owUHBivHoLAEGAn4UBCxL//////+eCZs62jOMhY9hby3IAQaCfhQELE///////Dx0BECR/41Lfc5bxewQAQcCfhQELE///////nyILoGj34jy5huBv1ywAQeCfhQELFP//////P1pvQBaq3WA8Q8VeasABAEGAoIUBCxT//////3+GWYTepKjIW6C0syeEEQBBoKCFAQsU////////QH8rsXCW1pVDDgWNKa8AQcCghQELFf///////4n4sutm4GHao44ygp/XBgBB4KCFAQsV////////Y7X9NAXE0odmkvkVO2xEAEGAoYUBCxb////////nFekRNKg7TgG4v9tOOqwCAEGgoYUBCxb///////8P2xqzCJJUDg0wfZUUR7oaAEHAoYUBCxf///////+fjgz/VrRNj4Lg49bNxkYLAQBB4KGFAQsX////////P5J99mULCZkZxeZkCsTDcAoAQYCihQELF////////3+256D7cVr6/7ID8WeopWdoAEGgooUBC6AF/////////yANSdRziMf//SRqD5R4DBQEAAAAAAAAAAD/////////SYPaSoZUy/3rcSWayLV8yCgAAAAAAAAAAP/////////jIInsPk3x6TdzdgXWGd/UlwEAAAAAAAAA/////////+dIWz11BG0jL4CgNlwCt1DuDwAAAAAAAAD/////////D9mQZZQsQmLXAUUimhcmJ0+fAAAAAAAAAP////////+feqj3y72V1mkSslYF7HyHFzkGAAAAAAAA/////////z/KlKz3adlhIrj0YjU44UrrOj4AAAAAAAD/////////f+bPvawjftJXMY/dFTLM7DBNbgIAAAAAAP//////////AB9qv2TtOG7tl6fa9Pk/6QNPGAAAAAAA//////////8JNiV670U5Tkbvi4qQw38cJxbzAAAAAAD//////////2McdMVauzwOv1h3aaWj/RyH3X4JAAAAAP//////////5xuJtotRX452d6kedmToIUen9F4AAAAA//////////8PF1shdS+5j6GqnjKd7BNTx4iOtQMAAAD//////////5/mjk2T2judT6oy+iM+xz7JV5EXJQAAAP//////////PwKVB8GJViQcp/rFZ23Ic9xtretyAQAA//////////9/FtJLimFhaxmHyrsNRtSFnErGNH0OAAD////////////gNPZmz80x/kbpVYm8Sjod6r4P5JAAAP///////////8kQngUaCvLtxRxbXV3rRiQldZ3oqAUA////////////46csOARldEu7H4+lpTHFanOTJhaZOAD////////////njr4xKvKL8lA9l3d48LMrgsKB3fo1Av///////////w+VcfGldXd5KWXoq7RkB7UVmRGnzBsWAEHgp4UBC+IU9/////////////////////////////////////////+d/////////////////////////////////////////xn8////////////////////////////////////////8dj///////////////////////////////////////9hef7//////////////////////////////////////8G98P//////////////////////////////////////gWln//////////////////////////////////////8BHwr6/////////////////////////////////////wE2ZcT/////////////////////////////////////ARz0q/3///////////////////////////////////8BGIm36P///////////////////////////////////wHwWisX////////////////////////////////////AWCNsef2//////////////////////////////////8BwIXvDKX//////////////////////////////////wGAOVuBcvz/////////////////////////////////AQA/kA153P////////////////////////////////8BAHaih7qc/v///////////////////////////////wEAnFhMSR/y////////////////////////////////AQAYdvvcOHX///////////////////////////////8BAPCc0qE4lPr//////////////////////////////wEAYCE6UjbKyf//////////////////////////////AQDATUU2H+bh/f////////////////////////////8BAIAJtR44/dLq/////////////////////////////wEAAF8SMzHkPSz/////////////////////////////AQAAtrf+6+lquvf///////////////////////////8BAAAcLfM3Iy1Irf///////////////////////////wEAABjDfy9gw9HE/P//////////////////////////AQAA8J792sGhMbDf//////////////////////////8BAABgNeiNklHw4bz+/////////////////////////wEAAMAVEou5L2PTYPP/////////////////////////AQAAgNm0bj/d30HIgf////////////////////////8BAAAAfxBTeqS+ktIR+////////////////////////wEAAAD2pD7HbHK7ObLO////////////////////////AQAAAJxxcsg/eFJB9hL+//////////////////////8BAAAAGHB41H2yOI2evez//////////////////////wEAAADwYLRM6vg2hDFoP///////////////////////AQAAAGDJC/8muSUq7xF6+P////////////////////8BAAAAwN119oU7eaVXs8S0/////////////////////wEAAACAqZqgO1O8dmwBrw/9////////////////////AQAAAACfCkZUQFujPA7WnOL///////////////////8BAAAAADZqvEqDkGFejlwg2v7//////////////////wEAAAAAHCZc6yClz6+PnUOF9P//////////////////AQAAAAAYfZkxSXMc3pwnpDSN//////////////////8BAAAAAPDi/u/bgBytIIxpDoT7/////////////////wEAAAAAYN30X5cIHcNGeR+QKNP/////////////////AQAAAADApZC/6VUin8O8OqGVP/7///////////////8BAAAAAIB5pnshW1c3pF9LTNh77v///////////////wEAAAAAAL+A1E6PaSlqvPH6ctZQ////////////////AQAAAAAAdgdNFJkfniVccc19YCj5//////////////8BAAAAAACcSgLL+jsteJltBurEk7v//////////////wEAAAAAABjqFu7LV8Sx/kdAJLHFU/3/////////////AQAAAAAA8CTlTPdtq/Hyz4Jq67hF5f////////////8BAAAAAABgcfMAqUuycH0fHCkyObn0/v///////////wEAAAAAAMBtggma9PZm5joZm/U7PI/1////////////AQAAAAAAgEkYXwSOpQUATfwOmFdamJf///////////8BAAAAAAAA3/K2K4x3OAAC25Xwa4fz6/v//////////wEAAAAAAAC2fCW1eas0AhSO2mU3SoM31///////////AQAAAAAAABzfdhPBsg4WyIyJ+inmICto/v////////8BAAAAAAAAGLekwor7ktzQf1/Jo/1IrxHw/////////wEAAAAAAADwJm+aa9O9nSj+ut1l6NnYsGD/////////AQAAAAAAAGCFVwg0Qmoplu1NqfoTg3joxvn///////8BAAAAAAAAwDVrUwiWJp7dRwudyscetRTFwf///////wEAAAAAAACAGTBCU9yBLajOcCLqzTMTz7KR/f//////AQAAAAAAAAD/4JVAmxLHkRJoWCULBsAW/LDn//////8BAAAAAAAAAPbJ2oUQusaxuRB0dW88gOPY6Qz//////wEAAAAAAAAAnOOLOqVEw/FAp4iWWlwC43gigfb/////AQAAAAAAAAAY5HZJdK6gcYmIVuGJmxfeuFgLof////8BAAAAAAAAAPDopN6K0EZwXlVhzWIT7Kw4d3FK/P///wEAAAAAAAAAYBlxsmwlxGKwVc0F3ME4wTaobuja////AQAAAAAAAADA/Wr4Pnap2+NYBTqYkjeMI5JSFI3+//8BAAAAAAAAAIDpLbR1np6U5ng1RPK5K3pjtTnLgvH//wEAAAAAAAAAAB/LCZkwMs4BuRaqdkO1xeIVQfAbb///AQAAAAAAAAAANu9h+uX1DRI646SiohS529qKYhdX+v8BAAAAAAAAAAAcWNPH+5qLtETgcFpazjqVjGzZ6WbH/wEAAAAAAAAAABhxQc7VDXQNr8JoiIcPTNR9PX4iBcr9AQAAAAAAAAAA8GqODlqKiIbWmhdUS5v4Supm7lgz5OkgaXMgdG9vIHNtYWxsIHRvIHN0b3JlIGluIGEgRGVjaW1hbDI1NiBvZiBwcmVjaXNpb24gAQAAAAAAAABgXSEANAAAAERGIQAJAAAAIGlzIHRvbyBsYXJnZSB0byBzdG9yZSBpbiBhIERlY2ltYWwyNTYgb2YgcHJlY2lzaW9uIAEAAAAAAAAArF0hADQAAACcRiEACQAAAExNYXggcHJlY2lzaW9uIG9mIGEgRGVjaW1hbDI1NiBpcyAAAPldIQAhAAAA4kYhAAoAAAB7DQAADAAAAAQAAAB8DQAAfQ0AAMcHAEHMvIUBC6EHAQAAAH4NAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAADseRAAawAAAEEDAAAVAAAA4l8QAGsAAADoAQAAFwAAAOJfEABrAAAAVAsAAAEAAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpITEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5SUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxgXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5kYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYgAAAOUqEABlAAAACAEAABsAAAABAAAAAAAAAAIAQfbDhQELAQUAQYDEhQELESAAIOkuAAAABGIhAAEAAAACAEGaxIUBCwEDAEGkxIUBCwUgAADpAgBBssSFAQsBBgBBvMSFAQsFIAAA6QIAQcrEhQELAQkAQdTEhQELwQIgAADpd3JpdGluZyByZmMzMzM5IGRhdGV0aW1lIHRvIHN0cmluZyBzaG91bGQgbmV2ZXIgZmFpbHuEEABiAAAAfwIAAA4AAADOdRAAagAAAL0BAAAdAAAAdmFsdWUgbGVuZ3RoICgpIG9mIHRoZSBhcnJheSBtdXN0ID49IDAAAKxiIQAOAAAAumIhABgAAAANQBAAfAAAADsAAAAJAAAADUAQAHwAAABAAAAAHQAAAIpAEAB9AAAAZgAAABsAAACKQBAAfQAAABQBAAAYAAAAikAQAH0AAAAbAQAAPAAAAIpAEAB9AAAAJwEAACIAAACKQBAAfQAAACUBAAAXAAAAyCwQAGAAAACWAwAAOQAAAC0AAADILBAAYAAAAPYFAAAfAAAAMC4AAAEAAAAAAAAAeGMhAAIAAAACAAAAAAAAAAIAQaDHhQELkwEgAADgAgAAAAAAAAABAAAAAgAAAAEAAAAwAACoAQAAAAAAAAAEYiEAAQAAAAIAAAAAAAAAAQAAAAEAAAAAAAAAMAAAiAAAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEY//////////8oZCEAQcTIhQELuh4EAAAABAAAAH8NAACADQAAgA0AAAAAAAAEAAAABAAAAH8NAACADQAAgA0AAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIJVEABoAAAAhgAAACYAAACvOQRL4Rz3M6BSkd6ERkmNK0wkXtFX+YAWCn4Fj6VnYc51EABqAAAApwEAAB8AAABuBRAAcAAAALIAAAAjAAAAU3RyaW5nAADwZCEABgAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFZpZXdBcnJheSBvZiBsZW5ndGggAAAAAGUhACUAAAAlZSEACAAAAC1lIQAUAAAAbgUQAHAAAAAyAQAACQAAAEJpbmFyeQAAbGUhAAYAAABuBRAAcAAAALEBAAAjAAAAVmlld0FycmF5ClsKAQAAAAAAAACMZSEADAAAAF0AAACBDQAAPAAAAAQAAACCDQAAgQ0AADwAAAAEAAAAgw0AAIENAAA8AAAABAAAAEQGAACEDQAARgYAAIUNAACGDQAASAYAADcGAAA4BgAAOQYAAIcNAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAACBDQAAPAAAAAQAAAAxBgAAiA0AADMGAACJDQAAhg0AADYGAAA3BgAAOAYAADkGAACHDQAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAbgUQAHAAAAAvAwAAFgAAAG4FEABwAAAAZwMAABUAAABuBRAAcAAAAGkDAAAmAAAAikAQAH0AAAAUAQAAGAAAAIpAEAB9AAAAUwEAAD0AAACKQBAAfQAAAFMBAAAnAAAAikAQAH0AAABlAQAAHgAAAIpAEAB9AAAAaAEAABoAAACKQBAAfQAAAHABAAAbAAAAikAQAH0AAAA7AQAAHwAAAIpAEAB9AAAAgQEAABsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAADj/9aYBcp+WmvV4R6JQCoke7I8HJu1h/yBm9JjW7WZ7pXGSEtF/rhGs2cet9Q4ijLXMhAAeAAAAOsHAAAJAAAAig0AABQAAAAEAAAAiw0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA+5UQAF4AAADMAAAAEQAAAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAIwNAAAMAAAABAAAAI0NAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yAM51EABqAAAAvQEAAB0AAADQBhAAawAAANYAAAApAAAAAQAAAAAAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBMaXN0QXJyYXksIGV4cGVjdGVkICBnb3QgAAAAbGkhACQAAACQaSEAFAAAAKRpIQAFAAAATm9uLW51bGxhYmxlIGZpZWxkIG9mIExpc3RBcnJheSAgY2Fubm90IGNvbnRhaW4gbnVsbHMAAADEaSEAFgAAANppIQAKAAAA5GkhABUAAABMaXN0QXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBmb3IgAAABAAAAAAAAABRqIQAdAAAApGkhAAUAAAAxaiEABQAAAE1heCBvZmZzZXQgb2YgIGV4Y2VlZHMgbGVuZ3RoIG9mIHZhbHVlcyBYaiEADgAAAGZqIQAaAAAATGFyZ2UAAACQaiEABQAAANAGEABrAAAADgEAADYAAADQBhAAawAAAF4BAAATAAAA0AYQAGsAAABfAQAAFQAAAEV4cGVjdGVkIGluZmFsbGlibGUgY3JlYXRpb24gb2YgR2VuZXJpY0xpc3RBcnJheSBmcm9tIEFycmF5RGF0YVJlZiBmYWlsZWQAAADQBhAAawAAALsBAAAOAAAA0AYQAGsAAADuAQAAFgAAAFtMYXJnZV1MaXN0QXJyYXkncyBjaGlsZCBkYXRhdHlwZSAgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgTGlzdCdzIGRhdGF0eXBlIAAAPGshACIAAABeayEALAAAAFtMYXJnZV1MaXN0QXJyYXkncyBkYXRhdHlwZSBtdXN0IGJlIFtMYXJnZV1MaXN0QXJyYXkoKS4gSXQgaXMgAACcayEAPgAAAExpc3RBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzIGFycmF5KSwgaGFkIAAA5GshAEIAAABMaXN0QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAodmFsdWUgb2Zmc2V0cyksIGhhZCAwbCEASAAAAI4NAAA4AAAABAAAAI8NAACODQAAOAAAAAQAAACQDQAAjg0AADgAAAAEAAAA+AQAAJENAAD6BAAAkg0AAJMNAAD8BAAA/QQAAP4EAADtBAAAlA0AAO8EAADwBAAA8QQAAPIEAADzBAAA9AQAAPUEAAD2BAAA9wQAAI4NAAA4AAAABAAAAOUEAACVDQAA5wQAAJYNAACTDQAA6gQAAOsEAADsBAAA7QQAAJQNAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABMaXN0QXJyYXkKWwoBAAAAAAAAAFBtIQAMAAAAXQAAAJYIEABqAAAARQAAACkAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBNYXBBcnJheSwgZXhwZWN0ZWQgAIBtIQA3AAAApGkhAAUAAABNYXBBcnJheSBlbnRyaWVzIG11c3QgY29udGFpbiB0d28gY2hpbGRyZW4sIGdvdCDIbSEAMAAAAE1hcEFycmF5IGV4cGVjdGVkIGRhdGEgdHlwZSAAbiEAHAAAAKRpIQAFAAAAMWohAAUAAABNYXBBcnJheSBlbnRyaWVzIGNhbm5vdCBjb250YWluIG51bGxzIGV4Y2VlZHMgbGVuZ3RoIG9mIGVudHJpZXMgWGohAA4AAABZbiEAGwAAAJYIEABqAAAAhAAAAEAAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RllggQAGoAAADSAAAAEwAAAJYIEABqAAAA0wAAABUAAABFeHBlY3RlZCBpbmZhbGxpYmxlIGNyZWF0aW9uIG9mIE1hcEFycmF5IGZyb20gQXJyYXlEYXRhIGZhaWxlZAAAlggQAGoAAAD3AAAADgAAAJYIEABqAAAAHwEAABcAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBhcnJheSB3aXRoIDIgZmllbGRzLCBoYXZlICBmaWVsZHMAADxvIQA7AAAAd28hAAcAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBhcnJheSBjaGlsZCwgZm91bmQgkG8hADQAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzIGFycmF5KSwgaGFkIAAAAMxvIQBBAAAATWFwQXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAodmFsdWUgb2Zmc2V0cyksIGhhZCAAGHAhAEcAAABNYXBBcnJheSBleHBlY3RlZCBBcnJheURhdGEgd2l0aCBEYXRhVHlwZTo6TWFwIGdvdCAAaHAhADMAAACXDQAAZAAAAAQAAACYDQAAlw0AAGQAAAAEAAAAsgQAAJkNAAC0BAAAmg0AAJsNAAC3BAAAuAQAALkEAAC6BAAAlA0AALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAMEEAADCBAAAwwQAAE1hcEFycmF5ClsKaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogVGhpcyBzaG91bGQgYmUgYSBtYXAgdHlwZS4AF3EhAEQAAACWCBAAagAAAMIBAAASAAAA4AkQAGwAAADJAgAAEgAAAG4FEABwAAAArwMAABcAAACxBxAAbQAAAEwAAAAKAAAAb2Zmc2V0IG92ZXJmbG93AAZHEABpAAAARgAAADQAAABsZW5ndGggb3ZlcmZsb3cABkcQAGkAAABHAAAALgAAAE1lbW9yeSBwb2ludGVyIGlzIG5vdCBhbGlnbmVkIHdpdGggdGhlIHNwZWNpZmllZCBzY2FsYXIgdHlwZeRxIQA8AAAABkcQAGkAAAChAAAAKgAAAE1lbW9yeSBwb2ludGVyIGZyb20gZXh0ZXJuYWwgc291cmNlIChlLmcsIEZGSSkgaXMgbm90IGFsaWduZWQgd2l0aCB0aGUgc3BlY2lmaWVkIHNjYWxhciB0eXBlLiBCZWZvcmUgaW1wb3J0aW5nIGJ1ZmZlciB0aHJvdWdoIEZGSSwgcGxlYXNlIG1ha2Ugc3VyZSB0aGUgYWxsb2NhdGlvbiBpcyBhbGlnbmVkLgAAOHIhAK4AAAAGRxAAaQAAAKYAAAARAAAAU2NhbGFyQnVmZmVyAAAAAAgAAAAEAAAAaA0AAAAAAAAIAAAABAAAAJwNAAAIQRAAeAAAADEAAAAjAAAACEEQAHgAAAAyAAAAGQAAAAhBEAB4AAAANAAAABwAAAAIQRAAeAAAAMEAAAAeAAAAgUEQAHQAAACZAAAAHQAAABIBAEGI54UBCwEQAEGU54UBCwISAwBBoOeFAQsBDQBBrOeFAQsCEwEAQbjnhQELAg0CAEHE54UBCwMjCQIAQdDnhQELAhECAEHc54UBCwESAEHo54UBCwIRAwBB9OeFAQsDJSYKAEGA6IUBCwMkEgYAQYzohQELAhABAEGY6IUBCwISAgBBpOiFAQsBEwBBsOiFAQsCDQEAQbzohQELAg0DAEHI6IUBCwMmTAoAQdTohQELAhMCAEHg6IUBC/0BaW5jb21wYXRpYmxlIGRhdGEgdHlwZSBmb3IgYnVpbGRlciwgZXhwZWN0ZWQgIGdvdCAAAGB0IQAtAAAAjXQhAAUAAACBQRAAdAAAALwAAAAJAAAAf2oQAGMAAAAsAAAACwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAL6cKpGRNjRgxUhAFxEOmzQKUbMsEqoS6gtZ3tvU7Lw51zIQAHgAAADrBwAACQBB6OqFAQvpBAEAAACdDQAAng0AABQAAAAEAAAAnw0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAoA0AAAwAAAAEAAAAoQ0AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3JMYXlvdXRFcnJvcgAAznUQAGoAAACnAQAAHwAAAM51EABqAAAAvQEAAB0AAABCb29sZWFuQXJyYXkKWwpdQ3chAAEAAABNChAAbgAAAFsAAAANAAAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgQm9vbGVhbkFycmF5IG9mIGxlbmd0aCBcdyEAJQAAAIF3IQAfAAAATQoQAG4AAADGAAAACQAAAKINAAAsAAAABAAAAKMNAAABAEHc74UBC8cOog0AACwAAAAEAAAAAgMAAKQNAAAEAwAApQ0AAKYNAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAANB3IQBCb29sZWFuQXJyYXkgZXhwZWN0ZWQgQXJyYXlEYXRhIHdpdGggdHlwZSAgZ290IAA4eCEAKgAAAGJ4IQAFAAAATQoQAG4AAACGAQAACQAAAAEAAABNChAAbgAAAJIBAAApAAAAQm9vbGVhbkFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gYSBzaW5nbGUgYnVmZmVyIG9ubHkgKHZhbHVlcyBidWZmZXIpAAAAnHghAEUAAABNChAAbgAAAI0BAAAJAAAAsQcQAG0AAABbAAAALgAAAHVzZSBTdHJ1Y3RBcnJheTo6dHJ5X25ld193aXRoX2xlbmd0aCBvciBTdHJ1Y3RBcnJheTo6bmV3X2VtcHR5X2ZpZWxkcyB0byBjcmVhdGUgYSBzdHJ1Y3QgYXJyYXkgd2l0aCBubyBmaWVsZHMgc28gdGhhdCB0aGUgbGVuZ3RoIGNhbiBiZSBzZXQgY29ycmVjdGx5SW5jb3JyZWN0IG51bWJlciBvZiBudWxscyBmb3IgU3RydWN0QXJyYXksIGV4cGVjdGVkIAAAAKF5IQA0AAAAYnghAAUAAABGb3VuZCB1bm1hc2tlZCBudWxscyBmb3Igbm9uLW51bGxhYmxlIFN0cnVjdEFycmF5IGZpZWxkIOh5IQA4AAAASW5jb3JyZWN0IGFycmF5IGxlbmd0aCBmb3IgU3RydWN0QXJyYXkgZmllbGQgLCBleHBlY3RlZCAoeiEALQAAAFV6IQALAAAAYnghAAUAAABJbmNvcnJlY3QgZGF0YXR5cGUgZm9yIFN0cnVjdEFycmF5IGZpZWxkIAAAAHh6IQApAAAAVXohAAsAAABieCEABQAAAEluY29ycmVjdCBudW1iZXIgb2YgYXJyYXlzIGZvciBTdHJ1Y3RBcnJheSBmaWVsZHMsIGV4cGVjdGVkILx6IQA8AAAAYnghAAUAAABjYW5ub3QgdXNlIFN0cnVjdEFycmF5OjpuZXdfdW5jaGVja2VkIGlmIHRoZXJlIGFyZSBubyBmaWVsZHMsIGxlbmd0aCBpcyB1bmtub3duALEHEABtAAAA4AAAADMAAACxBxAAbQAAAAkBAAANAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZbEHEABtAAAAFwEAABIAAACxBxAAbQAAAB4BAAAVAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogU3RydWN0IGFycmF5J3MgZGF0YSB0eXBlIGlzIG5vdCBzdHJ1Y3QhAAAAwHshAFEAAACxBxAAbQAAADIBAAASAAAAsQcQAG0AAAA6AQAAEgAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBTdHJ1Y3RBcnJheSBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAPHwhAE8AAACxBxAAbQAAAEwBAAAJAAAApw0AADQAAAAEAAAAqA0AAKcNAAA0AAAABAAAAIcBAACpDQAAiQEAAKoNAACrDQAAjAEAAKwNAACtDQAAjwEAAK4NAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABTdHJ1Y3RBcnJheQotLSB2YWxpZGl0eToKWwpdClsKLS0gY2hpbGQgOiAiIiAoKQorfSEACQAAADR9IQADAAAAN30hAAMAAAA6fSEAAgAAAApVbmFibGUgdG8gZG93bmNhc3QgdG8gZGljdGlvbmFyeSBhcnJheQA6GRAAXwAAAEoCAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIEJvb2xlYW5BcnJheQAAOhkQAF8AAADtAgAACgAAAHN0cnVjdCBhcnJheToZEABfAAAAiAMAAB4AAACxBxAAbQAAAEwAAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHR5cGVkIGFycmF5IHRocm91Z2ggYXNfbnVsbF9hcnJheQA6GRAAXwAAAAcDAAABAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHR5cGVkIGFycmF5IHRocm91Z2ggYXNfc3RydWN0X2FycmF5AAAAOhkQAF8AAAAIAwAAAQAAAFVuYWJsZSB0byBkb3duY2FzdCB0byB0eXBlZCBhcnJheSB0aHJvdWdoIGFzX3VuaW9uX2FycmF5OhkQAF8AAAAJAwAAAQAAAFVuYWJsZSB0byBkb3duY2FzdCB0byB0eXBlZCBhcnJheSB0aHJvdWdoIGFzX21hcF9hcnJheQAAOhkQAF8AAAAKAwAAAQAAAP//////////GH8hAEGw/oUBC6UBZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAGx/IQAzAAAAtW0QAGoAAACGAgAACQAAAOdMUGqIspqzZUn4sU20XNLXMhAAeAAAAOsHAAAJAEHg/4UBC8IpAQAAALENAAD7lRAAXgAAAMwAAAARAAAATGF5b3V0RXJyb3IAsg0AAM51EABqAAAAvQEAAB0AAABUeXBlIElkcyBhbmQgT2Zmc2V0cyBsZW5ndGhzIG11c3QgbWF0Y2gA4AkQAGwAAADSAAAAHgAAAE9mZnNldHMgbXVzdCBiZSBwb3NpdGl2ZSBhbmQgd2l0aGluIHRoZSBsZW5ndGggb2YgdGhlIEFycmF5VHlwZSBJZHMgdmFsdWVzIG11c3QgbWF0Y2ggb25lIG9mIHRoZSBmaWVsZCB0eXBlIGlkcwDgCRAAbAAAANQAAAAXAAAAU3BhcnNlIHVuaW9uIGNoaWxkIGFycmF5cyBtdXN0IGJlIGVxdWFsIGluIGxlbmd0aCB0byB0aGUgbGVuZ3RoIG9mIHRoZSB1bmlvblVuaW9uIGZpZWxkcyBsZW5ndGggbXVzdCBtYXRjaCBjaGlsZCBhcnJheXMgbGVuZ3RoAADgCRAAbAAAAOYAAABQAAAAYXNzZXJ0aW9uIGZhaWxlZDogKHR5cGVfaWQgYXMgdXNpemUpIDwgc2VsZi5maWVsZHMubGVuKCngCRAAbAAAAPsAAAAJAAAAaW52YWxpZCB0eXBlIGlkAOAJEABsAAAA/QAAABgAAABhc3NlcnRpb24gZmFpbGVkOiBpbmRleCA8IHNlbGYudHlwZV9pZHMubGVuKCkAAADgCRAAbAAAAAYBAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5kZXggPCBzZWxmLmxlbigp4AkQAGwAAAAaAQAACQAAAOAJEABsAAAAHAEAAB4AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBVbmlvbiBhcnJheSdzIGRhdGEgdHlwZSBpcyBub3QgYSB1bmlvbiEAAABMgiEAUQAAAOAJEABsAAAAPgEAABIAAADgCRAAbAAAAEYBAABQAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZeAJEABsAAAAyAEAABIAAADgCRAAbAAAAN8BAAA9AAAA4AkQAGwAAAAOAgAARAAAAOAJEABsAAAAHgIAAEEAAADgCRAAbAAAABMCAABBAAAA4AkQAGwAAABvAgAAEQAAAOAJEABsAAAAqQIAACMAAADgCRAAbAAAAK0CAAAjAAAA4AkQAGwAAACvAgAAFQAAAOAJEABsAAAAtwIAACAAAADgCRAAbAAAALkCAAAZAAAAVW5pb25BcnJheSBleHBlY3RlZCBBcnJheURhdGEgd2l0aCB0eXBlIFVuaW9uIGdvdCAAAKCDIQAyAAAA4AkQAGwAAAClAgAAEgAAALMNAAAwAAAABAAAALQNAACzDQAAMAAAAAQAAADXBQAAtQ0AANkFAAC2DQAAtw0AANwFAADdBQAA3gUAAN8FAADlBQAAuA0AAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAA4AkQAGwAAAACAwAAFQAAAOAJEABsAAAAbgMAABYAAADgCRAAbAAAABADAAASAAAAVW5pb25BcnJheShTcGFyc2UpCltVbmlvbkFycmF5KERlbnNlKQpbCgEAAAAAAAAAq4QhAAEAAAAtLSB0eXBlIGlkIGJ1ZmZlcjoKLS0gb2Zmc2V0cyBidWZmZXI6Cl0K4oQhAAIAAAAtLSBjaGlsZCA6ICIiICgpCgAAAOyEIQAJAAAA9YQhAAMAAAD4hCEAAwAAAPuEIQACAAAA4AkQAGwAAAC9AwAAEgAAAOAJEABsAAAAegAAAAoAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAABCxt2uXnKjhOUJHZN/4dGoAMC/8sE//nydYLxhVcVnAZ4EaqQYTmLdfDLLYYe7B8fHLP3sJdo49w2Zk8JQSsynEM/MnaU1JGkI+ioAjhXJQlPsFN832yXIIqwHEQap00y5DQAAFAAAAAQAAAC6DQAA+5UQAF4AAADMAAAAEQAAAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAALsNAAAMAAAABAAAALwNAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yAAEAAAAAAAAAU3RyaW5nAABUhyEABgAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIEFycmF5IG9mIGxlbmd0aCAAAABkhyEAJQAAAImHIQAIAAAAAQAAAAAAAACRhyEAEAAAAAgNEABrAAAAPgEAAAkAAABMYXJnZQAAANSHIQAFAAAAQmluYXJ5AADkhyEABgAAAEFycmF5ClsKAQAAAAAAAAABAAAAAAAAAPSHIQAIAAAAXQAAAL0NAAA8AAAABAAAAL4NAAC9DQAAPAAAAAQAAAC/DQAAvQ0AADwAAAAEAAAAwA0AAL0NAAA8AAAABAAAAMENAAC9DQAAPAAAAAQAAACLBwAAwg0AAI0HAADDDQAAxA0AAI8HAABeBwAAXwcAAGAHAADFDQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAvQ0AADwAAAAEAAAAkAcAAMYNAACSBwAAxw0AAMQNAACUBwAAbwcAAHAHAABgBwAAxQ0AAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAL0NAAA8AAAABAAAAFgHAADIDQAAWgcAAMkNAADEDQAAXQcAAF4HAABfBwAAYAcAAMUNAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAC9DQAAPAAAAAQAAABqBwAAyg0AAGwHAADLDQAAxA0AAG4HAABvBwAAcAcAAGAHAADFDQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAQXJyYXkgZXhwZWN0cyBEYXRhVHlwZTo6AQAAAAAAAAABAAAAAAAAALiJIQAYAAAACA0QAGsAAAAGAgAACQAAAAIAAAAIDRAAawAAABgCAAAaAAAAQXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiAyIGJ1ZmZlcnMgb25seSAob2Zmc2V0cyBhbmQgdmFsdWVzKQAAAAEAAAAAAAAAAQAAAAAAAAAMiiEAPQAAAAgNEABrAAAADgIAAAkAAAD9BBAAcAAAADIBAAAWAAAA/QQQAHAAAAAzAQAAFgAAAMwNAABEAAAABAAAAM0NAADMDQAARAAAAAQAAADODQAAzA0AAEQAAAAEAAAAtwwAAM8NAAC5DAAA0A0AANENAAC7DAAAvAwAAL0MAACmDAAAxQ0AAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAAMwNAABEAAAABAAAAJ4MAADSDQAAoAwAANMNAADRDQAAowwAAKQMAAClDAAApgwAAMUNAACnDAAAqAwAAKkMAACqDAAAqwwAAKwMAACtDAAArgwAAK8MAABMaXN0Vmlld0FycmF5ClsKAQAAAAAAAABkiyEAEAAAAEV4cGVjdGVkIGluZmFsbGlibGUgY3JlYXRpb24gb2YgR2VuZXJpY0xpc3RWaWV3QXJyYXkgZnJvbSBBcnJheURhdGFSZWYgZmFpbGVkAAAA/QQQAHAAAADbAQAADgAAAP0EEABwAAAACwIAABYAAAD9BBAAcAAAACICAAAvAAAA/QQQAHAAAAAjAgAALQAAAExpc3RWaWV3QXJyYXkncyBjaGlsZCBkYXRhdHlwZSAgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgTGlzdCdzIGRhdGF0eXBlIAABAAAAAAAAABSMIQAfAAAAM4whACwAAABMaXN0Vmlld0FycmF5J3MgZGF0YXR5cGUgbXVzdCBiZSBMaXN0Vmlld0FycmF5KCkuIEl0IGlzIAEAAAAAAAAAeIwhACEAAACZjCEAFwAAAExpc3RWaWV3QXJyYXkgc2hvdWxkIGNvbnRhaW4gYSBzaW5nbGUgY2hpbGQgYXJyYXkgKHZhbHVlcyBhcnJheSksIGhhZCAAAMiMIQBGAAAATGlzdFZpZXdBcnJheSBkYXRhIHNob3VsZCBjb250YWluIHR3byBidWZmZXJzICh2YWx1ZSBvZmZzZXRzICYgdmFsdWUgc2l6ZXMpLCBoYWQgAAAAGI0hAFEAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAAD/7Fp1xS4YcQF6eKTCW9WLEJ9k8dpo/gbvJq2NCifCzcBxzSv1lyosdScKFfVrmaRvIhAAdwAAAKMCAAABAAAA1A0AABQAAAAEAAAA1Q0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAA1g0AAAwAAAAEAAAA1w0AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IgZ290IFNpemUgY2Fubm90IGJlIG5lZ2F0aXZlLCBnb3QgAAAAgI8hAB0AAABUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBGaXhlZFNpemVCaW5hcnlBcnJheSBvZiBsZW5ndGggqI8hACUAAADNjyEAJwAAAIQEEAB4AAAAkQAAAAkAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgRml4ZWRTaXplQmluYXJ5QXJyYXkgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoFJAhAFgAAACEBBAAeAAAANMAAAAJAAAAAQAAAIQEEAB4AAAA7gEAAA0AAABFeHBlY3RlZCBkYXRhIHR5cGUgdG8gYmUgRml4ZWRTaXplQmluYXJ5mJAhACgAAACEBBAAeAAAAOkBAAASAAAARml4ZWRTaXplQmluYXJ5QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiAxIGJ1ZmZlciBvbmx5ICh2YWx1ZXMpANiQIQA/AAAAhAQQAHgAAADiAQAACQAAAAAAAABGaXhlZFNpemVCaW5hcnlBcnJheTw+ClsKAAAANJEhABUAAABJkSEABAAAAF0AAADYDQAAOAAAAAQAAADZDQAA2A0AADgAAAAEAAAAEwIAANoNAAAVAgAA2w0AANwNAAAYAgAA3Q0AAN4NAAAbAgAA/wIAABwCAAAdAgAAHgIAAB8CAAAgAgAAIQIAACICAAAjAgAAJAIAAFkGEAB2AAAAhgAAADMAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBGaXhlZFNpemVMaXN0QXJyYXksIGV4cGVjdGVkIAAAANyRIQBBAAAAe48hAAUAAABGb3VuZCB1bm1hc2tlZCBudWxscyBmb3Igbm9uLW51bGxhYmxlIEZpeGVkU2l6ZUxpc3RBcnJheSBmaWVsZCAAMJIhAD8AAABGaXhlZFNpemVMaXN0QXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBmb3IgAHiSIQAmAAAAe48hAAUAAACekiEABQAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBGaXhlZFNpemVMaXN0QXJyYXkgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoAAC8kiEAVgAAAFkGEAB2AAAAGAEAAAkAAABZBhAAdgAAAGcBAAAYAAAARml4ZWRTaXplTGlzdEFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gYSBGaXhlZFNpemVMaXN0IGRhdGEgdHlwZSwgZ290IAAAPJMhAEYAAABZBhAAdgAAAGEBAAARAAAA3w0AADQAAAAEAAAA4A0AAN8NAAA0AAAABAAAAJwEAADhDQAAngQAAOINAADjDQAAoQQAAOQNAADlDQAApAQAAP8CAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAABGaXhlZFNpemVMaXN0QXJyYXk8AASUIQATAAAASZEhAAQAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgQm9vbGVhbkJ1ZmZlciBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAAAAolCEAUQAAALwKEABrAAAAPgAAAAkAAAAAAAAABAAAAAQAAADmDQBBtKmGAQvmAgQAAAAEAAAA8gIAAOcNAAD0AgAA6A0AAOkNAAD3AgAA6g0AAOsNAADsDQAA/wIAAO0NAAD8AgAA/QIAAP4CAAD/AgAA6g0AAAADAAD/AgAAAQMAAKSUIQBOdWxsQXJyYXkgZGF0YSB0eXBlIHNob3VsZCBiZSBOdWxsAAAMlSEAIgAAALwKEABrAAAAiwAAAAkAAABOdWxsQXJyYXkgZGF0YSBzaG91bGQgbm90IGNvbnRhaW4gYSBudWxsIGJ1ZmZlciwgYXMgbm8gYnVmZmVycyBhcmUgcmVxdWlyZWQASJUhAEsAAAC8ChAAawAAAJUAAAAJAAAATnVsbEFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gMCBidWZmZXJzAKyVIQAnAAAAvAoQAGsAAACQAAAACQAAAE51bGxBcnJheSgpAOyVIQAKAAAA9pUhAAEAAAAAAAAABAAAAAQAAADuDQAAEgEAQaSshgELARIAQbCshgELAg0BAEG8rIYBCwMmTAoAQcishgELAhICAEHUrIYBCwETAEHgrIYBCwIRAgBB7KyGAQsDJSYKAEH4rIYBCwMjCQIAQYSthgELAg0DAEGQrYYBCwIRAwBBnK2GAQsDJBIGAEGorYYBCwENAEG0rYYBCwISAwBBwK2GAQsBEABBzK2GAQsCDQIAQdithgELAhABAEHorYYBC+0B0wijhYhqPyREc3ADLooZE9AxnykiOAmkiWxO7Jj6LghIYXNoIHRhYmxlIGNhcGFjaXR5IG92ZXJmbG93CJchABwAAAA0eBAAYAAAACUAAAAoAAAARm9ybWF0dGluZyBhcmd1bWVudCBvdXQgb2YgcmFuZ2U8lyEAIAAAAOJfEABrAAAAzwwAAA4AAAABAAAAAAAAABRfEABnAAAAsAAAACIAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAAOkUXxAAZwAAALEAAAAjAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAgAADoAgAAAAAAAAACAEHgr4YBC/MIIAAg4BRfEABnAAAAqgAAACIAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAIOkUXxAAZwAAAKsAAAAjAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAgACDoLCAAABRfEABnAAAATQIAABEAAAAAAAEBSmFuRmViTWFyQXByTWF5SnVuSnVsQXVnU2VwT2N0Tm92RGVjTJghAAMAAABPmCEAAwAAAFKYIQADAAAAVZghAAMAAABYmCEAAwAAAFuYIQADAAAAXpghAAMAAABhmCEAAwAAAGSYIQADAAAAZ5ghAAMAAABqmCEAAwAAAG2YIQADAAAAU3VuTW9uVHVlV2VkVGh1RnJpU2F0AAAA0JghAAMAAADTmCEAAwAAANaYIQADAAAA2ZghAAMAAADcmCEAAwAAAN+YIQADAAAA4pghAAMAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCSkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpQTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlheXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXGBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiAAAA5SoQAGUAAAAIAQAAGwAAAK5rEABlAAAAswEAACoAAACuaxAAZQAAANgBAAAUAAAArmsQAGUAAADhAQAAQAAAAHovAAAAAAAAQZwhAAEAAAAECAEAQeC4hgELC0GcIQABAAAABAIBAEH0uIYBCxMtAAAAAAAAAHScIQABAAAABAcBAEGUuYYBCwt0nCEAAQAAAAQIAQBBqLmGAQsTOgAAAAAAAAConCEAAQAAAAQRAQBByLmGAQsLqJwhAAEAAAAEEQEAQeC5hgELC6icIQABAAAABBIBAEH0uYYBCxIKCQAAAAAAAHScIQABAAAABQQAQZS6hgELC3ScIQABAAAABAABAEGouoYBC5sCOjp6OnoAAACuaxAAZQAAAE8CAAArAAAArmsQAGUAAABMAgAAKwAAAK5rEABlAAAASQIAACsAAACuaxAAZQAAAFUCAAAaAAAArmsQAGUAAABWAgAAHgAAAK5rEABlAAAAWgIAAB4AAACuaxAAZQAAAF4CAAAeAAAArmsQAGUAAABlAgAAGgAAAK5rEABlAAAAaQIAABoAAACuaxAAZQAAAG0CAAAaAAAAJWFzc2VydGlvbiBmYWlsZWQ6IG5leHRzcGVjID4gMACuaxAAZQAAAMUBAAARAAAArmsQAGUAAADGAQAALgAAAK5rEABlAAAAugEAABEAAACuaxAAZQAAALsBAAAsAAAArmsQAGUAAACHAgAALAAAAAQHAQBB0LyGAQsLQZwhAAEAAAAECAEAQei8hgELC0GcIQABAAAABAIBAEH8vIYBCwYgAAAABQYAQYy9hgELDgIAAAB8niEAAQAAAAUEAEGkvYYBCw8CAAAAfJ4hAAEAAAAECAIAQby9hgELDwIAAAB8niEAAQAAAAQPAQBB2L2GAQsLqJwhAAEAAAAEEQEAQfC9hgELC6icIQABAAAABBIBAEGEvoYBCw8CAAAAfJ4hAAEAAAAEAAEAQZy+hgELAwQPAQBBrL6GAQsLqJwhAAEAAAAEEQEAQcS+hgELC6icIQABAAAABBIBAEHYvoYBCwMEEAEAQei+hgELC6icIQABAAAABBEBAEGAv4YBCwuonCEAAQAAAAQSAQBBlL+GAQsOAgAAAHyeIQABAAAABQkAQay/hgEL7QM6hhAAcAAAAC4CAAARAAAA4l8QAGsAAADPDAAADgAAAPANAAAMAAAABAAAAPENAADyDQAAxwcAAAQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoLDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PCQoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQ4PCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgs6AAAAAQAAAAAAAAABAAAAAAAAAHShIQABAAAAAgAAAAAAAAACAEGkw4YBCwUgAADgAgBBssOGAQsPAgAAAAAAAQAAACAAAOkCAEHKw4YBCzcCAAAAAAACAAAAIAAA6QEAAAAAAAAAAQAAAAAAAAB0oSEAAQAAAHShIQABAAAAAgAAAAAAAAACAEGMxIYBCwUgAADgAgBBmsSGAQsPAgAAAAAAAQAAACAAAOkCAEGyxIYBCw8CAAAAAAACAAAAIAAA6QIAQcrEhgELjwECAAAAAAADAAAAIAAA6UZvcm1hdHRpbmcgYXJndW1lbnQgb3V0IG9mIHJhbmdlWKIhACAAAAAtUAAAAQAAAAAAAACBoiEAAQAAADBEVACWoiEAAQAAAHGVEABgAAAAZQIAABkAAAAuAAAAsKIhAAEAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAAOlTAAAAAgBB4sWGAQsBAwBB7MWGAQsFIAAA6QIAQfrFhgELAQYAQYTGhgELBSAAAOkCAEGSxoYBCwEJAEGcxoYBCw0gAADpAQAAAAAAAAACAEGyxoYBCwEFAEG8xoYBC8UMIAAg6QABAQEBAgICAgMDAwMEBAQEBQUFBQYGBgYHBwcHCAgICAkJCQkKCgoKCwsLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQERERERISEhITExMTFBQUFBUVFRUWFhYWFxcXFxgYGBgZGRkZGRkZGRoaGhobGxsbHBwcHB0dHR0eHh4eHx8fHyAgICAhISEhIiIiIiMjIyMkJCQkJSUlJSYmJiYnJycnKCgoKCkpKSkqKioqKysrKywsLCwtLS0tLi4uLi8vLy8wMDAwMTExMTExMTEyMjIyMzMzMzQ0NDQ1NTU1NjY2Njc3Nzc4ODg4OTk5OTo6Ojo7Ozs7PDw8PD09PT0+Pj4+Pz8/P0BAQEBBQUFBQkJCQkNDQ0NERERERUVFRUZGRkZHR0dHSEhISElJSUlJSUlJSkpKSktLS0tMTExMTU1NTU5OTk5PT09PUFBQUFFRUVFSUlJSU1NTU1RUVFRVVVVVVlZWVldXV1dYWFhYWVlZWVpaWlpbW1tbXFxcXF1dXV1eXl5eX19fX2BgYGBhYWFhAAAA24IQAGQAAABDCQAAEQAAANuCEABkAAAARgkAABsAAAAEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKCwwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwkKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0ODwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoL5SoQAGUAAABQAAAACQAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSExKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGIAAADlKhAAZQAAAAgBAAAbAEHG04YBC48HQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQgAAAAAAAABISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISgAASkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMAAAAAE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QAABQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFIAAAAAVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFYAAFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYAABYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFoAAAAAXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF4AAF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYAAAAABiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZOUqEABlAAAAYgEAAA8AAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAABhbGlnbl9vZmZzZXQ6IGFsaWduIGlzIG5vdCBhIHBvd2VyLW9mLXR3bwAAAAStIQApAAAAIDEQAHEAAABHBQAADQAAANcyEAB4AAAA6wcAAAkAQeDahgELhTEBAAAA9Q0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA9g0AABQAAAAEAAAA9w0AAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAPgNAAAMAAAABAAAAPkNAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yTnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAAAAQAAAAEAAAD6DQAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4VmlldwAAAAAAAAAEAAAABAAAADMIAABMaXN0TGlzdFZpZXf7DQAABAAAAAQAAAA1CAAARml4ZWRTaXplTGlzdExhcmdlTGlzdExhcmdlTGlzdFZpZXcAAAAAAAQAAAAEAAAANggAAFN0cnVjdAAA/A0AAAgAAAAEAAAAOAgAAAAAAAAEAAAABAAAADkIAABVbmlvbgAAAP0NAAAEAAAABAAAADsIAAAAAAAABAAAAAQAAAAXBgAARGljdGlvbmFyeQAAAAAAAAEAAAABAAAA/g0AAAAAAAAEAAAABAAAABEFAABEZWNpbWFsMzJEZWNpbWFsNjREZWNpbWFsMTI4RGVjaW1hbDI1NgAAAAAAAAQAAAAEAAAAPQgAAE1hcFJ1bkVuZEVuY29kZWRTZWNvbmRNaWxsaXNlY29uZE1pY3Jvc2Vjb25kTmFub3NlY29uZAAAAAAAAAQAAAAEAAAARAEAAFRyeUZyb21JbnRFcnJvcgDOdRAAagAAAL0BAAAdAAAA+5UQAF4AAAArAQAACgAAAG51bGxfYml0X2J1ZmZlciBzaXplIHRvbyBzbWFsbC4gZ290ICBuZWVkZWQgoLEhACQAAADEsSEACAAAAGFzc2VydGlvbiBmYWlsZWQ6IChvZmZzZXQgKyBsZW5ndGgpIDw9IHNlbGYubGVuKCkAAAD7lRAAXgAAACgCAAAJAAAA+5UQAF4AAAAxAgAAJwAAAPuVEABeAAAATgIAAAoAAAD7lRAAXgAAAE4CAAAtAAAA+5UQAF4AAACAAgAAMwAAAPuVEABeAAAAhQIAAEMAAAD7lRAAXgAAAHsCAAA1AAAAcnVuIG92ZXJmbG93+5UQAF4AAACbAgAAOgAAAPuVEABeAAAAnwIAADoAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHJ1biBlbmRzIGRhdGEgdHlwZSAAAACssiEARQAAAPuVEABeAAAApgIAAB8AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiAAAAyzIQAqAAAA+5UQAF4AAAC2AgAAFgAAAEFycmF5cyBvZiB0eXBlICBjYW5ub3QgY29udGFpbiBhIG51bGwgYml0bWFzawAAAFCzIQAPAAAAX7MhAB4AAABudWxsIGJ1ZmZlciBpbmNvcnJlY3Qgc2l6ZS4gZ290ICBleHBlY3RlZCAAAJCzIQAgAAAAsLMhAAoAAABudWxsX2NvdW50ICBmb3IgYW4gYXJyYXkgZXhjZWVkcyBsZW5ndGggb2YgIGVsZW1lbnRzzLMhAAsAAADXsyEAIAAAAPezIQAJAAAA+5UQAF4AAABTAwAAOgAAAPuVEABeAAAAVgMAADoAAABEaWN0aW9uYXJ5IGtleSB0eXBlIG11c3QgYmUgaW50ZWdlciwgYnV0IHdhcyAAAAA4tCEALQAAAFJ1bkFycmF5IHJ1bl9lbmRzIHR5cGVzIG11c3QgYmUgSW50MTYsIEludDMyIG9yIEludDY0LCBidXQgd2FzIABwtCEAPwAAAFRoZSBudWxsYWJsZSBzaG91bGQgYmUgc2V0IHRvIGZhbHNlIGZvciB0aGUgZmllbGQgZGVmaW5pbmcgcnVuX2VuZHMgYXJyYXkuTWlzYWxpZ25lZCBidWZmZXJzW10gaW4gYXJyYXkgb2YgdHlwZSAsIG9mZnNldCBmcm9tIGV4cGVjdGVkIGFsaWdubWVudCBvZiAgYnkgArUhABMAAAAVtSEAEwAAACi1IQAkAAAATLUhAAQAAABOZWVkIGF0IGxlYXN0ICBieXRlcyBpbiBidWZmZXJzWywgYnV0IGdvdCAAAHC1IQAOAAAAfrUhABIAAAAVtSEAEwAAAJC1IQAKAAAAIGJ5dGVzIGZvciBiaXRtYXAgaW4gYnVmZmVyc1sAAABwtSEADgAAALy1IQAdAAAAFbUhABMAAACQtSEACgAAAEV4cGVjdGVkICBidWZmZXJzIGluIGFycmF5IG9mIHR5cGUgLCBnb3QgAAAA/LUhAAkAAAAFtiEAGgAAAB+2IQAGAAAA+5UQAF4AAAB7AwAAKQAAAPuVEABeAAAAiAMAACMAAAD7lRAAXgAAAJYDAAAlAAAAQnVmZmVyICBvZiAgaXNuJ3QgbGFyZ2UgZW5vdWdoLiBFeHBlY3RlZCAgYnl0ZXMgZ290IHC2IQAHAAAAd7YhAAQAAAB7tiEAHgAAAJm2IQALAAAA+5UQAF4AAACsAwAAGwAAAEZpcnN0IG9mZnNldCAgaW4gIGlzIHNtYWxsZXIgdGhhbiBsYXN0IG9mZnNldCAAANS2IQANAAAA4bYhAAQAAADltiEAHQAAAExhc3Qgb2Zmc2V0ICBpcyBsYXJnZXIgdGhhbiB2YWx1ZXMgbGVuZ3RoIAAAHLchAAwAAAB3tiEABAAAACi3IQAeAAAA1LYhAA0AAAB3tiEABAAAACi3IQAeAAAARXJyb3IgY29udmVydGluZyBvZmZzZXRbMF0gKCkgdG8gdXNpemUgZm9yIAB4tyEAHAAAAJS3IQAPAAAARXJyb3IgY29udmVydGluZyBvZmZzZXRbXSAoALS3IQAYAAAAzLchAAMAAACUtyEADwAAAPuVEABeAAAA1AMAABgAAAD7lRAAXgAAANoDAAAaAAAAT2Zmc2V0IGFuZCBzaXplIGhhdmUgZXhjZWVkZWQgdGhlIHVzaXplIGJvdW5kYXJ5+5UQAF4AAADiAwAAEgAAAFNpemUgIGF0IGluZGV4ICBpcyBsYXJnZXIgdGhhbiB0aGUgcmVtYWluaW5nIHZhbHVlcyBmb3IgSLghAAUAAABNuCEACgAAAFe4IQApAAAARXJyb3IgY29udmVydGluZyBzaXplWwAAmLghABYAAADMtyEAAwAAAJS3IQAPAAAAaW50ZWdlciBvdmVyZmxvdyBjb21wdXRpbmcgZXhwZWN0ZWQgbnVtYmVyIG9mIGV4cGVjdGVkIHZhbHVlcyBpbiBGaXhlZExpc3RTaXplAAD7lRAAXgAAABEEAAAWAAAAVmFsdWVzIGxlbmd0aCAgaXMgbGVzcyB0aGFuIHRoZSBsZW5ndGggKCkgbXVsdGlwbGllZCBieSB0aGUgdmFsdWUgc2l6ZSAoKSBmb3IgAAAouSEADgAAADa5IQAaAAAAULkhACAAAABwuSEABgAAACBjaGlsZCBhcnJheSAjIGZvciBmaWVsZCAgaGFzIGxlbmd0aCBzbWFsbGVyIHRoYW4gZXhwZWN0ZWQgZm9yIHN0cnVjdCBhcnJheSAoIDwgKQAAAAEAAAAAAAAAmLkhAA4AAACmuSEACwAAALG5IQA0AAAA5bkhAAMAAADouSEAAQAAAFNwYXJzZSB1bmlvbiBjaGlsZCBhcnJheSAjIGhhcyBsZW5ndGggc21hbGxlciB0aGFuIGV4cGVjdGVkIGZvciB1bmlvbiBhcnJheSAoAAAAHLohABoAAAA2uiEAMwAAAOW5IQADAAAA6LkhAAEAAABGb3VuZCBudWxsIHZhbHVlcyBpbiBydW5fZW5kcyBhcnJheS4gVGhlIHJ1bl9lbmRzIGFycmF5IHNob3VsZCBub3QgaGF2ZSBudWxsIHZhbHVlcy5UaGUgcnVuX2VuZHMgYXJyYXkgbGVuZ3RoIHNob3VsZCBiZSB0aGUgc2FtZSBhcyB2YWx1ZXMgYXJyYXkgbGVuZ3RoLiBSdW5fZW5kcyBhcnJheSBsZW5ndGggaXMgLCB2YWx1ZXMgYXJyYXkgbGVuZ3RoIGlzIADguiEAXgAAAD67IQAZAAAARXhwZWN0ZWQgbm8gY2hpbGQgYXJyYXlzIGZvciB0eXBlICBidXQgZ290IABouyEAIgAAAIq7IQAJAAAAIGhhcyBhIG5lZ2F0aXZlIGxpc3Rfc2l6ZSAAAAEAAAAAAAAApLshABoAAABWYWx1ZSBkYXRhIGZvciAgc2hvdWxkIGNvbnRhaW4gIGNoaWxkIGRhdGEgYXJyYXkocyksIGhhZCAAAADQuyEADwAAAN+7IQAQAAAA77shABoAAABDaGlsZCB0eXBlIG1pc21hdGNoIGZvciAuIEV4cGVjdGVkICBidXQgY2hpbGQgZGF0YSBoYWQgACS8IQAYAAAAPLwhAAsAAABHvCEAFAAAACBkaWQgbm90IGhhdmUgZW5vdWdoIGNoaWxkIGFycmF5cy4gRXhwZWN0ZWQgYXQgbGVhc3QgIGJ1dCBoYWQgb25seSAAAQAAAAAAAAB0vCEANQAAAKm8IQAOAAAAbnVsbF9jb3VudCB2YWx1ZSAoKSBkb2Vzbid0IG1hdGNoIGFjdHVhbCBudW1iZXIgb2YgbnVsbHMgaW4gYXJyYXkgKADQvCEAEgAAAOK8IQAxAAAA6LkhAAEAAAD7lRAAXgAAAN0EAAAtAAAA+5UQAF4AAADZBAAARgAAAG5vbi1udWxsYWJsZSBjaGlsZCBvZiB0eXBlICBjb250YWlucyBudWxscyBub3QgcHJlc2VudCBpbiBwYXJlbnQgAAAATL0hABsAAABnvSEAJgAAACBjb250YWlucyBudWxscyBub3QgcHJlc2VudCBpbiBwYXJlbnQAAABMvSEAGwAAAKC9IQAlAAAA+5UQAF4AAAAbBQAATwAAAPuVEABeAAAAHAUAAFQAAAD7lRAAXgAAAB8FAAA6AAAA+5UQAF4AAAAjBQAAOgAAAPuVEABeAAAAKgUAAC0AAAD7lRAAXgAAADYFAAA9AAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZfuVEABeAAAAQQUAABoAAAD7lRAAXgAAACYFAAAtAAAA+5UQAF4AAABFBQAAJQAAAPuVEABeAAAASgUAABoAAABPZmZzZXQgaW52YXJpYW50IGZhaWx1cmU6IG9mZnNldCBhdCBwb3NpdGlvbiAgb3V0IG9mIGJvdW5kczogID4goL4hAC0AAADNviEAEAAAAN2+IQADAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBDb3VsZCBub3QgY29udmVydCBvZmZzZXQgIHRvIHVzaXplIGF0IHBvc2l0aW9uIAAAAPi+IQAzAAAAK78hABYAAAD7lRAAXgAAAJEFAAAqAAAA+5UQAF4AAAC/BQAAIwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSAvIG1lbTo6c2l6ZV9vZjo6PFQ+KCkgPj0gcmVxdWlyZWRfbGVu+5UQAF4AAADDBQAACQAAAPuVEABeAAAAxgUAADYAAABWYWx1ZSBhdCBwb3NpdGlvbiAgKHNob3VsZCBiZSBpbiBbMCwgXSkA2L8hABIAAADNviEAEAAAAOq/IQATAAAA/b8hAAIAAAAgKGNhbiBub3QgY29udmVydCB0byBpNjQpAAAA2L8hABIAAADNviEAEAAAACDAIQAZAAAAVGhlIG9mZnNldCArIGxlbmd0aCBvZiBhcnJheSBzaG91bGQgYmUgbGVzcyBvciBlcXVhbCB0byBsYXN0IHZhbHVlIGluIHRoZSBydW5fZW5kcyBhcnJheS4gVGhlIGxhc3QgdmFsdWUgb2YgcnVuX2VuZHMgYXJyYXkgaXMgIGFuZCBvZmZzZXQgKyBsZW5ndGggb2YgYXJyYXkgaXMgLlTAIQB+AAAA0sAhACEAAADzwCEAAQAAAFRoZSB2YWx1ZXMgaW4gcnVuX2VuZHMgYXJyYXkgc2hvdWxkIGJlIHN0cmljdGx5IGluY3JlYXNpbmcuIEZvdW5kIHZhbHVlICB3aXRoIHByZXZpb3VzIHZhbHVlICB0aGF0IGRvZXMgbm90IG1hdGNoIHRoZSBjcml0ZXJpYS4ADMEhAEgAAABNuCEACgAAAFTBIQAVAAAAacEhACIAAABUaGUgdmFsdWVzIGluIHJ1bl9lbmRzIGFycmF5IHNob3VsZCBiZSBzdHJpY3RseSBwb3NpdGl2ZS4gRm91bmQgdmFsdWUgAACswSEARgAAAE24IQAKAAAAacEhACIAAAD7lRAAXgAAAFcGAAAwAAAA+5UQAF4AAACtBwAAFgAAAPuVEABeAAAAvwcAABkAAAD7lRAAXgAAANIHAAAsAAAA+5UQAF4AAADMAAAAEQAAAAYAAAALAAAACwAAAAoAAAA4sSEAPrEhAEmxIQBUsSEABAAAAAgAAAAQAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAANcyEAB4AAAA6wcAAAkAAADEShAAagAAAG0IAAAfAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBvZmZzZXQgYXQgcG9zaXRpb24gIG91dCBvZiBib3VuZHM6ICA+INzCIQAtAAAACcMhABAAAAAZwyEAAwAAAE9mZnNldCBpbnZhcmlhbnQgZmFpbHVyZTogQ291bGQgbm90IGNvbnZlcnQgb2Zmc2V0ICB0byB1c2l6ZSBhdCBwb3NpdGlvbiAAAAA0wyEAMwAAAGfDIQAWAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBub24tbW9ub3RvbmljIG9mZnNldCBhdCBzbG90IDogAAAAkMMhADcAAADHwyEAAgAAABnDIQADAAAAaW5jb21wbGV0ZSB1dGYtOCBieXRlIHNlcXVlbmNlIGZyb20gaW5kZXggAADkwyEAKgAAAPuVEABeAAAAoQUAADMAAABJbnZhbGlkIFVURjggc2VxdWVuY2UgYXQgc3RyaW5nIGluZGV4ICAoKTogACjEIQAmAAAATsQhAAIAAABQxCEAAwAAAFOAEABnAAAA9AEAACMAAABTgBAAZwAAAA8CAAAvAAAAU4AQAGcAAAAfAgAALwAAAFOAEABnAAAAKQIAACsAAABTgBAAZwAAADICAAAjAAAAU4AQAGcAAAA2AgAAIwAAAFOAEABnAAAAQAIAACMAAABTgBAAZwAAAFMCAAAnAAAAU4AQAGcAAABpAgAAOAAAAFOAEABnAAAAmQIAACgAAAB2aWV3IGJ1ZmZlciBpbmRleCBvdmVyZmxvdwAAU4AQAGcAAACvAgAAHgAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAKcBAAAfAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAOAAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADXMhAAeAAAAOsHAAAJAEHwi4cBC6IEAQAAABEOAAASDgAAFAAAAAQAAAATDgAAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAFA4AAAwAAAAEAAAAFQ4AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IAxEoQAGoAAABtCAAAHwAAAEJpbmFyeUxpc3RTdHJ1Y3REaWN0aW9uYXJ5TGF5b3V0RXJyb3IAAAAAAAAABAAAAAQAAAAWDgAA+5UQAF4AAACMAAAAPwAAAPuVEABeAAAAYQAAAEcAAABNdXRhYmxlQXJyYXlEYXRhIG5vdCBudWxsYWJsZQAAAFOAEABnAAAASAAAAA4AAAAAAAAADAAAAAQAAAAXDgAAGA4AABgOAEGckIcBCw4BAAAAGQ4AABoOAAAaDgBBtJCHAQvFFQEAAAAbDgAAHA4AABwOAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlU4AQAGcAAADTAAAAEgAAAAAAAAAMAAAABAAAAB0OAAAeDgAAHg4AAFOAEABnAAAA4AAAAB4AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBzaG91bGQgdXNlIGJ1aWxkX2V4dGVuZF92aWV3AACkyCEARgAAAFOAEABnAAAACgEAADYAAABub3QgaW1wbGVtZW50ZWQ6IExpc3RWaWV3L0xhcmdlTGlzdFZpZXcgbm90IGltcGxlbWVudGVkAATJIQA3AAAAU4AQAGcAAAANAQAADQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHNob3VsZCB1c2UgYnVpbGRfZXh0ZW5kX2RpY3Rpb25hcnlUySEATAAAAFOAEABnAAAAEAEAACcAAABTgBAAZwAAAD0BAAANAAAAU4AQAGcAAABJAQAAEgAAAAAAAAAEAAAABAAAAB8OAAAgDgAAIA4AAFOAEABnAAAApAEAAB8AAABTgBAAZwAAAO8BAAARAAAAU4AQAGcAAABjAgAAJAAAAGRpY3Rpb25hcnkgY2FwYWNpdHkgbm90IHlldCBzdXBwb3J0ZWQAAAAgyiEAJQAAAFOAEABnAAAAZgIAAB0AAABNdXRhYmxlQXJyYXlEYXRhOjpuZXcgaXMgaW5mYWxsaWJsZQBTgBAAZwAAAKQCAAAfAAAAQ2FwYWNpdGllczogIG5vdCB5ZXQgc3VwcG9ydGVkAACUyiEADAAAAKDKIQASAAAAU4AQAGcAAADLAQAAEgAAAEFycmF5cyB3aXRoIGluY29uc2lzdGVudCB0eXBlcyBwYXNzZWQgdG8gTXV0YWJsZUFycmF5RGF0YQAAANTKIQA5AAAAU4AQAGcAAACnAQAADQAAAFOAEABnAAAAYAIAAB4AAABTgBAAZwAAAGACAAA7AAAAU4AQAGcAAADYAgAAHwAAAFOAEABnAAAA2QIAABwAAABTgBAAZwAAABEDAAATAAAAU4AQAGcAAAAiAwAAQAAAAPuVEABeAAAAzAAAABEAAAAAAAAABAAAAAQAAAAhDgAAAAAAAAQAAAAEAAAAIg4AAAAAAAAEAAAABAAAACMOAABBcnJheQAAAAQAAAAIAAAAEAAAAAQOAAAFDgAACQ4AAAIOAAADDgAABA4AAAUOAAACDgAAAw4AAAQOAAAFDgAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAAAAAAAIAAAABAAAACQOAAAlDgAAJQ4AAAAAAAAIAAAABAAAACYOAAAnDgAAJw4AAAAAAAAIAAAABAAAACgOAAApDgAAKQ4AAAAAAAAIAAAABAAAACgOAAApDgAAKQ4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAAAAAAAIAAAABAAAACwOAAAtDgAALQ4AAAAAAAAIAAAABAAAAC4OAAAvDgAALw4AAAAAAAAIAAAABAAAACYOAAAnDgAAJw4AAAAAAAAIAAAABAAAADAOAAAxDgAAMQ4AAAAAAAAIAAAABAAAADIOAAAzDgAAMw4AAAAAAAAIAAAABAAAADIOAAAzDgAAMw4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAA1kEABtAAAAHwAAACsAAAAAAAAADAAAAAQAAAA0DgAANQ4AADUOAAAAAAAAEAAAAAgAAAA2DgAANw4AADcOAAAAAAAADAAAAAQAAAA4DgAAOQ4AADkOAAAAAAAADAAAAAQAAAA6DgAAOw4AADsOAAAAAAAADAAAAAQAAAA8DgAAPQ4AAD0OAAAAAAAAEAAAAAgAAAA+DgAAPw4AAD8OAAAAAAAADAAAAAQAAABADgAAQQ4AAEEOAAAAAAAADAAAAAQAAABCDgAAQw4AAEMOAAANZBAAbQAAAC0AAAAfAAAA1zIQAHgAAADrBwAACQAAABA5EABvAAAAkAAAAC4AAABuXRAAXQAAAJkAAAAVAAAAbl0QAF0AAACsAAAAPQAAAG5dEABdAAAAlQAAACYAAAAAAAAABAAAAAQAAABFDgAAAAAAAAQAAAAEAAAAIQ4AAEJpbmFyeQAAAAAAAAQAAAAEAAAAIg4AAExpc3QAAAAABAAAAAQAAAAjDgAAU3RydWN0RGljdGlvbmFyeQAAAAAEAAAABAAAADEAAABBcnJheWZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0JFcQAGkAAAAYAAAACgAAAIZOEABlAAAALAAAABIAAACGThAAZQAAADAAAAASAAAAhk4QAGUAAAAxAAAAHwAAAIZOEABlAAAAMgAAAB8AAACGThAAZQAAAF0AAAAqAAAAhk4QAGUAAABeAAAAKgAAAIZOEABlAAAAaAAAADEAAACGThAAZQAAAGkAAAAxAAAAbm90IGltcGxlbWVudGVkOiBMb2dpY2FsIGVxdWFsaXR5IG5vdCB5ZXQgaW1wbGVtZW50ZWQgYmV0d2VlbiBkZW5zZSBhbmQgc3BhcnNlIHVuaW9uIGFycmF5cwDIzyEAWwAAAIZOEABlAAAAewAAAA4AAADOUBAAawAAABcAAAASAAAAAAAAAAwAAAAEAAAARg4AAEcOAABHDgAAUQIQAHAAAAAcAAAAEwAAAFECEABwAAAAHAAAADAAAAAAAAAADAAAAAQAAABIDgAASQ4AAEkOAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlUQIQAHAAAAAZAAAADgAAAFECEABwAAAAIAAAAC0AAABRAhAAcAAAACgAAAAOAAAAAAAAAAgAAAAEAAAASg4AAEsOAABLDgAAAAAAAAgAAAAEAAAATA4AAE0OAABNDgAAmhcQAGgAAAAmAAAARQAAAJoXEABoAAAAKAAAAB8AAACaFxAAaAAAACoAAAARAAAAmhcQAGgAAAArAAAAEQAAAG9mZnNldCBvdmVyZmxvdwC/KBAAaQAAACoAAAA4AAAALWMQAHEAAAAkAAAAGAAAAC1jEABxAAAAJQAAAB0AAAAtYxAAcQAAACYAAAAdAAAALWMQAHEAAAAuAAAAEgAAAAAAAAAQAAAABAAAAE4OAABPDgAATw4AAAAAAAAQAAAABAAAAFAOAABRDgAAUQ4AAC1jEABxAAAANwAAAEUAAABIbRAAbAAAAEsCAAATAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAGFzc2VydGlvbiBmYWlsZWQ6IHByZWZpeC5pc19lbXB0eSgpICYmIHN1ZmZpeC5pc19lbXB0eSgpSG0QAGwAAABPAQAACQBBhKaHAQuxAQEAAABSDgAATGF5b3V0RXJyb3IAyxYQAGoAAAAjAAAAFwAAAMsWEABqAAAAJAAAABcAAADLFhAAagAAADMAAAAlAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZcsWEABqAAAAIAAAAA4AAAAAAAAABAAAAAQAAABTDgAAVA4AAFQOAABXFhAAcwAAABoAAAAOAAAAVxYQAHMAAAAqAAAADgBBwKeHAQsOAQAAAFUOAABWDgAAVg4AQdinhwELkycBAAAAVw4AAFgOAABYDgAAAAAAAAgAAAAEAAAAWQ4AAFoOAABaDgAAHE4QAGkAAAAdAAAALQAAAAAAAAAUAAAABAAAAFsOAABcDgAAXA4AABxOEABpAAAAKwAAAAkAAAAcThAAaQAAADMAAAAtAAAAHE4QAGkAAAA2AAAAHwAAAGludmFsaWQgdW5pb24gdHlwZSBJRAAAABxOEABpAAAAOgAAABYAAAAcThAAaQAAADsAAAAiAAAAHE4QAGkAAAA8AAAAOQAAABxOEABpAAAAQQAAACMAAABjYW5ub3QgY2FsbCBleHRlbmRfbnVsbHMgb24gVW5pb25BcnJheSBhcyBjYW5ub3QgaW5mZXIgdHlwZQCw1CEAOwAAABxOEABpAAAASAAAAAUAAAAcThAAaQAAAEwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAAxgQAGQAAABPAAAAHAAAAAMYEABkAAAATwAAAEQAAAADGBAAZAAAAFAAAAALAAAAAxgQAGQAAABQAAAALQAAAAMYEABkAAAAUgAAABwAAAADGBAAZAAAAFIAAABEAAAAAxgQAGQAAABTAAAACwAAAAMYEABkAAAAUwAAAC0AAAADGBAAZAAAAFkAAAAXAAAAAxgQAGQAAABaAAAAFwAAAAMYEABkAAAAZgAAAB0AAAADGBAAZAAAAGcAAAAdAAAAAxgQAGQAAABsAAAAMwAAAAMYEABkAAAAbQAAADMAAAADGBAAZAAAAHIAAAAlAAAAAxgQAGQAAACCAAAAJAAAAAMYEABkAAAAggAAAEQAAAADGBAAZAAAAIMAAAAiAAAAAxgQAGQAAACDAAAARgAAAAMYEABkAAAAhAAAACQAAAADGBAAZAAAAIQAAABEAAAAAxgQAGQAAACFAAAAIgAAAAMYEABkAAAAhQAAAEYAAAApKRAAZQAAAGYAAAAPAAAAKSkQAGUAAABmAAAAOwAAAJ9jEABtAAAAIQAAABUAAACfYxAAbQAAACIAAAAVAAAAn2MQAG0AAAAjAAAAFAAAAJ9jEABtAAAAJQAAAAoAAACfYxAAbQAAACYAAAAUAAAAn2MQAG0AAAAoAAAACgAAAJ9jEABtAAAAPAAAABYAAACfYxAAbQAAAD0AAAAWAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAIhJEABnAAAAMgAAABcAAACISRAAZwAAAEsAAAAcAAAAcnVuIGVuZCBvdmVyZmxvd4hJEABnAAAATAAAABwAAACISRAAZwAAAE0AAAAcAAAASW52YWxpZCBydW4gZW5kIHR5cGUgZm9yIFJ1bkVuZEVuY29kZWQgYXJyYXk6IAAA2NchAC4AAACISRAAZwAAAE4AAAAOAAAAZXh0ZW5kX251bGxzIGNhbGxlZCBvbiBub24tUnVuRW5kRW5jb2RlZCBhcnJheQAAINghAC4AAACISRAAZwAAADgAAAAJAAAAiEkQAGcAAABnAAAANQAAAIhJEABnAAAAhQAAABYAAACISRAAZwAAAIYAAAAgAAAAVW5yZWFjaGFibGU6IHZhbHVlc19yYW5nZSBjYW5ub3QgYmUgTm9uZSB3aGVuIHByZXZfZW5kIDwgZW5kICYmIHJ1bl9lbmQgPj0gZW5kLiBEdWUgdG8gc2VxdWVudGlhbCBwcm9jZXNzaW5nIGFuZCBtb25vdG9uaWMgcHJldl9lbmQgYWR2YW5jZW1lbnQsIGlmIHdlIHJlYWNoIGEgcnVuIHRoYXQgc3BhbnMgYmV5b25kIHRoZSBzbGljZSBlbmQgKHJ1bl9lbmQgPj0gZW5kKSwgYXQgbGVhc3Qgb25lIHByZXZpb3VzIGNvbmRpdGlvbiBtdXN0IGhhdmUgbWF0Y2hlZCBmaXJzdCB0byBzZXQgdmFsdWVzX3JhbmdlLiBFaXRoZXIgdGhlIGZpcnN0IGNvbmRpdGlvbiBtYXRjaGVkIHdoZW4gdGhlIHNsaWNlIHN0YXJ0ZWQgKHByZXZfZW5kIDw9IHN0YXJ0ICYmIHJ1bl9lbmQgPiBzdGFydCksIG9yIHRoZSBzZWNvbmQgY29uZGl0aW9uIG1hdGNoZWQgZm9yIHJ1bnMgd2l0aGluIHRoZSBzbGljZSAocHJldl9lbmQgPj0gc3RhcnQgJiYgcnVuX2VuZCA8PSBlbmQpLohJEABnAAAAiQAAADMAAACISRAAZwAAAHoAAAAWAAAAiEkQAGcAAAB7AAAAIAAAAFVucmVhY2hhYmxlOiB2YWx1ZXNfcmFuZ2UgY2Fubm90IGJlIE5vbmUgd2hlbiBwcmV2X2VuZCA+PSBzdGFydCAmJiBydW5fZW5kIDw9IGVuZC4gSWYgcHJldl9lbmQgPj0gc3RhcnQgYW5kIHJ1bl9lbmQgPiBwcmV2X2VuZCAocmVxdWlyZWQgZm9yIHZhbGlkIHJ1bnMpLCB0aGVuIHJ1bl9lbmQgPiBzdGFydCwgd2hpY2ggbWVhbnMgdGhlIGZpcnN0IGNvbmRpdGlvbiAocHJldl9lbmQgPD0gc3RhcnQgJiYgcnVuX2VuZCA+IHN0YXJ0KSB3b3VsZCBoYXZlIGJlZW4gdHJ1ZSBhbmQgYWxyZWFkeSBzZXQgdmFsdWVzX3JhbmdlIHRvIFNvbWUuAAAAiEkQAGcAAAB+AAAAMwAAAIhJEABnAAAAcgAAABYAAACISRAAZwAAAHMAAAAgAAAAdmFsdWVzX3JhbmdlIHNob3VsZCBiZSBTb21lIGlmIHJ1bl9lbmRzX2J5dGVzIGlzIG5vdCBlbXB0eQAAiEkQAGcAAACxAAAAFgAAAIhJEABnAAAAsgAAABcAAAAAAAAABAAAAAQAAABdDgAAXg4AAF4OAACISRAAZwAAAMAAAAAkAAAAiEkQAGcAAADBAAAAIgAAAIhJEABnAAAA4QAAACQAAACISRAAZwAAAOIAAAAkAAAAiEkQAGcAAADjAAAAJAAAAIhJEABnAAAA5AAAABYAAABleHRlbmQgY2FsbGVkIG9uIG5vbi1SdW5FbmRFbmNvZGVkIG11dGFibGUgYXJyYXnk3CEAMAAAAIhJEABnAAAAyAAAABUAAAAkVxAAaQAAACcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAAAAAAAQAAAAEAAAAXw4AAAAAAAAEAAAABAAAAGAOAAAuLgAAOlEQAGcAAAAhAAAAFgAAADpREABnAAAAIgAAABYAAADCAhAAbAAAACYAAAAXAAAAwgIQAGwAAAAmAAAAMgAAAMICEABsAAAAJwAAABcAAADCAhAAbAAAACcAAAAyAAAAwgIQAGwAAABQAAAAKQAAAMICEABsAAAAOQAAACkAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlwgIQAGwAAAAjAAAADgAAACkpEABlAAAAZgAAAA8AAAApKRAAZQAAAGYAAAA7AAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAe2QQAGkAAAAkAAAAFwAAAHtkEABpAAAAJAAAADIAAAB7ZBAAaQAAACUAAAAXAAAAe2QQAGkAAAAlAAAAMgAAAHtkEABpAAAATgAAACkAAAB7ZBAAaQAAADgAAAApAAAAKSkQAGUAAABmAAAADwAAACkpEABlAAAAZgAAADsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAAB/ARAAagAAACEAAAAXAAAAfwEQAGoAAAAiAAAAFwAAAH8BEABqAAAANgAAACUAAAB/ARAAagAAAC4AAAARAAAAfwEQAGoAAAAuAAAALgAAAH8BEABqAAAALwAAABEAAAB/ARAAagAAAC8AAAAuAAAAfwEQAGoAAABDAAAAGQAAAH8BEABqAAAAQwAAADYAAAB/ARAAagAAAEQAAAAZAAAAfwEQAGoAAABEAAAANgAAAPBJEABjAAAALwAAAB8AAADwSRAAYwAAADAAAAAdAAAA8EkQAGMAAAAzAAAAHwAAAPBJEABjAAAANAAAAB0AAABub3QgaW1wbGVtZW50ZWQ6IExvZ2ljYWwgY29tcGFyaXNvbiBmb3IgcnVuIGFycmF5IG5vdCBzdXBwb3J0ZWQuOOAhAEAAAADwSRAAYwAAACcAAAAJAAAAKSkQAGUAAABGAAAAKAAAACkpEABlAAAARwAAACgAAAApKRAAZQAAAEgAAAAqAAAAKSkQAGUAAABJAAAAKgAAAE1hcCB0eXBlIHNob3VsZCBoYXZlIDIgZmllbGRzIFN0cnVjdCBpbiBpdHMgZmllbGQAAADQ4CEAMQAAACkpEABlAAAAVAAAABYAAABub3QgaW1wbGVtZW50ZWQ6IExpc3RWaWV3L0xhcmdlTGlzdFZpZXcgbm90IHlldCBpbXBsZW1lbnRlZAAc4SEAOwAAAIqBEABjAAAAbAAAAA0AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlioEQAGMAAAB7AAAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAANcyEAB4AAAA6wcAAAkAAABOb25lAAAAAAQAAAAEAAAAMQAAAFNvbWUAAAAABAAAAAQAAABhDgAAAAAAAAQAAAAEAAAAYg4AAM51EABqAAAAvQEAAB0AAAB4ExAAaQAAABsAAAArAAAAeBMQAGkAAAAcAAAAJQAAAHgTEABpAAAAHQAAACsAAAB4ExAAaQAAAB4AAAAlAAAAeBMQAGkAAAA7AAAAGQAAAHgTEABpAAAAPAAAABkAAAB4ExAAaQAAAEIAAAAUAAAAeBMQAGkAAABCAAAAOgAAAEtpEABpAAAANQAAACUAAABFbmNvdW50ZXJlZCBub24tVVRGLTggZGF0YSBhdCBpbmRleCA6IAAAwOIhACQAAADk4iEAAgAAAE1pc21hdGNoIGJldHdlZW4gZW1iZWRkZWQgcHJlZml4IGFuZCBkYXRhVmlldyBhdCBpbmRleCAgY29udGFpbmVkIG5vbi16ZXJvIHBhZGRpbmcgZm9yIHN0cmluZyBvZiBsZW5ndGggIeMhAA4AAAAv4yEAMQAAAEludmFsaWQgYnVmZmVyIGluZGV4IGF0IDogZ290IGluZGV4ICBidXQgb25seSBoYXMgIGJ1ZmZlcnMAAHDjIQAYAAAAiOMhAAwAAACU4yEADgAAAKLjIQAIAAAASW52YWxpZCBidWZmZXIgc2xpY2UgYXQgOiBnb3QgLi4gYnV0IGJ1ZmZlciAgaGFzIGxlbmd0aCDM4yEAGAAAAOTjIQAGAAAA6uMhAAIAAADs4yEADAAAAPjjIQAMAAAAcIsQAH4AAAA0AAAABQAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAF8DAAAJAAAA1zIQAHgAAADrBwAACQAAAFN0cnVjdCgsIAAAAAEAAAAAAAAAKU51bGxCb29sZWFuSW50OEludDE2SW50MzJJbnQ2NFVJbnQ4VUludDE2VUludDMyVUludDY0RmxvYXQxNkZsb2F0MzJGbG9hdDY0AAAAAAABAAAAAQAAAGQOAAAAAAAABAAAAAQAAAAyCAAAVGltZXN0YW1wRGF0ZTMyRGF0ZTY0AAAAAAAAAAQAAAAEAAAAKgQAAFRpbWUzMlRpbWU2NER1cmF0aW9uAAAAAAQAAAAEAAAAzAQAAEludGVydmFsQmluYXJ5AAAAAAAABAAAAAQAAABtAwAARml4ZWRTaXplQmluYXJ5TGFyZ2VCaW5hcnlCaW5hcnlWaWV3VXRmOExhcmdlVXRmOFV0ZjhWaWV3AAAAAAAAAAQAAAAEAAAAMwgAAExpc3RMaXN0Vmlld2UOAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AABmDgAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAZw4AAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAABoDgAAAAAAAAQAAAAEAAAAEQUAAERlY2ltYWwzMkRlY2ltYWw2NERlY2ltYWwxMjhEZWNpbWFsMjU2AAAAAAAABAAAAAQAAAA9CAAATWFwUnVuRW5kRW5jb2RlZFNlY29uZE1pbGxpc2Vjb25kTWljcm9zZWNvbmROYW5vc2Vjb25kWWVhck1vbnRoRGF5VGltZU1vbnRoRGF5TmFub1NwYXJzZURlbnNlAAAACQAAAAcAAAAMAAAA3uYhAOfmIQDu5iEABgAAAAsAAAALAAAACgAAALjmIQC+5iEAyeYhANTmIQDXMhAAeAAAAOsHAAAJAAAAznUQAGoAAAC9AQAAHQAAAP//////////YOchAEH4zocBC4oMAQAAAAAAAABOdWxsQm9vbGVhbkludDhJbnQxNkludDMySW50NjRVSW50OFVJbnQxNlVJbnQzMlVJbnQ2NEZsb2F0MTZGbG9hdDMyRmxvYXQ2NAAAAAAAAAEAAAABAAAAag4AAAAAAAAEAAAABAAAADIIAABUaW1lc3RhbXBEYXRlMzJEYXRlNjQAAAAAAAAABAAAAAQAAAAqBAAAVGltZTMyVGltZTY0RHVyYXRpb24AAAAABAAAAAQAAADMBAAASW50ZXJ2YWxCaW5hcnkAAAAAAAAEAAAABAAAAG0DAABGaXhlZFNpemVCaW5hcnlMYXJnZUJpbmFyeUJpbmFyeVZpZXdVdGY4TGFyZ2VVdGY4VXRmOFZpZXcAAAAAAAAABAAAAAQAAAAzCAAATGlzdExpc3RWaWV3aw4AAAQAAAAEAAAANQgAAEZpeGVkU2l6ZUxpc3RMYXJnZUxpc3RMYXJnZUxpc3RWaWV3AAAAAAAEAAAABAAAADYIAABTdHJ1Y3QAAGwOAAAIAAAABAAAADgIAAAAAAAABAAAAAQAAAA5CAAAVW5pb24AAABtDgAABAAAAAQAAAA7CAAAAAAAAAQAAAAEAAAAFwYAAERpY3Rpb25hcnkAAAAAAAABAAAAAQAAAG4OAAAAAAAABAAAAAQAAAARBQAARGVjaW1hbDMyRGVjaW1hbDY0RGVjaW1hbDEyOERlY2ltYWwyNTYAAAAAAAAEAAAABAAAAD0IAABNYXBSdW5FbmRFbmNvZGVkU2Vjb25kTWlsbGlzZWNvbmRNaWNyb3NlY29uZE5hbm9zZWNvbmQAAG8OAAAMAAAABAAAAHAOAABxDgAADAAAAAQAAAByDgAAAAAAAAEAAAABAAAAcw4AAAAAAAAIAAAACAAAAHQOAAAAAAAABAAAAAQAAAAlBAAAbmFtZWRhdGFfdHlwZW51bGxhYmxlZGljdF9pZGRpY3RfaXNfb3JkZXJlZG1ldGFkYXRhADDqIQAEAAAANOohAAkAAAA96iEACAAAAEXqIQAHAAAATOohAA8AAABb6iEACAAAAEZpZWxkAAAABgAAAAsAAAALAAAACgAAALjpIQC+6SEAyekhANTpIQDXMhAAeAAAAOsHAAAJAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQB5DgAAEAAAAAQAAAB6DgAAAAAAAAQAAAAEAAAAew4AAAAAAAAEAAAABAAAAHwOAABOdWxFcnJvcs51EABqAAAAvQEAAB0AAADMXRAAXwAAAIsAAAAsAAAAzF0QAF8AAAClAAAAKAAAAP///38gd2VyZSBwcm92aWRlZG1ldGFkYXRhIGtleSBjYW4gb25seSBoYXZlICBieXRlcywgYnV0IAAAAHLrIQAbAAAAjeshAAwAAABk6yEADgAAAG1ldGFkYXRhIHZhbHVlIGNhbiBvbmx5IGhhdmUgAAAAtOshAB0AAACN6yEADAAAAGTrIQAOAAAAbmJjc2lsQ1NJTGVmZ3RzczoAAAD56yEABAAAAHRzbToI7CEABAAAAHRzdToU7CEABAAAAHRzbjog7CEABAAAAHRkRHRkbXR0c3R0bXR0dXR0bnREc3REbXREdXREbnRpTXRpRHRpbnp3OgAAVOwhAAIAAABadnp1VXZ1K2wrdzpp7CEAAwAAACtMK3MsK3VzOgAAAHnsIQAEAAAAK3VkOojsIQAEAAAAZDosMzIAAACU7CEAAgAAAHjsIQABAAAAluwhAAMAAAAsNjQAlOwhAAIAAAB47CEAAQAAALTsIQADAAAAlOwhAAIAAAB47CEAAQAAACwyNTaU7CEAAgAAAHjsIQABAAAA4OwhAAQAAAArbStyVGhlIGRhdGF0eXBlICIiIGlzIHN0aWxsIG5vdCBzdXBwb3J0ZWQgaW4gUnVzdCBpbXBsZW1lbnRhdGlvbgAAAADtIQAOAAAADu0hAC8AAAA+7CEAQewhAETsIQBH7CEASuwhAE3sIQBQ7CEAfg4AAAwAAAAEAAAAfw4AAIAOAACBDgBBjNuHAQvfAQEAAACCDgAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA4l8QAGsAAADoAQAAFwAAAOJfEABrAAAAVAsAAAEAAABFcnJvcgAAAOJfEABrAAAAzwwAAA4AAAAgAAAAAQAAAAAAAAAU7iEAAQAAAHByb2plY3QgaW5kZXggIG91dCBvZiBib3VuZHMsIG1heCBmaWVsZCAo7iEADgAAADbuIQAaAAAA//////////9g7iEAQfjchwELowPXMhAAeAAAAOsHAAAJAAAAWpYQAGIAAAArAAAAFQAAAFVuYWJsZSB0byBnZXQgZmllbGQgbmFtZWQgIiIuIFZhbGlkIGZpZWxkczogmO4hABsAAACz7iEAEQAAACwgTm9uZQAAAAAAAAQAAAAEAAAAQwUAAFNvbWUAAAAABAAAAAQAAACEDgAAAAAAAAQAAAAEAAAASgIAAAAAAAAEAAAABAAAAIUOAAAAAAAABAAAAAQAAAAzCAAAAAAAAAQAAAAEAAAAhg4AAG1pZCA+IGxlbgAAAEDvIQAJAAAATBoQAH8AAABKAAAAHwAAAEwaEAB/AAAARAAAABcAAABhdHRlbXB0IHRvIGpvaW4gaW50byBjb2xsZWN0aW9uIHdpdGggbGVuID4gdXNpemU6Ok1BWAAAALcwEABoAAAAmgAAAAoAAAC3MBAAaAAAAJ0AAAAWAAAAtzAQAGgAAACgAAAADAAAAG1pZCA+IGxlbgAAANzvIQAJAAAAtzAQAGgAAACxAAAAFgAAAONqEABpAAAAzAAAAAUAAAD//////////xDwIQBBrOCHAQsaBAAAAAQAAAARBQAAAAAAAAQAAAAEAAAAMwgAQdDghwELwgwBAAAAhw4AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAgo8QAGkAAAAWCAAAKQAAAExheW91dEVycm9yTnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAAAAQAAAAEAAACIDgAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4Vmlld0xpc3RMaXN0VmlldwAAAIkOAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AACKDgAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAiw4AAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAACMDgAARGVjaW1hbDMyRGVjaW1hbDY0RGVjaW1hbDEyOERlY2ltYWwyNTYAAAAAAAAEAAAABAAAAD0IAABNYXBSdW5FbmRFbmNvZGVkU2Vjb25kTWlsbGlzZWNvbmRNaWNyb3NlY29uZE5hbm9zZWNvbmQAAI0OAAAMAAAABAAAAI4OAACPDgAADAAAAAQAAACQDgAAAAAAAAEAAAABAAAAkQ4AAAAAAAAIAAAACAAAAJIOAAAAAAAABAAAAAQAAAAlBAAAbmFtZWRhdGFfdHlwZW51bGxhYmxlZGljdF9pZGRpY3RfaXNfb3JkZXJlZG1ldGFkYXRhADDzIQAEAAAANPMhAAkAAAA98yEACAAAAEXzIQAHAAAATPMhAA8AAABb8yEACAAAAEZpZWxkAAAABgAAAAsAAAALAAAACgAAALjyIQC+8iEAyfIhANTyIQAQORAAbwAAAJAAAAAuAAAAOoYQAHAAAAAuAgAAEQAAAE51bGxCb29sZWFuSW50OEludDE2SW50MzJJbnQ2NFVJbnQ4VUludDE2VUludDMyVUludDY0RmxvYXQxNkZsb2F0MzJGbG9hdDY0AAAAAAAAAQAAAAEAAACTDgAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4VmlldwAAAAAAAAAEAAAABAAAADMIAABMaXN0TGlzdFZpZXeUDgAABAAAAAQAAAA1CAAARml4ZWRTaXplTGlzdExhcmdlTGlzdExhcmdlTGlzdFZpZXcAAAAAAAQAAAAEAAAANggAAFN0cnVjdAAAlQ4AAAgAAAAEAAAAOAgAAAAAAAAEAAAABAAAADkIAABVbmlvbgAAAJYOAAAEAAAABAAAADsIAAAAAAAABAAAAAQAAAAXBgAARGljdGlvbmFyeQAAAAAAAAEAAAABAAAAlw4AAAAAAAAEAAAABAAAABEFAABEZWNpbWFsMzJEZWNpbWFsNjREZWNpbWFsMTI4RGVjaW1hbDI1NgAAAAAAAAQAAAAEAAAAPQgAAE1hcFJ1bkVuZEVuY29kZWRTZWNvbmRNaWxsaXNlY29uZE1pY3Jvc2Vjb25kTmFub3NlY29uZAAABgAAAAsAAAALAAAACgAAABT2IQAa9iEAJfYhADD2IQDXMhAAeAAAAOsHAAAJAAAA8lkQAG8AAAAZAQAAGQAAAJoOAAAMAAAABAAAAJsOAACcDgAAgQ4AQZzthwELgQcBAAAAnQ4AAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAAM4FA5hqJmElzQK+h5WqMNlFcnJvcgAAAOJfEABrAAAAzwwAAA4AAABOb3QgeWV0IGltcGxlbWVudGVkOiAAAAAU9yEAFQAAAEV4dGVybmFsIGVycm9yOiA09yEAEAAAAENhc3QgZXJyb3I6IEz3IQAMAAAATWVtb3J5IGVycm9yOiAAAGD3IQAOAAAAUGFyc2VyIGVycm9yOiAAAHj3IQAOAAAAU2NoZW1hIGVycm9yOiAAAJD3IQAOAAAAQ29tcHV0ZSBlcnJvcjogAKj3IQAPAAAARGl2aWRlIGJ5IHplcm8gZXJyb3JBcml0aG1ldGljIG92ZXJmbG93OiAAAADU9yEAFQAAAENzdiBlcnJvcjogAPT3IQALAAAASnNvbiBlcnJvcjogCPghAAwAAABJbyBlcnJvcjogAAAc+CEACgAAAElwYyBlcnJvcjogADD4IQALAAAASW52YWxpZCBhcmd1bWVudCBlcnJvcjogRPghABgAAABQYXJxdWV0IGFyZ3VtZW50IGVycm9yOiBk+CEAGAAAAEMgRGF0YSBpbnRlcmZhY2UgZXJyb3I6IIT4IQAYAAAARGljdGlvbmFyeSBrZXkgYmlnZ2VyIHRoYW4gdGhlIGtleSB0eXBlUnVuIGVuZCBlbmNvZGVkIGFycmF5IGluZGV4IG92ZXJmbG93IGVycm9yT2Zmc2V0IG92ZXJmbG93IGVycm9yOiD1+CEAFwAAAJ4OAAAIAAAABAAAAIYAAACeDgAACAAAAAQAAABTAgAAhgAAABT5IQBUAgAAnw4AAFYCAABXAgAAoA4AALAbEABnAAAAswEAAA8AAACwGxAAZwAAAJEBAAAaAAAAAAAAAAQAAAAAAAAARxsQAGgAAADwAQAAFgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAow4AAAwAAAAEAAAApA4AAAEAAAAAAAAA+HgQAGYAAABVAAAAHgAAAPh4EABmAAAAVgAAAB8AAAD4eBAAZgAAADgBAAAWAAAA+HgQAGYAAAA7AQAASAAAAPh4EABmAAAAPAEAAD4AQaj0hwELrQYBAAAApQ4AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWVMYXlvdXRFcnJvcmZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyALVtEABqAAAAWgAAAA4AAAC1bRAAagAAAHgAAAA+AAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IHNlbGYubGF5b3V0LnNpemUoKQC1bRAAagAAAK4AAAAJAAAAtW0QAGoAAADjAAAAUQAAAGFzc2VydGlvbiBmYWlsZWQ6IHByZWZpeC5pc19lbXB0eSgpICYmIHN1ZmZpeC5pc19lbXB0eSgptW0QAGoAAACKAQAACQAAAAAAAABkaXZpc2lvbiBieSB6ZXJvSPshABAAAADiExAAZgAAACAAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogbiArIG0gPD0gTuITEABmAAAAWQAAAAUAAADiExAAZgAAAGwAAAARAAAA4hMQAGYAAAB0AAAADgAAAOITEABmAAAAegAAABIAAADiExAAZgAAAIgAAAAWAAAA4hMQAGYAAAChAAAAKgAAAOITEABmAAAArgAAAAkAAADiExAAZgAAANEAAAAKAAAAYXNzZXJ0aW9uIGZhaWxlZDogb2Zmc2V0X3dyaXRlICsgbGVuIDw9IHdyaXRlX2RhdGEubGVuKCkgKiA4YloQAGkAAAAjAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IG9mZnNldF9yZWFkICsgbGVuIDw9IGRhdGEubGVuKCkgKiA4AAAAYloQAGkAAAAkAAAABQAAAGYsEABhAAAA7wAAADQAAACmDgAAEAAAAAQAAABjMhAAcwAAADkAAAAdAAAAYzIQAHMAAAB2AAAAHgAAAGFzc2VydGlvbiBmYWlsZWQ6IGNlaWwob2Zmc2V0ICsgbGVuLCA4KSA8PSBidWZmZXIubGVuKCkgKiA4AGMyEABzAAAA4AAAAAkAAABjMhAAcwAAAOsAAAAcAAAAGlUQAGcAAABkAAAAPQAAACRXEABpAAAAOAAAAAUAQeD6hwEL6QEBAAAApw4AAExheW91dEVycm9yZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXK1bRAAagAAAFoAAAAOAAAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAKz9IQAzAAAAtW0QAGoAAACGAgAACQAAAHQnEABmAAAAWAAAACEAAAB0JxAAZgAAAHoAAAAhAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgBB1PyHAQuBAwEAAACoDgAATGF5b3V0RXJyb3J0aGUgb2Zmc2V0IG9mIHRoZSBuZXcgQnVmZmVyIGNhbm5vdCBleGNlZWQgdGhlIGV4aXN0aW5nIGxlbmd0aDogb2Zmc2V0PSBsZW5ndGg9AABn/iEARwAAAK7+IQAIAAAASG0QAGwAAAAVAQAACQAAAHRoZSBvZmZzZXQgb2YgdGhlIG5ldyBCdWZmZXIgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoOiBzbGljZSBvZmZzZXQ9IHNlbGZsZW49AADY/iEATQAAAK7+IQAIAAAAJf8hAAkAAABIbRAAbAAAACwBAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC9AAAAPAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAQeD/hwELpQQBAAAAqQ4AAExheW91dEVycm9yZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXK1bRAAagAAAFoAAAAOAAAAYnVmZmVyIG5vdCBsYXJnZSBlbm91Z2ggKG9mZnNldDogLCBsZW46ICwgYnVmZmVyX2xlbjogKQAsACIAIQAAAE0AIgAHAAAAVAAiAA4AAABiACIAAQAAAPdPEABqAAAAQQAAAAkAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgQm9vbGVhbkJ1ZmZlciBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAAACUACIAUQAAAPdPEABqAAAAowAAAAkAAAD3TxAAagAAAO4AAAAJAAAAYlAQAGsAAAC9AAAAPAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAABhc3NlcnRpb24gZmFpbGVkOiBsZW4gPD0gYnVmZmVyLmxlbigpICogOAAAAGJQEABrAAAAMQAAAAkAAABiUBAAawAAAIgAAAAuAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAADqGEABwAAAALgIAABEAAABiIiJcblxyXHRcAADtASIAAQAAAFwwXHj6ASIAAgAAAAIAQY6EiAELAQIAQZiEiAELXSAAAOkBAAAAAAAAAGFkdmFuY2Ugb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IGFkdmFuY2luZyBieSAkAiIAIgAAAEYCIgASAAAABJQQAFgAAACsAAAABQBBgIWIAQvVDAEAAACsDgAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUxheW91dEVycm9yAADOdRAAagAAAL0BAAAdAAAAqAEAAKkBAACqAQAArQ4AAK4OAAByYW5nZSBzdGFydCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gZW5kOiAgPD0gAADkAiIAKgAAAA4DIgAEAAAACywQAFoAAACGAQAACQAAAHJhbmdlIGVuZCBvdXQgb2YgYm91bmRzOiAAAAA0AyIAGQAAAA4DIgAEAAAACywQAFoAAACMAQAACQAAAHNwbGl0X3RvIG91dCBvZiBib3VuZHM6IHADIgAYAAAADgMiAAQAAAALLBAAWgAAAC4CAAAJAAAACywQAFoAAADOAwAAJAAAAK8OAACwDgAAsQ4AALIOAACzDgAAtA4AALUOAAC2DgAAsg4AALcOAAALLBAAWgAAAEgFAAAyAAAACywQAFoAAABWBQAASQAAALgOAAC5DgAAug4AALsOAAC8DgAAznUQAGoAAAC9AQAAHQAAAG92ZXJmbG93eBQQAF4AAACqAgAAFQAAAHgUEABeAAAAAAMAACcAAAB4FBAAXgAAANQCAAA4AAAAvQ4AAL4OAAC/DgAAwA4AAMEOAABtaWQgPiBsZW4AAABwBCIACQAAAC9LEABpAAAAOwAAABoAAAAvSxAAaQAAAGoAAAAiAAAAL0sQAGkAAABvAAAAFwAAAA1MEABsAAAAhwAAACUAAAABAAAAAx0QAGAAAAAsAAAAHQAAAAMdEABgAAAAYwMAABcAAABtaWQgPiBsZW4AAADoBCIACQAAAM51EABqAAAAvQEAAB0AAAAAAAAABAAAAAAAAAABAAAAL0sQAGkAAAA7AAAAGgAAAC9LEABpAAAAiQAAABsAAAAvSxAAaQAAAI4AAAAbAAAAekwQAG8AAAAsAAAAHAAAAAAAAABjYXJyeSBvdmVyZmxvdyBkdXJpbmcgbXVsdGlwbGljYXRpb24hAAAAYAUiACUAAAB6TBAAbwAAADkAAAAFAAAAekwQAG8AAABIAAAAGwAAAHpMEABvAAAAUAAAABsAAAB6TBAAbwAAAC0BAAAmAAAAekwQAG8AAAAxAQAAJgAAAHpMEABvAAAAMgEAACYAAAB6TBAAbwAAAJMBAAAnAAAAekwQAG8AAACSAQAAJgAAAHpMEABvAAAA5wAAABoAAAB6TBAAbwAAAOwAAAAlAAAAekwQAG8AAAD0AAAAFgAAAHpMEABvAAAA9QAAABYAAAB6TBAAbwAAAKQAAAAWAAAAekwQAG8AAABoAAAAHwAAAHpMEABvAAAAnAEAACQAAAB6TBAAbwAAAK8BAAAcAAAAekwQAG8AAAC5AQAADwAAAHpMEABvAAAAvAEAAA8AAAAAAAAABAAAAAAAAAADHRAAYAAAACwAAAAdAAAAAx0QAGAAAABjAwAAFwAAANcyEAB4AAAA6wcAAAkAAABjaHVuayBzaXplIG11c3QgYmUgbm9uLXplcm8A7AYiABsAAABhdHRlbXB0IHRvIGRpdmlkZSBieSB6ZXJvAAAAEAciABkAAACyTRAAaQAAAFcAAAAJAAAARxsQAGgAAAAwAAAAIAAAAEcbEABoAAAAMwAAAAoAAAAAAAAABAAAAAAAAABHGxAAaAAAAPABAAAWAAAARxsQAGgAAABeAgAAIAAAAEcbEABoAAAAYgIAABMAAABHGxAAaAAAAGQCAAAYAAAARxsQAGgAAABtAgAADQAAAEcbEABoAAAAZgIAABEAAABHGxAAaAAAAHwCAAATAAAARxsQAGgAAACTAgAADQAAAEcbEABoAAAAhgIAABEAAABHGxAAaAAAAK4CAAATAAAARxsQAGgAAADlAgAAHAAAAEcbEABoAAAA5wIAABIAAABHGxAAaAAAAOcCAAANAAAARxsQAGgAAADfAgAAFgAAAEcbEABoAAAA3wIAABEAAABHGxAAaAAAANUCAAAeAAAARxsQAGgAAADVAgAAGQAAAEcbEABoAAAA9AIAAAwAAABUaGUgcmFkaXggbXVzdCBiZSB3aXRoaW4gMi4uLjM2AJAIIgAfAAAARxsQAGgAAAADAwAABQAAAEcbEABoAAAAJgMAAAUAQfCRiAELBanmAAAKAEGAkogBCxUJPQAABgAAAEC2AAAGAAAAp0EAAAUAQaCSiAELNanmAAAFAAAAECcAAAQAAAAxOQAABAAAAABRAAAEAAAAkW8AAAQAAAAQlgAABAAAAMHFAAAEAEHgkogBC3UxEwAAAwAAAMgWAAADAAAAyxoAAAMAAABAHwAAAwAAAC0kAAADAAAAmCkAAAMAAACHLwAAAwAAAAA2AAADAAAACT0AAAMAAACoRAAAAwAAAONMAAADAAAAwFUAAAMAAABFXwAAAwAAAHhpAAADAAAAX3QAAAMAQeCTiAEL9QFhjAAAAwAAAIiZAAADAAAAe6cAAAMAAABAtgAAAwAAAN3FAAADAAAAWNYAAAMAAAC35wAAAwAAAAD6AAADAAAAkQYAAAIAAADkBgAAAgAAADkHAAACAAAAkAcAAAIAAADpBwAAAgAAAEQIAAACAAAAoQgAAAIAAAAACQAAAgAAAGEJAAACAAAAxAkAAAIAAAApCgAAAgAAAJAKAAACAAAA+QoAAAIAAABkCwAAAgAAANELAAACAAAAQAwAAAIAAACxDAAAAgAAACQNAAACAAAAmQ0AAAIAAAAQDgAAAgAAAIkOAAACAAAABA8AAAIAAACBDwAAAgBB4JWIAQv1A4EQAAACAAAABBEAAAIAAACJEQAAAgAAABASAAACAAAAmRIAAAIAAAAkEwAAAgAAALETAAACAAAAQBQAAAIAAADRFAAAAgAAAGQVAAACAAAA+RUAAAIAAACQFgAAAgAAACkXAAACAAAAxBcAAAIAAABhGAAAAgAAAAAZAAACAAAAoRkAAAIAAABEGgAAAgAAAOkaAAACAAAAkBsAAAIAAAA5HAAAAgAAAOQcAAACAAAAkR0AAAIAAABAHgAAAgAAAPEeAAACAAAApB8AAAIAAABZIAAAAgAAABAhAAACAAAAySEAAAIAAACEIgAAAgAAAEEjAAACAAAAACQAAAIAAADBJAAAAgAAAIQlAAACAAAASSYAAAIAAAAQJwAAAgAAANknAAACAAAApCgAAAIAAABxKQAAAgAAAEAqAAACAAAAESsAAAIAAADkKwAAAgAAALksAAACAAAAkC0AAAIAAABpLgAAAgAAAEQvAAACAAAAITAAAAIAAAAAMQAAAgAAAOExAAACAAAAxDIAAAIAAACpMwAAAgAAAJA0AAACAAAAeTUAAAIAAABkNgAAAgAAAFE3AAACAAAAQDgAAAIAAAAxOQAAAgAAACQ6AAACAAAAGTsAAAIAAAAQPAAAAgAAAAk9AAACAAAABD4AAAIAAAABPwAAAgBB4JmIAQv1BwFBAAACAAAABEIAAAIAAAAJQwAAAgAAABBEAAACAAAAGUUAAAIAAAAkRgAAAgAAADFHAAACAAAAQEgAAAIAAABRSQAAAgAAAGRKAAACAAAAeUsAAAIAAACQTAAAAgAAAKlNAAACAAAAxE4AAAIAAADhTwAAAgAAAABRAAACAAAAIVIAAAIAAABEUwAAAgAAAGlUAAACAAAAkFUAAAIAAAC5VgAAAgAAAORXAAACAAAAEVkAAAIAAABAWgAAAgAAAHFbAAACAAAApFwAAAIAAADZXQAAAgAAABBfAAACAAAASWAAAAIAAACEYQAAAgAAAMFiAAACAAAAAGQAAAIAAABBZQAAAgAAAIRmAAACAAAAyWcAAAIAAAAQaQAAAgAAAFlqAAACAAAApGsAAAIAAADxbAAAAgAAAEBuAAACAAAAkW8AAAIAAADkcAAAAgAAADlyAAACAAAAkHMAAAIAAADpdAAAAgAAAER2AAACAAAAoXcAAAIAAAAAeQAAAgAAAGF6AAACAAAAxHsAAAIAAAApfQAAAgAAAJB+AAACAAAA+X8AAAIAAABkgQAAAgAAANGCAAACAAAAQIQAAAIAAACxhQAAAgAAACSHAAACAAAAmYgAAAIAAAAQigAAAgAAAImLAAACAAAABI0AAAIAAACBjgAAAgAAAACQAAACAAAAgZEAAAIAAAAEkwAAAgAAAImUAAACAAAAEJYAAAIAAACZlwAAAgAAACSZAAACAAAAsZoAAAIAAABAnAAAAgAAANGdAAACAAAAZJ8AAAIAAAD5oAAAAgAAAJCiAAACAAAAKaQAAAIAAADEpQAAAgAAAGGnAAACAAAAAKkAAAIAAAChqgAAAgAAAESsAAACAAAA6a0AAAIAAACQrwAAAgAAADmxAAACAAAA5LIAAAIAAACRtAAAAgAAAEC2AAACAAAA8bcAAAIAAACkuQAAAgAAAFm7AAACAAAAEL0AAAIAAADJvgAAAgAAAITAAAACAAAAQcIAAAIAAAAAxAAAAgAAAMHFAAACAAAAhMcAAAIAAABJyQAAAgAAABDLAAACAAAA2cwAAAIAAACkzgAAAgAAAHHQAAACAAAAQNIAAAIAAAAR1AAAAgAAAOTVAAACAAAAudcAAAIAAACQ2QAAAgAAAGnbAAACAAAARN0AAAIAAAAh3wAAAgAAAADhAAACAAAA4eIAAAIAAADE5AAAAgAAAKnmAAACAAAAkOgAAAIAAAB56gAAAgAAAGTsAAACAAAAUe4AAAIAAABA8AAAAgAAADHyAAACAAAAJPQAAAIAAAAZ9gAAAgAAABD4AAACAAAACfoAAAIAAAAE/AAAAgAAAAH+AAACAEHgoYgBC4EwAx0QAGAAAAAsAAAAHQAAAAMdEABgAAAAVgMAACsAAAADHRAAYAAAAGMDAAAXAAAAOoYQAHAAAAAuAgAAEQAAAPyGEABsAAAA4goAACQAAADOdRAAagAAAL0BAAAdAAAAoTgQAG4AAAD2BQAAFQAAAG1pZCA+IGxlbgAAAFARIgAJAAAAL0sQAGkAAAA7AAAAGgAAAGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAAB0ESIAGQAAALJNEABpAAAAVwAAAAkAAAAAAAAABAAAAAAAAACyTRAAaQAAAO4AAAAfAAAAsk0QAGkAAADSAAAACQAAALJNEABpAAAAFQEAAA4AAACyTRAAaQAAABYBAAAOAAAAsk0QAGkAAAAaAQAADwAAALJNEABpAAAAUQEAAAwAAACyTRAAaQAAACABAAAhAAAAsk0QAGkAAAAhAQAAGAAAALJNEABpAAAAQgEAADwAAACyTRAAaQAAAEsBAAAPAAAARxsQAGgAAADwAQAAFgAAAAMdEABgAAAALAAAAB0AAAADHRAAYAAAAGMDAAAXAAAAznUQAGoAAAC9AQAAHQAAAHkfEABmAAAAHgAAABwAAAB5HxAAZgAAACgAAAAZAAAAeR8QAGYAAAAuAAAAEgAAAHkfEABmAAAASgAAACMAAAADHRAAYAAAAGMDAAAXAAAAbWlkID4gbGVuAAAA5BIiAAkAAABuZWdhdGl2ZSB2YWx1ZXMgYXJlIG5vbi16ZXJv4B8QAGUAAABmAAAAKAAAAC9LEABpAAAAOwAAABoAAAAAAAAABAAAAAQAAAC7CQAAQ2Fubm90IHN1YnRyYWN0IGIgZnJvbSBhIGJlY2F1c2UgYiBpcyBsYXJnZXIgdGhhbiBhLkQTIgA0AAAADUwQAGwAAABFAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGFfaGkuaXNfZW1wdHkoKQAAAA1MEABsAAAAYgAAAAUAAAANTBAAbAAAAGUAAAAFAAAAkSQQAGAAAACDAQAAAQAAAMMOAAAEAAAABAAAAMQOAADFDgAAww4AAAQAAAAEAAAAxg4AAMcOAABGbk9uY2UgY2FsbGVkIG1vcmUgdGhhbiBvbmNlyA4AAAQAAAAEAAAAyQ4AAMoOAAC6ZRAAaQAAACUAAAAuAAAAumUQAGkAAAAoAAAAKQAAALplEABpAAAAPgAAABoAAAC6ZRAAaQAAAD4AAAAnAAAAx5EQAGcAAACxAAAADwAAAMeREABnAAAAkQAAACcAAADHkRAAZwAAALsAAAAkAAAAY2xvc3VyZSBpbnZva2VkIHJlY3Vyc2l2ZWx5IG9yIGFmdGVyIGJlaW5nIGRyb3BwZWRMYXp5IGluc3RhbmNlIGhhcyBwcmV2aW91c2x5IGJlZW4gcG9pc29uZWTeFCIAKgAAAC+SEABcAAAACAMAABkAAAByZWVudHJhbnQgaW5pdAAAIBUiAA4AAAAvkhAAXAAAAHoCAAANAAAAHI0QAHUAAAAiAAAAFQAAAM4OAADPDgAA0A4AANEOAAAcjRAAdQAAAGcAAAAlAAAA0g4AAAgAAAAEAAAA0w4AAFdUEABhAAAAVQAAADUAAAABAAAAAAAAAAEAAAAAAAAAzBoQAHoAAAALAAAABQAAANk5EAB4AAAANwEAAEQAAABwtyIAfLciAIi3IgCUtyIAcmV0dXJuIHRoaXMATpMQAFkAAADsGQAAAQAAAExhenkgaW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAA9BUiACoAAAAvkhAAXAAAAAgDAAAZAAAAcmVlbnRyYW50IGluaXQAADgWIgAOAAAAL5IQAFwAAAB6AgAADQAAAHQuEABrAAAAIwEAAA4AAABjbG9zdXJlIGludm9rZWQgcmVjdXJzaXZlbHkgb3IgYWZ0ZXIgYmVpbmcgZHJvcHBlZGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWVudWxsIHBvaW50ZXIgcGFzc2VkIHRvIHJ1c3RyZWN1cnNpdmUgdXNlIG9mIGFuIG9iamVjdCBkZXRlY3RlZCB3aGljaCB3b3VsZCBsZWFkIHRvIHVuc2FmZSBhbGlhc2luZyBpbiBydXN0SnNWYWx1ZSgpAAA9FyIACAAAAEUXIgABAAAAEDkQAG8AAACQAAAALgAAAMZiEABmAAAAfgAAABEAAADGYhAAZgAAAIsAAAARAAAAdC4QAGsAAADnAAAAAQAAAFRKEABvAAAAPAYAABQAAABUShAAbwAAADwGAAAhAAAAVEoQAG8AAAAwBgAAFAAAAFRKEABvAAAAMAYAACEAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbinOdRAAagAAAL0BAAAdAAAAVEoQAG8AAAC9BAAAJAAAACBhdCBsaW5lICBjb2x1bW4gaW52YWxpZCB0eXBlOiAsIGV4cGVjdGVkIAAAORgiAA4AAABHGCIACwAAAGZsb2F0aW5nIHBvaW50IGBgAAAAZBgiABAAAAB0GCIAAQAAAG51bGxQMxAAYAAAAOcBAAAqAAAAUDMQAGAAAAD3AQAAIQAAAFAzEABgAAAA+wEAAAwAAABQMxAAYAAAAAICAAAhAAAAUDMQAGAAAAALAgAAKgAAAFAzEABgAAAADwIAACwAAABQMxAAYAAAABQCAAAJAAAAdWxscnVlYWxzZQAAAAAAAAAA8D8AAAAAAAAkQAAAAAAAAFlAAAAAAABAj0AAAAAAAIjDQAAAAAAAavhAAAAAAICELkEAAAAA0BJjQQAAAACE15dBAAAAAGXNzUEAAAAgX6ACQgAAAOh2SDdCAAAAopQabUIAAEDlnDCiQgAAkB7EvNZCAAA0JvVrDEMAgOA3ecNBQwCg2IVXNHZDAMhOZ23Bq0MAPZFg5FjhQ0CMtXgdrxVEUO/i1uQaS0SS1U0Gz/CARPZK4ccCLbVEtJ3ZeUN46kSRAigsKosgRTUDMrf0rVRFAoT+5HHZiUWBEh8v5yfARSHX5vrgMfRF6oygOVk+KUYksAiI741fRhduBbW1uJNGnMlGIuOmyEYDfNjqm9D+RoJNx3JhQjNH4yB5z/kSaEcbaVdDuBeeR7GhFirTztJHHUqc9IeCB0ilXMPxKWM9SOcZGjf6XXJIYaDgxHj1pkh5yBj21rLcSEx9z1nG7xFJnlxD8LdrRknGM1TspQZ8SVygtLMnhLFJc8ihoDHl5UmPOsoIfl4bSppkfsUOG1FKwP3ddtJhhUowfZUUR7q6Sj5u3WxstPBKzskUiIfhJEtB/Blq6RlaS6k9UOIxUJBLE03kWj5kxEtXYJ3xTX35S224BG6h3C9MRPPC5OTpY0wVsPMdXuSYTBuccKV1Hc9MkWFmh2lyA031+T/pA084TXL4j+PEYm5NR/s5Drv9ok0ZesjRKb3XTZ+YOkZ0rA1OZJ/kq8iLQk49x93Wui53Tgw5lYxp+qxOp0Pd94Ec4k6RlNR1oqMWT7W5SROLTExPERQO7NavgU8WmRGnzBu2T1v/1dC/outPmb+F4rdFIVB/LyfbJZdVUF/78FHv/IpQG502kxXewFBiRAT4mhX1UHtVBbYBWypRbVXDEeF4YFHIKjRWGZeUUXo1wavfvMlRbMFYywsWAFLH8S6+jhs0Ujmuum1yImlSx1kpCQ9rn1Id2Lll6aLTUiROKL+jiwhTrWHyroyuPlMMfVftFy1zU09crehd+KdTY7PYYnX23VMecMddCboSVCVMObWLaEdULp+Hoq5CfVR9w5QlrUmyVFz0+W4Y3OZUc3G4ih6THFXoRrMW89tRVaIYYNzvUoZVyh5406vnu1U/Eytky3DxVQ7YNT3+zCVWEk6DzD1AW1bLENKfJgiRVv6UxkcwSsVWPTq4Wbyc+lZmJBO49aEwV4DtFyZzymRX4Oid7w/9mVeMscL1KT7QV+9dM3O0TQRYazUAkCFhOVjFQgD0ablvWLspgDji06NYKjSgxtrI2Fg1QUh4EfsOWcEoLevqXENZ8XL4pSU0eFmtj3YPL0GuWcwZqmm96OJZP6AUxOyiF1pPyBn1p4tNWjIdMPlId4JafiR8NxsVt1qeLVsFYtrsWoL8WEN9CCJbozsvlJyKVluMCju5Qy2MW5fmxFNKnMFbPSC26FwD9ltNqOMiNIQrXDBJzpWgMmFcfNtBu0h/lVxbUhLqGt/KXHlzS9JwywBdV1DeBk3+NF1t5JVI4D1qXcSuXS2sZqBddRq1OFeA1F0SYeIGbaAJXqt8TSREBEBe1ttgLVUFdF7MErl4qgapXn9X5xZVSN9er5ZQLjWNE19bvOR5gnBIX3LrXRijjH5fJ7M67+UXs1/xXwlr393nX+23y0VX1R1g9FKfi1alUmCxJ4curE6HYJ3xKDpXIr1gApdZhHY18mDD/G8l1MImYfT7yy6Jc1xheH0/vTXIkWHWXI8sQzrGYQw0s/fTyPthhwDQeoRdMWKpAISZ5bRlYtQA5f8eIptihCDvX1P10GKl6Oo3qDIFY8+i5UVSfzpjwYWva5OPcGMyZ5tGeLOkY/5AQlhW4Nljn2gp9zUsEGTGwvN0QzdEZHizMFIURXlkVuC8ZlmWr2Q2DDbg973jZEOPQ9h1rRhlFHNUTtPYTmXsx/QQhEeDZej5MRVlGbhlYXh+Wr4f7mU9C4/41tMiZgzOsrbMiFdmj4Ff5P9qjWb5sLvu32LCZjidauqX+/ZmhkQF5X26LGfUSiOvjvRhZ4kd7FqycZZn6ySn8R4OzGcTdwhX04gBaNeUyiwI6zVoDTr9N8pla2hIRP5inh+haFrVvfuFZ9VosUqtemfBCmmvTqys4LhAaVpi19cY53Rp8TrNDd8gqmnWRKBoi1TgaQxWyEKuaRRqj2t60xmESWpzBllIIOV/agikNy0077NqCo2FOAHr6GpM8KaGwSUfazBWKPSYd1Nru2syMX9ViGuqBn/93mq+aypkb17LAvNrNT0LNn7DJ2yCDI7DXbRdbNHHOJq6kJJsxvnGQOk0x2w3uPiQIwL9bCNzmzpWITJt609CyaupZm3m45K7FlScbXDOOzWOtNFtDMKKwrEhBm6Pci0zHqo7bpln/N9SSnFuf4H7l+ecpW7fYfp9IQTbbix9vO6U4hBvdpxrKjobRW+Ugwa1CGJ6bz0SJHFFfbBvzBZtzZac5G9/XMiAvMMZcM85fdBVGlBwQ4icROsghHBUqsMVJim5cOmUNJtvc+9wEd0AwSWoI3FWFEExL5JYcWtZkf26to5x49d63jQyw3HcjRkWwv73cVPxn5ty/i1y1PZDoQe/YnKJ9JSJyW6Xcqsx+ut7Ss1yC198c41OAnPNdlvQMOI2c4FUcgS9mmxz0HTHIrbgoXMEUnmr41jWc4amV5Yc7wt0FMj23XF1QXQYenRVztJ1dJ6Y0eqBR6t0Y//CMrEM4XQ8v3N/3U8VdQuvUN/Uo0p1Z22SC2WmgHXACHdO/s+0dfHKFOL9A+p11v5MrX5CIHaMPqBYHlNUdi9OyO7lZ4l2u2F6at/Bv3YVfYyiK9nzdlqcL4t2zyh3cIP7LVQDX3cmMr2cFGKTd7B+7MOZOsh3XJ7nNEBJ/nf5whAhyO0yeLjzVCk6qWd4pTCqs4iTnXhnXkpwNXzSeAH2XMxCGwd5gjN0fxPiPHkxoKgvTA1yeT3IkjufkKZ5TXp3Csc03HlwrIpm/KAReoxXLYA7CUZ6b604YIqLe3plbCN8Njexen9HLBsEheV6Xln3IUXmGnvblzo1689Qe9I9iQLmA4V7Ro0rg99EuntMOPuxC2vwe18Gep7OhSR89ocYRkKnWXz6VM9riQiQfDgqw8arCsR8x/RzuFYN+Xz48ZBmrFAvfTuXGsBrkmN9Cj0hsAZ3mH1MjClcyJTOfbD3mTn9HAN+nHUAiDzkN34DkwCqS91tfuJbQEpPqqJ+2nLQHONU136QjwTkGyoNf7rZgm5ROkJ/KZAjyuXIdn8zdKw8H3usf6DI64XzzOF/4l8QAGsAAADPDAAADgAAADqGEABwAAAALgIAABEAAADpDgAADAAAAAQAAADqDgAA6w4AACAAAACSjRAAXwAAAKYBAABFAAAAko0QAF8AAACrAQAAPQAAAJKNEABfAAAAswEAABoAAACSjRAAXwAAAAACAAATAAAAko0QAF8AAAAJAgAAPgAAAJKNEABfAAAABQIAADMAAACSjRAAXwAAAA8CAAA6AAAAko0QAF8AAABuAgAAGQAAAJKNEABfAAAAcgMAABkAAACSjRAAXwAAAHMDAAAaAAAAko0QAF8AAAB0AwAAGQAAAJKNEABfAAAAdQMAABkAAACSjRAAXwAAAHYDAAAZAAAAko0QAF8AAAB3AwAAGQAAAJKNEABfAAAAeAMAABkAAACSjRAAXwAAAHkDAAAZAAAAko0QAF8AAADUAwAAEQAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAQACAAMABAAFAAYABwAIAAkA//////////////////8KAAsADAANAA4ADwD/////////////////////////////////////////////////////////////////////CgALAAwADQAOAA8A////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAQACAAMABAAFAAYABwAIAAkAD//////////////////6AAsADAANAA4ADwAP////////////////////////////////////////////////////////////////////+gALAAwADQAOAA8AD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////OdRAAagAAAL0BAAAdAAAAMDAwMTAyMDMwNDA1MDYwNzA4MDkxMDExMTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5Nzk4OTlpbmYtaW5mTmFOAAAAAAAAAQBB79GIAQvRKiCamZmZmZmZmZmZmZmZmZkZFa5H4XoUrkfhehSuR+F6FN4kBoGVQ4ts5/up8dJNYhCW1AloImx4eqUsQxzr4jYaq0Nuhhvw+WGE8GjjiLX4FCI2WDhJ88e0No3ttaD3xhBqI43ADlKmh1dIr7ya8tcaiE/XZqVBuJ/fOYww4o55FQemEh9RAS3mspTWJugLLhGkCVHLgWiu1re6vdfZ33wb6jqnojTt8d5flWR54X/9FbvIhej28Cd/GRHqLYGZlxH4DdZAvrQMZcKBdklowiUck3HeM5iQcOoBmyuhhpuEFkPBfingpvMhmxVW556vAxI3NTEPzdeFaSu8idiXstIc+ZBaP9ffNyGJltRGRvUOF/pzSMxF5l/noKtD0tFdchJdhg16PD1mpTSs0rZPyYMdsZ7XlGOXHlFdI0KSDKGcF8FLed2C337afU+bDgq04xJorFti0ZhkKpblXhcQIDkeU/Digafgtu5EUbISQLMtGKkmT85STZJYaqeOqJnCVxNBpH6wt3tQJ6rYfdr10PIeNFBlwF/JplK7E8uuxEDCGJCm6plM1OsOyQ888jaazhOAChHDrVN5sUEZYFC+9rAfZwh0AovcLcFnR7Om/l5aGVKgKTVvsCQ0hp/C6/5LSBTbGe6Q8lkdkJ5/aIll1jkQXymwtB3D+0yXMqeo1SP2GbK6WV2xNZY9rFsfunfpxBQoYuF9J16rl1ZJTPuSh50QDZ1oydjJq/LwDnr4t6WVGj4Xujp6obxbWnIuLZOERBXLRfsuyBrKr66Oi4pCnQMRRQmSsab33LJK5Hiqnfs4GwShQcHrkn31boMtVbEvxxUDtGdniXVkxFicV3cnJmwR0uyl2NuIbW30xiXyCz3gG9sj60YWB76KwzgeKKP9TBZJtlXSEWz+bpxgS1NPMdcRDorvtk8Tl7FgZ0WFGIKLHKWhv/hyD6wnGrlqN60B1hYeTplgwnJWueFgVSwkzkQSlRbCzQMeV/U1zrsTbeM6HaurAQsDGKwqK9gvdopPYhdWiTRvAuC8u1UT88RuDLUSiajtsdDMx5LvHrjUSnruHQe6V45ACtPb8kuTEG/78RcGyN9xANWofPVvD9pY/CcT1gxm6TO7p/q7TLIpjmCmHhHXhIcp/FKVyaOOVAsahRgOrNDSusmoqgeD2HZvrp0T46waHl7c2t2l0cBXsrBiH0+KSEtLsEh+UUGarI7AGxnZodPV1Vlty9rN4ValMxYUe4HcdxF7Vzzi1+er6sIRECrPYFmCXvLGNiamrKoEthm7pYBHaBj1a8VR61ZVnZEUloQABu15KiPRpyLf3X10EFYHNKPhj93RgQzRMZb8UxpFbPboGnPkpzQ9p/RE/Q8Vnlb4U+IoHVNdl1JdapfZEGJXjbkD22HrLvJQlRC/9RroRaTHz0hOvFhb2t2mZZEVIGuDbNnTcWOt4uEXHx5BEc0Rn60ohhyfSAQD82RjmxsL2xi+U2uw5QadNY8d6RUWohVHyw+J8+prSpFy5CCrETe8cXhM27hERqobhG0BRRxfY8HG1hXHAwVVSQO+mp0WGenNa0XeODY3dwdp/q4XEsFBFkaiY8FWWFhyDpex8hzOZ6vRgRwB33kT9XESjigXpexVQc4WNH9h3JDBDtiGEm5HVjV9JCBlAsfnaOSMpB0lOXj3MB2A6gFsuSAd17YXhPos+fOwmbs0I2FNF6z4Ejn3RyhTTlxfVDhoFfKsWh4uLNO5dQt9f0NgU0RbikgYWCPcx/fVMJnPGak2fDttEybS+XKMibSOso8O8fkrFR+4QS6PowcqciimC/THvN0Y+pq+pU85u8GGHtZcBpfkE/b3MAkZwl6c1zDw+tYk1B/4X1oHFGjlSXmNJi/fg3YZYObhBRAgUW7HClK/5c9eFBqFgdEMgNrxBW8OmYTZSxD11GiCFADET9bk4/Sg9RIaK3ftAaqZadkRtxz3s/fbFLzFigGIFO6tdJKwxVz5rxAsCd5opu18SVTqgG+UKLMaJNTkU7hXyjoQVZq/diBcFYN2HUNgeTtic6qu/16AFhGevcjRZvUrnbgQsTLLM1cbf2RtQVLEvH1gDfSOolzfFcy2imfbaf3K5j3D2E59fxHfindyxQ8vq9cvBY7kLv8bgNWSWwRz8oisjGo+Hb9lFmZEQknQKPXTVj1VmEr/6hGjoANCTUGIuVeVu/MQMqsc6eYCaNfNOWF5d/zCQFvvFlRSAiB5cWHnLfnJaM0VWRKGUJ2ZjrVopXxbdnQVVlsd0qZK4T6RIFH9FcX23UR8Fw4fohr/QE2nykQ3krHQyRJKy2n3ZM6uCxFuWFBPtA8eOzzuxVDYizyn8XlzP5AMGMnJ8TfaeQnKhfTHwjJAPRPbQum/9sKoqW+6DJ63Zsge45u6zCvPUyEmlXB+LFKgGIJJlXCJcqkauN0mZfB0sxOddYgaD4R194wvPgjnh4UfF16ge3I2kV8KJpgG7J83Gd/kGZZb+EAZ1YRGBfB/LBRM6kerr8YA4RA3BdGMmSMQR90/RUykZ87nJNW0R4/SGQaxzJ3W6VLYH7fdw59yqBQ4JwpLRe7beRksfmkZwoYQWdipEaLjXymPRjAPjzZxGnoTu6eBHLO6pWvz2NheJxUvqZXsmuMoYlGJj63gS+wQF3Xv4Pc4Dp3oDkyvmqwTG3kqWRqTLdiwU3LWJeJWqRUuVUdID755jdzB3reBRVQRfLsL2n6WjxWUnJeMzwi6G5cv1hT/EaZ3drDf1nJtLhZ5jN5D/6dR+ZHzsnj1vb4Rjq390v4/HMIc7LdaImNkHNiKZEIyM7ABF/BfFbW1thZGooObjsJZAaxZ5t2QxCsSowM5XxcE9s6swqP8GtQSHYOcLUysaV5yvZscykhDQhec44rWiVQY9f3iFggHaZsSxgWrvQ9Uje4va/EM2HTFHQVrIv5ydte+jCLBcEYq0RcEvE7LKMUS/9ZOZ41ruw0ToPl9eHQ7Ucskfth7El98Hk1h/vkpyQ0JtzGt/EF/YxgKgcuUIdTXoMUnJMo0zIITd854VM+5v2dvDG1DIa03H/lxLd2llMwfWXCKz01X+RjH9L19Ud3Wf3rzoT8+rPoTC+4vyeguvv/DuJwy/Xn3H9Yk86AgvzFmNvoWwv3Hkhl4HVwaGswnuF77qwHLbHUUYOR8e64JU5MYybxnovBdEJmglMWwQuse9HSUP2rnLxrh5nYEJwKJ5Vwq3TKIH/MU5+srnYXOoLew7rAooH/CENjf32FvSgFZtEpOdDPM0BqtTObnJdXN4CmiPpCP1nMV8dZRhlF3cU3utMvZcngpEehX6dbovuh7sFSsj4SNdRsgEyHfUzK6/FndiQxqpPcVgELnGEMoyGOuSm5w7umSEWZq2Cc4DQ0GFxFKGhdDHhzrIa3sLKQ9axJ0bnsSnH4WVk5XvfAc/ojbXFj8QeP+ESNKJWK0lJZBX2GNYDYFyxzp1B3oKaqrZ3/nPU340AgXh90XILshVrkyuWTX+XNtEqWVjGYraSPC6sE68sLsex0d3tYeibqCzrs0YlsCV5YXGBjfSwdiNaX89rTiAazeElnzZHnYnIg7lPGHNzYTMR7h9YPHRkpt/NxaBsaRQicYGisDBp9uVzAXr57Rp5tSE5De0TzLfSUaJRgxHKaS6h5A5acwPP4dSLd5WuOEqLsYAFGGwMkxS9PFx66CnVPJE820o81C6RFSCaYX0ciFqB+kkBw+AiHbdAe430A6nlMZUA1KywG0FfcFYBln++RCFKcKCAmbKd74N7N6UvyDNRDX3QyokUIwjlm4KreTOe8ZE0sKIA4CjT7h+e74QmG/FA88CIA+mz1l58dY+psamRDkLA0AZPjIbqUMjpD5kI4a6iOkmen504u3o3FAYdo+FbscUOG6lKk8+YL0mRoV/xArYbObxLp1x47RIMNduzEbiRopFmqVxNILDudosWLBFaF7uhGId9Dbbz4fhyeCZxGbkl0cQL+ALOZjmD4/0NgbSXXkSTPMM71RtkZl/wxHFtRdUG6P1o/Kp14FUcxw0hFTybPjS1cZRNn9bk6t54McqTr2ggl5RwPhlyWliuzPFrr7xGjUYGzPgHmE6m7wPxIq+QcOhzR65Zr10xBLGjMdIpQ5C2yQLlHiKkPaCBVcF7Wpx9W8povagVXP4dMQsBKHD9kiLnHfkJxV5QJTgeYdbAwUT4taTNoW3h3PqJrrF4qjqaWie6OueH6xpSDiIhOpBamial/SfSeXtaKaNp4eVNEggoh/25cfrPdOFZJ+GHengM4GZnx5TCPG2N10mBPxCwHkCnAtj61royeWVFofWtYAUKJZJAy+77UfeBAVGRVFmtmBFB1w/vL3svnZEBR3ansUm0MXwP5bxiguew0Q8kOS7cQF8szKLAoOfSuvGcKcDr7QN1sKb72hccoijBTO4z7Lc/lICIyXtCfVG3AQsJ9keOxbDtqsJVQMVflMGsB/UGDwrz57vbep1hBhChUzZkCA87/LlZcs7t5zGtUQUnDNZlJmrO9YR7BkuZDuGttZpLgOhSMmR2zztvqmixVJrraT2NCCHmwjKV+VhTwRdbCKH/Qanv2sOKj+7giUG/dZ1bIpr7GXvZOGmCUHEBYse3f1uiWOrJfcnhMebKYRE8VYIisJfXq/Lf64yXk9HHZqrU7voP1hzFfLYKGUlxbF7r0LWRr+5wkTCedN3RISOrH8RVtdY6bchA7Yr/vqHMiNMGuvShyFsNA+E/NiIhfU1ya88m7j0Cbay3XC6IEShoykxuoXn7TXKUaJnaecHWtwUAXv3xgqRu4EoReGsBeJ89mdJbPgVGuLnU15nvMSdFL2Ym/rzYd4RS98KJdSHl2oXoK/IgvTxmq/yYYSQhjkuUtozBs8D5+I/zrSDmgTbSl5QHosYBiY2piRg+QMHyQhlDPIVrNGE+ITDjYd1xi2TUMpoHiPONy03KSRSt8Tiq9rqGYnf1pgIWGhgqrLH6K/77nrhTIVTbRNtJu7bxlOmYxhidGOqj2QpPbiYlkUDOHWGqGn2O7K2bYrT4JHEEWbJF6bcid+EfaK37EDDBoESR0YSfWF/g34OxlbadYU0KBKE9Rdnsuk+S8UfIerEE0BEVJTyWPfOlzmufkLrBpxZ9p0D6EcGS+wHvv6b1YVwVJIKtmAsK0lwEsvL/MRETRRDaqONOcVCc0Ssn7rTxvEDXHuPl0fq20KDygyidkVnaSNi2UXGbxXCAwgKNR6EZQ6fBI88vQsWQ3gzNm59xtDlZbb/PTD8OA9s3Dhx18WAxESFpddNloay/UmgTnmEQToHPAk/FaQkN4iCzWPoxzQ7OOMHTDf2aZLgqJdP+kW2iODPbFZf+Hros5OsTJUElw5OC+1wstoedF95E6EUx3jLWC/XTXWU5SnZFByA3YXHIvmZbEqeKl27Lamjs/EEvpE12+1qiYP8ROL132yBx5iat+/KiJSPydDb6xkKAYYToh/mYhO22UfnPKJUCA4E0oNzCh0SsVvZZPqD7QzwB47pAmH9qFqWYQPInP2wpkYlrYHbPjn7q022bT1kTWuE1ZXDODzP35JJPW6IoMifR9FrNZM9v9k1OmQleho6DAZ0Yl4Pfj/g0Puc0TtUyAnFHShk5fGzJzP8Y8D8Q9NHxBSArklpEdhfxyzBeh/rssZDzXHt+nSTcwWXNHs//GiFNmQ0l8hDws9ErDaIzNbghDB51CZaEurYVCzKgaFK2oaZ7lAFLqiIk5AXFVrarwhFVOUAN2U6E4LzUlEvO7J5xBR7QDIh9oXEkip08ZKdgwb2r0AoGxIRttsh9xr1ZGjFa9kzUy9BgVJip/j792nTxGxOuJ6yAoIqEP/OOYvprIb9C7o+zmiOVNp/5Me84QoFl3y7C/7tMd1h/8PsvUDuhEu6kfmkSHZIj//f7Yi01wc8lQGhUGBerVl//+R6KiwFvVDODcBAWLEtzIz24btJhLun/PxAWg2OlmE65GkFQsdixn2J5u5Xvvgabx0UBE8F9Z6Xobi+n4v54djXUB0lhJWkf3W0PeX5XHZOGLNhr0dq9rKeA2TeYTBei3oPdLKF1YVby1xQmHQmsiKhjGoCBMiIhivTmpoTZHaqj1PQHQe6LR58j6IU6TarohkPwBdGIddYSj/bNzprlhtUMyZfROklWgNZa5gqeSNSBp6XC8fg0TtPbe+s7qDcaCuYbDyGDadijEsMvYuNsHmvudZ9RPwYXeCEx295Imb15c/9u4fWk4sNal9yoOhr9/fMviLGRWlVvcg/qGc5/KyTML5bxSqHRL5szEbSrkoj3CblFkQ3ZW2wey1XkP1DeWAxe0oGkreXgFXXuU1xKQdZwSL7RTVsRgBrH63xGkdflLQCL4QIrZam3mXJaEPLzC3s6fJGoFeFUlhrLdN2Vjz+MIfbhWbS0QHgSPG163g9ZM15iQRK6zTPpsFPVlJNFaGIj1uG7yJ3MsVnv3gbcMRBYLK8RVjoeNvERj+syRpQTebO44R0ZvSf7VZY4YHdTUlxcUWHA7jDjORFOnR0pD3UDeeeBYLHD+P2na6dHUNxkAsGPoReMYx5ZAk9+27SKNn4FnDHC0FW7dAHSyLydO1H02uAhckBHxfzX1Wb9QPK+Zwi2gSBm3GmEjJ8H7tshE9ThJ0HZ+9nuAGocCYV8Kn/aQOkBfmyktN0oAAR3mb7MpQpdkSokR5SB3OANiOxa1EgQgpHoLQLW0X2DMTP9FXnZrTIBjOpiQkeUb2qGWnrEoVdk0TfaQ6oI49vXRvpXp3iFbiHmRQleY+MWRdjLf7xQYStRi3pqrry422SnAsltFrDsQTV6SqEhMWJBEaR/DoEhegH9/p7g7cRIPaFGzzU0LfTBmAIb/YfJ0C4kMjKUNofz0UM4Eyev19aE42HFTPuTIxELjOUJCVyUBKvca5SylR6BnGC6emd9QzCDHSx2+H2rkUawnsHsZ2KaCNDtO/0q6UEN/brGSjV0IASRe4/x1+hxoZ4yPqtd8BzaASYJmxMTkVrrUciJFMznBNdeatJ476EOJVlKa1reMar7twSQx9Khvod0OFxFfpe/JijQc9l7sVh/k1BGp5h8mOtQoGZN9iEXHCvAYQj6V15Ih31mxl0RsnNcprpqW39+nTkqvwHUEWH8ShvB4exl/uDw9WjbHNEWXTAmFkY6P/FrOxiUhPfBxR3JtNUBzpMt8ojtQG2ckWDn1JcXPjII+yINh2BRQ7EnwuD4KFBZt+6s1Z8TtTKx3KvqUBnjevy+7XR/Qv3FUXoZiENEv5WAm/rGzDjBarEgBBz/yIAQsBEABB3/yIAQsBFABB7/yIAQsBGQBB/vyIAQsCQB8AQY79iAELAogTAEGe/YgBCwJqGABBrf2IAQsDgIQeAEG9/YgBCwPQEhMAQc39iAELA4TXFwBB3f2IAQsDZc0dAEHs/YgBCwQgX6ASAEH8/YgBCwTodkgXAEGM/ogBCwSilBodAEGb/ogBCwVA5ZwwEgBBq/6IAQsFkB7EvBYAQbv+iAELBTQm9WscAEHK/ogBCwaA4Dd5wxEAQdr+iAELBqDYhVc0FgBB6v6IAQsGyE5nbcEbAEH6/ogBCwY9kWDkWBEAQYn/iAELB0CMtXgdrxUAQZn/iAELB1Dv4tbkGhsAQan/iAEL3EKS1U0Gz/AQAAAAAAAAAACA9krhxwItFQAAAAAAAAAAILSd2XlDeBoAAAAAAAAAAJSQAigsKosQAAAAAAAAAAC5NAMyt/StFAAAAAAAAABA5wGE/uRx2RkAAAAAAAAAiDCBEh8v5ycQAAAAAAAAAKp8Idfm+uAxFAAAAAAAAIDU2+mMoDlZPhkAAAAAAACgyVIksAiI740fAAAAAAAABL6zFm4FtbW4EwAAAAAAAIWtYJzJRiLjphgAAAAAAEDm2HgDfNjqm9AeAAAAAADoj4crgk3HcmFCEwAAAAAA4nNptuIgec/5EhgAAAAAgNrQA2QbaVdDuBceAAAAAJCIYoIesaEWKtPOEgAAAAC0KvsiZh1KnPSHghcAAAAAYfW5q7+kXMPxKWMdAAAAoFw5VMv35hkaN/pdEgAAAMizRym+tWCg4MR49RYAAAC6oJmzLeN4yBj21rIcAABAdARAkPyNS33PWcbvEQAAUJEFULR7cZ5cQ/C3axYAAKT1BmSh2g3GM1TspQYcAICGWYTepKjIW6C0syeEEQAg6G8lFs7SunLIoaAx5RUAKOLLrpuBh2mPOsoIfl4bAFltP00BsfShmWR+xQ4bEUCvSI+gQd1xCsD93XbSYRUQ2xqzCJJUDg0wfZUUR7oa6sjwb0Xb9CgIPm7dbGy0ECT77MsWEjIzis3JFIiH4RTtOeh+nJb+v+xA/Blq6RkaNCRRzyEe//eTqD1Q4jFQEEFtJUOq5f71uBJN5Fo+ZBSSyO7TFJ9+M2dXYJ3xTX0ZtnrqCNpGXgBBbbgEbqHcH7KMkkVI7DqgSETzwuTk6RPeL/dWWqdJyFoVsPMdXuQY1vu07DARXHqxGpxwpXUdH2Ud8ZO+innsrpBhZodpchO/ZO04bu2Xp9r0+T/pA08Y770ox8nofVERcviP48RiHrV2eRx+se7SSkf7OQ67/RJi1Jej3V2qhx0ZesjRKb0Xe8l9DFX1lOlkn5g6RnSsHe2dzidVGf0Rn2Of5KvIixJoRcJxql981oY8x93Wui4XwtYyDpV3G4yoCzmVjGn6HDnG3yi9KpFXSadD3feBHBLItxdzbHV1rRuRlNR1oqMWuqXdj8fS0phitblJE4tMHJSH6rm8w4OfXREUDuzWrxF5KWXoq7RkB7UVmRGnzBsW13N+4tbhPUkiW//V0L+iG2YIj00mrcZt9Zi/heK3RRGAyvLgb1g4yTJ/LyfbJZcVIH0v2Ytuhnv/XvvwUe/8GjSuvWcXBTStXxudNpMV3hDBGa1BXQaBmDdiRAT4mhUVMmAYkvRHoX7FelUFtgFbGh88T9v4zCRvu2xVwxHheBAnCyMSNwDuSurHKjRWGZcU8M2r1kSAqd3keTXBq9+8GbZgKwYr8IkKL2zBWMsLFhDkOLbHNWwszTrH8S6+jhsUHcejOUOHd4AJOa66bXIiGeS4DAgUaZXgS8dZKQkPax+O8weFrGFdbI8c2Lll6aITcvBJphe6dEezI04ov6OLGI9s3I+d6FEZoKxh8q6Mrh7Zw+l5YjHTD+QLfVftFy0TzzRkGLv9xxPdTlyt6F34FwNCfd4p/blYlGKz2GJ19h1CSQ4rOj50t5wdcMddCboSktvRtchNUeUDJUw5tYtoF3dSRuM6oaXeRC6fh6KuQh2K8wvOxIQnC+t8w5QlrUkSbfCOAfZl8c0lXPT5bhjcFois8oFzv21BL3NxuIoekxzVqzcxqJfkiP3nRrMW89sRypaFPZK9Hev8oRhg3O9SFn385sz2LOUlfMoeeNOr5xvOXRBAGjyvl40+Eytky3ARQnUU0CALm/0wDtg1Pf7MFZKSGQTpzQE9vRFOg8w9QBub+4+isSAhRhbLENKfJggRgvozC95oqdfb/ZTGRzBKFSP5AI4Vw5PNUj06uFm8nBq2m8B47Vl8wFNmJBO49aEQo8Lw1mhwm7Dof+0XJnPKFEzzrAyDTMLc4t/one8P/RkPGOzn0W/5ye2LscL1KT4QEx7nYcbLdzzp7l0zc7RNFJjlYPq3vpWLo2o1AJAhYRn+Hvn4ZS57bkzFQgD0abkfX7Obu//8DMVPuymAOOLTEzeggqo/PFC2Iyo0oMbayBhESCOVT0vko6w0QUh4EfseKw02vRGvbubrwCgt6+pcE3WQgyzWWgrgJvFy+KUlNBiTdKS3i/EMmHCtj3YPL0Ee3MjGUvcWCF9mzBmqab3oEhN7eCe1HMr2fz+gFMTsohfXmVZx4qN89F9PyBn1p4sdJiDWhm3mzfibMR0w+Uh3EjCoi+gIYAH3An4kfDcbFRc8kq4iC7jBtIOdLVsFYtocZRut9QYT+VBygvxYQ30IEj9iGLPIVzflDqM7L5ScihbPet7fui2FntKLCju5Qy0cwQzry5Q8E6Njl+bEU0qcEfHP5f65C9iLPD0gtuhcAxbuQ59+qA7OrotMqOMiNIQbdYojTynJQE3XL0nOlaAyERJt7KJz+5AgzXvbQbtIfxVWiKeLUDq1aMBaUhLqGt8aNrVIV3JEcUG4eHNL0nDLEIPiGu2Olc1R5lZQ3gZN/hQkm2Go8vpA5p9s5JVI4D0a9wA9qdec6O/jw65dLaxmEDRBjJMNxOLr3HQatThXgBSBUW/4EHXbJhQSYeIGbaAZ8ZJFmyopSZhMq3xNJEQEEK33FkJ1c1u+H9bbYC1VBRSYtZySUlDyrafLErl4qgYZ/+JDN2fkbpmRflfnFlVIH99tioLATuX/Gq+WUC41jRNXCS2jcKLev+FavOR5gnAYrUv4ywxL1i+acetdGKOMHkwve//n7uVdACezOu/lFxMf+1n/oWpfdcDwXwlr390X53kwf0pFt5Lw7LfLRVfVHTBMfo9Oi7JbFvRSn4tWpRI8310zIi6f8huxJ4curE4XC1c1wKr5Ru9infEoOlciHWdWIbgKXIzVXQKXWYR2NRIBrClmDXPvSvXC/G8l1MIWARe0v9BPq52y8/vLLolzHGCO0HfiEYuiT3h9P701yBH5scQVW9Yti2PWXI8sQzoWd9412/FL+W38CzSz99PIGwqrASl3z7vEfYcA0HqEXRHNFULzVMPqNV2pAISZ5bQVQJsSMCp0ZYO00wDl/x4iGwihC16aaB/SUIQg719T9RBKiY71wEKnBmWl6Oo3qDIVnSvyMnETUUi+zqLlRVJ/GkJb178mrDLtNsGFr2uTjxASMs1vMFd/qIQxZ5tGeLMUl37Ai/wsn9Ll/UBCWFbgGR5PWNcdfKOjr55oKfc1LBDmYi5NJVuMjFvGwvN0QzcUn/t5oO5xr2/yd7MwUhRFGYd6mEhqTpsL71XgvGZZlh+UTF9tAhFBZ7U1DDbg970Tuh+3CENVEcEiQ49D2HWtGKjn5MqTqlVx6xNzVE7T2B7JEM9enIrVJnPsx/QQhEcT+9SCdkPtivCP5/kxFWUZGDqKI1SUqK3sc2F4flq+Hx5kNpa0XInsc+g8C4/41tMS/cO74bOr55AiDM6ytsyIF/20KtqgliE1K4+BX+T/ah0esVqIJP40AXv5sLvu32ISZV1xqq09gsHZN51q6pf7Fr+0DRUZzeIx0IVEBeV9uhz3kCitL8AtH6LTSiOvjvQRNbVymDsw+aaKiB3sWrJxFoJij35KfLdQreokp/EeDhyRnRmPrq1yUqwSdwhX04gR9gTgMhpZD2dX15TKLAjrFTMGmL9gL9NALQ06/TfKZRvgA793nP2DSDxIRP5inh8R2MSulQP9pFpLWtW9+4VnFQ52GntEPE4x3rBKrXpnwRrJifDMquXQ3oquTqys4LgQO6wsgBUfhZYtWmLX1xjnFErXN+DaZib8uPA6zQ3fIBqO5iLMSACYnXPWRKBoi1QQMqAr/1oA/oQQDFbIQq5pFD6I9r5xgD2mFI9retMZhBlOKrQujuDMz9lyBllIIOUfcJow3VgM4CHIB6Q3LTTvEw3BfBRvD1gqugmNhTgB6xhQ8ZvZShPutChM8KaGwSUf0nYByA7MFHGZL1Yo9Jh3E4bUAXoS/1nNf7trMjF/VRioSYIY136wwF+qBn/93moeCW5Rb0ZPbth7KmRvXssCE4vJJQsY44nOGjU9CzZ+wxfuO+8N3lssgmGCDI7DXbQddYW1yGq5W/F80cc4mrqQEtLm4nrFp7It3MX5xkDpNBeGoJvZtlEfOVM3uPiQIwIdVEQBSBKTswOUInObOlYhEmmVAdrWd6AEOetPQsmrqRbD+oGQzJXIRQfm45K7FlQcujxR2p9dnYvEb847NY60EeiL5dAHtYSutQvCisKxIRbj7h7FSeIlGqOOci0zHqobTVUzG26tV/AlmWf831JKEaEqAKLJmG1sb3+B+5fnnBVJNYAK/P6IR0vfYfp9IQQbTiGQhl2ftQyPK3287pTiEKEpNOg0B+PPcnacayo6GxUKNEEiAsnbgw+Ugwa1CGIahsBoVaFdabKJPBIkcUV9EKfwwqoJtQMfrMsWbc2WnBTRrHMVTKLEJpd+XMiAvMMZA0xojW/lOngezzl90FUaEANfwnDLnkkW5kKInETrIBTE9vJMfgbcm59TqsMVJikZdrQv4B0I04KH6JQ0m29zH8nQHawS5cOxVBHdAMElqBP8RCVXV9403qlVFEExL5IYO5buLO0VwlUUa1mR/bq2HuUdFTy0TZm17OLXet40MhNeZRpLIaH/4qfbjRkWwv4Xtv7gnWmJv9uRUvGfm3L+HTGfrALitVcpm9P2Q6EHvxL+xleDWqOt84GI9JSJyW4XvbgtJDEMmXCiqjH663tKHXaTnLaep1+GpQpffHONThJUuENkhpH3507NdlvQMOIWaaZU/ed19aGigFRyBL2aHAHoVP6waTmlZdB0xyK24BECIuo9HcSHDn8EUnmr41gWgqpkjSS1KdKehaZXlhzvG5HqXtg2EVpDgxPI9t1xdRE2pXaOhJUwFGQYenRVztIVg04UsuW6PBl9npjR6oFHGxKxTI/P9MUvDmP/wjKxDBFW3R9zA3K3u9E7v3N/3U8VrNTnT4ROpSrGCq9Q39SjGuvk8LESUafau2ZtkgtlphAmHm1eVyVR0WrACHdO/s8UsGUINq1upYWF8MoU4v0DGo4/xUEsZYdzU9b+TK1+QhBxjzZSdz5pUOiLPqBYHlMUTjPEJhWOg2TiLk7I7uVnGSJAdXCacaT9mrphemrfwR8VSEmGAMeG3qAUfYyiK9kTGprbp8B4KBbJWZwvi3bPGKGA0tHwlrJbO3CD+y1UAx9kkCODVp5PGSUmMr2cFGITfnTsI+yFo1+ur37sw5k6GJ2R5yxnZ4z3mVue5zRASR4CuxB8oMC3OkD5whAhyO0Sw+kUm8iwZUmQt/NUKTqpFzMk2sH6HL9bdKUwqrOIkx2gVii5HHJXuWhnXkpwNXwSSGxy56NOredCAfZczEIbF1oHT+FMopihk4EzdH8T4hyYZNEMcGX/RPwwoKgvTA0Svr0FEMw+P1Y7PciSO5+QFi4tBxR/Ds8rikx6dwrHNBw9fIRsD2lhW9ZvrIpm/KARTJulR1PDOfLLi1ctgDsJFh8CjxkoNMjuvm6tOGCKixtTYfkPmSA9VTdlbCN8NjcRqLn3U79ojCqFfkcsGwSFFRKo9Sjvgi91Jl5Z9yFF5hoLiZl51bE9Cdjalzo1688QTuv/10oejQuO0T2JAuYDFSLm/43dZXCO8UWNK4PfRBrV7794qj8G+bZLOPuxC2sQyuvvFpXPR7ekXgZ6ns6FFL3mq1x6wxnlTfaHGEZCpxk2cOt5LBowr/D5VM9riQgQQ0xmmLcg/NpsOCrDxqsKFFTff37lKLsRiMb0c7hWDRkq1x/eHvMpFir48ZBmrFAfeubTSvM32k0aO5cawGuSExngiB3wxVDh4Ak9IbAGdxgfGOskbPekGVlMjClcyJQeE+8Sl6MaB7C3r/eZOf0cE9iq13xM4QicpZt1AIg85BeOlQ2cnxkLA48CkwCqS90deX2IwQPw5mGZ4VtASk+qEtec6rEErGC6/9ly0BzjVBcNRGXeBdf4qH+QjwTkGyodiEr/qmOGm8lPutmCblE6Eiodv5X8ZwK84yiQI8rlyBZ05C67+wEDqxwzdKw8H3scyU79VD3h4erxn8jrhfPMEXuiPKqMWZpl7se6ZmcwQBYay8vU7+8A/+l5aUCBPNAb8F7/5PWVYD8y7EHI0CViEaw2P15zuzjPPmdS+kSvuhVXBM81UOoGgw4B5zgWWykbtmKhIXJS5BGpYJDj7dj5EGS7CaoOZ11W03h0XClPOBU9KoxU0sD0KwiXkbPzYoYaZprXdIP4eBtl/jpQ2P2TEACBDVKkNldi/r1JZE79uBRA4ZBmTQTt+n0tXP2hPOcZyIwaYLAi1LxunFk+5YUwEPovIXhcKwlsigPwjV6nPBT4eymWM3YLB20EbDE20UsZ9tqze8BTzkiIBce9g8WeH9poUE1Y9IAtdWOcVnI7wxMQg6RgbjHheFJ8Q+xOCrQYMC4wAAAAAAAIAAAABAAAAO0OAADuDgAA7w4AAGEgc3RyaW5nYnl0ZSBhcnJheWJvb2xlYW4gYGDOUiIACQAAANdSIgABAAAAaW50ZWdlciBgAAAA6FIiAAkAAADXUiIAAQAAAGZsb2F0aW5nIHBvaW50IGAEUyIAEAAAANdSIgABAAAAY2hhcmFjdGVyIGAAJFMiAAsAAADXUiIAAQAAAHN0cmluZyAAQFMiAAcAAAB1bml0IHZhbHVlT3B0aW9uIHZhbHVlbmV3dHlwZSBzdHJ1Y3RzZXF1ZW5jZW1hcGVudW11bml0IHZhcmlhbnRuZXd0eXBlIHZhcmlhbnR0dXBsZSB2YXJpYW50c3RydWN0IHZhcmlhbnQAAAABAAAAAAAAAC4wdXNpemUAOoYQAHAAAAAuAgAAEQAAAG1dy9YsUOtjeEGmV3Ebi7kJBmaBAfO5VKIIL0OCV3QyOiAAAAAAAAAEAAAABAAAAPQOAABphxAATAAAAOIKAAAkAAAAq4YQAFAAAAAuAgAAEQAAAPUOAAAMAAAABAAAAPYOAAD3DgAA+A4AAPUOAAAMAAAABAAAAPkOAAD6DgAA+w4AAPwOAAAMAAAABAAAAP0OAAD+DgAA/w4AADl2EABKAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA+PSBzaXplICsgbWluX292ZXJoZWFkAABLjhAAKgAAALEEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogcHNpemUgPD0gc2l6ZSArIG1heF9vdmVyaGVhZAAAS44QACoAAAC3BAAADQAAAEFjY2Vzc0Vycm9yY2Fubm90IGFjY2VzcyBhIFRocmVhZCBMb2NhbCBTdG9yYWdlIHZhbHVlIGR1cmluZyBvciBhZnRlciBkZXN0cnVjdGlvbjogABNVIgBIAAAAZmFpbGVkIHRvIGdlbmVyYXRlIHVuaXF1ZSB0aHJlYWQgSUQ6IGJpdHNwYWNlIGV4aGF1c3RlZABkVSIANwAAALmFEAAdAAAAvAQAAA0AAABXb3VsZEJsb2NrAABONRAAKAAAANMAAAAdAAAAAQAAAAAAAABlbnRpdHkgbm90IGZvdW5kcGVybWlzc2lvbiBkZW5pZWRjb25uZWN0aW9uIHJlZnVzZWRjb25uZWN0aW9uIHJlc2V0aG9zdCB1bnJlYWNoYWJsZW5ldHdvcmsgdW5yZWFjaGFibGVjb25uZWN0aW9uIGFib3J0ZWRub3QgY29ubmVjdGVkYWRkcmVzcyBpbiB1c2VhZGRyZXNzIG5vdCBhdmFpbGFibGVuZXR3b3JrIGRvd25icm9rZW4gcGlwZWVudGl0eSBhbHJlYWR5IGV4aXN0c29wZXJhdGlvbiB3b3VsZCBibG9ja25vdCBhIGRpcmVjdG9yeWlzIGEgZGlyZWN0b3J5ZGlyZWN0b3J5IG5vdCBlbXB0eXJlYWQtb25seSBmaWxlc3lzdGVtIG9yIHN0b3JhZ2UgbWVkaXVtZmlsZXN5c3RlbSBsb29wIG9yIGluZGlyZWN0aW9uIGxpbWl0IChlLmcuIHN5bWxpbmsgbG9vcClzdGFsZSBuZXR3b3JrIGZpbGUgaGFuZGxlaW52YWxpZCBpbnB1dCBwYXJhbWV0ZXJpbnZhbGlkIGRhdGF0aW1lZCBvdXR3cml0ZSB6ZXJvbm8gc3RvcmFnZSBzcGFjZXNlZWsgb24gdW5zZWVrYWJsZSBmaWxlcXVvdGEgZXhjZWVkZWRmaWxlIHRvbyBsYXJnZXJlc291cmNlIGJ1c3lleGVjdXRhYmxlIGZpbGUgYnVzeWRlYWRsb2NrY3Jvc3MtZGV2aWNlIGxpbmsgb3IgcmVuYW1ldG9vIG1hbnkgbGlua3NpbnZhbGlkIGZpbGVuYW1lYXJndW1lbnQgbGlzdCB0b28gbG9uZ29wZXJhdGlvbiBpbnRlcnJ1cHRlZHVuc3VwcG9ydGVkdW5leHBlY3RlZCBlbmQgb2YgZmlsZW91dCBvZiBtZW1vcnlpbiBwcm9ncmVzc290aGVyIGVycm9ydW5jYXRlZ29yaXplZCBlcnJvck9zAAAAAAAEAAAABAAAAAAPAABjb2RlAAAAAAEAAAABAAAAAQ8AAGtpbmT8DgAADAAAAAQAAAACDwAAbWVzc2FnZUtpbmRFcnJvcgAAAAAIAAAABAAAAAMPAAAAAAAABAAAAAQAAAAEDwAAQ3VzdG9tZXJyb3IgKG9zIGVycm9yICkAAQAAAAAAAAA7WSIACwAAAEZZIgABAAAABUkQABsAAAA3BAAAFAAAAAVJEAAbAAAARAQAABQAAABmYWlsZWQgcHJpbnRpbmcgdG8gAIBZIgATAAAA/FMiAAIAAAAFSRAAGwAAAI0EAAAJAAAAc3RkZXJyYSBmb3JtYXR0aW5nIHRyYWl0IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlpbmcgc3RyZWFtIGRpZCBub3S6WSIAVgAAAP5+EAAZAAAAiAIAABEAAABjYW5ub3QgcmVjdXJzaXZlbHkgYWNxdWlyZSBtdXRleChaIgAgAAAABDAQACwAAAATAAAACQAAAGxvY2sgY291bnQgb3ZlcmZsb3cgaW4gcmVlbnRyYW50IG11dGV4AAB0XBAAJgAAACQBAAAtAAAAbWVtb3J5IGFsbG9jYXRpb24gb2YgIGJ5dGVzIGZhaWxlZAAAmFoiABUAAACtWiIADQAAAEGPEAAYAAAAZAEAAAkAAAD8DgAADAAAAAQAAAAFDwAAAAAAAAgAAAAEAAAABg8AAAAAAAAIAAAABAAAAAcPAAAIDwAACQ8AAAoPAAALDwAAEAAAAAQAAAAMDwAADQ8AAA4PAAAPDwAAAAAAAAgAAAAEAAAAEA8AABEPAAASDwAADw8AAE5vdEZvdW5kUGVybWlzc2lvbkRlbmllZENvbm5lY3Rpb25SZWZ1c2VkQ29ubmVjdGlvblJlc2V0SG9zdFVucmVhY2hhYmxlTmV0d29ya1VucmVhY2hhYmxlQ29ubmVjdGlvbkFib3J0ZWROb3RDb25uZWN0ZWRBZGRySW5Vc2VBZGRyTm90QXZhaWxhYmxlTmV0d29ya0Rvd25Ccm9rZW5QaXBlQWxyZWFkeUV4aXN0c05vdEFEaXJlY3RvcnlJc0FEaXJlY3RvcnlEaXJlY3RvcnlOb3RFbXB0eVJlYWRPbmx5RmlsZXN5c3RlbUZpbGVzeXN0ZW1Mb29wU3RhbGVOZXR3b3JrRmlsZUhhbmRsZUludmFsaWRJbnB1dEludmFsaWREYXRhVGltZWRPdXRXcml0ZVplcm9TdG9yYWdlRnVsbE5vdFNlZWthYmxlUXVvdGFFeGNlZWRlZEZpbGVUb29MYXJnZVJlc291cmNlQnVzeUV4ZWN1dGFibGVGaWxlQnVzeURlYWRsb2NrQ3Jvc3Nlc0RldmljZXNUb29NYW55TGlua3NJbnZhbGlkRmlsZW5hbWVBcmd1bWVudExpc3RUb29Mb25nSW50ZXJydXB0ZWRVbnN1cHBvcnRlZFVuZXhwZWN0ZWRFb2ZPdXRPZk1lbW9yeUluUHJvZ3Jlc3NPdGhlclVuY2F0ZWdvcml6ZWRvcGVyYXRpb24gc3VjY2Vzc2Z1bAAAAAAQAAAAEQAAABIAAAAQAAAAEAAAABMAAAASAAAADQAAAA4AAAAVAAAADAAAAAsAAAAVAAAAFQAAAA8AAAAOAAAAEwAAACYAAAA4AAAAGQAAABcAAAAMAAAACQAAAAoAAAAQAAAAFwAAAA4AAAAOAAAADQAAABQAAAAIAAAAGwAAAA4AAAAQAAAAFgAAABUAAAALAAAAFgAAAA0AAAALAAAACwAAABMAAADYVSIA6FUiAPlVIgALViIAG1YiACtWIgA+ViIAUFYiAF1WIgBrViIAgFYiAIxWIgCXViIArFYiAMFWIgDQViIA3lYiAPFWIgAXVyIAT1ciAGhXIgB/VyIAi1ciAJRXIgCeVyIArlciAMVXIgDTVyIA4VciAO5XIgACWCIAClgiACVYIgAzWCIAQ1giAFlYIgBuWCIAeVgiAI9YIgCcWCIAp1giALJYIgAIAAAAEAAAABEAAAAPAAAADwAAABIAAAARAAAADAAAAAkAAAAQAAAACwAAAAoAAAANAAAACgAAAA0AAAAMAAAAEQAAABIAAAAOAAAAFgAAAAwAAAALAAAACAAAAAkAAAALAAAACwAAAA0AAAAMAAAADAAAABIAAAAIAAAADgAAAAwAAAAPAAAAEwAAAAsAAAALAAAADQAAAAsAAAAKAAAABQAAAA0AAABQWyIAWFsiAGhbIgB5WyIAiFsiAJdbIgCpWyIAulsiAMZbIgDPWyIA31siAOpbIgD0WyIAtFUiAAFcIgAOXCIAGlwiACtcIgA9XCIAS1wiAGFcIgBtXCIAeFwiAIBcIgCJXCIAlFwiAJ9cIgCsXCIAuFwiAMRcIgDWXCIA3lwiAOxcIgD4XCIAB10iABpdIgAlXSIAMF0iAD1dIgBIXSIAUl0iAFddIgAoKQAAAAAAAAQAAAAEAAAAQwUAAEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3cwYCIAHAAAAAl4EAAqAAAAJQAAACgAAABFcnJvckxheW91dEVycm9yEw8AAAwAAAAEAAAAFA8AABUPAAAWDwAAY2FwYWNpdHkgb3ZlcmZsb3cAAACMYCIAEQAAANuGEAAgAAAALgIAABEAAAAyYBAAGwAAAOgBAAAXAAAAGBwQACIAAABSAAAAEwAAAJgwEAAeAAAAGgEAAB4AAACYMBAAHgAAABYBAAA3AAAAmDAQAB4AAABVAQAACwBBkMKJAQttAQAAABcPAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlkIG5vdAAAAh8QABgAAACKAgAADgBBiMOJAQuBEgEAAAAYDwAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQBpdhAAGgAAAL0BAAAdAAAABzEQABgAAACfAQAAPwAAAAcxEAAYAAAAoAEAADMAAAAHMRAAGAAAAIMCAAATAAAA0o8QABkAAACDAQAAMgAAACkgc2hvdWxkIGJlIDwgbGVuIChpcyApaW5zZXJ0aW9uIGluZGV4IChpcyApIHNob3VsZCBiZSA8PSBsZW4gKGlzIAAAI2IiABQAAAA3YiIAFwAAACJiIgABAAAAcmVtb3ZhbCBpbmRleCAoaXMgAABoYiIAEgAAAAxiIgAWAAAAImIiAAEAAABgYXRgIHNwbGl0IGluZGV4IChpcyAAAACUYiIAFQAAADdiIgAXAAAAImIiAAEAAAAnAQYBCwEjAQEBRwEEAQEBBAECAgDABAIEAQkCAQH7B88BBQExLQEBAQIBAgEBLAELBgoLAQEjAQoVEAFlCAEKAQQhAQEBHhtbCzoLBAECARgYKwMsAQcCBQkpOjcBAQEECAQBAwcKAg0BDwE6AQQECAEUAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEUAhYGAQE6AQIBAQQIAQcCCwIeAT0BDAEyAQMBNwEBAwUDAQQHAgsCHQE6AQIBBgEFAhQCHAI5AgQECAEUAh0BSAEHAwEBWgECBwsJYgECCQkBAQdJAhsBAQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwFeAQADAAMdAh4CHgJAAgEHCAECCwMBBQEtBTMBQQIiAXYDBAIJAQYD2wICAToBAQcBAQEBAggGCgIBJwEIHzEEMAEBBQEBBQEoCQwCIAQCAgEDOAEBAgMBAQM6CAICQAZSAwENAQcEAQYBAwIyPw0BImUAAQEDCwMNAw0DDQIMBQgCCgECAQIFMQUBCgEBDQEQDTMhAAJxA30BDwFgIC8BAAEkBAMFBQFdBl0DAAEABgABYgQBCgEBHARQAg4iTgEXA2cDAwIIAQMBBAEZAgUBlwIaEg0BJggZCy4DMAECBAICEQEVAkIGAgICAgwBCAEjAQsBMwEBAwICBQIBARsBDgIFAgEBZAUJA3kBAgEEAQABkxEAEAMBDBAiAQIBqQEHAQYBCwEjAQEBLwEtAkMBFQMAAeIBlQUABgEqAQkAAwECBQQoAwQBpQIABCYBGgUBAQACTwRGCzEEewE2DykBAgIKAzEEAgICAQQBCgEyAyQFAQg+AQwCNAkKBAIBXwMCAQECBgECAZ0BAwgVAjkCAwElBwMFRgYNAQEBAQEOAlUIAgMBARcBVAYBAQQCAQLuBAYCAQIbAlUIAgEBAmoBAQECBgEBZQEBAQIEAQUACQECAAIBAQQBkAQCAgQBIAooBgIECAEJBgIDLg0BAgAHAQYBAVIWAgcBAgECegYDAQECAQcBAUgCAwEBAQACCwI0BQUBAQEXAQARBg8ADAMDAAU7BwkEAAMoAgABPxFAAgECAAQBBwECAAIBBAAuAhcAAwkQAgceBJQDADcEMggBDgEWBQEPAAcBEQIHAQIBBQU+IQGgDgABPQQABf4CAAdtCAAFAAEeYIDwAEEaBhovAQoBBAEFFwEfAcMBBATQASQHAh4FYAEqBAICAgQBAQYBAQMBAQEUAVMBiwimASYJKQAmAQEFAQIrAQQAVgIGAAsFKwIDQMBAAAIGAiYCBgIIAQEBAQEBAR8CNQEHAQEDAwEHAwQCBgQNBQMBB3QBDQEQDWUBBAECCgEBAwUGAQEBAQEBBAEGBAECBAUFBAERIAMCADQA5QYEAwIMJgEBBQEALhIehGYDBAE+AgIBAQEIFQUBAwArAQ4GUAAHDAUAGgYaAFBgJAQkdAsBDwEHAQIBCwEPAQcBAgABAgMBKgEJADMNM10WChYAQABAAFUBRwECAgECAgIEAQwBAQEHAUEBBAIIAQcBHAEEAQUBAQMHAQACGQEZAR8BGQEfARkBHwEZAR8BGQEIAAoBFAYGAD4ARAAaBhoGGgAAcAAHAC0BAQECAQIBAUgLMBUQAWUHAgYCAgEEIwEeG1sLOgkJARgEAQkBAwEFKwM7CSoYASA3AQEBBAgEAQMHCgIdAToBAQECBAgBCQEKAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEUAhYGAQE6AQECAQQIAQcDCgIeATsBAQEMAQkBKAEDATcBAQMFAwEEBwILAh0BOgECAgEBAwMBBAcCCwIcAjkCAQECBAgBCQEKAh0BSAEEAQIDAQEIAVEBAgcMCGIBAgkLB0kCGwEBAQEBNw4BBQECBQsBJAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAQADAAQcAx0CHgJAAgEHCAECCwkBLQMBAXUCIgF2AwQCCQEGA9sCAgE6AQEHAQEBAQIIBgoCATAfMQQwCgQDJgkMAiAEAgY4AQECAwEBBTgIAgKYAwENAQcEAQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0BJggZCwEBLAMwAQIEAgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAAAgAB4gGVBQADAQIFBCgDBAGlAgAEQQUAAk8ERgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkBAQgEAgFfAwIEBgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMBARcBUQECBgEBAgEBAgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAEAgIEASAKKAYCBAgBCQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUFAxcBAAEGDwAMAwMABTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFZAGgBwABPQQABP4CAAdtBwBggPAAAgICAgICAgICAwMBAQEAQZvViQELEAEAAAAAAAAAAgIAAAAAAAIAQdrViQELAQIAQYDWiQELAQEAQZvWiQELAQEAQfzWiQELwAquIxAAIQAAAC4AAAAJAAAAwW/yhiMAAACB76yFW0FtLe4EAAABH2q/ZO04bu2Xp9r0+T/pA08YAAE+lS4Jmd8D/TgVDy/kdCPs9c/TCNwExNqwzbwZfzOmAyYf6U4CAAABfC6YW4fTvnKf2diHLxUSxlDea3BuSs8P2JXVbnGyJrBmxq0kNhUdWtNCPA5U/2PAc1XMF+/5ZfIovFX3x9yA3O1u9M7v3F/3UwUAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ID4gMOxOEAAvAAAAdgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAAOxOEAAvAAAAdwAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLnBsdXMgPiAw7E4QAC8AAAB4AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBNQVhfU0lHX0RJR0lUUwAAAOxOEAAvAAAAewAAAAUAAADsThAALwAAAMIAAAAJAAAA7E4QAC8AAAD7AAAADQAAAOxOEAAvAAAAAgEAABIAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9zdWIoZC5taW51cykuaXNfc29tZSgpAOxOEAAvAAAAegAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9hZGQoZC5wbHVzKS5pc19zb21lKCkAAOxOEAAvAAAAeQAAAAUAAADsThAALwAAAAsBAAAFAAAA7E4QAC8AAAAMAQAABQAAAOxOEAAvAAAADQEAAAUAAADsThAALwAAAHIBAAAkAAAA7E4QAC8AAAB3AQAALwAAAOxOEAAvAAAAhAEAABIAAADsThAALwAAAGYBAAANAAAA7E4QAC8AAABMAQAAIgAAAOxOEAAvAAAADwEAAAUAAADsThAALwAAAA4BAAAFAAAA30UaPQPPGubB+8z+AAAAAMrGmscX/nCr3PvU/gAAAABP3Ly+/LF3//b73P4AAAAADNZrQe+RVr4R/OT+AAAAADz8f5CtH9CNLPzs/gAAAACDmlUxKFxR00b89P4AAAAAtcmmrY+scZ1h/Pz+AAAAAMuL7iN3Ipzqe/wE/wAAAABtU3hAkUnMrpb8DP8AAAAAV862XXkSPIKx/BT/AAAAADdW+002lBDCy/wc/wAAAABPmEg4b+qWkOb8JP8AAAAAxzqCJcuFdNcA/Sz/AAAAAPSXv5fNz4agG/00/wAAAADlrCoXmAo07zX9PP8AAAAAjrI1KvtnOLJQ/UT/AAAAADs/xtLf1MiEa/1M/wAAAAC6zdMaJ0TdxYX9VP8AAAAAlsklu86fa5Og/Vz/AAAAAISlYn0kbKzbuv1k/wAAAAD22l8NWGaro9X9bP8AAAAAJvHD3pP44vPv/XT/AAAAALiA/6qorbW1Cv58/wAAAACLSnxsBV9ihyX+hP8AAAAAUzDBNGD/vMk//oz/AAAAAFUmupGMhU6WWv6U/wAAAAC9filwJHf533T+nP8AAAAAj7jluJ+936aP/qT/AAAAAJR9dIjPX6n4qf6s/wAAAADPm6iPk3BEucT+tP8AAAAAaxUPv/jwCIrf/rz/AAAAALYxMWVVJbDN+f7E/wAAAACsf3vQxuI/mRT/zP8AAAAABjsrKsQQXOQu/9T/AAAAANOSc2mZJCSqSf/c/wAAAAAOygCD8rWH/WP/5P8AAAAA6xoRkmQI5bx+/+z/AAAAAMyIUG8JzLyMmf/0/wAAAAAsZRniWBe30bP//P8AQcbhiQELBUCczv8EAEHU4YkBC9kMEKXU6Oj/DAAAAAAAAABirMXreK0DABQAAAAAAIQJlPh4OT+BHgAcAAAAAACzFQfJe86XwDgAJAAAAAAAcFzqe84yfo9TACwAAAAAAGiA6aukONLVbQA0AAAAAABFIpoXJidPn4gAPAAAAAAAJ/vE1DGiY+2iAEQAAAAAAKityIw4Zd6wvQBMAAAAAADbZasajgjHg9gAVAAAAAAAmh1xQvkdXcTyAFwAAAAAAFjnG6YsaU2SDQFkAAAAAADqjXAaZO4B2icBbAAAAAAASnfvmpmjbaJCAXQAAAAAAIVrfbR7eAnyXAF8AAAAAAB3GN15oeRUtHcBhAAAAAAAwsWbW5KGW4aSAYwAAAAAAD1dlsjFUzXIrAGUAAAAAACzoJf6XLQqlccBnAAAAAAA41+gmb2fRt7hAaQAAAAAACWMOds0wpul/AGsAAAAAABcn5ijcprG9hYCtAAAAAAAzr7pVFO/3LcxArwAAAAAAOJBIvIX8/yITALEAAAAAACleFzTm84gzGYCzAAAAAAA31Mhe/NaFpiBAtQAAAAAADowH5fctaDimwLcAAAAAACWs+NcU9HZqLYC5AAAAAAAPESnpNl8m/vQAuwAAAAAABBEpKdMTHa76wL0AAAAAAAanEC2746riwYD/AAAAAAALIRXphDvH9AgAwQBAAAAACkxkenlpBCbOwMMAQAAAACdDJyh+5sQ51UDFAEAAAAAKfQ7YtkgKKxwAxwBAAAAAIXPp3peS0SAiwMkAQAAAAAt3awDQOQhv6UDLAEAAAAAj/9EXi+cZ47AAzQBAAAAAEG4jJydFzPU2gM8AQAAAACpG+O0ktsZnvUDRAEAAAAA2Xffum6/lusPBEwBAAAAAEkUEAAuAAAAfQAAABUAAABJFBAALgAAAKkAAAAFAAAASRQQAC4AAACqAAAABQAAAEkUEAAuAAAAqwAAAAUAAABJFBAALgAAAK4AAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ICsgZC5wbHVzIDwgKDEgPDwgNjEpAAAASRQQAC4AAACvAAAABQAAAEkUEAAuAAAACgEAABEAAABJFBAALgAAAA0BAAAJAAAASRQQAC4AAABAAQAACQAAAEkUEAAuAAAArQAAAAUAAABJFBAALgAAAKwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogIWJ1Zi5pc19lbXB0eSgpAAAASRQQAC4AAADcAQAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA8ICgxIDw8IDYxKUkUEAAuAAAA3QEAAAUAAABJFBAALgAAAN4BAAAFAAAAAQAAAAoAAABkAAAA6AMAABAnAACghgEAQEIPAICWmAAA4fUFAMqaO0kUEAAuAAAAMwIAABEAAABJFBAALgAAADYCAAAJAAAASRQQAC4AAABsAgAACQAAAEkUEAAuAAAA4wIAACYAAABJFBAALgAAAO8CAAAmAAAASRQQAC4AAADMAgAAJgAAALaHEAAjAAAAmQAAAA4AAAC2hxAAIwAAALcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmWzBdID4gYicwJwC2hxAAIwAAALgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogcGFydHMubGVuKCkgPj0gNAAAtocQACMAAAC5AAAABQAAAC4wLgC2hxAAIwAAAAYBAAAFAAAAtocQACMAAAAHAQAABQAAAGVFZS1FLS0rTmFOaW5mMDBlMDBFMGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBtYXhsZW4AALaHEAAjAAAAegIAAA0AAABvdXQgb2YgcmFuZ2UgaW50ZWdyYWwgdHlwZSBjb252ZXJzaW9uIGF0dGVtcHRlZGF0dGVtcHQgdG8gZGl2aWRlIHdpdGggb3ZlcmZsb3cAAGN2IgAfAAAAICgxIDw8ICkBAAAAAAAAAIx2IgAHAAAAk3YiAAEAAAAuLjAxMjM0NTY3ODlhYmNkZWYAAAEAAAAAAAAAUmVmQ2VsbCBhbHJlYWR5IG11dGFibHkgYm9ycm93ZWRSZWZDZWxsIGFscmVhZHkgYm9ycm93ZWQBAAAAAAAAAMR1IgABAAAAxHUiAAEAAADEdSIAAQAAAC07EAAmAAAAFQAAAB0AQbjuiQEL3AwBAAAAIw8AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAfEYQAB8AAAB+BAAAVAAAAFtjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlaW5kZXggb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyAAAKh3IgAgAAAAyHciABIAAAAAAAAABAAAAAQAAAAkDwAAAAAAAAQAAAAEAAAAJQ8AAD09IT1tYXRjaGVzYXNzZXJ0aW9uIGBsZWZ0ICByaWdodGAgZmFpbGVkCiAgbGVmdDogCiByaWdodDogABd4IgAQAAAAJ3giABcAAAA+eCIACQAAACByaWdodGAgZmFpbGVkOiAKICBsZWZ0OiAAAAAXeCIAEAAAAGB4IgAQAAAAcHgiAAkAAAA+eCIACQAAADogAAABAAAAAAAAAJx4IgACAAAAAAAAAAwAAAAEAAAAJg8AACcPAAAoDwAAICAgICB7ICwgIHsKLAp9IH0oKAosCntdYXR0ZW1wdGVkIHRvIGJlZ2luIGEgbmV3IG1hcCBlbnRyeSB3aXRob3V0IGNvbXBsZXRpbmcgdGhlIHByZXZpb3VzIG9uZQAA4HgiAEYAAABTJxAAIAAAANkDAAANAAAAYXR0ZW1wdGVkIHRvIGZvcm1hdCBhIG1hcCB2YWx1ZSBiZWZvcmUgaXRzIGtleQAAQHkiAC4AAABTJxAAIAAAACUEAAANAAAAYXR0ZW1wdGVkIHRvIGZpbmlzaCBhIG1hcCB3aXRoIGEgcGFydGlhbCBlbnRyeQAAiHkiAC4AAABTJxAAIAAAALEEAAANAAAAwVEQABsAAABJAAAAEQAAADB4MDAwMTAyMDMwNDA1MDYwNzA4MDkxMDExMTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5Nzk4OTkAAMFREAAbAAAAwAIAAA0AAADBURAAGwAAAGwDAAAJAAAAwVEQABsAAABtAwAACQAAAMFREAAbAAAAbgMAAAkAAADBURAAGwAAAG8DAAAJAAAAAAAAABQAAAAEAAAAKQ8AACoPAAArDwAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMF95EAAbAAAANQcAAB8AAABfeRAAGwAAADYJAAAJAAAAAAAAAAgAAAAEAAAAHQ8AAGZhbHNldHJ1ZQAAAF95EAAbAAAArwoAACYAAABfeRAAGwAAALgKAAAaAAAAsTMQACAAAACEAAAAHgAAALEzEAAgAAAAoAAAAAkAAAB1c2VyLXByb3ZpZGVkIGNvbXBhcmlzb24gZnVuY3Rpb24gZG9lcyBub3QgY29ycmVjdGx5IGltcGxlbWVudCBhIHRvdGFsIG9yZGVy0HsiAEwAAACaGRAALwAAAFwDAAAFAAAAYXR0ZW1wdGVkIHRvIGluZGV4IHNsaWNlIGZyb20gYWZ0ZXIgbWF4aW11bSB1c2l6ZQAAADR8IgAxAAAAYXR0ZW1wdGVkIHRvIGluZGV4IHNsaWNlIHVwIHRvIG1heGltdW0gdXNpemVwfCIALAAAAGludmFsaWQgdXRmLTggc2VxdWVuY2Ugb2YgIGJ5dGVzIGZyb20gaW5kZXggpHwiABoAAAC+fCIAEgAAAGluY29tcGxldGUgdXRmLTggYnl0ZSBzZXF1ZW5jZSBmcm9tIGluZGV4IAAA4HwiACoAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB1vuJAQszAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwQEBAQEAEGU/IkBC7kRpEoQAB8AAAB0BQAAEgAAAKRKEAAfAAAAdAUAACgAAACkShAAHwAAAGcGAAAVAAAApEoQAB8AAACVBgAAFQAAAKRKEAAfAAAAlgYAABUAAABbLi4uXWJlZ2luIDw9IGVuZCAoIDw9ICkgd2hlbiBzbGljaW5nIGBgaX4iAA4AAAB3fiIABAAAAHt+IgAQAAAAi34iAAEAAABieXRlIGluZGV4ICBpcyBub3QgYSBjaGFyIGJvdW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAArH4iAAsAAAC3fiIAJgAAAN1+IgAIAAAA5X4iAAYAAACLfiIAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAAKx+IgALAAAAFH8iABYAAACLfiIAAQAAACBuEAAlAAAAGgAAADYAAAAgbhAAJQAAAAoAAAArAAAAAAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcCGQ0cBR0IHwEkAWoEawKvA7ECvALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5OT4+enp97i5OWorK6hrEGBwk2PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpOT2RlioyNj7bBw8TGy9ZctrcbHAcICgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9TVJqbLi8nKFWdoKGjpKeorbq8xAYLDBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhKTFBTVVZYWlxeYGNlZmtzeH1/iqSqr7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4FKwVEBA4qgKoGJAQkBCgINAtOAzQMgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAnBAwJNgM6BRoHBAwHUEk3Mw0zBy4ICgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgnCXULQj4qBjsFCgZRBgEFEAMFC1kIAh1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpGRRtICFMNSQcKgLYiDgoGRgodA0dJNwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAWCo+bBYJHmrk6hsaCOQcqBFwGJgpGCigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0GDgQIgYyJBGsFDQMJBxCPYID6BoG0TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA1SsFPiEBcC0DGgQCgUAfEToFAYHQKoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwEZAxWCoCuOB0NLAQJBwIOBoCag9gEEQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJB4D6hAYAAQMFBQYGAgcGCAcJEQocCxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysDLQsuATAEMQIyAacEqQKqBKsI+gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSNjpGSqbG6u8XGycre5OX/AAQREikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJSl5kZYSRm53Jzs8NESk6O0VJV1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYukpr6/xcfP2ttImL3Nxs7PSU5PV1leX4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6ur027vBYXHh9GR05PWFpcXn5/tcXU1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/Tk9aWwcIDxAnL+7vbm83PT9CRZCRU2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEcAxkIAQQvBDQEBwMBBwYHEQpQDxIHVQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcMUARDAy0DAQQRBg8MOgQdJV8gbQRqJYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwEDAQBAzELLAQaBgsDgKwGCgYvMYD0CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUvBTsHAg4YCYC+InQMgNYagRAFgOEJ8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgcChYJTASAigarpAwXBDGhBIHaJgcMBQWAphCB9QcBICoGTASAjQSAvgMbAw8NgICAgICAgICA9O6AgPKAgICAgICAgICAgICAgICAgIAgIaIjJCUmpygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWlvcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9foCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAKJREAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2VydGlvbiBmYWlsZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwZW5jb2RlX3V0Zjg6IG5lZWQgIGJ5dGVzIHRvIGVuY29kZSBVKyBidXQgYnVmZmVyIGhhcyBqdXN0IHKGIgASAAAAhIYiABMAAACXhiIAFQAAAAIAAAAAAAAAAgBB2I2KAQsFIAAA4AIAQeaNigELr2AEAAAAAAABAAAAIAAA6QIAAAAAAAAAAgAAAAAAAAACAAAAIAAA4GF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAAAMhyIAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1haW5kZXIgd2l0aCBhIGRpdmlzb3Igb2YgemVybwAAADCHIgA5AAAAYGFzeW5jIGZuYCByZXN1bWVkIGFmdGVyIGNvbXBsZXRpb24AdIciACMAAABFcnJvcnJhbmdlIHN0YXJ0IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxlbmd0aCAAAAClhyIAEgAAALeHIgAiAAAAcmFuZ2UgZW5kIGluZGV4IOyHIgAQAAAAt4ciACIAAABzbGljZSBpbmRleCBzdGFydHMgYXQgIGJ1dCBlbmRzIGF0IAAMiCIAFgAAACKIIgANAAAAY29weV9mcm9tX3NsaWNlOiBzb3VyY2Ugc2xpY2UgbGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9uIHNsaWNlIGxlbmd0aCAoAAAAQIgiACYAAABmiCIAKwAAAJN2IgABAAAAsAIAAF0ToAISFyAivR9gInwsIDAFMGA0FaDgNfikYDcMpqA3HvvgNwD+4EP9AWFEgAchSAEK4UgkDaFJqw4hSy8YIUw7GaFbMBwhXPMeoV8wNGFjHmHhZPBqYWVAbeFlT2+hZvCvIWedvCFoAM/haGfRYWkA2uFpAOAha67ioWzr5KFu0Oghb/vzoW8BAC5w8AF/cKAQAACgE+AGgBwgCBYfoAi2JMAJACwgE0CmYBMwq+AUAPtgFyH/IBgABKEYgAchGYAM4RugGOEcQG7hHQDUIR6m1mEeAN8BIzDg4SUA6aEmMPHhJorxMicAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvgLQD+IDae/2A2/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFVAM9hVmXRoVYA2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9d0pUQACgAAADsAgAAHQAAAMAAAADgAAAAwQAAAOEAAADCAAAA4gAAAMMAAADjAAAAxAAAAOQAAADFAAAA5QAAAMYAAADmAAAAxwAAAOcAAADIAAAA6AAAAMkAAADpAAAAygAAAOoAAADLAAAA6wAAAMwAAADsAAAAzQAAAO0AAADOAAAA7gAAAM8AAADvAAAA0AAAAPAAAADRAAAA8QAAANIAAADyAAAA0wAAAPMAAADUAAAA9AAAANUAAAD1AAAA1gAAAPYAAADYAAAA+AAAANkAAAD5AAAA2gAAAPoAAADbAAAA+wAAANwAAAD8AAAA3QAAAP0AAADeAAAA/gAAAAABAAABAQAAAgEAAAMBAAAEAQAABQEAAAYBAAAHAQAACAEAAAkBAAAKAQAACwEAAAwBAAANAQAADgEAAA8BAAAQAQAAEQEAABIBAAATAQAAFAEAABUBAAAWAQAAFwEAABgBAAAZAQAAGgEAABsBAAAcAQAAHQEAAB4BAAAfAQAAIAEAACEBAAAiAQAAIwEAACQBAAAlAQAAJgEAACcBAAAoAQAAKQEAACoBAAArAQAALAEAAC0BAAAuAQAALwEAADABAAAAAEAAMgEAADMBAAA0AQAANQEAADYBAAA3AQAAOQEAADoBAAA7AQAAPAEAAD0BAAA+AQAAPwEAAEABAABBAQAAQgEAAEMBAABEAQAARQEAAEYBAABHAQAASAEAAEoBAABLAQAATAEAAE0BAABOAQAATwEAAFABAABRAQAAUgEAAFMBAABUAQAAVQEAAFYBAABXAQAAWAEAAFkBAABaAQAAWwEAAFwBAABdAQAAXgEAAF8BAABgAQAAYQEAAGIBAABjAQAAZAEAAGUBAABmAQAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAbQEAAG4BAABvAQAAcAEAAHEBAAByAQAAcwEAAHQBAAB1AQAAdgEAAHcBAAB4AQAA/wAAAHkBAAB6AQAAewEAAHwBAAB9AQAAfgEAAIEBAABTAgAAggEAAIMBAACEAQAAhQEAAIYBAABUAgAAhwEAAIgBAACJAQAAVgIAAIoBAABXAgAAiwEAAIwBAACOAQAA3QEAAI8BAABZAgAAkAEAAFsCAACRAQAAkgEAAJMBAABgAgAAlAEAAGMCAACWAQAAaQIAAJcBAABoAgAAmAEAAJkBAACcAQAAbwIAAJ0BAAByAgAAnwEAAHUCAACgAQAAoQEAAKIBAACjAQAApAEAAKUBAACmAQAAgAIAAKcBAACoAQAAqQEAAIMCAACsAQAArQEAAK4BAACIAgAArwEAALABAACxAQAAigIAALIBAACLAgAAswEAALQBAAC1AQAAtgEAALcBAACSAgAAuAEAALkBAAC8AQAAvQEAAMQBAADGAQAAxQEAAMYBAADHAQAAyQEAAMgBAADJAQAAygEAAMwBAADLAQAAzAEAAM0BAADOAQAAzwEAANABAADRAQAA0gEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADeAQAA3wEAAOABAADhAQAA4gEAAOMBAADkAQAA5QEAAOYBAADnAQAA6AEAAOkBAADqAQAA6wEAAOwBAADtAQAA7gEAAO8BAADxAQAA8wEAAPIBAADzAQAA9AEAAPUBAAD2AQAAlQEAAPcBAAC/AQAA+AEAAPkBAAD6AQAA+wEAAPwBAAD9AQAA/gEAAP8BAAAAAgAAAQIAAAICAAADAgAABAIAAAUCAAAGAgAABwIAAAgCAAAJAgAACgIAAAsCAAAMAgAADQIAAA4CAAAPAgAAEAIAABECAAASAgAAEwIAABQCAAAVAgAAFgIAABcCAAAYAgAAGQIAABoCAAAbAgAAHAIAAB0CAAAeAgAAHwIAACACAACeAQAAIgIAACMCAAAkAgAAJQIAACYCAAAnAgAAKAIAACkCAAAqAgAAKwIAACwCAAAtAgAALgIAAC8CAAAwAgAAMQIAADICAAAzAgAAOgIAAGUsAAA7AgAAPAIAAD0CAACaAQAAPgIAAGYsAABBAgAAQgIAAEMCAACAAQAARAIAAIkCAABFAgAAjAIAAEYCAABHAgAASAIAAEkCAABKAgAASwIAAEwCAABNAgAATgIAAE8CAABwAwAAcQMAAHIDAABzAwAAdgMAAHcDAAB/AwAA8wMAAIYDAACsAwAAiAMAAK0DAACJAwAArgMAAIoDAACvAwAAjAMAAMwDAACOAwAAzQMAAI8DAADOAwAAkQMAALEDAACSAwAAsgMAAJMDAACzAwAAlAMAALQDAACVAwAAtQMAAJYDAAC2AwAAlwMAALcDAACYAwAAuAMAAJkDAAC5AwAAmgMAALoDAACbAwAAuwMAAJwDAAC8AwAAnQMAAL0DAACeAwAAvgMAAJ8DAAC/AwAAoAMAAMADAAChAwAAwQMAAKMDAADDAwAApAMAAMQDAAClAwAAxQMAAKYDAADGAwAApwMAAMcDAACoAwAAyAMAAKkDAADJAwAAqgMAAMoDAACrAwAAywMAAM8DAADXAwAA2AMAANkDAADaAwAA2wMAANwDAADdAwAA3gMAAN8DAADgAwAA4QMAAOIDAADjAwAA5AMAAOUDAADmAwAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAA7QMAAO4DAADvAwAA9AMAALgDAAD3AwAA+AMAAPkDAADyAwAA+gMAAPsDAAD9AwAAewMAAP4DAAB8AwAA/wMAAH0DAAAABAAAUAQAAAEEAABRBAAAAgQAAFIEAAADBAAAUwQAAAQEAABUBAAABQQAAFUEAAAGBAAAVgQAAAcEAABXBAAACAQAAFgEAAAJBAAAWQQAAAoEAABaBAAACwQAAFsEAAAMBAAAXAQAAA0EAABdBAAADgQAAF4EAAAPBAAAXwQAABAEAAAwBAAAEQQAADEEAAASBAAAMgQAABMEAAAzBAAAFAQAADQEAAAVBAAANQQAABYEAAA2BAAAFwQAADcEAAAYBAAAOAQAABkEAAA5BAAAGgQAADoEAAAbBAAAOwQAABwEAAA8BAAAHQQAAD0EAAAeBAAAPgQAAB8EAAA/BAAAIAQAAEAEAAAhBAAAQQQAACIEAABCBAAAIwQAAEMEAAAkBAAARAQAACUEAABFBAAAJgQAAEYEAAAnBAAARwQAACgEAABIBAAAKQQAAEkEAAAqBAAASgQAACsEAABLBAAALAQAAEwEAAAtBAAATQQAAC4EAABOBAAALwQAAE8EAABgBAAAYQQAAGIEAABjBAAAZAQAAGUEAABmBAAAZwQAAGgEAABpBAAAagQAAGsEAABsBAAAbQQAAG4EAABvBAAAcAQAAHEEAAByBAAAcwQAAHQEAAB1BAAAdgQAAHcEAAB4BAAAeQQAAHoEAAB7BAAAfAQAAH0EAAB+BAAAfwQAAIAEAACBBAAAigQAAIsEAACMBAAAjQQAAI4EAACPBAAAkAQAAJEEAACSBAAAkwQAAJQEAACVBAAAlgQAAJcEAACYBAAAmQQAAJoEAACbBAAAnAQAAJ0EAACeBAAAnwQAAKAEAAChBAAAogQAAKMEAACkBAAApQQAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAK8EAACwBAAAsQQAALIEAACzBAAAtAQAALUEAAC2BAAAtwQAALgEAAC5BAAAugQAALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAM8EAADBBAAAwgQAAMMEAADEBAAAxQQAAMYEAADHBAAAyAQAAMkEAADKBAAAywQAAMwEAADNBAAAzgQAANAEAADRBAAA0gQAANMEAADUBAAA1QQAANYEAADXBAAA2AQAANkEAADaBAAA2wQAANwEAADdBAAA3gQAAN8EAADgBAAA4QQAAOIEAADjBAAA5AQAAOUEAADmBAAA5wQAAOgEAADpBAAA6gQAAOsEAADsBAAA7QQAAO4EAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAD4BAAA+QQAAPoEAAD7BAAA/AQAAP0EAAD+BAAA/wQAAAAFAAABBQAAAgUAAAMFAAAEBQAABQUAAAYFAAAHBQAACAUAAAkFAAAKBQAACwUAAAwFAAANBQAADgUAAA8FAAAQBQAAEQUAABIFAAATBQAAFAUAABUFAAAWBQAAFwUAABgFAAAZBQAAGgUAABsFAAAcBQAAHQUAAB4FAAAfBQAAIAUAACEFAAAiBQAAIwUAACQFAAAlBQAAJgUAACcFAAAoBQAAKQUAACoFAAArBQAALAUAAC0FAAAuBQAALwUAADEFAABhBQAAMgUAAGIFAAAzBQAAYwUAADQFAABkBQAANQUAAGUFAAA2BQAAZgUAADcFAABnBQAAOAUAAGgFAAA5BQAAaQUAADoFAABqBQAAOwUAAGsFAAA8BQAAbAUAAD0FAABtBQAAPgUAAG4FAAA/BQAAbwUAAEAFAABwBQAAQQUAAHEFAABCBQAAcgUAAEMFAABzBQAARAUAAHQFAABFBQAAdQUAAEYFAAB2BQAARwUAAHcFAABIBQAAeAUAAEkFAAB5BQAASgUAAHoFAABLBQAAewUAAEwFAAB8BQAATQUAAH0FAABOBQAAfgUAAE8FAAB/BQAAUAUAAIAFAABRBQAAgQUAAFIFAACCBQAAUwUAAIMFAABUBQAAhAUAAFUFAACFBQAAVgUAAIYFAACgEAAAAC0AAKEQAAABLQAAohAAAAItAACjEAAAAy0AAKQQAAAELQAApRAAAAUtAACmEAAABi0AAKcQAAAHLQAAqBAAAAgtAACpEAAACS0AAKoQAAAKLQAAqxAAAAstAACsEAAADC0AAK0QAAANLQAArhAAAA4tAACvEAAADy0AALAQAAAQLQAAsRAAABEtAACyEAAAEi0AALMQAAATLQAAtBAAABQtAAC1EAAAFS0AALYQAAAWLQAAtxAAABctAAC4EAAAGC0AALkQAAAZLQAAuhAAABotAAC7EAAAGy0AALwQAAAcLQAAvRAAAB0tAAC+EAAAHi0AAL8QAAAfLQAAwBAAACAtAADBEAAAIS0AAMIQAAAiLQAAwxAAACMtAADEEAAAJC0AAMUQAAAlLQAAxxAAACctAADNEAAALS0AAKATAABwqwAAoRMAAHGrAACiEwAAcqsAAKMTAABzqwAApBMAAHSrAAClEwAAdasAAKYTAAB2qwAApxMAAHerAACoEwAAeKsAAKkTAAB5qwAAqhMAAHqrAACrEwAAe6sAAKwTAAB8qwAArRMAAH2rAACuEwAAfqsAAK8TAAB/qwAAsBMAAICrAACxEwAAgasAALITAACCqwAAsxMAAIOrAAC0EwAAhKsAALUTAACFqwAAthMAAIarAAC3EwAAh6sAALgTAACIqwAAuRMAAImrAAC6EwAAiqsAALsTAACLqwAAvBMAAIyrAAC9EwAAjasAAL4TAACOqwAAvxMAAI+rAADAEwAAkKsAAMETAACRqwAAwhMAAJKrAADDEwAAk6sAAMQTAACUqwAAxRMAAJWrAADGEwAAlqsAAMcTAACXqwAAyBMAAJirAADJEwAAmasAAMoTAACaqwAAyxMAAJurAADMEwAAnKsAAM0TAACdqwAAzhMAAJ6rAADPEwAAn6sAANATAACgqwAA0RMAAKGrAADSEwAAoqsAANMTAACjqwAA1BMAAKSrAADVEwAApasAANYTAACmqwAA1xMAAKerAADYEwAAqKsAANkTAACpqwAA2hMAAKqrAADbEwAAq6sAANwTAACsqwAA3RMAAK2rAADeEwAArqsAAN8TAACvqwAA4BMAALCrAADhEwAAsasAAOITAACyqwAA4xMAALOrAADkEwAAtKsAAOUTAAC1qwAA5hMAALarAADnEwAAt6sAAOgTAAC4qwAA6RMAALmrAADqEwAAuqsAAOsTAAC7qwAA7BMAALyrAADtEwAAvasAAO4TAAC+qwAA7xMAAL+rAADwEwAA+BMAAPETAAD5EwAA8hMAAPoTAADzEwAA+xMAAPQTAAD8EwAA9RMAAP0TAACJHAAAihwAAJAcAADQEAAAkRwAANEQAACSHAAA0hAAAJMcAADTEAAAlBwAANQQAACVHAAA1RAAAJYcAADWEAAAlxwAANcQAACYHAAA2BAAAJkcAADZEAAAmhwAANoQAACbHAAA2xAAAJwcAADcEAAAnRwAAN0QAACeHAAA3hAAAJ8cAADfEAAAoBwAAOAQAAChHAAA4RAAAKIcAADiEAAAoxwAAOMQAACkHAAA5BAAAKUcAADlEAAAphwAAOYQAACnHAAA5xAAAKgcAADoEAAAqRwAAOkQAACqHAAA6hAAAKscAADrEAAArBwAAOwQAACtHAAA7RAAAK4cAADuEAAArxwAAO8QAACwHAAA8BAAALEcAADxEAAAshwAAPIQAACzHAAA8xAAALQcAAD0EAAAtRwAAPUQAAC2HAAA9hAAALccAAD3EAAAuBwAAPgQAAC5HAAA+RAAALocAAD6EAAAvRwAAP0QAAC+HAAA/hAAAL8cAAD/EAAAAB4AAAEeAAACHgAAAx4AAAQeAAAFHgAABh4AAAceAAAIHgAACR4AAAoeAAALHgAADB4AAA0eAAAOHgAADx4AABAeAAARHgAAEh4AABMeAAAUHgAAFR4AABYeAAAXHgAAGB4AABkeAAAaHgAAGx4AABweAAAdHgAAHh4AAB8eAAAgHgAAIR4AACIeAAAjHgAAJB4AACUeAAAmHgAAJx4AACgeAAApHgAAKh4AACseAAAsHgAALR4AAC4eAAAvHgAAMB4AADEeAAAyHgAAMx4AADQeAAA1HgAANh4AADceAAA4HgAAOR4AADoeAAA7HgAAPB4AAD0eAAA+HgAAPx4AAEAeAABBHgAAQh4AAEMeAABEHgAARR4AAEYeAABHHgAASB4AAEkeAABKHgAASx4AAEweAABNHgAATh4AAE8eAABQHgAAUR4AAFIeAABTHgAAVB4AAFUeAABWHgAAVx4AAFgeAABZHgAAWh4AAFseAABcHgAAXR4AAF4eAABfHgAAYB4AAGEeAABiHgAAYx4AAGQeAABlHgAAZh4AAGceAABoHgAAaR4AAGoeAABrHgAAbB4AAG0eAABuHgAAbx4AAHAeAABxHgAAch4AAHMeAAB0HgAAdR4AAHYeAAB3HgAAeB4AAHkeAAB6HgAAex4AAHweAAB9HgAAfh4AAH8eAACAHgAAgR4AAIIeAACDHgAAhB4AAIUeAACGHgAAhx4AAIgeAACJHgAAih4AAIseAACMHgAAjR4AAI4eAACPHgAAkB4AAJEeAACSHgAAkx4AAJQeAACVHgAAnh4AAN8AAACgHgAAoR4AAKIeAACjHgAApB4AAKUeAACmHgAApx4AAKgeAACpHgAAqh4AAKseAACsHgAArR4AAK4eAACvHgAAsB4AALEeAACyHgAAsx4AALQeAAC1HgAAth4AALceAAC4HgAAuR4AALoeAAC7HgAAvB4AAL0eAAC+HgAAvx4AAMAeAADBHgAAwh4AAMMeAADEHgAAxR4AAMYeAADHHgAAyB4AAMkeAADKHgAAyx4AAMweAADNHgAAzh4AAM8eAADQHgAA0R4AANIeAADTHgAA1B4AANUeAADWHgAA1x4AANgeAADZHgAA2h4AANseAADcHgAA3R4AAN4eAADfHgAA4B4AAOEeAADiHgAA4x4AAOQeAADlHgAA5h4AAOceAADoHgAA6R4AAOoeAADrHgAA7B4AAO0eAADuHgAA7x4AAPAeAADxHgAA8h4AAPMeAAD0HgAA9R4AAPYeAAD3HgAA+B4AAPkeAAD6HgAA+x4AAPweAAD9HgAA/h4AAP8eAAAIHwAAAB8AAAkfAAABHwAACh8AAAIfAAALHwAAAx8AAAwfAAAEHwAADR8AAAUfAAAOHwAABh8AAA8fAAAHHwAAGB8AABAfAAAZHwAAER8AABofAAASHwAAGx8AABMfAAAcHwAAFB8AAB0fAAAVHwAAKB8AACAfAAApHwAAIR8AACofAAAiHwAAKx8AACMfAAAsHwAAJB8AAC0fAAAlHwAALh8AACYfAAAvHwAAJx8AADgfAAAwHwAAOR8AADEfAAA6HwAAMh8AADsfAAAzHwAAPB8AADQfAAA9HwAANR8AAD4fAAA2HwAAPx8AADcfAABIHwAAQB8AAEkfAABBHwAASh8AAEIfAABLHwAAQx8AAEwfAABEHwAATR8AAEUfAABZHwAAUR8AAFsfAABTHwAAXR8AAFUfAABfHwAAVx8AAGgfAABgHwAAaR8AAGEfAABqHwAAYh8AAGsfAABjHwAAbB8AAGQfAABtHwAAZR8AAG4fAABmHwAAbx8AAGcfAACIHwAAgB8AAIkfAACBHwAAih8AAIIfAACLHwAAgx8AAIwfAACEHwAAjR8AAIUfAACOHwAAhh8AAI8fAACHHwAAmB8AAJAfAACZHwAAkR8AAJofAACSHwAAmx8AAJMfAACcHwAAlB8AAJ0fAACVHwAAnh8AAJYfAACfHwAAlx8AAKgfAACgHwAAqR8AAKEfAACqHwAAoh8AAKsfAACjHwAArB8AAKQfAACtHwAApR8AAK4fAACmHwAArx8AAKcfAAC4HwAAsB8AALkfAACxHwAAuh8AAHAfAAC7HwAAcR8AALwfAACzHwAAyB8AAHIfAADJHwAAcx8AAMofAAB0HwAAyx8AAHUfAADMHwAAwx8AANgfAADQHwAA2R8AANEfAADaHwAAdh8AANsfAAB3HwAA6B8AAOAfAADpHwAA4R8AAOofAAB6HwAA6x8AAHsfAADsHwAA5R8AAPgfAAB4HwAA+R8AAHkfAAD6HwAAfB8AAPsfAAB9HwAA/B8AAPMfAAAmIQAAyQMAACohAABrAAAAKyEAAOUAAAAyIQAATiEAAGAhAABwIQAAYSEAAHEhAABiIQAAciEAAGMhAABzIQAAZCEAAHQhAABlIQAAdSEAAGYhAAB2IQAAZyEAAHchAABoIQAAeCEAAGkhAAB5IQAAaiEAAHohAABrIQAAeyEAAGwhAAB8IQAAbSEAAH0hAABuIQAAfiEAAG8hAAB/IQAAgyEAAIQhAAC2JAAA0CQAALckAADRJAAAuCQAANIkAAC5JAAA0yQAALokAADUJAAAuyQAANUkAAC8JAAA1iQAAL0kAADXJAAAviQAANgkAAC/JAAA2SQAAMAkAADaJAAAwSQAANskAADCJAAA3CQAAMMkAADdJAAAxCQAAN4kAADFJAAA3yQAAMYkAADgJAAAxyQAAOEkAADIJAAA4iQAAMkkAADjJAAAyiQAAOQkAADLJAAA5SQAAMwkAADmJAAAzSQAAOckAADOJAAA6CQAAM8kAADpJAAAACwAADAsAAABLAAAMSwAAAIsAAAyLAAAAywAADMsAAAELAAANCwAAAUsAAA1LAAABiwAADYsAAAHLAAANywAAAgsAAA4LAAACSwAADksAAAKLAAAOiwAAAssAAA7LAAADCwAADwsAAANLAAAPSwAAA4sAAA+LAAADywAAD8sAAAQLAAAQCwAABEsAABBLAAAEiwAAEIsAAATLAAAQywAABQsAABELAAAFSwAAEUsAAAWLAAARiwAABcsAABHLAAAGCwAAEgsAAAZLAAASSwAABosAABKLAAAGywAAEssAAAcLAAATCwAAB0sAABNLAAAHiwAAE4sAAAfLAAATywAACAsAABQLAAAISwAAFEsAAAiLAAAUiwAACMsAABTLAAAJCwAAFQsAAAlLAAAVSwAACYsAABWLAAAJywAAFcsAAAoLAAAWCwAACksAABZLAAAKiwAAFosAAArLAAAWywAACwsAABcLAAALSwAAF0sAAAuLAAAXiwAAC8sAABfLAAAYCwAAGEsAABiLAAAawIAAGMsAAB9HQAAZCwAAH0CAABnLAAAaCwAAGksAABqLAAAaywAAGwsAABtLAAAUQIAAG4sAABxAgAAbywAAFACAABwLAAAUgIAAHIsAABzLAAAdSwAAHYsAAB+LAAAPwIAAH8sAABAAgAAgCwAAIEsAACCLAAAgywAAIQsAACFLAAAhiwAAIcsAACILAAAiSwAAIosAACLLAAAjCwAAI0sAACOLAAAjywAAJAsAACRLAAAkiwAAJMsAACULAAAlSwAAJYsAACXLAAAmCwAAJksAACaLAAAmywAAJwsAACdLAAAniwAAJ8sAACgLAAAoSwAAKIsAACjLAAApCwAAKUsAACmLAAApywAAKgsAACpLAAAqiwAAKssAACsLAAArSwAAK4sAACvLAAAsCwAALEsAACyLAAAsywAALQsAAC1LAAAtiwAALcsAAC4LAAAuSwAALosAAC7LAAAvCwAAL0sAAC+LAAAvywAAMAsAADBLAAAwiwAAMMsAADELAAAxSwAAMYsAADHLAAAyCwAAMksAADKLAAAyywAAMwsAADNLAAAziwAAM8sAADQLAAA0SwAANIsAADTLAAA1CwAANUsAADWLAAA1ywAANgsAADZLAAA2iwAANssAADcLAAA3SwAAN4sAADfLAAA4CwAAOEsAADiLAAA4ywAAOssAADsLAAA7SwAAO4sAADyLAAA8ywAAECmAABBpgAAQqYAAEOmAABEpgAARaYAAEamAABHpgAASKYAAEmmAABKpgAAS6YAAEymAABNpgAATqYAAE+mAABQpgAAUaYAAFKmAABTpgAAVKYAAFWmAABWpgAAV6YAAFimAABZpgAAWqYAAFumAABcpgAAXaYAAF6mAABfpgAAYKYAAGGmAABipgAAY6YAAGSmAABlpgAAZqYAAGemAABopgAAaaYAAGqmAABrpgAAbKYAAG2mAACApgAAgaYAAIKmAACDpgAAhKYAAIWmAACGpgAAh6YAAIimAACJpgAAiqYAAIumAACMpgAAjaYAAI6mAACPpgAAkKYAAJGmAACSpgAAk6YAAJSmAACVpgAAlqYAAJemAACYpgAAmaYAAJqmAACbpgAAIqcAACOnAAAkpwAAJacAACanAAAnpwAAKKcAACmnAAAqpwAAK6cAACynAAAtpwAALqcAAC+nAAAypwAAM6cAADSnAAA1pwAANqcAADenAAA4pwAAOacAADqnAAA7pwAAPKcAAD2nAAA+pwAAP6cAAECnAABBpwAAQqcAAEOnAABEpwAARacAAEanAABHpwAASKcAAEmnAABKpwAAS6cAAEynAABNpwAATqcAAE+nAABQpwAAUacAAFKnAABTpwAAVKcAAFWnAABWpwAAV6cAAFinAABZpwAAWqcAAFunAABcpwAAXacAAF6nAABfpwAAYKcAAGGnAABipwAAY6cAAGSnAABlpwAAZqcAAGenAABopwAAaacAAGqnAABrpwAAbKcAAG2nAABupwAAb6cAAHmnAAB6pwAAe6cAAHynAAB9pwAAeR0AAH6nAAB/pwAAgKcAAIGnAACCpwAAg6cAAISnAACFpwAAhqcAAIenAACLpwAAjKcAAI2nAABlAgAAkKcAAJGnAACSpwAAk6cAAJanAACXpwAAmKcAAJmnAACapwAAm6cAAJynAACdpwAAnqcAAJ+nAACgpwAAoacAAKKnAACjpwAApKcAAKWnAACmpwAAp6cAAKinAACppwAAqqcAAGYCAACrpwAAXAIAAKynAABhAgAAracAAGwCAACupwAAagIAALCnAACeAgAAsacAAIcCAACypwAAnQIAALOnAABTqwAAtKcAALWnAAC2pwAAt6cAALinAAC5pwAAuqcAALunAAC8pwAAvacAAL6nAAC/pwAAwKcAAMGnAADCpwAAw6cAAMSnAACUpwAAxacAAIICAADGpwAAjh0AAMenAADIpwAAyacAAMqnAADLpwAAZAIAAMynAADNpwAA0KcAANGnAADWpwAA16cAANinAADZpwAA2qcAANunAADcpwAAmwEAAPWnAAD2pwAAIf8AAEH/AAAi/wAAQv8AACP/AABD/wAAJP8AAET/AAAl/wAARf8AACb/AABG/wAAJ/8AAEf/AAAo/wAASP8AACn/AABJ/wAAKv8AAEr/AAAr/wAAS/8AACz/AABM/wAALf8AAE3/AAAu/wAATv8AAC//AABP/wAAMP8AAFD/AAAx/wAAUf8AADL/AABS/wAAM/8AAFP/AAA0/wAAVP8AADX/AABV/wAANv8AAFb/AAA3/wAAV/8AADj/AABY/wAAOf8AAFn/AAA6/wAAWv8AAAAEAQAoBAEAAQQBACkEAQACBAEAKgQBAAMEAQArBAEABAQBACwEAQAFBAEALQQBAAYEAQAuBAEABwQBAC8EAQAIBAEAMAQBAAkEAQAxBAEACgQBADIEAQALBAEAMwQBAAwEAQA0BAEADQQBADUEAQAOBAEANgQBAA8EAQA3BAEAEAQBADgEAQARBAEAOQQBABIEAQA6BAEAEwQBADsEAQAUBAEAPAQBABUEAQA9BAEAFgQBAD4EAQAXBAEAPwQBABgEAQBABAEAGQQBAEEEAQAaBAEAQgQBABsEAQBDBAEAHAQBAEQEAQAdBAEARQQBAB4EAQBGBAEAHwQBAEcEAQAgBAEASAQBACEEAQBJBAEAIgQBAEoEAQAjBAEASwQBACQEAQBMBAEAJQQBAE0EAQAmBAEATgQBACcEAQBPBAEAsAQBANgEAQCxBAEA2QQBALIEAQDaBAEAswQBANsEAQC0BAEA3AQBALUEAQDdBAEAtgQBAN4EAQC3BAEA3wQBALgEAQDgBAEAuQQBAOEEAQC6BAEA4gQBALsEAQDjBAEAvAQBAOQEAQC9BAEA5QQBAL4EAQDmBAEAvwQBAOcEAQDABAEA6AQBAMEEAQDpBAEAwgQBAOoEAQDDBAEA6wQBAMQEAQDsBAEAxQQBAO0EAQDGBAEA7gQBAMcEAQDvBAEAyAQBAPAEAQDJBAEA8QQBAMoEAQDyBAEAywQBAPMEAQDMBAEA9AQBAM0EAQD1BAEAzgQBAPYEAQDPBAEA9wQBANAEAQD4BAEA0QQBAPkEAQDSBAEA+gQBANMEAQD7BAEAcAUBAJcFAQBxBQEAmAUBAHIFAQCZBQEAcwUBAJoFAQB0BQEAmwUBAHUFAQCcBQEAdgUBAJ0FAQB3BQEAngUBAHgFAQCfBQEAeQUBAKAFAQB6BQEAoQUBAHwFAQCjBQEAfQUBAKQFAQB+BQEApQUBAH8FAQCmBQEAgAUBAKcFAQCBBQEAqAUBAIIFAQCpBQEAgwUBAKoFAQCEBQEAqwUBAIUFAQCsBQEAhgUBAK0FAQCHBQEArgUBAIgFAQCvBQEAiQUBALAFAQCKBQEAsQUBAIwFAQCzBQEAjQUBALQFAQCOBQEAtQUBAI8FAQC2BQEAkAUBALcFAQCRBQEAuAUBAJIFAQC5BQEAlAUBALsFAQCVBQEAvAUBAIAMAQDADAEAgQwBAMEMAQCCDAEAwgwBAIMMAQDDDAEAhAwBAMQMAQCFDAEAxQwBAIYMAQDGDAEAhwwBAMcMAQCIDAEAyAwBAIkMAQDJDAEAigwBAMoMAQCLDAEAywwBAIwMAQDMDAEAjQwBAM0MAQCODAEAzgwBAI8MAQDPDAEAkAwBANAMAQCRDAEA0QwBAJIMAQDSDAEAkwwBANMMAQCUDAEA1AwBAJUMAQDVDAEAlgwBANYMAQCXDAEA1wwBAJgMAQDYDAEAmQwBANkMAQCaDAEA2gwBAJsMAQDbDAEAnAwBANwMAQCdDAEA3QwBAJ4MAQDeDAEAnwwBAN8MAQCgDAEA4AwBAKEMAQDhDAEAogwBAOIMAQCjDAEA4wwBAKQMAQDkDAEApQwBAOUMAQCmDAEA5gwBAKcMAQDnDAEAqAwBAOgMAQCpDAEA6QwBAKoMAQDqDAEAqwwBAOsMAQCsDAEA7AwBAK0MAQDtDAEArgwBAO4MAQCvDAEA7wwBALAMAQDwDAEAsQwBAPEMAQCyDAEA8gwBAFANAQBwDQEAUQ0BAHENAQBSDQEAcg0BAFMNAQBzDQEAVA0BAHQNAQBVDQEAdQ0BAFYNAQB2DQEAVw0BAHcNAQBYDQEAeA0BAFkNAQB5DQEAWg0BAHoNAQBbDQEAew0BAFwNAQB8DQEAXQ0BAH0NAQBeDQEAfg0BAF8NAQB/DQEAYA0BAIANAQBhDQEAgQ0BAGINAQCCDQEAYw0BAIMNAQBkDQEAhA0BAGUNAQCFDQEAoBgBAMAYAQChGAEAwRgBAKIYAQDCGAEAoxgBAMMYAQCkGAEAxBgBAKUYAQDFGAEAphgBAMYYAQCnGAEAxxgBAKgYAQDIGAEAqRgBAMkYAQCqGAEAyhgBAKsYAQDLGAEArBgBAMwYAQCtGAEAzRgBAK4YAQDOGAEArxgBAM8YAQCwGAEA0BgBALEYAQDRGAEAshgBANIYAQCzGAEA0xgBALQYAQDUGAEAtRgBANUYAQC2GAEA1hgBALcYAQDXGAEAuBgBANgYAQC5GAEA2RgBALoYAQDaGAEAuxgBANsYAQC8GAEA3BgBAL0YAQDdGAEAvhgBAN4YAQC/GAEA3xgBAEBuAQBgbgEAQW4BAGFuAQBCbgEAYm4BAENuAQBjbgEARG4BAGRuAQBFbgEAZW4BAEZuAQBmbgEAR24BAGduAQBIbgEAaG4BAEluAQBpbgEASm4BAGpuAQBLbgEAa24BAExuAQBsbgEATW4BAG1uAQBObgEAbm4BAE9uAQBvbgEAUG4BAHBuAQBRbgEAcW4BAFJuAQBybgEAU24BAHNuAQBUbgEAdG4BAFVuAQB1bgEAVm4BAHZuAQBXbgEAd24BAFhuAQB4bgEAWW4BAHluAQBabgEAem4BAFtuAQB7bgEAXG4BAHxuAQBdbgEAfW4BAF5uAQB+bgEAX24BAH9uAQAA6QEAIukBAAHpAQAj6QEAAukBACTpAQAD6QEAJekBAATpAQAm6QEABekBACfpAQAG6QEAKOkBAAfpAQAp6QEACOkBACrpAQAJ6QEAK+kBAArpAQAs6QEAC+kBAC3pAQAM6QEALukBAA3pAQAv6QEADukBADDpAQAP6QEAMekBABDpAQAy6QEAEekBADPpAQAS6QEANOkBABPpAQA16QEAFOkBADbpAQAV6QEAN+kBABbpAQA46QEAF+kBADnpAQAY6QEAOukBABnpAQA76QEAGukBADzpAQAb6QEAPekBABzpAQA+6QEAHekBAD/pAQAe6QEAQOkBAB/pAQBB6QEAIOkBAELpAQAh6QEAQ+kBAAx4IgAOeCIAEHgiAAIAAAACAAAABwBBnu6KAQsa8D8AAAAAAAD4PwAAAAAAAAAABtDPQ+v9TD4AQcPuigELBUADuOI/AEHc7ooBCwYCAAAAyw4AQezuigELMtQOAAACAAAAAAAAANUOAAACAAAAAAAAANYOAAACAAAAAAAAANcOAAACAAAAAAAAANgOAEGo74oBCwEEAIYBCXByb2R1Y2VycwIIbGFuZ3VhZ2UBBFJ1c3QADHByb2Nlc3NlZC1ieQQFcnVzdGMdMS45MC4wICgxMTU5ZTc4YzQgMjAyNS0wOS0xNCkOSG9tZWJyZXcgY2xhbmcGMjAuMS4zBndhbHJ1cwYwLjIzLjMMd2FzbS1iaW5kZ2VuBzAuMi4xMDQAaw90YXJnZXRfZmVhdHVyZXMGKw9tdXRhYmxlLWdsb2JhbHMrE25vbnRyYXBwaW5nLWZwdG9pbnQrC2J1bGstbWVtb3J5KwhzaWduLWV4dCsPcmVmZXJlbmNlLXR5cGVzKwptdWx0aXZhbHVl");var O4="0.7.1",M4=!1;function eW(){M4||(P4(I4),M4=!0,typeof window<"u"&&(window.parquet_wasm={readParquet:Uq,readSchema:Vq,ParquetFile:y7,version:O4}))}async function lo(){return eW(),{readParquet:Uq,readSchema:Vq,ParquetFile:y7,version:O4}}var dr=async t=>{try{let A=await lo(),j=new Uint8Array(t),r=A.readParquet(j).intoIPCStream();return wn(r)}catch(A){let j=Zj(A,{messages:{unexpected:"Failed to convert ArrayBuffer to Arrow Table"},logUnexpected:!0,throwOnAuth:!1});throw new Error(j.message)}};function T4(t){let A=t.schema.fields.map(j=>({name:j.name,data:t.getChild(j.name).toArray()}));return Array.from({length:t.numRows},(j,e)=>Object.fromEntries(A.map(r=>[r.name,r.data[e]])))}function Qq(t){let A=t.schema.fields.map(r=>r.name);(A[0]==="row"||A[0]==="index")&&(A=A.slice(1));let j=A.map(r=>t.getChild(r).toArray()),e=[];for(let r=0;ri[r]);e.push(Array.from(n))}return e}var Wq=async(t,A="default",j={})=>{let e=`${t}/cgm/${A}`,[r,n,i,o,l,c]=await Promise.all([fetch(`${e}/meta.json`,j),fetch(`${e}/mat.parquet`,j),fetch(`${e}/row_nodes.parquet`,j),fetch(`${e}/col_nodes.parquet`,j),fetch(`${e}/row_linkage.parquet`,j),fetch(`${e}/col_linkage.parquet`,j)]);if(!r.ok)throw new Error(`Failed to load meta.json: ${r.status}`);let B=await r.json(),[h,d,k,g,E]=await Promise.all([n.arrayBuffer(),i.arrayBuffer(),o.arrayBuffer(),l.arrayBuffer(),c.arrayBuffer()]),m=await dr(h),y=await dr(d),b=await dr(k),v=await dr(g),_=await dr(E),w={...B};return w.mat=Qq(m),w.row_nodes=T4(y),w.col_nodes=T4(b),w.linkage={row:Qq(v),col:Qq(_)},w};function S4(t){let A=t.schema.fields.map(j=>({name:j.name,data:t.getChild(j.name).toArray()}));return Array.from({length:t.numRows},(j,e)=>Object.fromEntries(A.map(r=>[r.name,r.data[e]])))}function Yq(t){let A=t.schema.fields.map(r=>r.name);(A[0]==="row"||A[0]==="index")&&(A=A.slice(1));let j=A.map(r=>t.getChild(r).toArray()),e=[];for(let r=0;ri[r]);e.push(Array.from(n))}return e}var R4=async(t,A,j,e,r,n)=>{let i=await dr(A.buffer),o=await dr(j.buffer),l=await dr(e.buffer),c=await dr(r.buffer),B=await dr(n.buffer),h={...t};return h.mat=Yq(i),h.row_nodes=S4(o),h.col_nodes=S4(l),h.linkage={row:Yq(c),col:Yq(B)},h};var jB=async(t,A="__index_level_0__")=>{let j=await dr(t.buffer),e=j.schema.fields.map(l=>l.name);if(e.length<2)return{result:{},attr:[]};if(!e.includes(A))throw new Error(`Key field "${A}" not found in Parquet fields: ${e.join(", ")}`);let r=j.getChild(A).toArray(),n=e.filter(l=>l!==A),i=n.map(l=>j.getChild(l).toArray()),o={};for(let l=0;lB[l])}return{result:o,attr:n}};var Zq=new TextEncoder,rW={appstream2:"appstream",cloudhsmv2:"cloudhsm",email:"ses",marketplace:"aws-marketplace",mobile:"AWSMobileHubService",pinpoint:"mobiletargeting",queue:"sqs","git-codecommit":"codecommit","mturk-requester-sandbox":"mturk-requester","personalize-runtime":"personalize"},nW=new Set(["authorization","content-type","content-length","user-agent","presigned-expires","expect","x-amzn-trace-id","range","connection"]),Yo=class{constructor({accessKeyId:A,secretAccessKey:j,sessionToken:e,service:r,region:n,cache:i,retries:o,initRetryMs:l}){if(A==null)throw new TypeError("accessKeyId is a required option");if(j==null)throw new TypeError("secretAccessKey is a required option");this.accessKeyId=A,this.secretAccessKey=j,this.sessionToken=e,this.service=r,this.region=n,this.cache=i||new Map,this.retries=o??10,this.initRetryMs=l||50}async sign(A,j){if(A instanceof Request){let{method:n,url:i,headers:o,body:l}=A;j=Object.assign({method:n,url:i,headers:o},j),j.body==null&&o.has("Content-Type")&&(j.body=l!=null&&o.has("X-Amz-Content-Sha256")?l:await A.clone().arrayBuffer()),A=i}let e=new AG(Object.assign({url:A.toString()},j,this,j&&j.aws)),r=Object.assign({},j,await e.sign());delete r.aws;try{return new Request(r.url.toString(),r)}catch(n){if(n instanceof TypeError)return new Request(r.url.toString(),Object.assign({duplex:"half"},r));throw n}}async fetch(A,j){for(let e=0;e<=this.retries;e++){let r=fetch(await this.sign(A,j));if(e===this.retries)return r;let n=await r;if(n.status<500&&n.status!==429)return n;await new Promise(i=>setTimeout(i,Math.random()*this.initRetryMs*Math.pow(2,e)))}throw new Error("An unknown error occurred, ensure retries is not negative")}},AG=class{constructor({method:A,url:j,headers:e,body:r,accessKeyId:n,secretAccessKey:i,sessionToken:o,service:l,region:c,cache:B,datetime:h,signQuery:d,appendSessionToken:k,allHeaders:g,singleEncode:E}){if(j==null)throw new TypeError("url is a required option");if(n==null)throw new TypeError("accessKeyId is a required option");if(i==null)throw new TypeError("secretAccessKey is a required option");this.method=A||(r?"POST":"GET"),this.url=new URL(j),this.headers=new Headers(e||{}),this.body=r,this.accessKeyId=n,this.secretAccessKey=i,this.sessionToken=o;let m,y;(!l||!c)&&([m,y]=iW(this.url,this.headers)),this.service=l||m||"",this.region=c||y||"us-east-1",this.cache=B||new Map,this.datetime=h||new Date().toISOString().replace(/[:-]|\.\d{3}/g,""),this.signQuery=d,this.appendSessionToken=k||this.service==="iotdevicegateway",this.headers.delete("Host"),this.service==="s3"&&!this.signQuery&&!this.headers.has("X-Amz-Content-Sha256")&&this.headers.set("X-Amz-Content-Sha256","UNSIGNED-PAYLOAD");let b=this.signQuery?this.url.searchParams:this.headers;if(b.set("X-Amz-Date",this.datetime),this.sessionToken&&!this.appendSessionToken&&b.set("X-Amz-Security-Token",this.sessionToken),this.signableHeaders=["host",...this.headers.keys()].filter(_=>g||!nW.has(_)).sort(),this.signedHeaders=this.signableHeaders.join(";"),this.canonicalHeaders=this.signableHeaders.map(_=>_+":"+(_==="host"?this.url.host:(this.headers.get(_)||"").replace(/\s+/g," "))).join(` -`),this.credentialString=[this.datetime.slice(0,8),this.region,this.service,"aws4_request"].join("/"),this.signQuery&&(this.service==="s3"&&!b.has("X-Amz-Expires")&&b.set("X-Amz-Expires","86400"),b.set("X-Amz-Algorithm","AWS4-HMAC-SHA256"),b.set("X-Amz-Credential",this.accessKeyId+"/"+this.credentialString),b.set("X-Amz-SignedHeaders",this.signedHeaders)),this.service==="s3")try{this.encodedPath=decodeURIComponent(this.url.pathname.replace(/\+/g," "))}catch{this.encodedPath=this.url.pathname}else this.encodedPath=this.url.pathname.replace(/\/+/g,"/");E||(this.encodedPath=encodeURIComponent(this.encodedPath).replace(/%2F/g,"/")),this.encodedPath=H4(this.encodedPath);let v=new Set;this.encodedSearch=[...this.url.searchParams].filter(([_])=>{if(!_)return!1;if(this.service==="s3"){if(v.has(_))return!1;v.add(_)}return!0}).map(_=>_.map(w=>H4(encodeURIComponent(w)))).sort(([_,w],[x,S])=>_x?1:wS?1:0).map(_=>_.join("=")).join("&")}async sign(){return this.signQuery?(this.url.searchParams.set("X-Amz-Signature",await this.signature()),this.sessionToken&&this.appendSessionToken&&this.url.searchParams.set("X-Amz-Security-Token",this.sessionToken)):this.headers.set("Authorization",await this.authHeader()),{method:this.method,url:this.url,headers:this.headers,body:this.body}}async authHeader(){return["AWS4-HMAC-SHA256 Credential="+this.accessKeyId+"/"+this.credentialString,"SignedHeaders="+this.signedHeaders,"Signature="+await this.signature()].join(", ")}async signature(){let A=this.datetime.slice(0,8),j=[this.secretAccessKey,A,this.region,this.service].join(),e=this.cache.get(j);if(!e){let r=await _d("AWS4"+this.secretAccessKey,A),n=await _d(r,this.region),i=await _d(n,this.service);e=await _d(i,"aws4_request"),this.cache.set(j,e)}return Jq(await _d(e,await this.stringToSign()))}async stringToSign(){return["AWS4-HMAC-SHA256",this.datetime,this.credentialString,Jq(await L4(await this.canonicalString()))].join(` +]`}concat(...A){let j=this.schema,e=this.data.concat(A.flatMap(({data:r})=>r));return new t(j,e.map(r=>new Be(j,r)))}slice(A,j){let e=this.schema;[A,j]=Rh({length:this.numRows},A,j);let r=um(this.data,this._offsets,A,j);return new t(e,r.map(n=>new Be(e,n)))}getChild(A){return this.getChildAt(this.schema.fields.findIndex(j=>j.name===A))}getChildAt(A){if(A>-1&&Ae.children[A]);if(j.length===0){let{type:e}=this.schema.fields[A],r=ht({type:e,length:0,nullCount:0});j.push(r._changeLengthAndBackfillNullBitmap(this.numRows))}return new Dt(j)}return null}setChild(A,j){var e;return this.setChildAt((e=this.schema.fields)===null||e===void 0?void 0:e.findIndex(r=>r.name===A),j)}setChildAt(A,j){let e=this.schema,r=[...this.batches];if(A>-1&&Athis.getChildAt(c));[n[A],o[A]]=[i,j],[e,r]=Cm(e,o)}return new t(e,r)}select(A){let j=this.schema.fields.reduce((e,r,n)=>e.set(r.name,n),new Map);return this.selectAt(A.map(e=>j.get(e)).filter(e=>e>-1))}selectAt(A){let j=this.schema.selectAt(A),e=this.batches.map(r=>r.selectAt(A));return new t(j,e)}assign(A){let j=this.schema.fields,[e,r]=A.schema.fields.reduce((o,l,c)=>{let[B,h]=o,d=j.findIndex(k=>k.name===l.name);return~d?h[d]=c:B.push(c),o},[[],[]]),n=this.schema.assign(A.schema),i=[...j.map((o,l)=>[l,r[l]]).map(([o,l])=>l===void 0?this.getChildAt(o):A.getChildAt(l)),...e.map(o=>A.getChildAt(o))].filter(Boolean);return new t(...Cm(n,i))}};WM=Symbol.toStringTag;m6[WM]=(t=>(t.schema=null,t.batches=[],t._offsets=new Uint32Array([0]),t._nullCount=-1,t[Symbol.isConcatSpreadable]=!0,t.isValid=Iu(Hh),t.get=Iu(He.getVisitFn(Z.Struct)),t.set=Bm(Or.getVisitFn(Z.Struct)),t.indexOf=fm(Kl.getVisitFn(Z.Struct)),"Table"))(m6.prototype);var JM,Be=class t{constructor(...A){switch(A.length){case 2:{if([this.schema]=A,!(this.schema instanceof aj))throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");if([,this.data=ht({nullCount:0,type:new Oj(this.schema.fields),children:this.schema.fields.map(j=>ht({type:j.type,nullCount:0}))})]=A,!(this.data instanceof rj))throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");[this.schema,this.data]=YM(this.schema,this.data.children);break}case 1:{let[j]=A,{fields:e,children:r,length:n}=Object.keys(j).reduce((l,c,B)=>(l.children[B]=j[c],l.length=Math.max(l.length,j[c].length),l.fields[B]=St.new({name:c,type:j[c].type,nullable:!0}),l),{length:0,fields:new Array,children:new Array}),i=new aj(e),o=ht({type:new Oj(e),length:n,children:r,nullCount:0});[this.schema,this.data]=YM(i,o.children,n);break}default:throw new TypeError("RecordBatch constructor expects an Object mapping names to child Data, or a [Schema, Data] pair.")}}get dictionaries(){return this._dictionaries||(this._dictionaries=ZM(this.schema.fields,this.data.children))}get numCols(){return this.schema.fields.length}get numRows(){return this.data.length}get nullCount(){return this.data.nullCount}isValid(A){return this.data.getValid(A)}get(A){return He.visit(this.data,A)}set(A,j){return Or.visit(this.data,A,j)}indexOf(A,j){return Kl.visit(this.data,A,j)}[Symbol.iterator](){return Mu.visit(new Dt([this.data]))}toArray(){return[...this]}concat(...A){return new m6(this.schema,[this,...A])}slice(A,j){let[e]=new Dt([this.data]).slice(A,j).data;return new t(this.schema,e)}getChild(A){var j;return this.getChildAt((j=this.schema.fields)===null||j===void 0?void 0:j.findIndex(e=>e.name===A))}getChildAt(A){return A>-1&&Ar.name===A),j)}setChildAt(A,j){let e=this.schema,r=this.data;if(A>-1&&Ao.name===n);~i&&(r[i]=this.data.children[i])}return new t(j,ht({type:e,length:this.numRows,children:r}))}selectAt(A){let j=this.schema.selectAt(A),e=A.map(n=>this.data.children[n]).filter(Boolean),r=ht({type:new Oj(j.fields),length:this.numRows,children:e});return new t(j,r)}};JM=Symbol.toStringTag;Be[JM]=(t=>(t._nullCount=-1,t[Symbol.isConcatSpreadable]=!0,"RecordBatch"))(Be.prototype);function YM(t,A,j=A.reduce((e,r)=>Math.max(e,r.length),0)){var e;let r=[...t.fields],n=[...A],i=(j+63&-64)>>3;for(let[o,l]of t.fields.entries()){let c=A[o];(!c||c.length!==j)&&(r[o]=l.clone({nullable:!0}),n[o]=(e=c?._changeLengthAndBackfillNullBitmap(j))!==null&&e!==void 0?e:ht({type:l.type,length:j,nullCount:j,nullBitmap:new Uint8Array(i)}))}return[t.assign(r),ht({type:new Oj(r),length:j,children:n})]}function ZM(t,A,j=new Map){var e,r;if(((e=t?.length)!==null&&e!==void 0?e:0)>0&&t?.length===A?.length)for(let n=-1,i=t.length;++nht({type:r.type})),e=ht({type:new Oj(A.fields),nullCount:0,children:j});super(A,e)}};var io=class t{constructor(){this.bb=null,this.bb_pos=0}__init(A,j){return this.bb_pos=A,this.bb=j,this}static getRootAsMessage(A,j){return(j||new t).__init(A.readInt32(A.position())+A.position(),A)}static getSizePrefixedRootAsMessage(A,j){return A.setPosition(A.position()+4),(j||new t).__init(A.readInt32(A.position())+A.position(),A)}version(){let A=this.bb.__offset(this.bb_pos,4);return A?this.bb.readInt16(this.bb_pos+A):hj.V1}headerType(){let A=this.bb.__offset(this.bb_pos,6);return A?this.bb.readUint8(this.bb_pos+A):Lt.NONE}header(A){let j=this.bb.__offset(this.bb_pos,8);return j?this.bb.__union(A,this.bb_pos+j):null}bodyLength(){let A=this.bb.__offset(this.bb_pos,10);return A?this.bb.readInt64(this.bb_pos+A):BigInt("0")}customMetadata(A,j){let e=this.bb.__offset(this.bb_pos,12);return e?(j||new Je).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos+e)+A*4),this.bb):null}customMetadataLength(){let A=this.bb.__offset(this.bb_pos,12);return A?this.bb.__vector_len(this.bb_pos+A):0}static startMessage(A){A.startObject(5)}static addVersion(A,j){A.addFieldInt16(0,j,hj.V1)}static addHeaderType(A,j){A.addFieldInt8(1,j,Lt.NONE)}static addHeader(A,j){A.addFieldOffset(2,j,0)}static addBodyLength(A,j){A.addFieldInt64(3,j,BigInt("0"))}static addCustomMetadata(A,j){A.addFieldOffset(4,j,0)}static createCustomMetadataVector(A,j){A.startVector(4,j.length,4);for(let e=j.length-1;e>=0;e--)A.addOffset(j[e]);return A.endVector()}static startCustomMetadataVector(A,j){A.startVector(4,j,4)}static endMessage(A){return A.endObject()}static finishMessageBuffer(A,j){A.finish(j)}static finishSizePrefixedMessageBuffer(A,j){A.finish(j,void 0,!0)}static createMessage(A,j,e,r,n,i){return t.startMessage(A),t.addVersion(A,j),t.addHeaderType(A,e),t.addHeader(A,r),t.addBodyLength(A,n),t.addCustomMetadata(A,i),t.endMessage(A)}};var Oq=class extends WA{visit(A,j){return A==null||j==null?void 0:super.visit(A,j)}visitNull(A,j){return Ph.startNull(j),Ph.endNull(j)}visitInt(A,j){return Vi.startInt(j),Vi.addBitWidth(j,A.bitWidth),Vi.addIsSigned(j,A.isSigned),Vi.endInt(j)}visitFloat(A,j){return p7.startFloatingPoint(j),p7.addPrecision(j,A.precision),p7.endFloatingPoint(j)}visitBinary(A,j){return qh.startBinary(j),qh.endBinary(j)}visitLargeBinary(A,j){return Gh.startLargeBinary(j),Gh.endLargeBinary(j)}visitBool(A,j){return bh.startBool(j),bh.endBool(j)}visitUtf8(A,j){return Mh.startUtf8(j),Mh.endUtf8(j)}visitLargeUtf8(A,j){return wh.startLargeUtf8(j),wh.endLargeUtf8(j)}visitDecimal(A,j){return Ko.startDecimal(j),Ko.addScale(j,A.scale),Ko.addPrecision(j,A.precision),Ko.addBitWidth(j,A.bitWidth),Ko.endDecimal(j)}visitDate(A,j){return B7.startDate(j),B7.addUnit(j,A.unit),B7.endDate(j)}visitTime(A,j){return Ys.startTime(j),Ys.addUnit(j,A.unit),Ys.addBitWidth(j,A.bitWidth),Ys.endTime(j)}visitTimestamp(A,j){let e=A.timezone&&j.createString(A.timezone)||void 0;return Js.startTimestamp(j),Js.addUnit(j,A.unit),e!==void 0&&Js.addTimezone(j,e),Js.endTimestamp(j)}visitInterval(A,j){return k7.startInterval(j),k7.addUnit(j,A.unit),k7.endInterval(j)}visitDuration(A,j){return f7.startDuration(j),f7.addUnit(j,A.unit),f7.endDuration(j)}visitList(A,j){return Fh.startList(j),Fh.endList(j)}visitStruct(A,j){return Ih.startStruct_(j),Ih.endStruct_(j)}visitUnion(A,j){Qi.startTypeIdsVector(j,A.typeIds.length);let e=Qi.createTypeIdsVector(j,A.typeIds);return Qi.startUnion(j),Qi.addMode(j,A.mode),Qi.addTypeIds(j,e),Qi.endUnion(j)}visitDictionary(A,j){let e=this.visit(A.indices,j);return No.startDictionaryEncoding(j),No.addId(j,BigInt(A.id)),No.addIsOrdered(j,A.isOrdered),e!==void 0&&No.addIndexType(j,e),No.endDictionaryEncoding(j)}visitFixedSizeBinary(A,j){return h7.startFixedSizeBinary(j),h7.addByteWidth(j,A.byteWidth),h7.endFixedSizeBinary(j)}visitFixedSizeList(A,j){return d7.startFixedSizeList(j),d7.addListSize(j,A.listSize),d7.endFixedSizeList(j)}visitMap(A,j){return g7.startMap(j),g7.addKeysSorted(j,A.keysSorted),g7.endMap(j)}},Hm=new Oq;function e4(t,A=new Map){return new aj(uQ(t,A),Dm(t.metadata),A)}function Tq(t){return new Tr(t.count,n4(t.columns),i4(t.columns))}function r4(t){return new $6(Tq(t.data),t.id,t.isDelta)}function uQ(t,A){return(t.fields||[]).filter(Boolean).map(j=>St.fromJSON(j,A))}function A4(t,A){return(t.children||[]).filter(Boolean).map(j=>St.fromJSON(j,A))}function n4(t){return(t||[]).reduce((A,j)=>[...A,new ki(j.count,BQ(j.VALIDITY)),...n4(j.children)],[])}function i4(t,A=[]){for(let j=-1,e=(t||[]).length;++jA+ +(j===0),0)}function o4(t,A){let j,e,r,n,i,o;return!A||!(n=t.dictionary)?(i=j4(t,A4(t,A)),r=new St(t.name,i,t.nullable,Dm(t.metadata))):A.has(j=n.id)?(e=(e=n.indexType)?t4(e):new Xo,o=new z6(A.get(j),e,j,n.isOrdered),r=new St(t.name,o,t.nullable,Dm(t.metadata))):(e=(e=n.indexType)?t4(e):new Xo,A.set(j,i=j4(t,A4(t,A))),o=new z6(i,e,j,n.isOrdered),r=new St(t.name,o,t.nullable,Dm(t.metadata))),r||null}function Dm(t=[]){return new Map(t.map(({key:A,value:j})=>[A,j]))}function t4(t){return new qe(t.isSigned,t.bitWidth)}function j4(t,A){let j=t.type.name;switch(j){case"NONE":return new bn;case"null":return new bn;case"binary":return new Zs;case"largebinary":return new Aa;case"utf8":return new ta;case"largeutf8":return new ja;case"bool":return new ea;case"list":return new Ao((A||[])[0]);case"struct":return new Oj(A||[]);case"struct_":return new Oj(A||[])}switch(j){case"int":{let e=t.type;return new qe(e.isSigned,e.bitWidth)}case"floatingpoint":{let e=t.type;return new k6(mj[e.precision])}case"decimal":{let e=t.type;return new ra(e.scale,e.precision,e.bitWidth)}case"date":{let e=t.type;return new na(Ce[e.unit])}case"time":{let e=t.type;return new Zi(XA[e.unit],e.bitWidth)}case"timestamp":{let e=t.type;return new ia(XA[e.unit],e.timezone)}case"interval":{let e=t.type;return new oa(hr[e.unit])}case"duration":{let e=t.type;return new sa(XA[e.unit])}case"union":{let e=t.type,[r,...n]=(e.mode+"").toLowerCase(),i=r.toUpperCase()+n.join("");return new to(Gj[i],e.typeIds||[],A||[])}case"fixedsizebinary":{let e=t.type;return new aa(e.byteWidth)}case"fixedsizelist":{let e=t.type;return new jo(e.listSize,(A||[])[0])}case"map":{let e=t.type;return new eo((A||[])[0],e.keysSorted)}}throw new Error(`Unrecognized type: "${j}"`)}var fQ=Cl,hQ=K6,x6=class t{static fromJSON(A,j){let e=new t(0,hj.V5,j);return e._createHeader=dQ(A,j),e}static decode(A){A=new hQ(it(A));let j=io.getRootAsMessage(A),e=j.bodyLength(),r=j.version(),n=j.headerType(),i=new t(e,r,n);return i._createHeader=pQ(j,n),i}static encode(A){let j=new fQ,e=-1;return A.isSchema()?e=aj.encode(j,A.header()):A.isRecordBatch()?e=Tr.encode(j,A.header()):A.isDictionaryBatch()&&(e=$6.encode(j,A.header())),io.startMessage(j),io.addVersion(j,hj.V5),io.addHeader(j,e),io.addHeaderType(j,A.headerType),io.addBodyLength(j,BigInt(A.bodyLength)),io.finishMessageBuffer(j,io.endMessage(j)),j.asUint8Array()}static from(A,j=0){if(A instanceof aj)return new t(0,hj.V5,Lt.Schema,A);if(A instanceof Tr)return new t(j,hj.V5,Lt.RecordBatch,A);if(A instanceof $6)return new t(j,hj.V5,Lt.DictionaryBatch,A);throw new Error(`Unrecognized Message header: ${A}`)}get type(){return this.headerType}get version(){return this._version}get headerType(){return this._headerType}get bodyLength(){return this._bodyLength}header(){return this._createHeader()}isSchema(){return this.headerType===Lt.Schema}isRecordBatch(){return this.headerType===Lt.RecordBatch}isDictionaryBatch(){return this.headerType===Lt.DictionaryBatch}constructor(A,j,e,r){this._version=j,this._headerType=e,this.body=new Uint8Array(0),r&&(this._createHeader=()=>r),this._bodyLength=ee(A)}},Tr=class{get nodes(){return this._nodes}get length(){return this._length}get buffers(){return this._buffers}constructor(A,j,e){this._nodes=j,this._buffers=e,this._length=ee(A)}},$6=class{get id(){return this._id}get data(){return this._data}get isDelta(){return this._isDelta}get length(){return this.data.length}get nodes(){return this.data.nodes}get buffers(){return this.data.buffers}constructor(A,j,e=!1){this._data=A,this._isDelta=e,this._id=ee(j)}},E6=class{constructor(A,j){this.offset=ee(A),this.length=ee(j)}},ki=class{constructor(A,j){this.length=ee(A),this.nullCount=ee(j)}};function dQ(t,A){return()=>{switch(A){case Lt.Schema:return aj.fromJSON(t);case Lt.RecordBatch:return Tr.fromJSON(t);case Lt.DictionaryBatch:return $6.fromJSON(t)}throw new Error(`Unrecognized Message type: { name: ${Lt[A]}, type: ${A} }`)}}function pQ(t,A){return()=>{switch(A){case Lt.Schema:return aj.decode(t.header(new p6),new Map,t.version());case Lt.RecordBatch:return Tr.decode(t.header(new X6),t.version());case Lt.DictionaryBatch:return $6.decode(t.header(new Ws),t.version())}throw new Error(`Unrecognized Message type: { name: ${Lt[A]}, type: ${A} }`)}}St.encode=bQ;St.decode=_Q;St.fromJSON=o4;aj.encode=qQ;aj.decode=kQ;aj.fromJSON=e4;Tr.encode=GQ;Tr.decode=gQ;Tr.fromJSON=Tq;$6.encode=wQ;$6.decode=mQ;$6.fromJSON=r4;ki.encode=FQ;ki.decode=$Q;E6.encode=PQ;E6.decode=EQ;function kQ(t,A=new Map,j=hj.V5){let e=vQ(t,A);return new aj(e,Nm(t),A,j)}function gQ(t,A=hj.V5){if(t.compression()!==null)throw new Error("Record batch compression not implemented");return new Tr(t.length(),xQ(t),yQ(t,A))}function mQ(t,A=hj.V5){return new $6(Tr.decode(t.data(),A),t.id(),t.isDelta())}function EQ(t){return new E6(t.offset(),t.length())}function $Q(t){return new ki(t.length(),t.nullCount())}function xQ(t){let A=[];for(let j,e=-1,r=-1,n=t.nodesLength();++eSt.encode(t,n));p6.startFieldsVector(t,j.length);let e=p6.createFieldsVector(t,j),r=A.metadata&&A.metadata.size>0?p6.createCustomMetadataVector(t,[...A.metadata].map(([n,i])=>{let o=t.createString(`${n}`),l=t.createString(`${i}`);return Je.startKeyValue(t),Je.addKey(t,o),Je.addValue(t,l),Je.endKeyValue(t)})):-1;return p6.startSchema(t),p6.addFields(t,e),p6.addEndianness(t,IQ?u7.Little:u7.Big),r!==-1&&p6.addCustomMetadata(t,r),p6.endSchema(t)}function bQ(t,A){let j=-1,e=-1,r=-1,n=A.type,i=A.typeId;HA.isDictionary(n)?(i=n.dictionary.typeId,r=Hm.visit(n,t),e=Hm.visit(n.dictionary,t)):e=Hm.visit(n,t);let o=(n.children||[]).map(B=>St.encode(t,B)),l=jn.createChildrenVector(t,o),c=A.metadata&&A.metadata.size>0?jn.createCustomMetadataVector(t,[...A.metadata].map(([B,h])=>{let d=t.createString(`${B}`),k=t.createString(`${h}`);return Je.startKeyValue(t),Je.addKey(t,d),Je.addValue(t,k),Je.endKeyValue(t)})):-1;return A.name&&(j=t.createString(A.name)),jn.startField(t),jn.addType(t,e),jn.addTypeType(t,i),jn.addChildren(t,l),jn.addNullable(t,!!A.nullable),j!==-1&&jn.addName(t,j),r!==-1&&jn.addDictionary(t,r),c!==-1&&jn.addCustomMetadata(t,c),jn.endField(t)}function GQ(t,A){let j=A.nodes||[],e=A.buffers||[];X6.startNodesVector(t,j.length);for(let i of j.slice().reverse())ki.encode(t,i);let r=t.endVector();X6.startBuffersVector(t,e.length);for(let i of e.slice().reverse())E6.encode(t,i);let n=t.endVector();return X6.startRecordBatch(t),X6.addLength(t,BigInt(A.length)),X6.addNodes(t,r),X6.addBuffers(t,n),X6.endRecordBatch(t)}function wQ(t,A){let j=Tr.encode(t,A.data);return Ws.startDictionaryBatch(t),Ws.addId(t,BigInt(A.id)),Ws.addIsDelta(t,A.isDelta),Ws.addData(t,j),Ws.endDictionaryBatch(t)}function FQ(t,A){return vu.createFieldNode(t,BigInt(A.length),BigInt(A.nullCount))}function PQ(t,A){return yu.createBuffer(t,BigInt(A.offset),BigInt(A.length))}var IQ=(()=>{let t=new ArrayBuffer(2);return new DataView(t).setInt16(0,256,!0),new Int16Array(t)[0]===256})();var Rq=t=>`Expected ${Lt[t]} Message in stream, but was null or length 0.`,Lq=t=>`Header pointer of flatbuffer-encoded ${Lt[t]} Message is null or length 0.`,c4=(t,A)=>`Expected to read ${t} metadata bytes, but only read ${A}.`,u4=(t,A)=>`Expected to read ${t} bytes for message body, but only read ${A}.`,Du=class{constructor(A){this.source=A instanceof Vo?A:new Vo(A)}[Symbol.iterator](){return this}next(){let A;return(A=this.readMetadataLength()).done?Tj:A.value===-1&&(A=this.readMetadataLength()).done?Tj:(A=this.readMetadata(A.value)).done?Tj:A}throw(A){return this.source.throw(A)}return(A){return this.source.return(A)}readMessage(A){let j;if((j=this.next()).done)return null;if(A!=null&&j.value.headerType!==A)throw new Error(Rq(A));return j.value}readMessageBody(A){if(A<=0)return new Uint8Array(0);let j=it(this.source.read(A));if(j.byteLength[...r,...n.VALIDITY&&[n.VALIDITY]||[],...n.TYPE_ID&&[n.TYPE_ID]||[],...n.OFFSET&&[n.OFFSET]||[],...n.DATA&&[n.DATA]||[],...j(n.children)],[])}}readMessage(A){let j;if((j=this.next()).done)return null;if(A!=null&&j.value.headerType!==A)throw new Error(Rq(A));return j.value}readSchema(){let A=Lt.Schema,j=this.readMessage(A),e=j?.header();if(!j||!e)throw new Error(Lq(A));return e}},Km=4,Sq="ARROW1",Nu=new Uint8Array(Sq.length);for(let t=0;tthis):this}readRecordBatch(A){return this._impl.isFile()?this._impl.readRecordBatch(A):null}[Symbol.iterator](){return this._impl[Symbol.iterator]()}[Symbol.asyncIterator](){return this._impl[Symbol.asyncIterator]()}toDOMStream(){return Mr.toDOMStream(this.isSync()?{[Symbol.iterator]:()=>this}:{[Symbol.asyncIterator]:()=>this})}toNodeStream(){return Mr.toNodeStream(this.isSync()?{[Symbol.iterator]:()=>this}:{[Symbol.asyncIterator]:()=>this},{objectMode:!0})}static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A,j){throw new Error('"throughDOM" not available in this environment')}static from(A){return A instanceof t?A:Eg(A)?OQ(A):xg(A)?RQ(A):D6(A)?OA(this,void 0,void 0,function*(){return yield t.from(yield A)}):yg(A)||Eh(A)||_g(A)||Bi(A)?SQ(new di(A)):TQ(new Vo(A))}static readAll(A){return A instanceof t?A.isSync()?f4(A):h4(A):Eg(A)||ArrayBuffer.isView(A)||Xi(A)||$g(A)?f4(A):h4(A)}},ma=class extends Q6{constructor(A){super(A),this._impl=A}readAll(){return[...this]}[Symbol.iterator](){return this._impl[Symbol.iterator]()}[Symbol.asyncIterator](){return H6(this,arguments,function*(){yield vt(yield*$u(Ki(this[Symbol.iterator]())))})}},Ac=class extends Q6{constructor(A){super(A),this._impl=A}readAll(){var A,j,e,r;return OA(this,void 0,void 0,function*(){let n=new Array;try{for(var i=!0,o=Ki(this),l;l=yield o.next(),A=l.done,!A;i=!0){r=l.value,i=!1;let c=r;n.push(c)}}catch(c){j={error:c}}finally{try{!i&&!A&&(e=o.return)&&(yield e.call(o))}finally{if(j)throw j.error}}return n})}[Symbol.iterator](){throw new Error("AsyncRecordBatchStreamReader is not Iterable")}[Symbol.asyncIterator](){return this._impl[Symbol.asyncIterator]()}},tc=class extends ma{constructor(A){super(A),this._impl=A}},zm=class extends Ac{constructor(A){super(A),this._impl=A}},Um=class{get numDictionaries(){return this._dictionaryIndex}get numRecordBatches(){return this._recordBatchIndex}constructor(A=new Map){this.closed=!1,this.autoDestroy=!0,this._dictionaryIndex=0,this._recordBatchIndex=0,this.dictionaries=A}isSync(){return!1}isAsync(){return!1}isFile(){return!1}isStream(){return!1}reset(A){return this._dictionaryIndex=0,this._recordBatchIndex=0,this.schema=A,this.dictionaries=new Map,this}_loadRecordBatch(A,j){let e=this._loadVectors(A,j,this.schema.fields),r=ht({type:new Oj(this.schema.fields),length:A.length,children:e});return new Be(this.schema,r)}_loadDictionaryBatch(A,j){let{id:e,isDelta:r}=A,{dictionaries:n,schema:i}=this,o=n.get(e);if(r||!o){let l=i.dictionaries.get(e),c=this._loadVectors(A.data,j,[l]);return(o&&r?o.concat(new Dt(c)):new Dt(c)).memoize()}return o.memoize()}_loadVectors(A,j,e){return new zh(j,A.nodes,A.buffers,this.dictionaries,this.schema.metadataVersion).visitMany(e)}},Xu=class extends Um{constructor(A,j){super(j),this._reader=Eg(A)?new pd(this._handle=A):new Du(this._handle=A)}isSync(){return!0}isStream(){return!0}[Symbol.iterator](){return this}cancel(){!this.closed&&(this.closed=!0)&&(this.reset()._reader.return(),this._reader=null,this.dictionaries=null)}open(A){return this.closed||(this.autoDestroy=d4(this,A),this.schema||(this.schema=this._reader.readSchema())||this.cancel()),this}throw(A){return!this.closed&&this.autoDestroy&&(this.closed=!0)?this.reset()._reader.throw(A):Tj}return(A){return!this.closed&&this.autoDestroy&&(this.closed=!0)?this.reset()._reader.return(A):Tj}next(){if(this.closed)return Tj;let A,{_reader:j}=this;for(;A=this._readNextMessageAndValidate();)if(A.isSchema())this.reset(A.header());else if(A.isRecordBatch()){this._recordBatchIndex++;let e=A.header(),r=j.readMessageBody(A.bodyLength);return{done:!1,value:this._loadRecordBatch(e,r)}}else if(A.isDictionaryBatch()){this._dictionaryIndex++;let e=A.header(),r=j.readMessageBody(A.bodyLength),n=this._loadDictionaryBatch(e,r);this.dictionaries.set(e.id,n)}return this.schema&&this._recordBatchIndex===0?(this._recordBatchIndex++,{done:!1,value:new Zl(this.schema)}):this.return()}_readNextMessageAndValidate(A){return this._reader.readMessage(A)}},zu=class extends Um{constructor(A,j){super(j),this._reader=new dd(this._handle=A)}isAsync(){return!0}isStream(){return!0}[Symbol.asyncIterator](){return this}cancel(){return OA(this,void 0,void 0,function*(){!this.closed&&(this.closed=!0)&&(yield this.reset()._reader.return(),this._reader=null,this.dictionaries=null)})}open(A){return OA(this,void 0,void 0,function*(){return this.closed||(this.autoDestroy=d4(this,A),this.schema||(this.schema=yield this._reader.readSchema())||(yield this.cancel())),this})}throw(A){return OA(this,void 0,void 0,function*(){return!this.closed&&this.autoDestroy&&(this.closed=!0)?yield this.reset()._reader.throw(A):Tj})}return(A){return OA(this,void 0,void 0,function*(){return!this.closed&&this.autoDestroy&&(this.closed=!0)?yield this.reset()._reader.return(A):Tj})}next(){return OA(this,void 0,void 0,function*(){if(this.closed)return Tj;let A,{_reader:j}=this;for(;A=yield this._readNextMessageAndValidate();)if(A.isSchema())yield this.reset(A.header());else if(A.isRecordBatch()){this._recordBatchIndex++;let e=A.header(),r=yield j.readMessageBody(A.bodyLength);return{done:!1,value:this._loadRecordBatch(e,r)}}else if(A.isDictionaryBatch()){this._dictionaryIndex++;let e=A.header(),r=yield j.readMessageBody(A.bodyLength),n=this._loadDictionaryBatch(e,r);this.dictionaries.set(e.id,n)}return this.schema&&this._recordBatchIndex===0?(this._recordBatchIndex++,{done:!1,value:new Zl(this.schema)}):yield this.return()})}_readNextMessageAndValidate(A){return OA(this,void 0,void 0,function*(){return yield this._reader.readMessage(A)})}},Vm=class extends Xu{get footer(){return this._footer}get numDictionaries(){return this._footer?this._footer.numDictionaries:0}get numRecordBatches(){return this._footer?this._footer.numRecordBatches:0}constructor(A,j){super(A instanceof Nh?A:new Nh(A),j)}isSync(){return!0}isFile(){return!0}open(A){if(!this.closed&&!this._footer){this.schema=(this._footer=this._readFooter()).schema;for(let j of this._footer.dictionaryBatches())j&&this._readDictionaryBatch(this._dictionaryIndex++)}return super.open(A)}readRecordBatch(A){var j;if(this.closed)return null;this._footer||this.open();let e=(j=this._footer)===null||j===void 0?void 0:j.getRecordBatch(A);if(e&&this._handle.seek(e.offset)){let r=this._reader.readMessage(Lt.RecordBatch);if(r?.isRecordBatch()){let n=r.header(),i=this._reader.readMessageBody(r.bodyLength);return this._loadRecordBatch(n,i)}}return null}_readDictionaryBatch(A){var j;let e=(j=this._footer)===null||j===void 0?void 0:j.getDictionaryBatch(A);if(e&&this._handle.seek(e.offset)){let r=this._reader.readMessage(Lt.DictionaryBatch);if(r?.isDictionaryBatch()){let n=r.header(),i=this._reader.readMessageBody(r.bodyLength),o=this._loadDictionaryBatch(n,i);this.dictionaries.set(n.id,o)}}}_readFooter(){let{_handle:A}=this,j=A.size-Cq,e=A.readInt32(j),r=A.readAt(j-e,e);return ua.decode(r)}_readNextMessageAndValidate(A){var j;if(this._footer||this.open(),this._footer&&this._recordBatchIndexsuper.open}});return OA(this,void 0,void 0,function*(){if(!this.closed&&!this._footer){this.schema=(this._footer=yield this._readFooter()).schema;for(let e of this._footer.dictionaryBatches())e&&(yield this._readDictionaryBatch(this._dictionaryIndex++))}return yield j.open.call(this,A)})}readRecordBatch(A){var j;return OA(this,void 0,void 0,function*(){if(this.closed)return null;this._footer||(yield this.open());let e=(j=this._footer)===null||j===void 0?void 0:j.getRecordBatch(A);if(e&&(yield this._handle.seek(e.offset))){let r=yield this._reader.readMessage(Lt.RecordBatch);if(r?.isRecordBatch()){let n=r.header(),i=yield this._reader.readMessageBody(r.bodyLength);return this._loadRecordBatch(n,i)}}return null})}_readDictionaryBatch(A){var j;return OA(this,void 0,void 0,function*(){let e=(j=this._footer)===null||j===void 0?void 0:j.getDictionaryBatch(A);if(e&&(yield this._handle.seek(e.offset))){let r=yield this._reader.readMessage(Lt.DictionaryBatch);if(r?.isDictionaryBatch()){let n=r.header(),i=yield this._reader.readMessageBody(r.bodyLength),o=this._loadDictionaryBatch(n,i);this.dictionaries.set(n.id,o)}}})}_readFooter(){return OA(this,void 0,void 0,function*(){let{_handle:A}=this;A._pending&&(yield A._pending);let j=A.size-Cq,e=yield A.readInt32(j),r=yield A.readAt(j-e,e);return ua.decode(r)})}_readNextMessageAndValidate(A){return OA(this,void 0,void 0,function*(){if(this._footer||(yield this.open()),this._footer&&this._recordBatchIndex=4?Xm(A)?new tc(new Vm(t.read())):new ma(new Xu(t)):new ma(new Xu(function*(){}()))}function SQ(t){return OA(this,void 0,void 0,function*(){let A=yield t.peek(Ku+7&-8);return A&&A.byteLength>=4?Xm(A)?new tc(new Vm(yield t.read())):new Ac(new zu(t)):new Ac(new zu(function(){return H6(this,arguments,function*(){})}()))})}function RQ(t){return OA(this,void 0,void 0,function*(){let{size:A}=yield t.stat(),j=new x7(t,A);return A>=B4&&Xm(yield j.readAt(0,Ku+7&-8))?new zm(new Hq(j)):new Ac(new zu(j))})}var Jj=class t extends WA{static assemble(...A){let j=r=>r.flatMap(n=>Array.isArray(n)?j(n):n instanceof Be?n.data.children:n.data),e=new t;return e.visitMany(j(A)),e}constructor(){super(),this._byteLength=0,this._nodes=[],this._buffers=[],this._bufferRegions=[]}visit(A){if(A instanceof Dt)return this.visitMany(A.data),this;let{type:j}=A;if(!HA.isDictionary(j)){let{length:e}=A;if(e>2147483647)throw new RangeError("Cannot write arrays larger than 2^31 - 1 in length");if(HA.isUnion(j))this.nodes.push(new ki(e,0));else{let{nullCount:r}=A;HA.isNull(j)||oo.call(this,r<=0?new Uint8Array(0):Dl(A.offset,e,A.nullBitmap)),this.nodes.push(new ki(e,r))}}return super.visit(A)}visitNull(A){return this}visitDictionary(A){return this.visit(A.clone(A.type.indices))}get nodes(){return this._nodes}get buffers(){return this._buffers}get byteLength(){return this._byteLength}get bufferRegions(){return this._bufferRegions}};function oo(t){let A=t.byteLength+7&-8;return this.buffers.push(t),this.bufferRegions.push(new E6(this._byteLength,A)),this._byteLength+=A,this}function LQ(t){var A;let{type:j,length:e,typeIds:r,valueOffsets:n}=t;if(oo.call(this,r),j.mode===Gj.Sparse)return Nq.call(this,t);if(j.mode===Gj.Dense){if(t.offset<=0)return oo.call(this,n),Nq.call(this,t);{let i=new Int32Array(e),o=Object.create(null),l=Object.create(null);for(let c,B,h=-1;++h{let h=j.typeIds[B],d=o[h],k=l[h];return c.slice(d,Math.min(e,k))}))}}return this}function CQ(t){let A;return t.nullCount>=t.length?oo.call(this,new Uint8Array(0)):(A=t.values)instanceof Uint8Array?oo.call(this,Dl(t.offset,t.length,A)):oo.call(this,Nl(t.values))}function Ea(t){return oo.call(this,t.values.subarray(0,t.length*t.stride))}function Qm(t){let{length:A,values:j,valueOffsets:e}=t,r=ee(e[0]),n=ee(e[A]),i=Math.min(n-r,j.byteLength-r);return oo.call(this,bg(-r,A+1,e)),oo.call(this,j.subarray(r,r+i)),this}function Kq(t){let{length:A,valueOffsets:j}=t;if(j){let{[0]:e,[A]:r}=j;return oo.call(this,bg(-e,A+1,j)),this.visit(t.children[0].slice(e,r-e))}return this.visit(t.children[0])}function Nq(t){return this.visitMany(t.type.children.map((A,j)=>t.children[j]).filter(Boolean))[0]}Jj.prototype.visitBool=CQ;Jj.prototype.visitInt=Ea;Jj.prototype.visitFloat=Ea;Jj.prototype.visitUtf8=Qm;Jj.prototype.visitLargeUtf8=Qm;Jj.prototype.visitBinary=Qm;Jj.prototype.visitLargeBinary=Qm;Jj.prototype.visitFixedSizeBinary=Ea;Jj.prototype.visitDate=Ea;Jj.prototype.visitTimestamp=Ea;Jj.prototype.visitTime=Ea;Jj.prototype.visitDecimal=Ea;Jj.prototype.visitList=Kq;Jj.prototype.visitStruct=Nq;Jj.prototype.visitUnion=LQ;Jj.prototype.visitInterval=Ea;Jj.prototype.visitDuration=Ea;Jj.prototype.visitFixedSizeList=Kq;Jj.prototype.visitMap=Kq;var jc=class extends zl{static throughNode(A){throw new Error('"throughNode" not available in this environment')}static throughDOM(A,j){throw new Error('"throughDOM" not available in this environment')}constructor(A){super(),this._position=0,this._started=!1,this._sink=new Uo,this._schema=null,this._dictionaryBlocks=[],this._recordBatchBlocks=[],this._dictionaryDeltaOffsets=new Map,qn(A)||(A={autoDestroy:!0,writeLegacyIpcFormat:!1}),this._autoDestroy=typeof A.autoDestroy=="boolean"?A.autoDestroy:!0,this._writeLegacyIpcFormat=typeof A.writeLegacyIpcFormat=="boolean"?A.writeLegacyIpcFormat:!1}toString(A=!1){return this._sink.toString(A)}toUint8Array(A=!1){return this._sink.toUint8Array(A)}writeAll(A){return D6(A)?A.then(j=>this.writeAll(j)):Bi(A)?zq(this,A):Xq(this,A)}get closed(){return this._sink.closed}[Symbol.asyncIterator](){return this._sink[Symbol.asyncIterator]()}toDOMStream(A){return this._sink.toDOMStream(A)}toNodeStream(A){return this._sink.toNodeStream(A)}close(){return this.reset()._sink.close()}abort(A){return this.reset()._sink.abort(A)}finish(){return this._autoDestroy?this.close():this.reset(this._sink,this._schema),this}reset(A=this._sink,j=null){return A===this._sink||A instanceof Uo?this._sink=A:(this._sink=new Uo,A&&w8(A)?this.toDOMStream({type:"bytes"}).pipeTo(A):A&&F8(A)&&this.toNodeStream({objectMode:!1}).pipe(A)),this._started&&this._schema&&this._writeFooter(this._schema),this._started=!1,this._dictionaryBlocks=[],this._recordBatchBlocks=[],this._dictionaryDeltaOffsets=new Map,(!j||!Jl(j,this._schema))&&(j==null?(this._position=0,this._schema=null):(this._started=!0,this._schema=j,this._writeSchema(j))),this}write(A){let j=null;if(this._sink){if(A==null)return this.finish()&&void 0;if(A instanceof m6&&!(j=A.schema))return this.finish()&&void 0;if(A instanceof Be&&!(j=A.schema))return this.finish()&&void 0}else throw new Error("RecordBatchWriter is closed");if(j&&!Jl(j,this._schema)){if(this._started&&this._autoDestroy)return this.close();this.reset(this._sink,j)}A instanceof Be?A instanceof Zl||this._writeRecordBatch(A):A instanceof m6?this.writeAll(A.batches):Xi(A)&&this.writeAll(A)}_writeMessage(A,j=8){let e=j-1,r=x6.encode(A),n=r.byteLength,i=this._writeLegacyIpcFormat?4:8,o=n+i+e&~e,l=o-n-i;return A.headerType===Lt.RecordBatch?this._recordBatchBlocks.push(new Ba(o,A.bodyLength,this._position)):A.headerType===Lt.DictionaryBatch&&this._dictionaryBlocks.push(new Ba(o,A.bodyLength,this._position)),this._writeLegacyIpcFormat||this._write(Int32Array.of(-1)),this._write(Int32Array.of(o-i)),n>0&&this._write(r),this._writePadding(l)}_write(A){if(this._started){let j=it(A);j&&j.byteLength>0&&(this._sink.write(j),this._position+=j.byteLength)}return this}_writeSchema(A){return this._writeMessage(x6.from(A))}_writeFooter(A){return this._writeLegacyIpcFormat?this._write(Int32Array.of(0)):this._write(Int32Array.of(-1,0))}_writeMagic(){return this._write(Nu)}_writePadding(A){return A>0?this._write(new Uint8Array(A)):this}_writeRecordBatch(A){let{byteLength:j,nodes:e,bufferRegions:r,buffers:n}=Jj.assemble(A),i=new Tr(A.numRows,e,r),o=x6.from(i,j);return this._writeDictionaries(A)._writeMessage(o)._writeBodyBuffers(n)}_writeDictionaryBatch(A,j,e=!1){this._dictionaryDeltaOffsets.set(j,A.length+(this._dictionaryDeltaOffsets.get(j)||0));let{byteLength:r,nodes:n,bufferRegions:i,buffers:o}=Jj.assemble(new Dt([A])),l=new Tr(A.length,n,i),c=new $6(l,j,e),B=x6.from(c,r);return this._writeMessage(B)._writeBodyBuffers(o)}_writeBodyBuffers(A){let j,e,r;for(let n=-1,i=A.length;++n0&&(this._write(j),(r=(e+7&-8)-e)>0&&this._writePadding(r));return this}_writeDictionaries(A){for(let[j,e]of A.dictionaries){let r=this._dictionaryDeltaOffsets.get(j)||0;if(r===0||(e=e?.slice(r)).length>0)for(let n of e.data)this._writeDictionaryBatch(n,j,r>0),r+=n.length}return this}},kd=class t extends jc{static writeAll(A,j){let e=new t(j);return D6(A)?A.then(r=>e.writeAll(r)):Bi(A)?zq(e,A):Xq(e,A)}},gd=class t extends jc{static writeAll(A){let j=new t;return D6(A)?A.then(e=>j.writeAll(e)):Bi(A)?zq(j,A):Xq(j,A)}constructor(){super(),this._autoDestroy=!0}_writeSchema(A){return this._writeMagic()._writePadding(2)}_writeFooter(A){let j=ua.encode(new ua(A,hj.V5,this._recordBatchBlocks,this._dictionaryBlocks));return super._writeFooter(A)._write(j)._write(Int32Array.of(j.byteLength))._writeMagic()}};function Xq(t,A){let j=A;A instanceof m6&&(j=A.batches,t.reset(void 0,A.schema));for(let e of j)t.write(e);return t.finish()}function zq(t,A){var j,e,r,n,i,o,l;return OA(this,void 0,void 0,function*(){try{for(j=!0,e=Ki(A);r=yield e.next(),n=r.done,!n;j=!0){l=r.value,j=!1;let c=l;t.write(c)}}catch(c){i={error:c}}finally{try{!j&&!n&&(o=e.return)&&(yield o.call(e))}finally{if(i)throw i.error}}return t.finish()})}function p4(t,A){if(Bi(t))return DQ(t,A);if(Xi(t))return HQ(t,A);throw new Error("toDOMStream() must be called with an Iterable or AsyncIterable")}function HQ(t,A){let j=null,e=A?.type==="bytes"||!1,r=A?.highWaterMark||Math.pow(2,24);return new ReadableStream(Object.assign(Object.assign({},A),{start(i){n(i,j||(j=t[Symbol.iterator]()))},pull(i){j?n(i,j):i.close()},cancel(){(j?.return&&j.return()||!0)&&(j=null)}}),Object.assign({highWaterMark:e?r:void 0},A));function n(i,o){let l,c=null,B=i.desiredSize||null;for(;!(c=o.next(e?B:null)).done;)if(ArrayBuffer.isView(c.value)&&(l=it(c.value))&&(B!=null&&e&&(B=B-l.byteLength+1),c.value=l),i.enqueue(c.value),B!=null&&--B<=0)return;i.close()}}function DQ(t,A){let j=null,e=A?.type==="bytes"||!1,r=A?.highWaterMark||Math.pow(2,24);return new ReadableStream(Object.assign(Object.assign({},A),{start(i){return OA(this,void 0,void 0,function*(){yield n(i,j||(j=t[Symbol.asyncIterator]()))})},pull(i){return OA(this,void 0,void 0,function*(){j?yield n(i,j):i.close()})},cancel(){return OA(this,void 0,void 0,function*(){(j?.return&&(yield j.return())||!0)&&(j=null)})}}),Object.assign({highWaterMark:e?r:void 0},A));function n(i,o){return OA(this,void 0,void 0,function*(){let l,c=null,B=i.desiredSize||null;for(;!(c=yield o.next(e?B:null)).done;)if(ArrayBuffer.isView(c.value)&&(l=it(c.value))&&(B!=null&&e&&(B=B-l.byteLength+1),c.value=l),i.enqueue(c.value),B!=null&&--B<=0)return;i.close()})}}function m4(t){return new Uq(t)}var Uq=class{constructor(A){this._numChunks=0,this._finished=!1,this._bufferedSize=0;let{["readableStrategy"]:j,["writableStrategy"]:e,["queueingStrategy"]:r="count"}=A,n=b8(A,["readableStrategy","writableStrategy","queueingStrategy"]);this._controller=null,this._builder=Vl(n),this._getSize=r!=="bytes"?k4:g4;let{["highWaterMark"]:i=r==="bytes"?Math.pow(2,14):1e3}=Object.assign({},j),{["highWaterMark"]:o=r==="bytes"?Math.pow(2,14):1e3}=Object.assign({},e);this.readable=new ReadableStream({cancel:()=>{this._builder.clear()},pull:l=>{this._maybeFlush(this._builder,this._controller=l)},start:l=>{this._maybeFlush(this._builder,this._controller=l)}},{highWaterMark:i,size:r!=="bytes"?k4:g4}),this.writable=new WritableStream({abort:()=>{this._builder.clear()},write:()=>{this._maybeFlush(this._builder,this._controller)},close:()=>{this._maybeFlush(this._builder.finish(),this._controller)}},{highWaterMark:o,size:l=>this._writeValueAndReturnChunkSize(l)})}_writeValueAndReturnChunkSize(A){let j=this._bufferedSize;return this._bufferedSize=this._getSize(this._builder.append(A)),this._bufferedSize-j}_maybeFlush(A,j){j!=null&&(this._bufferedSize>=j.desiredSize&&++this._numChunks&&this._enqueue(j,A.toVector()),A.finished&&((A.length>0||this._numChunks===0)&&++this._numChunks&&this._enqueue(j,A.toVector()),!this._finished&&(this._finished=!0)&&this._enqueue(j,null)))}_enqueue(A,j){this._bufferedSize=0,this._controller=null,j==null?A.close():A.enqueue(j)}},k4=t=>{var A;return(A=t?.length)!==null&&A!==void 0?A:0},g4=t=>{var A;return(A=t?.byteLength)!==null&&A!==void 0?A:0};function Wm(t,A){let j=new Uo,e=null,r=new ReadableStream({cancel(){return OA(this,void 0,void 0,function*(){yield j.close()})},start(o){return OA(this,void 0,void 0,function*(){yield i(o,e||(e=yield n()))})},pull(o){return OA(this,void 0,void 0,function*(){e?yield i(o,e):o.close()})}});return{writable:new WritableStream(j,Object.assign({highWaterMark:Math.pow(2,14)},t)),readable:r};function n(){return OA(this,void 0,void 0,function*(){return yield(yield Q6.from(j)).open(A)})}function i(o,l){return OA(this,void 0,void 0,function*(){let c=o.desiredSize,B=null;for(;!(B=yield l.next()).done;)if(o.enqueue(B.value),c!=null&&--c<=0)return;o.close()})}}function Ym(t,A){let j=new this(t),e=new di(j),r=new ReadableStream({cancel(){return OA(this,void 0,void 0,function*(){yield e.cancel()})},pull(i){return OA(this,void 0,void 0,function*(){yield n(i)})},start(i){return OA(this,void 0,void 0,function*(){yield n(i)})}},Object.assign({highWaterMark:Math.pow(2,14)},A));return{writable:new WritableStream(j,t),readable:r};function n(i){return OA(this,void 0,void 0,function*(){let o=null,l=i.desiredSize;for(;o=yield e.read(l||null);)if(i.enqueue(o),l!=null&&(l-=o.byteLength)<=0)return;i.close()})}}function wn(t){let A=Q6.from(t);return D6(A)?A.then(j=>wn(j)):A.isAsync()?A.readAll().then(j=>new m6(j)):new m6(A.readAll())}var KQ=Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({},rq),wq),Eq),nq),Z_),mq),jq),{compareSchemas:Jl,compareFields:VM,compareTypes:QM});Mr.toDOMStream=p4;Nj.throughDOM=m4;Q6.throughDOM=Wm;tc.throughDOM=Wm;ma.throughDOM=Wm;jc.throughDOM=Ym;gd.throughDOM=Ym;kd.throughDOM=Ym;var Zj=(t,A={})=>{let{coordinates:j,url:e,messages:r={},throwOnAuth:n=!0,logUnexpected:i=!0}=A,l={...{network:"Network error occurred",notFound:"Resource not found",unauthorized:"Unauthorized access",forbidden:"Access forbidden",unexpected:"Unexpected error occurred"},...r};if(t.name==="NetworkError"||t.code==="NETWORK_ERROR")return{error:"network",message:l.network,retryable:!0};if(t.status===404)return{error:"not_found",message:l.notFound,retryable:!1};if(t.status===401){let c=j?`${l.unauthorized} for resource at ${j}`:l.unauthorized;if(n)throw new Error(c);return{error:"unauthorized",message:c,retryable:!1}}if(t.status===403){let c=j?`${l.forbidden} for resource at ${j}`:l.forbidden;if(n)throw new Error(c);return{error:"forbidden",message:c,retryable:!1}}if(i){let c={...j&&{coordinates:j},...e&&{url:e},error:t.message,stack:t.stack};console.error(l.unexpected,c)}return{error:"unexpected",message:l.unexpected,retryable:!1}},Uu=(t,A={})=>{let{logLevel:j="warn",shouldLog:e=!0}=A;e&&A.forceLog&&console[j](t,A.data||"")};var eA,md=null;function Vu(){return(md===null||md.byteLength===0)&&(md=new Uint8Array(eA.memory.buffer)),md}var Zm=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});Zm.decode();var XQ=2146435072,Vq=0;function zQ(t,A){return Vq+=A,Vq>=XQ&&(Zm=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),Zm.decode(),Vq=A),Zm.decode(Vu().subarray(t,t+A))}function so(t,A){return t=t>>>0,zQ(t,A)}var Sr=0,$d=new TextEncoder;"encodeInto"in $d||($d.encodeInto=function(t,A){let j=$d.encode(t);return A.set(j),{read:t.length,written:j.length}});function ao(t,A,j){if(j===void 0){let o=$d.encode(t),l=A(o.length,1)>>>0;return Vu().subarray(l,l+o.length).set(o),Sr=o.length,l}let e=t.length,r=A(e,1)>>>0,n=Vu(),i=0;for(;i127)break;n[r+i]=o}if(i!==e){i!==0&&(t=t.slice(i)),r=j(r,e,e=i+t.length*3,1)>>>0;let o=Vu().subarray(r+i,r+e),l=$d.encodeInto(t,o);i+=l.written,r=j(r,e,i,1)>>>0}return Sr=i,r}var ec=null;function W6(){return(ec===null||ec.buffer.detached===!0||ec.buffer.detached===void 0&&ec.buffer!==eA.memory.buffer)&&(ec=new DataView(eA.memory.buffer)),ec}function Wo(t){let A=eA.__externref_table_alloc();return eA.__wbindgen_export_4.set(A,t),A}function Ze(t,A){try{return t.apply(this,A)}catch(j){let e=Wo(j);eA.__wbindgen_exn_store(e)}}function en(t){return t==null}function Qu(t,A){return t=t>>>0,Vu().subarray(t/1,t/1+A)}function Wq(t){let A=typeof t;if(A=="number"||A=="boolean"||t==null)return`${t}`;if(A=="string")return`"${t}"`;if(A=="symbol"){let r=t.description;return r==null?"Symbol":`Symbol(${r})`}if(A=="function"){let r=t.name;return typeof r=="string"&&r.length>0?`Function(${r})`:"Function"}if(Array.isArray(t)){let r=t.length,n="[";r>0&&(n+=Wq(t[0]));for(let i=1;i1)e=j[1];else return toString.call(t);if(e=="Object")try{return"Object("+JSON.stringify(t)+")"}catch{return"Object"}return t instanceof Error?`${t.name}: ${t.message} +${t.stack}`:e}var E4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>{eA.__wbindgen_export_5.get(t.dtor)(t.a,t.b)});function $4(t,A,j,e){let r={a:t,b:A,cnt:1,dtor:j},n=(...i)=>{r.cnt++;let o=r.a;r.a=0;try{return e(o,r.b,...i)}finally{--r.cnt===0?(eA.__wbindgen_export_5.get(r.dtor)(o,r.b),E4.unregister(r)):r.a=o}};return n.original=r,E4.register(n,r,r),n}function fe(t){let A=eA.__wbindgen_export_4.get(t);return eA.__externref_table_dealloc(t),A}function xd(t,A){t=t>>>0;let j=W6(),e=[];for(let r=t;r>>0;return Vu().set(t,j/1),Sr=t.length,j}function Jq(t,A){let j=Yq(t,eA.__wbindgen_malloc),e=Sr,r=eA.readParquet(j,e,en(A)?0:Wo(A));if(r[2])throw fe(r[1]);return tB.__wrap(r[0])}function Zq(t){let A=Yq(t,eA.__wbindgen_malloc),j=Sr,e=eA.readSchema(A,j);if(e[2])throw fe(e[1]);return $a.__wrap(e[0])}function UQ(t,A){if(!(t instanceof A))throw new Error(`expected instance of ${A.name}`)}var Ed=null;function VQ(){return(Ed===null||Ed.byteLength===0)&&(Ed=new Uint32Array(eA.memory.buffer)),Ed}function QQ(t,A){return t=t>>>0,VQ().subarray(t/4,t/4+A)}function WQ(t,A){eA.wasm_bindgen__convert__closures_____invoke__hfec9c6c02f6046ed(t,A)}function YQ(t,A,j){eA.closure3789_externref_shim(t,A,j)}function JQ(t,A,j,e){eA.closure3803_externref_shim(t,A,j,e)}var b_A=Object.freeze({UNCOMPRESSED:0,0:"UNCOMPRESSED",SNAPPY:1,1:"SNAPPY",GZIP:2,2:"GZIP",BROTLI:3,3:"BROTLI",LZ4:4,4:"LZ4",ZSTD:5,5:"ZSTD",LZ4_RAW:6,6:"LZ4_RAW",LZO:7,7:"LZO"}),G_A=Object.freeze({None:0,0:"None",Chunk:1,1:"Chunk",Page:2,2:"Page"}),w_A=Object.freeze({PLAIN:0,0:"PLAIN",PLAIN_DICTIONARY:1,1:"PLAIN_DICTIONARY",RLE:2,2:"RLE",BIT_PACKED:3,3:"BIT_PACKED",DELTA_BINARY_PACKED:4,4:"DELTA_BINARY_PACKED",DELTA_LENGTH_BYTE_ARRAY:5,5:"DELTA_LENGTH_BYTE_ARRAY",DELTA_BYTE_ARRAY:6,6:"DELTA_BYTE_ARRAY",RLE_DICTIONARY:7,7:"RLE_DICTIONARY",BYTE_STREAM_SPLIT:8,8:"BYTE_STREAM_SPLIT"}),F_A=Object.freeze({V1:0,0:"V1",V2:1,1:"V2"}),ZQ=["bytes"],AW=["default","no-store","reload","no-cache","force-cache","only-if-cached"],tW=["omit","same-origin","include"],jW=["same-origin","no-cors","cors","navigate"],x4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_columnchunkmetadata_free(t>>>0,1)),Wu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,x4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,x4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_columnchunkmetadata_free(A,0)}filePath(){let A=eA.columnchunkmetadata_filePath(this.__wbg_ptr),j;return A[0]!==0&&(j=so(A[0],A[1]).slice(),eA.__wbindgen_free(A[0],A[1]*1,1)),j}fileOffset(){return eA.columnchunkmetadata_fileOffset(this.__wbg_ptr)}columnPath(){let A=eA.columnchunkmetadata_columnPath(this.__wbg_ptr);var j=xd(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}encodings(){let A=eA.columnchunkmetadata_encodings(this.__wbg_ptr);var j=xd(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}numValues(){return eA.columnchunkmetadata_numValues(this.__wbg_ptr)}compression(){return eA.columnchunkmetadata_compression(this.__wbg_ptr)}compressedSize(){return eA.columnchunkmetadata_compressedSize(this.__wbg_ptr)}uncompressedSize(){return eA.columnchunkmetadata_uncompressedSize(this.__wbg_ptr)}};Symbol.dispose&&(Wu.prototype[Symbol.dispose]=Wu.prototype.free);var y4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffidata_free(t>>>0,1)),Yu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,y4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,y4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffidata_free(A,0)}arrayAddr(){return eA.ffidata_arrayAddr(this.__wbg_ptr)>>>0}schemaAddr(){return eA.ffidata_schemaAddr(this.__wbg_ptr)>>>0}};Symbol.dispose&&(Yu.prototype[Symbol.dispose]=Yu.prototype.free);var v4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffischema_free(t>>>0,1)),Ju=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,v4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,v4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffischema_free(A,0)}addr(){return eA.ffischema_addr(this.__wbg_ptr)>>>0}};Symbol.dispose&&(Ju.prototype[Symbol.dispose]=Ju.prototype.free);var _4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_ffistream_free(t>>>0,1)),Zu=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,_4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,_4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_ffistream_free(A,0)}numArrays(){return eA.ffistream_numArrays(this.__wbg_ptr)>>>0}schemaAddr(){return eA.ffistream_schemaAddr(this.__wbg_ptr)>>>0}arrayAddr(A){return eA.ffistream_arrayAddr(this.__wbg_ptr,A)>>>0}arrayAddrs(){let A=eA.ffistream_arrayAddrs(this.__wbg_ptr);var j=QQ(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}drop(){let A=this.__destroy_into_raw();eA.ffistream_drop(A)}};Symbol.dispose&&(Zu.prototype[Symbol.dispose]=Zu.prototype.free);var q4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_filemetadata_free(t>>>0,1)),yd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,q4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,q4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_filemetadata_free(A,0)}version(){return eA.filemetadata_version(this.__wbg_ptr)}numRows(){return eA.filemetadata_numRows(this.__wbg_ptr)}createdBy(){let A=eA.filemetadata_createdBy(this.__wbg_ptr),j;return A[0]!==0&&(j=so(A[0],A[1]).slice(),eA.__wbindgen_free(A[0],A[1]*1,1)),j}keyValueMetadata(){let A=eA.filemetadata_keyValueMetadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return fe(A[0])}};Symbol.dispose&&(yd.prototype[Symbol.dispose]=yd.prototype.free);var eW=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingbytesource_free(t>>>0,1)),AE=class{__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,eW.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingbytesource_free(A,0)}get type(){let A=eA.intounderlyingbytesource_type(this.__wbg_ptr);return ZQ[A]}get autoAllocateChunkSize(){return eA.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr)>>>0}start(A){eA.intounderlyingbytesource_start(this.__wbg_ptr,A)}pull(A){return eA.intounderlyingbytesource_pull(this.__wbg_ptr,A)}cancel(){let A=this.__destroy_into_raw();eA.intounderlyingbytesource_cancel(A)}};Symbol.dispose&&(AE.prototype[Symbol.dispose]=AE.prototype.free);var rW=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingsink_free(t>>>0,1)),tE=class{__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,rW.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingsink_free(A,0)}write(A){return eA.intounderlyingsink_write(this.__wbg_ptr,A)}close(){let A=this.__destroy_into_raw();return eA.intounderlyingsink_close(A)}abort(A){let j=this.__destroy_into_raw();return eA.intounderlyingsink_abort(j,A)}};Symbol.dispose&&(tE.prototype[Symbol.dispose]=tE.prototype.free);var b4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_intounderlyingsource_free(t>>>0,1)),vd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,b4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,b4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_intounderlyingsource_free(A,0)}pull(A){return eA.intounderlyingsource_pull(this.__wbg_ptr,A)}cancel(){let A=this.__destroy_into_raw();eA.intounderlyingsource_cancel(A)}};Symbol.dispose&&(vd.prototype[Symbol.dispose]=vd.prototype.free);var G4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_parquetfile_free(t>>>0,1)),y7=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,G4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,G4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_parquetfile_free(A,0)}static fromUrl(A){let j=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),e=Sr;return eA.parquetfile_fromUrl(j,e)}static fromFile(A){return eA.parquetfile_fromFile(A)}metadata(){let A=eA.parquetfile_metadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return _d.__wrap(A[0])}schema(){let A=eA.parquetfile_schema(this.__wbg_ptr);if(A[2])throw fe(A[1]);return $a.__wrap(A[0])}read(A){return eA.parquetfile_read(this.__wbg_ptr,en(A)?0:Wo(A))}stream(A){return eA.parquetfile_stream(this.__wbg_ptr,en(A)?0:Wo(A))}};Symbol.dispose&&(y7.prototype[Symbol.dispose]=y7.prototype.free);var w4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_parquetmetadata_free(t>>>0,1)),_d=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,w4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,w4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_parquetmetadata_free(A,0)}fileMetadata(){let A=eA.parquetmetadata_fileMetadata(this.__wbg_ptr);return yd.__wrap(A)}numRowGroups(){return eA.parquetmetadata_numRowGroups(this.__wbg_ptr)>>>0}rowGroup(A){let j=eA.parquetmetadata_rowGroup(this.__wbg_ptr,A);return AB.__wrap(j)}rowGroups(){let A=eA.parquetmetadata_rowGroups(this.__wbg_ptr);var j=xd(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}};Symbol.dispose&&(_d.prototype[Symbol.dispose]=_d.prototype.free);var F4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_recordbatch_free(t>>>0,1)),rc=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,F4.register(j,j.__wbg_ptr,j),j}static __unwrap(A){return A instanceof t?A.__destroy_into_raw():0}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,F4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_recordbatch_free(A,0)}get numRows(){return eA.recordbatch_numRows(this.__wbg_ptr)>>>0}get numColumns(){return eA.recordbatch_numColumns(this.__wbg_ptr)>>>0}get schema(){let A=eA.recordbatch_schema(this.__wbg_ptr);return $a.__wrap(A)}toFFI(){let A=eA.recordbatch_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Yu.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.recordbatch_intoFFI(A);if(j[2])throw fe(j[1]);return Yu.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.recordbatch_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}withSchema(A){UQ(A,$a);var j=A.__destroy_into_raw();let e=eA.recordbatch_withSchema(this.__wbg_ptr,j);if(e[2])throw fe(e[1]);return t.__wrap(e[0])}slice(A,j){let e=eA.recordbatch_slice(this.__wbg_ptr,A,j);return t.__wrap(e)}getArrayMemorySize(){return eA.recordbatch_getArrayMemorySize(this.__wbg_ptr)>>>0}};Symbol.dispose&&(rc.prototype[Symbol.dispose]=rc.prototype.free);var P4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_rowgroupmetadata_free(t>>>0,1)),AB=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,P4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,P4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_rowgroupmetadata_free(A,0)}numColumns(){return eA.rowgroupmetadata_numColumns(this.__wbg_ptr)>>>0}column(A){let j=eA.rowgroupmetadata_column(this.__wbg_ptr,A);return Wu.__wrap(j)}columns(){let A=eA.rowgroupmetadata_columns(this.__wbg_ptr);var j=xd(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}numRows(){return eA.rowgroupmetadata_numRows(this.__wbg_ptr)}totalByteSize(){return eA.rowgroupmetadata_totalByteSize(this.__wbg_ptr)}compressedSize(){return eA.rowgroupmetadata_compressedSize(this.__wbg_ptr)}};Symbol.dispose&&(AB.prototype[Symbol.dispose]=AB.prototype.free);var I4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_schema_free(t>>>0,1)),$a=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,I4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,I4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_schema_free(A,0)}toFFI(){let A=eA.schema_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Ju.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.schema_intoFFI(A);if(j[2])throw fe(j[1]);return Ju.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.schema_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}withMetadata(A){let j=eA.schema_withMetadata(this.__wbg_ptr,A);if(j[2])throw fe(j[1]);return t.__wrap(j[0])}indexOf(A){let j=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),e=Sr,r=eA.schema_indexOf(this.__wbg_ptr,j,e);if(r[2])throw fe(r[1]);return r[0]>>>0}metadata(){let A=eA.schema_metadata(this.__wbg_ptr);if(A[2])throw fe(A[1]);return fe(A[0])}};Symbol.dispose&&($a.prototype[Symbol.dispose]=$a.prototype.free);var M4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_table_free(t>>>0,1)),tB=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,M4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,M4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_table_free(A,0)}get schema(){let A=eA.table_schema(this.__wbg_ptr);return $a.__wrap(A)}recordBatch(A){let j=eA.table_recordBatch(this.__wbg_ptr,A);return j===0?void 0:rc.__wrap(j)}recordBatches(){let A=eA.table_recordBatches(this.__wbg_ptr);var j=xd(A[0],A[1]).slice();return eA.__wbindgen_free(A[0],A[1]*4,4),j}get numBatches(){return eA.table_numBatches(this.__wbg_ptr)>>>0}toFFI(){let A=eA.table_toFFI(this.__wbg_ptr);if(A[2])throw fe(A[1]);return Zu.__wrap(A[0])}intoFFI(){let A=this.__destroy_into_raw(),j=eA.table_intoFFI(A);if(j[2])throw fe(j[1]);return Zu.__wrap(j[0])}intoIPCStream(){let A=this.__destroy_into_raw(),j=eA.table_intoIPCStream(A);if(j[3])throw fe(j[2]);var e=Qu(j[0],j[1]).slice();return eA.__wbindgen_free(j[0],j[1]*1,1),e}static fromIPCStream(A){let j=Yq(A,eA.__wbindgen_malloc),e=Sr,r=eA.table_fromIPCStream(j,e);if(r[2])throw fe(r[1]);return t.__wrap(r[0])}getArrayMemorySize(){return eA.table_getArrayMemorySize(this.__wbg_ptr)>>>0}};Symbol.dispose&&(tB.prototype[Symbol.dispose]=tB.prototype.free);var O4=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_writerproperties_free(t>>>0,1)),qd=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,O4.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,O4.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_writerproperties_free(A,0)}};Symbol.dispose&&(qd.prototype[Symbol.dispose]=qd.prototype.free);var Qq=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(t=>eA.__wbg_writerpropertiesbuilder_free(t>>>0,1)),jE=class t{static __wrap(A){A=A>>>0;let j=Object.create(t.prototype);return j.__wbg_ptr=A,Qq.register(j,j.__wbg_ptr,j),j}__destroy_into_raw(){let A=this.__wbg_ptr;return this.__wbg_ptr=0,Qq.unregister(this),A}free(){let A=this.__destroy_into_raw();eA.__wbg_writerpropertiesbuilder_free(A,0)}constructor(){let A=eA.writerpropertiesbuilder_new();return this.__wbg_ptr=A>>>0,Qq.register(this,this.__wbg_ptr,this),this}build(){let A=this.__destroy_into_raw(),j=eA.writerpropertiesbuilder_build(A);return qd.__wrap(j)}setWriterVersion(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setWriterVersion(j,A);return t.__wrap(e)}setDataPageSizeLimit(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDataPageSizeLimit(j,A);return t.__wrap(e)}setDictionaryPageSizeLimit(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDictionaryPageSizeLimit(j,A);return t.__wrap(e)}setWriteBatchSize(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setWriteBatchSize(j,A);return t.__wrap(e)}setMaxRowGroupSize(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setMaxRowGroupSize(j,A);return t.__wrap(e)}setCreatedBy(A){let j=this.__destroy_into_raw(),e=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),r=Sr,n=eA.writerpropertiesbuilder_setCreatedBy(j,e,r);return t.__wrap(n)}setKeyValueMetadata(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setKeyValueMetadata(j,A);if(e[2])throw fe(e[1]);return t.__wrap(e[0])}setEncoding(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setEncoding(j,A);return t.__wrap(e)}setCompression(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setCompression(j,A);return t.__wrap(e)}setDictionaryEnabled(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setDictionaryEnabled(j,A);return t.__wrap(e)}setStatisticsEnabled(A){let j=this.__destroy_into_raw(),e=eA.writerpropertiesbuilder_setStatisticsEnabled(j,A);return t.__wrap(e)}setColumnEncoding(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnEncoding(e,r,n,j);return t.__wrap(i)}setColumnCompression(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnCompression(e,r,n,j);return t.__wrap(i)}setColumnDictionaryEnabled(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnDictionaryEnabled(e,r,n,j);return t.__wrap(i)}setColumnStatisticsEnabled(A,j){let e=this.__destroy_into_raw(),r=ao(A,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr,i=eA.writerpropertiesbuilder_setColumnStatisticsEnabled(e,r,n,j);return t.__wrap(i)}};Symbol.dispose&&(jE.prototype[Symbol.dispose]=jE.prototype.free);var nW=new Set(["basic","cors","default"]);async function iW(t,A){if(typeof Response=="function"&&t instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(t,A)}catch(e){if(t.ok&&nW.has(t.type)&&t.headers.get("Content-Type")!=="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",e);else throw e}let j=await t.arrayBuffer();return await WebAssembly.instantiate(j,A)}else{let j=await WebAssembly.instantiate(t,A);return j instanceof WebAssembly.Instance?{instance:j,module:t}:j}}function T4(){let t={};return t.wbg={},t.wbg.__wbg_Error_e17e777aac105295=function(A,j){return Error(so(A,j))},t.wbg.__wbg_Number_998bea33bd87c3e0=function(A){return Number(A)},t.wbg.__wbg_String_8f0eb39a4a4c2f66=function(A,j){let e=String(j),r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_abort_67e1b49bf6614565=function(A){A.abort()},t.wbg.__wbg_abort_d830bf2e9aa6ec5b=function(A,j){A.abort(j)},t.wbg.__wbg_append_72a3c0addd2bce38=function(){return Ze(function(A,j,e,r,n){A.append(so(j,e),so(r,n))},arguments)},t.wbg.__wbg_arrayBuffer_2c907ed8e8ef4e35=function(A){return A.arrayBuffer()},t.wbg.__wbg_arrayBuffer_9c99b8e2809e8cbb=function(){return Ze(function(A){return A.arrayBuffer()},arguments)},t.wbg.__wbg_buffer_8d40b1d762fb3c66=function(A){return A.buffer},t.wbg.__wbg_byobRequest_2c036bceca1e6037=function(A){let j=A.byobRequest;return en(j)?0:Wo(j)},t.wbg.__wbg_byteLength_331a6b5545834024=function(A){return A.byteLength},t.wbg.__wbg_byteOffset_49a5b5608000358b=function(A){return A.byteOffset},t.wbg.__wbg_call_13410aac570ffff7=function(){return Ze(function(A,j){return A.call(j)},arguments)},t.wbg.__wbg_call_a5400b25a865cfd8=function(){return Ze(function(A,j,e){return A.call(j,e)},arguments)},t.wbg.__wbg_cancel_8bb5b8f4906b658a=function(A){return A.cancel()},t.wbg.__wbg_catch_c80ecae90cb8ed4e=function(A,j){return A.catch(j)},t.wbg.__wbg_clearTimeout_6222fede17abcb1a=function(A){return clearTimeout(A)},t.wbg.__wbg_close_a1918cff3cac355b=function(A){return A.close()},t.wbg.__wbg_close_cccada6053ee3a65=function(){return Ze(function(A){A.close()},arguments)},t.wbg.__wbg_close_d71a78219dc23e91=function(){return Ze(function(A){A.close()},arguments)},t.wbg.__wbg_columnchunkmetadata_new=function(A){return Wu.__wrap(A)},t.wbg.__wbg_done_75ed0ee6dd243d9d=function(A){return A.done},t.wbg.__wbg_enqueue_452bc2343d1c2ff9=function(){return Ze(function(A,j){A.enqueue(j)},arguments)},t.wbg.__wbg_entries_2be2f15bd5554996=function(A){return Object.entries(A)},t.wbg.__wbg_fetch_87aed7f306ec6d63=function(A,j){return A.fetch(j)},t.wbg.__wbg_fetch_f156d10be9a5c88a=function(A){return fetch(A)},t.wbg.__wbg_getReader_48e00749fe3f6089=function(){return Ze(function(A){return A.getReader()},arguments)},t.wbg.__wbg_getWriter_03d7689e275ac6a4=function(){return Ze(function(A){return A.getWriter()},arguments)},t.wbg.__wbg_get_0da715ceaecea5c8=function(A,j){return A[j>>>0]},t.wbg.__wbg_get_458e874b43b18b25=function(){return Ze(function(A,j){return Reflect.get(A,j)},arguments)},t.wbg.__wbg_getdone_f026246f6bbe58d3=function(A){let j=A.done;return en(j)?16777215:j?1:0},t.wbg.__wbg_getvalue_31e5a08f61e5aa42=function(A){return A.value},t.wbg.__wbg_getwithrefkey_1dc361bd10053bfe=function(A,j){return A[j]},t.wbg.__wbg_has_b89e451f638123e3=function(){return Ze(function(A,j){return Reflect.has(A,j)},arguments)},t.wbg.__wbg_headers_29fec3c72865cd75=function(A){return A.headers},t.wbg.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd=function(A){let j;try{j=A instanceof ArrayBuffer}catch{j=!1}return j},t.wbg.__wbg_instanceof_Response_50fde2cd696850bf=function(A){let j;try{j=A instanceof Response}catch{j=!1}return j},t.wbg.__wbg_instanceof_Uint8Array_9a8378d955933db7=function(A){let j;try{j=A instanceof Uint8Array}catch{j=!1}return j},t.wbg.__wbg_isArray_030cce220591fb41=function(A){return Array.isArray(A)},t.wbg.__wbg_isSafeInteger_1c0d1af5542e102a=function(A){return Number.isSafeInteger(A)},t.wbg.__wbg_iterator_f370b34483c71a1c=function(){return Symbol.iterator},t.wbg.__wbg_length_186546c51cd61acd=function(A){return A.length},t.wbg.__wbg_length_6bb7e81f9d7713e4=function(A){return A.length},t.wbg.__wbg_new_19c25a3f2fa63a02=function(){return new Object},t.wbg.__wbg_new_2e3c58a15f39f5f9=function(A,j){try{var e={a:A,b:j},r=(i,o)=>{let l=e.a;e.a=0;try{return JQ(l,e.b,i,o)}finally{e.a=l}};return new Promise(r)}finally{e.a=e.b=0}},t.wbg.__wbg_new_2ff1f68f3676ea53=function(){return new Map},t.wbg.__wbg_new_638ebfaedbf32a5e=function(A){return new Uint8Array(A)},t.wbg.__wbg_new_66b9434b4e59b63e=function(){return Ze(function(){return new AbortController},arguments)},t.wbg.__wbg_new_99a6a948d5b3f607=function(){return Ze(function(){return new TransformStream},arguments)},t.wbg.__wbg_new_da9dc54c5db29dfa=function(A,j){return new Error(so(A,j))},t.wbg.__wbg_new_f6e53210afea8e45=function(){return Ze(function(){return new Headers},arguments)},t.wbg.__wbg_newfromslice_074c56947bd43469=function(A,j){return new Uint8Array(Qu(A,j))},t.wbg.__wbg_newnoargs_254190557c45b4ec=function(A,j){return new Function(so(A,j))},t.wbg.__wbg_newwithbyteoffset_6bd4b2a4ca518883=function(A,j){return new Uint8Array(A,j>>>0)},t.wbg.__wbg_newwithbyteoffsetandlength_e8f53910b4d42b45=function(A,j,e){return new Uint8Array(A,j>>>0,e>>>0)},t.wbg.__wbg_newwithintounderlyingsource_b47f6a6a596a7f24=function(A,j){return new ReadableStream(vd.__wrap(A),j)},t.wbg.__wbg_newwithstrandinit_b5d168a29a3fd85f=function(){return Ze(function(A,j,e){return new Request(so(A,j),e)},arguments)},t.wbg.__wbg_next_5b3530e612fde77d=function(A){return A.next},t.wbg.__wbg_next_692e82279131b03c=function(){return Ze(function(A){return A.next()},arguments)},t.wbg.__wbg_parquetfile_new=function(A){return y7.__wrap(A)},t.wbg.__wbg_prototypesetcall_3d4a26c1ed734349=function(A,j,e){Uint8Array.prototype.set.call(Qu(A,j),e)},t.wbg.__wbg_queueMicrotask_25d0739ac89e8c88=function(A){queueMicrotask(A)},t.wbg.__wbg_queueMicrotask_4488407636f5bf24=function(A){return A.queueMicrotask},t.wbg.__wbg_read_bc925c758aa4d897=function(A){return A.read()},t.wbg.__wbg_readable_e82cff27b968ed1c=function(A){return A.readable},t.wbg.__wbg_ready_4186da3cb500ae7d=function(A){return A.ready},t.wbg.__wbg_recordbatch_new=function(A){return rc.__wrap(A)},t.wbg.__wbg_recordbatch_unwrap=function(A){return rc.__unwrap(A)},t.wbg.__wbg_releaseLock_62151472ae632176=function(A){A.releaseLock()},t.wbg.__wbg_releaseLock_ff29b586502a8221=function(A){A.releaseLock()},t.wbg.__wbg_resolve_4055c623acdd6a1b=function(A){return Promise.resolve(A)},t.wbg.__wbg_respond_6c2c4e20ef85138e=function(){return Ze(function(A,j){A.respond(j>>>0)},arguments)},t.wbg.__wbg_rowgroupmetadata_new=function(A){return AB.__wrap(A)},t.wbg.__wbg_setTimeout_2b339866a2aa3789=function(A,j){return setTimeout(A,j)},t.wbg.__wbg_set_1353b2a5e96bc48c=function(A,j,e){A.set(Qu(j,e))},t.wbg.__wbg_set_3f1d0b984ed272ed=function(A,j,e){A[j]=e},t.wbg.__wbg_set_b7f1cf4fae26fe2a=function(A,j,e){return A.set(j,e)},t.wbg.__wbg_setbody_c8460bdf44147df8=function(A,j){A.body=j},t.wbg.__wbg_setcache_90ca4ad8a8ad40d3=function(A,j){A.cache=AW[j]},t.wbg.__wbg_setcredentials_9cd60d632c9d5dfc=function(A,j){A.credentials=tW[j]},t.wbg.__wbg_setheaders_0052283e2f3503d1=function(A,j){A.headers=j},t.wbg.__wbg_sethighwatermark_3d5961f834647d41=function(A,j){A.highWaterMark=j},t.wbg.__wbg_setmethod_9b504d5b855b329c=function(A,j,e){A.method=so(j,e)},t.wbg.__wbg_setmode_a23e1a2ad8b512f8=function(A,j){A.mode=jW[j]},t.wbg.__wbg_setsignal_8c45ad1247a74809=function(A,j){A.signal=j},t.wbg.__wbg_signal_da4d466ce86118b5=function(A){return A.signal},t.wbg.__wbg_size_8f84e7768fba0589=function(A){return A.size},t.wbg.__wbg_slice_224856d46230c13c=function(){return Ze(function(A,j,e){return A.slice(j,e)},arguments)},t.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12=function(){let A=typeof global>"u"?null:global;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184=function(){let A=typeof globalThis>"u"?null:globalThis;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_SELF_995b214ae681ff99=function(){let A=typeof self>"u"?null:self;return en(A)?0:Wo(A)},t.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea=function(){let A=typeof window>"u"?null:window;return en(A)?0:Wo(A)},t.wbg.__wbg_status_3fea3036088621d6=function(A){return A.status},t.wbg.__wbg_stringify_b98c93d0a190446a=function(){return Ze(function(A){return JSON.stringify(A)},arguments)},t.wbg.__wbg_table_new=function(A){return tB.__wrap(A)},t.wbg.__wbg_then_b33a773d723afa3e=function(A,j,e){return A.then(j,e)},t.wbg.__wbg_then_e22500defe16819f=function(A,j){return A.then(j)},t.wbg.__wbg_toString_78df35411a4fd40c=function(A){return A.toString()},t.wbg.__wbg_url_e5720dfacf77b05e=function(A,j){let e=j.url,r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_value_dd9372230531eade=function(A){return A.value},t.wbg.__wbg_view_91cc97d57ab30530=function(A){let j=A.view;return en(j)?0:Wo(j)},t.wbg.__wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1=function(A,j){let e=j,r=typeof e=="bigint"?e:void 0;W6().setBigInt64(A+8*1,en(r)?BigInt(0):r,!0),W6().setInt32(A+4*0,!en(r),!0)},t.wbg.__wbg_wbindgenbooleanget_3fe6f642c7d97746=function(A){let j=A,e=typeof j=="boolean"?j:void 0;return en(e)?16777215:e?1:0},t.wbg.__wbg_wbindgencbdrop_eb10308566512b88=function(A){let j=A.original;return j.cnt--==1?(j.a=0,!0):!1},t.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d=function(A,j){let e=Wq(j),r=ao(e,eA.__wbindgen_malloc,eA.__wbindgen_realloc),n=Sr;W6().setInt32(A+4*1,n,!0),W6().setInt32(A+4*0,r,!0)},t.wbg.__wbg_wbindgenfunctiontable_aa1084b2969a9cbe=function(){return eA.__wbindgen_export_5},t.wbg.__wbg_wbindgenin_d7a1ee10933d2d55=function(A,j){return A in j},t.wbg.__wbg_wbindgenisbigint_ecb90cc08a5a9154=function(A){return typeof A=="bigint"},t.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74=function(A){return typeof A=="function"},t.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8=function(A){let j=A;return typeof j=="object"&&j!==null},t.wbg.__wbg_wbindgenisstring_d4fa939789f003b0=function(A){return typeof A=="string"},t.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5=function(A){return A===void 0},t.wbg.__wbg_wbindgenjsvaleq_e6f2ad59ccae1b58=function(A,j){return A===j},t.wbg.__wbg_wbindgenjsvallooseeq_9bec8c9be826bed1=function(A,j){return A==j},t.wbg.__wbg_wbindgenmemory_d84da70f7c42d172=function(){return eA.memory},t.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb=function(A,j){let e=j,r=typeof e=="number"?e:void 0;W6().setFloat64(A+8*1,en(r)?0:r,!0),W6().setInt32(A+4*0,!en(r),!0)},t.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f=function(A,j){let e=j,r=typeof e=="string"?e:void 0;var n=en(r)?0:ao(r,eA.__wbindgen_malloc,eA.__wbindgen_realloc),i=Sr;W6().setInt32(A+4*1,i,!0),W6().setInt32(A+4*0,n,!0)},t.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6=function(A,j){throw new Error(so(A,j))},t.wbg.__wbg_writable_e5202c9fd57615db=function(A){return A.writable},t.wbg.__wbg_write_2e39e04a4c8c9e9d=function(A,j){return A.write(j)},t.wbg.__wbindgen_cast_2241b6af4c4b2941=function(A,j){return so(A,j)},t.wbg.__wbindgen_cast_4625c577ab2ec9ee=function(A){return BigInt.asUintN(64,A)},t.wbg.__wbindgen_cast_d6cd19b81560fd6e=function(A){return A},t.wbg.__wbindgen_cast_e9d4edd5d697755b=function(A,j){return $4(A,j,317,WQ)},t.wbg.__wbindgen_cast_eb8544ce08914b2c=function(A,j){return $4(A,j,3778,YQ)},t.wbg.__wbindgen_init_externref_table=function(){let A=eA.__wbindgen_export_4,j=A.grow(4);A.set(0,void 0),A.set(j+0,void 0),A.set(j+1,null),A.set(j+2,!0),A.set(j+3,!1)},t}function S4(t,A){return eA=t.exports,oW.__wbindgen_wasm_module=A,ec=null,Ed=null,md=null,eA.__wbindgen_start(),eA}function R4(t){if(eA!==void 0)return eA;typeof t<"u"&&(Object.getPrototypeOf(t)===Object.prototype?{module:t}=t:console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));let A=T4();t instanceof WebAssembly.Module||(t=new WebAssembly.Module(t));let j=new WebAssembly.Instance(t,A);return S4(j,t)}async function oW(t){if(eA!==void 0)return eA;typeof t<"u"&&(Object.getPrototypeOf(t)===Object.prototype?{module_or_path:t}=t:console.warn("using deprecated parameters for the initialization function; pass a single object instead")),typeof t>"u"&&(t=new URL("parquet_wasm_bg.wasm",import.meta.url));let A=T4();(typeof t=="string"||typeof Request=="function"&&t instanceof Request||typeof URL=="function"&&t instanceof URL)&&(t=fetch(t));let{instance:j,module:e}=await iW(await t,A);return S4(j,e)}var L4=v8("AGFzbQEAAAAB5AiJAWACf38AYAN/f38AYAJ/fwF/YAF/AGABfwF/YAR/f39/AGADf39/AX9gBX9/f39/AGAGf39/f39/AGAFf39/f38Bf2AEf39/fwF/YAd/f39/f39/AGAAA39/f2ADf39/AX5gAW8Bb2AAAX9gBn9/f39/fwF/YAFvAX9gCH9/f39/f39/AX9gCH9/f39/f39/AGACf38BfmAAAn9/YAd/f39/f39/AX9gAn9/AW9gC39/f39/f39/f39/AX9gAn9+AGAAAW9gAX8Df39/YAx/f39/f39/f39/f38Bf2ADf39+AGAAAGAJf39/fn5+fn9/AGADf35/AGABfwJ/f2AABH9/f39gAn9vAGACb28Bb2AEf39+fwBgA39+fgBgAX8BfGABfwFvYAFvAGAKf39/f39/f39/fwF/YAp/f39/f39/f39/AGAEf35/fwBgAX8BfmACf28Bb2ACb28AYA5/f39/f39/f39/f39/fwF/YAR/f39+AGAFf35+fn4AYAl/f39/f39/f38Bf2AFf39+f38AYAJvfwFvYAJvfwBgAm9vAX9gDX9/f39/f39/f39/f38AYAZ/fn5+fn8AYAl/f39/f39/f38AYAF/AX1gBn9/fn5+fgBgA29vbwFvYAx/f39/f39/f39/f38AYAV/fn9/fwBgAn98AGAFf39/fn8AYAR/fn5/AGADf398AGABfwR/f39/YAJ/fwN/f39gAW8BfGADb39/AW9gA29/fwBgA39/bwBgC39/f39/f39/f39/AGADfn5/AX9gBX9/fn9/AX9gCX9+fn5+fn5+fgBgBH98f38Bf2AEf31/fwF/YAZ/f35/f38AYA5/f39/f39/f39/f39/fwBgAXwBfGADfn9/AX9gAX0BfWADf35/AX9gD39/f39/f39/f39/f39/fwF/YAF+AX9gA39/fwN/f39gAn9vA39/f2ADb29vAGADf39vAW9gAm98AGAFb39/f38AYAF8AW9gAX4Bb2AKf39/f39+f39/fwBgEX9/f39/f39/f39/f39/f39/AX9gBH9/fn4AYA9/f39/f39/f39/f39/f38AYAd/f35+fn5/AGAEf39/fQBgBX9/fn5/AGAEf398fwBgBH9/fX8AYBJ/f39/f39/f39/f39/f39/f38AYAl/f39/f39+fn4AYAV/f39+fwF/YAN/fnwAYAZ+f39/f38BfmAIf39/f39+f38AYAJ/fwF8YAN+f38BfmAFf39/f34AYBZ/f39/f39/f39/f39/f39/f39/f39/AX9gAn5/AGAHf39/f39+fwBgAn5+AXxgAn9/AX1gBH9/f38BfmAFfn5+fn8Bf2ACfH8BfGAEfn9/fwBgBH9/f34Bf2ADf39+AX9gBn9/f39/fgF/YAJ+fwF/YAJ+fgF+YAR/fn5+AGACf38Ef39/f2AFf399f38AYAR/fX9/AGAFf398f38AYAR/fH9/AGAEf39vbwBgA39/fAFvYAABfgLRJn4Dd2JnFV9fd2JnX3BhcnF1ZXRmaWxlX25ldwAoA3diZxpfX3diZ19yb3dncm91cG1ldGFkYXRhX25ldwAoA3diZx1fX3diZ19jb2x1bW5jaHVua21ldGFkYXRhX25ldwAoA3diZzJfX3diZ19uZXd3aXRoaW50b3VuZGVybHlpbmdzb3VyY2VfYjQ3ZjZhNmE1OTZhN2YyNAAuA3diZyBfX3diZ19nZXRSZWFkZXJfNDhlMDA3NDlmZTNmNjA4OQAOA3diZxxfX3diZ19mZXRjaF9mMTU2ZDEwYmU5YTVjODhhAA4Dd2JnIV9fd2JnX3NldFRpbWVvdXRfMmIzMzk4NjZhMmFhMzc4OQA1A3diZyNfX3diZ19jbGVhclRpbWVvdXRfNjIyMmZlZGUxN2FiY2IxYQAOA3diZxhfX3diZ19yZWNvcmRiYXRjaF91bndyYXAAEQN3YmcVX193YmdfcmVjb3JkYmF0Y2hfbmV3ACgDd2JnD19fd2JnX3RhYmxlX25ldwAoA3diZx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0YTRjMmY2NgAjA3diZyRfX3diZ19nZXR3aXRocmVma2V5XzFkYzM2MWJkMTAwNTNiZmUAJAN3YmcaX193Ymdfc2V0XzNmMWQwYjk4NGVkMjcyZWQAWgN3YmclX193YmdfcXVldWVNaWNyb3Rhc2tfMjVkMDczOWFjODllOGM4OAApA3diZyVfX3diZ19xdWV1ZU1pY3JvdGFza180NDg4NDA3NjM2ZjViZjI0AA4Dd2JnHF9fd2JnX2ZldGNoXzg3YWVkN2YzMDZlYzZkNjMAJAN3YmcdX193Ymdfc2lnbmFsX2RhNGQ0NjZjZTg2MTE4YjUADgN3YmcaX193YmdfbmV3XzY2Yjk0MzRiNGU1OWI2M2UAGgN3YmccX193YmdfYWJvcnRfNjdlMWI0OWJmNjYxNDU2NQApA3diZxxfX3diZ19hYm9ydF9kODMwYmYyZTlhYTZlYzViAC8Dd2JnG19fd2JnX3ZpZXdfOTFjYzk3ZDU3YWIzMDUzMAARA3diZx5fX3diZ19yZXNwb25kXzZjMmM0ZTIwZWY4NTEzOGUANgN3YmcoX193YmdfbmV3d2l0aHN0cmFuZGluaXRfYjVkMTY4YTI5YTNmZDg1ZgBbA3diZypfX3diZ19pbnN0YW5jZW9mX1Jlc3BvbnNlXzUwZmRlMmNkNjk2ODUwYmYAEQN3YmcaX193YmdfdXJsX2U1NzIwZGZhY2Y3N2IwNWUAIwN3YmcdX193Ymdfc3RhdHVzXzNmZWEzMDM2MDg4NjIxZDYAEQN3YmceX193YmdfaGVhZGVyc18yOWZlYzNjNzI4NjVjZDc1AA4Dd2JnIl9fd2JnX2FycmF5QnVmZmVyXzljOTliOGUyODA5ZThjYmIADgN3YmcnX193Ymdfc2V0aGlnaHdhdGVybWFya18zZDU5NjFmODM0NjQ3ZDQxAFwDd2JnG19fd2JnX3NpemVfOGY4NGU3NzY4ZmJhMDU4OQBGA3diZyJfX3diZ19hcnJheUJ1ZmZlcl8yYzkwN2VkOGU4ZWY0ZTM1AA4Dd2JnHF9fd2JnX3NsaWNlXzIyNDg1NmQ0NjIzMGMxM2MARwN3YmcgX193YmdfZ2V0V3JpdGVyXzAzZDc2ODllMjc1YWM2YTQADgN3YmcaX193YmdfbmV3X2Y2ZTUzMjEwYWZlYThlNDUAGgN3YmcdX193YmdfYXBwZW5kXzcyYTNjMGFkZGQyYmNlMzgAXQN3YmcbX193YmdfcmVhZF9iYzkyNWM3NThhYTRkODk3AA4Dd2JnIl9fd2JnX3JlbGVhc2VMb2NrX2ZmMjliNTg2NTAyYTgyMjEAKQN3YmcdX193YmdfY2FuY2VsXzhiYjViOGY0OTA2YjY1OGEADgN3YmcfX193YmdfcmVhZGFibGVfZTgyY2ZmMjdiOTY4ZWQxYwAOA3diZx9fX3diZ193cml0YWJsZV9lNTIwMmM5ZmQ1NzYxNWRiAA4Dd2JnGl9fd2JnX25ld185OWE2YTk0OGQ1YjNmNjA3ABoDd2JnHF9fd2JnX3JlYWR5XzQxODZkYTNjYjUwMGFlN2QADgN3YmccX193YmdfY2xvc2VfYTE5MThjZmYzY2FjMzU1YgAOA3diZyJfX3diZ19yZWxlYXNlTG9ja182MjE1MTQ3MmFlNjMyMTc2ACkDd2JnHF9fd2JnX3dyaXRlXzJlMzllMDRhNGM4YzllOWQAJAN3YmceX193Ymdfc2V0Ym9keV9jODQ2MGJkZjQ0MTQ3ZGY4AC8Dd2JnH19fd2JnX3NldGNhY2hlXzkwY2E0YWQ4YThhZDQwZDMANgN3YmclX193Ymdfc2V0Y3JlZGVudGlhbHNfOWNkNjBkNjMyYzlkNWRmYwA2A3diZyFfX3diZ19zZXRoZWFkZXJzXzAwNTIyODNlMmYzNTAzZDEALwN3YmcgX193Ymdfc2V0bWV0aG9kXzliNTA0ZDViODU1YjMyOWMASAN3YmceX193Ymdfc2V0bW9kZV9hMjNlMWEyYWQ4YjUxMmY4ADYDd2JnIF9fd2JnX3NldHNpZ25hbF84YzQ1YWQxMjQ3YTc0ODA5AC8Dd2JnHl9fd2JnX2dldGRvbmVfZjAyNjI0NmY2YmJlNThkMwARA3diZx9fX3diZ19nZXR2YWx1ZV8zMWU1YTA4ZjYxZTVhYTQyAA4Dd2JnIl9fd2JnX2J5b2JSZXF1ZXN0XzJjMDM2YmNlY2ExZTYwMzcAEQN3YmccX193YmdfY2xvc2VfY2NjYWRhNjA1M2VlM2E2NQApA3diZxxfX3diZ19jbG9zZV9kNzFhNzgyMTlkYzIzZTkxACkDd2JnHl9fd2JnX2VucXVldWVfNDUyYmMyMzQzZDFjMmZmOQAvA3diZxpfX3diZ19nZXRfMGRhNzE1Y2VhZWNlYTVjOAA1A3diZx1fX3diZ19sZW5ndGhfMTg2NTQ2YzUxY2Q2MWFjZAARA3diZyBfX3diZ19uZXdub2FyZ3NfMjU0MTkwNTU3YzQ1YjRlYwAXA3diZxpfX3diZ19uZXdfMmZmMWY2OGYzNjc2ZWE1MwAaA3diZxtfX3diZ19uZXh0XzViMzUzMGU2MTJmZGU3N2QADgN3YmcbX193YmdfZG9uZV83NWVkMGVlNmRkMjQzZDlkABEDd2JnHF9fd2JnX3ZhbHVlX2RkOTM3MjIzMDUzMWVhZGUADgN3YmcfX193YmdfaXRlcmF0b3JfZjM3MGIzNDQ4M2M3MWExYwAaA3diZxpfX3diZ19uZXdfMTljMjVhM2YyZmE2M2EwMgAaA3diZx5fX3diZ19pc0FycmF5XzAzMGNjZTIyMDU5MWZiNDEAEQN3YmctX193YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl82N2YzMDEyNTI5ZjZhMmRkABEDd2JnGl9fd2JnX25ld19kYTlkYzU0YzVkYjI5ZGZhABcDd2JnG19fd2JnX2NhbGxfMTM0MTBhYWM1NzBmZmZmNwAkA3diZxtfX3diZ19jYWxsX2E1NDAwYjI1YTg2NWNmZDgAPQN3YmcaX193Ymdfc2V0X2I3ZjFjZjRmYWUyNmZlMmEAPQN3YmcbX193YmdfbmV4dF82OTJlODIyNzkxMzFiMDNjAA4Dd2JnJF9fd2JnX2lzU2FmZUludGVnZXJfMWMwZDFhZjU1NDJlMTAyYQARA3diZx5fX3diZ19lbnRyaWVzXzJiZTJmMTViZDU1NTQ5OTYADgN3YmcfX193YmdfdG9TdHJpbmdfNzhkZjM1NDExYTRmZDQwYwAOA3diZxpfX3diZ19uZXdfMmUzYzU4YTE1ZjM5ZjVmOQAXA3diZx5fX3diZ19yZXNvbHZlXzQwNTVjNjIzYWNkZDZhMWIADgN3YmccX193YmdfY2F0Y2hfYzgwZWNhZTkwY2I4ZWQ0ZQAkA3diZxtfX3diZ190aGVuX2UyMjUwMGRlZmUxNjgxOWYAJAN3YmcbX193YmdfdGhlbl9iMzNhNzczZDcyM2FmYTNlAD0Dd2JnMl9fd2JnX3N0YXRpY19hY2Nlc3Nvcl9HTE9CQUxfVEhJU19mMGE0NDA5MTA1ODk4MTg0AA8Dd2JnK19fd2JnX3N0YXRpY19hY2Nlc3Nvcl9TRUxGXzk5NWIyMTRhZTY4MWZmOTkADwN3YmctX193Ymdfc3RhdGljX2FjY2Vzc29yX1dJTkRPV19jZGUzODkwNDc5YzY3NWVhAA8Dd2JnLV9fd2JnX3N0YXRpY19hY2Nlc3Nvcl9HTE9CQUxfODkyMWY4MjBjMmNlM2YxMgAPA3diZx1fX3diZ19sZW5ndGhfNmJiN2U4MWY5ZDc3MTNlNAARA3diZydfX3diZ19wcm90b3R5cGVzZXRjYWxsXzNkNGEyNmMxZWQ3MzQzNDkASQN3YmcaX193Ymdfc2V0XzEzNTNiMmE1ZTk2YmM0OGMASAN3YmcaX193YmdfbmV3XzYzOGViZmFlZGJmMzJhNWUADgN3YmcsX193YmdfaW5zdGFuY2VvZl9VaW50OEFycmF5XzlhODM3OGQ5NTU5MzNkYjcAEQN3YmcjX193YmdfbmV3ZnJvbXNsaWNlXzA3NGM1Njk0N2JkNDM0NjkAFwN3YmcoX193YmdfbmV3d2l0aGJ5dGVvZmZzZXRfNmJkNGIyYTRjYTUxODg4MwA1A3diZzFfX3diZ19uZXd3aXRoYnl0ZW9mZnNldGFuZGxlbmd0aF9lOGY1MzkxMGI0ZDQyYjQ1AEcDd2JnHV9fd2JnX2J1ZmZlcl84ZDQwYjFkNzYyZmIzYzY2AA4Dd2JnIV9fd2JnX2J5dGVMZW5ndGhfMzMxYTZiNTU0NTgzNDAyNAARA3diZyFfX3diZ19ieXRlT2Zmc2V0XzQ5YTViNTYwODAwMDM1OGIAEQN3YmcaX193YmdfZ2V0XzQ1OGU4NzRiNDNiMThiMjUAJAN3YmcaX193YmdfaGFzX2I4OWU0NTFmNjM4MTIzZTMANwN3YmcgX193Ymdfc3RyaW5naWZ5X2I5OGM5M2QwYTE5MDQ0NmEADgN3YmcqX193Ymdfd2JpbmRnZW5kZWJ1Z3N0cmluZ185OWVmMjU3YTNkZGRhMzRkACMDd2JnJV9fd2JnX3diaW5kZ2VubWVtb3J5X2Q4NGRhNzBmN2M0MmQxNzIAGgN3YmcsX193Ymdfd2JpbmRnZW5mdW5jdGlvbnRhYmxlX2FhMTA4NGIyOTY5YTljYmUAGgN3YmccX193YmdfRXJyb3JfZTE3ZTc3N2FhYzEwNTI5NQAXA3diZx1fX3diZ19OdW1iZXJfOTk4YmVhMzNiZDg3YzNlMABGA3diZypfX3diZ193YmluZGdlbmlzdW5kZWZpbmVkX2M0YjcxZDA3M2I5MmYzYzUAEQN3YmcnX193Ymdfd2JpbmRnZW5pc29iamVjdF8zMDdhNTNjNmJkOTdmYmY4ABEDd2JnKV9fd2JnX3diaW5kZ2VuaXNmdW5jdGlvbl84Y2VlN2RjZTM3MjVhZTc0ABEDd2JnJ19fd2JnX3diaW5kZ2VuaXNzdHJpbmdfZDRmYTkzOTc4OWYwMDNiMAARA3diZydfX3diZ193YmluZGdlbmlzYmlnaW50X2VjYjkwY2MwOGE1YTkxNTQAEQN3YmchX193Ymdfd2JpbmRnZW5pbl9kN2ExZWUxMDkzM2QyZDU1ADcDd2JnKF9fd2JnX3diaW5kZ2VubnVtYmVyZ2V0X2Y3NGI0Yzc1MjVhYzA1Y2IAIwN3YmcpX193Ymdfd2JpbmRnZW5ib29sZWFuZ2V0XzNmZTZmNjQyYzdkOTc3NDYAEQN3YmcoX193Ymdfd2JpbmRnZW5zdHJpbmdnZXRfMGYxNmE2ZGRkZGVmMzc2ZgAjA3diZy1fX3diZ193YmluZGdlbmJpZ2ludGdldGFzaTY0X2FjNzQzZWNlNmFiOWJiYTEAIwN3YmckX193Ymdfd2JpbmRnZW50aHJvd180NTFlYzFhODQ2OWQ3ZWI2AAADd2JnJV9fd2JnX3diaW5kZ2VuY2Jkcm9wX2ViMTAzMDg1NjY1MTJiODgAEQN3YmcmX193Ymdfd2JpbmRnZW5qc3ZhbGVxX2U2ZjJhZDU5Y2NhZTFiNTgANwN3YmcrX193Ymdfd2JpbmRnZW5qc3ZhbGxvb3NlZXFfOWJlYzhjOWJlODI2YmVkMQA3A3diZx9fX3diaW5kZ2VuX2luaXRfZXh0ZXJucmVmX3RhYmxlAB4Dd2JnIF9fd2JpbmRnZW5fY2FzdF9lOWQ0ZWRkNWQ2OTc3NTViABcDd2JnIF9fd2JpbmRnZW5fY2FzdF8yMjQxYjZhZjRjNGIyOTQxABcDd2JnIF9fd2JpbmRnZW5fY2FzdF9kNmNkMTliODE1NjBmZDZlAF4Dd2JnIF9fd2JpbmRnZW5fY2FzdF80NjI1YzU3N2FiMmVjOWVlAF8Dd2JnIF9fd2JpbmRnZW5fY2FzdF9lYjg1NDRjZTA4OTE0YjJjABcD2D3PPQcHBwcHBwcHBwUFBQUIAQUFAAAAAAcBAQIHYAAHAgIBBQUAAgUFAT4BBQEBCgMEOAcBFgABAgEHBwEHAAEBCAIKCwABBQUICAUFCAgAAAAICAgIAQUAAAgFBwAABQUAADk5AAABAQAAAAAAAAACYQEfHx8HBx8JHwcfEAcHBwcHBwcHBwcHBwcHBwcHBx8fAQEBAQIHAAgBBwcHAQcHAQEBAQcHB0oHBwcHBxABBg0SAwcCBwcFBQcABwEBAQUqBwcHBwcHBwcCCAcHBQA6EA0CAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAQEFEAEBAAAAAAAAAAAAAAgFBUsACwIAAQAABT8AAAABBQUFBQUFBQUFAAYBAQUBAAIAAAUFBQUFBQUBBQEFBRABBwUFFgEFBQAABQoKCgoAAgAAAAAAAAAAAAAAAAUAAAAACwAAAAAIBQAAAAAAAAAAAAEAAAAAAAAAAAAAAAgICAAAAAAAAAEABwUAAAUBAQUFBQEFAQUFAQEKCgUJBQUFBQUFBQAFBQoICgAAAAUBAAAABQUFAQIABQUFAQEBBQkFAQUFBQUFBQAFBQUBAQABBQIcAAAJCQkABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUWAAAFBQABAAAAAAAAAAEAAQAAAQAAAAAAAAAAAAAAAAAFBQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQBHAABAABMAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAFHAAAAAAAAAAAAAAAAAAABQAAAAUAAAACCgIwMDAFBQUKCgEKBQUFBQpNAAAxBQUFQAEAAjIFBQocHAgBAQkBABYBAQISAAoBCwEKBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFBQUIBwEBBQUBAQEBCAgKCgoKCgoKEAkCAgECAgICGAAABwcBGAAKCgoKCgAAAAAAAAZiAAEFBQUFBQUFBQUFBQU7OzsBAQEBBQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQoKAAAAEAAFAAgIAAUFOGMBBgYCCAIAEAkGBgkAARMIAQgIBU4GTwgICAgIHAcABQAAAAAAAAAAAAAJBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB00AAAAAAAAAAAAAAAoBAQEBAQEHBwgQAAAAABwBAAICAgICAgEBAQICAgICAgICAgICAgIAAQcrKysLAgUBHAA6BggBAQcBAAIBAQELAQEFBRMBASoqFkA4AQEQATMBAQEFAE4ABQUQAQEWCAgICAgICAgICAFPBQUAAgULCwsLCwtMAQAAAAIQARYHAQEHBQcFECoBBwcHBwcHBwcBBQIBATwHHAIFABYCAQUBBQgIBAQEBAUYAAEBAAcABgEICAgICAgICDEFBQUGBAQKBQUIAQU8AQsDBQUFAQEBAQgICAgICAgICAgCKwUAFBMBAgICCAgAAgICAgICAgJkAmULAQAFBgE8PAoFAQEBAQEBCDMAAQcTBQEBAQECAgEFBQIDAAAAAAAGAwcBAAsBAQUBBgYBAgEBAQULZgUFCQkABQUFAQsLBQcHBwcHBwcHBwcHBwoAAAcCASs+BQEBAQcAAAkCBQUABQUFZyUFBQUFBSVoAAABAAAAAAAAAAAAAAAACgUKAAUKBQUBNCUCBQAAAAAAAAACCQsHBgAICAAACAUFBQUJJgoKBgEBCwUAAQAFAQEBAAAGJg0LAgIABQkmAAABAQELBwMCAAAAFAACUAEBABQFAQECAQsSAAYUCwAAAAAAAAAAAAAAAAAAAAEBAAAAAAMFAwMDAwMICAgICAgDAwMDAQkDAwADAwMDAwMUFBQUFBQBAwMDAwMDAwMCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw0DAwMCAgICEwEAAAsLAANRAQEBAgMAAEEBFBQBAQAFFgsLCwA5AQUAAAAAAAUACAIACwMLEgEABgMAAAAFAQEBBQgeSgsLCwcICAgICAgqAQEBAQEBBQUFBQEFBQUFBWkGAQEFBQUFBQUFBwMLCwEBAQEFBQUFAQEABGoIAQEAAAACQQsLCwsLCwsLCwsBBQUFBQAAAQUFBQUFBQADBwcFAAUFAAEBAABQAQACBwUAAAABBQcBAQEBAQUYFAAAAgUTAQEAAAABAAUHAAAAAAELawIAAAEAAAEBAQFCAAEKAQAAADgHBwcHAgEAAAUHBwIAAQAFAQICAwUdAQEBATkBAAACAAIAAAAAAAABAAAAAAEADwcAAAAAAAAAAAAAAAAAAAAAAAQDCwAEAQEAAAAAARYBABMAAQYGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAQDBQcBAAAAAAAAAAUFBQUFBQUFAQECAgYAAAAAAAcAAAEBAQEBAAAFBQUFBQUFBQUFBQUFBQUFBgYGBwtSAAABAAAIExMTExMTHQUFBQUFBQUFBwEFBQUFBQUFBRABBQcWByAIBwcTEwAAAAAABwUEPgUAAggFAQUYAQEBAQcAAAAAAAIBAQEBBQUFExMLAwQBCAUDAgUCBRQAAAABBRMTAQEFAAEAAAUCBQYAABgAABABAQAAAAAAAAADAAAABwcHAFMBASAAAAEBAwABBQUFBQUACQA0BQEAAAcEAAMQAQUAAAAAAAAAAAAAAAAAAAAAAAAFBQMAAgcCAAcHCQICAAIDAQAAAAAAAQEACAUAAgMBAQEBAAEKCgoKAgUCCQICASAIBQICbAcAAAAAAAAAAAAAAAAAAAAAAQAFAgAEAAAAAAAAACwsLCwAAAEBAQICAgICAQICAgICCDBtCQMJAAAAAwAAAQAACgEQAAEAAAICBQsAAwsDAAAAMQEAABkCOgkBAUEIAwMtbgUFAAUAAQEBBQEAAgIBMwUFAAsBAQACBQELAAAABQUBAAIDAgICAgAADwEFBQUGPwAAAAJUCgAABAUDAAEBAAEACwEKVQBvAQEBAQEBAAUBAAAABwABCwcHAwAAAQEBAQEDAQADAAcACRAFBQUFCQkJCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDAAYFBgEJAQUCAgMHAwNVBQFWBnA/AQEBAQEBAQACAQUAAAUJAAUFAAMBAQAALAUHAwAAAAAGAQAAAAAAAAAAAwAAAAAAAQAFBwFxBwcAAAQHBgcBBwIABQAAAQEFAQUFBQUBAQEBBwAAAAAEBAABAQIFAQEHAAcHAwIKAgAxAQMLCAAAAAAAAAAAAAAAAAAAAAACAQMAAAICBgMAARISAQEAAAAAAQEBAQcFAQAFBQUFAAEABAAZBQAABgMDAwMDAwMDAAQDAwAFAwMDAwoBAAAAAAAAGQQZAAADAwMAAAUAAAEABQAAAgUBAQEBAQEBAAAAAAEBAAADAQIBBQcGAAgAAQABCwUABQUAGXIDAxIYKgoBBAAAAAAAAwUAAQIIBQYDBgsDAQUCAAQDNAoEAQEAGQABAQgIAQEBBwAAAQEAAAACAgcBKwsDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEDczAABgUABzMFdAUFBQUFBQUFBQUFBQUFBQUFBQUFBQECdQMDAAAAAQEHBwAJBwUBAQEBAQEBAQACQAEFAAEtCAABAQQFBAAEAwV2AwMDAwEBBFEKAgMAAAdWAAAEBAABBgcBAAABAwN3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAQIABwEDAwAAAQUAABkAAAQAAAABAAUFBQUBAgEFGAMABAAABQk0OgIBAgEBAwEBBwAAAAEABQABAAAAAAEBAQEAAAAAAAAAAAAAAAcAAAcFAgMtAQYAAQYJCQkJCQEAAwMDAwEBAAAABQUDAwEBAwcCAwABAAEAAAAAAAAAAAAAAAAAAAgWAAEDAwMCBAEAAQECMgAxAwMAAAAFAQEBAAAAAgADAwcHBwcHCgoABAUFBQUFBQUBAQIAAAEFAQEHCwMHAQEPAAEBCQEFCQUAAAAAAQAAAQIGAgMFAwIAAAABAQQEBAUCJgECAAAAAAECAAAAAAAABwAABQMCAgEBAQEBAQEBAQEBAQEBAQEBAQcAAgEBAgIBAwEBAQEABR0FAAEELQQAAgELAAUJCQkDAQcJAQMBBQYFBQEAAiYAAgUEAwMBAQEBAQEBAQEFAAUAAAMAAAAAAAAAAAEBAAUCAhQDAwAAAAMDAwACBwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAgEBBQUBAQEBHR0BAQEdBQMFCwYCAQEAAAABAQEFBQEBAAAAAAABAAMDAwAAAwMAAhYBARkFAgAEAgAAAQQDAAAAAAAFBQUFBAQEBAUDCAAGAw0AAAIBBAIAAwIAAAEBAQECAAEDAQAEAAQBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAggDCAICAgICAgADBAQEAQABBwMAAwETAAMCBwIAAQIDBgICAwMCCgMAAwIBAgQAAQAdAAoBCgYHAQEBAQEBBQUDAwMDAwMDAwMDAwUFBQUFBQUCAAMDBwMAAgICAgAABQUFBQUFBQYAAAAAAAAAAAACAAYAAAEBAQEBAQEBAQEBAQEBAQEBAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAXgCAgICAgIAAAAAAQAAAgMKAwMDAAAdAQUFBQMBAgoCAgICAgQEBAQEBAQEBAQEBAQEBAMDAwMDAwMDAwMDAwMICAIAAAAAAgMDAAAyAwMlCgMAAAMDAgMDBQICAAAAAQEDAQEBAQcDAwMHBwMDAwMDAwMDAwMAAAMHAAMDAwMDBAAAAwEABQUAAAUAAgAHAAICAgAAAAAAAAAAAAAAAQMBAwADAwMDAAADAwEACAEAAgICAAAAAAMDAwMAAAMDAwEBBQMCAgECCgoKCgoKCgoBAAAACgUDAwIlAwMDAAEDAwEDCQMBAQEBAQEBAQEBAQEBAQEBBAAGAgMCAiYDAwMEAgMDAwMAAAAEBAQEBAQBBAkDBAkAAwEAAAMDAwMDAwMEAQABAQADCgMDAAEDAgIHAQUCAgMDBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDAwMgAwMIBgkCAQAAAAMDAwMFBQAAAAMDAAAFAgIAAAIGAgQEBAQHBwcHBwcHBwIABAYAeQMGAAMAAAMDAwADAAAACgYUAAAAAAUFBQUFBQUFBQUFSwUFBQUFBQUFBQUFBQUFBQABAAACBAABAAEBAAUBAQEBAQEBAQ0DAQEACAEFBQMAAAMCAgICAgICAgMAAAAAAAEFAAEBBAMDAwMEAAAEAwMDAwADAwAAAAECAwIWAgAAAAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcBAAADAwMDAgAAAwADBgUNAwYDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwMBAgEDAAAAAwMDAwACAAMDAwMDAwYEBAAABgZ6BgcHBwcFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQMFAQAKMgMFAwMGQkIDAwAAAwQBAwEDAwEEAjIEBQMAAgAAAwEAAgICAgZ7AgcFAAEEBAQEBAQEBAQEBAADAwEAAAAAAgUFAQEIAAMDAwMAAAAEAgICAAUBAAACAgEABAAABQEAAFIABAUFBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwQCAAAAAAECA0NDBAADAwICBQEEAwMDBAQEBAQEAwMDA3wBAQAAAQAAAAAAAAAAAAADAwMDAwMAAAMDAwMDAwMDAwICAAAAAAAAAAACAgICAgICAwMCAgEAAgMDAwADAAAAAwABBAAAAEMAAAANAgAKAAAAAAAAAAQEBAQEBAQEBAQEBAQFBSAgICAHBwEDAwICBAIAAAADBAQCEAEBCgACAAACAwUEAgQAAQICAwMFAwADAwMDAwQCAwMDAQEGAwAAAAAAAAMBAgECBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcDAAMDAQMDAwUFBQUABAEBAQABAQYDAwMBAQEAAwAFBQMGDQMABQMBAwMIAQ0NAwQFAgMDAAADAgIDAw8DAgIDAwMDAQMCAAAAAwMDAAMJCgADAwMDAwMDAwMDAwMDAwMHBgAAAgIDAQACBgMGAwMDAwQEAgMDAw0NGQICAAJXBAcHBwcHBwcHBwcHBwcHBwcHBwcAAAMDAAMDAwUAAwMDAwMDAwMDBQMBAwICAQADBB4CAgQAAx4GAwMAAwMFAQIDAAAAAAAADQMHBwEQAgIAAwMDAAAAAAAAAAAABAEHAAIAAgAAAwAAAAEAAgMEAAAAAAAAAAAAAAIDfQIGEwYCAAAABAADAAQCBwABAwgAAwMDAwMDBAgDBwEDBQMDAQEJBQEHAQMEBAQDAgMCBAEHAAcBAQcGAgMABAQCBQACAgAAAgIGAAMCAQEBAAMBBgICAwMBBgMDAwMDAwADAQAAAwMBAwMDAwAEAQMDAwEBAQEAAQMDAwMDAAMDAAEAAAMAAAAAAgACAQAAAAEBBgAAAAAAAAAAAAJ+AgUFBQMDAAAAAAQEBAMDBAQDCgMDAAQDAAQDAwMDAwQEBAQEAwQEAAAAAAAAAAAEBAQBBQAEAAAAAwMDAwQEBAMHAgQEBAQEBAQEAwMDBAMBAQMDAgICBwICAAAAAAEBAQEBAQEBAAECAgIEAAICBQACBAMDAwMDAwMBAgEDBAMDA38FBAQDBAMEBAMEBAQEAAQABAQEBAQEBAQECYABAwMDAwMDAwMDAycnJycnJycFAgMDAAEDAwMDAwMAAwAEAwUFAQEDAwQBAQMAAgMDBAQEBAQEBAQDAwMDAwEEBQEAAAAFAwMAAgUFBwMDAgQtDwIAAgIBAgQDBQADBQAAAgICAgAEBlcEAwkCAgMCAgIDAwMEBAEAAAEDAQEKAwIeBAMDAwMCAgAAAAMCAwQAAgICAgICAgICAwICAgMDAQMBAgYPAgIDAQQEAQIEAwIKAgQDAwMCAwEDAwMBAwQDAwcHBwAEgQEDAwMDAwMDAwACAgIBAzsDAwAEAAQFAwIDAAIFWEREWEQDDwMEAQMDAwAHAAAAAAAAAAAAAAAAAAAAAgAAAAAACQMBAABZRUVZRQMDAwMDAwMDAAMAAAEDAwMAAAACAgMADQoAAgICAAADAAUAGxsbGxsbGxsbGwMDAwMAAQEBBAQFBAABAQMDAwMDAwMDAwMDAwAAAAADAgAAAgIDAQABAwAAAwIDAwMDAwMDAAADBAMEAwkJCQkJUwAAAwMDAAAAAAAAAAEEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAgABISEhISEhISEDAwMDAgMEAwMDAgICAgIGBgQCAAAAAAAAAwECAgAAACYZAAAEAxADAwMDAwICAgoAAAAAAAAAAQMEAwICJQMNDQMDAwICAQICAQEEAgICAg0CDQACAgICAgOCAYQBBwk0AwIACgMDAwMDAwACAwMDAwMDAwMDBBgYAwMAAAAAAAADAwIAAAEFAAIChgEDAwMDAQEAAgACAg8PDw8FBQQDBQUFBQUNDQMDAwMDAwEDDQENDQ0NDQICAgIAAAQPDxkDBQAGAgMDAgQEAwMDAwIAAAYSEhISEhISEhISEhIBAwMDAwAEAAMAAAICAgMGAVQENS4uLi4DAwMAAAMDAwADAwADAwAAAAMDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABB0AAAAAAAAAAAAAAAAAAAADAwMAAAAAAAAABwMDAC0AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAMAAAAAAAAAAAAAAAAAAAAAAAACAAICAgAAAAMDAwMAAAACAg4DBAMEBAQEBAYGCQkJCQkJCQkJCQkJCQkJCQkJCQkUBgAFBQAEAAQAAAQEAAAEBAAEDwIDAwICAgIBAwEBAAICBgMDCgIGBQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAQEDAAMDAAkCAAkJCQkJCQkQEAECAgYCBgMBAwMEAgYDAgMDBgIDBAQBBgEDBgYCBIcBSQAAAgIABAQDCQkJCQkJBAUIBAQEBAQAAwQEBAQEBAQGAAECBw8XFxcjAAMAAgICAAABAgIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAIAAwIAAAAAAAAAAAAAAAAAAAAAAAAJAAAAAgMCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAABAQEAAQEAgICAgIABAAEAAAAAAAEBAAABAAAAAcHBwcHBwcHAgcAAwQFBQADAAEEAwACAgIEKAICAQICBAIEBAAEBgEEBAQDAwIBAQICBQMCBAICAgICAgICAQUFAgoKCgQEAAQAAw8CBAQEBAQKBAEBAQMBAhoaAwICAgICAwMDAgICAgICAgICAgICAgICAgIEAgICAwIAAgICAgADAwIDAgIAAgABAQMDAwMDAwMDAwMDAwMDBAICAgIEBAQEBAQCAgIABAAEAgICAgMCAwMCAgICAgICAgICAgICAwICAgICBAICAgICAgICAwACAgICAgIAAgICAgACAgIEBAQEBAQEBAQEBAIEBAQEBAQCAgQEBAQEBAQEBAQEBAIEAgIEAgMDAwMEBAQEBAQEAgACAgICAwMCAgICAgICAgICAgICAgICAAICAgQBAgIFBAQEAAIEAgQAHh4CAgICAgICAgIAAgICAgIGAgAAAgICAgQEAgAABAQEAAAAAAAABAQAAAQCAAAEBAQEBAQAAAACAgQUBAAAAAAAAAAAAAQEAAAAAAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEAgQBAQMDAgICAgICBAQDBAQEAwQDAwMEBAQEBAMEBAQEBA8eBAQEBAQEBAQEBA8EBAQEBIgBBAQCAgQEAQMFAAcECwJwAa4erh5vAIABBQMBACMGCQF/AUGAgMAACwfkHYQBBm1lbW9yeQIAFl9fd2JnX3BhcnF1ZXRmaWxlX2ZyZWUA/hUTcGFycXVldGZpbGVfZnJvbVVybAClNhRwYXJxdWV0ZmlsZV9mcm9tRmlsZQDTNBRwYXJxdWV0ZmlsZV9tZXRhZGF0YQCYLRJwYXJxdWV0ZmlsZV9zY2hlbWEAmS0QcGFycXVldGZpbGVfcmVhZACmNhJwYXJxdWV0ZmlsZV9zdHJlYW0ApzYaX193YmdfcGFycXVldG1ldGFkYXRhX2ZyZWUAiiQccGFycXVldG1ldGFkYXRhX2ZpbGVNZXRhZGF0YQD8JRxwYXJxdWV0bWV0YWRhdGFfbnVtUm93R3JvdXBzAIMqGHBhcnF1ZXRtZXRhZGF0YV9yb3dHcm91cADVJRlwYXJxdWV0bWV0YWRhdGFfcm93R3JvdXBzAIouF19fd2JnX2ZpbGVtZXRhZGF0YV9mcmVlAJEhFGZpbGVtZXRhZGF0YV92ZXJzaW9uALMrFGZpbGVtZXRhZGF0YV9udW1Sb3dzAO4qFmZpbGVtZXRhZGF0YV9jcmVhdGVkQnkAiy4dZmlsZW1ldGFkYXRhX2tleVZhbHVlTWV0YWRhdGEAmi0bX193Ymdfcm93Z3JvdXBtZXRhZGF0YV9mcmVlAIskG3Jvd2dyb3VwbWV0YWRhdGFfbnVtQ29sdW1ucwCEKhdyb3dncm91cG1ldGFkYXRhX2NvbHVtbgDWJRhyb3dncm91cG1ldGFkYXRhX2NvbHVtbnMAjC4Ycm93Z3JvdXBtZXRhZGF0YV9udW1Sb3dzAO8qHnJvd2dyb3VwbWV0YWRhdGFfdG90YWxCeXRlU2l6ZQDwKh9yb3dncm91cG1ldGFkYXRhX2NvbXByZXNzZWRTaXplAPEqHl9fd2JnX2NvbHVtbmNodW5rbWV0YWRhdGFfZnJlZQCMJBxjb2x1bW5jaHVua21ldGFkYXRhX2ZpbGVQYXRoAI0uHmNvbHVtbmNodW5rbWV0YWRhdGFfZmlsZU9mZnNldAC0Kx5jb2x1bW5jaHVua21ldGFkYXRhX2NvbHVtblBhdGgAji4dY29sdW1uY2h1bmttZXRhZGF0YV9lbmNvZGluZ3MAjy4dY29sdW1uY2h1bmttZXRhZGF0YV9udW1WYWx1ZXMA8iofY29sdW1uY2h1bmttZXRhZGF0YV9jb21wcmVzc2lvbgDCKCJjb2x1bW5jaHVua21ldGFkYXRhX2NvbXByZXNzZWRTaXplAPMqJGNvbHVtbmNodW5rbWV0YWRhdGFfdW5jb21wcmVzc2VkU2l6ZQD0KhtfX3diZ193cml0ZXJwcm9wZXJ0aWVzX2ZyZWUAkiEbd3JpdGVycHJvcGVydGllc2J1aWxkZXJfbmV3ALUrHXdyaXRlcnByb3BlcnRpZXNidWlsZGVyX2J1aWxkAIYRKHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldFdyaXRlclZlcnNpb24A1hwsd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0RGF0YVBhZ2VTaXplTGltaXQAtB8yd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0RGljdGlvbmFyeVBhZ2VTaXplTGltaXQA5CYpd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0V3JpdGVCYXRjaFNpemUAkyEqd3JpdGVycHJvcGVydGllc2J1aWxkZXJfc2V0TWF4Um93R3JvdXBTaXplAOUmJHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENyZWF0ZWRCeQDgICt3cml0ZXJwcm9wZXJ0aWVzYnVpbGRlcl9zZXRLZXlWYWx1ZU1ldGFkYXRhAPAsI3dyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldEVuY29kaW5nANYfJndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbXByZXNzaW9uAP4bLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldERpY3Rpb25hcnlFbmFibGVkAP0lLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldFN0YXRpc3RpY3NFbmFibGVkANcfKXdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkVuY29kaW5nAJsZLHdyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkNvbXByZXNzaW9uAOwdMndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtbkRpY3Rpb25hcnlFbmFibGVkANccMndyaXRlcnByb3BlcnRpZXNidWlsZGVyX3NldENvbHVtblN0YXRpc3RpY3NFbmFibGVkAJwZIl9fd2JnX3dyaXRlcnByb3BlcnRpZXNidWlsZGVyX2ZyZWUAkiELcmVhZFBhcnF1ZXQAxywKcmVhZFNjaGVtYQDxLAx3cml0ZVBhcnF1ZXQAqiwRcmVhZFBhcnF1ZXRTdHJlYW0A/jUWdHJhbnNmb3JtUGFycXVldFN0cmVhbQCAMB1fX3diZ19pbnRvdW5kZXJseWluZ3NpbmtfZnJlZQDeHhhpbnRvdW5kZXJseWluZ3Npbmtfd3JpdGUAgTAYaW50b3VuZGVybHlpbmdzaW5rX2Nsb3NlAPU6GGludG91bmRlcmx5aW5nc2lua19hYm9ydACCMCNfX3diZ19pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfZnJlZQCVIR1pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfdHlwZQDyKy5pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfYXV0b0FsbG9jYXRlQ2h1bmtTaXplAIUqHmludG91bmRlcmx5aW5nYnl0ZXNvdXJjZV9zdGFydACoNh1pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfcHVsbACDMB9pbnRvdW5kZXJseWluZ2J5dGVzb3VyY2VfY2FuY2VsAM4sH19fd2JnX2ludG91bmRlcmx5aW5nc291cmNlX2ZyZWUAwCAZaW50b3VuZGVybHlpbmdzb3VyY2VfcHVsbACEMBtpbnRvdW5kZXJseWluZ3NvdXJjZV9jYW5jZWwAmSwWX193YmdfcmVjb3JkYmF0Y2hfZnJlZQCaIRNyZWNvcmRiYXRjaF9udW1Sb3dzAIkqFnJlY29yZGJhdGNoX251bUNvbHVtbnMAiioScmVjb3JkYmF0Y2hfc2NoZW1hAOcoEXJlY29yZGJhdGNoX3RvRkZJAJstE3JlY29yZGJhdGNoX2ludG9GRkkAnC0ZcmVjb3JkYmF0Y2hfaW50b0lQQ1N0cmVhbQDILBZyZWNvcmRiYXRjaF93aXRoU2NoZW1hAPIsEXJlY29yZGJhdGNoX3NsaWNlAIMmHnJlY29yZGJhdGNoX2dldEFycmF5TWVtb3J5U2l6ZQCLKhRfX3diZ19mZmlzdHJlYW1fZnJlZQCMGhNmZmlzdHJlYW1fbnVtQXJyYXlzAIwqFGZmaXN0cmVhbV9zY2hlbWFBZGRyAI0qE2ZmaXN0cmVhbV9hcnJheUFkZHIAkCQUZmZpc3RyZWFtX2FycmF5QWRkcnMAkC4OZmZpc3RyZWFtX2Ryb3AAly4UX193YmdfZmZpc2NoZW1hX2ZyZWUAyyEOZmZpc2NoZW1hX2FkZHIAjyMSX193YmdfZmZpZGF0YV9mcmVlAPAdEWZmaWRhdGFfYXJyYXlBZGRyAI4qEmZmaWRhdGFfc2NoZW1hQWRkcgCPKhFfX3diZ19zY2hlbWFfZnJlZQDxHQxzY2hlbWFfdG9GRkkAnS0Oc2NoZW1hX2ludG9GRkkAni0Uc2NoZW1hX2ludG9JUENTdHJlYW0AySwTc2NoZW1hX3dpdGhNZXRhZGF0YQDzLA5zY2hlbWFfaW5kZXhPZgDKLA9zY2hlbWFfbWV0YWRhdGEAny0Kd2FzbU1lbW9yeQC1Ow5fZnVuY3Rpb25UYWJsZQC2OxBfX3diZ190YWJsZV9mcmVlAJEkDHRhYmxlX3NjaGVtYQCjJBF0YWJsZV9yZWNvcmRCYXRjaADaGhN0YWJsZV9yZWNvcmRCYXRjaGVzAJEuEHRhYmxlX251bUJhdGNoZXMAkCoLdGFibGVfdG9GRkkAoC0NdGFibGVfaW50b0ZGSQChLRN0YWJsZV9pbnRvSVBDU3RyZWFtAMssE3RhYmxlX2Zyb21JUENTdHJlYW0A9CwYdGFibGVfZ2V0QXJyYXlNZW1vcnlTaXplAP0fGXJ1c3RfenN0ZF93YXNtX3NoaW1fcXNvcnQAuQoacnVzdF96c3RkX3dhc21fc2hpbV9tYWxsb2MAhi8acnVzdF96c3RkX3dhc21fc2hpbV9tZW1jbXAA4C8acnVzdF96c3RkX3dhc21fc2hpbV9jYWxsb2MAny4YcnVzdF96c3RkX3dhc21fc2hpbV9mcmVlANI1GnJ1c3RfenN0ZF93YXNtX3NoaW1fbWVtY3B5ANw0G3J1c3RfenN0ZF93YXNtX3NoaW1fbWVtbW92ZQDcNBpydXN0X3pzdGRfd2FzbV9zaGltX21lbXNldADdNBFfX3diaW5kZ2VuX21hbGxvYwC3KhJfX3diaW5kZ2VuX3JlYWxsb2MA4SsUX193YmluZGdlbl9leG5fc3RvcmUA+TUXX19leHRlcm5yZWZfdGFibGVfYWxsb2MA3xITX193YmluZGdlbl9leHBvcnRfNAEBE19fd2JpbmRnZW5fZXhwb3J0XzUBABlfX2V4dGVybnJlZl90YWJsZV9kZWFsbG9jAPIfFl9fZXh0ZXJucmVmX2Ryb3Bfc2xpY2UAqCwPX193YmluZGdlbl9mcmVlAPg1PXdhc21fYmluZGdlbl9fY29udmVydF9fY2xvc3VyZXNfX19fX2ludm9rZV9faGZlYzljNmMwMmY2MDQ2ZWQAoi8aY2xvc3VyZTM3ODlfZXh0ZXJucmVmX3NoaW0A/zUaY2xvc3VyZTM4MDNfZXh0ZXJucmVmX3NoaW0Amy8QX193YmluZGdlbl9zdGFydAB4CeI8AgBBAQurHvoloQGDI5gD6x3rAfsTvQHaHooG2R7hBdgeuAOEI6YGtxq3GrYathq0GrQahhqGGrUatRqzGrMatzuUNdcSmj24O7k7sivJI/sRoSnbHOor7zasNqs9iTDcO6s9yD7iNZoqhjX4O5k8uQnGLogwqTbGLsg+/CjjKJMu1wmMMIMOlTWpAZQutwmaJ8MSizCkAYowpBDXGpsB1hrVC8Im1Qy3O5Q11xK6O+sr1C/CLKEp1DSaGMkj/BG7O7c7iDerPY0wyD6yK/YuxAmWNagB9RfjAYIq0gn3LsUL9hfiAbc7lDXXErw7qjadPqMJ7Cu9O/gswSjuK787+SzAKO0rvjv6LL8ojSbrNfc61A70KP4llgG3O5Q11xLBO8I7oSm3O6s9kDDIPqsetR+VLvcMySP+EeAM6RWyK9Qt/Bi2K8EqxTvGO/Y6wDvJPswR1i32FNganAHCJtYM1hrWC7c7lDXXEsc79yvUL6Ep1DTJO/ArtzuHPdQ79iqrPZUwqzarPcg+zzvIO5Mwqz2rPZQwyD6yK4I2wwmzNr8Q2yOGI8s11C22K98K3grJC609yjvEO8M7sz3TG5Q8gCb3FKw9rz2hL48Y2RysPa49oC/dAZ0GyQfPG/8ewCqsPasP6hasPYgRiQq3O6w2kjyjJdAkgBamLfMrtzurPZkwyD6MI8cOiyPIDooj1QiII/ILiSOUCYoaihqLGosauhq6GsAVwBW7GrsatzuUNdkSyzv8LtQkySeaMK82+SrIPo0jnhD9LJswrzb9LMg+3Ry+Lqs9nTCrPdA7zjurPZwwrzarPcg+zTuzNpg1tzurPZ4wyD6rGrI2vCqCNsw7tyuiL3n6LuAfrR70K589siuWLrM2nBKCNtk7+SurPaQwsDbIPtg7+CuiML8u+iurPZ8wsDarPcg+sD37K6Ew0jv1K6Uwqz3TO/YroDCrPdY7ozCrPbgr1STaO4Q2hDa0HLc7mTXaEts7iCrqJpgo6yayK987ox+IEYoKtzusNrc7rDbhO7c7lDXZEuI71y+CKacw6Qu0NvAWtT23PYYhnT62Pdsnsj6cNoA1lCWTO806zTqBNdoq+yn/HdcMzCTXL7Ir8SWGMKw2zyvoKNkbuSt82C/QL44gjj2yPsg+rhDjI/YG0BbhI9kksDCsMLIwsTCzMKgwrjDZJKsw0CG+Nr89mzWwA541wi7DLs8hvzacNbEDnTWvMK0wpRy2NqouvT2xPqwjvjzDPJEvsj6SNvc0hyWLO646rjr4NL0sxzyvHLg2pi67PagjvTzFPM4hwDafNZsIoDWqMMEgwTbAPaE16QGiNcQuxS6pMKYcujalLr49oCPBPMY8rBy7NqkuuT20I788wjyhHLw2qC66PbAjwDzEPJUctzapLrk9myOdHLk2qC66PZ8j4R29NokUvD2xPo0hnj64PZEvkjb3NJsllzuuOq46+DS9LOw8iTWkPfc84iOgJ/0Nsh7aJNowyDC5MM0wyzC+MMMwzDC/MNUwvDDAMNgw0TDKMLYwyTC7MNcviRKLCuQ7uyueKogq4TWcPLIrmiriNbc7rDa9MIQpwTDNJtkwuS6XPsok3TDaG8kkyD7/LroEggqrPd4w1TarPcg+0y2EF6s92zDVNqs9nwSdJdwwgyvXNrU9tz2dPrY9sj7ZLcItuSbDLdQ28y3LJfQt9S35I/Yt9y3ELcUtxi34Lfkt+i37LfwtgjyBPIM8hhXgNsA9pzWIDLY1xC7FLocV4zajNf8LvjWIFd02sjWDDLM1iRXaNqU1gAy7NYoV3jaxNYQMtzWLFec2pjX8C7g1jBXZNrA1ggy1NY0V5DarNYEMtDWGFeI2rjWGDLw1hxXlNqk1hwy5NYgV4TakNf4LvTWJFd82qjX9C7o1ihXcNq81+wu1NYsV6DasNYUMtDWMFds2qDWCDLU1jRXmNq01gQy0NdAwxTDTMNQwzjDHMNIwtTC6MMIwxjDPMNYwtzDXMMQwnz7qNrE+wiqQEtAsuDDVI9Y24zvjO7M+7xugPsM9yT6yPskvxD7FPrI+7Ty3PrAq2DafFcI9tD6FIa0+iz71L64+mzb/NJUllDvLOss6gjW/LOE8pxzPNqkuuT2xPqojmhzSNqkuuT2rI8Q2uT2oHMg2qC66PZ4jlBzLNqguuj2hI8k2uj2qHM42qC66PbYjqRzMNqguuj2cI6Qc0DaoLro9uCOfHMc2qC66PacjnBzRNqkuuT2xI5YcwjaoLro9tSOTHMY2py7BPbcjqj6JPqMcyjalLr49qSOZHNM2py7BPbIjoBzNNqUuvj2mI8M2vT3FNrs9/CvJI4AS3zDrNsg+siucKp4l8BuBEv4rsivKLusVsj6qLf467BahPv4Mtj6EK+AwjhXcL8EruD6rLZguwiv9K9MSuT6aKN8pwyu3O7MvtT6oPqA+4h+rL74rvyudLOYRtz7LLq0vjA3BK9MSsS/aJawvvivBK9MSsi/ZJbsZviugEP8MqQn2C68v4x/YIqwZqQm3O+0TqD6gPswV6SiwL+QfzxGNDc0upC7BGNcvoj6mGMgovg2ePrI+5juaLusWlB2hDqQ+uj69H7UegxDcDfEUmy6SHdgNhBDdDfIUmy6QHdcN1gr0DOc7zC6RHfMMhhDWDfAUmS6THdkNhRDaDfMUmS6VHdsNoz7AEJYdsgulPrY+8x2CLbkE6AnVDac+tz6zCtQv6ifMJt4MgDu1ProrhC3yBekJ3g2mPrQKyybdDN4M3QzOLv0osiudLpwuni73O9ghtzvrKPAbgxL/K7I+yD63O6wouSvEPaEdxCvFK8crxiuALIs8+TvEPfk87zbWGdgMgD2uLuMk7zDXL/o78BuEErIr7CWGMOwouSueGukw0S7RLqUnpSekIaQhtS+1L6QnpCekJ6Qn9Cf0J7QvtC/PJs8mpSelJ9Iu0i6rIPE26TbrAv4CnhSrPfEw9TaxPqchxRDONa8psCnuNvQ2sT6mIdwBzTWtKa4p8zbYAe428jaxPqYh4QHNNa0primUFfc2yD3BNZkDxzXHLsgulRX2Nr81iBPANfw2kQGWFfo2wjWQAco1pRX5NsM1jwHGNZUV+zbFNfMCyDWWFfg2xDXyAsk18jD9Nrc97hC2Au8QqyWsJecw4jDiHe02/BTGPbE+jiGePrg9ki+yPps2/zSaJZg7yzrLOoI12iiJKOUw5DDrMK4q8DbkDcU9xz2EIcM61zyrLpo2+zSTJZE7xDrEOv402SvZKuow7jDtMOww5jDjMOgw8DCtLtY0jTyxKZ8q7yilKIk32y28Bs092S3UNr0e9jD1MIo8hC+GN4Uv7DaIPLIrhyn0MJ4e/zbkLM49sT6DIcA61TzBLbI+mTb8NJIlkjvBOsE6/TTcJu0lyhz+NuMszz2CIb861jyBN7U9tz2dPrY94RjoHqs9+DCAN8g+lTyJPKs99zCAN8g+5CO0Krc7qz35MKs9yD7dL+0V3xysPdE9vC/TAfwFhAfSG9E1yCvQPfgnjDyTFPcStha4EIUO+Q7TEbsGkBDIEuELvw2HNtoh1i65K8w1rDaoJ9cupyfYJd47qz36MMg+8CiyK98liCrcFt4t4TTgNN803jSINok2lRjiLeAt1zXYNdk12jWMNo024S3fLeU05DTjNOI0ijaLNug05zTmNOs06jTpNNs13DXdNe407TTsNPE08DTvNIgvhy/hL+Iv4y/kL+Uv5i/nL+gv6S/qL+sv7C+UPJE8vCqCNrku/TDnI9YOqz3+MIM3yD6yK5oqkzz5HZI8miq7K54qljybKpwq+BuRK6s9gjGFN8g+3juBMZc8mDybKukkqyiaPJo8mjyaPJo8mzz9As4CsAKzAZECiSzvNrc7hDHIPrIr5SXBEOI1hjCqJ94u6CW3O+M1uhGePLc74zW6EZ883y7gLuEu3jurPYUxyD7tHvwd7B6aL/sd/R3+HYos1y/XL6A82S3UNqE83CKGMY0phzGYCoo31RXVPbc9vCOrPoo+lRmyPrI+lwPEPsU+sj7uG9sgtCjcJ4s3tT23PZ0+tj3ZLdQ25DWyK4YwxRW2K9ArmBi+L74v4i7iLtcv7h6iPMQr0CvEK7kr/yPSK48g0yviFNQrkCC2K7srsivQK7ALpwvvNrMl6RKQLZAO4wukPP089iSSMZwxlTGLMZAxijGWMZcxmDGPMZExkzGTK4gxiTGbMZQxmjGdMYwxmTHdIo0xjjGLIKM34izZPbc9gSHSPNM8lBmyPpM2+TSRJY87tzq3Ovo07x/UPIogojfhLNo9gCGTN749sT7ZLdQ2syGcN9gs2z2xPvsgqz6KPug1sj6TNu4KiCWMO7c65gmVKaIs2Cu0IZs31izXPfcgyzzOPOg1vQrLCdUooizYK7UhnTfZLNY99CDJPMw86DW+CswJ0yiiLNgruCGaN9cs2D31IMo8zTzoNcAKzQnUKKIs2CuxIaE32CzbPfYg6DXvCuUJoizYK7choDfWLNc9+CDoNb8KygmiLNgrsiGeN9ks1j36IOg1oizYK7YhnzfXLNg9+SDoNaIs2CuUN7k9mTfBPY43uj2SN7k9kDe6PZY3wT2YN749kTe6PY83vT2VN7s9lze5PbIruSuyNtMr0ivDHsAxpzGhMbUx9yS8McMxvTGvMaIxxTG3MaMxrDHGMbYxuTG/MaAxnjGfMbgxszG6MbsxqzGtMaYxrjGlMaQxwjG0MbIxsDHBMfgkvjH3JLEx3iKoMaoxpTyOKcQxzSapMa83uj2xPrI+rTe9Pbo3uz28N7k9mxzEN6ouvT2kI5gctDeoLro9pSOeHLE3qC66PaMjlxypN6guuj2dI5IcqDeoLro9ryOwN7k9rje6Pb43uT2RHMM3qS65PbMjqxzCN6guuj26I60cxjepLrk9riOuHLI3qC66PaIjohy5N6guuj25I7ActzepLrk9rSO/N7o9qje6Paw3uj3BN7o92S3UNsc3xj2xPp4+uD3LN7U9tz2dPrY9yjfZPbc9yTfaPd0dpjfpLNw9sT6JIdM6xDzHLZM2+TSWJZU7tzq3Ovo0sSrnPOAdpDfnLN09iiHUOsM8sze+PcA3uT21N749qze6Pbs3wT3FN8E9vTe+Pbg3uT22N7o9zDfCPbw+yDe8PbE+nj64Pd4dpTfoLNw9hyHfHac35izdPYghxB7PMdox+STfMdUxyzHcMdIx2zHIMcoxxzHJMd0x2DHeMdMxzjHUMc0xzDHhMdkx1zHWMeAx3yLQMaY8zSbRMc033D2xPrI+uiz2N6AUqTzON909uyyoPOY32j23Pbc75TXcEu481De6PbE+2Te5Pd83uT3bN8E93De+Pdc3uj3QN7o92je6Pdg3uT3iN7k94Te6PdY3vj3lN7k95DfBPdM3uT3SN7o93je6PeA3uj3PN7o90Te6PeM3vT3dN7k91Te6Pec3wj29PrIr0iu5K9Mr7zaBDfok6THvMesx5DHnMeMx4jHsMe0x7jHmMegx5THqMac86Te9PbE+sj7wN7s98je5Pes3uj3tN7498ze+Peo3uj3vN7k96De6Pew3uT31N8E98TfBPe43uj30N7k9+QaRLeMu0yuSJ/o86C3MGcI05y3yNZMv5jX3BtArnDzZLdQ21y+qPLssuiyPJrkr0yv/PK8qsiWyJdom2ibZJtkm2SbZJsEvwS/CL8Ivwy/DL8QvxC/BL8Ev2ibaJsMvwy/CL8Iv5C7kLtML0wvAL8Avwi/CL8AvwC/DL8MvwC/AL/sk8THFHvAx8jGrPPk3zz2xPrI++DfOPfc3xj2xPp4+uD3ZLdQ2rzzfPOMU7za3O+U13BKuPIgRjwqsNqMa8zHZLdQ2/TfFPcc9sj78N5Imuye+J7MnoSapPpEmxh6UJpcmtyemJp8mmCOvJ8cemSa6J7AnoiaeJpojuSeYJpAmrie4J78nqSakJrUnqyaoJtEqnSa9J6w8lyOjJsQksSeZI60nmiaVJvs3rCaXJpwmshmgJrwnmyaWJqUmqia0J7InmianJpMmtifIHvcxiTL1MaUy/iSCMqIy/DH4MZYyizKRMqMymzKrMooy/jGFMvkxgDL/MacyjDL2MZgynTKTMpQy9DGIMpcylTKkMpAyqjKNMoQy/ySaMpwrpjKpMqEyjzL6MY4ymTKcMv4koDLyIv0xrDLJHpIyhjKwPM8jqDLzIoEykCmHMs0mnzKtJp4ygzL7MZ44wT2xPrI+kTi+PZQ4uT2IOLo9kjjBPZc4vj2LOLk9mzi6PZU4vj2gOLk9nTi6PYw4uj2cOLo9mTi6PZA4uj2fOLk9gji6PY04vT2TOLk9jzi6PYY4vT2KOLs9szjCPb4+hDi6PY44uj2FOLo9gzi6PZg4uT2HOLo9iTi5PZo4uT2WOLo9oTi6Pf833D2xPqs4vD2xPp4+uD2BON09rDjZPbc9gDjcPf433T2tONo9rzjOPaI4xj2xPp4+uD2uOM89sji1Pbc9nT62PbE41T23PbI+2S3UNqg42z2xPqY41z2pONY9pzjYPaQ42z2qONc9pTjWPaM42D2wOMU9xz2MH7Y42izgPbE+/CCdPrY96TWsPrMIxD7FPrI+6xuNLI4soiuNH7Q42yzhPf4gsgjtG44ftTjcLOI9/SCxCOwbniqaKoAlrTKxPNkt1Da3OLk9sT6yPpw7yh6xMsIyrzLcMoEluzLZMrYysjLPMsQyyjLaMtMy4TLDMrgyvjKzMroyuTLeMsUysDLRMtUyzDLNMq4ywTLQMs4y2zLJMuAyxjK9Mp0r3TLfMtgyyDK0Mscy0jLUMvQitzLiMsseyzK/MtcvtzvlNdwSsjyzPJEpwDLNJtcyrybWMrwytTLkONk9tz2yPuU42j3jONc9sT7cONg94TjbPd042z3iONY93jjWPd841z3gONg95jjPPbE+5zjOPcA4vT2xPtE4vj3VOLo9wji6PdQ4uT3KOLo9zDjBPdo4uT3JOLo91ji6Pc84vj29OLo92Ti5PcM4uT3HOL09xTi5PdA4uj3BOLo9zji5Pb84uj3TOLo9xDi7Pb44uj3GOLo92zi6PdI4uT28OLo9zTi5Pdg4wT3XOLo9yDi6Pcs4vj3pOMI9vz65ONw9sT66ONw9uzjdPbg43T3oOLU9tz2dPrY96jjhPbE+sj7rOOI97DjgPdkt1DbMHuYy9zLkMpEzgiXxMo4z6zLnMoMz+TL/Mo8zhzOWM/gy7TL0Mugy7zLuMpMz+jLlMoUziTOAM4Ez4zL2MoQzgjOQM/4ylTP7MvMyniuSM5QzjTP9Muky/DKGM4gzgiWMM/Ui7DKXM7U89iLwMpIp9TLNJoszsCaKM/Iy6jKNOcE9sT6yPoA5vj2DObk99zi6PYE5wT2GOb49+ji5PYo5uj2EOb49jzm5PYw5uj37OLo9izm6PYg5uj3/OLo9jjm5PfE4uj38OL09gjm5Pf44uj31OL09+Ti7PZ45wj3APvM4uj39OLo99Di6PfI4uj2HObk99ji6Pfg4uT2JObk9hTm6PZA5uj3uONw9sT6ZObw9sT6ePrg98DjdPZo52T23Pe843D3tON09mznaPZ05tT23PZ0+tj2cOdU9tz2yPpY52z2xPpQ51z2XOdY9lTnYPZI52z2YOdc9kznWPZE52D2hOeA9sT6fOeE9oDniPeUs1iq0PLQ87T35Kek97D3JPus96j25PLo8uzzkPeY95T3oPec92S3UNrUltjzDEcURwhHEEc0emzOpM5kzwDODJaQzvTOfM5wztTOrM7EzvjO5M8UzqjOhM6YznTOjM6IzwjOsM5oztzO7M7IzszOYM6gztjO0M78zsDPEM60zpTOfK8EzwzO8M68znjOuM7gzujP3IqAzxjOTKacz2S3UNqk5uj2xPrI+uDm5Pac5uj28Obk9uzm+PbU5vj26Obo9rTm5PbI5uj2zObo9sDm6PbY5wT3BObo9qDm6Pb45uT23Obk9uTm+Paw5uj2uObs9wDm6PcM5uT2/Obo9wjnBPb05uj3FObo9rzm5PcQ5uT2rObo9sTm9PbQ5uj2mObo9qjm9PaM53D2xPqI53T2kOdw9pTndPc051z2xPso52D3LOds9xjnYPcc52z3MOdY9yTnXPcg51j3POdo9tz3OOdk90Dm1Pbc9nT62Pbc8uDy8PIgRkAq3O6w2nyqbKsU07za5K80m2TPOHuAz1jPfM8kzoCv9M4I07jPrM9cz/zPoM/szhCX8Ofk9sT6yPv459z36Ofk9+DnxPeU59z2BOvA9+znxPe458D2EJYA0hSXzM88e2zPjM9Ej/jP2M80z6TP0M9ozzjPcM9Ez/DP5M+YzzzPIM+8z2DP3M8wz4jPwM+Ez9TPHM+oz8TPKM9Az5TP4M+wz5DPtM+cz3TPSKIE0sCHTM7Im3jPSM/oz+CLyM8szyRnUM9Uz5DnjO8M+oD7DPck+sj7SOfw9wj70Ofk98DnxPek58D2AOvA99TnwPew58D32OfA9hDrxPfE58D2COvE97znxPfI58D2DOvA96jnwPe058D3mOfA9/znwPes58T33OfA9+Tn+PdU57j2xPt857z2xPp4+uD3WOfQ9izr/Pbc91DnuPdM59D2KOoM+4jmEPqMejTqDEYc+sT6MIeg86jyjLJ02gzWXJZY71zrXOoQ1miTUI+A5gj6xPp4+uD3hOfI9zByMOoQRgD6LIek86zyFOvg9tz2dPrY9hjqIPrc91zmFPrE+3TnzPds59T3YOfs93jmFPtw58z3ZOfU92jn7Pec58T3oOfA9/Tn+PfM5hj7jOfY9xz2JOoE+sT6IOv09hzr6PYYlhzSWNJ00jTSINI40izSiNKE0lDSJNIQ0mjSMNJ80hjSRNJs0kDSeNIM0lzScNIU0ijSTNKA0mDSSNJk0lTSPNJA68T2xPrI+njrwPag68D2XOvA9kTrwPZ06+T2qOvA9mzrwPZM68D2iOv49jzrwPaM6+T2fOvA9nDqGPqU6+T2hOvE9pDrxPaY6/j2YOvE9rTrxPZY68D2gOvA9mTrxPac69z2rOvE9lDrxPZI68D2pOvA9jjr3PZU68D2sOvA9mjrwPcg8yRyoNKo0pjSlNKM0qTSkNKc0szr1PbE+sDr7PbY6hT61OvM9tDrzPbI6+z2xOvU9rzqFPsc6xTrIOpQ2lTbJOs88tCasNKs0rTS6OoE+sT6yPrg6+j25Ov091B+3O+U13BLQPNML0wv5IrE0sDS7OoM+tz2yPrw6/z2IEZEKtzusNtAesjSzNL068j2xPrI+vjqEPtIjtDTCOvY9xz3GOuA8iBGSCrc7rDbNJrU0yjr8PcY+2Ci2NMw6+D23PZ0+tj2yPtco3TziPNcvuSG3NM46iD63PbI+iBGTCrc7rDbRHr00uzS8NLg00DruPbE+sj7POvQ90TruPdI69D3LGbk0ujTVOoA+sT7WOoc+iBGUCrc7rDaZJcA02DrvPbE+nj64PZglvjTZOoI+sT6ePrg9vzTaOuM7xz6gPsM9yT6yPuo1wRLeO+w1xhH6Bus1kCyIEZUKtzusNuYu6C3nLe010CuUPMs+6B2+I7shuiG8IYsWhB2MFr0hnCSyKtsr3Cu+IawK3RTxPIgRlgq3O6w2siubO/UUyj7KPpo7xRLbOq0PmTuZO/AlkSfeJpkZmRmYGZgZmRmZGZYZlhmXGZcZmhmaGZgZmBnmGeYZ3TrqENw66RDdOuoQ3zqFEd466xDcOukQ3jrrEN86hRHlFbIriBeIF7wYvBilLI0TpiyOE+E6wA7gOr8O8zzQJdElzD7MPrYotijIFcgV4jrDCqcs1wHwPPY88jzuNe825y7oLect7zXQK4Ua6C7oLect8DXQK947rDbPDPsGxD3TK6ARgT3+PO823juzKrIr4TWUPN478TXIEYI9+DzjOsQ0+zyKNfw86S7oLect8zXQK947rDbSDPwGxD3TK+ou6C3nLeYM0CuLNcY03jvxNcgRgz3gJsc0yD6CGYQ9tzuIN4U91C+IPYk9jD22HLIrjT2yPsg+2CP0JekZti7fK50kyCeaGuArxynoOuk6oDuPPsgpwBj0FqE7kD63K8stnySAI6Ak/yLrLo4o7xOvFn2WL8QswSO5KJkpvCr2NeQOyjTLNMw0zTR70i+XL+4u7y7wLu4u7y7uLu0u7C6EJLgueu828RfeO/o1yhHoFqYa0y+bPZUs7zazNsEhnDzDI8EmpBGcPfwv+i+ePfsvlyfLEZ09uSvyLqw2sjb5L880zjTxOp4p8DrXO/Eu6h3WEvIXqz2ZL/YlmC/7L+Qn+hGgPaE9oj3TEMUspj2lPYI28jrzOuMroxvTHPw1tDuqPcwKjyinPeIowhKoPQBBrB4LAv81my8MApwqCom5zALPPcD5AgQffwd+AX0BfCMAQZAEayIFJAAgBSADNgKsAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAABBAmsOJQECAwQFBgcICQoLDA0ODxAAABYRFwAYGQAAAAAAAAAAABITFBUACyAFQQE2ArQBIAVBnLH/ADYCsAEgBUIBNwK8ASAFQa8DNgLUAiAFIAVB0AJqNgK4ASAFIAVBrAFqNgLQAiAFQcADaiAFQbABahCZDiAAQYKAgIB4NgIAIAAgBSkCwAM3AgQgAEEMaiAFQcgDaigCADYCAAwxCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgR4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNLyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NNyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCjKAsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAUgBUGwAWogCCACEIcLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTwgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0zIAVBiANqELsjDDMLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwtCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgx4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNKyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NNyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTsgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0yIAVBiANqELsjDDILIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwrCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQih4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNKSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NNyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBGGogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTkgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0wIAVBiANqELsjDDALIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwnCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNJSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCCACEIYLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTggBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0vIAVBiANqELsjDC8LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwlCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNIyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NMyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBMGogBUGwAWogCCACEIoLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0tIAVBiANqELsjDC0LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwhCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNHyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMCAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCCACEIILDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgARPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTUgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0sIAVBiANqELsjDCwLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwfCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiD0UNHSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NMCAFIAooAhAgA0ECdGoqAgAiKzgC0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCrDCEkIAUoArABIgRBCGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAHICR6p0EDdiACaiAIcSIMQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogKzgCACAFIAFBAWo2AowCIAVByABqIAVBsAFqICsgAhCMCwwBCyAEQQAgDGtBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY7AQQgAEGQgICAeDYCACAOELItIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPMeIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCABE8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNMyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSogBUGIA2oQuyMMKgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDBsLIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCULIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN4JDCQLIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCMLIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN4JDCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN4JDCELIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgYgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMIQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwVCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPMeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNEyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAVBwANqIQ0gBSgCWCETIAUoAlwhDyMAQTBrIgQkAAJAIA8gBUGwAWoiAigCMEYEQCMAQUBqIgYkACAGIA82AgQgBiATNgIAIAIgEyAPEM0CISQgBiACQTBqIgE2AjwgBiACQegAaiIYNgI4IAYgBjYCNCAGIAE2AhAgBiAYNgIMIAYgAjYCCCAGQRhqIQwgBkE0aiEQIAZBCGoiHyEBQQAhC0EAIRFBACEUQQAhGUEAIRojAEEgayIOJAAgAkEgaiIKKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAKKAIMIghBAWoiCSAITwRAAkAgCigCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAJSQRAAkACQCAIQQFqIgsgCSAJIAtJGyILQQ9PBEAgC0H/////AUsNAUF/IAtBA3RBB25BAWtndkEBaiELDAILQQRBCEEQIAtBCEkbIAtBBEkbIQsMAQsQ3ScgASgCHCELIAEoAhgiCUGBgICAeEcNBAsgAUHQAGogCkEQaiIHQQQgCxD7FCABKAJYIQsgASgCVCEJIAEoAlAiCEUNAyABIAEoAlw2AkwgASALNgJIIAEgCTYCRCABIAg2AkAgAUEQaiABQUBrEME0IAEoAhQiCwRAIAEoAhBB/wEgC/wLAAsgASgCSCELIAEoAkQhCSABKAJAIghFDQMgASABKAJMNgI8IAEgCzYCOCABIAk2AjQgASAINgIwIAFChICAgIABNwIoIAEgBzYCJCABQTBqISAgASAKKAIMIhwEfyAIQQhqISEgCigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgEUEIaiERIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIHKAIAIRUgAUEIaiAHKAIEIAcoAggoAgAgCigCACAleqdBA3YgEWpBAnQiImtBBGsoAgAQyiUgCCAJIBUgASgCCCABKAIMEM0CpyIjcSIHaikAAEKAgYKEiJCgwIB/gyImUARAQQghFQNAIAcgFWohByAVQQhqIRUgCCAHIAlxIgdqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCCAmeqdBA3YgB2ogCXEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiAjQRl2IhU6AAAgISAHQQhrIAlxaiAVOgAAIAggB0ECdGtBBGsgCigCACAia0EEaygAADYAACAcQQFrIhwNAAsgCigCDAVBAAsiCTYCPCABIAsgCWs2AjggCiAgQQQQ+iogAUEkahD1JwwBCyAKIAFBIGpB0OCAARDuCQtBgYCAgHghCQwBCxDdJyABKAIEIQsgASgCACEJCyAbIAs2AgQgGyAJNgIAIAFB4ABqJAALIAooAgQiCyAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEHIBAoAgQhESAQKAIAIQggCigCACEJA0ACQCABIAlqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIAwCfgJAA0AgJVANASAOIBEgBygCACAKKAIAICV6p0EDdiABaiALcSIVQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCCgCACAIKAIEIA4oAgAgDigCBBCfO0UNAAsgDCAkNwMIIAwgCigCAEEAIBVrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIAtxIRQLQQEgJSAmQgGGg1ANAhogDCAJIBRqLAAAQQBOBH8gCSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAUCzYCECAMICQ3AwhCAQs3AwAgDCAKNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiALcSEBDAELCyAGIA82AjwgBiATNgI4IAYgGDYCNCAfIAwgEBCLEyAGKAIQQQRrKAIAIQEgBkGQgICAeDYCGCAEQQRqIgogAUH//wNNBH8gDBCIEUGTgICAeAVBkICAgHgLNgIAIAogATsBBCAGQUBrJAAgBC8BCCEGIAQoAgQiAUGTgICAeEcEQCANIAQpAQo3AQYgDUEMaiAEQRBqKQEANwEAIA0gBjsBBCANIAE2AgAMAgsCQCACKAJABEAgAigCUCILQQFqIglBA3YgCUEHcUEAR2oiASACKAJMIgpLBEAgASAKayEOIAIoAkQiCCABSQRAIAJBQGsgCEEBdCIKIAFBwP///wNxQUBrIAEgAUE/cRsiCCAIIApJGxDoGSACKAJMIQoLIA4EQCACKAJIIApqQQAgDvwLAAsgAiABNgJMCyACIAk2AlAgAigCSCALQQN2aiIBIAEtAABBASALQQdxdHI6AAAMAQsgAiACKAJUQQFqNgJUCyACKAI8IgEgAigCNEYEQCACQTRqQci1gAEQrSgLIAIoAjggAUEBdGogBjsBACANIAY7AQQgDUGTgICAeDYCACACIAFBAWo2AjwMAQsgBCAPNgIcIARBAjYCCCAEQaC3gAE2AgQgBEICNwIQIARBOzYCLCAEQZwDNgIkIAQgAkEwajYCICAEIARBIGo2AgwgBCAEQRxqNgIoIA1BBGogBEEEahCZDiANQY2AgIB4NgIACyAEQTBqJAAgBSgCwAMiAUGTgICAeEYNASAAIAUpAcYDNwEGIABBDGogBUHMA2opAQA3AQAgACAFLwHEAzsBBCAAIAE2AgAgBUHQAWoQjjsgFxCyLSAFQZgCahCKLwwXCyAWEOY6IAUoAvABRQ0qIAUoAoACQQFqIgJBA3YgAkEHcUEAR2oiASAFKAL8ASIESwRAIAEgBGshBiAFKAL0ASIKIAFJBEAgFiAKQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIKIAQgCksbEOgZIAUoAvwBIQQLIAYEQCAFKAL4ASAEakEAIAb8CwALIAUgATYC/AELIAUgAjYCgAIgBSgC7AEiASAFKALkAUYEQCAXQYCd/wAQrSgLIAUoAugBIAFBAXRqQQA7AQAgBSABQQFqNgLsAQsgHiADQQFqIgNHDQALDBMLIAMtAAIhEiADLQABIRMgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDBILIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIgeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPMeIAFBxABqIAMQnx4gAUH4AGpBpLWAARClKyABKQOAASEmIAEpA3ghJwJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISVBACEDDAILIAEpAoABISUgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCElIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJjcDGCACICc3AxAgAiAlNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhBFDRAgBUHcAWohCSAFQdABaiEOIAVBkAJqIREgBUGEAmohDSAFQcABaiEUQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDSggBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBQgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiFSAESQRAIBEgFUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFSABIBVLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQfAAaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCABE8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf//A3EhAkGQgICAeCEBIANBAUcNFSAFQYgDahC7IwwVCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgEEcNAAsMEAsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMDwsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjR4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8x4gAUHEAGogAxChHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiE0UNDSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NKCAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgESAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBgAFqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0rIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBDzHiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgIAETw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0qIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0QtS0gBUGwAWpBIEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0PIAVBiANqELsjDA8LIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwKCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwJCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCAHiIKQQxqIgsQ3DwhBCALENw8IQMjAEGQAWsiASQAIAFBEGogBBDzHiABQcQAaiADEKIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEwQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDcPCITRQ0HIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDcPCADTQ0MIAooAhAgA0EFdGoiASkDACEkIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICQ3A8ADAkACQAJAIAUoArwBRQ0AIBEgBUHAA2oQrQwhJSAFKAKwASIEQTBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEBA0AgAiAEaikAACIpICqFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVBwANqQSAgByAleqdBA3YgAmogCHFBUGwiDGpBIBCfOw0EICVCAX0gJYMiJVBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiBCAFKAKEAkYEQCANELIoCyAFKAKIAiAEQQV0aiIBICg3AxggASAnNwMQIAEgJjcDCCABICQ3AwAgBSAEQQFqNgKMAiAFQaABaiAFQbABaiAkICYgJyAoIAIQlwoMAQsgBCAMakEQaygCACECCyAFQZCAgIB4NgLQAiACQYCABE8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCyLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf//A3EhAkGQgICAeCEBIANBAUcNDCAFQYgDahC7IwwMCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMBwsgASACKAIcEQQAQdSw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZSo0KABNgIAIANClKjQoMGChYoUNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIEKQnrPu2bSNkukAhSADKQMoQoj0q4HgscXkwgCFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhASADKAIgQQFGDSYgAygCKCICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQSBqIAIQ0zoQ8ykgAhDTOiIOBEAgA0HcAGohCiADQdAAaiELQQAhBANAAkAgAiAEEJYlRQRAIANBCGogAiAEEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQ1w8gAygCuAEiBkGTgICAeEYNASAAIAMpAb4BNwEGIABBDGogA0HEAWopAQA3AQAgACADLwG8ATsBBCAAIAY2AgAgARCOOyALELItIANBhAFqELosDAQLIAoQ5jogAygCXEUNKSADKAJsQQFqIglBA3YgCUEHcUEAR2oiASADKAJoIgZLBEAgASAGayENIAMoAmAiCCABSQRAIAogCEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiCCAGIAhLGxDoGSADKAJoIQYLIA0EQCADKAJkIAZqQQAgDfwLAAsgAyABNgJoCyADIAk2AmwgAygCWCIBIAMoAlBGBEAgC0GAnf8AEK0oCyADKAJUIAFBAXRqQQA7AQAgAyABQQFqNgJYCyAOIARBAWoiBEcNAAsLIANBuAFqIgIgA0EgaiIEEOIRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCyLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCcLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMHAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEPMpIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0nIAMoAsgBIgJBvrX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NLCADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIAMoAsABIAEQrB8gA0GsAWogA0EQaiADKAIAIAMoAgQQ1w8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJyADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEOIRQdAAQQQQrTYiAUUNJSABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuiwgA0GQAmokAAwbCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlqzYsAE2AgAgA0KWrNiw4cKFixY3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQsKM9/bqy9zRhH+FIAMpAyhC5ZP0mPmv+Oiof4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJSADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDUOhDwKSACENQ6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ8hYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDbDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuywMBAsgChDmOiADKAJcRQ0oIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ2xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJgsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwbCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSYgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0rIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDbDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0mIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ2xFB0ABBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC7LCADQZACaiQADBoLIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGYsODAATYCACADQpiw4MCBg4aMGDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCx9n0597Etpx3hSADKQMoQo2yzpSMypLmp3+FhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhASADKAIgQQFGDSQgAygCKCICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQSBqIAIQ0zoQ8ykgAhDTOiIOBEAgA0HcAGohCiADQdAAaiELQQAhBANAAkAgAiAEEJYlRQRAIANBCGogAiAEEP8WIANBuAFqIANBIGoiASADKAIIIAMoAgwQ3g8gAygCuAEiBkGTgICAeEYNASAAIAMpAb4BNwEGIABBDGogA0HEAWopAQA3AQAgACADLwG8ATsBBCAAIAY2AgAgARCOOyALELItIANBhAFqELosDAQLIAoQ5jogAygCXEUNJyADKAJsQQFqIglBA3YgCUEHcUEAR2oiASADKAJoIgZLBEAgASAGayENIAMoAmAiCCABSQRAIAogCEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiCCAGIAhLGxDoGSADKAJoIQYLIA0EQCADKAJkIAZqQQAgDfwLAAsgAyABNgJoCyADIAk2AmwgAygCWCIBIAMoAlBGBEAgC0GAnf8AEK0oCyADKAJUIAFBAXRqQQA7AQAgAyABQQFqNgJYCyAOIARBAWoiBEcNAAsLIANBuAFqIgIgA0EgaiIEENQRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCyLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCULIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGgsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEPMpIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCq5iR8ZX61fyAf4UgAykDyAFClpT4q/Cx6bPhAIWEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJSADKALIASICQZC1/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSogAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADQcABaiABEK0qIANBrAFqIANBEGogAygCACADKAIEEN4PIAMoAqwBIgFBk4CAgHhGDQEgACADKQGyATcBBiAAQQxqIANBuAFqKQEANwEAIAAgAy8BsAE7AQQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSUgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCtKAsgAygCRCABQQF0akEAOwEAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDUEUHQAEEEEK02IgFFDSMgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELItIANB9ABqELosIANBkAJqJAAMGQsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZmy5MgBNgIAIANCmbLkyJGjxowZNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELT2NP4/eb2kkiFIAMpAyhCotieiOGg6unMAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNIyADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDUOhDwKSACENQ6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDaDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuywMBAsgChDmOiADKAJcRQ0mIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ3BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwZCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0kIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKSADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2g8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJCADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENwRQdAAQQQQrTYiAUUNIiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuywgA0GQAmokAAwYCyABIAUoArgBQdCg/wAQ/S8ACyAFIAoQ/zs2AqADDBsLIAUgChCAPDYCoAMMGgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2hQgAUE0aiIJIAJBIGoQzxQCQEEMQQQQrTYiAwRAIANCh46cuPDgwYMHNwIAIANBCGpBh46cODYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDSIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNIyACIApBMPwKAAAgBCACEIY+IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ8IIAFBkANqJAAMAQsMIQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQti0gC0EwQRAQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfim/wA2AswCIAUgATYCyAIgBUGYAWogBUHIAmoQlCsQ3yECQAJAIAUoApgBIgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUH0tP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAKcARCAFSAFQbABaiACIBIgDxCjEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFyAFQcgCahC7IwwXCyAFQc8DaiIEIAVBwAFqIgYpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIKIAVB0AFqKQIANwMAIAVBmANqIgsgBUHYAWopAgA3AwAgBUGoA2oiCSACKQMANwMAIAVBrwNqIg0gBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRwgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogCSkDADcAACABQRhqIA0pAAA3AAAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACAFQbABaiAEIAFB1LL/ABDzCSAFLQD0ASIDQQJGBEAgBUHQA2ogBigCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFyAFQcgCahC7IwwXCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0WIAVByAJqELsjDBYLDB4LDB0LIAAgJDcCDCAAIAM2AgggACACNgIEIAAgATYCAAwTCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDTFCABQTRqIgkgAkEgahDPFAJAQQxBBBCtNiIDBEAgA0KHjpy48ODBgwc3AgAgA0EIakGHjpw4NgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNICAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPk9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0hIAIgCkEw/AoAACAEIAIQ/j0gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQnwggAUGQA2okAAwBCwwfCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCyLSAFQYQCahC1LSALQSBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB+Kb/ADYCzAIgBSABNgLIAiAFQYgBaiAFQcgCahCUKxDdIQJAAkAgBSgCiAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQYi1/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAowBEIAVIAVBsAFqIAIgEiAPEKETIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0VIAVByAJqELsjDBULIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUH8sf8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0VIAVByAJqELsjDBULIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRQgBUHIAmoQuyMMFAsMHAsMGwsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBELIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENIUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0eIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDR8gAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDB0LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELQtIAtBEEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUH4pv8ANgLMAiAFIAE2AsgCIAVB+ABqIAVByAJqEJQrEOIhAkACQCAFKAJ4IgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUHgtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJ8EIAVIAVBsAFqIAIgEiAPEKITIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUGksf8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADA8LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENcUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0cIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDR0gAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBsLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELMtIAtBCEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUH4pv8ANgLMAiAFIAE2AsgCIAVB6ABqIAVByAJqEJQrEN4hAkACQCAFKAJoIgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUGQtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJsEIAVIAVBsAFqIAIgEyASEKATIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUGss/8AEPMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsMGAsMFwsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADA0LIAVBwANqIQQjAEGQA2siASQAIAVBsAFqIgJBIGoQlzYgAUEIaiIKIAJB6ABqEMcUIAFBQGsiBiACQTRqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAigCMCELQQxBBBCtNiICRQ0aIAIgCzYCBCACQRU6AAAgASACNgJ4IAEgAzYCdCABQSI6AHAgAUHYAWoiAyAGEPk9IAFBtAJqIgIgAxChGyADIAIgAUHwAGoQjBhBxABBBBCtNiIGRQ0bIAYgChDvPSABQQE2ArwCIAEgBjYCuAIgAUEBNgK0AiABQfwAaiIGIAMgAhD8IiACIAYQzRwgBCACEJ8IIAFBkANqJAAMAQsMGQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARByAD8CgAAIABB+Kb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCOOyAFQeQBahCyLSAFQZgCahCKLyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQ0gBUHQAmoQuyMMDQsMFQsgBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVB0AJqELsjDAsLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENgUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0YIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRkgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBcLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVBiANqELsjDAsLDBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM0UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0XIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRggAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENUUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0WIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRcgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBULQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0JIAVBiANqELsjDAkLDBELIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENkUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0VIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRYgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBQLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAVBiANqELsjDAgLDBALIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENQUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0UIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRUgAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM8UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0TIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRQgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBILQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAVBiANqELsjDAYLDA4LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENEUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0SIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRMgAiAKQTD8CgAAIAQgAhD3PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBELQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAVBiANqELsjDAULDA0LIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENsUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0RIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRIgAiAKQTD8CgAAIAQgAhDwPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENAUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0QIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDREgAiAKQTD8CgAAIAQgAhDxPSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA8LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0DIAVBiANqELsjDAMLDAsLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM4UIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0PIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDRAgAiAKQTD8CgAAIAQgAhD5PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA4LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfim/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsi0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAVBiANqELsjDAILDAoLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENYUIAFBNGoiCSACQSBqEM8UAkBBDEEEEK02IgMEQCADQoeOnLjw4MGDBzcCACADQQhqQYeOnDg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0OIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDQ8gAiAKQTD8CgAAIAQgAhD3PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCfCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEH4pv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELItIAVBhAJqELEtIAtBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgChCjPDYCoAMMAwsgBSAKEP47NgKgAwwCCyAFIAoQ/Ds2AqADDAELIAUgChD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgASADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAEgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQALwPkCBB9/B34BfQF8IwBBkARrIgUkACAFIAM2AqwBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADDELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwxCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCBHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0vIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw03IAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKMoCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBSAFQbABaiAIIAIQhwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTQgBUGIA2oQuyMMNAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwwCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCOHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0tIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ03IAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEIaiAFQbABaiAIIAIQgwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTIgBUGIA2oQuyMMMgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCsLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwuCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCKHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPgeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0pIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ03IAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUEYaiAFQbABaiAkIAIQiwsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTEgBUGIA2oQuyMMMQsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCkLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwtCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCLHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0nIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw0zIAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKkZCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBUEgaiAFQbABaiAIIAIQiQsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS8gBUGIA2oQuyMMLwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCULIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwrCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCMHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0jIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0zIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEwaiAFQbABaiAIIAIQigsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS4gBUGIA2oQuyMMLgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCMLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCHHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0hIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0zIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUE4aiAFQbABaiAkIAIQhQsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYCAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOwEEIABBkICAgHg2AgAgDhCyLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSwgBUGIA2oQuyMMLAsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDB8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwoCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCEHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEPEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIPRQ0dIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0wIAUgCigCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKsMISQgBSgCsAEiBEEIayEHIAUoArQBIgggJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAcgJHqnQQN2IAJqIAhxIgxBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiArOAIAIAUgAUEBajYCjAIgBUHIAGogBUGwAWogKyACEIwLDAELIARBACAMa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjsBBCAAQZCAgIB4NgIAIA4Qsi0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0rIAVBiANqELsjDCsLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwdCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgh4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ9R4gAUHEAGogAxD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNGyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMCAFIAooAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCEkIAUoArABIgRBEGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAHICR6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogLDkDACAFIAFBAWo2AowCIAVB0ABqIAVBsAFqICwgAhCECwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgIACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY7AQQgAEGQgICAeDYCACAOELItIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQrSgLIAUoAtQBIAFBAXRqIAI7AQAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ3wkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ9R4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakHw34ABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf//AU0EfyAMEIgRQZOAgIB4BUGQgICAeAs2AgAgCiABOwEEIAZBQGskACAELwEIIQYgBCgCBCIBQZOAgIB4RwRAIA0gBCkBCjcBBiANQQxqIARBEGopAQA3AQAgDSAGOwEEIA0gATYCAAwCCwJAIAIoAkAEQCACKAJQIgtBAWoiCUEDdiAJQQdxQQBHaiIBIAIoAkwiCksEQCABIAprIQ4gAigCRCIIIAFJBEAgAkFAayAIQQF0IgogAUHA////A3FBQGsgASABQT9xGyIIIAggCkkbEOgZIAIoAkwhCgsgDgRAIAIoAkggCmpBACAO/AsACyACIAE2AkwLIAIgCTYCUCACKAJIIAtBA3ZqIgEgAS0AAEEBIAtBB3F0cjoAAAwBCyACIAIoAlRBAWo2AlQLIAIoAjwiASACKAI0RgRAIAJBNGpByLWAARCtKAsgAigCOCABQQF0aiAGOwEAIA0gBjsBBCANQZOAgIB4NgIAIAIgAUEBajYCPAwBCyAEIA82AhwgBEECNgIIIARBoLeAATYCBCAEQgI3AhAgBEE7NgIsIARBnAM2AiQgBCACQTBqNgIgIAQgBEEgajYCDCAEIARBHGo2AiggDUEEaiAEQQRqEJkOIA1BjYCAgHg2AgALIARBMGokACAFKALAAyIBQZOAgIB4Rg0BIAAgBSkBxgM3AQYgAEEMaiAFQcwDaikBADcBACAAIAUvAcQDOwEEIAAgATYCACAFQdABahCOOyAXELItIAVBmAJqEIovDBcLIBYQ5jogBSgC8AFFDSogBSgCgAJBAWoiAkEDdiACQQdxQQBHaiIBIAUoAvwBIgRLBEAgASAEayEGIAUoAvQBIgogAUkEQCAWIApBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgogBCAKSxsQ6BkgBSgC/AEhBAsgBgRAIAUoAvgBIARqQQAgBvwLAAsgBSABNgL8AQsgBSACNgKAAiAFKALsASIBIAUoAuQBRgRAIBdBgJ3/ABCtKAsgBSgC6AEgAUEBdGpBADsBACAFIAFBAWo2AuwBCyAeIANBAWoiA0cNAAsMEwsgAy0AAiESIAMtAAEhEyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMEgsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiB4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ9R4gAUHEAGogAxCfHiABQfgAakGktYABEKUrIAEpA4ABISYgASkDeCEnAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJUEAIQMMAgsgASkCgAEhJSAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISUgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAmNwMYIAIgJzcDECACICU3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEEUNECAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohESAFQYQCaiENIAVBwAFqIRRBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NKCAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgFCAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIVIARJBEAgESAVQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIVIAEgFUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVB8ABqIAVBsAFqIAggAhCICwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgIACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0sIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD1HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSsgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4Qsi0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH//wNxIQJBkICAgHghASADQQFHDRIgBUGIA2oQuyMMEgsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBNHDQALDA0LIAMtAAIhDyADLQABIRIgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDAwLIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIYeIgpBDGoiCxDaPCEEIAsQ2jwhAyMAQZABayIBJAAgAUEQaiAEEPUeIAFBxABqIAMQoB4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQSBBEAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENo8IhNFDQogBUHcAWohCSAFQdABaiEOIAVBkAJqIRAgBUGEAmohDSAFQcABaiERQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENo8IANNDQwgCigCECADQQR0aiIBKQMAISQgBSABKQMIIiY3A9gCIAUgJDcD0AICQAJAAkAgBSgCvAFFDQAgESAFQdACahCwDCElIAUoArABIgRBIGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hKEEAIQEDQCACIARqKQAAIicgKIUiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBECAHICV6p0EDdiACaiAIcSIMQQV0a0EQEJ87DQQgJUIBfSAlgyIlUEUNAAsLICcgJ0IBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCxKAsgBSgCiAIgAUEEdGoiBCAmNwMIIAQgJDcDACAFIAFBAWo2AowCIAVBkAFqIAVBsAFqICQgJiACENQKDAELIARBACAMa0EFdGpBEGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4Qsi0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH//wNxIQJBkICAgHghASADQQFHDQ8gBUGIA2oQuyMMDwsgAiEGQZCd/wALEK0oCyAFKALUASABQQF0aiACOwEAIAUgAUEBajYC2AEgA0EBaiIDIBNHDQALDAoLIAMtAAIhDyADLQABIRIgBUGwAWogASACIAMgBBCGASAFKAK4ASEDIAUoArQBIQIgBSgCsAEiAUGTgICAeEcEQCAFKQK8ASEkDAkLIAUgAzYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIAeIgpBDGoiCxDcPCEEIAsQ3DwhAyMAQZABayIBJAAgAUEQaiAEEPUeIAFBxABqIAMQoh4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQTBBEAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENw8IhNFDQcgBUHcAWohCSAFQdABaiEOIAVBkAJqIRAgBUGEAmohDSAFQcABaiERQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENw8IANNDQwgCigCECADQQV0aiIBKQMAISQgASkDCCEmIAEpAxAhJyAFIAEpAxgiKDcD2AMgBSAnNwPQAyAFICY3A8gDIAUgJDcDwAMCQAJAAkAgBSgCvAFFDQAgESAFQcADahCtDCElIAUoArABIgRBMGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hKkEAIQEDQCACIARqKQAAIikgKoUiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHAA2pBICAHICV6p0EDdiACaiAIcUFQbCIMakEgEJ87DQQgJUIBfSAlgyIlUEUNAAsLICkgKUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIUIARJBEAgECAUQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIUIAEgFEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIEIAUoAoQCRgRAIA0QsigLIAUoAogCIARBBXRqIgEgKDcDGCABICc3AxAgASAmNwMIIAEgJDcDACAFIARBAWo2AowCIAVBoAFqIAVBsAFqICQgJiAnICggAhCXCgwBCyAEIAxqQRBrKAIAIQILIAVBkICAgHg2AtACIAJBgIACTw0BIAVB0AJqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0pIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELItIA0Qti0gBUGwAWpBMEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAIAZB//8DcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCtKAsgBSgC1AEgAUEBdGogAjsBACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCJJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBDWDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmhFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiSUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDWDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmhFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EJAlIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMENIPIAMoArgBIgZBk4CAgHhGDQEgACADKQG+ATcBBiAAQQxqIANBxAFqKQEANwEAIAAgAy8BvAE7AQQgACAGNgIAIAEQjjsgCxCyLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCtKAsgAygCVCABQQF0akEAOwEAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCZEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsi0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCQJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEENIPIAMoAqwBIgFBk4CAgHhGDQEgACADKQGyATcBBiAAQQxqIANBuAFqKQEANwEAIAAgAy8BsAE7AQQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCtKAsgAygCRCABQQF0akEAOwEAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCZEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELItIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCJJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDYDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykBvgE3AQYgAEEMaiADQcQBaikBADcBACAAIAMvAbwBOwEEIAAgBjYCACABEI47IAsQsi0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQrSgLIAMoAlQgAUEBdGpBADsBACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQlRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELItIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiSUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2A8gAygCrAEiAUGTgICAeEYNASAAIAMpAbIBNwEGIABBDGogA0G4AWopAQA3AQAgACADLwGwATsBBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEK0oCyADKAJEIAFBAXRqQQA7AQAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJURQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsi0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EJAlIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMENUPIAMoArgBIgZBk4CAgHhGDQEgACADKQG+ATcBBiAAQQxqIANBxAFqKQEANwEAIAAgAy8BvAE7AQQgACAGNgIAIAEQjjsgCxCyLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCtKAsgAygCVCABQQF0akEAOwEAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCXEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsi0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCQJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBDVDyADKAKsASIBQZOAgIB4Rg0BIAAgAykBsgE3AQYgAEEMaiADQbgBaikBADcBACAAIAMvAbABOwEEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQrSgLIAMoAkQgAUEBdGpBADsBACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQlxFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCyLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDOFAJAQQxBBBCtNiIDBEAgA0KDhoyYsODAgQM3AgAgA0EIakGDhowYNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPk9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQpAggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCyLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBmKT/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCbKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEOIJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqEM4UAkBBDEEEEK02IgMEQCADQoOGjJiw4MCBAzcCACADQQhqQYOGjBg2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ+T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCkCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELItIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGYpP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJsrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQZik/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmysQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsi0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQZik/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmysQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQ4gkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ+T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQpAggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEGYpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELItIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBmKT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCyLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQzhQCQEEMQQQQrTYiAwRAIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD5PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKQIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQZik/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsi0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAv8+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTQgBUGIA2oQuyMMNAsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC8LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwwCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCOHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0tIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ03IAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEIaiAFQbABaiAIIAIQgwsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTwgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCyLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0zIAVBiANqELsjDDMLIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwtCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgx4iCkEMaiILENs8IQQgCxDbPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2zwiEkUNKyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2zwgA00NNyAFIAooAhAgA0ECdGooAgAiCDYC0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCrDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiACaiAHcSIPQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCdKAsgBSgCiAIgAUECdGogCDYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTEgBUGIA2oQuyMMMQsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCkLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwtCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCLHiIKQQxqIgsoAgghBCALKAIIIQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCygCCCISRQ0nIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgAyALKAIITw0zIAUgCigCECADai0AACIIOgDQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK8MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEKkZCyAFKAKIAiABaiAIOgAAIAUgAUEBajYCjAIgBUEgaiAFQbABaiAIIAIQiQsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTkgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0wIAVBiANqELsjDDALIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwnCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQiR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNJSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCCACEIYLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS4gBUGIA2oQuyMMLgsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCMLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCHHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD5HiABQcQAaiADEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCIPRQ0hIAVB3AFqIQkgBUHQAWohDiAFQZACaiESIAVBhAJqIQ0gBUHAAWohE0EAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0zIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhAgBEkEQCASIBBBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUE4aiAFQbABaiAkIAIQhQsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0tIAVBiANqELsjDC0LIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwhCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhR4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNHyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NMCAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCCACEIILDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBDYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY2AgQgAEGQgICAeDYCACAOELMtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPkeIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQQBIDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTQgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEIIAUoAuABIgcgAkkEQCAJIAdBAXQiASACQcD///8DcUFAayACIAJBP3EbIgcgASAHSxsQ6BkgBSgC6AEhAQsgCARAIAUoAuQBIAFqQQAgCPwLAAsgBSACNgLoAQsgBSAENgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjYCBCAAQZCAgIB4NgIAIA4Qsy0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0rIAVBiANqELsjDCsLIAIhBkGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwdCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJwsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgh4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ+R4gAUHEAGogAxD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNGyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMCAFIAooAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCEkIAUoArABIgRBEGshByAFKAK0ASIIICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAHICR6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogLDkDACAFIAFBAWo2AowCIAVB0ABqIAVBsAFqICwgAhCECwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNMyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAQ2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGNgIEIABBkICAgHg2AgAgDhCzLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDSogBUGIA2oQuyMMKgsgAiEGQZCd/wALEJ0oCyAFKALUASABQQJ0aiACNgIAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDBsLIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCULIAVBBDoAsAEgACABIAIgBUGwAWogAyAEENwJDCQLIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCMLIAVBBDoAsAEgACABIAIgBUGwAWogAyAEENwJDCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEENwJDCELIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgYgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMIQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwVCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPkeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNEyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAVBwANqIQ0gBSgCWCETIAUoAlwhDyMAQTBrIgQkAAJAIA8gBUGwAWoiAigCMEYEQCMAQUBqIgYkACAGIA82AgQgBiATNgIAIAIgEyAPEM0CISQgBiACQTBqIgE2AjwgBiACQegAaiIYNgI4IAYgBjYCNCAGIAE2AhAgBiAYNgIMIAYgAjYCCCAGQRhqIQwgBkE0aiEQIAZBCGoiHyEBQQAhC0EAIRFBACEUQQAhGUEAIRojAEEgayIOJAAgAkEgaiIKKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAKKAIMIghBAWoiCSAITwRAAkAgCigCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAJSQRAAkACQCAIQQFqIgsgCSAJIAtJGyILQQ9PBEAgC0H/////AUsNAUF/IAtBA3RBB25BAWtndkEBaiELDAILQQRBCEEQIAtBCEkbIAtBBEkbIQsMAQsQ3ScgASgCHCELIAEoAhgiCUGBgICAeEcNBAsgAUHQAGogCkEQaiIHQQQgCxD7FCABKAJYIQsgASgCVCEJIAEoAlAiCEUNAyABIAEoAlw2AkwgASALNgJIIAEgCTYCRCABIAg2AkAgAUEQaiABQUBrEME0IAEoAhQiCwRAIAEoAhBB/wEgC/wLAAsgASgCSCELIAEoAkQhCSABKAJAIghFDQMgASABKAJMNgI8IAEgCzYCOCABIAk2AjQgASAINgIwIAFChICAgIABNwIoIAEgBzYCJCABQTBqISAgASAKKAIMIhwEfyAIQQhqISEgCigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgEUEIaiERIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIHKAIAIRUgAUEIaiAHKAIEIAcoAggoAgAgCigCACAleqdBA3YgEWpBAnQiImtBBGsoAgAQyiUgCCAJIBUgASgCCCABKAIMEM0CpyIjcSIHaikAAEKAgYKEiJCgwIB/gyImUARAQQghFQNAIAcgFWohByAVQQhqIRUgCCAHIAlxIgdqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCCAmeqdBA3YgB2ogCXEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiAjQRl2IhU6AAAgISAHQQhrIAlxaiAVOgAAIAggB0ECdGtBBGsgCigCACAia0EEaygAADYAACAcQQFrIhwNAAsgCigCDAVBAAsiCTYCPCABIAsgCWs2AjggCiAgQQQQ+iogAUEkahD1JwwBCyAKIAFBIGpB0NeAARDuCQtBgYCAgHghCQwBCxDdJyABKAIEIQsgASgCACEJCyAbIAs2AgQgGyAJNgIAIAFB4ABqJAALIAooAgQiCyAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEHIBAoAgQhESAQKAIAIQggCigCACEJA0ACQCABIAlqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIAwCfgJAA0AgJVANASAOIBEgBygCACAKKAIAICV6p0EDdiABaiALcSIVQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCCgCACAIKAIEIA4oAgAgDigCBBCfO0UNAAsgDCAkNwMIIAwgCigCAEEAIBVrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIAtxIRQLQQEgJSAmQgGGg1ANAhogDCAJIBRqLAAAQQBOBH8gCSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAUCzYCECAMICQ3AwhCAQs3AwAgDCAKNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiALcSEBDAELCyAGIA82AjwgBiATNgI4IAYgGDYCNCAfIAwgEBCLEyAGKAIQQQRrKAIAIQEgBkGQgICAeDYCGCAEQQRqIgogAUEATgR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE2AgQgBkFAayQAIAQoAgghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQIMNwIIIA1BEGogBEEUaigCADYCACANIAY2AgQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEJ0oCyACKAI4IAFBAnRqIAY2AgAgDSAGNgIEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQLIAzcCCCAAQRBqIAVB0ANqKAIANgIAIAAgBSgCxAM2AgQgACABNgIAIAVB0AFqEI47IBcQsy0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiIEQQN2IARBB3FBAEdqIgIgBSgC/AEiAUsEQCACIAFrIQYgBSgC9AEiCiACSQRAIBYgCkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCiABIApLGxDoGSAFKAL8ASEBCyAGBEAgBSgC+AEgAWpBACAG/AsACyAFIAI2AvwBCyAFIAQ2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEJ0oCyAFKALoASABQQJ0akEANgIAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBiALENs8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBkEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBmopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEPIAUoApQCIhUgBkkEQCARIBVBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAGNgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIAZBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0sIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0VIAVBiANqELsjDBULIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBiALENg8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBkEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBmopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEMIAUoApQCIhQgBkkEQCAQIBRBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAGNgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIAZBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkEASA0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0rIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0SIAVBiANqELsjDBILIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASEEIAUoArABIgJBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgBDYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBiALENo8IQMjAEGQAWsiASQAIAFBEGogBhD5HiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQYMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEGIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAZBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQYLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAY2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIGQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAGaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgYgBSgCnAIiAUsEQCAGIAFrIQwgBSgClAIiFCAGSQRAIBAgFEEBdCIBIAZBwP///wNxQUBrIAYgBkE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAY2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgYgJjcDCCAGICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAGQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBAEgNASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBkEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAUsEQCAEIAFrIQcgBSgC4AEiDCAESQRAIAkgDEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiDCABIAxLGxDoGSAFKALoASEBCyAHBEAgBSgC5AEgAWpBACAH/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAZBA3ZqIgEgAS0AAEEBIAZBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQQMBAsgCRDmOiAFKALcAUUNKiAFKALsAUEBaiIGQQN2IAZBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQggBSgC4AEiByACSQRAIAkgB0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiByABIAdLGxDoGSAFKALoASEBCyAIBEAgBSgC5AEgAWpBACAI/AsACyAFIAI2AugBCyAFIAY2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCzLSANELUtIAVBsAFqQSBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCAEGQgICAeCECIANBAUcNDyAFQYgDahC7IwwPCyACIQRBkJ3/AAsQnSgLIAUoAtQBIAFBAnRqIAI2AgAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhBCAFKAKwASICQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAQ2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQYgCxDcPCEDIwBBkAFrIgEkACABQRBqIAYQ+R4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEGDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAGQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEGCyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAGNgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBkEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBmopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIGIAUoApwCIgFLBEAgBiABayEMIAUoApQCIhQgBkkEQCAQIBRBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAGNgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgYgBSgChAJGBEAgDRCyKAsgBSgCiAIgBkEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBkEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAYgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkEASA0BIAVB0AJqEIgRAkAgBSgC3AEEQCAFKALsASIGQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASIBSwRAIAQgAWshByAFKALgASIMIARJBEAgCSAMQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIMIAEgDEsbEOgZIAUoAugBIQELIAcEQCAFKALkASABakEAIAf8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBAwECyAJEOY6IAUoAtwBRQ0pIAUoAuwBQQFqIgZBA3YgBkEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCCAFKALgASIHIAJJBEAgCSAHQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIHIAEgB0sbEOgZIAUoAugBIQELIAgEQCAFKALkASABakEAIAj8CwALIAUgAjYC6AELIAUgBjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAOELMtIA0Qti0gBUGwAWpBMEEQENknIAUoAogDIgEgASgCACIDQQFrNgIAQZCAgIB4IQIgA0EBRw0MIAVBiANqELsjDAwLIAIhBEGQnf8ACxCdKAsgBSgC1AEgAUECdGogAjYCACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCOJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBDUDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgBjYCACABEI47IAsQsy0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmBFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQjiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBDUDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmBFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI0lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEN0PIAMoArgBIgZBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACAGNgIAIAEQjjsgCxCzLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCSEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCNJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEN0PIAMoAqwBIgFBk4CAgHhGDQEgACADKQK0ATcCCCAAQRBqIANBvAFqKAIANgIAIAAgAygCsAE2AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCdKAsgAygCRCABQQJ0akEANgIAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCSEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELMtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCOJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDZDyADKAK4ASIGQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgBjYCACABEI47IAsQsy0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQnRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQjiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ2Q8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJ0RQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI0lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEN8PIAMoArgBIgZBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACAGNgIAIAEQjjsgCxCzLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCQEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCNJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBDfDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkBFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDQFAJAQQxBBBCtNiIDBEAgA0KEiJCgwICBggQ3AgAgA0EIakGEiJAgNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPE9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQogggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB8KT/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCXKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEOMJIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAQ2AgQgACACNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENAUAkBBDEEEEK02IgMEQCADQoSIkKDAgIGCBDcCACADQQhqQYSIkCA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ8T0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCiCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELMtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHwpP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJcrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfCk/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQlysQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQfCk/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlysQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQ4wkgBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgBDYCBCAAIAI2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ8T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQogggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHwpP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELMtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB8KT/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ0BQCQEEMQQQQrTYiAwRAIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRDxPSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEKIIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQfCk/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvh+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEKkZCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPceIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYACTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2AkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ9x4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakGQ3IABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf8BTQR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE6AAQgBkFAayQAIAQtAAghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQAJNwAFIA1BDGogBEEQaikAADcAACANIAY6AAQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEKkZCyACKAI4IAFqIAY6AAAgDSAGOgAEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQDFAzcABSAAQQxqIAVBzANqKQAANwAAIAAgBS0AxAM6AAQgACABNgIAIAVB0AFqEI47IBcQsS0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiICQQN2IAJBB3FBAEdqIgEgBSgC/AEiBEsEQCABIARrIQYgBSgC9AEiCiABSQRAIBYgCkEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCiAEIApLGxDoGSAFKAL8ASEECyAGBEAgBSgC+AEgBGpBACAG/AsACyAFIAE2AvwBCyAFIAI2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEKkZCyAFKALoASABakEAOgAAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhUgBEkEQCARIBVBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAk8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBD3HiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgAJPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4QsS0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH/AXEhAkGQgICAeCEBIANBAUcNDyAFQYgDahC7IwwPCyACIQZBkJ3/AAsQqRkLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQQgCxDcPCEDIwBBkAFrIgEkACABQRBqIAQQ9x4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBEEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgQgBSgChAJGBEAgDRCyKAsgBSgCiAIgBEEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBEEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAQgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkGAAk8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCpGQsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhDvKSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBD2DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQqRkLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ4xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ7ykgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBD2DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQqRkLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ4xFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EPEpIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPUPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCpGQsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBDhEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDxKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEPUPIAMoAqwBIgFBk4CAgHhGDQEgACADKQCxATcABSAAQQxqIANBuAFqKQAANwAAIAAgAy0AsAE6AAQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCpGQsgAygCRCABakEAOgAAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDhEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELEtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhDvKSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBD8DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQqRkLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQ4BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ7ykgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ/A8gAygCrAEiAUGTgICAeEYNASAAIAMpALEBNwAFIABBDGogA0G4AWopAAA3AAAgACADLQCwAToABCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEKkZCyADKAJEIAFqQQA6AAAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEOARQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsS0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EPEpIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPkPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCpGQsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBDXEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDxKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBD5DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQqRkLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1xFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDRFAJAQQxBBBCtNiIDBEAgA0KGjJiw4MCBgwY3AgAgA0EIakGGjJgwNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPc9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQnQggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCxLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBoKb/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCaKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEJ0KIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENEUAkBBDEEEEK02IgMEQCADQoaMmLDgwIGDBjcCACADQQhqQYaMmDA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ9z0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCdCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELEtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGgpv8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJorEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQaCm/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmisQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQaCm/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmisQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQnQogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ9z0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQnQggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEGgpv8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELEtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBoKb/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ0RQCQEEMQQQQrTYiAwRAIANChoyYsODAgYMGNwIAIANBCGpBhoyYMDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ0IIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaCm/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsS0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvh+AIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQQJrDiUBAgMEBQYHCAkKCwwNDg8QAAAWERcAGBkAAAAAAAAAAAASExQVAAsgBUEBNgK0ASAFQZyx/wA2ArABIAVCATcCvAEgBUGvAzYC1AIgBSAFQdACajYCuAEgBSAFQawBajYC0AIgBUHAA2ogBUGwAWoQmQ4gAEGCgICAeDYCACAAIAUpAsADNwIEIABBDGogBUHIA2ooAgA2AgAMMQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADDELIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIEeIgpBDGoiCygCCCEEIAsoAgghAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALKAIIIhJFDS8gBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiADIAsoAghPDTcgBSAKKAIQIANqLQAAIgg6ANACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgAmogB3EiD0EDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQoygLIAUoAogCIAFqIAg6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAggAhCHCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDT0gBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCxLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw00IAVBiANqELsjDDQLIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwvCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMMAsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQjh4iCkEMaiILENk8IQQgCxDZPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2TwiEkUNLSAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2TwgA00NNyAFIAooAhAgA0EBdGovAQAiCDsB0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCuDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiACaiAHcSIPQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCDsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCCACEIMLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNPCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELItIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTMgBUGIA2oQuyMMMwsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDC0LIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwvCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCDHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCISRQ0rIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ03IAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAIIAIQiAsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ07IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNMiAFQYgDahC7IwwyCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMKwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADC4LIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIoeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDSkgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTcgBSAKKAIQIANBA3RqKQMAIiQ3A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJSAFKAKwASIEQRBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQQggByAleqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICVCAX0gJYMiJVBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICQ3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICQgAhCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRC0LSAFQbABakEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0xIAVBiANqELsjDDELIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAPRw0ACwwpCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLQsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQix4iCkEMaiILKAIIIQQgCygCCCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsoAggiEkUNJyAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEyAFQYQCaiENIAVBwAFqIRBBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAMgCygCCE8NMyAFIAooAhAgA2otAAAiCDoA0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCvDCEkIAUoArABIgRBCGshDCAFKAK0ASIHICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiACaiAHcSIPQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAHcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIHQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDyAFKAKUAiIRIARJBEAgEyARQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIRIAEgEUsbEOgZIAUoApwCIQELIA8EQCAFKAKYAiABakEAIA/8CwALIAUgBDYCnAILIAUgDDYCoAIgBSgCmAIgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCpGQsgBSgCiAIgAWogCDoAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCCACEIkLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNOSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELEtIAVBsAFqQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDTAgBUGIA2oQuyMMMAsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIBJHDQALDCcLIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwsCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCJHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0lIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0zIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAIIAIQhgsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ04IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLyAFQYgDahC7IwwvCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMJQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIweIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8IhJFDSMgBUHcAWohCSAFQdABaiEOIAVBkAJqIRMgBUGEAmohDSAFQcABaiEQQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTMgBSAKKAIQIANBAnRqKAIAIgg2AtACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQwgBSgCtAEiByAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgAmogB3EiD0EDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogB3EhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiB0EBaiIMQQN2IAxBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQ8gBSgClAIiESAESQRAIBMgEUEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiESABIBFLGxDoGSAFKAKcAiEBCyAPBEAgBSgCmAIgAWpBACAP/AsACyAFIAQ2ApwCCyAFIAw2AqACIAUoApgCIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqIAg2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAggAhCKCwwBCyAEQQAgD2tBA3RqQQRrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIAAgBjoABCAAQZCAgIB4NgIAIA4QsS0gDRCzLSAFQbABakEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAVBiANqELsjDC4LIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyASRw0ACwwjCyAFQbABaiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKgsgBSABNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQhx4iCkEMaiILENg8IQQgCxDYPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ2DwiD0UNISAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohEiAFQYQCaiENIAVBwAFqIRNBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ2DwgA00NMyAFIAooAhAgA0EDdGopAwAiJDcD0AICQAJAAkAgBSgCvAFFDQAgEyAFQdACahCsDCElIAUoArABIgRBEGshByAFKAK0ASIIICWncSECICVCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiVQRQRAA0AgBUHQAmpBCCAHICV6p0EDdiACaiAIcSIMQQR0a0EIEJ87DQQgJUIBfSAlgyIlUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAIcSECDAALAAsgDSgCCCECAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgdBA3YgB0EHcUEAR2oiBCAFKAKcAiIBSwRAIAQgAWshDCAFKAKUAiIQIARJBEAgEiAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgBDYCnAILIAUgBzYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA1BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJDcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJCACEIULDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNNiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgACAGOgAEIABBkICAgHg2AgAgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDS0gBUGIA2oQuyMMLQsgAiEGQZCd/wALEKMoCyAFKALUASABaiACOgAAIAUgAUEBajYC2AEgA0EBaiIDIA9HDQALDCELIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwpCyAFIAE2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCFHiIKQQxqIgsQ2TwhBCALENk8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDZPCISRQ0fIAVB3AFqIQkgBUHQAWohDiAFQZACaiETIAVBhAJqIQ0gBUHAAWohEEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDZPCADTQ0wIAUgCigCECADQQF0ai8BACIIOwHQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqEK4MISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhEgBEkEQCATIBFBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhEgASARSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEK0oCyAFKAKIAiABQQF0aiAIOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAIIAIQggsMAQsgBEEAIA9rQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ01IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsi0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNLCAFQYgDahC7IwwsCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgEkcNAAsMHwsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIQeIgpBDGoiCxDbPCEEIAsQ2zwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENs8Ig9FDR0gBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENs8IANNDTAgBSAKKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgByAkeqdBA3YgAmogCHEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAIQjAsMAQsgBEEAIAxrQQN0akEEaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0Qsy0gBUGwAWpBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKyAFQYgDahC7IwwrCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMHQsgBUGwAWogASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAUgATYCjAMgBSACNgKIAyAFQbABaiECIAVBiANqEIIeIgpBDGoiCxDYPCEEIAsQ2DwhAyMAQZABayIBJAAgAUEQaiAEEPAeIAFBxABqIAMQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIANFBEBBqLWAASEDQQAhBAwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IANBD08EQCADQf////8BSw0CQX8gA0EDdEEHbkEBa2d2QQFqDAELQQRBCEEQIANBCEkbIANBBEkbCxCdFCABKAJ8IQQgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgBEEJaiIJRQ0BIANB/wEgCfwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghBAsgAkEgaiABQRBqQTT8CgAAIAJB1ABqIAFBxABqQTT8CgAAIAIgJTcDGCACICY3AxAgAiAkNwMIIAIgBDYCBCACIAM2AgAgAUGQAWokACALENg8Ig9FDRsgBUHcAWohCSAFQdABaiEOIAVBkAJqIRIgBUGEAmohDSAFQcABaiETQQAhAwNAAkAgDgJ/AkACQCAKIAMQhyVFBEAgBSADNgLIAiALENg8IANNDTAgBSAKKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQcgBSgCtAEiCCAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggByAkeqdBA3YgAmogCHEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiECAESQRAIBIgEEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAIQhAsMAQsgBEEAIAxrQQR0akEIaygCACECCyAFQZCAgIB4NgLAAyACQYABTw0BIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIEQQFqIghBA3YgCEEHcUEAR2oiASAFKALoASIGSwRAIAEgBmshByAFKALgASIMIAFJBEAgCSAMQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIMIAYgDEsbEOgZIAUoAugBIQYLIAcEQCAFKALkASAGakEAIAf8CwALIAUgATYC6AELIAUgCDYC7AEgBSgC5AEgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASIBIAUoAtABRg0CIAIhBgwECyAJEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCCAFKALgASIHIAFJBEAgCSAHQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIHIAQgB0sbEOgZIAUoAugBIQQLIAgEQCAFKALkASAEakEAIAj8CwALIAUgATYC6AELIAUgAjYC7AFBACECIAUoAtgBIgEgBSgC0AFHDQNBgJ3/AAwCCyAAIAY6AAQgAEGQgICAeDYCACAOELEtIA0QtC0gBUGwAWpBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNKiAFQYgDahC7IwwqCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgD0cNAAsMGwsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMJQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMJAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2QkMIQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiBiAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwhCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBULIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ8B4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0TIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohDSAFKAJYIRMgBSgCXCEPIwBBMGsiBCQAAkAgDyAFQbABaiICKAIwRgRAIwBBQGoiBiQAIAYgDzYCBCAGIBM2AgAgAiATIA8QzQIhJCAGIAJBMGoiATYCPCAGIAJB6ABqIhg2AjggBiAGNgI0IAYgATYCECAGIBg2AgwgBiACNgIIIAZBGGohDCAGQTRqIRAgBkEIaiIfIQFBACELQQAhEUEAIRRBACEZQQAhGiMAQSBrIg4kACACQSBqIgooAghFBEAgDkEYaiABQQhqKAIANgIAIA4gASkCADcDECAOQQhqIRsjAEHgAGsiASQAIAEgDkEQajYCIAJAIAooAgwiCEEBaiIJIAhPBEACQCAKKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAlJBEACQAJAIAhBAWoiCyAJIAkgC0kbIgtBD08EQCALQf////8BSw0BQX8gC0EDdEEHbkEBa2d2QQFqIQsMAgtBBEEIQRAgC0EISRsgC0EESRshCwwBCxDdJyABKAIcIQsgASgCGCIJQYGAgIB4Rw0ECyABQdAAaiAKQRBqIgdBBCALEPsUIAEoAlghCyABKAJUIQkgASgCUCIIRQ0DIAEgASgCXDYCTCABIAs2AkggASAJNgJEIAEgCDYCQCABQRBqIAFBQGsQwTQgASgCFCILBEAgASgCEEH/ASAL/AsACyABKAJIIQsgASgCRCEJIAEoAkAiCEUNAyABIAEoAkw2AjwgASALNgI4IAEgCTYCNCABIAg2AjAgAUKEgICAgAE3AiggASAHNgIkIAFBMGohICABIAooAgwiHAR/IAhBCGohISAKKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCARQQhqIREgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIgcoAgAhFSABQQhqIAcoAgQgBygCCCgCACAKKAIAICV6p0EDdiARakECdCIia0EEaygCABDKJSAIIAkgFSABKAIIIAEoAgwQzQKnIiNxIgdqKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEVA0AgByAVaiEHIBVBCGohFSAIIAcgCXEiB2opAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSAIICZ6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqICNBGXYiFToAACAhIAdBCGsgCXFqIBU6AAAgCCAHQQJ0a0EEayAKKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAKKAIMBUEACyIJNgI8IAEgCyAJazYCOCAKICBBBBD6KiABQSRqEPUnDAELIAogAUEgakGg14ABEO4JC0GBgICAeCEJDAELEN0nIAEoAgQhCyABKAIAIQkLIBsgCzYCBCAbIAk2AgAgAUHgAGokAAsgCigCBCILICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAQKAIIIQcgECgCBCERIBAoAgAhCCAKKAIAIQkDQAJAIAEgCWopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgDAJ+AkADQCAlUA0BIA4gESAHKAIAIAooAgAgJXqnQQN2IAFqIAtxIhVBAnRrQQRrKAIAEMolICVCAX0gJYMhJSAIKAIAIAgoAgQgDigCACAOKAIEEJ87RQ0ACyAMICQ3AwggDCAKKAIAQQAgFWtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogC3EhFAtBASAlICZCAYaDUA0CGiAMIAkgFGosAABBAE4EfyAJKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAwgJDcDCEIBCzcDACAMIAo2AhQgDkEgaiQADAILQQALIRkgASAaQQhqIhpqIAtxIQEMAQsLIAYgDzYCPCAGIBM2AjggBiAYNgI0IB8gDCAQEIsTIAYoAhBBBGsoAgAhASAGQZCAgIB4NgIYIARBBGoiCiABQf8ATQR/IAwQiBFBk4CAgHgFQZCAgIB4CzYCACAKIAE6AAQgBkFAayQAIAQtAAghBiAEKAIEIgFBk4CAgHhHBEAgDSAEKQAJNwAFIA1BDGogBEEQaikAADcAACANIAY6AAQgDSABNgIADAILAkAgAigCQARAIAIoAlAiC0EBaiIJQQN2IAlBB3FBAEdqIgEgAigCTCIKSwRAIAEgCmshDiACKAJEIgggAUkEQCACQUBrIAhBAXQiCiABQcD///8DcUFAayABIAFBP3EbIgggCCAKSRsQ6BkgAigCTCEKCyAOBEAgAigCSCAKakEAIA78CwALIAIgATYCTAsgAiAJNgJQIAIoAkggC0EDdmoiASABLQAAQQEgC0EHcXRyOgAADAELIAIgAigCVEEBajYCVAsgAigCPCIBIAIoAjRGBEAgAkE0akHItYABEKMoCyACKAI4IAFqIAY6AAAgDSAGOgAEIA1Bk4CAgHg2AgAgAiABQQFqNgI8DAELIAQgDzYCHCAEQQI2AgggBEGgt4ABNgIEIARCAjcCECAEQTs2AiwgBEGcAzYCJCAEIAJBMGo2AiAgBCAEQSBqNgIMIAQgBEEcajYCKCANQQRqIARBBGoQmQ4gDUGNgICAeDYCAAsgBEEwaiQAIAUoAsADIgFBk4CAgHhGDQEgACAFKQDFAzcABSAAQQxqIAVBzANqKQAANwAAIAAgBS0AxAM6AAQgACABNgIAIAVB0AFqEI47IBcQsS0gBUGYAmoQii8MFwsgFhDmOiAFKALwAUUNKiAFKAKAAkEBaiICQQN2IAJBB3FBAEdqIgEgBSgC/AEiBEsEQCABIARrIQYgBSgC9AEiCiABSQRAIBYgCkEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCiAEIApLGxDoGSAFKAL8ASEECyAGBEAgBSgC+AEgBGpBACAG/AsACyAFIAE2AvwBCyAFIAI2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AEKMoCyAFKALoASABakEAOgAAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwTCyADLQACIRIgAy0AASETIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwSCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCIHiIKQQxqIgsQ2zwhBCALENs8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJiABKQN4IScCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEIQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASElQQAhAwwCCyABKQKAASElIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJSABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICY3AxggAiAnNwMQIAIgJTcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDbPCIQRQ0QIAVB3AFqIQkgBUHQAWohDiAFQZACaiERIAVBhAJqIQ0gBUHAAWohFEEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDbPCADTQ0oIAUgCigCECADQQJ0aigCACIINgLQAgJAAkACQCAFKAK8AUUNACAUIAVB0AJqEKsMISQgBSgCsAEiBEEIayEMIAUoArQBIgcgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IAJqIAdxIg9BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAdxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIgdBAWoiDEEDdiAMQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEPIAUoApQCIhUgBEkEQCARIBVBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDwRAIAUoApgCIAFqQQAgD/wLAAsgBSAENgKcAgsgBSAMNgKgAiAFKAKYAiAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAINgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCCACEIgLDAELIARBACAPa0EDdGpBBGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNLCAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELMtIAVBsAFqQQhBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0VIAVBiANqELsjDBULIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyAQRw0ACwwQCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwPCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCNHiIKQQxqIgsQ2DwhBCALENg8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEQQQgCfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDYPCITRQ0NIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDYPCADTQ0oIAUgCigCECADQQN0aikDACIkNwPQAgJAAkACQCAFKAK8AUUNACARIAVB0AJqEKwMISUgBSgCsAEiBEEQayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQdACakEIIAcgJXqnQQN2IAJqIAhxIgxBBHRrQQgQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDUGQnf8AELMoCyAFKAKIAiABQQN0aiAkNwMAIAUgAUEBajYCjAIgBUGAAWogBUGwAWogJCACEIsLDAELIARBACAMa0EEdGpBCGsoAgAhAgsgBUGQgICAeDYCwAMgAkGAAU8NASAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKyAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELQtIAVBsAFqQRBBCBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0SIAVBiANqELsjDBILIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwNCyADLQACIQ8gAy0AASESIAVBsAFqIAEgAiADIAQQhgEgBSgCuAEhAyAFKAK0ASECIAUoArABIgFBk4CAgHhHBEAgBSkCvAEhJAwMCyAFIAM2AowDIAUgAjYCiAMgBUGwAWohAiAFQYgDahCGHiIKQQxqIgsQ2jwhBCALENo8IQMjAEGQAWsiASQAIAFBEGogBBDwHiABQcQAaiADEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCADRQRAQai1gAEhA0EAIQQMAQsCQCABQfgAaiABQY8BakEgQRACfyADQQ9PBEAgA0H/////AUsNAkF/IANBA3RBB25BAWtndkEBagwBC0EEQQhBECADQQhJGyADQQRJGwsQnRQgASgCfCEEIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIARBCWoiCUUNASADQf8BIAn8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQQLIAJBIGogAUEQakE0/AoAACACQdQAaiABQcQAakE0/AoAACACICU3AxggAiAmNwMQIAIgJDcDCCACIAQ2AgQgAiADNgIAIAFBkAFqJAAgCxDaPCITRQ0KIAVB3AFqIQkgBUHQAWohDiAFQZACaiEQIAVBhAJqIQ0gBUHAAWohEUEAIQMDQAJAIA4CfwJAAkAgCiADEIclRQRAIAUgAzYCyAIgCxDaPCADTQ0MIAooAhAgA0EEdGoiASkDACEkIAUgASkDCCImNwPYAiAFICQ3A9ACAkACQAJAIAUoArwBRQ0AIBEgBUHQAmoQsAwhJSAFKAKwASIEQSBrIQcgBSgCtAEiCCAlp3EhAiAlQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIlUEUEQANAIAVB0AJqQRAgByAleqdBA3YgAmogCHEiDEEFdGtBEBCfOw0EICVCAX0gJYMiJVBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCHEhAgwACwALIA0oAgghAgJAIAUoApACBEAgBSgCoAIiCEEBaiIHQQN2IAdBB3FBAEdqIgQgBSgCnAIiAUsEQCAEIAFrIQwgBSgClAIiFCAESQRAIBAgFEEBdCIBIARBwP///wNxQUBrIAQgBEE/cRsiFCABIBRLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAQ2ApwCCyAFIAc2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCANQZCd/wAQsSgLIAUoAogCIAFBBHRqIgQgJjcDCCAEICQ3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAkICYgAhDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQILIAVBkICAgHg2AsADIAJBgAFPDQEgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIgRBAWoiCEEDdiAIQQdxQQBHaiIBIAUoAugBIgZLBEAgASAGayEHIAUoAuABIgwgAUkEQCAJIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBSgC6AEhBgsgBwRAIAUoAuQBIAZqQQAgB/wLAAsgBSABNgLoAQsgBSAINgLsASAFKALkASAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgEgBSgC0AFGDQIgAiEGDAQLIAkQ5jogBSgC3AFFDSogBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEIIAUoAuABIgcgAUkEQCAJIAdBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgcgBCAHSxsQ6BkgBSgC6AEhBAsgCARAIAUoAuQBIARqQQAgCPwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQIgBSgC2AEiASAFKALQAUcNA0GAnf8ADAILIA4QsS0gDRC1LSAFQbABakEgQRAQ2ScgBSgCiAMiASABKAIAIgNBAWs2AgAgBkH/AXEhAkGQgICAeCEBIANBAUcNDyAFQYgDahC7IwwPCyACIQZBkJ3/AAsQoygLIAUoAtQBIAFqIAI6AAAgBSABQQFqNgLYASADQQFqIgMgE0cNAAsMCgsgAy0AAiEPIAMtAAEhEiAFQbABaiABIAIgAyAEEIYBIAUoArgBIQMgBSgCtAEhAiAFKAKwASIBQZOAgIB4RwRAIAUpArwBISQMCQsgBSADNgKMAyAFIAI2AogDIAVBsAFqIQIgBUGIA2oQgB4iCkEMaiILENw8IQQgCxDcPCEDIwBBkAFrIgEkACABQRBqIAQQ8B4gAUHEAGogAxCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgA0UEQEGotYABIQNBACEEDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gA0EPTwRAIANB/////wFLDQJBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgA0EISRsgA0EESRsLEJ0UIAEoAnwhBCABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCAEQQlqIglFDQEgA0H/ASAJ/AsADAELEOMnQQAhAyABNQIMISQgASgCCCEECyACQSBqIAFBEGpBNPwKAAAgAkHUAGogAUHEAGpBNPwKAAAgAiAlNwMYIAIgJjcDECACICQ3AwggAiAENgIEIAIgAzYCACABQZABaiQAIAsQ3DwiE0UNByAFQdwBaiEJIAVB0AFqIQ4gBUGQAmohECAFQYQCaiENIAVBwAFqIRFBACEDA0ACQCAOAn8CQAJAIAogAxCHJUUEQCAFIAM2AsgCIAsQ3DwgA00NDCAKKAIQIANBBXRqIgEpAwAhJCABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAkNwPAAwJAAkACQCAFKAK8AUUNACARIAVBwANqEK0MISUgBSgCsAEiBEEwayEHIAUoArQBIgggJadxIQIgJUIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJVBFBEADQCAFQcADakEgIAcgJXqnQQN2IAJqIAhxQVBsIgxqQSAQnzsNBCAlQgF9ICWDIiVQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAhxIQIMAAsACyANKAIIIQICQCAFKAKQAgRAIAUoAqACIghBAWoiB0EDdiAHQQdxQQBHaiIEIAUoApwCIgFLBEAgBCABayEMIAUoApQCIhQgBEkEQCAQIBRBAXQiASAEQcD///8DcUFAayAEIARBP3EbIhQgASAUSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSAENgKcAgsgBSAHNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgQgBSgChAJGBEAgDRCyKAsgBSgCiAIgBEEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAkNwMAIAUgBEEBajYCjAIgBUGgAWogBUGwAWogJCAmICcgKCACEJcKDAELIAQgDGpBEGsoAgAhAgsgBUGQgICAeDYC0AIgAkGAAU8NASAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiBEEBaiIIQQN2IAhBB3FBAEdqIgEgBSgC6AEiBksEQCABIAZrIQcgBSgC4AEiDCABSQRAIAkgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAFKALoASEGCyAHBEAgBSgC5AEgBmpBACAH/AsACyAFIAE2AugBCyAFIAg2AuwBIAUoAuQBIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiASAFKALQAUYNAiACIQYMBAsgCRDmOiAFKALcAUUNKSAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQggBSgC4AEiByABSQRAIAkgB0EBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiByAEIAdLGxDoGSAFKALoASEECyAIBEAgBSgC5AEgBGpBACAI/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhAiAFKALYASIBIAUoAtABRw0DQYCd/wAMAgsgDhCxLSANELYtIAVBsAFqQTBBEBDZJyAFKAKIAyIBIAEoAgAiA0EBazYCACAGQf8BcSECQZCAgIB4IQEgA0EBRw0MIAVBiANqELsjDAwLIAIhBkGQnf8ACxCjKAsgBSgC1AEgAWogAjoAACAFIAFBAWo2AtgBIANBAWoiAyATRw0ACwwHCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJiADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCKJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQgBcgA0G4AWogA0EgaiIBIAMoAgggAygCDBD4DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0pIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQoygLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQmxFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwcCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDScgAygCyAEiAkG+tf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0sIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgAygCwAEgARCsHyADQawBaiADQRBqIAMoAgAgAygCBBD4DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0nIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQoygLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQmxFB0ABBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC6LCADQZACaiQADBsLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgIgAygCFCgCDBEAAAJAAkAgAgRAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0lIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI8lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPcPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSggAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCjKAsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCPEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwmCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBsLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCPJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQEgAygCwAFBAUYNJiADKALIASICQb61/wBBLvwKAAAgAEEuNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgEgAygC4AFHBEAgA0HMAGohBCADQUBrIQsgA0HEAWohCQNAAkACQCADKALEAQRAIAEgAygC1AFPDSsgAygCyAEgAygC0AEgAWoiAkEDdmotAABB/wFzIAJBB3F2QQFxDQELIAMgAUEBajYC3AEgAyADKALAASABEKwfIANBrAFqIANBEGogAygCACADKAIEEPcPIAMoAqwBIgFBk4CAgHhGDQEgACADKQCxATcABSAAQQxqIANBuAFqKQAANwAAIAAgAy0AsAE6AAQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAkQ+x4MBAsgAyABQQFqNgLcASAEEOY6IAMoAkxFDSYgAygCXEEBaiIGQQN2IAZBB3FBAEdqIgIgAygCWCIBSwRAIAIgAWshCiADKAJQIg0gAkkEQCAEIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgAygCWCEBCyAKBEAgAygCVCABakEAIAr8CwALIAMgAjYCWAsgAyAGNgJcIAMoAkgiASADKAJARgRAIAtBgJ3/ABCjKAsgAygCRCABakEAOgAAIAMgAUEBajYCSAsgAygC3AEiASADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCPEUHQAEEEEK02IgFFDSQgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELEtIANB9ABqELssIANBkAJqJAAMGgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiAiADKAIUKAIMEQAAAkACQCACBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCEBIAMoAiBBAUYNJCADKAIoIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBIGogAhDTOhCKJSACENM6Ig4EQCADQdwAaiEKIANB0ABqIQtBACEEA0ACQCACIAQQliVFBEAgA0EIaiACIAQQ/xYgA0G4AWogA0EgaiIBIAMoAgggAygCDBD6DyADKAK4ASIGQZOAgIB4Rg0BIAAgAykAvQE3AAUgAEEMaiADQcQBaikAADcAACAAIAMtALwBOgAEIAAgBjYCACABEI47IAsQsS0gA0GEAWoQuiwMBAsgChDmOiADKAJcRQ0nIAMoAmxBAWoiCUEDdiAJQQdxQQBHaiIBIAMoAmgiBksEQCABIAZrIQ0gAygCYCIIIAFJBEAgCiAIQQF0IgYgAUHA////A3FBQGsgASABQT9xGyIIIAYgCEsbEOgZIAMoAmghBgsgDQRAIAMoAmQgBmpBACAN/AsACyADIAE2AmgLIAMgCTYCbCADKAJYIgEgAygCUEYEQCALQYCd/wAQoygLIAMoAlQgAWpBADoAACADIAFBAWo2AlgLIA4gBEEBaiIERw0ACwsgA0G4AWoiAiADQSBqIgQQnBFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELEtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMJQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwaCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiiUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhASADKALAAUEBRg0lIAMoAsgBIgJBkLX/AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiASADKALgAUcEQCADQcwAaiEEIANBQGshCyADQcQBaiEJA0ACQAJAIAMoAsQBBEAgASADKALUAU8NKiADKALIASADKALQASABaiICQQN2ai0AAEH/AXMgAkEHcXZBAXENAQsgAyABQQFqNgLcASADIANBwAFqIAEQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ+g8gAygCrAEiAUGTgICAeEYNASAAIAMpALEBNwAFIABBDGogA0G4AWopAAA3AAAgACADLQCwAToABCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCRD7HgwECyADIAFBAWo2AtwBIAQQ5jogAygCTEUNJSADKAJcQQFqIgZBA3YgBkEHcUEAR2oiAiADKAJYIgFLBEAgAiABayEKIAMoAlAiDSACSQRAIAQgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSADKAJYIQELIAoEQCADKAJUIAFqQQAgCvwLAAsgAyACNgJYCyADIAY2AlwgAygCSCIBIAMoAkBGBEAgC0GAnf8AEKMoCyADKAJEIAFqQQA6AAAgAyABQQFqNgJICyADKALcASIBIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJwRQdAAQQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsS0gA0H0AGoQuiwgA0GQAmokAAwZCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECICIAMoAhQoAgwRAAACQAJAIAIEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQEgAygCIEEBRg0jIAMoAigiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0EgaiACENQ6EI8lIAIQ1DoiDgRAIANB3ABqIQogA0HQAGohC0EAIQQDQAJAIAIgBBCWJUUEQCADQQhqIAIgBBDxFiADQbgBaiADQSBqIgEgAygCCCADKAIMEPsPIAMoArgBIgZBk4CAgHhGDQEgACADKQC9ATcABSAAQQxqIANBxAFqKQAANwAAIAAgAy0AvAE6AAQgACAGNgIAIAEQjjsgCxCxLSADQYQBahC7LAwECyAKEOY6IAMoAlxFDSYgAygCbEEBaiIJQQN2IAlBB3FBAEdqIgEgAygCaCIGSwRAIAEgBmshDSADKAJgIgggAUkEQCAKIAhBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgggBiAISxsQ6BkgAygCaCEGCyANBEAgAygCZCAGakEAIA38CwALIAMgATYCaAsgAyAJNgJsIAMoAlgiASADKAJQRgRAIAtBgJ3/ABCjKAsgAygCVCABakEAOgAAIAMgAUEBajYCWAsgDiAEQQFqIgRHDQALCyADQbgBaiICIANBIGoiBBCTEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsS0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwkCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBkLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCPJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASEBIAMoAsABQQFGDSQgAygCyAEiAkGQtf8AQS78CgAAIABBLjYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASIBIAMoAuABRwRAIANBzABqIQQgA0FAayELIANBxAFqIQkDQAJAAkAgAygCxAEEQCABIAMoAtQBTw0pIAMoAsgBIAMoAtABIAFqIgJBA3ZqLQAAQf8BcyACQQdxdkEBcQ0BCyADIAFBAWo2AtwBIAMgA0HAAWogARCtKiADQawBaiADQRBqIAMoAgAgAygCBBD7DyADKAKsASIBQZOAgIB4Rg0BIAAgAykAsQE3AAUgAEEMaiADQbgBaikAADcAACAAIAMtALABOgAEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAJEPseDAQLIAMgAUEBajYC3AEgBBDmOiADKAJMRQ0kIAMoAlxBAWoiBkEDdiAGQQdxQQBHaiICIAMoAlgiAUsEQCACIAFrIQogAygCUCINIAJJBEAgBCANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAMoAlghAQsgCgRAIAMoAlQgAWpBACAK/AsACyADIAI2AlgLIAMgBjYCXCADKAJIIgEgAygCQEYEQCALQYCd/wAQoygLIAMoAkQgAWpBADoAACADIAFBAWo2AkgLIAMoAtwBIgEgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkxFB0ABBBBCtNiIBRQ0iIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCxLSADQfQAahC7LCADQZACaiQADBgLIAEgBSgCuAFB0KD/ABD9LwALIAUgChD/OzYCoAMMGwsgBSAKEIA8NgKgAwwaCyMAQZADayIBJAAgBUGwAWoiCyICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgkgAkEgahDWFAJAQQxBBBCtNiIDBEAgA0KChIiQoMCAgQI3AgAgA0EIakGChIgQNgIAIAFBqAJqIgIgChDIBkEMQQQQrTYiBEUNIiAEIAEpAqgCNwIAIARBCGogAUGwAmooAgA2AgAgASAENgJsIAEgAzYCaCABQSI6AGQgAUHMAWoiAyAJEPc9IAIgAxChGyADIAIgAUHkAGoQjBhBxABBBBCtNiIERQ0jIAIgCkEw/AoAACAEIAIQhj4gAUEBNgKMAyABIAQ2AogDIAFBATYChAMgAUHwAGoiBCADIAFBhANqEPwiIAIgBBDNHCAGIAIQngggAUGQA2okAAwBCwwhCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCxLSAFQYQCahC2LSALQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBwKP/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCZKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgEiAPEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBzwNqIgQgBUHAAWoiBikAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgogBUHQAWopAgA3AwAgBUGYA2oiCyAFQdgBaikCADcDACAFQagDaiIJIAIpAwA3AwAgBUGvA2oiDSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNHCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAJKQMANwAAIAFBGGogDSkAADcAACABQShqIAopAwA3AgAgAUEwaiALKQMANwIAIAVBsAFqIAQgAUHUsv8AEIQKIAUtAPQBIgNBAkYEQCAFQdADaiAGKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0XIAVByAJqELsjDBcLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRYgBUHIAmoQuyMMFgsMHgsMHQsgACAkNwIMIAAgAzYCCCAAIAI2AgQgACABNgIADBMLIwBBkANrIgEkACAFQbABaiILIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCSACQSBqENYUAkBBDEEEEK02IgMEQCADQoKEiJCgwICBAjcCACADQQhqQYKEiBA2AgAgAUGoAmoiAiAKEMgGQQxBBBCtNiIERQ0gIAQgASkCqAI3AgAgBEEIaiABQbACaigCADYCACABIAQ2AmwgASADNgJoIAFBIjoAZCABQcwBaiIDIAkQ9z0gAiADEKEbIAMgAiABQeQAahCMGEHEAEEEEK02IgRFDSEgAiAKQTD8CgAAIAQgAhD+PSABQQE2AowDIAEgBDYCiAMgAUEBNgKEAyABQfAAaiIEIAMgAUGEA2oQ/CIgAiAEEM0cIAYgAhCeCCABQZADaiQADAELDB8LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELEtIAVBhAJqELUtIAtBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHAo/8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJkrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiASIA8QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0aIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQfyx/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRUgBUHIAmoQuyMMFQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNFCAFQcgCahC7IwwUCwwcCwwbCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDR4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHyACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMHQsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQtC0gC0EQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcCj/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQmSsQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiASIA8QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQaSx/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRwgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNHSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsS0gBUGEAmoQsy0gC0EIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcCj/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQmSsQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiATIBIQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIGKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiCiAFQdABaikCADcDACAFQZgDaiILIAVB2AFqKQIANwMAIAVBqANqIgkgAikDADcDACAFQa8DaiINIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAkpAwA3AAAgAUEYaiANKQAANwAAIAFBKGogCikDADcCACABQTBqIAspAwA3AgAgBUGwAWogBCABQayz/wAQhAogBS0A9AEiA0ECRgRAIAVB0ANqIAYoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyAAICQ3AgwgACADNgIIIAAgAjYCBCAAIAE2AgAMDQsgBUHAA2ohBCMAQZADayIBJAAgBUGwAWoiAkEgahCXNiABQQhqIgogAkHoAGoQxxQgAUFAayIGIAJBNGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACACKAIwIQtBDEEEEK02IgJFDRogAiALNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAYQ9z0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgZFDRsgBiAKEO89IAFBATYCvAIgASAGNgK4AiABQQE2ArQCIAFB/ABqIgYgAyACEPwiIAIgBhDNHCAEIAIQngggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHAo/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELEtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRggBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGSACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRcgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNGCACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRYgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFyACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRUgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRQgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFSACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzxQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRMgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNFCACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRIgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCxLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDREgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNEiACIApBMPwKAAAgBCACEPA9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahC0LSALQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0BQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDRAgBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNESACIApBMPwKAAAgBCACEPE9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCzLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ8gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNECACIApBMPwKAAAgBCACEPk9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBwKP/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCxLSAFQYQCahCyLSALQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgsiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIJIAJBIGoQ1hQCQEEMQQQQrTYiAwRAIANCgoSIkKDAgIECNwIAIANBCGpBgoSIEDYCACABQagCaiICIAoQyAZBDEEEEK02IgRFDQ4gBCABKQKoAjcCACAEQQhqIAFBsAJqKAIANgIAIAEgBDYCbCABIAM2AmggAUEiOgBkIAFBzAFqIgMgCRD3PSACIAMQoRsgAyACIAFB5ABqEIwYQcQAQQQQrTYiBEUNDyACIApBMPwKAAAgBCACEPc9IAFBATYCjAMgASAENgKIAyABQQE2AoQDIAFB8ABqIgQgAyABQYQDahD8IiACIAQQzRwgBiACEJ4IIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcCj/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsS0gBUGEAmoQsS0gC0EIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAKEKM8NgKgAwwDCyAFIAoQ/js2AqADDAILIAUgChD8OzYCoAMMAQsgBSAKEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyABIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgASADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvS6wIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADC0LIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgR4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEUUNLCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiADIAooAghPDTEgBSAHKAIQIANqLQAAIgk6ANACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgBGogCHEiDUEDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQoygLIAUoAogCIAFqIAk6AAAgBSABQQFqNgKMAiAFIAVBsAFqIAkgBBCHCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ03IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCwLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMLAsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCOHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEPUeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0qIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NMSAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBCGogBUGwAWogCSAEEIMLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMKgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwrCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIMeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ+R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8IhFFDSggBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0xIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUEQaiAFQbABaiAJIAQQiAsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwoCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCoLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQih4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNJiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDTEgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQRhqIAVBsAFqICUgBBCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASIPIAJJBEAgBiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ00IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDCYLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKQsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCLHiIHQQxqIgooAgghAyAKKAIIIQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEPceIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgCigCCCIRRQ0kIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAMgCigCCE8NLSAFIAcoAhAgA2otAAAiCToA0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCvDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBASAMICR6p0EDdiAEaiAIcSINQQN0a0EBEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCpGQsgBSgCiAIgAWogCToAACAFIAFBAWo2AowCIAVBIGogBUGwAWogCSAEEIkLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTMgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMJAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwoCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIkeIgdBDGoiChDZPCEDIAoQ2TwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ8x4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENk8IhFFDSIgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0tIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK4MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IARqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEK0oCyAFKAKIAiABQQF0aiAJOwEAIAUgAUEBajYCjAIgBUEoaiAFQbABaiAJIAQQhgsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNMiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwiCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEUUNICAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDS0gBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQqwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgBGogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqIAk2AgAgBSABQQFqNgKMAiAFQTBqIAVBsAFqIAkgBBCKCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0xIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCALIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJgsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCHHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEO8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCINRQ0eIAVB3AFqIQYgBUHQAWohCyAFQZACaiERIAVBhAJqIQ4gBUHAAWohEkEAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NLSAFIAcoAhAgA0EDdGopAwAiJTcD0AICQAJAAkAgBSgCvAFFDQAgEiAFQdACahCsDCEkIAUoArABIgRBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAJcSECDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDCAFKAKUAiIPIAJJBEAgESAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgAjYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJTcDACAFIAFBAWo2AowCIAVBOGogBUGwAWogJSAEEIULDAELIARBACAMa0EEdGpBCGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTAgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMHgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwlCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIUeIgdBDGoiChDZPCEDIAoQ2TwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQ9B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENk8IhFFDRwgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0qIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK4MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAwgJHqnQQN2IARqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEK0oCyAFKAKIAiABQQF0aiAJOwEAIAUgAUEBajYCjAIgBUFAayAFQbABaiAJIAQQggsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwcCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCQLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiDUUNGiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSogBSAHKAIQIANBAnRqKgIAIis4AtACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgCCAkeqdBA3YgAmogCXEiDEEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqICs4AgAgBSABQQFqNgKMAiAFQcgAaiAFQbABaiArIAQQjAsMAQsgBEEAIAxrQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwaCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCMLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgh4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhD2HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNGCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSogBSAHKAIQIANBA3RqKwMAIiw5A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICw5AwAgBSABQQFqNgKMAiAFQdAAaiAFQbABaiAsIAQQhAsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNLSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwYCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCILIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDCELIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN0JDCALIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDB8LIAVBBDoAsAEgACABIAIgBUGwAWogAyAEEN0JDB4LIAVBBToAsAEgACABIAIgBUGwAWogAyAEEN0JDB0LIAMoAgQhAyAFQRU6AMADIAUgAzYCxAMgBUGwAWogASACIAVBwANqIgcgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiBEGTgICAeEcEQCAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAcQpgwMHQsgBSABNgLUAiAFIAI2AtACIAVBwANqEKYMIAVB4ABqIAVB0AJqELkmIAVBsAFqIAUoAmAiEiAFKAJkKAIMEQAAAkAgEgRAIAUpA7ABQsDjtd7S/qWVLIUgBSkDuAFC9c6oqNH+2sykf4WEUA0BCyAFQbABakEvQQBBAUEBEKAYIAUoArQBIQEgBSgCsAFBAUYNCSAFKAK4ASICQey1/wBBL/wKAAAgAEEvNgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwRCyAFQbABaiIBQdi4gAFB+LiAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgAUEgahCvNCABQTRqQYAIEPgeIAFB6ABqQYAIIAMQjxcgASADNgIwIBIoAjAiHkUNDyAFQfABaiEWIAVB5AFqIRdBACEDA0ACQCASIAMQmyVFBEAgBUHYAGogEiADEKAbIAUoAlghDyAFKAJcIREjAEEwayIHJAAgBUHAA2oiDAJ/IBEgBUGwAWoiBCgCMEYEQCMAQUBqIgIkACACIBE2AgQgAiAPNgIAIAQgDyAREM0CISQgAiAEQTBqIgE2AjwgAiAEQegAaiIYNgI4IAIgAjYCNCACIAE2AhAgAiAYNgIMIAIgBDYCCCACQRhqIQ0gAkE0aiEQIAJBCGoiHyEBQQAhCkEAIRNBACEVQQAhGUEAIRojAEEgayIOJAAgBEEgaiIGKAIIRQRAIA5BGGogAUEIaigCADYCACAOIAEpAgA3AxAgDkEIaiEbIwBB4ABrIgEkACABIA5BEGo2AiACQCAGKAIMIglBAWoiCyAJTwRAAkAgBigCBCIJIAlBAWpBA3ZBB2wgCUEISRsiCUEBdiALSQRAAkACQCAJQQFqIgogCyAKIAtLGyIKQQ9PBEAgCkH/////AUsNAUF/IApBA3RBB25BAWtndkEBaiEKDAILQQRBCEEQIApBCEkbIApBBEkbIQoMAQsQ3ScgASgCHCEKIAEoAhgiC0GBgICAeEcNBAsgAUHQAGogBkEQaiIIQQQgChD7FCABKAJYIQogASgCVCELIAEoAlAiCUUNAyABIAEoAlw2AkwgASAKNgJIIAEgCzYCRCABIAk2AkAgAUEQaiABQUBrEME0IAEoAhQiCgRAIAEoAhBB/wEgCvwLAAsgASgCSCEKIAEoAkQhCyABKAJAIglFDQMgASABKAJMNgI8IAEgCjYCOCABIAs2AjQgASAJNgIwIAFChICAgIABNwIoIAEgCDYCJCABQTBqISAgASAGKAIMIhwEfyAJQQhqISEgBigCACIdKQMAQn+FQoCBgoSIkKDAgH+DISUDQCAlUARAA0AgE0EIaiETIB1BCGoiHSkDAEKAgYKEiJCgwIB/gyIlQoCBgoSIkKDAgH9RDQALICVCgIGChIiQoMCAf4UhJQsgASgCICIIKAIAIRQgAUEIaiAIKAIEIAgoAggoAgAgBigCACAleqdBA3YgE2pBAnQiImtBBGsoAgAQyiUgCSALIBQgASgCCCABKAIMEM0CpyIjcSIIaikAAEKAgYKEiJCgwIB/gyImUARAQQghFANAIAggFGohCCAUQQhqIRQgCSAIIAtxIghqKQAAQoCBgoSIkKDAgH+DIiZQDQALCyAlQgF9ICWDISUgCSAmeqdBA3YgCGogC3EiCGosAABBAE4EQCAJKQMAQoCBgoSIkKDAgH+DeqdBA3YhCAsgCCAJaiAjQRl2IhQ6AAAgISAIQQhrIAtxaiAUOgAAIAkgCEECdGtBBGsgBigCACAia0EEaygAADYAACAcQQFrIhwNAAsgBigCDAVBAAsiCzYCPCABIAogC2s2AjggBiAgQQQQ+iogAUEkahD1JwwBCyAGIAFBIGpBsNiAARDuCQtBgYCAgHghCwwBCxDdJyABKAIEIQogASgCACELCyAbIAo2AgQgGyALNgIAIAFB4ABqJAALIAYoAgQiCiAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+IScgECgCCCEIIBAoAgQhEyAQKAIAIQkgBigCACELA0ACQCABIAtqKQAAIiYgJ4UiJUJ/hSAlQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DISUCfwJAIA0CfgJAA0AgJVANASAOIBMgCCgCACAGKAIAICV6p0EDdiABaiAKcSIUQQJ0a0EEaygCABDKJSAlQgF9ICWDISUgCSgCACAJKAIEIA4oAgAgDigCBBCfO0UNAAsgDSAkNwMIIA0gBigCAEEAIBRrQQJ0ajYCEEIADAELICZCgIGChIiQoMCAf4MhJSAZRQRAICVQDQIgJXqnQQN2IAFqIApxIRULQQEgJSAmQgGGg1ANAhogDSALIBVqLAAAQQBOBH8gCykDAEKAgYKEiJCgwIB/g3qnQQN2BSAVCzYCECANICQ3AwhCAQs3AwAgDSAGNgIUIA5BIGokAAwCC0EACyEZIAEgGkEIaiIaaiAKcSEBDAELCyACIBE2AjwgAiAPNgI4IAIgGDYCNCAfIA0gEBCLEyACKAIQQQRrNQIAISQgAkGQgICAeDYCGCANEIgRIAdBGGoiAUEANgIAIAEgJDcDCCACQUBrJAAgBygCGARAIAcoAhwhASAHKQMgISQgDCAHKQMoNwMQIAwgJDcDCCAMIAE2AgRBAQwCCyAHKQMgISQCQCAEKAJABEAgBCgCUCIGQQFqIgpBA3YgCkEHcUEAR2oiASAEKAJMIgJLBEAgASACayELIAQoAkQiDiABSQRAIARBQGsgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSAEKAJMIQILIAsEQCAEKAJIIAJqQQAgC/wLAAsgBCABNgJMCyAEIAo2AlAgBCgCSCAGQQN2aiIBIAEtAABBASAGQQdxdHI6AAAMAQsgBCAEKAJUQQFqNgJUCyAEKAI8IgEgBCgCNEYEQCAEQTRqQci1gAEQsygLIAQoAjggAUEDdGogJDcDACAMICQ3AwggBCABQQFqNgI8QQAMAQsgByARNgIEIAdBAjYCHCAHQaC3gAE2AhggB0ICNwIkIAdBOzYCFCAHQZwDNgIMIAcgBEEwajYCCCAHIAdBCGo2AiAgByAHQQRqNgIQIAxBCGogB0EYahCZDiAMQY2AgIB4NgIEQQELNgIAIAdBMGokACAFKALAA0UNASAFKALEAyEBIAUpA8gDISQgACAFKQPQAzcCDCAAICQ3AgQgACABNgIAIAVB0AFqEI47IBcQtC0gBUGYAmoQii8MEwsgFhDmOiAFKALwAUUNJiAFKAKAAkEBaiIEQQN2IARBB3FBAEdqIgIgBSgC/AEiAUsEQCACIAFrIQcgBSgC9AEiBiACSQRAIBYgBkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiBiABIAZLGxDoGSAFKAL8ASEBCyAHBEAgBSgC+AEgAWpBACAH/AsACyAFIAI2AvwBCyAFIAQ2AoACIAUoAuwBIgEgBSgC5AFGBEAgF0GAnf8AELMoCyAFKALoASABQQN0akIANwMAIAUgAUEBajYC7AELIB4gA0EBaiIDRw0ACwwPCyADLQACIREgAy0AASESIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQiB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ+B4gAUHEAGogAhCfHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiD0UNDiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohECAFQYQCaiEOIAVBwAFqIRNBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSIgBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgDCAkeqdBA3YgBGogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiFSACSQRAIBAgFUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiFSABIBVLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQnSgLIAUoAogCIAFBAnRqIAk2AgAgBSABQQFqNgKMAiAFQfAAaiAFQbABaiAJIAQQiAsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNJiAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyAPRw0ACwwOCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBsLIAMtAAIhDSADLQABIREgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCNHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxD4HiABQcQAaiACEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCISRQ0MIAVB3AFqIQYgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NIiAFIAcoAhAgA0EDdGopAwAiJTcD0AICQAJAAkAgBSgCvAFFDQAgECAFQdACahCsDCEkIAUoArABIgRBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJ0EAIQEDQCACIARqKQAAIiYgJ4UiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSIMQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICYgJkIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgAUEIaiIBaiAJcSECDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDCAFKAKUAiITIAJJBEAgDyATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoApwCIQELIAwEQCAFKAKYAiABakEAIAz8CwALIAUgAjYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCzKAsgBSgCiAIgAUEDdGogJTcDACAFIAFBAWo2AowCIAVBgAFqIAVBsAFqICUgBBCLCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASITIAJJBEAgBiATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0lIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBJHDQALDAwLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGgsgAy0AAiENIAMtAAEhESAFQbABaiIHIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIYeIgZBDGoiChDaPCEDIAoQ2jwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQoB4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQSBBEAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgB0EgaiABQRBqQTT8CgAAIAdB1ABqIAFBxABqQTT8CgAAIAcgJTcDGCAHICY3AxAgByAkNwMIIAcgAjYCBCAHIAM2AgAgAUGQAWokACAKENo8IhJFDQogBUHcAWohByAFQdABaiELIAVBkAJqIQ8gBUGEAmohDiAFQcABaiEQQQAhAwNAAkAgBiADEIclRQRAIAUgAzYCyAIgChDaPCADTQ0KIAYoAhAgA0EEdGoiASkDACElIAUgASkDCCImNwPYAiAFICU3A9ACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQsAwhJCAFKAKwASIEQSBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+IShBACEBA0AgAiAEaikAACInICiFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQRAgCCAkeqdBA3YgAmogCXEiDEEFdGtBEBCfOw0EICRCAX0gJIMiJFBFDQALCyAnICdCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsSgLIAUoAogCIAFBBHRqIgIgJjcDCCACICU3AwAgBSABQQFqNgKMAiAFQZABaiAFQbABaiAlICYgBBDUCgwBCyAEQQAgDGtBBXRqQRBrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASITIAJJBEAgByATQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyITIAEgE0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAHEOY6IAUoAtwBRQ0kIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgByAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBJHDQALDAoLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGQsgAy0AAiENIAMtAAEhESAFQbABaiIHIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIAeIgZBDGoiChDcPCEDIAoQ3DwhAiMAQZABayIBJAAgAUEQaiADEPgeIAFBxABqIAIQoh4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQTBBEAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgB0EgaiABQRBqQTT8CgAAIAdB1ABqIAFBxABqQTT8CgAAIAcgJTcDGCAHICY3AxAgByAkNwMIIAcgAjYCBCAHIAM2AgAgAUGQAWokACAKENw8IhJFDQggBUHcAWohByAFQdABaiELIAVBkAJqIQ8gBUGEAmohDiAFQcABaiEQQQAhAwNAAkAgBiADEIclRQRAIAUgAzYCyAIgChDcPCADTQ0KIAYoAhAgA0EFdGoiASkDACElIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICU3A8ADAkACQAJAIAUoArwBRQ0AIBAgBUHAA2oQrQwhJCAFKAKwASIEQTBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEBA0AgAiAEaikAACIpICqFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVBwANqQSAgCCAkeqdBA3YgAmogCXFBUGwiDGpBIBCfOw0EICRCAX0gJIMiJFBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAOELIoCyAFKAKIAiACQQV0aiIBICg3AxggASAnNwMQIAEgJjcDCCABICU3AwAgBSACQQFqNgKMAiAFQaABaiAFQbABaiAlICYgJyAoIAQQlwoMAQsgBCAMakEQaygCACEECyAFQZCAgIB4NgLQAiAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAcgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBxDmOiAFKALcAUUNIyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAcgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwICyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGUqNCgATYCACADQpSo0KDBgoWKFDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCkJ6z7tm0jZLpAIUgAykDKEKI9KuB4LHF5MIAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0iIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EIslIAQQ0zoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQvQ8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuiwMBAsgBhDmOiADKAJcRQ0lIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQjhFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIwsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwYCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiyUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSMgAygCyAEiAUG+tf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0oIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgAygCwAEgAhCsHyADQagBaiADQRBqIAMoAgAgAygCBBC9DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSMgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCOEUHQAEEEEK02IgFFDSEgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELosIANBkAJqJAAMFwsgASACKAIcEQQAQdSw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZas2LABNgIAIANClqzYsOHChYsWNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELCjPf26svc0YR/hSADKQMoQuWT9Jj5r/joqH+FhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDSEgAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQjCUgBBDUOiIJBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8hYgA0G4AWogA0EgaiIBIAMoAgggAygCDBC8DyADKAK4AUUNASADKAK8ASECIAMpA8ABISQgACADKQPIATcCDCAAICQ3AgQgACACNgIAIAEQjjsgChC0LSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSQgAygCbEEBaiILQQN2IAtBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshDiADKAJgIgggAUkEQCAGIAhBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgggAiAISxsQ6BkgAygCaCECCyAOBEAgAygCZCACakEAIA78CwALIAMgATYCaAsgAyALNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCzKAsgAygCVCABQQN0akIANwMAIAMgAUEBajYCWAsgCSAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBCWEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQtC0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwiCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBcLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCMJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNIiADKALIASIBQb61/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohCwNAAkACQCADKALEAQRAIAIgAygC1AFPDScgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADKALAASACEKwfIANBqAFqIANBEGogAygCACADKAIEELwPIAMoAqgBRQ0BIAMoAqwBIQEgAykDsAEhJCAAIAMpA7gBNwIMIAAgJDcCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCxD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNIiADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiDiABSQRAIAQgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AELMoCyADKAJEIAFBA3RqQgA3AwAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEJYRQdAAQQQQrTYiAUUNICABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQtC0gA0H0AGoQuywgA0GQAmokAAwWCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmLDgwAE2AgAgA0KYsODAgYOGjBg3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQsfZ9OfexLacd4UgAykDKEKNss6UjMqS5qd/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0gIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EIslIAQQ0zoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEP8WIANBuAFqIANBIGoiASADKAIIIAMoAgwQtg8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuiwMBAsgBhDmOiADKAJcRQ0jIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQkRFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELosIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIQsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwWCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQiyUgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0hIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJiADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GoAWogA0EQaiADKAIAIAMoAgQQtg8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0hIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQkRFB0ABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC6LCADQZACaiQADBULIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGZsuTIATYCACADQpmy5MiRo8aMGTcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBC09jT+P3m9pJIhSADKQMoQqLYnojhoOrpzACFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDR8gAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQjCUgBBDUOiIJBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBC5DyADKAK4AUUNASADKAK8ASECIAMpA8ABISQgACADKQPIATcCDCAAICQ3AgQgACACNgIAIAEQjjsgChC0LSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSIgAygCbEEBaiILQQN2IAtBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshDiADKAJgIgggAUkEQCAGIAhBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgggAiAISxsQ6BkgAygCaCECCyAOBEAgAygCZCACakEAIA78CwALIAMgATYCaAsgAyALNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCzKAsgAygCVCABQQN0akIANwMAIAMgAUEBajYCWAsgCSAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBCUEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQtC0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwgCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBULIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABCMJSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSAgAygCyAEiAUGQtf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0lIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgA0HAAWogAhCtKiADQagBaiADQRBqIAMoAgAgAygCBBC5DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSAgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahCUEUHQAEEEEK02IgFFDR4gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELssIANBkAJqJAAMFAsgASAFKAK4AUHQoP8AEP0vAAsgBSAGEP87NgKgAwwXCyAFIAYQgDw2AqADDBYLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDaFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0fIAMgCkEw/AoAACAHIAMQhj4gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwdCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahC0LSAFQYQCahC2LSACQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVByKX/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCVKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgESANEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiILIAIpAwA3AwAgBUGvA2oiDiAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiALKQMANwAAIAFBGGogDikAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUHUsv8AEOEJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0dIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR4gAyAKQTD8CgAAIAcgAxD+PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBwLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELUtIAJBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUHIpf8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJUrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiARIA0QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0XIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQfyx/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCwwZCwwYCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRwgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHSADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMGwsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcil/wA2AswCIAUgATYCyAIgBUH4AGogBUHIAmoQlSsQ4iECQAJAIAUoAngiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQeC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAnwQgBUgBUGwAWogAiARIA0QohMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0WIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQaSx/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCwwYCwwXCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1xQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRsgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMGgsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQcil/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlSsQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiASIBEQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0VIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQayz/wAQ4QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNDyAFQcgCahC7IwwPCwwXCwwWCyAFQcADaiEEIwBBkANrIgEkACAFQbABaiICQSBqEJc2IAFBCGoiBiACQegAahDHFCABQUBrIgcgAkE0ahDbFAJAQQxBBBCtNiIDBEAgA0KFipSo0KDBggU3AgAgA0EIakGFipQoNgIAIAIoAjAhCkEMQQQQrTYiAkUNGiACIAo2AgQgAkEVOgAAIAEgAjYCeCABIAM2AnQgAUEiOgBwIAFB2AFqIgMgBxDwPSABQbQCaiICIAMQoRsgAyACIAFB8ABqEIwYQcQAQQQQrTYiB0UNGyAHIAYQ7z0gAUEBNgK8AiABIAc2ArgCIAFBATYCtAIgAUH8AGoiByADIAIQ/CIgAiAHEM0cIAQgAhCgCCABQZADaiQADAELDBkLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQjjsgBUHkAWoQtC0gBUGYAmoQii8gBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0NIAVB0AJqELsjDA0LDBULIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQdACahC7IwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRggByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNGSADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMFwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUGIA2oQuyMMCwsMEwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM0UIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0XIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRggAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDVFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0XIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwVC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCSAFQYgDahC7IwwJCwwRCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRUgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFiADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMFAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQggBUGIA2oQuyMMCAsMEAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENQUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0UIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRUgAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDPFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0UIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwSC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBiAFQYgDahC7IwwGCwwOCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRIgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNEyADIApBMPwKAAAgByADEPc9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMEQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCxLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQUgBUGIA2oQuyMMBQsMDQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENsUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0RIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRIgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQcil/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDQFCABQTRqIgsgAkEgahDbFAJAQQxBBBCtNiIEBEAgBEKFipSo0KDBggU3AgAgBEEIakGFipQoNgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNECAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0RIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoAggAUGQA2okAAwBCwwPC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELMtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAyAFQYgDahC7IwwDCwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiILIAJBIGoQ2xQCQEEMQQQQrTYiBARAIARChYqUqNCgwYIFNwIAIARBCGpBhYqUKDYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDQ8gByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNECADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKAIIAFBkANqJAAMAQsMDgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABByKX/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQIgBUGIA2oQuyMMAgsMCgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENYUIAFBNGoiCyACQSBqENsUAkBBDEEEEK02IgQEQCAEQoWKlKjQoMGCBTcCACAEQQhqQYWKlCg2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0OIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDQ8gAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCgCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHIpf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgBxCjPDYCoAMMAwsgBSAHEP47NgKgAwwCCyAFIAcQ/Ds2AqADDAELIAUgBxD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgAiADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAIgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQAL4usCBB9/B34BfQF8IwBBkARrIgUkACAFIAM2AqwBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAABBAmsOJQECAwQFBgcICQoLDA0ODxAAABYRFwAYGQAAAAAAAAAAABITFBUACyAFQQE2ArQBIAVBnLH/ADYCsAEgBUIBNwK8ASAFQa8DNgLUAiAFIAVB0AJqNgK4ASAFIAVBrAFqNgLQAiAFQcADaiAFQbABahCZDiAAQYKAgIB4NgIAIAAgBSkCwAM3AgQgAEEMaiAFQcgDaigCADYCAAwtCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIEeIgdBDGoiCigCCCEDIAooAgghAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKKAIIIhFFDSwgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0xIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEK8MISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAwgJHqnQQN2IARqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEKMoCyAFKAKIAiABaiAJOgAAIAUgAUEBajYCjAIgBSAFQbABaiAJIAQQhwsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNyAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwsCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCwLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjh4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEUUNKiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENk8IANNDTEgBSAHKAIQIANBAXRqLwEAIgk7AdACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrgwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQIgDCAkeqdBA3YgBGogCHEiDUEDdGtBAhCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQrSgLIAUoAogCIAFBAXRqIAk7AQAgBSABQQFqNgKMAiAFQQhqIAVBsAFqIAkgBBCDCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ02IAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCoLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKwsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCDHiIHQQxqIgoQ2zwhAyAKENs8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPkeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDbPCIRRQ0oIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2zwgA00NMSAFIAcoAhAgA0ECdGooAgAiCTYC0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCrDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBBCAMICR6p0EDdiAEaiAIcSINQQN0a0EEEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCdKAsgBSgCiAIgAUECdGogCTYCACAFIAFBAWo2AowCIAVBEGogBUGwAWogCSAEEIgLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTUgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMKAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwqCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIoeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ+B4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDSYgBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0xIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiBEEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhAQNAIAIgBGopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgxBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELMoCyAFKAKIAiABQQN0aiAlNwMAIAUgAUEBajYCjAIgBUEYaiAFQbABaiAlIAQQiwsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDyACSQRAIAYgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNNCAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwmCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCkLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQix4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEUUNJCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohEiAFQYQCaiEOIAVBwAFqIQ9BACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiADIAooAghPDS0gBSAHKAIQIANqLQAAIgk6ANACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrwwhJCAFKAKwASICQQhrIQwgBSgCtAEiCCAkp3EhBCAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACEBA0AgAiAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQEgDCAkeqdBA3YgBGogCHEiDUEDdGtBARCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASAEIAFBCGoiAWogCHEhBAwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCEEBaiIMQQN2IAxBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQ0gBSgClAIiECACSQRAIBIgEEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiECABIBBLGxDoGSAFKAKcAiEBCyANBEAgBSgCmAIgAWpBACAN/AsACyAFIAI2ApwCCyAFIAw2AqACIAUoApgCIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQqRkLIAUoAogCIAFqIAk6AAAgBSABQQFqNgKMAiAFQSBqIAVBsAFqIAkgBBCJCwwBCyACQQAgDWtBA3RqQQRrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASINIAJJBEAgBiANQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyINIAEgDUsbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0zIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIBFHDQALDCQLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMKAsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCJHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPMeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0iIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NLSAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBKGogBUGwAWogCSAEEIYLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDTIgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMIgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwnCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIweIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8IhFFDSAgBUHcAWohBiAFQdABaiELIAVBkAJqIRIgBUGEAmohDiAFQcABaiEPQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0tIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAPIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhAgAkkEQCASIBBBAXQiASACQcD///8DcUFAayACIAJBP3EbIhAgASAQSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUEwaiAFQbABaiAJIAQQigsMAQsgAkEAIA1rQQN0akEEaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiDSACSQRAIAYgDUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDSABIA1LGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNMSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwgCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCYLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhx4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNHiAFQdwBaiEGIAVB0AFqIQsgBUGQAmohESAFQYQCaiEOIAVBwAFqIRJBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDS0gBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBIgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiDyACSQRAIBEgD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQThqIAVBsAFqICUgBBCFCwwBCyAEQQAgDGtBBHRqQQhrKAIAIQQLIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshDCAFKALgASIPIAJJBEAgBiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAUoAugBIQELIAwEQCAFKALkASABakEAIAz8CwALIAUgAjYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRgRAIAtBkJ3/ABCzKAsgBK0hJAwBCyAGEOY6IAUoAtwBRQ0wIAUoAuwBQQFqIgRBA3YgBEEHcUEAR2oiAiAFKALoASIBSwRAIAIgAWshCSAFKALgASIIIAJJBEAgBiAIQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIIIAEgCEsbEOgZIAUoAugBIQELIAkEQCAFKALkASABakEAIAn8CwALIAUgAjYC6AELIAUgBDYC7AFCACEkIAUoAtgBIgIgBSgC0AFHDQAgC0GAnf8AELMoCyAFKALUASACQQN0aiAkNwMAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDB4LIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMJQsgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCFHiIHQQxqIgoQ2TwhAyAKENk8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEPQeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDZPCIRRQ0cIAVB3AFqIQYgBUHQAWohCyAFQZACaiESIAVBhAJqIQ4gBUHAAWohD0EAIQMDQAJAIAcgAxCHJUUEQCAFIAM2AsgCIAoQ2TwgA00NKiAFIAcoAhAgA0EBdGovAQAiCTsB0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCuDCEkIAUoArABIgJBCGshDCAFKAK0ASIIICSncSEEICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQEDQCACIARqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBAiAMICR6p0EDdiAEaiAIcSINQQN0a0ECEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAQgAUEIaiIBaiAIcSEEDAALAAsgDigCCCEEAkAgBSgCkAIEQCAFKAKgAiIIQQFqIgxBA3YgDEEHcUEAR2oiAiAFKAKcAiIBSwRAIAIgAWshDSAFKAKUAiIQIAJJBEAgEiAQQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIQIAEgEEsbEOgZIAUoApwCIQELIA0EQCAFKAKYAiABakEAIA38CwALIAUgAjYCnAILIAUgDDYCoAIgBSgCmAIgCEEDdmoiASABLQAAQQEgCEEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiIBIAUoAoQCRgRAIA5BkJ3/ABCtKAsgBSgCiAIgAUEBdGogCTsBACAFIAFBAWo2AowCIAVBQGsgBUGwAWogCSAEEIILDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS8gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMHAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwkCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIQeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ8R4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8Ig1FDRogBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0qIAUgBygCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKsMISQgBSgCsAEiBEEIayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAggJHqnQQN2IAJqIAlxIgxBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiArOAIAIAUgAUEBajYCjAIgBUHIAGogBUGwAWogKyAEEIwLDAELIARBACAMa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS4gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwjCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIIeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDRggBUHcAWohBiAFQdABaiELIAVBkAJqIREgBUGEAmohDiAFQcABaiESQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0qIAUgBygCECADQQN0aisDACIsOQPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiBEEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgxBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIg8gAkkEQCARIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELMoCyAFKAKIAiABQQN0aiAsOQMAIAUgAUEBajYCjAIgBUHQAGogBUGwAWogLCAEEIQLDAELIARBACAMa0EEdGpBCGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg8gAkkEQCAGIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDS0gBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwiCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwhCyAFQQQ6ALABIAAgASACIAVBsAFqIAMgBBDaCQwgCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwfCyAFQQQ6ALABIAAgASACIAVBsAFqIAMgBBDaCQweCyAFQQU6ALABIAAgASACIAVBsAFqIAMgBBDaCQwdCyADKAIEIQMgBUEVOgDAAyAFIAM2AsQDIAVBsAFqIAEgAiAFQcADaiIHIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgRBk4CAgHhHBEAgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgBDYCACAHEKYMDB0LIAUgATYC1AIgBSACNgLQAiAFQcADahCmDCAFQeAAaiAFQdACahC5JiAFQbABaiAFKAJgIhIgBSgCZCgCDBEAAAJAIBIEQCAFKQOwAULA47Xe0v6llSyFIAUpA7gBQvXOqKjR/trMpH+FhFANAQsgBUGwAWpBL0EAQQFBARCgGCAFKAK0ASEBIAUoArABQQFGDQkgBSgCuAEiAkHstf8AQS/8CgAAIABBLzYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMEQsgBUGwAWoiAUHYuIABQfi4gAEQhTUiAigCACACKAIEKAIMEQQAENoBIAFBIGoQrzQgAUE0akGACBDvHiABQegAakGACCADEI8XIAEgAzYCMCASKAIwIh5FDQ8gBUHwAWohFiAFQeQBaiEXQQAhAwNAAkAgEiADEJslRQRAIAVB2ABqIBIgAxCgGyAFKAJYIQ8gBSgCXCERIwBBMGsiByQAIAVBwANqIgwCfyARIAVBsAFqIgQoAjBGBEAjAEFAaiICJAAgAiARNgIEIAIgDzYCACAEIA8gERDNAiEkIAIgBEEwaiIBNgI8IAIgBEHoAGoiGDYCOCACIAI2AjQgAiABNgIQIAIgGDYCDCACIAQ2AgggAkEYaiENIAJBNGohECACQQhqIh8hAUEAIQpBACETQQAhFUEAIRlBACEaIwBBIGsiDiQAIARBIGoiBigCCEUEQCAOQRhqIAFBCGooAgA2AgAgDiABKQIANwMQIA5BCGohGyMAQeAAayIBJAAgASAOQRBqNgIgAkAgBigCDCIJQQFqIgsgCU8EQAJAIAYoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgC0kEQAJAAkAgCUEBaiIKIAsgCiALSxsiCkEPTwRAIApB/////wFLDQFBfyAKQQN0QQduQQFrZ3ZBAWohCgwCC0EEQQhBECAKQQhJGyAKQQRJGyEKDAELEN0nIAEoAhwhCiABKAIYIgtBgYCAgHhHDQQLIAFB0ABqIAZBEGoiCEEEIAoQ+xQgASgCWCEKIAEoAlQhCyABKAJQIglFDQMgASABKAJcNgJMIAEgCjYCSCABIAs2AkQgASAJNgJAIAFBEGogAUFAaxDBNCABKAIUIgoEQCABKAIQQf8BIAr8CwALIAEoAkghCiABKAJEIQsgASgCQCIJRQ0DIAEgASgCTDYCPCABIAo2AjggASALNgI0IAEgCTYCMCABQoSAgICAATcCKCABIAg2AiQgAUEwaiEgIAEgBigCDCIcBH8gCUEIaiEhIAYoAgAiHSkDAEJ/hUKAgYKEiJCgwIB/gyElA0AgJVAEQANAIBNBCGohEyAdQQhqIh0pAwBCgIGChIiQoMCAf4MiJUKAgYKEiJCgwIB/UQ0ACyAlQoCBgoSIkKDAgH+FISULIAEoAiAiCCgCACEUIAFBCGogCCgCBCAIKAIIKAIAIAYoAgAgJXqnQQN2IBNqQQJ0IiJrQQRrKAIAEMolIAkgCyAUIAEoAgggASgCDBDNAqciI3EiCGopAABCgIGChIiQoMCAf4MiJlAEQEEIIRQDQCAIIBRqIQggFEEIaiEUIAkgCCALcSIIaikAAEKAgYKEiJCgwIB/gyImUA0ACwsgJUIBfSAlgyElIAkgJnqnQQN2IAhqIAtxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogI0EZdiIUOgAAICEgCEEIayALcWogFDoAACAJIAhBAnRrQQRrIAYoAgAgImtBBGsoAAA2AAAgHEEBayIcDQALIAYoAgwFQQALIgs2AjwgASAKIAtrNgI4IAYgIEEEEPoqIAFBJGoQ9ScMAQsgBiABQSBqQaDdgAEQ7gkLQYGAgIB4IQsMAQsQ3ScgASgCBCEKIAEoAgAhCwsgGyAKNgIEIBsgCzYCACABQeAAaiQACyAGKAIEIgogJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEnIBAoAgghCCAQKAIEIRMgECgCACEJIAYoAgAhCwNAAkAgASALaikAACImICeFIiVCf4UgJUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyElAn8CQCANAn4CQANAICVQDQEgDiATIAgoAgAgBigCACAleqdBA3YgAWogCnEiFEECdGtBBGsoAgAQyiUgJUIBfSAlgyElIAkoAgAgCSgCBCAOKAIAIA4oAgQQnztFDQALIA0gJDcDCCANIAYoAgBBACAUa0ECdGo2AhBCAAwBCyAmQoCBgoSIkKDAgH+DISUgGUUEQCAlUA0CICV6p0EDdiABaiAKcSEVC0EBICUgJkIBhoNQDQIaIA0gCyAVaiwAAEEATgR/IAspAwBCgIGChIiQoMCAf4N6p0EDdgUgFQs2AhAgDSAkNwMIQgELNwMAIA0gBjYCFCAOQSBqJAAMAgtBAAshGSABIBpBCGoiGmogCnEhAQwBCwsgAiARNgI8IAIgDzYCOCACIBg2AjQgHyANIBAQixMgAigCEEEEazUCACEkIAJBkICAgHg2AhggDRCIESAHQRhqIgFBADYCACABICQ3AwggAkFAayQAIAcoAhgEQCAHKAIcIQEgBykDICEkIAwgBykDKDcDECAMICQ3AwggDCABNgIEQQEMAgsgBykDICEkAkAgBCgCQARAIAQoAlAiBkEBaiIKQQN2IApBB3FBAEdqIgEgBCgCTCICSwRAIAEgAmshCyAEKAJEIg4gAUkEQCAEQUBrIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgBCgCTCECCyALBEAgBCgCSCACakEAIAv8CwALIAQgATYCTAsgBCAKNgJQIAQoAkggBkEDdmoiASABLQAAQQEgBkEHcXRyOgAADAELIAQgBCgCVEEBajYCVAsgBCgCPCIBIAQoAjRGBEAgBEE0akHItYABELMoCyAEKAI4IAFBA3RqICQ3AwAgDCAkNwMIIAQgAUEBajYCPEEADAELIAcgETYCBCAHQQI2AhwgB0Ggt4ABNgIYIAdCAjcCJCAHQTs2AhQgB0GcAzYCDCAHIARBMGo2AgggByAHQQhqNgIgIAcgB0EEajYCECAMQQhqIAdBGGoQmQ4gDEGNgICAeDYCBEEBCzYCACAHQTBqJAAgBSgCwANFDQEgBSgCxAMhASAFKQPIAyEkIAAgBSkD0AM3AgwgACAkNwIEIAAgATYCACAFQdABahCOOyAXELQtIAVBmAJqEIovDBMLIBYQ5jogBSgC8AFFDSYgBSgCgAJBAWoiBEEDdiAEQQdxQQBHaiICIAUoAvwBIgFLBEAgAiABayEHIAUoAvQBIgYgAkkEQCAWIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBSgC/AEhAQsgBwRAIAUoAvgBIAFqQQAgB/wLAAsgBSACNgL8AQsgBSAENgKAAiAFKALsASIBIAUoAuQBRgRAIBdBgJ3/ABCzKAsgBSgC6AEgAUEDdGpCADcDACAFIAFBAWo2AuwBCyAeIANBAWoiA0cNAAsMDwsgAy0AAiERIAMtAAEhEiAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIgeIgdBDGoiChDbPCEDIAoQ2zwhAiMAQZABayIBJAAgAUEQaiADEO8eIAFBxABqIAIQnx4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQQhBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENs8Ig9FDQ4gBUHcAWohBiAFQdABaiELIAVBkAJqIRAgBUGEAmohDiAFQcABaiETQQAhAwNAAkAgByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0iIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACATIAVB0AJqEKsMISQgBSgCsAEiAkEIayEMIAUoArQBIgggJKdxIQQgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAQNAIAIgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAwgJHqnQQN2IARqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgBCABQQhqIgFqIAhxIQQMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIghBAWoiDEEDdiAMQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayENIAUoApQCIhUgAkkEQCAQIBVBAXQiASACQcD///8DcUFAayACIAJBP3EbIhUgASAVSxsQ6BkgBSgCnAIhAQsgDQRAIAUoApgCIAFqQQAgDfwLAAsgBSACNgKcAgsgBSAMNgKgAiAFKAKYAiAIQQN2aiIBIAEtAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AEJ0oCyAFKAKIAiABQQJ0aiAJNgIAIAUgAUEBajYCjAIgBUHwAGogBUGwAWogCSAEEIgLDAELIAJBACANa0EDdGpBBGsoAgAhBAsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIg0gAkkEQCAGIA1BAXQiASACQcD///8DcUFAayACIAJBP3EbIg0gASANSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAYQ5jogBSgC3AFFDSYgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAGIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgD0cNAAsMDgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwbCyADLQACIQ0gAy0AASERIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjR4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ7x4gAUHEAGogAhChHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiEkUNDCAFQdwBaiEGIAVB0AFqIQsgBUGQAmohDyAFQYQCaiEOIAVBwAFqIRBBACEDA0ACQCAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSIgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIBAgBUHQAmoQrAwhJCAFKAKwASIEQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEBA0AgAiAEaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiDEEEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIAFBCGoiAWogCXEhAgwACwALIA4oAgghBAJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgCnAIiAUsEQCACIAFrIQwgBSgClAIiEyACSQRAIA8gE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKAKcAiEBCyAMBEAgBSgCmAIgAWpBACAM/AsACyAFIAI2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiASAFKAKEAkYEQCAOQZCd/wAQsygLIAUoAogCIAFBA3RqICU3AwAgBSABQQFqNgKMAiAFQYABaiAFQbABaiAlIAQQiwsMAQsgBEEAIAxrQQR0akEIaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAYgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBhDmOiAFKALcAUUNJSAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAYgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwMCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBoLIAMtAAIhDSADLQABIREgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCGHiIGQQxqIgoQ2jwhAyAKENo8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEgQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDaPCISRQ0KIAVB3AFqIQcgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAYgAxCHJUUEQCAFIAM2AsgCIAoQ2jwgA00NCiAGKAIQIANBBHRqIgEpAwAhJSAFIAEpAwgiJjcD2AIgBSAlNwPQAgJAAkACQCAFKAK8AUUNACAQIAVB0AJqELAMISQgBSgCsAEiBEEgayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEoQQAhAQNAIAIgBGopAAAiJyAohSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEQIAggJHqnQQN2IAJqIAlxIgxBBXRrQRAQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJyAnQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIhMgAkkEQCAPIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgEgBSgChAJGBEAgDkGQnf8AELEoCyAFKAKIAiABQQR0aiICICY3AwggAiAlNwMAIAUgAUEBajYCjAIgBUGQAWogBUGwAWogJSAmIAQQ1AoMAQsgBEEAIAxrQQV0akEQaygCACEECyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQwgBSgC4AEiEyACSQRAIAcgE0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiEyABIBNLGxDoGSAFKALoASEBCyAMBEAgBSgC5AEgAWpBACAM/AsACyAFIAI2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUYEQCALQZCd/wAQsygLIAStISQMAQsgBxDmOiAFKALcAUUNJCAFKALsAUEBaiIEQQN2IARBB3FBAEdqIgIgBSgC6AEiAUsEQCACIAFrIQkgBSgC4AEiCCACSQRAIAcgCEEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCCABIAhLGxDoGSAFKALoASEBCyAJBEAgBSgC5AEgAWpBACAJ/AsACyAFIAI2AugBCyAFIAQ2AuwBQgAhJCAFKALYASICIAUoAtABRw0AIAtBgJ3/ABCzKAsgBSgC1AEgAkEDdGogJDcDACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwKCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBkLIAMtAAIhDSADLQABIREgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCAHiIGQQxqIgoQ3DwhAyAKENw8IQIjAEGQAWsiASQAIAFBEGogAxDvHiABQcQAaiACEKIeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEwQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDcPCISRQ0IIAVB3AFqIQcgBUHQAWohCyAFQZACaiEPIAVBhAJqIQ4gBUHAAWohEEEAIQMDQAJAIAYgAxCHJUUEQCAFIAM2AsgCIAoQ3DwgA00NCiAGKAIQIANBBXRqIgEpAwAhJSABKQMIISYgASkDECEnIAUgASkDGCIoNwPYAyAFICc3A9ADIAUgJjcDyAMgBSAlNwPAAwJAAkACQCAFKAK8AUUNACAQIAVBwANqEK0MISQgBSgCsAEiBEEwayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEqQQAhAQNAIAIgBGopAAAiKSAqhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQcADakEgIAggJHqnQQN2IAJqIAlxQVBsIgxqQSAQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiABQQhqIgFqIAlxIQIMAAsACyAOKAIIIQQCQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoApwCIgFLBEAgAiABayEMIAUoApQCIhMgAkkEQCAPIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgCnAIhAQsgDARAIAUoApgCIAFqQQAgDPwLAAsgBSACNgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDhCyKAsgBSgCiAIgAkEFdGoiASAoNwMYIAEgJzcDECABICY3AwggASAlNwMAIAUgAkEBajYCjAIgBUGgAWogBUGwAWogJSAmICcgKCAEEJcKDAELIAQgDGpBEGsoAgAhBAsgBUGQgICAeDYC0AIgBUHQAmoQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEMIAUoAuABIhMgAkkEQCAHIBNBAXQiASACQcD///8DcUFAayACIAJBP3EbIhMgASATSxsQ6BkgBSgC6AEhAQsgDARAIAUoAuQBIAFqQQAgDPwLAAsgBSACNgLoAQsgBSAINgLsASAFKALkASAJQQN2aiIBIAEtAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFGBEAgC0GQnf8AELMoCyAErSEkDAELIAcQ5jogBSgC3AFFDSMgBSgC7AFBAWoiBEEDdiAEQQdxQQBHaiICIAUoAugBIgFLBEAgAiABayEJIAUoAuABIgggAkkEQCAHIAhBAXQiASACQcD///8DcUFAayACIAJBP3EbIgggASAISxsQ6BkgBSgC6AEhAQsgCQRAIAUoAuQBIAFqQQAgCfwLAAsgBSACNgLoAQsgBSAENgLsAUIAISQgBSgC2AEiAiAFKALQAUcNACALQYCd/wAQsygLIAUoAtQBIAJBA3RqICQ3AwAgBSACQQFqNgLYASADQQFqIgMgEkcNAAsMCAsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwYCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlKjQoAE2AgAgA0KUqNCgwYKFihQ3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQpCes+7ZtI2S6QCFIAMpAyhCiPSrgeCxxeTCAIWEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNIiADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDtKSAEENM6IgkEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxCAFyADQbgBaiADQSBqIgEgAygCCCADKAIMELgPIAMoArgBRQ0BIAMoArwBIQIgAykDwAEhJCAAIAMpA8gBNwIMIAAgJDcCBCAAIAI2AgAgARCOOyAKELQtIANBhAFqELosDAQLIAYQ5jogAygCXEUNJSADKAJsQQFqIgtBA3YgC0EHcUEAR2oiASADKAJoIgJLBEAgASACayEOIAMoAmAiCCABSQRAIAYgCEEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCCACIAhLGxDoGSADKAJoIQILIA4EQCADKAJkIAJqQQAgDvwLAAsgAyABNgJoCyADIAs2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AELMoCyADKAJUIAFBA3RqQgA3AwAgAyABQQFqNgJYCyAJIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEENURQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahC0LSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCMLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO0pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0jIAMoAsgBIgFBvrX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NKCADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIAMoAsABIAIQrB8gA0GoAWogA0EQaiADKAIAIAMoAgQQuA8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0jIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1RFB0ABBBBCtNiIBRQ0hIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC6LCADQZACaiQADBcLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGWrNiwATYCACADQpas2LDhwoWLFjcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCwoz39urL3NGEf4UgAykDKELlk/SY+a/46Kh/hYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0hIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENQ6EPIpIAQQ1DoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEPIWIANBuAFqIANBIGoiASADKAIIIAMoAgwQuw8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0kIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ2RFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIgsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwXCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8ikgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKv85DYlJzH+zOFIAMpA8gBQqClxfTN0NGkjX+FhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSIgAygCyAEiAUG+tf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQsDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0nIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgAygCwAEgAhCsHyADQagBaiADQRBqIAMoAgAgAygCBBC7DyADKAKoAUUNASADKAKsASEBIAMpA7ABISQgACADKQO4ATcCDCAAICQ3AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAsQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSIgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIg4gAUkEQCAEIA5BAXQiAiABQcD///8DcUFAayABIAFBP3EbIg4gAiAOSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCzKAsgAygCRCABQQN0akIANwMAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDZEUHQAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELQtIANB9ABqELssIANBkAJqJAAMFgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNICADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDtKSAEENM6IgkEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxD/FiADQbgBaiADQSBqIgEgAygCCCADKAIMELoPIAMoArgBRQ0BIAMoArwBIQIgAykDwAEhJCAAIAMpA8gBNwIMIAAgJDcCBCAAIAI2AgAgARCOOyAKELQtIANBhAFqELosDAQLIAYQ5jogAygCXEUNIyADKAJsQQFqIgtBA3YgC0EHcUEAR2oiASADKAJoIgJLBEAgASACayEOIAMoAmAiCCABSQRAIAYgCEEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCCACIAhLGxDoGSADKAJoIQILIA4EQCADKAJkIAJqQQAgDvwLAAsgAyABNgJoCyADIAs2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AELMoCyADKAJUIAFBA3RqQgA3AwAgAyABQQFqNgJYCyAJIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEEN4RQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahC0LSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCELIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMFgsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO0pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCq5iR8ZX61fyAf4UgAykDyAFClpT4q/Cx6bPhAIWEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNISADKALIASIBQZC1/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohCwNAAkACQCADKALEAQRAIAIgAygC1AFPDSYgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADQcABaiACEK0qIANBqAFqIANBEGogAygCACADKAIEELoPIAMoAqgBRQ0BIAMoAqwBIQEgAykDsAEhJCAAIAMpA7gBNwIMIAAgJDcCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgCxD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNISADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiDiABSQRAIAQgDkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiDiACIA5LGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AELMoCyADKAJEIAFBA3RqQgA3AwAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqEN4RQdAAQQQQrTYiAUUNHyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQtC0gA0H0AGoQuiwgA0GQAmokAAwVCyABIAIoAhwRBABB4LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQtPY0/j95vaSSIUgAykDKEKi2J6I4aDq6cwAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0fIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENQ6EPIpIAQQ1DoiCQRAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEPEWIANBuAFqIANBIGoiASADKAIIIAMoAgwQtw8gAygCuAFFDQEgAygCvAEhAiADKQPAASEkIAAgAykDyAE3AgwgACAkNwIEIAAgAjYCACABEI47IAoQtC0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0iIAMoAmxBAWoiC0EDdiALQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQ4gAygCYCIIIAFJBEAgBiAIQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIIIAIgCEsbEOgZIAMoAmghAgsgDgRAIAMoAmQgAmpBACAO/AsACyADIAE2AmgLIAMgCzYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQsygLIAMoAlQgAUEDdGpCADcDACADIAFBAWo2AlgLIAkgB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ3xFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELQtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwVCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ8ikgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0gIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiELA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJSADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GoAWogA0EQaiADKAIAIAMoAgQQtw8gAygCqAFFDQEgAygCrAEhASADKQOwASEkIAAgAykDuAE3AgwgACAkNwIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCALEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0gIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIOIAFJBEAgBCAOQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIOIAIgDksbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQsygLIAMoAkQgAUEDdGpCADcDACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ3xFB0ABBBBCtNiIBRQ0eIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxC0LSADQfQAahC7LCADQZACaiQADBQLIAEgBSgCuAFB0KD/ABD9LwALIAUgBhD/OzYCoAMMFwsgBSAGEIA8NgKgAwwWCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2hQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0eIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR8gAyAKQTD8CgAAIAcgAxCGPiABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDB0LAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELYtIAJBMEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVBmAFqIAVByAJqEJgrEN8hAkACQCAFKAKYASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVB9LT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCnAEQgBUgBUGwAWogAiARIA0QoxMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0YIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQdSy/wAQ8QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRMgBUHIAmoQuyMMEwsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNEiAFQcgCahC7IwwSCwwaCwwZCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0xQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0dIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR4gAyAKQTD8CgAAIAcgAxD+PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBwLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELUtIAJBIEEQENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVBiAFqIAVByAJqEJgrEN0hAkACQCAFKAKIASIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBiLX/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCjAEQgBUgBUGwAWogAiARIA0QoRMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgsgAikDADcDACAFQa8DaiIOIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0XIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAspAwA3AAAgAUEYaiAOKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQfyx/wAQ8QkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCwwZCwwYCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0hQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0cIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDR0gAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBsLAkBB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIAVB0AFqELQtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgDahC7IwsgBUGoqP8ANgLMAiAFIAE2AsgCIAVB+ABqIAVByAJqEJgrEOIhAkACQCAFKAJ4IgFFBEAgBUECNgK0ASAFQcS0/wA2ArABIAVCATcCvAEgBUHMATYC1AIgBUHgtP8ANgLQAiAFIAVB0AJqNgK4ASAFQcQDaiAFQbABahCZDiAFKQLEAyEkIAAgBSkCzAM3AgwgACAkNwIEIABBhoCAgHg2AgAMAQsgBUHQAmoiAiAFKAJ8EIAVIAVBsAFqIAIgESANEKITIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiILIAIpAwA3AwAgBUGvA2oiDiAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFiABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiALKQMANwAAIAFBGGogDikAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUGksf8AEPEJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0RIAVByAJqELsjDBELIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsMGAsMFwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENcUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNGyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0cIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwaCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVBqKj/ADYCzAIgBSABNgLIAiAFQegAaiAFQcgCahCYKxDeIQJAAkAgBSgCaCIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVBkLT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCbBCAFSAFQbABaiACIBIgERCgEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCyAFQc8DaiIEIAVBwAFqIgcpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIGIAVB0AFqKQIANwMAIAVBmANqIgogBUHYAWopAgA3AwAgBUGoA2oiCyACKQMANwMAIAVBrwNqIg4gBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRUgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogCykDADcAACABQRhqIA4pAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCikDADcCACAFQbABaiAEIAFBrLP/ABDxCSAFLQD0ASIDQQJGBEAgBUHQA2ogBygCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNECAFQcgCahC7IwwQCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0PIAVByAJqELsjDA8LDBcLDBYLIAVBwANqIQQjAEGQA2siASQAIAVBsAFqIgJBIGoQlzYgAUEIaiIGIAJB6ABqEMcUIAFBQGsiByACQTRqENkUAkBBDEEEEK02IgMEQCADQomSpMiQocKECTcCACADQQhqQYmSpMgANgIAIAIoAjAhCkEMQQQQrTYiAkUNGiACIAo2AgQgAkEVOgAAIAEgAjYCeCABIAM2AnQgAUEiOgBwIAFB2AFqIgMgBxDwPSABQbQCaiICIAMQoRsgAyACIAFB8ABqEIwYQcQAQQQQrTYiB0UNGyAHIAYQ7z0gAUEBNgK8AiABIAc2ArgCIAFBATYCtAIgAUH8AGoiByADIAIQ/CIgAiAHEM0cIAQgAhChCCABQZADaiQADAELDBkLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQjjsgBUHkAWoQtC0gBUGYAmoQii8gBSgC0AIiACAAKAIAIgBBAWs2AgAgAEEBRw0NIAVB0AJqELsjDA0LDBULIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQdACahC7IwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2BQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0YIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRkgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBcLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAVBiANqELsjDAsLDBMLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDNFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRcgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNGCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMFgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQogBUGIA2oQuyMMCgsMEgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENUUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0XIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwVC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCSAFQYgDahC7IwwJCwwRCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2RQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0VIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRYgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBQLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAVBiANqELsjDAgLDBALIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDUFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRQgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFSADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMEwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQcgBUGIA2oQuyMMBwsMDwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM8UIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0UIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwSC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBiAFQYgDahC7IwwGCwwOCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ0RQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0SIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRMgAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDBELQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsS0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAVBiANqELsjDAULDA0LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDbFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDREgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNEiADIApBMPwKAAAgByADEPA9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMEAtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABBqKj/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahC0LSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQQgBUGIA2oQuyMMBAsMDAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENAUIAFBNGoiCyACQSBqENkUAkBBDEEEEK02IgQEQCAEQomSpMiQocKECTcCACAEQQhqQYmSpMgANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNECAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCALEPA9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0RIAMgCkEw/AoAACAHIAMQ8T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQoQggAUGQA2okAAwBCwwPC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEGoqP8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELQtIAVBhAJqELMtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAyAFQYgDahC7IwwDCwwLCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzhQgAUE0aiILIAJBIGoQ2RQCQEEMQQQQrTYiBARAIARCiZKkyJChwoQJNwIAIARBCGpBiZKkyAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0PIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAsQ8D0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRAgAyAKQTD8CgAAIAcgAxD5PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxChCCABQZADaiQADAELDA4LQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsi0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAVBiANqELsjDAILDAoLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDWFCABQTRqIgsgAkEgahDZFAJAQQxBBBCtNiIEBEAgBEKJkqTIkKHChAk3AgAgBEEIakGJkqTIADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDQ4gByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgCxDwPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNDyADIApBMPwKAAAgByADEPc9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKEIIAFBkANqJAAMAQsMDQtB0ABBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQaio/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQtC0gBUGEAmoQsS0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBiANqELsjCyAFQZAEaiQADwsgBSAHEKM8NgKgAwwDCyAFIAcQ/js2AqADDAILIAUgBxD8OzYCoAMMAQsgBSAHEP07NgKgAwsgBUECNgLEAyAFQeCc/wA2AsADIAVCAjcCzAMgBUE7NgLcAiAFQTs2AtQCIAUgBUHQAmo2AsgDIAUgBUGgA2o2AtgCIAUgBUHIAmo2AtACIAVBwANqQfCc/wAQ7ywAC0EEQTgQoz0ACyACIAMoAihB0KD/ABD9LwALQeCd/wAQsjsAC0EEQdAAEKM9AAsgAiADKALIAUHQoP8AEP0vAAtBsJ3/AEEgQdCd/wAQnykAC0EEQQwQoz0AC0EEQcQAEKM9AAvw6wIEH38HfgF9AXwjAEGQBGsiBSQAIAUgAzYCrAECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAEECaw4lAQIDBAUGBwgJCgsMDQ4PEAAAFhEXABgZAAAAAAAAAAAAEhMUFQALIAVBATYCtAEgBUGcsf8ANgKwASAFQgE3ArwBIAVBrwM2AtQCIAUgBUHQAmo2ArgBIAUgBUGsAWo2AtACIAVBwANqIAVBsAFqEJkOIABBgoCAgHg2AgAgACAFKQLAAzcCBCAAQQxqIAVByANqKAIANgIADC0LIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgR4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDwHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEEUNLCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0yIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK8MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEKMoCyAFKAKIAiACaiAJOgAAIAUgAkEBajYCjAIgBSAFQbABaiAJIAEQhwsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTggBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwsCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCwLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjh4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD1HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNKiAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0yIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUEIaiAFQbABaiAJIAEQgwsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTcgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwqCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCsLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgx4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD5HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEEUNKCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0yIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEKsMISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiAJNgIAIAUgAkEBajYCjAIgBUEQaiAFQbABaiAJIAEQiAsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwoCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCoLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQih4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD4HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNJiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0yIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiAUEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhBANAIAEgAmopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgtBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AELMoCyAFKAKIAiACQQN0aiAlNwMAIAUgAkEBajYCjAIgBUEYaiAFQbABaiAlIAEQiwsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDiAESQRAIAYgDkEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDiACIA5LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTUgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwwmCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCkLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQix4iB0EMaiIKKAIIIQMgCigCCCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD3HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAooAggiEEUNJCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgAyAKKAIITw0uIAUgBygCECADai0AACIJOgDQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK8MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEBIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQEQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEKkZCyAFKAKIAiACaiAJOgAAIAUgAkEBajYCjAIgBUEgaiAFQbABaiAJIAEQiQsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwkCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCgLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQiR4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDzHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNIiAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0uIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUEoaiAFQbABaiAJIAEQhgsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTMgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwiCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCcLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQjB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDyHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiEEUNICAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0uIAUgBygCECADQQJ0aigCACIJNgLQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEKsMISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiAJNgIAIAUgAkEBajYCjAIgBUEwaiAFQbABaiAJIAEQigsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTIgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwgCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCYLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhx4iB0EMaiIKENg8IQMgChDYPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDvHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBEEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2DwiDUUNHiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDYPCADTQ0uIAUgBygCECADQQN0aikDACIlNwPQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKwMISQgBSgCsAEiAUEQayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEnQQAhBANAIAEgAmopAAAiJiAnhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEIIAggJHqnQQN2IAJqIAlxIgtBBHRrQQgQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJiAmQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AELMoCyAFKAKIAiACQQN0aiAlNwMAIAUgAkEBajYCjAIgBUE4aiAFQbABaiAlIAEQhQsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDiAESQRAIAYgDkEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDiACIA5LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTEgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyANRw0ACwweCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCULIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhR4iB0EMaiIKENk8IQMgChDZPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhD0HiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2TwiEEUNHCAFQdwBaiEGIAVB0AFqIREgBUGQAmohEiAFQYQCaiEMIAVBwAFqIQ5BACEDA0ACQCARAn8gByADEIclRQRAIAUgAzYCyAIgChDZPCADTQ0rIAUgBygCECADQQF0ai8BACIJOwHQAgJAAkACQCAFKAK8AUUNACAOIAVB0AJqEK4MISQgBSgCsAEiBEEIayELIAUoArQBIgggJKdxIQEgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhAgNAIAEgBGopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakECIAsgJHqnQQN2IAFqIAhxIg1BA3RrQQIQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgASACQQhqIgJqIAhxIQEMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIghBAWoiC0EDdiALQQdxQQBHaiICIAUoApwCIgRLBEAgAiAEayENIAUoApQCIg8gAkkEQCASIA9BAXQiBCACQcD///8DcUFAayACIAJBP3EbIg8gBCAPSxsQ6BkgBSgCnAIhBAsgDQRAIAUoApgCIARqQQAgDfwLAAsgBSACNgKcAgsgBSALNgKgAiAFKAKYAiAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEK0oCyAFKAKIAiACQQF0aiAJOwEAIAUgAkEBajYCjAIgBUFAayAFQbABaiAJIAEQggsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDTAgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyAQRw0ACwwcCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADCQLIAVBsAFqIgYgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQhB4iB0EMaiIKENs8IQMgChDbPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhDxHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBCEEIAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAGQSBqIAFBEGpBNPwKAAAgBkHUAGogAUHEAGpBNPwKAAAgBiAlNwMYIAYgJjcDECAGICQ3AwggBiACNgIEIAYgAzYCACABQZABaiQAIAoQ2zwiDUUNGiAFQdwBaiEGIAVB0AFqIRAgBUGQAmohESAFQYQCaiEMIAVBwAFqIRJBACEDA0ACQCAQAn8gByADEIclRQRAIAUgAzYCyAIgChDbPCADTQ0rIAUgBygCECADQQJ0aioCACIrOALQAgJAAkACQCAFKAK8AUUNACASIAVB0AJqEKsMISQgBSgCsAEiAUEIayEIIAUoArQBIgkgJKdxIQIgJEIZiEL/AINCgYKEiJCgwIABfiEmQQAhBANAIAEgAmopAAAiJSAmhSIkQn+FICRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiJFBFBEADQCAFQdACakEEIAggJHqnQQN2IAJqIAlxIgtBA3RrQQQQnzsNBCAkQgF9ICSDIiRQRQ0ACwsgJSAlQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAEQQhqIgRqIAlxIQIMAAsACyAMKAIIIQECQCAFKAKQAgRAIAUoAqACIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoApwCIgJLBEAgBCACayELIAUoApQCIg4gBEkEQCARIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgCnAIhAgsgCwRAIAUoApgCIAJqQQAgC/wLAAsgBSAENgKcAgsgBSAINgKgAiAFKAKYAiAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKAKkAkEBajYCpAILIAUoAowCIgIgBSgChAJGBEAgDEGQnf8AEJ0oCyAFKAKIAiACQQJ0aiArOAIAIAUgAkEBajYCjAIgBUHIAGogBUGwAWogKyABEIwLDAELIAFBACALa0EDdGpBBGsoAgAhAQsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAugBIgJLBEAgBCACayELIAUoAuABIg4gBEkEQCAGIA5BAXQiAiAEQcD///8DcUFAayAEIARBP3EbIg4gAiAOSxsQ6BkgBSgC6AEhAgsgCwRAIAUoAuQBIAJqQQAgC/wLAAsgBSAENgLoAQsgBSAINgLsASAFKALkASAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFHDQJBkJ3/AAwBCyAGEOY6IAUoAtwBRQ0vIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCSAFKALgASIIIAFJBEAgBiAIQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIIIAQgCEsbEOgZIAUoAugBIQQLIAkEQCAFKALkASAEakEAIAn8CwALIAUgATYC6AELIAUgAjYC7AFBACEBIAUoAtgBIgIgBSgC0AFHDQFBgJ3/AAsQnSgLIAUoAtQBIAJBAnRqIAE2AgAgBSACQQFqNgLYASADQQFqIgMgDUcNAAsMGgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwjCyAFQbABaiIGIAEgAiADIAQQhgEgBSgCuAEhASAFKAK0ASECIAUoArABIgNBk4CAgHhGBEAgBSABNgKMAyAFIAI2AogDIAVBiANqEIIeIgdBDGoiChDYPCEDIAoQ2DwhAiMAQZABayIBJAAgAUEQaiADEPIeIAFBxABqIAIQ9h4gAUH4AGpBpLWAARClKyABKQOAASElIAEpA3ghJgJAIAJFBEBBqLWAASEDQQAhAgwBCwJAIAFB+ABqIAFBjwFqQRBBCAJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCxCdFCABKAJ8IQIgASgCeCIDRQRAIAE1AoABISRBACEDDAILIAEpAoABISQgAkEJaiIERQ0BIANB/wEgBPwLAAwBCxDjJ0EAIQMgATUCDCEkIAEoAgghAgsgBkEgaiABQRBqQTT8CgAAIAZB1ABqIAFBxABqQTT8CgAAIAYgJTcDGCAGICY3AxAgBiAkNwMIIAYgAjYCBCAGIAM2AgAgAUGQAWokACAKENg8Ig1FDRggBUHcAWohBiAFQdABaiEQIAVBkAJqIREgBUGEAmohDCAFQcABaiESQQAhAwNAAkAgEAJ/IAcgAxCHJUUEQCAFIAM2AsgCIAoQ2DwgA00NKyAFIAcoAhAgA0EDdGorAwAiLDkD0AICQAJAAkAgBSgCvAFFDQAgEiAFQdACahCsDCEkIAUoArABIgFBEGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hJkEAIQQDQCABIAJqKQAAIiUgJoUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBCCAIICR6p0EDdiACaiAJcSILQQR0a0EIEJ87DQQgJEIBfSAkgyIkUEUNAAsLICUgJUIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgBEEIaiIEaiAJcSECDAALAAsgDCgCCCEBAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKAKcAiICSwRAIAQgAmshCyAFKAKUAiIOIARJBEAgESAOQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyIOIAIgDksbEOgZIAUoApwCIQILIAsEQCAFKAKYAiACakEAIAv8CwALIAUgBDYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiICIAUoAoQCRgRAIAxBkJ3/ABCzKAsgBSgCiAIgAkEDdGogLDkDACAFIAJBAWo2AowCIAVB0ABqIAVBsAFqICwgARCECwwBCyABQQAgC2tBBHRqQQhrKAIAIQELIAVBkICAgHg2AsADIAVBwANqEIgRAkAgBSgC3AEEQCAFKALsASIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKALoASICSwRAIAQgAmshCyAFKALgASIOIARJBEAgBiAOQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyIOIAIgDksbEOgZIAUoAugBIQILIAsEQCAFKALkASACakEAIAv8CwALIAUgBDYC6AELIAUgCDYC7AEgBSgC5AEgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgC8AFBAWo2AvABCyAFKALYASICIAUoAtABRw0CQZCd/wAMAQsgBhDmOiAFKALcAUUNLiAFKALsAUEBaiICQQN2IAJBB3FBAEdqIgEgBSgC6AEiBEsEQCABIARrIQkgBSgC4AEiCCABSQRAIAYgCEEBdCIEIAFBwP///wNxQUBrIAEgAUE/cRsiCCAEIAhLGxDoGSAFKALoASEECyAJBEAgBSgC5AEgBGpBACAJ/AsACyAFIAE2AugBCyAFIAI2AuwBQQAhASAFKALYASICIAUoAtABRw0BQYCd/wALEJ0oCyAFKALUASACQQJ0aiABNgIAIAUgAkEBajYC2AEgA0EBaiIDIA1HDQALDBgLIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMIgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMIQsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMIAsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHwsgBUEEOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHgsgBUEFOgCwASAAIAEgAiAFQbABaiADIAQQ2wkMHQsgAygCBCEDIAVBFToAwAMgBSADNgLEAyAFQbABaiABIAIgBUHAA2oiByAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIEQZOAgIB4RwRAIAAgBSkCvAE3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBxCmDAwdCyAFIAE2AtQCIAUgAjYC0AIgBUHAA2oQpgwgBUHgAGogBUHQAmoQuSYgBUGwAWogBSgCYCISIAUoAmQoAgwRAAACQCASBEAgBSkDsAFCwOO13tL+pZUshSAFKQO4AUL1zqio0f7azKR/hYRQDQELIAVBsAFqQS9BAEEBQQEQoBggBSgCtAEhASAFKAKwAUEBRg0JIAUoArgBIgJB7LX/AEEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADBELIAVBsAFqIgFB2LiAAUH4uIABEIU1IgIoAgAgAigCBCgCDBEEABDaASABQSBqEK80IAFBNGpBgAgQ8h4gAUHoAGpBgAggAxCPFyABIAM2AjAgEigCMCIeRQ0PIAVB8AFqIRYgBUHkAWohF0EAIQMDQAJAIBIgAxCbJUUEQCAFQdgAaiASIAMQoBsgBUHAA2ohCSAFKAJYIQ4gBSgCXCERIwBBMGsiByQAAkAgESAFQbABaiIEKAIwRgRAIwBBQGoiAiQAIAIgETYCBCACIA42AgAgBCAOIBEQzQIhJCACIARBMGoiATYCPCACIARB6ABqIhg2AjggAiACNgI0IAIgATYCECACIBg2AgwgAiAENgIIIAJBGGohECACQTRqIQ8gAkEIaiIfIQFBACEKQQAhE0EAIRVBACEZQQAhGiMAQSBrIggkACAEQSBqIgYoAghFBEAgCEEYaiABQQhqKAIANgIAIAggASkCADcDECAIQQhqIRsjAEHgAGsiASQAIAEgCEEQajYCIAJAIAYoAgwiC0EBaiIMIAtPBEACQCAGKAIEIgsgC0EBakEDdkEHbCALQQhJGyILQQF2IAxJBEACQAJAIAtBAWoiCiAMIAogDEsbIgpBD08EQCAKQf////8BSw0BQX8gCkEDdEEHbkEBa2d2QQFqIQoMAgtBBEEIQRAgCkEISRsgCkEESRshCgwBCxDdJyABKAIcIQogASgCGCIMQYGAgIB4Rw0ECyABQdAAaiAGQRBqIg1BBCAKEPsUIAEoAlghCiABKAJUIQwgASgCUCILRQ0DIAEgASgCXDYCTCABIAo2AkggASAMNgJEIAEgCzYCQCABQRBqIAFBQGsQwTQgASgCFCIKBEAgASgCEEH/ASAK/AsACyABKAJIIQogASgCRCEMIAEoAkAiC0UNAyABIAEoAkw2AjwgASAKNgI4IAEgDDYCNCABIAs2AjAgAUKEgICAgAE3AiggASANNgIkIAFBMGohICABIAYoAgwiHAR/IAtBCGohISAGKAIAIh0pAwBCf4VCgIGChIiQoMCAf4MhJQNAICVQBEADQCATQQhqIRMgHUEIaiIdKQMAQoCBgoSIkKDAgH+DIiVCgIGChIiQoMCAf1ENAAsgJUKAgYKEiJCgwIB/hSElCyABKAIgIg0oAgAhFCABQQhqIA0oAgQgDSgCCCgCACAGKAIAICV6p0EDdiATakECdCIia0EEaygCABDKJSALIAwgFCABKAIIIAEoAgwQzQKnIiNxIg1qKQAAQoCBgoSIkKDAgH+DIiZQBEBBCCEUA0AgDSAUaiENIBRBCGohFCALIAwgDXEiDWopAABCgIGChIiQoMCAf4MiJlANAAsLICVCAX0gJYMhJSALICZ6p0EDdiANaiAMcSINaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiENCyALIA1qICNBGXYiFDoAACAhIA1BCGsgDHFqIBQ6AAAgCyANQQJ0a0EEayAGKAIAICJrQQRrKAAANgAAIBxBAWsiHA0ACyAGKAIMBUEACyIMNgI8IAEgCiAMazYCOCAGICBBBBD6KiABQSRqEPUnDAELIAYgAUEgakHA3IABEO4JC0GBgICAeCEMDAELEN0nIAEoAgQhCiABKAIAIQwLIBsgCjYCBCAbIAw2AgAgAUHgAGokAAsgBigCBCIKICSncSEBICRCGYhC/wCDQoGChIiQoMCAAX4hJyAPKAIIIQ0gDygCBCETIA8oAgAhCyAGKAIAIQwDQAJAIAEgDGopAAAiJiAnhSIlQn+FICVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhJQJ/AkAgEAJ+AkADQCAlUA0BIAggEyANKAIAIAYoAgAgJXqnQQN2IAFqIApxIhRBAnRrQQRrKAIAEMolICVCAX0gJYMhJSALKAIAIAsoAgQgCCgCACAIKAIEEJ87RQ0ACyAQICQ3AwggECAGKAIAQQAgFGtBAnRqNgIQQgAMAQsgJkKAgYKEiJCgwIB/gyElIBlFBEAgJVANAiAleqdBA3YgAWogCnEhFQtBASAlICZCAYaDUA0CGiAQIAwgFWosAABBAE4EfyAMKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBULNgIQIBAgJDcDCEIBCzcDACAQIAY2AhQgCEEgaiQADAILQQALIRkgASAaQQhqIhpqIApxIQEMAQsLIAIgETYCPCACIA42AjggAiAYNgI0IB8gECAPEIsTIAIoAhBBBGsoAgAhASACQZCAgIB4NgIYIBAQiBEgB0EEaiIGQZOAgIB4NgIAIAYgATYCBCACQUBrJAAgBygCCCEGIAcoAgQiAUGTgICAeEcEQCAJIAcpAgw3AgggCUEQaiAHQRRqKAIANgIAIAkgBjYCBCAJIAE2AgAMAgsCQCAEKAJABEAgBCgCUCIKQQFqIgxBA3YgDEEHcUEAR2oiASAEKAJMIgJLBEAgASACayEIIAQoAkQiCyABSQRAIARBQGsgC0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCyACIAtLGxDoGSAEKAJMIQILIAgEQCAEKAJIIAJqQQAgCPwLAAsgBCABNgJMCyAEIAw2AlAgBCgCSCAKQQN2aiIBIAEtAABBASAKQQdxdHI6AAAMAQsgBCAEKAJUQQFqNgJUCyAEKAI8IgEgBCgCNEYEQCAEQTRqQci1gAEQnSgLIAQoAjggAUECdGogBjYCACAJIAY2AgQgCUGTgICAeDYCACAEIAFBAWo2AjwMAQsgByARNgIcIAdBAjYCCCAHQaC3gAE2AgQgB0ICNwIQIAdBOzYCLCAHQZwDNgIkIAcgBEEwajYCICAHIAdBIGo2AgwgByAHQRxqNgIoIAlBBGogB0EEahCZDiAJQY2AgIB4NgIACyAHQTBqJAAgBSgCwAMiAUGTgICAeEYNASAAIAUpAsgDNwIIIABBEGogBUHQA2ooAgA2AgAgACAFKALEAzYCBCAAIAE2AgAgBUHQAWoQjjsgFxCzLSAFQZgCahCKLwwTCyAWEOY6IAUoAvABRQ0mIAUoAoACQQFqIgJBA3YgAkEHcUEAR2oiASAFKAL8ASIESwRAIAEgBGshByAFKAL0ASIGIAFJBEAgFiAGQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIGIAQgBksbEOgZIAUoAvwBIQQLIAcEQCAFKAL4ASAEakEAIAf8CwALIAUgATYC/AELIAUgAjYCgAIgBSgC7AEiASAFKALkAUYEQCAXQYCd/wAQnSgLIAUoAugBIAFBAnRqQQA2AgAgBSABQQFqNgLsAQsgHiADQQFqIgNHDQALDA8LIAMtAAIhECADLQABIREgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCIHiIHQQxqIgoQ2zwhAyAKENs8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEJ8eIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEIQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDbPCISRQ0OIAVB3AFqIQYgBUHQAWohDiAFQZACaiEPIAVBhAJqIQwgBUHAAWohE0EAIQMDQAJAIA4CfyAHIAMQhyVFBEAgBSADNgLIAiAKENs8IANNDSMgBSAHKAIQIANBAnRqKAIAIgk2AtACAkACQAJAIAUoArwBRQ0AIBMgBUHQAmoQqwwhJCAFKAKwASIEQQhrIQsgBSgCtAEiCCAkp3EhASAkQhmIQv8Ag0KBgoSIkKDAgAF+ISZBACECA0AgASAEaikAACIlICaFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQQgCyAkeqdBA3YgAWogCHEiDUEDdGtBBBCfOw0EICRCAX0gJIMiJFBFDQALCyAlICVCAYaDQoCBgoSIkKDAgH+DUEUNASABIAJBCGoiAmogCHEhAQwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCEEBaiILQQN2IAtBB3FBAEdqIgIgBSgCnAIiBEsEQCACIARrIQ0gBSgClAIiFSACSQRAIA8gFUEBdCIEIAJBwP///wNxQUBrIAIgAkE/cRsiFSAEIBVLGxDoGSAFKAKcAiEECyANBEAgBSgCmAIgBGpBACAN/AsACyAFIAI2ApwCCyAFIAs2AqACIAUoApgCIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAMQZCd/wAQnSgLIAUoAogCIAJBAnRqIAk2AgAgBSACQQFqNgKMAiAFQfAAaiAFQbABaiAJIAEQiAsMAQsgBEEAIA1rQQN0akEEaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiDSAESQRAIAYgDUEBdCICIARBwP///wNxQUBrIAQgBEE/cRsiDSACIA1LGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDScgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyASRw0ACwwOCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBsLIAMtAAIhDSADLQABIRAgBUGwAWoiBiABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCNHiIHQQxqIgoQ2DwhAyAKENg8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEKEeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEQQQgCfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAZBIGogAUEQakE0/AoAACAGQdQAaiABQcQAakE0/AoAACAGICU3AxggBiAmNwMQIAYgJDcDCCAGIAI2AgQgBiADNgIAIAFBkAFqJAAgChDYPCIRRQ0MIAVB3AFqIQYgBUHQAWohEiAFQZACaiEOIAVBhAJqIQwgBUHAAWohD0EAIQMDQAJAIBICfyAHIAMQhyVFBEAgBSADNgLIAiAKENg8IANNDSMgBSAHKAIQIANBA3RqKQMAIiU3A9ACAkACQAJAIAUoArwBRQ0AIA8gBUHQAmoQrAwhJCAFKAKwASIBQRBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISdBACEEA0AgASACaikAACImICeFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVB0AJqQQggCCAkeqdBA3YgAmogCXEiC0EEdGtBCBCfOw0EICRCAX0gJIMiJFBFDQALCyAmICZCAYaDQoCBgoSIkKDAgH+DUEUNASACIARBCGoiBGogCXEhAgwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgCnAIiAksEQCAEIAJrIQsgBSgClAIiEyAESQRAIA4gE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKAKcAiECCyALBEAgBSgCmAIgAmpBACAL/AsACyAFIAQ2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiAiAFKAKEAkYEQCAMQZCd/wAQsygLIAUoAogCIAJBA3RqICU3AwAgBSACQQFqNgKMAiAFQYABaiAFQbABaiAlIAEQiwsMAQsgAUEAIAtrQQR0akEIaygCACEBCyAFQZCAgIB4NgLAAyAFQcADahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiEyAESQRAIAYgE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAYQ5jogBSgC3AFFDSYgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAGIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwMCyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBoLIAMtAAIhDSADLQABIRAgBUGwAWoiByABIAIgAyAEEIYBIAUoArgBIQEgBSgCtAEhAiAFKAKwASIDQZOAgIB4RgRAIAUgATYCjAMgBSACNgKIAyAFQYgDahCGHiIGQQxqIgoQ2jwhAyAKENo8IQIjAEGQAWsiASQAIAFBEGogAxDyHiABQcQAaiACEKAeIAFB+ABqQaS1gAEQpSsgASkDgAEhJSABKQN4ISYCQCACRQRAQai1gAEhA0EAIQIMAQsCQCABQfgAaiABQY8BakEgQRACfyACQQ9PBEAgAkH/////AUsNAkF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsQnRQgASgCfCECIAEoAngiA0UEQCABNQKAASEkQQAhAwwCCyABKQKAASEkIAJBCWoiBEUNASADQf8BIAT8CwAMAQsQ4ydBACEDIAE1AgwhJCABKAIIIQILIAdBIGogAUEQakE0/AoAACAHQdQAaiABQcQAakE0/AoAACAHICU3AxggByAmNwMQIAcgJDcDCCAHIAI2AgQgByADNgIAIAFBkAFqJAAgChDaPCIRRQ0KIAVB3AFqIQcgBUHQAWohEiAFQZACaiEOIAVBhAJqIQwgBUHAAWohD0EAIQMDQAJAIBICfyAGIAMQhyVFBEAgBSADNgLIAiAKENo8IANNDQsgBigCECADQQR0aiIBKQMAISUgBSABKQMIIiY3A9gCIAUgJTcD0AICQAJAAkAgBSgCvAFFDQAgDyAFQdACahCwDCEkIAUoArABIgFBIGshCCAFKAK0ASIJICSncSECICRCGYhC/wCDQoGChIiQoMCAAX4hKEEAIQQDQCABIAJqKQAAIicgKIUiJEJ/hSAkQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiRQRQRAA0AgBUHQAmpBECAIICR6p0EDdiACaiAJcSILQQV0a0EQEJ87DQQgJEIBfSAkgyIkUEUNAAsLICcgJ0IBhoNCgIGChIiQoMCAf4NQRQ0BIAIgBEEIaiIEaiAJcSECDAALAAsgDCgCCCEBAkAgBSgCkAIEQCAFKAKgAiIJQQFqIghBA3YgCEEHcUEAR2oiBCAFKAKcAiICSwRAIAQgAmshCyAFKAKUAiITIARJBEAgDiATQQF0IgIgBEHA////A3FBQGsgBCAEQT9xGyITIAIgE0sbEOgZIAUoApwCIQILIAsEQCAFKAKYAiACakEAIAv8CwALIAUgBDYCnAILIAUgCDYCoAIgBSgCmAIgCUEDdmoiAiACLQAAQQEgCUEHcXRyOgAADAELIAUgBSgCpAJBAWo2AqQCCyAFKAKMAiICIAUoAoQCRgRAIAxBkJ3/ABCxKAsgBSgCiAIgAkEEdGoiBCAmNwMIIAQgJTcDACAFIAJBAWo2AowCIAVBkAFqIAVBsAFqICUgJiABENQKDAELIAFBACALa0EFdGpBEGsoAgAhAQsgBUGQgICAeDYCwAMgBUHAA2oQiBECQCAFKALcAQRAIAUoAuwBIglBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAugBIgJLBEAgBCACayELIAUoAuABIhMgBEkEQCAHIBNBAXQiAiAEQcD///8DcUFAayAEIARBP3EbIhMgAiATSxsQ6BkgBSgC6AEhAgsgCwRAIAUoAuQBIAJqQQAgC/wLAAsgBSAENgLoAQsgBSAINgLsASAFKALkASAJQQN2aiICIAItAABBASAJQQdxdHI6AAAMAQsgBSAFKALwAUEBajYC8AELIAUoAtgBIgIgBSgC0AFHDQJBkJ3/AAwBCyAHEOY6IAUoAtwBRQ0lIAUoAuwBQQFqIgJBA3YgAkEHcUEAR2oiASAFKALoASIESwRAIAEgBGshCSAFKALgASIIIAFJBEAgByAIQQF0IgQgAUHA////A3FBQGsgASABQT9xGyIIIAQgCEsbEOgZIAUoAugBIQQLIAkEQCAFKALkASAEakEAIAn8CwALIAUgATYC6AELIAUgAjYC7AFBACEBIAUoAtgBIgIgBSgC0AFHDQFBgJ3/AAsQnSgLIAUoAtQBIAJBAnRqIAE2AgAgBSACQQFqNgLYASADQQFqIgMgEUcNAAsMCgsgACAFKQK8ATcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwZCyADLQACIQ0gAy0AASEQIAVBsAFqIgcgASACIAMgBBCGASAFKAK4ASEBIAUoArQBIQIgBSgCsAEiA0GTgICAeEYEQCAFIAE2AowDIAUgAjYCiAMgBUGIA2oQgB4iBkEMaiIKENw8IQMgChDcPCECIwBBkAFrIgEkACABQRBqIAMQ8h4gAUHEAGogAhCiHiABQfgAakGktYABEKUrIAEpA4ABISUgASkDeCEmAkAgAkUEQEGotYABIQNBACECDAELAkAgAUH4AGogAUGPAWpBMEEQAn8gAkEPTwRAIAJB/////wFLDQJBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLEJ0UIAEoAnwhAiABKAJ4IgNFBEAgATUCgAEhJEEAIQMMAgsgASkCgAEhJCACQQlqIgRFDQEgA0H/ASAE/AsADAELEOMnQQAhAyABNQIMISQgASgCCCECCyAHQSBqIAFBEGpBNPwKAAAgB0HUAGogAUHEAGpBNPwKAAAgByAlNwMYIAcgJjcDECAHICQ3AwggByACNgIEIAcgAzYCACABQZABaiQAIAoQ3DwiEUUNCCAFQdwBaiEHIAVB0AFqIRIgBUGQAmohDiAFQYQCaiEMIAVBwAFqIQ9BACEDA0ACQCASAn8gBiADEIclRQRAIAUgAzYCyAIgChDcPCADTQ0LIAYoAhAgA0EFdGoiASkDACElIAEpAwghJiABKQMQIScgBSABKQMYIig3A9gDIAUgJzcD0AMgBSAmNwPIAyAFICU3A8ADAkACQAJAIAUoArwBRQ0AIA8gBUHAA2oQrQwhJCAFKAKwASIBQTBrIQggBSgCtAEiCSAkp3EhAiAkQhmIQv8Ag0KBgoSIkKDAgAF+ISpBACEEA0AgASACaikAACIpICqFIiRCf4UgJEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIkUEUEQANAIAVBwANqQSAgCCAkeqdBA3YgAmogCXFBUGwiC2pBIBCfOw0EICRCAX0gJIMiJFBFDQALCyApIClCAYaDQoCBgoSIkKDAgH+DUEUNASACIARBCGoiBGogCXEhAgwACwALIAwoAgghAQJAIAUoApACBEAgBSgCoAIiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgCnAIiAksEQCAEIAJrIQsgBSgClAIiEyAESQRAIA4gE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKAKcAiECCyALBEAgBSgCmAIgAmpBACAL/AsACyAFIAQ2ApwCCyAFIAg2AqACIAUoApgCIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAqQCQQFqNgKkAgsgBSgCjAIiBCAFKAKEAkYEQCAMELIoCyAFKAKIAiAEQQV0aiICICg3AxggAiAnNwMQIAIgJjcDCCACICU3AwAgBSAEQQFqNgKMAiAFQaABaiAFQbABaiAlICYgJyAoIAEQlwoMAQsgASALakEQaygCACEBCyAFQZCAgIB4NgLQAiAFQdACahCIEQJAIAUoAtwBBEAgBSgC7AEiCUEBaiIIQQN2IAhBB3FBAEdqIgQgBSgC6AEiAksEQCAEIAJrIQsgBSgC4AEiEyAESQRAIAcgE0EBdCICIARBwP///wNxQUBrIAQgBEE/cRsiEyACIBNLGxDoGSAFKALoASECCyALBEAgBSgC5AEgAmpBACAL/AsACyAFIAQ2AugBCyAFIAg2AuwBIAUoAuQBIAlBA3ZqIgIgAi0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAvABQQFqNgLwAQsgBSgC2AEiAiAFKALQAUcNAkGQnf8ADAELIAcQ5jogBSgC3AFFDSQgBSgC7AFBAWoiAkEDdiACQQdxQQBHaiIBIAUoAugBIgRLBEAgASAEayEJIAUoAuABIgggAUkEQCAHIAhBAXQiBCABQcD///8DcUFAayABIAFBP3EbIgggBCAISxsQ6BkgBSgC6AEhBAsgCQRAIAUoAuQBIARqQQAgCfwLAAsgBSABNgLoAQsgBSACNgLsAUEAIQEgBSgC2AEiAiAFKALQAUcNAUGAnf8ACxCdKAsgBSgC1AEgAkECdGogATYCACAFIAJBAWo2AtgBIANBAWoiAyARRw0ACwwICyAAIAUpArwBNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAEgAigCHBEEAEHUsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGUqNCgATYCACADQpSo0KDBgoWKFDcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBCkJ6z7tm0jZLpAIUgAykDKEKI9KuB4LHF5MIAhYRQDQELIANBIGpBL0EAQQFBARCgGCADKAIkIQIgAygCIEEBRg0iIAMoAigiAUHstf8AQS/8CgAAIABBLzYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0EgaiAEENM6EO4pIAQQ0zoiCARAIANB3ABqIQYgA0HQAGohCgNAAkAgBCAHEJYlRQRAIANBCGogBCAHEIAXIANBuAFqIANBIGoiASADKAIIIAMoAgwQ4Q8gAygCuAEiAkGTgICAeEYNASAAIAMpAsABNwIIIABBEGogA0HIAWooAgA2AgAgACADKAK8ATYCBCAAIAI2AgAgARCOOyAKELMtIANBhAFqELosDAQLIAYQ5jogAygCXEUNJSADKAJsQQFqIgxBA3YgDEEHcUEAR2oiASADKAJoIgJLBEAgASACayEJIAMoAmAiCyABSQRAIAYgC0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCyACIAtLGxDoGSADKAJoIQILIAkEQCADKAJkIAJqQQAgCfwLAAsgAyABNgJoCyADIAw2AmwgAygCWCIBIAMoAlBGBEAgCkGAnf8AEJ0oCyADKAJUIAFBAnRqQQA2AgAgAyABQQFqNgJYCyAIIAdBAWoiB0cNAAsLIANBuAFqIgIgA0EgaiIEENoRQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBCOOyADQdAAahCzLSADQYQBahC6LCADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiADQRhqELsjDAILDCMLIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQuyMLIANBgAJqJAAMGAsjAEGQAmsiAyQAIANBEGogASACKAIkEQQAEO4pIANBCGogASACKAIQEQAAIANBwAFqIAMoAggiASADKAIMKAIMEQAAAkACQCABBEAgAykDwAFCr/OQ2JScx/szhSADKQPIAUKgpcX0zdDRpI1/hYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0jIAMoAsgBIgFBvrX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiEMA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NKCADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIAMoAsABIAIQrB8gA0GsAWogA0EQaiADKAIAIAMoAgQQ4Q8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgDBD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNIyADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiCSABSQRAIAQgCUEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCSACIAlLGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENoRQdAAQQQQrTYiAUUNISABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuiwgA0GQAmokAAwXCyABIAIoAhwRBABB1LD/ABC6CEUEQCMAQYACayIDJAAgA0HAAWpBlqzYsAE2AgAgA0KWrNiw4cKFixY3A7gBIANBIGogASACIANBuAFqIgYgBBCGASADKAIoIQEgAygCJCECAkAgAygCICIEQZOAgIB4RwRAIAAgAykCLDcCDCAAIAE2AgggACACNgIEIAAgBDYCACAGEKYMDAELIAMgATYCHCADIAI2AhggA0G4AWoQpgwgA0EQaiADQRhqELkmIANBIGogAygCECIEIAMoAhQoAgwRAAACQAJAIAQEQCADKQMgQsKM9/bqy9zRhH+FIAMpAyhC5ZP0mPmv+Oiof4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNISADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDUOhD0KSAEENQ6IggEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxDyFiADQbgBaiADQSBqIgEgAygCCCADKAIMENwPIAMoArgBIgJBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACACNgIAIAEQjjsgChCzLSADQYQBahC7LAwECyAGEOY6IAMoAlxFDSQgAygCbEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshCSADKAJgIgsgAUkEQCAGIAtBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgsgAiALSxsQ6BkgAygCaCECCyAJBEAgAygCZCACakEAIAn8CwALIAMgATYCaAsgAyAMNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgCCAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBDdEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuywgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwiCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBcLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABD0KSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQq/zkNiUnMf7M4UgAykDyAFCoKXF9M3Q0aSNf4WEUA0BCyADQcABakEuQQBBAUEBEKAYIAMoAsQBIQIgAygCwAFBAUYNIiADKALIASIBQb61/wBBLvwKAAAgAEEuNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQcABaiABENgqIAMoAtwBIgIgAygC4AFHBEAgA0HMAGohBCADQUBrIQogA0HEAWohDANAAkACQCADKALEAQRAIAIgAygC1AFPDScgAygCyAEgAygC0AEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxDQELIAMgAkEBajYC3AEgAyADKALAASACEKwfIANBrAFqIANBEGogAygCACADKAIEENwPIAMoAqwBIgFBk4CAgHhGDQEgACADKQK0ATcCCCAAQRBqIANBvAFqKAIANgIAIAAgAygCsAE2AgQgACABNgIAIAMoAsQBIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAwQ+x4MBAsgAyACQQFqNgLcASAEEOY6IAMoAkxFDSIgAygCXEEBaiIHQQN2IAdBB3FBAEdqIgEgAygCWCICSwRAIAEgAmshBiADKAJQIgkgAUkEQCAEIAlBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgkgAiAJSxsQ6BkgAygCWCECCyAGBEAgAygCVCACakEAIAb8CwALIAMgATYCWAsgAyAHNgJcIAMoAkgiASADKAJARgRAIApBgJ3/ABCdKAsgAygCRCABQQJ0akEANgIAIAMgAUEBajYCSAsgAygC3AEiAiADKALgAUcNAAsLAkAgAygCxAEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgA0HEAWoQ+x4LIANBwAFqIgIgA0EQahDdEUHQAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0EQahCOOyADQUBrELMtIANB9ABqELssIANBkAJqJAAMFgsgASACKAIcEQQAQeCw/wAQughFBEAjAEGAAmsiAyQAIANBwAFqQZiw4MABNgIAIANCmLDgwIGDhowYNwO4ASADQSBqIAEgAiADQbgBaiIGIAQQhgEgAygCKCEBIAMoAiQhAgJAIAMoAiAiBEGTgICAeEcEQCAAIAMpAiw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAgBhCmDAwBCyADIAE2AhwgAyACNgIYIANBuAFqEKYMIANBEGogA0EYahC5JiADQSBqIAMoAhAiBCADKAIUKAIMEQAAAkACQCAEBEAgAykDIELH2fTn3sS2nHeFIAMpAyhCjbLOlIzKkuanf4WEUA0BCyADQSBqQS9BAEEBQQEQoBggAygCJCECIAMoAiBBAUYNICADKAIoIgFB7LX/AEEv/AoAACAAQS82AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBIGogBBDTOhDuKSAEENM6IggEQCADQdwAaiEGIANB0ABqIQoDQAJAIAQgBxCWJUUEQCADQQhqIAQgBxD/FiADQbgBaiADQSBqIgEgAygCCCADKAIMEOAPIAMoArgBIgJBk4CAgHhGDQEgACADKQLAATcCCCAAQRBqIANByAFqKAIANgIAIAAgAygCvAE2AgQgACACNgIAIAEQjjsgChCzLSADQYQBahC6LAwECyAGEOY6IAMoAlxFDSMgAygCbEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCaCICSwRAIAEgAmshCSADKAJgIgsgAUkEQCAGIAtBAXQiAiABQcD///8DcUFAayABIAFBP3EbIgsgAiALSxsQ6BkgAygCaCECCyAJBEAgAygCZCACakEAIAn8CwALIAMgATYCaAsgAyAMNgJsIAMoAlgiASADKAJQRgRAIApBgJ3/ABCdKAsgAygCVCABQQJ0akEANgIAIAMgAUEBajYCWAsgCCAHQQFqIgdHDQALCyADQbgBaiICIANBIGoiBBDWEUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQjjsgA0HQAGoQsy0gA0GEAWoQuiwgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgA0EYahC7IwwCCwwhCyADKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACADQRhqELsjCyADQYACaiQADBYLIwBBkAJrIgMkACADQRBqIAEgAigCJBEEABDuKSADQQhqIAEgAigCEBEAACADQcABaiADKAIIIgEgAygCDCgCDBEAAAJAAkAgAQRAIAMpA8ABQquYkfGV+tX8gH+FIAMpA8gBQpaU+Kvwsemz4QCFhFANAQsgA0HAAWpBLkEAQQFBARCgGCADKALEASECIAMoAsABQQFGDSEgAygCyAEiAUGQtf8AQS78CgAAIABBLjYCDCAAIAE2AgggACACNgIEIABBhoCAgHg2AgAMAQsgA0HAAWogARDYKiADKALcASICIAMoAuABRwRAIANBzABqIQQgA0FAayEKIANBxAFqIQwDQAJAAkAgAygCxAEEQCACIAMoAtQBTw0mIAMoAsgBIAMoAtABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyADIAJBAWo2AtwBIAMgA0HAAWogAhCtKiADQawBaiADQRBqIAMoAgAgAygCBBDgDyADKAKsASIBQZOAgIB4Rg0BIAAgAykCtAE3AgggAEEQaiADQbwBaigCADYCACAAIAMoArABNgIEIAAgATYCACADKALEASIARQ0EIAAgACgCACIAQQFrNgIAIABBAUcNBCAMEPseDAQLIAMgAkEBajYC3AEgBBDmOiADKAJMRQ0hIAMoAlxBAWoiB0EDdiAHQQdxQQBHaiIBIAMoAlgiAksEQCABIAJrIQYgAygCUCIJIAFJBEAgBCAJQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIJIAIgCUsbEOgZIAMoAlghAgsgBgRAIAMoAlQgAmpBACAG/AsACyADIAE2AlgLIAMgBzYCXCADKAJIIgEgAygCQEYEQCAKQYCd/wAQnSgLIAMoAkQgAUECdGpBADYCACADIAFBAWo2AkgLIAMoAtwBIgIgAygC4AFHDQALCwJAIAMoAsQBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBxAFqEPseCyADQcABaiICIANBEGoQ1hFB0ABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiACQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgALIANBEGoQjjsgA0FAaxCzLSADQfQAahC6LCADQZACaiQADBULIAEgAigCHBEEAEHgsP8AELoIRQRAIwBBgAJrIgMkACADQcABakGZsuTIATYCACADQpmy5MiRo8aMGTcDuAEgA0EgaiABIAIgA0G4AWoiBiAEEIYBIAMoAighASADKAIkIQICQCADKAIgIgRBk4CAgHhHBEAgACADKQIsNwIMIAAgATYCCCAAIAI2AgQgACAENgIAIAYQpgwMAQsgAyABNgIcIAMgAjYCGCADQbgBahCmDCADQRBqIANBGGoQuSYgA0EgaiADKAIQIgQgAygCFCgCDBEAAAJAAkAgBARAIAMpAyBC09jT+P3m9pJIhSADKQMoQqLYnojhoOrpzACFhFANAQsgA0EgakEvQQBBAUEBEKAYIAMoAiQhAiADKAIgQQFGDR8gAygCKCIBQey1/wBBL/wKAAAgAEEvNgIMIAAgATYCCCAAIAI2AgQgAEGGgICAeDYCAAwBCyADQSBqIAQQ1DoQ9CkgBBDUOiIIBEAgA0HcAGohBiADQdAAaiEKA0ACQCAEIAcQliVFBEAgA0EIaiAEIAcQ8RYgA0G4AWogA0EgaiIBIAMoAgggAygCDBDTDyADKAK4ASICQZOAgIB4Rg0BIAAgAykCwAE3AgggAEEQaiADQcgBaigCADYCACAAIAMoArwBNgIEIAAgAjYCACABEI47IAoQsy0gA0GEAWoQuywMBAsgBhDmOiADKAJcRQ0iIAMoAmxBAWoiDEEDdiAMQQdxQQBHaiIBIAMoAmgiAksEQCABIAJrIQkgAygCYCILIAFJBEAgBiALQQF0IgIgAUHA////A3FBQGsgASABQT9xGyILIAIgC0sbEOgZIAMoAmghAgsgCQRAIAMoAmQgAmpBACAJ/AsACyADIAE2AmgLIAMgDDYCbCADKAJYIgEgAygCUEYEQCAKQYCd/wAQnSgLIAMoAlQgAUECdGpBADYCACADIAFBAWo2AlgLIAggB0EBaiIHRw0ACwsgA0G4AWoiAiADQSBqIgQQ2BFB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEEI47IANB0ABqELMtIANBhAFqELssIAMoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIANBGGoQuyMMAgsMIAsgAygCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahC7IwsgA0GAAmokAAwVCyMAQZACayIDJAAgA0EQaiABIAIoAiQRBAAQ9CkgA0EIaiABIAIoAhARAAAgA0HAAWogAygCCCIBIAMoAgwoAgwRAAACQAJAIAEEQCADKQPAAUKrmJHxlfrV/IB/hSADKQPIAUKWlPir8LHps+EAhYRQDQELIANBwAFqQS5BAEEBQQEQoBggAygCxAEhAiADKALAAUEBRg0gIAMoAsgBIgFBkLX/AEEu/AoAACAAQS42AgwgACABNgIIIAAgAjYCBCAAQYaAgIB4NgIADAELIANBwAFqIAEQ2CogAygC3AEiAiADKALgAUcEQCADQcwAaiEEIANBQGshCiADQcQBaiEMA0ACQAJAIAMoAsQBBEAgAiADKALUAU8NJSADKALIASADKALQASACaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgAyACQQFqNgLcASADIANBwAFqIAIQrSogA0GsAWogA0EQaiADKAIAIAMoAgQQ0w8gAygCrAEiAUGTgICAeEYNASAAIAMpArQBNwIIIABBEGogA0G8AWooAgA2AgAgACADKAKwATYCBCAAIAE2AgAgAygCxAEiAEUNBCAAIAAoAgAiAEEBazYCACAAQQFHDQQgDBD7HgwECyADIAJBAWo2AtwBIAQQ5jogAygCTEUNICADKAJcQQFqIgdBA3YgB0EHcUEAR2oiASADKAJYIgJLBEAgASACayEGIAMoAlAiCSABSQRAIAQgCUEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiCSACIAlLGxDoGSADKAJYIQILIAYEQCADKAJUIAJqQQAgBvwLAAsgAyABNgJYCyADIAc2AlwgAygCSCIBIAMoAkBGBEAgCkGAnf8AEJ0oCyADKAJEIAFBAnRqQQA2AgAgAyABQQFqNgJICyADKALcASICIAMoAuABRw0ACwsCQCADKALEASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADQcQBahD7HgsgA0HAAWoiAiADQRBqENgRQdAAQQQQrTYiAUUNHiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyADQRBqEI47IANBQGsQsy0gA0H0AGoQuywgA0GQAmokAAwUCyABIAUoArgBQdCg/wAQ/S8ACyAFIAYQ/zs2AqADDBcLIAUgBhCAPDYCoAMMFgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENoUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0fIAMgCkEw/AoAACAHIAMQhj4gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwdCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC2LSACQTBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQZgBaiAFQcgCahCWKxDfIQJAAkAgBSgCmAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQfS0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoApwBEIAVIAVBsAFqIAIgECANEKMTIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiIMIAIpAwA3AwAgBUGvA2oiCSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNGCABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAMKQMANwAAIAFBGGogCSkAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUHUsv8AEPIJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0TIAVByAJqELsjDBMLIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRIgBUHIAmoQuyMMEgsMGgsMGQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENMUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHSAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0eIAMgCkEw/AoAACAHIAMQ/j0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwcCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC1LSACQSBBEBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQYgBaiAFQcgCahCWKxDdIQJAAkAgBSgCiAEiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQYi1/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAowBEIAVIAVBsAFqIAIgECANEKETIAUtALABIgNBKUcNASAFQdMDaiAFQcQBaigCACIBNgAAIAVBywNqIAVBvAFqKQIAIiQ3AAAgBSAFKQK0ASIlNwDDAyAAQRBqIAE2AAAgAEEIaiAkNwAAIAAgJTcAAAsgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0SIAVByAJqELsjDBILIAVBzwNqIgQgBUHAAWoiBykAADcAACAFQcgDaiICIAVBuQFqKQAANwMAIAVBkANqIgYgBUHQAWopAgA3AwAgBUGYA2oiCiAFQdgBaikCADcDACAFQagDaiIMIAIpAwA3AwAgBUGvA2oiCSAEKQAANwAAIAUgBSkCyAE3A4gDIAUgBSkAsQE3A6ADIAVBwANqIgQgAUEMahCAFUE4QQQQrTYiAUUNFyABIAM6AAggAUKBgICAEDcCACABIAUpA6ADNwAJIAEgBSkDiAM3AiAgAUERaiAMKQMANwAAIAFBGGogCSkAADcAACABQShqIAYpAwA3AgAgAUEwaiAKKQMANwIAIAVBsAFqIAQgAUH8sf8AEPIJIAUtAPQBIgNBAkYEQCAFQdADaiAHKAIAIgE2AgAgAiAFQbgBaikCACIkNwMAIAUgBSkCsAEiJTcDwAMgAEEQaiABNgIAIABBCGogJDcCACAAICU3AgAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0SIAVByAJqELsjDBILIAVBwANqIgIgBUGwAWpBxAD8CgAAIAVBvgNqIgQgBUH3AWotAAA6AAAgBSAFLwD1ATsBvANB0ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQcQA/AoAACABIAM6AEwgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAEgBS8BvAM7AE0gAUHPAGogBC0AADoAACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDREgBUHIAmoQuyMMEQsMGQsMGAsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENIUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNHCAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0dIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwbCwJAQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAFQdABahCzLSAFQYQCahC0LSACQRBBCBDZJyAFKAKIAyICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIA2oQuyMLIAVB0Kf/ADYCzAIgBSABNgLIAiAFQfgAaiAFQcgCahCWKxDiIQJAAkAgBSgCeCIBRQRAIAVBAjYCtAEgBUHEtP8ANgKwASAFQgE3ArwBIAVBzAE2AtQCIAVB4LT/ADYC0AIgBSAFQdACajYCuAEgBUHEA2ogBUGwAWoQmQ4gBSkCxAMhJCAAIAUpAswDNwIMIAAgJDcCBCAAQYaAgIB4NgIADAELIAVB0AJqIgIgBSgCfBCAFSAFQbABaiACIBAgDRCiEyAFLQCwASIDQSlHDQEgBUHTA2ogBUHEAWooAgAiATYAACAFQcsDaiAFQbwBaikCACIkNwAAIAUgBSkCtAEiJTcAwwMgAEEQaiABNgAAIABBCGogJDcAACAAICU3AAALIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCyAFQc8DaiIEIAVBwAFqIgcpAAA3AAAgBUHIA2oiAiAFQbkBaikAADcDACAFQZADaiIGIAVB0AFqKQIANwMAIAVBmANqIgogBUHYAWopAgA3AwAgBUGoA2oiDCACKQMANwMAIAVBrwNqIgkgBCkAADcAACAFIAUpAsgBNwOIAyAFIAUpALEBNwOgAyAFQcADaiIEIAFBDGoQgBVBOEEEEK02IgFFDRYgASADOgAIIAFCgYCAgBA3AgAgASAFKQOgAzcACSABIAUpA4gDNwIgIAFBEWogDCkDADcAACABQRhqIAkpAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCikDADcCACAFQbABaiAEIAFBpLH/ABDyCSAFLQD0ASIDQQJGBEAgBUHQA2ogBygCACIBNgIAIAIgBUG4AWopAgAiJDcDACAFIAUpArABIiU3A8ADIABBEGogATYCACAAQQhqICQ3AgAgACAlNwIAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNESAFQcgCahC7IwwRCyAFQcADaiICIAVBsAFqQcQA/AoAACAFQb4DaiIEIAVB9wFqLQAAOgAAIAUgBS8A9QE7AbwDQdAAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkHEAPwKAAAgASADOgBMIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACABIAUvAbwDOwBNIAFBzwBqIAQtAAA6AAAgBSgCyAIiACAAKAIAIgBBAWs2AgAgAEEBRw0QIAVByAJqELsjDBALDBgLDBcLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDXFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRsgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNHCADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMGgsCQEHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiANqELsjCyAFQdCn/wA2AswCIAUgATYCyAIgBUHoAGogBUHIAmoQlisQ3iECQAJAIAUoAmgiAUUEQCAFQQI2ArQBIAVBxLT/ADYCsAEgBUIBNwK8ASAFQcwBNgLUAiAFQZC0/wA2AtACIAUgBUHQAmo2ArgBIAVBxANqIAVBsAFqEJkOIAUpAsQDISQgACAFKQLMAzcCDCAAICQ3AgQgAEGGgICAeDYCAAwBCyAFQdACaiICIAUoAmwQgBUgBUGwAWogAiARIBAQoBMgBS0AsAEiA0EpRw0BIAVB0wNqIAVBxAFqKAIAIgE2AAAgBUHLA2ogBUG8AWopAgAiJDcAACAFIAUpArQBIiU3AMMDIABBEGogATYAACAAQQhqICQ3AAAgACAlNwAACyAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHPA2oiBCAFQcABaiIHKQAANwAAIAVByANqIgIgBUG5AWopAAA3AwAgBUGQA2oiBiAFQdABaikCADcDACAFQZgDaiIKIAVB2AFqKQIANwMAIAVBqANqIgwgAikDADcDACAFQa8DaiIJIAQpAAA3AAAgBSAFKQLIATcDiAMgBSAFKQCxATcDoAMgBUHAA2oiBCABQQxqEIAVQThBBBCtNiIBRQ0VIAEgAzoACCABQoGAgIAQNwIAIAEgBSkDoAM3AAkgASAFKQOIAzcCICABQRFqIAwpAwA3AAAgAUEYaiAJKQAANwAAIAFBKGogBikDADcCACABQTBqIAopAwA3AgAgBUGwAWogBCABQayz/wAQ8gkgBS0A9AEiA0ECRgRAIAVB0ANqIAcoAgAiATYCACACIAVBuAFqKQIAIiQ3AwAgBSAFKQKwASIlNwPAAyAAQRBqIAE2AgAgAEEIaiAkNwIAIAAgJTcCACAFKALIAiIAIAAoAgAiAEEBazYCACAAQQFHDRAgBUHIAmoQuyMMEAsgBUHAA2oiAiAFQbABakHEAPwKAAAgBUG+A2oiBCAFQfcBai0AADoAACAFIAUvAPUBOwG8A0HQAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBxAD8CgAAIAEgAzoATCAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgASAFLwG8AzsATSABQc8AaiAELQAAOgAAIAUoAsgCIgAgACgCACIAQQFrNgIAIABBAUcNDyAFQcgCahC7IwwPCwwXCwwWCyAFQcADaiEEIwBBkANrIgEkACAFQbABaiICQSBqEJc2IAFBCGoiBiACQegAahDHFCABQUBrIgcgAkE0ahDUFAJAQQxBBBCtNiIDBEAgA0KIkKDAgIGChAg3AgAgA0EIakGIkKDAADYCACACKAIwIQpBDEEEEK02IgJFDRogAiAKNgIEIAJBFToAACABIAI2AnggASADNgJ0IAFBIjoAcCABQdgBaiIDIAcQ8T0gAUG0AmoiAiADEKEbIAMgAiABQfAAahCMGEHEAEEEEK02IgdFDRsgByAGEO89IAFBATYCvAIgASAHNgK4AiABQQE2ArQCIAFB/ABqIgcgAyACEPwiIAIgBxDNHCAEIAIQowggAUGQA2okAAwBCwwZC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqEI47IAVB5AFqELMtIAVBmAJqEIovIAUoAtACIgAgACgCACIAQQFrNgIAIABBAUcNDSAFQdACahC7IwwNCwwVCyAFKALQAiIAIAAoAgAiAEEBazYCACAAQQFHDQsgBUHQAmoQuyMMCwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENgUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNGCAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0ZIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwXC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCyAFQYgDahC7IwwLCwwTCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQzRQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0XIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRggAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBYLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAVBiANqELsjDAoLDBILIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDVFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRYgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFyADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMFQtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQkgBUGIA2oQuyMMCQsMEQsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENkUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNFSAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0WIAMgCkEw/AoAACAHIAMQ8D0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwUC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELQtIAJBEEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNCCAFQYgDahC7IwwICwwQCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1BQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0UIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRUgAyAKQTD8CgAAIAcgAxDxPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBMLQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQsy0gAkEIQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAVBiANqELsjDAcLDA8LIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDPFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRMgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNFCADIApBMPwKAAAgByADEPk9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMEgtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCyLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQYgBUGIA2oQuyMMBgsMDgsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqENEUIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNEiAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0TIAMgCkEw/AoAACAHIAMQ9z0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwRC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNBSAFQYgDahC7IwwFCwwNCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ2xQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0RIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDRIgAyAKQTD8CgAAIAcgAxDwPSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDBALQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAGQcgA/AoAACAAQdCn/wA2AgggACABNgIEIABBk4CAgHg2AgAgBUHQAWoQsy0gBUGEAmoQtC0gAkEQQQgQ2ScgBSgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0EIAVBiANqELsjDAQLDAwLIwBBkANrIgEkACAFQbABaiICKAIMBEACQCACKAIEIgNFDQAgA0EJaiIERQ0AIAIoAgBB/wEgBPwLAAsgAkEANgIMIAIgAyADQQFqQQN2QQdsIANBCEkbNgIICyAFQcADaiEGIAFBBGoiCiACQdQAahDQFCABQTRqIgwgAkEgahDUFAJAQQxBBBCtNiIEBEAgBEKIkKDAgIGChAg3AgAgBEEIakGIkKDAADYCACABQagCaiIDIAoQyAZBDEEEEK02IgdFDRAgByABKQKoAjcCACAHQQhqIAFBsAJqKAIANgIAIAEgBzYCbCABIAQ2AmggAUEiOgBkIAFBzAFqIgQgDBDxPSADIAQQoRsgBCADIAFB5ABqEIwYQcQAQQQQrTYiB0UNESADIApBMPwKAAAgByADEPE9IAFBATYCjAMgASAHNgKIAyABQQE2AoQDIAFB8ABqIgcgBCABQYQDahD8IiADIAcQzRwgBiADEKMIIAFBkANqJAAMAQsMDwtB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAZByAD8CgAAIABB0Kf/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAFQdABahCzLSAFQYQCahCzLSACQQhBCBDZJyAFKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQMgBUGIA2oQuyMMAwsMCwsjAEGQA2siASQAIAVBsAFqIgIoAgwEQAJAIAIoAgQiA0UNACADQQlqIgRFDQAgAigCAEH/ASAE/AsACyACQQA2AgwgAiADIANBAWpBA3ZBB2wgA0EISRs2AggLIAVBwANqIQYgAUEEaiIKIAJB1ABqEM4UIAFBNGoiDCACQSBqENQUAkBBDEEEEK02IgQEQCAEQoiQoMCAgYKECDcCACAEQQhqQYiQoMAANgIAIAFBqAJqIgMgChDIBkEMQQQQrTYiB0UNDyAHIAEpAqgCNwIAIAdBCGogAUGwAmooAgA2AgAgASAHNgJsIAEgBDYCaCABQSI6AGQgAUHMAWoiBCAMEPE9IAMgBBChGyAEIAMgAUHkAGoQjBhBxABBBBCtNiIHRQ0QIAMgCkEw/AoAACAHIAMQ+T0gAUEBNgKMAyABIAc2AogDIAFBATYChAMgAUHwAGoiByAEIAFBhANqEPwiIAMgBxDNHCAGIAMQowggAUGQA2okAAwBCwwOC0HQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELItIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNAiAFQYgDahC7IwwCCwwKCyMAQZADayIBJAAgBUGwAWoiAigCDARAAkAgAigCBCIDRQ0AIANBCWoiBEUNACACKAIAQf8BIAT8CwALIAJBADYCDCACIAMgA0EBakEDdkEHbCADQQhJGzYCCAsgBUHAA2ohBiABQQRqIgogAkHUAGoQ1hQgAUE0aiIMIAJBIGoQ1BQCQEEMQQQQrTYiBARAIARCiJCgwICBgoQINwIAIARBCGpBiJCgwAA2AgAgAUGoAmoiAyAKEMgGQQxBBBCtNiIHRQ0OIAcgASkCqAI3AgAgB0EIaiABQbACaigCADYCACABIAc2AmwgASAENgJoIAFBIjoAZCABQcwBaiIEIAwQ8T0gAyAEEKEbIAQgAyABQeQAahCMGEHEAEEEEK02IgdFDQ8gAyAKQTD8CgAAIAcgAxD3PSABQQE2AowDIAEgBzYCiAMgAUEBNgKEAyABQfAAaiIHIAQgAUGEA2oQ/CIgAyAHEM0cIAYgAxCjCCABQZADaiQADAELDA0LQdAAQQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogBkHIAPwKAAAgAEHQp/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAVB0AFqELMtIAVBhAJqELEtIAJBCEEIENknIAUoAogDIgAgACgCACIAQQFrNgIAIABBAUcNACAFQYgDahC7IwsgBUGQBGokAA8LIAUgBxCjPDYCoAMMAwsgBSAHEP47NgKgAwwCCyAFIAcQ/Ds2AqADDAELIAUgBxD9OzYCoAMLIAVBAjYCxAMgBUHgnP8ANgLAAyAFQgI3AswDIAVBOzYC3AIgBUE7NgLUAiAFIAVB0AJqNgLIAyAFIAVBoANqNgLYAiAFIAVByAJqNgLQAiAFQcADakHwnP8AEO8sAAtBBEE4EKM9AAsgAiADKAIoQdCg/wAQ/S8AC0Hgnf8AELI7AAtBBEHQABCjPQALIAIgAygCyAFB0KD/ABD9LwALQbCd/wBBIEHQnf8AEJ8pAAtBBEEMEKM9AAtBBEHEABCjPQALhcUYAhZ/B34jAEGQCmsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwRBAAiCiADELsIBEAgCiEJIAEhBSACIQYMAQsgA0EEaiEHIAMoAgQhCyADLQAAIg1BAWshDiANQRtGIQ8gDUEbayEQIAohCSACIQYgASEFA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAktAAAiDARAIAxBIkYNASAQDggNDA4PDAwMEAwLIA4OJwEBAQEBAQEBAQsBAQEBAQEBAQEBAQEBAQEBAQsBAQsBCwELCwsLAQsLIAggAzYCSCAIIAk2AkwgCSgCBC0AAEECaw4IAgMEBQYHCAkBCyAIQUBrIAMgBSAGKAIkEQQAEKErIAAgCCkDQDcCBCAAQZOAgIB4NgIADLcDCyAIQQM2AlQgCEHs2/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLYDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhCIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQdiq/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIQiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMsDCyABQQhqIAUgBhCEIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMoDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANCxsy654zqoIW8f4UgASkDuANCutKR74r29PjMAIWEUA0DCyABQbADakHKAEEAQQFBARCgGCABKAK0AyECIAEoArADQQFHDQMMyQMLIAEoArgDIgNB9q//AEHGAPwKAAAgAELGADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMCgsgAigCECEHIAFBsANqIgUgA0EYahCoPhDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNAyABIAQ2ArAEIAEgAikCHDcCtAQgBSABQbAEaiICENkgGiACIANBDGoQvS0gASgCzAQiAiABKALQBEYNByABQegDaiEJIAFBjARqIQQgAUG0BGohCgNAAkACQAJAAkAgASgCtAQEQCACIAEoAsQETw3JAyABKAK4BCABKALABCACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLMBCABKAKwBCgCECACaiwAACICQQBODQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMzQMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNyAMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNCyACIAIoAgAiAkEBazYCACACQQFHDQsgChD7HgwLCyABQbADakEAIAcgAkECdGoiAigCACIDIAJBBGooAgAgA2sQiRALIAEoAswEIgIgASgC0ARHDQALDAcLIAFBsANqIgYgAkEMahCnLiABQcgBaiIJIAYQthMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUHYqv8ANgIgIAEgBTYCHCAGIAFBHGpB6KL/ACAHKAIAIgkgBBCGASABKAKwAyIFQZOAgIB4RwRAIAEpArQDIRsgACABKQK8AzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCtAM3AtQEIAFBsANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCuAMhBCABKAK0AyECIAEoArADIgVBk4CAgHhHBEAgACABKQK8AzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AuQCIAEgAjYC4AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFB1ARqEPgtIAFBHGoQ+C1NBEAgAUEoaiIGIAEoAtQEIAEoAtgEENMjIAFBsANqIgUgBhChGyABQbAEaiIGIAMQxwYgAUHIAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCuAQgASAHNgK0BCABQQE2ArAEIAFB7ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUHUBGoQ+C0gAUEcaiIDEPgtazYCJCABIAMQ8y02ArAEIAFBAzYCzAEgAUHoqf8ANgLIASABQgM3AtQBIAFBlww2AsQDIAFBrwM2ArwDIAFBOzYCtAMgASABQbADajYC0AEgASABQRhqNgLAAyABIAFBsARqNgK4AyABIAFBJGo2ArADIABBBGogAUHIAWoQqhggAEGGgICAeDYCACACIAIoAgAiAEEBazYCACAAQQFHDQsgAUHgAmoQuyMMCwsgAUGwA2oiAiABQcgBahCeCCACEOspIQJBwKP/AAwHCyABQbADaiICIAFByAFqEKQIIAIQ6ykhAkGYpP8ADAYLIAFBsANqIgIgAUHIAWoQogggAhDrKSECQfCk/wAMBQsgAUGwA2oiAiABQcgBahCgCCACEOspIQJByKX/AAwECyABQbADaiICIAFByAFqEJ0IIAIQ6ykhAkGgpv8ADAMLIAFBsANqIgIgAUHIAWoQnwggAhDrKSECQfim/wAMAgsgAUGwA2oiAiABQcgBahCjCCACEOspIQJB0Kf/AAwBCyABQbADaiICIAFByAFqEKEIIAIQ6ykhAkGoqP8ACzYCCCAAIAI2AgQgAEGTgICAeDYCACABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNDCABQRxqELsjDAwLIAFBAjYCtAMgAUGoqf8ANgKwAyABQgE3ArwDIAFBlww2ArQEIAEgAUGwBGo2ArgDIAEgAUEYajYCsAQgAEEEaiABQbADahCqGCAAQYKAgIB4NgIAIAFByAFqEP8mDAILDMYDCyABKALUBCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHUBGoQuyMLIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgASgCuAMiA0Horv8AQcoA/AoAACAAQcoANgIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwHCyACKAIQIQcgAUGwA2oiBSADQRhqEKg+EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC9LSABKALMBCICIAEoAtAERg0BIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcYDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJqLAAAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzKAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3FAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0FIAIgAigCACICQQFrNgIAIAJBAUcNBSAKEPseDAULIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMAQsACwJAIAEoArQEIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBtARqEPseCyABQcgBaiABQbADahDbDAsgAUGwA2oQ6SUgAUHoAmoiAiABQdQBaikCADcDACABQfACaiIDIAFB3AFqKAIANgIAIAEgASkCzAE3A+ACIAEoAsgBIgRBgICAgHhGBEAgACABKQPgAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAQLIAFBpAJqIgMgAUHgAWpBJPwKAAAgAUHQAmoiBSABQegCaikDADcDACABQdgCaiIGIAFB8AJqKAIANgIAIAEgASkD4AI3A8gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDyAI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAQLDMADCyABKAK4AyIDQbKv/wBBxAD8CgAAIABCxAA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAILAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENwMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUH0AmoiAyABQeABakEk/AoAACABQaADaiIFIAFB6AJqKQMANwMAIAFBqANqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDmAMQsD5BxABBBBCtNiICRQ29AyACIAQ2AgggAkKBgICAEDcCACACIAEpA5gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwy1AwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAiAkEXaw4EAgEBAwALIAJBIkYNAwsgAUGwA2ogBSAGEIMiIgVBPGpB6KL/ACADIAQQhgEgASgCuAMhAyABKAK0AyECIAEoArADIgRBk4CAgHhHBEAgACABKQK8AzcCDCAAIAM2AgggACACNgIEIAAgBDYCAAwPCyABIAM2AswBIAEgAjYCyAEgACACIAMoAghBAWtBeHFqQQhqIAMgBUEMakGQrv8AEJMBIAIgAigCACIAQQFrNgIAIABBAUcNDiABQcgBahC7IwwOCyABIAUgBhCDIiIDQTxqELkmIAFBsANqIAEoAgAiAiABKAIEKAIMEQAAIAIEQCABKQOwA0KQnrPu2bSNkukAhSABKQO4A0KI9KuB4LHF5MIAhYRQDQQLIAFBsANqQcYAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAgzKAwsgAUEIaiAFIAYQgyIiA0E8ahC5JiABQbADaiABKAIIIgIgASgCDCgCDBEAACACBEAgASkDsANCx9n0597Etpx3hSABKQO4A0KNss6UjMqS5qd/hYRQDQYLIAFBsANqQcQAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNCQzJAwsgASADQQRqIgc2AhggAUEQaiAFIAYoAhARAAAgAUGwA2ogASgCECICIAEoAhQoAgwRAAAgAgRAIAEpA7ADQpOT7vXoqIKWZ4UgASkDuANCmJLh6biI4pZphYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzIAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENk8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC/LSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcgDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBAXRqLgEAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzMAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3HAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMBwsgAUGwA2oiBiACQQxqEKUuIAFByAFqIgkgBhC9ExCwPgJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGogCUEw/AoAACABQZCu/wA2AiAgASAFNgIcIAYgAUEcakHoov8AIAcoAgAiCSAEEIYBIAEoArADIgVBk4CAgHhHBEAgASkCtAMhGyAAIAEpArwDNwIMIAAgGzcCBCAAIAU2AgAMAwsgASABKQK0AzcC1AQgAUGwA2ogAkE8akHoov8AIAMoAgggBBCGASABKAK4AyEEIAEoArQDIQIgASgCsAMiBUGTgICAeEcEQCAAIAEpArwDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC5AIgASACNgLgAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUHUBGoQ+C0gAUEcahD4LU0EQCABQShqIgYgASgC1AQgASgC2AQQ0yMgAUGwA2oiBSAGEKEbIAFBsARqIgYgAxDHBiABQcgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgK4BCABIAc2ArQEIAFBATYCsAQgAUHsAGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQdQEahD4LSABQRxqIgMQ+C1rNgIkIAEgAxDzLTYCsAQgAUEDNgLMASABQeip/wA2AsgBIAFCAzcC1AEgAUGXDDYCxAMgAUGvAzYCvAMgAUE7NgK0AyABIAFBsANqNgLQASABIAFBGGo2AsADIAEgAUGwBGo2ArgDIAEgAUEkajYCsAMgAEEEaiABQcgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQeACahC7IwwLCyABQbADaiICIAFByAFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBsANqIgIgAUHIAWoQpAggAhDrKSECQZik/wAMBgsgAUGwA2oiAiABQcgBahCiCCACEOspIQJB8KT/AAwFCyABQbADaiICIAFByAFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBsANqIgIgAUHIAWoQnQggAhDrKSECQaCm/wAMAwsgAUGwA2oiAiABQcgBahCfCCACEOspIQJB+Kb/AAwCCyABQbADaiICIAFByAFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBsANqIgIgAUHIAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0MIAFBHGoQuyMMDAsgAUECNgK0AyABQaip/wA2ArADIAFCATcCvAMgAUGXDDYCtAQgASABQbAEajYCuAMgASABQRhqNgKwBCAAQQRqIAFBsANqEKoYIABBgoCAgHg2AgAgAUHIAWoQ/yYMAgsMxQMLIAEoAtQEIgAgACgCACIAQQFrNgIAIABBAUcNACABQdQEahC7IwsgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQggAUEcahC7IwwICyABKAK4AyIDQeiu/wBBygD8CgAAIABBygA2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAcLIAIoAhAhByABQbADaiIFIANBGGoQ2TwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEL8tIAEoAswEIgIgASgC0ARGDQEgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NxQMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkEBdGouAQAiAkEATg0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMkDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcQDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIAJBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMvwMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbwDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDLQDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhyIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQYis/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIciIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMkDCyABQQhqIAUgBhCHIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMgDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANC2s6AyavF6v3HAIUgASkDuANCm/Tdt5mL044/hYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzHAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENs8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahDALSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDccDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBAnRqKAIAIgJBAE4NAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzLAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3GAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByACQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMBwsgAUGwA2oiBiACQQxqEKkuIAFByAFqIgkgBhCtExCwPgJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGogCUEw/AoAACABQYis/wA2AiAgASAFNgIcIAYgAUEcakHoov8AIAcoAgAiCSAEEIYBIAEoArADIgVBk4CAgHhHBEAgASkCtAMhGyAAIAEpArwDNwIMIAAgGzcCBCAAIAU2AgAMAwsgASABKQK0AzcC1AQgAUGwA2ogAkE8akHoov8AIAMoAgggBBCGASABKAK4AyEEIAEoArQDIQIgASgCsAMiBUGTgICAeEcEQCAAIAEpArwDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC5AIgASACNgLgAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUHUBGoQ+C0gAUEcahD4LU0EQCABQShqIgYgASgC1AQgASgC2AQQ0yMgAUGwA2oiBSAGEKEbIAFBsARqIgYgAxDHBiABQcgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgK4BCABIAc2ArQEIAFBATYCsAQgAUHsAGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQdQEahD4LSABQRxqIgMQ+C1rNgIkIAEgAxDzLTYCsAQgAUEDNgLMASABQeip/wA2AsgBIAFCAzcC1AEgAUGXDDYCxAMgAUGvAzYCvAMgAUE7NgK0AyABIAFBsANqNgLQASABIAFBGGo2AsADIAEgAUGwBGo2ArgDIAEgAUEkajYCsAMgAEEEaiABQcgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQeACahC7IwwLCyABQbADaiICIAFByAFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBsANqIgIgAUHIAWoQpAggAhDrKSECQZik/wAMBgsgAUGwA2oiAiABQcgBahCiCCACEOspIQJB8KT/AAwFCyABQbADaiICIAFByAFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBsANqIgIgAUHIAWoQnQggAhDrKSECQaCm/wAMAwsgAUGwA2oiAiABQcgBahCfCCACEOspIQJB+Kb/AAwCCyABQbADaiICIAFByAFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBsANqIgIgAUHIAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0MIAFBHGoQuyMMDAsgAUECNgK0AyABQaip/wA2ArADIAFCATcCvAMgAUGXDDYCtAQgASABQbAEajYCuAMgASABQRhqNgKwBCAAQQRqIAFBsANqEKoYIABBgoCAgHg2AgAgAUHIAWoQ/yYMAgsMxAMLIAEoAtQEIgAgACgCACIAQQFrNgIAIABBAUcNACABQdQEahC7IwsgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQggAUEcahC7IwwICyABKAK4AyIDQeiu/wBBygD8CgAAIABBygA2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAcLIAIoAhAhByABQbADaiIFIANBGGoQ2zwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEMAtIAEoAswEIgIgASgC0ARGDQEgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NxAMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkECdGooAgAiAkEATg0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMgDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcMDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIAJBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMvgMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbsDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDLMDCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhSIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQeCs/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIUiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMgDCyABQQhqIAUgBhCFIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMcDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANC/Ou54rzv+NByhSABKQO4A0La45+NzI/hgal/hYRQDQMLIAFBsANqQcoAQQBBAUEBEKAYIAEoArQDIQIgASgCsANBAUcNAwzGAwsgASgCuAMiA0H2r/8AQcYA/AoAACAAQsYANwIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwKCyACKAIQIQcgAUGwA2oiBSADQRhqENg8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC+LSABKALMBCICIAEoAtAERg0HIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDcYDIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBA3RqKQMAIhtCgICAgBBUDQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMygMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNxQMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNCyACIAIoAgAiAkEBazYCACACQQFHDQsgChD7HgwLCyABQbADakEAIAcgG6dBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwHCyABQbADaiIGIAJBDGoQqC4gAUHIAWoiCSAGELETELA+AkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiAJQTD8CgAAIAFB4Kz/ADYCICABIAU2AhwgBiABQRxqQeii/wAgBygCACIJIAQQhgEgASgCsAMiBUGTgICAeEcEQCABKQK0AyEbIAAgASkCvAM3AgwgACAbNwIEIAAgBTYCAAwDCyABIAEpArQDNwLUBCABQbADaiACQTxqQeii/wAgAygCCCAEEIYBIAEoArgDIQQgASgCtAMhAiABKAKwAyIFQZOAgIB4RwRAIAAgASkCvAM3AgwgACAENgIIIAAgAjYCBCAAIAU2AgAMAgsgASAENgLkAiABIAI2AuACAkAgAAJ/AkACQAJAAkACQAJAAkACQCABQdQEahD4LSABQRxqEPgtTQRAIAFBKGoiBiABKALUBCABKALYBBDTIyABQbADaiIFIAYQoRsgAUGwBGoiBiADEMcGIAFByAFqIgMgBSAGEIwYEKgvIQcgBSACIAQQ0yMgByAFQcQA/AoAACABQQE2ArgEIAEgBzYCtAQgAUEBNgKwBCABQewAaiICIAMgBhD8IiADIAIQzRwgCS0AAEECaw4IAQIDBAUGBwgKCyABIAFB1ARqEPgtIAFBHGoiAxD4LWs2AiQgASADEPMtNgKwBCABQQM2AswBIAFB6Kn/ADYCyAEgAUIDNwLUASABQZcMNgLEAyABQa8DNgK8AyABQTs2ArQDIAEgAUGwA2o2AtABIAEgAUEYajYCwAMgASABQbAEajYCuAMgASABQSRqNgKwAyAAQQRqIAFByAFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB4AJqELsjDAsLIAFBsANqIgIgAUHIAWoQngggAhDrKSECQcCj/wAMBwsgAUGwA2oiAiABQcgBahCkCCACEOspIQJBmKT/AAwGCyABQbADaiICIAFByAFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBsANqIgIgAUHIAWoQoAggAhDrKSECQcil/wAMBAsgAUGwA2oiAiABQcgBahCdCCACEOspIQJBoKb/AAwDCyABQbADaiICIAFByAFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBsANqIgIgAUHIAWoQowggAhDrKSECQdCn/wAMAQsgAUGwA2oiAiABQcgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCHCIAIAAoAgAiAEEBazYCACAAQQFHDQwgAUEcahC7IwwMCyABQQI2ArQDIAFBqKn/ADYCsAMgAUIBNwK8AyABQZcMNgK0BCABIAFBsARqNgK4AyABIAFBGGo2ArAEIABBBGogAUGwA2oQqhggAEGCgICAeDYCACABQcgBahD/JgwCCwzDAwsgASgC1AQiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFB1ARqELsjCyABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNCCABQRxqELsjDAgLIAEoArgDIgNB6K7/AEHKAPwKAAAgAEHKADYCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMBwsgAigCECEHIAFBsANqIgUgA0EYahDYPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNACABIAQ2ArAEIAEgAikCHDcCtAQgBSABQbAEaiICENkgGiACIANBDGoQvi0gASgCzAQiAiABKALQBEYNASABQegDaiEJIAFBjARqIQQgAUG0BGohCgNAAkACQAJAAkAgASgCtAQEQCACIAEoAsQETw3DAyABKAK4BCABKALABCACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLMBCABKAKwBCgCECACQQN0aikDACIbQoCAgIAQVA0CIAFB1ARqQRhBAEEBQQEQoBggASgC2AQhAiABKALUBEEBRw0BDMcDCyABIAJBAWo2AswEIAQQ5jogASgCjARFDcIDIAEoApwEQQFqIgVBA3YgBUEHcUEAR2oiAyABKAKYBCICSwRAIAMgAmshBiABKAKQBCILIANJBEAgBCALQQF0IgIgA0HA////A3FBQGsgAyADQT9xGyILIAIgC0sbEOgZIAEoApgEIQILIAYEQCABKAKUBCACakEAIAb8CwALIAEgAzYCmAQLIAEgBTYCnAQgASgC8AMiAiABKALoA0YEQCAJQaCd/wAQsSgLIAEoAuwDIAJBBHRqIgNCADcDCCADQgA3AwAgASACQQFqNgLwAwwCCyABKALcBCIDQRBqQcyw/wApAAA3AAAgA0EIakHEsP8AKQAANwAAIANBvLD/ACkAADcAACABQRg2AtgBIAEgAzYC1AEgASACNgLQASABQoCAgIDogICAgH83AsgBIAEoArQEIgJFDQUgAiACKAIAIgJBAWs2AgAgAkEBRw0FIAoQ+x4MBQsgAUGwA2pBACAHIBunQQJ0aiICKAIAIgMgAkEEaigCACADaxCJEAsgASgCzAQiAiABKALQBEcNAAsMAQsACwJAIAEoArQEIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBtARqEPseCyABQcgBaiABQbADahDbDAsgAUGwA2oQ6SUgAUHoAmoiAiABQdQBaikCADcDACABQfACaiIDIAFB3AFqKAIANgIAIAEgASkCzAE3A+ACIAEoAsgBIgRBgICAgHhGBEAgACABKQPgAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAQLIAFBpAJqIgMgAUHgAWpBJPwKAAAgAUHQAmoiBSABQegCaikDADcDACABQdgCaiIGIAFB8AJqKAIANgIAIAEgASkD4AI3A8gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDyAI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAQLDL0DCyABKAK4AyIDQbKv/wBBxAD8CgAAIABCxAA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAILAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENwMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUH0AmoiAyABQeABakEk/AoAACABQaADaiIFIAFB6AJqKQMANwMAIAFBqANqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDmAMQsD5BxABBBBCtNiICRQ26AyACIAQ2AgggAkKBgICAEDcCACACIAEpA5gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwyyAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQcADaiAFIAYQiSIiBUE8akHoov8AIAMgBBCGASABKALIAyEDIAEoAsQDIQIgASgCwAMiBEGTgICAeEcEQCAAIAEpAswDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA0LIAEgAzYC3AEgASACNgLYASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQbit/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0MIAFB2AFqELsjDAwLIAFBCGogBSAGEIkiIgNBPGoQuSYgAUHAA2ogASgCCCICIAEoAgwoAgwRAAAgAgRAIAEpA8ADQpCes+7ZtI2S6QCFIAEpA8gDQoj0q4HgscXkwgCFhFANBAsgAUHAA2pBxgBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0CDMcDCyABQRBqIAUgBhCJIiIDQTxqELkmIAFBwANqIAEoAhAiAiABKAIUKAIMEQAAIAIEQCABKQPAA0LH2fTn3sS2nHeFIAEpA8gDQo2yzpSMypLmp3+FhFANBgsgAUHAA2pBxABBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0IDMYDCyABIANBBGoiBzYCICABQRhqIAUgBigCEBEAACABQcADaiABKAIYIgIgASgCHCgCDBEAACACBEAgASkDwANC/Pb4rvGI1KEVhSABKQPIA0LvytP9o9G+0fAAhYRQDQMLIAFBwANqQcoAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAwzFAwsgASgCyAMiAkH2r/8AQcYA/AoAACAAQsYANwIMIAAgAjYCCCAAIAM2AgQgAEGGgICAeDYCAAwICyACKAIQIQogAUHAA2oiBSADQRhqEKg+EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0DIAEgBDYCvAQgASACKQIcNwLABCAFIAFBvARqIgIQ2SAaIAIgA0EMahC9LSABKALYBCICIAEoAtwEIgtGBEAgASgCwAQhBAwHCyABQfgDaiEMIAFBnARqIQYgASgCwAQhBANAAkACQCAERQ0AIAIgASgC0ARPDcADIAEoAsQEIAIgASgCzARqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcUUNACABIAJBAWo2AtgEIAYQ5jogASgCnARFDcEDIAEoAqwEQQFqIgdBA3YgB0EHcUEAR2oiBSABKAKoBCIDSwRAIAUgA2shCSABKAKgBCINIAVJBEAgBiANQQF0IgMgBUHA////A3FBQGsgBSAFQT9xGyINIAMgDUsbEOgZIAEoAqgEIQMLIAkEQCABKAKkBCADakEAIAn8CwALIAEgBTYCqAQLIAEgBzYCrAQgASgCgAQiAyABKAL4A0YEQCAMQaCd/wAQsSgLIAEoAvwDIANBBHRqIgVCADcDCCAFQgA3AwAgASADQQFqNgKABAwBCyABIAJBAWo2AtgEIAFBwANqQQAgCiABKAK8BCgCECACai0AAEECdGoiAygCACIFIANBBGooAgAgBWsQiRAMAAsgAkEBaiICIAtHDQALDAYLIAFBwANqIgYgAkEMahCnLiABQdgBaiIJIAYQuBMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUG4rf8ANgIoIAEgBTYCJCAGIAFBJGpB6KL/ACAHKAIAIgkgBBCGASABKALAAyIFQZOAgIB4RwRAIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCxAM3AiwgAUHAA2ogAkE8akHoov8AIAMoAgggBBCGASABKALIAyEEIAEoAsQDIQIgASgCwAMiBUGTgICAeEcEQCAAIAEpAswDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC9AIgASACNgLwAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUEsahD4LSABQSRqEPgtTQRAIAFBOGoiBiABKAIsIAEoAjAQ0yMgAUHAA2oiBSAGEKEbIAFBvARqIgYgAxDHBiABQdgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgLEBCABIAc2AsAEIAFBATYCvAQgAUH8AGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQSxqEPgtIAFBJGoiAxD4LWs2AjQgASADEPMtNgK8BCABQQM2AtwBIAFB6Kn/ADYC2AEgAUIDNwLkASABQZcMNgLUAyABQa8DNgLMAyABQTs2AsQDIAEgAUHAA2o2AuABIAEgAUEgajYC0AMgASABQbwEajYCyAMgASABQTRqNgLAAyAAQQRqIAFB2AFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB8AJqELsjDAsLIAFBwANqIgIgAUHYAWoQngggAhDrKSECQcCj/wAMBwsgAUHAA2oiAiABQdgBahCkCCACEOspIQJBmKT/AAwGCyABQcADaiICIAFB2AFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBwANqIgIgAUHYAWoQoAggAhDrKSECQcil/wAMBAsgAUHAA2oiAiABQdgBahCdCCACEOspIQJBoKb/AAwDCyABQcADaiICIAFB2AFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBwANqIgIgAUHYAWoQowggAhDrKSECQdCn/wAMAQsgAUHAA2oiAiABQdgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQogAUEkahC7IwwKCyABQQI2AsQDIAFBqKn/ADYCwAMgAUIBNwLMAyABQZcMNgLABCABIAFBvARqNgLIAyABIAFBIGo2ArwEIABBBGogAUHAA2oQqhggAEGCgICAeDYCACABQdgBahD/JgwCCwzAAwsgASgCLCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEsahC7IwsgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAUEkahC7IwwGCyABKALIAyICQeiu/wBBygD8CgAAIABBygA2AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAULIAIoAhAhCiABQcADaiIFIANBGGoQqD4QxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQAgASAENgK8BCABIAIpAhw3AsAEIAUgAUG8BGoiAhDZIBogAiADQQxqEL0tIAEoAtgEIgIgASgC3AQiC0YEQCABKALABCEEDAILIAFB+ANqIQwgAUGcBGohBiABKALABCEEA0ACQAJAIARFDQAgAiABKALQBE8NvQMgASgCxAQgAiABKALMBGoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYC2AQgBhDmOiABKAKcBEUNvgMgASgCrARBAWoiB0EDdiAHQQdxQQBHaiIFIAEoAqgEIgNLBEAgBSADayEJIAEoAqAEIg0gBUkEQCAGIA1BAXQiAyAFQcD///8DcUFAayAFIAVBP3EbIg0gAyANSxsQ6BkgASgCqAQhAwsgCQRAIAEoAqQEIANqQQAgCfwLAAsgASAFNgKoBAsgASAHNgKsBCABKAKABCIDIAEoAvgDRgRAIAxBoJ3/ABCxKAsgASgC/AMgA0EEdGoiBUIANwMIIAVCADcDACABIANBAWo2AoAEDAELIAEgAkEBajYC2AQgAUHAA2pBACAKIAEoArwEKAIQIAJqLQAAQQJ0aiIDKAIAIgUgA0EEaigCACAFaxCJEAwACyACQQFqIgIgC0cNAAsMAQsACwJAIARFDQAgBCAEKAIAIgJBAWs2AgAgAkEBRw0AIAFBwARqEPseCyABQdgBaiABQcADaiICENsMIAIQ6SUgAUH4AmoiAiABQeQBaikCADcDACABQYADaiIDIAFB7AFqKAIANgIAIAEgASkC3AE3A/ACIAEoAtgBIgRBgICAgHhGBEAgACABKQPwAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAMLIAFBtAJqIgMgAUHwAWpBJPwKAAAgAUHgAmoiBSABQfgCaikDADcDACABQegCaiIGIAFBgANqKAIANgIAIAEgASkD8AI3A9gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkD2AI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAMLDLsDCyABKALIAyICQbKv/wBBxAD8CgAAIABCxAA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAELAkAgBEUNACAEIAQoAgAiAkEBazYCACACQQFHDQAgAUHABGoQ+x4LIAFB2AFqIAFBwANqIgIQ3AwgAhDpJSABQfgCaiICIAFB5AFqKQIANwMAIAFBgANqIgMgAUHsAWooAgA2AgAgASABKQLcATcD8AIgASgC2AEiBEGAgICAeEYEQCAAIAEpA/ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUGEA2oiAyABQfABakEk/AoAACABQbADaiIFIAFB+AJqKQMANwMAIAFBuANqIgYgAUGAA2ooAgA2AgAgASABKQPwAjcDqAMQsD5BxABBBBCtNiICRQ25AyACIAQ2AgggAkKBgICAEDcCACACIAEpA6gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwyxAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQcADaiAFIAYQiCIiBUE8akHoov8AIAMgBBCGASABKALIAyEDIAEoAsQDIQIgASgCwAMiBEGTgICAeEcEQCAAIAEpAswDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA0LIAEgAzYC3AEgASACNgLYASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQZCi/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0MIAFB2AFqELsjDAwLIAFBCGogBSAGEIgiIgNBPGoQuSYgAUHAA2ogASgCCCICIAEoAgwoAgwRAAAgAgRAIAEpA8ADQpCes+7ZtI2S6QCFIAEpA8gDQoj0q4HgscXkwgCFhFANBAsgAUHAA2pBxgBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0CDMYDCyABQRBqIAUgBhCIIiIDQTxqELkmIAFBwANqIAEoAhAiAiABKAIUKAIMEQAAIAIEQCABKQPAA0LH2fTn3sS2nHeFIAEpA8gDQo2yzpSMypLmp3+FhFANBgsgAUHAA2pBxABBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0IDMUDCyABIANBBGoiBzYCICABQRhqIAUgBigCEBEAACABQcADaiABKAIYIgIgASgCHCgCDBEAACACBEAgASkDwANChrKY2Z2pt6ZuhSABKQPIA0Ldr7vZ27bP1maFhFANAwsgAUHAA2pBygBBAEEBQQEQoBggASgCxAMhAyABKALAA0EBRw0DDMQDCyABKALIAyICQfav/wBBxgD8CgAAIABCxgA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAgLIAIoAhAhCyABQcADaiIFIANBGGoQ2TwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQMgASAENgK8BCABIAIpAhw3AsAEIAUgAUG8BGoiAhDZIBogAiADQQxqEL8tIAEoAtgEIgIgASgC3AQiDEYEQCABKALABCEDDAcLIAJBAXQhBCABQfgDaiENIAFBnARqIQcgASgCwAQhAwNAAkACQCADRQ0AIAIgASgC0ARPDb8DIAEoAsQEIAIgASgCzARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2AtgEIAcQ5jogASgCnARFDcADIAEoAqwEQQFqIglBA3YgCUEHcUEAR2oiBiABKAKoBCIFSwRAIAYgBWshCiABKAKgBCIOIAZJBEAgByAOQQF0IgUgBkHA////A3FBQGsgBiAGQT9xGyIOIAUgDksbEOgZIAEoAqgEIQULIAoEQCABKAKkBCAFakEAIAr8CwALIAEgBjYCqAQLIAEgCTYCrAQgASgCgAQiBSABKAL4A0YEQCANQaCd/wAQsSgLIAEoAvwDIAVBBHRqIgZCADcDCCAGQgA3AwAgASAFQQFqNgKABAwBCyABIAJBAWo2AtgEIAFBwANqQQAgCyABKAK8BCgCECAEai8BAEECdGoiBSgCACIGIAVBBGooAgAgBmsQiRAMAAsgBEECaiEEIAJBAWoiAiAMRw0ACwwGCyABQcADaiIGIAJBDGoQpS4gAUHYAWoiCSAGEKoTELA+AkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiAJQTD8CgAAIAFBkKL/ADYCKCABIAU2AiQgBiABQSRqQeii/wAgBygCACIJIAQQhgEgASgCwAMiBUGTgICAeEcEQCABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIAAgBTYCAAwDCyABIAEpAsQDNwIsIAFBwANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCyAMhBCABKALEAyECIAEoAsADIgVBk4CAgHhHBEAgACABKQLMAzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AvQCIAEgAjYC8AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFBLGoQ+C0gAUEkahD4LU0EQCABQThqIgYgASgCLCABKAIwENMjIAFBwANqIgUgBhChGyABQbwEaiIGIAMQxwYgAUHYAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCxAQgASAHNgLABCABQQE2ArwEIAFB/ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUEsahD4LSABQSRqIgMQ+C1rNgI0IAEgAxDzLTYCvAQgAUEDNgLcASABQeip/wA2AtgBIAFCAzcC5AEgAUGXDDYC1AMgAUGvAzYCzAMgAUE7NgLEAyABIAFBwANqNgLgASABIAFBIGo2AtADIAEgAUG8BGo2AsgDIAEgAUE0ajYCwAMgAEEEaiABQdgBahCqGCAAQYaAgIB4NgIAIAIgAigCACIAQQFrNgIAIABBAUcNCyABQfACahC7IwwLCyABQcADaiICIAFB2AFqEJ4IIAIQ6ykhAkHAo/8ADAcLIAFBwANqIgIgAUHYAWoQpAggAhDrKSECQZik/wAMBgsgAUHAA2oiAiABQdgBahCiCCACEOspIQJB8KT/AAwFCyABQcADaiICIAFB2AFqEKAIIAIQ6ykhAkHIpf8ADAQLIAFBwANqIgIgAUHYAWoQnQggAhDrKSECQaCm/wAMAwsgAUHAA2oiAiABQdgBahCfCCACEOspIQJB+Kb/AAwCCyABQcADaiICIAFB2AFqEKMIIAIQ6ykhAkHQp/8ADAELIAFBwANqIgIgAUHYAWoQoQggAhDrKSECQaio/wALNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0KIAFBJGoQuyMMCgsgAUECNgLEAyABQaip/wA2AsADIAFCATcCzAMgAUGXDDYCwAQgASABQbwEajYCyAMgASABQSBqNgK8BCAAQQRqIAFBwANqEKoYIABBgoCAgHg2AgAgAUHYAWoQ/yYMAgsMvwMLIAEoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBLGoQuyMLIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAFBJGoQuyMMBgsgASgCyAMiAkHorv8AQcoA/AoAACAAQcoANgIMIAAgAjYCCCAAIAM2AgQgAEGGgICAeDYCAAwFCyACKAIQIQsgAUHAA2oiBSADQRhqENk8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCvAQgASACKQIcNwLABCAFIAFBvARqIgIQ2SAaIAIgA0EMahC/LSABKALYBCICIAEoAtwEIgxGBEAgASgCwAQhAwwCCyACQQF0IQQgAUH4A2ohDSABQZwEaiEHIAEoAsAEIQMDQAJAAkAgA0UNACACIAEoAtAETw28AyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASACQQFqNgLYBCAHEOY6IAEoApwERQ29AyABKAKsBEEBaiIJQQN2IAlBB3FBAEdqIgYgASgCqAQiBUsEQCAGIAVrIQogASgCoAQiDiAGSQRAIAcgDkEBdCIFIAZBwP///wNxQUBrIAYgBkE/cRsiDiAFIA5LGxDoGSABKAKoBCEFCyAKBEAgASgCpAQgBWpBACAK/AsACyABIAY2AqgECyABIAk2AqwEIAEoAoAEIgUgASgC+ANGBEAgDUGgnf8AELEoCyABKAL8AyAFQQR0aiIGQgA3AwggBkIANwMAIAEgBUEBajYCgAQMAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGovAQBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAALIARBAmohBCACQQFqIgIgDEcNAAsMAQsACwJAIANFDQAgAyADKAIAIgJBAWs2AgAgAkEBRw0AIAFBwARqEPseCyABQdgBaiABQcADaiICENsMIAIQ6SUgAUH4AmoiAiABQeQBaikCADcDACABQYADaiIDIAFB7AFqKAIANgIAIAEgASkC3AE3A/ACIAEoAtgBIgRBgICAgHhGBEAgACABKQPwAjcCACAAQRBqIAMoAgA2AgAgAEEIaiACKQMANwIADAMLIAFBtAJqIgMgAUHwAWpBJPwKAAAgAUHgAmoiBSABQfgCaikDADcDACABQegCaiIGIAFBgANqKAIANgIAIAEgASkD8AI3A9gCELA+QcQAQQQQrTYiAgRAIAIgBDYCCCACQoGAgIAQNwIAIAIgASkD2AI3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEG4of8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAMLDLoDCyABKALIAyICQbKv/wBBxAD8CgAAIABCxAA3AgwgACACNgIIIAAgAzYCBCAAQYaAgIB4NgIADAELAkAgA0UNACADIAMoAgAiAkEBazYCACACQQFHDQAgAUHABGoQ+x4LIAFB2AFqIAFBwANqIgIQ3AwgAhDpJSABQfgCaiICIAFB5AFqKQIANwMAIAFBgANqIgMgAUHsAWooAgA2AgAgASABKQLcATcD8AIgASgC2AEiBEGAgICAeEYEQCAAIAEpA/ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUGEA2oiAyABQfABakEk/AoAACABQbADaiIFIAFB+AJqKQMANwMAIAFBuANqIgYgAUGAA2ooAgA2AgAgASABKQPwAjcDqAMQsD5BxABBBBCtNiICRQ24AyACIAQ2AgggAkKBgICAEDcCACACIAEpA6gDNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABB4KD/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgBGokAAwACwywAwsjAEHgBGsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAiAkEXaw4EAgEBAwALIAJBIkYNAwsgAUHAA2ogBSAGEIoiIgVBPGpB6KL/ACADIAQQhgEgASgCyAMhAyABKALEAyECIAEoAsADIgRBk4CAgHhHBEAgACABKQLMAzcCDCAAIAM2AgggACACNgIEIAAgBDYCAAwPCyABIAM2AtwBIAEgAjYC2AEgACACIAMoAghBAWtBeHFqQQhqIAMgBUEMakGAqv8AEJMBIAIgAigCACIAQQFrNgIAIABBAUcNDiABQdgBahC7IwwOCyABQQhqIAUgBhCKIiIDQTxqELkmIAFBwANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQPAA0KQnrPu2bSNkukAhSABKQPIA0KI9KuB4LHF5MIAhYRQDQQLIAFBwANqQcYAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAgzHAwsgAUEQaiAFIAYQiiIiA0E8ahC5JiABQcADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDwANCx9n0597Etpx3hSABKQPIA0KNss6UjMqS5qd/hYRQDQULIAFBwANqQcQAQQBBAUEBEKAYIAEoAsQDIQMgASgCwANBAUcNAwzGAwsgASADQQRqIgc2AiAgAUEYaiAFIAYoAhARAAAgAUHAA2ogASgCGCICIAEoAhwoAgwRAAAgAgRAIAEpA8ADQvLI+sP06YyY8wCFIAEpA8gDQvC4kO3DhNv9ToWEUA0GCyABQcADakHKAEEAQQFBARCgGCABKALEAyEDIAEoAsADQQFHDQQMxQMLIAEoAsgDIgJB9q//AEHGAPwKAAAgAELGADcCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMCgsgAigCECELIAFBwANqIgUgA0EYahDbPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNBCABIAQ2ArwEIAEgAikCHDcCwAQgBSABQbwEaiICENkgGiACIANBDGoQwC0gASgC2AQiAiABKALcBCIMRgRAIAEoAsAEIQMMCQsgAkECdCEEIAFB+ANqIQ0gAUGcBGohByABKALABCEDA0ACQAJAIAMEQCACIAEoAtAETw3BAyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGooAgBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAELIAEgAkEBajYC2AQgBxDmOiABKAKcBEUNwAMgASgCrARBAWoiCUEDdiAJQQdxQQBHaiIGIAEoAqgEIgVLBEAgBiAFayEKIAEoAqAEIg4gBkkEQCAHIA5BAXQiBSAGQcD///8DcUFAayAGIAZBP3EbIg4gBSAOSxsQ6BkgASgCqAQhBQsgCgRAIAEoAqQEIAVqQQAgCvwLAAsgASAGNgKoBAsgASAJNgKsBCABKAKABCIFIAEoAvgDRgRAIA1BoJ3/ABCxKAsgASgC/AMgBUEEdGoiBkIANwMIIAZCADcDACABIAVBAWo2AoAECyAEQQRqIQQgAkEBaiICIAxHDQALDAgLIAEoAsgDIgJBsq//AEHEAPwKAAAgAELEADcCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMCAsgAigCECELIAFBwANqIgUgA0EYahDbPBDEGyACKAIYIgQgBCgCACIGQQFqNgIAIAZBAEgNAiABIAQ2ArwEIAEgAikCHDcCwAQgBSABQbwEaiICENkgGiACIANBDGoQwC0gASgC2AQiAiABKALcBCIMRgRAIAEoAsAEIQMMBgsgAkECdCEEIAFB+ANqIQ0gAUGcBGohByABKALABCEDA0ACQAJAIAMEQCACIAEoAtAETw2/AyABKALEBCACIAEoAswEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgLYBCABQcADakEAIAsgASgCvAQoAhAgBGooAgBBAnRqIgUoAgAiBiAFQQRqKAIAIAZrEIkQDAELIAEgAkEBajYC2AQgBxDmOiABKAKcBEUNvgMgASgCrARBAWoiCUEDdiAJQQdxQQBHaiIGIAEoAqgEIgVLBEAgBiAFayEKIAEoAqAEIg4gBkkEQCAHIA5BAXQiBSAGQcD///8DcUFAayAGIAZBP3EbIg4gBSAOSxsQ6BkgASgCqAQhBQsgCgRAIAEoAqQEIAVqQQAgCvwLAAsgASAGNgKoBAsgASAJNgKsBCABKAKABCIFIAEoAvgDRgRAIA1BoJ3/ABCxKAsgASgC/AMgBUEEdGoiBkIANwMIIAZCADcDACABIAVBAWo2AoAECyAEQQRqIQQgAkEBaiICIAxHDQALDAULIAEoAsgDIgJB6K7/AEHKAPwKAAAgAEHKADYCDCAAIAI2AgggACADNgIEIABBhoCAgHg2AgAMBgsgAUHAA2oiBiACQQxqEKkuIAFB2AFqIgkgBhC5ExCwPkE4QQQQrTYiBUUNuwMgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUGAqv8ANgIoIAEgBTYCJCAGIAFBJGpB6KL/ACAHKAIAIgkgBBCGASABKALAAyIFQZOAgIB4RwRAIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCxAM3AiwgAUHAA2ogAkE8akHoov8AIAMoAgggBBCGASABKALIAyEEIAEoAsQDIQIgASgCwAMiBUGTgICAeEcEQCAAIAEpAswDNwIMIAAgBDYCCCAAIAI2AgQgACAFNgIADAILIAEgBDYC9AIgASACNgLwAgJAIAACfwJAAkACQAJAAkACQAJAAkAgAUEsahD4LSABQSRqEPgtTQRAIAFBOGoiBiABKAIsIAEoAjAQ0yMgAUHAA2oiBSAGEKEbIAFBvARqIgYgAxDHBiABQdgBaiIDIAUgBhCMGBCoLyEHIAUgAiAEENMjIAcgBUHEAPwKAAAgAUEBNgLEBCABIAc2AsAEIAFBATYCvAQgAUH8AGoiAiADIAYQ/CIgAyACEM0cIAktAABBAmsOCAECAwQFBgcICgsgASABQSxqEPgtIAFBJGoiAxD4LWs2AjQgASADEPMtNgK8BCABQQM2AtwBIAFB6Kn/ADYC2AEgAUIDNwLkASABQZcMNgLUAyABQa8DNgLMAyABQTs2AsQDIAEgAUHAA2o2AuABIAEgAUEgajYC0AMgASABQbwEajYCyAMgASABQTRqNgLAAyAAQQRqIAFB2AFqEKoYIABBhoCAgHg2AgAgAiACKAIAIgBBAWs2AgAgAEEBRw0LIAFB8AJqELsjDAsLIAFBwANqIgIgAUHYAWoQngggAhDrKSECQcCj/wAMBwsgAUHAA2oiAiABQdgBahCkCCACEOspIQJBmKT/AAwGCyABQcADaiICIAFB2AFqEKIIIAIQ6ykhAkHwpP8ADAULIAFBwANqIgIgAUHYAWoQoAggAhDrKSECQcil/wAMBAsgAUHAA2oiAiABQdgBahCdCCACEOspIQJBoKb/AAwDCyABQcADaiICIAFB2AFqEJ8IIAIQ6ykhAkH4pv8ADAILIAFBwANqIgIgAUHYAWoQowggAhDrKSECQdCn/wAMAQsgAUHAA2oiAiABQdgBahChCCACEOspIQJBqKj/AAs2AgggACACNgIEIABBk4CAgHg2AgAgASgCJCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAUEkahC7IwwGCyABQQI2AsQDIAFBqKn/ADYCwAMgAUIBNwLMAyABQZcMNgLABCABIAFBvARqNgLIAyABIAFBIGo2ArwEIABBBGogAUHAA2oQqhggAEGCgICAeDYCACABQdgBahD/JgwCCwALIAEoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBLGoQuyMLIAEoAiQiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBJGoQuyMMAgsCQCADRQ0AIAMgAygCACICQQFrNgIAIAJBAUcNACABQcAEahD7HgsgAUHYAWogAUHAA2oiAhDbDCACEOklIAFB+AJqIgIgAUHkAWopAgA3AwAgAUGAA2oiAyABQewBaigCADYCACABIAEpAtwBNwPwAiABKALYASIEQYCAgIB4RgRAIAAgASkD8AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwCCyABQbQCaiIDIAFB8AFqQST8CgAAIAFB4AJqIgUgAUH4AmopAwA3AwAgAUHoAmoiBiABQYADaigCADYCACABIAEpA/ACNwPYAhCwPkHEAEEEEK02IgIEQCACIAQ2AgggAkKBgICAEDcCACACIAEpA9gCNwIMIAJBFGogBSkDADcCACACQRxqIAYoAgA2AgAgAkEgaiADQST8CgAAIABBuKH/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwCCwy4AwsCQCADRQ0AIAMgAygCACICQQFrNgIAIAJBAUcNACABQcAEahD7HgsgAUHYAWogAUHAA2oiAhDcDCACEOklIAFB+AJqIgIgAUHkAWopAgA3AwAgAUGAA2oiAyABQewBaigCADYCACABIAEpAtwBNwPwAiABKALYASIEQYCAgIB4RgRAIAAgASkD8AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQYQDaiIDIAFB8AFqQST8CgAAIAFBsANqIgUgAUH4AmopAwA3AwAgAUG4A2oiBiABQYADaigCADYCACABIAEpA/ACNwOoAxCwPkHEAEEEEK02IgJFDbcDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDqAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDK8DCyMAQeAEayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AACICQRdrDgQCAQEDAAsgAkEiRg0DCyABQbADaiAFIAYQhiIiBUE8akHoov8AIAMgBBCGASABKAK4AyEDIAEoArQDIQIgASgCsAMiBEGTgICAeEcEQCAAIAEpArwDNwIMIAAgAzYCCCAAIAI2AgQgACAENgIADA8LIAEgAzYCzAEgASACNgLIASAAIAIgAygCCEEBa0F4cWpBCGogAyAFQQxqQbCr/wAQkwEgAiACKAIAIgBBAWs2AgAgAEEBRw0OIAFByAFqELsjDA4LIAEgBSAGEIYiIgNBPGoQuSYgAUGwA2ogASgCACICIAEoAgQoAgwRAAAgAgRAIAEpA7ADQpCes+7ZtI2S6QCFIAEpA7gDQoj0q4HgscXkwgCFhFANBAsgAUGwA2pBxgBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0CDMQDCyABQQhqIAUgBhCGIiIDQTxqELkmIAFBsANqIAEoAggiAiABKAIMKAIMEQAAIAIEQCABKQOwA0LH2fTn3sS2nHeFIAEpA7gDQo2yzpSMypLmp3+FhFANBgsgAUGwA2pBxABBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0JDMMDCyABIANBBGoiBzYCGCABQRBqIAUgBigCEBEAACABQbADaiABKAIQIgIgASgCFCgCDBEAACACBEAgASkDsANCpJvx8abpgqoQhSABKQO4A0LNu9rE68fEghiFhFANAwsgAUGwA2pBygBBAEEBQQEQoBggASgCtAMhAiABKAKwA0EBRw0DDMIDCyABKAK4AyIDQfav/wBBxgD8CgAAIABCxgA3AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAoLIAIoAhAhByABQbADaiIFIANBGGoQ2DwQxBsgAigCGCIEIAQoAgAiBkEBajYCACAGQQBIDQMgASAENgKwBCABIAIpAhw3ArQEIAUgAUGwBGoiAhDZIBogAiADQQxqEL4tIAEoAswEIgIgASgC0ARGDQcgAUHoA2ohCSABQYwEaiEEIAFBtARqIQoDQAJAAkACQAJAIAEoArQEBEAgAiABKALEBE8NwgMgASgCuAQgASgCwAQgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCzAQgASgCsAQoAhAgAkEDdGopAwAiG0KAgICAEFQNAiABQdQEakEYQQBBAUEBEKAYIAEoAtgEIQIgASgC1ARBAUcNAQzGAwsgASACQQFqNgLMBCAEEOY6IAEoAowERQ3BAyABKAKcBEEBaiIFQQN2IAVBB3FBAEdqIgMgASgCmAQiAksEQCADIAJrIQYgASgCkAQiCyADSQRAIAQgC0EBdCICIANBwP///wNxQUBrIAMgA0E/cRsiCyACIAtLGxDoGSABKAKYBCECCyAGBEAgASgClAQgAmpBACAG/AsACyABIAM2ApgECyABIAU2ApwEIAEoAvADIgIgASgC6ANGBEAgCUGgnf8AELEoCyABKALsAyACQQR0aiIDQgA3AwggA0IANwMAIAEgAkEBajYC8AMMAgsgASgC3AQiA0EQakHMsP8AKQAANwAAIANBCGpBxLD/ACkAADcAACADQbyw/wApAAA3AAAgAUEYNgLYASABIAM2AtQBIAEgAjYC0AEgAUKAgICA6ICAgIB/NwLIASABKAK0BCICRQ0LIAIgAigCACICQQFrNgIAIAJBAUcNCyAKEPseDAsLIAFBsANqQQAgByAbp0ECdGoiAigCACIDIAJBBGooAgAgA2sQiRALIAEoAswEIgIgASgC0ARHDQALDAcLIAFBsANqIgYgAkEMahCoLiABQcgBaiIJIAYQrhMQsD4CQAJAQThBBBCtNiIFBEAgBUKBgICAEDcCACAFQQhqIAlBMPwKAAAgAUGwq/8ANgIgIAEgBTYCHCAGIAFBHGpB6KL/ACAHKAIAIgkgBBCGASABKAKwAyIFQZOAgIB4RwRAIAEpArQDIRsgACABKQK8AzcCDCAAIBs3AgQgACAFNgIADAMLIAEgASkCtAM3AtQEIAFBsANqIAJBPGpB6KL/ACADKAIIIAQQhgEgASgCuAMhBCABKAK0AyECIAEoArADIgVBk4CAgHhHBEAgACABKQK8AzcCDCAAIAQ2AgggACACNgIEIAAgBTYCAAwCCyABIAQ2AuQCIAEgAjYC4AICQCAAAn8CQAJAAkACQAJAAkACQAJAIAFB1ARqEPgtIAFBHGoQ+C1NBEAgAUEoaiIGIAEoAtQEIAEoAtgEENMjIAFBsANqIgUgBhChGyABQbAEaiIGIAMQxwYgAUHIAWoiAyAFIAYQjBgQqC8hByAFIAIgBBDTIyAHIAVBxAD8CgAAIAFBATYCuAQgASAHNgK0BCABQQE2ArAEIAFB7ABqIgIgAyAGEPwiIAMgAhDNHCAJLQAAQQJrDggBAgMEBQYHCAoLIAEgAUHUBGoQ+C0gAUEcaiIDEPgtazYCJCABIAMQ8y02ArAEIAFBAzYCzAEgAUHoqf8ANgLIASABQgM3AtQBIAFBlww2AsQDIAFBrwM2ArwDIAFBOzYCtAMgASABQbADajYC0AEgASABQRhqNgLAAyABIAFBsARqNgK4AyABIAFBJGo2ArADIABBBGogAUHIAWoQqhggAEGGgICAeDYCACACIAIoAgAiAEEBazYCACAAQQFHDQsgAUHgAmoQuyMMCwsgAUGwA2oiAiABQcgBahCeCCACEOspIQJBwKP/AAwHCyABQbADaiICIAFByAFqEKQIIAIQ6ykhAkGYpP8ADAYLIAFBsANqIgIgAUHIAWoQogggAhDrKSECQfCk/wAMBQsgAUGwA2oiAiABQcgBahCgCCACEOspIQJByKX/AAwECyABQbADaiICIAFByAFqEJ0IIAIQ6ykhAkGgpv8ADAMLIAFBsANqIgIgAUHIAWoQnwggAhDrKSECQfim/wAMAgsgAUGwA2oiAiABQcgBahCjCCACEOspIQJB0Kf/AAwBCyABQbADaiICIAFByAFqEKEIIAIQ6ykhAkGoqP8ACzYCCCAAIAI2AgQgAEGTgICAeDYCACABKAIcIgAgACgCACIAQQFrNgIAIABBAUcNDCABQRxqELsjDAwLIAFBAjYCtAMgAUGoqf8ANgKwAyABQgE3ArwDIAFBlww2ArQEIAEgAUGwBGo2ArgDIAEgAUEYajYCsAQgAEEEaiABQbADahCqGCAAQYKAgIB4NgIAIAFByAFqEP8mDAILDL8DCyABKALUBCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHUBGoQuyMLIAEoAhwiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgASgCuAMiA0Horv8AQcoA/AoAACAAQcoANgIMIAAgAzYCCCAAIAI2AgQgAEGGgICAeDYCAAwHCyACKAIQIQcgAUGwA2oiBSADQRhqENg8EMQbIAIoAhgiBCAEKAIAIgZBAWo2AgAgBkEASA0AIAEgBDYCsAQgASACKQIcNwK0BCAFIAFBsARqIgIQ2SAaIAIgA0EMahC+LSABKALMBCICIAEoAtAERg0BIAFB6ANqIQkgAUGMBGohBCABQbQEaiEKA0ACQAJAAkACQCABKAK0BARAIAIgASgCxARPDb8DIAEoArgEIAEoAsAEIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AswEIAEoArAEKAIQIAJBA3RqKQMAIhtCgICAgBBUDQIgAUHUBGpBGEEAQQFBARCgGCABKALYBCECIAEoAtQEQQFHDQEMwwMLIAEgAkEBajYCzAQgBBDmOiABKAKMBEUNvgMgASgCnARBAWoiBUEDdiAFQQdxQQBHaiIDIAEoApgEIgJLBEAgAyACayEGIAEoApAEIgsgA0kEQCAEIAtBAXQiAiADQcD///8DcUFAayADIANBP3EbIgsgAiALSxsQ6BkgASgCmAQhAgsgBgRAIAEoApQEIAJqQQAgBvwLAAsgASADNgKYBAsgASAFNgKcBCABKALwAyICIAEoAugDRgRAIAlBoJ3/ABCxKAsgASgC7AMgAkEEdGoiA0IANwMIIANCADcDACABIAJBAWo2AvADDAILIAEoAtwEIgNBEGpBzLD/ACkAADcAACADQQhqQcSw/wApAAA3AAAgA0G8sP8AKQAANwAAIAFBGDYC2AEgASADNgLUASABIAI2AtABIAFCgICAgOiAgICAfzcCyAEgASgCtAQiAkUNBSACIAIoAgAiAkEBazYCACACQQFHDQUgChD7HgwFCyABQbADakEAIAcgG6dBAnRqIgIoAgAiAyACQQRqKAIAIANrEIkQCyABKALMBCICIAEoAtAERw0ACwwBCwALAkAgASgCtAQiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUG0BGoQ+x4LIAFByAFqIAFBsANqENsMCyABQbADahDpJSABQegCaiICIAFB1AFqKQIANwMAIAFB8AJqIgMgAUHcAWooAgA2AgAgASABKQLMATcD4AIgASgCyAEiBEGAgICAeEYEQCAAIAEpA+ACNwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMBAsgAUGkAmoiAyABQeABakEk/AoAACABQdACaiIFIAFB6AJqKQMANwMAIAFB2AJqIgYgAUHwAmooAgA2AgAgASABKQPgAjcDyAIQsD5BxABBBBCtNiICBEAgAiAENgIIIAJCgYCAgBA3AgAgAiABKQPIAjcCDCACQRRqIAUpAwA3AgAgAkEcaiAGKAIANgIAIAJBIGogA0Ek/AoAACAAQbih/wA2AgggACACNgIEIABBk4CAgHg2AgAMBAsMuQMLIAEoArgDIgNBsq//AEHEAPwKAAAgAELEADcCDCAAIAM2AgggACACNgIEIABBhoCAgHg2AgAMAgsCQCABKAK0BCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQbQEahD7HgsgAUHIAWogAUGwA2oQ3AwLIAFBsANqEOklIAFB6AJqIgIgAUHUAWopAgA3AwAgAUHwAmoiAyABQdwBaigCADYCACABIAEpAswBNwPgAiABKALIASIEQYCAgIB4RgRAIAAgASkD4AI3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfQCaiIDIAFB4AFqQST8CgAAIAFBoANqIgUgAUHoAmopAwA3AwAgAUGoA2oiBiABQfACaigCADYCACABIAEpA+ACNwOYAxCwPkHEAEEEEK02IgJFDbYDIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDmAM3AgwgAkEUaiAFKQMANwIAIAJBHGogBigCADYCACACQSBqIANBJPwKAAAgAEHgoP8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeAEaiQADAALDK4DCyAMQRtrDgQVExYVEwsgCCAKNgJMIAggAzYCSCAMQRtrDgQDExYEEwsgDEEbaw4EBBsWBRsLIAggCjYCTCAIIAM2AkggDEEbaw4EBRwWBhwLIAggCjYCTCAIIAM2AkggCy0AAEECaw4IBwgJCgsMDQ4GCyMAQeAAayIDJAAgA0EEaiABIAIQkCIiAUEMakHs54ABIAcoAgAiAkEwaiAEEIYBIAMoAgwhBCADKAIIIQUCQAJAAkAgAygCBCIGQZOAgIB4RwRAIAAgAykCEDcCDCAAIAQ2AgggACAFNgIEIAAgBjYCAAwBCyACIAIoAgAiBkEBajYCACAGQQBIDQEgASgCFCIGIAYoAgAiB0EBajYCACAHQQBIDQEgAyAGNgI8IAMgASkCGDcCQCADQcgAaiIGIAEQmTYQ7iUgA0EEaiIHIAIgA0E8aiAFIAQgBhCcHhCwPkHAAEEEEK02IgFFDbUDIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HgAGokAAwBCwALDKgDCyMAQYABayIDJAAgAyABIAIQkSIiARCZNhDuJQJAAkACQAJAAkACQCABQQxqIgIQ9C1BAEgEQCADQTBqQSNBAEEBQQEQoBggAygCNCEBIAMoAjBBAUYNBCADKAI4IgJBqOmAAUEj/AoAACAAQSM2AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADAELIANBMGogAkHs54ABIAcoAgAiAkEwaiAEEIYBIAMoAjghBCADKAI0IQUgAygCMCIGQZOAgIB4Rg0BIAAgAykCPDcCDCAAIAQ2AgggACAFNgIEIAAgBjYCAAsgAygCACIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASADEPseDAELIANBGGoiBiABKAIYIgcgByABKAIcQXhxahC4GyADQSRqIgEgBhDoGCACIAIoAgAiBkEBajYCACAGQQBIDQIgA0H4AGogA0EQaikCADcDACADQfAAaiADQQhqKQIANwMAIAMgAykCADcDaCADQTBqIgYgAiABIAUgBCADQegAahCcHhCwPkHAAEEEEK02IgFFDbUDIAFCgYCAgBA3AgAgAUEIaiAGQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAWokAAwCCyABIAMoAjhB1OWAARD9LwsACwynAwsgBSAGEJAiIQkgA0EIaiEOQQAhB0EAIQwjAEGwBWsiBiQAIAYgCzYCHCAJEMA6IQMCQAJAAkACfwJAIAQtADQiD0EBRg0AIAkQwToNACAGQQA2AiBBAAwBC0HAACEBIAkQwDoiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDbcDIAIEQBCwPiACQcAAEK02IgFFDbcDCyAGQgA3AqQDIAYgATYCoAMgBiACNgKcAyAGQcAANgKYAwJAIAkQmTYiAQRAIAZBmANqIAEQlS8MAQsgBkGYA2ogCRDAOhCrEQsgBkEwaiAGQagDaigCADYCACAGQShqIAZBoANqKQIANwMAIAYgBikCmAM3AyBBAQshAiAGQTRqIgUgCUEMaiIQEMMtELA+AkBBBEEEEK02IgEEQCAGQQE2AqADIAYgATYCnAMgBkEBNgKYAyABIAU2AgAgBkH4AGogBkGYA2ogAiADIAtsIgoQwCxBACECAkACQCAJKAIcIgFBCE8EQCABQQJ2IQ0gCSgCGCIBKAIEIAEoAgByRSEMA0AgBiAHNgLEAiAGIAFBBGoiAygCACIFIAEoAgAiAWsiFDYCyAICQCALIBRGDQACQAJAAkAgD0UEQCAJIAcQkiVFDQELIAEgAkcEQCAGQfgAakEAIAIgARDYGwsgBkH4AGogCxCHFyAGKAIgRQ0BIAZBEGogBkEgahCGPSAHQQN2IgEgBigCFCICTw0CIAYoAhAgAWoiASABLQAAQX4gB0EHcXdxOgAAIAUhAgwDCyAGQQM2AtgCIAZBgOmAATYC1AIgBkIDNwLgAiAGQTs2AqwDIAZBOzYCpAMgBkGcAzYCnAMgBiAGQZgDajYC3AIgBiAGQcgCajYCqAMgBiAGQcQCajYCoAMgBiAGQRxqNgKYAyAAQQRqIAZB1AJqEJkOIABBgoCAgHg2AgAMBQtBmOmAARCyOwALIAEgAkGQ44ABEMMhAAsgB0EBaiEHIAMhASANQQFrIg1BAk8NAAsLIAYCfyAMIAJBAEdyIgMEQCAKIAYoAtABIgFHBEAgBkH4AGpBACACIAIgCmogAWsQ2BsLIAZBmANqIgEgBkH4AGpBzAH8CgAAIAZB1AJqIgIgARDqLCAGIAIQoAEgBigCBCEHIAYoAgAMAQsgBkEIaiAQQQAgChDLJSAGKAIMIQcgBigCCAsiATYCzAIgBiAHNgLQAiAGQZgDaiABIAcoAghBAWtBeHFqQQhqIAcgDigCACIBQTBqIAQQhgEgBigCoAMhAiAGKAKcAyEEIAYoApgDIgVBk4CAgHhHBEAgACAGKQKkAzcCDCAAIAI2AgggACAENgIEIAAgBTYCACAGKALMAiIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkHMAmoQuyMLIANFDQEMBgsCQCAGKAIgIgUEQCAGQeACaiAGQSxqKQIANwIAIAYgBTYC1AIgBiAGKQIkNwLYAiAGQZgDaiIFIAZB1AJqIgcQgxQgBkHkBGogBRDhJyAHEM8vDAELIAZBADYC5AQLIAEgASgCACIFQQFqNgIAIAVBAEgNAyAGQfwEaiIFIAEgBigCHCAEIAIgBkHkBGoQsxwQsD5BPEEEEK02IgFFDbgDIAFCgYCAgBA3AgAgAUEIaiAFQTT8CgAAIABBlOeAATYCCCAAIAE2AgQgAEGTgICAeDYCACAGKALMAiIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkHMAmoQuyMLIANFDQEMBAsgBkH4AGoQ7hcMBAsgBkH4AGoQ7hcMAgtBBEEEEKM9CwALIAZBNGoQgScMAQsgBkE0ahCBJyAGKAIgRQ0AIAZBIGoQzy8LIAZBsAVqJAAMpgMLIAUgBhCRIiEJIANBCGohDkEAIQdBACEMIwBBsAVrIgYkACAGIAs2AhwgCRC/OiEDAkACQAJAAn8CQCAELQA0Ig9BAUYNACAJEME6DQAgBkEANgIgQQAMAQtBwAAhASAJEL86IgJBA3YgAkEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ22AyACBEAQsD4gAkHAABCtNiIBRQ22AwsgBkIANwKkAyAGIAE2AqADIAYgAjYCnAMgBkHAADYCmAMCQCAJEJk2IgEEQCAGQZgDaiABEJUvDAELIAZBmANqIAkQvzoQqxELIAZBMGogBkGoA2ooAgA2AgAgBkEoaiAGQaADaikCADcDACAGIAYpApgDNwMgQQELIQIgBkE0aiIFIAlBDGoiEBDDLRCwPgJAQQRBBBCtNiIBBEAgBkEBNgKgAyAGIAE2ApwDIAZBATYCmAMgASAFNgIAIAZB+ABqIAZBmANqIAIgAyALbCIKEMAsQQAhAgJAAkAgCSgCHCIBQRBPBEAgAUEDdiENIAkoAhgiASkDCCABKQMAhKdFIQwDQCAGIAc2AsQCIAYgAUEIaiIDKAIAIgUgASgCACIBayIUNgLIAgJAIAsgFEYNAAJAAkACQCAPRQRAIAkgBxCSJUUNAQsgASACRwRAIAZB+ABqQQAgAiABENgbCyAGQfgAaiALEIcXIAYoAiBFDQEgBkEQaiAGQSBqEIY9IAdBA3YiASAGKAIUIgJPDQIgBigCECABaiIBIAEtAABBfiAHQQdxd3E6AAAgBSECDAMLIAZBAzYC2AIgBkGA6YABNgLUAiAGQgM3AuACIAZBOzYCrAMgBkE7NgKkAyAGQZwDNgKcAyAGIAZBmANqNgLcAiAGIAZByAJqNgKoAyAGIAZBxAJqNgKgAyAGIAZBHGo2ApgDIABBBGogBkHUAmoQmQ4gAEGCgICAeDYCAAwFC0GY6YABELI7AAsgASACQZDjgAEQwyEACyAHQQFqIQcgAyEBIA1BAWsiDUECTw0ACwsgBgJ/IAwgAkEAR3IiAwRAIAogBigC0AEiAUcEQCAGQfgAakEAIAIgAiAKaiABaxDYGwsgBkGYA2oiASAGQfgAakHMAfwKAAAgBkHUAmoiAiABEOosIAYgAhCgASAGKAIEIQcgBigCAAwBCyAGQQhqIBBBACAKEMslIAYoAgwhByAGKAIICyIBNgLMAiAGIAc2AtACIAZBmANqIAEgBygCCEEBa0F4cWpBCGogByAOKAIAIgFBMGogBBCGASAGKAKgAyECIAYoApwDIQQgBigCmAMiBUGTgICAeEcEQCAAIAYpAqQDNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIAIAYoAswCIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQcwCahC7IwsgA0UNAQwGCwJAIAYoAiAiBQRAIAZB4AJqIAZBLGopAgA3AgAgBiAFNgLUAiAGIAYpAiQ3AtgCIAZBmANqIgUgBkHUAmoiBxCDFCAGQeQEaiAFEOEnIAcQzy8MAQsgBkEANgLkBAsgASABKAIAIgVBAWo2AgAgBUEASA0DIAZB/ARqIgUgASAGKAIcIAQgAiAGQeQEahCzHBCwPkE8QQQQrTYiAUUNtwMgAUKBgICAEDcCACABQQhqIAVBNPwKAAAgAEGU54ABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAYoAswCIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQcwCahC7IwsgA0UNAQwECyAGQfgAahDuFwwECyAGQfgAahDuFwwCC0EEQQQQoz0LAAsgBkE0ahCBJwwBCyAGQTRqEIEnIAYoAiBFDQAgBkEgahDPLwsgBkGwBWokAAylAwsjAEGAAWsiAyQAIAMgASACEJAiIgEQmTYQ7iUgA0EwaiABQQxqQezngAEgBygCACICQTBqIAQQhgEgAygCOCEEIAMoAjQhBQJAAkACQCADKAIwIgZBk4CAgHhHBEAgACADKQI8NwIMIAAgBDYCCCAAIAU2AgQgACAGNgIAIAMoAgAiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAxD7HgwBCyADQRhqIgYgASgCGCIHIAcgASgCHEF8cWoQuRsgA0EkaiIBIAYQvRggAiACKAIAIgZBAWo2AgAgBkEASA0BIANB+ABqIANBEGopAgA3AwAgA0HwAGogA0EIaikCADcDACADIAMpAgA3A2ggA0EwaiIGIAIgASAFIAQgA0HoAGoQnR4QsD5BwABBBBCtNiIBRQ2xAyABQoGAgIAQNwIAIAFBCGogBkE4/AoAACAAQeTlgAE2AgggACABNgIEIABBk4CAgHg2AgALIANBgAFqJAAMAQsACwykAwsjAEHgAGsiAyQAIANBBGogASACEJEiIgFBDGpB7OeAASAHKAIAIgJBMGogBBCGASADKAIMIQQgAygCCCEFAkACQAJAIAMoAgQiBkGTgICAeEcEQCAAIAMpAhA3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgAiACKAIAIgZBAWo2AgAgBkEASA0BIAEoAhQiBiAGKAIAIgdBAWo2AgAgB0EASA0BIAMgBjYCPCADIAEpAhg3AkAgA0HIAGoiBiABEJk2EO4lIANBBGoiByACIANBPGogBSAEIAYQnR4QsD5BwABBBBCtNiIBRQ2wAyABQoGAgIAQNwIAIAFBCGogB0E4/AoAACAAQeTlgAE2AgggACABNgIEIABBk4CAgHg2AgALIANB4ABqJAAMAQsACwyjAwsgCEEDNgJUIAhBrNz/ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAyiAwsgACABIAIgAygCCCAEEIIBDKEDCyAAIAEgAiADKAIIIAQQfwygAwsgACABIAIgAygCCCAEEIABDJ8DCyAAIAEgAiADKAIIIAQQgwEMngMLIAAgASACIAMoAgggBBCBAQydAwsgACABIAIgAygCCCAEEH4MnAMLIAAgASACIAMoAgggBBCFAQybAwsgACABIAIgAygCCCAEEIQBDJoDCyAPRQ0KIAYhAiAFIQELIwBB8ABrIgMkACADQdgAaiABIAIgBygCACIBQTBqIAQQhgEgAygCYCECIAMoAlwhBAJAAkACQCADKAJYIgVBk4CAgHhHBEAgACADKQJkNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIADAELIAMgAjYCECADIAQ2AgwgA0EUaiIFIANBDGoQ9C1BARCCESABIAEoAgAiBkEBajYCACAGQQBIDQEgA0EANgJYIANBIGoiBiABIAUgBCACIANB2ABqEJweELA+QcAAQQQQrTYiAUUNpQMgAUKBgICAEDcCACABQQhqIAZBOPwKAAAgAEG85oABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQfAAaiQADAELAAsMmAMLIAggCTYCTCAIIAM2AkggDUEYaw4CBQYECyANQRtHDQogCCAJNgJMIAggAzYCSCAJIQogBiECIAUhAQsgC0EwaiAKKAIIQTBqELsIBEAgACABIAIQ9BAMlgMLIAsgCygCACIDQQFqNgIAIANBAEgNlgMgCEEdOgCQAiAIKAJMKAIEIQMgCCALNgKYAiAIIAM2ApQCIAhB0ABqIAEgAiAIQZACaiIDIAQQhgEgCCgCWCECIAgoAlQhASAIKAJQIgRBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAMQpwwMlgMLIAggAjYCxAMgCCABNgLAAyAAIAEgAigCCEEBa0F4cWpBCGogAhD0ECABIAEoAgAiAEEBazYCACAAQQFGBEAgCEHAA2oQuyMLIAhBkAJqEKcMDJUDCyAIIAM2AkggCCAJNgJMIAkoAgQgC0YNkwMgCEHQAGohAiMAQRBrIgEkACABQQRqQcIAQQBBAUEBEKAYIAEoAgghAwJAIAEoAgRBAUcEQCABKAIMIgRBhN7/AEHCAPwKAAAgAkHCADYCCCACIAQ2AgQgAiADNgIAIAFBEGokAAwBCwyjAwsgAEGCgICAeDYCACAAIAgpAlA3AgQgAEEMaiAIQdgAaigCADYCAAyUAwsgC0EwaiAKKAIIQTBqELsIDZEDIAsgCygCACIDQQFqNgIAIANBAEgNlAMgCEEdOgCQAiAIKAJMKAIEIQMgCCALNgKYAiAIIAM2ApQCIAhB0ABqIAEgAiAIQZACaiIDIAQQhgEgCCgCWCECIAgoAlQhASAIKAJQIgRBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAMQpwwMlAMLIAggAjYCxAMgCCABNgLAAyAAIAEgAigCCEEBa0F4cWpBCGogAhDzECABIAEoAgAiAEEBazYCACAAQQFGBEAgCEHAA2oQuyMLIAhBkAJqEKcMDJMDCyAIQdAAaiECIwBBEGsiASQAIAFBBGpBJ0EAQQFBARCgGCABKAIIIQMCQCABKAIEQQFHBEAgASgCDCIEQcbe/wBBJ/wKAAAgAkEnNgIIIAIgBDYCBCACIAM2AgAgAUEQaiQADAELDKEDCyAAQYKAgIB4NgIAIAAgCCkCUDcCBCAAQQxqIAhB2ABqKAIANgIADJIDCyAAIAUgBiAEEJEJDJEDCyAAIAUgBiAEEJIJDJADCyALQQFGDQILIAxBHUYNAiAMQSNrDgUEBQYHCAMLIwBB8ABrIgMkACADQdgAaiABIAIgBygCACIBQTBqIAQQhgEgAygCYCECIAMoAlwhBAJAAkACQCADKAJYIgVBk4CAgHhHBEAgACADKQJkNwIMIAAgAjYCCCAAIAQ2AgQgACAFNgIADAELIAMgAjYCECADIAQ2AgwgA0EUaiIFIANBDGoQ9C1BARCKESABIAEoAgAiBkEBajYCACAGQQBIDQEgA0EANgJYIANBIGoiBiABIAUgBCACIANB2ABqEJ0eELA+QcAAQQQQrTYiAUUNmgMgAUKBgICAEDcCACABQQhqIAZBOPwKAAAgAEHk5YABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQfAAaiQADAELAAsMjQMLIwBB0ABrIgEkACABQThqIAUgBiADQQhqKAIAIgJBMGogBBCGASABKAJAIQMgASgCPCEEAkACQAJAIAEoAjgiBUGTgICAeEcEQCAAIAEpAkQ3AgwgACADNgIIIAAgBDYCBCAAIAU2AgAMAQsgAiACKAIAIgVBAWo2AgAgBUEASA0BIAFBADYCOCABQQRqIgUgAkEBIAQgAyABQThqELMcELA+QTxBBBCtNiICRQ2aAyACQoGAgIAQNwIAIAJBCGogBUE0/AoAACAAQZTngAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB0ABqJAAMAQsACwyMAwsgCSgCBEEBRg0GCyAIIAk2AkwgCCADNgJIDB0LIAggCTYCTCAIIAM2AkggDUEjaw4EBwgJCgsLIAggCTYCTCAIIAM2AkggDUEjaw4ECwwNDg8LIAggCTYCTCAIIAM2AkggDUEjaw4EDxAREhMLIAggCTYCTCAIIAM2AkggDUEjaw4EExQVFhcLIAggCTYCTCAIIAM2AkhBACEBQSchAiANQQFrDicl/AL8AvwC/AL8AvwC/AL8AvwC/AL8AvAC/AL8AvwC/ALwAvAC8ALwAvAC8ALnAukC6wLwAvAC8ALwAvACJPAC8AIZGx0fF/ACCyAFIAYQxi9B7OeAASEGQQxqIgUQ8y0iCSADELsIRQ0ACwsgCCAJNgJMIAggAzYCSCAIQdAAaiIBIAUgBigCFBEAACAIIAEQoAEgACAIKQMANwIEIABBk4CAgHg2AgAMggMLIAUgBhDkISEKIAktAAEhCyAJLQACIQkgAy0AASEGIAMtAAIhByMAQcACayIBJAACQAJAAkACQAJ/AkACQAJ/AkACQAJAIAcgCUYgBiALT3FFBEACQAJAIAnAIAfASgRAIAEgBjoApQEgASAGOgCmASABIAc6AKcBIAEgCSAHayIJwCICNgLwAUEKIQMgAUEKNgKwAUEBIQUDQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNBCACQQFGDQELIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNAyACQQF2IQIMAQsLIAEgBTYCqAEgASAFQQJtIgI2AqwBIAFBACACazYCvAEgASABQbwBajYCuAEgASABQawBajYCtAEgASABQagBajYCsAEgCyAJa8AgBsBOBEAgBC0ANA0FIAEgAUGlAWo2ArgCIAEgAUGmAWo2ArQCIAEgAUGwAWo2ArACIAFBgAJqIAogAUGwAmoQqgQgAS0AgAIiBUEpRgRAIAFB6ABqIAFBlAJqKAIANgIAIAEgASkCjAI3A2AgASgCiAIhAyABKAKEAiECDA4LIAFB4AFqIAFBoAJqKQIANwIAIAFB6AFqIAFBqAJqKQIANwIAIAFB1AFqIAFBlAJqKAIANgIAIAEgAS0AgwI6AMMBIAEgAS8AgQI7AMEBIAEgASkCmAI3AtgBIAEgASkCjAI3AswBIAEoAogCIQMgASgChAIMCwsgAUGAAmogBiAHEM4OIAEoAoACIgJBk4CAgHhHBEAgAUHoAGogAUGQAmooAgA2AgAgASABKQKIAjcDYCABKAKEAiEDDA0LIAFBwAFqIAogAUGwAWoQzB8MCQsgASAGOgBsIAEgBjoAqAEgASAHOgCpASABIAcgCWsiDMAiAjYC8AFBCiEDIAFBCjYCOEEBIQUCQCAHIAlGDQADQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQQgAkEBRg0CCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQMgAkEBdiECDAALAAsgASAFNgK8ASABIAFBvAFqNgI4IAsgDGrAIAbASgRAIAQtADQNBSABIAFB7ABqNgK4AiABIAFBqAFqNgK0AiABIAFBOGo2ArACIAFBgAJqIAogAUGwAmoQvAcgAS0AgAIiBUEpRgRAIAFBuAFqIAFBlAJqKAIANgIAIAEgASkCjAI3A7ABIAEoAogCIQMgASgChAIhAgwJCyABQeABaiABQaACaikCADcCACABQegBaiABQagCaikCADcCACABQdQBaiABQZQCaigCADYCACABIAEtAIMCOgDDASABIAEvAIECOwDBASABIAEpApgCNwLYASABIAEpAowCNwLMASABKAKIAiEDIAEoAoQCDAcLIAFBgAJqIAYgBxDODiABKAKAAiICQZOAgIB4RwRAIAFBuAFqIAFBkAJqKAIANgIAIAEgASkCiAI3A7ABIAEoAoQCIQMMCAsgAUHAAWogCiABQbwBahDJHwwFCyABQQI2AoQCIAFBiJiAATYCgAIgAUICNwKMAiABQfoPNgK8AiABQfwPNgK0AiABIAFBsAJqNgKIAiABIAFB8AFqNgK4AiABIAFBsAFqNgKwAiABQcQBaiABQYACahCZDiABQegAaiABQdABaigCADYCACABIAEpAsgBNwNgIAEoAsQBIQNBiICAgHghAgwKCyABQQI2AoQCIAFBiJiAATYCgAIgAUICNwKMAiABQfoPNgK8AiABQfwPNgK0AiABIAFBsAJqNgKIAiABIAFB8AFqNgK4AiABIAFBOGo2ArACIAFBxAFqIAFBgAJqEJkOIAFBuAFqIAFB0AFqKAIANgIAIAEgASkCyAE3A7ABIAEoAsQBIQNBiICAgHghAgwFCyABQQhqIAoQgBUMBwsgAUHAAWogCiABQbABaiABQaUBahDvBAwECyABQcABaiAKIAFBOGogAUHsAGoQ0wQLIAEoAsgBIQMgAS0AwAEhBSABKALEAQshAiABQa4BaiIEIAEtAMMBOgAAIAFBuAFqIgkgAUHUAWooAgA2AgAgAUHQAGoiCiABQeABaikCADcDACABQdgAaiILIAFB6AFqKQIANwMAIAEgAS8AwQE7AawBIAEgASkCzAE3A7ABIAEgASkC2AE3A0ggBUH/AXFBKUYNACABQegAaiAJKAIAIgk2AgAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACABQRxqIAk2AgAgASABLwGsATsACSABIAEpA7ABIhs3A2AgASABKQNINwIgIAEgBC0AADoACyABIBs3AhQgASADNgIQIAEgAjYCDCABIAU6AAgMAwsgAUHoAGogAUG4AWooAgAiBDYCACABIAEpA7ABIhs3A2AgAEEQaiAENgAAIAAgGzcACCAAIAM2AgQgACACNgIADAULIAEoAsgBIQMgAS0AwAEhBSABKALEAQshAiABQe4AaiIEIAEtAMMBOgAAIAFB6ABqIgkgAUHUAWooAgA2AgAgAUHQAGoiCiABQeABaikCADcDACABQdgAaiILIAFB6AFqKQIANwMAIAEgAS8AwQE7AWwgASABKQLMATcDYCABIAEpAtgBNwNIIAVB/wFxQSlGDQEgAUFAayAJKAIAIgk2AgAgAUEoaiAKKQMANwIAIAFBMGogCykDADcCACABQRxqIAk2AgAgASABLwFsOwAJIAEgASkDYCIbNwM4IAEgASkDSDcCICABIAQtAAA6AAsgASAbNwIUIAEgAzYCECABIAI2AgwgASAFOgAICyABQYACaiABQQhqIAYgBxCgEyABLQCAAiIDQSlHDQEgAUGDAWogAUGUAmooAgAiAjYAACABQfsAaiABQYwCaikCACIbNwAAIAEgASkChAIiHDcAcyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQUBrIAFB6ABqKAIAIgQ2AgAgASABKQNgIhs3AzggAEEQaiAENgAAIAAgGzcACCAAIAM2AgQgACACNgIADAELIAFB/wBqIgQgAUGQAmopAAA3AAAgAUH4AGoiBSABQYkCaikAADcDACABQZABaiIGIAFBoAJqKQIANwMAIAFBmAFqIgcgAUGoAmopAgA3AwAgASABKQCBAjcDcCABIAEpApgCNwOIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDcDcACSACIAEpA4gBNwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAQsMhwMLIAFBwAJqJAAMgQMLIAUgBhDkISEKIAksAAEhCyAJLQACIQUgAy0AASEGIAMtAAIhByMAQZACayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFwCAHwEwEQCABIAY6AJYBIAEgBjoAPCABIAc6AD0gASAHIAVrIgPAIgI2ApwBQgohGyABQgo3A6ABQgEhHAJAIAUgB0YNAANAIAJBAXEEQCABQRBqIBwgHEI/hyAbIBtCP4cQqB4gASkDGCABKQMQIhxCP4dSDQQgAkEBRg0CCyABIBsgG0I/hyIdIBsgHRCoHiABKQMIIAEpAwAiG0I/h1INAyACQQF2IQIMAAsACyABIBw3A4gBIAEgAUGIAWo2AqABIAMgC2rAIAbASgRAIAQtADQNBiABIAFBlgFqNgIoIAEgAUE8ajYCJCABIAFBoAFqNgIgIAFB4AFqIAogAUEgahC3ByABLQDgASIEQSlHDQMgASkC8AEhGyABKQLoASEcIAEoAuQBIQIMDAsgAUHgAWogBiAHEM0OIAEoAuABIgJBk4CAgHhHBEAgASkC7AEhGyABKQLkASEcDAwLIAFBsAFqIAogAUGIAWoQzR8MCgsgASAGOgCVASABIAY6AJYBIAEgBzoAlwEgASAFIAdrIgnAIgI2AqABQQohBSABQQo2AogBQQEhAwNAAkAgAkEBcQRAIAOsIAWsfiIbQiCIpyAbpyIDQR91Rw0FIAJBAUYNAQsgBawiGyAbfiIbQiCIpyAbpyIFQR91Rw0EIAJBAXYhAgwBCwsgASADNgKYASABIANBAm0iAjYCnAEgAUEAIAJrNgKIASABIAFBiAFqNgKoASABIAFBnAFqNgKkASABIAFBmAFqNgKgASALIAlrwCAGwE4EQCAELQA0DQYgASABQZUBajYCKCABIAFBlgFqNgIkIAEgAUGgAWo2AiAgAUHgAWogCiABQSBqELYEIAEtAOABIgRBKUcNBCABKQLwASEbIAEoAuwBIQUgASgC6AEhAyABKALkASECDAgLIAFB4AFqIAYgBxDNDiABKALgASICQZOAgIB4RwRAIAEpAuwBIRsgASgC6AEhBSABKALkASEDDAgLIAFBsAFqIAogAUGgAWoQxh8MBgsgAUECNgLkASABQYiYgAE2AuABIAFCAjcC7AEgAUH6DzYCLCABQf0PNgIkIAEgAUEgajYC6AEgASABQZwBajYCKCABIAFBoAFqNgIgIAFBtAFqIAFB4AFqEJkOIAEpArQBIRwgASkCvAEhG0GIgICAeCECDAkLIAFBmgFqIAEtAOMBIgI6AAAgAUHQAGogAUGIAmopAgA3AwAgAUHIAGogAUGAAmopAgA3AwAgASACOgCzASABIAEvAOEBIgI7ALEBIAEgASkC+AEiGzcCyAEgASACOwGYASABIBs3A0AgASgC5AEhAiABKQLoASEcIAEpAvABIRsMCgsgAUECNgLkASABQYiYgAE2AuABIAFCAjcC7AEgAUH6DzYCLCABQfwPNgIkIAEgAUEgajYC6AEgASABQaABajYCKCABIAFBiAFqNgIgIAFBtAFqIAFB4AFqEJkOIAEoArQBIQMgASgCuAEhBSABKQK8ASEbQYiAgIB4IQIMBAsgAUHQAWogAUGAAmopAgAiHDcCACABQdgBaiABQYgCaikCACIdNwIAIAFBPmogAS0A4wEiAjoAACABIAI6ALMBIAEgAS8A4QEiAjsAsQEgASABKQL4ASIeNwLIASABIAI7ATwgASgC5AEhAiABKALoASEDIAEoAuwBIQUgASkC8AEhGyABQdAAaiAdNwMAIAFByABqIBw3AwAgASAeNwNADAQLIAFBsAFqIAogAUGgAWogAUGWAWoQ2wQMBAsgAUGwAWogCiABQaABaiABQZUBahCEBQsgAUE+aiABLQCzAToAACABQcgAaiABQdABaikCADcDACABQdAAaiABQdgBaikCADcDACABIAEvALEBOwE8IAEgASkCyAE3A0AgASkCwAEhGyABKAK8ASEFIAEoArgBIQMgASgCtAEhAiABLQCwASIEQSlHDQELIAAgBTYCCCAAIAM2AgQMAwsgAUGiAWogAUE+ai0AADoAACABQShqIAFByABqKQMANwMAIAFBMGogAUHQAGopAwA3AwAgASABLwE8OwGgASABIAEpA0A3AyAMBAsgAUGaAWogAS0AswE6AAAgAUHIAGogAUHQAWopAgA3AwAgAUHQAGogAUHYAWopAgA3AwAgASABLwCxATsBmAEgASABKQLIATcDQCABKQLAASEbIAEpArgBIRwgASgCtAEhAiABLQCwASIEQSlHDQILIAAgHDcCBAsgACACNgIAIAAgGzcCDAwCCyABQaIBaiABQZoBai0AADoAACABQShqIAFByABqKQMANwMAIAFBMGogAUHQAGopAwA3AwAgASABLwGYATsBoAEgASABKQNANwMgIBxCIIinIQUgHKchAwsgAUGAAmogAUEoaikDADcCACABQYgCaiABQTBqKQMANwIAIAEgBDoA4AEgASABLwGgATsA4QEgASAbNwLwASABIAU2AuwBIAEgAzYC6AEgASACNgLkASABIAEpAyA3AvgBIAEgAUGiAWotAAA6AOMBIAFBsAFqIAFB4AFqIAYgBxCiEyABLQCwASIDQSlGBEAgAUHrAGogAUHEAWooAgAiAjYAACABQeMAaiABQbwBaikCACIbNwAAIAEgASkCtAEiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQecAaiIEIAFBwAFqKQAANwAAIAFB4ABqIgUgAUG5AWopAAA3AwAgAUH4AGoiBiABQdABaikCADcDACABQYABaiIHIAFB2AFqKQIANwMAIAEgASkAsQE3A1ggASABKQLIATcDcBCwPkE4QQQQrTYiAkUNhwMgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNYNwAJIAIgASkDcDcCICAAQbyagAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQZACaiQADAALDIADCyAFIAYQ5CEhCiAJLAABIQsgCS0AAiEFIAMtAAEhBiADLQACIQcjAEGwAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBcAgB8BMBEAgASAGOgDGASABIAY6AFQgASAHOgBVIAEgByAFayIDwCICNgLMASABQgA3A7gBQgohGyABQgo3A7ABQgEhHgJAIAUgB0YNAANAIAJBAXEEQCABQQA2AjQgAUEgaiAeIB0gGyAcIAFBNGoQ9gwgASgCNA0EIAEpAyghHSABKQMgIR4gAkEBRg0CCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0DIAEpAwghHCABKQMAIRsgAkEBdiECDAALAAsgASAeNwOgASABIB03A6gBIAEgAUGgAWo2ArABIAMgC2rAIAbASgRAIAQtADQNBiABIAFBxgFqNgJAIAEgAUHUAGo2AjwgASABQbABajYCOCABQYACaiAKIAFBOGoQwQcgAS0AgAIiBEEpRw0DIAEpApACIRsgASkCiAIhHCABKAKEAiECDAwLIAFBgAJqIAYgBxDMDiABKAKAAiICQZOAgIB4RwRAIAEpAowCIRsgASkChAIhHAwMCyABQdABaiAKIAFBoAFqEMEfDAoLIAEgBjoAxQEgASAGOgDGASABIAc6AMcBIAEgBSAHayIJwCICNgKwAUEKIQUgAUEKNgKgAUEBIQMDQAJAIAJBAXEEQCADrCAFrH4iG0IgiKcgG6ciA0EfdUcNBSACQQFGDQELIAWsIhsgG34iG0IgiKcgG6ciBUEfdUcNBCACQQF2IQIMAQsLIAEgAzYCyAEgASADQQJtIgI2AswBIAFBACACazYCoAEgASABQaABajYCuAEgASABQcwBajYCtAEgASABQcgBajYCsAEgCyAJa8AgBsBOBEAgBC0ANA0GIAEgAUHFAWo2AkAgASABQcYBajYCPCABIAFBsAFqNgI4IAFBgAJqIAogAUE4ahCkBCABLQCAAiIEQSlHDQQgASkCkAIhGyABKAKMAiEFIAEoAogCIQMgASgChAIhAgwICyABQYACaiAGIAcQzA4gASgCgAIiAkGTgICAeEcEQCABKQKMAiEbIAEoAogCIQUgASgChAIhAwwICyABQdABaiAKIAFBsAFqEMQfDAYLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AkQgAUH7DzYCPCABIAFBOGo2AogCIAEgAUHMAWo2AkAgASABQbABajYCOCABQdQBaiABQYACahCZDiABKQLUASEcIAEpAtwBIRtBiICAgHghAgwJCyABQcoBaiABLQCDAiICOgAAIAFB6ABqIAFBqAJqKQIANwMAIAFB4ABqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsByAEgASAbNwNYIAEoAoQCIQIgASkCiAIhHCABKQKQAiEbDAoLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AkQgAUH8DzYCPCABIAFBOGo2AogCIAEgAUGwAWo2AkAgASABQaABajYCOCABQdQBaiABQYACahCZDiABKALUASEDIAEoAtgBIQUgASkC3AEhG0GIgICAeCECDAQLIAFB8AFqIAFBoAJqKQIAIhw3AgAgAUH4AWogAUGoAmopAgAiHTcCACABQdYAaiABLQCDAiICOgAAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIh43AugBIAEgAjsBVCABKAKEAiECIAEoAogCIQMgASgCjAIhBSABKQKQAiEbIAFB6ABqIB03AwAgAUHgAGogHDcDACABIB43A1gMBAsgAUHQAWogCiABQbABaiABQcYBahDQBAwECyABQdABaiAKIAFBsAFqIAFBxQFqEIIFCyABQdYAaiABLQDTAToAACABQeAAaiABQfABaikCADcDACABQegAaiABQfgBaikCADcDACABIAEvANEBOwFUIAEgASkC6AE3A1ggASkC4AEhGyABKALcASEFIAEoAtgBIQMgASgC1AEhAiABLQDQASIEQSlHDQELIAAgBTYCCCAAIAM2AgQMAwsgAUGyAWogAUHWAGotAAA6AAAgAUFAayABQeAAaikDADcDACABQcgAaiABQegAaikDADcDACABIAEvAVQ7AbABIAEgASkDWDcDOAwECyABQcoBaiABLQDTAToAACABQeAAaiABQfABaikCADcDACABQegAaiABQfgBaikCADcDACABIAEvANEBOwHIASABIAEpAugBNwNYIAEpAuABIRsgASkC2AEhHCABKALUASECIAEtANABIgRBKUcNAgsgACAcNwIECyAAIAI2AgAgACAbNwIMDAILIAFBsgFqIAFBygFqLQAAOgAAIAFBQGsgAUHgAGopAwA3AwAgAUHIAGogAUHoAGopAwA3AwAgASABLwHIATsBsAEgASABKQNYNwM4IBxCIIinIQUgHKchAwsgAUGgAmogAUFAaykDADcCACABQagCaiABQcgAaikDADcCACABIAQ6AIACIAEgAS8BsAE7AIECIAEgGzcCkAIgASAFNgKMAiABIAM2AogCIAEgAjYChAIgASABKQM4NwKYAiABIAFBsgFqLQAAOgCDAiABQdABaiABQYACaiAGIAcQoRMgAS0A0AEiA0EpRgRAIAFBgwFqIAFB5AFqKAIAIgI2AAAgAUH7AGogAUHcAWopAgAiGzcAACABIAEpAtQBIhw3AHMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUH/AGoiBCABQeABaikAADcAACABQfgAaiIFIAFB2QFqKQAANwMAIAFBkAFqIgYgAUHwAWopAgA3AwAgAUGYAWoiByABQfgBaikCADcDACABIAEpANEBNwNwIAEgASkC6AE3A4gBELA+QThBBBCtNiICRQ2GAyACIAM6AAggAkKBgICAEDcCACACIAEpA3A3AAkgAiABKQOIATcCICAAQbSYgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQbACaiQADAALDP8CCyAFIAYQ5CEhCiAJLAABIQsgCS0AAiECIAMtAAEhBiADLQACIQcjAEGQAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIALAIAfATARAIAEgBjoAJCABIAY6AJgBIAEgBzoAmQEgAUGgAWpCCkIAELIuIAFB0AFqIAEpA6ABIAEpA6gBIAEpA7ABIAEpA7gBIAcgAmsiAsAQ3wEgASgC0AFBAUYEQCABKQPgASEbIAEpA9gBIRwgASgC1AEhAgwLCyABIAEpA/gBNwOIASABIAEpA/ABNwOAASABIAEpA+gBNwN4IAEgASkD4AE3A3AgASABQfAAajYCjAIgAiALasAgBsBKBEAgBC0ANA0FIAEgAUEkajYCECABIAFBmAFqNgIMIAEgAUGMAmo2AgggAUHQAWogCiABQQhqELIHIAEtANABIgRBKUcNAiABKQLgASEbIAEpAtgBIRwgASgC1AEhAgwLCyABQdABaiAGIAcQzw4gASgC0AEiAkGTgICAeEcEQCABKQLcASEbIAEpAtQBIRwMCwsgAUGgAWogCiABQfAAahDDHwwJCyABIAY6AJUBIAEgBjoAlgEgASAHOgCXASABIAIgB2siCcAiAjYCCEEKIQUgAUEKNgKMAkEBIQMDQAJAIAJBAXEEQCADrCAFrH4iG0IgiKcgG6ciA0EfdUcNBCACQQFGDQELIAWsIhsgG34iG0IgiKcgG6ciBUEfdUcNAyACQQF2IQIMAQsLIAEgAzYCmAEgASADQQJtIgI2ApwBIAFBACACazYCjAIgASABQYwCajYCECABIAFBnAFqNgIMIAEgAUGYAWo2AgggCyAJa8AgBsBOBEAgBC0ANA0FIAEgAUGVAWo2AjAgASABQZYBajYCLCABIAFBCGo2AiggAUHQAWogCiABQShqEIAEIAEtANABIgRBKUcNAyABKQLgASEbIAEoAtwBIQUgASgC2AEhAyABKALUASECDAcLIAFB0AFqIAYgBxDPDiABKALQASICQZOAgIB4RwRAIAEpAtwBIRsgASgC2AEhBSABKALUASEDDAcLIAFBoAFqIAogAUEIahDPHwwFCyABQZ4BaiABLQDTASICOgAAIAFBOGogAUH4AWopAgA3AwAgAUEwaiABQfABaikCADcDACABIAI6AKMBIAEgAS8A0QEiAjsAoQEgASABKQLoASIbNwK4ASABIAI7AZwBIAEgGzcDKCABKALUASECIAEpAtgBIRwgASkC4AEhGwwKCyABQQI2AtQBIAFBiJiAATYC0AEgAUICNwLcASABQfoPNgI0IAFB/A82AiwgASABQShqNgLYASABIAFBCGo2AjAgASABQYwCajYCKCABQaQBaiABQdABahCZDiABKAKkASEDIAEoAqgBIQUgASkCrAEhG0GIgICAeCECDAQLIAFBwAFqIAFB8AFqKQIAIhw3AgAgAUHIAWogAUH4AWopAgAiHTcCACABQSZqIAEtANMBIgI6AAAgASACOgCjASABIAEvANEBIgI7AKEBIAEgASkC6AEiHjcCuAEgASACOwEkIAEoAtQBIQIgASgC2AEhAyABKALcASEFIAEpAuABIRsgAUGAAWogHTcDACABQfgAaiAcNwMAIAEgHjcDcAwECyABQaABaiAKIAFBjAJqIAFBJGoQ3QQMBAsgAUGgAWogCiABQQhqIAFBlQFqENYECyABQSZqIAEtAKMBOgAAIAFB+ABqIAFBwAFqKQIANwMAIAFBgAFqIAFByAFqKQIANwMAIAEgAS8AoQE7ASQgASABKQK4ATcDcCABKQKwASEbIAEoAqwBIQUgASgCqAEhAyABKAKkASECIAEtAKABIgRBKUcNAQsgACAFNgIIIAAgAzYCBAwDCyABQY4CaiABQSZqLQAAOgAAIAFBEGogAUH4AGopAwA3AwAgAUEYaiABQYABaikDADcDACABIAEvASQ7AYwCIAEgASkDcDcDCAwECyABQZ4BaiABLQCjAToAACABQTBqIAFBwAFqKQIANwMAIAFBOGogAUHIAWopAgA3AwAgASABLwChATsBnAEgASABKQK4ATcDKCABKQKwASEbIAEpAqgBIRwgASgCpAEhAiABLQCgASIEQSlHDQILIAAgHDcCBAsgACACNgIAIAAgGzcCDAwCCyABQY4CaiABQZ4Bai0AADoAACABQRBqIAFBMGopAwA3AwAgAUEYaiABQThqKQMANwMAIAEgAS8BnAE7AYwCIAEgASkDKDcDCCAcQiCIpyEFIBynIQMLIAFB8AFqIAFBEGopAwA3AgAgAUH4AWogAUEYaikDADcCACABIAQ6ANABIAEgAS8BjAI7ANEBIAEgGzcC4AEgASAFNgLcASABIAM2AtgBIAEgAjYC1AEgASABKQMINwLoASABIAFBjgJqLQAAOgDTASABQaABaiABQdABaiAGIAcQoxMgAS0AoAEiA0EpRgRAIAFB0wBqIAFBtAFqKAIAIgI2AAAgAUHLAGogAUGsAWopAgAiGzcAACABIAEpAqQBIhw3AEMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUHPAGoiBCABQbABaikAADcAACABQcgAaiIFIAFBqQFqKQAANwMAIAFB4ABqIgYgAUHAAWopAgA3AwAgAUHoAGoiByABQcgBaikCADcDACABIAEpAKEBNwNAIAEgASkCuAE3A1gQsD5BOEEEEK02IgJFDYUDIAIgAzoACCACQoGAgIAQNwIAIAIgASkDQDcACSACIAEpA1g3AiAgAEGMmYABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUGQAmokAAwACwz+AgsgDUENa0H/AXFBB0kNECAJQQJqIQIjAEFAaiIBJAAgASADNgIQIAEgCTYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIAItAAAgBBCbAgwMCyAAIAUgBiACLQAAIAQQlgIMCwsgACAFIAYgAi0AACAEELECDAoLIAAgBSAGIAItAAAgBBCyAgwJCyAAIAUgBiACLQAAIAQQoAIMCAsgACAFIAYgAi0AACAEEJoCDAcLIAAgBSAGIAItAAAgBBCYAgwGCyAAIAUgBiACLQAAIAQQlwIMBQsgACAFIAYgAUE/aiACENMgDAQLIAAgBSAGIAFBP2ogAhDXIAwDCyAAIAUgBiAEEJEJDAILIAAgBSAGIAQQkgkMAQsgACAFIAYgBBCnAQsgAUFAayQADP0CCyAFIAYQ6CEhCiAJLAABIQsgCS0AAiEJIAMtAAEhBSADLQACIQYjAEGgAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCcAgBsBMBEAgASAFOgCWASABIAU6AEQgASAGOgBFIAEgBiAJayIMwCICNgKwAUEKIQcgAUEKNgKoAUEBIQMCQCAGIAlGDQADQCACQQFxBEAgA6wgB6x+IhtCIIinIBunIgNBH3VHDQQgAkEBRg0CCyAHrCIbIBt+IhtCIIinIBunIgdBH3VHDQMgAkEBdiECDAALAAsgASADNgKgASABIAFBoAFqNgKwASALIAxqwCAFwEoEQCAELQA0DQYgASABQZYBajYCMCABIAFBxABqNgIsIAEgAUGwAWo2AiggAUHwAWogCiABQShqEL0HIAEtAPABIgdBKUcNAyABKQKAAiEbIAEoAvwBIQMgASgC+AEhBCABKAL0ASECDAwLIAFB8AFqIAUgBhDODiABKALwASICQZOAgIB4RwRAIAEpAvwBIRsgASgC+AEhAyABKAL0ASEEDAwLIAFBwAFqIAogAUGgAWoQwh8MCgsgASAFOgCVASABIAU6AJYBIAEgBjoAlwEgASAJIAZrIgPAIgI2AqgBQgohGyABQgo3A7ABQgEhHANAAkAgAkEBcQRAIAFBEGogHCAcQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHEI/h1INBSACQQFGDQELIAEgGyAbQj+HIh0gGyAdEKgeIAEpAwggASkDACIbQj+HUg0EIAJBAXYhAgwBCwsgASAcNwOYASABIBxCAn8iGzcDoAEgAUIAIBt9NwOoASABIAFBqAFqNgK4ASABIAFBoAFqNgK0ASABIAFBmAFqNgKwASALIANrwCAFwE4EQCAELQA0DQYgASABQZUBajYCMCABIAFBlgFqNgIsIAEgAUGwAWo2AiggAUHwAWogCiABQShqELUHIAEtAPABIgdBKUcNBCABKQKAAiEbIAEpAvgBIRwgASgC9AEhAgwICyABQfABaiAFIAYQzg4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEbIAEpAvQBIRwMCAsgAUHAAWogCiABQbABahDFHwwGCyABQQI2AvQBIAFBiJiAATYC8AEgAUICNwL8ASABQfoPNgI0IAFB/A82AiwgASABQShqNgL4ASABIAFBsAFqNgIwIAEgAUGoAWo2AiggAUHEAWogAUHwAWoQmQ4gASgCxAEhBCABKALIASEDIAEpAswBIRtBiICAgHghAgwJCyABQeABaiABQZACaikCACIcNwIAIAFB6AFqIAFBmAJqKQIAIh03AgAgAUGaAWogAS0A8wEiAjoAACABIAI6AMMBIAEgAS8A8QEiAjsAwQEgASABKQKIAiIeNwLYASABIAI7AZgBIAEoAvQBIQIgASgC+AEhBCABKAL8ASEDIAEpAoACIRsgAUHYAGogHTcDACABQdAAaiAcNwMAIAEgHjcDSAwKCyABQQI2AvQBIAFBiJiAATYC8AEgAUICNwL8ASABQfoPNgI0IAFB/Q82AiwgASABQShqNgL4ASABIAFBqAFqNgIwIAEgAUGwAWo2AiggAUHEAWogAUHwAWoQmQ4gASkCxAEhHCABKQLMASEbQYiAgIB4IQIMBAsgAUHGAGogAS0A8wEiAjoAACABQdgAaiABQZgCaikCADcDACABQdAAaiABQZACaikCADcDACABIAI6AMMBIAEgAS8A8QEiAjsAwQEgASABKQKIAiIbNwLYASABIAI7AUQgASAbNwNIIAEoAvQBIQIgASkC+AEhHCABKQKAAiEbDAQLIAFBwAFqIAogAUGwAWogAUGWAWoQ1QQMBAsgAUHAAWogCiABQbABaiABQZUBahD2BAsgAUHGAGogAS0AwwE6AAAgAUHQAGogAUHgAWopAgA3AwAgAUHYAGogAUHoAWopAgA3AwAgASABLwDBATsBRCABIAEpAtgBNwNIIAEpAtABIRsgASkCyAEhHCABKALEASECIAEtAMABIgdBKUcNAQsgACAcNwIEDAMLIAFBsgFqIAFBxgBqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAUQ7AbABIAEgASkDSDcDKAwECyABQZoBaiABLQDDAToAACABQdAAaiABQeABaikCADcDACABQdgAaiABQegBaikCADcDACABIAEvAMEBOwGYASABIAEpAtgBNwNIIAEpAtABIRsgASgCzAEhAyABKALIASEEIAEoAsQBIQIgAS0AwAEiB0EpRw0CCyAAIAM2AgggACAENgIECyAAIAI2AgAgACAbNwIMDAILIAFBsgFqIAFBmgFqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAZgBOwGwASABIAEpA0g3AyggBK0gA61CIIaEIRwLIAFBkAJqIAFBMGopAwA3AgAgAUGYAmogAUE4aikDADcCACABIAc6APABIAEgAS8BsAE7APEBIAEgGzcCgAIgASAcNwL4ASABIAI2AvQBIAEgASkDKDcCiAIgASABQbIBai0AADoA8wEgAUHAAWogAUHwAWogBSAGEKATIAEtAMABIgNBKUYEQCABQfMAaiABQdQBaigCACICNgAAIAFB6wBqIAFBzAFqKQIAIhs3AAAgASABKQLEASIcNwBjIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB7wBqIgQgAUHQAWopAAA3AAAgAUHoAGoiBSABQckBaikAADcDACABQYABaiIGIAFB4AFqKQIANwMAIAFBiAFqIgcgAUHoAWopAgA3AwAgASABKQDBATcDYCABIAEpAtgBNwN4ELA+QThBBBCtNiICRQ2DAyACIAM6AAggAkKBgICAEDcCACACIAEpA2A3AAkgAiABKQN4NwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFBoAJqJAAMAAsM/AILIAUgBhDoISEGIAktAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQeACayIBJAACQAJAAkACQAJAAkACQAJAAkACQCADIAdGIAUgCk9xRQRAAkACQAJAAkAgB8AgA8BKBEAgASAFOgDFASABIAU6AMYBIAEgAzoAxwEgASAHIANrIgfAIgI2AugBQgohGyABQgo3A9gBQgEhHANAAkAgAkEBcQRAIAFBEGogHCAcQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHEI/h1INBCACQQFGDQELIAEgGyAbQj+HIh0gGyAdEKgeIAEpAwggASkDACIbQj+HUg0DIAJBAXYhAgwBCwsgASAcNwPIASABIBxCAn8iGzcD0AEgAUIAIBt9NwPoASABIAFB6AFqNgLgASABIAFB0AFqNgLcASABIAFByAFqNgLYASAKIAdrwCAFwE4EQCAELQA0DQcgASABQcUBajYC2AIgASABQcYBajYC1AIgASABQdgBajYC0AIgAUGgAmogBiABQdACahC1BCABLQCgAiIEQSlHDQMgASkCsAIhGyABKQKoAiEcIAEoAqQCIQIMDQsgAUGgAmogBSADEM0OIAEoAqACIgJBk4CAgHhHBEAgASkCrAIhGyABKQKkAiEcDA0LIAFB8AFqIAYgAUHYAWoQyh8MCwsgASAFOgDGASABIAU6AIwBIAEgAzoAjQEgASADIAdrIgnAIgI2AtABQgohGyABQgo3A9gBQgEhHAJAIAMgB0YNAANAIAJBAXEEQCABQTBqIBwgHEI/hyAbIBtCP4cQqB4gASkDOCABKQMwIhxCP4dSDQUgAkEBRg0CCyABQSBqIBsgG0I/hyIdIBsgHRCoHiABKQMoIAEpAyAiG0I/h1INBCACQQF2IQIMAAsACyABIBw3A+gBIAEgAUHoAWo2AtgBIAkgCmrAIAXASgRAIAQtADQNByABIAFBxgFqNgLYAiABIAFBjAFqNgLUAiABIAFB2AFqNgLQAiABQaACaiAGIAFB0AJqELkHIAEtAKACIgRBKUcNBCABKQKwAiEbIAEpAqgCIRwgASgCpAIhAgwJCyABQaACaiAFIAMQzQ4gASgCoAIiAkGTgICAeEcEQCABKQKsAiEbIAEpAqQCIRwMCQsgAUHwAWogBiABQegBahDIHwwHCyABQQI2AqQCIAFBiJiAATYCoAIgAUICNwKsAiABQfoPNgLcAiABQf0PNgLUAiABIAFB0AJqNgKoAiABIAFB6AFqNgLYAiABIAFB2AFqNgLQAiABQfQBaiABQaACahCZDiABKQL0ASEcIAEpAvwBIRtBiICAgHghAgwKCyABQY4BaiABLQCjAiICOgAAIAFBgAFqIAFByAJqKQIANwMAIAFB+ABqIAFBwAJqKQIANwMAIAEgAjoA8wEgASABLwChAiICOwDxASABIAEpArgCIhs3AogCIAEgAjsBjAEgASAbNwNwIAEoAqQCIQIgASkCqAIhHCABKQKwAiEbDAoLIAFBAjYCpAIgAUGImIABNgKgAiABQgI3AqwCIAFB+g82AtwCIAFB/Q82AtQCIAEgAUHQAmo2AqgCIAEgAUHQAWo2AtgCIAEgAUHYAWo2AtACIAFB9AFqIAFBoAJqEJkOIAEpAvQBIRwgASkC/AEhG0GIgICAeCECDAULIAFBygFqIAEtAKMCIgI6AAAgAUGAAWogAUHIAmopAgA3AwAgAUH4AGogAUHAAmopAgA3AwAgASACOgDzASABIAEvAKECIgI7APEBIAEgASkCuAIiGzcCiAIgASACOwHIASABIBs3A3AgASgCpAIhAiABKQKoAiEcIAEpArACIRsMBQsgAUFAayAGEIAVDAgLIAFB8AFqIAYgAUHYAWogAUHFAWoQ+wQMBAsgAUHwAWogBiABQdgBaiABQcYBahDEBAsgAUHKAWogAS0A8wE6AAAgAUH4AGogAUGQAmopAgA3AwAgAUGAAWogAUGYAmopAgA3AwAgASABLwDxATsByAEgASABKQKIAjcDcCABKQKAAiEbIAEpAvgBIRwgASgC9AEhAiABLQDwASIEQSlHDQELIAAgGzcCDCAAIBw3AgQgACACNgIADAULIAFB4ABqIAFB+ABqKQMANwIAIAFB6ABqIAFBgAFqKQMANwIAIAEgAS8ByAE7AEEgASABKQNwNwJYIAEgAUHKAWotAAA6AEMgASAbNwJQIAEgHDcCSCABIAI2AkQgASAEOgBADAMLIAFBjgFqIAEtAPMBOgAAIAFB+ABqIAFBkAJqKQIANwMAIAFBgAFqIAFBmAJqKQIANwMAIAEgAS8A8QE7AYwBIAEgASkCiAI3A3AgASkCgAIhGyABKQL4ASEcIAEoAvQBIQIgAS0A8AEiBEEpRw0BCyAAIBs3AgwgACAcNwIEIAAgAjYCAAwCCyABQeAAaiABQfgAaikDADcCACABQegAaiABQYABaikDADcCACABIAEvAYwBOwBBIAEgASkDcDcCWCABIAFBjgFqLQAAOgBDIAEgGzcCUCABIBw3AkggASACNgJEIAEgBDoAQAsgAUGgAmogAUFAayAFIAMQohMgAS0AoAIiA0EpRgRAIAFBowFqIAFBtAJqKAIAIgI2AAAgAUGbAWogAUGsAmopAgAiGzcAACABIAEpAqQCIhw3AJMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBnwFqIgQgAUGwAmopAAA3AAAgAUGYAWoiBSABQakCaikAADcDACABQbABaiIGIAFBwAJqKQIANwMAIAFBuAFqIgcgAUHIAmopAgA3AwAgASABKQChAjcDkAEgASABKQK4AjcDqAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA5ABNwAJIAIgASkDqAE3AiAgAEG8moABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwBCwyBAwsgAUHgAmokAAz7AgsgBSAGEOghIQYgCSwAASEKIAktAAIhByADLQABIQUgAy0AAiEDIwBB4AJrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAfAIAPATARAIAEgBToA7gEgASAFOgB0IAEgAzoAdSABIAMgB2siCcAiAjYC+AEgAUIANwPYAUIKIRsgAUIKNwPQAUIBIR4CQCADIAdGDQADQCACQQFxBEAgAUEANgJUIAFBQGsgHiAdIBsgHCABQdQAahD2DCABKAJUDQQgASkDSCEdIAEpA0AhHiACQQFGDQILIAFBADYCPCABQSBqIBsgHCAbIBwgAUE8ahD2DCABKAI8DQMgASkDKCEcIAEpAyAhGyACQQF2IQIMAAsACyABIB43A8ABIAEgHTcDyAEgASABQcABajYC0AEgCSAKasAgBcBKBEAgBC0ANA0GIAEgAUHuAWo2AmAgASABQfQAajYCXCABIAFB0AFqNgJYIAFBsAJqIAYgAUHYAGoQtAcgAS0AsAIiBEEpRw0DDA4LIAFBsAJqIAUgAxDMDiABKAKwAiICQZOAgIB4Rw0MIAFBgAJqIAYgAUHAAWoQzh8MCQsgASAFOgDtASABIAU6AO4BIAEgAzoA7wEgASAHIANrIgfAIgI2AsABQgohGyABQgo3A9ABQgEhHQNAAkAgAkEBcQRAIAFBEGogHSAdQj+HIBsgG0I/hxCoHiABKQMYIAEpAxAiHUI/h1INBSACQQFGDQELIAEgGyAbQj+HIhwgGyAcEKgeIAEpAwggASkDACIbQj+HUg0EIAJBAXYhAgwBCwsgASAdNwPwASABIB1CAn8iGzcD+AEgAUIAIBt9NwPAASABIAFBwAFqNgLYASABIAFB+AFqNgLUASABIAFB8AFqNgLQASAKIAdrwCAFwE4EQCAELQA0DQYgASABQe0BajYCYCABIAFB7gFqNgJcIAEgAUHQAWo2AlggAUGwAmogBiABQdgAahCeBCABLQCwAiIEQSlGDQ0gAUH2AGogAS0AswIiAjoAACABQYgBaiABQdgCaikCADcDACABQYABaiABQdACaikCADcDACABIAI6AIMCIAEgAS8AsQIiAjsAgQIgASABKQLIAiIbNwKYAiABIAI7AXQgASAbNwN4IAEoArQCIQIgASkCuAIhHCABKQLAAiEbDAgLIAFBsAJqIAUgAxDMDiABKAKwAiICQZOAgIB4Rw0LIAFBgAJqIAYgAUHQAWoQxx8MBgsgAUECNgK0AiABQYiYgAE2ArACIAFCAjcCvAIgAUH6DzYCZCABQfsPNgJcIAEgAUHYAGo2ArgCIAEgAUH4AWo2AmAMAgsgAUHyAWogAS0AswIiAjoAACABQYgBaiABQdgCaikCADcDACABQYABaiABQdACaikCADcDACABIAI6AIMCIAEgAS8AsQIiAjsAgQIgASABKQLIAiIbNwKYAiABIAI7AfABIAEgGzcDeCABKAK0AiECIAEpArgCIRwgASkCwAIhGwwHCyABQQI2ArQCIAFBiJiAATYCsAIgAUICNwK8AiABQfoPNgJkIAFB/Q82AlwgASABQdgAajYCuAIgASABQcABajYCYAsgASABQdABajYCWCABQYQCaiABQbACahCZDiABKQKEAiEcQYiAgIB4IQIgASkCjAIMCQsgAUGAAmogBiABQdABaiABQe4BahDrBAwDCyABQYACaiAGIAFB0AFqIAFB7QFqEOMECyABQfYAaiABLQCDAjoAACABQYABaiABQaACaikCADcDACABQYgBaiABQagCaikCADcDACABIAEvAIECOwF0IAEgASkCmAI3A3ggASkCiAIhHCABKAKEAiECIAEpApACIhsgAS0AgAIiBEEpRg0GGgsgAUHSAWogAUH2AGotAAA6AAAgAUHgAGogAUGAAWopAwA3AwAgAUHoAGogAUGIAWopAwA3AwAgASABLwF0OwHQAQwCCyABQfIBaiABLQCDAjoAACABQYABaiABQaACaikCADcDACABQYgBaiABQagCaikCADcDACABIAEvAIECOwHwASABIAEpApgCNwN4IAEpAogCIRwgASgChAIhAiABKQKQAiIbIAEtAIACIgRBKUYNBBoLIAFB0gFqIAFB8gFqLQAAOgAAIAFB4ABqIAFBgAFqKQMANwMAIAFB6ABqIAFBiAFqKQMANwMAIAEgAS8B8AE7AdABCyABIAEpA3g3A1ggAUHQAmogAUHgAGopAwA3AgAgAUHYAmogAUHoAGopAwA3AgAgASAEOgCwAiABIAEvAdABOwCxAiABIBs3AsACIAEgHDcCuAIgASACNgK0AiABIAEpA1g3AsgCIAEgAUHSAWotAAA6ALMCIAFBgAJqIAFBsAJqIAUgAxChEyABLQCAAiIDQSlGBEAgAUGjAWogAUGUAmooAgAiAjYAACABQZsBaiABQYwCaikCACIbNwAAIAEgASkChAIiHDcAkwEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUGfAWoiBCABQZACaikAADcAACABQZgBaiIFIAFBiQJqKQAANwMAIAFBsAFqIgYgAUGgAmopAgA3AwAgAUG4AWoiByABQagCaikCADcDACABIAEpAIECNwOQASABIAEpApgCNwOoARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDkAE3AAkgAiABKQOoATcCICAAQbSYgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAQLDIMDCyABKQK0AiEcIAEpArwCDAELIAEpArgCIRwgASgCtAIhAiABKQLAAgs3AgwgACAcNwIEIAAgAjYCAAsgAUHgAmokAAz6AgsgBSAGEOghIQYgCSwAASEHIAktAAIhAiADLQABIQUgAy0AAiEDIwBBsAJrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAsAgA8BMBEAgASAFOgBEIAEgBToAuAEgASADOgC5ASABQdABakIKQgAQsi4gAUGAAmogASkD0AEgASkD2AEgASkD4AEgASkD6AEgAyACayICwBDfASABKAKAAkEBRgRAIAEpA4gCIRsgASgChAIhAiABKQOQAgwNCyABIAEpA6gCNwOoASABIAEpA6ACNwOgASABIAEpA5gCNwOYASABIAEpA5ACNwOQASABIAFBkAFqNgLIASACIAdqwCAFwEoEQCAELQA0DQQgASABQcQAajYCMCABIAFBuAFqNgIsIAEgAUHIAWo2AiggAUGAAmogBiABQShqEMIHIAEtAIACIgRBKUcNAgwMCyABQYACaiAFIAMQzw4gASgCgAIiAkGTgICAeEcNCiABQdABaiAGIAFBkAFqEMsfDAcLIAEgBToAtQEgASAFOgC2ASABIAM6ALcBIAEgAiADayIJwCICNgLIAUIKIRwgAUIKNwMoQgEhGwNAAkAgAkEBcQRAIAFBEGogGyAbQj+HIBwgHEI/hxCoHiABKQMYIAEpAxAiG0I/h1INBCACQQFGDQELIAEgHCAcQj+HIh0gHCAdEKgeIAEpAwggASkDACIcQj+HUg0DIAJBAXYhAgwBCwsgASAbNwO4ASABIBtCAn8iGzcDwAEgAUIAIBt9NwPIASABIAFByAFqNgIwIAEgAUHAAWo2AiwgASABQbgBajYCKCAHIAlrwCAFwE4EQCAELQA0DQQgASABQbUBajYCUCABIAFBtgFqNgJMIAEgAUEoajYCSCABQYACaiAGIAFByABqEP0DIAEtAIACIgRBKUYNCyABQcYAaiABLQCDAiICOgAAIAFBoAFqIAFBqAJqKQIANwMAIAFBmAFqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsBRCABIBs3A5ABIAEoAoQCIQIgASkCiAIhGyABKQKQAiEcDAYLIAFBgAJqIAUgAxDPDiABKAKAAiICQZOAgIB4Rw0JIAFB0AFqIAYgAUEoahDQHwwECyABQcIBaiABLQCDAiICOgAAIAFB2ABqIAFBqAJqKQIANwMAIAFB0ABqIAFBoAJqKQIANwMAIAEgAjoA0wEgASABLwCBAiICOwDRASABIAEpApgCIhs3AugBIAEgAjsBwAEgASAbNwNIIAEoAoQCIQIgASkCiAIhGyABKQKQAiEcDAYLIAFBAjYChAIgAUGImIABNgKAAiABQgI3AowCIAFB+g82AlQgAUH9DzYCTCABIAFByABqNgKIAiABIAFByAFqNgJQIAEgAUEoajYCSCABQdQBaiABQYACahCZDiABKQLUASEbQYiAgIB4IQIgASkC3AEMCQsgAUHQAWogBiABQcgBaiABQcQAahD0BAwDCyABQdABaiAGIAFBKGogAUG1AWoQ/QQLIAFBxgBqIAEtANMBOgAAIAFBmAFqIAFB8AFqKQIANwMAIAFBoAFqIAFB+AFqKQIANwMAIAEgAS8A0QE7AUQgASABKQLoATcDkAEgASkC2AEhGyABKALUASECIAEpAuABIhwgAS0A0AEiBEEpRg0GGgsgAUHKAWogAUHGAGotAAA6AAAgAUEwaiABQZgBaikDADcDACABQThqIAFBoAFqKQMANwMAIAEgAS8BRDsByAEgASABKQOQATcDKAwCCyABQcIBaiABLQDTAToAACABQdAAaiABQfABaikCADcDACABQdgAaiABQfgBaikCADcDACABIAEvANEBOwHAASABIAEpAugBNwNIIAEpAtgBIRsgASgC1AEhAiABKQLgASIcIAEtANABIgRBKUYNBBoLIAFBygFqIAFBwgFqLQAAOgAAIAFBMGogAUHQAGopAwA3AwAgAUE4aiABQdgAaikDADcDACABIAEvAcABOwHIASABIAEpA0g3AygLIAFBoAJqIAFBMGopAwA3AgAgAUGoAmogAUE4aikDADcCACABIAQ6AIACIAEgAS8ByAE7AIECIAEgHDcCkAIgASAbNwKIAiABIAI2AoQCIAEgASkDKDcCmAIgASABQcoBai0AADoAgwIgAUHQAWogAUGAAmogBSADEKMTIAEtANABIgNBKUYEQCABQfMAaiABQeQBaigCACICNgAAIAFB6wBqIAFB3AFqKQIAIhs3AAAgASABKQLUASIcNwBjIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLIAFB7wBqIgQgAUHgAWopAAA3AAAgAUHoAGoiBSABQdkBaikAADcDACABQYABaiIGIAFB8AFqKQIANwMAIAFBiAFqIgcgAUH4AWopAgA3AwAgASABKQDRATcDYCABIAEpAugBNwN4ELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNgNwAJIAIgASkDeDcCICAAQYyZgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAQLDIIDCyABKQKEAiEbIAEpAowCDAELIAEpAogCIRsgASgChAIhAiABKQKQAgs3AgwgACAbNwIEIAAgAjYCAAsgAUGwAmokAAz5AgsgDUENa0H/AXFBB0kNCyAJQQJqIQIjAEFAaiIBJAAgASADNgIQIAEgCTYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIAItAAAgBBCmAgwMCyAAIAUgBiACLQAAIAQQoQIMCwsgACAFIAYgAi0AACAEEKICDAoLIAAgBSAGIAItAAAgBBC/AgwJCyAAIAUgBiACLQAAIAQQpwIMCAsgACAFIAYgAi0AACAEEKQCDAcLIAAgBSAGIAItAAAgBBClAgwGCyAAIAUgBiACLQAAIAQQqAIMBQsgACAFIAYgAUE/aiACENUgDAQLIAAgBSAGIAFBP2ogAhDSIAwDCyAAIAUgBiAEEJEJDAILIAAgBSAGIAQQkgkMAQsgACAFIAYgBBCnAQsgAUFAayQADPgCCyAFIAYQ/CEhCiAJLAABIQsgCS0AAiEJIAMtAAEhBSADLQACIQYjAEHgAmsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCcAgBsBMBEAgASAFOgC+ASABIAU6AGwgASAGOgBtIAEgBiAJayIMwCICNgLQAkEKIQcgAUEKNgLAAUEBIQMCQCAGIAlGDQADQCACQQFxBEAgA6wgB6x+IhtCIIinIBunIgNBH3VHDQQgAkEBRg0CCyAHrCIbIBt+IhtCIIinIBunIgdBH3VHDQMgAkEBdiECDAALAAsgASADNgLEAiABIAFBxAJqNgLQAiALIAxqwCAFwEoEQCAELQA0DQYgASABQb4BajYCWCABIAFB7ABqNgJUIAEgAUHQAmo2AlAgAUGUAmogCiABQdAAahC7ByABLQCUAiIHQSlHDQMgASkCpAIhGyABKAKgAiEDIAEoApwCIQQgASgCmAIhAgwMCyABQZQCaiAFIAYQzg4gASgClAIiAkGTgICAeEcEQCABKQKgAiEbIAEoApwCIQMgASgCmAIhBAwMCyABQeQBaiAKIAFBxAJqEKsdDAoLIAEgBToAvQEgASAFOgC+ASABIAY6AL8BIAEgCSAGayIDwCICNgLEAiABQgA3A9gCQgohGyABQgo3A9ACQgEhHgNAAkAgAkEBcQRAIAFBADYCTCABQTBqIB4gHSAbIBwgAUHMAGoQ9gwgASgCTA0FIAEpAzghHSABKQMwIR4gAkEBRg0BCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0EIAEpAwghHCABKQMAIRsgAkEBdiECDAELCyABIB43A8ABIAEgHTcDyAEgAUEgaiAeIB1CAkIAEIMZIAEgASkDICIbNwPQAiABIAEpAygiHDcD2AIgAUIAIBt9NwNQIAFCACAcIBtCAFKtfH03A1ggASABQdAAajYC4AEgASABQdACajYC3AEgASABQcABajYC2AEgCyADa8AgBcBOBEAgBC0ANA0GIAEgAUG9AWo2AswCIAEgAUG+AWo2AsgCIAEgAUHYAWo2AsQCIAFBlAJqIAogAUHEAmoQugcgAS0AlAIiB0EpRw0EIAEpAqQCIRsgASkCnAIhHCABKAKYAiECDAgLIAFBlAJqIAUgBhDODiABKAKUAiICQZOAgIB4RwRAIAEpAqACIRsgASkCmAIhHAwICyABQeQBaiAKIAFB2AFqEKodDAYLIAFBAjYCmAIgAUGImIABNgKUAiABQgI3AqACIAFB+g82AlwgAUH8DzYCVCABIAFB0ABqNgKcAiABIAFB0AJqNgJYIAEgAUHAAWo2AlAgAUHoAWogAUGUAmoQmQ4gASgC6AEhBCABKALsASEDIAEpAvABIRtBiICAgHghAgwJCyABQYQCaiABQbQCaikCACIcNwIAIAFBjAJqIAFBvAJqKQIAIh03AgAgAUHaAWogAS0AlwIiAjoAACABIAI6AOcBIAEgAS8AlQIiAjsA5QEgASABKQKsAiIeNwL8ASABIAI7AdgBIAEoApgCIQIgASgCnAIhBCABKAKgAiEDIAEpAqQCIRsgAUGAAWogHTcDACABQfgAaiAcNwMAIAEgHjcDcAwKCyABQQI2ApgCIAFBiJiAATYClAIgAUICNwKgAiABQfoPNgJcIAFB+w82AlQgASABQdAAajYCnAIgASABQcQCajYCWCABIAFB0AJqNgJQIAFB6AFqIAFBlAJqEJkOIAEpAugBIRwgASkC8AEhG0GIgICAeCECDAQLIAFB7gBqIAEtAJcCIgI6AAAgAUGAAWogAUG8AmopAgA3AwAgAUH4AGogAUG0AmopAgA3AwAgASACOgDnASABIAEvAJUCIgI7AOUBIAEgASkCrAIiGzcC/AEgASACOwFsIAEgGzcDcCABKAKYAiECIAEpApwCIRwgASkCpAIhGwwECyABQeQBaiAKIAFB0AJqIAFBvgFqEM4EDAQLIAFB5AFqIAogAUHYAWogAUG9AWoQ5gQLIAFB7gBqIAEtAOcBOgAAIAFB+ABqIAFBhAJqKQIANwMAIAFBgAFqIAFBjAJqKQIANwMAIAEgAS8A5QE7AWwgASABKQL8ATcDcCABKQL0ASEbIAEpAuwBIRwgASgC6AEhAiABLQDkASIHQSlHDQELIAAgHDcCBAwDCyABQdICaiABQe4Aai0AADoAACABQdgAaiABQfgAaikDADcDACABQeAAaiABQYABaikDADcDACABIAEvAWw7AdACIAEgASkDcDcDUAwECyABQdoBaiABLQDnAToAACABQfgAaiABQYQCaikCADcDACABQYABaiABQYwCaikCADcDACABIAEvAOUBOwHYASABIAEpAvwBNwNwIAEpAvQBIRsgASgC8AEhAyABKALsASEEIAEoAugBIQIgAS0A5AEiB0EpRw0CCyAAIAM2AgggACAENgIECyAAIAI2AgAgACAbNwIMDAILIAFB0gJqIAFB2gFqLQAAOgAAIAFB2ABqIAFB+ABqKQMANwMAIAFB4ABqIAFBgAFqKQMANwMAIAEgAS8B2AE7AdACIAEgASkDcDcDUCAErSADrUIghoQhHAsgAUG0AmogAUHYAGopAwA3AgAgAUG8AmogAUHgAGopAwA3AgAgASAHOgCUAiABIAEvAdACOwCVAiABIBs3AqQCIAEgHDcCnAIgASACNgKYAiABIAEpA1A3AqwCIAEgAUHSAmotAAA6AJcCIAFB5AFqIAFBlAJqIAUgBhCgEyABLQDkASIDQSlGBEAgAUGbAWogAUH4AWooAgAiAjYAACABQZMBaiABQfABaikCACIbNwAAIAEgASkC6AEiHDcAiwEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUGXAWoiBCABQfQBaikAADcAACABQZABaiIFIAFB7QFqKQAANwMAIAFBqAFqIgYgAUGEAmopAgA3AwAgAUGwAWoiByABQYwCaikCADcDACABIAEpAOUBNwOIASABIAEpAvwBNwOgARCwPkE4QQQQrTYiAkUN/gIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQOIATcACSACIAEpA6ABNwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4AJqJAAMAAsM9wILIAUgBhD8ISEGIAksAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQYADayIBJAACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHwCADwEwEQCABIAU6AN4BIAEgBToAjAEgASADOgCNASABIAMgB2siCcAiAjYC5AJCCiEbIAFCCjcD8AJCASEdAkAgAyAHRg0AA0AgAkEBcQRAIAFB4ABqIB0gHUI/hyAbIBtCP4cQqB4gASkDaCABKQNgIh1CP4dSDQQgAkEBRg0CCyABQdAAaiAbIBtCP4ciHCAbIBwQqB4gASkDWCABKQNQIhtCP4dSDQMgAkEBdiECDAALAAsgASAdNwPgASABIAFB4AFqNgLwAiAJIApqwCAFwEoEQCAELQA0DQYgASABQd4BajYCeCABIAFBjAFqNgJ0IAEgAUHwAmo2AnAgAUG0AmogBiABQfAAahCvByABLQC0AiIEQSlHDQMMDgsgAUG0AmogBSADEM0OIAEoArQCIgJBk4CAgHhHDQwgAUGEAmogBiABQeABahCnHQwJCyABIAU6AN0BIAEgBToA3gEgASADOgDfASABIAcgA2siB8AiAjYC5AIgAUIANwP4AkIKIRsgAUIKNwPwAkIBIR4DQAJAIAJBAXEEQCABQQA2AkwgAUEwaiAeIB0gGyAcIAFBzABqEPYMIAEoAkwNBSABKQM4IR0gASkDMCEeIAJBAUYNAQsgAUEANgIcIAEgGyAcIBsgHCABQRxqEPYMIAEoAhwNBCABKQMIIRwgASkDACEbIAJBAXYhAgwBCwsgASAeNwPgASABIB03A+gBIAFBIGogHiAdQgJCABCDGSABIAEpAyAiGzcD8AIgASABKQMoIhw3A/gCIAFCACAbfTcDcCABQgAgHCAbQgBSrXx9NwN4IAEgAUHwAGo2AoACIAEgAUHwAmo2AvwBIAEgAUHgAWo2AvgBIAogB2vAIAXATgRAIAQtADQNBiABIAFB3QFqNgLsAiABIAFB3gFqNgLoAiABIAFB+AFqNgLkAiABQbQCaiAGIAFB5AJqELAHIAEtALQCIgRBKUYNDSABQY4BaiABLQC3AiICOgAAIAFBoAFqIAFB3AJqKQIANwMAIAFBmAFqIAFB1AJqKQIANwMAIAEgAjoAhwIgASABLwC1AiICOwCFAiABIAEpAswCIhs3ApwCIAEgAjsBjAEgASAbNwOQASABKAK4AiECIAEpArwCIRwgASkCxAIhGwwICyABQbQCaiAFIAMQzQ4gASgCtAIiAkGTgICAeEcNCyABQYQCaiAGIAFB+AFqEKYdDAYLIAFBAjYCuAIgAUGImIABNgK0AiABQgI3AsACIAFB+g82AnwgAUH9DzYCdAwCCyABQfoBaiABLQC3AiICOgAAIAFBoAFqIAFB3AJqKQIANwMAIAFBmAFqIAFB1AJqKQIANwMAIAEgAjoAhwIgASABLwC1AiICOwCFAiABIAEpAswCIhs3ApwCIAEgAjsB+AEgASAbNwOQASABKAK4AiECIAEpArwCIRwgASkCxAIhGwwHCyABQQI2ArgCIAFBiJiAATYCtAIgAUICNwLAAiABQfoPNgJ8IAFB+w82AnQLIAEgAUHwAGo2ArwCIAEgAUHkAmo2AnggASABQfACajYCcCABQYgCaiABQbQCahCZDiABKQKIAiEcQYiAgIB4IQIgASkCkAIMCQsgAUGEAmogBiABQfACaiABQd4BahDHBAwDCyABQYQCaiAGIAFB+AFqIAFB3QFqEPgECyABQY4BaiABLQCHAjoAACABQZgBaiABQaQCaikCADcDACABQaABaiABQawCaikCADcDACABIAEvAIUCOwGMASABIAEpApwCNwOQASABKQKMAiEcIAEoAogCIQIgASkClAIiGyABLQCEAiIEQSlGDQYaCyABQfICaiABQY4Bai0AADoAACABQfgAaiABQZgBaikDADcDACABQYABaiABQaABaikDADcDACABIAEvAYwBOwHwAgwCCyABQfoBaiABLQCHAjoAACABQZgBaiABQaQCaikCADcDACABQaABaiABQawCaikCADcDACABIAEvAIUCOwH4ASABIAEpApwCNwOQASABKQKMAiEcIAEoAogCIQIgASkClAIiGyABLQCEAiIEQSlGDQQaCyABQfICaiABQfoBai0AADoAACABQfgAaiABQZgBaikDADcDACABQYABaiABQaABaikDADcDACABIAEvAfgBOwHwAgsgASABKQOQATcDcCABQdQCaiABQfgAaikDADcCACABQdwCaiABQYABaikDADcCACABIAQ6ALQCIAEgAS8B8AI7ALUCIAEgGzcCxAIgASAcNwK8AiABIAI2ArgCIAEgASkDcDcCzAIgASABQfICai0AADoAtwIgAUGEAmogAUG0AmogBSADEKITIAEtAIQCIgNBKUYEQCABQbsBaiABQZgCaigCACICNgAAIAFBswFqIAFBkAJqKQIAIhs3AAAgASABKQKIAiIcNwCrASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECyABQbcBaiIEIAFBlAJqKQAANwAAIAFBsAFqIgUgAUGNAmopAAA3AwAgAUHIAWoiBiABQaQCaikCADcDACABQdABaiIHIAFBrAJqKQIANwMAIAEgASkAhQI3A6gBIAEgASkCnAI3A8ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQOoATcACSACIAEpA8ABNwIgIABBvJqAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBAsM/wILIAEpArgCIRwgASkCwAIMAQsgASkCvAIhHCABKAK4AiECIAEpAsQCCzcCDCAAIBw3AgQgACACNgIACyABQYADaiQADPYCCyAFIAYQ/CEhBiAJLQABIQogCS0AAiEHIAMtAAEhBSADLQACIQMjAEHAA2siASQAAkACQAJAAkACQAJAAkACQAJAAkAgAyAHRiAFIApPcUUEQAJAAkACQAJAIAfAIAPASgRAIAEgBToAlQIgASAFOgCWAiABIAM6AJcCIAEgByADayIHwCICNgKkAiABQgA3A6gDQgohGyABQgo3A6ADQgEhHQNAAkAgAkEBcQRAIAFBADYCTCABQTBqIB0gHiAbIBwgAUHMAGoQ9gwgASgCTA0EIAEpAzghHiABKQMwIR0gAkEBRg0BCyABQQA2AhwgASAbIBwgGyAcIAFBHGoQ9gwgASgCHA0DIAEpAwghHCABKQMAIRsgAkEBdiECDAELCyABIB03A7ACIAEgHjcDuAIgAUEgaiAdIB5CAkIAEIMZIAEgASkDICIbNwOgAyABIAEpAygiHDcDqAMgAUIAIBt9NwOwAyABQgAgHCAbQgBSrXx9NwO4AyABIAFBsANqNgKgAiABIAFBoANqNgKcAiABIAFBsAJqNgKYAiAKIAdrwCAFwE4EQCAELQA0DQcgASABQZUCajYCrAIgASABQZYCajYCqAIgASABQZgCajYCpAIgAUHwAmogBiABQaQCahCHAyABLQDwAiIEQSlHDQMgASkCgAMhGyABKQL4AiEcIAEoAvQCIQIMDQsgAUHwAmogBSADEMwOIAEoAvACIgJBk4CAgHhHBEAgASkC/AIhGyABKQL0AiEcDA0LIAFBwAJqIAYgAUGYAmoQqB0MCwsgASAFOgCWAiABIAU6ANwBIAEgAzoA3QEgASADIAdrIgnAIgI2AqQCIAFCADcDqANCCiEbIAFCCjcDoANCASEdAkAgAyAHRg0AA0AgAkEBcQRAIAFBADYCjAEgAUHwAGogHSAeIBsgHCABQYwBahD2DCABKAKMAQ0FIAEpA3ghHiABKQNwIR0gAkEBRg0CCyABQQA2AmwgAUHQAGogGyAcIBsgHCABQewAahD2DCABKAJsDQQgASkDWCEcIAEpA1AhGyACQQF2IQIMAAsACyABIB03A7ACIAEgHjcDuAIgASABQbACajYCoAMgCSAKasAgBcBKBEAgBC0ANA0HIAEgAUGWAmo2ArgDIAEgAUHcAWo2ArQDIAEgAUGgA2o2ArADIAFB8AJqIAYgAUGwA2oQvgcgAS0A8AIiBEEpRw0EIAEpAoADIRsgASkC+AIhHCABKAL0AiECDAkLIAFB8AJqIAUgAxDMDiABKALwAiICQZOAgIB4RwRAIAEpAvwCIRsgASkC9AIhHAwJCyABQcACaiAGIAFBsAJqELEdDAcLIAFBAjYC9AIgAUGImIABNgLwAiABQgI3AvwCIAFB+g82ArwDIAFB+w82ArQDIAEgAUGwA2o2AvgCIAEgAUGkAmo2ArgDIAEgAUGgA2o2ArADIAFBxAJqIAFB8AJqEJkOIAEpAsQCIRwgASkCzAIhG0GIgICAeCECDAoLIAFB3gFqIAEtAPMCIgI6AAAgAUHQAWogAUGYA2opAgA3AwAgAUHIAWogAUGQA2opAgA3AwAgASACOgDDAiABIAEvAPECIgI7AMECIAEgASkCiAMiGzcC2AIgASACOwHcASABIBs3A8ABIAEoAvQCIQIgASkC+AIhHCABKQKAAyEbDAoLIAFBAjYC9AIgAUGImIABNgLwAiABQgI3AvwCIAFB+g82ArwDIAFB+w82ArQDIAEgAUGwA2o2AvgCIAEgAUGkAmo2ArgDIAEgAUGgA2o2ArADIAFBxAJqIAFB8AJqEJkOIAEpAsQCIRwgASkCzAIhG0GIgICAeCECDAULIAFBmgJqIAEtAPMCIgI6AAAgAUHQAWogAUGYA2opAgA3AwAgAUHIAWogAUGQA2opAgA3AwAgASACOgDDAiABIAEvAPECIgI7AMECIAEgASkCiAMiGzcC2AIgASACOwGYAiABIBs3A8ABIAEoAvQCIQIgASkC+AIhHCABKQKAAyEbDAULIAFBkAFqIAYQgBUMCAsgAUHAAmogBiABQZgCaiABQZUCahDCBAwECyABQcACaiAGIAFBoANqIAFBlgJqEOQECyABQZoCaiABLQDDAjoAACABQcgBaiABQeACaikCADcDACABQdABaiABQegCaikCADcDACABIAEvAMECOwGYAiABIAEpAtgCNwPAASABKQLQAiEbIAEpAsgCIRwgASgCxAIhAiABLQDAAiIEQSlHDQELIAAgGzcCDCAAIBw3AgQgACACNgIADAULIAFBsAFqIAFByAFqKQMANwIAIAFBuAFqIAFB0AFqKQMANwIAIAEgAS8BmAI7AJEBIAEgASkDwAE3AqgBIAEgAUGaAmotAAA6AJMBIAEgGzcCoAEgASAcNwKYASABIAI2ApQBIAEgBDoAkAEMAwsgAUHeAWogAS0AwwI6AAAgAUHIAWogAUHgAmopAgA3AwAgAUHQAWogAUHoAmopAgA3AwAgASABLwDBAjsB3AEgASABKQLYAjcDwAEgASkC0AIhGyABKQLIAiEcIAEoAsQCIQIgAS0AwAIiBEEpRw0BCyAAIBs3AgwgACAcNwIEIAAgAjYCAAwCCyABQbABaiABQcgBaikDADcCACABQbgBaiABQdABaikDADcCACABIAEvAdwBOwCRASABIAEpA8ABNwKoASABIAFB3gFqLQAAOgCTASABIBs3AqABIAEgHDcCmAEgASACNgKUASABIAQ6AJABCyABQfACaiABQZABaiAFIAMQoRMgAS0A8AIiA0EpRgRAIAFB8wFqIAFBhANqKAIAIgI2AAAgAUHrAWogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB7wFqIgQgAUGAA2opAAA3AAAgAUHoAWoiBSABQfkCaikAADcDACABQYACaiIGIAFBkANqKQIANwMAIAFBiAJqIgcgAUGYA2opAgA3AwAgASABKQDxAjcD4AEgASABKQKIAzcD+AEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA+ABNwAJIAIgASkD+AE3AiAgAEG0mIABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwBCwz7AgsgAUHAA2okAAz1AgsgBSAGEPwhIQYgCSwAASEHIAktAAIhAiADLQABIQUgAy0AAiEDIwBBgANrIgEkAAJAIAACfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAsAgA8BMBEAgASAFOgBsIAEgBToAhAIgASADOgCFAiABQZACakIKQgAQsi4gAUHAAmogASkDkAIgASkDmAIgASkDoAIgASkDqAIgAyACayICwBDfASABKALAAkEBRgRAIAEpA8gCIRsgASgCxAIhAiABKQPQAgwNCyABIAEpA+gCNwPYASABIAEpA+ACNwPQASABIAEpA9gCNwPIASABIAEpA9ACNwPAASABIAFBwAFqNgLwASACIAdqwCAFwEoEQCAELQA0DQQgASABQewAajYCWCABIAFBhAJqNgJUIAEgAUHwAWo2AlAgAUHAAmogBiABQdAAahC2ByABLQDAAiIEQSlHDQIMDAsgAUHAAmogBSADEM8OIAEoAsACIgJBk4CAgHhHDQogAUGQAmogBiABQcABahCsHQwHCyABIAU6AO0BIAEgBToA7gEgASADOgDvASABIAIgA2siCcAiAjYC9AIgAUIANwNYQgohHCABQgo3A1BCASEeA0ACQCACQQFxBEAgAUEANgJMIAFBMGogHiAdIBwgGyABQcwAahD2DCABKAJMDQQgASkDOCEdIAEpAzAhHiACQQFGDQELIAFBADYCHCABIBwgGyAcIBsgAUEcahD2DCABKAIcDQMgASkDCCEbIAEpAwAhHCACQQF2IQIMAQsLIAEgHjcD8AEgASAdNwP4ASABQSBqIB4gHUICQgAQgxkgASABKQMgIhs3A1AgASABKQMoIhw3A1ggAUIAIBt9NwNwIAFCACAcIBtCAFKtfH03A3ggASABQfAAajYCjAIgASABQdAAajYCiAIgASABQfABajYChAIgByAJa8AgBcBOBEAgBC0ANA0EIAEgAUHtAWo2AvwCIAEgAUHuAWo2AvgCIAEgAUGEAmo2AvQCIAFBwAJqIAYgAUH0AmoQ7AIgAS0AwAIiBEEpRg0LIAFB7gBqIAEtAMMCIgI6AAAgAUHQAWogAUHoAmopAgA3AwAgAUHIAWogAUHgAmopAgA3AwAgASACOgCTAiABIAEvAMECIgI7AJECIAEgASkC2AIiGzcCqAIgASACOwFsIAEgGzcDwAEgASgCxAIhAiABKQLIAiEbIAEpAtACIRwMBgsgAUHAAmogBSADEM8OIAEoAsACIgJBk4CAgHhHDQkgAUGQAmogBiABQYQCahC2HQwECyABQfYCaiABLQDDAiICOgAAIAFBgAFqIAFB6AJqKQIANwMAIAFB+ABqIAFB4AJqKQIANwMAIAEgAjoAkwIgASABLwDBAiICOwCRAiABIAEpAtgCIhs3AqgCIAEgAjsB9AIgASAbNwNwIAEoAsQCIQIgASkCyAIhGyABKQLQAiEcDAYLIAFBAjYCxAIgAUGImIABNgLAAiABQgI3AswCIAFB+g82AnwgAUH7DzYCdCABIAFB8ABqNgLIAiABIAFB9AJqNgJ4IAEgAUHQAGo2AnAgAUGUAmogAUHAAmoQmQ4gASkClAIhG0GIgICAeCECIAEpApwCDAkLIAFBkAJqIAYgAUHwAWogAUHsAGoQ4AQMAwsgAUGQAmogBiABQYQCaiABQe0BahD3BAsgAUHuAGogAS0AkwI6AAAgAUHIAWogAUGwAmopAgA3AwAgAUHQAWogAUG4AmopAgA3AwAgASABLwCRAjsBbCABIAEpAqgCNwPAASABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQYaCyABQfIBaiABQe4Aai0AADoAACABQdgAaiABQcgBaikDADcDACABQeAAaiABQdABaikDADcDACABIAEvAWw7AfABIAEgASkDwAE3A1AMAgsgAUH2AmogAS0AkwI6AAAgAUH4AGogAUGwAmopAgA3AwAgAUGAAWogAUG4AmopAgA3AwAgASABLwCRAjsB9AIgASABKQKoAjcDcCABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQQaCyABQfIBaiABQfYCai0AADoAACABQdgAaiABQfgAaikDADcDACABQeAAaiABQYABaikDADcDACABIAEvAfQCOwHwASABIAEpA3A3A1ALIAFB4AJqIAFB2ABqKQMANwIAIAFB6AJqIAFB4ABqKQMANwIAIAEgBDoAwAIgASABLwHwATsAwQIgASAcNwLQAiABIBs3AsgCIAEgAjYCxAIgASABKQNQNwLYAiABIAFB8gFqLQAAOgDDAiABQZACaiABQcACaiAFIAMQoxMgAS0AkAIiA0EpRgRAIAFBowFqIAFBpAJqKAIAIgI2AAAgAUGbAWogAUGcAmopAgAiGzcAACABIAEpApQCIhw3AJMBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLIAFBnwFqIgQgAUGgAmopAAA3AAAgAUGYAWoiBSABQZkCaikAADcDACABQbABaiIGIAFBsAJqKQIANwMAIAFBuAFqIgcgAUG4AmopAgA3AwAgASABKQCRAjcDkAEgASABKQKoAjcDqAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA5ABNwAJIAIgASkDqAE3AiAgAEGMmYABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwz9AgsgASkCxAIhGyABKQLMAgwBCyABKQLIAiEbIAEoAsQCIQIgASkC0AILNwIMIAAgGzcCBCAAIAI2AgALIAFBgANqJAAM9AILIA1BDWtB/wFxQQdJDQYgCUECaiECIwBBQGoiASQAIAEgAzYCECABIAk2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAADhsBAAIDBAUGBwgJAAoLAAAAAAAAAAAAAAAMDQ4ACyABQQM2AhggAUHY3/8ANgIUIAFCAjcCICABQa8DNgI4IAFBrwM2AjAgASABQSxqNgIcIAEgAUEQajYCNCABIAFBDGo2AiwgAEEEaiABQRRqEJkOIABBgoCAgHg2AgAMDgsgASADIAUgBigCJBEEABChKyAAIAEpAwA3AgQgAEGTgICAeDYCAAwNCyAAIAUgBiACLQAAIAQQ9gEMDAsgACAFIAYgAi0AACAEEPIBDAsLIAAgBSAGIAItAAAgBBDxAQwKCyAAIAUgBiACLQAAIAQQ/AEMCQsgACAFIAYgAi0AACAEEPsBDAgLIAAgBSAGIAItAAAgBBD6AQwHCyAAIAUgBiACLQAAIAQQ+QEMBgsgACAFIAYgAi0AACAEEJICDAULIAAgBSAGIAFBP2ogAhDUIAwECyAAIAUgBiABQT9qIAIQ2CAMAwsgACAFIAYgBBCRCQwCCyAAIAUgBiAEEJIJDAELIAAgBSAGIAQQpwELIAFBQGskAAzzAgsgBSAGEOMhIQogCSwAASELIAktAAIhCSADLQABIQYgAy0AAiEHIwBB4AJrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJwCAHwEwEQCABIAY6AF4gASAGOgAkIAEgBzoAJSABIAcgCWsiDMAiAjYCYEEKIQMgAUEKNgIIQQEhBQJAIAcgCUYNAANAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNBCACQQFGDQILIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNAyACQQF2IQIMAAsACyABIAU2AoQCIAEgAUGEAmo2AmAgCyAMasAgBsBKBEAgBC0ANA0FIAEgAUHeAGo2AogBIAEgAUEkajYChAEgASABQeAAajYCgAEgAUGQAmogCiABQYABahCzByABLQCQAiIEQSlHDQMgASkCoAIhGyABKAKcAiEDIAEoApgCIQUgASgClAIhAgwLCyABQZACaiAGIAcQzg4gASgCkAIiAkGTgICAeEcEQCABKQKcAiEbIAEoApgCIQMgASgClAIhBQwLCyABQdABaiAKIAFBhAJqEK8dDAkLIAEgBjoAXSABIAY6AF4gASAHOgBfIAFB0AFqQgpCABCyLiABQZACaiABKQPQASABKQPYASABKQPgASABKQPoASAJIAdrIgLAEN8BIAEoApACQQFGBEAgASkDoAIhGyABKQOYAiEcIAEoApQCIQIMBwsgASABKQO4AiIbNwN4IAEgASkDsAIiHDcDcCABIAEpA6gCIh03A2ggASABKQOgAiIeNwNgIAFBkAJqIgMQ7CwgASgCkAJBAXFFDZADIAMgHiAdIBwgGyABKQOgAiABKQOoAiABKQOwAiABKQO4AhCaCCABAn4gAS0AkAJBAUYEQCABLQCRAgRAQoCAgICAgICAgH8hHEIAIRtCACEdQgAMAgsgAUEANgLgASABQQE2AtQBIAFBjJSAATYC0AEgAUIENwLYASABQdABakGUlIABEO8sAAsgASkDuAIhHCABKQOwAiEdIAEpA6gCIRsgASkDoAILIh43A4ABIAEgGzcDiAEgASAdNwOQASABIBw3A5gBIAFCACAbIB5CAFKtfH0iGzcDqAEgAUIAIB59Ih43A6ABIAEgHkIAUiAbQgBSIBtQG0F/c61CAYMiGyAdQn+FfCIdNwOwASABIBsgHVatIBxCf4V8NwO4ASABIAFBoAFqNgLMASABIAFBgAFqNgLIASABIAFB4ABqNgLEASALIAJrwCAGwE4EQCAELQA0DQUgASABQd0AajYCjAIgASABQd4AajYCiAIgASABQcQBajYChAIgAUGQAmogCiABQYQCahCkAyABLQCQAiIEQSlHDQMgASkCoAIhGyABKQKYAiEcIAEoApQCIQIMBwsgAUGQAmogBiAHEM4OIAEoApACIgJBk4CAgHhHBEAgASkCnAIhGyABKQKUAiEcDAcLIAFB0AFqIAogAUHEAWoQqR0MBQsgAUECNgKUAiABQYiYgAE2ApACIAFCAjcCnAIgAUH6DzYCjAEgAUH8DzYChAEgASABQYABajYCmAIgASABQeAAajYCiAEgASABQQhqNgKAASABQdQBaiABQZACahCZDiABKALUASEFIAEoAtgBIQMgASkC3AEhG0GIgICAeCECDAgLIAFB8AFqIAFBsAJqKQIAIhw3AgAgAUH4AWogAUG4AmopAgAiHTcCACABQcYBaiABLQCTAiICOgAAIAEgAjoA0wEgASABLwCRAiICOwDRASABIAEpAqgCIh43AugBIAEgAjsBxAEgASgClAIhAiABKAKYAiEFIAEoApwCIQMgASkCoAIhGyABQbABaiAdNwMAIAFBqAFqIBw3AwAgASAeNwOgAQwJCyABQSZqIAEtAJMCIgI6AAAgAUEYaiABQbgCaikCADcDACABQRBqIAFBsAJqKQIANwMAIAEgAjoA0wEgASABLwCRAiICOwDRASABIAEpAqgCIhs3AugBIAEgAjsBJCABIBs3AwggASgClAIhAiABKQKYAiEcIAEpAqACIRsMBAsgAUHQAWogCiABQeAAaiABQd4AahD+BAwECyABQdABaiAKIAFBxAFqIAFB3QBqEJ8DCyABQSZqIAEtANMBOgAAIAFBEGogAUHwAWopAgA3AwAgAUEYaiABQfgBaikCADcDACABIAEvANEBOwEkIAEgASkC6AE3AwggASkC4AEhGyABKQLYASEcIAEoAtQBIQIgAS0A0AEiBEEpRw0BCyAAIBw3AgQMAwsgAUHiAGogAUEmai0AADoAACABQYgBaiABQRBqKQMANwMAIAFBkAFqIAFBGGopAwA3AwAgASABLwEkOwFgIAEgASkDCDcDgAEMBAsgAUHGAWogAS0A0wE6AAAgAUGoAWogAUHwAWopAgA3AwAgAUGwAWogAUH4AWopAgA3AwAgASABLwDRATsBxAEgASABKQLoATcDoAEgASkC4AEhGyABKALcASEDIAEoAtgBIQUgASgC1AEhAiABLQDQASIEQSlHDQILIAAgAzYCCCAAIAU2AgQLIAAgAjYCACAAIBs3AgwMAgsgAUHiAGogAUHGAWotAAA6AAAgAUGIAWogAUGoAWopAwA3AwAgAUGQAWogAUGwAWopAwA3AwAgASABLwHEATsBYCABIAEpA6ABNwOAASAFrSADrUIghoQhHAsgAUGwAmogAUGIAWopAwA3AgAgAUG4AmogAUGQAWopAwA3AgAgASAEOgCQAiABIAEvAWA7AJECIAEgGzcCoAIgASAcNwKYAiABIAI2ApQCIAEgASkDgAE3AqgCIAEgAUHiAGotAAA6AJMCIAFB0AFqIAFBkAJqIAYgBxCgEyABLQDQASIDQSlGBEAgAUE7aiABQeQBaigCACICNgAAIAFBM2ogAUHcAWopAgAiGzcAACABIAEpAtQBIhw3ACsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUE3aiIEIAFB4AFqKQAANwAAIAFBMGoiBSABQdkBaikAADcDACABQcgAaiIGIAFB8AFqKQIANwMAIAFB0ABqIgcgAUH4AWopAgA3AwAgASABKQDRATcDKCABIAEpAugBNwNAELA+QThBBBCtNiICRQ35AiACIAM6AAggAkKBgICAEDcCACACIAEpAyg3AAkgAiABKQNANwIgIABB5JmAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4AJqJAAMAAsM8gILIAUgBhDjISEGIAksAAEhCiAJLQACIQcgAy0AASEFIAMtAAIhAyMAQYADayIBJAACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAIAfAIAPATARAIAEgBToAfiABIAU6AEQgASADOgBFIAEgAyAHayIJwCICNgKkAkIKIRwgAUIKNwOAAUIBIR0CQCADIAdGDQADQCACQQFxBEAgAUEQaiAdIB1CP4cgHCAcQj+HEKgeIAEpAxggASkDECIdQj+HUg0EIAJBAUYNAgsgASAcIBxCP4ciGyAcIBsQqB4gASkDCCABKQMAIhxCP4dSDQMgAkEBdiECDAALAAsgASAdNwMoIAEgAUEoajYCgAEgCSAKasAgBcBKBEAgBC0ANA0EIAEgAUH+AGo2AqgBIAEgAUHEAGo2AqQBIAEgAUGAAWo2AqABIAFBsAJqIAYgAUGgAWoQuAcgAS0AsAIiBEEpRw0DDAwLIAFBsAJqIAUgAxDNDiABKAKwAiICQZOAgIB4Rw0KIAFB8AFqIAYgAUEoahC1HQwHCyABIAU6AH0gASAFOgB+IAEgAzoAfyABQfABakIKQgAQsi4gAUGwAmogASkD8AEgASkD+AEgASkDgAIgASkDiAIgByADayICwBDfASABKAKwAkEBRgRAIAEpA7gCIRsgASgCtAIhAiABKQPAAgwMCyABIAEpA9gCIhs3A5gBIAEgASkD0AIiHDcDkAEgASABKQPIAiIdNwOIASABIAEpA8ACIh43A4ABIAFBsAJqIgcQ7CwgASgCsAJBAXFFDY0DIAcgHiAdIBwgGyABKQPAAiABKQPIAiABKQPQAiABKQPYAhCaCCABAn4gAS0AsAJBAUYEQCABLQCxAgRAQoCAgICAgICAgH8hG0IAIR1CACEcQgAMAgsgAUEANgKAAiABQQE2AvQBIAFBjJSAATYC8AEgAUIENwL4ASABQfABakGUlIABEO8sAAsgASkD2AIhGyABKQPQAiEcIAEpA8gCIR0gASkDwAILIh43A6ABIAEgHTcDqAEgASAcNwOwASABIBs3A7gBIAFCACAdIB5CAFKtfH0iHTcDyAEgAUIAIB59Ih43A8ABIAEgHkIAUiAdQgBSIB1QG0F/c61CAYMiHSAcQn+FfCIcNwPQASABIBwgHVStIBtCf4V8NwPYASABIAFBwAFqNgLsASABIAFBoAFqNgLoASABIAFBgAFqNgLkASAKIAJrwCAFwE4EQCAELQA0DQQgASABQf0AajYCrAIgASABQf4AajYCqAIgASABQeQBajYCpAIgAUGwAmogBiABQaQCahD7AyABLQCwAiIEQSlGDQsgAUHGAGogAS0AswIiAjoAACABQThqIAFB2AJqKQIANwMAIAFBMGogAUHQAmopAgA3AwAgASACOgDzASABIAEvALECIgI7APEBIAEgASkCyAIiGzcCiAIgASACOwFEIAEgGzcDKCABKAK0AiECIAEpArgCIRsgASkCwAIhHAwGCyABQbACaiAFIAMQzQ4gASgCsAIiAkGTgICAeEcNCSABQfABaiAGIAFB5AFqELAdDAQLIAFBAjYCtAIgAUGImIABNgKwAiABQgI3ArwCIAFB+g82AqwBIAFB/Q82AqQBIAEgAUGgAWo2ArgCIAEgAUGkAmo2AqgBIAEgAUGAAWo2AqABIAFB9AFqIAFBsAJqEJkOIAEpAvQBIRtBiICAgHghAiABKQL8AQwKCyABQeYBaiABLQCzAiICOgAAIAFB0AFqIAFB2AJqKQIANwMAIAFByAFqIAFB0AJqKQIANwMAIAEgAjoA8wEgASABLwCxAiICOwDxASABIAEpAsgCIhs3AogCIAEgAjsB5AEgASAbNwPAASABKAK0AiECIAEpArgCIRsgASkCwAIhHAwFCyABQfABaiAGIAFBgAFqIAFB/gBqEO4EDAMLIAFB8AFqIAYgAUHkAWogAUH9AGoQowMLIAFBxgBqIAEtAPMBOgAAIAFBMGogAUGQAmopAgA3AwAgAUE4aiABQZgCaikCADcDACABIAEvAPEBOwFEIAEgASkCiAI3AyggASkC+AEhGyABKAL0ASECIAEpAoACIhwgAS0A8AEiBEEpRg0GGgsgAUGCAWogAUHGAGotAAA6AAAgAUGoAWogAUEwaikDADcDACABQbABaiABQThqKQMANwMAIAEgAS8BRDsBgAEgASABKQMoNwOgAQwCCyABQeYBaiABLQDzAToAACABQcgBaiABQZACaikCADcDACABQdABaiABQZgCaikCADcDACABIAEvAPEBOwHkASABIAEpAogCNwPAASABKQL4ASEbIAEoAvQBIQIgASkCgAIiHCABLQDwASIEQSlGDQQaCyABQYIBaiABQeYBai0AADoAACABQagBaiABQcgBaikDADcDACABQbABaiABQdABaikDADcDACABIAEvAeQBOwGAASABIAEpA8ABNwOgAQsgAUHQAmogAUGoAWopAwA3AgAgAUHYAmogAUGwAWopAwA3AgAgASAEOgCwAiABIAEvAYABOwCxAiABIBw3AsACIAEgGzcCuAIgASACNgK0AiABIAEpA6ABNwLIAiABIAFBggFqLQAAOgCzAiABQfABaiABQbACaiAFIAMQohMgAS0A8AEiA0EpRgRAIAFB2wBqIAFBhAJqKAIAIgI2AAAgAUHTAGogAUH8AWopAgAiGzcAACABIAEpAvQBIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUHXAGoiBCABQYACaikAADcAACABQdAAaiIFIAFB+QFqKQAANwMAIAFB6ABqIgYgAUGQAmopAgA3AwAgAUHwAGoiByABQZgCaikCADcDACABIAEpAPEBNwNIIAEgASkCiAI3A2AQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQNgNwIgIABBvJqAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBAsM+gILIAEpArQCIRsgASkCvAIMAQsgASkCuAIhGyABKAK0AiECIAEpAsACCzcCDCAAIBs3AgQgACACNgIACyABQYADaiQADPECCyAFIAYQ4yEhBiAJLAABIQogCS0AAiEHIAMtAAEhBSADLQACIQMjAEGgA2siASQAAkAgAAJ+AkACQAJAAkACQAJAAkACQAJAAkACQCAHwCADwEwEQCABIAU6AJ4BIAEgBToAZCABIAM6AGUgASADIAdrIgnAIgI2AsQCIAFCADcDqAFCCiEcIAFCCjcDoAFCASEeAkAgAyAHRg0AA0AgAkEBcQRAIAFBADYCPCABQSBqIB4gHSAcIBsgAUE8ahD2DCABKAI8DQQgASkDKCEdIAEpAyAhHiACQQFGDQILIAFBADYCHCABIBwgGyAcIBsgAUEcahD2DCABKAIcDQMgASkDCCEbIAEpAwAhHCACQQF2IQIMAAsACyABIB43A0AgASAdNwNIIAEgAUFAazYCoAEgCSAKasAgBcBKBEAgBC0ANA0EIAEgAUGeAWo2AsgBIAEgAUHkAGo2AsQBIAEgAUGgAWo2AsABIAFB0AJqIAYgAUHAAWoQsQcgAS0A0AIiBEEpRw0DDAwLIAFB0AJqIAUgAxDMDiABKALQAiICQZOAgIB4Rw0KIAFBkAJqIAYgAUFAaxCtHQwHCyABIAU6AJ0BIAEgBToAngEgASADOgCfASABQZACakIKQgAQsi4gAUHQAmogASkDkAIgASkDmAIgASkDoAIgASkDqAIgByADayICwBDfASABKALQAkEBRgRAIAEpA9gCIRsgASgC1AIhAiABKQPgAgwMCyABIAEpA/gCIhs3A7gBIAEgASkD8AIiHDcDsAEgASABKQPoAiIdNwOoASABIAEpA+ACIh43A6ABIAFB0AJqIgcQ7CwgASgC0AJBAXFFDYwDIAcgHiAdIBwgGyABKQPgAiABKQPoAiABKQPwAiABKQP4AhCaCCABAn4gAS0A0AJBAUYEQCABLQDRAgRAQoCAgICAgICAgH8hG0IAIR1CACEeQgAMAgsgAUEANgKgAiABQQE2ApQCIAFBjJSAATYCkAIgAUIENwKYAiABQZACakGUlIABEO8sAAsgASkD+AIhGyABKQPwAiEeIAEpA+gCIR0gASkD4AILIhw3A8ABIAEgHTcDyAEgASAeNwPQASABIBs3A9gBIAFCACAdIBxCAFKtfH0iHTcD6AEgAUIAIBx9Ihw3A+ABIAEgHEIAUiAdQgBSIB1QG0F/c61CAYMiHCAeQn+FfCIdNwPwASABIBwgHVatIBtCf4V8NwP4ASABIAFB4AFqNgKMAiABIAFBwAFqNgKIAiABIAFBoAFqNgKEAiAKIAJrwCAFwE4EQCAELQA0DQQgASABQZ0BajYCzAIgASABQZ4BajYCyAIgASABQYQCajYCxAIgAUHQAmogBiABQcQCahDaAyABLQDQAiIEQSlGDQsgAUHmAGogAS0A0wIiAjoAACABQdAAaiABQfgCaikCADcDACABQcgAaiABQfACaikCADcDACABIAI6AJMCIAEgAS8A0QIiAjsAkQIgASABKQLoAiIbNwKoAiABIAI7AWQgASAbNwNAIAEoAtQCIQIgASkC2AIhGyABKQLgAiEcDAYLIAFB0AJqIAUgAxDMDiABKALQAiICQZOAgIB4Rw0JIAFBkAJqIAYgAUGEAmoQsx0MBAsgAUECNgLUAiABQYiYgAE2AtACIAFCAjcC3AIgAUH6DzYCzAEgAUH7DzYCxAEgASABQcABajYC2AIgASABQcQCajYCyAEgASABQaABajYCwAEgAUGUAmogAUHQAmoQmQ4gASkClAIhG0GIgICAeCECIAEpApwCDAoLIAFBhgJqIAEtANMCIgI6AAAgAUHwAWogAUH4AmopAgA3AwAgAUHoAWogAUHwAmopAgA3AwAgASACOgCTAiABIAEvANECIgI7AJECIAEgASkC6AIiGzcCqAIgASACOwGEAiABIBs3A+ABIAEoAtQCIQIgASkC2AIhGyABKQLgAiEcDAULIAFBkAJqIAYgAUGgAWogAUGeAWoQ8QQMAwsgAUGQAmogBiABQYQCaiABQZ0BahCbAwsgAUHmAGogAS0AkwI6AAAgAUHIAGogAUGwAmopAgA3AwAgAUHQAGogAUG4AmopAgA3AwAgASABLwCRAjsBZCABIAEpAqgCNwNAIAEpApgCIRsgASgClAIhAiABKQKgAiIcIAEtAJACIgRBKUYNBhoLIAFBogFqIAFB5gBqLQAAOgAAIAFByAFqIAFByABqKQMANwMAIAFB0AFqIAFB0ABqKQMANwMAIAEgAS8BZDsBoAEgASABKQNANwPAAQwCCyABQYYCaiABLQCTAjoAACABQegBaiABQbACaikCADcDACABQfABaiABQbgCaikCADcDACABIAEvAJECOwGEAiABIAEpAqgCNwPgASABKQKYAiEbIAEoApQCIQIgASkCoAIiHCABLQCQAiIEQSlGDQQaCyABQaIBaiABQYYCai0AADoAACABQcgBaiABQegBaikDADcDACABQdABaiABQfABaikDADcDACABIAEvAYQCOwGgASABIAEpA+ABNwPAAQsgAUHwAmogAUHIAWopAwA3AgAgAUH4AmogAUHQAWopAwA3AgAgASAEOgDQAiABIAEvAaABOwDRAiABIBw3AuACIAEgGzcC2AIgASACNgLUAiABIAEpA8ABNwLoAiABIAFBogFqLQAAOgDTAiABQZACaiABQdACaiAFIAMQoRMgAS0AkAIiA0EpRgRAIAFB+wBqIAFBpAJqKAIAIgI2AAAgAUHzAGogAUGcAmopAgAiGzcAACABIAEpApQCIhw3AGsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUH3AGoiBCABQaACaikAADcAACABQfAAaiIFIAFBmQJqKQAANwMAIAFBiAFqIgYgAUGwAmopAgA3AwAgAUGQAWoiByABQbgCaikCADcDACABIAEpAJECNwNoIAEgASkCqAI3A4ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNoNwAJIAIgASkDgAE3AiAgAEG0mIABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwz5AgsgASkC1AIhGyABKQLcAgwBCyABKQLYAiEbIAEoAtQCIQIgASkC4AILNwIMIAAgGzcCBCAAIAI2AgALIAFBoANqJAAM8AILIAUgBhDjISEGIAktAAEhByAJLQACIQIgAy0AASEFIAMtAAIhAyMAQZADayIBJAACQAJAAkACQAJAAkACQAJAAkACQCACIANGIAUgB09xRQRAAkACQCACwCADwEoEQCABIAU6AI0BIAEgBToAjgEgASADOgCPASABQeACakIKQgAQsi4gAUHwAWogASkD4AIgASkD6AIgASkD8AIgASkD+AIgAiADayICwBDfASABKALwAUEBRgRAIAEpA4ACIRwgASkD+AEhGyABKAL0ASECDAsLIAEgASkDmAIiGzcDqAEgASABKQOQAiIcNwOgASABIAEpA4gCIh03A5gBIAEgASkDgAIiHjcDkAEgAUHwAWoiCRDsLCABKALwAUEBcUUNjAMgCSAeIB0gHCAbIAEpA4ACIAEpA4gCIAEpA5ACIAEpA5gCEJoIIAECfiABLQDwAUEBRgRAIAEtAPEBBEBCgICAgICAgICAfyEbQgAhHEIAIR1CAAwCCyABQQA2AvACIAFBATYC5AIgAUGMlIABNgLgAiABQgQ3AugCIAFB4AJqQZSUgAEQ7ywACyABKQOYAiEbIAEpA5ACIR0gASkDiAIhHCABKQOAAgsiHjcDsAEgASAcNwO4ASABIB03A8ABIAEgGzcDyAEgAUIAIBwgHkIAUq18fSIcNwPIAiABQgAgHn0iHjcDwAIgASAeQgBSIBxCAFIgHFAbQX9zrUIBgyIcIB1Cf4V8Ih03A9ACIAEgHCAdVq0gG0J/hXw3A9gCIAEgAUHAAmo2AuABIAEgAUGwAWo2AtwBIAEgAUGQAWo2AtgBIAcgAmvAIAXATgRAIAQtADQNBSABIAFBjQFqNgLsASABIAFBjgFqNgLoASABIAFB2AFqNgLkASABQfABaiAGIAFB5AFqEL8HIAEtAPABIgRBKUcNAiABKQKAAiEcIAEpAvgBIRsgASgC9AEhAgwLCyABQfABaiAFIAMQzw4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEcIAEpAvQBIRsMCwsgAUHgAmogBiABQdgBahC0HQwJCyABIAU6AFQgASAFOgDYASABIAM6ANkBIAFB4AJqQgpCABCyLiABQfABaiABKQPgAiABKQPoAiABKQPwAiABKQP4AiADIAJrIgLAEN8BIAEoAvABQQFGBEAgASkDgAIhHCABKQP4ASEbIAEoAvQBIQIMBwsgASABKQOYAjcD2AIgASABKQOQAjcD0AIgASABKQOIAjcDyAIgASABKQOAAjcDwAIgASABQcACajYCOCACIAdqwCAFwEoEQCAELQA0DQUgASABQdQAajYCmAEgASABQdgBajYClAEgASABQThqNgKQASABQfABaiAGIAFBkAFqEMAHIAEtAPABIgRBKUcNAiABKQKAAiEcIAEpAvgBIRsgASgC9AEhAgwHCyABQfABaiAFIAMQzw4gASgC8AEiAkGTgICAeEcEQCABKQL8ASEcIAEpAvQBIRsMBwsgAUHgAmogBiABQcACahCyHQwFCyABQdYAaiABLQDzASICOgAAIAFByABqIAFBmAJqKQIANwMAIAFBQGsgAUGQAmopAgA3AwAgASACOgDjAiABIAEvAPEBIgI7AOECIAEgASkCiAIiGzcC+AIgASACOwFUIAEgGzcDOCABKAL0ASECIAEpAvgBIRsgASkCgAIhHAwJCyABQeYBaiABLQDzASICOgAAIAFBwAFqIAFBmAJqKQIANwMAIAFBuAFqIAFBkAJqKQIANwMAIAEgAjoA4wIgASABLwDxASICOwDhAiABIAEpAogCIhs3AvgCIAEgAjsB5AEgASAbNwOwASABKAL0ASECIAEpAvgBIRsgASkCgAIhHAwFCyABQQhqIAYQgBUMCAsgAUHgAmogBiABQdgBaiABQY0BahCPAwwECyABQeACaiAGIAFBOGogAUHUAGoQ6gQLIAFB5gFqIAEtAOMCOgAAIAFBuAFqIAFBgANqKQIANwMAIAFBwAFqIAFBiANqKQIANwMAIAEgAS8A4QI7AeQBIAEgASkC+AI3A7ABIAEpAvACIRwgASkC6AIhGyABKALkAiECIAEtAOACIgRBKUcNAQsgACAcNwIMIAAgGzcCBCAAIAI2AgAMBQsgAUEoaiABQbgBaikDADcCACABQTBqIAFBwAFqKQMANwIAIAEgAS8B5AE7AAkgASABKQOwATcCICABIAFB5gFqLQAAOgALIAEgHDcCGCABIBs3AhAgASACNgIMIAEgBDoACAwDCyABQdYAaiABLQDjAjoAACABQUBrIAFBgANqKQIANwMAIAFByABqIAFBiANqKQIANwMAIAEgAS8A4QI7AVQgASABKQL4AjcDOCABKQLwAiEcIAEpAugCIRsgASgC5AIhAiABLQDgAiIEQSlHDQELIAAgHDcCDCAAIBs3AgQgACACNgIADAILIAFBKGogAUFAaykDADcCACABQTBqIAFByABqKQMANwIAIAEgAS8BVDsACSABIAEpAzg3AiAgASABQdYAai0AADoACyABIBw3AhggASAbNwIQIAEgAjYCDCABIAQ6AAgLIAFB8AFqIAFBCGogBSADEKMTIAEtAPABIgNBKUYEQCABQesAaiABQYQCaigCACICNgAAIAFB4wBqIAFB/AFqKQIAIhs3AAAgASABKQL0ASIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFB5wBqIgQgAUGAAmopAAA3AAAgAUHgAGoiBSABQfkBaikAADcDACABQfgAaiIGIAFBkAJqKQIANwMAIAFBgAFqIgcgAUGYAmopAgA3AwAgASABKQDxATcDWCABIAEpAogCNwNwELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNYNwAJIAIgASkDcDcCICAAQYyZgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAELDPUCCyABQZADaiQADO8CCyANQQ1rQf8BcUEHSQ0BIAhB0ABqQgpCABCyLiAIKQNQIRsgCCkDWCEcIAgpA2AhHSAIKQNoIR4gCUECaiECIAgoAkwhByAIKAJIIQMjAEFAaiIBJAAgASADNgIQIAEgBzYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDgALIAFBAzYCGCABQdjf/wA2AhQgAUICNwIgIAFBrwM2AjggAUGvAzYCMCABIAFBLGo2AhwgASABQRBqNgI0IAEgAUEMajYCLCAAQQRqIAFBFGoQmQ4gAEGCgICAeDYCAAwOCyABIAMgBSAGKAIkEQQAEKErIAAgASkDADcCBCAAQZOAgIB4NgIADA0LIAAgBSAGIBsgHCAdIB4gAi0AACAEEPUBDAwLIAAgBSAGIBsgHCAdIB4gAi0AACAEEO4BDAsLIAAgBSAGIBsgHCAdIB4gAi0AACAEEO8BDAoLIAAgBSAGIBsgHCAdIB4gAi0AACAEEIsCDAkLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPcBDAgLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPABDAcLIAAgBSAGIBsgHCAdIB4gAi0AACAEEPMBDAYLIAAgBSAGIBsgHCAdIB4gAi0AACAEEIwCDAULIAAgBSAGIAFBP2ogAhDWIAwECyAAIAUgBiABQT9qIAIQ0SAMAwsgACAFIAYgBBCRCQwCCyAAIAUgBiAEEJIJDAELIAAgBSAGIAQQpwELIAFBQGskAAzuAgsgCS0AASADLQABRw3kAiAFIAYQxy8hAiAJLQABIQwjAEHgAWsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAQSdGBEAgA0EEaiIJEKwnIQUgAUGUAWpBGEEAQQFBARCgGCABKAKYASEDIAEoApQBQQFGDQIgASgCnAEiBkEIakHQh4EBKQAANwAAIAZByIeBASkAADcAACAGQRBqQdiHgQEpAAA3AAAgAUEYNgIwIAEgBjYCLCABIAM2AiggAUGCgICAeDYCJCAFDQEgACABQSxqIgIpAgA3AgggAEEQaiACQQhqKAIANgIAIAAgAzYCBCAAQYKAgIB4NgIADAsLIAFBJGpBL0EAQQFBARCgGCABKAIoIQIgASgCJEEBRg0CIAEoAiwiA0GsiYEBQS/8CgAAIABBLzYCDCAAIAM2AgggACACNgIEIABBgoCAgHg2AgAMCgsgAUEkahCIESABIAU2AhQgCRDrJSEGIAFBlAFqQRpBAEEBQQEQoBggASgCmAEhByABKAKUAUEBRg0CIAEoApwBIgNBCGpB6IeBASkAADcAACADQeCHgQEpAAA3AAAgA0EYakH4h4EBLwAAOwAAIANBEGpB8IeBASkAADcAACABQRo2AjAgASADNgIsIAEgBzYCKCABQYKAgIB4NgIkIAZFBEAgACABQSxqIgIpAgA3AgggAEEQaiACQQhqKAIANgIAIAAgBzYCBCAAQYKAgIB4NgIADAkLIAFBJGoiAxCIESABIAY2AhggAyACEPMvQfyHgQEgBUEwaiAEEIYBIAEoAiwhByABKAIoIQMgASgCJCIKQZOAgIB4RwRAIAAgASkCMDcCDCAAIAc2AgggACADNgIEIAAgCjYCAAwICyABIAc2AiAgASADNgIcIAFBJGogAhDyLUH8h4EBIAZBMGogBBCGASABKAIsIQogASgCKCELIAEoAiQiBEGTgICAeEcEQCAAIAEpAjA3AgwgACAKNgIIIAAgCzYCBCAAIAQ2AgAgAyADKAIAIgBBAWs2AgAgAEEBRw0IIAFBHGoQuyMMCAsgCSgCACIJIAkoAgAiBEEBajYCACAEQQBIDQMgAigCQCIEIAQoAgAiDUEBajYCACANQQBIDQMgASAENgKIASABIAIpAkQ3AowBELA+QQhBBBCtNiIERQ0EIAQgBjYCBCAEIAU2AgAgAUECNgIsIAEgBDYCKCABQQI2AiQgAUEIaiABQSRqIgUQthkgASgCDCEGIAEoAgghDRCwPkEQQQQQrTYiBEUNBSAEIAo2AgwgBCALNgIIIAQgBzYCBCAEIAM2AgAgAUECNgLQASABIAQ2AswBIAFBAjYCyAEgBSACEJw2EO4lIAFBlAFqIgQgDSAGIAFByAFqIgMgBRDLHCADIAIQmjYQ7iUgBSAJIAFBiAFqIAQgAyAMELEcELA+QewAQQQQrTYiAkUNBiACQoGAgIAQNwIAIAJBCGogBUHkAPwKAAAgAEHUiIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIADAkLIAMgASgCnAFBuIeBARD9LwALIAIgASgCLEG4h4EBEP0vAAsgByABKAKcAUG4h4EBEP0vCwALQQRBCBCjPQALQQRBEBCjPQALQQRB7AAQoz0ACyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPIlCyABKAIUIgAgACgCACIAQQFrNgIAIABBAUcNACABQRRqEPIlCyABQeABaiQADO0CCwJAIA1BIGsOBwsICAACBAYICyAMQQ1rQQdJDQgLIANBAWohAiADQQJqIQcjAEHwAWsiASQAIAEgAzYCDCABIAk2AggCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCS0AAA4bAQACAwQFBgcICQAKCwAAAAAAAAAAAAAADA0MAAsgAUEDNgJkIAFB2N//ADYCYCABQgI3AmwgAUGvAzYCJCABQa8DNgIcIAEgAUEYajYCaCABIAFBDGo2AiAgASABQQhqNgIYIAFB2AFqIAFB4ABqEJkOIABBgoCAgHg2AgAgACABKQLYATcCBCAAQQxqIAFB4AFqKAIANgIADC0LIAEgAyAFIAYoAiQRBAAQoSsgACABKQMANwIEIABBk4CAgHg2AgAMLAsgBSAGEPIhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0LQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMLAsgASAFNgIUIAdBAE4NKSAELQA0DQwgAUHgAGogBiABQRRqIAFBEmoQqQYgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwsCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDCoLIAUgBhD4ISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUNDEEBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCsLIAEgBTYCFCAHQQBODSYgBC0ANA0NIAFB4ABqIAYgAUEUaiABQRJqEKIGIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKwsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwnCyAFIAYQ+yEhBiACLQAAIQIgASAHLQAAIgU6ABMgASACOgASIAEgBcAiByAHQR91IgJzIAJrIgI2ArABQQohAyABQQo2AqwBIAVFDQ1BASEFAkADQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNASACQQFGDQMLIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNACACQQF2IQIMAQsLIAFBAjYCZCABQfDI/wA2AmAgAUICNwJsIAFBwg02AtABIAFBww02AsgBIAEgAUHEAWoiAjYCaCABIAFBsAFqNgLMASABIAFBrAFqNgLEASABQdwBaiABQeAAaiIDEJkOIAEoAtwBIQQgAUHUAWogAUHoAWooAgA2AgAgASABKQLgATcCzAEgASAENgLIASABQYiAgIB4NgLEASABQQQ2AtwBIAFB7Mz/ADYC2AEgAUIDNwLkASABQfQLNgJ0IAFBuwc2AmwgAUHEDTYCZCABQbTM/wA2AmAgASADNgLgASABIAFBE2o2AnAgASABQRJqNgJoIAFBtAFqIAFB2AFqEJkOIAIQiBEgACABKQK4ATcCCCAAQRBqIAFBwAFqKAIANgIAIAAgASgCtAE2AgQgAEGCgICAeDYCAAwqCyABIAU2AhQgB0EATg0jIAQtADQNDiABQeAAaiAGIAFBFGogAUESahD1AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCoLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMJAsgBSAGEPMhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0OQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMKQsgASAFNgIUIAdBAE4NICAELQA0DQ8gAUHgAGogBiABQRRqIAFBEmoQ8gMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwpCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDCELIAUgBhD3ISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUND0EBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCgLIAEgBTYCFCAHQQBODR0gBC0ANA0QIAFB4ABqIAYgAUEUaiABQRJqEKgGIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKAsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAweCyAFIAYQ8CEhBiACLQAAIQIgASAHLQAAIgU6ABMgASACOgASIAEgBcAiByAHQR91IgJzIAJrIgI2ArABQQohAyABQQo2AqwBIAVFDRBBASEFAkADQAJAIAJBAXEEQCAFrCADrH4iG0IgiKcgG6ciBUEfdUcNASACQQFGDQMLIAOsIhsgG34iG0IgiKcgG6ciA0EfdUcNACACQQF2IQIMAQsLIAFBAjYCZCABQfDI/wA2AmAgAUICNwJsIAFBwg02AtABIAFBww02AsgBIAEgAUHEAWoiAjYCaCABIAFBsAFqNgLMASABIAFBrAFqNgLEASABQdwBaiABQeAAaiIDEJkOIAEoAtwBIQQgAUHUAWogAUHoAWooAgA2AgAgASABKQLgATcCzAEgASAENgLIASABQYiAgIB4NgLEASABQQQ2AtwBIAFB7Mz/ADYC2AEgAUIDNwLkASABQfQLNgJ0IAFBuwc2AmwgAUHEDTYCZCABQbTM/wA2AmAgASADNgLgASABIAFBE2o2AnAgASABQRJqNgJoIAFBtAFqIAFB2AFqEJkOIAIQiBEgACABKQK4ATcCCCAAQRBqIAFBwAFqKAIANgIAIAAgASgCtAE2AgQgAEGCgICAeDYCAAwnCyABIAU2AhQgB0EATg0aIAQtADQNESABQeAAaiAGIAFBFGogAUESahChBiABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCcLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMGwsgBSAGEPUhIQYgAi0AACECIAEgBy0AACIFOgATIAEgAjoAEiABIAXAIgcgB0EfdSICcyACayICNgKwAUEKIQMgAUEKNgKsASAFRQ0RQQEhBQJAA0ACQCACQQFxBEAgBawgA6x+IhtCIIinIBunIgVBH3VHDQEgAkEBRg0DCyADrCIbIBt+IhtCIIinIBunIgNBH3VHDQAgAkEBdiECDAELCyABQQI2AmQgAUHwyP8ANgJgIAFCAjcCbCABQcINNgLQASABQcMNNgLIASABIAFBxAFqIgI2AmggASABQbABajYCzAEgASABQawBajYCxAEgAUHcAWogAUHgAGoiAxCZDiABKALcASEEIAFB1AFqIAFB6AFqKAIANgIAIAEgASkC4AE3AswBIAEgBDYCyAEgAUGIgICAeDYCxAEgAUEENgLcASABQezM/wA2AtgBIAFCAzcC5AEgAUH0CzYCdCABQbsHNgJsIAFBxA02AmQgAUG0zP8ANgJgIAEgAzYC4AEgASABQRNqNgJwIAEgAUESajYCaCABQbQBaiABQdgBahCZDiACEIgRIAAgASkCuAE3AgggAEEQaiABQcABaigCADYCACAAIAEoArQBNgIEIABBgoCAgHg2AgAMJgsgASAFNgIUIAdBAE4NFyAELQA0DRIgAUHgAGogBiABQRRqIAFBEmoQ9QMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwmCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDBgLIAUgBhDsISEGIAItAAAhAiABIActAAAiBToAEyABIAI6ABIgASAFwCIHIAdBH3UiAnMgAmsiAjYCsAFBCiEDIAFBCjYCrAEgBUUNEkEBIQUCQANAAkAgAkEBcQRAIAWsIAOsfiIbQiCIpyAbpyIFQR91Rw0BIAJBAUYNAwsgA6wiGyAbfiIbQiCIpyAbpyIDQR91Rw0AIAJBAXYhAgwBCwsgAUECNgJkIAFB8Mj/ADYCYCABQgI3AmwgAUHCDTYC0AEgAUHDDTYCyAEgASABQcQBaiICNgJoIAEgAUGwAWo2AswBIAEgAUGsAWo2AsQBIAFB3AFqIAFB4ABqIgMQmQ4gASgC3AEhBCABQdQBaiABQegBaigCADYCACABIAEpAuABNwLMASABIAQ2AsgBIAFBiICAgHg2AsQBIAFBBDYC3AEgAUHszP8ANgLYASABQgM3AuQBIAFB9As2AnQgAUG7BzYCbCABQcQNNgJkIAFBtMz/ADYCYCABIAM2AuABIAEgAUETajYCcCABIAFBEmo2AmggAUG0AWogAUHYAWoQmQ4gAhCIESAAIAEpArgBNwIIIABBEGogAUHAAWooAgA2AgAgACABKAK0ATYCBCAAQYKAgIB4NgIADCULIAEgBTYCFCAHQQBODRQgBC0ANA0TIAFB4ABqIAYgAUEUaiABQRJqEPIDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwVCyAAIAUgBhDvISACLQAAIActAAAgBBCvCQwjCyAAIAUgBhCCIiACLQAAIActAAAgBBCwCQwiCyAAIAUgBiACLQAAIActAAAgBBDNAQwhCyAAIAUgBiACLQAAIActAAAgBBDOAQwgCyABQQE2AhQMHQsgAUEYaiAGIAFBFGogAUESahCvAwwdCyABQQE2AhQMGQsgAUEYaiAGIAFBFGogAUESahCrAwwZCyABQQE2AhQMFQsgAUEYaiAGIAFBFGogAUESahDPBAwVCyABQQE2AhQMEQsgAUEYaiAGIAFBFGogAUESahDlBAwRCyABQQE2AhQMDQsgAUEYaiAGIAFBFGogAUESahCuAwwNCyABQQE2AhQMCQsgAUEYaiAGIAFBFGogAUESahCqAwwJCyABQQE2AhQMBQsgAUEYaiAGIAFBFGogAUESahDPBAwFCyABQQE2AhQMAQsgAUEYaiAGIAFBFGogAUESahDlBAwBCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEPkDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMEQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqEMkECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDwsMgAMLIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ/AMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwPCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQ7AQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwNCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNINwAJIAIgASkDkAE3AiAgAEHQy/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwNCwz+AgsgBC0ANEUEQCABQeAAaiAGIAFBFGogAUESahD4AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA0LIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMAQsgAUEYaiAGIAFBFGogAUESahDFBAsgAUHgAGogAUEYaiABLQASIAcQoBMgAS0AYCIDQSlGBEAgAUHbAGogAUH0AGooAgAiAjYAACABQdMAaiABQewAaikCACIbNwAAIAEgASkCZCIcNwBLIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAsLIAFB1wBqIgQgAUHwAGopAAA3AAAgAUHQAGoiBSABQekAaikAADcDACABQZgBaiIGIAFBgAFqKQIANwMAIAFBoAFqIgcgAUGIAWopAgA3AwAgASABKQBhNwNIIAEgASkCeDcDkAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAsLDPwCCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEP4DIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqENQECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCQsM+gILIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ+QMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQyQQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwHCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQNINwAJIAIgASkDkAE3AiAgAEHQy/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwHCwz4AgsgBC0ANEUEQCABQeAAaiAGIAFBFGogAUESahD8AyABLQBgIgJBKUYEQCABQesBaiABQfQAaigCACICNgAAIAFB4wFqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3ANsBIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAcLIAFB5wFqIgMgAUHwAGopAAA3AAAgAUHgAWoiBCABQekAaikAADcDACABQThqIAFBgAFqKQIANwIAIAFBQGsgAUGIAWopAgA3AgAgAUEhaiAEKQMANwAAIAFBKGogAykAADcAACABIAEpAGEiGzcD2AEgASABKQJ4NwIwIAEgGzcAGSABIAI6ABgMAQsgAUEYaiAGIAFBFGogAUESahDsBAsgAUHgAGogAUEYaiABLQASIAcQoBMgAS0AYCIDQSlGBEAgAUHbAGogAUH0AGooAgAiAjYAACABQdMAaiABQewAaikCACIbNwAAIAEgASkCZCIcNwBLIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAULIAFB1wBqIgQgAUHwAGopAAA3AAAgAUHQAGoiBSABQekAaikAADcDACABQZgBaiIGIAFBgAFqKQIANwMAIAFBoAFqIgcgAUGIAWopAgA3AwAgASABKQBhNwNIIAEgASkCeDcDkAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPYCCyAELQA0RQRAIAFB4ABqIAYgAUEUaiABQRJqEPoDIAEtAGAiAkEpRgRAIAFB6wFqIAFB9ABqKAIAIgI2AAAgAUHjAWogAUHsAGopAgAiGzcAACABIAEpAmQiHDcA2wEgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUHnAWoiAyABQfAAaikAADcAACABQeABaiIEIAFB6QBqKQAANwMAIAFBOGogAUGAAWopAgA3AgAgAUFAayABQYgBaikCADcCACABQSFqIAQpAwA3AAAgAUEoaiADKQAANwAAIAEgASkAYSIbNwPYASABIAEpAng3AjAgASAbNwAZIAEgAjoAGAwBCyABQRhqIAYgAUEUaiABQRJqENgECyABQeAAaiABQRhqIAEtABIgBxCgEyABLQBgIgNBKUYEQCABQdsAaiABQfQAaigCACICNgAAIAFB0wBqIAFB7ABqKQIAIhs3AAAgASABKQJkIhw3AEsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUHXAGoiBCABQfAAaikAADcAACABQdAAaiIFIAFB6QBqKQAANwMAIAFBmAFqIgYgAUGAAWopAgA3AwAgAUGgAWoiByABQYgBaikCADcDACABIAEpAGE3A0ggASABKQJ4NwOQARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDSDcACSACIAEpA5ABNwIgIABB0Mv/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM9AILIAQtADRFBEAgAUHgAGogBiABQRRqIAFBEmoQ/wMgAS0AYCICQSlGBEAgAUHrAWogAUH0AGooAgAiAjYAACABQeMBaiABQewAaikCACIbNwAAIAEgASkCZCIcNwDbASAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwDCyABQecBaiIDIAFB8ABqKQAANwAAIAFB4AFqIgQgAUHpAGopAAA3AwAgAUE4aiABQYABaikCADcCACABQUBrIAFBiAFqKQIANwIAIAFBIWogBCkDADcAACABQShqIAMpAAA3AAAgASABKQBhIhs3A9gBIAEgASkCeDcCMCABIBs3ABkgASACOgAYDAELIAFBGGogBiABQRRqIAFBEmoQyAQLIAFB4ABqIAFBGGogAS0AEiAHEKATIAEtAGAiA0EpRgRAIAFB2wBqIAFB9ABqKAIAIgI2AAAgAUHTAGogAUHsAGopAgAiGzcAACABIAEpAmQiHDcASyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQdcAaiIEIAFB8ABqKQAANwAAIAFB0ABqIgUgAUHpAGopAAA3AwAgAUGYAWoiBiABQYABaikCADcDACABQaABaiIHIAFBiAFqKQIANwMAIAEgASkAYTcDSCABIAEpAng3A5ABELA+QThBBBCtNiICRQ3yAiACIAM6AAggAkKBgICAEDcCACACIAEpA0g3AAkgAiABKQOQATcCICAAQdDL/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQfABaiQADAALDOsCCyAMQQ1rQQdJDQYLIANBAWohAiADQQJqIQcjAEGABGsiASQAIAEgAzYCmAIgASAJNgKUAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJLQAADhsBAAIDBAUGBwgJAAoLAAAAAAAAAAAAAAAMDQwACyABQQM2AvQCIAFB2N//ADYC8AIgAUICNwL8AiABQa8DNgK0AiABQa8DNgKsAiABIAFBqAJqNgL4AiABIAFBmAJqNgKwAiABIAFBlAJqNgKoAiABQegDaiABQfACahCZDiAAQYKAgIB4NgIAIAAgASkC6AM3AgQgAEEMaiABQfADaigCADYCAAwtCyABQQhqIAMgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCwLIAUgBhDyISEDIAItAAAhAiABIActAAAiBjoAnwIgASACOgCeAiABIAbAIgUgBUEfdSICcyACayICNgK8A0IKIRsgAUIKNwPAAyAGRQ0LQgEhHAJAA0ACQCACQQFxBEAgAUEgaiAcIBxCP4cgGyAbQj+HEKgeIAEpAyggASkDICIcQj+HUg0BIAJBAUYNAwsgAUEQaiAbIBtCP4ciHSAbIB0QqB4gASkDGCABKQMQIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwsCyABIBw3A6ACIAVBAE4NKSAELQA0DQwgAUHwAmogAyABQaACaiABQZ4CahDlBiABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMLAsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwqCyAFIAYQ+CEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUNDEIBIRwCQANAAkAgAkEBcQRAIAFBQGsgHCAcQj+HIBsgG0I/hxCoHiABKQNIIAEpA0AiHEI/h1INASACQQFGDQMLIAFBMGogGyAbQj+HIh0gGyAdEKgeIAEpAzggASkDMCIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKwsgASAcNwOgAiAFQQBODSYgBC0ANA0NIAFB8AJqIAMgAUGgAmogAUGeAmoQ3wYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCsLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMJwsgBSAGEPshIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDQ1CASEcAkADQAJAIAJBAXEEQCABQeAAaiAcIBxCP4cgGyAbQj+HEKgeIAEpA2ggASkDYCIcQj+HUg0BIAJBAUYNAwsgAUHQAGogGyAbQj+HIh0gGyAdEKgeIAEpA1ggASkDUCIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKgsgASAcNwOgAiAFQQBODSMgBC0ANA0OIAFB8AJqIAMgAUGgAmogAUGeAmoQ4AYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCoLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMJAsgBSAGEPMhIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDQ5CASEcAkADQAJAIAJBAXEEQCABQYABaiAcIBxCP4cgGyAbQj+HEKgeIAEpA4gBIAEpA4ABIhxCP4dSDQEgAkEBRg0DCyABQfAAaiAbIBtCP4ciHSAbIB0QqB4gASkDeCABKQNwIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwpCyABIBw3A6ACIAVBAE4NICAELQA0DQ8gAUHwAmogAyABQaACaiABQZ4CahCyBCABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKQsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwhCyAFIAYQ9yEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUND0IBIRwCQANAAkAgAkEBcQRAIAFBoAFqIBwgHEI/hyAbIBtCP4cQqB4gASkDqAEgASkDoAEiHEI/h1INASACQQFGDQMLIAFBkAFqIBsgG0I/hyIdIBsgHRCoHiABKQOYASABKQOQASIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMKAsgASAcNwOgAiAFQQBODR0gBC0ANA0QIAFB8AJqIAMgAUGgAmogAUGeAmoQ5gYgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCgLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMHgsgBSAGEPAhIQMgAi0AACECIAEgBy0AACIGOgCfAiABIAI6AJ4CIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwDQgohGyABQgo3A8ADIAZFDRBCASEcAkADQAJAIAJBAXEEQCABQcABaiAcIBxCP4cgGyAbQj+HEKgeIAEpA8gBIAEpA8ABIhxCP4dSDQEgAkEBRg0DCyABQbABaiAbIBtCP4ciHSAbIB0QqB4gASkDuAEgASkDsAEiG0I/h1INACACQQF2IQIMAQsLIAFBAjYC9AIgAUHwyP8ANgLwAiABQgI3AvwCIAFBwg02AuADIAFBxQ02AtgDIAEgAUHUA2oiAjYC+AIgASABQbwDajYC3AMgASABQcADajYC1AMgAUHsA2ogAUHwAmoiAxCZDiABKQLsAyEbIAEgASkC9AM3AuADIAEgGzcC2AMgAUGIgICAeDYC1AMgAUEENgLsAyABQezM/wA2AugDIAFCAzcC9AMgAUH0CzYChAMgAUG7BzYC/AIgAUHEDTYC9AIgAUGszf8ANgLwAiABIAM2AvADIAEgAUGfAmo2AoADIAEgAUGeAmo2AvgCIAFBxANqIAFB6ANqEJkOIAIQiBEgASkCxAMhGyAAIAEpAswDNwIMIAAgGzcCBCAAQYKAgIB4NgIADCcLIAEgHDcDoAIgBUEATg0aIAQtADQNESABQfACaiADIAFBoAJqIAFBngJqEN4GIAEtAPACIgJBKUYEQCABQfsDaiABQYQDaigCACICNgAAIAFB8wNqIAFB/AJqKQIAIhs3AAAgASABKQL0AiIcNwDrAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwnCyABQfcDaiIDIAFBgANqKQAANwAAIAFB8ANqIgQgAUH5AmopAAA3AwAgAUHIAmogAUGQA2opAgA3AgAgAUHQAmogAUGYA2opAgA3AgAgAUGxAmogBCkDADcAACABQbgCaiADKQAANwAAIAEgASkA8QIiGzcD6AMgASABKQKIAzcCwAIgASAbNwCpAiABIAI6AKgCDBsLIAUgBhD1ISEDIAItAAAhAiABIActAAAiBjoAnwIgASACOgCeAiABIAbAIgUgBUEfdSICcyACayICNgK8A0IKIRsgAUIKNwPAAyAGRQ0RQgEhHAJAA0ACQCACQQFxBEAgAUHgAWogHCAcQj+HIBsgG0I/hxCoHiABKQPoASABKQPgASIcQj+HUg0BIAJBAUYNAwsgAUHQAWogGyAbQj+HIh0gGyAdEKgeIAEpA9gBIAEpA9ABIhtCP4dSDQAgAkEBdiECDAELCyABQQI2AvQCIAFB8Mj/ADYC8AIgAUICNwL8AiABQcINNgLgAyABQcUNNgLYAyABIAFB1ANqIgI2AvgCIAEgAUG8A2o2AtwDIAEgAUHAA2o2AtQDIAFB7ANqIAFB8AJqIgMQmQ4gASkC7AMhGyABIAEpAvQDNwLgAyABIBs3AtgDIAFBiICAgHg2AtQDIAFBBDYC7AMgAUHszP8ANgLoAyABQgM3AvQDIAFB9As2AoQDIAFBuwc2AvwCIAFBxA02AvQCIAFBrM3/ADYC8AIgASADNgLwAyABIAFBnwJqNgKAAyABIAFBngJqNgL4AiABQcQDaiABQegDahCZDiACEIgRIAEpAsQDIRsgACABKQLMAzcCDCAAIBs3AgQgAEGCgICAeDYCAAwmCyABIBw3A6ACIAVBAE4NFyAELQA0DRIgAUHwAmogAyABQaACaiABQZ4CahDdBiABLQDwAiICQSlGBEAgAUH7A2ogAUGEA2ooAgAiAjYAACABQfMDaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA6wMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJgsgAUH3A2oiAyABQYADaikAADcAACABQfADaiIEIAFB+QJqKQAANwMAIAFByAJqIAFBkANqKQIANwIAIAFB0AJqIAFBmANqKQIANwIAIAFBsQJqIAQpAwA3AAAgAUG4AmogAykAADcAACABIAEpAPECIhs3A+gDIAEgASkCiAM3AsACIAEgGzcAqQIgASACOgCoAgwYCyAFIAYQ7CEhAyACLQAAIQIgASAHLQAAIgY6AJ8CIAEgAjoAngIgASAGwCIFIAVBH3UiAnMgAmsiAjYCvANCCiEbIAFCCjcDwAMgBkUNEkIBIRwCQANAAkAgAkEBcQRAIAFBgAJqIBwgHEI/hyAbIBtCP4cQqB4gASkDiAIgASkDgAIiHEI/h1INASACQQFGDQMLIAFB8AFqIBsgG0I/hyIdIBsgHRCoHiABKQP4ASABKQPwASIbQj+HUg0AIAJBAXYhAgwBCwsgAUECNgL0AiABQfDI/wA2AvACIAFCAjcC/AIgAUHCDTYC4AMgAUHFDTYC2AMgASABQdQDaiICNgL4AiABIAFBvANqNgLcAyABIAFBwANqNgLUAyABQewDaiABQfACaiIDEJkOIAEpAuwDIRsgASABKQL0AzcC4AMgASAbNwLYAyABQYiAgIB4NgLUAyABQQQ2AuwDIAFB7Mz/ADYC6AMgAUIDNwL0AyABQfQLNgKEAyABQbsHNgL8AiABQcQNNgL0AiABQazN/wA2AvACIAEgAzYC8AMgASABQZ8CajYCgAMgASABQZ4CajYC+AIgAUHEA2ogAUHoA2oQmQ4gAhCIESABKQLEAyEbIAAgASkCzAM3AgwgACAbNwIEIABBgoCAgHg2AgAMJQsgASAcNwOgAiAFQQBODRQgBC0ANA0TIAFB8AJqIAMgAUGgAmogAUGeAmoQsgQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCULIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMFQsgACAFIAYQ7yEgAi0AACAHLQAAIAQQtgkMIwsgACAFIAYQgiIgAi0AACAHLQAAIAQQtQkMIgsgACAFIAYgAi0AACAHLQAAIAQQyAEMIQsgACAFIAYgAi0AACAHLQAAIAQQyQEMIAsgAUIBNwOgAgwdCyABQagCaiADIAFBoAJqIAFBngJqEKYDDB0LIAFCATcDoAIMGQsgAUGoAmogAyABQaACaiABQZ4CahCeAwwZCyABQgE3A6ACDBULIAFBqAJqIAMgAUGgAmogAUGeAmoQnQMMFQsgAUIBNwOgAgwRCyABQagCaiADIAFBoAJqIAFBngJqEOkEDBELIAFCATcDoAIMDQsgAUGoAmogAyABQaACaiABQZ4CahClAwwNCyABQgE3A6ACDAkLIAFBqAJqIAMgAUGgAmogAUGeAmoQoAMMCQsgAUIBNwOgAgwFCyABQagCaiADIAFBoAJqIAFBngJqEKEDDAULIAFCATcDoAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDpBAwBCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADBELIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDyBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADA8LDP4CCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQoQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA8LIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDDBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADA0LDPwCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQogQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADA0LIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDhBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAsLDPoCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQpwQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAsLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDeBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAkLDPgCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnQQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAkLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDyBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAcLDPYCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQmwQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAcLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahD6BAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPQCCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQnAQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAULIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahDoBAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkD2AI3AAkgAiABKQOgAzcCICAAQcjJ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAMLDPICCyAELQA0RQRAIAFB8AJqIAMgAUGgAmogAUGeAmoQowQgAS0A8AIiAkEpRgRAIAFB+wNqIAFBhANqKAIAIgI2AAAgAUHzA2ogAUH8AmopAgAiGzcAACABIAEpAvQCIhw3AOsDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAMLIAFB9wNqIgMgAUGAA2opAAA3AAAgAUHwA2oiBCABQfkCaikAADcDACABQcgCaiABQZADaikCADcCACABQdACaiABQZgDaikCADcCACABQbECaiAEKQMANwAAIAFBuAJqIAMpAAA3AAAgASABKQDxAiIbNwPoAyABIAEpAogDNwLAAiABIBs3AKkCIAEgAjoAqAIMAQsgAUGoAmogAyABQaACaiABQZ4CahD1BAsgAUHwAmogAUGoAmogAS0AngIgBRCiEyABLQDwAiIDQSlGBEAgAUHrAmogAUGEA2ooAgAiAjYAACABQeMCaiABQfwCaikCACIbNwAAIAEgASkC9AIiHDcA2wIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUHnAmoiBCABQYADaikAADcAACABQeACaiIFIAFB+QJqKQAANwMAIAFBqANqIgYgAUGQA2opAgA3AwAgAUGwA2oiByABQZgDaikCADcDACABIAEpAPECNwPYAiABIAEpAogDNwOgAxCwPkE4QQQQrTYiAkUN8AIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYAjcACSACIAEpA6ADNwIgIABByMn/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFBgARqJAAMAAsM6QILIAxBDWtBB0kNBAsgA0EBaiECIANBAmohByMAQZAGayIBJAAgASADNgKIBCABIAk2AoQEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAktAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDAALIAFBAzYC9AQgAUHY3/8ANgLwBCABQgI3AvwEIAFBrwM2ArQEIAFBrwM2AqwEIAEgAUGoBGo2AvgEIAEgAUGIBGo2ArAEIAEgAUGEBGo2AqgEIABBBGogAUHwBGoQmQ4gAEGCgICAeDYCAAwtCyABQQhqIAMgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCwLIAUgBhDyISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDQtCASEdAkADQAJAIAJBAXEEQCABQQA2AkwgAUEwaiAdIB4gGyAcIAFBzABqEPYMIAEoAkwNASABKQM4IR4gASkDMCEdIAJBAUYNAwsgAUEANgIsIAFBEGogGyAcIBsgHCABQSxqEPYMIAEoAiwNACABKQMYIRwgASkDECEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCwLIAEgHTcDkAQgASAeNwOYBCAFQQBODSkgBC0ANA0MIAFB8ARqIAMgAUGQBGogAUGOBGoQlwYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCwLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMKgsgBSAGEPghIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUNDEIBIR0CQANAAkAgAkEBcQRAIAFBADYCjAEgAUHwAGogHSAeIBsgHCABQYwBahD2DCABKAKMAQ0BIAEpA3ghHiABKQNwIR0gAkEBRg0DCyABQQA2AmwgAUHQAGogGyAcIBsgHCABQewAahD2DCABKAJsDQAgASkDWCEcIAEpA1AhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwrCyABIB03A5AEIAEgHjcDmAQgBUEATg0mIAQtADQNDSABQfAEaiADIAFBkARqIAFBjgRqEJAGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwrCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDCcLIAUgBhD7ISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDQ1CASEdAkADQAJAIAJBAXEEQCABQQA2AswBIAFBsAFqIB0gHiAbIBwgAUHMAWoQ9gwgASgCzAENASABKQO4ASEeIAEpA7ABIR0gAkEBRg0DCyABQQA2AqwBIAFBkAFqIBsgHCAbIBwgAUGsAWoQ9gwgASgCrAENACABKQOYASEcIAEpA5ABIRsgAkEBdiECDAELCyABQQI2AvQEIAFB8Mj/ADYC8AQgAUICNwL8BCABQcINNgLsBSABQcYNNgLkBSABIAFB4AVqIgI2AvgEIAEgAUG8BWo2AugFIAEgAUHABWo2AuAFIAFB/AVqIAFB8ARqIgMQmQ4gAUGIgICAeDYC+AUgAUHoBWogAUGABmooAgA2AgAgASABKQL4BTcD4AUgASABKQKEBjcC7AUgAUEENgL8BSABQezM/wA2AvgFIAFCAzcChAYgAUH0CzYChAUgAUG7BzYC/AQgAUHEDTYC9AQgAUHAzf8ANgLwBCABIAM2AoAGIAEgAUGPBGo2AoAFIAEgAUGOBGo2AvgEIAFBxAVqIAFB+AVqEJkOIAFBgoCAgHg2AsAFIAIQiBEgAEEIaiABQcgFaigCADYCACAAIAEpAsAFNwIAIAAgASkCzAU3AgwMKgsgASAdNwOQBCABIB43A5gEIAVBAE4NIyAELQA0DQ4gAUHwBGogAyABQZAEaiABQY4EahCRBiABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMKgsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwkCyAFIAYQ8yEhAyACLQAAIQIgASAHLQAAIgY6AI8EIAEgAjoAjgQgASAGwCIFIAVBH3UiAnMgAmsiAjYCvAUgAUIANwPIBUIKIRsgAUIKNwPABSAGRQ0OQgEhHQJAA0ACQCACQQFxBEAgAUEANgKMAiABQfABaiAdIB4gGyAcIAFBjAJqEPYMIAEoAowCDQEgASkD+AEhHiABKQPwASEdIAJBAUYNAwsgAUEANgLsASABQdABaiAbIBwgGyAcIAFB7AFqEPYMIAEoAuwBDQAgASkD2AEhHCABKQPQASEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCkLIAEgHTcDkAQgASAeNwOYBCAFQQBODSAgBC0ANA0PIAFB8ARqIAMgAUGQBGogAUGOBGoQkgYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCkLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMIQsgBSAGEPchIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUND0IBIR0CQANAAkAgAkEBcQRAIAFBADYCzAIgAUGwAmogHSAeIBsgHCABQcwCahD2DCABKALMAg0BIAEpA7gCIR4gASkDsAIhHSACQQFGDQMLIAFBADYCrAIgAUGQAmogGyAcIBsgHCABQawCahD2DCABKAKsAg0AIAEpA5gCIRwgASkDkAIhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwoCyABIB03A5AEIAEgHjcDmAQgBUEATg0dIAQtADQNECABQfAEaiADIAFBkARqIAFBjgRqEKAGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwoCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDB4LIAUgBhDwISEDIAItAAAhAiABIActAAAiBjoAjwQgASACOgCOBCABIAbAIgUgBUEfdSICcyACayICNgK8BSABQgA3A8gFQgohGyABQgo3A8AFIAZFDRBCASEdAkADQAJAIAJBAXEEQCABQQA2AowDIAFB8AJqIB0gHiAbIBwgAUGMA2oQ9gwgASgCjAMNASABKQP4AiEeIAEpA/ACIR0gAkEBRg0DCyABQQA2AuwCIAFB0AJqIBsgHCAbIBwgAUHsAmoQ9gwgASgC7AINACABKQPYAiEcIAEpA9ACIRsgAkEBdiECDAELCyABQQI2AvQEIAFB8Mj/ADYC8AQgAUICNwL8BCABQcINNgLsBSABQcYNNgLkBSABIAFB4AVqIgI2AvgEIAEgAUG8BWo2AugFIAEgAUHABWo2AuAFIAFB/AVqIAFB8ARqIgMQmQ4gAUGIgICAeDYC+AUgAUHoBWogAUGABmooAgA2AgAgASABKQL4BTcD4AUgASABKQKEBjcC7AUgAUEENgL8BSABQezM/wA2AvgFIAFCAzcChAYgAUH0CzYChAUgAUG7BzYC/AQgAUHEDTYC9AQgAUHAzf8ANgLwBCABIAM2AoAGIAEgAUGPBGo2AoAFIAEgAUGOBGo2AvgEIAFBxAVqIAFB+AVqEJkOIAFBgoCAgHg2AsAFIAIQiBEgAEEIaiABQcgFaigCADYCACAAIAEpAsAFNwIAIAAgASkCzAU3AgwMJwsgASAdNwOQBCABIB43A5gEIAVBAE4NGiAELQA0DREgAUHwBGogAyABQZAEaiABQY4EahCaBiABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwbCyAFIAYQ9SEhAyACLQAAIQIgASAHLQAAIgY6AI8EIAEgAjoAjgQgASAGwCIFIAVBH3UiAnMgAmsiAjYCvAUgAUIANwPIBUIKIRsgAUIKNwPABSAGRQ0RQgEhHQJAA0ACQCACQQFxBEAgAUEANgLMAyABQbADaiAdIB4gGyAcIAFBzANqEPYMIAEoAswDDQEgASkDuAMhHiABKQOwAyEdIAJBAUYNAwsgAUEANgKsAyABQZADaiAbIBwgGyAcIAFBrANqEPYMIAEoAqwDDQAgASkDmAMhHCABKQOQAyEbIAJBAXYhAgwBCwsgAUECNgL0BCABQfDI/wA2AvAEIAFCAjcC/AQgAUHCDTYC7AUgAUHGDTYC5AUgASABQeAFaiICNgL4BCABIAFBvAVqNgLoBSABIAFBwAVqNgLgBSABQfwFaiABQfAEaiIDEJkOIAFBiICAgHg2AvgFIAFB6AVqIAFBgAZqKAIANgIAIAEgASkC+AU3A+AFIAEgASkChAY3AuwFIAFBBDYC/AUgAUHszP8ANgL4BSABQgM3AoQGIAFB9As2AoQFIAFBuwc2AvwEIAFBxA02AvQEIAFBwM3/ADYC8AQgASADNgKABiABIAFBjwRqNgKABSABIAFBjgRqNgL4BCABQcQFaiABQfgFahCZDiABQYKAgIB4NgLABSACEIgRIABBCGogAUHIBWooAgA2AgAgACABKQLABTcCACAAIAEpAswFNwIMDCYLIAEgHTcDkAQgASAeNwOYBCAFQQBODRcgBC0ANA0SIAFB8ARqIAMgAUGQBGogAUGOBGoQmQYgAS0A8AQiAkEpRgRAIAFBiwZqIAFBhAVqKAIAIgI2AAAgAUGDBmogAUH8BGopAgAiGzcAACABIAEpAvQEIhw3APsFIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCYLIAFBhwZqIgMgAUGABWopAAA3AAAgAUGABmoiBCABQfkEaikAADcDACABQcgEaiABQZAFaikCADcCACABQdAEaiABQZgFaikCADcCACABQbEEaiAEKQMANwAAIAFBuARqIAMpAAA3AAAgASABKQDxBCIbNwP4BSABIAEpAogFNwLABCABIBs3AKkEIAEgAjoAqAQMGAsgBSAGEOwhIQMgAi0AACECIAEgBy0AACIGOgCPBCABIAI6AI4EIAEgBsAiBSAFQR91IgJzIAJrIgI2ArwFIAFCADcDyAVCCiEbIAFCCjcDwAUgBkUNEkIBIR0CQANAAkAgAkEBcQRAIAFBADYCgAQgAUHwA2ogHSAeIBsgHCABQYAEahD2DCABKAKABA0BIAEpA/gDIR4gASkD8AMhHSACQQFGDQMLIAFBADYC7AMgAUHQA2ogGyAcIBsgHCABQewDahD2DCABKALsAw0AIAEpA9gDIRwgASkD0AMhGyACQQF2IQIMAQsLIAFBAjYC9AQgAUHwyP8ANgLwBCABQgI3AvwEIAFBwg02AuwFIAFBxg02AuQFIAEgAUHgBWoiAjYC+AQgASABQbwFajYC6AUgASABQcAFajYC4AUgAUH8BWogAUHwBGoiAxCZDiABQYiAgIB4NgL4BSABQegFaiABQYAGaigCADYCACABIAEpAvgFNwPgBSABIAEpAoQGNwLsBSABQQQ2AvwFIAFB7Mz/ADYC+AUgAUIDNwKEBiABQfQLNgKEBSABQbsHNgL8BCABQcQNNgL0BCABQcDN/wA2AvAEIAEgAzYCgAYgASABQY8EajYCgAUgASABQY4EajYC+AQgAUHEBWogAUH4BWoQmQ4gAUGCgICAeDYCwAUgAhCIESAAQQhqIAFByAVqKAIANgIAIAAgASkCwAU3AgAgACABKQLMBTcCDAwlCyABIB03A5AEIAEgHjcDmAQgBUEATg0UIAQtADQNEyABQfAEaiADIAFBkARqIAFBjgRqEJgGIAEtAPAEIgJBKUYEQCABQYsGaiABQYQFaigCACICNgAAIAFBgwZqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwD7BSAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwlCyABQYcGaiIDIAFBgAVqKQAANwAAIAFBgAZqIgQgAUH5BGopAAA3AwAgAUHIBGogAUGQBWopAgA3AgAgAUHQBGogAUGYBWopAgA3AgAgAUGxBGogBCkDADcAACABQbgEaiADKQAANwAAIAEgASkA8QQiGzcD+AUgASABKQKIBTcCwAQgASAbNwCpBCABIAI6AKgEDBULIAAgBSAGEO8hIAItAAAgBy0AACAEELEJDCMLIAAgBSAGEIIiIAItAAAgBy0AACAEELIJDCILIAAgBSAGIAItAAAgBy0AACAEENABDCELIAAgBSAGIAItAAAgBy0AACAEEM8BDCALIAFCADcDmAQgAUIBNwOQBAwdCyABQagEaiADIAFBkARqIAFBjgRqEIsDDB0LIAFCADcDmAQgAUIBNwOQBAwZCyABQagEaiADIAFBkARqIAFBjgRqEIgDDBkLIAFCADcDmAQgAUIBNwOQBAwVCyABQagEaiADIAFBkARqIAFBjgRqEIkDDBULIAFCADcDmAQgAUIBNwOQBAwRCyABQagEaiADIAFBkARqIAFBjgRqEIoDDBELIAFCADcDmAQgAUIBNwOQBAwNCyABQagEaiADIAFBkARqIAFBjgRqEI4DDA0LIAFCADcDmAQgAUIBNwOQBAwJCyABQagEaiADIAFBkARqIAFBjgRqEIwDDAkLIAFCADcDmAQgAUIBNwOQBAwFCyABQagEaiADIAFBkARqIAFBjgRqEI0DDAULIAFCADcDmAQgAUIBNwOQBAwBCyABQagEaiADIAFBkARqIAFBjgRqEJADDAELIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCLBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMEQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEPkECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwPCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDwsM/AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCKBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEN8ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwNCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMDQsM+gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCMBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMDQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEIAFCyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwLCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCwsM+AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCOBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqENIECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMCQsM9gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCIBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMCQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEO0ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwHCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBwsM9AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCHBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEMsECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwFCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBQsM8gILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCGBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBQsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEMYECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwDCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQPYBDcACSACIAEpA6AFNwIgIABBoMr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM8AILIAQtADRFBEAgAUHwBGogAyABQZAEaiABQY4EahCJBCABLQDwBCICQSlGBEAgAUGLBmogAUGEBWooAgAiAjYAACABQYMGaiABQfwEaikCACIbNwAAIAEgASkC9AQiHDcA+wUgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAwsgAUGHBmoiAyABQYAFaikAADcAACABQYAGaiIEIAFB+QRqKQAANwMAIAFByARqIAFBkAVqKQIANwIAIAFB0ARqIAFBmAVqKQIANwIAIAFBsQRqIAQpAwA3AAAgAUG4BGogAykAADcAACABIAEpAPEEIhs3A/gFIAEgASkCiAU3AsAEIAEgGzcAqQQgASACOgCoBAwBCyABQagEaiADIAFBkARqIAFBjgRqEP8ECyABQfAEaiABQagEaiABLQCOBCAFEKETIAEtAPAEIgNBKUYEQCABQesEaiABQYQFaigCACICNgAAIAFB4wRqIAFB/ARqKQIAIhs3AAAgASABKQL0BCIcNwDbBCAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwBCyABQecEaiIEIAFBgAVqKQAANwAAIAFB4ARqIgUgAUH5BGopAAA3AwAgAUGoBWoiBiABQZAFaikCADcDACABQbAFaiIHIAFBmAVqKQIANwMAIAEgASkA8QQ3A9gEIAEgASkCiAU3A6AFELA+QThBBBCtNiICRQ3uAiACIAM6AAggAkKBgICAEDcCACACIAEpA9gENwAJIAIgASkDoAU3AiAgAEGgyv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUGQBmokAAwACwznAgsgDEENa0EHSQ0CCyAIQdAAakIKQgAQsi4gCCkDUCEbIAgpA1ghHCAIKQNgIR0gCCkDaCEeIANBAWohAiADQQJqIQMgCCgCTCEHIAgoAkghCSMAQcACayIBJAAgASAJNgIYIAEgBzYCFAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIActAAAOGwEAAgMEBQYHCAkACgsAAAAAAAAAAAAAAAwNDAALIAFBAzYClAEgAUHY3/8ANgKQASABQgI3ApwBIAFBrwM2AlQgAUGvAzYCTCABIAFByABqNgKYASABIAFBGGo2AlAgASABQRRqNgJIIABBBGogAUGQAWoQmQ4gAEGCgICAeDYCAAwlCyABQQhqIAkgBSAGKAIkEQQAEKErIAAgASkDCDcCBCAAQZOAgIB4NgIADCQLIAUgBhDyISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAwkCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0MIAFBkAFqIAUgAUEgaiABQR5qELMEIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwlCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDCMLIANBAXENDCABQZABaiAFIAFBIGogAUEeahCXByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJAsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwiCyAFIAYQ+CEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMIwsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENDSABQZABaiAFIAFBIGogAUEeahCtBCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMJAsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwhCyADQQFxDQ0gAUGQAWogBSABQSBqIAFBHmoQnQcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCMLIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMIAsgBSAGEPshIQUgAi0AACEGIAEgAywAACICOgAfIAEgBjoAHiABQZABaiAbIBwgHSAeIAIgAkEfdSIDcyADaxDeASABKAKQAUEBRgRAIAFBgAJqIAEpApwBNwMAIAFBiAJqIAFBpAFqKAIANgIAIAEgASkClAE3A/gBIAFB7Mz/ADYCkAIgAUIDNwKcAiABQfQLNgK8AiABQbsHNgK0AiABQcQNNgKsAiABQZjN/wA2AqgCIAEgAUGoAmo2ApgCIAEgAUEfajYCuAIgASABQR5qNgKwAiABQQQ2ApQCIAFB6AFqIAFBkAJqEJkOIAFBgoCAgHg2AuQBIAFB+AFqEIgRIABBCGogAUHsAWooAgA2AgAgACABKQLkATcCACAAIAEpAvABNwIMDCILIAEgASkDuAE3AzggASABKQOwATcDMCABIAEpA6gBNwMoIAEgASkDoAE3AyAgBC0ANCEDIAJBAE4EQCADQQFxDQ4gAUGQAWogBSABQSBqIAFBHmoQsAQgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCMLIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMHwsgA0EBcQ0OIAFBkAFqIAUgAUEgaiABQR5qEJoHIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwiCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDB4LIAUgBhDzISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAwhCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0PIAFBkAFqIAUgAUEgaiABQR5qEKwEIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwiCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDB0LIANBAXENDyABQZABaiAFIAFBIGogAUEeahCZByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMIQsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwcCyAFIAYQ9yEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMIAsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENECABQZABaiAFIAFBIGogAUEeahC0BCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMIQsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwbCyADQQFxDRAgAUGQAWogBSABQSBqIAFBHmoQlAcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCALIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMGgsgBSAGEPAhIQUgAi0AACEGIAEgAywAACICOgAfIAEgBjoAHiABQZABaiAbIBwgHSAeIAIgAkEfdSIDcyADaxDeASABKAKQAUEBRgRAIAFBgAJqIAEpApwBNwMAIAFBiAJqIAFBpAFqKAIANgIAIAEgASkClAE3A/gBIAFB7Mz/ADYCkAIgAUIDNwKcAiABQfQLNgK8AiABQbsHNgK0AiABQcQNNgKsAiABQZjN/wA2AqgCIAEgAUGoAmo2ApgCIAEgAUEfajYCuAIgASABQR5qNgKwAiABQQQ2ApQCIAFB6AFqIAFBkAJqEJkOIAFBgoCAgHg2AuQBIAFB+AFqEIgRIABBCGogAUHsAWooAgA2AgAgACABKQLkATcCACAAIAEpAvABNwIMDB8LIAEgASkDuAE3AzggASABKQOwATcDMCABIAEpA6gBNwMoIAEgASkDoAE3AyAgBC0ANCEDIAJBAE4EQCADQQFxDREgAUGQAWogBSABQSBqIAFBHmoQqwQgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADCALIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMGQsgA0EBcQ0RIAFBkAFqIAUgAUEgaiABQR5qEJwHIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwfCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDBgLIAUgBhD1ISEFIAItAAAhBiABIAMsAAAiAjoAHyABIAY6AB4gAUGQAWogGyAcIB0gHiACIAJBH3UiA3MgA2sQ3gEgASgCkAFBAUYEQCABQYACaiABKQKcATcDACABQYgCaiABQaQBaigCADYCACABIAEpApQBNwP4ASABQezM/wA2ApACIAFCAzcCnAIgAUH0CzYCvAIgAUG7BzYCtAIgAUHEDTYCrAIgAUGYzf8ANgKoAiABIAFBqAJqNgKYAiABIAFBH2o2ArgCIAEgAUEeajYCsAIgAUEENgKUAiABQegBaiABQZACahCZDiABQYKAgIB4NgLkASABQfgBahCIESAAQQhqIAFB7AFqKAIANgIAIAAgASkC5AE3AgAgACABKQLwATcCDAweCyABIAEpA7gBNwM4IAEgASkDsAE3AzAgASABKQOoATcDKCABIAEpA6ABNwMgIAQtADQhAyACQQBOBEAgA0EBcQ0SIAFBkAFqIAUgAUEgaiABQR5qEK4EIAEtAJABIgNBKUYEQCABQbsCaiABQaQBaigCACICNgAAIAFBswJqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwCrAiAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwfCyABQbcCaiIEIAFBoAFqKQAANwAAIAFBsAJqIgUgAUGZAWopAAA3AwAgAUHoAGogAUGwAWopAgA3AgAgAUHwAGogAUG4AWopAgA3AgAgAUHRAGogBSkDADcAACABQdgAaiAEKQAANwAAIAEgASkAkQEiGzcDqAIgASABKQKoATcCYCABIBs3AEkgASADOgBIDBcLIANBAXENEiABQZABaiAFIAFBIGogAUEeahCVByABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMHgsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwWCyAFIAYQ7CEhBSACLQAAIQYgASADLAAAIgI6AB8gASAGOgAeIAFBkAFqIBsgHCAdIB4gAiACQR91IgNzIANrEN4BIAEoApABQQFGBEAgAUGAAmogASkCnAE3AwAgAUGIAmogAUGkAWooAgA2AgAgASABKQKUATcD+AEgAUHszP8ANgKQAiABQgM3ApwCIAFB9As2ArwCIAFBuwc2ArQCIAFBxA02AqwCIAFBmM3/ADYCqAIgASABQagCajYCmAIgASABQR9qNgK4AiABIAFBHmo2ArACIAFBBDYClAIgAUHoAWogAUGQAmoQmQ4gAUGCgICAeDYC5AEgAUH4AWoQiBEgAEEIaiABQewBaigCADYCACAAIAEpAuQBNwIAIAAgASkC8AE3AgwMHQsgASABKQO4ATcDOCABIAEpA7ABNwMwIAEgASkDqAE3AyggASABKQOgATcDICAELQA0IQMgAkEATgRAIANBAXENEyABQZABaiAFIAFBIGogAUEeahCvBCABLQCQASIDQSlGBEAgAUG7AmogAUGkAWooAgAiAjYAACABQbMCaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAqwIgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMHgsgAUG3AmoiBCABQaABaikAADcAACABQbACaiIFIAFBmQFqKQAANwMAIAFB6ABqIAFBsAFqKQIANwIAIAFB8ABqIAFBuAFqKQIANwIAIAFB0QBqIAUpAwA3AAAgAUHYAGogBCkAADcAACABIAEpAJEBIhs3A6gCIAEgASkCqAE3AmAgASAbNwBJIAEgAzoASAwVCyADQQFxDRMgAUGQAWogBSABQSBqIAFBHmoQngcgAS0AkAEiA0EpRgRAIAFBuwJqIAFBpAFqKAIAIgI2AAAgAUGzAmogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AKsCIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADB0LIAFBtwJqIgQgAUGgAWopAAA3AAAgAUGwAmoiBSABQZkBaikAADcDACABQegAaiABQbABaikCADcCACABQfAAaiABQbgBaikCADcCACABQdEAaiAFKQMANwAAIAFB2ABqIAQpAAA3AAAgASABKQCRASIbNwOoAiABIAEpAqgBNwJgIAEgGzcASSABIAM6AEgMFAsgACAFIAYQ7yEgAi0AACADLQAAIAQQtAkMGwsgACAFIAYQgiIgAi0AACADLQAAIAQQswkMGgsgACAFIAYgAi0AACADLQAAIAQQxAEMGQsgACAFIAYgAi0AACADLQAAIAQQxQEMGAsgAUHIAGogBSABQSBqIAFBHmoQ3AQMFgsgAUHIAGogBSABQSBqIAFBHmoQ8AQMFQsgAUHIAGogBSABQSBqIAFBHmoQ2QQMEwsgAUHIAGogBSABQSBqIAFBHmoQgwUMEgsgAUHIAGogBSABQSBqIAFBHmoQ2gQMEAsgAUHIAGogBSABQSBqIAFBHmoQ0QQMDwsgAUHIAGogBSABQSBqIAFBHmoQgQUMDQsgAUHIAGogBSABQSBqIAFBHmoQ8wQMDAsgAUHIAGogBSABQSBqIAFBHmoQhQUMCgsgAUHIAGogBSABQSBqIAFBHmoQ4gQMCQsgAUHIAGogBSABQSBqIAFBHmoQzQQMBwsgAUHIAGogBSABQSBqIAFBHmoQ/AQMBgsgAUHIAGogBSABQSBqIAFBHmoQ1wQMBAsgAUHIAGogBSABQSBqIAFBHmoQ5wQMAwsgAUHIAGogBSABQSBqIAFBHmoQzAQMAQsgAUHIAGogBSABQSBqIAFBHmoQygQLIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwICyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAgLDPMCCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBwsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQN4NwAJIAIgASkDyAE3AiAgAEH4yv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwHCwzyAgsgAUGQAWogAUHIAGogAS0AHiACEKMTIAEtAJABIgNBKUYEQCABQYsBaiABQaQBaigCACICNgAAIAFBgwFqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwB7IABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAYLIAFBhwFqIgQgAUGgAWopAAA3AAAgAUGAAWoiBSABQZkBaikAADcDACABQdABaiIGIAFBsAFqKQIANwMAIAFB2AFqIgcgAUG4AWopAgA3AwAgASABKQCRATcDeCABIAEpAqgBNwPIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDeDcACSACIAEpA8gBNwIgIABB+Mr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMBgsM8QILIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwFCyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAULDPACCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICBEAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQN4NwAJIAIgASkDyAE3AiAgAEH4yv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAwECwzvAgsgAUGQAWogAUHIAGogAS0AHiACEKMTIAEtAJABIgNBKUYEQCABQYsBaiABQaQBaigCACICNgAAIAFBgwFqIAFBnAFqKQIAIhs3AAAgASABKQKUASIcNwB7IABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAMLIAFBhwFqIgQgAUGgAWopAAA3AAAgAUGAAWoiBSABQZkBaikAADcDACABQdABaiIGIAFBsAFqKQIANwMAIAFB2AFqIgcgAUG4AWopAgA3AwAgASABKQCRATcDeCABIAEpAqgBNwPIARCwPkE4QQQQrTYiAgRAIAIgAzoACCACQoGAgIAQNwIAIAIgASkDeDcACSACIAEpA8gBNwIgIABB+Mr/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgAMAwsM7gILIAFBkAFqIAFByABqIAEtAB4gAhCjEyABLQCQASIDQSlGBEAgAUGLAWogAUGkAWooAgAiAjYAACABQYMBaiABQZwBaikCACIbNwAAIAEgASkClAEiHDcAeyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQYcBaiIEIAFBoAFqKQAANwAAIAFBgAFqIgUgAUGZAWopAAA3AwAgAUHQAWoiBiABQbABaikCADcDACABQdgBaiIHIAFBuAFqKQIANwMAIAEgASkAkQE3A3ggASABKQKoATcDyAEQsD5BOEEEEK02IgIEQCACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIADAILDO0CCyABQZABaiABQcgAaiABLQAeIAIQoxMgAS0AkAEiA0EpRgRAIAFBiwFqIAFBpAFqKAIAIgI2AAAgAUGDAWogAUGcAWopAgAiGzcAACABIAEpApQBIhw3AHsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAQsgAUGHAWoiBCABQaABaikAADcAACABQYABaiIFIAFBmQFqKQAANwMAIAFB0AFqIgYgAUGwAWopAgA3AwAgAUHYAWoiByABQbgBaikCADcDACABIAEpAJEBNwN4IAEgASkCqAE3A8gBELA+QThBBBCtNiICRQ3sAiACIAM6AAggAkKBgICAEDcCACACIAEpA3g3AAkgAiABKQPIATcCICAAQfjK/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQcACaiQADAALDOUCCyAMQSBGDeACIA1BAUYNASANQSBGDQMLIAxBFGsOBxMUFRYXGBkSCyAMQQJrDhkDBAUGBwgJCgsMDQICAgICAgICAgICDg8QAgsgDEEgRg3eAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAzgAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAzfAgsjAEGAAWsiASQAIAFBOGogBSAGEPIhIgNBDGoiBBCoPhD0GCAEEKg+IgUEQCADKAIQIQZBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAQQqD4gAksEQCACIAZqLQAARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM8gILIAFBOGoQoBILIAUgAkEBaiICRw0ACwsgAUEMaiABQThqIgIQyg0gAhDxLwJAAkAgASgCDEUEQCAAIAEpAhA3AgAgAEEQaiABQSBqKAIANgIAIABBCGogAUEYaikCADcCAAwBCxCwPkE0QQQQrTYiAkUN8QIgAkKBgICAEDcCACACQQhqIAFBDGpBLPwKAAAgAEGA6f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQYABaiQADAALDN4CCyMAQYABayIBJAAgAUE4aiAFIAYQ+CEiA0EMaiIFENk8EPQYIAUQ2TwiBgRAIAMoAhAhBEEAIQIDQAJAIAMgAhCHJUUEQCABIAI2AmggBRDZPCACSwRAIAQvAQAQuz5B//8DcUYEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQJqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3wAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM3QILIwBBgAFrIgEkACABQThqIAUgBhD7ISIDQQxqIgUQ2zwQ9BggBRDbPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENs8IAJLBEAgBCgCABC7PkYEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQRqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3vAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM3AILIwBBgAFrIgEkACABQThqIAUgBhDzISIDQQxqIgUQ2DwQ9BggBRDYPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENg8IAJLBEAgBCkDABDBPlEEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDPMCCyABQThqEKASCyAEQQhqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3uAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM2wILIwBBgAFrIgEkACABQThqIAUgBhD3ISIDQQxqIgQQqD4Q9BggBBCoPiIFBEAgAygCECEGQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAEEKg+IAJLBEAgAiAGai0AAEUEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDO4CCyABQThqEKASCyAFIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDe0CIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzaAgsjAEGAAWsiASQAIAFBOGogBSAGEPAhIgNBDGoiBRDZPBD0GCAFENk8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2TwgAksEQCAELwEARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBAmohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDewCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzZAgsjAEGAAWsiASQAIAFBOGogBSAGEPUhIgNBDGoiBRDbPBD0GCAFENs8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2zwgAksEQCAEKAIARQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBBGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDesCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzYAgsjAEGAAWsiASQAIAFBOGogBSAGEOwhIgNBDGoiBRDYPBD0GCAFENg8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2DwgAksEQCAEKQMAUARAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7wILIAFBOGoQoBILIARBCGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDeoCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzXAgsjAEGAAWsiASQAIAFBOGogBSAGEPQhIgNBDGoiBRDZPBD0GCAFENk8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2TwgAksEQCABIAQvAQA7AXAgAUEAOwEMIAFB8ABqIAFBDGoQjSgEQCABQThqQQAQqQ8MAwsgAUE4akEBEKkPDAILDOwCCyABQThqEKASCyAEQQJqIQQgBiACQQFqIgJHDQALCyABQQxqIAFBOGoiAhDKDSACEPEvAkACQCABKAIMRQRAIAAgASkCEDcCACAAQRBqIAFBIGooAgA2AgAgAEEIaiABQRhqKQIANwIADAELELA+QTRBBBCtNiICRQ3pAiACQoGAgIAQNwIAIAJBCGogAUEMakEs/AoAACAAQYDp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBgAFqJAAMAAsM1gILIwBBgAFrIgEkACABQThqIAUgBhDvISIDQQxqIgUQ2zwQ9BggBRDbPCIGBEAgAygCECEEQQAhAgNAAkAgAyACEIclRQRAIAEgAjYCaCAFENs8IAJLBEAgBCoCAEMAAAAAWwRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7AILIAFBOGoQoBILIARBBGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDegCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzVAgsjAEGAAWsiASQAIAFBOGogBSAGEIIiIgNBDGoiBRDYPBD0GCAFENg8IgYEQCADKAIQIQRBACECA0ACQCADIAIQhyVFBEAgASACNgJoIAUQ2DwgAksEQCAEKwMARAAAAAAAAAAAYQRAIAFBOGpBABCpDwwDCyABQThqQQEQqQ8MAgsM7AILIAFBOGoQoBILIARBCGohBCAGIAJBAWoiAkcNAAsLIAFBDGogAUE4aiICEMoNIAIQ8S8CQAJAIAEoAgxFBEAgACABKQIQNwIAIABBEGogAUEgaigCADYCACAAQQhqIAFBGGopAgA3AgAMAQsQsD5BNEEEEK02IgJFDecCIAJCgYCAgBA3AgAgAkEIaiABQQxqQSz8CgAAIABBgOn/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGAAWokAAwACwzUAgsjAEGQAWsiASQAIAEgBSAGKAIQEQAAIAFBIGoiAyABKAIAIgIgASgCBCgCDBEAAAJAAkAgAkUNACABKQMgQsfZ9OfexLacd4UgASkDKEKNss6UjMqS5qd/hYRQRQ0AIAIQ0zohBSABQewAaiACEPk0IAEgBDYCjAEgASAFNgKIASABQQA2AoQBIAEgAjYCaCADIAFB6ABqEL8ZIAFBEGoiAiABQSxqKQIANwMAIAFBGGoiAyABQTRqKAIANgIAIAEgASkCJDcDCAJAIAEoAiAiBEUEQCAAIAEpAwg3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQeAAaiIFIAFByABqKAIANgIAIAFB2ABqIgYgAUFAaykCADcDACABQfAAaiIHIAIpAwA3AwAgAUH4AGoiCSADKAIANgIAIAEgASkCODcDUCABIAEpAwg3A2gQsD5BNEEEEK02IgJFDecCIAIgBDYCCCACQoGAgIAQNwIAIAIgASkDaDcCDCACIAEpA1A3AiAgAEG4joABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBFGogBykDADcCACACQRxqIAkoAgA2AgAgAkEoaiAGKQMANwIAIAJBMGogBSgCADYCAAsgAUGQAWokAAwBC0GQj4ABELI7AAsM0wILIwBBkAFrIgEkACABIAUgBigCEBEAACABQSBqIgMgASgCACICIAEoAgQoAgwRAAACQAJAIAJFDQAgASkDIELT2NP4/eb2kkiFIAEpAyhCotieiOGg6unMAIWEUEUNACACENQ6IQUgAUHsAGogAhD5NCABIAQ2AowBIAEgBTYCiAEgAUEANgKEASABIAI2AmggAyABQegAahC+GSABQRBqIgIgAUEsaikCADcDACABQRhqIgMgAUE0aigCADYCACABIAEpAiQ3AwgCQCABKAIgIgRFBEAgACABKQMINwIAIABBEGogAygCADYCACAAQQhqIAIpAwA3AgAMAQsgAUHgAGoiBSABQcgAaigCADYCACABQdgAaiIGIAFBQGspAgA3AwAgAUHwAGoiByACKQMANwMAIAFB+ABqIgkgAygCADYCACABIAEpAjg3A1AgASABKQMINwNoELA+QTRBBBCtNiICRQ3mAiACIAQ2AgggAkKBgICAEDcCACACIAEpA2g3AgwgAiABKQNQNwIgIABBuI6AATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRRqIAcpAwA3AgAgAkEcaiAJKAIANgIAIAJBKGogBikDADcCACACQTBqIAUoAgA2AgALIAFBkAFqJAAMAQtBkI+AARCyOwALDNICCyMAQaABayIBJAAgAUEIaiAFIAYoAhARAAAgAUEwaiIDIAEoAggiAiABKAIMKAIMEQAAAkACQCACRQ0AIAEpAzBCq5iR8ZX61fyAf4UgASkDOEKWlPir8LHps+EAhYRQRQ0AIAEgAjYCFCABQfgAaiICIAFBFGoQ+ikgASAENgKcASADIAIQwBkgAUEgaiICIAFBPGopAgA3AwAgAUEoaiIDIAFBxABqKAIANgIAIAEgASkCNDcDGAJAIAEoAjAiBEUEQCAAIAEpAxg3AgAgAEEQaiADKAIANgIAIABBCGogAikDADcCAAwBCyABQfAAaiIFIAFB2ABqKAIANgIAIAFB6ABqIgYgAUHQAGopAgA3AwAgAUGAAWoiByACKQMANwMAIAFBiAFqIgkgAygCADYCACABIAEpAkg3A2AgASABKQMYNwN4ELA+QTRBBBCtNiICRQ3lAiACIAQ2AgggAkKBgICAEDcCACACIAEpA3g3AgwgAiABKQNgNwIgIABBuI6AATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRRqIAcpAwA3AgAgAkEcaiAJKAIANgIAIAJBKGogBikDADcCACACQTBqIAUoAgA2AgALIAFBoAFqJAAMAQtBoI+AARCyOwALDNECCyAMQQFHBEAgDUECaw4ZjQGOAY8BkAGRAZIBkwGUAZUBlgGXAboCmAGZAZoBmwG6AroCjAG6ArICugKzArUCtwK6AgsgDUECaw4ZCAkKCwwNDg8QERIHBwcHBwcHBwcHB7MCtQK3AgcLIA1BFWsOBhMUFRYXGBILIA1BFGsOBBkYGhsYCyANQRRrDgccHRseIB8hGwsgDUEUaw4HIiEjISQlJiELIA1BAmsOGSYnKCkqKywtxQIuLzAxMjM0xQI1NsUCNzjFAjk6xQILIA1BAmsOGUVGR0hJSktMwwJNTk9QUVJTwwJUVcMCVldYwwJZwwILIA1BAmsOGGRlZmdoaWprwQJsbW5vcHFywQJzdMECdXZ3eMECCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADMgCCyAAIQMjAEGwAWsiByQAIAdBGGogBSAGKAIQEQAAIAdB0ABqIAcoAhgiBSAHKAIcKAIMEQAAAn8CQAJAIAVFDd8CIAcpA1BCiqLN5aLCqolqhSAHKQNYQouy+d7NmrveOYWEUEUN3wIgByAFEK0+IgA2ApgBIAdBIGpBfyAAQQdqIgEgACABSxtBA3YQ0h8gACIBQT9xIgIEQCABIAEgAmtBQGsiAUsN4QILQcAAIQIgAUHAABDRNEUN4QIgAQRAELA+IAFBwAAQrTYiAkUNAQsgBygCKCEGIABFBEAgAiEEQQAMAwtBACEEA0AgAiAEaiEJAkAgBSAEEJUlRQRAIAkgBSAEEIQaOgAAIAYgBEEDdmoiCSAJLQAAQQEgBEEHcXRyOgAADAELIAlBADoAAAsgBEEBaiIEIABHDQALDAELQcAAIAEQoz0ACyACIARqIQQgBygCmAELIQUgByAEIAJrIgQ2AqQBAkAgBCAFRgRAIAcoAiwhBSAHIAcpAiA3AlwgB0EANgJYIAcgBTYCVCAHIAY2AlAgB0EQaiAHQdAAaiIGENc7IAcoAhAhCRCwPkEcQQQQrTYiBEUN4QIgBEKBgICAEDcCACAEIAcpAlA3AgggBEEQaiAHQdgAaiIKKQIANwIAIARBGGogB0HgAGoiCygCADYCACAHIAE2AmAgB0KAgICAgAg3AlggByAANgJUIAcgAjYCUCAHQQhqIAYQ1zsgBygCCCEGELA+QRxBBBCtNiIBRQRADOICCyABQoGAgIAQNwIAIAEgBykCUDcCCCABQRBqIAopAgA3AgAgAUEYaiALKAIANgIAIAcgBTYCoAEgByAJNgKcASAHIAQ2ApgBELA+QQxBBBCtNiICRQ3jAiACIAA2AgggAiAGNgIEIAIgATYCACAHQQE2AqwBIAcgAjYCqAEgB0EBNgKkASAHQQA2AiggB0KAgICAwAA3AiAgB0HQAGoiBEGgvP8AIAAgAiAHQZgBaiAHQaQBaiAHQSBqIgEQjBMgASAEELYTELA+QThBBBCtNiIARQ3OAiAAQoGAgIAQNwIAIABBCGogAUEw/AoAACADQaDm/wA2AgggAyAANgIEIANBk4CAgHg2AgAgB0GwAWokAAwBCwzhAgsMxwILIAAhAiMAQbABayIDJAAgA0EYaiAFIAYoAhARAAAgA0HQAGogAygCGCIJIAMoAhwoAgwRAAACfwJAIAlFDd0CIAMpA1BCiqLN5aLCqolqhSADKQNYQouy+d7NmrveOYWEUEUN3QIgAyAJEK0+IgQ2ApgBIANBIGpBfyAEQQdqIgAgACAESRtBA3YQ0h8gBEEBdCIHIQUgB0E+cSIABEAgByAAa0FAayIFIAdJDd8CC0HAACEBIAVBwAAQ0TRFDeMCIAUEQBCwPiAFQcAAEK02IgFFDeUCCyADKAIoIQogBEUEQCABIQBBAAwCCyABIQBBACEGA0ACQCAJIAYQlSVFBEAgACAJIAYQhBoEf0EBBRC7Pgs7AQAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEAOwEACyAAQQJqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0EBdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDeACIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzhAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN4gIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBjL3/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRC9ExCwPkE4QQQQrTYiAEUNzQIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkH45v8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM5AILDMYCCyAAIQFBACEAQQAhAkEAIQojAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCyADKAIcKAIMEQAAAkAgC0UN2wIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3bAiADIAsQrT4iBTYCrAEgA0EgakF/IAVBB2oiBCAEIAVJG0EDdhDSHyAFQQJ0IgYhBCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkN3QILQcAAIQ0gBEHAABDRNEUN4QIgBARAELA+IARBwAAQrTYiDUUN5QILIAMoAighDkEAIQxBACEHA0AgA0HQAGohCQJ/IAUgB00EQEECIQogAAwBC0EAIQkCQCALIAcQlSUNAEEBIQkgCyAHEIQaBEBBASEKDAELELs+IQoLIAdBAWohByADIAk2AlAgA0GUAWohCSAAIgJBAWoLIQAgCSAKNgIAAkACQAJAIAMoAlAiD0ECRwRAIAwgDWohCSAPQQFxRQ0BIAkgAygClAE2AgAgDiACQQN2aiIJIAktAABBASACQQdxdHI6AAAMAgsgAyAMQQJ1IgA2AqABIAAgAygCrAFHDekCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIA42AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN4gIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiCygCADYCACADIAQ2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgDTYCUCADQQhqIAIQ1zsgAygCCCEEELA+QRxBBBCtNiICDQIM4gILIAlBADYCAAsgDEEEaiEMDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiALKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3gAiAAIAY2AgggACAENgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEGAvf8AIAUgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAEK0TELA+QThBBBCtNiIARQ3LAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZDS/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzFAgsgACEBQQAhAEEAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN2gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3aAiADIAkQrT4iBDYCrAEgA0EgakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgYhBSAGQThxIgcEQCAGIAdrQUBrIgUgBkkN3AILQcAAIQsgBUHAABDRNEUN4AIgBQRAELA+IAVBwAAQrTYiC0UN4gILQQAhCiADKAIoIQxBACEHA0AgA0HQAGohDQJ/IAQgB00EQEICIRsgAAwBC0IAIRwCQCAJIAcQlSUNAEIBIRwgCSAHEIQaBEBCASEbDAELEME+IRsLIAdBAWohByADIBw3A1AgA0GgAWohDSAAIgJBAWoLIQAgDSAbNwMAAkACQAJAIAMpA1AiG0ICUgRAIAogC2ohDSAbp0EBcUUNASANIAMpA6ABNwMAIAwgAkEDdmoiDSANLQAAQQEgAkEHcXRyOgAADAILIAMgCkEDdSIANgKUASAAIARHDekCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIAw2AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN4QIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiDCgCADYCACADIAU2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgCzYCUCADQQhqIAIQ1zsgAygCCCEFELA+QRxBBBCtNiICDQIM4QILIA1CADcDAAsgCkEIaiEKDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3fAiAAIAY2AgggACAFNgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEHQvP8AIAQgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAELETELA+QThBBBCtNiIARQ3KAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQejS/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzEAgsgACEDIwBBsAFrIgckACAHQRhqIAUgBigCEBEAACAHQdAAaiAHKAIYIgUgBygCHCgCDBEAAAJ/AkACQCAFRQ3bAiAHKQNQQoqizeWiwqqJaoUgBykDWEKLsvnezZq73jmFhFBFDdsCIAcgBRCtPiIANgKYASAHQSBqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIAAiAUE/cSICBEAgASABIAJrQUBrIgFLDd0CC0HAACECIAFBwAAQ0TRFDd0CIAEEQBCwPiABQcAAEK02IgJFDQELIAcoAighBiAARQRAIAIhBEEADAMLQQAhBANAIAIgBGohCQJAIAUgBBCVJUUEQCAJIAUgBBCEGjoAACAGIARBA3ZqIgkgCS0AAEEBIARBB3F0cjoAAAwBCyAJQQA6AAALIARBAWoiBCAARw0ACwwBC0HAACABEKM9AAsgAiAEaiEEIAcoApgBCyEFIAcgBCACayIENgKkAQJAIAQgBUYEQCAHKAIsIQUgByAHKQIgNwJcIAdBADYCWCAHIAU2AlQgByAGNgJQIAdBEGogB0HQAGoiBhDXOyAHKAIQIQkQsD5BHEEEEK02IgRFDd0CIARCgYCAgBA3AgAgBCAHKQJQNwIIIARBEGogB0HYAGoiCikCADcCACAEQRhqIAdB4ABqIgsoAgA2AgAgByABNgJgIAdCgICAgIAINwJYIAcgADYCVCAHIAI2AlAgB0EIaiAGENc7IAcoAgghBhCwPkEcQQQQrTYiAUUEQAzeAgsgAUKBgICAEDcCACABIAcpAlA3AgggAUEQaiAKKQIANwIAIAFBGGogCygCADYCACAHIAU2AqABIAcgCTYCnAEgByAENgKYARCwPkEMQQQQrTYiAkUN3wIgAiAANgIIIAIgBjYCBCACIAE2AgAgB0EBNgKsASAHIAI2AqgBIAdBATYCpAEgB0EANgIoIAdCgICAgMAANwIgIAdB0ABqIgRB6Lz/ACAAIAIgB0GYAWogB0GkAWogB0EgaiIBEIwTIAEgBBC4ExCwPkE4QQQQrTYiAEUNygIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgA0HI5f8ANgIIIAMgADYCBCADQZOAgIB4NgIAIAdBsAFqJAAMAQsM3QILDMMCCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAn8CQCAJRQ3ZAiADKQNQQoqizeWiwqqJaoUgAykDWEKLsvnezZq73jmFhFBFDdkCIAMgCRCtPiIENgKYASADQSBqQX8gBEEHaiIAIAAgBEkbQQN2ENIfIARBAXQiByEFIAdBPnEiAARAIAcgAGtBQGsiBSAHSQ3bAgtBwAAhASAFQcAAENE0RQ3fAiAFBEAQsD4gBUHAABCtNiIBRQ3hAgsgAygCKCEKIARFBEAgASEAQQAMAgsgASEAQQAhBgNAAkAgCSAGEJUlRQRAIAAgCSAGEIQaOwEAIAogBkEDdmoiCyALLQAAQQEgBkEHcXRyOgAADAELIABBADsBAAsgAEECaiEAIAZBAWoiBiAERw0ACwwACyADKAKYAQshBiADIAAgAWtBAXUiADYCpAECQCAAIAZGBEAgAygCLCEGIAMgAykCIDcCXCADQQA2AlggAyAGNgJUIAMgCjYCUCADQRBqIANB0ABqIgkQ1zsgAygCECEKELA+QRxBBBCtNiIARQ3cAiAAQoGAgIAQNwIAIAAgAykCUDcCCCAAQRBqIANB2ABqIgspAgA3AgAgAEEYaiADQeAAaiIMKAIANgIAIAMgBTYCYCADQoCAgICACDcCWCADIAc2AlQgAyABNgJQIANBCGogCRDXOyADKAIIIQUQsD5BHEEEEK02IgFFBEAM3QILIAFCgYCAgBA3AgAgASADKQJQNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAGNgKgASADIAo2ApwBIAMgADYCmAEQsD5BDEEEEK02IgBFDd4CIAAgBzYCCCAAIAU2AgQgACABNgIAIANBATYCrAEgAyAANgKoASADQQE2AqQBIANBADYCKCADQoCAgIDAADcCICADQdAAaiIFQdy8/wAgBCAAIANBmAFqIANBpAFqIANBIGoiARCMEyABIAUQqhMQsD5BOEEEEK02IgBFDckCIABCgYCAgBA3AgAgAEEIaiABQTD8CgAAIAJBmOT/ADYCCCACIAA2AgQgAkGTgICAeDYCACADQbABaiQADAELDOACCwzCAgsgACEBQQAhAEEAIQJBACEMIwBBsAFrIgMkACADQRhqIAUgBigCEBEAACADQdAAaiADKAIYIgogAygCHCgCDBEAAAJAIApFDdcCIAMpA1BCiqLN5aLCqolqhSADKQNYQouy+d7NmrveOYWEUEUN1wIgAyAKEK0+IgU2AqwBIANBIGpBfyAFQQdqIgQgBCAFSRtBA3YQ0h8gBUECdCIGIQQgBkE8cSIHBEAgBiAHa0FAayIEIAZJDdkCC0HAACENIARBwAAQ0TRFDd0CIAQEQBCwPiAEQcAAEK02Ig1FDeECCyADKAIoIQ5BACELQQAhBwNAIANB0ABqIQkCfyAFIAdNBEBBAiEMIAAMAQtBACEJIAogBxCVJUUEQCAKIAcQhBohDEEBIQkLIAdBAWohByADIAk2AlAgA0GUAWohCSAAIgJBAWoLIQAgCSAMNgIAAkACQAJAIAMoAlAiD0ECRwRAIAsgDWohCSAPQQFxRQ0BIAkgAygClAE2AgAgDiACQQN2aiIJIAktAABBASACQQdxdHI6AAAMAgsgAyALQQJ1IgA2AqABIAAgAygCrAFHDeUCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIA42AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN3gIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiCygCADYCACADIAQ2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgDTYCUCADQQhqIAIQ1zsgAygCCCEEELA+QRxBBBCtNiICDQIM3gILIAlBADYCAAsgC0EEaiELDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiALKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3cAiAAIAY2AgggACAENgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEHwu/8AIAUgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAELkTELA+QThBBBCtNiIARQ3HAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQdDn/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzBAgsgACEBQQAhAEEAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN1gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3WAiADIAkQrT4iBDYCrAEgA0EgakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgYhBSAGQThxIgcEQCAGIAdrQUBrIgUgBkkN2AILQcAAIQsgBUHAABDRNEUN3AIgBQRAELA+IAVBwAAQrTYiC0UN3gILQQAhCiADKAIoIQxBACEHA0AgA0HQAGohDQJ/IAQgB00EQEICIRsgAAwBC0IAIRwgCSAHEJUlRQRAQgEhHCAJIAcQhBqtIRsLIAdBAWohByADIBw3A1AgA0GgAWohDSAAIgJBAWoLIQAgDSAbNwMAAkACQAJAIAMpA1AiG0ICUgRAIAogC2ohDSAbp0EBcUUNASANIAMpA6ABNwMAIAwgAkEDdmoiDSANLQAAQQEgAkEHcXRyOgAADAILIAMgCkEDdSIANgKUASAAIARHDeUCIAMoAiwhByADIAMpAiA3AlwgA0EANgJYIAMgBzYCVCADIAw2AlAgA0EQaiADQdAAaiICENc7IAMoAhAhCRCwPkEcQQQQrTYiAEUN3QIgAEKBgICAEDcCACAAIAMpAlA3AgggAEEQaiADQdgAaiIKKQIANwIAIABBGGogA0HgAGoiDCgCADYCACADIAU2AmAgA0KAgICAgAg3AlggAyAGNgJUIAMgCzYCUCADQQhqIAIQ1zsgAygCCCEFELA+QRxBBBCtNiICDQIM3QILIA1CADcDAAsgCkEIaiEKDAELCyACQoGAgIAQNwIAIAIgAykCUDcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAMgBzYCnAEgAyAJNgKYASADIAA2ApQBELA+QQxBBBCtNiIARQ3bAiAAIAY2AgggACAFNgIEIAAgAjYCACADQQE2AqgBIAMgADYCpAEgA0EBNgKgASADQQA2AiggA0KAgICAwAA3AiAgA0HQAGoiAEG4vP8AIAQgAyADQZQBaiADQaABaiADQSBqIgIQjBMgAiAAEK4TELA+QThBBBCtNiIARQ3GAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQfDk/wA2AgggASAANgIEIAFBk4CAgHg2AgAgA0GwAWokAAwACwzAAgsgACECIwBBsAFrIgMkACADQRhqIAUgBigCEBEAACADQdAAaiADKAIYIgkgAygCHCgCDBEAAAJ/AkAgCUUN1gIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3WAiADIAkQrT4iBDYCmAEgA0EgakF/IARBB2oiACAAIARJG0EDdhDSHyAEQQF0IgchBSAHQT5xIgAEQCAHIABrQUBrIgUgB0kN2AILQcAAIQEgBUHAABDRNEUN3AIgBQRAELA+IAVBwAAQrTYiAUUN3gILIAMoAighCiAERQRAIAEhAEEADAILIAEhAEEAIQYDQAJAIAkgBhCVJUUEQCAAQYD4AEEAIAkgBhCEGhs7AQAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEAOwEACyAAQQJqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0EBdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdkCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzaAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2wIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBlLz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRCrExCwPkE4QQQQrTYiAEUNxgIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkHo4v8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM3QILDL8CCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAn8CQCAJRQ3VAiADKQNQQoqizeWiwqqJaoUgAykDWEKLsvnezZq73jmFhFBFDdUCIAMgCRCtPiIENgKYASADQSBqQX8gBEEHaiIAIAAgBEkbQQN2ENIfIARBAnQiByEFIAdBPHEiAARAIAcgAGtBQGsiBSAHSQ3XAgtBwAAhASAFQcAAENE0RQ3bAiAFBEAQsD4gBUHAABCtNiIBRQ3dAgsgAygCKCEKIARFBEAgASEAQQAMAgsgASEAQQAhBgNAAkAgCSAGEJUlRQRAIABDAACAP0MAAAAAIAkgBhCEGhs4AgAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEEANgIACyAAQQRqIQAgBkEBaiIGIARHDQALDAALIAMoApgBCyEGIAMgACABa0ECdSIANgKkAQJAIAAgBkYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdgCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzZAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2gIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVBrLz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRCzExCwPkE4QQQQrTYiAEUNxQIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkHA4/8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM3AILDL4CCyAAIQIjAEGwAWsiAyQAIANBGGogBSAGKAIQEQAAIANB0ABqIAMoAhgiCSADKAIcKAIMEQAAAkAgCUUN0wIgAykDUEKKos3losKqiWqFIAMpA1hCi7L53s2au945hYRQRQ3TAiADIAkQrT4iBDYCmAEgA0EgakF/IARBB2oiACAAIARJG0EDdhDSHyAEQQN0IgchBSAHQThxIgAEQCAHIABrQUBrIgUgB0kN1QILQcAAIQEgBUHAABDRNEUN2QIgBQRAELA+IAVBwAAQrTYiAUUN2wILIAMoAighCiABIQAgBEUNAEEAIQYDQAJAIAkgBhCVJUUEQCAARAAAAAAAAPA/RAAAAAAAAAAAIAkgBhCEGhs5AwAgCiAGQQN2aiILIAstAABBASAGQQdxdHI6AAAMAQsgAEIANwMACyAAQQhqIQAgBCAGQQFqIgZHDQALDAALIAMgACABa0EDdSIANgKkAQJAIAAgBEYEQCADKAIsIQYgAyADKQIgNwJcIANBADYCWCADIAY2AlQgAyAKNgJQIANBEGogA0HQAGoiCRDXOyADKAIQIQoQsD5BHEEEEK02IgBFDdcCIABCgYCAgBA3AgAgACADKQJQNwIIIABBEGogA0HYAGoiCykCADcCACAAQRhqIANB4ABqIgwoAgA2AgAgAyAFNgJgIANCgICAgIAINwJYIAMgBzYCVCADIAE2AlAgA0EIaiAJENc7IAMoAgghBRCwPkEcQQQQrTYiAUUEQAzYAgsgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiALKQIANwIAIAFBGGogDCgCADYCACADIAY2AqABIAMgCjYCnAEgAyAANgKYARCwPkEMQQQQrTYiAEUN2QIgACAHNgIIIAAgBTYCBCAAIAE2AgAgA0EBNgKsASADIAA2AqgBIANBATYCpAEgA0EANgIoIANCgICAgMAANwIgIANB0ABqIgVB9Lz/ACAEIAAgA0GYAWogA0GkAWogA0EgaiIBEIwTIAEgBRDHExCwPkE4QQQQrTYiAEUNxAIgAEKBgICAEDcCACAAQQhqIAFBMPwKAAAgAkGo6P8ANgIIIAIgADYCBCACQZOAgIB4NgIAIANBsAFqJAAMAQsM2wILDL0CCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLwCCyMAQYABayIBJAAgAUEIaiAFIAYQlyIiAxDTOiALEI8XAkACQCADENM6IgUEQEEAIQIgBC0ANEEBcSEEA0ACQCADIAIQliVFBEAgASADIAIQgBcgAUE0aiABQQhqIAEoAgAgASgCBBCiECABKAI0QZOAgIB4Rg0BIAFB2ABqIAFBxABqKAIANgIAIAFB0ABqIAFBPGopAgA3AwAgASABKQI0NwNIIARFBEAgACABKQI0NwIAIABBEGogAUHEAGooAgA2AgAgAEEIaiABQTxqKQIANwIADAULIAFBCGoQkRUgAUHIAGoQiBEMAQsgAUEIahCRFQsgBSACQQFqIgJHDQALCyABQcgAaiIDIAFBCGoQxxQQsD5BwABBBBCtNiICRQ3HAiACQoGAgIAQNwIAIAJBCGogA0E4/AoAACAAQejp/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBCGoQii8gAUGAAWokAAwACwy7AgsgACAFIAYQrgYMugILIAhB0ABqIQcgBSAGEJciIQQjAEGwAWsiAyQAIAQoAhAhAQJAAkACQCAEKAIUIgJBBEkNACABIAJBfHFqQQRrIgVFDQAgBSgCAEF/Rg0BCyADIAQQ0zoiCTYCDCADQRBqIgYgCRDEGyAEKAIYIgUgBSgCACIKQQFqNgIAAkACQCAKQQBOBEAgAyAFNgKIASADIAQpAhw3AowBIAYgA0GIAWoQ2SAhDiACQQhJDQIgAkECdiEKIANByABqIQ8gA0HsAGohC0EAIQUDQCABQQRqIgIoAgAhBiABKAIAIQECQCAEIAUQliVFBEAgA0EQaiAOIAEgBiABaxCJEAwBCyALEOY6IAMoAmxFDQMgAygCfEEBaiIMQQN2IAxBB3FBAEdqIgEgAygCeCIGSwRAIAEgBmshDSADKAJwIhAgAUkEQCALIBBBAXQiBiABENAqIhAgBiAQSxsQ6BkgAygCeCEGCyANBEAgAygCdCAGakEAIA38CwALIAMgATYCeAsgAyAMNgJ8IAMoAlAiASADKAJIRgRAIA9B/OmAARCxKAsgAygCTCABQQR0aiIGQgA3AwggBkIANwMAIAMgAUEBajYCUAsgBUEBaiEFIAIhASAKQQFrIgpBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAJRgRAIAcgARDcDCABEOklDAILDNwCCyAEENM6IQEgA0EUaiAEEPk0IAMgATYCMCADQQA2AiwgAyAENgIQIAcgA0EQahDFDwsgA0GwAWokACAHEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADLkCCyAAIAUgBiAEEM8HDLgCCyAIQdAAaiAFIAYgBBDPByAIKAJYIQIgCCgCVCEBIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACACNgIIIAAgATYCBCAAIAM2AgAMuAILIAggAjYClAIgCCABNgKQAiAAIAEgAigCCEEBa0F4cWpBCGogAhCvBiABIAEoAgAiAEEBazYCACAAQQFHDbcCIAhBkAJqELsjDLcCCyAIQZACaiAFIAYgBBDPByAIKAKYAiECIAgoApQCIQEgCCgCkAIiA0GTgICAeEcEQCAAIAgpApwCNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADLcCCyAIIAI2AsQDIAggATYCwAMgCEHAA2oiAygCACADKAIEIgQoAghBAWtBeHFqQQhqIAQQlyQiBEUEQEGA4oABQQxBjOKAARDLJAALIAhB0ABqIgIgBBCcCiACEOwpIQIgAEHI4P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEgASgCACIAQQFrNgIAIABBAUcNtgIgAxC7Iwy2AgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAy1AgsgCSgCBCEEIwBBoAFrIgEkACABQSBqIAUgBigCEBEAACABQeAAaiIDIAEoAiAiAiABKAIkKAIMEQAAAkACQAJAAkACQCACRQ0AIAEpA2BCwOO13tL+pZUshSABKQNoQvXOqKjR/trMpH+FhFBFDQAgAjUCMCEbIAFB6ABqQZSo0KABNgIAIAFClKjQoMGChYoUNwNgIAFBEGogG0IAIASsIhsgG0I/hxCoHiABKQMYIRsgASkDECADEKcMQoCAgIAIVCAbQgBTIBtQG0UEQCADQTdBAEEBQQEQoBggASgCZCECIAEoAmBBAUYNAiABKAJoIgNB0Or/AEE3/AoAACAAQTc2AgwgACADNgIIIAAgAjYCBCAAQYaAgIB4NgIADAQLIAFBLGogAigCMCIDIAMQphQgAigCMCIERQ0CQQAhAwNAAkAgAiADEJslRQRAIAFBCGogAiADEKAbIAFBLGogASgCCCABKAIMEP0SDAELIAFBLGoQphULIAQgA0EBaiIDRw0ACwwCC0HA6v8AELI7AAsgAiABKAJoQYzJ/wAQ/S8ACyABQeAAaiIDIAFBLGoiBBDrDhCwPkHEAEEEEK02IgJFDbwCIAJCgYCAgBA3AgAgAkEIaiADQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACAEELosCyABQaABaiQADAALDLQCCyMAQZABayIBJAAgAUEQaiAFIAYoAhARAAAgAUHQAGoiAyABKAIQIgIgASgCFCgCDBEAAAJAAkAgAkUNACABKQNQQsDjtd7S/qWVLIUgASkDWEL1zqio0f7azKR/hYRQRQ0AIAFB2ABqQZas2LABNgIAIAFClqzYsOHChYsWNwNQIAMQpwwgAUEcaiACKAIwIgMgAxClFCACKAIwIgRFDQFBACEDA0ACQCACIAMQmyVFBEAgAUEIaiACIAMQoBsgAUEcaiABKAIIIAEoAgwQ/hIMAQsgAUEcahCnFQsgBCADQQFqIgNHDQALDAELQcDq/wAQsjsACyABQdAAaiIDIAFBHGoiBBDsDhCwPgJAQcQAQQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiADQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACAEELssIAFBkAFqJAAMAQsMugILDLMCCyAAIQRBACEJIwBBgANrIgckACAHQRhqIAUgBigCEBEAACAHQSBqIgAgBygCGCIFIAcoAhwoAgwRAAACQAJAIAVFDQAgBykDIELA47Xe0v6llSyFIAcpAyhC9c6oqNH+2sykf4WEUEUNACAAIAUoAjAQxBsgBSgCMCIXRQ0BIAdB5ABqIRggB0HwAGohCiAHQagBaiELIAdBqAJqIQwgB0H8AGohBiAHQdgAaiENIAdBOGohDiAHQdwCaiEQIAdBLGohFCAHQShqIQ8CQANAAkACQAJAAkACQCAFIAkQmyVFBEAgB0EQaiAFIAkQoBsgBygCECEDIAcgBygCFCIANgLcASAHIAM2AtgBAkAgAEENTwRAIAcoAighASAHQQA2AiggAQ0BDAULIAdBADYC6AEgB0IANwPgASAABEAgB0HgAWogAyAA/AoAAAsgBzUC6AEhGyAHKQPgASEcIAcoAmAiASAHKAJYRgRAIA1BgMD/ABCxKAsgBygCXCABQQR0aiICIBs+AgwgAiAcNwIEIAIgADYCACAHIAFBAWo2AmAgBygCfARAIAcoAowBIgJBAWoiA0EDdiADQQdxQQBHaiIAIAcoAogBIgFLBEAgACABayERIAcoAoABIhIgAEkEQCAGIBJBAXQiASAAEM0qIhIgASASSxsQ6BkgBygCiAEhAQsgEQRAIAcoAoQBIAFqQQAgEfwLAAsgByAANgKIAQsgByADNgKMASAHKAKEASACQQN2aiIAIAAtAABBASACQQdxdHI6AAAMBgsgByAHKAKQAUEBajYCkAEMBQsgECAUKQIANwIAIBBBCGogFEEIaigCADYCACAHQYACaiIRIA5BCGopAwAiGzcDACAHQYgCaiISIA5BEGopAwAiIDcDACAHQZACaiIWIA5BGGopAwAiHzcDACAHIAE2AtgCIAcgDikDACIcNwP4ASAbIACtIh6FIh1COIYgHUKA/gODQiiGhCAdQoCA/AeDQhiGIB1CgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAdQtii0e/CqeW/LX6FIB58Qq3+1eTUhf2o2AB+IRsCQCAAQRBNBEAgGyAcfCADKQAAICCFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgACADakEIaykAACAfhSIdQn+FfiIeQjiGIB5CgP4Dg0IohoQgHkKAgPwHg0IYhiAeQoCAgPgPg0IIhoSEIB5CCIhCgICA+A+DIB5CGIhCgID8B4OEIB5CKIhCgP4DgyAeQjiIhISEhSAdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEIBt+hUIXiSEbDAELIBsgHHwgICAAIANqQRBrIgEpAACFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgHyABKQAIhSIdQn+FfiIeQjiGIB5CgP4Dg0IohoQgHkKAgPwHg0IYhiAeQoCAgPgPg0IIhoSEIB5CCIhCgICA+A+DIB5CGIhCgID8B4OEIB5CKIhCgP4DgyAeQjiIhISEhSAdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEIBt+hUIXiSEbIB9Cf4UhHiADIQIgACEBA0AgGyAcfCAgIAIpAACFIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgAikACCIhIB6FfiIdQjiGIB1CgP4Dg0IohoQgHUKAgPwHg0IYhiAdQoCAgPgPg0IIhoSEIB1CCIhCgICA+A+DIB1CGIhCgID8B4OEIB1CKIhCgP4DgyAdQjiIhISEhSAbIB8gIYUiHUI4hiAdQoD+A4NCKIaEIB1CgID8B4NCGIYgHUKAgID4D4NCCIaEhCAdQgiIQoCAgPgPgyAdQhiIQoCA/AeDhCAdQiiIQoD+A4MgHUI4iISEhH6FQheJIRsgAkEQaiECIAFBEGsiAUEQSw0ACwsgB0HoAmogB0HYAmogGyAcQjiGIBxCgP4Dg0IohoQgHEKAgPwHg0IYhiAcQoCAgPgPg0IIhoSEIBxCCIhCgICA+A+DIBxCGIhCgID8B4OEIBxCKIhCgP4DgyAcQjiIhISEfiAbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEIBtCCIhCgICA+A+DIBtCGIhCgID8B4OEIBtCKIhCgP4DgyAbQjiIhISEIBxCf4V+IhxCOIYgHEKA/gODQiiGhCAcQoCA/AeDQhiGIBxCgICA+A+DQgiGhIQgHEIIiEKAgID4D4MgHEIYiEKAgPwHg4QgHEIoiEKA/gODIBxCOIiEhISFIBuJIAdBIGogB0HYAWogB0H4AWoQ+g0gBygC6AJBAUYEQCAHKAL8AiIBKAIAIgIgBygC+AIiFWoiEy0AACEZIAcoAmAhGiATIAcoAvACQRl2IhM6AAAgAiABKAIEIBVBCGtxakEIaiATOgAAIAEgASgCDEEBajYCDCABIAEoAgggGUEBcWs2AgggAiAVQQJ0a0EEayAaNgIAIAdBoAFqIAdB4AJqKQIANwMAIAcgBykC2AI3A5gBIAtBGGogFikDADcDACALQRBqIBIpAwA3AwAgC0EIaiARKQMANwMAIAsgBykD+AE3AwAgBygCKARAIA8QjjsLIA8gB0GYAWpBMPwKAAAMBAsgBygC+AJBBGsoAgAiASAHKAJgIgBPDQEgBygCXCICIAFBBHRqIgEpAwghGyABKQMAIRwgBygCWCAARgR/IA1BwL//ABCxKCAHKAJcBSACCyAAQQR0aiIBIBs3AwggASAcNwMAIAcgAEEBajYCYAJAIAcoAnwEQCAHKAKMASICQQFqIgNBA3YgA0EHcUEAR2oiACAHKAKIASIBSwRAIAAgAWshFSAHKAKAASITIABJBEAgBiATQQF0IgEgABDNKiITIAEgE0sbEOgZIAcoAogBIQELIBUEQCAHKAKEASABakEAIBX8CwALIAcgADYCiAELIAcgAzYCjAEgBygChAEgAkEDdmoiACAALQAAQQEgAkEHcXRyOgAADAELIAcgBygCkAFBAWo2ApABCyAMIAcpA/gBNwMAIAdBoAJqIAdB4AJqKQIANwMAIAxBCGogESkDADcDACAMQRBqIBIpAwA3AwAgDEEYaiAWKQMANwMAIAcgBykC2AI3A5gCIAcoAigEQCAPEI47CyAPIAdBmAJqQTD8CgAADAQLIAYQ5jogBygCfEUNASAHKAKMAUEBaiIBQQN2IAFBB3FBAEdqIgAgBygCiAEiAksEQCAAIAJrIQMgBygCgAEiESAASQRAIAYgEUEBdCICIAAQzSoiESACIBFLGxDoGSAHKAKIASECCyADBEAgBygChAEgAmpBACAD/AsACyAHIAA2AogBCyAHIAE2AowBIAcoAmAiACAHKAJYRgRAIA1BoL//ABCxKAsgBygCXCAAQQR0aiIBQgA3AwggAUIANwMAIAcgAEEBajYCYAwDCyABIABBsL//ABDDIQALQejB/wAQsjsACyAHKAJwIAcoAngiAiAAakkEQCACBEAgB0HQAmogCkEIaigCADYCACAHIAopAgA3A8gCIAdBADYCeCAHQoCAgIAQNwNwIAdB2AJqIAdByAJqEPIvIAcgBykC2AI3AvQCIAdBADYC8AIgByAHKALkAiICNgLsAiAHIAcoAuACNgLoAiAHQQhqIAdB6AJqENc7IAcoAgghFhCwPkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBykC6AI3AgggAUEQaiAHQfACaikCADcCACABQRhqIAdB+AJqKAIANgIAIAJBf0YNBSAHKAJsIhEgBygCZEYEQCAYQbjA/wAQkCgLIAcoAmggEUEMbGoiEiACNgIIIBIgFjYCBCASIAE2AgAgByARQQFqNgJsCyAKIAdBIGoQ1yoiASAAIAAgAUkbEIQuIAcoAnghAgsgCiADIAAQoTYgBzUCbCACrUIghoQhGyAArSADNQAAQiCGhCEcIAcoAmAiACAHKAJYRgRAIA1B8L//ABCxKAsgBygCXCAAQQR0aiIBIBs3AwggASAcNwMAIAcgAEEBajYCYCAHKAJ8BEAgBygCjAEiAkEBaiIDQQN2IANBB3FBAEdqIgAgBygCiAEiAUsEQCAAIAFrIREgBygCgAEiEiAASQRAIAYgEkEBdCIBIAAQzSoiEiABIBJLGxDoGSAHKAKIASEBCyARBEAgBygChAEgAWpBACAR/AsACyAHIAA2AogBCyAHIAM2AowBIAcoAoQBIAJBA3ZqIgAgAC0AAEEBIAJBB3F0cjoAAAwBCyAHIAcoApABQQFqNgKQAQsgCUEBaiIJIBdHDQEMBAsLDM0CCyAHQQA2AvgCIAdBATYC7AIgB0GgwP8ANgLoAiAHQgQ3AvACIAdB6AJqQajA/wAQ7ywAC0GI6/8AELI7AAsgB0GYAWoiASAHQSBqENwMELA+AkBBxABBBBCtNiIABEAgAEKBgICAEDcCACAAQQhqIAFBPPwKAAAgBEHw3/8ANgIIIAQgADYCBCAEQZOAgIB4NgIAIAdB2ABqIgAQyT4gABDmPCAHKAJ8BEAgB0H8AGoQzy8LIAdB5ABqIgAQxScgABDoOyAHQfAAaiIAEMk+IAAQ3jsgBygCKARAIAdBKGoQjjsLIAdBgANqJAAMAQsMuQILDLICCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADLECCyAAIAUgBhClBAywAgsjAEGAAWsiASQAIAFBCGogBSAGEJYiIgMQ1DogCxCPFwJAAkAgAxDUOiIFBEBBACECIAQtADRBAXEhBANAAkAgAyACEJYlRQRAIAEgAyACEPIWIAFBNGogAUEIaiABKAIAIAEoAgQQohAgASgCNEGTgICAeEYNASABQdgAaiABQcQAaigCADYCACABQdAAaiABQTxqKQIANwMAIAEgASkCNDcDSCAERQRAIAAgASkCNDcCACAAQRBqIAFBxABqKAIANgIAIABBCGogAUE8aikCADcCAAwFCyABQQhqEJEVIAFByABqEIgRDAELIAFBCGoQkRULIAUgAkEBaiICRw0ACwsgAUHIAGoiAyABQQhqEMcUELA+QcAAQQQQrTYiAkUNuwIgAkKBgICAEDcCACACQQhqIANBOPwKAAAgAEHo6f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQQhqEIovIAFBgAFqJAAMAAsMrwILIAhB0ABqIQcgBSAGEJYiIQQjAEGwAWsiAyQAIAQoAhAhAQJAAkACQCAEKAIUIgJBCEkNACABIAJBeHFqQQhrIgVFDQAgBSgCAEF/Rg0BCyADIAQQ1DoiCTYCDCADQRBqIgYgCRDEGyAEKAIYIgUgBSgCACIKQQFqNgIAAkACQCAKQQBOBEAgAyAFNgKIASADIAQpAhw3AowBIAYgA0GIAWoQ2SAhDiACQRBJDQIgAkEDdiEKIANByABqIQ8gA0HsAGohC0EAIQUDQCABQQhqIgIpAwAhGyABKQMAIRwCQCAEIAUQliVFBEAgA0EQaiAOIBynIgEgG6cgAWsQiRAMAQsgCxDmOiADKAJsRQ0DIAMoAnxBAWoiDEEDdiAMQQdxQQBHaiIBIAMoAngiBksEQCABIAZrIQ0gAygCcCIQIAFJBEAgCyAQQQF0IgYgARDQKiIQIAYgEEsbEOgZIAMoAnghBgsgDQRAIAMoAnQgBmpBACAN/AsACyADIAE2AngLIAMgDDYCfCADKAJQIgEgAygCSEYEQCAPQfzpgAEQsSgLIAMoAkwgAUEEdGoiBkIANwMIIAZCADcDACADIAFBAWo2AlALIAVBAWohBSACIQEgCkEBayIKQQJPDQALDAILAAtB3OyAARCyOwALIAMgA0EQaiIBENE8IgI2ApQBIAIgCUYEQCAHIAEQ3AwgARDpJQwCCwzRAgsgBBDUOiEBIANBFGogBBD5NCADIAE2AjAgA0EANgIsIAMgBDYCECAHIANBEGoQxg8LIANBsAFqJAAgBxDsKSEBIABB8N//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyuAgsgACAFIAYgBBDQBwytAgsgCEHQAGogBSAGIAQQ0AcgCCgCWCECIAgoAlQhASAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADK0CCyAIIAI2ApQCIAggATYCkAIgACABIAIoAghBAWtBeHFqQQhqIAIQpgQgASABKAIAIgBBAWs2AgAgAEEBRw2sAiAIQZACahC7IwysAgsgCEHQAGogBSAGIAQQ0AcgCCgCWCECIAgoAlQhASAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgAjYCCCAAIAE2AgQgACADNgIADKwCCyAIIAI2ApQCIAggATYCkAIgCEGQAmoiAygCACADKAIEIgQoAghBAWtBeHFqQQhqIAQQliQiBEUEQEGA4oABQQxBjOKAARDLJAALIAhB0ABqIgIgBBCOCiACEOwpIQIgAEHI4P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAEgASgCACIAQQFrNgIAIABBAUcNqwIgAxC7IwyrAgsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAyqAgsgACAFIAYQ6wsMqQILIAAgBSAGEOwLDKgCCyAIQdAAaiAFIAYQ6wsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADKgCCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgBBDPByAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDacCIAAQuyMMpwILIAhB0ABqIAUgBhDsCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMpwILIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAEENAHIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNpgIgABC7IwymAgsgCEHQAGoiASAFIAYQiyIQpBQgCEGQAmohAyMAQYABayICJAAgAkHEAGogASgCHCABKAIgQQR2IAEoAgQgASgCCBDiBgJAIAIoAkQiBEGTgICAeEcEQCADIAIpAkg3AgggA0EQaiACQdAAaikCADcCACADQYCAgIB4NgIAIAMgBDYCBCABEPkiDAELIAJBxABqIAFBPPwKAAAgAkEcakGatOjQATYCACACQShqIAFBIGooAgA2AgAgAkEQaiABQQhqKAIANgIAIAJBNGogAUEsaikCADcCACACQTxqIAFBNGopAgA3AgAgAkKatOjQocOGjRo3AhQgAiABKQIYNwMgIAIgASkCADcDCCACIAEpAiQ3AiwgAkHQAGoQwgwgAyACQQhqQTz8CgAACyACQYABaiQAIAhByANqIgEgCEGcAmopAgA3AwAgCEHQA2oiAiAIQaQCaigCADYCACAIIAgpApQCNwPAAyAIKAKQAiIDQYCAgIB4Rg2gAiAIQeQCaiAIQagCakEk/AoAACAIQdgCaiABKQMANwIAIAhB4AJqIAIoAgA2AgAgCCADNgLMAiAIIAgpA8ADNwLQAiAIQcwCahDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAylAgsgACEBIwBB4AFrIgckACAFIAYQmSIiAxDTOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahCgFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENM6GiADENM6IQkgAxDTOhogByADENM6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNtgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwzQAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQjywgB0EYaiAHKAIgIAcoAiQQux0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNwwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDcUCIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQfTy/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELYTELA+QThBBBCtNiIARQ2wAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZiHgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMzQILDMECCwzMAgsMzAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDYHRCwPkE4QQQQrTYiAEUNqwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDKQCCyMAQeABayIDJAAgBSAGEJkiIgEQ0zohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQyhcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEJIAEQ0zoaIAMgARDTOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ3HAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw3PAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRCPLCADQRhqIAMoAiAgAygCJBDuHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNwgIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMwwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ3EAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGY8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARC9ExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQYCBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMzwILDK0CCwzOAgsMywILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDaHRCwPkE4QQQQrTYiAUUNqgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDKMCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQsBcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3LAgtBwAAhCSAEQcAAENE0RQ3NAiAEBEAQsD4gBEHAABCtNiIJRQ3EAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NywIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ7RxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3SAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ3BAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgzBAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2/AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHI8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUNqgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBC/HRCwPkE4QQQQrTYiAkUNqQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDKICCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQtxcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcoCC0HAACEKIANBwAAQ0TRFDc4CIAMEQBCwPiADQcAAEK02IgpFDdACCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NywIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDWGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcN1AIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDcACIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgzAAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2+AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkG09P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACELETELA+QThBBBCtNiICRQ2pAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQciIgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1h0QsD5BOEEEEK02IgJFDagCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyhAgsgACEBIwBB4AFrIgckACAFIAYQmSIiAxDTOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDPFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENM6GiADENM6IQkgAxDTOhogByADENM6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNsgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwzMAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQjywgB0EYaiAHKAIgIAcoAiQQuh0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNvwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDcECIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQeDz/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELgTELA+QThBBBCtNiIARQ2sAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMyQILDL0CCwzIAgsMyAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDBHRCwPkE4QQQQrTYiAEUNpwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDKACCyMAQeABayIDJAAgBSAGEJkiIgEQ0zohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQsxcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEJIAEQ0zoaIAMgARDTOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ3DAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw3LAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRCPLCADQRhqIAMoAiAgAygCJBDsHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNvgIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMvwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ3AAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGw8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMywILDKkCCwzKAgsMxwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDNHRCwPkE4QQQQrTYiAUUNpgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDJ8CCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQ2hcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3HAgtBwAAhCSAEQcAAENE0RQ3JAiAEBEAQsD4gBEHAABCtNiIJRQ3AAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NxwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ6xxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3OAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ29AiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgy9AgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ27AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkG48v8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhC5ExCwPkE4QQQQrTYiAkUNpgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDHHRCwPkE4QQQQrTYiAkUNpQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDJ4CCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQ0xcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcYCC0HAACEKIANBwAAQ0TRFDcoCIAMEQBCwPiADQcAAEK02IgpFDcwCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NxwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDVGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcN0AIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDbwCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgy8AgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ26AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGc9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEK4TELA+QThBBBCtNiICRQ2lAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQ5xggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ2R0QsD5BOEEEEK02IgJFDaQCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBsIKAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwydAgsjAEHQAWsiAyQAIAUgBhCZIiIBENM6IQUgA0EgaiIHIAEQ+TQgAyAFNgI8IANBADYCOCADIAE2AhwCQAJAAkAgBC0ANEUEQCADQfQAaiADQRxqEKQXIANByABqIgIgA0GAAWooAgA2AgAgAyADKQJ4NwNAIAMoAnQiBEGTgICAeEYNASADKAKEASEBIAAgAykDQDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABENM6GiABENM6IQkgARDTOhogAyABENM6IgI2ArgBIANBQGtBfyACQQdqIgQgAiAESxtBA3YQ0h8gAkECdCIGIQQCQCAGQTxxIgIEQCAGIAJrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNwAILIAMoAkghCiADQYABaiAHQQhqKQIANwIAIANBiAFqIAdBEGopAgA3AgAgAyABNgJ0IANBADYCmAEgAyAFNgKUASADQQA2ApABIAMgBykCADcCeCACIQEgBQRAQQAhBQNAAkACQAJAIAMoAnhFBEAgAygCmAEhBwwBCyADKAKIASAFSwRAIAMoApgBIQcgAygCfCADKAKEASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQEgAyAHQQFqNgKYASADIAVBAWo2ApABDAILDMgCCyADIAVBAWo2ApABIANBEGogAygCdCAFEI8sIANBxAFqIAMoAhAgAygCFBDBASADIAdBAWo2ApgBIAMoAsQBQTFHDQAgASADKgLIATgCACAKIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQQA2AgALIAFBBGohASADKAKQASIFIAMoApQBRw0ACwsCQCADKAJ4IgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANB+ABqEPseCyADIAEgAmtBAnUiATYCxAECQCADKAK4ASABRgRAIAMoAkghASADKAJMIQcgAyADKQJANwKAASADQQA2AnwgAyAHNgJ4IAMgATYCdCADQQhqIANB9ABqIgUQ1zsgAygCCCEKELA+QRxBBBCtNiIBRQ27AiABQoGAgIAQNwIAIAEgAykCdDcCCCABQRBqIANB/ABqIgspAgA3AgAgAUEYaiADQYQBaiIMKAIANgIAIAMgBDYChAEgA0KAgICAgAg3AnwgAyAGNgJ4IAMgAjYCdCADIAUQ1zsgAygCACEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ0NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLAASADIAo2ArwBIAMgATYCuAEQsD5BDEEEEK02IgFFDb0CIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYCzAEgAyABNgLIASADQQE2AsQBIANBADYCSCADQoCAgIDAADcCQCAFQYzz/wAgCSADIANBuAFqIANBxAFqIANBQGsiAhCMEyACIAUQsxMQsD5BOEEEEK02IgFFDagCIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCwzPAgsMuQILDM4CCwzEAgsgA0HAAWogAigCADYCACADIAMpA0A3A7gBIANBxAFqIgIgA0G4AWoQ6BggA0H0AGoiBCABEJM2EO4lIANBQGsiBSACIAQQvh0QsD5BOEEEEK02IgFFDaMCIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HQAWokAAwACwycAgsjAEHgAWsiAyQAIAUgBhCZIiIBENM6IQcgA0EoaiIJIAEQ+TQgAyAHNgJEIANBADYCQCADIAE2AiQCQAJAAkAgBC0ANEUEQCADQfwAaiADQSRqENkXIANB0ABqIgIgA0GIAWooAgA2AgAgAyADKQKAATcDSCADKAJ8IgRBk4CAgHhGDQEgAygCjAEhASAAIAMpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDTOhogARDTOiEKIAEQ0zoaIAMgARDTOiICNgLAASADQdABakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQN0IgYhBAJAIAZBOHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2/AgsgAygC2AEhCyADQYgBaiAJQQhqKQIANwIAIANBkAFqIAlBEGopAgA3AgAgAyABNgJ8QQAhBSADQQA2AqABIAMgBzYCnAEgA0EANgKYASADIAkpAgA3AoABIAIhASAHBEADQAJAAkACQCADKAKAAUUEQCADKAKgASEHDAELIAMoApABIAVLBEAgAygCoAEhByADKAKEASADKAKMASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgKgASADIAVBAWo2ApgBDAILDMcCCyADIAVBAWo2ApgBIANBGGogAygCfCAFEI8sIANByABqIAMoAhggAygCHBDRASADIAdBAWo2AqABIAMoAkhBAXFFDQAgASADKwNQOQMAIAsgB0EDdmoiBSAFLQAAQQEgB0EHcXRyOgAADAELIAFCADcDAAsgAUEIaiEBIAMoApgBIgUgAygCnAFHDQALCwJAIAMoAoABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBgAFqEPseCyADIAEgAmtBA3UiATYCSAJAIAMoAsABIAFGBEAgAygC2AEhASADKALcASEHIAMgAykC0AE3AogBIANBADYChAEgAyAHNgKAASADIAE2AnwgA0EQaiADQfwAaiIFENc7IAMoAhAhCRCwPkEcQQQQrTYiAUUNugIgAUKBgICAEDcCACABIAMpAnw3AgggAUEQaiADQYQBaiILKQIANwIAIAFBGGogA0GMAWoiDCgCADYCACADIAQ2AowBIANCgICAgIAINwKEASADIAY2AoABIAMgAjYCfCADQQhqIAUQ1zsgAygCCCEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ8NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLIASADIAk2AsQBIAMgATYCwAEQsD5BDEEEEK02IgFFDbwCIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC2AEgAyABNgLUASADQQE2AtABIANBADYCUCADQoCAgIDAADcCSCAFQdTz/wAgCiADIANBwAFqIANB0AFqIANByABqIgIQjBMgAiAFEMcTELA+QThBBBCtNiIBRQ2nAiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsM0AILDLgCCwzPAgsMwwILIANByAFqIAIoAgA2AgAgAyADKQNINwPAASADQdABaiICIANBwAFqEOcYIANB/ABqIgQgARCTNhDuJSADQcgAaiIFIAIgBBDbHRCwPkE4QQQQrTYiAUUNogIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHYgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDJsCCyADLQABQQFrDgMLDA0KCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQtRcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENM6GiACENM6IQsgAhDTOhogASACENM6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ3CAgtBwAAhCSAEQcAAENE0RQ3EAiAEBEAQsD4gBEHAABCtNiIJRQ27AgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NwgIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQjywgAUEQaiABKAIYIAEoAhwQ2CZBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw3JAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ24AiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgy4AgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ22AiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHs8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhDEExCwPkE4QQQQrTYiAkUNoQIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDSHRCwPkE4QQQQrTYiAkUNoAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDJkCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQtBcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDcECC0HAACEKIANBwAAQ0TRFDcUCIAMEQBCwPiADQcAAEK02IgpFDccCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NwgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBC/EiABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNywIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDbcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgy3AgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ21AiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkHo8v8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEMATELA+QThBBBCtNiICRQ2gAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQxB0QsD5BOEEEEK02IgJFDZ8CIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBkIWAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyYAgsgAy0AAQ4CCwyRAgsgAy0AAUECaw4CDA2QAgsgAy0AAUEBaw4CDg8NCyAIQdAAaiIBIAUgBhCZIhCzFCAIQZACaiICIAEQ/SQgAhDsKSEBIABBoOH/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyUAgsgCEHQAGoiAiAFIAYQmSIQsxQgCEGQAmoiASACEP0kIAAgAUGg4f8AEK4GIAEQwx4MkwILIAhB0ABqIgEgBSAGEJkiEJwKIAhBkAJqIgIgARCtHyACEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADJICCyAAIAUgBhCvBgyRAgsgCEHQAGoiASAFIAYQmSIQnAogARDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAyQAgsjAEHgAmsiASQAIAUgBhCZIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQxBcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvwILQcAAIQkgBEHAABDRNEUNygIgBARAELA+IARBwAAQrTYiCUUNuAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDcECIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3PAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNtQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgy1AgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNswIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBgPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC/EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQrBcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvQILQcAAIQkgBEHAABDRNEUNyAIgBARAELA+IARBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3NAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNswIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyzAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNsQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2wAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQYDz/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQvxMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ2XAiACIAU2AhAgAiAKNgIMIAJBDTsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABBoImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsMjwILIwBB4AJrIgEkACAFIAYQmSIhAgJAAkACQAJAAkACQCAHKAIAIgoEQCABQZwCaiAKQQhqIAcoAgQQihggASgCoAIhAyABKAKcAiIFQZOAgIB4Rg0BIAAgASkCpAI3AgggAEEQaiABQawCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgAUEBNgLAAiABQfwBaiACENAXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ0zoaIAIQ0zohDCACENM6GiABIAIQ0zoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDb4CC0HAACEJIARBwAAQ0TRFDckCIAQEQBCwPiAEQcAAEK02IglFDbcCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCIAFCATcCwAIgASAGNgK8AkEAIQUgAUEANgK4AiABIAMpAgA3AqACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw3AAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQRhqIAEoApwCIAIQjywgAUH8AWoiAiABKALAAiABKAIYIAEoAhwQggMgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNzgIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBEGogAUGcAmoiAxDXOyABKAIQIQYQsD5BHEEEEK02IgJFDbQCIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQQhqIAMQ1zsgASgCCCEEELA+QRxBBBCtNiIDDQIMtAILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDbICIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNBCACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQcTy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQxhMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAQsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLDAILIAEgAzYCVCACENM6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABIAFB1ABqNgLAAiABQfwBaiACELwXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ0zoaIAIQ0zohDCACENM6GiABIAIQ0zoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDbwCC0HAACEJIARBwAAQ0TRFDccCIAQEQBCwPiAEQcAAEK02IglFDbUCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCQQAhBSABQQA2AsQCIAEgBjYCvAIgAUEANgK4AiABIAMpAgA3AqACIAEgAUHUAGo2AsACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2+AiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQTBqIAEoApwCIAIQjywgAUH8AWoiAiABKALAAiABKAIwIAEoAjQQ+QIgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNzAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBKGogAUGcAmoiAxDXOyABKAIoIQYQsD5BHEEEEK02IgJFDbICIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQSBqIAMQ1zsgASgCICEEELA+QRxBBBCtNiIDDQIMsgILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDbACIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNrwIgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEHE8v8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEEMYTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQILIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHnAGoiBSABQYABaikAADcAACABQeAAaiIDIAFB+QBqKQAANwMAIAFBQGsiBCABQZABaikCADcDACABQcgAaiIGIAFBmAFqKQIANwMAIAFBqAFqIgkgAykDADcDACABQa8BaiIDIAUpAAA3AAAgASABKQKIATcDOCABIAEpAHE3A6ABIAFBpQJqIAkpAwA3AAAgAUGsAmogAykAADcAACABQbwCaiAEKQMANwIAIAFBxAJqIAYpAwA3AgAgASACOgCcAiABIAEpA6ABNwCdAiABIAEpAzg3ArQCIAoEQCAKIAooAgAiAkEBajYCACACQQBIDQIgBygCBCEFCyABQZwCahClDBCwPkE4QQQQrTYiAkUNlgIgAiAFNgIQIAIgCjYCDCACQY0COwEIIAJCgYCAgBA3AgAgAiABKQCrATcAFCACIAEpAzg3AiAgAEHQioABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBHGogAUGzAWooAAA2AAAgAkEoaiABQUBrKQMANwIAIAJBMGogAUHIAGopAwA3AgALIAFB4AJqJAAMAQsACwyOAgsjAEHgAmsiASQAIAUgBhCZIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQwxcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNvQILQcAAIQkgBEHAABDRNEUNyAIgBARAELA+IARBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3NAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNswIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyzAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNsQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARB3PL/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBCoEyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ0zohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQoxcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNuwILQcAAIQkgBEHAABDRNEUNxgIgBARAELA+IARBwAAQrTYiCUUNtAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDb0CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhCPLCABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw3LAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNsQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyxAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNrwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2uAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQdzy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQqBMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ2VAiACIAU2AhAgAiAKNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAKsBNwAUIAIgASkDODcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQbMBaigAADYAACACQShqIAFBQGspAwA3AgAgAkEwaiABQcgAaikDADcCAAsgAUHgAmokAAwBCwALDI0CCyMAQeACayIBJAAgBSAGEJkiIQICQAJAAkACQAJAAkAgBygCACIKBEAgAUGcAmogCkEIaiAHKAIEEIoYIAEoAqACIQMgASgCnAIiBUGTgICAeEYNASAAIAEpAqQCNwIIIABBEGogAUGsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyACENM6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAFBATYCwAIgAUH8AWogAhDUFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENM6GiACENM6IQwgAhDTOhogASACENM6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ28AgtBwAAhCSAEQcAAENE0RQ3HAiAEBEAQsD4gBEHAABCtNiIJRQ21AgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAiABQgE3AsACIAEgBjYCvAJBACEFIAFBADYCuAIgASADKQIANwKgAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NvgIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEYaiABKAKcAiACEI8sIAFB/AFqIgIgASgCwAIgASgCGCABKAIcEIIDIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDcwCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQRBqIAFBnAJqIgMQ1zsgASgCECEGELA+QRxBBBCtNiICRQ2yAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEIaiADENc7IAEoAgghBBCwPkEcQQQQrTYiAw0CDLICCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2wAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDQQgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEG88/8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEELQTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQELIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AlQgAhDTOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgASABQdQAajYCwAIgAUH8AWogAhClFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENM6GiACENM6IQwgAhDTOhogASACENM6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ26AgtBwAAhCSAEQcAAENE0RQ3FAiAEBEAQsD4gBEHAABCtNiIJRQ2zAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAkEAIQUgAUEANgLEAiABIAY2ArwCIAFBADYCuAIgASADKQIANwKgAiABIAFB1ABqNgLAAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NvAIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEwaiABKAKcAiACEI8sIAFB/AFqIgIgASgCwAIgASgCMCABKAI0EPkCIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDcoCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQShqIAFBnAJqIgMQ1zsgASgCKCEGELA+QRxBBBCtNiICRQ2wAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEgaiADENc7IAEoAiAhBBCwPkEcQQQQrTYiAw0CDLACCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2uAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDa0CIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBvPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC0EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0CCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB5wBqIgUgAUGAAWopAAA3AAAgAUHgAGoiAyABQfkAaikAADcDACABQUBrIgQgAUGQAWopAgA3AwAgAUHIAGoiBiABQZgBaikCADcDACABQagBaiIJIAMpAwA3AwAgAUGvAWoiAyAFKQAANwAAIAEgASkCiAE3AzggASABKQBxNwOgASABQaUCaiAJKQMANwAAIAFBrAJqIAMpAAA3AAAgAUG8AmogBCkDADcCACABQcQCaiAGKQMANwIAIAEgAjoAnAIgASABKQOgATcAnQIgASABKQM4NwK0AiAKBEAgCiAKKAIAIgJBAWo2AgAgAkEASA0CIAcoAgQhBQsgAUGcAmoQpQwQsD5BOEEEEK02IgJFDZQCIAIgBTYCECACIAo2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABB+ImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsMjAILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahDqFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDbQCC0HAACEJIARBwAAQ0TRFDbYCIAQEQBCwPiAEQcAAEK02IglFDa0CCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw20AiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhCPLCABQRBqIAEoAhggASgCHBCQHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDbsCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDaoCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDKoCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDagCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQazy/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELsTELA+QThBBBCtNiICRQ2TAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEEMwdELA+QThBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsMiwILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCpFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDbMCC0HAACEJIARBwAAQ0TRFDbUCIAQEQBCwPiAEQcAAEK02IglFDawCCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2zAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhCPLCABQRBqIAEoAhggASgCHBCPHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDboCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDakCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDKkCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDacCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQaTz/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELITELA+QThBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEENcdELA+QThBBBCtNiICRQ2RAiACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsMigILIwBB4AFrIgEkACAFIAYQmSIiAhDTOiEFIAFBIGoiCSACEPk0IAEgBTYCPCABQQA2AjggASACNgIcAkACQAJAIAQtADRFBEAgAUH0AGogAUEcahDYFyABQcgAaiIDIAFBgAFqKAIANgIAIAEgASkCeDcDQCABKAJ0IgRBk4CAgHhGDQEgASgChAEhAiAAIAEpA0A3AgQgACACNgIQIAAgBDYCACAAQQxqIAMoAgA2AgAMAgsgAhDTOhogAhDTOiELIAIQ0zoaIAEgAhDTOiIDNgLEASABQcgBakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNsgILQcAAIQogA0HAABDRNEUNtgIgAwRAELA+IANBwAAQrTYiCkUNuAILIAEoAtABIQwgAUGAAWogCUEIaikCADcCACABQYgBaiAJQRBqKQIANwIAIAEgAjYCdEEAIQcgAUEANgKYASABIAU2ApQBIAFBADYCkAEgASAJKQIANwJ4IAFB+ABqIQlBACECA0AgAUG4AWohDUICIRsgAiAFRwR/IAECfgJAIAEoAngEQCACIAEoAogBTw2zAiABKAJ8IAEoAoQBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApABIAFBEGogASgCdCACEI8sIAFBQGsgASgCECABKAIUEI4cIAEpA0ghGyABKQNADAELIAEgAkEBajYCkAFCAAs3A7gBIAEgASgCmAEiBkEBajYCmAEgAUHYAWoFIA0LIBs3AwACQAJAAkAgASkDuAEiG0ICUgRAIAcgCmohAiAbp0EBcUUNASACIAEpA9gBNwMAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCeCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYCQCACIAEoAsQBRw28AiABKALQASECIAEoAtQBIQUgASABKQLIATcCgAEgAUEANgJ8IAEgBTYCeCABIAI2AnQgAUEIaiABQfQAaiIGENc7IAEoAgghBxCwPkEcQQQQrTYiAkUNqAIgAkKBgICAEDcCACACIAEpAnQ3AgggAkEQaiABQfwAaiIJKQIANwIAIAJBGGogAUGEAWoiDCgCADYCACABIAM2AoQBIAFCgICAgIAINwJ8IAEgBDYCeCABIAo2AnQgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAw0CDKgCCyACQgA3AwALIAdBCGohByABKAKUASEFIAEoApABIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ0NwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLAASABIAc2ArwBIAEgAjYCuAEQsD5BDEEEEK02IgJFDaYCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC0AEgASACNgLMASABQQE2AsgBIAFBADYCSCABQoCAgIDAADcCQCABQfQAaiICQZD0/wAgCyABIAFBuAFqIAFByAFqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDZECIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQcABaiADKAIANgIAIAEgASkDQDcDuAEgAUHIAWoiAyABQbgBahC9GCABQfQAaiIEIAIQkzYQ7iUgAUFAayIFIAMgBBDCHRCwPkE4QQQQrTYiAkUNkAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDIkCCyMAQeABayIBJAAgBSAGEJkiIgIQ0zohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQxxcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ0zoaIAIQ0zohCyACENM6GiABIAIQ0zoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDbECC0HAACEKIANBwAAQ0TRFDbUCIAMEQBCwPiADQcAAEK02IgpFDbcCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NsgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhCPLCABQUBrIAEoAhAgASgCFBDqHCABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNuwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDacCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgynAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2lAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGo9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEKkTELA+QThBBBCtNiICRQ2QAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQYiDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1R0QsD5BOEEEEK02IgJFDY8CIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyIAgtBACEHIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNuwIgASkDgAFCx9n0597Etpx3hSABKQOIAUKNss6UjMqS5qd/hYRQRQ27AiACENM6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADELgXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDTOhogAhDTOiELIAIQ0zoaIAEgAhDTOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQJ0IgQhAyAEQTxxIgkEQCAEIAlrQUBrIgMgBEkNsQILQcAAIQkgA0HAABDRNEUNvwIgAwRAELA+IANBwAAQrTYiCUUNtwILIAEoAuABIQwgAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiENQQAhBkEAIQIDQCABQcgBaiEOQQIhCiACIAVHBH8CQAJAIAEoAoQBRQ0AIAIgASgClAFPDbECIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ApwBQQAhAgwBCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhCPLCABQdAAaiABKAIYIAEoAhwQsQwgASgCUEGTgICAeEYiAgRAIAEoAlQhCgwBCyABQdAAahCIEQsgASACNgLIASABIAEoAqgBIgdBAWo2AqgBIAFB7AFqBSAOCyAKNgIAAkACQAJAIAEoAsgBIgVBAkcEQCAGIAlqIQIgBUEBcUUNASACIAEoAuwBNgIAIAwgB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AlAgAiABKALUAUcNxAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDacCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiIMKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMpwILIAJBADYCAAsgBkEEaiEGIAEoAqABIQUgASgCnAEhAgwBCwsgA0KBgICAEDcCACADIAEpAoABNwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAFNgLQASABIAc2AswBIAEgAjYCyAEQsD5BDEEEEK02IgJFDaUCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC4AEgASACNgLcASABQQE2AtgBIAFBADYCWCABQoCAgIDAADcCUCABQYABaiICQfjz/wAgCyABIAFByAFqIAFB2AFqIAFB0ABqIgMQjBMgAyACEK8TDAELIAFBiAFqIAIoAgA2AgAgASABKQPYATcDgAEgAUHQAGogAUGAAWoQ4QgLELA+QThBBBCtNiICRQ2OAiACQoGAgIAQNwIAIAJBCGogAUHQAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQfABaiQADAALDIcCC0EAIQdBACEKIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNugIgASkDgAFCx9n0597Etpx3hSABKQOIAUKNss6UjMqS5qd/hYRQRQ26AiACENM6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADENcXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDTOhogAhDTOiEMIAIQ0zoaIAEgAhDTOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQN0IgQhAyAEQThxIgkEQCAEIAlrQUBrIgMgBEkNsAILQcAAIQkgA0HAABDRNEUNvgIgAwRAELA+IANBwAAQrTYiCUUNtgILIAEoAuABIQ0gAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiEOQQAhBkEAIQIDQCABQcgBaiEPQQIhCyACIAVHBH8gAQJ/AkACQCABKAKEAQRAIAIgASgClAFPDbICIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhCPLCABQdAAaiABKAIYIAEoAhwQ4AcgASgCUEGTgICAeEYEQCABKAJYIQsgASgCVCEKQQEMAwsgAUHQAGoQiBEMAQsgASACQQFqNgKcAQtBAAs2AsgBIAEgASgCqAEiB0EBajYCqAEgAUHsAWoFIA8LIAs2AgACQAJAAkAgASgCyAEiBUECRwRAIAYgCWohAiAFQQFxRQ0BIAIgCjYCACACQQRqIAEoAuwBNgIAIA0gB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAGQQN1IgI2AlAgAiABKALUAUcNwwIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDaYCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiILKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMpgILIAJBADYCACACQQRqQQA2AgALIAZBCGohBiABKAKgASEFIAEoApwBIQIMAQsLIANCgYCAgBA3AgAgAyABKQKAATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC0AEgASAHNgLMASABIAI2AsgBELA+QQxBBBCtNiICRQ2kAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AuABIAEgAjYC3AEgAUEBNgLYASABQQA2AlggAUKAgICAwAA3AlAgAUGAAWoiAkGE9P8AIAwgASABQcgBaiABQdgBaiABQdAAaiIDEIwTIAMgAhCsEwwBCyABQYgBaiACKAIANgIAIAEgASkD2AE3A4ABIAFB0ABqIAFBgAFqENkICxCwPkE4QQQQrTYiAkUNjQIgAkKBgICAEDcCACACQQhqIAFB0ABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHwAWokAAwACwyGAgsgACECIwBBgAJrIgMkACADQSBqIAUgBigCEBEAACADQYABaiIBIAMoAiAiBSADKAIkKAIMEQAAAkACQAJAAkACQCAFRQ29AiADKQOAAULH2fTn3sS2nHeFIAMpA4gBQo2yzpSMypLmp3+FhFBFDb0CIAUQ0zohByADQTBqIgkgBRD5NCADIAc2AkwgA0EANgJIIAMgBTYCLCAELQA0RQRAIAEgA0EsakEk/AoAACADIAE2AqQBIANB0ABqIAEQ4RcgA0H4AWoiASADQdwAaigCADYCACADIAMpAlQ3A/ABIAMoAlAiBEGTgICAeEYNASADKAJgIQIgACADKQPwATcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwECyAFENM6GiAFENM6IQogBRDTOhogAyAFENM6IgA2AswBIANB0AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDasCCyADKALYASELIANBjAFqIAlBCGopAgA3AgAgA0GUAWogCUEQaikCADcCACADIAU2AoABQQAhBSADQQA2AqgBIAMgBzYCoAEgA0EANgKcASADIAkpAgA3AoQBIAMgA0GAAWo2AqQBIAEhACAHRQ0DIANB0ABqQQRyIQkgA0HYAGohBwNAAkACQAJAAkAgAygChAEEQCAFIAMoApQBTw20AiADKAKIASADKAKQASAFaiIMQQN2ai0AAEH/AXMgDEEHcXZBAXENAQsgAyAFQQFqNgKcASADQRhqIAMoAoABIAUQjywgA0HQAGogAygCGCADKAIcEOkcAkAgAygCUCIFRQRAIANB+AFqIAdBCGopAwA3AwAgAyAHKQMANwPwAQwBCyAFDQILIANB6AFqIANB+AFqKQMAIhs3AwAgAyADKQPwASIcNwPgASADIAMoAqgBIgVBAWo2AqgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiIMIAwtAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgKcAQwBCyAJEIgRCyADQegBaiADQfgBaikDADcDACADIAMpA/ABNwPgASADIAMoAqgBQQFqNgKoASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCnAEiBSADKAKgAUcNAAsMAwsMwQILDK8CCyADQYgBaiABKAIANgIAIAMgAykD8AE3A4ABIANB0ABqIANBgAFqEM4IDAELAkAgAygChAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GEAWoQ+x4LIAMgACABa0EEdSIANgJQIAAgAygCzAFHDb8CIAMoAtgBIQAgAygC3AEhBSADIAMpAtABNwKMASADQQA2AogBIAMgBTYChAEgAyAANgKAASADQRBqIANBgAFqIgcQ1zsgAygCECEJELA+QRxBBBCtNiIARQ2gAiAAQoGAgIAQNwIAIAAgAykCgAE3AgggAEEQaiADQYgBaiILKQIANwIAIABBGGogA0GQAWoiDCgCADYCACADIAQ2ApABIANCgICAgIAINwKIASADIAY2AoQBIAMgATYCgAEgA0EIaiAHENc7IAMoAgghBBCwPkEcQQQQrTYiAUUEQAyhAgsgAUKBgICAEDcCACABIAMpAoABNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgADYC4AEQsD5BDEEEEK02IgBFDaICIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYC+AEgAyAANgL0ASADQQE2AvABIANBADYCWCADQoCAgIDAADcCUCADQYABaiIAQdDy/wAgCiADIANB4AFqIANB8AFqIANB0ABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUNjAIgAEKBgICAEDcCACAAQQhqIANB0ABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GAAmokAAwACwyFAgsgACEBIwBB4AFrIgckACAFIAYQmCIiAxDUOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDBFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENQ6GiADENQ6IQkgAxDUOhogByADENQ6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNlgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwywAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQ2isgB0EYaiAHKAIgIAcoAiQQux0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNowIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDaUCIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQfTy/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELYTELA+QThBBBCtNiIARQ2QAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQZiHgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMrQILDKECCwysAgsMrAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDYHRCwPkE4QQQQrTYiAEUNiwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDIQCCyMAQeABayIDJAAgBSAGEJgiIgEQ1DohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQqBcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEJIAEQ1DoaIAMgARDUOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2nAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw2vAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRDaKyADQRhqIAMoAiAgAygCJBDuHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNogIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMowILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ2kAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGY8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARC9ExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQYCBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMrwILDI0CCwyuAgsMqwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDaHRCwPkE4QQQQrTYiAUUNigIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDIMCCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQzhcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2rAgtBwAAhCSAEQcAAENE0RQ2tAiAEBEAQsD4gBEHAABCtNiIJRQ2kAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NqwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ7RxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2yAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2hAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgyhAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2fAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHI8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUNigIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBC/HRCwPkE4QQQQrTYiAkUNiQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDIICCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQohcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaoCC0HAACEKIANBwAAQ0TRFDa4CIAMEQBCwPiADQcAAEK02IgpFDbACCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NqwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDWGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNtAIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDaACIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgygAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2eAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkG09P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACELETELA+QThBBBCtNiICRQ2JAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQciIgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1h0QsD5BOEEEEK02IgJFDYgCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwyBAgsgACEBIwBB4AFrIgckACAFIAYQmCIiAxDUOiEFIAdBMGoiBiADEPk0IAcgBTYCTCAHQQA2AkggByADNgIsAkACQAJAIAQtADRFBEAgB0GEAWogB0EsahDsFyAHQdgAaiICIAdBkAFqKAIANgIAIAcgBykCiAE3A1AgBygChAEiBEGTgICAeEYNASAHKAKUASEBIAAgBykDUDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyADENQ6GiADENQ6IQkgAxDUOhogByADENQ6IgA2AsgBIAdB0ABqQX8gAEEHaiICIAAgAksbQQN2ENIfAkAgACICQT9xIgQEQCACIAIgBGtBQGsiAksNAQtBwAAhBCACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiBEUNkgILIAcoAlghCiAHQZABaiAGQQhqKQIANwIAIAdBmAFqIAZBEGopAgA3AgAgByADNgKEASAHQQA2AqgBIAcgBTYCpAEgB0EANgKgASAHIAYpAgA3AogBIAQhAyAFBEBBACEFA0ACQAJAAkAgBygCiAFFBEAgBygCqAEhBgwBCyAHKAKYASAFSwRAIAcoAqgBIQYgBygCjAEgBygClAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0BIAcgBkEBajYCqAEgByAFQQFqNgKgAQwCCwysAgsgByAFQQFqNgKgASAHQSBqIAcoAoQBIAUQ2isgB0EYaiAHKAIgIAcoAiQQuh0gByAGQQFqNgKoASAHLQAYRQ0AIAMgBy0AGToAACAKIAZBA3ZqIgUgBS0AAEEBIAZBB3F0cjoAAAwBCyADQQA6AAALIANBAWohAyAHKAKgASIFIAcoAqQBRw0ACwsCQCAHKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAHQYgBahD7HgsgByADIARrIgM2AtQBAkAgBygCyAEgA0YEQCAHKAJYIQMgBygCXCEGIAcgBykCUDcCkAEgB0EANgKMASAHIAY2AogBIAcgAzYChAEgB0EQaiAHQYQBaiIFENc7IAcoAhAhChCwPkEcQQQQrTYiA0UNnwIgA0KBgICAEDcCACADIAcpAoQBNwIIIANBEGogB0GMAWoiCykCADcCACADQRhqIAdBlAFqIgwoAgA2AgAgByACNgKUASAHQoCAgICACDcCjAEgByAANgKIASAHIAQ2AoQBIAdBCGogBRDXOyAHKAIIIQQQsD5BHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAcpAoQBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgByAGNgLQASAHIAo2AswBIAcgAzYCyAEQsD5BDEEEEK02IgNFDaECIAMgADYCCCADIAQ2AgQgAyACNgIAIAdBATYC3AEgByADNgLYASAHQQE2AtQBIAdBADYCWCAHQoCAgIDAADcCUCAFQeDz/wAgCSAHIAdByAFqIAdB1AFqIAdB0ABqIgIQjBMgAiAFELgTELA+QThBBBCtNiIARQ2MAiAAQoGAgIAQNwIAIABBCGogAkEw/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMBQsMqQILDJ0CCwyoAgsMqAILIAdB0AFqIAIoAgA2AgAgByAHKQNQNwPIASAHQdQBaiIAIAdByAFqEO4YIAdBhAFqIgIgAxCTNhDuJSAHQdAAaiIDIAAgAhDBHRCwPkE4QQQQrTYiAEUNhwIgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQeABaiQADAALDIACCyMAQeABayIDJAAgBSAGEJgiIgEQ1DohBSADQTBqIgcgARD5NCADIAU2AkwgA0EANgJIIAMgATYCLAJAAkACQCAELQA0RQRAIANBhAFqIANBLGoQ0hcgA0HYAGoiAiADQZABaigCADYCACADIAMpAogBNwNQIAMoAoQBIgRBk4CAgHhGDQEgAygClAEhASAAIAMpA1A3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEJIAEQ1DoaIAMgARDUOiICNgLIASADQdAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQF0IgYhBAJAIAZBPnEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2jAgsgAygCWCEKIANBkAFqIAdBCGopAgA3AgAgA0GYAWogB0EQaikCADcCACADIAE2AoQBIANBADYCqAEgAyAFNgKkASADQQA2AqABIAMgBykCADcCiAEgAiEBAkAgBUUNAEEAIQUDQAJAAkACQCADKAKIAUUNACAFIAMoApgBTw2rAiADKAKMASADKAKUASAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgAyAFQQFqNgKgASADIAMoAqgBQQFqNgKoAQwBCyADIAVBAWo2AqABIANBIGogAygChAEgBRDaKyADQRhqIAMoAiAgAygCJBDsHCADLwEYIgdBAkYNAyADLwEaIQsgAyADKAKoASIFQQFqNgKoASAHQQFxRQ0AIAEgCzsBACAKIAVBA3ZqIgcgBy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAKgASIFIAMoAqQBRw0ACwsCQCADKAKIASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQYgBahD7HgsgAyABIAJrQQF1IgE2AtQBAkAgAygCyAEgAUYEQCADKAJYIQEgAygCXCEFIAMgAykCUDcCkAEgA0EANgKMASADIAU2AogBIAMgATYChAEgA0EQaiADQYQBaiIHENc7IAMoAhAhChCwPkEcQQQQrTYiAUUNngIgAUKBgICAEDcCACABIAMpAoQBNwIIIAFBEGogA0GMAWoiCykCADcCACABQRhqIANBlAFqIgwoAgA2AgAgAyAENgKUASADQoCAgICACDcCjAEgAyAGNgKIASADIAI2AoQBIANBCGogBxDXOyADKAIIIQQQsD5BHEEEEK02IgJFBEAMnwILIAJCgYCAgBA3AgAgAiADKQKEATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC0AEgAyAKNgLMASADIAE2AsgBELA+QQxBBBCtNiIBRQ2gAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AtwBIAMgATYC2AEgA0EBNgLUASADQQA2AlggA0KAgICAwAA3AlAgA0GEAWoiAUGw8/8AIAkgAyADQcgBaiADQdQBaiADQdAAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMqwILDIkCCwyqAgsMpwILIANB0AFqIAIoAgA2AgAgAyADKQNQNwPIASADQdQBaiICIANByAFqEOkYIANBhAFqIgQgARCTNhDuJSADQdAAaiIFIAIgBBDNHRCwPkE4QQQQrTYiAUUNhgIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDP8BCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQoRcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2nAgtBwAAhCSAEQcAAENE0RQ2pAiAEBEAQsD4gBEHAABCtNiIJRQ2gAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NpwIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ6xxBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2uAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2dAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgydAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2bAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkG48v8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhC5ExCwPkE4QQQQrTYiAkUNhgIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDHHRCwPkE4QQQQrTYiAkUNhQIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEH4/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDP4BCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQthcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaYCC0HAACEKIANBwAAQ0TRFDaoCIAMEQBCwPiADQcAAEK02IgpFDawCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NpwIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDVGyABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNsAIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDZwCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgycAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2aAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGc9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEK4TELA+QThBBBCtNiICRQ2FAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQ5xggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ2R0QsD5BOEEEEK02IgJFDYQCIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBsIKAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwz9AQsjAEHQAWsiAyQAIAUgBhCYIiIBENQ6IQUgA0EgaiIHIAEQ+TQgAyAFNgI8IANBADYCOCADIAE2AhwCQAJAAkAgBC0ANEUEQCADQfQAaiADQRxqENwXIANByABqIgIgA0GAAWooAgA2AgAgAyADKQJ4NwNAIAMoAnQiBEGTgICAeEYNASADKAKEASEBIAAgAykDQDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABENQ6GiABENQ6IQkgARDUOhogAyABENQ6IgI2ArgBIANBQGtBfyACQQdqIgQgAiAESxtBA3YQ0h8gAkECdCIGIQQCQCAGQTxxIgIEQCAGIAJrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNoAILIAMoAkghCiADQYABaiAHQQhqKQIANwIAIANBiAFqIAdBEGopAgA3AgAgAyABNgJ0IANBADYCmAEgAyAFNgKUASADQQA2ApABIAMgBykCADcCeCACIQEgBQRAQQAhBQNAAkACQAJAIAMoAnhFBEAgAygCmAEhBwwBCyADKAKIASAFSwRAIAMoApgBIQcgAygCfCADKAKEASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQEgAyAHQQFqNgKYASADIAVBAWo2ApABDAILDKgCCyADIAVBAWo2ApABIANBEGogAygCdCAFENorIANBxAFqIAMoAhAgAygCFBDBASADIAdBAWo2ApgBIAMoAsQBQTFHDQAgASADKgLIATgCACAKIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQQA2AgALIAFBBGohASADKAKQASIFIAMoApQBRw0ACwsCQCADKAJ4IgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANB+ABqEPseCyADIAEgAmtBAnUiATYCxAECQCADKAK4ASABRgRAIAMoAkghASADKAJMIQcgAyADKQJANwKAASADQQA2AnwgAyAHNgJ4IAMgATYCdCADQQhqIANB9ABqIgUQ1zsgAygCCCEKELA+QRxBBBCtNiIBRQ2bAiABQoGAgIAQNwIAIAEgAykCdDcCCCABQRBqIANB/ABqIgspAgA3AgAgAUEYaiADQYQBaiIMKAIANgIAIAMgBDYChAEgA0KAgICAgAg3AnwgAyAGNgJ4IAMgAjYCdCADIAUQ1zsgAygCACEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ0NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLAASADIAo2ArwBIAMgATYCuAEQsD5BDEEEEK02IgFFDZ0CIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYCzAEgAyABNgLIASADQQE2AsQBIANBADYCSCADQoCAgIDAADcCQCAFQYzz/wAgCSADIANBuAFqIANBxAFqIANBQGsiAhCMEyACIAUQsxMQsD5BOEEEEK02IgFFDYgCIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCwyvAgsMmQILDK4CCwykAgsgA0HAAWogAigCADYCACADIAMpA0A3A7gBIANBxAFqIgIgA0G4AWoQ6BggA0H0AGoiBCABEJM2EO4lIANBQGsiBSACIAQQvh0QsD5BOEEEEK02IgFFDYMCIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0HQAWokAAwACwz8AQsjAEHgAWsiAyQAIAUgBhCYIiIBENQ6IQcgA0EoaiIJIAEQ+TQgAyAHNgJEIANBADYCQCADIAE2AiQCQAJAAkAgBC0ANEUEQCADQfwAaiADQSRqEOMXIANB0ABqIgIgA0GIAWooAgA2AgAgAyADKQKAATcDSCADKAJ8IgRBk4CAgHhGDQEgAygCjAEhASAAIAMpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgARDUOhogARDUOiEKIAEQ1DoaIAMgARDUOiICNgLAASADQdABakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQN0IgYhBAJAIAZBOHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2fAgsgAygC2AEhCyADQYgBaiAJQQhqKQIANwIAIANBkAFqIAlBEGopAgA3AgAgAyABNgJ8QQAhBSADQQA2AqABIAMgBzYCnAEgA0EANgKYASADIAkpAgA3AoABIAIhASAHBEADQAJAAkACQCADKAKAAUUEQCADKAKgASEHDAELIAMoApABIAVLBEAgAygCoAEhByADKAKEASADKAKMASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgKgASADIAVBAWo2ApgBDAILDKcCCyADIAVBAWo2ApgBIANBGGogAygCfCAFENorIANByABqIAMoAhggAygCHBDRASADIAdBAWo2AqABIAMoAkhBAXFFDQAgASADKwNQOQMAIAsgB0EDdmoiBSAFLQAAQQEgB0EHcXRyOgAADAELIAFCADcDAAsgAUEIaiEBIAMoApgBIgUgAygCnAFHDQALCwJAIAMoAoABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBgAFqEPseCyADIAEgAmtBA3UiATYCSAJAIAMoAsABIAFGBEAgAygC2AEhASADKALcASEHIAMgAykC0AE3AogBIANBADYChAEgAyAHNgKAASADIAE2AnwgA0EQaiADQfwAaiIFENc7IAMoAhAhCRCwPkEcQQQQrTYiAUUNmgIgAUKBgICAEDcCACABIAMpAnw3AgggAUEQaiADQYQBaiILKQIANwIAIAFBGGogA0GMAWoiDCgCADYCACADIAQ2AowBIANCgICAgIAINwKEASADIAY2AoABIAMgAjYCfCADQQhqIAUQ1zsgAygCCCEEELA+QRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQJ8NwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAHNgLIASADIAk2AsQBIAMgATYCwAEQsD5BDEEEEK02IgFFDZwCIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC2AEgAyABNgLUASADQQE2AtABIANBADYCUCADQoCAgIDAADcCSCAFQdTz/wAgCiADIANBwAFqIANB0AFqIANByABqIgIQjBMgAiAFEMcTELA+QThBBBCtNiIBRQ2HAiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMsAILDJgCCwyvAgsMowILIANByAFqIAIoAgA2AgAgAyADKQNINwPAASADQdABaiICIANBwAFqEOcYIANB/ABqIgQgARCTNhDuJSADQcgAaiIFIAIgBBDbHRCwPkE4QQQQrTYiAUUNggIgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHYgYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQeABaiQADAALDPsBCyADLQABQQFrDgMLDA0KCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohAyABQShqIgcgAhD5NCABIAM2AkQgAUEANgJAIAEgAjYCJAJAAkACQCAELQA0RQRAIAFB/ABqIAFBJGoQ4hcgAUHQAGoiAyABQYgBaigCADYCACABIAEpAoABNwNIIAEoAnwiBEGTgICAeEYNASABKAKMASECIAAgASkDSDcCBCAAIAI2AhAgACAENgIAIABBDGogAygCADYCAAwCCyACENQ6GiACENQ6IQsgAhDUOhogASACENQ6IgQ2AtwBIAFByABqQX8gBEEHaiIGIAQgBksbQQN2ENIfIARBAnQiBSEEIAVBPHEiCQRAIAUgCWtBQGsiBCAFSQ2iAgtBwAAhCSAEQcAAENE0RQ2kAiAEBEAQsD4gBEHAABCtNiIJRQ2bAgsgASgCUCEMIAFBiAFqIAdBCGopAgA3AgAgAUGQAWogB0EQaikCADcCACABIAI2AnwgAUEANgKgASABIAM2ApwBIAFBADYCmAEgASAHKQIANwKAASABQYABaiENQQAhB0EAIQIDQCABQdABaiEKAkAgAiADRgRAQQIhAgwBCwJAAkAgASgCgAFFDQAgAiABKAKQAU8NogIgASgChAEgASgCjAEgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxRQ0AIAEgAkEBajYCmAFBACEDDAELIAEgAkEBajYCmAEgAUEYaiABKAJ8IAIQ2isgAUEQaiABKAIYIAEoAhwQ2CZBAiECIAEoAhAiA0ECRg0BIAEoAhQhAgsgASADNgLQASABIAEoAqABIgZBAWo2AqABIAFBwAFqIQoLIAogAjYCAAJAAkACQCABKALQASIDQQJHBEAgByAJaiECIANBAXFFDQEgAiABKALAATYCACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAoABIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgB0ECdSICNgLQASACIAEoAtwBRw2pAiABKAJQIQIgASgCVCEGIAEgASkCSDcCiAEgAUEANgKEASABIAY2AoABIAEgAjYCfCABQQhqIAFB/ABqIgMQ1zsgASgCCCEHELA+QRxBBBCtNiICRQ2YAiACQoGAgIAQNwIAIAIgASkCfDcCCCACQRBqIAFBhAFqIgopAgA3AgAgAkEYaiABQYwBaiIMKAIANgIAIAEgBDYCjAEgAUKAgICAgAg3AoQBIAEgBTYCgAEgASAJNgJ8IAEgAxDXOyABKAIAIQQQsD5BHEEEEK02IgMNAgyYAgsgAkEANgIACyAHQQRqIQcgASgCnAEhAyABKAKYASECDAELCyADQoGAgIAQNwIAIAMgASkCfDcCCCADQRBqIAopAgA3AgAgA0EYaiAMKAIANgIAIAEgBjYCyAEgASAHNgLEASABIAI2AsABELA+QQxBBBCtNiICRQ2WAiACIAU2AgggAiAENgIEIAIgAzYCACABQQE2AtgBIAEgAjYC1AEgAUEBNgLQASABQQA2AlAgAUKAgICAwAA3AkggAUH8AGoiAkHs8/8AIAsgASABQcABaiABQdABaiABQcgAaiIDEIwTIAMgAhDEExCwPkE4QQQQrTYiAkUNgQIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFByAFqIAMoAgA2AgAgASABKQNINwPAASABQdABaiIDIAFBwAFqEOgYIAFB/ABqIgQgAhCTNhDuJSABQcgAaiIFIAMgBBDSHRCwPkE4QQQQrTYiAkUNgAIgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEHAhoABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDPkBCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQzBcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDaECC0HAACEKIANBwAAQ0TRFDaUCIAMEQBCwPiADQcAAEK02IgpFDacCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NogIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBC/EiABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNqwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDZcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgyXAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2VAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkHo8v8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEMATELA+QThBBBCtNiICRQ2AAiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQxB0QsD5BOEEEEK02IgJFDf8BIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBkIWAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwz4AQsgAy0AAQ4CCwzwAQsgAy0AAUECaw4CDA3vAQsgAy0AAUEBaw4CDg8NCyAIQdAAaiICIAUgBhCYIhC1FCAIQZACaiIBIAIQ/CQgACABQfjh/wAQpQQgARDDHgz0AQsgCEHQAGoiASAFIAYQmCIQtRQgCEGQAmoiAiABEPwkIAIQ7CkhASAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAM8wELIAUgBhCYIiICENQ6IQMgCEHQAGoiAUEEaiACEPk0IAEgAzYCICABQQA2AhwgASACNgIAIAhBkAJqIQJBACEGIwBBQGoiAyQAAkACQAJAAkAgASgCHCIEIAEoAiBHBEACfwJAIAEoAgQEQCAEIAEoAhRPDQUgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIARBAWoiBzYCHCADQQhqIAEoAgAiBSAEENorIAMoAgwhBiADKAIIDAELIAEgBEEBaiIHNgIcIAEoAgAhBUEACyEJIAUQ1DohCiAFENQ6GiADQRxqIgRBBCAKIAdrQQFqIgVBfyAFGyIFIAVBBE0bQQBBBEEIEKAYIAMoAiAhBSADKAIcQQFGDQMgAygCJCIHIAY2AgQgByAJNgIAIANBGGoiBkEBNgIAIAMgBzYCFCADIAU2AhAgBCABQST8CgAAIANBEGogBBCXECACQQhqIAYoAgA2AgAgAiADKQIQNwIADAELIAJBADYCCCACQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIANBQGskAAwCC0G8tIABQSBB3LSAARCfKQALIAUgAygCJEG0yP8AEP0vAAsjAEEQayIDJAAgAyACKAIANgIIIAMgAigCBCIENgIAIAMgBDYCBCADIAQgAigCCEEDdGo2AgwgASADENIOIANBEGokACABEOwpIQEgAEHw3/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADPIBCyAAIAUgBhCmBAzxAQsgCEHQAGoiASAFIAYQmCIQjgogARDsKSEBIABByOD/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAzwAQsjAEHgAmsiASQAIAUgBhCYIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQvRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnwILQcAAIQkgBEHAABDRNEUNqgIgBARAELA+IARBwAAQrTYiCUUNmAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDaECIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2vAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNlQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyVAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBgPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC/EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQrRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnQILQcAAIQkgBEHAABDRNEUNqAIgBARAELA+IARBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDEJyABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2tAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNkwIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyTAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkGA8/8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEL8TDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2QAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQYDz/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQvxMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ33ASACIAU2AhAgAiAKNgIMIAJBDTsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABBoImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsM7wELIwBB4AJrIgEkACAFIAYQmCIhAgJAAkACQAJAAkACQCAHKAIAIgoEQCABQZwCaiAKQQhqIAcoAgQQihggASgCoAIhAyABKAKcAiIFQZOAgIB4Rg0BIAAgASkCpAI3AgggAEEQaiABQawCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgAUEBNgLAAiABQfwBaiACELoXIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ1DoaIAIQ1DohDCACENQ6GiABIAIQ1DoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDZ4CC0HAACEJIARBwAAQ0TRFDakCIAQEQBCwPiAEQcAAEK02IglFDZcCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCIAFCATcCwAIgASAGNgK8AkEAIQUgAUEANgK4AiABIAMpAgA3AqACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2gAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQRhqIAEoApwCIAIQ2isgAUH8AWoiAiABKALAAiABKAIYIAEoAhwQggMgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNrgIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBEGogAUGcAmoiAxDXOyABKAIQIQYQsD5BHEEEEK02IgJFDZQCIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQQhqIAMQ1zsgASgCCCEEELA+QRxBBBCtNiIDDQIMlAILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDZICIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNBCACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQcTy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQxhMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAQsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAQLDAILIAEgAzYCVCACENQ6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABIAFB1ABqNgLAAiABQfwBaiACEL4XIAFB8AFqIgIgAUGIAmooAgA2AgAgASABKQKAAjcD6AEgASgC/AEiA0GTgICAeEYNASABQYABaiACKAIANgIAIAEgASkD6AE3AnggASABKAKMAjYChAEgASADNgJ0DAMLIAIQ1DoaIAIQ1DohDCACENQ6GiABIAIQ1DoiBDYC1AEgAUHYAWpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEEDdCILIQQgC0E4cSIFBEAgCyAFa0FAayIEIAtJDZwCC0HAACEJIARBwAAQ0TRFDacCIAQEQBCwPiAEQcAAEK02IglFDZUCCyABKALgASENIAFBqAJqIANBCGopAgA3AgAgAUGwAmogA0EQaikCADcCACABIAI2ApwCQQAhBSABQQA2AsQCIAEgBjYCvAIgAUEANgK4AiABIAMpAgA3AqACIAEgAUHUAGo2AsACIAFBoAJqIQ5BACECA0AgAUGQAmohD0ICIRsgAiAGRwR/IAECfgJAAkAgASgCoAIEQCACIAEoArACTw2eAiABKAKkAiABKAKsAiACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgK4AiABQTBqIAEoApwCIAIQ2isgAUH8AWoiAiABKALAAiABKAIwIAEoAjQQ+QIgASgC/AFBk4CAgHhHBEAgAhCIEQwCCyABKAKAAiICRQ0BIAEgASkChAI3AoACIAEgAjYC/AEgAUHoAWogAUH8AWoQmSQgASkD8AEhGyABKQPoAQwCCyABIAJBAWo2ArgCC0IACzcDkAIgASABKALEAiIDQQFqNgLEAiABQcgBagUgDwsgGzcDAAJAAkACQCABKQOQAiIbQgJSBEAgBSAJaiECIBunQQFxRQ0BIAIgASkDyAE3AwAgDSADQQN2aiICIAItAABBASADQQdxdHI6AAAMAgsCQCABKAKgAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAOEPseCyABIAVBA3UiAjYC/AEgAiABKALUAUcNrAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AqgCIAFBADYCpAIgASAFNgKgAiABIAI2ApwCIAFBKGogAUGcAmoiAxDXOyABKAIoIQYQsD5BHEEEEK02IgJFDZICIAJCgYCAgBA3AgAgAiABKQKcAjcCCCACQRBqIAFBpAJqIg0pAgA3AgAgAkEYaiABQawCaiIOKAIANgIAIAEgBDYCrAIgAUKAgICAgAg3AqQCIAEgCzYCoAIgASAJNgKcAiABQSBqIAMQ1zsgASgCICEEELA+QRxBBBCtNiIDDQIMkgILIAJCADcDAAsgBUEIaiEFIAEoArwCIQYgASgCuAIhAgwBCwsgA0KBgICAEDcCACADIAEpApwCNwIIIANBEGogDSkCADcCACADQRhqIA4oAgA2AgAgASAFNgLgASABIAY2AtwBIAEgAjYC2AEQsD5BDEEEEK02IgJFDZACIAIgCzYCCCACIAQ2AgQgAiADNgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIAFBnAJqIgJBxPL/ACAMIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogAhDGEwwBCyABQdABaiACKAIAIgM2AgAgASABKQPoATcDyAEgAUGcAmoiBCABKALMASICIAIgA0EEdGoQ9QkgAUHgAWogAUGkAmooAgA2AgAgAUGYAmoiBSABQbACaigCADYCACABIAEpApwCNwPYASABIAEpAqgCNwOQAhCwPkEMQQQQrTYiAkUNjwIgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEHE8v8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEEMYTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQILIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHnAGoiBSABQYABaikAADcAACABQeAAaiIDIAFB+QBqKQAANwMAIAFBQGsiBCABQZABaikCADcDACABQcgAaiIGIAFBmAFqKQIANwMAIAFBqAFqIgkgAykDADcDACABQa8BaiIDIAUpAAA3AAAgASABKQKIATcDOCABIAEpAHE3A6ABIAFBpQJqIAkpAwA3AAAgAUGsAmogAykAADcAACABQbwCaiAEKQMANwIAIAFBxAJqIAYpAwA3AgAgASACOgCcAiABIAEpA6ABNwCdAiABIAEpAzg3ArQCIAoEQCAKIAooAgAiAkEBajYCACACQQBIDQIgBygCBCEFCyABQZwCahClDBCwPkE4QQQQrTYiAkUN9gEgAiAFNgIQIAIgCjYCDCACQY0COwEIIAJCgYCAgBA3AgAgAiABKQCrATcAFCACIAEpAzg3AiAgAEHQioABNgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBHGogAUGzAWooAAA2AAAgAkEoaiABQUBrKQMANwIAIAJBMGogAUHIAGopAwA3AgALIAFB4AJqJAAMAQsACwzuAQsjAEHgAmsiASQAIAUgBhCYIiECAkACQAJAAkACQAJAIAcoAgAiCgRAIAFBnAJqIApBCGogBygCBBCKGCABKAKgAiEDIAEoApwCIgVBk4CAgHhGDQEgACABKQKkAjcCCCAAQRBqIAFBrAJqKAIANgIAIAAgAzYCBCAAIAU2AgAMBAsgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQAJAIAQtADRFBEAgAUGcAmoiAiABQaABakEk/AoAACABQQE2AsACIAFB/AFqIAIQnRcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNnQILQcAAIQkgBEHAABDRNEUNqAIgBARAELA+IARBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAIgAUIBNwLAAiABIAY2ArwCQQAhBSABQQA2ArgCIAEgAykCADcCoAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ8CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBGGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAhggASgCHBCCAyABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2tAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEQaiABQZwCaiIDENc7IAEoAhAhBhCwPkEcQQQQrTYiAkUNkwIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBCGogAxDXOyABKAIIIQQQsD5BHEEEEK02IgMNAgyTAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNkQIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ0EIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARB3PL/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBCoEyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0BCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJUIAIQ1DohBiABQaQBaiIDIAIQ+TQgASAGNgLAASABQQA2ArwBIAEgAjYCoAECQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAEgAUHUAGo2AsACIAFB/AFqIAIQ6BcgAUHwAWoiAiABQYgCaigCADYCACABIAEpAoACNwPoASABKAL8ASIDQZOAgIB4Rg0BIAFBgAFqIAIoAgA2AgAgASABKQPoATcCeCABIAEoAowCNgKEASABIAM2AnQMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIENgLUASABQdgBakF/IARBB2oiBSAEIAVLG0EDdhDSHyAEQQN0IgshBCALQThxIgUEQCALIAVrQUBrIgQgC0kNmwILQcAAIQkgBEHAABDRNEUNpgIgBARAELA+IARBwAAQrTYiCUUNlAILIAEoAuABIQ0gAUGoAmogA0EIaikCADcCACABQbACaiADQRBqKQIANwIAIAEgAjYCnAJBACEFIAFBADYCxAIgASAGNgK8AiABQQA2ArgCIAEgAykCADcCoAIgASABQdQAajYCwAIgAUGgAmohDkEAIQIDQCABQZACaiEPQgIhGyACIAZHBH8gAQJ+AkACQCABKAKgAgRAIAIgASgCsAJPDZ0CIAEoAqQCIAEoAqwCIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2ArgCIAFBMGogASgCnAIgAhDaKyABQfwBaiICIAEoAsACIAEoAjAgASgCNBD5AiABKAL8AUGTgICAeEcEQCACEIgRDAILIAEoAoACIgJFDQEgASABKQKEAjcCgAIgASACNgL8ASABQegBaiABQfwBahDgGSABKQPwASEbIAEpA+gBDAILIAEgAkEBajYCuAILQgALNwOQAiABIAEoAsQCIgNBAWo2AsQCIAFByAFqBSAPCyAbNwMAAkACQAJAIAEpA5ACIhtCAlIEQCAFIAlqIQIgG6dBAXFFDQEgAiABKQPIATcDACANIANBA3ZqIgIgAi0AAEEBIANBB3F0cjoAAAwCCwJAIAEoAqACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA4Q+x4LIAEgBUEDdSICNgL8ASACIAEoAtQBRw2rAiABKALgASECIAEoAuQBIQUgASABKQLYATcCqAIgAUEANgKkAiABIAU2AqACIAEgAjYCnAIgAUEoaiABQZwCaiIDENc7IAEoAighBhCwPkEcQQQQrTYiAkUNkQIgAkKBgICAEDcCACACIAEpApwCNwIIIAJBEGogAUGkAmoiDSkCADcCACACQRhqIAFBrAJqIg4oAgA2AgAgASAENgKsAiABQoCAgICACDcCpAIgASALNgKgAiABIAk2ApwCIAFBIGogAxDXOyABKAIgIQQQsD5BHEEEEK02IgMNAgyRAgsgAkIANwMACyAFQQhqIQUgASgCvAIhBiABKAK4AiECDAELCyADQoGAgIAQNwIAIAMgASkCnAI3AgggA0EQaiANKQIANwIAIANBGGogDigCADYCACABIAU2AuABIAEgBjYC3AEgASACNgLYARCwPkEMQQQQrTYiAkUNjwIgAiALNgIIIAIgBDYCBCACIAM2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgAUGcAmoiAkHc8v8AIAwgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiACEKgTDAELIAFB0AFqIAIoAgAiAzYCACABIAEpA+gBNwPIASABQZwCaiIEIAEoAswBIgIgAiADQQR0ahD1CSABQeABaiABQaQCaigCADYCACABQZgCaiIFIAFBsAJqKAIANgIAIAEgASkCnAI3A9gBIAEgASkCqAI3A5ACELA+QQxBBBCtNiICRQ2OAiACIAEpA5ACNwIAIAJBCGogBSgCADYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASAEQdzy/wAgAyABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAQQqBMgAUHIAWoiAhDJPiACEO07CyABLQBwIgJBKUcNAgsgAUHrAGogAUGEAWooAgAiAjYAACABQeMAaiABQfwAaikCACIbNwAAIAEgASkCdCIcNwBbIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILQQRBDBCjPQwCCyABQecAaiIFIAFBgAFqKQAANwAAIAFB4ABqIgMgAUH5AGopAAA3AwAgAUFAayIEIAFBkAFqKQIANwMAIAFByABqIgYgAUGYAWopAgA3AwAgAUGoAWoiCSADKQMANwMAIAFBrwFqIgMgBSkAADcAACABIAEpAogBNwM4IAEgASkAcTcDoAEgAUGlAmogCSkDADcAACABQawCaiADKQAANwAAIAFBvAJqIAQpAwA3AgAgAUHEAmogBikDADcCACABIAI6AJwCIAEgASkDoAE3AJ0CIAEgASkDODcCtAIgCgRAIAogCigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQULIAFBnAJqEKUMELA+QThBBBCtNiICRQ31ASACIAU2AhAgAiAKNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAKsBNwAUIAIgASkDODcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQbMBaigAADYAACACQShqIAFBQGspAwA3AgAgAkEwaiABQcgAaikDADcCAAsgAUHgAmokAAwBCwALDO0BCyMAQeACayIBJAAgBSAGEJgiIQICQAJAAkACQAJAAkAgBygCACIKBEAgAUGcAmogCkEIaiAHKAIEEIoYIAEoAqACIQMgASgCnAIiBUGTgICAeEYNASAAIAEpAqQCNwIIIABBEGogAUGsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyACENQ6IQYgAUGkAWoiAyACEPk0IAEgBjYCwAEgAUEANgK8ASABIAI2AqABAkACQAJAAkAgBC0ANEUEQCABQZwCaiICIAFBoAFqQST8CgAAIAFBATYCwAIgAUH8AWogAhDrFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENQ6GiACENQ6IQwgAhDUOhogASACENQ6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ2cAgtBwAAhCSAEQcAAENE0RQ2nAiAEBEAQsD4gBEHAABCtNiIJRQ2VAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAiABQgE3AsACIAEgBjYCvAJBACEFIAFBADYCuAIgASADKQIANwKgAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NngIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEYaiABKAKcAiACENorIAFB/AFqIgIgASgCwAIgASgCGCABKAIcEIIDIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDawCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQRBqIAFBnAJqIgMQ1zsgASgCECEGELA+QRxBBBCtNiICRQ2SAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEIaiADENc7IAEoAgghBBCwPkEcQQQQrTYiAw0CDJICCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2QAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDQQgAiABKQOQAjcCACACQQhqIAUoAgA2AgAgAUEBNgLwASABIAI2AuwBIAFBATYC6AEgAUEANgKEAiABQoCAgIDAADcC/AEgBEG88/8AIAMgASABQdgBaiABQegBaiABQfwBahCMEyABQfAAaiAEELQTIAFByAFqIgIQyT4gAhDtOwsgAS0AcCICQSlHDQELIAFB6wBqIAFBhAFqKAIAIgI2AAAgAUHjAGogAUH8AGopAgAiGzcAACABIAEpAnQiHDcAWyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AlQgAhDUOiEGIAFBpAFqIgMgAhD5NCABIAY2AsABIAFBADYCvAEgASACNgKgAQJAAkACQCAELQA0RQRAIAFBnAJqIgIgAUGgAWpBJPwKAAAgASABQdQAajYCwAIgAUH8AWogAhDgFyABQfABaiICIAFBiAJqKAIANgIAIAEgASkCgAI3A+gBIAEoAvwBIgNBk4CAgHhGDQEgAUGAAWogAigCADYCACABIAEpA+gBNwJ4IAEgASgCjAI2AoQBIAEgAzYCdAwDCyACENQ6GiACENQ6IQwgAhDUOhogASACENQ6IgQ2AtQBIAFB2AFqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBA3QiCyEEIAtBOHEiBQRAIAsgBWtBQGsiBCALSQ2aAgtBwAAhCSAEQcAAENE0RQ2lAiAEBEAQsD4gBEHAABCtNiIJRQ2TAgsgASgC4AEhDSABQagCaiADQQhqKQIANwIAIAFBsAJqIANBEGopAgA3AgAgASACNgKcAkEAIQUgAUEANgLEAiABIAY2ArwCIAFBADYCuAIgASADKQIANwKgAiABIAFB1ABqNgLAAiABQaACaiEOQQAhAgNAIAFBkAJqIQ9CAiEbIAIgBkcEfyABAn4CQAJAIAEoAqACBEAgAiABKAKwAk8NnAIgASgCpAIgASgCrAIgAmoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAEgAkEBajYCuAIgAUEwaiABKAKcAiACENorIAFB/AFqIgIgASgCwAIgASgCMCABKAI0EPkCIAEoAvwBQZOAgIB4RwRAIAIQiBEMAgsgASgCgAIiAkUNASABIAEpAoQCNwKAAiABIAI2AvwBIAFB6AFqIAFB/AFqEJkaIAEpA/ABIRsgASkD6AEMAgsgASACQQFqNgK4AgtCAAs3A5ACIAEgASgCxAIiA0EBajYCxAIgAUHIAWoFIA8LIBs3AwACQAJAAkAgASkDkAIiG0ICUgRAIAUgCWohAiAbp0EBcUUNASACIAEpA8gBNwMAIA0gA0EDdmoiAiACLQAAQQEgA0EHcXRyOgAADAILAkAgASgCoAIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAFQQN1IgI2AvwBIAIgASgC1AFHDaoCIAEoAuABIQIgASgC5AEhBSABIAEpAtgBNwKoAiABQQA2AqQCIAEgBTYCoAIgASACNgKcAiABQShqIAFBnAJqIgMQ1zsgASgCKCEGELA+QRxBBBCtNiICRQ2QAiACQoGAgIAQNwIAIAIgASkCnAI3AgggAkEQaiABQaQCaiINKQIANwIAIAJBGGogAUGsAmoiDigCADYCACABIAQ2AqwCIAFCgICAgIAINwKkAiABIAs2AqACIAEgCTYCnAIgAUEgaiADENc7IAEoAiAhBBCwPkEcQQQQrTYiAw0CDJACCyACQgA3AwALIAVBCGohBSABKAK8AiEGIAEoArgCIQIMAQsLIANCgYCAgBA3AgAgAyABKQKcAjcCCCADQRBqIA0pAgA3AgAgA0EYaiAOKAIANgIAIAEgBTYC4AEgASAGNgLcASABIAI2AtgBELA+QQxBBBCtNiICRQ2OAiACIAs2AgggAiAENgIEIAIgAzYCACABQQE2AvABIAEgAjYC7AEgAUEBNgLoASABQQA2AoQCIAFCgICAgMAANwL8ASABQZwCaiICQbzz/wAgDCABIAFB2AFqIAFB6AFqIAFB/AFqEIwTIAFB8ABqIAIQtBMMAQsgAUHQAWogAigCACIDNgIAIAEgASkD6AE3A8gBIAFBnAJqIgQgASgCzAEiAiACIANBBHRqEPUJIAFB4AFqIAFBpAJqKAIANgIAIAFBmAJqIgUgAUGwAmooAgA2AgAgASABKQKcAjcD2AEgASABKQKoAjcDkAIQsD5BDEEEEK02IgJFDY0CIAIgASkDkAI3AgAgAkEIaiAFKAIANgIAIAFBATYC8AEgASACNgLsASABQQE2AugBIAFBADYChAIgAUKAgICAwAA3AvwBIARBvPP/ACADIAEgAUHYAWogAUHoAWogAUH8AWoQjBMgAUHwAGogBBC0EyABQcgBaiICEMk+IAIQ7TsLIAEtAHAiAkEpRw0CCyABQesAaiABQYQBaigCACICNgAAIAFB4wBqIAFB/ABqKQIAIhs3AAAgASABKQJ0Ihw3AFsgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB5wBqIgUgAUGAAWopAAA3AAAgAUHgAGoiAyABQfkAaikAADcDACABQUBrIgQgAUGQAWopAgA3AwAgAUHIAGoiBiABQZgBaikCADcDACABQagBaiIJIAMpAwA3AwAgAUGvAWoiAyAFKQAANwAAIAEgASkCiAE3AzggASABKQBxNwOgASABQaUCaiAJKQMANwAAIAFBrAJqIAMpAAA3AAAgAUG8AmogBCkDADcCACABQcQCaiAGKQMANwIAIAEgAjoAnAIgASABKQOgATcAnQIgASABKQM4NwK0AiAKBEAgCiAKKAIAIgJBAWo2AgAgAkEASA0CIAcoAgQhBQsgAUGcAmoQpQwQsD5BOEEEEK02IgJFDfQBIAIgBTYCECACIAo2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgASkAqwE3ABQgAiABKQM4NwIgIABB+ImAATYCCCAAIAI2AgQgAEGTgICAeDYCACACQRxqIAFBswFqKAAANgAAIAJBKGogAUFAaykDADcCACACQTBqIAFByABqKQMANwIACyABQeACaiQADAELAAsM7AELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCmFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDZQCC0HAACEJIARBwAAQ0TRFDZYCIAQEQBCwPiAEQcAAEK02IglFDY0CCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2UAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhDaKyABQRBqIAEoAhggASgCHBCQHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDZsCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYoCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDIoCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDYgCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQazy/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELsTELA+QThBBBCtNiICRQ3zASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEEMwdELA+QThBBBCtNiICRQ3yASACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQbiEgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsM6wELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEDIAFBKGoiByACEPk0IAEgAzYCRCABQQA2AkAgASACNgIkAkACQAJAIAQtADRFBEAgAUH8AGogAUEkahCrFyABQdAAaiIDIAFBiAFqKAIANgIAIAEgASkCgAE3A0ggASgCfCIEQZOAgIB4Rg0BIAEoAowBIQIgACABKQNINwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiBDYC3AEgAUHIAGpBfyAEQQdqIgYgBCAGSxtBA3YQ0h8gBEECdCIFIQQgBUE8cSIJBEAgBSAJa0FAayIEIAVJDZMCC0HAACEJIARBwAAQ0TRFDZUCIAQEQBCwPiAEQcAAEK02IglFDYwCCyABKAJQIQwgAUGIAWogB0EIaikCADcCACABQZABaiAHQRBqKQIANwIAIAEgAjYCfCABQQA2AqABIAEgAzYCnAEgAUEANgKYASABIAcpAgA3AoABIAFBgAFqIQ1BACEHQQAhAgNAIAFB0AFqIQoCQCACIANGBEBBAiECDAELAkACQCABKAKAAUUNACACIAEoApABTw2TAiABKAKEASABKAKMASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXFFDQAgASACQQFqNgKYAUEAIQMMAQsgASACQQFqNgKYASABQRhqIAEoAnwgAhDaKyABQRBqIAEoAhggASgCHBCPHEECIQIgASgCECIDQQJGDQEgASgCFCECCyABIAM2AtABIAEgASgCoAEiBkEBajYCoAEgAUHAAWohCgsgCiACNgIAAkACQAJAIAEoAtABIgNBAkcEQCAHIAlqIQIgA0EBcUUNASACIAEoAsABNgIAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCgAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAHQQJ1IgI2AtABIAIgASgC3AFHDZoCIAEoAlAhAiABKAJUIQYgASABKQJINwKIASABQQA2AoQBIAEgBjYCgAEgASACNgJ8IAFBCGogAUH8AGoiAxDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYkCIAJCgYCAgBA3AgAgAiABKQJ8NwIIIAJBEGogAUGEAWoiCikCADcCACACQRhqIAFBjAFqIgwoAgA2AgAgASAENgKMASABQoCAgICACDcChAEgASAFNgKAASABIAk2AnwgASADENc7IAEoAgAhBBCwPkEcQQQQrTYiAw0CDIkCCyACQQA2AgALIAdBBGohByABKAKcASEDIAEoApgBIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ8NwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAGNgLIASABIAc2AsQBIAEgAjYCwAEQsD5BDEEEEK02IgJFDYcCIAIgBTYCCCACIAQ2AgQgAiADNgIAIAFBATYC2AEgASACNgLUASABQQE2AtABIAFBADYCUCABQoCAgIDAADcCSCABQfwAaiICQaTz/wAgCyABIAFBwAFqIAFB0AFqIAFByABqIgMQjBMgAyACELITELA+QThBBBCtNiICRQ3yASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHIAWogAygCADYCACABIAEpA0g3A8ABIAFB0AFqIgMgAUHAAWoQ6BggAUH8AGoiBCACEJM2EO4lIAFByABqIgUgAyAEENcdELA+QThBBBCtNiICRQ3xASACQoGAgIAQNwIAIAJBCGogBUEw/AoAACAAQeCDgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFB4AFqJAAMAAsM6gELIwBB4AFrIgEkACAFIAYQmCIiAhDUOiEFIAFBIGoiCSACEPk0IAEgBTYCPCABQQA2AjggASACNgIcAkACQAJAIAQtADRFBEAgAUH0AGogAUEcahDFFyABQcgAaiIDIAFBgAFqKAIANgIAIAEgASkCeDcDQCABKAJ0IgRBk4CAgHhGDQEgASgChAEhAiAAIAEpA0A3AgQgACACNgIQIAAgBDYCACAAQQxqIAMoAgA2AgAMAgsgAhDUOhogAhDUOiELIAIQ1DoaIAEgAhDUOiIDNgLEASABQcgBakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNkgILQcAAIQogA0HAABDRNEUNlgIgAwRAELA+IANBwAAQrTYiCkUNmAILIAEoAtABIQwgAUGAAWogCUEIaikCADcCACABQYgBaiAJQRBqKQIANwIAIAEgAjYCdEEAIQcgAUEANgKYASABIAU2ApQBIAFBADYCkAEgASAJKQIANwJ4IAFB+ABqIQlBACECA0AgAUG4AWohDUICIRsgAiAFRwR/IAECfgJAIAEoAngEQCACIAEoAogBTw2TAiABKAJ8IAEoAoQBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApABIAFBEGogASgCdCACENorIAFBQGsgASgCECABKAIUEI4cIAEpA0ghGyABKQNADAELIAEgAkEBajYCkAFCAAs3A7gBIAEgASgCmAEiBkEBajYCmAEgAUHYAWoFIA0LIBs3AwACQAJAAkAgASkDuAEiG0ICUgRAIAcgCmohAiAbp0EBcUUNASACIAEpA9gBNwMAIAwgBkEDdmoiAiACLQAAQQEgBkEHcXRyOgAADAILAkAgASgCeCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYCQCACIAEoAsQBRw2cAiABKALQASECIAEoAtQBIQUgASABKQLIATcCgAEgAUEANgJ8IAEgBTYCeCABIAI2AnQgAUEIaiABQfQAaiIGENc7IAEoAgghBxCwPkEcQQQQrTYiAkUNiAIgAkKBgICAEDcCACACIAEpAnQ3AgggAkEQaiABQfwAaiIJKQIANwIAIAJBGGogAUGEAWoiDCgCADYCACABIAM2AoQBIAFCgICAgIAINwJ8IAEgBDYCeCABIAo2AnQgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAw0CDIgCCyACQgA3AwALIAdBCGohByABKAKUASEFIAEoApABIQIMAQsLIANCgYCAgBA3AgAgAyABKQJ0NwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLAASABIAc2ArwBIAEgAjYCuAEQsD5BDEEEEK02IgJFDYYCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC0AEgASACNgLMASABQQE2AsgBIAFBADYCSCABQoCAgIDAADcCQCABQfQAaiICQZD0/wAgCyABIAFBuAFqIAFByAFqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDfEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQcABaiADKAIANgIAIAEgASkDQDcDuAEgAUHIAWoiAyABQbgBahC9GCABQfQAaiIEIAIQkzYQ7iUgAUFAayIFIAMgBBDCHRCwPkE4QQQQrTYiAkUN8AEgAkKBgICAEDcCACACQQhqIAVBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQeABaiQADAALDOkBCyMAQeABayIBJAAgBSAGEJgiIgIQ1DohBSABQSBqIgkgAhD5NCABIAU2AjwgAUEANgI4IAEgAjYCHAJAAkACQCAELQA0RQRAIAFB9ABqIAFBHGoQ5RcgAUHIAGoiAyABQYABaigCADYCACABIAEpAng3A0AgASgCdCIEQZOAgIB4Rg0BIAEoAoQBIQIgACABKQNANwIEIAAgAjYCECAAIAQ2AgAgAEEMaiADKAIANgIADAILIAIQ1DoaIAIQ1DohCyACENQ6GiABIAIQ1DoiAzYCxAEgAUHIAWpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDZECC0HAACEKIANBwAAQ0TRFDZUCIAMEQBCwPiADQcAAEK02IgpFDZcCCyABKALQASEMIAFBgAFqIAlBCGopAgA3AgAgAUGIAWogCUEQaikCADcCACABIAI2AnRBACEHIAFBADYCmAEgASAFNgKUASABQQA2ApABIAEgCSkCADcCeCABQfgAaiEJQQAhAgNAIAFBuAFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAJ4BEAgAiABKAKIAU8NkgIgASgCfCABKAKEASACaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASACQQFqNgKQASABQRBqIAEoAnQgAhDaKyABQUBrIAEoAhAgASgCFBDqHCABKQNIIRsgASkDQAwBCyABIAJBAWo2ApABQgALNwO4ASABIAEoApgBIgZBAWo2ApgBIAFB2AFqBSANCyAbNwMAAkACQAJAIAEpA7gBIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPYATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoAngiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgCRD7HgsgASAHQQN1IgI2AkAgAiABKALEAUcNmwIgASgC0AEhAiABKALUASEFIAEgASkCyAE3AoABIAFBADYCfCABIAU2AnggASACNgJ0IAFBCGogAUH0AGoiBhDXOyABKAIIIQcQsD5BHEEEEK02IgJFDYcCIAJCgYCAgBA3AgAgAiABKQJ0NwIIIAJBEGogAUH8AGoiCSkCADcCACACQRhqIAFBhAFqIgwoAgA2AgAgASADNgKEASABQoCAgICACDcCfCABIAQ2AnggASAKNgJ0IAEgBhDXOyABKAIAIQYQsD5BHEEEEK02IgMNAgyHAgsgAkIANwMACyAHQQhqIQcgASgClAEhBSABKAKQASECDAELCyADQoGAgIAQNwIAIAMgASkCdDcCCCADQRBqIAkpAgA3AgAgA0EYaiAMKAIANgIAIAEgBTYCwAEgASAHNgK8ASABIAI2ArgBELA+QQxBBBCtNiICRQ2FAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AtABIAEgAjYCzAEgAUEBNgLIASABQQA2AkggAUKAgICAwAA3AkAgAUH0AGoiAkGo9P8AIAsgASABQbgBaiABQcgBaiABQUBrIgMQjBMgAyACEKkTELA+QThBBBCtNiICRQ3wASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQYiDgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHAAWogAygCADYCACABIAEpA0A3A7gBIAFByAFqIgMgAUG4AWoQvRggAUH0AGoiBCACEJM2EO4lIAFBQGsiBSADIAQQ1R0QsD5BOEEEEK02IgJFDe8BIAJCgYCAgBA3AgAgAkEIaiAFQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHgAWokAAwACwzoAQtBACEHIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNmwIgASkDgAFC09jT+P3m9pJIhSABKQOIAUKi2J6I4aDq6cwAhYRQRQ2bAiACENQ6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADELkXIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDUOhogAhDUOiELIAIQ1DoaIAEgAhDUOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQJ0IgQhAyAEQTxxIgkEQCAEIAlrQUBrIgMgBEkNkQILQcAAIQkgA0HAABDRNEUNnwIgAwRAELA+IANBwAAQrTYiCUUNlwILIAEoAuABIQwgAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiENQQAhBkEAIQIDQCABQcgBaiEOQQIhCiACIAVHBH8CQAJAIAEoAoQBRQ0AIAIgASgClAFPDZECIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ApwBQQAhAgwBCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhDaKyABQdAAaiABKAIYIAEoAhwQsQwgASgCUEGTgICAeEYiAgRAIAEoAlQhCgwBCyABQdAAahCIEQsgASACNgLIASABIAEoAqgBIgdBAWo2AqgBIAFB7AFqBSAOCyAKNgIAAkACQAJAIAEoAsgBIgVBAkcEQCAGIAlqIQIgBUEBcUUNASACIAEoAuwBNgIAIAwgB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AlAgAiABKALUAUcNpAIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDYcCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiIMKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMhwILIAJBADYCAAsgBkEEaiEGIAEoAqABIQUgASgCnAEhAgwBCwsgA0KBgICAEDcCACADIAEpAoABNwIIIANBEGogCikCADcCACADQRhqIAwoAgA2AgAgASAFNgLQASABIAc2AswBIAEgAjYCyAEQsD5BDEEEEK02IgJFDYUCIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYC4AEgASACNgLcASABQQE2AtgBIAFBADYCWCABQoCAgIDAADcCUCABQYABaiICQfjz/wAgCyABIAFByAFqIAFB2AFqIAFB0ABqIgMQjBMgAyACEK8TDAELIAFBiAFqIAIoAgA2AgAgASABKQPYATcDgAEgAUHQAGogAUGAAWoQ4QgLELA+QThBBBCtNiICRQ3uASACQoGAgIAQNwIAIAJBCGogAUHQAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQfABaiQADAALDOcBC0EAIQdBACEKIwBB8AFrIgEkACABQSBqIAUgBigCEBEAACABQYABaiIDIAEoAiAiAiABKAIkKAIMEQAAAkAgAkUNmgIgASkDgAFC09jT+P3m9pJIhSABKQOIAUKi2J6I4aDq6cwAhYRQRQ2aAiACENQ6IQUgAUEwaiIGIAIQ+TQgASAFNgJMIAFBADYCSCABIAI2AiwCQAJAAkAgBC0ANEUEQCADIAFBLGpBJPwKAAAgASADNgKkASABQdAAaiADEN0XIAFB4AFqIgIgAUHcAGooAgA2AgAgASABKQJUNwPYASABKAJQIgNBk4CAgHhGDQEgASgCYCEEIAAgASkD2AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAhDUOhogAhDUOiEMIAIQ1DoaIAEgAhDUOiIDNgLUASABQdgBakF/IANBB2oiBCADIARLG0EDdhDSHyADQQN0IgQhAyAEQThxIgkEQCAEIAlrQUBrIgMgBEkNkAILQcAAIQkgA0HAABDRNEUNngIgAwRAELA+IANBwAAQrTYiCUUNlgILIAEoAuABIQ0gAUGMAWogBkEIaikCADcCACABQZQBaiAGQRBqKQIANwIAIAEgAjYCgAEgAUEANgKoASABIAU2AqABIAFBADYCnAEgASAGKQIANwKEASABIAFBgAFqNgKkASABQYQBaiEOQQAhBkEAIQIDQCABQcgBaiEPQQIhCyACIAVHBH8gAQJ/AkACQCABKAKEAQRAIAIgASgClAFPDZICIAEoAogBIAEoApABIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcQ0BCyABIAJBAWo2ApwBIAFBGGogASgCgAEgAhDaKyABQdAAaiABKAIYIAEoAhwQ4AcgASgCUEGTgICAeEYEQCABKAJYIQsgASgCVCEKQQEMAwsgAUHQAGoQiBEMAQsgASACQQFqNgKcAQtBAAs2AsgBIAEgASgCqAEiB0EBajYCqAEgAUHsAWoFIA8LIAs2AgACQAJAAkAgASgCyAEiBUECRwRAIAYgCWohAiAFQQFxRQ0BIAIgCjYCACACQQRqIAEoAuwBNgIAIA0gB0EDdmoiAiACLQAAQQEgB0EHcXRyOgAADAILAkAgASgChAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDhD7HgsgASAGQQN1IgI2AlAgAiABKALUAUcNowIgASgC4AEhAiABKALkASEFIAEgASkC2AE3AowBIAFBADYCiAEgASAFNgKEASABIAI2AoABIAFBEGogAUGAAWoiBhDXOyABKAIQIQcQsD5BHEEEEK02IgJFDYYCIAJCgYCAgBA3AgAgAiABKQKAATcCCCACQRBqIAFBiAFqIgopAgA3AgAgAkEYaiABQZABaiILKAIANgIAIAEgAzYCkAEgAUKAgICAgAg3AogBIAEgBDYChAEgASAJNgKAASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMhgILIAJBADYCACACQQRqQQA2AgALIAZBCGohBiABKAKgASEFIAEoApwBIQIMAQsLIANCgYCAgBA3AgAgAyABKQKAATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC0AEgASAHNgLMASABIAI2AsgBELA+QQxBBBCtNiICRQ2EAiACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AuABIAEgAjYC3AEgAUEBNgLYASABQQA2AlggAUKAgICAwAA3AlAgAUGAAWoiAkGE9P8AIAwgASABQcgBaiABQdgBaiABQdAAaiIDEIwTIAMgAhCsEwwBCyABQYgBaiACKAIANgIAIAEgASkD2AE3A4ABIAFB0ABqIAFBgAFqENkICxCwPkE4QQQQrTYiAkUN7QEgAkKBgICAEDcCACACQQhqIAFB0ABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUHwAWokAAwACwzmAQsgACECIwBBgAJrIgMkACADQSBqIAUgBigCEBEAACADQYABaiIBIAMoAiAiBSADKAIkKAIMEQAAAkACQAJAAkACQCAFRQ2dAiADKQOAAULT2NP4/eb2kkiFIAMpA4gBQqLYnojhoOrpzACFhFBFDZ0CIAUQ1DohByADQTBqIgkgBRD5NCADIAc2AkwgA0EANgJIIAMgBTYCLCAELQA0RQRAIAEgA0EsakEk/AoAACADIAE2AqQBIANB0ABqIAEQ5hcgA0H4AWoiASADQdwAaigCADYCACADIAMpAlQ3A/ABIAMoAlAiBEGTgICAeEYNASADKAJgIQIgACADKQPwATcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwECyAFENQ6GiAFENQ6IQogBRDUOhogAyAFENQ6IgA2AswBIANB0AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDYsCCyADKALYASELIANBjAFqIAlBCGopAgA3AgAgA0GUAWogCUEQaikCADcCACADIAU2AoABQQAhBSADQQA2AqgBIAMgBzYCoAEgA0EANgKcASADIAkpAgA3AoQBIAMgA0GAAWo2AqQBIAEhACAHRQ0DIANB0ABqQQRyIQkgA0HYAGohBwNAAkACQAJAAkAgAygChAEEQCAFIAMoApQBTw2UAiADKAKIASADKAKQASAFaiIMQQN2ai0AAEH/AXMgDEEHcXZBAXENAQsgAyAFQQFqNgKcASADQRhqIAMoAoABIAUQ2isgA0HQAGogAygCGCADKAIcEOkcAkAgAygCUCIFRQRAIANB+AFqIAdBCGopAwA3AwAgAyAHKQMANwPwAQwBCyAFDQILIANB6AFqIANB+AFqKQMAIhs3AwAgAyADKQPwASIcNwPgASADIAMoAqgBIgVBAWo2AqgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiIMIAwtAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgKcAQwBCyAJEIgRCyADQegBaiADQfgBaikDADcDACADIAMpA/ABNwPgASADIAMoAqgBQQFqNgKoASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCnAEiBSADKAKgAUcNAAsMAwsMoQILDI8CCyADQYgBaiABKAIANgIAIAMgAykD8AE3A4ABIANB0ABqIANBgAFqEM4IDAELAkAgAygChAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GEAWoQ+x4LIAMgACABa0EEdSIANgJQIAAgAygCzAFHDZ8CIAMoAtgBIQAgAygC3AEhBSADIAMpAtABNwKMASADQQA2AogBIAMgBTYChAEgAyAANgKAASADQRBqIANBgAFqIgcQ1zsgAygCECEJELA+QRxBBBCtNiIARQ2AAiAAQoGAgIAQNwIAIAAgAykCgAE3AgggAEEQaiADQYgBaiILKQIANwIAIABBGGogA0GQAWoiDCgCADYCACADIAQ2ApABIANCgICAgIAINwKIASADIAY2AoQBIAMgATYCgAEgA0EIaiAHENc7IAMoAgghBBCwPkEcQQQQrTYiAUUEQAyBAgsgAUKBgICAEDcCACABIAMpAoABNwIIIAFBEGogCykCADcCACABQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgADYC4AEQsD5BDEEEEK02IgBFDYICIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYC+AEgAyAANgL0ASADQQE2AvABIANBADYCWCADQoCAgIDAADcCUCADQYABaiIAQdDy/wAgCiADIANB4AFqIANB8AFqIANB0ABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUN7AEgAEKBgICAEDcCACAAQQhqIANB0ABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GAAmokAAwACwzlAQsgACEBIwBBgAJrIgckACAHQSRqIgIgBSAGEIwiIgMQ2CoCQAJAAkACQCAELQA0RQRAIAdBnAFqIAIQmhcgB0HQAGoiAiAHQagBaigCADYCACAHIAcpAqABNwNIIAcoApwBIgRBk4CAgHhGDQEgBygCrAEhASAAIAcpA0g3AgQgACABNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAwsgB0H4AGogB0EkakEk/AoAACAHQfgAaiIAEJA7GiAHKAKUASEGIAAQkDshCSAHQcgAaiICIABBJPwKAAAgAhCQOxogBygCZCEAIAcgB0HIAGoQkDsgAGsiADYC7AEgB0HwAWpBfyAAQQdqIgIgACACSxtBA3YQ0h8CQCAAIgJBP3EiAwRAIAIgAiADa0FAayICSw0BC0HAACEEIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIERQ33AQsgBygC+AEhCiAHQZwBaiAHQcgAakEk/AoAACAHQQA2AsABIAQhAyAHKAK4ASIFIAcoArwBRg0DA0ACQAJAAkACQCAHKAKgAUUNACAFIAcoArABTw2RAiAHKAKkASAHKAKsASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgByAFQQFqNgK4ASAHIAcoAsABQQFqNgLAAQwBCyAHIAVBAWo2ArgBIAdBGGogB0GcAWogBRCtKiAHQRBqIAcoAhggBygCHBC7HSAHIAcoAsABIgVBAWo2AsABIActABANAQsgA0EAOgAADAELIAMgBy0AEToAACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAsgA0EBaiEDIAcoArgBIgUgBygCvAFHDQALDAMLDKECCwyNAgsgB0H4AWogAigCADYCACAHIAcpA0g3A/ABIAdB+ABqIgAgB0HwAWoQ7hggB0GcAWoiAiADEJM2EO4lIAdByABqIgMgACACENgdELA+QThBBBCtNiIABEAgAEKBgICAEDcCACAAQQhqIANBMPwKAAAgAUGYh4ABNgIIIAEgADYCBCABQZOAgIB4NgIADAILDOwBCwJAIAcoAqABIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIAdBoAFqEPseCyAHIAMgBGsiAzYC4AEgAyAHKALsAUcNnwIgBygC+AEhAyAHKAL8ASEFIAcgBykC8AE3AqgBIAdBADYCpAEgByAFNgKgASAHIAM2ApwBIAdBCGogB0GcAWoiChDXOyAHKAIIIQsQsD5BHEEEEK02IgNFDf4BIANCgYCAgBA3AgAgAyAHKQKcATcCCCADQRBqIAdBpAFqIgwpAgA3AgAgA0EYaiAHQawBaiINKAIANgIAIAcgAjYCrAEgB0KAgICAgAg3AqQBIAcgADYCoAEgByAENgKcASAHIAoQ1zsgBygCACEEELA+QRxBBBCtNiICRQRADP8BCyACQoGAgIAQNwIAIAIgBykCnAE3AgggAkEQaiAMKQIANwIAIAJBGGogDSgCADYCACAHIAU2AugBIAcgCzYC5AEgByADNgLgARCwPkEMQQQQrTYiA0UNgAIgAyAANgIIIAMgBDYCBCADIAI2AgAgB0EBNgL4ASAHIAM2AvQBIAdBATYC8AEgB0EANgJQIAdCgICAgMAANwJIIAdBnAFqIgBB9PL/ACAJIAZrIAcgB0HgAWogB0HwAWogB0HIAGoiAhCMEyACIAAQthMQsD5BOEEEEK02IgBFDesBIABCgYCAgBA3AgAgAEEIaiACQTD8CgAAIAFBmIeAATYCCCABIAA2AgQgAUGTgICAeDYCAAsgB0GAAmokAAwACwzkAQsjAEGAAmsiAyQAIANBJGoiASAFIAYQjCIiAhDYKgJAAkACQCAELQA0RQRAIANBnAFqIAEQwBcgA0HQAGoiASADQagBaigCADYCACADIAMpAqABNwNIIAMoApwBIgRBk4CAgHhGDQEgAygCrAEhAiAAIAMpA0g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMAgsgA0H4AGogA0EkakEk/AoAACADQfgAaiIBEJA7GiADKAKUASEHIAEQkDshCSADQcgAaiICIAFBJPwKAAAgAhCQOxogAygCZCEBIAMgA0HIAGoQkDsgAWsiATYC7AEgA0HwAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEBdCIGIQQCQCAGQT5xIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNhwILIAMoAvgBIQogA0GcAWogA0HIAGpBJPwKAAAgA0EANgLAASACIQECQCADKAK4ASIFIAMoArwBRg0AA0ACQAJAAkAgAygCoAFFDQAgBSADKAKwAU8NjwIgAygCpAEgAygCrAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0AIAMgBUEBajYCuAEgAyADKALAAUEBajYCwAEMAQsgAyAFQQFqNgK4ASADQRhqIANBnAFqIAUQrSogA0EQaiADKAIYIAMoAhwQ7hwgAy8BECILQQJGDQMgAy8BEiEMIAMgAygCwAEiBUEBajYCwAEgC0EBcUUNACABIAw7AQAgCiAFQQN2aiILIAstAABBASAFQQdxdHI6AAAMAQsgAUEAOwEACyABQQJqIQEgAygCuAEiBSADKAK8AUcNAAsLAkAgAygCoAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GgAWoQ+x4LIAMgASACa0EBdSIBNgLgAQJAIAMoAuwBIAFGBEAgAygC+AEhASADKAL8ASEFIAMgAykC8AE3AqgBIANBADYCpAEgAyAFNgKgASADIAE2ApwBIANBCGogA0GcAWoiChDXOyADKAIIIQsQsD5BHEEEEK02IgFFDYICIAFCgYCAgBA3AgAgASADKQKcATcCCCABQRBqIANBpAFqIgwpAgA3AgAgAUEYaiADQawBaiINKAIANgIAIAMgBDYCrAEgA0KAgICAgAg3AqQBIAMgBjYCoAEgAyACNgKcASADIAoQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADIMCCyACQoGAgIAQNwIAIAIgAykCnAE3AgggAkEQaiAMKQIANwIAIAJBGGogDSgCADYCACADIAU2AugBIAMgCzYC5AEgAyABNgLgARCwPkEMQQQQrTYiAUUNhAIgASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJQIANCgICAgMAANwJIIANBnAFqIgFBmPP/ACAJIAdrIAMgA0HgAWogA0HwAWogA0HIAGoiAhCMEyACIAEQvRMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGAgYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAULDKMCCwztAQsMogILDIsCCyADQfgBaiABKAIANgIAIAMgAykDSDcD8AEgA0H4AGoiASADQfABahDpGCADQZwBaiIEIAIQkzYQ7iUgA0HIAGoiAiABIAQQ2h0QsD5BOEEEEK02IgFFDeoBIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBgIGAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAmokAAwACwzjAQsjAEGQAmsiASQAIAFBLGoiAiAFIAYQjCIiAxDYKgJAAkACQCAELQA0RQRAIAFBpAFqIAIQsRcgAUHYAGoiAiABQbABaigCADYCACABIAEpAqgBNwNQIAEoAqQBIgRBk4CAgHhGDQEgASgCtAEhAyAAIAEpA1A3AgQgACADNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgAUGAAWogAUEsakEk/AoAACABQYABaiICEJA7GiABKAKcASEGIAIQkDshBSABQdAAaiIDIAJBJPwKAAAgAxCQOxogASgCbCECIAEgAUHQAGoQkDsgAmsiAjYC9AEgAUH4AWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkECdCIEIQMgBEE8cSICBEAgBCACa0FAayIDIARJDYsCC0HAACEHIANBwAAQ0TRFDaECIAMEQBCwPiADQcAAEK02IgdFDZECCyABKAKAAiELIAFBpAFqIAFB0ABqQST8CgAAIAUgBmshDCABQQA2AsgBIAFBqAFqIQ1BACEGA0AgAUHoAWohCQJAIAEoAsABIgIgASgCxAFGBEBBAiECDAELAkACQCABKAKoAUUNACACIAEoArgBTw2LAiABKAKsASABKAK0ASACaiIKQQN2ai0AAEH/AXMgCkEHcXZBAXFFDQAgASACQQFqNgLAAUEAIQoMAQsgASACQQFqNgLAASABQSBqIAFBpAFqIAIQrSogAUEYaiABKAIgIAEoAiQQ7RxBAiECIAEoAhgiCkECRg0BIAEoAhwhAgsgASAKNgLoASABIAEoAsgBIgVBAWo2AsgBIAFBjAJqIQkLIAkgAjYCAAJAAkACQCABKALoASIJQQJHBEAgBiAHaiECIAlBAXFFDQEgAiABKAKMAjYCACALIAVBA3ZqIgIgAi0AAEEBIAVBB3F0cjoAAAwCCwJAIAEoAqgBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgBkECdSICNgLoASACIAEoAvQBRw2mAiABKAKAAiECIAEoAoQCIQUgASABKQL4ATcCsAEgAUEANgKsASABIAU2AqgBIAEgAjYCpAEgAUEQaiABQaQBaiIGENc7IAEoAhAhCRCwPkEcQQQQrTYiAkUNgQIgAkKBgICAEDcCACACIAEpAqQBNwIIIAJBEGogAUGsAWoiCikCADcCACACQRhqIAFBtAFqIgsoAgA2AgAgASADNgK0ASABQoCAgICACDcCrAEgASAENgKoASABIAc2AqQBIAFBCGogBhDXOyABKAIIIQYQsD5BHEEEEK02IgMNAgyBAgsgAkEANgIACyAGQQRqIQYMAQsLIANCgYCAgBA3AgAgAyABKQKkATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC8AEgASAJNgLsASABIAI2AugBELA+QQxBBBCtNiICRQ3/ASACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AoACIAEgAjYC/AEgAUEBNgL4ASABQQA2AlggAUKAgICAwAA3AlAgAUGkAWoiAkHI8/8AIAwgASABQegBaiABQfgBaiABQdAAaiIDEIwTIAMgAhCtExCwPkE4QQQQrTYiAkUN6gEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBgAJqIAIoAgA2AgAgASABKQNQNwP4ASABQYABaiICIAFB+AFqEOgYIAFBpAFqIgQgAxCTNhDuJSABQdAAaiIDIAIgBBC/HRCwPkE4QQQQrTYiAkUN6QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHwh4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDOIBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDCFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDYoCC0HAACEHIAJBwAAQ0TRFDaICIAIEQBCwPiACQcAAEK02IgdFDfEBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8NiwIgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBDWGyABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDacCIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ2AAiAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDIACCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDf4BIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQbT0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQsRMQsD5BOEEEEK02IgJFDekBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByIiAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDWHRCwPkE4QQQQrTYiAkUN6AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHIiIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDOEBCyAAIQEjAEGAAmsiByQAIAdBJGoiAiAFIAYQjCIiAxDYKgJAAkACQAJAIAQtADRFBEAgB0GcAWogAhDGFyAHQdAAaiICIAdBqAFqKAIANgIAIAcgBykCoAE3A0ggBygCnAEiBEGTgICAeEYNASAHKAKsASEBIAAgBykDSDcCBCAAIAE2AhAgACAENgIAIABBDGogAigCADYCAAwDCyAHQfgAaiAHQSRqQST8CgAAIAdB+ABqIgAQkDsaIAcoApQBIQYgABCQOyEJIAdByABqIgIgAEEk/AoAACACEJA7GiAHKAJkIQAgByAHQcgAahCQOyAAayIANgLsASAHQfABakF/IABBB2oiAiAAIAJLG0EDdhDSHwJAIAAiAkE/cSIDBEAgAiACIANrQUBrIgJLDQELQcAAIQQgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgRFDfMBCyAHKAL4ASEKIAdBnAFqIAdByABqQST8CgAAIAdBADYCwAEgBCEDIAcoArgBIgUgBygCvAFGDQMDQAJAAkACQAJAIAcoAqABRQ0AIAUgBygCsAFPDY0CIAcoAqQBIAcoAqwBIAVqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcUUNACAHIAVBAWo2ArgBIAcgBygCwAFBAWo2AsABDAELIAcgBUEBajYCuAEgB0EYaiAHQZwBaiAFEK0qIAdBEGogBygCGCAHKAIcELodIAcgBygCwAEiBUEBajYCwAEgBy0AEA0BCyADQQA6AAAMAQsgAyAHLQAROgAAIAogBUEDdmoiCyALLQAAQQEgBUEHcXRyOgAACyADQQFqIQMgBygCuAEiBSAHKAK8AUcNAAsMAwsMnQILDIkCCyAHQfgBaiACKAIANgIAIAcgBykDSDcD8AEgB0H4AGoiACAHQfABahDuGCAHQZwBaiICIAMQkzYQ7iUgB0HIAGoiAyAAIAIQwR0QsD5BOEEEEK02IgAEQCAAQoGAgIAQNwIAIABBCGogA0Ew/AoAACABQaiAgAE2AgggASAANgIEIAFBk4CAgHg2AgAMAgsM6AELAkAgBygCoAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgB0GgAWoQ+x4LIAcgAyAEayIDNgLgASADIAcoAuwBRw2bAiAHKAL4ASEDIAcoAvwBIQUgByAHKQLwATcCqAEgB0EANgKkASAHIAU2AqABIAcgAzYCnAEgB0EIaiAHQZwBaiIKENc7IAcoAgghCxCwPkEcQQQQrTYiA0UN+gEgA0KBgICAEDcCACADIAcpApwBNwIIIANBEGogB0GkAWoiDCkCADcCACADQRhqIAdBrAFqIg0oAgA2AgAgByACNgKsASAHQoCAgICACDcCpAEgByAANgKgASAHIAQ2ApwBIAcgChDXOyAHKAIAIQQQsD5BHEEEEK02IgJFBEAM+wELIAJCgYCAgBA3AgAgAiAHKQKcATcCCCACQRBqIAwpAgA3AgAgAkEYaiANKAIANgIAIAcgBTYC6AEgByALNgLkASAHIAM2AuABELA+QQxBBBCtNiIDRQ38ASADIAA2AgggAyAENgIEIAMgAjYCACAHQQE2AvgBIAcgAzYC9AEgB0EBNgLwASAHQQA2AlAgB0KAgICAwAA3AkggB0GcAWoiAEHg8/8AIAkgBmsgByAHQeABaiAHQfABaiAHQcgAaiICEIwTIAIgABC4ExCwPkE4QQQQrTYiAEUN5wEgAEKBgICAEDcCACAAQQhqIAJBMPwKAAAgAUGogIABNgIIIAEgADYCBCABQZOAgIB4NgIACyAHQYACaiQADAALDOABCyMAQYACayIDJAAgA0EkaiIBIAUgBhCMIiICENgqAkACQAJAIAQtADRFBEAgA0GcAWogARCeFyADQdAAaiIBIANBqAFqKAIANgIAIAMgAykCoAE3A0ggAygCnAEiBEGTgICAeEYNASADKAKsASECIAAgAykDSDcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwCCyADQfgAaiADQSRqQST8CgAAIANB+ABqIgEQkDsaIAMoApQBIQcgARCQOyEJIANByABqIgIgAUEk/AoAACACEJA7GiADKAJkIQEgAyADQcgAahCQOyABayIBNgLsASADQfABakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQF0IgYhBAJAIAZBPnEiAQRAIAYgAWtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ2DAgsgAygC+AEhCiADQZwBaiADQcgAakEk/AoAACADQQA2AsABIAIhAQJAIAMoArgBIgUgAygCvAFGDQADQAJAAkACQCADKAKgAUUNACAFIAMoArABTw2LAiADKAKkASADKAKsASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgAyAFQQFqNgK4ASADIAMoAsABQQFqNgLAAQwBCyADIAVBAWo2ArgBIANBGGogA0GcAWogBRCtKiADQRBqIAMoAhggAygCHBDsHCADLwEQIgtBAkYNAyADLwESIQwgAyADKALAASIFQQFqNgLAASALQQFxRQ0AIAEgDDsBACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAwBCyABQQA7AQALIAFBAmohASADKAK4ASIFIAMoArwBRw0ACwsCQCADKAKgASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQaABahD7HgsgAyABIAJrQQF1IgE2AuABAkAgAygC7AEgAUYEQCADKAL4ASEBIAMoAvwBIQUgAyADKQLwATcCqAEgA0EANgKkASADIAU2AqABIAMgATYCnAEgA0EIaiADQZwBaiIKENc7IAMoAgghCxCwPkEcQQQQrTYiAUUN/gEgAUKBgICAEDcCACABIAMpApwBNwIIIAFBEGogA0GkAWoiDCkCADcCACABQRhqIANBrAFqIg0oAgA2AgAgAyAENgKsASADQoCAgICACDcCpAEgAyAGNgKgASADIAI2ApwBIAMgChDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAM/wELIAJCgYCAgBA3AgAgAiADKQKcATcCCCACQRBqIAwpAgA3AgAgAkEYaiANKAIANgIAIAMgBTYC6AEgAyALNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ2AAiABIAY2AgggASAENgIEIAEgAjYCACADQQE2AvgBIAMgATYC9AEgA0EBNgLwASADQQA2AlAgA0KAgICAwAA3AkggA0GcAWoiAUGw8/8AIAkgB2sgAyADQeABaiADQfABaiADQcgAaiICEIwTIAIgARCqExCwPkE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQeiFgAE2AgggACABNgIEIABBk4CAgHg2AgAMBQsMnwILDOkBCwyeAgsMhwILIANB+AFqIAEoAgA2AgAgAyADKQNINwPwASADQfgAaiIBIANB8AFqEOkYIANBnAFqIgQgAhCTNhDuJSADQcgAaiICIAEgBBDNHRCwPkE4QQQQrTYiAUUN5gEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHohYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyADQYACaiQADAALDN8BCyMAQZACayIBJAAgAUEsaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGkAWogAhDLFyABQdgAaiICIAFBsAFqKAIANgIAIAEgASkCqAE3A1AgASgCpAEiBEGTgICAeEYNASABKAK0ASEDIAAgASkDUDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQYABaiABQSxqQST8CgAAIAFBgAFqIgIQkDsaIAEoApwBIQYgAhCQOyEFIAFB0ABqIgMgAkEk/AoAACADEJA7GiABKAJsIQIgASABQdAAahCQOyACayICNgL0ASABQfgBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgQhAyAEQTxxIgIEQCAEIAJrQUBrIgMgBEkNhwILQcAAIQcgA0HAABDRNEUNnQIgAwRAELA+IANBwAAQrTYiB0UNjQILIAEoAoACIQsgAUGkAWogAUHQAGpBJPwKAAAgBSAGayEMIAFBADYCyAEgAUGoAWohDUEAIQYDQCABQegBaiEJAkAgASgCwAEiAiABKALEAUYEQEECIQIMAQsCQAJAIAEoAqgBRQ0AIAIgASgCuAFPDYcCIAEoAqwBIAEoArQBIAJqIgpBA3ZqLQAAQf8BcyAKQQdxdkEBcUUNACABIAJBAWo2AsABQQAhCgwBCyABIAJBAWo2AsABIAFBIGogAUGkAWogAhCtKiABQRhqIAEoAiAgASgCJBDrHEECIQIgASgCGCIKQQJGDQEgASgCHCECCyABIAo2AugBIAEgASgCyAEiBUEBajYCyAEgAUGMAmohCQsgCSACNgIAAkACQAJAIAEoAugBIglBAkcEQCAGIAdqIQIgCUEBcUUNASACIAEoAowCNgIAIAsgBUEDdmoiAiACLQAAQQEgBUEHcXRyOgAADAILAkAgASgCqAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AugBIAIgASgC9AFHDaICIAEoAoACIQIgASgChAIhBSABIAEpAvgBNwKwASABQQA2AqwBIAEgBTYCqAEgASACNgKkASABQRBqIAFBpAFqIgYQ1zsgASgCECEJELA+QRxBBBCtNiICRQ39ASACQoGAgIAQNwIAIAIgASkCpAE3AgggAkEQaiABQawBaiIKKQIANwIAIAJBGGogAUG0AWoiCygCADYCACABIAM2ArQBIAFCgICAgIAINwKsASABIAQ2AqgBIAEgBzYCpAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDP0BCyACQQA2AgALIAZBBGohBgwBCwsgA0KBgICAEDcCACADIAEpAqQBNwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgASAFNgLwASABIAk2AuwBIAEgAjYC6AEQsD5BDEEEEK02IgJFDfsBIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYCgAIgASACNgL8ASABQQE2AvgBIAFBADYCWCABQoCAgIDAADcCUCABQaQBaiICQbjy/wAgDCABIAFB6AFqIAFB+AFqIAFB0ABqIgMQjBMgAyACELkTELA+QThBBBCtNiICRQ3mASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfj+/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUGAAmogAigCADYCACABIAEpA1A3A/gBIAFBgAFqIgIgAUH4AWoQ6BggAUGkAWoiBCADEJM2EO4lIAFB0ABqIgMgAiAEEMcdELA+QThBBBCtNiICRQ3lASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfj+/wA2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM3gELIwBBkAJrIgEkACABQRxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQZgBaiACEMgXIAFByABqIgIgAUGkAWooAgA2AgAgASABKQKcATcDQCABKAKYASIEQZOAgIB4Rg0BIAEoAqgBIQMgACABKQNANwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFB9ABqIAFBHGpBJPwKAAAgAUH0AGoiAhCQOxogASgCkAEhBCACEJA7IQUgAUFAayIDIAJBJPwKAAAgAxCQOxogASgCXCECIAEgAUFAaxCQOyACayICNgLcASABQeABakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgMhAiADQThxIgYEQCADIAZrQUBrIgIgA0kNhgILQcAAIQcgAkHAABDRNEUNngIgAgRAELA+IAJBwAAQrTYiB0UN7QELIAEoAugBIQkgAUGYAWogAUFAa0Ek/AoAACAFIARrIQpBACEGIAFBADYCvAEgAUGcAWohCwNAIAFB+AFqIQxCAiEbIAEoArQBIgQgASgCuAFHBH8gAQJ+AkAgASgCnAEEQCAEIAEoAqwBTw2HAiABKAKgASABKAKoASAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASAEQQFqNgK0ASABQRBqIAFBmAFqIAQQrSogAUGAAmogASgCECABKAIUENUbIAEpA4gCIRsgASkDgAIMAQsgASAEQQFqNgK0AUIACzcD+AEgASABKAK8ASIFQQFqNgK8ASABQfABagUgDAsgGzcDAAJAAkACQCABKQP4ASIbQgJSBEAgBiAHaiEEIBunQQFxRQ0BIAQgASkD8AE3AwAgCSAFQQN2aiIEIAQtAABBASAFQQdxdHI6AAAMAgsCQCABKAKcASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACALEPseCyABIAZBA3UiBDYCgAIgBCABKALcAUcNowIgASgC6AEhBCABKALsASEFIAEgASkC4AE3AqQBIAFBADYCoAEgASAFNgKcASABIAQ2ApgBIAFBCGogAUGYAWoiBhDXOyABKAIIIQkQsD5BHEEEEK02IgRFDfwBIARCgYCAgBA3AgAgBCABKQKYATcCCCAEQRBqIAFBoAFqIgspAgA3AgAgBEEYaiABQagBaiIMKAIANgIAIAEgAjYCqAEgAUKAgICAgAg3AqABIAEgAzYCnAEgASAHNgKYASABIAYQ1zsgASgCACEGELA+QRxBBBCtNiICDQIM/AELIARCADcDAAsgBkEIaiEGDAELCyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiALKQIANwIAIAJBGGogDCgCADYCACABIAU2AugBIAEgCTYC5AEgASAENgLgARCwPkEMQQQQrTYiBEUN+gEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKIAiABIAQ2AoQCIAFBATYCgAIgAUEANgJIIAFCgICAgMAANwJAIAFBmAFqIgJBnPT/ACAKIAEgAUHgAWogAUGAAmogAUFAayIDEIwTIAMgAhCuExCwPkE4QQQQrTYiAkUN5QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGwgoABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBiAJqIAIoAgA2AgAgASABKQNANwOAAiABQfQAaiICIAFBgAJqEOcYIAFBmAFqIgQgAxCTNhDuJSABQUBrIgMgAiAEENkdELA+QThBBBCtNiICRQ3kASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQbCCgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM3QELIwBBgAJrIgMkACADQSRqIgEgBSAGEIwiIgIQ2CoCQAJAAkACQCAELQA0RQRAIANBnAFqIAEQ2xcgA0HQAGoiASADQagBaigCADYCACADIAMpAqABNwNIIAMoApwBIgRBk4CAgHhGDQEgAygCrAEhAiAAIAMpA0g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMAwsgA0H4AGogA0EkakEk/AoAACADQfgAaiIBEJA7GiADKAKUASEHIAEQkDshCSADQcgAaiICIAFBJPwKAAAgAhCQOxogAygCZCEBIAMgA0HIAGoQkDsgAWsiATYC7AEgA0HwAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUECdCIGIQQCQCAGQTxxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNgQILIAMoAvgBIQogA0GcAWogA0HIAGpBJPwKAAAgA0EANgLAASACIQEgAygCuAEiBSADKAK8AUYNAwNAAkACQAJAAkAgAygCoAFFDQAgBSADKAKwAU8NiQIgAygCpAEgAygCrAEgBWoiC0EDdmotAABB/wFzIAtBB3F2QQFxRQ0AIAMgBUEBajYCuAEgAyADKALAAUEBajYCwAEMAQsgAyAFQQFqNgK4ASADQRhqIANBnAFqIAUQrSogA0HgAWogAygCGCADKAIcEMEBIAMgAygCwAEiBUEBajYCwAEgAygC4AFBMUYNAQsgAUEANgIADAELIAEgAyoC5AE4AgAgCiAFQQN2aiILIAstAABBASAFQQdxdHI6AAALIAFBBGohASADKAK4ASIFIAMoArwBRw0ACwwDCwycAgsMhQILIANB+AFqIAEoAgA2AgAgAyADKQNINwPwASADQfgAaiIBIANB8AFqEOgYIANBnAFqIgQgAhCTNhDuJSADQcgAaiICIAEgBBC+HRCwPkE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0P//ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCwzkAQsCQCADKAKgASIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQaABahD7HgsgAyABIAJrQQJ1IgE2AuABIAEgAygC7AFHDZgCIAMoAvgBIQEgAygC/AEhBSADIAMpAvABNwKoASADQQA2AqQBIAMgBTYCoAEgAyABNgKcASADQRBqIANBnAFqIgoQ1zsgAygCECELELA+QRxBBBCtNiIBRQ32ASABQoGAgIAQNwIAIAEgAykCnAE3AgggAUEQaiADQaQBaiIMKQIANwIAIAFBGGogA0GsAWoiDSgCADYCACADIAQ2AqwBIANCgICAgIAINwKkASADIAY2AqABIAMgAjYCnAEgA0EIaiAKENc7IAMoAgghBBCwPkEcQQQQrTYiAkUEQAz3AQsgAkKBgICAEDcCACACIAMpApwBNwIIIAJBEGogDCkCADcCACACQRhqIA0oAgA2AgAgAyAFNgLoASADIAs2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDfgBIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCUCADQoCAgIDAADcCSCADQZwBaiIBQYzz/wAgCSAHayADIANB4AFqIANB8AFqIANByABqIgIQjBMgAiABELMTELA+QThBBBCtNiIBRQ3jASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdD//wA2AgggACABNgIEIABBk4CAgHg2AgALIANBgAJqJAAMAAsM3AELIwBBgAJrIgMkACADQRxqIgEgBSAGEIwiIgIQ2CoCQAJAAkACQAJAIAQtADRFBEAgA0GYAWogARCvFyADQcgAaiIBIANBpAFqKAIANgIAIAMgAykCnAE3A0AgAygCmAEiBEGTgICAeEYNASADKAKoASECIAAgAykDQDcCBCAAIAI2AhAgACAENgIAIABBDGogASgCADYCAAwDCyADQfQAaiADQRxqQST8CgAAIANB9ABqIgEQkDsaIAMoApABIQcgARCQOyEJIANBQGsiAiABQST8CgAAIAIQkDsaIAMoAlwhASADIANBQGsQkDsgAWsiATYC3AEgA0HgAWpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEDdCIGIQQCQCAGQThxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhAiAEQcAAENE0BEAgBARAELA+IARBwAAQrTYiAkUNgQILIAMoAugBIQogA0GYAWogA0FAa0Ek/AoAACADQQA2ArwBIAIhASADKAK0ASIFIAMoArgBRg0DA0ACQAJAAkACQCADKAKcAUUNACAFIAMoAqwBTw2JAiADKAKgASADKAKoASAFaiILQQN2ai0AAEH/AXMgC0EHcXZBAXFFDQAgAyAFQQFqNgK0ASADIAMoArwBQQFqNgK8AQwBCyADIAVBAWo2ArQBIANBEGogA0GYAWogBRCtKiADQfABaiADKAIQIAMoAhQQ0QEgAyADKAK8ASIFQQFqNgK8ASADKALwAUEBcQ0BCyABQgA3AwAMAQsgASADKwP4ATkDACAKIAVBA3ZqIgsgCy0AAEEBIAVBB3F0cjoAAAsgAUEIaiEBIAMoArQBIgUgAygCuAFHDQALDAMLQfz2/wBBKSADQZgBakH4+v8AQaj3/wAQ1R4ACwyFAgsgA0H4AWogASgCADYCACADIAMpA0A3A/ABIANB9ABqIgEgA0HwAWoQ5xggA0GYAWoiBCACEJM2EO4lIANBQGsiAiABIAQQ2x0QsD5BOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdiBgAE2AgggACABNgIEIABBk4CAgHg2AgAMAgsM5AELAkAgAygCnAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GcAWoQ+x4LIAMgASACa0EDdSIBNgLwASABIAMoAtwBRw0BIAMoAugBIQEgAygC7AEhBSADIAMpAuABNwKkASADQQA2AqABIAMgBTYCnAEgAyABNgKYASADQQhqIANBmAFqIgoQ1zsgAygCCCELELA+QRxBBBCtNiIBRQ32ASABQoGAgIAQNwIAIAEgAykCmAE3AgggAUEQaiADQaABaiIMKQIANwIAIAFBGGogA0GoAWoiDSgCADYCACADIAQ2AqgBIANCgICAgIAINwKgASADIAY2ApwBIAMgAjYCmAEgAyAKENc7IAMoAgAhBBCwPkEcQQQQrTYiAkUEQAz3AQsgAkKBgICAEDcCACACIAMpApgBNwIIIAJBEGogDCkCADcCACACQRhqIA0oAgA2AgAgAyAFNgLoASADIAs2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDfgBIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCSCADQoCAgIDAADcCQCADQZgBaiIBQdTz/wAgCSAHayADIANB4AFqIANB8AFqIANBQGsiAhCMEyACIAEQxxMQsD5BOEEEEK02IgFFDeMBIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB2IGAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgA0GAAmokAAwBCyADQgA3AqQBIANCgYCAgMAANwKcASADQZTy/wA2ApgBQQAgA0HwAWogA0HcAWogA0GYAWpBnPL/ABCvKwALDNsBCyADLQABQQFrDgMLDA0KCyMAQZACayIBJAAgAUEsaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGkAWogAhDJFyABQdgAaiICIAFBsAFqKAIANgIAIAEgASkCqAE3A1AgASgCpAEiBEGTgICAeEYNASABKAK0ASEDIAAgASkDUDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQYABaiABQSxqQST8CgAAIAFBgAFqIgIQkDsaIAEoApwBIQYgAhCQOyEFIAFB0ABqIgMgAkEk/AoAACADEJA7GiABKAJsIQIgASABQdAAahCQOyACayICNgL0ASABQfgBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgQhAyAEQTxxIgIEQCAEIAJrQUBrIgMgBEkNggILQcAAIQcgA0HAABDRNEUNmAIgAwRAELA+IANBwAAQrTYiB0UNiAILIAEoAoACIQsgAUGkAWogAUHQAGpBJPwKAAAgBSAGayEMIAFBADYCyAEgAUGoAWohDUEAIQYDQCABQegBaiEJAkAgASgCwAEiAiABKALEAUYEQEECIQIMAQsCQAJAIAEoAqgBRQ0AIAIgASgCuAFPDYICIAEoAqwBIAEoArQBIAJqIgpBA3ZqLQAAQf8BcyAKQQdxdkEBcUUNACABIAJBAWo2AsABQQAhCgwBCyABIAJBAWo2AsABIAFBIGogAUGkAWogAhCtKiABQRhqIAEoAiAgASgCJBDYJkECIQIgASgCGCIKQQJGDQEgASgCHCECCyABIAo2AugBIAEgASgCyAEiBUEBajYCyAEgAUGMAmohCQsgCSACNgIAAkACQAJAIAEoAugBIglBAkcEQCAGIAdqIQIgCUEBcUUNASACIAEoAowCNgIAIAsgBUEDdmoiAiACLQAAQQEgBUEHcXRyOgAADAILAkAgASgCqAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgDRD7HgsgASAGQQJ1IgI2AugBIAIgASgC9AFHDZ0CIAEoAoACIQIgASgChAIhBSABIAEpAvgBNwKwASABQQA2AqwBIAEgBTYCqAEgASACNgKkASABQRBqIAFBpAFqIgYQ1zsgASgCECEJELA+QRxBBBCtNiICRQ34ASACQoGAgIAQNwIAIAIgASkCpAE3AgggAkEQaiABQawBaiIKKQIANwIAIAJBGGogAUG0AWoiCygCADYCACABIAM2ArQBIAFCgICAgIAINwKsASABIAQ2AqgBIAEgBzYCpAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDPgBCyACQQA2AgALIAZBBGohBgwBCwsgA0KBgICAEDcCACADIAEpAqQBNwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgASAFNgLwASABIAk2AuwBIAEgAjYC6AEQsD5BDEEEEK02IgJFDfYBIAIgBDYCCCACIAY2AgQgAiADNgIAIAFBATYCgAIgASACNgL8ASABQQE2AvgBIAFBADYCWCABQoCAgIDAADcCUCABQaQBaiICQezz/wAgDCABIAFB6AFqIAFB+AFqIAFB0ABqIgMQjBMgAyACEMQTELA+QThBBBCtNiICRQ3hASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcCGgAE2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUGAAmogAigCADYCACABIAEpA1A3A/gBIAFBgAFqIgIgAUH4AWoQ6BggAUGkAWoiBCADEJM2EO4lIAFB0ABqIgMgAiAEENIdELA+QThBBBCtNiICRQ3gASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcCGgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM2QELIwBBkAJrIgEkACABQRxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQZgBaiACEJ8XIAFByABqIgIgAUGkAWooAgA2AgAgASABKQKcATcDQCABKAKYASIEQZOAgIB4Rg0BIAEoAqgBIQMgACABKQNANwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFB9ABqIAFBHGpBJPwKAAAgAUH0AGoiAhCQOxogASgCkAEhBCACEJA7IQUgAUFAayIDIAJBJPwKAAAgAxCQOxogASgCXCECIAEgAUFAaxCQOyACayICNgLcASABQeABakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgMhAiADQThxIgYEQCADIAZrQUBrIgIgA0kNgQILQcAAIQcgAkHAABDRNEUNmQIgAgRAELA+IAJBwAAQrTYiB0UN6AELIAEoAugBIQkgAUGYAWogAUFAa0Ek/AoAACAFIARrIQpBACEGIAFBADYCvAEgAUGcAWohCwNAIAFB+AFqIQxCAiEbIAEoArQBIgQgASgCuAFHBH8gAQJ+AkAgASgCnAEEQCAEIAEoAqwBTw2CAiABKAKgASABKAKoASAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgASAEQQFqNgK0ASABQRBqIAFBmAFqIAQQrSogAUGAAmogASgCECABKAIUEL8SIAEpA4gCIRsgASkDgAIMAQsgASAEQQFqNgK0AUIACzcD+AEgASABKAK8ASIFQQFqNgK8ASABQfABagUgDAsgGzcDAAJAAkACQCABKQP4ASIbQgJSBEAgBiAHaiEEIBunQQFxRQ0BIAQgASkD8AE3AwAgCSAFQQN2aiIEIAQtAABBASAFQQdxdHI6AAAMAgsCQCABKAKcASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACALEPseCyABIAZBA3UiBDYCgAIgBCABKALcAUcNngIgASgC6AEhBCABKALsASEFIAEgASkC4AE3AqQBIAFBADYCoAEgASAFNgKcASABIAQ2ApgBIAFBCGogAUGYAWoiBhDXOyABKAIIIQkQsD5BHEEEEK02IgRFDfcBIARCgYCAgBA3AgAgBCABKQKYATcCCCAEQRBqIAFBoAFqIgspAgA3AgAgBEEYaiABQagBaiIMKAIANgIAIAEgAjYCqAEgAUKAgICAgAg3AqABIAEgAzYCnAEgASAHNgKYASABIAYQ1zsgASgCACEGELA+QRxBBBCtNiICDQIM9wELIARCADcDAAsgBkEIaiEGDAELCyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiALKQIANwIAIAJBGGogDCgCADYCACABIAU2AugBIAEgCTYC5AEgASAENgLgARCwPkEMQQQQrTYiBEUN9QEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKIAiABIAQ2AoQCIAFBATYCgAIgAUEANgJIIAFCgICAgMAANwJAIAFBmAFqIgJB6PL/ACAKIAEgAUHgAWogAUGAAmogAUFAayIDEIwTIAMgAhDAExCwPkE4QQQQrTYiAkUN4AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQhYABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBiAJqIAIoAgA2AgAgASABKQNANwOAAiABQfQAaiICIAFBgAJqEL0YIAFBmAFqIgQgAxCTNhDuJSABQUBrIgMgAiAEEMQdELA+QThBBBCtNiICRQ3fASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZCFgAE2AgggACACNgIEIABBk4CAgHg2AgALIAFBkAJqJAAMAAsM2AELIAMtAAEOAgsMzwELIAMtAAFBAmsOAgwNzgELIAMtAAFBAWsOAg4PDQsjAEGAAmsiASQAIAFBEGoiAiAFIAYoAhQRAAAgAUHUAGoiAyACENINIAMQ0jwhBUEAIQMgASgCdCIEQRBPBEAgASgCcCECIARBBHYhBANAIAMgAigCAGohAyACQRBqIQIgBEEBayIEDQALCyABQZABaiAFIAMQphQgAUHEAWogAUHUAGoQ2CoCQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQcgAUGoAWohCQNAAkACQCABKALIAQRAIAIgASgC2AFPDZoCIAEoAswBIAEoAtQBIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AuABIAFBCGogAUHEAWogAhCtKiABQZABaiABKAIIIAEoAgwQoTYCQCABKAKoAQRAIAEoArgBIgRBAWoiBUEDdiAFQQdxQQBHaiIDIAEoArQBIgJLBEAgAyACayEGIAEoAqwBIgogA0kEQCAJIApBAXQiAiADEM0qIgogAiAKSxsQ6BkgASgCtAEhAgsgBgRAIAEoArABIAJqQQAgBvwLAAsgASADNgK0AQsgASAFNgK4ASABKAKwASAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAK8AUEBajYCvAELIAEoApgBIQMgASgCpAEiAiABKAKcAUYEQCAHQaC+/wAQnSgLIAEoAqABIAJBAnRqIAM2AgAgASACQQFqNgKkAQwBCyABIAJBAWo2AuABIAFBkAFqEKYVCyABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiAyABQZABaiIEEOsOELA+QcQAQQQQrTYiAkUN2wEgAkKBgICAEDcCACACQQhqIANBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAQQuiwgAUHUAGoQ3iIgAUGAAmokAAwACwzUAQsjAEGAAmsiASQAIAFBEGoiAiAFIAYoAhQRAAAgAUHUAGoiAyACENINIAMQ0jwhBUEAIQMgASgCdCIEQRBPBEAgASgCcCECIARBBHYhBANAIAMgAigCAGohAyACQRBqIQIgBEEBayIEDQALCyABQZABaiAFIAMQpRQgAUHEAWogAUHUAGoQ2CoCQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQcgAUGoAWohCQNAAkACQCABKALIAQRAIAIgASgC2AFPDZkCIAEoAswBIAEoAtQBIAJqIgNBA3ZqLQAAQf8BcyADQQdxdkEBcQ0BCyABIAJBAWo2AuABIAFBCGogAUHEAWogAhCtKiABQZABaiABKAIIIAEoAgwQoTYCQCABKAKoAQRAIAEoArgBIgRBAWoiBUEDdiAFQQdxQQBHaiIDIAEoArQBIgJLBEAgAyACayEGIAEoAqwBIgogA0kEQCAJIApBAXQiAiADEM0qIgogAiAKSxsQ6BkgASgCtAEhAgsgBgRAIAEoArABIAJqQQAgBvwLAAsgASADNgK0AQsgASAFNgK4ASABKAKwASAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAK8AUEBajYCvAELIAE1ApgBIRsgASgCpAEiAiABKAKcAUYEQCAHQaC+/wAQsygLIAEoAqABIAJBA3RqIBs3AwAgASACQQFqNgKkAQwBCyABIAJBAWo2AuABIAFBkAFqEKcVCyABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiAyABQZABaiIEEOwOELA+QcQAQQQQrTYiAkUN2gEgAkKBgICAEDcCACACQQhqIANBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAQQuywgAUHUAGoQ3iIgAUGAAmokAAwACwzTAQsgCEHQAGoiASAFIAYQjCIQoxQgCEGQAmoiAiABEK0fIAIQ7CkhASAAQfDf/wA2AgggACABNgIEIABBk4CAgHg2AgAM0gELIwBBgAJrIgEkACABQRBqIgIgBSAGKAIUEQAAIAFB1ABqIgMgAhDSDSADENI8IQVBACEDIAEoAnQiBEEQTwRAIAEoAnAhAiAEQQR2IQQDQCADIAIoAgBqIQMgAkEQaiECIARBAWsiBA0ACwsgAUGQAWogBSADEKYUIAFBxAFqIAFB1ABqENgqAkACQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQkgAUGoAWohBQNAAkAgCQJ/AkAgASgCyAEEQCACIAEoAtgBTw2ZAiABKALMASABKALUASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLgASABQQhqIAFBxAFqIAIQrSogAUGQAWogASgCCCABKAIMEKE2AkAgASgCqAEEQCABKAK4ASIEQQFqIgZBA3YgBkEHcUEAR2oiAyABKAK0ASICSwRAIAMgAmshByABKAKsASIKIANJBEAgBSAKQQF0IgIgAxDNKiIKIAIgCksbEOgZIAEoArQBIQILIAcEQCABKAKwASACakEAIAf8CwALIAEgAzYCtAELIAEgBjYCuAEgASgCsAEgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCvAFBAWo2ArwBCyABKAKYASEDIAEoAqQBIgIgASgCnAFHDQJBoL7/AAwBCyABIAJBAWo2AuABIAUQ5jogASgCqAFFDQQgASgCuAFBAWoiA0EDdiADQQdxQQBHaiICIAEoArQBIgRLBEAgAiAEayEGIAEoAqwBIgcgAkkEQCAFIAdBAXQiBCACEM0qIgcgBCAHSxsQ6BkgASgCtAEhBAsgBgRAIAEoArABIARqQQAgBvwLAAsgASACNgK0AQsgASADNgK4ASABKAKYASEDIAEoAqQBIgIgASgCnAFHDQFBgL7/AAsQnSgLIAEoAqABIAJBAnRqIAM2AgAgASACQQFqNgKkASABKALgASICIAEoAuQBRw0ACwsCQCABKALIASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQcgBahD7HgsgAUHEAWoiBCABQZABaiIDEO0OELA+QcQAQQQQrTYiAkUN2QEgAkKBgICAEDcCACACQQhqIARBPPwKAAAgAEHI6/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAMQyT4gAxDeOyABQZwBaiIAEMk+IAAQ6TsgASgCqAEEQCABQagBahDPLwsgAUHUAGoQ3iIgAUGAAmokAAwBC0Howf8AELI7AAsM0QELIwBBgAJrIgEkACABQRBqIgIgBSAGKAIUEQAAIAFB1ABqIgMgAhDSDSADENI8IQVBACEDIAEoAnQiBEEQTwRAIAEoAnAhAiAEQQR2IQQDQCADIAIoAgBqIQMgAkEQaiECIARBAWsiBA0ACwsgAUGQAWogBSADEKUUIAFBxAFqIAFB1ABqENgqAkACQCABKALgASICIAEoAuQBRwRAIAFBnAFqIQkgAUGoAWohBQNAAkAgCQJ/AkAgASgCyAEEQCACIAEoAtgBTw2YAiABKALMASABKALUASACaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgASACQQFqNgLgASABQQhqIAFBxAFqIAIQrSogAUGQAWogASgCCCABKAIMEKE2AkAgASgCqAEEQCABKAK4ASIEQQFqIgZBA3YgBkEHcUEAR2oiAyABKAK0ASICSwRAIAMgAmshByABKAKsASIKIANJBEAgBSAKQQF0IgIgAxDNKiIKIAIgCksbEOgZIAEoArQBIQILIAcEQCABKAKwASACakEAIAf8CwALIAEgAzYCtAELIAEgBjYCuAEgASgCsAEgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCvAFBAWo2ArwBCyABKAKYASEDIAEoAqQBIgIgASgCnAFHDQJBoL7/AAwBCyABIAJBAWo2AuABIAUQ5jogASgCqAFFDQQgASgCuAFBAWoiA0EDdiADQQdxQQBHaiICIAEoArQBIgRLBEAgAiAEayEGIAEoAqwBIgcgAkkEQCAFIAdBAXQiBCACEM0qIgcgBCAHSxsQ6BkgASgCtAEhBAsgBgRAIAEoArABIARqQQAgBvwLAAsgASACNgK0AQsgASADNgK4ASABKAKYASEDIAEoAqQBIgIgASgCnAFHDQFBgL7/AAsQsygLIAEoAqABIAJBA3RqIAOtNwMAIAEgAkEBajYCpAEgASgC4AEiAiABKALkAUcNAAsLAkAgASgCyAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUHIAWoQ+x4LIAFBxAFqIgQgAUGQAWoiAxDuDhCwPkHEAEEEEK02IgJFDdgBIAJCgYCAgBA3AgAgAkEIaiAEQTz8CgAAIABBoOz/ADYCCCAAIAI2AgQgAEGTgICAeDYCACADEMk+IAMQ3jsgAUGcAWoiABDJPiAAEOM8IAEoAqgBBEAgAUGoAWoQzy8LIAFB1ABqEN4iIAFBgAJqJAAMAQtB6MH/ABCyOwALDNABCyMAQaADayIBJAAgBSAGEIwiIQICQAJAAkACQAJAAkAgBygCACIGBEAgAUHcAmogBkEIaiAHKAIEEIoYIAEoAuACIQMgASgC3AIiBUGTgICAeEYNASAAIAEpAuQCNwIIIABBEGogAUHsAmooAgA2AgAgACADNgIEIAAgBTYCAAwECyABQZwBaiIDIAIQ2CoCQAJAAkACQCAELQA0RQRAIAFB3AJqIgIgA0Ek/AoAACABQQE2AoADIAFB6AFqIAIQuxcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABQQE2AuQBIAIQkDsaIAEoAtwBIQMgAhCQOyEEIAFB6AFqIgUgAkEo/AoAACAFEJA7GiABKAKEAiECIAEgBRCQOyACayICNgKUAiABQZgCakF/IAJBB2oiBSACIAVLG0EDdhDSHyACQQN0IgkhAiAJQThxIgUEQCAJIAVrQUBrIgIgCUkN/wELQcAAIQUgAkHAABDRNEUNmgIgAgRAELA+IAJBwAAQrTYiBUUN5gELIAEoAqACIQsgAUHcAmogAUHoAWpBKPwKAAAgBCADayEMQQAhAyABQQA2AoQDIAFB4AJqIQ0DQCABQbACaiEOQgIhGyABKAL4AiIKIAEoAvwCRwR/IAECfgJAAkAgASgC4AIEQCAKIAEoAvACTw2BAiABKALkAiABKALsAiAKaiIEQQN2ai0AAEH/AXMgBEEHcXZBAXENAQsgASAKQQFqNgL4AiABQRBqIAFB3AJqIAoQrSogAUHIAmoiBCABKAKAAyABKAIQIAEoAhQQggMgASgCyAJBk4CAgHhHBEAgBBCIEQwCCyABKALMAiIERQ0BIAEgASkC0AI3AswCIAEgBDYCyAIgAUG4AmogAUHIAmoQxCcgASkDwAIhGyABKQO4AgwCCyABIApBAWo2AvgCC0IACzcDsAIgASABKAKEAyIEQQFqNgKEAyABQagCagUgDgsgGzcDAAJAAkACQCABKQOwAiIbQgJSBEAgAyAFaiEKIBunQQFxRQ0BIAogASkDqAI3AwAgCyAEQQN2aiIKIAotAABBASAEQQdxdHI6AAAMAgsCQCABKALgAiIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACANEPseCyABIANBA3UiAzYCyAIgAyABKAKUAkcNnwIgASgCoAIhAyABKAKkAiEEIAEgASkCmAI3AugCIAFBADYC5AIgASAENgLgAiABIAM2AtwCIAFBCGogAUHcAmoiChDXOyABKAIIIQsQsD5BHEEEEK02IgNFDfUBIANCgYCAgBA3AgAgAyABKQLcAjcCCCADQRBqIAFB5AJqIg0pAgA3AgAgA0EYaiABQewCaiIOKAIANgIAIAEgAjYC7AIgAUKAgICAgAg3AuQCIAEgCTYC4AIgASAFNgLcAiABIAoQ1zsgASgCACEFELA+QRxBBBCtNiICDQIM9QELIApCADcDAAsgA0EIaiEDDAELCyACQoGAgIAQNwIAIAIgASkC3AI3AgggAkEQaiANKQIANwIAIAJBGGogDigCADYCACABIAQ2AsACIAEgCzYCvAIgASADNgK4AhCwPkEMQQQQrTYiA0UN8wEgAyAJNgIIIAMgBTYCBCADIAI2AgAgAUEBNgLQAiABIAM2AswCIAFBATYCyAIgAUEANgLwASABQoCAgIDAADcC6AEgAUHcAmoiAkGA8/8AIAwgASABQbgCaiABQcgCaiABQegBahCMEyABQewAaiACEL8TDAELIAFBoAJqIAIoAgAiAzYCACABIAEpA8ABNwOYAiABQdwCaiIEIAEoApwCIgIgAiADQQR0ahD1CSABQdACaiABQeQCaigCADYCACABQcACaiIFIAFB8AJqKAIANgIAIAEgASkC3AI3A8gCIAEgASkC6AI3A7gCELA+QQxBBBCtNiICRQ0EIAIgASkDuAI3AgAgAkEIaiAFKAIANgIAIAFBATYCyAEgASACNgLEASABQQE2AsABIAFBADYC8AEgAUKAgICAwAA3AugBIARBgPP/ACADIAEgAUHIAmogAUHAAWogAUHoAWoQjBMgAUHsAGogBBC/EyABQZgCaiICEMk+IAIQ7TsLIAEtAGwiA0EpRw0BCyABQeMAaiABQYABaigCACICNgAAIAFB2wBqIAFB+ABqKQIAIhs3AAAgASABKQJwIhw3AFMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMBAsMAgsgASADNgJMIAFBnAFqIgMgAhDYKgJAAkACQCAELQA0RQRAIAFB3AJqIgIgA0Ek/AoAACABIAFBzABqNgKAAyABQegBaiACENEXIAFByAFqIgIgAUH0AWooAgA2AgAgASABKQLsATcDwAEgASgC6AEiA0GTgICAeEYNASABQfwAaiACKAIANgIAIAEgASkDwAE3AnQgASABKAL4ATYCgAEgASADNgJwDAMLIAFBwAFqIgIgAUGcAWpBJPwKAAAgASABQcwAajYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ39AQtBwAAhBSACQcAAENE0RQ2YAiACBEAQsD4gAkHAABCtNiIFRQ3kAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf8BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBKGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAiggASgCLBD5AiABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahDEJyABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2dAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEgaiABQdwCaiIKENc7IAEoAiAhCxCwPkEcQQQQrTYiA0UN8wEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAFBGGogChDXOyABKAIYIQUQsD5BHEEEEK02IgINAgzzAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3xASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQYDz/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQvxMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDfABIAIgASkDuAI3AgAgAkEIaiAFKAIANgIAIAFBATYCyAEgASACNgLEASABQQE2AsABIAFBADYC8AEgAUKAgICAwAA3AugBIARBgPP/ACADIAEgAUHIAmogAUHAAWogAUHoAWoQjBMgAUHsAGogBBC/EyABQZgCaiICEMk+IAIQ7TsLIAEtAGwiA0EpRw0CCyABQeMAaiABQYABaigCACICNgAAIAFB2wBqIAFB+ABqKQIAIhs3AAAgASABKQJwIhw3AFMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgtBBEEMEKM9DAILIAFB3wBqIgQgAUH8AGopAAA3AAAgAUHYAGoiAiABQfUAaikAADcDACABQThqIgUgAUGMAWopAgA3AwAgAUFAayIJIAFBlAFqKQIANwMAIAFB8AFqIgogAikDADcDACABQfcBaiICIAQpAAA3AAAgASABKQKEATcDMCABIAEpAG03A+gBIAFB5QJqIAopAwA3AAAgAUHsAmogAikAADcAACABQfwCaiAFKQMANwIAIAFBhANqIAkpAwA3AgAgASADOgDcAiABIAEpA+gBNwDdAiABIAEpAzA3AvQCIAYEQCAGIAYoAgAiAkEBajYCACACQQBIDQIgBygCBCEECyABQdwCahClDBCwPkE4QQQQrTYiAkUN1wEgAiAENgIQIAIgBjYCDCACQQ07AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQaCJgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzwELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhDNFyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ3+AQtBwAAhBSACQcAAENE0RQ2ZAiACBEAQsD4gAkHAABCtNiIFRQ3lAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDYACIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahCZJCABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2eAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN9AEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgz0AQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3yASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQcTy/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQxhMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHE8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEMYTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQqhcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfwBC0HAACEFIAJBwAAQ0TRFDZcCIAIEQBCwPiACQcAAEK02IgVFDeMBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/gEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEJkkIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZwCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3yASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPIBCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDfABIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJBxPL/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhDGEwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7wEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHE8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEMYTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3WASACIAQ2AhAgAiAGNgIMIAJBjQI7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQdCKgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzgELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhCbFyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ39AQtBwAAhBSACQcAAENE0RQ2YAiACBEAQsD4gAkHAABCtNiIFRQ3kAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf8BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahDgGSABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2dAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN8wEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgzzAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3xASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQdzy/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQqBMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHc8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEKgTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQ5BcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfsBC0HAACEFIAJBwAAQ0TRFDZYCIAIEQBCwPiACQcAAEK02IgVFDeIBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/QEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEOAZIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZsCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3xASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPEBCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDe8BIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJB3PL/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhCoEwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7gEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEHc8v8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEEKgTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3VASACIAQ2AhAgAiAGNgIMIAJBjQQ7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQaiLgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzQELIwBBoANrIgEkACAFIAYQjCIhAgJAAkACQAJAAkACQCAHKAIAIgYEQCABQdwCaiAGQQhqIAcoAgQQihggASgC4AIhAyABKALcAiIFQZOAgIB4Rg0BIAAgASkC5AI3AgggAEEQaiABQewCaigCADYCACAAIAM2AgQgACAFNgIADAQLIAFBnAFqIgMgAhDYKgJAAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAFBATYCgAMgAUHoAWogAhC/FyABQcgBaiICIAFB9AFqKAIANgIAIAEgASkC7AE3A8ABIAEoAugBIgNBk4CAgHhGDQEgAUH8AGogAigCADYCACABIAEpA8ABNwJ0IAEgASgC+AE2AoABIAEgAzYCcAwDCyABQcABaiICIAFBnAFqQST8CgAAIAFBATYC5AEgAhCQOxogASgC3AEhAyACEJA7IQQgAUHoAWoiBSACQSj8CgAAIAUQkDsaIAEoAoQCIQIgASAFEJA7IAJrIgI2ApQCIAFBmAJqQX8gAkEHaiIFIAIgBUsbQQN2ENIfIAJBA3QiCSECIAlBOHEiBQRAIAkgBWtBQGsiAiAJSQ38AQtBwAAhBSACQcAAENE0RQ2XAiACBEAQsD4gAkHAABCtNiIFRQ3jAQsgASgCoAIhCyABQdwCaiABQegBakEo/AoAACAEIANrIQxBACEDIAFBADYChAMgAUHgAmohDQNAIAFBsAJqIQ5CAiEbIAEoAvgCIgogASgC/AJHBH8gAQJ+AkACQCABKALgAgRAIAogASgC8AJPDf4BIAEoAuQCIAEoAuwCIApqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcQ0BCyABIApBAWo2AvgCIAFBEGogAUHcAmogChCtKiABQcgCaiIEIAEoAoADIAEoAhAgASgCFBCCAyABKALIAkGTgICAeEcEQCAEEIgRDAILIAEoAswCIgRFDQEgASABKQLQAjcCzAIgASAENgLIAiABQbgCaiABQcgCahCZGiABKQPAAiEbIAEpA7gCDAILIAEgCkEBajYC+AILQgALNwOwAiABIAEoAoQDIgRBAWo2AoQDIAFBqAJqBSAOCyAbNwMAAkACQAJAIAEpA7ACIhtCAlIEQCADIAVqIQogG6dBAXFFDQEgCiABKQOoAjcDACALIARBA3ZqIgogCi0AAEEBIARBB3F0cjoAAAwCCwJAIAEoAuACIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgA0EDdSIDNgLIAiADIAEoApQCRw2cAiABKAKgAiEDIAEoAqQCIQQgASABKQKYAjcC6AIgAUEANgLkAiABIAQ2AuACIAEgAzYC3AIgAUEIaiABQdwCaiIKENc7IAEoAgghCxCwPkEcQQQQrTYiA0UN8gEgA0KBgICAEDcCACADIAEpAtwCNwIIIANBEGogAUHkAmoiDSkCADcCACADQRhqIAFB7AJqIg4oAgA2AgAgASACNgLsAiABQoCAgICACDcC5AIgASAJNgLgAiABIAU2AtwCIAEgChDXOyABKAIAIQUQsD5BHEEEEK02IgINAgzyAQsgCkIANwMACyADQQhqIQMMAQsLIAJCgYCAgBA3AgAgAiABKQLcAjcCCCACQRBqIA0pAgA3AgAgAkEYaiAOKAIANgIAIAEgBDYCwAIgASALNgK8AiABIAM2ArgCELA+QQxBBBCtNiIDRQ3wASADIAk2AgggAyAFNgIEIAMgAjYCACABQQE2AtACIAEgAzYCzAIgAUEBNgLIAiABQQA2AvABIAFCgICAgMAANwLoASABQdwCaiICQbzz/wAgDCABIAFBuAJqIAFByAJqIAFB6AFqEIwTIAFB7ABqIAIQtBMMAQsgAUGgAmogAigCACIDNgIAIAEgASkDwAE3A5gCIAFB3AJqIgQgASgCnAIiAiACIANBBHRqEPUJIAFB0AJqIAFB5AJqKAIANgIAIAFBwAJqIgUgAUHwAmooAgA2AgAgASABKQLcAjcDyAIgASABKQLoAjcDuAIQsD5BDEEEEK02IgJFDQQgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEG88/8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEELQTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQELIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwECwwCCyABIAM2AkwgAUGcAWoiAyACENgqAkACQAJAIAQtADRFBEAgAUHcAmoiAiADQST8CgAAIAEgAUHMAGo2AoADIAFB6AFqIAIQ5xcgAUHIAWoiAiABQfQBaigCADYCACABIAEpAuwBNwPAASABKALoASIDQZOAgIB4Rg0BIAFB/ABqIAIoAgA2AgAgASABKQPAATcCdCABIAEoAvgBNgKAASABIAM2AnAMAwsgAUHAAWoiAiABQZwBakEk/AoAACABIAFBzABqNgLkASACEJA7GiABKALcASEDIAIQkDshBCABQegBaiIFIAJBKPwKAAAgBRCQOxogASgChAIhAiABIAUQkDsgAmsiAjYClAIgAUGYAmpBfyACQQdqIgUgAiAFSxtBA3YQ0h8gAkEDdCIJIQIgCUE4cSIFBEAgCSAFa0FAayICIAlJDfoBC0HAACEFIAJBwAAQ0TRFDZUCIAIEQBCwPiACQcAAEK02IgVFDeEBCyABKAKgAiELIAFB3AJqIAFB6AFqQSj8CgAAIAQgA2shDEEAIQMgAUEANgKEAyABQeACaiENA0AgAUGwAmohDkICIRsgASgC+AIiCiABKAL8AkcEfyABAn4CQAJAIAEoAuACBEAgCiABKALwAk8N/AEgASgC5AIgASgC7AIgCmoiBEEDdmotAABB/wFzIARBB3F2QQFxDQELIAEgCkEBajYC+AIgAUEoaiABQdwCaiAKEK0qIAFByAJqIgQgASgCgAMgASgCKCABKAIsEPkCIAEoAsgCQZOAgIB4RwRAIAQQiBEMAgsgASgCzAIiBEUNASABIAEpAtACNwLMAiABIAQ2AsgCIAFBuAJqIAFByAJqEJkaIAEpA8ACIRsgASkDuAIMAgsgASAKQQFqNgL4AgtCAAs3A7ACIAEgASgChAMiBEEBajYChAMgAUGoAmoFIA4LIBs3AwACQAJAAkAgASkDsAIiG0ICUgRAIAMgBWohCiAbp0EBcUUNASAKIAEpA6gCNwMAIAsgBEEDdmoiCiAKLQAAQQEgBEEHcXRyOgAADAILAkAgASgC4AIiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgDRD7HgsgASADQQN1IgM2AsgCIAMgASgClAJHDZoCIAEoAqACIQMgASgCpAIhBCABIAEpApgCNwLoAiABQQA2AuQCIAEgBDYC4AIgASADNgLcAiABQSBqIAFB3AJqIgoQ1zsgASgCICELELA+QRxBBBCtNiIDRQ3wASADQoGAgIAQNwIAIAMgASkC3AI3AgggA0EQaiABQeQCaiINKQIANwIAIANBGGogAUHsAmoiDigCADYCACABIAI2AuwCIAFCgICAgIAINwLkAiABIAk2AuACIAEgBTYC3AIgAUEYaiAKENc7IAEoAhghBRCwPkEcQQQQrTYiAg0CDPABCyAKQgA3AwALIANBCGohAwwBCwsgAkKBgICAEDcCACACIAEpAtwCNwIIIAJBEGogDSkCADcCACACQRhqIA4oAgA2AgAgASAENgLAAiABIAs2ArwCIAEgAzYCuAIQsD5BDEEEEK02IgNFDe4BIAMgCTYCCCADIAU2AgQgAyACNgIAIAFBATYC0AIgASADNgLMAiABQQE2AsgCIAFBADYC8AEgAUKAgICAwAA3AugBIAFB3AJqIgJBvPP/ACAMIAEgAUG4AmogAUHIAmogAUHoAWoQjBMgAUHsAGogAhC0EwwBCyABQaACaiACKAIAIgM2AgAgASABKQPAATcDmAIgAUHcAmoiBCABKAKcAiICIAIgA0EEdGoQ9QkgAUHQAmogAUHkAmooAgA2AgAgAUHAAmoiBSABQfACaigCADYCACABIAEpAtwCNwPIAiABIAEpAugCNwO4AhCwPkEMQQQQrTYiAkUN7QEgAiABKQO4AjcCACACQQhqIAUoAgA2AgAgAUEBNgLIASABIAI2AsQBIAFBATYCwAEgAUEANgLwASABQoCAgIDAADcC6AEgBEG88/8AIAMgASABQcgCaiABQcABaiABQegBahCMEyABQewAaiAEELQTIAFBmAJqIgIQyT4gAhDtOwsgAS0AbCIDQSlHDQILIAFB4wBqIAFBgAFqKAIAIgI2AAAgAUHbAGogAUH4AGopAgAiGzcAACABIAEpAnAiHDcAUyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCC0EEQQwQoz0MAgsgAUHfAGoiBCABQfwAaikAADcAACABQdgAaiICIAFB9QBqKQAANwMAIAFBOGoiBSABQYwBaikCADcDACABQUBrIgkgAUGUAWopAgA3AwAgAUHwAWoiCiACKQMANwMAIAFB9wFqIgIgBCkAADcAACABIAEpAoQBNwMwIAEgASkAbTcD6AEgAUHlAmogCikDADcAACABQewCaiACKQAANwAAIAFB/AJqIAUpAwA3AgAgAUGEA2ogCSkDADcCACABIAM6ANwCIAEgASkD6AE3AN0CIAEgASkDMDcC9AIgBgRAIAYgBigCACICQQFqNgIAIAJBAEgNAiAHKAIEIQQLIAFB3AJqEKUMELA+QThBBBCtNiICRQ3UASACIAQ2AhAgAiAGNgIMIAJBjQY7AQggAkKBgICAEDcCACACIAEpAPMBNwAUIAIgASkDMDcCICAAQfiJgAE2AgggACACNgIEIABBk4CAgHg2AgAgAkEcaiABQfsBaigAADYAACACQShqIAFBOGopAwA3AgAgAkEwaiABQUBrKQMANwIACyABQaADaiQADAELAAsMzAELIwBBkAJrIgEkACABQSxqIgIgBSAGEIwiIgMQ2CoCQAJAAkAgBC0ANEUEQCABQaQBaiACEKcXIAFB2ABqIgIgAUGwAWooAgA2AgAgASABKQKoATcDUCABKAKkASIEQZOAgIB4Rg0BIAEoArQBIQMgACABKQNQNwIEIAAgAzYCECAAIAQ2AgAgAEEMaiACKAIANgIADAILIAFBgAFqIAFBLGpBJPwKAAAgAUGAAWoiAhCQOxogASgCnAEhBiACEJA7IQUgAUHQAGoiAyACQST8CgAAIAMQkDsaIAEoAmwhAiABIAFB0ABqEJA7IAJrIgI2AvQBIAFB+AFqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBAnQiBCEDIARBPHEiAgRAIAQgAmtBQGsiAyAESQ30AQtBwAAhByADQcAAENE0RQ2KAiADBEAQsD4gA0HAABCtNiIHRQ36AQsgASgCgAIhCyABQaQBaiABQdAAakEk/AoAACAFIAZrIQwgAUEANgLIASABQagBaiENQQAhBgNAIAFB6AFqIQkCQCABKALAASICIAEoAsQBRgRAQQIhAgwBCwJAAkAgASgCqAFFDQAgAiABKAK4AU8N9AEgASgCrAEgASgCtAEgAmoiCkEDdmotAABB/wFzIApBB3F2QQFxRQ0AIAEgAkEBajYCwAFBACEKDAELIAEgAkEBajYCwAEgAUEgaiABQaQBaiACEK0qIAFBGGogASgCICABKAIkEJAcQQIhAiABKAIYIgpBAkYNASABKAIcIQILIAEgCjYC6AEgASABKALIASIFQQFqNgLIASABQYwCaiEJCyAJIAI2AgACQAJAAkAgASgC6AEiCUECRwRAIAYgB2ohAiAJQQFxRQ0BIAIgASgCjAI2AgAgCyAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAgsCQCABKAKoASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACANEPseCyABIAZBAnUiAjYC6AEgAiABKAL0AUcNjwIgASgCgAIhAiABKAKEAiEFIAEgASkC+AE3ArABIAFBADYCrAEgASAFNgKoASABIAI2AqQBIAFBEGogAUGkAWoiBhDXOyABKAIQIQkQsD5BHEEEEK02IgJFDeoBIAJCgYCAgBA3AgAgAiABKQKkATcCCCACQRBqIAFBrAFqIgopAgA3AgAgAkEYaiABQbQBaiILKAIANgIAIAEgAzYCtAEgAUKAgICAgAg3AqwBIAEgBDYCqAEgASAHNgKkASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIM6gELIAJBADYCAAsgBkEEaiEGDAELCyADQoGAgIAQNwIAIAMgASkCpAE3AgggA0EQaiAKKQIANwIAIANBGGogCygCADYCACABIAU2AvABIAEgCTYC7AEgASACNgLoARCwPkEMQQQQrTYiAkUN6AEgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgKAAiABIAI2AvwBIAFBATYC+AEgAUEANgJYIAFCgICAgMAANwJQIAFBpAFqIgJBrPL/ACAMIAEgAUHoAWogAUH4AWogAUHQAGoiAxCMEyADIAIQuxMQsD5BOEEEEK02IgJFDdMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBuISAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYACaiACKAIANgIAIAEgASkDUDcD+AEgAUGAAWoiAiABQfgBahDoGCABQaQBaiIEIAMQkzYQ7iUgAUHQAGoiAyACIAQQzB0QsD5BOEEEEK02IgJFDdIBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBuISAATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGQAmokAAwACwzLAQsjAEGQAmsiASQAIAFBLGoiAiAFIAYQjCIiAxDYKgJAAkACQCAELQA0RQRAIAFBpAFqIAIQnBcgAUHYAGoiAiABQbABaigCADYCACABIAEpAqgBNwNQIAEoAqQBIgRBk4CAgHhGDQEgASgCtAEhAyAAIAEpA1A3AgQgACADNgIQIAAgBDYCACAAQQxqIAIoAgA2AgAMAgsgAUGAAWogAUEsakEk/AoAACABQYABaiICEJA7GiABKAKcASEGIAIQkDshBSABQdAAaiIDIAJBJPwKAAAgAxCQOxogASgCbCECIAEgAUHQAGoQkDsgAmsiAjYC9AEgAUH4AWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkECdCIEIQMgBEE8cSICBEAgBCACa0FAayIDIARJDfMBC0HAACEHIANBwAAQ0TRFDYkCIAMEQBCwPiADQcAAEK02IgdFDfkBCyABKAKAAiELIAFBpAFqIAFB0ABqQST8CgAAIAUgBmshDCABQQA2AsgBIAFBqAFqIQ1BACEGA0AgAUHoAWohCQJAIAEoAsABIgIgASgCxAFGBEBBAiECDAELAkACQCABKAKoAUUNACACIAEoArgBTw3zASABKAKsASABKAK0ASACaiIKQQN2ai0AAEH/AXMgCkEHcXZBAXFFDQAgASACQQFqNgLAAUEAIQoMAQsgASACQQFqNgLAASABQSBqIAFBpAFqIAIQrSogAUEYaiABKAIgIAEoAiQQjxxBAiECIAEoAhgiCkECRg0BIAEoAhwhAgsgASAKNgLoASABIAEoAsgBIgVBAWo2AsgBIAFBjAJqIQkLIAkgAjYCAAJAAkACQCABKALoASIJQQJHBEAgBiAHaiECIAlBAXFFDQEgAiABKAKMAjYCACALIAVBA3ZqIgIgAi0AAEEBIAVBB3F0cjoAAAwCCwJAIAEoAqgBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIA0Q+x4LIAEgBkECdSICNgLoASACIAEoAvQBRw2OAiABKAKAAiECIAEoAoQCIQUgASABKQL4ATcCsAEgAUEANgKsASABIAU2AqgBIAEgAjYCpAEgAUEQaiABQaQBaiIGENc7IAEoAhAhCRCwPkEcQQQQrTYiAkUN6QEgAkKBgICAEDcCACACIAEpAqQBNwIIIAJBEGogAUGsAWoiCikCADcCACACQRhqIAFBtAFqIgsoAgA2AgAgASADNgK0ASABQoCAgICACDcCrAEgASAENgKoASABIAc2AqQBIAFBCGogBhDXOyABKAIIIQYQsD5BHEEEEK02IgMNAgzpAQsgAkEANgIACyAGQQRqIQYMAQsLIANCgYCAgBA3AgAgAyABKQKkATcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAEgBTYC8AEgASAJNgLsASABIAI2AugBELA+QQxBBBCtNiICRQ3nASACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AoACIAEgAjYC/AEgAUEBNgL4ASABQQA2AlggAUKAgICAwAA3AlAgAUGkAWoiAkGk8/8AIAwgASABQegBaiABQfgBaiABQdAAaiIDEIwTIAMgAhCyExCwPkE4QQQQrTYiAkUN0gEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHgg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBgAJqIAIoAgA2AgAgASABKQNQNwP4ASABQYABaiICIAFB+AFqEOgYIAFBpAFqIgQgAxCTNhDuJSABQdAAaiIDIAIgBBDXHRCwPkE4QQQQrTYiAkUN0QEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHgg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMoBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDpFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDfIBC0HAACEHIAJBwAAQ0TRFDYoCIAIEQBCwPiACQcAAEK02IgdFDdkBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8N8wEgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBCOHCABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDY8CIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ3oASAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDOgBCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDeYBIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQZD0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQwhMQsD5BOEEEEK02IgJFDdEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoP7/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDCHRCwPkE4QQQQrTYiAkUN0AEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg/v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMkBCyMAQZACayIBJAAgAUEcaiICIAUgBhCMIiIDENgqAkACQAJAIAQtADRFBEAgAUGYAWogAhDeFyABQcgAaiICIAFBpAFqKAIANgIAIAEgASkCnAE3A0AgASgCmAEiBEGTgICAeEYNASABKAKoASEDIAAgASkDQDcCBCAAIAM2AhAgACAENgIAIABBDGogAigCADYCAAwCCyABQfQAaiABQRxqQST8CgAAIAFB9ABqIgIQkDsaIAEoApABIQQgAhCQOyEFIAFBQGsiAyACQST8CgAAIAMQkDsaIAEoAlwhAiABIAFBQGsQkDsgAmsiAjYC3AEgAUHgAWpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIDIQIgA0E4cSIGBEAgAyAGa0FAayICIANJDfEBC0HAACEHIAJBwAAQ0TRFDYkCIAIEQBCwPiACQcAAEK02IgdFDdgBCyABKALoASEJIAFBmAFqIAFBQGtBJPwKAAAgBSAEayEKQQAhBiABQQA2ArwBIAFBnAFqIQsDQCABQfgBaiEMQgIhGyABKAK0ASIEIAEoArgBRwR/IAECfgJAIAEoApwBBEAgBCABKAKsAU8N8gEgASgCoAEgASgCqAEgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAEgBEEBajYCtAEgAUEQaiABQZgBaiAEEK0qIAFBgAJqIAEoAhAgASgCFBDqHCABKQOIAiEbIAEpA4ACDAELIAEgBEEBajYCtAFCAAs3A/gBIAEgASgCvAEiBUEBajYCvAEgAUHwAWoFIAwLIBs3AwACQAJAAkAgASkD+AEiG0ICUgRAIAYgB2ohBCAbp0EBcUUNASAEIAEpA/ABNwMAIAkgBUEDdmoiBCAELQAAQQEgBUEHcXRyOgAADAILAkAgASgCnAEiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgCxD7HgsgASAGQQN1IgQ2AoACIAQgASgC3AFHDY4CIAEoAugBIQQgASgC7AEhBSABIAEpAuABNwKkASABQQA2AqABIAEgBTYCnAEgASAENgKYASABQQhqIAFBmAFqIgYQ1zsgASgCCCEJELA+QRxBBBCtNiIERQ3nASAEQoGAgIAQNwIAIAQgASkCmAE3AgggBEEQaiABQaABaiILKQIANwIAIARBGGogAUGoAWoiDCgCADYCACABIAI2AqgBIAFCgICAgIAINwKgASABIAM2ApwBIAEgBzYCmAEgASAGENc7IAEoAgAhBhCwPkEcQQQQrTYiAg0CDOcBCyAEQgA3AwALIAZBCGohBgwBCwsgAkKBgICAEDcCACACIAEpApgBNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgASAFNgLoASABIAk2AuQBIAEgBDYC4AEQsD5BDEEEEK02IgRFDeUBIAQgAzYCCCAEIAY2AgQgBCACNgIAIAFBATYCiAIgASAENgKEAiABQQE2AoACIAFBADYCSCABQoCAgIDAADcCQCABQZgBaiICQaj0/wAgCiABIAFB4AFqIAFBgAJqIAFBQGsiAxCMEyADIAIQqRMQsD5BOEEEEK02IgJFDdABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBiIOAATYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQYgCaiACKAIANgIAIAEgASkDQDcDgAIgAUH0AGoiAiABQYACahC9GCABQZgBaiIEIAMQkzYQ7iUgAUFAayIDIAIgBBDVHRCwPkE4QQQQrTYiAkUNzwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGIg4ABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQZACaiQADAALDMgBC0EAIQcjAEGgAmsiASQAIAFBGGogBSAGKAIQEQAAIAFBoAFqIgIgASgCGCIDIAEoAhwoAgwRAAACQAJAIANFDQAgASkDoAFCq5iR8ZX61fyAf4UgASkDqAFClpT4q/Cx6bPhAIWEUEUNACABQSRqIgUgAxDYKgJAAkACQCAELQA0RQRAIAIgBUEk/AoAACABIAI2AsQBIAFByABqIAIQ1hcgAUGAAWoiAiABQdQAaigCADYCACABIAEpAkw3A3ggASgCSCIDQZOAgIB4Rg0BIAEoAlghBCAAIAEpA3g3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAwsgAUH4AGoiAiABQSRqQST8CgAAIAEgAUGgAWo2ApwBIAIQkDsaIAEoApQBIQQgAhCQOyABQcgAaiIDIAJBKPwKAAAgAxCQOxogASgCZCECIAEgAxCQOyACayICNgLwASABQfQBakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQJ0IgMhAiADQTxxIgYEQCADIAZrQUBrIgIgA0kN8gELQcAAIQYgAkHAABDRNEUNjwIgAgRAELA+IAJBwAAQrTYiBkUN2QELIAEoAvwBIQogAUGgAWogAUHIAGpBKPwKAAAgBGshCyABQQA2AsgBIAFBpAFqIQxBACEFA0AgAUGIAmohDUECIQkgASgCvAEiBCABKALAAUcEfwJAAkAgASgCpAFFDQAgBCABKAK0AU8N8gEgASgCqAEgASgCsAEgBGoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBEEBajYCvAFBACEEDAELIAEgBEEBajYCvAEgAUEQaiABQaABaiAEEK0qIAFBjAJqIAEoAhAgASgCFBCxDCABKAKMAkGTgICAeEYiBARAIAEoApACIQkMAQsgAUGMAmoQiBELIAEgBDYCiAIgASABKALIASIHQQFqNgLIASABQYQCagUgDQsgCTYCAAJAAkACQCABKAKIAiIJQQJHBEAgBSAGaiEEIAlBAXFFDQEgBCABKAKEAjYCACAKIAdBA3ZqIgQgBC0AAEEBIAdBB3F0cjoAAAwCCwJAIAEoAqQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAwQ+x4LIAEgBUECdSIENgKMAiAEIAEoAvABRw2UAiABKAL8ASEEIAEoAoACIQUgASABKQL0ATcCrAEgAUEANgKoASABIAU2AqQBIAEgBDYCoAEgAUEIaiABQaABaiIHENc7IAEoAgghCRCwPkEcQQQQrTYiBEUN6AEgBEKBgICAEDcCACAEIAEpAqABNwIIIARBEGogAUGoAWoiCikCADcCACAEQRhqIAFBsAFqIgwoAgA2AgAgASACNgKwASABQoCAgICACDcCqAEgASADNgKkASABIAY2AqABIAEgBxDXOyABKAIAIQYQsD5BHEEEEK02IgINAgzoAQsgBEEANgIACyAFQQRqIQUMAQsLIAJCgYCAgBA3AgAgAiABKQKgATcCCCACQRBqIAopAgA3AgAgAkEYaiAMKAIANgIAIAEgBTYC/AEgASAJNgL4ASABIAQ2AvQBELA+QQxBBBCtNiIERQ3mASAEIAM2AgggBCAGNgIEIAQgAjYCACABQQE2ApQCIAEgBDYCkAIgAUEBNgKMAiABQQA2AlAgAUKAgICAwAA3AkggAUGgAWoiAkH48/8AIAsgASABQfQBaiABQYwCaiABQcgAaiIDEIwTIAMgAhCvEwwBCyABQagBaiACKAIANgIAIAEgASkDeDcDoAEgAUHIAGogAUGgAWoQ4QgLELA+QThBBBCtNiICRQ3PASACQoGAgIAQNwIAIAJBCGogAUHIAGpBMPwKAAAgAEH4jIABNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQaACaiQADAELQZCMgAEQsjsACwzHAQtBACEHQQAhCSMAQaACayIBJAAgAUEYaiAFIAYoAhARAAAgAUGgAWoiAiABKAIYIgMgASgCHCgCDBEAAAJAAkAgA0UNACABKQOgAUKrmJHxlfrV/IB/hSABKQOoAUKWlPir8LHps+EAhYRQRQ0AIAFBJGoiBSADENgqAkACQAJAIAQtADRFBEAgAiAFQST8CgAAIAEgAjYCxAEgAUHIAGogAhDfFyABQYABaiICIAFB1ABqKAIANgIAIAEgASkCTDcDeCABKAJIIgNBk4CAgHhGDQEgASgCWCEEIAAgASkDeDcCBCAAIAQ2AhAgACADNgIAIABBDGogAigCADYCAAwDCyABQfgAaiICIAFBJGpBJPwKAAAgASABQaABajYCnAEgAhCQOxogASgClAEhBCACEJA7IAFByABqIgMgAkEo/AoAACADEJA7GiABKAJkIQIgASADEJA7IAJrIgI2AvABIAFB9AFqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBA3QiAyECIANBOHEiBgRAIAMgBmtBQGsiAiADSQ3xAQtBwAAhBiACQcAAENE0RQ2OAiACBEAQsD4gAkHAABCtNiIGRQ3YAQsgASgC/AEhCyABQaABaiABQcgAakEo/AoAACAEayEMIAFBADYCyAEgAUGkAWohDUEAIQUDQCABQYgCaiEOQQIhCiABKAK8ASIEIAEoAsABRwR/IAECfwJAAkAgASgCpAEEQCAEIAEoArQBTw3zASABKAKoASABKAKwASAEaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXENAQsgASAEQQFqNgK8ASABQRBqIAFBoAFqIAQQrSogAUGMAmogASgCECABKAIUEOAHIAEoAowCQZOAgIB4RgRAIAEoApQCIQogASgCkAIhCUEBDAMLIAFBjAJqEIgRDAELIAEgBEEBajYCvAELQQALNgKIAiABIAEoAsgBIgdBAWo2AsgBIAFBhAJqBSAOCyAKNgIAAkACQAJAIAEoAogCIgpBAkcEQCAFIAZqIQQgCkEBcUUNASAEIAk2AgAgBEEEaiABKAKEAjYCACALIAdBA3ZqIgQgBC0AAEEBIAdBB3F0cjoAAAwCCwJAIAEoAqQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIA0Q+x4LIAEgBUEDdSIENgKMAiAEIAEoAvABRw2TAiABKAL8ASEEIAEoAoACIQUgASABKQL0ATcCrAEgAUEANgKoASABIAU2AqQBIAEgBDYCoAEgAUEIaiABQaABaiIHENc7IAEoAgghCRCwPkEcQQQQrTYiBEUN5wEgBEKBgICAEDcCACAEIAEpAqABNwIIIARBEGogAUGoAWoiCikCADcCACAEQRhqIAFBsAFqIgsoAgA2AgAgASACNgKwASABQoCAgICACDcCqAEgASADNgKkASABIAY2AqABIAEgBxDXOyABKAIAIQYQsD5BHEEEEK02IgINAgznAQsgBEEANgIAIARBBGpBADYCAAsgBUEIaiEFDAELCyACQoGAgIAQNwIAIAIgASkCoAE3AgggAkEQaiAKKQIANwIAIAJBGGogCygCADYCACABIAU2AvwBIAEgCTYC+AEgASAENgL0ARCwPkEMQQQQrTYiBEUN5QEgBCADNgIIIAQgBjYCBCAEIAI2AgAgAUEBNgKUAiABIAQ2ApACIAFBATYCjAIgAUEANgJQIAFCgICAgMAANwJIIAFBoAFqIgJBhPT/ACAMIAEgAUH0AWogAUGMAmogAUHIAGoiAxCMEyADIAIQrBMMAQsgAUGoAWogAigCADYCACABIAEpA3g3A6ABIAFByABqIAFBoAFqENkICxCwPkE4QQQQrTYiAkUNzgEgAkKBgICAEDcCACACQQhqIAFByABqQTD8CgAAIABB0I2AATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUGgAmokAAwBC0GQjIABELI7AAsMxgELIAAhAiMAQbACayIDJAAgA0EYaiAFIAYoAhARAAAgA0GgAWoiASADKAIYIgUgAygCHCgCDBEAAAJAAkACQAJAAkACQAJAIAVFDQAgAykDoAFCq5iR8ZX61fyAf4UgAykDqAFClpT4q/Cx6bPhAIWEUEUNACADQSRqIgYgBRDYKiAELQA0RQRAIAEgBkEk/AoAACADIAE2AsQBIANByABqIAEQ1RcgA0GAAWoiASADQdQAaigCADYCACADIAMpAkw3A3ggAygCSCIEQZOAgIB4Rg0CIAMoAlghAiAAIAMpA3g3AgQgACACNgIQIAAgBDYCACAAQQxqIAEoAgA2AgAMBQsgA0H4AGoiACADQSRqQST8CgAAIAMgA0GgAWo2ApwBIAAQkDsaIAMoApQBIQkgABCQOyEKIANByABqIgEgAEEo/AoAACABEJA7GiADKAJkIQAgAyABEJA7IABrIgA2AuQBIANB6AFqQX8gAEEHaiIBIAAgAUsbQQN2ENIfIABBBHQiBiEEAkAgBkEwcSIABEAgBiAAa0FAayIEIAZJDQELQcAAIQEgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgFFDe0BCyADKALwASELIANBoAFqIANByABqQSj8CgAAIANBADYCyAEgASEAIAMoArwBIgUgAygCwAFGDQQgA0GYAmpBBHIhDCADQaACaiEHA0ACQAJAAkACQCADKAKkAQRAIAUgAygCtAFPDfYBIAMoAqgBIAMoArABIAVqIg1BA3ZqLQAAQf8BcyANQQdxdkEBcQ0BCyADIAVBAWo2ArwBIANBEGogA0GgAWogBRCtKiADQZgCaiADKAIQIAMoAhQQ6RwCQCADKAKYAiIFRQRAIANBkAJqIAdBCGopAwA3AwAgAyAHKQMANwOIAgwBCyAFDQILIANBgAJqIANBkAJqKQMAIhs3AwAgAyADKQOIAiIcNwP4ASADIAMoAsgBIgVBAWo2AsgBIABBCGogGzcDACAAIBw3AwAgCyAFQQN2aiINIA0tAABBASAFQQdxdHI6AAAMAwsgAyAFQQFqNgK8AQwBCyAMEIgRCyADQYACaiADQZACaikDADcDACADIAMpA4gCNwP4ASADIAMoAsgBQQFqNgLIASAAQQhqQgA3AwAgAEIANwMACyAAQRBqIQAgAygCvAEiBSADKALAAUcNAAsMBAtB/Pb/AEEpIANBoAFqQfj6/wBBqPf/ABDVHgALDPEBC0GQjIABELI7AAsgA0GoAWogASgCADYCACADIAMpA3g3A6ABIANByABqIANBoAFqEM4IDAELAkAgAygCpAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GkAWoQ+x4LIAMgACABa0EEdSIANgKYAiAAIAMoAuQBRw0CIAMoAvABIQAgAygC9AEhBSADIAMpAugBNwKsASADQQA2AqgBIAMgBTYCpAEgAyAANgKgASADQQhqIANBoAFqIgcQ1zsgAygCCCELELA+QRxBBBCtNiIARQ3hASAAQoGAgIAQNwIAIAAgAykCoAE3AgggAEEQaiADQagBaiIMKQIANwIAIABBGGogA0GwAWoiDSgCADYCACADIAQ2ArABIANCgICAgIAINwKoASADIAY2AqQBIAMgATYCoAEgAyAHENc7IAMoAgAhBBCwPkEcQQQQrTYiAUUEQAziAQsgAUKBgICAEDcCACABIAMpAqABNwIIIAFBEGogDCkCADcCACABQRhqIA0oAgA2AgAgAyAFNgKQAiADIAs2AowCIAMgADYCiAIQsD5BDEEEEK02IgBFDeMBIAAgBjYCCCAAIAQ2AgQgACABNgIAIANBATYCoAIgAyAANgKcAiADQQE2ApgCIANBADYCUCADQoCAgIDAADcCSCADQaABaiIAQdDy/wAgCiAJayADIANBiAJqIANBmAJqIANByABqIgEQjBMgASAAEL4TCxCwPkE4QQQQrTYiAEUNzQEgAEKBgICAEDcCACAAQQhqIANByABqQTD8CgAAIAJBoIyAATYCCCACIAA2AgQgAkGTgICAeDYCAAsgA0GwAmokAAwBCyADQgA3AqwBIANCgYCAgMAANwKkASADQZTy/wA2AqABQQAgA0GYAmogA0HkAWogA0GgAWpBnPL/ABCvKwALDMUBCyAMQQJrQQhJDaQBDK0BCyAMQQNrDhAODxAREhMUFRYXrQG6AboBugG6Aa8BugELIAxBAmsOERe5ARgZGhscHR4fIKwBuQG5AbkBuQGuAbkBCyAMQQJrDhEgIbgBIiMkJSYnKCmrASosK7gBrQG4AQsgDEECaw4RLi8wtwExMjM0NTY3qgE6OLcBOawBtwELIAxBAmsOETw9Pj+2AUBBQkNERakBtgG2AbYBtgGrAbYBCyAMQQJrDhFFRkdISbUBSktMTU6oAbUBtQG1AbUBqgG1AQsgDEECaw4RTk9QUVJTtAFUVVZXpwG0AbQBtAG0AakBtAELIAxBAmsOEVdYWVpbXF2zAV5fYKYBswGzAbMBswGoAbMBCyAMQQJrDhFgYWJjZGVmZ7IBaGmlAbIBsgGyAbIBpwGyAQsgDEECaw4RaWprbG1ub3BxsQFypAGxAbEBsQGxAaYBsQELIAxBAmsOEXJzdHV2d3h5enuwAaMBsAGwAbABsAGlAbABCwJAIAxBDWsOBqMBsAF9sAGwAaUBAAsgDEEEaw4Ce32vAQsCQCAMQQ1rDgaiAX+vAa8BrwGkAQALIAxBBGsOAn99rgELIAxBDWsOBqABrQGtAX+AAaIBngELIAxBDWsOBp8BrAGsAYkBigGhAYgBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRDQBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghENEDELA+QThBBBCtNiICRQ28ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ27ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMtAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshENgFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ4gMQsD5BOEEEEK02IgJFDbsBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDboBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyzAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQ3QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDhAxCwPkE4QQQQrTYiAkUNugEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNuQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDLIBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRD7BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchEPQDELA+QThBBBCtNiICRQ25ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ24ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMsQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPAhEPEFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8CEQ7gMQsD5BOEEEEK02IgJFDbgBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbcBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwywAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQ7QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRDtAxCwPkE4QQQQrTYiAkUNtwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNtgEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDK8BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRD1BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhEOsDELA+QThBBBCtNiICRQ22ASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ21ASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMrgELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPQhEMYHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9CEQwAUQsD5BOEEEEK02IgJFDbUBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbQBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwytAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQxwUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDIAxCwPkE4QQQQrTYiAkUNtAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGg5v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNswEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKwBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhDMBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiEMYDELA+QThBBBCtNiICRQ2zASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQaDm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2yASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBoOb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMqwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEJIIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQvQUQsD5BOEEEEK02IgJFDbIBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDbEBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyqAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQ0wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRDNAxCwPkE4QQQQrTYiAkUNsQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNsAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKkBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRDVBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhEMsDELA+QThBBBCtNiICRQ2wASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2vASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMqAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJUIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQvwUQsD5BOEEEEK02IgJFDa8BIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDa4BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwynAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQ4wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRDdAxCwPkE4QQQQrTYiAkUNrgEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNrQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKYBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRDcBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhENMDELA+QThBBBCtNiICRQ2tASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2sASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMpQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEOoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ1AMQsD5BOEEEEK02IgJFDawBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDasBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwykAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqgcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCvBRCwPkE4QQQQrTYiAkUNqwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNqgEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKMBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRC0BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEMADELA+QThBBBCtNiICRQ2qASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfjm/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2pASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMogELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEMYFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQvgMQsD5BOEEEEK02IgJFDakBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB+Ob/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDagBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEH45v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyhAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8iEQmAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDyIRC5BRCwPkE4QQQQrTYiAkUNqAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNpwEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDKABCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRCCCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghEJsFELA+QThBBBCtNiICRQ2nASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2mASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMnwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhENcFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQzAMQsD5BOEEEEK02IgJFDaYBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDaUBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyeAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQlwggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRC3BRCwPkE4QQQQrTYiAkUNpQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNpAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJ0BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRCHCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJoFELA+QThBBBCtNiICRQ2kASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2jASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMnAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEO8FIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQ2wMQsD5BOEEEEK02IgJFDaMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDaIBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwybAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQ5wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRDWAxCwPkE4QQQQrTYiAkUNogEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNoQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJoBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCsByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEKoFELA+QThBBBCtNiICRQ2hASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2gASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMmQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEMkFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQwQMQsD5BOEEEEK02IgJFDaABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZ8BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyYAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQxAUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhC7AxCwPkE4QQQQrTYiAkUNnwEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNngEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZDS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJcBCyMAQTBrIgEkACABIAUgBhD/IRDvJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwycAQsMlgELIAktAAEOAgECjAELIAhB0ABqIAUgBkHQvP8AIAQQhgEgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADJUBCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBBgL3/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNlAEgABC7IwyUAQsjAEEwayIBJAAgASAFIAYQ/iEQ7yQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBkNL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMmQELDJMBCyMAQTBrIgEkACABIAUgBhDxIRDvJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGQ0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwyYAQsMkgELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEJMIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQuwUQsD5BOEEEEK02IgJFDZkBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZgBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyRAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQhAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRCdBRCwPkE4QQQQrTYiAkUNmAEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNlwEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDJABCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRCICCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEJwFELA+QThBBBCtNiICRQ2XASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2WASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMjwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJEIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQvAUQsD5BOEEEEK02IgJFDZYBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZUBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyOAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQhgggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCiBRCwPkE4QQQQrTYiAkUNlQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNlAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDI0BCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRCLCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhEKMFELA+QThBBBCtNiICRQ2UASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2TASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMjAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEIkGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ3wMQsD5BOEEEEK02IgJFDZMBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDZIBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyLAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqwcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCrBRCwPkE4QQQQrTYiAkUNkgEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNkQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDIoBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRDfBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEL0DELA+QThBBBCtNiICRQ2RASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQejS/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2QASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMiQELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEPkFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQxAMQsD5BOEEEEK02IgJFDZABIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDY8BIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyIAQsjAEEwayIBJAAgASAFIAYQ+iEQ7CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMjQELDIcBCyAJLQABQQJrDgIBAn0LIAhB0ABqIAUgBkGAvf8AIAQQhgEgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADIYBCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBB0Lz/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNhQEgABC7IwyFAQsjAEEwayIBJAAgASAFIAYQ5SEQ7CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB6NL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMigELDIQBCyMAQTBrIgEkACABIAUgBhDtIRDsJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHo0v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwyJAQsMgwELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEPoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQ8wMQsD5BOEEEEK02IgJFDYoBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYkBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwyCAQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQ6AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRDpAxCwPkE4QQQQrTYiAkUNiQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNiAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDIEBCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRDmBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEOwDELA+QThBBBCtNiICRQ2IASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2HASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMgAELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEPcFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQ6gMQsD5BOEEEEK02IgJFDYcBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYYBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx/CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRDuBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEOkDELA+QThBBBCtNiICRQ2GASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2FASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMfgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQ7AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRDsAxCwPkE4QQQQrTYiAkUNhQEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNhAEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDH0LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEPYFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQ6gMQsD5BOEEEEK02IgJFDYQBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYMBIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx8CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRDFByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEL4FELA+QThBBBCtNiICRQ2DASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ2CASACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMewsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQwgUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDHAxCwPkE4QQQQrTYiAkUNggEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNgQEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcjl/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHoLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEMsFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQyQMQsD5BOEEEEK02IgJFDYEBIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByOX/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDYABIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHI5f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx5CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRD0BSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhEOMDELA+QThBBBCtNiICRQ2AASACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1/IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx4CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRDkBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghENwDELA+QThBBBCtNiICRQ1/IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDX4gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHcLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshENoFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ2AMQsD5BOEEEEK02IgJFDX4gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNfSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMdgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQ6QUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDVAxCwPkE4QQQQrTYiAkUNfSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ18IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwx1CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRCQCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchELgFELA+QThBBBCtNiICRQ18IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXsgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHQLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhENsFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQ2AMQsD5BOEEEEK02IgJFDXsgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNeiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMcwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQ6wUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRDVAxCwPkE4QQQQrTYiAkUNeiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ15IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxyCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCtByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEK0FELA+QThBBBCtNiICRQ15IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDHELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hELUFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQuQMQsD5BOEEEEK02IgJFDXggAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNdyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBmOT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMcAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQwwUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhC8AxCwPkE4QQQQrTYiAkUNdyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQZjk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ12IAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGY5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxvCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRDZBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhEOQDELA+QThBBBCtNiICRQ12IAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXUgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDG4LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPghENIFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+CEQ2QMQsD5BOEEEEK02IgJFDXUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNdCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMbQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQ8AUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRDeAxCwPkE4QQQQrTYiAkUNdCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1zIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxsCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRDiBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhENIDELA+QThBBBCtNiICRQ1zIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDXIgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGsLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEJYIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQugUQsD5BOEEEEK02IgJFDXIgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNcSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMagsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQgwggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCkBRCwPkE4QQQQrTYiAkUNcSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1wIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxpCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRDlBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhENIDELA+QThBBBCtNiICRQ1wIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDW8gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGgLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPQhEKkHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9CEQrgUQsD5BOEEEEK02IgJFDW8gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNbiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMZwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7yEQyAUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDvIRDDAxCwPkE4QQQQrTYiAkUNbiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1tIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHQ5/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxmCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhDFBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiELoDELA+QThBBBCtNiICRQ1tIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB0Of/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWwgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQdDn/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGULIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEIQGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQ5QMQsD5BOEEEEK02IgJFDWwgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNayACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMZAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQgQYgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRDXAxCwPkE4QQQQrTYiAkUNayACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1qIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxjCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRCFBiABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEM4DELA+QThBBBCtNiICRQ1qIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWkgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDGILIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEIgGIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQ4AMQsD5BOEEEEK02IgJFDWkgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNaCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMYQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQlAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRC2BRCwPkE4QQQQrTYiAkUNaCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1nIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxgCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRCJCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJ4FELA+QThBBBCtNiICRQ1nIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWYgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDF8LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEIEIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQnwUQsD5BOEEEEK02IgJFDWYgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNZSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMXgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQqAcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCsBRCwPkE4QQQQrTYiAkUNZSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1kIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxdCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDvIRDgBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEO8hEL8DELA+QThBBBCtNiICRQ1kIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWMgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQfDk/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFwLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEIIiEPgFIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQgiIQwgMQsD5BOEEEEK02IgJFDWMgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHw5P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNYiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB8OT/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMWwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8iEQmQQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDyIRD2AhCwPkE4QQQQrTYiAkUNYiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1hIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxaCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD4IRCYBCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPghEPQCELA+QThBBBCtNiICRQ1hIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDWAgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFkLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPshEJMEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+yEQ8QIQsD5BOEEEEK02IgJFDWAgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNXyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMWAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8yEQlAQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDzIRDwAhCwPkE4QQQQrTYiAkUNXyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1eIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxXCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD3IRCHBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPchEIUDELA+QThBBBCtNiICRQ1eIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDV0gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFYLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPAhEMEEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8CEQhAMQsD5BOEEEEK02IgJFDV0gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNXCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMVQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9SEQvAQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD1IRCBAxCwPkE4QQQQrTYiAkUNXCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1bIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxUCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDsIRC9BCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEOwhEIADELA+QThBBBCtNiICRQ1bIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVogAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFMLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEJoEIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQ9QIQsD5BOEEEEK02IgJFDVogAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNWSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABB6OL/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMUgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQgiIQlQQgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhCCIhDvAhCwPkE4QQQQrTYiAkUNWSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQeji/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1YIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHo4v8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxRCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDyIRCMCCABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPIhELEFELA+QThBBBCtNiICRQ1YIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVcgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDFALIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPghEPMHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ+CEQjQUQsD5BOEEEEK02IgJFDVcgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNViACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMTwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+yEQhQggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD7IRCgBRCwPkE4QQQQrTYiAkUNViACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1VIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxOCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDzIRD5ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPMhEJgFELA+QThBBBCtNiICRQ1VIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVQgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDE0LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPchEI8IIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9yEQsAUQsD5BOEEEEK02IgJFDVQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNUyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMTAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ8CEQ9QcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDwIRCSBRCwPkE4QQQQrTYiAkUNUyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1SIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxLCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD1IRD/ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPUhEKEFELA+QThBBBCtNiICRQ1SIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDVEgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEoLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEOwhEPcHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7CEQlQUQsD5BOEEEEK02IgJFDVEgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNUCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMSQsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9CEQ1gUgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD0IRCRAxCwPkE4QQQQrTYiAkUNUCACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1PIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEHA4/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxICyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhCCIhD0ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEIIiEJcFELA+QThBBBCtNiICRQ1PIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBwOP/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDU4gAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQcDj/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEcLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPIhEI0IIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8iEQswUQsD5BOEEEEK02IgJFDU4gAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNTSACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMRgsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ+CEQ+AcgAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD4IRCPBRCwPkE4QQQQrTYiAkUNTSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1MIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxFCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD7IRD8ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPshEI4FELA+QThBBBCtNiICRQ1MIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUsgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEQLIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPMhEIoIIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ8yEQpgUQsD5BOEEEEK02IgJFDUsgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNSiACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMQwsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ9yEQjgggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhD3IRCyBRCwPkE4QQQQrTYiAkUNSiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1JIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACwxCCyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhDwIRD7ByABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPAhEJMFELA+QThBBBCtNiICRQ1JIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDEELIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEPUhEPYHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ9SEQkQUQsD5BOEEEEK02IgJFDUggAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNRyACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMQAsjAEHgAGsiASQAAkACQAJAIAQtADRFBEAgAUEYaiAFIAYQ7CEQgAggAS0AGCIDQSlHDQEgAUETaiABQSxqKAIAIgI2AAAgAUELaiABQSRqKQIAIhs3AAAgASABKQIcIhw3AAMgAEEQaiACNgAAIABBCGogGzcAACAAIBw3AAAMAgsgAUEYaiIDIAUgBhDsIRClBRCwPkE4QQQQrTYiAkUNRyACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUEPaiIEIAFBKGopAAA3AAAgAUEIaiIFIAFBIWopAAA3AwAgAUHQAGoiBiABQThqKQIANwMAIAFB2ABqIgcgAUFAaykCADcDACABIAEpABk3AwAgASABKQIwNwNIELA+QThBBBCtNiICRQ1GIAIgAzoACCACQoGAgIAQNwIAIAIgASkDADcACSACIAEpA0g3AiAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAJBEWogBSkDADcAACACQRhqIAQpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogBykDADcCAAsgAUHgAGokAAwACww/CyMAQeAAayIBJAACQAJAAkAgBC0ANEUEQCABQRhqIAUgBhD0IRCIBSABLQAYIgNBKUcNASABQRNqIAFBLGooAgAiAjYAACABQQtqIAFBJGopAgAiGzcAACABIAEpAhwiHDcAAyAAQRBqIAI2AAAgAEEIaiAbNwAAIAAgHDcAAAwCCyABQRhqIgMgBSAGEPQhEIYDELA+QThBBBCtNiICRQ1GIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCAAwBCyABQQ9qIgQgAUEoaikAADcAACABQQhqIgUgAUEhaikAADcDACABQdAAaiIGIAFBOGopAgA3AwAgAUHYAGoiByABQUBrKQIANwMAIAEgASkAGTcDACABIAEpAjA3A0gQsD5BOEEEEK02IgJFDUUgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMANwAJIAIgASkDSDcCICAAQajo/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAFKQMANwAAIAJBGGogBCkAADcAACACQShqIAYpAwA3AgAgAkEwaiAHKQMANwIACyABQeAAaiQADAALDD4LIwBB4ABrIgEkAAJAAkACQCAELQA0RQRAIAFBGGogBSAGEO8hEPoHIAEtABgiA0EpRw0BIAFBE2ogAUEsaigCACICNgAAIAFBC2ogAUEkaikCACIbNwAAIAEgASkCHCIcNwADIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAILIAFBGGoiAyAFIAYQ7yEQkAUQsD5BOEEEEK02IgJFDUUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGo6P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFBD2oiBCABQShqKQAANwAAIAFBCGoiBSABQSFqKQAANwMAIAFB0ABqIgYgAUE4aikCADcDACABQdgAaiIHIAFBQGspAgA3AwAgASABKQAZNwMAIAEgASkCMDcDSBCwPkE4QQQQrTYiAkUNRCACIAM6AAggAkKBgICAEDcCACACIAEpAwA3AAkgAiABKQNINwIgIABBqOj/ADYCCCAAIAI2AgQgAEGTgICAeDYCACACQRFqIAUpAwA3AAAgAkEYaiAEKQAANwAAIAJBKGogBikDADcCACACQTBqIAcpAwA3AgALIAFB4ABqJAAMAAsMPQsjAEEwayIBJAAgASAFIAYQ+yEQ9CQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABByNX/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMQgsMPAsgBSAGEPohIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhD2GiACIAQQ6BggCEHQAGoiBCACIAMQ0h0gAUFAayQAIAQQ3CkhASAAQcjV/wA2AgggACABNgIEIABBk4CAgHg2AgAMOwsgCEHQAGogBSAGQYC9/wAgBBCGASAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMOwsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AQdDi/wAgBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDTogABC7Iww6CyMAQTBrIgEkACABIAUgBhDzIRDtJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHw1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCww/Cww5CyAFIAYQ/yEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOkaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAIQdAAaiAFIAZB0OL/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAw4CyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wBB3OL/ACAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNNyAAELsjDDcLIAMtAAEOAgECLQsgAy0AAQ4CAgMsCyAJLQABQQFHDSsgBSAGEPEhIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEI8vIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhD1GiACIAQQ6BggCEHQAGoiBCACIAMQzB0gAUFAayQAIAQQ3CkhASAAQZjU/wA2AgggACABNgIEIABBk4CAgHg2AgAMNAsgCS0AAQ0qIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ7xogAiAEEOgYIAhB0ABqIgQgAiADENcdIAFBQGskACAEENwpIQEgAEHQ1/8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAktAAFBAmsOAgECKQsgCS0AAUECaw4CAgMoCyAFIAYQ5SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOcaIAIgBBDoGCAIQdAAaiIEIAIgAxDMHSABQUBrJAAgBBDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwwCyAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEO4aIAIgBBDoGCAIQdAAaiIEIAIgAxDMHSABQUBrJAAgBBDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwvCyAFIAYQ5SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEPAaIAIgBBDoGCAIQdAAaiIEIAIgAxDXHSABQUBrJAAgBBDcKSEBIABB0Nf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwuCyAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOcaIAIgBBDoGCAIQdAAaiIEIAIgAxDXHSABQUBrJAAgBBDcKSEBIABB0Nf/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwtCyAMQQVHDSMgAy0AAUECaw4CAgMjCyADLQABQQJrDgIDBCILIAMtAAFBAmsOAggJIQsjAEEwayIBJAAgASAFIAYQ8yEQ7iQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBoNb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMLwsMKQsjAEEwayIBJAAgASAFIAYQ8yEQ8SQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABB+Nb/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMLgsMKAsgCS0AAQ4CAQIeCyAJLQABDgICAx0LIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ6BogAiAEEL0YIAhB0ABqIgQgAiADEMIdIAFBQGskACAEENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCULIAUgBhDxISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ8hogAiAEEL0YIAhB0ABqIgQgAiADEMIdIAFBQGskACAEENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCQLIAUgBhD+ISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ5BogAiAEEL0YIAhB0ABqIgQgAiADENUdIAFBQGskACAEENwpIQEgAEH41v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIAUgBhDxISECIwBBQGoiASQAIAFBDGoiAyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiBCABQTBqIgIQ9BogAiAEEL0YIAhB0ABqIgQgAiADENUdIAFBQGskACAEENwpIQEgAEH41v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADCILIAktAAFBA0cNGCAFIAYQ7SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOYaIAIgBBC9GCAIQdAAaiIEIAIgAxDCHSABQUBrJAAgBBDcKSEBIABBoNb/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAJLQABQQJHDRcgBSAGEOUhIQIjAEFAaiIBJAAgAUEMaiIDIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIEIAFBMGoiAhDjGiACIAQQvRggCEHQAGoiBCACIAMQ1R0gAUFAayQAIAQQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIAsCQAJAAkACQAJAAkACQAJAIAxBA2sOBwECAwQFBgcACyMAQfAAayIBJAAgAUEEaiIEIAUgBhDyISICQQxqEKg+QQEQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNLiACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCYLIwBB8ABrIgEkACABQQRqIgQgBSAGEPghIgJBDGoQ2TxBAhCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0tIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMJQsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ+yEiAkEMahDbPEEEEIIRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDvHBCwPkHEAEEEEK02IgJFDSwgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwkCyMAQfAAayIBJAAgAUEEaiIEIAUgBhDzISICQQxqENg8QQgQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNKyACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCMLIwBB8ABrIgEkACABQQRqIgQgBSAGEPchIgJBDGoQqD5BARCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0qIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIgsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8CEiAkEMahDZPEECEIIRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDvHBCwPkHEAEEEEK02IgJFDSkgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEGg4f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwhCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD1ISICQQxqENs8QQQQghEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEO8cELA+QcQAQQQQrTYiAkUNKCACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQaDh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCALIwBB8ABrIgEkACABQQRqIgQgBSAGEOwhIgJBDGoQ2DxBCBCCESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ7xwQsD5BxABBBBCtNiICRQ0nIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABBoOH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMHwsgDEECa0EITw0HAkACQAJAAkACQAJAAkACQCAMQQNrDgcBAgMEBQYHAAsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8iEiAkEMahCoPkEBEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDS0gAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwlCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD4ISICQQxqENk8QQIQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNLCACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCQLIwBB8ABrIgEkACABQQRqIgQgBSAGEPshIgJBDGoQ2zxBBBCKESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ8BwQsD5BxABBBBCtNiICRQ0rIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIwsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ8yEiAkEMahDYPEEIEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDSogAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwiCyMAQfAAayIBJAAgAUEEaiIEIAUgBhD3ISICQQxqEKg+QQEQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNKSACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDCELIwBB8ABrIgEkACABQQRqIgQgBSAGEPAhIgJBDGoQ2TxBAhCKESACKAIMIgMgAygCACIFQQFqNgIAAkAgBUEATgRAIAEgAzYCTCABIAIpAhA3AlAgAUHYAGoiAyACEJI2EO4lIAFBEGoiBSAEIAFBzABqIAMQ8BwQsD5BxABBBBCtNiICRQ0oIAJCgYCAgBA3AgAgAkEIaiAFQTz8CgAAIABB+OH/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQfAAaiQADAELAAsMIAsjAEHwAGsiASQAIAFBBGoiBCAFIAYQ9SEiAkEMahDbPEEEEIoRIAIoAgwiAyADKAIAIgVBAWo2AgACQCAFQQBOBEAgASADNgJMIAEgAikCEDcCUCABQdgAaiIDIAIQkjYQ7iUgAUEQaiIFIAQgAUHMAGogAxDwHBCwPkHEAEEEEK02IgJFDScgAkKBgICAEDcCACACQQhqIAVBPPwKAAAgAEH44f8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFB8ABqJAAMAQsACwwfCyMAQfAAayIBJAAgAUEEaiIEIAUgBhDsISICQQxqENg8QQgQihEgAigCDCIDIAMoAgAiBUEBajYCAAJAIAVBAE4EQCABIAM2AkwgASACKQIQNwJQIAFB2ABqIgMgAhCSNhDuJSABQRBqIgUgBCABQcwAaiADEPAcELA+QcQAQQQQrTYiAkUNJiACQoGAgIAQNwIAIAJBCGogBUE8/AoAACAAQfjh/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHwAGokAAwBCwALDB4LIAkQsChFDQYLIAAgBSAGIAQQkQkMHAsgCRCwKEUNBAsgACAFIAYgBBCSCQwaCyAJELAoRQ0CCyAAIAUgBiAEEKcBDBgLIAxBBEcNDgJAAkAgAy0AAQ4CAAEQCyMAQTBrIgEkACABIAUgBhD7IRDyJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEGY1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwweCwwYCyMAQTBrIgEkACABIAUgBhD7IRDwJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHQ1/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwwdCwwXCyAMQQ1GDQBBACEBIAwhAgwBCwJAAkACQAJAAkAgCS0AAUEBaw4DAQIDAAsgAxCRNkUNAyAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEPYhEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDB8LIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwaCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNGSAAELsjDBkLIAMQkTZFDQIgCEHQAGohASMAQTBrIgIkACACIAUgBhDpIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwweCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMGQsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDRggABC7IwwYCyADEJE2RQ0BIAhB0ABqIQEjAEEwayICJAAgAiAFIAYQ5iEQ7CQQsD4CQEE4QQQQrTYiAwRAIANCgYCAgBA3AgAgA0EIaiACQTD8CgAAIAFB6NL/ADYCCCABIAM2AgQgAUGTgICAeDYCACACQTBqJAAMAQsMHQsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBgLIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAIKAJIIAQQhgEgCCgCkAIiASABKAIAIgFBAWs2AgAgAUEBRw0XIAAQuyMMFwsgAxCRNkUNACAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEPkhEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDBwLIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwXCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNFiAAELsjDBYLQQEhAUENIQILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA1BDWsOBgECAwQFAA4LIAkQkTYNBQwNCyAJEJE2RQRAAkACQAJAAkACQAJAAkACQAJAAkACQCACQQ1rDgYCAAEkJBkkCyADLQABQQFrDgMDBAUCCyADLQABQQFrDgMGBwgFCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIFQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBTYCAAwrCyAIIAE2AowDIAggAjYCiAMgCEGIA2oQih4hAgJAAkAgCS0AAUEDdEGg7v8AaikDACIbIAMtAAFBA3RBoO7/AGopAwAiHFUgGyAcU2tB/wFxDgIBEgALIAggHKcgG6durTcDwAMgBC0ANA0PIAhB0ABqIAIgCEHAA2oQzgUgCC0AUCIBQSlHDRAgCEGjAmogCEHkAGooAgAiATYAACAIQZsCaiAIQdwAaikCACIbNwAAIAggCCkCVCIcNwCTAiAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwVCyAIQZADaiACEIAVDBMLIAUgBhD/ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ8RogAiADEL0YIAhB0ABqIgMgAiAFENQdIAFBQGskACAAIANBqNj/ACAIKAJIIAQQhgEgAxD3JAwpCyAFIAYQ/yEhAiMAQUBqIgEkACABQQxqIgUgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgMgAUEwaiICEOkaIAIgAxC9GCAIQdAAaiIDIAIgBRDIHSABQUBrJAAgACADQYDZ/wAgCCgCSCAEEIYBIAMQ9yQMKAsgBSAGEP8hIQIjAEFAaiIBJAAgAUEMaiIFIAIQkjYQ7iUgASACQQxqEI8vIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIDIAFBMGoiAhDrGiACIAMQvRggCEHQAGoiAyACIAUQyR0gAUFAayQAIAAgA0HY2f8AIAgoAkggBBCGASADEPckDCcLIAUgBhD/ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ7RogAiADEL0YIAhB0ABqIgMgAiAFENEdIAFBQGskACAAIANBsNr/ACAIKAJIIAQQhgEgAxD3JAwmCyAFIAYQ+iEhAiMAQUBqIgEkACABQQxqIgUgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgMgAUEwaiICEOYaIAIgAxC9GCAIQdAAaiIDIAIgBRDUHSABQUBrJAAgACADQajY/wAgCCgCSCAEEIYBIAMQ9yQMJQsgCEHQAGoiASAFIAYQ+iEQ9SQgACABQYDZ/wAgCCgCSCAEEIYBIAEQ9yQMJAsgBSAGEPohIQIjAEFAaiIBJAAgAUEMaiIFIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCMCABIAFBP2o2AjggAUEkaiIDIAFBMGoiAhDjGiACIAMQvRggCEHQAGoiAyACIAUQyR0gAUFAayQAIAAgA0HY2f8AIAgoAkggBBCGASADEPckDCMLIAUgBhD6ISECIwBBQGoiASQAIAFBDGoiBSACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjAgASABQT9qNgI4IAFBJGoiAyABQTBqIgIQ6hogAiADEL0YIAhB0ABqIgMgAiAFENEdIAFBQGskACAAIANBsNr/ACAIKAJIIAQQhgEgAxD3JAwiCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIEQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwiCyAIIAE2ApQCIAggAjYCkAIgCEEQaiAIQZACahCKHiAIKAJILQABIAsgCwR/IAsgCygCACIBQQFqNgIAIAFBAEgNIyADKAIIBSADCxDwByAAIAgpAxA3AgQgAEGTgICAeDYCACAIKAKQAiIAIAAoAgAiAEEBazYCACAAQQFHDSEgCEGQAmoQuyMMIQsgAUUNCwJAAkACQAJAIAktAAFBAWsOAwECAwALIAUgBhD2ISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/QUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCWBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSogAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCMLIAUgBhDpISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/gUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCbBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSkgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCILIAUgBhDmISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQgAYMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCYBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDSggAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCELIAUgBhD5ISECIwBBkAFrIgEkACABIAIQoCoCQAJAAkACQCABKAIAIgMEQCABQdwAaiADIAEoAgQQihggASgCYCEDIAEoAlwiBEGTgICAeEYNASAAIAEpAmQ3AgggAEEQaiABQewAaigCADYCACAAIAM2AgQgACAENgIADAMLIAFB3ABqIAIQ/wUMAQsgASADNgI8IAFB3ABqIAIgAUE8aiABQY8BahCfBwsgAS0AXCIDQSlGBEAgAUHTAGogAUHwAGooAgAiAjYAACABQcsAaiABQegAaikCACIbNwAAIAEgASkCYCIcNwBDIABBEGogAjYAACAAQQhqIBs3AAAgACAcNwAADAELIAFBzwBqIgIgAUHsAGopAAA3AAAgAUHIAGoiBCABQeUAaikAADcDACABQRBqIgUgAUH8AGopAgA3AwAgAUEYaiIGIAFBhAFqKQIANwMAIAFBKGoiCSAEKQMANwMAIAFBL2oiBCACKQAANwAAIAEgASkCdDcDCCABIAEpAF03AyAQsD5BOEEEEK02IgJFDScgAiADOgAIIAJCgYCAgBA3AgAgAiABKQMgNwAJIAIgASkDCDcCICAAQcjV/wA2AgggACACNgIEIABBk4CAgHg2AgAgAkERaiAJKQMANwAAIAJBGGogBCkAADcAACACQShqIAUpAwA3AgAgAkEwaiAGKQMANwIACyABQZABaiQADAALDCALIAFFDQoCQAJAAkACQCAJLQABQQFrDgMAAQIDCyMAQTBrIgEkACABIAUgBhDpIRDtJBCwPgJAQThBBBCtNiICBEAgAkKBgICAEDcCACACQQhqIAFBMPwKAAAgAEHw1P8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFBMGokAAwBCwwoCwwiCyAFIAYQ5iEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEOYaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAFIAYQ+SEhAiMAQUBqIgEkACABQQxqIgMgAhCSNhDuJSABIAJBDGoQkC8gASABKQMANwIwIAEgAUE/ajYCOCABQSRqIgQgAUEwaiICEPMaIAIgBBC9GCAIQdAAaiIEIAIgAxDEHSABQUBrJAAgBBDcKSEBIABB8NT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwgCyAELQA0DQYgCEHQAGohByAFIAYQ9iEhBSMAQfABayIBJAAgBUEMahDYPCEGIAFBMGogBRCSNhDuJSAGQQN0IgQhAgJAAkACfgJAAkACQCAEQThxIgMEQCAEIANrQUBrIgIgBEkNawtBwAAhAyACQcAAENE0BEAgAgRAELA+IAJBwAAQrTYiA0UNMwsgASADNgJQIAEgAjYCTCABQcAANgJIIAQEQCADQQAgBPwLAAsgASAGNgJYIAEgBDYCVCABKAIwRQ0BIAEoAkQgASgCQEYNAiABQegAaiABQTBqEMg0IAFBiAFqIQIgBSgCECEEIAEpA5ABIRsDQAJAIBtQRQRAIAEpA5gBIRwMAQsDQAJ+AkAgASkDeCIcQgNSBEACQAJAAkAgHEICUQ0AIAEgHFCtQgGGNwN4IBynQQFxRQ0AIAEgASkDgAE3A8gBDAELIAEoAogBRQ0BIAFBwAFqIAIQtiogASkDwAEhHAsgHEIAUg0CCyABQgM3A3gLIAEpA2giHEICUQ0HIAFCADcDaCABKQNwDAELIAEpA8gBCyEbIBynQQFxRQ0FIAEgASkDmAFCQH0iHDcDmAEgASAbNwOQASAbUA0ACwsgAUIBIBt6Ih2GIBuFIhs3A5ABIAQgHacgHKdqQQN0IgVqKQMAIRwgAULoBzcD6AEgASAcNwOgASABQSBqIBwgHEI/h0LoB0IAEKgeIAEpAyggASkDICIcQj+HUQRAIAMgBWogHDcDAAwBCwsgAUECNgLEASABQayQ/wA2AsABIAFCAjcCzAEgAUGGDDYC5AEgAUGGDDYC3AEgASABQdgBajYCyAEgASABQegBajYC4AEgASABQaABajYC2AEgAUGwAWogAUHAAWoQmQ4gASkCuAEhGyABKQKwAQwEC0Hci/8AQSkgAUHoAGpB7I//AEGIjP8AENUeAAsgBkUNACAFKAIQIQRBACECA0AgBCkDACEbIAFC6Ac3A9gBIAEgGzcD6AEgAUEQaiAbIBtCP4dC6AdCABCoHiABKQMYIAEpAxAiG0I/h1INAiADIBs3AwAgA0EIaiEDIARBCGohBCAGIAJBAWoiAkcNAAsLIAFB6ABqIgMQlykgAUHQAGoiAigCACEGIAEoAlQhBCACIAFB8ABqIgUpAgA3AwAgASkDSCEbIAEgASkCaDcDSCABQQA2AlggASAbNwJ0IAFBADYCcCABIAQ2AmwgASAGNgJoIAFBCGogAxDXOyABKAIIIQYQsD5BHEEEEK02IgJFDTsgAkKBgICAEDcCACACIAEpAmg3AgggAkEQaiAFKQIANwIAIAJBGGogAUH4AGoiCSgCADYCACABIAQ2AsgBIAEgBjYCxAEgASACNgLAASABQdwAaiICIAFBwAFqEOQZIAkgAUFAaykCADcDACAFIAFBOGopAgA3AwAgASABKQIwNwNoIAcgAiADEMQdIAFByABqEM8vDAILIAFBAjYCbCABQayQ/wA2AmggAUICNwJ0IAFBhgw2ArgBIAFBhgw2ArABIAEgAUGsAWo2AnAgASABQdgBajYCtAEgASABQegBajYCrAEgAUHEAWogAUHoAGoQmQ4gASkCzAEhGyABKQLEAQshHCAHIBs3AhAgByAcNwIIIAdBiICAgHg2AgQgB0EpOgAAIAFByABqEM8vIAEoAjAiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEwahD7HgsgAUHwAWokAAwACyAILQBQIgFBKUYEQCAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADCALIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbACaiAIQfAAaikCADcCACAIQbgCaiAIQfgAaikCADcCACAIQZkCaiADKQMANwAAIAhBoAJqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCqAIgCCAbNwCRAiAIIAE6AJACDAcLIAFFDQkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQABDgIAASsLIAktAAFBAWsOAwIDBAELIAktAAFBAWsOAxESExALQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADDkLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ9iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDYMBC0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1LCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPERIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDIMBCyAJRQ0AIAcoAgQhCiAHKAIAIQsgBigCECEEQQAhBwNAIAFBQGsgBCkDACALIAoQ8REgASgCRCECIAEoAkAiBkGTgICAeEcNAiADIAI2AgAgA0EEaiEDIARBCGohBCAJIAdBAWoiB0cNAAsLIAFBQGsiAxCXKSABQShqIgIoAgAhByABKAIsIQQgAiABQcgAaiIGKQIANwMAIAEpAyAhGyABIAEpAkA3AyAgAUEANgIwIAEgGzcCTCABQQA2AkggASAENgJEIAEgBzYCQCABIAMQ1zsgASgCACEHELA+QRxBBBCtNiICRQ1TIAJCgYCAgBA3AgAgAiABKQJANwIIIAJBEGogBikCADcCACACQRhqIAFB0ABqIgkoAgA2AgAgASAENgKAASABIAc2AnwgASACNgJ4IAFBNGoiAiABQfgAahDlGSAJIAFBGGopAgA3AwAgBiABQRBqKQIANwMAIAEgASkCCDcDQCAFIAIgAxDMHSABQSBqEM8vDAILIAEoAkghAyABKQJMCzcCECAFIAM2AgwgBSACNgIIIAUgBjYCBCAFQSk6AAAgAUEgahDPLyABKAIIIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBCGoQ+x4LIAFBkAFqJAAMAAsgCC0AUCIBQSlGBEAgCEGjAmogCEHkAGooAgAiATYAACAIQZsCaiAIQdwAaikCACIbNwAAIAggCCkCVCIcNwCTAiAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAw4CyAIQZ8CaiICIAhB4ABqKQAANwAAIAhBmAJqIgMgCEHZAGopAAA3AwAgCEGwB2ogCEHwAGopAgA3AgAgCEG4B2ogCEH4AGopAgA3AgAgCEGZB2ogAykDADcAACAIQaAHaiACKQAANwAAIAggCCkAUSIbNwOQAiAIIAgpAmg3AqgHIAggAToAkAcgCCAbNwCRByAIQZAHahDcKSEBIABBmNT/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAIKQJUIRsgACAIKQJcNwIMIAAgGzcCBCAAIAE2AgAMNgtBASEDIAgoAlQhCQsgCCAJNgLEAyAIIAM2AsADIAUgBhDpISEGIAhBwANqIQcjAEGQAWsiASQAIAZBDGoQ2DwhCSABQQhqIAYQkjYQ7iUgCUECdCIEIQICQAJAIAhB0ABqIgUCfgJAAkACQCAEQTxxIgMEQCAEIANrQUBrIgIgBEkNgAELQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDUgLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQQgBygCBCEJIAcoAgAhByAGKAIQIQoDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogBBC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAKIB2nIBunaiILQQN0aikDACAHIAkQ8xEgASgCfCECIAEoAngiBkGTgICAeEYEQCADIAtBAnRqIAI2AgAMAQsLIAEoAoABIQMgASkChAEMBAsMgAELIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChDzESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDVAgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDULIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQZAIaiAIQfAAaikCADcCACAIQZgIaiAIQfgAaikCADcCACAIQfkHaiADKQMANwAAIAhBgAhqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCiAggCCABOgDwByAIIBs3APEHIAhB8AdqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDQLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwzC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgBSAGEOYhIQYgCEHAA2ohByMAQZABayIBJAAgBkEMahDYPCEJIAFBCGogBhCSNhDuJSAJQQJ0IgQhAgJAAkAgCEHQAGoiBQJ+AkACQAJAIARBPHEiAwRAIAQgA2tBQGsiAiAESQ19C0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1FCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPQRIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDH0LIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChD0ESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDU0gAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDILIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQfAIaiAIQfAAaikCADcCACAIQfgIaiAIQfgAaikCADcCACAIQdkIaiADKQMANwAAIAhB4AhqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcC6AggCCABOgDQCCAIIBs3ANEIIAhB0AhqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDELIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwwC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgBSAGEPkhIQYgCEHAA2ohByMAQZABayIBJAAgBkEMahDYPCEJIAFBCGogBhCSNhDuJSAJQQJ0IgQhAgJAAkAgCEHQAGoiBQJ+AkACQAJAIARBPHEiAwRAIAQgA2tBQGsiAiAESQ16C0HAACEDIAJBwAAQ0TQEQCACBEAQsD4gAkHAABCtNiIDRQ1CCyABIAM2AiggASACNgIkIAFBwAA2AiAgBARAIANBACAE/AsACyABIAk2AjAgASAENgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEEIAcoAgQhCSAHKAIAIQcgBigCECEKA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAQQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCiAdpyAbp2oiC0EDdGopAwAgByAJEPIRIAEoAnwhAiABKAJ4IgZBk4CAgHhGBEAgAyALQQJ0aiACNgIADAELCyABKAKAASEDIAEpAoQBDAQLDHoLIAlFDQAgBygCBCEKIAcoAgAhCyAGKAIQIQRBACEHA0AgAUFAayAEKQMAIAsgChDyESABKAJEIQIgASgCQCIGQZOAgIB4Rw0CIAMgAjYCACADQQRqIQMgBEEIaiEEIAkgB0EBaiIHRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUogAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADEMwdIAFBIGoQzy8MAgsgASgCSCEDIAEpAkwLNwIQIAUgAzYCDCAFIAI2AgggBSAGNgIEIAVBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADC8LIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQdAJaiAIQfAAaikCADcCACAIQdgJaiAIQfgAaikCADcCACAIQbkJaiADKQMANwAAIAhBwAlqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCyAkgCCABOgCwCSAIIBs3ALEJIAhBsAlqENwpIQEgAEGY1P8ANgIIIAAgATYCBCAAQZOAgIB4NgIADC4LQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCkLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ9iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDXMLQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTsLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8REgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMcwsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPERIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUMgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMKAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhB4AdqIAhB8ABqKQIANwIAIAhB6AdqIAhB+ABqKQIANwIAIAhByQdqIAMpAwA3AAAgCEHQB2ogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwLYByAIIAE6AMAHIAggGzcAwQcgCEHAB2oQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMJwsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCYLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ6SEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDXALQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTgLIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8xEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMcAsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPMRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJQsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBwAhqIAhB8ABqKQIANwIAIAhByAhqIAhB+ABqKQIANwIAIAhBqQhqIAMpAwA3AAAgCEGwCGogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwK4CCAIIAE6AKAIIAggGzcAoQggCEGgCGoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMJAsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCMLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ5iEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDW0LQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTULIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ9BEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMbQsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPQRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDT0gAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMIgsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBoAlqIAhB8ABqKQIANwIAIAhBqAlqIAhB+ABqKQIANwIAIAhBiQlqIAMpAwA3AAAgCEGQCWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKYCSAIIAE6AIAJIAggGzcAgQkgCEGACWoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMIQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCALQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAFIAYQ+SEhBiAIQcADaiEHIwBBkAFrIgEkACAGQQxqENg8IQkgAUEIaiAGEJI2EO4lIAlBAnQiBCECAkACQCAIQdAAaiIFAn4CQAJAAkAgBEE8cSIDBEAgBCADa0FAayICIARJDWoLQcAAIQMgAkHAABDRNARAIAIEQBCwPiACQcAAEK02IgNFDTILIAEgAzYCKCABIAI2AiQgAUHAADYCICAEBEAgA0EAIAT8CwALIAEgCTYCMCABIAQ2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBygCBCEKIAcoAgAhCyAGKAIQIQYDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiAGIB2nIBunaiIMQQN0aikDACALIAoQ8hEgASgCgAEhAiABKAJ8IQQgASgCeCIHQZOAgIB4RgRAIAMgDEECdGogBEHoB2wgAkHAhD1uajYCAAwBCwsgASkChAEMBAsMagsgCUUNACAHKAIEIQsgBygCACEMIAYoAhAhBkEAIQoDQCABQUBrIAYpAwAgDCALEPIRIAEoAkghAiABKAJEIQQgASgCQCIHQZOAgIB4Rw0CIAMgBEHoB2wgAkHAhD1uajYCACADQQRqIQMgBkEIaiEGIAkgCkEBaiIKRw0ACwsgAUFAayIDEJcpIAFBKGoiAigCACEHIAEoAiwhBCACIAFByABqIgYpAgA3AwAgASkDICEbIAEgASkCQDcDICABQQA2AjAgASAbNwJMIAFBADYCSCABIAQ2AkQgASAHNgJAIAEgAxDXOyABKAIAIQcQsD5BHEEEEK02IgJFDTogAkKBgICAEDcCACACIAEpAkA3AgggAkEQaiAGKQIANwIAIAJBGGogAUHQAGoiCSgCADYCACABIAQ2AoABIAEgBzYCfCABIAI2AnggAUE0aiICIAFB+ABqEOUZIAkgAUEYaikCADcDACAGIAFBEGopAgA3AwAgASABKQIINwNAIAUgAiADENcdIAFBIGoQzy8MAgsgASkCTAs3AhAgBSACNgIMIAUgBDYCCCAFIAc2AgQgBUEpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMHwsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBgApqIAhB8ABqKQIANwIAIAhBiApqIAhB+ABqKQIANwIAIAhB6QlqIAMpAwA3AAAgCEHwCWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwL4CSAIIAE6AOAJIAggGzcA4QkgCEHgCWoQ3CkhASAAQdDX/wA2AgggACABNgIEIABBk4CAgHg2AgAMHgsgAUUNCAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAAFBAmsOAgABKgsgCS0AAUEBaw4DAgMEAQsgCS0AAUEBaw4DERITEAtBACEDIAkoAgQiAUUNBSAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBAUDC0EAIQMgCSgCBCIBRQ0HIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIGBwULQQAhAyAJKAIEIgFFDQkgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAggJBwtBACEDIAkoAgQiAUUNCyAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CCgsJCyAIKQJUIRsgACAIKQJcNwIMIAAgGzcCBCAAIAE2AgAMOAtBASEDIAgoAlQhCQsgCCAJNgLEAyAIIAM2AsADIAhB0ABqIQcgBSAGEPYhIQUgCEHAA2ohBiMAQZABayIBJAAgBUEMahDYPCEJIAFBCGogBRCSNhDuJSAJQQN0IgMhBAJAAkACfgJAAkACQCADQThxIgIEQCADIAJrQUBrIgQgA0kNggELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDVwLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8REgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA0HoB26tIAStQsCEPX58NwMADAELCyABKQKEASEcIAStIAOtQiCGhAwECwyCAQsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPERIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNUiACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDcLIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQbAEaiAIQfAAaikCADcCACAIQbgEaiAIQfgAaikCADcCACAIQZkEaiADKQMANwAAIAhBoARqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCqAQgCCABOgCQBCAIIBs3AJEEIAhBkARqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDYLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAw1C0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ6SEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ1/C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1ZCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPMRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMfwsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPMRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNTyACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDQLIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQZAFaiAIQfAAaikCADcCACAIQZgFaiAIQfgAaikCADcCACAIQfkEaiADKQMANwAAIAhBgAVqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCiAUgCCABOgDwBCAIIBs3APEEIAhB8ARqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwyC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ5iEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ18C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1WCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPQRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMfAsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPQRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNTCACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADDELIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQfAFaiAIQfAAaikCADcCACAIQfgFaiAIQfgAaikCADcCACAIQdkFaiADKQMANwAAIAhB4AVqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcC6AUgCCABOgDQBSAIIBs3ANEFIAhB0AVqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADDALIAgpAlQhGyAAIAgpAlw3AgwgACAbNwIEIAAgATYCAAwvC0EBIQMgCCgCVCEJCyAIIAk2AsQDIAggAzYCwAMgCEHQAGohByAFIAYQ+SEhBSAIQcADaiEGIwBBkAFrIgEkACAFQQxqENg8IQkgAUEIaiAFEJI2EO4lIAlBA3QiAyEEAkACQAJ+AkACQAJAIANBOHEiAgRAIAMgAmtBQGsiBCADSQ15C0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ1TCyABIAI2AiggASAENgIkIAFBwAA2AiAgAwRAIAJBACAD/AsACyABIAk2AjAgASADNgIsIAEoAghFDQEgASgCHCABKAIYRg0CIAFBQGsgAUEIahDINCABQeAAaiEJIAYoAgQhCiAGKAIAIQYgBSgCECELA0ACQCABKQNoIhxQRQRAIAEpA3AhGwwBCwNAAn4CQCABKQNQIhtCA1IEQAJAAkACQCAbQgJRDQAgASAbUK1CAYY3A1AgG6dBAXFFDQAgASABKQNYNwOAAQwBCyABKAJgRQ0BIAFB+ABqIAkQtiogASkDeCEbCyAbQgBSDQILIAFCAzcDUAsgASkDQCIbQgJRDQcgAUIANwNAIAEpA0gMAQsgASkDgAELIRwgG6dBAXFFDQUgASABKQNwQkB9Ihs3A3AgASAcNwNoIBxQDQALCyABIBxCASAceiIdhoU3A2ggAUH4AGogCyAdpyAbp2pBA3QiDGopAwAgBiAKEPIRIAEoAoABIQMgASgCfCEEIAEoAngiBUGTgICAeEYEQCACIAxqIANB6AdurSAErULAhD1+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMeQsgCUUNACAGKAIEIQsgBigCACEMIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgDCALEPIRIAEoAkghBiABKAJEIQogASgCQCIFQZOAgIB4Rw0CIAIgBkHoB26tIAqtQsCEPX58NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNSSACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQwh0gAUEgahDPLwwCCyABKQJMIRwgCq0gBq1CIIaECyEbIAcgHDcCECAHIBs3AgggByAFNgIEIAdBKToAACABQSBqEM8vIAEoAggiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEIahD7HgsgAUGQAWokAAwACyAILQBQIgFBKUYEQCAIQaMCaiAIQeQAaigCACIBNgAAIAhBmwJqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AJMCIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADC4LIAhBnwJqIgIgCEHgAGopAAA3AAAgCEGYAmoiAyAIQdkAaikAADcDACAIQdAGaiAIQfAAaikCADcCACAIQdgGaiAIQfgAaikCADcCACAIQbkGaiADKQMANwAAIAhBwAZqIAIpAAA3AAAgCCAIKQBRIhs3A5ACIAggCCkCaDcCyAYgCCABOgCwBiAIIBs3ALEGIAhBsAZqENwpIQEgAEGg1v8ANgIIIAAgATYCBCAAQZOAgIB4NgIADC0LQQAhAyAJKAIEIgFFDQUgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgQFAwtBACEDIAkoAgQiAUUNByAIQdAAaiABQQhqIAkoAggQihggCCgCUCIBQe3///8Hag4CBgcFC0EAIQMgCSgCBCIBRQ0JIAhB0ABqIAFBCGogCSgCCBCKGCAIKAJQIgFB7f///wdqDgIICQcLQQAhAyAJKAIEIgFFDQsgCEHQAGogAUEIaiAJKAIIEIoYIAgoAlAiAUHt////B2oOAgoLCQsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCgLQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhD2ISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDXILQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUwLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8REgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMcgsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPERIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNQiACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJwsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhB4ARqIAhB8ABqKQIANwIAIAhB6ARqIAhB+ABqKQIANwIAIAhByQRqIAMpAwA3AAAgCEHQBGogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwLYBCAIIAE6AMAEIAggGzcAwQQgCEHABGoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMJgsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCULQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhDpISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDW8LQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUkLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8xEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMbwsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPMRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNPyACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMJAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBwAVqIAhB8ABqKQIANwIAIAhByAVqIAhB+ABqKQIANwIAIAhBqQVqIAMpAwA3AAAgCEGwBWogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwK4BSAIIAE6AKAFIAggGzcAoQUgCEGgBWoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIwsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADCILQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhDmISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDWwLQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUYLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ9BEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMbAsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPQRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNPCACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMIQsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBoAZqIAhB8ABqKQIANwIAIAhBqAZqIAhB+ABqKQIANwIAIAhBiQZqIAMpAwA3AAAgCEGQBmogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKYBiAIIAE6AIAGIAggGzcAgQYgCEGABmoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMIAsgCCkCVCEbIAAgCCkCXDcCDCAAIBs3AgQgACABNgIADB8LQQEhAyAIKAJUIQkLIAggCTYCxAMgCCADNgLAAyAIQdAAaiEHIAUgBhD5ISEFIAhBwANqIQYjAEGQAWsiASQAIAVBDGoQ2DwhCSABQQhqIAUQkjYQ7iUgCUEDdCIDIQQCQAJAAn4CQAJAAkAgA0E4cSICBEAgAyACa0FAayIEIANJDWkLQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDUMLIAEgAjYCKCABIAQ2AiQgAUHAADYCICADBEAgAkEAIAP8CwALIAEgCTYCMCABIAM2AiwgASgCCEUNASABKAIcIAEoAhhGDQIgAUFAayABQQhqEMg0IAFB4ABqIQkgBigCBCEKIAYoAgAhBiAFKAIQIQsDQAJAIAEpA2giHFBFBEAgASkDcCEbDAELA0ACfgJAIAEpA1AiG0IDUgRAAkACQAJAIBtCAlENACABIBtQrUIBhjcDUCAbp0EBcUUNACABIAEpA1g3A4ABDAELIAEoAmBFDQEgAUH4AGogCRC2KiABKQN4IRsLIBtCAFINAgsgAUIDNwNQCyABKQNAIhtCAlENByABQgA3A0AgASkDSAwBCyABKQOAAQshHCAbp0EBcUUNBSABIAEpA3BCQH0iGzcDcCABIBw3A2ggHFANAAsLIAEgHEIBIBx6Ih2GhTcDaCABQfgAaiALIB2nIBunakEDdCIMaikDACAGIAoQ8hEgASgCgAEhAyABKAJ8IQQgASgCeCIFQZOAgIB4RgRAIAIgDGogA60gBK1CgJTr3AN+fDcDAAwBCwsgASkChAEhHCAErSADrUIghoQMBAsMaQsgCUUNACAGKAIEIQogBigCACELIAUoAhAhA0EAIQQDQCABQUBrIAMpAwAgCyAKEPIRIAE1AkghGyABKAJEIQYgASgCQCIFQZOAgIB4Rw0CIAIgBq1CgJTr3AN+IBt8NwMAIAJBCGohAiADQQhqIQMgCSAEQQFqIgRHDQALCyABQUBrIgMQlykgAUEoaiICKAIAIQYgASgCLCEEIAIgAUHIAGoiBSkCADcDACABKQMgIRsgASABKQJANwMgIAFBADYCMCABIBs3AkwgAUEANgJIIAEgBDYCRCABIAY2AkAgASADENc7IAEoAgAhBhCwPkEcQQQQrTYiAkUNOSACQoGAgIAQNwIAIAIgASkCQDcCCCACQRBqIAUpAgA3AgAgAkEYaiABQdAAaiIJKAIANgIAIAEgBDYCgAEgASAGNgJ8IAEgAjYCeCABQTRqIgIgAUH4AGoQ5BkgCSABQRhqKQIANwMAIAUgAUEQaikCADcDACABIAEpAgg3A0AgByACIAMQ1R0gAUEgahDPLwwCCyABKQJMIRwgBq0gG0IghoQLIRsgByAcNwIQIAcgGzcCCCAHIAU2AgQgB0EpOgAAIAFBIGoQzy8gASgCCCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACABQQhqEPseCyABQZABaiQADAALIAgtAFAiAUEpRgRAIAhBowJqIAhB5ABqKAIAIgE2AAAgCEGbAmogCEHcAGopAgAiGzcAACAIIAgpAlQiHDcAkwIgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMHgsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIDIAhB2QBqKQAANwMAIAhBgAdqIAhB8ABqKQIANwIAIAhBiAdqIAhB+ABqKQIANwIAIAhB6QZqIAMpAwA3AAAgCEHwBmogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwL4BiAIIAE6AOAGIAggGzcA4QYgCEHgBmoQ3CkhASAAQfjW/wA2AgggACABNgIEIABBk4CAgHg2AgAMHQsgCEHQAGogBSAGQdC8/wAgBBCGASAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMHQsgCCABNgKUAiAIIAI2ApACIAhBIGogCEGQAmoiARCKHiAIKAJILQABEMERIAAgCCkDIDcCBCAAQZOAgIB4NgIAIAgoApACIgAgACgCACIAQQFrNgIAIABBAUcNHCABELsjDBwLIAhBkANqIAIgCEHAA2oQrQMMBAsgCEGfAmoiAiAIQeAAaikAADcAACAIQZgCaiIFIAhB2QBqKQAANwMAIAhBsANqIAhB8ABqKQIANwIAIAhBuANqIAhB+ABqKQIANwIAIAhBmQNqIAUpAwA3AAAgCEGgA2ogAikAADcAACAIIAgpAFEiGzcDkAIgCCAIKQJoNwKoAyAIIBs3AJEDIAggAToAkAMMAwsgCCAbpyAcp26tNwNQIwBBQGoiASQAIAEgCEHQAGo2AgwgAUEQaiIFIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCNCABIAFBDGo2AjwgAUEoaiIGIAFBNGoiAhDlGiACIAYQvRggCEGQA2ogAiAFENYdIAFBQGskAAwCCyAIQZACaiENIAUgBhD2ISEHQQAhCUEAIQpBACELQQAhDCMAQeABayIDJAAgB0EMahDYPCEBAkACQAJAAkAgBxCSNiIEBEBBwAAhBSADQUBrIAQQ3DsgBCgCFCECIAQoAgwhCSADKAJEIQsgAygCQCEKIAFBA3YgAUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0DIAQEQBCwPiAEQcAAEK02IgVFDTwLIANCADcCWCADIAU2AlQgAyAENgJQIANBwAA2AkwgA0HMAGogCSABIAlqIAogCxC/GAwBC0HAACEFIAFBA3YgAUEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0CIAIEQBCwPiACQcAAEK02IgVFDSkLIANCADcCWCADIAU2AlQgAyACNgJQIANBwAA2AkwgA0HMAGogARDeEEEAIQILIAFBA3QiBSEEAkAgBUE4cSIGBEAgBSAGa0FAayIEIAVJDQELQcAAIQYgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgZFDTwLIANBADYCcCADIAY2AmggAyAENgJkIANBwAA2AmAgBQRAIAUEQCAGQQAgBfwLAAsgAygCcCEMIAMoAmghBgsgAyAFNgJsIAMgASAMajYCcAJAAkAgAgRAIAEgAkcNASABIQIMBQsgAUUEQEEAIQIMBQsgBygCECEFQQAhAkEAIQQDQCADQRBqIAUpAwAiGyAbQj+HQugHQgAQqB4CQCADKQMYIAMpAxAiG0I/h1EEQCAGIBs3AwAMAQsgA0EIaiADQcwAahCGPSAEQQN2IgcgAygCDCIJTw0DIAMoAgggB2oiByAHLQAAQX4gBEEHcXdxOgAAIAJBAWohAgsgBkEIaiEGIAVBCGohBSABIARBAWoiBEcNAAsMBAsgCgRAIANBmAFqIAogCyAJIAEQvxQgA0G4AWohBSAHKAIQIQcDQAJAIAMpA8ABIhxQRQRAIAMpA8gBIRsMAQsDQAJ+AkAgAykDqAEiG0IDUgRAAkACQAJAIBtCAlENACADIBtQrUIBhjcDqAEgG6dBAXFFDQAgAyADKQOwATcD2AEMAQsgAygCuAFFDQEgA0HQAWogBRC2KiADKQPQASEbCyAbQgBSDQILIANCAzcDqAELIAMpA5gBIhtCAlENCSADQgA3A5gBIAMpA6ABDAELIAMpA9gBCyEcIBunQQFxRQ0HIAMgAykDyAFCQH0iGzcDyAEgAyAcNwPAASAcUA0ACwsgAyAcQgEgHHoiHYaFNwPAASADQTBqIAcgHacgG6dqIgFBA3QiBGopAwAiGyAbQj+HQugHQgAQqB4gAykDOCADKQMwIhtCP4dRBEAgBCAGaiAbNwMADAELIANBKGogA0HMAGoQhj0gAUEDdiIEIAMoAiwiCUkEQCADKAIoIARqIgQgBC0AAEF+IAFBB3F3cToAACACQQFqIQIMAQsLIAQgCUGIi/8AEMMhAAtBxIr/ABCyOwALIAcgCUGIi/8AEMMhAAsMAgsMYAsgA0H4AGogA0HMAGoiBxCCFCADQZgBaiIEEJcpIANB6ABqIgEoAgAhCSADKAJsIQUgASADQaABaiIGKQIANwMAIAMpA2AhGyADIAMpApgBNwNgIANBADYCcCADIBs3AqQBIANBADYCoAEgAyAFNgKcASADIAk2ApgBIAMgBBDXOyADKAIAIQkQsD5BHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCmAE3AgggAUEQaiAGKQIANwIAIAFBGGogA0GoAWoiCigCADYCACADIAU2AtgBIAMgCTYC1AEgAyABNgLQASADQYwBaiIBIANB0AFqEOQZIAogA0GIAWooAgA2AgAgBiADQYABaikCADcDACADIAMpAng3A5gBIAMgAjYCrAEgDSABIAQQxB0gA0HgAGoQzy8gBxDPLyADQeABaiQADAILDDILQdyL/wBBKSADQZgBakHsj/8AQYiM/wAQ1R4ACwsgCEGQAmoQ3CkhASAAQfDU/wA2AgggACABNgIEIABBk4CAgHg2AgAMFwsCQAJAIAgoAkwoAgQNACAIKAJIKAIERQ0AIAhB0ABqIAtBCGogAygCCBCKGCAIKAJUIQEgCCgCUCICQZOAgIB4RwRAIAAgCCkCWDcCCCAAQRBqIAhB4ABqKAIANgIAIAAgATYCBCAAIAI2AgAgCEGQA2oQ9yQMAwsgCCABNgL0AwJAAkACQAJAAkACQAJAAkAgCCgCSC0AAUEBaw4DAQIDAAsgCEHQAGoiASAIQZADakEw/AoAACAIQZACaiEFIwBBgAFrIgIkACACIAhB9ANqIgY2AgQCQAJAIAQtADRFBEAgAkHQAGogASACQQRqEKQHIAItAFAiBEEpRgRAIAJBywBqIAJB5ABqKAIAIgQ2AAAgAkHDAGogAkHcAGopAgAiGzcAACACIAIpAlQiHDcAOyAFQRRqIAQ2AAAgBUEMaiAbNwAAIAUgHDcABCAFQSk6AAAMAwsgAkHHAGoiBiACQeAAaikAADcAACACQUBrIgcgAkHZAGopAAA3AwAgAkEoaiACQfAAaikCADcCACACQTBqIAJB+ABqKQIANwIAIAJBEWogBykDADcAACACQRhqIAYpAAA3AAAgAiACKQBRIhs3AzggAiACKQJoNwIgIAIgGzcACSACIAQ6AAgMAQsgAkEIaiABIAYQlgULIAUgAkEIakEw/AoAAAsgARD3JCACQYABaiQAIAgtAJACIgFBKUcNAyAIQYsEaiAIQaQCaigCACIBNgAAIAhBgwRqIAhBnAJqKQIAIhs3AAAgCCAIKQKUAiIcNwD7AyAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwJCyAIQdAAaiIBIAhBkANqQTD8CgAAIAhBkAJqIQUjAEGAAWsiAiQAIAIgCEH0A2oiBjYCBAJAAkAgBC0ANEUEQCACQdAAaiABIAJBBGoQpgcgAi0AUCIEQSlGBEAgAkHLAGogAkHkAGooAgAiBDYAACACQcMAaiACQdwAaikCACIbNwAAIAIgAikCVCIcNwA7IAVBFGogBDYAACAFQQxqIBs3AAAgBSAcNwAEIAVBKToAAAwDCyACQccAaiIGIAJB4ABqKQAANwAAIAJBQGsiByACQdkAaikAADcDACACQShqIAJB8ABqKQIANwIAIAJBMGogAkH4AGopAgA3AgAgAkERaiAHKQMANwAAIAJBGGogBikAADcAACACIAIpAFEiGzcDOCACIAIpAmg3AiAgAiAbNwAJIAIgBDoACAwBCyACQQhqIAEgBhCUBQsgBSACQQhqQTD8CgAACyABEPckIAJBgAFqJAAgCC0AkAIiAUEpRw0DIAhBiwRqIAhBpAJqKAIAIgE2AAAgCEGDBGogCEGcAmopAgAiGzcAACAIIAgpApQCIhw3APsDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADAgLIAhB0ABqIgEgCEGQA2pBMPwKAAAgCEGQAmohBSMAQYABayICJAAgAiAIQfQDaiIGNgIEAkACQCAELQA0RQRAIAJB0ABqIAEgAkEEahClByACLQBQIgRBKUYEQCACQcsAaiACQeQAaigCACIENgAAIAJBwwBqIAJB3ABqKQIAIhs3AAAgAiACKQJUIhw3ADsgBUEUaiAENgAAIAVBDGogGzcAACAFIBw3AAQgBUEpOgAADAMLIAJBxwBqIgYgAkHgAGopAAA3AAAgAkFAayIHIAJB2QBqKQAANwMAIAJBKGogAkHwAGopAgA3AgAgAkEwaiACQfgAaikCADcCACACQRFqIAcpAwA3AAAgAkEYaiAGKQAANwAAIAIgAikAUSIbNwM4IAIgAikCaDcCICACIBs3AAkgAiAEOgAIDAELIAJBCGogASAGEIwFCyAFIAJBCGpBMPwKAAALIAEQ9yQgAkGAAWokACAILQCQAiIBQSlHDQMgCEGLBGogCEGkAmooAgAiATYAACAIQYMEaiAIQZwCaikCACIbNwAAIAggCCkClAIiHDcA+wMgAEEQaiABNgAAIABBCGogGzcAACAAIBw3AAAMBwsgCEHQAGoiASAIQZADakEw/AoAACAIQZACaiEFIwBBgAFrIgIkACACIAhB9ANqIgY2AgQCQAJAIAQtADRFBEAgAkHQAGogASACQQRqEKMHIAItAFAiBEEpRgRAIAJBywBqIAJB5ABqKAIAIgQ2AAAgAkHDAGogAkHcAGopAgAiGzcAACACIAIpAlQiHDcAOyAFQRRqIAQ2AAAgBUEMaiAbNwAAIAUgHDcABCAFQSk6AAAMAwsgAkHHAGoiBiACQeAAaikAADcAACACQUBrIgcgAkHZAGopAAA3AwAgAkEoaiACQfAAaikCADcCACACQTBqIAJB+ABqKQIANwIAIAJBEWogBykDADcAACACQRhqIAYpAAA3AAAgAiACKQBRIhs3AzggAiACKQJoNwIgIAIgGzcACSACIAQ6AAgMAQsgAkEIaiABIAYQmQULIAUgAkEIakEw/AoAAAsgARD3JCACQYABaiQAIAgtAJACIgFBKUcNAyAIQYsEaiAIQaQCaigCACIBNgAAIAhBgwRqIAhBnAJqKQIAIhs3AAAgCCAIKQKUAiIcNwD7AyAAQRBqIAE2AAAgAEEIaiAbNwAAIAAgHDcAAAwGCyAIQYcEaiICIAhBoAJqKQAANwAAIAhBgARqIgQgCEGZAmopAAA3AwAgCEHgA2ogCEGwAmopAgA3AgAgCEHoA2ogCEG4AmopAgA3AgAgCEHJA2ogBCkDADcAACAIQdADaiACKQAANwAAIAggCCkAkQIiGzcD+AMgCCAIKQKoAjcC2AMgCCAbNwDBAyAIIAE6AMADDAQLIAhBhwRqIgIgCEGgAmopAAA3AAAgCEGABGoiBCAIQZkCaikAADcDACAIQeADaiAIQbACaikCADcCACAIQegDaiAIQbgCaikCADcCACAIQckDaiAEKQMANwAAIAhB0ANqIAIpAAA3AAAgCCAIKQCRAiIbNwP4AyAIIAgpAqgCNwLYAyAIIBs3AMEDIAggAToAwAMMAwsgCEGHBGoiAiAIQaACaikAADcAACAIQYAEaiIEIAhBmQJqKQAANwMAIAhB4ANqIAhBsAJqKQIANwIAIAhB6ANqIAhBuAJqKQIANwIAIAhByQNqIAQpAwA3AAAgCEHQA2ogAikAADcAACAIIAgpAJECIhs3A/gDIAggCCkCqAI3AtgDIAggGzcAwQMgCCABOgDAAwwCCyAIQYcEaiICIAhBoAJqKQAANwAAIAhBgARqIgQgCEGZAmopAAA3AwAgCEHgA2ogCEGwAmopAgA3AgAgCEHoA2ogCEG4AmopAgA3AgAgCEHJA2ogBCkDADcAACAIQdADaiACKQAANwAAIAggCCkAkQIiGzcD+AMgCCAIKQKoAjcC2AMgCCAbNwDBAyAIIAE6AMADDAELIAhBwANqIAhBkANqQTD8CgAACyAIKAJILQABIQEgCwRAIAsgCygCACICQQFqNgIAIAJBAEgNGCADKAIIIQMLIAhBGGogCEHAA2oiAiABIAsgAxDwByAAIAgpAxg3AgQgAEGTgICAeDYCACACEPckIAgoAogDIgAgACgCACIAQQFrNgIAIABBAUcNFiAIQYgDahC7IwwWCyAIKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDRUgCEGIA2oQuyMMFQsCQCACQRJrDgIBAgALIAJBBEcgDUETR3INCyADLQABDQsjAEEwayIBJAAgASAFIAYQ+yEQ8yQQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABBwNP/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMGgsMFAsgCS0AASIBQQFrDgMCAwQBCyANQRJrDgIFBAkLIAMQkTZFDQcgCEHQAGohASMAQTBrIgIkACACIAUgBhDqIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwwXCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMEgsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDREgABC7IwwRCyADEJE2RQ0GIAhB0ABqIQEjAEEwayICJAAgAiAFIAYQ5yEQ7CQQsD4CQEE4QQQQrTYiAwRAIANCgYCAgBA3AgAgA0EIaiACQTD8CgAAIAFB6NL/ADYCCCABIAM2AgQgAUGTgICAeDYCACACQTBqJAAMAQsMFgsgCCgCWCEBIAgoAlQhAiAIKAJQIgNBk4CAgHhHBEAgACAIKQJcNwIMIAAgATYCCCAAIAI2AgQgACADNgIADBELIAggATYClAIgCCACNgKQAiAAIAhBkAJqIgBB1Nz/ACAIKAJIIAQQhgEgCCgCkAIiASABKAIAIgFBAWs2AgAgAUEBRw0QIAAQuyMMEAsgAxCRNkUNBSAIQdAAaiEBIwBBMGsiAiQAIAIgBSAGEIEiEOwkELA+AkBBOEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAkEw/AoAACABQejS/wA2AgggASADNgIEIAFBk4CAgHg2AgAgAkEwaiQADAELDBULIAgoAlghASAIKAJUIQIgCCgCUCIDQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwQCyAIIAE2ApQCIAggAjYCkAIgACAIQZACaiIAQdTc/wAgCCgCSCAEEIYBIAgoApACIgEgASgCACIBQQFrNgIAIAFBAUcNDyAAELsjDA8LIAMQkTZFDQQgCEHQAGohASMAQTBrIgIkACACIAUgBhDuIRDsJBCwPgJAQThBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAJBMPwKAAAgAUHo0v8ANgIIIAEgAzYCBCABQZOAgIB4NgIAIAJBMGokAAwBCwwUCyAIKAJYIQEgCCgCVCECIAgoAlAiA0GTgICAeEcEQCAAIAgpAlw3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMDwsgCCABNgKUAiAIIAI2ApACIAAgCEGQAmoiAEHU3P8AIAgoAkggBBCGASAIKAKQAiIBIAEoAgAiAUEBazYCACABQQFHDQ4gABC7IwwOCyAJLQABQQFrDgICBAELIAktAAFBAkcNAwJAAkACQAJAIAMtAAFBAWsOAwECAwALIwBBgAJrIgEkACAFIAYQ/SEhAiABQaABakHgu/8AKAIANgIAIAFCgJTr3AM3AxggAUHYu/8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDSkLQcAAIQogA0HAABDRNEUNWSADBEAQsD4gA0HAABCtNiIKRQ0+CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1WIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1dIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDV5CACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNYCABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNLiACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDC4LIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSwgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJB2Lv/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQvBMQsD5BOEEEEK02IgJFDRcgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgz/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSsgAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARB2Lv/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQvBMQsD5BOEEEEK02IgJFDRYgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgz/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwPCyMAQYACayIBJAAgBSAGEP0hIQIgAUGgAWpBhLz/ACgCADYCACABQsCEPTcDGCABQfy7/wApAgA3A5gBIAFBmAFqIgMQpwwCQAJAAkAgBC0ANEUEQCACEL48IQQgAUGcAWogAhD3NCABIAQ2ArgBIAFBADYCtAEgASACNgKYASABIAFBGGo2ArwBIAFB2ABqIAMQshcgAUH4AWoiAiABQeQAaigCADYCACABIAEpAlw3A/ABIAEoAlgiA0GTgICAeEYNASABKAJoIQQgACABKQPwATcCBCAAIAQ2AhAgACADNgIAIABBDGogAigCADYCAAwCCyACEL48IQUgAUEoaiIJIAIQ9zQgASAFNgJEIAFBADYCQCABIAI2AiQgAhC+PBogAhC+PCELIAIQvjwaIAEgAhC+PCIDNgKIASABQdgAakF/IANBB2oiBiADIAZLG0EDdhDSHyADQQN0IgQhAyAEQThxIgcEQCAEIAdrQUBrIgMgBEkNKAtBwAAhCiADQcAAENE0RQ1YIAMEQBCwPiADQcAAEK02IgpFDT0LIAEoAmAhDCABQaQBaiAJQQhqKQIANwIAIAFBrAFqIAlBEGopAgA3AgAgASACNgKYAUEAIQcgAUEANgLAASABIAU2ArgBIAFBADYCtAEgASAJKQIANwKcASABIAFBGGo2ArwBIAFBnAFqIQlBACECA0AgAUHwAWohDUICIRsgAiAFRwR/IAECfgJAIAEoApwBRQ0AIAIgASgCrAFPDVUgASgCoAEgASgCqAEgAmoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgAkEBajYCtAFCAAwBCyABIAJBAWo2ArQBIAEoArwBKQMAIhxQDVwgASgCmAEoAhAgAkEEdGoiAigCBCEFIAIoAgAhBiACKQMIIh1CgICAgICAgICAf1EgHEJ/UXENXUIAIAUgBnINABogHSAcfyEbQgELNwPwASABIAEoAsABIgZBAWo2AsABIAFB4AFqBSANCyAbNwMAAkACQAJAIAEpA/ABIhtCAlIEQCAHIApqIQIgG6dBAXFFDQEgAiABKQPgATcDACAMIAZBA3ZqIgIgAi0AAEEBIAZBB3F0cjoAAAwCCwJAIAEoApwBIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAkQ+x4LIAEgB0EDdSICNgLwASACIAEoAogBRw1fIAEoAmAhAiABKAJkIQUgASABKQJYNwKkASABQQA2AqABIAEgBTYCnAEgASACNgKYASABQRBqIAFBmAFqIgYQ1zsgASgCECEHELA+QRxBBBCtNiICRQ0tIAJCgYCAgBA3AgAgAiABKQKYATcCCCACQRBqIAFBoAFqIgkpAgA3AgAgAkEYaiABQagBaiIMKAIANgIAIAEgAzYCqAEgAUKAgICAgAg3AqABIAEgBDYCnAEgASAKNgKYASABQQhqIAYQ1zsgASgCCCEGELA+QRxBBBCtNiIDDQIMLQsgAkIANwMACyAHQQhqIQcgASgCuAEhBSABKAK0ASECDAELCyADQoGAgIAQNwIAIAMgASkCmAE3AgggA0EQaiAJKQIANwIAIANBGGogDCgCADYCACABIAU2AugBIAEgBzYC5AEgASACNgLgARCwPkEMQQQQrTYiAkUNKyACIAQ2AgggAiAGNgIEIAIgAzYCACABQQE2AvgBIAEgAjYC9AEgAUEBNgLwASABQQA2AmAgAUKAgICAwAA3AlggAUGYAWoiAkH8u/8AIAsgASABQeABaiABQfABaiABQdgAaiIDEIwTIAMgAhC1ExCwPkE4QQQQrTYiAkUNFiACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDQ/wA2AgggACACNgIEIABBk4CAgHg2AgAMAQsgAUHQAGogAUH4AWooAgAiAzYCACABIAEpA/ABNwNIIAFBmAFqIgQgASgCTCICIAIgA0EEdGoQ9AkgAUHoAWogAUGgAWooAgA2AgAgAUGQAWoiBSABQawBaigCADYCACABIAEpApgBNwPgASABIAEpAqQBNwOIARCwPkEMQQQQrTYiAkUNKiACIAEpA4gBNwIAIAJBCGogBSgCADYCACABQQE2AvgBIAEgAjYC9AEgAUEBNgLwASABQQA2AmAgAUKAgICAwAA3AlggBEH8u/8AIAMgASABQeABaiABQfABaiABQdgAaiIDEIwTIAMgBBC1ExCwPkE4QQQQrTYiAkUNFSACQoGAgIAQNwIAIAJBCGogA0Ew/AoAACAAQdDQ/wA2AgggACACNgIEIABBk4CAgHg2AgAgAUHIAGoiABDJPiAAEO07CyABQYACaiQADAALDA4LIwBBgAJrIgEkACAFIAYQ/SEhAiABQaABakHMvP8AKAIANgIAIAFC6Ac3AxggAUHEvP8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDScLQcAAIQogA0HAABDRNEUNVyADBEAQsD4gA0HAABCtNiIKRQ08CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1UIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1bIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDVxCACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNXiABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNLCACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDCwLIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSogAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJBxLz/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQuhMQsD5BOEEEEK02IgJFDRUgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgzv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSkgAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARBxLz/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQuhMQsD5BOEEEEK02IgJFDRQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEGgzv8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwNCyMAQYACayIBJAAgBSAGEP0hIQIgAUGgAWpBkLz/ACgCADYCACABQgE3AxggAUGIvP8AKQIANwOYASABQZgBaiIDEKcMAkACQAJAIAQtADRFBEAgAhC+PCEEIAFBnAFqIAIQ9zQgASAENgK4ASABQQA2ArQBIAEgAjYCmAEgASABQRhqNgK8ASABQdgAaiADELIXIAFB+AFqIgIgAUHkAGooAgA2AgAgASABKQJcNwPwASABKAJYIgNBk4CAgHhGDQEgASgCaCEEIAAgASkD8AE3AgQgACAENgIQIAAgAzYCACAAQQxqIAIoAgA2AgAMAgsgAhC+PCEFIAFBKGoiCSACEPc0IAEgBTYCRCABQQA2AkAgASACNgIkIAIQvjwaIAIQvjwhCyACEL48GiABIAIQvjwiAzYCiAEgAUHYAGpBfyADQQdqIgYgAyAGSxtBA3YQ0h8gA0EDdCIEIQMgBEE4cSIHBEAgBCAHa0FAayIDIARJDSYLQcAAIQogA0HAABDRNEUNViADBEAQsD4gA0HAABCtNiIKRQ07CyABKAJgIQwgAUGkAWogCUEIaikCADcCACABQawBaiAJQRBqKQIANwIAIAEgAjYCmAFBACEHIAFBADYCwAEgASAFNgK4ASABQQA2ArQBIAEgCSkCADcCnAEgASABQRhqNgK8ASABQZwBaiEJQQAhAgNAIAFB8AFqIQ1CAiEbIAIgBUcEfyABAn4CQCABKAKcAUUNACACIAEoAqwBTw1TIAEoAqABIAEoAqgBIAJqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIAJBAWo2ArQBQgAMAQsgASACQQFqNgK0ASABKAK8ASkDACIcUA1aIAEoApgBKAIQIAJBBHRqIgIoAgQhBSACKAIAIQYgAikDCCIdQoCAgICAgICAgH9RIBxCf1FxDVtCACAFIAZyDQAaIB0gHH8hG0IBCzcD8AEgASABKALAASIGQQFqNgLAASABQeABagUgDQsgGzcDAAJAAkACQCABKQPwASIbQgJSBEAgByAKaiECIBunQQFxRQ0BIAIgASkD4AE3AwAgDCAGQQN2aiICIAItAABBASAGQQdxdHI6AAAMAgsCQCABKAKcASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAJEPseCyABIAdBA3UiAjYC8AEgAiABKAKIAUcNXSABKAJgIQIgASgCZCEFIAEgASkCWDcCpAEgAUEANgKgASABIAU2ApwBIAEgAjYCmAEgAUEQaiABQZgBaiIGENc7IAEoAhAhBxCwPkEcQQQQrTYiAkUNKyACQoGAgIAQNwIAIAIgASkCmAE3AgggAkEQaiABQaABaiIJKQIANwIAIAJBGGogAUGoAWoiDCgCADYCACABIAM2AqgBIAFCgICAgIAINwKgASABIAQ2ApwBIAEgCjYCmAEgAUEIaiAGENc7IAEoAgghBhCwPkEcQQQQrTYiAw0CDCsLIAJCADcDAAsgB0EIaiEHIAEoArgBIQUgASgCtAEhAgwBCwsgA0KBgICAEDcCACADIAEpApgBNwIIIANBEGogCSkCADcCACADQRhqIAwoAgA2AgAgASAFNgLoASABIAc2AuQBIAEgAjYC4AEQsD5BDEEEEK02IgJFDSkgAiAENgIIIAIgBjYCBCACIAM2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIAFBmAFqIgJBiLz/ACALIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAIQwRMQsD5BOEEEEK02IgJFDRQgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4z/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIADAELIAFB0ABqIAFB+AFqKAIAIgM2AgAgASABKQPwATcDSCABQZgBaiIEIAEoAkwiAiACIANBBHRqEPQJIAFB6AFqIAFBoAFqKAIANgIAIAFBkAFqIgUgAUGsAWooAgA2AgAgASABKQKYATcD4AEgASABKQKkATcDiAEQsD5BDEEEEK02IgJFDSggAiABKQOIATcCACACQQhqIAUoAgA2AgAgAUEBNgL4ASABIAI2AvQBIAFBATYC8AEgAUEANgJgIAFCgICAgMAANwJYIARBiLz/ACADIAEgAUHgAWogAUHwAWogAUHYAGoiAxCMEyADIAQQwRMQsD5BOEEEEK02IgJFDRMgAkKBgICAEDcCACACQQhqIANBMPwKAAAgAEH4z/8ANgIIIAAgAjYCBCAAQZOAgIB4NgIAIAFByABqIgAQyT4gABDtOwsgAUGAAmokAAwACwwMCyADLQABQQJHDQIjAEEwayIBJAAgASAFIAYQgCIQtSAQsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiABQTD8CgAAIABByM3/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQTBqJAAMAQsMEQsMCwsgAy0AAUECRw0BIwBBQGoiASQAIAUgBhDrISECIAFCwIQ9NwMIIAFBEGoiAyACIAFBCGoQrh0QsD4CQEE4QQQQrTYiAgRAIAJCgYCAgBA3AgAgAkEIaiADQTD8CgAAIABByM3/ADYCCCAAIAI2AgQgAEGTgICAeDYCACABQUBrJAAMAQsMEAsMCgsCQAJAAkACQAJAAkACQAJAAkAgDUESaw4CAQAJCyABQQFrDgMCAwQBCyAIQdAAaiAFIAZB0Lz/ACAEEIYBIAgoAlghASAIKAJUIQIgCCgCUCIFQZOAgIB4RwRAIAAgCCkCXDcCDCAAIAE2AgggACACNgIEIAAgBTYCAAwRCyAIIAE2AvwDIAggAjYC+AMgCEH4A2oQih4hAgJAAkACQCAJLQABQQN0QaDu/wBqKQMAIhsgAy0AAUEDdEGg7v8AaikDACIcVSAbIBxTa0H/AXEOAgECAAsgCCAcpyAbp26tNwOQAyAELQA0DQYgCEHQAGogAiAIQZADahDOBSAILQBQIgFBKUcNByAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAAIAgoAvgDIgAgACgCACIAQQFrNgIAIABBAUcNEiAIQfgDahC7IwwSCyAIQZACaiACEIAVDAcLIAggG6cgHKdurTcDUCMAQUBqIgEkACABIAhB0ABqNgIMIAFBEGoiAyACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjQgASABQQxqNgI8IAFBKGoiBCABQTRqIgIQ7BogAiAEEL0YIAhBkAJqIAIgAxDWHSABQUBrJAAMBgsgAy0AAUECRw0GIwBBgAJrIgMkACADQShqIAUgBigCEBEAACADQZABaiADKAIoIgEgAygCLCgCDBEAAAJAAkACQAJAIAEEQCADKQOQAUKo+Inf7v3i9xmFIAMpA5gBQoKIosHluO7+FoWEUA0BCyADQZABakHGAEEAQQFBARCgGCADKAKUASEBIAMoApABQQFGDWEgAygCmAEiAkHI0f8AQcYA/AoAACAAQcYANgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwCCyABLQAAQRJGBEAgAyABLQABQQN0QYDu/wBqKQMANwMwIAQtADRFBEAgARDAPCECIANBlAFqIAEQ9zQgAyACNgKwASADQQA2AqwBIAMgATYCkAEgAyADQTBqNgK0ASADQeAAaiADQZABahCuFyADQfgBaiIBIANB7ABqKAIANgIAIAMgAykCZDcD8AEgAygCYCICQZOAgIB4Rg0CIAMoAnAhBCAAIAMpA/ABNwIEIAAgBDYCECAAIAI2AgAgAEEMaiABKAIANgIADAMLIAEQwDwhByADQUBrIgkgARD3NCADIAc2AlwgA0EANgJYIAMgATYCPCABEMA8GiABEMA8IQogARDAPBogAyABEMA8IgI2AuABIANB4ABqQX8gAkEHaiIEIAIgBEsbQQN2ENIfIAJBBHQiBiEEAkAgBkEwcSICBEAgBiACa0FAayIEIAZJDQELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDTQLIAMoAmghCyADQZwBaiAJQQhqKQIANwIAIANBpAFqIAlBEGopAgA3AgAgAyABNgKQAUEAIQUgA0EANgK4ASADIAc2ArABIANBADYCrAEgAyAJKQIANwKUASADIANBMGo2ArQBIAIhASAHBEADQAJAAkACQCADKAKUAUUEQCADKAK4ASEHDAELIAMoAqQBIAVLBEAgAygCuAEhByADKAKYASADKAKgASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgK4ASADIAVBAWo2AqwBDAILDFoLIAMgBUEBajYCrAEgA0EQaiADKAKQASgCECAFQQN0aikDACIbIBtCP4cgAygCtAEpAwAiGyAbQj+HEKgeIAMgB0EBajYCuAEgAykDGCADKQMQIhtCP4dSDQAgAUIANwMAIAFBCGogGzcDACALIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQgA3AwAgAUEIakIANwMACyABQRBqIQEgAygCrAEiBSADKAKwAUcNAAsLAkAgAygClAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GUAWoQ+x4LIAMgASACa0EEdSIBNgLwAQJAIAMoAuABIAFGBEAgAygCaCEBIAMoAmwhBSADIAMpAmA3ApwBIANBADYCmAEgAyAFNgKUASADIAE2ApABIANBCGogA0GQAWoiBxDXOyADKAIIIQkQsD5BHEEEEK02IgFFDS8gAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogA0GYAWoiCykCADcCACABQRhqIANBoAFqIgwoAgA2AgAgAyAENgKgASADQoCAgICACDcCmAEgAyAGNgKUASADIAI2ApABIAMgBxDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAMMAsgAkKBgICAEDcCACACIAMpApABNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDTEgASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJoIANCgICAgMAANwJgIANBkAFqIgFB5Lv/ACAKIAMgA0HgAWogA0HwAWogA0HgAGoiAhCMEyACIAEQvhMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIADAYLDGELDBoLDGALDCkLDF8LIANB6AFqIAEoAgAiATYCACADIAMpA/ABNwPgASADQZABaiICIAMoAuQBIgQgBCABQRhsahDzCBCwPkE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjN/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HgAWoiABDJPiAAEPU7CyADQYACaiQADAALDA8LIAMtAAFBAkcNBSMAQYACayIDJAAgA0EoaiAFIAYoAhARAAAgA0GQAWogAygCKCIBIAMoAiwoAgwRAAACQAJAAkACQCABBEAgAykDkAFC+pi2+pKmisMchSADKQOYAUKjwLrZ1ubhqiaFhFANAQsgA0GQAWpBxgBBAEEBQQEQoBggAygClAEhASADKAKQAUEBRg1gIAMoApgBIgJByNH/AEHGAPwKAAAgAEHGADYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAgsgAS0AAEESRgRAIAMgAS0AAUEDdEGA7v8AaikDADcDMCAELQA0RQRAIAEQwDwhAiADQZQBaiABEPc0IAMgAjYCsAEgA0EANgKsASADIAE2ApABIAMgA0EwajYCtAEgA0HgAGogA0GQAWoQrhcgA0H4AWoiASADQewAaigCADYCACADIAMpAmQ3A/ABIAMoAmAiAkGTgICAeEYNAiADKAJwIQQgACADKQPwATcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCAAwDCyABEMA8IQcgA0FAayIJIAEQ9zQgAyAHNgJcIANBADYCWCADIAE2AjwgARDAPBogARDAPCEKIAEQwDwaIAMgARDAPCICNgLgASADQeAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQR0IgYhBAJAIAZBMHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ0zCyADKAJoIQsgA0GcAWogCUEIaikCADcCACADQaQBaiAJQRBqKQIANwIAIAMgATYCkAFBACEFIANBADYCuAEgAyAHNgKwASADQQA2AqwBIAMgCSkCADcClAEgAyADQTBqNgK0ASACIQEgBwRAA0ACQAJAAkAgAygClAFFBEAgAygCuAEhBwwBCyADKAKkASAFSwRAIAMoArgBIQcgAygCmAEgAygCoAEgBWoiCUEDdmotAABB/wFzIAlBB3F2QQFxRQ0BIAMgB0EBajYCuAEgAyAFQQFqNgKsAQwCCwxZCyADIAVBAWo2AqwBIANBEGogAygCkAEoAhAgBUEDdGopAwAiGyAbQj+HIAMoArQBKQMAIhsgG0I/hxCoHiADIAdBAWo2ArgBIAMpAxggAykDECIbQj+HUg0AIAFCADcDACABQQhqIBs3AwAgCyAHQQN2aiIFIAUtAABBASAHQQdxdHI6AAAMAQsgAUIANwMAIAFBCGpCADcDAAsgAUEQaiEBIAMoAqwBIgUgAygCsAFHDQALCwJAIAMoApQBIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBlAFqEPseCyADIAEgAmtBBHUiATYC8AECQCADKALgASABRgRAIAMoAmghASADKAJsIQUgAyADKQJgNwKcASADQQA2ApgBIAMgBTYClAEgAyABNgKQASADQQhqIANBkAFqIgcQ1zsgAygCCCEJELA+QRxBBBCtNiIBRQ0uIAFCgYCAgBA3AgAgASADKQKQATcCCCABQRBqIANBmAFqIgspAgA3AgAgAUEYaiADQaABaiIMKAIANgIAIAMgBDYCoAEgA0KAgICAgAg3ApgBIAMgBjYClAEgAyACNgKQASADIAcQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADC8LIAJCgYCAgBA3AgAgAiADKQKQATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC6AEgAyAJNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ0wIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCaCADQoCAgIDAADcCYCADQZABaiIBQeS7/wAgCiADIANB4AFqIANB8AFqIANB4ABqIgIQjBMgAiABEL4TELA+QThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByM3/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCwxgCwwZCwxfCwwoCwxeCyADQegBaiABKAIAIgE2AgAgAyADKQPwATcD4AEgA0GQAWoiAiADKALkASIEIAQgAUEYbGoQ8wgQsD5BOEEEEK02IgFFDRUgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB4AFqIgAQyT4gABD1OwsgA0GAAmokAAwACwwOCyADLQABQQJHDQQjAEGAAmsiAyQAIANBKGogBSAGKAIQEQAAIANBkAFqIAMoAigiASADKAIsKAIMEQAAAkACQAJAAkAgAQRAIAMpA5ABQu3Flqe9j+DYVIUgAykDmAFC14P/uOLrl/HcAIWEUA0BCyADQZABakHGAEEAQQFBARCgGCADKAKUASEBIAMoApABQQFGDV8gAygCmAEiAkHI0f8AQcYA/AoAACAAQcYANgIMIAAgAjYCCCAAIAE2AgQgAEGGgICAeDYCAAwCCyABLQAAQRJGBEAgAyABLQABQQN0QYDu/wBqKQMANwMwIAQtADRFBEAgARDAPCECIANBlAFqIAEQ9zQgAyACNgKwASADQQA2AqwBIAMgATYCkAEgAyADQTBqNgK0ASADQeAAaiADQZABahCuFyADQfgBaiIBIANB7ABqKAIANgIAIAMgAykCZDcD8AEgAygCYCICQZOAgIB4Rg0CIAMoAnAhBCAAIAMpA/ABNwIEIAAgBDYCECAAIAI2AgAgAEEMaiABKAIANgIADAMLIAEQwDwhByADQUBrIgkgARD3NCADIAc2AlwgA0EANgJYIAMgATYCPCABEMA8GiABEMA8IQogARDAPBogAyABEMA8IgI2AuABIANB4ABqQX8gAkEHaiIEIAIgBEsbQQN2ENIfIAJBBHQiBiEEAkAgBkEwcSICBEAgBiACa0FAayIEIAZJDQELQcAAIQIgBEHAABDRNARAIAQEQBCwPiAEQcAAEK02IgJFDTILIAMoAmghCyADQZwBaiAJQQhqKQIANwIAIANBpAFqIAlBEGopAgA3AgAgAyABNgKQAUEAIQUgA0EANgK4ASADIAc2ArABIANBADYCrAEgAyAJKQIANwKUASADIANBMGo2ArQBIAIhASAHBEADQAJAAkACQCADKAKUAUUEQCADKAK4ASEHDAELIAMoAqQBIAVLBEAgAygCuAEhByADKAKYASADKAKgASAFaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQEgAyAHQQFqNgK4ASADIAVBAWo2AqwBDAILDFgLIAMgBUEBajYCrAEgA0EQaiADKAKQASgCECAFQQN0aikDACIbIBtCP4cgAygCtAEpAwAiGyAbQj+HEKgeIAMgB0EBajYCuAEgAykDGCADKQMQIhtCP4dSDQAgAUIANwMAIAFBCGogGzcDACALIAdBA3ZqIgUgBS0AAEEBIAdBB3F0cjoAAAwBCyABQgA3AwAgAUEIakIANwMACyABQRBqIQEgAygCrAEiBSADKAKwAUcNAAsLAkAgAygClAEiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgA0GUAWoQ+x4LIAMgASACa0EEdSIBNgLwAQJAIAMoAuABIAFGBEAgAygCaCEBIAMoAmwhBSADIAMpAmA3ApwBIANBADYCmAEgAyAFNgKUASADIAE2ApABIANBCGogA0GQAWoiBxDXOyADKAIIIQkQsD5BHEEEEK02IgFFDS0gAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogA0GYAWoiCykCADcCACABQRhqIANBoAFqIgwoAgA2AgAgAyAENgKgASADQoCAgICACDcCmAEgAyAGNgKUASADIAI2ApABIAMgBxDXOyADKAIAIQQQsD5BHEEEEK02IgJFBEAMLgsgAkKBgICAEDcCACACIAMpApABNwIIIAJBEGogCykCADcCACACQRhqIAwoAgA2AgAgAyAFNgLoASADIAk2AuQBIAMgATYC4AEQsD5BDEEEEK02IgFFDS8gASAGNgIIIAEgBDYCBCABIAI2AgAgA0EBNgL4ASADIAE2AvQBIANBATYC8AEgA0EANgJoIANCgICAgMAANwJgIANBkAFqIgFB5Lv/ACAKIAMgA0HgAWogA0HwAWogA0HgAGoiAhCMEyACIAEQvhMQsD5BOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIADAYLDF8LDBgLDF4LDCcLDF0LIANB6AFqIAEoAgAiATYCACADIAMpA/ABNwPgASADQZABaiICIAMoAuQBIgQgBCABQRhsahDzCBCwPkE4QQQQrTYiAUUNFCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjN/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HgAWoiABDJPiAAEPU7CyADQYACaiQADAALDA0LIAMtAAFBAkcNAyMAQYACayIDJAAgA0EoaiAFIAYoAhARAAAgA0GQAWogAygCKCIBIAMoAiwoAgwRAAACQAJAAkACQCABBEAgAykDkAFC/7qo06KElftAhSADKQOYAUKG7fP27Ny75gCFhFANAQsgA0GQAWpBxgBBAEEBQQEQoBggAygClAEhASADKAKQAUEBRg1eIAMoApgBIgJByNH/AEHGAPwKAAAgAEHGADYCDCAAIAI2AgggACABNgIEIABBhoCAgHg2AgAMAgsgAS0AAEESRgRAIAMgAS0AAUEDdEGA7v8AaikDADcDMCAELQA0RQRAIAEQwDwhAiADQZQBaiABEPc0IAMgAjYCsAEgA0EANgKsASADIAE2ApABIAMgA0EwajYCtAEgA0HgAGogA0GQAWoQrhcgA0H4AWoiASADQewAaigCADYCACADIAMpAmQ3A/ABIAMoAmAiAkGTgICAeEYNAiADKAJwIQQgACADKQPwATcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCAAwDCyABEMA8IQcgA0FAayIJIAEQ9zQgAyAHNgJcIANBADYCWCADIAE2AjwgARDAPBogARDAPCEKIAEQwDwaIAMgARDAPCICNgLgASADQeAAakF/IAJBB2oiBCACIARLG0EDdhDSHyACQQR0IgYhBAJAIAZBMHEiAgRAIAYgAmtBQGsiBCAGSQ0BC0HAACECIARBwAAQ0TQEQCAEBEAQsD4gBEHAABCtNiICRQ0xCyADKAJoIQsgA0GcAWogCUEIaikCADcCACADQaQBaiAJQRBqKQIANwIAIAMgATYCkAFBACEFIANBADYCuAEgAyAHNgKwASADQQA2AqwBIAMgCSkCADcClAEgAyADQTBqNgK0ASACIQEgBwRAA0ACQAJAAkAgAygClAFFBEAgAygCuAEhBwwBCyADKAKkASAFSwRAIAMoArgBIQcgAygCmAEgAygCoAEgBWoiCUEDdmotAABB/wFzIAlBB3F2QQFxRQ0BIAMgB0EBajYCuAEgAyAFQQFqNgKsAQwCCwxXCyADIAVBAWo2AqwBIANBEGogAygCkAEoAhAgBUEDdGopAwAiGyAbQj+HIAMoArQBKQMAIhsgG0I/hxCoHiADIAdBAWo2ArgBIAMpAxggAykDECIbQj+HUg0AIAFCADcDACABQQhqIBs3AwAgCyAHQQN2aiIFIAUtAABBASAHQQdxdHI6AAAMAQsgAUIANwMAIAFBCGpCADcDAAsgAUEQaiEBIAMoAqwBIgUgAygCsAFHDQALCwJAIAMoApQBIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIANBlAFqEPseCyADIAEgAmtBBHUiATYC8AECQCADKALgASABRgRAIAMoAmghASADKAJsIQUgAyADKQJgNwKcASADQQA2ApgBIAMgBTYClAEgAyABNgKQASADQQhqIANBkAFqIgcQ1zsgAygCCCEJELA+QRxBBBCtNiIBRQ0sIAFCgYCAgBA3AgAgASADKQKQATcCCCABQRBqIANBmAFqIgspAgA3AgAgAUEYaiADQaABaiIMKAIANgIAIAMgBDYCoAEgA0KAgICAgAg3ApgBIAMgBjYClAEgAyACNgKQASADIAcQ1zsgAygCACEEELA+QRxBBBCtNiICRQRADC0LIAJCgYCAgBA3AgAgAiADKQKQATcCCCACQRBqIAspAgA3AgAgAkEYaiAMKAIANgIAIAMgBTYC6AEgAyAJNgLkASADIAE2AuABELA+QQxBBBCtNiIBRQ0uIAEgBjYCCCABIAQ2AgQgASACNgIAIANBATYC+AEgAyABNgL0ASADQQE2AvABIANBADYCaCADQoCAgIDAADcCYCADQZABaiIBQeS7/wAgCiADIANB4AFqIANB8AFqIANB4ABqIgIQjBMgAiABEL4TELA+QThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByM3/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCwxeCwwXCwxdCwwmCwxcCyADQegBaiABKAIAIgE2AgAgAyADKQPwATcD4AEgA0GQAWoiAiADKALkASIEIAQgAUEYbGoQ8wgQsD5BOEEEEK02IgFFDRMgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIzf8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB4AFqIgAQyT4gABD1OwsgA0GAAmokAAwACwwMCyAIQZACaiACIAhBkANqEK0DDAELIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbACaiAIQfAAaikCADcCACAIQbgCaiAIQfgAaikCADcCACAIQZkCaiADKQMANwAAIAhBoAJqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCqAIgCCAbNwCRAiAIIAE6AJACCyAIQQhqIAhBkAJqIgEgCCgCSC0AARDBESAAIAgpAwg3AgQgAEGTgICAeDYCACABEPckIAgoAvgDIgAgACgCACIAQQFrNgIAIABBAUcNCSAIQfgDahC7IwwJCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAgLIAhBAzYCVCAIQdjf/wA2AlAgCEICNwJcIAhBrwM2ApwCIAhBrwM2ApQCIAggCEGQAmo2AlggCCAIQcgAajYCmAIgCCAIQcwAajYCkAIgCEHAA2ogCEHQAGoQqxggAEGCgICAeDYCACAAIAgpAsADNwIEIABBDGogCEHIA2ooAgA2AgAMBwsgCEEDNgJUIAhB2N//ADYCUCAIQgI3AlwgCEGvAzYCnAIgCEGvAzYClAIgCCAIQZACajYCWCAIIAhByABqNgKYAiAIIAhBzABqNgKQAiAIQcADaiAIQdAAahCrGCAAQYKAgIB4NgIAIAAgCCkCwAM3AgQgAEEMaiAIQcgDaigCADYCAAwGCyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAULIAAgCCkDwAM3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwECyAIQQM2AlQgCEHY3/8ANgJQIAhCAjcCXCAIQa8DNgKcAiAIQa8DNgKUAiAIIAhBkAJqNgJYIAggCEHIAGo2ApgCIAggCEHMAGo2ApACIAhBwANqIAhB0ABqEKsYIABBgoCAgHg2AgAgACAIKQLAAzcCBCAAQQxqIAhByANqKAIANgIADAMLIAhBMGogBSAGEMgvIgUQ3DsgCCgCMCECIAgoAjQhBiAIQShqIAcQwzQgCEHQAGoiASACIAIgBkEDdGogCCgCKCICIAIgCCgCLEECdGoQyCIgCCAENgJoIAhBkAJqIQQjAEFAaiICJAAgAkGTgICAeDYCACACQThqIAFBGGooAgA2AgAgAkEwaiABQRBqKQIANwMAIAJBKGogAUEIaikCADcDACACIAEpAgA3AyAgAiACNgI8IAJBFGoiASACQSBqEIoTAkAgAigCAEGTgICAeEcEQCAEIAIpAgA3AgAgBEEQaiACQRBqKAIANgIAIARBCGogAkEIaikCADcCACABEMMnIAEQ6jsMAQsgBCACKQIUNwIEIARBk4CAgHg2AgAgBEEMaiACQRxqKAIANgIACyACQUBrJAAgCEHIA2oiASAIQZwCaigCADYCACAIIAgpApQCNwPAAyAIKAKQAiICQZOAgIB4RwRAIAgoAqACIQMgACAIKQPAAzcCBCAAIAM2AhAgACACNgIAIABBDGogASgCADYCAAwDCyAIQdgBaiABKAIANgIAIAggCCkDwAM3A9ABIAsgCygCACIBQQFqNgIAIAFBAEgNAyADKAIIIQEgCEGQAmoiAiAFEJw2EO4lIAhB0ABqIAsgASAIQdABaiACEOUPIAhByANqIgEgCEHcAGopAgA3AwAgCEHQA2oiAiAIQeQAaigCADYCACAIIAgpAlQ3A8ADIAgoAlAiA0GAgICAeEYEQCAAIAgpA8ADNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMAwsgCEGMAmogCEGAAWooAgA2AgAgCEGEAmogCEH4AGopAgA3AgAgCEH8AWogCEHwAGopAgA3AgAgCEHoAWogASkDADcCACAIQfABaiACKAIANgIAIAggCCkCaDcC9AEgCCADNgLcASAIIAgpA8ADNwLgASAIQdwBahDlKSEBIABB8N7/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCyAAIAEgAhDzEAwBCyAIQThqIAUgBigCEBEAACAIQdAAaiICIAgoAjgiASAIKAI8KAIMEQAAIAFFDQIgCCkDUEL/2euq19iLjPEAhSAIKQNYQoH04aOq+Nbqi3+FhFBFDQIgAiABQQxqQdTc/wAgAygCCCICQTBqIAQQhgEgCCgCWCEDIAgoAlQhBCAIKAJQIgVBk4CAgHhHBEAgACAIKQJcNwIMIAAgAzYCCCAAIAQ2AgQgACAFNgIADAELIAIgAigCACIFQQFqNgIAIAVBAEgNASAIKAJMKAIEIQUgCEGQAmoiBiABEJs2EO4lIAhB0ABqIAIgBSAEIAMgBhDhBiAILQBQIgFBKUYEQCAIQdMDaiAIQeQAaigCACIBNgAAIAhBywNqIAhB3ABqKQIAIhs3AAAgCCAIKQJUIhw3AMMDIABBEGogATYAACAAQQhqIBs3AAAgACAcNwAADAELIAhBzwNqIgIgCEHgAGopAAA3AAAgCEHIA2oiAyAIQdkAaikAADcDACAIQbwBaiAIQfAAaikCADcCACAIQcQBaiAIQfgAaikCADcCACAIQcwBaiAIQYABaigCADYCACAIQaUBaiADKQMANwAAIAhBrAFqIAIpAAA3AAAgCCAIKQBRIhs3A8ADIAggCCkCaDcCtAEgCCABOgCcASAIIBs3AJ0BIAhBnAFqEOUpIQEgAEGs3f8ANgIIIAAgATYCBCAAQZOAgIB4NgIACyAIQZAKaiQADwsAC0HE3P8AELI7AAtBsJ3/AEEgQdCd/wAQnykAC0Hgnf8AELI7AAtBBEE4EKM9AAtBBEHEABCjPQALIAIgASgCuANB0KD/ABD9LwALIAIgASgC3ARB0KD/ABD9LwALIAMgASgCyANB0KD/ABD9LwALQQRBwAAQoz0AC0EEQTwQoz0AC0HAACACEKM9AAtBoOOAAUEpIAZBmANqQfTkgAFBzOOAARDVHgALIAMgASgCDEGMyf8AEP0vAAtBpJiAARCyOwALIAEgAxCjPDYCbAw+C0EEQTQQoz0ACyABIAMQ/js2AmwMPAsgASADEPw7NgJsDDsLIAEgAxD9OzYCbAw6C0HY6f8AELI7AAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgB0HQAGpBxMj/AEHYwf8AENUeAAtBBEEcEKM9AAsgB0IANwJcIAdCgYCAgMAANwJUIAdBwLv/ADYCUEEAIAdBpAFqIAdBmAFqIAdB0ABqQci7/wAQrysAC0EEQQwQoz0AC0Gswf8AQSkgA0HQAGpBxMj/AEHYwf8AENUeAAtBwAAgBRCjPQALIANCADcCXCADQoGAgIDAADcCVCADQcC7/wA2AlBBACADQaQBaiADQZgBaiADQdAAakHIu/8AEK8rAAtBwAAgBBCjPQALIANCADcCXCADQoGAgIDAADcCVCADQcC7/wA2AlBBACADQaABaiADQawBaiADQdAAakHIu/8AEK8rAAsgA0IANwJcIANCgYCAgMAANwJUIANBwLv/ADYCUEEAIANBlAFqIANBrAFqIANB0ABqQci7/wAQrysACyADQQA2ApgBQQAgA0GUAWogA0EMaiADQZgBakHs7IABEK8rAAtBzPb/AEEgQez2/wAQnykACyAHQgA3ApABIAdCgYCAgMAANwKIASAHQZTy/wA2AoQBQQAgB0HUAWogB0HIAWogB0GEAWpBnPL/ABCvKwALQfz2/wBBKSAHQYQBakH4+v8AQaj3/wAQ1R4AC0GY9v8AQSNBvPb/ABDLJAALIANCADcCkAEgA0KBgICAwAA3AogBIANBlPL/ADYChAFBACADQdQBaiADQcgBaiADQYQBakGc8v8AEK8rAAtB/Pb/AEEpIANBhAFqQfj6/wBBqPf/ABDVHgALQfz2/wBBKSABQfwAakH4+v8AQaj3/wAQ1R4ACyABQgA3AogBIAFCgYCAgMAANwKAASABQZTy/wA2AnxBACABQdABaiABQdwBaiABQfwAakGc8v8AEK8rAAtB/Pb/AEEpIAFB9ABqQfj6/wBBqPf/ABDVHgALQcAAIAMQoz0ACyABQgA3AoABIAFCgYCAgMAANwJ4IAFBlPL/ADYCdEEAIAFBQGsgAUHEAWogAUH0AGpBnPL/ABCvKwALIANCADcCgAEgA0KBgICAwAA3AnggA0GU8v8ANgJ0QQAgA0HEAWogA0G4AWogA0H0AGpBnPL/ABCvKwALQfz2/wBBKSADQfQAakH4+v8AQaj3/wAQ1R4ACyADQgA3AogBIANCgYCAgMAANwKAASADQZTy/wA2AnxBACADQcgAaiADQcABaiADQfwAakGc8v8AEK8rAAtB/Pb/AEEpIANB/ABqQfj6/wBBqPf/ABDVHgALQfz2/wBBKSABQZwCakH4+v8AQaj3/wAQ1R4ACyABQgA3AqgCIAFCgYCAgMAANwKgAiABQZTy/wA2ApwCQQAgAUH8AWogAUHUAWogAUGcAmpBnPL/ABCvKwALQYCMgAEQsjsAC0H89v8AQSkgAUGAAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKMASABQoGAgIDAADcChAEgAUGU8v8ANgKAAUEAIAFB0ABqIAFB1AFqIAFBgAFqQZzy/wAQrysAC0H89v8AQSkgA0GAAWpB+Pr/AEGo9/8AENUeAAsgA0IANwKMASADQoGAgIDAADcChAEgA0GU8v8ANgKAAUEAIANB0ABqIANBzAFqIANBgAFqQZzy/wAQrysAC0H89v8AQSkgB0GcAWpB+Pr/AEGo9/8AENUeAAsgB0IANwKoASAHQoGAgIDAADcCoAEgB0GU8v8ANgKcAUEAIAdB4AFqIAdB7AFqIAdBnAFqQZzy/wAQrysACyADQgA3AqgBIANCgYCAgMAANwKgASADQZTy/wA2ApwBQQAgA0HgAWogA0HsAWogA0GcAWpBnPL/ABCvKwALQfz2/wBBKSADQZwBakH4+v8AQaj3/wAQ1R4AC0H89v8AQSkgAUGkAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKwASABQoGAgIDAADcCqAEgAUGU8v8ANgKkAUEAIAFB6AFqIAFB9AFqIAFBpAFqQZzy/wAQrysAC0H89v8AQSkgAUGYAWpB+Pr/AEGo9/8AENUeAAsgAUIANwKkASABQoGAgIDAADcCnAEgAUGU8v8ANgKYAUEAIAFBgAJqIAFB3AFqIAFBmAFqQZzy/wAQrysAC0H8wP8AQSBBnMH/ABCfKQALQfz2/wBBKSABQdwCakH4+v8AQaj3/wAQ1R4ACyABQgA3AugCIAFCgYCAgMAANwLgAiABQZTy/wA2AtwCQQAgAUHIAmogAUGUAmogAUHcAmpBnPL/ABCvKwALQfz2/wBBKSABQaABakH4+v8AQaj3/wAQ1R4ACyABQgA3AqwBIAFCgYCAgMAANwKkASABQZTy/wA2AqABQQAgAUGMAmogAUHwAWogAUGgAWpBnPL/ABCvKwALQdSK/wBBI0H4iv8AEMskAAtB3Iv/AEEpIAFBQGtB7I//AEGIjP8AENUeAAtBrMH/AEEpIAFBmAFqQcTI/wBB2MH/ABDVHgALQajR/wAQ4isAC0Go0f8AEOYrAAsgAUIANwKkASABQoGAgIDAADcCnAEgAUHAu/8ANgKYAUEAIAFB8AFqIAFBiAFqIAFBmAFqQci7/wAQrysACyADQgA3ApwBIANCgYCAgMAANwKUASADQcC7/wA2ApABQQAgA0HwAWogA0HgAWogA0GQAWpByLv/ABCvKwALQazB/wBBKSADQZABakHEyP8AQdjB/wAQ1R4AC0H4zv8AQShBuNH/ABCfKQALIAEgAygCmAFBjMn/ABD9LwALIAFBAjYCECABQeC9/wA2AgwgAUICNwIYIAFBOzYCfCABQTs2AnQgASABQfAAajYCFCABIAFB7ABqNgJ4IAEgAUHoAGo2AnAgAUEMakHwvf8AEO8sAAuLyAIEE38EfgF9AXwjAEGQH2siBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEgAigCHCIHEQQAIgYtAABBAmsOJQMEBQYHCAkKCwwNAAAAAAABAgAAAAAAAAAAAAAAAAAAABUWFxgACyABIAcRBAAiBi0AAA4pHhhVVVVVVVVVVVVVVRkjJBobVVUpHCssLS4vMFUdMlUzNDVVVVVVNjdVCyAGLQABQQFrDgMNDg8MCyAGLQABQQFrDgIQEQ8LIARBkBpqIAEgAhC7IiADEOMWIAQtAJAaIgJBKUYNaCAEQe8AaiIDIARBoBpqKQAANwAAIARB6ABqIgYgBEGZGmopAAA3AwAgBEGAAWoiByAEQbAaaikCADcDACAEQYgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A2AgBCAEKQKoGjcDeEE4QQQQrTYiAUUNaiABIAI6AAggAUKBgICAEDcCACABIAQpA2A3AAkgASAEKQN4NwIgIABBtP+BATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaQsgBEGQGmogASACEKgiIAMQoRYgBC0AkBoiAkEpRg1mIARBnwFqIgMgBEGgGmopAAA3AAAgBEGYAWoiBiAEQZkaaikAADcDACAEQbABaiIHIARBsBpqKQIANwMAIARBuAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDkAEgBCAEKQKoGjcDqAFBOEEEEK02IgFFDWkgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQATcACSABIAQpA6gBNwIgIABBjICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaAsgBEGQGmogASACELEiIAMQohYgBC0AkBoiAkEpRg1kIARBzwFqIgMgBEGgGmopAAA3AAAgBEHIAWoiBiAEQZkaaikAADcDACAEQeABaiIHIARBsBpqKQIANwMAIARB6AFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDwAEgBCAEKQKoGjcD2AFBOEEEEK02IgFFDWggASACOgAIIAFCgYCAgBA3AgAgASAEKQPAATcACSABIAQpA9gBNwIgIABB5ICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZwsgBEGQGmogASACEKQiIAMQoxYgBC0AkBoiAkEpRg1iIARB/wFqIgMgBEGgGmopAAA3AAAgBEH4AWoiBiAEQZkaaikAADcDACAEQZACaiIHIARBsBpqKQIANwMAIARBmAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD8AEgBCAEKQKoGjcDiAJBOEEEEK02IgFFDWcgASACOgAIIAFCgYCAgBA3AgAgASAEKQPwATcACSABIAQpA4gCNwIgIABBvIGCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZgsgBEGQGmogASACEKoiIAMQ5BYgBC0AkBoiAkEpRg1gIARBrwJqIgMgBEGgGmopAAA3AAAgBEGoAmoiBiAEQZkaaikAADcDACAEQcACaiIHIARBsBpqKQIANwMAIARByAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDoAIgBCAEKQKoGjcDuAJBOEEEEK02IgFFDWYgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgAjcACSABIAQpA7gCNwIgIABBlIKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZQsgBEGQGmogASACEK0iIAMQpBYgBC0AkBoiAkEpRg1eIARB3wJqIgMgBEGgGmopAAA3AAAgBEHYAmoiBiAEQZkaaikAADcDACAEQfACaiIHIARBsBpqKQIANwMAIARB+AJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD0AIgBCAEKQKoGjcD6AJBOEEEEK02IgFFDWUgASACOgAIIAFCgYCAgBA3AgAgASAEKQPQAjcACSABIAQpA+gCNwIgIABB7IKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZAsgBEGQGmogASACELciIAMQpRYgBC0AkBoiAkEpRg1cIARBjwNqIgMgBEGgGmopAAA3AAAgBEGIA2oiBiAEQZkaaikAADcDACAEQaADaiIHIARBsBpqKQIANwMAIARBqANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDgAMgBCAEKQKoGjcDmANBOEEEEK02IgFFDWQgASACOgAIIAFCgYCAgBA3AgAgASAEKQOAAzcACSABIAQpA5gDNwIgIABBxIOCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYwsgBEGQGmogASACEKIiIAMQphYgBC0AkBoiAkEpRg1aIARBvwNqIgMgBEGgGmopAAA3AAAgBEG4A2oiBiAEQZkaaikAADcDACAEQdADaiIHIARBsBpqKQIANwMAIARB2ANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDsAMgBCAEKQKoGjcDyANBOEEEEK02IgFFDWMgASACOgAIIAFCgYCAgBA3AgAgASAEKQOwAzcACSABIAQpA8gDNwIgIABBnISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYgsgBEGAH2oiBiABIAIQuSIiASgCECABKAIUQQF2IAMQwhYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQzx0gBEG4HmoiAiABEMoGIAIQmB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNWCAEQe8DaiIDIARBxxlqKQAANwAAIARB6ANqIgUgBEHAGWopAwA3AwAgBEGABGoiCCAGKQMANwMAIARBiARqIgYgBykDADcDACAEIAQpA7gZNwPgAyAEIAQpA7gPNwP4A0E4QQQQrTYiAUUNYiABIAI6AAggAUKBgICAEDcCACABIAQpA+ADNwAJIAEgBCkD+AM3AiAgAEH0hIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxhCyAEQYAfaiEOIAEgAhC1IiIKKAIQIQIgCigCFEECdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF4cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCAIKAIYIQIgCCgCFEEBRg1tIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayIHJAAgCEEIaiICIAUoAgQgBSgCAGtBA3YQ7i0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiINKAIEIQsgDSgCACESAkAgB0EIaiIFKAIAIgkgBSgCBCIPRwRAIAUoAhQhDCAFKAIQIRMgBSgCDCEUIAUoAgghBSANKAIIIAtBAnRqIQ0gDyAJa0EDdiEPA0AgAiAJNgIMAkAgCSgCACIRIBNJBEAgFCARQQJ0aioCACEbDAELIAUgDCgCEE8Nd0MAAAAAIRsgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXgLIA0gGzgCACAJQQhqIQkgDUEEaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCNGwsgDiAGEOgYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARC+HSAEQbgeaiIBIAoQygYgARCTHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1WIARBnwRqIgMgBEHHGWopAAA3AAAgBEGYBGoiBSAEQcAZaikDADcDACAEQbAEaiIIIAYpAwA3AwAgBEG4BGoiBiAHKQMANwMAIAQgBCkDuBk3A5AEIAQgBCkDuA83A6gEQThBBBCtNiIBRQ1hIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAQ3AAkgASAEKQOoBDcCICAAQcyFggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGALIARBgB9qIQ4gASACEKYiIgooAhAhAiAKKAIUQQN2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBCEEIEKAYIAgoAhghAiAIKAIUQQFGDWwgCEEQaiIQQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDsLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg0oAgQhCyANKAIAIRICQCAHQQhqIgUoAgAiCSAFKAIEIg9HBEAgBSgCFCEMIAUoAhAhEyAFKAIMIRQgBSgCCCEFIA0oAgggC0EDdGohDSAPIAlrQQN2IQ8DQCACIAk2AgwCQCAJKAIAIhEgE0kEQCAUIBFBA3RqKwMAIRwMAQsgBSAMKAIQTw12RAAAAAAAAAAAIRwgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXcLIA0gHDkDACAJQQhqIQkgDUEIaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahD7GgsgDiAGEOcYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARDbHSAEQbgeaiIBIAoQygYgARCQHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1UIARBzwRqIgMgBEHHGWopAAA3AAAgBEHIBGoiBSAEQcAZaikDADcDACAEQeAEaiIIIAYpAwA3AwAgBEHoBGoiBiAHKQMANwMAIAQgBCkDuBk3A8AEIAQgBCkDuA83A9gEQThBBBCtNiIBRQ1gIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAQ3AAkgASAEKQPYBDcCICAAQaSGggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADF8LIAEgAhCzIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC8HSABQdQAaiIGIAIQygYgBhDyHCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHgB2ogBEGwGmopAgA3AgAgBEHoB2ogBEG4GmopAgA3AgAgBEHJB2ogAykDADcAACAEQdAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC2AcgBCABOgDAByAEIBc3AMEHIARBwAdqENwpIQEgAEH8hoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADF4LIAEgAhChIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDAHSABQdQAaiIGIAIQygYgBhD1HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGQCGogBEGwGmopAgA3AgAgBEGYCGogBEG4GmopAgA3AgAgBEH5B2ogAykDADcAACAEQYAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCiAggBCABOgDwByAEIBc3APEHIARB8AdqENwpIQEgAEHUh4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADF0LIAEgAhCdIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDDHSABQdQAaiIGIAIQygYgBhD6HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHACGogBEGwGmopAgA3AgAgBEHICGogBEG4GmopAgA3AgAgBEGpCGogAykDADcAACAEQbAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCuAggBCABOgCgCCAEIBc3AKEIIARBoAhqENwpIQEgAEGsiIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFwLIAEgAhCuIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMQWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDQHSABQdQAaiIGIAIQygYgBhD5HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHwCGogBEGwGmopAgA3AgAgBEH4CGogBEG4GmopAgA3AgAgBEHZCGogAykDADcAACAEQeAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC6AggBCABOgDQCCAEIBc3ANEIIARB0AhqENwpIQEgAEGEiYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFsLIAEgAhC4IiECIwBB4ABrIgEkACABIAIoAhAgAigCFEECdiADEMMWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC9HSABQdQAaiIGIAIQygYgBhD0HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNSiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHQBmogBEGwGmopAgA3AgAgBEHYBmogBEG4GmopAgA3AgAgBEG5BmogAykDADcAACAEQcAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCyAYgBCABOgCwBiAEIBc3ALEGIARBsAZqENwpIQEgAEHciYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFoLIAEgAhCjIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEDdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQRBCBCgGCAIKAIYIQYgCCgCFEEBRg1nIAhBEGoiE0EANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6i0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACEUAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIREgCSgCDCEVIAkoAgghCSANKAIIIAxBA3RqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIQIBFJBEAgFSAQQQN0aiISKAIEIRAgEigCACESDAELIAkgDigCEE8NcEEAIRBBACESIA4oAgQgCSAOKAIMaiIWQQN2ai0AACAWQQdxdkEBcQ1yCyANIBI2AgAgDUEEaiAQNgIAIAtBCGohCyANQQhqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBQgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogEygCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEJUbCyAFIAcQ6xggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDTHSAFQdQAaiIBIAoQygYgARD3HCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNSCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGAB2ogBEGwGmopAgA3AgAgBEGIB2ogBEG4GmopAgA3AgAgBEHpBmogAykDADcAACAEQfAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC+AYgBCABOgDgBiAEIBc3AOEGIARB4AZqENwpIQEgAEG0ioIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFkLIAEgAhCgIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEEdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQhBEBCgGCAIKAIYIQYgCCgCFEEBRg1mIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6S0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACESAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIRMgCSgCDCEUIAkoAgghCSANKAIIIAxBBHRqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIRIBNJBEAgAUEYaiAUIBFBBHRqIhFBCGopAwA3AwAgASARKQMANwMQDAELIAkgDigCEE8NbyAOKAIEIAkgDigCDGoiEUEDdmotAAAgEUEHcXZBAXENcSABQRhqQgA3AwAgAUIANwMQCyANIAEpAxA3AwAgDUEIaiABQRhqKQMANwMAIAtBCGohCyANQRBqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBIgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogECgCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEP4aCyAFIAcQ6hggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDFHSAFQdQAaiIBIAoQygYgARDxHCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNRiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGwB2ogBEGwGmopAgA3AgAgBEG4B2ogBEG4GmopAgA3AgAgBEGZB2ogAykDADcAACAEQaAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCqAcgBCABOgCQByAEIBc3AJEHIARBkAdqENwpIQEgAEGMi4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADFgLIARBgB9qIgYgASACEKciIgEoAhAgASgCFEECdiADEMMWIARBiBVqIgIgARCSNiADEPMSIARBkBpqIgMgBiACEModIARBuB5qIgIgARDKBiACENAYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUQgBEH/BGoiAyAEQccZaikAADcAACAEQfgEaiIFIARBwBlqKQMANwMAIARBkAVqIgggBikDADcDACAEQZgFaiIGIAcpAwA3AwAgBCAEKQO4GTcD8AQgBCAEKQO4DzcDiAVBOEEEEK02IgFFDVggASACOgAIIAFCgYCAgBA3AgAgASAEKQPwBDcACSABIAQpA4gFNwIgIABB5IuCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVwsgBEGAH2oiBiABIAIQqyIiASgCECABKAIUQQN2IAMQxBYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQxh0gBEG4HmoiAiABEMoGIAIQ0hggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQiAEQa8FaiIDIARBxxlqKQAANwAAIARBqAVqIgUgBEHAGWopAwA3AwAgBEHABWoiCCAGKQMANwMAIARByAVqIgYgBykDADcDACAEIAQpA7gZNwOgBSAEIAQpA7gPNwO4BUE4QQQQrTYiAUUNVyABIAI6AAggAUKBgICAEDcCACABIAQpA6AFNwAJIAEgBCkDuAU3AiAgAEG8jIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxWCyAEQYAfaiEJIAEgAhC8IiIFKAIQIQIgBSgCFEEEdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCELIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAggC0F4cWo2AhAgASAINgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBygCBCAHKAIAa0EDdkEAQRBBEBCgGCAIKAIYIQIgCCgCFEEBRg1iIAhBEGoiCkEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayICJAAgCEEIaiILIAcoAgQgBygCAGtBA3YQ6y0gCykCBCEXIAJBGGogB0EQaikCADcDACACQRBqIAdBCGopAgA3AwAgAiAHKQIANwMIIAIgF0IgiTcCKCACIAtBCGo2AiQgAkEIaiACQSRqEKkQIAJBMGokACAGQQhqIAooAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEIIAEgBjYCGCABIAI2AhQgASAHIAhBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCJGwsgCSAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDzEiAEQZAaaiIDIAkgARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAgoAhghAiAIKAIUQQFGDWEgCEEQaiISQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCyAOKAIAIRMCQCAHQQhqIgUoAgAiCSAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIREgBSgCCCEKIA4oAgggC0EFdGohBSAQIAlrQQN2IRADQCACIAk2AgwCQCAJKAIAIg4gFEkEQCARIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyAKIA0oAhBPDWtCACEaQgAhGUIAIRhCACEXIA0oAgQgCiANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1sCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCUEIaiEJIAVBIGohBSAKQQFqIQogC0EBaiELIBBBAWsiEA0ACwsgEyALNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiASKAIANgIAIAYgCCkCCDcCACAIQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXhxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhRsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8xIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9iggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAGLQABQQFrDgMGBwgFCyAGLQABDgIKCzoLIAYtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiAiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCACIAEgAyAGKAIEENQVIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiICIAQoAigiASAEKAIsKAIMEQAAIAFFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCACIAEgAyAGKAIEEOkCIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENg8IAMQ2DwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQwxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQxBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjwIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJ4CIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMoWIAdBDGogARCTNiADEPMSIAEoAgQhCSAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAJKAIAIgggCCgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAkpAgQ3AgAgAiAINgIAIAJBDGohAiALQQxrIQsgCUEMaiEJIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQkAIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCfAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDKFiAHQQxqIAEQkzYgAxDzEiABKAIEIQkgB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCSgCACIIIAgoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAJKQIENwIAIAIgCDYCACACQQxqIQIgC0EMayELIAlBDGohCSAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADELgCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmogASACEJEiIAMQuQIgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQkjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQsjAEEwayIBJAAgAUEIaiACQSBqIgcQhCgCQAJAAkAgASgCCCIKBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIIIA02AgQgCCAKNgIAIAFBHGoiD0EBNgIAIAEgCDYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQhCggBSgCCCIIBEAgAUEUaiEKIAUoAgwhBwNAIAooAggiDSAKKAIARgRAIApBARDqLQsgCigCBCANQQN0aiIQIAc2AgQgECAINgIAIAogDUEBajYCCCAFIAwQhCggBSgCBCEHIAUoAgAiCA0ACwsgBUEQaiQAIAtBCGogDygCADYCACALIAEpAhQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCSACKQIANwIAIAlBEGogAkEQaigCADYCACAJQQhqIAJBCGopAgA3AgAgCxDDJyALEOo7DAELIAkgAikCFDcCBCAJQZOAgIB4NgIAIAlBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIBEP8YIAEgAxC+LSAEIA42ArQaIARBhBFqIAEQ8BggBCgCwA8EQCAEQZAVaiAEQcAPaigCADYCACAEQZwVaiAEQYwRaigCADYCACAEIAQpArgPNwOIFSAEIAQpAoQRNwKUFSABIARBiBVqEK0QIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmoiASAEQYQRakEAIANBDGoiAhDYPBDyFSAEQYgVaiIDIAEQ4ScgASACENg8IAMQ1RggARDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCACAEQbgPaiIAEO4fIAAQ6DsMOAsgBkEEaiEHIAYtAAENCyAEQfwYaiAHKAIEEOojIARB2ABqIAEgAigCEBEAACAEQZAaaiAEKAJYIgIgBCgCXCgCDBEAACACRQ0GIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNBiAEQYAfaiACKAIcIAIoAiAgAxDFFiAEQdAAaiAHELAuIAQoAlAiASAEKAJUIgtGDQoDQCAEQZAaaiACIAEtAAAQ2ShBiJ+CASADEIcBIAQoApgaIQUgBCgClBohCCAEKAKQGiIJQZOAgIB4RwRAIAAgBCkCnBo3AgwgACAFNgIIIAAgCDYCBCAAIAk2AgAgBCgCgB8iACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBgB9qEPseCyAEQfwYaiIAEMMnIAAQ6jsMOQsgBCgChBkiCSAEKAL8GEYEQCAEQfwYakHgn4IBEJsoCyAEKAKAGSAJQQN0aiIKIAU2AgQgCiAINgIAIAQgCUEBajYChBkgAUEIaiIBIAtHDQALDAoLIAEgBxEEACIGLQAAQSJGDQggBCAGNgK4DyAEQQE2ApQaIARB7KaCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakH0poIBEO8sAAsgBEGQGmoiBiABIAIQxy8Qjw4gBEG4D2oiBSAGEPwVIAYgBSADELgCIAQtAJAaIgJBKUYNBiAEQZcVaiIDIARBoBpqKQAANwAAIARBkBVqIgggBEGZGmopAAA3AwAgBEGQEGogBEGwGmopAgA3AgAgBEGYEGogBEG4GmopAgA3AgAgBEGgEGogBEHAGmopAgA3AgAgBEH5D2ogCCkDADcAACAEQYAQaiADKQAANwAAIAQgBCkCqBo3AogQIAQgAjoA8A8gBCAEKQCRGjcA8Q8gBEGIFWoiAiAEQfAPahCEPiAGIAIQoRsgAiABIAcRBAAQygYgBEGoEGoiASAGIAIQjBggAiABEM0cIAYgAhC4BiAGEPcpIQEgAEGEp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAUQyR4MNQsgASAHEQQAIgYtAABBKEYNBCAEIAY2ArgPIARBATYClBogBEH8qoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQYSrggEQ7ywAC0HQjoIBELI7AAtBgJeCARCyOwALQfibggEQsjsAC0GgnoIBELI7DAULAkACQAJAAkACQAJAIAYoAgQiBi0AMEEDaw4DAQIDAAsgBCAGQTBqNgK4DyAEQQE2ApQaIARBsKqCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakG4qoIBEO8sAAsgBEGQGmohDSABIAIQnCIhDiMAQeAEayIFJAACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NTCAGKAIAIgMgCk8NTQJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAVCIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NVCABKAIAIgEgCk8NVSAPIAhBA3RqKQMAIA8gAUEDdGopAwBUDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVMgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWg0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOwKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuhUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAXZPDQQgAyALQQF0aiEGIAkgC2oLIgxBAWohCSAGQQJqIQNBACELIAEgAk8NACABQQJ0IQogBi4BACASayEPA0AgASAFKAJUIgZPDUUgBSgCUCAKaigCACIGIAJPDUYgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRyAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggA0GAgAJPDQkgBSgCLCIGQQJqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQJqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzsAACAFIAUoAixBAmo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEELIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAIQYCAAk8NAiAFKAIsIgJBAmoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkECaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg7AAAgBSAFKAIsQQJqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBg4aMGDYCACAFQoOGjJiw4MCBAzcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGJkqTIADYCACAFQomSpMiQocKECTcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCygCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADEK4TIAMgDkEgakGIn4IBIAFBnISCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAoQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQnwkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAwtBf0EAQZCvggEQwyEAC0Gwr4IBELI7AAtB0K+CARCyOwALIAQtAJAaIgFBKUYNAyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG4FmogBEGwGmopAgA3AgAgBEGhFmogAykDADcAACAEQagWaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCsBYgBCABOgCYFiAEIBc3AJkWIARBmBZqEPUpIQEgAEHcp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIARBkBpqIQ0gASACEJoiIQ4jAEHgBGsiBSQAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NSSAGKAIAIgMgCk8NSgJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAVCIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NUSABKAIAIgEgCk8NUiAPIAhBA3RqKQMAIA8gAUEDdGopAwBUDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVAgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWg0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOoKDAILDEwLIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuhUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDT4gBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABDfGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF8cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAnZPDQQgAyALQQJ0aiEGIAkgC2oLIgxBAWohCSAGQQRqIQNBACELIAEgAk8NACABQQJ0IQogBigCACASayEPA0AgASAFKAJUIgZPDUIgBSgCUCAKaigCACIGIAJPDUMgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRCAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQSAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUEgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQRqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NPyACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD4LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNPiACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGJkqTIADYCACAFQomSpMiQocKECTcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNPiACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCygCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADEK4TIAMgDkEgakGIn4IBIAFBnISCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAoQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQngkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQtBf0EAQZCvggEQwyEACyAELQCQGiIBQSlGDQEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4BZqIARBsBpqKQIANwIAIARByRZqIAMpAwA3AAAgBEHQFmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgWIAQgAToAwBYgBCAXNwDBFiAEQcAWahD1KSEBIABBtKiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZAaaiENIAEgAhCbIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAIAMoAhQiAUEHTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIRIgDigCGCETIAVBzABqIAFBA3YiAkG8/IEBEKQaIAUoAlAhByAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAchBiABDQEgBigCBCIIIAVB1ANqIhQoAgAiASgCBCIKTw1HIAYoAgAiAyAKTw1IAkACQAJAAkAgASgCACIPIAhBA3RqKQMAIA8gA0EDdGopAwBUIhFFBEBBAiEJIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCCAKTw1PIAEoAgAiASAKTw1QIA8gCEEDdGopAwAgDyABQQN0aikDAFQNAiADIQEgDCAJQQFqIglHDQALDAILQQIhCSAMQQJGDQAgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NTiABKAIAIgEgCk8NBCAPIAhBA3RqKQMAIA8gAUEDdGopAwBaDQEgAyEBIAwgCUEBaiIJRw0ACwwBCyAJIAxHDQELIBFFDQMgDEEBdiEDIAxBAnQgBmpBBGshCANAIAYoAgAhASAGIAgoAgA2AgAgCCABNgIAIAhBBGshCCAGQQRqIQYgA0EBayIDDQALDAMLIAYgDEEAIAxBAXJnQQF0QT5zIBQQ4goMAgsMSgsgDEECdCEBQQQhBgNAIAcgBiAHaiAFQdQDahC6FSABIAZBBGoiBkcNAAsLAkACQCAMRQ0AIAcgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NPCAFIBAgAUEDdGooAgAiATYC3AQgASATSQRAQQAhCCASBEAgDkEMakEAEMgZIQsLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQXhxaiEJQQAhAQNAAn8gC0UEQCADIQYgCCADIAlHDQEaDAULIAsgCSADa0EDdk8NBCADIAtBA3RqIQYgCCALagsiDEEBaiEIIAZBCGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBJrIQ8DQCABIAUoAlQiBk8NQCAFKAJQIApqKAIAIgYgAk8NQSAPIBAgBkEDdGooAgBNDQEgBiAFKALcAyIHTw1CIAUoAtgDIAZBAnRqIAw2AgAgCkEEaiEKIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNQUHAAEHAABCtNiIBRQ0/IAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUFBwABBwAAQrTYiAUUNPyAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4QQEhCyAFKAIYIgdBAk8EQCAHrSEYQQAhA0IBIRcDQCAFKAIUIANqIgFBBGooAgAgASgCACIBRwRAIAUoAkQiCEEIaiIGIAUoAjwiAksEQCAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRCIIQQhqIQYgBSgCPCECCyACIAZJBH8gBUE4aiACQQF0IgIgBhDSKiIGIAIgBksbEOgZIAUoAkQFIAgLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCICQQhqIgEgBSgCJCIGSwRAIAVBIGogBkEBdCICIAEQ0ioiASABIAJJGxDoGSAFKAIkIQYgBSgCLCICQQhqIQELIAEgBksEfyAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCLAUgAgsgBSgCKGogFzcAACAFIAUoAixBCGo2AiwgBSAFKAIwQQFqNgIwIAtBAWohCwsgA0EEaiEDIBggF0IBfCIXUg0ACwsgB0EBayEBIAdFDQQgBSgCFCABQQJ0ajUCACEXIAUoAkQiBkEIaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRCIGQQhqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQFIAYLIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBCGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiBkEIaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSAGCyAFQShqIgIoAgBqIAetNwAAIAUgBSgCLEEIaiIDNgIsIAUgBSgCMEEBajYCMCAFQaADaiIHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgBUGcAmoiARCXKSACKAIAIQggAiAFQaQCaiIGKQIANwMAIAUpAyAhFyAFIAUpApwCNwMgIAVBADYCMCAFIBc3AqgCIAVBADYCpAIgBSADNgKgAiAFIAg2ApwCIAVBCGogARDXOyAFKAIIIQhBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAVBrAJqIgkoAgA2AgAgBSADNgLcAyAFIAg2AtgDIAUgAjYC1AMgASAFQfgCaiIDIAVB1ANqIggQ+iMgBUHMAGoiCiABEM0cIAdBiZKkyAA2AgAgBUKJkqTIkKHChAk3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgARCXKSAFQUBrIgIoAgAhCyAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAs2ApwCIAUgARDXOyAFKAIAIQtBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAkoAgA2AgAgBSAHNgLcAyAFIAs2AtgDIAUgAjYC1AMgASADIAgQ+iMgAyABEM0cIAVBkAFqIgEgAxCuEyADIA5BIGpBiJ+CASABQZyEggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhGDQIgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAMLIAEgBSgCVCIDTw09IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPAsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQoAkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQsgAUEAQZCvggEQwyEACyAELQCQGiIBQSlHBEAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBiBdqIARBsBpqKQIANwIAIARB8RZqIAMpAwA3AAAgBEH4FmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AoAXIAQgAToA6BYgBCAXNwDpFiAEQegWahD1KSEBIABBjKmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwxCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwwCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwvCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAACAEQbgPahDJHgwuCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAgQiBi0AAEECaw4IAQIDBAUGBwgACyAEIAY2ArgPIARBATYClBogBEGcpoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQaSmggEQ7ywACyAEQZAaaiEGIAEgAhDEIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDjFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQ0gBEGIFWoiAiAGQcQA/AoAACAEQdcRaiAEQdcaai0AADoAACAEIAQvANUaOwDVESAEQZARaiIDIAJBxAD8CgAAIAQgAToA1BEgAxDrKSEBIABBkKCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw7CyAEQZAaaiEGIAEgAhDBIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxChFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQsgBEGIFWoiAiAGQcQA/AoAACAEQZ8SaiAEQdcaai0AADoAACAEIAQvANUaOwCdEiAEQdgRaiIDIAJBxAD8CgAAIAQgAToAnBIgAxDrKSEBIABB6KCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEGIAEgAhDAIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCiFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQkgBEGIFWoiAiAGQcQA/AoAACAEQecSaiAEQdcaai0AADoAACAEIAQvANUaOwDlEiAEQaASaiIDIAJBxAD8CgAAIAQgAToA5BIgAxDrKSEBIABBwKGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiEGIAEgAhDDIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCjFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQcgBEGIFWoiAiAGQcQA/AoAACAEQa8TaiAEQdcaai0AADoAACAEIAQvANUaOwCtEyAEQegSaiIDIAJBxAD8CgAAIAQgAToArBMgAxDrKSEBIABBmKKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAEQZAaaiEGIAEgAhDCIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDkFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQUgBEGIFWoiAiAGQcQA/AoAACAEQfcTaiAEQdcaai0AADoAACAEIAQvANUaOwD1EyAEQbATaiIDIAJBxAD8CgAAIAQgAToA9BMgAxDrKSEBIABB8KKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAEQZAaaiEGIAEgAhC/IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCkFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQMgBEGIFWoiAiAGQcQA/AoAACAEQb8UaiAEQdcaai0AADoAACAEIAQvANUaOwC9FCAEQfgTaiIDIAJBxAD8CgAAIAQgAToAvBQgAxDrKSEBIABByKOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw2CyAEQZAaaiEGIAEgAhC+IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxClFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQEgBEGIFWoiAiAGQcQA/AoAACAEQYcVaiAEQdcaai0AADoAACAEIAQvANUaOwCFFSAEQcAUaiIDIAJBxAD8CgAAIAQgAToAhBUgAxDrKSEBIABBoKSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZAaaiEGIAEgAhC9IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCmFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJHBEAgBEGIFWoiAiAGQcQA/AoAACAEQZcWaiAEQdcaai0AADoAACAEIAQvANUaOwCVFiAEQdAVaiIDIAJBxAD8CgAAIAQgAToAlBYgAxDrKSEBIABB+KSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAw0CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwzCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwyCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwxCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwwCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwvCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwuCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwtCyAHKAIAIgEgASgCACICQQFqNgIAIAJBAEgNASAGKAIIIQIgBEHAHmogBEGIH2ooAgA2AgAgBCAEKQKAHzcDuB4gBEEANgK4GSAEQcAPaiAEQYQZaigCADYCACAEIAQpAvwYNwO4DyAEQZAaaiABIAIgBEG4HmogBEG4GWogBEG4D2oQkQQgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGBEAgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADC0LIARBsBlqIARBuBpqKQIANwIAIARBqBlqIARBsBpqKQIANwIAIARBlBlqIAEpAwA3AgAgBEGcGWogAigCADYCACAEIAQpAqgaNwKgGSAEIAM2AogZIAQgBCkDiBU3AowZIARBiBlqENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCwLIARByABqIAEgAigCEBEAACAEQZAaaiICIAQoAkgiASAEKAJMKAIMEQAAAkACQCABRQ0AIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNACAEQYgVaiIFIAEoAhwgASgCICADEMUWIARBADYC6BkgBEGgGmogBEH4GWopAgA3AwAgBEGYGmogBEHwGWopAgA3AwAgBCAEKQLoGTcDkBogBEG4GWoiCCAFIAIQ2B0gARCTNiIJRQ0BIAIgCSgCBCAJKAIIQQJ2IAMQwxYgBEG4D2oiAyACIARB6BlqEL8dIARBQGsgBxCwLiAEKQNAIRcgBCABNgKgGiAEIBc3ApAaIAQgAzYCnBogBCAINgKYGiAFIAIQuxUgBEHAHmoiASAEQZQVaigCADYCACAEIAQpAowVNwO4HiAEKAKIFSICQZOAgIB4RwRAIAQoApgVIQYgACAEKQO4HjcCBCAAIAY2AhAgACACNgIAIABBDGogASgCADYCACADEP4kIAgQ/iQMLgsgBEGIGmogBEHAHmooAgA2AgAgBCAEKQO4HjcDgBogBEGQGmoiAUEAQYAE/AsAIAQgBCgCyBkiAjYCiBUgBCACIARBzBlqIgMoAgBqNgKMFSAEIAE2ApAVIARBnB5qIARBiBVqIgEQvCwgBEGwHmogAygCACICNgIAIARBnBVqIAI2AgAgBEGoFWogBEHYGWopAgA3AwAgBEGwFWogBEHgGWopAgA3AwAgBEGQFWogBEHAGWooAgA2AgAgBCAEKQLEGSIXNwOoHiAEIBc3ApQVIAQgBCkC0Bk3A6AVIAQgBCkCuBk3A4gVIAEQtAwCQCAEKAKgFSIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQaAVahD7HgsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQIgBigCCCECIARBiB9qIARBpB5qKAIANgIAIAQgBCkCnB43A4AfIARBiBVqIAEgAiAEQageaiAEQYAfaiAEQYAaahCRBCAEQcAeaiIBIARBlBVqKQIANwMAIARByB5qIgIgBEGcFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiA0GAgICAeEYEQCAAIAQpA7geNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBEG4D2oQ/iQMLgsgBEH4HmogBEGwFWopAgA3AgAgBEHwHmogBEGoFWopAgA3AgAgBEHcHmogASkDADcCACAEQeQeaiACKAIANgIAIAQgBCkCoBU3AugeIAQgAzYC0B4gBCAEKQO4HjcC1B4gBEHQHmoQ3CkhASAAQbCeggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oQ/iQMLQtB8J+CARCyOwALQYCgggEQsjsACwALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCgLIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwnCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwmCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwlCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGAsgBEEIakHEjoIBIAMQoSsgACAEKQMINwIEIABBk4CAgHg2AgAMFwsgBCAGNgK4DyAEQQE2ApQaIARByKuCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakHQq4IBEO8sAAsgBEGTBmogASgAACIBNgAAIARBiwZqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwCDBiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwVCyAEQeMFaiABKAAAIgE2AAAgBEHbBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3ANMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBQLIARBswVqIAEoAAAiATYAACAEQasFaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAowUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEwsgBEGDBWogASgAACIBNgAAIARB+wRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDzBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwSCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwRCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwQCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwPCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwOCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwNCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwMCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwLCyAEQdMEaiABKAAAIgE2AAAgBEHLBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AMMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAoLIARBowRqIAEoAAAiATYAACAEQZsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAkwQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCQsgBEHzA2ogASgAACIBNgAAIARB6wNqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDjAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwICyAEQcMDaiAEQaQaaigCACIBNgAAIARBuwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCzAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwHCyAEQZMDaiAEQaQaaigCACIBNgAAIARBiwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCDAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwGCyAEQeMCaiAEQaQaaigCACIBNgAAIARB2wJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDTAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwFCyAEQbMCaiAEQaQaaigCACIBNgAAIARBqwJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCjAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwECyAEQYMCaiAEQaQaaigCACIBNgAAIARB+wFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDzASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwDCyAEQdMBaiAEQaQaaigCACIBNgAAIARBywFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDDASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwCCyAEQaMBaiAEQaQaaigCACIBNgAAIARBmwFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCTASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwBCyAEQfMAaiAEQaQaaigCACIBNgAAIARB6wBqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwBjIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAACyAEQZAfaiQADwtBBEE4EKM9AAsgASACQbjxgQEQwyEACyABIAZB7PKBARDDIQALIAYgAkH88oEBEMMhAAsgBiAHQYzzgQEQwyEACyABIAJB6PGBARDDIQALIAEgA0HY8YEBEMMhAAtBwABBwAAQoz0AC0EEQRwQoz0AC0HA9IEBQSkgBUH4AmpBzPyBAUHs9IEBENUeAAsgAiAIKAIcQbz8gQEQ/S8ACyAGIAgoAhxBvPyBARD9LwALIAggCkHw9oMBEMMhAAsgAyAKQYD3gwEQwyEACyAIIApB8PaDARDDIQALIAEgCkGA94MBEMMhAAtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQboTNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgAUEBNgIUIAFB3LaCATYCECABQgE3AhwgAUG6EzYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpB5LaCARDvLAALje4CBBN/BH4BfQF8IwBBkB9rIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASACKAIcIgcRBAAiBi0AAEECaw4lAwQFBgcICQoLDA0AAAAAAAECAAAAAAAAAAAAAAAAAAAAFRYXGAALIAEgBxEEACIGLQAADikeGFVVVVVVVVVVVVVVGSMkGhtVVSkcKywtLi8wVR0yVTM0NVVVVVU2N1ULIAYtAAFBAWsOAw0ODwwLIAYtAAFBAWsOAhARDwsgBEGQGmogASACELsiIAMQ4RYgBC0AkBoiAkEpRg1oIARB7wBqIgMgBEGgGmopAAA3AAAgBEHoAGoiBiAEQZkaaikAADcDACAEQYABaiIHIARBsBpqKQIANwMAIARBiAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDYCAEIAQpAqgaNwN4QThBBBCtNiIBRQ1qIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDYDcACSABIAQpA3g3AiAgAEG0/4EBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxpCyAEQZAaaiABIAIQqCIgAxCbFiAELQCQGiICQSlGDWYgBEGfAWoiAyAEQaAaaikAADcAACAEQZgBaiIGIARBmRpqKQAANwMAIARBsAFqIgcgBEGwGmopAgA3AwAgBEG4AWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwOQASAEIAQpAqgaNwOoAUE4QQQQrTYiAUUNaSABIAI6AAggAUKBgICAEDcCACABIAQpA5ABNwAJIAEgBCkDqAE3AiAgAEGMgIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxoCyAEQZAaaiABIAIQsSIgAxCcFiAELQCQGiICQSlGDWQgBEHPAWoiAyAEQaAaaikAADcAACAEQcgBaiIGIARBmRpqKQAANwMAIARB4AFqIgcgBEGwGmopAgA3AwAgBEHoAWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPAASAEIAQpAqgaNwPYAUE4QQQQrTYiAUUNaCABIAI6AAggAUKBgICAEDcCACABIAQpA8ABNwAJIAEgBCkD2AE3AiAgAEHkgIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxnCyAEQZAaaiABIAIQpCIgAxCdFiAELQCQGiICQSlGDWIgBEH/AWoiAyAEQaAaaikAADcAACAEQfgBaiIGIARBmRpqKQAANwMAIARBkAJqIgcgBEGwGmopAgA3AwAgBEGYAmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPwASAEIAQpAqgaNwOIAkE4QQQQrTYiAUUNZyABIAI6AAggAUKBgICAEDcCACABIAQpA/ABNwAJIAEgBCkDiAI3AiAgAEG8gYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxmCyAEQZAaaiABIAIQqiIgAxDiFiAELQCQGiICQSlGDWAgBEGvAmoiAyAEQaAaaikAADcAACAEQagCaiIGIARBmRpqKQAANwMAIARBwAJqIgcgBEGwGmopAgA3AwAgBEHIAmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwOgAiAEIAQpAqgaNwO4AkE4QQQQrTYiAUUNZiABIAI6AAggAUKBgICAEDcCACABIAQpA6ACNwAJIAEgBCkDuAI3AiAgAEGUgoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxlCyAEQZAaaiABIAIQrSIgAxCeFiAELQCQGiICQSlGDV4gBEHfAmoiAyAEQaAaaikAADcAACAEQdgCaiIGIARBmRpqKQAANwMAIARB8AJqIgcgBEGwGmopAgA3AwAgBEH4AmoiBSAEQbgaaikCADcDACAEIAQpAJEaNwPQAiAEIAQpAqgaNwPoAkE4QQQQrTYiAUUNZSABIAI6AAggAUKBgICAEDcCACABIAQpA9ACNwAJIAEgBCkD6AI3AiAgAEHsgoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxkCyAEQZAaaiABIAIQtyIgAxCfFiAELQCQGiICQSlGDVwgBEGPA2oiAyAEQaAaaikAADcAACAEQYgDaiIGIARBmRpqKQAANwMAIARBoANqIgcgBEGwGmopAgA3AwAgBEGoA2oiBSAEQbgaaikCADcDACAEIAQpAJEaNwOAAyAEIAQpAqgaNwOYA0E4QQQQrTYiAUUNZCABIAI6AAggAUKBgICAEDcCACABIAQpA4ADNwAJIAEgBCkDmAM3AiAgAEHEg4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxjCyAEQZAaaiABIAIQoiIgAxCgFiAELQCQGiICQSlGDVogBEG/A2oiAyAEQaAaaikAADcAACAEQbgDaiIGIARBmRpqKQAANwMAIARB0ANqIgcgBEGwGmopAgA3AwAgBEHYA2oiBSAEQbgaaikCADcDACAEIAQpAJEaNwOwAyAEIAQpAqgaNwPIA0E4QQQQrTYiAUUNYyABIAI6AAggAUKBgICAEDcCACABIAQpA7ADNwAJIAEgBCkDyAM3AiAgAEGchIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBikDADcAACABQRhqIAMpAAA3AAAgAUEoaiAHKQMANwIAIAFBMGogBSkDADcCAAxiCyAEQYAfaiIGIAEgAhC5IiIBKAIQIAEoAhRBAXYgAxC+FiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDPHSAEQbgeaiICIAEQygYgAhCYHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1YIARB7wNqIgMgBEHHGWopAAA3AAAgBEHoA2oiBSAEQcAZaikDADcDACAEQYAEaiIIIAYpAwA3AwAgBEGIBGoiBiAHKQMANwMAIAQgBCkDuBk3A+ADIAQgBCkDuA83A/gDQThBBBCtNiIBRQ1iIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD4AM3AAkgASAEKQP4AzcCICAAQfSEggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGELIARBgB9qIQ4gASACELUiIgsoAhAhASALKAIUQQJ2IQIjAEEwayIHJAACQAJAIAMQkjYiBkUNACAGKAIURQ0AIAMoAhAhBSADKAIUIQggByAGNgIgIAcgAjYCHCAHIAE2AhggB0EANgIUIAcgBSAIQXxxajYCECAHIAU2AgwgB0EkaiEGIwBBIGsiCSQAIAlBFGogB0EMaiIBKAIEIAEoAgBrQQJ2QQBBBEEEEKAYIAkoAhghAiAJKAIUQQFGDW0gCUEQaiIQQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQRBrIggkACAJQQhqIgIgASgCBCABKAIAa0ECdhDuLSAIIAIpAgRCIIk3AgggCCACQQhqNgIEIwBBMGsiAiQAIAhBBGoiDSgCBCEKIA0oAgAhEQJAIAEoAgAiBSABKAIEIg9HBEAgASgCFCEMIAEoAhAhEyABKAIMIRQgASgCCCEBIA0oAgggCkECdGohDSAPIAVrQQJ2IQ8DQCACIAU2AgwCQCATIAUoAgAiEksEQCAUIBJBAnRqKgIAIRsMAQsgASAMKAIQTw14QwAAAAAhGyAMKAIEIAEgDCgCDGoiEkEDdmotAAAgEkEHcXZBAXENeQsgDSAbOAIAIAVBBGohBSANQQRqIQ0gAUEBaiEBIApBAWohCiAPQQFrIg8NAAsLIBEgCjYCACACQTBqJAAMAAsgCEEQaiQAIAZBCGogECgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhBiADKAIUIQUgByACNgIYIAcgATYCFCAHIAYgBUF8cWo2AhAgByAGNgIMIAdBJGoiBiAHQQxqEI4bCyAOIAYQ6BggB0EwaiQAIARBiBVqIgEgCxCSNiADEPISIARBkBpqIgMgDiABEL4dIARBuB5qIgEgCxDKBiABEJMeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVYgBEGfBGoiAyAEQccZaikAADcAACAEQZgEaiIFIARBwBlqKQMANwMAIARBsARqIgggBikDADcDACAEQbgEaiIGIAcpAwA3AwAgBCAEKQO4GTcDkAQgBCAEKQO4DzcDqARBOEEEEK02IgFFDWEgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQBDcACSABIAQpA6gENwIgIABBzIWCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMYAsgBEGAH2ohDiABIAIQpiIiCygCECEBIAsoAhRBA3YhAiMAQTBrIgckAAJAAkAgAxCSNiIGRQ0AIAYoAhRFDQAgAygCECEFIAMoAhQhCCAHIAY2AiAgByACNgIcIAcgATYCGCAHQQA2AhQgByAFIAhBfHFqNgIQIAcgBTYCDCAHQSRqIQYjAEEgayIJJAAgCUEUaiAHQQxqIgEoAgQgASgCAGtBAnZBAEEIQQgQoBggCSgCGCECIAkoAhRBAUYNbCAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiCCQAIAlBCGoiAiABKAIEIAEoAgBrQQJ2EOwtIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEEwayICJAAgCEEEaiINKAIEIQogDSgCACERAkAgASgCACIFIAEoAgQiD0cEQCABKAIUIQwgASgCECETIAEoAgwhFCABKAIIIQEgDSgCCCAKQQN0aiENIA8gBWtBAnYhDwNAIAIgBTYCDAJAIBMgBSgCACISSwRAIBQgEkEDdGorAwAhHAwBCyABIAwoAhBPDXdEAAAAAAAAAAAhHCAMKAIEIAEgDCgCDGoiEkEDdmotAAAgEkEHcXZBAXENeAsgDSAcOQMAIAVBBGohBSANQQhqIQ0gAUEBaiEBIApBAWohCiAPQQFrIg8NAAsLIBEgCjYCACACQTBqJAAMAAsgCEEQaiQAIAZBCGogECgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhBiADKAIUIQUgByACNgIYIAcgATYCFCAHIAYgBUF8cWo2AhAgByAGNgIMIAdBJGoiBiAHQQxqEJMbCyAOIAYQ5xggB0EwaiQAIARBiBVqIgEgCxCSNiADEPISIARBkBpqIgMgDiABENsdIARBuB5qIgEgCxDKBiABEJAeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVQgBEHPBGoiAyAEQccZaikAADcAACAEQcgEaiIFIARBwBlqKQMANwMAIARB4ARqIgggBikDADcDACAEQegEaiIGIAcpAwA3AwAgBCAEKQO4GTcDwAQgBCAEKQO4DzcD2ARBOEEEEK02IgFFDWAgASACOgAIIAFCgYCAgBA3AgAgASAEKQPABDcACSABIAQpA9gENwIgIABBpIaCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMXwsgASACELMiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGELwdIAFB1ABqIgYgAhDKBiAGEPIcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1SIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAHaiAEQbAaaikCADcCACAEQegHaiAEQbgaaikCADcCACAEQckHaiADKQMANwAAIARB0AdqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYByAEIAE6AMAHIAQgFzcAwQcgBEHAB2oQ3CkhASAAQfyGggE2AgggACABNgIEIABBk4CAgHg2AgAMXgsgASACEKEiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMAdIAFB1ABqIgYgAhDKBiAGEPUcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1QIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZAIaiAEQbAaaikCADcCACAEQZgIaiAEQbgaaikCADcCACAEQfkHaiADKQMANwAAIARBgAhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICCAEIAE6APAHIAQgFzcA8QcgBEHwB2oQ3CkhASAAQdSHggE2AgggACABNgIEIABBk4CAgHg2AgAMXQsgASACEJ0iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMMdIAFB1ABqIgYgAhDKBiAGEPocIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1OIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcAIaiAEQbAaaikCADcCACAEQcgIaiAEQbgaaikCADcCACAEQakIaiADKQMANwAAIARBsAhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CCAEIAE6AKAIIAQgFzcAoQggBEGgCGoQ3CkhASAAQayIggE2AgggACABNgIEIABBk4CAgHg2AgAMXAsgASACEK4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENAdIAFB1ABqIgYgAhDKBiAGEPkcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1MIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfAIaiAEQbAaaikCADcCACAEQfgIaiAEQbgaaikCADcCACAEQdkIaiADKQMANwAAIARB4AhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCCAEIAE6ANAIIAQgFzcA0QggBEHQCGoQ3CkhASAAQYSJggE2AgggACABNgIEIABBk4CAgHg2AgAMWwsgASACELgiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEL0dIAFB1ABqIgYgAhDKBiAGEPQcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg1KIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAGaiAEQbAaaikCADcCACAEQdgGaiAEQbgaaikCADcCACAEQbkGaiADKQMANwAAIARBwAZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIBiAEIAE6ALAGIAQgFzcAsQYgBEGwBmoQ3CkhASAAQdyJggE2AgggACABNgIEIABBk4CAgHg2AgAMWgsgASACEKMiIQsjAEHgAGsiBSQAIAsoAhAhASALKAIUQQN2IQYjAEEwayICJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCCADKAIUIQkgAiAHNgIgIAIgBjYCHCACIAE2AhggAkEANgIUIAIgCCAJQXxxajYCECACIAg2AgwgAkEkaiEHIwBBIGsiCSQAIAlBFGogAkEMaiIBKAIEIAEoAgBrQQJ2QQBBBEEIEKAYIAkoAhghBiAJKAIUQQFGDWcgCUEQaiITQQA2AgAgCSAJKAIcNgIMIAkgBjYCCCMAQTBrIgYkACAJQQhqIgggASgCBCABKAIAa0ECdhDqLSAIKQIEIRcgBkEYaiABQRBqKQIANwMAIAZBEGogAUEIaikCADcDACAGIAEpAgA3AwggBiAXQiCJNwIoIAYgCEEIajYCJCMAQTBrIgEkACAGQSRqIg0oAgQhDCANKAIAIRQCQCAGQQhqIggoAgAiCiAIKAIEIg9HBEAgCCgCFCEOIAgoAhAhEiAIKAIMIRUgCCgCCCEIIA0oAgggDEEDdGohDSAPIAprQQJ2IQ8DQCABIAo2AgwCQCASIAooAgAiEEsEQCAVIBBBA3RqIhEoAgQhECARKAIAIREMAQsgCCAOKAIQTw1xQQAhEEEAIREgDigCBCAIIA4oAgxqIhZBA3ZqLQAAIBZBB3F2QQFxDXMLIA0gETYCACANQQRqIBA2AgAgCkEEaiEKIA1BCGohDSAIQQFqIQggDEEBaiEMIA9BAWsiDw0ACwsgFCAMNgIAIAFBMGokAAwACyAGQTBqJAAgB0EIaiATKAIANgIAIAcgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCCACIAY2AhggAiABNgIUIAIgByAIQXxxajYCECACIAc2AgwgAkEkaiIHIAJBDGoQjxsLIAUgBxDrGCACQTBqJAAgBUEMaiIBIAsQkjYgAxDyEiAFQSRqIgIgBSABENMdIAVB1ABqIgEgCxDKBiABEPccIARBkBpqIgFBCGogBUHcAGooAgA2AgAgASAFKQJUNwIAIAEgBSkCMDcCDCABQRRqIAVBOGooAgA2AgAgASAFKQI8NwIYIAFBIGogBUHEAGopAgA3AgAgAUEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAAgBC0AkBoiAUEpRg1IIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAHaiAEQbAaaikCADcCACAEQYgHaiAEQbgaaikCADcCACAEQekGaiADKQMANwAAIARB8AZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4BiAEIAE6AOAGIAQgFzcA4QYgBEHgBmoQ3CkhASAAQbSKggE2AgggACABNgIEIABBk4CAgHg2AgAMWQsgASACEKAiIQsjAEHgAGsiBSQAIAsoAhAhASALKAIUQQR2IQYjAEEwayICJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCCADKAIUIQkgAiAHNgIgIAIgBjYCHCACIAE2AhggAkEANgIUIAIgCCAJQXxxajYCECACIAg2AgwgAkEkaiEHIwBBIGsiCSQAIAlBFGogAkEMaiIBKAIEIAEoAgBrQQJ2QQBBCEEQEKAYIAkoAhghBiAJKAIUQQFGDWYgCUEQaiIQQQA2AgAgCSAJKAIcNgIMIAkgBjYCCCMAQTBrIgYkACAJQQhqIgggASgCBCABKAIAa0ECdhDpLSAIKQIEIRcgBkEYaiABQRBqKQIANwMAIAZBEGogAUEIaikCADcDACAGIAEpAgA3AwggBiAXQiCJNwIoIAYgCEEIajYCJCMAQTBrIgEkACAGQSRqIg0oAgQhDCANKAIAIRECQCAGQQhqIggoAgAiCiAIKAIEIg9HBEAgCCgCFCEOIAgoAhAhEyAIKAIMIRQgCCgCCCEIIA0oAgggDEEEdGohDSAPIAprQQJ2IQ8DQCABIAo2AgwCQCATIAooAgAiEksEQCABQRhqIBQgEkEEdGoiEkEIaikDADcDACABIBIpAwA3AxAMAQsgCCAOKAIQTw1wIA4oAgQgCCAOKAIMaiISQQN2ai0AACASQQdxdkEBcQ1yIAFBGGpCADcDACABQgA3AxALIA0gASkDEDcDACANQQhqIAFBGGopAwA3AwAgCkEEaiEKIA1BEGohDSAIQQFqIQggDEEBaiEMIA9BAWsiDw0ACwsgESAMNgIAIAFBMGokAAwACyAGQTBqJAAgB0EIaiAQKAIANgIAIAcgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCCACIAY2AhggAiABNgIUIAIgByAIQXxxajYCECACIAc2AgwgAkEkaiIHIAJBDGoQkhsLIAUgBxDqGCACQTBqJAAgBUEMaiIBIAsQkjYgAxDyEiAFQSRqIgIgBSABEMUdIAVB1ABqIgEgCxDKBiABEPEcIARBkBpqIgFBCGogBUHcAGooAgA2AgAgASAFKQJUNwIAIAEgBSkCMDcCDCABQRRqIAVBOGooAgA2AgAgASAFKQI8NwIYIAFBIGogBUHEAGopAgA3AgAgAUEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAAgBC0AkBoiAUEpRg1GIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAHaiAEQbAaaikCADcCACAEQbgHaiAEQbgaaikCADcCACAEQZkHaiADKQMANwAAIARBoAdqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoByAEIAE6AJAHIAQgFzcAkQcgBEGQB2oQ3CkhASAAQYyLggE2AgggACABNgIEIABBk4CAgHg2AgAMWAsgBEGAH2oiBiABIAIQpyIiASgCECABKAIUQQJ2IAMQvxYgBEGIFWoiAiABEJI2IAMQ8hIgBEGQGmoiAyAGIAIQyh0gBEG4HmoiAiABEMoGIAIQ0BggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNRCAEQf8EaiIDIARBxxlqKQAANwAAIARB+ARqIgUgBEHAGWopAwA3AwAgBEGQBWoiCCAGKQMANwMAIARBmAVqIgYgBykDADcDACAEIAQpA7gZNwPwBCAEIAQpA7gPNwOIBUE4QQQQrTYiAUUNWCABIAI6AAggAUKBgICAEDcCACABIAQpA/AENwAJIAEgBCkDiAU3AiAgAEHki4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxXCyAEQYAfaiIGIAEgAhCrIiIBKAIQIAEoAhRBA3YgAxDAFiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDGHSAEQbgeaiICIAEQygYgAhDSGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1CIARBrwVqIgMgBEHHGWopAAA3AAAgBEGoBWoiBSAEQcAZaikDADcDACAEQcAFaiIIIAYpAwA3AwAgBEHIBWoiBiAHKQMANwMAIAQgBCkDuBk3A6AFIAQgBCkDuA83A7gFQThBBBCtNiIBRQ1XIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDoAU3AAkgASAEKQO4BTcCICAAQbyMggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFYLIARBgB9qIQggASACELwiIgUoAhAhAiAFKAIUQQR2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhCSADKAIUIQogASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgCSAKQXxxajYCECABIAk2AgwgAUEkaiEGIwBBIGsiCSQAIAlBFGogAUEMaiIHKAIEIAcoAgBrQQJ2QQBBEEEQEKAYIAkoAhghAiAJKAIUQQFGDWIgCUEQaiILQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQRBrIgIkACAJQQhqIgogBygCBCAHKAIAa0ECdhDrLSACIAopAgRCIIk3AgggAiAKQQhqNgIEIAcgAkEEahCrECACQRBqJAAgBkEIaiALKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhCSABIAY2AhggASACNgIUIAEgByAJQXxxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQmBsLIAggBhDsGCABQTBqJAAgBEGIFWoiASAFEJI2IAMQ8hIgBEGQGmoiAyAIIAEQyx0gBEG4HmoiASAFEMoGIAEQ0xggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQCAEQd8FaiIDIARBxxlqKQAANwAAIARB2AVqIgUgBEHAGWopAwA3AwAgBEHwBWoiCCAGKQMANwMAIARB+AVqIgYgBykDADcDACAEIAQpA7gZNwPQBSAEIAQpA7gPNwPoBUE4QQQQrTYiAUUNViABIAI6AAggAUKBgICAEDcCACABIAQpA9AFNwAJIAEgBCkD6AU3AiAgAEGUjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxVCyAEQYAfaiEPIAEgAhCpIiIMKAIQIQIgDCgCFEEFdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF8cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIgkkACAJQRRqIAFBDGoiBSgCBCAFKAIAa0ECdkEAQRBBIBCgGCAJKAIYIQIgCSgCFEEBRg1hIAlBEGoiEUEANgIAIAkgCSgCHDYCDCAJIAI2AggjAEEwayIHJAAgCUEIaiICIAUoAgQgBSgCAGtBAnYQ7y0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiIOKAIEIQogDigCACETAkAgB0EIaiIFKAIAIgggBSgCBCIQRwRAIAUoAhQhDSAFKAIQIRQgBSgCDCESIAUoAgghCyAOKAIIIApBBXRqIQUgECAIa0ECdiEQA0AgAiAINgIMAkAgFCAIKAIAIg5LBEAgEiAOQQV0aiIOKQMYIRcgDikDECEYIA4pAwghGSAOKQMAIRoMAQsgCyANKAIQTw1sQgAhGkIAIRlCACEYQgAhFyANKAIEIAsgDSgCDGoiDkEDdmotAAAgDkEHcXZBAXENbQsgBSAaNwMAIAVBGGogFzcDACAFQRBqIBg3AwAgBSAZNwMIIAhBBGohCCAFQSBqIQUgC0EBaiELIApBAWohCiAQQQFrIhANAAsLIBMgCjYCACACQTBqJAAMAAsgB0EwaiQAIAZBCGogESgCADYCACAGIAkpAgg3AgAgCUEgaiQADAELIAMoAhAhByADKAIUIQUgASAGNgIYIAEgAjYCFCABIAcgBUF8cWo2AhAgASAHNgIMIAFBJGoiBiABQQxqEIcbCyAPIAYQ7RggAUEwaiQAIARBiBVqIgEgDBCSNiADEPISIARBkBpqIgMgDyABEM4dIARBuB5qIgEgDBDKBiABENEYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDT4gBEGPBmoiAyAEQccZaikAADcAACAEQYgGaiIFIARBwBlqKQMANwMAIARBoAZqIgggBikDADcDACAEQagGaiIGIAcpAwA3AwAgBCAEKQO4GTcDgAYgBCAEKQO4DzcDmAZBOEEEEK02IgFFDVUgASACOgAIIAFCgYCAgBA3AgAgASAEKQOABjcACSABIAQpA5gGNwIgIABB7I2CATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVAsgBEEYaiABIAIoAhARAAAgBEGQGmoiASAEKAIYIgIgBCgCHCgCDBEAACACRQ0fIAQpA5AaQoqizeWiwqqJaoUgBCkDmBpCi7L53s2au945hYRQRQ0fIAEgAiADEPUoIAEQ9ikhASAAQeCOggE2AgggACABNgIEIABBk4CAgHg2AgAMUwsgBi0AAUEBaw4DBgcIBQsgBi0AAQ4CCgs6CyAGLQABQQJrDgILDDkLIARBIGogASACKAIQEQAAIARBkBpqIgcgBCgCICIBIAQoAiQoAgwRAAAgAUUNHCAEKQOQGkLA47Xe0v6llSyFIAQpA5gaQvXOqKjR/trMpH+FhFBFDRwgBigCBCEMIwBBQGoiAiQAIAIgARCSNjYCCCADKAIUIQYgAygCECEDIAIgATYCPCACIAM2AjAgAiADIAZBfHFqNgI0IAIgAkEIajYCOCACQRxqIQUjAEFAaiIDJAAgA0GTgICAeDYCCCADQTBqIAJBMGoiAUEIaikCADcDACADIAEpAgA3AyggAyADQQhqNgI4IANBHGohCCMAQTBrIgEkACABQQxqIANBKGoiBhDxIAJAAkACQCABKAIMQQFGBEAgASgCFCENIAEoAhAhDiABQRhqIgpBBEEAQQRBCBCgGCABKAIcIQkgASgCGEEBRg0CIAEoAiAiCyANNgIEIAsgDjYCACABQQhqIg1BATYCACABIAs2AgQgASAJNgIAIAFBKGogBkEQaigCADYCACABQSBqIAZBCGopAgA3AwAgASAGKQIANwMYIwBBEGsiBiQAIAZBBGogChDxICAGKAIEQQFGBEADQCAGKAIMIQsgBigCCCEOIAEoAggiCSABKAIARgRAIAEgCUEBQQRBCBDeKAsgASgCBCAJQQN0aiIPIAs2AgQgDyAONgIAIAEgCUEBajYCCCAGQQRqIAoQ8SAgBigCBA0ACwsgBkEQaiQAIAhBCGogDSgCADYCACAIIAEpAgA3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyABQTBqJAAMAQsgCSABKAIgQYj5gwEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgBSADKQIINwIAIAVBEGogA0EYaigCADYCACAFQQhqIANBEGopAgA3AgAgCBDqOwwBCyAFIAMpAhw3AgQgBUGTgICAeDYCACAFQQxqIANBJGooAgA2AgALIANBQGskACACKAIoIQMgAigCJCEBIAIoAiAhBgJAIAIoAhwiBUGTgICAeEcEQCAHIAIoAiw2AhQgByADNgIQIAcgATYCDCAHIAY2AgggByAFNgIEIAdBKToAAAwBCyACIAY2AhQgAiABNgIMIAIgATYCECACIAEgA0EDdGo2AhggByACQQxqIAwQugYLIAJBQGskACAELQCQGiIBQSlHDQ0gBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMTwsgBEEoaiABIAIoAhARAAAgBEGQGmoiByAEKAIoIgkgBCgCLCgCDBEAACAJRQ0cIAQpA5AaQv/Z66rX2IuM8QCFIAQpA5gaQoH04aOq+Nbqi3+FhFBFDRwgBigCBCEBIwBBgARrIgIkACACQcgCaiADQQxqIgYQ2zwgAWwQ8h4CQAJAAkACQAJAIAYQ2zwiDwRAIAkoAiwhECADKAIQIQggAkHUAmohDANAAkAgAyAFEIs7RQRAIAwQ5jogAigC1AJFDQQgAigC5AIgAWoiDUEDdiANQQdxQQBHaiIKIAIoAuACIgtLBEAgCiALayEOIAIoAtgCIhEgCkkEQCAMIBFBAXQiCyAKENIqIhEgCyARSxsQ6BkgAigC4AIhCwsgDgRAIAIoAtwCIAtqQQAgDvwLAAsgAiAKNgLgAgsgAiANNgLkAiACQcgCaiABELQlDAELIAIgBTYC6AMgBhDbPCAFTQ0EIAJByAJqIAgoAgAgEGwiCiABIApqEIgPCyAIQQRqIQggDyAFQQFqIgVHDQALCyACQeAAaiACQcgCaiIBENQUIAEQvC0CQCACLQBgIgFBKUYEQCACQdsAaiACQfQAaigCACIBNgAAIAJB0wBqIAJB7ABqKQIAIhc3AAAgAiACKQJkIhg3AEsgB0EUaiABNgAAIAdBDGogFzcAACAHIBg3AAQgB0EpOgAADAELIAJB1wBqIgUgAkHwAGopAAA3AAAgAkHQAGoiCCACQekAaikAADcDACACQThqIAJBgAFqKQIANwIAIAJBQGsgAkGIAWopAgA3AgAgAkEhaiAIKQMANwAAIAJBKGogBSkAADcAACACIAIpAGEiFzcDSCACIAIpAng3AjAgAiAXNwAZIAIgAToAGCACQcgCaiAJKAIMIAkoAhAiASgCCEEBa0F4cWpBCGogASACQRhqIgEQiAEgAigC0AIhCyACKALMAiEMIAIoAsgCIgVBk4CAgHhHBEAgByACKQLUAjcCECAHIAs2AgwgByAMNgIIIAcgBTYCBCAHQSk6AAAgARD+JAwBC0HAACEKIAYQ2zwiAUEDdiABQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIgFBwAAQ0TRFDQMgAQRAIAFBwAAQrTYiCkUNYgtBACEFIAJBADYC1AIgAiAKNgLQAiACIAE2AswCIAJBwAA2AsgCIAJByABqIgEgAkHIAmogCBDSJSACQRBqIAEQhj0gAigCFCEBIAIoAhAhDSAGENs8Ig4EQCADKAIQIQgDQCACIAU2AvwDIAYQ2zwgBU0NBiAIKAIAIQoCQCADIAUQizsEQCAJIAoQmiVFDQELIAVBA3YiCiABTw1sIAogDWoiCiAKLQAAQX4gBUEHcXdxOgAACyAIQQRqIQggDiAFQQFqIgVHDQALCyACQegCaiAJEMoGIAYQ2zwhASACQQA7AaADIAJBADYCnAMgAkEANgKEAyACQQA2AvgCIAIgATYC9AIgAkIENwLgAiACQgA3AtgCIAJCgICAgMAANwLQAiACQQA2AsgCIAIoAlAhASACKAJUIQMgAiACKQJINwJsIAJBADYCaCACIAM2AmQgAiABNgJgIAJBCGogAkHgAGoQ1zsgAigCCCEGQRxBBBCtNiIBRQ1WIAFCgYCAgBA3AgAgASACKQJgNwIIIAFBEGogAkHoAGopAgA3AgAgAUEYaiACQfAAaigCADYCACACIAM2AvQDIAIgBjYC8AMgAiABNgLsAyACQewBaiIDIAJByAJqIgEgAkHsA2oQrhYgAkEANgLAAiABIAwgCxDTIyACQZABaiIGIAMgARDvJSACQaQDaiIBIAYQzRwgByABENwUIAJBGGoQ/iQLIAJBgARqJAAMBAtB/PSBARCyOwALIAIgAxD8OzYC/AMgAkECNgIcIAJBiPGBATYCGCACQgI3AiQgAkE7NgL4AyACQTs2AvADIAIgAkHsA2o2AiAgAiACQfwDajYC9AMgAiACQegDajYC7AMgAkEYakGY8YEBEO8sAAtBwPSBAUEpIAJByAJqQcz8gQFB7PSBARDVHgALIAIgAxD8OzYC7AMgAkECNgLMAiACQYjxgQE2AsgCIAJCAjcC1AIgAkE7NgJsIAJBOzYCZCACIAJB4ABqNgLQAiACIAJB7ANqNgJoIAIgAkH8A2o2AmAgAkHIAmpBmPGBARDvLAALIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENs8IAMQ2zwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQvxYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQwBYgAUEMaiIGIAIQkjYgAxDyEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjQIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJwCIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMsWIAdBDGogARCTNiADEPISIAEoAgQhCCAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAIKAIAIgkgCSgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAgpAgQ3AgAgAiAJNgIAIAJBDGohAiALQQxrIQsgCEEMaiEIIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQjgIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCdAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDLFiAHQQxqIAEQkzYgAxDyEiABKAIEIQggB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCCgCACIJIAkoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAIKQIENwIAIAIgCTYCACACQQxqIQIgC0EMayELIAhBDGohCCAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADEOcCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBSABIAIQkSIhCCMAQfAEayIGJAAgCCgCGCENIAgoAhwhCyAGQdgCaiADQQxqIgkQ2zxBAEEIQQgQoBggBigC3AIhAQJAIAYoAtgCQQFHBEAgBkEANgLIBCAGIAYoAuACIgI2AsQEIAYgATYCwAQgBkEANgLUBCAGQoCAgICAATcCzAQgAQR/IAIFIAZBwARqQfCvggEQsyggBigCxAQLQgA3AwAgBkEBNgLIBEHAACEHIAkQ2zwiAUEDdiABQQdxQQBHaiIKQcD///8DcUFAayAKIApBP3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIHRQ1KC0EAIQIgBkEANgLkAiAGIAc2AuACIAYgATYC3AIgBkHAADYC2AIgBkHYBGoiASAGQdgCaiAKENIlIAZBGGogARCGPSAGKAIcIQEgBigCGCEOIAkQ2zwiDwRAIAtBA3YhByADKAIQIRADQAJAAkACQAJAIAMgAhCLO0UEQCACQQN2IgogAU8NWCAKIA5qIgogCi0AAEF+IAJBB3F3cToAACAGKALIBCIKIAYoAsAERgRAIAZBwARqQYCwggEQsygLIAYoAsQEIApBA3RqIBc3AwAgBiAKQQFqNgLIBAwECyAGIAI2AugEIAkQ2zwgAk0NACAQIAJBAnRqKAIAIgwgB08NASAMQQFqIgogB08NAiANIApBA3RqKQMAIhkgDSAMQQN0aikDACIYfSAXfCEXIAYoAsgEIgogBigCwARGBEAgBkHABGpBsLCCARCzKAsgBigCxAQgCkEDdGogFzcDACAGIApBAWo2AsgEIBggGVMEQCAGKALUBCILQQN0IQoDQCAGKALMBCALRgRAIAZBzARqQcCwggEQsygLIAYoAtAEIApqIBg3AwAgBiALQQFqIgs2AtQEIApBCGohCiAZIBhCAXwiGFINAAsLIAggDBCSOw0DIAJBA3YiCiABTw1XIAogDmoiCiAKLQAAQX4gAkEHcXdxOgAADAMLIAYgAxD8OzYC7AQgBkECNgLcAiAGQYjxgQE2AtgCIAZCAjcC5AIgBkE7NgIsIAZBOzYCJCAGIAZBIGo2AuACIAYgBkHsBGo2AiggBiAGQegEajYCICAGQdgCakGY8YEBEO8sAAsgDCAHQZCwggEQwyEACyAKIAdBoLCCARDDIQALIAJBAWoiAiAPRw0ACwsgBkEoaiAGQdQEaigCADYCACAGIAYpAswENwMgIAZB5AJqIgEgBkEgahCaEiAGQeACaiAGQcgEaigCADYCACAGIAYpAsAEIhg3A9gCIAYpAtwCIRcgBkG4A2ogAUEw/AoAACAGQYgBaiAGQeAEaikCADcDACAGIAYpAtgENwOAAQJAAkAgGKciAkGAgICAeEYEQCAGQdgAaiAGQcADaigCACIBNgIAIAYgBikCuAMiGDcDUCAFQRRqIAE2AgAgBSAYNwIMIAUgFzcCBCAFQSk6AAAMAQsgBkHQAGoiAyAGQbgDakEw/AoAACAGQeAEaiAGQYgBaikDADcDACAGIAYpA4ABNwPYBCAGQSBqIgEgA0Ew/AoAACAGIBc3AoQBIAYgAjYCgAEgBkHYAmogCCgCDCAIKAIQIgIoAghBAWtBeHFqQQhqIAIgARCKASAGKALgAiEHIAYoAtwCIQogBigC2AIiAkGTgICAeEcEQCAFIAYpAuQCNwIQIAUgBzYCDCAFIAo2AgggBSACNgIEIAVBKToAACAGQdgEahDPLyAGQYABahDjPCABEP4kDAELIAZBuANqIgIgBkGAAWoQ3iwgBiAGKQK4AzcC5AIgBkEANgLgAiAGIAYoAsQDIgs2AtwCIAYgBigCwAM2AtgCIAZBEGogBkHYAmoiAxDXOyAGKAIQIQxBHEEEEK02IgFFDUAgAUKBgICAEDcCACABIAYpAtgCNwIIIAFBEGogBkHgAmopAgA3AgAgAUEYaiAGQegCaigCADYCACAGIAs2ApwBIAYgDDYCmAEgBiABNgKUASAGQfgCaiAIEMoGIAkQ2zwhASAGQQA7AbADIAZBADYCrAMgBkEANgKUAyAGQQA2AogDIAYgATYChAMgBkIENwLwAiAGQgA3AugCIAZCgICAgMAANwLgAiAGQQA2AtgCIAYoAuAEIQEgBigC5AQhCCAGIAYpA9gENwLEAyAGQQA2AsADIAYgCDYCvAMgBiABNgK4AyAGQQhqIAIQ1zsgBigCCCEJQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAGKQK4AzcCCCABQRBqIAZBwANqKQIANwIAIAFBGGogBkHIA2ooAgA2AgAgBiAINgJYIAYgCTYCVCAGIAE2AlAgBkH8AWoiASADIAZB0ABqEK4WIAZBADYC0AIgAiAKIAcQ0yMgAyABIAIQ7yUgBkGgAWoiASADIAZBlAFqEPojIAZB/ANqIgIgARDNHCAFIAIQrh8gBkEgahD+JAsgBkHwBGokAAwDCww+C0HA9IEBQSkgBkHYAmpBzPyBAUHs9IEBENUeAAsgASAGKALgAkHgr4IBEP0vAAsgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQgjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQojAEEwayIBJAAgAUEIaiACQSBqIgcQgygCQAJAAkAgASgCCCILBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIJIA02AgQgCSALNgIAIAFBHGoiD0EBNgIAIAEgCTYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQgyggBSgCCCIJBEAgAUEUaiELIAUoAgwhBwNAIAsoAggiDSALKAIARgRAIAtBARDqLQsgCygCBCANQQN0aiIQIAc2AgQgECAJNgIAIAsgDUEBajYCCCAFIAwQgyggBSgCBCEHIAUoAgAiCQ0ACwsgBUEQaiQAIApBCGogDygCADYCACAKIAEpAhQ3AgAMAQsgCkEANgIIIApCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCCACKQIANwIAIAhBEGogAkEQaigCADYCACAIQQhqIAJBCGopAgA3AgAgChDDJyAKEOo7DAELIAggAikCFDcCBCAIQZOAgIB4NgIAIAhBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIJEP8YIAkgAxDALSAEIA42ArQaIwBBMGsiByQAIAdBDGohDSMAQUBqIgYkACAGQQhqIAlBKPwKAAAgBigCCCIKEL88IQEgBigCJCECIAoQvzwaQcAAIQUCQEF/IAEgAmsiAUEHaiIIIAEgCEsbIgFBA3YiCEHA////AXFBQGsgCCABQfgDcRsiAUHAABDRNARAIAEEQCABQcAAEK02IgVFDUgLIAZBADYCPCAGIAU2AjggBiABNgI0IAZBwAA2AjAgBkEMaiEOIAYoAiwhDyAGKAIYIRAgBigCECERIAYoAhwhEyAGKAIMIQsgBigCKCEBQQAhBUEBIQgDQAJAAkACQCABIAJGIhRFBEACfyALBEAgAiATTw0DQQAgESACIBBqIgxBA3ZqLQAAQf8BcyAMQQdxdkEBcQ0BGgsgCEEAIA8gCigCECACQQJ0aigCABCTOxsLIAVyIQUgAkEBaiECIAhBAXQiCEH+AXENBCAGIAI2AiQMAgsgBiABNgIkIAEhAiAIQf8BcUEBRw0BDAILQZz4gwFBIEG8+IMBEJ8pAAsCQCAGKAI8IgwgBigCNEcNACAKEL88IQggChC/PBogBigCPCIMQX8gCCACayIIQQdqIhIgCCASSxtBA3ZqQQFqIgggBigCNE0NACAIENUqIQggBkEwaiAGKAI0QQF0IgwgCCAIIAxJGxDoGSAGKAI8IQwLIAYoAjggDGogBToAAEEBIQggBiAMQQFqNgI8QQAhBSAURQ0BCwsgDSAGKQIwNwIAIA1BCGogBkE4aikCADcCAAJAIAtFDQAgCyALKAIAIgFBAWs2AgAgAUEBRw0AIA4Q+x4LIAZBQGskAAwBC0HM+IMBQSkgBkEwakGY+YMBQfj4gwEQ1R4ACyAHIAcpAgw3AiggB0EANgIkIAcgBygCGCIGNgIgIAcgBygCFDYCHCAHIAdBHGoQ1zsgBygCACEFQRxBBBCtNiIBRQ06IAFCgYCAgBA3AgAgASAHKQIcNwIIIARBhBFqIgIgBjYCCCACIAU2AgQgAiABNgIAIAFBEGogB0EkaikCADcCACABQRhqIAdBLGooAgA2AgAgB0EwaiQAIAQoAsAPBEAgBEGQFWogBEHAD2ooAgA2AgAgBEGcFWogBEGMEWooAgA2AgAgBCAEKQK4DzcDiBUgBCAEKQKEETcClBUgCSAEQYgVahCtECAJEOUpIQEgAEG4nYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDkLIARBkBpqIgEgBEGEEWpBACADQQxqIgIQ2zwQ8hUgBEGIFWoiAyABEOEnIAEgAhDbPCADENUYIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oiABDuHyAAEOg7DDgLIAZBBGohByAGLQABDQsgBEH8GGogBygCBBDqIyAEQdgAaiABIAIoAhARAAAgBEGQGmogBCgCWCICIAQoAlwoAgwRAAAgAkUNBiAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQYgBEGAH2ogAigCHCACKAIgIAMQwRYgBEHQAGogBxCwLiAEKAJQIgEgBCgCVCIKRg0KA0AgBEGQGmogAiABLQAAENkoQYifggEgAxCIASAEKAKYGiEFIAQoApQaIQggBCgCkBoiCUGTgICAeEcEQCAAIAQpApwaNwIMIAAgBTYCCCAAIAg2AgQgACAJNgIAIAQoAoAfIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQYAfahD7HgsgBEH8GGoiABDDJyAAEOo7DDkLIAQoAoQZIgkgBCgC/BhGBEAgBEH8GGpB4J+CARCbKAsgBCgCgBkgCUEDdGoiCyAFNgIEIAsgCDYCACAEIAlBAWo2AoQZIAFBCGoiASAKRw0ACwwKCyABIAcRBAAiBi0AAEEiRg0IIAQgBjYCuA8gBEEBNgKUGiAEQeymggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB9KaCARDvLAALIARBkBpqIgYgASACEMcvEI8OIARBuA9qIgUgBhD8FSAGIAUgAxDnAiAELQCQGiICQSlGDQYgBEGXFWoiAyAEQaAaaikAADcAACAEQZAVaiIIIARBmRpqKQAANwMAIARBkBBqIARBsBpqKQIANwIAIARBmBBqIARBuBpqKQIANwIAIARBoBBqIARBwBpqKQIANwIAIARB+Q9qIAgpAwA3AAAgBEGAEGogAykAADcAACAEIAQpAqgaNwKIECAEIAI6APAPIAQgBCkAkRo3APEPIARBiBVqIgIgBEHwD2oQhD4gBiACEKEbIAIgASAHEQQAEMoGIARBqBBqIgEgBiACEIwYIAIgARDNHCAGIAIQuAYgBhD3KSEBIABBhKeCATYCCCAAIAE2AgQgAEGTgICAeDYCACAFEMkeDDULIAEgBxEEACIGLQAAQShGDQQgBCAGNgK4DyAEQQE2ApQaIARB/KqCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGEq4IBEO8sAAtB0I6CARCyOwALQYCXggEQsjsAC0H4m4IBELI7AAtBoJ6CARCyOwwFCwJAAkACQAJAAkACQCAGKAIEIgYtADBBA2sOAwECAwALIAQgBkEwajYCuA8gBEEBNgKUGiAEQbCqggE2ApAaIARCATcCnBogBEGnBDYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpBuKqCARDvLAALIARBkBpqIQ0gASACEJwiIQ4jAEHgBGsiBSQAAkACQAJAAkACQAJ/AkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEGIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgBiEHIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIghPDU0gBigCACIDIAhPDU5BAiEKAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBJIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAhPDVUgASgCACIBIAhPDVYgDyAJQQJ0aigCACAPIAFBAnRqKAIASQ0CIAMhASAMIApBAWoiCkcNAAsMAgsgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIJIAhPDVQgASgCACIBIAhPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATw0BIAMhASAMIApBAWoiCkcNAAsMAQsgCiAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQoDQCAHKAIAIQEgByAKKAIANgIAIAogATYCACAKQQRrIQogB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOcKDAILDFALIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuRUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUIgBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQggEQRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohB0EAIQEDQAJ/IAtFBEAgCCAHIAMiBkcNARoMBQsgCyAHIANrQQF2Tw0EIAMgC0EBdGohBiAIIAtqCyIMQQFqIQggBkECaiEDQQAhCyABIAJPDQAgAUECdCEKIAYuAQAgEWshDwNAIAEgBSgCVCIGTw1GIAUoAlAgCmooAgAiBiACTw1HIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NSCAFKALYAyATaiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRSAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUUgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIglBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEEaiIIIAUoAjwiBksEQCAFQThqIAZBAXQiBiAIENIqIgggBiAISxsQ6BkgBSgCRCIKQQRqIQggBSgCPCEGCyAGIAhJBH8gBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQFIAoLIAUoAkBqIAE2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCADQYCAAk8NCSAFKAIsIgZBAmoiASAFKAIkIghLBEAgBUEgaiAIQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCCAFKAIsIgZBAmohAQsgASAISwR/IAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADOwAAIAUgBSgCLEECajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCUcNAAsgCUEBayEIIAUoAkQhASAFKAI8DAMLIAEgBSgCVCIDTw1DIAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQJ0aigCADYCICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMQgsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAgsgCUUNAkEBIQdBACEBIAUoAhQhAkEAIQhBwAALIQMgAiAIQQJ0aigCACEGIAMgAUEEaiICSQRAIAVBOGogA0EBdCIBIAIQ0ioiAiABIAJLGxDoGSAFKAI8IQMgBSgCRCIBQQRqIQILIAIgA0sEfyAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCRAUgAQsgBSgCQGogBjYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAlBgIACTw0CIAUoAiwiAkECaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQJqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCTsAACAFIAUoAixBAmoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGDhowYNgIAIAVCg4aMmLDgwIEDNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ06IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIKKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgsgARDNHCAIQYiQoMAANgIAIAVCiJCgwICBgoQINwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ06IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAKKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQuRMgAyAOQSBqQYifggEgAUHEg4IBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgCxCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCfCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQbCvggEQsjsAC0HQr4IBELI7AAsgBC0AkBoiAUEpRg0DIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbgWaiAEQbAaaikCADcCACAEQaEWaiADKQMANwAAIARBqBZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKwFiAEIAE6AJgWIAQgFzcAmRYgBEGYFmoQ9SkhASAAQdynggE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgBEGQGmohDSABIAIQmiIhDiMAQeAEayIFJAACQAJAAkACfwJAAkACQAJAIAMoAhQiAUEDTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIREgDigCGCETIAVBzABqIAFBAnYiAkG8/IEBEKQaIAUoAlAhBiAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAYhByABDQEgBigCBCIJIAVB1ANqIhQoAgAiASgCBCIITw1KIAYoAgAiAyAITw1LQQIhCgJAAkACQAJAIAEoAgAiDyAJQQJ0aigCACAPIANBAnRqKAIASSISRQRAIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1SIAEoAgAiASAITw1TIA8gCUECdGooAgAgDyABQQJ0aigCAEkNAiADIQEgDCAKQQFqIgpHDQALDAILIAxBAkYNACAHQQRqIQEDQCABQQRqIgMoAgAiCSAITw1RIAEoAgAiASAITw0EIA8gCUECdGooAgAgDyABQQJ0aigCAE8NASADIQEgDCAKQQFqIgpHDQALDAELIAogDEcNAQsgEkUNAyAMQQF2IQMgDEECdCAHakEEayEKA0AgBygCACEBIAcgCigCADYCACAKIAE2AgAgCkEEayEKIAdBBGohByADQQFrIgMNAAsMAwsgByAMQQAgDEEBcmdBAXRBPnMgFBDjCgwCCwxNCyAMQQJ0IQFBBCEHA0AgBiAGIAdqIAVB1ANqELkVIAEgB0EEaiIHRw0ACwsCQAJAIAxFDQAgBiAMQQJ0akEEayIBRQ0AIAEoAgAiASACTw0/IAUgECABQQJ0aigCACIBNgLcBCABIBNJBEBBACEIIBEEQCAOQQxqQQAQ3xkhCwsgBUHUA2pBACACQcjxgQEQsxUgDigCECIDIA4oAhRBfHFqIQdBACEBA0ACfyALRQRAIAggByADIgZHDQEaDAULIAsgByADa0ECdk8NBCADIAtBAnRqIQYgCCALagsiDEEBaiEIIAZBBGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBFrIQ8DQCABIAUoAlQiBk8NQyAFKAJQIApqKAIAIgYgAk8NRCAQIAZBAnQiE2ooAgAgD08NASAGIAUoAtwDIglPDUUgBSgC2AMgE2ogDDYCACAKQQRqIQogAiABQQFqIgFHDQALIAIhAQwACwALIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYC2AMgBSAFQdQDajYCgAMgBSAFQdwEajYC1AMgBUGgAmogBUH4AmoQmQ4MBAtBqPGBARCyOwALIAEgAkkNASAFQagCaiAFQdwDaigCADYCACAFIAUpAtQDNwKgAiAFQcwAahDpOwsgBUEYaiAFQagCaigCADYCACAFIAUpAqACNwMQQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUIgBUIANwIsIAUgATYCKCAFQsCAgICACDcCIEHAAEHAABDRNEUNQ0HAAEHAABCtNiIBRQ1CIAVCADcCRCAFIAE2AkAgBULAgICAgAg3AjggBSgCGCIJQQJJDQJBASEHQQEhAwNAIAUoAhQiAiADQQJ0aiIBKAIAIAFBBGsoAgAiAUcEQCAFKAJEIgpBBGoiCCAFKAI8IgZLBEAgBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQiCkEEaiEIIAUoAjwhBgsgBiAISQR/IAVBOGogBkEBdCIGIAgQ0ioiCCAGIAhLGxDoGSAFKAJEBSAKCyAFKAJAaiABNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIISwRAIAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQggBSgCLCIGQQRqIQELIAEgCEsEfyAFQSBqIAhBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAlHDQALIAlBAWshCCAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQCACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD8LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAlFDQJBASEHQQAhASAFKAIUIQJBACEIQcAACyEDIAIgCEECdGooAgAhBiADIAFBBGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEEaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIAY2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAk2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNNyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCigCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiILIAEQzRwgCEGIkKDAADYCACAFQoiQoMCAgYKECDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyABEJcpIAVBQGsiAigCACEIIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCDYCnAIgBSABENc7IAUoAgAhCEEcQQQQrTYiAkUNNyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCigCADYCACAFIAc2AtwDIAUgCDYC2AMgBSACNgLUAyABIAMgCRD6IyADIAEQzRwgBUGQAWoiASADELkTIAMgDkEgakGIn4IBIAFBxIOCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEcEQCANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAsQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQngkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQtBf0EAQZCvggEQwyEACyAELQCQGiIBQSlGDQEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4BZqIARBsBpqKQIANwIAIARByRZqIAMpAwA3AAAgBEHQFmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgWIAQgAToAwBYgBCAXNwDBFiAEQcAWahD1KSEBIABBtKiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZAaaiENIAEgAhCbIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAIAMoAhQiAUEDTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIREgDigCGCETIAVBzABqIAFBAnYiAkG8/IEBEKQaIAUoAlAhByAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAchBiABDQEgBigCBCIJIAVB1ANqIhQoAgAiASgCBCIITw1IIAYoAgAiAyAITw1JQQIhCgJAAkACQAJAIAEoAgAiDyAJQQJ0aigCACAPIANBAnRqKAIASSISRQRAIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1QIAEoAgAiASAITw1RIA8gCUECdGooAgAgDyABQQJ0aigCAEkNAiADIQEgDCAKQQFqIgpHDQALDAILIAxBAkYNACAGQQRqIQEDQCABQQRqIgMoAgAiCSAITw1PIAEoAgAiASAITw0EIA8gCUECdGooAgAgDyABQQJ0aigCAE8NASADIQEgDCAKQQFqIgpHDQALDAELIAogDEcNAQsgEkUNAyAMQQF2IQMgDEECdCAGakEEayEKA0AgBigCACEBIAYgCigCADYCACAKIAE2AgAgCkEEayEKIAZBBGohBiADQQFrIgMNAAsMAwsgBiAMQQAgDEEBcmdBAXRBPnMgFBDhCgwCCwxLCyAMQQJ0IQFBBCEGA0AgByAGIAdqIAVB1ANqELkVIAEgBkEEaiIGRw0ACwsCQAJAIAxFDQAgByAMQQJ0akEEayIBRQ0AIAEoAgAiASACTw09IAUgECABQQJ0aigCACIBNgLcBCABIBNJBEBBACEHIBEEQCAOQQxqQQAQyBkhCwsgBUHUA2pBACACQcjxgQEQsxUgDigCECIDIA4oAhRBeHFqIQhBACEBA0ACfyALRQRAIAcgCCADIgZHDQEaDAULIAsgCCADa0EDdk8NBCADIAtBA3RqIQYgByALagsiDEEBaiEHIAZBCGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBFrIQ8DQCABIAUoAlQiBk8NQSAFKAJQIApqKAIAIgYgAk8NQiAQIAZBAnQiE2ooAgAgD08NASAGIAUoAtwDIglPDUMgBSgC2AMgE2ogDDYCACAKQQRqIQogAiABQQFqIgFHDQALIAIhAQwACwALIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYC2AMgBSAFQdQDajYCgAMgBSAFQdwEajYC1AMgBUGgAmogBUH4AmoQmQ4MBAtBqPGBARCyOwALIAEgAkkNASAFQagCaiAFQdwDaigCADYCACAFIAUpAtQDNwKgAiAFQcwAahDpOwsgBUEYaiAFQagCaigCADYCACAFIAUpAqACNwMQQcAAQcAAENE0RQ1BQcAAQcAAEK02IgFFDUAgBUIANwIsIAUgATYCKCAFQsCAgICACDcCIEHAAEHAABDRNEUNQUHAAEHAABCtNiIBRQ1AIAVCADcCRCAFIAE2AkAgBULAgICAgAg3AjhBASELIAUoAhgiCEECTwRAIAitIRhBACEDQgEhFwNAIAUoAhQgA2oiAUEEaigCACABKAIAIgFHBEAgBSgCRCIHQQRqIgYgBSgCPCICSwRAIAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEIgdBBGohBiAFKAI8IQILIAIgBkkEfyAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRAUgBwsgBSgCQGogATYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCALQQFqIQsLIANBBGohAyAYIBdCAXwiF1INAAsLIAhBAWshASAIRQ0EIAUoAhQgAUECdGooAgAhAiAFKAJEIgZBBGoiAyAFKAI8IgFLBEAgBUE4aiABQQF0IgEgAxDSKiIDIAEgA0sbEOgZIAUoAkQiBkEEaiEDIAUoAjwhAQsgASADSQR/IAVBOGogAUEBdCIBIAMQ0ioiAyABIANLGxDoGSAFKAJEBSAGCyAFKAJAaiACNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQhqIgMgBSgCJCIBSwRAIAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsIgZBCGohAyAFKAIkIQELIAEgA0kEfyAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLAUgBgsgBUEoaiICKAIAaiAIrTcAACAFIAUoAixBCGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiB0GFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAVBnAJqIgEQlykgAigCACEIIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAINgKcAiAFQQhqIAEQ1zsgBSgCCCEIQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIJKAIANgIAIAUgAzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIIEPojIAVBzABqIgogARDNHCAHQYiQoMAANgIAIAVCiJCgwICBgoQINwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAEQlykgBUFAayICKAIAIQsgBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSALNgKcAiAFIAEQ1zsgBSgCACELQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAJKAIANgIAIAUgBzYC3AMgBSALNgLYAyAFIAI2AtQDIAEgAyAIEPojIAMgARDNHCAFQZABaiIBIAMQuRMgAyAOQSBqQYifggEgAUHEg4IBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4Rg0CIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgChCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwDCyABIAUoAlQiA08NPiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDD0LIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEKAJIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAELIAFBAEGQr4IBEMMhAAsgBC0AkBoiAUEpRwRAIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYgXaiAEQbAaaikCADcCACAEQfEWaiADKQMANwAAIARB+BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKAFyAEIAE6AOgWIAQgFzcA6RYgBEHoFmoQ9SkhASAAQYypggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMLwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAgBEG4D2oQyR4MLgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIEIgYtAABBAmsOCAECAwQFBgcIAAsgBCAGNgK4DyAEQQE2ApQaIARBnKaCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGkpoIBEO8sAAsgBEGQGmohBiABIAIQxCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4RYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0NIARBiBVqIgIgBkHEAPwKAAAgBEHXEWogBEHXGmotAAA6AAAgBCAELwDVGjsA1REgBEGQEWoiAyACQcQA/AoAACAEIAE6ANQRIAMQ6ykhASAAQZCgggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGQGmohBiABIAIQwSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0LIARBiBVqIgIgBkHEAPwKAAAgBEGfEmogBEHXGmotAAA6AAAgBCAELwDVGjsAnRIgBEHYEWoiAyACQcQA/AoAACAEIAE6AJwSIAMQ6ykhASAAQeigggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBiABIAIQwCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0JIARBiBVqIgIgBkHEAPwKAAAgBEHnEmogBEHXGmotAAA6AAAgBCAELwDVGjsA5RIgBEGgEmoiAyACQcQA/AoAACAEIAE6AOQSIAMQ6ykhASAAQcChggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmohBiABIAIQwyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0HIARBiBVqIgIgBkHEAPwKAAAgBEGvE2ogBEHXGmotAAA6AAAgBCAELwDVGjsArRMgBEHoEmoiAyACQcQA/AoAACAEIAE6AKwTIAMQ6ykhASAAQZiiggE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgBEGQGmohBiABIAIQwiIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4hYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0FIARBiBVqIgIgBkHEAPwKAAAgBEH3E2ogBEHXGmotAAA6AAAgBCAELwDVGjsA9RMgBEGwE2oiAyACQcQA/AoAACAEIAE6APQTIAMQ6ykhASAAQfCiggE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgBEGQGmohBiABIAIQvyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0DIARBiBVqIgIgBkHEAPwKAAAgBEG/FGogBEHXGmotAAA6AAAgBCAELwDVGjsAvRQgBEH4E2oiAyACQcQA/AoAACAEIAE6ALwUIAMQ6ykhASAAQcijggE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgBEGQGmohBiABIAIQviIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQnxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0BIARBiBVqIgIgBkHEAPwKAAAgBEGHFWogBEHXGmotAAA6AAAgBCAELwDVGjsAhRUgBEHAFGoiAyACQcQA/AoAACAEIAE6AIQVIAMQ6ykhASAAQaCkggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGQGmohBiABIAIQvSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQoBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRwRAIARBiBVqIgIgBkHEAPwKAAAgBEGXFmogBEHXGmotAAA6AAAgBCAELwDVGjsAlRYgBEHQFWoiAyACQcQA/AoAACAEIAE6AJQWIAMQ6ykhASAAQfikggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMNAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLQsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQEgBigCCCECIARBwB5qIARBiB9qKAIANgIAIAQgBCkCgB83A7geIARBADYCuBkgBEHAD2ogBEGEGWooAgA2AgAgBCAEKQL8GDcDuA8gBEGQGmogASACIARBuB5qIARBuBlqIARBuA9qEJEEIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4RgRAIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwtCyAEQbAZaiAEQbgaaikCADcCACAEQagZaiAEQbAaaikCADcCACAEQZQZaiABKQMANwIAIARBnBlqIAIoAgA2AgAgBCAEKQKoGjcCoBkgBCADNgKIGSAEIAQpA4gVNwKMGSAEQYgZahDcKSEBIABBsJ6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAwsCyAEQcgAaiABIAIoAhARAAAgBEGQGmoiAiAEKAJIIgEgBCgCTCgCDBEAAAJAAkAgAUUNACAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQAgBEGIFWoiBSABKAIcIAEoAiAgAxDBFiAEQQA2AugZIARBoBpqIARB+BlqKQIANwMAIARBmBpqIARB8BlqKQIANwMAIAQgBCkC6Bk3A5AaIARBuBlqIgggBSACENgdIAEQkzYiCUUNASACIAkoAgQgCSgCCEECdiADEL8WIARBuA9qIgMgAiAEQegZahC/HSAEQUBrIAcQsC4gBCkDQCEXIAQgATYCoBogBCAXNwKQGiAEIAM2ApwaIAQgCDYCmBogBSACELsVIARBwB5qIgEgBEGUFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiAkGTgICAeEcEQCAEKAKYFSEGIAAgBCkDuB43AgQgACAGNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAgAxD+JCAIEP4kDC4LIARBiBpqIARBwB5qKAIANgIAIAQgBCkDuB43A4AaIARBkBpqIgFBAEGABPwLACAEIAQoAsgZIgI2AogVIAQgAiAEQcwZaiIDKAIAajYCjBUgBCABNgKQFSAEQZweaiAEQYgVaiIBELwsIARBsB5qIAMoAgAiAjYCACAEQZwVaiACNgIAIARBqBVqIARB2BlqKQIANwMAIARBsBVqIARB4BlqKQIANwMAIARBkBVqIARBwBlqKAIANgIAIAQgBCkCxBkiFzcDqB4gBCAXNwKUFSAEIAQpAtAZNwOgFSAEIAQpArgZNwOIFSABELQMAkAgBCgCoBUiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEGgFWoQ+x4LIAcoAgAiASABKAIAIgJBAWo2AgAgAkEASA0CIAYoAgghAiAEQYgfaiAEQaQeaigCADYCACAEIAQpApweNwOAHyAEQYgVaiABIAIgBEGoHmogBEGAH2ogBEGAGmoQkQQgBEHAHmoiASAEQZQVaikCADcDACAEQcgeaiICIARBnBVqKAIANgIAIAQgBCkCjBU3A7geIAQoAogVIgNBgICAgHhGBEAgACAEKQO4HjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIARBuA9qEP4kDC4LIARB+B5qIARBsBVqKQIANwIAIARB8B5qIARBqBVqKQIANwIAIARB3B5qIAEpAwA3AgAgBEHkHmogAigCADYCACAEIAQpAqAVNwLoHiAEIAM2AtAeIAQgBCkDuB43AtQeIARB0B5qENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qEP4kDC0LQfCfggEQsjsAC0GAoIIBELI7AAsACyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwpCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwoCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJQsgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADCQLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCMLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCILIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCELIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB8LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB4LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB0LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBwLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBsLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBoLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBgLIARBCGpBxI6CASADEKErIAAgBCkDCDcCBCAAQZOAgIB4NgIADBcLIAQgBjYCuA8gBEEBNgKUGiAEQcirggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB0KuCARDvLAALIARBkwZqIAEoAAAiATYAACAEQYsGaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAgwYgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMFQsgBEHjBWogASgAACIBNgAAIARB2wVqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDTBSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwUCyAEQbMFaiABKAAAIgE2AAAgBEGrBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AKMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBMLIARBgwVqIAEoAAAiATYAACAEQfsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA8wQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCwsgBEHTBGogASgAACIBNgAAIARBywRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDDBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwKCyAEQaMEaiABKAAAIgE2AAAgBEGbBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AJMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAkLIARB8wNqIAEoAAAiATYAACAEQesDaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA4wMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCAsgBEHDA2ogBEGkGmooAgAiATYAACAEQbsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAswMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBwsgBEGTA2ogBEGkGmooAgAiATYAACAEQYsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAgwMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBgsgBEHjAmogBEGkGmooAgAiATYAACAEQdsCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA0wIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBQsgBEGzAmogBEGkGmooAgAiATYAACAEQasCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAowIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBAsgBEGDAmogBEGkGmooAgAiATYAACAEQfsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA8wEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAwsgBEHTAWogBEGkGmooAgAiATYAACAEQcsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAwwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAgsgBEGjAWogBEGkGmooAgAiATYAACAEQZsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAkwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAQsgBEHzAGogBEGkGmooAgAiATYAACAEQesAaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAYyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAsgBEGQH2okAA8LQQRBOBCjPQALQQRBHBCjPQALIAEgAkG48YEBEMMhAAsgASAGQezygQEQwyEACyAGIAJB/PKBARDDIQALIAYgCUGM84EBEMMhAAsgASACQejxgQEQwyEACyABIANB2PGBARDDIQALQcAAQcAAEKM9AAtBwPSBAUEpIAVB+AJqQcz8gQFB7PSBARDVHgALIAIgCSgCHEG8/IEBEP0vAAsgBiAJKAIcQbz8gQEQ/S8AC0HAACABEKM9AAsgCSAIQfD2gwEQwyEACyADIAhBgPeDARDDIQALIAkgCEHw9oMBEMMhAAsgASAIQYD3gwEQwyEAC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyABQQE2AhQgAUHctoIBNgIQIAFCATcCHCABQbsTNgIsIAEgAUEoajYCGCABIAFBDGo2AiggAUEQakHktoIBEO8sAAsgCiABQYD0gQEQwyEAC7DzAgQTfwR+AX0BfCMAQZAfayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwiBxEEACIGLQAAQQJrDiUDBAUGBwgJCgsMDQAAAAAAAQIAAAAAAAAAAAAAAAAAAAAVFhcYAAsgASAHEQQAIggtAAAOKR4YVVVVVVVVVVVVVVUZIyQaG1VVKRwrLC0uLzBVHTJVMzQ1VVVVVTY3VQsgBi0AAUEBaw4DDQ4PDAsgBi0AAUEBaw4CEBEPCyAEQZAaaiABIAIQuyIgAxDfFiAELQCQGiICQSlGDWggBEHvAGoiAyAEQaAaaikAADcAACAEQegAaiIGIARBmRpqKQAANwMAIARBgAFqIgcgBEGwGmopAgA3AwAgBEGIAWoiBSAEQbgaaikCADcDACAEIAQpAJEaNwNgIAQgBCkCqBo3A3hBOEEEEK02IgFFDWogASACOgAIIAFCgYCAgBA3AgAgASAEKQNgNwAJIAEgBCkDeDcCICAAQbT/gQE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGkLIARBkBpqIAEgAhCoIiADEJUWIAQtAJAaIgJBKUYNZiAEQZ8BaiIDIARBoBpqKQAANwAAIARBmAFqIgYgBEGZGmopAAA3AwAgBEGwAWoiByAEQbAaaikCADcDACAEQbgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A5ABIAQgBCkCqBo3A6gBQThBBBCtNiIBRQ1pIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAE3AAkgASAEKQOoATcCICAAQYyAggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGgLIARBkBpqIAEgAhCxIiADEJYWIAQtAJAaIgJBKUYNZCAEQc8BaiIDIARBoBpqKQAANwAAIARByAFqIgYgBEGZGmopAAA3AwAgBEHgAWoiByAEQbAaaikCADcDACAEQegBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A8ABIAQgBCkCqBo3A9gBQThBBBCtNiIBRQ1oIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAE3AAkgASAEKQPYATcCICAAQeSAggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGcLIARBkBpqIAEgAhCkIiADEJcWIAQtAJAaIgJBKUYNYiAEQf8BaiIDIARBoBpqKQAANwAAIARB+AFqIgYgBEGZGmopAAA3AwAgBEGQAmoiByAEQbAaaikCADcDACAEQZgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A/ABIAQgBCkCqBo3A4gCQThBBBCtNiIBRQ1nIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD8AE3AAkgASAEKQOIAjcCICAAQbyBggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGYLIARBkBpqIAEgAhCqIiADEOAWIAQtAJAaIgJBKUYNYCAEQa8CaiIDIARBoBpqKQAANwAAIARBqAJqIgYgBEGZGmopAAA3AwAgBEHAAmoiByAEQbAaaikCADcDACAEQcgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A6ACIAQgBCkCqBo3A7gCQThBBBCtNiIBRQ1mIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDoAI3AAkgASAEKQO4AjcCICAAQZSCggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGULIARBkBpqIAEgAhCtIiADEJgWIAQtAJAaIgJBKUYNXiAEQd8CaiIDIARBoBpqKQAANwAAIARB2AJqIgYgBEGZGmopAAA3AwAgBEHwAmoiByAEQbAaaikCADcDACAEQfgCaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A9ACIAQgBCkCqBo3A+gCQThBBBCtNiIBRQ1lIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AI3AAkgASAEKQPoAjcCICAAQeyCggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGQLIARBkBpqIAEgAhC3IiADEJkWIAQtAJAaIgJBKUYNXCAEQY8DaiIDIARBoBpqKQAANwAAIARBiANqIgYgBEGZGmopAAA3AwAgBEGgA2oiByAEQbAaaikCADcDACAEQagDaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A4ADIAQgBCkCqBo3A5gDQThBBBCtNiIBRQ1kIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDgAM3AAkgASAEKQOYAzcCICAAQcSDggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGMLIARBkBpqIAEgAhCiIiADEJoWIAQtAJAaIgJBKUYNWiAEQb8DaiIDIARBoBpqKQAANwAAIARBuANqIgYgBEGZGmopAAA3AwAgBEHQA2oiByAEQbAaaikCADcDACAEQdgDaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A7ADIAQgBCkCqBo3A8gDQThBBBCtNiIBRQ1jIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDsAM3AAkgASAEKQPIAzcCICAAQZyEggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAGKQMANwAAIAFBGGogAykAADcAACABQShqIAcpAwA3AgAgAUEwaiAFKQMANwIADGILIARBgB9qIgYgASACELkiIgEoAhAgASgCFEEBdiADELoWIARBiBVqIgIgARCSNiADEPISIARBkBpqIgMgBiACEM8dIARBuB5qIgIgARDKBiACEJgeIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDVggBEHvA2oiAyAEQccZaikAADcAACAEQegDaiIFIARBwBlqKQMANwMAIARBgARqIgggBikDADcDACAEQYgEaiIGIAcpAwA3AwAgBCAEKQO4GTcD4AMgBCAEKQO4DzcD+ANBOEEEEK02IgFFDWIgASACOgAIIAFCgYCAgBA3AgAgASAEKQPgAzcACSABIAQpA/gDNwIgIABB9ISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMYQsgBEGAH2ohDiABIAIQtSIiCygCECEBIAsoAhRBAnYhAiMAQTBrIgckAAJAAkAgAxCSNiIGRQ0AIAYoAhRFDQAgAygCECEFIAMoAhQhCCAHIAY2AiAgByACNgIcIAcgATYCGCAHQQA2AhQgByAFIAhBfHFqNgIQIAcgBTYCDCAHQSRqIQYjAEEgayIJJAAgCUEUaiAHQQxqIgEoAgQgASgCAGtBAnZBAEEEQQQQoBggCSgCGCECIAkoAhRBAUYNbSAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiCCQAIAlBCGoiAiABKAIEIAEoAgBrQQJ2EO4tIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEEwayICJAAgCEEEaiINKAIEIQogDSgCACERAkAgASgCACIFIAEoAgQiD0cEQCABKAIUIQwgASgCECETIAEoAgwhFCABKAIIIQEgDSgCCCAKQQJ0aiENIA8gBWtBAnYhDwNAIAIgBTYCDAJAIBMgBSgCACISSwRAIBQgEkECdGoqAgAhGwwBCyABIAwoAhBPDXhDAAAAACEbIAwoAgQgASAMKAIMaiISQQN2ai0AACASQQdxdkEBcQ15CyANIBs4AgAgBUEEaiEFIA1BBGohDSABQQFqIQEgCkEBaiEKIA9BAWsiDw0ACwsgESAKNgIAIAJBMGokAAwACyAIQRBqJAAgBkEIaiAQKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEGIAMoAhQhBSAHIAI2AhggByABNgIUIAcgBiAFQXxxajYCECAHIAY2AgwgB0EkaiIGIAdBDGoQjhsLIA4gBhDoGCAHQTBqJAAgBEGIFWoiASALEJI2IAMQ8hIgBEGQGmoiAyAOIAEQvh0gBEG4HmoiASALEMoGIAEQkx4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNViAEQZ8EaiIDIARBxxlqKQAANwAAIARBmARqIgUgBEHAGWopAwA3AwAgBEGwBGoiCCAGKQMANwMAIARBuARqIgYgBykDADcDACAEIAQpA7gZNwOQBCAEIAQpA7gPNwOoBEE4QQQQrTYiAUUNYSABIAI6AAggAUKBgICAEDcCACABIAQpA5AENwAJIAEgBCkDqAQ3AiAgAEHMhYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxgCyAEQYAfaiEOIAEgAhCmIiILKAIQIQEgCygCFEEDdiECIwBBMGsiByQAAkACQCADEJI2IgZFDQAgBigCFEUNACADKAIQIQUgAygCFCEIIAcgBjYCICAHIAI2AhwgByABNgIYIAdBADYCFCAHIAUgCEF8cWo2AhAgByAFNgIMIAdBJGohBiMAQSBrIgkkACAJQRRqIAdBDGoiASgCBCABKAIAa0ECdkEAQQhBCBCgGCAJKAIYIQIgCSgCFEEBRg1sIAlBEGoiEEEANgIAIAkgCSgCHDYCDCAJIAI2AggjAEEQayIIJAAgCUEIaiICIAEoAgQgASgCAGtBAnYQ7C0gCCACKQIEQiCJNwIIIAggAkEIajYCBCMAQTBrIgIkACAIQQRqIg0oAgQhCiANKAIAIRECQCABKAIAIgUgASgCBCIPRwRAIAEoAhQhDCABKAIQIRMgASgCDCEUIAEoAgghASANKAIIIApBA3RqIQ0gDyAFa0ECdiEPA0AgAiAFNgIMAkAgEyAFKAIAIhJLBEAgFCASQQN0aisDACEcDAELIAEgDCgCEE8Nd0QAAAAAAAAAACEcIAwoAgQgASAMKAIMaiISQQN2ai0AACASQQdxdkEBcQ14CyANIBw5AwAgBUEEaiEFIA1BCGohDSABQQFqIQEgCkEBaiEKIA9BAWsiDw0ACwsgESAKNgIAIAJBMGokAAwACyAIQRBqJAAgBkEIaiAQKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEGIAMoAhQhBSAHIAI2AhggByABNgIUIAcgBiAFQXxxajYCECAHIAY2AgwgB0EkaiIGIAdBDGoQkxsLIA4gBhDnGCAHQTBqJAAgBEGIFWoiASALEJI2IAMQ8hIgBEGQGmoiAyAOIAEQ2x0gBEG4HmoiASALEMoGIAEQkB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNVCAEQc8EaiIDIARBxxlqKQAANwAAIARByARqIgUgBEHAGWopAwA3AwAgBEHgBGoiCCAGKQMANwMAIARB6ARqIgYgBykDADcDACAEIAQpA7gZNwPABCAEIAQpA7gPNwPYBEE4QQQQrTYiAUUNYCABIAI6AAggAUKBgICAEDcCACABIAQpA8AENwAJIAEgBCkD2AQ3AiAgAEGkhoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxfCyABIAIQsyIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQvB0gAUHUAGoiBiACEMoGIAYQ8hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDVIgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4AdqIARBsBpqKQIANwIAIARB6AdqIARBuBpqKQIANwIAIARByQdqIAMpAwA3AAAgBEHQB2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgHIAQgAToAwAcgBCAXNwDBByAEQcAHahDcKSEBIABB/IaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxeCyABIAIQoSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwB0gAUHUAGoiBiACEMoGIAYQ9RwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDVAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBkAhqIARBsBpqKQIANwIAIARBmAhqIARBuBpqKQIANwIAIARB+QdqIAMpAwA3AAAgBEGACGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AogIIAQgAToA8AcgBCAXNwDxByAEQfAHahDcKSEBIABB1IeCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxdCyABIAIQnSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwx0gAUHUAGoiBiACEMoGIAYQ+hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDU4gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBwAhqIARBsBpqKQIANwIAIARByAhqIARBuBpqKQIANwIAIARBqQhqIAMpAwA3AAAgBEGwCGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ArgIIAQgAToAoAggBCAXNwChCCAEQaAIahDcKSEBIABBrIiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxcCyABIAIQriIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0B0gAUHUAGoiBiACEMoGIAYQ+RwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDUwgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB8AhqIARBsBpqKQIANwIAIARB+AhqIARBuBpqKQIANwIAIARB2QhqIAMpAwA3AAAgBEHgCGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AugIIAQgAToA0AggBCAXNwDRCCAEQdAIahDcKSEBIABBhImCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxbCyABIAIQuCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQvR0gAUHUAGoiBiACEMoGIAYQ9BwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDUogBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AZqIARBsBpqKQIANwIAIARB2AZqIARBuBpqKQIANwIAIARBuQZqIAMpAwA3AAAgBEHABmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgGIAQgAToAsAYgBCAXNwCxBiAEQbAGahDcKSEBIABB3ImCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxaCyABIAIQoyIhCyMAQeAAayIFJAAgCygCECEBIAsoAhRBA3YhBiMAQTBrIgIkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEIIAMoAhQhCSACIAc2AiAgAiAGNgIcIAIgATYCGCACQQA2AhQgAiAIIAlBfHFqNgIQIAIgCDYCDCACQSRqIQcjAEEgayIJJAAgCUEUaiACQQxqIgEoAgQgASgCAGtBAnZBAEEEQQgQoBggCSgCGCEGIAkoAhRBAUYNZyAJQRBqIhNBADYCACAJIAkoAhw2AgwgCSAGNgIIIwBBMGsiBiQAIAlBCGoiCCABKAIEIAEoAgBrQQJ2EOotIAgpAgQhFyAGQRhqIAFBEGopAgA3AwAgBkEQaiABQQhqKQIANwMAIAYgASkCADcDCCAGIBdCIIk3AiggBiAIQQhqNgIkIwBBMGsiASQAIAZBJGoiDSgCBCEMIA0oAgAhFAJAIAZBCGoiCCgCACIKIAgoAgQiD0cEQCAIKAIUIQ4gCCgCECESIAgoAgwhFSAIKAIIIQggDSgCCCAMQQN0aiENIA8gCmtBAnYhDwNAIAEgCjYCDAJAIBIgCigCACIQSwRAIBUgEEEDdGoiESgCBCEQIBEoAgAhEQwBCyAIIA4oAhBPDXFBACEQQQAhESAOKAIEIAggDigCDGoiFkEDdmotAAAgFkEHcXZBAXENcwsgDSARNgIAIA1BBGogEDYCACAKQQRqIQogDUEIaiENIAhBAWohCCAMQQFqIQwgD0EBayIPDQALCyAUIAw2AgAgAUEwaiQADAALIAZBMGokACAHQQhqIBMoAgA2AgAgByAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEIIAIgBjYCGCACIAE2AhQgAiAHIAhBfHFqNgIQIAIgBzYCDCACQSRqIgcgAkEMahCPGwsgBSAHEOsYIAJBMGokACAFQQxqIgEgCxCSNiADEPISIAVBJGoiAiAFIAEQ0x0gBUHUAGoiASALEMoGIAEQ9xwgBEGQGmoiAUEIaiAFQdwAaigCADYCACABIAUpAlQ3AgAgASAFKQIwNwIMIAFBFGogBUE4aigCADYCACABIAUpAjw3AhggAUEgaiAFQcQAaikCADcCACABQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokACAELQCQGiIBQSlGDUggBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBgAdqIARBsBpqKQIANwIAIARBiAdqIARBuBpqKQIANwIAIARB6QZqIAMpAwA3AAAgBEHwBmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AvgGIAQgAToA4AYgBCAXNwDhBiAEQeAGahDcKSEBIABBtIqCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxZCyABIAIQoCIhCyMAQeAAayIFJAAgCygCECEBIAsoAhRBBHYhBiMAQTBrIgIkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEIIAMoAhQhCSACIAc2AiAgAiAGNgIcIAIgATYCGCACQQA2AhQgAiAIIAlBfHFqNgIQIAIgCDYCDCACQSRqIQcjAEEgayIJJAAgCUEUaiACQQxqIgEoAgQgASgCAGtBAnZBAEEIQRAQoBggCSgCGCEGIAkoAhRBAUYNZiAJQRBqIhBBADYCACAJIAkoAhw2AgwgCSAGNgIIIwBBMGsiBiQAIAlBCGoiCCABKAIEIAEoAgBrQQJ2EOktIAgpAgQhFyAGQRhqIAFBEGopAgA3AwAgBkEQaiABQQhqKQIANwMAIAYgASkCADcDCCAGIBdCIIk3AiggBiAIQQhqNgIkIwBBMGsiASQAIAZBJGoiDSgCBCEMIA0oAgAhEQJAIAZBCGoiCCgCACIKIAgoAgQiD0cEQCAIKAIUIQ4gCCgCECETIAgoAgwhFCAIKAIIIQggDSgCCCAMQQR0aiENIA8gCmtBAnYhDwNAIAEgCjYCDAJAIBMgCigCACISSwRAIAFBGGogFCASQQR0aiISQQhqKQMANwMAIAEgEikDADcDEAwBCyAIIA4oAhBPDXAgDigCBCAIIA4oAgxqIhJBA3ZqLQAAIBJBB3F2QQFxDXIgAUEYakIANwMAIAFCADcDEAsgDSABKQMQNwMAIA1BCGogAUEYaikDADcDACAKQQRqIQogDUEQaiENIAhBAWohCCAMQQFqIQwgD0EBayIPDQALCyARIAw2AgAgAUEwaiQADAALIAZBMGokACAHQQhqIBAoAgA2AgAgByAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEIIAIgBjYCGCACIAE2AhQgAiAHIAhBfHFqNgIQIAIgBzYCDCACQSRqIgcgAkEMahCSGwsgBSAHEOoYIAJBMGokACAFQQxqIgEgCxCSNiADEPISIAVBJGoiAiAFIAEQxR0gBUHUAGoiASALEMoGIAEQ8RwgBEGQGmoiAUEIaiAFQdwAaigCADYCACABIAUpAlQ3AgAgASAFKQIwNwIMIAFBFGogBUE4aigCADYCACABIAUpAjw3AhggAUEgaiAFQcQAaikCADcCACABQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokACAELQCQGiIBQSlGDUYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBsAdqIARBsBpqKQIANwIAIARBuAdqIARBuBpqKQIANwIAIARBmQdqIAMpAwA3AAAgBEGgB2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AqgHIAQgAToAkAcgBCAXNwCRByAEQZAHahDcKSEBIABBjIuCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxYCyAEQYAfaiIGIAEgAhCnIiIBKAIQIAEoAhRBAnYgAxC7FiAEQYgVaiICIAEQkjYgAxDyEiAEQZAaaiIDIAYgAhDKHSAEQbgeaiICIAEQygYgAhDQGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1EIARB/wRqIgMgBEHHGWopAAA3AAAgBEH4BGoiBSAEQcAZaikDADcDACAEQZAFaiIIIAYpAwA3AwAgBEGYBWoiBiAHKQMANwMAIAQgBCkDuBk3A/AEIAQgBCkDuA83A4gFQThBBBCtNiIBRQ1YIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD8AQ3AAkgASAEKQOIBTcCICAAQeSLggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFcLIARBgB9qIgYgASACEKsiIgEoAhAgASgCFEEDdiADELwWIARBiBVqIgIgARCSNiADEPISIARBkBpqIgMgBiACEMYdIARBuB5qIgIgARDKBiACENIYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUIgBEGvBWoiAyAEQccZaikAADcAACAEQagFaiIFIARBwBlqKQMANwMAIARBwAVqIgggBikDADcDACAEQcgFaiIGIAcpAwA3AwAgBCAEKQO4GTcDoAUgBCAEKQO4DzcDuAVBOEEEEK02IgFFDVcgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgBTcACSABIAQpA7gFNwIgIABBvIyCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVgsgBEGAH2ohCCABIAIQvCIiBSgCECECIAUoAhRBBHYhBiMAQTBrIgEkAAJAAkAgAxCSNiIHRQ0AIAcoAhRFDQAgAygCECEJIAMoAhQhCiABIAc2AiAgASAGNgIcIAEgAjYCGCABQQA2AhQgASAJIApBfHFqNgIQIAEgCTYCDCABQSRqIQYjAEEgayIJJAAgCUEUaiABQQxqIgcoAgQgBygCAGtBAnZBAEEQQRAQoBggCSgCGCECIAkoAhRBAUYNYiAJQRBqIgtBADYCACAJIAkoAhw2AgwgCSACNgIIIwBBEGsiAiQAIAlBCGoiCiAHKAIEIAcoAgBrQQJ2EOstIAIgCikCBEIgiTcCCCACIApBCGo2AgQgByACQQRqEKoQIAJBEGokACAGQQhqIAsoAgA2AgAgBiAJKQIINwIAIAlBIGokAAwBCyADKAIQIQcgAygCFCEJIAEgBjYCGCABIAI2AhQgASAHIAlBfHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCYGwsgCCAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDyEiAEQZAaaiIDIAggARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXxxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCSQAIAlBFGogAUEMaiIFKAIEIAUoAgBrQQJ2QQBBEEEgEKAYIAkoAhghAiAJKAIUQQFGDWEgCUEQaiIRQQA2AgAgCSAJKAIcNgIMIAkgAjYCCCMAQTBrIgckACAJQQhqIgIgBSgCBCAFKAIAa0ECdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCiAOKAIAIRMCQCAHQQhqIgUoAgAiCCAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIRIgBSgCCCELIA4oAgggCkEFdGohBSAQIAhrQQJ2IRADQCACIAg2AgwCQCAUIAgoAgAiDksEQCASIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyALIA0oAhBPDWxCACEaQgAhGUIAIRhCACEXIA0oAgQgCyANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1tCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCEEEaiEIIAVBIGohBSALQQFqIQsgCkEBaiEKIBBBAWsiEA0ACwsgEyAKNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiARKAIANgIAIAYgCSkCCDcCACAJQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXxxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhxsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8hIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9SggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAILQABQQFrDgMGBwgFCyAILQABDgIKCzoLIAgtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiBiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCAIKAIEIQwjAEFAaiICJAAgAiABEJI2NgIIIAMoAhQhByADKAIQIQMgAiABNgI8IAIgAzYCMCACIAMgB0F8cWo2AjQgAiACQQhqNgI4IAJBHGohBSMAQUBqIgMkACADQZOAgIB4NgIIIANBMGogAkEwaiIBQQhqKQIANwMAIAMgASkCADcDKCADIANBCGo2AjggA0EcaiEIIwBBMGsiASQAIAFBDGogA0EoaiIHEPIgAkACQAJAIAEoAgxBAUYEQCABKAIUIQ0gASgCECEOIAFBGGoiCkEEQQBBBEEIEKAYIAEoAhwhCSABKAIYQQFGDQIgASgCICILIA02AgQgCyAONgIAIAFBCGoiDUEBNgIAIAEgCzYCBCABIAk2AgAgAUEoaiAHQRBqKAIANgIAIAFBIGogB0EIaikCADcDACABIAcpAgA3AxgjAEEQayIHJAAgB0EEaiAKEPIgIAcoAgRBAUYEQANAIAcoAgwhCyAHKAIIIQ4gASgCCCIJIAEoAgBGBEAgASAJQQFBBEEIEN4oCyABKAIEIAlBA3RqIg8gCzYCBCAPIA42AgAgASAJQQFqNgIIIAdBBGogChDyICAHKAIEDQALCyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCADcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgALIAFBMGokAAwBCyAJIAEoAiBBiPmDARD9LwALAkAgAygCCEGTgICAeEcEQCAFIAMpAgg3AgAgBUEQaiADQRhqKAIANgIAIAVBCGogA0EQaikCADcCACAIEOo7DAELIAUgAykCHDcCBCAFQZOAgIB4NgIAIAVBDGogA0EkaigCADYCAAsgA0FAayQAIAIoAighAyACKAIkIQEgAigCICEHAkAgAigCHCIFQZOAgIB4RwRAIAYgAigCLDYCFCAGIAM2AhAgBiABNgIMIAYgBzYCCCAGIAU2AgQgBkEpOgAADAELIAIgBzYCFCACIAE2AgwgAiABNgIQIAIgASADQQN0ajYCGCAGIAJBDGogDBC6BgsgAkFAayQAIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiIGIAQoAigiCSAEKAIsKAIMEQAAIAlFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCAIKAIEIQEjAEGABGsiAiQAIAJBzAJqIANBDGoiCxDbPCABbBDyHgJAAkACQAJAIAsQ2zwiDwRAIAkoAiwhECADKAIQIQggAkHYAmohDANAAkACQAJAAkAgAyAFEIs7RQRAIAwQ5jogAigC2AJFDQEgAigC6AIgAWoiDUEDdiANQQdxQQBHaiIHIAIoAuQCIgpLBEAgByAKayEOIAIoAtwCIhEgB0kEQCAMIBFBAXQiCiAHENIqIhEgCiARSxsQ6BkgAigC5AIhCgsgDgRAIAIoAuACIApqQQAgDvwLAAsgAiAHNgLkAgsgAiANNgLoAiACQcwCaiABELQlDAQLIAIgBTYC/AMgCxDbPCAFTQ0BIAgoAgAiB0EASARAIAJBEGpBFEEAQQFBARCgGCACKAIUIQMgAigCEEEBRg0DIAIoAhgiAUEQakGw/4EBKAAANgAAIAFBCGpBqP+BASkAADcAACABQaD/gQEpAAA3AAAgAkEUNgJsIAIgATYCaCACIAM2AmQgAkGGgICAeDYCYCACQcwCahC8LQwHCyACQcwCaiAHIBBsIgcgASAHahCIDwwDC0H89IEBELI7AAsgAiADEPw7NgKMASACQQI2AhQgAkGI8YEBNgIQIAJCAjcCHCACQTs2AvgDIAJBOzYC8AMgAiACQewDajYCGCACIAJBjAFqNgL0AyACIAJB/ANqNgLsAyACQRBqQZjxgQEQ7ywACyADIAIoAhhBiP2BARD9LwALIAhBBGohCCAPIAVBAWoiBUcNAAsLIAJB3ABqIAJBzAJqIgEQ1BQgAi0AXCEHIAEQvC0gB0EpRg0AIAJBzwBqIgUgAkHsAGopAAA3AAAgAkHIAGoiCCACQeUAaikAADcDACACQTBqIAJB/ABqKQIANwIAIAJBOGogAkGEAWopAgA3AgAgAkEZaiAIKQMANwAAIAJBIGogBSkAADcAACACIAIpAF0iFzcDQCACIAIpAnQ3AiggAiAXNwARIAIgBzoAECABIAkoAgwgCSgCECIBKAIIQQFrQXhxakEIaiABIAJBEGoQiAEgAigC1AIhASACKALQAiEHIAIoAswCIgVBk4CAgHhGDQEgBiACKQLYAjcCECAGIAE2AgwgBiAHNgIIIAYgBTYCBCAGQSk6AAAMAgsgAkHTAGogAkHwAGooAgAiATYAACACQcsAaiACQegAaikCACIXNwAAIAIgAikCYCIYNwBDIAZBFGogATYAACAGQQxqIBc3AAAgBiAYNwAEIAZBKToAAAwCCyACIAE2ApABIAIgBzYCjAFBwAAhBwJAIAsQ2zwiAUEDdiABQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIHRQ1gC0EAIQUgAkEANgLYAiACIAc2AtQCIAIgATYC0AIgAkHAADYCzAIgAkFAayIBIAJBzAJqIAgQ0iUgAkEIaiABEIY9IAIoAgwhASACKAIIIQogCxDbPCIMRQ0BIAMoAhAhCANAAkAgAiAFNgL8AwJAAkAgCxDbPCAFSwRAIAgoAgAiB0EASARAIAJBzAJqQRRBAEEBQQEQoBggAigC0AIhAyACKALMAkEBRgRAIAMgAigC1AJBiP2BARD9LwALIAIoAtQCIgFBEGpBsP+BASgAADYAACABQQhqQaj/gQEpAAA3AAAgAUGg/4EBKQAANwAAIAZBFDYCECAGIAE2AgwgBiADNgIIIAZBhoCAgHg2AgQgBkEpOgAAIAJBQGsQzy8gAigCjAEiASABKAIAIgFBAWs2AgAgAUEBRw0IIAJBjAFqELsjDAgLIAMgBRCLO0UNASAJIAcQmiUNAQwCCyACIAMQ/Ds2AuwDIAJBAjYC0AIgAkGI8YEBNgLMAiACQgI3AtgCIAJBOzYCaCACQTs2AmAgAiACQdwAajYC1AIgAiACQewDajYCZCACIAJB/ANqNgJcIAJBzAJqQZjxgQEQ7ywACyAFQQN2IgcgAU8NASAHIApqIgcgBy0AAEF+IAVBB3F3cToAAAsgCEEEaiEIIAwgBUEBaiIFRw0BDAMLCyAHIAFBgPSBARDDIQALQcD0gQFBKSACQcwCakHM/IEBQez0gQEQ1R4ACyACQewCaiAJEMoGIAsQ2zwhASACQQA7AaQDIAJBADYCoAMgAkEANgKIAyACQQA2AvwCIAIgATYC+AIgAkIENwLkAiACQgA3AtwCIAJCgICAgMAANwLUAiACQQA2AswCIAIoAkghASACKAJMIQMgAiACKQJANwJoIAJBADYCZCACIAM2AmAgAiABNgJcIAIgAkHcAGoQ1zsgAigCACEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAlw3AgggAUEQaiACQeQAaikCADcCACABQRhqIAJB7ABqKAIANgIAIAIgAzYC9AMgAiAHNgLwAyACIAE2AuwDIAJB8AFqIgMgAkHMAmoiASACQewDahCuFiACQQA2AsQCIAEgAigCjAEgAigCkAEQ0yMgAkGUAWoiByADIAEQ7yUgAkGoA2oiASAHEM0cIAYgARDcFCACQRBqEP4kDAILDFILIAJBEGoQ/iQLIAJBgARqJAAgBC0AkBoiAUEpRw0TIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADE4LIAEgAigCJBEEACADQQxqIgMQ2zwgAxDbPCEDSQ01IARBEGogAUEAIAMgAigCIBEFACAAIAQpAxA3AgQgAEGTgICAeDYCAAxNCyABIAIQnyIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1B0gAUHUAGoiBiACEMoGIAYQhRcgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDTMgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBwAtqIARBsBpqKQIANwIAIARByAtqIARBuBpqKQIANwIAIARBqQtqIAMpAwA3AAAgBEGwC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ArgLIAQgAToAoAsgBCAXNwChCyAEQaALahDcKSEBIABBuI+CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxMCyABIAIQtCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQyB0gAUHUAGoiBiACEMoGIAYQ/hYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDTEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB8AtqIARBsBpqKQIANwIAIARB+AtqIARBuBpqKQIANwIAIARB2QtqIAMpAwA3AAAgBEHgC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AugLIAQgAToA0AsgBCAXNwDRCyAEQdALahDcKSEBIABBkJCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxLCyABIAIQsiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQyR0gAUHUAGoiBiACEMoGIAYQ/RYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDS8gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBoAxqIARBsBpqKQIANwIAIARBqAxqIARBuBpqKQIANwIAIARBiQxqIAMpAwA3AAAgBEGQDGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApgMIAQgAToAgAwgBCAXNwCBDCAEQYAMahDcKSEBIABB6JCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxKCyABIAIQrCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0R0gAUHUAGoiBiACEMoGIAYQ/BYgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDS0gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AxqIARBsBpqKQIANwIAIARB2AxqIARBuBpqKQIANwIAIARBuQxqIAMpAwA3AAAgBEHADGogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgMIAQgAToAsAwgBCAXNwCxDCAEQbAMahDcKSEBIABBwJGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxJCyABIAIQpSIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ0h0gAUHUAGoiBiACEMoGIAYQlB4gBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSsgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB4ApqIARBsBpqKQIANwIAIARB6ApqIARBuBpqKQIANwIAIARByQpqIAMpAwA3AAAgBEHQCmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AtgKIAQgAToAwAogBCAXNwDBCiAEQcAKahDcKSEBIABBmJKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxICyABIAIQsCIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQxB0gAUHUAGoiBiACEMoGIAYQlx4gBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSkgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBkAtqIARBsBpqKQIANwIAIARBmAtqIARBuBpqKQIANwIAIARB+QpqIAMpAwA3AAAgBEGAC2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AogLIAQgAToA8AogBCAXNwDxCiAEQfAKahDcKSEBIABB8JKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxHCyABIAIQniIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQzB0gAUHUAGoiBiACEMoGIAYQ+BwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDScgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBoAlqIARBsBpqKQIANwIAIARBqAlqIARBuBpqKQIANwIAIARBiQlqIAMpAwA3AAAgBEGQCWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApgJIAQgAToAgAkgBCAXNwCBCSAEQYAJahDcKSEBIABByJOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxGCyABIAIQtiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBAnYgAxC7FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1x0gAUHUAGoiBiACEMoGIAYQ8xwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSUgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARB0AlqIARBsBpqKQIANwIAIARB2AlqIARBuBpqKQIANwIAIARBuQlqIAMpAwA3AAAgBEHACWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AsgJIAQgAToAsAkgBCAXNwCxCSAEQbAJahDcKSEBIABBoJSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxFCyABIAIQryIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQwh0gAUHUAGoiBiACEMoGIAYQ+xwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSMgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBgApqIARBsBpqKQIANwIAIARBiApqIARBuBpqKQIANwIAIARB6QlqIAMpAwA3AAAgBEHwCWogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AvgJIAQgAToA4AkgBCAXNwDhCSAEQeAJahDcKSEBIABB+JSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxECyABIAIQuiIhAiMAQeAAayIBJAAgASACKAIQIAIoAhRBA3YgAxC8FiABQQxqIgYgAhCSNiADEPISIAFBJGoiAyABIAYQ1R0gAUHUAGoiBiACEMoGIAYQ9hwgBEGQGmoiAkEIaiABQdwAaigCADYCACACIAEpAlQ3AgAgAiABKQIwNwIMIAJBFGogAUE4aigCADYCACACIAEpAjw3AhggAkEgaiABQcQAaikCADcCACACQShqIAFBzABqKQIANwIAIAMQuwwgAUHgAGokACAELQCQGiIBQSlGDSEgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBsApqIARBsBpqKQIANwIAIARBuApqIARBuBpqKQIANwIAIARBmQpqIAMpAwA3AAAgBEGgCmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AqgKIAQgAToAkAogBCAXNwCRCiAEQZAKahDcKSEBIABB0JWCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxDCyAEQZAaaiABIAIQlyIgAxCNAiAELQCQGiIBQSlGDR8gBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBqBdqIARBqBpqQST8CgAAIARBmRdqIAMpAwA3AAAgBEGgF2ogAikAADcAACAEIAE6AJAXIAQgBCkDiBU3AJEXIARBkBdqEOwpIQEgAEGoloIBNgIIIAAgATYCBCAAQZOAgIB4NgIADEILIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeQYaiAEQbAaaikCADcCACAEQewYaiAEQbgaaikCADcCACAEQfQYaiAEQcAaaikCADcCACAEQc0YaiADKQMANwAAIARB1BhqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLcGCAEIAE6AMQYIAQgFzcAxRggBEHEGGoQ5ikhASAAQZCXggE2AgggACABNgIEIABBk4CAgHg2AgAMQQsgBEGQGmogASACEJYiIAMQnAIgBC0AkBoiAUEpRg0cIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQeQXaiAEQagaakEk/AoAACAEQdUXaiADKQMANwAAIARB3BdqIAIpAAA3AAAgBCABOgDMFyAEIAQpA4gVNwDNFyAEQcwXahDsKSEBIABB6JeCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxACyAEQZAaaiELIAEgAhCLIiEBIwBBMGsiByQAIAcgASgCHCABKAIgQQR2IAMQzRYgB0EMaiABEJM2IAMQ8hIgASgCBCEIIAdBJGogASgCCCIFQQBBBEEMEKAYIAcoAighAQJAAkAgBygCJEEBRwRAIAcoAiwhAwJAIAFFDQAgBUEMbCEKIAMhAiABIQYDQCAKRQ0BIAgoAgAiCSAJKAIAIgxBAWo2AgAgDEEASA0DIAJBBGogCCkCBDcCACACIAk2AgAgAkEMaiECIApBDGshCiAIQQxqIQggBkEBayIGDQALCyAHIAU2AiwgByADNgIoIAcgATYCJCALIAcgB0EkaiAHQQxqELwgIAdBMGokAAwCCyABIAcoAixBmP2BARD9LwsACyAEQZAVaiIBIARBnBpqKQIANwMAIARBmBVqIgIgBEGkGmooAgA2AgAgBCAEKQKUGjcDiBUgBCgCkBoiA0GAgICAeEYNGiAEQaAYaiAEQagaakEk/AoAACAEQZQYaiABKQMANwIAIARBnBhqIAIoAgA2AgAgBCADNgKIGCAEIAQpA4gVNwKMGCAEQYgYahDsKSEBIABBwJiCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw/CyAEQZAaaiABIAIQmSIgAxCOAiAELQCQGiIBQSlGDRggBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARB+AxqIARBqBpqQST8CgAAIARB6QxqIAMpAwA3AAAgBEHwDGogAikAADcAACAEIAE6AOAMIAQgBCkDiBU3AOEMIARB4AxqEOwpIQEgAEGYmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD4LIARBkBpqIAEgAhCYIiADEJ0CIAQtAJAaIgFBKUYNFiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEG0DWogBEGoGmpBJPwKAAAgBEGlDWogAykDADcAACAEQawNaiACKQAANwAAIAQgAToAnA0gBCAEKQOIFTcAnQ0gBEGcDWoQ7CkhASAAQfCZggE2AgggACABNgIEIABBk4CAgHg2AgAMPQsgBEGQGmohCyABIAIQjCIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEM0WIAdBDGogARCTNiADEPISIAEoAgQhCCAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCiADIQIgASEGA0AgCkUNASAIKAIAIgkgCSgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAgpAgQ3AgAgAiAJNgIAIAJBDGohAiAKQQxrIQogCEEMaiEIIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCyAHIAdBJGogB0EMahC9ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRQgBEHwDWogBEGoGmpBJPwKAAAgBEHkDWogASkDADcCACAEQewNaiACKAIANgIAIAQgAzYC2A0gBCAEKQOIFTcC3A0gBEHYDWoQ7CkhASAAQciaggE2AgggACABNgIEIABBk4CAgHg2AgAMPAsgBEGQGmogASACEJAiIAMQugIgBC0AkBoiAUEpRg0SIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbQOaiAEQbAaaikCADcCACAEQbwOaiAEQbgaaikCADcCACAEQcQOaiAEQcAaaikCADcCACAEQZ0OaiADKQMANwAAIARBpA5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKsDiAEIAE6AJQOIAQgFzcAlQ4gBEGUDmoQ5ikhASAAQaCbggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBpA9qIARBsBpqKQIANwIAIARBrA9qIARBuBpqKQIANwIAIARBtA9qIARBwBpqKAIANgIAIARBjQ9qIAMpAwA3AAAgBEGUD2ogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3ApwPIAQgAToAhA8gBCAXNwCFDyAEQYQPahDlKSEBIABBiJyCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEHIAEgAhCRIiEJIwBBwARrIgYkACAJKAIYIQ0gCSgCHCEKIAZBqAJqIANBDGoiCxDbPEEAQQhBCBCgGCAGKAKsAiEBAkAgBigCqAJBAUcEQCAGQQA2ApgEIAYgBigCsAIiAjYClAQgBiABNgKQBCAGQQA2AqQEIAZCgICAgIABNwKcBCABBH8gAgUgBkGQBGpB8K+CARCzKCAGKAKUBAtCADcDACAGQQE2ApgEQcAAIQUgCxDbPCIBQQN2IAFBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiAUHAABDRNARAIAEEQCABQcAAEK02IgVFDUoLQQAhAiAGQQA2ArQCIAYgBTYCsAIgBiABNgKsAiAGQcAANgKoAiAGQagEaiIBIAZBqAJqIAgQ0iUgBkEYaiABEIY9IAYoAhwhASAGKAIYIQ4CQAJAAkACQCALENs8Ig8EQCAKQQN2IQwgAygCECEQA0ACQAJAAkACQAJAAkACQCADIAIQiztFBEAgAkEDdiIFIAFPDQEgBSAOaiIFIAUtAABBfiACQQdxd3E6AAAgBigCmAQiBSAGKAKQBEYEQCAGQZAEakGAsIIBELMoCyAGKAKUBCAFQQN0aiAXNwMAIAYgBUEBajYCmAQMBwsgBiACNgK4BCALENs8IAJNDQEgECACQQJ0aigCACIFQQBIBEBBFCECIAZBqAJqQRRBAEEBQQEQoBggBigCrAIhCiAGKAKoAkEBRg0FIAYoArACIghBEGpBsP+BASgAADYAACAIQQhqQaj/gQEpAAA3AAAgCEGg/4EBKQAANwAAIAZBqARqEM8vIAZBnARqEOM8IAZBkARqEOM8QYaAgIB4IQMMCgsgBSAMTw0CIAVBAWoiCCAMTw0FIA0gCEEDdGopAwAiGSANIAVBA3RqKQMAIhh9IBd8IRcgBigCmAQiCCAGKAKQBEYEQCAGQZAEakGwsIIBELMoCyAGKAKUBCAIQQN0aiAXNwMAIAYgCEEBajYCmAQgGCAZUwRAIAYoAqQEIghBA3QhCgNAIAYoApwEIAhGBEAgBkGcBGpBwLCCARCzKAsgBigCoAQgCmogGDcDACAGIAhBAWoiCDYCpAQgCkEIaiEKIBkgGEIBfCIYUg0ACwsgCSAFEJI7DQYgAkEDdiIFIAFPDQMgBSAOaiIFIAUtAABBfiACQQdxd3E6AAAMBgsgBSABQYD0gQEQwyEACyAGIAMQ/Ds2ArwEIAZBAjYCrAIgBkGI8YEBNgKoAiAGQgI3ArQCIAZBOzYCLCAGQTs2AiQgBiAGQSBqNgKwAiAGIAZBvARqNgIoIAYgBkG4BGo2AiAgBkGoAmpBmPGBARDvLAALIAUgDEGQsIIBEMMhAAsgBSABQYD0gQEQwyEACyAKIAYoArACQYj9gQEQ/S8ACyAIIAxBoLCCARDDIQALIAJBAWoiAiAPRw0ACwsgBkEoaiAGQaQEaigCADYCACAGIAYpApwENwMgIAZBtAJqIAZBIGoiARCaEiAGQbACaiAGQZgEaigCACIKNgIAIAYgBikCkAQiFzcDqAIgBigCtAIhCCAGKAK4AiECIAYoArwCIQUgBigCrAIhAyAGQYgDaiIMIAZBwAJqQST8CgAAIAZB2ABqIg0gBkGwBGoiDikCADcDACAGIAYpAqgENwNQIBenIg9BgICAgHhGDQAgBkEsaiAMQST8CgAAIA4gDSkDADcDACAGIAYpA1A3A6gEIAYgBTYCKCAGIAI2AiQgBiAINgIgIAYgCjYCpAQgBiADNgKgBCAGIA82ApwEIAZBqAJqIAkoAgwgCSgCECICKAIIQQFrQXhxakEIaiACIAEQigEgBigCsAIhBSAGKAKsAiEIIAYoAqgCIgJBk4CAgHhGDQEgByAGKQK0AjcCECAHIAU2AgwgByAINgIIIAcgAjYCBCAHQSk6AAAgBkGoBGoQzy8gBkGcBGoQ4zwgARD+JAwCCyAHIAU2AhQgByACNgIQIAcgCDYCDCAHIAo2AgggByADNgIEIAdBKToAAAwBCyAGQYgDaiICIAZBnARqEN4sIAYgBikCiAM3ArQCIAZBADYCsAIgBiAGKAKUAyIKNgKsAiAGIAYoApADNgKoAiAGQRBqIAZBqAJqIgMQ1zsgBigCECEMQRxBBBCtNiIBRQ1AIAFCgYCAgBA3AgAgASAGKQKoAjcCCCABQRBqIAZBsAJqKQIANwIAIAFBGGogBkG4AmooAgA2AgAgBiAKNgJsIAYgDDYCaCAGIAE2AmQgBkHIAmogCRDKBiALENs8IQEgBkEAOwGAAyAGQQA2AvwCIAZBADYC5AIgBkEANgLYAiAGIAE2AtQCIAZCBDcCwAIgBkIANwK4AiAGQoCAgIDAADcCsAIgBkEANgKoAiAGKAKwBCEBIAYoArQEIQkgBiAGKQOoBDcClAMgBkEANgKQAyAGIAk2AowDIAYgATYCiAMgBkEIaiACENc7IAYoAgghCkEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgBikCiAM3AgggAUEQaiAGQZADaikCADcCACABQRhqIAZBmANqKAIANgIAIAYgCTYCWCAGIAo2AlQgBiABNgJQIAZBzAFqIgEgAyAGQdAAahCuFiAGQQA2AqACIAIgCCAFENMjIAMgASACEO8lIAZB8ABqIgEgAyAGQeQAahD6IyAGQcwDaiICIAEQzRwgByACEK4fIAZBIGoQ/iQLIAZBwARqJAAMAwsMPgtBwPSBAUEpIAZBqAJqQcz8gQFB7PSBARDVHgALIAEgBigCsAJB4K+CARD9LwALIAQtAJAaIgFBKUYNDyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHsDmogBEGwGmopAgA3AgAgBEH0DmogBEG4GmopAgA3AgAgBEH8DmogBEHAGmopAgA3AgAgBEHVDmogAykDADcAACAEQdwOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC5A4gBCABOgDMDiAEIBc3AM0OIARBzA5qEOYpIQEgAEHgnIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDkLIARBOGogASACEMgvIg4Q3DsgBCgCPCECIAQoAjghASAEIAM2ApAVIAQgATYCiBUgBCABIAJBA3RqNgKMFSAEQZAaaiEFIwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiAEQYgVaiIBQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEKIwBBMGsiASQAIAFBCGogAkEgaiIGEIYoAkACQAJAIAEoAggiCwRAIAEoAgwhDSABQSBqIgxBBEEAQQRBCBCgGCABKAIkIQcgASgCIEEBRg0CIAEoAigiCSANNgIEIAkgCzYCACABQRxqIg9BATYCACABIAk2AhggASAHNgIUIAFBKGogBkEIaikCADcDACABIAYpAgA3AyAjAEEQayIGJAAgBkEIaiAMEIYoIAYoAggiCQRAIAFBFGohCyAGKAIMIQcDQCALKAIIIg0gCygCAEYEQCALQQEQ6i0LIAsoAgQgDUEDdGoiECAHNgIEIBAgCTYCACALIA1BAWo2AgggBiAMEIYoIAYoAgQhByAGKAIAIgkNAAsLIAZBEGokACAKQQhqIA8oAgA2AgAgCiABKQIUNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEGI+YMBEP0vAAsCQCACKAIAQZOAgIB4RwRAIAUgAikCADcCACAFQRBqIAJBEGooAgA2AgAgBUEIaiACQQhqKQIANwIAIAoQwycgChDqOwwBCyAFIAIpAhQ3AgQgBUGTgICAeDYCACAFQQxqIAJBHGooAgA2AgALIAJBMGokACAEKAKcGiECIAQoApgaIQEgBCgClBohBiAEKAKQGiIHQZOAgIB4RwRAIAAgBCgCoBo2AhAgACACNgIMIAAgATYCCCAAIAY2AgQgACAHNgIADDkLIARBMGogCEEEahDDNCAEKAI0IQUgBCgCMCEHIARCADcCqBogBCABIAJBA3RqNgKkGiAEIAY2AqAaIAQgATYCnBogBCABNgKYGiAEIAc2ApAaIAQgByAFQQJ0ajYClBogBEG4D2ogBEGQGmoiCRD/GCAJIAMQwC0gBCAONgK0GiMAQTBrIgckACAHQQxqIQ0jAEFAaiIGJAAgBkEIaiAJQSj8CgAAIAYoAggiChC/PCEBIAYoAiQhAiAKEL88GkHAACEFAkBBfyABIAJrIgFBB2oiCCABIAhLGyIBQQN2IghBwP///wFxQUBrIAggAUH4A3EbIgFBwAAQ0TQEQCABBEAgAUHAABCtNiIFRQ1ICyAGQQA2AjwgBiAFNgI4IAYgATYCNCAGQcAANgIwIAZBDGohDiAGKAIsIQ8gBigCGCEQIAYoAhAhESAGKAIcIRMgBigCDCEMIAYoAighAUEAIQVBASEIA0ACQAJAAkACQCABIAJGIhRFBEACfyAMBEAgAiATTw0DQQAgESACIBBqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcQ0BGgsgCigCECACQQJ0aigCACILQQBIDQMgCEEAIA8gCxCTOxsLIAVyIQUgAkEBaiECIAhBAXQiCEH+AXENBSAGIAI2AiQMAwsgBiABNgIkIAEhAiAIQf8BcUEBRw0CDAMLQZz4gwFBIEG8+IMBEJ8pAAtBtPmDARCyOwALAkAgBigCPCILIAYoAjRHDQAgChC/PCEIIAoQvzwaIAYoAjwiC0F/IAggAmsiCEEHaiISIAggEksbQQN2akEBaiIIIAYoAjRNDQAgCBDVKiEIIAZBMGogBigCNEEBdCILIAggCCALSRsQ6BkgBigCPCELCyAGKAI4IAtqIAU6AABBASEIIAYgC0EBajYCPEEAIQUgFEUNAQsLIA0gBikCMDcCACANQQhqIAZBOGopAgA3AgACQCAMRQ0AIAwgDCgCACIBQQFrNgIAIAFBAUcNACAOEPseCyAGQUBrJAAMAQtBzPiDAUEpIAZBMGpBmPmDAUH4+IMBENUeAAsgByAHKQIMNwIoIAdBADYCJCAHIAcoAhgiBjYCICAHIAcoAhQ2AhwgByAHQRxqENc7IAcoAgAhBUEcQQQQrTYiAUUNOiABQoGAgIAQNwIAIAEgBykCHDcCCCAEQYQRaiICIAY2AgggAiAFNgIEIAIgATYCACABQRBqIAdBJGopAgA3AgAgAUEYaiAHQSxqKAIANgIAIAdBMGokACAEKALADwRAIARBkBVqIARBwA9qKAIANgIAIARBnBVqIARBjBFqKAIANgIAIAQgBCkCuA83A4gVIAQgBCkChBE3ApQVIAkgBEGIFWoQrRAgCRDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiIBIARBhBFqQQAgA0EMaiICENs8EPIVIARBiBVqIgMgARDhJyABIAIQ2zwgAxDVGCABEOUpIQEgAEG4nYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qIgAQ7h8gABDoOww4CyAIQQRqIQYgCC0AAQ0LIARB/BhqIAYoAgQQ6iMgBEHYAGogASACKAIQEQAAIARBkBpqIAQoAlgiAiAEKAJcKAIMEQAAIAJFDQYgBCkDkBpC55nB0obRrM2zf4UgBCkDmBpC5ZLhj9uJra5ShYRQRQ0GIARBgB9qIAIoAhwgAigCICADEL0WIARB0ABqIAYQsC4gBCgCUCIBIAQoAlQiCkYNCgNAIARBkBpqIAIgAS0AABDZKEGIn4IBIAMQiQEgBCgCmBohByAEKAKUGiEFIAQoApAaIglBk4CAgHhHBEAgACAEKQKcGjcCDCAAIAc2AgggACAFNgIEIAAgCTYCACAEKAKAHyIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEGAH2oQ+x4LIARB/BhqIgAQwycgABDqOww5CyAEKAKEGSIJIAQoAvwYRgRAIARB/BhqQeCfggEQmygLIAQoAoAZIAlBA3RqIgsgBzYCBCALIAU2AgAgBCAJQQFqNgKEGSABQQhqIgEgCkcNAAsMCgsgASAHEQQAIgYtAABBIkYNCCAEIAY2ArgPIARBATYClBogBEHspoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQfSmggEQ7ywACyAEQZAaaiIGIAEgAhDHLxCPDiAEQbgPaiIFIAYQ/BUgBiAFIAMQugIgBC0AkBoiAkEpRg0GIARBlxVqIgMgBEGgGmopAAA3AAAgBEGQFWoiCCAEQZkaaikAADcDACAEQZAQaiAEQbAaaikCADcCACAEQZgQaiAEQbgaaikCADcCACAEQaAQaiAEQcAaaikCADcCACAEQfkPaiAIKQMANwAAIARBgBBqIAMpAAA3AAAgBCAEKQKoGjcCiBAgBCACOgDwDyAEIAQpAJEaNwDxDyAEQYgVaiICIARB8A9qEIQ+IAYgAhChGyACIAEgBxEEABDKBiAEQagQaiIBIAYgAhCMGCACIAEQzRwgBiACELgGIAYQ9ykhASAAQYSnggE2AgggACABNgIEIABBk4CAgHg2AgAgBRDJHgw1CyABIAcRBAAiBi0AAEEoRg0EIAQgBjYCuA8gBEEBNgKUGiAEQfyqggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpBhKuCARDvLAALQdCOggEQsjsAC0GAl4IBELI7AAtB+JuCARCyOwALQaCeggEQsjsMBQsCQAJAAkACQAJAAkAgBigCBCIGLQAwQQNrDgMBAgMACyAEIAZBMGo2ArgPIARBATYClBogBEGwqoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQbiqggEQ7ywACyAEQZAaaiENIAEgAhCcIiEOIwBB4ARrIgUkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBA00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCERIA4oAhghEyAFQcwAaiABQQJ2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCSAFQdQDaiIUKAIAIgEoAgQiC08NTyAGKAIAIgMgC08NUEECIQgCQAJAAkACQCABKAIAIg8gCUECdGooAgAgDyADQQJ0aigCAEgiEkUEQCAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgkgC08NVyABKAIAIgEgC08NWCAPIAlBAnRqKAIAIA8gAUECdGooAgBIDQIgAyEBIAwgCEEBaiIIRw0ACwwCCyAMQQJGDQAgB0EEaiEBA0AgAUEEaiIDKAIAIgkgC08NViABKAIAIgEgC08NBCAPIAlBAnRqKAIAIA8gAUECdGooAgBODQEgAyEBIAwgCEEBaiIIRw0ACwwBCyAIIAxHDQELIBJFDQMgDEEBdiEDIAxBAnQgB2pBBGshCANAIAcoAgAhASAHIAgoAgA2AgAgCCABNgIAIAhBBGshCCAHQQRqIQcgA0EBayIDDQALDAMLIAcgDEEAIAxBAXJnQQF0QT5zIBQQ5goMAgsMUgsgDEECdCEBQQQhBwNAIAYgBiAHaiAFQdQDahC4FSABIAdBBGoiB0cNAAsLAkACQCAMRQ0AIAYgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NRCAFIBAgAUECdGooAgAiATYC3AQgASATSQRAQQAhCCARBEAgDkEMakEAEJIZIQoLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQX5xaiEHQQAhAQNAAn8gCkUEQCAIIAcgAyIGRw0BGgwFCyAKIAcgA2tBAXZPDQQgAyAKQQF0aiEGIAggCmoLIgxBAWohCCAGQQJqIQNBACEKIAEgAk8NACABQQJ0IQsgBi4BACARayEPA0AgASAFKAJUIgZPDUggBSgCUCALaigCACIGIAJPDUkgECAGQQJ0IhNqKAIAIA9PDQEgBiAFKALcAyIJTw1KIAUoAtgDIBNqIAw2AgAgC0EEaiELIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNSEHAAEHAABCtNiIBRQ1HIAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUhBwABBwAAQrTYiAUUNRyAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4IAUoAhgiCUECSQ0CQQEhB0EBIQMDQCAFKAIUIgIgA0ECdGoiASgCACABQQRrKAIAIgFHBEAgAUEASA0KIAUoAkQiC0EEaiIIIAUoAjwiBksEQCAFQThqIAZBAXQiBiAIENIqIgggBiAISxsQ6BkgBSgCRCILQQRqIQggBSgCPCEGCyAGIAhJBH8gBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQFIAsLIAUoAkBqIAE2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCADQYCAAk8NCyAFKAIsIgZBAmoiASAFKAIkIghLBEAgBUEgaiAIQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCCAFKAIsIgZBAmohAQsgASAISwR/IAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADOwAAIAUgBSgCLEECajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCUcNAAsgCUEBawwDCyABIAUoAlQiA08NRSACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUECdGooAgA2AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEQLIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAlFDQJBASEHIAUoAhQhAkEAC0ECdCACaigCACIGQQBIDQIgBSgCRCICQQRqIgMgBSgCPCIBSwRAIAVBOGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAJEIgJBBGohAyAFKAI8IQELIAEgA0kEfyAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRAUgAgsgBSgCQGogBjYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAlBgIACTw0DIAUoAiwiAkECaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQJqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCTsAACAFIAUoAixBAmoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGDhowYNgIAIAVCg4aMmLDgwIEDNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ08IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIKKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgsgARDNHCAIQYSIkCA2AgAgBUKEiJCgwICBggQ3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgBzYCpAMgARCXKSAFQUBrIgIoAgAhCCAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAg2ApwCIAUgARDXOyAFKAIAIQhBHEEEEK02IgJFDTwgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAooAgA2AgAgBSAHNgLcAyAFIAg2AtgDIAUgAjYC1AMgASADIAkQ+iMgAyABEM0cIAVBkAFqIgEgAxCtEyADIA5BIGpBiJ+CASABQeSAggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhHBEAgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCALEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEJ8JIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAULQX9BAEGQr4IBEMMhAAtBoK+CARCyOwALQbCvggEQsjsAC0HAr4IBELI7AAtB0K+CARCyOwALIAQtAJAaIgFBKUYNAyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG4FmogBEGwGmopAgA3AgAgBEGhFmogAykDADcAACAEQagWaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCsBYgBCABOgCYFiAEIBc3AJkWIARBmBZqEPUpIQEgAEHcp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIARBkBpqIQ0gASACEJoiIQ4jAEHgBGsiBSQAAkACQAJAAkACQAJ/AkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEGIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgBiEHIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIgtPDUwgBigCACIDIAtPDU1BAiEIAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBIIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVQgASgCACIBIAtPDVUgDyAJQQJ0aigCACAPIAFBAnRqKAIASA0CIAMhASAMIAhBAWoiCEcNAAsMAgsgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIJIAtPDVMgASgCACIBIAtPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATg0BIAMhASAMIAhBAWoiCEcNAAsMAQsgCCAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOQKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQuBUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQggEQRAIA5BDGpBABDfGSEKCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF8cWohB0EAIQEDQAJ/IApFBEAgCCAHIAMiBkcNARoMBQsgCiAHIANrQQJ2Tw0EIAMgCkECdGohBiAIIApqCyIMQQFqIQggBkEEaiEDQQAhCiABIAJPDQAgAUECdCELIAYoAgAgEWshDwNAIAEgBSgCVCIGTw1FIAUoAlAgC2ooAgAiBiACTw1GIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NRyAFKALYAyATaiAMNgIAIAtBBGohCyACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUVBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1FQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIglBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAFBAEgNCSAFKAJEIgtBBGoiCCAFKAI8IgZLBEAgBUE4aiAGQQF0IgYgCBDSKiIIIAYgCEsbEOgZIAUoAkQiC0EEaiEIIAUoAjwhBgsgBiAISQR/IAVBOGogBkEBdCIGIAgQ0ioiCCAGIAhLGxDoGSAFKAJEBSALCyAFKAJAaiABNgAAIAUgBSgCREEEajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQRqIgEgBSgCJCIISwRAIAVBIGogCEEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQggBSgCLCIGQQRqIQELIAEgCEsEfyAFQSBqIAhBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzYAACAFIAUoAixBBGo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAlHDQALIAlBAWsMAwsgASAFKAJUIgNPDUIgAiAFKAJQIAFBAnRqKAIAIgFLBEAgBSAQIAFBAnRqKAIANgIgIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYCPCAFIAVBOGo2AoADIAUgBUEgajYCOCAFQaACaiAFQfgCahCZDiAFQdQDahDpOwwBCwxBCyAFQcwAahDpOyAFQZgBaiAFQagCaigCACIBNgIAIAUgBSkCoAIiFzcDkAEgBSgCrAIhAiANQRBqIAE2AgAgDSAXNwIIIA0gAjYCFCANQY2AgIB4NgIEIA1BKToAAAwCCyAJRQ0CQQEhByAFKAIUIQJBAAtBAnQgAmooAgAiBkEASA0CIAUoAkQiAkEEaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCRCICQQRqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQFIAILIAUoAkBqIAY2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgJBBGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkEEaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAk2AAAgBSAFKAIsQQRqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNOSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCigCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiILIAEQzRwgCEGEiJAgNgIAIAVChIiQoMCAgYIENwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ05IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAKKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQrRMgAyAOQSBqQYifggEgAUHkgIIBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgCxCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCeCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQaCvggEQsjsAC0HAr4IBELI7AAsgBC0AkBoiAUEpRg0BIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAWaiAEQbAaaikCADcCACAEQckWaiADKQMANwAAIARB0BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYFiAEIAE6AMAWIAQgFzcAwRYgBEHAFmoQ9SkhASAAQbSoggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGQGmohDSABIAIQmyIhDiMAQeAEayIFJAACQAJAAkACQAJAAkACQAJAAkAgAygCFCIBQQNNBEAgBUEANgKoAiAFQoCAgIDAADcCoAIMAQsgAygCECEQIA4oAhwhESAOKAIYIRMgBUHMAGogAUECdiICQbz8gQEQpBogBSgCUCEHIAUoAlQhDCAFIAI2AvwCIAUgEDYC+AIgBSAFQfgCajYC1AMCQCAMQQJJIgENACAMQRVPBEAgByEGIAENASAGKAIEIgkgBUHUA2oiFCgCACIBKAIEIgtPDUogBigCACIDIAtPDUtBAiEIAkACQAJAAkAgASgCACIPIAlBAnRqKAIAIA8gA0ECdGooAgBIIhJFBEAgDEECRg0BIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVIgASgCACIBIAtPDVMgDyAJQQJ0aigCACAPIAFBAnRqKAIASA0CIAMhASAMIAhBAWoiCEcNAAsMAgsgDEECRg0AIAZBBGohAQNAIAFBBGoiAygCACIJIAtPDVEgASgCACIBIAtPDQQgDyAJQQJ0aigCACAPIAFBAnRqKAIATg0BIAMhASAMIAhBAWoiCEcNAAsMAQsgCCAMRw0BCyASRQ0DIAxBAXYhAyAMQQJ0IAZqQQRrIQgDQCAGKAIAIQEgBiAIKAIANgIAIAggATYCACAIQQRrIQggBkEEaiEGIANBAWsiAw0ACwwDCyAGIAxBACAMQQFyZ0EBdEE+cyAUEOkKDAILDE0LIAxBAnQhAUEEIQYDQCAHIAYgB2ogBUHUA2oQuBUgASAGQQRqIgZHDQALCwJAAkAgDEUNACAHIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDT8gBSAQIAFBAnRqKAIAIgE2AtwEIAEgE0kEQEEAIQcgEQRAIA5BDGpBABDIGSEKCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF4cWohCEEAIQEDQAJ/IApFBEAgByAIIAMiBkcNARoMBQsgCiAIIANrQQN2Tw0EIAMgCkEDdGohBiAHIApqCyIMQQFqIQcgBkEIaiEDQQAhCiABIAJPDQAgAUECdCELIAYoAgAgEWshDwNAIAEgBSgCVCIGTw1DIAUoAlAgC2ooAgAiBiACTw1EIBAgBkECdCITaigCACAPTw0BIAYgBSgC3AMiCU8NRSAFKALYAyATaiAMNgIAIAtBBGohCyACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQiAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1DQcAAQcAAEK02IgFFDUIgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOEEBIQogBSgCGCIIQQJPBEAgCK0hGEEAIQNCASEXA0AgBSgCFCADaiIBQQRqKAIAIAEoAgAiAUcEQCABQQBIDQkgBSgCRCIHQQRqIgYgBSgCPCICSwRAIAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEIgdBBGohBiAFKAI8IQILIAIgBkkEfyAFQThqIAJBAXQiAiAGENIqIgYgAiAGSxsQ6BkgBSgCRAUgBwsgBSgCQGogATYAACAFIAUoAkRBBGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCAKQQFqIQoLIANBBGohAyAYIBdCAXwiF1INAAsLIAhBAWshASAIRQ0EIAUoAhQgAUECdGooAgAiAkEASA0FIAUoAkQiBkEEaiIDIAUoAjwiAUsEQCAFQThqIAFBAXQiASADENIqIgMgASADSxsQ6BkgBSgCRCIGQQRqIQMgBSgCPCEBCyABIANJBH8gBUE4aiABQQF0IgEgAxDSKiIDIAEgA0sbEOgZIAUoAkQFIAYLIAUoAkBqIAI2AAAgBSAFKAJEQQRqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBCGoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiBkEIaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSAGCyAFQShqIgIoAgBqIAitNwAAIAUgBSgCLEEIaiIDNgIsIAUgBSgCMEEBajYCMCAFQaADaiIHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCjYCpAMgBUGcAmoiARCXKSACKAIAIQggAiAFQaQCaiIGKQIANwMAIAUpAyAhFyAFIAUpApwCNwMgIAVBADYCMCAFIBc3AqgCIAVBADYCpAIgBSADNgKgAiAFIAg2ApwCIAVBCGogARDXOyAFKAIIIQhBHEEEEK02IgJFDTsgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAVBrAJqIgkoAgA2AgAgBSADNgLcAyAFIAg2AtgDIAUgAjYC1AMgASAFQfgCaiIDIAVB1ANqIggQ+iMgBUHMAGoiCyABEM0cIAdBhIiQIDYCACAFQoSIkKDAgIGCBDcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAKNgKkAyABEJcpIAVBQGsiAigCACEKIAUoAkQhByACIAYpAgA3AwAgBSkDOCEXIAUgBSkCnAI3AzggBUEANgJIIAUgFzcCqAIgBUEANgKkAiAFIAc2AqACIAUgCjYCnAIgBSABENc7IAUoAgAhCkEcQQQQrTYiAkUNOyACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogCSgCADYCACAFIAc2AtwDIAUgCjYC2AMgBSACNgLUAyABIAMgCBD6IyADIAEQzRwgBUGQAWoiASADEK0TIAMgDkEgakGIn4IBIAFB5ICCARCTASAFKAKAAyECIAUoAvwCIQMgBSgC+AIiBkGTgICAeEYNAiANIAUpAoQDNwIQIA0gAjYCDCANIAM2AgggDSAGNgIEIA1BKToAACABEP4kIAsQgicgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsMAwsgASAFKAJUIgNPDUAgAiAFKAJQIAFBAnRqKAIAIgFLBEAgBSAQIAFBAnRqKAIANgIgIAVBAjYC/AIgBUHc8oEBNgL4AiAFQgE3AoQDIAVBOzYCPCAFIAVBOGo2AoADIAUgBUEgajYCOCAFQaACaiAFQfgCahCZDiAFQdQDahDpOwwBCww/CyAFQcwAahDpOyAFQZgBaiAFQagCaigCACIBNgIAIAUgBSkCoAIiFzcDkAEgBSgCrAIhAiANQRBqIAE2AgAgDSAXNwIIIA0gAjYCFCANQY2AgIB4NgIEIA1BKToAAAwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCgCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDCyABQQBBkK+CARDDIQALQaCvggEQsjsAC0HAr4IBELI7AAsgBC0AkBoiAUEpRwRAIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYgXaiAEQbAaaikCADcCACAEQfEWaiADKQMANwAAIARB+BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKAFyAEIAE6AOgWIAQgFzcA6RYgBEHoFmoQ9SkhASAAQYypggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMMAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMLwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAgBEG4D2oQyR4MLgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIEIgYtAABBAmsOCAECAwQFBgcIAAsgBCAGNgK4DyAEQQE2ApQaIARBnKaCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakGkpoIBEO8sAAsgBEGQGmohBiABIAIQxCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ3xYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0NIARBiBVqIgIgBkHEAPwKAAAgBEHXEWogBEHXGmotAAA6AAAgBCAELwDVGjsA1REgBEGQEWoiAyACQcQA/AoAACAEIAE6ANQRIAMQ6ykhASAAQZCgggE2AgggACABNgIEIABBk4CAgHg2AgAMOwsgBEGQGmohBiABIAIQwSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0LIARBiBVqIgIgBkHEAPwKAAAgBEGfEmogBEHXGmotAAA6AAAgBCAELwDVGjsAnRIgBEHYEWoiAyACQcQA/AoAACAEIAE6AJwSIAMQ6ykhASAAQeigggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmohBiABIAIQwCIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0JIARBiBVqIgIgBkHEAPwKAAAgBEHnEmogBEHXGmotAAA6AAAgBCAELwDVGjsA5RIgBEGgEmoiAyACQcQA/AoAACAEIAE6AOQSIAMQ6ykhASAAQcChggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmohBiABIAIQwyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQlxYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0HIARBiBVqIgIgBkHEAPwKAAAgBEGvE2ogBEHXGmotAAA6AAAgBCAELwDVGjsArRMgBEHoEmoiAyACQcQA/AoAACAEIAE6AKwTIAMQ6ykhASAAQZiiggE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgBEGQGmohBiABIAIQwiIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQ4BYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0FIARBiBVqIgIgBkHEAPwKAAAgBEH3E2ogBEHXGmotAAA6AAAgBCAELwDVGjsA9RMgBEGwE2oiAyACQcQA/AoAACAEIAE6APQTIAMQ6ykhASAAQfCiggE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgBEGQGmohBiABIAIQvyIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmBYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0DIARBiBVqIgIgBkHEAPwKAAAgBEG/FGogBEHXGmotAAA6AAAgBCAELwDVGjsAvRQgBEH4E2oiAyACQcQA/AoAACAEIAE6ALwUIAMQ6ykhASAAQcijggE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgBEGQGmohBiABIAIQviIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmRYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRg0BIARBiBVqIgIgBkHEAPwKAAAgBEGHFWogBEHXGmotAAA6AAAgBCAELwDVGjsAhRUgBEHAFGoiAyACQcQA/AoAACAEIAE6AIQVIAMQ6ykhASAAQaCkggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGQGmohBiABIAIQvSIhAiMAQYABayIBJAAgAUEgaiACQQxqIAMQmhYCQAJAAkAgAS0AICIDQSlGBEAgAUEbaiABQTRqKAIAIgI2AAAgAUETaiABQSxqKQIAIhc3AAAgASABKQIkIhg3AAsgBkEQaiACNgAAIAZBCGogFzcAACAGIBg3AAAgBkECOgBEDAELIAFBF2oiByABQTBqKQAANwAAIAFBEGoiBSABQSlqKQAANwMAIAFB8ABqIAFBQGspAgA3AgAgAUH4AGogAUHIAGopAgA3AgAgAUHZAGogBSkDADcAACABQeAAaiAHKQAANwAAIAEgASkCODcCaCABIAM6AFAgASABKQAhNwBRIAIoAjwiAyADKAIAIgdBAWo2AgAgB0EASA0BIAYgAUHQAGogAyACKAJAEMcVCyABQYABaiQADAELAAsgBC0A1BoiAUECRwRAIARBiBVqIgIgBkHEAPwKAAAgBEGXFmogBEHXGmotAAA6AAAgBCAELwDVGjsAlRYgBEHQFWoiAyACQcQA/AoAACAEIAE6AJQWIAMQ6ykhASAAQfikggE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMNAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMQsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMMAsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLwsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLgsgBEGYFWogBEGgGmooAgAiATYCACAEQZAVaiAEQZgaaikCACIXNwMAIAQgBCkCkBoiGDcDiBUgAEEQaiABNgIAIABBCGogFzcCACAAIBg3AgAMLQsgBigCACIBIAEoAgAiAkEBajYCACACQQBIDQEgCCgCCCECIARBwB5qIARBiB9qKAIANgIAIAQgBCkCgB83A7geIARBADYCuBkgBEHAD2ogBEGEGWooAgA2AgAgBCAEKQL8GDcDuA8gBEGQGmogASACIARBuB5qIARBuBlqIARBuA9qEJEEIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4RgRAIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwtCyAEQbAZaiAEQbgaaikCADcCACAEQagZaiAEQbAaaikCADcCACAEQZQZaiABKQMANwIAIARBnBlqIAIoAgA2AgAgBCAEKQKoGjcCoBkgBCADNgKIGSAEIAQpA4gVNwKMGSAEQYgZahDcKSEBIABBsJ6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAwsCyAEQcgAaiABIAIoAhARAAAgBEGQGmoiAiAEKAJIIgEgBCgCTCgCDBEAAAJAAkAgAUUNACAEKQOQGkLnmcHShtGszbN/hSAEKQOYGkLlkuGP24mtrlKFhFBFDQAgBEGIFWoiByABKAIcIAEoAiAgAxC9FiAEQQA2AugZIARBoBpqIARB+BlqKQIANwMAIARBmBpqIARB8BlqKQIANwMAIAQgBCkC6Bk3A5AaIARBuBlqIgUgByACENgdIAEQkzYiCUUNASACIAkoAgQgCSgCCEECdiADELsWIARBuA9qIgMgAiAEQegZahC/HSAEQUBrIAYQsC4gBCkDQCEXIAQgATYCoBogBCAXNwKQGiAEIAM2ApwaIAQgBTYCmBogByACELsVIARBwB5qIgEgBEGUFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiAkGTgICAeEcEQCAEKAKYFSEGIAAgBCkDuB43AgQgACAGNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAgAxD+JCAFEP4kDC4LIARBiBpqIARBwB5qKAIANgIAIAQgBCkDuB43A4AaIARBkBpqIgFBAEGABPwLACAEIAQoAsgZIgI2AogVIAQgAiAEQcwZaiIDKAIAajYCjBUgBCABNgKQFSAEQZweaiAEQYgVaiIBELwsIARBsB5qIAMoAgAiAjYCACAEQZwVaiACNgIAIARBqBVqIARB2BlqKQIANwMAIARBsBVqIARB4BlqKQIANwMAIARBkBVqIARBwBlqKAIANgIAIAQgBCkCxBkiFzcDqB4gBCAXNwKUFSAEIAQpAtAZNwOgFSAEIAQpArgZNwOIFSABELQMAkAgBCgCoBUiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEGgFWoQ+x4LIAYoAgAiASABKAIAIgJBAWo2AgAgAkEASA0CIAgoAgghAiAEQYgfaiAEQaQeaigCADYCACAEIAQpApweNwOAHyAEQYgVaiABIAIgBEGoHmogBEGAH2ogBEGAGmoQkQQgBEHAHmoiASAEQZQVaikCADcDACAEQcgeaiICIARBnBVqKAIANgIAIAQgBCkCjBU3A7geIAQoAogVIgNBgICAgHhGBEAgACAEKQO4HjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIARBuA9qEP4kDC4LIARB+B5qIARBsBVqKQIANwIAIARB8B5qIARBqBVqKQIANwIAIARB3B5qIAEpAwA3AgAgBEHkHmogAigCADYCACAEIAQpAqAVNwLoHiAEIAM2AtAeIAQgBCkDuB43AtQeIARB0B5qENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIARBuA9qEP4kDC0LQfCfggEQsjsAC0GAoIIBELI7AAsACyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwpCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwoCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMJQsgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADCQLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCMLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCILIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCELIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB8LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB4LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADB0LIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBwLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBsLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBoLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBgLIARBCGpBxI6CASADEKErIAAgBCkDCDcCBCAAQZOAgIB4NgIADBcLIAQgCDYCuA8gBEEBNgKUGiAEQcirggE2ApAaIARCATcCnBogBEGvAzYCjBUgBCAEQYgVajYCmBogBCAEQbgPajYCiBUgBEGQGmpB0KuCARDvLAALIARBkwZqIAEoAAAiATYAACAEQYsGaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAgwYgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMFQsgBEHjBWogASgAACIBNgAAIARB2wVqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDTBSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwUCyAEQbMFaiABKAAAIgE2AAAgBEGrBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AKMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBMLIARBgwVqIAEoAAAiATYAACAEQfsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA8wQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMDAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCwsgBEHTBGogASgAACIBNgAAIARBywRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDDBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwKCyAEQaMEaiABKAAAIgE2AAAgBEGbBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AJMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAkLIARB8wNqIAEoAAAiATYAACAEQesDaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcA4wMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCAsgBEHDA2ogBEGkGmooAgAiATYAACAEQbsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAswMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBwsgBEGTA2ogBEGkGmooAgAiATYAACAEQYsDaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAgwMgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBgsgBEHjAmogBEGkGmooAgAiATYAACAEQdsCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA0wIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBQsgBEGzAmogBEGkGmooAgAiATYAACAEQasCaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAowIgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMBAsgBEGDAmogBEGkGmooAgAiATYAACAEQfsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcA8wEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAwsgBEHTAWogBEGkGmooAgAiATYAACAEQcsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAwwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAgsgBEGjAWogBEGkGmooAgAiATYAACAEQZsBaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAkwEgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMAQsgBEHzAGogBEGkGmooAgAiATYAACAEQesAaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAYyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAsgBEGQH2okAA8LQQRBOBCjPQALQQRBHBCjPQALIAEgAkG48YEBEMMhAAsgASAGQezygQEQwyEACyAGIAJB/PKBARDDIQALIAYgCUGM84EBEMMhAAsgASACQejxgQEQwyEACyABIANB2PGBARDDIQALQcAAQcAAEKM9AAtBwPSBAUEpIAVB+AJqQcz8gQFB7PSBARDVHgALIAIgCSgCHEG8/IEBEP0vAAsgBiAJKAIcQbz8gQEQ/S8AC0HAACABEKM9AAsgCSALQfD2gwEQwyEACyADIAtBgPeDARDDIQALIAkgC0Hw9oMBEMMhAAsgASALQYD3gwEQwyEAC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyABQQE2AhQgAUHctoIBNgIQIAFCATcCHCABQe0GNgIsIAEgAUEoajYCGCABIAFBDGo2AiggAUEQakHktoIBEO8sAAuIyAIEE38EfgF9AXwjAEGQH2siBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEgAigCHCIHEQQAIgYtAABBAmsOJQMEBQYHCAkKCwwNAAAAAAABAgAAAAAAAAAAAAAAAAAAABUWFxgACyABIAcRBAAiBi0AAA4pHhhVVVVVVVVVVVVVVRkjJBobVVUpHCssLS4vMFUdMlUzNDVVVVVVNjdVCyAGLQABQQFrDgMNDg8MCyAGLQABQQFrDgIQEQ8LIARBkBpqIAEgAhC7IiADEOUWIAQtAJAaIgJBKUYNaCAEQe8AaiIDIARBoBpqKQAANwAAIARB6ABqIgYgBEGZGmopAAA3AwAgBEGAAWoiByAEQbAaaikCADcDACAEQYgBaiIFIARBuBpqKQIANwMAIAQgBCkAkRo3A2AgBCAEKQKoGjcDeEE4QQQQrTYiAUUNaiABIAI6AAggAUKBgICAEDcCACABIAQpA2A3AAkgASAEKQN4NwIgIABBtP+BATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaQsgBEGQGmogASACEKgiIAMQpxYgBC0AkBoiAkEpRg1mIARBnwFqIgMgBEGgGmopAAA3AAAgBEGYAWoiBiAEQZkaaikAADcDACAEQbABaiIHIARBsBpqKQIANwMAIARBuAFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDkAEgBCAEKQKoGjcDqAFBOEEEEK02IgFFDWkgASACOgAIIAFCgYCAgBA3AgAgASAEKQOQATcACSABIAQpA6gBNwIgIABBjICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMaAsgBEGQGmogASACELEiIAMQqBYgBC0AkBoiAkEpRg1kIARBzwFqIgMgBEGgGmopAAA3AAAgBEHIAWoiBiAEQZkaaikAADcDACAEQeABaiIHIARBsBpqKQIANwMAIARB6AFqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDwAEgBCAEKQKoGjcD2AFBOEEEEK02IgFFDWggASACOgAIIAFCgYCAgBA3AgAgASAEKQPAATcACSABIAQpA9gBNwIgIABB5ICCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZwsgBEGQGmogASACEKQiIAMQqRYgBC0AkBoiAkEpRg1iIARB/wFqIgMgBEGgGmopAAA3AAAgBEH4AWoiBiAEQZkaaikAADcDACAEQZACaiIHIARBsBpqKQIANwMAIARBmAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD8AEgBCAEKQKoGjcDiAJBOEEEEK02IgFFDWcgASACOgAIIAFCgYCAgBA3AgAgASAEKQPwATcACSABIAQpA4gCNwIgIABBvIGCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZgsgBEGQGmogASACEKoiIAMQ5hYgBC0AkBoiAkEpRg1gIARBrwJqIgMgBEGgGmopAAA3AAAgBEGoAmoiBiAEQZkaaikAADcDACAEQcACaiIHIARBsBpqKQIANwMAIARByAJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDoAIgBCAEKQKoGjcDuAJBOEEEEK02IgFFDWYgASACOgAIIAFCgYCAgBA3AgAgASAEKQOgAjcACSABIAQpA7gCNwIgIABBlIKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZQsgBEGQGmogASACEK0iIAMQqhYgBC0AkBoiAkEpRg1eIARB3wJqIgMgBEGgGmopAAA3AAAgBEHYAmoiBiAEQZkaaikAADcDACAEQfACaiIHIARBsBpqKQIANwMAIARB+AJqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcD0AIgBCAEKQKoGjcD6AJBOEEEEK02IgFFDWUgASACOgAIIAFCgYCAgBA3AgAgASAEKQPQAjcACSABIAQpA+gCNwIgIABB7IKCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMZAsgBEGQGmogASACELciIAMQqxYgBC0AkBoiAkEpRg1cIARBjwNqIgMgBEGgGmopAAA3AAAgBEGIA2oiBiAEQZkaaikAADcDACAEQaADaiIHIARBsBpqKQIANwMAIARBqANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDgAMgBCAEKQKoGjcDmANBOEEEEK02IgFFDWQgASACOgAIIAFCgYCAgBA3AgAgASAEKQOAAzcACSABIAQpA5gDNwIgIABBxIOCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYwsgBEGQGmogASACEKIiIAMQrBYgBC0AkBoiAkEpRg1aIARBvwNqIgMgBEGgGmopAAA3AAAgBEG4A2oiBiAEQZkaaikAADcDACAEQdADaiIHIARBsBpqKQIANwMAIARB2ANqIgUgBEG4GmopAgA3AwAgBCAEKQCRGjcDsAMgBCAEKQKoGjcDyANBOEEEEK02IgFFDWMgASACOgAIIAFCgYCAgBA3AgAgASAEKQOwAzcACSABIAQpA8gDNwIgIABBnISCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAYpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAMYgsgBEGAH2oiBiABIAIQuSIiASgCECABKAIUQQF2IAMQxhYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQzx0gBEG4HmoiAiABEMoGIAIQmB4gBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNWCAEQe8DaiIDIARBxxlqKQAANwAAIARB6ANqIgUgBEHAGWopAwA3AwAgBEGABGoiCCAGKQMANwMAIARBiARqIgYgBykDADcDACAEIAQpA7gZNwPgAyAEIAQpA7gPNwP4A0E4QQQQrTYiAUUNYiABIAI6AAggAUKBgICAEDcCACABIAQpA+ADNwAJIAEgBCkD+AM3AiAgAEH0hIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxhCyAEQYAfaiEOIAEgAhC1IiIKKAIQIQIgCigCFEECdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQUgAygCFCEIIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAUgCEF4cWo2AhAgASAFNgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCAIKAIYIQIgCCgCFEEBRg1tIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayIHJAAgCEEIaiICIAUoAgQgBSgCAGtBA3YQ7i0gAikCBCEXIAdBGGogBUEQaikCADcDACAHQRBqIAVBCGopAgA3AwAgByAFKQIANwMIIAcgF0IgiTcCKCAHIAJBCGo2AiQjAEEwayICJAAgB0EkaiINKAIEIQsgDSgCACESAkAgB0EIaiIFKAIAIgkgBSgCBCIPRwRAIAUoAhQhDCAFKAIQIRMgBSgCDCEUIAUoAgghBSANKAIIIAtBAnRqIQ0gDyAJa0EDdiEPA0AgAiAJNgIMAkAgCSgCACIRIBNJBEAgFCARQQJ0aioCACEbDAELIAUgDCgCEE8Nd0MAAAAAIRsgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXgLIA0gGzgCACAJQQhqIQkgDUEEaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCNGwsgDiAGEOgYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARC+HSAEQbgeaiIBIAoQygYgARCTHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1WIARBnwRqIgMgBEHHGWopAAA3AAAgBEGYBGoiBSAEQcAZaikDADcDACAEQbAEaiIIIAYpAwA3AwAgBEG4BGoiBiAHKQMANwMAIAQgBCkDuBk3A5AEIAQgBCkDuA83A6gEQThBBBCtNiIBRQ1hIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDkAQ3AAkgASAEKQOoBDcCICAAQcyFggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADGALIARBgB9qIQ4gASACEKYiIgooAhAhAiAKKAIUQQN2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBCEEIEKAYIAgoAhghAiAIKAIUQQFGDWwgCEEQaiIQQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDsLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg0oAgQhCyANKAIAIRICQCAHQQhqIgUoAgAiCSAFKAIEIg9HBEAgBSgCFCEMIAUoAhAhEyAFKAIMIRQgBSgCCCEFIA0oAgggC0EDdGohDSAPIAlrQQN2IQ8DQCACIAk2AgwCQCAJKAIAIhEgE0kEQCAUIBFBA3RqKwMAIRwMAQsgBSAMKAIQTw12RAAAAAAAAAAAIRwgDCgCBCAFIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDXcLIA0gHDkDACAJQQhqIQkgDUEIaiENIAVBAWohBSALQQFqIQsgD0EBayIPDQALCyASIAs2AgAgAkEwaiQADAALIAdBMGokACAGQQhqIBAoAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEFIAEgBjYCGCABIAI2AhQgASAHIAVBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahD7GgsgDiAGEOcYIAFBMGokACAEQYgVaiIBIAoQkjYgAxDzEiAEQZAaaiIDIA4gARDbHSAEQbgeaiIBIAoQygYgARCQHiAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1UIARBzwRqIgMgBEHHGWopAAA3AAAgBEHIBGoiBSAEQcAZaikDADcDACAEQeAEaiIIIAYpAwA3AwAgBEHoBGoiBiAHKQMANwMAIAQgBCkDuBk3A8AEIAQgBCkDuA83A9gEQThBBBCtNiIBRQ1gIAEgAjoACCABQoGAgIAQNwIAIAEgBCkDwAQ3AAkgASAEKQPYBDcCICAAQaSGggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADF8LIAEgAhCzIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC8HSABQdQAaiIGIAIQygYgBhDyHCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHgB2ogBEGwGmopAgA3AgAgBEHoB2ogBEG4GmopAgA3AgAgBEHJB2ogAykDADcAACAEQdAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC2AcgBCABOgDAByAEIBc3AMEHIARBwAdqENwpIQEgAEH8hoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADF4LIAEgAhChIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDAHSABQdQAaiIGIAIQygYgBhD1HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNUCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGQCGogBEGwGmopAgA3AgAgBEGYCGogBEG4GmopAgA3AgAgBEH5B2ogAykDADcAACAEQYAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCiAggBCABOgDwByAEIBc3APEHIARB8AdqENwpIQEgAEHUh4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADF0LIAEgAhCdIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDDHSABQdQAaiIGIAIQygYgBhD6HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHACGogBEGwGmopAgA3AgAgBEHICGogBEG4GmopAgA3AgAgBEGpCGogAykDADcAACAEQbAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCuAggBCABOgCgCCAEIBc3AKEIIARBoAhqENwpIQEgAEGsiIIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFwLIAEgAhCuIiECIwBB4ABrIgEkACABIAIoAhAgAigCFEEDdiADEMgWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhDQHSABQdQAaiIGIAIQygYgBhD5HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNTCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHwCGogBEGwGmopAgA3AgAgBEH4CGogBEG4GmopAgA3AgAgBEHZCGogAykDADcAACAEQeAIaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC6AggBCABOgDQCCAEIBc3ANEIIARB0AhqENwpIQEgAEGEiYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFsLIAEgAhC4IiECIwBB4ABrIgEkACABIAIoAhAgAigCFEECdiADEMcWIAFBDGoiBiACEJI2IAMQ8xIgAUEkaiIDIAEgBhC9HSABQdQAaiIGIAIQygYgBhD0HCAEQZAaaiICQQhqIAFB3ABqKAIANgIAIAIgASkCVDcCACACIAEpAjA3AgwgAkEUaiABQThqKAIANgIAIAIgASkCPDcCGCACQSBqIAFBxABqKQIANwIAIAJBKGogAUHMAGopAgA3AgAgAxC7DCABQeAAaiQAIAQtAJAaIgFBKUYNSiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHQBmogBEGwGmopAgA3AgAgBEHYBmogBEG4GmopAgA3AgAgBEG5BmogAykDADcAACAEQcAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCyAYgBCABOgCwBiAEIBc3ALEGIARBsAZqENwpIQEgAEHciYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFoLIAEgAhCjIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEDdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQRBCBCgGCAIKAIYIQYgCCgCFEEBRg1nIAhBEGoiE0EANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6i0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACEUAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIREgCSgCDCEVIAkoAgghCSANKAIIIAxBA3RqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIQIBFJBEAgFSAQQQN0aiISKAIEIRAgEigCACESDAELIAkgDigCEE8NcEEAIRBBACESIA4oAgQgCSAOKAIMaiIWQQN2ai0AACAWQQdxdkEBcQ1yCyANIBI2AgAgDUEEaiAQNgIAIAtBCGohCyANQQhqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBQgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogEygCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEJUbCyAFIAcQ6xggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDTHSAFQdQAaiIBIAoQygYgARD3HCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNSCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGAB2ogBEGwGmopAgA3AgAgBEGIB2ogBEG4GmopAgA3AgAgBEHpBmogAykDADcAACAEQfAGaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC+AYgBCABOgDgBiAEIBc3AOEGIARB4AZqENwpIQEgAEG0ioIBNgIIIAAgATYCBCAAQZOAgIB4NgIADFkLIAEgAhCgIiEKIwBB4ABrIgUkACAKKAIQIQEgCigCFEEEdiEGIwBBMGsiAiQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCEJIAIgBzYCICACIAY2AhwgAiABNgIYIAJBADYCFCACIAggCUF4cWo2AhAgAiAINgIMIAJBJGohByMAQSBrIggkACAIQRRqIAJBDGoiASgCBCABKAIAa0EDdkEAQQhBEBCgGCAIKAIYIQYgCCgCFEEBRg1mIAhBEGoiEEEANgIAIAggCCgCHDYCDCAIIAY2AggjAEEwayIGJAAgCEEIaiIJIAEoAgQgASgCAGtBA3YQ6S0gCSkCBCEXIAZBGGogAUEQaikCADcDACAGQRBqIAFBCGopAgA3AwAgBiABKQIANwMIIAYgF0IgiTcCKCAGIAlBCGo2AiQjAEEwayIBJAAgBkEkaiINKAIEIQwgDSgCACESAkAgBkEIaiIJKAIAIgsgCSgCBCIPRwRAIAkoAhQhDiAJKAIQIRMgCSgCDCEUIAkoAgghCSANKAIIIAxBBHRqIQ0gDyALa0EDdiEPA0AgASALNgIMAkAgCygCACIRIBNJBEAgAUEYaiAUIBFBBHRqIhFBCGopAwA3AwAgASARKQMANwMQDAELIAkgDigCEE8NbyAOKAIEIAkgDigCDGoiEUEDdmotAAAgEUEHcXZBAXENcSABQRhqQgA3AwAgAUIANwMQCyANIAEpAxA3AwAgDUEIaiABQRhqKQMANwMAIAtBCGohCyANQRBqIQ0gCUEBaiEJIAxBAWohDCAPQQFrIg8NAAsLIBIgDDYCACABQTBqJAAMAAsgBkEwaiQAIAdBCGogECgCADYCACAHIAgpAgg3AgAgCEEgaiQADAELIAMoAhAhByADKAIUIQggAiAGNgIYIAIgATYCFCACIAcgCEF4cWo2AhAgAiAHNgIMIAJBJGoiByACQQxqEP4aCyAFIAcQ6hggAkEwaiQAIAVBDGoiASAKEJI2IAMQ8xIgBUEkaiICIAUgARDFHSAFQdQAaiIBIAoQygYgARDxHCAEQZAaaiIBQQhqIAVB3ABqKAIANgIAIAEgBSkCVDcCACABIAUpAjA3AgwgAUEUaiAFQThqKAIANgIAIAEgBSkCPDcCGCABQSBqIAVBxABqKQIANwIAIAFBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAIAQtAJAaIgFBKUYNRiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEGwB2ogBEGwGmopAgA3AgAgBEG4B2ogBEG4GmopAgA3AgAgBEGZB2ogAykDADcAACAEQaAHaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCqAcgBCABOgCQByAEIBc3AJEHIARBkAdqENwpIQEgAEGMi4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADFgLIARBgB9qIgYgASACEKciIgEoAhAgASgCFEECdiADEMcWIARBiBVqIgIgARCSNiADEPMSIARBkBpqIgMgBiACEModIARBuB5qIgIgARDKBiACENAYIARByxlqIgEgBEGkGmooAgA2AAAgBEHAD2oiBiAEQbAaaikCADcDACAEQcgPaiIHIARBuBpqKQIANwMAIAQgBCkAuR43A7gZIAQgBEHAHmooAAA2AL8ZIAQgBCkCnBo3AMMZIAQgBCkCqBo3A7gPIAQtALgeIQIgAxC7DCACQSlGDUQgBEH/BGoiAyAEQccZaikAADcAACAEQfgEaiIFIARBwBlqKQMANwMAIARBkAVqIgggBikDADcDACAEQZgFaiIGIAcpAwA3AwAgBCAEKQO4GTcD8AQgBCAEKQO4DzcDiAVBOEEEEK02IgFFDVggASACOgAIIAFCgYCAgBA3AgAgASAEKQPwBDcACSABIAQpA4gFNwIgIABB5IuCATYCCCAAIAE2AgQgAEGTgICAeDYCACABQRFqIAUpAwA3AAAgAUEYaiADKQAANwAAIAFBKGogCCkDADcCACABQTBqIAYpAwA3AgAMVwsgBEGAH2oiBiABIAIQqyIiASgCECABKAIUQQN2IAMQyBYgBEGIFWoiAiABEJI2IAMQ8xIgBEGQGmoiAyAGIAIQxh0gBEG4HmoiAiABEMoGIAIQ0hggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNQiAEQa8FaiIDIARBxxlqKQAANwAAIARBqAVqIgUgBEHAGWopAwA3AwAgBEHABWoiCCAGKQMANwMAIARByAVqIgYgBykDADcDACAEIAQpA7gZNwOgBSAEIAQpA7gPNwO4BUE4QQQQrTYiAUUNVyABIAI6AAggAUKBgICAEDcCACABIAQpA6AFNwAJIAEgBCkDuAU3AiAgAEG8jIIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxWCyAEQYAfaiEJIAEgAhC8IiIFKAIQIQIgBSgCFEEEdiEGIwBBMGsiASQAAkACQCADEJI2IgdFDQAgBygCFEUNACADKAIQIQggAygCFCELIAEgBzYCICABIAY2AhwgASACNgIYIAFBADYCFCABIAggC0F4cWo2AhAgASAINgIMIAFBJGohBiMAQSBrIggkACAIQRRqIAFBDGoiBygCBCAHKAIAa0EDdkEAQRBBEBCgGCAIKAIYIQIgCCgCFEEBRg1iIAhBEGoiCkEANgIAIAggCCgCHDYCDCAIIAI2AggjAEEwayICJAAgCEEIaiILIAcoAgQgBygCAGtBA3YQ6y0gCykCBCEXIAJBGGogB0EQaikCADcDACACQRBqIAdBCGopAgA3AwAgAiAHKQIANwMIIAIgF0IgiTcCKCACIAtBCGo2AiQgAkEIaiACQSRqEKwQIAJBMGokACAGQQhqIAooAgA2AgAgBiAIKQIINwIAIAhBIGokAAwBCyADKAIQIQcgAygCFCEIIAEgBjYCGCABIAI2AhQgASAHIAhBeHFqNgIQIAEgBzYCDCABQSRqIgYgAUEMahCJGwsgCSAGEOwYIAFBMGokACAEQYgVaiIBIAUQkjYgAxDzEiAEQZAaaiIDIAkgARDLHSAEQbgeaiIBIAUQygYgARDTGCAEQcsZaiIBIARBpBpqKAIANgAAIARBwA9qIgYgBEGwGmopAgA3AwAgBEHID2oiByAEQbgaaikCADcDACAEIAQpALkeNwO4GSAEIARBwB5qKAAANgC/GSAEIAQpApwaNwDDGSAEIAQpAqgaNwO4DyAELQC4HiECIAMQuwwgAkEpRg1AIARB3wVqIgMgBEHHGWopAAA3AAAgBEHYBWoiBSAEQcAZaikDADcDACAEQfAFaiIIIAYpAwA3AwAgBEH4BWoiBiAHKQMANwMAIAQgBCkDuBk3A9AFIAQgBCkDuA83A+gFQThBBBCtNiIBRQ1WIAEgAjoACCABQoGAgIAQNwIAIAEgBCkD0AU3AAkgASAEKQPoBTcCICAAQZSNggE2AgggACABNgIEIABBk4CAgHg2AgAgAUERaiAFKQMANwAAIAFBGGogAykAADcAACABQShqIAgpAwA3AgAgAUEwaiAGKQMANwIADFULIARBgB9qIQ8gASACEKkiIgwoAhAhAiAMKAIUQQV2IQYjAEEwayIBJAACQAJAIAMQkjYiB0UNACAHKAIURQ0AIAMoAhAhBSADKAIUIQggASAHNgIgIAEgBjYCHCABIAI2AhggAUEANgIUIAEgBSAIQXhxajYCECABIAU2AgwgAUEkaiEGIwBBIGsiCCQAIAhBFGogAUEMaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAgoAhghAiAIKAIUQQFGDWEgCEEQaiISQQA2AgAgCCAIKAIcNgIMIAggAjYCCCMAQTBrIgckACAIQQhqIgIgBSgCBCAFKAIAa0EDdhDvLSACKQIEIRcgB0EYaiAFQRBqKQIANwMAIAdBEGogBUEIaikCADcDACAHIAUpAgA3AwggByAXQiCJNwIoIAcgAkEIajYCJCMAQTBrIgIkACAHQSRqIg4oAgQhCyAOKAIAIRMCQCAHQQhqIgUoAgAiCSAFKAIEIhBHBEAgBSgCFCENIAUoAhAhFCAFKAIMIREgBSgCCCEKIA4oAgggC0EFdGohBSAQIAlrQQN2IRADQCACIAk2AgwCQCAJKAIAIg4gFEkEQCARIA5BBXRqIg4pAxghFyAOKQMQIRggDikDCCEZIA4pAwAhGgwBCyAKIA0oAhBPDWtCACEaQgAhGUIAIRhCACEXIA0oAgQgCiANKAIMaiIOQQN2ai0AACAOQQdxdkEBcQ1sCyAFIBo3AwAgBUEYaiAXNwMAIAVBEGogGDcDACAFIBk3AwggCUEIaiEJIAVBIGohBSAKQQFqIQogC0EBaiELIBBBAWsiEA0ACwsgEyALNgIAIAJBMGokAAwACyAHQTBqJAAgBkEIaiASKAIANgIAIAYgCCkCCDcCACAIQSBqJAAMAQsgAygCECEHIAMoAhQhBSABIAY2AhggASACNgIUIAEgByAFQXhxajYCECABIAc2AgwgAUEkaiIGIAFBDGoQhRsLIA8gBhDtGCABQTBqJAAgBEGIFWoiASAMEJI2IAMQ8xIgBEGQGmoiAyAPIAEQzh0gBEG4HmoiASAMEMoGIAEQ0RggBEHLGWoiASAEQaQaaigCADYAACAEQcAPaiIGIARBsBpqKQIANwMAIARByA9qIgcgBEG4GmopAgA3AwAgBCAEKQC5HjcDuBkgBCAEQcAeaigAADYAvxkgBCAEKQKcGjcAwxkgBCAEKQKoGjcDuA8gBC0AuB4hAiADELsMIAJBKUYNPiAEQY8GaiIDIARBxxlqKQAANwAAIARBiAZqIgUgBEHAGWopAwA3AwAgBEGgBmoiCCAGKQMANwMAIARBqAZqIgYgBykDADcDACAEIAQpA7gZNwOABiAEIAQpA7gPNwOYBkE4QQQQrTYiAUUNVSABIAI6AAggAUKBgICAEDcCACABIAQpA4AGNwAJIAEgBCkDmAY3AiAgAEHsjYIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAFBEWogBSkDADcAACABQRhqIAMpAAA3AAAgAUEoaiAIKQMANwIAIAFBMGogBikDADcCAAxUCyAEQRhqIAEgAigCEBEAACAEQZAaaiIBIAQoAhgiAiAEKAIcKAIMEQAAIAJFDR8gBCkDkBpCiqLN5aLCqolqhSAEKQOYGkKLsvnezZq73jmFhFBFDR8gASACIAMQ9iggARD2KSEBIABB4I6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAxTCyAGLQABQQFrDgMGBwgFCyAGLQABDgIKCzoLIAYtAAFBAmsOAgsMOQsgBEEgaiABIAIoAhARAAAgBEGQGmoiAiAEKAIgIgEgBCgCJCgCDBEAACABRQ0cIAQpA5AaQsDjtd7S/qWVLIUgBCkDmBpC9c6oqNH+2sykf4WEUEUNHCACIAEgAyAGKAIEENQVIAQtAJAaIgFBKUcNDSAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxPCyAEQShqIAEgAigCEBEAACAEQZAaaiICIAQoAigiASAEKAIsKAIMEQAAIAFFDRwgBCkDkBpC/9nrqtfYi4zxAIUgBCkDmBpCgfTho6r41uqLf4WEUEUNHCACIAEgAyAGKAIEEOkCIAQtAJAaIgFBKUcNEyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAxOCyABIAIoAiQRBAAgA0EMaiIDENg8IAMQ2DwhA0kNNSAEQRBqIAFBACADIAIoAiARBQAgACAEKQMQNwIEIABBk4CAgHg2AgAMTQsgASACEJ8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENQdIAFB1ABqIgYgAhDKBiAGEIUXIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0zIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQcALaiAEQbAaaikCADcCACAEQcgLaiAEQbgaaikCADcCACAEQakLaiADKQMANwAAIARBsAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwK4CyAEIAE6AKALIAQgFzcAoQsgBEGgC2oQ3CkhASAAQbiPggE2AgggACABNgIEIABBk4CAgHg2AgAMTAsgASACELQiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMgdIAFB1ABqIgYgAhDKBiAGEP4WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0xIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQfALaiAEQbAaaikCADcCACAEQfgLaiAEQbgaaikCADcCACAEQdkLaiADKQMANwAAIARB4AtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLoCyAEIAE6ANALIAQgFzcA0QsgBEHQC2oQ3CkhASAAQZCQggE2AgggACABNgIEIABBk4CAgHg2AgAMSwsgASACELIiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMkdIAFB1ABqIgYgAhDKBiAGEP0WIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0vIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAMaiAEQbAaaikCADcCACAEQagMaiAEQbgaaikCADcCACAEQYkMaiADKQMANwAAIARBkAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYDCAEIAE6AIAMIAQgFzcAgQwgBEGADGoQ3CkhASAAQeiQggE2AgggACABNgIEIABBk4CAgHg2AgAMSgsgASACEKwiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENEdIAFB1ABqIgYgAhDKBiAGEPwWIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0tIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAMaiAEQbAaaikCADcCACAEQdgMaiAEQbgaaikCADcCACAEQbkMaiADKQMANwAAIARBwAxqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLIDCAEIAE6ALAMIAQgFzcAsQwgBEGwDGoQ3CkhASAAQcCRggE2AgggACABNgIEIABBk4CAgHg2AgAMSQsgASACEKUiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENIdIAFB1ABqIgYgAhDKBiAGEJQeIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0rIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAKaiAEQbAaaikCADcCACAEQegKaiAEQbgaaikCADcCACAEQckKaiADKQMANwAAIARB0ApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYCiAEIAE6AMAKIAQgFzcAwQogBEHACmoQ3CkhASAAQZiSggE2AgggACABNgIEIABBk4CAgHg2AgAMSAsgASACELAiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMQdIAFB1ABqIgYgAhDKBiAGEJceIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0pIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQZALaiAEQbAaaikCADcCACAEQZgLaiAEQbgaaikCADcCACAEQfkKaiADKQMANwAAIARBgAtqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKICyAEIAE6APAKIAQgFzcA8QogBEHwCmoQ3CkhASAAQfCSggE2AgggACABNgIEIABBk4CAgHg2AgAMRwsgASACEJ4iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMwdIAFB1ABqIgYgAhDKBiAGEPgcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0nIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaAJaiAEQbAaaikCADcCACAEQagJaiAEQbgaaikCADcCACAEQYkJaiADKQMANwAAIARBkAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKYCSAEIAE6AIAJIAQgFzcAgQkgBEGACWoQ3CkhASAAQciTggE2AgggACABNgIEIABBk4CAgHg2AgAMRgsgASACELYiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQJ2IAMQxxYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENcdIAFB1ABqIgYgAhDKBiAGEPMcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0lIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQdAJaiAEQbAaaikCADcCACAEQdgJaiAEQbgaaikCADcCACAEQbkJaiADKQMANwAAIARBwAlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLICSAEIAE6ALAJIAQgFzcAsQkgBEGwCWoQ3CkhASAAQaCUggE2AgggACABNgIEIABBk4CAgHg2AgAMRQsgASACEK8iIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGEMIdIAFB1ABqIgYgAhDKBiAGEPscIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0jIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQYAKaiAEQbAaaikCADcCACAEQYgKaiAEQbgaaikCADcCACAEQekJaiADKQMANwAAIARB8AlqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwL4CSAEIAE6AOAJIAQgFzcA4QkgBEHgCWoQ3CkhASAAQfiUggE2AgggACABNgIEIABBk4CAgHg2AgAMRAsgASACELoiIQIjAEHgAGsiASQAIAEgAigCECACKAIUQQN2IAMQyBYgAUEMaiIGIAIQkjYgAxDzEiABQSRqIgMgASAGENUdIAFB1ABqIgYgAhDKBiAGEPYcIARBkBpqIgJBCGogAUHcAGooAgA2AgAgAiABKQJUNwIAIAIgASkCMDcCDCACQRRqIAFBOGooAgA2AgAgAiABKQI8NwIYIAJBIGogAUHEAGopAgA3AgAgAkEoaiABQcwAaikCADcCACADELsMIAFB4ABqJAAgBC0AkBoiAUEpRg0hIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbAKaiAEQbAaaikCADcCACAEQbgKaiAEQbgaaikCADcCACAEQZkKaiADKQMANwAAIARBoApqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKoCiAEIAE6AJAKIAQgFzcAkQogBEGQCmoQ3CkhASAAQdCVggE2AgggACABNgIEIABBk4CAgHg2AgAMQwsgBEGQGmogASACEJciIAMQjwIgBC0AkBoiAUEpRg0fIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQagXaiAEQagaakEk/AoAACAEQZkXaiADKQMANwAAIARBoBdqIAIpAAA3AAAgBCABOgCQFyAEIAQpA4gVNwCRFyAEQZAXahDsKSEBIABBqJaCATYCCCAAIAE2AgQgAEGTgICAeDYCAAxCCyAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEHkGGogBEGwGmopAgA3AgAgBEHsGGogBEG4GmopAgA3AgAgBEH0GGogBEHAGmopAgA3AgAgBEHNGGogAykDADcAACAEQdQYaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcC3BggBCABOgDEGCAEIBc3AMUYIARBxBhqEOYpIQEgAEGQl4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADEELIARBkBpqIAEgAhCWIiADEJ4CIAQtAJAaIgFBKUYNHCAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBCAEKQCRGjcDiBUgBEHkF2ogBEGoGmpBJPwKAAAgBEHVF2ogAykDADcAACAEQdwXaiACKQAANwAAIAQgAToAzBcgBCAEKQOIFTcAzRcgBEHMF2oQ7CkhASAAQeiXggE2AgggACABNgIEIABBk4CAgHg2AgAMQAsgBEGQGmohCiABIAIQiyIhASMAQTBrIgckACAHIAEoAhwgASgCIEEEdiADEMwWIAdBDGogARCTNiADEPMSIAEoAgQhCSAHQSRqIAEoAggiBUEAQQRBDBCgGCAHKAIoIQECQAJAIAcoAiRBAUcEQCAHKAIsIQMCQCABRQ0AIAVBDGwhCyADIQIgASEGA0AgC0UNASAJKAIAIgggCCgCACIMQQFqNgIAIAxBAEgNAyACQQRqIAkpAgQ3AgAgAiAINgIAIAJBDGohAiALQQxrIQsgCUEMaiEJIAZBAWsiBg0ACwsgByAFNgIsIAcgAzYCKCAHIAE2AiQgCiAHIAdBJGogB0EMahC8ICAHQTBqJAAMAgsgASAHKAIsQZj9gQEQ/S8LAAsgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGDRogBEGgGGogBEGoGmpBJPwKAAAgBEGUGGogASkDADcCACAEQZwYaiACKAIANgIAIAQgAzYCiBggBCAEKQOIFTcCjBggBEGIGGoQ7CkhASAAQcCYggE2AgggACABNgIEIABBk4CAgHg2AgAMPwsgBEGQGmogASACEJkiIAMQkAIgBC0AkBoiAUEpRg0YIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEIAQpAJEaNwOIFSAEQfgMaiAEQagaakEk/AoAACAEQekMaiADKQMANwAAIARB8AxqIAIpAAA3AAAgBCABOgDgDCAEIAQpA4gVNwDhDCAEQeAMahDsKSEBIABBmJmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw+CyAEQZAaaiABIAIQmCIgAxCfAiAELQCQGiIBQSlGDRYgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIAQgBCkAkRo3A4gVIARBtA1qIARBqBpqQST8CgAAIARBpQ1qIAMpAwA3AAAgBEGsDWogAikAADcAACAEIAE6AJwNIAQgBCkDiBU3AJ0NIARBnA1qEOwpIQEgAEHwmYIBNgIIIAAgATYCBCAAQZOAgIB4NgIADD0LIARBkBpqIQogASACEIwiIQEjAEEwayIHJAAgByABKAIcIAEoAiBBBHYgAxDMFiAHQQxqIAEQkzYgAxDzEiABKAIEIQkgB0EkaiABKAIIIgVBAEEEQQwQoBggBygCKCEBAkACQCAHKAIkQQFHBEAgBygCLCEDAkAgAUUNACAFQQxsIQsgAyECIAEhBgNAIAtFDQEgCSgCACIIIAgoAgAiDEEBajYCACAMQQBIDQMgAkEEaiAJKQIENwIAIAIgCDYCACACQQxqIQIgC0EMayELIAlBDGohCSAGQQFrIgYNAAsLIAcgBTYCLCAHIAM2AiggByABNgIkIAogByAHQSRqIAdBDGoQvSAgB0EwaiQADAILIAEgBygCLEGY/YEBEP0vCwALIARBkBVqIgEgBEGcGmopAgA3AwAgBEGYFWoiAiAEQaQaaigCADYCACAEIAQpApQaNwOIFSAEKAKQGiIDQYCAgIB4Rg0UIARB8A1qIARBqBpqQST8CgAAIARB5A1qIAEpAwA3AgAgBEHsDWogAigCADYCACAEIAM2AtgNIAQgBCkDiBU3AtwNIARB2A1qEOwpIQEgAEHImoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADDwLIARBkBpqIAEgAhCQIiADELgCIAQtAJAaIgFBKUYNEiAEQZcVaiICIARBoBpqKQAANwAAIARBkBVqIgMgBEGZGmopAAA3AwAgBEG0DmogBEGwGmopAgA3AgAgBEG8DmogBEG4GmopAgA3AgAgBEHEDmogBEHAGmopAgA3AgAgBEGdDmogAykDADcAACAEQaQOaiACKQAANwAAIAQgBCkAkRoiFzcDiBUgBCAEKQKoGjcCrA4gBCABOgCUDiAEIBc3AJUOIARBlA5qEOYpIQEgAEGgm4IBNgIIIAAgATYCBCAAQZOAgIB4NgIADDsLIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQaQPaiAEQbAaaikCADcCACAEQawPaiAEQbgaaikCADcCACAEQbQPaiAEQcAaaigCADYCACAEQY0PaiADKQMANwAAIARBlA9qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKcDyAEIAE6AIQPIAQgFzcAhQ8gBEGED2oQ5SkhASAAQYicggE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgBEGQGmogASACEJEiIAMQuQIgBC0AkBoiAUEpRg0PIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQewOaiAEQbAaaikCADcCACAEQfQOaiAEQbgaaikCADcCACAEQfwOaiAEQcAaaikCADcCACAEQdUOaiADKQMANwAAIARB3A5qIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLkDiAEIAE6AMwOIAQgFzcAzQ4gBEHMDmoQ5ikhASAAQeCcggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEE4aiABIAIQyC8iDhDcOyAEKAI8IQIgBCgCOCEBIAQgAzYCkBUgBCABNgKIFSAEIAEgAkEDdGo2AowVIARBkBpqIQkjAEEwayICJAAgAkGTgICAeDYCACACQShqIARBiBVqIgFBCGooAgA2AgAgAiABKQIANwMgIAIgAjYCLCACQRRqIQsjAEEwayIBJAAgAUEIaiACQSBqIgcQhSgCQAJAAkAgASgCCCIKBEAgASgCDCENIAFBIGoiDEEEQQBBBEEIEKAYIAEoAiQhBSABKAIgQQFGDQIgASgCKCIIIA02AgQgCCAKNgIAIAFBHGoiD0EBNgIAIAEgCDYCGCABIAU2AhQgAUEoaiAHQQhqKQIANwMAIAEgBykCADcDICMAQRBrIgUkACAFQQhqIAwQhSggBSgCCCIIBEAgAUEUaiEKIAUoAgwhBwNAIAooAggiDSAKKAIARgRAIApBARDqLQsgCigCBCANQQN0aiIQIAc2AgQgECAINgIAIAogDUEBajYCCCAFIAwQhSggBSgCBCEHIAUoAgAiCA0ACwsgBUEQaiQAIAtBCGogDygCADYCACALIAEpAhQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyABQTBqJAAMAQsgBSABKAIoQYj5gwEQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgCSACKQIANwIAIAlBEGogAkEQaigCADYCACAJQQhqIAJBCGopAgA3AgAgCxDDJyALEOo7DAELIAkgAikCFDcCBCAJQZOAgIB4NgIAIAlBDGogAkEcaigCADYCAAsgAkEwaiQAIAQoApwaIQIgBCgCmBohASAEKAKUGiEHIAQoApAaIgVBk4CAgHhHBEAgACAEKAKgGjYCECAAIAI2AgwgACABNgIIIAAgBzYCBCAAIAU2AgAMOQsgBEEwaiAGQQRqEMM0IAQoAjQhBSAEKAIwIQYgBEIANwKoGiAEIAEgAkEDdGo2AqQaIAQgBzYCoBogBCABNgKcGiAEIAE2ApgaIAQgBjYCkBogBCAGIAVBAnRqNgKUGiAEQbgPaiAEQZAaaiIBEP8YIAEgAxC+LSAEIA42ArQaIARBhBFqIAEQ8BggBCgCwA8EQCAEQZAVaiAEQcAPaigCADYCACAEQZwVaiAEQYwRaigCADYCACAEIAQpArgPNwOIFSAEIAQpAoQRNwKUFSABIARBiBVqEK0QIAEQ5SkhASAAQbidggE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgBEGQGmoiASAEQYQRakEAIANBDGoiAhDYPBDyFSAEQYgVaiIDIAEQ4ScgASACENg8IAMQ1RggARDlKSEBIABBuJ2CATYCCCAAIAE2AgQgAEGTgICAeDYCACAEQbgPaiIAEO4fIAAQ6DsMOAsgBkEEaiEHIAYtAAENCyAEQfwYaiAHKAIEEOojIARB2ABqIAEgAigCEBEAACAEQZAaaiAEKAJYIgIgBCgCXCgCDBEAACACRQ0GIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNBiAEQYAfaiACKAIcIAIoAiAgAxDJFiAEQdAAaiAHELAuIAQoAlAiASAEKAJUIgtGDQoDQCAEQZAaaiACIAEtAAAQ2ShBiJ+CASADEIoBIAQoApgaIQUgBCgClBohCCAEKAKQGiIJQZOAgIB4RwRAIAAgBCkCnBo3AgwgACAFNgIIIAAgCDYCBCAAIAk2AgAgBCgCgB8iACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBgB9qEPseCyAEQfwYaiIAEMMnIAAQ6jsMOQsgBCgChBkiCSAEKAL8GEYEQCAEQfwYakHgn4IBEJsoCyAEKAKAGSAJQQN0aiIKIAU2AgQgCiAINgIAIAQgCUEBajYChBkgAUEIaiIBIAtHDQALDAoLIAEgBxEEACIGLQAAQSJGDQggBCAGNgK4DyAEQQE2ApQaIARB7KaCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakH0poIBEO8sAAsgBEGQGmoiBiABIAIQxy8Qjw4gBEG4D2oiBSAGEPwVIAYgBSADELgCIAQtAJAaIgJBKUYNBiAEQZcVaiIDIARBoBpqKQAANwAAIARBkBVqIgggBEGZGmopAAA3AwAgBEGQEGogBEGwGmopAgA3AgAgBEGYEGogBEG4GmopAgA3AgAgBEGgEGogBEHAGmopAgA3AgAgBEH5D2ogCCkDADcAACAEQYAQaiADKQAANwAAIAQgBCkCqBo3AogQIAQgAjoA8A8gBCAEKQCRGjcA8Q8gBEGIFWoiAiAEQfAPahCEPiAGIAIQoRsgAiABIAcRBAAQygYgBEGoEGoiASAGIAIQjBggAiABEM0cIAYgAhC4BiAGEPcpIQEgAEGEp4IBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAUQyR4MNQsgASAHEQQAIgYtAABBKEYNBCAEIAY2ArgPIARBATYClBogBEH8qoIBNgKQGiAEQgE3ApwaIARBrwM2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQYSrggEQ7ywAC0HQjoIBELI7AAtBgJeCARCyOwALQfibggEQsjsAC0GgnoIBELI7DAULAkACQAJAAkACQAJAIAYoAgQiBi0AMEEDaw4DAQIDAAsgBCAGQTBqNgK4DyAEQQE2ApQaIARBsKqCATYCkBogBEIBNwKcGiAEQacENgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakG4qoIBEO8sAAsgBEGQGmohDSABIAIQnCIhDiMAQeAEayIFJAACQAJAAkACQAJAAn8CQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQYgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAGIQcgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NTCAGKAIAIgMgCk8NTQJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAUyIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NVCABKAIAIgEgCk8NVSAPIAhBA3RqKQMAIA8gAUEDdGopAwBTDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAdBBGohAQNAIAFBBGoiAygCACIIIApPDVMgASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWQ0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAdqQQRrIQgDQCAHKAIAIQEgByAIKAIANgIAIAggATYCACAIQQRrIQggB0EEaiEHIANBAWsiAw0ACwwDCyAHIAxBACAMQQFyZ0EBdEE+cyAUEOgKDAILDE8LIAxBAnQhAUEEIQcDQCAGIAYgB2ogBUHUA2oQtxUgASAHQQRqIgdHDQALCwJAAkAgDEUNACAGIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDUEgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQkgEgRAIA5BDGpBABCSGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF+cWohCEEAIQEDQAJ/IAtFBEAgAyEGIAkgAyAIRw0BGgwFCyALIAggA2tBAXZPDQQgAyALQQF0aiEGIAkgC2oLIgxBAWohCSAGQQJqIQNBACELIAEgAk8NACABQQJ0IQogBi4BACASayEPA0AgASAFKAJUIgZPDUUgBSgCUCAKaigCACIGIAJPDUYgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NRyAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUZBwABBwAAQrTYiAUUNRCAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1GQcAAQcAAEK02IgFFDUQgBUIANwJEIAUgATYCQCAFQsCAgICACDcCOCAFKAIYIghBAkkNAkEBIQdBASEDA0AgBSgCFCICIANBAnRqIgEoAgAgAUEEaygCACIBRwRAIAUoAkQiCkEIaiIJIAUoAjwiBksEQCAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRCIKQQhqIQkgBSgCPCEGCyAGIAlJBH8gBUE4aiAGQQF0IgYgCRDSKiIJIAYgCUsbEOgZIAUoAkQFIAoLIAUoAkBqIAGtNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggA0GAgAJPDQkgBSgCLCIGQQJqIgEgBSgCJCIJSwRAIAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIkIQkgBSgCLCIGQQJqIQELIAEgCUsEfyAFQSBqIAlBAXQiBiABENIqIgEgASAGSRsQ6BkgBSgCLAUgBgsgBSgCKGogAzsAACAFIAUoAixBAmo2AiwgBSAFKAIwQQFqNgIwIAdBAWohBwsgA0EBaiIDIAhHDQALIAhBAWshCSAFKAJEIQEgBSgCPAwDCyABIAUoAlQiA08NQiACIAUoAlAgAUECdGooAgAiAUsEQCAFIBAgAUEDdGopAwA+AiAgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgI8IAUgBUE4ajYCgAMgBSAFQSBqNgI4IAVBoAJqIAVB+AJqEJkOIAVB1ANqEOk7DAELDEELIAVBzABqEOk7IAVBmAFqIAVBqAJqKAIAIgE2AgAgBSAFKQKgAiIXNwOQASAFKAKsAiECIA1BEGogATYCACANIBc3AgggDSACNgIUIA1BjYCAgHg2AgQgDUEpOgAADAILIAhFDQJBASEHQQAhASAFKAIUIQJBACEJQcAACyEDIAIgCUECdGo1AgAhFyADIAFBCGoiAkkEQCAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCPCEDIAUoAkQiAUEIaiECCyACIANLBH8gBUE4aiADQQF0IgEgAhDSKiICIAEgAksbEOgZIAUoAkQFIAELIAUoAkBqIBc3AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAIQYCAAk8NAiAFKAIsIgJBAmoiAyAFKAIkIgFLBEAgBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwiAkECaiEDIAUoAiQhAQsgASADSQR/IAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsBSACCyAFQShqIgIoAgBqIAg7AAAgBSAFKAIsQQJqIgM2AiwgBSAFKAIwQQFqNgIwIAVBoANqIghBg4aMGDYCACAFQoOGjJiw4MCBAzcCmAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQgE3AvgCIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBSAHNgKkAyAFQZwCaiIBEJcpIAIoAgAhCSACIAVBpAJqIgYpAgA3AwAgBSkDICEXIAUgBSkCnAI3AyAgBUEANgIwIAUgFzcCqAIgBUEANgKkAiAFIAM2AqACIAUgCTYCnAIgBUEIaiABENc7IAUoAgghCUEcQQQQrTYiAkUNQSACQoGAgIAQNwIAIAIgBSkCnAI3AgggAkEQaiAGKQIANwIAIAJBGGogBUGsAmoiCygCADYCACAFIAM2AtwDIAUgCTYC2AMgBSACNgLUAyABIAVB+AJqIgMgBUHUA2oiCRD6IyAFQcwAaiIKIAEQzRwgCEGFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAEQlykgBUFAayICKAIAIQggBSgCRCEHIAIgBikCADcDACAFKQM4IRcgBSAFKQKcAjcDOCAFQQA2AkggBSAXNwKoAiAFQQA2AqQCIAUgBzYCoAIgBSAINgKcAiAFIAEQ1zsgBSgCACEIQRxBBBCtNiICRQ1BIAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiALKAIANgIAIAUgBzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgAyAJEPojIAMgARDNHCAFQZABaiIBIAMQsRMgAyAOQSBqQYifggEgAUG8gYIBEJMBIAUoAoADIQIgBSgC/AIhAyAFKAL4AiIGQZOAgIB4RwRAIA0gBSkChAM3AhAgDSACNgIMIA0gAzYCCCANIAY2AgQgDUEpOgAAIAEQ/iQgChCCJyAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwwBCyAFQZgDaiAOEMoGIAVBADsB0AMgBUEANgLMAyAFQQA2ArQDIAVBADYCqAMgBUIENwKQAyAFQgA3AogDIAVCgICAgMAANwKAAyAFQQA2AvgCIAUgBSgCGDYCpAMgBUHUA2oiBiAFQcwAakHEAPwKAAAgBUGcAmoiByAFQfgCaiIBIAYQ7yUgASADIAIQ0yMgBUHAAWoiAiAHIAEQ7yUgBUGYBGoiASACEM0cIA0gARCfCSAFQZABahD+JCAFQThqEM8vIAVBIGoQzy8gBUEQahDpOwsgBUHgBGokAAwDC0F/QQBBkK+CARDDIQALQbCvggEQsjsAC0HQr4IBELI7AAsgBC0AkBoiAUEpRg0DIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQbgWaiAEQbAaaikCADcCACAEQaEWaiADKQMANwAAIARBqBZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwKwFiAEIAE6AJgWIAQgFzcAmRYgBEGYFmoQ9SkhASAAQdynggE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgBEGQGmohDSABIAIQmiIhDiMAQeAEayIFJAACQAJAAkACfwJAAkACQAJAIAMoAhQiAUEHTQRAIAVBADYCqAIgBUKAgICAwAA3AqACDAELIAMoAhAhECAOKAIcIRIgDigCGCETIAVBzABqIAFBA3YiAkG8/IEBEKQaIAUoAlAhBiAFKAJUIQwgBSACNgL8AiAFIBA2AvgCIAUgBUH4Amo2AtQDAkAgDEECSSIBDQAgDEEVTwRAIAYhByABDQEgBigCBCIIIAVB1ANqIhQoAgAiASgCBCIKTw1JIAYoAgAiAyAKTw1KAkACQAJAAkAgASgCACIPIAhBA3RqKQMAIA8gA0EDdGopAwBTIhFFBEBBAiEJIAxBAkYNASAGQQRqIQEDQCABQQRqIgMoAgAiCCAKTw1RIAEoAgAiASAKTw1SIA8gCEEDdGopAwAgDyABQQN0aikDAFMNAiADIQEgDCAJQQFqIglHDQALDAILQQIhCSAMQQJGDQAgB0EEaiEBA0AgAUEEaiIDKAIAIgggCk8NUCABKAIAIgEgCk8NBCAPIAhBA3RqKQMAIA8gAUEDdGopAwBZDQEgAyEBIAwgCUEBaiIJRw0ACwwBCyAJIAxHDQELIBFFDQMgDEEBdiEDIAxBAnQgB2pBBGshCANAIAcoAgAhASAHIAgoAgA2AgAgCCABNgIAIAhBBGshCCAHQQRqIQcgA0EBayIDDQALDAMLIAcgDEEAIAxBAXJnQQF0QT5zIBQQ6woMAgsMTAsgDEECdCEBQQQhBwNAIAYgBiAHaiAFQdQDahC3FSABIAdBBGoiB0cNAAsLAkACQCAMRQ0AIAYgDEECdGpBBGsiAUUNACABKAIAIgEgAk8NPiAFIBAgAUEDdGooAgAiATYC3AQgASATSQRAQQAhCSASBEAgDkEMakEAEN8ZIQsLIAVB1ANqQQAgAkHI8YEBELMVIA4oAhAiAyAOKAIUQXxxaiEIQQAhAQNAAn8gC0UEQCADIQYgCSADIAhHDQEaDAULIAsgCCADa0ECdk8NBCADIAtBAnRqIQYgCSALagsiDEEBaiEJIAZBBGohA0EAIQsgASACTw0AIAFBAnQhCiAGKAIAIBJrIQ8DQCABIAUoAlQiBk8NQiAFKAJQIApqKAIAIgYgAk8NQyAPIBAgBkEDdGooAgBNDQEgBiAFKALcAyIHTw1EIAUoAtgDIAZBAnRqIAw2AgAgCkEEaiEKIAIgAUEBaiIBRw0ACyACIQEMAAsACyAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AtgDIAUgBUHUA2o2AoADIAUgBUHcBGo2AtQDIAVBoAJqIAVB+AJqEJkODAQLQajxgQEQsjsACyABIAJJDQEgBUGoAmogBUHcA2ooAgA2AgAgBSAFKQLUAzcCoAIgBUHMAGoQ6TsLIAVBGGogBUGoAmooAgA2AgAgBSAFKQKgAjcDEEHAAEHAABDRNEUNQ0HAAEHAABCtNiIBRQ1BIAVCADcCLCAFIAE2AiggBULAgICAgAg3AiBBwABBwAAQ0TRFDUNBwABBwAAQrTYiAUUNQSAFQgA3AkQgBSABNgJAIAVCwICAgIAINwI4IAUoAhgiCEECSQ0CQQEhB0EBIQMDQCAFKAIUIgIgA0ECdGoiASgCACABQQRrKAIAIgFHBEAgBSgCRCIKQQhqIgkgBSgCPCIGSwRAIAVBOGogBkEBdCIGIAkQ0ioiCSAGIAlLGxDoGSAFKAJEIgpBCGohCSAFKAI8IQYLIAYgCUkEfyAFQThqIAZBAXQiBiAJENIqIgkgBiAJSxsQ6BkgBSgCRAUgCgsgBSgCQGogAa03AAAgBSAFKAJEQQhqNgJEIAUgBSgCSEEBajYCSCAFKAIsIgZBBGoiASAFKAIkIglLBEAgBUEgaiAJQQF0IgYgARDSKiIBIAEgBkkbEOgZIAUoAiQhCSAFKAIsIgZBBGohAQsgASAJSwR/IAVBIGogCUEBdCIGIAEQ0ioiASABIAZJGxDoGSAFKAIsBSAGCyAFKAIoaiADNgAAIAUgBSgCLEEEajYCLCAFIAUoAjBBAWo2AjAgB0EBaiEHCyADQQFqIgMgCEcNAAsgCEEBayEJIAUoAkQhASAFKAI8DAMLIAEgBSgCVCIDTw0/IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPgsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAgsgCEUNAkEBIQdBACEBIAUoAhQhAkEAIQlBwAALIQMgAiAJQQJ0ajUCACEXIAMgAUEIaiICSQRAIAVBOGogA0EBdCIBIAIQ0ioiAiABIAJLGxDoGSAFKAI8IQMgBSgCRCIBQQhqIQILIAIgA0sEfyAFQThqIANBAXQiASACENIqIgIgASACSxsQ6BkgBSgCRAUgAQsgBSgCQGogFzcAACAFIAUoAkRBCGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEEaiIDIAUoAiQiAUsEQCAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLCICQQRqIQMgBSgCJCEBCyABIANJBH8gBUEgaiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAiwFIAILIAVBKGoiAigCAGogCDYAACAFIAUoAixBBGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiCEGEiJAgNgIAIAVChIiQoMCAgYIENwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAc2AqQDIAVBnAJqIgEQlykgAigCACEJIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAJNgKcAiAFQQhqIAEQ1zsgBSgCCCEJQRxBBBCtNiICRQ0+IAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiILKAIANgIAIAUgAzYC3AMgBSAJNgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIJEPojIAVBzABqIgogARDNHCAIQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgBzYCpAMgARCXKSAFQUBrIgIoAgAhCCAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAg2ApwCIAUgARDXOyAFKAIAIQhBHEEEEK02IgJFDT4gAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAsoAgA2AgAgBSAHNgLcAyAFIAg2AtgDIAUgAjYC1AMgASADIAkQ+iMgAyABEM0cIAVBkAFqIgEgAxCxEyADIA5BIGpBiJ+CASABQbyBggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhHBEAgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAELIAVBmANqIA4QygYgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVBADYC+AIgBSAFKAIYNgKkAyAFQdQDaiIGIAVBzABqQcQA/AoAACAFQZwCaiIHIAVB+AJqIgEgBhDvJSABIAMgAhDTIyAFQcABaiICIAcgARDvJSAFQZgEaiIBIAIQzRwgDSABEJ4JIAVBkAFqEP4kIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7CyAFQeAEaiQADAELQX9BAEGQr4IBEMMhAAsgBC0AkBoiAUEpRg0BIARBlxVqIgIgBEGgGmopAAA3AAAgBEGQFWoiAyAEQZkaaikAADcDACAEQeAWaiAEQbAaaikCADcCACAEQckWaiADKQMANwAAIARB0BZqIAIpAAA3AAAgBCAEKQCRGiIXNwOIFSAEIAQpAqgaNwLYFiAEIAE6AMAWIAQgFzcAwRYgBEHAFmoQ9SkhASAAQbSoggE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgBEGQGmohDSABIAIQmyIhDiMAQeAEayIFJAACQAJAAkACQAJAAkACQCADKAIUIgFBB00EQCAFQQA2AqgCIAVCgICAgMAANwKgAgwBCyADKAIQIRAgDigCHCESIA4oAhghEyAFQcwAaiABQQN2IgJBvPyBARCkGiAFKAJQIQcgBSgCVCEMIAUgAjYC/AIgBSAQNgL4AiAFIAVB+AJqNgLUAwJAIAxBAkkiAQ0AIAxBFU8EQCAHIQYgAQ0BIAYoAgQiCCAFQdQDaiIUKAIAIgEoAgQiCk8NRyAGKAIAIgMgCk8NSAJAAkACQAJAIAEoAgAiDyAIQQN0aikDACAPIANBA3RqKQMAUyIRRQRAQQIhCSAMQQJGDQEgBkEEaiEBA0AgAUEEaiIDKAIAIgggCk8NTyABKAIAIgEgCk8NUCAPIAhBA3RqKQMAIA8gAUEDdGopAwBTDQIgAyEBIAwgCUEBaiIJRw0ACwwCC0ECIQkgDEECRg0AIAZBBGohAQNAIAFBBGoiAygCACIIIApPDU4gASgCACIBIApPDQQgDyAIQQN0aikDACAPIAFBA3RqKQMAWQ0BIAMhASAMIAlBAWoiCUcNAAsMAQsgCSAMRw0BCyARRQ0DIAxBAXYhAyAMQQJ0IAZqQQRrIQgDQCAGKAIAIQEgBiAIKAIANgIAIAggATYCACAIQQRrIQggBkEEaiEGIANBAWsiAw0ACwwDCyAGIAxBACAMQQFyZ0EBdEE+cyAUEOUKDAILDEoLIAxBAnQhAUEEIQYDQCAHIAYgB2ogBUHUA2oQtxUgASAGQQRqIgZHDQALCwJAAkAgDEUNACAHIAxBAnRqQQRrIgFFDQAgASgCACIBIAJPDTwgBSAQIAFBA3RqKAIAIgE2AtwEIAEgE0kEQEEAIQggEgRAIA5BDGpBABDIGSELCyAFQdQDakEAIAJByPGBARCzFSAOKAIQIgMgDigCFEF4cWohCUEAIQEDQAJ/IAtFBEAgAyEGIAggAyAJRw0BGgwFCyALIAkgA2tBA3ZPDQQgAyALQQN0aiEGIAggC2oLIgxBAWohCCAGQQhqIQNBACELIAEgAk8NACABQQJ0IQogBigCACASayEPA0AgASAFKAJUIgZPDUAgBSgCUCAKaigCACIGIAJPDUEgDyAQIAZBA3RqKAIATQ0BIAYgBSgC3AMiB08NQiAFKALYAyAGQQJ0aiAMNgIAIApBBGohCiACIAFBAWoiAUcNAAsgAiEBDAALAAsgBUECNgL8AiAFQdzygQE2AvgCIAVCATcChAMgBUE7NgLYAyAFIAVB1ANqNgKAAyAFIAVB3ARqNgLUAyAFQaACaiAFQfgCahCZDgwEC0Go8YEBELI7AAsgASACSQ0BIAVBqAJqIAVB3ANqKAIANgIAIAUgBSkC1AM3AqACIAVBzABqEOk7CyAFQRhqIAVBqAJqKAIANgIAIAUgBSkCoAI3AxBBwABBwAAQ0TRFDUFBwABBwAAQrTYiAUUNPyAFQgA3AiwgBSABNgIoIAVCwICAgIAINwIgQcAAQcAAENE0RQ1BQcAAQcAAEK02IgFFDT8gBUIANwJEIAUgATYCQCAFQsCAgICACDcCOEEBIQsgBSgCGCIHQQJPBEAgB60hGEEAIQNCASEXA0AgBSgCFCADaiIBQQRqKAIAIAEoAgAiAUcEQCAFKAJEIghBCGoiBiAFKAI8IgJLBEAgBUE4aiACQQF0IgIgBhDSKiIGIAIgBksbEOgZIAUoAkQiCEEIaiEGIAUoAjwhAgsgAiAGSQR/IAVBOGogAkEBdCICIAYQ0ioiBiACIAZLGxDoGSAFKAJEBSAICyAFKAJAaiABrTcAACAFIAUoAkRBCGo2AkQgBSAFKAJIQQFqNgJIIAUoAiwiAkEIaiIBIAUoAiQiBksEQCAFQSBqIAZBAXQiAiABENIqIgEgASACSRsQ6BkgBSgCJCEGIAUoAiwiAkEIaiEBCyABIAZLBH8gBUEgaiAGQQF0IgIgARDSKiIBIAEgAkkbEOgZIAUoAiwFIAILIAUoAihqIBc3AAAgBSAFKAIsQQhqNgIsIAUgBSgCMEEBajYCMCALQQFqIQsLIANBBGohAyAYIBdCAXwiF1INAAsLIAdBAWshASAHRQ0EIAUoAhQgAUECdGo1AgAhFyAFKAJEIgZBCGoiAyAFKAI8IgFLBEAgBUE4aiABQQF0IgEgAxDSKiICIAEgAksbEOgZIAUoAkQiBkEIaiEDIAUoAjwhAQsgASADSQR/IAVBOGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAJEBSAGCyAFKAJAaiAXNwAAIAUgBSgCREEIajYCRCAFIAUoAkhBAWo2AkggBSgCLCIGQQhqIgMgBSgCJCIBSwRAIAVBIGogAUEBdCIBIAMQ0ioiAiABIAJLGxDoGSAFKAIsIgZBCGohAyAFKAIkIQELIAEgA0kEfyAFQSBqIAFBAXQiASADENIqIgIgASACSxsQ6BkgBSgCLAUgBgsgBUEoaiICKAIAaiAHrTcAACAFIAUoAixBCGoiAzYCLCAFIAUoAjBBAWo2AjAgBUGgA2oiB0GFipQoNgIAIAVChYqUqNCgwYIFNwKYAyAFQgQ3ApADIAVCADcCiAMgBUKAgICAwAA3AoADIAVCATcC+AIgBUEAOwHQAyAFQQA2AswDIAVBADYCtAMgBUEANgKoAyAFIAs2AqQDIAVBnAJqIgEQlykgAigCACEIIAIgBUGkAmoiBikCADcDACAFKQMgIRcgBSAFKQKcAjcDICAFQQA2AjAgBSAXNwKoAiAFQQA2AqQCIAUgAzYCoAIgBSAINgKcAiAFQQhqIAEQ1zsgBSgCCCEIQRxBBBCtNiICRQ1AIAJCgYCAgBA3AgAgAiAFKQKcAjcCCCACQRBqIAYpAgA3AgAgAkEYaiAFQawCaiIJKAIANgIAIAUgAzYC3AMgBSAINgLYAyAFIAI2AtQDIAEgBUH4AmoiAyAFQdQDaiIIEPojIAVBzABqIgogARDNHCAHQYWKlCg2AgAgBUKFipSo0KDBggU3ApgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUIBNwL4AiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAUgCzYCpAMgARCXKSAFQUBrIgIoAgAhCyAFKAJEIQcgAiAGKQIANwMAIAUpAzghFyAFIAUpApwCNwM4IAVBADYCSCAFIBc3AqgCIAVBADYCpAIgBSAHNgKgAiAFIAs2ApwCIAUgARDXOyAFKAIAIQtBHEEEEK02IgJFDUAgAkKBgICAEDcCACACIAUpApwCNwIIIAJBEGogBikCADcCACACQRhqIAkoAgA2AgAgBSAHNgLcAyAFIAs2AtgDIAUgAjYC1AMgASADIAgQ+iMgAyABEM0cIAVBkAFqIgEgAxCxEyADIA5BIGpBiJ+CASABQbyBggEQkwEgBSgCgAMhAiAFKAL8AiEDIAUoAvgCIgZBk4CAgHhGDQIgDSAFKQKEAzcCECANIAI2AgwgDSADNgIIIA0gBjYCBCANQSk6AAAgARD+JCAKEIInIAVBOGoQzy8gBUEgahDPLyAFQRBqEOk7DAMLIAEgBSgCVCIDTw09IAIgBSgCUCABQQJ0aigCACIBSwRAIAUgECABQQN0aikDAD4CICAFQQI2AvwCIAVB3PKBATYC+AIgBUIBNwKEAyAFQTs2AjwgBSAFQThqNgKAAyAFIAVBIGo2AjggBUGgAmogBUH4AmoQmQ4gBUHUA2oQ6TsMAQsMPAsgBUHMAGoQ6TsgBUGYAWogBUGoAmooAgAiATYCACAFIAUpAqACIhc3A5ABIAUoAqwCIQIgDUEQaiABNgIAIA0gFzcCCCANIAI2AhQgDUGNgICAeDYCBCANQSk6AAAMAQsgBUGYA2ogDhDKBiAFQQA7AdADIAVBADYCzAMgBUEANgK0AyAFQQA2AqgDIAVCBDcCkAMgBUIANwKIAyAFQoCAgIDAADcCgAMgBUEANgL4AiAFIAUoAhg2AqQDIAVB1ANqIgYgBUHMAGpBxAD8CgAAIAVBnAJqIgcgBUH4AmoiASAGEO8lIAEgAyACENMjIAVBwAFqIgIgByABEO8lIAVBmARqIgEgAhDNHCANIAEQoAkgBUGQAWoQ/iQgBUE4ahDPLyAFQSBqEM8vIAVBEGoQ6TsLIAVB4ARqJAAMAQsgAUEAQZCvggEQwyEACyAELQCQGiIBQSlHBEAgBEGXFWoiAiAEQaAaaikAADcAACAEQZAVaiIDIARBmRpqKQAANwMAIARBiBdqIARBsBpqKQIANwIAIARB8RZqIAMpAwA3AAAgBEH4FmogAikAADcAACAEIAQpAJEaIhc3A4gVIAQgBCkCqBo3AoAXIAQgAToA6BYgBCAXNwDpFiAEQegWahD1KSEBIABBjKmCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwxCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwwCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwvCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAACAEQbgPahDJHgwuCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAgQiBi0AAEECaw4IAQIDBAUGBwgACyAEIAY2ArgPIARBATYClBogBEGcpoIBNgKQGiAEQgE3ApwaIARBpwQ2AowVIAQgBEGIFWo2ApgaIAQgBEG4D2o2AogVIARBkBpqQaSmggEQ7ywACyAEQZAaaiEGIAEgAhDEIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDlFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQ0gBEGIFWoiAiAGQcQA/AoAACAEQdcRaiAEQdcaai0AADoAACAEIAQvANUaOwDVESAEQZARaiIDIAJBxAD8CgAAIAQgAToA1BEgAxDrKSEBIABBkKCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw7CyAEQZAaaiEGIAEgAhDBIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCnFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQsgBEGIFWoiAiAGQcQA/AoAACAEQZ8SaiAEQdcaai0AADoAACAEIAQvANUaOwCdEiAEQdgRaiIDIAJBxAD8CgAAIAQgAToAnBIgAxDrKSEBIABB6KCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw6CyAEQZAaaiEGIAEgAhDAIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCoFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQkgBEGIFWoiAiAGQcQA/AoAACAEQecSaiAEQdcaai0AADoAACAEIAQvANUaOwDlEiAEQaASaiIDIAJBxAD8CgAAIAQgAToA5BIgAxDrKSEBIABBwKGCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw5CyAEQZAaaiEGIAEgAhDDIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCpFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQcgBEGIFWoiAiAGQcQA/AoAACAEQa8TaiAEQdcaai0AADoAACAEIAQvANUaOwCtEyAEQegSaiIDIAJBxAD8CgAAIAQgAToArBMgAxDrKSEBIABBmKKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAEQZAaaiEGIAEgAhDCIiECIwBBgAFrIgEkACABQSBqIAJBDGogAxDmFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQUgBEGIFWoiAiAGQcQA/AoAACAEQfcTaiAEQdcaai0AADoAACAEIAQvANUaOwD1EyAEQbATaiIDIAJBxAD8CgAAIAQgAToA9BMgAxDrKSEBIABB8KKCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw3CyAEQZAaaiEGIAEgAhC/IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCqFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQMgBEGIFWoiAiAGQcQA/AoAACAEQb8UaiAEQdcaai0AADoAACAEIAQvANUaOwC9FCAEQfgTaiIDIAJBxAD8CgAAIAQgAToAvBQgAxDrKSEBIABByKOCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw2CyAEQZAaaiEGIAEgAhC+IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCrFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJGDQEgBEGIFWoiAiAGQcQA/AoAACAEQYcVaiAEQdcaai0AADoAACAEIAQvANUaOwCFFSAEQcAUaiIDIAJBxAD8CgAAIAQgAToAhBUgAxDrKSEBIABBoKSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZAaaiEGIAEgAhC9IiECIwBBgAFrIgEkACABQSBqIAJBDGogAxCsFgJAAkACQCABLQAgIgNBKUYEQCABQRtqIAFBNGooAgAiAjYAACABQRNqIAFBLGopAgAiFzcAACABIAEpAiQiGDcACyAGQRBqIAI2AAAgBkEIaiAXNwAAIAYgGDcAACAGQQI6AEQMAQsgAUEXaiIHIAFBMGopAAA3AAAgAUEQaiIFIAFBKWopAAA3AwAgAUHwAGogAUFAaykCADcCACABQfgAaiABQcgAaikCADcCACABQdkAaiAFKQMANwAAIAFB4ABqIAcpAAA3AAAgASABKQI4NwJoIAEgAzoAUCABIAEpACE3AFEgAigCPCIDIAMoAgAiB0EBajYCACAHQQBIDQEgBiABQdAAaiADIAIoAkAQxxULIAFBgAFqJAAMAQsACyAELQDUGiIBQQJHBEAgBEGIFWoiAiAGQcQA/AoAACAEQZcWaiAEQdcaai0AADoAACAEIAQvANUaOwCVFiAEQdAVaiIDIAJBxAD8CgAAIAQgAToAlBYgAxDrKSEBIABB+KSCATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAw0CyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwzCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwyCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwxCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwwCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwvCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwuCyAEQZgVaiAEQaAaaigCACIBNgIAIARBkBVqIARBmBpqKQIAIhc3AwAgBCAEKQKQGiIYNwOIFSAAQRBqIAE2AgAgAEEIaiAXNwIAIAAgGDcCAAwtCyAHKAIAIgEgASgCACICQQFqNgIAIAJBAEgNASAGKAIIIQIgBEHAHmogBEGIH2ooAgA2AgAgBCAEKQKAHzcDuB4gBEEANgK4GSAEQcAPaiAEQYQZaigCADYCACAEIAQpAvwYNwO4DyAEQZAaaiABIAIgBEG4HmogBEG4GWogBEG4D2oQkQQgBEGQFWoiASAEQZwaaikCADcDACAEQZgVaiICIARBpBpqKAIANgIAIAQgBCkClBo3A4gVIAQoApAaIgNBgICAgHhGBEAgACAEKQOIFTcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADC0LIARBsBlqIARBuBpqKQIANwIAIARBqBlqIARBsBpqKQIANwIAIARBlBlqIAEpAwA3AgAgBEGcGWogAigCADYCACAEIAQpAqgaNwKgGSAEIAM2AogZIAQgBCkDiBU3AowZIARBiBlqENwpIQEgAEGwnoIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCwLIARByABqIAEgAigCEBEAACAEQZAaaiICIAQoAkgiASAEKAJMKAIMEQAAAkACQCABRQ0AIAQpA5AaQueZwdKG0azNs3+FIAQpA5gaQuWS4Y/bia2uUoWEUEUNACAEQYgVaiIFIAEoAhwgASgCICADEMkWIARBADYC6BkgBEGgGmogBEH4GWopAgA3AwAgBEGYGmogBEHwGWopAgA3AwAgBCAEKQLoGTcDkBogBEG4GWoiCCAFIAIQ2B0gARCTNiIJRQ0BIAIgCSgCBCAJKAIIQQJ2IAMQxxYgBEG4D2oiAyACIARB6BlqEL8dIARBQGsgBxCwLiAEKQNAIRcgBCABNgKgGiAEIBc3ApAaIAQgAzYCnBogBCAINgKYGiAFIAIQuxUgBEHAHmoiASAEQZQVaigCADYCACAEIAQpAowVNwO4HiAEKAKIFSICQZOAgIB4RwRAIAQoApgVIQYgACAEKQO4HjcCBCAAIAY2AhAgACACNgIAIABBDGogASgCADYCACADEP4kIAgQ/iQMLgsgBEGIGmogBEHAHmooAgA2AgAgBCAEKQO4HjcDgBogBEGQGmoiAUEAQYAE/AsAIAQgBCgCyBkiAjYCiBUgBCACIARBzBlqIgMoAgBqNgKMFSAEIAE2ApAVIARBnB5qIARBiBVqIgEQvCwgBEGwHmogAygCACICNgIAIARBnBVqIAI2AgAgBEGoFWogBEHYGWopAgA3AwAgBEGwFWogBEHgGWopAgA3AwAgBEGQFWogBEHAGWooAgA2AgAgBCAEKQLEGSIXNwOoHiAEIBc3ApQVIAQgBCkC0Bk3A6AVIAQgBCkCuBk3A4gVIAEQtAwCQCAEKAKgFSIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQaAVahD7HgsgBygCACIBIAEoAgAiAkEBajYCACACQQBIDQIgBigCCCECIARBiB9qIARBpB5qKAIANgIAIAQgBCkCnB43A4AfIARBiBVqIAEgAiAEQageaiAEQYAfaiAEQYAaahCRBCAEQcAeaiIBIARBlBVqKQIANwMAIARByB5qIgIgBEGcFWooAgA2AgAgBCAEKQKMFTcDuB4gBCgCiBUiA0GAgICAeEYEQCAAIAQpA7geNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBEG4D2oQ/iQMLgsgBEH4HmogBEGwFWopAgA3AgAgBEHwHmogBEGoFWopAgA3AgAgBEHcHmogASkDADcCACAEQeQeaiACKAIANgIAIAQgBCkCoBU3AugeIAQgAzYC0B4gBCAEKQO4HjcC1B4gBEHQHmoQ3CkhASAAQbCeggE2AgggACABNgIEIABBk4CAgHg2AgAgBEG4D2oQ/iQMLQtB8J+CARCyOwALQYCgggEQsjsACwALIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCkLIARBmxVqIARBpBpqKAIAIgE2AAAgBEGTFWogBEGcGmopAgAiFzcAACAEIAQpApQaIhg3AIsVIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADCgLIAAgBCkDiBU3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwnCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwmCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwlCyAAIAQpA4gVNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMJAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMIAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMHAsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGwsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGgsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGQsgBEGbFWogBEGkGmooAgAiATYAACAEQZMVaiAEQZwaaikCACIXNwAAIAQgBCkClBoiGDcAixUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMGAsgBEEIakHEjoIBIAMQoSsgACAEKQMINwIEIABBk4CAgHg2AgAMFwsgBCAGNgK4DyAEQQE2ApQaIARByKuCATYCkBogBEIBNwKcGiAEQa8DNgKMFSAEIARBiBVqNgKYGiAEIARBuA9qNgKIFSAEQZAaakHQq4IBEO8sAAsgBEGTBmogASgAACIBNgAAIARBiwZqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwCDBiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwVCyAEQeMFaiABKAAAIgE2AAAgBEHbBWogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3ANMFIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADBQLIARBswVqIAEoAAAiATYAACAEQasFaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAowUgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMEwsgBEGDBWogASgAACIBNgAAIARB+wRqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDzBCAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwSCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwRCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwQCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwPCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwOCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwNCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwMCyAEQZsVaiAEQaQaaigCACIBNgAAIARBkxVqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCLFSAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwLCyAEQdMEaiABKAAAIgE2AAAgBEHLBGogBEHDGWopAAAiFzcAACAEIAQpALsZIhg3AMMEIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAADAoLIARBowRqIAEoAAAiATYAACAEQZsEaiAEQcMZaikAACIXNwAAIAQgBCkAuxkiGDcAkwQgAEEQaiABNgAAIABBCGogFzcAACAAIBg3AAAMCQsgBEHzA2ogASgAACIBNgAAIARB6wNqIARBwxlqKQAAIhc3AAAgBCAEKQC7GSIYNwDjAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwICyAEQcMDaiAEQaQaaigCACIBNgAAIARBuwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCzAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwHCyAEQZMDaiAEQaQaaigCACIBNgAAIARBiwNqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCDAyAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwGCyAEQeMCaiAEQaQaaigCACIBNgAAIARB2wJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDTAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwFCyAEQbMCaiAEQaQaaigCACIBNgAAIARBqwJqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCjAiAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwECyAEQYMCaiAEQaQaaigCACIBNgAAIARB+wFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDzASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwDCyAEQdMBaiAEQaQaaigCACIBNgAAIARBywFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwDDASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwCCyAEQaMBaiAEQaQaaigCACIBNgAAIARBmwFqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwCTASAAQRBqIAE2AAAgAEEIaiAXNwAAIAAgGDcAAAwBCyAEQfMAaiAEQaQaaigCACIBNgAAIARB6wBqIARBnBpqKQIAIhc3AAAgBCAEKQKUGiIYNwBjIABBEGogATYAACAAQQhqIBc3AAAgACAYNwAACyAEQZAfaiQADwtBBEE4EKM9AAsgASACQbjxgQEQwyEACyABIAZB7PKBARDDIQALIAYgAkH88oEBEMMhAAsgBiAHQYzzgQEQwyEACyABIAJB6PGBARDDIQALIAEgA0HY8YEBEMMhAAtBwABBwAAQoz0AC0EEQRwQoz0AC0HA9IEBQSkgBUH4AmpBzPyBAUHs9IEBENUeAAsgAiAIKAIcQbz8gQEQ/S8ACyAGIAgoAhxBvPyBARD9LwALIAggCkHw9oMBEMMhAAsgAyAKQYD3gwEQwyEACyAIIApB8PaDARDDIQALIAEgCkGA94MBEMMhAAtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgAUEBNgIUIAFB3LaCATYCECABQgE3AhwgAUHIEDYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpB5LaCARDvLAALy04CDX8CfiMAQfADayIGJAACQANAAkAgA0UEQEEAIQkMAQsgAigCAARAIAMhCQwBCyADQQJ0QQRrIQdBACEIA0AgB0UNAyAAQQRqIQAgB0EEayEHIAhBAWohCCACQQRqIgIoAgBFDQALIAEgCEEBa0sEQCABIAhrIQEgAyAIayEJDAELIAggAUGgi4gBEK87AAsCQCAFRQRAQQAhBQwBCyAEKAIADQAgBUECdEEEayEHQQAhCANAIAdFDQMgAEEEaiEAIAdBBGshByAIQQFqIQggBEEEaiIEKAIARQ0ACyABIAhBAWtLBEAgASAIayEBIAUgCGshBQwBCyAIIAFBsIuIARCvOwALIAkgBSAFIAlJGyEKIAQgAiAFIAlLIgMbIQwgAiAEIAMbIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAkgBSADGyIDQSFPBEAgA0EBdCAKTQ0OIANBgQJJDQggBkH4AGoiCSACIApBA25BAWoiBSADIAMgBUsbIgQQmA4gAyAFIAMgBGsiByAFIAdJGyIIIARqIgdJDQEgBkGIAWoiCyACIARBAnRqIAgQmA4gBkGYAWoiBCACIAdBAnRqIAMgB2sQmA4gCkUNAiAGQagBaiIHIAwgBRCYDiAKIAUgCiAFayICIAIgBUsbIgMgBWoiAkkNAyAGQbgBaiIIIAwgBUECdGogAxCYDiAGQcgBaiIDIAwgAkECdGogCiACaxCYDiAGQdgBaiICIAkgBBCCByAGQegBaiIEIAcgAxCCByAGQfgBaiACIAsQlwQgBkGIAmogBCAIEJcEQQEhB0EBIQQgBi0AhAEiAkEBRg0NIAYtALQBIgRBAWsOAg0JCgsgA0UNDyACIANBAnRqIREgAUECdCEPIAUgCSAFIAlLG0ECdCIDQQRqIQ0gACADaiELIAAhAwNAIAEgDkkNBAJAIAIoAgAiBEUNACAKIAEgDmsiEEsNBiAGIAAgDkECdGoiBTYC2AMgBiAFIApBAnRqIgU2AtwDIAogBkHYA2oQnjYiByAHIApLGyIIBH8gBK0hFEIAIRMgAyEHIAwhBANAIAcgEyAHNQIAfCAENQIAIBR+fCITPgIAIBNCIIghEyAHQQRqIQcgBEEEaiEEIAhBAWsiCA0ACyATpwVBAAshCSAKIBBGDQcgBiAFNgLYAyAGIAVBBGo2AtwDIAZB2ANqEJ42IgRFDQAgBEEARyEIQQAhBSALIQcDQCAHIAUgBygCACIFIAlqIgRqIhA2AgAgBCAFSSAEIBBLciIEIQUgB0EEaiEHIAhBAWsiCA0ACyAERQ0AIA0hBwNAIAcgD0YNCSADIAdqIgQgBCgCAEEBaiIENgIAIAdBBGohByAERQ0ACwsgDkEBaiEOIA9BBGshDyALQQRqIQsgA0EEaiEDIBEgAkEEaiICRw0ACwwPCyAHIANBwIuIARCwOwALIAVBAEHQi4gBELA7AAsgAiAKQeCLiAEQsDsACyAOIAFB4IyIARCvOwALIAZBADYC6AMgBkEBNgLcAyAGQfSJiAE2AtgDIAZCBDcC4AMgBkHYA2pBzIqIARDvLAALIAZBADYC6AMgBkEBNgLcAyAGQfSJiAE2AtgDIAZCBDcC4AMgBkHYA2pBnIqIARDvLAALIAZBATYCyAMgBkIANwLkAyAGQoGAgIDAADcC3AMgBkGIi4gBNgLYAyAGQcgDakHciogBIAZB2ANqQZCLiAEQqCsACwJAIANBAXYiBCAKTQRAIAZB2ANqIAogBGsiCiADIARrIg5qQQFqIgVBoIyIARC/FSAGQZADaiAGQeADaigCACIJNgIAIAYgBikC2AM3A4gDIAYoAowDIgggCSACIARBAnQiB2oiDyAOIAcgDGoiESAKEIsBIAlFDQEgCCAJQQJ0IgtqQQRrIgdFDQEgBygCAA0BIAshByAIQQRrIQsgCUH/////A3EhCAJAA0AgB0UEQEEAIQcMAgsgCEEBayEIIAcgC2ogB0EEayEHKAIARQ0ACyAIQQFqIgcgCUsNAgsgBiAHNgKQAyAHIQkMAQsgBkEANgLoAyAGQQE2AtwDIAZB9ImIATYC2AMgBkIENwLgAyAGQdgDakGQjIgBEO8sAAsCQCAJIAYoAogDQQJ2Tw0AIAZBGGogBkGIA2ogCUEEQQQQ9BQgBigCGCIHQYGAgIB4Rg0AIAcgBigCHEHMjYgBEP0vAAsCQAJAIAEgBE8EQCAAIARBAnRqIgsgASAEayINIAYoAowDIgcgBigCkAMiCBCEEyABIANB/gNxIgNJDQEgACADQQJ0aiABIANrIAcgCBCEE0EAIQggBkEANgKQAyAFBH8gBkGIA2ogBRDTGiAGKAKQAyEIIAYoAowDBSAHCyAIIAIgBCAMIAQQiwEgBigCjAMhCSAGKAKQAyIDRQ0CIAkgA0ECdCIIakEEayIHRQ0CIAcoAgANAiAIIQcgCUEEayEQIANB/////wNxIQgCQANAIAdFBEBBACEHDAILIAhBAWshCCAHIBBqIAdBBGshBygCAEUNAAsgCEEBaiIHIANLDQMLIAYgBzYCkAMgByEDDAILIAQgAUGwjIgBEK87AAsgAyABQcCMiAEQrzsACwJAAkACQAJAIAYoAogDQQJ2IANLBEAgBkEQaiAGQYgDaiADQQRBBBD0FCAGKAIQIgNBgYCAgHhHDQEgBigCjAMhCSAGKAKQAyEDCyAAIAEgCSADEIQTIAsgDSAGKAKMAyAGKAKQAxCEEyAGQdgDaiIDIA8gDiACIAQQvgYgBi0A2AMhACAGQaADaiAGQeQDaiIBKAIANgIAIAYgBikC3AM3A5gDIAMgESAKIAwgBBC+BiAGLQDYAyECIAZB0ANqIAEoAgA2AgAgBiAGKQLcAzcDyAMgAEEBRg0DAkACQAJAIAJBAWsOAgYAAQsgAA0BDAQLIAANAwtBACEHIAZBADYCkAMgBQRAIAZBiANqIAUQ0xogBigCkAMhBwsgBigCjAMgByAGKAKcAyAGKAKgAyAGKALMAyAGKALQAxCLASAGKAKMAyEIIAYoApADIgJFDQEgCCACQQJ0IgdqQQRrIgBFDQEgACgCAA0BIAhBBGshACACQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgACAHaiAHQQRrIQcoAgBFDQALIARBAWoiByACSw0CCyAGIAc2ApADIAchAgwBCyADIAYoAhRBzI2IARD9LwALAkAgBigCiANBAnYgAksEQCAGQQhqIAZBiANqIAJBBEEEEPQUIAYoAggiAEGBgICAeEcNASAGKAKMAyEIIAYoApADIQILIAsgDSAIIAIQzRAMAgsgACAGKAIMQcyNiAEQ/S8ACyALIA0gBigCnAMgBigCoAMgBigCzAMgBigC0AMQiwELIAZByANqQQRBBBDgHiAGQZgDakEEQQQQ4B4gBkGIA2pBBEEEEOAeDAcLIAINAQwCCyACDQELQQIhBEEAIQcMAQtBACEHQQAhBAsCQAJAIAYoAoABIgIEQCAGKAKwASIDDQELIAZB0ANqQbiNiAEoAgA2AgAgBkGwjYgBKQIANwPIAwwBCyAGKAKsASEIIANBAUYEQCAIKAIAIQIgBkHYA2oiAyAGQfgAahDpHSADIAIQ4w4gBkHQA2ogBkHgA2ooAgA2AgAgBiAGKQLYAzcDyAMMAQsgBigCfCEJIAJBAUYEQCAJKAIAIQIgBkHYA2oiAyAGQagBahDpHSADIAIQ4w4gBkHQA2ogBkHgA2ooAgA2AgAgBiAGKQLYAzcDyAMMAQsgBkHIA2ogCSACIAggAxCjEQsCQCAHRQRAIARBASAGKALQAxshBwwBCyAGQQA2AtADIAZByANqQQRBBBCeJAJAIAYoAtADIghFDQAgBigCzAMiAiAIQQJ0IgdqQQRrIgNFDQAgAygCAA0AIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0BCyAGIAc2AtADIAchCAtBASEHIAggBigCyANBAnZPDQAgBkHwAGogBkHIA2ogCEEEQQQQ9BQgBigCcCICQYGAgIB4Rg0AIAIgBigCdEHMjYgBEP0vAAsgBkGgAmogBkHQA2ooAgA2AgAgBiAGKQPIAzcDmAIgBiAHOgCkAkEBIQdBASEEAkAgBi0ApAEiAkEBRg0AAkACQAJAAkAgBi0A1AEiBEEBaw4CBAEACyACDQEMAgsgAg0BC0EAIQdBACEEDAELQQIhBEEAIQcLAkACQCAGKAKgASICBEAgBigC0AEiAw0BCyAGQdADakG4jYgBKAIANgIAIAZBsI2IASkCADcDyAMMAQsgBigCzAEhCCADQQFGBEAgCCgCACECIAZB2ANqIgMgBkGYAWoQ6R0gAyACEOMOIAZB0ANqIAZB4ANqKAIANgIAIAYgBikC2AM3A8gDDAELIAYoApwBIQkgAkEBRgRAIAkoAgAhAiAGQdgDaiIDIAZByAFqEOkdIAMgAhDjDiAGQdADaiAGQeADaigCADYCACAGIAYpAtgDNwPIAwwBCyAGQcgDaiAJIAIgCCADEKMRCwJAIAdFBEAgBEEBIAYoAtADGyEEDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQQgCCAGKALIA0ECdk8NACAGQegAaiAGQcgDaiAIQQRBBBD0FCAGKAJoIgJBgYCAgHhGDQAgAiAGKAJsQcyNiAEQ/S8ACyAGQbACaiAGQdADaiICKAIANgIAIAYgBikDyAM3A6gCIAYgBDoAtAIgAiAGQeABaikCADcDACAGIAYpAtgBNwPIAyAGQeADaiIDIAZBkAFqKQIANwMAIAYgBikCiAE3A9gDIAZBiANqIAZByANqIgQgBkHYA2oiBxDRBSACIAZB8AFqKQIANwMAIAYgBikC6AE3A8gDIAMgBkHAAWopAgA3AwAgBiAGKQK4ATcD2AMgBkGYA2ogBCAHENEFIAZBgANqIAZBoANqKAIANgIAIAZB8AJqIAZBkANqKAIANgIAIAYgBikCmAM3A/gCIAYgBikCiAM3A+gCAkACfwJAAkAgBi0AlAMiAkEBRg0AAkACQAJAIAYtAKQDQQFrDgIDAQALIAINAQwDCyACDQILQQAMAgsCfwJAAkAgBigC8AIiAgRAIAYoAoADIgMNAQsgBkHQA2pBuI2IASgCADYCACAGQbCNiAEpAgA3A8gDDAELIAYoAvwCIQQgA0EBRgRAIAQoAgAhAiAGQeADaiIDIAZBkANqKAIANgIAIAYgBikCiAM3A9gDIAZB2ANqIAIQ4w4gBkHQA2ogAygCADYCACAGIAYpA9gDNwPIAyAGQfgCagwCCyAGKALsAiEHIAJBAUYEQCAHKAIAIQIgBkHgA2oiAyAGQaADaigCADYCACAGIAYpApgDNwPYAyAGQdgDaiACEOMOIAZB0ANqIAMoAgA2AgAgBiAGKQPYAzcDyAMgBkHoAmoMAgsgBkHIA2ogByACIAQgAxCjEQsgBkGYA2pBBEEEEOAeIAZB6AJqCyIHQQRBBBDgHiAGQQA2AtADIAZByANqQQRBBBCeJAJAIAYoAtADIghFDQAgBigCzAMiAiAIQQJ0IgdqQQRrIgNFDQAgAygCAA0AIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0BCyAGIAc2AtADIAchCAtBASEHIAggBigCyANBAnZPDQIgBkHgAGogBkHIA2ogCEEEQQQQ9BQgBigCYCICQYGAgIB4Rg0CIAIgBigCZEHMjYgBEP0vAAtBAgsgBkHIA2ogBkGIA2ogBkGYA2oQzxNBASAGKALQAxshBwsgBkHAAmogBkHQA2ooAgA2AgAgBiAGKQPIAzcDuAIgBiAHOgDEAkEBIQdBASEEAkAgBi0AhAIiAkEBRg0AAkACQAJAAkAgBi0AlAIiBEEBaw4CBAEACyACDQEMAgsgAg0BC0EAIQdBACEEDAELQQIhBEEAIQcLAkACQCAGKAKAAiICBEAgBigCkAIiAw0BCyAGQdADakG4jYgBKAIANgIAIAZBsI2IASkCADcDyAMMAQsgBigCjAIhCCADQQFGBEAgCCgCACECIAZB2ANqIgMgBkH4AWoQ6R0gAyACEOMOIAZB0ANqIAZB4ANqKAIANgIAIAYgBikC2AM3A8gDDAELIAYoAvwBIQkgAkEBRgRAIAkoAgAhAiAGQdgDaiIDIAZBiAJqEOkdIAMgAhDjDiAGQdADaiAGQeADaigCADYCACAGIAYpAtgDNwPIAwwBCyAGQcgDaiAJIAIgCCADEKMRCwJAIAdFBEAgBEEBIAYoAtADGyEHDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQcgCCAGKALIA0ECdk8NACAGQdgAaiAGQcgDaiAIQQRBBBD0FCAGKAJYIgJBgYCAgHhGDQAgAiAGKAJcQcyNiAEQ/S8ACyAGQdACaiAGQdADaiIDKAIANgIAIAYgBikDyAM3A8gCIAYgBzoA1AIgBkHgA2oiAiAGQaABaikCADcDACAGIAYpApgBNwPYAyAGQcgDaiIEIAZB+AFqIAZB2ANqIgcQ0QUgBkGYA2oiCCAEEPoOIAIgBkGAAWopAgA3AwAgBiAGKQJ4NwPYAyAGQYgDaiAIIAcQqAMgAiAGQdABaikCADcDACAGIAYpAsgBNwPYAyAEIAZBiAJqIAcQ0QUgCCAEEPoOIAIgBkGwAWopAgA3AwAgBiAGKQKoATcD2AMgBCAIIAcQqAMgBkGAA2ogAygCADYCACAGQfACaiAGQZADaigCADYCACAGIAYpAsgDNwP4AiAGIAYpAogDNwPoAgJAAn8CQAJAIAYtAJQDIgJBAUYNAAJAAkACQCAGLQDUA0EBaw4CAwEACyACDQEMAwsgAg0CC0EADAILAn8CQAJAIAYoAvACIgIEQCAGKAKAAyIDDQELIAZBoANqQbiNiAEoAgA2AgAgBkGwjYgBKQIANwOYAwwBCyAGKAL8AiEEIANBAUYEQCAEKAIAIQIgBkHgA2oiAyAGQZADaigCADYCACAGIAYpAogDNwPYAyAGQdgDaiACEOMOIAZBoANqIAMoAgA2AgAgBiAGKQPYAzcDmAMgBkH4AmoMAgsgBigC7AIhByACQQFGBEAgBygCACECIAZB4ANqIgMgBkHQA2ooAgA2AgAgBiAGKQLIAzcD2AMgBkHYA2ogAhDjDiAGQaADaiADKAIANgIAIAYgBikD2AM3A5gDIAZB6AJqDAILIAZBmANqIAcgAiAEIAMQoxELIAZByANqQQRBBBDgHiAGQegCagsiB0EEQQQQ4B4gBkEANgKgAyAGQZgDakEEQQQQniQCQCAGKAKgAyIIRQ0AIAYoApwDIgIgCEECdCIHakEEayIDRQ0AIAMoAgANACACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNAQsgBiAHNgKgAyAHIQgLQQEhByAIIAYoApgDQQJ2Tw0CIAZB0ABqIAZBmANqIAhBBEEEEPQUIAYoAlAiAkGBgICAeEYNAiACIAYoAlRBzI2IARD9LwALQQILIAZBmANqIAZBiANqIAZByANqEM8TQQEgBigCoAMbIQcLIAZB4AJqIAZBoANqKAIANgIAIAYgBikDmAM3A9gCIAYgBzoA5AIgBkHYA2ogBkHYAmogBkG4AmoQpAYgBi0A5AMhAyAGKALcAyECIAYoAtgDIQggBigC4AMiCQRAIAJBBGshDCAJQQJ0IQdBACEEA0AgByAMaiILIAsoAgAiC0EQdiINIA0gBEEQdHJBA24iBEEDbGtBEHQgC0H//wNxciILQQNuIg0gBEEQdHI2AgAgCyANQQNsayEEIAdBBGsiBw0ACwsgBiAJNgLQAyAGIAg2AsgDIAYgAjYCzAMCQCAJRQ0AIAIgCUECdCIEakEEayIHRQ0AIAcoAgANACAEIQcgAkEEayECIAlB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAlLDQELIAYgBzYC0AMgByEJCwJAAkACQCAIQQJ2IAlLBEAgBkHIAGogBkHIA2ogCUEEQQQQ9BQgBigCSCIHQYGAgIB4Rw0BCyAGQaADaiAGQdADaigCADYCACAGIAYpAsgDNwOYAyADQQFHBEAgA0EBIAYoAqADGyEHDAMLIAZBADYCoAMgBkGYA2pBBEEEEJ4kIAYoAqADIghFDQEgBigCnAMiAiAIQQJ0IgdqQQRrIgNFDQEgAygCAA0BIAJBBGshAiAIQf////8DcSEEAkADQCAHRQRAQQAhBwwCCyAEQQFrIQQgAiAHaiAHQQRrIQcoAgBFDQALIARBAWoiByAISw0CCyAGIAc2AqADIAchCAwBCyAHIAYoAkxBzI2IARD9LwALQQEhByAIIAYoApgDQQJ2Tw0AIAZBQGsgBkGYA2ogCEEEQQQQ9BQgBigCQCICQYGAgIB4Rg0AIAIgBigCREHMjYgBEP0vAAsgBkHwAmoiAiAGQaADaigCADYCACAGIAYpA5gDNwPoAiAGIAc6APQCIAZB4ANqIgMgBkHAAmopAwA3AwAgBiAGKQO4AjcD2AMgBkHIA2oiByAGQdgDaiIEIAZByAJqEKQGIAZB+AJqIAcQ/AggAyAGQdACaikDADcDACAGIAYpA8gCNwPYAyAGQYgDaiIHIAQgBkGYAmoQpAYCQAJAAkACQAJAIAYtAPQCIgNBAUYEQCAGLQCUAyECIAQgBxDpHSAGIAI6AOQDDAELIAIoAgAhBCAGKALsAiEHAkACQAJAAkACQAJAAkAgBi0AlAMiAkEBaw4CAAIBCyAGQeADaiAGQfACaigCADYCACAGIAYpA+gCNwPYAyAGQQIgA2s6AOQDDAoLIANFDQEMAgsgA0UNAQsCfyAEIAYoApADIgNHBEAgAyAESyADIARJawwBCyAGKAKMA0EEayEIIAdBBGshCSADQQJ0IQcCQANAIAdFDQEgByAJaiEEIAcgCGogB0EEayEHKAIAIgMgBCgCACIERg0ACyADIARLIAMgBElrDAELQX9BACAHGwsiB0H/AXEOAgIEAQsgBkHQA2ogBkHwAmooAgA2AgAgBiAGKQPoAjcDyAMgBkGYA2ogBkHIA2ogBkGIA2oQ7QggBkHgA2ogBkGgA2ooAgAiAzYCACAGIAYpApgDNwPYAyAGIAJBASADGzoA5AMMBgtBAiEHAkACQAJAIAJBAWsOAgIAAQtBACEHCyAGQeADaiICIAZB8AJqKAIANgIAIAYgBikD6AI3A9gDIAZB2ANqIAZBiANqEO8UIAZB0ANqIAIoAgAiAjYCACAGIAYpA9gDNwPIAyAHQQEgAhshBwwFCyAGQeADaiAGQfACaigCADYCACAGIAYpA+gCNwPYAyAGQdgDaiAGQYgDahDvFCAGIAYpA9gDNwPIAyAGQQA2AtADIAZByANqQQRBBBCeJCAGKALQAyIIRQ0DIAYoAswDIgIgCEECdCIHakEEayIDRQ0DIAMoAgANAyACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNBAsgBiAHNgLQAyAHIQgMAwsgBkHgA2pBlIqIASkCADcDACAGQYyKiAEpAgA3A9gDCyAGQegCakEEQQQQ4B4MAwsgBkHgA2ogBkHwAmooAgA2AgAgBiAGKQPoAjcD2AMgBkHIA2ogBkGIA2ogBkHYA2oQ8goCQCACQQFHBEAgAkEBIAYoAtADGyEHDAELIAZBADYC0AMgBkHIA2pBBEEEEJ4kAkAgBigC0AMiCEUNACAGKALMAyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYC0AMgByEIC0EBIQcgCCAGKALIA0ECdk8NACAGQThqIAZByANqIAhBBEEEEPQUIAYoAjgiAkGBgICAeEYNACACIAYoAjxBzI2IARD9LwALIAZB4ANqIAZB0ANqKAIANgIAIAYgBikCyAM3A9gDIAYgBzoA5AMMAgtBASEHIAggBigCyANBAnZPDQAgBkEwaiAGQcgDaiAIQQRBBBD0FCAGKAIwIgJBgYCAgHhGDQAgAiAGKAI0QcyNiAEQ/S8ACyAGQeADaiAGQdADaigCADYCACAGIAYpA8gDNwPYAyAGIAc6AOQDCyAGQcgDaiAGQdgDaiIDEPwIIAYtALQCIQICQCAGKAKwAgRAIAZBgICAgHg2AtgDIAYgBkGoAmo2AtwDIAZBmANqIANBAEEBEKgFDAELIAZBmANqIAZBqAJqEOkdCwJAIAJBAUcEQCACQQEgBigCoAMbIQcMAQsgBkEANgKgAyAGQZgDakEEQQQQniQCQCAGKAKgAyIIRQ0AIAYoApwDIgIgCEECdCIHakEEayIDRQ0AIAMoAgANACACQQRrIQIgCEH/////A3EhBAJAA0AgB0UEQEEAIQcMAgsgBEEBayEEIAIgB2ogB0EEayEHKAIARQ0ACyAEQQFqIgcgCEsNAQsgBiAHNgKgAyAHIQgLQQEhByAIIAYoApgDQQJ2Tw0AIAZBKGogBkGYA2ogCEEEQQQQ9BQgBigCKCICQYGAgIB4Rg0AIAIgBigCLEHMjYgBEP0vAAsgBkHgA2oiAyAGQaADaigCADYCACAGIAYpApgDNwPYAyAGIAc6AOQDIAZB6AJqIAZByANqIAZB2ANqENEFIAZBmANqIAZB+AJqIAZBqAJqEJcEIAZBkANqIgIpAwAhEyACQZSKiAEpAgA3AwAgBkHQA2oiBCATNwMAIAYpA4gDIRMgBkGMiogBKQIANwOIAyAGIBM3A8gDAkAgBi0ApAMiAkEBRgRAIAMgBCkDADcDACAGIAYpA8gDNwPYAwwBCwJAAkACQAJAAkACQAJAAkACQCAGLQDUAyIDQQFrDgIDAAELIAJFDQEMBwsgAkUNBgsCfyAGKALQAyIEIAYoAqADIgdHBEAgBCAHSyAEIAdJawwBCyAGKALMA0EEayEJIAYoApwDQQRrIQwgBEECdCEHAkADQCAHRQ0BIAcgDGohCCAHIAlqIAdBBGshBygCACIEIAgoAgAiCEYNAAsgBCAISyAEIAhJawwBC0F/QQAgBxsLQf8BcQ4CAgMBCyAGQdgDaiAGQZgDahDpHSAGIAI6AOQDDAMLIAZBwANqIAZB0ANqKAIANgIAIAYgBikDyAM3A7gDIAZBrANqIAZBmANqIAZBuANqEPIKIAZB4ANqIAZBtANqKAIAIgM2AgAgBiAGKQKsAzcD2AMgBiACQQEgAxs6AOQDDAQLIAZB4ANqQZSKiAEpAgA3AwAgBkGMiogBKQIANwPYAwwBCyAGQeADaiICIAZB0ANqKAIANgIAIAYgBikDyAM3A9gDIAZB2ANqIAZBmANqEO8UIAZBwANqIAIoAgA2AgAgBiAGKQPYAzcDuAMCQCADQQFHBEAgA0EBIAYoAsADGyEHDAELIAZBADYCwAMgBkG4A2pBBEEEEJ4kAkAgBigCwAMiCEUNACAGKAK8AyICIAhBAnQiB2pBBGsiA0UNACADKAIADQAgAkEEayECIAhB/////wNxIQQCQANAIAdFBEBBACEHDAILIARBAWshBCACIAdqIAdBBGshBygCAEUNAAsgBEEBaiIHIAhLDQELIAYgBzYCwAMgByEIC0EBIQcgCCAGKAK4A0ECdk8NACAGQSBqIAZBuANqIAhBBEEEEPQUIAYoAiAiAkGBgICAeEYNACACIAYoAiRBzI2IARD9LwALIAZB4ANqIAZBwANqKAIANgIAIAYgBikDuAM3A9gDIAYgBzoA5AMMAgsgBkHIA2pBBEEEEOAeDAELIAZBwANqIAZB0ANqKAIANgIAIAYgBikDyAM3A7gDIAZBrANqIAZBuANqIAZBmANqEO0IIAZB4ANqIAZBtANqKAIAIgI2AgAgBiAGKQKsAzcD2AMgBiADQQEgAhs6AOQDCyAGQYgDaiIEQQRBBBDgHiAGQZADaiAGQeADaiIDKQMANwMAIAYgBikD2AM3A4gDIAZBmANqQQRBBBDgHiAGQYADaiICKQMAIRMgAkGUiogBKQIANwMAIAZB0ANqIBM3AwAgBikD+AIhEyAGQYyKiAEpAgA3A/gCIAYgEzcDyAMgBkHYA2ogBkHIA2ogBkHoAmoiBxCkBiAGQfgCaiIIQQRBBBDgHiACIAMpAgA3AwAgBiAGKQLYAzcD+AIgBiAGQagCajYC6AMgBiAHNgLkAyAGIAQ2AuADIAYgCDYC3AMgBiAGQZgCajYC2ANBECEHA0AgB0ECdiEDAkACQAJAAkACQCAGQdgDaiAHaigCACICLQAMQQFrDgIEAQALIAEgAyAFbCIDSQ0BIAAgA0ECdGogASADayACKAIEIAIoAggQzRAMAwsgASADIAVsIgNJDQEgACADQQJ0aiABIANrIAIoAgQgAigCCBCEEwwCCyADIAFB8IuIARCvOwALIAMgAUGAjIgBEK87AAsgB0EEayIHQXxHDQALIAZBiANqQQRBBBDgHiAGQfgCakEEQQQQ4B4gBkHoAmpBBEEEEOAeIAZBqAJqQQRBBBDgHiAGQZgCakEEQQQQ4B4MAgsgACABIAIgAyAMIApBAXYiBBCLASABIARPBEAgASAEayEBIAogBGshBSAAIARBAnQiBGohACAEIAxqIQQMAQsLIAQgAUHQjIgBEK87AAsgBkHwA2okAAvYVAIVfwR+IwBBsAJrIgMkACABKAIIIgZBBGohBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGQXtNBEAgBCABKAIEIgVLDUYgA0HoAWoiByABKAIAIgQgBSAGIAQgBmoiCCgAAGsQ9jQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQQwQzCBB//8DcSIHBEAgBiAHaiIHQQRqIQkgB0F7Sw0+IAUgCUkNPyACDQELIANB6AFqIgIgBCAFIAYgCCgAAGsQ9jQgAkEIEMwgIgJB//8DcUUEQEEAIQcMggELIAYgAkH//wNxaiICIAVLDYMBIAIgBGotAAAiB0EBaw4YAQMLBAcCFgwNDg8RNhcKExUQBgkSFAUIgQELIAQgB2ooAAAgB2oiAkEEaiEGIAJBe0sNPiAFIAZJDT8gA0HoAWoiBiAEIAUgAiACIARqKAAAaxD2NAJAIAZBBhDMIEH//wNxIgYEQCACIAZqIgJBBGohBiACQXtLDUIgBSAGTw0BIAYgBUGAuf4AELA7AAtBlLr+ABCyOwALIAIgBGooAAAgAmoiAkEEaiEGIAJBe0sNQSAFIAZJDUIgA0HoAWoiBiAEIAUgAiACIARqIggoAABrEPY0IAZBBBDMIEH//wNxIgYEfyACIAZqIgYgBUsNRCAEIAZqKAAAQQhrBUF4CyEGIANB6AFqIgcgBCAFIAIgCCgAAGsQ9jQgB0EGEMwgIghB//8DcQR/IAIgCEH//wNxaiICIAVLDYMBIAIgBGotAABBAEcFQQALIQICfwJAAkACQAJAAkAgBkEddw4IAQIAAwAAAAQACyADQQA2AvgBIANBATYC7AEgA0HEuv4ANgLoASADQgQ3AvABIANB6AFqQcy6/gAQ7ywAC0ECQQYgAhsMAwtBA0EHIAIbDAILQQRBCCACGwwBC0EFQQkgAhsLIQVBDEEEEK02IgJFDUQgAiAFOgAAIANB6AFqIAFBABCMAUEMQQQQrTYiAUUNRSABIAMpAugBNwIAIAFBCGogA0HwAWooAgA2AgAgACABNgIIIAAgAjYCBCAAQSI6AAAMfwsgAEEAOgAADH4LIABBAToAAAx9CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUMgAiAGaiICIAVLDX8gAiAEai0AAEECRw1DIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgZFDUMgAygCOCIFQQRqIQEgBUF7Sw1EIAEgAygCNCIESw1FIAcgBiAEIAUgBSAGaiIIKAAAaxD2NEEAIQJBACEBIAdBBBDMIEH//wNxIgcEQCAFIAdqIgEgBEsNgQEgASAGaigAACEBCyADQegBaiIHIAYgBCAFIAgoAABrEPY0IAdBBhDMICIIQf//A3EEQCAFIAhB//8DcWoiAiAESw1HIAIgBmotAABBAEchAgsgAUEIa0Eddw4IFRYUFxQUFBgUCyAAQRQ6AAAMewsgAEEXOgAADHoLIABBFjoAAAx5CyAAQRg6AAAMeAsgAEEaOgAADHcLIABBGToAAAx2CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUAgAiAGaiICIAVLDXggAiAEai0AAEEPRw1AIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUAgAygCOCIBQQRqIQQgAUF7Sw16IAQgAygCNCICSw17IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBAR/IAEgBGoiASACSw19IAEgBWooAAAFQQALIQEgAEEVOgAAIAAgATYCBAx1CyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUAgAiAGaiICIAVLDXcgAiAEai0AAEEDRw1AIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUAgAygCOCIBQQRqIQQgAUF7Sw15IAQgAygCNCICSw16IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBEUNEiABIARqIgEgAksNeyABIAVqLwAAIgEOAxITFBELIANB6AFqIgAgBCAFIAYgCCgAAGsQ9jQgAEEIEMwgQf//A3EiAkUNQCACIAZqIgIgBUsNdiACIARqLQAAQQhHDUAgA0EANgLoASADQTBqIgYgAUEKIAAQvBQgAygCMCIFRQ1AIAMoAjgiAUEEaiEEIAFBe0sNeCAEIAMoAjQiAksNeSAAIAUgAiABIAEgBWooAABrEPY0IABBBBDMIEH//wNxIgRFDRQgASAEaiIBIAJLDXpBDiABIAVqLwAAIgFFDRUaIAFBAUYNFCADIAE7AdwBIANBAjYC7AEgA0HcvP4ANgLoASADQgE3AvQBIANBxQs2AjQgAyAGNgLwASADIANB3AFqNgIwIABB7Lz+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQCACIAZqIgIgBUsNdSACIARqLQAAQQlHDUAgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBEUNQCADKAI4IgJBBGohASACQXtLDUEgASADKAI0IgVLDUIgByAEIAUgAiACIARqIgYoAABrEPY0IAdBBhDMIEH//wNxIgEEfyABIAJqIgEgBUsNfSABIARqKAAABUEgCyEBIANB6AFqIgggBCAFIAIgBigAAGsQ9jQgCEEEEMwgIgZB//8DcQR/IAIgBkH//wNxaiICIAVLDXYgAiAEai8AAAVBAQshAiABQSBGDRUgAUHAAEYNFgxxCyADQegBaiIJIAQgBSAGIAgoAABrEPY0IAlBCBDMIEH//wNxIgJFDUIgAiAGaiICIAVLDXQgAiAEai0AAEEKRw1CQQAhBiADQQA2AugBIANBMGogAUEKIAkQvBQgAygCMCICRQ1CIAMgAykCNCIYNwLgASADIAI2AtwBIANBCGogA0HcAWpBBhC9FCAYQiCIpyEBIAMoAggiBQRAIAMgBSADKAIMEJQnIAMoAgQhByADKAIAIQYLIAFBBGohBCAYQv////+/f1YNdiAEIBinIgVLDXMgA0HoAWoiBCACIAUgASABIAJqKAAAaxD2NCAEQQQQzCBB//8DcSIERQRAQQAhAgxwCyABIARqIgEgBUsNeyABIAJqLwAAIgJBBEkNbyADIAI7AdABIANBAjYC7AEgA0GMvv4ANgLoASADQgE3AvQBIANBxgs2AjQgAyADQTBqNgLwASADIANB0AFqNgIwIANB6AFqQZy+/gAQ7ywACyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUIgAiAGaiICIAVLDXMgAiAEai0AAEELRw1CIANBADYC6AEgA0EwaiABQQogBxC8FCADKAIwIgVFDUIgAygCOCIBQQRqIQQgAUF7Sw11IAQgAygCNCICSw12IAcgBSACIAEgASAFaigAAGsQ9jQgB0EEEMwgQf//A3EiBEUNGiABIARqIgEgAksNdyABIAVqLwAAIgEOAxobHBkLIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQiACIAZqIgIgBUsNciACIARqLQAAQRJHDUIgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBUUNQiADKAI4IgFBBGohBCABQXtLDXQgBCADKAI0IgJLDXUgByAFIAIgASABIAVqKAAAaxD2NCAHQQQQzCBB//8DcSIERQ0eIAEgBGoiASACSw12IAEgBWovAAAiAQ4EHR4fIBwLIANBADYC6AEgA0EwaiABQQ4gA0HoAWoiBBC8FCADKAIwIgVFDUIgAygCOCIBIAMoAjQiAksNdSABIAVqKAAAQQFGDSAgA0EANgL4ASADQQE2AuwBIANBgMD+ADYC6AEgA0IENwLwASAEQYjA/gAQ7ywACyADQQA2AugBIANBMGogAUEOIANB6AFqIgQQvBQgAygCMCIFRQ1CIAMoAjgiASADKAI0IgJLDXQgASAFaigAAEEBRg0gIANBADYC+AEgA0EBNgLsASADQdDA/gA2AugBIANCBDcC8AEgBEHYwP4AEO8sAAsgA0EANgLoASADQTBqIAFBDiADQegBaiIKELwUIAMoAjAiCUUNQiADKAI4IgIgAygCNCIHSw1DIAIgCWoiCygAAEEBRw0hIAogBCAFIAYgCCgAAGsQ9jQgCkEIEMwgQf//A3EiCA0gDGkLIANBADYC6AEgA0EwaiICIAFBDiADQegBaiIGELwUIAMoAjAiBEUNQyADKAI4IgEgAygCNCIFSw11IAEgBGoiCCgAAEECRg0iIAEgBUsNdSAIKAAAIQAgA0E7NgI0IAMgADYC3AEgA0EBNgLsASADQeTB/gA2AugBIANCATcC9AEgAyADQdwBajYCMCADIAI2AvABIAZB7MH+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNQyACIAZqIgIgBUsNbSACIARqLQAAQRFHDUMgA0EANgLoASADQTBqIgQgAUEKIAcQvBQgAygCMCIGRQ1DIAMoAjghAiADKAI0IQUgA0EANgLoASAEIAFBDiAHELwUIAMoAjAiCEUNRCADKAI4IgEgAygCNCIESw1uIAEgCGooAABBAUYNIiADQQA2AvgBIANBATYC7AEgA0G8wv4ANgLoASADQgQ3AvABIAdBxML+ABDvLAALIANB6AFqIgcgBCAFIAYgCCgAAGsQ9jQgB0EIEMwgQf//A3EiAkUNRCACIAZqIgIgBUsNbCACIARqLQAAQQdHDUQgA0EANgLoASADQTBqIAFBCiAHELwUIAMoAjAiBUUNRCADKAI4IgJBBGohBCACQXtLDUUgBCADKAI0IgFLDUYgByAFIAEgAiACIAVqIgQoAABrEPY0IAMgB0EIEMwgQf//A3EiBgR/IAIgBmoiBiABSw1IIAUgBmooAAAFQYABCyIINgLcASADQegBaiIGIAUgASACIAQoAABrEPY0AkAgBkEEEMwgIgZB//8DcUUEQEEAIQcMAQsgAiAGQf//A3FqIgYgAUsNSSAFIAZqKAAAIgdBgAJPDUoLIANB6AFqIgYgBSABIAIgBCgAAGsQ9jQCQCAGQQYQzCBB//8DcSIERQRAQQAhBQwBCyACIARqIgIgAUsNSyACIAVqKAAAIgVBgAFrQf99TQ1MCyAIQSBrQRt3IgFBCEkNIgxlCyADQegBaiIHIAQgBSAGIAgoAABrEPY0IAdBCBDMIEH//wNxIgJFDUsgAiAGaiICIAVLDWsgAiAEai0AAEEORw1LIANBADYC6AEgA0EwaiIFIAFBCiAHELwUIAMoAjAiBkUNSyADKAI4IghBBGohAiAIQXtLDUwgAiADKAI0IgRLDU0gByAGIAQgCCAGIAhqIgooAABrEPY0IAdBBBDMIEH//wNxIgJFDSIgAiAIaiICIARLDU5BASACIAZqLwAAIgJBAUYNIxogAkUNIiADIAI7AdwBIANBATYC7AEgA0H0w/4ANgLoASADQgE3AvQBIANBxws2AjQgAyAFNgLwASADIANB3AFqNgIwIAdB/MP+ABDvLAALIAMgAjoA4AEgAyABNgLcASADQQM2AuwBIANBpLv+ADYC6AEgA0ICNwL0ASADQcgLNgI8IAMgA0HgAWo2AjggA0GcAzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBvLv+ABDvLAALIAJFBEAgAEEGOgAADGcLIABBAjoAAAxmCyACRQRAIABBBzoAAAxmCyAAQQM6AAAMZQsgAkUEQCAAQQg6AAAMZQsgAEEEOgAADGQLIAJFBEAgAEEJOgAADGQLIABBBToAAAxjCyADIAE7AdwBIANBAjYC7AEgA0GUvP4ANgLoASADQgE3AvQBIANByQs2AjQgAyADQTBqNgLwASADIANB3AFqNgIwIANB6AFqQaS8/gAQ7ywACyAAQQo6AAAMYQsgAEELOgAADGALIABBDDoAAAxfC0EPCzoAAAxdCyACQf//A3EOAgECWwsgAkH//wNxQQJrDgICA1oLIABBEDsBAAxaCyAAQZACOwEADFkLIABBkQQ7AQAMWAsgAEGRBjsBAAxXCyADIAE7AdwBIANBAjYC7AEgA0Hkvv4ANgLoASADQgE3AvQBIANBygs2AjQgAyADQTBqNgLwASADIANB3AFqNgIwIANB6AFqQfS+/gAQ7ywACyAAQRM7AQAMVQsgAEGTAjsBAAxUCyAAQZMEOwEADFMLIAMgATsB3AEgA0ECNgLsASADQbC//gA2AugBIANCATcC9AEgA0HGCzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBwL/+ABDvLAALIABBEjsBAAxRCyAAQZICOwEADFALIABBkgQ7AQAMTwsgAEGSBjsBAAxOCyABQQhqIgQgAUEEaiIBSQ00IAIgBEkNNSADIAI2AjQgAyAFNgIwIAMgASAFaigAACABajYCOCADQegBaiICIANBMGoQ8ANB0ABBCBCtNiIBRQ1VIAFCgYCAgBA3AwAgAUEIaiACQcgA/AoAACAAQRs6AAAgACABNgIEDE0LIAFBCGoiBCABQQRqIgFJDTUgAiAESQ02IAMgAjYCNCADIAU2AjAgAyABIAVqKAAAIAFqNgI4IANB6AFqIgIgA0EwahDwA0HQAEEIEK02IgFFDVQgAUKBgICAEDcDACABQQhqIAJByAD8CgAAIABBHjoAACAAIAE2AgQMTAsgBiAIaiIGIAVLDTYgBCAGai0AAEEQRw1IIANBADYC6AEgA0EwaiIIIAFBCiADQegBaiIFELwUIAMoAjAiBEUNSCALKAAARQ1UIAJBCGoiASACQQRqIgZJDTcgASAHSw04IAMoAjghASADKAI0IQIgAyAHNgI0IAMgCTYCMCADIAYgCWooAAAgBmo2AjggBSAIEPADQdAAQQgQrTYiBkUNUyAGQoGAgIAQNwMAIAZBCGogBUHIAPwKAAAgAUEEaiEIIAFBe0sNOSACIAhJDTogBSAEIAIgASABIARqKAAAaxD2NCAAIAVBBBDMIEH//wNxIgUEfyABIAVqIgEgAksNUyABIARqKAAABUEACzYCBCAAIAY2AgggAEEdOgAADEsLIANBADYC+AEgA0EBNgLsASADQYDA/gA2AugBIANCBDcC8AEgA0HoAWpBiMH+ABDvLAALIANBADYC6AEgA0EwaiABQQ4gA0HoAWoiAhC8FAJ/IAMoAjAiBARAIAMoAjgiASADKAI0IgVLDVUgAyAFNgLsASADIAFBBGo2AvABIAMgBDYC6AEgAyABIARqKAAANgL0ASMAQTBrIgEkACABQSBqIAJBCGopAgA3AwAgASACKQIANwMYIAFBDGohBCMAQSBrIgIkAAJAAkACQCABQRhqIgkiBRD/FCIHBEAgAkEQaiIGQQQgBSgCDEEBaiIIQX8gCBsiCCAIQQRNG0EAQQRBBBCgGCACKAIUIQggAigCEEEBRg0CIAIoAhgiCiAHNgIAIAJBDGoiC0EBNgIAIAIgCjYCCCACIAg2AgQgAkEYaiAFQQhqKQIANwMAIAIgBSkCADcDECAGEP8UIggEQCACQQRqIQUDQCAFKAIIIgcgBSgCAEYEQCAFIAYoAgxBAWoiCkF/IAobEIAuCyAFKAIEIAdBAnRqIAg2AgAgBSAHQQFqNgIIIAYQ/xQiCA0ACwsgBEEIaiALKAIANgIAIAQgAikCBDcCAAwBCyAEQQA2AgggBEKAgICAwAA3AgALIAJBIGokAAwBCyAIIAIoAhhBjID/ABD9LwALIAEoAgwhBiABKAIQIQIgASABKAIUIgU2AhggASAFQQJ0IgUgCRC/ISABKAIAIQQgASgCBCEIIAUEQCAEQQhqIAIgBfwKAAALIAFBADYCJCABIAI2AhwgASAGNgIYIAEgAUEvajYCICABQRhqIgIQxicgAhDpOyADQRhqIgIgCDYCBCACIAQ2AgAgAUEwaiQAIAMoAhghBSADKAIcDAELIANBEGoQwSwgAygCECEFIAMoAhQLIQEgACAFNgIEIABBIDoAACAAIAE2AggMSQsgAUEIaiICIAFBBGoiBkkNOCACIAVLDTkgAyAFNgLsASADIAQ2AugBIAMgBCAGaigAACAGajYC8AEgA0FAayIGIANB6AFqIgcQ8AMgCCgAAEEBTQ1RIAFBDGoiASACSQ06IAEgBUsNOyADIAU2AuwBIAMgBDYC6AEgAyACIARqKAAAIAJqNgLwASADQYgBaiIFIAcQ8ANB0ABBCBCtNiIBRQ1QIAFCgYCAgBA3AwAgAUEIaiAGQcgA/AoAAEHQAEEIEK02IgJFDVAgAkKBgICAEDcDACACQQhqIAVByAD8CgAAIAAgAjYCCCAAIAE2AgQgAEEoOgAADEgLIAFBCGoiByABQQRqIgFJDTsgBCAHSQ08IAMgBDYCNCADIAg2AjAgAyABIAhqKAAAIAFqNgI4IANB6AFqIgEgA0EwahDwA0HQAEEIEK02IghFDU8gCEKBgICAEDcDACAIQQhqIAFByAD8CgAAIAJBBGohBCACQXtLDT0gBCAFSw1JIAEgBiAFIAIgAiAGaigAAGsQ9jQgACABQQQQzCBB//8DcSIBBH8gASACaiICIAVLDUsgAiAGai0AAEEARwVBAAs6AAEgACAINgIEIABBJzoAAAxHC0GLASABdkEBcUUNQiAAIAU6AAIgACAHOgABIABCo8iAqIKAgIAmIAFBA3StiDwAAAxGC0EACyETIANBADYC2AEgA0KAgICAgAE3AtABIANBADYC6AEgA0HcAWogAUEOIANB6AFqELwUAkAgAygC3AEiCUUNACADKALkASIBIAMoAuABIgdLDTwgASAJaiILKAAAIgxFDQAgAUEEaiECQQAhBQNAIAUgCygAAE8NTyACQXtLDT8gAkEEaiIBIAdLDUAgAyAHNgI0IAMgCTYCMCADIAIgAiAJaigAAGo2AjggA0HoAWogA0EwahDwAyADKALYASICIAMoAtABRgRAIANB0AFqQczD/gAQtygLIAMoAtQBIAJByABsaiADQegBakHIAPwKAAAgAyACQQFqNgLYASABIQIgDCAFQQFqIgVHDQALCyADQegBaiICIAYgBCAIIAooAABrEPY0An8gAkEGEMwgQf//A3EiAQRAIAEgCGoiAUEEaiEFIAFBe0sNPiAEIAVJDUEgASAGaigAACABaiIBIARLDUogAyAENgLsASADIAFBBGo2AvABIAMgBjYC6AEgAyABIAZqKAAANgL0ASADQThqIANB2AFqKAIANgIAIAMgAykC0AE3AzAjAEHQAGsiBSQAIANBMGoiBCgCACEGIAQoAgQhASAEKAIIIQQgBUIANwMYIAVCADcDECAFQShqIAJBCGopAgA3AwAgBUIANwJEIAUgASAEQcgAbGo2AkAgBSAGNgI8IAUgATYCOCAFIAE2AjQgBSACKQIANwMgIAUgBUEQajYCMCMAQdAAayICJAAgAkEgaiIBIAVBIGpBLPwKAAAgAkEUaiEJIwBBQGoiBCQAIAQgARDfDgJAAkACQCAEKAIEIgoEQCAELQAAIQsgBEEUaiIGQQMgASgCICABKAIYa0HIAG4iCCABKAIMIgcgByAISxsiCCAIQQNNG0EBakEAQQRBCBCgGCAEKAIYIQggBCgCFEEBRg0CIAQoAhwiByAKNgIEIAcgCzoAACAEQRBqIg5BATYCACAEIAc2AgwgBCAINgIIIAYgAUEs/AoAACMAQRBrIggkACAIQQhqIAYQ3w4gCCgCDCIKBEAgBEEIaiEHIAgtAAghCwNAIAcoAggiDCAHKAIARgRAIAcgBigCICAGKAIYa0HIAG4iDSAGKAIMIhAgDSAQSRtBAWoQ/y0LIAcoAgQgDEEDdGoiDSAKNgIEIA0gCzoAACAHIAxBAWo2AgggCCAGEN8OIAgtAAAhCyAIKAIEIgoNAAsLIAZBFGoQ0BwgCEEQaiQAIAlBCGogDigCADYCACAJIAQpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBFGoQ0BwLIARBQGskAAwBCyAIIAQoAhxBjID/ABD9LwALIAIoAhQhCCACKAIYIQQgAiACKAIcIgY2AiAgAkEIaiAGQQN0IgYgARC/ISACKAIIIQEgAigCDCEHIAYEQCABQQhqIAQgBvwKAAALIAJBADYCLCACIAQ2AiQgAiAINgIgIAIgAkHPAGo2AiggAkEgaiIEEN8mIAQQ6jsgBUEIaiIEIAc2AgQgBCABNgIAIAJB0ABqJAAgA0EoaiAFKQMINwMAIAVB0ABqJAAgAygCKCEFIAMoAiwMAQsgA0HwAWogA0HYAWooAgAiBTYCACADIAMpAtABNwPoASMAQUBqIgckACADQegBaiICKAIAIQQgAigCBCEBIAIoAgghAiAHQgA3AxggB0IANwMQIAdCADcDOCAHIAEgAkHIAGxqNgI0IAcgBDYCMCAHIAE2AiwgByABNgIoIAcgB0EQaq0gBa1C/wGDQiiGhDcDICMAQUBqIgYkACAGQTBqIAdBIGoiAUEYaikCADcDACAGQShqIAFBEGopAgA3AwAgBkEgaiABQQhqKQIANwMAIAYgASkCADcDGCAGQQxqIQsjAEHwAGsiBCQAAkACQAJAAkACQCAGQRhqIhAiAiwABCIIIAIsAAUiCU4NACACIAhBAWoiCjoABCAEIAg6AB8gBEIBQgAgCEH/AHEQxiMgAigCACIBKQMAIhggBCkDACIZgyABKQMIIhogBCkDCCIbg4RQRQ0CIAEgGCAZhDcDACABIBogG4Q3AwggAigCDCIFIAIoAhQiDEYNACACIAVByABqIg42AgwgBSgCNCINQYCAgIB4Rg0AIARBKGoiASAFQTT8CgAAIARB6ABqIAVBQGspAwA3AwAgBCANNgJcIAQgBSkDODcDYCABENApIQ0gAUEEQQMgDCAOa0HIAG4iBSAJIArAIgprIgwgBSAMSRsiBSAFQQNNG0EBaiAJIApMG0EAQQRBCBCgGCAEKAIsIQUgBCgCKEEBRg0DIAQoAjAiCSANNgIEIAkgCDoAACAEQRhqIhRBATYCACAEIAk2AhQgBCAFNgIQIARBQGsgAkEYaikCADcDACAEQThqIAJBEGopAgA3AwAgBEEwaiACQQhqKQIANwMAIAQgAikCADcDKCAEQRBqIQkjAEHwAGsiCCQAAkACQAJAIAEsAAQiAiABLAAFIg5ODQAgAkF/cyENIAEoAgAhDCAIQeAAaiIVQQhqIRYDQCABIAJBAWoiBToABCAIIAI6AB8gCEIBQgAgAkH/AHEQxiMgDCkDACIYIAgpAwAiGYMgDCkDCCIaIAgpAwgiG4OEUEUNAiAMIBggGYQ3AwAgDCAaIBuENwMIIAEoAgwiCiABKAIUIg9GDQEgASAKQcgAaiIRNgIMIAooAjQiEkGAgICAeEYNASAIQShqIhcgCkE0/AoAACAWIApBQGspAwA3AwAgFSAKKQM4NwMAIAggEjYCXCAXENApIRIgCSgCCCIKIAkoAgBGBEAgCUEBIA8gEWtByABuIg8gDSAOaiIRIA8gEUkbQQFqIAUgDk4bEP8tCyAJKAIEIApBA3RqIg8gEjYCBCAPIAI6AAAgCSAKQQFqNgIIIA1BAWshDSAFIgIgDkcNAAsLIAFBCGoQ0BwgCEHwAGokAAwBCyAIQQE2AiwgCEH07f4ANgIoIAhCATcCNCAIQfQLNgIkIAggCEEgajYCMCAIIAhBH2o2AiAgCEEoakH87f4AEO8sAAsgC0EIaiAUKAIANgIAIAsgBCkCEDcCAAwBCyALQQA2AgggC0KAgICAwAA3AgAgAkEIahDQHAsgBEHwAGokAAwCCyAEQQE2AiwgBEH07f4ANgIoIARCATcCNCAEQfQLNgIkIAQgBEEgajYCMCAEIARBH2o2AiAgBEEoakH87f4AEO8sAAsgBSAEKAIwQYyA/wAQ/S8ACyAGKAIMIQQgBigCECEBIAYgBigCFCICNgIYIAYgAkEDdCICIBAQvyEgBigCACEFIAYoAgQhCCACBEAgBUEIaiABIAL8CgAACyAGQQA2AiQgBiABNgIcIAYgBDYCGCAGIAZBP2o2AiAgBkEYaiIBEN8mIAEQ6jsgB0EIaiIBIAg2AgQgASAFNgIAIAZBQGskACADQSBqIAcpAwg3AwAgB0FAayQAIAMoAiAhBSADKAIkCyEBIAAgBTYCBCAAIBM6AAEgAEEhOgAAIAAgATYCCAxECyAGIARBkLn+ABCxOwALIAcgCUGAuf4AELE7AAsgCSAFQYC5/gAQsDsACyACIAZBkLn+ABCxOwALIAYgBUGQuf4AELA7AAsgAiAGQYC5/gAQsTsACyACIAZBkLn+ABCxOwALIAYgBUGQuf4AELA7AAsgBiAFQfS1/gAQrzsAC0EEQQwQoz0AC0EEQQwQoz0AC0Hcuv4AELI7AAsgBSABQZC5/gAQsTsACyABIARBkLn+ABCwOwALIAIgBEH0tf4AEK87AAtBzLv+ABCyOwALQdy7/gAQsjsAC0G0vP4AELI7AAtB/Lz+ABCyOwALIAIgAUGQuf4AELE7AAsgASAFQZC5/gAQsDsAC0Hgvf4AELI7AAtBrL7+ABCyOwALQYS//gAQsjsAC0HQv/4AELI7AAtBmMD+ABCyOwALQejA/gAQsjsACyACIAdB9LX+ABCvOwALQZjB/gAQsjsAC0H8wf4AELI7AAtBjML+ABCyOwALQdTC/gAQsjsACyACIARBkLn+ABCxOwALIAQgAUGQuf4AELA7AAsgBiABQfS1/gAQrzsACyAGIAFB9LX+ABCvOwALQYS4/gBBKyADQegBakH0t/4AQeTC/gAQ1R4ACyACIAFB9LX+ABCvOwALQYS4/gBBKyADQegBakH0t/4AQfTC/gAQ1R4AC0G8w/4AELI7AAsgCCACQZC5/gAQsTsACyACIARBkLn+ABCwOwALIAIgBEH0tf4AEK87AAsgASAEQYC5/gAQsTsACyAEIAJBgLn+ABCwOwALIAEgBEGAuf4AELE7AAsgBCACQYC5/gAQsDsACyAGIAVB9LX+ABCvOwALIAYgAUGAuf4AELE7AAsgASAHQYC5/gAQsDsACyABIAhBkLn+ABCxOwALIAggAkGQuf4AELA7AAsgBiACQYC5/gAQsTsACyACIAVBgLn+ABCwOwALIAIgAUGAuf4AELE7AAsgASAFQYC5/gAQsDsACyABIAdBgLn+ABCxOwALIAcgBEGAuf4AELA7AAsgAiAEQZC5/gAQsTsACyABIAdB9LX+ABCvOwALIAEgBUGAuf4AELE7AAsgAiACQQRqQYC5/gAQsTsACyACQQRqIAdBgLn+ABCwOwALIAUgBEGAuf4AELA7AAsgA0EBNgLsASADQaTD/gA2AugBIANCATcC9AEgA0GcAzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBrMP+ABDvLAALQfjA/gAQsjsACyAAIAc2AgggACAGNgIEIAAgAjoAASAAQQ06AAAMAQsgAyACOwHgASADIAE2AtwBIANBAzYC7AEgA0G4vf4ANgLoASADQgI3AvQBIANBxgs2AjwgAyADQeABajYCOCADQZwDNgI0IAMgA0EwajYC8AEgAyADQdwBajYCMCADQegBakHQvf4AEO8sAAsgA0GwAmokAA8LIAMgBzoA3AEgA0ECNgLsASADQaTE/gA2AugBIANCATcC9AEgA0HLCzYCNCADIANBMGo2AvABIAMgA0HcAWo2AjAgA0HoAWpBtMT+ABDvLAALIAQgBUGQuf4AELA7AAsgAiAFQfS1/gAQrzsACyABIARB9LX+ABCvOwALIAEgBEGQuf4AELE7AAsgBCACQZC5/gAQsDsACyABIAJB9LX+ABCvOwALQQhB0AAQoz0AC0GEtv4AQSJBqLb+ABCfKQALIAEgBUH0tf4AEK87AAu4TwIHfwN+IwBB4ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASACKAIcIgYRBAAiBS0AAEECaw4lARsaGRgXFhUUExIAAAAAABEQAAAAAAAAAAAAAAAAAAAADw4NDAALIAEgBhEEACIFLQAAQQ1rDg0JCAcGBQoKBAoDCgIBCgsgASACEPIhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgBEE4aiEHIAIoAhAhCCACKAIUIQMCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQE2AgggBiABIAhqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMHQsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwbCwwcCyABIAIQmCIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ8RYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwdCwwZCyABIAIQmSIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ/xYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwcCwwYCyABIAIQliIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQ8hYgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwbCwwXCyABIAIQlyIhAiMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCEFAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASAFNgIMIAYgAxDINCABQThqIQcDQAJAAkAgASkDQCIMUEUEQCABKQNIIQsMAQsDQAJ+AkAgASkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAEgC1CtQgGGNwMoIAunQQFxRQ0AIAEgASkDMDcDWAwBCyABKAI4RQ0BIAFB0ABqIAcQtiogASkDUCELCyALQgBSDQILIAFCAzcDKAsgASkDGCILQgJRDQQgAUIANwMYIAEpAyAMAQsgASkDWAshDCALp0EBcUUNAiABIAEpA0hCQH0iCzcDSCABIAw3A0AgDFANAAsLIAEgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIDEJU7IQUgASACIAMQgBcgASgCAEEAIAUbIQggASgCBCEJIAEoAhQiBSABKAIMRgRAIAFBDGpB+LWDARCQKAsgASgCECAFQQxsaiIGIAk2AgggBiAINgIEIAYgAzYCACABIAVBAWo2AhQMAQsLIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCwwaCwwWCwJAAkAgBS0AAUECaw4CAAEGCyAAIAEgAhDlISADEM0LDBYLIAAgASACEO0hIAMQzQsMFQsCQAJAIAUtAAEOAgABBQsgACABIAIQ/iEgAxDOCwwVCyAAIAEgAhDxISADEM4LDBQLIAAgASACEPohIAMQzQsMEwsgACABIAIQ/yEgAxDOCwwSCwJAAkACQAJAIAUtAAFBAWsOAwECAwALIAAgASACEPYhIAMQzQsMFAsgACABIAIQ6SEgAxDNCwwTCyAAIAEgAhDmISADEM0LDBILIAAgASACEPkhIAMQzQsMEQsgASAGEQQAIQAgBEGnBDYCVCAEIAA2AgwgBEECNgIcIARByLWDATYCGCAEQgE3AiQgBCAEQQxqNgJQIAQgBEHQAGo2AiAgBEEYakHYtYMBEO8sAAsgASACEOMhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEFdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQSA2AgggBiAIIAFBBXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMEgsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwQCwwRCyABIAIQ/CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQR2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBEDYCCCAGIAggAUEEdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwRCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADA8LDBALIAEgAhDoISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBA3YhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEINgIIIAYgCCABQQN0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDBALIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMDgsMDwsgASACEOQhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEECdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQQ2AgggBiAIIAFBAnRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMDwsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwNCwwOCwJAAkACQCAFLQABQQFrDgIBAgALIAAgASACEIAiIAMQzgsMDQsgACABIAIQ6yEgAxDNCwwMCyABIAIQ/SEhBSMAQeAAayIBJAAgAUEYaiIGIAMQ5zpBAEEEQQwQoBggASgCHCECAkAgASgCGEEBRwRAIAFBADYCFCABIAEoAiA2AhAgASACNgIMIAYgAxDINCAFKAIUQQR2IQMgAUE4aiEIIAUoAhAhCQJAA0ACQCABKQNAIgxQRQRAIAEpA0ghCwwBCwNAAn4CQCABKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgASALUK1CAYY3AyggC6dBAXFFDQAgASABKQMwNwNYDAELIAEoAjhFDQEgAUHQAGogCBC2KiABKQNQIQsLIAtCAFINAgsgAUIDNwMoCyABKQMYIgtCAlENBSABQgA3AxggASkDIAwBCyABKQNYCyEMIAunQQFxRQ0DIAEgASkDSEJAfSILNwNIIAEgDDcDQCAMUA0ACwsgASAMQgEgDHoiDYaFNwNAIAUgDacgC6dqIgIQizshCiACIANJBEAgASgCFCIGIAEoAgxGBEAgAUEMakH4tIMBEJAoCyABKAIQIAZBDGxqIgdBEDYCCCAHIAkgAkEEdGpBACAKGzYCBCAHIAI2AgAgASAGQQFqNgIUDAELCyACIANB6LSDARDDIQALIAAgASkCDDcCACAAQQhqIAFBFGooAgA2AgAgAUHgAGokAAwBCyACIAEoAiBB2LSDARD9LwALDAsLAkACQAJAAkAgBS0AAUEBaw4DAQIDAAsgACABIAIQ6iEgAxDNCwwNCyAAIAEgAhDnISADEM0LDAwLIAAgASACEIEiIAMQzQsMCwsgACABIAIQ7iEgAxDNCwwKCyABIAIQgiIhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQN2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBCDYCCCAGIAggAUEDdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwMCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAoLDAsLIAEgAhDvISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBAnYhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEENgIIIAYgCCABQQJ0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAsLIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMCQsMCgsgASACEPQhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEBdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQI2AgggBiAIIAFBAXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMCgsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwICwwJCyABIAIQ7CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQN2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBCDYCCCAGIAggAUEDdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwJCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAcLDAgLIAEgAhD1ISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBAnYhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEENgIIIAYgCCABQQJ0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAgLIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMBgsMBwsgASACEPAhIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEEBdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQI2AgggBiAIIAFBAXRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMBwsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwFCwwGCyABIAIQ9yEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRwRAIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCAEQThqIQcgAigCECEIIAIoAhQhAwJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBATYCCCAGIAEgCGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwGCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIADAQLDAULIAEgAhDzISECIARBGGoiBSADEOc6QQBBBEEMEKAYIAQoAhwhASAEKAIYQQFHBEAgBEEANgIUIAQgBCgCIDYCECAEIAE2AgwgBSADEMg0IAIoAhRBA3YhAyAEQThqIQcgAigCECEIAkADQAJAIAQpA0AiDFBFBEAgBCkDSCELDAELA0ACfgJAIAQpAygiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDKCALp0EBcUUNACAEIAQpAzA3A1gMAQsgBCgCOEUNASAEQdAAaiAHELYqIAQpA1AhCwsgC0IAUg0CCyAEQgM3AygLIAQpAxgiC0ICUQ0FIARCADcDGCAEKQMgDAELIAQpA1gLIQwgC6dBAXFFDQMgBCAEKQNIQkB9Igs3A0ggBCAMNwNAIAxQDQALCyAEIAxCASAMeiINhoU3A0AgAiANpyALp2oiARCLOyEJIAEgA0kEQCAEKAIUIgUgBCgCDEYEQCAEQQxqQfi0gwEQkCgLIAQoAhAgBUEMbGoiBkEINgIIIAYgCCABQQN0akEAIAkbNgIEIAYgATYCACAEIAVBAWo2AhQMAQsLDAULIAAgBCkCDDcCACAAQQhqIARBFGooAgA2AgAMAwsMBAsgASACEPshIQIgBEEYaiIFIAMQ5zpBAEEEQQwQoBggBCgCHCEBIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgATYCDCAFIAMQyDQgAigCFEECdiEDIARBOGohByACKAIQIQgCQANAAkAgBCkDQCIMUEUEQCAEKQNIIQsMAQsDQAJ+AkAgBCkDKCILQgNSBEACQAJAAkAgC0ICUQ0AIAQgC1CtQgGGNwMoIAunQQFxRQ0AIAQgBCkDMDcDWAwBCyAEKAI4RQ0BIARB0ABqIAcQtiogBCkDUCELCyALQgBSDQILIARCAzcDKAsgBCkDGCILQgJRDQUgBEIANwMYIAQpAyAMAQsgBCkDWAshDCALp0EBcUUNAyAEIAQpA0hCQH0iCzcDSCAEIAw3A0AgDFANAAsLIAQgDEIBIAx6Ig2GhTcDQCACIA2nIAunaiIBEIs7IQkgASADSQRAIAQoAhQiBSAEKAIMRgRAIARBDGpB+LSDARCQKAsgBCgCECAFQQxsaiIGQQQ2AgggBiAIIAFBAnRqQQAgCRs2AgQgBiABNgIAIAQgBUEBajYCFAwBCwsMBAsgACAEKQIMNwIAIABBCGogBEEUaigCADYCAAwCCwwDCyABIAIQ+CEhAiAEQRhqIgUgAxDnOkEAQQRBDBCgGCAEKAIcIQEgBCgCGEEBRg0CIARBADYCFCAEIAQoAiA2AhAgBCABNgIMIAUgAxDINCACKAIUQQF2IQMgBEE4aiEHIAIoAhAhCAJAA0ACQCAEKQNAIgxQRQRAIAQpA0ghCwwBCwNAAn4CQCAEKQMoIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3AyggC6dBAXFFDQAgBCAEKQMwNwNYDAELIAQoAjhFDQEgBEHQAGogBxC2KiAEKQNQIQsLIAtCAFINAgsgBEIDNwMoCyAEKQMYIgtCAlENBSAEQgA3AxggBCkDIAwBCyAEKQNYCyEMIAunQQFxRQ0DIAQgBCkDSEJAfSILNwNIIAQgDDcDQCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNAIAIgDacgC6dqIgEQizshCSABIANJBEAgBCgCFCIFIAQoAgxGBEAgBEEMakH4tIMBEJAoCyAEKAIQIAVBDGxqIgZBAjYCCCAGIAggAUEBdGpBACAJGzYCBCAGIAE2AgAgBCAFQQFqNgIUDAELCwwCCyAAIAQpAgw3AgAgAEEIaiAEQRRqKAIANgIACyAEQeAAaiQADwsgASADQei0gwEQwyEACyABIAQoAiBB2LSDARD9LwALIAUgASgCIEHotYMBEP0vAAuOUgIJfwR+IwBB8ARrIgQkACAEIAI2AhQgBCACQShqIgc2AhgCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAoIgVBFGsOFQUEBQIFBQILAQcLAQgJCgEBAQELDAALIAVFDQILIARB2AFqIAEgAhDxFSAEKALcASECIAQoAtgBIgNBk4CAgHhGDQsgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgAjYCBCAAIAM2AgAMEAsgAygCDCICBEAgAyACQQFrNgIMIAMgAygCCCIFQQFqIgcgAygCACIGQQAgBiAHTRtrNgIIIAMoAgQgBUEDdGopAwBCAnwhDQsgBEECNgLcASAEQdzW/gA2AtgBIARCATcC5AEgBEGnBDYCvAIgBCAEQbgCajYC4AEgBCAEQRhqNgK4AiAEQfwAaiAEQdgBahCZDiAEQYyAgIB4NgJ4IAINAyAEKQJ8IQ0gACAEKQKEATcCDCAAIA03AgQgAEGMgICAeDYCAAwPCyAEQdgBaiABIAIQ8RUgBCgC3AEhAiAEKALYASIDQZOAgIB4RwRAIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAI2AgQgACADNgIADA8LIAQgAikAACINNwPgAyAEIAIpAAgiDjcD6AMgDSAOUQRAIARBlARqIAcQxgYgBEIANwLIBCAEQQA2ArAEIARBADYCpAQgBCANPgKgBCAEQgQ3AowEIARCADcChAQgBEKAgICAwAA3AvwDIARBADYC9AMgACABIARB9ANqEMsQDA8LIARBAzYCfCAEQaDW/gA2AnggBEIDNwKEASAEQe4GNgLsASAEQe4GNgLkASAEQdILNgLcASAEIARB2AFqNgKAASAEIARB4ANqNgLoASAEIARB6ANqNgLgASAEIARBFGo2AtgBIARBuAJqIQMjAEEQayIBJAAgBEH4AGoiAigCDCEFAkACQAJAAkACQAJAAkAgAigCBA4CAAECCyAFDQFBASEFQQAhAgwCCyAFDQAgAigCACIFKAIEIQIgBSgCACEFDAELIAMgAhCZDgwBCyABQQRqIAJBAEEBQQEQoBggASgCCCEHIAEoAgRBAUYNASABKAIMIQYgAgRAIAYgBSAC/AoAAAsgAyACNgIIIAMgBjYCBCADIAc2AgALIAFBEGokAAwBCyAHIAEoAgxBnNX+ABD9LwALIABBhYCAgHg2AgAgACAEKQK4AjcCBCAAQQxqIARBwAJqKAIANgIADA4LIARB2AFqIAEgAhDxFSAEKALcASECIAQoAtgBIgNBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgAjYCBCAAIAM2AgAMDgsgBEH4AGogARCIFiAEQegEaiIDIARBhAFqIgUoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADA4LIARB2ARqIAMoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIDIAUoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgVBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAU2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNDiAEQdAEahD7HgwOCyAEQeQBaiIDIAQpA7gCNwIAIANBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgACABIAIgByAEQdgBaiICQQIQ6wZBACEAA0AgAigCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAhD7HgsgAEEBcUEBIQAgAyECRQ0ACwwNCyAEQdgBaiABIAIQ8RUgBCgC3AEhAiAEKALYASIDQZOAgIB4RwRAIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAI2AgQgACADNgIADA0LIARB+ABqIAEQiBYgBEGoA2oiAyAEQYQBaiIFKAIANgIAIAQgBCkCfDcDoAMgBCgCeCIGQZOAgIB4RwRAIAQoAogBIQEgACAEKQOgAzcCBCAAIAE2AhAgACAGNgIAIABBDGogAygCADYCAAwNCyAEQZADaiADKAIANgIAIAQgBCkDoAM3A4gDIARB+ABqIAEQiBYgBEHoBGoiAyAFKAIANgIAIAQgBCkCfDcD4AQgBCgCeCIFQZOAgIB4RwRAIAQoAogBIQEgACAEKQPgBDcCBCAAIAE2AhAgACAFNgIAIABBDGogAygCADYCACAEKAKIAyIAIAAoAgAiAEEBazYCACAAQQFHDQ0gBEGIA2oQ+x4MDQsgBEHYBGogBEHoBGoiBSgCADYCACAEIAQpA+AENwPQBCAEQfgAaiABEIgWIARBwAJqIgMgBEGEAWooAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQdAEahD7HgsgBCgCiAMiACAAKAIAIgBBAWs2AgAgAEEBRw0NIARBiANqEPseDA0LIARB+AFqIAMoAgA2AgAgBEHgAWogBEGQA2ooAgA2AgAgBEHsAWogBSgCADYCACAEIAQpA7gCNwPwASAEIAQpA4gDNwPYASAEIAQpA+AENwLkASAAIAEgAiAHIARB2AFqIgBBAxDrBkEAIQEDQCAAIAFqIgIoAgAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAIQ+x4LIAFBDGoiAUEkRw0ACwwMCyAEQfgAaiIHEIgRIAQgATYC6AEgBCANNwPgASAEQgA3A9gBIwBBQGoiAyQAIANBk4CAgHg2AgAgA0EwaiAEQdgBaiICQRBqKQMANwMAIANBKGogAkEIaikDADcDACADIAIpAwA3AyAgAyADNgI4IANBFGohCCMAQUBqIgIkACACQRRqIANBIGoiBRDqJAJAAkACQCACKAIUBEAgAkEgaiIJIAUQ2hkgCUEEIAIoAiBBAWoiBkF/IAYbIgYgBkEETRtBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgogAikCFDcCACAKQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAKNgIMIAIgBjYCCCACQThqIAVBGGopAwA3AwAgAkEwaiAFQRBqKQMANwMAIAJBKGogBUEIaikDADcDACACIAUpAwA3AyAjAEEgayIFJAAgBUEIaiAJEOokIAUoAggEQCACQQhqIQYDQCAGKAIIIgogBigCAEYEQCAFQRRqIAkQ2hkgBiAFKAIUQQFqIgxBfyAMGxD9LQsgBigCBCAKQQxsaiIMIAUpAgg3AgAgDEEIaiAFQRBqKAIANgIAIAYgCkEBajYCCCAFQQhqIAkQ6iQgBSgCCA0ACwsgBUEgaiQAIAhBCGogCygCADYCACAIIAIpAgg3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyACQUBrJAAMAQsgBiACKAIoQZT2/gAQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgByADKQIANwIAIAdBEGogA0EQaigCADYCACAHQQhqIANBCGopAgA3AgAgCBDFJyAIEOg7DAELIAcgAykCFDcCBCAHQZOAgIB4NgIAIAdBDGogA0EcaigCADYCAAsgA0FAayQAIARBwAJqIgIgBEGEAWooAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgNBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAM2AgAgAEEMaiACKAIANgIADAwLIARB6ARqIAIoAgA2AgAgBCAEKQO4AjcD4AQgBEHYAWogASAEKAIUEPEVIAQoAtwBIQIgBCgC2AEiA0GTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACACNgIEIAAgAzYCACAEQeAEaiIAEMUnIAAQ6DsMDAsgACABIAIgBCgCGCAEKALkBCAEKALoBBDrBiAEQeAEaiIAEMUnIAAQ6DsMCwsgBEHYAWogASACEPEVIAQoAtwBIQUgBCgC2AEiBkGTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAFNgIEIAAgBjYCAAwLCyAEQdgBaiABEIgWIARBgAFqIgYgBEHkAWooAgA2AgAgBCAEKQLcATcDeCAEKALYASIIQZOAgIB4RwRAIAQoAugBIQEgACAEKQN4NwIEIAAgATYCECAAIAg2AgAgAEEMaiAGKAIANgIADAsLIARBwAJqIAYoAgA2AgAgBCAEKQN4NwO4AiAEQdgBaiABIAIoAjBBCGogAxCOASAEKALgASECIAQoAtwBIQMgBCgC2AEiBkGTgICAeEcEQCAAIAQpAuQBNwIMIAAgAjYCCCAAIAM2AgQgACAGNgIAIAQoArgCIgAgACgCACIAQQFrNgIAIABBAUcNCyAEQbgCahD7HgwLCyAAIAEgBSAHIARBuAJqIgBBASADIAIQrwogBCgCuAIiASABKAIAIgFBAWs2AgAgAUEBRw0KIAAQ+x4MCgsgBEHYAWogASACEPEVIAQoAtwBIQggBCgC2AEiBUGTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAINgIEIAAgBTYCAAwKCyAEQdgBaiABEIgWIARBgAFqIgUgBEHkAWooAgA2AgAgBCAEKQLcATcDeCAEKALYASIHQZOAgIB4RwRAIAQoAugBIQEgACAEKQN4NwIEIAAgATYCECAAIAc2AgAgAEEMaiAFKAIANgIADAoLIARB6ARqIAUoAgA2AgAgBCAEKQN4NwPgBCAEQQA2AsACIARCgICAgMAANwK4AiAEIAJBLGoiBRCvLiAEKAIAIgIgBCgCBCIKRwRAA0AgBEHYAWogASACKAIAQQhqIAMQjgEgBCgC4AEhByAEKALcASEGIAQoAtgBIglBk4CAgHhHBEAgACAEKQLkATcCDCAAIAc2AgggACAGNgIEIAAgCTYCACAEQbgCaiIAEMMnIAAQ6jsgBCgC4AQiACAAKAIAIgBBAWs2AgAgAEEBRw0MIARB4ARqEPseDAwLIAQoAsACIgkgBCgCuAJGBEAgBEG4AmpB7Nb+ABCbKAsgBCgCvAIgCUEDdGoiCyAHNgIEIAsgBjYCACAEIAlBAWo2AsACIAJBBGoiAiAKRw0ACwsgBEGAAWogBEHoBGooAgA2AgAgBCAEKQPgBDcDeCAEQeABaiAEQcACaigCADYCACAEIAQpArgCNwPYASAEQfgAaiEJIAUhAiAEQdgBaiEHIwBB0AFrIgUkACAFIAgoAAgiBjYCACABLQBEIQMgCCgAACEIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBgRAIAVBBGogCUEAIAgQ8hUgA0EBcUUNASAFQSBqIAVBEGopAgA3AwAgBSAFKQIINwMYIAUoAgQhASAHKAIIDQMMCAsgBygCCA0BQQAhAQwHCyAFQbgBaiIBIAVBBGoQ4ScgBiAFKALMASIDRwRAIAUgAzYCqAEgBUEDNgJ4IAVBuNv+ADYCdCAFQgI3AoABIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCfCAFIAVBqAFqNgJoIAUgBTYCYCAAQQRqIAVB9ABqEJkOIABBjYCAgHg2AgAgBSgCuAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIAcQwycgBxDqOwwJCyAFQSBqIAVBxAFqKQIANwMAIAUgBSkCvAE3AxggBSgCuAEhASAHKAIIRQ0GDAILQQAhASADQQFxRQ0BCyACKAIAIgMgAygCACIIQQFqNgIAIAhBAEgNCCACKAIEIQIgBUHAAWogB0EIaigCADYCACAFIAcpAgA3A7gBIAVBgAFqIAVBIGopAwA3AgAgBSABNgJ0IAUgBSkDGDcCeCAFIAY2AogBIAVBLGohASAFQfQAaiEHIAVBuAFqIggoAghFBEBBiPaFAUHPAEHY9oUBEMskAAsgCCgCBCIKKAIAIAooAgQiCigCCEEBa0F4cWpBCGogCigCJBEEACEKIAEgAjYCFCABIAM2AhAgAUEgOgAMIAEgCjYCGCABIAcpAgA3AhwgAUEkaiAHQQhqKQIANwIAIAFBLGogB0EQaikCADcCACABIAgpAgA3AgAgAUEIaiAIQQhqKAIANgIADAELIAIoAgAiAyADKAIAIghBAWo2AgAgCEEASA0HIAIoAgQhAiAFQbABaiAHQQhqKAIANgIAIAUgBykCADcDqAEgBUHEAWogBUEgaikDADcCACAFIAE2ArgBIAUgBSkDGDcCvAEgBSAGNgLMASAFQfQAaiADIAIgBUGoAWogBUG4AWoQ5Q8gBUHoAGoiASAFQYABaikCADcDACAFQfAAaiICIAVBiAFqKAIANgIAIAUgBSkCeDcDYCAFKAJ0IgNBgICAgHhGDQEgBUHcAGogBUGkAWooAgA2AgAgBUHUAGogBUGcAWopAgA3AgAgBUHMAGogBUGUAWopAgA3AgAgBUE4aiABKQMANwIAIAVBQGsgAigCADYCACAFIAUpAowBNwJEIAUgBSkDYDcCMCAFIAM2AiwLQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAFQSxqQTT8CgAAIABB0Nv+ADYCCCAAIAE2AgQgAEGTgICAeDYCACAGDQQMAwsgACAFKQNgNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAgBkUNAgwDC0EEQTwQoz0ACyAFQcQBaiAFQSBqKQMANwIAIAUgATYCuAEgBSAFKQMYNwK8ASAFIAY2AswBIAVB9ABqIgIgCCAFQbgBahDVGEE8QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQdDb/gA2AgggACABNgIEIABBk4CAgHg2AgAgBxDDJyAHEOo7IAYNAQsgCSgCACIAIAAoAgAiAEEBazYCACAAQQFHDQAgCRD7HgsgBUHQAWokAAwCC0EEQTwQoz0LAAsMCQsgBEHYAWogASACEPEVIAQoAtwBIQUgBCgC2AEiB0GTgICAeEcEQCAAIAQpAuABNwIIIABBEGogBEHoAWooAgA2AgAgACAFNgIEIAAgBzYCAAwJCyAFKAAAIQUCQCABLgFAQQNKDQAgBEHYAWogARCIFiAEQYABaiIHIARB5AFqKAIANgIAIAQgBCkC3AE3A3ggBCgC2AEiBkGTgICAeEcEQCAEKALoASEBIAAgBCkDeDcCBCAAIAE2AhAgACAGNgIAIABBDGogBygCADYCAAwKCyAEQcACaiAHKAIANgIAIAQgBCkDeCINNwO4AiANpyIHIAcoAgAiB0EBazYCACAHQQFHDQAgBEG4AmoQ+x4LIARB2AFqIAEQiBYgBEGAAWoiByAEQeQBaigCADYCACAEIAQpAtwBNwN4IAQoAtgBIgZBk4CAgHhHBEAgBCgC6AEhASAAIAQpA3g3AgQgACABNgIQIAAgBjYCACAAQQxqIAcoAgA2AgAMCQsgBEHAAmogBygCADYCACAEIAQpA3g3A7gCIARB4ARqIgcgBEG4AmoiBkEAIAUQ5hUgBEH8AmogBxDjGSAEKAK4AiIHIAcoAgAiB0EBazYCACAHQQFGBEAgBhD7HgsCQCAEKAIYLQABQQFGBEAgBEHYAWogARCIFiAEQYABaiIHIARB5AFqKAIANgIAIAQgBCkC3AE3A3ggBCgC2AEiBkGTgICAeEYNASAEKALoASEBIAAgBCkDeDcCBCAAIAE2AhAgACAGNgIAIABBDGogBygCADYCAAwJCyAEQQA2AogDDAYLIARBwAJqIAcoAgA2AgAgBCAEKQN4NwO4AiAEQeAEaiIHIARBuAJqIgZBACAFQQJ0EOYVIARBlANqIAcQ5RkgBCgCuAIiBSAFKAIAIgVBAWs2AgAgBUEBRgRAIAYQ+x4LIARBkANqIARBnANqKAIANgIAIAQgBCkClAM3A4gDDAULIARB2AFqIAEgAhDxFSAEKALcASEIIAQoAtgBIgJBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgCDYCBCAAIAI2AgAMCAsgBEHYAWogARCIFiAEQegEaiICIARB5AFqIgMoAgA2AgAgBCAEKQLcATcD4AQgBCgC2AEiBUGTgICAeEcEQCAEKALoASEBIAAgBCkD4AQ3AgQgACABNgIQIAAgBTYCACAAQQxqIAIoAgA2AgAMCAsgBEHYBGogAigCADYCACAEIAQpA+AENwPQBCAEQdgBaiABEIgWIARBwAJqIgIgAygCADYCACAEIAQpAtwBNwO4AiAEKALYASIDQZOAgIB4RwRAIAQoAugBIQEgACAEKQO4AjcCBCAAIAE2AhAgACADNgIAIABBDGogAigCADYCACAEKALQBCIAIAAoAgAiAEEBazYCACAAQQFHDQggBEHQBGoQ+x4MCAsgBEGEAWoiAyAEKQO4AjcCACADQQhqIARBwAJqKAIANgIAIARBgAFqIARB6ARqKAIANgIAIAQgBCkD4AQ3A3ggBEHYAWohBSAEKAIUIgItAChBIkcEfkIABSACKQMgIQ1CAQshDiAEQRRqIQkjAEFAaiICJABBASEGAkAgDqdBAXEEQCAFIA03AwhBACEGDAELIAJBAjYCJCACQYzY/gA2AiAgAkIBNwIsIAJB0gs2AjwgAiAJNgI4IAIgAkE4ajYCKCACQRBqIAJBIGoQmQ4gAkGEgICAeDYCDCAFIAIpAgw3AgQgBUEMaiACQRRqKQIANwIAIAVBFGogAkEcaigCADYCAAsgBSAGNgIAIAJBQGskAAJAAkAgBCgC2AFBAUYEQCAEKALcASEBIAQpA+ABIQ0gACAEKQPoATcCDCAAIA03AgQgACABNgIADAELIAQgBCkD4AE3A7gCIARBuAJqIQlBACEFIAEoAjgiAigCDARAIAIoAgAiBkEQayELIAIoAgQiCiACQRBqIAkQjQ4iDadxIQUgDUIZiEL/AINCgYKEiJCgwIABfiEPIAkpAwAhEEEAIQICfwNAAkAgBSAGaikAACIOIA+FIg1Cf4UgDUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyINUEUEQANAIBAgCyANeqdBA3YgBWogCnEiDEEEdGspAwBRDQIgDUIBfSANgyINUEUNAAsLQQAgDiAOQgGGg0KAgYKEiJCgwIB/g1BFDQIaIAUgAkEIaiICaiAKcSEFDAELCyAGQQAgDGtBBHRqCyICQRBrQQAgAhshBQsgBEHYAWohBiMAQUBqIgIkAAJAIAVBCGpBACAFGyIFBEAgBkGTgICAeDYCACAGIAU2AgQMAQsgAkEBNgIkIAJBzNj+ADYCICACQgE3AiwgAkHuBjYCPCACIAk2AjggAiACQThqNgIoIAJBEGogAkEgahCZDiACQYSAgIB4NgIMIAYgAikCDDcCACAGQQhqIAJBFGopAgA3AgAgBkEQaiACQRxqKAIANgIACyACQUBrJAAgBCgC3AEhBSAEKALYASICQZOAgIB4Rg0BIAAgBCkC4AE3AgggAEEQaiAEQegBaigCADYCACAAIAU2AgQgACACNgIACyAEQfgAaiECQQAhAANAIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQ+x4LIABBAXFBASEAIAMhAkUNAAsMCAsgBSgCACIGIAYoAgAiAkEBajYCACACQQBIDQUgBEH4AGohAiAFKAIEIQkjAEHwAmsiBSQAIAUgBzYCBAJAAkAgBy0AAEEiRgRAIAgpAAghDSACKAIAIgcgBygCACIKQQFqNgIAIApBAEgNASAFIAc2AtABIAUgAikCBDcC1AECQCANQgBXBEAgByAHKAIAIgdBAWs2AgAgBUEANgIIIAdBAUcNASAFQdABahD7HgwBCyAFQRBqIAVB2AFqKAIANgIAIAUgBSkC0AE3AwgLIAVB8AFqIAUoAgQQxgYgBUEAOwGoAiAFQQA2AqQCIAVBADYCjAIgBUEANgKAAiAFQgQ3AugBIAVCADcC4AEgBUKAgICAwAA3AtgBIAVBADYC0AEgBSAIKQAAPgL8ASACKAIMIgcgBygCACIIQQFqNgIAIAhBAEgNASAFIAc2AqwCIAUgAikCEDcCsAIgBUH0AGoiCiAFQdABaiIHIAVBrAJqIggQ+iMgCCAGIAkQ0yMgByAKIAgQ7yUgBUEYaiIGIAcgBUEIahCuFiAFIA0+AhwgBUEBNgIYIAAgASAGEMsQIAVB8AJqJAAMAgsgBUEBNgLUASAFQfjc/gA2AtABIAVCATcC3AEgBUGvAzYCeCAFIAVB9ABqNgLYASAFIAVBBGo2AnQgBUHQAWpBgN3+ABDvLAsAC0EAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACADIQJFDQALDAcLIARB2AFqIAEgAhDxFSAEKALcASEGIAQoAtgBIgVBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgBjYCBCAAIAU2AgAMBwsgBEH4AGogARCIFiAEQegEaiIFIARBhAFqIggoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IglBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAk2AgAgAEEMaiAFKAIANgIADAcLIARB2ARqIAUoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIFIAgoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IghBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAg2AgAgAEEMaiAFKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNByAEQdAEahD7HgwHCyAEQeQBaiIFIAQpA7gCNwIAIAVBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgBEH4AGogASACKAIsQQhqIAMQjgEgBCgCgAEhAyAEKAJ8IQggBCgCeCICQZOAgIB4RwRAIAAgBCkChAE3AgwgACADNgIIIAAgCDYCBCAAIAI2AgAgBEHYAWohAkEAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACAFIQJFDQALDAcLIAAgASAGIAcgBEHYAWoiAkECIAggAxCvCkEAIQADQCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAAQQFxQQEhACAFIQJFDQALDAYLIARB2AFqIAEgAhDxFSAEKALcASEGIAQoAtgBIgVBk4CAgHhHBEAgACAEKQLgATcCCCAAQRBqIARB6AFqKAIANgIAIAAgBjYCBCAAIAU2AgAMBgsgBEHYAWogASACKAIsQQhqIAMQjgEgBCgC4AEhCCAEKALcASEFIAQoAtgBIglBk4CAgHhHBEAgACAEKQLkATcCDCAAIAg2AgggACAFNgIEIAAgCTYCAAwGCyAEIAg2AuQEIAQgBTYC4AQgBEHYAWogASACKAIwQQhqIAMQjgEgBCgC4AEhAiAEKALcASEDIAQoAtgBIglBk4CAgHhGDQEgACAEKQLkATcCDCAAIAI2AgggACADNgIEIAAgCTYCACAFIAUoAgAiAEEBazYCACAAQQFHDQUgBEHgBGoQuyMMBQsgBEH4AGogARCIFiAEQegEaiIDIARBhAFqIgUoAgA2AgAgBCAEKQJ8NwPgBCAEKAJ4IgZBk4CAgHhHBEAgBCgCiAEhASAAIAQpA+AENwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADAULIARB2ARqIAMoAgA2AgAgBCAEKQPgBDcD0AQgBEH4AGogARCIFiAEQcACaiIDIAUoAgA2AgAgBCAEKQJ8NwO4AiAEKAJ4IgVBk4CAgHhHBEAgBCgCiAEhASAAIAQpA7gCNwIEIAAgATYCECAAIAU2AgAgAEEMaiADKAIANgIAIAQoAtAEIgAgACgCACIAQQFrNgIAIABBAUcNBSAEQdAEahD7HgwFCyAEQeQBaiIDIAQpA7gCNwIAIANBCGogBEHAAmooAgA2AgAgBEHgAWogBEHoBGooAgA2AgAgBCAEKQPgBDcD2AEgACABIAIgByAEQdgBaiICQQIQ6wZBACEAA0AgAigCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAhD7HgsgAEEBcUEBIQAgAyECRQ0ACwwECyAGKQAAIQ0gBEH4AWogBxDGBiAEQgA3AqwCIARBADYClAIgBEEANgKIAiAEIA0+AoQCIARCBDcC8AEgBEIANwLoASAEQoCAgIDAADcC4AEgBEEANgLYASAEQbgCaiIHIAUgCBDTIyAEQfgAaiIIIARB2AFqIgUgBxDvJSAFIAMgAhDTIyAEQRxqIgIgCCAFEO8lIARBATYCHCAEIAYpAAg+AiAgACABIAIQyxAMAwsgAkEsaiIHKAIEIQYjAEEQayIFJAAgBUEEaiAGQQBBBEEIEKAYIAUoAgghBiAFKAIEQQFGBEAgBiAFKAIMQfzW/gAQ/S8ACyAFKAIMIQkgBEGgA2oiCEEANgIIIAggCTYCBCAIIAY2AgAgBUEQaiQAIARBCGogBxCwLgJAIAQoAggiBSAEKAIMIgpGDQADQAJAIARB2AFqIAEgBUEEaigCAEEIaiADEI4BIAQoAuABIQYgBCgC3AEhCCAEKALYASIJQZOAgIB4Rw0AIAQoAqgDIgkgBCgCoANGBEAgBEGgA2pB5Nf+ABCbKAsgBCgCpAMgCUEDdGoiCyAGNgIEIAsgCDYCACAEIAlBAWo2AqgDIAogBUEIaiIFRw0BDAILCyAAIAQpAuQBNwIMIAAgBjYCCCAAIAg2AgQgACAJNgIAIARBoANqIgAQwycgABDqOyAEKAKIAyIARQ0CIAAgACgCACIAQQFrNgIAIABBAUcNAiAEQYgDahD7HgwCCwJAAkAgAS0AREUEQCAHKAIAIgEgASgCACIDQQFqNgIAIANBAEgNAyACKAIwIQIgBEHYBGogBEGEA2ooAgA2AgAgBCAEKQL8AjcD0AQgBEHoBGogBEGQA2ooAgA2AgAgBCAEKQOIAzcD4AQgBEHAAmogBEGoA2ooAgA2AgAgBCAEKQKgAzcDuAIgBEHYAWogASACIARB0ARqIARB4ARqIARBuAJqEJEEIARBgAFqIgEgBEHkAWopAgA3AwAgBEGIAWoiAiAEQewBaigCADYCACAEIAQpAtwBNwN4IAQoAtgBIgNBgICAgHhGDQIgBEHYA2ogBEGAAmopAgA3AgAgBEHQA2ogBEH4AWopAgA3AgAgBEG8A2ogASkDADcCACAEQcQDaiACKAIANgIAIAQgBCkC8AE3AsgDIAQgBCkDeDcCtAMgBCADNgKwAwwBCyAHKAIAIgEgASgCACIDQQFqNgIAIANBAEgNAiACKAIwIQIgBEHgAWogBEGoA2ooAgA2AgAgBCAEKQKgAzcD2AEgBEGwA2ogASACIARB/AJqIARBiANqIARB2AFqEI4QCyAEQbADahDcKSEBIABBjNf+ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyAAIAQpA3g3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAwCCwALIAQoAvwCIgAgACgCACIAQQFrNgIAIABBAUcNACAEQfwCahD7HgsgBEHwBGokAAv6SgIMfwJ+IwBBgAprIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A0AJBDUYEQCACQfACaiABQdACaiIJEMIGIAJB+AFqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAEpAogCIQ4gAUKAgICAwAA3A4gCIAIgDjcD8AEgAkGIAWohDCACQfABaiINIQMjAEHQAGsiBCQAAkACQAJAAkACfwJAAkACQAJAIAktAABBDUYEQCAJLQABQQFrDgMCAwQBCyAEQQA2AkggBEEBNgI8IARBmJvPADYCOCAEQgQ3AkAgBEE4akGgm88AEO8sAAtBwAAhByADKAIIIghBA3QiBUHA////B3FBQGsgBSAIQQdxGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgdFDQYLIARCADcCLCAEIAc2AiggBCAGNgIkIARBwAA2AiAgAygCBCEFIAMoAgAhCiAIBEAgBSAIQQxsaiELQQAhBiAFIQMDQCADQQhqNAIAQoCjBX4gAykCAEKAlOvcA398IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgKSQxZEGfTcAACAEIAQoAixBCGoiBjYCLCAEIAQoAjBBAWo2AjAgA0EMaiIDIAtHDQALCyAEIAU2AjwgBCAKNgI4IARBOGoiA0EEQQwQ4B4gAxCXKSAEQShqIgUoAgAhCCAEKAIsIQYgBSAEQUBrIgcpAgA3AwAgBCkDICEPIAQgBCkCODcDICAEQQA2AjAgBCAPNwJEIARBADYCQCAEIAY2AjwgBCAINgI4IAQgAxDXOyAEKAIADAMLQcAAIQcgAygCCCIIQQN0IgVBwP///wdxQUBrIAUgCEEHcRsiBkHAABDRNEUNAyAGBEAgBkHAABCtNiIHRQ0FCyAEQgA3AiwgBCAHNgIoIAQgBjYCJCAEQcAANgIgIAMoAgQhBSADKAIAIQogCARAIAUgCEEMbGohC0EAIQYgBSEDA0AgA0EIajQCAEKAuJkpfiADKQIAQsCEPX98IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgKCZh4T5L303AAAgBCAEKAIsQQhqIgY2AiwgBCAEKAIwQQFqNgIwIANBDGoiAyALRw0ACwsgBCAFNgI8IAQgCjYCOCAEQThqIgNBBEEMEOAeIAMQlykgBEEoaiIFKAIAIQggBCgCLCEGIAUgBEFAayIHKQIANwMAIAQpAyAhDyAEIAQpAjg3AyAgBEEANgIwIAQgDzcCRCAEQQA2AkAgBCAGNgI8IAQgCDYCOCAEQQhqIAMQ1zsgBCgCCAwCC0HAACEHIAMoAggiCEEDdCIFQcD///8HcUFAayAFIAhBB3EbIgZBwAAQ0TRFDQIgBgRAIAZBwAAQrTYiB0UNBAsgBEIANwIsIAQgBzYCKCAEIAY2AiQgBEHAADYCICADKAIEIQUgAygCACEKIAgEQCAFIAhBDGxqIQtBACEGIAUhAwNAIANBCGo0AgBCgMDd7sECfiADKQIAQugHf3whDyAGQQhqIgggBCgCJCIHSwRAIARBIGogB0EBdCIGIAgQxCoiByAGIAdLGxDoGSAEKAIsIgZBCGohCCAEKAIkIQcLIAcgCEkEfyAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLAUgBgsgBCgCKGogD0KAgKKd2MfJ9gJ9NwAAIAQgBCgCLEEIaiIGNgIsIAQgBCgCMEEBajYCMCADQQxqIgMgC0cNAAsLIAQgBTYCPCAEIAo2AjggBEE4aiIDQQRBDBDgHiADEJcpIARBKGoiBSgCACEIIAQoAiwhBiAFIARBQGsiBykCADcDACAEKQMgIQ8gBCAEKQI4NwMgIARBADYCMCAEIA83AkQgBEEANgJAIAQgBjYCPCAEIAg2AjggBEEQaiADENc7IAQoAhAMAQtBwAAhByADKAIIIghBA3QiBUHA////B3FBQGsgBSAIQQdxGyIGQcAAENE0RQ0BIAYEQCAGQcAAEK02IgdFDQMLIARCADcCLCAEIAc2AiggBCAGNgIkIARBwAA2AiAgAygCBCEFIAMoAgAhCiAIBEAgBSAIQQxsaiELQQAhBiAFIQMDQCADKQIAIANBCGo0AgBCgIC8isnSE358IQ8gBkEIaiIIIAQoAiQiB0sEQCAEQSBqIAdBAXQiBiAIEMQqIgcgBiAHSxsQ6BkgBCgCLCIGQQhqIQggBCgCJCEHCyAHIAhJBH8gBEEgaiAHQQF0IgYgCBDEKiIHIAYgB0sbEOgZIAQoAiwFIAYLIAQoAihqIA9CgIDQ0aSJ2K7uAH03AAAgBCAEKAIsQQhqIgY2AiwgBCAEKAIwQQFqNgIwIANBDGoiAyALRw0ACwsgBCAFNgI8IAQgCjYCOCAEQThqIgNBBEEMEOAeIAMQlykgBEEoaiIFKAIAIQggBCgCLCEGIAUgBEFAayIHKQIANwMAIAQpAyAhDyAEIAQpAjg3AyAgBEEANgIwIAQgDzcCRCAEQQA2AkAgBCAGNgI8IAQgCDYCOCAEQRhqIAMQ1zsgBCgCGAshBUEcQQQQrTYiA0UNAiADQoGAgIAQNwIAIAMgBCkCODcCCCAMIAY2AgggDCAFNgIEIAwgAzYCACADQRBqIAcpAgA3AgAgA0EYaiAEQcgAaigCADYCACAEQSBqEM8vIARB0ABqJAAMAwtBjJfPAEEpIARBOGpBiJjPAEG4l88AENUeAAtBwAAgBhCjPQALQQRBHBCjPQALIAJBADsBqAMgAkEANgKkAyACQQA2AowDIAJBADYCgAMgAkIENwLoAiACQgA3AuACIAJCgICAgMAANwLYAiACQQA2AtACIAIgASgCpAI2AvwCIA0gAkHQAmoiAyAMEPojIAMgARDWGCACQZQBaiIFIA0gAxCuFiACQawDaiAFEM0cIAICfwJAAkACQAJAIAEtANACQQ1GBEAgAS0A0QJBAWsOAwIDBAELIAJBADYC4AIgAkEBNgLUAiACQZzZzQA2AtACIAJCBDcC2AIgAkHQAmpBnOHNABDvLAALIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxC/E0E4QQQQrTYiA0UNGyADQoGAgIAQNwIAIANBCGogBUEw/AoAAEG83s0ADAMLIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxDGE0E4QQQQrTYiA0UNGiADQoGAgIAQNwIAIANBCGogBUEw/AoAAEGU380ADAILIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxCoE0E4QQQQrTYiA0UNGSADQoGAgIAQNwIAIANBCGogBUEw/AoAAEHs380ADAELIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB8AFqIgUgAxC0E0E4QQQQrTYiA0UNGCADQoGAgIAQNwIAIANBCGogBUEw/AoAAEHE4M0ACyIFNgL0AyACIAM2AvADAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAJLQAAIgRBAmsOBgECMjIDBAALAkACQAJAAkAgBEEiaw4FATUaAgMACyAEQQ9GDQcMNAsgASgC2AIiBC0AAEEjaw4ECgcICRcLIAMgBSgCCEEBa0F4cWpBCGoiAyAFKAIcIgQRBAAtAABBBGsOAhkaGAsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBBEEAC0AAEEEaw4CHB0bCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0wIAJBCGogAyAFKAIQEQAAIAJB0AJqIAIoAggiAyACKAIMKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkGoBGoiBSADEJYgQThBBBCtNiIDRQ01IANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQfjizQAhBQwxCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0vIAJBEGogAyAFKAIQEQAAIAJB0AJqIAIoAhAiAyACKAIUKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkGIBWoiBSADEKIgQThBBBCtNiIDRQ00IANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQeDjzQAhBQwwCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0uIAJBGGogAyAFKAIQEQAAIAJB0AJqIAIoAhgiAyACKAIcKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkH4A2oiBSADEJwgQThBBBCtNiIDRQ0zIANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQcjkzQAhBQwvCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHBEEAEHc4s0AELgIRQ0tIAJBIGogAyAFKAIQEQAAIAJB0AJqIAIoAiAiAyACKAIkKAIMEQAAIANFDR8gAikD0AJCpK/0+qipnZAthSACKQPYAkLjrPqF49vQ9WyFhFBFDR8gAkHYBGoiBSADEJUgQThBBBCtNiIDRQ0yIANCgYCAgBA3AgAgA0EIaiAFQTD8CgAAQbDlzQAhBQwuCyADIAUoAghBAWtBeHFqQQhqIAUoAhwRBABB3OLNABC4CEUNLCACQdACaiACQfADakG0yM0AQYjmzQAQ6SMgAigC2AIhAyACKALUAiEFIAIoAtACIgRBk4CAgHhHBEAgAiACKQLcAjcCxAUgAiADNgLABSACIAU2ArwFIAIgBDYCuAUgACACQbgFahCmJQwvCyACIAM2AvQBIAIgBTYC8AEgAkHQAmogAkHwAWoiBEG0yM0AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgZBk4CAgHhHBEAgAiACKQLcAjcC2AUgAiAFNgLUBSACIAM2AtAFIAIgBjYCzAUgACACQcwFahCmJSACKALwASIAIAAoAgAiAEEBazYCACAAQQFHDS8gBBC7IwwvCyACKALwASIEIAQoAgAiBEEBazYCACAEQQFHDS0gAkHwAWoQuyMMLQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBhEEAC0AAEEEaw4CBAUDCyADIAUoAghBAWtBeHFqQQhqIgMgBSgCHCIGEQQALQAAQQRrDgIHCAYLIAMgBSgCCEEBa0F4cWpBCGoiAyAFKAIcIgYRBAAtAABBBGsOAgoLCQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBhEEAC0AAEEERg0nIAMgBhEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMKgsgAyAGEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwpCyACQTBqIAMgBSgCEBEAACACQYAJaiACKAIwIgMgAigCNCgCDBEAACADRQ0ZIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0ZIAJB0AJqIAMQmSAMAQsgAkE4aiADIAUoAhARAAAgAkGACWogAigCOCIDIAIoAjwoAgwRAAAgA0UNGSACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0ZIAJB0AJqIAMQoSALIAJB8AFqIAJB0AJqIAQtAAEgBC0AAhCiEyACLQDwASIDQSlGBEAgAkH7CGogAkGEAmooAgAiATYAACACQfMIaiACQfwBaikCACIONwAAIAJB6AdqIA43AwAgAkHwB2ogATYCACACIAIpAvQBIg43AOsIIAIgDjcD4AcgACACQeAHahCmJQwnCyACQfcIaiIFIAJBgAJqKQAANwAAIAJB8AhqIgQgAkH5AWopAAA3AwAgAkHQCGogAkGQAmopAgA3AgAgAkHYCGogAkGYAmopAgA3AgAgAkG5CGogBCkDADcAACACQcAIaiAFKQAANwAAIAIgAikA8QEiDjcD6AggAiACKQKIAjcCyAggAiAONwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgRB1N3NACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AoAIIAIgBTYC/AcgAiADNgL4ByACIAY2AvQHIAAgAkH0B2oQpiUgBBDaJAwnCyACQbAIahDaJAwlCyADIAYRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCULIAJBQGsgAyAFKAIQEQAAIAJBgAlqIAIoAkAiAyACKAJEKAIMEQAAIANFDRcgAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDRcgAkHQAmogAxCjIAwBCyACQcgAaiADIAUoAhARAAAgAkGACWogAigCSCIDIAIoAkwoAgwRAAAgA0UNFyACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0XIAJB0AJqIAMQmiALIAJB8AFqIAJB0AJqIAQtAAEgBC0AAhChEyACLQDwASIDQSlGBEAgAkH7CGogAkGEAmooAgAiATYAACACQfMIaiACQfwBaikCACIONwAAIAJBkAhqIA43AwAgAkGYCGogATYCACACIAIpAvQBIg43AOsIIAIgDjcDiAggACACQYgIahCmJQwjCyACQfcIaiIFIAJBgAJqKQAANwAAIAJB8AhqIgQgAkH5AWopAAA3AwAgAkHQCGogAkGQAmopAgA3AgAgAkHYCGogAkGYAmopAgA3AgAgAkG5CGogBCkDADcAACACQcAIaiAFKQAANwAAIAIgAikA8QEiDjcD6AggAiACKQKIAjcCyAggAiAONwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgRBnOfNACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AqgIIAIgBTYCpAggAiADNgKgCCACIAY2ApwIIAAgAkGcCGoQpiUgBBDaJAwjCyACQbAIahDaJAwhCyADIAYRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCELIAJB0ABqIAMgBSgCEBEAACACQYAJaiACKAJQIgMgAigCVCgCDBEAACADRQ0VIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0VIAJB0AJqIAMQniAMAQsgAkHYAGogAyAFKAIQEQAAIAJBgAlqIAIoAlgiAyACKAJcKAIMEQAAIANFDRUgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFSACQdACaiADEKcgCyACQfABaiACQdACaiAELQABIAQtAAIQoxMgAi0A8AEiA0EpRgRAIAJB+whqIAJBhAJqKAIAIgE2AAAgAkHzCGogAkH8AWopAgAiDjcAACACQbgJaiAONwMAIAJBwAlqIAE2AgAgAiACKQL0ASIONwDrCCACIA43A7AJIAAgAkGwCWoQpiUMHwsgAkH3CGoiBSACQYACaikAADcAACACQfAIaiIEIAJB+QFqKQAANwMAIAJB0AhqIAJBkAJqKQIANwIAIAJB2AhqIAJBmAJqKQIANwIAIAJBuQhqIAQpAwA3AAAgAkHACGogBSkAADcAACACIAIpAPEBIg43A+gIIAIgAikCiAI3AsgIIAIgDjcAsQggAiADOgCwCCACQdACaiACQbAIaiIEQZTozQAgCRDpIyACKALYAiEFIAIoAtQCIQMgAigC0AIiBkGTgICAeEcEQCACIAIpAtwCNwLQCSACIAU2AswJIAIgAzYCyAkgAiAGNgLECSAAIAJBxAlqEKYlIAQQ2iQMHwsgAkGwCGoQ2iQMHQsgAkHQAmogAkHwA2pBtMjNACAJEOkjIAIoAtgCIQUgAigC1AIhAyACKALQAiIEQZOAgIB4Rg0cIAIgAikC3AI3AuQJIAIgBTYC4AkgAiADNgLcCSACIAQ2AtgJIAAgAkHYCWoQpiUMHQsgAyAFKAIIQQFrQXhxakEIaiIDIAUoAhwiBBEEAEHc4s0AELgIRQ0aIAMgBBEEAC0AAEEERw0UIAJB4ABqIAMgBSgCEBEAACACQbAIaiACKAJgIgMgAigCZCgCDBEAACADRQ0TIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0TIAJB0AJqIgUgAxCZICACQfABaiAFIAEtANECIAEtANICEKITIAItAPABIgNBKUYEQCACQZMJaiACQYQCaigCACIBNgAAIAJBiwlqIAJB/AFqKQIAIg43AAAgAkHoBWogDjcDACACQfAFaiABNgIAIAIgAikC9AEiDjcAgwkgAiAONwPgBSAAIAJB4AVqEKYlDB0LIAJBjwlqIgUgAkGAAmopAAA3AAAgAkGICWoiBCACQfkBaikAADcDACACQZgGaiACQZACaikCADcCACACQaAGaiACQZgCaikCADcCACACQYEGaiAEKQMANwAAIAJBiAZqIAUpAAA3AAAgAiACKQKIAjcCkAYgAiADOgD4BSACIAIpAPEBNwD5BUHU3c0AIQUgAkH4BWoQ3CkhAwwbCyADIAQRBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADBsLIAJB6ABqIAMgBSgCEBEAACACQbAIaiACKAJoIgMgAigCbCgCDBEAACADRQ0TIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0TIAJB0AJqIAMQoyAMAQsgAkHwAGogAyAFKAIQEQAAIAJBsAhqIAIoAnAiAyACKAJ0KAIMEQAAIANFDRMgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNEyACQdACaiADEJogCyACQfABaiACQdACaiABLQDRAiABLQDSAhChEyACLQDwASIFQSlGBEAgAkGTCWogAkGEAmooAgAiATYAACACQYsJaiACQfwBaikCACIONwAAIAJBsAZqIA43AwAgAkG4BmogATYCACACIAIpAvQBIg43AIMJIAIgDjcDqAYgACACQagGahCmJQwZCyACQY8JaiIDIAJBgAJqKQAANwAAIAJBiAlqIgQgAkH5AWopAAA3AwAgAkHIBmoiBiACQZACaikCADcDACACQdAGaiIHIAJBmAJqKQIANwMAIAJB4AZqIgggBCkDADcDACACQecGaiIEIAMpAAA3AAAgAiACKQKIAjcDwAYgAiACKQDxATcD2AZBOEEEEK02IgNFDRsgAyAFOgAIIANCgYCAgBA3AgAgAyACKQPYBjcACSADIAIpA8AGNwIgIANBEWogCCkDADcAACADQRhqIAQpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGc580AIQUMFwsgAyAEEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwXCyACQfgAaiADIAUoAhARAAAgAkGwCGogAigCeCIDIAIoAnwoAgwRAAAgA0UNESACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNESACQdACaiADEKQgDAELIAJBgAFqIAMgBSgCEBEAACACQbAIaiACKAKAASIDIAIoAoQBKAIMEQAAIANFDREgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNESACQdACaiADEJsgCyACQfABaiACQdACaiABLQDRAiABLQDSAhCjEyACLQDwASIFQSlGBEAgAkGTCWogAkGEAmooAgAiATYAACACQYsJaiACQfwBaikCACIONwAAIAJB+AZqIA43AwAgAkGAB2ogATYCACACIAIpAvQBIg43AIMJIAIgDjcD8AYgACACQfAGahCmJQwVCyACQY8JaiIDIAJBgAJqKQAANwAAIAJBiAlqIgQgAkH5AWopAAA3AwAgAkGQB2oiBiACQZACaikCADcDACACQZgHaiIHIAJBmAJqKQIANwMAIAJBqAdqIgggBCkDADcDACACQa8HaiIEIAMpAAA3AAAgAiACKQKIAjcDiAcgAiACKQDxATcDoAdBOEEEEK02IgNFDRcgAyAFOgAIIANCgYCAgBA3AgAgAyACKQOgBzcACSADIAIpA4gHNwIgIANBEWogCCkDADcAACADQRhqIAQpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGU6M0AIQUMEwsgAkEANgLgAiACQQE2AtQCIAJBnNnNADYC0AIgAkIENwLYAiACQdACakGk2c0AEO8sAAtB6OLNABCyOwALQdDjzQAQsjsAC0G45M0AELI7AAtBoOXNABCyOwALQdzmzQAQsjsAC0Hs5s0AELI7AAtB/ObNABCyOwALQYznzQAQsjsAC0H0580AELI7AAtBhOjNABCyOwALQezozQAQsjsACyADIAQRBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADAcLQZjpzQAQsjsAC0Go6c0AELI7AAtBuOnNABCyOwALQcjpzQAQsjsACyACQShqIAMgBSgCEBEAACACQYAJaiACKAIoIgMgAigCLCgCDBEAAAJAIANFDQAgAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDQAgAkHQAmoiBSADEJQgIAJB8AFqIAUgBC0AASAELQACEKATIAItAPABIgNBKUYEQCACQfsIaiACQYQCaigCACIBNgAAIAJB8whqIAJB/AFqKQIAIg43AAAgAkHAB2ogDjcDACACQcgHaiABNgIAIAIgAikC9AEiDjcA6wggAiAONwO4ByAAIAJBuAdqEKYlDAQLIAJB9whqIgUgAkGAAmopAAA3AAAgAkHwCGoiBCACQfkBaikAADcDACACQdAIaiACQZACaikCADcCACACQdgIaiACQZgCaikCADcCACACQbkIaiAEKQMANwAAIAJBwAhqIAUpAAA3AAAgAiACKQDxASIONwPoCCACIAIpAogCNwLICCACIA43ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBEG8280AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgZBk4CAgHhHBEAgAiACKQLcAjcC2AcgAiAFNgLUByACIAM2AtAHIAIgBjYCzAcgACACQcwHahCmJSAEENokDAQLIAJBsAhqENokDAILQZTmzQAQsjsACyACQdACaiACQfADakG0yM0AIAkQ6SMgAigC2AIhBSACKALUAiEDIAIoAtACIgRBk4CAgHhGDQAgAiACKQLcAjcC+AkgAiAFNgL0CSACIAM2AvAJIAIgBDYC7AkgACACQewJahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIQ4gAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgDjcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIQ4gAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAONwPIAiABIAQ2AsQCIAFCADcCpAIgACAFNgIIIAAgAzYCBCAAQQg2AgAgAigC8AMiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAvADIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkHwA2oQuyMLIAJBgApqJAAPC0EEQTgQoz0AC9o5Agd/AX4jAEGACmsiAiQAIAFB0AJqIQUCQAJAIAEtANACIgNBCUcEQCADQSRGDQEgAkEFOgCAAQwCCyACQQk6AIABDAELIAJBgAFqIAUQwgYLIAEpAogCIQkgAUKAgICAgAE3A4gCIAJB2AJqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAIgCTcD0AIgAkGMAWoiBCACQdACaiIDIAUQ3hggAkH4AmogAkGIAWooAgA2AgAgAiACKQKAATcC8AIgAkEAOwGoAyACQQA2AqQDIAJBADYCjAMgAkEANgKAAyACQgQ3AugCIAJCADcC4AIgAkKAgICAwAA3AtgCIAJBADYC0AIgAiABKAKkAjYC/AIgAkH0AWoiBiADIAQQ+iMgAyABENYYIAJBmAFqIgQgBiADEK4WIAJBrANqIAQQzRwCQCACAn8CQAJAAkACQAJAIAItAMQDIgNBBWsOBQIBAQEDAAsgA0EkRg0DC0HMwc0AQShBrN7NABCfKQALIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxCxE0E4QQQQrTYiA0UNAyADQoGAgIAQNwIAIANBCGogBEEw/AoAAEGk3M0ADAILIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxCuE0E4QQQQrTYiA0UNAiADQoGAgIAQNwIAIANBCGogBEEw/AoAAEH83M0ADAELIAJB0AJqIgMgAkGsA2pBxAD8CgAAIAJB9AFqIgQgAxC3E0E4QQQQrTYiA0UNASADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHU3c0ACyIENgL0AyACIAM2AvADAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUtAAAiBkECaw4GAQIxMQMEAAsCQAJAAkACQCAGQSJrDgUBNBoCAwALIAZBD0YNBwwzCyABKALYAiIGLQAAQSNrDgQKBwgJFwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBREEAC0AAEEEaw4CGRoYCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIFEQQALQAAQQRrDgIcHRsLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS8gAiADIAQoAhARAAAgAkHQAmogAigCACIDIAIoAgQoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQagEaiIEIAMQliBBOEEEEK02IgNFDTQgA0KBgICAEDcCACADQQhqIARBMPwKAABB+OLNACEEDDALIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS4gAkEIaiADIAQoAhARAAAgAkHQAmogAigCCCIDIAIoAgwoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQYgFaiIEIAMQoiBBOEEEEK02IgNFDTMgA0KBgICAEDcCACADQQhqIARBMPwKAABB4OPNACEEDC8LIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDS0gAkEQaiADIAQoAhARAAAgAkHQAmogAigCECIDIAIoAhQoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQfgDaiIEIAMQnCBBOEEEEK02IgNFDTIgA0KBgICAEDcCACADQQhqIARBMPwKAABByOTNACEEDC4LIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcEQQAQdzizQAQuAhFDSwgAkEYaiADIAQoAhARAAAgAkHQAmogAigCGCIDIAIoAhwoAgwRAAAgA0UNHiACKQPQAkKkr/T6qKmdkC2FIAIpA9gCQuOs+oXj29D1bIWEUEUNHiACQdgEaiIEIAMQlSBBOEEEEK02IgNFDTEgA0KBgICAEDcCACADQQhqIARBMPwKAABBsOXNACEEDC0LIAMgBCgCCEEBa0F4cWpBCGogBCgCHBEEAEHc4s0AELgIRQ0rIAJB0AJqIAJB8ANqQbTIzQBBiObNABDpIyACKALYAiEDIAIoAtQCIQQgAigC0AIiBkGTgICAeEcEQCACIAIpAtwCNwLEBSACIAM2AsAFIAIgBDYCvAUgAiAGNgK4BSAAIAJBuAVqEKYlDC4LIAIgAzYC+AEgAiAENgL0ASACQdACaiACQfQBaiIGQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLYBSACIAQ2AtQFIAIgAzYC0AUgAiAFNgLMBSAAIAJBzAVqEKYlIAIoAvQBIgAgACgCACIAQQFrNgIAIABBAUcNLiAGELsjDC4LIAIoAvQBIgUgBSgCACIFQQFrNgIAIAVBAUcNLCACQfQBahC7IwwsCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRrDgIEBQMLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBGsOAgcIBgsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBxEEAC0AAEEEaw4CCgsJCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRGDSYgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwpCyADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCgLIAJBKGogAyAEKAIQEQAAIAJBgAlqIAIoAigiAyACKAIsKAIMEQAAIANFDRggAikDgAlCpK/0+qipnZAthSACKQOICULjrPqF49vQ9WyFhFBFDRggAkHQAmogAxCZIAwBCyACQTBqIAMgBCgCEBEAACACQYAJaiACKAIwIgMgAigCNCgCDBEAACADRQ0YIAIpA4AJQo2j65PMtMaQ9wCFIAIpA4gJQtmr7PbZ4MX0jH+FhFBFDRggAkHQAmogAxChIAsgAkH0AWogAkHQAmogBi0AASAGLQACEKITIAItAPQBIgNBKUYEQCACQfsIaiACQYgCaigCACIBNgAAIAJB8whqIAJBgAJqKQIAIgk3AAAgAkHoB2ogCTcDACACQfAHaiABNgIAIAIgAikC+AEiCTcA6wggAiAJNwPgByAAIAJB4AdqEKYlDCYLIAJB9whqIgQgAkGEAmopAAA3AAAgAkHwCGoiBiACQf0BaikAADcDACACQdAIaiACQZQCaikCADcCACACQdgIaiACQZwCaikCADcCACACQbkIaiAGKQMANwAAIAJBwAhqIAQpAAA3AAAgAiACKQD1ASIJNwPoCCACIAIpAowCNwLICCACIAk3ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBkHU3c0AIAUQ6SMgAigC2AIhBCACKALUAiEDIAIoAtACIgVBk4CAgHhHBEAgAiACKQLcAjcCgAggAiAENgL8ByACIAM2AvgHIAIgBTYC9AcgACACQfQHahCmJSAGENokDCYLIAJBsAhqENokDCQLIAMgBxEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMJAsgAkE4aiADIAQoAhARAAAgAkGACWogAigCOCIDIAIoAjwoAgwRAAAgA0UNFiACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNFiACQdACaiADEKMgDAELIAJBQGsgAyAEKAIQEQAAIAJBgAlqIAIoAkAiAyACKAJEKAIMEQAAIANFDRYgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFiACQdACaiADEJogCyACQfQBaiACQdACaiAGLQABIAYtAAIQoRMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQZAIaiAJNwMAIAJBmAhqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A4gIIAAgAkGICGoQpiUMIgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQZznzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwKoCCACIAQ2AqQIIAIgAzYCoAggAiAFNgKcCCAAIAJBnAhqEKYlIAYQ2iQMIgsgAkGwCGoQ2iQMIAsgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwgCyACQcgAaiADIAQoAhARAAAgAkGACWogAigCSCIDIAIoAkwoAgwRAAAgA0UNFCACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNFCACQdACaiADEJ4gDAELIAJB0ABqIAMgBCgCEBEAACACQYAJaiACKAJQIgMgAigCVCgCDBEAACADRQ0UIAIpA4AJQo2j65PMtMaQ9wCFIAIpA4gJQtmr7PbZ4MX0jH+FhFBFDRQgAkHQAmogAxCnIAsgAkH0AWogAkHQAmogBi0AASAGLQACEKMTIAItAPQBIgNBKUYEQCACQfsIaiACQYgCaigCACIBNgAAIAJB8whqIAJBgAJqKQIAIgk3AAAgAkG4CWogCTcDACACQcAJaiABNgIAIAIgAikC+AEiCTcA6wggAiAJNwOwCSAAIAJBsAlqEKYlDB4LIAJB9whqIgQgAkGEAmopAAA3AAAgAkHwCGoiBiACQf0BaikAADcDACACQdAIaiACQZQCaikCADcCACACQdgIaiACQZwCaikCADcCACACQbkIaiAGKQMANwAAIAJBwAhqIAQpAAA3AAAgAiACKQD1ASIJNwPoCCACIAIpAowCNwLICCACIAk3ALEIIAIgAzoAsAggAkHQAmogAkGwCGoiBkGU6M0AIAUQ6SMgAigC2AIhBCACKALUAiEDIAIoAtACIgVBk4CAgHhHBEAgAiACKQLcAjcC0AkgAiAENgLMCSACIAM2AsgJIAIgBTYCxAkgACACQcQJahCmJSAGENokDB4LIAJBsAhqENokDBwLIAJB0AJqIAJB8ANqQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEYNGyACIAIpAtwCNwLkCSACIAQ2AuAJIAIgAzYC3AkgAiAFNgLYCSAAIAJB2AlqEKYlDBwLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgYRBABB3OLNABC4CEUNGSADIAYRBAAtAABBBEcNEyACQdgAaiADIAQoAhARAAAgAkGwCGogAigCWCIDIAIoAlwoAgwRAAAgA0UNEiACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNEiACQdACaiIEIAMQmSAgAkH0AWogBCABLQDRAiABLQDSAhCiEyACLQD0ASIDQSlGBEAgAkGTCWogAkGIAmooAgAiATYAACACQYsJaiACQYACaikCACIJNwAAIAJB6AVqIAk3AwAgAkHwBWogATYCACACIAIpAvgBIgk3AIMJIAIgCTcD4AUgACACQeAFahCmJQwcCyACQY8JaiIEIAJBhAJqKQAANwAAIAJBiAlqIgUgAkH9AWopAAA3AwAgAkGYBmogAkGUAmopAgA3AgAgAkGgBmogAkGcAmopAgA3AgAgAkGBBmogBSkDADcAACACQYgGaiAEKQAANwAAIAIgAikCjAI3ApAGIAIgAzoA+AUgAiACKQD1ATcA+QVB1N3NACEEIAJB+AVqENwpIQMMGgsgAyAFEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwaCyACQeAAaiADIAQoAhARAAAgAkGwCGogAigCYCIDIAIoAmQoAgwRAAAgA0UNEiACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNEiACQdACaiADEKMgDAELIAJB6ABqIAMgBCgCEBEAACACQbAIaiACKAJoIgMgAigCbCgCDBEAACADRQ0SIAIpA7AIQo2j65PMtMaQ9wCFIAIpA7gIQtmr7PbZ4MX0jH+FhFBFDRIgAkHQAmogAxCaIAsgAkH0AWogAkHQAmogAS0A0QIgAS0A0gIQoRMgAi0A9AEiBEEpRgRAIAJBkwlqIAJBiAJqKAIAIgE2AAAgAkGLCWogAkGAAmopAgAiCTcAACACQbAGaiAJNwMAIAJBuAZqIAE2AgAgAiACKQL4ASIJNwCDCSACIAk3A6gGIAAgAkGoBmoQpiUMGAsgAkGPCWoiAyACQYQCaikAADcAACACQYgJaiIFIAJB/QFqKQAANwMAIAJByAZqIgYgAkGUAmopAgA3AwAgAkHQBmoiByACQZwCaikCADcDACACQeAGaiIIIAUpAwA3AwAgAkHnBmoiBSADKQAANwAAIAIgAikCjAI3A8AGIAIgAikA9QE3A9gGQThBBBCtNiIDRQ0aIAMgBDoACCADQoGAgIAQNwIAIAMgAikD2AY3AAkgAyACKQPABjcCICADQRFqIAgpAwA3AAAgA0EYaiAFKQAANwAAIANBKGogBikDADcCACADQTBqIAcpAwA3AgBBnOfNACEEDBYLIAMgBREEACEBIAJBrwM2AuwIIAIgATYCpAkgAkECNgK0CCACQYjpzQA2ArAIIAJCATcCvAggAiACQaQJajYC6AggAiACQegIajYCuAggAEEEaiACQbAIahCZDiAAQQM2AgAMFgsgAkHwAGogAyAEKAIQEQAAIAJBsAhqIAIoAnAiAyACKAJ0KAIMEQAAIANFDRAgAikDsAhCpK/0+qipnZAthSACKQO4CELjrPqF49vQ9WyFhFBFDRAgAkHQAmogAxCkIAwBCyACQfgAaiADIAQoAhARAAAgAkGwCGogAigCeCIDIAIoAnwoAgwRAAAgA0UNECACKQOwCEKNo+uTzLTGkPcAhSACKQO4CELZq+z22eDF9Ix/hYRQRQ0QIAJB0AJqIAMQmyALIAJB9AFqIAJB0AJqIAEtANECIAEtANICEKMTIAItAPQBIgRBKUYEQCACQZMJaiACQYgCaigCACIBNgAAIAJBiwlqIAJBgAJqKQIAIgk3AAAgAkH4BmogCTcDACACQYAHaiABNgIAIAIgAikC+AEiCTcAgwkgAiAJNwPwBiAAIAJB8AZqEKYlDBQLIAJBjwlqIgMgAkGEAmopAAA3AAAgAkGICWoiBSACQf0BaikAADcDACACQZAHaiIGIAJBlAJqKQIANwMAIAJBmAdqIgcgAkGcAmopAgA3AwAgAkGoB2oiCCAFKQMANwMAIAJBrwdqIgUgAykAADcAACACIAIpAowCNwOIByACIAIpAPUBNwOgB0E4QQQQrTYiA0UNFiADIAQ6AAggA0KBgICAEDcCACADIAIpA6AHNwAJIAMgAikDiAc3AiAgA0ERaiAIKQMANwAAIANBGGogBSkAADcAACADQShqIAYpAwA3AgAgA0EwaiAHKQMANwIAQZTozQAhBAwSC0Ho4s0AELI7AAtB0OPNABCyOwALQbjkzQAQsjsAC0Gg5c0AELI7AAtB3ObNABCyOwALQezmzQAQsjsAC0H85s0AELI7AAtBjOfNABCyOwALQfTnzQAQsjsAC0GE6M0AELI7AAtB7OjNABCyOwALIAMgBhEEACEBIAJBrwM2AuwIIAIgATYCpAkgAkECNgK0CCACQYjpzQA2ArAIIAJCATcCvAggAiACQaQJajYC6AggAiACQegIajYCuAggAEEEaiACQbAIahCZDiAAQQM2AgAMBwtBmOnNABCyOwALQajpzQAQsjsAC0G46c0AELI7AAtByOnNABCyOwALIAJBIGogAyAEKAIQEQAAIAJBgAlqIAIoAiAiAyACKAIkKAIMEQAAAkAgA0UNACACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNACACQdACaiIEIAMQlCAgAkH0AWogBCAGLQABIAYtAAIQoBMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQcAHaiAJNwMAIAJByAdqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A7gHIAAgAkG4B2oQpiUMBAsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQbzbzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLYByACIAQ2AtQHIAIgAzYC0AcgAiAFNgLMByAAIAJBzAdqEKYlIAYQ2iQMBAsgAkGwCGoQ2iQMAgtBlObNABCyOwALIAJB0AJqIAJB8ANqQbTIzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEYNACACIAIpAtwCNwL4CSACIAQ2AvQJIAIgAzYC8AkgAiAFNgLsCSAAIAJB7AlqEKYlDAELAn9BgICAgHggASgC4AEiBUGBgICAeEYNABpBgICAgHggBUGAgICAeEYNABogASkC5AEhCSABQQA2AugBIAFCgICAgCA3A+ABIAULIQUgAUG4AmoQtDAgASAJNwK8AiABIAU2ArgCIAEoApQCIgVBgICAgHhHBEAgASkDmAIhCSABQQA2ApwCIAFCgICAgCA3ApQCCyABQcQCahC0MCABIAk3A8gCIAEgBTYCxAIgAUIANwKkAiAAIAQ2AgggACADNgIEIABBCDYCACACKALwAyIAIAAoAgAiAEEBazYCACAAQQFGDQEMAgsgAigC8AMiACAAKAIAIgBBAWs2AgAgAEEBRw0BCyACQfADahC7IwsgAkGACmokAA8LQQRBOBCjPQAL2jkCB38BfiMAQYAKayICJAAgAUHQAmohBQJAAkAgAS0A0AIiA0EIRwRAIANBI0YNASACQQQ6AIABDAILIAJBCDoAgAEMAQsgAkGAAWogBRDCBgsgASkCiAIhCSABQoCAgIDAADcDiAIgAkHYAmogAUGQAmoiAygCADYCACADQQA2AgAgAiAJNwPQAiACQYwBaiIEIAJB0AJqIgMgBRDdGCACQfgCaiACQYgBaigCADYCACACIAIpAoABNwLwAiACQQA7AagDIAJBADYCpAMgAkEANgKMAyACQQA2AoADIAJCBDcC6AIgAkIANwLgAiACQoCAgIDAADcC2AIgAkEANgLQAiACIAEoAqQCNgL8AiACQfQBaiIGIAMgBBD6IyADIAEQ1hggAkGYAWoiBCAGIAMQrhYgAkGsA2ogBBDNHAJAIAICfwJAAkACQAJAAkAgAi0AxAMiA0EEaw4FAgEBAQMACyADQSNGDQMLQczBzQBBKEGU3M0AEJ8pAAsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADEK0TQThBBBCtNiIDRQ0DIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQYzazQAMAgsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADELkTQThBBBCtNiIDRQ0CIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQeTazQAMAQsgAkHQAmoiAyACQawDakHEAPwKAAAgAkH0AWoiBCADEMMTQThBBBCtNiIDRQ0BIANCgYCAgBA3AgAgA0EIaiAEQTD8CgAAQbzbzQALIgQ2AvQDIAIgAzYC8AMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBS0AACIGQQJrDgYBAjExAwQACwJAAkACQAJAIAZBImsOBQE0GgIDAAsgBkEPRg0HDDMLIAEoAtgCIgYtAABBI2sOBAoHCAkXCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIFEQQALQAAQQRrDgIZGhgLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgURBAAtAABBBGsOAhwdGwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLyACIAMgBCgCEBEAACACQdACaiACKAIAIgMgAigCBCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJBqARqIgQgAxCWIEE4QQQQrTYiA0UNNCADQoGAgIAQNwIAIANBCGogBEEw/AoAAEH44s0AIQQMMAsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLiACQQhqIAMgBCgCEBEAACACQdACaiACKAIIIgMgAigCDCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJBiAVqIgQgAxCiIEE4QQQQrTYiA0UNMyADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHg480AIQQMLwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLSACQRBqIAMgBCgCEBEAACACQdACaiACKAIQIgMgAigCFCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJB+ANqIgQgAxCcIEE4QQQQrTYiA0UNMiADQoGAgIAQNwIAIANBCGogBEEw/AoAAEHI5M0AIQQMLgsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwRBABB3OLNABC4CEUNLCACQRhqIAMgBCgCEBEAACACQdACaiACKAIYIgMgAigCHCgCDBEAACADRQ0eIAIpA9ACQqSv9PqoqZ2QLYUgAikD2AJC46z6hePb0PVshYRQRQ0eIAJB2ARqIgQgAxCVIEE4QQQQrTYiA0UNMSADQoGAgIAQNwIAIANBCGogBEEw/AoAAEGw5c0AIQQMLQsgAyAEKAIIQQFrQXhxakEIaiAEKAIcEQQAQdzizQAQuAhFDSsgAkHQAmogAkHwA2pBtMjNAEGI5s0AEOkjIAIoAtgCIQMgAigC1AIhBCACKALQAiIGQZOAgIB4RwRAIAIgAikC3AI3AsQFIAIgAzYCwAUgAiAENgK8BSACIAY2ArgFIAAgAkG4BWoQpiUMLgsgAiADNgL4ASACIAQ2AvQBIAJB0AJqIAJB9AFqIgZBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AtgFIAIgBDYC1AUgAiADNgLQBSACIAU2AswFIAAgAkHMBWoQpiUgAigC9AEiACAAKAIAIgBBAWs2AgAgAEEBRw0uIAYQuyMMLgsgAigC9AEiBSAFKAIAIgVBAWs2AgAgBUEBRw0sIAJB9AFqELsjDCwLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBGsOAgQFAwsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBxEEAC0AAEEEaw4CBwgGCyADIAQoAghBAWtBeHFqQQhqIgMgBCgCHCIHEQQALQAAQQRrDgIKCwkLIAMgBCgCCEEBa0F4cWpBCGoiAyAEKAIcIgcRBAAtAABBBEYNJiADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCkLIAMgBxEEACEBIAJBrwM2AqgJIAIgATYCrAkgAkECNgKECSACQczmzQA2AoAJIAJCATcCjAkgAiACQawJajYCpAkgAiACQaQJajYCiAkgAEEEaiACQYAJahCiGCAAQQM2AgAMKAsgAkEoaiADIAQoAhARAAAgAkGACWogAigCKCIDIAIoAiwoAgwRAAAgA0UNGCACKQOACUKkr/T6qKmdkC2FIAIpA4gJQuOs+oXj29D1bIWEUEUNGCACQdACaiADEJkgDAELIAJBMGogAyAEKAIQEQAAIAJBgAlqIAIoAjAiAyACKAI0KAIMEQAAIANFDRggAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNGCACQdACaiADEKEgCyACQfQBaiACQdACaiAGLQABIAYtAAIQohMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQegHaiAJNwMAIAJB8AdqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A+AHIAAgAkHgB2oQpiUMJgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQdTdzQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwKACCACIAQ2AvwHIAIgAzYC+AcgAiAFNgL0ByAAIAJB9AdqEKYlIAYQ2iQMJgsgAkGwCGoQ2iQMJAsgAyAHEQQAIQEgAkGvAzYCqAkgAiABNgKsCSACQQI2AoQJIAJBzObNADYCgAkgAkIBNwKMCSACIAJBrAlqNgKkCSACIAJBpAlqNgKICSAAQQRqIAJBgAlqEKIYIABBAzYCAAwkCyACQThqIAMgBCgCEBEAACACQYAJaiACKAI4IgMgAigCPCgCDBEAACADRQ0WIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0WIAJB0AJqIAMQoyAMAQsgAkFAayADIAQoAhARAAAgAkGACWogAigCQCIDIAIoAkQoAgwRAAAgA0UNFiACKQOACUKNo+uTzLTGkPcAhSACKQOICULZq+z22eDF9Ix/hYRQRQ0WIAJB0AJqIAMQmiALIAJB9AFqIAJB0AJqIAYtAAEgBi0AAhChEyACLQD0ASIDQSlGBEAgAkH7CGogAkGIAmooAgAiATYAACACQfMIaiACQYACaikCACIJNwAAIAJBkAhqIAk3AwAgAkGYCGogATYCACACIAIpAvgBIgk3AOsIIAIgCTcDiAggACACQYgIahCmJQwiCyACQfcIaiIEIAJBhAJqKQAANwAAIAJB8AhqIgYgAkH9AWopAAA3AwAgAkHQCGogAkGUAmopAgA3AgAgAkHYCGogAkGcAmopAgA3AgAgAkG5CGogBikDADcAACACQcAIaiAEKQAANwAAIAIgAikA9QEiCTcD6AggAiACKQKMAjcCyAggAiAJNwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgZBnOfNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AqgIIAIgBDYCpAggAiADNgKgCCACIAU2ApwIIAAgAkGcCGoQpiUgBhDaJAwiCyACQbAIahDaJAwgCyADIAcRBAAhASACQa8DNgKoCSACIAE2AqwJIAJBAjYChAkgAkHM5s0ANgKACSACQgE3AowJIAIgAkGsCWo2AqQJIAIgAkGkCWo2AogJIABBBGogAkGACWoQohggAEEDNgIADCALIAJByABqIAMgBCgCEBEAACACQYAJaiACKAJIIgMgAigCTCgCDBEAACADRQ0UIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0UIAJB0AJqIAMQniAMAQsgAkHQAGogAyAEKAIQEQAAIAJBgAlqIAIoAlAiAyACKAJUKAIMEQAAIANFDRQgAikDgAlCjaPrk8y0xpD3AIUgAikDiAlC2avs9tngxfSMf4WEUEUNFCACQdACaiADEKcgCyACQfQBaiACQdACaiAGLQABIAYtAAIQoxMgAi0A9AEiA0EpRgRAIAJB+whqIAJBiAJqKAIAIgE2AAAgAkHzCGogAkGAAmopAgAiCTcAACACQbgJaiAJNwMAIAJBwAlqIAE2AgAgAiACKQL4ASIJNwDrCCACIAk3A7AJIAAgAkGwCWoQpiUMHgsgAkH3CGoiBCACQYQCaikAADcAACACQfAIaiIGIAJB/QFqKQAANwMAIAJB0AhqIAJBlAJqKQIANwIAIAJB2AhqIAJBnAJqKQIANwIAIAJBuQhqIAYpAwA3AAAgAkHACGogBCkAADcAACACIAIpAPUBIgk3A+gIIAIgAikCjAI3AsgIIAIgCTcAsQggAiADOgCwCCACQdACaiACQbAIaiIGQZTozQAgBRDpIyACKALYAiEEIAIoAtQCIQMgAigC0AIiBUGTgICAeEcEQCACIAIpAtwCNwLQCSACIAQ2AswJIAIgAzYCyAkgAiAFNgLECSAAIAJBxAlqEKYlIAYQ2iQMHgsgAkGwCGoQ2iQMHAsgAkHQAmogAkHwA2pBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4Rg0bIAIgAikC3AI3AuQJIAIgBDYC4AkgAiADNgLcCSACIAU2AtgJIAAgAkHYCWoQpiUMHAsgAyAEKAIIQQFrQXhxakEIaiIDIAQoAhwiBhEEAEHc4s0AELgIRQ0ZIAMgBhEEAC0AAEEERw0TIAJB2ABqIAMgBCgCEBEAACACQbAIaiACKAJYIgMgAigCXCgCDBEAACADRQ0SIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0SIAJB0AJqIgQgAxCZICACQfQBaiAEIAEtANECIAEtANICEKITIAItAPQBIgNBKUYEQCACQZMJaiACQYgCaigCACIBNgAAIAJBiwlqIAJBgAJqKQIAIgk3AAAgAkHoBWogCTcDACACQfAFaiABNgIAIAIgAikC+AEiCTcAgwkgAiAJNwPgBSAAIAJB4AVqEKYlDBwLIAJBjwlqIgQgAkGEAmopAAA3AAAgAkGICWoiBSACQf0BaikAADcDACACQZgGaiACQZQCaikCADcCACACQaAGaiACQZwCaikCADcCACACQYEGaiAFKQMANwAAIAJBiAZqIAQpAAA3AAAgAiACKQKMAjcCkAYgAiADOgD4BSACIAIpAPUBNwD5BUHU3c0AIQQgAkH4BWoQ3CkhAwwaCyADIAURBAAhASACQa8DNgLsCCACIAE2AqQJIAJBAjYCtAggAkGI6c0ANgKwCCACQgE3ArwIIAIgAkGkCWo2AugIIAIgAkHoCGo2ArgIIABBBGogAkGwCGoQmQ4gAEEDNgIADBoLIAJB4ABqIAMgBCgCEBEAACACQbAIaiACKAJgIgMgAigCZCgCDBEAACADRQ0SIAIpA7AIQqSv9PqoqZ2QLYUgAikDuAhC46z6hePb0PVshYRQRQ0SIAJB0AJqIAMQoyAMAQsgAkHoAGogAyAEKAIQEQAAIAJBsAhqIAIoAmgiAyACKAJsKAIMEQAAIANFDRIgAikDsAhCjaPrk8y0xpD3AIUgAikDuAhC2avs9tngxfSMf4WEUEUNEiACQdACaiADEJogCyACQfQBaiACQdACaiABLQDRAiABLQDSAhChEyACLQD0ASIEQSlGBEAgAkGTCWogAkGIAmooAgAiATYAACACQYsJaiACQYACaikCACIJNwAAIAJBsAZqIAk3AwAgAkG4BmogATYCACACIAIpAvgBIgk3AIMJIAIgCTcDqAYgACACQagGahCmJQwYCyACQY8JaiIDIAJBhAJqKQAANwAAIAJBiAlqIgUgAkH9AWopAAA3AwAgAkHIBmoiBiACQZQCaikCADcDACACQdAGaiIHIAJBnAJqKQIANwMAIAJB4AZqIgggBSkDADcDACACQecGaiIFIAMpAAA3AAAgAiACKQKMAjcDwAYgAiACKQD1ATcD2AZBOEEEEK02IgNFDRogAyAEOgAIIANCgYCAgBA3AgAgAyACKQPYBjcACSADIAIpA8AGNwIgIANBEWogCCkDADcAACADQRhqIAUpAAA3AAAgA0EoaiAGKQMANwIAIANBMGogBykDADcCAEGc580AIQQMFgsgAyAFEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwWCyACQfAAaiADIAQoAhARAAAgAkGwCGogAigCcCIDIAIoAnQoAgwRAAAgA0UNECACKQOwCEKkr/T6qKmdkC2FIAIpA7gIQuOs+oXj29D1bIWEUEUNECACQdACaiADEKQgDAELIAJB+ABqIAMgBCgCEBEAACACQbAIaiACKAJ4IgMgAigCfCgCDBEAACADRQ0QIAIpA7AIQo2j65PMtMaQ9wCFIAIpA7gIQtmr7PbZ4MX0jH+FhFBFDRAgAkHQAmogAxCbIAsgAkH0AWogAkHQAmogAS0A0QIgAS0A0gIQoxMgAi0A9AEiBEEpRgRAIAJBkwlqIAJBiAJqKAIAIgE2AAAgAkGLCWogAkGAAmopAgAiCTcAACACQfgGaiAJNwMAIAJBgAdqIAE2AgAgAiACKQL4ASIJNwCDCSACIAk3A/AGIAAgAkHwBmoQpiUMFAsgAkGPCWoiAyACQYQCaikAADcAACACQYgJaiIFIAJB/QFqKQAANwMAIAJBkAdqIgYgAkGUAmopAgA3AwAgAkGYB2oiByACQZwCaikCADcDACACQagHaiIIIAUpAwA3AwAgAkGvB2oiBSADKQAANwAAIAIgAikCjAI3A4gHIAIgAikA9QE3A6AHQThBBBCtNiIDRQ0WIAMgBDoACCADQoGAgIAQNwIAIAMgAikDoAc3AAkgAyACKQOIBzcCICADQRFqIAgpAwA3AAAgA0EYaiAFKQAANwAAIANBKGogBikDADcCACADQTBqIAcpAwA3AgBBlOjNACEEDBILQejizQAQsjsAC0HQ480AELI7AAtBuOTNABCyOwALQaDlzQAQsjsAC0Hc5s0AELI7AAtB7ObNABCyOwALQfzmzQAQsjsAC0GM580AELI7AAtB9OfNABCyOwALQYTozQAQsjsAC0Hs6M0AELI7AAsgAyAGEQQAIQEgAkGvAzYC7AggAiABNgKkCSACQQI2ArQIIAJBiOnNADYCsAggAkIBNwK8CCACIAJBpAlqNgLoCCACIAJB6AhqNgK4CCAAQQRqIAJBsAhqEJkOIABBAzYCAAwHC0GY6c0AELI7AAtBqOnNABCyOwALQbjpzQAQsjsAC0HI6c0AELI7AAsgAkEgaiADIAQoAhARAAAgAkGACWogAigCICIDIAIoAiQoAgwRAAACQCADRQ0AIAIpA4AJQqSv9PqoqZ2QLYUgAikDiAlC46z6hePb0PVshYRQRQ0AIAJB0AJqIgQgAxCUICACQfQBaiAEIAYtAAEgBi0AAhCgEyACLQD0ASIDQSlGBEAgAkH7CGogAkGIAmooAgAiATYAACACQfMIaiACQYACaikCACIJNwAAIAJBwAdqIAk3AwAgAkHIB2ogATYCACACIAIpAvgBIgk3AOsIIAIgCTcDuAcgACACQbgHahCmJQwECyACQfcIaiIEIAJBhAJqKQAANwAAIAJB8AhqIgYgAkH9AWopAAA3AwAgAkHQCGogAkGUAmopAgA3AgAgAkHYCGogAkGcAmopAgA3AgAgAkG5CGogBikDADcAACACQcAIaiAEKQAANwAAIAIgAikA9QEiCTcD6AggAiACKQKMAjcCyAggAiAJNwCxCCACIAM6ALAIIAJB0AJqIAJBsAhqIgZBvNvNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4RwRAIAIgAikC3AI3AtgHIAIgBDYC1AcgAiADNgLQByACIAU2AswHIAAgAkHMB2oQpiUgBhDaJAwECyACQbAIahDaJAwCC0GU5s0AELI7AAsgAkHQAmogAkHwA2pBtMjNACAFEOkjIAIoAtgCIQQgAigC1AIhAyACKALQAiIFQZOAgIB4Rg0AIAIgAikC3AI3AvgJIAIgBDYC9AkgAiADNgLwCSACIAU2AuwJIAAgAkHsCWoQpiUMAQsCf0GAgICAeCABKALgASIFQYGAgIB4Rg0AGkGAgICAeCAFQYCAgIB4Rg0AGiABKQLkASEJIAFBADYC6AEgAUKAgICAIDcD4AEgBQshBSABQbgCahC0MCABIAk3ArwCIAEgBTYCuAIgASgClAIiBUGAgICAeEcEQCABKQOYAiEJIAFBADYCnAIgAUKAgICAIDcClAILIAFBxAJqELQwIAEgCTcDyAIgASAFNgLEAiABQgA3AqQCIAAgBDYCCCAAIAM2AgQgAEEINgIAIAIoAvADIgAgACgCACIAQQFrNgIAIABBAUYNAQwCCyACKALwAyIAIAAoAgAiAEEBazYCACAAQQFHDQELIAJB8ANqELsjCyACQYAKaiQADwtBBEE4EKM9AAvdMQIbfwJ+IwBBgClrIgUkACAAKAIcIgYoAhAiGiAGKAI8IhhrIRkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAJIBEACQCAGLAAEQQBMBEAgGEEATg0BIAVBADYClBIgBUEBNgKIEiAFQdj5+wA2AoQSIAVCBDcCjBIgBUGEEmpB4Pn7ABDvLAALIAAoAixBAkYEQCAGQagBaiEDQv+A/58PIR0CQANAAkAgHUIBg1ANACADIARqLwEARQ0AQQAhBAwCCyAdQgGIIR0gBEEEaiIEQYABRw0AC0EBIQQgBi8BzAENACAGLwHQAQ0AIAYvAdwBDQAgBkGoAmohBEEAIQMDQCADIgJBgAdHBEAgA0EEaiEDIAIgBGovAQBFDQELCyACQYAHRyEECyAAIAQ2AiwLIAVBCGpB8ML7AEH8EfwKAABBACEEA0AgBUEIaiAEaiIDKAIAIQIgAyAEIAZqQaQBaiIDKAIANgIAIAMgAjYCACAEQQRqIgRB/BFHDQALIAUoAggiAygCBCEJIAMoAgAhCyADKAIUIQcgBUGEEmoiAkEAQbkW/AsAIAdBvgRJBEAgAiAFQQxqIgwgBxDHGSENAkACQAJAAkACQAJAIAUoAvgjIgRBAU0EQCAGKAJ4QQFrIQMgBigCfCEIIAVBgCRqIQoDQCAFIARBAWoiAjYC+CMgBUGEEmogAkECdGogDUEBaiIEQQAgDUECSCIPGyICNgIAIAJBvARLDQIgBiADNgJ4IAIgCmpBADoAACAMIAJBAnQiDmpBATsBACAJBEAgAiAJTw0YIAYgCCALIA5qLwECayIINgJ8CyAEIA0gDxshDSADQQFrIQMgBSgC+CMiBEECSQ0ACwsgBSANNgKAEiAEQQF2IQQDQCAFQYQSaiICIAxBvQQgBBD/DSAEQQFrIgQNAAsgAiAMQb0EIAcQ8AwgBSgCCCIDLwEYIQggAygCECEQIAMoAgwhEiADKAIIIRMgAygCBCEOIAMoAgAhFiAFKAKAEiEUIAVB+ChqQgA3AwAgBUHwKGpCADcDACAFQegoakIANwMAIAVCADcD4CggBSgC/CMiA0G8BEsNBQJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQQJ0IgcgAmooAgAiAkG9BEkEQEEAIQkgDCACQQJ0akECakEAOwEAAkAgA0G8BEYNACADQbwEayEEIAUgB2pBiBJqIQMgBigCfCEHIAYoAnghCwNAIAMoAgAiCkG8BEsNEyAMIApBAnQiF2oiES8BAiICQb0ETw0SIBEgDCACQQJ0akECai8BAEEBakH//wNxIhUgCCAIIBVLGyIPOwECAkAgCiAUSw0AIA9BD0sNEiAFQeAoaiAPQQF0aiICIAIvAQBBAWo7AQBBACECIAogEE8EQCAKIBBrIgIgEk8NEiACIBNqLQAAIQILIAYgES8BACIRIAIgD2psIAtqIgs2AnggDkUNACAKIA5PDR8gBiACIBYgF2ovAQJqIBFsIAdqIgc2AnwLIAkgCCAVSWohCSADQQRqIQMgBEEBaiIEDQALIAlFDQAgCEEBayECIAVB4ChqIAhBAXRqIgpBAmohByAIQRBJIQ8CQANAIAchAyACIQQDQCAEQQ9LDSQgBEEBayEEIANBBGsgA0ECayEDLwEAIg5FDQALIANBAmsgDkEBazsBACAEQQ5GDSIgAyADLwEAQQJqOwEAIA9FDSAgCiAKLwEAQQFrOwEAIAlBAmsiCUEASg0ACyAIRQ0BIAVBgBJqIQpBvQQhAwwACwNAAkAgBUHgKGogCCIHQQF0ai8BACIIRQ0AAkADQCAKIANBAnRqIQQgAyECAkADQCACQQFrIgNBvARLDQEgBCgCACEJIARBBGshBCADIQIgCSAUSw0ACyAJQbwESw0CIAwgCUECdGoiAi8BAiIEIAdHBEAgAiAHOwECIAYgCyACLwEAIgIgB2xB//8DcWogAiAEbEH//wNxayILNgJ4CyAIQQFrIghB//8DcUUNAwwBCwsMIgsgCUG9BEG89vsAEMMhAAsgB0EBayEIIAdBAUcNAAsLIAVB2ChqIAVB+ChqKQMANwMAIAVB0ChqIAVB8ChqKQMANwMAIAVByChqIAVB6ChqKQMANwMAIAUgBSkD4Cg3A8AoIAxBvQQgDSAFQcAoahCODUEAIQQDQCAFQQhqIgcgBGoiAygCACECIAMgBCAGakGkAWoiAygCADYCACADIAI2AgAgBEEEaiIEQfwRRw0ACyAHQYDV+wBB/AH8CgAAQQAhBANAIAVBCGogBGoiAygCACECIAMgBCAGakGgE2oiAygCADYCACADIAI2AgAgBEEEaiIEQfwBRw0ACyAFKAIIIgMoAgQhCSADKAIAIQsgAygCFCEHIAVBhBJqIgJBAEG5FvwLACAHQT5PDQwgAiAFQQxqIgwgBxDHGSENIAUoAvgjIgRBAU0EQCAGKAJ4QQFrIQMgBigCfCEIIAVBgCRqIQoDQCAFIARBAWoiAjYC+CMgBUGEEmogAkECdGogDUEBaiIEQQAgDUECSCIPGyICNgIAIAJBPEsNCSAGIAM2AnggAiAKakEAOgAAIAwgAkECdCIOakEBOwEAIAkEQCACIAlPDSUgBiAIIAsgDmovAQJrIgg2AnwLIAQgDSAPGyENIANBAWshAyAFKAL4IyIEQQJJDQALCyAFIA02AoACIARBAXYhBANAIAVBhBJqIgIgDEE9IAQQ/w0gBEEBayIEDQALIAIgDEE9IAcQ8AwgBSgCCCIDLwEYIQggAygCECEQIAMoAgwhEiADKAIIIRMgAygCBCEOIAMoAgAhFiAFKAKAAiEUIAVB+ChqQgA3AwAgBUHwKGpCADcDACAFQegoakIANwMAIAVCADcD4CggBSgC/CMiA0G8BEsNISADQQJ0IgcgAmooAgAiAkE9SQRAQQAhCSAMIAJBAnRqQQJqQQA7AQACQCADQbwERg0AIANBvARrIQQgBSAHakGIEmohAyAGKAJ8IQcgBigCeCELA0AgAygCACIKQTxLDQ4gDCAKQQJ0IhdqIhEvAQIiAkE9Tw0NIBEgDCACQQJ0akECai8BAEEBakH//wNxIhUgCCAIIBVLGyIPOwECAkAgCiAUSw0AIA9BD0sNDSAFQeAoaiAPQQF0aiICIAIvAQBBAWo7AQBBACECIAogEE8EQCAKIBBrIgIgEk8NDSACIBNqLQAAIQILIAYgES8BACIRIAIgD2psIAtqIgs2AnggDkUNACAKIA5PDR8gBiACIBYgF2ovAQJqIBFsIAdqIgc2AnwLIAkgCCAVSWohCSADQQRqIQMgBEEBaiIEDQALIAlFDQAgCEEBayECIAVB4ChqIAhBAXRqIgpBAmohByAIQRBJIQ8CQANAIAchAyACIQQDQCAEQQ9LDSUgBEEBayEEIANBBGsgA0ECayEDLwEAIg5FDQALIANBAmsgDkEBazsBACAEQQ5GDSMgAyADLwEAQQJqOwEAIA9FDSEgCiAKLwEAQQFrOwEAIAlBAmsiCUEASg0ACyAIRQ0BIAVBgBJqIQpBvQQhAwwACwNAAkAgBUHgKGogCCIHQQF0ai8BACIIRQ0AAkADQCAKIANBAnRqIQQgAyECAkADQCACQQFrIgNBvARLDQEgBCgCACEJIARBBGshBCADIQIgCSAUSw0ACyAJQTxLDQIgDCAJQQJ0aiICLwECIgQgB0cEQCACIAc7AQIgBiALIAIvAQAiAiAHbEH//wNxaiACIARsQf//A3FrIgs2AngLIAhBAWsiCEH//wNxRQ0DDAELCwwjCyAJQT1BvPb7ABDDIQALIAdBAWshCCAHQQFHDQALCyAFQdgoaiAFQfgoaikDADcDACAFQdAoaiAFQfAoaikDADcDACAFQcgoaiAFQegoaikDADcDACAFIAUpA+AoNwPAKCAMQT0gDSAFQcAoahCODUEAIQQDQCAFQQhqIgcgBGoiAygCACECIAMgBCAGakGgE2oiAygCADYCACADIAI2AgAgBEEEaiIEQfwBRw0ACyAGQZwVaiIDIAZBqAFqIg9BvQQgBigCnBMQ7wsgAyAGQaQTaiISQT0gBigCmBUQ7wsgB0H81vsAQaQB/AoAAEEAIQQDQCAFQQhqIARqIgMoAgAhAiADIAQgBmpBnBVqIgMoAgA2AgAgAyACNgIAIARBBGoiBEGkAUcNAAsgBSgCCCIDKAIEIQkgAygCACELIAMoAhQhByAFQYQSaiICQQBBuRb8CwAgB0EoTw0HIAIgBUEMaiIMIAcQxxkhDSAFKAL4IyIEQQFNBEAgBigCeEEBayEDIAYoAnwhCCAFQYAkaiEKA0AgBSAEQQFqIgI2AvgjIAVBhBJqIAJBAnRqIA1BAWoiBEEAIA1BAkgiDhsiAjYCACACQSZLDQQgBiADNgJ4IAIgCmpBADoAACAMIAJBAnQiEGpBATsBACAJBEAgAiAJTw0mIAYgCCALIBBqLwECayIINgJ8CyAEIA0gDhshDSADQQFrIQMgBSgC+CMiBEECSQ0ACwsgBSANNgKoASAEQQF2IQQDQCAFQYQSaiICIAxBJyAEEP8NIARBAWsiBA0ACyACIAxBJyAHEPAMIAUoAggiAy8BGCEIIAMoAhAhFCADKAIMIREgAygCCCEXIAMoAgQhECADKAIAIRsgBSgCqAEhFSAFQfgoakIANwMAIAVB8ChqQgA3AwAgBUHoKGpCADcDACAFQgA3A+AoIAUoAvwjIgNBvARLDSIgA0ECdCIHIAJqKAIAIgJBJ0kEQEEAIQkgDCACQQJ0akECakEAOwEAAkAgA0G8BEYNACADQbwEayEEIAUgB2pBiBJqIQMgBigCfCEHIAYoAnghCwNAIAMoAgAiCkEmSw0JIAwgCkECdCIcaiITLwECIgJBJ08NCCATIAwgAkECdGpBAmovAQBBAWpB//8DcSIWIAggCCAWSxsiDjsBAgJAIAogFUsNACAOQQ9LDQggBUHgKGogDkEBdGoiAiACLwEAQQFqOwEAQQAhAiAKIBRPBEAgCiAUayICIBFPDQggAiAXai0AACECCyAGIBMvAQAiEyACIA5qbCALaiILNgJ4IBBFDQAgCiAQTw0fIAYgAiAbIBxqLwECaiATbCAHaiIHNgJ8CyAJIAggFklqIQkgA0EEaiEDIARBAWoiBA0ACyAJRQ0AIAhBAWshAiAFQeAoaiAIQQF0aiIKQQJqIQcgCEEQSSEOAkADQCAHIQMgAiEEA0AgBEEPSw0mIARBAWshBCADQQRrIANBAmshAy8BACIQRQ0ACyADQQJrIBBBAWs7AQAgBEEORg0kIAMgAy8BAEECajsBACAORQ0iIAogCi8BAEEBazsBACAJQQJrIglBAEoNAAsgCEUNASAFQYASaiEKQb0EIQMMAAsDQAJAIAVB4ChqIAgiB0EBdGovAQAiCEUNAAJAA0AgCiADQQJ0aiEEIAMhAgJAA0AgAkEBayIDQbwESw0BIAQoAgAhCSAEQQRrIQQgAyECIAkgFUsNAAsgCUEmSw0CIAwgCUECdGoiAi8BAiIEIAdHBEAgAiAHOwECIAYgCyACLwEAIgIgB2xB//8DcWogAiAEbEH//wNxayILNgJ4CyAIQQFrIghB//8DcUUNAwwBCwsMJAsgCUEnQbz2+wAQwyEACyAHQQFrIQggB0EBRw0ACwsgBUHYKGogBUH4KGopAwA3AwAgBUHQKGogBUHwKGopAwA3AwAgBUHIKGogBUHoKGopAwA3AwAgBSAFKQPgKDcDwCggDEEnIA0gBUHAKGoQjg1BACEEA0AgBUEIaiAEaiIDKAIAIQIgAyAEIAZqQZwVaiIDKAIANgIAIAMgAjYCACAEQQRqIgRBpAFHDQALIAZBohVqIQdBEiEEA0ACQAJAIARBnPn7AGotAAAiA0EmTQRAIAcgA0ECdGovAQBFDQEgBCEDDAILIANBJ0HA+fsAEMMhAAtBAiEDIARBAWsiBEECSw0BCwsgBiAGKAJ4IANBA2xqIgRBEWo2AngCQCAGKAJ8QQpqQQN2IgIgBEEbakEDdiIESwRAIAYtAANBBEcNAQsgAiEECyAZQQRqIARNIBhBAE5xDRggAiAERg0ZIAZB2ABqIghBAiABEIwmAkACQCADQQFqIg1BBEkNACAGKAKcEyILQQFqIgJBgQJJDQAgBigCmBUiDEEBaiIJDQELIAVBADYClBIgBUEBNgKIEiAFQdz4+wA2AoQSIAVCBDcCjBIgBUGEEmpB5Pj7ABDvLAALAkACQAJAAkAgDUETSyACQZ4CS3IgCUEfT3JFBEAgAq1CgQJ9IR0CQCAGLQBwIgJBBWoiBEH/AXFBwABPBEAgCCAdIAQQ8BAgBi0AcCEEDAELIAYgBDoAcCAGIAYpA2ggHSACrYaENwNoCyAJrUIBfSEdAkAgBEEFaiICQf8BcUHAAE8EQCAIIB0gAhDwECAGLQBwIQIMAQsgBiACOgBwIAYgBikDaCAdIASthoQ3A2gLIA2tQgR9IR0CQCACQQRqIgRB/wFxQcAATwRAIAggHSAEEPAQDAELIAYgBDoAcCAGIAYpA2ggHSACrYaENwNoC0F/IQQDQCAEQZ35+wBqLQAAIgJBJksNAiAHIAJBAnRqMwEAIR0CQCAGLQBwIg1BA2oiAkH/AXFBwABPBEAgCCAdIAIQ8BAMAQsgBiACOgBwIAYgBikDaCAdIA2thoQ3A2gLIAMgBEEBaiIERw0ACyAIIA9BvQQgBkGgFWoiAyALENQJIAggEkE9IAMgDBDUCSAGKAJIIgMgBigCRCICSw0CIAMgA0EDcGsiDUEDTwRAIAYoAkAhBANAIARBAmotAAAhAgJAIAQvAAAiCUUEQCAIIA9BvQQgAhDJKgwBCyACQbDY+wBqLQAAIgdBHU8NBiAPIAdBAnRqIgsvAYYIIQMgCzMBhAghHSAHQdTa+wBqLQAAIgsEQCACIAdB8dr7AGotAABrrSADQT9xrYYgHYQhHSADIAtqIQMLIAlBAWsiCUH//wNxEMoqQf8BcSIHQR5PDQcgEiAHQQJ0aiILLwECIQIgCzMBACEeIAdBsNv7AGotAAAiCwRAIAkgB0EBdEHO2/sAai8BAGutQv//A4MgAkE/ca2GIB6EIR4gAiALaiECCyAeIANBP3GthiAdhCEdIAYtAHAiByACIANqaiIDQf8BcUHAAE8EQCAIIB0gAxDwEAwBCyAGIAM6AHAgBiAGKQNoIB0gB62GhDcDaAsgBEEDaiEEIA1BA2siDUECSw0ACyAAKAIcIQYLIAhBgAIgD0G9BBCrIQwfCyAFQQA2ApQSIAVBATYCiBIgBUGE+fsANgKEEiAFQgQ3AowSIAVBhBJqQYz5+wAQ7ywACyACQSdBsPn7ABDDIQALIAMgAkG0wvsAELA7AAsgBUEANgKUEiAFQQE2AogSIAVBvNr7ADYChBIgBUIENwKMEiAFQYQSakHE2vsAEO8sAAsgBUEANgKUEiAFQQE2AogSIAVBmNv7ADYChBIgBUIENwKMEiAFQYQSakGg2/sAEO8sAAsgAkEnQez1+wAQwyEACyACQT1B7PX7ABDDIQALIAJBvQRB7PX7ABDDIQALIAJBJ0G89fsAEMMhAAsgAiARQfz2+wAQwyEACyAOQRBB7Pb7ABDDIQALIAJBJ0Hc9vsAEMMhAAsgCkEnQcz2+wAQwyEACyAHQSdBrPX7ABCwOwALIAJBPUG89fsAEMMhAAsgAiASQfz2+wAQwyEACyAPQRBB7Pb7ABDDIQALIAJBPUHc9vsAEMMhAAsgCkE9Qcz2+wAQwyEACyAHQT1BrPX7ABCwOwALIAJBvQRBvPX7ABDDIQALIAIgEkH89vsAEMMhAAsgD0EQQez2+wAQwyEACyACQb0EQdz2+wAQwyEACyAKQb0EQcz2+wAQwyEACwwOCyAHQb0EQaz1+wAQsDsACyAZQQRqIBlBBWpNDQEMAgsgBkEHNgJ8IBlBfEcgGEEASHINAQsgBiAYIBogARD4DAwBCyAGQdgAaiICQQEgARCMJiAGKAJIIgMgBigCRCIESw0BIAMgA0EDcGsiA0EDTwRAIAYoAkAhBANAIARBAmotAAAhCAJAIAQvAAAiB0UEQCACQfzc+wBBoAIgCBDJKgwBCyACIAggBxC7EgsgBEEDaiEEIANBA2siA0ECSw0ACwsgAkGAAkH83PsAQaACEKshCyAGELEaIAEEQCAGQdgAahDwFQsgACgCHCIBIAEoAhA2AjwgABDiGCAFQYApaiQADwsgAyAEQbTC+wAQsDsACyAKIBBBjPf7ABDDIQALIAogDkGM9/sAEMMhAAsgCiAOQYz3+wAQwyEACyAIQRBBnPb7ABDDIQALIAJBAWtBvQRBrPb7ABDDIQALQRBBEEGM9vsAEMMhAAsgBEEQQfz1+wAQwyEACyADQb0EQdz1+wAQwyEACyACIAlBzPX7ABDDIQALuA4BCn8jAEGQAmsiCSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAyAEKAIcEQQAIgUtAABBAmsOCAABAgMEBQYHCAsgAyAEELsiIQgMDwsgAyAEEKgiIQUMDQsgAyAEELEiIQQMCwsgAyAEEKQiIQQMCQsgAyAEEKoiIQgMBwsgAyAEEK0iIQUMBQsgAyAEELciIQQMAwsgAyAEEKIiIQQMAQsgCSAFNgLQASAJQQE2AowBIAlBvP6BATYCiAEgCUIBNwKUASAJQa8DNgLsASAJIAlB6AFqNgKQASAJIAlB0AFqNgLoASAAQQRqIAlBiAFqEJkOIABBjYCAgHg2AgAMCAsgCUGIAWoiAyAEEIAVIAAgASACIAMQhwEgAxD+JAwHCyAJQYgBaiIDIAQQgBUgACABIAIgAxCIASADEP4kDAYLIwBBMGsiCCQAIAhBGGohCiAFKAIQIgMhBCADIAUoAhRBfnFqIQYjAEEgayIDJAAgA0EUaiAGIARrQQF2QQBBBEEEEKAYIAMoAhghByADKAIUQQFGBEAMBwsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIgcgBiAEa0EBdiILEIUuIAcoAgghDCAHIAQgBkcEfyALIAxqIAcoAgQgDEECdGohBgNAIAYgBC8BADYCACAEQQJqIQQgBkEEaiEGIAtBAWsiCw0ACwUgDAs2AgggCkEIaiANKAIANgIAIAogAykCCDcCACADQSBqJAAgCEEMaiIEIAoQ6BggCiAFEJI2EO4lIAlBiAFqIgMgBCAKEMcdIAhBMGokACAAIAEgAiADEIgBIAMQ/iQMBQsjAEEwayIKJAAgCkEYaiEGIAgoAhAiAyEEIAMgCCgCFGohBSMAQSBrIgMkACADQRRqIAUgBGtBAEEEQQQQoBggAygCGCEHIAMoAhRBAUYEQAwGCyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAHNgIIIANBCGoiByAFIARrIgwQhS4gBygCCCELIAcgBCAFRwR/IAUgC2ogBGsgBygCBCALQQJ0aiEFA0AgBSAELQAANgIAIARBAWohBCAFQQRqIQUgDEEBayIMDQALBSALCzYCCCAGQQhqIA0oAgA2AgAgBiADKQIINwIAIANBIGokACAKQQxqIgQgBhDoGCAGIAgQkjYQ7iUgCUGIAWoiAyAEIAYQxx0gCkEwaiQAIAAgASACIAMQiAEgAxD+JAwECyMAQTBrIgMkACAEKAIMIgUgBSgCACIIQQFqNgIAIAhBAEgEQAALIAMgBTYCGCADIAQpAhA3AhwgA0EMaiIIIANBGGoiBUEAIARBDGoQ2DwQ/hwgBSAEEJI2EO4lIAlBiAFqIgQgCCAFENkdIANBMGokACAAIAEgAiAEEIcBIAQQ/iQMAwsjAEEwayIDJAAgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIBEAACyADIAU2AhggAyAEKQIQNwIcIANBDGoiCCADQRhqIgVBACAEQQxqENs8EIAdIAUgBBCSNhDuJSAJQYgBaiIEIAggBRDHHSADQTBqJAAgACABIAIgBBCIASAEEP4kDAILIwBBMGsiCCQAIAhBGGohCiAFKAIQIgMhBCADIAUoAhRBfnFqIQYjAEEgayIDJAAgA0EUaiAGIARrQQF2QQBBBEEEEKAYIAMoAhghByADKAIUQQFGBEAMAwsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIgcgBiAEa0EBdiILEIUuIAcoAgghDCAHIAQgBkcEfyALIAxqIAcoAgQgDEECdGohBgNAIAYgBC4BADYCACAEQQJqIQQgBkEEaiEGIAtBAWsiCw0ACwUgDAs2AgggCkEIaiANKAIANgIAIAogAykCCDcCACADQSBqJAAgCEEMaiIEIAoQ6BggCiAFEJI2EO4lIAlBiAFqIgMgBCAKEMcdIAhBMGokACAAIAEgAiADEIgBIAMQ/iQMAQsjAEEwayIKJAAgCkEYaiEGIAgoAhAiAyEEIAMgCCgCFGohBSMAQSBrIgMkACADQRRqIAUgBGtBAEEEQQQQoBggAygCGCEHIAMoAhRBAUYEQAwCCyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAHNgIIIANBCGoiByAFIARrIgwQhS4gBygCCCELIAcgBCAFRwR/IAUgC2ogBGsgBygCBCALQQJ0aiEFA0AgBSAELAAANgIAIARBAWohBCAFQQRqIQUgDEEBayIMDQALBSALCzYCCCAGQQhqIA0oAgA2AgAgBiADKQIINwIAIANBIGokACAKQQxqIgQgBhDoGCAGIAgQkjYQ7iUgCUGIAWoiAyAEIAYQxx0gCkEwaiQAIAAgASACIAMQiAEgAxD+JAsgCUGQAmokAA8LIAcgAygCHEHs/YMBEP0vAAvFKgIdfwR+IwBBoAprIgMkAAJAAkACQAJAAkACQAJAIAEpAwAiIFBFBEAgASkDCCIhUEUEQCABKQMQIiJQRQRAICAgICAifCIjWARAICAgIVoEQCABLAAaIRIgAS4BGCEBIAMgID4CACADQQFBAiAgQoCAgIAQVCIGGzYCoAEgA0EAICBCIIinIAYbNgIEIANBCGpBAEGYAfwLACADICE+AqQBIANBAUECICFCgICAgBBUIgYbNgLEAiADQQAgIUIgiKcgBhs2AqgBIANBrAFqQQBBmAH8CwAgAyAiPgLIAiADQQFBAiAiQoCAgIAQVCIGGzYC6AMgA0EAICJCIIinIAYbNgLMAiADQdACakEAQZgB/AsAIANB8ANqQQBBnAH8CwAgA0EBNgLsAyADQQE2AowFIAGsICNCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciBsEhDwJAIAFBAE4EQCADIAEQtgYaIANBpAFqIAEQtgYaIANByAJqIAEQtgYaDAELIANB7ANqQQAgAWvBELYGGgsCQCAPQQBIBEAgA0EAIA9rQf//A3EiARDeBSADQaQBaiABEN4FIANByAJqIAEQ3gUMAQsgA0HsA2ogBkH//wFxEN4FCyADQfwIaiADQaQB/AoAAAJAAkACQAJAIAMoAugDIgYgAygCnAoiASABIAZJGyIEQShNBEAgBEUEQEEAIQQMBAsgBEEBcSEKIARBAUcNAQwCCwwMCyAEQT5xIQsgA0H8CGohASADQcgCaiEHA0AgASAIIAEoAgAiECAHKAIAaiIJaiIINgIAIAFBBGoiDCAMKAIAIhEgB0EEaigCAGoiDCAJIBBJIAggCUlyaiIJNgIAIAwgEUkgCSAMSXIhCCAHQQhqIQcgAUEIaiEBIAsgBUECaiIFRw0ACwsgCgR/IAVBAnQiASADQfwIamoiBSAFKAIAIgUgA0HIAmogAWooAgBqIgEgCGoiCTYCACABIAVJIAEgCUtyBSAIC0UNACAEQShGDQEgA0H8CGogBEECdGpBATYCACAEQQFqIQQLIAMgBDYCnAogBCADKAKMBSIBIAEgBEkbIgFBKUkEQCABQQJ0IQECQAJAAn8CQANAIAFFDQEgAUEEayIBIANB7ANqaigCACIEIAEgA0H8CGpqKAIAIgVGDQALIAQgBUsgBCAFSWsMAQtBf0EAIAEbCyASTgRAIAMoAqABIgVBKU8NAgJAIAVFBEBBACEFDAELIAVBAWtB/////wNxIgFBAWoiBEEDcSEHAkAgAUEDSQRAIAMhAUIAISEMAQsgBEH8////B3EhCCADIQFCACEhA0AgASABNQIAQgp+ICF8IiA+AgAgAUEEaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQhqIgQgBDUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBCAENQIAQgp+ICBCIIh8IiA+AgAgIEIgiCEhIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAhfCIgPgIAIAFBBGohASAgQiCIISEgB0EBayIHDQALCyAgQoCAgIAQVA0AIAVBKEYNESADIAVBAnRqICE+AgAgBUEBaiEFCyADIAU2AqABIAMoAsQCIgRBKU8NDSADAn9BACAERQ0AGiAEQQFrQf////8DcSIBQQFqIgVBA3EhBwJAIAFBA0kEQCADQaQBaiEBQgAhIAwBCyAFQfz///8HcSEIIANBpAFqIQFCACEgA0AgASABNQIAQgp+ICB8IiA+AgAgAUEEaiIFIAU1AgBCCn4gIEIgiHwiID4CACABQQhqIgUgBTUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBSAFNQIAQgp+ICBCIIh8IiE+AgAgIUIgiCEgIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAgfCIhPgIAIAFBBGohASAhQiCIISAgB0EBayIHDQALCyAEICFCgICAgBBUDQAaIARBKEYNESADQaQBaiAEQQJ0aiAgPgIAIARBAWoLNgLEAiADIAYEfyAGQQFrQf////8DcSIBQQFqIgRBA3EhBwJAIAFBA0kEQCADQcgCaiEBQgAhIAwBCyAEQfz///8HcSEIIANByAJqIQFCACEgA0AgASABNQIAQgp+ICB8IiA+AgAgAUEEaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQhqIgQgBDUCAEIKfiAgQiCIfCIgPgIAIAFBDGoiBCAENQIAQgp+ICBCIIh8IiE+AgAgIUIgiCEgIAFBEGohASAIQQRrIggNAAsLIAcEQANAIAEgATUCAEIKfiAgfCIhPgIAIAFBBGohASAhQiCIISAgB0EBayIHDQALCyAhQoCAgIAQVARAIAMgBjYC6AMMAwsgBkEoRg0RIANByAJqIAZBAnRqICA+AgAgBkEBagVBAAs2AugDDAELIA9BAWohDwsgA0GQBWogA0HsA2pBpAH8CgAAIANBkAVqQQEQtgYhEyADQbQGaiIBIANB7ANqIgZBpAH8CgAAIAFBAhC2BiEUIANB2AdqIgEgBkGkAfwKAAACQAJAAkACQAJAIAFBAxC2BiIXKAKgASIRIAMoAqABIgUgBSARSRsiBkEoTQRAIANBjAVqIRggA0GwBmohGSADQdQHaiEaIBMoAqABIRUgFCgCoAEhFiADKAKMBSEQQQAhCQNAIAkhDCAGQQJ0IQECfwJAAkACQANAIAFFDQEgASAaaiEEIAFBBGsiASADaigCACIJIAQoAgAiBEYNAAsgBCAJSw0BDAILIAFFDQELIAUhBkEADAELIAYEQEEBIQhBACEFIAZBAUcEQCAGQT5xIQogAyIBQdgHaiEHA0AgASAIIAEoAgAiCyAHKAIAQX9zaiIEaiIINgIAIAFBBGoiCSAJKAIAIg0gB0EEaigCAEF/c2oiCSAEIAtJIAQgCEtyaiIENgIAIAkgDUkgBCAJSXIhCCAHQQhqIQcgAUEIaiEBIAogBUECaiIFRw0ACwsgBkEBcQR/IAMgBUECdCIBaiIEIAQoAgAiBCABIBdqKAIAQX9zaiIBIAhqIgU2AgAgASAESSABIAVLcgUgCAtFDRULIAMgBjYCoAFBCAshCiAWIAYgBiAWSRsiBEEpTw0SIARBAnQhAQJAAkACQANAIAFFDQEgASAZaiEFIAFBBGsiASADaigCACIJIAUoAgAiBUYNAAsgBSAJTQ0BIAYhBAwCCyABRQ0AIAYhBAwBCyAEBEBBASEIQQAhBSAEQQFHBEAgBEE+cSELIAMiAUG0BmohBwNAIAEgCCABKAIAIg0gBygCAEF/c2oiBmoiCDYCACABQQRqIgkgCSgCACIOIAdBBGooAgBBf3NqIgkgBiANSSAGIAhLcmoiBjYCACAJIA5JIAYgCUlyIQggB0EIaiEHIAFBCGohASALIAVBAmoiBUcNAAsLIARBAXEEfyADIAVBAnQiAWoiBiAGKAIAIgYgASAUaigCAEF/c2oiASAIaiIFNgIAIAEgBkkgASAFS3IFIAgLRQ0VCyADIAQ2AqABIApBBHIhCgsgFSAEIAQgFUkbIgZBKU8NAyAGQQJ0IQECQAJAAkADQCABRQ0BIAEgGGohBSABQQRrIgEgA2ooAgAiCSAFKAIAIgVGDQALIAUgCU0NASAEIQYMAgsgAUUNACAEIQYMAQsgBgRAQQEhCEEAIQUgBkEBRwRAIAZBPnEhCyADIgFBkAVqIQcDQCABIAggASgCACINIAcoAgBBf3NqIgRqIgg2AgAgAUEEaiIJIAkoAgAiDiAHQQRqKAIAQX9zaiIJIAQgDUkgBCAIS3JqIgQ2AgAgCSAOSSAEIAlJciEIIAdBCGohByABQQhqIQEgCyAFQQJqIgVHDQALCyAGQQFxBH8gAyAFQQJ0IgFqIgQgBCgCACIEIAEgE2ooAgBBf3NqIgEgCGoiBTYCACABIARJIAEgBUtyBSAIC0UNFQsgAyAGNgKgASAKQQJqIQoLIBAgBiAGIBBJGyIEQSlPDRIgBEECdCEBAkACQAJAA0AgAUUNASABQQRrIgEgA2ooAgAiBSABIANB7ANqaigCACIJRg0ACyAFIAlPDQEgBiEEDAILIAFFDQAgBiEEDAELIAQEQEEBIQhBACEFIARBAUcEQCAEQT5xIQsgAyIBQewDaiEHA0AgASAIIAEoAgAiDSAHKAIAQX9zaiIGaiIINgIAIAFBBGoiCSAJKAIAIg4gB0EEaigCAEF/c2oiCSAGIA1JIAYgCEtyaiIGNgIAIAkgDkkgBiAJSXIhCCAHQQhqIQcgAUEIaiEBIAsgBUECaiIFRw0ACwsgBEEBcQR/IAMgBUECdCIBaiIGIAYoAgAiBiADQewDaiABaigCAEF/c2oiASAIaiIFNgIAIAEgBkkgASAFS3IFIAgLRQ0VCyADIAQ2AqABIApBAWohCgsgDEERRg0FIAIgDGoiDSAKQTBqOgAAIAMoAsQCIgYgBCAEIAZJGyIBQSlPDRQgDEEBaiEJIAFBAnQhAQJ/AkADQCABRQ0BIAFBBGsiASADaigCACIFIAEgA0GkAWpqKAIAIgdGDQALIAUgB0sgBSAHSWsMAQtBf0EAIAEbCyEbIANB/AhqIANBpAH8CgAAIAMoAugDIgsgAygCnAoiASABIAtJGyIKQShLDQQCQCAKRQRAQQAhCgwBC0EAIQhBACEFIApBAUcEQCAKQT5xIRwgA0H8CGohASADQcgCaiEHA0AgASAIIAEoAgAiHSAHKAIAaiIOaiIeNgIAIAFBBGoiCCAIKAIAIh8gB0EEaigCAGoiCCAOIB1JIA4gHktyaiIONgIAIAggH0kgCCAOS3IhCCAHQQhqIQcgAUEIaiEBIBwgBUECaiIFRw0ACwsgCkEBcQR/IAVBAnQiASADQfwIamoiBSAFKAIAIgUgA0HIAmogAWooAgBqIgEgCGoiBzYCACABIAVJIAEgB0tyBSAIC0UNACAKQShGDRYgA0H8CGogCkECdGpBATYCACAKQQFqIQoLIAMgCjYCnAogCiAQIAogEEsbIgFBKU8NFCABQQJ0IQECfwJAA0AgAUUNASABQQRrIgEgA0HsA2pqKAIAIgUgASADQfwIamooAgAiB0YNAAsgBSAHSyAFIAdJawwBC0F/QQAgARsLIBJOIgEgEiAbSiIFRXFFBEAgAQ0SIAUNAwwRC0EAIQwgAwJ/QQAgBEUNABogBEEBa0H/////A3EiAUEBaiIFQQNxIQcCQCABQQNJBEAgAyEBQgAhIAwBCyAFQfz///8HcSEIIAMhAUIAISADQCABIAE1AgBCCn4gIHwiID4CACABQQRqIgUgBTUCAEIKfiAgQiCIfCIgPgIAIAFBCGoiBSAFNQIAQgp+ICBCIIh8IiA+AgAgAUEMaiIFIAU1AgBCCn4gIEIgiHwiIT4CACAhQiCIISAgAUEQaiEBIAhBBGsiCA0ACwsgBwRAA0AgASABNQIAQgp+ICB8IiE+AgAgAUEEaiEBICFCIIghICAHQQFrIgcNAAsLIAQgIUKAgICAEFQNABogBEEoRg0WIAMgBEECdGogID4CACAEQQFqCyIFNgKgAQJAIAZFDQAgBkEBa0H/////A3EiAUEBaiIEQQNxIQcCQCABQQNJBEAgA0GkAWohAUIAISEMAQsgBEH8////B3EhCCADQaQBaiEBQgAhIQNAIAEgATUCAEIKfiAhfCIgPgIAIAFBBGoiBCAENQIAQgp+ICBCIIh8IiA+AgAgAUEIaiIEIAQ1AgBCCn4gIEIgiHwiID4CACABQQxqIgQgBDUCAEIKfiAgQiCIfCIgPgIAICBCIIghISABQRBqIQEgCEEEayIIDQALCyAHBEADQCABIAE1AgBCCn4gIXwiID4CACABQQRqIQEgIEIgiCEhIAdBAWsiBw0ACwsgIEKAgICAEFQEQCAGIQwMAQsgBkEoRg0WIANBpAFqIAZBAnRqICE+AgAgBkEBaiEMCyADIAw2AsQCAkAgC0UEQEEAIQsMAQsgC0EBa0H/////A3EiAUEBaiIGQQNxIQcCQCABQQNJBEAgA0HIAmohAUIAISAMAQsgBkH8////B3EhCCADQcgCaiEBQgAhIANAIAEgATUCAEIKfiAgfCIgPgIAIAFBBGoiBiAGNQIAQgp+ICBCIIh8IiA+AgAgAUEIaiIGIAY1AgBCCn4gIEIgiHwiID4CACABQQxqIgYgBjUCAEIKfiAgQiCIfCIhPgIAICFCIIghICABQRBqIQEgCEEEayIIDQALCyAHBEADQCABIAE1AgBCCn4gIHwiIT4CACABQQRqIQEgIUIgiCEgIAdBAWsiBw0ACwsgIUKAgICAEFQNACALQShGDRYgA0HIAmogC0ECdGogID4CACALQQFqIQsLIAMgCzYC6AMgESAFIAUgEUkbIgZBKE0NAAsLIAZBKEGQjIoBELA7AAsgA0EBELYGGiADKAKMBSIBIAMoAqABIgYgASAGSxsiAUEpTw0DIAFBAnQhASADQQRrIQYgA0HoA2ohBANAIAFFDQ0gASAEaiEFIAEgBmogAUEEayEBKAIAIgcgBSgCACIFRg0ACyAFIAdNDQ0MDgsgBkEoQZCMigEQsDsACyAKQShBkIyKARCwOwALQRFBEUHw2YkBEMMhAAsMDQsgBUEoQZCMigEQsDsACwwLCwwLC0Gg2okBQTdB2NqJARCfKQALQejaiQFBNkGg24kBEJ8pAAtBhNmJAUEcQaDZiQEQnykAC0HU2IkBQR1B9NiJARCfKQALQajYiQFBHEHE2IkBEJ8pAAsgAQ0BCyACIAlqIQRBACEHQX8hAQJAAkACQANAIAEgDEYNASABQQFqIQEgByANaiAHQQFrIgYhBy0AAEE5Rg0ACyAGIAxqIgEgAmpBAWoiBCAELQAAQQFqOgAAIAFBAmoiASAJTQ0BIAEgCUHA6okBEK87AAsgAkExOgAAIAwEQCACQQFqQTAgDPwLAAsgCUERTw0BIARBMDoAACAPQQFqIQ8gDEECaiEJDAILIAZBf0YNASAGQX9zIgFFDQEgBiANakECakEwIAH8CwAMAQsgCUERQYDaiQEQwyEACyAJQRFNBEAgACAPOwEIIAAgCTYCBCAAIAI2AgAgA0GgCmokAA8LIAlBEUGQ2okBELA7AAsgBEEoQZCMigEQsDsAC0GgjIoBQRpBkIyKARCfKQALIAFBKEGQjIoBELA7AAtBKEEoQZCMigEQwyEAC+Y5Ag5/A34jAEGQBWsiAyQAIAMgAjoALyABLQBAIQggASgCPCEEIAEoAjghCQJ/QQAgASgCDCILRQ0AGiABQRBqQZzZzwBBEBDRDCERIAEoAgAiBkEYayEMIAEoAgQiCiARp3EhBSARQhmIQv8Ag0KBgoSIkKDAgAF+IRMDQAJAIAUgBmopAAAiEiAThSIRQn+FIBFCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiEVBFBEADQEGc2c8AQRAgDEEAIBF6p0EDdiAFaiAKcWsiDUEYbGoQnzYNAiARQgF9IBGDIhFQRQ0ACwtBACASIBJCAYaDQoCBgoSIkKDAgH+DUEUNAhogBSAOQQhqIg5qIApxIQUMAQsLIANByARqIAYgDUEYbGoiB0EIaygCACAHQQRrKAIAEM8KIAMoAswEIQcgAy0AyARBf3NBAXELIQZBLCEFAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAoQQFrDigBAgMEBQYHCAkKCwwaDRscDg8QERIRExQUFR4WHR4WHxcYICAgICEZAAsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EJOgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwtCyADQQA7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCwLIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBAToA0gQgA0GIEDsB0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMKwsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EBOgDSBCADQYggOwHQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwqCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCkLIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMKAsgA0EBOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EAOgDSBCADQYgQOwHQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwnCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQA6ANIEIANBiCA7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCYLIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0gQgA0GIwAA7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCULIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0gQgA0GIgAE7AdAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCQLIANBBzsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQoKAgIBwNwLkBCADQQ06ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCMLIANBBDsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMIgsgA0EFOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwhCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQU6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDCALIAFBKWohBSALRQ0dIAFBEGpB9N7PAEEPENEMIREgASgCACILQRhrIQwgASgCBCIKIBGncSEBIBFCGYhC/wCDQoGChIiQoMCAAX4hE0EAIQIDQCABIAtqKQAAIhIgE4UiEUJ/hSARQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhFQRQRAA0BBAUH03s8AQQ8gDCAReqdBA3YgAWogCnFBaGxqEJ82DSEaIBFCAX0gEYMiEVBFDQALCyASIBJCAYaDQoCBgoSIkKDAgH+DUEUNHiABIAJBCGoiAmogCnEhAQwACwALIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMHgsgA0GHLDsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQoyAgIBwNwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDB0LIANBBjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMHAsgA0EHOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQn83AugEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAMgASgCLDYC5AQgACADQcgEahDlAQwbCyADQQY7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQRE6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDBoLIANBBjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBADoA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMGQsgA0EGOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EAOgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwYCyADQQA2AtgEIANBATYCzAQgA0GA4c8ANgLIBCADQgQ3AtAEIANByARqQYjhzwAQ7ywACyADQQA2AtgEIANBATYCzAQgA0Hw4c8ANgLIBCADQgQ3AtAEIANByARqQfjhzwAQ7ywACyADQfwEaiABQTRqEN0gIANB8ARqIAFBKGoQwwYgASkDICERIAEtAEEhAiADQcgEaiIEIAEQsS4gAyACOgCJBSADIBE3A+gEIAMgCDoAiAUgA0HoAmoiAiABKAIwEMMGIANBgARqIgEgBCACEKQrIAAgASADLQAvEJUBIAEQgy8MFQsgA0HIBGpBNUEAQQFBARCgGCADKALMBCEBIAMoAsgEQQFGDQggAygC0AQiAkH44s8AQTX8CgAAIABBNTYCFCAAIAI2AhAgACABNgIMIABBAzYCCCAAQQE2AgAMFAsgAS0AKSICRQ0QIANBAjsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0J/NwLkBCADQQc6ANAEIAMgBzYCzAQgAyAGNgLIBCADQX82AuwEIAMgAkEBazoA0QQgAyABKAIsQQBHIAEoAjBBAEdxOgDSBCAAIANByARqEOUBDBMLIAJFBEAgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwTCyADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADQQU6ANAEIAMgBzYCzAQgAyAGNgLIBCAAIANByARqEOUBDBILIAEtACkiC0UNDQJ/QQAhBQJAIAEoAgxFDQAgAUEQakH03s8AQQ8Q0QwhESABKAIAIgxBGGshDSABKAIEIgogEadxIQIgEUIZiEL/AINCgYKEiJCgwIABfiETA0AgAiAMaikAACISIBOFIhFCf4UgEUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIRUEUEQANAQQFB9N7PAEEPIA0gEXqnQQN2IAJqIApxQWhsahCfNg0EGiARQgF9IBGDIhFQRQ0ACwsgEiASQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAFQQhqIgVqIApxIQIMAAsAC0EACyECIAtBAUYEQCADQQE7APEEIAMgCDoA8AQgAyAENgLgBCADIAk2AtwEIANBfzYC7AQgA0J/NwLkBCADIAI6ANIEIANBBjsB0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMEgsgAyABQSlqNgLoAiADQQE2AswEIANByN/PADYCyAQgA0IBNwLUBCADQaoINgKEBCADIANBgARqNgLQBCADIANB6AJqNgKABCADQcgEakHQ388AEO8sAAtBMCEFCyABIAVqKAIAIQEgAkUNBiABKAJAIAEoAkRBvODPAEEHEMEuDQYgA0HIBGoiAiABQQhqEO0oIANBgARqIgEgAkG84M8AQQcQshsgAiABIAMtAC8QlQEgAygCyAQEQCADQcQAaiADQeAEaikDACIRNwIAIANBPGogA0HYBGopAwAiEjcCACADIAMpA9AEIhM3AjQgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIAEQgy8MEAsgA0EwaiIBIANByARqQQRyQTT8CgAAIAEQ5SkhASADQYAEahCDLwwHCyADQRBqIAFBLGoiARDDNCADKAIURQ0DIANBCGogARDDNCADKAIMIQEgAyADKAIIIgI2AoAEIAMgAiABQQJ0ajYChAQgAyADQS9qNgKIBCADQcgEaiEKIwBBQGoiAiQAIAJBCDYCCCACQThqIANBgARqIgFBCGooAgA2AgAgAiABKQIANwMwIAIgAkEIajYCPCACQSRqIQ0jAEEwayIBJAAgAUEIaiACQTBqIgUgAUEgaiILIAUoAgwQ4hICQAJAAkACQCABKAIIQQFxRQ0AIAEoAgwiDkUNACALQQRBAEEEQQQQoBggASgCJCEMIAEoAiBBAUYNAiABKAIoIg8gDjYCACABQRxqIhBBATYCACABIA82AhggASAMNgIUIAFBKGogBUEIaikCADcDACABIAUpAgA3AyAgAUEUaiEMIwBBIGsiBSQAIAVBEGogCyAFQR9qIAsoAgwQ4hICQCAFKAIQQQFxRQ0AIAUoAhQiD0UNAANAIAwoAggiDiAMKAIARgRAIAwgDkEBQQRBBBDQKAsgDCgCBCAOQQJ0aiAPNgIAIAwgDkEBajYCCCAFQQhqIAsgBUEfaiALKAIMEOISIAUoAghBAXFFDQEgBSgCDCIPDQALCyAFQSBqJAAgDUEIaiAQKAIANgIAIA0gASkCFDcCAAwBCyANQQA2AgggDUKAgICAwAA3AgALIAFBMGokAAwBCyAMIAEoAihByJfPABD9LwALAkAgAigCCEEIRwRAIAogAikDCDcDACAKQRBqIAJBGGopAwA3AwAgCkEIaiACQRBqKQMANwMAIA0QoicgDUEEQQQQ4B4MAQsgCiACKQIkNwIEIApBCDYCACAKQQxqIAJBLGooAgA2AgALIAJBQGskACADQfACaiIBIANB1ARqKAIANgIAIAMgAykCzAQ3A+gCIAMoAsgEIgJBCEcEQCADKQPYBCERIAAgAykD6AI3AgwgACARNwMYIAAgAjYCCCAAQQE2AgAgAEEUaiABKAIANgIADA8LIANBgAJqIAEoAgA2AgAgAyADKQPoAjcD+AEgA0EDOwHwBCADIAQ2AuwEIAMgCTYC6AQgA0EROgDcBCADQQA2AtgEIANCgICAgMAANwLQBCADQQA2AsgEIANBgARqIANByARqIANB+AFqEM4jIANB0AJqIANBmARqKQIANwMAIANByAJqIgEgA0GQBGopAgA3AwAgA0HAAmoiAiADQYgEaikCADcDACADQYQDaiADQdQCaigCADYCACADIAMpAoAENwO4AiADIAg6AJADIAMgAy0AqQQ6AJEDIAMgAykCoAQ3AogDIAMgAykCzAI3AvwCIANB+AJqIAEoAgA2AgAgAyACKQMANwLwAiADIAc2AuwCIAMgBjYC6AIgACADQegCahDCDgwOC0F/IQUCf0EBIAEtACkiAkECa0H/AXFBCEkNABpBAiACQRNJDQAaRAAAAAAAACRAIAIQ3iBEAAAAAAAA8D+gEOcPRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMhBUEHCyEKIANBADoA8gQgAyAKOgDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADIAI2AugEIAMgBTYC5AQgAyACNgLYBCADQQQ6ANAEIAMgBzYCzAQgAyAGNgLIBCADIAEsACoiATYC7AQgAyABNgLUBCAAIANByARqEOUBDA0LIAEoAiwiAS0AMEEgRg0CIANBADYC2AQgA0EBNgLMBCADQfDizwA2AsgEIANCBDcC0AQgAEEMaiADQcgEahCnGCAAQQE2AgAgAEEDNgIIDAwLIAEgAygC0ARB5KPPABD9LwALIANBADYC2AQgA0EBNgLMBCADQcjhzwA2AsgEIANCBDcC0AQgAEEMaiADQcgEahCnGCAAQQE2AgAgAEEDNgIIDAoLIAFBNGohBQJ/IAIEQEGI4s8AIQJBCQwBCyABKAJAIQIgASgCRAshCiADIANBL2o2AoQCIANBIGogBRDDNAJAIAMoAiQEQCADQcgEaiADQYQCakGk4s8AQQMgAygCIBCuCiADKALMBCEBIAMoAsgEIgtBCEcEQCAAIAMpA9AENwMQIABBGGogA0HYBGopAwA3AwAgACABNgIMIAAgCzYCCCAAQQE2AgAMDAsgAyABNgKIAiADQRhqIAUQwzQgAygCHCIFQQJJDQEgA0HIBGogA0GEAmpBuOLPAEEFIAMoAhhBBGoQrgogAygCzAQhBSADKALIBCILQQhHBEAgACADKQPQBDcDECAAQRhqIANB2ARqKQMANwMAIAAgBTYCDCAAIAs2AgggAEEBNgIAIAEgASgCACIAQQFrNgIAIABBAUcNDCADQYgCahCDIAwMCyADQQM7AZADIAMgBDYCjAMgAyAJNgKIAyADQRE6APwCIANBADYC+AIgA0KAgICAwAA3AvACIANBADYC6AJBBEEEEKYvIQQgA0EDOwGoBCADIAo2AqQEIAMgAjYCoAQgA0EROgCUBCADQQA2ApAEIANCgICAgMAANwKIBCADQQA2AoAEQQhBBBCmLyICIAU2AgQgAiABNgIAIANBAjYCoAEgAyACNgKcASADQQI2ApgBIANB1ANqIgEgA0GABGogA0GYAWoQziMgA0ECOgD8AyADQcgEaiABEMIOIAMoAsgEQQFGBEAgA0G0A2ogA0HgBGopAwAiETcCACADQawDaiADQdgEaikDACISNwIAIAMgAykD0AQiEzcCpAMgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIARBBEEEEPg6IANB8AJqIgAQoicgAEEEQQQQ4B4MDAsgA0GgA2oiASADQcgEakEEckE0/AoAACAEIAEQ5Sk2AgAgA0EBNgKcAyADIAQ2ApgDIANBATYClAMgA0G4AmogA0HoAmogA0GUA2oQziMgA0GcAmogA0HIAmooAgA2AgAgAyADKQLAAjcClAIgAyAIOgC0AiADQQE6AKACIAMgBzYCkAIgAyAGNgKMAiADIAMtAOECOgC1AiADIAMpAtgCNwKsAiAAIANBjAJqEMIODAsLQQBBAEGU4s8AEMMhAAtBASAFQajizwAQwyEACyADQcgEaiABQQhqIAIQlQEgAygCyAQEQCADQfgAaiADQeAEaikDACIRNwIAIANB8ABqIANB2ARqKQMAIhI3AgAgAyADKQPQBCITNwJoIABBGGogETcCACAAQRBqIBI3AgAgACATNwIIIABBATYCAAwJCyADQeQAaiICIANByARqQQRyQTT8CgAAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAACyADQQM7AeACIAMgBDYC3AIgAyAJNgLYAiADQRE6AMwCIANBADYCyAIgA0KAgICAwAA3AsACIANBADYCuAJBBEEEEK02IgJFDQEgA0EDOwGoBCADQQQ2AqQEIANBw+DPADYCoAQgA0EROgCUBCADQQA2ApAEIANCgICAgMAANwKIBCADQQA2AoAEQQRBBBCtNiIERQ0CIAQgATYCACADQYQDaiADQZQEaiIBQQhqKAIANgIAIAMgASkCADcC/AIgA0GIBGoiARCiJyABQQRBBBDgHiADQQI7AZADIANBBDYCjAMgA0HD4M8ANgKIAyADQQE2AvgCIAMgBDYC9AIgA0EBNgLwAiADQQA2AugCIANByARqIANB6AJqEMIOIAMoAsgEBEAgA0HYAWogA0HgBGopAwAiETcCACADQdABaiADQdgEaikDACISNwIAIAMgAykD0AQiEzcCyAEgAEEYaiARNwIAIABBEGogEjcCACAAIBM3AgggAEEBNgIAIAJBBEEEEPg6IANBwAJqIgAQoicgAEEEQQQQ4B4MCAsgA0HEAWoiASADQcgEakEEckE0/AoAACACIAEQ5Sk2AgAgA0EBNgKcAyADIAI2ApgDIANBATYClAMgA0GMAmogA0G4AmogA0GUA2oQziMgA0GoAWogA0GcAmooAgA2AgAgAyADKQKUAjcCoAEgAyAIOgDAASADQQI6AKwBIAMgBzYCnAEgAyAGNgKYASADIAMtALUCOgDBASADIAMpAqwCNwK4ASAAIANBmAFqEMIODAcLQQRBPBCjPQALQQRBBBCjPQALQQRBBBCjPQALIANBATsA8QQgAyAIOgDwBCADIAQ2AuAEIAMgCTYC3AQgA0F/NgLsBCADQn83AuQEIANBEToA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QEMAwsgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgA0EROgDQBCADIAc2AswEIAMgBjYCyAQgACADQcgEahDlAQwCC0EACyECQQEhAQJAAkACQCAFLQAAQQJrDgICAQALIAMgBTYC6AIgA0EBNgLMBCADQaTgzwA2AsgEIANCATcC1AQgA0GqCDYChAQgAyADQYAEajYC0AQgAyADQegCajYCgAQgA0HIBGpBrODPABDvLAALQQIhAQsgA0ECOwDxBCADIAg6APAEIAMgBDYC4AQgAyAJNgLcBCADQX82AuwEIANCfzcC5AQgAyACOgDSBCADIAE6ANEEIANBBjoA0AQgAyAHNgLMBCADIAY2AsgEIAAgA0HIBGoQ5QELIANBkAVqJAAL+TMCDX8CfiMAQYAXayICJAACQAJAIAACfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AxAdBAWsOAwYMAAELIABBCGohDSAAQSBqIQsCQCAALQAgQQFrDgQEDAMFAAsgACgCGCEEIAApAxAhDyAAKAIMIQMgACgCCCEFDAELIABBADoAICAAIAAoArAHIgQ2AhggACAAKQMAIg83AxAgACAAKALAByIDNgIMIAAgACgCvAciBTYCCCAAQSBqIQsgAEEIaiENCyAAEOgmNgIcIAJBtAFqIgwgDyAErRDYHyACQZgNaiEGIABBHGojAEHgA2siBCQAIARByAFqIAUgAxC4GUHIt8MAKAIAIQNBxLfDACgCACEJQcC3wwAtAAAhBwJAIAQoAsgBQQJGBEBCAyEPIAQoAswBIQogA0UgB0EKSXINASAJIANBARD4OgwBC0HMt8MAKQIAIQ8gBEGQAmoQ/iwgBEHHA2pBw7fDAC0AADoAACAEIAc6AMQDIAQgDzcD0AMgBCADNgLMAyAEIAk2AsgDIARBwbfDAC8AADsAxQMgBEHQAmogBEHIAWpByAD8CgAAIARBAToA2AMgBEGAlOvcAzYCoAMgBEEANgKoAyAEQoSAgIDwADcCvAMgBCkDkAIhDyAEKAKYAiEKIARBBGogBEGcAmpBxAH8CgAACygCACIDIAMoAgAiCUEBajYCAAJAIAlBAE4EQCAGIAo2AgggBiAPNwMAIAYgAzYC0AEgBkEMaiAEQQRqQcQB/AoAACAEQeADaiQADAELAAsgAkGoAmoiBCAGQaCXwwAgDBCLDiAAQShqIgkgBEGAB/wKAAAgAEEAOgCoByAAQagHaiEKDAcLIABBKGohCSAAQagHaiEKIAAtAKgHQQFrDgMDCAcGC0Gol8MAEOgrAAsgAEEoaiEDIABBhAJqIQYCQCAALQCEAkEBaw4DBAcAEwsgAEH4AWohCSAAQYACaiEFAkAgAC0AgAJBAWsOAwMHFwALIAkoAgAhBAwVC0HYl8MAEOgrAAtBjJbDABDoKwALQdiVwwAQ6CsAC0GclsMAEOgrAAsgAEGAAmogCUHYAfwKAABCAyEPIAAoAogCIQQgACkDgAIiEEIDUQRAIAAoAtADIgYgBigCACIGQQFrNgIAIAZBAUcNDSAAQdADahCdJwwNCyACQdQLaiAAQTRqQcQB/AoAACACIAQ2AtALIAIgEDcDyAsgAkGYDWoiBSAAQdADaiACQcgLahDOEiAAQdgDaiAFQdAD/AoAAAsgAEHYA2ohDAJAAkACQCAALQCkB0EBaw4DAQMCAAsgAEEAOgClByAAQagFaiIFIAxB0AH8CgAAIAAQrz42AvgGIABB+AZqIQdB25HDACEEQQchAwJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A3AZBAWsOCgABAgMEBQYHCAkKC0HikcMAIQRBAyEDDAkLQeWRwwAhBEEEIQMMCAtB6ZHDACEEQQMhAwwHC0HskcMAIQRBBiEDDAYLQfKRwwAhBEEEIQMMBQtB9pHDACEEQQUhAwwEC0H7kcMAIQQMAwtBgpLDACEEQQUhAwwCCyACQZgBaiAAQd0GahD/LCACKAKcASEDIAIoApgBIQQMAQsgAkGgAWogAEHgBmoQ1zsgAigCpAEhAyACKAKgASEECyAHIAQgAxDtOiACQZABahDTJSACKAKUASEEAkAgAigCkAFBAXFFDQAgAkGIAWogBBCEGSACKAKMASEEIAIoAogBIgZFDQAgBiAEEPo6IQQMCgsgACAENgL8BiAAQQE6AKUHIAJB2BVqIAUQ+y4gAkHwEmogAkHgFWopAgA3AwAgAiACKQLYFTcD6BIgAkGAAWogAkHoEmoQ7RIgAigCgAEiBARAIABB/AZqIQggAigChAEhBgNAAkAgBCgCAARAIAQoAgghBSAEKAIEIQMMAQtBBiEFQeyIwwAhAwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0ABEEBaw5QAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QC0EOIQVB8ojDACEDDE8LQQ8hBUGAicMAIQMMTgtBDyEFQY+JwwAhAwxNC0ENIQVBnonDACEDDEwLQSAhBUGricMAIQMMSwtBHCEFQcuJwwAhAwxKC0EcIQVB54nDACEDDEkLQRshBUGDisMAIQMMSAtBHSEFQZ6KwwAhAwxHC0EWIQVBu4rDACEDDEYLQR4hBUHRisMAIQMMRQtBHSEFQe+KwwAhAwxEC0EDIQVBjIvDACEDDEMLQQUhBUGPi8MAIQMMQgtBByEFQZSLwwAhAwxBC0ENIQVBm4vDACEDDEALQQ0hBUGoi8MAIQMMPwtBDCEFQbWLwwAhAww+C0ERIQVBwYvDACEDDD0LQQohBUHSi8MAIQMMPAtBEyEFQdyLwwAhAww7C0EQIQVB74vDACEDDDoLQRAhBUH/i8MAIQMMOQtBDiEFQY+MwwAhAww4C0EQIQVBnYzDACEDDDcLQQ0hBUGtjMMAIQMMNgtBFyEFQbqMwwAhAww1C0EjIQVB0YzDACEDDDQLQQwhBUH0jMMAIQMMMwtBgI3DACEDDDILQQMhBUGGjcMAIQMMMQtBBCEFQYmNwwAhAwwwC0EEIQVBjY3DACEDDC8LQZGNwwAhAwwuC0EHIQVBl43DACEDDC0LQQkhBUGejcMAIQMMLAtBBCEFQaeNwwAhAwwrC0EEIQVBq43DACEDDCoLQQghBUGvjcMAIQMMKQtBESEFQbeNwwAhAwwoC0ENIQVByI3DACEDDCcLQQghBUHVjcMAIQMMJgtBEyEFQd2NwwAhAwwlC0ENIQVB8I3DACEDDCQLQQQhBUH9jcMAIQMMIwtBCCEFQYGOwwAhAwwiC0EMIQVBiY7DACEDDCELQZWOwwAhAwwgC0GbjsMAIQMMHwtBEiEFQaGOwwAhAwweC0ETIQVBs47DACEDDB0LQQ8hBUHGjsMAIQMMHAtBGyEFQdWOwwAhAwwbC0EFIQVB8I7DACEDDBoLQQchBUH1jsMAIQMMGQtBDyEFQfyOwwAhAwwYC0EHIQVBi4/DACEDDBcLQQshBUGSj8MAIQMMFgtBFCEFQZ2PwwAhAwwVC0EYIQVBsY/DACEDDBQLQREhBUHJj8MAIQMMEwtBFiEFQdqPwwAhAwwSC0EVIQVB8I/DACEDDBELQYWQwwAhAwwQC0EKIQVBi5DDACEDDA8LQRkhBUGVkMMAIQMMDgtBAiEFQa6QwwAhAwwNC0EHIQVBsJDDACEDDAwLQREhBUG3kMMAIQMMCwtBCiEFQciQwwAhAwwKC0EHIQVB0pDDACEDDAkLQRkhBUHZkMMAIQMMCAtBBCEFQfKQwwAhAwwHC0EDIQVB9pDDACEDDAYLQQchBUH5kMMAIQMMBQtBECEFQYCRwwAhAwwEC0EWIQVBkJHDACEDDAMLQRYhBUGmkcMAIQMMAgtBDyEFQbyRwwAhAwwBC0EQIQVBy5HDACEDCyACQfgAaiAGEOMgIAIoAngiBEUEQCACENUpIQQMCwsgAkHwAGogCCADIAUgBCACKAJ8ELooAkAgAigCcEEBcUUNACACQegAaiACKAJ0EIQZIAIoAmgiBEUNACAEIAIoAmwQ+johBAwLCyACQeAAaiACQegSahDtEiACKAJkIQYgAigCYCIEDQALCyAAQQA6AKUHIAIgACgC/AY2AugSIAcgAkHoEmoQ7DogAigC6BIiBEGEAU8EQCAEEPIfCyAALQDwBkUEQCAHEKU7CyAAKALUBiIEQQRHBEAgByAEEKQ7CyAAKALYBiIEQQdHBEAgByAEEJI9CyAAKALABkEBRw0EIABBxAZqIgQQ5igNBCACQdgAaiAEEMohIAIoAlwhBCACKAJYQQFxDQggAiAENgLoEiAHIAJB6BJqEMwtIAIoAugSIgRBhAFJDQQgBBDyHwwEC0GglMMAEOgrAAsgAEGYB2ohBCAAQaAHaiEHAkAgAC0AoAdBAWsOAwIBBQALIAQoAgAhAwwDCwALQdiVwwAQ6CsACyACQegSahCZHyACKALsEiEEIAIoAugSDQMgAkHgFWogAkH4EmopAgAiDzcDACACIAIpAvASIhA3A9gVIAAgBDYCgAcgACAQNwKEByAAQYwHaiAPNwIAIABBgAdqIQQgACgCuAYiBkGAlOvcA0cEQCAEIAApA7AGIAYQzRELIAIgBBDROzYC6BIgByACQegSahDNLSACKALoEiIEQYQBTwRAIAQQ8h8LIAJB0ABqIAAoAvwFIAAoAoAGIAcQgCQgAigCVCEEAkAgAigCUEEBcUUNACACQcgAaiAEEIQZIAIoAkwhBCACKAJIIgZFDQAgBiAEEPo6IQQMAwsgACAENgKUByAAQZQHahCMFyEDIABBADoAoAcgACADNgKYByAAQaAHaiEHIABBmAdqIQQLIAAgAxD7DjYCnAcLIAJBQGsgAEGcB2oiAyABEMcYAkACQAJAAkACQAJAAkACQAJAIAIoAkAiBUECRwRAIAIoAkQhBiADKAIAIgggCCgCAEEBayIINgIAIAhFBEAgAxCyGgsCQAJAAkAgBUEBcUUNACACQThqIAYQhBkgAigCPCEGIAIoAjgiA0UNACAGIQUMAQsgAiAGNgLoEiACQegSaiIDEKM7DQEgA0EjQQBBAUEBEKAYIAIoAuwSIQUgAigC6BJBAUYNAyACKALwEiIIQeiVwwBBI/wKAABBDEEEEK02IgNFDQQgA0EjNgIIIAMgCDYCBCADIAU2AgBBvJLDACEFIAZBhAFJDQAgBhDyHwsgB0EBOgAAIAQQ5CggAiAFNgLUEyACIAM2AtATIAJBADYC4BUgAkKAgICAEDcC2BUgAkGQh8MANgLsEiACQqCAgIAONwLwEiACIAJB2BVqNgLoEiACQdATaiACQegSahCDNg0EIAJBqBRqIAJB4BVqKAIAIgQ2AgAgAiACKQLYFTcDoBQgAigCpBQgBEGylcMAQSQQwS4hBCACQaAUahDeOwJ/IARFBEAgAigC0BMhAyACKALUEwwBCyACQdATahC8KkEBIQNBoLPDAAshBEEBIAIgAyAEENgpIQQgACgClAciBkGEAUkNCyAGEPIfDAsLIAdBAToAACAEEOQoIAIgBjYCxBEgAkHoEmoiBBDZKSACQcgRaiAEIAJBxBFqIgMQjz0Q4BIgAkGgFGoiByADEOImIAIoAqgUIQggAigCpBQhDiACQQA2AuAVIAJBADYC2BUgAkEANgLoFSAEIAJB2BVqIA4gCBC8GiACKALoEkECRg0EIAJBkBJqIARByAD8CgAAIAcQ3jsgAiADEJA9NgLYEiAEIAJB2BJqEMcSIAItAOwSIgRBA0YNBSAEQQJGDQYgAigC6BIhAyACIAQ6AOASIAIgAzYC3BIgAkEwaiACQdwSahD8KSACKAIwIgRBAkcEQCACQeQVaiEFIAIoAjQhAwNAIARBAXENCSACIAM2AuQSIAJBKGogAkHkEmoQyCQgAigCKEEBcQ0KIAJBuBZqIgcgAigCLBCrKyACQaAUaiIEIAIoArwWIAIoAsAWEJA1IAJB6BJqIgMgBBDIEyACKALoEkGAgICAeEYNCyACQegVaiACQfgSaikCADcDACACQeAVaiACQfASaikCACIPNwMAIAIgAikC6BIiEDcD2BUgAkHYE2ogDz4CACACIBA3A9ATIAJBqBRqIAVBCGooAgA2AgAgAiAFKQIANwOgFCADIAJByBFqIghByAD8CgAAIAggAyACQdATaiIDIAQQsA0gBBDeOyADEN47IAcQ3jsgAigC5BIiBEGEAU8EQCAEEPIfCyACQSBqIAJB3BJqEPwpIAIoAiQhAyACKAIgIgRBAkcNAAsLIAIoAtwSIgRBhAFPBEAgBBDyHwsgAi0A0REhBCACLQDQESEDAkACQAJAIAIpA8gRIg9CA1EEQCAGQYQBTwRAIAYQ8h8LIAJBoBRqIAJBkBJqQcgA/AoAACACQfgUaiAAQZAHaigCADYCACACQfAUaiAAQYgHaikCADcCACACIAApAoAHNwLoFCACQbAUaiIFEN47IAJB6BRqEL0oDAELIAIgBDoA2RMgAiADOgDYEyACIA83A9ATIAJB2hNqIAJB0hFqQT78CgAAIAIgBjYCmBQgAkGgFGogAkGQEmpByAD8CgAAIAJB+BRqIABBkAdqKAIANgIAIAJB8BRqIABBiAdqKQIANwIAIAIgACkCgAc3AugUIAJB2BVqIAJBoBRqQdwA/AoAACACQbgWaiIEIAJBkBJqQcgA/AoAACACQegSaiACQdATaiAEIAJBoBZqEJMgIAIpA+gSIg9CA1INASACLQDxEiEEIAItAPASIQMLQgMhD0EBIAIgAyAEEKweIQQMAQsgAigC8BIhBCACQfwUaiACQfQSakHcAPwKAAALIAIoAtgSIgZBhAFPBEAgBhDyHwsgACgClAciBkGEAU8EQCAGEPIfCyAAQQA6AKUHIAAoAvgGIgNBhAFJDQ4MDQsgAEEDOgCgByAAQQM6AKQHDBELIAUgAigC8BJBvJbDABD9LwALQQRBDBCjPQALQbiHwwBBNyACQaAUakGoh8MAQfCHwwAQ1R4AC0GwlMMAQQkQlz0AC0G5lMMAQRAQlz0AC0HJlMMAQRgQlz0AC0HhlMMAQR4Qlz0AC0H/lMMAQRIQlz0AC0GRlcMAQSEQlz0ACyAAQYAHahC9KAsgAC0ApQdFDQAgACgC/AYiBkGEAUkNACAGEPIfCyAAQQA6AKUHQgMhDyAAKAL4BiIDQYMBSw0AIABBqAVqEKkeIABBAToApAcMAgsgAxDyHwsgAEGoBWoQqR4gAEEBOgCkByAPQgRRDQMLIAJB6BBqIAJB/BRqQdwA/AoAACAMEM0kIAAoAtADIgYgBigCACIGQQFrNgIAIAZBAUcNACAAQdADahCdJwsgAkGoCWogAkHoEGpB3AD8CgAAIApBAToAACACQYQKaiIGIAJBqAlqQdwA/AoAACAJEKoeIA9CA1ENCCACQewKaiAGQdwA/AoAACACIAQ2AugKIAIgDzcD4AogAkHAAWogAkHgCmoQkRMgAigCyAEhBCACKQPAASIPQgNRDQggAkGYDWogAkHMAWpB3AD8CgAAIAAgBDYCMCAAIA83AyggAEE0aiACQZgNakHcAPwKAAAgAEGQAWogAkGoAmpB9AD8CgAAIABBADoAhAIgAEEoaiEDIABBhAJqIQYLIABBkAFqIANB6AD8CgAAIAJBGGogAEHYAWoQxyQgAigCHCEEIAIoAhhBAXFFDQEgAkEQaiAEEIQZIAIoAhQhBCACKAIQIgVFDQFBBSACIAUgBBDYKSEEDAYLIApBAzoAAEEDDAMLIABBADoAgAIgACAENgL4ASAAQYACaiEFIABB+AFqIQkLIAAgBBD7DjYC/AELIAJBCGogAEH8AWoiBCABEMcYIAIoAggiAUECRwRAIAIoAgwhBiAEKAIAIgcgBygCAEEBayIHNgIAIAdFBEAgBBCyGgsCQCABQQFxRQ0AIAIgBhCEGSACKAIEIQYgAigCACIBRQ0AIAVBAToAACAJEOQoQQUgAiABIAYQ2CkhBAwECyAFQQE6AAAgCRDkKCACIAY2AvwUIAIgAkH8FGoQlD02AtgVIAJBwAFqIgEgAkHYFWoiBBCWPUGslsMAEM4YIAQgAigCxAEgAigCyAEQgyQgAkHIC2ogARDnFSACKQLQCyEPIAIoAswLIQEgAigCyAshBiACKALYFSIEQYQBTwRAIAQQ8h8LIAIoAvwUIgRBhAFPBEAgBBDyHwsgAEGQAWoQoSUgAEEBOgCEAiADENItIAZFBEAgASEEDAULIAIgATYC7BIgAiAGNgLoEiACIA83AvASIAJByAtqIA+nIgVBAEEBQQEQoBggAigCzAshAyACKALIC0EBRg0CIAIoAtALIQQgBQRAIAQgASAF/AoAAAsgAkH0EmogASAFIAYoAhARAQAgACgCHCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEcaiEGDAULIAVBAzoAACAGQQM6AABBBAshACALIAA6AABBASEDQQMMBQsgAyACKALQC0G8lsMAEP0vAAsgAEGQAWoQoSUgAEEBOgCEAiADENItCyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRxqIQZBgICAgHghAwwBCyALQQE6AAAgDRCcJwwECyAGEJ0nCyALQQE6AAAgDRCcJyADQYCAgIB4Rg0CIAIgBTYCsAEgAiAENgKsASACIAM2AqgBIAJBmA1qIAAoArQHIAJBqAFqEMUmIAIoApgNQYCAgIB4Rw0BIABBuAdqEN47QQAhA0EBCzoAxAcgAkGAF2okACADDwsgAkGwAmogAkGgDWooAgA2AgAgAiACKQKYDTcDqAJBoIjDAEErIAJBqAJqQdyIwwBB+JfDABDVHgALIAIgBDYCqAJBoIjDAEErIAJBqAJqQcyIwwBB6JfDABDVHgALqjICIH8BfiMAQcAEayIFJAAgBUGABGogASAEEN0QIAUoAogEIRggBSgChAQhBwJAIAUoAoAEIgRBioCAgHhHBEAgACAFKQKMBDcCDCAAQRxqIAVBnARqKQIANwIAIABBFGogBUGUBGopAgA3AgAgACAYNgIIIAAgBzYCBCAAIAQ2AgAMAQsgB0EBcQRAIAVBgARqIAEoAgAiEiAYEJMOIAUoAoQEIQcCQCAFKAKABCIEQYqAgIB4RwRAIAVB/ANqIAVBoARqKAIANgIAIAVB9ANqIAVBmARqKQIANwIAIAVB7ANqIAVBkARqKQIANwIAIAUgBSkCiAQ3AuQDIAUgBzYC4AMgBSAENgLcAwwBCyAFQYAEaiEKIwBBMGsiCCQAIAhBDGogEkF/IAcgGGoiBCAEIAdJGyIHEJMOIAgoAhAhCQJAIAgoAgwiBEGKgICAeEcEQCAKIAgpAhQ3AgggCkEgaiAIQSxqKAIANgIAIApBGGogCEEkaikCADcCACAKQRBqIAhBHGopAgA3AgAgCiAJNgIEIAogBDYCAAwBC0F/IAdBBGoiBCAEIAdJGyIGQQNxBEAgCiAGNgIcIApBxwA2AhggCkGf4/4ANgIUIApBgICAgHg2AhAgCkIENwIIIApChICAgAg3AgAMAQsCQAJAQX8gBkF/IAlBAnQgCUH/////A0sbIgdqIgQgBCAGSRsiCSASKAIETQRAIBIgEigCFCAHaiIENgIUQYiAgIB4IQcgBCASKAIIKAIISw0BDAILIAhBDGogBiAJEL8vIAgoAgwiB0GKgICAeEYNAQsgCiAIKQIQNwIEIApBHGogCEEoaikCADcCACAKQRRqIAhBIGopAgA3AgAgCkEMaiAIQRhqKQIANwIAIAogBzYCAAwBCyAKIAk2AgggCiAGNgIEIApBioCAgHg2AgALIAhBMGokACAFKAKIBCEJIAUoAoQEIQQgBSgCgAQiB0GKgICAeEcEQCAFQfgDaiAFQZwEaikCADcCACAFQfADaiAFQZQEaikCADcCACAFIAUpAowENwLoAyAFIAk2AuQDIAUgBDYC4AMgBSAHNgLcAwwBCyAJIARrIgdBACAHIAlNGyIHQQJ2IAdBA3FBAEdqIgcEQCAEQX9zIRlBACAHayEkIAVBiAFqIRwgBUH8AGohHSAFQcABaiEeIAVBsAFqIR8gBUHUAmohICAFQfADaiEOIAVBlARqIQ0gBUH4AmohECAFQYQEaiEbIAVB6AJqISEgBUHsAmohGiAFQYgEaiERIAVB4ANqISIgBUHkAGohDyAFQdgAaiETIAVB1ABqIRQDQCAFQYAEaiASIAQQkw4gBSgChAQhCQJAIAUoAoAEIgdBioCAgHhHBEAgEyARKQIANwIAIBNBGGogEUEYaigCADYCACATQRBqIBFBEGopAgA3AgAgE0EIaiARQQhqKQIANwIAIAUgCTYCVCAFIAc2AlAMAQsgBUGABGogEiAJIBkgCSAZSRsgBGoQtAYgBUH4AWoiCSAbQQhqIgopAgA3AwAgBSAbKQIANwPwASAFKAKABCIHQYqAgIB4RwRAIA8gDSkCADcCACAPQQhqIA1BCGopAgA3AgAgFEEIaiAJKQMANwIAIBQgBSkD8AE3AgAgBSAHNgJQDAELIAVBiAJqIAkpAwA3AwAgBSAFKQPwATcDgAIgBUHcA2ogBUGAAmpB7ef+AEEEQQQQrQggBUHoAWoiCSAiQQhqKQIANwMAIAUgIikCADcD4AEgBSgC3AMiB0GKgICAeEcEQCAPIA4pAgA3AgAgD0EIaiAOQQhqKQIANwIAIBRBCGogCSkDADcCACAUIAUpA+ABNwIAIAUgBzYCUAwBCyAFQZgCaiAJKQMANwMAIAUgBSkD4AE3A5ACIAVBgARqIAVBkAJqQQYQ3RAgBSgCiAQhDCAFKAKEBCEGAkACfiAFKAKABCIIQYqAgIB4RwRAIAVByAJqIA1BCGopAgA3AwAgBSANKQIANwPAAiAFKQKMBAwBCyAGQQFxRQ0BAkAgDEEBaiIHQX8gBxsiByAFKAKQAiIJKAIETQRAIAkgCSgCFEEBaiIHNgIUIAkoAggoAgggB08EQCAFQYqAgIB4NgKABAwCCyAFQYiAgIB4NgKABAwBCyAFQYAEaiAMIAcQvy8LIAVBCDYC9AIgBUHx5/4ANgLwAiAFQYCAgIB4NgLsAiAFIAw2AugCIAVBATYC5AIgBUHcA2ogBUGABGogBUHkAmoQgRQgBSgC3AMiCEGKgICAeEYNASAFQcgCaiAOQQhqKQIANwMAIAUgDikCADcDwAIgBSgC5AMhDCAFKALgAyEGIAUpAugDCyElIA8gBSkDwAI3AgAgD0EIaiAFQcgCaikDADcCACAFICU3AlwgBSAMNgJYIAUgBjYCVCAFIAg2AlAMAQsgBSAFKQOYAjcCqAIgBSAFKQOQAjcCoAIgBUGABGogBUGgAmpBChDdECAFKAKIBCEIIAUoAoQEIQYCfyAFKAKABCIMQYqAgIB4RwRAIAUoAqAEIQsgBSgCnAQhFSAFKAKYBCEWIAUoApQEIRcgBSgCkAQhCiAFKAKMBAwBCyAFQYAEaiAFQaACakEIEN0QIAUoAogEIQkgBSgChAQhByAFKAKABCIMQYqAgIB4RwRAIAUoAqAEIQsgBSgCnAQhFSAFKAKYBCEWIAUoApQEIRcgBSgCkAQhCiAHIQYgCSEIIAUoAowEDAELAkACQAJ+AkACQAJ+AkACQAJAAkACQAJAIAdBAXEEQCAGQQFxRQ0MIAlBAWoiB0F/IAcbIgcgBSgCoAIiBigCBEsNASAGIAYoAhRBAWoiBzYCFCAGKAIIKAIIIAdPBEAgBUGKgICAeDYCgAQMAwsgBUGIgICAeDYCgAQMAgsgBkEBcQ0LDAILIAVBgARqIAkgBxC/LwsgBUEJNgL0AiAFQfnn/gA2AvACIAVBgICAgHg2AuwCIAUgCTYC6AIgBUEBNgLkAiAFQdwDaiAFQYAEaiAFQeQCahCBFCAFKALcAyIMQYqAgIB4RwRAIAUoAvwDIQsgBSgC+AMhFSAFKAL0AyEWIAUoAvADIRcgBSgC7AMhCiAFKALkAyEIIAUoAuADIQYgBSgC6AMMCwsgCSAFKAKgAiIGKAIEIgdLDQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGKAIAIAlqLQAAQQFrDhoBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGgALIAVBioCAgHg2AtwDDBoLIAVB3ANqIAZBqOj+AEEKIAgQqBAMGQsgBUGABGoiByAGIAgQ+AYgBUEJNgLQAiAFQbLo/gA2AswCIAVBgICAgHg2AsgCIAUgCDYCxAIgBUECNgLAAiAFQdwDaiAHIAVBwAJqEIEUDBgLIAVB3ANqIAYgCBDeCAwXCyAFQdwDaiAGQc7o/gBBDCAIEKgQDBYLIAVB3ANqIAZB2uj+AEEKIAgQqBAMFQsgBUHcA2ogBkHk6P4AQQogCBCoEAwUCyAFQdwDaiAGIAgQogMMEwsgBUHcA2ogBkH76P4AQQogCBDfCAwSCyAFQdwDaiAGIAgQlQYMEQsgBUHcA2ogBiAIEOMHDBALIAVB3ANqIAZBnun+AEEOIAgQ3wgMDwsgBUHcA2ogBkGs6f4AQQogCBCoEAwOCyAFQdwDaiAGQbbp/gBBDSAIEKgQDA0LIAVB3ANqIAYgCBCpBQwMCyAFQdwDaiAGIAgQ4AgMCwsgBUHcA2ogBiAIEN0IDAoLIAVB3ANqIAYgCBCCCQwJCyAFQdwDaiAGQf/p/gBBDiAIEN8IDAgLIAVB3ANqIAZBjer+AEERIAgQqBAMBwsgBUHcA2ogBkGe6v4AQQ8gCBCoEAwGCyAFQdwDaiAGQa3q/gBBDyAIEKgQDAULIAVB3ANqIAZBvOr+AEETIAgQqBAMBAsgBUHcA2ogBkHP6v4AQRAgCBCoEAwDCyAFQdwDaiAGQd/q/gBBDiAIEKgQDAILIAVB3ANqIAZB7er+AEEOIAgQqBAMAQsgBUHcA2ogBkH76v4AQRMgCBCoEAsgBUEFNgKQBCAFQYLo/gA2AowEIAVBgICAgHg2AogEIAUgCDYChAQgBUEBNgKABCAFQeQCaiAFQdwDaiAFQYAEahCBFCAFKALkAiIMQYqAgIB4Rg0AIAUoAoQDIQsgBSgCgAMhFSAFKAL8AiEWIAUoAvgCIRcgBSgC9AIhCiAFKALsAiEIIAUoAugCIQYgBSgC8AIMCgsgBSAFKQKoAjcCuAIgBSAFKQKgAjcCsAIgBUGABGogBUGwAmpBDBDdECAFKAKIBCEMIAUoAoQEIQYgBSgCgAQiCEGKgICAeEcEQCAFQdgBaiANQQhqKQIANwMAIAUgDSkCADcD0AEgBSkCjAQMBwsgBkEBcUUNByAFQYAEaiAFKAKwAiIJIAwQkw4gBSgChAQhBiAFKAKABCIHQYqAgIB4RwRAIBogESkCADcCACAaQRhqIBFBGGooAgA2AgAgGkEQaiARQRBqKQIANwIAIBpBCGogEUEIaikCADcCACAFIAY2AugCIAUgBzYC5AIMBgsgBUGABGogCUF/IAYgDGoiByAGIAdLGxC0BiAFQZADaiIJIAopAgA3AwAgBSAbKQIANwOIAyAFKAKABCIHQYqAgIB4RwRAIBAgDSkCADcCACAQQQhqIA1BCGopAgA3AgAgIUEIaiAJKQMANwIAICEgBSkDiAM3AgAgBSAHNgLkAgwGCyAFQaADaiAJKQMANwMAIAUgBSkDiAM3A5gDIAVBgARqIAVBmANqQQQQ3RAgBSgCiAQhBiAFKAKEBCELIAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAQLIAtBAXFFDQQgBkEHcQRAIAUgBjYCnAQgBUEDNgKYBCAFQbDk/gA2ApQEIAVBgICAgHg2ApAEIAVCBDcCiAQgBUKEgICACDcCgAQMAwtBfyAGQQhqIgcgBiAHSxsiByAFKAKYAyIJKAIESw0BIAkgCSgCFEEIaiIHNgIUIAkoAggoAgggB08EQCAFQYqAgIB4NgKABAwDCyAFQYiAgIB4NgKABAwCCyAJIAdB0OH+ABCvOwALIAVBgARqIAYgBxC/LwsgBUECNgK4BCAFQefm/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQOgAzcCtAMgBSAFKQOYAzcCrAMgBUGABGogBUGsA2pBBhDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQEgBUGABGoiByAFKAKsAyAGEPgGIAVBCTYCuAQgBUHN5/4ANgK0BCAFQYCAgIB4NgKwBCAFIAY2AqwEIAVBATYCqAQgBUHcA2ogByAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQK0AzcCxAMgBSAFKQKsAzcCvAMgBUGABGogBUG8A2pBCBDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQECQCAGQQFqIgdBfyAHGyIHIAUoArwDIgkoAgRNBEAgCSAJKAIUQQFqIgc2AhQgCSgCCCgCCCAHTwRAIAVBioCAgHg2AoAEDAILIAVBiICAgHg2AoAEDAELIAVBgARqIAYgBxC/LwsgBUEJNgK4BCAFQdbn/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSAFKQLEAzcC1AMgBSAFKQK8AzcCzAMgBUGABGogBUHMA2pBChDdECAFKAKIBCEGIAUoAoQEIQsCQAJ+IAUoAoAEIghBioCAgHhHBEAgBUGwBGogDUEIaikCADcDACAFIA0pAgA3A6gEIAUpAowEDAELIAtBAXFFDQECQCAGQQFxBEAgBSAGNgKcBCAFQQM2ApgEIAVBueT+ADYClAQgBUGAgICAeDYCkAQgBUIENwKIBCAFQoSAgIAINwKABAwBC0F/IAZBAmoiByAGIAdLGyIHIAUoAswDIgkoAgRNBEAgCSAJKAIUQQJqIgc2AhQgCSgCCCgCCCAHTwRAIAVBioCAgHg2AoAEDAILIAVBiICAgHg2AoAEDAELIAVBgARqIAYgBxC/LwsgBUEONgK4BCAFQd/n/gA2ArQEIAVBgICAgHg2ArAEIAUgBjYCrAQgBUEBNgKoBCAFQdwDaiAFQYAEaiAFQagEahCBFCAFKALcAyIIQYqAgIB4Rg0BIAVBsARqIA5BCGopAgA3AwAgBSAOKQIANwOoBCAFKALkAyEGIAUoAuADIQsgBSkC6AMLISUgECAFKQOoBDcCACAQQQhqIAVBsARqKQMANwIAIAUgJTcC8AIgBSAGNgLsAiAFIAs2AugCIAUgCDYC5AIMAQsgBSgCzAMiByAHKAIMQQFrNgIMIAVBioCAgHg2AuQCCyAFQQo2ApAEIAVBh+j+ADYCjAQgBUGAgICAeDYCiAQgBSAMNgKEBCAFQQE2AoAEIAVBwAJqIAVB5AJqIAVBgARqEIEUIAUoAsACIghBioCAgHhGDQEgBUHYAWogIEEIaikCADcDACAFICApAgA3A9ABIAUoAsgCIQwgBSgCxAIhBiAFKQLMAgshJSAPIAUpA9ABNwIAIA9BCGogBUHYAWopAwA3AgAgBSAlNwJcIAUgDDYCWCAFIAY2AlQgBSAINgJQDAMLIAUgBSkCuAI3AuQDIAUgBSkCsAI3AtwDIAVBrAFqIAVB3ANqQZHo/gBBCEEOEJcBIAVBoAFqIgkgH0EIaikCADcDACAFIB8pAgA3A5gBIAUoAqwBIgdBioCAgHhHBEAgDyAeKQIANwIAIA9BCGogHkEIaikCADcCACAUQQhqIAkpAwA3AgAgFCAFKQOYATcCACAFIAc2AlAMAwsgESAJKQMANwMAIAUgBSkDmAE3A4AEIAVB9ABqIAVBgARqQRAQ7wMgBSgCeCEJIAUoAnQiB0GKgICAeEcEQCATIB0pAgA3AgAgDyAcKQIANwIAIBNBCGogHUEIaigCADYCACAPQQhqIBxBCGopAgA3AgAgBSAJNgJUIAUgBzYCUAwDCyAJIAkoAgxBAWs2AgwgBUGKgICAeDYCUAwCC0EFIQtBguj+ACEVQQkhF0H55/4AIQpBBCEGQQAhDEEAIQhBgICAgHghFkGAgICAeAshByAFIAs2AnAgBSAVNgJsIAUgFjYCaCAFIBc2AmQgBSAKNgJgIAUgBzYCXCAFIAg2AlggBSAGNgJUIAUgDDYCUAsgBSAENgKIBCAFICM2AoQEIAVBADYCgAQgBUEsaiAFQdAAaiAFQYAEahCBFCAFKAIsIgdBioCAgHhHBEAgBUH4A2ogBUHIAGopAgA3AgAgBUHwA2ogBUFAaykCADcCACAFQegDaiAFQThqKQIANwIAIAUgBSkCMDcC4AMgBSAHNgLcAwwDCyAEQQRqIQQgGUEEayEZICQgI0EBaiIjag0ACwsgBUGKgICAeDYC3AMLIAUgAzYCkAQgBSACNgKMBCAFQYCAgIB4NgKIBCAFIBg2AoQEIAVBATYCgAQgAEEEaiEDIAVBCGogBUHcA2ogBUGABGoQgRQCQCAFKAIIIgJBioCAgHhHBEAgAyAFKQIMNwIAIANBGGogBUEkaikCADcCACADQRBqIAVBHGopAgA3AgAgA0EIaiAFQRRqKQIANwIADAELIAMgASkCADcCACADQQhqIAFBCGopAgA3AgALIAAgAjYCAAwBCyAAQYqAgIB4NgIAIAAgASkCADcCBCAAQQxqIAFBCGopAgA3AgALIAVBwARqJAAL81gCCn8CfiMAQfAEayILJAAgAUEYaiEPIAatIRQCQAJAAkACQAJAAkACQAJAAkAgAS0AGCINRQRAIAQoAggiBiAEKAIARgRAIARBkNL+ABCuKAsgBCgCBCAGQQR0aiIHIBQ3AAggByAUNwAAIAQgBkEBajYCCAwBCyAEKAIIIgogBCgCAEYEQCAEQaDS/gAQrigLIAQoAgQgCkEEdGoiECAHrTcACCAQIBQ3AAAgBCAKQQFqNgIIAkAgDUEoRiANQSFGciAJLgECQQROcQ0AAkACQAJAIAEoAiwEQCALQYgEaiABQSxqEKA2DAELQcAAIQogBkEDdiAGQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgZBwAAQ0TRFDQsgBgRAIAZBwAAQrTYiCkUNAgsgC0EANgL8ASALIAo2AvgBIAsgBjYC9AEgC0HAADYC8AEgC0GAAmogC0HwAWogBxDSJSALIAspAoACNwLcAiALQQA2AtgCIAsgCygCjAIiBzYC1AIgCyALKAKIAjYC0AIgC0HoAWogC0HQAmoQ1zsgCygC6AEhCkEcQQQQrTYiBkUNAiAGQoGAgIAQNwIAIAYgCykC0AI3AgggBkEQaiALQdgCaikCADcCACAGQRhqIAtB4AJqKAIANgIAIAsgBzYCkAQgCyAKNgKMBCALIAY2AogECyALQeABaiALQYgEaiIGENw7IAtB0AJqIAsoAuABIAsoAuQBIAIgAyAFIAggCS0ABhC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIAIAsoAogEIgAgACgCACIAQQFrNgIAIABBAUcNCSAGEPseDAkLIAspA9gCIQUgCygCiAQiBiAGKAIAIgZBAWs2AgAgBkEBRw0CIAtBiARqEPseDAILQcAAIAYQoz0ACwwJCwJAAkACQAJAAkACQAJAIA1BAmsOJQQEBAQEBAQEBAQEAwMDAwMDAwADAgEAAgEDAwMDAwMDAwQEBAQDCwJAAkAgASgCJARAIAtBoAFqIAEQ3DsgCygCpAFFDQEgC0HQAmogCygCoAEgARCvEiALQZAEaiIGIAtB2AJqIgcoAgA2AgAgCyALKQLQAjcDiAQgCygC3AIhDCALKALgAiEOIAtBmAFqIAEQ3DsgCygCnAEiCkEBTQ0CIAtB3AJqIAsoApgBQQxqIAwgDhDmFSAHIAYoAgA2AgAgCyALKQOIBDcD0AIMCAtBAEHAABDRNEUNDyALQQA2AuACIAtCgICAgIAINwLYAiALQsAANwLQAiALQZABaiALQdACahDXOyALKAKQASEMQRxBBBCtNiIGRQ0QIAZCgYCAgBA3AgAgBiALKQLQAjcCCCAGQRBqIAtB2AJqKQIANwIAIAZBGGogC0HgAmooAgA2AgBBAEHAABDRNEUNDyALQQA2ApgEIAtCgICAgIAINwKQBCALQsAANwKIBCALQYgBaiALQYgEahDXOyALKAKIASEOQRxBBBCtNiIHRQ0QIAdCgYCAgBA3AgAgByALKQKIBDcCCCAHQRBqIAtBkARqKQIANwIAIAdBGGogC0GYBGooAgA2AgAgC0EANgLkAiALIA42AuACIAsgBzYC3AIgC0EANgLYAiALIAw2AtQCIAsgBjYC0AIMBwtBAEEAQcDR/gAQwyEAC0EBIApB0NH+ABDDIQALIAtBsAFqIAEQ3DsgCygCtAEiB0UNBiALKAKwASEGIAdBDGwhByAJLQAGIQoDQCALQagBaiAGENw7IAtB0AJqIAsoAqgBIAsoAqwBIAIgAyAFIAggChC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIADAwLIAZBDGohBiALKQPYAiEFIAdBDGsiBw0ACwwGCwJAAkAgASgCJARAIAtB2AFqIAEQ3DsgCygC3AFFDQEgC0HQAmogCygC2AEgARCuEiALQZAEaiIGIAtB2AJqIgcoAgA2AgAgCyALKQLQAjcDiAQgCygC3AIhDCALKALgAiEOIAtB0AFqIAEQ3DsgCygC1AEiCkEBTQ0CIAtB3AJqIAsoAtABQQxqIAwgDhDmFSAHIAYoAgA2AgAgCyALKQOIBDcD0AIMBQtBAEHAABDRNEUNDSALQQA2AuACIAtCgICAgIAINwLYAiALQsAANwLQAiALQcgBaiALQdACahDXOyALKALIASEMQRxBBBCtNiIGRQ0OIAZCgYCAgBA3AgAgBiALKQLQAjcCCCAGQRBqIAtB2AJqKQIANwIAIAZBGGogC0HgAmooAgA2AgBBAEHAABDRNEUNDSALQQA2ApgEIAtCgICAgIAINwKQBCALQsAANwKIBCALQcABaiALQYgEahDXOyALKALAASEOQRxBBBCtNiIHRQ0OIAdCgYCAgBA3AgAgByALKQKIBDcCCCAHQRBqIAtBkARqKQIANwIAIAdBGGogC0GYBGooAgA2AgAgC0EANgLkAiALIA42AuACIAsgBzYC3AIgC0EANgLYAiALIAw2AtQCIAsgBjYC0AIMBAtBAEEAQcDR/gAQwyEAC0EBIApB0NH+ABDDIQALIA1BDWtBBk0NAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDUEaTARAIA1BAUYNASANQRVHDRIMDwsCQAJAIA1BG2sOCAETAwETExMQAAsgDUEnRw0SCyALQegAaiABENw7IAsgCygCbCIGNgLIAiAGQQFHDQIgC0HgAGogARDvPCALIAsoAmQiBjYCzAIgBkEBRw0DIA1BG2sOBAYFBQcECyALQdAAaiABENw7IAsgCygCVCIGNgLEAiAGQQFHDQkgC0HIAGogARDcOyALKAJMRQ0KIAtBiARqIgYgCygCSCABKAIoIAEoAiQQtSogC0FAayAGENw7IAtB0AJqIAsoAkAgCygCRCACIAMgBSAIIAktAAYQtRIgCygC0AIEQCALKALUAiEBIAspA9gCIQUgACALKQPgAjcDECAAIAU3AwggACABNgIEIABBATYCACALKAKIBCIAIAAoAgAiAEEBazYCACAAQQFHDRYgBhD7HgwWCyALKQPYAiEFIAsoAogEIgYgBigCACIGQQFrNgIAIAZBAUcNEiALQYgEahD7HgwSCyALQfgAaiABEO88IAsgCygCfCIGNgKkAyAGQQFHDQogASgCJCEHIAEoAighDCABKAIcIQYgC0HwAGogARDvPCALKAJ0RQ0LIAtB0AJqIgEgCygCcCAGIAxsIAYgB2wQ1ghBACEGIAtBiARqIAEgAiADIAQgBSALKAL0AiALKAKQA0EAIAsoAvwCGyAIIAkQmAECfyALKAKIBARAIAspA5gEIQUgCygCjAQhASAAIAspA5AENwMIIAAgATYCBEEBIQZBEAwBCyALKQOQBCEFQQgLIABqIAU3AwAgACAGNgIAIAtB0AJqEP4mDBQLIAtBADYC0AJBACALQcgCakGw0v4AIAtB0AJqQbzT/gAQrysACyALQQA2AtACQQAgC0HMAmpBsNL+ACALQdACakGs0/4AEK8rAAsgDUEnRg0DC0H00v4AQShBnNP+ABCfKQALIAtB0AJqIAEQpQ4MAgsgC0HQAmohByMAQUBqIgYkAAJAAkACQAJAAkAgASgCJARAIAZBGGogARDcOyAGKAIcRQ0BIAZBLGogBigCGCABEK4SIAZBKGoiDCAGQTRqKAIANgIAIAYgBikCLDcDICAGKAI4IQ4gBigCPCEKIAZBEGogARDvPCAGKAIURQ0CIAdBDGogBigCECAOIAoQ1gggB0EIaiAMKAIANgIAIAcgBikDIDcCAAwFC0EAQcAAENE0RQ0DIAZBADYCPCAGQoCAgICACDcCNCAGQsAANwIsIAZBCGogBkEsahDXOyAGKAIIIQ5BHEEEEK02IgxFDRYgDEKBgICAEDcCACAMIAYpAiw3AgggDEEQaiAGQTRqKQIANwIAIAxBGGogBkE8aigCADYCACAGIAEQ7zwgBigCBEUNAiAHQQxqIAYoAgBBAEEAENYIIAdBADYCCCAHIA42AgQgByAMNgIADAQLQQBBAEHg0f4AEMMhAAtBAEEAQfDR/gAQwyEAC0EAQQBBgNL+ABDDIQALQYDI/gBBKSAGQSxqQfzI/gBBrMj+ABDVHgALIAZBQGskAAwBCyALQdACaiABEKUOCyALQbADaiALQdgCaigCADYCACALIAspAtACNwOoAyALQYgEaiALQdwCakHEAPwKAAAgC0HYAGogC0GoA2oQ3DsgC0HQAmogCygCWCALKAJcIAIgAyAFIAggCS0ABhC1EkEBIQYCfyALKALQAkEBRgRAIAspA+ACIQUgCygC1AIhASAAIAspA9gCNwMIIAAgATYCBEEQDAELIAtB0AJqIAtBiARqIAIgAyAEIAspA9gCIAsoAqwEIAsoAsgEQQAgCygCtAQbIAggCRCYASALKALQAkEBRgRAIAspA+ACIQUgCygC1AIhASAAIAspA9gCNwMIIAAgATYCBEEQDAELIAspA9gCIQVBACEGQQgLIABqIAU3AwAgACAGNgIAIAtBiARqEP4mIAsoAqgDIgAgACgCACIAQQFrNgIAIABBAUcNDCALQagDahD7HgwMCyALQQA2AtACQQAgC0HEAmpBsNL+ACALQdACakHE0v4AEK8rAAtBAEEAQbTS/gAQwyEACyALQQA2AtACQQAgC0GkA2pBsNL+ACALQdACakHk0v4AEK8rAAtBAEEAQdTS/gAQwyEACyALQThqIAEQ3DsgCyALKAI8IgY2AsACAkAgBkEBRgRAIAtBMGogARDcOyALKAI0DQFBAEEAQczT/gAQwyEACyALQQA2AtACQQAgC0HAAmpBsNL+ACALQdACakH80/4AEK8rAAsgCygCMCEGIAtBiARqIA8Q5gsCQAJAIAsoApAEBEAgC0HQAmoCfwJAIAsoAowEIgcoAgAiCkEDRwRAIAEoAigiDkEAIAcoAgQgChsiDCABKAIkbCIHIAYoAggiCklyDQELIAtBIGogBhDcOyALKAIkIQYgCygCIAwBCyALQShqIAYQ3DsgCiAMIA5sIgxrIgYgByAGIAdJGyIGIAxqIgcgBkkNAiAHIAsoAiwiCksNAyALKAIoIAxqCyAGIAIgAyAFIAggCS0ABhC1EiALKALQAkEBRgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIAIAtBiARqEOg7DAsLIAspA9gCIQUgC0GIBGoQ6DsMBgtBAEEAQdzT/gAQwyEACyAMIAdB7NP+ABCxOwALIAcgCkHs0/4AELA7DAgLIAtBsAJqIgYgC0HYAmoiCigCADYCACALQbwCaiALQeQCaigCADYCACALIAspA9ACIhQ3A6gCIAsgCykC3AI3ArQCIAtB4AJqIAYpAwA3AgAgC0HoAmogC0G4AmopAwA3AgAgC0KBgICAIDcC0AIgCyAUNwLYAgJAIBSnIgZFBEBBAiEMQQEhDgwBCyAJLQAGIRAgCiEHA0AgCyAHKQIENwKsAyALIAY2AqgDIAtBuAFqIAtBqANqIgYQ3DsgC0GIBGogCygCuAEgCygCvAEgAiADIAUgCCAQELUSIAsoAogEBEAgCygCjAQhASALKQOQBCEFIAAgCykDmAQ3AxAgACAFNwMIIAAgATYCBCAAQQE2AgAgCygCqAMiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAogCygC0AIgCygC1AIQ6yQMCQsgCykDkAQhBSALKAKoAyIGIAYoAgAiBkEBazYCACAGQQFGBEAgC0GoA2oQ+x4LIAsoAtQCIgwgCygC0AIiBkcEQCALIAZBAWoiDjYC0AIgCiAGQQxsaiIHKAIAIgZFDQIMAQsLIAwhDgsgCiAOIAwQ6yQMAgsgC0GYAmoiBiALQdgCaiIKKAIANgIAIAtBpAJqIAtB5AJqKAIANgIAIAsgCykD0AIiFDcDkAIgCyALKQLcAjcCnAIgC0HgAmogBikDADcCACALQegCaiALQaACaikDADcCACALQoGAgIAgNwLQAiALIBQ3AtgCAkAgFKciBkUEQEECIQxBASEODAELIAktAAYhECAKIQcDQCALIAcpAgQ3AqwDIAsgBjYCqAMgC0GAAWogC0GoA2oiBhDcOyALQYgEaiALKAKAASALKAKEASACIAMgBSAIIBAQtRIgCygCiAQEQCALKAKMBCEBIAspA5AEIQUgACALKQOYBDcDECAAIAU3AwggACABNgIEIABBATYCACALKAKoAyIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhD7HgsgCiALKALQAiALKALUAhDrJAwICyALKQOQBCEFIAsoAqgDIgYgBigCACIGQQFrNgIAIAZBAUYEQCALQagDahD7HgsgCygC1AIiDCALKALQAiIGRwRAIAsgBkEBaiIONgLQAiAKIAZBDGxqIgcoAgAiBkUNAgwBCwsgDCEOCyAKIA4gDBDrJAwBCyALQRhqIAEQ3DsgCygCHCIHRQ0AIAsoAhghBiAHQQxsIQcgCS0ABiEKA0ACQCALQRBqIAYQ3DsgC0HQAmogCygCECALKAIUIAIgAyAFIAggChC1EiALKALQAkEBRg0AIAZBDGohBiALKQPYAiEFIAdBDGsiBw0BDAILCyALKALUAiEBIAspA9gCIQUgACALKQPgAjcDECAAIAU3AwggACABNgIEIABBATYCAAwECyANQSJGDQIgDUEoRg0BCyALIAEQ7zwgCygCBCIBRQ0BIAsoAgAhBiABQcQAbCEHA0AgC0HQAmogBiACIAMgBCAFIAZBJGooAgAgBkFAaygCAEEAIAZBLGooAgAbIAggCRCYASALKALQAgRAIAsoAtQCIQEgCykD2AIhBSAAIAspA+ACNwMQIAAgBTcDCCAAIAE2AgQgAEEBNgIADAQLIAZBxABqIQYgCykD2AIhBSAHQcQAayIHDQALDAELIAtBzARqIA8QxQYgASgCKCEHIAEoAiQhCiALQdgEaiABEL4VIAtB5ARqIAFBDGoQgAsgASgCLCIGBEAgBiAGKAIAIgxBAWo2AgAgDEEASA0DIAEoAkAhDSABKAI8IQ8gASgCOCEMIAEoAjQhDiABKAIwIQELIAtB8AJqIAtB1ARqKAIANgIAIAtB2AJqIAtB4ARqKAIANgIAIAtB5AJqIAtB7ARqKAIANgIAIAsgCykCzAQ3A+gCIAsgBzYC+AIgCyAKNgL0AiALIAspAtgENwPQAiALIAspAuQENwLcAiALIA02ApADIAsgDzYCjAMgCyAMNgKIAyALIA42AoQDIAsgATYCgAMgCyAGNgL8AiALQYgEaiEQIwBB8ARrIgokAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAtB0AJqIgEtABhBKEYEQCABKAIcIgYtADBBA2sOAwIDBAELIAogAUEYajYC9AIgCkEBNgKYBCAKQaTP/gA2ApQEIApCATcCoAQgCkGnBDYCvAMgCiAKQbgDajYCnAQgCiAKQfQCajYCuAMgEEEIaiAKQZQEahCZDiAQQoCAgIDYgYCAgH83AgAgARD+JgwHCyAKIAZBMGo2AvQCIApBATYCmAQgCkHMzv4ANgKUBCAKQgE3AqAEIApBpwQ2ArwDIAogCkG4A2o2ApwEIAogCkH0Amo2ArgDIApBlARqQdTO/gAQ7ywACyAKQZQEaiIGIAFBxAD8CgAAIApByAFqIAYQnwkCQAJAIAooAuQBDQBBACEGAkAgCigC3AEiAUECSQ0AIAooAtgBIAFBfnFqQQJrIgFFDQAgAS4BACEGCyAGIAooAuABRw0AIApBoAFqIApByAFqQSj8CgAADAELQQAhBgJAIApB1AFqIgEoAhBFDQAgASgCDEUNACABQQAQkhkhBgsgBiEOAn9BACEGQQAgASgCDCIHRQ0AGgJAIAEoAggiDEECSQ0AIAEoAgQgDEF+cWpBAmsiDUUNACANLgEAIQYLIAEoAhAgB2ogBkcEQCABIAdBAWsQkhkMAQsgDEEBdkEBawshBiAKKALkASESIAYgDmtBAWoiEUEBdCIHQT5xIgwEQCAHIAcgDGtBQGsiB0sNCgtBwAAhDCAHQcAAENE0RQ0KIAcEQCAHQcAAEK02IgxFDQwLIApCADcCpAIgCiAMNgKgAiAKIAc2ApwCIApBwAA2ApgCIAYgDkkNDCAGIAooAtwBQQF2IgdLDQ0gBiAORwRAIAZBAXQgDkEBdCIGayEMIAooAtgBIAZqIQdBACEGA0AgBy8BACETIAdBAmohByAGQQJqIg0gCigCnAIiD0sEQCAKQZgCaiAPQQF0IgYgDRDLKiINIAYgDUsbEOgZIAooApwCIQ8gCigCpAIiBkECaiENCyANIA9LBH8gCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKkAgUgBgsgCigCoAJqIBMgEms7AAAgCiAKKAKkAkECaiIGNgKkAiAKIAooAqgCQQFqNgKoAiAMQQJrIgwNAAsLIApByAFqKAIYIg1BgIACTw0HIAooAqQCIgxBAmoiBiAKKAKcAiIHSwRAIApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCnAIhByAKKAKkAiIMQQJqIQYLIAYgB0sEfyAKQZgCaiAHQQF0IgcgBhDLKiIGIAYgB0kbEOgZIAooAqQCBSAMCyAKQaACaiIHKAIAaiANOwAAIAogCigCpAJBAmoiDDYCpAIgCiAKKAKoAkEBajYCqAIgCkG8BGpBg4aMGDYCACAKQoOGjJiw4MCBAzcCtAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIApBADsB7AQgCkEANgLoBCAKQQA2AtAEIApBADYCxAQgCiARNgLABCAKQbgDaiIGEJcpIAcoAgAhDSAHIApBwANqIg8pAgA3AwAgCikDmAIhFCAKIAopArgDNwOYAiAKQQA2AqgCIAogFDcCxAMgCkEANgLAAyAKIAw2ArwDIAogDTYCuAMgCkEQaiAGENc7IAooAhAhDUEcQQQQrTYiB0UNEyAHQoGAgIAQNwIAIAcgCikCuAM3AgggB0EQaiAPKQIANwIAIAdBGGogCkHIA2ooAgA2AgAgCiAMNgL8AiAKIA02AvgCIAogBzYC9AIgBiAKQZQEaiIHIApB9AJqIgwQ+iMgCkGwAmoiDSAGEM0cIApBCGogCkHoAWoiDyAOIBEQyyUgDCAKKAIIIAooAgwQ0yMgCkG0BGogCkHIAWoiDhDFBiAOKAIYIREgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApCBDcCrAQgCkIANwKkBCAKQoCAgIDAADcCnAQgCkEANgKUBCAGIAcgDRDvJSAHIAYgDBDvJSAGIAcQzRwgCkGgAWogBhCfCSAKQZgCahDPLyAOEKIMIAooAtQBIgYgBigCACIGQQFrNgIAIAZBAUYEQCABEPseCyAKKALoASIBIAEoAgAiAUEBazYCACABQQFHDQAgDxC7IwsgCi0AoAEiAUEpRw0CIApBmwFqIApBtAFqKAIAIgE2AAAgCkGTAWogCkGsAWopAgAiFDcAACAKIAopAqQBIhU3AIsBIBBBFGogATYAACAQQQxqIBQ3AAAgECAVNwAEIBBBgICAgHg2AgAMBQsgCkGUBGoiBiABQcQA/AoAACAKQcgBaiAGEJ4JAkACQCAKKALkAQ0AQQAhBgJAIAooAtwBIgFBBEkNACAKKALYASABQXxxakEEayIBRQ0AIAEoAgAhBgsgBiAKKALgAUcNACAKQaABaiAKQcgBakEo/AoAAAwBC0EAIQYCQCAKQdQBaiIBKAIQRQ0AIAEoAgxFDQAgAUEAEN8ZIQYLIAYhDgJ/QQAhBkEAIAEoAgwiB0UNABoCQCABKAIIIgxBBEkNACABKAIEIAxBfHFqQQRrIg1FDQAgDSgCACEGCyABKAIQIAdqIAZHBEAgASAHQQFrEN8ZDAELIAxBAnZBAWsLIQYgCigC5AEhEiAGIA5rQQFqIhFBAnQiB0E8cSIMBEAgByAHIAxrQUBrIgdLDQkLQcAAIQwgB0HAABDRNEUNCSAHBEAgB0HAABCtNiIMRQ0LCyAKQgA3AqQCIAogDDYCoAIgCiAHNgKcAiAKQcAANgKYAiAGIA5JDQsgBiAKKALcAUECdiIHSw0MIAYgDkcEQCAGQQJ0IA5BAnQiBmshDCAKKALYASAGaiEHQQAhBgNAIAcoAgAhEyAHQQRqIQcgBkEEaiINIAooApwCIg9LBEAgCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKcAiEPIAooAqQCIgZBBGohDQsgDSAPSwR/IApBmAJqIA9BAXQiBiANEMsqIg0gBiANSxsQ6BkgCigCpAIFIAYLIAooAqACaiATIBJrNgAAIAogCigCpAJBBGoiBjYCpAIgCiAKKAKoAkEBajYCqAIgDEEEayIMDQALCyAKQcgBaigCGCINQQBIDQcgCigCpAIiDEEEaiIGIAooApwCIgdLBEAgCkGYAmogB0EBdCIHIAYQyyoiBiAGIAdJGxDoGSAKKAKcAiEHIAooAqQCIgxBBGohBgsgBiAHSwR/IApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCpAIFIAwLIApBoAJqIgcoAgBqIA02AAAgCiAKKAKkAkEEaiIMNgKkAiAKIAooAqgCQQFqNgKoAiAKQbwEakGEiJAgNgIAIApChIiQoMCAgYIENwK0BCAKQgQ3AqwEIApCADcCpAQgCkKAgICAwAA3ApwEIApBADYClAQgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApBuANqIgYQlykgBygCACENIAcgCkHAA2oiDykCADcDACAKKQOYAiEUIAogCikCuAM3A5gCIApBADYCqAIgCiAUNwLEAyAKQQA2AsADIAogDDYCvAMgCiANNgK4AyAKQSBqIAYQ1zsgCigCICENQRxBBBCtNiIHRQ0SIAdCgYCAgBA3AgAgByAKKQK4AzcCCCAHQRBqIA8pAgA3AgAgB0EYaiAKQcgDaigCADYCACAKIAw2AvwCIAogDTYC+AIgCiAHNgL0AiAGIApBlARqIgcgCkH0AmoiDBD6IyAKQbACaiINIAYQzRwgCkEYaiAKQegBaiIPIA4gERDLJSAMIAooAhggCigCHBDTIyAKQbQEaiAKQcgBaiIOEMUGIA4oAhghESAKQQA7AewEIApBADYC6AQgCkEANgLQBCAKQQA2AsQEIAogETYCwAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIAYgByANEO8lIAcgBiAMEO8lIAYgBxDNHCAKQaABaiAGEJ4JIApBmAJqEM8vIA4QogwgCigC1AEiBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAEQ+x4LIAooAugBIgEgASgCACIBQQFrNgIAIAFBAUcNACAPELsjCyAKLQCgASIBQSlHDQIgCkGbAWogCkG0AWooAgAiATYAACAKQZMBaiAKQawBaikCACIUNwAAIAogCikCpAEiFTcAiwEgEEEUaiABNgAAIBBBDGogFDcAACAQIBU3AAQgEEGAgICAeDYCAAwECyAKQZQEaiIGIAFBxAD8CgAAIApByAFqIAYQoAkCQAJAIAooAuQBDQBBACEGAkAgCigC3AEiAUEISQ0AIAooAtgBIAFBeHFqQQhrIgFFDQAgASgCACEGCyAGIAooAuABRw0AIApBoAFqIApByAFqQSj8CgAADAELQQAhBgJAIApB1AFqIgEoAhBFDQAgASgCDEUNACABQQAQyBkhBgsgBiEOAn9BACEGQQAgASgCDCIHRQ0AGgJAIAEoAggiDEEISQ0AIAEoAgQgDEF4cWpBCGsiDUUNACANKAIAIQYLIAEoAhAgB2ogBkcEQCABIAdBAWsQyBkMAQsgDEEDdkEBawshBiAKNQLkASEUIAYgDmtBAWoiEUEDdCIHQThxIgwEQCAHIAcgDGtBQGsiB0sNCAtBwAAhDCAHQcAAENE0RQ0IIAcEQCAHQcAAEK02IgxFDQoLIApCADcCpAIgCiAMNgKgAiAKIAc2ApwCIApBwAA2ApgCIAYgDkkNCiAGIAooAtwBQQN2IgdLDQsgBiAORwRAIAZBA3QgDkEDdCIGayEMIAooAtgBIAZqIQdBACEGA0AgBykDACEVIAdBCGohByAGQQhqIg0gCigCnAIiD0sEQCAKQZgCaiAPQQF0IgYgDRDLKiINIAYgDUsbEOgZIAooApwCIQ8gCigCpAIiBkEIaiENCyANIA9LBH8gCkGYAmogD0EBdCIGIA0QyyoiDSAGIA1LGxDoGSAKKAKkAgUgBgsgCigCoAJqIBUgFH03AAAgCiAKKAKkAkEIaiIGNgKkAiAKIAooAqgCQQFqNgKoAiAMQQhrIgwNAAsLIApByAFqKAIYIQ0gCigCpAIiDEEIaiIGIAooApwCIgdLBEAgCkGYAmogB0EBdCIHIAYQyyoiBiAGIAdJGxDoGSAKKAKcAiEHIAooAqQCIgxBCGohBgsgBiAHSwR/IApBmAJqIAdBAXQiByAGEMsqIgYgBiAHSRsQ6BkgCigCpAIFIAwLIApBoAJqIgcoAgBqIA2tNwAAIAogCigCpAJBCGoiDDYCpAIgCiAKKAKoAkEBajYCqAIgCkG8BGpBhYqUKDYCACAKQoWKlKjQoMGCBTcCtAQgCkIENwKsBCAKQgA3AqQEIApCgICAgMAANwKcBCAKQQA2ApQEIApBADsB7AQgCkEANgLoBCAKQQA2AtAEIApBADYCxAQgCiARNgLABCAKQbgDaiIGEJcpIAcoAgAhDSAHIApBwANqIg8pAgA3AwAgCikDmAIhFCAKIAopArgDNwOYAiAKQQA2AqgCIAogFDcCxAMgCkEANgLAAyAKIAw2ArwDIAogDTYCuAMgCkEwaiAGENc7IAooAjAhDUEcQQQQrTYiB0UNESAHQoGAgIAQNwIAIAcgCikCuAM3AgggB0EQaiAPKQIANwIAIAdBGGogCkHIA2ooAgA2AgAgCiAMNgL8AiAKIA02AvgCIAogBzYC9AIgBiAKQZQEaiIHIApB9AJqIgwQ+iMgCkGwAmoiDSAGEM0cIApBKGogCkHoAWoiDyAOIBEQyyUgDCAKKAIoIAooAiwQ0yMgCkG0BGogCkHIAWoiDhDFBiAOKAIYIREgCkEAOwHsBCAKQQA2AugEIApBADYC0AQgCkEANgLEBCAKIBE2AsAEIApCBDcCrAQgCkIANwKkBCAKQoCAgIDAADcCnAQgCkEANgKUBCAGIAcgDRDvJSAHIAYgDBDvJSAGIAcQzRwgCkGgAWogBhCgCSAKQZgCahDPLyAOEKIMIAooAtQBIgYgBigCACIGQQFrNgIAIAZBAUYEQCABEPseCyAKKALoASIBIAEoAgAiAUEBazYCACABQQFHDQAgDxC7IwsgCi0AoAEiAUEpRw0CIApBmwFqIApBtAFqKAIAIgE2AAAgCkGTAWogCkGsAWopAgAiFDcAACAKIAopAqQBIhU3AIsBIBBBFGogATYAACAQQQxqIBQ3AAAgECAVNwAEIBBBgICAgHg2AgAMAwsgCkGXAWoiBiAKQbABaikAADcAACAKQZABaiIHIApBqQFqKQAANwMAIApB2ABqIApBwAFqKQIANwIAIApBwQBqIAcpAwA3AAAgCkHIAGogBikAADcAACAKIAopAKEBIhQ3A4gBIAogCikCuAE3AlAgCiABOgA4IAogFDcAOSAQIApBOGoQgT4MAgsgCkGXAWoiBiAKQbABaikAADcAACAKQZABaiIHIApBqQFqKQAANwMAIApBgAFqIApBwAFqKQIANwIAIApB6QBqIAcpAwA3AAAgCkHwAGogBikAADcAACAKIAopAKEBIhQ3A4gBIAogCikCuAE3AnggCiABOgBgIAogFDcAYSAQIApB4ABqEP09DAELIApBlwFqIgYgCkGwAWopAAA3AAAgCkGQAWoiByAKQakBaikAADcDACAKQZACaiAKQcABaikCADcCACAKQfkBaiAHKQMANwAAIApBgAJqIAYpAAA3AAAgCiAKKQChASIUNwOIASAKIAopArgBNwKIAiAKIAE6APABIAogFDcA8QEgECAKQfABahD6PQsgCkHwBGokAAwHC0G8z/4AELI7AAtBvM/+ABCyOwALQczH/gBBI0Hwx/4AEMskAAtBgMj+AEEpIApBlARqQfzI/gBBrMj+ABDVHgALQcAAIAcQoz0ACyAOIAZBrM/+ABCxOwALIAYgB0Gsz/4AELA7AAsgC0H4A2oiASALQZQEaikCADcDACALQYAEaiIGIAtBnARqKAIANgIAIAsgCykCjAQ3A/ADIAsoAogEIgdBgICAgHhGBEAgACALKQPwAzcCBCAAQQE2AgAgAEEUaiAGKAIANgIAIABBDGogASkDADcCAAwCCyALQcADaiALQaAEakEs/AoAACALQbQDaiALQfgDaikDADcCACALQbwDaiALQYAEaigCADYCACALIAc2AqgDIAsgCykD8AM3AqwDIAtBCGogC0GoA2oQ7zwgCygCDCIBBEAgCygCCCEGIAFBxABsIQcDQCALQdACaiAGIAIgAyAEIAUgBkEkaigCACAGQUBrKAIAQQAgBkEsaigCABsgCCAJEJgBIAsoAtACBEAgCygC1AIhASALKQPYAiEFIAAgCykD4AI3AxAgACAFNwMIIAAgATYCBCAAQQE2AgAgC0GoA2oQ/iYMBAsgBkHEAGohBiALKQPYAiEFIAdBxABrIgcNAAsLIAtBqANqEP4mCyAAQQA2AgAgACAFNwMICyALQfAEaiQADwsAC0GAyP4AQSkgC0HQAmpB/Mj+AEGsyP4AENUeAAtBBEEcEKM9AAuRLgELfyMAQcABayICJAACQCABKAIMIgUEQCABKAIIIQQgASAFQQFrNgIMIAEgBEEMajYCCAJAAkACQAJAAkACQCAELQAAIgdBAWsOBgABAgMEBQELIAJBgAFqIARBBGoQzCIgAigChAEhBSACKAKAASEDDAQLIAQoAgghBSAEKAIEIQMgBC0AAyEIIAQtAAIhASAELQABIQYMAwsgAkGIAWogBEEEahDMIiACKAKMASEFIAIoAogBIQMMAgsgBC0AAiEBIAQtAAEhBgwBC0EEIQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEETIAQtAAEiBEEEayAEQQNNG0H/AXFBAWsOEwABAgMEBQYHCAkKCwwNDg8QERITC0EFIQYMEgtBBiEGDBELQQchBgwQC0EIIQYMDwtBCSEGDA4LQQohBgwNC0ELIQYMDAtBDCEGDAsLQQ0hBgwKC0EOIQYMCQtBDyEGDAgLQRAhBgwHC0ERIQYMBgtBEiEGDAULQRMhBgwEC0EUIQYMAwtBFSEGDAILQRYhBgwBCyAEIQYLIAAgBTYCCCAAIAM2AgQgACAIOgADIAAgAToAAiAAIAY6AAEgACAHOgAADAELAkACQAJAAkACQAJAIAEoAgQiCQRAAn8gASgCACIHLAAAIgRBAE4EQCAEQf8BcQwBCyAHLQABQT9xIQUgBEEfcSEDIANBBnQgBXIgBEFfTQ0AGiAHLQACQT9xIAVBBnRyIQUgBSADQQx0ciAEQXBJDQAaIANBEnRBgIDwAHEgBy0AA0E/cSAFQQZ0cnILIQQgByAJaiELIARBH0wEQCAEQQlrQQVJDQQMAwsgBEEgRg0DIARBJUYNASAEQYCAxABHDQILIAJBBzoAmAEMBAsgB0EBaiEFQQAhBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACfwJAAkACQCAJQQFGDQAgBSwAACIDQb9/TA0EAkAgCUEBayIEAn8CQAJAAkACQCADQQBIBEAgBy0AAkE/cSEGIANBH3EhCCADQV9LDQEgCEEGdCAGciEDDAILIANB/wFxIQMMAgsgBy0AA0E/cSAGQQZ0ciEGIANBcEkEQCAGIAhBDHRyIQMMAQsgCEESdEGAgPAAcSAHLQAEQT9xIAZBBnRyciIDQYCAxABGDQULIANBgAFPDQELQQEMAQtBAiADQYAQSQ0AGkEDQQQgA0GAgARJGwsiCE0EQCAEIAhGDQEMUgsgBSAIaiwAAEG/f0wNUQsgBSAIaiEFIAQgCGshBEEDIQoCQCADQS1rDgQCCgoDAAtBASADQSNGDQMaIANB3wBHDQlBAiEKQQAMAwsgAkGYAWogASAHIAkgBBCMIAxTC0EAIQpBAAwBC0EBIQpBAAshDCAFIAtHBEACQCAFLAAAIgNBAEgEQCAFLQABQT9xIQYgA0EfcSEIIANBX0sNASAIQQZ0IAZyIQMMBAsgA0H/AXEhA0EBIQYMBAsgBS0AAkE/cSAGQQZ0ciEGIANBcEkEQCAGIAhBDHRyIQMMAwsgCEESdEGAgPAAcSAFLQADQT9xIAZBBnRyciIDQYCAxABHDQILIAJBmAFqIAEgByAJIAQQjCAMUAsgByAJQQEgCUGQuIYBEKM2AAtBASEGIANBgAFPDQELQQEMAQtBACEGQQIgA0GAEEkNABpBA0EEIANBgIAESRsLIQgCQCAEIAhNBEAgBCAIRg0BDEgLIAUgCGosAABBv39MDUcLIAUgCGohBSAEIAhrIQQgDA0BCyADQSVrDlYWQUFBQUEXQUEEQUFBQQVBQQZBQQcDQUFBQUFBQD8+PUE8Ozo5QUFBOEFBN0E2NTQzMjEwLy5BQUFBQUEtLCsqKSgnLEEmJSQjIkEhIB8eHRwbGhkYAUELAkACfwJAIAZFBEAgAkEANgKkASADQYAQSQ0BIANBgIAETwRAIAIgA0ESdkHwAXI6AKQBIAIgA0EGdkE/cUGAAXI6AKYBIAIgA0EMdkE/cUGAAXI6AKUBQQQhBiACQaQBakEDcgwDCyACIANBDHZB4AFyOgCkASACIANBBnZBP3FBgAFyOgClAUEDIQYgAkGkAWpBAnIMAgsgA0H6AEcNAgxECyACIANBBnZBwAFyOgCkAUECIQYgAkGkAWpBAXILIANBP3FBgAFyOgAAIAJBpAFqIAZBwLiGAUEBEMEuDQILIAJBmAFqIAEgByAJIAQQjCAMSQsgAkGFJjsBpAEMQQsgA0Elaw5WEz4+Pj4+FD4+AT4+Pj4CPj4DPj4EAD4+Pj4+Pj08Ozo+OTg3Nj4+PjU+PjQ+MzIxMC8uLSwrPj4+Pj4+KikoJyYlJCk+IyIhIB8+Hh0cGxoZGBcWFT8+CyAFIARBqLqGAUEDEPQuDQQgBSAEQau6hgFBAhD0Lg0FIAJB+gA2ArgBQQEhAyAFIAQgAkG4AWpBARD0LkUEQCACQaQBaiABIAcgCSAEEIwgDEELIAJBEGogBSAEQQFBsLqGARCNJyACQYUeOwGkASACKAIUIQQgAigCECEFDEALIAIgBTYCsAEgAiAEIAVqNgK0AQJAAkACQAJAAkACQCACQbABahD1FiIDQYCAxABHBEAgAkHIAGogBSAEAn9BASADQYABSQ0AGkECIANBgBBJDQAaQQNBBCADQYCABEkbC0HguoYBEI0nIAIoAkwhBCACKAJIIQUgA0Ezaw4HBAICBQICBgELIAJBmAFqIAEgByAJIAQQjCAMSwsgA0HmAEYNAQsgAkGkAWogASAHIAkgBBCMIAxCCyACQYUUOwGkAQxBCyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkEgaiAFIARBAkEDQQQgA0GAgARJGyADQYAQSRtB8LqGARCNJyACKAIkIQQgAigCICEFDBMLIAJBGGogBSAEQQFB8LqGARCNJyACKAIcIQQgAigCGCEFIANB5gBHDRIgAkGFFjsBpAEMQAsgAiAFNgK4ASACIAQgBWo2ArwBIAJBuAFqEPUWIgNBgIDEAEYNByADQYABTwRAIAJBMGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQYC7hgEQjScgAigCNCEEIAIoAjAhBQwRCyACQShqIAUgBEEBQYC7hgEQjScgAigCLCEEIAIoAighBSADQeYARw0QIAJBhRg7AaQBDD8LIAIgBTYCuAEgAiAEIAVqNgK8ASACQbgBahD1FiIDQYCAxABGDQcgA0GAAU8EQCACQUBrIAUgBEECQQNBBCADQYCABEkbIANBgBBJG0GQu4YBEI0nIAIoAkQhBCACKAJAIQUMDwsgAkE4aiAFIARBAUGQu4YBEI0nIAIoAjwhBCACKAI4IQUgA0HmAEcNDiACQYUaOwGkAQw+CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkHYAGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQaC7hgEQjScgAigCXCEEIAIoAlghBQwNCyACQdAAaiAFIARBAUGgu4YBEI0nIAIoAlQhBCACKAJQIQUgA0HmAEcNDCACQYUCOwGkAQw9CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkHoAGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQbC7hgEQjScgAigCbCEEIAIoAmghBQwLCyACQeAAaiAFIARBAUGwu4YBEI0nIAIoAmQhBCACKAJgIQUgA0HmAEcNCiACQYUEOwGkAQw8CyACIAU2ArgBIAIgBCAFajYCvAEgAkG4AWoQ9RYiA0GAgMQARg0HIANBgAFPBEAgAkH4AGogBSAEQQJBA0EEIANBgIAESRsgA0GAEEkbQcC7hgEQjScgAigCfCEEIAIoAnghBQwJCyACQfAAaiAFIARBAUHAu4YBEI0nIAIoAnQhBCACKAJwIQUgA0HmAEcNCCACQYUGOwGkAQw7CyACIAUgBEEDQdC6hgEQjScgAkGFIjsBpAFBASEDIAIoAgQhBCACKAIAIQUMOwsgAkEIaiAFIARBAkHAuoYBEI0nIAJBhSA7AaQBQQEhAyACKAIMIQQgAigCCCEFDDoLIAJBmAFqIAEgByAJIAQQjCAMPwsgAkGYAWogASAHIAkgBBCMIAw+CyACQZgBaiABIAcgCSAEEIwgDD0LIAJBmAFqIAEgByAJIAQQjCAMPAsgAkGYAWogASAHIAkgBBCMIAw7CyACQZgBaiABIAcgCSAEEIwgDDoLIAJBpAFqIAEgByAJIAQQjCAMMgsgAkGkAWogASAHIAkgBBCMIAwxCyACQaQBaiABIAcgCSAEEIwgDDALIAJBpAFqIAEgByAJIAQQjCAMLwsgAkGkAWogASAHIAkgBBCMIAwuCyACQaQBaiABIAcgCSAEEIwgDC0LQQEhAyACQQE2AqwBIAJB0LuGATYCqAEgAkEAOgCkAQwtCyACQYUsOwGkAQwrC0EBIQMgAkEBOgCmASACQYQEOwGkAQwrCyABQQQ2AgwgAUHMvIYBNgIIIAJBpAFqQcC8hgEQgQ9BACEDDCoLIAJBADoApgEgAkGEGDsBpAEMKAsgAUEENgIMIAFB+LmGATYCCCACQQI6AKYBIAJBhBA7AaQBQQAhAwwoCyACQQA6AKYBIAJBhBo7AaQBDCYLQQEhAyACQQE2AqwBIAJB9bmGATYCqAEgAkECOgCkAQwmCyACQQA6AKYBIAJBhCg7AaQBDCQLIAFBBjYCDCABQeS+hgE2AgggAkGkAWpB2L6GARCBD0EAIQMMJAsgAkEAOgCmASACQYQMOwGkAQwiCyACQYUSOwGkAQwhC0EBIQMgAkEBNgKsASACQfS5hgE2AqgBIAJBAjoApAEMIQtBASEDIAJBAToApgEgAkGEDjsBpAEMIAsgAkECOgCmASACQYQgOwGkAQweCyACQQI6AKYBIAJBhB47AaQBDB0LQQEhAyACQQE6AKYBIAJBhBw7AaQBDB0LQQEhAyACQQE6AKYBIAJBhAo7AaQBDBwLQQEhAyACQQE6AKYBIAJBhCY7AaQBDBsLIAJBAjoApgEgAkGEEDsBpAEMGQtBASEDIAJBAToApgEgAkGEEDsBpAEMGQsgAUEMNgIMIAFBjL2GATYCCCACQaQBakGAvYYBEIEPQQAhAwwYCyACQYUIOwGkAQwWCyACQYUMOwGkAQwVCyACQYUcOwGkAQwUC0EBIQMgAkEBOgCmASACQQQ7AaQBDBQLIAFBBDYCDCABQai+hgE2AgggAkGkAWpBnL6GARCBD0EAIQMMEwtBASEDIAJBAToApgEgAkGEFDsBpAEMEgtBASEDIAJBAToApgEgAkGEFjsBpAEMEQtBASEDIAJBAToApgEgAkGEEjsBpAEMEAsgAUEENgIMIAFBxLmGATYCCCACQQE6AKYBIAJBhB47AaQBQQAhAwwPC0EBIQMgAkEBOgCmASACQYQkOwGkAQwOCyABQQI2AgwgAUGsuYYBNgIIIAJBAToApgEgAkGEHjsBpAFBACEDDA0LIAJBhRA7AaQBDAsLQQEhAyACQQE6AKYBIAJBhCI7AaQBDAsLQQEhAyACQQE6AKYBIAJBhCA7AaQBDAoLQQEhAyACQQE6AKYBIAJBhB47AaQBDAkLQQEhAyACQQE6AKYBIAJBhAY7AaQBDAgLIAFBBDYCDCABQfi4hgE2AgggAkEBOgCmASACQQQ7AaQBQQAhAwwHCyABQQQ2AgwgAUHEuIYBNgIIIAJBAToApgEgAkGEDjsBpAFBACEDDAYLQQEhAyACQQE6AKYBIAJBhAI7AaQBDAULIAJBhQo7AaQBDAMLIAJBhQ47AaQBDAILIAJBpAFqIAEgByAJIAQQjCAMAQsgAkEFOwGkAQtBASEDCwJAIApBA0cEQCADIAItAKQBQQRGcUUNASACIAo6AJoBIAIgAi0ApQE6AJkBIAJBBDoAmAEMBwsgAkGgAWogAkGsAWooAgA2AgAgAiACKQKkATcCmAEMBgsgAkGYAWogASAHIAkgBBCMIAJAIAItAKQBQQFrDgMABgAGCyACKAKsASIDRQ0FIAIoAqgBIANBARD4OgwFCyAFIAQgCCAEQbC4hgEQozYACyAFIAQgCCAEQaC4hgEQozYACyAEQYABSQ0BAkACQCAEQQh2IgNBH00EQCADRQ0BIANBFkcgBEGALUdyDQQMAwsgA0EgRg0BIANBMEcgBEGA4ABHcg0DDAILIARB/wFxQfvUiQFqLQAAQQFxDQEMAgsgBEH/AXFB+9SJAWotAABBAnFFDQELIAchBAJAA0ACfyAEIgUsAAAiA0EATgRAIANB/wFxIQMgBEEBagwBCyAFLQABQT9xIQYgA0EfcSEEIANBX00EQCAEQQZ0IAZyIQMgBUECagwBCyAFLQACQT9xIAZBBnRyIQYgA0FwSQRAIAYgBEEMdHIhAyAFQQNqDAELIARBEnRBgIDwAHEgBS0AA0E/cSAGQQZ0cnIhAyAFQQRqCyEEAkAgA0EgRiADQQlrQQVJcg0AIANBgAFJDQICQCADQQh2IgZBH00EQCAGRQ0BIAZBFkcNBCADQYAtRg0CDAQLIAZBIEcEQCAGQTBHDQQgA0GA4ABGDQIMBAsgA0H/AXFB+9SJAWotAABBAnENAQwDCyADQf8BcUH71IkBai0AAEEBcUUNAgsgCCAFayAEaiEIIAQgC0cNAAsgCSEICyAIRQRAQdG7hgFBHkGQvIYBEJ8pAAsCQAJAIAggCU8EQCAIIAlGDQEMAgsgByAIaiwAAEG/f0wNAQsgAkECOgCYASACIAc2ApwBIAIgCDYCoAEgByAIaiEFIAkgCGshBAwCCyAHIAlBACAIQaC8hgEQozYAC0EAIQUgByEEA0ACQCAFIQMgBCALRgRAIAkhAwwBCwJ/IAQsAAAiBUEATgRAIAVB/wFxIQUgBEEBagwBCyAELQABQT9xIQYgBUEfcSEIIAVBX00EQCAIQQZ0IAZyIQUgBEECagwBCyAELQACQT9xIAZBBnRyIQYgBUFwSQRAIAYgCEEMdHIhBSAEQQNqDAELIAhBEnRBgIDwAHEgBC0AA0E/cSAGQQZ0cnIhBSAEQQRqCyEIIAVBCWsiBkEXTUEAQQEgBnRBn4CABHEbDQBBACEKAkAgBUGAAUkNAAJAAkAgBUEIdiIGQR9NBEAgBkUNASAGQRZHDQMgBUGALUYhCgwDCyAGQSBGDQEgBkEwRw0CIAVBgOAARiEKDAILIAVB/wFxQfvUiQFqLQAAIQoMAQsgBUH/AXFB+9SJAWotAABBAnFBAXYhCgsgBUElRg0AIAMgBGsgCGohBSAIIQQgCkEBcUUNAQsLIANFBEBB0buGAUEeQfC7hgEQnykACwJAIAMgCU8EQCADIAlGDQEMAwsgAyAHaiwAAEG/f0wNAgsgAkEAOgCYASACIAc2ApwBIAIgAzYCoAEgAyAHaiEFIAkgA2shBAsgAi0AmAEiA0EHRgRAIABBBzoAAAwCCyAAIAIpAJkBNwABIABBCGogAkGgAWooAAA2AAAgASAENgIEIAEgBTYCACAAIAM6AAAMAQsgByAJQQAgA0GAvIYBEKM2AAsgAkHAAWokAAuFJQIafwN+IwBBwAZrIggkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABKQMAIh9QRQRAIAEpAwgiIFANASABKQMQIiFQDQIgHyAhfCAfVA0DIB8gIFQNBCABLgEYIQEgCCAfPgIMIAhBAUECIB9CgICAgBBUIgYbNgKsASAIQQAgH0IgiKcgBhs2AhAgCEEUakEAQZgB/AsAIAhBtAFqQQBBnAH8CwAgCEEBNgKwASAIQQE2AtACIAGsIB9CAX15fULCmsHoBH5CgKHNoLQCfEIgiKciBsEhDQJAIAFBAE4EQCAIQQxqIAEQtgYaDAELIAhBsAFqQQAgAWvBELYGGgsCQCANQQBIBEAgCEEMakEAIA1rQf//A3EQ3gUMAQsgCEGwAWogBkH//wFxEN4FCyAIQZwFaiAIQbABakGkAfwKAAAgAyIHQQpPBEAgCEGUBWohCwNAIAgoArwGIgFBKU8NEQJAIAFFDQAgAUH/////A2ohBiABQQJ0IQUCfyABQQFGBEBCACEfIAhBnAVqIAVqDAELIAUgC2ohASAGQf////8DcUEBakH+////B3EhCUIAIR8DQCABQQRqIgUgBTUCACAfQiCGhCIfQoCU69wDgCIgPgIAIAEgATUCACAfICBCgJTr3AN+fUIghoQiH0KAlOvcA4AiID4CACAfICBCgJTr3AN+fSEfIAFBCGshASAJQQJrIgkNAAsgH0IghiEfIAFBCGoLIAZBAXENAEEEayIBIB8gATUCAIRCgJTr3AOAPgIACyAHQQlrIgdBCUsNAAsLIAdBAnRBuOmJAWooAgBBAXQiB0UNBSAIKAK8BiIBQSlPDQ8gAQR/IAFB/////wNqIQYgAUECdCEFIAetIR8CfyABQQFGBEBCACEgIAhBnAVqIAVqDAELIAUgCGpBlAVqIQEgBkH/////A3FBAWpB/v///wdxIQlCACEgA0AgAUEEaiIFIAU1AgAgIEIghoQiICAfgCIhPgIAIAEgATUCACAgIB8gIX59QiCGhCIgIB+AIiE+AgAgICAfICF+fSEgIAFBCGshASAJQQJrIgkNAAsgIEIghiEgIAFBCGoLIQEgBkEBcUUEQCABQQRrIgEgICABNQIAhCAfgD4CAAsgCCgCvAYFQQALIQECQAJAAkAgCCgCrAEiBiABIAEgBkkbIgVBKE0EQCAFRQRAQQAhBQwECyAFQQFxIQwgBUEBRw0BQQAhBwwCCyAFQShBkIyKARCwOwALIAVBPnEhDkEAIQcgCEGcBWohASAIQQxqIQkDQCABIAEoAgAiEiAJKAIAaiILIAdBAXFqIhQ2AgAgAUEEaiIHIAcoAgAiFSAJQQRqKAIAaiIHIAsgEkkgCyAUS3JqIgs2AgAgByAVSSAHIAtLciEHIAlBCGohCSABQQhqIQEgDiAKQQJqIgpHDQALCyAMBH8gCkECdCIBIAhBnAVqaiILIAcgCygCACIHIAhBDGogAWooAgBqIgFqIgs2AgAgASAHSSABIAtLcgUgBwtBAXFFDQAgBUEoRg0RIAhBnAVqIAVBAnRqQQE2AgAgBUEBaiEFCyAIIAU2ArwGIAgoAtACIgogBSAFIApJGyIBQSlPDQ8gAUECdCEBAkACQANAIAFFDQEgAUEEayIBIAhBnAVqaigCACIFIAEgCEGwAWpqKAIAIgdGDQALIAUgB08NAQwICyABDQcLIA1BAWohDQwHC0Go2IkBQRxBsNuJARCfKQALQdTYiQFBHUHA24kBEJ8pAAtBhNmJAUEcQdDbiQEQnykAC0Ho2okBQTZBwNyJARCfKQALQaDaiQFBN0Gw3IkBEJ8pAAtB14yKAUEbQZCMigEQnykACyAGRQRAQQAhBiAIQQA2AqwBDAELIAZBAWtB/////wNxIgFBAWoiBUEDcSEJAkAgAUEDSQRAIAhBDGohAUIAIR8MAQsgBUH8////B3EhByAIQQxqIQFCACEfA0AgASABNQIAQgp+IB98Ih8+AgAgAUEEaiIFIAU1AgBCCn4gH0IgiHwiHz4CACABQQhqIgUgBTUCAEIKfiAfQiCIfCIfPgIAIAFBDGoiBSAFNQIAQgp+IB9CIIh8IiA+AgAgIEIgiCEfIAFBEGohASAHQQRrIgcNAAsLIAkEQANAIAEgATUCAEIKfiAffCIgPgIAIAFBBGohASAgQiCIIR8gCUEBayIJDQALCyAgQoCAgIAQWgRAIAZBKEYNCiAIQQxqIAZBAnRqIB8+AgAgBkEBaiEGCyAIIAY2AqwBC0EAIQVBASEMIA3BIgEgBMEiB0giGg0EIA0gBGvBIAMgASAHayADSRsiC0UNBEEAIgFFBEAgCEHUAmogCEGwAWpBpAH8CgAAC0EBIRIgCEHUAmpBARC2BiEUIAFFBEAgCEH4A2ogCEGwAWpBpAH8CgAACyAIQfgDakECELYGIRUgAUUEQCAIQZwFaiAIQbABakGkAfwKAAALIAhBrAFqIRsgCEHQAmohHCAIQfQDaiEdIAhBmAVqIR4gCEGcBWpBAxC2BiEWIBQoAqABIRcgFSgCoAEhGCAWKAKgASEZQQAhDiAIKAKsASEGIAgoAtACIQoCQANAIAZBKU8NCyAGQQJ0IQRBACEBAn8CQAJAA0AgASAERg0BIAhBDGogAWogAUEEaiEBKAIARQ0ACyAZIAYgBiAZSRsiBEEpTw0FIARBAnQhAQJAA0AgAUUNASABIB5qIQUgAUEEayIBIAhBDGpqKAIAIgcgBSgCACIFRg0ACyAFIAdNDQJBAAwDCyABRQ0BQQAMAgsgAyALSQ0FAkAgCyAORg0AIAsgDmsiAUUNACACIA5qQTAgAfwLAAsgACANOwEIIAAgCzYCBAwJC0EBIQdBACEGIARBAUcEQCAEQT5xIQwgCEEMaiEBIAhBnAVqIQkDQCABIAEoAgAiDyAJKAIAQX9zaiIFIAdBAXFqIhA2AgAgAUEEaiIHIAcoAgAiESAJQQRqKAIAQX9zaiIHIAUgD0kgBSAQS3JqIgU2AgAgByARSSAFIAdJciEHIAlBCGohCSABQQhqIQEgDCAGQQJqIgZHDQALCyAEQQFxBH8gBkECdCIBIAhBDGpqIgYgBigCACIGIAEgFmooAgBBf3NqIgEgB2oiBTYCACABIAZJIAEgBUtyBSAHC0EBcUUNDSAIIAQ2AqwBIAQhBkEICyEMIBggBiAGIBhJGyIEQSlPDQQgBEECdCEBAkACQAJAA0AgAUUNASABIB1qIQUgAUEEayIBIAhBDGpqKAIAIgcgBSgCACIFRg0ACyAFIAdNDQEgBiEEDAILIAFFDQAgBiEEDAELIAQEQEEBIQdBACEGIARBAUcEQCAEQT5xIQ8gCEEMaiEBIAhB+ANqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIFIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAUgEEkgBSARS3JqIgU2AgAgByATSSAFIAdJciEHIAlBCGohCSABQQhqIQEgDyAGQQJqIgZHDQALCyAEQQFxBH8gBkECdCIBIAhBDGpqIgYgBigCACIGIAEgFWooAgBBf3NqIgEgB2oiBTYCACABIAZJIAEgBUtyBSAHC0EBcUUNDgsgCCAENgKsASAMQQRyIQwLIBcgBCAEIBdJGyIFQSlPDQUgBUECdCEBAkACQAJAA0AgAUUNASABIBxqIQYgAUEEayIBIAhBDGpqKAIAIgcgBigCACIGRg0ACyAGIAdNDQEgBCEFDAILIAFFDQAgBCEFDAELIAUEQEEBIQdBACEGIAVBAUcEQCAFQT5xIQ8gCEEMaiEBIAhB1AJqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIEIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAQgEEkgBCARS3JqIgQ2AgAgByATSSAEIAdJciEHIAlBCGohCSABQQhqIQEgDyAGQQJqIgZHDQALCyAFQQFxBH8gBkECdCIBIAhBDGpqIgQgBCgCACIEIAEgFGooAgBBf3NqIgEgB2oiBjYCACABIARJIAEgBktyBSAHC0EBcUUNDgsgCCAFNgKsASAMQQJqIQwLIAogBSAFIApJGyIGQSlPDQsgBkECdCEBAkACQAJAA0AgAUUNASABIBtqIQQgAUEEayIBIAhBDGpqKAIAIgcgBCgCACIERg0ACyAEIAdNDQEgBSEGDAILIAFFDQAgBSEGDAELIAYEQEEBIQdBACEFIAZBAUcEQCAGQT5xIQ8gCEEMaiEBIAhBsAFqIQkDQCABIAEoAgAiECAJKAIAQX9zaiIEIAdBAXFqIhE2AgAgAUEEaiIHIAcoAgAiEyAJQQRqKAIAQX9zaiIHIAQgEEkgBCARS3JqIgQ2AgAgByATSSAEIAdJciEHIAlBCGohCSABQQhqIQEgDyAFQQJqIgVHDQALCyAGQQFxBH8gBUECdCIBIAhBDGpqIgQgBCgCACIEIAhBsAFqIAFqKAIAQX9zaiIBIAdqIgU2AgAgASAESSABIAVLcgUgBwtBAXFFDQ4LIAggBjYCrAEgDEEBaiEMCyADIA5NDQEgAiAOaiAMQTBqOgAAIAZBKU8NCwJAIAZFBEBBACEGDAELIAZBAWtB/////wNxIgFBAWoiBEEDcSEJAkAgAUEDSQRAIAhBDGohAUIAISAMAQsgBEH8////B3EhByAIQQxqIQFCACEgA0AgASABNQIAQgp+ICB8Ih8+AgAgAUEEaiIEIAQ1AgBCCn4gH0IgiHwiHz4CACABQQhqIgQgBDUCAEIKfiAfQiCIfCIfPgIAIAFBDGoiBCAENQIAQgp+IB9CIIh8Ih8+AgAgH0IgiCEgIAFBEGohASAHQQRrIgcNAAsLIAkEQANAIAEgATUCAEIKfiAgfCIfPgIAIAFBBGohASAfQiCIISAgCUEBayIJDQALCyAfQoCAgIAQVA0AIAZBKEYNCyAIQQxqIAZBAnRqICA+AgAgBkEBaiEGCyAIIAY2AqwBIA5BAWohDiASIAsgEksiAWohEiABDQALQQAhDCALIQUMBQsgDiADQZDciQEQwyEACyAEQShBkIyKARCwOwALIAsgA0Gg3IkBELA7AAsgBEEoQZCMigEQsDsACyAFQShBkIyKARCwOwALAkACfwJAAkAgCkEpSQRAAkAgCkUEQEEAIQoMAQsgCkEBa0H/////A3EiAUEBaiIEQQNxIQkCQCABQQNJBEAgCEGwAWohAUIAIR8MAQsgBEH8////B3EhByAIQbABaiEBQgAhHwNAIAEgATUCAEIFfiAffCIfPgIAIAFBBGoiBCAENQIAQgV+IB9CIIh8Ih8+AgAgAUEIaiIEIAQ1AgBCBX4gH0IgiHwiHz4CACABQQxqIgQgBDUCAEIFfiAfQiCIfCIgPgIAICBCIIghHyABQRBqIQEgB0EEayIHDQALCyAJBEADQCABIAE1AgBCBX4gH3wiID4CACABQQRqIQEgIEIgiCEfIAlBAWsiCQ0ACwsgIEKAgICAEFQNACAKQShGDQkgCEGwAWogCkECdGogHz4CACAKQQFqIQoLIAggCjYC0AIgCiAGIAYgCkkbIgFBKU8NByABQQJ0IQEgCEEIaiEHIAhBrAFqIQsCQAJ/AkADQCABRQ0BIAEgC2ohBiABIAdqIAFBBGshASgCACIEIAYoAgAiBkYNAAsgBCAGSyAEIAZJawwBC0F/QQAgARsLQf8BcQ4CAAIDC0EAIAwNAxogAyAFQQFrIgFLBEAgASACai0AAEEBcQ0CDAMLIAEgA0Hg24kBEMMhAAsgCkEoQZCMigEQsDsACyADIAVJDQQgAiAFaiEGQQAhAQJAAkADQCABIAVqRQ0BIAFBAWsiASAGaiIELQAAQTlGDQALIAQgBC0AAEEBajoAACABIAVqQQFqIgYgBU0NASAGIAVBwOqJARCvOwALAkAgDARAQTEhAQwBCyACQTE6AABBMCEBIAVBAWsiBEUgBEVyDQAgAkEBakEwIAT8CwALIA1BAWohDSAaIAMgBU1yDQEgBiABOgAAIAVBAWohBQwBCyABQX9GDQAgAUF/cyIBRQ0AIARBAWpBMCAB/AsACyADIAVJDQEgBQshASAAIA07AQggACABNgIEDAELIAUgA0GA3IkBELA7AAsgACACNgIAIAhBwAZqJAAPCyAFIANB8NuJARCwOwALIAFBKEGQjIoBELA7AAtBKEEoQZCMigEQwyEACyAGQShBkIyKARCwOwALQaCMigFBGkGQjIoBEJ8pAAunLgIKfwJ+IwBBwBVrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtACBBAWsOBAIIAQMACyACQZAKaiIDIABBCGooAgA2AgAgAiAAKQIANwOICiACQdgLaiIGIABBGGpBwLfDACACQYgKaiIEENQQIAMgAEEUaigCADYCACACIAApAgw3A4gKIAJB+AJqIgMgBkHs9sIAIAQQiw4gAEEoaiIIIANBgAf8CgAAIABBADoAqAcgAEGoB2ohCgwFCyAAQShqIQggAEGoB2ohCiAALQCoB0EBaw4DAgYFBAtB9PbCABDoKwALIABBKGohAyAAQYQCaiEIAkACQCAALQCEAkEBaw4DAQYAEgsgAEH4AWohBiAAQYACaiEEAkAgAC0AgAJBAWsOAwMGFgALIAYoAgAhBQwUC0G888IAEOgrAAtBrPPCABDoKwALQfjywgAQ6CsACyAAQYACaiAIQdgB/AoAAEIDIQwgACgCiAIhBSAAKQOAAiINQgNRBEAgACgC0AMiAyADKAIAIgNBAWs2AgAgA0EBRw0NIABB0ANqEJ0nDA0LIAJBlApqIABBNGpBxAH8CgAAIAIgBTYCkAogAiANNwOICiACQdgLaiIDIABB0ANqIAJBiApqEM4SIABB2ANqIANB0AP8CgAACyAAQdgDaiELAkACQAJAIAAtAKQHQQFrDgMBAwIACyAAQQA6AKUHIABBqAVqIgMgC0HQAfwKAAAgABCvPjYC+AYgAEH4BmohB0GH6sIAIQVBByEEAkACQAJAAkACQAJAAkACQAJAAkACQCAALQDcBkEBaw4KAAECAwQFBgcICQoLQY7qwgAhBUEDIQQMCQtBkerCACEFQQQhBAwIC0GV6sIAIQVBAyEEDAcLQZjqwgAhBUEGIQQMBgtBnurCACEFQQQhBAwFC0Gi6sIAIQVBBSEEDAQLQafqwgAhBQwDC0Gu6sIAIQVBBSEEDAILIAJBmAFqIABB3QZqEP8sIAIoApwBIQQgAigCmAEhBQwBCyACQaABaiAAQeAGahDXOyACKAKkASEEIAIoAqABIQULIAcgBSAEEO06IAJBkAFqENMlIAIoApQBIQUCQCACKAKQAUEBcUUNACACQYgBaiAFEIQZIAIoAowBIQUgAigCiAEiBkUNACAGIAUQ+johBQwKCyAAIAU2AvwGIABBAToApQcgAkGYFGogAxD7LiACQbARaiACQaAUaikCADcDACACIAIpApgUNwOoESACQYABaiACQagRahDtEiACKAKAASIFBEAgAEH8BmohCSACKAKEASEGA0ACQCAFKAIABEAgBSgCCCEDIAUoAgQhBAwBC0EGIQNBmOHCACEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFLQAEQQFrDlAAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1ALQQ4hA0Ge4cIAIQQMTwtBDyEDQazhwgAhBAxOC0EPIQNBu+HCACEEDE0LQQ0hA0HK4cIAIQQMTAtBICEDQdfhwgAhBAxLC0EcIQNB9+HCACEEDEoLQRwhA0GT4sIAIQQMSQtBGyEDQa/iwgAhBAxIC0EdIQNByuLCACEEDEcLQRYhA0Hn4sIAIQQMRgtBHiEDQf3iwgAhBAxFC0EdIQNBm+PCACEEDEQLQQMhA0G448IAIQQMQwtBBSEDQbvjwgAhBAxCC0EHIQNBwOPCACEEDEELQQ0hA0HH48IAIQQMQAtBDSEDQdTjwgAhBAw/C0EMIQNB4ePCACEEDD4LQREhA0Ht48IAIQQMPQtBCiEDQf7jwgAhBAw8C0ETIQNBiOTCACEEDDsLQRAhA0Gb5MIAIQQMOgtBECEDQavkwgAhBAw5C0EOIQNBu+TCACEEDDgLQRAhA0HJ5MIAIQQMNwtBDSEDQdnkwgAhBAw2C0EXIQNB5uTCACEEDDULQSMhA0H95MIAIQQMNAtBDCEDQaDlwgAhBAwzC0Gs5cIAIQQMMgtBAyEDQbLlwgAhBAwxC0EEIQNBteXCACEEDDALQQQhA0G55cIAIQQMLwtBveXCACEEDC4LQQchA0HD5cIAIQQMLQtBCSEDQcrlwgAhBAwsC0EEIQNB0+XCACEEDCsLQQQhA0HX5cIAIQQMKgtBCCEDQdvlwgAhBAwpC0ERIQNB4+XCACEEDCgLQQ0hA0H05cIAIQQMJwtBCCEDQYHmwgAhBAwmC0ETIQNBiebCACEEDCULQQ0hA0Gc5sIAIQQMJAtBBCEDQanmwgAhBAwjC0EIIQNBrebCACEEDCILQQwhA0G15sIAIQQMIQtBwebCACEEDCALQcfmwgAhBAwfC0ESIQNBzebCACEEDB4LQRMhA0Hf5sIAIQQMHQtBDyEDQfLmwgAhBAwcC0EbIQNBgefCACEEDBsLQQUhA0Gc58IAIQQMGgtBByEDQaHnwgAhBAwZC0EPIQNBqOfCACEEDBgLQQchA0G358IAIQQMFwtBCyEDQb7nwgAhBAwWC0EUIQNByefCACEEDBULQRghA0Hd58IAIQQMFAtBESEDQfXnwgAhBAwTC0EWIQNBhujCACEEDBILQRUhA0Gc6MIAIQQMEQtBsejCACEEDBALQQohA0G36MIAIQQMDwtBGSEDQcHowgAhBAwOC0ECIQNB2ujCACEEDA0LQQchA0Hc6MIAIQQMDAtBESEDQePowgAhBAwLC0EKIQNB9OjCACEEDAoLQQchA0H+6MIAIQQMCQtBGSEDQYXpwgAhBAwIC0EEIQNBnunCACEEDAcLQQMhA0Gi6cIAIQQMBgtBByEDQaXpwgAhBAwFC0EQIQNBrOnCACEEDAQLQRYhA0G86cIAIQQMAwtBFiEDQdLpwgAhBAwCC0EPIQNB6OnCACEEDAELQRAhA0H36cIAIQQLIAJB+ABqIAYQ4yAgAigCeCIGRQRAIAIQ1SkhBQwLCyACQfAAaiAJIAQgAyAGIAIoAnwQuigCQCACKAJwQQFxRQ0AIAJB6ABqIAIoAnQQhBkgAigCaCIDRQ0AIAMgAigCbBD6OiEFDAsLIAJB4ABqIAJBqBFqEO0SIAIoAmQhBiACKAJgIgUNAAsLIABBADoApQcgAiAAKAL8BjYCqBEgByACQagRahDsOiACKAKoESIDQYQBTwRAIAMQ8h8LIAAtAPAGRQRAIAcQpTsLIAAoAtQGIgNBBEcEQCAHIAMQpDsLIAAoAtgGIgNBB0cEQCAHIAMQkj0LIAAoAsAGQQFHDQQgAEHEBmoiAxDmKA0EIAJB2ABqIAMQyiEgAigCXCEFIAIoAlhBAXENCCACIAU2AqgRIAcgAkGoEWoQzC0gAigCqBEiA0GEAUkNBCADEPIfDAQLQcDxwgAQ6CsACyAAQZgHaiEFIABBoAdqIQcCQCAALQCgB0EBaw4DAgEFAAsgBSgCACEEDAMLAAtB+PLCABDoKwALIAJBqBFqEJkfIAIoAqwRIQUgAigCqBENAyACQaAUaiACQbgRaikCACIMNwMAIAIgAikCsBEiDTcDmBQgACAFNgKAByAAIA03AoQHIABBjAdqIAw3AgAgAEGAB2ohAyAAKAK4BiIGQYCU69wDRwRAIAMgACkDsAYgBhDNEQsgAiADENE7NgKoESAHIAJBqBFqEM0tIAIoAqgRIgNBhAFPBEAgAxDyHwsgAkHQAGogACgC/AUgACgCgAYgBxCAJCACKAJUIQUCQCACKAJQQQFxRQ0AIAJByABqIAUQhBkgAigCTCEFIAIoAkgiA0UNACADIAUQ+johBQwDCyAAIAU2ApQHIABBlAdqEIwXIQQgAEEAOgCgByAAIAQ2ApgHIABBoAdqIQcgAEGYB2ohBQsgACAEEPsONgKcBwsgAkFAayAAQZwHaiIDIAEQxxgCQAJAAkACQAJAAkACQAJAAkAgAigCQCIEQQJHBEAgAigCRCEGIAMoAgAiCSAJKAIAQQFrIgk2AgAgCUUEQCADELIaCwJAAkACQCAEQQFxRQ0AIAJBOGogBhCEGSACKAI8IQYgAigCOCIERQ0AIAYhAwwBCyACIAY2AqgRIAJBqBFqIgMQozsNASADQSNBAEEBQQEQoBggAigCrBEhAyACKAKoEUEBRg0DIAIoArARIglBiPPCAEEj/AoAAEEMQQQQrTYiBEUNBCAEQSM2AgggBCAJNgIEIAQgAzYCAEHo6sIAIQMgBkGEAUkNACAGEPIfCyAHQQE6AAAgBRDkKCACIAM2ApQSIAIgBDYCkBIgAkEANgKgFCACQoCAgIAQNwKYFCACQezewgA2AqwRIAJCoICAgA43ArARIAIgAkGYFGo2AqgRIAJBkBJqIAJBqBFqEIM2DQQgAkHoEmogAkGgFGooAgAiAzYCACACIAIpApgUNwPgEiACKALkEiADQdLywgBBJBDBLiEDIAJB4BJqEN47QQEgAgJ/IANFBEAgAigClBIhBSACKAKQEgwBCyACQZASahC8KkGgs8MAIQVBAQsgBRDYKSEFIAAoApQHIgNBhAFJDQsgAxDyHwwLCyAHQQE6AAAgBRDkKCACIAY2AoQQIAJBqBFqIgMQ2SkgAkGIEGogAyACQYQQaiIEEI89EOASIAJB4BJqIgUgBBDiJiACKALoEiEHIAIoAuQSIQkgAkEANgKgFCACQQA2ApgUIAJBADYCqBQgAyACQZgUaiAJIAcQvBogAigCqBFBAkYNBCACQdAQaiADQcgA/AoAACAFEN47IAIgBBCQPTYCmBEgAyACQZgRahDHEiACLQCsESIDQQNGDQUgA0ECRg0GIAIoAqgRIQQgAiADOgCgESACIAQ2ApwRIAJBMGogAkGcEWoQ/CkgAigCMCIFQQJHBEAgAkGkFGohByACKAI0IQQDQCAFQQFxDQkgAiAENgKkESACQShqIAJBpBFqEMgkIAIoAihBAXENCiACQfgUaiIFIAIoAiwQqysgAkHgEmoiAyACKAL8FCACKAKAFRCQNSACQagRaiIEIAMQyBMgAigCqBFBgICAgHhGDQsgAkGoFGogAkG4EWopAgA3AwAgAkGgFGogAkGwEWopAgAiDDcDACACIAIpAqgRIg03A5gUIAJBmBJqIAw+AgAgAiANNwOQEiACQegSaiAHQQhqKAIANgIAIAIgBykCADcD4BIgBCACQYgQaiIJQcgA/AoAACAJIAQgAkGQEmoiBCADELANIAMQ3jsgBBDeOyAFEN47IAIoAqQRIgNBhAFPBEAgAxDyHwsgAkEgaiACQZwRahD8KSACKAIkIQQgAigCICIFQQJHDQALCyACKAKcESIDQYQBTwRAIAMQ8h8LIAItAJEQIQUgAi0AkBAhBAJAAkACQCACKQOIECIMQgNRBEAgBkGEAU8EQCAGEPIfCyACQeASaiACQdAQakHIAPwKAAAgAkG4E2ogAEGQB2ooAgA2AgAgAkGwE2ogAEGIB2opAgA3AgAgAiAAKQKABzcCqBMgAkHwEmoQ3jsgAkGoE2oQvSgMAQsgAiAFOgCZEiACIAQ6AJgSIAIgDDcDkBIgAkGaEmogAkGSEGpBPvwKAAAgAiAGNgLYEiACQeASaiACQdAQakHIAPwKAAAgAkG4E2ogAEGQB2ooAgA2AgAgAkGwE2ogAEGIB2opAgA3AgAgAiAAKQKABzcCqBMgAkGYFGogAkHgEmpB3AD8CgAAIAJB+BRqIgMgAkHQEGpByAD8CgAAIAJBqBFqIAJBkBJqIAMgAkHgFGoQkyAgAikDqBEiDEIDUg0BIAItALERIQUgAi0AsBEhBAtCAyEMQQEgAiAEIAUQrB4hBQwBCyACKAKwESEFIAJBvBNqIAJBtBFqQdwA/AoAAAsgAigCmBEiA0GEAU8EQCADEPIfCyAAKAKUByIDQYQBTwRAIAMQ8h8LIABBADoApQcgACgC+AYiBEGEAUkNDgwNCyAAQQM6AKAHIABBAzoApAcMEQsgAyACKAKwEUHc88IAEP0vAAtBBEEMEKM9AAtBlN/CAEE3IAJB4BJqQYTfwgBBzN/CABDVHgALQdDxwgBBCRCXPQALQdnxwgBBEBCXPQALQenxwgBBGBCXPQALQYHywgBBHhCXPQALQZ/ywgBBEhCXPQALQbHywgBBIRCXPQALIABBgAdqEL0oCyAALQClB0UNACAAKAL8BiIDQYQBSQ0AIAMQ8h8LIABBADoApQdCAyEMIAAoAvgGIgRBgwFLDQAgAEGoBWoQqR4gAEEBOgCkBwwCCyAEEPIfCyAAQagFahCpHiAAQQE6AKQHIAxCBFENAwsgAkGoD2ogAkG8E2pB3AD8CgAAIAsQzSQgACgC0AMiAyADKAIAIgNBAWs2AgAgA0EBRw0AIABB0ANqEJ0nCyAKQQE6AAAgCBCqHiAMQgNRDQUgAiAFNgKYAiACIAw3A5ACIAJBnAJqIAJBqA9qQdwA/AoAACACQagBaiIDIAJBkAJqEJETIAIpA6gBQgNRDQYgAkHYC2oiBiADQegA/AoAACAIIAZB3AH8CgAAIABBADoAhAIgAEEoaiEDIABBhAJqIQgLIABBkAFqIANB6AD8CgAAIAJBGGogAEHYAWoQxyQgAigCHCEFIAIoAhhBAXFFDQEgAkEQaiAFEIQZIAIoAhQhBSACKAIQIgZFDQFBBSACIAYgBRDYKSEEDAgLQQMhBSAKQQM6AABBASEEDAYLIABBADoAgAIgACAFNgL4ASAAQYACaiEEIABB+AFqIQYLIAAgBRD7DjYC/AELIAJBCGogAEH8AWoiBSABEMcYIAIoAggiAUECRwRAIAIoAgwhCCAFKAIAIgcgBygCAEEBayIHNgIAIAdFBEAgBRCyGgsCQCABQQFxBEAgAiAIEIQZIAIoAgQhCCACKAIAIgENAQsgBEEBOgAAIAYQ5CggAiAINgKQAiACIAJBkAJqEJQ9NgKoESACQYgKaiIBIAJBqBFqIgYQlj1BzPPCABDOGCAGIAIoAowKIAIoApAKEIMkIAJB+AJqIAEQ5xUgAikCgAMhDCACKAL8AiEEIAIoAvgCIQEgAigCqBEiBkGDAUsEQCAGEPIfCyACKAKQAiIGQYQBTwRAIAYQ8h8LIABBkAFqEKElIABBAToAhAIgAxDSLSABRQ0HIAIgDDcCgAogAiAENgL8CSACIAE2AvgJIAJB2AtqIAAoAhwgAkH4CWoQxiYgAigC2AsNBCAAKAIYIgEgASgCACIBQQFrNgIAQQEhBUEAIQQgAUEBRw0FIABBGGoQnScMBQsgBEEBOgAAIAYQ5ChBBSACIAEgCBDYKSEEDAULIARBAzoAACAIQQM6AABBASEEQQQhBQwDCyACIAU2AtgLQZzgwgBBKyACQdgLakHI4MIAQYT3wgAQ1R4ACyACIAIoArABNgLYC0Gc4MIAQSsgAkHYC2pByODCAEGU98IAENUeAAsgAkGAA2ogAkHgC2opAgA3AwAgAiACKQLYCzcD+AJBnODCAEErIAJB+AJqQYzgwgBBtPfCABDVHgALIAAgBToAICACQcAVaiQAIAQPCyAAQZABahChJSAAQQE6AIQCIAMQ0i0LIAIgBDYC+AJBnODCAEErIAJB+AJqQcjgwgBBpPfCABDVHgALpy4CC38CfiMAQcAVayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAgQQFrDgQCCAEDAAsgAkGQCmoiAyAAQQhqKAIANgIAIAIgACkCADcDiAogAkHYC2oiBiAAQRhqQcC3wwAgAkGICmoiBBDUECADIABBFGooAgA2AgAgAiAAKQIMNwOICiACQfgCaiIDIAZBzLrDACAEEIsOIABBKGoiCCADQYAH/AoAACAAQQA6AKgHIABBqAdqIQoMBQsgAEEoaiEIIABBqAdqIQogAC0AqAdBAWsOAwIGBQQLQdS6wwAQ6CsACyAAQShqIQMgAEGEAmohCAJAAkAgAC0AhAJBAWsOAwEGABILIABB+AFqIQYgAEGAAmohBAJAIAAtAIACQQFrDgMDBhYACyAGKAIAIQUMFAtBrLjDABDoKwALQZy4wwAQ6CsAC0Hot8MAEOgrAAsgAEGAAmogCEHYAfwKAABCAyENIAAoAogCIQUgACkDgAIiDkIDUQRAIAAoAtADIgMgAygCACIDQQFrNgIAIANBAUcNDSAAQdADahCdJwwNCyACQZQKaiAAQTRqQcQB/AoAACACIAU2ApAKIAIgDjcDiAogAkHYC2oiAyAAQdADaiACQYgKahDOEiAAQdgDaiADQdAD/AoAAAsgAEHYA2ohCwJAAkACQCAALQCkB0EBaw4DAQMCAAsgAEEAOgClByAAQagFaiIDIAtB0AH8CgAAIAAQrz42AvgGIABB+AZqIQdB87HDACEFQQchBAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A3AZBAWsOCgABAgMEBQYHCAkKC0H6scMAIQVBAyEEDAkLQf2xwwAhBUEEIQQMCAtBgbLDACEFQQMhBAwHC0GEssMAIQVBBiEEDAYLQYqywwAhBUEEIQQMBQtBjrLDACEFQQUhBAwEC0GTssMAIQUMAwtBmrLDACEFQQUhBAwCCyACQZgBaiAAQd0GahD/LCACKAKcASEEIAIoApgBIQUMAQsgAkGgAWogAEHgBmoQ1zsgAigCpAEhBCACKAKgASEFCyAHIAUgBBDtOiACQZABahDTJSACKAKUASEFAkAgAigCkAFBAXFFDQAgAkGIAWogBRCEGSACKAKMASEFIAIoAogBIgZFDQAgBiAFEPo6IQUMCgsgACAFNgL8BiAAQQE6AKUHIAJBmBRqIAMQ+y4gAkGwEWogAkGgFGopAgA3AwAgAiACKQKYFDcDqBEgAkGAAWogAkGoEWoQ7RIgAigCgAEiBQRAIABB/AZqIQkgAigChAEhBgNAAkAgBSgCAARAIAUoAgghAyAFKAIEIQQMAQtBBiEDQYSpwwAhBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBS0ABEEBaw5QAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QC0EOIQNBiqnDACEEDE8LQQ8hA0GYqcMAIQQMTgtBDyEDQaepwwAhBAxNC0ENIQNBtqnDACEEDEwLQSAhA0HDqcMAIQQMSwtBHCEDQeOpwwAhBAxKC0EcIQNB/6nDACEEDEkLQRshA0GbqsMAIQQMSAtBHSEDQbaqwwAhBAxHC0EWIQNB06rDACEEDEYLQR4hA0HpqsMAIQQMRQtBHSEDQYerwwAhBAxEC0EDIQNBpKvDACEEDEMLQQUhA0Gnq8MAIQQMQgtBByEDQayrwwAhBAxBC0ENIQNBs6vDACEEDEALQQ0hA0HAq8MAIQQMPwtBDCEDQc2rwwAhBAw+C0ERIQNB2avDACEEDD0LQQohA0Hqq8MAIQQMPAtBEyEDQfSrwwAhBAw7C0EQIQNBh6zDACEEDDoLQRAhA0GXrMMAIQQMOQtBDiEDQaeswwAhBAw4C0EQIQNBtazDACEEDDcLQQ0hA0HFrMMAIQQMNgtBFyEDQdKswwAhBAw1C0EjIQNB6azDACEEDDQLQQwhA0GMrcMAIQQMMwtBmK3DACEEDDILQQMhA0GercMAIQQMMQtBBCEDQaGtwwAhBAwwC0EEIQNBpa3DACEEDC8LQamtwwAhBAwuC0EHIQNBr63DACEEDC0LQQkhA0G2rcMAIQQMLAtBBCEDQb+twwAhBAwrC0EEIQNBw63DACEEDCoLQQghA0HHrcMAIQQMKQtBESEDQc+twwAhBAwoC0ENIQNB4K3DACEEDCcLQQghA0HtrcMAIQQMJgtBEyEDQfWtwwAhBAwlC0ENIQNBiK7DACEEDCQLQQQhA0GVrsMAIQQMIwtBCCEDQZmuwwAhBAwiC0EMIQNBoa7DACEEDCELQa2uwwAhBAwgC0GzrsMAIQQMHwtBEiEDQbmuwwAhBAweC0ETIQNBy67DACEEDB0LQQ8hA0HersMAIQQMHAtBGyEDQe2uwwAhBAwbC0EFIQNBiK/DACEEDBoLQQchA0GNr8MAIQQMGQtBDyEDQZSvwwAhBAwYC0EHIQNBo6/DACEEDBcLQQshA0Gqr8MAIQQMFgtBFCEDQbWvwwAhBAwVC0EYIQNBya/DACEEDBQLQREhA0Hhr8MAIQQMEwtBFiEDQfKvwwAhBAwSC0EVIQNBiLDDACEEDBELQZ2wwwAhBAwQC0EKIQNBo7DDACEEDA8LQRkhA0GtsMMAIQQMDgtBAiEDQcawwwAhBAwNC0EHIQNByLDDACEEDAwLQREhA0HPsMMAIQQMCwtBCiEDQeCwwwAhBAwKC0EHIQNB6rDDACEEDAkLQRkhA0HxsMMAIQQMCAtBBCEDQYqxwwAhBAwHC0EDIQNBjrHDACEEDAYLQQchA0GRscMAIQQMBQtBECEDQZixwwAhBAwEC0EWIQNBqLHDACEEDAMLQRYhA0G+scMAIQQMAgtBDyEDQdSxwwAhBAwBC0EQIQNB47HDACEECyACQfgAaiAGEOMgIAIoAngiBkUEQCACENUpIQUMCwsgAkHwAGogCSAEIAMgBiACKAJ8ELooAkAgAigCcEEBcUUNACACQegAaiACKAJ0EIQZIAIoAmgiA0UNACADIAIoAmwQ+johBQwLCyACQeAAaiACQagRahDtEiACKAJkIQYgAigCYCIFDQALCyAAQQA6AKUHIAIgACgC/AY2AqgRIAcgAkGoEWoQ7DogAigCqBEiA0GEAU8EQCADEPIfCyAALQDwBkUEQCAHEKU7CyAAKALUBiIDQQRHBEAgByADEKQ7CyAAKALYBiIDQQdHBEAgByADEJI9CyAAKALABkEBRw0EIABBxAZqIgMQ5igNBCACQdgAaiADEMohIAIoAlwhBSACKAJYQQFxDQggAiAFNgKoESAHIAJBqBFqEMwtIAIoAqgRIgNBhAFJDQQgAxDyHwwEC0GItsMAEOgrAAsgAEGYB2ohBSAAQaAHaiEHAkAgAC0AoAdBAWsOAwIBBQALIAUoAgAhBAwDCwALQei3wwAQ6CsACyACQagRahCZHyACKAKsESEFIAIoAqgRDQMgAkGgFGogAkG4EWopAgAiDTcDACACIAIpArARIg43A5gUIAAgBTYCgAcgACAONwKEByAAQYwHaiANNwIAIABBgAdqIQMgACgCuAYiBkGAlOvcA0cEQCADIAApA7AGIAYQzRELIAIgAxDROzYCqBEgByACQagRahDNLSACKAKoESIDQYQBTwRAIAMQ8h8LIAJB0ABqIAAoAvwFIAAoAoAGIAcQgCQgAigCVCEFAkAgAigCUEEBcUUNACACQcgAaiAFEIQZIAIoAkwhBSACKAJIIgNFDQAgAyAFEPo6IQUMAwsgACAFNgKUByAAQZQHahCMFyEEIABBADoAoAcgACAENgKYByAAQaAHaiEHIABBmAdqIQULIAAgBBD7DjYCnAcLIAJBQGsgAEGcB2oiAyABEMcYAkACQAJAAkACQAJAAkACQAJAIAIoAkAiBEECRwRAIAIoAkQhBiADKAIAIgkgCSgCAEEBayIJNgIAIAlFBEAgAxCyGgsCQAJAAkAgBEEBcUUNACACQThqIAYQhBkgAigCPCEGIAIoAjgiBEUNACAGIQMMAQsgAiAGNgKoESACQagRaiIDEKM7DQEgA0EjQQBBAUEBEKAYIAIoAqwRIQMgAigCqBFBAUYNAyACKAKwESIJQfi3wwBBI/wKAABBDEEEEK02IgRFDQQgBEEjNgIIIAQgCTYCBCAEIAM2AgBB3LPDACEDIAZBhAFJDQAgBhDyHwsgB0EBOgAAIAUQ5CggAiADNgKUEiACIAQ2ApASIAJBADYCoBQgAkKAgICAEDcCmBQgAkH4pMMANgKsESACQqCAgIAONwKwESACIAJBmBRqNgKoESACQZASaiACQagRahCDNg0EIAJB6BJqIAJBoBRqKAIAIgM2AgAgAiACKQKYFDcD4BIgAigC5BIgA0Gat8MAQSQQwS4hAyACQeASahDeO0EBIAICfyADRQRAIAIoApQSIQUgAigCkBIMAQsgAkGQEmoQvCpBoLPDACEFQQELIAUQ2CkhBSAAKAKUByIDQYQBSQ0LIAMQ8h8MCwsgB0EBOgAAIAUQ5CggAiAGNgKEECACQagRaiIDENkpIAJBiBBqIAMgAkGEEGoiBBCPPRDgEiACQeASaiIFIAQQ4iYgAigC6BIhByACKALkEiEJIAJBADYCoBQgAkEANgKYFCACQQA2AqgUIAMgAkGYFGogCSAHELwaIAIoAqgRQQJGDQQgAkHQEGogA0HIAPwKAAAgBRDeOyACIAQQkD02ApgRIAMgAkGYEWoQxxIgAi0ArBEiA0EDRg0FIANBAkYNBiACKAKoESEEIAIgAzoAoBEgAiAENgKcESACQTBqIAJBnBFqEPwpIAIoAjAiBUECRwRAIAJBpBRqIQcgAigCNCEEA0AgBUEBcQ0JIAIgBDYCpBEgAkEoaiACQaQRahDIJCACKAIoQQFxDQogAkH4FGoiBSACKAIsEKsrIAJB4BJqIgMgAigC/BQgAigCgBUQkDUgAkGoEWoiBCADEMgTIAIoAqgRQYCAgIB4Rg0LIAJBqBRqIAJBuBFqKQIANwMAIAJBoBRqIAJBsBFqKQIAIg03AwAgAiACKQKoESIONwOYFCACQZgSaiANPgIAIAIgDjcDkBIgAkHoEmogB0EIaigCADYCACACIAcpAgA3A+ASIAQgAkGIEGoiCSACQZASaiIMIAMQsA0gCSAEQcgA/AoAACADEN47IAwQ3jsgBRDeOyACKAKkESIDQYQBTwRAIAMQ8h8LIAJBIGogAkGcEWoQ/CkgAigCJCEEIAIoAiAiBUECRw0ACwsgAigCnBEiA0GEAU8EQCADEPIfCyACLQCRECEFIAItAJAQIQQCQAJAAkAgAikDiBAiDUIDUQRAIAZBhAFPBEAgBhDyHwsgAkHgEmogAkHQEGpByAD8CgAAIAJBuBNqIABBkAdqKAIANgIAIAJBsBNqIABBiAdqKQIANwIAIAIgACkCgAc3AqgTIAJB8BJqEN47IAJBqBNqEL0oDAELIAIgBToAmRIgAiAEOgCYEiACIA03A5ASIAJBmhJqIAJBkhBqQT78CgAAIAIgBjYC2BIgAkHgEmogAkHQEGpByAD8CgAAIAJBuBNqIABBkAdqKAIANgIAIAJBsBNqIABBiAdqKQIANwIAIAIgACkCgAc3AqgTIAJBmBRqIAJB4BJqQdwA/AoAACACQfgUaiIDIAJB0BBqQcgA/AoAACACQagRaiACQZASaiADIAJB4BRqEJMgIAIpA6gRIg1CA1INASACLQCxESEFIAItALARIQQLQgMhDUEBIAIgBCAFEKweIQUMAQsgAigCsBEhBSACQbwTaiACQbQRakHcAPwKAAALIAIoApgRIgNBhAFPBEAgAxDyHwsgACgClAciA0GEAU8EQCADEPIfCyAAQQA6AKUHIAAoAvgGIgRBhAFJDQ4MDQsgAEEDOgCgByAAQQM6AKQHDBELIAMgAigCsBFBzLjDABD9LwALQQRBDBCjPQALQaClwwBBNyACQeASakGQpcMAQdilwwAQ1R4AC0GYtsMAQQkQlz0AC0GhtsMAQRAQlz0AC0GxtsMAQRgQlz0AC0HJtsMAQR4Qlz0AC0HntsMAQRIQlz0AC0H5tsMAQSEQlz0ACyAAQYAHahC9KAsgAC0ApQdFDQAgACgC/AYiA0GEAUkNACADEPIfCyAAQQA6AKUHQgMhDSAAKAL4BiIEQYMBSw0AIABBqAVqEKkeIABBAToApAcMAgsgBBDyHwsgAEGoBWoQqR4gAEEBOgCkByANQgRRDQMLIAJBqA9qIAJBvBNqQdwA/AoAACALEM0kIAAoAtADIgMgAygCACIDQQFrNgIAIANBAUcNACAAQdADahCdJwsgCkEBOgAAIAgQyCEgDUIDUQ0FIAIgBTYCmAIgAiANNwOQAiACQZwCaiACQagPakHcAPwKAAAgAkGoAWoiAyACQZACahCREyACKQOoAUIDUQ0GIAJB2AtqIgYgA0HoAPwKAAAgCCAGQdwB/AoAACAAQQA6AIQCIABBKGohAyAAQYQCaiEICyAAQZABaiADQegA/AoAACACQRhqIABB2AFqEMckIAIoAhwhBSACKAIYQQFxRQ0BIAJBEGogBRCEGSACKAIUIQUgAigCECIGRQ0BQQUgAiAGIAUQ2CkhBAwIC0EDIQUgCkEDOgAAQQEhBAwGCyAAQQA6AIACIAAgBTYC+AEgAEGAAmohBCAAQfgBaiEGCyAAIAUQ+w42AvwBCyACQQhqIABB/AFqIgUgARDHGCACKAIIIgFBAkcEQCACKAIMIQggBSgCACIHIAcoAgBBAWsiBzYCACAHRQRAIAUQshoLAkAgAUEBcQRAIAIgCBCEGSACKAIEIQggAigCACIBDQELIARBAToAACAGEOQoIAIgCDYCkAIgAiACQZACahCUPTYCqBEgAkGICmoiASACQagRaiIGEJY9Qby4wwAQzhggBiACKAKMCiACKAKQChCDJCACQfgCaiABEOcVIAIpAoADIQ0gAigC/AIhBCACKAL4AiEBIAIoAqgRIgZBgwFLBEAgBhDyHwsgAigCkAIiBkGEAU8EQCAGEPIfCyAAQZABahCkKSAAQQE6AIQCIAMQ1S0gAUUNByACIA03AoAKIAIgBDYC/AkgAiABNgL4CSACQdgLaiAAKAIcIAJB+AlqEMYmIAIoAtgLDQQgACgCGCIBIAEoAgAiAUEBazYCAEEBIQVBACEEIAFBAUcNBSAAQRhqEJ0nDAULIARBAToAACAGEOQoQQUgAiABIAgQ2CkhBAwFCyAEQQM6AAAgCEEDOgAAQQEhBEEEIQUMAwsgAiAFNgLYC0HgpsMAQSsgAkHYC2pBjKfDAEHkusMAENUeAAsgAiACKAKwATYC2AtB4KbDAEErIAJB2AtqQYynwwBB9LrDABDVHgALIAJBgANqIAJB4AtqKQIANwMAIAIgAikC2As3A/gCQeCmwwBBKyACQfgCakHQpsMAQZS7wwAQ1R4ACyAAIAU6ACAgAkHAFWokACAEDwsgAEGQAWoQpCkgAEEBOgCEAiADENUtCyACIAQ2AvgCQeCmwwBBKyACQfgCakGMp8MAQYS7wwAQ1R4AC7P5AwIjfwR+IwBBkAFrIgokAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg4CAAECCyAKQRBqQStBAEEBQQEQoBggCigCFCEBIAooAhBBAUYNAiAKKAIYIgJB2POCAUEr/AoAACAAQSs2AgwgACACNgIIIAAgATYCBCAAQYaAgIB4NgIADCgLIAogASgCACICQQAgAiABKAIEIgEoAiQRBAAgASgCIBEFACAAIAopAwA3AgQgAEGTgICAeDYCAAwnCyAKIAEoAgAgASgCBCgCHBEEACIINgIMIAJBA3QiBEEIayEDIAEgBGohBQNAIAMgBkYNAiABIAZqIQQgBkEIaiEGIARBCGooAgAgBEEMaigCACgCHBEEACAIELwIDQALIApBEGoiBEHcx4IBEKUrIAopAxghJyAKKQMQISggBCAKQY8BakEEQQhBEBCdFCAKKAIUIQQCQCAKKAIQIgZFBEAgCjUCGCEmDAELIAopAhghJiAEQQlqIghFDQAgBkH/ASAI/AsACyAKICc3AyggCiAoNwMgIAogJjcDGCAKIAQ2AhQgCiAGNgIQIApBATYCRCAKQYDzggE2AkAgCkIBNwJMIApBpwQ2AoQBIAogCkGAAWo2AkggCiAKQQxqNgKAASAKQTRqIApBQGsQmQ4gCkEQaiAKKAIMELoMGgJAIAJFDQADQCAKQRBqIAEoAgAiAiABQQRqKAIAKAIcIgQRBAAQugwhBgJAAkAgCigCHEELRwRAIAZFDQEMAgsgCkE0akGI84IBQY3zggEQvSYMAwsgCkE0aiIGQbTzggFBtvOCARC9JiACIAQRBAAgCkEANgKIASAKQoCAgIAQNwKAASAKQeDHggE2AkQgCkKggICADjcCSCAKIApBgAFqNgJAIApBQGsQrhANBSAKQeAAaiAKQYgBaigCACICNgIAIAogCikCgAE3A1ggBiAKKAJcIgQgAiAEahC9JiAKQdgAahDeOwsgAUEIaiIBIAVHDQALCyAKQTRqQaDzggFBovOCARC9JiAKQcgAaiIBIApBPGooAgA2AgAgCiAKKQI0NwNAIApBEGpBBEEIENknIABBjYCAgHg2AgAgACAKKQNANwIEIABBDGogASgCADYCAAwmCyABIAooAhhBpMmCARD9LwALIAgtAABBAWsOKBEhIB8eHRwbGhkYFxACAQ8OIyINEgwLCgkIBxISBhIFEgQWFRQTEgMSC0GIyIIBQTcgCkGPAWpB+MeCAUHAyIIBENUeAAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNMyAFKAIMIQYgA0E8aiIEQo+evPjw4cOHDzcCKCAEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBMGpBj568+AA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQxSVFBEAgB0EoakGPnrz4ADYCACAHQo+evPjw4cOHDzcDIAw1CyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPohIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDSQgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxDAEyABQYADaiQAQThBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBiN+CATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADCMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQRBBBCgGCAFKAIIIQcgBSgCBEEBRg0yIAUoAgwhBiADQTxqIgRCjpy48ODBg4cONwIoIAQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEEwakGOnLjwADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDCJUUEQCAHQShqQY6cuPAANgIAIAdCjpy48ODBg4cONwMgDDQLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/yEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNIyACKAIQIQcgA0EIaiACKAIUIglBAnYiDBDuLSAJQXxxIgkEQCADKAIMIAMoAhBBAnRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENs8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgMAANwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8RggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHEMQTIAFBgANqJABBOEEEEK02IgFFDSMgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEHI5IIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMIgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCELIAogCEEEajYCbAJAAkACQAJAIAgoAgQtADBBA2sOAwECAwALIApBATYCFCAKQaTyggE2AhAgCkIBNwIcIApBsxA2AkQgCiAKQUBrNgIYIAogCkHsAGo2AkAgCkEQakGs8oIBEO8sAAsjAEHwAmsiCyQAIAtBBGohBCABIAJBA3RqIQgjAEEQayIFJAACQAJAA0AgASAIRg0BIAFBBGohAiABKAIAIAFBCGoiAyEBIAIoAgAQjiIiAigCGEUNAAsgBUEEaiIBQQRBAEEEQQQQoBggBSgCCCEGIAUoAgRBAUYNNyAFKAIMIgcgAjYCACAFQQxqIglBATYCACAFIAc2AgggBSAGNgIEA0ACQAJAAkAgAyAIRwRAIAMoAgAgA0EEaigCABCOIiIGKAIYDQEMAgsMAgsgASgCCCICIAEoAgBGBEAgASACQQFBBEEEEN4oCyABKAIEIAJBAnRqIAY2AgAgASACQQFqNgIICyADQQhqIQMMAQsLIARBCGogCSgCADYCACAEIAUpAgQ3AgAMAQsgBEEANgIIIARCgICAgMAANwIACyAFQRBqJAAgCygCDCEbIAsoAgghFSALQQA7AbQBIAsgFTYCrAEgCyAVIBtBAnRqIhw2ArABIAtBATYCqAEgC0EQaiEJIwBBIGsiBiQAAkACQAJAAkACQAJAIAtBqAFqIh0iAi8BACIBQQJGDQAgAiABQQFHIgFBAXQ7AQAgAQ0AIAIvAQIhBAwBCyACKAIEIgFFDQEgASACKAIIRg0BIAIgAUEEajYCBCABKAIAIgEoAhQiBEECSQ07IAEoAhAgBEF+cWpBAmsiAUUNOyACIAEvAQAgAi8BDGoiBDsBDAsgBkEQaiIBQQRBAEECQQIQoBggBigCFCEIIAYoAhBBAUYNAiAGKAIYIgcgBDsBACAGQQxqIgxBATYCACAGIAc2AgggBiAINgIEIAZBGGogAkEIaikCADcDACAGIAIpAgA3AxAgBkEEaiEDIAEvAQwhCCABKAIEIQIgASgCCCENIAEvAQIhDiABLwEAIQcCQANAAkACfwJAIAdBAkYNACABIAdBAUciBEEBdDsBAEEAIQUgBA0AQQAhByAODAELIAJFIAIgDUZyDQMgASACQQRqIgQ2AgQgAigCACICKAIUIgdBAkkNASACKAIQIAdBfnFqQQJrIgJFDQEgASACLwEAIAhqIgg7AQxBAiEHQQEhBSAEIQIgCAshECADKAIIIgQgAygCAEYEQCADQQEgB0EBciAFGxDtLQsgAygCBCAEQQF0aiAQOwEAIAMgBEEBajYCCAwBCwsMOwsgCUEIaiAMKAIANgIAIAkgBikCBDcCAAwBCyAJQQA2AgggCUKAgICAIDcCAAsgBkEgaiQADAELIAggBigCGEHQyIIBEP0vAAsCQAJAIAsoAhgiAUUNACALKAIUIAFBAXRqQQJrIgFFDQAgAS4BACEfIAtBsAFqIAtBGGooAgA2AgAgCyALKQIQNwOoASALQQA2AswBIAtCADcCvAEgCyAcNgK4ASALIBU2ArQBIwBBEGsiGCQAIBhBBGohGSMAQeAAayIRJAAgEUEgaiISIB1BMPwKAAAgEUEUaiEWIwBBQGoiEyQAIBIiBygCFCIBIAcoAggiDCABIAxLGyENIAcoAgQgAUEBdGohCSAHKAIMIQIgBygCECEOIAcoAhghBSAHKAIAQYCAgIB4RiEQIAcoAhwiAyEGAkACQAJAAkACQAJ/AkACQANAAkAgBQRAIAUgBkcNASAHQQA2AhgLIBAEQCADIQYMBAsgAiAORg0DIAcgAUEBaiIENgIUIAcgAkEEaiIINgIMIAEgDUYNAiACKAIAIgEoAhAiBUUNAyAHIAU2AhggByAJLwEAOwEgIAcgBSABKAIUQX5xaiIGNgIcIAlBAmohCSAEIQEgCCECDAELCyAHIAVBAmoiATYCGCAHKAIoIQkgBygCJCECIAcvASAgBS8BAGoMAgsgDSAMQZy4ggEQwyEACyAHKAIkIgRFDQIgBCAHKAIoIglGDQEgByAEQQJqIgI2AiRBACEBIAcvASwgBC8BAGoLIQQgE0EQaiIPQQMgBiABa0EBdkEAIAEbIAkgAmtBAXZBACACG2oiASABQQNNG0EBakEAQQJBAhCgGCATKAIUIQEgEygCEEEBRg0DIBMoAhgiAiAEOwEAIBNBDGoiIEEBNgIAIBMgAjYCCCATIAE2AgQgDyAHQTD8CgAAIBNBBGohFyAPKAIUIQ0gDygCBCEhIA8oAgghGiAPKAIQISIgDygCAEGAgICAeEYhIyAPKAIMIgghByAPKAIcIgIhDiAPKAIYIgkhBQJAAkACQANAIA0gGiANIBpLGyEeICEgDUEBdGohFCAIIQQgAiEBIA0hBiAHIQMgDiEMAkACfwJAAkADQCAFBEAgBSAMRw0DIA9BADYCGEEAIQkLICMEQCACIQEgDiEMIAghBAwCCyADICJGBEAgBiENIAMhBwwCCyAPIAZBAWoiEDYCFCAPIANBBGoiBDYCDCAGIB5GDQcgAygCACIDKAIQIgUEQCAPIAU2AhggDyAULwEAOwEgIA8gBSADKAIUQX5xaiIBNgIcIBRBAmohFCAFIQkgECEGIAQhAyABIQwMAQsLIAZBAWohDSAEIQcLIA8oAiQiAkUNBCACIA8oAihGDQIgDyACQQJqNgIkIA8vASwgAi8BAGohFEEAIQUgASECIAQhCCAMDAELIA8gBUECaiIJNgIYIA8vASAgBS8BAGohFCABIQIgBCEIIAYhDSADIQcgCSEFIAwLIQ4gFygCCCIBIBcoAgBGBEAgFyACIAlrQQF2QQFqQQEgCRsgDygCKCAPKAIkIgRrQQF2QQAgBBtqEO0tIAkhBSACIQ4gCCEHCyAXKAIEIAFBAXRqIBQ7AQAgFyABQQFqNgIIDAELCyAPQQA2AiQLIA8QtDAMAQsgHiAaQZy4ggEQwyEACyAWQQhqICAoAgA2AgAgFiATKQIENwIADAILIAdBADYCJAsgFkEANgIIIBZCgICAgCA3AgAgBxC0MAsgE0FAayQADAELIAEgEygCGEHAg4QBEP0vAAsgEUHQAGogFhDfLCARIBEpAlA3AiwgEUEANgIoIBEgESgCXCICNgIkIBEgESgCWDYCICARQQhqIBIQ1zsgESgCCCEEQRxBBBCtNiIBRQRADEELIAFCgYCAgBA3AgAgASARKQIgNwIIIBkgAjYCCCAZIAQ2AgQgGSABNgIAIAFBEGogEUEoaikCADcCACABQRhqIBFBMGooAgA2AgAgEUHgAGokACALQRxqIgFBDGogGUEAIBgoAgxBAXYQ/BwgAUEIakGDhowYNgIAIAFCg4aMmLDgwIEDNwIAIAFBADYCGCAYQRBqJAAgC0GEAmoiAiAVIBwQvRsgHSALKAKIAiALKAKMAhCdASALKAKwASEEIAsoAqwBIQYCQCALKAKoASIIQZOAgIB4RwRAIAAgCykCtAE3AgwgACAENgIIIAAgBjYCBCAAIAg2AgAgAkEEQQgQ4B4gARCBJQwBCyALQYQCaiIBQQRBCBDgHiAbRQ0oIAtByAFqIBUoAgAQywYgC0EAOwGAAiALQQA2AvwBIAtBADYC5AEgC0EANgLYASALIB82AtQBIAtCBDcCwAEgC0IANwK4ASALQoCAgIDAADcCsAEgC0EANgKoAUGIAUEEEK02IgJFDSkgASALQRxqQTD8CgAAIAIgARD5PSACQcQAaiAGIAQQ0yMgC0ECNgKMAiALIAI2AogCIAtBAjYChAIgC0HMAGoiAiALQagBaiIEIAEQ/CIgASACEM0cIAQgARDnFiALKAKoASICQZOAgIB4RwRAIAAgCykCrAE3AgQgAEEMaiALQbQBaikCADcCACAAIAI2AgAgARCDJwwBCyALQagBaiIBIAtBhAJqQcQA/AoAACALQcgCaiICIAEQnwlBMEEEEK02IgFFDSogAUKBgICAEDcCACABQQhqIAJBKPwKAAAgAEHI74IBNgIIIAAgATYCBCAAQZOAgIB4NgIACyALQQRqQQRBBBDgHiALQfACaiQADAELQfjtggEQsjsACwwiCyMAQfACayILJAAgC0EEaiEEIAEgAkEDdGohCCMAQRBrIgUkAAJAAkADQCABIAhGDQEgAUEEaiECIAEoAgAgAUEIaiIDIQEgAigCABCNIiICKAIYRQ0ACyAFQQRqIgFBBEEAQQRBBBCgGCAFKAIIIQYgBSgCBEEBRg02IAUoAgwiByACNgIAIAVBDGoiCUEBNgIAIAUgBzYCCCAFIAY2AgQDQAJAAkACQCADIAhHBEAgAygCACADQQRqKAIAEI0iIgYoAhgNAQwCCwwCCyABKAIIIgIgASgCAEYEQCABIAJBAUEEQQQQ3igLIAEoAgQgAkECdGogBjYCACABIAJBAWo2AggLIANBCGohAwwBCwsgBEEIaiAJKAIANgIAIAQgBSkCBDcCAAwBCyAEQQA2AgggBEKAgICAwAA3AgALIAVBEGokACALKAIMIRwgCygCCCEWIAtBADYCuAEgCyAWNgKwASALQgE3AqgBIAsgFiAcQQJ0aiIdNgK0ASALQRBqIQkjAEEwayIGJAACQAJAAkACQAJAAkAgC0GoAWoiHiICKAIAIgFBAkYNACACIAFBAUciAUEBdDYCACABDQAgAigCBCEEDAELIAIoAggiAUUNASABIAIoAgxGDQEgAiABQQRqNgIIIAEoAgAiASgCFCIEQQRJDTogASgCECAEQXxxakEEayIBRQ06IAIgASgCACACKAIQaiIENgIQCyAGQRhqIgFBBEEAQQRBBBCgGCAGKAIcIQggBigCGEEBRg0CIAYoAiAiByAENgIAIAZBFGoiDEEBNgIAIAYgBzYCECAGIAg2AgwgBkEoaiACQRBqKAIANgIAIAZBIGogAkEIaikCADcDACAGIAIpAgA3AxggBkEMaiEDIAEoAhAhCCABKAIIIQIgASgCDCENIAEoAgQhDiABKAIAIQcCQANAAkACfwJAIAdBAkYNACABIAdBAUciBEEBdDYCAEEAIQUgBA0AQQAhByAODAELIAJFIAIgDUZyDQMgASACQQRqIgQ2AgggAigCACICKAIUIgdBBEkNASACKAIQIAdBfHFqQQRrIgJFDQEgASACKAIAIAhqIgg2AhBBAiEHQQEhBSAEIQIgCAshECADKAIIIgQgAygCAEYEQCADQQEgB0EBciAFGxDuLQsgAygCBCAEQQJ0aiAQNgIAIAMgBEEBajYCCAwBCwsMOgsgCUEIaiAMKAIANgIAIAkgBikCDDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAZBMGokAAwBCyAIIAYoAiBB0MiCARD9LwALAkACQCALKAIYIgFFDQAgCygCFCABQQJ0akEEayIBRQ0AIAEoAgAhICALQbABaiALQRhqKAIANgIAIAsgCykCEDcDqAEgC0EANgLMASALQgA3ArwBIAsgHTYCuAEgCyAWNgK0ASMAQRBrIhkkACAZQQRqIRojAEHgAGsiEyQAIBNBIGoiDyAeQTD8CgAAIBNBFGohFyMAQUBqIhQkACAPKAIUIgEgDygCCCIDIAEgA0sbIQwgDygCBCABQQJ0aiEJIA8oAgwhAiAPKAIQIQ0gDygCGCEFIA8oAgBBgICAgHhGIQ4gDygCHCIHIQYCQAJAAkACQAJAAn8CQAJAA0ACQCAFBEAgBSAGRw0BIA9BADYCGAsgDgRAIAchBgwECyACIA1GDQMgDyABQQFqIgQ2AhQgDyACQQRqIgg2AgwgASAMRg0CIAIoAgAiASgCECIFRQ0DIA8gBTYCGCAPIAkoAgA2AiAgDyAFIAEoAhRBfHFqIgY2AhwgCUEEaiEJIAQhASAIIQIMAQsLIA8gBUEEaiIBNgIYIA8oAighCSAPKAIkIQIgDygCICAFKAIAagwCCyAMIANBnLiCARDDIQALIA8oAiQiBEUNAiAEIA8oAigiCUYNASAPIARBBGoiAjYCJEEAIQEgDygCLCAEKAIAagshBCAUQRBqIhFBAyAGIAFrQQJ2QQAgARsgCSACa0ECdkEAIAIbaiIBIAFBA00bQQFqQQBBBEEEEKAYIBQoAhQhASAUKAIQQQFGDQMgFCgCGCICIAQ2AgAgFEEMaiIhQQE2AgAgFCACNgIIIBQgATYCBCARIA9BMPwKAAAgFEEEaiEYIBEoAhQhAyARKAIEISIgESgCCCEbIBEoAhAhIyARKAIAQYCAgIB4RiEkIBEoAgwiByEGIBEoAhwiCCENIBEoAhgiCSEFAkACQAJAA0AgAyAbIAMgG0sbIR8gIiADQQJ0aiElQQAhFSAHIQQgCCECIAMhASAGIQ4gDSEMAkACfwJAAkACQANAIAYgFWohEiAFBEAgBSAMRw0EIBFBADYCGEEAIQkLICQEQCAIIQIgDSEMIAchBCADIQEMAwsgEiAjRg0BIBEgAUEBaiIQNgIUIBEgBiAVakEEajYCDCABIB9GDQggDkEEaiEEIBIoAgAiDigCECIFBEAgESAFNgIYIBEgFSAlaigCADYCICARIAUgDigCFEF8cWoiAjYCHCAVQQRqIRUgBSEJIBAhASAEIQ4gAiEMDAELCyABQQFqIQEgBCEGDAELIAYgFWohBgsgESgCJCIIRQ0EIAggESgCKEYNAiARIAhBBGo2AiQgESgCLCAIKAIAaiEOQQAhBSACIQggBCEHIAEhAyAMDAELIBEgBUEEaiIJNgIYIBEoAiAgBSgCAGohDiACIQggBCEHIAEhAyASIQYgCSEFIAwLIQ0gGCgCCCIBIBgoAgBGBEAgGCAIIAlrQQJ2QQFqQQEgCRsgESgCKCARKAIkIgJrQQJ2QQAgAhtqEO4tIAkhBSAIIQ0gByEGCyAYKAIEIAFBAnRqIA42AgAgGCABQQFqNgIIDAELCyARQQA2AiQLIBEQlzAMAQsgHyAbQZy4ggEQwyEACyAXQQhqICEoAgA2AgAgFyAUKQIENwIADAILIA9BADYCJAsgF0EANgIIIBdCgICAgMAANwIAIA8QlzALIBRBQGskAAwBCyABIBQoAhhBwIOEARD9LwALIBNB0ABqIBcQ4CwgEyATKQJQNwIsIBNBADYCKCATIBMoAlwiAjYCJCATIBMoAlg2AiAgE0EIaiAPENc7IBMoAgghBEEcQQQQrTYiAUUEQAxACyABQoGAgIAQNwIAIAEgEykCIDcCCCAaIAI2AgggGiAENgIEIBogATYCACABQRBqIBNBKGopAgA3AgAgAUEYaiATQTBqKAIANgIAIBNB4ABqJAAgC0EcaiIBQQxqIBpBACAZKAIMQQJ2EIAdIAFBCGpBhIiQIDYCACABQoSIkKDAgIGCBDcCACABQQA2AhggGUEQaiQAIAtBhAJqIgIgFiAdEL0bIB4gCygCiAIgCygCjAIQnQEgCygCsAEhBCALKAKsASEGAkAgCygCqAEiCEGTgICAeEcEQCAAIAspArQBNwIMIAAgBDYCCCAAIAY2AgQgACAINgIAIAJBBEEIEOAeIAEQgSUMAQsgC0GEAmoiAUEEQQgQ4B4gHEUNJyALQcgBaiAWKAIAEMsGIAtBADsBgAIgC0EANgL8ASALQQA2AuQBIAtBADYC2AEgCyAgNgLUASALQgQ3AsABIAtCADcCuAEgC0KAgICAwAA3ArABIAtBADYCqAFBiAFBBBCtNiICRQ0oIAEgC0EcakEw/AoAACACIAEQ8T0gAkHEAGogBiAEENMjIAtBAjYCjAIgCyACNgKIAiALQQI2AoQCIAtBzABqIgIgC0GoAWoiBCABEPwiIAEgAhDNHCAEIAEQ5xYgCygCqAEiAkGTgICAeEcEQCAAIAspAqwBNwIEIABBDGogC0G0AWopAgA3AgAgACACNgIAIAEQgycMAQsgC0GoAWoiASALQYQCakHEAPwKAAAgC0HIAmoiAiABEJ4JQTBBBBCtNiIBRQ0pIAFCgYCAgBA3AgAgAUEIaiACQSj8CgAAIABBmO6CATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgC0EEakEEQQQQ4B4gC0HwAmokAAwBC0H47YIBELI7AAsMIQsjAEHwAmsiCyQAIAtBBGohBCABIAJBA3RqIQgjAEEQayIFJAACQAJAA0AgASAIRg0BIAFBBGohAiABKAIAIAFBCGoiAyEBIAIoAgAQjyIiAigCGEUNAAsgBUEEaiIBQQRBAEEEQQQQoBggBSgCCCEGIAUoAgRBAUYNNSAFKAIMIgcgAjYCACAFQQxqIglBATYCACAFIAc2AgggBSAGNgIEA0ACQAJAAkAgAyAIRwRAIAMoAgAgA0EEaigCABCPIiIGKAIYDQEMAgsMAgsgASgCCCICIAEoAgBGBEAgASACQQFBBEEEEN4oCyABKAIEIAJBAnRqIAY2AgAgASACQQFqNgIICyADQQhqIQMMAQsLIARBCGogCSgCADYCACAEIAUpAgQ3AgAMAQsgBEEANgIIIARCgICAgMAANwIACyAFQRBqJAAgCygCDCEbIAsoAgghFCALQgA3A8ABIAsgFDYCuAEgC0IANwOwASALQgE3A6gBIAsgFCAbQQJ0aiIcNgK8ASALQRBqIQcjAEEwayIGJAACQAJAAkACQAJAAkAgC0GoAWoiHSICKQMAIiZCAlENACACICZQrUIBhjcDACAmp0EBcUUNACACKQMIISYMAQsgAigCECIBRQ0BIAEgAigCFEYNASACIAFBBGo2AhAgASgCACIBKAIUIgRBCEkNOSABKAIQIARBeHFqQQhrIgFFDTkgAiABKQMAIAIpAxh8IiY3AxgLIAZBEGoiAUEEQQBBCEEIEKAYIAYoAhQhBCAGKAIQQQFGDQIgBigCGCIIICY3AwAgBkEMaiIDQQE2AgAgBiAINgIIIAYgBDYCBCAGQShqIAJBGGopAwA3AwAgBkEgaiACQRBqKQMANwMAIAZBGGogAkEIaikDADcDACAGIAIpAwA3AxAgBkEEaiEIIAEpAxghKCABKAIQIQIgASgCFCEFIAEpAwghKSABKQMAISYCQANAAkBCAiEnAn4CQCAmQgJRDQAgASAmUK1CAYYiJzcDACAmp0EBcUUNACAnISYgKQwBCyACRSACIAVGcg0DIAEgAkEEaiIENgIQIAIoAgAiAigCFCIJQQhJDQEgAigCECAJQXhxakEIayICRQ0BIAEgAikDACAofCIoNwMYIAQhAiAnISYgKAshJyAIKAIIIgQgCCgCAEYEQCAIQQEgJqdBAWogJkICURsQ7C0LIAgoAgQgBEEDdGogJzcDACAIIARBAWo2AggMAQsLDDkLIAdBCGogAygCADYCACAHIAYpAgQ3AgAMAQsgB0EANgIIIAdCgICAgIABNwIACyAGQTBqJAAMAQsgBCAGKAIYQdDIggEQ/S8ACwJAAkAgCygCGCIBRQ0AIAsoAhQgAUEDdGpBCGsiAUUNACABKAIAIR8gC0GwAWogC0EYaigCADYCACALIAspAhA3A6gBIAtBADYC0AEgC0IANwK8ASALIBw2ArgBIAsgFDYCtAEjAEEQayIXJAAgF0EEaiEYIwBB4ABrIhEkACARQRhqIhIgHUE4/AoAACARQQxqIRUjAEHQAGsiEyQAIBIiBygCFCIBIAcoAggiCSABIAlLGyEMIAcoAgQgAUEDdGohDSAHKAIMIQIgBygCECEOIAcoAhghBSAHKAIAQYCAgIB4RiEQIAcoAhwiAyEGAkACQAJAAkACQAJ+AkACQANAAkAgBQRAIAUgBkcNASAHQQA2AhgLIBAEQCADIQYMBAsgAiAORg0DIAcgAUEBaiIENgIUIAcgAkEEaiIINgIMIAEgDEYNAiACKAIAIgEoAhAiBUUNAyAHIAU2AhggByANKQMANwMgIAcgBSABKAIUQXhxaiIGNgIcIA1BCGohDSAEIQEgCCECDAELCyAHIAVBCGoiATYCGCAHKAIsIQ0gBygCKCECIAcpAyAgBSkDAHwMAgsgDCAJQZy4ggEQwyEACyAHKAIoIgRFDQIgBCAHKAIsIg1GDQEgByAEQQhqIgI2AihBACEBIAcpAzAgBCkDAHwLISYgE0EYaiIPQQMgBiABa0EDdkEAIAEbIA0gAmtBA3ZBACACG2oiASABQQNNG0EBakEAQQhBCBCgGCATKAIcIQEgEygCGEEBRg0DIBMoAiAiAiAmNwMAIBNBFGoiIEEBNgIAIBMgAjYCECATIAE2AgwgDyAHQTj8CgAAIBNBDGohFiAPKAIUIQ0gDygCBCEhIA8oAgghGSAPKAIQISIgDygCAEGAgICAeEYhIyAPKAIMIgEhAiAPKAIcIg4hByAPKAIYIgkhBQJAAkACQANAIA0gGSANIBlLGyEeICEgDUEDdGohGiABIQQgDiEMIA0hBiACIQMgByEIAkACfwJAAkADQCAFBEAgBSAIRw0DIA9BADYCGEEAIQkLICMEQCAOIQwgByEIIAEhBAwCCyADICJGBEAgBiENIAMhAgwCCyAPIAZBAWoiEDYCFCAPIANBBGoiBDYCDCAGIB5GDQcgAygCACIDKAIQIgUEQCAPIAU2AhggDyAaKQMANwMgIA8gBSADKAIUQXhxaiIMNgIcIBpBCGohGiAFIQkgECEGIAQhAyAMIQgMAQsLIAZBAWohDSAEIQILIA8oAigiAUUNBCABIA8oAixGDQIgDyABQQhqNgIoIA8pAzAgASkDAHwhJkEAIQUgCCEHIAQhASAMDAELIA8gBUEIaiIJNgIYIA8pAyAgBSkDAHwhJiAIIQcgBCEBIAYhDSADIQIgCSEFIAwLIQ4gFigCCCIEIBYoAgBGBEAgFiAOIAlrQQN2QQFqQQEgCRsgDygCLCAPKAIoIgJrQQN2QQAgAhtqEOwtIAkhBSAOIQcgASECCyAWKAIEIARBA3RqICY3AwAgFiAEQQFqNgIIDAELCyAPQQA2AigLIA8QhTAMAQsgHiAZQZy4ggEQwyEACyAVQQhqICAoAgA2AgAgFSATKQIMNwIADAILIAdBADYCKAsgFUEANgIIIBVCgICAgIABNwIAIAcQhTALIBNB0ABqJAAMAQsgASATKAIgQcCDhAEQ/S8ACyARQdAAaiAVEN4sIBEgESkCUDcCJCARQQA2AiAgESARKAJcIgI2AhwgESARKAJYNgIYIBEgEhDXOyARKAIAIQRBHEEEEK02IgFFBEAMPwsgAUKBgICAEDcCACABIBEpAhg3AgggGCACNgIIIBggBDYCBCAYIAE2AgAgAUEQaiARQSBqKQIANwIAIAFBGGogEUEoaigCADYCACARQeAAaiQAIAtBHGoiAUEMaiAYQQAgFygCDEEDdhD+HCABQQhqQYWKlCg2AgAgAUKFipSo0KDBggU3AgAgAUEANgIYIBdBEGokACALQYQCaiICIBQgHBC9GyAdIAsoAogCIAsoAowCEJ0BIAsoArABIQQgCygCrAEhBgJAIAsoAqgBIghBk4CAgHhHBEAgACALKQK0ATcCDCAAIAQ2AgggACAGNgIEIAAgCDYCACACQQRBCBDgHiABEIElDAELIAtBhAJqIgFBBEEIEOAeIBtFDSYgC0HIAWogFCgCABDLBiALQQA7AYACIAtBADYC/AEgC0EANgLkASALQQA2AtgBIAsgHzYC1AEgC0IENwLAASALQgA3ArgBIAtCgICAgMAANwKwASALQQA2AqgBQYgBQQQQrTYiAkUNJyABIAtBHGpBMPwKAAAgAiABEPA9IAJBxABqIAYgBBDTIyALQQI2AowCIAsgAjYCiAIgC0ECNgKEAiALQcwAaiICIAtBqAFqIgQgARD8IiABIAIQzRwgBCABEOcWIAsoAqgBIgJBk4CAgHhHBEAgACALKQKsATcCBCAAQQxqIAtBtAFqKQIANwIAIAAgAjYCACABEIMnDAELIAtBqAFqIgEgC0GEAmpBxAD8CgAAIAtByAJqIgIgARCgCUEwQQQQrTYiAUUNKCABQoGAgIAQNwIAIAFBCGogAkEo/AoAACAAQfDuggE2AgggACABNgIEIABBk4CAgHg2AgALIAtBBGpBBEEEEOAeIAtB8AJqJAAMAQtB+O2CARCyOwALDCALIAogCEEEajYCaAJAAkACQAJAAkACQAJAAkACQCAIKAIELQAAQQJrDggBAgMEBQYHCAALIApBATYCFCAKQcDxggE2AhAgCkIBNwIcIApBxRM2AkQgCiAKQUBrNgIYIAogCkHoAGo2AkAgCkEQakHI8YIBEO8sAAsgCkEQaiEMIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiDSgCACIEIA0oAgQiBkcEQCANIARBCGoiCDYCACAEKAIAIAQoAgQQhCIiAygCICEEIA0oAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg09IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiANQQhqKAIANgIAIAkgDSkCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQhCIiESgCICALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiAyAFKAIUIgggBSgCCBCLD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIAwgASACIA0Q+hQMAQsgBUG4AWogAyAIQQAgBRDIAiAFKALMASEJIAUoAsgBIQ0gBSgCxAEhASAFKALAASECIAUoArwBIQQgBSgCuAFBAUYEQCAMIAk2AhAgDCANNgIMIAwgATYCCCAMIAI2AgQgDCAENgIADAELIAVBuAFqIAUoAghBAEEBQQEQoBggBSgCvAEhBgJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgBjYCGCAFQgA3AtABIAUgAiABQQxsaiISNgLMASAFIAQ2AsgBIAUgAjYCxAEgBSACNgLAASAFIAM2ArgBIAUgAyAIQQJ0aiILNgK8ASAFQcABaiEOIAhFDQEgAyEBA0ACQCAFIAFBBGoiBDYCuAEgAiASRg0AIAUgAkEMaiIGNgLEASACKAIAIhBBgICAgHhGDQAgBSACKQIENwLwASAFIBA2AuwBIAEoAgAQtzogBSABKAIAQRhqEPQvIAUoAgAiAiAFKAIEIhFHBEADQEEAIQEgAiwAACIQIAUoAvQBSQRAIAUoAvABIBBqLQAAIQELIAUoAiAiECAFKAIYRgRAIAVBGGpByMyCARCjKAsgBSgCHCAQaiABOgAAIAUgEEEBajYCICACQQFqIgIgEUcNAAsLQQBHIAdyIQcgBUHsAWoQ3jsgBiECIAQiASALRw0BCwsgDhC6ICAHQQFxRQ0CQcAAIQEgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNQSACBEAgAkHAABCtNiIBRQ0yCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAIQQJ0IQIDQAJAIAMoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogAygCACgCIBDmEAsgA0EEaiEDIAJBBGsiAg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsgBiAFKALAAUHQy4IBEP0vAAsgDhC6IAsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEO4YIAVBPGoiBCACIAVBJGoQ2B0gBSAFQcgAaigCCCICNgJsIAIgBSgCCEcNPiABIARBMPwKAAAgBUHwAGoiAiABIA0gCRDHFUHQAEEEEK02IgFFDS4gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIAxBsM2CATYCCCAMIAE2AgQgDEGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCYLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIMiIgMQyzwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNPCAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIMiIhEQyzwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQig9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQwwIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBAkECEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgEoAiAiCUECTwRAIAEoAhwhBiAJQX5xIQEDQEEAIQkgBi4BACIPIAUoAvQBSQRAIAUoAvABIA9BAXRqLwEAIQkLIAUoAiAiDyAFKAIYRgRAIAVBGGpByMyCARCtKAsgBkECaiEGIAUoAhwgD0EBdGogCTsBACAFIA9BAWo2AiAgAUECayIBDQALCyAMIBFyIQwgBUHsAWoQnTwgByEGIAIiASADRw0ACyADIQIMAgsgCxC4IAwDCwwyCyAHIQgLIAUgCDYCxAEgBSACNgK4ASALELggIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAOQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDLPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPwsMLgsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEOkYIAVBPGoiBCACIAVBJGoQ2h0gBSAFQcgAahDZPCICNgJsIAIgBSgCCEcNPSABIARBMPwKAAAgBUHwAGoiAiABIBIgEBDHFUHQAEEEEK02IgFFDS0gAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1BkNCCATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCULIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIciIgMQyTwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOyAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIciIhEQyTwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQiQ9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQxAIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBBEEEEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgEoAiAiCUEETwRAIAEoAhwhBiAJQXxxIQEDQEEAIQkgBigCACIPIAUoAvQBSQRAIAUoAvABIA9BAnRqKAIAIQkLIAUoAiAiDyAFKAIYRgRAIAVBGGpByMyCARCdKAsgBkEEaiEGIAUoAhwgD0ECdGogCTYCACAFIA9BAWo2AiAgAUEEayIBDQALCyAMIBFyIQwgBUHsAWoQ6TsgByEGIAIiASADRw0ACyADIQIMAgsgCxCRIAwDCwwxCyAHIQgLIAUgCDYCxAEgBSACNgK4ASALEJEgIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAOQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDJPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPgsMLQsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEOgYIAVBPGoiBCACIAVBJGoQvx0gBSAFQcgAahDbPCICNgJsIAIgBSgCCEcNPCABIARBMPwKAAAgBUHwAGoiAiABIBIgEBDHFUHQAEEEEK02IgFFDSwgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1B4M6CATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJQsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCQLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIUiIgMQyjwhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOiAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIUiIhEQyjwgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIJIAUoAggQ4g9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgCUEAIAUQwAIgBSgCzAEhDiAFKALIASEQIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAONgIQIA0gEDYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBCEEIEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAJQQJ0aiIDNgK8ASAFQcABaiESIAkEQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIgtBgICAgHhGDQMgBSAGKQIENwLwASAFIAs2AuwBIAEoAgAQtzpBAEchDyABKAIAIgEoAiAiC0EITwRAIAEoAhwhBiALQXhxIQEDQEIAISYgBigCACILIAUoAvQBSQRAIAUoAvABIAtBA3RqKQMAISYLIAUoAiAiCyAFKAIYRgRAIAVBGGpByMyCARCzKAsgBkEIaiEGIAUoAhwgC0EDdGogJjcDACAFIAtBAWo2AiAgAUEIayIBDQALCyAMIA9yIQwgBUHsAWoQ4zwgByEGIAMgAiIBRw0ACyADIQIMAgsgEhC7IAwDCwwwCyAHIQgLIAUgCDYCxAEgBSACNgK4ASASELsgIAxBAXFFDQBBwAAhAQJAIAUoAggiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TQEQCACBEAgAkHAABCtNiIBRQ0CCyAFQgA3AvgBIAUgATYC9AEgBSACNgLwASAFQcAANgLsASAJQQJ0IQYDQAJAIAQoAgAQkzYiAQRAIAVB7AFqIAEQlS8MAQsgBUHsAWogBCgCABDKPBDmEAsgBEEEaiEEIAZBBGsiBg0ACyAFQbgBaiIBIAVB7AFqIgIQhRQgBUEkaiABEOEnIAIQzy8MAwsMPQsMLAsgBUEANgIkCyAFQcABaiAFQSBqKAIANgIAIAUgBSkCGDcDuAEgBUHsAWoiAiAFQbgBaiIBEL0YIAVBPGoiBCACIAVBJGoQ1h0gBSAFQcgAahDYPCICNgJsIAIgBSgCCEcNOyABIARBMPwKAAAgBUHwAGoiAiABIBAgDhDHFUHQAEEEEK02IgFFDSsgAUKBgICAEDcCACABQQhqIAJByAD8CgAAIA1B6NCCATYCCCANIAE2AgQgDUGTgICAeDYCAAsgBUEMakEEQQQQ4B4gBUGAAmokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMJAsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIApBEGohDSMAQYACayIFJAAgBUEANgIIIAUgASACQQN0ajYCvAEgBSABNgK4ASAFIAVBCGo2AsABIAVBDGohDiMAQSBrIgkkAAJAIAVBuAFqIgcoAgAiBCAHKAIEIgZHBEAgByAEQQhqIgg2AgAgBCgCACAEKAIEEIkiIgMoAiAhBCAHKAIIIhAgBCAQKAIAajYCACAJQRBqIhBBAyAGIAhrQQN2IgQgBEEDTRtBAWpBAEEEQQQQoBggCSgCFCEEIAkoAhBBAUYNOSAJKAIYIgYgAzYCACAJQQxqIg9BATYCACAJIAY2AgggCSAENgIEIAlBGGogB0EIaigCADYCACAJIAcpAgA3AxAgECgCACIEIBAoAgQiEkcEQCAJQQRqIQMgEiAEa0EIayEIIBAoAgghCwNAIBAgBEEIaiIGNgIAIAsgBCgCACAEQQRqKAIAEIkiIhEoAiAgCygCAGo2AgAgAygCCCIEIAMoAgBGBEAgAyAEIAhBA3ZBAWpBBEEEEN4oCyADKAIEIARBAnRqIBE2AgAgAyAEQQFqNgIIIAhBCGshCCAGIgQgEkcNAAsLIA5BCGogDygCADYCACAOIAkpAgQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyAJQSBqJAACQCAFKAIQIgQgBSgCFCIOIAUoAggQjQ9FBEAgBSAFKAIINgK8ASAFQYWAgIB4NgK4ASANIAEgAiAHEPoUDAELIAVBuAFqIAQgDkEAIAUQxwIgBSgCzAEhECAFKALIASESIAUoAsQBIQEgBSgCwAEhBiAFKAK8ASECIAUoArgBQQFGBEAgDSAQNgIQIA0gEjYCDCANIAE2AgggDSAGNgIEIA0gAjYCAAwBCyAFQbgBaiAFKAIIQQBBAUEBEKAYIAUoArwBIQMCQAJAAkACQCAFKAK4AUEBRwRAIAVBADYCICAFIAUoAsABNgIcIAUgAzYCGCAFQgA3AtABIAUgBiABQQxsaiIINgLMASAFIAI2AsgBIAUgBjYCxAEgBSAGNgLAASAFIAQ2ArgBIAUgBCAOQQJ0aiIDNgK8ASAFQcABaiELIA4EQCAEIQEDQCABQQRqIQIgBiAIRg0EIAZBDGohByAGKAIAIglBgICAgHhGDQMgBSAGKQIENwLwASAFIAk2AuwBIAEoAgAQtzpBAEchESABKAIAIgYoAiAiAQRAIAYoAhwhBgNAQQAhCSAGLQAAIg8gBSgC9AFJBEAgBSgC8AEgD2otAAAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEKkZCyAGQQFqIQYgBSgCHCAPaiAJOgAAIAUgD0EBajYCICABQQFrIgENAAsLIAwgEXIhDCAFQewBahDeOyAHIQYgAiIBIANHDQALIAMhAgwCCyALELogDAMLDC8LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQuiAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAKAIgEOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww8CwwrCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ7hggBUE8aiIEIAIgBUEkahDBHSAFIAVByABqKAIIIgI2AmwgAiAFKAIIRw06IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKiABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUGIzoIBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwjCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIgsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQiCIiAxDLPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg04IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQiCIiERDLPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIg4gBSgCCBCMD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAOQQAgBRDBAiAFKALMASEQIAUoAsgBIRIgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIBA2AhAgDSASNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEECQQIQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIA5BAnRqIgM2ArwBIAVBwAFqIQsgDgRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiCUGAgICAeEYNAyAFIAYpAgQ3AvABIAUgCTYC7AEgASgCABC3OkEARyERIAEoAgAiASgCICIJQQJPBEAgASgCHCEGIAlBfnEhAQNAQQAhCSAGLwEAIg8gBSgC9AFJBEAgBSgC8AEgD0EBdGovAQAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEK0oCyAGQQJqIQYgBSgCHCAPQQF0aiAJOwEAIAUgD0EBajYCICABQQJrIgENAAsLIAwgEXIhDCAFQewBahCdPCAHIQYgAiIBIANHDQALIAMhAgwCCyALELggDAMLDC4LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQuCAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMs8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww7CwwqCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ6RggBUE8aiIEIAIgBUEkahDNHSAFIAVByABqENk8IgI2AmwgAiAFKAIIRw05IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKSABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUHwy4IBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwiCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIQsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQiiIiAxDJPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg03IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQiiIiERDJPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIg4gBSgCCBDkD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAOQQAgBRDCAiAFKALMASEQIAUoAsgBIRIgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIBA2AhAgDSASNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEEEQQQQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIA5BAnRqIgM2ArwBIAVBwAFqIQsgDgRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiCUGAgICAeEYNAyAFIAYpAgQ3AvABIAUgCTYC7AEgASgCABC3OkEARyERIAEoAgAiASgCICIJQQRPBEAgASgCHCEGIAlBfHEhAQNAQQAhCSAGKAIAIg8gBSgC9AFJBEAgBSgC8AEgD0ECdGooAgAhCQsgBSgCICIPIAUoAhhGBEAgBUEYakHIzIIBEJ0oCyAGQQRqIQYgBSgCHCAPQQJ0aiAJNgIAIAUgD0EBajYCICABQQRrIgENAAsLIAwgEXIhDCAFQewBahDpOyAHIQYgAiIBIANHDQALIAMhAgwCCyALEJEgDAMLDC0LIAchCAsgBSAINgLEASAFIAI2ArgBIAsQkSAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIA5BAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMk8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww6CwwpCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ6BggBUE8aiIEIAIgBUEkahDHHSAFIAVByABqENs8IgI2AmwgAiAFKAIIRw04IAEgBEEw/AoAACAFQfAAaiICIAEgEiAQEMcVQdAAQQQQrTYiAUUNKCABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUG4z4IBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwhCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMIAsgCkEQaiENIwBBgAJrIgUkACAFQQA2AgggBSABIAJBA3RqNgK8ASAFIAE2ArgBIAUgBUEIajYCwAEgBUEMaiEOIwBBIGsiCSQAAkAgBUG4AWoiBygCACIEIAcoAgQiBkcEQCAHIARBCGoiCDYCACAEKAIAIAQoAgQQhiIiAxDKPCEEIAcoAggiECAEIBAoAgBqNgIAIAlBEGoiEEEDIAYgCGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCAJKAIUIQQgCSgCEEEBRg02IAkoAhgiBiADNgIAIAlBDGoiD0EBNgIAIAkgBjYCCCAJIAQ2AgQgCUEYaiAHQQhqKAIANgIAIAkgBykCADcDECAQKAIAIgQgECgCBCISRwRAIAlBBGohAyASIARrQQhrIQggECgCCCELA0AgECAEQQhqIgY2AgAgCyAEKAIAIARBBGooAgAQhiIiERDKPCALKAIAajYCACADKAIIIgQgAygCAEYEQCADIAQgCEEDdkEBakEEQQQQ3igLIAMoAgQgBEECdGogETYCACADIARBAWo2AgggCEEIayEIIAYiBCASRw0ACwsgDkEIaiAPKAIANgIAIA4gCSkCBDcCAAwBCyAOQQA2AgggDkKAgICAwAA3AgALIAlBIGokAAJAIAUoAhAiBCAFKAIUIgkgBSgCCBDjD0UEQCAFIAUoAgg2ArwBIAVBhYCAgHg2ArgBIA0gASACIAcQ+hQMAQsgBUG4AWogBCAJQQAgBRDAAiAFKALMASEOIAUoAsgBIRAgBSgCxAEhASAFKALAASEGIAUoArwBIQIgBSgCuAFBAUYEQCANIA42AhAgDSAQNgIMIA0gATYCCCANIAY2AgQgDSACNgIADAELIAVBuAFqIAUoAghBAEEIQQgQoBggBSgCvAEhAwJAAkACQAJAIAUoArgBQQFHBEAgBUEANgIgIAUgBSgCwAE2AhwgBSADNgIYIAVCADcC0AEgBSAGIAFBDGxqIgg2AswBIAUgAjYCyAEgBSAGNgLEASAFIAY2AsABIAUgBDYCuAEgBSAEIAlBAnRqIgM2ArwBIAVBwAFqIRIgCQRAIAQhAQNAIAFBBGohAiAGIAhGDQQgBkEMaiEHIAYoAgAiC0GAgICAeEYNAyAFIAYpAgQ3AvABIAUgCzYC7AEgASgCABC3OkEARyEPIAEoAgAiASgCICILQQhPBEAgASgCHCEGIAtBeHEhAQNAQgAhJiAGKAIAIgsgBSgC9AFJBEAgBSgC8AEgC0EDdGopAwAhJgsgBSgCICILIAUoAhhGBEAgBUEYakHIzIIBELMoCyAGQQhqIQYgBSgCHCALQQN0aiAmNwMAIAUgC0EBajYCICABQQhrIgENAAsLIAwgD3IhDCAFQewBahDjPCAHIQYgAyACIgFHDQALIAMhAgwCCyASELsgDAMLDCwLIAchCAsgBSAINgLEASAFIAI2ArgBIBIQuyAgDEEBcUUNAEHAACEBAkAgBSgCCCICQQN2IAJBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNARAIAIEQCACQcAAEK02IgFFDQILIAVCADcC+AEgBSABNgL0ASAFIAI2AvABIAVBwAA2AuwBIAlBAnQhBgNAAkAgBCgCABCTNiIBBEAgBUHsAWogARCVLwwBCyAFQewBaiAEKAIAEMo8EOYQCyAEQQRqIQQgBkEEayIGDQALIAVBuAFqIgEgBUHsAWoiAhCFFCAFQSRqIAEQ4ScgAhDPLwwDCww5CwwoCyAFQQA2AiQLIAVBwAFqIAVBIGooAgA2AgAgBSAFKQIYNwO4ASAFQewBaiICIAVBuAFqIgEQ5xggBUE8aiIEIAIgBUEkahDZHSAFIAVByABqENg8IgI2AmwgAiAFKAIIRw03IAEgBEEw/AoAACAFQfAAaiICIAEgECAOEMcVQdAAQQQQrTYiAUUNJyABQoGAgIAQNwIAIAFBCGogAkHIAPwKAAAgDUHYzIIBNgIIIA0gATYCBCANQZOAgIB4NgIACyAFQQxqQQRBBBDgHiAFQYACaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwgCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMHwsjAEHgAWsiBiQAIAZBADYCFCAGQQA6ABsgBiABNgJ0IAYgASACQQN0ajYCeCAGIAZBG2o2AoABIAYgBkEUajYCfCMAQSBrIgEkACABQRRqIAZB9ABqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB0MiCARD9LwALIAFBEGoiEkEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIHJAAgAigCBCACKAIAa0EDdiIFIAFBCGoiAygCACADKAIIIgRrSwRAIAMgBCAFQQRBBBDeKCADKAIIIQQLIAhBBGohBSAGQRxqIQkgByADKAIENgIMIAcgBDYCCCAHIANBCGo2AgQgB0EEaiIDKAIEIQggAygCACACKAIAIgQgAigCBCIORwRAIAIoAgwhDCACKAIIIQ0gAygCCCAIQQJ0aiECIAggDiAEa0EDdiIDaiEIA0AgDSAEKAIAIg4gBEEEaigCACIQKAIkEQQAIA0oAgBqNgIAIAwgDiAQKAJEEQQAQQBHIAwtAAByOgAAIAIgDiAQEMgvNgIAIARBCGohBCACQQRqIQIgA0EBayIDDQALCyAINgIAIAdBEGokACAJQQhqIBIoAgA2AgAgCSABKQIINwIAIAFBIGokAAJAAkACQAJAAkACQCAGLQAbRQRAIAZBADYCKAwBC0HAACEBIAYoAhQiAkEDdiACQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDQEgAgRAIAJBwAAQrTYiAUUNAwsgBkIANwK0ASAGIAE2ArABIAYgAjYCrAEgBkHAADYCqAEgBigCJCIBBEAgBigCICECIAFBAnQhAQNAAkAgAigCABCcNiIEBEAgBkGoAWogBBCVLwwBCyAGQagBaiACKAIAKAIYEOYQCyACQQRqIQIgAUEEayIBDQALCyAGQfQAaiIBIAZBqAFqIgIQhRQgBkEoaiABEOEnIAIQzy8LIAZBCGogBRDDNCAGIAYoAgw2ArABIAZBADYCrAEgBiAGQRxqNgKoASAGQfQAaiEIIwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiAGQagBaiIBQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEDIwBBMGsiASQAIAFBCGogAkEgaiIEEIgoAkACQAJAIAEoAggiDQRAIAEoAgwhDiABQSBqIglBBEEAQQRBCBCgGCABKAIkIQcgASgCIEEBRg0CIAEoAigiDCAONgIEIAwgDTYCACABQRxqIhBBATYCACABIAw2AhggASAHNgIUIAFBKGogBEEIaikCADcDACABIAQpAgA3AyAjAEEQayIEJAAgBEEIaiAJEIgoIAQoAggiDARAIAFBFGohByAEKAIMIQ0DQCAHKAIIIg4gBygCAEYEQCAHQQEQ6i0LIAcoAgQgDkEDdGoiEiANNgIEIBIgDDYCACAHIA5BAWo2AgggBCAJEIgoIAQoAgQhDSAEKAIAIgwNAAsLIARBEGokACADQQhqIBAoAgA2AgAgAyABKQIUNwIADAELIANBADYCCCADQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEGI+YMBEP0vAAsCQCACKAIAQZOAgIB4RwRAIAggAikCADcCACAIQRBqIAJBEGooAgA2AgAgCEEIaiACQQhqKQIANwIAIAMQwycgAxDqOwwBCyAIIAIpAhQ3AgQgCEGTgICAeDYCACAIQQxqIAJBHGooAgA2AgALIAJBMGokACAGQcgAaiIBIAZBgAFqKAIANgIAIAYgBikCeDcDQAJAIAYoAnQiAkGTgICAeEcEQCAGKAKEASEEIAAgBikDQDcCBCAAIAQ2AhAgACACNgIAIABBDGogASgCADYCACAGKAIoIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAZBKGoQ+x4MAQsgBkHYAGogASgCADYCACAGIAYpA0A3A1AgBSgCACIBIAEoAgAiAkEBajYCACACQQBIDQMgBSgCBCECIAZBuAFqIAZBOGopAgA3AwAgBkGwAWogBkEwaikCADcDACAGIAYpAig3A6gBIAZB9ABqIAEgAiAGQdAAaiAGQagBaiAGKAIUEM8DIAZB6ABqIgEgBkGAAWopAgA3AwAgBkHwAGoiAiAGQYgBaigCADYCACAGIAYpAng3A2AgBigCdCIEQYCAgIB4RgRAIAAgBikDYDcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADAELIAZB2AFqIgIgBkGkAWooAgA2AgAgBkHQAWoiCCAGQZwBaikCADcDACAGQcgBaiIHIAZBlAFqKQIANwMAIAYgBikCjAE3A8ABQTxBBBCtNiIBRQ0EIAEgBDYCCCABQoGAgIAQNwIAIAEgBikDYDcCDCABIAYpA8ABNwIgIABBoO2CATYCCCAAIAE2AgQgAUEUaiAGQegAaikDADcCACABQRxqIAZB8ABqKAIANgIAIAFBKGogBykDADcCACABQTBqIAgpAwA3AgAgAUE4aiACKAIANgIAIABBk4CAgHg2AgALIAZBHGpBBEEEEOAeIAZB4AFqJAAMBAtBsMCCAUEpIAZB9ABqQeDIggFB3MCCARDVHgALQcAAIAIQoz0LAAtBBEE8EKM9AAsMHgsgCEEEaiEVIwBBgAJrIgMkACADQQA2AhAgA0EAOgAWIANBADoAFyADIAE2AnggAyABIAJBA3RqNgJ8IAMgA0EXajYCiAEgAyADQRZqNgKEASADIANBEGo2AoABIANBGGohBiMAQTBrIgEkAAJAIANB+ABqIgIQ3xUiBwRAIAFBGGoiCEEDIAIoAgQgAigCAGtBA3YiBCAEQQNNG0EBakEAQQRBBBCgGCABKAIcIQQgASgCGEEBRg03IAEoAiAiBSAHNgIAIAFBFGoiCUEBNgIAIAEgBTYCECABIAQ2AgwgAUEoaiACQRBqKAIANgIAIAFBIGogAkEIaikCADcDACABIAIpAgA3AxggCBDfFSICBEAgAUEMaiEEA0AgBCgCCCIHIAQoAgBGBEAgBCAHIAgoAgQgCCgCAGtBA3ZBAWpBBEEEEN4oCyAEKAIEIAdBAnRqIAI2AgAgBCAHQQFqNgIIIAgQ3xUiAg0ACwsgBkEIaiAJKAIANgIAIAYgASkCDDcCAAwBCyAGQQA2AgggBkKAgICAwAA3AgALIAFBMGokAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AFkUEQCADQQA2AiQMAQtBwAAhAiADKAIQIgFBA3YgAUEHcUEAR2oiAUHA////A3FBQGsgASABQT9xGyIBQcAAENE0RQ0xIAEEQCABQcAAEK02IgJFDQILIANCADcCvAEgAyACNgK4ASADIAE2ArQBIANBwAA2ArABIAMoAiAiAgRAIAMoAhwhASACQQJ0IQIDQAJAIAEoAgAQmTYiBARAIANBsAFqIAQQlS8MAQsgA0GwAWogASgCABC/OhDmEAsgAUEEaiEBIAJBBGsiAg0ACwsgA0H4AGoiASADQbABaiICEIUUIANBJGogARDhJyACEM8vCyADLQAXIhJFBEAgA0HIAGogAygCHCIBIAEgAygCIEECdGoQvxsMBgtBACECIANB+ABqIAMoAiAiBEEAQQRBCBCgGCADKAJ8IQYgAygCeEEBRg0BIANBADYCRCADIAMoAoABIgE2AkAgAyAGNgI8IARFDQQgAygCHCEBIARBAnQhBANAIAEoAgAiAigCHCIGQQhJBEBBAEEAQajSggEQwyEACyACKAIYIgggBkF4cWpBCGsiBkUNAyADQQhqIAJBDGogCCgCACICIAYoAgAgAmsQyyUgAygCDCEGIAMoAgghCCADKAJEIgIgAygCPEYEQCADQTxqQcjSggEQmygLIAFBBGohASADKAJAIAJBA3RqIgcgBjYCBCAHIAg2AgAgAyACQQFqIgI2AkQgBEEEayIEDQALDAMLQcAAIAEQoz0ACyAGIAMoAoABQcDRggEQ/S8MBAtBuNKCARCyOwALIAMoAkAhAQsgA0HIAGogASABIAJBA3RqEL4bCyADQfgAaiADKAJMIAMoAlAQnQEgAygCgAEhCyADKAJ8IQ8gAygCeCIRQZOAgIB4RwRAIAAgAykChAE3AgwgACALNgIIIAAgDzYCBCAAIBE2AgAMAwsgA0EANgKMASADQQA2AoABIAMgAygCHCIBNgJ4IAMgASADKAIgQQJ0ajYCfCADQdQAaiETIwBBIGsiCSQAIANB+ABqIhYiASgCBCEUIAEoAgAhByAJQRBqIAEoAhgiBSABKAIcIhBrQQFqQQAgBSAQTxtBACABKAIUIggbIgJBfyACIAEoAgwiDCABKAIQIg1rQQFqIgRqIgYgBCAGSxsgDCANSRsgAiABKAIIIgEbQQFqQQBBCEEIEKAYIAkoAhQhAgJAIAkoAhBBAUcEQCAJQQA2AgwgCSAJKAIYIgQ2AgggCSACNgIEIAIEfyAEBSAJQQRqQaCFhAEQsyggCSgCCAtCADcDAEEAIQRBASEOA0AgCSAONgIMAn8CQAJAAkACQCABQQAgDCANTxtFBEAgB0UNAiAHIBRHDQEMAgsgDUEBSw0DDEILA0AgByICKAIAIgYoAhgiAQRAIAYoAhwiBkEDdiEMIAJBBGohByAGQRBPDQNBAiENIAcgFEcNAQsLIAJBBGohBwsCQCAIRSAFIBBJckUEQCAQQQFNDQEgBUEBayEFIAgiAUEIaiEIQQAMBAsgCUEYaiAJQQxqKAIANgIAIAkgCSkCBDcDECATIAlBEGoQvRggCUEgaiQADAYLDEALQQIhDQsgDEEBayEMIAFBCGoLIQYgBCABKAIIIAEoAgBrIARqIgJNBEAgCSgCBCAORgRAIAlBBGpB8IWEARCzKAsgCSgCCCAOQQN0aiACrTcDACAOQQFqIQ4gBiEBIAIhBAwBCwtB0IWEAUEOQeCFhAEQyyQACww/CyAVKAIAIgEgASgCACICQQFqNgIAIAJBAEgNACADQcABaiADQTRqKQIANwMAIANBuAFqIANBLGopAgA3AwAgAyADKQIkNwOwASAWIAEgEyAPIAsgA0GwAWoQ5QcgAy0AeCICQSlGBEAgA0HzAGogA0GMAWooAgAiATYAACADQesAaiADQYQBaikCACImNwAAIAMgAykCfCInNwBjIABBEGogATYAACAAQQhqICY3AAAgACAnNwAADAMLIANB7wBqIgEgA0GIAWopAAA3AAAgA0HoAGoiBCADQYEBaikAADcDACADQdABaiIGIANBmAFqKQIANwMAIANB2AFqIgggA0GgAWopAgA3AwAgA0HgAWoiByADQagBaikCADcDACADQfABaiIFIAQpAwA3AwAgA0H3AWoiBCABKQAANwAAIAMgAykCkAE3A8gBIAMgAykAeTcD6AFBwABBBBCtNiIBRQ0BIAEgAjoACCABQoGAgIAQNwIAIAEgAykD6AE3AAkgASADKQPIATcCICAAQdDRggE2AgggACABNgIEIAFBEWogBSkDADcAACABQRhqIAQpAAA3AAAgAUEoaiAGKQMANwIAIAFBMGogCCkDADcCACABQThqIAcpAwA3AgAgAEGTgICAeDYCACADQcgAakEEQQgQ4B4gEkUNAyADQTxqIgAQwycgABDqOwwDCwALQQRBwAAQoz0ACyADQcgAakEEQQgQ4B4gEgRAIANBPGoiABDDJyAAEOo7CyARQZOAgIB4Rg0AIAMoAiQiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EkahD7HgsgA0EYakEEQQQQ4B4gA0GAAmokAAwdCyAIQQRqIRUjAEGAAmsiAyQAIANBADYCECADQQA6ABYgA0EAOgAXIAMgATYCeCADIAEgAkEDdGo2AnwgAyADQRdqNgKIASADIANBFmo2AoQBIAMgA0EQajYCgAEgA0EYaiEGIwBBMGsiASQAAkAgA0H4AGoiAhD5FSIHBEAgAUEYaiIIQQMgAigCBCACKAIAa0EDdiIEIARBA00bQQFqQQBBBEEEEKAYIAEoAhwhBCABKAIYQQFGDTYgASgCICIFIAc2AgAgAUEUaiIJQQE2AgAgASAFNgIQIAEgBDYCDCABQShqIAJBEGooAgA2AgAgAUEgaiACQQhqKQIANwMAIAEgAikCADcDGCAIEPkVIgIEQCABQQxqIQQDQCAEKAIIIgcgBCgCAEYEQCAEIAcgCCgCBCAIKAIAa0EDdkEBakEEQQQQ3igLIAQoAgQgB0ECdGogAjYCACAEIAdBAWo2AgggCBD5FSICDQALCyAGQQhqIAkoAgA2AgAgBiABKQIMNwIADAELIAZBADYCCCAGQoCAgIDAADcCAAsgAUEwaiQAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAWRQRAIANBADYCJAwBC0HAACECIAMoAhAiAUEDdiABQQdxQQBHaiIBQcD///8DcUFAayABIAFBP3EbIgFBwAAQ0TRFDTAgAQRAIAFBwAAQrTYiAkUNAgsgA0IANwK8ASADIAI2ArgBIAMgATYCtAEgA0HAADYCsAEgAygCICICBEAgAygCHCEBIAJBAnQhAgNAAkAgASgCABCZNiIEBEAgA0GwAWogBBCVLwwBCyADQbABaiABKAIAEMA6EOYQCyABQQRqIQEgAkEEayICDQALCyADQfgAaiIBIANBsAFqIgIQhRQgA0EkaiABEOEnIAIQzy8LIAMtABciEkUEQCADQcgAaiADKAIcIgEgASADKAIgQQJ0ahC/GwwGC0EAIQIgA0H4AGogAygCICIEQQBBBEEIEKAYIAMoAnwhBiADKAJ4QQFGDQEgA0EANgJEIAMgAygCgAEiATYCQCADIAY2AjwgBEUNBCADKAIcIQEgBEECdCEEA0AgASgCACICKAIcIgZBBEkEQEEAQQBBqNKCARDDIQALIAIoAhgiCCAGQXxxakEEayIGRQ0DIANBCGogAkEMaiAIKAIAIgIgBigCACACaxDLJSADKAIMIQYgAygCCCEIIAMoAkQiAiADKAI8RgRAIANBPGpByNKCARCbKAsgAUEEaiEBIAMoAkAgAkEDdGoiByAGNgIEIAcgCDYCACADIAJBAWoiAjYCRCAEQQRrIgQNAAsMAwtBwAAgARCjPQALIAYgAygCgAFBwNGCARD9LwwEC0G40oIBELI7AAsgAygCQCEBCyADQcgAaiABIAEgAkEDdGoQvhsLIANB+ABqIAMoAkwgAygCUBCdASADKAKAASELIAMoAnwhDyADKAJ4IhFBk4CAgHhHBEAgACADKQKEATcCDCAAIAs2AgggACAPNgIEIAAgETYCAAwDCyADQQA2AowBIANBADYCgAEgAyADKAIcIgE2AnggAyABIAMoAiBBAnRqNgJ8IANB1ABqIRMjAEEgayIJJAAgA0H4AGoiFiIBKAIEIRQgASgCACEHIAlBEGogASgCGCIFIAEoAhwiEGtBAWpBACAFIBBPG0EAIAEoAhQiCBsiAkF/IAIgASgCDCINIAEoAhAiDmtBAWoiBGoiBiAEIAZLGyANIA5JGyACIAEoAggiARtBAWpBAEEEQQQQoBggCSgCFCECAkAgCSgCEEEBRwRAIAlBADYCDCAJIAkoAhgiBjYCCCAJIAI2AgRBACEEIAIEfyAGBSAJQQRqQaCFhAEQnSggCSgCCAtBADYCAEEBIQwDQCAJIAw2AgwCfwJAAkACQAJAIAFBACANIA5PG0UEQCAHRQ0CIAcgFEcNAQwCCyAOQQFLDQMMQQsDQCAHIgIoAgAiBigCGCIBBEAgBigCHCIGQQJ2IQ0gAkEEaiEHIAZBCE8NA0ECIQ4gByAURw0BCwsgAkEEaiEHCyAIRSAFIBBJckUEQCAQQQFNDUAgBUEBayEFIAgiAUEEaiEIQQAMAwsgBEEATgRAIAlBGGogCUEMaigCADYCACAJIAkpAgQ3AxAgEyAJQRBqEOgYIAlBIGokAAwGC0GwhYQBQQ9BwIWEARDLJAALQQIhDgsgDUEBayENIAFBBGoLIQYgBCABKAIEIAEoAgBrIARqIgJNBEAgCSgCBCAMRgRAIAlBBGpB8IWEARCdKAsgCSgCCCAMQQJ0aiACNgIAIAxBAWohDCAGIQEgAiEEDAELC0HQhYQBQQ5B4IWEARDLJAALDD4LIBUoAgAiASABKAIAIgJBAWo2AgAgAkEASA0AIANBwAFqIANBNGopAgA3AwAgA0G4AWogA0EsaikCADcDACADIAMpAiQ3A7ABIBYgASATIA8gCyADQbABahDkByADLQB4IgJBKUYEQCADQfMAaiADQYwBaigCACIBNgAAIANB6wBqIANBhAFqKQIAIiY3AAAgAyADKQJ8Iic3AGMgAEEQaiABNgAAIABBCGogJjcAACAAICc3AAAMAwsgA0HvAGoiASADQYgBaikAADcAACADQegAaiIEIANBgQFqKQAANwMAIANB0AFqIgYgA0GYAWopAgA3AwAgA0HYAWoiCCADQaABaikCADcDACADQeABaiIHIANBqAFqKQIANwMAIANB8AFqIgUgBCkDADcDACADQfcBaiIEIAEpAAA3AAAgAyADKQKQATcDyAEgAyADKQB5NwPoAUHAAEEEEK02IgFFDQEgASACOgAIIAFCgYCAgBA3AgAgASADKQPoATcACSABIAMpA8gBNwIgIABB2NKCATYCCCAAIAE2AgQgAUERaiAFKQMANwAAIAFBGGogBCkAADcAACABQShqIAYpAwA3AgAgAUEwaiAIKQMANwIAIAFBOGogBykDADcCACAAQZOAgIB4NgIAIANByABqQQRBCBDgHiASRQ0DIANBPGoiABDDJyAAEOo7DAMLAAtBBEHAABCjPQALIANByABqQQRBCBDgHiASBEAgA0E8aiIAEMMnIAAQ6jsLIBFBk4CAgHhGDQAgAygCJCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQSRqEPseCyADQRhqQQRBBBDgHiADQYACaiQADBwLQQAhBCMAQcABayIHJAAgASEGIAIhCANAIAYoAgAgBkEEaigCACgCJBEEACAEaiEEIAZBCGohBiAIQQFrIggNAAsgB0EIaiAEEMQbIAEgAkEDdGohBgNAIAEoAgAhBCABQQRqKAIAIQgjAEEgayICJAAgAkEIaiAEIAgoAhARAAAgAkEQaiACKAIIIgQgAigCDCgCDBEAAAJAIAQEQCACKQMQQquYkfGV+tX8gH+FIAIpAxhClpT4q/Cx6bPhAIWEUA0BC0Ho8IMBQQ9B+PCDARDLJAALIAJBIGokACAHQQhqIgIgBBDICyABQQhqIgEgBkcNAAsgB0GEAWoiBCACENsMAkBBxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBPPwKAAAgAEH4yoIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBQGsQ5jwgBygCZARAIAdB5ABqEM8vCyAHQcwAaiIAEMUnIAAQ6DsgB0HYAGoQ3jsgBygCEARAIAdBEGoQjjsLIAdBwAFqJAAMAQsMJgsMGwsjAEGQAWsiAyQAIANByABqIgQgASACEK0YIAMoAkhBgYCAgHhHDSUgAygCTEUNJSADKAJQIQYgAygCVCEIIAQQrSEgA0EUaiAIIAYQpRQgASACQQN0aiEOIANBLGohCSADQSBqIQ0DQAJAIAEoAgAgASgCBBCTIiICENQ6RQ0AIAIoAhQiBUEISQ0oIAVBA3YhCAJAIAM1AhwiJiACKAIQIgQpAwAiJ1EEQCANIAhBAWsiBhDsLSAGQQN0IgcEQCADKAIkIAMoAihBA3RqIARBCGogB/wKAAALIAMgAygCKCAGajYCKAwBCyADQcgAaiAIQQFrQQBBCEEIEKAYIAMoAkwhByADKAJIQQFGDSpBACEGIANBADYCjAEgAyADKAJQIgw2AogBIAMgBzYChAEgBUF4cSIHQQhHBEAgJiAnfSEmIAdBCGshByAEQQhqIQxBACEFA0AgJiAFIAxqKQMAfCEnIAMoAoQBIAZGBEAgA0GEAWpB4L+CARCzKAsgAygCiAEgBWogJzcDACADIAZBAWoiBjYCjAEgByAFQQhqIgVHDQALIAMoAogBIQwLIA0gBhDsLSAGQQN0IgcEQCADKAIkIAMoAihBA3RqIAwgB/wKAAALIAMgAygCKCAGajYCKCADQYQBahDjPAsgA0EIaiACQRhqENw7IAQoAgAhBiADKAIMIQUgAygCCCEMIAIQ1DoiByAITw0sIAQgB0EDdGooAgAiCCAGSQ0qIAUgCEkNKyADQRRqIAYgDGogCCAGaxChNiACEJM2IgQEQCAJIAQQ4SYMAQsgAhDUOiECIAMoAiwEQCAJIAIQ5hAMAQsgAyADKAJAIAJqNgJACyABQQhqIgEgDkcNAAsgA0HIAGoiAiADQRRqIgQQ7g5BxABBBBCtNiIBRQ0kIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABByOyCATYCCCAAIAE2AgQgAEGTgICAeDYCACAEEN47IA0Q4zwgAygCLARAIAkQzy8LIANBkAFqJAAMGgsjAEGQAWsiAyQAIANByABqIgQgASACELAYIAMoAkhBgYCAgHhHDSQgAygCTEUNJCADKAJQIQYgAygCVCEIIAQQrSEgA0EUaiAIIAYQphQgASACQQN0aiEOIANBLGohCSADQSBqIQ0DQAJAIAEoAgAgASgCBBCSIiICENM6RQ0AIAIoAhQiBUEESQ0nIAVBAnYhCAJAIAMoAhwiECACKAIQIgQoAgAiEkYEQCANIAhBAWsiBhDuLSAGQQJ0IgcEQCADKAIkIAMoAihBAnRqIARBBGogB/wKAAALIAMgAygCKCAGajYCKAwBCyADQcgAaiAIQQFrQQBBBEEEEKAYIAMoAkwhByADKAJIQQFGDSlBACEGIANBADYCjAEgAyADKAJQIgw2AogBIAMgBzYChAEgBUF8cSIHQQRHBEAgECASayEMIAdBBGshByAEQQRqIRBBACEFA0AgDCAFIBBqKAIAaiESIAMoAoQBIAZGBEAgA0GEAWpB4L+CARCdKAsgAygCiAEgBWogEjYCACADIAZBAWoiBjYCjAEgByAFQQRqIgVHDQALIAMoAogBIQwLIA0gBhDuLSAGQQJ0IgcEQCADKAIkIAMoAihBAnRqIAwgB/wKAAALIAMgAygCKCAGajYCKCADQYQBahDpOwsgA0EIaiACQRhqENw7IAQoAgAhBiADKAIMIQUgAygCCCEMIAIQ0zoiByAITw0rIAQgB0ECdGooAgAiCCAGSQ0pIAUgCEkNKiADQRRqIAYgDGogCCAGaxChNiACEJM2IgQEQCAJIAQQ4SYMAQsgAhDTOiECIAMoAiwEQCAJIAIQ5hAMAQsgAyADKAJAIAJqNgJACyABQQhqIgEgDkcNAAsgA0HIAGoiAiADQRRqIgQQ7Q5BxABBBBCtNiIBRQ0jIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABBmOuCATYCCCAAIAE2AgQgAEGTgICAeDYCACAEEN47IA0Q6TsgAygCLARAIAkQzy8LIANBkAFqJAAMGQtBACEEIwBBwAFrIgckACABIQYgAiEIA0AgBigCACAGQQRqKAIAKAIkEQQAIARqIQQgBkEIaiEGIAhBAWsiCA0ACyAHQQhqIAQQxBsgASACQQN0aiEGA0AgASgCACEEIAFBBGooAgAhCCMAQSBrIgIkACACQQhqIAQgCCgCEBEAACACQRBqIAIoAggiBCACKAIMKAIMEQAAAkAgBARAIAIpAxBCr/OQ2JScx/szhSACKQMYQqClxfTN0NGkjX+FhFANAQtB6PCDAUEPQfjwgwEQyyQACyACQSBqJAAgB0EIaiICIAQQyAsgAUEIaiIBIAZHDQALIAdBhAFqIgQgAhDcDAJAQcQAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTz8CgAAIABBoMqCATYCCCAAIAE2AgQgAEGTgICAeDYCACAHQUBrEOY8IAcoAmQEQCAHQeQAahDPLwsgB0HMAGoiABDFJyAAEOg7IAdB2ABqEN47IAcoAhAEQCAHQRBqEI47CyAHQcABaiQADAELDCMLDBgLIwBBkAFrIgMkACADQcgAaiIEIAEgAhCuGCADKAJIQYGAgIB4Rw0iIAMoAkxFDSIgAygCUCEGIAMoAlQhCCAEEK0hIANBFGogCCAGEKUUIAEgAkEDdGohDiADQSxqIQkgA0EgaiENA0ACQCABKAIAIAEoAgQQlSIiAhDUOkUNACACKAIUIgVBCEkNJSAFQQN2IQgCQCADNQIcIiYgAigCECIEKQMAIidRBEAgDSAIQQFrIgYQ7C0gBkEDdCIHBEAgAygCJCADKAIoQQN0aiAEQQhqIAf8CgAACyADIAMoAiggBmo2AigMAQsgA0HIAGogCEEBa0EAQQhBCBCgGCADKAJMIQcgAygCSEEBRg0nQQAhBiADQQA2AowBIAMgAygCUCIMNgKIASADIAc2AoQBIAVBeHEiB0EIRwRAICYgJ30hJiAHQQhrIQcgBEEIaiEMQQAhBQNAICYgBSAMaikDAHwhJyADKAKEASAGRgRAIANBhAFqQeC/ggEQsygLIAMoAogBIAVqICc3AwAgAyAGQQFqIgY2AowBIAcgBUEIaiIFRw0ACyADKAKIASEMCyANIAYQ7C0gBkEDdCIHBEAgAygCJCADKAIoQQN0aiAMIAf8CgAACyADIAMoAiggBmo2AiggA0GEAWoQ4zwLIANBCGogAkEYahDcOyAEKAIAIQYgAygCDCEFIAMoAgghDCACENQ6IgcgCE8NKSAEIAdBA3RqKAIAIgggBkkNJyAFIAhJDSggA0EUaiAGIAxqIAggBmsQoTYgAhCTNiIEBEAgCSAEEOEmDAELIAIQ1DohAiADKAIsBEAgCSACEOYQDAELIAMgAygCQCACajYCQAsgAUEIaiIBIA5HDQALIANByABqIgIgA0EUaiIEEOwOQcQAQQQQrTYiAUUNISABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQfDrggE2AgggACABNgIEIABBk4CAgHg2AgAgBBDeOyANEOM8IAMoAiwEQCAJEM8vCyADQZABaiQADBcLIwBBkAFrIgMkACADQcgAaiIEIAEgAhCvGCADKAJIQYGAgIB4Rw0hIAMoAkxFDSEgAygCUCEGIAMoAlQhCCAEEK0hIANBFGogCCAGEKYUIAEgAkEDdGohDiADQSxqIQkgA0EgaiENA0ACQCABKAIAIAEoAgQQlCIiAhDTOkUNACACKAIUIgVBBEkNJCAFQQJ2IQgCQCADKAIcIhAgAigCECIEKAIAIhJGBEAgDSAIQQFrIgYQ7i0gBkECdCIHBEAgAygCJCADKAIoQQJ0aiAEQQRqIAf8CgAACyADIAMoAiggBmo2AigMAQsgA0HIAGogCEEBa0EAQQRBBBCgGCADKAJMIQcgAygCSEEBRg0mQQAhBiADQQA2AowBIAMgAygCUCIMNgKIASADIAc2AoQBIAVBfHEiB0EERwRAIBAgEmshDCAHQQRrIQcgBEEEaiEQQQAhBQNAIAwgBSAQaigCAGohEiADKAKEASAGRgRAIANBhAFqQeC/ggEQnSgLIAMoAogBIAVqIBI2AgAgAyAGQQFqIgY2AowBIAcgBUEEaiIFRw0ACyADKAKIASEMCyANIAYQ7i0gBkECdCIHBEAgAygCJCADKAIoQQJ0aiAMIAf8CgAACyADIAMoAiggBmo2AiggA0GEAWoQ6TsLIANBCGogAkEYahDcOyAEKAIAIQYgAygCDCEFIAMoAgghDCACENM6IgcgCE8NKCAEIAdBAnRqKAIAIgggBkkNJiAFIAhJDScgA0EUaiAGIAxqIAggBmsQoTYgAhCTNiIEBEAgCSAEEOEmDAELIAIQ0zohAiADKAIsBEAgCSACEOYQDAELIAMgAygCQCACajYCQAsgAUEIaiIBIA5HDQALIANByABqIgIgA0EUaiIEEOsOQcQAQQQQrTYiAUUNICABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQYjqggE2AgggACABNgIEIABBk4CAgHg2AgAgBBDeOyANEOk7IAMoAiwEQCAJEM8vCyADQZABaiQADBYLAkACQCAILQABQQJrDgIAAQULQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBCEEIEKAYIAUoAgghByAFKAIEQQFGDScgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQdDnhQEpAgA3AiggBEEwakHY54UBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEPYjRQRAIAdBKGpBqPyDASgCADYCACAHQaD8gwEpAgA3AyAMKQsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDlISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0YIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQwhMgAUGAA2okAEE4QQQQrTYiAUUNGCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQbDeggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwXCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJiAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARB6OeFASkCADcCKCAEQTBqQfDnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ8SNFBEAgB0EoakHo+oMBKAIANgIAIAdB4PqDASkCADcDIAwoCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO0hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDRcgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxCpEyABQYADaiQAQThBBBCtNiIBRQ0XIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhB8OOCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADBYLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwVCwJAAkAgCC0AAQ4CAAEEC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQRBBBCgGCAFKAIIIQcgBSgCBEEBRg0mIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEGI54UBKQIANwIoIARBMGpBkOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDzI0UEQCAHQShqQcj7gwEoAgA2AgAgB0HA+4MBKQIANwMgDCgLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/iEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNFyACKAIQIQcgA0EIaiACKAIUIglBAnYiDBDuLSAJQXxxIgkEQCADKAIMIAMoAhBBAnRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENs8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgMAANwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8RggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHELsTIAFBgANqJABBOEEEEK02IgFFDRcgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEGo3IIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMFgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADBULQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBBEEEEKAYIAUoAgghByAFKAIEQQFGDSUgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQYzohQEpAgA3AiggBEEwakGU6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEO4jRQRAIAdBKGpB3PqDASgCADYCACAHQdT6gwEpAgA3AyAMJwsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDxISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0WIAIoAhAhByADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAwAA3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDxGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQshMgAUGAA2okAEE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQZDWggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwVCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFAsCQAJAAkACQCAILQABQQFrDgMBAgMAC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBCBCgGCAFKAIIIQcgBSgCBEEBRg0nIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEGg54UBKQIANwIoIARBMGpBqOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiByQAIAdBEGpBuMmEASgCADYCACAHQbDJhAEpAgA3AwggBi0AACEIIAYtAAEgB0EIaiICEL8MRSAIQQ1GcUUEQCAHQShqQajnhQEoAgA2AgAgB0Gg54UBKQIANwMgDDELIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD2ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0YIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQvxMgAUGAA2okAEE4QQQQrTYiAUUNGCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQcDiggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwXCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJiAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBsOiFASkCADcCKCAEQTBqQbjohQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQaTKhAEoAgA2AgAgB0GcyoQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQFGcUUEQCAHQShqQbjohQEoAgA2AgAgB0Gw6IUBKQIANwMgDDALIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDpISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0XIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQxhMgAUGAA2okAEE4QQQQrTYiAUUNFyABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQYDoggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwWCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJSAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBuOeFASkCADcCKCAEQTBqQcDnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQYDKhAEoAgA2AgAgB0H4yYQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQJGcUUEQCAHQShqQcDnhQEoAgA2AgAgB0G454UBKQIANwMgDC8LIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDmISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0WIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQqBMgAUGAA2okAEE4QQQQrTYiAUUNFiABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQbjgggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwVCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMFAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNJCAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBvOiFASkCADcCKCAEQTBqQcTohQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIAEgAkEDdGohBSMAQUBqIgckACAHQRBqQdzJhAEoAgA2AgAgB0HUyYQBKQIANwMIIAYtAAAgBi0AASEJIAdBCGoiAhC/DEENRiAJQQNGcUUEQCAHQShqQcTohQEoAgA2AgAgB0G86IUBKQIANwMgDC4LIApBEGohCCADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD5ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0VIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQtBMgAUGAA2okAEE4QQQQrTYiAUUNFSABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQfjaggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwUCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMEwtBACEEIwBB4ABrIgckACABIQYgAiEIA0AgBigCACAGQQRqKAIAKAIkEQQAIARqIQQgBkEIaiEGIAhBAWsiCA0ACyAHQQRqIAQQ9BggASACQQN0aiEGIAdBGGohAgNAIAdBBGogASgCACABQQRqKAIAEMUvIgQQlS8CQCAEEJs2IggEQCACIAgQ4SYMAQsgBCgCECEEIAcoAhgEQCACIAQQ5hAMAQsgByAHKAIsIARqNgIsCyABQQhqIgEgBkcNAAsgB0E0aiIEIAdBBGoiBhDKDQJAQTRBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBLPwKAAAgAEGw6YIBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAYQzy8gBygCGARAIAIQzy8LIAdB4ABqJAAMAQtBBEE0EKM9AAsMEgsgCkHwAGoiBCABIAIgCBC+DiAAIAEgAiAEEPoUDBELQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoh4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpBxMmEASgCADYCACAIQbzJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJkcEQCAIQShqQdDohQEoAgA2AgAgCEHI6IUBKQIANwMgDCwLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDjISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0SIAIoAhAhCCADQQhqIAIoAhQiCUEFdiIMEO8tIAlBYHEiCQRAIAMoAgwgAygCEEEFdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ3DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ2hRBOEEEEK02IgFFDRIgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Ho4YIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ5TwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMEQsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADBALQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoB4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpByMqEASgCADYCACAIQcDKhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJUcEQCAIQShqQfznhQEoAgA2AgAgCEH054UBKQIANwMgDCsLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD8ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0RIAIoAhAhCCADQQhqIAIoAhQiCUEEdiIMEOstIAlBcHEiCQRAIAMoAgwgAygCEEEEdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2jwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ0xRBOEEEEK02IgFFDREgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Gw04IBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ5jwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMEAsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA8LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQoR4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpB6MmEASgCADYCACAIQeDJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBJEcEQCAIQShqQYjohQEoAgA2AgAgCEGA6IUBKQIANwMgDCoLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDoISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0QIAIoAhAhCCADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ0hRBOEEEEK02IgFFDRAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0Hw2IIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ4zwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMDwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA4LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQnx4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYgASACQQN0aiEFIwBBQGoiCCQAIAhBEGpBoMmEASgCADYCACAIQZjJhAEpAgA3AwggBi0AACAIQQhqIgIQvwxBI0cEQCAIQShqQcznhQEoAgA2AgAgCEHE54UBKQIANwMgDCkLIApBEGohByADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahDEDCAIQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABDkISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0PIAIoAhAhCCADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogCCAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIIBEAgBCAIEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIggQ1xRBOEEEEK02IgFFDQ8gAUKBgICAEDcCACABQQhqIAJBMPwKAAAgB0H45YIBNgIIIAcgATYCBCAHQZOAgIB4NgIAIAgQ6TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMDgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADA0LQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQ9h4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhC+JUUEQCAHQShqQYyYsOAANgIAIAdCjJiw4MCBg4YMNwMgDB8LIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQgiIhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNDiACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENgUQThBBBCtNiIBRQ0OIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhBqOeCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADA0LIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwMC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIANBPGoiBCAIEPEeIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQwSVFBEAgB0EoakGLlqzYADYCACAHQouWrNiw4cKFCzcDIAweCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO8hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQ0gAigCECEHIANBCGogAigCFCIJQQJ2IgwQ7i0gCUF8cSIJBEAgAygCDCADKAIQQQJ0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDNFEE4QQQQrTYiAUUNDSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQZjYggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwMCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMCwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD0HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMYlRQRAIAdBKGpBipSo0AA2AgAgB0KKlKjQoMGChQo3AyAMHQsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABD0ISECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0MIAIoAhAhByADQQhqIAIoAhQiCUEBdiIMEO0tIAlBfnEiCQRAIAMoAgwgAygCEEEBdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2TwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIANBPGoiAiADQQhqIgcQ1RRBOEEEEK02IgFFDQwgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgCEGg2oIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAcQnTwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMCwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAoLQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsgA0E8aiIEIAgQ7x4gA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhC/JUUEQCAHQShqQYmSpMgANgIAIAdCiZKkyJChwoQJNwMgDBwLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ7CEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNCyACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENkUQThBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhB4NSCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAoLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwJC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIANBPGoiBCAIEPIeIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQvSVFBEAgB0EoakGIkKDAADYCACAHQoiQoMCAgYKECDcDIAwbCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPUhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQogA0EIaiACKAIQIAIoAhRBAnYQjTUCQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDUFEE4QQQQrTYiAUUNCiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQdjdggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwJCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMCAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBDzHiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMQlRQRAIAdBKGpBh46cODYCACAHQoeOnLjw4MGDBzcDIAwaCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPAhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQkgAigCECEHIANBCGogAigCFCIJQQF2IgwQ7S0gCUF+cSIJBEAgAygCDCADKAIQQQF0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDZPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDPFEE4QQQQrTYiAUUNCSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQYjUggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxCdPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwICyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD3HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMklRQRAIAdBKGpBhoyYMDYCACAHQoaMmLDgwIGDBjcDIAwZCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPchIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQggA0EIaiACKAIQIAIoAhQQoTYCQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMaigCCCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDRFEE4QQQQrTYiAUUNCCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQcDXggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDeOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwHCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBgtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD4HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMMlRQRAIAdBKGpBhYqUKDYCACAHQoWKlKjQoMGCBTcDIAwYCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPMhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQcgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDbFEE4QQQQrTYiAUUNByABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQbjVggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwGCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD5HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMAlRQRAIAdBKGpBhIiQIDYCACAHQoSIkKDAgIGCBDcDIAwXCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPshIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQYgAigCECEHIANBCGogAigCFCIJQQJ2IgwQ7i0gCUF8cSIJBEAgAygCDCADKAIQQQJ0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDbPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDQFEE4QQQQrTYiAUUNBiABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQeDfggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwFCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMBAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBD1HiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMclRQRAIAdBKGpBg4aMGDYCACAHQoOGjJiw4MCBAzcDIAwWCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPghIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQUgAigCECEHIANBCGogAigCFCIJQQF2IgwQ7S0gCUF+cSIJBEAgAygCDCADKAIQQQF0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDZPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsgA0E8aiICIANBCGoiBxDOFEE4QQQQrTYiAUUNBSABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAIQdjoggE2AgggCCABNgIEIAhBk4CAgHg2AgAgBxCdPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwECyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyADQTxqIgQgCBDwHiADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEMglRQRAIAdBKGpBgoSIEDYCACAHQoKEiJCgwICBAjcDIAwVCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEPIhIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQQgAigCECEJIANBCGogAigCFCIHEIEuIAcEQCADKAIMIAMoAhBqIAkgB/wKAAALIAMgAygCECAHajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqKAIIIQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyADQTxqIgIgA0EIaiIHENYUQThBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIAhB0OaCATYCCCAIIAE2AgQgCEGTgICAeDYCACAHEN47IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwCCwJAAkACQCAILQABQQFrDgIBAgALQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBBEEEEKAYIAUoAgghByAFKAIEQQFGDRQgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQaTohQEpAgA3AiggBEEwakGs6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEO8jRQRAIAdBKGpBgPuDASgCADYCACAHQfj6gwEpAgA3AyAMFgsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABCAIiECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0FIAIoAhAhByADQQhqIAIoAhQiCUECdiIMEO4tIAlBfHEiCQRAIAMoAgwgAygCEEECdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2zwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAwAA3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDxGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQrxMgAUGAA2okAEE4QQQQrTYiAUUNBSABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQdDbggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDpOyADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwECyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAwtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEEQQgQoBggBSgCCCEHIAUoAgRBAUYNEyAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBrOeFASkCADcCKCAEQTBqQbTnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ8iNFBEAgB0EoakH0+oMBKAIANgIAIAdB7PqDASkCADcDIAwVCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEOshIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQQgAigCECEHIANBCGogAigCFCIJQQN2IgwQ6i0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgIDAADcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHELQYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxCsEyABQYADaiQAQThBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBoOWCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOo7IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAMLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwCC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBEBCgGCAFKAIIIQcgBSgCBEEBRg0SIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEHU6IUBKQIANwIoIARBMGpB3OiFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDsI0UEQCAHQShqQbz7gwEoAgA2AgAgB0G0+4MBKQIANwMgDBQLIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ/SEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNAyACKAIQIQcgA0EIaiACKAIUIglBBHYiDBDpLSAJQXBxIgkEQCADKAIMIAMoAhBBBHRqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENo8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgIABNwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQtxggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHEL4TIAFBgANqJABBOEEEEK02IgFFDQMgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEGA3YIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ7TsgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMAgsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAELAkACQAJAAkAgCC0AAUEBaw4DAQIDAAtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNFCAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARB3OeFASkCADcCKCAEQTBqQeTnhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ7SNFBEAgB0EoakGE/IMBKAIANgIAIAdB/PuDASkCADcDIAwWCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEOohIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQUgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxC8EyABQYADaiQAQThBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhBmOOCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAQLIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAwDC0EAIQgjAEGAAWsiAyQAIAEhBiACIQQDQCAGKAIAIAZBBGooAgAoAiQRBAAgCGohCCAGQQhqIQYgBEEBayIEDQALIwBBEGsiBSQAIAVBBGogCEEAQQhBCBCgGCAFKAIIIQcgBSgCBEEBRg0TIAUoAgwhBiADQTxqIgQgCDYCJCAEQQA2AiAgBEIANwIIIAQgBjYCBCAEIAc2AgAgBEH85oUBKQIANwIoIARBMGpBhOeFASgCADYCACAFQRBqJAAgA0HwAGoiBiABKAIAIAEoAgQoAhwRBAAQywYjAEFAaiIHJAAgBhDwI0UEQCAHQShqQZD8gwEoAgA2AgAgB0GI/IMBKQIANwMgDBULIApBEGohCCABIAJBA3RqIQUgA0EIaiICIAQpAgA3AgAgAiAEKQIMNwIMIAIgBikCADcCKCACQQhqIARBCGooAgA2AgAgAkEUaiAEQRRqKQIANwIAIAJBHGogBEEcaikCADcCACACQSRqIARBJGooAgA2AgAgAkEwaiAGQQhqKAIANgIAIARBKGoQuwwgB0FAayQAIANBFGohBCADQTBqIQYDQCABKAIAIAFBBGooAgAQ5yEhAiADIAY2AnwgAyACNgJwIAYgAhC8CEUNBCACKAIQIQcgA0EIaiACKAIUIglBA3YiDBDsLSAJQXhxIgkEQCADKAIMIAMoAhBBA3RqIAcgCfwKAAALIAMgAygCECAMajYCEAJAIAIQkjYiBwRAIAQgBxDhJgwBCyACQQxqENg8IQIgAygCFARAIAQgAhDmEAwBCyADIAMoAiggAmo2AigLIAFBCGoiASAFRw0ACyMAQYADayIBJAAgA0EIaiICQQhqIgcoAgAhBSABQQRqIgkgAkEMahD0EiABQfQBaiACQShqENUGIAFBADsBrAIgAUEANgKoAiABQQA2ApACIAFBADYChAIgASAFNgKAAiABQgQ3AuwBIAFCADcC5AEgAUKAgICAwAA3AtwBIAFBADYC1AEgAUGAAWogBygCADYCACAHQQA2AgAgAikCACEmIAJCgICAgIABNwIAIAEgJjcDeCABQbACaiIFIAFB+ABqIgcQ8xggByABQdQBaiAFEPojIAFBHGoiBSAHIAkQwhkgAUG8AmoiByAFEM0cIANBPGoiBSAHELUTIAFBgANqJABBOEEEEK02IgFFDQQgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgCEHI2YIBNgIIIAggATYCBCAIQZOAgIB4NgIAIAIQ4zwgAygCFARAIAQQzy8LIAYQtgwgA0GAAWokACAKKAIYIQEgCigCFCECIAooAhAiBEGTgICAeEcEQCAAIAopAhw3AgwgACABNgIIIAAgAjYCBCAAIAQ2AgAMAwsgAiABEJosIQEgAEGg8IIBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILQQAhCCMAQYABayIDJAAgASEGIAIhBANAIAYoAgAgBkEEaigCACgCJBEEACAIaiEIIAZBCGohBiAEQQFrIgQNAAsjAEEQayIFJAAgBUEEaiAIQQBBCEEIEKAYIAUoAgghByAFKAIEQQFGDRIgBSgCDCEGIANBPGoiBCAINgIkIARBADYCICAEQgA3AgggBCAGNgIEIAQgBzYCACAEQZjohQEpAgA3AiggBEEwakGg6IUBKAIANgIAIAVBEGokACADQfAAaiIGIAEoAgAgASgCBCgCHBEEABDLBiMAQUBqIgckACAGEPUjRQRAIAdBKGpB1PuDASgCADYCACAHQcz7gwEpAgA3AyAMFAsgCkEQaiEIIAEgAkEDdGohBSADQQhqIgIgBCkCADcCACACIAQpAgw3AgwgAiAGKQIANwIoIAJBCGogBEEIaigCADYCACACQRRqIARBFGopAgA3AgAgAkEcaiAEQRxqKQIANwIAIAJBJGogBEEkaigCADYCACACQTBqIAZBCGooAgA2AgAgBEEoahC7DCAHQUBrJAAgA0EUaiEEIANBMGohBgNAIAEoAgAgAUEEaigCABCBIiECIAMgBjYCfCADIAI2AnAgBiACELwIRQ0DIAIoAhAhByADQQhqIAIoAhQiCUEDdiIMEOwtIAlBeHEiCQRAIAMoAgwgAygCEEEDdGogByAJ/AoAAAsgAyADKAIQIAxqNgIQAkAgAhCSNiIHBEAgBCAHEOEmDAELIAJBDGoQ2DwhAiADKAIUBEAgBCACEOYQDAELIAMgAygCKCACajYCKAsgAUEIaiIBIAVHDQALIwBBgANrIgEkACADQQhqIgJBCGoiBygCACEFIAFBBGoiCSACQQxqEPQSIAFB9AFqIAJBKGoQ1QYgAUEAOwGsAiABQQA2AqgCIAFBADYCkAIgAUEANgKEAiABIAU2AoACIAFCBDcC7AEgAUIANwLkASABQoCAgIDAADcC3AEgAUEANgLUASABQYABaiAHKAIANgIAIAdBADYCACACKQIAISYgAkKAgICAgAE3AgAgASAmNwN4IAFBsAJqIgUgAUH4AGoiBxDzGCAHIAFB1AFqIAUQ+iMgAUEcaiIFIAcgCRDCGSABQbwCaiIHIAUQzRwgA0E8aiIFIAcQuhMgAUGAA2okAEE4QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAIQZDhggE2AgggCCABNgIEIAhBk4CAgHg2AgAgAhDjPCADKAIUBEAgBBDPLwsgBhC2DCADQYABaiQAIAooAhghASAKKAIUIQIgCigCECIEQZOAgIB4RwRAIAAgCikCHDcCDCAAIAE2AgggACACNgIEIAAgBDYCAAwCCyACIAEQmiwhASAAQaDwggE2AgggACABNgIEIABBk4CAgHg2AgAMAQtBACEIIwBBgAFrIgMkACABIQYgAiEEA0AgBigCACAGQQRqKAIAKAIkEQQAIAhqIQggBkEIaiEGIARBAWsiBA0ACyMAQRBrIgUkACAFQQRqIAhBAEEIQQgQoBggBSgCCCEHIAUoAgRBAUYNESAFKAIMIQYgA0E8aiIEIAg2AiQgBEEANgIgIARCADcCCCAEIAY2AgQgBCAHNgIAIARBlOeFASkCADcCKCAEQTBqQZznhQEoAgA2AgAgBUEQaiQAIANB8ABqIgYgASgCACABKAIEKAIcEQQAEMsGIwBBQGoiByQAIAYQ9CNFBEAgB0EoakGk+4MBKAIANgIAIAdBnPuDASkCADcDIAwTCyAKQRBqIQggASACQQN0aiEFIANBCGoiAiAEKQIANwIAIAIgBCkCDDcCDCACIAYpAgA3AiggAkEIaiAEQQhqKAIANgIAIAJBFGogBEEUaikCADcCACACQRxqIARBHGopAgA3AgAgAkEkaiAEQSRqKAIANgIAIAJBMGogBkEIaigCADYCACAEQShqELsMIAdBQGskACADQRRqIQQgA0EwaiEGA0AgASgCACABQQRqKAIAEO4hIQIgAyAGNgJ8IAMgAjYCcCAGIAIQvAhFDQIgAigCECEHIANBCGogAigCFCIJQQN2IgwQ7C0gCUF4cSIJBEAgAygCDCADKAIQQQN0aiAHIAn8CgAACyADIAMoAhAgDGo2AhACQCACEJI2IgcEQCAEIAcQ4SYMAQsgAkEMahDYPCECIAMoAhQEQCAEIAIQ5hAMAQsgAyADKAIoIAJqNgIoCyABQQhqIgEgBUcNAAsjAEGAA2siASQAIANBCGoiAkEIaiIHKAIAIQUgAUEEaiIJIAJBDGoQ9BIgAUH0AWogAkEoahDVBiABQQA7AawCIAFBADYCqAIgAUEANgKQAiABQQA2AoQCIAEgBTYCgAIgAUIENwLsASABQgA3AuQBIAFCgICAgMAANwLcASABQQA2AtQBIAFBgAFqIAcoAgA2AgAgB0EANgIAIAIpAgAhJiACQoCAgICAATcCACABICY3A3ggAUGwAmoiBSABQfgAaiIHEPMYIAcgAUHUAWogBRD6IyABQRxqIgUgByAJEMIZIAFBvAJqIgcgBRDNHCADQTxqIgUgBxDBEyABQYADaiQAQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIAhB6NaCATYCCCAIIAE2AgQgCEGTgICAeDYCACACEOM8IAMoAhQEQCAEEM8vCyAGELYMIANBgAFqJAAgCigCGCEBIAooAhQhAiAKKAIQIgRBk4CAgHhHBEAgACAKKQIcNwIMIAAgATYCCCAAIAI2AgQgACAENgIADAELIAIgARCaLCEBIABBoPCCATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgCkGQAWokAA8LIANCADcCSCADQoGAgIDAADcCQCADQYi/ggE2AjwgA0H8AGogA0HwAGogA0E8akGQv4IBEKMrAAtBBEE4EKM9AAtBAEEAQYjuggEQwyEAC0EEQYgBEKM9AAtBBEEwEKM9AAtBwAAgAhCjPQALQQRB0AAQoz0ACyADIAUoAsABQdDLggEQ/S8AC0GwwIIBQSkgA0H4AGpB4MiCAUHcwIIBENUeAAtBBEHEABCjPQALQeDqggFBKEGI64IBEJ8pAAtBAEEAQbC/ggEQwyEACyAHIAMoAlBBwL+CARD9LwALIAYgCEGQwIIBELE7AAsgCCAFQZDAggEQsDsACyAHIAhBgMCCARDDIQALIAcgBSgCDEHs5oUBEP0vAAsgB0ECNgIMIAdB3PyDATYCCCAHQgI3AhQgB0GtAzYCPCAHIAY2AjggB0GtAzYCNCAHIAdBMGo2AhAgByAHQSBqNgIwIAdBCGpB7PyDARDvLAALIAYgBSgCDEHQyIIBEP0vAAtBjLiCARCyOwALIAQgCSgCGEHQyIIBEP0vAAtBsMCCAUEpIAVBuAFqQeDIggFB3MCCARDVHgALIAVBADYCuAFBACAFQewAaiAFQQhqIAVBuAFqQeDLggEQrysACyAEIAEoAiBB0MiCARD9LwALQQFBAUGAhoQBEMMhAAsgB0ECNgIMIAdBlOmFATYCCCAHQgI3AhQgB0GtAzYCPCAHIAY2AjggB0GtAzYCNCAHIAdBMGo2AhAgByAHQSBqNgIwIAJBpOmFARDvLAALIAhBAjYCDCAIQZTphQE2AgggCEICNwIUIAhBrQM2AjwgCCAGNgI4IAhBrQM2AjQgCCAIQTBqNgIQIAggCEEgajYCMCACQaTphQEQ7ywAC0EEQRwQoz0ACyACIAkoAhhBkIWEARD9LwAL21ACDH8DfiMAQeAVayIEJAACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCACLQAMIgVBG2sOBgMCBAUCBgELIAIoAgQiBygCCEECRg0HIAIoAgghCyAHIAcoAgAiBUEBajYCACAFQQBIDR4gBCAHNgI8IAMgCxDyJkUEQCAHIAcoAgAiAkEBazYCAEEAIQcgAkEBRw0eIARBPGoQgyAMHgsjAEEgayIDJAAgB0EIaiIFKAIAQQJGBEAgA0EANgIYIANBATYCDCADQfyszwA2AgggA0IENwIQIANBCGpBhK3PABDvLAALIAUtADAhCCADQSBqJAAgAi8BGCEDIAIvARohBkEcQQQQrTYiBUUNCCAFIAM7ARogBSAGOwEYIAUgBzYCFCAFQQA2AhAgBUKAgICAwAA3AgggBUKBgICAEDcCACAEIAU2AkAgBEGwEGogASgCACALIAEoAgQoAhARAQAgBCgCuBAhAyAEKAK0ECEHIAQoArAQIgZBCEcEQCAEQThqIARBxBBqKAIANgIAIAQgBCkCvBA3AzAgBSAFKAIAIgFBAWs2AgAgAUEBRw0dIARBQGsQ2SEMHQsgBEHEAGogAkEMahDDBgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAhB/wFxQQFrDgcCAwQFBgALAQsgBC0ARCICQRdrDgQIBwcIBgsgBEGwEGohAiMAQfABayIGJAAgBiADNgIQIAYgBzYCDCAGIAU2AhQCQAJAIARBxABqIggtAABBKUcEQCAGQSBqIAhBCGooAgA2AgAgBiAIKQIANwMYDAELIAZBqAFqIAVBCGoQiwUgBigC3AEiCEGAgICAeEYEQCAGQYABaiAGQbgBaikDACIQNwMAIAZB+ABqIAZBsAFqKQMAIhE3AwAgBiAGKQOoASISNwNwIAJBGGogEDcDACACQRBqIBE3AwAgAiASNwMIIAJCBjcDACAFIAUoAgAiAkEBazYCACACQQFGBEAgBkEUahDZIQsgBkEMahC8KgwCCyAGQfAAaiIJIAZBqAFqQTT8CgAAIAZB6ABqIAZB6AFqKQMANwMAIAYgBikD4AE3A2AgBkEoaiIKIAlBNPwKAAAgBiAINgJcIAZBGGogBkHQAGoQwgYgChCALwtBACEJIwBBMGsiCCQAIAggBTYCBAJAIAUuARgiCkEATARAIAhBgYCAgHg2AggMAQsCQCAKQQFHDQAgBS8BGg0AIAUoAhQiCUEIaiAJKAIIQQJGQQJ0ai0AICIJQQNHIAlBAEdxIQkLIAhBCGogCEEEaiAJEJUSCyACIAU2AqACIAJBADYCkAIgAkKAgICAEDcDiAIgBS4BGiEFIAJB4AFqIAhBCGpBKPwKAAAgAkICNwOYAiACQgA3AqQCIAJCBTcDACACIAVBAExBH3Q2ApQCIAhBMGokACACQYCAgIB4NgLEAiACQYCAgIB4NgK4AiACIAM2ArQCIAIgBzYCsAIgAiAGKQMYNwPQAiACQdgCaiAGQSBqKAIANgIACyAGQfABaiQAIARB2ABqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDUCAEKALAECEDIAQoArwQIQIgBCgCuBAhBiAEKQOwECIQQgZRDQogBEHgAGoiCCAEQdAQakHAAvwKAABB4AJBCBCmLyIHIAM2AhAgByACNgIMIAcgBjYCCCAHIBA3AwAgByAEKQNQNwIUIAdBHGogBSgCADYCACAHQSBqIAhBwAL8CgAAQczGzwAhAwwoCwJAIAQtAEQEQCAEQbAQaiAHIAMgBSAEQcQAahDwDSAEQfgFaiIFIARBzBBqKAIANgIAIAQgBCkCxBA3A/AFIAQoAsAQIQMgBCgCvBAhAiAEKAK4ECEGIAQpA7AQIhBCBlINASAEQThqIAUoAgA2AgAgBCAEKQPwBTcDMCACDCcLIARBsBBqIAUQyhUgBEGoA2oiBSAEQcwQaigCADYCACAEQQA6AIATIARBgICAgHg2AvQSIARBgICAgHg2AugSIAQgAzYC5BIgBCAHNgLgEiAEIAQpAsQQNwOgAyAEKALAECEDIAQoArwQIQIgBCgCuBAhBiAEKQOwECIQQgZRBEAgBEE4aiAFKAIANgIAIAQgBCkDoAM3AzAgBEHEAGoQnQwgAgwnCyAEQbADaiIFIARB0BBqQcAC/AoAAEHgAkEIEKYvIgcgAzYCECAHIAI2AgwgByAGNgIIIAcgEDcDACAHIAQpA6ADNwIUIAdBHGogBEGoA2ooAgA2AgAgB0EgaiAFQcAC/AoAACAEQcQAahCdDEH0xs8AIQMMKAsgBEGABmoiBSAEQdAQakHAAvwKAABB4AJBCBCmLyIHIAM2AhAgByACNgIMIAcgBjYCCCAHIBA3AwAgByAEKQPwBTcCFCAHQRxqIARB+AVqKAIANgIAIAdBIGogBUHAAvwKAABBnMfPACEDDCcLIARBsBBqIAcgAyAFIARBxABqEO8NIARByAhqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDwAggBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0jIARB0AhqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkDwAg3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBxMfPACEDDCYLIARBsBBqIAcgAyAFIARBxABqEPANIARBmAtqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcDkAsgBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0hIARBoAtqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkDkAs3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABB7MfPACEDDCULIARBsBBqIAcgAyAFIARBxABqEPANIARB6A1qIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcD4A0gBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0fIARB8A1qIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkD4A03AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBlMjPACEDDCQLIARBsBBqIAcgAyAFIARBxABqEO8NIARB2BVqIgUgBEHMEGooAgA2AgAgBCAEKQLEEDcD0BUgBCgCwBAhAyAEKAK8ECECIAQoArgQIQYgBCkDsBAiEEIGUQ0dIARBkBNqIgggBEHQEGpBwAL8CgAAQeACQQgQpi8iByADNgIQIAcgAjYCDCAHIAY2AgggByAQNwMAIAcgBCkD0BU3AhQgB0EcaiAFKAIANgIAIAdBIGogCEHAAvwKAABBvMjPACEDDCMLIAJBIkYNAgsgBEGwEGohBiMAQaAHayICJAAgAiADNgIQIAIgBzYCDCACIAU2AhQCQAJAIARBxABqIggtAABBKUcEQCACQSBqIAhBCGooAgA2AgAgAiAIKQIANwMYDAELIAJBqAFqIAVBCGoQiwUgAigC3AEiBUGAgICAeEYEQCACQYABaiACQbgBaikDACIQNwMAIAJB+ABqIAJBsAFqKQMAIhE3AwAgAiACKQOoASISNwNwIAZBEGogEDcDACAGQQhqIBE3AwAgBiASNwMAIAIoAhQiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBFGoQ2SELIAJBDGoQvCoMAgsgAkHwAGoiCSACQagBakE0/AoAACACQegAaiACQegBaikDADcDACACIAIpA+ABNwNgIAJBKGoiCCAJQTT8CgAAIAIgBTYCXCACQRhqIAJB0ABqEMEGIAgQ/i4LAkAgBgJ/AkACQAJAIAItABgiBUEUaw4GAQQCBAECAAsgBUEla0ECTw0DCyACIAIoAhQiCDYCKEEAIQUCQCAILgEYIglBAEwEQCACQYGAgIB4NgLQBgwBCwJAIAlBAUcNACAILwEaDQAgCCgCFCIFQQhqIAUoAghBAkZBAnRqLQAgIgVBA0cgBUEAR3EhBQsgAkHQBmogAkEoaiAFEJUSCyAILgEaIQogAkGwAWoiCUEANgIAIAJCgICAgMAANwKoASACQagBakEBEIYtIAJBmARqIAkoAgA2AgAgAiACKQKoATcDkAQgAkG4AWoiDCACQSBqKAIANgIAIAIgAikDGDcDsAFBsANBCBCtNiIFRQ0rIAVCBTcDACAFQQhqIAJB8AFqQawC/AoAACAFQQA2ArwCIAVCgICAgBA3ArQCIAVBwAJqIAJB0AZqQSj8CgAAIAVBgICAgHg2ApQDIAVBgICAgHg2AogDIAUgAzYChAMgBSAHNgKAAyAFQgA3A/gCIAUgCDYC9AIgBUICNwLsAiAFIApBAExBH3Q2AugCIAUgAikDqAE3A5gDIAVBoANqIAkpAwA3AwAgBUGoA2ogDCgCADYCAEGgic0ADAELIAIgAigCFCIINgIoQQAhBQJAIAguARgiCUEATARAIAJBgYCAgHg2AvgGDAELAkAgCUEBRw0AIAgvARoNACAIKAIUIgVBCGogBSgCCEECRkECdGotACAiBUEDRyAFQQBHcSEFCyACQfgGaiACQShqIAUQlRILIAguARohCiACQbABaiIJQQA2AgAgAkKAgICAgAE3AqgBIAJBqAFqQQEQhy0gAkHIBmogCSgCADYCACACIAIpAqgBNwPABiACQbgBaiIMIAJBIGooAgA2AgAgAiACKQMYNwOwAUGwA0EIEK02IgVFDSogBUIFNwMAIAVBCGogAkGgBGpBrAL8CgAAIAVBADYCvAIgBUKAgICAEDcCtAIgBUHAAmogAkH4BmpBKPwKAAAgBUGAgICAeDYClAMgBUGAgICAeDYCiAMgBSADNgKEAyAFIAc2AoADIAVCADcD+AIgBSAINgL0AiAFQgI3AuwCIAUgCkEATEEfdDYC6AIgBSACKQOoATcDmAMgBUGgA2ogCSkDADcDACAFQagDaiAMKAIANgIAQfiIzQALNgIIIAYgBTYCBCAGQQg2AgAMAQsgAkH0ic0ANgKoASACQgE3ArQBIAJBrQM2AiwgAiACQShqNgKwASACIAJBGGoiAzYCKCACQQE2AqwBIAZBBGogAkGoAWoQmQ4gBkEANgIAIAMQlAwgAigCFCIDIAMoAgAiA0EBazYCACADQQFGBEAgAkEUahDZIQsgAkEMahC8KgsgAkGgB2okACAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0hIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAwgCyAEQbAQaiEGIwBBkAJrIgIkACACIAM2AgggAiAHNgIEIAIgBTYCDAJAAkAgBEHEAGoiCC0AAEEpRwRAIAJBGGogCEEIaigCADYCACACIAgpAgAiEDcDECAQpyEFDAELIAJBoAFqIAVBCGoQiwUgAigC1AEiBUGAgICAeEYEQCACQfgAaiACQbABaikDACIQNwMAIAJB8ABqIAJBqAFqKQMAIhE3AwAgAiACKQOgASISNwNoIAZBEGogEDcDACAGQQhqIBE3AwAgBiASNwMAIAIoAgwiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBDGoQ2SELIAJBBGoQvCoMAgsgAkHoAGoiCSACQaABakE0/AoAACACQeAAaiACQeABaikDADcDACACIAIpA9gBNwNYIAJBIGoiCCAJQTT8CgAAIAIgBTYCVCACQRpBFyACLQBIQT1xQRhGGyIFOgAQIAgQ/i4LAkACQCAFQf8BcUEXaw4EAQAAAQALIAJBkJDNADYCoAEgAkIBNwKsASACQa0DNgIkIAIgAkEgajYCqAEgAiACQRBqIgM2AiAgAkEBNgKkASAGQQRqIAJBoAFqEJkOIAZBADYCACADEJQMIAIoAgwiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBDGoQ2SELIAJBBGoQvCoMAQsgAiACKAIMIgg2AqABQQAhBQJAIAguARgiCUEATARAIAJBgYCAgHg2AugBDAELAkAgCUEBRw0AIAgvARoNACAIKAIUIgVBCGogBSgCCEECRkECdGotACAiBUEDRyAFQQBHcSEFCyACQegBaiACQaABaiAFEJUSCyAILgEaIQkgAkGwAWoiCiACQRhqKAIANgIAIAIgAikDEDcDqAFBsANBCBCtNiIFBEAgBUIENwO4AiAFQgA3A7ACIAVCgICAgIACNwOoAiAFQgU3AwAgBUHAAmogAkHoAWpBKPwKAAAgBUGAgICAeDYClAMgBUGAgICAeDYCiAMgBSADNgKEAyAFIAc2AoADIAVCADcD+AIgBSAINgL0AiAFQgI3AuwCIAUgCUEATEEfdDYC6AIgBSACKQOgATcDmAMgBUGgA2ogAkGoAWopAwA3AwAgBUGoA2ogCigCADYCACAGQayPzQA2AgggBiAFNgIEIAZBCDYCAAwBCwwnCyACQZACaiQAIAQoArgQIQMgBCgCtBAhByAEKAKwECIGQQhGDSAgBEE4aiAEQcQQaigCADYCACAEIAQpArwQNwMwDB8LIARBsBBqIAcgAyAFIARBxABqELgBIAQoArgQIQMgBCgCtBAhByAEKAKwECIGQQhGDR8gBEE4aiAEQcQQaigCADYCACAEIAQpArwQNwMwDB4LIAQtAERBIkcEQCAEQbAQaiEIIwBBwARrIgIkACACIAM2AhAgAiAHNgIMIAIgBTYCFAJAAkACQCAEQcQAaiIGLQAAQSlHBEAgAkEgaiAGQQhqKAIANgIAIAIgBikCADcDGAwBCyACQagBaiAFQQhqEIsFIAIoAtwBIgZBgICAgHhGBEAgAkGAAWogAkG4AWopAwAiEDcDACACQfgAaiACQbABaikDACIRNwMAIAIgAikDqAEiEjcDcCAIQRBqIBA3AwAgCEEIaiARNwMAIAggEjcDAAwCCyACQfAAaiIJIAJBqAFqQTT8CgAAIAJB6ABqIAJB6AFqKQMANwMAIAIgAikD4AE3A2AgAkEoaiIKIAlBNPwKAAAgAiAGNgJcIAJBGGogAkHQAGoQwQYgChD+LgsCQAJAAkACQAJAAkACQAJAAkACQAJAIAVBCGoiBhDdJUH/AXEiCUEHRgRAIAIgBhDeJSIJNgL0AQJAIAItABgiBkEjaw4EBwgJCgALIAZBE2sOAwMCCwELIAIgCToAcCACQQE2AqwBIAJB2JbNADYCqAEgAkIBNwK0ASACQbEDNgIsIAIgAkEoajYCsAEgAiACQfAAajYCKAwJCyAGQQpGDQILIAJBATYCrAEgAkGUls0ANgKoASACQgE3ArQBIAJBrQM2AiwgAiACQShqNgKwASACIAJBGGo2AigMBwsgCUEMRw0BDAcLIAlBAkYNBiACQQE2AqwBIAJB6JLNADYCqAEgAkIBNwK0ASACQTs2AiwgAiACQShqNgKwASACIAJB9AFqNgIoDAULIAJBATYCrAEgAkGck80ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMBAsgCUEETQ0EIAJBATYCrAEgAkHgk80ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAwsgCUEITQ0DIAJBATYCrAEgAkGklM0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAgsgCUEQTQ0CIAJBATYCrAEgAkHolM0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigMAQsgCUEgTQ0BIAJBATYCrAEgAkHUlc0ANgKoASACQgE3ArQBIAJBOzYCLCACIAJBKGo2ArABIAIgAkH0AWo2AigLIAhBBGogAkGoAWoQmQ4gCEEANgIAIAJBGGoQlAwMAQsgAkH4AGogAkEgaigCADYCACACIAIpAxg3A3AgAiAFNgK8BEEAIQYCQCAFLgEYIgpBAEwEQCACQYGAgIB4NgKoAQwBCwJAIApBAUcNACAFLwEaDQAgBSgCFCIGQQhqIAYoAghBAkZBAnRqLQAgIgZBA0cgBkEAR3EhBgsgAkGoAWogAkG8BGogBhCVEgsgBS4BGiEKIAJBkARqIAJBqAFqQSj8CgAAIAJBOGoiDCACQfgAaigCADYCACACIAIpA3A3AzBBqANBCBCtNiIGBEAgBkIFNwMAIAZBCGogAkH4AWpBwAL8CgAAIAZBgICAgHg2AowDIAZBgICAgHg2AoADIAYgAzYC/AIgBiAHNgL4AiAGQgA3AuwCIAYgBTYC6AIgBkICNwPgAiAGIApBAExBH3Q2AtwCIAZBADYC2AIgBkKAgICAEDcD0AIgBkEANgLIAiAGIAIpAyg3A5ADIAZBmANqIAJBMGopAwA3AwAgBkGgA2ogDCgCADYCACAGIAk2AqQDIAhB8JTNADYCCCAIIAY2AgQgCEEINgIADAILQQhBqAMQoz0ACyAFIAUoAgAiA0EBazYCACADQQFGBEAgAkEUahDZIQsgAkEMahC8KgsgAkHABGokACAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0fIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAweCyAEQbAQaiAHIAMgBSAEQcQAahC4ASAEKAK4ECEDIAQoArQQIQcgBCgCsBAiBkEIRg0eIARBOGogBEHEEGooAgA2AgAgBCAEKQK8EDcDMAwdCyAEQThqIAUoAgA2AgAgBCAEKQNQNwMwIAIMGwsgBUEnRg0FCyAEIAJBDGo2AvANIARBAjYCtBAgBEGcw88ANgKwECAEQgE3ArwQIARBpwQ2ApQTIAQgBEGQE2o2ArgQIAQgBEHwDWo2ApATIARBsBBqQazDzwAQ7ywACyAAIAEgAiADQQAQqgkMHwsgBCACKAIIIgU2AqALIAVBAUcNBSAEQbAQaiABIAIoAgQgAxCeASAEKAK4ECEFIAQoArQQIQEgBCgCsBAiA0EIRwRAIAAgBCkCvBA3AgwgAEEUaiAEQcQQaigCADYCACAAIAU2AgggACABNgIEIAAgAzYCAAwfCyABRQRAQQAhAgwTCyAEQfANaiIGIAEgBSgCEBEEABDDBiACKAIQIQcgBEHkEGogAigCFCIDQTxqEN0gIARB2BBqIANBMGoQwwYgAy8BSCEIIAMpAyghECAEQbAQaiIJIANBCGoQsS4gBCAQNwPQECAEIAg7AfAQIARBkBNqIgggCSAGEKQrQdAAQQgQrTYiA0UNBiADQoGAgIAQNwMAIANBCGogCEHIAPwKAAAgAi0AHCEGIAIvARghCCACLwEaIQlBIEEEEK02IgJFDQcgAiAGOgAcIAIgCDsBGiACIAk7ARggAiAHNgIUIAIgBTYCECACIAE2AgwgAiADNgIIIAIgBzYCBCACQR06AAAMEgsgACABIAIgA0EBEKoJDB0LIAIoAgQhCCACKAIIIQUgBEEIaiACQRBqIgYQwzQgBCAFNgKwAyAEIAQoAgwiBzYCYCAFIAdHDQYgBEGwEGoiCSAFQQBBBEEIEKAYIAQoArQQIQcgBCgCsBBBAUYNByAEQQA2AogGIAQgBCgCuBA2AoQGIAQgBzYCgAYgBEHwDWogBRCUFyAEIAYQwzQgBCgCBCEHIAQgBCgCACIGNgKwECAEIAYgB0ECdGo2ArQQIAUgCRCeNiIHIAUgB0kbIgtFDQ0gBEHYEGohCiAEQeQQaiEMA0AgBEGwEGogASAIIAMQngEgBCgCuBAhCSAEKAK0ECEFIAQoArAQIgdBCEcEQCAAIAQpArwQNwIMIABBFGogBEHEEGooAgA2AgAgACAJNgIIIAAgBTYCBCAAIAc2AgAMEAsgBQRAIARB0AhqIg0gBSAJKAIQEQQAEMMGIAwgBigCACIHQTxqEN0gIAogB0EwahDDBiAHLwFIIQ4gBykDKCEQIARBsBBqIg8gB0EIahCxLiAEIBA3A9AQIAQgDjsB8BAgBEGQE2oiByAPIA0QpCsgBEHwDWogBxCIKSAEKAKIBiIHIAQoAoAGRgRAIARBgAZqQbzJzwAQmygLIAQoAoQGIAdBA3RqIg0gCTYCBCANIAU2AgAgBCAHQQFqNgKIBgsgBkEEaiEGIAhBIGohCCALQQFrIgsNAAsMDAsgBCACKAIIIgU2AsAIIAVBAkcNByAEQbAQaiABIAIoAgQiByADEJ4BIAQoArgQIQggBCgCtBAhBSAEKAKwECIGQQhHBEAgACAEKQK8EDcCDCAAQRRqIARBxBBqKAIANgIAIAAgCDYCCCAAIAU2AgQgACAGNgIADBwLIAQgCDYC5A0gBCAFNgLgDSAEQbAQaiABIAdBIGogAxCeASAEKAK4ECELIAQoArQQIQcgBCgCsBAiAUEIRwRAIAAgBCkCvBA3AgwgAEEUaiAEQcQQaigCADYCACAAIAs2AgggACAHNgIEIAAgATYCACAFRQ0cIARB4A1qELwqDBwLIAQgCzYCjAYgBCAHNgKIBiAEIAg2AoQGIAQgBTYCgAYCQAJAIAUEQCAHDQEgAEEEakHQxM8AQS8QgSAgAEEANgIAIARBgAZqELwqDB4LIAcNASAAQgg3AwAMHQsgBEHQFWoiCSAFIAgoAhARBAAQwwYgBEHgAGoiCiAHIAsoAhARBAAQwwYgAigCECIBLQAwQSBHDQkgBEEoaiABQTRqIgYQwzQgBCAEKAIsIgM2ApALIANBAkcNCiAEQaALaiINIAFBCGoQ7ShBkAFBCBCmLyEBIARBIGogBhDDNCAEKAIkRQ0LIARBsBBqIgMgBCgCICgCAEEIahDtKCAEQfANaiIMIAMgCRCkKyAEQRhqIAYQwzQgBCgCHCIGQQFLBEAgAyAEKAIYKAIEQQhqEO0oIARBkBNqIgYgAyAKEKQrIAEgDEHIAPwKAAAgAUHIAGogBkHIAPwKAAAgBEECNgK4ECAEIAE2ArQQIARBAjYCsBAgBEEQaiADEP4jIARBIDoAkBMgBCAEKQMQNwKUEyAEQdAIaiIBIA0gBhCkKyAEIAEQ0Ck2ArQDIARBJzoAsAMgBCACLQANOgCxAyACLwEaIQwgAi8BGCENIAItABwhDiMAQTBrIgEkAAJAAkACQAJAAkAgBEGwA2oiCi0AAEEnRgRAIAooAgQiBi0AMEEgRw0BIAEgBkE0ahDDNCABKAIEQQJHDQEgBi0ASEUEQCABQQhqIAZBMGoQwwZBEEEEEK02IglFDQMgCSALNgIMIAkgBzYCCCAJIAg2AgQgCSAFNgIAIAFBKGoiBSABQRBqKAIANgIAIAEgASkCCDcDIEEgQQQQrTYiAkUNBCACQQI2AgggAiAJNgIEIAJBAjYCACACIAEpAyA3AgwgAkEAOgAcIAIgDUEBajsBGiACQQJBASAOGyAMajsBGCACQRRqIAUoAgA2AgAgBiAGKAIAIgVBAWo2AgAgBUEASA0FIAMgDjoAJCADIA07ASIgAyAMOwEgIANBlMnPADYCHCADIAI2AhggAyAGNgIQIANBGzoADCADIAopAgA3AgAgA0EIaiAKQQhqKAIANgIAIAFBMGokAAwGCyABQQA2AhggAUEBNgIMIAFB4M3PADYCCCABQgQ3AhAgAUEIakHozc8AEO8sAAsgAUEANgIYIAFBATYCDCABQZjPzwA2AgggAUIENwIQIAFBCGpBoM/PABDvLAALIAFBADYCGCABQQE2AgwgAUHEzs8ANgIIIAFCBDcCECABQQhqQczOzwAQ7ywAC0EEQRAQoz0AC0EEQSAQoz0LAAtBKEEEEKYvIgEgA0Eo/AoAACAAQeDDzwA2AgggACABNgIEIABBCDYCAAwdC0EBIAZB0MPPABDDIQALIABBBGpB0MTPAEEvEIEgIABBADYCACAEQYgGahC8KgwbC0GYxM8AQShB5MjPABCfKQwWC0EEQRwQoz0ACyAEQQA2ArAQQQAgBEGgC2pBoMXPACAEQbAQakG8xs8AEK8rAAtBCEHQABCjPQALQQRBIBCjPQALIARBADYCsBBBACAEQeAAaiAEQbADaiAEQbAQakH0yM8AEK8rAAsgByAEKAK4EEGEyc8AEP0vAAsgBEEANgKwEEEAIARBwAhqQbzDzwAgBEGwEGpBgMXPABCvKwALQZjEzwBBKEHAxM8AEJ8pAAsgBEEANgKwEEEAIARBkAtqQbzDzwAgBEGwEGpBiMTPABCvKwALQQBBAEHAw88AEMMhAAsgBCgCiAZFDQAgBEGwEGoiASAEQfANakEw/AoAACAEQZATaiABEPEfIARBqAtqIgMgBEGIBmooAgA2AgAgBCAEKQKABjcDoAsgAi8BGiEFIAIvARghByACLQAcIQIgBCgCkBMhBiAEKAKUEyEIQSBBBBCtNiIBRQ0CIAEgBCkDoAs3AgAgASACOgAcIAEgBzsBGiABIAU7ARggASAINgIUIAEgBjYCECABQSA6AAwgAUEIaiADKAIANgIAIABBlMnPADYCCCAAIAE2AgQgAEEINgIAIARBmBNqEJMnDA8LIABCCDcDAAsgBEGQDmoiABDHJyAAEOk7IARB8A1qEJMnIARBgAZqIgAQgSMgAEEEQQgQ4B4MDQtBBEEgEKM9AAsgAEGUxs8ANgIIIAAgAjYCBCAAQQg2AgAMCwsgBEE4aiAFKAIANgIAIAQgBCkD0BU3AzAgAgwDCyAEQThqIAUoAgA2AgAgBCAEKQPgDTcDMCACDAILIARBOGogBSgCADYCACAEIAQpA5ALNwMwIAIMAQsgBEE4aiAFKAIANgIAIAQgBCkDwAg3AzAgAgshByAGQQhGDQELIAAgBCkDMDcCDCAAQRRqIARBOGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAY2AgAMBQsgB0UNASABKAIMIgJFDQIgAigCACALEPImRQRAIAAgAzYCCCAAIAc2AgQgAEEINgIADAULIAIoAgQoAgAiBSAFKAIAIgZBAWo2AgAgBkEASA0AIAItAAghCCABKAIIKAIAIgYEQCAGIAYoAgAiAUEBajYCACABQQBIDQELIwBBIGsiAiQAIAJBCGogBUEIahCoISACKAIMIgFBADoAACABKAIoIQlBAEHAABDRNEUEQEG0rM0AQSkgAkEQakGYs80AQeCszQAQ1R4ACyACQRBqQfCxzQAQpSsgAikDECEQIAIpAxghESAEQbAQaiIBIAU2AjwgASADNgIkIAEgBzYCICABIAhBAXE6AFQgAUEANgJQIAFCwAA3A0ggAULAADcDQCABIAk2AjQgAUIANwIsIAEgCzYCKCABQYCyzQApAwA3AwAgAUEIakGIss0AKQMANwMAIAEgBjYCOCABIBE3AxggASAQNwMQIAJBIGokAEHYAEEIEK02IgJFDQMgAiABQdgA/AoAACAAQcDCzwA2AgggACACNgIEIABBCDYCAAwECwALIABCCDcDAAwCCyAAIAM2AgggACAHNgIEIABBCDYCAAwBC0EIQdgAEKM9AAsgBEHgFWokAA8LQQhBsAMQoz0AC8ksAQl/IwBB8AFrIgQkACAEQQA2ApwBIARCgICAgMAANwKUAQJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAIgVBAWsOKAECAgICAwMDAwQEBB8FBiAgBwgJCgsMDQ4PEBESExEUFRYXGBkaGxwACyADQQE6ADggAyADKAIwENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQE6AAwgACACNgIEIABBATYCAAwnCyADQQE6ADggAyADKAIwENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQY6AAwgACACNgIEIABBATYCAAwmCyADQQRBABDCDyEBIANBAToAOCADKAIwIQIgA0EGQQEQrhEgA0EEIAVBAnRBnMb+AGooAgBBABDKDiADIAIQ2AchAiADQQA2AhQgA0EAOgA4IABBAjoADCAAIAI2AgggACABNgIEIABBATYCAAwlCyADQQRBABDCDyEBIANBAToAOCADKAIwIQIgA0EGQQAQrhEgA0EEIAVBAnRBjMb+AGooAgBBABDKDiADIAIQ2AchAiADQQA2AhQgA0EAOgA4IABBAjoADCAAIAI2AgggACABNgIEIABBATYCAAwkCyADQQRBABDCDyEHIANBAToAOCADKAIwIQFBASECIAVBC2sOAiEZGAsgA0EBOgA4IAQgAzYCuAEgBCADKAIwIgE2ArwBIARBuAFqQQAQvA4gAyABENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQg6AAwgACACNgIEIABBATYCAAwiCyADQQE6ADggBCADNgK4ASAEIAMoAjAiATYCvAEgBEG4AWpBARC8DiADIAEQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBCDoADCAAIAI2AgQgAEEBNgIADCELIANBAToAOCADKAIwIQIgAyABLQABQQEQuw4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQRI6AAwgACACNgIEIABBATYCAAwgCyADQQE6ADggAygCMCEFQQEhAiABLQABQQFrDgIaGBkLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBBDoADCAAIAI2AgQgAEEBNgIADB4LIANBAToAOCADKAIwIQIgA0EEIAEoAgRBABDKDiADIAIQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBDzoADCAAIAI2AgQgAEEBNgIADB0LIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBEzoADCAAIAI2AgQgAEEBNgIADBwLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBFzoADCAAIAI2AgQgAEEBNgIADBsLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBBToADCAAIAI2AgQgAEEBNgIADBoLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBFDoADCAAIAI2AgQgAEEBNgIADBkLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IANBBEEAEMIPIQIgACABNgIIIABBGDoADCAAIAI2AgQgAEEBNgIADBgLIAMgAiABKAIEQQhqEKsCIQEgA0EBOgA4IAMgAygCMBDYByECIANBADYCFCADQQA6ADggBCABNgK4ASADIARBuAFqQQEQwg8hASAAIAI2AgggAEEMOgAMIAAgATYCBCAAQQE2AgAMFwsgBEEANgLIASAEQQE2ArwBIARBzMX+ADYCuAEgBEIENwLAASAEQbgBakHUxf4AEO8sAAsgAyACIAEoAghBCGoQqwIhAiADQQE6ADggAygCMCEFIANBBCABKAIEQQAQyg4gAyAFENgHIQEgA0EANgIUIANBADoAOCAEIAI2ArgBIAMgBEG4AWpBARDCDyECIAAgATYCCCAAQRA6AAwgACACNgIEIABBATYCAAwVCyADIAIgASgCBEEIahCrAiEBIANBAToAOCADIAMoAjAQ2AchAiADQQA2AhQgA0EAOgA4IAQgATYCuAEgAyAEQbgBakEBEMIPIQEgACACNgIIIABBFToADCAAIAE2AgQgAEEBNgIADBQLIARBADYCwAEgBEKAgICAwAA3ArgBIARBOGogAUEEahCvLiAEKAI4IgEgBCgCPCIGRwRAA0AgAyACIAEoAgBBCGoQqwIhByAEKALAASIFIAQoArgBRgRAIARBuAFqQeTF/gAQnSgLIAQoArwBIAVBAnRqIAc2AgAgBCAFQQFqNgLAASABQQRqIgEgBkcNAAsLIANBAToAOCADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IAMgBCgCvAEgBCgCwAEQwg8hAiAAIAE2AgggAEENOgAMIAAgAjYCBCAAQQE2AgAgBEG4AWpBBEEEEOAeDBMLIARBADYCqAEgBEKAgICAwAA3AqABIARBiAFqIAFBBGoiBxCwLiAEKAKIASIFIAQoAowBIghHBEADQCADIAIgBUEEaigCAEEIahCrAiEKIAQoAqgBIgYgBCgCoAFGBEAgBEGgAWpB9MX+ABCdKAsgBCgCpAEgBkECdGogCjYCACAEIAZBAWo2AqgBIAVBCGoiBSAIRw0ACwsgAS0AASEKIARBgAFqIAcQsC4gBCgCgAEhASAEKAKEASEFIwBBIGsiAiQAIAJBFGogBSABa0EDdkEAQQRBBBCgGCACKAIYIQYgAigCFEEBRgRAIAYgAigCHEHQt/4AEP0vAAsgBEGsAWohCSACQRBqIgtBADYCACACIAIoAhw2AgwgAiAGNgIIIAJBCGoiBiAFIAFrQQN2IgcQ7i0gBigCCCEIIAYgASAFRwR/IAcgCGogBigCBCAIQQJ0aiEFA0AgBSABLAAANgIAIAFBCGohASAFQQRqIQUgB0EBayIHDQALBSAICzYCCCAJQQhqIAsoAgA2AgAgCSACKQIINwIAIAJBIGokACADQQQgAygCNCIBIAFBBE0bNgI0IAQoArABIQcgA0EwaiEGIAQoArQBIghBAnQhAQJAQQAgAygCMCIFa0EDcSICIAMoAgggBWtNDQAgAygCCCADKAIwayACTw0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAIQjTcCQCABQQRqIgIgAygCCCADKAIwayIFTQ0AIAJBgICAgHhLDRAgAiAFTQ0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAEQjTcgBEH4AGogAxDcOyAEQfAAaiAEKAJ4IAQoAnwgAygCMCICIAIgAWtByLb+ABDXJiAEKAJ0IQEgBCgCcCECIARBBDYC7AEgBCACNgLkASAEIAFBA3E2AuABIAQgAUF8cSIBNgLoASAEIAEgAmo2AtwBIwBBEGsiAiQAIAIgByAIQQJ0aiILNgIMIAIgBzYCCCACQQhqEJ42IQkgBEHcAWoiBSgCECIMRQRAQeT0/gAQ4isACyAEQbgBaiIBQQA2AhwgASALNgIEIAEgBzYCACABIAUpAgA3AgggAUEQaiAFQQhqKQIANwIAIAFBGGogBUEQaigCADYCACABIAUoAgwgDG4iASAJIAEgCUkbNgIgIAJBEGokACAEKALYASIBIAQoAtQBIgJLBEAgASACayEFIAQoArgBIAJBAnRqIQEgBCgCyAEgAiAEKALQASIHbGohAgNAIAIgASgCADYAACABQQRqIQEgAiAHaiECIAVBAWsiBQ0ACwsgAyAIEKkRIQcgBEGsAWoQ6TsgA0EBOgA4IAMoAjAhAQJ/IApFBEAgASADLQA6QQFHDQEaCyADQQIgAygCNCICIAJBAk0bNgI0AkAgAUEBcSICIAMoAgggAWtNDQAgAygCCCADKAIwayACTw0AA0AgAxD7FiADKAIIIAMoAjBrIAJJDQALCyAGIAIQjTcgAygCCCADKAIwa0EBSyICIAJyRQRAA0AgAxD7FiADKAIIIAMoAjBrQQJJDQALCyAGQQIQjTcgBEHoAGogAxDcOyAEKAJsIQIgBCgCaCEFIARB4ABqIAMoAjAQjDcgBEHYAGogBSACIAQoAmAgBCgCZEGwt/4AENcmIAQoAlxBAU0NFCAEKAJYIAo7AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIIQQQ7AQQgCCAFNgIAIAMgAkEBajYCFCADKAIwCyEFIANBBCADKAI0IgIgAkEETRs2AjQCQEEAIAVrQQNxIgIgAygCCCAFa00NACADKAIIIAMoAjBrIAJPDQADQCADEPsWIAMoAgggAygCMGsgAkkNAAsLIAYgAhCNNyADKAIIIAMoAjBrQQNLIgIgAnJFBEADQCADEPsWIAMoAgggAygCMGtBBEkNAAsLIAZBBBCNNyAEQdAAaiADENw7IAQoAlQhAiAEKAJQIQUgBEHIAGogAygCMBCMNyAEQUBrIAUgAiAEKAJIIAQoAkxBsLf+ABDXJiAEKAJEIgJBA00NEyAEKAJAIAIgB2s2AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIGQQY7AQQgBiAFNgIAIAMgAkEBajYCFCADIAEQ2AchASADQQA2AhQgA0EAOgA4IAMgBCgCpAEgBCgCqAEQwg8hAiAAIAE2AgggAEEOOgAMIAAgAjYCBCAAQQE2AgAgBEGgAWpBBEEEEOAeDBILIAAgASgCCCACIAMQnwEMEQsgA0EBOgA4IAMoAjAhAiADQQQgAS0AAUEAEMoOIANBBiABLAACQQAQyg4gA0EIQSBBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwQCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBwABBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwPCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBgAFBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwOCyADQQE6ADggAygCMCECIANBBCABLQABQQAQyg4gA0EGIAEsAAJBABDKDiADQQhBgAJBgAEQyg4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQc6AAwgACACNgIEIABBATYCAAwNCyADIAIgASgCBEEIahCrAiECIANBAToAOCADKAIwIQUgA0EEIAEtAAEQrhEgAyAFENgHIQEgA0EANgIUIANBADoAOCAEIAI2ArgBIAMgBEG4AWpBARDCDyECIAAgATYCCCAAQRE6AAwgACACNgIEIABBATYCAAwMCyADIAIgASgCBEEIahCrAiEFIAMgAiABKAIIQQhqEKsCIQEgA0EBOgA4IAQgATYCvAEgBCAFNgK4ASADIAMoAjAQ2AchASADQQA2AhQgA0EAOgA4IAMgBEG4AWpBAhDCDyECIAAgATYCCCAAQRY6AAwgACACNgIEIABBATYCAAwLC0EAIQIgAy0AOkEBRw0JDAgLQQIhAgwHCyADIAEoAgQiAkEIakEBIAIbIAEoAghBACACGyICELQLIQUgA0EBOgA4IAMoAjAhBiADIAEtAAFBABC7DiACBEAgA0EGIAUQ/A4LIAMgBhDYByEBIANBADYCFCADQQA6ADggA0EEQQAQwg8hAiAAIAE2AgggAEEKOgAMIAAgAjYCBCAAQQE2AgAMCAsgA0EBOgA4IAMoAjAhAiADQQYgAS0AASIBQQJ0QbTG/gBqKAIAQSAQyg4gAyABQQEQuw4gAyACENgHIQEgA0EANgIUIANBADoAOCADQQRBABDCDyECIAAgATYCCCAAQQk6AAwgACACNgIEIABBATYCAAwHC0ECIQIMAQtBACECQQQgAy0AOkEBRw0BGgsgA0EwaiEGIANBAiADKAI0IgEgAUECTRs2AjQCQCAFQQFxIgEgAygCCCAFa00NACADKAIIIAMoAjBrIAFPDQADQCADEPsWIAMoAgggAygCMGsgAUkNAAsLIAYgARCNNyADKAIIIAMoAjBrQQFLIgEgAXJFBEADQCADEPsWIAMoAgggAygCMGtBAkkNAAsLIAZBAhCNNyAEQTBqIAMQ3DsgBCgCNCEBIAQoAjAhBiAEQShqIAMoAjAQjDcgBEEgaiAGIAEgBCgCKCAEKAIsQbC3/gAQ1yYgBCgCJEEBTQ0FIAQoAiAgAjsAACADKAIwIQIgAygCFCIBIAMoAgxGBEAgA0EMakG4tv4AEJsoCyADKAIQIAFBA3RqIgZBBDsBBCAGIAI2AgAgAyABQQFqNgIUIAQoApwBIQIgBCgCmAELIQEgAyAFENgHIQUgA0EANgIUIANBADoAOCADIAEgAhDCDyEBIAAgBTYCCCAAQQs6AAwgACABNgIEIABBATYCAAwDC0HYtv4AQSVBgLf+ABCfKQALIANBMGohBiADQQIgAygCNCIFIAVBAk0bNgI0AkAgAUEBcSIFIAMoAgggAWtNDQAgAygCCCADKAIwayAFTw0AA0AgAxD7FiADKAIIIAMoAjBrIAVJDQALCyAGIAUQjTcgAygCCCADKAIwa0EBSyIFIAVyRQRAA0AgAxD7FiADKAIIIAMoAjBrQQJJDQALCyAGQQIQjTcgBEEYaiADENw7IAQoAhwhBSAEKAIYIQYgBEEQaiADKAIwEIw3IARBCGogBiAFIAQoAhAgBCgCFEGwt/4AENcmIAQoAgxBAU0NAiAEKAIIIAI7AAAgAygCMCEFIAMoAhQiAiADKAIMRgRAIANBDGpBuLb+ABCbKAsgAygCECACQQN0aiIGQQQ7AQQgBiAFNgIAIAMgAkEBajYCFAsgAyABENgHIQEgA0EANgIUIANBADoAOCAAQQM6AAwgACABNgIIIAAgBzYCBCAAQQE2AgALIARBlAFqQQRBBBDgHiAEQfABaiQADwsgBEEANgLIASAEQQE2ArwBIARB7Lf+ADYCuAEgBEIENwLAASAEQbgBakHAt/4AEO8sAAvtOAENfyMAQbABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AGEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnSAALIARBBGoiAiABQcQA/AoAAAJ/IwBBMGsiBSQAIAUgAkEYaiIBNgIQAkACQCABQaSphgEQyAgEQCAFQQhqIAIQ3DsgBSAFKAIMIgE2AhQgAQ0BIAIoAiwNAiACKAIkIAIQjCcgBUEwaiQADAMLIAVCADcCJCAFQoGAgIDAADcCHCAFQbCqhgE2AhggBUEQakGIqoYBIAVBGGpBuKqGARCjKwALIAVCADcCJCAFQoGAgIDAADcCHCAFQdSrhgE2AhhBACAFQRRqQbCihgEgBUEYakHcq4YBEK8rAAsgBUEANgIoIAVBATYCHCAFQZSrhgE2AhggBUIENwIgIAVBGGpBnKuGARDvLAALIQJBDEEEEK02IgFFDUAgASACNgIIIAFCgYCAgBA3AgBBpJ6EASECDEgLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0RBBNEEEEK02IgFFDUAgAUKBgICAEDcCACABQQhqIAJBLPwKAABB/J6EASECDEcLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQthNBOEEEEK02IgFFDUcgAUKBgICAEDcCACABQQhqIAJBMPwKAABBpJOEASECDEYLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQvRNBOEEEEK02IgFFDUYgAUKBgICAEDcCACABQQhqIAJBMPwKAABBxJCEASECDEULIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQrRNBOEEEEK02IgFFDUUgAUKBgICAEDcCACABQQhqIAJBMPwKAABBzJKEASECDEQLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQsRNBOEEEEK02IgFFDUQgAUKBgICAEDcCACABQQhqIAJBMPwKAABBrJWEASECDEMLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQuBNBOEEEEK02IgFFDUMgAUKBgICAEDcCACABQQhqIAJBMPwKAABBnJGEASECDEILIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQqhNBOEEEEK02IgFFDUIgAUKBgICAEDcCACABQQhqIAJBMPwKAABB9JGEASECDEELIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQuRNBOEEEEK02IgFFDUEgAUKBgICAEDcCACABQQhqIAJBMPwKAABB1JSEASECDEALIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQrhNBOEEEEK02IgFFDUAgAUKBgICAEDcCACABQQhqIAJBMPwKAABB/JOEASECDD8LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQqxNBOEEEEK02IgFFDT8gAUKBgICAEDcCACABQQhqIAJBMPwKAABB1J+EASECDD4LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQsxNBOEEEEK02IgFFDT4gAUKBgICAEDcCACABQQhqIAJBMPwKAABBrKCEASECDD0LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQxxNBOEEEEK02IgFFDT0gAUKBgICAEDcCACABQQhqIAJBMPwKAABBhKGEASECDDwLIAEtABlBAWsOAxscHRoLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQxBNBOEEEEK02IgFFDTsgAUKBgICAEDcCACABQQhqIAJBMPwKAABBvKSEASECDDoLIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQwBNBOEEEEK02IgFFDTogAUKBgICAEDcCACABQQhqIAJBMPwKAABBlKWEASECDDkLIAEtABkOAhwdGwsgAS0AGUECaw4CHR4aCyABLQAZQQFrDgMfICEeCyABLQAZQQFrDgIiIyELIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQjQxBxABBBBCtNiIBRQ02IAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQeSthAEhAgw0CyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEMsSQcAAQQQQrTYiAUUNNiABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEG8roQBIQIMMwsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCLDEHEAEEEEK02IgFFDTQgAUKBgICAEDcCACABQQhqIAJBPPwKAABBlK+EASECDDILIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0Q1BxABBBBCtNiIBRQ0zIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQeyvhAEhAgwxCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEI4MQcQAQQQQrTYiAUUNMiABQoGAgIAQNwIAIAFBCGogAkE8/AoAAEHEsIQBIQIMMAsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCMDEHEAEEEEK02IgFFDTEgAUKBgICAEDcCACABQQhqIAJBPPwKAABBnLGEASECDC8LIARBBGoiBSABQcQA/AoAACAEQewAaiICIAUQ0g1BxABBBBCtNiIBRQ0wIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAQfSxhAEhAgwuCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEK8fQcAAQQQQrTYiAUUNMCABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEHMsoQBIQIMLQsgBEEEaiICIAFBxAD8CgAAIARB7ABqIQ4jAEHgAGsiCiQAIApBBGohBkEAIQEjAEGAAmsiAyQAIANBOGogAhDcOwJAAkACQAJAAkACQAJAAkAgAygCPEECRgRAIANBKGogAhDvPCADKAIsQQFHDQIgA0EYaiACEO88IAMoAhxFDQQgA0H0AWogAygCGCIHQRhqENgGIAcoAighDSAHKAIkIQUgA0GMAWogBxC+FSADQaQBaiAHQQxqEIALIAcoAiwiCQRAIAkgCSgCACIBQQFqNgIAIAFBAEgNBCAHKAJAIQsgBygCPCEIIAcoAjghDCAHKAI0IQEgBygCMCEHCyADQeAAaiADQfwBaigCADYCACADQcgAaiADQZQBaigCADYCACADQdQAaiADQawBaigCADYCACADIAMpAvQBNwNYIAMgDTYCaCADIAU2AmQgAyADKQKMATcDQCADIAMpAqQBNwJMIAMgCzYCgAEgAyAINgJ8IAMgDDYCeCADIAE2AnQgAyAHNgJwIAMgCTYCbCACQRhqIQsgAi0AGEEcRw0BIAMgAigCHEEwaiIFNgKIASADQdgAaiIBIAUQxwhFDQUgA0GkAWoiCSADQUBrQcQA/AoAACADQRBqIAkQoAEgAygCFCEMIAMoAhAhDSADQQhqIAIQ3DsgAygCDEUNBiADKAIIIgUoAgAiCCAIKAIAIgFBAWo2AgAgAUEASA0DIAMgCDYCpAEgAyAFKQIENwKoASADQegBaiAJIAIoAiggAigCJBCAHSADIAIQ3DsgAygCBCIBQQFLBEAgAygCACIFKAIMIgggCCgCACIBQQFqNgIAIAFBAEgNBCADIAg2AowBIAMgBSkCEDcCkAEgCSADQYwBaiACKAIoIAIoAiQQgB0gBiALENgGIAZBLGogAkEsakEAIAIoAiwbEO4lIAYgDDYCECAGIA02AgwgBkEcaiADQfABaigCADYCACAGIAMpAugBNwIUIAYgAykCpAE3AiAgBkEoaiADQawBaigCADYCAAwJC0EBIAFBhJiGARDDIQALIANBMGogAhDcOyADQTs2AkQgA0EBNgKoASADQeyahgE2AqQBIANCATcCsAEgAyADKAI0NgKMASADIANBjAFqNgJAIAMgA0FAazYCrAEgBkEIaiADQaQBahCZDiAGQSk6AAAgBkGNgICAeDYCBAwHCyADIAs2AvQBIANBAzYCkAEgA0GwmYYBNgKMASADQgM3ApgBIANBrwM2ArgBIANBxwI2ArABIANBzI6GATYCrAEgA0HHAjYCqAEgA0HMjoYBNgKkASADIANBpAFqNgKUASADIANB9AFqNgK0AQwFCyADQSBqIAIQ7zwgA0E7NgJEIANBATYCqAEgA0GQmoYBNgKkASADQgE3ArABIAMgAygCJDYCjAEgAyADQYwBajYCQCADIANBQGs2AqwBIAZBCGogA0GkAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMBQsAC0EAQQBB5JeGARDDIQALIAMgATYC9AEgA0EDNgKQASADQeCYhgE2AowBIANCAzcCmAEgA0GvAzYCuAEgA0GvAzYCsAEgA0HHAjYCqAEgA0HMjoYBNgKkASADIANBpAFqNgKUASADIANBiAFqNgK0ASADIANB9AFqNgKsAQwBC0EAQQBB9JeGARDDIQALIAZBCGogA0GMAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQgA0FAaxCLJwsgAhCLJyADQYACaiQAAkAgCi0ABEEpRwRAIA4gBkHEAPwKAAAgCkHgAGokAAwBCwwxC0HMAEEEEK02IgFFDSYgAUKBgICAEDcCACABQQhqIA5BxAD8CgAAQaSzhAEhAgwsCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFENwUQTxBBBCtNiIBRQ0mIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAQfyzhAEhAgwrCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEK4fQcAAQQQQrTYiAUUNLSABQoGAgIAQNwIAIAFBCGogAkE4/AoAAEHUtIQBIQIMKgsgBEEEaiICIAFBxAD8CgAAIARB7ABqIQ4jAEHgAGsiCiQAIApBBGohBkEAIQEjAEGAAmsiAyQAIANBOGogAhDcOwJAAkACQAJAAkACQAJAAkAgAygCPEECRgRAIANBKGogAhDvPCADKAIsQQFHDQIgA0EYaiACEO88IAMoAhxFDQQgA0H0AWogAygCGCIHQRhqENgGIAcoAighDSAHKAIkIQUgA0GMAWogBxC+FSADQaQBaiAHQQxqEIALIAcoAiwiCQRAIAkgCSgCACIBQQFqNgIAIAFBAEgNBCAHKAJAIQsgBygCPCEIIAcoAjghDCAHKAI0IQEgBygCMCEHCyADQeAAaiADQfwBaigCADYCACADQcgAaiADQZQBaigCADYCACADQdQAaiADQawBaigCADYCACADIAMpAvQBNwNYIAMgDTYCaCADIAU2AmQgAyADKQKMATcDQCADIAMpAqQBNwJMIAMgCzYCgAEgAyAINgJ8IAMgDDYCeCADIAE2AnQgAyAHNgJwIAMgCTYCbCACQRhqIQsgAi0AGEEfRw0BIAMgAigCHEEwaiIFNgKIASADQdgAaiIBIAUQxwhFDQUgA0GkAWoiCSADQUBrQcQA/AoAACADQRBqIAkQoAEgAygCFCEMIAMoAhAhDSADQQhqIAIQ3DsgAygCDEUNBiADKAIIIgUoAgAiCCAIKAIAIgFBAWo2AgAgAUEASA0DIAMgCDYCpAEgAyAFKQIENwKoASADQegBaiAJIAIoAiggAigCJBD+HCADIAIQ3DsgAygCBCIBQQFLBEAgAygCACIFKAIMIgggCCgCACIBQQFqNgIAIAFBAEgNBCADIAg2AowBIAMgBSkCEDcCkAEgCSADQYwBaiACKAIoIAIoAiQQ/hwgBiALENgGIAZBLGogAkEsakEAIAIoAiwbEO4lIAYgDDYCECAGIA02AgwgBkEcaiADQfABaigCADYCACAGIAMpAugBNwIUIAYgAykCpAE3AiAgBkEoaiADQawBaigCADYCAAwJC0EBIAFBhJiGARDDIQALIANBMGogAhDcOyADQTs2AkQgA0EBNgKoASADQeyahgE2AqQBIANCATcCsAEgAyADKAI0NgKMASADIANBjAFqNgJAIAMgA0FAazYCrAEgBkEIaiADQaQBahCZDiAGQSk6AAAgBkGNgICAeDYCBAwHCyADIAs2AvQBIANBAzYCkAEgA0GwmYYBNgKMASADQgM3ApgBIANBrwM2ArgBIANBxwI2ArABIANB3I+GATYCrAEgA0HHAjYCqAEgA0Hcj4YBNgKkASADIANBpAFqNgKUASADIANB9AFqNgK0AQwFCyADQSBqIAIQ7zwgA0E7NgJEIANBATYCqAEgA0GQmoYBNgKkASADQgE3ArABIAMgAygCJDYCjAEgAyADQYwBajYCQCADIANBQGs2AqwBIAZBCGogA0GkAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMBQsAC0EAQQBB5JeGARDDIQALIAMgATYC9AEgA0EDNgKQASADQeCYhgE2AowBIANCAzcCmAEgA0GvAzYCuAEgA0GvAzYCsAEgA0HHAjYCqAEgA0Hcj4YBNgKkASADIANBpAFqNgKUASADIANBiAFqNgK0ASADIANB9AFqNgKsAQwBC0EAQQBB9JeGARDDIQALIAZBCGogA0GMAWoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQgA0FAaxCLJwsgAhCLJyADQYACaiQAAkAgCi0ABEEpRwRAIA4gBkHEAPwKAAAgCkHgAGokAAwBCwwuC0HMAEEEEK02IgFFDSUgAUKBgICAEDcCACABQQhqIA5BxAD8CgAAQay1hAEhAgwpCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFEIYXQTxBBBCtNiIBRQ0lIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAQYS2hAEhAgwoCyAEQQRqIgUgAUHEAPwKAAAgBEHsAGoiAiAFELcEQThBBBCtNiIBRQ0oIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAQdy2hAEhAgwnCyABKAIcIgItAABBAmsOCBYXGBkaGxwdFQsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRDDE0E4QQQQrTYiAUUNJiABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEGsvYQBIQIMJQsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRC3E0E4QQQQrTYiAUUNJSABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEGEvoQBIQIMJAsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRCwE0E4QQQQrTYiAUUNJCABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEHcvoQBIQIMIwsgBEEEaiIFIAFBxAD8CgAAIARB7ABqIgIgBRDFE0E4QQQQrTYiAUUNIyABQoGAgIAQNwIAIAFBCGogAkEw/AoAAEG0v4QBIQIMIgsgBEHsAGoiBSABQcQA/AoAACAEQQRqIgIgBRC4BkHsAEEEEK02IgFFDR8gAUKBgICAEDcCACABQQhqIAJB5AD8CgAAQYzAhAEhAgwhCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEL8TIAEQ3CkhAUHcoYQBIQIMIAsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhDGEyABENwpIQFBtKKEASECDB8LIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQqBMgARDcKSEBQYyjhAEhAgweCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELQTIAEQ3CkhAUHko4QBIQIMHQsgBCABQRhqNgJoIARBATYCCCAEQeSohAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpB7KiEARDvLAALIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQuxMgARDcKSEBQeylhAEhAgwbCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELITIAEQ3CkhAUHEpoQBIQIMGgsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhDCEyABENwpIQFBnKeEASECDBkLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQqRMgARDcKSEBQfSnhAEhAgwYCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACELwTIAEQ3CkhAUH8qIQBIQIMFwsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhC1EyABENwpIQFB1KmEASECDBYLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQuhMgARDcKSEBQayqhAEhAgwVCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEMETIAEQ3CkhAUGEq4QBIQIMFAsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhCvEyABENwpIQFB3KuEASECDBMLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQrBMgARDcKSEBQbSshAEhAgwSCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEL4TIAEQ3CkhAUGMrYQBIQIMEQsgBCACNgJoIARBATYCCCAEQZS9hAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpBnL2EARDvLAALIARBBGoiAiABEJ4IIAIQ6ykhAUG0t4QBIQIMDwsgBEEEaiICIAEQpAggAhDrKSEBQYy4hAEhAgwOCyAEQQRqIgIgARCiCCACEOspIQFB5LiEASECDA0LIARBBGoiAiABEKAIIAIQ6ykhAUG8uYQBIQIMDAsgBEEEaiICIAEQnQggAhDrKSEBQZS6hAEhAgwLCyAEQQRqIgIgARCfCCACEOspIQFB7LqEASECDAoLIARBBGoiAiABEKMIIAIQ6ykhAUHEu4QBIQIMCQsgBEEEaiICIAEQoQggAhDrKSEBQZy8hAEhAgwIC0EEQQwQoz0AC0EEQTQQoz0AC0EEQcwAEKM9AAtBBEE8EKM9AAtBBEHMABCjPQALQQRBPBCjPQALQQRB7AAQoz0ACwJAAkACQAJAIAEoAhwiAi0AMEEDaw4DAgEAAwsgBEEEaiICIAFBxAD8CgAAIARB7ABqIgEgAhCgCSABEPUpIQFBlMKEASECDAMLIARBBGoiAiABQcQA/AoAACAEQewAaiIBIAIQngkgARD1KSEBQbzBhAEhAgwCCyAEQQRqIgIgAUHEAPwKAAAgBEHsAGoiASACEJ8JIAEQ9SkhAUHkwIQBIQIMAQsgBCACQTBqNgJoIARBATYCCCAEQZTDhAE2AgQgBEIBNwIQIARBrwM2AnAgBCAEQewAajYCDCAEIARB6ABqNgJsIARBBGpBnMOEARDvLAALIAAgAjYCBCAAIAE2AgAgBEGwAWokAA8LQQRBOBCjPQALQQRBxAAQoz0AC0EEQcAAEKM9AAsgCkHYAGogCkEYaigCADYCACAKQdAAaiAKQRBqKQIANwMAIAogCikCCDcDSEGEl4YBQc0AIApByABqQdCLhgFB1JeGARDVHgALnjECEH8DfiMAQfAbayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AsAdBAWsOAwIHAQALIAJBvA9qIABBrAdqKAIANgIAIAIgACkCpAc3ArQPIAJBkAFqIgMgAkGoCGpBmAf8CgAAIAAgA0GYB/wKAAAgAEEAOgCYByAAQZgHaiEIDAMLIABBmAdqIQgCQAJAIAAtAJgHQQFrDgMBBwAECyAAQYAHaiEJIAAtAIAHQQFrDgMCBgUEC0GM2sIAEOgrAAtB3NrCABDoKwALQezZwgAQ6CsACyACQcgPaiAAQZQHaigCADYCACACIAApAowHNwPADyAAEOgmNgKIByACQagIaiIDIABBiAdqQdS3wwAgAkHAD2oQ1BAgACADQYAH/AoAACAAQQA6AIAHIABBgAdqIQkLIABB2AFqIABB2AH8CgAAIAAoAuABIQMgACkD2AEiEkIDUQRAIAAoAqgDIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQagDahCdJwsgAEEBOgCAByAAEKoeDBALIAJBxBBqIABBDGpBxAH8CgAAIAIgAzYCwBAgAiASNwO4ECACQYgSaiIDIABBqANqIAJBuBBqEM4SIABBsANqIANB0AP8CgAACyAAQbADaiELAkACQAJAIAAtAPwGQQFrDgMBAwIACyAAQQA6AP0GIABBgAVqIgQgC0HQAfwKAAAgABCvPjYC0AYgAEHQBmohB0Gf1MIAIQVBByEDAkACQAJAAkACQAJAAkACQAJAAkACQCAALQC0BkEBaw4KAAECAwQFBgcICQoLQabUwgAhBUEDIQMMCQtBqdTCACEFQQQhAwwIC0Gt1MIAIQVBAyEDDAcLQbDUwgAhBUEGIQMMBgtBttTCACEFQQQhAwwFC0G61MIAIQVBBSEDDAQLQb/UwgAhBQwDC0HG1MIAIQVBBSEDDAILIAJBgAFqIABBtQZqEP8sIAIoAoQBIQMgAigCgAEhBQwBCyACQYgBaiAAQbgGahDXOyACKAKMASEDIAIoAogBIQULIAcgBSADEO06IAJB+ABqENMlIAIoAnwhBQJAIAIoAnhBAXFFDQAgAkHwAGogBRCEGSACKAJ0IQUgAigCcCIDRQ0AIAMgBRD6OiEDDAoLIAAgBTYC1AYgAEEBOgD9BiACQcgaaiAEEPsuIAJB4BdqIAJB0BpqKQIANwMAIAIgAikCyBo3A9gXIAJB6ABqIAJB2BdqEO0SIAIoAmgiBQRAIABB1AZqIQ0gAigCbCEGA0ACQCAFKAIABEAgBSgCCCEEIAUoAgQhAwwBC0EGIQRBsMvCACEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFLQAEQQFrDlAAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1ALQQ4hBEG2y8IAIQMMTwtBDyEEQcTLwgAhAwxOC0EPIQRB08vCACEDDE0LQQ0hBEHiy8IAIQMMTAtBICEEQe/LwgAhAwxLC0EcIQRBj8zCACEDDEoLQRwhBEGrzMIAIQMMSQtBGyEEQcfMwgAhAwxIC0EdIQRB4szCACEDDEcLQRYhBEH/zMIAIQMMRgtBHiEEQZXNwgAhAwxFC0EdIQRBs83CACEDDEQLQQMhBEHQzcIAIQMMQwtBBSEEQdPNwgAhAwxCC0EHIQRB2M3CACEDDEELQQ0hBEHfzcIAIQMMQAtBDSEEQezNwgAhAww/C0EMIQRB+c3CACEDDD4LQREhBEGFzsIAIQMMPQtBCiEEQZbOwgAhAww8C0ETIQRBoM7CACEDDDsLQRAhBEGzzsIAIQMMOgtBECEEQcPOwgAhAww5C0EOIQRB087CACEDDDgLQRAhBEHhzsIAIQMMNwtBDSEEQfHOwgAhAww2C0EXIQRB/s7CACEDDDULQSMhBEGVz8IAIQMMNAtBDCEEQbjPwgAhAwwzC0HEz8IAIQMMMgtBAyEEQcrPwgAhAwwxC0EEIQRBzc/CACEDDDALQQQhBEHRz8IAIQMMLwtB1c/CACEDDC4LQQchBEHbz8IAIQMMLQtBCSEEQeLPwgAhAwwsC0EEIQRB68/CACEDDCsLQQQhBEHvz8IAIQMMKgtBCCEEQfPPwgAhAwwpC0ERIQRB+8/CACEDDCgLQQ0hBEGM0MIAIQMMJwtBCCEEQZnQwgAhAwwmC0ETIQRBodDCACEDDCULQQ0hBEG00MIAIQMMJAtBBCEEQcHQwgAhAwwjC0EIIQRBxdDCACEDDCILQQwhBEHN0MIAIQMMIQtB2dDCACEDDCALQd/QwgAhAwwfC0ESIQRB5dDCACEDDB4LQRMhBEH30MIAIQMMHQtBDyEEQYrRwgAhAwwcC0EbIQRBmdHCACEDDBsLQQUhBEG00cIAIQMMGgtBByEEQbnRwgAhAwwZC0EPIQRBwNHCACEDDBgLQQchBEHP0cIAIQMMFwtBCyEEQdbRwgAhAwwWC0EUIQRB4dHCACEDDBULQRghBEH10cIAIQMMFAtBESEEQY3SwgAhAwwTC0EWIQRBntLCACEDDBILQRUhBEG00sIAIQMMEQtBydLCACEDDBALQQohBEHP0sIAIQMMDwtBGSEEQdnSwgAhAwwOC0ECIQRB8tLCACEDDA0LQQchBEH00sIAIQMMDAtBESEEQfvSwgAhAwwLC0EKIQRBjNPCACEDDAoLQQchBEGW08IAIQMMCQtBGSEEQZ3TwgAhAwwIC0EEIQRBttPCACEDDAcLQQMhBEG608IAIQMMBgtBByEEQb3TwgAhAwwFC0EQIQRBxNPCACEDDAQLQRYhBEHU08IAIQMMAwtBFiEEQerTwgAhAwwCC0EPIQRBgNTCACEDDAELQRAhBEGP1MIAIQMLIAJB4ABqIAYQ4yAgAigCYCIGRQRAIAIQ1SkhAwwLCyACQdgAaiANIAMgBCAGIAIoAmQQuigCQCACKAJYQQFxRQ0AIAJB0ABqIAIoAlwQhBkgAigCUCIDRQ0AIAMgAigCVBD6OiEDDAsLIAJByABqIAJB2BdqEO0SIAIoAkwhBiACKAJIIgUNAAsLIABBADoA/QYgAiAAKALUBjYC2BcgByACQdgXahDsOiACKALYFyIDQYQBTwRAIAMQ8h8LIAAtAMgGRQRAIAcQpTsLIAAoAqwGIgNBBEcEQCAHIAMQpDsLIAAoArAGIgNBB0cEQCAHIAMQkj0LIAAoApgGQQFHDQQgAEGcBmoiAxDmKA0EIAJBQGsgAxDKISACKAJEIQMgAigCQEEBcQ0IIAIgAzYC2BcgByACQdgXahDMLSACKALYFyIDQYQBSQ0EIAMQ8h8MBAtBgNjCABDoKwALIABB8AZqIQUgAEH4BmohBwJAIAAtAPgGQQFrDgMCAQUACyAFKAIAIQMMAwsAC0G42cIAEOgrAAsgAkHYF2oQmR8gAigC3BchAyACKALYFw0DIAJB0BpqIAJB6BdqKQIAIhI3AwAgAiACKQLgFyITNwPIGiAAIAM2AtgGIAAgEzcC3AYgAEHkBmogEjcCACAAQdgGaiEDIAAoApAGIgRBgJTr3ANHBEAgAyAAKQOIBiAEEM0RCyACIAMQ0Ts2AtgXIAcgAkHYF2oQzS0gAigC2BciA0GEAU8EQCADEPIfCyACQThqIAAoAtQFIAAoAtgFIAcQgCQgAigCPCEFAkAgAigCOEEBcUUNACACQTBqIAUQhBkgAigCNCEFIAIoAjAiA0UNACADIAUQ+johAwwDCyAAIAU2AuwGIABB7AZqEIwXIQMgAEEAOgD4BiAAIAM2AvAGIABB+AZqIQcgAEHwBmohBQsgACADEPsONgL0BgsgAkEoaiAAQfQGaiIDIAEQxxgCQAJAAkACQAJAAkACQAJAAkAgAigCKCIBQQJHBEAgAigCLCEGIAMoAgAiBCAEKAIAQQFrIgQ2AgAgBEUEQCADELIaCwJAAkACQCABQQFxRQ0AIAJBIGogBhCEGSACKAIkIQYgAigCICIDRQ0AIAYhBAwBCyACIAY2AtgXIAJB2BdqIgEQozsNASABQSNBAEEBQQEQoBggAigC3BchASACKALYF0EBRg0DIAIoAuAXIgRByNnCAEEj/AoAAEEMQQQQrTYiA0UNBCADQSM2AgggAyAENgIEIAMgATYCAEGA1cIAIQQgBkGEAUkNACAGEPIfCyAHQQE6AAAgBRDkKCACIAQ2AsQYIAIgAzYCwBggAkEANgLQGiACQoCAgIAQNwLIGiACQezIwgA2AtwXIAJCoICAgA43AuAXIAIgAkHIGmo2AtgXIAJBwBhqIAJB2BdqEIM2DQQgAkGYGWogAkHQGmooAgAiATYCACACIAIpAsgaNwOQGSACKAKUGSABQZLZwgBBJBDBLiEBIAJBkBlqEN47QQEgAgJ/IAFFBEAgAigCxBghBSACKALAGAwBCyACQcAYahC8KkGgs8MAIQVBAQsgBRDYKSEDIAAoAuwGIgFBhAFJDQsgARDyHwwLCyAHQQE6AAAgBRDkKCACIAY2ArQWIAJB2BdqIgEQ2SkgAkG4FmogASACQbQWaiIDEI89EOASIAJBkBlqIgQgAxDiJiACKAKYGSEFIAIoApQZIQcgAkEANgLQGiACQQA2AsgaIAJBADYC2BogASACQcgaaiAHIAUQvBogAigC2BdBAkYNBCACQYAXaiABQcgA/AoAACAEEN47IAIgAxCQPTYCyBcgASACQcgXahDHEiACLQDcFyIBQQNGDQUgAUECRg0GIAIoAtgXIQMgAiABOgDQFyACIAM2AswXIAJBGGogAkHMF2oQ/CkgAigCGCIFQQJHBEAgAkHUGmohBCACKAIcIQMDQCAFQQFxDQkgAiADNgLUFyACQRBqIAJB1BdqEMgkIAIoAhBBAXENCiACQagbaiIFIAIoAhQQqysgAkGQGWoiASACKAKsGyACKAKwGxCQNSACQdgXaiIDIAEQyBMgAigC2BdBgICAgHhGDQsgAkHYGmogAkHoF2opAgA3AwAgAkHQGmogAkHgF2opAgAiEjcDACACIAIpAtgXIhM3A8gaIAJByBhqIBI+AgAgAiATNwPAGCACQZgZaiAEQQhqKAIANgIAIAIgBCkCADcDkBkgAyACQbgWaiIHQcgA/AoAACAHIAMgAkHAGGoiAyABELANIAEQ3jsgAxDeOyAFEN47IAIoAtQXIgFBhAFPBEAgARDyHwsgAkEIaiACQcwXahD8KSACKAIMIQMgAigCCCIFQQJHDQALCyACKALMFyIBQYQBTwRAIAEQ8h8LIAItAMEWIQUgAi0AwBYhAwJAAkACQCACKQO4FiISQgNRBEAgBkGEAU8EQCAGEPIfCyACQZAZaiACQYAXakHIAPwKAAAgAkHoGWogAEHoBmooAgA2AgAgAkHgGWogAEHgBmopAgA3AgAgAiAAKQLYBjcC2BkgAkGgGWoQ3jsgAkHYGWoQvSgMAQsgAiAFOgDJGCACIAM6AMgYIAIgEjcDwBggAkHKGGogAkHCFmpBPvwKAAAgAiAGNgKIGSACQZAZaiIBIAJBgBdqIgRByAD8CgAAIAJB6BlqIABB6AZqKAIANgIAIAJB4BlqIABB4AZqKQIANwIAIAIgACkC2AY3AtgZIAJByBpqIAFB3AD8CgAAIAJBqBtqIgEgBEHIAPwKAAAgAkHYF2ogAkHAGGogASACQZAbahCTICACKQPYFyISQgNSDQEgAi0A4RchBSACLQDgFyEDC0IDIRJBASACIAMgBRCsHiEDDAELIAIoAuAXIQMgAkHsGWogAkHkF2pB3AD8CgAACyACKALIFyIBQYQBTwRAIAEQ8h8LIAAoAuwGIgFBhAFPBEAgARDyHwsgAEEAOgD9BiAAKALQBiIFQYQBSQ0ODA0LIABBAzoA+AYgAEEDOgD8BgwPCyABIAIoAuAXQfzZwgAQ/S8AC0EEQQwQoz0AC0GUycIAQTcgAkGoG2pBhMnCAEHMycIAENUeAAtBkNjCAEEJEJc9AAtBmdjCAEEQEJc9AAtBqdjCAEEYEJc9AAtBwdjCAEEeEJc9AAtB39jCAEESEJc9AAtB8djCAEEhEJc9AAsgAEHYBmoQvSgLIAAtAP0GRQ0AIAAoAtQGIgFBhAFJDQAgARDyHwsgAEEAOgD9BkIDIRIgACgC0AYiBUGDAUsNACAAQYAFahCpHiAAQQE6APwGDAILIAUQ8h8LIABBgAVqEKkeIABBAToA/AYgEkIEUQ0BCyACQdgVaiACQewZakHcAPwKAAAgCxDNJCAAKAKoAyIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGoA2oQnScLIABBAToAgAcgABCqHiASQgNRDQMgAkHcD2ogAkHYFWpB3AD8CgAAIAIgAzYC2A8gAiASNwPQDyACQagIaiEHQgAhEkIAIRMjAEEwayIGJAAgBkEoakH87cMAKQIANwMAIAZB9O3DACkCADcDICAGQSBqIQRBACEFIAJB0A9qIg4iASgCKCIJBH8gASAEEKEJIQMgAS8BOCILIANB//8DcSIPcSEDIAEoAiQhDSABKAIYIRAgASgCHCERAkACQANAIAMhAUEAIQMgASARTw0AQQAhCiAQIAFBAnRqIgwvAQAiA0H//wNGDQIgBSABIAwvAQIiDCALcWsgC3FLDQICQAJAIAwgD0cNACADIAlPDQEgBCgCAEUgDSADQTRsaiIKKAIgIgxBAEdGDQAgCkEgaiEKIAwEQCAKIAQQjDVFDQEMBAsgCi0ABCAELQAERg0DCyABQQFqIQMgBUEBaiEFDAELCyADIAlBwOHDABDDIQALIA0gA0E0bGpBDGohCgsgCgVBAAshASAEKAIAIgMEQCAEQQxqIAQoAgQgBCgCCCADKAIQEQEACwJAIAFFDQAgBkEYaiABEOMgIAYoAhgiA0UNAAJAAkACQAJAAkAgBigCHCIEDgIFAAELQQEhASADLQAAQStrDgMEAQQBCyADLQAAQStGBEAgBEEBayEBIANBAWohAyAEQRJJDQEMAgsgBCIBQRFPDQELA0AgAy0AAEEwayIEQQlLDQMgA0EBaiEDIAStIBJCCn58IRIgAUEBayIBDQALDAELA0AgAUUNASAGIBJCAEIKQgAQqB4gAy0AAEEwayIEQQlLDQIgBikDCEIAUg0CIANBAWohAyABQQFrIQEgBikDACIUIAStfCISIBRaDQALDAELIAcgEjcDCEIBIRMLIAcgEzcDACAGQTBqJAAgAigCqAhFDQEgAikDsAgiEkKAgICAEFoNAiAOEMspIAIoApAQIgEEQCABEOkmIAFBEEEEEPg6CyACKAKYECIBQYQBTwRAIAEQ8h8LIBKnIQMgAkGkEGoQvSggAigCoBAiAUEQahDeOyABQcgAQQQQ+DogACgCiAciASABKAIAIgFBAWs2AgAgAUEBRgRAIABBiAdqEJ0nC0EAIQUMBAsgCUEDOgAAIAhBAzoAAEECIQUMBAtBnNrCABCyOwALQcTKwgBBKyACQagbakGgy8IAQazawgAQ1R4ACyAAKAKIByIBIAEoAgAiAUEBazYCAEEBIQUgAUEBRw0AIABBiAdqEJ0nCyAIQQE6AAALAkAgBUECRgRAQQMhBAwBCyAAEOYnQQEhBCAFQQFxRQRAIAAoAqAHIQcjAEEQayIBJAAgASAHNgIMQQEhCAJAAkACQCAHQQhqIgYtACQNACAGLQAIIAZBAToACA0AIAYoAgANAUEAIQggBkEAOgAIIAYgAzYCBCAGQQE2AgAgBi0AJEUNACAGLQAIIAZBAToACA0AIAZBADoACCAGKAIAIQggBkEANgIAIAYoAgQgAyAIGyEDCyABIAM2AgQgASAINgIADAELQYiBwwBBIEGogcMAEJ8pAAsgASgCBCEDIAEoAgAhCCAGEJQfIAcgBygCACIGQQFrNgIAIAZBAUYEQCABQQxqENkjCyACIAg2AgAgAiADNgIEIAFBEGokACACKAIAQQFxRQ0BIAIgAigCBDYCqAhBxMrCAEErIAJBqAhqQfDKwgBB/NrCABDVHgALIAIgAzYCqAhBxMrCAEErIAJBqAhqQZDLwgBB7NrCABDVHgALIAAgBDoAsAcgAkHwG2okACAFQQJGC4egAgISfwl+IwBB8AZrIggkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANBEGoiCSgCECABIAIoAiQiBREEAE0EQCADKAIAIgdBBGsOAgIDAQsgCCAJKAIQNgIgIAggASAFEQQANgIkIAhBAjYCpAUgCEGsrIMBNgKgBSAIQgI3AqwFIAhBOzYC1AIgCEE7NgLMAiAIIAhByAJqNgKoBSAIIAhBJGo2AtACIAggCEEgajYCyAIgCEGEAmogCEGgBWoQmQ4gAEGNgICAeDYCACAAIAgpAoQCNwIEIABBDGogCEGMAmooAgA2AgAMPQsgASACKAIcIgYRBAAiBS0AAEECaw4lAwQFBgcICQoLDA0CAgICAg4PAgICAgICAgICAgICAgICEBESEwILIAhBEGogAUEAIAMoAjwgAigCIBEFACAAIAgpAxA3AgQgAEGTgICAeDYCAAw7CyAIQRhqIAEgAigCHBEEABCUKSAAIAgpAxg3AgQgAEGTgICAeDYCAAw6CyABIAYRBAAiBS0AAEEBaw4oGCYmJiYmJiYmJiYmGRobHB0mJh4fICEiIyQmJiYmJi8lMSYmJiYmMiYLIAhBoAVqIgUgASACELsiIAMQ9BMgBRDcKSEBIABBrISDATYCCCAAIAE2AgQgAEGTgICAeDYCAAw4CyAIQaAFaiIFIAEgAhCoIiADEOETIAUQ3CkhASAAQYSFgwE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgCEGgBWoiBSABIAIQsSIgAxDiEyAFENwpIQEgAEHchYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADDYLIAhBoAVqIgUgASACEKQiIAMQ4xMgBRDcKSEBIABBtIaDATYCCCAAIAE2AgQgAEGTgICAeDYCAAw1CyAIQaAFaiIFIAEgAhCqIiADEPUTIAUQ3CkhASAAQYyHgwE2AgggACABNgIEIABBk4CAgHg2AgAMNAsgCEGgBWoiBSABIAIQrSIgAxDkEyAFENwpIQEgAEHkh4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADDMLIAhBoAVqIgUgASACELciIAMQ5RMgBRDcKSEBIABBvIiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwyCyAIQaAFaiIFIAEgAhCiIiADEOYTIAUQ3CkhASAAQZSJgwE2AgggACABNgIEIABBk4CAgHg2AgAMMQsgASACELkiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAXYgAxCJBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEKsTIAFBoAJqJAAgAxDcKSEBIABB7ImDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwwCyABIAIQtSIhCyMAQaACayIHJAAgB0EIaiEKIAsoAhAhDiALKAIUQQJ2IQkjAEHAAWsiBCQAAkACQAJAAkACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDPz8ACyAEQfgAaiICIAMoAjxBAEEEQQQQoBggBCgCfCEGIAQoAnhBAUYNQCAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNSCABIAlLDUkgBEEkaiABIAJrIgEQ7i0gAUECdCIFBEAgBCgCKCAEKAIsQQJ0aiAOIAJBAnRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC4GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhAiAEIAQoArABIgxBAnQiATYCJCABIQYgAUE8cSIFBEAgASAFa0FAayIGIAFJDUELQcAAIQUgBkHAABDRNEUNQSAGBEAgBkHAABCtNiIFRQ0FCyAEQfgAaiINIARBMGpBOPwKAAAgBCAJNgK8ASAEIA42ArgBIAQgAjYCtAEgBCAMNgKwASAEQRhqIA0Q1hAgBSECIAQoAhhBAXEEQCAEKAIcIQEDQCABIAQoArwBIglPDQcgAiAEKAK4ASABQQJ0aioCADgAACACQQRqIQIgBEEQaiAEQfgAahDWECAEKAIUIQEgBCgCEEEBcQ0ACyAEKAIkIQELIAQgAiAFayICNgJsIAEgAkcNQiAEIAY2AogBIARCgICAgIAINwKAASAEIAE2AnwgBCAFNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCEFQRxBBBCtNiICRQ1DIAJCgYCAgBA3AgAgAiAEKQJ4NwIIIAogATYCCCAKIAU2AgQgCiACNgIAIAJBEGogBEGAAWopAgA3AgAgAkEYaiAEQYgBaigCADYCAAwCCyADKAIIIQEgAygCDCECIAQgCTYChAEgBCAONgKAASAEIAEgAkECdGo2AnwgBCABNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBBBCgGCABKAIYIQYgASgCFEEBRg07IAFBEGoiD0EANgIAIAEgASgCHDYCDCABIAY2AggjAEEQayIFJAAgAUEIaiIGIAIoAgQgAigCAGtBAnYQ7i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCAFQQRqIg4oAgQhBiAOKAIAIRACQCACKAIAIgkgAigCBCINRwRAIAIoAgwhDCACKAIIIREgDigCCCAGQQJ0aiECIA0gCWtBAnYhDgNAIAkoAgAiDSAMTw1RIAIgESANQQJ0aioCADgCACAJQQRqIQkgAkEEaiECIAZBAWohBiAOQQFrIg4NAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELgYDAELIARB+ABqIAMoAjxBAEEEQQQQoBggBCgCfCEBIAQoAnhBAUYNQiAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCIBBEAgAygCCCICIAFBA3RqIQYDQCACQQRqKAIAIgEgAigCACIFSQ0GIAEgCUsNByAEQewAaiABIAVrIgEQ7i0gAUECdCIMBEAgBCgCcCAEKAJ0QQJ0aiAOIAVBAnRqIAz8CgAACyAEIAQoAnQgAWo2AnQgAkEIaiICIAZHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC4GAsgBEHAAWokAAwFCww6C0HAACAGEKM9AAsgASAJQeyvgwEQwyEACyAFIAFBvK+DARCxOwALIAEgCUG8r4MBELA7AAsgB0GgAWogCxDMBiAHQQA7AdgBIAdBADYC1AEgB0EANgK8ASAHQQA2ArABIAdCBDcCmAEgB0IANwKQASAHQoCAgIDAADcCiAEgB0EANgKAASAHIAMoAjw2AqwBIAdBFGoiASAHQYABaiICIAoQ+iMgB0HwAGogCxCSNiADEOYYIAcoAnQEQCAHKAJwIQMgB0GIAWogB0EcakHUAPwKAAAgByADNgKEASAHQQE2AoABIAEgAiAHQfQAahCuFgsgB0HcAWoiASAHQRRqEM0cIAhBoAVqIgIgARCzEyAHQaACaiQAIAIQ3CkhASAAQcSKgwE2AgggACABNgIEIABBk4CAgHg2AgAMLwsgASACEKYiIQ4jAEGgAmsiByQAIAdBCGohCiAOKAIQIQsgDigCFEEDdiEJIwBBwAFrIgQkAAJAIAkgA0EQaiIBKAIQTwRAAkACQAJAAkACQCADKAIAQQFrDgUBAgM6OgALIARB+ABqIgIgAygCPEEAQQhBCBCgGCAEKAJ8IQYgBCgCeEEBRg07IARBADYCLCAEIAQoAoABNgIoIAQgBjYCJCACIAEQyTQgBEHsAGogAhDVCSAEKAJsQQFGBEADQCAEKAJ0IgEgBCgCcCICSQ1DIAEgCUsNRCAEQSRqIAEgAmsiARDsLSABQQN0IgUEQCAEKAIoIAQoAixBA3RqIAsgAkEDdGogBfwKAAALIAQgBCgCLCABajYCLCAEQewAaiAEQfgAahDVCSAEKAJsDQALCyAEQYABaiAEQSxqKAIANgIAIAQgBCkCJDcDeCAKIARB+ABqELMYDAMLIARB+ABqIgIgASADKAI8ELEmIARBMGogAkE4/AoAACAEKAK0ASEBIAQgBCgCsAEiDEEDdCIGNgIkIAYiAkE4cSIFBEAgAiACIAVrQUBrIgJLDTwLQcAAIQUgAkHAABDRNEUNPCACBEAgAkHAABCtNiIFRQ1DCyAEQfgAaiINIARBMGpBOPwKAAAgBCAJNgK8ASAEIAs2ArgBIAQgATYCtAEgBCAMNgKwASAEQRhqIA0Q1hAgBSEBIAQoAhhBAXEEQCAEKAIcIQkDQCAJIAQoArwBIgtPDUUgASAEKAK4ASAJQQN0aisDADkAACABQQhqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw09IAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDT4gAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBCEEIEKAYIAEoAhghBiABKAIUQQFGDTYgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDsLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAIAIoAgAiCSACKAIEIg1HBEAgAigCDCEMIAIoAgghESALKAIIIAZBA3RqIQIgDSAJa0ECdiELA0AgCSgCACINIAxPDUwgAiARIA1BA3RqKwMAOQMAIAlBBGohCSACQQhqIQIgBkEBaiEGIAtBAWsiCw0ACwsgECAGNgIADAALIAVBEGokACAEQewAaiICQQhqIA8oAgA2AgAgAiABKQIINwIAIAFBIGokACAKIAIQsxgMAQsgBEH4AGogAygCPEEAQQhBCBCgGCAEKAJ8IQEgBCgCeEEBRg09IARBADYCdCAEIAQoAoABNgJwIAQgATYCbCADKAIMIgIEQCADKAIIIgEgAkEDdGohBQNAIAFBBGooAgAiAiABKAIAIgZJDUQgAiAJSw1FIARB7ABqIAIgBmsiAhDsLSACQQN0IgwEQCAEKAJwIAQoAnRBA3RqIAsgBkEDdGogDPwKAAALIAQgBCgCdCACajYCdCABQQhqIgEgBUcNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAKIARB+ABqELMYCyAEQcABaiQADAELDDULIAdBoAFqIA4QzAYgB0EAOwHYASAHQQA2AtQBIAdBADYCvAEgB0EANgKwASAHQgQ3ApgBIAdCADcCkAEgB0KAgICAwAA3AogBIAdBADYCgAEgByADKAI8NgKsASAHQRRqIgEgB0GAAWoiAiAKEPojIAdB8ABqIA4QkjYgAxDmGCAHKAJ0BEAgBygCcCEDIAdBiAFqIAdBHGpB1AD8CgAAIAcgAzYChAEgB0EBNgKAASABIAIgB0H0AGoQrhYLIAdB3AFqIgEgB0EUahDNHCAIQaAFaiICIAEQxxMgB0GgAmokACACENwpIQEgAEGci4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADC4LIAUtAAFBAWsOAwYHCAULIAUtAAFBAWsOAgkKCAsgASACEKciIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMMTIAFBoAJqJAAgAxDcKSEBIABB3JCDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwrCyABIAIQqyIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQtxMgAUGgAmokACADENwpIQEgAEG0kYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCoLIAEgAhC8IiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBBHYhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDNTUACyAEQfgAaiICIAMoAjxBAEEQQRAQoBggBCgCfCEGIAQoAnhBAUYNNiAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNPiABIAlLDT8gBEEkaiABIAJrIgEQ6y0gAUEEdCIFBEAgBCgCKCAEKAIsQQR0aiALIAJBBHRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC1GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBBHQiBjYCJCAGIgJBMHEiBQRAIAIgAiAFa0FAayICSw03C0HAACEFIAJBwAAQ0TRFDTcgAgRAIAJBwAAQrTYiBUUNPgsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw1AIAQoArgBIAlBBHRqIgkpAwAhFiABIAkpAwg3AAggASAWNwAAIAFBEGohASAEQRBqIARB+ABqENYQIAQoAhQhCSAEKAIQQQFxDQALCyAEIAEgBWsiATYCbCABIAZHDTggBCACNgKIASAEQoCAgICACDcCgAEgBCAGNgJ8IAQgBTYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNOSABQoGAgIAQNwIAIAEgBCkCeDcCCCAKIAY2AgggCiACNgIEIAogATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEBIAMoAgwhAiAEIAk2AoQBIAQgCzYCgAEgBCABIAJBAnRqNgJ8IAQgATYCeCMAQSBrIgEkACABQRRqIARB+ABqIgIoAgQgAigCAGtBAnZBAEEQQRAQoBggASgCGCEGIAEoAhRBAUYNMSABQRBqIglBADYCACABIAEoAhw2AgwgASAGNgIIIwBBEGsiBSQAIAFBCGoiBiACKAIEIAIoAgBrQQJ2EOstIAUgBikCBEIgiTcCCCAFIAZBCGo2AgQgAiAFQQRqEJEZIAVBEGokACAEQewAaiICQQhqIAkoAgA2AgAgAiABKQIINwIAIAFBIGokACAKIAIQtRgMAQsgBEH4AGogAygCPEEAQRBBEBCgGCAEKAJ8IQEgBCgCeEEBRg04IARBADYCdCAEIAQoAoABNgJwIAQgATYCbCADKAIMIgIEQCADKAIIIgEgAkEDdGohBQNAIAFBBGooAgAiAiABKAIAIgZJDT8gAiAJSw1AIARB7ABqIAIgBmsiAhDrLSACQQR0IgwEQCAEKAJwIAQoAnRBBHRqIAsgBkEEdGogDPwKAAALIAQgBCgCdCACajYCdCABQQhqIgEgBUcNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAKIARB+ABqELUYCyAEQcABaiQADAELDDALIAdBoAFqIA4QzAYgB0EAOwHYASAHQQA2AtQBIAdBADYCvAEgB0EANgKwASAHQgQ3ApgBIAdCADcCkAEgB0KAgICAwAA3AogBIAdBADYCgAEgByADKAI8NgKsASAHQRRqIgEgB0GAAWoiAiAKEPojIAdB8ABqIA4QkjYgAxDmGCAHKAJ0BEAgBygCcCEDIAdBiAFqIAdBHGpB1AD8CgAAIAcgAzYChAEgB0EBNgKAASABIAIgB0H0AGoQrhYLIAdB3AFqIgEgB0EUahDNHCAIQaAFaiICIAEQsBMgB0GgAmokACACENwpIQEgAEGMkoMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCkLIAEgAhCpIiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBBXYhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDNDQACyAEQfgAaiICIAMoAjxBAEEQQSAQoBggBCgCfCEGIAQoAnhBAUYNNSAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNPSABIAlLDT4gBEEkaiABIAJrIgEQ7y0gAUEFdCIFBEAgBCgCKCAEKAIsQQV0aiALIAJBBXRqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC5GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBBXQiBjYCJCAGIgJBIHEiBQRAIAIgAiAFa0FAayICSw02C0HAACEFIAJBwAAQ0TRFDTYgAgRAIAJBwAAQrTYiBUUNPQsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw0/IAQoArgBIAlBBXRqIgkpAwghFiAJKQMAIRcgCSkDGCEYIAFBEGogCSkDEDcAACABQRhqIBg3AAAgASAXNwAAIAEgFjcACCABQSBqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw03IAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDTggAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBEEEgEKAYIAEoAhghBiABKAIUQQFGDTAgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDvLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAAkAgAigCACIJIAIoAgQiDUcEQCACKAIMIQwgAigCCCERIAsoAgggBkEFdGohAiANIAlrQQJ2IQ0DQCAJKAIAIgsgDE8NAiARIAtBBXRqIgspAwAhFiACQRBqIAspAxA3AwAgCykDCCEXIAJBGGogCykDGDcDACACIBY3AwAgAiAXNwMIIAlBBGohCSACQSBqIQIgBkEBaiEGIA1BAWsiDQ0ACwsgECAGNgIADAELIAsgDEG8tIIBEMMhAAsgBUEQaiQAIARB7ABqIgJBCGogDygCADYCACACIAEpAgg3AgAgAUEgaiQAIAogAhC5GAwBCyAEQfgAaiADKAI8QQBBEEEgEKAYIAQoAnwhASAEKAJ4QQFGDTcgBEEANgJ0IAQgBCgCgAE2AnAgBCABNgJsIAMoAgwiAgRAIAMoAggiASACQQN0aiEFA0AgAUEEaigCACICIAEoAgAiBkkNPiACIAlLDT8gBEHsAGogAiAGayICEO8tIAJBBXQiDARAIAQoAnAgBCgCdEEFdGogCyAGQQV0aiAM/AoAAAsgBCAEKAJ0IAJqNgJ0IAFBCGoiASAFRw0ACwsgBEGAAWogBEH0AGooAgA2AgAgBCAEKQJsNwN4IAogBEH4AGoQuRgLIARBwAFqJAAMAQsMLwsgB0GgAWogDhDMBiAHQQA7AdgBIAdBADYC1AEgB0EANgK8ASAHQQA2ArABIAdCBDcCmAEgB0IANwKQASAHQoCAgIDAADcCiAEgB0EANgKAASAHIAMoAjw2AqwBIAdBFGoiASAHQYABaiICIAoQ+iMgB0HwAGogDhCSNiADEOYYIAcoAnQEQCAHKAJwIQMgB0GIAWogB0EcakHUAPwKAAAgByADNgKEASAHQQE2AoABIAEgAiAHQfQAahCuFgsgB0HcAWoiASAHQRRqEM0cIAhBoAVqIgIgARDFEyAHQaACaiQAIAIQ3CkhASAAQeSSgwE2AgggACABNgIEIABBk4CAgHg2AgAMKAsgASACELMiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACELwTIAFBoAJqJAAgAxDcKSEBIABB9IuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwnCyABIAIQoSIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQtRMgAUGgAmokACADENwpIQEgAEHMjIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCYLIAEgAhCdIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC6EyABQaACaiQAIAMQ3CkhASAAQaSNgwE2AgggACABNgIEIABBk4CAgHg2AgAMJQsgASACEK4iIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMETIAFBoAJqJAAgAxDcKSEBIABB/I2DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwkCyABIAIQuCIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEECdiADEIoFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQrxMgAUGgAmokACADENwpIQEgAEHUjoMBNgIIIAAgATYCBCAAQZOAgIB4NgIADCMLIAEgAhCjIiEOIwBBoAJrIgckACAHQQhqIQogDigCECELIA4oAhRBA3YhCSMAQcABayIEJAACQCAJIANBEGoiASgCEE8EQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDLi4ACyAEQfgAaiICIAMoAjxBAEEEQQgQoBggBCgCfCEGIAQoAnhBAUYNLyAEQQA2AiwgBCAEKAKAATYCKCAEIAY2AiQgAiABEMk0IARB7ABqIAIQ1QkgBCgCbEEBRgRAA0AgBCgCdCIBIAQoAnAiAkkNNyABIAlLDTggBEEkaiABIAJrIgEQ6i0gAUEDdCIFBEAgBCgCKCAEKAIsQQN0aiALIAJBA3RqIAX8CgAACyAEIAQoAiwgAWo2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggCiAEQfgAahC0GAwDCyAEQfgAaiICIAEgAygCPBCxJiAEQTBqIAJBOPwKAAAgBCgCtAEhASAEIAQoArABIgxBA3QiBjYCJCAGIgJBOHEiBQRAIAIgAiAFa0FAayICSw0wC0HAACEFIAJBwAAQ0TRFDTAgAgRAIAJBwAAQrTYiBUUNNwsgBEH4AGoiDSAEQTBqQTj8CgAAIAQgCTYCvAEgBCALNgK4ASAEIAE2ArQBIAQgDDYCsAEgBEEYaiANENYQIAUhASAEKAIYQQFxBEAgBCgCHCEJA0AgCSAEKAK8ASILTw05IAEgBCgCuAEgCUEDdGopAgA3AAAgAUEIaiEBIARBEGogBEH4AGoQ1hAgBCgCFCEJIAQoAhBBAXENAAsLIAQgASAFayIBNgJsIAEgBkcNMSAEIAI2AogBIARCgICAgIAINwKAASAEIAY2AnwgBCAFNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0yIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAogBjYCCCAKIAI2AgQgCiABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQEgAygCDCECIAQgCTYChAEgBCALNgKAASAEIAEgAkECdGo2AnwgBCABNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBCBCgGCABKAIYIQYgASgCFEEBRg0qIAFBEGoiD0EANgIAIAEgASgCHDYCDCABIAY2AggjAEEQayIFJAAgAUEIaiIGIAIoAgQgAigCAGtBAnYQ6i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCAFQQRqIgsoAgQhBiALKAIAIRACQCACKAIAIgkgAigCBCINRwRAIAIoAgwhDCACKAIIIREgCygCCCAGQQN0aiECIA0gCWtBAnYhCwNAIAkoAgAiDSAMTw1AIAIgESANQQN0aikCADcCACAJQQRqIQkgAkEIaiECIAZBAWohBiALQQFrIgsNAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELQYDAELIARB+ABqIAMoAjxBAEEEQQgQoBggBCgCfCEBIAQoAnhBAUYNMSAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCICBEAgAygCCCIBIAJBA3RqIQUDQCABQQRqKAIAIgIgASgCACIGSQ04IAIgCUsNOSAEQewAaiACIAZrIgIQ6i0gAkEDdCIMBEAgBCgCcCAEKAJ0QQN0aiALIAZBA3RqIAz8CgAACyAEIAQoAnQgAmo2AnQgAUEIaiIBIAVHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC0GAsgBEHAAWokAAwBCwwpCyAHQaABaiAOEMwGIAdBADsB2AEgB0EANgLUASAHQQA2ArwBIAdBADYCsAEgB0IENwKYASAHQgA3ApABIAdCgICAgMAANwKIASAHQQA2AoABIAcgAygCPDYCrAEgB0EUaiIBIAdBgAFqIgIgChD6IyAHQfAAaiAOEJI2IAMQ5hggBygCdARAIAcoAnAhAyAHQYgBaiAHQRxqQdQA/AoAACAHIAM2AoQBIAdBATYCgAEgASACIAdB9ABqEK4WCyAHQdwBaiIBIAdBFGoQzRwgCEGgBWoiAiABEKwTIAdBoAJqJAAgAhDcKSEBIABBrI+DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiCyABIAIQoCIhDiMAQaACayIHJAAgB0EIaiEKIA4oAhAhCyAOKAIUQQR2IQkjAEHAAWsiBCQAAkAgCSADQRBqIgEoAhBPBEACQAJAAkACQAJAIAMoAgBBAWsOBQECAy0tAAsgBEH4AGoiAiADKAI8QQBBCEEQEKAYIAQoAnwhBiAEKAJ4QQFGDS4gBEEANgIsIAQgBCgCgAE2AiggBCAGNgIkIAIgARDJNCAEQewAaiACENUJIAQoAmxBAUYEQANAIAQoAnQiASAEKAJwIgJJDTYgASAJSw03IARBJGogASACayIBEOktIAFBBHQiBQRAIAQoAiggBCgCLEEEdGogCyACQQR0aiAF/AoAAAsgBCAEKAIsIAFqNgIsIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAogBEH4AGoQtxgMAwsgBEH4AGoiAiABIAMoAjwQsSYgBEEwaiACQTj8CgAAIAQoArQBIQEgBCAEKAKwASIMQQR0IgY2AiQgBiICQTBxIgUEQCACIAIgBWtBQGsiAksNLwtBwAAhBSACQcAAENE0RQ0vIAIEQCACQcAAEK02IgVFDTYLIARB+ABqIg0gBEEwakE4/AoAACAEIAk2ArwBIAQgCzYCuAEgBCABNgK0ASAEIAw2ArABIARBGGogDRDWECAFIQEgBCgCGEEBcQRAIAQoAhwhCQNAIAkgBCgCvAEiC08NOCAEKAK4ASAJQQR0aiIJKQAAIRYgAUEIaiAJQQhqKQAANwAAIAEgFjcAACABQRBqIQEgBEEQaiAEQfgAahDWECAEKAIUIQkgBCgCEEEBcQ0ACwsgBCABIAVrIgE2AmwgASAGRw0wIAQgAjYCiAEgBEKAgICAgAg3AoABIAQgBjYCfCAEIAU2AnggBEEIaiAEQfgAahDXOyAEKAIIIQJBHEEEEK02IgFFDTEgAUKBgICAEDcCACABIAQpAng3AgggCiAGNgIIIAogAjYCBCAKIAE2AgAgAUEQaiAEQYABaikCADcCACABQRhqIARBiAFqKAIANgIADAILIAMoAgghASADKAIMIQIgBCAJNgKEASAEIAs2AoABIAQgASACQQJ0ajYCfCAEIAE2AngjAEEgayIBJAAgAUEUaiAEQfgAaiICKAIEIAIoAgBrQQJ2QQBBCEEQEKAYIAEoAhghBiABKAIUQQFGDSkgAUEQaiIPQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgUkACABQQhqIgYgAigCBCACKAIAa0ECdhDpLSAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAVBBGoiCygCBCEGIAsoAgAhEAJAIAIoAgAiCSACKAIEIg1HBEAgAigCDCEMIAIoAgghESALKAIIIAZBBHRqIQIgDSAJa0ECdiELA0AgCSgCACINIAxPDT8gESANQQR0aiINKQMAIRYgAkEIaiANQQhqKQMANwMAIAIgFjcDACAJQQRqIQkgAkEQaiECIAZBAWohBiALQQFrIgsNAAsLIBAgBjYCAAwACyAFQRBqJAAgBEHsAGoiAkEIaiAPKAIANgIAIAIgASkCCDcCACABQSBqJAAgCiACELcYDAELIARB+ABqIAMoAjxBAEEIQRAQoBggBCgCfCEBIAQoAnhBAUYNMCAEQQA2AnQgBCAEKAKAATYCcCAEIAE2AmwgAygCDCICBEAgAygCCCIBIAJBA3RqIQUDQCABQQRqKAIAIgIgASgCACIGSQ03IAIgCUsNOCAEQewAaiACIAZrIgIQ6S0gAkEEdCIMBEAgBCgCcCAEKAJ0QQR0aiALIAZBBHRqIAz8CgAACyAEIAQoAnQgAmo2AnQgAUEIaiIBIAVHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggCiAEQfgAahC3GAsgBEHAAWokAAwBCwwoCyAHQaABaiAOEMwGIAdBADsB2AEgB0EANgLUASAHQQA2ArwBIAdBADYCsAEgB0IENwKYASAHQgA3ApABIAdCgICAgMAANwKIASAHQQA2AoABIAcgAygCPDYCrAEgB0EUaiIBIAdBgAFqIgIgChD6IyAHQfAAaiAOEJI2IAMQ5hggBygCdARAIAcoAnAhAyAHQYgBaiAHQRxqQdQA/AoAACAHIAM2AoQBIAdBATYCgAEgASACIAdB9ABqEK4WCyAHQdwBaiIBIAdBFGoQzRwgCEGgBWoiAiABEL4TIAdBoAJqJAAgAhDcKSEBIABBhJCDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAIQQhqIAEgAigCEBEAACAIQaAFaiIFIAgoAggiAiAIKAIMKAIMEQAAIAJFDRwgCCkDoAVCiqLN5aLCqolqhSAIKQOoBUKLsvnezZq73jmFhFBFDRwjAEGgAmsiASQAIAFBCGoiBiACIAMQlQIgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQQE6AKABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBCABQYABaiIJIAYQ+iMgAUHwAGogAhCbNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAQgCSABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAUgAhDRECABQaACaiQAIAUQ9ikhASAAQcyTgwE2AgggACABNgIEIABBk4CAgHg2AgAMIAsgBS0AAUEBaw4DDg8QDQsgASACEKUiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMQTIAFBoAJqJAAgAxDcKSEBIABBhJeDATYCCCAAIAE2AgQgAEGTgICAeDYCAAweCyABIAIQsCIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQwBMgAUGgAmokACADENwpIQEgAEHcl4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADB0LIAUtAAEOAg4PCQsgBS0AAUECaw4CDxAICyAIQaAFaiEGIAEgAhCXIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEEQQQQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgk2ApwBIAQgAjYCmAEgAgR/IAkFIARBmAFqQYywgwEQnSggBCgCnAELQQA2AgAgBEGgAWoiAkEBNgIAIAUoAhAhCSAFKAIUIQcgBEEIaiAFQRhqENw7IARBGGogAigCADYCACAEIAdBAnYiCjYCLCAEIAk2AiggBEEANgI4IARBADYCJCAEQoCAgIAQNwIcIAQgBCkCmAE3AxAgBCAEKQMINwMwIARBOGohBwJAAkACQAJAAkAgAygCAEEBaw4FAAECIiIDCyAEQYACaiICIANBEGoiCSABELEmIAQgBzYCyAIgBCAEKQMoNwPAAiAEQRBqIgcgAhCZEyACIAkgARCxJiAHIAIQ3RIMAwsgAygCDCELIAMoAgghAiAEIAc2ApACIAQgCjYCjAIgBCAJNgKIAiAEIAI2AoACIAQgAiALQQJ0aiIJNgKEAiAEQRBqIgcgBEGAAmoQtyAgByACIAkQihYMAgsgBEEQaiIJIAMoAggiAiACIAMoAgxBA3RqIgcgARDNEyAJIAIgBxD6FQwBCyAEQYACaiICIANBEGoiCRDJNCAEQRBqIgcgAiABELQRIAIgCRDJNCAHIAIQ9hMLIARBqAJqQZSo0KABNgIAIARClKjQoMGChYoUNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIARBGGooAgA2AgAgBCAEKQMQNwOYASAEQfQBaiIBIARBmAFqIgIQ8RggAiAEQYACaiIJIAEQ+iMgBEGIAmoiByAEQRxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAkQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogCSAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAYgARCNDCAEQaADaiQADAELDB0LIAYQ7CkhASAAQZSbgwE2AgggACABNgIEIABBk4CAgHg2AgAMGgsjAEEgayIFJAAgBUEIaiABIAIoAhARAAAgBUEQaiAFKAIIIgEgBSgCDCgCDBEAACAFKQMYIRYgBSkDECEXIAVBIGokACABQQAgF0LA47Xe0v6llSyFIBZC9c6oqNH+2sykf4WEUBsiCkUEQEG48oMBQRdB0PKDARDLJAALIAhBoAVqIQ4jAEGgA2siASQAIAFBCGogCkEMahDcOyABIAooAjQiAjYCECABKAIMIQYgASgCCCEHIAEgAUEQajYCFAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQCADKAIAQQFrDgUBAgMEBAALIAMoAjwiCSACbCIFQT9xIgIEQCAFIAUgAmtBQGsiBUsNMAtBwAAhAiAFQcAAENE0RQ0LIAUEQCAFQcAAEK02IgJFDQ0LIAFBADYCmAMgASACNgKUAyABIAU2ApADIAFBwAA2AowDIAFB6AFqIgsgA0EQahDJNCABQdwBaiALENUJQcAAIAEoAtwBQQFHDQoaA0AgASgCFCgCACIFIAEoAuQBbCICIAUgASgC4AFsIgVJDQUgAiAGSw0GIAEoApgDIgQgAiAFayICaiILIAEoApADIgxLBEAgAUGMA2ogDEEBdCIEIAsQ1CoiCyAEIAtLGxDoGSABKAKYAyEECyACBEAgASgClAMgBGogBSAHaiAC/AoAAAsgASABKAKYAyACajYCmAMgAUHcAWogAUHoAWoQ1QkgASgC3AENAAsgASgCmAMhBCABKAKUAyECIAEoApADIQUgASgCjAMMCgsgAUEYaiADQRBqIAMoAjwiCRCxJiABIAY2AlwgASAHNgJYIAEoAhAgASABQRRqNgJgIAlsIgVBP3EiAgRAIAUgBSACa0FAayIFSw0vC0HAACECIAVBwAAQ0TRFDQogBQRAIAVBwAAQrTYiAkUNDAsgAUEANgL0ASABIAI2AvABIAEgBTYC7AEgAUHAADYC6AEgAUHoAWohBSMAQdAAayICJAAgAkEQaiIEIAFBGGoiBkHAAPwKAAAgBigCSCEMIAYoAkQhCyAGKAJAIQ0gAkEIaiAEENYQAkACQAJAIAIoAghBAXEEQCACKAIMIQYDQCAMKAIAKAIAIgQgBkEBamwiByAEIAZsIgZJDQIgByALSw0DIAUoAgwiByAEaiIPIAUoAgQiEEsEQCAFIBBBAXQiByAPENMqIg8gByAPSxsQ6BkgBSgCDCEHCyAEBEAgBSgCCCAHaiAGIA1qIAT8CgAACyAFIAUoAgwgBGo2AgwgAiACQRBqENYQIAIoAgQhBiACKAIAQQFxDQALCyACQdAAaiQADAILIAYgB0HMtIIBELE7AAsgByALQcy0ggEQsDsACwwHCyABIAY2AnggASAHNgJ0IAEgAygCCCIFNgJsIAEgBSADKAIMQQJ0ajYCcCABIAFBFGo2AnwgAygCPCIJIAJsIgVBP3EiAgRAIAUgBSACa0FAayIFSw0uC0HAACECIAVBwAAQ0TRFDQkgBQRAIAVBwAAQrTYiAkUNCwsgAUEANgL0ASABIAI2AvABIAEgBTYC7AEgAUHAADYC6AEgAUHoAWohAgJAAkACQCABQewAaiIFKAIAIgQgBSgCBCIGRwRAIAUoAhAhDSAFKAIMIQcgBSgCCCEPIAYgBGtBAnYhCwNAIA0oAgAoAgAiBSAEKAIAIgxBAWpsIgYgBSAMbCIMSQ0CIAYgB0sNAyACKAIMIgYgBWoiECACKAIEIhFLBEAgAiARQQF0IgYgEBDTKiIQIAYgEEsbEOgZIAIoAgwhBgsgBQRAIAIoAgggBmogDCAPaiAF/AoAAAsgAiACKAIMIAVqNgIMIARBBGohBCALQQFrIgsNAAsLDAILIAwgBkHctIIBELE7AAsgBiAHQdy0ggEQsDsACwwGCyADKAI8IgkgAmwiBUE/cSICBEAgBSAFIAJrQUBrIgVLDS0LQcAAIQIgBUHAABDRNEUNCCAFBEAgBUHAABCtNiICRQ0KCyABQQA2AvQBIAEgAjYC8AEgASAFNgLsASABQcAANgLoAUHAACADKAIMIgtFDQcaIAMoAggiBSALQQN0aiEMA0AgASgCFCgCACILIAVBBGooAgBsIgIgCyAFKAIAbCILSQ0EIAIgBksNBSACIAtrIgIgBGoiDSABKALsASIPSwRAIAFB6AFqIA9BAXQiBCANENQqIg0gBCANSxsQ6BkgASgC9AEhBAsgAgRAIAEoAvABIARqIAcgC2ogAvwKAAALIAEgASgC9AEgAmoiBDYC9AEgBUEIaiIFIAxHDQALDAYLQfytgwFBKEGwsoMBEJ8pAAsgBSACQZCygwEQsTsACyACIAZBkLKDARCwOwALIAsgAkGgsoMBELE7AAsgAiAGQaCygwEQsDsACyABKAL0ASEECyABKALwASECIAEoAuwBIQUgASgC6AELIQYgAUGIAmogChDMBiABQQA7AcACIAFBADYCvAIgAUEANgKkAiABQQA2ApgCIAEgCTYClAIgAUIENwKAAiABQgA3AvgBIAFCgICAgMAANwLwASABQQA2AugBIAEgBTYCnAMgASAGNgKYAyABQQA2ApQDIAEgBDYCkAMgASACNgKMAyABIAFBjANqIgUQ1zsgASgCACEGQRxBBBCtNiICBEAgAkKBgICAEDcCACACIAEpAowDNwIIIAJBEGogAUGUA2opAgA3AgAgAkEYaiABQZwDaigCADYCACABIAQ2AuQBIAEgBjYC4AEgASACNgLcASABQYABaiICIAFB6AFqIgYgAUHcAWoQ+iMgBSAKEJI2IAMQ5hggASgCkAMEQCABKAKMAyEDIAFB8AFqIAFBiAFqQdQA/AoAACABIAM2AuwBIAFBATYC6AEgAiAGIAFBkANqEK4WCyABQcgCaiICIAFBgAFqEM0cIA4gAhDLEiABQaADaiQADAMLDCcLQbj6ggFBKSABQegBakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgDhDmKSEBIABB7JuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwZCyAIQaAFaiEJIAEgAhCWIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEIQQgQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgY2ApwBIAQgAjYCmAEgAgR/IAYFIARBmAFqQYywgwEQsyggBCgCnAELQgA3AwAgBEGgAWoiAkEBNgIAIAUoAhAhByAFKAIUIQYgBCAFQRhqENw7IARBKGogAigCADYCACAEQQA2AjQgBEKAgICAEDcCLCAEIAZBA3YiCjYCFCAEIAc2AhAgBEIANwMIIAQgBCkCmAE3AyAgBCAEKQMANwMYIARBIGohAgJAAkACQAJAAkAgAygCAEEBaw4FAAECICADCyAEQYACaiIGIANBEGoiByABELEmIAQgBCkDEDcDwAIgBCAEQQhqIgo2AsgCIAIgBhChFCAGIAcgARCxJiAKIAYQ3hIMAwsgAygCDCELIAMoAgghBiAEIAo2AowCIAQgBzYCiAIgBCAGNgKAAiAEIAYgC0ECdGoiBzYChAIgBCAEQQhqIgo2ApACIAIgBEGAAmoQtiAgCiAGIAcQiRYMAgsgBEEIaiIHIAMoAggiBiAGIAMoAgxBA3RqIgogARCiFCAHIAYgChD7FQwBCyAEQYACaiIGIANBEGoiBxDJNCAEQQhqIgogBiABEJgSIAYgBxDJNCAKIAYQ9xMLIARBqAJqQZas2LABNgIAIARClqzYsOHChYsWNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIAJBCGooAgA2AgAgBCACKQIANwOYASAEQfQBaiIBIARBmAFqIgIQ8xggAiAEQYACaiIGIAEQ+iMgBEGIAmoiByAEQSxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAYQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogBiAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAkgARCLDCAEQaADaiQADAELDBsLIAkQ7CkhASAAQcScgwE2AgggACABNgIEIABBk4CAgHg2AgAMGAsgCEGgBWohCyABIAIQiyIhCiMAQaACayIHJAAgByAKKAIcIAooAiBBBHYgAxCGBiAHQewBakGXrty4ATYCACAHQpeu3Ljx4sWLFzcC5AEgB0IENwLcASAHQgA3AtQBIAdCgICAgMAANwLMASAHQQA2AsQBIAdBADsBnAIgB0EANgKYAiAHQQA2AoACIAdBADYC9AEgByADKAI8NgLwASAHQegAaiAHQcQBaiIBIAcQ+iMgCigCBCEJIAEgCigCCCIOQQBBBEEMEKAYIAcoAsgBIQUCQAJAIAcoAsQBQQFHBEAgBygCzAEhBgJAIAVFDQAgDkEMbCEEIAYhAiAFIQEDQCAERQ0BIAkoAgAiDCAMKAIAIg1BAWo2AgAgDUEASA0DIAJBBGogCSkCBDcCACACIAw2AgAgAkEMaiECIARBDGshBCAJQQxqIQkgAUEBayIBDQALCyAHIAU2AswBIAcgBjYCxAEgByAGNgLIASAHIAYgDkEMbGo2AtABIAdB8ABqIAdBxAFqIgEQriYgB0EMaiICIAdB6ABqIgVB3AD8CgAAIAUgChCTNiADEOYYIAcoAmwEQCAHKAJoIQMgB0HMAWogB0EUakHUAPwKAAAgByADNgLIASAHQQE2AsQBIAIgASAHQewAahCuFgsgB0HEAWoiASAHQQxqEM0cIAsgARDRDSAHQaACaiQADAILIAUgBygCzAFBzIKDARD9LwsACyALEOwpIQEgAEGcnYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADBcLIAhBoAVqIQYgASACEJkiIQUjAEGgA2siBCQAIARBgAJqIAMoAjwiAUEBakEAQQRBBBCgGCAEKAKEAiECAkAgBCgCgAJBAUcEQCAEQQA2AqABIAQgBCgCiAIiCTYCnAEgBCACNgKYASACBH8gCQUgBEGYAWpBjLCDARCdKCAEKAKcAQtBADYCACAEQaABaiICQQE2AgAgBSgCECEJIAUoAhQhByAEQQhqIAVBGGoQ3DsgBEEYaiACKAIANgIAIAQgB0ECdiIKNgIsIAQgCTYCKCAEQQA2AjggBEEANgIkIARCgICAgBA3AhwgBCAEKQKYATcDECAEIAQpAwg3AzAgBEE4aiEHAkACQAJAAkACQCADKAIAQQFrDgUAAQIeHgMLIARBgAJqIgIgA0EQaiIJIAEQsSYgBCAHNgLIAiAEIAQpAyg3A8ACIARBEGoiByACEJkTIAIgCSABELEmIAcgAhDdEgwDCyADKAIMIQsgAygCCCECIAQgBzYCkAIgBCAKNgKMAiAEIAk2AogCIAQgAjYCgAIgBCACIAtBAnRqIgk2AoQCIARBEGoiByAEQYACahC3ICAHIAIgCRCKFgwCCyAEQRBqIgkgAygCCCICIAIgAygCDEEDdGoiByABEM0TIAkgAiAHEPoVDAELIARBgAJqIgIgA0EQaiIJEMk0IARBEGoiByACIAEQtBEgAiAJEMk0IAcgAhD2EwsgBEGoAmpBmLDgwAE2AgAgBEKYsODAgYOGjBg3AqACIARCBDcCmAIgBEIANwKQAiAEQoCAgIDAADcCiAIgBEEANgKAAiAEQQA7AdgCIARBADYC1AIgBEEANgK8AiAEQQA2ArACIAQgATYCrAIgBEGgAWogBEEYaigCADYCACAEIAQpAxA3A5gBIARB9AFqIgEgBEGYAWoiAhDxGCACIARBgAJqIgkgARD6IyAEQYgCaiIHIARBHGoiCkEIaigCADYCACAEIAopAgA3A4ACIAEgCRCTGSAEQTxqIgogAiABEPojIAIgBRCTNiADEOYYIAQoApwBBEAgBCgCmAEhASAHIARBxABqQdQA/AoAACAEIAE2AoQCIARBATYCgAIgCiAJIARBnAFqEK4WCyAEQdwCaiIBIARBPGoQzRwgBiABEI4MIARBoANqJAAMAQsMGQsgBhDsKSEBIABB9J2DATYCCCAAIAE2AgQgAEGTgICAeDYCAAwWCyAIQaAFaiEJIAEgAhCYIiEFIwBBoANrIgQkACAEQYACaiADKAI8IgFBAWpBAEEIQQgQoBggBCgChAIhAgJAIAQoAoACQQFHBEAgBEEANgKgASAEIAQoAogCIgY2ApwBIAQgAjYCmAEgAgR/IAYFIARBmAFqQYywgwEQsyggBCgCnAELQgA3AwAgBEGgAWoiAkEBNgIAIAUoAhAhByAFKAIUIQYgBCAFQRhqENw7IARBKGogAigCADYCACAEQQA2AjQgBEKAgICAEDcCLCAEIAZBA3YiCjYCFCAEIAc2AhAgBEIANwMIIAQgBCkCmAE3AyAgBCAEKQMANwMYIARBIGohAgJAAkACQAJAAkAgAygCAEEBaw4FAAECHR0DCyAEQYACaiIGIANBEGoiByABELEmIAQgBCkDEDcDwAIgBCAEQQhqIgo2AsgCIAIgBhChFCAGIAcgARCxJiAKIAYQ3hIMAwsgAygCDCELIAMoAgghBiAEIAo2AowCIAQgBzYCiAIgBCAGNgKAAiAEIAYgC0ECdGoiBzYChAIgBCAEQQhqIgo2ApACIAIgBEGAAmoQtiAgCiAGIAcQiRYMAgsgBEEIaiIHIAMoAggiBiAGIAMoAgxBA3RqIgogARCiFCAHIAYgChD7FQwBCyAEQYACaiIGIANBEGoiBxDJNCAEQQhqIgogBiABEJgSIAYgBxDJNCAKIAYQ9xMLIARBqAJqQZmy5MgBNgIAIARCmbLkyJGjxowZNwKgAiAEQgQ3ApgCIARCADcCkAIgBEKAgICAwAA3AogCIARBADYCgAIgBEEAOwHYAiAEQQA2AtQCIARBADYCvAIgBEEANgKwAiAEIAE2AqwCIARBoAFqIAJBCGooAgA2AgAgBCACKQIANwOYASAEQfQBaiIBIARBmAFqIgIQ8xggAiAEQYACaiIGIAEQ+iMgBEGIAmoiByAEQSxqIgpBCGooAgA2AgAgBCAKKQIANwOAAiABIAYQkxkgBEE8aiIKIAIgARD6IyACIAUQkzYgAxDmGCAEKAKcAQRAIAQoApgBIQEgByAEQcQAakHUAPwKAAAgBCABNgKEAiAEQQE2AoACIAogBiAEQZwBahCuFgsgBEHcAmoiASAEQTxqEM0cIAkgARCMDCAEQaADaiQADAELDBgLIAkQ7CkhASAAQcyegwE2AgggACABNgIEIABBk4CAgHg2AgAMFQsgCEGgBWohCyABIAIQjCIhCiMAQaACayIHJAAgByAKKAIcIAooAiBBBHYgAxCGBiAHQewBakGatOjQATYCACAHQpq06NChw4aNGjcC5AEgB0IENwLcASAHQgA3AtQBIAdCgICAgMAANwLMASAHQQA2AsQBIAdBADsBnAIgB0EANgKYAiAHQQA2AoACIAdBADYC9AEgByADKAI8NgLwASAHQegAaiAHQcQBaiIBIAcQ+iMgCigCBCEJIAEgCigCCCIOQQBBBEEMEKAYIAcoAsgBIQUCQAJAIAcoAsQBQQFHBEAgBygCzAEhBgJAIAVFDQAgDkEMbCEEIAYhAiAFIQEDQCAERQ0BIAkoAgAiDCAMKAIAIg1BAWo2AgAgDUEASA0DIAJBBGogCSkCBDcCACACIAw2AgAgAkEMaiECIARBDGshBCAJQQxqIQkgAUEBayIBDQALCyAHIAU2AswBIAcgBjYCxAEgByAGNgLIASAHIAYgDkEMbGo2AtABIAdB8ABqIAdBxAFqIgEQriYgB0EMaiICIAdB6ABqIgVB3AD8CgAAIAUgChCTNiADEOYYIAcoAmwEQCAHKAJoIQMgB0HMAWogB0EUakHUAPwKAAAgByADNgLIASAHQQE2AsQBIAIgASAHQewAahCuFgsgB0HEAWoiASAHQQxqEM0cIAsgARDSDSAHQaACaiQADAILIAUgBygCzAFBzIKDARD9LwsACyALEOwpIQEgAEGkn4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADBQLIAUtAAFFDQoLIAhBhAJqIgUgASACKAIUEQAAEKkvIQEgCEEBNgKoBSAIIAE2AqQFIAhBATYCoAUgASAFNgIAIAhByAJqIAhBoAVqQQAgAygCPBDALCAHQQNHDQwgAygCDCICRQ0NIAMoAggiASACQQN0aiECA0AgCEHIAmpBACABKAIAIAFBBGooAgAQ2BsgAUEIaiIBIAJHDQALDA0LIAEgAhCfIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC/EyABQaACaiQAIAMQ3CkhASAAQaSUgwE2AgggACABNgIEIABBk4CAgHg2AgAMEQsgASACELQiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEMYTIAFBoAJqJAAgAxDcKSEBIABB/JSDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwQCyABIAIQsiIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEEDdiADEKcFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQqBMgAUGgAmokACADENwpIQEgAEHUlYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADA8LIAEgAhCsIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhC0EyABQaACaiQAIAMQ3CkhASAAQayWgwE2AgggACABNgIEIABBk4CAgHg2AgAMDgsgASACEJ4iIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBAnYgAxCKBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACELsTIAFBoAJqJAAgAxDcKSEBIABBtJiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwNCyABIAIQtiIhAiMAQaACayIBJAAgAUEIaiIFIAIoAhAgAigCFEECdiADEIoFIAFBoAFqIAIQzAYgAUEAOwHYASABQQA2AtQBIAFBADYCvAEgAUEANgKwASABQgQ3ApgBIAFCADcCkAEgAUKAgICAwAA3AogBIAFBADYCgAEgASADKAI8NgKsASABQRRqIgYgAUGAAWoiBCAFEPojIAFB8ABqIAIQkjYgAxDmGCABKAJ0BEAgASgCcCECIAFBiAFqIAFBHGpB1AD8CgAAIAEgAjYChAEgAUEBNgKAASAGIAQgAUH0AGoQrhYLIAFB3AFqIgIgAUEUahDNHCAIQaAFaiIDIAIQshMgAUGgAmokACADENwpIQEgAEGMmYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAwLIAEgAhCvIiECIwBBoAJrIgEkACABQQhqIgUgAigCECACKAIUQQN2IAMQpwUgAUGgAWogAhDMBiABQQA7AdgBIAFBADYC1AEgAUEANgK8ASABQQA2ArABIAFCBDcCmAEgAUIANwKQASABQoCAgIDAADcCiAEgAUEANgKAASABIAMoAjw2AqwBIAFBFGoiBiABQYABaiIEIAUQ+iMgAUHwAGogAhCSNiADEOYYIAEoAnQEQCABKAJwIQIgAUGIAWogAUEcakHUAPwKAAAgASACNgKEASABQQE2AoABIAYgBCABQfQAahCuFgsgAUHcAWoiAiABQRRqEM0cIAhBoAVqIgMgAhDCEyABQaACaiQAIAMQ3CkhASAAQeSZgwE2AgggACABNgIEIABBk4CAgHg2AgAMCwsgASACELoiIQIjAEGgAmsiASQAIAFBCGoiBSACKAIQIAIoAhRBA3YgAxCnBSABQaABaiACEMwGIAFBADsB2AEgAUEANgLUASABQQA2ArwBIAFBADYCsAEgAUIENwKYASABQgA3ApABIAFCgICAgMAANwKIASABQQA2AoABIAEgAygCPDYCrAEgAUEUaiIGIAFBgAFqIgQgBRD6IyABQfAAaiACEJI2IAMQ5hggASgCdARAIAEoAnAhAiABQYgBaiABQRxqQdQA/AoAACABIAI2AoQBIAFBATYCgAEgBiAEIAFB9ABqEK4WCyABQdwBaiICIAFBFGoQzRwgCEGgBWoiAyACEKkTIAFBoAJqJAAgAxDcKSEBIABBvJqDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwKCyAIQaAFaiEFIAEgAhDILyELQQAhBiMAQeAAayIBJAAgASALENw7IAEoAgQhBCABKAIAIQIgASADNgJAIAEgAjYCOCABIAIgBEEDdGo2AjwgAUEUaiEHIwBBMGsiBCQAIARBk4CAgHg2AgAgBEEoaiABQThqIgJBCGooAgA2AgAgBCACKQIANwMgIAQgBDYCLCAEQRRqIQ4jAEEwayICJAAgAkEIaiAEQSBqIgkQhygCQAJAAkAgAigCCCIPBEAgAigCDCEQIAJBIGoiDEEEQQBBBEEIEKAYIAIoAiQhCiACKAIgQQFGDQIgAigCKCINIBA2AgQgDSAPNgIAIAJBHGoiEUEBNgIAIAIgDTYCGCACIAo2AhQgAkEoaiAJQQhqKQIANwMAIAIgCSkCADcDICMAQRBrIgkkACAJQQhqIAwQhyggCSgCCCINBEAgAkEUaiEKIAkoAgwhDwNAIAooAggiECAKKAIARgRAIApBARDqLQsgCigCBCAQQQN0aiISIA82AgQgEiANNgIAIAogEEEBajYCCCAJIAwQhyggCSgCBCEPIAkoAgAiDQ0ACwsgCUEQaiQAIA5BCGogESgCADYCACAOIAIpAhQ3AgAMAQsgDkEANgIIIA5CgICAgMAANwIACyACQTBqJAAMAQsgCiACKAIoQYj5gwEQ/S8ACwJAIAQoAgBBk4CAgHhHBEAgByAEKQIANwIAIAdBEGogBEEQaigCADYCACAHQQhqIARBCGopAgA3AgAgDhDDJyAOEOo7DAELIAcgBCkCFDcCBCAHQZOAgIB4NgIAIAdBDGogBEEcaigCADYCAAsgBEEwaiQAIAFBEGoiAiABQSBqKAIANgIAIAEgASkCGDcDCAJAAkACQCABKAIUIgRBk4CAgHhHBEAgASgCJCEDIAUgASkDCDcCCCAFIAM2AhQgBSAENgIEIAVBgICAgHg2AgAgBUEQaiACKAIANgIADAELIAFBMGogAigCADYCACABIAEpAwg3AyggAUEUaiALEJw2IAMQ5hggASgCGAR/IAEoAhQhBiABQcwAaiABQRhqQQAgAygCPBDyFSABQUBrIAFB2ABqKQIANwMAIAEgASkCUDcDOCABKAJMBUEACyEEIAstAAxBIEYEfyALQRBqBUH49oUBQShBrPiFARCfKQALIgkoAgAiAiACKAIAIgdBAWo2AgAgB0EASA0BIAUgASkDODcCICAFIAEpAyg3AgAgBSAGNgIwIAUgBDYCHCAFIAI2AhAgBUEgOgAMIAUgAygCPDYCGCAFIAkoAgQ2AhQgBUEoaiABQUBrKQMANwIAIAVBCGogAUEwaigCADYCAAsgAUHgAGokAAwBCwALIAhB0AJqIgEgCEGsBWopAgA3AwAgCEHYAmoiAiAIQbQFaigCADYCACAIIAgpAqQFNwPIAiAIKAKgBSIDQYCAgIB4Rg0IIAhB0AFqIAhB0AVqKAIANgIAIAhByAFqIAhByAVqKQIANwIAIAhBwAFqIAhBwAVqKQIANwIAIAhBrAFqIAEpAwA3AgAgCEG0AWogAigCADYCACAIIAgpArgFNwK4ASAIIAM2AqABIAggCCkDyAI3AqQBIAhBoAFqEOUpIQEgAEH8n4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAkLIwBBIGsiBSQAIAVBCGogASACKAIQEQAAIAVBEGogBSgCCCIBIAUoAgwoAgwRAAAgBSkDGCEWIAUpAxAhFyAFQSBqJAAgAUEAIBdC55nB0obRrM2zf4UgFkLlkuGP24mtrlKFhFAbIgZFBEBB0PODAUELQdzzgwEQyyQACyAIQaAFaiEJIwBBoAFrIgEkAAJAAkACQCAGLQAMQSFHDQAgBi0ADUEBRg0AIAYoAhgiAiACKAIAIgVBAWo2AgAgBUEASA0BIAEgAjYCUCABIAYpAhw3AlQgAUEANgI4IAFB8ABqIgUgAUHQAGogAUE4aiICENgdIAFBCGoiDyAFIAMQ9BMgBRCCJSABIAZBEGoiEBCwLiABKQMAIRYgASADNgJEIAEgBjYCQCABIBY3AjgjAEFAaiIDJAAgA0GTgICAeDYCCCADQTBqIAJBCGopAgA3AwAgAyACKQIANwMoIAMgA0EIajYCOCADQRxqIQojAEEwayICJAAgAiADQShqIgQQryECQAJAAkAgAigCACIMBEAgAigCBCENIAJBGGoiC0EEQQBBBEEIEKAYIAIoAhwhByACKAIYQQFGDQIgAigCICIOIA02AgQgDiAMNgIAIAJBFGoiEUEBNgIAIAIgDjYCECACIAc2AgwgAkEoaiAEQRBqKAIANgIAIAJBIGogBEEIaikCADcDACACIAQpAgA3AxgjAEEQayIEJAAgBEEIaiALEK8hIAQoAggiDgRAIAJBDGohByAEKAIMIQwDQCAHKAIIIg0gBygCAEYEQCAHQQEQ6i0LIAcoAgQgDUEDdGoiEiAMNgIEIBIgDjYCACAHIA1BAWo2AgggBCALEK8hIAQoAgQhDCAEKAIAIg4NAAsLIARBEGokACAKQQhqIBEoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgAkEwaiQADAELIAcgAigCIEGI+YMBEP0vAAsCQCADKAIIQZOAgIB4RwRAIAUgAykCCDcCACAFQRBqIANBGGooAgA2AgAgBUEIaiADQRBqKQIANwIAIAoQwycgChDqOwwBCyAFIAMpAhw3AgQgBUGTgICAeDYCACAFQQxqIANBJGooAgA2AgALIANBQGskACABQdgAaiICIAFB/ABqKAIANgIAIAEgASkCdDcDUAJAIAEoAnAiA0GTgICAeEcEQCABKAKAASEFIAkgASkDUDcCCCAJIAU2AhQgCSADNgIEIAlBgICAgHg2AgAgCUEQaiACKAIANgIAIA8QgiUMAQsgAUHoAGogAigCADYCACABIAEpA1A3A2AgECgCACICIAIoAgAiA0EBajYCACADQQBIDQIgBigCFCEDIAFBhAFqIAFBHGooAgA2AgAgAUGQAWogAUEoaikCADcDACABQZgBaiABQTBqKQIANwMAIAFB+ABqIAFBEGooAgA2AgAgASABKQIUNwJ8IAEgASkCIDcDiAEgASABKQIINwNwIAFBADYCOCAJIAIgAyABQRRqIAFBOGogAUHgAGoQjhAgAUHwAGoQtwwgASgCiAEiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUGIAWoQ+x4LIAFBoAFqJAAMAgtB/K2DAUEoQcCygwEQnykLAAsgCEHQAmoiASAIQawFaikCADcDACAIQdgCaiICIAhBtAVqKAIANgIAIAggCCkCpAU3A8gCIAgoAqAFIgNBgICAgHhGBEAgACAIKQPIAjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIADAkLIAhB/AFqIAhByAVqKQIANwIAIAhB9AFqIAhBwAVqKQIANwIAIAhB4AFqIAEpAwA3AgAgCEHoAWogAigCADYCACAIIAgpArgFNwLsASAIIAM2AtQBIAggCCkDyAI3AtgBIAhB1AFqENwpIQEgAEHUoIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIAEgBhEEACIFLQAAQSJGDQUgCCAFNgKEAiAIQQE2AqQFIAhBjKiDATYCoAUgCEIBNwKsBSAIQa8DNgLMAiAIIAhByAJqNgKoBSAIIAhBhAJqNgLIAiAIQaAFakGUqIMBEO8sAAsgASAGEQQAIgUtAABBKEYNAyAIIAU2AoQCIAhBATYCpAUgCEHQq4MBNgKgBSAIQgE3AqwFIAhBrwM2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQdirgwEQ7ywACyAIQZgEaiICIAkQyTQjAEEQayIBJAAgAUEEaiACENUJIAEoAgRBAUYEQCAIQcgCaiEDA0AgA0EAIAEoAgggASgCDBDYGyABQQRqIAIQ1QkgASgCBA0ACwsgAUEQaiQACyAIQaAFaiIBIAhByAJqQcwB/AoAACAIQdwEaiICIAEQ6iwgCCACEKABIAAgCCkDADcCBCAAQZOAgIB4NgIAIAhBhAJqIgBBGGoQtwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwwEC0G8k4MBELI7AAsCQAJAAkACQAJAAkAgBSgCBCIFLQAwQQNrDgMBAgMACyAIIAVBMGo2AoQCIAhBATYCpAUgCEH4qoMBNgKgBSAIQgE3AqwFIAhBpwQ2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQYCrgwEQ7ywACyABIAIQnCIhDiMAQbABayIBJAAgAUEEaiICIA4oAhhBvKyDARCZFSABQgA3AxAgAUEANgIYIAFBADsBHiAOQQxqIgUQ2TwhCiABIANBEGo2AlwgASAFNgJYIAEgAUEYajYCbCABIAI2AmggASABQR5qNgJkIAEgAUEQajYCYCABQSBqIRQgAUHYAGohAyMAQTBrIgIkAEHAACEHAkACQAJAAkAgCkEGdiIFIApBP3EiD0EAR2oiBkEDdCIEQcD///8DcUFAayAEIAZBB3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIHRQ0CC0EAIQQgCkHAAE8EQCAFrSEcIAMoAhQhDCADKAIQIRAgAygCDCERIAMoAgghEiADKAIEIQ0gAygCACEVA0AgGUIGhiEdIBlCAXwhGUIAIRdCACEYA0AgFyAdfCIWIBUoAghBAXYiBa1aDSIgES8BACEGQQAhBSAVKAIEIBanQQF0ajIBACIWIA01AhAiGiAWIBpUGyIaIBIpAwAiG1YEQCAaIBt9IRYgG6chCQNAIBEgBiANKAIEIAkgDSgCDGoiE0EDdmotAAAgE0EHcXYiE0EBcWoiBjsBACAFIBNyIQUgCUEBaiEJIBZCAX0iFkIAUg0ACwsgDCgCACIJIBAoAggiE08NBiAQKAIEIAlBAXRqIAY7AQAgDCAMKAIAIAVBAXFqNgIAIBIgGjcDACAFrUIBgyAXhiAYhCEYIBdCAXwiF0LAAFINAAsgBCAHaiAYNwMAIARBCGohBCAZIBxSDQALCyAPBEAgCkFAca0hGyAPrSEcIAMoAhQhDCADKAIQIQ8gAygCDCEQIAMoAgghESADKAIEIQ0gAygCACEDQgAhF0IAIRgDQCAXIBt8IhYgAygCCEEBdiIFrVoNISAQLwEAIQZBACEFIAMoAgQgFqdBAXRqMgEAIhYgDTUCECIZIBYgGVQbIhkgESkDACIaVgRAIBkgGn0hFiAapyEJA0AgECAGIA0oAgQgCSANKAIMaiISQQN2ai0AACASQQdxdiISQQFxaiIGOwEAIAUgEnIhBSAJQQFqIQkgFkIBfSIWQgBSDQALCyAMKAIAIgkgDygCCCISTw0EIA8oAgQgCUEBdGogBjsBACAMIAwoAgAgBUEBcWo2AgAgESAZNwMAIAWtQgGDIBeGIBiEIRggF0IBfCIXIBxSDQALIAQgB2ogGDcAACAEQQhqIQQLIAIgCzYCLCACQoCAgICACDcCJCACIAc2AhwgAiAKQQN2IApBB3FBAEdqIgMgBCADIARJGyIFNgIgIAJBCGogAkEcahDXOyACKAIIIQZBHEEEEK02IgNFDRYgA0KBgICAEDcCACADIAIpAhw3AgggA0EQaiACQSRqKQIANwIAIANBGGogAkEsaigCADYCACACIAU2AhggAiAGNgIUIAIgAzYCECAUIAJBEGpBACAKEPIVIAJBMGokAAwECwwdC0HAACALEKM9AAsgCSASQdj1gwEQwyEACyAJIBNB2PWDARDDIQALIAFBADYCNCABKAIYIgIgASgCDE0EQCABIAI2AgwLIAhBoAVqIQMgASAOQSBqNgJMIAFB2ABqIAFBzABqQcysgwEgAUEgaiIGEMIQIAEoAmAhAiABKAJcIQUCQCABKAJYIgRBk4CAgHhHBEAgAyABKQJkNwIQIAMgAjYCDCADIAU2AgggAyAENgIEIANBKToAACAGEM0mIAFBBGoQnTwMAQsgASACNgJUIAEgBTYCUCABQeAAaiABQQxqKAIANgIAIAEgASkCBDcDWCABQYwBaiICIAFB2ABqIgYQ6RggAUEANgKYASAGIAIgAUGYAWoQ2h0jAEHwAmsiAiQAIAIgBhDPBiACQQxqIgUgAUHQAGoiCkHArYMBKAIAEQQAEM8GIAJB0AFqIgRBuISEAUEIIAJBABCbFAJAQdAAQQgQrTYiCQRAIAlCgYCAgBA3AwAgCUEIaiAEQcgA/AoAACAEQcCEhAFBBiAFQQEQmxRB0ABBCBCtNiIHRQ0fIAdCgYCAgBA3AwAgB0EIaiAEQcgA/AoAAAJ/IwBBMGsiBSQAAkAgBkEMaiIOENk8IgsEfyAFIAtBAWsiCzYCACAOENk8IAtNDQEgBigCECALQQF0ai4BAAVBAAsgBUEwaiQADAELIAUgBhD+OzYCHAwfCyEFIAJBADsBqAIgAkEANgKkAiACQQA2AowCIAJBADYCgAIgAiAFNgL8ASACIAc2AvgBIAIgCTYC9AEgAkEoOgDwASACQgQ3AugBIAJCADcC4AEgAkKAgICAwAA3AtgBIAJBADYC0AEgAkGsAmoiCSAGEKUuIAJB9ABqIgUgBCAJEO8lIAQgCkG4rYMBKAIAEQAAIAJBGGoiCSAFIAQQ7yUgBSAJEM0cIAQgBRDnFgJAIAIoAtABIgRBk4CAgHhHBEAgAyACKQLUATcCCCADQRBqIAJB3AFqKQIANwIAIANBKToAACADIAQ2AgQgBRCFJwwBCyACQdABaiIFIAJB9ABqQcQA/AoAACADIAUQnwkLIAJB8AJqJAAMAQsMHgsgBhCCJSABKAJQIgIgAigCACICQQFrNgIAIAJBAUYEQCAKELsjCyABQSBqEM0mCyABQbABaiQAIAgtAKAFIgFBKUYNAyAIQdcCaiICIAhBsAVqKQAANwAAIAhB0AJqIgMgCEGpBWopAAA3AwAgCEHIAGogCEHABWopAgA3AgAgCEExaiADKQMANwAAIAhBOGogAikAADcAACAIIAgpAKEFIhY3A8gCIAggCCkCuAU3AkAgCCABOgAoIAggFjcAKSAIQShqEPUpIQEgAEGkqIMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAYLIAEgAhCaIiEOIwBBsAFrIgEkACABQQRqIgJBACAOKAIYQbysgwEQsxUgAUIANwMQIAFBADYCGCABQQA2AhwgDkEMaiIFENs8IQogASADQRBqNgJcIAEgBTYCWCABIAFBGGo2AmwgASACNgJoIAEgAUEcajYCZCABIAFBEGo2AmAgAUEgaiEUIAFB2ABqIQMjAEEwayICJABBwAAhBwJAAkACQAJAIApBBnYiBSAKQT9xIg9BAEdqIgZBA3QiBEHA////A3FBQGsgBCAGQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiB0UNAgtBACEEIApBwABPBEAgBa0hHCADKAIUIQwgAygCECEQIAMoAgwhESADKAIIIRIgAygCBCENIAMoAgAhFQNAIBlCBoYhHSAZQgF8IRlCACEXQgAhGANAIBcgHXwiFiAVKAIIQQJ2IgWtWg0hIBEoAgAhBkEAIQUgFSgCBCAWp0ECdGo0AgAiFiANNQIQIhogFiAaVBsiGiASKQMAIhtWBEAgGiAbfSEWIBunIQkDQCARIAYgDSgCBCAJIA0oAgxqIhNBA3ZqLQAAIBNBB3F2IhNBAXFqIgY2AgAgBSATciEFIAlBAWohCSAWQgF9IhZCAFINAAsLIAwoAgAiCSAQKAIIIhNPDQYgECgCBCAJQQJ0aiAGNgIAIAwgDCgCACAFQQFxajYCACASIBo3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhdCwABSDQALIAQgB2ogGDcDACAEQQhqIQQgGSAcUg0ACwsgDwRAIApBQHGtIRsgD60hHCADKAIUIQwgAygCECEPIAMoAgwhECADKAIIIREgAygCBCENIAMoAgAhA0IAIRdCACEYA0AgFyAbfCIWIAMoAghBAnYiBa1aDSAgECgCACEGQQAhBSADKAIEIBanQQJ0ajQCACIWIA01AhAiGSAWIBlUGyIZIBEpAwAiGlYEQCAZIBp9IRYgGqchCQNAIBAgBiANKAIEIAkgDSgCDGoiEkEDdmotAAAgEkEHcXYiEkEBcWoiBjYCACAFIBJyIQUgCUEBaiEJIBZCAX0iFkIAUg0ACwsgDCgCACIJIA8oAggiEk8NBCAPKAIEIAlBAnRqIAY2AgAgDCAMKAIAIAVBAXFqNgIAIBEgGTcDACAFrUIBgyAXhiAYhCEYIBdCAXwiFyAcUg0ACyAEIAdqIBg3AAAgBEEIaiEECyACIAs2AiwgAkKAgICAgAg3AiQgAiAHNgIcIAIgCkEDdiAKQQdxQQBHaiIDIAQgAyAESRsiBTYCICACQQhqIAJBHGoQ1zsgAigCCCEGQRxBBBCtNiIDRQ0VIANCgYCAgBA3AgAgAyACKQIcNwIIIANBEGogAkEkaikCADcCACADQRhqIAJBLGooAgA2AgAgAiAFNgIYIAIgBjYCFCACIAM2AhAgFCACQRBqQQAgChDyFSACQTBqJAAMBAsMHAtBwAAgCxCjPQALIAkgEkHY9YMBEMMhAAsgCSATQdj1gwEQwyEACyABQQA2AjQgASgCGCICIAEoAgxNBEAgASACNgIMCyAIQaAFaiEDIAEgDkEgajYCTCABQdgAaiABQcwAakHMrIMBIAFBIGoiBhDCECABKAJgIQIgASgCXCEFAkAgASgCWCIEQZOAgIB4RwRAIAMgASkCZDcCECADIAI2AgwgAyAFNgIIIAMgBDYCBCADQSk6AAAgBhDNJiABQQRqEOk7DAELIAEgAjYCVCABIAU2AlAgAUHgAGogAUEMaigCADYCACABIAEpAgQ3A1ggAUGMAWoiAiABQdgAaiIGEOgYIAFBADYCmAEgBiACIAFBmAFqEL8dIwBB8AJrIgIkACACIAYQzwYgAkEMaiIFIAFB0ABqIgpBwK2DASgCABEEABDPBiACQdABaiIEQbiEhAFBCCACQQAQmxQCQEHQAEEIEK02IgkEQCAJQoGAgIAQNwMAIAlBCGogBEHIAPwKAAAgBEHAhIQBQQYgBUEBEJsUQdAAQQgQrTYiB0UNHiAHQoGAgIAQNwMAIAdBCGogBEHIAPwKAAACfyMAQTBrIgUkAAJAIAZBDGoiDhDbPCILBH8gBSALQQFrIgs2AgAgDhDbPCALTQ0BIAYoAhAgC0ECdGooAgAFQQALIAVBMGokAAwBCyAFIAYQ/Ds2AhwMHgshBSACQQA7AagCIAJBADYCpAIgAkEANgKMAiACQQA2AoACIAIgBTYC/AEgAiAHNgL4ASACIAk2AvQBIAJBKDoA8AEgAkIENwLoASACQgA3AuABIAJCgICAgMAANwLYASACQQA2AtABIAJBrAJqIgkgBhCpLiACQfQAaiIFIAQgCRDvJSAEIApBuK2DASgCABEAACACQRhqIgkgBSAEEO8lIAUgCRDNHCAEIAUQ5xYCQCACKALQASIEQZOAgIB4RwRAIAMgAikC1AE3AgggA0EQaiACQdwBaikCADcCACADQSk6AAAgAyAENgIEIAUQhScMAQsgAkHQAWoiBSACQfQAakHEAPwKAAAgAyAFEJ4JCyACQfACaiQADAELDB0LIAYQgiUgASgCUCICIAIoAgAiAkEBazYCACACQQFGBEAgChC7IwsgAUEgahDNJgsgAUGwAWokACAILQCgBSIBQSlGDQEgCEHXAmoiAiAIQbAFaikAADcAACAIQdACaiIDIAhBqQVqKQAANwMAIAhB8ABqIAhBwAVqKQIANwIAIAhB2QBqIAMpAwA3AAAgCEHgAGogAikAADcAACAIIAgpAKEFIhY3A8gCIAggCCkCuAU3AmggCCABOgBQIAggFjcAUSAIQdAAahD1KSEBIABB/KiDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwFCyABIAIQmyIhCyMAQcABayIBJAAgAUEMaiICIAsoAhhBvKyDARC2FSABQgA3AxggAUEANgIkIAFCADcDKCALQQxqIgUQ2DwhByABIANBEGo2AmwgASAFNgJoIAEgAUEkajYCfCABIAI2AnggASABQShqNgJ0IAEgAUEYajYCcCABQTBqIRUgAUHoAGohAyMAQTBrIgIkAEHAACEJAkACQAJAAkAgB0EGdiIFIAdBP3EiDUEAR2oiBkEDdCIEQcD///8DcUFAayAEIAZBB3EbIgpBwAAQ0TQEQCAKBEAgCkHAABCtNiIJRQ0CC0EAIQQgB0HAAE8EQCAFrSEdIAMoAhQhDiADKAIQIQ8gAygCDCEQIAMoAgghESADKAIEIQwgAygCACESA0AgGkIGhiEeIBpCAXwhGkIAIRdCACEYA0AgFyAefCIWIBIoAghBA3YiBa1aDSAgECkDACEZQQAhBSASKAIEIBanQQN0aikDACIWIAw1AhAiGyAWIBtUGyIbIBEpAwAiHFYEQCAbIBx9IRYgHKchBgNAIBAgGSAMKAIEIAYgDCgCDGoiFEEDdmotAAAgFEEHcXYiFEEBca18Ihk3AwAgBSAUciEFIAZBAWohBiAWQgF9IhZCAFINAAsLIA4oAgAiBiAPKAIIIhRPDQYgDygCBCAGQQN0aiAZNwMAIA4gDigCACAFQQFxajYCACARIBs3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhdCwABSDQALIAQgCWogGDcDACAEQQhqIQQgGiAdUg0ACwsgDQRAIAdBQHGtIRwgDa0hHSADKAIUIQ4gAygCECENIAMoAgwhDyADKAIIIRAgAygCBCEMIAMoAgAhA0IAIRdCACEYA0AgFyAcfCIWIAMoAghBA3YiBa1aDR8gDykDACEZQQAhBSADKAIEIBanQQN0aikDACIWIAw1AhAiGiAWIBpUGyIaIBApAwAiG1YEQCAaIBt9IRYgG6chBgNAIA8gGSAMKAIEIAYgDCgCDGoiEUEDdmotAAAgEUEHcXYiEUEBca18Ihk3AwAgBSARciEFIAZBAWohBiAWQgF9IhZCAFINAAsLIA4oAgAiBiANKAIIIhFPDQQgDSgCBCAGQQN0aiAZNwMAIA4gDigCACAFQQFxajYCACAQIBo3AwAgBa1CAYMgF4YgGIQhGCAXQgF8IhcgHVINAAsgBCAJaiAYNwAAIARBCGohBAsgAiAKNgIsIAJCgICAgIAINwIkIAIgCTYCHCACIAdBA3YgB0EHcUEAR2oiAyAEIAMgBEkbIgU2AiAgAkEIaiACQRxqENc7IAIoAgghBkEcQQQQrTYiA0UNFCADQoGAgIAQNwIAIAMgAikCHDcCCCADQRBqIAJBJGopAgA3AgAgA0EYaiACQSxqKAIANgIAIAIgBTYCGCACIAY2AhQgAiADNgIQIBUgAkEQakEAIAcQ8hUgAkEwaiQADAQLDBsLQcAAIAoQoz0ACyAGIBFB2PWDARDDIQALIAYgFEHY9YMBEMMhAAsgAUEANgJEIAEoAiQiAiABKAIUTQRAIAEgAjYCFAsgCEGgBWohAyABIAtBIGo2AlwgAUHoAGogAUHcAGpBzKyDASABQTBqIgYQwhAgASgCcCECIAEoAmwhBQJAIAEoAmgiBEGTgICAeEcEQCADIAEpAnQ3AhAgAyACNgIMIAMgBTYCCCADIAQ2AgQgA0EpOgAAIAYQzSYgAUEMahDjPAwBCyABIAI2AmQgASAFNgJgIAFB8ABqIAFBFGooAgA2AgAgASABKQIMNwNoIAFBnAFqIgIgAUHoAGoiBhC9GCABQQA2AqgBIAYgAiABQagBahDWHSMAQfACayICJAAgAiAGEM8GIAJBDGoiBSABQeAAaiIKQcCtgwEoAgARBAAQzwYgAkHQAWoiBEG4hIQBQQggAkEAEJsUAkBB0ABBCBCtNiIJBEAgCUKBgICAEDcDACAJQQhqIARByAD8CgAAIARBwISEAUEGIAVBARCbFEHQAEEIEK02IgdFDR0gB0KBgICAEDcDACAHQQhqIARByAD8CgAAAn8jAEEwayIFJAACQCAGQQxqIg4Q2DwiCwR/IAUgC0EBayILNgIAIA4Q2DwgC00NASAGKAIQIAtBA3RqKAIABUEACyAFQTBqJAAMAQsgBSAGEP07NgIcDB0LIQUgAkEAOwGoAiACQQA2AqQCIAJBADYCjAIgAkEANgKAAiACIAU2AvwBIAIgBzYC+AEgAiAJNgL0ASACQSg6APABIAJCBDcC6AEgAkIANwLgASACQoCAgIDAADcC2AEgAkEANgLQASACQawCaiIJIAYQqC4gAkH0AGoiBSAEIAkQ7yUgBCAKQbitgwEoAgARAAAgAkEYaiIJIAUgBBDvJSAFIAkQzRwgBCAFEOcWAkAgAigC0AEiBEGTgICAeEcEQCADIAIpAtQBNwIIIANBEGogAkHcAWopAgA3AgAgA0EpOgAAIAMgBDYCBCAFEIUnDAELIAJB0AFqIgUgAkH0AGpBxAD8CgAAIAMgBRCgCQsgAkHwAmokAAwBCwwcCyAGEIIlIAEoAmAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAoQuyMLIAFBMGoQzSYLIAFBwAFqJAAgCC0AoAUiAUEpRwRAIAhB1wJqIgIgCEGwBWopAAA3AAAgCEHQAmoiAyAIQakFaikAADcDACAIQZgBaiAIQcAFaikCADcCACAIQYEBaiADKQMANwAAIAhBiAFqIAIpAAA3AAAgCCAIKQChBSIWNwPIAiAIIAgpArgFNwKQASAIIAE6AHggCCAWNwB5IAhB+ABqEPUpIQEgAEHUqYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAULIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAQLIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAMLIAhB2wJqIAhBtAVqKAIAIgE2AAAgCEHTAmogCEGsBWopAgAiFjcAACAIIAgpAqQFIhc3AMsCIABBEGogATYAACAAQQhqIBY3AAAgACAXNwAADAILAkACQAJAAkACQAJAAkACQAJAIAUoAgQiBS0AAEECaw4IAQIDBAUGBwgACyAIIAU2AoQCIAhBATYCpAUgCEG4p4MBNgKgBSAIQgE3AqwFIAhBpwQ2AswCIAggCEHIAmo2AqgFIAggCEGEAmo2AsgCIAhBoAVqQcCngwEQ7ywACyABIAIQxCIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ9BMgAkHcAGoiBiIDIAEQ9z0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQsgAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQngggAkGgAmokACADEOspIQEgAEGsoYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIAEgAhDBIiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxDhEyACQdwAaiIGIgMgARD5PSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNCiADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARCkCCACQaACaiQAIAMQ6ykhASAAQYSigwE2AgggACABNgIEIABBk4CAgHg2AgAMBwsgASACEMAiIQUjAEGgAmsiAiQAIAJBuAFqIgEgBUEMaiADEOITIAJB3ABqIgYiAyABEPE9IAEgAxChGyACQZQCaiIEIAUQzAYgAyABIAQQjBhBxABBBBCtNiIDRQ0JIAMgBUE8ahDDLSACQQE2AsABIAIgAzYCvAEgAkEBNgK4ASACIAYgARD8IiABIAIQzRwgCEGgBWoiAyABEKIIIAJBoAJqJAAgAxDrKSEBIABB3KKDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyABIAIQwyIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ4xMgAkHcAGoiBiIDIAEQ8D0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQggAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQoAggAkGgAmokACADEOspIQEgAEG0o4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAULIAEgAhDCIiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxD1EyACQdwAaiIGIgMgARD3PSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNByADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARCdCCACQaACaiQAIAMQ6ykhASAAQYykgwE2AgggACABNgIEIABBk4CAgHg2AgAMBAsgASACEL8iIQUjAEGgAmsiAiQAIAJBuAFqIgEgBUEMaiADEOQTIAJB3ABqIgYiAyABEPk9IAEgAxChGyACQZQCaiIEIAUQzAYgAyABIAQQjBhBxABBBBCtNiIDRQ0GIAMgBUE8ahDDLSACQQE2AsABIAIgAzYCvAEgAkEBNgK4ASACIAYgARD8IiABIAIQzRwgCEGgBWoiAyABEJ8IIAJBoAJqJAAgAxDrKSEBIABB5KSDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyABIAIQviIhBSMAQaACayICJAAgAkG4AWoiASAFQQxqIAMQ5RMgAkHcAGoiBiIDIAEQ8T0gASADEKEbIAJBlAJqIgQgBRDMBiADIAEgBBCMGEHEAEEEEK02IgNFDQUgAyAFQTxqEMMtIAJBATYCwAEgAiADNgK8ASACQQE2ArgBIAIgBiABEPwiIAEgAhDNHCAIQaAFaiIDIAEQowggAkGgAmokACADEOspIQEgAEG8pYMBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILIAEgAhC9IiEFIwBBoAJrIgIkACACQbgBaiIBIAVBDGogAxDmEyACQdwAaiIGIgMgARDwPSABIAMQoRsgAkGUAmoiBCAFEMwGIAMgASAEEIwYQcQAQQQQrTYiA0UNBCADIAVBPGoQwy0gAkEBNgLAASACIAM2ArwBIAJBATYCuAEgAiAGIAEQ/CIgASACEM0cIAhBoAVqIgMgARChCCACQaACaiQAIAMQ6ykhASAAQZSmgwE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgACAIKQPIAjcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIACyAIQfAGaiQADwtB/K2DAUEoQYCygwEQnykACyACIAQoAogCQfyvgwEQ/S8AC0EEQcQAEKM9AAsgBiABKAIcQaCCgwEQ/S8AC0H8rYMBQShB3K+DARCfKQALQbSugwFBOEHsroMBEJ8pAAsgBiAEKAKAAUH8roMBEP0vAAtB9PmCAUEjQZj6ggEQyyQAC0G4+oIBQSkgBEH4AGpBsIKDAUHk+oIBENUeAAsgBEIANwKEASAEQoGAgIDAADcCfCAEQaj7ggE2AnhBACAEQewAaiAEQSRqIARB+ABqQbD7ggEQrysAC0EEQRwQoz0ACyABIAQoAoABQayvgwEQ/S8ACyACIAFBjK+DARCxOwALIAEgCUGMr4MBELA7AAtBwAAgAhCjPQALIAkgC0Hsr4MBEMMhAAsgBiACQbyvgwEQsTsACyACIAlBvK+DARCwOwALQfD0gwFBKSACQRxqQaz1gwFBnPWDARDVHgALIBanIAVByPWDARDDIQALIAVBAjYCCCAFQZiEhAE2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBUEcajYCKCAFIAU2AiAgBUEEakGohIQBEO8sAAtBCEHQABCjPQALIA0gDEG8tIIBEMMhAAv5gwECJ38BfiMAQYAHayIFJAACQCABKAIIIhAEQCAFIAEoAgQiDygCACISQRhqIhw2AiQgDyAQQQJ0aiEKQQEhBiAPIQsDQAJAIAhBAXEEQCAKIAtHDQEMBAsgBiAKIAtrQQJ2Tw0DIAsgBkECdGohCwsgBSALKAIAQRhqIgQ2AqgBIBwgBBDKCARAIAtBBGohC0EAIQZBASEIDAEFIAVCADcCxAMgBUKBgICAwAA3ArwDIAVBkJaHATYCuAMgBUEkaiAFQagBaiAFQbgDakGYlocBEKMrAAsACwALQQBBAEHwk4cBEMMhAAsgEEECdCEkQQAhCANAIAgiCyAkRwRAIAhBBGohCCALIA9qKAIAIgQoAixFDQEgBCgCQEUNAQsLIAUgAiALICRHcjoAKwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBAiADKAIAIgJB/////wdqIAJBgICAgHhNGw4FAgAFBQEFCyAcLQAAIgJBHWtBAkkgAkEbRnINAgwECyAFIAMoAgQiAjYCLCAFQbgDaiAcIAIQtAEMAgsgAygCBEUNAgJAAkAgHC0AAEEUaw4GAAQBBAABBAsgBSADKAIMIgI2AiwgAygCCCEEIAJBAnRBBGoiAkE8cSILBEAgAiACIAtrQUBrIgJLDQULIAJBwAAQ0TRFDQUCfyACRQRAIAVCwAA3AqQGIAVCwAA3AqwGIAVBpAZqQcAAEOgZIAUoAqwGIQggBSgCsAYMAQsgAkHAABCtNiIIRQ0HIAVBADYCsAYgBSAINgKsBiAFIAI2AqgGIAVBwAA2AqQGQQALIAhqQQA2AAAgBSAFKAKwBkEEajYCsAYgBUGwAWogBUGsBmopAgA3AwAgBSAFKQKkBjcDqAECQCAEQT9xIgJFBEAgBCECDAELIAQgAmtBQGsiAiAESQ0FC0HAACELIAJBwAAQ0TRFDQUgAgRAIAJBwAAQrTYiC0UNBwsgBUHAA2ogBUGwAWopAwA3AwAgBSAFKQOoATcDuAMgBUEANgLUAyAFIAs2AtADIAUgAjYCzAMgBUHAADYCyAMMAgsgBSADKAIMIgI2AiwgAygCCCEEIAJBA3RBCGoiAkE4cSILBEAgAiACIAtrQUBrIgJLDQQLIAJBwAAQ0TRFDQQCfyACRQRAIAVCwAA3AqQGIAVCwAA3AqwGIAVBpAZqQcAAEOgZIAUoAqwGIQggBSgCsAYMAQsgAkHAABCtNiIIRQ0GIAVBADYCsAYgBSAINgKsBiAFIAI2AqgGIAVBwAA2AqQGQQALIAhqQgA3AAAgBSAFKAKwBkEIajYCsAYgBUGwAWogBUGsBmopAgA3AwAgBSAFKQKkBjcDqAECQCAEQT9xIgJFBEAgBCECDAELIAQgAmtBQGsiAiAESQ0EC0HAACELIAJBwAAQ0TRFDQQgAgRAIAJBwAAQrTYiC0UNBgsgBUHAA2ogBUGwAWopAwA3AwAgBSAFKQOoATcDuAMgBUEANgLUAyAFIAs2AtADIAUgAjYCzAMgBUHAADYCyAMMAQsgBSADKAIEIgI2AiwgBUG4A2ogHCACELQBCyAFQThqIAVBwANqKQMANwMAIAVByABqIAVB0ANqKQMANwMAIAUgBSkDuAM3AzAgBSAFKQPIAzcDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgHC0AACICQRtJDQAgAkEcaw4NAQUHAQYCAwAAAAAHBAcLIAVBADYCWCAFQoCAgIDAADcCUAwMCyAFQQA2AsgDIAVBATYCvAMgBUG8kocBNgK4AyAFQgQ3AsADIAVBuANqQYCUhwEQ7ywACyAFIBJBHGooAgQ2AsgDIAVBADYCxAMgBSABNgK4AyAFIAVBLGo2AsADIAUgBUErajYCvAMjAEEgayICJAAgAkEUaiAFQbgDaiIIKAIQIgQgCCgCDGsiBkEAIAQgBk8bQQBBBEHMARCgGCACKAIYIQYgAigCFEEBRg0YIAJBEGoiG0EANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIHJAAgCCgCECIEIAgoAgxrIgZBACAEIAZPGyIGIAJBCGoiBCgCACAEKAIIIglrSwRAIAQgCSAGQQRBzAEQ3iggBCgCCCEJCyAFQdAAaiEWIAcgBCgCBDYCDCAHIAk2AgggByAEQQhqNgIEIwBB8AFrIgQkACAHQQRqIgkoAgQhBiAJKAIAIAgoAgwiDCAIKAIQIhNJBH8gCCgCCCEaIAgoAgQhHSAGIBNqIAxrIAkoAgggBkHMAWxqIRQgCCgCACEYA0AgBCAMNgLQASAYKAIIIQggBCAYKAIEIgY2AgQgBCAGIAhBAnRqNgIIIAQgBEHQAWo2AgwjAEEgayIIJAAgCEEUaiAEQQRqIgYoAgQgBigCAGtBAnZBAEEEQQQQoBggCCgCGCEJIAgoAhRBAUYEQAwZCyAIQRBqIh9BADYCACAIIAgoAhw2AgwgCCAJNgIIIwBBEGsiDSQAIAYoAgQgBigCAGtBAnYiFSAIQQhqIg4oAgAgDigCCCIJa0sEQCAOIAkgFUEEQQQQ3iggDigCCCEJCyAEQdQBaiEVIA0gDigCBDYCDCANIAk2AgggDSAOQQhqNgIEIA1BBGoiESgCBCEOIBEoAgAhIAJAAkAgBigCACIJIAYoAgQiF0cEQCAGKAIIISEgESgCCCAOQQJ0aiERIBcgCWtBAnYhFwNAICEoAgAiGSAJKAIAIiIoAhQiI08NAiARICIoAhAgGUHEAGxqNgIAIAlBBGohCSARQQRqIREgDkEBaiEOIBdBAWsiFw0ACwsgICAONgIADAELIBkgI0HciYcBEMMhAAsgDUEQaiQAIBVBCGogHygCADYCACAVIAgpAgg3AgAgCEEgaiQAIB0tAAAhCCAaKAIAIQkgBEGFgICAeDYC4AEgBCAJNgLkASAGIBUgCCAEQeABahCjASAUIAZBzAH8CgAAIBRBzAFqIRQgEyAMQQFqIgxHDQALBSAGCzYCACAEQfABaiQAIAdBEGokACAWQQhqIBsoAgA2AgAgFiACKQIINwIAIAJBIGokAAwKCyAFQQA2AlggBUKAgICAwAA3AlAMCQsgBUHsAGoiDSEHIwBBIGsiAiQAIAJBFGogCiAPa0ECdkEAQQRBBBCgGCACKAIYIQggAigCFEEBRg0TIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIJJAAgCiAPIgRrQQJ2IgYgAkEIaiIIKAIAIAgoAggiC2tLBEAgCCALIAZBBEEEEN4oIAgoAgghCwsgCSAIKAIENgIMIAkgCzYCCCAJIAhBCGo2AgQgCUEEaiILKAIEIQYgCygCACEMAkACQCAEIApHBEAgCygCCCAGQQJ0aiELIAogBGtBAnYhCANAIAQoAgAiFCgCFEUNAiALIBQoAhA2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCEEBayIIDQALCyAMIAY2AgAMAQtBAEEAQayJhwEQwyEACyAJQRBqJAAgB0EIaiAOKAIANgIAIAcgAikCCDcCACACQSBqJAAjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRMgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQfgAaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDAJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIhQoAhQiFUEBTQ0CIAsgFCgCEEHEAGo2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCEEBayIIDQALCyAMIAY2AgAMAQtBASAVQbyJhwEQwyEACyAJQRBqJAAgB0EIaiAOKAIANgIAIAcgAikCCDcCACACQSBqJABBmANBBBCtNiICRQ0DIAUoAiwhBCAFQYWAgIB4NgK4AyAFIAQ2ArwDIAVBqAFqIgQgDUEAIAVBuANqIgsQowEgBS0AKyEIIAUoAiwhBiAFQYWAgIB4NgKkBiAFIAY2AqgGIAsgByAIIAVBpAZqEKMBQQAiC0UEQCACIARBzAH8CgAACyACQcwBaiAFQbgDakHMAfwKAAAgBUECNgJYIAUgAjYCVCAFQQI2AlAMCAsjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRIgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQYQBaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDgJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIgwoAhRFDQIgCyAMKAIQNgIAIARBBGohBCALQQRqIQsgBkEBaiEGIAhBAWsiCA0ACwsgDiAGNgIADAELQQBBAEHMiYcBEMMhAAsgCUEQaiQAIAdBCGogDSgCADYCACAHIAIpAgg3AgAgAkEgaiQAIAMoAgBBgoCAgHhGDQUgEigCHCAFKAIsbCEIQYWAgIB4IQsMBgsgEkEcaiECIAMoAgAiC0GBgICAeE8EQCAFQRhqIAIQwzQgBSAFKAIcNgLIAyAFQQA2AsQDIAUgATYCuAMgBSAFQSxqNgLAAyAFIAVBK2o2ArwDIwBBIGsiAiQAIAJBFGogBUG4A2oiCCgCECIEIAgoAgxrIgZBACAEIAZPG0EAQQRBzAEQoBggAigCGCEGIAIoAhRBAUYNFSACQRBqIhtBADYCACACIAIoAhw2AgwgAiAGNgIIIwBBEGsiByQAIAgoAhAiBCAIKAIMayIGQQAgBCAGTxsiBiACQQhqIgQoAgAgBCgCCCIJa0sEQCAEIAkgBkEEQcwBEN4oIAQoAgghCQsgBUHQAGohFiAHIAQoAgQ2AgwgByAJNgIIIAcgBEEIajYCBCMAQfABayIEJAAgB0EEaiIJKAIEIQYgCSgCACAIKAIMIgwgCCgCECITSQR/IAgoAgghGiAIKAIEIR0gBiATaiAMayAJKAIIIAZBzAFsaiEUIAgoAgAhGANAIAQgDDYC0AEgGCgCCCEIIAQgGCgCBCIGNgIEIAQgBiAIQQJ0ajYCCCAEIARB0AFqNgIMIwBBIGsiCCQAIAhBFGogBEEEaiIGKAIEIAYoAgBrQQJ2QQBBBEEEEKAYIAgoAhghCSAIKAIUQQFGBEAMFgsgCEEQaiIfQQA2AgAgCCAIKAIcNgIMIAggCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhUgCEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBVBBEEEEN4oIA4oAgghCQsgBEHUAWohFSANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhEoAgQhDiARKAIAISACQAJAIAYoAgAiCSAGKAIEIhdHBEAgBigCCCEhIBEoAgggDkECdGohESAXIAlrQQJ2IRcDQCAhKAIAIhkgCSgCACIiKAIUIiNPDQIgESAiKAIQIBlBxABsajYCACAJQQRqIQkgEUEEaiERIA5BAWohDiAXQQFrIhcNAAsLICAgDjYCAAwBCyAZICNBnImHARDDIQALIA1BEGokACAVQQhqIB8oAgA2AgAgFSAIKQIINwIAIAhBIGokACAdLQAAIQggGigCACEJIARBhYCAgHg2AuABIAQgCTYC5AEgBiAVIAggBEHgAWoQowEgFCAGQcwB/AoAACAUQcwBaiEUIBMgDEEBaiIMRw0ACwUgBgs2AgAgBEHwAWokACAHQRBqJAAgFkEIaiAbKAIANgIAIBYgAikCCDcCACACQSBqJAAMBwsgAygCDCEEIAtBgICAgHhHBEAgBSAENgIsIAVBEGogAhDDNCADKAIIIQIgAygCBCELIAUgBSgCFCIENgLEAyAFQQA2AsADIAUgATYC0AMgBUEANgLIAyAFIAs2ArgDIAUgAiAEIAIgBEkbNgLMAyAFIAsgAkEEdGo2ArwDIAUgBUErajYC1AMjAEEgayICJAAgAkEUaiAFQbgDaiIEKAIUIAQoAhBrQQBBBEHMARCgGCACKAIYIQYgAigCFEEBRg0VIAJBEGoiGkEANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIHJAAgBCgCFCAEKAIQayIGIAJBCGoiCCgCACAIKAIIIglrSwRAIAggCSAGQQRBzAEQ3iggCCgCCCEJCyAFQdAAaiETIAcgCCgCBDYCDCAHIAk2AgggByAIQQhqNgIEIwBB8AFrIggkACAHQQRqIg0oAgQhCSANKAIAIAQoAhQiDiAEKAIQIgZHBH8gDiAGayEYIAQoAhwhHSAJIA5qIAZrIAQoAgggBmohDCANKAIIIAlBzAFsaiEUIAQoAgAgBkEEdGohFSAEKAIYIRcDQCAIIAw2AtABIBcoAgghBCAIIBcoAgQiBjYCBCAIIAYgBEECdGo2AgggCCAIQdABajYCDCMAQSBrIgQkACAEQRRqIAhBBGoiBigCBCAGKAIAa0ECdkEAQQRBBBCgGCAEKAIYIQkgBCgCFEEBRgRAIAkgBCgCHEG8hYcBEP0vAAsgBEEQaiIfQQA2AgAgBCAEKAIcNgIMIAQgCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhEgBEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBFBBEEEEN4oIA4oAgghCQsgCEHUAWohESANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhYoAgQhDiAWKAIAISACQAJAIAYoAgAiCSAGKAIEIhlHBEAgBigCCCEhIBYoAgggDkECdGohFiAZIAlrQQJ2IRkDQCAhKAIAIhsgCSgCACIiKAIUIiNPDQIgFiAiKAIQIBtBxABsajYCACAJQQRqIQkgFkEEaiEWIA5BAWohDiAZQQFrIhkNAAsLICAgDjYCAAwBCyAbICNB/IiHARDDIQALIA1BEGokACARQQhqIB8oAgA2AgAgESAEKQIINwIAIARBIGokACAdLQAAIQQgCEHgAWoiCSAVEMYQIAYgESAEIAkQowEgFCAGQcwB/AoAACAUQcwBaiEUIAxBAWohDCAVQRBqIRUgGEEBayIYDQALBSAJCzYCACAIQfABaiQAIAdBEGokACATQQhqIBooAgA2AgAgEyACKQIINwIAIAJBIGokAAwHCyAFIAQ2AiwgBSAENgJoIAVBCGogAhDDNCAFIAUoAgw2AsgDIAVBADYCxAMgBSABNgK4AyAFIAVB6ABqNgLAAyAFIAVBK2o2ArwDIwBBIGsiAiQAIAJBFGogBUG4A2oiCCgCECIEIAgoAgxrIgZBACAEIAZPG0EAQQRBzAEQoBggAigCGCEGIAIoAhRBAUYNFCACQRBqIhtBADYCACACIAIoAhw2AgwgAiAGNgIIIwBBEGsiByQAIAgoAhAiBCAIKAIMayIGQQAgBCAGTxsiBiACQQhqIgQoAgAgBCgCCCIJa0sEQCAEIAkgBkEEQcwBEN4oIAQoAgghCQsgBUHQAGohFiAHIAQoAgQ2AgwgByAJNgIIIAcgBEEIajYCBCMAQfABayIEJAAgB0EEaiIJKAIEIQYgCSgCACAIKAIMIgwgCCgCECITSQR/IAgoAgghGiAIKAIEIR0gBiATaiAMayAJKAIIIAZBzAFsaiEUIAgoAgAhGANAIAQgDDYC0AEgGCgCCCEIIAQgGCgCBCIGNgIEIAQgBiAIQQJ0ajYCCCAEIARB0AFqNgIMIwBBIGsiCCQAIAhBFGogBEEEaiIGKAIEIAYoAgBrQQJ2QQBBBEEEEKAYIAgoAhghCSAIKAIUQQFGBEAMFQsgCEEQaiIfQQA2AgAgCCAIKAIcNgIMIAggCTYCCCMAQRBrIg0kACAGKAIEIAYoAgBrQQJ2IhUgCEEIaiIOKAIAIA4oAggiCWtLBEAgDiAJIBVBBEEEEN4oIA4oAgghCQsgBEHUAWohFSANIA4oAgQ2AgwgDSAJNgIIIA0gDkEIajYCBCANQQRqIhEoAgQhDiARKAIAISACQAJAIAYoAgAiCSAGKAIEIhdHBEAgBigCCCEhIBEoAgggDkECdGohESAXIAlrQQJ2IRcDQCAhKAIAIhkgCSgCACIiKAIUIiNPDQIgESAiKAIQIBlBxABsajYCACAJQQRqIQkgEUEEaiERIA5BAWohDiAXQQFrIhcNAAsLICAgDjYCAAwBCyAZICNBjImHARDDIQALIA1BEGokACAVQQhqIB8oAgA2AgAgFSAIKQIINwIAIAhBIGokACAdLQAAIQggGigCACEJIARBhYCAgHg2AuABIAQgCTYC5AEgBiAVIAggBEHgAWoQowEgFCAGQcwB/AoAACAUQcwBaiEUIBMgDEEBaiIMRw0ACwUgBgs2AgAgBEHwAWokACAHQRBqJAAgFkEIaiAbKAIANgIAIBYgAikCCDcCACACQSBqJAAMBgsjAEEgayICJAAgAkEUaiAKIA9rQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGDRAgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIgkkACAKIA8iBGtBAnYiBiACQQhqIggoAgAgCCgCCCILa0sEQCAIIAsgBkEEQQQQ3iggCCgCCCELCyAFQdwAaiEHIAkgCCgCBDYCDCAJIAs2AgggCSAIQQhqNgIEIAlBBGoiCygCBCEGIAsoAgAhDgJAAkAgBCAKRwRAIAsoAgggBkECdGohCyAKIARrQQJ2IQgDQCAEKAIAIgwoAhRFDQIgCyAMKAIQNgIAIARBBGohBCALQQRqIQsgBkEBaiEGIAhBAWsiCA0ACwsgDiAGNgIADAELQQBBAEHsiIcBEMMhAAsgCUEQaiQAIAdBCGogDSgCADYCACAHIAIpAgg3AgAgAkEgaiQAIAMoAgBBgoCAgHhGDQFBhYCAgHghCCAFKAIsIQsMAgtBBEGYAxCjPQALIAMoAgQhCwJAIANBCGoQmhQiBEUNACAEKQIIISsgBCgCBCAEKAIAIQggBEEQQQQQ+DogBUGFgICAeDYCuAMgBSALNgK8AyAIQYaAgIB4Rg0AIAVBuANqENIaIQsMAQtBhYCAgHghCCAFKQLAAyErC0HMAUEEEK02IgIEQCAFICs3ArABIAUgCzYCrAEgBSAINgKoASAFQbgDaiIEIAVB3ABqIAUtACsgBUGoAWoQowEgAiAEQcwB/AoAACAFQQE2AlggBSACNgJUIAVBATYCUAwDC0EEQcwBEKM9AAsgAygCBCEIAkAgA0EIahCaFCIERQRAIBIoAhwgCGwhCAwBCyAEKQIIISsgBCgCBCAEKAIAIQsgBEEQQQQQ+DogBUGFgICAeDYCuAMgBSASKAIcIAhsIgg2ArwDIAtBhoCAgHhGDQAgBUG4A2oQ0hohCAwBC0GFgICAeCELIAUpAsADISsLQcwBQQQQrTYiAkUNASAFICs3ArABIAUgCDYCrAEgBSALNgKoASAFQbgDaiIEIAVBhAFqIAUtACsgBUGoAWoQowEgAiAEQcwB/AoAACAFQQE2AlggBSACNgJUIAVBATYCUAtBACEGAkAgHC0AAEEiRwRAQYCAgIB4IQgMAQsgEEEBaiECIA8hBAJAAkADQCACQQFrIgJBAkkNASAEKAIAIgsoAhRFDQUgBEEEaiIEKAIAIggoAhRFDQYgCygCECAIKAIQEKIRDQALIAMoAgBBhICAgHhHDQEgBUEANgLIAyAFQQE2ArwDIAVByJSHATYCuAMgBUIENwLAAyAFQbgDakHQlIcBEO8sAAsgDygCACICKAIUBEAgBUGkBmogAigCECICQRhqENwGIAIoAighJiACKAIkISQgBUGoAWogAhC+FSAFQbgDaiACQQxqEIALIAIoAiwiCwRAIAsgCygCACIEQQFqNgIAIARBAEgNByACKAIwIScgAigCQCEoIAIoAjwhKSACKAI4ISogAigCNCElCyAFQZAGaiAFQawGaigCADYCACAFQaAGaiAFQcADaigCADYCACAFIAUpAqQGNwOIBiAFIAUpArgDNwOYBiAFKAKoASEIIAUpAqwBISsMAgtBAEEAQZCUhwEQwyEACyMAQSBrIgIkACACQRRqIAogD2tBAnZBAEEEQQQQoBggAigCGCEIIAIoAhRBAUYNCyACQRBqIg1BADYCACACIAIoAhw2AgwgAiAINgIIIwBBEGsiCCQAIAogDyIEa0ECdiIJIAJBCGoiBigCACAGKAIIIgtrSwRAIAYgCyAJQQRBBBDeKCAGKAIIIQsLIAVBkAFqIQcgCCAGKAIENgIMIAggCzYCCCAIIAZBCGo2AgQgCEEEaiILKAIEIQYgCygCACEOAkACQCAEIApHBEAgCygCCCAGQQJ0aiELIAogBGtBAnYhCQNAIAQoAgAiDCgCFEUNAiALIAwoAhA2AgAgBEEEaiEEIAtBBGohCyAGQQFqIQYgCUEBayIJDQALCyAOIAY2AgAMAQtBAEEAQeyJhwEQwyEACyAIQRBqJAAgB0EIaiANKAIANgIAIAcgAikCCDcCACACQSBqJAAgBSgClAEiAiEEIAIgBSgCmAFBAnRqIQkjAEEgayICJAAgAkEUaiAJIARrQQJ2IgdBAEEEQQQQoBggAigCGCEGIAIoAhRBAUYNDiACQRBqIg1BADYCACACIAIoAhw2AgwgAiAGNgIIIAJBCGoiCygCACALKAIIIghrIAdJBEAgCyAIIAdBBEEEEN4oIAsoAgghCAsgBUGcAWohBiALIAQgCUcEfyAHIAhqIAsoAgQgCEECdGohCANAIAggBCgCACgCJDYCACAEQQRqIQQgCEEEaiEIIAdBAWsiBw0ACwUgCAs2AgggBkEIaiANKAIANgIAIAYgAikCCDcCACACQSBqJABBACECIAUoAqQBIgsEQCAFKAKgASEEA0AgBCgCACACaiECIARBBGohBCALQQFrIgsNAAsLIAVBhYCAgHg2ArgDIAUgAjYCvAMgBUGoAWogBUGQAWpBACAFQbgDahCjASAFKAKkASICBEAgBSgCoAEhBCACQQJ0IQtBACECA0AgBUGoAWogAkEAIAQoAgAQ2BsgAkEBaiECIARBBGohBCALQQRrIgsNAAsLIAVBuANqIgIgBUGoAWpBzAH8CgAAIAVBpAZqIgQgAhDZASAFQfQCaiAEEM0cIAVBoAZqIAVBiANqKAIANgIAIAVBkAZqIAVBlANqKAIANgIAIAUgBSkCgAM3A5gGIAUgBSkCjAM3A4gGIAUoAvQCIQggBSkC+AIhKyAFKAKYAyEkIAUoApwDISYgBSgCoAMhCyAFKAKkAyEnIAUoAqgDISUgBSgCrAMhKiAFKAKwAyEpIAUoArQDISggBUGcAWpBBEEEEOAeQQEhBgsgBSAGOgD0AgJAAkACQCAcLQAAIgRBF2sOBAEAAAEACyAFQQA2ArABIAVCgICAgMAANwKoAQwBCyAFQQA2AswDIAVBADYCwAMgBSAKNgK8AyAFIA82ArgDIAVBqAFqIRUjAEEwayIMJAAgBUG4A2oiBigCDCEOIAYoAhAhCSAGKAIEIQ0gBigCACECIAYoAgghBwJAAkACQAJAAkACQAJAAkADQCAHBEACQCAJRQRAIAcgDkYNASAGIAdBDGoiAjYCCEEAIQkMBgsgBkEANgIQIAkgDiAHa0EMbkkNAwsgBkEANgIIQQAhCQsgAkUgAiANRnJFBEBBASEJIAZBATYCECAGIAJBBGoiBDYCACAGIAIoAgAiAigCBCIHNgIIIAYgByACKAIIQQxsaiIONgIMIAQhAgwBCwsgBigCFCICRQ0DAkAgBigCHCINRQRAQQAgAkEMaiACIAYoAhhGIgcbIQRBACACIAcbIQcMAQtBACEEIAZBADYCHEEAIQcgDSAGKAIYIAJrQQxuTw0AIAIgDUEMbGoiB0EMaiEECyAGIAQ2AhRBACECDAELIAYgByAJQQxsaiIHQQxqIgI2AghBACEJCyAHRQ0BCyAHKAIAIgQgBCgCACINQQFqNgIAIA1BAEgNAiAHKAIIIRAgBygCBCEHIAxBEGoiDUEDIAIEfyAOIAJrQQxuIgIgCWsiCUEAIAIgCU8bBUEACyAGKAIUIgIEfyAGKAIYIAJrQQxuIgIgBigCHGsiCUEAIAIgCU8bBUEAC2oiAiACQQNNG0EBakEAQQRBDBCgGCAMKAIUIQkgDCgCEEEBRg0DIAwoAhgiAiAQNgIIIAIgBzYCBCACIAQ2AgAgDEEMaiIYQQE2AgAgDCACNgIIIAwgCTYCBCAMQShqIAZBGGopAgA3AwAgDEEgaiAGQRBqKQIANwMAIAxBGGogBkEIaikCADcDACAMIAYpAgA3AxAgDEEEaiEQIA0oAhwhFCANKAIUIQIgDSgCGCEWIA0oAgwhESANKAIQIQ4gDSgCACEHIA0oAgghBiANKAIEIRcCQANAAkACQAJAIAYEQAJAIA5FBEAgBiARRg0BIA0gBkEMaiIJNgIIQQAhDiACIQQMBQsgDUEANgIQIA4gESAGa0EMbkkNAgsgDUEANgIIQQAhDgsgB0UgByAXRnJFBEBBASEOIA1BATYCECANIAdBBGoiBDYCACANIAcoAgAiCSgCBCIGNgIIIA0gBiAJKAIIQQxsaiIRNgIMIAQhBwwECyACRQ0EAkAgFEUEQEEAIAJBDGogAiAWRiIGGyEEQQAgAiAGGyEGDAELQQAhBCANQQA2AhxBACEGIBQgFiACa0EMbk8NACACIBRBDGxqIgZBDGohBAsgDSAENgIUQQAhFEEAIQkMAQsgDSAGIA5BDGxqIgZBDGoiCTYCCEEAIQ4gAiEECyAGRQ0CCyAGKAIAIhMgEygCACICQQFqNgIAIAJBAE4EQCAGKAIIIRkgBigCBCEbIBAoAggiBiAQKAIARgRAQQEhAiAJBEAgESAJa0EMbiICIA5rIhpBACACIBpPG0EBaiECCyAQIAYgBAR/IBYgBGtBDG4iGiAUayIdQQAgGiAdTxsFQQALIAJqQQRBDBDeKAsgECgCBCAGQQxsaiICIBk2AgggAiAbNgIEIAIgEzYCACAQIAZBAWo2AgggBCECIAkhBgwBCwsACyAVQQhqIBgoAgA2AgAgFSAMKQIENwIADAELIBVBADYCCCAVQoCAgIDAADcCAAsgDEEwaiQADAILAAsgCSAMKAIYQdiLhwEQ/S8ACyAcLQAAIQQLQYAcIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBEH/AXFBAWsOKAABAgMLBAUGBwgJCgsDCwMLCwwNDg8QDQ8QERITFBIVFhoDCxcYERkgC0GBHCECDB8LQYIcIQIMHgtBgxwhAgwdC0GEHCECDBwLQYIcIQIMGwtBgxwhAgwaC0GEHCECDBkLQYUcIQIMGAtBgxwhAgwXC0GEHCECDBYLQYUcIQIMFQtBhRwhAgwUCyASLQAZQQJ0QdyXhwFqKAIAIQIMEwtBhhwhAgwSC0GHHCECDBELQYgcIQIMEAtBiRwhAgwPC0GGHCECDA4LIAVBADYCyAMgBUEBNgK8AyAFQbyShwE2ArgDIAVCBDcCwAMgBUG4A2pBuJOHARDvLAALQYocIQIMDAtBiBwhAgwLC0GLHCECDAoLQYwcQY0cIBItABkbIQIMCQtBiRwhAgwIC0GOHCECDAcLQY8cIQIMBgsgEigCHC0AAEECayICQf8BcUEISQ0EQcSQhwFBKEHIk4cBEJ8pAAtBBEHMARCjPQALQQBBAEGolocBEMMhAAtBAEEAQbiWhwEQwyELAAsgAkH/AXFBAnRB6JeHAWooAgAhAgtBBEEEEK02IhVFBEAMBwsgFSACNgIAIAUgCjYCvAMgBSAPNgK4AyAFIAVBK2o2AsADIwBBIGsiAiQAIAJBFGogBUG4A2oiBCgCBCAEKAIAa0ECdkEAQQRBCBCgGCACKAIYIQYgAigCFEEBRgRADAgLIAJBEGoiFEEANgIAIAIgAigCHDYCDCACIAY2AggjAEEQayIGJAAgBCgCBCAEKAIAa0ECdiINIAJBCGoiBygCACAHKAIIIglrSwRAIAcgCSANQQRBCBDeKCAHKAIIIQkLIAVBhAVqIRIgBiAHKAIENgIMIAYgCTYCCCAGIAdBCGo2AgQjAEEQayIOJAAgBkEEaiINKAIEIQkgDSgCACAEKAIAIgcgBCgCBCIQRwRAIAQoAgghFiANKAIIIAlBA3RqIQwgCSAQIAdrQQJ2IhBqIQkDQCAHKAIAIQQgFi0AACETIwBBEGsiDSQAAkAgDkEIaiIYAn8gBCgCLARAIA1BCGogBEEsaiITENw7IA0oAgwhFyANKAIIIRlBDEEEEK02IgRFDQ0gBCATNgIIIAQgGTYCACAEIBc2AgRB/I+HAQwBC0EBIQRBrJCHAUGUkIcBIBMbCzYCBCAYIAQ2AgAgDUEQaiQADAALIAwgDikDCDcCACAHQQRqIQcgDEEIaiEMIBBBAWsiEA0ACwsgCTYCACAOQRBqJAAgBkEQaiQAIBJBCGogFCgCADYCACASIAIpAgg3AgAgAkEgaiQAAkAgBS0AK0UEQCAFQQA2ApAFDAELIAVBkAVqIAUoAiwiAkEDdiACQQdxQQBHahDSHwsCQAJAAkACQAJAAkAgHC0AACICQRdrDgQCAQECAAsgAkEiRg0CCyMAQSBrIg0kACANQRRqIAogD2tBAnZBAEEEQQgQoBggDSgCGCECIA0oAhRBAUYEQCACIA0oAhxB2IuHARD9LwALIA1BEGoiGUEANgIAIA0gDSgCHDYCDCANIAI2AggjAEEQayIOJAAgCiAPa0ECdiIEIA1BCGoiAigCACACKAIIIgdrSwRAIAIgByAEQQRBCBDeKCACKAIIIQcLIA4gAigCBDYCDCAOIAc2AgggDiACQQhqNgIEIwBBEGsiFCQAIA5BBGoiAigCBCEGIAIoAgAgCiAPRwRAIAIoAgggBkEDdGohCSAGIAogD2tBAnYiEWohBgNAIBRBCGohFiAPKAIAIQpBACETIwBBgAJrIgckAEG4p4cBIQJBASEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKLQAYQQFrDigAAQIDBAUGBwgJCgsfHh8eHx8MDQ4PEA0PEBESExQSFR0WFxgZGhEbIAsgB0EIaiEMIwBBEGsiAiQAAkAgCigCCARAIAJBCGogCigCBBDcOyACKAIMIRIgAigCCCEQQQxBBBCtNiIERQ0yIAQgCjYCCCAEIBA2AgAgBCASNgIEIAxBzKCHATYCBCAMIAQ2AgAgAkEQaiQADAELQQBBAEG8oIcBEMMhAAsgBygCDCECIAcoAgghBAwfCyMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNHyAEIAw2AgAgBCAKNgIEIAdBEGoiCkGsmocBNgIEIAogBDYCACACQRBqJAAgBygCFCECIAcoAhAhBAweCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNHiAEIAw2AgAgBCAKNgIEIAdBGGoiCkHEmocBNgIEIAogBDYCACACQRBqJAAgBygCHCECIAcoAhghBAwdCyAHQSBqIAoQ/CMgBygCJCECIAcoAiAhBAwcCyAHQShqIAoQ+yMgBygCLCECIAcoAighBAwbCyMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNGyAEIAw2AgAgBCAKNgIEIAdBMGoiCkGUmocBNgIEIAogBDYCACACQRBqJAAgBygCNCECIAcoAjAhBAwaCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNGiAEIAw2AgAgBCAKNgIEIAdBOGoiCkGcmYcBNgIEIAogBDYCACACQRBqJAAgBygCPCECIAcoAjghBAwZCyMAQRBrIgIkACACQQhqIApBABDnHSACKAIMIQogAigCCCEMQQhBBBCtNiIERQ0ZIAQgDDYCACAEIAo2AgQgB0FAayIKQeyYhwE2AgQgCiAENgIAIAJBEGokACAHKAJEIQIgBygCQCEEDBgLIwBBEGsiAiQAIAJBCGogChDlHSACKAIMIQogAigCCCEMQQhBBBCtNiIERQ0YIAQgDDYCACAEIAo2AgQgB0HIAGoiCkHkmYcBNgIEIAogBDYCACACQRBqJAAgBygCTCECIAcoAkghBAwXCyMAQRBrIgIkACACQQhqIAoQ5B0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNFyAEIAw2AgAgBCAKNgIEIAdB0ABqIgpB3JqHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAlQhAiAHKAJQIQQMFgsjAEEQayICJAAgAkEIaiAKQQAQ5x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNFiAEIAw2AgAgBCAKNgIEIAdB2ABqIgpBvJiHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAlwhAiAHKAJYIQQMFQsjAEEQayICJAAgAkEIaiAKEOMdIAIoAgwhCiACKAIIIQxBCEEEEK02IgRFDRUgBCAMNgIAIAQgCjYCBCAHQeAAaiIKQfyZhwE2AgQgCiAENgIAIAJBEGokACAHKAJkIQIgBygCYCEEDBQLIAotABlBAWsOAhIPEQsgB0GAAWohDCMAQRBrIgIkACACQQhqIApBABDnHQJAAkAgCigCCCIEQQJPBEAgAigCDCESIAIoAgghECACIAooAgRBDGoQ3DsgAigCBCEKIAIoAgAhE0EQQQQQrTYiBEUNASAEIBM2AgggBCAQNgIAIAQgCjYCDCAEIBI2AgQgDEHEo4cBNgIEIAwgBDYCACACQRBqJAAMAgtBASAEQbSjhwEQwyEAC0EEQRAQoz0ACyAHKAKEASECIAcoAoABIQQMEgsgB0GIAWohDCMAQRBrIgIkAAJAAkAgCi0AGEEVRgRAIAooAggEQCAKKAIcIRIgAkEIaiAKKAIEENw7IAIoAgwiECASIAooAihsIgpJDQIgAigCCCETQQxBBBCtNiIERQ0mIAQgEjYCCCAEIBAgCms2AgQgBCAKIBNqNgIAIAxBhKGHATYCBCAMIAQ2AgAgAkEQaiQADAMLQQBBAEHkoIcBEMMhAAtBnKGHAUEoQcShhwEQnykACyAKIBBB9KCHARCvOwALIAcoAowBIQIgBygCiAEhBAwRCyAHQZABaiEMIwBBEGsiAiQAIAJBCGogChDjHQJAAkAgCigCCCIEQQJPBEAgAigCDCESIAIoAgghECACIAooAgRBDGoQ3DsgAigCBCEKIAIoAgAhE0EQQQQQrTYiBEUNASAEIBM2AgggBCAQNgIAIAQgCjYCDCAEIBI2AgQgDEHco4cBNgIEIAwgBDYCACACQRBqJAAMAgtBASAEQbSjhwEQwyEAC0EEQRAQoz0ACyAHKAKUASECIAcoApABIQQMEAsgB0EANgL4ASAHQQE2AuwBIAdB7JGHATYC6AEgB0IENwLwASAHQegBakH0kYcBEO8sAAsjAEEQayICJAAgAkEIaiAKQQAQ5x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNDyAEIAw2AgAgBCAKNgIEIAdBmAFqIgpBjKKHATYCBCAKIAQ2AgAgAkEQaiQAIAcoApwBIQIgBygCmAEhBAwOCyAHQQA2AvgBIAdBATYC7AEgB0G8kocBNgLoASAHQgQ3AvABIAdB6AFqQcSShwEQ7ywACyAHQaABaiECAkAgCi0AGEEdRgRAIAooAhwhCkEEQQQQrTYiBEUNHSAEIAo2AgAgAkGAp4cBNgIEIAIgBDYCAAwBC0HIpocBQShBmKeHARCfKQALIAcoAqQBIQIgBygCoAEhBAwMCyMAQRBrIgIkACACQQhqIAoQ4x0gAigCDCEKIAIoAgghDEEIQQQQrTYiBEUNDCAEIAw2AgAgBCAKNgIEIAdBqAFqIgpB9KGHATYCBCAKIAQ2AgAgAkEQaiQAIAcoAqwBIQIgBygCqAEhBAwLC0HQp4cBIQIMCgsgB0EANgL4ASAHQQE2AuwBIAdBoJOHATYC6AEgB0IENwLwASAHQegBakGok4cBEO8sAAsgB0HAAWogChD8IyAHKALEASECIAcoAsABIQQMCAsgB0HIAWogChD7IyAHKALMASECIAcoAsgBIQQMBwsgB0HQAWogChD9IyAHKALUASECIAcoAtABIQQMBgsjAEEQayIMJAAgDEEIaiEYIwBBEGsiEiQAAkACQCAKKAIIIgIEQCAKKAIEIQIjAEEQayIQJAAgEEEIaiACENw7QRAhFwJAIBAoAgwiBCAQKAIIIhpBEBD4LyICSQRAIAQhAkEAIQQMAQsgAiAaaiEXIAQgAmsiE0EfcSEEIBNBBXYhEwsgAiAEcgRAQbSlhwFBOEHspYcBEJ8pAAsgEkEIaiICIBM2AgQgAiAXNgIAIBBBEGokACASKAIMIgQgCigCKCICSQ0BIBIoAgghCiAYIAQgAms2AgQgGCAKIAJBBXRqNgIAIBJBEGokAAwCC0EAIAJBsOSGARDDIQALIAIgBEHA5IYBEK87AAsgDCgCDCEEIAwoAgghCkEIQQQQrTYiAkUNBiACIAo2AgAgAiAENgIEIAdB2AFqIgRBtJmHATYCBCAEIAI2AgAgDEEQaiQAIAcoAtwBIQIgBygC2AEhBAwFC0EEQQQQrTYiAkUEQAwUCyACIAo2AgAgB0HgAWoiBEHsuIcBNgIEIAQgAjYCACAHKALkASECIAcoAuABIQQMBAsgB0H4AGogChD9IyAHKAJ8IQIgBygCeCEEDAMLIAotABlFBEAjAEEQayICJAAgAkEIaiAKENIeIAIoAgwhCiACKAIIIQxBCEEEEK02IgRFDQQgBCAMNgIAIAQgCjYCBCAHQbgBaiIKQeinhwE2AgQgCiAENgIAIAJBEGokACAHKAK8ASECIAcoArgBIQQMAwsgB0GwAWohDCMAQRBrIgIkACACQQhqIAoQ0h4gAigCDCESIAIoAgghECACIApBARDnHQJAAkAgCi0AGEEhRgRAIAIoAgQhEyACKAIAIRhBFEEEEK02IgRFDQEgBCAYNgIMIAQgEDYCACAEIBM2AhAgBCAKQRxqNgIIIAQgEjYCBCAMQZCohwE2AgQgDCAENgIAIAJBEGokAAwCC0HIpocBQShBqKiHARCfKQALQQRBFBCjPQALIAcoArQBIQIgBygCsAEhBAwCCyAHQfAAaiAKEPwjIAcoAnQhAiAHKAJwIQQMAQsgB0HoAGogChD7IyAHKAJsIQIgBygCaCEECyAWIAQ2AgAgFiACNgIEIAdBgAJqJAAMAQtBBEEIEKM9AAsgCSAUKQMINwIAIA9BBGohDyAJQQhqIQkgEUEBayIRDQALCyAGNgIAIBRBEGokACAOQRBqJAAgBUGgBWoiAkEIaiAZKAIANgIAIAIgDSkCCDcCACANQSBqJAAMAgsgBUEANgKkBiAFIAo2ArwDIAUgDzYCuAMgBSAFQaQGajYCwAMjAEEgayICJAAgAkEUaiAFQbgDaiIEKAIEIAQoAgBrQQJ2QQBBBEEIEKAYIAIoAhghBiACKAIUQQFGDQogAkEQaiIUQQA2AgAgAiACKAIcNgIMIAIgBjYCCCMAQRBrIg8kACAEKAIEIAQoAgBrQQJ2IgcgAkEIaiIJKAIAIAkoAggiBmtLBEAgCSAGIAdBBEEIEN4oIAkoAgghBgsgBUGgBWohDiAPIAkoAgQ2AgwgDyAGNgIIIA8gCUEIajYCBCMAQRBrIgokACAPQQRqIgcoAgQhBiAHKAIAIRECQAJAIAQoAgAiCSAEKAIEIhJHBEAgBCgCCCEMIAcoAgggBkEDdGohDSASIAlrQQJ2IRIDQCAMKAIAIhAgCSgCACIHKAIIQQFraiIEIBBJDQIgDCAENgIAIwBBEGsiBCQAIARBCGogBxDmHSAEKAIMIRYgBCgCCCETQQxBBBCtNiIHRQRADBALIAcgEDYCCCAHIBM2AgAgByAWNgIEIApBCGoiEEH8kIcBNgIEIBAgBzYCACAEQRBqJAAgDSAKKQMINwIAIAlBBGohCSANQQhqIQ0gBkEBaiEGIBJBAWsiEg0ACwsgESAGNgIAIApBEGokAAwBC0GMiocBQRpBqIqHARDLJAALIA9BEGokACAOQQhqIBQoAgA2AgAgDiACKQIINwIAIAJBIGokAAwBCyAFQQA2AqQGIAUgCjYCvAMgBSAPNgK4AyAFIAVB9AJqNgLEAyAFIAVBpAZqNgLAAyAFQawFaiEGIwBBQGoiBCQAIARBk4CAgHg2AgggBEEwaiAFQbgDaiICQQhqKQIANwMAIAQgAikCADcDKCAEIARBCGo2AjggBEEcaiEJIwBBMGsiAiQAIAIgBEEoaiIPEIwoAkACQAJAIAIoAgAiDgRAIAIoAgQhDCACQRhqIg1BBEEAQQRBCBCgGCACKAIcIQcgAigCGEEBRg0CIAIoAiAiCiAMNgIEIAogDjYCACACQRRqIhJBATYCACACIAo2AhAgAiAHNgIMIAJBKGogD0EQaigCADYCACACQSBqIA9BCGopAgA3AwAgAiAPKQIANwMYIwBBEGsiDyQAIA9BCGogDRCMKCAPKAIIIgwEQCACQQxqIQcgDygCDCEOA0AgBygCCCIKIAcoAgBGBEAgByAKQQFBBEEIEN4oCyAHKAIEIApBA3RqIhAgDjYCBCAQIAw2AgAgByAKQQFqNgIIIA8gDRCMKCAPKAIEIQ4gDygCACIMDQALCyAPQRBqJAAgCUEIaiASKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAJBMGokAAwBCyAHIAIoAiBB2MOHARD9LwALAkAgBCgCCEGTgICAeEcEQCAGIAQpAgg3AgAgBkEQaiAEQRhqKAIANgIAIAZBCGogBEEQaikCADcCACAJEIEjIAlBBEEIEOAeDAELIAYgBCkCHDcCBCAGQZOAgIB4NgIAIAZBDGogBEEkaigCADYCAAsgBEFAayQAIAUoAqwFQZOAgIB4Rw0BIAVBqAVqIAVBuAVqKAIANgIAIAUgBSkCsAU3A6AFCyAFQfwFaiAcENwGIAVB6AVqIAVB2ABqKAIANgIAIAVB9AVqIAVBmAVqKQIANwIAIAVByAVqIAVBOGopAwA3AwAgBUHYBWogBUHIAGopAwA3AwAgAEHkAGogBUGwAWooAgA2AgAgACAFKQKoATcCXCAFIAUpAlA3A+AFIAUgBSkCkAU3AuwFIAUgBSkDMDcDwAUgBSAFKQNANwPQBSAAQQhqIAFBCGooAgA2AgAgACABKQIANwIAIABBDGogBUHABWpByAD8CgAAIAAgKzcChAEgACAINgKAASAAQgA3AlQgACAoNgLAASAAICk2ArwBIAAgKjYCuAEgACAlNgK0ASAAICc2ArABIAAgCzYCrAEgACAmNgKoASAAICQ2AqQBIAAgBSkDmAY3AowBIABBlAFqIAVBoAZqKAIANgIAIAAgBSkDiAY3ApgBIABBoAFqIAVBkAZqKAIANgIAIABB2JOHATYCyAEgACAVNgLEASAAQfAAaiAFQagFaigCADYCACAAIAUpA6AFNwJoIABB/ABqIAVBjAVqKAIANgIAIAAgBSkChAU3AnQgAxDSGiAFQYAHaiQADwsgBUHIA2ogBUG8BWooAgA2AgAgBUHAA2ogBUG0BWopAgA3AwAgBSAFKQKsBTcDuANB4JSHAUEjIAVBuANqQfiLhwFBhJWHARDVHgALIAVBAjYCvAMgBUG0lYcBNgK4AyAFQgE3AsQDIAVBkBw2AqwBIAUgAzYCqAEgBSAFQagBajYCwAMgBUG4A2pBxJWHARDvLAALQdiKhwFBI0H8iocBEMskAAtBnIuHAUEpIAVBuANqQeiLhwFByIuHARDVHgALQcAAIAIQoz0ACyAIIAIoAhxB2IuHARD9LwALIAkgCCgCHEG8hYcBEP0vAAtBBEEEEKM9AAsgBiACKAIcQdiLhwEQ/S8AC0EEQQwQoz0AC9ooAhF/A34jAEHQB2siAyQAIAECfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkAgAS0AhANBAWsOAxkMAQALIANBkAFqIgUQuy8gA0EYaiIGIAVBARCWKiABKQMAIRQgASgCgAMhBCABQQhqIg4gBkH4APwKAAAgAUEAOgD8AiABIAQ2AvgCIAEgFDcDgAEgAUH8AmohDwwBCyABQQhqIQ4gAUH8AmohDwJAIAEtAPwCQQFrDgMPCwIACyABKQOAASEUIAEoAvgCIQQLIAFBiAFqIgYgDkH4APwKAAAgAUEAOgCZAiABIAQ2ApQCIAEgBjYCkAIgASAUNwOAAiABQZkCaiEQIAFBgAJqIREMAQsgAUGAAmohESABQZkCaiEQAkAgAS0AmQJBAWsOBAcJAggACyABKQOAAiEUIAEoApQCIQQgASgCkAIhBgsgAUEBOgCYAiABIAY2AogCIAFBADoAyAIgASAGNgK4AiABIBQ3A6ACIAEgBDYCjAIgASABQYwCaiIENgK8AiABQcgCaiEKIAFBoAJqIRIMAQsgAUGgAmohEiABQcgCaiEKAkAgAS0AyAJBAWsOBAwHAgQACyABKQOgAiEUIAEoArwCIQQgASgCuAIhBgsgASAENgLEAiABIAY2AsACIAEgFDcDqAIgFEIIWgRAIAEgFEEIIAYoAgQiBSAFQQhNG61CCCAGKAIAG30iFUIAIBQgFVobIhU3A7ACIAQoAgAhBSADQQA6AKgBIAMgFDcDmAEgAyAVNwOQASADIAU2AqABIANBEGogA0GQAWoQyiMgAygCECEGIAFBnN7CADYC1AIgASAGNgLQAkGc3sIADAILQQIhBiADQQI2ApQBIANBjO3CADYCkAEgA0IBNwKcASADQTw2AswGIAMgAUGoAmo2AsgGIAMgA0HIBmo2ApgBIANBuARqIANBkAFqEJkOIAMgAygAvQQ2AqAHIAMgA0HABGooAAA2AKMHIAMoArgEIQUgAy0AvAQhB0GAgICAeCEJDBoLIAEoAtACIQYgASgC1AILIQUgA0GQAWogBiACIAUoAgwRAQBBAyADKAKQASIGQQlGDRIaIAMgAykAmQE3A7AGIAMgA0GgAWooAAA2ALcGIAMtAJgBIQcgAygClAEhBSADKAKkASEIIAFB0AJqIgQQvCogBkEIRwRAIAMgAygAtwY2AKcHIAMgAykDsAY3A6AHDBgLIAEgAykDsAY3AO0CIAEgBzoA7AIgASAFNgLoAiABQfQCaiADKAC3BjYAACADIAEoAvACIgU2AsAGIAEpA6gCIAEpA7ACfSIUQoCAgIAQWg0JIAMgFKciBjYCxAYCQCAFIAZPBEAgBEIANwMAIAVBCGshCCAFQQdNDQwgASABKALsAiAIaikAADcD0AIgA0GQAWogBBCKGSADLQCYASEHIAMoApQBIQUgAygCkAEiBkEIRg0BIAMgAykAmQE3A6AHIAMgA0GgAWooAAA2AKcHIAMoAqQBIQgMGAtBAiEGIANBAjYClAEgA0Go78IANgKQASADQgI3ApwBIANBOzYCxAQgA0E7NgK8BCADIANBuARqNgKYASADIANBwAZqNgLABCADIANBxAZqNgK4BCADQcgGaiADQZABahCZDgwWCyABIAc6ANwCIAEgBTYC2AIgASkDqAIiFCAFQQhqIgatIhVUDQsgBSAISw0PIBQgASkDsAIgFXx9IhRCgICAgBBaDQwgCCAUpyIESQ0NIAggASgC8AIiBUsNDiADQZABaiABKALAAiABKALsAiAEaiAIIARrIAFB2AJqEP8ZIAMgAykAmQE3A7gEIAMgA0GgAWooAAA2AL8EIAMoAqQBIQggAy0AmAEhByADKAKUASEFIAMoApABIQYgAygC4AEiCUGAgICAeEYEQCADIAMpA7gENwOgByADIAMoAL8ENgCnBwwXCyADQegGaiADQagBakE4/AoAACADQcgHaiADQewBaigCADYCACADIAMpAuQBNwPAByADIAMpA7gENwOgByADIAMoAL8ENgCnByABKAKwAiETIANBkAFqIAFB6AJqIAQQzRUgA0G4B2ogA0GcAWooAgA2AgAgAyADKQKUATcDsAcgAygCkAEMFAsgASgC5AIhBCABKALgAiEGDBALQbDxwgAQ6CsACyABQaACaiEKIAFB8AJqIQQgAS0A8AJBAWsOAwMAAgELAAsgASgCvAIhBSABKAK4AiEGDBQLIAEoArQCIQUgASgCsAIhBgwUC0GQ8cIAEOgrAAtBuO/CABDoKwALQZztwgAQ6CsAC0Gs7cIAQSsgA0GQAWpB/N/CAEHY7cIAENUeAAsgCCAFQejtwgAQsTsACyADIAY2AtQGQQIhBiADQQI2ApQBIANB6O7CADYCkAEgA0ICNwKcASADQTs2AsQEIANBPDYCvAQgAyABQagCajYCuAQgAyADQbgEajYCmAEgAyADQdQGajYCwAQgA0HIBmohByMAQRBrIgUkACADQZABaiIEKAIMIQkCQAJAAkACQAJAAkACQCAEKAIEDgIAAQILIAkNAUEBIQlBACEEDAILIAkNACAEKAIAIgkoAgQhBCAJKAIAIQkMAQsgByAEEJkODAELIAVBBGogBEEAQQFBARCgGCAFKAIIIQsgBSgCBEEBRg0BIAUoAgwhDCAEBEAgDCAJIAT8CgAACyAHIAQ2AgggByAMNgIEIAcgCzYCAAsgBUEQaiQADAELIAsgBSgCDEHc88IAEP0vAAsMCQtB+O3CAEEvIANBkAFqQfzfwgBBqO7CABDVHgALIAQgCEG47sIAELE7AAsgCCAFQbjuwgAQsDsACyABKALEAigCACEFIANBADoAqAEgAyAUQgh9NwOYASADIBQgFX03A5ABIAMgBTYCoAEgA0EIaiADQZABahDKIyADKAIIIQZBnN7CACEEIAFBnN7CADYC5AIgASAGNgLgAgwBC0G89sIAEOgrAAsgA0GQAWogBiACIAQoAgwRAQAgAygCkAEiBkEJRw0BQQQLIQEgCiABOgAAQQMMEAsgAyADKQCZATcD2AYgAyADQaABaiIFKAAANgDfBiADLQCYASEHIAMoApQBIQQgAygCpAEhCCABQeACahC8KiAGQQhHBEAgAyADKADfBjYApwcgAyADKQPYBjcDoAcgBCEFDAMLIANBxARqIg0gAygA3wY2AAAgAyADKQPYBjcAvQQgAyAHOgC8BCADIAQ2ArgEIANBkAFqIAEoAsACIAMoArwEIgsgAygCwAQiDCABQdgCahD/GSADIAMpAJkBNwPIBiADIAUoAAA2AM8GIAMoAqQBIQggAy0AmAEhByADKAKUASEFIAMoApABIQYgAygC4AEiCUGAgICAeEYEQCADIAMpA8gGNwOgByADIAMoAM8GNgCnByANIAsgDCAEKAIQEQEADAMLIANB6AZqIANBqAFqQTj8CgAAIANByAdqIANB7AFqKAIANgIAIAMgAykC5AE3A8AHIAMgAykDyAY3A6AHIAMgAygAzwY2AKcHIANBxARqIAsgDCAEKAIQEQEAQQALIQ0gAUH0AmogASgC7AIgASgC8AIgASgC6AIoAhARAQAMAwsgAyADKADNBjYCoAcgAyADQdAGaigAADYAowcgAygCyAYhBSADLQDMBiEHCyABQfQCaiABKALsAiABKALwAiABKALoAigCEBEBAAtBgICAgHghCQsgAyADKACnBzYArwUgAyADKQOgBzcDqAUgA0HwBGogA0HoBmpBOPwKAAAgA0HoBGoiBCADQcgHaigCADYCACADQdgEaiILIANBuAdqKAIANgIAIAMgAykDwAc3A+AEIAMgAykDsAc3A9AEIApBAToAACADIAMpA6gFNwOQBiADIAMoAK8FNgCXBiADQdgFaiIMIANB8ARqQTj8CgAAIANB0AVqIgogBCgCADYCACADQcAFaiIEIAsoAgA2AgAgAyADKQPgBDcDyAUgAyADKQPQBDcDuAUgEhCiKSAJQYCAgIB4Rg0EIANByARqIAQoAgA2AgAgAyANNgK8BCADIBM2ArgEIAMgAykDuAU3AsAEIAEoAogCQRBqENIWIAEoAogCIgQgBzoAGCAEIAU2AhQgBCAGNgIQIAQgAykDkAY3ABkgBCAINgIkIARBIGogAygAlwY2AAAgBEEoaiAMQTj8CgAAIAQgCTYCYCAEQewAaiAKKAIANgIAIAQgAykDyAU3AmQCQCABKAKIAiIGLQBwRQRAIAYtAHFFDQELIAFBADoAmAIgASAGNgK4AiABIAMpArgENwLAAiABQQA6APACIAEgASgCjAIiBTYCvAIgAUHIAmogA0HABGopAgA3AgAgAUHQAmogA0HIBGooAgA2AgAgAUGgAmohCiABQfACaiEEDAELQQghBiANRQ0NIANByARqIAMoAsAEIAMoAsQEIA0oAhARAQAMDQsgASAFNgLYAiABIAY2AtQCIAEgASkCwAI3AtwCIAFB7AJqIAFB0AJqKAIANgIAIAFB5AJqIAFByAJqKQIANwIAAkAgBigCYEGAgICAeEcEQCADQfAEaiAGENwLIAMoAvAERQ0DIAEgAykDgAUiFTcDqAIgASADKQP4BCIUNwOgAiABKALgAgRAIBQgAUHcAmo1AgAiFloNAgsgASgC2AIhBSADQQA6AKgBIAMgFTcDmAEgAyAUNwOQASADIAU2AqABIAMgA0GQAWoQyiMgAygCACEGQZzewgAhBSABQZzewgA2ArQCIAEgBjYCsAIMAgsgA0GQAWpBHkEAQQFBARCgGCADKAKUASEFIAMoApABQQFGDQUgAygCmAEhAiADQQA2AugGIAJBFmpBhvHCACkAADcAACACQRBqQYDxwgApAAA3AAAgAkEIakH48MIAKQAANwAAIAJB8PDCACkAADcAACADQR42AvQGIAMgAjYC8AYgAyAFNgLsBgwICyAUIBZ9IhRCgICAgBBaBEAgA0HoBmoQ2yQMCAsgFSAWfSIVQoCAgIAQWgRAIANB6AZqENskDAgLIBWnIgIgASgC6AJLDQUgA0GwB2ogAUHgAmogFKcgAhDSEAwGCyADQZABaiAGIAIgBSgCDBEBACADKAKQASICQQlHDQEgBEEDOgAADAcLIANBCDYC6AYMBQsgA0HIB2oiBSADQZwBaikCADcDACADIAMpApQBNwPAByADKAKkASEGIAFBsAJqELwqIAJBCEcEQCADQfQGaiAFKQMANwIAIAMgAykDwAc3AuwGIAMgBjYC/AYgAyACNgLoBgwFCyADQbgHaiAFKQMANwMAIAMgAykDwAc3A7AHDAMLIAFBgAI7AZgCIAMgAykDkAY3A6AGIAMgAygAlwY2AKcGIAZBCUYNBgwJCyAFIAMoApgBQdzzwgAQ/S8AC0G48MIAQShB4PDCABCfKQALIAMgAzUCuAciFDcD0AQgAyABKQOoAiABKQOgAiIVfSIWNwPgBCAUIBZSBEAgA0EANgKQASADQdAEaiADQeAEaiADQZABakGg8cIAEK4rAAsgA0GQAWoiAiABKALUAiADQbAHaiIFIBUQphICQCADKAKQASIGQQhHDQAgAiABKALUAiAFIAEpA6ACEJ8GIAMoApABIgZBCEcNACADQQg2AugGIANBvAdqIAMoArQHIAMoArgHIAMoArAHKAIQEQEADAELIANB/AZqIANBpAFqKAIANgIAIANB9AZqIANBnAFqKQIANwIAIAMgAykClAE3AuwGIAMgBjYC6AYgA0G8B2ogAygCtAcgAygCuAcgAygCsAcoAhARAQALIAEoAuACIgIEQCABQewCaiABKALkAiABKALoAiACKAIQEQEACyADIAMpAPEGNwPIBiADIANB+AZqKAAANgDPBiADLQDwBiEHIAMoAuwGIQUgAygC/AYhCCADKALoBiEGIARBAToAACAGQQlHDQMLQQQLIQEgECABOgAACyAPQQM6AAAMAwsgAyADKADPBjYApwYgAyADKQPIBjcDoAYgChDFIQsgAUGAAjsBmAILIAMgAygApwY2AM8DIAMgAykDoAY3A8gDIBEQlywCfyAGQQhHBEAgA0HoA2ogAygAzwM2AAAgAyADKQPIAzcA4QMgA0GAgICAeDYCqAQgAyAINgLsAyADIAc6AOADIAMgBTYC3AMgAyAGNgLYA0GAgICAeAwBCyADQdgDaiABQYgBahD+FCADKALcAyEFIAMoAtgDIQYgAygCqAQLIQIgAUGYAWoQ0hYgA0HYAmoiBCADQegDaikDADcDACADIAMpA+ADNwPQAiADQZgCaiIHIANB8ANqQTj8CgAAIAFBAToA/AIgA0GQAmoiASADQbQEaigCADYCACADIAMpAqwENwOIAiACQYGAgIB4Rg0AIANBsANqIgggBCkDADcDACADIAMpA9ACNwOoAyADQfACaiAHQTj8CgAAIANB6AJqIAEoAgA2AgAgAyADKQOIAjcD4AIgDhD2LAJAAkAgAkGAgICAeEYEQCADQcADaiAIKQMANwMAIAMgAykDqAM3A7gDIAYhByAFIQQMAQtBCCEHQegAQQgQrTYiBEUNASAEIAU2AgwgBCAGNgIIIARCgYCAgBA3AwAgBCADKQOoAzcDECAEQRhqIANBsANqKQMANwMAIARBIGogA0HwAmpBOPwKAAAgBCACNgJYIAQgAykD4AI3AlwgBEHkAGogA0HoAmooAgA2AgALIAAgBDYCBCAAIAc2AgAgACADKQO4AzcDCCAAQRBqIANBwANqKQMANwMAQQEMAgtBCEHoABCjPQALIABBCTYCAEEDCzoAhAMgA0HQB2okAAujrwEDM38Jfgd9IwBBoNYCayISJAAgEkEcakEAQYCAAfwLACASQZyAAWpBAEGQwAH8CwACQCAJKAIEIg1FDQAgCSgCACEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCrMACAkACQAJAIAkoAhAgDUYEQAJAIAkoAiAiDUUEQEEAIQwMAQsgCSgCHCEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCsMACIA0gCSgCLEcNAQJAIAkoAjQiDUUEQEEAIQwMAQsgCSgCMCEMIA1BAUYNACAMQQFqIREgDUEBayEOIAwtAAAhEwNAIBEtAAAiDSATQf8BcSIQIA0gEEsbIRMgDCARIA0gEEkbIQwgEUEBaiERIA5BAWsiDg0ACwsgEiAMQcy0wgAgDBstAABBAWoiDTYCtMACIA0gCSgCQEcNAiAJKAIYIgxBgYABTyAMRXINAyAJKAIUIREgDEECdCEQIBJBHGohDQNAIA0gESgCADoAACANQQFqIQ0gEUEEaiERIBBBBGsiEA0ACwwDCyASQQA2AvjLAiASQazAAmogCUEQaiASQfjLAmpByKTQABCoKwALIBJBADYC+MsCIBJBsMACaiAJQSxqIBJB+MsCakHYpNAAEKgrAAsgEkEANgL4ywIgEkG0wAJqIAlBQGsgEkH4ywJqQeik0AAQqCsACyAJKAJIIg5BgYABTyAORXJFBEAgCSgCRCERIA5BAnQhECASQazAAWohDQNAIA0gESgCADoAACANQQFqIQ0gEUEEaiERIBBBBGsiEA0ACwsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDEGBgAFJBEAgDkGQwABqIg9BkcABTw0BIBJBADYCzMACIBJBADYCwMACIBIgDDYCvMACIBIgDzYCyMACIBIgEkGcgAFqNgLEwAIgEiASQRxqNgK4wAIgD0GEwABJDQ8gEkGggAFqQQRBgMAA/AsAIBJB/MsCaiEQIBIgCikCSDcB+MsCQQAhESAPQYbAAGsiDUEAIA0gD00bIRQgDkEMaiEWIBJB+MsCaiENQQEhEwNAIA0vAQAiDmdBEGshFUEAIQwgDgRAQX8gFUF/c0EPcSIMdCAOakEDdEH4/wNxIAx2IQwLIBFBhMAAciEOIBEgFkYNAyASQZyAAWogDmogDEGAfyAVQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQYbAAHIhDSARIBRGDQQgEkGcgAFqIA1qIA5BgH8gDEEDdGtyOgAAQQEhESATQQFxQQAhEyAQIQ0NAAsgEiAKLwFGIhQ7Af7LAiASIAovAUQiFjsB/MsCIBIgCi8BQiIXOwH6ywIgEiAKLwFAIhg7AfjLAkEAIREgD0GKwABrIg1BACANIA9NGyEbIA9BiMAAayINQQAgDSAPTRshGSASQfjLAmohDUEBIRMDQCANLwEAIgxnQRBrIRVBACEOIAwEQCAMQX8gFUF/c0EPcSIOdGpBA3RB+P8DcSAOdiEOCyARQYjAAHIhDCARIBlGDQUgEkGcgAFqIAxqIA5BgH8gFUEDdGtyOgAAIA0vAQIiDWdBEGshDCANBH8gDUF/IAxBf3NBD3EiDnRqQQN0Qfj/A3EgDnYFQQALIQ4gEUGKwAByIQ0gESAbRg0GIBJBnIABaiANaiAOQYB/IAxBA3RrcjoAAEEBIREgE0EBcUEAIRMgECENDQALIBIgFDsB/ssCIBIgFjsB/MsCIBIgFzsB+ssCIBIgGDsB+MsCQQAhESAPQY7AAGsiDUEAIA0gD00bIRQgD0GMwABrIg1BACANIA9NGyEWIBJB+MsCaiENQQEhEwNAIA0vAQAiDGdBEGshFUEAIQ4gDARAIAxBfyAVQX9zQQ9xIg50akEDdEH4/wNxIA52IQ4LIBFBjMAAciEMIBEgFkYNByASQZyAAWogDGogDkGAfyAVQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQY7AAHIhDSARIBRGDQggEkGcgAFqIA1qIA5BgH8gDEEDdGtyOgAAQQEhESATQQFxQQAhEyAQIQ0NAAsgEiALQQAgC0H/AXFBBEcbOgCcgAECQCAKLQBZIi1BAWtB/wFxQQFNBEAgEkH4ywJqIgwgAEEAIBIQwAkgEkHQwAJqIg4gDEGAAfwKAAAjAEGAAWsiDSQAIA1B+ABqIABBgIAEELkpIA0oAnghDyANKAJ8IREgDUHwAGogAEGAgAQQuSkgDSgCcCEVIA0oAnQhEyANQegAaiAAQYCABBC5KSANKAJoIRQgDSgCbCEWIA1B4ABqIABBgIAEELkpIA0oAmAhFyANKAJkIRggDUHYAGogAEGAgAQQuSkgDSgCWCEbIA0oAlwhGSANQdAAaiAAQYCABBC5KSANKAJQIRogDSgCVCEcIA1ByABqIABBgIAEELkpIA0oAkghHSANKAJMIR4gDUFAayAAQYCABBC5KSANKAJAIR8gDSgCRCEjIA1BOGogAEGAgAQQuSkgDSgCOCEkIA0oAjwhJSANQTBqIABBgIAEELkpIA0oAjAhJiANKAI0IScgDUEoaiAAQYCABBC5KSANKAIoISggDSgCLCEpIA1BIGogAEGAgAQQuSkgDSgCICEqIA0oAiQhKyANQRhqIABBgIAEELkpIA0oAhghICANKAIcISEgDUEQaiAAQYCABBC5KSANKAIQISwgDSgCFCEiIA1BCGogAEGAgAQQuSkgDSgCCCEuIA0oAgwhMCAMQfcBakIANwAAIAxCADcD8AEgDEIANwPoASAMIDA2AuQBIAwgLjYC4AEgDEIANwPYASAMICI2AtQBIAwgLDYC0AEgDEIANwPIASAMICE2AsQBIAwgIDYCwAEgDEIANwO4ASAMICs2ArQBIAwgKjYCsAEgDEIANwOoASAMICk2AqQBIAwgKDYCoAEgDEIANwOYASAMICc2ApQBIAwgJjYCkAEgDEIANwOIASAMICU2AoQBIAwgJDYCgAEgDEIANwN4IAwgIzYCdCAMIB82AnAgDEIANwNoIAwgHjYCZCAMIB02AmAgDEIANwNYIAwgHDYCVCAMIBo2AlAgDEIANwNIIAwgGTYCRCAMIBs2AkAgDEIANwM4IAwgGDYCNCAMIBc2AjAgDEIANwMoIAwgFjYCJCAMIBQ2AiAgDEIANwMYIAwgEzYCFCAMIBU2AhAgDEIANwMIIAwgETYCBCAMIA82AgAgDUGAAWokACASQdDBAmoiDSAMQYAC/AoAACMAQfABayIMJAAgDCAENgIgIAwgBjYCHCAMIAU2AhggDEEANgIUIAwgBDYCECAMIAM2AgwgDEEANgIkIA0gDEEMaiIcIhUgDkEAIAxBJGoiFCAUENwIIAxBtAFqIg8gFSAVEIQ7QQF2EJgTIAxBATYCjAEgDEIBNwKEASANIA8gDkEBIAxBhAFqIhEgFBDcCCAPIBUgFRCEO0EBdhCYEyAMQQI2AowBIAxCgYCAgBA3AoQBIA0gDEHMAWoiFyAOQQIgFCARENwIIA8gFSAcEIQ7QQJ2EJgTIAxBAzYCjAEgDEKBgICAEDcChAEgDSAPIA5BAyARIBQQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAPIAxBDGoQhDtBAnYQmBMgDEEDNgLsASAMQoGAgIAgNwLkASAMQQQ2AlwgDEKBgICAMDcCVCANIAxBnAFqIhggDkEEIAxB5AFqIhYgDEHUAGoiExDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyAMQQU2AlwgDEKBgICAMDcCVCANIBEgDkEFIBMgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyAMQQY2AlwgDEKBgICAMDcCVCANIBggDkEGIBMgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQc2AjggDEKBgICAwAA3AjAgDSATIA5BByAMQTBqIhkgFBDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQg2AuwBIAxCgYCAgPAANwLkASANIAxB7ABqIhsgDkEIIBkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBggDEEMahCEO0EDdhCYEyAMQQc2AkQgDEKBgICA0AA3AjwgDEEJNgLsASAMQoGAgIDwADcC5AEgDSATIA5BCSAMQTxqIhkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIA8gDEEMahCEO0ECdhCYEyATIBggDEEMahCEO0EDdhCYEyAMQQo2AuwBIAxCgYCAgPAANwLkASANIBsgDkEKIBkgFhDcCCAPIBUgDEEMahCEO0EBdhCYEyARIBcgDEEMahCEO0ECdhCYEyATIBEgDEEMahCEO0EDdhCYEyAMQQc2AlAgDEKBgICA4AA3AkggDEELNgLsASAMQoGAgIDwADcC5AEgDSATIA5BCyAMQcgAaiIZIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyARIAxBDGoQhDtBA3YQmBMgDEEMNgLsASAMQoGAgIDwADcC5AEgDSAbIA5BDCAZIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyAYIAxBDGoQhDtBA3YQmBMgDEENNgLsASAMQoGAgIDwADcC5AEgDSATIA5BDSAUIBYQ3AggDyAVIAxBDGoQhDtBAXYQmBMgESAXIAxBDGoQhDtBAnYQmBMgEyAYIAxBDGoQhDtBA3YQmBMgDEEONgLsASAMQoGAgIDwADcC5AEgDSAbIA5BDiAUIBYQ3AggDEHwAWokAAwBCyASQfjLAmoiDSAAQQFBABDACSASQdDAAmogDUGAAfwKAAAjAEGAAWsiDCQAIAxB+ABqEP4nIAwoAnghDyAMKAJ8IREgDEHwAGoQ/icgDCgCcCEOIAwoAnQhFSAMQegAahD+JyAMKAJoIRMgDCgCbCEUIAxB4ABqEP4nIAwoAmAhFiAMKAJkIRcgDEHYAGoQ/icgDCgCWCEYIAwoAlwhGyAMQdAAahD+JyAMKAJQIRkgDCgCVCEaIAxByABqEP4nIAwoAkghHCAMKAJMIR0gDEFAaxD+JyAMKAJAIR4gDCgCRCEfIAxBOGoQ/icgDCgCOCEjIAwoAjwhJCAMQTBqEP4nIAwoAjAhJSAMKAI0ISYgDEEoahD+JyAMKAIoIScgDCgCLCEoIAxBIGoQ/icgDCgCICEpIAwoAiQhKiAMQRhqEP4nIAwoAhghKyAMKAIcISAgDEEQahD+JyAMKAIQISEgDCgCFCEsIAxBCGoQ/icgDCgCCCEiIAwoAgwhLiANQfcBakIANwAAIA1CADcD8AEgDUIANwPoASANIC42AuQBIA0gIjYC4AEgDUIANwPYASANICw2AtQBIA0gITYC0AEgDUIANwPIASANICA2AsQBIA0gKzYCwAEgDUIANwO4ASANICo2ArQBIA0gKTYCsAEgDUIANwOoASANICg2AqQBIA0gJzYCoAEgDUIANwOYASANICY2ApQBIA0gJTYCkAEgDUIANwOIASANICQ2AoQBIA0gIzYCgAEgDUIANwN4IA0gHzYCdCANIB42AnAgDUIANwNoIA0gHTYCZCANIBw2AmAgDUIANwNYIA0gGjYCVCANIBk2AlAgDUIANwNIIA0gGzYCRCANIBg2AkAgDUIANwM4IA0gFzYCNCANIBY2AjAgDUIANwMoIA0gFDYCJCANIBM2AiAgDUIANwMYIA0gFTYCFCANIA42AhAgDUIANwMIIA0gETYCBCANIA82AgAgDEGAAWokACASQdDBAmogDUGAAvwKAAALIBIgBDYC5MMCIBIgBjYC4MMCIBIgBTYC3MMCIBJBADYC2MMCIBIgBDYC1MMCIBIgAzYC0MMCIBJBEGoQ/ScgEigCFCEFIBIoAhAhDAJAIC1BA0kEQCAMIQQgBSEGDAELIBJB0MMCaiIVIQ0jAEHQAWsiAyQAIANByABqIBJBuMACaiIOENgOIAMvAUgiBiADLwFKIgRyRQRAIAMgCi8BQiIEOwFKIAMgCi8BQCIGOwFICyAEIAZyQf//A3FFBEAgA0GIgICAAjYCSEEIIQZBgMAAIQQLIAMvAUwiDyADLwFOIhNyRQRAIAMgCi8BRiITOwFOIAMgCi8BRCIPOwFMCyAPIBNyRQRAIAMgBDsBTiADIAY7AUwLIBJB+MsCaiERIANB0ABqIgRBIBCjFSADQUBrIARBzILOABCYISADKQNAIT9BACEGIARBgICAAUHEntAAEJkVIANBOGogBEHMgs4AEKohIAMpAzghQCAEQYCAgAFBxJ7QABCZFSADQTBqIARBzILOABCqISADKQMwIUEgBEGAgIABQcSe0AAQmRUgA0EoaiAEQcyCzgAQqiEgAykDKCFCIARBgICAAUHEntAAEJkVIANBIGogBEHMgs4AEKohIAMpAyAhQyAEQYCAgAFBxJ7QABCZFSADQRhqIARBzILOABCqISADKQMYIUQgBEGAgIABQcSe0AAQmRUgA0EQaiAEQcyCzgAQqiEgAykDECFFIARBgICAAUHEntAAEJkVIANBCGogBEHMgs4AEKohIAMpAwghRiAEQYCAgAFBxJ7QABCZFSADIARBzILOABCqISADKQMAIUcgA0HYAGogDUEIaikCADcDACADQeAAaiANQRBqKQIANwMAIAMgDjYCbCADIAA2AmggA0GAAjsByAEgAyADKQNINwPAASADQgA3A7gBIAMgPzcDsAEgAyBHNwOoASADIEY3A6ABIAMgRTcDmAEgAyBENwOQASADIEM3A4gBIAMgQjcDgAEgAyBBNwN4IAMgQDcDcCADIA0pAgA3A1ADQCADQdAAaiIOIAZqIg1BIGooAgAhBCANQSRqKAIAIg0EQCANQQF0IQ9BACENA0AgBCANQQJ0QTxxQQRqOwEAIA1BAWohDSAEQQJqIQQgD0ECayIPDQALCyAGQQhqIgZBwABHDQALIBEgDkH8APwKAAAgA0HQAWokACABIQ0gCCgCACEdQQAhFkEAIRsjAEGwAmsiDyQAIA9BMGogFUEQaikCADcDACAPQShqIBVBCGopAgA3AwAgDyAVKQIANwMgIA9BQGsgB0EIaikCADcDACAPIAcpAgA3AzhBgICAgHghF0GAgICAeCEUIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFAsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRcLQYCAgIB4IRgCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRgLIA9BGGpBABCENyAPIA8vARg7AIECIA9BBDoAgAIgESAPQYACahCdDiAVEIQ7IQYgAgRAIA0gAkEEdGohISAKQQRqISwgCSgCAEEBaiEiIAkoAghBBGohLkEBIAooAhh0QRBrIR4gD0GYAmohGSAJKAIwITAgCSgCOCExIAkoAjwhHyAJKAI0ITIgCSgCHCEzIAkoAiQhNCAJKAIoISMgCSgCICE1IA9BOGpBBHIhJCAJKAIMISUgCSgCBCE2IAotAFohJiALQf8BcUEERiEnQQAhAwNAIA9BgAJqIA9BIGogBiANKAIAIgQgBCAGSxsQmBMgD0HYAGoiEyAPQZACaiIoKQIANwMAIA9B0ABqIi8gD0GIAmoiKSkCADcDACAPIA8pAoACNwNIIA9B8ABqIBlBEGoiKikCADcDACAPQegAaiAZQQhqIispAgA3AwAgDyAZKQIANwNgIA9ByABqEIQ7ITcgFRCEOxogD0HgAGoQhDsaIA0oAgQhDiAPQRBqIA0gLBDJEiAPKAIUIiAhGgJAAkACQAJAAkACQCAPKAIQIhwEQCAcQQFrIQQgHEEFTw0BIA9BOGogBEECdGooAgAgIGohGgsgD0HIAGoQhDsgBk0EQCAPQcgAahCEO0UNBSAPQeABaiI4IBMpAwA3AwAgD0HYAWoiOSAvKQMANwMAIA8gDykDSDcD0AECQCAPQdABahCEOyAUSwRAIC4gA0ECdGohEyADIQQDQCAPQYACaiAPQdABaiAUEJgTIA9BoAFqICgpAgA3AwAgD0GYAWogKSkCADcDACAPQYABaiIDICspAgA3AwAgD0GIAWoiFCAqKQIANwMAIA8gDykCgAI3A5ABIA8gGSkCADcDeAJAIA9BkAFqIi8QhDtFDQACQCAnBEAgJg0BIBEgLxC/GgwCCyARIA9BkAFqEL8aDAELIBEgD0GQAWoQwBoLIA9BkAFqEIQ7IS8gOCAUKQMANwMAIDkgAykDADcDACAPIA8pA3g3A9ABQYCAgIB4IRQgBEEBaiIDIDZJBEAgAyAlTw0DIBMoAgAhFCAPQQhqIAQgImotAAAQhDcgD0EEOgCAAiAPIA8vAQg7AIECIBEgD0GAAmoQnQ4LIAYgL2shBiATQQRqIRMgAyEEIA9B0AFqEIQ7IBRLDQALCyAnRQ0EICYNAyARIA9B0AFqEL8aDAULIARBAWogJUGEq9AAEMMhAAsMGwsgBEEEQfin0AAQwyEACyARIA9B0AFqEMAaDAELIBEgD0HQAWoQvxoLIA9B0AFqEIQ7RQ0AIAYgD0HQAWoQhDtrIQQgFCAPQdABahCEO2shFAwBCyAGIQQLIA5BGHZBgAFxIA5BGXZywCAOQf///w9xaiEOAkAgHiAdIDdqIh0gHSAeSxsiBiAaTwRAIA4gBCAEIA5LGyITBEAgDyATNgKIAiAPIBo2AoQCIA9BADoAgAIgESAPQYACahCdDgsgBCATayEGICBFIBxBAUZxDQEgDykDOCE/ICRBCGogD0FAaygCADYCACAkID83AgAgDyAaNgI4DAELAkACQAJAAkAgDkEDSwRAIA5BGU8NHSAOQQJ0QcCp0ABqKAIAIBogBkF/c2oiGkF/IA5BpKnQAGotAAAiIHRBf3NxIi8gDmxqIgYgDmoiEyAGSQ0BIBNBoL8HSw0CIA9BkAFqIhxBAEEm/AsAIBxBJiAGQaTp8wBqIA4gDiAaICB2IgYQogkiEyAESwRAQQAhBiAERQ0GIA9BgAJqIhogD0HgAGoiICAEEJgTIBEgGhC/GiAPQQA2AswBIA9CATcCxAEgD0IANwK8ASAPIBw2ArgBIBogIEEAEJgTIA9BuAFqIgQgGhDEFA0GIA9BADYC0AEgBCAaIA9B0AFqQbSq0AAQhisACyAPQQA6AIsCIA8gBjoAiQIgDyAOOgCIAiAPIC82AoQCIA9BAToAgAIgDyATOgCKAiARIA9BgAJqIgYQnQ4gE0EnTw0DIA9CADcCyAEgD0KAgICAEDcCwAEgDyATNgK8ASAPIA9BkAFqNgK4ASAGIA9B4ABqIBMQmBMgD0G4AWogBhDEFEUNBCAEIBNrIQYMBQsMGwsgBiATQaSq0AAQsTsACyATQaC/B0GkqtAAELA7AAsgD0EANgKQAiAPQQE2AoQCIA9B+KDQADYCgAIgD0IENwKIAiAPQYACakHEqtAAEO8sAAsgD0EANgLQASAPQbgBaiAPQYACaiAPQdABakHUqtAAEIYrAAsCQAJAAkACQCAXQQFrIhcNAEGAgICAeCEXIDUgFkEBaiIWTQ0AIBYgI08NASA0IBZBAnRqKAIAIRcgD0EDOgCAAiAPIBYgM2otAAA6AIECIBEgD0GAAmoQnQ4LIA5FDQIgDS8BDEGAAUkNAiAYQQFrIhgNAkGAgICAeCEYIDIgG0EBaiIbTQ0CIBsgH08NASAxIBtBAnRqKAIAIRggD0EFOgCAAiAPIBsgMGotAAA6AIECIBEgD0GAAmoQnQ4MAgsgFiAjQeSq0AAQwyEACyAbIB9B9KrQABDDIQALIA9BgAJqIA9B4ABqIBMQmBMgD0GgAWogKCkCADcDACAPQZgBaiApKQIANwMAIA9B8AFqIgQgKykCADcDACAPQfgBaiIOICopAgA3AwAgDyAPKQKAAjcDkAEgDyAZKQIANwPoASAPQZABahCEOyAPQTBqIA4pAwA3AwAgD0EoaiAEKQMANwMAIA8gDykD6AE3AyAgHWohHSANQRBqIg0gIUcNAAsLIA9BsAJqJAAMAQsMFQsgEkEIaiASKAKQzAIgEigC5MwCELgpIBIoAgwhBiASKAIIIQQgBQRAIAwgBUEBEPg6CyAEIQNBACEOIwBBIGsiDCQAIAwgBjYCBAJAAkACQAJAAkAgEkH4ywJqIgUoAmwgBkYEQCAFKAJkIhEgBk0NASARIAZBA3RBD2pNDQIgBgRAIAMgBmohFiAFKAJgIhdBIGohDwNAIBEgDkEDdEEIaiIVSQ0FIBEgFWtBB00NBiAOQQFqIQ4gA0EBaiAXIBVBAnRqKgIAIUlBACETQQAhFUEAIRQDQCAPIBRqKgIAIkogSSBKQwAAAECSIEldIhgbIUkgFSATIBgbIRMgFUEBaiEVIBRBBGoiFEEgRw0ACyADIBM6AAAgD0EgaiEPIgMgFkcNAAsLIAxBIGokAAwFCyAMQQA2AghBACAMQQRqIAVB7ABqIAxBCGpBnNPMABCvKwALQazTzABBPkHs08wAEJ8pAAtB/NPMAEHNAEHM1MwAEJ8pAAsgDEEANgIYIAxBATYCDCAMQeDSzAA2AgggDEIENwIQIAxBCGpB3NTMABDvLAALIAxBADYCGCAMQQE2AgwgDEHg0swANgIIIAxCBDcCECAMQQhqQezUzAAQ7ywAC0EAIQ0jAEEgayIDJAAgA0EANgIcIANCgICAgMAANwIUIANBCGogA0EUakGMh84AEJghIAUoAmQhDCAFKAJgIQ8gBSADKQMINwJgIAwEQCAPIAxBAnRBBBD4OgtBACEMA0AgA0EANgIcIANCgICAgCA3AhQgAyADQRRqQYyHzgAQqiEgBSAMaiIRQSRqKAIAIQ8gEUEgaiIRKAIAIQ4gESADKQMANwIAIA8EQCAOIA9BAXRBAhD4OgsgDEEIaiIMQcAARw0ACyADQSBqJAADQCAFIA1qIgNBJGooAgAiDARAIANBIGooAgAgDEEBdEECEPg6CyANQQhqIg1BwABHDQALIAUoAmQiAwRAIAUoAmAgA0ECdEEEEPg6CwsgEkIANwP4ywIgEkH4ywJqIg1BCCASQcfDAmoiLkEIQfTYzgAQ1SwgEiASKQP4ywI3A9DKAiASQYjMAmoiMCASQcjAAmopAgA3AwAgEkGAzAJqIjEgEkHAwAJqKQIANwMAIBIgEikCuMACNwP4ywIgEkHowwJqIhMhDCASQdDDAmoiGyEPIAotAFshEUEAIQUjAEGQCWsiAyQAIANBCGogEUEARyIUQYCAxAAQux4gAygCDCEOIAMoAgghFSADIBRBgICAEBC7HiADKAIEIRQgAygCACEWA0AgA0GQA2ogBWoiF0KBgICAEDcCACAXQQpqQQE6AAAgF0EIakGAgAE7AQAgBUEMaiIFQcABRw0AC0EAIQUDQCADQdAEaiAFaiIXQoGAgIAQNwIAIBdBCmpBAToAACAXQQhqQYCAATsBACAFQQxqIgVBwAFHDQALQQAiBUUEQCADQRBqIANBkANqQcAB/AoAAAsgEkHQygJqIANB0AFqIANB0ARqQcAB/AoAAANAIANBkAZqIAVqQQBBgAH8CwAgBUGAAWoiBUGAA0cNAAsgA0HgBGogD0EQaikCADcDACADQdgEaiAPQQhqKQIANwMAIANB8ARqIA1BCGopAgA3AwAgA0H4BGogDUEQaikCADcDACADIA8pAgA3A9AEIAMgDSkCADcD6AQpAAAhPyARBEAgFSAOEOYSIBYgFBDmEgsgDCADQdAEakEw/AoAACAMQQA2AkAgDCAUNgI8IAwgFjYCOCAMIA42AjQgDCAVNgIwIAxBxABqIANBEGpBgAP8CgAAIAwgPzcCxAMgDEHMA2ogA0GQBmpBgAP8CgAAIAxBgAI7AcwGIANBkAlqJAAgCCgCACEFIBEEQCABIQ8gBSEVQQAhGEEAIRkjAEGwAmsiDiQAIA5BMGogG0EQaikCADcDACAOQShqIBtBCGopAgA3AwAgDiAbKQIANwMgIA5BQGsgB0EIaikCADcDACAOIAcpAgA3AzhBgICAgHghGkGAgICAeCEXIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFwsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRoLQYCAgIB4IRwCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRwLIA5BGGpBABCENyAOIA4vARg7AIECIA5BBDoAgAIgEyAOQYACahC0DiAbEIQ7IREgAgRAIA8gAkEEdGohMiAKQQRqITMgCSgCAEEBaiE0IAkoAghBBGohNUEBIAooAhh0QRBrISMgDkGYAmohHSAJKAIwITYgCSgCOCEvIAkoAjwhJCAJKAI0ITcgCSgCHCE4IAkoAiQhOSAJKAIoISUgCSgCICE6IA5BOGpBBHIhJiAJKAIMIScgCSgCBCE7IAotAFohKCALQf8BcUEERiEpQQAhAwNAIA5BgAJqIA5BIGogESAPKAIAIgwgDCARSxsQmBMgDkHYAGoiFiAOQZACaiIqKQIANwMAIA5B0ABqIiIgDkGIAmoiKykCADcDACAOIA4pAoACNwNIIA5B8ABqIB1BEGoiICkCADcDACAOQegAaiAdQQhqIiEpAgA3AwAgDiAdKQIANwNgIA5ByABqEIQ7ITwgGxCEOxogDkHgAGoQhDsaIA8oAgQhFCAOQRBqIA8gMxDJEiAOKAIUIiwhHgJAAkACQAJAAkACQCAOKAIQIh8EQCAfQQFrIQwgH0EFTw0BIA5BOGogDEECdGooAgAgLGohHgsgDkHIAGoQhDsgEU0EQCAOQcgAahCEO0UNBSAOQeABaiI9IBYpAwA3AwAgDkHYAWoiPiAiKQMANwMAIA4gDikDSDcD0AECQCAOQdABahCEOyAXSwRAIDUgA0ECdGohFiADIQwDQCAOQYACaiAOQdABaiAXEJgTIA5BoAFqICopAgA3AwAgDkGYAWogKykCADcDACAOQYABaiIDICEpAgA3AwAgDkGIAWoiFyAgKQIANwMAIA4gDikCgAI3A5ABIA4gHSkCADcDeAJAIA5BkAFqIiIQhDtFDQACQCApBEAgKA0BIBMgIhDEGgwCCyATIA5BkAFqEMQaDAELIBMgDkGQAWoQxRoLIA5BkAFqEIQ7ISIgPSAXKQMANwMAID4gAykDADcDACAOIA4pA3g3A9ABQYCAgIB4IRcgDEEBaiIDIDtJBEAgAyAnTw0DIBYoAgAhFyAOQQhqIAwgNGotAAAQhDcgDkEEOgCAAiAOIA4vAQg7AIECIBMgDkGAAmoQtA4LIBEgImshESAWQQRqIRYgAyEMIA5B0AFqEIQ7IBdLDQALCyApRQ0EICgNAyATIA5B0AFqEMQaDAULIAxBAWogJ0GEq9AAEMMhAAsMGwsgDEEEQfin0AAQwyEACyATIA5B0AFqEMUaDAELIBMgDkHQAWoQxBoLIA5B0AFqEIQ7RQ0AIBEgDkHQAWoQhDtrIQwgFyAOQdABahCEO2shFwwBCyARIQwLIBRBGHZBgAFxIBRBGXZywCAUQf///w9xaiEUAkAgIyAVIDxqIiIgIiAjSxsiESAeTwRAIBQgDCAMIBRLGyIWBEAgDiAWNgKIAiAOIB42AoQCIA5BADoAgAIgEyAOQYACahC0DgsgDCAWayERICxFIB9BAUZxDQEgDikDOCE/ICZBCGogDkFAaygCADYCACAmID83AgAgDiAeNgI4DAELAkACQAJAAkAgFEEDSwRAIBRBGU8NHSAUQQJ0QcCp0ABqKAIAIB4gEUF/c2oiFkF/IBRBpKnQAGotAAAiH3RBf3NxIiwgFGxqIhEgFGoiFSARSQ0BIBVBoL8HSw0CIA5BkAFqIh5BAEEm/AsAIB5BJiARQaTp8wBqIBQgFCAWIB92IhEQogkiFiAMSwRAQQAhESAMRQ0GIA5BgAJqIhUgDkHgAGoiHyAMEJgTIBMgFRDEGiAOQQA2AswBIA5CATcCxAEgDkIANwK8ASAOIB42ArgBIBUgH0EAEJgTIA5BuAFqIgwgFRDEFA0GIA5BADYC0AEgDCAVIA5B0AFqQbSq0AAQhisACyAOQQA6AIsCIA4gEToAiQIgDiAUOgCIAiAOICw2AoQCIA5BAToAgAIgDiAWOgCKAiATIA5BgAJqIhEQtA4gFkEnTw0DIA5CADcCyAEgDkKAgICAEDcCwAEgDiAWNgK8ASAOIA5BkAFqNgK4ASARIA5B4ABqIBYQmBMgDkG4AWogERDEFEUNBCAMIBZrIREMBQsMGwsgESAVQaSq0AAQsTsACyAVQaC/B0GkqtAAELA7AAsgDkEANgKQAiAOQQE2AoQCIA5B+KDQADYCgAIgDkIENwKIAiAOQYACakHEqtAAEO8sAAsgDkEANgLQASAOQbgBaiAOQYACaiAOQdABakHUqtAAEIYrAAsCQAJAAkACQCAaQQFrIhoNAEGAgICAeCEaIDogGEEBaiIYTQ0AIBggJU8NASA5IBhBAnRqKAIAIRogDkEDOgCAAiAOIBggOGotAAA6AIECIBMgDkGAAmoQtA4LIBRFDQIgDy8BDEGAAUkNAiAcQQFrIhwNAkGAgICAeCEcIDcgGUEBaiIZTQ0CIBkgJE8NASAvIBlBAnRqKAIAIRwgDkEFOgCAAiAOIBkgNmotAAA6AIECIBMgDkGAAmoQtA4MAgsgGCAlQeSq0AAQwyEACyAZICRB9KrQABDDIQALIA5BgAJqIA5B4ABqIBYQmBMgDkGgAWogKikCADcDACAOQZgBaiArKQIANwMAIA5B8AFqIgwgISkCADcDACAOQfgBaiIVICApAgA3AwAgDiAOKQKAAjcDkAEgDiAdKQIANwPoASAOQZABahCEOyAOQTBqIBUpAwA3AwAgDkEoaiAMKQMANwMAIA4gDikD6AE3AyAgImohFSAPQRBqIg8gMkcNAAsLIA5BsAJqJAAMAQsMFQtBACERQQEhAyANIBNBAUEAELUQIA0gE0EAQQAQtRAgDSATQQBBARC1ECASQbjKAmogE0EBQQAQnh8gEkHAygJqIBNBAEEAEJ4fIBJByMoCaiATQQBBARCeHyASQbTHAmoQuCwgEkH0xwJqELgsIBJBtMgCahC4LCASQfTIAmoQuCwgEkG0yQJqELgsIBJB9MkCahC4LCASIBIpA8DKAjcB+MsCIBIoApDEAiIPQYbAAGsiDEEAIAwgD00bIRQgD0GEwABrIgxBACAMIA9NGyEWIBIoAozEAiEVA0AgDS8BACIMZ0EQayETQQAhDiAMBEAgDEF/IBNBf3NBD3EiDnRqQQN0Qfj/A3EgDnYhDgsgEUGEwAByIQwgESAWRg0KIAwgFWogDkGAfyATQQN0a3I6AAAgDS8BAiINZ0EQayEMIA0EfyANQX8gDEF/c0EPcSIOdGpBA3RB+P8DcSAOdgVBAAshDiARQYbAAHIhDSARIBRGDQsgDSAVaiAOQYB/IAxBA3RrcjoAAEEBIREgA0EAIQMgECENDQALIBIgEikDuMoCNwH4ywJBACERIBIoApDEAiIPQYrAAGsiA0EAIAMgD00bIRQgD0GIwABrIgNBACADIA9NGyEWIBJB+MsCaiENQQEhAyASKAKMxAIhFQNAIA0vAQAiDGdBEGshE0EAIQ4gDARAIAxBfyATQX9zQQ9xIg50akEDdEH4/wNxIA52IQ4LIBFBiMAAciEMIBEgFkYNDCAMIBVqIA5BgH8gE0EDdGtyOgAAIA0vAQIiDWdBEGshDCANBH8gDUF/IAxBf3NBD3EiDnRqQQN0Qfj/A3EgDnYFQQALIQ4gEUGKwAByIQ0gESAURg0NIA0gFWogDkGAfyAMQQN0a3I6AABBASERIANBACEDIBAhDQ0ACyASIBIpA8jKAjcB+MsCQQAhESASKAKQxAIiD0GOwABrIgNBACADIA9NGyEUIA9BjMAAayIDQQAgAyAPTRshFiASQfjLAmohDUEBIQMgEigCjMQCIRUDQCANLwEAIgxnQRBrIRNBACEOIAwEQCAMQX8gE0F/c0EPcSIOdGpBA3RB+P8DcSAOdiEOCyARQYzAAHIhDCARIBZGDQ4gDCAVaiAOQYB/IBNBA3RrcjoAACANLwECIg1nQRBrIQwgDQR/IA1BfyAMQX9zQQ9xIg50akEDdEH4/wNxIA52BUEACyEOIBFBjsAAciENIBEgFEYNDyANIBVqIA5BgH8gDEEDdGtyOgAAQQEhESADQQAhAyAQIQ0NAAsLIBJCADcD+MsCIBJB+MsCaiIRQQggLkEIQfTYzgAQ1SwgEkGIxAJqIgMpAgAhPyADQoCAgIAQNwIAIBJBkMQCaiIDKQIAIUAgA0IANwIAIBIgEikD+MsCNwPwywIgMCBANwMAIDEgPzcDACASKQKAxAIhPyASQgE3AoDEAiASID83A/jLAiMAQZABayIDJAAgCi0AXCEWIANB0ABqIQ1BACEOQQAhFUEAIRMCQAJAAkACQCARKAIQIhBBicAATwRAIBBBicAARg0BIBBBisAATQ0CIBBBi8AARg0DIBEoAgwiEC0AikAhDCAQLQCIQCIPQQhPBEAgD0EHcSAPQQN2QQFrQQ9xIg90Qfj/A3FBA3ZBASAPdHIhFQsgEC0AiUAhDyAMQQhPBEAgDEEHcSAMQQN2QQFrQQ9xIgx0Qfj/A3FBA3ZBASAMdHIhDgsgEC0Ai0AhECAPQQhPBEAgD0EHcSAPQQN2QQFrQQ9xIgx0Qfj/A3FBA3ZBASAMdHIhEwsgDSAQQQhPBH8gEEEHcSAQQQN2QQFrQQ9xIhB0Qfj/A3FBA3ZBASAQdHIFQQALOwEGIA0gEzsBBCANIA47AQIgDSAVOwEADAQLQYjAACAQQbz0zgAQwyEAC0GJwABBicAAQcz0zgAQwyEAC0GKwABBisAAQdz0zgAQwyEAC0GLwABBi8AAQez0zgAQwyEACyADQdgAaiARENgOIAMvAVAiDCADLwFSIg5yRQRAIAMgCi8BSiIOOwFSIAMgCi8BSCIMOwFQCyAMIA5yRQRAIANBiICAgAI2AlBBgMAAIQ5BCCEMCyADLwFUIg8gAy8BViITckUEQCADIAovAU4iEzsBViADIAovAUwiDzsBVAsgDyATckUEQCADIA47AVYgAyAMOwFUCyADLwFYIgwgAy8BWiIOckUEQCADIAovAUIiDjsBWiADIAovAUAiDDsBWAsgDCAOckUEQCADQYiAgIACNgJYQYDAACEOQQghDAsgAy8BXCIPIAMvAV4iE3JFBEAgAyAKLwFGIhM7AV4gAyAKLwFEIg87AVwLIA8gE3JFBEAgAyAOOwFeIAMgDDsBXAsgEkHQygJqIRQgEkHQwwJqIRMgEkHwywJqIANByABqEP4nIAMpA0ghPyADQUBrIBZBAEciEEGAIhCtGSADKAJEIQwgAygCQCEPIANBOGogEEGAIhCtGSADKAI8IQ4gAygCOCEVIANBMGogEEGAIhCtGSADKAI0IRYgAygCMCEXIANBKGogEEGAgAgQrRkgAygCLCEYIAMoAighGyADQSBqIBBBgIAIEK0ZIAMoAiQhGSADKAIgIRogA0EYaiAQQYCACBCtGSADKAIcIRwgAygCGCEdIANBEGogEEGAgAgQrRkgAygCFCEeIAMoAhAhHyADQQhqIBBBgIDUABCtGSADKAIMISMgAygCCCEkIwBBQGoiDSQAAn8gEEUEQCANQQA2AiggDUKAgICAwAA3AiAgDUEIaiANQSBqQYyHzgAQniEgDSgCCCEQIA0oAgwMAQsgDUE4akIANwMAIA1BMGpCADcDACANQShqQgA3AwAgDUIANwMgIA1BFGoiECANQSBqQYDAABCHHCANIBBBzILOABCeISANKAIAIRAgDSgCBAshJiADIBA2AgAgAyAmNgIEIA1BQGskACADQegAaiATQQhqKQIANwMAIANB8ABqIBNBEGopAgA3AwAgA0GAAWogEUEIaikCADcDACADQYgBaiARQRBqKQIANwMAIAMgEykCADcDYCADIBEpAgA3A3gpAAAhQCADKQMAIUEgAykDUCFCIAMpA1ghQyAPIAwQ/SYgFSAOEP0mIBcgFhD9JiAbIBgQ/SYgGiAZEP0mIB0gHBD9JiAfIB4Q/SYgJCAjEP0mIBQgA0HgAGpBMPwKAAAgFEGAAjsBnAEgFCBDNwKUASAUIEI3AowBIBQgQDcChAEgFEEANgKAASAUIEE3AnggFCAjNgJ0IBQgJDYCcCAUIB42AmwgFCAfNgJoIBQgHDYCZCAUIB02AmAgFCAZNgJcIBQgGjYCWCAUIBg2AlQgFCAbNgJQIBQgFjYCTCAUIBc2AkggFCAONgJEIBQgFTYCQCAUIAw2AjwgFCAPNgI4IBQgPzcCMCADQZABaiQAIAotAFwEQCABIQ4gBSEPQQAhG0EAIRcjAEGwAmsiECQAIBBBMGogE0EQaikCADcDACAQQShqIBNBCGopAgA3AwAgECATKQIANwMgIBBBQGsgB0EIaikCADcDACAQIAcpAgA3AzhBgICAgHghGEGAgICAeCEWIAkoAhBBAUcEQCAJKAIMRQ0XIAkoAggoAgAhFgsCQCAJKAIsQQFHBEAgCSgCKEUNFyAJKAIkKAIAIRgLQYCAgIB4IRkCQCAJKAJAQQFHBEAgCSgCPEUNASAJKAI4KAIAIRkLIBBBGGpBABCENyAQIBAvARg7AIECIBBBBDoAgAIgFCAQQYACahDVDiATEIQ7IQwgAgRAIA4gAkEEdGohLCAKQQRqISIgCSgCAEEBaiEuIAkoAghBBGohMEEBIAooAhh0QRBrIR4gEEGYAmohGiAJKAIwITEgCSgCOCEyIAkoAjwhHyAJKAI0ITMgCSgCHCE0IAkoAiQhNSAJKAIoISMgCSgCICE2IBBBOGpBBHIhJCAJKAIMISUgCSgCBCEvIAotAFohJiALQf8BcUEERiEnQQAhAwNAIBBBgAJqIBBBIGogDCAOKAIAIg0gDCANSRsQmBMgEEHYAGoiFSAQQZACaiIoKQIANwMAIBBB0ABqIiEgEEGIAmoiKSkCADcDACAQIBApAoACNwNIIBBB8ABqIBpBEGoiKikCADcDACAQQegAaiAaQQhqIispAgA3AwAgECAaKQIANwNgIBBByABqEIQ7ITcgExCEOxogEEHgAGoQhDsaIA4oAgQhESAQQRBqIA4gIhDJEiAQKAIUIiAhHAJAAkACQAJAAkACQCAQKAIQIh0EQCAdQQFrIQ0gHUEFTw0BIBBBOGogDUECdGooAgAgIGohHAsgEEHIAGoQhDsgDE0EQCAQQcgAahCEO0UNBSAQQeABaiI4IBUpAwA3AwAgEEHYAWoiOSAhKQMANwMAIBAgECkDSDcD0AECQCAQQdABahCEOyAWSwRAIDAgA0ECdGohFSADIQ0DQCAQQYACaiAQQdABaiAWEJgTIBBBoAFqICgpAgA3AwAgEEGYAWogKSkCADcDACAQQYABaiIDICspAgA3AwAgEEGIAWoiFiAqKQIANwMAIBAgECkCgAI3A5ABIBAgGikCADcDeAJAIBBBkAFqIiEQhDtFDQACQCAnBEAgJg0BIBQgIRDCGgwCCyAUIBBBkAFqEMIaDAELIBQgEEGQAWoQwxoLIBBBkAFqEIQ7ISEgOCAWKQMANwMAIDkgAykDADcDACAQIBApA3g3A9ABQYCAgIB4IRYgDUEBaiIDIC9JBEAgAyAlTw0DIBUoAgAhFiAQQQhqIA0gLmotAAAQhDcgEEEEOgCAAiAQIBAvAQg7AIECIBQgEEGAAmoQ1Q4LIAwgIWshDCAVQQRqIRUgAyENIBBB0AFqEIQ7IBZLDQALCyAnRQ0EICYNAyAUIBBB0AFqEMIaDAULIA1BAWogJUGEq9AAEMMhAAsMGwsgDUEEQfin0AAQwyEACyAUIBBB0AFqEMMaDAELIBQgEEHQAWoQwhoLIBBB0AFqEIQ7RQ0AIAwgEEHQAWoQhDtrIQ0gFiAQQdABahCEO2shFgwBCyAMIQ0LIBFBGHZBgAFxIBFBGXZywCARQf///w9xaiERAkAgHiAPIDdqIiEgHiAhSRsiDCAcTwRAIBEgDSANIBFLGyIVBEAgECAVNgKIAiAQIBw2AoQCIBBBADoAgAIgFCAQQYACahDVDgsgDSAVayEMICBFIB1BAUZxDQEgECkDOCE/ICRBCGogEEFAaygCADYCACAkID83AgAgECAcNgI4DAELAkACQAJAAkAgEUEDSwRAIBFBGU8NHSARQQJ0QcCp0ABqKAIAIBwgDEF/c2oiFUF/IBFBpKnQAGotAAAiHXRBf3NxIiAgEWxqIgwgEWoiDyAMSQ0BIA9BoL8HSw0CIBBBkAFqIhxBAEEm/AsAIBxBJiAMQaTp8wBqIBEgESAVIB12IgwQogkiFSANSwRAQQAhDCANRQ0GIBBBgAJqIg8gEEHgAGoiHSANEJgTIBQgDxDCGiAQQQA2AswBIBBCATcCxAEgEEIANwK8ASAQIBw2ArgBIA8gHUEAEJgTIBBBuAFqIg0gDxDEFA0GIBBBADYC0AEgDSAPIBBB0AFqQbSq0AAQhisACyAQQQA6AIsCIBAgDDoAiQIgECAROgCIAiAQICA2AoQCIBBBAToAgAIgECAVOgCKAiAUIBBBgAJqIgwQ1Q4gFUEnTw0DIBBCADcCyAEgEEKAgICAEDcCwAEgECAVNgK8ASAQIBBBkAFqNgK4ASAMIBBB4ABqIBUQmBMgEEG4AWogDBDEFEUNBCANIBVrIQwMBQsMGwsgDCAPQaSq0AAQsTsACyAPQaC/B0GkqtAAELA7AAsgEEEANgKQAiAQQQE2AoQCIBBB+KDQADYCgAIgEEIENwKIAiAQQYACakHEqtAAEO8sAAsgEEEANgLQASAQQbgBaiAQQYACaiAQQdABakHUqtAAEIYrAAsCQAJAAkACQCAYQQFrIhgNAEGAgICAeCEYIDYgG0EBaiIbTQ0AIBsgI08NASA1IBtBAnRqKAIAIRggEEEDOgCAAiAQIBsgNGotAAA6AIECIBQgEEGAAmoQ1Q4LIBFFDQIgDi8BDEGAAUkNAiAZQQFrIhkNAkGAgICAeCEZIDMgF0EBaiIXTQ0CIBcgH08NASAyIBdBAnRqKAIAIRkgEEEFOgCAAiAQIBcgMWotAAA6AIECIBQgEEGAAmoQ1Q4MAgsgGyAjQeSq0AAQwyEACyAXIB9B9KrQABDDIQALIBBBgAJqIBBB4ABqIBUQmBMgEEGgAWogKCkCADcDACAQQZgBaiApKQIANwMAIBBB8AFqIg0gKykCADcDACAQQfgBaiIPICopAgA3AwAgECAQKQKAAjcDkAEgECAaKQIANwPoASAQQZABahCEOyAQQTBqIA8pAwA3AwAgEEEoaiANKQMANwMAIBAgECkD6AE3AyAgIWohDyAOQRBqIg4gLEcNAAsLIBBBsAJqJAAMAQsMFQtBACERQQAhDyMAQaDAAGsiDSQAIA1BGGpCADcDACANQRBqQgA3AwAgDUEIakIANwMAIA1CADcDACANQSBqQQBBgMAA/AsAIBQoAnwiAwRAIBQoAnghDCADQQV0IRNBACEDA0AgDEEAQdiEzgAQoi4qAgAhSSAMQQJB6ITOABCiLioCACFMIAxBA0H4hM4AEKIuKgIAIUsgDEEEQYiFzgAQoi4qAgAhSiAMQQVBmIXOABCiLioCACFIIAxBBkGohc4AEKIuKgIAIU0gDEEHQbiFzgAQoi4qAgAiTkMAAIA/kvwFIj8gTvwFIkEgPyBBVBsiPyBNQwAAgEGS/AUiQiA/IEJUGyI/IEj8BSJAID8gQFQbIkMgSvwFIkQgQyBEVBsiP7UhSgJAAkACQAJAIAxBAUHIhc4AEKIuKgIAQwAAwECSIkggS0MAAIBBkiJLXUUgSCBMXUVyIEggSV1FckUgSCBKXXFFBEAgTEMAAMBAkiJIIEtdRSBIIEldRXJFIEggSl1xRQRAIEkgS0MAAMBAkiJIXiBIIEpdcUUEQCBKQwAAwECSIEldRQRAIANBgMAASQRAQQAhDiANQSBqIANqQQA6AAAMCAsgA0GAwABB2IXOABDDIQALIANBgMAASQ0FIANBgMAAQeiFzgAQwyEACyADQYDAAEkNAyADQYDAAEH4hc4AEMMhAAsgA0GAwABJDQEgA0GAwABBiIbOABDDIQALIANBgMAATwRAIANBgMAAQZiGzgAQwyEAC0EBIQ4gDUEgaiADakEBOgAADAMLQQIhDiANQSBqIANqQQI6AAAMAgtBAyEOIA1BIGogA2pBAzoAAAwBCyANQSBqIANqIhBBB0EEID8gQVEbIg46AAAgQyBEWiIVID8gQlFyRSA/IEBScQ0AIBBBBEEFQQYgPyBAURsgFRsiDjoAAAsCQCA/UARAIA1BIGogA2ogDzoAAAwBCyANIA5BAnRqIhAgECgCAEEBaiIQNgIAIBAgESAQIBFLIhAbIREgDiAPIBAbIQ8LIAxBIGohDCADQQFqIQMgE0EgayITDQALCwJAIBQoAigiA0GDwABLBEAgFCgCJEEEakGAwAAgDUEgakGAwABB/IbOABDVLCANQaDAAGokAAwBC0GEwAAgA0Hshs4AELA7AAsLIBJB8MoCaiIDKQIAIT8gA0KAgICAEDcCACASQfjKAmoiAykCACFAIANCADcCACASQfDVAmogQDcDACASQejVAmogPzcDACASKQLoygIhPyASQgE3AujKAiASID83A+DVAiMAQeAAayIDJAAgA0EANgJcIANCgICAgMAANwJUIANByABqIANB1ABqQYyHzgAQniEgEkHQygJqIg0oAnwhECANKAJ4IQwgDSADKQNINwJ4IBAEQCAMIBBBBXRBBBD4OgsgA0EANgJcIANCgICAgCA3AlQgA0FAayADQdQAakGMh84AEKEhIA0oAjwhECANKAI4IQwgDSADKQNANwI4IBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0E4aiADQdQAakGMh84AEKEhIA0oAkQhECANKAJAIQwgDSADKQM4NwJAIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EwaiADQdQAakGMh84AEKEhIA0oAkwhECANKAJIIQwgDSADKQMwNwJIIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EoaiADQdQAakGMh84AEKEhIA0oAlQhECANKAJQIQwgDSADKQMoNwJQIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EgaiADQdQAakGMh84AEKEhIA0oAlwhECANKAJYIQwgDSADKQMgNwJYIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EYaiADQdQAakGMh84AEKEhIA0oAmQhECANKAJgIQwgDSADKQMYNwJgIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EQaiADQdQAakGMh84AEKEhIA0oAmwhECANKAJoIQwgDSADKQMQNwJoIBAEQCAMIBBBBXRBAhD4OgsgA0EANgJcIANCgICAgCA3AlQgA0EIaiADQdQAakGMh84AEKEhIA0oAnQhECANKAJwIQwgDSADKQMINwJwIBAEQCAMIBBBBXRBAhD4OgsgA0HgAGokACAKLQBaIRAgEkH4zgJqIBJB6MMCakHQBvwKAAAgEkH4zQJqIBJB0MACakGAAfwKAAAgEkH4ywJqIgMgEkHQwQJqQYAC/AoAACASQdjVAmogEkHgwwJqKQIANwMAIBJB0NUCaiASQdjDAmopAgA3AwAgEiASKQLQwwI3A8jVAiASIAJBEWxBBHZBBGoQ+SYgEiAANgKU1gIgEkEANgKI1gIgEiAQOgCZ1gIgEiAtOgCY1gIgEiAGNgKE1gIgEiAENgKA1gIgEkEAOwGa1gIgEkIANwKM1gIgEiASKQMANwP41QIgCAJ/IAEhBCACIQBBACEMQQAhDiMAQbACayIGJAAgBkEwaiASQdDDAmoiE0EQaikCADcDACAGQShqIBNBCGopAgA3AwAgBiATKQIANwMgIAZBQGsgB0EIaikCADcDACAGIAcpAgA3AzhBgICAgHghEUGAgICAeCEQAkAgCSgCEEEBRwRAIAkoAgxFDQEgCSgCCCgCACEQCwJAIAkoAixBAUcEQCAJKAIoRQ0BIAkoAiQoAgAhEQtBgICAgHghDwJAIAkoAkBBAUcEQCAJKAI8RQ0BIAkoAjgoAgAhDwsgBkEYakEAEIQ3IAYgBi8BGDsAgQIgBkEEOgCAAiADIAZBgAJqELkRIBMQhDshAiAABEAgBCAAQQR0aiEjIApBBGohJCAJKAIAQQFqISUgCSgCCEEEaiEmQQEgCigCGHRBEGshFCAGQZgCaiEVIAkoAjAhJyAJKAI4ISggCSgCPCEWIAkoAjQhKSAJKAIcISogCSgCJCErIAkoAighFyAJKAIgISAgBkE4akEEciEYIAkoAgwhGyAJKAIEISEgCi0AWiEZIAtB/wFxQQRGIQtBACEAA0AgBkGAAmogBkEgaiACIAQoAgAiASABIAJLGxCYEyAGQdgAaiIHIAZBkAJqIhopAgA3AwAgBkHQAGoiLSAGQYgCaiIcKQIANwMAIAYgBikCgAI3A0ggBkHwAGogFUEQaiIdKQIANwMAIAZB6ABqIBVBCGoiHikCADcDACAGIBUpAgA3A2AgBkHIAGoQhDshLCATEIQ7GiAGQeAAahCEOxogBCgCBCEIIAZBEGogBCAkEMkSIAYoAhQiHyEJAkACQAJAAkACQAJAIAYoAhAiCgRAIApBAWshASAKQQVPDQEgBkE4aiABQQJ0aigCACAfaiEJCyAGQcgAahCEOyACTQRAIAZByABqEIQ7RQ0FIAZB4AFqIiIgBykDADcDACAGQdgBaiIuIC0pAwA3AwAgBiAGKQNINwPQAQJAIAZB0AFqEIQ7IBBLBEAgJiAAQQJ0aiEHIAAhAQNAIAZBgAJqIAZB0AFqIBAQmBMgBkGgAWogGikCADcDACAGQZgBaiAcKQIANwMAIAZBgAFqIgAgHikCADcDACAGQYgBaiIQIB0pAgA3AwAgBiAGKQKAAjcDkAEgBiAVKQIANwN4AkAgBkGQAWoiLRCEO0UNAAJAIAsEQCAZDQEgAyAtEMcaDAILIAMgBkGQAWoQxxoMAQsgAyAGQZABahDIGgsgBkGQAWoQhDshLSAiIBApAwA3AwAgLiAAKQMANwMAIAYgBikDeDcD0AFBgICAgHghECABQQFqIgAgIUkEQCAAIBtPDQMgBygCACEQIAZBCGogASAlai0AABCENyAGQQQ6AIACIAYgBi8BCDsAgQIgAyAGQYACahC5EQsgAiAtayECIAdBBGohByAAIQEgBkHQAWoQhDsgEEsNAAsLIAtFDQQgGQ0DIAMgBkHQAWoQxxoMBQsgAUEBaiAbQYSr0AAQwyEACwwcCyABQQRB+KfQABDDIQALIAMgBkHQAWoQyBoMAQsgAyAGQdABahDHGgsgBkHQAWoQhDtFDQAgAiAGQdABahCEO2shASAQIAZB0AFqEIQ7ayEQDAELIAIhAQsgCEEYdkGAAXEgCEEZdnLAIAhB////D3FqIQgCQCAUIAUgLGoiLSAUIC1JGyICIAlPBEAgCCABIAEgCEsbIgcEQCAGIAc2AogCIAYgCTYChAIgBkEAOgCAAiADIAZBgAJqELkRCyABIAdrIQIgH0UgCkEBRnENASAGKQM4IT8gGEEIaiAGQUBrKAIANgIAIBggPzcCACAGIAk2AjgMAQsCQAJAAkACQCAIQQNLBEAgCEEZTw0eIAhBAnRBwKnQAGooAgAgCSACQX9zaiIHQX8gCEGkqdAAai0AACIKdEF/c3EiHyAIbGoiAiAIaiIFIAJJDQEgBUGgvwdLDQIgBkGQAWoiCUEAQSb8CwAgCUEmIAJBpOnzAGogCCAIIAcgCnYiAhCiCSIHIAFLBEBBACECIAFFDQYgBkGAAmoiBSAGQeAAaiIKIAEQmBMgAyAFEMcaIAZBADYCzAEgBkIBNwLEASAGQgA3ArwBIAYgCTYCuAEgBSAKQQAQmBMgBkG4AWoiASAFEMQUDQYgBkEANgLQASABIAUgBkHQAWpBtKrQABCGKwALIAZBADoAiwIgBiACOgCJAiAGIAg6AIgCIAYgHzYChAIgBkEBOgCAAiAGIAc6AIoCIAMgBkGAAmoiAhC5ESAHQSdPDQMgBkIANwLIASAGQoCAgIAQNwLAASAGIAc2ArwBIAYgBkGQAWo2ArgBIAIgBkHgAGogBxCYEyAGQbgBaiACEMQURQ0EIAEgB2shAgwFCwwcCyACIAVBpKrQABCxOwALIAVBoL8HQaSq0AAQsDsACyAGQQA2ApACIAZBATYChAIgBkH4oNAANgKAAiAGQgQ3AogCIAZBgAJqQcSq0AAQ7ywACyAGQQA2AtABIAZBuAFqIAZBgAJqIAZB0AFqQdSq0AAQhisACwJAAkACQAJAIBFBAWsiEQ0AQYCAgIB4IREgICAMQQFqIgxNDQAgDCAXTw0BICsgDEECdGooAgAhESAGQQM6AIACIAYgDCAqai0AADoAgQIgAyAGQYACahC5EQsgCEUNAiAELwEMQYABSQ0CIA9BAWsiDw0CQYCAgIB4IQ8gKSAOQQFqIg5NDQIgDiAWTw0BICggDkECdGooAgAhDyAGQQU6AIACIAYgDiAnai0AADoAgQIgAyAGQYACahC5EQwCCyAMIBdB5KrQABDDIQALIA4gFkH0qtAAEMMhAAsgBkGAAmogBkHgAGogBxCYEyAGQaABaiAaKQIANwMAIAZBmAFqIBwpAgA3AwAgBkHwAWoiASAeKQIANwMAIAZB+AFqIgUgHSkCADcDACAGIAYpAoACNwOQASAGIBUpAgA3A+gBIAZBkAFqEIQ7IAZBMGogBSkDADcDACAGQShqIAEpAwA3AwAgBiAGKQPoATcDICAtaiEFIARBEGoiBCAjRw0ACwsgBkGwAmokACAFDAMLDBYLDBYLDBYLNgIAAn8jAEEwayIAJAAgAygClAogAygChApNBEAgA0EAOgCiCiADQQA2ApQKIANBgAJqIQUgAygCnAoaQQAhAiMAQRBrIgEkAANAIAFBCGoQ/icgAiAFaiIEKAIAIAQgASgCCDYCACAEQQRqIgQoAgAgBCABKAIMNgIAEIAxIAJBEGoiAkGAAUcNAAsgAUEQaiQAIAMoApwKGkEAIQIjAEEQayIBJAADQCABQQhqEP4nIAIgA2oiBCgCACAEIAEoAgg2AgAgBEEEaiIEKAIAIAQgASgCDDYCABCAMSACQRBqIgJB8AFHDQALIAFBEGokACADKAKcChojAEEgayIBJAAgAUEANgIcIAFCgICAgCA3AhQgAUEIaiABQRRqQYyHzgAQqiEgA0GAA2oiAigCNCEEIAIoAjAhBSACIAEpAwg3AjAgBARAIAUgBEEBdEECEPg6CyABQQA2AhwgAUKAgICAIDcCFCABIAFBFGpBjIfOABCqISACKAI8IQQgAigCOCEFIAIgASkDADcCOCAEBEAgBSAEQQF0QQIQ+DoLIAFBIGokACAAQQA2AiAgAEKAgICAwAA3AhggAEEQaiAAQRhqQYyHzgAQmSEgAygChAohASADKAKACiECIAMgACkDEDcDgAogAQRAIAIgAUEUbEEEEPg6CyADKAKcCiAAQQhqEP0nIAMoAogKIAMgACgCCDYCiAogAygCjAogAyAAKAIMNgKMChDgNSADLQCjCiAAQTBqJAAMAQsgAEEANgIoIABBATYCHCAAQfig0AA2AhggAEIENwIgIABBGGpBlK3QABDvLAALDQ4gAygChAIEQCMAQRBrIgAkACAAQejvigE2AgwgAEEEaiECAkAgAEEMahC2FCIBKAIQRQRAIAJBwAA2AgQgAkEENgIAIAEgASgCCEEBayICNgIIIAJFBEAgAUEAOgAMIAFCADcDAAsMAQtB4LKJARCbPgALIAAtAAQiAUEERiABQQNHckUEQCAAKAIIIgEoAgAhAiABKAIEIgQoAgAiBQRAIAIgBREDAAsgBCgCBCIFBEAgAiAFIAQoAggQ+DoLIAFBDEEEEPg6CyAAQRBqJAALIAMoAoQKIgAEQCADKAKACiAAQRRsQQQQ+DoLQQAhAANAIAAgA2oiAUGEAmooAgAiAgRAIAFBgAJqKAIAIAJBAnRBBBD4OgsgAEEQaiIAQYABRw0ACyADKAKMCiIABEAgAygCiAogAEEBEPg6C0EAIQADQCAAIANqIgFBBGooAgAiAgRAIAEoAgAgAkECdEEEEPg6CyAAQRBqIgBB8AFHDQALIAMoArQDIgAEQCADKAKwAyAAQQF0QQIQ+DoLIAMoArwDIgAEQCADKAK4AyAAQQF0QQIQ+DoLIA0oAjQiAARAIA0oAjAgAEECdEEEEPg6CyANKAI8IgAEQCANKAI4IABBBXRBAhD4OgsgDSgCRCIABEAgDSgCQCAAQQV0QQIQ+DoLIA0oAkwiAARAIA0oAkggAEEFdEECEPg6C0EAIQEDQCABIA1qIgBB1ABqKAIAIgIEQCAAQdAAaigCACACQQV0QQIQ+DoLIAFBCGoiAUEgRw0ACyANKAJ0IgAEQCANKAJwIABBBXRBAhD4OgsgDSgCfCIABEAgDSgCeCAAQQV0QQQQ+DoLIBJBoNYCaiQADwsgEkEANgKIzAIgEkEBNgL8ywIgEkH4oNAANgL4ywIgEkIENwKAzAIgEkH4ywJqQfik0AAQ7ywACyASQQA2AojMAiASQQE2AvzLAiASQfig0AA2AvjLAiASQgQ3AoDMAiASQfjLAmpBiKXQABDvLAALIA4gD0HYxNAAEMMhAAsgDSAPQejE0AAQwyEACyAMIA9BuMTQABDDIQALIA0gD0HIxNAAEMMhAAsgDCAPQfjE0AAQwyEACyANIA9BiMXQABDDIQALIAwgD0HYxNAAEMMhAAsgDSAPQejE0AAQwyEACyAMIA9BuMTQABDDIQALIA0gD0HIxNAAEMMhAAsgDCAPQfjE0AAQwyEACyANIA9BiMXQABDDIQALQfSi0ABBKyASQfDLAmpBsKPQAEGYpdAAENUeAAtBhMAAIA9BqMTQABCwOwALQYio0ABBKUG0qNAAEJ8pAAtBxKjQAEEfQeSo0AAQnykAC0H0qNAAQR9BlKnQABCfKQALQQBBAEHop9AAEMMhAAtBAEEAQdin0AAQwyEAC0EAQQBByKfQABDDIQAL8yACDH8DfiMAQYAEayIEJAAgBEEAOwH8AyABKAIYIQwCQCABKAIcIgpFDQADQCAGIAxqLQAAQTBHDQEgCiAGQQFqIgZHDQALIAohBgsCQAJAAkACQAJAAkACQAJAAkADQEEAIQcCfwJAIAIgBWtBCEkgCiAGa0EISXJFBEAgBiAMaikAACIPQsaMmbLkyJGjxgB8IA9CsODAgYOGjJgwfSIPhEKAgYKEiJCgwIB/g1ANAQtBAAwBCyAPQgp+IA9CCIh8Ig9CEIhC/4GAgPAfg0KBgICAgOIJfiAPQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiKchByAGQQhqIQYgBUEIaiEFQQgLIQMCQCACIAVNBEAgAyELDAELIAogBmsiCEEAIAggCk0bIgggA2ohCQNAIAgEQCAHQQpsIAYgDGotAABBMGtB/wFxaiEHIAVBAWohBSADQQFqIQsgBkEBaiEGIANBB0sNAiAIQQFrIQggCyEDIAIgBUsNAQwCCwsCQCABKAIQIgpFDQBBACEDAkAgBSABKAIUIgFFcg0AA0AgAyAKai0AAEEwRw0BIAEgA0EBaiIDRw0ACyABIQMLIAFBCGshDCACQQhrIQ4CQANAAkACQCACIAVrQQhJIAlBCmtBd0tyIAEgA2tBCElyDQAgDCADayELIA4gBWshCANAIAMgCmopAAAiD0LGjJmy5MiRo8YAfCAPQrDgwIGDhoyYMH0iD4RCgIGChIiQoMCAf4NCAFINASAPQgp+IA9CCIh8Ig9CEIhC/4GAgPAfg0KBgICAgOIJfiAPQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiKcgB0GAwtcvbGohByAFQQhqIQUgCUEIaiEGIANBCGohAyAIQQhJIAlBAmtBd0tyDQIgCEEIayEIIAtBB0sgC0EIayELIAYhCQ0ACwwBCyAJIQYLAkAgAiAFTSAGQQhLckUEQCADIAEgASADSRshCSAHIQgDQCADIAlGBEAgCCEHIAYhCQwGCyAIQQpsIAMgCmotAABBMGtB/wFxaiEIIAVBAWohBSAGQQFqIQcgA0EBaiEDIAZBB0sNAiAHIQYgAiAFSw0ACwwBCyAHIQggBiEHCwJAAkAgAiAFRwRAIAQvAfwDIgZFDQIgBkECdCEGIARBCGohB0IAIQ8MAQsCQCAHRQ0AAkAgB0EUSQRAAkAgBC8B/AMiBkUNACAGQQJ0IQYgB0EDdEHQ04ABajUCACERIARBCGohBUIAIQ8DQCAFIBEgBTUCAH4gD3wiED4CACAFQQRqIQUgEEIgiCEPIAZBBGsiBg0ACyAQQoCAgIAQVA0AIAQvAfwDIgZB/ABLDQIgBEEIaiAGQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAIRQ0CIARBCGohBUF/IQcDQAJAIAdBAWoiByAELwH8AyIGTwRAIAZB/ABLDQEgBEEIaiAGQQJ0aiAINgIAIAQgBC8B/ANBAWo7AfwDDAULIAUgBSgCACIGIAhqIgk2AgBBASEIIAVBBGohBSAGIAlLDQEMBAsLQdDVgAEQsjsACyAHQRRB8NSAARDDIQALQdDVgAEQsjsACyADIApqIQVBACADayEDA0AgASADakEHTQRAQQAgA2shAwNAIAEgA00NDiADIApqIANBAWohAy0AAEEwRg0ACwJAAkAgBC8B/AMiAUUNACABQQJ0IQUgBEEIaiEDQgAhDwNAIAMgAzUCAEIKfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBUEEayIFDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIBTwRAIAFB/ABNBEAgBEEIaiABQQJ0akEBNgIAIAQgBC8B/ANBAWo7AfwDDAILDBMLIAMgAygCAEEBaiIBNgIAIANBBGohAyABRQ0BCwsgAkEBaiEFDA8LDA8LIANBCGshAyAFKQAAIAVBCGohBUKw4MCBg4aMmDBRDQALAkACQCAELwH8AyIBRQ0AIAFBAnQhBSAEQQhqIQNCACEPA0AgAyADNQIAQgp+IA98IhA+AgAgA0EEaiEDIBBCIIghDyAFQQRrIgUNAAsgEEKAgICAEFQNACAELwH8AyIBQfwASw0BIARBCGogAUECdGogDz4CACAEIAQvAfwDQQFqOwH8AwsgBEEIaiEDQX8hBQNAAkAgBUEBaiIFIAQvAfwDIgFPBEAgAUH8AE0EQCAEQQhqIAFBAnRqQQE2AgAgBCAELwH8A0EBajsB/AMMAgsMEQsgAyADKAIAQQFqIgE2AgAgA0EEaiEDIAFFDQELCyACQQFqIQUMDQsMDQsDQCAHIAc1AgBCgJTr3AN+IA98IhA+AgAgB0EEaiEHIBBCIIghDyAGQQRrIgYNAAsgEEKAgICAEFQNACAELwH8AyIGQfwASw0CIARBCGogBkECdGogDz4CACAEIAQvAfwDQQFqOwH8AwtBACEHQQAhCSAIRQ0AIARBCGohBkF/IQsCQANAAkAgC0EBaiILIAQvAfwDIglPBEAgCUH8AEsNAyAEQQhqIAlBAnRqIAg2AgAgBCAELwH8A0EBajsB/AMMAQsgBiAGKAIAIgkgCGoiDTYCAEEBIQggBkEEaiEGIAkgDUsNAQsLQQAhCQwBCwtBwNWAARCyOwALQcDVgAEQsjsACyAJRQ0HAkACQCAELwH8AyIBRQ0AIAFBAnQhBiAJQQN0QdDTgAFqNQIAIREgBEEIaiEDQgAhDwNAIAMgESADNQIAfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBkEEayIGDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIAdFDQggBEEIaiEDQX8hBgNAAkAgBkEBaiIGIAQvAfwDIgFPBEAgAUH8AEsNASAEQQhqIAFBAnRqIAc2AgAgBCAELwH8A0EBajsB/AMMCwsgAyADKAIAIgEgB2oiAjYCAEEBIQcgA0EEaiEDIAEgAksNAQwKCwtB8NWAARCyOwALQfDVgAEQsjsACyACIAVGDQECQCAELwH8AyIDRQ0AIANBAnQhCCAEQQhqIQNCACEPA0AgAyADNQIAQoCU69wDfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gCEEEayIIDQALIBBCgICAgBBUDQAgBC8B/AMiA0H8AEsNAyAEQQhqIANBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIAdFDQAgBEEIaiEDQX8hCANAAkAgCEEBaiIIIAQvAfwDIglPBEAgCUH8AEsNASAEQQhqIAlBAnRqIAc2AgAgBCAELwH8A0EBajsB/AMMAwsgAyADKAIAIgkgB2oiCzYCAEEBIQcgA0EEaiEDIAkgC0sNAQwCCwsLQYDVgAEQsjsACyALRQ0CAkAgBC8B/AMiA0UNACADQQJ0IQUgC0EDdEHQ04ABajUCACERIARBCGohA0IAIQ8DQCADIBEgAzUCAH4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgNB/ABLDQIgBEEIaiADQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAHRQ0CIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIITwRAIAhB/ABLDQEgBEEIaiAIQQJ0aiAHNgIAIAQgBC8B/ANBAWo7AfwDDAULIAMgAygCACIIIAdqIgk2AgBBASEHIANBBGohAyAIIAlLDQEMBAsLQZDVgAEQsjsAC0GA1YABELI7AAtBkNWAARCyOwALIAYgDGohBUEAIAZrIQMDQCADIApqQQdNBEBBACADayEDAkADQCADIApPDQEgAyAMaiADQQFqIQMtAABBMEYNAAsCQAJAIAQvAfwDIgFFDQAgAUECdCEFIARBCGohA0IAIQ8DQCADIAM1AgBCCn4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgFB/ABLDQEgBEEIaiABQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAEQQhqIQNBfyEFA0ACQCAFQQFqIgUgBC8B/AMiAU8EQCABQfwATQRAIARBCGogAUECdGpBATYCACAEIAQvAfwDQQFqOwH8AwwCCwwKCyADIAMoAgBBAWoiATYCACADQQRqIQMgAUUNAQsLIAJBAWohBQwFCwwGCyABKAIQIgZFDQIgASgCFCEBQQAhAyAGIQUDQCABIANqQQdNBEBBACADayEDA0AgASADTQ0FIAMgBmogA0EBaiEDLQAAQTBGDQALAkACQCAELwH8AyIBRQ0AIAFBAnQhBSAEQQhqIQNCACEPA0AgAyADNQIAQgp+IA98IhA+AgAgA0EEaiEDIBBCIIghDyAFQQRrIgUNAAsgEEKAgICAEFQNACAELwH8AyIBQfwASw0BIARBCGogAUECdGogDz4CACAEIAQvAfwDQQFqOwH8AwsgBEEIaiEDQX8hBQNAAkAgBUEBaiIFIAQvAfwDIgFPBEAgAUH8AE0EQCAEQQhqIAFBAnRqQQE2AgAgBCAELwH8A0EBajsB/AMMAgsMDAsgAyADKAIAQQFqIgE2AgAgA0EEaiEDIAFFDQELCyACQQFqIQUMBgsMCAsgA0EIayEDIAUpAAAgBUEIaiEFQrDgwIGDhoyYMFENAAsCQAJAIAQvAfwDIgFFDQAgAUECdCEFIARBCGohA0IAIQ8DQCADIAM1AgBCCn4gD3wiED4CACADQQRqIQMgEEIgiCEPIAVBBGsiBQ0ACyAQQoCAgIAQVA0AIAQvAfwDIgFB/ABLDQEgBEEIaiABQQJ0aiAPPgIAIAQgBC8B/ANBAWo7AfwDCyAEQQhqIQNBfyEFA0ACQCAFQQFqIgUgBC8B/AMiAU8EQCABQfwATQRAIARBCGogAUECdGpBATYCACAEIAQvAfwDQQFqOwH8AwwCCwwKCyADIAMoAgBBAWoiATYCACADQQRqIQMgAUUNAQsLIAJBAWohBQwECwwGCyADQQhrIQMgBSkAACAFQQhqIQVCsODAgYOGjJgwUQ0ACwJAAkAgBC8B/AMiAUUNACABQQJ0IQUgBEEIaiEDQgAhDwNAIAMgAzUCAEIKfiAPfCIQPgIAIANBBGohAyAQQiCIIQ8gBUEEayIFDQALIBBCgICAgBBUDQAgBC8B/AMiAUH8AEsNASAEQQhqIAFBAnRqIA8+AgAgBCAELwH8A0EBajsB/AMLIARBCGohA0F/IQUDQAJAIAVBAWoiBSAELwH8AyIBTwRAIAFB/ABNBEAgBEEIaiABQQJ0akEBNgIAIAQgBC8B/ANBAWo7AfwDDAILDAcLIAMgAygCAEEBaiIBNgIAIANBBGohAyABRQ0BCwsgAkEBaiEFDAILDAMLIAIhBQsgACAEQQhqQfgD/AoAACAAIAU2AvgDIARBgARqJAAPC0Hg1YABELI7AAtBoNWAARCyOwALQbDVgAEQsjsAC6suAiN/B34jAEHwAmsiBCQAIARBCGogASACKAIkIgURBAAQxBsgBEGYAWogASACIAMQ2wEgBCgCoAEhByAEKAKcASEJAkACQCAEKAKYASIGQZOAgIB4RwRAIAAgBCkCpAEiJz4CDCAAIAc2AgggACAJNgIEIAAgJ0IgiD4CECAAIAY2AgAMAQsgBCAHNgKEASAEIAk2AoABIAQgAy0AMDYCiAEgASACKAI0EQQAIQ8gBEEANgKUASAEQoCAgIAQNwKMAQJAIAEgBREEACIhRQ0AIARBzABqISIgBEHYAGohECAEQagBaiERIARBmAJqIRIgBEEgaiETIARBzAJqIRggBEEUaiEZIARBEGohFCAEQUBrIRUgBEHkAGohDEEAIQMCQANAAkACQAJAAkACQAJAAkACQCAPBEAgAyAPKAIQTw0DIA8oAgQgDygCDCADaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgBEEANgKUASAEIAM2AowCIAQgBEGAAWoiATYCiAIgBEGYAWogBEGIAmogBEGMAWoiAkGI/v8AENMVIAQoApgBIgdBk4CAgHhGDQEgACAEKQKcATcCBCAAQQxqIARBpAFqKQIANwIAIAAgBzYCACACEN47IAEQvCoMCwsgDBDmOiAEKAJkRQ0CIAQoAnRBAWoiB0EDdiAHQQdxQQBHaiIBIAQoAnAiAksEQCABIAJrIQkgBCgCaCIFIAFJBEAgDCAFQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIFIAIgBUsbEOgZIAQoAnAhAgsgCQRAIAQoAmwgAmpBACAJ/AsACyAEIAE2AnALIAQgBzYCdCAEKAJIIgEgBCgCQEYEQCAVQfD0/wAQsSgLIAQoAkQgAUEEdGoiAkIANwMIIAJCADcDACAEIAFBAWo2AkgMBQsgBCAEKAKUASIHNgLcASAEIAQoApABIgk2AtgBAkAgB0ENTwRAIAQoAhAhASAEQQA2AhAgAQ0BDAULIARBADYC6AEgBEIANwPgASAHBEAgBEHgAWogCSAH/AoAAAsgBDUC6AEhJyAEKQPgASEpIAQoAkgiASAEKAJARgRAIBVB0PX/ABCxKAsgBCgCRCABQQR0aiICICc+AgwgAiApNwIEIAIgBzYCACAEIAFBAWo2AkggBCgCZARAIAQoAnQiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBCgCcCIBSwRAIAIgAWshBSAEKAJoIgYgAkkEQCAMIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBCgCcCEBCyAFBEAgBCgCbCABakEAIAX8CwALIAQgAjYCcAsgBCAJNgJ0IAQoAmwgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAYLIAQgBCgCeEEBajYCeAwFCyAYIBkpAgA3AgAgGEEIaiAZQQhqKAIANgIAIARB6AFqIhogE0EIaikDACInNwMAIARB8AFqIhsgE0EQaikDACIsNwMAIARB+AFqIhwgE0EYaikDACIrNwMAIAQgATYCyAIgBCATKQMAIik3A+ABICcgB60iKoUiKEI4hiAoQoD+A4NCKIaEIChCgID8B4NCGIYgKEKAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhELSgaqbq/qC16d/fiInQjiGICdCgP4Dg0IohoQgJ0KAgPwHg0IYhiAnQoCAgPgPg0IIhoSEICdCCIhCgICA+A+DICdCGIhCgID8B4OEICdCKIhCgP4DgyAnQjiIhISEIChC2KLR78Kp5b8tfoUgKnxCrf7V5NSF/ajYAH4hJwJAIAdBEE0EQCAnICl8IAkpAAAgLIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCAHIAlqQQhrKQAAICuFIihCf4V+IipCOIYgKkKA/gODQiiGhCAqQoCA/AeDQhiGICpCgICA+A+DQgiGhIQgKkIIiEKAgID4D4MgKkIYiEKAgPwHg4QgKkIoiEKA/gODICpCOIiEhISFIChCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJ36FQheJIScMAQsgJyApfCAsIAcgCWpBEGsiASkAAIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCArIAEpAAiFIihCf4V+IipCOIYgKkKA/gODQiiGhCAqQoCA/AeDQhiGICpCgICA+A+DQgiGhIQgKkIIiEKAgID4D4MgKkIYiEKAgPwHg4QgKkIoiEKA/gODICpCOIiEhISFIChCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJ36FQheJIScgK0J/hSEqIAkhASAHIQIDQCAnICl8ICwgASkAAIUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCABKQAIIi0gKoV+IihCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhISFICcgKyAthSIoQjiGIChCgP4Dg0IohoQgKEKAgPwHg0IYhiAoQoCAgPgPg0IIhoSEIChCCIhCgICA+A+DIChCGIhCgID8B4OEIChCKIhCgP4DgyAoQjiIhISEfoVCF4khJyABQRBqIQEgAkEQayICQRBLDQALCyAnIClCOIYgKUKA/gODQiiGhCApQoCA/AeDQhiGIClCgICA+A+DQgiGhIQgKUIIiEKAgID4D4MgKUIYiEKAgPwHg4QgKUIoiEKA/gODIClCOIiEhIR+ICdCOIYgJ0KA/gODQiiGhCAnQoCA/AeDQhiGICdCgICA+A+DQgiGhIQgJ0IIiEKAgID4D4MgJ0IYiEKAgPwHg4QgJ0IoiEKA/gODICdCOIiEhIQgKUJ/hX4iKUI4hiApQoD+A4NCKIaEIClCgID8B4NCGIYgKUKAgID4D4NCCIaEhCApQgiIQoCAgPgPgyApQhiIQoCA/AeDhCApQiiIQoD+A4MgKUI4iISEhIUgJ4khK0EAIRZBACEdQQAhHiMAQRBrIg0kACAEQcgCaiIBKAIIRQRAIA1BCGohF0EAIQUjAEHgAGsiAiQAIAIgBEHgAWo2AhwgASgCDCEIIAIgAkEcajYCIAJAIAggCEEBaiIGTQRAAkAgASgCBCIIIAhBAWpBA3ZBB2wgCEEISRsiCEEBdiAGSQRAAkACQCAIQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgAigCFCEFIAIoAhAiBkGBgICAeEcNBAsgAkHQAGogAUEQaiIKQQQgBRD7FCACKAJYIQUgAigCVCEGIAIoAlAiCEUNAyACIAIoAlw2AkwgAiAFNgJIIAIgBjYCRCACIAg2AkAgAkEIaiACQUBrEME0IAIoAgwiBQRAIAIoAghB/wEgBfwLAAsgAigCSCEFIAIoAkQhBiACKAJAIghFDQMgAiACKAJMNgI8IAIgBTYCOCACIAY2AjQgAiAINgIwIAJChICAgIABNwIoIAIgCjYCJCACQTBqISMgAiABKAIMIh8EfyAIQQhqISQgASgCACIgKQMAQn+FQoCBgoSIkKDAgH+DISpBACEOA0AgKlAEQANAIA5BCGohDiAgQQhqIiApAwBCgIGChIiQoMCAf4MiJ0KAgYKEiJCgwIB/UQ0ACyAnQoCBgoSIkKDAgH+FISoLIAggBiACKAIgKAIAIgopAwgiJyABKAIAICp6p0EDdiAOakECdCIla0EEazUCAIUiKUI4hiApQoD+A4NCKIaEIClCgID8B4NCGIYgKUKAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhELSgaqbq/qC16d/fiInQjiGICdCgP4Dg0IohoQgJ0KAgPwHg0IYhiAnQoCAgPgPg0IIhoSEICdCCIhCgICA+A+DICdCGIhCgID8B4OEICdCKIhCgP4DgyAnQjiIhISEIClC2KLR78Kp5b8tfoUiJ0I4hiAnQoD+A4NCKIaEICdCgID8B4NCGIYgJ0KAgID4D4NCCIaEhCAnQgiIQoCAgPgPgyAnQhiIQoCA/AeDhCAnQiiIQoD+A4MgJ0I4iISEhCAKKQMAIilCf4V+IihCOIYgKEKA/gODQiiGhCAoQoCA/AeDQhiGIChCgICA+A+DQgiGhIQgKEIIiEKAgID4D4MgKEIYiEKAgPwHg4QgKEIoiEKA/gODIChCOIiEhIQgJyApQjiGIClCgP4Dg0IohoQgKUKAgPwHg0IYhiApQoCAgPgPg0IIhoSEIClCCIhCgICA+A+DIClCGIhCgID8B4OEIClCKIhCgP4DgyApQjiIhISEfoUgJ4mnIiZxIgpqKQAAQoCBgoSIkKDAgH+DIidQBEBBCCELA0AgCiALaiEKIAtBCGohCyAIIAYgCnEiCmopAABCgIGChIiQoMCAf4MiJ1ANAAsLICpCAX0gKoMhKiAIICd6p0EDdiAKaiAGcSIKaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAIIApqICZBGXYiCzoAACAkIApBCGsgBnFqIAs6AAAgCCAKQQJ0a0EEayABKAIAICVrQQRrKAAANgAAIB9BAWsiHw0ACyABKAIMBUEACyIGNgI8IAIgBSAGazYCOCABICNBBBD6KiACQSRqEPUnDAELIAEgAkEgakGA3oABEO4JC0GBgICAeCEGDAELEN0nIAIoAgQhBSACKAIAIQYLIBcgBTYCBCAXIAY2AgAgAkHgAGokAAsgBEHYAmohAiAEQQhqIQogASgCBCIGICuncSEFICtCGYhC/wCDQoGChIiQoMCAAX4hKCAEQdgBaiIIKAIEIQ4gCCgCACELIAEoAgAhCANAAkAgBSAIaikAACIpICiFIidCf4UgJ0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEnAn8CQCACAn4CQANAICdQDQEgDSAKIAEoAgAgJ3qnQQN2IAVqIAZxIhdBAnRrQQRrKAIAEPgSICdCAX0gJ4MhJyALIA4gDSgCACANKAIEEJ87RQ0ACyACICs3AwggAiABKAIAQQAgF2tBAnRqNgIQQgAMAQsgKUKAgYKEiJCgwIB/gyEnIB5FBEAgJ1ANAiAneqdBA3YgBWogBnEhFgtBASAnIClCAYaDUA0CGiACIAggFmosAABBAE4EfyAIKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBYLNgIQIAIgKzcDCEIBCzcDACACIAE2AhQgDUEQaiQADAILQQALIR4gBSAdQQhqIh1qIAZxIQUMAQsLIAQoAtgCQQFGBEAgBCgC7AIiASgCACICIAQoAugCIgVqIgYtAAAhCCAEKAJIIQogBiAEKALgAkEZdiIGOgAAIAIgASgCBCAFQQhrcWpBCGogBjoAACABIAEoAgxBAWo2AgwgASABKAIIIAhBAXFrNgIIIAIgBUECdGtBBGsgCjYCACAEQaABaiAEQdACaikCADcDACAEIAQpAsgCNwOYASARQRhqIBwpAwA3AwAgEUEQaiAbKQMANwMAIBFBCGogGikDADcDACARIAQpA+ABNwMAIAQoAhAEQCAUEI47CyAUIARBmAFqQTD8CgAADAQLIAQoAugCQQRrKAIAIgIgBCgCSCIBTw0CIAQoAkQiByACQQR0aiICKQMIIScgAikDACEpIAQoAkAgAUYEfyAVQZD1/wAQsSggBCgCRAUgBwsgAUEEdGoiAiAnNwMIIAIgKTcDACAEIAFBAWo2AkgCQCAEKAJkBEAgBCgCdCIHQQFqIglBA3YgCUEHcUEAR2oiAiAEKAJwIgFLBEAgAiABayEFIAQoAmgiBiACSQRAIAwgBkEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiBiABIAZLGxDoGSAEKAJwIQELIAUEQCAEKAJsIAFqQQAgBfwLAAsgBCACNgJwCyAEIAk2AnQgBCgCbCAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBCAEKAJ4QQFqNgJ4CyASIAQpA+ABNwMAIARBkAJqIARB0AJqKQIANwMAIBJBCGogGikDADcDACASQRBqIBspAwA3AwAgEkEYaiAcKQMANwMAIAQgBCkCyAI3A4gCIAQoAhAEQCAUEI47CyAUIARBiAJqQTD8CgAADAQLQcz2/wBBIEHs9v8AEJ8pAAtBuPf/ABCyOwALIAIgAUGA9f8AEMMhAAsgBCgCWCAEKAJgIgEgB2pJBEAgAQRAIARBwAJqIBBBCGooAgA2AgAgBCAQKQIANwO4AiAEQQA2AmAgBEKAgICAEDcDWCAEQcgCaiAEQbgCahDyLyAEIAQpAsgCNwLkAiAEQQA2AuACIAQgBCgC1AIiAjYC3AIgBCAEKALQAjYC2AIgBCAEQdgCahDXOyAEKAIAIQhBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAtgCNwIIIAFBEGogBEHgAmopAgA3AgAgAUEYaiAEQegCaigCADYCACACQX9GDQUgBCgCVCIFIAQoAkxGBEAgIkGI9v8AEJAoCyAEKAJQIAVBDGxqIgYgAjYCCCAGIAg2AgQgBiABNgIAIAQgBUEBajYCVAsgECAEQQhqENcqIgEgByABIAdLGxCELiAEKAJgIQELIBAgCSAHEKE2IAQ1AlQgAa1CIIaEIScgB60gCTUAAEIghoQhKSAEKAJIIgEgBCgCQEYEQCAVQcD1/wAQsSgLIAQoAkQgAUEEdGoiAiAnNwMIIAIgKTcDACAEIAFBAWo2AkggBCgCZARAIAQoAnQiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBCgCcCIBSwRAIAIgAWshBSAEKAJoIgYgAkkEQCAMIAZBAXQiASACQcD///8DcUFAayACIAJBP3EbIgYgASAGSxsQ6BkgBCgCcCEBCyAFBEAgBCgCbCABakEAIAX8CwALIAQgAjYCcAsgBCAJNgJ0IAQoAmwgB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAQgBCgCeEEBajYCeAsgA0EBaiIDICFHDQEMAwsLQQRBHBCjPQALIARBADYC6AIgBEEBNgLcAiAEQfD1/wA2AtgCIARCBDcC4AIgBEHYAmpB+PX/ABDvLAALIARBmAFqIgIgBEEIahDbDEHEAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEGw/f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIARBjAFqEN47IARBgAFqELwqCyAEQUBrEOY8IAQoAmQEQCAEQeQAahDPLwsgBEHMAGoiABDFJyAAEOg7IARB2ABqEN47IAQoAhAEQCAEQRBqEI47CyAEQfACaiQADwtBBEHEABCjPQALyiQCD38DfiMAQcAJayIDJAAgAQJ/AkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A8AJBAWsOAxYNAQALIANBGGoiBRC7LyADQZABaiIEIAUgASgC7AIiBQR/QQJBACAFLQAEGwVBAAsQliogASgC6AIhBSABIARB4AL8CgAAIAFBADoA5AIgASAFNgLgAiABQeQCaiENDAELIAFB5AJqIQ0CQCABLQDkAkEBaw4DEAwCAAsgASgC4AIhBQsgAUH4AGoiBCABQfgA/AoAACABQQA6AIECIAEgBTYC/AEgASAENgL4ASABQfABaiEIIAFBgQJqIQ4MAQsgAUHwAWohCCABQYECaiEOAkAgAS0AgQJBAWsOBAgKAgkACyABKAL8ASEFIAEoAvgBIQQLIAFBAToAgAIgASAENgLwASABQQA6AJQCIAEgBDYChAIgASAFNgL0ASABIAFB9AFqIgU2AogCIAFBlAJqIQogAUGEAmohDwwBCyABQYQCaiEPIAFBlAJqIQoCQCABLQCUAkEBaw4EDQgCBAALIAEoAogCIQUgASgChAIhBAsgASAFNgKQAiABIAQ2AowCIAQoAgAhBiAEKAIEIQQgA0EAOgAgIAMgBTYCGCADQQggBCAEQQhNG0EIIAYbNgIcIANBEGogA0EYahDPKSADKAIQIQQgASADKAIUIgU2ApwCIAEgBDYCmAIMAQsgASgCnAIhBSABKAKYAiEECyADQRhqIAQgAiAFKAIMEQEAQQMgAygCGCIEQQlGDQ8aIAMgAykAITcDmAggAyADQShqKAAANgCfCCADLQAgIQcgAygCHCEGIAMoAiwhCSABQZgCahC8KiAEQQhHBEAgAyADKACfCDYAlwkgAyADKQOYCDcDkAkMFAsgASADKQOYCDcAvQIgASAHOgC8AiABIAY2ArgCIAFBxAJqIAMoAJ8INgAAIAMgASgCwAIiBTYCpAggBUEISQ0BIAFCADcDoAIgASABKAK8AiAFakEIaykAADcDoAIgA0EYaiABQaACahCKGSADLQAgIQcgAygCHCEGIAMoAhgiBEEIRwRAIAMgAykAITcDkAkgAyADQShqKAAANgCXCSADKAIsIQkMEgsgASAHOgCsAiABIAY2AqgCIAEgBjYCmAIgASAGQQhqIgc2ApwCIAYgBUEIayIESw0MIAQgBSAHayIFSQ0KIAQgASgCwAIiB0sNCyADQRhqIAEoAowCIAEoArwCIAVqIAYgAUGoAmoQ/xkgAyADKQAhNwOgBiADIANBKGooAAA2AKcGIAMoAiwhCSADLQAgIQcgAygCHCEGIAMoAhghBCADKAJoIgtBgICAgHhGBEAgAyADKQOgBjcDkAkgAyADKACnBjYAlwkMEgsgA0HYCGogA0EwakE4/AoAACADQagJaiADQfQAaigCADYCACADIAMpAmw3A6AJIAMgAykDoAY3A5AJIAMgAygApwY2AJcJIANBGGogAUG4AmogBRDNFSADQdAIaiADQSRqKAIANgIAIAMgAykCHDcDyAggAygCGCEMDBILIAEoArQCIQUgASgCsAIhBAwNC0ECIQQgA0ECNgIcIANBnPzCADYCGCADQgI3AiQgA0E7NgKsBiADQTs2AqQGIANB4PvCADYCoAYgAyADQaAGajYCICADIANBpAhqNgKoBiADQbAJaiADQRhqEJkOIAMgAygAtQk2ApAJIAMgA0G4CWooAAA2AJMJIAMoArAJIQYgAy0AtAkhBwwPC0Gw+8IAEOgrAAsgAUGIAmohCiABQdgCaiEFIAEtANgCQQFrDgMDAAIBCwALIAEoAqQCIQYgASgCoAIhBAwPCyABKAKcAiEGIAEoApgCIQQMDwtBuP3CABDoKwALQdD8wgAQ6CsAC0HA+8IAEOgrAAsgBSAEQdD7wgAQsTsACyAEIAdB0PvCABCwOwALIAEoApACIQQgA0EAOgAgIAMgBzYCHCADIAQ2AhggA0EIaiADQRhqEM8pIAMoAgghBCABIAMoAgwiBTYCtAIgASAENgKwAgwBC0HA+sIAEOgrAAsgA0EYaiAEIAIgBSgCDBEBACADKAIYIgRBCUcNAUEECyEBIAogAToAAEEDDA8LIAMgAykAITcDqAggAyADQShqKAAANgCvCCADLQAgIQcgAygCHCEGIAMoAiwhCSABQbACahC8KiAEQQhHBEAgAyADKACvCDYAlwkgAyADKQOoCDcDkAkMAQsgA0G8CWoiBSADKACvCDYAACADIAMpA6gINwC1CSADIAc6ALQJIAMgBjYCsAkgAygCuAkiBCABKAKcAk8EQCABKAKMAiEEIANBoAZqIANBsAlqQQAgASgCmAIQ0hAgA0EYaiAEIAMoAqQGIAMoAqgGIAFBqAJqEP8ZIAMgAykAITcDuAggAyADQShqKAAANgC/CCADKAIsIQkgAy0AICEHIAMoAhwhBiADKAIYIQQgAygCaCILQYCAgIB4RgRAIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIAUgAygCtAkgAygCuAkgAygCsAkoAhARAQAgA0GsBmogAygCpAYgAygCqAYgAygCoAYoAhARAQAMAgsgA0HYCGogA0EwakE4/AoAACADQagJaiADQfQAaigCADYCACADIAMpAmw3A6AJIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIANBvAlqIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIAMgBDYCxAhBAiEEIANBAjYCHCADQcD8wgA2AhggA0ICNwIkIANBOzYCrAYgA0E7NgKkBiADIAFBnAJqNgKgBiADIANBoAZqNgIgIAMgA0HECGo2AqgGIANBuAhqIANBGGoQmQ4gAyADKAC9CDYCkAkgAyADQcAIaigAADYAkwkgAygCuAghBiADLQC8CCEHIAUgAygCtAkgAygCuAkgAygCsAkoAhARAQALIAFBxAJqIAEoArwCIAEoAsACIAEoArgCKAIQEQEADAELIAFBxAJqIAEoArwCIAEoAsACIAEoArgCKAIQEQEADAELQYCAgIB4IQsLIAMgAygAlwk2AJcHIAMgAykDkAk3A5AHIANB2AZqIANB2AhqQTj8CgAAIANB0AZqIgUgA0GoCWooAgA2AgAgA0HABmoiECADQdAIaigCADYCACADIAMpA6AJNwPIBiADIAMpA8gINwO4BiAKQQE6AAAgAyADKQOQBzcD+AcgAyADKACXBzYA/wcgA0HAB2oiESADQdgGakE4/AoAACADQbgHaiIKIAUoAgA2AgAgA0GoB2oiBSAQKAIANgIAIAMgAykDyAY3A7AHIAMgAykDuAY3A6AHIA8QoykgC0GAgICAeEYNBCADQbAGaiAFKAIANgIAIAMgDDYCpAYgA0EANgKgBiADIAMpA6AHNwKoBiAIKAIAQRBqENIWIAgoAgAiBSAHOgAYIAUgBjYCFCAFIAQ2AhAgBSADKQP4BzcAGSAFIAk2AiQgBUEgaiADKAD/BzYAACAFQShqIBFBOPwKAAAgBSALNgJgIAVB7ABqIAooAgA2AgAgBSADKQOwBzcCZAJAIAgoAgAiBC0AcEUEQCAELQBxRQ0BCyABQQA6AIACIAEgBDYCoAIgASADKQKgBjcCqAIgAUEAOgDYAiABIAEoAvQBIgY2AqQCIAFBsAJqIANBqAZqKQIANwIAIAFBuAJqIANBsAZqKAIANgIAIAFBiAJqIQogAUHYAmohBQwBC0EIIQQgDEUNDSADQbAGaiADKAKoBiADKAKsBiAMKAIQEQEADA0LIAEgBjYCwAIgASAENgK8AiABIAEpAqgCNwLEAiABQdQCaiABQbgCaigCADYCACABQcwCaiABQbACaikCADcCAAJAIAQoAmBBgICAgHhHBEAgA0HYBmogBBDcCyADKALYBkUNAyABIAMpA+gGIhM3A5ACIAEgAykD4AYiEjcDiAIgASgCyAIEQCASIAFBxAJqNQIAIhRaDQILIAEoAsACIQQgA0EAOgAsIAMgEzcDICADIBI3AxggAyAENgIoIAMgA0EYahDNKSADKAIAIQQgASADKAIEIgY2ApwCIAEgBDYCmAIMAgsgA0EYakEeQQBBAUEBEKAYIAMoAhwhBCADKAIYQQFGDQUgAygCICECIANBADYC2AggAkEWakGu/cIAKQAANwAAIAJBEGpBqP3CACkAADcAACACQQhqQaD9wgApAAA3AAAgAkGY/cIAKQAANwAAIANBHjYC5AggAyACNgLgCCADIAQ2AtwIDAgLIBIgFH0iEkKAgICAEFoEQCADQdgIahDbJAwICyATIBR9IhNCgICAgBBaBEAgA0HYCGoQ2yQMCAsgE6ciAiABKALQAksNBSADQaAJaiABQcgCaiASpyACENIQDAYLIANBGGogBCACIAYoAgwRAQAgAygCGCICQQlHDQEgBUEDOgAADAcLIANBCDYC2AgMBQsgA0G4CWoiBCADQSRqKQIANwMAIAMgAykCHDcDsAkgAygCLCEGIAFBmAJqELwqIAJBCEcEQCADQeQIaiAEKQMANwIAIAMgAykDsAk3AtwIIAMgBjYC7AggAyACNgLYCAwFCyADQagJaiAEKQMANwMAIAMgAykDsAk3A6AJDAMLIAFBgAI7AYACIAMgAykD+Ac3A4gIIAMgAygA/wc2AI8IIARBCUYNBgwJCyAEIAMoAiBB7P/CABD9LwALQeD8wgBBKEGI/cIAEJ8pAAsgAyADNQKoCSISNwPIBiADIAEpA5ACIAEpA4gCIhN9IhQ3A7gIIBIgFFIEQCADQQA2AhggA0HIBmogA0G4CGogA0EYakHI/cIAEK4rAAsgA0EYaiICIAEoArwCIANBoAlqIgYgExCmEgJAIAMoAhgiBEEIRw0AIAIgASgCvAIgBiABKQOIAhCfBiADKAIYIgRBCEcNACADQQg2AtgIIANBrAlqIAMoAqQJIAMoAqgJIAMoAqAJKAIQEQEADAELIANB7AhqIANBLGooAgA2AgAgA0HkCGogA0EkaikCADcCACADIAMpAhw3AtwIIAMgBDYC2AggA0GsCWogAygCpAkgAygCqAkgAygCoAkoAhARAQALIAEoAsgCIgIEQCABQdQCaiABKALMAiABKALQAiACKAIQEQEACyADIAMpAOEINwPICCADIANB6AhqKAAANgDPCCADLQDgCCEHIAMoAtwIIQYgAygC7AghCSADKALYCCEEIAVBAToAACAEQQlHDQMLQQQLIQEgDiABOgAACyANQQM6AAAMAwsgAyADKADPCDYAjwggAyADKQPICDcDiAggChDFIQsgAUGAAjsBgAILIAMgAygAjwg2ALcFIAMgAykDiAg3A7AFIAgQmCwCfyAEQQhHBEAgA0HQBWogAygAtwU2AAAgAyADKQOwBTcAyQUgAyAJNgLUBSADIAc6AMgFQYCAgIB4DAELIANBwAVqIAFB+ABqEP4UIAMoAsQFIQYgAygCwAUhBCADKAKQBgshAiABQYgBahDSFiADQcAEaiIFIANB0AVqKQMANwMAIAMgAykDyAU3A7gEIANBgARqIgggA0HYBWpBOPwKAAAgAUEBOgDkAiADQfgDaiIHIANBnAZqKAIANgIAIAMgAykClAY3A/ADIAJBgYCAgHhGDQAgA0GYBWoiCSAFKQMANwMAIAMgAykDuAQ3A5AFIANB2ARqIAhBOPwKAAAgA0HQBGogBygCADYCACADIAMpA/ADNwPIBCABEPcsAkACQCACQYCAgIB4RgRAIANBqAVqIAkpAwA3AwAgAyADKQOQBTcDoAUgBCEIIAYhBQwBC0EIIQhB6ABBCBCtNiIFRQ0BIAUgBjYCDCAFIAQ2AgggBUKBgICAEDcDACAFIAMpA5AFNwMQIAVBGGogA0GYBWopAwA3AwAgBUEgaiADQdgEakE4/AoAACAFIAI2AlggBSADKQPIBDcCXCAFQeQAaiADQdAEaigCADYCAAsgACAFNgIEIAAgCDYCACAAIAMpA6AFNwMIIABBEGogA0GoBWopAwA3AwBBAQwCC0EIQegAEKM9AAsgAEEJNgIAQQMLOgDwAiADQcAJaiQAC6cmAg9/A34jAEHACWsiAyQAIAECfwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAIAEtAOwCQQFrDgMWDQEACyADQfgCaiIEELsvIANBGGoiBiAEQQEQliogASgC6AIhBSABIAZB4AL8CgAAIAFBADoA5AIgASAFNgLgAiABQeQCaiEODAELIAFB5AJqIQ4CQCABLQDkAkEBaw4DEAwCAAsgASgC4AIhBQsgAUH4AGoiBCABQfgA/AoAACABQQA6AIECIAEgBTYC/AEgASAENgL4ASABQfABaiEIIAFBgQJqIQ8MAQsgAUHwAWohCCABQYECaiEPAkAgAS0AgQJBAWsOBAgKAgkACyABKAL8ASEFIAEoAvgBIQQLIAFBAToAgAIgASAENgLwASABQQA6AJQCIAEgBDYChAIgASAFNgL0ASABIAFB9AFqIgU2AogCIAFBlAJqIQogAUGEAmohEAwBCyABQYQCaiEQIAFBlAJqIQoCQCABLQCUAkEBaw4EDQgCBAALIAEoAogCIQUgASgChAIhBAsgASAFNgKQAiABIAQ2AowCIAQoAgAhBiAEKAIEIQQgA0EAOgCkAyADIAU2AvgCIANBCCAEIARBCE0bQQggBhs2AvwCIANBEGogA0H4AmoQzCkgAygCECEEIAFBzN3CADYCnAIgASAENgKYAkHM3cIADAELIAEoApgCIQQgASgCnAILIQUgA0H4AmogBCACIAUoAgwRAQBBAyADKAL4AiIEQQlGDQ8aIAMgAykAgQM3A5gIIAMgA0GIA2ooAAA2AJ8IIAMtAIADIQcgAygC/AIhBiADKAKMAyEJIAFBmAJqELwqIARBCEcEQCADIAMoAJ8INgCXCSADIAMpA5gINwOQCQwUCyABIAMpA5gINwC9AiABIAc6ALwCIAEgBjYCuAIgAUHEAmogAygAnwg2AAAgAyABKALAAiIFNgKkCCAFQQhJDQEgAUIANwOgAiABIAEoArwCIAVqQQhrKQAANwOgAiADQfgCaiABQaACahCKGSADLQCAAyEHIAMoAvwCIQYgAygC+AIiBEEIRwRAIAMgAykAgQM3A5AJIAMgA0GIA2ooAAA2AJcJIAMoAowDIQkMEgsgASAHOgCsAiABIAY2AqgCIAEgBjYCmAIgASAGQQhqIgc2ApwCIAYgBUEIayIESw0MIAQgBSAHayIFSQ0KIAQgASgCwAIiB0sNCyADQfgCaiABKAKMAiABKAK8AiAFaiAGIAFBqAJqEP8ZIAMgAykAgQM3A6AGIAMgA0GIA2ooAAA2AKcGIAMoAowDIQkgAy0AgAMhByADKAL8AiEGIAMoAvgCIQQgAygCyAMiC0GAgICAeEYEQCADIAMpA6AGNwOQCSADIAMoAKcGNgCXCQwSCyADQdgIaiADQZADakE4/AoAACADQagJaiADQdQDaigCADYCACADIAMpAswDNwOgCSADIAMpA6AGNwOQCSADIAMoAKcGNgCXCSADQfgCaiABQbgCaiAFEM0VIANB0AhqIANBhANqKAIANgIAIAMgAykC/AI3A8gIIAMoAvgCIQwMEgsgASgCtAIhBSABKAKwAiEEDA0LQQIhBCADQQI2AvwCIANBmPDCADYC+AIgA0ICNwKEAyADQTs2AqwGIANBOzYCpAYgA0H478IANgKgBiADIANBoAZqNgKAAyADIANBpAhqNgKoBiADQbAJaiADQfgCahCZDiADIAMoALUJNgKQCSADIANBuAlqKAAANgCTCSADKAKwCSEGIAMtALQJIQcMDwtByO/CABDoKwALIAFBiAJqIQogAUHYAmohBSABLQDYAkEBaw4DAwACAQsACyABKAKkAiEGIAEoAqACIQQMDwsgASgCnAIhBiABKAKYAiEEDA8LQZDxwgAQ6CsAC0Go8MIAEOgrAAtB2O/CABDoKwALIAUgBEHo78IAELE7AAsgBCAHQejvwgAQsDsACyABKAKQAiEEIANBADoApAMgAyAENgL4AiADIAc2AvwCIANBCGogA0H4AmoQzCkgAygCCCEEQczdwgAhBSABQczdwgA2ArQCIAEgBDYCsAIMAQtB3PTCABDoKwALIANB+AJqIAQgAiAFKAIMEQEAIAMoAvgCIgRBCUcNAUEECyEBIAogAToAAEEDDA8LIAMgAykAgQM3A6gIIAMgA0GIA2ooAAA2AK8IIAMtAIADIQcgAygC/AIhBiADKAKMAyEJIAFBsAJqELwqIARBCEcEQCADIAMoAK8INgCXCSADIAMpA6gINwOQCQwBCyADQbwJaiIFIAMoAK8INgAAIAMgAykDqAg3ALUJIAMgBzoAtAkgAyAGNgKwCSADKAK4CSIEIAEoApwCTwRAIAEoAowCIQQgA0GgBmogA0GwCWpBACABKAKYAhDSECADQfgCaiAEIAMoAqQGIAMoAqgGIAFBqAJqEP8ZIAMgAykAgQM3A7gIIAMgA0GIA2ooAAA2AL8IIAMoAowDIQkgAy0AgAMhByADKAL8AiEGIAMoAvgCIQQgAygCyAMiC0GAgICAeEYEQCADIAMpA7gINwOQCSADIAMoAL8INgCXCSAFIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIANB2AhqIANBkANqQTj8CgAAIANBqAlqIANB1ANqKAIANgIAIAMgAykCzAM3A6AJIAMgAykDuAg3A5AJIAMgAygAvwg2AJcJIANBvAlqIAMoArQJIAMoArgJIAMoArAJKAIQEQEAIANBrAZqIAMoAqQGIAMoAqgGIAMoAqAGKAIQEQEADAILIAMgBDYCxAhBAiEEIANBAjYC/AIgA0Go78IANgL4AiADQgI3AoQDIANBOzYCrAYgA0E7NgKkBiADIAFBnAJqNgKgBiADIANBoAZqNgKAAyADIANBxAhqNgKoBiADQbgIaiADQfgCahCZDiADIAMoAL0INgKQCSADIANBwAhqKAAANgCTCSADKAK4CCEGIAMtALwIIQcgBSADKAK0CSADKAK4CSADKAKwCSgCEBEBAAsgAUHEAmogASgCvAIgASgCwAIgASgCuAIoAhARAQAMAQsgAUHEAmogASgCvAIgASgCwAIgASgCuAIoAhARAQAMAQtBgICAgHghCwsgAyADKACXCTYAlwcgAyADKQOQCTcDkAcgA0HYBmoiDSADQdgIakE4/AoAACADQdAGaiIFIANBqAlqKAIANgIAIANBwAZqIhEgA0HQCGooAgA2AgAgAyADKQOgCTcDyAYgAyADKQPICDcDuAYgCkEBOgAAIAMgAykDkAc3A/gHIAMgAygAlwc2AP8HIANBwAdqIgogDUE4/AoAACADQbgHaiINIAUoAgA2AgAgA0GoB2oiBSARKAIANgIAIAMgAykDyAY3A7AHIAMgAykDuAY3A6AHIBAQoykgC0GAgICAeEYNBCADQbAGaiAFKAIANgIAIAMgDDYCpAYgA0EANgKgBiADIAMpA6AHNwKoBiAIKAIAQRBqENIWIAgoAgAiBSAHOgAYIAUgBjYCFCAFIAQ2AhAgBSADKQP4BzcAGSAFIAk2AiQgBUEgaiADKAD/BzYAACAFQShqIApBOPwKAAAgBSALNgJgIAVB7ABqIA0oAgA2AgAgBSADKQOwBzcCZAJAIAgoAgAiBC0AcEUEQCAELQBxRQ0BCyABQQA6AIACIAEgBDYCoAIgASADKQKgBjcCqAIgAUEAOgDYAiABIAEoAvQBIgY2AqQCIAFBsAJqIANBqAZqKQIANwIAIAFBuAJqIANBsAZqKAIANgIAIAFBiAJqIQogAUHYAmohBQwBC0EIIQQgDEUNDSADQbAGaiADKAKoBiADKAKsBiAMKAIQEQEADA0LIAEgBjYCwAIgASAENgK8AiABIAEpAqgCNwLEAiABQdQCaiABQbgCaigCADYCACABQcwCaiABQbACaikCADcCAAJAIAQoAmBBgICAgHhHBEAgA0HYBmogBBDcCyADKALYBkUNAyABIAMpA+gGIhM3A5ACIAEgAykD4AYiEjcDiAIgASgCyAIEQCASIAFBxAJqNQIAIhRaDQILIAEoAsACIQYjAEHgAGsiBCQAIARB1ABqIAZBCGoQ3SAgBigCFCIGIAYoAgAiB0EBajYCACAHQQBIBEAACyAEQcgAaiAEQdwAaigCADYCACAEIAQpAlQ3A0AgBCAGNgI8IARBADoATCAEIBM3AxAgBCASNwMIIARBCGohBwJAQcgAQQgQrTYiBgRAIAYgB0HIAPwKAAAgBEH83cIANgIEIAQgBjYCAAwBC0EIQcgAEKM9AAsgAyAEKQMANwMAIARB4ABqJAAgAygCACEEQfzdwgAhBiABQfzdwgA2ApwCIAEgBDYCmAIMAgsgA0HYCGpBHkEAQQFBARCgGCADKALcCCEEIAMoAtgIQQFGDQUgAygC4AghAiADQQA2AvgCIAJBFmpBhvHCACkAADcAACACQRBqQYDxwgApAAA3AAAgAkEIakH48MIAKQAANwAAIAJB8PDCACkAADcAACADQR42AoQDIAMgAjYCgAMgAyAENgL8AgwICyASIBR9IhJCgICAgBBaBEAgA0H4AmoQ2yQMCAsgEyAUfSITQoCAgIAQWgRAIANB+AJqENskDAgLIBOnIgIgASgC0AJLDQUgA0GgCWogAUHIAmogEqcgAhDSEAwGCyADQdgIaiAEIAIgBigCDBEBACADKALYCCICQQlHDQEgBUEDOgAADAcLIANBCDYC+AIMBQsgA0G4CWoiBCADQeQIaikCADcDACADIAMpAtwINwOwCSADKALsCCEGIAFBmAJqELwqIAJBCEcEQCADQYQDaiAEKQMANwIAIAMgAykDsAk3AvwCIAMgBjYCjAMgAyACNgL4AgwFCyADQagJaiAEKQMANwMAIAMgAykDsAk3A6AJDAMLIAFBgAI7AYACIAMgAykD+Ac3A4gIIAMgAygA/wc2AI8IIARBCUYNBgwJCyAEIAMoAuAIQdzzwgAQ/S8AC0G48MIAQShB4PDCABCfKQALIAMgAzUCqAkiEjcDyAYgAyABKQOQAiABKQOIAiITfSIUNwO4CCASIBRSBEAgA0EANgLYCCADQcgGaiADQbgIaiADQdgIakGg8cIAEK4rAAsgA0HYCGoiAiABKAK8AiADQaAJaiIGIBMQphICQCADKALYCCIEQQhHDQAgAiABKAK8AiAGIAEpA4gCEJ8GIAMoAtgIIgRBCEcNACADQQg2AvgCIANBrAlqIAMoAqQJIAMoAqgJIAMoAqAJKAIQEQEADAELIANBjANqIANB7AhqKAIANgIAIANBhANqIANB5AhqKQIANwIAIAMgAykC3Ag3AvwCIAMgBDYC+AIgA0GsCWogAygCpAkgAygCqAkgAygCoAkoAhARAQALIAEoAsgCIgIEQCABQdQCaiABKALMAiABKALQAiACKAIQEQEACyADIAMpAIEDNwPICCADIANBiANqKAAANgDPCCADLQCAAyEHIAMoAvwCIQYgAygCjAMhCSADKAL4AiEEIAVBAToAACAEQQlHDQMLQQQLIQEgDyABOgAACyAOQQM6AAAMAwsgAyADKADPCDYAjwggAyADKQPICDcDiAggChDFIQsgAUGAAjsBgAILIAMgAygAjwg2ALcFIAMgAykDiAg3A7AFIAgQmCwCfyAEQQhHBEAgA0HQBWogAygAtwU2AAAgAyADKQOwBTcAyQUgAyAJNgLUBSADIAc6AMgFQYCAgIB4DAELIANBwAVqIAFB+ABqEP4UIAMoAsQFIQYgAygCwAUhBCADKAKQBgshAiABQYgBahDSFiADQcAEaiIFIANB0AVqKQMANwMAIAMgAykDyAU3A7gEIANBgARqIgggA0HYBWpBOPwKAAAgAUEBOgDkAiADQfgDaiIHIANBnAZqKAIANgIAIAMgAykClAY3A/ADIAJBgYCAgHhGDQAgA0GYBWoiCSAFKQMANwMAIAMgAykDuAQ3A5AFIANB2ARqIAhBOPwKAAAgA0HQBGogBygCADYCACADIAMpA/ADNwPIBCABEPcsAkACQCACQYCAgIB4RgRAIANBqAVqIAkpAwA3AwAgAyADKQOQBTcDoAUgBCEIIAYhBQwBC0EIIQhB6ABBCBCtNiIFRQ0BIAUgBjYCDCAFIAQ2AgggBUKBgICAEDcDACAFIAMpA5AFNwMQIAVBGGogA0GYBWopAwA3AwAgBUEgaiADQdgEakE4/AoAACAFIAI2AlggBSADKQPIBDcCXCAFQeQAaiADQdAEaigCADYCAAsgACAFNgIEIAAgCDYCACAAIAMpA6AFNwMIIABBEGogA0GoBWopAwA3AwBBAQwCC0EIQegAEKM9AAsgAEEJNgIAQQMLOgDsAiADQcAJaiQAC7lFAhV/AX4jAEHgMGsiCSQAQQIhDQJAAkACQAJAAkACQCAARQRAIAEoAoAOQRxJDQELIAFB8A1qIQ8CQCAADQAgASgC+A1BwABHDQAgDyACIAMQyyBFDQELIAEoAtgPIQogCSABKALQDyIFNgIEIAlB0CBqIgQQhSAgCUEYaiABQaAOaiIGKQIANwMAIAlBEGogAUGYDmoiBykCADcDACABKQKQDiEZIAEgCSkC0CA3ApAOIAcgCUHYIGoiBykCADcCACAGIAlB4CBqIgYpAgA3AgAgCSAZNwMIIAQQhSAgCUEwaiABQdAOaiIMKQIANwMAIAlBKGogAUHIDmoiCCkCADcDACABKQLADiEZIAEgCSkC0CA3AsAOIAggBykCADcCACAMIAYpAgA3AgAgCSAZNwMgIAQQhSAgCUHIAGogAUG4DmoiDCkCADcDACAJQUBrIAFBsA5qIggpAgA3AwAgASkCqA4hGSABIAkpAtAgNwKoDiAIIAcpAgA3AgAgDCAGKQIANwIAIAkgGTcDOCABQYgPaiEXIAFB4A1qIRYgAEEBcyESIAFBqA5qIRMgAUHADmohFCABQZAOaiEVIAlB0ABqIAlBCGoQsRUgCUHQEGogCUEgahCxFSAEIAlBOGoQsRUgAS0AihEhCAJAAkACQAJAA0AgBSEHIAUhBgNAQWEhDQJAAkACQAJAAkACQCAIQf8BcUEHaw4EAAEDAgkLQQIhDSAARQRAIAEoAoAOQRtNDQkLIAEoAqwPRQRAIAAgFyAPQQEgAiADENoHRQ0JQQchCCABQQc6AIoRIAEgASgCwA87AfAQDAYLAn8gCUEEaiEQIAlB0CBqIQUjAEEQayIEJAAgBEEANgIEIARBADYCCCAEQQA2AgwCQAJAAkACQAJ/IAECfwJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQCAARQRAIAEvAfAQIgdBgAJJBEAgBSAHQQN0aiIFKAIEIQcgBSgCACELIAEpA/ANIRkgASgC+A0iBUEwTwRAIAEgGUIwiCIZNwPwDSABKAL8DSIGQQhqIQwgBkF3Sw0DIAMgDEkNKSABIAZBBmo2AvwNIAEgASgCgA5BBms2AoAOIAEgAiAGaiIGNQAAQhCGIAYxAARCMIaEIAYxAAVCOIaEIBmEIhk3A/ANIAVBMHMhBQsgGSAFQT9xrYinIg5B/wFxIgwgB08NAyALIAxBAnRqIgYvAQAhCCAGLQACIgZBCEsEQCAGQQhrQf8BcSIGQSFPDQUgCCAMaiAGQQJ0Qfic8wBqKAIAIA5BCHZxaiIGIAdPDQYgCyAGQQJ0aiIHLQACIQYgBy8BACEIIAVBCGohBQsgASAFIAZqNgL4DUEAIQxCACEZQQAhBkEAIQsgCAwHCyAHQYACQcSn8wAQwyEACyABLwHwECIHQYACSQ0EIAdBgAJB1KfzABDDIQALIAYgDEGcnvMAELE7AAsgDCAHQaye8wAQwyEACyAGQSFB/J3zABDDIQALIAYgB0G8nvMAEMMhAAsgASgCgA4hCyABKAL8DSEGIAEoAvgNIQwgASkD8A0hGUEAIAUgB0EDdGoiBSgCACAFKAIEIAFB8A1qIARBBGogAiADEJ8TRQ0LGiAEKAIECyIFQcAFSQRAIAEgBUEDdCIFQeun8wBqLQAAIgc2AoQQIAEgBUHqp/MAaiwAADYCqBAgByABKAL4D2oiByABKALkDiIITw0BIAVB5qfzAGovAQAhESAFQemn8wBqLQAAIQ4gBUHop/MAai0AACEIIBAgBUHkp/MAai8BACIYNgIAIAEgASgC4A4gB2otAAA6AIURIAANAiAIDQMgASgC+A0hBQwJCyAFQcAFQeTT8wAQwyEACyAHIAhB9NPzABDDIQALIAFB8A1qIQUgCA0BIARBADYCCAwECwJ+An8CQCAIQQhNIAEoAvgNIgVBN0txRQRAIAhBEE0gBUEvS3ENASABKQPwDSEZIAVBH0sEQCABIAVBIHMiBTYC+A0gASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBiAHQXtLDQYgAyAGSQ0eIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANCyAIQSFPDQYgGSAFQT9xrYgMAwsgASABKQPwDUI4iCIZNwPwDSABKAL8DSILQQhqIQcgC0F3Sw0NIAMgB0kNDiABIAtBB2o2AvwNIAEgASgCgA5BB2s2AoAOIAIgC2oiBzUAAEIIhiAHMQAEQiiGhCAHMQAFQjCGhCAHMQAGQjiGhCAZhCEZIAVBOHMMAQsgASABKQPwDUIwiCIZNwPwDSABKAL8DSILQQhqIQcgC0F3Sw0MIAMgB0kNDSABIAtBBmo2AvwNIAEgASgCgA5BBms2AoAOIAIgC2oiBzUAAEIQhiAHMQAEQjCGhCAHMQAFQjiGhCAZhCEZIAVBMHMLIQUgASAZNwPwDSAZIAVBP3GtiAshGSABIAUgCGoiBTYC+A0gBCAIQQJ0Qfic8wBqKAIAIBmncTYCCAwFCyAFIAggBEEIaiACIAMQ7R8NAgwDCyAHIAZBjJ7zABCxOwALIAhBIUH8nfMAEMMhAAtBACAORQ0CGiAFIA4gBEEMaiACIAMQ7R9FDQAgBCgCDAwCCyABIAs2AoAOIAEgBjYC/A0gASAMNgL4DSABIBk3A/ANQQAMAgsCfgJ/AkAgDkEITSAFQTdLcUUEQCAOQRBNIAVBL0txDQEgASkD8A0hGSAFQR9LBEAgASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBiAHQXtLDQcgAyAGSQ0YIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANIAVBIHMhBQsgDkEhTw0HIBkgBUE/ca2IDAMLIAEgASkD8A1COIgiGTcD8A0gASgC/A0iC0EIaiEHIAtBd0sNByADIAdJDQggASALQQdqNgL8DSABIAEoAoAOQQdrNgKADiACIAtqIgc1AABCCIYgBzEABEIohoQgBzEABUIwhoQgBzEABkI4hoQgGYQhGSAFQThzDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iC0EIaiEHIAtBd0sNBiADIAdJDQcgASALQQZqNgL8DSABIAEoAoAOQQZrNgKADiACIAtqIgc1AABCEIYgBzEABEIwhoQgBzEABUI4hoQgGYQhGSAFQTBzCyEFIAEgGTcD8A0gGSAFQT9xrYgLIRkgASAFIA5qNgL4DSAOQQJ0Qfic8wBqKAIAIBmncQsgEWo2AqQQIBAgBCgCCCAYajYCACABIAEoAqwPQQFrNgKsD0EBCyAEQRBqJAAMBAsgByAGQYye8wAQsTsACyAOQSFB/J3zABDDIQALIAsgB0GcnvMAELE7AAsgByADQZye8wAQsDsACyAJKAIEIQUgEnJFDQggBUUEQEEJIQggAUEJOgCKEUEAIQVBACEHQQAhBgwGC0EIIQggAUEIOgCKESABIAEoAogQIAVrNgKIEAwGCyABKAKAEEUNAiAJQQA2AtQwIAlBADYC2DAgACAJQdAAaiABLQCEEUEDdGoiCCgCACAIKAIEIA8gCUHUMGogCUHYMGogAiADEKooA0BBAiENAkACQCAARQRAIAEoAoAOQRxJDQELAkAgASgCqA8NACAAIAEgAiADEI0tIBJyQQFHDQEgACAJQdAAaiABLQCEEUEDdGoiCCgCACAIKAIEIA8gCUHUMGogCUHYMGogAiADEKooIAEoAoAQDQBBCCEIIAFBCDoAihEMCAsCQAJAIABFBEAgCCgCACEOIAgoAgQhBCAJQdgwaiENAkAgCUHUMGoiESgCACIQQQhNBEAgDyAPKAIIIBBqNgIIIA0oAgAhCwwBCwJAAkAgDygCCCILQTBPBEAgDygCDCIFQQhqIQwgBUF3Sw0BIAMgDEkNGSAPKQMAIRkgDyAFQQZqNgIMIA8gDygCEEEGazYCECAPIAIgBWoiBTUAAEIQhiAZQjCIhCAFMQAEQjCGhCAFMQAFQjiGhDcDACALQTBzIQsLIBBBCGsiDEEhTw0BIAQgDSgCACAPKQMAIAtBP3GtiKciBUH/AXFqIAxBAnRB+JzzAGooAgAgBUEIdnFqIgVLBEAgDyALIA4gBUECdGoiBS0AAmpBCGo2AgggBS8BACELDAMLIAUgBEGMn/MAEMMhAAsgBSAMQZye8wAQsTsACwwTC0EAIA4gBCAPIBEgDSACIAMQqiggCiABKALcDiIFTw0BIAEoAtgOIApqIAs6AAAMAgsgCUEANgLcMCAIKAIAIAgoAgQgDyAJQdwwaiACIAMQnxNFDQIgASgC3A4iBSAKSwRAIAEoAtgOIApqIAkoAtwwOgAADAILIAogBUHU1fMAEMMhAAsgCiAFQcTV8wAQwyEACyABKAKoDyIFDQFBcyENCyAGIQUMCQsgASAFQQFrNgKoDyAKQQFqIgQgASgC6A9HBEAgCSAGQQFrIgU2AgQgBSEHIAUhBiAEIQogBQ0BDAULCyABQQ06AIoRQQEhDSAKQQFqIQogB0EBayEFDAcLIAZBH3UgBnEhCyABKALoDyEHIAYhBSAKIQQCQAJAAkADQCAFQQBMDQIgASgC7A8gBCABKAKoEGtxIgggASgC3A4iDE8NAyAEIAxPDQEgASgC2A4iDCAEaiAIIAxqLQAAOgAAIAVBAWshBSAHIARBAWoiBEcNAAsgAUEQOgCKESAGIApqIAdrIQVBASENIAchCgwJCyAEIAxBpNfzABDDIQALIAkgC0EBayIFNgIEIAEoAogQQQBKBEBBByEIIAFBBzoAihEgBSEHIAUhBiAEIQoMBQsgAUEOOgCKEUEBIQ0gBCEKDAcLIAggDEGU1/MAEMMhAAsCQAJAIAEoAqgQIgRBAEgEQCABKAKwD0UEQAJ/AkAgACABQYgPaiABQfANakECIAIgAxDaByIHBEAgASABKALID0ECdCIENgL4DyABKAKEECAEaiIEIAEoAuQOIgZPDQEgASABKALgDiAEai0AADoAhRELIAcMAQsgBCAGQeSl8wAQwyEACyASckEBRw0DCyAJQdAQaiEEQQAhDiMAQRBrIhEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAEQCARQQA2AgggASgCgA4hDSABKAL8DSEIIAEoAvgNIQYgASkD8A0hGSAEIAEtAIURQQN0aiIEKAIAIAQoAgQgAUHwDWogEUEIaiACIAMQnxNFDQ0gASARKAIIIgs2AqgQDAELIAQgAS0AhRFBA3RqIgQoAgQhBiAEKAIAIQwgASkD8A0hGSABKAL4DSIOQTBPBEAgASAZQjCIIhk3A/ANIAEoAvwNIgdBCGohBCAHQXdLDRwgAyAESQ0dIAEgB0EGajYC/A0gASABKAKADkEGazYCgA4gASACIAdqIgQ1AABCEIYgBDEABEIwhoQgBDEABUI4hoQgGYQiGTcD8A0gDkEwcyEOCyAZIA5BP3GtiKciC0H/AXEiBCAGTw0BIAwgBEECdGoiCC8BACEHIAEgCC0AAiINQQhLBH8gDUEIa0H/AXEiCEEhTw0DIAQgB2ogCEECdEH4nPMAaigCACALQQh2cWoiBCAGTw0EIA5BCGohDiAMIARBAnRqIgQtAAIhDSAELwEABSAHC0H//wNxIgs2AqgQIAEgDiANQf8BcWo2AvgNQQAhBkIAIRlBACEIQQAhDQsgAUEANgKEECALQRBJBEAgASgC8A8hBAJAIAEoAqgQIgdFBEAgAUEBNgKEECABIARBAWsiBDYC8A8gASABIARBA3FBAnRqKALgDTYCqBAMAQtBgMr+UiAHQQF0Igx2QQNxIQYgAUGb/r/VeiAMdSAEakEDcUECdGooAuANIQQgB0EBcUUEQCABQf////8HIAQgBmsiBCAEQQBMGzYCqBAMAQsgASAEIAZqNgKoEAsgASABKAKwD0EBazYCsA9BASEODAwLIAsgASgCkBAiDmsiEEEASA0KAkACfwJAAn4CfwJAAkAgAEUEQCABKAKMECIIDQUgEEEBdkEBaiEGIBBBD00gASgC+A0iC0E3S3ENASAQQR9NIAtBL0txDQIgASkD8A0hGSALQR9LBEAgASAZQiCIIhk3A/ANIAEoAvwNIgdBBGohBCAHQXtLDQwgAyAESQ0NIAEgBDYC/A0gASABKAKADkEEazYCgA4gASACIAdqNQAAQiCGIBmEIhk3A/ANIAtBIHMhCwsgEEHAAE8NDSAZIAtBP3GtiAwEC0EAIQ4gEUEANgIMIAEoApQQIQcgAUHwDWogECABKAKMEHYiDEEBdkEBaiILIBFBDGogAiADEO0fRQ0GIAEoApAQIQ4gASgCjBAhCCARKAIMDAULIAEgASkD8A1COIgiGTcD8A0gASgC/A0iB0EIaiEEIAdBd0sNICADIARJDSEgASAHQQdqNgL8DSABIAEoAoAOQQdrNgKADiACIAdqIgQ1AABCCIYgBDEABEIohoQgBDEABUIwhoQgBDEABkI4hoQgGYQhGSALQThzDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iB0EIaiEEIAdBd0sNHyADIARJDSAgASAHQQZqNgL8DSABIAEoAoAOQQZrNgKADiACIAdqIgQ1AABCEIYgBDEABEIwhoQgBDEABUI4hoQgGYQhGSALQTBzCyELIAEgGTcD8A0gGSALQT9xrYgLIRkgASAGIAtqNgL4DSAOIBBBAXFBAnIgBnRqIAZBAnRB+JzzAGooAgAgGadxakEEayELDA0LIBAgCHYiDEEBdkEBaiELIAEoApQQIQcCfiABAn4CQCAMQQ9NIAEoAvgNIg1BN0txRQRAIAxBH00gDUEvS3ENASABKQPwDSEZIA1BH0sEQCABIA1BIHMiDTYC+A0gASAZQiCIIhk3A/ANIAEoAvwNIgRBBGohBiAEQXtLDQ8gAyAGSQ0fIAEgBjYC/A0gASABKAKADkEEazYCgA4gASACIARqNQAAQiCGIBmEIhk3A/ANCyAMQcAATw0PIBkgDUE/ca2IDAMLIAEgASkD8A1COIgiGTcD8A0gASgC/A0iBkEIaiEEIAZBd0sNCyADIARJDSAgDUE4cyENIAEgBkEHajYC/A0gASABKAKADkEHazYCgA4gAiAGaiIENQAAQgiGIAQxAARCKIaEIAQxAAVCMIaEIAQxAAZCOIaEIBmEDAELIAEgASkD8A1CMIgiGTcD8A0gASgC/A0iBkEIaiEEIAZBd0sNCyADIARJDR8gDUEwcyENIAEgBkEGajYC/A0gASABKAKADkEGazYCgA4gAiAGaiIENQAAQhCGIAQxAARCMIaEIAQxAAVCOIaEIBmECyIZNwPwDSAZIA1BP3GtiAshGSABIAsgDWo2AvgNIAtBAnRB+JzzAGooAgAgGadxCyEEIAxBAXFBAnIgC3RBBGutIAStfCAIQT9xrYanIA4gByAQcWpqIQsMCwsgASANNgKADiABIAg2AvwNIAEgBjYC+A0gASAZNwPwDSABQX82AqgQDAsLIAQgBkGsnvMAEMMhAAsgCEEhQfyd8wAQwyEACyAEIAZBvJ7zABDDIQALIAcgBEGMnvMAELE7AAsgBCADQYye8wAQsDsACyAGQSFB/J3zABDDIQALIAYgBEGcnvMAELE7AAsgBiAEQZye8wAQsTsACyAEIAZBjJ7zABCxOwALIAtBIUH8nfMAEMMhAAsgASALQQ9rNgKoECABIAEoArAPQQFrNgKwD0EBIQ4LIBFBEGokACAOIBJyQQFHDQIMAQsgASAERTYChBAgASABKALwD0EBayIFNgLwDyABIBYgBUEDcUECdGooAgA2AqgQCyABKALkDyIGIAEoAtwPIgVHBEAgASABKALcECAKaiAFIAogASgC4A9IGyIGNgLkDwsgCSABKAKkECIFNgIEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYgASgCqBAiBEgEQCAEQfz///8HSg0aIAVBBGtBFUkNAUF0IQ0MGQsgASABKALwDyIHQQFqNgLwDyABIAEoAogQIAVrNgKIECAWIAdBA3FBAnRqIAQ2AgAgASgC7A8gCiAEa3EiCEEQaiEHIAhBb0sNBCAHIAEoAtwOIgRLDQUgCkEQaiEGIApBb0sNBiAEIAZJDQcgASgC2A4iBCAIaiIMKQAAIRkgBCAKaiIEQQhqIAxBCGopAAA3AAAgBCAZNwAAAkAgCCAFIApqIgxJIAUgCGoiBCAKS3ENACAMIAEoAugPIgtPIAQgC09yDQACQCAFQRFIDQAgASgC3A4hBCABKALYDiELIAVBIE0EQCAIQSBqIgggB0kNCyAEIAhJDQwgCkEgaiIKIAZJDQ0gBCAKSQ0OIAcgC2oiCikAACEZIAYgC2oiBEEIaiAKQQhqKQAANwAAIAQgGTcAAAwBCyAFQRBrIQojAEEgayIIJAACQAJAAkACQAJAAkACQAJAAkACQCAGIAdNBEAgBCAHSQ0CIAogBCAHayIESw0DIAYgCmoiBCAKSQ0EIAQgB0sNBSAKRQ0BIAYgC2ogByALaiAK/AoAAAwBCyAEIAZJDQUgByAKaiINIApJDQYgBiANSQ0HIAogBCAGayIESw0IIApFDQAgBiALaiAHIAtqIAr8CgAACyAIQSBqJAAMCAsgCEEANgIYIAhBATYCDCAIQfCc8wA2AgggCEIENwIQIAhBCGpBpNTzABDvLAALIAogBEG01PMAELA7AAsgBiAEQcTU8wAQsTsACyAEIAdBxNTzABCwOwALIAhBADYCGCAIQQE2AgwgCEHwnPMANgIIIAhCBDcCECAIQQhqQdTU8wAQ7ywACyAHIA1B5NTzABCxOwALIA0gBkHk1PMAELA7AAsgCiAEQfTU8wAQsDsACwsgASgCiBAhBAwCC0EKIQggAUEKOgCKEQwWCyAFQcjW8wBqLQAAIgxBIU8NHCAFQQJ0QeTV8wBqKAIAIQcgASABKALwDyABKAKEEGo2AvAPIAQgBkF/c2oiBCAMdSIGQfgASgRAQXUhDQwYCyAMQQJ0Qfic8wBqKAIAIARxIAVsIAdqIgQgBWoiByAESQ0LIAdBoL8HSw0MIARBpOnzAGohBAJAIAZFBEAgBSAKaiIMIAVJDQ8gDCABKALcDiIHSw0QIAUEQCABKALYDiAKaiAEIAX8CgAACyAFIQQMAQsgASgC3A4iByAKSQ0QIAEoAtgOIApqIAcgCmsgBCAFIAUgBhCiCSIEIApqIQwLIAEgASgCiBAgBGsiBDYCiBAgDCABKALoD04NAQsgBEEATA0BQQchCCABQQc6AIoRIAUhByAFIQYgDCEKDBMLIAFBDzoAihEMDgsgAUEOOgCKEQwNCyAIIAdBhNTzABCxOwALIAcgBEGE1PMAELA7AAsgCiAGQZTU8wAQsTsACyAGIARBlNTzABCwOwALIAcgCEGE1PMAELE7AAsgCCAEQYTU8wAQsDsACyAGIApBlNTzABCxOwALIAogBEGU1PMAELA7AAsgBCAHQeTW8wAQsTsACyAHQaC/B0Hk1vMAELA7AAsgCiAMQfTW8wAQsTsACyAMIAdB9NbzABCwOwALIAogB0GE1/MAEK87AAtBASENIAwhCgwGC0ECIQ0MBQsgASgC7A8iBiAKQQFrcSIEIAEoAtwOIgVPBEAgBCAFQYTV8wAQwyEACwJAAkAgBSAGIApBAmtxIgZLBEAgBCABKALYDiIMai0AACEFIAYgDGotAAAhCCABLQCSE0EBRyAKQQJOcg0BQQAhCEEAIQUMAgsgBiAFQZTV8wAQwyEACyAKQQJIDQAgAUEAOgCSEwsCQANAAkAgAA0AIAEoAoAOQRtLDQAgAUEIOgCKEQwGCwJAAkACQAJAAkACQCABKAKoD0UEQCAAIAEgAiADEI0tIBJyQQFHDQwgASgCgBANAQsgASgC9A8gASgC6BAiBCAIQf8BcWpBgAJqLQAAIAQgBUH/AXFqLQAAcmoiBCABKAL8DiIGTw0BIAlB0ABqIAEoAvgOIARqLQAAQQN0aiIEKAIEIQggBCgCACELIABFBEAgASkD8A0hGSABKAL4DSIEQTBPBEAgASAEQTBzIgQ2AvgNIAEgGUIwiCIZNwPwDSABKAL8DSIGQQhqIQwgBkF3Sw0EIAMgDEkNFiABIAZBBmo2AvwNIAEgASgCgA5BBms2AoAOIAEgAiAGaiIGNQAAQhCGIAYxAARCMIaEIAYxAAVCOIaEIBmEIhk3A/ANCyAZIARBP3GtiKciEEH/AXEiDiAITw0EIAsgDkECdGoiDC8BACEGIAwtAAIiDUEISwRAIAEgBEEIaiIENgL4DSANQQhrQf8BcSIMQSFPDRMgBiAOaiAMQQJ0Qfic8wBqKAIAIBBBCHZxaiIGIAhPDQYgCyAGQQJ0aiIGLQACIQ0gBi8BACEGCyABIAQgDUH/AXFqNgL4DSAGQf//A3EhBgwGCyAJQQA2AtwwIAsgCCAPIAlB3DBqIAIgAxCfE0UNCyAJKALcMCEGDAULQQghCCABQQg6AIoRIAkgBzYCBCAHIgUhBgwICyAEIAZBpNXzABDDIQALIAYgDEGcnvMAELE7AAsgDiAIQaye8wAQwyEACyAGIAhBvJ7zABDDIQALAkAgASgC3A4iBCAKSwRAIAEoAtgOIApqIAY6AAAgASgCqA8iBA0BQXMhDSAHIQUMCAsgCiAEQbTV8wAQwyEACyABIARBAWs2AqgPIApBAWoiBCABKALoD0YNASAFIQggBiEFIAQhCiAHQQFrIgcNAAsgCUEANgIEDAELIAFBDToAihFBASENIApBAWohCiAHQQFrIQUMBAsgASgCiBBBAEoEQEEJIQggAUEJOgCKEUEAIQVBACEHQQAhBiAEIQoMAQsLCyABQQ46AIoRQQEhDUEAIQUgBCEKDAELQQIhDSAHIQULIAEgBTYC0A8gASAKNgLYDyAJQdAgaiIAEIUgIAlB4BBqIgEgCUEYaiIFKQMANwMAIAlB2BBqIgIgCUEQaiIDKQMANwMAIAMgCUHYIGoiAykCADcDACAFIAlB4CBqIgUpAgA3AwAgCSAJKQMINwPQECAJIAkpAtAgNwMIIAMgFUEIaiIKKQIANwMAIAUgFUEQaiIEKQIANwMAIAkgFSkCADcD0CAgFSAJKQPQEDcCACAKIAIpAwA3AgAgBCABKQMANwIAIAAQmSogABCFICABIAlBMGoiCikDADcDACACIAlBKGoiBCkDADcDACAEIAMpAgA3AwAgCiAFKQIANwMAIAkgCSkDIDcD0BAgCSAJKQLQIDcDICADIBRBCGoiCikCADcDACAFIBRBEGoiBCkCADcDACAJIBQpAgA3A9AgIBQgCSkD0BA3AgAgCiACKQMANwIAIAQgASkDADcCACAAEJkqIAAQhSAgASAJQcgAaiIKKQMANwMAIAIgCUFAayIEKQMANwMAIAQgAykCADcDACAKIAUpAgA3AwAgCSAJKQM4NwPQECAJIAkpAtAgNwM4IAMgE0EIaiIDKQIANwMAIAUgE0EQaiIFKQIANwMAIAkgEykCADcD0CAgEyAJKQPQEDcCACADIAIpAwA3AgAgBSABKQMANwIAIAAQmSoMAQtBcCENCyAJQThqEJkqIAlBIGoQmSogCUEIahCZKgsgCUHgMGokACANDwsgBiADQYye8wAQsDsACyAMQSFB/J3zABDDIQALIAcgBEGcnvMAELE7AAsgBCADQZye8wAQsDsACyAMIANBnJ7zABCwOwALvx8BBn8gACgCCCIFBEAgACgCBCEGA0ACQCAGIARBuAVsaiIAKQMAQgJSBEAgACgCmAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAVqENkhCyAAKAKcBSIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGcBWoQriALIABBwARqELwqIABByARqENcpIABBsAFqIQECQAJAAkACQEECIAAoApACIgNBgICAgHhzIANBAE4bDgIBAgALIABBkAJqEN47IABBnAJqEN47IABBqAJqEN0pIABBrAJqEN0pDAILIABBlAJqEN47DAELIABBlAJqEN47IABBoAJqEN0pCyABKAIAQYCAgIB4RwRAIABByAFqQQgQ7iggARDeOyAAQbwBakEEQQgQ4B4gAEGAAmoQ4zwLAkAgACgCzAJFDQAgACgC0AIiAUUNACAAQdwCaiAAKALUAiAAKALYAiABKAIQEQEACwJAIAAoAuACRQ0AIAAoAuQCIgFFDQAgAEHwAmogACgC6AIgACgC7AIgASgCEBEBAAsgACgCwAJBgICAgHhHBEAgAEHAAmpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAENIhIABBoAVqEMMcIABB9ARqQQRBCBDgHiAAQYAFahCdPCAAQYwFahCdPCAAQYADaiIBEIcZIAFBCEGIARDgHiAAQZADahDtJyAAQYgEahDHKCAAQdAEahDxJgwBCwJAAkACQAJAAkACQAJAAkAgACgCCEEBaw4HAgMEBQYHAAELIAAoApAFIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZAFahDZIQsgACgClAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBlAVqEK4gCyAAQbgEahC8KiAAQcAEahDXKSAAKAJ4IQEgACgCfCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJoQYCAgIB4RwRAIABBIGpBCBDuKCAAQdAAaiIBENwlIAFBBEEQEOAeIABB6ABqEOM8CyAAKAK0ASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEG0AWoQ2SELAkAgACgCgAFFDQAgACgChAEiAUUNACAAQZABaiAAKAKIASAAKAKMASABKAIQEQEACwJAIAAoApQBRQ0AIAAoApgBIgFFDQAgAEGkAWogACgCnAEgACgCoAEgASgCEBEBAAsgACgCqAFBgICAgHhHBEAgAEGoAWpBBEEgEOAeCyAAQeADahCFMCAAQewDahCFMAJAIAAoArACRQ0AIAAoArQCIgFFDQAgAEHAAmogACgCuAIgACgCvAIgASgCEBEBAAsCQCAAKALEAkUNACAAKALIAiIBRQ0AIABB1AJqIAAoAswCIAAoAtACIAEoAhARAQALIABB2AJqEIUwIABB5AJqEIUwIABBmAVqEMMcIABB7ARqQQRBCBDgHiAAQfgEahCdPCAAQYQFahCdPCAAQfgCaiIBEIcZIAFBCEGIARDgHiAAQYgDahDtJyAAQYAEahDHKCAAKALIBEUNByAAKALMBCIBBEAgAEHYBGogACgC0AQgACgC1AQgASgCEBEBAAsgACgC3AQiAUUNByAAQegEaiAAKALgBCAAKALkBCABKAIQEQEADAcLIAAoAqQEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaQEahDZIQsgACgCqAQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBqARqEK4gCyAAQfADahC8KiAAQfgDahDXKSAAKAJ4IQEgACgCfCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJoQYCAgIB4RwRAIABBIGpBCBDuKCAAQdAAahDeOyAAQegAahDjPAsgACgCjAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBjAFqENkhCyAAKAKAAUGAgICAeEcEQCAAQYABakEEQSAQ4B4LIABBmANqEIUwIABBpANqEIUwIABBiAJqEIUwIABBlAJqEIUwIABBrARqEMMcIABBgARqQQRBCBDgHiAAQYwEahCdPCAAQZgEahCdPCAAQbACaiIBEIcZIAFBCEGIARDgHiAAQcACahDtJyAAQbgDahDHKAwGCyAAKALIBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHIBGoQ2SELIAAoAswEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcwEahCuIAsgAEGIBGoQvCogAEGQBGoQ1ykgACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDpOyAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LIABBsANqEIUwIABBvANqEIUwIABBqAJqEIUwIABBtAJqEIUwIABB0ARqEMMcIABBpARqQQRBCBDgHiAAQbAEahCdPCAAQbwEahCdPCAAQcgCaiIBEIcZIAFBCEGIARDgHiAAQdgCahDtJyAAQdADahDHKAwFCyAAKAL0BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH0BGoQ2SELIAAoAvgEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgEahCuIAsgAEHABGoQvCogAEHIBGoQ1ykgACgCmAEhASAAKAKcASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAKIAUGAgICAeEcEQCAAQUBrQQgQ7iggAEHwAGoQ4zwgAEGIAWoQ4zwLIAAoAqwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQawBahDZIQsgACgCoAFBgICAgHhHBEAgAEGgAWpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAQcgCahCFMCAAQdQCahCFMCAAQfwEahDDHCAAQdAEakEEQQgQ4B4gAEHcBGoQnTwgAEHoBGoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxygMBAsgACgC+AQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB+ARqENkhCyAAKAL8BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH8BGoQriALIABBqARqELwqIABBsARqENcpIAAoApgBIQEgACgCnAEiAygCACICBEAgASACEQMACyADKAIEIgIEQCABIAIgAygCCBD4OgsgACgCiAFBgICAgHhHBEAgAEFAa0EIEO4oIABB8ABqQQRBDBDgHiAAQYgBahDjPAsgACgCrAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBrAFqENkhCyAAKAKgAUGAgICAeEcEQCAAQaABakEEQSAQ4B4LIABB0ANqEIUwIABB3ANqEIUwIABByAJqEIUwIABB1AJqEIUwIABBgAVqEMMcIABB1ARqQQRBCBDgHiAAQeAEahCdPCAAQewEahCdPCAAQegCaiIBEIcZIAFBCEGIARDgHiAAQfgCahDtJyAAQfADahDHKAwDCyAAKALIBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHIBGoQ2SELIAAoAswEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcwEahCuIAsgAEGIBGoQvCogAEGQBGoQ1ykgACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDpOyAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LIABBsANqEIUwIABBvANqEIUwIABBqAJqEIUwIABBtAJqEIUwIABB0ARqEMMcIABBpARqQQRBCBDgHiAAQbAEahCdPCAAQbwEahCdPCAAQcgCaiIBEIcZIAFBCEGIARDgHiAAQdgCahDtJyAAQdADahDHKAwCCyAAKAL0BCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEH0BGoQ2SELIAAoAvgEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgEahCuIAsgAEHABGoQvCogAEHIBGoQ1ykgACgCmAEhASAAKAKcASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAKIAUGAgICAeEcEQCAAQUBrQQgQ7iggAEHwAGoQ4zwgAEGIAWoQ4zwLIAAoAqwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQawBahDZIQsgACgCoAFBgICAgHhHBEAgAEGgAWpBBEEgEOAeCyAAQegDahCFMCAAQfQDahCFMCAAQcgCahCFMCAAQdQCahCFMCAAQfwEahDDHCAAQdAEakEEQQgQ4B4gAEHcBGoQnTwgAEHoBGoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxygMAQsgACgCkAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAVqENkhCyAAKAKUBSIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGUBWoQriALIABBuARqELwqIABBwARqENcpIAAoAnghASAAKAJ8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAmhBgICAgHhHBEAgAEEgakEIEO4oIABB0ABqIgEQ3CUgAUEEQRAQ4B4gAEHoAGoQ4zwLIAAoArQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbQBahDZIQsCQCAAKAKAAUUNACAAKAKEASIBRQ0AIABBkAFqIAAoAogBIAAoAowBIAEoAhARAQALAkAgACgClAFFDQAgACgCmAEiAUUNACAAQaQBaiAAKAKcASAAKAKgASABKAIQEQEACyAAKAKoAUGAgICAeEcEQCAAQagBakEEQSAQ4B4LIABB4ANqEIUwIABB7ANqEIUwIABBwAFqENIhIABBmAVqEMMcIABB7ARqQQRBCBDgHiAAQfgEahCdPCAAQYQFahCdPCAAQfgCaiIBEIcZIAFBCEGIARDgHiAAQYgDahDtJyAAQYAEahDHKCAAQcgEahDxJgsgACgCsAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBsAVqEIgcCyAEQQFqIgQgBUcNAAsLC+wjAgt/AX4jAEEQayIJJAACQAJAAkACQAJAAkAgAEH1AU8EQCAAQcz/e0sEQEEAIQAMBwsgAEELaiIBQXhxIQRBxPOKASgCACIIRQ0EQR8hB0EAIARrIQMgAEH0//8HTQRAIARBBiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmohBwsgB0ECdEGo8IoBaigCACICRQRAQQAhAEEAIQEMAgtBACEAIARBGSAHQQF2a0EAIAdBH0cbdCEFQQAhAQNAAkAgAigCBEF4cSIGIARJDQAgBiAEayIGIANPDQAgAiEBIAYiAw0AQQAhAyABIQAMBAsgAigCFCIGIAAgBiACIAVBHXZBBHFqKAIQIgJHGyAAIAYbIQAgBUEBdCEFIAINAAsMAQsCQAJAAkACQEHA84oBKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIEQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgZBA3QiAUG48YoBaiIFIAFBwPGKAWooAgAiACgCCCIDRg0BIAMgBTYCDCAFIAM2AgggACABEPMuDAkLIARByPOKASgCAE0NByABDQFBxPOKASgCACIARQ0HIABoQQJ0QajwigFqKAIAIgEoAgRBeHEgBGshAyABIQIDQAJAIAEoAhAiAA0AIAEoAhQiAA0AIAIgBBCYPiEIIAIoAhghBwJAAkAgAiACKAIMIgBGBEAgAkEUQRAgAigCFCIAG2ooAgAiAQ0BQQAhAAwCCyACKAIIIgEgADYCDCAAIAE2AggMAQsgAkEUaiACQRBqIAAbIQUDQCAFIQYgASIAQRRqIABBEGogACgCFCIBGyEFIABBFEEQIAEbaigCACIBDQALIAZBADYCAAsgB0UNBQJAIAIoAhxBAnRBqPCKAWoiASgCACACRwRAIAIgBygCEEcEQCAHIAA2AhQgAA0CDAgLIAcgADYCECAADQEMBwsgASAANgIAIABFDQULIAAgBzYCGCACKAIQIgEEQCAAIAE2AhAgASAANgIYCyACKAIUIgFFDQUgACABNgIUIAEgADYCGAwFCyAAKAIEQXhxIARrIgEgAyABIANJIgEbIQMgACACIAEbIQIgACEBDAALAAtBwPOKASACQX4gBndxNgIAIAAgARDzLgwHCwJAQQIgAHQiBUEAIAVrciABIAB0cWgiBkEDdCIBQbjxigFqIgUgAUHA8YoBaigCACIAKAIIIgNHBEAgAyAFNgIMIAUgAzYCCAwBC0HA84oBIAJBfiAGd3E2AgALIAAgBEEDcjYCBCAAIAQQmD4iBiABIARrIgQQ0DRByPOKASgCACICBEBB0POKASgCACEBAn9BwPOKASgCACIFQQEgAkEDdnQiA3FFBEBBwPOKASADIAVyNgIAIAJBeHFBuPGKAWoiAwwBCyACQXhxIgJBuPGKAWohAyACQcDxigFqKAIACyEFIAMgATYCCCAFIAE2AgwgASADNgIMIAEgBTYCCAtB0POKASAGNgIAQcjzigEgBDYCAAwGC0HE84oBQcTzigEoAgBBfiACKAIcd3E2AgALAkACQCADQRBPBEAgAiAEQQNyNgIEIAggAxDQNEHI84oBKAIAIgFFDQFB0POKASgCACEAAn9BwPOKASgCACIFQQEgAUEDdnQiBnFFBEBBwPOKASAFIAZyNgIAIAFBeHFBuPGKAWoiAQwBCyABQXhxIgVBuPGKAWohASAFQcDxigFqKAIACyEFIAEgADYCCCAFIAA2AgwgACABNgIMIAAgBTYCCAwBCyACIAMgBGoQ8y4MAQtB0POKASAINgIAQcjzigEgAzYCAAsgAhCZPiIARQ0DDAULIAAgAXJFBEBBACEBQQIgB3QiAEEAIABrciAIcSIARQ0DIABoQQJ0QajwigFqKAIAIQALIABFDQELA0AgACABIAAoAgRBeHEiBSAEayIGIANJIgcbIQggACgCECICRQRAIAAoAhQhAgsgASAIIAQgBUsiABshASADIAYgAyAHGyAAGyEDIAIiAA0ACwsgAUUNACAEQcjzigEoAgAiAE0gAyAAIARrT3ENACABIAQQmD4hByABKAIYIQgCQAJAIAEgASgCDCIARgRAIAFBFEEQIAEoAhQiABtqKAIAIgINAUEAIQAMAgsgASgCCCICIAA2AgwgACACNgIIDAELIAFBFGogAUEQaiAAGyEFA0AgBSEGIAIiAEEUaiAAQRBqIAAoAhQiAhshBSAAQRRBECACG2ooAgAiAg0ACyAGQQA2AgALAkAgCEUNAAJAAkAgASgCHEECdEGo8IoBaiICKAIAIAFHBEAgASAIKAIQRwRAIAggADYCFCAADQIMBAsgCCAANgIQIAANAQwDCyACIAA2AgAgAEUNAQsgACAINgIYIAEoAhAiAgRAIAAgAjYCECACIAA2AhgLIAEoAhQiAkUNASAAIAI2AhQgAiAANgIYDAELQcTzigFBxPOKASgCAEF+IAEoAhx3cTYCAAsCQCADQRBPBEAgASAEQQNyNgIEIAcgAxDQNCADQYACTwRAIAcgAxDsEAwCCwJ/QcDzigEoAgAiAEEBIANBA3Z0IgJxRQRAQcDzigEgACACcjYCACADQfgBcUG48YoBaiIADAELIANB+AFxIgJBuPGKAWohACACQcDxigFqKAIACyEDIAAgBzYCCCADIAc2AgwgByAANgIMIAcgAzYCCAwBCyABIAMgBGoQ8y4LIAEQmT4iAA0CCwJAAkAgBEHI84oBKAIAIgFLBEAgBEHM84oBKAIAIgBPBEAgCUEEaiAEQa+ABGpBgIB8cRDLIiAJKAIEIgFFBEBBACEADAYLIAkoAgwhA0HY84oBIAkoAggiBUHY84oBKAIAaiIANgIAQdzzigEgAEHc84oBKAIAIgIgACACSxs2AgACQEHU84oBKAIABEBBqPGKASEAA0AgABCuOyABRg0CIAAoAggiAA0ACwwEC0Hk84oBKAIAIgBBACAAIAFNG0UEQEHk84oBIAE2AgALQejzigFB/x82AgBBtPGKASADNgIAQazxigEgBTYCAEGo8YoBIAE2AgBBxPGKAUG48YoBNgIAQczxigFBwPGKATYCAEHA8YoBQbjxigE2AgBB1PGKAUHI8YoBNgIAQcjxigFBwPGKATYCAEHc8YoBQdDxigE2AgBB0PGKAUHI8YoBNgIAQeTxigFB2PGKATYCAEHY8YoBQdDxigE2AgBB7PGKAUHg8YoBNgIAQeDxigFB2PGKATYCAEH08YoBQejxigE2AgBB6PGKAUHg8YoBNgIAQfzxigFB8PGKATYCAEHw8YoBQejxigE2AgBBhPKKAUH48YoBNgIAQfjxigFB8PGKATYCAEGA8ooBQfjxigE2AgBBjPKKAUGA8ooBNgIAQYjyigFBgPKKATYCAEGU8ooBQYjyigE2AgBBkPKKAUGI8ooBNgIAQZzyigFBkPKKATYCAEGY8ooBQZDyigE2AgBBpPKKAUGY8ooBNgIAQaDyigFBmPKKATYCAEGs8ooBQaDyigE2AgBBqPKKAUGg8ooBNgIAQbTyigFBqPKKATYCAEGw8ooBQajyigE2AgBBvPKKAUGw8ooBNgIAQbjyigFBsPKKATYCAEHE8ooBQbjyigE2AgBBzPKKAUHA8ooBNgIAQcDyigFBuPKKATYCAEHU8ooBQcjyigE2AgBByPKKAUHA8ooBNgIAQdzyigFB0PKKATYCAEHQ8ooBQcjyigE2AgBB5PKKAUHY8ooBNgIAQdjyigFB0PKKATYCAEHs8ooBQeDyigE2AgBB4PKKAUHY8ooBNgIAQfTyigFB6PKKATYCAEHo8ooBQeDyigE2AgBB/PKKAUHw8ooBNgIAQfDyigFB6PKKATYCAEGE84oBQfjyigE2AgBB+PKKAUHw8ooBNgIAQYzzigFBgPOKATYCAEGA84oBQfjyigE2AgBBlPOKAUGI84oBNgIAQYjzigFBgPOKATYCAEGc84oBQZDzigE2AgBBkPOKAUGI84oBNgIAQaTzigFBmPOKATYCAEGY84oBQZDzigE2AgBBrPOKAUGg84oBNgIAQaDzigFBmPOKATYCAEG084oBQajzigE2AgBBqPOKAUGg84oBNgIAQbzzigFBsPOKATYCAEGw84oBQajzigE2AgBBuPOKAUGw84oBNgIAQdTzigEgASABEJk+IgBBB2pBeHEgAGsiARCYPiIANgIAQczzigEgBSABa0EoayIBNgIAIAAgAUEBcjYCBCAAIAEQmD5BKDYCBEHg84oBQYCAgAE2AgAMBAsgACgCDCICQQFxIAJBAXYgA0dyDQIgAEHU84oBKAIAEM8tRQ0CIAAgACgCBCAFajYCBEHM84oBKAIAIQFB1POKASgCACIAIAAQmT4iAEEHakF4cSAAayICEJg+IQBBzPOKASABIAVqIAJrIgE2AgBB1POKASAANgIAIAAgAUEBcjYCBCAAIAEQmD5BKDYCBEHg84oBQYCAgAE2AgAMAwtBzPOKASAAIARrIgE2AgBB1POKAUHU84oBKAIAIgAgBBCYPiICNgIAIAIgAUEBcjYCBCAAIARBA3I2AgQMAwtB0POKASgCACEAIAEgBGsiAkEPTQRAQdDzigFBADYCAEHI84oBQQA2AgAgACABEPMuDAMLIAAgBBCYPiEBQcjzigEgAjYCAEHQ84oBIAE2AgAgASACENA0IAAgBEEDcjYCBAwCC0Hk84oBQeTzigEoAgAiACABIAAgAUkbNgIAIAEgBWohBkGo8YoBIQACQAJAA0AgBiAAKAIAIgJHBEAgACgCCCIADQEMAgsLIAAoAgwiBkEBcQ0AIAZBAXYgA0YNAQtB1POKASgCACECQajxigEhAAJAA0AgAiAAKAIATwRAIAAQrjsgAksNAgsgACgCCCIADQALQQAhAAsgAiAAEK47IgtBL2siABCZPiIGQQdqQXhxIAZrIABqIgAgACACQRBqSRsiBhCZPiEHIAZBGBCYPiEAQdTzigEgASABEJk+IghBB2pBeHEgCGsiChCYPiIINgIAQczzigEgBSAKa0EoayIKNgIAIAggCkEBcjYCBCAIIAoQmD5BKDYCBEHg84oBQYCAgAE2AgAgBkEbNgIEQajxigEpAgAhDCAHQQhqQbDxigEpAgA3AgAgByAMNwIAQbTxigEgAzYCAEGs8YoBIAU2AgBBqPGKASABNgIAQbDxigEgBzYCAANAIABBBBCYPiAAQQc2AgQiAEEEaiALSQ0ACyACIAZGDQEgAiAGIAJrIgAgAiAAEJg+EIkuIABBgAJPBEAgAiAAEOwQDAILAn9BwPOKASgCACIBQQEgAEEDdnQiBXFFBEBBwPOKASABIAVyNgIAIABB+AFxQbjxigFqIgAMAQsgAEH4AXEiAUG48YoBaiEAIAFBwPGKAWooAgALIQMgACACNgIIIAMgAjYCDCACIAA2AgwgAiADNgIIDAELIAAgATYCACAAIAAoAgQgBWo2AgQgARCZPiEAIAIQmT4hBSABIABBB2pBeHEgAGtqIgAgBBCYPiEBIAAgBEEDcjYCBCACIAVBB2pBeHEgBWtqIgMgACAEamshBAJAQdTzigEoAgAgA0cEQCADQdDzigEoAgBGDQEgAygCBCICQQNxQQFGBEAgAyACQXhxIgIQhQ8gAiAEaiEEIAMgAhCYPiEDCyABIAQgAxCJLiAEQYACTwRAIAEgBBDsEAwECwJ/QcDzigEoAgAiAkEBIARBA3Z0IgVxRQRAQcDzigEgAiAFcjYCACAEQfgBcUG48YoBaiIEDAELIARB+AFxIgJBuPGKAWohBCACQcDxigFqKAIACyEDIAQgATYCCCADIAE2AgwgASAENgIMIAEgAzYCCAwDC0HU84oBIAE2AgBBzPOKAUHM84oBKAIAIARqIgI2AgAgASACQQFyNgIEDAILQdDzigEgATYCAEHI84oBQcjzigEoAgAgBGoiAjYCACABIAIQ0DQMAQtBACEAQczzigEoAgAiASAETQ0BQczzigEgASAEayIBNgIAQdTzigFB1POKASgCACIAIAQQmD4iAjYCACACIAFBAXI2AgQgACAEQQNyNgIECyAAEJk+IQALIAlBEGokACAAC5gcAg5/Bn4jAEEgayINJAAgACABaiESAkACQCABQQ9NDQAgAEEBaiIOIARNBEAgAyAOaiAEIA5rQcAAIAdrIhYgCBD6HSEPIABBAmoiByACQRBrIgIgASAIayIBIAEgAksbIABqIhRLDQEgFkE/ca0hHCAIQThsQThxrSEdIAwoAgAhESAJKAIAIRcgCigCACEYIAkoAgQhFUF/IRADQEEhIQIDQAJAAkACQAJAAkACQCAHIgEgBE0EQCABIANqIAQgAWsgFiAIEPodIRMgBCAOSQ0BIAQgDiAQayIHSQ0CIAcgDklBACADIA5qIhkgBCAOayIaIAMgB2ogBCAHayAIEKgRG0UEQCAGIA9LBEAgBSAPQQJ0aiIPKAIAIQcgDyAONgIAIAQgB0kNBSAZIBogAyAHaiAEIAdrIAgQqBENBwwICyAPIAZB+ILSABDDIQALIAYgD0sNBCAPIAZBmIPSABDDIQALIAEgBEHIgtIAEK87AAsgDiAEQdiC0gAQrzsACyAHIARB6ILSABCvOwALIAcgBEGIg9IAEK87AAsgBSAPQQJ0aiAONgIACyAOIAdrIg9B8P8PSw0AAkACQAJAAkAgByAIaiICIARNBEAgBCAIIA5qIgFJDQEgAiADaiAEIAJrIAEgA2ogBCABayASIAFrELIgIQIgDiAAayIBIAsQpA4gDCARQQFqNgIAIAEgFUsNAiAAIA5LDQMgFyABIAAgA2ogAUHog9IAENUsIAkgFSABayIVNgIEIAkgASAXaiIXNgIAIAogASAYaiIYNgIAIA8gEEcEQCAPIAsQ6x4MBQsgCygCBCIABEAgCygCACIBQcAANgIAIAsgAEEBazYCBCALIAFBBGo2AgAgECEPDAULQQBBAEH4g9IAEMMhAAsgAiAEQaiD0gAQrzsACyABIARBuIPSABCvOwALIAEgFUHIg9IAELA7AAsgACAOQdiD0gAQsTsACyAMIBFBAmoiEDYCAAJ/AkACQAJAAkACQCACIAhqIgJBDE8EQCACQcgATwRAIAJBiAFPBEAgCygCBCEAIAJByBBPBEAgAEUNBCALKAIAIgEgAkEIdEHBjyFrNgIAIABBAUcEQAwJC0EAQQBByIDSABDDIQALIABFDQQgCygCACIBIAJByABrIgdnQSBqQT9zIhNBfyATdCAHakEIdHJBNGo2AgAgAEEBRwRADAgLQQBBAEHogNIAEMMhAAsgCygCBCIARQ0EIAsoAgAiASACQQhrIgdBBXZBNmogB0EIdEGAPnFyNgIAIABBAUcEQCABQcAANgIEIAFBCGohASAAQQJrIQBBAgwIC0EAQQBBiIHSABDDIQALIAsoAgQiAQRAIAsoAgAiEyACQQhrIgAgACAAZ0EgakE/c0EBayIAdiIRIAB0a0EIdCARIABBAXRqQRxqcjYCACABQQFrIQAgE0EEaiEBQQEMBwtBAEEAQZiB0gAQwyEACyALKAIEIgBFDQMgCygCACIBIAJBFGo2AgAgAEEBayEAIAFBBGohAUEBDAULQQBBAEG4gNIAEMMhAAtBAEEAQdiA0gAQwyEAC0EAQQBB+IDSABDDIQALQQBBAEGogdIAEMMhAAsgAUHAADYCBCABQQhqIQEgAEECayEAQQILIQcgCyAANgIEIAsgATYCACAMIAcgEGoiETYCACACIA5qIgAgFE8NBAJAAkACQAJAAkACQAJAAkACQAJAIAhBBEYEQCAEIABBA2siAUkNASANQgA3AwAgBCABa0EHTQ0QIA1BCCABIANqQQhByI7SABDVLCAGIA01AgAiG0KAgICA0Pfpmh5+IByIpyICTQ0CIA0xAAYhHiANMQAFIA0xAAQhICAFIAJBAnRqIgIgATYCACAGIBsgIEIghoQiG0IYhkKAgICAcINCvc/W8QF+IByIpyIBTQ0DQiiGIB5CMIaEIBuEQgiGQoCAgIBwgyEbIAUgAUECdGogAEECazYCACACIABBAWs2AgAMCgsgAEEETQ0DIAQgAEEFayIBSQ0EIA1CADcDACAEIAFrQQdNDQ8gDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NBSAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciAU0NBiAFIAFBAnRqIABBBGs2AgAgBiAbQhCIIB2GQr3P1vEBfiAciKciAU0NByAFIAFBAnRqIABBA2s2AgAgDUIANwMAIAQgAEECayIBa0EHTQ0PIA1BCCABIANqQQhByI7SABDVLCAGIA0pAwAiGyAdhkK9z9bxAX4gHIinIgJNDQggBSACQQJ0aiABNgIAIBtCCIggHYZCvc/W8QF+IByIpyIBIAZJBEAgG0IQiCAdhiEbIAUgAUECdGogAEEBazYCAAwKCyABIAZBuIXSABDDIQALIAEgBEGIhNIAEK87AAsgAiAGQZiE0gAQwyEACyABIAZBqITSABDDIQALQbiE0gBBH0HYhNIAEJ8pAAsgASAEQeiE0gAQrzsACyACIAZB+ITSABDDIQALIAEgBkGIhdIAEMMhAAsgASAGQZiF0gAQwyEACyACIAZBqIXSABDDIQALIBtCvc/W8QF+IByIpyIBIAZPBEAgASAGQciF0gAQwyEACyAFIAFBAnRqIgEoAgAhDiABIAA2AgACQAJAIAAgDmsiB0Hw/w9LDQACQAJAAkACQAJAAkACQAJAA0ACQCAHIRAgACAESw0AIAQgDkkNAiAAIANqIAQgAGsgAyAOaiAEIA5rIAgQqBFFDQogBCAIIA5qIgJJDQMgBCAAIAhqIgFJDQQCfyACIANqIAQgAmsgASADaiAEIAFrIBIgAWsQsiAgCGoiAkEKTwRAIAJBhgFPBEAgCygCBCEHIAJBxhBPBEAgAkEIdEHBiyFrIAcNAxpBAEEAQbiB0gAQwyEACyAHBEAgAkHGAGsiAWdBIGpBP3MiD0F/IA90IAFqQQh0ckE0agwDC0EAQQBByIHSABDDIQALIAsoAgQiBwRAIAJBBmsiASABIAFnQSBqQT9zQQFrIgF2Ig8gAXRrQQh0IA8gAUEBdGpBLGpyDAILQQBBAEHYgdIAEMMhAAsgCygCBCIHRQ0GIAJBJmoLIQEgCygCACIPIAE2AgAgCyAHQQFrNgIEIAsgD0EEajYCACAQIAsQ6x4gDCARQQJqIhE2AgAgACACaiIAIBRPDRAgAEEETQ0GAkACQAJAAkACQAJAAn4CQAJAAkAgCEEERwRAIAQgAEEFayIBSQ0SIA1CADcDACAEIAFrQQdNDRwgDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NASAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciAU0NAiAFIAFBAnRqIABBBGs2AgAgBiAbQhCIIB2GQr3P1vEBfiAciKciAUsNAyABIAZB2IbSABDDIQALIAQgAEEDayIBSQ0SIA1CADcDACAEIAFrQQdNDRsgDUEIIAEgA2pBCEHIjtIAENUsIAYgDTUCACIbQoCAgIDQ9+maHn4gHIinIgJNDQYgDTEABiEeIA0xAAUhHyANMQAEISAgBSACQQJ0aiABNgIAIAYgGyAgQiCGhCIbQhiGQoCAgIBwg0K9z9bxAX4gHIinIgFNDQcgBSABQQJ0aiAAQQJrNgIAIAYgH0IohiAeQjCGhCAbhCIbQhCGQoCAgIBwg0K9z9bxAX4gHIinIg5NDQggG0IIhkKAgICAcIMMAwsgAiAGQbiG0gAQwyEACyABIAZByIbSABDDIQALIAUgAUECdGogAEEDazYCACANQgA3AwAgBCAAQQJrIgFrQQdNDRAgDUEIIAEgA2pBCEHIjtIAENUsIAYgDSkDACIbIB2GQr3P1vEBfiAciKciAk0NASAFIAJBAnRqIAE2AgAgBiAbQgiIIB2GQr3P1vEBfiAciKciDk0NAiAbQhCIIB2GCyEbIAUgDkECdGogAEEBazYCACAGIBtCvc/W8QF+IByIpyIBSw0FIAEgBkHIh9IAEMMhAAsgAiAGQeiG0gAQwyEACyAOIAZB+IbSABDDIQALIAIgBkGYh9IAEMMhAAsgASAGQaiH0gAQwyEACyAOIAZBuIfSABDDIQALIAUgAUECdGoiASgCACEOIAEgADYCACAQIQ8gACAOayIHQfH/D0kNAQwLCwsgACAEQdiF0gAQrzsACyAOIARB6IXSABCvOwALIAIgBEH4hdIAEK87AAsgASAEQYiG0gAQrzsAC0EAQQBB6IHSABDDIQALQbiE0gBBH0GYhtIAEJ8pAAsgASAEQaiG0gAQrzsACyABIARBiIfSABCvOwALDAcLIA8hEAsgAEEBaiEOIAAgBEkEQCADIA5qIAQgDmsgFiAIEPodIQ8gAEECaiIHIBRLDQUMAwsgDiAEQdiH0gAQrzsACyACQQV2IQcgAkEBaiECIBMhDyAUIAcgASIOaiIHTw0ACwsMAQsgDiAEQbiC0gAQrzsACwJAAkAgACASSQRAIBIgAGsiASALEKQOIAwgDCgCAEEBajYCACAJKAIEIgIgAUkNASAEIBJJDQIgCSgCACIEIAEgACADaiABQYiI0gAQ1SwgCSACIAFrNgIEIAkgASAEajYCACAKIAooAgAgAWo2AgALIA1BIGokAA8LIAEgAkHoh9IAELA7AAsgEiAEQfiH0gAQsDsACyANQQA2AhggDUEBNgIMIA1BwP/RADYCCCANQgQ3AhAgDUEIakG4jtIAEO8sAAvfIAIRfwZ+IwBBgANrIgUkACABQegAaiEMQQEhBgJAAkACQAJAAkACQAJAAkACQAJAIAEpA2hCA1IEQCABKALQASIHQQBIDQEgASgC1AEiBkEASA0BIAYgB2oiByABKAL4AUoNASAHQQBIBEBBASEEIAVBATYCTCAFQay+zQA2AkggBUIBNwJUIAVBpgQ2AqwCIAUgBUGoAmo2AlAgBSAFQRRqNgKoAiAAQQxqIAVByABqEJkOIABBADYCCCAAQgw3AwAMBgsgAS0A2AEiBkECRiAGciEGCyAEQQBHIAZxIhANASAFQQhqIAJBCGopAgA3AwAgBSACKQIANwMADAMLIAVBBDYCrAIgBUGc/c0ANgKoAiAFQgM3ArQCIAVBnAM2AlwgBSABQfgBajYCWCAFQZwDNgJUIAUgAUHUAWo2AlAgBUGcAzYCTCAFIAFB0AFqNgJIIAUgBUHIAGo2ArACIAVB0AFqIAVBqAJqEJkOIABBADYCCCAAIAUpAtABNwIMIABBFGogBUHYAWooAgA2AgAgAEIMNwMADAELIAEoAvgBIgZBAEgEQCAFQQE2AkwgBUGsvs0ANgJIIAVCATcCVCAFQaYENgKsAiAFIAVBqAJqNgJQIAUgBUEUajYCqAIgAEEMaiAFQcgAahCZDiAAQQA2AgggAEIMNwMADAELIAUgBjYCECAFQcgAaiIIIAZBAEEBQQEQoBggBSgCTCEJAkACQAJAAkAgBSgCSEEBRwRAIAVBADYCyAEgBSAFKAJQNgLEASAFIAk2AsABIAcgAigCCCIJSw0BIAVBwAFqIgogAigCBCAHEKE2IAYgB0YNAyACKAIIIgkgB0kNAiAIIAQoAgAgAigCBCAHaiAJIAdrIApBASAGIAdrIAQoAgQoAhARCwAgBSgCSCIEQQhGDQMgACAFKQNQNwMQIABBGGogBUHYAGopAwA3AwAgACAFKAJMNgIMIAAgBDYCCAwECyAJIAUoAlBBvP3NABD9LwALIAcgCUHM/c0AELA7AAsgByAJQez9zQAQrzsACyAGIAUoAsgBIgRGBEAgBUHQAGogBUHIAWooAgA2AgAgBSAFKQLAATcDSCAFIAVByABqEOcVDAMLIAUgBDYCFCAFQQM2AkwgBUG8/s0ANgJIIAVCAjcCVCAFQTs2ArQCIAVBOzYCrAIgBSAFQagCajYCUCAFIAVBEGo2ArACIAUgBUEUajYCqAIgBUHQAWogBUHIAGoQmQ4gAEEANgIIIAAgBSkC0AE3AgwgAEEUaiAFQdgBaigCADYCAAsgAEIMNwMAIAVBwAFqEN47C0EBIQQMAQsCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAvQBDgQCAAEDAAsgBUECNgJMIAVBgP/NADYCSCAFQgE3AlQgBUHmBjYCrAIgBSABQfQBajYCqAIgBSAFQagCajYCUCAFQcgAakGQ/80AEO8sAAsgAS0A8AEiB0EDRw0CQQEhByAFQcgAakEeQQBBAUEBEKAYIAUoAkwhBCAFKAJIQQFHDQcgBCAFKAJQQbT1zQAQ/S8ACyABKQMAIhZCA1INA0EBIQRBACEHIAVBqAJqQRtBAEEBQQEQoBggBSgCrAIhBiAFKAKoAkEBRw0CDBALIAwpAwAiFkIDUg0EQQEhB0EAIQQgBUGoAmpBG0EAQQFBARCgGCAFKAKsAiEGIAUoAqgCQQFHDQMMDwsgBUGwAmogBUEIaikDADcDACAFIAUpAwA3A6gCIAEoAugBIgNBAEgEQEEBIQcgBUEBNgJMIAVBrL7NADYCSCAFQgE3AlQgBUGmBDYC1AEgBSAFQdABajYCUCAFIAVBFGo2AtABIABBDGogBUHIAGoQmQ4gAEEANgIIIABCDDcDACAFQbQCaiAFKAKsAiAFKAKwAiAFKAKoAigCEBEBAEEBIQQMBwsgBUHIAGogASgC7AEQxhogBS0ATCEIIAUoAkgiBEEIRwRAIAAgBSkATTcADSAAQRxqIAVB3ABqKAAANgAAIABBFWogBUHVAGopAAA3AAAgACAIOgAMIAAgBDYCCCAAQgw3AwAgBUG0AmogBSgCrAIgBSgCsAIgBSgCqAIoAhARAQBBASEHQQEhBAwHCyAHQQFxIQogBSkDqAIhFyAFKQOwAiEWQgshGAwHCyAFKAKwAiIDQRdqQdX/zQAoAAA2AAAgA0EQakHO/80AKQAANwAAIANBCGpBxv/NACkAADcAACADQb7/zQApAAA3AAAgAEEbNgIUIAAgAzYCECAAIAY2AgwgAEEANgIIIABCDDcDAAwECyABKQMIIRcgASkDECEYIAEpAxghGSAFQegAaiABQSBqQcgA/AoAACAFIBk3A2AgBSAYNwNYIAUgFzcDUCAFIBY3A0ggBUHIAWogBUEIaikDADcDACAFIAUpAwA3A8ABIAUoAqABIgdBAEgEQEEBIQQgBUEBNgKsAiAFQay+zQA2AqgCIAVCATcCtAIgBUGmBDYC1AEgBSAFQdABajYCsAIgBSAFQRRqNgLQASAAQQxqIAVBqAJqEJkOQQAhByAAQQA2AgggAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAULIAVBqAJqIAUoAqQBEMYaIAUtAKwCIQQCQAJAIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIAQ6AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiAFKAKoARDGGiAFLQCsAiEOIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIA46AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiAFKAKsARDGGiAFLQCsAiEPIAUoAqgCIgZBCEcEQCAAIAUpAK0CNwANIABBHGogBUG8AmooAAA2AAAgAEEVaiAFQbUCaikAADcAACAAIA86AAwgACAGNgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFQagCaiIGIAVByABqQdgA/AoAACAFQdABaiADIAYQqgIgBSkD6AEhGSAFLwHmASENIAUtAOUBIQogBS0A5AEhCCAFKALgASEDIAUpA9gBIRYgBSkD0AEiF0IJUg0BIAAgGTcDGCAAIA07ARYgACAKOgAVIAAgCDoAFCAAIAM2AhAgACAWNwMIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBAAtBASEEQQAhBwwFCyAFQRhqIAVB8AFqQTD8CgAAIAUpA6ACIRogBSkDwAEhGyAFKALIASEGIAUoAswBIRFBASESQgkhGAwFCyAFKAKwAiIDQRdqQfD/zQAoAAA2AAAgA0EQakHp/80AKQAANwAAIANBCGpB4f/NACkAADcAACADQdn/zQApAAA3AAAgAEEbNgIUIAAgAzYCECAAIAY2AgwgAEEANgIIIABCDDcDAAwCCyABKQNwIRcgASkDeCEYIAEpA4ABIRkgBUHoAGogAUGIAWpB2AD8CgAAIAUgGTcDYCAFIBg3A1ggBSAXNwNQIAUgFjcDSCAFLQC4ASELIAVByAFqIAVBCGopAwA3AwAgBSAFKQMANwPAASAFKAKgASIGQQBIBEBBASEHIAVBATYCrAIgBUGsvs0ANgKoAiAFQgE3ArQCIAVBpgQ2AtQBIAUgBUHQAWo2ArACIAUgBUEUajYC0AEgAEEMaiAFQagCahCZDkEAIQQgAEEANgIIIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwDCyAFQagCaiAFKAKsARDGGiAFLQCsAiEJAkACQCAFKAKoAiIEQQhHBEAgACAFKQCtAjcADSAAQRxqIAVBvAJqKAAANgAAIABBFWogBUG1AmopAAA3AAAgACAJOgAMIAAgBDYCCCAAQgw3AwAgBUHMAWogBSgCxAEgBSgCyAEgBSgCwAEoAhARAQAgBUHIAGoQ8SsMAQsgBSgCpAEiEUEASARAIABBCGoQ2yQgAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAELIAUoAqgBIgdBAEgEQCAAQQhqENskIABCDDcDACAFQcwBaiAFKALEASAFKALIASAFKALAASgCEBEBACAFQcgAahDxKwwBCyAFKAKwASIEQQBIBEAgAEEIahDbJCAAQgw3AwAgBUHMAWogBSgCxAEgBSgCyAEgBSgCwAEoAhARAQAgBUHIAGoQ8SsMAQsgBSgCtAEiE0EASARAIABBCGoQ2yQgAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAIAVByABqEPErDAELIAVBqAJqIgggBUHIAGpB2AD8CgAAIAVB0AFqIAMgCBCqAiAFLwHuASENIAUtAO0BIQogBS0A7AEhCCAFKALoASEDIAUpA+ABIRYgBSkD2AEhFyAFKQPQASIYQglSDQEgACANOwEeIAAgCjoAHSAAIAg6ABwgACADNgIYIAAgFjcDECAAIBc3AwggAEIMNwMAIAVBzAFqIAUoAsQBIAUoAsgBIAUoAsABKAIQEQEAC0EAIQRBASEHDAMLIAUpA/ABIRkgBUEYaiAFQfgBakEw/AoAACALQQJGIAtyQQFxIRQgBEGAgID4B3EhCyAEQRB2IQ8gBEEIdiEOIAUpA8ABIRogBSkDyAEhG0EBDAQLIAUoAlAiA0EWakG2/80AKQAANwAAIANBEGpBsP/NACkAADcAACADQQhqQaj/zQApAAA3AAAgA0Gg/80AKQAANwAAIABBHjYCFCAAIAM2AhAgACAENgIMIABBADYCCCAAQgw3AwBBASEECyAFQQxqIAUoAgQgBSgCCCAFKAIAKAIQEQEACyAQDQMMBAtBAAsgACAZNwMgIAAgDTsBHiAAIAo6AB0gACAIOgAcIAAgAzYCGCAAIBY3AxAgACAXNwMIIAAgGDcDACAAQShqIAVBGGpBMPwKAAAgACAJOgB9IAAgFDoAfCAAIBM2AnggACAHNgJwIAAgETYCbCAAIAY2AmggACAbNwNgIAAgGjcDWCAAIARB/wFxIA9B/wFxQRB0IAtyIA5B/wFxQQh0cnI2AnQgEARAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIBIgASkDAEIDUXJFBEAgARDxKwsgDCkDAEIDUXINBAwDC0EBIQcLIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALAkAgB0UNACABKQMAQgNRDQAgARDxKwsgBEUNASAMKQMAQgNRDQELIAwQ8SsLIAVBgANqJAAPCyAGIAUoArACQbT1zQAQ/S8AC4guAhF/AX4jAEHQBGsiAyQAIAMgAjYCeEEBIQYCQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAIAEtAAAiBEECaw4lBgABAgYAAQIAAQICAQIBAgIDBwcHBwcHBwcHBwcHBwcHAQIEBQcLQQIhBgwFC0EEIQYMBAtBCCEGDAMLIAEtAAFBAnRB/ISHAWooAgAhBgwCC0EQIQYMAQtBICEGC0EMQQQQrTYiB0UNBSADQZQDaiACIAZsENIfIAMgAykClAM3AvwDIANBADYC+AMgAyADKAKgAyIENgL0AyADIAMoApwDNgLwAyADQfAAaiADQfADahDXOyADKAJwIQgMAwtBBCEHIAQhBUEEIQYgBCEIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBA4pHwEAAAAAAAAAAAAAAAAAAAAAAAACAwQFAgQFDAAGBwALCAkAAAAADAoACyADIAE2ArQCIANBATYC9AMgA0G45oYBNgLwAyADQgE3AvwDIANBpwQ2ApgDIAMgA0GUA2o2AvgDIAMgA0G0Amo2ApQDIANB8ANqQcDmhgEQ7ywAC0EMQQQQrTYiB0UNHiADQZQDaiACQQN2IAJBB3FBAEdqENIfIAMgAykClAM3AvwDQQAhBSADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0EIaiADQfADahDXOyADKAIIIQgMHAtBGEEEEK02IgdFDREgA0GUA2oiCiACQQJ0QQRqENIfIAMgAykClAM3AvwDIANBADYC+AMgAyADKAKgAyIFNgL0AyADIAMoApwDNgLwAyADQRhqIANB8ANqIgQQ1zsgAygCGCEIQRxBBBCtNiICRQ0fIAJCgYCAgBA3AgAgAiADKQLwAzcCCCACQRBqIANB+ANqIg8pAgA3AgAgAkEYaiADQYAEaiIMKAIANgIAIApBABDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiCTYC9AMgAyADKAKcAzYC8AMgA0EQaiAEENc7IAMoAhAhCkEcQQQQrTYiBEUNHyAEQoGAgIAQNwIAIAQgAykC8AM3AgggBEEQaiAPKQIANwIADBoLQQxBBBCtNiIHRQ0cIANBlANqIAEoAgQgAmwQ0h8gAyADKQKUAzcC/ANBACEFIANBADYC+AMgAyADKAKgAyIENgL0AyADIAMoApwDNgLwAyADQSBqIANB8ANqENc7IAMoAiAhCAwaC0EYQQQQrTYiB0UNECADQZQDaiIKIAJBA3RBCGoQ0h8gAyADKQKUAzcC/AMgA0EANgL4AyADIAMoAqADIgU2AvQDIAMgAygCnAM2AvADIANBMGogA0HwA2oiBBDXOyADKAIwIQhBHEEEEK02IgJFDR0gAkKBgICAEDcCACACIAMpAvADNwIIIAJBEGogA0H4A2opAgA3AgAgAkEYaiADQYAEaiIMKAIANgIAIApBABDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiCTYC9AMgAyADKAKcAzYC8AMgA0EoaiAEENc7IAMoAighCkEcQQQQrTYiBEUNHSAEQoGAgIAQNwIAIAQgAykC8AM3AgggBEEQaiADQfgDaikCADcCAAwYC0EMQQQQrTYiB0UNGiADQZQDaiACQQR0ENIfIAMgAykClAM3AvwDQQAhBSADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0E4aiADQfADahDXOyADKAI4IQgMGAtBxABBBBCtNiIGRQ0aIAYgASgCCEEwaiABKAIEIAJsEK8BQQEhBUEADBULQQxBBBCtNiIHRQ0YIANBlANqIAJBA3RBCGoQ0h8gAyADKQKUAzcC/AMgA0EANgL4AyADIAMoAqADIgQ2AvQDIAMgAygCnAM2AvADIANByABqIANB8ANqENc7IAMoAkghAkEcQQQQrTYiBUUNGiAFQoGAgIAQNwIAIAUgAykC8AM3AgggBUEQaiADQfgDaikCADcCACAFQRhqIANBgARqKAIANgIAIAcgBDYCCCAHIAI2AgQgByAFNgIAQcQAQQQQrTYiBkUNGSAGIAEoAgRBMGpBABCvAQwTCyADQeAAaiABQQRqIgoQsC4gAygCYCIEIAMoAmRGDQ0gBC0AACEEIwBBMGsiDCQAIAxBEGohCCMAQSBrIgkkACAJQRRqIAJBAEEBQQEQoBggCSgCGCEFAkAgCSgCFEEBRwRAIAlBADYCECAJIAkoAhw2AgwgCSAFNgIIIAlBCGogAhCBLiAJKAIQIQUgAgRAIAIEQCAJKAIMIAVqIAQgAvwLAAsgAiAFaiEFCyAIIAkpAgg3AgAgCEEIaiAFNgIAIAlBIGokAAwBCyAFIAkoAhxBhKSHARD9LwALIAwoAhQhAiAMKAIYIQUgDCAMKAIQNgIsIAxCgICAgBA3AiQgDCAFNgIgIAwgAjYCHCAMQQhqIAxBHGoQ1zsgDCgCCCECQRxBBBCtNiIIRQ0ZIAhCgYCAgBA3AgAgCCAMKQIcNwIIIANB/ABqIgQgBTYCCCAEIAI2AgQgBCAINgIAIAhBEGogDEEkaikCADcCACAIQRhqIAxBLGooAgA2AgAgDEEwaiQAIAFBAWoiCC0AAA0EQQwQyy8iB0EIaiADQYQBaigCADYCACAHIAMpAnw3AgBBAQwFC0EMQQQQrTYiB0UNFkEBIQQCQAJAAkACQAJAAkACQAJAIAEoAgQiBS0AAEECaw4lBwYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAULQQQhBAwGC0EIIQQMBQsgBS0AAUECdEH8hIcBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtB8OSGARCyOwALQQIhBAsgA0GUA2ogAiAEbBDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0HoAGogA0HwA2oQ1zsgAygCaCECQRxBBBCtNiIFRQ0YIAVCgYCAgBA3AgAgBSADKQLwAzcCCCAFQRBqIANB+ANqKQIANwIAIAVBGGogA0GABGooAgA2AgAgByAENgIIIAcgAjYCBCAHIAU2AgBBxABBBBCtNiIGRQ0XIAYgASgCCEEAEK8BDBELIAEoAgQiBEEwaiEIIAQtADBBA2sOAwUGBwQLIANB0ABqIAFBBGoQwzQgAygCVCEEIAMgAygCUCICNgLwAyADIAIgBEECdGo2AvQDIAMgA0H4AGo2AvgDIwBBIGsiDiQAIA5BFGogA0HwA2oiAigCBCACKAIAa0ECdkEAQQRBxAAQoBggDigCGCEEIA4oAhRBAUYEQCAEIA4oAhxByNqGARD9LwALIANBlANqIQ8gDkEQaiIKQQA2AgAgDiAOKAIcNgIMIA4gBDYCCCMAQRBrIg0kACACKAIEIAIoAgBrQQJ2IgQgDkEIaiIFKAIAIAUoAggiC2tLBEAgBSALIARBBEHEABDeKCAFKAIIIQsLIA0gBSgCBDYCDCANIAs2AgggDSAFQQhqNgIEIwBB0ABrIgwkACANQQRqIgkoAgQhBiAJKAIAIAIoAgAiCyACKAIEIgVHBEAgAigCCCEEIAkoAgggBkHEAGxqIQkgBiAFIAtrQQJ2IgVqIQYDQCAMQQxqIgIgCygCAEEwaiAEKAIAEK8BIAkgAkHEAPwKAAAgC0EEaiELIAlBxABqIQkgBUEBayIFDQALCyAGNgIAIAxB0ABqJAAgDUEQaiQAIA9BCGogCigCADYCACAPIA4pAgg3AgAgDkEgaiQAIAMoApQDIQUgAygCmAMhBiADKAKcAyEIQQEhE0EAIQQMEwtBDEEEEK02IgdFDRMgA0GUA2ogAkECdEEEahDSHyADIAMpApQDNwL8AyADQQA2AvgDIAMgAygCoAMiBDYC9AMgAyADKAKcAzYC8AMgA0FAayADQfADahDXOyADKAJAIQJBHEEEEK02IgVFDRUgBUKBgICAEDcCACAFIAMpAvADNwIIIAVBEGogA0H4A2opAgA3AgAgBUEYaiADQYAEaigCADYCACAHIAQ2AgggByACNgIEIAcgBTYCAEHEAEEEEK02IgZFDRQgBiABKAIEQTBqQQAQrwEMDgsgAygCeCICQQBIDQlBGBDLLyEHIwBBMGsiCyQAIAtBEGohCUEAIQwjAEEgayINJAAgDUEUaiACQQAgAkEAShtBAEEEQQQQoBggDSgCGCEEIA0oAhRBAUYEQCAEIA0oAhxBhKSHARD9LwALIA1BEGoiBUEANgIAIA0gDSgCHDYCDCANIAQ2AgggAkEAIAJBAEobIgQgDUEIaiIPKAIAIA8oAggiBmtLBEAgDyAGIARBBEEEEN4oIA8oAgghBgsgDyACQQBKBH8gAiAGaiAPKAIEIAZBAnRqIQYDQCAGIAw2AgAgBkEEaiEGIAIgDEEBaiIMRw0ACwUgBgs2AgggCUEIaiAFKAIANgIAIAkgDSkCCDcCACANQSBqJAAgCygCFCEFIAsoAhghAiALIAsoAhBBAnQ2AiwgC0KAgICAwAA3AiQgCyACQQJ0IgQ2AiAgCyAFNgIcIAtBCGogC0EcahDXOyALKAIIIQJBHEEEEK02IglFDRQgCUKBgICAEDcCACAJIAspAhw3AgggA0HwA2oiBSAENgIIIAUgAjYCBCAFIAk2AgAgCUEQaiALQSRqKQIANwIAIAlBGGogC0EsaigCADYCACALQTBqJAAgB0EIaiADQYQBaigCADYCACAHIAMpAnw3AgAgByADKQLwAzcCDCAHQRRqIANB+ANqKAIANgIAQQILIQQgA0HYAGogChCwLiADKQNYIRQgAyAINgL8AyADQQA2AvgDIAMgFDcC8AMgAyADQfgAajYCgAQjAEEgayIRJAAgEUEUaiADQfADaiICKAIEIAIoAgBrQQN2QQBBBEHEABCgGCARKAIYIQUgESgCFEEBRgRAIAUgESgCHEHI2oYBEP0vAAsgA0GIAWohDCARQRBqIgpBADYCACARIBEoAhw2AgwgESAFNgIIIwBBIGsiEiQAIAIoAgQiCSACKAIAIgZrQQN2IgUgEUEIaiIIKAIAIAgoAggiEGtLBEAgCCAQIAVBBEHEABDeKCAIKAIIIRALIAgoAgQhBSACKQIMIRQgEiACKAIINgIcIBIgFDcCFCASIAU2AhAgEiAQNgIMIBIgCEEIajYCCCMAQdAAayIOJAAgEkEIaiIQKAIEIQsgECgCACAGIAlHBEAgECgCFCEPIBAoAhAhBSAQKAIMIQIgBkEEaiENIBAoAgggC0HEAGxqIRAgCyAJIAZrQQN2IglqIQsDQAJAAkAgD0UNACACLQAARQ0AIA5BDGogDSgCAEEwakEAEK8BDAELIA5BDGogDSgCAEEwaiAFKAIAEK8BCyAQIA5BDGpBxAD8CgAAIA1BCGohDSAQQcQAaiEQIA9BAWohDyAJQQFrIgkNAAsLIAs2AgAgDkHQAGokACASQSBqJAAgDEEIaiAKKAIANgIAIAwgESkCCDcCACARQSBqJAAgAygCkAEhCCADKAKMASEGIAMoAogBIQUMEAsgAyAINgK0AiADQQE2AvQDIANB9OWGATYC8AMgA0IBNwL8AyADQacENgKYAyADIANBlANqNgL4AyADIANBtAJqNgKUAyADQfADakH85YYBEO8sAAsgAkGAgAJPDQcgA0GUA2ohCiMAQSBrIgQkAAJAQcAAQcAAENE0BEBBwABBwAAQrTYiBUUNFSAFIAI7AQAgBELAgICAgAg3AhggBEICNwIQIAQgBTYCDCAEIARBDGoQ1zsgBCgCACECQRxBBBCtNiIFRQ0TIAVCgYCAgBA3AgAgBSAEKQIMNwIIIApBAjYCCCAKIAI2AgQgCiAFNgIAIAVBEGogBEEUaikCADcCACAFQRhqIARBHGooAgA2AgAgBEEgaiQADAELDBMLDAILIAJBAEgNByADQZQDaiEKIwBBIGsiBCQAAkBBwABBwAAQ0TQEQEHAAEHAABCtNiIFRQ0UIAUgAjYCACAEQsCAgICACDcCGCAEQgQ3AhAgBCAFNgIMIAQgBEEMahDXOyAEKAIAIQJBHEEEEK02IgVFDRIgBUKBgICAEDcCACAFIAQpAgw3AgggCkEENgIIIAogAjYCBCAKIAU2AgAgBUEQaiAEQRRqKQIANwIAIAVBGGogBEEcaigCADYCACAEQSBqJAAMAQsMEgsMAQsgAyACrTcD8AMgA0GUA2ohBSADQfADaiECIwBBIGsiCiQAAkBBwABBwAAQ0TQEQEHAAEHAABCtNiIERQ0TIAQgAikDADcDACAKQsCAgICACDcCGCAKQgg3AhAgCiAENgIMIAogCkEMahDXOyAKKAIAIQJBHEEEEK02IgRFDREgBEKBgICAEDcCACAEIAopAgw3AgggBUEINgIIIAUgAjYCBCAFIAQ2AgAgBEEQaiAKQRRqKQIANwIAIARBGGogCkEcaigCADYCACAKQSBqJAAMAQtB+KSHAUEpIApBDGpB/KWHAUGkpYcBENUeAAsLIANBkARqIAgQ2gYgA0EAOwHIBCADQQA2AsQEIANBADYCrAQgA0IBNwKcBCADQgQ3AogEIANCADcCgAQgA0KAgICAwAA3AvgDIANBADYC8ANBDEEEEK02IgRFDQwgBCADKQKUAzcCACAEQQhqIANBnANqKAIANgIAIANB+ANqIgIQxScgAkEEQQwQ4B4gA0EBNgKABCADIAQ2AvwDIANBATYC+AMgA0GUAWoiBCADQfADakHcAPwKAAAgA0HwAWoiAiAEEM0cQYgBQQQQrTYiBkUNBiAGQcQAaiABKAIIQTBqQQEQrwEgBiACQcQA/AoAAEEAIQRBAiEFQQIhCAwLC0EEQRgQoz0AC0EEQRgQoz0AC0HQ5IYBELI7AAtB4OSGARCyOwALQYDlhgFBDEGM5YYBEMskAAtBgOWGAUEMQZzlhgEQyyQAC0EEQYgBEKM9AAtBASEFQQELIQRBASEIQQEhEwwCCyAEQRhqIAwoAgA2AgAgByAJNgIUIAcgCjYCECAHIAQ2AgwgByAFNgIIIAcgCDYCBCAHIAI2AgBBASETQQAhBUECIQRBACEIDAELQRxBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAiADKQLwAzcCCCACQRBqIANB+ANqKQIANwIAIAJBGGogA0GABGooAgA2AgAgByAENgIIIAcgCDYCBCAHIAI2AgBBASEEQQQhBkEAIQhBASETCyADQZAEaiABENoGIANBADsByAQgA0EANgLEBCADQQA2AqwEIANBADYCoAQgA0IENwKIBCADQgA3AoAEIANCgICAgMAANwL4AyADQQA2AvADIAMgAygCeDYCnAQgA0H4A2oiARDFJyABQQRBDBDgHiADIAQ2AoAEIAMgBzYC/AMgAyAENgL4AyADQZQDaiADQfADakHcAPwKAAAgAygCsAMiBARAIAMoAqwDIQcDQCAHEKUeIAdBxABqIQcgBEEBayIEDQALCyADQagDakEEQcQAEOAeIAMgCDYCsAMgAyAGNgKsAyADIAU2AqgDIANBuAJqIgQgA0GUA2oiAkHcAPwKAAAgEwRAIANB8ANqIgEgBEHcAPwKAAAgAiADKAJ4EOU6IAQgASACEMIZCyAAIANBuAJqEM0cIANB0ARqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAtBBEEcEKM9AAtB+KSHAUEpIARBDGpB/KWHAUGkpYcBENUeAAtBwABBwAAQoz0AC8gbAhp/AX4jAEFAaiIIJAAgACgCDCAAKAIEIAAoAswBIQsgACgCyAEhDCAIIAAoAhw2AjwgACgChAEhDyAAKAKAASEUIAhBOGpBADYCACAIQgA3AzAgBkEEdEEGIAwgDEEGTxtBA2tBACAMQQNPG0ECdGpB0KvRAGoCQCAAKALUASIGBEAgCEEgaiAGQRBqKAIANgIAIAhBGGogBkEIaikCADcDACAIIAYpAgA3AxAMAQsgCEEgakEANgIAIAhBGGpCADcDACAIQgA3AxALIAxBA0YhDCALQf8fSSEYIAMgBGohFSgCACEZIABB8ABqIRJqIQogCEIANwIkIAhBADYCLCAIQRBqQQAgBBCRFiAAQQA2AqgBIAAoArABIQYCQCAAAn8gACgCjAFFBEAgBEEITQRAIABBATYCqAELIAAoAqwBIgkoAoQIQQJGBEBBACEEIABBADYCqAECQCAGQQJGDQAgAEEANgKIAUEAIQcDQCAHQYACRg0BIAAoAnAgBGpBAUELIAkgB0ECdGotAAQiBmt0QQEgBhsiBjYCACAAIAAoAogBIAZqNgKIASAEQQRqIQQgB0EBaiEHIAAoAqwBIQkMAAsAC0EAIQcgAEEANgKMAUEBIAkvALgZIgRBAWt0QQEgBBtBAnQgCWpBwBlqIQQgACgCdCEGA0AgB0GQAUcEQCAGIAdqQQFBAUEKIAQoAgBB//8DaiIOQRB2a3QgDkGAgARJGyIONgIAIAAgDiAAKAKMAWo2AowBIARBCGohBCAHQQRqIQcMAQsLQQAhByAAQQA2ApABQQEgCS8AjA4iBEEBa3RBASAEG0ECdCAJakGUDmohBCAAKAJ4IQYDQCAHQdQBRwRAIAYgB2pBAUEBQQogBCgCAEH//wNqIg5BEHZrdCAOQYCABEkbIg42AgAgACAOIAAoApABajYCkAEgBEEIaiEEIAdBBGohBwwBCwtBACEHIABBADYClAFBASAJLwCICCIEQQFrdEEBIAQbQQJ0IAlqQZAIaiEEIAAoAnwhBgNAIAdBgAFGDQQgBiAHakEBQQFBCiAEKAIAQf//A2oiDkEQdmt0IA5BgIAESRsiDjYCACAAIA4gACgClAFqNgKUASAEQQhqIQQgB0EEaiEHDAALAAsgBkECRwRAIAhB/wE2AgQgACgCcCAIQQRqIAMgBBCYFRogACAAKAJwQf8BQQhBABDjJTYCiAELIAAoAnRBgKzRAEGQAfwKAAAgAEGArNEAQSQQhiw2AowBIAAoAnghBEEAIQcDQCAHQdQBRwRAIAQgB2pBATYCACAHQQRqIQcMAQsLIABBNTYCkAEgACgCfEGQrdEAQYAB/AoAAEGQrdEAQSAQhiwMAQsgBkECRwRAIAAgACgCcEH/AUEMEMorNgKIAQsgACAAKAJ0QSNBCxDKKzYCjAEgACAAKAJ4QTRBCxDKKzYCkAEgACgCfEEfQQsQyisLNgKUAQtBA0EEIAwbIQ4gC0H/HyAYGyEaIBVBCGshGyASIAUQuhIgD0EcaiEYIBVBIGshFyADIAMgCkZqIRMgAyEMA0ACQAJAAkACfwJAIBMgG0kEQCAIIBQgACAIQTxqIBMgFSACIAwgE0YgDiAZERIANgIEIAhBEGogFCAIQQRqIBMgA2sgFSATaxDdFiAIKAIEIgsEQCATIAxrIRBBACEHA0AgB0EMRwRAIAcgD2pBEGogAiAHaigCADYCACAHQQRqIQcMAQsLIA8gEDYCDCAPQQA2AgggDyAQIBIgBRDkEiIKNgIAIBogFCALQQN0aiIEQQRrKAIAIgZJBEAgBEEIaygCACEJQQAhBAwFC0EBIQdBACASIAUQ5BIhBiAYIQQDQCAHIA5GBEAgBiAKaiEKQQAhCSAOIQQDQCAJIAtHBEAgDyAEQRxsaiEHIBQgCUEDdGoiBigCBCENIAYoAgAhBgNAIAQgDU0EQCAGIAQgEiAFELAOIREgB0EMaiAQNgIAIAdBBGogBjYCACAHQQhqIAQ2AgAgByAKIBFqNgIAIAdBHGohByAEQQFqIQQMAQsLIAlBAWohCQwBCwsgBEEBayEHQQEhDQNAAkAgByANSQ0AIA8gDUEcbGoiCkEca0EBIQYgCkEUaygCAEUEQCAKQRBrKAIAQQFqIQYLIA0gE2ohESgCACEJAn9BgBAgACgCsAFBAkYNABpBgAwgACgCqAFBAUYNABogACgCmAEiEEGAAmshBCAAKAJwIBFBAWstAABBAnRqKAIAQQFqIhZnIQsgECAEAn8gBQRAQR8gC2siC0EIdCAWQQh0IAt2agwBC0GAPiALQQh0awsiC0kEfyAEBSALC2sLIQQCfwJAAkAgBiASIAUQ5BIgBCAJamogBkEBayASIAUQ5BJrIgsgCigCACIETARAIAogBjYCDCAKQgA3AgQgCiALNgIAIApBCGohFgwBCyAKQQhqIRYgCigCCCIGDQEgBCELCyAKIApBDGsiBCkCADcCECAKQRhqIARBCGooAgA2AgBBASEJQQAMAQsgCEEEaiAPIA0gBmtBHGxqQRBqIAooAgQgCigCDEUQjxogCkEYaiAIQQxqKAIANgIAIAogCCkCBDcCEEEAIQkgBCELQQELIQQCQCARIBtLDQAgByANRg0BIAVFBEAgCkEcaigCACALQYABakwNAQtBACEQIAkEQCAKKAIMIRALQQAgEiAFEOQSIAggFCAAIAhBPGogESAVIApBEGogBCAOIBkREgA2AgQgCEEQaiAUIAhBBGogESADayAVIBFrEN0WIAgoAgQiHEUNACAUIBxBA3RqIgRBBGsoAgAiBiAaSyAGIA1qQf8fS3INByALaiEfQQAhEQNAIBEgHEYNASAUIBFBA3RqIgQoAgQhBiAOIQsgEQRAIARBBGsoAgBBAWohCwsgBCgCACEWIAYgDWohCQNAAkAgBiALSQ0AIBYgBiASIAUQsA4gH2ohHQJAAkAgByAGIA1qIh5PBEAgHSAPIB5BHGxqKAIATg0BCyAYIAdBHGxqIQQgByAJIAcgCUsbIgogB2shBwNAIAcEQCAEQYCAgIAENgIAIARBHGohBCAHQQFrIQcMAQsLIA8gHkEcbGoiBCAQNgIMIAQgFjYCBCAEIAY2AgggBCAdNgIAIAohBwwBCyAFRQ0BCyAJQQFrIQkgBkEBayEGDAELCyARQQFqIREMAAsACyANQQFqIQ0MAQsLIAhBOGogDyAHQRxsaiIEQRhqKAIANgIAIAggBCkCEDcDMCAEKAIEIQkgBCgCACEgIAcgBCgCDCIQIAQoAggiBmprIgRBACAEIAdNGwwFBSAEQYCAgIAENgIAIARBHGohBCAHQQFqIQcMAQsACwALIBNBAWohEwwGCyAIQUBrJAAgFSAMaw8LIARBCGsoAgAhCSANIBYoAgAEf0EABSAKKAIMC2siBEEAIARBgCBNGwshBCAGRQ0BCyAIQQRqIA8gBEEcbGpBEGogCSAQRRCPGiACQQhqIAhBDGooAgA2AgAgAiAIKQIENwIADAELIAIgDyAEQRxsaiIGKQIQNwIAIAJBCGogBkEYaigCADYCAEEAIQYLIA8gBEEcbGoiB0EoaiAQNgIAIAdBJGogBjYCACAHQSBqIAk2AgAgB0EcaiAgNgIAIAdBLGogCCkDMDcCACAHQTRqIAhBOGooAgA2AgAgBEEBaiIQIQsDQCAEBEAgDyAEQRxsaiIGKAAMIQogBkEIaiIJKAAAIQ0gB0EYaiAGQRhqKAIANgIAIAdBEGogBkEQaikCADcCACAHQQhqIAkpAgA3AgAgByAGKQIANwIAIAQgCiANamsiBkEAIAQgBk8bIQQgB0EcayEHIAtBAWshCwwBCwsDQAJ/AkAgCyAQTQRAIA8gC0EcbGoiBCgCDCIGIAxqIAQoAggiCkUNAhogBCgCBCEJIAAoArABQQJHBEAgBiEHIAwhBANAIAcEQCASKAIAIAQtAABBAnRqIg0gDSgCAEECajYCACAHQQFrIQcgBEEBaiEEDAELCyAAIAAoAogBIAZBAXRqNgKIAQsgACgCdCAGQcAATwR/QTIgBmdrBSAGQcCu0QBqLQAAC0ECdGoiBCAEKAIAQQFqNgIAIAAgACgCjAFBAWo2AowBIAAoAnxBHyAJZ2tBAnRqIgQgBCgCAEEBajYCACAAIAAoApQBQQFqNgKUASAAKAJ4An8gCkEDayIEQYABTwRAQcMAIARnawwBCyAEQcCv0QBqLQAAC0ECdGoiByAHKAIAQQFqNgIAIAAgACgCkAFBAWo2ApABIAEoAgwhByAXIAYgDGoiDU8EQCAMKQAAISEgB0EIaiAMQQhqKQAANwAAIAcgITcAACAGQRFJDQIgASgCDEEQaiAMQRBqIAZBEGsQ2BkMAgsgDCAXTQRAIAcgDCAXIAxrIgwQ2BkgByAMaiEHIBchDAsDQCAMIA1PDQIgByAMLQAAOgAAIAdBAWohByAMQQFqIQwMAAsACyASIAUQuhIMAwsgASABKAIMIAZqNgIMAkAgBkH//wNNBEAgASgCBCEHDAELIAFBATYCJCABIAEoAgQiByABKAIAa0EDdTYCKAsgByAJNgIAIAcgBjsBBCAEQYCABE8EQCABQQI2AiQgASAHIAEoAgBrQQN1NgIoCyAHIAQ7AQYgASAHQQhqNgIEIAogDWoiDAshEyALQQFqIQsMAAsACwAL4DICE38DfiMAQYACayICJAAgASEDAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0AAA4pKSorLC0uLzAxAAECAwQFBgcICQoLDA0ODxAREjMTFDMVKBYXGRobHB0zC0H114cBIQVBgICAgHgMMQtB9teHASEFQYCAgIB4DDALQffXhwEhBUGAgICAeAwvC0H414cBIQVBgICAgHgMLgtBBCEKIANBBGohBSADKAIEIQYgAy0AAUEBaw4DGhscGQtBgICAgHghBkGs2IcBIQVBAyEKDDMLQYCAgIB4IQZBr9iHASEFQQMhCgwyC0GAgICAeCEGQbLYhwEhBUEDIQogAy0AAQ4CMR4rC0GAgICAeCEGQbjYhwEhBUEDIQogAy0AAUECaw4CMB4qCyADLQABQQJ0QdDahwFqKAIAIQUMLgsgAy0AAUECdEHg2ocBaigCACEFDC0LQdPYhwEhBUGAgICAeAwmCyACIANBBGo2AiggAkEBNgLMASACQdjYhwE2AsgBIAJCATcC1AEgAkGpCDYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQmQ4MKQtB4NiHASEFQYCAgIB4DCQLQYCAgIB4IQZB4diHASEFQQIhCgwqC0Hj2IcBIQVBgICAgHgMIgtB5NiHASEFQYCAgIB4DCELQYCAgIB4IQZB5diHASEFQQIhCgwnC0GAgICAeCEGQefYhwEhBUECIQoMJgsgAiADQQRqNgIoIAJBATYCzAEgAkHs2IcBNgLIASACQgE3AtQBIAJBqQg2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEJkODCILQYCAgIB4IQZB9NiHASEFQQIhCgwkC0GAgICAeCEGQfbYhwEhBUECIQoMIwsgAygCBCEDDAELCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkGc2YcBNgLIAQweCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkG42YcBNgLIAQwdCyACIANBAWo2AhggAiADQQJqNgIoIAJBAjYCzAEgAkHQ2YcBNgLIAQwcCyACIANBAWo2AhggAiADQQJqNgIoIAJBAzYCzAEgAkHk2YcBNgLIAQwbC0GAgICAeCEGQfzZhwEhBUECIQoMHAtBgICAgHghBkH+2YcBIQVBAiEKDBsLIAYNA0GAgICAeCEGQfnXhwEhBQwaCyAGDQNBgICAgHghBkGI2IcBIQUMGQsgBg0DQYCAgIB4IQZBlNiHASEFDBgLIAYNA0GAgICAeCEGQaDYhwEhBQwXCyACIAU2AiggAkEBNgLMASACQYDYhwE2AsgBIAJCATcC1AEgAkH5FzYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQvhgMEwsgAiAFNgIoIAJBATYCzAEgAkGM2IcBNgLIASACQgE3AtQBIAJB+Rc2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEL4YDBILIAIgBTYCKCACQQE2AswBIAJBmNiHATYCyAEgAkIBNwLUASACQfkXNgJcIAIgAkHYAGo2AtABIAIgAkEoajYCWCACQZABaiACQcgBahC+GAwRCyACIAU2AiggAkEBNgLMASACQaTYhwE2AsgBIAJCATcC1AEgAkH5FzYCXCACIAJB2ABqNgLQASACIAJBKGo2AlggAkGQAWogAkHIAWoQvhgMEAtBtdiHASEFDBILQbvYhwEhBQwRCyADKAIEQQhqIgUgAygCCEEDdGohByMAQSBrIgokACAKQRRqIAcgBWtBA3ZBAEEEQQwQoBggCigCGCEGIAooAhRBAUYEQCAGIAooAhxBvNWHARD9LwALIApBEGoiEEEANgIAIAogCigCHDYCDCAKIAY2AggjAEEQayIEJAAgByAFa0EDdiIIIApBCGoiBigCACAGKAIIIgtrSwRAIAYgCyAIQQRBDBDcKCAGKAIIIQsLIAJBKGohDiAEIAYoAgQ2AgwgBCALNgIIIAQgBkEIajYCBCMAQTBrIgYkACAEQQRqIggoAgQhCyAIKAIAIRECQAJAAkAgBSAHRwRAIAgoAgggC0EMbGohCCAHIAVrQQN2IQ0DQAJ/IAUsAAAiB0EATgRAQQNBARCtNiIJRQ0EIAYgCTYCKCAGQQM2AiRBAAwBC0EEQQEQrTYiCUUNBCAJQS06AAAgBiAJNgIoIAZBBDYCJEEBCyEJIAZBLGoiEiAJNgIAIAZBIWohCQJAIAcgB8BBB3UiDHMgDGsiDEH/AXEiD0EKSQRAQQMhBwwBCyAJQQJqIAwgD0HkAG4iDEHkAGxrQf8BcUEBdCITQePziQFqLQAAOgAAIAlBASIHaiATQeLziQFqLQAAOgAAC0EAIA8gDEH/AXEbRQRAIAkgB0EBayIHaiAMQQF0Qf4BcUHj84kBai0AADoAAAsgBkEIaiIMQQMgB2s2AgQgDCAHIAlqNgIAIAZBJGogBigCCCIHIAcgBigCDGoQvCYgBkEYaiASKAIAIgc2AgAgBiAGKQIkIhU3AxAgCEEIaiAHNgIAIAggFTcCACAFQQhqIQUgCEEMaiEIIAtBAWohCyANQQFrIg0NAAsLIBEgCzYCACAGQTBqJAAMAgtBAUEDQdzbhwEQ/S8AC0EBQQRB3NuHARD9LwALIARBEGokACAOQQhqIBAoAgA2AgAgDiAKKQIINwIAIApBIGokACADLQABDQsgAkGQAWoiBiACKAIsIgMgAigCMCIEQfjYhwFBARDxAyACQfgcNgIcIAJBATYCzAEgAkGA2YcBNgLIAQwMC0Hs14cBIQVBgICAgHgMCAtB7deHASEFQYCAgIB4DAcLQe7XhwEhBUGAgICAeAwGC0Hv14cBIQVBgICAgHgMBQtB8NeHASEFQYCAgIB4DAQLQfHXhwEhBUGAgICAeAwDC0Hy14cBIQVBgICAgHgMAgtB89eHASEFQYCAgIB4DAELQfTXhwEhBUGAgICAeAshBkEBIQoMBgsgAiADNgIoIAJBAjYCzAEgAkHA2ocBNgLIASACQgE3AtQBIAJBrwM2AlwgAiACQdgAajYC0AEgAiACQShqNgJYIAJBkAFqIAJByAFqEJkOIAIpApABIRUgACACKAKYATYCECAAIBU3AwggAEKBgICA8IGAgIB/NwMADAYLIAJBkAFqIgYgAigCLCIDIAIoAjAiBEH42IcBQQEQ8QMgAkH4HDYCHCACQQE2AswBIAJBjNmHATYCyAELIAJCATcC1AEgAiAGNgIYIAIgAkEYajYC0AEgAkHYAGogAkHIAWoQvhggBkEBQQEQ4B4gAigCWCEGIAIoAlwhBSACKAJgIQogBARAA0AgA0EBQQEQ4B4gA0EMaiEDIARBAWsiBA0ACwsgAkEoakEEQQwQ4B4MAwsgAigCkAEhBiACKAKUASEFIAIoApgBIQoMAgsgAkICNwLUASACQfYcNgKcASACQfccNgKUASACIAJBkAFqNgLQASACIAJBKGo2ApgBIAIgAkEYajYCkAEgAkHYAGogAkHIAWoQmQ4gAigCWCEGIAIoAlwhBSACKAJgIQoMAQtBgICAgHghBkEDIQoLIAIgCjYCFCACIAU2AhAgAiAGNgIMQQQhBAJAIAICfgJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AACIHQRtrDg4CBAECBAMFBAQEBAQCAAQLQeAAQQgQrTYiA0UNByACQcgBaiABKAIEQQhqEOgMIAIoAsgBRQ0GIAJB6ABqIAJB3AFqKAIAIgE2AgAgAkHgAGogAkHUAWopAgAiFTcDACACIAIpAswBIhY3A1ggAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIANB4ABBCBD4OgwLC0EIIQQLQTBBCBCtNiIDRQ0MIAJByAFqIAEgBGooAgBBCGoQ6AwgAigCyAFFDQMgAkGgAWogAkHcAWooAgAiATYCACACQZgBaiACQdQBaikCACIVNwMAIAIgAikCzAEiFjcDkAEgAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIANBMEEIEPg6DAkLIAJByAFqIQsgASgCBEEIaiIDIAEoAghBAnRqIQQjAEEwayIBJAAgAUGTgICAeDYCBCABIAQ2AiggASADNgIkIAEgAUEEajYCLCABQRhqIQwjAEHQAGsiAyQAIANBCGoiDiABQSRqIgcQxhgCQCADKAIIQQFGBEAgA0HEAGoiCUEEQQBBCEEwEKAYIAMoAkghBCADKAJEQQFGDQwgAygCTCIIIANBEGoiDUEw/AoAACADQcwAaiIPQQE2AgAgAyAINgJIIAMgBDYCRCANIAdBCGooAgA2AgAgAyAHKQIANwMIIwBBQGoiCCQAIAhBCGogDhDGGCAIKAIIQQFGBEAgCEEQaiENIAkoAggiBEEwbCEHA0AgCSgCACAERgRAIAkgBEEBQQhBMBDcKAsgCSgCBCAHaiANQTD8CgAAIAkgBEEBaiIENgIIIAhBCGogDhDGGCAHQTBqIQcgCCgCCA0ACwsgCEFAayQAIAxBCGogDygCADYCACAMIAMpAkQ3AgAMAQsgDEEANgIIIAxCgICAgIABNwIACyADQdAAaiQAAkAgASgCBEGTgICAeEcEQCALIAEpAgQ3AgAgC0EQaiABQRRqKAIANgIAIAtBCGogAUEMaikCADcCACABKAIgIgQEQCABKAIcIQMDQCADQShqKAIAIgcEQCADIAcRAwALIANBMGohAyAEQQFrIgQNAAsLIAFBGGpBCEEwEOAeDAELIAsgASkCGDcCBCALQZOAgIB4NgIAIAtBDGogAUEgaigCADYCAAsgAUEwaiQAIAJBmAFqIgEgAkHUAWooAgA2AgAgAiACKQLMATcDkAEgAigCyAEiA0GTgICAeEcEQCACKALYASEFIAAgAikDkAE3AgggACAFNgIUIAAgAzYCBCAAQQE2AgAgAEEQaiABKAIANgIADAkLIAJBIGogASgCADYCACACIAIpA5ABNwMYDAYLQQAhBCACQQA2AiAgAkKAgICAgAE3AxhBCCEDQQEhFAwECyACQcgBaiELIAEoAgRBCGoiAyABKAIIQQN0aiEEIwBBMGsiASQAIAFBk4CAgHg2AgQgASAENgIoIAEgAzYCJCABIAFBBGo2AiwgAUEYaiEMIwBB0ABrIgMkACADQQhqIg4gAUEkaiIHEI0WAkAgAygCCEEBRgRAIANBxABqIglBBEEAQQhBMBCgGCADKAJIIQQgAygCREEBRg0KIAMoAkwiCCADQRBqIg1BMPwKAAAgA0HMAGoiD0EBNgIAIAMgCDYCSCADIAQ2AkQgDSAHQQhqKAIANgIAIAMgBykCADcDCCMAQUBqIggkACAIQQhqIA4QjRYgCCgCCEEBRgRAIAhBEGohDSAJKAIIIgRBMGwhBwNAIAkoAgAgBEYEQCAJIARBAUEIQTAQ3CgLIAkoAgQgB2ogDUEw/AoAACAJIARBAWoiBDYCCCAIQQhqIA4QjRYgB0EwaiEHIAgoAggNAAsLIAhBQGskACAMQQhqIA8oAgA2AgAgDCADKQJENwIADAELIAxBADYCCCAMQoCAgICAATcCAAsgA0HQAGokAAJAIAEoAgRBk4CAgHhHBEAgCyABKQIENwIAIAtBEGogAUEUaigCADYCACALQQhqIAFBDGopAgA3AgAgASgCICIEBEAgASgCHCEDA0AgA0EoaigCACIHBEAgAyAHEQMACyADQTBqIQMgBEEBayIEDQALCyABQRhqQQhBMBDgHgwBCyALIAEpAhg3AgQgC0GTgICAeDYCACALQQxqIAFBIGooAgA2AgALIAFBMGokACACQZgBaiIBIAJB1AFqKAIANgIAIAIgAikCzAE3A5ABIAIoAsgBIgNBk4CAgHhHBEAgAigC2AEhBSAAIAIpA5ABNwIIIAAgBTYCFCAAIAM2AgQgAEEBNgIAIABBEGogASgCADYCAAwHCyACQSBqIAEoAgA2AgAgAiACKQOQATcDGAwECyACQZQBaiIEIAJB0AFqQTD8CgAAIAMgBEEw/AoAAEEBIQQgAkEBNgIgIAIgAzYCHCACQQE2AhgMAgsgAkHcAGoiBCACQdABakEw/AoAACACQShqIgcgBEEw/AoAACACQcgBaiABKAIIQQhqEOgMIAIoAsgBQQFGBEAgAkGgAWogAkHcAWooAgAiATYCACACQZgBaiACQdQBaikCACIVNwMAIAIgAikCzAEiFjcDkAEgAEEUaiABNgIAIABBDGogFTcCACAAIBY3AgQgAEEBNgIAIAIoAlAiAARAIAcgABEDAAsgA0HgAEEIEPg6DAULIAJBlAFqIgEgAkHQAWpBMPwKAAAgA0EwaiABQTD8CgAAIAMgBEEw/AoAACACQQI2AiAgAiADNgIcIAJBAjYCGAwCC0EIQeAAEKM9AAsgB0EiRwRAQgAgB0EnRw0CGkIEQgAgAS0AARshFkIADAILIAJByAFqIAEoAggQsQEgAigCyAFBAUYEQCACQaABaiACQdwBaigCACIBNgIAIAJBmAFqIAJB1AFqKQIAIhU3AwAgAiACKQLMASIWNwOQASAAQRRqIAE2AgAgAEEMaiAVNwIAIAAgFjcCBCAAQQE2AgAgFEUEQANAIANBKGooAgAiAARAIAMgABEDAAsgA0EwaiEDIARBAWsiBA0ACyACKAIMIQYLIAJBGGpBCEEwEOAeDAMLIAJBlAFqIgEgAkHQAWpBMPwKAAAgAkHYAGogAUEw/AoAAEIBDAELQgALNwPIASACQdABaiACQdgAakEw/AoAACMAQTBrIgMkACADIAJBGGoiASgCADYCKCADIAEoAgQiBDYCJCADIAQ2AiAgAyAEIAEoAghBMGxqNgIsIwBBIGsiByQAIAdBFGogA0EgaiIIKAIMIAgoAgRrQTBuQQBBBEEEEKAYIAcoAhghASAHKAIUQQFGBEAgASAHKAIcQazIhwEQ/S8ACyAHQRBqIhFBADYCACAHIAcoAhw2AgwgByABNgIIIwBBIGsiASQAIAgoAgwgCCgCBGtBMG4iCyAHQQhqIgkoAgAgCSgCCCIEa0sEQCAJIAQgC0EEQQQQ3CggCSgCCCEECyACQZABaiELIAJByAFqIQ8gA0EQaiEMIAkoAgQhDiABQQhqIAhBCGopAgA3AwAgASAIKQIANwMAIAEgDjYCHCABIAQ2AhggASAJQQhqNgIUIAFBFGohCCMAQTBrIg4kAAJAAkAgASgCBCIJIAEoAgwiEkYEQCAIKAIEIQQMAQsgCCgCCCAIKAIEIgRBAnRqIQ0DQCAOIAlBMPwKAAAgASAJQTBqIgk2AgRBMEEIEK02IhBFDQYgECAOQTD8CgAAIAggBEEBaiIENgIEIA0gEDYCACANQQRqIQ0gCSASRw0ACwsgCCgCACAENgIAIwBBEGsiCSQAIAEoAgwiDSABKAIEIghrQTBuIQQgCCANRwRAA0AgCEEoaigCACINBEAgCCANEQMACyAIQTBqIQggBEEBayIEDQALCyAJIAEoAgA2AgwgCSABKAIINgIIIAlBCGpBCEEwEOAeIAlBEGokACAOQTBqJAAMAAsgAUEgaiQAIAxBCGogESgCADYCACAMIAcpAgg3AgAgB0EgaiQAIANBCGogDEG854cBEJghIAMoAgwhBCADKAIIIQcgDCAFIAoQvw8CQAJAIAMoAhBBgICAgHhGBEAgAygCFCEFQQAhCiAPKAIAQQFGBEBBMEEIEK02IgpFDQcgCiAPQQhqQTD8CgAAC0EYQQQQrTYiAUUNASABIAo2AhQgASAHNgIMIAFBgICAgHg2AgAgCyABNgI0IAtB9Rw2AjAgCyAKNgIsIAsgBzYCKCALQgA3AxggC0IANwIMIAsgBTYCCCALQQA2AgAgASAENgIQIAsgBK03AyAgA0EwaiQADAILIANBKGogA0EYaikCADcDACADIAMpAhA3AyBBzNWHAUErIANBIGpB+NWHAUHA1ocBENUeAAtBBEEYEKM9AAsgAigCkAFBAUYEQCACQThqIAJBpAFqKAIAIgE2AgAgAkEwaiACQZwBaikCACIVNwMAIAIgAikClAEiFjcDKCAAQRRqIAE2AgAgAEEMaiAVNwIAIAAgFjcCBCAAQQE2AgAgBkGAgICAeEYNAiACQQxqQQFBARDgHgwCCyAAIAIpA7ABNwMgIAJBNGogAkGgAWopAwAiFTcCACAAQShqIAJBuAFqKQMANwMAIABBMGogAkHAAWopAwA3AwAgAiACKQOYASIXNwIsIABBEGogFTcCACAAIBc3AgggACAWNwMYIABBADYCACAGQYCAgIB4Rg0BIAJBDGpBAUEBEOAeDAELIAZBgICAgHhGDQAgAkEMakEBQQEQ4B4LIAJBgAJqJAAPCyAEIAMoAkxB3OyHARD9LwALQQhBMBCjPQAL8R4CA38BfiMAQZACayIDJAAgA0HsAWogASACEJMOIAMoAvABIQQCQCADKALsASIFQYqAgIB4RwRAIAAgAykC9AE3AgggAEEgaiADQYwCaigCADYCACAAQRhqIANBhAJqKQIANwIAIABBEGogA0H8AWopAgA3AgAgACAENgIEIAAgBTYCAAwBCyADQewBaiABQX8gAiAEaiIBIAEgBEkbELQGIANBEGoiASADQfgBaikCADcDACADIAMpAvABNwMIIAMoAuwBIgJBioCAgHhHBEAgACADKQKAAjcCFCAAQRxqIANBiAJqKQIANwIAIABBDGogASkDADcCACAAIAMpAwg3AgQgACACNgIADAELIANBIGogASkDADcDACADIAMpAwg3AxggA0HsAWogA0EYakEEEN0QIAMoAvQBIQIgAygC8AEhAQJAIAACfiADKALsASIEQYqAgIB4RwRAIANBqAFqIANBiAJqKQIANwMAIAMgAykCgAI3A6ABIAMpAvgBDAELIAFBAXFFDQECQCACQQdxBEAgAyACNgKIAiADQQM2AoQCIANBsOT+ADYCgAIgA0GAgICAeDYC/AEgA0IENwL0ASADQoSAgIAINwLsAQwBC0F/IAJBCGoiASABIAJJGyIEIAMoAhgiASgCBE0EQCABIAEoAhRBCGoiBDYCFCABKAIIKAIIIARPBEAgA0GKgICAeDYC7AEMAgsgA0GIgICAeDYC7AEMAQsgA0HsAWogAiAEEL8vCyADQQY2ArABIANBtub+ADYCrAEgA0GAgICAeDYCqAEgAyACNgKkASADQQE2AqABIANByAFqIANB7AFqIANBoAFqEIEUIAMoAsgBIgRBioCAgHhGDQEgA0GoAWogA0HkAWopAgA3AwAgAyADKQLcATcDoAEgAygC0AEhAiADKALMASEBIAMpAtQBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA6ABNwIUIABBHGogA0GoAWopAwA3AgAMAQsgAyADKQMgNwIwIAMgAykDGDcCKCADQewBaiADQShqQQYQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAIoIgQgAhCTDiADKALwASEBAkAgAygC7AEiBUGKgICAeEcEQCADQegBaiADQYwCaigCADYCACADQeABaiADQYQCaikCADcCACADQdgBaiADQfwBaikCADcCACADIAMpAvQBNwLQASADIAE2AswBIAMgBTYCyAEMAQsgA0HsAWogBEF/IAEgAmoiBCABIARLGxDLDyADKALsASIBQYqAgIB4RwRAIANB3AFqIANBgAJqKQIANwIAIANB5AFqIANBiAJqKQIANwIAIAMgAykC+AE3AtQBIAMgAykC8AE3AswBCyADIAE2AsgBCyADQQU2AvwBIANBvOb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQIwNwJAIAMgAykCKDcCOCADQewBaiADQThqQQgQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAI4IgQgAhCTDiADKALwASEBAkAgAygC7AEiBUGKgICAeEcEQCADQegBaiADQYwCaigCADYCACADQeABaiADQYQCaikCADcCACADQdgBaiADQfwBaikCADcCACADIAMpAvQBNwLQASADIAE2AswBIAMgBTYCyAEMAQsgA0HsAWogBEF/IAEgAmoiBCABIARLGxDLDyADKALsASIBQYqAgIB4RwRAIANB3AFqIANBgAJqKQIANwIAIANB5AFqIANBiAJqKQIANwIAIAMgAykC+AE3AtQBIAMgAykC8AE3AswBCyADIAE2AsgBCyADQQc2AvwBIANBweb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQJANwJQIAMgAykCODcCSCADQewBaiADQcgAakEKEN0QIAMoAvQBIQIgAygC8AEhAQJAIAACfiADKALsASIEQYqAgIB4RwRAIANB0AFqIANBiAJqKQIANwMAIAMgAykCgAI3A8gBIAMpAvgBDAELIAFBAXFFDQEgA0HsAWogAygCSCIEIAIQkw4gAygC8AEhAQJAIAMoAuwBIgVBioCAgHhHBEAgA0HoAWogA0GMAmooAgA2AgAgA0HgAWogA0GEAmopAgA3AgAgA0HYAWogA0H8AWopAgA3AgAgAyADKQL0ATcC0AEgAyABNgLMASADIAU2AsgBDAELIANB7AFqIARBfyABIAJqIgQgASAESxsQtAYgA0HgAGoiASADQfgBaikCADcDACADIAMpAvABNwNYIAMoAuwBIgRBioCAgHhHBEAgA0HkAWogA0GIAmopAgA3AgAgA0HUAWogASkDADcCACADIAMpAoACNwLcASADIAMpA1g3AswBIAMgBDYCyAEMAQsgA0HwAGogASkDADcDACADIAMpA1g3A2ggA0HsAWogA0HoAGpBBBDdECADKAL0ASEBIAMoAvABIQQCQAJ+IAMoAuwBIgVBioCAgHhHBEAgA0GQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDiAEgAykC+AEMAQsgBEEBcUUNAQJAIAFBAWoiBEF/IAQbIgUgAygCaCIEKAIETQRAIAQgBCgCFEEBaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgLsAQwCCyADQYiAgIB4NgLsAQwBCyADQewBaiABIAUQvy8LIANBBTYCmAEgA0Gr5v4ANgKUASADQYCAgIB4NgKQASADIAE2AowBIANBATYCiAEgA0HIAWogA0HsAWogA0GIAWoQgRQgAygCyAEiBUGKgICAeEYNASADQZABaiADQeQBaikCADcDACADIAMpAtwBNwOIASADKALQASEBIAMoAswBIQQgAykC1AELIQYgA0HkAWogA0GQAWopAwA3AgAgAyAGNwLUASADIAE2AtABIAMgBDYCzAEgAyAFNgLIASADIAMpA4gBNwLcAQwBCyADIAMpA3A3AoABIAMgAykDaDcCeCADQewBaiADQfgAakEGEN0QIAMoAvQBIQEgAygC8AEhBAJAAn4gAygC7AEiBUGKgICAeEcEQCADQZABaiADQYgCaikCADcDACADIAMpAoACNwOIASADKQL4AQwBCyAEQQFxRQ0BAkAgAUEBaiIEQX8gBBsiBSADKAJ4IgQoAgRNBEAgBCAEKAIUQQFqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2AuwBDAILIANBiICAgHg2AuwBDAELIANB7AFqIAEgBRC/LwsgA0EGNgKYASADQbDm/gA2ApQBIANBgICAgHg2ApABIAMgATYCjAEgA0EBNgKIASADQcgBaiADQewBaiADQYgBahCBFCADKALIASIFQYqAgIB4Rg0BIANBkAFqIANB5AFqKQIANwMAIAMgAykC3AE3A4gBIAMoAtABIQEgAygCzAEhBCADKQLUAQshBiADQeQBaiADQZABaikDADcCACADIAY3AtQBIAMgATYC0AEgAyAENgLMASADIAU2AsgBIAMgAykDiAE3AtwBDAELIAMoAngiASABKAIMQQFrNgIMIANBioCAgHg2AsgBCyADQQs2AvwBIANByOb+ADYC+AEgA0GAgICAeDYC9AEgAyACNgLwASADQQE2AuwBIANBoAFqIANByAFqIANB7AFqEIEUIAMoAqABIgRBioCAgHhGDQEgA0HQAWogA0G8AWopAgA3AwAgAyADKQK0ATcDyAEgAygCqAEhAiADKAKkASEBIAMpAqwBCzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA8gBNwIUIABBHGogA0HQAWopAwA3AgAMAQsgAyADKQJQNwKQASADIAMpAkg3AogBIANB7AFqIANBiAFqQQwQ3RAgAygC9AEhAiADKALwASEBAkAgAAJ+IAMoAuwBIgRBioCAgHhHBEAgA0HQAWogA0GIAmopAgA3AwAgAyADKQKAAjcDyAEgAykC+AEMAQsgAUEBcUUNASADQewBaiADKAKIASIEIAIQkw4gAygC8AEhAQJAIAMoAuwBIgVBioCAgHhHBEAgA0HoAWogA0GMAmooAgA2AgAgA0HgAWogA0GEAmopAgA3AgAgA0HYAWogA0H8AWopAgA3AgAgAyADKQL0ATcC0AEgAyABNgLMASADIAU2AsgBDAELIANB7AFqIARBfyABIAJqIgQgASAESxsQhg4gAygC7AEiAUGKgICAeEcEQCADQdwBaiADQYACaikCADcCACADQeQBaiADQYgCaikCADcCACADIAMpAvgBNwLUASADIAMpAvABNwLMAQsgAyABNgLIAQsgA0EUNgL8ASADQdPm/gA2AvgBIANBgICAgHg2AvQBIAMgAjYC8AEgA0EBNgLsASADQaABaiADQcgBaiADQewBahCBFCADKAKgASIEQYqAgIB4Rg0BIANB0AFqIANBvAFqKQIANwMAIAMgAykCtAE3A8gBIAMoAqgBIQIgAygCpAEhASADKQKsAQs3AgwgACACNgIIIAAgATYCBCAAIAQ2AgAgACADKQPIATcCFCAAQRxqIANB0AFqKQMANwIADAELIAMoAogBIgEgASgCDEEBazYCDCAAQYqAgIB4NgIACyADQZACaiQAC/8bAhZ/AX4jAEEwayIJJAAgAUH/AXEhEyAAKAIcIgQsAAQiFEEESiEVA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCJCIFQYUCTQRAIAQoAiAiCkEBdCEGIApBhgJrIQwDQCAEKAJQIAUgBCgCECICamshBQJAAkACQAJAAkACQAJAAkACQCAMIAQoAiBqIAJNBEAgBiAEKAIYIgJLDQEgCkEASA0CIAoEQCAEKAIUIgIgAiAKaiAK/AoAAAsgBCAELwEMIgIgCkH//wNxIgNrIgdBACACIAdPGzsBDCACIANNBEAgBEEAOwE0CyAEIAQoAhAgCmsiAjYCECAEIAQoAjwgCms2AjwgBCACIAQoAoABIgMgAiADSRs2AoABIAQQlBYgBSAKaiEFCyAAKAIERQRAIAAoAhwhBAwMCyAFQQFNDQIgACAAKAIcIgIoAiQgAigCEGogBRDMEyEDIAAoAhwiAiADIAIoAiRqIgM2AiQgAyACKAKAASIDakEDSQ0IIAIoAhAiByADayEFIAIvATZBgAhNBEAgAyAHRg0IIAVBAWshAyACLQAGQQFGBEAgAiADENkZGgwJCyACKAIYIgcgA0kNBCAHIANrIgdBA00NBSACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIg8vAQAiDiADQf//A3FGDQggAigCIEEBayADcSIHIAIoAiwiEE8NBiACKAIoIAdBAXRqIA47AQAgDyADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0HE//wAEMMhAAsgBUEBaiIHIANJDQYgByADQdT//AAQwyEACyAGIAJBhP/8ABCwOwALIAlBADYCKCAJQQE2AhwgCUHc+vwANgIYIAlCBDcCICAJQRhqQZT//AAQ7ywACyAJQQA2AiggCUEBNgIcIAlBrP/8ADYCGCAJQgQ3AiAgCUEYakG0//wAEO8sAAsgAyAHQeT7/AAQrzsAC0EEIAdB9Pv8ABCwOwALIAcgEEGE/PwAEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAHai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiRBAUZrIgNFDQACQCACLQAGQQFGBEAgAiAFIAMQ4BMMAQsgAiAFIAMQ6xQLIAIgAigCgAEgA2s2AoABCyAAKAIcIgQoAiQiBUGFAksNAiAAKAIEDQALDAELAkAgFEEFTgRAIApB//8DcSIDDQELIAQoAhAhAwwCCwJ/AkAgBSADQQRqTQ0AAkAgA0EDTQRAQQEhAiADQQFHDQEgCAwDCyAIIApqIQUgCEEBakH//wNxIgIgC0H//wNxIgNJBEAgBUH//wNxIANNDQIgBSALa0H//wNxIQIgBC0ABkEBRgRAIAQgAyACEOATDAMLIAQgAyACEOsUDAILIAMgBUH//wNxTwRAIAsgCGtB//8DcSEDIAQtAAZBAUYEQCAEIAIgAxDgEwwDCyAEIAIgAxDrFAwCCyAKQQFrQf//A3EhAyAELQAGQQFGBEAgBCACIAMQ4BMMAgsgBCACIAMQ6xQMAQsgCEEBakH//wNxIgIgC0H//wNxIgNJDQAgAyAIIApqQf//A3FPBEAgCyAIa0H//wNxIQMgBC0ABkEBRgRAIAQgAiADEOATDAILIAQgAiADEOsUDAELIAQtAAZBAUYEQCAEIAJB//8DEOATDAELIAQgAkH//wMQ6xQLIAohAiAICyEDIA0hDwwJCyAEKAIQIgMgBCgCUEGGAmtLBEAgCUEANgIoIAlBATYCHCAJQYCA/QA2AhggCUIENwIgIAlBGGpBiID9ABDvLAALIAQoAiQiAkGGAk8NACATRQRAQQAhBAwLCyACRQRAIARBAiADIANBAk8bNgKAASABQf8BcUEERg0DIAAoAhwoAkgEQEEAIQQgAEEAEJIBIAAoAhBFDQwLQQEhBAwLC0EAIQUgAkEDTQ0BCyAEKAIYIgIgA0kNAiACIANrIgJBA00NAyAEKAIwIAQoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgovAQAiBSADQf//A3FGDQAgBCgCIEEBayADcSICIAQoAiwiBk8NBCAEKAIoIAJBAXRqIAU7AQAgCiADOwEAIAAoAhwiBCgCECEDC0EBIQJBACEKIAVFDQQgA60gBa19IhhCAFcNBEEAIQ8gGCAEKAIgQYYCa61VDQUgCUEQaiAEIAUQkwcgCSgCECECIAAoAhwgCS8BFCIPOwEMAkAgACgCHCIGKAIkQQEgAkEBIAJB/P8DcRsiAiAPIANB//8DcSIHTxsiBUH//wNxIgxBBGpNDQAgBUEBayEOAkACQCAMQQNNBEAgB0H//wNGDQMgDkH//wNxIgxFDQMgA0EBakH//wNxIQIgAyAFakH//wNxIAdLDQIgBi0ABkEBRw0BIAYgAkEAEOATDAMLIAdB//8DRg0IIANBAWpB//8DcSEMIAcgAyAFakH//wNxTwRAIAYtAAZBAUYEQCAGIAxBABDgEwwKCyAGIAxBABDrFAwJCyAOQf//A3EhBSAGLQAGQQFGBEAgBiAMIAUQ4BMMCQsgBiAMIAUQ6xQMCAsgBiACQQAQ6xQMAQsgBi0ABkEBRgRAIAYgAiAMEOATDAELIAYgAiAMEOsUCyAFIQIMBQsgAEEBEJIBQQNBAiAAKAIQGyEEDAcLIAMgAkHk+/wAEK87AAtBBCACQfT7/AAQsDsACyACIAZBhPz8ABDDIQALQQAhDwsgFUUNAQtBACEKIAAoAhwiBSgCJEGGAk0NACACIANqQf//A3EiBiAFKAJQQYYCa08NACAFIAY2AhACQAJAIAAoAhwiBCgCGCIIIAQoAhAiC08EQCAIIAtrIghBA0sEQAJAIAQoAjAgBCgCFCALaigAAEGx893xeWxBD3ZB/v8HcWoiDS8BACIIIAtB//8DcUcEQCAEKAIgQQFrIAtxIgogBCgCLCIFTw0BIAQoAiggCkEBdGogCDsBACANIAs7AQAgACgCHCIEKAIQIQsLQQAhDQJAAkAgCEUNACALrSAIrX0iGEIAVw0AIBggBCgCIEGGAmutVQ0AIAlBCGogBCAIEJMHIAkoAgghCiAAKAIcIAkvAQwiDTsBDCAAKAIcIQQgDSALQf//A3EiEU8NACAKQf//A3FBA0sNAQsgCyEIQQEhCgwFCyACQf//A3EiBUECSSAFIA1BAWpB//8DcUtyDQMgBSALQQFqIhZB//8DcUsNAyANIAVrQQFqIgYgBCgCGCIITQRAIAggC0H//wNxIgcgBWtBAWoiDE8EQCAGIAhHBEAgCCAMRwRAIAQoAhQiBSAGai0AACAFIAxqLQAARw0HIAggDU8EQCAHIAhNBEAgBSAHaiEOIAUgDWohEEEAIRIgESAEKAIgQYYCa0H//wNxayIIQQAgCCARTRtB//8DcSERIAshCCAKIQcgDSEMIAIhBgNAAkACQAJAIAUgEEcEQCAFIA5GDQIgEEEBayIQLQAAIA5BAWsiDi0AAEcNAgwBCyAFIA5GIAUhECAFIQ5FDQELIAZB//8DcUUgCEH//wNxIBFNciAHQf//A3FB/wFLcg0AIAxB//8DcUEBSw0BCyASRSAGQf//A3FBAUtyDQsgFiELIAchCiAMIQ0gBiECDAwLIBJBAWshEiAGQQFrIQYgB0EBaiEHIAxBAWshDCAIQQFrIQgMAAsACyAHIAhB1Pv8ABCwOwALIA0gCEHE+/wAELA7AAtBAEEAQbT7/AAQwyEAC0EAQQBBpPv8ABDDIQALIAwgCEGU+/wAEK87AAsgBiAIQYT7/AAQrzsACyAKIAVBhPz8ABDDIQALQQQgCEH0+/wAELA7AAsgCyAIQeT7/AAQrzsACyALIQgLIAQgA0H//wNxNgIQCyAAKAIcIQYCQAJAAkACQAJAAkACQAJAAkAgAkH//wNxIgVBBE8EQCAGKAJEIgcgBigCSCICSQ0BIAcgAmsiB0ECTQ0CIAYoAkAgAmoiByAFQQNrIgI6AAIgByADIA9rIgNBCHY6AAEgByADOgAAIAYgBigCSEEDajYCSCAGQf8BIAYtADpBAWoiByAHQf8BTxs6ADogA0H//wNxQQFrIgMgBigCIEGGAmtPDQMgAxDKKkH/AXFBHk8NAyACQYACTw0EIAYgAkHk/PwAai0AAEECdGpBrAlqIgIgAi8BAEEBajsBACADEMoqQf8BcSICQT1PDQUgBiAGKAIkIAVrNgIkIAYgAkECdGoiAiACLwGkE0EBajsBpBMgBigCSCAGKAJEIAAoAhwiBiAGKAIQIAVqNgIQQQNrRw0JDAgLIAYoAhgiByAGKAIQIgNJDQUgByADayIHIAVJDQYgAkH//wNxRQ0IIAYoAhQgA2ohBCAGQaQBaiEHIAZBQGshDEEAIQMgBSECA0AgDCAHIAQtAAAQliMhDyAGIAYoAiRBAWs2AiQgAyAPciEDIARBAWohBCACQQFrIgINAAsgACgCHCICIAIoAhAgBWo2AhAgA0EBcQ0HDAgLIAIgB0GU/PwAEK87AAtBAyAHQaT8/AAQsDsACyAJQQA2AiggCUEBNgIcIAlBzPz8ADYCGCAJQgQ3AiAgCUEYakHU/PwAEO8sAAsgAkGAAkHk/vwAEMMhAAsgAkE9QfT+/AAQwyEACyADIAdB5Pr8ABCvOwALIAUgB0H0+vwAELA7AAtBACEEIABBABCSASAAKAIQRQ0BCyAAKAIcIQQMAQsLIAlBMGokACAEC80XAQV/IwBB0ABrIgMkAAJAAkACQAJAAkACQEEAQcAAENE0BEAgA0LAADcCECADQsAANwIIAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AACIFQQFrDigBAgICAgICAgICAgICAgICAgICAwQFBgMFBgcICQoLCQwOAgICAgcJAAtBAEHAABDRNEUNESAAIAMpAgg3AgAgAELAADcCGCAAQsAANwIQIABBCGogA0EQaikCADcCAAwQC0HAACEBIAJBA3YgAkEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0QIAIEQCACQcAAEK02IgFFDRILIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwPC0EBIQQCQAJAAkACQAJAAkACQAJAIAVBA2sOJAYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAcLQQQhBAwGC0EIIQQMBQsgAS0AAUECdEHQl4cBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtBvI+HARCyOwALQQIhBAsgAiAEbCICQT9xIgEEQCACIAIgAWtBQGsiAksNEgtBwAAhASACQcAAENE0RQ0PIAIEQCACQcAAEK02IgFFDRELIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwOCyACQQJ0QQRqIgFBPHEiBARAIAEgASAEa0FAayIBSw0RCyABQcAAENE0RQ0OAn8gAUUEQCADQsAANwIYIANCwAA3AiAgA0EYakHAABDoGSADKAIgIQQgAygCJAwBCyABQcAAEK02IgRFDRIgA0EANgIkIAMgBDYCICADIAE2AhwgA0HAADYCGEEACyAEakEANgAAIAMgAygCJEEEajYCJCADQTBqIANBIGopAgA3AwAgAyADKQIYNwMoAkAgAkE/cSIBRQRAIAIhAQwBCyACIAFrQUBrIgEgAkkNEQtBwAAhAiABQcAAENE0RQ0OIAEEQCABQcAAEK02IgJFDRILIAAgAykDKDcCACAAQQA2AhwgACACNgIYIAAgATYCFCAAQcAANgIQIABBCGogA0EwaikDADcCAAwJCyABKAIEIAJsIgJBP3EiAQRAIAIgAiABa0FAayICSw0QC0HAACEBIAJBwAAQ0TRFDQ0gAgRAIAJBwAAQrTYiAUUNDwsgACADKQIINwIQIABBADYCDCAAIAE2AgggACACNgIEIABBwAA2AgAgAEEYaiADQRBqKQIANwIADAwLIAJBA3RBCGoiAUE4cSIEBEAgASABIARrQUBrIgFLDQ8LIAFBwAAQ0TRFDQwCfyABRQRAIANCwAA3AhggA0LAADcCICADQRhqQcAAEOgZIAMoAiAhBCADKAIkDAELIAFBwAAQrTYiBEUNECADQQA2AiQgAyAENgIgIAMgATYCHCADQcAANgIYQQALIARqQgA3AAAgAyADKAIkQQhqNgIkIANBMGogA0EgaikCADcDACADIAMpAhg3AygCQCACQT9xIgFFBEAgAiEBDAELIAIgAWtBQGsiASACSQ0PC0HAACECIAFBwAAQ0TRFDQwgAQRAIAFBwAAQrTYiAkUNEAsgACADKQMoNwIAIABBADYCHCAAIAI2AhggACABNgIUIABBwAA2AhAgAEEIaiADQTBqKQMANwIADAcLIAJBBHQiAkEwcSIBBEAgAiACIAFrQUBrIgJLDQ4LQcAAIQEgAkHAABDRNEUNCyACBEAgAkHAABCtNiIBRQ0NCyAAIAMpAgg3AhAgAEEANgIMIAAgATYCCCAAIAI2AgQgAEHAADYCACAAQRhqIANBEGopAgA3AgAMCgsgAkECdEEEaiICQTxxIgEEQCACIAIgAWtBQGsiAksNDQsgAkHAABDRNEUNCgJ/IAJFBEAgA0LAADcCKCADQsAANwIwIANBKGpBwAAQ6BkgAygCMCEBIAMoAjQMAQsgAkHAABCtNiIBRQ0MIANBADYCNCADIAE2AjAgAyACNgIsIANBwAA2AihBAAshAiABIAJqQQA2AAAgACADKQIoNwIAIAAgAykCCDcCECAAQRhqIANBEGopAgA3AgAgAyADKAI0QQRqNgI0IABBCGogA0EwaikCADcCAAwJCyACQQJ0IgQhAiAEQTxxIgEEQCAEIAFrQUBrIgIgBEkNDAtBwAAhBSACQcAAENE0RQ0JIAIEQCACQcAAEK02IgVFDQsLIAEEQCAEIAQgAWtBQGsiBEsNDAtBwAAhASAEQcAAENE0RQ0JIAQEQCAEQcAAEK02IgFFDQ4LIABBADYCHCAAIAE2AhggACAENgIUIABCgICAgIAINwIMIAAgBTYCCCAAIAI2AgQgAEHAADYCAAwEC0EAQcAAENE0RQ0IIAAgAykCCDcCACAAQsAANwIYIABCwAA3AhAgAEEIaiADQRBqKQIANwIADAcLIAJBA3RBCGoiAkE4cSIBBEAgAiACIAFrQUBrIgJLDQoLIAJBwAAQ0TRFDQcCfyACRQRAIANCwAA3AiggA0LAADcCMCADQShqQcAAEOgZIAMoAjAhASADKAI0DAELIAJBwAAQrTYiAUUNCSADQQA2AjQgAyABNgIwIAMgAjYCLCADQcAANgIoQQALIQIgASACakIANwAAIAAgAykCKDcCACAAIAMpAgg3AhAgAEEYaiADQRBqKQIANwIAIAMgAygCNEEIajYCNCAAQQhqIANBMGopAgA3AgAMBgsgAkEDdCIEIQIgBEE4cSIBBEAgBCABa0FAayICIARJDQkLQcAAIQUgAkHAABDRNEUNBiACBEAgAkHAABCtNiIFRQ0ICyABBEAgBCAEIAFrQUBrIgRLDQkLQcAAIQEgBEHAABDRNEUNBiAEBEAgBEHAABCtNiIBRQ0LCyAAQQA2AhwgACABNgIYIAAgBDYCFCAAQoCAgICACDcCDCAAIAU2AgggACACNgIEIABBwAA2AgAMAQsgAiEEIAJBP3EiBQRAIAIgBWtBQGsiBCACSQ0IC0HAACEFIARBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNCgsgAS0AAUUNAiADQTxqIQYjAEEQayIHJAACQAJAAkACQCACQQJ0IgFBP3EiAgRAIAEgASACa0FAayIBSw0BC0HAACECIAFBwAAQ0TRFDQEgAQRAIAFBwAAQrTYiAkUNAwsgBkEANgIMIAYgAjYCCCAGIAE2AgQgBkHAADYCACAHQRBqJAAMAwtB2IqHAUEjQfyKhwEQyyQAC0Gci4cBQSkgB0EPakHoi4cBQciLhwEQ1R4AC0HAACABEKM9AAsgAEEANgIMIAAgBTYCCCAAIAQ2AgQgAEHAADYCACAAIAMpAjw3AhAgAEEYaiADQcQAaikCADcCAAsgA0EIahDPLwwDC0EBIQQCQAJAAkACQAJAAkACQAJAIAEoAgQiAS0AAEECaw4lBwYAAQcGAAEGAAEBAAEAAQECBQUFBQUFBQUFBQUFBQUFAAEDBAULQQQhBAwGC0EIIQQMBQsgAS0AAUECdEHQl4cBaigCACEEDAQLQRAhBAwDC0EgIQQMAgtBrI+HARCyOwALQQIhBAsgAiAEbCICQT9xIgEEQCACIAIgAWtBQGsiAksNBgtBwAAhASACQcAAENE0RQ0DIAIEQCACQcAAEK02IgFFDQULIAAgAykCCDcCECAAQQA2AgwgACABNgIIIAAgAjYCBCAAQcAANgIAIABBGGogA0EQaikCADcCAAwCCyAAIAMpAgg3AhAgAEEANgIMIAAgBTYCCCAAIAQ2AgQgAEHAADYCACAAQRhqIANBEGopAgA3AgAMAQsMAQsgA0HQAGokAA8LQZyLhwFBKSADQc8AakHoi4cBQciLhwEQ1R4AC0HAACACEKM9AAtB2IqHAUEjQfyKhwEQyyQAC0HAACABEKM9AAtBwAAgBBCjPQAL/iACEX8BfiMAQYACayIFJAAgBSADNgJMIAUgAjYCSCAFIAM2ApQBIAUgAjYCkAEgBUGQAWoQ7hIhCyAFKAKQASEOIAUgBSgClAEiCDYCVCAFIA42AlACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAtBL0YgC0HcAEZyRQRAIAtBgIDEAEcNBCAERQ0FIAQoAghBAUcNASAEKAIUIQggBCgCDCIDDQJBACEDDAMLAkAgC0HcAEcNACABKAIYIgZFDQAgBkEAIAEoAhwoAhQRAAALIAUgCDYClAEgBSAONgKQASAFQZABaiIGEO4SIQcgBSgClAEhCSAFKAKQASEKIAdBL0YgB0HcAEZyDQwgAUGwh8QAQbeHxAAQgSZBByENIAVB0ABqEI0XIARFcg0KIwBBEGsiByQAIAcgBBC2ESAHKAIEIQkgBygCACEKIAdBLzYCDCAGIAogCSAHQQxqQQEQ9C4EfyAGQQE7ASQgBkEANgIcIAZBAToAGCAGQS82AhQgBkEANgIMIAYgCUEBayIJNgIgIAYgCTYCECAGIAk2AgggBiAKQQFqNgIEQS8FQYCAxAALNgIAIAdBEGokACAFKAKQAUGAgMQARwRAIAVB6ABqIAZBKPwKAAAgBS0AjQENDAJAAkACfwJAIAUoAngiCSAFKAJ0IgdJDQAgCSAFKAJwIgxLDQAgBSgCbCESIAVB+wBqIRMgBUH8AGohFANAIAUoAmwgB2ohDyATIAUtAIABIgpqLQAAIRACQAJAAkAgCSAHayIRQQdNBEAgByAJRg0BQQAhBgNAIAYgD2otAAAgEEYNBCARIAZBAWoiBkcNAAsMAQsgBUEoaiAQIA8gERCdEiAFKAIoQQFxDQEgBSgCeCEJCyAFIAk2AnQMAwsgBSgCLCEGIAUtAIABIQogBSgCcCEMIAUoAnQhBwsgBSAGIAdqQQFqIgc2AnQCQCAHIApJIAcgDEtyDQAgCkEFSQRAIAcgCmsiBiAFKAJsaiAKIBQgChDBLkUEQCAFKAJwIQwgBSgCdCEHDAILIBIgBSgChAEiB2ohCSAGIAdrDAQLIApBBEGEhsQAELA7AAsgBSgCeCIJIAdJDQEgCSAMTQ0ACwsgBS0AjQENDyAFQQE6AI0BAkAgBS0AjAFBAUYEQCAFKAKIASEHIAUoAoQBIQYMAQsgBSgCiAEiByAFKAKEASIGRg0QCyAFKAJsIAZqIQkgByAGawtBAkcNACAJLQAAQd8BcUHBAGtB/wFxQRlLDQAgCS0AAUE6Rg0BC0EAIQkCQAJAIAVBIGoiDCAEIgYtADQEfyAEKAIYIQkgBCgCFCEKIAQoAiwiByAEKAIoIgZJDQECQCAGRQ0AIAYgCU8EQCAGIAlHDQMMAQsgBiAKaiwAAEG/f0wNAgsCQCAHRQ0AIAcgCU8EQCAHIAlGDQEMAwsgByAKaiwAAEG/f0wNAgsgBiAKaiEJIAcgBmsFIAYLNgIEIAwgCTYCAAwBCyAKIAkgBiAHQdCXxAAQozYACyAFKAIgIgZFDQwgASAGIAYgBSgCJGoQgSYgBUHgAWogBEE9aikAADcDACAFIAQpADU3A9gBIAQtADQhFSABKAIIIQ0MDAsgASgCCCEEIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAEQQFqNgIIIAEgCSAJQQJqEIEmDAsLQfiHxAAQsjsACyAEKAIYIQMgBCgCFCEIDAELAkAgBCgCGCICIANNBEAgAiADRw0BDAILIAMgCGosAABBv39KDQELIAggAkEAIANByIjEABCjNgALIAEgCCADIAhqEIEmIABBADYCCCAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQIAAgBCkCNDcCNCAAQTxqIARBPGopAgA3AgAgAEHEAGogBEHEAGotAAA6AAAgACAEKAIwNgIwIAAgBCkCADcCACAAIAQpAiA3AiAgACAEKQIoNwIoIAAgBCgCHDYCHAwMCyAEDQELIAFBiInEAEGQicQAEIEmIAVBADoAkAEgBSABQQAgBUGQAWoiBEEHIAIgAxC/ASAEIAFBAEEEIAUoAgAgBSgCBBDOESAFKAKQASICQQJGDQEgBSkClAEhFiAFKAKcASEDIABBADoANCAAQQc2AjAgAEKHgICA8AA3AiggAEKEgICA8AA3AiAgAEEAOwEcIAAgAzYCDCAAIBY3AgQgACACNgIAIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAMCgsCQAJAAkACQCALQSNHBEAgC0E/Rg0BIAVByABqEI0XDQMgBCgCAEUNAiAEQQRqIQYMBwsgBUGQAWoiBiABQST8CgAAIAAgBiAEIAIgAxCPEAwNCwJ/IAQoAgBFBEAgBEEMaiAEKAIIDQEaIAQoAhghBiAEKAIUIQgMBAsgBEEEagsgBCgCFCEIKAIAIgZFBEBBACEGDAMLAkAgBCgCGCIHIAZNBEAgBiAHRg0EDAELIAYgCGosAABBv39KDQMLDA0LIAQoAggEQCAEQQxqIQYMBQsgBCgCGCEGIAQoAhQhCAwFCyABQYiJxABBkInEABCBJiAFQQA6AJABIAVBCGogAUEAIAVBkAFqIgRBByACIAMQvwEgBCABQQBBBCAFKAIIIAUoAgwQzhEgBSgCkAEiAkECRg0BIAUpApQBIRYgBSgCnAEhAyAAQQA6ADQgAEEHNgIwIABCh4CAgPAANwIoIABChICAgPAANwIgIABBADsBHCAAIAM2AgwgACAWNwIEIAAgAjYCACAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQDAoLIAEgCCAGIAhqEIEmIAVBkAFqIAFBACAEKAIgIgYgAiADEM4RIAUoApABIgJBAkcNAQsgBS0AlAEhAiAAQQI2AgAgACACOgAEDAYLIAUpApQBIRYgBSgCnAEhAyAAIAI2AgAgACADNgIMIAAgBjYCICAAIBY3AgQgAEEYaiABQQhqKAIANgIAIAAgASkCADcCECAAIAQpAjQ3AjQgAEE8aiAEQTxqKQIANwIAIABBxABqIARBxABqLQAAOgAAIAAgBCgCHDYCHCAAIAQpAiw3AiwgACAEKQIkNwIkDAcLIAQoAhQhCCAGKAIAIgZFBEBBACEGDAELAkAgBCgCGCIHIAZNBEAgBiAHRg0CDAELIAYgCGosAABBv39KDQELDAcLIAEgCCAGIAhqEIEmIAFBACAEKAIwIgYQrhsgBUEBOgCQASAFQRBqIAFBACAFQZABaiIIIAYgAiADEL8BIAUoAhQhAiAFKAIQIQMgCCABQST8CgAAIAAgCEEAIAQoAiAgBCgCJCAEKAIoIAQoAiwgBEE0aiAELwEcIAQvAR4gBiADIAIQ0QcMBQsgBUEAOgCQASAFQRhqIAFBACAFQZABaiIEIA0gC0HcAEYgC0EjayIGQRxNQQBBASAGdEGBoICAAXEbcgR/IAIFIAghAyAOCyADEL8BIAQgAUEAQQQgBSgCGCAFKAIcEM4RIAUoApABIgJBAkYEQCAFLQCUASECIABBAjYCACAAIAI6AAQMAwsgBSkClAEhFiAFKAKcASEDIAAgBSkD2AE3ADUgACAVOgA0IAAgDTYCMCAAIA02AiwgAEEHNgIoIABChICAgPAANwIgIABBADsBHCAAIAM2AgwgACAWNwIEIAAgAjYCACAAQRhqIAFBCGooAgA2AgAgACABKQIANwIQIABBPWogBUHgAWopAwA3AAAMBAtBiIjEABCyOwALAkAgB0HcAEcNACABKAIYIgJFDQAgAkEAIAEoAhwoAhQRAAALIAFBsIfEAEG3h8QAEIEmIAVBkAFqIgYgCiAJENcIIAUtAJQBIQQCfwJAAkACQAJ/AkACQCAFKAKQASIIQYGAgIB4Rg0AIAUgBSkAlQEiFjcD2AEgBSAFQZwBaigAADYA3wEgBSgCoAEhAiAFKAKkASEDIAVBwAFqIgcgBSgA2wE2AAAgBSAWPgC9ASAFIAQ6ALwBIAUgCDYCuAEgBUFAayAFQbgBahDcOyAFKAJERQ0DIAVB+AFqIAcoAgA2AgAgBSAFKQK4ATcD8AEgBiAFQfABahCaAyAFLQCRASEEIAUtAJABIgZBA0YNACAFQeoBaiAFQaIBai8BADsBACAFQeIBaiAFQZoBaikBADcBACAFIAUpAZIBNwHaASAFIAQ6ANkBIAUgBjoA2AEgBkUEQCAFKALgASAFKALkAUHsi8QAQQkQwS4NAgsgBUH4AGoiBCAFQegBaigCADYCACAFQfAAaiIIIAVB4AFqKQIANwMAIAUgBSkC2AE3A2hBASEGIAVBATYClAEgBUGQi8QANgKQASAFQgE3ApwBIAVB6QI2AvQBIAUgBUHwAWo2ApgBIAUgBUHoAGo2AvABIAEgBUGQAWoiBxDbOw0EIAVBoAFqIAQoAgA2AgAgBUGYAWogCCkDADcDACAFIAUpA2g3A5ABIAVBxwFqIAcQrh4gBS0AxwEMAgsgAEECNgIAIAAgBDoABAwGCyAFQdwBahCGMEEAIQZBAAshCCAFQeAAaiAFQdABaikAADcDACAFIAUpAMgBNwNYIAEoAgghBCAFIAhB/wFxQQBHOgBoIAZFDQIgBUE4aiABQQAgBUHoAGogAiADEM0NIAUoAjwhAyAFKAI4DAMLIAVBuAFqEIYwIAEoAgghBEEAIQggBUEAOgBoDAELQcyExABBKyAFQZABakG8hMQAQfiLxAAQ1R4ACyABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgBEEBajYCCCAFQTBqIAFBACAFQegAaiAEIAIgAxC/ASAFKAI0IQMgBSgCMAshCSAFLQBoRQRAIAVBkAFqIQIjAEEQayIIJAAgCEEIakEHIAQgASgCCCIHQdiHxAAQhyogASgCBCELIAgoAgwhBAJAIAgoAggiBkUNAAJAIAYgB08EQCAGIAdHDQEMAgsgBiALaiwAAEG/f0oNAQtB1prEAEEuQdiHxAAQnykACwJAIARFDQACQCAEIAdPBEAgBCAHRw0BDAILIAQgC2osAABBv39KDQELQYSbxABBLEHYh8QAEJ8pAAsgAiAENgIQIAIgBjYCDCACIAE2AgggAiAEIAtqNgIEIAIgBiALajYCACAIQRBqJAACQCACKAIMIgYgAigCECIESw0AIAIoAggiAigCCCIIIARJDQAgAiAGNgIIIAggBGshBwJAIAQgBkYEQCAEIAhGDQIMAQsgBCAIRg0BIAdFDQAgAigCBCIIIAZqIAQgCGogB/wKAAALIAIgBiAHajYCCAtBACEIQQchBAsgBUGQAWogAUEAQQQgCSADEM4RIAUoApABIgJBAkcNASAFLQCUASECIABBAjYCACAAIAI6AAQLIAEQ3jsMAQsgBSkClAEhFiAFKAKcASEDIAAgBSkDWDcANSAAIAg6ADQgACAENgIwIAAgBDYCLCAAQQc2AiggAEKEgICA8AA3AiAgAEEAOwEcIAAgAzYCDCAAIBY3AgQgACACNgIAIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgAEE9aiAFQeAAaikDADcAAAsgBUGAAmokAA8LIAggB0EAIAZBlJXEABCjNgAL7iQCCX8DfiMAQfADayIFJAACQAJAAkACQCABQShqIgggBBDzLSIHELgIDQAgBy0AACEGAn8gCC0AAEEiRgRAIAZBIkYEQCAHKAIIIQcLIAEoAjAMAQsgBkEiRgRAIAcoAgghBwsgCAsiBiAHELgIDQACQAJAAkACQAJAAkAgBi0AAEEUaw4HBQcAAQIDBAcLIActAABBFGsOBAUGBgUGCyAHLQAAQT1xQRRHDQUMBAsgBy0AAEEZa0H/AXFBAk8NBAwDCyAHLQAAQT1xQRhHDQMMAgsgBy0AAEE+cUEYRg0BDAILIActAABBPnFBFkcNAQsgAS0AQCEJAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBBDzLSIHEIY2RQRAQQQhBiAHLQAAQRtrDg0EAgMEAgUCAQICAgIEAgsgBCgCACIBIAEoAgAiB0EBajYCACAHQQBIDQsgACACIAMgCUEBcSABIAQoAgQQ8RsMFAsgBygCCBCGNg0ECyAFIAc2AjAgBUECNgLMAiAFQaTCzQA2AsgCIAVCATcC1AIgBUGnBDYCrAIgBSAFQagCajYC0AIgBSAFQTBqNgKoAiAAQQxqIAVByAJqEJkOIABBhICAgHg2AgAgAEEBNgIIDBILQQghBgsgAkEBaiECIAYgB2ohCkECQQEgCUEBcRsgA2ohByAILQAAIgZBG2sOBAMJBAUCCyMAQSBrIgEkACABQQhqIAQoAgAgBCgCBCIEKAIIQQFrQXhxakEIaiAEKAIQEQAAIAFBEGogASgCCCIIIAEoAgwoAgwRAAACQCAIBEAgASkDEEK+uaqJmdKNmuAAhSABKQMYQsWRgbqRwsPNNIWEUA0BC0HI+4UBQQxB1PuFARDLJAALIAFBIGokACAFIAI7ARQgBSADIAlB/wFxajsBFiAFQQhqIAdBBGoQwzQgBSgCCCECIAUoAgwhAyAFIAgQ3DsgBUHIAmoiASACIAIgA0ECdGogBSgCACICIAIgBSgCBEEDdGoQySIgBSAFQRRqNgLgAiAFQagCaiEDIwBB0ABrIgIkACACQQg2AgggAkHIAGogAUEYaigCADYCACACQUBrIAFBEGopAgA3AwAgAkE4aiABQQhqKQIANwMAIAIgASkCADcDMCACIAJBCGo2AkwgAkEkaiEGIwBBgAFrIgEkACABQRhqIgkgAkEwaiIEEJ8dAkACQAJAIAEoAhhBhICAgHhHBEAgAUHgAGoiCkEEQQBBBEHIABCgGCABKAJkIQcgASgCYEEBRg0CIAEoAmgiCyAJQcgA/AoAACABQRRqIgxBATYCACABIAs2AhAgASAHNgIMIAFB+ABqIARBGGopAgA3AwAgAUHwAGogBEEQaikCADcDACABQegAaiAEQQhqKQIANwMAIAEgBCkCADcDYCMAQdAAayIEJAAgBEEIaiAKEJ8dIAQoAghBhICAgHhHBEAgAUEMaiEHA0AgBygCCCIJIAcoAgBGBEAgByAJQQFBBEHIABDQKAsgBygCBCAJQcgAbGogBEEIaiILQcgA/AoAACAHIAlBAWo2AgggCyAKEJ8dIAQoAghBhICAgHhHDQALCyAEQdAAaiQAIAZBCGogDCgCADYCACAGIAEpAgw3AgAMAQsgBkEANgIIIAZCgICAgMAANwIACyABQYABaiQADAELIAcgASgCaEHIl88AEP0vAAsCQCACKAIIQQhHBEAgAyACKQMINwMAIANBEGogAkEYaikDADcDACADQQhqIAJBEGopAwA3AwAgAigCLCIDBEAgAigCKCEBA0AgARDiCyABQcgAaiEBIANBAWsiAw0ACwsgAkEkakEEQcgAEOAeDAELIAMgAikCJDcCBCADQQg2AgAgA0EMaiACQSxqKAIANgIACyACQdAAaiQAIAVBOGoiASAFQbQCaigCADYCACAFIAUpAqwCNwMwIAUoAqgCIgJBCEcEQCAFKQO4AiEOIAAgBSkDMDcCDCAAIA43AxggACACNgIIIABBhICAgHg2AgAgAEEUaiABKAIANgIADBALIAAgBSkDMDcCBCAAQQxqIAEoAgA2AgAgAEEUaiAIEJw2EO4lIABBg4CAgHg2AgAgACAFKAEUNgIQDA8LIAQoAgAiASABKAIAIgdBAWo2AgAgB0EASA0FIAAgAiADIAlBAXEgASAEKAIEEPEbDA4LIAZBJ0cNBiMAQSBrIgEkACABQQhqIAQoAgAgBCgCBCIEKAIIQQFrQXhxakEIaiAEKAIQEQAAIAFBEGogASgCCCIEIAEoAgwoAgwRAAAgASkDGCEOIAEpAxAhDyABQSBqJAAgBEEAIA9ClY2j2tTIv9zGAIUgDkKzz/m4y5qOxTKFhFAbIgZFBEBB8N7QAEEJQfze0AAQyyQACyAGKAIYIQggBUGoAmogBkEMahDCBiAGKAIcIgEEQCABIAEoAgAiA0EBajYCACADQQBIDQUgBigCLCEJIAYoAighCyAGKAIkIQwgBigCICENIAYoAjAhAwsgBUHIAmoiBCAGELwVIAVB3AJqIAVBsAJqKAIANgIAIAUgCDYC4AIgBSADNgL4AiAFIAk2AvQCIAUgCzYC8AIgBSAMNgLsAiAFIA02AugCIAUgATYC5AIgBSAFKQKoAjcC1AJBPEEEEK02IgFFDQUgAUKBgICAEDcCACABQQhqIARBNPwKAAAgBUH0wM0ANgLcASAFIAE2AtgBIAQgCigCAEEIaiACIAcgBUHYAWoiAxC2ASAFKALIAiIIQYSAgIB4Rw0DIAVBvAJqIAVB4AJqKQMAIg43AgAgBUG0AmogBUHYAmopAwAiDzcCACAFIAUpA9ACIhA3AqwCIABBGGogDjcCACAAQRBqIA83AgAgACAQNwIIIABBhICAgHg2AgAgASABKAIAIgBBAWs2AgAgAEEBRw0NIAMQuyMMDQsgBCgCACAEKAIEIgMoAghBAWtBeHFqQQhqIQQjAEEgayIBJAAgAUEIaiAEIAMoAhARAAAgAUEQaiABKAIIIgMgASgCDCgCDBEAACABKQMYIQ4gASkDECEPIAFBIGokACADQQAgD0L75PLhsbPtw3yFIA5CgbfKnrar7cxuhYRQGyIGRQRAQYzf0ABBCkGY39AAEMskAAsgBUHIAmogCigCAEEIaiACIAcgBkEMahC2ASAFKALIAiIIQYSAgIB4Rg0KIAVBwAJqIgEgBUHkAmooAgA2AgAgBUG4AmoiAyAFQdwCaikCADcDACAFQbACaiIEIAVB1AJqKQIANwMAIAUgBSkCzAI3A6gCIAVByABqIgogBUHoAmpBKPwKAAAgBUH4AGoiCyAEKQMANwMAIAVBgAFqIgwgAykDADcDACAFQYgBaiINIAEoAgA2AgAgBSAFKQOoAjcDcCAGKAIUIgEgASgCACIDQQFqNgIAIANBAEgNAyAGKAIcIQMgBigCGCEJQcgAQQQQrTYiBEUNDSAEIAg2AgAgBCAFKQNwNwIEIARBDGogCykDADcCACAEQRRqIAwpAwA3AgAgBEEcaiANKAIANgIAIARBIGogCkEo/AoAACAFQTBqIAYQmTYQ7iUgAUEQdiEGDAgLIwBBIGsiAyQAIANBCGogBCgCACAEKAIEIgQoAghBAWtBeHFqQQhqIAQoAhARAAAgA0EQaiADKAIIIgQgAygCDCgCDBEAACADKQMYIQ4gAykDECEPIANBIGokACAEQQAgD0L/2euq19iLjPEAhSAOQoH04aOq+Nbqi3+FhFAbIgNFBEBByN7QAEEVQeDe0AAQyyQACyAFQcgCaiAKKAIAQQhqIAIgByADQQxqELYBIAUoAsgCIgZBhICAgHhGDQYgBUHAAmoiBCAFQeQCaigCADYCACAFQbgCaiIJIAVB3AJqKQIANwMAIAVBsAJqIgggBUHUAmopAgA3AwAgBSAFKQLMAjcDqAIgBUGQA2oiCiAFQegCakEo/AoAACAFQcADaiILIAgpAwA3AwAgBUHIA2oiCCAJKQMANwMAIAVB0ANqIgkgBCgCADYCACAFIAUpA6gCNwO4AyAFQdgDaiADEJs2EO4lQcgAQQQQrTYiBEUNDCAEIAY2AgAgBCAFKQO4AzcCBCAEQQxqIAspAwA3AgAgBEEUaiAIKQMANwIAIARBHGogCSgCADYCACAEQSBqIApBKPwKAAAgBUE4aiAFQegDaikCADcDACAFIAUpAuADNwMwIAEoAiwhCSAFKALYAyEDIAIhASAHIQYgBS8B3AMhAiAFLwHeAyEHQYKAgIB4DAgLIAQoAgAgBCgCBCIDKAIIQQFrQXhxakEIaiEEIwBBIGsiASQAIAFBCGogBCADKAIQEQAAIAFBEGogASgCCCIDIAEoAgwoAgwRAAAgASkDGCEOIAEpAxAhDyABQSBqJAAgA0EAIA9C4//bxtnAsr/aAIUgDkLrqof3kZGQlSSFhFAbIgRFBEBBjN/QAEEKQZjf0AAQyyQACyAFQcgCaiAKKAIAQQhqIAIgByAEQQxqELYBIAUoAsgCIgZBhICAgHhGDQQgBUHAAmoiASAFQeQCaigCADYCACAFQbgCaiIDIAVB3AJqKQIANwMAIAVBsAJqIgkgBUHUAmopAgA3AwAgBSAFKQLMAjcDqAIgBUGQAWoiCCAFQegCakEo/AoAACAFQcABaiIKIAkpAwA3AwAgBUHIAWoiCyADKQMANwMAIAVB0AFqIgwgASgCADYCACAFIAUpA6gCNwO4ASAEKAIUIgEgASgCACIDQQFqNgIAIANBAEgNASAEKAIcIQMgBCgCGCEJIAVBMGogBBCZNhDuJUHIAEEEEK02IgRFDQsgBCAGNgIAIAQgBSkDuAE3AgQgBEEMaiAKKQMANwIAIARBFGogCykDADcCACAEQRxqIAwoAgA2AgAgBEEgaiAIQSj8CgAAIAFBEHYhBkGBgICAeAwHCyAFQcACaiIBIAVB5AJqKAIANgIAIAVBuAJqIgMgBUHcAmopAgA3AwAgBUGwAmoiBCAFQdQCaikCADcDACAFIAUpAswCNwOoAiAFQeABaiIKIAVB6AJqQSj8CgAAIAVBkAJqIgsgBCkDADcDACAFQZgCaiIMIAMpAwA3AwAgBUGgAmoiDSABKAIANgIAIAUgBSkDqAI3A4gCIAYoAkAiASABKAIAIgNBAWo2AgAgA0EASA0AIAYoAkghAyAGKAJEIQlByABBBBCtNiIERQ0KIAQgCDYCACAEIAUpA4gCNwIEIARBDGogCykDADcCACAEQRRqIAwpAwA3AgAgBEEcaiANKAIANgIAIARBIGogCkEo/AoAACAFQTBqIAYQmjYQ7iUgBSgC2AEiBiAGKAIAIghBAWs2AgAgAUEQdiEGIAhBAUcNBSAFQdgBahC7IwwFCwALQQRBPBCjPQALQczBzQBBKEH0wc0AEJ8pAAsgBUG8AmogBUHgAmopAwAiDjcCACAFQbQCaiAFQdgCaikDACIPNwIAIAUgBSkD0AIiEDcCrAIgAEEYaiAONwIAIABBEGogDzcCACAAIBA3AgggAEGEgICAeDYCAAwFCyAFQbwCaiAFQeACaikDACIONwIAIAVBtAJqIAVB2AJqKQMAIg83AgAgBSAFKQPQAiIQNwKsAiAAQRhqIA43AgAgAEEQaiAPNwIAIAAgEDcCCCAAQYSAgIB4NgIADAQLQYCAgIB4CyEIIAAgBzsBFiAAIAI7ARQgACADNgIQIAAgCTYCDCAAIAY7AQogACABOwEIIAAgBDYCBCAAIAg2AgAgACAFKQMwNwIYIAAgBSkCGDcCMCAAQSBqIAVBOGopAwA3AgAgAEEoaiAFQUBrKQMANwIAIABBOGogBUEgaikCADcCACAAQUBrIAVBKGopAgA3AgAMAgsgBUG8AmogBUHgAmopAwAiDjcCACAFQbQCaiAFQdgCaikDACIPNwIAIAUgBSkD0AIiEDcCrAIgAEEYaiAONwIAIABBEGogDzcCACAAIBA3AgggAEGEgICAeDYCAAwBCyAFIAFBNGo2AhAgBSAINgLYASAFIAQQ8y02AhggBUEDNgKsAiAFQdzAzQA2AqgCIAVCAzcCtAIgBUGnBDYC3AIgBUGnBDYC1AIgBUGEATYCzAIgBSAFQcgCajYCsAIgBSAFQRhqNgLYAiAFIAVB2AFqNgLQAiAFIAVBEGo2AsgCIAVBMGoiASAFQagCahCZDiAAQQxqIAEQ3SAgAEGEgICAeDYCACAAQQM2AgggARDeOwsgBUHwA2okAA8LQQRByAAQoz0AC9+sAQITfwJ+IwBBgANrIgYkACAGQQA6ABQgBkGAgICAeDYCECAGQsCAgICAyNAHNwIIIAZBADYCLCAGQgA3AiQgBiACNgIcIAYgATYCGCAGIAZBCGo2AiAgBkHIAmogBkEYakEAEJQOIAYoAswCIQ0CQAJAIAYoAsgCIgNBioCAgHhHBEAgBkHAAWogBkHkAmopAgA3AwAgBiAGKQLcAjcDuAEgBikC1AIhFiAGKALQAiEHDAELIAZByAJqIAZBGGogDRC1BiAGKQLUAiEWIAYoAtACIQcgBigCzAIhDSAGKALIAiIDQYqAgIB4RwRAIAZBwAFqIAZB5AJqKQIANwMAIAYgBikC3AI3A7gBDAELIAYgFjcCOCAGIAc2AjQgBiANNgIwIAZByAJqIAZBMGpBBBDdECAGKALQAiEHIAYoAswCIQ0gBigCyAIiA0GKgICAeEcEQCAGQcABaiAGQeQCaikCADcDACAGIAYpAtwCNwO4ASAGKQLUAiEWDAELAkACQCANQQFxRQ0AAkAgB0EBcQRAIAYgBzYC5AIgBkEDNgLgAiAGQcn2/gA2AtwCIAZBgICAgHg2AtgCIAZCBDcC0AIgBkKEgICACDcCyAIMAQtBfyAHQQJqIgMgAyAHSRsiDSAGKAIwIgMoAgRNBEAgAyADKAIUQQJqIg02AhQgAygCCCgCCCANTwRAIAZBioCAgHg2AsgCDAILIAZBiICAgHg2AsgCDAELIAZByAJqIAcgDRC/LwsgBkEHNgLIASAGQbD3/gA2AsQBIAZBgICAgHg2AsABIAYgBzYCvAEgBkEBNgK4ASAGQZQCaiAGQcgCaiAGQbgBahCBFCAGKAKUAiIDQYqAgIB4Rg0ADAELIAYgBikCODcCSCAGIAYpAjA3AkAgBkHIAmogBkFAa0EIEN0QIAYoAtACIQ0gBigCzAIhBwJAIAYoAsgCIgNBioCAgHhHBEAgBkH4AWogBkHkAmopAgA3AgAgBkHwAWogBkHcAmopAgA3AgAgBiAGKQLUAjcC6AEgBiANNgLkASAGIAc2AuABDAELIAZByAJqIAZBQGtBBhDdECAGKALQAiEFIAYoAswCIQggBigCyAIiA0GKgICAeEcEQCAGQfgBaiAGQeQCaikCADcCACAGQfABaiAGQdwCaikCADcCACAGIAYpAtQCNwLoASAGIAU2AuQBIAYgCDYC4AEMAQsCQAJAAkAgCEEBcQRAIAdBAXENAQwDCyAHQQFxDQIgBkHgAWohDQwBCwJAIAVBAWoiB0F/IAcbIgMgBigCQCIHKAIETQRAIAcgBygCFEEBaiIDNgIUIAcoAggoAgggA08EQCAGQYqAgIB4NgLIAgwCCyAGQYiAgIB4NgLIAgwBCyAGQcgCaiAFIAMQvy8LIAZBCzYCyAEgBkG39/4ANgLEASAGQYCAgIB4NgLAASAGIAU2ArwBIAZBATYCuAEgBkGUAmogBkHIAmogBkG4AWoQgRQgBigClAIiA0GKgICAeEcEQCAGQfgBaiAGQbACaikCADcCACAGQfABaiAGQagCaikCADcCACAGQegBaiAGQaACaikCADcCACAGIAYpApgCNwLgAQwDCyAGKAJAIgcoAgQiAyAFTwRAAkACQAJAAkACQAJAAkAgBygCACAFai0AAEEBaw4FAQIDBAUACyAGQYqAgIB4NgLIAgwFCyAGQcgCaiMAQbACayIFJAAgBUGMAmogByANEJMOIAUoApACIQMCQCAFKAKMAiIIQYqAgIB4RwRAIAVBJGogBUGsAmooAgA2AgAgBUEcaiAFQaQCaikCADcCACAFQRRqIAVBnAJqKQIANwIAIAUgBSkClAI3AgwgBSADNgIIIAUgCDYCBAwBCyAFQYwCaiAHQX8gAyANaiIHIAMgB0sbELQGIAVB+ABqIgcgBUGYAmopAgA3AwAgBSAFKQKQAjcDcCAFKAKMAiIDQYqAgIB4RwRAIAVBIGogBUGoAmopAgA3AgAgBUEQaiAHKQMANwIAIAUgBSkCoAI3AhggBSAFKQNwNwIIIAUgAzYCBAwBCyAFQYgBaiAHKQMANwMAIAUgBSkDcDcDgAEgBUGMAmogBUGAAWpBBBDdECAFKAKUAiEHIAUoApACIQgCQAJ+IAUoAowCIgRBioCAgHhHBEAgBUG4AWogBUGoAmopAgA3AwAgBSAFKQKgAjcDsAEgBSkCmAIMAQsgCEEBcUUNAQJAIAdBAXEEQCAFIAc2AqgCIAVBAzYCpAIgBUG55P4ANgKgAiAFQYCAgIB4NgKcAiAFQgQ3ApQCIAVChICAgAg3AowCDAELQX8gB0ECaiIDIAMgB0kbIgggBSgCgAEiAygCBE0EQCADIAMoAhRBAmoiCDYCFCADKAIIKAIIIAhPBEAgBUGKgICAeDYCjAIMAgsgBUGIgICAeDYCjAIMAQsgBUGMAmogByAIEL8vCyAFQQo2AsABIAVBjuv+ADYCvAEgBUGAgICAeDYCuAEgBSAHNgK0ASAFQQE2ArABIAVB6AFqIAVBjAJqIAVBsAFqEIEUIAUoAugBIgRBioCAgHhGDQEgBUG4AWogBUGEAmopAgA3AwAgBSAFKQL8ATcDsAEgBSgC8AEhByAFKALsASEIIAUpAvQBCyEWIAVBIGogBUG4AWopAwA3AgAgBSAWNwIQIAUgBzYCDCAFIAg2AgggBSAENgIEIAUgBSkDsAE3AhgMAQsgBSAFKQOIATcCmAEgBSAFKQOAATcCkAEgBUHEAWogBUGQAWpBmOv+AEEGQQYQlwEgBUHoAGoiByAFQdABaikCADcDACAFIAUpAsgBNwNgIAUoAsQBIgNBioCAgHhHBEAgBUEgaiAFQeABaikCADcCACAFQRBqIAcpAwA3AgAgBSAFKQLYATcCGCAFIAUpA2A3AgggBSADNgIEDAELIAVBqAFqIAcpAwA3AwAgBSAFKQNgNwOgASAFQTxqIAVBoAFqQQgQ7wMgBUEwaiIHIAVByABqKQIANwMAIAUgBSkCQDcDKCAFKAI8IgNBioCAgHhHBEAgBUEgaiAFQdgAaikCADcCACAFQRBqIAcpAwA3AgAgBSAFKQJQNwIYIAUgBSkDKDcCCCAFIAM2AgQMAQsgBUG4AWogBUEwaikDADcDACAFIAUpAyg3A7ABIAVBjAJqIAVBsAFqQQoQ3RAgBSgClAIhByAFKAKQAiEIAkACfiAFKAKMAiIEQYqAgIB4RwRAIAVB8AFqIAVBqAJqKQIANwMAIAUgBSkCoAI3A+gBIAUpApgCDAELIAhBAXFFDQEgBUGMAmogBSgCsAEiAyAHEJMOIAUoApACIQkCQCAFKAKMAiIIQYqAgIB4RwRAIAVBiAJqIAVBrAJqKAIANgIAIAVBgAJqIAVBpAJqKQIANwIAIAVB+AFqIAVBnAJqKQIANwIAIAUgBSkClAI3AvABIAUgCTYC7AEgBSAINgLoAQwBCyAFQYwCaiEIIwBBMGsiBCQAIARBDGogA0F/IAcgCWoiCyAJIAtLGyIJEJMOIAQoAhAhCwJAIAQoAgwiCkGKgICAeEcEQCAIIAQpAhQ3AgggCEEgaiAEQSxqKAIANgIAIAhBGGogBEEkaikCADcCACAIQRBqIARBHGopAgA3AgAgCCALNgIEIAggCjYCAAwBC0F/IAlBBGoiCiAJIApLGyIJQQdxBEAgCCAJNgIcIAhBHzYCGCAIQYDj/gA2AhQgCEGAgICAeDYCECAIQgQ3AgggCEKEgICACDcCAAwBCwJAAkBBfyAJQX8gC0EDdCALQf////8BSxsiCmoiCyAJIAtLGyILIAMoAgRNBEAgAyADKAIUIApqIg42AhRBiICAgHghCiAOIAMoAggoAghLDQEMAgsgBEEMaiAJIAsQvy8gBCgCDCIKQYqAgIB4Rg0BCyAIIAQpAhA3AgQgCEEcaiAEQShqKQIANwIAIAhBFGogBEEgaikCADcCACAIQQxqIARBGGopAgA3AgAgCCAKNgIADAELIAggCzYCCCAIIAk2AgQgCEGKgICAeDYCAAsgBEEwaiQAIAUoAowCIgNBioCAgHhHBEAgBUH8AWogBUGgAmopAgA3AgAgBUGEAmogBUGoAmopAgA3AgAgBSAFKQKYAjcC9AEgBSAFKQKQAjcC7AELIAUgAzYC6AELIAVBCDYCnAIgBUGe6/4ANgKYAiAFQYCAgIB4NgKUAiAFIAc2ApACIAVBATYCjAIgBUHEAWogBUHoAWogBUGMAmoQgRQgBSgCxAEiBEGKgICAeEYNASAFQfABaiAFQeABaikCADcDACAFIAUpAtgBNwPoASAFKALMASEHIAUoAsgBIQggBSkC0AELIRYgBUEgaiAFQfABaikDADcCACAFIBY3AhAgBSAHNgIMIAUgCDYCCCAFIAQ2AgQgBSAFKQPoATcCGAwBCyAFKAKwASIHIAcoAgxBAWs2AgwgBUGKgICAeDYCBAsgBUEVNgKcAiAFQeH3/gA2ApgCIAVBgICAgHg2ApQCIAUgDTYCkAIgBUECNgKMAiAFQQRqIAVBjAJqEIEUIAVBsAJqJAAMBAsgBkHIAmojAEHQAWsiAyQAIANBlAFqIAcgDRCTDiADKAKYASEFAkAgAygClAEiCEGKgICAeEcEQCADQSxqIANBtAFqKAIANgIAIANBJGogA0GsAWopAgA3AgAgA0EcaiADQaQBaikCADcCACADIAMpApwBNwIUIAMgBTYCECADIAg2AgwMAQsgA0GUAWogB0F/IAUgDWoiByAFIAdLGxC0BiADQThqIgcgA0GgAWopAgA3AwAgAyADKQKYATcDMCADKAKUASIFQYqAgIB4RwRAIANBKGogA0GwAWopAgA3AgAgA0EYaiAHKQMANwIAIAMgAykCqAE3AiAgAyADKQMwNwIQIAMgBTYCDAwBCyADQcgAaiAHKQMANwMAIAMgAykDMDcDQCADQZQBaiADQUBrQQQQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQECQCAHQQdxBEAgAyAHNgKwASADQQM2AqwBIANBsOT+ADYCqAEgA0GAgICAeDYCpAEgA0IENwKcASADQoSAgIAINwKUAQwBC0F/IAdBCGoiBSAFIAdJGyIIIAMoAkAiBSgCBE0EQCAFIAUoAhRBCGoiCDYCFCAFKAIIKAIIIAhPBEAgA0GKgICAeDYClAEMAgsgA0GIgICAeDYClAEMAQsgA0GUAWogByAIEL8vCyADQQI2AsgBIANB5+b+ADYCxAEgA0GAgICAeDYCwAEgAyAHNgK8ASADQQE2ArgBIANB8ABqIANBlAFqIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADIAMpA0g3AlggAyADKQNANwJQIANBlAFqIANB0ABqQQYQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQEgA0GUAWoiBSADKAJQIAcQsgEgA0EENgLIASADQenm/gA2AsQBIANBgICAgHg2AsABIAMgBzYCvAEgA0EBNgK4ASADQfAAaiAFIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADIAMpAlg3AmggAyADKQJQNwJgIANBlAFqIANB4ABqQQgQ3RAgAygCnAEhByADKAKYASEIAkACfiADKAKUASIEQYqAgIB4RwRAIANBwAFqIANBsAFqKQIANwMAIAMgAykCqAE3A7gBIAMpAqABDAELIAhBAXFFDQECQCAHQQFqIgVBfyAFGyIIIAMoAmAiBSgCBE0EQCAFIAUoAhRBAWoiCDYCFCAFKAIIKAIIIAhPBEAgA0GKgICAeDYClAEMAgsgA0GIgICAeDYClAEMAQsgA0GUAWogByAIEL8vCyADQQc2AsgBIANB7eb+ADYCxAEgA0GAgICAeDYCwAEgAyAHNgK8ASADQQE2ArgBIANB8ABqIANBlAFqIANBuAFqEIEUIAMoAnAiBEGKgICAeEYNASADQcABaiADQYwBaikCADcDACADIAMpAoQBNwO4ASADKAJ4IQcgAygCdCEIIAMpAnwLIRYgA0EoaiADQcABaikDADcCACADIBY3AhggAyAHNgIUIAMgCDYCECADIAQ2AgwgAyADKQO4ATcCIAwBCyADKAJgIgcgBygCDEEBazYCDCADQYqAgIB4NgIMCyADQR42AqQBIANB9vf+ADYCoAEgA0GAgICAeDYCnAEgAyANNgKYASADQQI2ApQBIANBDGogA0GUAWoQgRQgA0HQAWokAAwDCyMAQUBqIgMkACADQQhqIgUgByANELIBIANBGjYCPCADQZT4/gA2AjggA0GAgICAeDYCNCADIA02AjAgA0ECNgIsIAZByAJqIAUgA0EsahCBFCADQUBrJAAMAgsgBkHIAmpCACEWIwBBkAJrIgQkACAEQewBaiAHIA0Qkw4gBCgC8AEhAwJAIAQoAuwBIgVBioCAgHhHBEAgBEEkaiAEQYwCaigCADYCACAEQRxqIARBhAJqKQIANwIAIARBFGogBEH8AWopAgA3AgAgBCAEKQL0ATcCDCAEIAM2AgggBCAFNgIEDAELIARB7AFqIAdBfyADIA1qIgcgAyAHSxsQtAYgBEHoAGoiByAEQfgBaikCADcDACAEIAQpAvABNwNgIAQoAuwBIgNBioCAgHhHBEAgBEEgaiAEQYgCaikCADcCACAEQRBqIAcpAwA3AgAgBCAEKQKAAjcCGCAEIAQpA2A3AgggBCADNgIEDAELIARB+ABqIAcpAwA3AwAgBCAEKQNgNwNwIARB7AFqIARB8ABqQQYQ3RAgBCgC9AEhByAEKALwASEDAn8gBCgC7AEiCUGKgICAeEcEQCAEKAKMAiELIAQoAogCIQogBCgCgAIhDCAEKAL8ASEOIAQoAvgBIQ8gBCgChAIMAQsgBEHsAWogBEHwAGpBBBDdECAEKAL0ASEFIAQoAvABIQggBCgC7AEiCUGKgICAeEcEQCAEKAKMAiELIAQoAogCIQogBCgCgAIhDCAEKAL8ASEOIAQoAvgBIQ8gBSEHIAghAyAEKAKEAgwBCwJAAkAgCEEBcQRAIANBAXENAQwCCyADQQFxDQFBBCEHQYCAgIB4IQ5Bguj+ACEMQQAhA0GAgICAeCEJQQUMAgsCQCAFQQFqIgNBfyADGyIIIAQoAnAiAygCBE0EQCADIAMoAhRBAWoiCDYCFCADKAIIKAIIIAhPBEAgBEGKgICAeDYC7AEMAgsgBEGIgICAeDYC7AEMAQsgBEHsAWogBSAIEL8vCyAEQQk2ArQBIARB+ef+ADYCsAEgBEGAgICAeDYCrAEgBCAFNgKoASAEQQE2AqQBIARByAFqIARB7AFqIARBpAFqEIEUIAQoAsgBIglBioCAgHhHBEAgBCgC6AEhCyAEKALkASEKIAQoAtwBIQwgBCgC2AEhDiAEKALUASEPIAQoAtABIQcgBCgCzAEhAyAEKALgAQwCCwJAAn8CQAJAIAQoAnAiAygCBCIIIAVPBEACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADKAIAIAVqLQAAQQFrDhoBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGgALIARBioCAgHg2AsgBDBoLIARByAFqIANBqOj+AEEKIAcQqBAMGQsgBEHsAWoiBSADIAcQ+AYgBEEJNgKgASAEQbLo/gA2ApwBIARBgICAgHg2ApgBIAQgBzYClAEgBEECNgKQASAEQcgBaiAFIARBkAFqEIEUDBgLIARByAFqIAMgBxDeCAwXCyAEQcgBaiADQc7o/gBBDCAHEKgQDBYLIARByAFqIANB2uj+AEEKIAcQqBAMFQsgBEHIAWogA0Hk6P4AQQogBxCoEAwUCyAEQcgBaiADIAcQogMMEwsgBEHIAWogA0H76P4AQQogBxDfCAwSCyAEQcgBaiADIAcQlQYMEQsgBEHIAWogAyAHEOMHDBALIARByAFqIANBnun+AEEOIAcQ3wgMDwsgBEHIAWogA0Gs6f4AQQogBxCoEAwOCyAEQcgBaiADQbbp/gBBDSAHEKgQDA0LIARByAFqIAMgBxCpBQwMCyAEQcgBaiADIAcQ4AgMCwsgBEHIAWogAyAHEN0IDAoLIARByAFqIAMgBxCCCQwJCyAEQcgBaiADQf/p/gBBDiAHEN8IDAgLIARByAFqIANBjer+AEERIAcQqBAMBwsgBEHIAWogA0Ge6v4AQQ8gBxCoEAwGCyAEQcgBaiADQa3q/gBBDyAHEKgQDAULIARByAFqIANBvOr+AEETIAcQqBAMBAsgBEHIAWogA0HP6v4AQRAgBxCoEAwDCyAEQcgBaiADQd/q/gBBDiAHEKgQDAILIARByAFqIANB7er+AEEOIAcQqBAMAQsgBEHIAWogA0H76v4AQRMgBxCoEAsgBEEFNgL8ASAEQYLo/gA2AvgBIARBgICAgHg2AvQBIAQgBzYC8AEgBEEBNgLsASAEQaQBaiAEQcgBaiAEQewBahCBFCAEKAKkASIJQYqAgIB4RwRAIAQoAsQBIQsgBCgCwAEhCiAEKAK4ASEMIAQoArQBIQ4gBCgCsAEhDyAEKAKsASEHIAQoAqgBIQMgBCgCvAEMBwsgBCAEKQN4NwKIASAEIAQpA3A3AoABIARBPGogBEGAAWoQ+wIgBEEwaiIHIARByABqKQIANwMAIAQgBCkCQDcDKCAEKAI8IgNBioCAgHhHBEAgBEEgaiAEQdgAaikCADcCACAEQRBqIAcpAwA3AgAgBCAEKQJQNwIYIAQgBCkDKDcCCCAEIAM2AgQMCAsgBEGYAWogBykDADcDACAEIAQpAyg3A5ABIARB7AFqIARBkAFqQQoQ3RAgBCgC9AEhCSAEKALwASEDAkACfiAEKALsASIHQYqAgIB4RwRAIARB0AFqIARBiAJqKQIANwMAIAQgBCkCgAI3A8gBIAQpAvgBDAELIANBAXFFDQEgBEHsAWogBCgCkAEiAyAJEJMOIAQoAvABIQcCQCAEKALsASIFQYqAgIB4RwRAIARB6AFqIARBjAJqKAIANgIAIARB4AFqIARBhAJqKQIANwIAIARB2AFqIARB/AFqKQIANwIAIAQgBCkC9AE3AtABIAQgBzYCzAEgBCAFNgLIAQwBCyAEQewBaiADQX8gByAJaiIDIAMgB0kbEIYOIAQoAuwBIgdBioCAgHhHBEAgBEHcAWogBEGAAmopAgA3AgAgBEHkAWogBEGIAmopAgA3AgAgBCAEKQL4ATcC1AEgBCAEKQLwATcCzAELIAQgBzYCyAELIARBBzYC/AEgBEHI7f4ANgL4ASAEQYCAgIB4NgL0ASAEIAk2AvABIARBATYC7AEgBEGkAWogBEHIAWogBEHsAWoQgRQgBCgCpAEiB0GKgICAeEYNASAEQdABaiAEQcABaikCADcDACAEIAQpArgBNwPIASAEKAKsASEJIAQoAqgBIQMgBCkCsAELIRYgBEEgaiAEQdABaikDADcCACAEIBY3AhAgBCAJNgIMIAQgAzYCCCAEIAc2AgQgBCAEKQPIATcCGAwICyAEIAQpA5gBNwJEIAQgBCkDkAE3AjwgBEHsAWogBEE8akEMEN0QIAQoAvQBIQkgBCgC8AEhAyAEKALsASIHQYqAgIB4RwRAIAQpAogCIRYgBCgChAIhCyAEKAKAAiEKIAQoAvgBIQwgBCgC/AEMBAsgA0EBcUUEQEHp5v4AIQpBBCELQQQhCUEAIQNBgICAgHghB0GAgICAeAwEC0F/IAlBEGoiByAHIAlJGyIDIAQoAjwiBygCBEsNASAHIAcoAhRBEGoiAzYCFCAHKAIIKAIIIANPBEAgBEGKgICAeDYC7AEMAwsgBEGIgICAeDYC7AEMAgsgBSAIQdDh/gAQrzsACyAEQewBaiAJIAMQvy8LIARBBDYCtAEgBEHp5v4ANgKwASAEQYCAgIB4NgKsASAEIAk2AqgBIARBATYCpAEgBEHIAWogBEHsAWogBEGkAWoQgRQgBCgCyAEiB0GKgICAeEYNASAEKQLkASEWIAQoAuABIQsgBCgC3AEhCiAEKALUASEMIAQoAtABIQkgBCgCzAEhAyAEKALYAQshBSAEIBY3AiAgBCALNgIcIAQgCjYCGCAEIAU2AhQgBCAMNgIQIAQgCTYCDCAEIAM2AgggBCAHNgIEDAMLIAQoAjwiByAHKAIMQQFrNgIMIARBioCAgHg2AgQMAgtBBCEDQQAhB0H55/4AIQ5BCSEMQYLo/gAhCkEFIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAMNgIYIAQgDjYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQLIARBFTYC/AEgBEGu+P4ANgL4ASAEQYCAgIB4NgL0ASAEIA02AvABIARBAjYC7AEgBEEEaiAEQewBahCBFCAEQZACaiQADAELIAZByAJqQgAhFiMAQaACayIEJAAgBEH8AWogByANEJMOIAQoAoACIQMCQCAEKAL8ASIFQYqAgIB4RwRAIARBJGogBEGcAmooAgA2AgAgBEEcaiAEQZQCaikCADcCACAEQRRqIARBjAJqKQIANwIAIAQgBCkChAI3AgwgBCADNgIIIAQgBTYCBAwBCyAEQfwBaiAHQX8gAyANaiIHIAMgB0sbELQGIARB6ABqIgcgBEGIAmopAgA3AwAgBCAEKQKAAjcDYCAEKAL8ASIDQYqAgIB4RwRAIARBIGogBEGYAmopAgA3AgAgBEEQaiAHKQMANwIAIAQgBCkCkAI3AhggBCAEKQNgNwIIIAQgAzYCBAwBCyAEQfgAaiAHKQMANwMAIAQgBCkDYDcDcCAEQfwBaiAEQfAAakEGEN0QIAQoAoQCIQcgBCgCgAIhAwJ/IAQoAvwBIglBioCAgHhHBEAgBCgCnAIhCyAEKAKYAiEKIAQoApACIQ4gBCgCjAIhDCAEKAKIAiEPIAQoApQCDAELIARB/AFqIARB8ABqQQQQ3RAgBCgChAIhBSAEKAKAAiEIIAQoAvwBIglBioCAgHhHBEAgBCgCnAIhCyAEKAKYAiEKIAQoApACIQ4gBCgCjAIhDCAEKAKIAiEPIAUhByAIIQMgBCgClAIMAQsCQAJAIAhBAXEEQCADQQFxDQEMAgsgA0EBcQ0BQQQhB0GAgICAeCEMQYLo/gAhDkEAIQNBgICAgHghCUEFDAILAkAgBUEBaiIDQX8gAxsiCCAEKAJwIgMoAgRNBEAgAyADKAIUQQFqIgg2AhQgAygCCCgCCCAITwRAIARBioCAgHg2AvwBDAILIARBiICAgHg2AvwBDAELIARB/AFqIAUgCBC/LwsgBEEJNgKwASAEQfnn/gA2AqwBIARBgICAgHg2AqgBIAQgBTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFCAEKALYASIJQYqAgIB4RwRAIAQoAvgBIQsgBCgC9AEhCiAEKALsASEOIAQoAugBIQwgBCgC5AEhDyAEKALgASEHIAQoAtwBIQMgBCgC8AEMAgsCQAJ+AkACQCAEKAJwIgMoAgQiCCAFTwRAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAygCACAFai0AAEEBaw4aAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRoACyAEQYqAgIB4NgLYAQwaCyAEQdgBaiADQajo/gBBCiAHEKgQDBkLIARB/AFqIgUgAyAHEPgGIARBCTYC1AEgBEGy6P4ANgLQASAEQYCAgIB4NgLMASAEIAc2AsgBIARBAjYCxAEgBEHYAWogBSAEQcQBahCBFAwYCyAEQdgBaiADIAcQ3ggMFwsgBEHYAWogA0HO6P4AQQwgBxCoEAwWCyAEQdgBaiADQdro/gBBCiAHEKgQDBULIARB2AFqIANB5Oj+AEEKIAcQqBAMFAsgBEHYAWogAyAHEKIDDBMLIARB2AFqIANB++j+AEEKIAcQ3wgMEgsgBEHYAWogAyAHEJUGDBELIARB2AFqIAMgBxDjBwwQCyAEQdgBaiADQZ7p/gBBDiAHEN8IDA8LIARB2AFqIANBrOn+AEEKIAcQqBAMDgsgBEHYAWogA0G26f4AQQ0gBxCoEAwNCyAEQdgBaiADIAcQqQUMDAsgBEHYAWogAyAHEOAIDAsLIARB2AFqIAMgBxDdCAwKCyAEQdgBaiADIAcQggkMCQsgBEHYAWogA0H/6f4AQQ4gBxDfCAwICyAEQdgBaiADQY3q/gBBESAHEKgQDAcLIARB2AFqIANBnur+AEEPIAcQqBAMBgsgBEHYAWogA0Gt6v4AQQ8gBxCoEAwFCyAEQdgBaiADQbzq/gBBEyAHEKgQDAQLIARB2AFqIANBz+r+AEEQIAcQqBAMAwsgBEHYAWogA0Hf6v4AQQ4gBxCoEAwCCyAEQdgBaiADQe3q/gBBDiAHEKgQDAELIARB2AFqIANB++r+AEETIAcQqBALIARBBTYCjAIgBEGC6P4ANgKIAiAEQYCAgIB4NgKEAiAEIAc2AoACIARBATYC/AEgBEGgAWogBEHYAWogBEH8AWoQgRQgBCgCoAEiCUGKgICAeEcEQCAEKALAASELIAQoArwBIQogBCgCtAEhDiAEKAKwASEMIAQoAqwBIQ8gBCgCqAEhByAEKAKkASEDIAQoArgBDAcLIAQgBCkDeDcCiAEgBCAEKQNwNwKAASAEQTxqIARBgAFqEPsCIARBMGoiByAEQcgAaikCADcDACAEIAQpAkA3AyggBCgCPCIDQYqAgIB4RwRAIARBIGogBEHYAGopAgA3AgAgBEEQaiAHKQMANwIAIAQgBCkCUDcCGCAEIAQpAyg3AgggBCADNgIEDAgLIARBmAFqIAcpAwA3AwAgBCAEKQMoNwOQASAEQfwBaiAEQZABakEKEN0QIAQoAoQCIQkgBCgCgAIhAyAEKAL8ASIHQYqAgIB4RwRAIARBqAFqIARBmAJqKQIANwMAIAQgBCkCkAI3A6ABIAQpAogCDAQLIANBAXFFDQQgCUEHcQRAIAQgCTYCmAIgBEEDNgKUAiAEQbDk/gA2ApACIARBgICAgHg2AowCIARCBDcChAIgBEKEgICACDcC/AEMAwtBfyAJQQhqIgcgByAJSRsiAyAEKAKQASIHKAIESw0BIAcgBygCFEEIaiIDNgIUIAcoAggoAgggA08EQCAEQYqAgIB4NgL8AQwDCyAEQYiAgIB4NgL8AQwCCyAFIAhB0OH+ABCvOwALIARB/AFqIAkgAxC/LwsgBEEPNgKwASAEQaTs/gA2AqwBIARBgICAgHg2AqgBIAQgCTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFCAEKALYASIHQYqAgIB4Rg0BIARBqAFqIARB9AFqKQIANwMAIAQgBCkC7AE3A6ABIAQoAuABIQkgBCgC3AEhAyAEKQLkAQshFiAEQSBqIARBqAFqKQMANwIAIAQgFjcCECAEIAk2AgwgBCADNgIIIAQgBzYCBCAEIAQpA6ABNwIYDAMLIAQgBCkDmAE3AswBIAQgBCkDkAE3AsQBIARB/AFqIARBxAFqQQ4Q3RAgBCgChAIhByAEKAKAAiEDAn8gBCgC/AEiCUGKgICAeEcEQCAEKAKcAiELIAQoApgCIQogBCgCkAIhDiAEKAKMAiEMIAQoAogCIQ8gBCgClAIMAQsgBEH8AWogBEHEAWpBDBDdECAEKAKEAiEFIAQoAoACIQggBCgC/AEiCUGKgICAeEcEQCAEKAKcAiELIAQoApgCIQogBCgCkAIhDiAEKAKMAiEMIAQoAogCIQ8gBSEHIAghAyAEKAKUAgwBCwJAAkAgCEEBcQRAIANBAXENAQwCCyADQQFxDQFBBCEHQYCAgIB4IQxBw+z+ACEOQQAhA0GAgICAeCEJQQsMAgsCQCAFQQFqIgNBfyADGyIIIAQoAsQBIgMoAgRNBEAgAyADKAIUQQFqIgg2AhQgAygCCCgCCCAITwRAIARBioCAgHg2AvwBDAILIARBiICAgHg2AvwBDAELIARB/AFqIAUgCBC/LwsgBEEQNgKwASAEQbPs/gA2AqwBIARBgICAgHg2AqgBIAQgBTYCpAEgBEEBNgKgASAEQdgBaiAEQfwBaiAEQaABahCBFAJAAn8CQAJAAkACQCAEKALYASIJQYqAgIB4RgRAIAUgBCgCxAEiCCgCBCIDSw0CAkACQAJAAkACQCAIKAIAIAVqLQAAQQFrDgMBAgMACyAEQYqAgIB4NgL8AQwDCyAEQfwBaiMAQfABayIDJAAgA0HMAWogCCAHEJMOIAMoAtABIQUCQCADKALMASIJQYqAgIB4RwRAIANBLGogA0HsAWooAgA2AgAgA0EkaiADQeQBaikCADcCACADQRxqIANB3AFqKQIANwIAIAMgAykC1AE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQcwBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQdgBaikCADcDACADIAMpAtABNwMwIAMoAswBIghBioCAgHhHBEAgA0EoaiADQegBaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLgATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANBzAFqIANBQGtBBBDdECADKALUASEJIAMoAtABIQUCQAJ/IAMoAswBIghBioCAgHhHBEAgAykC6AEhFiADKALgASELIAMoAtwBIQogAygC2AEhDCADKALkAQwBCyAFQQFxRQRAQYCAgIB4IQpBpuv+ACELQQQhCUEAIQVBgICAgHghCEELDAELIANBzAFqIgUgAygCQCAJEPgGIANBCzYCkAEgA0Gm6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogBSADQYABahCBFCADKAKoASIIQYqAgIB4Rg0BIAMpAsQBIRYgAygCvAEhCyADKAK4ASEKIAMoArQBIQwgAygCsAEhCSADKAKsASEFIAMoAsABCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQNINwJYIAMgAykDQDcCUCADQcwBaiADQdAAakEGEN0QIAMoAtQBIQkgAygC0AEhBQJAAn4gAygCzAEiCEGKgICAeEcEQCADQbABaiADQegBaikCADcDACADIAMpAuABNwOoASADKQLYAQwBCyAFQQFxRQ0BIANBzAFqIAMoAlAiCCAJEJMOIAMoAtABIQUCQCADKALMASILQYqAgIB4RwRAIANByAFqIANB7AFqKAIANgIAIANBwAFqIANB5AFqKQIANwIAIANBuAFqIANB3AFqKQIANwIAIAMgAykC1AE3ArABIAMgBTYCrAEgAyALNgKoAQwBCyADQcwBaiAIQX8gBSAJaiIIIAUgCEsbEIYOIAMoAswBIgVBioCAgHhHBEAgA0G8AWogA0HgAWopAgA3AgAgA0HEAWogA0HoAWopAgA3AgAgAyADKQLYATcCtAEgAyADKQLQATcCrAELIAMgBTYCqAELIANBDjYC3AEgA0Gx6/4ANgLYASADQYCAgIB4NgLUASADIAk2AtABIANBATYCzAEgA0GAAWogA0GoAWogA0HMAWoQgRQgAygCgAEiCEGKgICAeEYNASADQbABaiADQZwBaikCADcDACADIAMpApQBNwOoASADKAKIASEJIAMoAoQBIQUgAykCjAELIRYgA0EoaiADQbABaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQOoATcCIAwBCyADIAMpAlg3AmggAyADKQJQNwJgIANBzAFqIANB4ABqQQgQ3RAgAygC1AEhCSADKALQASEFAkACfyADKALMASIIQYqAgIB4RwRAIAMpAugBIRYgAygC4AEhCyADKALcASEKIAMoAtgBIQwgAygC5AEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkG/6/4AIQtBACEFQYCAgIB4IQhBDQwBCwJAQX8gCUEQaiIFIAUgCUkbIgggAygCYCIFKAIETQRAIAUgBSgCFEEQaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgLMAQwCCyADQYiAgIB4NgLMAQwBCyADQcwBaiAJIAgQvy8LIANBDTYCkAEgA0G/6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogA0HMAWogA0GAAWoQgRQgAygCqAEiCEGKgICAeEYNASADKQLEASEWIAMoArwBIQsgAygCuAEhCiADKAK0ASEMIAMoArABIQkgAygCrAEhBSADKALAAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMgAykCaDcCeCADIAMpAmA3AnAgA0HMAWogA0HwAGpBChDdECADKALUASEJIAMoAtABIQUCQAJ+IAMoAswBIghBioCAgHhHBEAgA0GIAWogA0HoAWopAgA3AwAgAyADKQLgATcDgAEgAykC2AEMAQsgBUEBcUUNAQJAIAlBAWoiBUF/IAUbIgggAygCcCIFKAIETQRAIAUgBSgCFEEBaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgLMAQwCCyADQYiAgIB4NgLMAQwBCyADQcwBaiAJIAgQvy8LIANBCzYCkAEgA0HM6/4ANgKMASADQYCAgIB4NgKIASADIAk2AoQBIANBATYCgAEgA0GoAWogA0HMAWogA0GAAWoQgRQgAygCqAEiCEGKgICAeEYNASADQYgBaiADQcQBaikCADcDACADIAMpArwBNwOAASADKAKwASEJIAMoAqwBIQUgAykCtAELIRYgA0EoaiADQYgBaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQOAATcCIAwBCyADKAJwIgUgBSgCDEEBazYCDCADQYqAgIB4NgIMCyADQSc2AtwBIANBzuz+ADYC2AEgA0GAgICAeDYC1AEgAyAHNgLQASADQQI2AswBIANBDGogA0HMAWoQgRQgA0HwAWokAAwCCyAEQfwBaiMAQfABayIDJAAgA0G0AWogCCAHEJMOIAMoArgBIQUCQCADKAK0ASIJQYqAgIB4RwRAIANBLGogA0HUAWooAgA2AgAgA0EkaiADQcwBaikCADcCACADQRxqIANBxAFqKQIANwIAIAMgAykCvAE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQbQBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQcABaikCADcDACADIAMpArgBNwMwIAMoArQBIghBioCAgHhHBEAgA0EoaiADQdABaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLIATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANBtAFqIANBQGtBBBDdECADKAK8ASEJIAMoArgBIQUCQAJ+IAMoArQBIghBioCAgHhHBEAgA0HgAWogA0HQAWopAgA3AwAgAyADKQLIATcD2AEgAykCwAEMAQsgBUEBcUUNAQJAIAlBAXEEQCADIAk2AtABIANBAzYCzAEgA0G55P4ANgLIASADQYCAgIB4NgLEASADQgQ3ArwBIANChICAgAg3ArQBDAELQX8gCUECaiIFIAUgCUkbIgggAygCQCIFKAIETQRAIAUgBSgCFEECaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgK0AQwCCyADQYiAgIB4NgK0AQwBCyADQbQBaiAJIAgQvy8LIANBDjYC6AEgA0HX6/4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgA0GQAWogA0G0AWogA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADQeABaiADQawBaikCADcDACADIAMpAqQBNwPYASADKAKYASEJIAMoApQBIQUgAykCnAELIRYgA0EoaiADQeABaikDADcCACADIBY3AhggAyAJNgIUIAMgBTYCECADIAg2AgwgAyADKQPYATcCIAwBCyADIAMpA0g3AlggAyADKQNANwJQIANBtAFqIANB0ABqQQYQ3RAgAygCvAEhCSADKAK4ASEFAkACfyADKAK0ASIIQYqAgIB4RwRAIAMpAtABIRYgAygCyAEhCyADKALEASEKIAMoAsABIQwgAygCzAEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkHl6/4AIQtBACEFQYCAgIB4IQhBCgwBCyADQbQBaiIFIAMoAlAgCRD4BiADQQo2AugBIANB5ev+ADYC5AEgA0GAgICAeDYC4AEgAyAJNgLcASADQQE2AtgBIANBkAFqIAUgA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADKQKsASEWIAMoAqQBIQsgAygCoAEhCiADKAKcASEMIAMoApgBIQkgAygClAEhBSADKAKoAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMgAykCWDcCaCADIAMpAlA3AmAgA0G0AWogA0HgAGpBCBDdECADKAK8ASEJIAMoArgBIQUCQAJ/IAMoArQBIghBioCAgHhHBEAgAykC0AEhFiADKALIASELIAMoAsQBIQogAygCwAEhDCADKALMAQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQe/r/gAhC0EAIQVBgICAgHghCEEMDAELAkBBfyAJQRBqIgUgBSAJSRsiCCADKAJgIgUoAgRNBEAgBSAFKAIUQRBqIgg2AhQgBSgCCCgCCCAITwRAIANBioCAgHg2ArQBDAILIANBiICAgHg2ArQBDAELIANBtAFqIAkgCBC/LwsgA0EMNgLoASADQe/r/gA2AuQBIANBgICAgHg2AuABIAMgCTYC3AEgA0EBNgLYASADQZABaiADQbQBaiADQdgBahCBFCADKAKQASIIQYqAgIB4Rg0BIAMpAqwBIRYgAygCpAEhCyADKAKgASEKIAMoApwBIQwgAygCmAEhCSADKAKUASEFIAMoAqgBCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQJoNwJ4IAMgAykCYDcCcCADQbQBaiADQfAAakEKEN0QIAMoArwBIQkgAygCuAEhBQJAAn8gAygCtAEiCEGKgICAeEcEQCADKQLQASEWIAMoAsgBIQsgAygCxAEhCiADKALAASEMIAMoAswBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpBpuv+ACELQQAhBUGAgICAeCEIQQsMAQsgA0G0AWoiBSADKAJwIAkQ+AYgA0ELNgLoASADQabr/gA2AuQBIANBgICAgHg2AuABIAMgCTYC3AEgA0EBNgLYASADQZABaiAFIANB2AFqEIEUIAMoApABIghBioCAgHhGDQEgAykCrAEhFiADKAKkASELIAMoAqABIQogAygCnAEhDCADKAKYASEJIAMoApQBIQUgAygCqAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAng3AogBIAMgAykCcDcCgAEgA0G0AWogA0GAAWpBDBDdECADKAK8ASEJIAMoArgBIQUCQAJ/IAMoArQBIghBioCAgHhHBEAgAykC0AEhFiADKALIASELIAMoAsQBIQogAygCwAEhDCADKALMAQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQb/r/gAhC0EAIQVBgICAgHghCEENDAELAkBBfyAJQRBqIgUgBSAJSRsiCCADKAKAASIFKAIETQRAIAUgBSgCFEEQaiIINgIUIAUoAggoAgggCE8EQCADQYqAgIB4NgK0AQwCCyADQYiAgIB4NgK0AQwBCyADQbQBaiAJIAgQvy8LIANBDTYC6AEgA0G/6/4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgA0GQAWogA0G0AWogA0HYAWoQgRQgAygCkAEiCEGKgICAeEYNASADKQKsASEWIAMoAqQBIQsgAygCoAEhCiADKAKcASEMIAMoApgBIQkgAygClAEhBSADKAKoAQshECADIBY3AiggAyAQNgIkIAMgCzYCICADIAo2AhwgAyAMNgIYIAMgCTYCFCADIAU2AhAgAyAINgIMDAELIAMoAoABIgUgBSgCDEEBazYCDCADQYqAgIB4NgIMCyADQSc2AsQBIANB9ez+ADYCwAEgA0GAgICAeDYCvAEgAyAHNgK4ASADQQI2ArQBIANBDGogA0G0AWoQgRQgA0HwAWokAAwBCyAEQfwBaiMAQYACayIDJAAgA0HcAWogCCAHEJMOIAMoAuABIQUCQCADKALcASIJQYqAgIB4RwRAIANBLGogA0H8AWooAgA2AgAgA0EkaiADQfQBaikCADcCACADQRxqIANB7AFqKQIANwIAIAMgAykC5AE3AhQgAyAFNgIQIAMgCTYCDAwBCyADQdwBaiAIQX8gBSAHaiIIIAUgCEsbELQGIANBOGoiBSADQegBaikCADcDACADIAMpAuABNwMwIAMoAtwBIghBioCAgHhHBEAgA0EoaiADQfgBaikCADcCACADQRhqIAUpAwA3AgAgAyADKQLwATcCICADIAMpAzA3AhAgAyAINgIMDAELIANByABqIAUpAwA3AwAgAyADKQMwNwNAIANB3AFqIANBQGtBBBDdECADKALkASEJIAMoAuABIQUCQAJ/IAMoAtwBIghBioCAgHhHBEAgAykC+AEhFiADKALwASELIAMoAuwBIQogAygC6AEhDCADKAL0AQwBCyAFQQFxRQRAQYCAgIB4IQpB5ev+ACELQQQhCUEAIQVBgICAgHghCEEKDAELIANB3AFqIgUgAygCQCAJEPgGIANBCjYCpAEgA0Hl6/4ANgKgASADQYCAgIB4NgKcASADIAk2ApgBIANBATYClAEgA0G4AWogBSADQZQBahCBFCADKAK4ASIIQYqAgIB4Rg0BIAMpAtQBIRYgAygCzAEhCyADKALIASEKIAMoAsQBIQwgAygCwAEhCSADKAK8ASEFIAMoAtABCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQNINwJcIAMgAykDQDcCVCADQdwBaiADQdQAakEGEN0QIAMoAuQBIQkgAygC4AEhBQJAAn8gAygC3AEiCEGKgICAeEcEQCADKQL4ASEWIAMoAvABIQsgAygC7AEhCiADKALoASEMIAMoAvQBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpB++v+ACELQQAhBUGAgICAeCEIQQ0MAQsgA0HcAWogAygCVCIIIAkQkw4gAygC4AEhBQJAIAMoAtwBIgtBioCAgHhHBEAgA0HYAWogA0H8AWooAgA2AgAgA0HQAWogA0H0AWopAgA3AgAgA0HIAWogA0HsAWopAgA3AgAgAyADKQLkATcCwAEgAyAFNgK8ASADIAs2ArgBDAELIANB3AFqIAhBfyAFIAlqIgggBSAISxsQyw8gAygC3AEiBUGKgICAeEcEQCADQcwBaiADQfABaikCADcCACADQdQBaiADQfgBaikCADcCACADIAMpAugBNwLEASADIAMpAuABNwK8AQsgAyAFNgK4AQsgA0ENNgLsASADQfvr/gA2AugBIANBgICAgHg2AuQBIAMgCTYC4AEgA0EBNgLcASADQZQBaiADQbgBaiADQdwBahCBFCADKAKUASIIQYqAgIB4Rg0BIAMpArABIRYgAygCqAEhCyADKAKkASEKIAMoAqABIQwgAygCnAEhCSADKAKYASEFIAMoAqwBCyEQIAMgFjcCKCADIBA2AiQgAyALNgIgIAMgCjYCHCADIAw2AhggAyAJNgIUIAMgBTYCECADIAg2AgwMAQsgAyADKQJcNwJsIAMgAykCVDcCZCADQdwBaiADQeQAakEIEN0QIAMoAuQBIQkgAygC4AEhBQJAAn8gAygC3AEiCEGKgICAeEcEQCADKQL4ASEWIAMoAvABIQsgAygC7AEhCiADKALoASEMIAMoAvQBDAELIAVBAXFFBEBBBCEJQYCAgIB4IQpBpuv+ACELQQAhBUGAgICAeCEIQQsMAQsgA0HcAWoiBSADKAJkIAkQ+AYgA0ELNgKkASADQabr/gA2AqABIANBgICAgHg2ApwBIAMgCTYCmAEgA0EBNgKUASADQbgBaiAFIANBlAFqEIEUIAMoArgBIghBioCAgHhGDQEgAykC1AEhFiADKALMASELIAMoAsgBIQogAygCxAEhDCADKALAASEJIAMoArwBIQUgAygC0AELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAmw3AnwgAyADKQJkNwJ0IANB3AFqIANB9ABqQQoQ3RAgAygC5AEhCSADKALgASEFAkACfyADKALcASIIQYqAgIB4RwRAIAMpAvgBIRYgAygC8AEhCyADKALsASEKIAMoAugBIQwgAygC9AEMAQsgBUEBcUUEQEEEIQlBgICAgHghCkGI7P4AIQtBACEFQYCAgIB4IQhBDgwBCyADQdwBaiADKAJ0IgggCRCTDiADKALgASEFAkAgAygC3AEiC0GKgICAeEcEQCADQdgBaiADQfwBaigCADYCACADQdABaiADQfQBaikCADcCACADQcgBaiADQewBaikCADcCACADIAMpAuQBNwLAASADIAU2ArwBIAMgCzYCuAEMAQsgA0HcAWogCEF/IAUgCWoiCCAFIAhLGxDLDyADKALcASIFQYqAgIB4RwRAIANBzAFqIANB8AFqKQIANwIAIANB1AFqIANB+AFqKQIANwIAIAMgAykC6AE3AsQBIAMgAykC4AE3ArwBCyADIAU2ArgBCyADQQ42AuwBIANBiOz+ADYC6AEgA0GAgICAeDYC5AEgAyAJNgLgASADQQE2AtwBIANBlAFqIANBuAFqIANB3AFqEIEUIAMoApQBIghBioCAgHhGDQEgAykCsAEhFiADKAKoASELIAMoAqQBIQogAygCoAEhDCADKAKcASEJIAMoApgBIQUgAygCrAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADIAMpAnw3AowBIAMgAykCdDcChAEgA0HcAWogA0GEAWpBDBDdECADKALkASEJIAMoAuABIQUCQAJ/IAMoAtwBIghBioCAgHhHBEAgAykC+AEhFiADKALwASELIAMoAuwBIQogAygC6AEhDCADKAL0AQwBCyAFQQFxRQRAQQQhCUGAgICAeCEKQZbs/gAhC0EAIQVBgICAgHghCEEJDAELIANB3AFqIAMoAoQBIgggCRCTDiADKALgASEFAkAgAygC3AEiC0GKgICAeEcEQCADQdgBaiADQfwBaigCADYCACADQdABaiADQfQBaikCADcCACADQcgBaiADQewBaikCADcCACADIAMpAuQBNwLAASADIAU2ArwBIAMgCzYCuAEMAQsgA0HcAWogCEF/IAUgCWoiCCAFIAhLGxCIDiADKALcASIFQYqAgIB4RwRAIANBzAFqIANB8AFqKQIANwIAIANB1AFqIANB+AFqKQIANwIAIAMgAykC6AE3AsQBIAMgAykC4AE3ArwBCyADIAU2ArgBCyADQQk2AuwBIANBluz+ADYC6AEgA0GAgICAeDYC5AEgAyAJNgLgASADQQE2AtwBIANBlAFqIANBuAFqIANB3AFqEIEUIAMoApQBIghBioCAgHhGDQEgAykCsAEhFiADKAKoASELIAMoAqQBIQogAygCoAEhDCADKAKcASEJIAMoApgBIQUgAygCrAELIRAgAyAWNwIoIAMgEDYCJCADIAs2AiAgAyAKNgIcIAMgDDYCGCADIAk2AhQgAyAFNgIQIAMgCDYCDAwBCyADKAKEASIFIAUoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0EnNgLsASADQZzt/gA2AugBIANBgICAgHg2AuQBIAMgBzYC4AEgA0ECNgLcASADQQxqIANB3AFqEIEUIANBgAJqJAALIARBCzYCsAEgBEHD7P4ANgKsASAEQYCAgIB4NgKoASAEIAc2AqQBIARBATYCoAEgBEHYAWogBEH8AWogBEGgAWoQgRQgBCgC2AEiCUGKgICAeEYNAQsgBCgC+AEhCyAEKAL0ASEKIAQoAuwBIQ4gBCgC6AEhDCAEKALkASEPIAQoAuABIQcgBCgC3AEhAyAEKALwAQwHCyAEIAQpAswBNwJEIAQgBCkCxAE3AjwgBEH8AWogBEE8akEQEN0QIAQoAoQCIQkgBCgCgAIhAyAEKAL8ASIHQYqAgIB4RwRAIAQpApgCIRcgBCgClAIhCyAEKAKQAiEKIAQoAogCIQ4gBCgCjAIMBAsgA0EBcUUEQEHp5v4AIQpBBCELQQQhCUEAIQNBgICAgHghB0GAgICAeAwEC0F/IAlBEGoiByAHIAlJGyIDIAQoAjwiBygCBEsNASAHIAcoAhRBEGoiAzYCFCAHKAIIKAIIIANPBEAgBEGKgICAeDYC/AEMAwsgBEGIgICAeDYC/AEMAgsgBSADQdDh/gAQrzsACyAEQfwBaiAJIAMQvy8LIARBBDYCsAEgBEHp5v4ANgKsASAEQYCAgIB4NgKoASAEIAk2AqQBIARBATYCoAEgBEHYAWogBEH8AWogBEGgAWoQgRQgBCgC2AEiB0GKgICAeEYNASAEKQL0ASEXIAQoAvABIQsgBCgC7AEhCiAEKALkASEOIAQoAuABIQkgBCgC3AEhAyAEKALoAQshBSAEIBc3AiAgBCALNgIcIAQgCjYCGCAEIAU2AhQgBCAONgIQIAQgCTYCDCAEIAM2AgggBCAHNgIEDAULIAQoAjwiByAHKAIMQQFrNgIMIARBioCAgHg2AgQMBAtBBCEDQQAhB0Gz7P4AIQxBECEOQcPs/gAhCkELIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAONgIYIAQgDDYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQMAgtBBCEDQQAhB0H55/4AIQxBCSEOQYLo/gAhCkEFIQtBgICAgHghD0EAIQlBgICAgHgLIQUgBCALNgIkIAQgCjYCICAEIAU2AhwgBCAONgIYIAQgDDYCFCAEIA82AhAgBCAHNgIMIAQgAzYCCCAEIAk2AgQLIARBGzYCjAIgBEHD+P4ANgKIAiAEQYCAgIB4NgKEAiAEIA02AoACIARBAjYC/AEgBEEEaiAEQfwBahCBFCAEQaACaiQACyAGQQY2AsgBIAZBwvf+ADYCxAEgBkGAgICAeDYCwAEgBiANNgK8ASAGQQE2ArgBIAZBlAJqIAZByAJqIAZBuAFqEIEUIAZB4AFqIQ0gBigClAIiA0GKgICAeEYNASANIAYpApgCNwIAIA1BGGogBkGwAmopAgA3AgAgDUEQaiAGQagCaikCADcCACANQQhqIAZBoAJqKQIANwIADAMLIAUgA0H09P4AEK87AAsgDUEIaiAGQcgAaikCADcCACANIAYpAkA3AgAgBiAGKQLoATcCWCAGIAYpAuABNwJQIAZByAJqIAZB0ABqQQoQ3RAgBigC0AIhByAGKALMAiENIAYoAsgCIgNBioCAgHhHBEAgBkHAAWogBkHkAmopAgA3AwAgBiAGKQLcAjcDuAEgBikC1AIhFgwECwJAIA1BAXFFDQACQCAHQQdxBEAgBiAHNgLkAiAGQQM2AuACIAZBwPb+ADYC3AIgBkGAgICAeDYC2AIgBkIENwLQAiAGQoSAgIAINwLIAgwBC0F/IAdBCGoiAyADIAdJGyINIAYoAlAiAygCBE0EQCADIAMoAhRBCGoiDTYCFCADKAIIKAIIIA1PBEAgBkGKgICAeDYCyAIMAgsgBkGIgICAeDYCyAIMAQsgBkHIAmogByANEL8vCyAGQQo2AuwBIAZByPf+ADYC6AEgBkGAgICAeDYC5AEgBiAHNgLgASAGQQE2AtwBIAZBlAJqIAZByAJqIAZB3AFqEIEUIAYoApQCIgNBioCAgHhGDQAMAwsgBiAGKQJYNwJoIAYgBikCUDcCYCAGQcgCaiAGQeAAakEMEN0QIAYoAtACIQcgBigCzAIhDSAGKALIAiIDQYqAgIB4RwRAIAZBwAFqIAZB5AJqKQIANwMAIAYgBikC3AI3A7gBIAYpAtQCIRYMBAsCQCANQQFxRQ0AIAZByAJqIAYoAmAiCyAHEJQOIAYoAswCIQMCQCAGKALIAiINQYqAgIB4RwRAIAZBtAJqIAZB6AJqKAIANgIAIAZBrAJqIAZB4AJqKQIANwIAIAZBpAJqIAZB2AJqKQIANwIAIAYgBikC0AI3ApwCIAYgAzYCmAIgBiANNgKUAgwBCyAGQcgCaiALQX8gAyAHaiINIAMgDUsbEIcOIAYoAtACIQMgBigCzAIhDSAGKALIAiIFQYqAgIB4RwRAIAZBsAJqIAZB5AJqKQIANwIAIAZBqAJqIAZB3AJqKQIANwIAIAYgBikC1AI3AqACIAYgAzYCnAIgBiANNgKYAiAGIAU2ApQCDAELIAMgDWsiBUEAIAMgBU8bIgNBAnYgA0EDcUEAR2oiBQRAIA1Bf3MhA0EAIAVrIRUgBkHwAWohDCAGQeQBaiEOIAZBqAJqIQ8gBkGYAmohEiAGQcwBaiEFIAZB3AJqIRAgBkHMAmohEyAGQbwBaiEJIAZBwAFqIQggBkHQAmohBANAIAZByAJqIAsgDRCUDiAGKALMAiEKAkAgBigCyAIiEUGKgICAeEcEQCAIIAQpAgA3AgAgCEEYaiAEQRhqKAIANgIAIAhBEGogBEEQaikCADcCACAIQQhqIARBCGopAgA3AgAgBiAKNgK8ASAGIBE2ArgBDAELIAZByAJqIAsgCiADIAMgCksbIA1qELUGIAZBwAJqIgogE0EIaikCADcDACAGIBMpAgA3A7gCIAYoAsgCIhFBioCAgHhHBEAgBSAQKQIANwIAIAVBCGogEEEIaikCADcCACAJQQhqIAopAwA3AgAgCSAGKQO4AjcCACAGIBE2ArgBDAELIAZB+AJqIAopAwA3AwAgBiAGKQO4AjcD8AIgBkGUAmogBkHwAmpB3vj+AEEDQQQQrgggBkGIAmoiCiASQQhqKQIANwMAIAYgEikCADcDgAIgBigClAIiEUGKgICAeEcEQCAFIA8pAgA3AgAgBUEIaiAPQQhqKQIANwIAIAlBCGogCikDADcCACAJIAYpA4ACNwIAIAYgETYCuAEMAQsgBCAKKQMANwMAIAYgBikDgAI3A8gCIAZB3AFqIAZByAJqQeH4/gBBBUEGEK4IIAYoAuABIQogBigC3AEiEUGKgICAeEcEQCAIIA4pAgA3AgAgBSAMKQIANwIAIAhBCGogDkEIaigCADYCACAFQQhqIAxBCGopAgA3AgAgBiAKNgK8ASAGIBE2ArgBDAELIAogCigCDEEBazYCDCAGQYqAgIB4NgK4AQsgBiANNgLQAiAGIBQ2AswCIAZBADYCyAIgBkGUAWogBkG4AWogBkHIAmoQgRQgBigClAEiCkGKgICAeEcEQCAGQbACaiAGQbABaikCADcCACAGQagCaiAGQagBaikCADcCACAGQaACaiAGQaABaikCADcCACAGIAYpApgBNwKYAiAGIAo2ApQCDAMLIA1BBGohDSADQQRrIQMgFSAUQQFqIhRqDQALCyAGQYqAgIB4NgKUAgsgBkEPNgLYAiAGQdL3/gA2AtQCIAZBgICAgHg2AtACIAYgBzYCzAIgBkEBNgLIAiAGQfAAaiAGQZQCaiAGQcgCahCBFCAGKAJwIgNBioCAgHhGDQAgBkHAAWogBkGMAWopAgA3AwAgBiAGKQKEATcDuAEgBikCfCEWIAYoAnghByAGKAJ0IQ0MBAsgBigCYCIHIAcoAgxBAWs2AgwgAkEDSwRAIAAgAjYCCCAAIAE2AgQgAEGKgICAeDYCACAAIAEoAAA2AgwMBQtBBCACQfD2/gAQsDsACyAGQQY2AvwBIAZBwvf+ADYC+AEgBkKLgICAgICAgIB/NwLwASAGQbf3/gA2AuwBIAZBgICAgHg2AugBIAZCBDcC4AFBACEDCyAGQcABaiAGQfgBaikCADcDACAGIAYpAvABNwO4ASAGKQLoASEWIAYoAuQBIQcgBigC4AEhDQwBCyAGQcABaiAGQbACaikCADcDACAGIAYpAqgCNwO4ASAGKQKgAiEWIAYoApwCIQcgBigCmAIhDQsgACAWNwIMIAAgBzYCCCAAIA02AgQgACADNgIAIAAgBikDuAE3AhQgAEEcaiAGQcABaikDADcCAAsgBkGAA2okAAv4GgIDfwN+IwBBoARrIgUkACAFIAI2AhAgBSABNgIMIAUgAzYCFAJAAkACQCAELQAAQSlHBEAgBUEgaiAEQQhqKAIANgIAIAUgBCkCADcDGAwBCyAFQagBaiADQQhqEIsFIAUoAtwBIgNBgICAgHhGBEAgBUGAAWogBUG4AWopAwAiCDcDACAFQfgAaiAFQbABaikDACIJNwMAIAUgBSkDqAEiCjcDcCAAQRBqIAg3AwAgAEEIaiAJNwMAIAAgCjcDACAFKAIUIgAgACgCACIAQQFrNgIAIABBAUYEQCAFQRRqENkhCyAFQQxqELwqDAILIAVB8ABqIAVBqAFqQTT8CgAAIAVB6ABqIAVB6AFqKQMANwMAIAUgBSkD4AE3A2AgBUEoaiIEIAVB8ABqQTT8CgAAIAUgAzYCXCAFQRhqIAVB0ABqEMIGIAQQgC8LAkACQCAFLQAYQSJGBEAgBSgCICEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUoAhwtAABBAmsOCAABAgMEBQYHCAsgAy0AACIDQRlLDQdBASADdCIDQYCAwAlxDQggA0GAgIAScUUNByAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEH8y80AIQMMEwsgAy0AACIDQRlLDQZBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBiAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHMzM0AIQMMEgsgAy0AACIDQRlLDQVBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBSAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGczc0AIQMMEQsgAy0AACIDQRlLDQRBASADdCIDQYCAwAlxDQggA0GAgIAScUUNBCAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHszc0AIQMMEAsgAy0AACIDQRlLDQNBASADdCIDQYCAwAlxDQggA0GAgIAScUUNAyAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEG8zs0AIQMMDwsgAy0AACIDQRlLDQJBASADdCIDQYCAwAlxDQggA0GAgIAScUUNAiAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGMz80AIQMMDgsgAy0AACIDQRlLDQFBASADdCIDQYCAwAlxDQggA0GAgIAScUUNASAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEHcz80AIQMMDQsgAy0AACIDQRlLDQBBASADdCIDQYCAwAlxDQggA0GAgIAScQ0JCyAFQQE2AqwBIAVBkNHNADYCqAEMCgsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQwgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBB1MvNACEDDAoLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0LIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQaTMzQAhAwwJCyAFQagBaiIDIAUoAhQQhxMgBUE4aiIGIAVBIGooAgA2AgAgBSAFKQMYNwMwQagDQQgQrTYiBEUNCiAEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAVBMGopAwA3AwAgBEGgA2ogBigCADYCAEH0zM0AIQMMCAsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQkgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBBxM3NACEDDAcLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0IIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQZTOzQAhAwwGCyAFQagBaiIDIAUoAhQQhxMgBUE4aiIGIAVBIGooAgA2AgAgBSAFKQMYNwMwQagDQQgQrTYiBEUNByAEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAVBMGopAwA3AwAgBEGgA2ogBigCADYCAEHkzs0AIQMMBQsgBUGoAWoiAyAFKAIUEIcTIAVBOGoiBiAFQSBqKAIANgIAIAUgBSkDGDcDMEGoA0EIEK02IgRFDQYgBCADQfgC/AoAACAEQYCAgIB4NgKMAyAEQYCAgIB4NgKAAyAEIAI2AvwCIAQgATYC+AIgBCAFKQMoNwOQAyAEQZgDaiAFQTBqKQMANwMAIARBoANqIAYoAgA2AgBBtM/NACEDDAQLIAVBqAFqIgMgBSgCFBCHEyAFQThqIgYgBUEgaigCADYCACAFIAUpAxg3AzBBqANBCBCtNiIERQ0FIAQgA0H4AvwKAAAgBEGAgICAeDYCjAMgBEGAgICAeDYCgAMgBCACNgL8AiAEIAE2AvgCIAQgBSkDKDcDkAMgBEGYA2ogBUEwaikDADcDACAEQaADaiAGKAIANgIAQYTQzQAhAwwDCyAFQagBaiIDIAUoAhQQhhMgBUE4aiIGIAVBIGooAgA2AgAgBUEwaiIHIAUpAxg3AwBBqANBCBCmLyIEIANB+AL8CgAAIARBgICAgHg2AowDIARBgICAgHg2AoADIAQgAjYC/AIgBCABNgL4AiAEIAUpAyg3A5ADIARBmANqIAcpAwA3AwAgBEGgA2ogBigCADYCAEGs0M0AIQMMAgsgBUEBNgKsASAFQdzRzQA2AqgBCyAFQgE3ArQBIAVBrQM2AiwgBSAFQShqNgKwASAFIAVBGGoiATYCKCAAQQRqIAVBqAFqEJkOIABBADYCACABEJUMIAUoAhQiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBFGoQ2SELIAVBDGoQvCoMAQsgACADNgIIIAAgBDYCBCAAQQg2AgALIAVBoARqJAAPC0EIQagDEKM9AAu5KgIOfwJ+IwBBoAFrIgIkACABKAIoIQUgASgCJCELIAJBIGogAUEYaiIKEOYLAkACQCACLQAsQQEgASgCLCIOGwRAAkAgASgCCCIJIAIoAigiA0kNACADIAlHBEAgAi0ALUEBcUUNAQsgBSALaiEEIAEoAgQhDSADRQ0CIARBA3YgBEEHcUEAR2ohDCANQQRqIQUgAigCJEEIaiEGIAStIRADQCACIAc2ApwBAkACQAJAAkACQAJAAkAgBkEIaygCAEEBaw4DBgAGAQsgAiAMNgI4IAVBBGooAgAiCCAMSQ0BDAULIAIgBjYCMCACQX8gECAGQQRrNQIAfiIRpyARQiCIpxsiCDYCNCAIIAVBBGooAgAiD0sNAiAGKAIAIghpQQFHDQEgBSgCACAIEPgvIghFDQQgAiAGKAIAIAhrIgEgCCABIAhJGzYCkAEgAkHQ6oYBNgJ4IAJCBDcChAEgAkE7NgJoIAJB3AE2AmAgAkHzGzYCWCACIAo2AlQgAkE7NgJQIAJBBDYCfCACIAJBzABqNgKAASACIAJBkAFqNgJkIAIgAkEwajYCXCACIAJBnAFqNgJMDAMLIAIgCDYCkAEgAkHc64YBNgJ4IAJCBDcChAEgAkE7NgJoIAJB8xs2AmAgAiAKNgJcIAJBOzYCWCACQTs2AlAgAkEENgJ8IAIgAkHMAGo2AoABIAIgAkGQAWo2AmQgAiACQZwBajYCVCACIAJBOGo2AkwMAgsgAkEANgJcIAJBATYCUCACQbDahgE2AkwgAkIENwJUIAJBzABqQbjahgEQ7ywACyACIA82ApABIAJBnOuGATYCeCACQgQ3AoQBIAJBOzYCaCACQfMbNgJgIAIgCjYCXCACQTs2AlggAkE7NgJQIAJBBDYCfCACIAJBzABqNgKAASACIAJBkAFqNgJkIAIgAkGcAWo2AlQgAiACQTRqNgJMCyAAQQRqIAJB+ABqEJkOIABBjYCAgHg2AgAMBQsgBUEMaiEFIAZBDGohBiADIAdBAWoiB0cNAAsMAgsgAiADNgKcASACIAk2ApABIAJBAzYCfCACQajshgE2AnggAkIDNwKEASACQTs2AmAgAkHzGzYCWCACIAo2AlQgAkE7NgJQIAIgAkHMAGo2AoABIAIgAkGQAWo2AlwgAiACQZwBajYCTCAAQQRqIAJB+ABqEJkOIABBjYCAgHg2AgAMAgsgAkECNgJQIAJBgOeGATYCTCACQgE3AlggAkHzGzYCfCACIAo2AnggAiACQfgAajYCVCAAQQRqIAJBzABqEJkOIABBjYCAgHg2AgAMAQsgAUEkaiEIAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA4EQCABKAJAIgUgC0sNASACQRhqIAFBLGoQ3DsgAiACKAIcIgU2AjwgAiAEQQN2IARBB3FBAEdqIgc2AkAgBSAHSQ0CIAEoAjwiBSALRw0DCwJAAkACQAJAAkACQAJAAkACQCAKLQAAIgxBG2sODgcAAQIDBAUGDAwMDAcIDAsgAkHMAGoiBCABIAEoAhxBMGoQvSMgAigCUCEFIAIoAkwiB0GTgICAeEcNGyAFKAIkIQ1BACEJIwBB0ABrIgMkACADQThqIAEiB0EAIAEoAiQiBRCfESADKAJAIQsgAygCPCEBAkAgAygCOCIGQZOAgIB4RwRAIAQgAykCRDcCDCAEIAs2AgggBCABNgIEIAQgBjYCAAwBCyADQThqIAdBASAFEJ8RIAMoAkAhCCADKAI8IQUgAygCOCIGQZOAgIB4RwRAIAQgAykCRDcCDCAEIAg2AgggBCAFNgIEIAQgBjYCAAwBCwJAIA1FDQAgBSEGIAEhCgJAA0AgAyAJNgIEAkAgCCAJRwRAIAUoAgAiDEEATg0BIANBAzYCJCADQbDxhgE2AiAgA0IDNwIsIANBrQM2AkwgAyAHQRhqNgJIIANBnAM2AkQgAyAGNgJAIANBOzYCPCADIANBOGo2AiggAyADQQRqNgI4IANBEGogA0EgahCZDiAEIAMpAhQ3AgggBEEQaiADQRxqKAIANgIAIAQgAygCEDYCBCAEQY2AgIB4NgIADAULIAggCEHo74YBEMMhAAsgAyAMNgIIIAkgC0YNASABKAIAIg5BAEgEQCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQZwDNgJEIAMgCjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwECyANIAwgDmpPBEAgBUEEaiEFIAZBBGohBiABQQRqIQEgCkEEaiEKIA0gCUEBaiIJRw0BDAMLCyADQQM2AiQgA0GA8YYBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQTs2AkQgA0E7NgI8IAMgA0E4ajYCKCADIANBBGo2AkAgAyADQQhqNgI4IARBBGogA0EgahCZDiAEQY2AgIB4NgIADAILIAsgC0H474YBEMMhAAsgBEGTgICAeDYCAAsgA0HQAGokACACKAJMIgdBk4CAgHhGDRkMGgsgAiABQRxqNgJEIAJBzABqIgQgASABKAIgQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRogASgCHCIHQR92IQMgAkHEAGohCSMAQUBqIgYkAAJAIAMEQCAGQQI2AhwgBkHA94YBNgIYIAZCAjcCJCAGQakINgI8IAYgCTYCOCAGQa0DNgI0IAYgAUEYajYCMCAGIAZBMGo2AiAgBkEIaiAGQRhqEJkOIAZBjYCAgHg2AgQgBCAGKQIENwIAIARBCGogBkEMaikCADcCACAEQRBqIAZBFGooAgA2AgAMAQsgBEGTgICAeDYCACAEIAc2AgQLIAZBQGskACACKAJQIQQgAigCTCIHQZOAgIB4RwRAIAIoAlwhASACKQJUIRAgBCEFDBwLIAIgBDYCnAEgC60gBK1+IhBCIIinDREgBSgCJCAQp08NGCACQQQ2AnwgAkH48oYBNgJ4IAJCBDcChAEgAkGtAzYCaCACIAo2AmQgAkE7NgJgIAJBOzYCWCACIAg2AlQgAkE7NgJQIAIgBUEkajYCTCACIAJBzABqNgKAASACIAJBnAFqNgJcIAJBkAFqIAJB+ABqELsYDBULIAJBzABqIgQgASABKAIcQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRkgBCABIAUoAiQQ5wggAigCTCIHQZOAgIB4Rw0YDBcLIAJBzABqIgQgASABKAIcQTBqEL0jIAIoAlAhBSACKAJMIgdBk4CAgHhHDRggBSgCJCENQQAhCSMAQdAAayIDJAAgA0E4aiABIgdBACABKAIkIgUQnhEgAygCQCELIAMoAjwhAQJAIAMoAjgiBkGTgICAeEcEQCAEIAMpAkQ3AgwgBCALNgIIIAQgATYCBCAEIAY2AgAMAQsgA0E4aiAHQQEgBRCeESADKAJAIQggAygCPCEFIAMoAjgiBkGTgICAeEcEQCAEIAMpAkQ3AgwgBCAINgIIIAQgBTYCBCAEIAY2AgAMAQsCQCANRQ0AIAUhBiABIQoCQAJAA0ACQCAIIAlHBEAgBSkDACIQQoCAgIAQVA0BIAMgCTYCBCADQQM2AiQgA0Gw8YYBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQe4GNgJEIAMgBjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwGCyAIIAhB6O+GARDDIQALIAMgEKciDDYCCCAJIAtGDQEgASkDACIQQoCAgIAQWgRAIAMgCTYCBCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgB0EYajYCSCADQe4GNgJEIAMgCjYCQCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGNgICAeDYCAAwFCyAMIAwgEKdqIg5LDQIgDSAOTwRAIAVBCGohBSAGQQhqIQYgAUEIaiEBIApBCGohCiANIAlBAWoiCUcNAQwECwsgAyAJNgIEIANBAzYCJCADQYDxhgE2AiAgA0IDNwIsIANBrQM2AkwgAyAHQRhqNgJIIANBOzYCRCADQTs2AjwgAyADQThqNgIoIAMgA0EEajYCQCADIANBCGo2AjggBEEEaiADQSBqEJkOIARBjYCAgHg2AgAMAwsgCyALQfjvhgEQwyEAC0GI8IYBQTBBuPCGARDLJAALIARBk4CAgHg2AgALIANB0ABqJAAgAigCTCIHQZOAgIB4Rw0XDBYLIAJBCGogAUEcaiIFEMM0IAJBzABqIAEgAigCDBCRGiACKAJMIgdBk4CAgHhHDRYgAiAFEMM0IAIoAgRBAnQhAyACKAIAQQRrIQRBACEFA0AgA0UNCSACIAU2AkggAkHMAGoiBiABIAUgBEEEaiIEKAIAQTBqEMUOIAIoAkwiB0GTgICAeEcNFyADQQRrIQMgBUEBaiEFIAIoAlAiBygCJCALTw0ACyACIAQoAgBBPGo2ApwBIAJBBjYCfCACQezzhgE2AnggAkIFNwKEASACQTs2AnAgAiAINgJsIAJBOzYCaCACIAdBJGo2AmQgAkH0GzYCYCACQTs2AlggAkGtAzYCUCACIAo2AkwgAiAGNgKAASACIAJBnAFqNgJcIAIgAkHIAGo2AlQgAkGQAWogAkH4AGoQuxgMEgsgAkHMAGogASABQRxqIgUoAgQQkRogAigCTCIHQZOAgIB4Rw0VIAJBEGogBRCwLiACKAIQIgMgAigCFCIKRg0UQQAhBiABLQAZIQsDQCACIAY2AnQgAkHMAGogASAGIANBBGooAgBBMGoQxQ4gAigCUCEFIAIoAkwiB0GTgICAeEcNFwJAIAtFBEAgBSgCJCAESQ0BCyAGQQFqIQYgA0EIaiIDIApHDQEMCQsLIAIgBDYCnAEgAkEENgJ8IAJB7PSGATYCeCACQgM3AoQBIAJBOzYCYCACQTs2AlggAiAFQSRqNgJUIAJBOzYCUCACIAJBzABqNgKAASACIAJBnAFqNgJcIAIgAkH0AGo2AkwgAkGQAWogAkH4AGoQuxgMEQsgAkHMAGogASABKAIgEL0jIAIoAkwiB0GTgICAeEcNFAwSCyACQcwAaiIEIAEgASgCHEEwahC9IyACKAJQIQUgAigCTCIHQZOAgIB4Rw0UIAQgASAFKAIkEOwIIAIoAkwiB0GTgICAeEcNEwwFCyACQcwAaiIEIAFBAhCRGiACKAJMIgdBk4CAgHhHDRIgBCABQQAgASgCHCIGQTBqEMUOIAIoAlAhBSACKAJMIgdBk4CAgHhHDRMgBCABQQEgASgCIEEwahDFDiACKAJQIQQgAigCTCIHQZOAgIB4RwRAIAIoAlwhASACKQJUIRAgBCEFDBULIAUoAiQgBCgCJEYEQCAFKAIsRQ0GIAJBzABqQYz1hgFB1AAQjSAgAikCUCEQIAIoAkwMEAsgAkECNgJQIAJB2PaGATYCTCACQgI3AlggAkE7NgKEASACIARBJGo2AoABIAJBOzYCfCACIAVBJGo2AnggAiACQfgAajYCVCACQZABaiACQcwAahC7GAwOCyACIAU2ApABIAJBAzYCUCACQYDohgE2AkwgAkICNwJYIAJBOzYChAEgAiAINgKAASACQTs2AnwgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQmQ4gAEGNgICAeDYCAAwUCyACQQI2AlAgAkHM44YBNgJMIAJCAjcCWCACQTs2AoQBIAJBOzYCfCACIAJB+ABqNgJUIAIgAkFAazYCgAEgAiACQTxqNgJ4IABBBGogAkHMAGoQmQ4gAEGNgICAeDYCAAwTCyACIAU2ApABIAJBAjYCUCACQbznhgE2AkwgAkICNwJYIAJBOzYChAEgAiAINgKAASACQTs2AnwgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQuxggAEGNgICAeDYCAAwSCyABKAIUIgUNCQsCQCAMQRRrDgYCDQMNAgMACyAMQSJGDQsgDEEoRw0MIAEoAhwhBgsgBi0ASA0CIAYtADBBA2tB/wFxQQNPDQMMCwsgCUEBTQ0EIAJBzABqIAEgDSgCFBDsCCACKAJMIgFBk4CAgHhGDQogACACKQJQNwIEIABBDGogAkHYAGopAgA3AgAgACABNgIADA4LIAlBAU0NBCACQcwAaiABIA0oAhQQ5wggAigCTCIBQZOAgIB4Rg0JIAAgAikCUDcCBCAAQQxqIAJB2ABqKQIANwIAIAAgATYCAAwNCyAAQQRqQbjphgFBygAQjSAgAEGNgICAeDYCAAwMCyACQQE2AlAgAkGw6YYBNgJMIAJCATcCWCACQacENgJ8IAIgBkEwajYCkAEgAiACQfgAajYCVCACIAJBkAFqNgJ4IABBBGogAkHMAGoQuxggAEGNgICAeDYCAAwLC0HI8YYBQc4AQZjyhgEQyyQAC0EBIAlBmOiGARDDIQALQQEgCUGo6IYBEMMhAAsgAiAFNgKcASACQQI2AlAgAkGU94YBNgJMIAJCAjcCWCACQTs2AoQBIAJBrQM2AnwgAiAKNgJ4IAIgAkH4AGo2AlQgAiACQZwBajYCgAEgAkGQAWogAkHMAGoQuxgLIAIpApQBIRAgAigCkAELIQVBjYCAgHghBwwECyACIAFBHGo2ApABIAEoAhwtAABBAmtB/wFxQQhJDQAgAkEBNgJQIAJB6OiGATYCTCACQgE3AlggAkHFEzYCfCACIAJB+ABqNgJUIAIgAkGQAWo2AnggAEEEaiACQcwAahC7GCAAQY2AgIB4NgIADAQLIABBk4CAgHg2AgAMAwsgAigCXCEBIAIpAlQhECACKAJQIQUMAQsgAigCXCEBIAIpAlQhEAsgACABNgIQIAAgEDcCCCAAIAU2AgQgACAHNgIACyACQSBqQQRBDBDgHiACQaABaiQAC9EYAgd+CH8jAEHQAWsiCiQAAkACQAJAAkAgAQRAIAogATYCCCAKIAI2AgwCQCACQQ1PBEAgACgCCCELIABBADYCCCALDQEMBQsgCkEANgIYIApCADcDECACBEAgCkEQaiABIAL8CgAACyAKNQIYIQMgCikDECEFIAAoAkAiASAAKAI4RgRAIABBOGpBoOuAARCxKAsgACgCPCABQQR0aiILIAM+AgwgCyAFNwIEIAsgAjYCACAAIAFBAWo2AkAgACgCXARAIAAoAmwiC0EBaiIMQQN2IAxBB3FBAEdqIgIgACgCaCIBSwRAIAIgAWshDSAAKAJgIg4gAkkEQCAAQdwAaiAOQQF0IgEgAhDQKiIOIAEgDksbEOgZIAAoAmghAQsgDQRAIAAoAmQgAWpBACAN/AsACyAAIAI2AmgLIAAgDDYCbCAAKAJkIAtBA3ZqIgAgAC0AAEEBIAtBB3F0cjoAAAwGCyAAIAAoAnBBAWo2AnAMBQsgCkE0aiAAQRRqKAIANgIAIApBQGsgAEEgaikDACIDNwMAIApByABqIABBKGopAwAiCDcDACAKQdAAaiAAQTBqKQMAIgc3AwAgCiALNgIoIAogACkCDDcCLCAKIAApAxgiBTcDOCADIAKtIgaFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIAZ8Qq3+1eTUhf2o2AB+IQMCQCACQRBNBEAgAyAFfCABKQAAIAiFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASACakEIaykAACAHhSIEQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAN+hUIXiSEDDAELIAMgBXwgCCABIAJqQRBrIgspAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgByALKQAIhSIEQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAN+hUIXiSEDIAdCf4UhBiABIQwgAiELA0AgAyAFfCAIIAwpAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgDCkACCIJIAaFfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhSADIAcgCYUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhH6FQheJIQMgDEEQaiEMIAtBEGsiC0EQSw0ACwsgAEEIaiELIApB2ABqIApBKGogAyAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEfiADQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAVCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhISFIAOJIAAgCkEIaiAKQThqEPoNIAooAlhBAUYEQCAKKAJsIgwoAgAiDSAKKAJoIg5qIg8tAAAhECAAKAJAIREgDyAKKAJgQRl2Ig86AAAgDSAMKAIEIA5BCGtxakEIaiAPOgAAIAwgDCgCDEEBajYCDCAMIAwoAgggEEEBcWs2AgggDSAOQQJ0a0EEayARNgIAIApBqAFqIApBMGopAgA3AwAgCiAKKQIoNwOgASAKQcgBaiAKQdAAaikDADcDACAKQcABaiAKQcgAaikDADcDACAKQbgBaiAKQUBrKQMANwMAIAogCikDODcDsAEgACgCCARAIAsQjjsLIAsgCkGgAWpBMPwKAAAMBAsgCigCaEEEaygCACIMIAAoAkAiAU8NASAAKAI8IgIgDEEEdGoiDCkDCCEDIAwpAwAhBSAAKAI4IAFGBH8gAEE4akHg6oABELEoIAAoAjwFIAILIAFBBHRqIgIgAzcDCCACIAU3AwAgACABQQFqNgJAAkAgACgCXARAIAAoAmwiDEEBaiINQQN2IA1BB3FBAEdqIgEgACgCaCICSwRAIAEgAmshDiAAKAJgIg8gAUkEQCAAQdwAaiAPQQF0IgIgARDQKiIPIAIgD0sbEOgZIAAoAmghAgsgDgRAIAAoAmQgAmpBACAO/AsACyAAIAE2AmgLIAAgDTYCbCAAKAJkIAxBA3ZqIgAgAC0AAEEBIAxBB3F0cjoAAAwBCyAAIAAoAnBBAWo2AnALIApB+ABqIApBMGopAgA3AwAgCkGIAWogCkFAaykDADcDACAKQZABaiAKQcgAaikDADcDACAKQZgBaiAKQdAAaikDADcDACAKIAopAig3A3AgCiAKKQM4NwOAASALKAIABEAgCxCOOwsgCyAKQfAAakEw/AoAAAwECyAAQdwAaiINEOY6IAAoAlxFDQEgACgCbEEBaiILQQN2IAtBB3FBAEdqIgEgACgCaCICSwRAIAEgAmshDCAAKAJgIg4gAUkEQCANIA5BAXQiAiABENAqIg0gAiANSxsQ6BkgACgCaCECCyAMBEAgACgCZCACakEAIAz8CwALIAAgATYCaAsgACALNgJsIAAoAkAiASAAKAI4RgRAIABBOGpB/OmAARCxKAsgACgCPCABQQR0aiICQgA3AwggAkIANwMAIAAgAUEBajYCQAwDCyAMIAFB0OqAARDDIQALQdzsgAEQsjsACyAAQdAAaiEMIAAoAlAgACgCWCILIAJqSQRAIAAQuRAgDCAAENcqIgsgAiACIAtJGxCELiAAKAJYIQsLIAwgASACEKE2IAA1AkwgC61CIIaEIQMgAq0gATUAAEIghoQhBSAAKAJAIgEgACgCOEYEQCAAQThqQZDrgAEQsSgLIAAoAjwgAUEEdGoiAiADNwMIIAIgBTcDACAAIAFBAWo2AkAgACgCXARAIAAoAmwiC0EBaiIMQQN2IAxBB3FBAEdqIgIgACgCaCIBSwRAIAIgAWshDSAAKAJgIg4gAkkEQCAAQdwAaiAOQQF0IgEgAhDQKiIOIAEgDksbEOgZIAAoAmghAQsgDQRAIAAoAmQgAWpBACAN/AsACyAAIAI2AmgLIAAgDDYCbCAAKAJkIAtBA3ZqIgAgAC0AAEEBIAtBB3F0cjoAAAwBCyAAIAAoAnBBAWo2AnALIApB0AFqJAALjiYCB34UfyMAQdABayIMJAACQAJAAkACQCABBEAgDCABNgIIIAwgAjYCDAJAIAJBDU8EQCAAKAIIIQsgAEEANgIIIAsNAQwFCyAMQQA2AhggDEIANwMQIAIEQCAMQRBqIAEgAvwKAAALIAw1AhghAyAMKQMQIQUgACgCQCIBIAAoAjhGBEAgAEE4akGg64ABELEoCyAAKAI8IAFBBHRqIgsgAz4CDCALIAU3AgQgCyACNgIAIAAgAUEBajYCQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiAiAAKAJoIgFLBEAgAiABayEPIAAoAmAiDSACSQRAIABB3ABqIA1BAXQiASACENAqIg0gASANSxsQ6BkgACgCaCEBCyAPBEAgACgCZCABakEAIA/8CwALIAAgAjYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAYLIAAgACgCcEEBajYCcAwFCyAMQTRqIABBFGooAgA2AgAgDEFAayAAQSBqKQMAIgM3AwAgDEHIAGogAEEoaikDACIINwMAIAxB0ABqIABBMGopAwAiBzcDACAMIAs2AiggDCAAKQIMNwIsIAwgACkDGCIFNwM4IAMgAq0iBoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUgBnxCrf7V5NSF/ajYAH4hAwJAIAJBEE0EQCADIAV8IAEpAAAgCIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABIAJqQQhrKQAAIAeFIgRCf4V+IgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBkIIiEKAgID4D4MgBkIYiEKAgPwHg4QgBkIoiEKA/gODIAZCOIiEhISFIARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgA36FQheJIQMMAQsgAyAFfCAIIAEgAmpBEGsiCykAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAHIAspAAiFIgRCf4V+IgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBkIIiEKAgID4D4MgBkIYiEKAgPwHg4QgBkIoiEKA/gODIAZCOIiEhISFIARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgA36FQheJIQMgB0J/hSEGIAEhCiACIQsDQCADIAV8IAggCikAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAKKQAIIgkgBoV+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFIAMgByAJhSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoVCF4khAyAKQRBqIQogC0EQayILQRBLDQALCyADIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIR+IANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgBUJ/hX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgA4khByMAQRBrIhEkACAMQShqIgsoAghFBEAgEUEIaiEUIwBB4ABrIgokACAKIAxBOGo2AhwgCygCDCEOIAogCkEcajYCIAJAIA4gDkEBaiINTQRAAkAgCygCBCIOIA5BAWpBA3ZBB2wgDkEISRsiDkEBdiANSQRAAkACQCAOQQFqIg8gDSANIA9JGyIOQQ9PBEAgDkH/////AUsNAUF/IA5BA3RBB25BAWtndkEBaiEPDAILQQRBCEEQIA5BCEkbIA5BBEkbIQ8MAQsQ3ScgCigCFCEPIAooAhAiDUGBgICAeEcNBAsgCkHQAGogDkEEIA8Q+xQgCigCWCEPIAooAlQhDSAKKAJQIg5FDQMgCiAKKAJcNgJMIAogDzYCSCAKIA02AkQgCiAONgJAIApBCGogCkFAaxDBNCAKKAIMIg8EQCAKKAIIQf8BIA/8CwALIAooAkghDyAKKAJEIQ0gCigCQCIORQ0DIAogCigCTDYCPCAKIA82AjggCiANNgI0IAogDjYCMCAKQoSAgICAATcCKCAKIAtBEGo2AiQgCkEwaiEYIAogCygCDCIWBH8gDkEIaiEZIAsoAgAiFykDAEJ/hUKAgYKEiJCgwIB/gyEGA0AgBlAEQANAIBNBCGohEyAXQQhqIhcpAwBCgIGChIiQoMCAf4MiA0KAgYKEiJCgwIB/UQ0ACyADQoCBgoSIkKDAgH+FIQYLIA4gDSAKKAIgKAIAIhApAwgiAyALKAIAIAZ6p0EDdiATakECdCIaa0EEazUCAIUiBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAVC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAQKQMAIgVCf4V+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgAyAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEfoUgA4mnIhtxIhBqKQAAQoCBgoSIkKDAgH+DIgNQBEBBCCESA0AgECASaiEQIBJBCGohEiAOIA0gEHEiEGopAABCgIGChIiQoMCAf4MiA1ANAAsLIAZCAX0gBoMhBiAOIAN6p0EDdiAQaiANcSIQaiwAAEEATgRAIA4pAwBCgIGChIiQoMCAf4N6p0EDdiEQCyAOIBBqIBtBGXYiEjoAACAZIBBBCGsgDXFqIBI6AAAgDiAQQQJ0a0EEayALKAIAIBprQQRrKAAANgAAIBZBAWsiFg0ACyALKAIMBUEACyINNgI8IAogDyANazYCOCALIBhBBBD6KiAKQSRqEPUnDAELIAsgCkEgakHAyIUBEO4JC0GBgICAeCENDAELEN0nIAooAgQhDyAKKAIAIQ0LIBQgDzYCBCAUIA02AgAgCkHgAGokAAsgAEEIaiEPIAxB2ABqIQogCygCBCIOIAencSENIAdCGYhC/wCDQoGChIiQoMCAAX4hBCAMQQhqIhAoAgQhEyAQKAIAIRIgCygCACEQA0ACQCANIBBqKQAAIgUgBIUiA0J/hSADQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIQMCfwJAIAoCfgJAA0AgA1ANASARIAAgCygCACADeqdBA3YgDWogDnEiFEECdGtBBGsoAgAQ+BIgA0IBfSADgyEDIBIgEyARKAIAIBEoAgQQnztFDQALIAogBzcDCCAKIAsoAgBBACAUa0ECdGo2AhBCAAwBCyAFQoCBgoSIkKDAgH+DIQMgHEUEQCADUA0CIAN6p0EDdiANaiAOcSEVC0EBIAMgBUIBhoNQDQIaIAogECAVaiwAAEEATgR/IBApAwBCgIGChIiQoMCAf4N6p0EDdgUgFQs2AhAgCiAHNwMIQgELNwMAIAogCzYCFCARQRBqJAAMAgtBAAshHCANIB1BCGoiHWogDnEhDQwBCwsgDCgCWEEBRgRAIAwoAmwiCygCACIKIAwoAmgiDWoiDi0AACEQIAAoAkAhESAOIAwoAmBBGXYiDjoAACAKIAsoAgQgDUEIa3FqQQhqIA46AAAgCyALKAIMQQFqNgIMIAsgCygCCCAQQQFxazYCCCAKIA1BAnRrQQRrIBE2AgAgDEGoAWogDEEwaikCADcDACAMIAwpAig3A6ABIAxByAFqIAxB0ABqKQMANwMAIAxBwAFqIAxByABqKQMANwMAIAxBuAFqIAxBQGspAwA3AwAgDCAMKQM4NwOwASAAKAIIBEAgDxCOOwsgDyAMQaABakEw/AoAAAwECyAMKAJoQQRrKAIAIgIgACgCQCIBTw0BIAAoAjwiCyACQQR0aiICKQMIIQMgAikDACEFIAAoAjggAUYEfyAAQThqQeDqgAEQsSggACgCPAUgCwsgAUEEdGoiAiADNwMIIAIgBTcDACAAIAFBAWo2AkACQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiASAAKAJoIgJLBEAgASACayENIAAoAmAiDiABSQRAIABB3ABqIA5BAXQiAiABENAqIg4gAiAOSxsQ6BkgACgCaCECCyANBEAgACgCZCACakEAIA38CwALIAAgATYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgDEH4AGogDEEwaikCADcDACAMQYgBaiAMQUBrKQMANwMAIAxBkAFqIAxByABqKQMANwMAIAxBmAFqIAxB0ABqKQMANwMAIAwgDCkCKDcDcCAMIAwpAzg3A4ABIA8oAgAEQCAPEI47CyAPIAxB8ABqQTD8CgAADAQLIABB3ABqIg8Q5jogACgCXEUNASAAKAJsQQFqIgtBA3YgC0EHcUEAR2oiASAAKAJoIgJLBEAgASACayEKIAAoAmAiDSABSQRAIA8gDUEBdCICIAEQ0CoiDyACIA9LGxDoGSAAKAJoIQILIAoEQCAAKAJkIAJqQQAgCvwLAAsgACABNgJoCyAAIAs2AmwgACgCQCIBIAAoAjhGBEAgAEE4akH86YABELEoCyAAKAI8IAFBBHRqIgJCADcDCCACQgA3AwAgACABQQFqNgJADAMLIAIgAUHQ6oABEMMhAAtB3OyAARCyOwALIABB0ABqIQogACgCUCAAKAJYIgsgAmpJBEAgABC5ECAKIAAQ1yoiCyACIAIgC0kbEIQuIAAoAlghCwsgCiABIAIQoTYgADUCTCALrUIghoQhAyACrSABNQAAQiCGhCEFIAAoAkAiASAAKAI4RgRAIABBOGpBkOuAARCxKAsgACgCPCABQQR0aiICIAM3AwggAiAFNwMAIAAgAUEBajYCQCAAKAJcBEAgACgCbCILQQFqIgpBA3YgCkEHcUEAR2oiAiAAKAJoIgFLBEAgAiABayEPIAAoAmAiDSACSQRAIABB3ABqIA1BAXQiASACENAqIg0gASANSxsQ6BkgACgCaCEBCyAPBEAgACgCZCABakEAIA/8CwALIAAgAjYCaAsgACAKNgJsIAAoAmQgC0EDdmoiACAALQAAQQEgC0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgDEHQAWokAAupGgIDfwF+IwBB0CtrIgYkACAGIAI2AiQgBiADNgIwIAYgBTYCLCAGIAE2AiggBiADNgI8IAYgBTYCOCAGIAE2AjQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAAIgdBAmtBC0kgB0Eja0EESXIgB0ENa0EHSXJFBEBBBCEIIAdBFGsOFAMCAwMDAwMIEgcIEgQSBRISEhIRAQsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNEyADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNEyAGQYAhaiACIAMgBBD5FiAGQeAFaiAGQYghaikDADcDACAGQegFaiAGQZAhaikDADcDACAGIAE2AqgmIAYgBikDgCE3A9gFIAZBQGsgBkGYIWpBmAX8CgAAIAUoAggiAiAFKAIARgRAIAVBqO3PABCgKAsgBSgCBCACQbgFbGoiAUICNwMAIAEgBikD2AU3AwggAUEQaiAGQeAFaikDADcDACABQRhqIAZB6AVqKQMANwMAIAFBIGogBkFAa0GYBfwKAAAgBSACQQFqNgIIDB0LIAdBAk8NEAsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNESADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNESAGQYAhaiACIAMgBBD5FiAGQZALaiAGQYghaikDADcDACAGQZgLaiAGQZAhaikDADcDACAGIAE2AqgmIAYgBikDgCE3A4gLIAZB8AVqIAZBmCFqQZgF/AoAACAFKAIIIgIgBSgCAEYEQCAFQZjqzwAQoCgLIAUoAgQgAkG4BWxqIgFCAjcDACABIAYpA4gLNwMIIAFBEGogBkGQC2opAwA3AwAgAUEYaiAGQZgLaikDADcDACABQSBqIAZB8AVqQZgF/AoAACAFIAJBAWo2AggMGwsgBCgCACICIAQoAgRGDRIgBCACQQRqNgIAEKkvIQQQqi8iAUIANwIUIAFCgICAgMAANwIMIAFBADoACCABQoKAgIAQNwIAIAQgATYCACACKAIAIgIgAigCACIHQQFqNgIAIAdBAEgNECADKAIAIgMgAygCACIHQQFqNgIAIAdBAEgNECAGQfggaiACIAMgBBCcAyAGQagLaiICIAZBiCFqKQMANwMAIAZBsAtqIgMgBkGQIWopAwA3AwAgBiABNgKoJiAGIAYpA4AhNwOgCyAGKQP4ICIJQgNSDQIgACAGKQOgCzcDACAAQRBqIAMpAwA3AwAgAEEIaiACKQMANwMADBsLIAZBCGogAkEEahCvLiAGKAIIIgIgBigCDCIHRg0ZDAQLIAIoAggtAAAiAUEaTQRAQQEgAXQiAkGAgMAacQ0FIAJBgICAJHENByABQRVGDQYLIAQoAgAiAyAEKAIERg0RIAQgA0EEajYCACAGQfggaiECIAZBKGohBxCpLyEEEKovIgFCADcCFCABQoCAgIDAADcCDCABQQA6AAggAUKCgICAEDcCACAEIAE2AgAgAygCACIDIAMoAgAiCEEBajYCAAJAAkAgCEEASA0AIAcoAggoAgAiByAHKAIAIghBAWo2AgAgCEEASA0AIAJBCGogAyAHIAQQ+RYgAiABNgKwBSACQgI3AwAMAQsACyAGQeggaiIBIAZBiCFqKQMANwMAIAZB8CBqIgIgBkGQIWopAwA3AwAgBiAGKQOAITcD4CAgBikD+CAiCUIDUg0KIAAgBikD4CA3AwAgAEEQaiACKQMANwMAIABBCGogASkDADcDAAwZCyAGQbgLaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUG46s8AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQOgCzcDCCABQRBqIAZBqAtqKQMANwMAIAFBGGogBkGwC2opAwA3AwAgAUEgaiAGQbgLakGYBfwKAAAgBSACQQFqNgIIDBcLQQghCAsgBkH4IGogASACIAhqKAIAQTBqIAMgBCAFELwBIAYoAvggIgFBCEYNFSAAIAYpAvwgNwIEIABBFGogBkGMIWooAgA2AgAgAEEMaiAGQYQhaikCADcCACAAIAE2AgAMFgsDQAJAIAZB+CBqIAEgAigCAEEwaiADIAQgBRC8ASAGKAL4ICIIQQhHDQAgByACQQRqIgJHDQEMFgsLIAAgBikC/CA3AgQgAEEUaiAGQYwhaigCADYCACAAQQxqIAZBhCFqKQIANwIAIAAgCDYCAAwVCyAEKAIAIgEgBCgCBEYNDSAEIAFBBGo2AgAgBkH4IGogBkE0aiABEPgdIAZB2BBqIgEgBkGIIWopAwA3AwAgBkHgEGoiAiAGQZAhaikDADcDACAGIAYpA4AhNwPQECAGKQP4ICIJQgNSDQMgACAGKQPQEDcDACAAQRBqIAIpAwA3AwAgAEEIaiABKQMANwMADBQLIAQoAgAiASAEKAIERg0NIAQgAUEEajYCACAGQfggaiAGQTRqIAEQ+B0gBkG4G2oiASAGQYghaikDADcDACAGQcAbaiICIAZBkCFqKQMANwMAIAYgBikDgCE3A7AbIAYpA/ggIglCA1INASAAIAYpA7AbNwMAIABBEGogAikDADcDACAAQQhqIAEpAwA3AwAMEwsgBCgCACIBIAQoAgRGDQ0gBCABQQRqNgIAIAZB+CBqIAZBNGogARD4HSAGQYgWaiIBIAZBiCFqKQMANwMAIAZBkBZqIgIgBkGQIWopAwA3AwAgBiAGKQOAITcDgBYgBikD+CAiCUIDUg0CIAAgBikDgBY3AwAgAEEQaiACKQMANwMAIABBCGogASkDADcDAAwSCyAGQcgbaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUHY6s8AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQOwGzcDCCABQRBqIAZBuBtqKQMANwMAIAFBGGogBkHAG2opAwA3AwAgAUEgaiAGQcgbakGYBfwKAAAgBSACQQFqNgIIDBALIAZB6BBqIAZBmCFqQZgF/AoAACAFKAIIIgIgBSgCAEYEQCAFQfjqzwAQoCgLIAUoAgQgAkG4BWxqIgEgCTcDACABIAYpA9AQNwMIIAFBEGogBkHYEGopAwA3AwAgAUEYaiAGQeAQaikDADcDACABQSBqIAZB6BBqQZgF/AoAACAFIAJBAWo2AggMDwsgBkGYFmogBkGYIWpBmAX8CgAAIAUoAggiAiAFKAIARgRAIAVBmOvPABCgKAsgBSgCBCACQbgFbGoiASAJNwMAIAEgBikDgBY3AwggAUEQaiAGQYgWaikDADcDACABQRhqIAZBkBZqKQMANwMAIAFBIGogBkGYFmpBmAX8CgAAIAUgAkEBajYCCAwOCyAGQbAmaiAGQZghakGYBfwKAAAgBSgCCCICIAUoAgBGBEAgBUG4688AEKAoCyAFKAIEIAJBuAVsaiIBIAk3AwAgASAGKQPgIDcDCCABQRBqIAZB6CBqKQMANwMAIAFBGGogBkHwIGopAwA3AwAgAUEgaiAGQbAmakGYBfwKAAAgBSACQQFqNgIIDA0LIAIoAgQiAi0AMEEgRw0JIAZBGGogAkE0aiICEMM0IAYoAhxFDQogBkH4IGogASAGKAIYKAIAQTBqIAMgBCAFELwBIAYoAvggIgdBCEcEQCAAIAYpAvwgNwIEIABBFGogBkGMIWooAgA2AgAgAEEMaiAGQYQhaikCADcCACAAIAc2AgAMDgsgBkEQaiACEMM0IAYoAhQiAkECSQ0LIAZB+CBqIAEgBigCECgCBEEwaiADIAQgBRC8ASAGKAL4ICIBQQhGDQwgACAGKQL8IDcCBCAAQRRqIAZBjCFqKAIANgIAIABBDGogBkGEIWopAgA3AgAgACABNgIADA0LIAZBAjYC/CAgBkGI7c8ANgL4ICAGQgE3AoQhIAZBrwM2AswrIAYgBkHIK2o2AoAhIAYgBkEkajYCyCsgAEEEaiAGQfggahCZDiAAQQE2AgAMDAtBmO3PABCyOwsAC0GI6s8AELI7AAtBqOrPABCyOwALQajrzwAQsjsAC0Ho6s8AELI7AAtByOrPABCyOwALQYjrzwAQsjsACyAGQQA2AoghIAZBATYC/CAgBkGk7M8ANgL4ICAGQgQ3AoAhIAZB+CBqQazszwAQ7ywAC0EAQQBByOvPABDDIQALQQEgAkHY688AEMMhAAsgAEEINgIACyAGQdAraiQAC62+AgMofwN+AXwjAEGACmsiDCQAAkACQAJAAkACQAJAIAxB+AlqAn8CQAJ/AkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQCwBUEBaw4GBwUBAgMEAAsgAEGBgoAINgCxBSAAQYGAgIB4NgK8ASAAQQA6ALgBIAAgACkDmAE3A6gBIAAgAEGoAWoiAzYCuAUgACADNgKYBSAAQbABaiAAQaABaikDADcDAAsgDEEQaiEFIwBBEGsiAyQAAkAgAEG4BWoiBygCACIKBEAgA0EIaiAKIAEQ0RNBASECIAUgAygCCEEBcQR/QQAFIAdBADYCACADIAogARDREyADKAIAIQIgAygCBAs2AgQgBSACNgIAIANBEGokAAwBC0HMlsMAQRxB6JbDABCfKQALQQEhAyAMKAIQQQFxBEBBAyEgDBsLAkAgDCgCFCIDBEAgAygCAEGAgICAeEYNASADEPEtIQogAEEAOgCyBSAMQagHaiAAQYgFaikDADcDACAMQbAHaiAAQZAFaigCADYCACAMQgM3A5AHIAwgACkDgAU3A6AHIABBADoAsQUgDEGoAWoiFCAAQZgB/AoAACMAQfADayIIJAAgCEGwAWoQzzUCQCAUKQMAQgJSBEAgCEHYAmogFEGYAfwKAAAMAQsgCEHYAmoQshILIAhBCGoiAiAIQbABaiAIQdgCahDrHyMAQeABayIHJAAgB0EANgLcASAHQoCAgIAQNwLUASMAQZAEayIDJAAgAyAKNgIMIANBEGogAkGYAfwKAAAgAyADLQCnAToAtAEgA0EMNgKwASADQciBwwA2AqwBIAIoApgBQYCAgIB4RwRAIAMgAikCnAE3AqwBCyAAQdABaiESIAxBkAdqIQQgB0EgaiEFIAdB1AFqIREgAkGYAWohEyADQdgBaiADQawBaiAKQQhqIgoQ0AoCQAJAAkACQCADKALYAUEBRgRAIANBhANqIANB8AFqKQMAIio3AgAgA0H8AmogA0HoAWopAwAiKzcCACADIAMpA+ABIiw3AvQCIAVBGGogKjcCACAFQRBqICs3AgAgBSAsNwIIIAVBgICAgHg2AgAgA0EQahDMLCATEIYwIAMoAgwiAiACKAIAIgJBAWs2AgAgAkEBRgRAIANBDGoQ+CMLIBEQ3jsMAQsgA0HAAWogA0HkAWopAgA3AwAgA0HIAWogA0HsAWopAgA3AwAgA0HQAWogA0H0AWooAgA2AgAgAyADKQLcATcDuAEgAi0ApAFFBEAgCiADQRBqEN4OCyADKAKgASEWIANB2AFqIgogA0EQakGYAfwKAABBoAFBCBCtNiIGRQ0BIAZCgYCAgBA3AwAgBkEIaiAKQZgB/AoAACADIAY2AtQBIANBiARqIBFBCGooAgA2AgAgAyARKQIANwOABCADQbgBahDaLSEJIAYgBigCACICQQFqNgIAIAJBAEgNAiMAQfAAayICJAAgAiAGNgIQIAIgCTYCDCMAQRBrIgskACALQQRqQYDAAEEAQQFBARCgGCALKAIIIRUgCygCBEEBRgRAIBUgCygCDEHQhsMAEP0vAAsgCygCDCEXIAJBFGoiEUEAOgAMIBFBADYCCCARIBc2AgQgESAVNgIAIBEgA0GABGoiFSkCADcCECARQRhqIBVBCGooAgA2AgAgC0EQaiQAIAJBADYCMCAJIAkoAgAiC0EBajYCAAJAAkAgC0EATgRAIAJBNGoiFyAJEKUSIAJB0ABqIRUjAEEQayILJAAgC0EIaiIZIBFBxL7DAEEEEKcaAkACQCALLQAIQQRGDQAgCykDCCIqQv8Bg0IEUQ0AIAsgKjcDCCAVIBkQgSsMAQsgFUEINgIACyALQRBqJAACQCACKAJQIgtBCEcEQCAKIAIpAlQ3AgwgCkEcaiACQeQAaigCADYCACAKQRRqIAJB3ABqKQIANwIAIApBgICAgHg2AgAgCiALNgIIIBcQ/iggERDTKSAREN47IAJBJGoQ3jsgBiAGKAIAIgpBAWs2AgAgCkEBRgRAIAJBEGoQriALIAIoAgwiCiAKKAIAIgpBAWs2AgAgCkEBRw0BIAJBDGoQgyAMAQsgAkHoAGoiCyACQSxqKQIANwMAIAJB4ABqIhUgAkEkaikCADcDACACQdgAaiIXIAJBHGopAgA3AwAgAiACKQIUNwNQQSRBBBCtNiIRRQ0CIBFCgYCAgBA3AgAgESACKQI0NwIIIAogAikDUDcCACARQRBqIAJBPGopAgA3AgAgEUEYaiACQcQAaikCADcCACARQSBqIAJBzABqKAIANgIAIApBCGogFykDADcCACAKQRBqIBUpAwA3AgAgCkEYaiALKQMANwIAIApBADoAbCAKQQA2AmggCiAGNgJkIAogETYCYCAKIAk2AlwgCkEANgJYIApCgICAgMAANwNQIApCBDcDSCAKQgA3A0AgCkKAgICAwAA3AzggCkIENwMwIApCADcDKCAKQoCAgICAATcDIAsgAkHwAGokAAwCCwALQQRBJBCjPQALIAMoAtgBIgpBgICAgHhGBEAgA0H0A2ogA0HwAWopAwAiKjcCACADQewDaiADQegBaikDACIrNwIAIAMgAykD4AEiLDcC5AMgBUEYaiAqNwIAIAVBEGogKzcCACAFICw3AgggBUGAgICAeDYCACAGIAYoAgAiAkEBazYCACACQQFGBEAgA0HUAWoQriALIANBuAFqEP4oIBMQhjAgAygCDCICIAIoAgAiAkEBazYCACACQQFHDQEgA0EMahD4IwwBCyADQfgDaiICIANB9AFqKAIANgIAIANB8ANqIhEgA0HsAWopAgA3AwAgA0HoA2oiCyADQeQBaikCADcDACADIAMpAtwBNwPgAyADQfACaiIJIANB+AFqQdAA/AoAACADQcgDaiIVIAspAwA3AwAgA0HQA2oiCyARKQMANwMAIANB2ANqIhEgAigCADYCACADIAMpA+ADNwPAAyADQfABaiIXIANB0AFqKAIANgIAIANB6AFqIhkgA0HIAWopAwA3AwAgA0HgAWoiHCADQcABaikDADcDACADIAMpA7gBNwPYASADKAIMIgIgAigCACIdQQFqNgIAIB1BAEgNAiAFIAMpA9gBNwJwIAVBiAFqIBcoAgA2AgAgBUGAAWogGSkDADcCACAFQfgAaiAcKQMANwIAIAVBHGogESgCADYCACAFQRRqIAspAwA3AgAgBUEMaiAVKQMANwIAIAUgAykDwAM3AgQgBUEgaiAJQdAA/AoAACAFIBY2AqwBIAVBgICAgHg2ApQBIAUgBjYCkAEgBSACNgKMASAFIAo2AgAgBSADKAIMNgKoASATEIYwCyADQZAEaiQADAILQQhBoAEQoz0LAAsCQCAHKAIgIgNBgICAgHhGBEAgB0EUaiAHQThqKQMAIio3AgAgB0EMaiAHQTBqKQMAIis3AgAgByAHKQMoIiw3AgQgEkEYaiAqNwIAIBJBEGogKzcCACASICw3AgggEkIENwMAAkAgBCgCEEUNACAEQRRqEJI+IAQoAhQiA0GEAUkNACADEPIfCwJAIAQoAhgiA0UNACADIAMoAgBBAWsiAzYCACADDQAgBEEYahCyGgsCQCAEKAIcIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIARBHGoQshoLIAQoAiAiA0UNASADIAMoAgBBAWsiAzYCACADDQEgBEEgahCyGgwBCyAHQRhqIgIgB0E8aigCADYCACAHQRBqIgUgB0E0aikCADcDACAHQQhqIgogB0EsaikCADcDACAHIAcpAiQ3AwAgEkHIAGogB0FAa0GQAfwKAAAgEkHEAGogAigCADYCACASQTxqIAUpAwA3AgAgEkE0aiAKKQMANwIAIBIgBykDADcCLCASIARBKPwKAAAgEiADNgIoCyAHQeABaiQAIAhB8ANqJAAgACkD0AFCBFEEQCAMQfAGaiIDIABB6AFqKQMANwMAIAxB6AZqIgIgAEHgAWopAwA3AwAgDCAAKQPYATcD4AYgAEEAOgC0BSAAKAKUBSEFQRhBCBCtNiIBRQ0JIAEgDCkD4AY3AwAgAUEQaiADKQMANwMAIAFBCGogAikDADcDACAMIAE2AqwBIAxBATYCqAEgBCAFIBQQxyYgDCgCkAdBBnFBBkYNHCAEEO4NDBwLIABBAToAswUgAEGoA2ogEkHYAfwKAAAgAEEAOgC0BSAAKAKUBSEDIAxBBjYCqAEgDEGQB2oiAiADIAxBqAFqEMcmIAwoApAHQQZxQQZHBEAgAhDuDQtBAAwPCyAAQQA6ALQFIAAoApQFIQIgDEGoAWoiBUEQQQBBAUEBEKAYIAwoAqwBIQMgDCgCqAFBAUYNCCAMKAKwASIBQQhqQYTcwgApAAA3AAAgAUH828IAKQAANwAAIAxBEDYCmAcgDCABNgKUByAMIAM2ApAHIAFBEBCTPiEDIAxBkAdqIgEQ3jsgDCADNgKsASAMQQU2AqgBIAEgAiAFEMcmIAwoApAHQQZxQQZGDRogARDuDQwaCyAAQQA6ALQFIAAoApQFIQIgDEEANgKYByAMQoCAgIAQNwKQByAMQezIwgA2AqwBIAxCoICAgA43ArABIAwgDEGQB2oiATYCqAEgA0EEaiAMQagBaiIDEKwRDQggDEE4aiAMQZgHaigCACIFNgIAIAwgDCkCkAc3AzAgDCgCNCAFEJM+IQUgDEEwahDeOyAMIAU2AqwBIAxBBTYCqAEgASACIAMQxyYgDCgCkAdBBnFBBkYNGSABEO4NDBkLIAAoArgFISNBAQwMCyAAQfgFaiEmAkAgAC0A+AVBAWsOAwgCCwALIAAoAuQFIQ8gACgC4AUhJEECDAsLIABBuAVqISAgAEGACmohJgJAIAAtAIAKQQFrDgMJAQAMCyAAQegIaiEkIABB6AlqISUCQCAALQDoCUEBaw4ECAEOAAILIAAoAvQJISMgACgC8AkhAwwOCwALIAAoAuAJIQMMCgtB7NvCABDoKwALQQhBGBCjPQALIAMgDCgCsAFB/NnCABD9LwALQZTJwgBBNyAMQTBqQYTJwgBBzMnCABDVHgALQZTXwgAQ6CsAC0Gk18IAEOgrAAtBhNfCABDoKwALQQMLIQMDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDgMAAQIDCyAAIABBmAVqIiM2ArgFDAwLICMoAgAiAigCFCEDIAJBgYCAgHg2AhQgAEG4BWohIAJAIANBgYCAgHhHBEAgDEEoaiACQSBqKQIANwIAIAwgAzYCHCAMIAIpAhg3AiAMAQsgDEEcaiACIAEQqRogDCgCHCEDCyADQYKAgIB4Rw0FQQEhA0EEISAMGgsgJCgCUCAMQagBaiAkQShqIA8Q9gkgDCgCqAEiA0EIRwRAIAxBQGsgDEG8AWooAgA2AgAgDEE4aiAMQbQBaikCADcDACAMIAwpAqwBNwMwDAQLICQoAlBGDQEgAEEAOgD0BSAAICQ2AugFQQMhAwwMCyAMQagBaiAAQegFaiABEMYOIAwoAqgBIgNBCUYNByAMQZgIaiAMQbwBaigCADYCACAMQZAIaiAMQbQBaikCADcDACAMIAwpAqwBNwOICCAALQD0BUEDRgRAIABB7AVqELwqCyADQQhHDQELQQghAwwBCyAMQUBrIAxBmAhqKAIANgIAIAxBOGogDEGQCGopAwA3AwAgDCAMKQOICDcDMAsgDEGICWoiAiAMQUBrKAIANgIAIAxBgAlqIgUgDEE4aikDADcDACAMIAwpAzA3A/gIICZBAToAACAMQZwHaiAFKQMANwIAIAxBpAdqIAIoAgA2AgAgDCAMKQP4CDcClAcgDCADNgKQByADQQhHBEAgDEGQB2oQySMLIABBzAVqEOkrIAAoArgFQYCAgIB4Rw0FDAELIAAgDCkCHCIqNwKcBSAAQawFaiAMQSxqIgMoAgA2AgAgAEGkBWogDEEkaiICKQIANwIAICqnQYGAgIB4Rg0CICAgDCkCHCIqNwIAICBBEGogAygCADYCACAgQQhqIAIpAgA3AgAgKqdBgICAgHhHDQELIABBuAVqEPUuDAMLIAAgDCkCHDcCzAUgAEEAOgD4BSAAIABBzAVqIg82AuQFIAAgAEGoA2oiJDYC4AUgAEHcBWogDEEsaigCADYCACAAQdQFaiAMQSRqKQIANwIAIABB+AVqISYMBAsgAEEAOgCzBSAMQagBaiIDIABBqANqQdgB/AoAACAgIANByAT8CgAAIABBADoAgAogAEGACmohJgwFCyAmQQM6AABBASEDQQUhIAwQC0EAIQMMAgtBASEDDAELQQIhAwwACwALIABBkAdqIgMgIEHYAfwKAAAgAEEAOgDoCSAAIAM2AuAJIABB6AhqISQgAEHoCWohJQsgACADNgLkCSAMQZAHaiEeIwBBIGsiJyQAICdBCGogA0EoaiIcEP8GAkAgJygCCCIDQQhHBEAgHiAnKQIMNwIMIB5BHGogJ0EcaigCADYCACAeQRRqICdBFGopAgA3AgAgHkEDNgIAIB4gAzYCCAwBC0IAISojAEGQAmsiFSQAAkACQAJAAkACQCAcLQBsRQRAIBwoAmggHCgCKEYNAkEoIQIgFUGYAWpBKEEAQQFBARCgGCAVKAKcASEDIBUoApgBQQFGDQQgFSgCoAEiBUGUwcMAQSj8CgAADAELQSUhAiAVQZgBakElQQBBAUEBEKAYIBUoApwBIQMgFSgCmAFBAUYNAyAVKAKgASIFQbzBwwBBJfwKAAALIB4gAjYCFCAeIAU2AhAgHiADNgIMIB5BADYCCCAeQQM2AgAMAQsgFUGYAWohGSMAQbABayIUJAAgHEEBOgBsAkACQAJAIBwoAigiAwRAIBwoAiQhAiADQQZ0IQMDQCAUQegAaiAcIBwoAjAgHCgCNCACEIEHIBQoAmgiBUEIRwRAIBkgFCkCbDcCDCAZQRxqIBRB/ABqKAIANgIAIBlBFGogFEH0AGopAgA3AgAgGUEDNgIAIBkgBTYCCAwDCyACQUBrIQIgA0FAaiIDDQALCwJ/IBwoAmRBCGoQ1TQiAwRAIAMoAgghAiAcKAJYIQUgAygCBCEDIBQgHCgCVCIKNgJwIBQgAzYCaCAUIAogBUEYbGo2AnQgFCADIAJBGGxqNgJsIBRBCGogFEHoAGoQqRUgFCkCDCEqIBQoAggMAQtBgICAgHggHCgCWEUNABogFEHoAGogHEHQAGoQxBAgFCkCbCEqIBQoAmgLIQIgFEEUaiAcKAIkIgMgAyAcKAIoQQZ0ahCkGyAUIBwoAmRBCGoQ5TsgFCgCACEHIBRB6ABqIBQoAgQiA0EAQQFBARCgGCAUKAJsIQUgFCgCaEEBRg0BIBQoAnAhCiADBEAgCiAHIAP8CgAACyAUQShqIBRBHGooAgA2AgAgFEEANgJYIBRBADYCUCAUIAM2AkAgFCAKNgI8IBQgBTYCOCAUIBQpAhQ3AyAgFCAcNgJEIBQgHEHgAGo2AkwgFCAcQdwAajYCSCAUQQJBASAcKAJkLQCdARs2AmAgFEGAgICAeDYCLCACQYCAgIB4RwRAIBRB6ABqIgMgFEEgaiIFQcQA/AoAACAUQfQAahCHMCAUICo3AnggFCACNgJ0IAUgA0HEAPwKAAALIBQgHCkCPDcDUCAUIBwpAkg3A1hBACEGQgAhKiMAQZACayISJAAgFEEgaiIXKAIIIgIEQCAXKAIEQShqIR0DQCAdKQMAICp8ISogHUHQAGohHSACQQFrIgINAAsLAkACQAJAAkAgFygCMCIhRQ0AIBJByABqIQkgFygCNCEbIwBBIGsiCCQAAkACQCAXKAIIIgNFDQAgFygCBCIRIANB0ABsaiEiIBdBJGohFgJAA0ACQCARKAI4IgMEQCAGIBtPDQMgA0HoA2whEyARKAI0QawDaiEdICEgBkEMbGoiGigCCCEQQQAhC0F/IQ8DQCAQIA9BAWoiD0YNAiAaKAIEIAtqIgIoAgBBgICAgHhHBEAgFigCACgCHCENIAhBCGohDiMAQdAAayIDJAAgAyAWNgIgIANCgICAgJCAgICAfzcCCCADQoCAgIAgNwIAIANBADsBJCADQShqIQojAEFAaiIFJAAgBUEMakH9usIAQQsQgCAgBUEsaiADEOcnAkAgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgBUEsaiIHQYi7wgBBCkENQQEQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwBCyAFQSxqIgcQhjAgByADQQIgAigCCCIEEKwUIAUoAiwiB0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAHNgIADAELIAQEQCACKAIEIQcDQCAFQSxqIAMgBy0AABDRGSAFKAIsIh9BBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogHzYCAAwDCyAHQQFqIQcgBEEBayIEDQALCyADEMYhIAVBLGoiB0GSu8IAQQpBDUECEOgcIAVBGGogAyAHEK0UIAUoAhgiBEEERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiAENgIAIAcQhjAMAQsgBUEsaiIHEIYwIAcgA0EIIAIoAhQiBBCsFCAFKAIsIgdBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogBzYCAAwBCyAEBEAgAigCEEEIaiEHIARBDGwhBANAIAVBLGogAyAHQQRrKAIAIAcoAgAQphsgBSgCLCIfQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIB82AgAMAwsgB0EMaiEHIARBDGsiBA0ACwsgAxDGISAFQSxqIgdBnLvCAEEKQQ1BAxDoHCAFQRhqIAMgBxCtFCAFKAIYIgRBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBDYCACAHEIYwDAELIAVBLGoiBxCGMCAHIANBCCACKAIgIgQQrBQgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgBARAIAIoAhxBCGohByAEQQxsIQQDQCAFQSxqIAMgB0EEaygCACAHKAIAEKYbIAUoAiwiH0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAfNgIADAMLIAdBDGohByAEQQxrIgQNAAsLIAMQxiEgBUEsaiIHQaa7wgBBDkEGQQQQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwBCyAFQSxqIgcQhjAgByADIAIoAkgQqhsgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAQsgAxDGISACKAIkQYCAgIB4RwRAIAVBLGoiB0G0u8IAQQtBDUEFEOgcIAVBGGogAyAHEK0UIAUoAhgiBEEERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiAENgIAIAcQhjAMAgsgBUEsaiIHEIYwIAcgA0EHIAIoAiwiBBCsFCAFKAIsIgdBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogBzYCAAwCCyAEBEAgAigCKCEHIARBA3QhBANAIAVBLGogAyAHKQMAEK0bIAUoAiwiH0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAfNgIADAQLIAdBCGohByAEQQhrIgQNAAsLIAMQxiELIAIoAjBBgICAgHhHBEAgBUEsaiIHQb+7wgBBG0ENQQYQ6BwgBUEYaiADIAcQrRQgBSgCGCIEQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAQ2AgAgBxCGMAwCCyAFQSxqIgcQhjAgByADQQcgAigCOCIEEKwUIAUoAiwiB0EERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiAHNgIADAILIAQEQCACKAI0IQcgBEEDdCEEA0AgBUEsaiADIAcpAwAQrRsgBSgCLCIfQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIB82AgAMBAsgB0EIaiEHIARBCGsiBA0ACwsgAxDGIQsgAigCPEGAgICAeEcEQCAFQSxqIgdB2rvCAEEbQQ1BBxDoHCAFQRhqIAMgBxCtFCAFKAIYIgRBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBDYCACAHEIYwDAILIAVBLGoiBxCGMCAHIANBByACKAJEIgQQrBQgBSgCLCIHQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAc2AgAMAgsgBARAIAIoAkAhByAEQQN0IQQDQCAFQSxqIAMgBykDABCtGyAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwECyAHQQhqIQcgBEEIayIEDQALCyADEMYhCyAFQSxqIAMQgDYgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgCiADEOUoCyAFQQxqEN47IAVBQGskAAJAIAMoAigiAkEERwRAIANByABqIANBNGopAgA3AgAgAyADKQIsNwJAIAMgAjYCPCAOIANBPGoQpSUMAQsgDkEINgIACyADELouIANB0ABqJAAgCCgCCCICQQhHBEAgCSAIKQIMNwIEIAlBFGogCEEcaigCADYCACAJQQxqIAhBFGopAgA3AgAMCAsgFigCACgCHCEDIB1BBGtBATYCACAdQZQDayANrTcDACAdQZwDa0IBNwMAIB0gAyANazYCAAsgHUHoA2ohHSALQcwAaiELIBNB6ANrIhMNAAsLIAZBAWohBiAiIBFB0ABqIhFHDQEMAwsLIBAgEEHgncMAEMMhAAsgBiAbQdCdwwAQwyEAC0EIIQILIAkgAjYCACAIQSBqJAAgEigCSCIdQQhGDQAMAQsCQCAXKAI4Ih9FDQAgEkHIAGohECAXKAI8IQ4jAEEgayIJJAACQAJAIBcoAggiA0UNACAXKAIEIhEgA0HQAGxqISggF0EkaiEbQQAhBgJAA0ACQCARKAI4IgMEQCAGIA5PDQMgESgCNCEdIANB6ANsIRMgHyAGQQxsaiIpKAIIIQ1BACELQX8hDwNAIA0gD0EBaiIPRg0CICkoAgQgC2oiAigCAEGAgICAeEcEQCAbKAIAKAIcISEgCUEIaiEiIwBB0ABrIgMkACADIBs2AiAgA0KAgICAkICAgIB/NwIIIANCgICAgCA3AgAgA0EAOwEkIANBKGohByMAQUBqIgokACAKQQxqQaa9wgBBCxCAICAKQSxqIAMQ5ycCQCAKKAIsIgVBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgBTYCAAwBCyAKQSxqIgVBsb3CAEEOQQ1BARDoHCAKQRhqIAMgBRCtFCAKKAIYIgRBBEcEQCAHIAopAhw3AgQgB0EMaiAKQSRqKQIANwIAIAcgBDYCACAFEIYwDAELIApBLGoiBRCGMCAFIANBCiACKAIIIgUQrBQgCigCLCIEQQRHBEAgByAKKQIwNwIEIAdBDGogCkE4aikCADcCACAHIAQ2AgAMAQsgBQRAIAIoAgQhCCAFQRhsIRYDQCAKQSxqIQQjAEFAaiIFJAAgBUEMakGgv8IAQQwQgCAgBUEsaiADEOcnAkAgBSgCLCIaQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIBo2AgAMAQsgBUEsaiIaQay/wgBBBkEHQQEQ6BwgBUEYaiADIBoQrRQgBSgCGCIYQQRHBEAgBCAFKQIcNwIEIARBDGogBUEkaikCADcCACAEIBg2AgAgGhCGMAwBCyAFQSxqIhoQhjAgGiADIAgpAwAQrRsgBSgCLCIaQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIBo2AgAMAQsgAxDGISAFQSxqIhpBsr/CAEEUQQZBAhDoHCAFQRhqIAMgGhCtFCAFKAIYIhhBBEcEQCAEIAUpAhw3AgQgBEEMaiAFQSRqKQIANwIAIAQgGDYCACAaEIYwDAELIAVBLGoiGhCGMCAaIAMgCCgCEBCqGyAFKAIsIhpBBEcEQCAEIAUpAjA3AgQgBEEMaiAFQThqKQIANwIAIAQgGjYCAAwBCyADEMYhIAVBLGoiGkHGv8IAQQ9BB0EDEOgcIAVBGGogAyAaEK0UIAUoAhgiGEEERwRAIAQgBSkCHDcCBCAEQQxqIAVBJGopAgA3AgAgBCAYNgIAIBoQhjAMAQsgBUEsaiIaEIYwIBogAyAIKQMIEK0bIAUoAiwiGkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCAaNgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiGkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCAaNgIADAELIAQgAxDlKAsgBUEMahDeOyAFQUBrJAAgCigCLCIFQQRHBEAgByAKKQIwNwIEIAdBDGogCkE4aikCADcCACAHIAU2AgAMAwsgCEEYaiEIIBZBGGsiFg0ACwsgAxDGISACKAIMQYCAgIB4RwRAIApBLGoiBUG/vcIAQR9BDUECEOgcIApBGGogAyAFEK0UIAooAhgiBEEERwRAIAcgCikCHDcCBCAHQQxqIApBJGopAgA3AgAgByAENgIAIAUQhjAMAgsgCkEsaiIFEIYwIAUgA0EHIAIoAhQiBRCsFCAKKAIsIgRBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgBDYCAAwCCyAFBEAgAigCECEIIAVBA3QhFgNAIApBLGogAyAIKQMAEK0bIAooAiwiAkEERwRAIAcgCikCMDcCBCAHQQxqIApBOGopAgA3AgAgByACNgIADAQLIAhBCGohCCAWQQhrIhYNAAsLIAMQxiELIApBLGogAxCANiAKKAIsIgJBBEcEQCAHIAopAjA3AgQgB0EMaiAKQThqKQIANwIAIAcgAjYCAAwBCyAHIAMQ5SgLIApBDGoQ3jsgCkFAayQAAkAgAygCKCICQQRHBEAgA0HIAGogA0E0aikCADcCACADIAMpAiw3AkAgAyACNgI8ICIgA0E8ahClJQwBCyAiQQg2AgALIAMQui4gA0HQAGokACAJKAIIIgJBCEcEQCAQIAkpAgw3AgQgEEEUaiAJQRxqKAIANgIAIBBBDGogCUEUaikCADcCAAwICyAbKAIAKAIcIQMgHUGgA2pBATYCACAdQQhqICGtNwMAIB1CATcDACAdQaQDaiADICFrNgIACyALQRhqIQsgHUHoA2ohHSATQegDayITDQALCyAGQQFqIQYgKCARQdAAaiIRRw0BDAMLCyANIA1BgJ7DABDDIQALIAYgDkHwncMAEMMhAAtBCCECCyAQIAI2AgAgCUEgaiQAIBIoAkgiHUEIRg0ADAELIBJBBGogFygCLCgCAEEIaigCCBD0HyAXKAIAIQMgFykCBCErIBJBgICAgHg2AhAgEkECNgIcIBJBgICAgHg2AjwgEiArNwLEASASIAM2AsABIBdBDGohGgJAIBcoAgxBgICAgHhHBEAgEkHMAWogGhDEEAwBCyASQYCAgIB4NgLMAQsgFygCQCEDIBJB6AFqIgIgFygCKCgCAEEIahCuFSASQeABaiIFIBJB9AFqKAIANgIAIBIgEikC7AE3A9gBAkAgEigC6AEiCkEIRgRAIBdBGGohHQJAIBcoAhhBgICAgHhHBEAgAiAdEN0gDAELIBJBgICAgHg2AugBCyASQagBaiASQQxqKAIANgIAIBJB0ABqIBJBJGopAgA3AwAgEkHYAGogEkEsaikCADcDACASQeAAaiASQTRqKQIANwMAIBJBtAFqIBJBxABqKAIANgIAIBIgEikCBDcDoAEgEiASKQIcNwNIIBIgEikCPDcCrAEgEiADNgK4ASASQfgAaiASQeABaigCADYCACASQYQBaiASQcgBaigCADYCACASQZABaiASQdQBaigCADYCACASQZwBaiASQfABaigCADYCACASICo3A2ggEiASKQPYATcDcCASIBIpAsABNwJ8IBIgEikCzAE3A4gBIBIgEikC6AE3ApQBIBcoAiQoAhwhKSASQegBaiEfIwBB0ABrIgMkACADIBdBJGoiKDYCICADQoCAgICQgICAgH83AgggA0KAgICAIDcCACADQQA7ASQgA0EoaiERIBJByABqIRsjAEFAaiIKJAAgCkEMakH+vcIAQQwQgCAgCkEsaiADEOcnAkAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAQsgCkEsaiICQYq+wgBBB0EGQQEQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwBCyAKQSxqIgIQhjAgAiADIBsoAnAQqhsgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAQsgAxDGISAKQSxqIgJBkb7CAEEGQQ1BAhDoHCAKQRhqIAMgAhCtFCAKKAIYIgVBBEcEQCARIAopAhw3AgQgEUEMaiAKQSRqKQIANwIAIBEgBTYCACACEIYwDAELIApBLGoiAhCGMCACIANBCiAbKAIwIgIQrBQgCigCLCIFQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAU2AgAMAQsgAgRAIBsoAiwhEyACQeAAbCEhA0AgCkEsaiEEIwBBQGoiByQAIAdBDGpB97/CAEENEIAgIAdBLGogAxDnJwJAIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIBMoAgBBAUYEQCAHQSxqIgJBhMDCAEEEQQZBARDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgEygCBBCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIIBEAgEygCDCEFIAdBLGoiAkGIwMIAQQtBBkECEOgcIAdBGGogAyACEK0UIAcoAhgiBkEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAGNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAFEKobIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAILIAMQxiELIBMoAhAEQCAHQSxqIgJBk8DCAEEPQQZBAxDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgEygCFBCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyAHQSxqIgJBosDCAEEEQQhBBBDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBTYCACACEIYwDAELIAdBLGoiAhCGMCACIAMgEygCWCATKAJcEKYbIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIAMQxiEgEygCGEEBRgRAIBMoAhwhBSAHQSxqIgJBpsDCAEEMQQZBBRDoHCAHQRhqIAMgAhCtFCAHKAIYIgZBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBjYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgBRCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIgBEAgB0EsaiICQbLAwgBBDkEGQQYQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgBCAHKQIcNwIEIARBDGogB0EkaikCADcCACAEIAU2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIBMoAiQQqhsgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgEygCKARAIBMoAiwhBSAHQSxqIgJBlbzCAEEFQQZBBxDoHCAHQRhqIAMgAhCtFCAHKAIYIgZBBEcEQCAEIAcpAhw3AgQgBEEMaiAHQSRqKQIANwIAIAQgBjYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgBRCqGyAHKAIsIgJBBEcEQCAEIAcpAjA3AgQgBEEMaiAHQThqKQIANwIAIAQgAjYCAAwCCyADEMYhCyATKAIwBEAgEygCNCEFIAdBLGoiAkGavMIAQQlBBkEIEOgcIAdBGGogAyACEK0UIAcoAhgiBkEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAGNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAFEKobIAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAILIAMQxiELIBMoAjgEQCATKAI8IQUgB0EsaiICQcDAwgBBCEEGQQkQ6BwgB0EYaiADIAIQrRQgBygCGCIGQQRHBEAgBCAHKQIcNwIEIARBDGogB0EkaikCADcCACAEIAY2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgEygCQEESRwRAIAdBLGoiAkHIwMIAQQtBCkEKEOgcIAdBGGogAyACEK0UIAcoAhgiBUEERwRAIAQgBykCHDcCBCAEQQxqIAdBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgB0EsaiIFEIYwIBNBQGshCyMAQUBqIgIkACACQQxqQa68wgBBCxCAICACQSxqIAMQ5ycCQCACKAIsIgZBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwBCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEQIAsoAgAiBkECayAGQQFNG0EBaw4QAQIDBAUGBwgJCgsMDQ4PEAALIAJBLGoiBkG5vMIAQQZBCkEBEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEgsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBrLnCAEEKEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0QIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADBELIAJBLGoiBkG/vMIAQQNBCkECEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEQsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBvbbCAEEHEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0PIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADBALIAJBLGoiBkHCvMIAQQRBCkEDEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMEAsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBprfCAEEIEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0OIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADA8LIAJBLGoiBkHGvMIAQQRBCkEEEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMDwsgAkEsaiIIEIYwIwBBIGsiBiQAIAZBhrfCAEEIEIAgIAZBDGogAxDnJwJAIAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAZBDGogAxCANiAGKAIMIgtBBEcEQCAIIAYpAhA3AgQgCEEMaiAGQRhqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERg0NIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADA4LIAJBLGoiBkHKvMIAQQdBCkEFEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMDgsgAkEsaiIIEIYwIAtBBGohCyMAQUBqIgYkACAGQQxqQYq8wgBBCxCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyAGQSxqIglBlbzCAEEFQQZBARDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAMgCygCABCqGyAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyADEMYhIAZBLGoiCUGavMIAQQlBBkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALKAIEEKobIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAMQxiEgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQwgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMDQsgAkEsaiIGQdG8wgBBBEEKQQYQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwNCyACQSxqIggQhjAjAEEgayIGJAAgBkH+tsIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQsgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMDAsgAkEsaiIGQdW8wgBBBEEKQQcQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwMCyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpBkrjCAEEIEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAZBLGoiCUGauMIAQQ9BAkEBEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALLQAAENEZIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAMQxiEgBkEsaiIJQam4wgBBBEEKQQIQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwBCyAGQSxqIgkQhjAgCSALQQFqIAMQpwkgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgAxDGISAGQSxqIAMQgDYgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgCCADEOUoCyAGQQxqEN47IAZBQGskACACKAIsIgZBBEYNCiAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwLCyACQSxqIgZB2bzCAEEJQQpBCBDoHCACQRhqIAMgBhCtFCACKAIYIghBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCDYCACAGEIYwDAsLIAJBLGoiCBCGMCALQQRqIQsjAEFAaiIGJAAgBkEMakH/wMIAQQ0QgCAgBkEsaiADEOcnAkAgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAQsgBkEsaiIJQZq4wgBBD0ECQQEQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwBCyAGQSxqIgkQhjAgCSADIAstAAAQ0RkgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAQsgAxDGISAGQSxqIglBqbjCAEEEQQpBAhDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAtBAWogAxCnCSAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyADEMYhIAZBLGogAxCANiAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAZBDGoQ3jsgBkFAayQAIAIoAiwiBkEERg0JIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAoLIAJBLGoiBkHivMIAQQdBCkEKEOgcIAJBGGogAyAGEK0UIAIoAhgiCEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAINgIAIAYQhjAMCgsgAkEsaiIIEIYwIAtBBGohCyMAQUBqIgYkACAGQQxqQaa2wgBBBxCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyAGQSxqIglBrbbCAEEIQQNBARDoHCAGQRhqIAMgCRCtFCAGKAIYIg9BBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggDzYCACAJEIYwDAELIAZBLGoiCRCGMCAJIAMgCy0AARCJGiAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyADEMYhIAZBLGoiCUG1tsIAQQhBAkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAQsgBkEsaiIJEIYwIAkgAyALLQAAENEZIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAMQxiEgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQggBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMCQsgAkEsaiIGQem8wgBBB0EKQQsQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwJCyACQSxqIggQhjAjAEEgayIGJAAgBkGut8IAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQcgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMCAsgAkEsaiIGQfC8wgBBBEEKQQwQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwICyACQSxqIggQhjAjAEEgayIGJAAgBkGOt8IAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQYgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBwsgAkEsaiIGQfS8wgBBBEEKQQ0Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwHCyACQSxqIggQhjAjAEEgayIGJAAgBkH2tsIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQUgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBgsgAkEsaiIGQfi8wgBBBEEKQQ4Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwGCyACQSxqIggQhjAjAEEgayIGJAAgBkHGuMIAQQgQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQQgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBQsgAkEsaiIGQfy8wgBBB0EKQQ8Q6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwFCyACQSxqIggQhjAjAEEgayIGJAAgBkGjvMIAQQsQgCAgBkEMaiADEOcnAkAgBigCDCILQQRHBEAgCCAGKQIQNwIEIAhBDGogBkEYaikCADcCACAIIAs2AgAMAQsgBkEMaiADEIA2IAYoAgwiC0EERwRAIAggBikCEDcCBCAIQQxqIAZBGGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBhDeOyAGQSBqJAAgAigCLCIGQQRGDQMgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMBAsgAkEsaiIGQYO9wgBBB0EKQRAQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwECyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpB3r3CAEELEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAstAABBAUYEQCALLQABIQkgBkEsaiILQem9wgBBFUEDQQEQ6BwgBkEYaiADIAsQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCxCGMAwCCyAGQSxqIgsQhjAgCyADIAkQiRogBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAgsgAxDGIQsgBkEsaiADEIA2IAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAELIAggAxDlKAsgBkEMahDeOyAGQUBrJAAgAigCLCIGQQRGDQIgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAY2AgAMAwsgAkEsaiIGQYq9wgBBCEEKQREQ6BwgAkEYaiADIAYQrRQgAigCGCIIQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAg2AgAgBhCGMAwDCyACQSxqIggQhjAgC0EEaiELIwBBQGoiBiQAIAZBDGpB+b7CAEEMEIAgIAZBLGogAxDnJwJAIAYoAiwiCUEERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCAJNgIADAELIAsoAgBBgICAgHhHBEAgBkEsaiIJQYW/wgBBA0EIQQEQ6BwgBkEYaiADIAkQrRQgBigCGCIPQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIA82AgAgCRCGMAwCCyAGQSxqIgkQhjAgCSADIAsoAgQgCygCCBCmGyAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwCCyADEMYhCyAGQSxqIAMQgDYgBigCLCILQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAs2AgAMAQsgCCADEOUoCyAGQQxqEN47IAZBQGskACACKAIsIgZBBEYNASAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBjYCAAwCCyACQSxqIgZBkr3CAEEJQQpBEhDoHCACQRhqIAMgBhCtFCACKAIYIghBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCDYCACAGEIYwDAILIAJBLGoiCBCGMCMAQUBqIgYkACAGQQxqQeG/wgBBDRCAICAGQSxqIAMQ5ycCQCAGKAIsIglBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCTYCAAwBCyALKAIIQYCAgIB4RwRAIAZBLGoiCUGFv8IAQQNBCEEBEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAgsgBkEsaiIJEIYwIAkgAyALKAIMIAsoAhAQphsgBigCLCIJQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAk2AgAMAgsgAxDGIQsgCygCAARAIAZBLGoiCUHuv8IAQQlBBkECEOgcIAZBGGogAyAJEK0UIAYoAhgiD0EERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAPNgIAIAkQhjAMAgsgBkEsaiIJEIYwIAkgAyALKAIEEKobIAYoAiwiC0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCALNgIADAILIAMQxiELIAZBLGogAxCANiAGKAIsIgtBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggCzYCAAwBCyAIIAMQ5SgLIAZBDGoQ3jsgBkFAayQAIAIoAiwiBkEERg0AIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAELIAMQxiEgAkEsaiADEIA2IAIoAiwiBkEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAGNgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBygCLCICQQRHBEAgBCAHKQIwNwIEIARBDGogB0E4aikCADcCACAEIAI2AgAMAgsgAxDGIQsgB0EsaiADEIA2IAcoAiwiAkEERwRAIAQgBykCMDcCBCAEQQxqIAdBOGopAgA3AgAgBCACNgIADAELIAQgAxDlKAsgB0EMahDeOyAHQUBrJAAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAwsgE0HgAGohEyAhQeAAayIhDQALCyADEMYhIApBLGoiAkHUt8IAQQhBB0EDEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAQsgCkEsaiICEIYwIAIgAyAbKQMgEK0bIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAELIAMQxiEgCkEsaiICQZe+wgBBCkENQQQQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwBCyAKQSxqIgIQhjAgAiADQQogGygCPCICEKwUIAooAiwiBUEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESAFNgIADAELIAIEQCAbKAI4IRMgAkHQAGwhIQNAIApBLGohCyMAQUBqIgYkACAGQQxqQba3wgBBCBCAICAGQSxqIAMQ5ycCQCAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwBCyAGQSxqIgJBvrfCAEEHQQ1BARDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAELIAZBLGoiAhCGMCACIANBCiATKAI4IgIQrBQgBigCLCIFQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAU2AgAMAQsgAgRAIBMoAjQhFiACQegDbCEiA0AgBkEsaiEIIwBBQGoiByQAIAdBDGpB7LnCAEELEIAgIAdBLGogAxDnJwJAIAcoAiwiAkEERwRAIAggBykCMDcCBCAIQQxqIAdBOGopAgA3AgAgCCACNgIADAELIBYoAtADQYCAgIB4RwRAIAdBLGoiAkH3ucIAQQlBCEEBEOgcIAdBGGogAyACEK0UIAcoAhgiBUEERwRAIAggBykCHDcCBCAIQQxqIAdBJGopAgA3AgAgCCAFNgIAIAIQhjAMAgsgB0EsaiICEIYwIAIgAyAWKALUAyAWKALYAxCmGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAHQSxqIgJB67fCAEELQQdBAhDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAELIAdBLGoiAhCGMCACIAMgFikDyAMQrRsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAQsgAxDGISAWKQMgQgJSBEAgB0EsaiICQYC6wgBBCUEKQQMQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgUQhjAgFkEgaiEPIwBBQGoiAiQAIAJBDGpBjMHCAEEOEIAgIAJBLGogAxDnJwJAIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAELIAJBLGoiBEGEwMIAQQRBBkEBEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAyAPKAL4AhCqGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwBCyADEMYhIAJBLGoiBEGawcIAQQlBDUECEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgA0EGIA8oAtACIgQQrBQgAigCLCIJQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAk2AgAMAQsgBARAIA8oAswCIRAgBEECdCENA0AgAkEsaiADIBAoAgAQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAwsgEEEEaiEQIA1BBGsiDQ0ACwsgAxDGISACQSxqIgRBo8HCAEEOQQ1BAxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIANBCCAPKALcAiIEEKwUIAIoAiwiCUEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAJNgIADAELIAQEQCAPKALYAkEIaiEQIARBDGwhDQNAIAJBLGogAyAQQQRrKAIAIBAoAgAQphsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAwsgEEEMaiEQIA1BDGsiDQ0ACwsgAxDGISACQSxqIgRBscHCAEEFQQZBBBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDygC/AIQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRBtsHCAEEKQQdBBRDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDqAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRBwMHCAEEXQQdBBhDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDsAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISACQSxqIgRB9rfCAEEVQQdBBxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAELIAJBLGoiBBCGMCAEIAMgDykDuAIQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAQsgAxDGISAPKALgAkGAgICAeEcEQCACQSxqIgRBob7CAEESQQ1BCBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIANBCiAPKALoAiIEEKwUIAIoAiwiCUEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAJNgIADAILIAQEQCAPKALkAiEQIARBGGwhDQNAIAJBLGogECADEPgKIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAQLIBBBGGohECANQRhrIg0NAAsLIAMQxiELIAJBLGoiBEHXwcIAQRBBB0EJEOgcIAJBGGogAyAEEK0UIAIoAhgiCUEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAJNgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAyAPKQPAAhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwBCyADEMYhIA8oAgBBAUYEQCAPKQMIISogAkEsaiIEQefBwgBBEUEHQQoQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADICoQrRsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDygCEARAIA8pAxghKiACQSxqIgRB+MHCAEEWQQdBCxDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAMgKhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwCCyADEMYhCyAPKQMwQgJSBEAgAkEsaiIEQY7CwgBBCkEKQQwQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgkQhjAgD0EwaiEQIwBBQGoiBCQAIARBDGpBzrjCAEEKEIAgIARBLGogAxDnJwJAIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAELIBAoAiBBgICAgHhHBEAgBEEsaiINQdi4wgBBA0EIQQEQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIBAoAiQgECgCKBCmGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAIsQYCAgIB4RwRAIARBLGoiDUHbuMIAQQNBCEECEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAQKAIwIBAoAjQQphsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgECgCAARAIBApAwghKiAEQSxqIg1B3rjCAEEKQQdBAxDoHCAEQRhqIAMgDRCtFCAEKAIYIg5BBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgDjYCACANEIYwDAILIARBLGoiDRCGMCANIAMgKhCtGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAIQBEAgECkDGCEqIARBLGoiDUHouMIAQQ5BB0EEEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAqEK0bIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAILIAMQxiELIBAoAjhBgICAgHhHBEAgBEEsaiINQfa4wgBBCUEIQQUQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIBAoAjwgECgCQBCmGyAEKAIsIg1BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDTYCAAwCCyADEMYhCyAQKAJEQYCAgIB4RwRAIARBLGoiDUH/uMIAQQlBCEEGEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gAyAQKAJIIBAoAkwQphsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgEC0AUCIOQQJHBEAgBEEsaiINQYi5wgBBEkECQQcQ6BwgBEEYaiADIA0QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADIA5BAXEQ0RkgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgEC0AUSINQQJHBEAgBEEsaiIQQZq5wgBBEkECQQgQ6BwgBEEYaiADIBAQrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgEBCGMAwCCyAEQSxqIhAQhjAgECADIA1BAXEQ0RkgBCgCLCIQQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIBA2AgAMAgsgAxDGIQsgBEEsaiADEIA2IAQoAiwiEEEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAQNgIADAELIAkgAxDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDygC7AJBgICAgHhHBEAgAkEsaiIEQZjCwgBBDkENQQ0Q6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADQQogDygC9AIiBBCsFCACKAIsIglBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgCTYCAAwCCyAEBEAgDygC8AIhECAEQQxsIQ0DQCACQSxqIQkjAEFAaiIEJAAgBEEMakH/w8IAQREQgCAgBEEsaiADEOcnAkAgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgBEEsaiIOQZDEwgBBCUEGQQEQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIBAoAgAQqhsgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISAEQSxqIg5BmcTCAEEIQQZBAhDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAELIARBLGoiDhCGMCAOIAMgECgCBBCqGyAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyADEMYhIARBLGoiDkGhxMIAQQVBBkEDEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAQsgBEEsaiIOEIYwIA4gAyAQKAIIEKobIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAMQxiEgBEEsaiADEIA2IAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAkgAxDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMBAsgEEEMaiEQIA1BDGsiDQ0ACwsgAxDGIQsgDygCIARAIA8pAyghKiACQSxqIgRBpsLCAEETQQdBDhDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAMgKhCtGyACKAIsIgRBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBDYCAAwCCyADEMYhCyAPKAKgAgRAIA8oAqQCIQkgAkEsaiIEQbnCwgBBE0EGQQ8Q6BwgAkEYaiADIAQQrRQgAigCGCIQQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIBA2AgAgBBCGMAwCCyACQSxqIgQQhjAgBCADIAkQqhsgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgDykDiAFCAlIEQCACQSxqIgRBzMLCAEEPQQpBEBDoHCACQRhqIAMgBBCtFCACKAIYIglBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgCTYCACAEEIYwDAILIAJBLGoiCRCGMCAPQYgBaiEQIwBBQGoiBCQAIARBDGpB8MLCAEEOEIAgIARBLGogAxDnJwJAIAQoAiwiDUEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSANNgIADAELIBAoAgBBAUYEQCAQKQMIISogBEEsaiINQb+9wgBBH0EHQQEQ6BwgBEEYaiADIA0QrRQgBCgCGCIOQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIA42AgAgDRCGMAwCCyAEQSxqIg0QhjAgDSADICoQrRsgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgAxDGIQsgECgCEEGAgICAeEcEQCAEQSxqIg1B/sLCAEEaQQ1BAhDoHCAEQRhqIAMgDRCtFCAEKAIYIg5BBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgDjYCACANEIYwDAILIARBLGoiDRCGMCANIANBByAQKAIYIg4QrBQgBCgCLCINQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA02AgAMAgsgDgRAIBAoAhQhDSAOQQN0IQ4DQCAEQSxqIAMgDSkDABCtGyAEKAIsIhhBBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgGDYCAAwECyANQQhqIQ0gDkEIayIODQALCyADEMYhCyAQKAIcQYCAgIB4RwRAIARBLGoiDUGYw8IAQRpBDUEDEOgcIARBGGogAyANEK0UIAQoAhgiDkEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAONgIAIA0QhjAMAgsgBEEsaiINEIYwIA0gA0EHIBAoAiQiDRCsFCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwCCyANBEAgECgCICEOIA1BA3QhDQNAIARBLGogAyAOKQMAEK0bIAQoAiwiEEEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAQNgIADAQLIA5BCGohDiANQQhrIg0NAAsLIAMQxiELIARBLGogAxCANiAEKAIsIhBBBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgEDYCAAwBCyAJIAMQ5SgLIARBDGoQ3jsgBEFAayQAIAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAILIAMQxiELIA8pA7ABQgNSBEAgAkEsaiIEQdvCwgBBFUEKQREQ6BwgAkEYaiADIAQQrRQgAigCGCIJQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAk2AgAgBBCGMAwCCyACQSxqIhAQhjAgD0GwAWohDSMAQUBqIg8kACAPQQxqQcXFwgBBFBCAICAPQSxqIAMQ5ycCQCAPKAIsIgRBBEcEQCAQIA8pAjA3AgQgEEEMaiAPQThqKQIANwIAIBAgBDYCAAwBCyANKQMAQgJSBEAgD0EsaiIEQdnFwgBBBEEKQQEQ6BwgD0EYaiADIAQQrRQgDygCGCIJQQRHBEAgECAPKQIcNwIEIBBBDGogD0EkaikCADcCACAQIAk2AgAgBBCGMAwCCyAPQSxqIgkQhjAjAEFAaiIEJAAgBEEMakHBucIAQQsQgCAgBEEsaiADEOcnAkAgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgBEEsaiIOQcy5wgBBBEEEQQEQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIA0rA0AQzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISAEQSxqIg5B0LnCAEEEQQRBAhDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAELIARBLGoiDhCGMCAOIAMgDSsDSBDPJCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyADEMYhIARBLGoiDkHUucIAQQRBBEEDEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAQsgBEEsaiIOEIYwIA4gAyANKwNQEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAELIAMQxiEgBEEsaiIOQdi5wgBBBEEEQQQQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwBCyAEQSxqIg4QhjAgDiADIA0rA1gQzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAQsgAxDGISANKAIAQQFGBEAgDSsDCCEtIARBLGoiDkHcucIAQQRBBEEFEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAgsgBEEsaiIOEIYwIA4gAyAtEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAILIAMQxiELIA0oAhAEQCANKwMYIS0gBEEsaiIOQeC5wgBBBEEEQQYQ6BwgBEEYaiADIA4QrRQgBCgCGCIYQQRHBEAgCSAEKQIcNwIEIAlBDGogBEEkaikCADcCACAJIBg2AgAgDhCGMAwCCyAEQSxqIg4QhjAgDiADIC0QzyQgBCgCLCIOQQRHBEAgCSAEKQIwNwIEIAlBDGogBEE4aikCADcCACAJIA42AgAMAgsgAxDGIQsgDSgCIARAIA0rAyghLSAEQSxqIg5B5LnCAEEEQQRBBxDoHCAEQRhqIAMgDhCtFCAEKAIYIhhBBEcEQCAJIAQpAhw3AgQgCUEMaiAEQSRqKQIANwIAIAkgGDYCACAOEIYwDAILIARBLGoiDhCGMCAOIAMgLRDPJCAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwCCyADEMYhCyANKAIwBEAgDSsDOCEtIARBLGoiDkHoucIAQQRBBEEIEOgcIARBGGogAyAOEK0UIAQoAhgiGEEERwRAIAkgBCkCHDcCBCAJQQxqIARBJGopAgA3AgAgCSAYNgIAIA4QhjAMAgsgBEEsaiIOEIYwIA4gAyAtEM8kIAQoAiwiDkEERwRAIAkgBCkCMDcCBCAJQQxqIARBOGopAgA3AgAgCSAONgIADAILIAMQxiELIARBLGogAxCANiAEKAIsIg5BBEcEQCAJIAQpAjA3AgQgCUEMaiAEQThqKQIANwIAIAkgDjYCAAwBCyAJIAMQ5SgLIARBDGoQ3jsgBEFAayQAIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAILIAMQxiELIA0oAmBBgICAgHhHBEAgD0EsaiIEQd3FwgBBEEENQQIQ6BwgD0EYaiADIAQQrRQgDygCGCIJQQRHBEAgECAPKQIcNwIEIBBBDGogD0EkaikCADcCACAQIAk2AgAgBBCGMAwCCyAPQSxqIgQQhjAgBCADQQYgDSgCaCIJEKwUIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAILIAkEQCANKAJkIQQgCUECdCEOA0AgD0EsaiADIAQoAgAQqhsgDygCLCIJQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAk2AgAMBAsgBEEEaiEEIA5BBGsiDg0ACwsgAxDGIQsgD0EsaiADEIA2IA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAELIBAgAxDlKAsgD0EMahDeOyAPQUBrJAAgAigCLCIEQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAQ2AgAMAgsgAxDGIQsgAkEsaiADEIA2IAIoAiwiBEEERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAENgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCAARAIBYpAwghKiAHQSxqIgJBibrCAEETQQdBBBDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgKhCtGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAWKAKgAwRAIBYoAqQDIQUgB0EsaiICQZy6wgBBE0EGQQUQ6BwgB0EYaiADIAIQrRQgBygCGCIEQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAQ2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCEARAIBYpAxghKiAHQSxqIgJBr7rCAEETQQdBBhDoHCAHQRhqIAMgAhCtFCAHKAIYIgVBBEcEQCAIIAcpAhw3AgQgCEEMaiAHQSRqKQIANwIAIAggBTYCACACEIYwDAILIAdBLGoiAhCGMCACIAMgKhCtGyAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwCCyADEMYhCyAWKAKoAwRAIBYoAqwDIQUgB0EsaiICQcK6wgBBE0EGQQcQ6BwgB0EYaiADIAIQrRQgBygCGCIEQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAQ2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIAUQqhsgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigCsANBgYCAgHhHBEAgB0EsaiICQdW6wgBBD0EKQQgQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgkQhjAgFkGwA2ohDyMAQUBqIgUkACAFQQxqQf3EwgBBFBCAICAFQSxqIAMQ5ycCQCAFKAIsIgJBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgAjYCAAwBCwJAAkAgDygCAEGAgICAeEcEQCAFQSxqIgJBq8XCAEEaQQpBAhDoHCAFQRhqIAMgAhCtFCAFKAIYIgRBBEYNASAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgBDYCACACEIYwDAMLIAVBLGoiAkGRxcIAQRpBCkEBEOgcIAVBGGogAyACEK0UIAUoAhgiBEEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAENgIAIAIQhjAMAwsgBUEsaiIEEIYwIwBBIGsiAiQAIAJBssbCAEEXEIAgIAJBDGogAxDnJwJAIAIoAgwiD0EERwRAIAQgAikCEDcCBCAEQQxqIAJBGGopAgA3AgAgBCAPNgIADAELIAJBDGogAxCANiACKAIMIg9BBEcEQCAEIAIpAhA3AgQgBEEMaiACQRhqKQIANwIAIAQgDzYCAAwBCyAEIAMQ5SgLIAIQ3jsgAkEgaiQAIAUoAiwiAkEERg0BIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAILIAVBLGoiBBCGMCMAQUBqIgIkACACQQxqQY/GwgBBFxCAICACQSxqIAMQ5ycCQCACKAIsIhBBBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgEDYCAAwBCyACQSxqIhBBo8HCAEEOQQ1BARDoHCACQRhqIAMgEBCtFCACKAIYIg1BBEcEQCAEIAIpAhw3AgQgBEEMaiACQSRqKQIANwIAIAQgDTYCACAQEIYwDAELIAJBLGoiEBCGMCAQIANBCCAPKAIIIg0QrBQgAigCLCIQQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIBA2AgAMAQsgDQRAIA8oAgRBCGohECANQQxsIQ0DQCACQSxqIAMgEEEEaygCACAQKAIAEKYbIAIoAiwiDkEERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAONgIADAMLIBBBDGohECANQQxrIg0NAAsLIAMQxiEgDygCDEGAgICAeEcEQCACQSxqIhBBpsbCAEEMQQhBAhDoHCACQRhqIAMgEBCtFCACKAIYIg1BBEcEQCAEIAIpAhw3AgQgBEEMaiACQSRqKQIANwIAIAQgDTYCACAQEIYwDAILIAJBLGoiEBCGMCAQIAMgDygCECAPKAIUEKYbIAIoAiwiD0EERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAPNgIADAILIAMQxiELIAJBLGogAxCANiACKAIsIg9BBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgDzYCAAwBCyAEIAMQ5SgLIAJBDGoQ3jsgAkFAayQAIAUoAiwiAkEERg0AIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiAkEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSACNgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgBygCLCICQQRHBEAgCCAHKQIwNwIEIAhBDGogB0E4aikCADcCACAIIAI2AgAMAgsgAxDGIQsgFigC3ANBgICAgHhHBEAgB0EsaiICQeS6wgBBGUEIQQkQ6BwgB0EYaiADIAIQrRQgBygCGCIFQQRHBEAgCCAHKQIcNwIEIAhBDGogB0EkaikCADcCACAIIAU2AgAgAhCGMAwCCyAHQSxqIgIQhjAgAiADIBYoAuADIBYoAuQDEKYbIAcoAiwiAkEERwRAIAggBykCMDcCBCAIQQxqIAdBOGopAgA3AgAgCCACNgIADAILIAMQxiELIAdBLGogAxCANiAHKAIsIgJBBEcEQCAIIAcpAjA3AgQgCEEMaiAHQThqKQIANwIAIAggAjYCAAwBCyAIIAMQ5SgLIAdBDGoQ3jsgB0FAayQAIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAMLIBZB6ANqIRYgIkHoA2siIg0ACwsgAxDGISAGQSxqIgJBxbfCAEEPQQdBAhDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAELIAZBLGoiAhCGMCACIAMgEykDIBCtGyAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwBCyADEMYhIAZBLGoiAkHUt8IAQQhBB0EDEOgcIAZBGGogAyACEK0UIAYoAhgiBUEERwRAIAsgBikCHDcCBCALQQxqIAZBJGopAgA3AgAgCyAFNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgAyATKQMoEK0bIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAELIAMQxiEgEygCPEGAgICAeEcEQCAGQSxqIgJB3LfCAEEPQQ1BBBDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIANBCiATKAJEIgIQrBQgBigCLCIFQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAU2AgAMAgsgAgRAIBMoAkAhFiACQQN0ISIDQCAGQSxqIQUjAEFAaiICJAAgAkEMakHTwMIAQQ0QgCAgAkEsaiADEOcnAkAgAigCLCIHQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAc2AgAMAQsgAkEsaiIHQeDAwgBBCkEGQQEQ6BwgAkEYaiADIAcQrRQgAigCGCIEQQRHBEAgBSACKQIcNwIEIAVBDGogAkEkaikCADcCACAFIAQ2AgAgBxCGMAwBCyACQSxqIgcQhjAgByADIBYoAgAQqhsgAigCLCIHQQRHBEAgBSACKQIwNwIEIAVBDGogAkE4aikCADcCACAFIAc2AgAMAQsgAxDGISACQSxqIgdB6sDCAEEKQQJBAhDoHCACQRhqIAMgBxCtFCACKAIYIgRBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgBDYCACAHEIYwDAELIAJBLGoiBxCGMCAHIAMgFi0ABBDRGSACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyADEMYhIAJBLGoiB0H0wMIAQQtBAkEDEOgcIAJBGGogAyAHEK0UIAIoAhgiBEEERwRAIAUgAikCHDcCBCAFQQxqIAJBJGopAgA3AgAgBSAENgIAIAcQhjAMAQsgAkEsaiIHEIYwIAcgAyAWLQAFENEZIAIoAiwiB0EERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAHNgIADAELIAMQxiEgAkEsaiADEIA2IAIoAiwiB0EERwRAIAUgAikCMDcCBCAFQQxqIAJBOGopAgA3AgAgBSAHNgIADAELIAUgAxDlKAsgAkEMahDeOyACQUBrJAAgBigCLCICQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAI2AgAMBAsgFkEIaiEWICJBCGsiIg0ACwsgAxDGIQsgEygCAARAIBMpAwghKiAGQSxqIgJB67fCAEELQQdBBRDoHCAGQRhqIAMgAhCtFCAGKAIYIgVBBEcEQCALIAYpAhw3AgQgC0EMaiAGQSRqKQIANwIAIAsgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIAMgKhCtGyAGKAIsIgJBBEcEQCALIAYpAjA3AgQgC0EMaiAGQThqKQIANwIAIAsgAjYCAAwCCyADEMYhCyATKAIQBEAgEykDGCEqIAZBLGoiAkH2t8IAQRVBB0EGEOgcIAZBGGogAyACEK0UIAYoAhgiBUEERwRAIAsgBikCHDcCBCALQQxqIAZBJGopAgA3AgAgCyAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgAyAqEK0bIAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAILIAMQxiELIBMvAUgEQCATLwFKIQUgBkEsaiICQYu4wgBBB0EFQQcQ6BwgBkEYaiADIAIQrRQgBigCGCIHQQRHBEAgCyAGKQIcNwIEIAtBDGogBkEkaikCADcCACALIAc2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiADIAUQqBsgBigCLCICQQRHBEAgCyAGKQIwNwIEIAtBDGogBkE4aikCADcCACALIAI2AgAMAgsgAxDGIQsgBkEsaiADEIA2IAYoAiwiAkEERwRAIAsgBikCMDcCBCALQQxqIAZBOGopAgA3AgAgCyACNgIADAELIAsgAxDlKAsgBkEMahDeOyAGQUBrJAAgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAwsgE0HQAGohEyAhQdAAayIhDQALCyADEMYhIBsoAkBBgICAgHhHBEAgCkEsaiICQaG+wgBBEkENQQUQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwCCyAKQSxqIgIQhjAgAiADQQogGygCSCICEKwUIAooAiwiBUEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESAFNgIADAILIAIEQCAbKAJEIRMgAkEYbCEhA0AgCkEsaiATIAMQ+AogCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMBAsgE0EYaiETICFBGGsiIQ0ACwsgAxDGIQsgGygCTEGAgICAeEcEQCAKQSxqIgJBs77CAEEKQQhBBhDoHCAKQRhqIAMgAhCtFCAKKAIYIgVBBEcEQCARIAopAhw3AgQgEUEMaiAKQSRqKQIANwIAIBEgBTYCACACEIYwDAILIApBLGoiAhCGMCACIAMgGygCUCAbKAJUEKYbIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAILIAMQxiELIBsoAlhBgICAgHhHBEAgCkEsaiICQb2+wgBBDUENQQcQ6BwgCkEYaiADIAIQrRQgCigCGCIFQQRHBEAgESAKKQIcNwIEIBFBDGogCkEkaikCADcCACARIAU2AgAgAhCGMAwCCyAKQSxqIgIQhjAgAiADQQogGygCYCITEKwUIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAILIBMEQANAIApBLGohBSMAQUBqIgIkACACQQxqQfW7wgBBCxCAICACQSxqIAMQ5ycCQCACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyACQSxqIgdBgLzCAEEKQQpBARDoHCACQRhqIAMgBxCtFCACKAIYIgRBBEcEQCAFIAIpAhw3AgQgBUEMaiACQSRqKQIANwIAIAUgBDYCACAHEIYwDAELIAJBLGoiBBCGMCMAQSBrIgckACAHQcfDwgBBEBCAICAHQQxqIAMQ5ycCQCAHKAIMIgZBBEcEQCAEIAcpAhA3AgQgBEEMaiAHQRhqKQIANwIAIAQgBjYCAAwBCyAHQQxqIAMQgDYgBygCDCIGQQRHBEAgBCAHKQIQNwIEIARBDGogB0EYaikCADcCACAEIAY2AgAMAQsgBCADEOUoCyAHEN47IAdBIGokACACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyADEMYhIAJBLGogAxCANiACKAIsIgdBBEcEQCAFIAIpAjA3AgQgBUEMaiACQThqKQIANwIAIAUgBzYCAAwBCyAFIAMQ5SgLIAJBDGoQ3jsgAkFAayQAIAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAQLIBNBAWsiEw0ACwsgAxDGIQsgGygCAEECRwRAIApBLGoiAkHKvsIAQRRBCkEIEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAgsgCkEsaiIEEIYwIwBBQGoiBSQAIAVBDGpBpsTCAEETEIAgIAVBLGogAxDnJwJAIAUoAiwiAkEERwRAIAQgBSkCMDcCBCAEQQxqIAVBOGopAgA3AgAgBCACNgIADAELAkACQCAbKAIAQQFGBEAgBUEsaiICQcPEwgBBDkEKQQIQ6BwgBUEYaiADIAIQrRQgBSgCGCIHQQRGDQEgBCAFKQIcNwIEIARBDGogBUEkaikCADcCACAEIAc2AgAgAhCGMAwDCyAFQSxqIgJBucTCAEEKQQpBARDoHCAFQRhqIAMgAhCtFCAFKAIYIgdBBEcEQCAEIAUpAhw3AgQgBEEMaiAFQSRqKQIANwIAIAQgBzYCACACEIYwDAMLIAVBLGoiBxCGMCAbQQRqIQYjAEFAaiICJAAgAkEMakHEtsIAQQgQgCAgAkEsaiADEOcnAkAgAigCLCIIQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAg2AgAMAQsgBigCAEGAgICAeEcEQCACQSxqIghBzLbCAEEKQQhBARDoHCACQRhqIAMgCBCtFCACKAIYIgtBBEcEQCAHIAIpAhw3AgQgB0EMaiACQSRqKQIANwIAIAcgCzYCACAIEIYwDAILIAJBLGoiCBCGMCAIIAMgBigCBCAGKAIIEKYbIAIoAiwiCEEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAINgIADAILIAMQxiELIAYoAgxBgICAgHhHBEAgAkEsaiIIQda2wgBBD0EIQQIQ6BwgAkEYaiADIAgQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgCBCGMAwCCyACQSxqIggQhjAgCCADIAYoAhAgBigCFBCmGyACKAIsIghBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgCDYCAAwCCyADEMYhCyAGLQAYIghBAkcEQCACQSxqIgZB5bbCAEERQQJBAxDoHCACQRhqIAMgBhCtFCACKAIYIgtBBEcEQCAHIAIpAhw3AgQgB0EMaiACQSRqKQIANwIAIAcgCzYCACAGEIYwDAILIAJBLGoiBhCGMCAGIAMgCEEBcRDRGSACKAIsIgZBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgBjYCAAwCCyADEMYhCyACQSxqIAMQgDYgAigCLCIGQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAY2AgAMAQsgByADEOUoCyACQQxqEN47IAJBQGskACAFKAIsIgJBBEYNASAEIAUpAjA3AgQgBEEMaiAFQThqKQIANwIAIAQgAjYCAAwCCyAFQSxqIgcQhjAgG0EEaiEGIwBBQGoiAiQAIAJBDGpBtrnCAEELEIAgIAJBLGogAxDnJwJAIAIoAiwiCEEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAINgIADAELIAYoAgBBgICAgHhHBEAgAkEsaiIIQcy2wgBBCkEIQQEQ6BwgAkEYaiADIAgQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgCBCGMAwCCyACQSxqIggQhjAgCCADIAYoAgQgBigCCBCmGyACKAIsIghBBEcEQCAHIAIpAjA3AgQgB0EMaiACQThqKQIANwIAIAcgCDYCAAwCCyADEMYhCyAGKAIMQYCAgIB4RwRAIAJBLGoiCEHWtsIAQQ9BCEECEOgcIAJBGGogAyAIEK0UIAIoAhgiC0EERwRAIAcgAikCHDcCBCAHQQxqIAJBJGopAgA3AgAgByALNgIAIAgQhjAMAgsgAkEsaiIIEIYwIAggAyAGKAIQIAYoAhQQphsgAigCLCIIQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAg2AgAMAgsgAxDGIQsgBi0AGCIIQQJHBEAgAkEsaiIGQeW2wgBBEUECQQMQ6BwgAkEYaiADIAYQrRQgAigCGCILQQRHBEAgByACKQIcNwIEIAdBDGogAkEkaikCADcCACAHIAs2AgAgBhCGMAwCCyACQSxqIgYQhjAgBiADIAhBAXEQ0RkgAigCLCIGQQRHBEAgByACKQIwNwIEIAdBDGogAkE4aikCADcCACAHIAY2AgAMAgsgAxDGIQsgAkEsaiADEIA2IAIoAiwiBkEERwRAIAcgAikCMDcCBCAHQQxqIAJBOGopAgA3AgAgByAGNgIADAELIAcgAxDlKAsgAkEMahDeOyACQUBrJAAgBSgCLCICQQRGDQAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIAI2AgAMAQsgAxDGISAFQSxqIAMQgDYgBSgCLCICQQRHBEAgBCAFKQIwNwIEIARBDGogBUE4aikCADcCACAEIAI2AgAMAQsgBCADEOUoCyAFQQxqEN47IAVBQGskACAKKAIsIgJBBEcEQCARIAopAjA3AgQgEUEMaiAKQThqKQIANwIAIBEgAjYCAAwCCyADEMYhCyAbKAJkQYCAgIB4RwRAIApBLGoiAkHevsIAQRtBCEEJEOgcIApBGGogAyACEK0UIAooAhgiBUEERwRAIBEgCikCHDcCBCARQQxqIApBJGopAgA3AgAgESAFNgIAIAIQhjAMAgsgCkEsaiICEIYwIAIgAyAbKAJoIBsoAmwQphsgCigCLCICQQRHBEAgESAKKQIwNwIEIBFBDGogCkE4aikCADcCACARIAI2AgAMAgsgAxDGIQsgCkEsaiADEIA2IAooAiwiAkEERwRAIBEgCikCMDcCBCARQQxqIApBOGopAgA3AgAgESACNgIADAELIBEgAxDlKAsgCkEMahDeOyAKQUBrJAACQCADKAIoIgJBBEcEQCADQcgAaiADQTRqKQIANwIAIAMgAykCLDcCQCADIAI2AjwgHyADQTxqEKUlDAELIB9BCDYCAAsgAxC6LiADQdAAaiQAIBIoAugBIgNBCEcEQCAZIBIpAuwBNwIMIBlBHGogEkH8AWooAgA2AgAgGUEUaiASQfQBaikCADcCACAZQQM2AgAgGSADNgIIDAILIBIgKCgCACIDKAIcIClrNgLMASASQegBaiICIAMgEkHMAWpBBBCnGgJAIBItAOgBQQRGDQAgEikD6AEiKkL/AYNCBFENACASICo3A+gBIBlBCGogAhCBKyAZQQM2AgAMAgsgEkHoAWoiAyAoKAIAQYD2zwBBBBCnGgJAIBItAOgBQQRGDQAgEikD6AEiKkL/AYNCBFENACASICo3A+gBIBlBCGogAxCBKyAZQQM2AgAMAgsgEigCEEGAgICAeEcEQCASQYgCaiICIBJBGGooAgA2AgAgEiASKQIQNwOAAiASQfwAaiIDEPQbIAMQ7zsgA0EIaiACKAIANgIAIAMgEikDgAI3AgALIBkgEkHIAGpB+AD8CgAAIBoQhzAMBAsgEikD+AEhKiAZIBIpA9gBNwIMIBkgKjcDGCAZIAo2AgggGUEDNgIAIBlBFGogBSgCADYCACASQcwBahCHMCASQcABaiIDEPQbIAMQ7zsgEkE8ahCGMCASQRxqELsuIBJBEGoQkjAgEkEEahCRMAwCCyASQcgAahCSKCASQRBqEJIwDAELIBkgEikCTDcCDCAZQRxqIBJB3ABqKAIANgIAIBlBFGogEkHUAGopAgA3AgAgGUEDNgIAIBkgHTYCCCAXEPQbIBcQ7zsLIBdBDGoQhzAgF0EYaiEdCyAdEIYwIBJBkAJqJAALIBRBsAFqJAAMAQsgBSAUKAJwQfDFwwAQ/S8ACyAVKAKYASIDQQNGBEAgFUGMAWogFUGwAWopAwAiKjcCACAVQYQBaiAVQagBaikDACIrNwIAIBUgFSkDoAEiLDcCfCAeQRhqICo3AgAgHkEQaiArNwIAIB4gLDcCCCAeQQM2AgAMAQsgFUGQAWoiAiAVQbQBaigCADYCACAVQYgBaiIFIBVBrAFqKQIANwMAIBVBgAFqIgogFUGkAWopAgA3AwAgFSAVKQKcATcDeCAVQSBqIBVBuAFqQdgA/AoAACAVQQxqIAopAwA3AgAgFUEUaiAFKQMANwIAIBVBHGogAigCADYCACAVIAM2AgAgFSAVKQN4NwIEIBVBmAFqIgMgHBCdGQJAIBUtAJgBQQRGDQAgFSkDmAEiKkL/AYNCBFENACAVICo3A5gBIB5BCGogAxCBKyAeQQM2AgAgFRDYHAwBCyAeIBVB+AD8CgAACyAVQZACaiQADAELIAMgFSgCoAFB8MXDABD9LwALCyAnQSBqJAAgDCgCkAciA0EDRgRAIAxBgAdqIAxBpAdqKQIAIio3AwAgDEGIB2ogDEGsB2ooAgAiATYCACAMQfAJaiAqNwMAIAxB+AlqIAE2AgAgDCAMKQKcByIqNwP4BiAMICo3A+gJIAwoApgHIQMMBgsgDEGAB2oiIyAMQaQHaikCADcDACAMQYgHaiICIAxBrAdqKAIANgIAIAwgDCkCnAc3A/gGIAwpApQHISogDEGICGoiBSAMQbAHakHYAPwKAAAgACAqNwLsCCAAIAM2AugIIAAgDCkD+AY3AvQIIABB/AhqICMpAwA3AgAgAEGECWogAigCADYCACAAQYgJaiAFQdgA/AoAACAAQQA6APwJIAAgACgC5Ak2AvAJCyAMQZAHaiAAQfAJaiABEMYOQQMgDCgCkAciA0EJRg0BGiAMQfAIaiAMQaQHaigCADYCACAMQegIaiAMQZwHaikCADcDACAMIAwpApQHNwPgCCAALQD8CUEDRgRAIABB9AlqELwqCyAMQeAIaiADQQhHDQMaIAAoAuQJIQMgDEEAOgCUByAMIAM2ApAHQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgDEGQB2oiAikCADcCACADQQhqIAJBCGooAgA2AgAgDEEIaiICQfyjwwA2AgQgAiADNgIAIAwoAgghAyAAIAwoAgwiIzYC9AkgACADNgLwCQsgDEGQB2ogAyABICMoAgwRAQAgDCgCkAciA0EJRw0BQQQLIQEgJSABOgAADAQLIAxBiAlqIAxBpAdqKAIANgIAIAxBgAlqIAxBnAdqKQIANwMAIAwgDCkClAc3A/gIIABB8AlqELwqIANBCEYNAiAMQfgIagsiAUEQaigCADYCACAMQfAJaiABQQhqKQIANwMAIAwgASkCADcD6AkgJBDUHAsgJUEBOgAAQQMhJQwCCyAMQfAJaiAAQfwIaikCADcDACAMQfgJaiAAQYQJaigCADYCACAMIAApAvQINwPoCSAAKALwCCEDIAAoAuwIISMgACgC6AghJSAMQZAJaiAAQYgJakHYAPwKAAAgAEEBOgDoCSAlQQRHDQELICZBAzoAAEEBIQNBBiEgDAILICQQ5SogAEGQB2oQ1AwgDEHYBmoiASAMQfgJaigCADYCACAMQdAGaiICIAxB8AlqKQMANwMAIAwgDCkD6Ak3A8gGIAxB8AVqIgUgDEGQCWpB2AD8CgAAIABBAToAgAogDEHEAGogAikDADcCACAMQcwAaiABKAIANgIAIAwgAzYCOCAMICM2AjQgDCAMKQPIBjcCPCAMICU2AjAgDEHQAGogBUHYAPwKAAAgIBDRLQJAICVBA0cEQCAMQTBqENQcDAELIAxBOGoQySMLIABBADoAswULIABBqAFqEJ0vIAAtALIFBEAgAEGABWoQhxoLQQAhA0EBISAgAC0AsQVFDQAgACkDAEICUQ0AIAAQoCkLIAAgIDoAsAUgDEGACmokACADC+LdBARcfw1+GH0CfCMAQdAAayI7JAAgOyAAKQPoASAAKQP4AX0iYaciCTYCKCAAKAL4KSEjIAAQ+A4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtALoqDQAgAQRAIABBAToAuioLIAAQ+A4gYUEBIAAoAiR0rVYNACA7IAAtAL4qNgIsIAAgACkD6AEgACkD8AF9pyIEIAkgBCAJSxtBAXRBjwRqEMkaAkACQAJAAkACQAJAAkACQCAAKALMAQRAIAAoAsgBIAAtALgqOgAAAkACQCAAKALMASIEQQFLBEAgAEG+KmohKyAAKALIASAALQC5KjoAASAALQC9Kg4EAQICCwILQQEgBEHAvNAAEMMhAAsgAC0AX0EBRw0AIAAoAsgBIQcgACgCzAEhBiMAQSBrIgQkAEEBQgAgO0EsaiIMIAcgBhDlEkECQgMgDCAHIAYQ5RJBAUIAIAwgByAGEOUSQQJCASAMIAcgBhDlEiAEQRhqQQA7AQAgBEIANwMQIABBCGoiDTUCICFgQQEhBQJAA0AgBCAFakEPaiIKIGCnIh1B/wBxOgAAIGBCgAFUDQEgCiAdQYABcjoAACBgQgeIIWAgBUEBaiIFQQtHDQALQQohBQsgBEEIaiAEQRhqLwEAOwEAIAQgBCkDEDcDAEEIIAWtQgN8IAwgByAGEOUSIAwgDCgCAEEHaiIKQXhxNgIAAkACQCAGIApBA3YiCksEQCAHIApqQQA6AAAgDS0AVEUNASANLQBVDQEgBEGBAToADyAEQeGvAjsADQwCCyAKIAZBzOzRABDDIQALIARB4a8COwANIA0tAFZFBEAgBEGAAToADwwBCyAEQYIBOgAPC0EAIQoDQEEIIARBDWogCmoxAAAgDCAHIAYQ5RIgCkEBaiIKQQNHDQALQQhCASAMIAcgBhDlEgJAIAVBC0kEQEEAIQoDQEEIIAQgCmoxAAAgDCAHIAYQ5RIgBSAKQQFqIgpHDQALIARBIGokAAwBCyAFQQpBrO7RABCwOwALIDsoAiwiBkEDdiIbIAAoAswBIgRPDQIgG0EBaiIFIARPDQggACgCyAEhBCADIBs2AgAgBCAbai0AACEHIAQgBWotAAAhBCAAIAZBB3E6AL4qIABCADcDACAAQQE6AL0qIAAgByAEQQh0cjsBuCoLIAAtAFxFBEAgAEEDOgC9KgwJCyAJRQRAQQAhCQwJCyAAKQP4AUICWgRAIAAtALwqRQ0DCyAAKALwKSIFIAAoAowqIgRJDQMgK0EAIAAoAuwpIARqIgYgBSAEayIEIAAoAvABICMgAEEIakECIAkgCUECTxsiByAAQbAqaiA7QSxqIAAoAsgBIAAoAswBQQAQtQ4gOygCLCINQQN2IhsgACgCzAEiBU8NBCAbQQFqIgwgBU8NBSAAKALIASIFIBtqLQAAIQogBSAMai0AACEFIAAgDUEHcToAviogACAALQC/KjoAwCogACAKIAVBCHRyOwG4KiAjIAApA/ABImCnIgxxIgUgBE8NBiAAIAUgBmotAAAiBToAvyoCQCAJQQFGIg1FBEAgACAFOgDAKiAMQQFqICNxIgUgBE8NASAAIAUgBmotAAA6AL8qCyAAQgA3AwAgAyAbNgIAIAAgYCAHrSJhfDcD8AEgACAAKQP4ASBhfCJgNwP4ASAAQQNBAiAALQC9KkECRhtBAyANGzoAvSogOyAJIAdrIgk2AiggACkD6AEgYH0hYQwJCyAFIARBiL7QABDDIQALQQBBAEGwvNAAEMMhAAsgGyAEQdC80AAQwyEAC0HwvNAAQcgAQbi90AAQnykACyAEIAVByL3QABCvOwALIBsgBUHYvdAAEMMhAAsgDCAFQei90AAQwyEACyAFIARB+L3QABDDIQALIAUgBEHgvNAAEMMhAAsgOyAAKQP4ARDLKyIHNgIwAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIgRBAUYEQEEBIQQgACgC3AENASA7QSBqICtBgIAIELkpIDsoAiQhBCA7KAIgIQUgACgC3AEiBgRAIAAoAtgBIAZBAnRBBBD4OgsgACAENgLcASAAIAU2AtgBIDtBGGogK0GAgAgQuCkgOygCHCEEIDsoAhghBSAAKALkASIGBEAgACgC4AEgBkEBEPg6CyAAIAQ2AuQBIAAgBTYC4AEgACgCHCEECyAEQQJPDQELIDtBADYCQCABRSBhUHENCCAAKALwKSIGIAAoAowqIgVJDQEgACgC7CkhDCA7IABB0AJqIABB0AFqIAQgCSA7QUBrELwQIAcgI3EhAiAGIAVrIQQgBSAMaiEFIDsoAgQhBiA7KAIAIQcCQCAAKAIcRQRAIAIgBEsNBCACIAVqIAQgAmsgCSABIAcgBiA7KAJAIABB0CJqIABB0CNqIABBpCpqIABB0CVqIDtBLGogACgCyAEgACgCzAEQghcMAQsgAiAESw0EIAIgBWogBCACayAJIAEgACgC2AEgACgC3AEgACgC4AEgACgC5AEgByAGIDsoAkAgO0EsaiAAKALIASAAKALMARDhDAsgOygCLCIFQQN2IgEgACgCzAEiAk8NBCACIAFBAWoiBEsEQCABIAAoAsgBIgJqLQAAIQEgAiAEai0AACECIAAgBUEHcToAviogACABIAJBCHRyOwG4KiAAKQP4ARDLKxogACkD6AEiYBDLKxogAEIANwMAIAAgYDcD+AEgOygCLEEDdiEbDAkLIAQgAkHYvtAAEMMhAAsgAEGUKmohDyAAKAKUKiAJQQF2akEBaiIEIAAoApAqTQ0GIAAgCUECdiAEakEQaiIENgKQKiA7QcgAakIANwMAIDtCADcDQCA7QTRqIgUgO0FAayAEEIMcIDtBEGogBUHMgs4AEJ0hIDsoAhQhBSA7KAIQIQYCQCAAKALEASIJRQ0AIA8oAgAiBCAFSw0FIAQgCUsNBiAEQQR0IgQEQCAGIAAoAsABIAT8CgAACyA7QQA2AkggO0KAgICAwAA3AkAgO0EIaiA7QUBrQYyHzgAQnSEgOygCCCEHIAAoAsQBIQQgACA7KAIMIgk2AsQBIAAoAsABIQwgACAHNgLAASAEBEAgDCAEQQR0QQQQ+DogACgCxAEhCQsgCUUNACAAKALAASAJQQR0QQQQ+DoLIAAgBTYCxAEgACAGNgLAAQwGCyAFIAZBmL7QABCvOwALIAIgBEGovtAAEK87AAsgAiAEQbi+0AAQrzsACyABIAJByL7QABDDIQALIAQgBUHovtAAELA7AAsgBCAJQfi+0AAQsDsACwJAAkACQCAAKALwKSIFIAAoAowqIgRPBEAgAEEIaiElIAAoArQqIQcgACgC7CkgBGohCCAFIARrIRAgOygCMCEEIDsoAighCSMAQeAAayI9JAAgAEHoAGoiQSgCACEFAkACQAJAIARFBEAgBUUNASBBIAEgCSAIIBAQ/hBFDQMgQRCUKkIANwIcDAMLIAUNAQtBCiEGAkACQCAlKAIUIgVBCkgNACAlLQBQQQFGDQBBKCESDAELAkACQCAFQQlrDgIBAQALQSghEiAFQQRHICUoAiAiBkH//z9NckUEQEE2IQYMAgsgBUEFSARAIAUhBgwCCwJAICUoAhgiDEERTgRAAkAgJS0AUEUEQCAGQYGAgAJJIAxBEk1yDQEMAwsgBkGBgMAASQ0AIAxBEksNAgsgJUEFNgIoICVBCSAFQQFrIgwgDEEJTxs2AjAgJUEOQQ8gBkGBgMAASRtBDyAFQQdJIgYbNgIsQQRBCkEQIAVBCUkbIAYbIQZBOCESDAMLQShBKUEqIAVBCUkbIAVBB0kbIQYMAgsgJUKGgICA8AE3AiggJUEFNgI0ICVBCSAFQQFrIgYgBkEJTxs2AjBBBEEKQRAgBUEJSRsgBUEHSRshBkE4IRIMAQsgJUEQNgI4ICVCiYCAgPABNwIoICVBCDYCMEEEIQZBNCESCyASICVqIAY2AgAgPUEIaiEdIAchDCMAQUBqIhckACAlQShqIQUCQAJAAkACQAJAAkACQAJAAkACQCAlKAIoIgZBAmsOCQABAgMHBwcEBQYLIB0gBSkCADcCDCAdQRxqIAVBEGopAgA3AgAgHUEUaiAFQQhqKQIANwIAIBcgK0GJgAQQuSkgFygCACEFIBcoAgQhBiAdQQA2AiwgHUEANgIoIB1BATYCJCAdIAY2AgggHSAFNgIEIB1BATYCACAdICUoAjwiBUGcBCAFGzYCMAwICyAdIAUpAgA3AgwgHUEcaiAFQRBqKQIANwIAIB1BFGogBUEIaikCADcCACAXQQhqICtBioAEELkpIBcoAgghBSAXKAIMIQYgHUEANgIsIB1BADYCKCAdQQE2AiQgHSAGNgIIIB0gBTYCBCAdQQI2AgAgHSAlKAI8IgVBnAQgBRs2AjAMBwsgHSAFKQIANwIMIB1BHGogBUEQaikCADcCACAdQRRqIAVBCGopAgA3AgAgF0EQaiArQYiACBC5KSAXKAIQIQUgFygCFCEGIB1BADYCLCAdQQA2AiggHUEBNgIkIB0gBjYCCCAdIAU2AgQgHUEDNgIAIB0gJSgCPCIFQZwEIAUbNgIwDAYLIwBBIGsiBiQAIAZBCGogK0IBICUoAiwiB0E/ca2GImAgJSgCMCISQT9xrSJhhqcQuSkgBigCDCEMIAYoAgghDSAGQRRqIgUgYKciDkHEntAAEJkVIAYgBUHMgs4AEKohICVBKGohBSAGKAIEIQogBigCACERAn8CfwJAAkACQAJAIBJBBGsOAwACAQILIAdBH3FBDkcNASAdIA02AgwgHSAKNgIIIB0gETYCBCAdIAUpAgA3AhQgHUEcaiAFQQhqKQIANwIAQRAhCiAdQSRqIAVBEGopAgA3AgBBByENICUoAjwiBUGcBCAFGwwDCyAHQR9xQQ9GDQELIB1BADYCNCAdQgE3AiwgHSASNgIcIB0gBzYCGCAdIAw2AhAgHSANNgIMIB0gCjYCCCAdIBE2AgQgHSAlKQI0NwIgIB0gJSgCKDYCFCAdQShqICVBPGooAgAiBTYCAEEgIAdrIQxCfyBhhqdBf3MhByAFQZwEIAUbIRFBBSENQcgAIQVBxAAhFkHAACEwQTghCkE8DAILIB0gDTYCDCAdIAo2AgggHSARNgIEIB0gBSkCADcCFCAdQRxqIAVBCGopAgA3AgBBECEKIB1BJGogBUEQaikCADcCAEEGIQ0gJSgCPCIFQZwEIAUbCyERQTghBUE0IRZBACEHQTAhMEEBIQ5BACESQSwLIAogHWogDDYCACAdaiAONgIAIB0gMGogBzYCACAWIB1qIBI2AgAgHSANNgIAIAUgHWogETYCACAGQSBqJAAMBQsgHSAFKQIANwIUIB1BJGogBUEQaikCADcCACAdQRxqIAVBCGopAgA3AgAgF0E0aiIFQYCAAkHEntAAEJkVIBdBIGogBUHMgs4AEKohIBcoAiAhBSAXKAIkIQYgF0EYaiArQYCAgAQQuSkgFygCGCEHIBcoAhwhDCAdQQA2AjQgHUEANgIwIB1BATYCLCAdIAw2AhAgHSAHNgIMIB0gBjYCCCAdIAU2AgQgHUEJNgIAIB0gJSgCPCIFQZwEIAUbNgI4DAQLIwBBEGsiDSQAICUoAhghBSANQQhqICtBgIAIELkpQQFBASAFdCIKayESIA0oAgghBiANKAIMIhEEQCARQQJ0IQcgBiEFA0AgBSASNgIAIAVBBGohBSAHQQRrIgcNAAsLIB1BBGoiBSAlKQIoNwIYIAVBKGogJUE4aikCADcCACAFQSBqICVBMGopAgA3AgAgDSArIApBAXQQuSkgDSkDACFgIAVBADYCOCAFQgE3AjAgBSAMNgIUIAUgCkEBazYCECAFIBI2AjwgBSARNgIEIAUgBjYCACAFIGA3AgggDUEQaiQAIB1BCjYCAAwDCyAGQTZGDQELIwBBIGsiBSQAIAVBCGogK0IBICUoAiwiBkE/ca2GImAgJSgCMCIHQT9xrSJhhqcQuSkgBSkDCCFiIAVBFGoiDCBgp0HEntAAEJkVIAUgDEHMgs4AEKohIAUpAwAhYCAdQQA2AlAgHUIBNwNIIB0gBzYCOCAdIAY2AjQgHSAHNgIsIB1CfyBhhqdBf3M2AiggHUEBIAZ0NgIkIB1BwAAgBms2AiAgHSBiNwMQIB0gYDcDCCAdICUpAjQ3AjwgHUHEAGogJUE8aigCACIGNgIAIB0gJSgCKDYCMCAdIAZBnAQgBhs2AlQgHUJ/ICUoAjRBOGxBOHGtiDcDGCAdQQg2AgAgBUEgaiQADAELIB0gBSkCADcCDCAdQRxqIAVBEGopAgA3AgAgHUEUaiAFQQhqKQIANwIAIBdBKGogK0GMgMAAELkpIBcoAighBSAXKAIsIQYgHUEANgIsIB1BADYCKCAdQQE2AiQgHSAGNgIIIB0gBTYCBCAdQQQ2AgAgHSAlKAI8IgVBnAQgBRs2AjALIBdBQGskACBBEPMTIEEgHUHYAPwKAAAgPUEYaiIGICVBOGopAgA3AwAgPUEQaiIHICVBMGopAgA3AwAgPSAlKQIoNwMIIEEQlCoiBUEQaiAGKQMANwIAIAVBCGogBykDADcCACAFID0pAwg3AgAgQSgCAARAIEEQlCpBADYCGAsgQRCUKkEBNgIYDAELIEFBACAJIAggEBD+EBoLID1B4ABqJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgQSgCAEEBaw4KAQIDBAUGBwgJCgALQeTNzgBBDEGAzs4AEO0sAAsgCUEHSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDCHCAFIAggECAjIARBAmsQwhwgBSAIIBAgIyAEQQFrEMIcCwwJCyAJQQdJIARBAk1yRQRAIEFBBGoiBSAIIBAgIyAEQQNrENsaIAUgCCAQICMgBEECaxDbGiAFIAggECAjIARBAWsQ2xoLDAgLIAlBB0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQ3RogBSAIIBAgIyAEQQJrEN0aIAUgCCAQICMgBEEBaxDdGgsMBwsgCUEHSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDcGiAFIAggECAjIARBAmsQ3BogBSAIIBAgIyAEQQFrENwaCwwGCyAJQQNJIARBAk1yRQRAIEFBBGoiBSAIIBAgIyAEQQNrENYTIAUgCCAQICMgBEECaxDWEyAFIAggECAjIARBAWsQ1hMLDAULIAlBA0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQ2RYgBSAIIBAgIyAEQQJrENkWIAUgCCAQICMgBEEBaxDZFgsMBAsgCUEDSSAEQQJNckUEQCBBQQRqIgUgCCAQICMgBEEDaxDaFiAFIAggECAjIARBAmsQ2hYgBSAIIBAgIyAEQQFrENoWCwwDCyAJQQdJIARBAk1yRQRAIEFBCGoiBSAIIBAgIyAEQQNrEJAWIAUgCCAQICMgBEECaxCQFiAFIAggECAjIARBAWsQkBYLDAILIAlBA0kgBEECTXJFBEAgQUEEaiIFIAggECAjIARBA2sQiRMgBSAIIBAgIyAEQQJrEIkTIAUgCCAQICMgBEEBaxCJEwsMAQsgQUEEaiEHIEEoAhghDCMAQRBrIgYkAAJAIAlBA0kgBEH/AE1yDQAgBEGAAWsiBSAFIAlqIg0gBCAEIA1LGyINTw0AA0AgBygCECEKIAZBADYCDCAHIAggECAFICMgDEGAASAKQQ8gBCAFayIKIApBD00bayAGQQxqQQhBABCDBxogBUEBaiIFIA1HDQALCyAGQRBqJAALIAAoAuwpIQUgACgC8CkhByAAKQPwARDLKyEMIAApA+gBIAApA/ABfachDQJAICUoAgBBA2siBkEESQ0AQQIhBiAlKAIUQQlMDQBBAkEDIAUgByAMICMgDRC/CxshBgsgBiE9AkAgACgClCpFDQAgACgCnCoNACA7QShqIQcgO0EwaiEMAkACQAJAAkAgACgClCpBAWsiBCAAKALEASIFSQRAIAA1AiAhYSAAKALAASAEQQR0aiIENQIEIWIgACkD+AEhYyAAKAL4KSENIAAoAoACIgWsIWAgBCAAQQxqELMgIgZBEE8gBq1CD30gYFJxDQQgYCBjIGJC////D4N9ImJCASBhhkIQfSJhIGEgYlYbVg0DIAcoAgAiBkUNA0EAIAVrIRAgBkEBayEFIAAoAowqIQogACgC8CkhCSAAKALsKSEdIAwoAgAhBgNAIAYgDXEgCmoiCCAJTw0CIAYgEGogDXEgCmoiEiAJTw0DIAggHWotAAAgEiAdai0AAEcNBCAHIAU2AgAgDCAGQQFqIgY2AgAgBCAEKAIEQQFqNgIEIAVBAWsiBUF/Rw0ACwwDCyAEIAVBmMHQABDDIQALIAggCUGowdAAEMMhAAsgEiAJQbjB0AAQwyEACyAEKAIEIgVB////D3EgBUEZdmohBiAELwEOAn8CQAJAIAQoAgAiBUEGTwRAIAVBggFJDQEgBUHCEEkNAkEVIAVBwjBJDQMaQRZBFyAFQcKwAUkbDAMLIAUMAgsgBUECayIFZ0EgakE/c0EBayIHQQF0IAUgB3ZqQQJqDAELIAVBwgBrZ0EgakE/c0EKagshBUH/B3EhBwJ/AkAgBkEKTwRAIAZBhgFJDQFBFyAGQcYQTw0CGiAGQcYAa2dBIGpBP3NBDGoMAgsgBkECawwBCyAGQQZrIgZnQSBqQT9zQQFrIglBAXQgBiAJdmpBBGoLIgZBB3EgBUEDdEE4cXIhCSAEAn8gByAFQf//A3FBB0tyRSAGQf//A3FBEElxRQRAIAVB+P8DcUEDdkEDbCAGQfj/A3FBA3ZqIgRBBnRBwJrIAiAEQQF0dkHAAXFqIAlyQUBrDAELIAkgCUHAAHIgBkH//wNxQQhJGws7AQwLIDsoAjAhBCA7KAIoIQkLIAAoAvApIgwgACgCjCoiBUkNASAAKALEASINIAAoApQqIgdJDQIgACgC7CkgBWohBiAMIAVrIQUgACgCtCohCiAAQYACaiEmIABBnCpqIRogACgCwAEgB0EEdGohHSANIAdrIRAgAEGYKmohOgJAAkACQAJAAkACQAJAAkACQAJAAkACQCBBKAIAQQFrDgoJAQIDBAUGBwgKAAtBlOLOAEEjQbjizgAQ7SwACyMAQTBrIgckACAaKAIAIREgBCAJaiIMIARBCGpLBEAgQUEEaiEXIAxBB2siIiAEIAlBB0sbIRlBASAlKAIYdEEQayEwQcAAQYAEICUoAhQiCUEJSBsiJ0ECdCEkICVBBGohHCAEICdqIQ4gDEEBayEeIAdBCGohGCAJQQVIISADQCAYQgA3AwAgGEEIakEANgIAIAdC5A83AwACfwJ/AkAgFyAGIAUgIyAKICYgBCAMIARrIg0gMCAEIAQgMEsbIAcQ7wgEQCAeIARrIQ1BACEJA0AgB0IANwIkIAdC5A83AxggByANIAcoAggiCEEBayISIA0gEkkbQQAgIBs2AiAgFyAGIAUgIyAKICYgBCAJaiISQQFqIgsgDSAwIAsgCyAwSxsiDiAHQRhqEO8IRQ0CIAcpAxggBykDAEKvAXxUDQIgB0EQaiAHQShqKQMANwMAIBggB0EgaikDADcDACAHIAcpAxg3AwAgEkEJaiAMSSAJQQJNcQRAIA1BAWshDSAJQQFqIQkMAQUgEkEBaiESIAcoAgghCCAJIBFqQQFqDAQLAAsACyAOIARBAWoiCU8EQCAJIQQgEUEBagwDCyAiIARBEWoiCEsEQCAOICRqIAlPBEBBACENA0AgFyAGIAUgIyAJIA1qENsaIA1BAmoiDUEIRw0ACyAEQQlqIQQgEUEJagwEC0EAIQ0DQCAXIAYgBSAjIAkgDWoQ2xogDUEEaiINQRBHDQALIAghBCARQRFqDAMLIAwhBCANIBFqDAILIDAgEiASIDBLGyEOIAkgEWoLIQ0CQAJ/AkAgBygCECIJIA5LDQBBACEEIAkgJigCACILRg0CQQEgJigCBCIEIAlGDQEaAkAgCUEDaiIRIAtrIgtBB08EQCARIARrIgRBB0kNAUECICYoAgggCUYNAxogCSAmKAIMRw0CQQMMAwtB6IjUywAgC0ECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgCUEPagsiBEUgCSAOS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgCTYCAAsgEEUNFCAIQQF0ICdqIBJqIQ4gHSAcIA0gCCAHKAIMIAhzIAQQgA0gOiA6KAIAIA1qNgIAAn8jAEEgayILJAACQAJAAkACQAJAIBkgCCASaiIEIAQgGUsbIi0iDSASQQJqIglBEGpPBEAgDSAJayIhQQRPBEAgIUECdiEqIBcoAgQhCCAXKAIAIREgCSENA0AgBSANICNxIhJJDSUgBSASa0EKTQ0HIAtCADcDCCALQQhqIhZBCCAGIBJqIhVBCEHU2c4AENUsIAsxAAwhYCALNQIIIWEgC0IANwMIIBZBCCAVQQFqQQhB1NnOABDVLCALMQAMIWIgCzUCCCFjIAtCADcDCCAWQQggFUECakEIQdTZzgAQ1SwgCzEADCFkIAs1AgghZSALQgA3AwggFkEIIBVBA2pBCEHU2c4AENUsIBJBA3ZBAXEiFiBgQjiGIGFCGIaEQr3P1vHR9+maHn5CMIinaiIVIAhPDQMgCzUCCCFgIAsxAAwhYSARIBVBAnRqIBI2AgAgFiBiQjiGIGNCGIaEQr3P1vHR9+maHn5CMIinaiIVIAhPDQQgESAVQQJ0aiASQQFqNgIAIBYgZEI4hiBlQhiGhEK9z9bx0ffpmh5+QjCIp2oiFSAITw0FIBEgFUECdGogEkECajYCACAWIGFCOIYgYEIYhoRCvc/W8dH36ZoefkIwiKdqIhYgCE8NBiARIBZBAnRqIBJBA2o2AgAgDUEEaiENICpBAWsiKg0ACwsgIUF8cSAJaiEJCyALQSBqJAAgCQwFCyAVIAhBlOHOABDDIQALIBUgCEGk4c4AEMMhAAsgFSAIQbThzgAQwyEACyAWIAhBxOHOABDDIQALDB4LIg0gLUkEQANAIBcgBiAFICMgDRDbGiAtIA1BAWoiDUcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQALIREgBEEIaiAMSQ0ACwsgGiAMIBFqIARrNgIAIA8gDygCACAUajYCACAHQTBqJAAMCQtBwNHRAEEAICUtAFUbIRlBACEwIwBBMGsiEiQAIBooAgAhDCAEIAlqIgsgBEEIaksEQCBBQQRqIREgC0EHayIcIAQgCUEHSxshJ0EBICUoAhh0QRBrIQ5BwABBgAQgJSgCFCIJQQlIGyItQQJ0IR4gJUEEaiEgIAQgLWohCCALQQFrISwgJSgCECEhIBJBCGohGCAJQQVIIS4DQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgESAZIAYgBSAjIAogJiAEIAsgBGsiCSAOIAQgBCAOSxsgISASELUIBEAgLCAEayEJQQAhBwNAIBJCADcCJCASQuQPNwMYIBIgCSASKAIIQQFrIg0gCSANSRtBACAuGzYCICARIBkgBiAFICMgCiAmIAQgB2oiDUEBaiIIIAkgDiAIIAggDksbICEgEkEYahC1CEUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIAdBAksgDUEJaiALT3JFBEAgCUEBayEJIAdBAWohBwwBCwsgDUEBaiENIAcgDGpBAWoMAgsgCCAEQQFqIgdPBEAgDEEBaiEMIAcMAwsgHCAEQRFqIg1LBEAgCCAeaiAHTwRAQQAhCQNAIBEgBiAFICMgByAJahDdGiAJQQJqIglBCEcNAAsgDEEJaiEMIARBCWoMBAtBACEJA0AgESAGIAUgIyAHIAlqEN0aIAlBBGoiCUEQRw0ACyAMQRFqIQwgDQwDCyAJIAxqIQwgCwwCCyAHIAxqCyEMIBIoAgghCQJAAn8CQCASKAIQIgQgDiANIA0gDksbIghLDQBBACEHIAQgJigCACIXRg0CQQEgJigCBCIHIARGDQEaAkAgBEEDaiIUIBdrIhdBB08EQCAUIAdrIgdBB0kNAUECICYoAgggBEYNAxogBCAmKAIMRw0CQQMMAwtB6IjUywAgF0ECdHZBD3EMAgtBzrXs/gAgB0ECdHZBD3EMAQsgBEEPagsiB0UgBCAIS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBDYCAAsgEEUNFCANIC1qIAlBAXRqIQggHSAgIAwgCSASKAIMIAlzIAcQgA0gOiA6KAIAIAxqNgIAAn8gJyASKAIIIA1qIgQgBCAnSxsiKiEJIwBBIGsiByQAAkACQAJAAkACQCANQQJqIgRBEGogCU0EQCAJIARrIiJBBE8EQCAiQQJ2ISQgESgCBCEMIBEoAgAhFCAEIQkDQCAFIAkgI3EiF0kNJiAFIBdrQQpNDQcgB0IANwMIIAdBCGoiFkEIIAYgF2oiFUEIQdTZzgAQ1SwgBzEADCFgIAc1AgghYSAHQgA3AwggFkEIIBVBAWpBCEHU2c4AENUsIAcxAAwhYiAHNQIIIWMgB0IANwMIIBZBCCAVQQJqQQhB1NnOABDVLCAHMQAMIWQgBzUCCCFlIAdCADcDCCAWQQggFUEDakEIQdTZzgAQ1SwgF0EDdkEDcSIWIGBCOIYgYUIYhoRCvc/W8dH36ZoefkIviKdqIhUgDE8NAyAHNQIIIWAgBzEADCFhIBQgFUECdGogFzYCACAWIGJCOIYgY0IYhoRCvc/W8dH36ZoefkIviKdqIhUgDE8NBCAUIBVBAnRqIBdBAWo2AgAgFiBkQjiGIGVCGIaEQr3P1vHR9+maHn5CL4inaiIVIAxPDQUgFCAVQQJ0aiAXQQJqNgIAIBYgYUI4hiBgQhiGhEK9z9bx0ffpmh5+Qi+Ip2oiFiAMTw0GIBQgFkECdGogF0EDajYCACAJQQRqIQkgJEEBayIkDQALCyAiQXxxIARqIQQLIAdBIGokACAEDAULIBUgDEGU4c4AEMMhAAsgFSAMQaThzgAQwyEACyAVIAxBtOHOABDDIQALIBYgDEHE4c4AEMMhAAsMHwsiCSAqSQRAA0AgESAGIAUgIyAJEN0aICogCUEBaiIJRw0ACwsgMEEBaiEwIBBBAWshECAdQRBqIR1BACEMIBIoAgggDWoLIgRBCGogC0kNAAsLIBogCyAMaiAEazYCACAPIA8oAgAgMGo2AgAgEkEwaiQADAgLIwBBMGsiByQAIBooAgAhESAEIAlqIgwgBEEIaksEQCBBQQRqIRcgDEEHayIiIAQgCUEHSxshFUEBICUoAhh0QRBrITBBwABBgAQgJSgCFCIJQQlIGyIZQQJ0ISQgJUEEaiEcIAQgGWohDiAMQQFrIR4gB0EIaiEYIAlBBUghIANAIBhCADcDACAYQQhqQQA2AgAgB0LkDzcDAAJ/An8CQCAXIAYgBSAjIAogJiAEIAwgBGsiDSAwIAQgBCAwSxsgBxDuCARAIB4gBGshDUEAIQkDQCAHQgA3AiQgB0LkDzcDGCAHIA0gBygCCCIIQQFrIhIgDSASSRtBACAgGzYCICAXIAYgBSAjIAogJiAEIAlqIhJBAWoiCyANIDAgCyALIDBLGyIOIAdBGGoQ7ghFDQIgBykDGCAHKQMAQq8BfFQNAiAHQRBqIAdBKGopAwA3AwAgGCAHQSBqKQMANwMAIAcgBykDGDcDACASQQlqIAxJIAlBAk1xBEAgDUEBayENIAlBAWohCQwBBSASQQFqIRIgBygCCCEIIAkgEWpBAWoMBAsACwALIA4gBEEBaiIJTwRAIAkhBCARQQFqDAMLICIgBEERaiIISwRAIA4gJGogCU8EQEEAIQ0DQCAXIAYgBSAjIAkgDWoQ3BogDUECaiINQQhHDQALIARBCWohBCARQQlqDAQLQQAhDQNAIBcgBiAFICMgCSANahDcGiANQQRqIg1BEEcNAAsgCCEEIBFBEWoMAwsgDCEEIA0gEWoMAgsgMCASIBIgMEsbIQ4gCSARagshDQJAAn8CQCAHKAIQIgkgDksNAEEAIQQgCSAmKAIAIgtGDQJBASAmKAIEIgQgCUYNARoCQCAJQQNqIhEgC2siC0EHTwRAIBEgBGsiBEEHSQ0BQQIgJigCCCAJRg0DGiAJICYoAgxHDQJBAwwDC0HoiNTLACALQQJ0dkEPcQwCC0HOtez+ACAEQQJ0dkEPcQwBCyAJQQ9qCyIERSAJIA5Lcg0AICYgJigCCDYCDCAmICYpAgA3AgQgJiAJNgIACyAQRQ0SIAhBAXQgGWogEmohDiAdIBwgDSAIIAcoAgwgCHMgBBCADSA6IDooAgAgDWo2AgACfyMAQSBrIgskAAJAAkACQAJAAkAgFSAIIBJqIgQgBCAVSxsiJyINIBJBAmoiCUEQak8EQCANIAlrIi1BBE8EQCAtQQJ2ISEgFygCBCEIIBcoAgAhESAJIQ0DQCAFIA0gI3EiEkkNIyAFIBJrQQpNDQcgBiASaiIWQQsQlhogFkEBakEKEJYaISwgFkECakEJEJYaIS4gFkEDakEIEJYaITggEkEDdkEDcSIWaiIqIAhPDQMgESAqQQJ0aiASNgIAIBYgLGoiKiAITw0EIBEgKkECdGogEkEBajYCACAWIC5qIiogCE8NBSARICpBAnRqIBJBAmo2AgAgFiA4aiIWIAhPDQYgESAWQQJ0aiASQQNqNgIAIA1BBGohDSAhQQFrIiENAAsLIC1BfHEgCWohCQsgC0EgaiQAIAkMBQsgKiAIQZThzgAQwyEACyAqIAhBpOHOABDDIQALICogCEG04c4AEMMhAAsgFiAIQcThzgAQwyEACwwcCyINICdJBEADQCAXIAYgBSAjIA0Q3BogJyANQQFqIg1HDQALCyAUQQFqIRQgEEEBayEQIB1BEGohHUEACyERIARBCGogDEkNAAsLIBogDCARaiAEazYCACAPIA8oAgAgFGo2AgAgB0EwaiQADAcLQcDR0QBBACAlLQBVGyEgIwBBMGsiEiQAIBooAgAhByAlKAIYIQ0gJSgCFCEIICYgQUEEaiIMKAIgEPUNIAQgCWoiMCAEQQRqSwRAIDBBA2sgBCAJQQNLGyEsQQEgDXRBEGshDkHAAEGABCAIQQlIGyIuQQJ0ITMgMEEEayEoICVBBGohEyAEIC5qIQ0gMEEBayE1ICUoAhAhOCASQQhqIScgCEEFSCE0A0AgJ0IANwMAICdBCGpBADYCACASQuQPNwMAAn8CfwJAIAwgICAGIAUgIyAKICYgBCAwIARrIgggDiAEIAQgDksbIDggEhDPBQRAIDUgBGshDUEAIREDQCASQgA3AiQgEkLkDzcDGCASIA0gEigCCEEBayIJIAkgDUsbQQAgNBs2AiAgDCAgIAYgBSAjIAogJiAEIBFqIglBAWoiCCANIA4gCCAIIA5LGyA4IBJBGGoQzwVFDQIgEikDGCASKQMAQq8BfFQNAiASQRBqIBJBKGopAwA3AwAgJyASQSBqKQMANwMAIBIgEikDGDcDACARQQJLIAlBBWogME9yRQRAIA1BAWshDSARQQFqIREMAQsLIAlBAWohCSAHIBFqQQFqDAILIA0gBEEBaiIJTwRAIAdBAWohByAJDAMLICggBEERaiIfSwRAIA0gM2ogCU8EQAJAAkACQAJAAkACQAJAAkACQAJAIAUgCSAjcSIRSwRAIBFBAWoiCCAFTw0sIBFBAmoiCyAFTw0tIBFBA2oiFCAFTw0BIBFBBGoiFSAFTw0uIBFBBWoiGSAFTw0vIBFBBmoiLSAFTw0CIBFBB2oiISAFTw0DIAlBCGogI3EiFyAFTw0EIBdBAWoiKiAFTw0FIAwoAgQiFiAGIBFqMQAAIAYgCGoxAABCCIaEIAYgC2oxAABCEIaEIAYgFGoxAABCGIaEImFCvc/W8QF+Qv////8PgyAMKAI0QT9xrSJgiKciC00NJCAMKAIMIREgDCgCCCEIIAYgFWoxAAAhYiAGIBlqMQAAIWMgBiAhajEAACFkIAYgLWoxAAAhZSAGICpqMQAAIWYgBiAXajEAACFnIAwoAgAiFCALQQF0aiIXIBcvAQAiIUEBajsBACAWIGJCIIYgY0IohoQgYYQiYUIQiEK9z9bxAX5C/////w+DIGCIpyIVTQ0wIAwoAjwhFyAUIBVBAXRqIhkgGS8BACIqQQFqOwEAIBYgZUIwhiBkQjiGhCBhhCJhQiCIQr3P1vEBfkL/////D4MgYIinIhlNDTEgFCAZQQF0aiItIC0vAQAiIkEBajsBACAWIGdCEIYgZkIYhoQgYUIwiIRCvc/W8QF+Qv////8PgyBgiKciLU0NBiAUIC1BAXRqIhQgFC8BACIWQQFqOwEAIBcgIXEgCyAMKAJAIgt0aiIUIBFPDQcgCCAUQQJ0aiAJNgIAIBcgKnEgFSALdGoiFCARTw0IIAggFEECdGogCUECajYCACAXICJxIBkgC3RqIhQgEU8NCSAIIBRBAnRqIAlBBGo2AgAgFiAXcSAtIAt0aiIWIBFJDQoMIgsMIgsgFCAFQeDRzgAQwyEACyAtIAVBkNLOABDDIQALICEgBUGg0s4AEMMhAAsgFyAFQbDSzgAQwyEACyAqIAVBwNLOABDDIQALIC0gFkGA084AEMMhAAsgFCARQZDTzgAQwyEACyAUIBFBoNPOABDDIQALIBQgEUGw084AEMMhAAsgCCAWQQJ0aiAJQQZqNgIAIAdBCWohByAEQQlqDAQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIgRLBEAgBEEBaiILIAVPDQEgBEECaiIXIAVPDQIgBEEDaiIUIAVPDQMgBEEEaiIWIAVPDTcgBEEFaiIVIAVPDTggBEEGaiIZIAVPDTkgBEEHaiItIAVPDQQgCUEIaiJHICNxIhEgBU8NLCARQQFqIiEgBU8NBSARQQJqIiogBU8NBiARQQNqIiIgBU8NByARQQRqIiQgBU8NCCARQQVqIhwgBU8NCSARQQZqIh4gBU8NCiARQQdqIkUgBU8NCyAMKAIEIgggBCAGajEAACAGIAtqMQAAQgiGhCAGIBdqMQAAQhCGhCAGIBRqMQAAQhiGhEK9z9bxAX5C/////w+DIAwoAjRBP3GtImCIpyIXTQ0MIAwoAgwhBCAMKAIIIQsgBiAWajEAACFhIAYgFWoxAAAhYiAGIBlqMQAAIWMgBiAtajEAACFkIAYgEWoxAAAhZSAGICFqMQAAIWYgBiAqajEAACFnIAYgImoxAAAhaCAGICRqMQAAIWkgBiAcajEAACFqIAYgHmoxAAAhayAGIEVqMQAAIWwgDCgCACIUIBdBAXRqIhEgES8BACItQQFqOwEAIAggYSBiQgiGhCBjQhCGhCBkQhiGhEK9z9bxAX5C/////w+DIGCIpyIWTQ06IAwoAjwhESAUIBZBAXRqIhUgFS8BACIhQQFqOwEAIAggZkIIhiBlhCBnQhCGhCBoQhiGhEK9z9bxAX5C/////w+DIGCIpyIVTQ07IBQgFUEBdGoiGSAZLwEAIipBAWo7AQAgCCBqQgiGIGmEIGtCEIaEIGxCGIaEQr3P1vEBfkL/////D4MgYIinIhlNDTwgFCAZQQF0aiIIIAgvAQAiFEEBajsBACARIC1xIBcgDCgCQCIIdGoiFyAETw0NIAsgF0ECdGogCTYCACARICFxIBYgCHRqIhcgBE8NDiALIBdBAnRqIAlBBGo2AgAgESAqcSAVIAh0aiIXIARPDQ8gCyAXQQJ0aiBHNgIAIBEgFHEgGSAIdGoiESAESQ0QDCoLDCoLIAsgBUHAzs4AEMMhAAsgFyAFQdDOzgAQwyEACyAUIAVB4M7OABDDIQALIC0gBUGgz84AEMMhAAsgISAFQcDPzgAQwyEACyAqIAVB0M/OABDDIQALICIgBUHgz84AEMMhAAsgJCAFQfDPzgAQwyEACyAcIAVBgNDOABDDIQALIB4gBUGQ0M4AEMMhAAsgRSAFQaDQzgAQwyEACyAXIAhBsNDOABDDIQALIBcgBEHw0M4AEMMhAAsgFyAEQYDRzgAQwyEACyAXIARBkNHOABDDIQALIAsgEUECdGogCUEMajYCACAHQRFqIQcgHwwDCyAHIAhqIQcgMAwCCyAHIBFqCyEIIBIoAgghDQJAAn8CQCASKAIQIgcgDiAJIAkgDksbIgtLDQBBACEEIAcgJigCACIRRg0CQQEgJigCBCIEIAdGDQEaAkAgB0EDaiIXIBFrIhFBB08EQCAXIARrIgRBB0kNAUECICYoAgggB0YNAxogByAmKAIMRw0CQQMMAwtB6IjUywAgEUECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgB0EPagsiBEUgByALS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBzYCACAmIAwoAiAQ9Q0LIBBFDRIgCSAuaiANQQF0aiENIB0gEyAIIBIoAggiByAHIBIoAgxzIAQQgA0gOiA6KAIAIAhqNgIAAn8gLCASKAIIIAlqIgQgBCAsSxsiRSEHIwBBMGsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCUECaiIEQQhqIAdNBEAgCCAMKAIEIgs2AgggCCAMKAI4IhE2AgwgCyARRw07IAwoAgwhESAMKAIIIRQgDCgCACEWIAggCyAMKAJAIhd0IhU2AhQgCCARNgIQIBEgFUcNECAHIARrIh9BBE8EQCAXQR9xIRUgH0ECdiFHIAw1AjRCP4MhYCAMKAI8IRkgBCEHA0AgByAjcSIXIAVPDQMgF0EBaiItIAVPDQQgF0ECaiIhIAVPDQUgF0EDaiIqIAVPDQYgF0EEaiIkIAVPDQcgF0EFaiIcIAVPDQggF0EGaiIeIAVPDQkgCyAGIBdqMQAAIAYgLWoxAABCCIaEIAYgIWoxAABCEIaEIAYgKmoxAABCGIaEImFCvc/W8QF+Qv////8PgyBgiKciIk0NCiAGICRqMQAAIWIgBiAeajEAACFjIAYgHGoxAAAhZCAWICJBAXRqIiQgJC8BACI2QQFqOwEAIAsgYkIghiBhhCJhQgiIQr3P1vEBfkL/////D4MgYIinIiRNDQsgFiAkQQF0aiIcIBwvAQAiKUEBajsBACALIGRCKIYgY0IwhoQgYYQiYUIQiEK9z9bxAX5C/////w+DIGCIpyIcTQ0MIBYgHEEBdGoiHiAeLwEAIjFBAWo7AQAgCyBhQhiIQr3P1vEBfkL/////D4MgYIinIh5NDQ0gFiAeQQF0aiIvIC8vAQAiL0EBajsBACAZIDZxICIgFXRqIiIgEU8NDiAUICJBAnRqIBc2AgAgGSApcSAkIBV0aiIXIBFPDQ8gFCAXQQJ0aiAtNgIAIBkgMXEgHCAVdGoiFyARTw0QIBQgF0ECdGogITYCACAZIC9xIB4gFXRqIhcgEU8NESAUIBdBAnRqICo2AgAgB0EEaiEHIEdBAWsiRw0ACwsgH0F8cSAEaiEECyAIQTBqJAAgBAwQCyAXIAVB6OLOABDDIQALIC0gBUH44s4AEMMhAAsgISAFQYjjzgAQwyEACyAqIAVBmOPOABDDIQALICQgBUGo484AEMMhAAsgHCAFQbjjzgAQwyEACyAeIAVByOPOABDDIQALICIgC0HY484AEMMhAAsgJCALQejjzgAQwyEACyAcIAtB+OPOABDDIQALIB4gC0GI5M4AEMMhAAsgIiARQZjkzgAQwyEACyAXIBFBqOTOABDDIQALIBcgEUG45M4AEMMhAAsgFyARQcjkzgAQwyEACwwrCyIEIEVJBEADQCAMIAYgBSAjIAQQ1hMgRSAEQQFqIgRHDQALCyAYQQFqIRggEEEBayEQIB1BEGohHUEAIQcgEigCCCAJagsiBEEEaiAwSQ0ACwsgGiAHIDBqIARrNgIAIA8gDygCACAYajYCACASQTBqJAAMBgtBwNHRAEEAICUtAFUbIS0jAEEwayISJAAgGigCACEHICUoAhghDSAlKAIUIQggJiBBQQRqIgwoAiAQ9Q0gBCAJaiIXIARBBGpLBEAgF0EDayAEIAlBA0sbISFBASANdEEQayEwQcAAQYAEIAhBCUgbIipBAnQhRSAXQQRrIR8gJUEEaiFHIAQgKmohDSAXQQFrITMgJSgCECEiIBJBCGohGCAIQQVIISgDQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgDCAtIAYgBSAjIAogJiAEIBcgBGsiCCAwIAQgBCAwSxsgIiASEKsGBEAgMyAEayENQQAhEQNAIBJCADcCJCASQuQPNwMYIBIgDSASKAIIQQFrIgkgCSANSxtBACAoGzYCICAMIC0gBiAFICMgCiAmIAQgEWoiCUEBaiIIIA0gMCAIIAggMEsbICIgEkEYahCrBkUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIBFBAksgCUEFaiAXT3JFBEAgDUEBayENIBFBAWohEQwBCwsgCUEBaiEJIAcgEWpBAWoMAgsgDSAEQQFqIglPBEAgB0EBaiEHIAkMAwsgHyAEQRFqIhNLBEAgDSBFaiAJTwRAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIhFLBEAgEUEBaiIIIAVPDSsgEUECaiILIAVPDSwgEUEDaiIWIAVPDQEgEUEEaiIVIAVPDS0gEUEFaiIZIAVPDS4gEUEGaiInIAVPDQIgEUEHaiIkIAVPDQMgCUEIaiAjcSIOIAVPDQQgDkEBaiIcIAVPDQUgBiARajEAACAGIAhqMQAAQgiGhCAGIAtqMQAAQhCGhCAGIBZqMQAAQhiGhCJgp0G9z9bxAWxBEXYiCyAMKAIEIhZPDSMgDCgCDCERIAwoAgghCCAGIBVqMQAAIAYgGWoxAAAhYiAGICRqMQAAIWMgBiAnajEAACFkIAYgDmoxAAAhZSAGIBxqMQAAIWYgDCgCACIOIAtBAXRqIhUgFS8BACIkQQFqOwEAQiCGIGJCKIaEIGCEImBCEIinQb3P1vEBbEERdiIVIBZPDS8gDiAVQQF0aiIZIBkvAQAiHEEBajsBACBkQjCGIGNCOIaEIGCEImBCIIinQb3P1vEBbEERdiIZIBZPDTAgDiAZQQF0aiInICcvAQAiHkEBajsBACBlQhCGIGBCMIiEIGZCGIaEp0G9z9bxAWxBEXYiJyAWTw0GIA4gJ0EBdGoiDiAOLwEAIg5BAWo7AQAgJEE/cSALQQZ0ciILIBFPDQcgCCALQQJ0aiAJNgIAIBxBP3EgFUEGdHIiCyARTw0IIAggC0ECdGogCUECajYCACAeQT9xIBlBBnRyIgsgEU8NCSAIIAtBAnRqIAlBBGo2AgAgDkE/cSAnQQZ0ciIWIBFJDQoMIQsMIQsgFiAFQeDRzgAQwyEACyAnIAVBkNLOABDDIQALICQgBUGg0s4AEMMhAAsgDiAFQbDSzgAQwyEACyAcIAVBwNLOABDDIQALICcgFkGA084AEMMhAAsgCyARQZDTzgAQwyEACyALIBFBoNPOABDDIQALIAsgEUGw084AEMMhAAsgCCAWQQJ0aiAJQQZqNgIAIAdBCWohByAEQQlqDAQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBSAJICNxIgRLBEAgBEEBaiIIIAVPDQEgBEECaiILIAVPDQIgBEEDaiIOIAVPDQMgBEEEaiIWIAVPDTYgBEEFaiIVIAVPDTcgBEEGaiIZIAVPDTggBEEHaiInIAVPDQQgCUEIaiI1ICNxIhEgBU8NKyARQQFqIiQgBU8NBSARQQJqIhwgBU8NBiARQQNqIh4gBU8NByARQQRqIiAgBU8NCCARQQVqIiwgBU8NCSARQQZqIi4gBU8NCiARQQdqIjggBU8NCyAEIAZqLQAAIAYgCGotAABBCHRyIAYgC2otAABBEHRyIAYgDmotAABBGHRyQb3P1vEBbEERdiIOIAwoAgQiCE8NDCAMKAIMIQQgDCgCCCELIAYgFmotAAAgBiAVai0AACAGIBlqLQAAIRkgBiAnai0AACEnIAYgEWotAAAhNCAGICRqLQAAISQgBiAcai0AACEcIAYgHmotAAAhHiAGICBqLQAAISAgBiAsai0AACEsIAYgLmotAAAhLiAGIDhqLQAAITggDCgCACIRIA5BAXRqIjYgNi8BACI2QQFqOwEAQQh0ciAZQRB0ciAnQRh0ckG9z9bxAWxBEXYiFiAITw05IBEgFkEBdGoiFSAVLwEAIidBAWo7AQAgJEEIdCA0ciAcQRB0ciAeQRh0ckG9z9bxAWxBEXYiFSAITw06IBEgFUEBdGoiGSAZLwEAIiRBAWo7AQAgLEEIdCAgciAuQRB0ciA4QRh0ckG9z9bxAWxBEXYiGSAITw07IBEgGUEBdGoiCCAILwEAIhFBAWo7AQAgNkE/cSAOQQZ0ciIIIARPDQ0gCyAIQQJ0aiAJNgIAICdBP3EgFkEGdHIiCCAETw0OIAsgCEECdGogCUEEajYCACAkQT9xIBVBBnRyIgggBE8NDyALIAhBAnRqIDU2AgAgEUE/cSAZQQZ0ciIRIARJDRAMKQsMKQsgCCAFQcDOzgAQwyEACyALIAVB0M7OABDDIQALIA4gBUHgzs4AEMMhAAsgJyAFQaDPzgAQwyEACyAkIAVBwM/OABDDIQALIBwgBUHQz84AEMMhAAsgHiAFQeDPzgAQwyEACyAgIAVB8M/OABDDIQALICwgBUGA0M4AEMMhAAsgLiAFQZDQzgAQwyEACyA4IAVBoNDOABDDIQALIA4gCEGw0M4AEMMhAAsgCCAEQfDQzgAQwyEACyAIIARBgNHOABDDIQALIAggBEGQ0c4AEMMhAAsgCyARQQJ0aiAJQQxqNgIAIAdBEWohByATDAMLIAcgCGohByAXDAILIAcgEWoLIQggEigCCCENAkACfwJAIBIoAhAiByAwIAkgCSAwSxsiC0sNAEEAIQQgByAmKAIAIhFGDQJBASAmKAIEIgQgB0YNARoCQCAHQQNqIg4gEWsiEUEHTwRAIA4gBGsiBEEHSQ0BQQIgJigCCCAHRg0DGiAHICYoAgxHDQJBAwwDC0HoiNTLACARQQJ0dkEPcQwCC0HOtez+ACAEQQJ0dkEPcQwBCyAHQQ9qCyIERSAHIAtLcg0AICYgJigCCDYCDCAmICYpAgA3AgQgJiAHNgIAICYgDCgCIBD1DQsgEEUNESAJICpqIA1BAXRqIQ0gHSBHIAggEigCCCIHIAcgEigCDHMgBBCADSA6IDooAgAgCGo2AgACfyAhIBIoAgggCWoiBCAEICFLGyInIQcjAEEwayIIJAACQAJAAkACQAJAAkACQCAJQQJqIgRBCGogB00EQCAIIAwoAgQiCzYCCCAIQYCAAjYCDCALQYCAAkcNMSAMKAIIIREgDCgCACEOIAggDCgCDCILNgIQIAhBgICAATYCFCALQYCAgAFHDTIgByAEayIkQQRPBEAgJEECdiEcIAQhBwNAIAcgI3EiCyAFTw0DIAtBAWoiFiAFTw0EIAtBAmoiFSAFTw0FIAtBA2oiGSAFTw0GIAtBBGoiHiAFTw0HIAtBBWoiICAFTw0IIAtBBmoiLCAFTw0JIAYgHmoxAAAhYCAOIAYgC2oxAAAgBiAWajEAAEIIhoQgBiAVajEAAEIQhoQgBiAZajEAAEIYhoQiYadBvc/W8QFsQRF2Ih5BAXRqIi4gLi8BACIuQQFqOwEAIA4gYEIghiBhhCJgQgiIp0G9z9bxAWxBEXYiOEEBdGoiEyATLwEAIhNBAWo7AQAgDiAGICBqMQAAQiiGIAYgLGoxAABCMIaEIGCEImBCEIinQb3P1vEBbEERdiIgQQF0aiIsICwvAQAiLEEBajsBACAOIGBCGIinQb3P1vEBbEERdiI1QQF0aiI0IDQvAQAiNEEBajsBACARIB5BCHQgLkE/cUECdHJqIAs2AgAgESA4QQh0IBNBP3FBAnRyaiAWNgIAIBEgIEEIdCAsQT9xQQJ0cmogFTYCACARIDVBCHQgNEE/cUECdHJqIBk2AgAgB0EEaiEHIBxBAWsiHA0ACwsgJEF8cSAEaiEECyAIQTBqJAAgBAwHCyALIAVB6OLOABDDIQALIBYgBUH44s4AEMMhAAsgFSAFQYjjzgAQwyEACyAZIAVBmOPOABDDIQALIB4gBUGo484AEMMhAAsgICAFQbjjzgAQwyEACyAsIAVByOPOABDDIQALIgQgJ0kEQANAIAwgBiAFICMgBBDZFiAnIARBAWoiBEcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQAhByASKAIIIAlqCyIEQQRqIBdJDQALCyAaIAcgF2ogBGs2AgAgDyAPKAIAIBRqNgIAIBJBMGokAAwFC0HA0dEAQQAgJS0AVRshLSMAQTBrIhIkACAaKAIAIQcgJSgCGCENICUoAhQhCCAmIEFBBGoiDCgCIBD1DSAEIAlqIhcgBEEEaksEQCAXQQNrIAQgCUEDSxshIUEBIA10QRBrITBBwABBgAQgCEEJSBsiKkECdCFFIBdBBGshHyAlQQRqIUcgBCAqaiENIBdBAWshMyAlKAIQISIgEkEIaiEYIAhBBUghKANAIBhCADcDACAYQQhqQQA2AgAgEkLkDzcDAAJ/An8CQCAMIC0gBiAFICMgCiAmIAQgFyAEayIIIDAgBCAEIDBLGyAiIBIQrAYEQCAzIARrIQ1BACERA0AgEkIANwIkIBJC5A83AxggEiANIBIoAghBAWsiCSAJIA1LG0EAICgbNgIgIAwgLSAGIAUgIyAKICYgBCARaiIJQQFqIgggDSAwIAggCCAwSxsgIiASQRhqEKwGRQ0CIBIpAxggEikDAEKvAXxUDQIgEkEQaiASQShqKQMANwMAIBggEkEgaikDADcDACASIBIpAxg3AwAgEUECSyAJQQVqIBdPckUEQCANQQFrIQ0gEUEBaiERDAELCyAJQQFqIQkgByARakEBagwCCyANIARBAWoiCU8EQCAHQQFqIQcgCQwDCyAfIARBEWoiE0sEQCANIEVqIAlPBEACQAJAAkACQAJAAkACQAJAAkACQCAFIAkgI3EiEUsEQCARQQFqIgggBU8NKiARQQJqIgsgBU8NKyARQQNqIhYgBU8NASARQQRqIhUgBU8NLCARQQVqIhkgBU8NLSARQQZqIicgBU8NAiARQQdqIiQgBU8NAyAJQQhqICNxIg4gBU8NBCAOQQFqIhwgBU8NBSAGIBFqMQAAIAYgCGoxAABCCIaEIAYgC2oxAABCEIaEIAYgFmoxAABCGIaEImCnQb3P1vEBbEESdiILIAwoAgQiFk8NIiAMKAIMIREgDCgCCCEIIAYgFWoxAAAgBiAZajEAACFiIAYgJGoxAAAhYyAGICdqMQAAIWQgBiAOajEAACFlIAYgHGoxAAAhZiAMKAIAIg4gC0EBdGoiFSAVLwEAIiRBAWo7AQBCIIYgYkIohoQgYIQiYEIQiKdBvc/W8QFsQRJ2IhUgFk8NLiAOIBVBAXRqIhkgGS8BACIcQQFqOwEAIGRCMIYgY0I4hoQgYIQiYEIgiKdBvc/W8QFsQRJ2IhkgFk8NLyAOIBlBAXRqIicgJy8BACIeQQFqOwEAIGVCEIYgYEIwiIQgZkIYhoSnQb3P1vEBbEESdiInIBZPDQYgDiAnQQF0aiIOIA4vAQAiDkEBajsBACAkQQ9xIAtBBHRyIgsgEU8NByAIIAtBAnRqIAk2AgAgHEEPcSAVQQR0ciILIBFPDQggCCALQQJ0aiAJQQJqNgIAIB5BD3EgGUEEdHIiCyARTw0JIAggC0ECdGogCUEEajYCACAOQQ9xICdBBHRyIhYgEUkNCgwgCwwgCyAWIAVB4NHOABDDIQALICcgBUGQ0s4AEMMhAAsgJCAFQaDSzgAQwyEACyAOIAVBsNLOABDDIQALIBwgBUHA0s4AEMMhAAsgJyAWQYDTzgAQwyEACyALIBFBkNPOABDDIQALIAsgEUGg084AEMMhAAsgCyARQbDTzgAQwyEACyAIIBZBAnRqIAlBBmo2AgAgB0EJaiEHIARBCWoMBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFIAkgI3EiBEsEQCAEQQFqIgggBU8NASAEQQJqIgsgBU8NAiAEQQNqIg4gBU8NAyAEQQRqIhYgBU8NNSAEQQVqIhUgBU8NNiAEQQZqIhkgBU8NNyAEQQdqIicgBU8NBCAJQQhqIjUgI3EiESAFTw0qIBFBAWoiJCAFTw0FIBFBAmoiHCAFTw0GIBFBA2oiHiAFTw0HIBFBBGoiICAFTw0IIBFBBWoiLCAFTw0JIBFBBmoiLiAFTw0KIBFBB2oiOCAFTw0LIAQgBmotAAAgBiAIai0AAEEIdHIgBiALai0AAEEQdHIgBiAOai0AAEEYdHJBvc/W8QFsQRJ2Ig4gDCgCBCIITw0MIAwoAgwhBCAMKAIIIQsgBiAWai0AACAGIBVqLQAAIAYgGWotAAAhGSAGICdqLQAAIScgBiARai0AACE0IAYgJGotAAAhJCAGIBxqLQAAIRwgBiAeai0AACEeIAYgIGotAAAhICAGICxqLQAAISwgBiAuai0AACEuIAYgOGotAAAhOCAMKAIAIhEgDkEBdGoiNiA2LwEAIjZBAWo7AQBBCHRyIBlBEHRyICdBGHRyQb3P1vEBbEESdiIWIAhPDTggESAWQQF0aiIVIBUvAQAiJ0EBajsBACAkQQh0IDRyIBxBEHRyIB5BGHRyQb3P1vEBbEESdiIVIAhPDTkgESAVQQF0aiIZIBkvAQAiJEEBajsBACAsQQh0ICByIC5BEHRyIDhBGHRyQb3P1vEBbEESdiIZIAhPDTogESAZQQF0aiIIIAgvAQAiEUEBajsBACA2QQ9xIA5BBHRyIgggBE8NDSALIAhBAnRqIAk2AgAgJ0EPcSAWQQR0ciIIIARPDQ4gCyAIQQJ0aiAJQQRqNgIAICRBD3EgFUEEdHIiCCAETw0PIAsgCEECdGogNTYCACARQQ9xIBlBBHRyIhEgBEkNEAwoCwwoCyAIIAVBwM7OABDDIQALIAsgBUHQzs4AEMMhAAsgDiAFQeDOzgAQwyEACyAnIAVBoM/OABDDIQALICQgBUHAz84AEMMhAAsgHCAFQdDPzgAQwyEACyAeIAVB4M/OABDDIQALICAgBUHwz84AEMMhAAsgLCAFQYDQzgAQwyEACyAuIAVBkNDOABDDIQALIDggBUGg0M4AEMMhAAsgDiAIQbDQzgAQwyEACyAIIARB8NDOABDDIQALIAggBEGA0c4AEMMhAAsgCCAEQZDRzgAQwyEACyALIBFBAnRqIAlBDGo2AgAgB0ERaiEHIBMMAwsgByAIaiEHIBcMAgsgByARagshCCASKAIIIQ0CQAJ/AkAgEigCECIHIDAgCSAJIDBLGyILSw0AQQAhBCAHICYoAgAiEUYNAkEBICYoAgQiBCAHRg0BGgJAIAdBA2oiDiARayIRQQdPBEAgDiAEayIEQQdJDQFBAiAmKAIIIAdGDQMaIAcgJigCDEcNAkEDDAMLQeiI1MsAIBFBAnR2QQ9xDAILQc617P4AIARBAnR2QQ9xDAELIAdBD2oLIgRFIAcgC0tyDQAgJiAmKAIINgIMICYgJikCADcCBCAmIAc2AgAgJiAMKAIgEPUNCyAQRQ0QIAkgKmogDUEBdGohDSAdIEcgCCASKAIIIgcgByASKAIMcyAEEIANIDogOigCACAIajYCAAJ/ICEgEigCCCAJaiIEIAQgIUsbIichByMAQTBrIggkAAJAAkACQAJAAkACQAJAIAlBAmoiBEEIaiAHTQRAIAggDCgCBCILNgIIIAhBgIABNgIMIAtBgIABRw0wIAwoAgghESAMKAIAIQ4gCCAMKAIMIgs2AhAgCEGAgBA2AhQgC0GAgBBHDTEgByAEayIkQQRPBEAgJEECdiEcIAQhBwNAIAcgI3EiCyAFTw0DIAtBAWoiFiAFTw0EIAtBAmoiFSAFTw0FIAtBA2oiGSAFTw0GIAtBBGoiHiAFTw0HIAtBBWoiICAFTw0IIAtBBmoiLCAFTw0JIAYgHmoxAAAhYCAOIAYgC2oxAAAgBiAWajEAAEIIhoQgBiAVajEAAEIQhoQgBiAZajEAAEIYhoQiYadBvc/W8QFsQRJ2Ih5BAXRqIi4gLi8BACIuQQFqOwEAIA4gYEIghiBhhCJgQgiIp0G9z9bxAWxBEnYiOEEBdGoiEyATLwEAIhNBAWo7AQAgDiAGICBqMQAAQiiGIAYgLGoxAABCMIaEIGCEImBCEIinQb3P1vEBbEESdiIgQQF0aiIsICwvAQAiLEEBajsBACAOIGBCGIinQb3P1vEBbEESdiI1QQF0aiI0IDQvAQAiNEEBajsBACARIB5BBnQgLkEPcUECdHJqIAs2AgAgESA4QQZ0IBNBD3FBAnRyaiAWNgIAIBEgIEEGdCAsQQ9xQQJ0cmogFTYCACARIDVBBnQgNEEPcUECdHJqIBk2AgAgB0EEaiEHIBxBAWsiHA0ACwsgJEF8cSAEaiEECyAIQTBqJAAgBAwHCyALIAVB6OLOABDDIQALIBYgBUH44s4AEMMhAAsgFSAFQYjjzgAQwyEACyAZIAVBmOPOABDDIQALIB4gBUGo484AEMMhAAsgICAFQbjjzgAQwyEACyAsIAVByOPOABDDIQALIgQgJ0kEQANAIAwgBiAFICMgBBDaFiAnIARBAWoiBEcNAAsLIBRBAWohFCAQQQFrIRAgHUEQaiEdQQAhByASKAIIIAlqCyIEQQRqIBdJDQALCyAaIAcgF2ogBGs2AgAgDyAPKAIAIBRqNgIAIBJBMGokAAwEC0HA0dEAQQAgJS0AVRshFEEAITAjAEEwayIHJAAgGigCACERICUoAhghCCAlKAIUIQ0gJiBBQQhqIgsoAjgQ9Q0gBCAJaiIMIARBCGpLBEAgDEEHayIZIAQgCUEHSxshGEEBIAh0QRBrIRdBwABBgAQgDUEJSBsiFkECdCEnICVBBGohLSAEIBZqIQggDEEBayEhICUoAhAhFSAHQQhqIQ4gDUEFSCEqA0AgDkIANwMAIA5BCGpBADYCACAHQuQPNwMAAkACfwJAIAsgFCAGIAUgIyAKICYgBCAMIARrIg0gFyAEIAQgF0sbIBUgBxDzBQRAICEgBGshDUEAIQkDQCAHQgA3AiQgB0LkDzcDGCAHIA0gBygCCEEBayIIIAggDUsbQQAgKhs2AiAgCyAUIAYgBSAjIAogJiAEIAlqIhJBAWoiCCANIBcgCCAIIBdLGyAVIAdBGGoQ8wVFDQIgBykDGCAHKQMAQq8BfFQNAiAHQRBqIAdBKGopAwA3AwAgDiAHQSBqKQMANwMAIAcgBykDGDcDACAJQQJLIBJBCWogDE9yRQRAIA1BAWshDSAJQQFqIQkMAQsLIBJBAWohEiAJIBFqQQFqDAILIAggBEEBaiIJTwRAIBFBAWohESAJIQQMAwsgGSAEQRFqIhJLBEAgCCAnaiAJTwRAQQAhDQNAIAsgBiAFICMgCSANahCQFiANQQJqIg1BCEcNAAsgBEEJaiEEIBFBCWohEQwEC0EAIQ0DQCALIAYgBSAjIAkgDWoQkBYgDUEEaiINQRBHDQALIBFBEWohESASIQQMAwsgDSARaiERIAwhBAwCCyAJIBFqCyENIAcoAgghCAJAAn8CQCAHKAIQIgkgFyASIBIgF0sbIhFLDQBBACEEIAkgJigCACIiRg0CQQEgJigCBCIEIAlGDQEaAkAgCUEDaiIkICJrIiJBB08EQCAkIARrIgRBB0kNAUECICYoAgggCUYNAxogCSAmKAIMRw0CQQMMAwtB6IjUywAgIkECdHZBD3EMAgtBzrXs/gAgBEECdHZBD3EMAQsgCUEPagsiBEUgCSARS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgCTYCACAmIAsoAjgQ9Q0LIBBFDQ4gEiAWaiAIQQF0aiEIIB0gLSANIAcoAggiCSAJIAcoAgxzIAQQgA0gOiA6KAIAIA1qNgIAIDBBAWohMCAQQQFrIRAgHUEQaiEdQQAhESASQQJqIg0gGCAHKAIIIBJqIgQgBCAYSxsiCU8NAANAIAsgBiAFICMgDRCQFiAJIA1BAWoiDUcNAAsgBygCCCASaiEECyAEQQhqIAxJDQALCyAaIAwgEWogBGs2AgAgDyAPKAIAIDBqNgIAIAdBMGokAAwDC0HA0dEAQQAgJS0AVRshFEEAITAjAEEwayIHJAAgGigCACERICUoAhghCCAlKAIUIQ0gJkEQEPUNIAQgCWoiDCAEQQRqSwRAIEFBBGohFyAMQQNrIAQgCUEDSxshGEEBIAh0QRBrIQtBwABBgAQgDUEJSBsiFkECdCEZIAxBBGshJyAlQQRqIS0gBCAWaiEIIAxBAWshISAlKAIQIRUgB0EIaiEOIA1BBUghKgNAIA5CADcDACAOQQhqQQA2AgAgB0LkDzcDAAJAAn8CQCAXIBQgBiAFICMgCiAmIAQgDCAEayINIAsgBCAEIAtLGyAVIAcQuwQEQCAhIARrIQ1BACEJA0AgB0IANwIkIAdC5A83AxggByANIAcoAghBAWsiCCAIIA1LG0EAICobNgIgIBcgFCAGIAUgIyAKICYgBCAJaiISQQFqIgggDSALIAggCCALSxsgFSAHQRhqELsERQ0CIAcpAxggBykDAEKvAXxUDQIgB0EQaiAHQShqKQMANwMAIA4gB0EgaikDADcDACAHIAcpAxg3AwAgCUECSyASQQVqIAxPckUEQCANQQFrIQ0gCUEBaiEJDAELCyASQQFqIRIgCSARakEBagwCCyAIIARBAWoiCU8EQCARQQFqIREgCSEEDAMLICcgBEERaiISSwRAIAggGWogCU8EQEEAIQ0DQCAXIAYgBSAjIAkgDWoQiRMgDUECaiINQQhHDQALIARBCWohBCARQQlqIREMBAtBACENA0AgFyAGIAUgIyAJIA1qEIkTIA1BBGoiDUEQRw0ACyARQRFqIREgEiEEDAMLIA0gEWohESAMIQQMAgsgCSARagshDSAHKAIIIQgCQAJ/AkAgBygCECIJIAsgEiALIBJJGyIRSw0AQQAhBCAJICYoAgAiIkYNAkEBICYoAgQiBCAJRg0BGgJAIAlBA2oiJCAiayIiQQdPBEAgJCAEayIEQQdJDQFBAiAmKAIIIAlGDQMaIAkgJigCDEcNAkEDDAMLQeiI1MsAICJBAnR2QQ9xDAILQc617P4AIARBAnR2QQ9xDAELIAlBD2oLIgRFIAkgEUtyDQAgJiAmKAIINgIMICYgJikCADcCBCAmIAk2AgAgJkEQEPUNCyAQRQ0NIBIgFmogCEEBdGohCCAdIC0gDSAHKAIIIgkgCSAHKAIMcyAEEIANIDogOigCACANajYCACAwQQFqITAgEEEBayEQIB1BEGohHUEAIREgEkECaiINIBggBygCCCASaiIEIAQgGEsbIglPDQADQCAXIAYgBSAjIA0QiRMgCSANQQFqIg1HDQALIAcoAgggEmohBAsgBEEEaiAMSQ0ACwsgGiAMIBFqIARrNgIAIA8gDygCACAwajYCACAHQTBqJAAMAgtBwNHRAEEAICUtAFUbIRlBACEwIwBBMGsiEiQAIBooAgAhDCAEIAlqIgsgBEEIaksEQCBBQQRqIREgC0EHayIcIAQgCUEHSxshJ0EBICUoAhh0QRBrIRdBwABBgAQgJSgCFCIJQQlIGyItQQJ0IR4gJUEEaiEgIAQgLWohCCALQQFrISwgJSgCECEhIBJBCGohGCAJQQVIIS4DQCAYQgA3AwAgGEEIakEANgIAIBJC5A83AwACfwJ/AkAgESAZIAYgBSAjIAogJiAEIAsgBGsiCSAXIAQgBCAXSxsgISASEL4JBEAgLCAEayEJQQAhBwNAIBJCADcCJCASQuQPNwMYIBIgCSASKAIIQQFrIg0gCSANSRtBACAuGzYCICARIBkgBiAFICMgCiAmIAQgB2oiDUEBaiIIIAkgFyAIIAggF0sbICEgEkEYahC+CUUNAiASKQMYIBIpAwBCrwF8VA0CIBJBEGogEkEoaikDADcDACAYIBJBIGopAwA3AwAgEiASKQMYNwMAIAdBAksgDUEJaiALT3JFBEAgCUEBayEJIAdBAWohBwwBCwsgDUEBaiENIAcgDGpBAWoMAgsgCCAEQQFqIgdPBEAgDEEBaiEMIAcMAwsgHCAEQRFqIg1LBEAgCCAeaiAHTwRAQQAhCQNAIBEgBiAFICMgByAJahDCHCAJQQJqIglBCEcNAAsgDEEJaiEMIARBCWoMBAtBACEJA0AgESAGIAUgIyAHIAlqEMIcIAlBBGoiCUEQRw0ACyAMQRFqIQwgDQwDCyAJIAxqIQwgCwwCCyAHIAxqCyEMIBIoAgghCQJAAn8CQCASKAIQIgQgFyANIA0gF0sbIghLDQBBACEHIAQgJigCACIORg0CQQEgJigCBCIHIARGDQEaAkAgBEEDaiIUIA5rIg5BB08EQCAUIAdrIgdBB0kNAUECICYoAgggBEYNAxogBCAmKAIMRw0CQQMMAwtB6IjUywAgDkECdHZBD3EMAgtBzrXs/gAgB0ECdHZBD3EMAQsgBEEPagsiB0UgBCAIS3INACAmICYoAgg2AgwgJiAmKQIANwIEICYgBDYCAAsgEEUNDSANIC1qIAlBAXRqIQggHSAgIAwgCSASKAIMIAlzIAcQgA0gOiA6KAIAIAxqNgIAAn8gJyASKAIIIA1qIgQgBCAnSxsiKiEJIwBBIGsiByQAAkACQAJAAkACQCANQQJqIgRBEGogCU0EQCAJIARrIiJBBE8EQCAiQQJ2ISQgESgCBCEMIBEoAgAhFCAEIQkDQCAFIAkgI3EiDkkNHyAFIA5rQQpNDQcgB0IANwMIIAdBCGoiFkEIIAYgDmoiFUEIQdTZzgAQ1SwgBzEADCFgIAc1AgghYSAHQgA3AwggFkEIIBVBAWpBCEHU2c4AENUsIAcxAAwhYiAHNQIIIWMgB0IANwMIIBZBCCAVQQJqQQhB1NnOABDVLCAHMQAMIWQgBzUCCCFlIAdCADcDCCAWQQggFUEDakEIQdTZzgAQ1SwgDCBgQjiGIGFCGIaEQr3P1vHR9+maHn5CMIinIhZNDQMgBzUCCCFgIAcxAAwhYSAUIBZBAnRqIA42AgAgDCBiQjiGIGNCGIaEQr3P1vHR9+maHn5CMIinIhZNDQQgFCAWQQJ0aiAOQQFqNgIAIAwgZEI4hiBlQhiGhEK9z9bx0ffpmh5+QjCIpyIWTQ0FIBQgFkECdGogDkECajYCACAMIGFCOIYgYEIYhoRCvc/W8dH36ZoefkIwiKciFk0NBiAUIBZBAnRqIA5BA2o2AgAgCUEEaiEJICRBAWsiJA0ACwsgIkF8cSAEaiEECyAHQSBqJAAgBAwFCyAWIAxBlOHOABDDIQALIBYgDEGk4c4AEMMhAAsgFiAMQbThzgAQwyEACyAWIAxBxOHOABDDIQALDBgLIgkgKkkEQANAIBEgBiAFICMgCRDCHCAqIAlBAWoiCUcNAAsLIDBBAWohMCAQQQFrIRAgHUEQaiEdQQAhDCASKAIIIA1qCyIEQQhqIAtJDQALCyAaIAsgDGogBGs2AgAgDyAPKAIAIDBqNgIAIBJBMGokAAwBC0HA0dEAQQAgJS0AVRshByBBQQRqIRIgJSgCFEEKTARAIAchCyAEIQwgBiENIAUhCEEAIQUjAEEgayIXJAAgJSgCGCEwIBdBCGogCUEBaiIGEOsgIBcoAgwhESAXKAIIIQcCQCAGBEAgByEEA0AgBSARRg0CIARCgICAgOCz8v/+ADcCACAEQRBqQQA2AgAgBEEIakIBNwIAIARBFGohBCAGIAVBAWoiBUcNAAsLIA8gDygCAAJ/IAkhBUEBIDB0QRBrITAjAEGwIGsiDyQAICUoAhQhBiAPQaAYakEAQYAI/AsAIBEEQCAHQgA3AgAgB0EANgIIIA9BMGpBAEGAFvwLACAPQRhqIAVBAmoQuR4gDykDGCFgIA9BEGogJSgCDCIEQQBHIAQgBWoQvB4gDyAFNgK4FiAPQQA2ArQWIA9BoAQgBCAEQaAETxs2ArAWIA8gYDcCKCAPIA8pAxA3AiAgD0EgaiAMIA0gCCAjEP4NIA9BvBZqQQBB5AH8CwAgBUEETwRAIAwgBUH/AGsiBEEAIAQgBU0baiEYQZYBQcUCIAZBC0gbIRZBACEEA0ACQAJAAkAgBSAMIAQgDSAIICMgCiAlIDAgJgJ/QQAgEiALIA0gCCAjIAogBCAMaiIOIAUgBGsgMCAOIA4gMEsbICUgD0GgGGoiFUGAARDvByIGRQ0AGiAGQQFrIRQgBkGBAU8NASAGIBYgFEEDdCAVaikDACJgQiWIp08NABogDyBgNwOgGEEBCyIUIA9BoBhqQYABIA9BIGogD0G8FmogByAREOwBIgZBACAGQYCAAU8bIQYgFEEBRgRAIAYgDykDoBhCJYinIhQgBiAUSxsgBiAUIBZLGyEGCyAGQQJPDQEgBCEGDAILIBRBgAFBnLfQABDDIQALIBIgDSAIICMgDkEBaiAYIAYgDmoiDiAOIBhLGxDLFSAEQQRqIQQgBkEBayEUA0AgBEEDayEGIAQgBU8NASAMIAYgMCAmIA9BIGogD0G8FmogByAREIYPIARBAWohBCAUQQFrIhQNAAsLIAZBAWohBCAGQQRqIAVJDQALCyAPQQA2AqwgIA9CgICAgMAANwKkICAPQQhqIA9BpCBqQYyHzgAQmCEgDygCLCEEIA8oAighBiAPIA8pAwg3AiggBARAIAYgBEECdEEEEPg6CyAPQQA2AqwgIA9CgICAgMAANwKkICAPIA9BpCBqQYyHzgAQmCEgDygCJCEEIA8oAiAhBiAPIA8pAwA3AiAgBARAIAYgBEECdEEEEPg6CwJAIAUgEUkEQCAHIAVBFGxqIQQDQCAEQRBqKAIAQf///z9xDQIgBEEIaigCAEEBRw0CIARBFGshBCAFQQFrIgUgEUkNAAsLIAUgEUH8tNAAEMMhAAsgBEKBgICAcDcCAEEAIQQCQAJAIAUEQANAIAUgEU8NAiAFIAcgBUEUbGoiBSgCEEH///8/cSAFKAIIQf///w9xaiIGayIFIBFPDQMgByAFQRRsaiINIAY2AgQgDUEBNgIAIARBAWohBCAFDQALCyAPQSBqEJgqIA9BsCBqJAAgBAwDCyAFIBFBjLXQABDDIQALIAUgEUGctdAAEMMhAAtBAEEAQYy30AAQwyEAC2o2AgAgCSAMIDAgByARICYgGiAlIB0gECA6EJUNIBdBADYCHCAXQoCAgIDAADcCFCAXIBdBFGpBjIfOABCZISAXKAIEIQQgFygCACEFIBEEQCAHIBFBFGxBBBD4OgsgBARAIAUgBEEUbEEEEPg6CyAXQSBqJAAMAgsgESARQcy00AAQwyEACyAHIRggBCEMIAYhCCAFIQ0gCiERIBIhFyAdITBBACEKIwBBkBdrIhYkAEEBICUoAhh0An8gCUUEQCAWQcgAahD+JyAWKAJIIScgFigCTAwBCyAWQdAAaiArIAkQuSkgFigCUCEnIBYoAlQLIRVBEGshLSAWQeAAakIANwMAIBZCADcDWCAWQUBrIAlBAnQiBhC4HiAWKAJEIRIgFigCQCEdAkAgCUEESQ0AIAwgCUH/AGsiBEEAIAQgCU0baiEZAkACQANAIApBgAFqIgcgBksEQCAGIAcgBhshBQNAIAUiBEEBdCEFIAQgB0kNAAsgFkE4aiAEELgeIBYoAjwhFCAWKAI4IQcCQAJAAkAgBkUNAAJAIAYgFE0EQCAGIBJLDQEgByAGQQN0Ig5qIQYgFkHoAGoiISIFQQA2AhAgBSAOIB1qIg42AgwgBSAdNgIIIAUgBjYCBCAFIAc2AgAgBSAOIB1rQQN2IgUgBiAHa0EDdiIGIAUgBkkbNgIUIBYoAnwiBiAWKAJ4IgVNBEAgFkEANgJwIBZCgICAgIABNwJoIBZBMGogIUGMh84AEKMhIBYoAjQhBSAWKAIwIQ4MBAsgBiAFayEGIAVBA3QiDiAWKAJoaiEFIBYoAnAgDmohDgNAIAUgDikDADcDACAFQQhqIQUgDkEIaiEOIAZBAWsiBg0ACwwCCyAWQQA2AnggFkEBNgJsIBZB+KDQADYCaCAWQgQ3AnAgFkHoAGpBvLfQABDvLAALIBZBADYCeCAWQQE2AmwgFkH4oNAANgJoIBZCBDcCcCAWQegAakHMt9AAEO8sAAsgFkEANgJwIBZCgICAgIABNwJoIBZBKGogFkHoAGpBjIfOABCjISAWKAIsIQUgFigCKCEOIBJFDQELIB0gEkEDdEEIEPg6CyAFBEAgDiAFQQN0QQgQ+DoLIAchHSAUIRIgBCEGCyAKIBJNBEAgFyAYIAggDSAjIBEgCyAMaiIFIAkgC2sgLSAFIAUgLUsbICUgHSAKQQN0aiIOIBIgCmsQ7wchBAJ/AkAgCyAVSQRAICcgC0ECdGoiFCAENgIAIAQNASALDAILIAsgFUHst9AAEMMhAAsCQCASIAQgCmoiBEEBayIHSwRAIB0gB0EDdGopAwAiYEL//////5cKVg0BIAQhCiALDAILIAcgEkH8t9AAEMMhAAsgCiASTw0DIA4gYDcDACAUQQE2AgAgFyAIIA0gIyAFQQFqIBkgBSBgQiWIpyIEaiIFIAUgGUsbEMsVIARBAWsiBSAVIAtBAWoiB2tLDQQCQCAFRQ0AIARBAnRBBGsiBEUNACAnIAdBAnRqQQAgBPwLAAsgCkEBaiEKIAUgC2oLIgRBAWohCyAEQQRqIAlJDQEMBAsLIAogEkHct9AAEK87AAsgCiASQYy40AAQwyEACyAWQQA2AnggFkEBNgJsIBZB+KDQADYCaCAWQgQ3AnAgFkHoAGpBnLjQABDvLAALIBooAgAhKiA6KAIAIRwgFiAmNgJoIBYgJkEQajYCbAJAIBZB6ABqEJ42IgRFDQBBBCAEIARBBE8bQQJ0IgRFDQAgFkHYAGogJiAE/AoAAAtBASEKIA8oAgAhISAWQSBqIAlBAWoiIhDrICAWKAIkIRQgFigCICEHIBZB+ABqQQBBgBb8CwAgFkHoAGohHiAWQRhqIAlBAmoQuR4gFikDGCFgIBZBEGogJSgCDCIEQQBHIAQgCWoQvB4gFiAJNgKAFyAWQQA2AvwWIBZBoAQgBCAEQaAETxs2AvgWIBYgYDcCcCAWIBYpAxA3AmgCQAJAA0AgIgRAQQAhBSAHIQQDQCAFIBRGDQMgBEKAgICA4LPy//4ANwIAIARBEGpBADYCACAEQQhqQgE3AgAgBEEUaiEEICIgBUEBaiIFRw0ACwsCQCAKIhcEQCAWQegAaiAMIAggDSAjEP4NDAELIA8oAgAgIWshGEEAIQ5DAAAAACFvIwBBsCprIgskACALQQBBgAj8CwAgC0GACGpBAEGAFvwLACALQYAeakEAQbAE/AsAIAtBsCJqQQBBgAj8CwAgGARAIAwgKmshBQNAAkACQAJAIA4gEEcEQCAwIA5BBHRqIgQvAQwiCkHABU8NASAELwEOIRkgBCgCBCEkIAQoAgAhBiALQYAIaiAKQQJ0aiIEIAQoAgBBAWo2AgAgCkH/AEsNAgwDCyAQIBBBnLbQABDDIQALIApBwAVBrLbQABDDIQALIBlB/wdxIgRBiwFNBEAgC0GAHmogBEECdGoiBCAEKAIAQQFqNgIADAELIARBjAFBvLbQABDDIQALIAUhBAJAIAYiCkUNAANAIA0gBCAjcSIZSwRAIAsgCCAZai0AAEECdGoiGSAZKAIAQQFqNgIAIARBAWohBCAKQQFrIgoNAQwCCwsgGSANQcy20AAQwyEACyAFIAZqICRB////D3FqIQUgDkEBaiIOIBhHDQALC0EQIQQgC0GAAkGAAkEBIAtBsCJqQYACEJMNIAtBgAhqQcAFQcAFQQAgFkHoAGoiBUEQakHABRCTDSALQYAeakGMASAFKAKQFkEAIAUoAgAgBSgCBBCTDUOeyf9+IW0DQCBtIG0gBCAFaioCACJuIG0gbl0bIG4gblwbIW0gBEEEaiIEQZAWRw0ACyAFIG04ApQWAkACQAJAIAUoAgwiBgRAIAUoApgWIQ5BACEEIAUoAggiBUEANgIAIA4EQCAFQQRqIQogBkEBayEYQwAAAAAhbQNAIAQgDGogI3EiBSANTw0DIAQgGEYNBCAKIG0gbyALQbAiaiAFIAhqLQAAQQJ0aioCAJIib5IibjgCACBvIG4gbZOTIW8gCkEEaiEKIG4hbSAOIARBAWoiBEcNAAsLIAtBsCpqJAAMAwtBAEEAQey10AAQwyEACyAFIA1B/LXQABDDIQALIAYgBkGMttAAEMMhAAsLIDogHDYCACAPICE2AgAgGiAqNgIAIBYgHjYCiBcgFiAWQdgAaiIFNgKEFwJAIBZBhBdqEJ42IgRFDQBBBCAEIARBBE8bQQJ0IgRFDQAgJiAFIAT8CgAAC0EAIQogDwJ/IAkhBUEAIQRBACELIwBB8AFrIhgkACAUBEAgJSgCFCEGIAdCADcCACAHQQA2AgggGEEMakEAQeQB/AsAIAVBBE8EQCAWQegAaiEkQZYBQcUCIAZBC0gbISAgJ0EEaiEsA0ACQAJAIAQgFUkEQCALIBJNBEAgBSAMIAQgCCANICMgESAlIC0gJiAnIARBAnQiLmooAgAiDiAdIAtBA3RqIBIgC2sgJCAYQQxqIAcgFBDsASIGQQAgBkGAgAFPGyEGIAsgDmohCyAOQQFGBEAgC0EBayIOIBJPDQMgBiAdIA5BA3RqKQMAQiWIpyIOIAYgDksbIAYgDiAgSxshBgsgBkECSQRAIAQhBgwECyAEQQRqIQQgBkEBayEZICwgLmohDgNAIARBA2shBiAEIAVPDQQgDCAGIC0gJiAkIBhBDGogByAUEIYPIAYgFUkEQCAEQQFqIQQgDigCACALaiELIA5BBGohDiAZQQFrIhlFDQUMAQsLIARBA2sgFUH0stAAEMMhAAsgCyASQdSy0AAQrzsACyAEIBVBxLLQABDDIQALIA4gEkHkstAAEMMhAAsgBkEBaiEEIAZBBGogBUkNAAsLAkAgBSAUSQRAIAcgBUEUbGohBANAIARBEGooAgBB////P3ENAiAEQQhqKAIAQQFHDQIgBEEUayEEIAVBAWsiBSAUSQ0ACwsgBSAUQfy00AAQwyEACyAEQoGAgIBwNwIAQQAhBAJAAkAgBQRAA0AgBSAUTw0CIAUgByAFQRRsaiIFKAIQQf///z9xIAUoAghB////D3FqIgZrIgUgFE8NAyAHIAVBFGxqIgsgBjYCBCALQQE2AgAgBEEBaiEEIAUNAAsLIBhB8AFqJAAgBAwDCyAFIBRBjLXQABDDIQALIAUgFEGctdAAEMMhAAtBAEEAQbSy0AAQwyEACyAhajYCACAJIAwgLSAHIBQgJiAaICUgMCAQIDoQlQ0gFw0ACwwBCyAUIBRBzLTQABDDIQALIBZBADYCjBcgFkKAgICAwAA3AoQXIBZBCGogFkGEF2pBjIfOABCYISAWKAJ0IQQgFigCcCEFIBYgFikDCDcCcCAEBEAgBSAEQQJ0QQQQ+DoLIBZBADYCjBcgFkKAgICAwAA3AoQXIBYgFkGEF2pBjIfOABCYISAWKAJsIQQgFigCaCEFIBYgFikDADcCaCAEBEAgBSAEQQJ0QQQQ+DoLIBQEQCAHIBRBFGxBBBD4OgsgEgRAIB0gEkEDdEEIEPg6CyAnIBUQgDEgFkHoAGoQmCogFkGQF2okAAtBAUEYICUoAhwiBCAlKAIYIgUgBCAFShtBAWoiBCAEQRhOG3QhBCAAKQPwASFgIAApA+gBIAAQ+A4gASACcg0DIAAoApQqIgIgACgCmCoiBWpB/98ASSAAKAIcQQNKckUNAyBgfadBASAAKAIkdGogBEsNAyAFIARBA3YiBE8gAiAET3INAyAAKQP4ARDLKyAAKQPoASJgEMsrIAAgYDcD+AFNDQQgACgCaEUNBCBBEJQqQQA2AhgMBAsgBCAFQYi/0AAQrzsACyAFIAxBmL/QABCvOwALIAcgDUGov9AAEK87AAsCQAJAAkACQAJAAkAgGigCACICBEAgACgClCoiBCAAKALEASIFTw0BIAAoAsABIARBBHRqIgRBkAg7AQ4gBEKAgIDAADcCBCAEIAI2AgAgBAJ/AkACQCACQQZPBEAgAkGCAUkNASACQcIQSQ0CQRUgAkHCMEkNAxpBFkEXIAJBwrABSRsMAwsgAgwCCyACQQJrIgJnQSBqQT9zQQFrIgRBAXQgAiAEdmpBAmoMAQsgAkHCAGtnQSBqQT9zQQpqCyICQfj/A3FBA3ZBA2wiBEEGdEHAmsgCIARBAXR2QcABcWogAkEDdEE4cXJBwgBqOwEMIAAoApwqIQIgAEEANgKcKiAAIAAoApQqQQFqNgKUKiAAIAIgACgCmCpqNgKYKgsgAUUEQCAAKQPoASAAKQPwAVENBwsgACgC8CkiBCAAKAKMKiICSQ0BIAAoAuwpIAJqITogBCACayEqIAApA+gBIAApA/ABImB9pyFEID1B/wFxIU4gAC0AvyohFiAALQDAKiEwIAAoApgqIQYgACgClCohEiAAKALAASEdIAAoAsQBIT0gAEHAAmohSSAAQbAqaiFPIDtBLGohNSAAKALIASE2IAAoAswBITRBACECIwBB8AFrIhckACAlLQBUIQUCQAJAAkACQAJAAkACQCAlLQBWIglFBEAgASECIAVBAXENAQsgYBDLKyERIBdBDGogJUEMaikCADcCACAXQTBqICVBMGopAgA3AgAgF0E4aiAlQThqKQIANwIAIBcgJSkCBDcCBCAXICUpAig3AiggJSgCICENICUoAiQhCiAlKABZIQcgJSkCGCFhICUoAgAhDCAlKAIUIQQgJS8BUCEIIBdByABqICVByABqKQIANwIAIBcgCDsBUCAXIAQ2AhQgFyAMNgIAIBcgYTcCGCAXIAc2AFkgFyAKNgIkIBcgDTYCICAXIAk6AFYgFyAFOgBUIBcgJSkCQDcCQCAXICUvAFc7AFcgFyAlLQBVOgBVIBcgJS8BUjsBUiBERQRAQQJCAyA1IDYgNBDfEyA1IDUoAgBBB2pBeHE2AgAMBwsCfyMAQZAIayIFJABBASEMAkACQCASIERBCHZBAmpPDQAgBrMgRLMibUOkcH0/lF5FDQAgBUEQakEAQYAI/AsAIERBDGoiBkENbiEMIAZBDU8EQCBgpyEHA0AgByAjcSIGICpPDQMgBUEQaiAGIDpqLQAAQQJ0aiIGIAYoAgBBAWo2AgAgB0ENaiEHIAxBAWsiDA0ACwsgBUEIaiAFQRBqQYACQYACEIERIG1DpHD9QJRDAABQQZUgBSgCDLMibSAFKgIIIm4gbSBuXhtdRSEMCyAFQZAIaiQAIAwMAQsgBiAqQZT40QAQwyEAC0UEQCAmIEkpAgA3AgAgJkEIaiBJQQhqKQIANwIAICsgAiA6ICogESAjICUgRCBPIDUgNiA0QQAQtQ4MBgsgNSgCACJaQQN2IllBAWoiBSA0Tw0BIDYgWWoiWy0AACFcIAUgNmoiXS0AACFeIARBA0gNAiAEQQNGDQMjAEHwAGsiBSQAIAVB2ABqEP0nIAUpA1ghYCAFQdAAahD+JyAXQeAAaiIhIgYgBSkDUDcCCCAGIGA3AgAgBkIANwIQIAVByABqEP0nIAUpA0ghYCAFQUBrEP4nIAYgBSkDQDcCICAGIGA3AhggBkIANwIoIAVBOGoQ/ScgBSkDOCFgIAVBMGoQ/icgBiAFKQMwNwI4IAYgYDcCMCAGQgA3AkAgBUEoahD+JyAFKQMoIWAgBUEgahD+JyAFKQMgIWEgBUEANgJsIAVCgICAgMAANwJkIAVBGGogBUHkAGoiCUGMh84AEKIhIAUpAxghYiAFQQA2AmwgBUKAgICAwAA3AmQgBUEQaiAJQYyHzgAQnCEgBSkDECFjIAVBADYCbCAFQoCAgIDAADcCZCAFQQhqIAlBjIfOABCgISAFKQMIIWQgBkEANgJwIAYgYDcCSCAGIGE3AlAgBkIANwJ0IAYgYjcCWCAGIGM3AmAgBkIANwJ8IAYgZDcCaCAFQfAAaiQAAkAgBEEKTwRAIBEhCSAWIQwgMCENIwBBwBdrIigkACAoQQA2AsABIChCgICAgBA3ArgBIChByABqIChBuAFqQYyHzgAQkCEgKCgCTCFFICgoAkghRyAXLQBTIgRFBEAgKEHcAGogF0EMaiIiKQIANwIAIChBgAFqIBdBMGoiJCkCADcCACAoQYgBaiAXQThqIhwpAgA3AgAgKCAXKQIENwJUICggFykCKDcCeCAXLQBcIQUgFygCGCEGIBcoAhwhByAXKAIgIQogFygCJCEIIBctAFEhDyAXLQBZIQsgFy0AWiEQIBctAFshDiAXKAIAIRQgFygCFCEYIBctAFAhGiAoQZgBaiAXQcgAaiIeKQIANwIAICggGjoAoAEgKCAYNgJkICggFDYCUCAoIA46AKsBICggEDoAqgEgKCALOgCpASAoIA86AKEBICggCDYCdCAoIAo2AnAgKCAHNgJsICggBjYCaCAoIAU6AKwBICggFykCQDcCkAEgFy0AUiEbIBctAFQhFSAXLQBVIRkgFy0AViEnIBctAFchLSAoIBctAFgiIDoAqAEgKCAtOgCnASAoICc6AKYBICggGToApQEgKCAVOgCkASAoIAQ6AKMBICggGzoAogEgKEHEAWogIikCADcCACAoQegBaiAkKQIANwIAIChB8AFqIBwpAgA3AgAgKEGAAmogHikCADcCACAoIBo6AIgCICggGDYCzAEgKCAUNgK4ASAoIAU6AJQCICggDjoAkwIgKCAQOgCSAiAoIAs6AJECICggDzoAiQIgKCAINgLcASAoIAo2AtgBICggBzYC1AEgKCAGNgLQASAoIBcpAgQ3ArwBICggFykCKDcC4AEgKCAXKQJANwL4ASAoICA6AJACICggLToAjwIgKCAnOgCOAiAoIBk6AI0CICggFToAjAIgKCAEOgCLAiAoIBs6AIoCIBdBBGohBiAoQbwBaiEKIChB1ABqIQRELp+Hoq5CfVQhhQFBACEHQQEhC0EAIQgDQCCFASGGAQJAIAciBUEPSw0AA0ACQCAoQgA3A7ABIChBuAFqIAggByAIdCIFEMQVIAggKCgCVEcgBSAoKAJYR3IgC3EhCyAdID0gEiAEIAogKEGwAWoQhxBFDQAgKCsDsAEihQEghgFkDQAgBiAKKQIANwIAIAZBCGogCkEIaikCADcCAEEQIQUghQEhhgEgB0EBaiIHQRBHDQEMAgsLIIYBIYUBIAchBQsgBUEBayIHQQAgBSAHTxtBAXYhByAIQQFqIghBBEcNAAsCQCALQQFxRQ0AIChCADcDsAEgHSA9IBIgBCAEIChBsAFqEIcQGiAoKwOwASCFAWNFDQAgBiAEKQIANwIAIAZBCGogBEEIaikCADcCAAsgHSEFIwBBIGsiByQAAkACQAJAIAYoAgAiCiAEKAIARgRAIAQoAgQgBigCBEYNAQsgEiA9Sw0BIBJFDQAgEkEEdCEIIAqtIWAgBigCBCEGA0ACQCAFQQRqKAIAQf///w9xRQ0AIAVBDGovAQBB/wBNDQAgBSAEELMgIAYgYCAFQQ5qIAVBCGoQlhgLIAVBEGohBSAIQRBrIggNAAsLIAdBIGokAAwBCyAHQQA2AhggB0EBNgIMIAdBrJfSADYCCCAHQgQ3AhAgB0EIakGkmNIAEO8sAAsLICFBGGohJyAhQTBqIS0jAEEwayJGJAAgRkEYaiArAn8gHSEEQQAgEiIFRQ0AGiAFQQFrID1JBEBBACEGA0AgBCgCACAGaiEGIARBEGohBCAFQQFrIgUNAAsgBgwBCyA9ID1BgKHWABDDIQALIhAQuCkgHSEKIAkhBCBGKAIYIiwhFCBGKAIcIi4hD0EAIQVBACEOAkACQAJAAkACQAJAAkACQAJAIBIEQCAjQQFqIQsDQAJAAkAgDiA9RwRAIAooAgAiCCAEICNxIgRqICNLDQEgBSEGDAILID0gPUGQodYAEMMhAAsgCyAEayIHIAVqIgYgB0kNAyAGIA9LDQQgBCALSw0FICMgKk8NBiAFIBRqIAcgBCA6aiAHQcCh1gAQ1SwgCCAHayEIQQAhBAsCQCAIRQRAIAQhByAGIQUMAQsgBiAIaiIFIAZJDQcgBSAPSw0IIAQgCGoiByAESQ0JIAcgKksNCiAGIBRqIAggBCA6aiAIQfCh1gAQ1SwLIApBBGooAgBB////D3EgB2ohBCAKQRBqIQogEiAOQQFqIg5HDQALCwwICyAFIAZBoKHWABCxOwALIAYgD0GgodYAELA7AAsgBCALQbCh1gAQsTsACyALICpBsKHWABCwOwALIAYgBUHQodYAELE7AAsgBSAPQdCh1gAQsDsACyAEIAdB4KHWABCxOwALIAcgKkHgodYAELA7AAsgLCELIC4hGUEAIQcjAEHgCGsiMyQAAkAgEEUEQCAhQQE2AhAMAQsgEEGAAU8EQCAzQcgAaiIKQQBBhAj8CwAgM0Gj4P/7BzYCzAggM0HUCGoiDiAKQeQAIBBBoARuQQFqIgQgBEHkAE8bIg8QgRwgM0FAayAOQcyCzgAQoiEgMygCQCIUIQYgMygCRCIgIQQjAEEQayIFJAAgBUEHNgIMAkAgDwRAIBAgD24hGCAEIA9PBEAgBiAPQYgIbGohCCAGIQQDQCAEQQBBhAj8CwAgBEGECGpBo+D/+wc2AgAgBEGICGoiBCAIRw0ACyAQQccAayEaQQAhCANAIAggD24hBAJAIAdFDQAgBUEMahDdLiEbIA8gEE0EQCAbIBhwIARqIQQMAQtB/N7MABDnKwALIAQgGiAEQcYAaiAQSRsiBCAZSwRAIAQgGUGM38wAEK87AAsgBiAEIAtqIBkgBGtBxgAQkiQgCCAQaiEIIAZBiAhqIQYgDyAHQQFqIgdHDQALIAVBEGokAAwCCyAPIARBrOrMABCwOwALQezezAAQ4isAC0EAIRgjAEGQCGsiByQAIAdBBzYCBAJAIA8EQAJAIA8gEEEBdEHGAG5qQeMAaiIEIAQgD3AiBUcEQCAEIAVrIRpBACEEA0AgB0EIaiIFQQBBhAj8CwAgB0Gj4P/7BzYCjAggB0EEaiEbQQAhCAJAAkACQCAQIgZBxgBLBEAgGxDdLiAQQcUAayIIRQ0BIAhwIgggGUsNAkHGACEGCyAFIAggC2ogGSAIayAGEJIkDAILQazYzAAQ5ysACyAIIBlBvNjMABCvOwALIAQgIE8NAiAEQQFqIgVBACAFIA9HGyAYQQFqIRggFCAEQYgIbGoiBiAHKAKICCAGKAKACGo2AoAIQQAhBEEAIQgDQCAGIAhBAnRqIhsgB0EIaiAEaigCACAbKAIAajYCACAIQQFqIQggBEEEaiIEQYAIRw0ACyEEIBggGkkNAAsLIAdBkAhqJAAMAgsgBCAgQdzezAAQwyEAC0HM3swAEOIrAAsgM0E4aiArIBAQuCkgMygCPCETIDMoAjghOSAKIA9BCHQQoxUgM0EwaiAKQcyCzgAQmCEgMygCNCEeIDMoAjAhBiAzQeAAakIANwMAIDNB2ABqQgA3AwAgM0HQAGpCADcDACAzQgA3A0ggDiAKIA9BB2pBA3YiBBCHHCAzQShqIA5BzILOABCeISAzKAIsITggMygCKCEFIDNBIGogKyAEIBBsELgpIDMoAiQhHyAzKAIgIS8gCiAPQcSe0AAQmRUgM0EYaiAKQcyCzgAQqiEgMygCHCEyIDMoAhghQkEDQQogFygCFEEMSBshCgNAIAshDkEAIQhBACEbIwBBgAFrIhwkAAJAIA9FDQACQAJAAkACQCAgBEBBASEbIA9BAUcNASAQRQ0FA0AgCCATRg0DIAggOWpBADoAACAIQQFqIgggEEcNAAsMBQsMNAsgHiAPQQh0IgRPBEAgD0EHaiE+AkAgD0H///8BcUUNACAPQQp0IgRFDQAgBkEAIAT8CwALID5BA3YhKSAUQYAIaiEHIAYhBANAIAggIEYEQCAgICBB/NfMABDDIQALAn0gBygCACIYQYACTwRAIBizEOoSDAELIBhBAnRBwIfzAGoqAgALIW0gCCAeRg0DIAQgbTgCACAHQYgIaiEHIARBBGohBCAPIAhBAWoiCEcNAAsgD0ECdCEYIA9B/AdsIRogD0H/AWwhGyAUQfwHaiEVQYACISIDQCAiQQFrISJBACEIIAYhByAVIQQCQAJAAkADQCAIIB5GDQEgCCAgRg0CIAcqAgAhbSAEKAIAELksIW4gHiAIIBtqIiRLBEAgByAaaiBtIG6TOAIAIAdBBGohByAEQYgIaiEEIA8gCEEBaiIIRg0EDAELCyAkIB5B7NfMABDDIQALIB4gHkHM18wAEMMhAAsgICAgQdzXzAAQwyEACyAaIBhrIRogGyAPayEbIBVBBGshFSAiDQALIDgEQCA4QQV0IQcgBSEIA0AgCEIANwIAIAhBGGpCADcCACAIQRBqQgA3AgAgCEEIakIANwIAIAhBIGohCCAHQSBrIgcNAAsLIB8gECApbCIETwRAIAQEQCAvQQAgBPwLAAsgECAZTQRAIBBFDQUgDiAQaiFIIA9BeHEhGCAPQQdxIj9BAnQhJCAFIClBBXRqIVAgBSAPQQN2IlFBBXRqIVIgD0EISSFTQQAhIkEAITECQANAIBMgMUYEQCATIBNBnNbMABDDIQALAkACQAJAIA8gDi0AAGwiNyAeTQRAIDggUUkNASAxIDlqITxDmXaWfiFtIFMNAyAeIDdrIUAgBiA3QQJ0aiFDQQAhGkEAIRUgBSEEA0AgFUEDdCIHIEBLBEAgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQZzXzAAQ7ywACyBAIAdrQQdNDQMgBEEgaiAVQQFqIRUgHEH4AGogQyAHQQJ0aiIHQRhqKQIANwMAIBxB8ABqIAdBEGopAgA3AwAgHEHoAGogB0EIaikCADcDACAcIAcpAgA3A2BBACEIQQAhBwNAIAQgCGoiSiAcQeAAaiAIaioCACBKKgIAkjgCACBtIAQgB0G818wAEKIuKgIAIm5eBEAgPCAHIBpqOgAAIG4hbQsgCEEEaiEIIAdBAWoiB0EIRw0ACyAaQQhqIRoiBCBSRw0ACwwDCyAcQQA2AnAgHEEBNgJkIBxB4NLMADYCYCAcQgQ3AmggHEHgAGpBrNbMABDvLAALIBxBADYCcCAcQQE2AmQgHEHg0swANgJgIBxCBDcCaCAcQeAAakG81swAEO8sAAsgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQazXzAAQ7ywACwJAAkAgGCA3aiIEIB5NBEAgPyAeIARrSw0BAkAgPwRAIAYgBEECdGohB0EAIQggJCEaIAUhBCAYIRsDQCAIIBhqIjdBA3YiFSA4Tw0CIAQgG0ECdEFgcWoiQCAHKgIAIEAqAgCSOAIAIG0gBSAVQQV0aiIVIAhB/NbMABCiLioCAF4EQCAVIAhBjNfMABCiLiA8IDc6AAAqAgAhbQsgB0EEaiEHIARBBGohBCAIQQFqIQggG0EBaiEbIBpBBGsiGg0ACwtDzczgQSFuIDFB0A9PDQMgMbNDKVyPPZRDAAD6RJVDuB5FP5JDzczgQZQhbgwDCyAVIDhB7NbMABDDIQALIBxBADYCcCAcQQE2AmQgHEHg0swANgJgIBxCBDcCaCAcQeAAakHM1swAEO8sAAsgHEEANgJwIBxBATYCZCAcQeDSzAA2AmAgHEIENwJoIBxB4ABqQdzWzAAQ7ywACyAxQQFqITEgDkEBaiEOQQAhCANAIBxB4ABqIAhqIG04AgAgCEEEaiIIQSBHDQALIBwqAnwhfSAcKgJ4IX4gHCoCdCF/IBwqAnAhgAEgHCoCbCGBASAcKgJoIYIBIBwqAmQhgwEgHCoCYCGEAUEAIQgDQCAcQeAAaiAIaiBuOAIAIAhBBGoiCEEgRw0ACyAcQRhqIhsgHEH4AGoiFSkCADcDACAcQRBqIjcgHEHwAGoiPCkCADcDACAcQQhqIkAgHEHoAGoiQykCADcDACAcIBwpAmA3AwAgKSA4TQRAID5BCE8EQCAiIQcgBSEIA0AgCEEEaiJKKgIAIW0gCEEIaiJMKgIAIW4gCEEMaiJUKgIAIW8gCEEQaiJVKgIAIXAgCEEUaiJWKgIAIXEgCEEYaiJXKgIAIXIgCCoCACFzIBwgCEEcaiJYKgIAIH2TOAI8IBwgciB+kzgCOCAcIHEgf5M4AjQgHCBwIIABkzgCMCAcIG8ggQGTOAIsIBwgbiCCAZM4AiggHCBtIIMBkzgCJCAcIHMghAGTOAIgIBUgGykDADcDACA8IDcpAwA3AwAgQyBAKQMANwMAIBwgHCkDADcDYCAcQSBqIgRBAEHs38wAEKIuKgIAIW0gHEHgAGoiGkEAQfzfzAAQoi4qAgAhbiAEQQFBjODMABCiLioCACFvIBpBAUGc4MwAEKIuKgIAIXAgBEECQazgzAAQoi4qAgAhcSAaQQJBvODMABCiLioCACFyIARBA0HM4MwAEKIuKgIAIXMgGkEDQdzgzAAQoi4qAgAhdCAEQQRB7ODMABCiLioCACF1IBpBBEH84MwAEKIuKgIAIXYgBEEFQYzhzAAQoi4qAgAhdyAaQQVBnOHMABCiLioCACF4IARBBkGs4cwAEKIuKgIAIXkgGkEGQbzhzAAQoi4qAgAheiAEQQdBzOHMABCiLioCACF7IBpBB0Hc4cwAEKIuIUsgHCB5IHpgQQZ0NgJYIBwgdyB4YEEFdDYCVCAcIHUgdmBBBHQ2AlAgHCBzIHRgQQN0NgJMIBwgcSByYEECdDYCSCAcIG8gcGBBAXQ2AkQgHCBtIG5gNgJAIBwgeyBLKgIAYEEHdDYCXCAcQUBrEMwrIUsgByAfTw0EIAcgL2oiTSBNLQAAIEtyOgAAIBUgGykDADcDACA8IDcpAwA3AwAgQyBAKQMANwMAIBwgHCkDADcDYCAEQQBB7OHMABCiLioCACFtIBpBAEH84cwAEKIuKgIAIW4gBEEBQYzizAAQoi4qAgAhbyAaQQFBnOLMABCiLioCACFwIARBAkGs4swAEKIuKgIAIXEgGkECQbzizAAQoi4qAgAhciAEQQNBzOLMABCiLioCACFzIBpBA0Hc4swAEKIuKgIAIXQgBEEEQezizAAQoi4qAgAhdSAaQQRB/OLMABCiLioCACF2IARBBUGM48wAEKIuKgIAIXcgGkEFQZzjzAAQoi4qAgAheCAEQQZBrOPMABCiLioCACF5IBpBBkG848wAEKIuKgIAIXogBEEHQczjzAAQoi4qAgAheyAaQQdB3OPMABCiLioCACF8IFcgeSB6IHkgel0bOAIAIFYgdyB4IHcgeF0bOAIAIFUgdSB2IHUgdl0bOAIAIFQgcyB0IHMgdF0bOAIAIEwgcSByIHEgcl0bOAIAIEogbyBwIG8gcF0bOAIAIAggbSBuIG0gbl0bOAIAIFggeyB8IHsgfF0bOAIAIAdBAWohByAIQSBqIgggUEcNAAsLICIgKWohIiAOIEhHDQEMCAsLICkgOEHM38wAELA7AAsgByAfQdzfzAAQwyEACyAQIBlBzNXMABCwOwALIAQgH0G81cwAELA7AAsgBCAeQazVzAAQsDsACyATIBNBnNjMABDDIQALIB4gHkGM2MwAEMMhAAsCQCATIBBBAWsiB0sEQCAHDQFBASEbDAILIAcgE0Hc1cwAEMMhAAsgKSAQQQJrIg5sIQQgByA5ai0AACEIIA4hB0EBIRsCQAJAA0AgBCAIQQN2QR9xaiIYIB9PDQEgGCAvai0AACAIQQdxdkEBcQRAIAcgE08NAyAbIAhB/wFxIAcgOWotAAAiCEdqIRsLIA4gE0kEQCAHIDlqIAg6AAAgBCApayEEIAdBAWsiB0F/Rg0EDAELCyAHIBNBjNbMABDDIQALIAhB+AFxQQN2IARqIB9B7NXMABDDIQALIAcgE0H81cwAEMMhAAsgHEGAAWokAAJAAkACQCA5IBMgECBCIDIgDxCWEiIPIgQgIE0EQCAEBEAgFCAEQYgIbGohByAUIQQDQCAEQQBBhAj8CwAgBEGECGpBo+D/+wc2AgAgBEGICGoiBCAHRw0ACwsCQCAQBEBBACEEA0AgBCATRg0EICAgBCA5ai0AACIHTQ0FIAQgGUYNAiAUIAdBiAhsaiAEIAtqLQAAELYpIARBAWoiBCAQRw0ACwsMBAsgGSAZQbzfzAAQwyEACyAEICBBrOrMABCwOwALIBMgE0Gc38wAEMMhAAsgByAgQazfzAAQwyEACyAKQQFrIgoNAAsgHgRAIAYgHkECdEEEEPg6CyA4BEAgBSA4QQV0QQQQ+DoLICsgLyAfEOA1IDIEQCBCIDJBAXRBAhD4OgsgIARAIBQgIEGICGxBBBD4OgtBACEYQQAhKUEAITdBACFCQQAhPiMAQaAZayIfJAAgH0GIAWogKyAbELkpIB8oAowBITEgHygCiAEhFCAfQYABaiArIBsQuSkgHygChAEhLyAfKAKAASEkIB9BmBFqIgVBAEGECPwLACAfQaPg//sHNgKcGSAfQZAJaiIEIAUgG0EEdEHwB2pBBnYiDhCBHCAfQfgAaiAEQcyCzgAQoiEgHygCfCEaIB8oAnghFSAfQfAAaiArIA4QuSkgHygCdCEGIB8oAnAhCiAFQQBBhAj8CwAgH0Gj4P/7BzYCnBkgBCAFQcAAIBsgG0HAAE8bEIEcIB9B6ABqIARBzILOABCiISAfKAJsITIgHygCaCE/IB9BoBFqQgA3AwAgH0IANwOYESAEIAVBgRAQgxwgH0HgAGogBEHMgs4AEJ0hIB8oAmQhHCAfKAJgISBBACIFRQRAIB9BkAFqQQBBgAL8CwALIB9BkANqQQBBgAL8CwAgH0GQBWpBAEGAAvwLACAfQZAHakEAQYAC/AsAIBAEQCAQQQFrIQcDQAJAAkACQCAYIC9JBEAgJCAYQQJ0aiIEIAQoAgBBAWo2AgAgBUEBaiEEIAUgB0cNAQwCCyAYIC9B/NzMABDDIQALAkAgBSATSQRAIAQgE08NASAFIDlqIgUtAAAgBUEBai0AAEcNAgwDCyAFIBNBjN3MABDDIQALIAVBAWogE0Gc3cwAEMMhAAsgGEEBaiEYCyAEIgUgEEcNAAsLIAshOAJAIBtFBEAgBiELIAohBAwBCyAUIQggGyEeIA4hEEEAIQUCQAJAAkACQANAQcAAIBsgN2siBCAEQcAATxshD0EBQcAAIB4gHkHAAE8bIgQgBEEBTRshQEEAISICQAJAAkACQAJAAkACQANAICIgMkYNASA/ICJBiAhsaiIEQQBBgAj8CwAgBEKAgICAsIT8v/8ANwKACCAiIDdqIgcgL08NAiAkIAdBAnRqKAIAIgcEQCAFIBkgBSAZSRshGANAIBggGUYNBSAEIAUgOGotAAAQtikgGEEBaiEYIAVBAWohBSAHQQFrIgcNAAsLIAQgBBChBzgChAggIkECdCIEIB9BkAVqIgdqICI2AgAgH0GQA2oiCyAEaiAiNgIAIAQgH0GQAWoiGGpBATYCACAiQQFqIiIgQEcNAAsgDiA/IDIgGEHAACAHQcAAIAtBwAAgICAcIA8gD0HAAEGAEBCPBiI8IEJqIg9PDQYgDiAPIA4bIQcDQCAHIgRBAXQhByAEIA9JDQALIB9BmBFqIgdBAEGECPwLACAfQaPg//sHNgKcGSAfQZAJaiIPIAcgBBCBHCAfQdgAaiAPQcyCzgAQoiEgDiAfKAJcIgdLDQMgDiAaSw0EIB8oAlghDwJAIA5FDQAgDkGICGwiC0UNACAPIBUgC/wKAAALIBpFDQUgFSAaQYgIbEEEEPg6DAULIDIgMkHM3MwAEMMhAAsgLyA3IC8gN0sbIC9B3NzMABDDIQALIAUgGUHs3MwAEMMhAAsgDiAHQYzbzAAQsDsACyAOIBpBnNvMABCwOwALIAchGiAPIRUgBCEOCwJAIDwgPmoiBCAQTQRAIAYhCyAKIQQgECEPDAELIBAgBCAQGyEYA0AgGCIPQQF0IRggBCAPSw0ACyAfQdAAaiArIA8QuSkCQCAfKAJUIgsgEE8EQCAGIBBJDQEgHygCUCEEIBBBAnQiBwRAIAQgCiAH/AoAAAsgCiAGEIAxDAILIBAgC0Gs28wAELA7AAsgECAGQbzbzAAQsDsACyA8BEBBACEYIAsgPmsiBkEAIAYgC00bIQogGiBCayIGQQAgBiAaTRshQyAEID5BAnRqISIgFSBCQYgIbGohECAfQZADaiEHA0AgGEHAAEYNNyAHKAIAIgYgMk8NAyAYIENGDQQgECA/IAZBiAhsakGICPwKAAAgBkHAAE8NOCAKIBhGDQUgIiAfQZABaiAGQQJ0aigCADYCACAHKAIAIgZBwABPDTkgH0GQB2ogBkECdGogGDYCACAHQQRqIQcgIkEEaiEiIBBBiAhqIRAgGEEBaiIGIRggBiA8Rw0ACyAGID5qIT4gBiBCaiFCC0EAIQcgH0GQBWohGCAIIQYCQANAIBgoAgAiCkE/Sw0GIAcgN2oiECAxTw0BIAYgH0GQB2ogCkECdGooAgAgKWo2AgAgGEEEaiEYIAZBBGohBiBAIAdBAWoiB0cNAAsgCEGAAmohCCAeQUBqIR4gKSA8aiEpIA8hECAEIQogCyEGIDdBQGsiNyAbTw0GDAELCyAQIDFB3NvMABDDIQALIAYgMkH828wAEMMhAAsgGCBCaiAaQYzczAAQwyEACyAYID5qIAtBrNzMABDDIQALIApBwABBzNvMABDDIQALIB9BADYCoBEgH0KAgICAwAA3ApgRIB9ByABqIB9BmBFqQYyHzgAQoiEgHygCTCEeIB8oAkghNyAyBEAgPyAyQYgIbEEEEPg6CwJAIClBAXYgKWwiBSApQQZ0IgYgBSAGSRsiCkGAEE0EQCAcIQYgICEiDAELIB9BoBFqQgA3AwAgH0IANwOYESAfQZAJaiIFIB9BmBFqIApBAWoQgxwgH0FAayAFQcyCzgAQnSEgHygCRCEGIB8oAkAhIiAcRQ0AICAgHEEEdEEEEPg6CyAfQThqICsgKRC5KQJAIB8oAjwiDyApTwRAIB8oAjghCCApBEAgKUECdCEHQQAhBSAIIRgDQCAYIAU2AgAgBUEBaiEFIBhBBGohGCAHQQRrIgcNAAsLIBUgGiAEIAsgFCAxIAggDyAiIAYgKSAbQYACIAoQjwYhByAfQQA2AqARIB9CgICAgMAANwKYESAfQTBqIB9BmBFqQYyHzgAQnSEgHygCNCEgIB8oAjAhQiAGBEAgIiAGQQR0QQQQ+DoLIB9BKGoQ/icgHygCLCEyIB8oAighPiAEIAsQgDEgH0EgaiArICkQuSkgHygCICEcAkAgHygCJCIORQ0AIA5BAnQiBEUNACAcQf8BIAT8CwALIBtFDQFBACEiQQAhCkEAISkCQANAIB9BkAlqQQBBhAj8CwAgH0Gj4P/7BzYClBECQAJAAkACQCApIC9HBEAgJCApQQJ0IhBqKAIAIhgEQCAiIBkgGSAiSxshBQNAIAUgGUYNBCAfQZAJaiAiIDhqLQAAELYpIAVBAWohBSAiQQFqISIgGEEBayIYDQALCyApDQEgFCEFIDFFDTsMBAsgLyAvQfzZzAAQwyEACyApQQFrIgQgMUkNASAEIDFBnNrMABDDIQALICIgGUH82swAEMMhAAsgFCAEQQJ0aiEFCwJAIBogBSgCACILSwRAIB8oApARBH0gH0GYEWogH0GQCWpBiAj8CgAAIB8gFSALQYgIbGoiBCgCgAggHygCmBlqNgKYGUEAIQUDQCAfQZgRaiIGIAVqIhggBCAFaigCACAYKAIAajYCACAFQQRqIgVBgAhHDQALIAYQoQcgBCoChAiTBUMAAAAACyFtIAdFDQFBACEGA0ACQAJAAn0CQCAGIA9HBEAgCCAGQQJ0aiIYKAIAIgQgGk8NAyAfKAKQEQ0BQwAAAAAMAgsgDyAPQdzazAAQwyEACyAfQZgRaiAfQZAJakGICPwKAAAgHyAVIARBiAhsaiIEKAKACCAfKAKYGWo2ApgZQQAhBQNAIB9BmBFqIj8gBWoiPCAEIAVqKAIAIDwoAgBqNgIAIAVBBGoiBUGACEcNAAsgPxChByAEKgKECJMLIm4gbV1FDQEgGCgCACELIG4hbQwBCyAEIBpB7NrMABDDIQALIAZBAWoiBiAHRw0ACwwBCyALIBpBrNrMABDDIQALICkgMUcEQCAQIBRqIAs2AgAgCyAOTw0CIBwgC0ECdGoiBCgCAEF/RgRAIAQgCjYCACAKQQFqIQoLIClBAWoiKSAbRw0BDAQLCyAxIDFBvNrMABDDIQALIAsgDkHM2swAEMMhAAsgKSAPQczYzAAQsDsACyAfQRhqEP4nIB8oAhwhGSAfKAIYITggCCAPEIAxIB9BADYCoBEgH0KAgICAwAA3ApgRIB9BEGogH0GYEWpBjIfOABCiISAfKAIUIQggHygCECEpIBoEQCAVIBpBiAhsQQQQ+DoLAkAgGyAhKAIEIgRNBEAgBCELDAELIAQgGyAEGyEFA0AgBSIGQQF0IQUgBiAbSQ0ACyAfQQhqICsgBhC4KSAfKAIMIgsgBE8EQCAfKAIIIgUgBCAhKAIAIARB7NjMABDVLCAhKAIEIQQgISALNgIEICEoAgAhBiAhIAU2AgAgKyAGIAQQ4DUMAQsgBCALQdzYzAAQsDsACwJAAkACQAJAAkACQAJAAkACQCAhAn8CQCAbICEoAgwiBEsEQCAEIBsgBBshBQNAIAUiBkEBdCEFIAYgG0kNAAsgHyArIAYQuSkgBCAfKAIEIhBLDQUgHygCACEPIARBAnQiBARAIA8gISgCCCAE/AoAAAsgISgCDCEEICEgEDYCDCAhKAIIICEgDzYCCCAEEIAxICEoAgQhCwwBCyAbRQRAQQAhGEEBDAILICEoAgghDyAEIRALIBtBAWshGiAhKAIAIRVBACEiICQhCiAUIQdBACEYQQAhBkEAIQUDQCAFIC9GDQIgBUEBaiEEIAooAgAgBmohBgJAIAUgGkcEQCAFIDFPDQcgBCAxTw0IIAcoAgAgB0EEaigCAEYNAQsgBSAxTw0IIAcoAgAiBSAOTw0JIAsgGE0NCiAVIBhqIBwgBUECdGooAgAiBToAACAQIBhNDQQgDyAYQQJ0aiAGNgIAIAVB/wFxIgUgIkH/AXEiBiAFIAZLGyEiIBhBAWohGEEAIQYLIApBBGohCiAHQQRqIQcgBCIFIBtHDQALICJB/wFxQQFqCzYCECAhIBg2AhQgHCAOEIAxICQgLxCAMSAUIDEQgDEgGQRAIDggGUECdEEEEPg6CyAgBEAgQiAgQQR0QQQQ+DoLIB4EQCA3IB5BiAhsQQQQ+DoLIDIEQCA+IDJBAnRBBBD4OgsgCARAICkgCEGICGxBBBD4OgsgH0GgGWokAAwICyAvIC9BjNnMABDDIQALIBggEEHs2cwAEMMhAAsgBCAQQfzYzAAQsDsACyAFIDFBnNnMABDDIQALIAVBAWogMUGs2cwAEMMhAAsgBSAxQbzZzAAQwyEACyAFIA5BzNnMABDDIQALIBggC0Hc2cwAEMMhAAsgKyA5IBMQ4DUMAQsCQCAhKAIEIgQgISgCFCIFQQFqIg9PBEAgBCEKDAELIAQgDyAEGyEFA0AgBSIGQQF0IQUgBiAPSQ0ACyAzQRBqICsgBhC4KSAzKAIUIgogBE8EQCAzKAIQIgUgBCAhKAIAIARBzN3MABDVLCAhKAIEIQQgISAKNgIEICEoAgAhBiAhIAU2AgAgKyAGIAQQ4DUgISgCFCIFQQFqIQ8MAQsgBCAKQbzdzAAQsDsACwJAAkACQCAPICEoAgwiBE0EQCAEIQ8MAQsgBCAPIAQbIQUDQCAFIgZBAXQhBSAGIA9JDQALIDNBCGogKyAGELkpIAQgMygCDCIPSw0BIDMoAgghBSAEQQJ0IgQEQCAFICEoAgggBPwKAAALICEoAgwhBCAhIA82AgwgISgCCCAhIAU2AgggBBCAMSAhKAIUIQUgISgCBCEKCyAhQQE2AhAgBSAKTw0BICEoAgAgBWpBADoAACAFIA9JBEAgISAFQQFqNgIUICEoAgggBUECdGogEDYCAAwDCyAFIA9B/N3MABDDIQALIAQgD0Hc3cwAELA7AAsgBSAKQezdzAAQwyEACyAzQeAIaiQAICsgLCAuEOA1QQAhDiBGQSRqIgQgEkHEntAAEJkVIEZBEGogBEHMgs4AEKohIEYoAhQhICBGKAIQIRkCQAJAID0gEiASID1LGyIEBEAgHUEMaiEUIBkhBQNAIA4gIEYNAiAFIBQvAQA7AQAgBUECaiEFIBRBEGohFCAEIA5BAWoiDkcNAAsLIBkhDyAgIQsgJyEbQQAhBkEAIQgjAEHgFmsiKSQAAkAgEkUEQCAbQQE2AhAMAQsgEkGAAU8EQCApQcgAaiIUQQBBhBb8CwAgKUGj4P/7BzYCzBYgKUHUFmoiGiAUQTIgEkGSBG5BAWoiBCAEQTJPGyIQEIQcIClBQGsgGkHMgs4AEJwhICkoAkAiGCEFICkoAkQiLiEEIwBBEGsiByQAIAdBBzYCDAJAIBAEQCASIBBuIQogBCAQTwRAIAUgEEGIFmxqIQ4gBSEEA0AgBEEAQYQW/AsAIARBhBZqQaPg//sHNgIAIARBiBZqIgQgDkcNAAsgEkEpayEOA0AgBiAQbiEEAkAgCEUNACAHQQxqEN0uIRUgECASTQRAIBUgCnAgBGohBAwBC0H83swAEOcrAAsgBCAOIARBKGogEkkbIgQgC0sEQCAEIAtBjN/MABCvOwALIAUgDyAEQQF0aiALIARrQSgQ4x4gBiASaiEGIAVBiBZqIQUgECAIQQFqIghHDQALIAdBEGokAAwCCyAQIARBrOrMABCwOwALQezezAAQ4isAC0EAIQojAEGQFmsiByQAIAdBBzYCBAJAIBAEQAJAIBAgEkEBdEEobmpB4wBqIgQgBCAQcCIFRwRAIAQgBWshDkEAIQQDQCAHQQhqIghBAEGEFvwLACAHQaPg//sHNgKMFiAHQQRqIRVBACEGAkACQAJAIBIiBUEoSwRAIBUQ3S4gEkEnayIGRQ0BIAZwIgYgC0sNAkEoIQULIAggDyAGQQF0aiALIAZrIAUQ4x4MAgtBrNjMABDnKwALIAYgC0G82MwAEK87AAsgBCAuTw0CIARBAWoiBUEAIAUgEEcbIApBAWohCiAYIARBiBZsaiIIIAcoAogWIAgoAoAWajYCgBZBACEEQQAhBgNAIAggBkECdGoiFSAHQQhqIARqKAIAIBUoAgBqNgIAIAZBAWohBiAEQQRqIgRBgBZHDQALIQQgCiAOSQ0ACwsgB0GQFmokAAwCCyAEIC5B3N7MABDDIQALQczezAAQ4isACyApQThqICsgEhC4KSApKAI8ITEgKSgCOCFCIBQgEEHABWwQoxUgKUEwaiAUQcyCzgAQmCEgKSgCNCEsICkoAjAhDiApQeAAakIANwMAIClB2ABqQgA3AwAgKUHQAGpCADcDACApQgA3A0ggGiAUIBBBB2pBA3YiBBCHHCApQShqIBpBzILOABCeISApKAIsITggKSgCKCEFIClBIGogKyAEIBJsELgpICkoAiQhHyApKAIgIS8gFCAQQcSe0AAQmRUgKUEYaiAUQcyCzgAQqiEgKSgCHCE5ICkoAhghN0EDQQogFygCFEEMSBshBwNAIA8hFUEAIQpBACEIIwBBgAFrIh4kAAJAIBBFDQACQAJAAkACQCAuBEBBASEIIBBBAUcNASASRQ0FA0AgCiAxRg0DIAogQmpBADoAACAKQQFqIgogEkcNAAsMBQsMNgsgLCAQQcAFbCIETwRAIBBBgBZsIgRFIARFckUEQCAOQQAgBPwLAAsgEEEHaiJDQQN2ITMgGEGAFmohBiAOIQQDQCAKIC5GBEAgLiAuQfzXzAAQwyEACwJ9IAYoAgAiCEGAAk8EQCAIsxDqEgwBCyAIQQJ0QcCH8wBqKgIACyFtIAogLEYNAyAEIG04AgAgBkGIFmohBiAEQQRqIQQgECAKQQFqIgpHDQALIBBBAnQhJCAQQfwVbCEUIBBBvwVsIQggGEH8FWohGkHABSEiA0AgIkEBayEiQQAhCiAOIQYgGiEEAkACQAJAA0AgCiAsRg0BIAogLkYNAiAGKgIAIW0gBCgCABC5LCFuICwgCCAKaiIcSwRAIAYgFGogbSBukzgCACAGQQRqIQYgBEGIFmohBCAQIApBAWoiCkYNBAwBCwsgHCAsQezXzAAQwyEACyAsICxBzNfMABDDIQALIC4gLkHc18wAEMMhAAsgFCAkayEUIAggEGshCCAaQQRrIRogIg0ACyA4BEAgOEEFdCEGIAUhCgNAIApCADcCACAKQRhqQgA3AgAgCkEQakIANwIAIApBCGpCADcCACAKQSBqIQogBkEgayIGDQALCyAfIBIgM2wiBE8EQCAEBEAgL0EAIAT8CwALIAsgEk8EQCASRQ0FIBUgEkEBdGohSCAQQXhxISIgEEEHcSI+QQJ0IRwgBSAzQQV0aiFQIAUgEEEDdiJRQQV0aiFSIBBBCEkhU0EAISRBACETAkADQCATIDFGBEAgMSAxQZzWzAAQwyEACwJAAkACQCAQIBUvAQBsIjIgLE0EQCA4IFFJDQEgEyBCaiE/Q5l2ln4hbSBTDQMgLCAyayE8IA4gMkECdGohQEEAIRRBACEaIAUhBANAIBpBA3QiBiA8SwRAIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakGc18wAEO8sAAsgPCAGa0EHTQ0DIARBIGogGkEBaiEaIB5B+ABqIEAgBkECdGoiBkEYaikCADcDACAeQfAAaiAGQRBqKQIANwMAIB5B6ABqIAZBCGopAgA3AwAgHiAGKQIANwNgQQAhCkEAIQYDQCAEIApqIkogHkHgAGogCmoqAgAgSioCAJI4AgAgbSAEIAZBvNfMABCiLioCACJuXgRAID8gBiAUajoAACBuIW0LIApBBGohCiAGQQFqIgZBCEcNAAsgFEEIaiEUIgQgUkcNAAsMAwsgHkEANgJwIB5BATYCZCAeQeDSzAA2AmAgHkIENwJoIB5B4ABqQazWzAAQ7ywACyAeQQA2AnAgHkEBNgJkIB5B4NLMADYCYCAeQgQ3AmggHkHgAGpBvNbMABDvLAALIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakGs18wAEO8sAAsCQAJAICIgMmoiBCAsTQRAID4gLCAEa0sNAQJAID4EQCAOIARBAnRqIQZBACEKIBwhFCAFIQQgIiEIA0AgCiAiaiIyQQN2IhogOE8NAiAEIAhBAnRBYHFqIjwgBioCACA8KgIAkjgCACBtIAUgGkEFdGoiGiAKQfzWzAAQoi4qAgBeBEAgGiAKQYzXzAAQoi4gPyAyOgAAKgIAIW0LIAZBBGohBiAEQQRqIQQgCkEBaiEKIAhBAWohCCAUQQRrIhQNAAsLQwAAWEEhbiATQdAPTw0DIBOzQylcjz2UQwAA+kSVQ7geRT+SQwAAWEGUIW4MAwsgGiA4QezWzAAQwyEACyAeQQA2AnAgHkEBNgJkIB5B4NLMADYCYCAeQgQ3AmggHkHgAGpBzNbMABDvLAALIB5BADYCcCAeQQE2AmQgHkHg0swANgJgIB5CBDcCaCAeQeAAakHc1swAEO8sAAsgE0EBaiETIBVBAmohFUEAIQoDQCAeQeAAaiAKaiBtOAIAIApBBGoiCkEgRw0ACyAeKgJ8IX0gHioCeCF+IB4qAnQhfyAeKgJwIYABIB4qAmwhgQEgHioCaCGCASAeKgJkIYMBIB4qAmAhhAFBACEKA0AgHkHgAGogCmogbjgCACAKQQRqIgpBIEcNAAsgHkEYaiIUIB5B+ABqIhopAgA3AwAgHkEQaiIyIB5B8ABqIj8pAgA3AwAgHkEIaiI8IB5B6ABqIkApAgA3AwAgHiAeKQJgNwMAIDMgOE0EQCBDQQhPBEAgJCEGIAUhCgNAIApBBGoiSioCACFtIApBCGoiTCoCACFuIApBDGoiVCoCACFvIApBEGoiVSoCACFwIApBFGoiVioCACFxIApBGGoiVyoCACFyIAoqAgAhcyAeIApBHGoiWCoCACB9kzgCPCAeIHIgfpM4AjggHiBxIH+TOAI0IB4gcCCAAZM4AjAgHiBvIIEBkzgCLCAeIG4gggGTOAIoIB4gbSCDAZM4AiQgHiBzIIQBkzgCICAaIBQpAwA3AwAgPyAyKQMANwMAIEAgPCkDADcDACAeIB4pAwA3A2AgHkEgaiIEQQBB7N/MABCiLioCACFtIB5B4ABqIghBAEH838wAEKIuKgIAIW4gBEEBQYzgzAAQoi4qAgAhbyAIQQFBnODMABCiLioCACFwIARBAkGs4MwAEKIuKgIAIXEgCEECQbzgzAAQoi4qAgAhciAEQQNBzODMABCiLioCACFzIAhBA0Hc4MwAEKIuKgIAIXQgBEEEQezgzAAQoi4qAgAhdSAIQQRB/ODMABCiLioCACF2IARBBUGM4cwAEKIuKgIAIXcgCEEFQZzhzAAQoi4qAgAheCAEQQZBrOHMABCiLioCACF5IAhBBkG84cwAEKIuKgIAIXogBEEHQczhzAAQoi4qAgAheyAIQQdB3OHMABCiLiFLIB4geSB6YEEGdDYCWCAeIHcgeGBBBXQ2AlQgHiB1IHZgQQR0NgJQIB4gcyB0YEEDdDYCTCAeIHEgcmBBAnQ2AkggHiBvIHBgQQF0NgJEIB4gbSBuYDYCQCAeIHsgSyoCAGBBB3Q2AlwgHkFAaxDMKyFLIAYgH08NBCAGIC9qIk0gTS0AACBLcjoAACAaIBQpAwA3AwAgPyAyKQMANwMAIEAgPCkDADcDACAeIB4pAwA3A2AgBEEAQezhzAAQoi4qAgAhbSAIQQBB/OHMABCiLioCACFuIARBAUGM4swAEKIuKgIAIW8gCEEBQZzizAAQoi4qAgAhcCAEQQJBrOLMABCiLioCACFxIAhBAkG84swAEKIuKgIAIXIgBEEDQczizAAQoi4qAgAhcyAIQQNB3OLMABCiLioCACF0IARBBEHs4swAEKIuKgIAIXUgCEEEQfzizAAQoi4qAgAhdiAEQQVBjOPMABCiLioCACF3IAhBBUGc48wAEKIuKgIAIXggBEEGQazjzAAQoi4qAgAheSAIQQZBvOPMABCiLioCACF6IARBB0HM48wAEKIuKgIAIXsgCEEHQdzjzAAQoi4qAgAhfCBXIHkgeiB5IHpdGzgCACBWIHcgeCB3IHhdGzgCACBVIHUgdiB1IHZdGzgCACBUIHMgdCBzIHRdGzgCACBMIHEgciBxIHJdGzgCACBKIG8gcCBvIHBdGzgCACAKIG0gbiBtIG5dGzgCACBYIHsgfCB7IHxdGzgCACAGQQFqIQYgCkEgaiIKIFBHDQALCyAkIDNqISQgFSBIRw0BDAgLCyAzIDhBzN/MABCwOwALIAYgH0Hc38wAEMMhAAsgEiALQczVzAAQsDsACyAEIB9BvNXMABCwOwALIAQgLEGs1cwAELA7AAsgMSAxQZzYzAAQwyEACyAsICxBjNjMABDDIQALAkAgMSASQQFrIgZLBEAgBg0BQQEhCAwCCyAGIDFB3NXMABDDIQALIDMgEkECayIUbCEEIAYgQmotAAAhCiAUIQZBASEIAkACQANAIAQgCkEDdkEfcWoiGiAfTw0BIBogL2otAAAgCkEHcXZBAXEEQCAGIDFPDQMgCCAKQf8BcSAGIEJqLQAAIgpHaiEICyAUIDFJBEAgBiBCaiAKOgAAIAQgM2shBCAGQQFrIgZBf0YNBAwBCwsgBiAxQYzWzAAQwyEACyAKQfgBcUEDdiAEaiAfQezVzAAQwyEACyAGIDFB/NXMABDDIQALIB5BgAFqJAAgDyEEAkACQAJAIEIgMSASIDcgOSAQEJYSIhAgLk0EQCAQBEAgGCAQQYgWbGohCiAYIQYDQCAGQQBBhBb8CwAgBkGEFmpBo+D/+wc2AgAgBkGIFmoiBiAKRw0ACwsCQCASBEBBACEGA0AgBiAxRg0EIC4gBiBCai0AACIKTQ0FIAYgC0YNAiAYIApBiBZsaiAELwEAELcpIARBAmohBCASIAZBAWoiBkcNAAsLDAQLIAsgC0G838wAEMMhAAsgECAuQazqzAAQsDsACyAxIDFBnN/MABDDIQALIAogLkGs38wAEMMhAAsgB0EBayIHDQALICwEQCAOICxBAnRBBBD4OgsgOARAIAUgOEEFdEEEEPg6CyArIC8gHxDgNSA5BEAgNyA5QQF0QQIQ+DoLIC4EQCAYIC5BiBZsQQQQ+DoLQQAhCkEAIS9BACEaQQAhP0EAITwjAEGgNWsiEyQAIBNBiAFqICsgCCIVELkpIBMoAowBITkgEygCiAEhFCATQYABaiArIAgQuSkgEygChAEhNyATKAKAASEsIBNBmB9qIgVBAEGEFvwLACATQaPg//sHNgKcNSATQZAJaiIEIAUgCEEEdEHwB2pBBnYiCBCEHCATQfgAaiAEQcyCzgAQnCEgEygCfCEkIBMoAnghIiATQfAAaiArIAgQuSkgEygCdCEOIBMoAnAhByAFQQBBhBb8CwAgE0Gj4P/7BzYCnDUgBCAFQcAAIBUgFUHAAE8bEIQcIBNB6ABqIARBzILOABCcISATKAJsIT4gEygCaCFAIBNBoB9qQgA3AwAgE0IANwOYHyAEIAVBgRAQgxwgE0HgAGogBEHMgs4AEJ0hIBMoAmQhLiATKAJgIR9BACIFRQRAIBNBkAFqQQBBgAL8CwALIBNBkANqQQBBgAL8CwAgE0GQBWpBAEGAAvwLACATQZAHakEAQYAC/AsAIBIEQCASQQFrIQYDQAJAAkACQCAKIDdJBEAgLCAKQQJ0aiIEIAQoAgBBAWo2AgAgBUEBaiEEIAUgBkcNAQwCCyAKIDdB/NzMABDDIQALAkAgBSAxSQRAIAQgMU8NASAFIEJqIgUtAAAgBUEBai0AAEcNAgwDCyAFIDFBjN3MABDDIQALDDkLIApBAWohCgsgBCIFIBJHDQALCyAPITMgCyEeAkAgFUUEQCAOIQQgByEYDAELIBQhECAVITggCCEPQQAhHAJAAkACQANAQcAAIBUgHGsiBCAEQcAATxshC0EBQcAAIDggOEHAAE8bIgQgBEEBTRshSEEAITICQAJAAkACQAJAAkACQANAIDIgPkYNASBAIDJBiBZsaiIEQQBBgBb8CwAgBEKAgICAsIT8v/8ANwKAFiAcIDJqIgUgN08NAiAsIAVBAnRqKAIAIgYEQCAaIB4gGiAeSRshBSAzIBpBAXRqIQoDQCAFIB5GDQUgBCAKLwEAELcpIAVBAWohBSAKQQJqIQogGkEBaiEaIAZBAWsiBg0ACwsgBCAEEKAHOAKEFiAyQQJ0IgQgE0GQBWoiBWogMjYCACATQZADaiIGIARqIDI2AgAgBCATQZABaiIEakEBNgIAIDJBAWoiCiEyIAogSEcNAAsgCCBAID4gBEHAACAFQcAAIAZBwAAgHyAuIAsgC0HAAEGAEBCNBiJDID9qIgVPDQYgCCAFIAgbIQoDQCAKIgRBAXQhCiAEIAVJDQALIBNBmB9qIgVBAEGEFvwLACATQaPg//sHNgKcNSATQZAJaiIGIAUgBBCEHCATQdgAaiAGQcyCzgAQnCEgCCATKAJcIgVLDQMgCCAkSw0EIBMoAlghBgJAIAhFDQAgCEGIFmwiCkUNACAGICIgCvwKAAALICRFDQUgIiAkQYgWbEEEEPg6DAULID4gPkHM3MwAEMMhAAsgNyAcIBwgN0kbIDdB3NzMABDDIQALIBogHkHs3MwAEMMhAAsgCCAFQYzbzAAQsDsACyAIICRBnNvMABCwOwALIAUhJCAGISIgBCEICwJAIDwgQ2oiBCAPTQRAIA4hBCAHIRggDyELDAELIA8gBCAPGyEFA0AgBSILQQF0IQUgBCALSw0ACyATQdAAaiArIAsQuSkCQCATKAJUIgQgD08EQCAOIA9JDQEgEygCUCEYIA9BAnQiBQRAIBggByAF/AoAAAsgByAOEIAxDAILIA8gBEGs28wAELA7AAsgDyAOQbzbzAAQsDsACyBDBEBBACEFIAQgPGsiBkEAIAQgBk8bIQcgJCA/ayIGQQAgBiAkTRshDiAYIDxBAnRqIQ8gIiA/QYgWbGohMiATQZADaiEKA0AgBUHAAEYNOCAKKAIAIgYgPk8NAyAFIA5GDQQgMiBAIAZBiBZsakGIFvwKAAAgBkHAAE8NOSAFIAdGDT0gDyATQZABaiAGQQJ0aigCADYCACAKKAIAIgZBwABPDTogE0GQB2ogBkECdGogBTYCACAKQQRqIQogD0EEaiEPIDJBiBZqITIgBUEBaiIFIENHDQALIAUgPGohPCAFID9qIT8LQQAhCiATQZAFaiEFIBAhBgJAA0AgBSgCACIHQT9LDQUgCiAcaiIPIDlPDQEgBiATQZAHaiAHQQJ0aigCACAvajYCACAFQQRqIQUgBkEEaiEGIEggCkEBaiIKRw0ACyAQQYACaiEQIDhBQGohOCAvIENqIS8gCyEPIBghByAEIQ4gHEFAayIcIBVPDQUMAQsLIA8gOUHc28wAEMMhAAsgBiA+QfzbzAAQwyEACyAFID9qICRBjNzMABDDIQALIAdBwABBzNvMABDDIQALIBNBADYCoB8gE0KAgICAwAA3ApgfIBNByABqIBNBmB9qQYyHzgAQnCEgEygCTCE4IBMoAkghPyA+BEAgQCA+QYgWbEEEEPg6CwJAIC9BAXYgL2wiBSAvQQZ0IgYgBSAGSRsiC0GAEE0EQCAuIQYgHyEPDAELIBNBoB9qQgA3AwAgE0IANwOYHyATQZAJaiIFIBNBmB9qIAtBAWoQgxwgE0FAayAFQcyCzgAQnSEgEygCRCEGIBMoAkAhDyAuRQ0AIB8gLkEEdEEEEPg6CyATQThqICsgLxC5KQJAIBMoAjwiCCAvTwRAIBMoAjghByAvBEAgL0ECdCEaQQAhBSAHIQoDQCAKIAU2AgAgBUEBaiEFIApBBGohCiAaQQRrIhoNAAsLICIgJCAYIAQgFCA5IAcgCCAPIAYgLyAVQYACIAsQjQYhCyATQQA2AqAfIBNCgICAgMAANwKYHyATQTBqIBNBmB9qQYyHzgAQnSEgEygCNCEuIBMoAjAhPiAGBEAgDyAGQQR0QQQQ+DoLIBNBKGoQ/icgEygCLCEfIBMoAighPCAYIAQQgDEgE0EgaiArIC8QuSkgEygCICEYAkAgEygCJCIQRQ0AIBBBAnQiBEUNACAYQf8BIAT8CwALIBVFDQFBACEPQQAhDkEAIS8CQANAIBNBkAlqQQBBhBb8CwAgE0Gj4P/7BzYClB8CQAJAAkACQCAvIDdHBEAgLCAvQQJ0IhxqKAIAIhoEQCAPIB4gDyAeSRshBSAzIA9BAXRqIQoDQCAFIB5GDQQgE0GQCWogCi8BABC3KSAFQQFqIQUgCkECaiEKIA9BAWohDyAaQQFrIhoNAAsLIC8NASAUIQUgOUUNPQwECyA3IDdB/NnMABDDIQALIC9BAWsiBCA5SQ0BIAQgOUGc2swAEMMhAAsgDyAeQfzazAAQwyEACyAUIARBAnRqIQULAkAgJCAFKAIAIgpLBEAgEygCkB8EfSATQZgfaiATQZAJakGIFvwKAAAgEyAiIApBiBZsaiIEKAKAFiATKAKYNWo2Apg1QQAhBQNAIBNBmB9qIgYgBWoiGiAEIAVqKAIAIBooAgBqNgIAIAVBBGoiBUGAFkcNAAsgBhCgByAEKgKEFpMFQwAAAAALIW0gC0UNAUEAIQYDQAJAAkACfQJAIAYgCEcEQCAHIAZBAnRqIhooAgAiBCAkTw0DIBMoApAfDQFDAAAAAAwCCyAIIAhB3NrMABDDIQALIBNBmB9qIBNBkAlqQYgW/AoAACATICIgBEGIFmxqIgQoAoAWIBMoApg1ajYCmDVBACEFA0AgE0GYH2oiMiAFaiJAIAQgBWooAgAgQCgCAGo2AgAgBUEEaiIFQYAWRw0ACyAyEKAHIAQqAoQWkwsibiBtXUUNASAaKAIAIQogbiFtDAELIAQgJEHs2swAEMMhAAsgBkEBaiIGIAtHDQALDAELIAogJEGs2swAEMMhAAsgLyA5RwRAIBQgHGogCjYCACAKIBBPDQIgGCAKQQJ0aiIEKAIAQX9GBEAgBCAONgIAIA5BAWohDgsgL0EBaiIvIBVHDQEMBAsLIDkgOUG82swAEMMhAAsgCiAQQczazAAQwyEACyAvIAhBzNjMABCwOwALIBNBGGoQ/icgEygCHCEPIBMoAhghDiAHIAgQgDEgE0EANgKgHyATQoCAgIDAADcCmB8gE0EQaiATQZgfakGMh84AEJwhIBMoAhQhCCATKAIQIR4gJARAICIgJEGIFmxBBBD4OgsCQCAVIBsoAgQiBE0EQCAEIRwMAQsgBCAVIAQbIQUDQCAFIgZBAXQhBSAGIBVJDQALIBNBCGogKyAGELgpIBMoAgwiHCAETwRAIBMoAggiBSAEIBsoAgAgBEHs2MwAENUsIBsoAgQhBCAbIBw2AgQgGygCACEGIBsgBTYCACArIAYgBBDgNQwBCyAEIBxB3NjMABCwOwALAkACQAJAAkACQAJAAkACQCAbAn8CQCAVIBsoAgwiBEsEQCAEIBUgBBshBQNAIAUiBkEBdCEFIAYgFUkNAAsgEyArIAYQuSkgBCATKAIEIgdLDQUgEygCACEiIARBAnQiBARAICIgGygCCCAE/AoAAAsgGygCDCEEIBsgBzYCDCAbKAIIIBsgIjYCCCAEEIAxIBsoAgQhHAwBCyAVRQRAQQAhCkEBDAILIBsoAgghIiAEIQcLIBVBAWshJCAbKAIAITNBACEyICwhCyAUIRpBACEKQQAhBkEAIQUDQCAFIDdGDQIgBUEBaiEEIAsoAgAgBmohBgJAIAUgJEcEQCAFIDlPDQcgBCA5Tw1DIBooAgAgGkEEaigCAEYNAQsgBSA5Tw0HIBooAgAiBSAQTw0IIAogHE8NCSAKIDNqIBggBUECdGooAgAiBToAACAHIApNDQQgIiAKQQJ0aiAGNgIAIAVB/wFxIgUgMkH/AXEiBiAFIAZLGyEyIApBAWohCkEAIQYLIAtBBGohCyAaQQRqIRogBCIFIBVHDQALIDJB/wFxQQFqCzYCECAbIAo2AhQgGCAQEIAxICwgNxCAMSAUIDkQgDEgDwRAIA4gD0ECdEEEEPg6CyAuBEAgPiAuQQR0QQQQ+DoLIDgEQCA/IDhBiBZsQQQQ+DoLIB8EQCA8IB9BAnRBBBD4OgsgCARAIB4gCEGIFmxBBBD4OgsgE0GgNWokAAwHCyA3IDdBjNnMABDDIQALIAogB0Hs2cwAEMMhAAsgBCAHQfzYzAAQsDsACyAFIDlBnNnMABDDIQALIAUgOUG82cwAEMMhAAsgBSAQQczZzAAQwyEACyAKIBxB3NnMABDDIQALICsgQiAxEOA1DAELAkAgGygCBCIEIBsoAhQiBUEBaiIQTwRAIAQhBwwBCyAEIBAgBBshBQNAIAUiBkEBdCEFIAYgEEkNAAsgKUEQaiArIAYQuCkgKSgCFCIHIARPBEAgKSgCECIFIAQgGygCACAEQczdzAAQ1SwgGygCBCEEIBsgBzYCBCAbKAIAIQYgGyAFNgIAICsgBiAEEOA1IBsoAhQiBUEBaiEQDAELIAQgB0G83cwAELA7AAsCQAJAAkAgECAbKAIMIgRNBEAgBCEQDAELIAQgECAEGyEFA0AgBSIGQQF0IQUgBiAQSQ0ACyApQQhqICsgBhC5KSAEICkoAgwiEEsNASApKAIIIQUgBEECdCIEBEAgBSAbKAIIIAT8CgAACyAbKAIMIQQgGyAQNgIMIBsoAgggGyAFNgIIIAQQgDEgGygCFCEFIBsoAgQhBwsgG0EBNgIQIAUgB08NASAbKAIAIAVqQQA6AAAgBSAQSQRAIBsgBUEBajYCFCAbKAIIIAVBAnRqIBI2AgAMAwsgBSAQQfzdzAAQwyEACyAEIBBB3N3MABCwOwALIAUgB0Hs3cwAEMMhAAsgKUHgFmokACAgBEAgGSAgQQF0QQIQ+DoLQQAhBSBGQSRqIgQgEkHEntAAEJkVIEZBCGogBEHMgs4AEKohIEYoAgwhHiBGKAIIITgCQAJAIBIEQCAdQQ5qIQ5BACEUA0AgFCA9Rg0CAkAgDkEKaygCAEH///8PcUUNACAOQQJrLwEAQf8ATQ0AIAUgHk8NBCA4IAVBAXRqIA4vAQBB/wdxOwEAIAVBAWohBQsgDkEQaiEOIBIgFEEBaiIURw0ACwsgOCEPIB4hGCAtIRtBACEGQQAhCCMAQeARayIpJAACQCAFIgtFBEAgG0EBNgIQDAELIAtBgAFPBEAgKUHIAGoiFEEAQYQR/AsAIClBo+D/+wc2AswRIClB1BFqIhogFEEyIAtBoARuQQFqIgQgBEEyTxsiEBCCHCApQUBrIBpBzILOABCgISApKAJAIhUhBSApKAJEIi4hBCMAQRBrIgckACAHQQc2AgwCQCAQBEAgCyAQbiEKIAQgEE8EQCAFIBBBiBFsaiEOIAUhBANAIARBAEGEEfwLACAEQYQRakGj4P/7BzYCACAEQYgRaiIEIA5HDQALIAtBKWshDgNAIAYgEG4hBAJAIAhFDQAgB0EMahDdLiEZIAsgEE8EQCAZIApwIARqIQQMAQtB/N7MABDnKwALIAQgDiAEQShqIAtJGyIEIBhLBEAgBCAYQYzfzAAQrzsACyAFIA8gBEEBdGogGCAEa0EoEOIeIAYgC2ohBiAFQYgRaiEFIBAgCEEBaiIIRw0ACyAHQRBqJAAMAgsgECAEQazqzAAQsDsAC0Hs3swAEOIrAAtBACEKIwBBkBFrIgckACAHQQc2AgQCQCAQBEACQCAQIAtBAXRBKG5qQeMAaiIEIAQgEHAiBUcEQCAEIAVrIQ5BACEEA0AgB0EIaiIIQQBBhBH8CwAgB0Gj4P/7BzYCjBEgB0EEaiEZQQAhBgJAAkACQCALIgVBKEsEQCAZEN0uIAtBJ2siBkUNASAGcCIGIBhLDQJBKCEFCyAIIA8gBkEBdGogGCAGayAFEOIeDAILQazYzAAQ5ysACyAGIBhBvNjMABCvOwALIAQgLk8NAiAEQQFqIgVBACAFIBBHGyAKQQFqIQogFSAEQYgRbGoiCCAHKAKIESAIKAKAEWo2AoARQQAhBEEAIQYDQCAIIAZBAnRqIhkgB0EIaiAEaigCACAZKAIAajYCACAGQQFqIQYgBEEEaiIEQYARRw0ACyEEIAogDkkNAAsLIAdBkBFqJAAMAgsgBCAuQdzezAAQwyEAC0HM3swAEOIrAAsgKUE4aiArIAsQuCkgKSgCPCExICkoAjghQiAUIBBBoARsEKMVIClBMGogFEHMgs4AEJghICkoAjQhLCApKAIwIQ4gKUHgAGpCADcDACApQdgAakIANwMAIClB0ABqQgA3AwAgKUIANwNIIBogFCAQQQdqQQN2IgQQhxwgKUEoaiAaQcyCzgAQniEgKSgCLCEfICkoAighBSApQSBqICsgBCALbBC4KSApKAIkITMgKSgCICE5IBQgEEHEntAAEJkVIClBGGogFEHMgs4AEKohICkoAhwhMiApKAIYIT5BA0EKIBcoAhRBDEgbIQcDQCAPISJBACEKQQAhCCMAQYABayIgJAACQCAQRQ0AAkACQAJAAkAgLgRAQQEhCCAQQQFHDQEgC0UNBQNAIAogMUYNAyAKIEJqQQA6AAAgCkEBaiIKIAtHDQALDAULDDgLICwgEEGgBGwiBE8EQCAQQYARbCIERSAERXJFBEAgDkEAIAT8CwALIBBBB2oiSEEDdiETIBVBgBFqIQYgDiEEA0AgCiAuRgRAIC4gLkH818wAEMMhAAsCfSAGKAIAIghBgAJPBEAgCLMQ6hIMAQsgCEECdEHAh/MAaioCAAshbSAKICxGDQMgBCBtOAIAIAZBiBFqIQYgBEEEaiEEIBAgCkEBaiIKRw0ACyAQQQJ0ISQgEEH8EGwhFCAQQZ8EbCEIIBVB/BBqIRpBoAQhGQNAIBlBAWshGUEAIQogDiEGIBohBAJAAkACQANAIAogLEYNASAKIC5GDQIgBioCACFtIAQoAgAQuSwhbiAsIAggCmoiHEsEQCAGIBRqIG0gbpM4AgAgBkEEaiEGIARBiBFqIQQgECAKQQFqIgpGDQQMAQsLIBwgLEHs18wAEMMhAAsgLCAsQczXzAAQwyEACyAuIC5B3NfMABDDIQALIBQgJGshFCAIIBBrIQggGkEEayEaIBkNAAsgHwRAIB9BBXQhBiAFIQoDQCAKQgA3AgAgCkEYakIANwIAIApBEGpCADcCACAKQQhqQgA3AgAgCkEgaiEKIAZBIGsiBg0ACwsgMyALIBNsIgRPBEAgBARAIDlBACAE/AsACyALIBhNBEAgC0UNBSAiIAtBAXRqIVAgEEF4cSEZIBBBB3EiP0ECdCEcIAUgE0EFdGohUSAFIBBBA3YiUkEFdGohUyAQQQhJIUpBACEkQQAhLwJAA0AgLyAxRgRAIDEgMUGc1swAEMMhAAsCQAJAAkAgECAiLwEAbCI3ICxNBEAgHyBSSQ0BIC8gQmohPEOZdpZ+IW0gSg0DICwgN2shQCAOIDdBAnRqIUNBACEUQQAhGiAFIQQDQCAaQQN0IgYgQEsEQCAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpBnNfMABDvLAALIEAgBmtBB00NAyAEQSBqIBpBAWohGiAgQfgAaiBDIAZBAnRqIgZBGGopAgA3AwAgIEHwAGogBkEQaikCADcDACAgQegAaiAGQQhqKQIANwMAICAgBikCADcDYEEAIQpBACEGA0AgBCAKaiJMICBB4ABqIApqKgIAIEwqAgCSOAIAIG0gBCAGQbzXzAAQoi4qAgAibl4EQCA8IAYgFGo6AAAgbiFtCyAKQQRqIQogBkEBaiIGQQhHDQALIBRBCGohFCIEIFNHDQALDAMLICBBADYCcCAgQQE2AmQgIEHg0swANgJgICBCBDcCaCAgQeAAakGs1swAEO8sAAsgIEEANgJwICBBATYCZCAgQeDSzAA2AmAgIEIENwJoICBB4ABqQbzWzAAQ7ywACyAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpBrNfMABDvLAALAkACQCAZIDdqIgQgLE0EQCA/ICwgBGtLDQECQCA/BEAgDiAEQQJ0aiEGQQAhCiAcIRQgBSEEIBkhCANAIAogGWoiN0EDdiIaIB9PDQIgBCAIQQJ0QWBxaiJAIAYqAgAgQCoCAJI4AgAgbSAFIBpBBXRqIhogCkH81swAEKIuKgIAXgRAIBogCkGM18wAEKIuIDwgNzoAACoCACFtCyAGQQRqIQYgBEEEaiEEIApBAWohCiAIQQFqIQggFEEEayIUDQALC0OamWlBIW4gL0HQD08NAyAvs0MpXI89lEMAAPpElUO4HkU/kkOamWlBlCFuDAMLIBogH0Hs1swAEMMhAAsgIEEANgJwICBBATYCZCAgQeDSzAA2AmAgIEIENwJoICBB4ABqQczWzAAQ7ywACyAgQQA2AnAgIEEBNgJkICBB4NLMADYCYCAgQgQ3AmggIEHgAGpB3NbMABDvLAALIC9BAWohLyAiQQJqISJBACEKA0AgIEHgAGogCmogbTgCACAKQQRqIgpBIEcNAAsgICoCfCF9ICAqAnghfiAgKgJ0IX8gICoCcCGAASAgKgJsIYEBICAqAmghggEgICoCZCGDASAgKgJgIYQBQQAhCgNAICBB4ABqIApqIG44AgAgCkEEaiIKQSBHDQALICBBGGoiFCAgQfgAaiIaKQIANwMAICBBEGoiNyAgQfAAaiI8KQIANwMAICBBCGoiQCAgQegAaiJDKQIANwMAICAgICkCYDcDACATIB9NBEAgSEEITwRAICQhBiAFIQoDQCAKQQRqIkwqAgAhbSAKQQhqIlQqAgAhbiAKQQxqIlUqAgAhbyAKQRBqIlYqAgAhcCAKQRRqIlcqAgAhcSAKQRhqIlgqAgAhciAKKgIAIXMgICAKQRxqIksqAgAgfZM4AjwgICByIH6TOAI4ICAgcSB/kzgCNCAgIHAggAGTOAIwICAgbyCBAZM4AiwgICBuIIIBkzgCKCAgIG0ggwGTOAIkICAgcyCEAZM4AiAgGiAUKQMANwMAIDwgNykDADcDACBDIEApAwA3AwAgICAgKQMANwNgICBBIGoiBEEAQezfzAAQoi4qAgAhbSAgQeAAaiIIQQBB/N/MABCiLioCACFuIARBAUGM4MwAEKIuKgIAIW8gCEEBQZzgzAAQoi4qAgAhcCAEQQJBrODMABCiLioCACFxIAhBAkG84MwAEKIuKgIAIXIgBEEDQczgzAAQoi4qAgAhcyAIQQNB3ODMABCiLioCACF0IARBBEHs4MwAEKIuKgIAIXUgCEEEQfzgzAAQoi4qAgAhdiAEQQVBjOHMABCiLioCACF3IAhBBUGc4cwAEKIuKgIAIXggBEEGQazhzAAQoi4qAgAheSAIQQZBvOHMABCiLioCACF6IARBB0HM4cwAEKIuKgIAIXsgCEEHQdzhzAAQoi4hTSAgIHkgemBBBnQ2AlggICB3IHhgQQV0NgJUICAgdSB2YEEEdDYCUCAgIHMgdGBBA3Q2AkwgICBxIHJgQQJ0NgJIICAgbyBwYEEBdDYCRCAgIG0gbmA2AkAgICB7IE0qAgBgQQd0NgJcICBBQGsQzCshTSAGIDNPDQQgBiA5aiJfIF8tAAAgTXI6AAAgGiAUKQMANwMAIDwgNykDADcDACBDIEApAwA3AwAgICAgKQMANwNgIARBAEHs4cwAEKIuKgIAIW0gCEEAQfzhzAAQoi4qAgAhbiAEQQFBjOLMABCiLioCACFvIAhBAUGc4swAEKIuKgIAIXAgBEECQazizAAQoi4qAgAhcSAIQQJBvOLMABCiLioCACFyIARBA0HM4swAEKIuKgIAIXMgCEEDQdzizAAQoi4qAgAhdCAEQQRB7OLMABCiLioCACF1IAhBBEH84swAEKIuKgIAIXYgBEEFQYzjzAAQoi4qAgAhdyAIQQVBnOPMABCiLioCACF4IARBBkGs48wAEKIuKgIAIXkgCEEGQbzjzAAQoi4qAgAheiAEQQdBzOPMABCiLioCACF7IAhBB0Hc48wAEKIuKgIAIXwgWCB5IHogeSB6XRs4AgAgVyB3IHggdyB4XRs4AgAgViB1IHYgdSB2XRs4AgAgVSBzIHQgcyB0XRs4AgAgVCBxIHIgcSByXRs4AgAgTCBvIHAgbyBwXRs4AgAgCiBtIG4gbSBuXRs4AgAgSyB7IHwgeyB8XRs4AgAgBkEBaiEGIApBIGoiCiBRRw0ACwsgEyAkaiEkICIgUEcNAQwICwsgEyAfQczfzAAQsDsACyAGIDNB3N/MABDDIQALIAsgGEHM1cwAELA7AAsgBCAzQbzVzAAQsDsACyAEICxBrNXMABCwOwALIDEgMUGc2MwAEMMhAAsgLCAsQYzYzAAQwyEACwJAIDEgC0EBayIGSwRAIAYNAUEBIQgMAgsgBiAxQdzVzAAQwyEACyATIAtBAmsiFGwhBCAGIEJqLQAAIQogFCEGQQEhCAJAAkADQCAEIApBA3ZBH3FqIhogM08NASAaIDlqLQAAIApBB3F2QQFxBEAgBiAxTw0DIAggCkH/AXEgBiBCai0AACIKR2ohCAsgFCAxSQRAIAYgQmogCjoAACAEIBNrIQQgBkEBayIGQX9GDQQMAQsLIAYgMUGM1swAEMMhAAsgCkH4AXFBA3YgBGogM0Hs1cwAEMMhAAsgBiAxQfzVzAAQwyEACyAgQYABaiQAIA8hBAJAAkACQCBCIDEgCyA+IDIgEBCWEiIQIC5NBEAgEARAIBUgEEGIEWxqIQogFSEGA0AgBkEAQYQR/AsAIAZBhBFqQaPg//sHNgIAIAZBiBFqIgYgCkcNAAsLAkAgCwRAQQAhBgNAIAYgMUYNBCAuIAYgQmotAAAiCk0NBSAGIBhGDQIgFSAKQYgRbGogBC8BABC1KSAEQQJqIQQgCyAGQQFqIgZHDQALCwwECyAYIBhBvN/MABDDIQALIBAgLkGs6swAELA7AAsgMSAxQZzfzAAQwyEACyAKIC5BrN/MABDDIQALIAdBAWsiBw0ACyAsBEAgDiAsQQJ0QQQQ+DoLIB8EQCAFIB9BBXRBBBD4OgsgKyA5IDMQ4DUgMgRAID4gMkEBdEECEPg6CyAuBEAgFSAuQYgRbEEEEPg6C0EAIQpBACEvQQAhGkEAIT9BACE8IwBBoCtrIhMkACATQYgBaiArIAgiFRC5KSATKAKMASE5IBMoAogBIRQgE0GAAWogKyAIELkpIBMoAoQBITcgEygCgAEhICATQZgaaiIFQQBBhBH8CwAgE0Gj4P/7BzYCnCsgE0GQCWoiBCAFIAhBBHRB8AdqQQZ2IggQghwgE0H4AGogBEHMgs4AEKAhIBMoAnwhIiATKAJ4IRkgE0HwAGogKyAIELkpIBMoAnQhDiATKAJwIQcgBUEAQYQR/AsAIBNBo+D/+wc2ApwrIAQgBUHAACAVIBVBwABPGxCCHCATQegAaiAEQcyCzgAQoCEgEygCbCE+IBMoAmghQCATQaAaakIANwMAIBNCADcDmBogBCAFQYEQEIMcIBNB4ABqIARBzILOABCdISATKAJkISwgEygCYCEfQQAiBUUEQCATQZABakEAQYAC/AsACyATQZADakEAQYAC/AsAIBNBkAVqQQBBgAL8CwAgE0GQB2pBAEGAAvwLACALBEAgC0EBayEGA0ACQAJAAkAgCiA3SQRAICAgCkECdGoiBCAEKAIAQQFqNgIAIAVBAWohBCAFIAZHDQEMAgsgCiA3QfzczAAQwyEACwJAIAUgMUkEQCAEIDFPDQEgBSBCaiIFLQAAIAVBAWotAABHDQIMAwsgBSAxQYzdzAAQwyEACww7CyAKQQFqIQoLIAQiBSALRw0ACwsgDyEzIBghHAJAIBVFBEAgDiEEIAchGAwBCyAUIRAgFSEuIAghD0EAISQCQAJAAkADQEHAACAVICRrIgQgBEHAAE8bIQtBAUHAACAuIC5BwABPGyIEIARBAU0bIUhBACEyAkACQAJAAkACQAJAAkADQCAyID5GDQEgQCAyQYgRbGoiBEEAQYAR/AsAIARCgICAgLCE/L//ADcCgBEgJCAyaiIFIDdPDQIgICAFQQJ0aigCACIGBEAgGiAcIBogHEkbIQUgMyAaQQF0aiEKA0AgBSAcRg0FIAQgCi8BABC1KSAFQQFqIQUgCkECaiEKIBpBAWohGiAGQQFrIgYNAAsLIAQgBBCiBzgChBEgMkECdCIEIBNBkAVqIgVqIDI2AgAgE0GQA2oiBiAEaiAyNgIAIAQgE0GQAWoiBGpBATYCACAyQQFqIgohMiAKIEhHDQALIAggQCA+IARBwAAgBUHAACAGQcAAIB8gLCALIAtBwABBgBAQjgYiQyA/aiIFTw0GIAggBSAIGyEKA0AgCiIEQQF0IQogBCAFSQ0ACyATQZgaaiIFQQBBhBH8CwAgE0Gj4P/7BzYCnCsgE0GQCWoiBiAFIAQQghwgE0HYAGogBkHMgs4AEKAhIAggEygCXCIFSw0DIAggIksNBCATKAJYIQYCQCAIRQ0AIAhBiBFsIgpFDQAgBiAZIAr8CgAACyAiRQ0FIBkgIkGIEWxBBBD4OgwFCyA+ID5BzNzMABDDIQALIDcgJCAkIDdJGyA3QdzczAAQwyEACyAaIBxB7NzMABDDIQALIAggBUGM28wAELA7AAsgCCAiQZzbzAAQsDsACyAFISIgBiEZIAQhCAsCQCA8IENqIgQgD00EQCAOIQQgByEYIA8hCwwBCyAPIAQgDxshBQNAIAUiC0EBdCEFIAQgC0sNAAsgE0HQAGogKyALELkpAkAgEygCVCIEIA9PBEAgDiAPSQ0BIBMoAlAhGCAPQQJ0IgUEQCAYIAcgBfwKAAALIAcgDhCAMQwCCyAPIARBrNvMABCwOwALIA8gDkG828wAELA7AAsgQwRAQQAhBSAEIDxrIgZBACAEIAZPGyEHICIgP2siBkEAIAYgIk0bIQ4gGCA8QQJ0aiEPIBkgP0GIEWxqITIgE0GQA2ohCgNAIAVBwABGDTogCigCACIGID5PDQMgBSAORg0EIDIgQCAGQYgRbGpBiBH8CgAAIAZBwABPDTsgBSAHRg0/IA8gE0GQAWogBkECdGooAgA2AgAgCigCACIGQcAATw08IBNBkAdqIAZBAnRqIAU2AgAgCkEEaiEKIA9BBGohDyAyQYgRaiEyIAVBAWoiBSBDRw0ACyAFIDxqITwgBSA/aiE/C0EAIQogE0GQBWohBSAQIQYCQANAIAUoAgAiB0E/Sw0FIAogJGoiDyA5Tw0BIAYgE0GQB2ogB0ECdGooAgAgL2o2AgAgBUEEaiEFIAZBBGohBiBIIApBAWoiCkcNAAsgEEGAAmohECAuQUBqIS4gLyBDaiEvIAshDyAYIQcgBCEOICRBQGsiJCAVTw0FDAELCyAPIDlB3NvMABDDIQALIAYgPkH828wAEMMhAAsgBSA/aiAiQYzczAAQwyEACyAHQcAAQczbzAAQwyEACyATQQA2AqAaIBNCgICAgMAANwKYGiATQcgAaiATQZgaakGMh84AEKAhIBMoAkwhLiATKAJIIT8gPgRAIEAgPkGIEWxBBBD4OgsCQCAvQQF2IC9sIgUgL0EGdCIGIAUgBkkbIgtBgBBNBEAgLCEGIB8hDwwBCyATQaAaakIANwMAIBNCADcDmBogE0GQCWoiBSATQZgaaiALQQFqEIMcIBNBQGsgBUHMgs4AEJ0hIBMoAkQhBiATKAJAIQ8gLEUNACAfICxBBHRBBBD4OgsgE0E4aiArIC8QuSkCQCATKAI8IgggL08EQCATKAI4IQcgLwRAIC9BAnQhGkEAIQUgByEKA0AgCiAFNgIAIAVBAWohBSAKQQRqIQogGkEEayIaDQALCyAZICIgGCAEIBQgOSAHIAggDyAGIC8gFUGAAiALEI4GIQsgE0EANgKgGiATQoCAgIDAADcCmBogE0EwaiATQZgaakGMh84AEJ0hIBMoAjQhLCATKAIwIT4gBgRAIA8gBkEEdEEEEPg6CyATQShqEP4nIBMoAiwhHyATKAIoITwgGCAEEIAxIBNBIGogKyAvELkpIBMoAiAhGAJAIBMoAiQiEEUNACAQQQJ0IgRFDQAgGEH/ASAE/AsACyAVRQ0BQQAhD0EAIQ5BACEvAkADQCATQZAJakEAQYQR/AsAIBNBo+D/+wc2ApQaAkACQAJAAkAgLyA3RwRAICAgL0ECdCIkaigCACIaBEAgDyAcIA8gHEkbIQUgMyAPQQF0aiEKA0AgBSAcRg0EIBNBkAlqIAovAQAQtSkgBUEBaiEFIApBAmohCiAPQQFqIQ8gGkEBayIaDQALCyAvDQEgFCEFIDlFDT8MBAsgNyA3QfzZzAAQwyEACyAvQQFrIgQgOUkNASAEIDlBnNrMABDDIQALIA8gHEH82swAEMMhAAsgFCAEQQJ0aiEFCwJAICIgBSgCACIKSwRAIBMoApAaBH0gE0GYGmogE0GQCWpBiBH8CgAAIBMgGSAKQYgRbGoiBCgCgBEgEygCmCtqNgKYK0EAIQUDQCATQZgaaiIGIAVqIhogBCAFaigCACAaKAIAajYCACAFQQRqIgVBgBFHDQALIAYQogcgBCoChBGTBUMAAAAACyFtIAtFDQFBACEGA0ACQAJAAn0CQCAGIAhHBEAgByAGQQJ0aiIaKAIAIgQgIk8NAyATKAKQGg0BQwAAAAAMAgsgCCAIQdzazAAQwyEACyATQZgaaiATQZAJakGIEfwKAAAgEyAZIARBiBFsaiIEKAKAESATKAKYK2o2ApgrQQAhBQNAIBNBmBpqIjIgBWoiQCAEIAVqKAIAIEAoAgBqNgIAIAVBBGoiBUGAEUcNAAsgMhCiByAEKgKEEZMLIm4gbV1FDQEgGigCACEKIG4hbQwBCyAEICJB7NrMABDDIQALIAZBAWoiBiALRw0ACwwBCyAKICJBrNrMABDDIQALIC8gOUcEQCAUICRqIAo2AgAgCiAQTw0CIBggCkECdGoiBCgCAEF/RgRAIAQgDjYCACAOQQFqIQ4LIC9BAWoiLyAVRw0BDAQLCyA5IDlBvNrMABDDIQALIAogEEHM2swAEMMhAAsgLyAIQczYzAAQsDsACyATQRhqEP4nIBMoAhwhDyATKAIYIQ4gByAIEIAxIBNBADYCoBogE0KAgICAwAA3ApgaIBNBEGogE0GYGmpBjIfOABCgISATKAIUIQggEygCECEcICIEQCAZICJBiBFsQQQQ+DoLAkAgFSAbKAIEIgRNBEAgBCEkDAELIAQgFSAEGyEFA0AgBSIGQQF0IQUgBiAVSQ0ACyATQQhqICsgBhC4KSATKAIMIiQgBE8EQCATKAIIIgUgBCAbKAIAIARB7NjMABDVLCAbKAIEIQQgGyAkNgIEIBsoAgAhBiAbIAU2AgAgKyAGIAQQ4DUMAQsgBCAkQdzYzAAQsDsACwJAAkACQAJAAkACQAJAAkAgGwJ/AkAgFSAbKAIMIgRLBEAgBCAVIAQbIQUDQCAFIgZBAXQhBSAGIBVJDQALIBMgKyAGELkpIAQgEygCBCIHSw0FIBMoAgAhGSAEQQJ0IgQEQCAZIBsoAgggBPwKAAALIBsoAgwhBCAbIAc2AgwgGygCCCAbIBk2AgggBBCAMSAbKAIEISQMAQsgFUUEQEEAIQpBAQwCCyAbKAIIIRkgBCEHCyAVQQFrISIgGygCACEzQQAhMiAgIQsgFCEaQQAhCkEAIQZBACEFA0AgBSA3Rg0CIAVBAWohBCALKAIAIAZqIQYCQCAFICJHBEAgBSA5Tw0HIAQgOU8NRSAaKAIAIBpBBGooAgBGDQELIAUgOU8NByAaKAIAIgUgEE8NCCAKICRPDQkgCiAzaiAYIAVBAnRqKAIAIgU6AAAgByAKTQ0EIBkgCkECdGogBjYCACAFQf8BcSIFIDJB/wFxIgYgBSAGSxshMiAKQQFqIQpBACEGCyALQQRqIQsgGkEEaiEaIAQiBSAVRw0ACyAyQf8BcUEBags2AhAgGyAKNgIUIBggEBCAMSAgIDcQgDEgFCA5EIAxIA8EQCAOIA9BAnRBBBD4OgsgLARAID4gLEEEdEEEEPg6CyAuBEAgPyAuQYgRbEEEEPg6CyAfBEAgPCAfQQJ0QQQQ+DoLIAgEQCAcIAhBiBFsQQQQ+DoLIBNBoCtqJAAMBwsgNyA3QYzZzAAQwyEACyAKIAdB7NnMABDDIQALIAQgB0H82MwAELA7AAsgBSA5QZzZzAAQwyEACyAFIDlBvNnMABDDIQALIAUgEEHM2cwAEMMhAAsgCiAkQdzZzAAQwyEACyArIEIgMRDgNQwBCwJAIBsoAgQiBCAbKAIUIgVBAWoiEE8EQCAEIQcMAQsgBCAQIAQbIQUDQCAFIgZBAXQhBSAGIBBJDQALIClBEGogKyAGELgpICkoAhQiByAETwRAICkoAhAiBSAEIBsoAgAgBEHM3cwAENUsIBsoAgQhBCAbIAc2AgQgGygCACEGIBsgBTYCACArIAYgBBDgNSAbKAIUIgVBAWohEAwBCyAEIAdBvN3MABCwOwALAkACQAJAIBAgGygCDCIETQRAIAQhEAwBCyAEIBAgBBshBQNAIAUiBkEBdCEFIAYgEEkNAAsgKUEIaiArIAYQuSkgBCApKAIMIhBLDQEgKSgCCCEFIARBAnQiBARAIAUgGygCCCAE/AoAAAsgGygCDCEEIBsgEDYCDCAbKAIIIBsgBTYCCCAEEIAxIBsoAhQhBSAbKAIEIQcLIBtBATYCECAFIAdPDQEgGygCACAFakEAOgAAIAUgEEkEQCAbIAVBAWo2AhQgGygCCCAFQQJ0aiALNgIADAMLIAUgEEH83cwAEMMhAAsgBCAQQdzdzAAQsDsACyAFIAdB7N3MABDDIQALIClB4BFqJAAgHgRAIDggHkEBdEECEPg6CyBGQTBqJAAMAwsgPSA9QYzezAAQwyEACyAFIB5BnN7MABDDIQALICAgIEGs3swAEMMhAAtBASEHAkAgFygCJARAIEchBSBFIQgMAQsgISgCECEFIwBBIGsiBCQAIARBFGogBUEAQQFBARCgGCAEKAIYIQYgBCgCFEEBRgRAIAYgBCgCHEHEntAAEP0vAAsgBEEQaiIHQQA2AgAgBCAEKAIcNgIMIAQgBjYCCCAEQQhqIAUQhhwgKEG4AWoiBUEIaiAHKAIANgIAIAUgBCkCCDcCACAEQSBqJAAgKEFAayAFQcyCzgAQkCEgKCgCRCEIICgoAkAhBSBFBEAgRyBFQQEQ+DoLQcAAIQcgCEUEQEEAIQgMAQsgCEUNACAFIE4gCPwLAAsgISgCECEKIChBuAFqIgRBAEGECPwLACAoQaPg//sHNgK8CSAoQdAAaiIGIAQgByAKbCIUEIEcIChBOGogBkHMgs4AEKIhICgoAjwhDiAoKAI4IRsgISgCQCEHIARBAEGEEfwLACAoQaPg//sHNgK8EiAGIAQgB0ECdBCCHCAoQTBqIAZBzILOABCgISAoKAI0IRogKCgCMCEVICEgISgCKCIHNgJ8IARBAEGEFvwLACAoQaPg//sHNgK8FyAGIAQgBxCEHCAoQShqIAZBzILOABCcISAoKAIsIQ8gKCgCKCEZICEoAmQiBARAICEoAmAgBEGIFmxBBBD4OgsgISAPNgJkICEgGTYCYEEAIQojAEEwayIGJAAgBiAhKAIMBH8gISgCCCgCAAVBAAs2AgwgBkIANwIEIAYgITYCACAGICcoAgwEfyAnKAIIKAIABUEACzYCHCAGQgA3AhQgBiAnNgIQIAYgLSgCDAR/IC0oAggoAgAFQQALNgIsIAZCADcCJCAGIC02AiAgEgRAA0ACQAJAAkACQCAKID1HBEAgBkEQahCwHiAGKAIYIgQgD08NASAZIARBiBZsaiAdIApBBHRqIhAvAQwiGBC3KSAQKAIAIgtFDQQDQCAGELAeIAYoAgghByAIBEAgByAITw0EIAdBBnQCfwJAAkACQAJAIAUgB2otAABBAWsOAwECAwALIAxBP3EMAwsgDEH8AXFBAnYMAgsgDUH/AXFBtJPiAGotAAAgDEH/AXFBtJHiAGotAAByDAELIA1B/wFxQbSV4gBqLQAAIAxB/wFxQbSV4gBqLQAAQQN0agtB/wFxaiEHCyAHIA5PDQQgKiAJICNxIgRLBEAgGyAHQYgIbGogBCA6ai0AACIEELYpIAlBAWohCSAMIQ0gBCEMIAtBAWsiC0UNBgwBCwsgBCAqQYzszAAQwyEACyA9ID1BnOvMABDDIQALIAQgD0Gs68wAEMMhAAsgByAIQezrzAAQwyEACyAHIA5B/OvMABDDIQALIBAoAgRB////D3EiBCAJaiEJAkAgBEUNAAJAAkACQAJAICogCUECayAjcSIESwRAIAlBAWsgI3EiByAqTw0BIAQgOmotAAAhDSAHIDpqLQAAIQwgGEH/AE0NBSAYQQdxIQQgBkEgahCwHiAGKAIoQQJ0IScgGEEGdiILQQRLQQEgC3RBFXFFcg0CQQMhByAEQQNJDQMMBAsgBCAqQbzrzAAQwyEACyAHICpBzOvMABDDIQALQQMhByALQQdHIARBAktyDQELIAQhBwsgGiAHICdqIgRLBEAgFSAEQYgRbGogEC8BDkH/B3EQtSkMAQsgBCAaQdzrzAAQwyEACyAKQQFqIgogEkcNAAsLIAZBMGokACAIBEAgBSAIQQEQ+DoLICEgISgCEEEGdCIENgJwIChBIGogKyAEELkpICgoAiQhBCAoKAIgIQUgISgCTCIGBEAgISgCSCAGQQJ0QQQQ+DoLICEgBDYCTCAhIAU2AkggISAhKAJwIgQ2AnggKEG4AWoiBUEAQYQI/AsAIChBo+D/+wc2ArwJIChB0ABqIgYgBSAEEIEcIChBGGogBkHMgs4AEKIhICgoAhwhDyAoKAIYIRAgISgCXCIEBEAgISgCWCAEQYgIbEEEEPg6CyAhIA82AlwgISAQNgJYICFB+ABqICEoAkghBiAhKAJMIQpBACEHQQAhGSMAQdAAayInJAACfyAUIgRFBEAgJ0EYahD+JyAnKAIcIS0gJygCGCEMICdBEGoQ/icgJygCFCEUICcoAhAMAQsgJ0EoaiArIAQQuSkgJygCLCEtICcoAighDCAnQSBqICsgBBC5KSAnKAIkIRQgJygCIAshGCAnQcgAakIANwMAICdCADcDQCAnQTRqIgUgJ0FAa0GBEBCDHCAnQQhqIAVBzILOABCdISAnKAIMIQ0gJygCCCEFAkAgBEUNACAMIQkCQAJAAkADQCAHIC1GDQEgCUEBNgIAIAlBBGohCSAEIAdBAWoiB0cNAAtBACEJIAYhC0EAIQcCQAJAAkADQCAHIA5GDQEgByAPRg0CIAkgEGoiCCAJIBtqIiJBhAj8CgAAIAhBhAhqICIQoQc4AgAgByAKRg0DIAsgBzYCACAJQYgIaiEJIAtBBGohCyAHQQFqIgcgBEcNAAsgBCEIQQAhCwNAIBQgGWsiIkEAIBQgIk8bIR5BwAAgBCALayIJIAlBwABPGyEkQQFBwAAgCCAIQcAATxsiCSAJQQFNGyEgIBggGUECdCIsaiEJQQAhBwJAA0AgByAeRg0BIAkgByALajYCACAJQQRqIQkgICAHQQFqIgdHDQALIAogC0kNBiAUIBlJDQcgECAPIAwgLSAGIAtBAnRqIAogC2sgGCAsaiAiIAUgDSAkICRBgAJBgBAQjwYgGWohGSAIQUBqIQggC0FAayILIARPDQgMAQsLIAcgGWogFEHc6MwAEMMhAAsgDiAOQezozAAQwyEACyAPIA9B/OjMABDDIQALIAogCkGM6cwAEMMhAAsgLSAtQZzpzAAQwyEACyALIApBvOjMABCvOwALIBkgFEHM6MwAEK87AAtBgBAhBwJAAkAgGUEBdiAZbCIJIBlBBnQiCCAIIAlLGyILQYAQSQRAIBAgDyAMIC0gBiAKIBggFCAFIA0gGSAEQYACIAsQjwYhByANRQ0CDAELA0AgByIJQQF0IQcgCSALTQ0ACyAnIAkQ4RoCQCAnKAIEIglB/w9LBEAgDUH/D00NASAnKAIAIgggBUGAgAL8CgAAIAUgDUEEdEEEEPg6IBAgDyAMIC0gBiAKIBggFCAIIAkgGSAEQYACIAsQjwYhByAJIQ0gCCEFDAILQYAQIAlBnOjMABCwOwALQYAQIA1BrOjMABCwOwALIAUgDUEEdEEEEPg6CyAMIC0QgDEgGyEJIBghBSAHIQxBACEIIwBBkAhrIg0kAAJAIARFDQACQANAAn8gCEUEQCAGIAoNARpBAEEAQbzkzAAQwyEACyAKIAhBAWsiB00EQCAHIApBzOTMABDDIQALIAYgB0ECdGoLIQcCfQJAIAggDkcEQCAHKAIAIgsgD08NBCAJIAhBiAhsaiIiKAKACCIeDQFDAAAAAAwCCyAOIA5B3OTMABDDIQALIA1BCGogIkGICPwKAAAgDSAQIAtBiAhsaiIZKAKACCANKAKICGo2AogIQQAhBwNAIA1BCGoiLSAHaiIkIAcgGWooAgAgJCgCAGo2AgAgB0EEaiIHQYAIRw0ACyAtEKEHIBkqAoQIkwshbQJAIAxFDQBBACEZAkADQCAUIBlGDQEgDyAFIBlBAnRqKAIAIi1LBEAgHgR9IA1BCGogIkGICPwKAAAgDSAQIC1BiAhsaiIkKAKACCANKAKICGo2AogIQQAhBwNAIA1BCGoiICAHaiIsIAcgJGooAgAgLCgCAGo2AgAgB0EEaiIHQYAIRw0ACyAgEKEHICQqAoQIkwVDAAAAAAsibiBtIG0gbl4iBxshbSAtIAsgBxshCyAZQQFqIhkgDEcNAQwDCwsgLSAPQZzlzAAQwyEACyAUIBRBjOXMABDDIQALIAggCkcEQCAGIAhBAnRqIAs2AgAgCEEBaiIHIQggBCAHRw0BDAMLCyAKIApB/OTMABDDIQALIAsgD0Hs5MwAEMMhAAsCQAJAAkAgDARAQQAhBwNAIAcgFEYNAyAFKAIAIgggD08NAiAQIAhBiAhsaiIIQQBBhAj8CwAgCEGj4P/7BzYChAggBUEEaiEFIAwgB0EBaiIHRw0ACwsgBARAQQAhByAJIQUDQAJAAkAgByAKRwRAIAYgB0ECdGooAgAiCCAPTw0BIAcgDkcEQCAHQQFqIQwgECAIQYgIbGoiCCAJIAdBiAhsaigCgAggCCgCgAhqNgKACEEAIQcDQCAHIAhqIgsgBSAHaigCACALKAIAajYCACAHQQRqIgdBgAhHDQALDAMLIA4gDkGM5MwAEMMhAAsgCiAKQezjzAAQwyEACyAIIA9B/OPMABDDIQALIAVBiAhqIQUgDCIHIARHDQALCyANQZAIaiQADAILIAggD0Gs5MwAEMMhAAsgFCAUQZzkzAAQwyEACyAYIBQQgDFBACEJQQAhBUEAIQdBACEUIwBBMGsiDCQAAkAgBEUEQCAMQQhqEP4nIAwoAgwhBCAMKAIIIAxBADYCLCAMQoCAgIDAADcCJCAMIAxBJGpBjIfOABCiISAMKAIEIQcgDCgCACEIIAQQgDEMAQsgDEEYaiArIAQQuSkgDCgCHCENIAwoAhgiCyEFAkACQAJAA0AgCSANRg0BIAVBfzYCACAFQQRqIQUgBCAJQQFqIglHDQALIAYhBUEAIQkCQAJAA0AgCSAKRg0BIAUoAgAiCCANTw0CIAsgCEECdGoiCCgCAEF/RgRAIAggBzYCACAHQQFqIQcLIAVBBGohBSAEIAlBAWoiCUcNAAsgDEEQaiEJIwBBsAhrIgUkAAJ/IAdFBEAgBUEANgIwIAVCgICAgMAANwIoIAVBCGogBUEoakGMh84AEKIhIAUoAgghByAFKAIMDAELIAVBKGoiCEEAQYQI/AsAIAVBo+D/+wc2AqwIIAVBHGoiGCAIIAcQgRwgBUEQaiAYQcyCzgAQoiEgBSgCECEHIAUoAhQLIQggCSAHNgIAIAkgCDYCBCAFQbAIaiQAQQAhBSAMKAIUIQcgDCgCECEIAkACQAJAAkADQCAKIBRGDQEgBigCACIJIA1PDQIgBSALIAlBAnRqKAIARgRAIAkgD08NBCAFIAdPDQUgCCAFQYgIbGogECAJQYgIbGpBiAj8CgAAIAYoAgAhCSAFQQFqIQULIAkgDU8NCSAGIAsgCUECdGooAgA2AgAgBkEEaiEGIAQgFEEBaiIURw0ACyALIA0QgDEgBUUEQEEAIQUMCgtBACEGQQAhCQNAIAcgCUYNCCAJIA9HBEAgBiAQaiAGIAhqQYgI/AoAACAGQYgIaiEGIAUgCUEBaiIJRg0LDAELCyAPIA9BjOfMABDDIQALIAogCkGc58wAEMMhAAsgCSANQaznzAAQwyEACyAJIA9BvOfMABDDIQALIAUgB0HM58wAEMMhAAsgCiAKQeznzAAQwyEACyAIIA1B/OfMABDDIQALIA0gDUGM6MwAEMMhAAsgByAHQfzmzAAQwyEACyAJIA1B3OfMABDDIQALIAcEQCAIIAdBiAhsQQQQ+DoLIAxBMGokACAFNgIAICdB0ABqJAAgDgRAIBsgDkGICGxBBBD4OgsCQCAXKAIkRQ0AICEoAhAiC0UNACALQQh0IQUgC0EGdEFAaiEMA0AgC0EBayILQQJ0IQYgDCEHQYB+IQgCQAJAA0AgCyAhKAJMIgRPDQEgBCAHSwRAICEoAkgiBCAFaiAIaiAEIAZqKAIANgIAIAdBAWohByAIQQRqIghFDQMMAQsLIAcgBEGc7cwAEMMhAAsgCyAEQYztzAAQwyEACyAFQYACayEFIAxBQGohDCALDQALCyAhICEoAkBBAnQiBDYCdCAoQRBqICsgBBC5KSAoKAIUIQQgKCgCECEFICEoAlQiBgRAICEoAlAgBkECdEEEEPg6CyAhIAQ2AlQgISAFNgJQICEgISgCdCIENgKAASAoQbgBaiIFQQBBhBH8CwAgKEGj4P/7BzYCvBIgKEHQAGoiBiAFIAQQghwgKEEIaiAGQcyCzgAQoCEgKCgCDCEPICgoAgghECAhKAJsIgQEQCAhKAJoIARBiBFsQQQQ+DoLICEgEDYCaCAhIA82AmwgISgCdCEEICFBgAFqICEoAlAhBiAhKAJUIQpBACENQQAhBSMAQdAAayIbJAACfyAERQRAIBtBGGoQ/icgGygCHCEZIBsoAhghCyAbQRBqEP4nIBsoAhQhCCAbKAIQDAELIBtBKGogKyAEELkpIBsoAiwhGSAbKAIoIQsgG0EgaiArIAQQuSkgGygCJCEIIBsoAiALIRQgG0HIAGpCADcDACAbQgA3A0AgG0E0aiIJIBtBQGtBgRAQgxwgG0EIaiAJQcyCzgAQnSEgGygCDCEYIBsoAgghDgJAIARFDQAgCyEHAkACQAJAA0AgDSAZRg0BIAdBATYCACAHQQRqIQcgBCANQQFqIg1HDQALQQAhByAGIQlBACENAkACQAJAA0AgDSAaRg0BIA0gD0YNAiAHIBBqIgwgByAVaiInQYQR/AoAACAMQYQRaiAnEKIHOAIAIAogDUYNAyAJIA02AgAgB0GIEWohByAJQQRqIQkgDUEBaiINIARHDQALIAQhDEEAIQkDQCAIIAVrIidBACAIICdPGyEhQcAAIAQgCWsiByAHQcAATxshLUEBQcAAIAwgDEHAAE8bIgcgB0EBTRshJCAUIAVBAnQiHGohB0EAIQ0CQANAIA0gIUYNASAHIAkgDWo2AgAgB0EEaiEHICQgDUEBaiINRw0ACyAJIApLDQYgBSAISw0HIBAgDyALIBkgBiAJQQJ0aiAKIAlrIBQgHGogJyAOIBggLSAtQYACQYAQEI4GIAVqIQUgDEFAaiEMIAlBQGsiCSAETw0IDAELCyAFIA1qIAhB3OjMABDDIQALIBogGkHs6MwAEMMhAAsgDyAPQfzozAAQwyEACyAKIApBjOnMABDDIQALIBkgGUGc6cwAEMMhAAsgCSAKQbzozAAQrzsACyAFIAhBzOjMABCvOwALQYAQIQ0CQAJAIAVBAXYgBWwiCSAFQQZ0IgcgByAJSxsiDEGAEEkEQCAQIA8gCyAZIAYgCiAUIAggDiAYIAUgBEGAAiAMEI4GIQ0gGEUNAgwBCwNAIA0iCUEBdCENIAkgDE0NAAsgGyAJEOEaAkAgGygCBCIJQf8PSwRAIBhB/w9NDQEgGygCACIHIA5BgIAC/AoAACAOIBhBBHRBBBD4OiAQIA8gCyAZIAYgCiAUIAggByAJIAUgBEGAAiAMEI4GIQ0gCSEYIAchDgwCC0GAECAJQZzozAAQsDsAC0GAECAYQazozAAQsDsACyAOIBhBBHRBBBD4OgsgCyAZEIAxIBUhCSAUIQVBACEMIwBBkBFrIgskAAJAIARFDQACQANAAn8gDEUEQCAGIAoNARpBAEEAQbzkzAAQwyEACyAKIAxBAWsiB00EQCAHIApBzOTMABDDIQALIAYgB0ECdGoLIQcCfQJAIAwgGkcEQCAHKAIAIg4gD08NBCAJIAxBiBFsaiInKAKAESIhDQFDAAAAAAwCCyAaIBpB3OTMABDDIQALIAtBCGogJ0GIEfwKAAAgCyAQIA5BiBFsaiIYKAKAESALKAKIEWo2AogRQQAhBwNAIAtBCGoiGSAHaiItIAcgGGooAgAgLSgCAGo2AgAgB0EEaiIHQYARRw0ACyAZEKIHIBgqAoQRkwshbQJAIA1FDQBBACEYAkADQCAIIBhGDQEgDyAFIBhBAnRqKAIAIhlLBEAgIQR9IAtBCGogJ0GIEfwKAAAgCyAQIBlBiBFsaiItKAKAESALKAKIEWo2AogRQQAhBwNAIAtBCGoiJCAHaiIcIAcgLWooAgAgHCgCAGo2AgAgB0EEaiIHQYARRw0ACyAkEKIHIC0qAoQRkwVDAAAAAAsibiBtIG0gbl4iBxshbSAZIA4gBxshDiAYQQFqIhggDUcNAQwDCwsgGSAPQZzlzAAQwyEACyAIIAhBjOXMABDDIQALIAogDEcEQCAGIAxBAnRqIA42AgAgDEEBaiIHIQwgBCAHRw0BDAMLCyAKIApB/OTMABDDIQALIA4gD0Hs5MwAEMMhAAsCQAJAAkAgDQRAQQAhBwNAIAcgCEYNAyAFKAIAIgwgD08NAiAQIAxBiBFsaiIMQQBBhBH8CwAgDEGj4P/7BzYChBEgBUEEaiEFIA0gB0EBaiIHRw0ACwsgBARAQQAhByAJIQUDQAJAAkAgByAKRwRAIAYgB0ECdGooAgAiDSAPTw0BIAcgGkcEQCAHQQFqIQwgECANQYgRbGoiDSAJIAdBiBFsaigCgBEgDSgCgBFqNgKAEUEAIQcDQCAHIA1qIg4gBSAHaigCACAOKAIAajYCACAHQQRqIgdBgBFHDQALDAMLIBogGkGM5MwAEMMhAAsgCiAKQezjzAAQwyEACyANIA9B/OPMABDDIQALIAVBiBFqIQUgDCIHIARHDQALCyALQZARaiQADAILIAwgD0Gs5MwAEMMhAAsgCCAIQZzkzAAQwyEACyAUIAgQgDEgKyEJQQAhB0EAIQVBACEMQQAhDiMAQTBrIg0kAAJAIARFBEAgDUEIahD+JyANKAIMIQQgDSgCCCANQQA2AiwgDUKAgICAwAA3AiQgDSANQSRqQYyHzgAQoCEgDSgCBCEMIA0oAgAhCCAEEIAxDAELIA1BGGogCSAEELkpIA0oAhwhCSANKAIYIgshBQJAAkACQANAIAcgCUYNASAFQX82AgAgBUEEaiEFIAQgB0EBaiIHRw0ACyAGIQVBACEHAkACQANAIAcgCkYNASAFKAIAIgggCU8NAiALIAhBAnRqIggoAgBBf0YEQCAIIAw2AgAgDEEBaiEMCyAFQQRqIQUgBCAHQQFqIgdHDQALIA1BEGohByMAQbARayIFJAACfyAMRQRAIAVBADYCMCAFQoCAgIDAADcCKCAFQQhqIAVBKGpBjIfOABCgISAFKAIIIQwgBSgCDAwBCyAFQShqIghBAEGEEfwLACAFQaPg//sHNgKsESAFQRxqIhQgCCAMEIIcIAVBEGogFEHMgs4AEKAhIAUoAhAhDCAFKAIUCyEIIAcgDDYCACAHIAg2AgQgBUGwEWokAEEAIQUgDSgCFCEMIA0oAhAhCAJAAkACQAJAA0AgCiAORg0BIAYoAgAiByAJTw0CIAUgCyAHQQJ0aigCAEYEQCAHIA9PDQQgBSAMTw0FIAggBUGIEWxqIBAgB0GIEWxqQYgR/AoAACAGKAIAIQcgBUEBaiEFCyAHIAlPDQkgBiALIAdBAnRqKAIANgIAIAZBBGohBiAEIA5BAWoiDkcNAAsgCyAJEIAxIAVFBEBBACEFDAoLQQAhBkEAIQcDQCAHIAxGDQggByAPRwRAIAYgEGogBiAIakGIEfwKAAAgBkGIEWohBiAFIAdBAWoiB0YNCwwBCwsgDyAPQYznzAAQwyEACyAKIApBnOfMABDDIQALIAcgCUGs58wAEMMhAAsgByAPQbznzAAQwyEACyAFIAxBzOfMABDDIQALIAogCkHs58wAEMMhAAsgCCAJQfznzAAQwyEACyAJIAlBjOjMABDDIQALIAwgDEH85swAEMMhAAsgByAJQdznzAAQwyEACyAMBEAgCCAMQYgRbEEEEPg6CyANQTBqJAAgBTYCACAbQdAAaiQAIBoEQCAVIBpBiBFsQQQQ+DoLIChBwBdqJAAMAQtBASEJIBdBATYC5AEgF0IENwLoAQJ/IAoEQEEEIQVBAAwBCyARIQkgF0HkAWohECAXQegBaiEPQwAAAAAhbkMAAAAAIW1BACEOIwBBwA5rIgokAAJAAkACQAJAIERBwABJIAQiBkEETHINAAJAIA1B//8/TQRAIAlBQGshDCAJIERqIRQMAQsgCkEwakEAQYAB/AsAIApBsAFqQQBBgA38CwAgCUFAayIMIAkgRGoiFE0EQCAMIQ0gCSEHAkACQANAIAcgI3EiBCAqTw0BICogB0EBaiAjcSIFSwRAIA0gB0ECaksEQCAOQT5qIQ4gBCA6ai0AACEIIAUgOmotAAAhBUECIQsDQAJAAkAgKiAHIAtqICNxIgRLBEAgBCA6ai0AACEEIAhB/wFxQYACckG0ieIAai0AACAFQf8BcUG0ieIAai0AAHIiCEHAAE8NASAEQQN2QQJ0IhggCkEwamoiGiAaKAIAQQFqNgIAIAhBAnRBpPzRAGotAAAiCEENSQ0CIAhBDUHk/tEAEMMhAAsgBCAqQcT+0QAQwyEACyAIQcAAQdT+0QAQwyEACyAKQbABaiAIQQd0aiAYaiIIIAgoAgBBAWo2AgAgBSEIIAQhBSALQQFqIgtBwABHDQALCyAHQYAgaiEHIA1BgCBqIg0gFEsNAwwBCwsgBSAqQbT+0QAQwyEACyAEICpBpP7RABDDIQALIA6zIW4LIApBKGogCkEwakEgQSAQgRFBACELIAoqAighbwNAIApBIGogCkGwAWogC2pBIEEgEIERIG0gCioCIJIhbSALQYABaiILQYANRw0AC0MAAIA/IG6VIm4gbZQibUMAAEBAXiBuIG+UIG2TQ83MTD5dcg0AIA9BwAA2AgQgD0Gk/NEANgIAIBBBDTYCAAwBCyAKQbABakEAQST8CwACQAJAIAwgFE0EQANAIAkgI3EiBCAqTw0FIAwgCUEBaksEQCAEIDpqLQAAQQR2QQxxQaT/0QBqKAIAIQVBASELA0AgCSALaiAjcSIEICpPDQggBUEDbCAEIDpqLQAAQQR2QQxxQaT/0QBqKAIAIgVqIgRBCEsNBCAKQbABaiAEQQJ0aiIEIAQoAgBBAWo2AgAgC0EBaiILQcAARw0ACwsgCUGAIGohCSAMQYAgaiIMIBRNDQALC0EAIQsgCkG4DmpBADYCACAKQgA3A7AOIApBQGtCADcDACAKQThqQgA3AwAgCkIANwMwIApBsAFqIQUDQCAKQbAOaiIEIAtB/wFxQQNwQQJ0aiIJIAUoAgAiByAJKAIAajYCACAKQTBqIgkgCyALQQZrIAtBBkkbQQJ0aiIMIAcgDCgCAGo2AgAgBUEEaiEFIAtBAWoiC0EJRw0ACyAKQRhqIARBA0EDEIERIAoqAhggCkEQaiAJQQZBAxCBESAKKgIQIXAgCkEIaiAKQTxqQQNBAxCBEUMAAAAAIW0gCkGwAWohC0EJIQUgCioCCCFxA0AgCiALIAVBAxCBESALQQxqIQsgbSAKKgIAkiFtIAVBA2siBQ0AC0MAAIA/IAooArgOIAooArQOIAooArAOamqzlSJulCJvQwAAIEGUIG0gbpQgBkEHSRshbSBvIHAgcZIgbpQibpNDzcxMPl0gbyBtk0PNzEw+XXENASBuIG2TQwrXozxdRQRAIA9BwAA2AgQgD0Gk+NEANgIAIBBBAzYCAAwDCyAPQcAANgIEIA9BpPrRADYCACAQQQI2AgAMAgsgBEEJQZT/0QAQwyEACyAQQQE2AgALIApBwA5qJAAMAgsgBCAqQfT+0QAQwyEACyAEICpBhP/RABDDIQALIBcoAugBIQUgFygC5AEhCSAXKALsAQshBiAXQeAAaiEEAkAgCUEBRgRAICsgOiAqIBEgIyAWIDAgTkEBQQRBACAdID0gEiAEENIHDAELICsgOiAqIBEgIyAWIDAgTiAJIAUgBiAdID0gEiAEENIHCwtBoAQgFygCDCIEIARBoARPGyEGQQAhCSMAQcAFayIEJAAgBEEAQcAF/AsAAkACQCAXQeAAaiIHKAJ4Ig0EQCAHKAJYIQwgBygCXCEFA0AgBSAJRg0CQYACIAxBgAIgBBCpBCAMQYgIaiEMIA0gCUEBaiIJRw0ACwsCQCAHKAJ8Ig0EQCAHKAJgIQwgBygCZCEFQQAhCQNAIAUgCUYNAkHABSAMQcAFIAQQqQQgDEGIFmohDCANIAlBAWoiCUcNAAsLAkAgBygCgAEiDQRAIAcoAmghDCAHKAJsIQVBACEJA0AgBSAJRg0CIAYgDEGgBCAEEKkEIAxBiBFqIQwgDSAJQQFqIglHDQALCyAEQcAFaiQADAMLIAUgBUGs78wAEMMhAAsgBSAFQbzvzAAQwyEACyAFIAVBzO/MABDDIQALIB0hBUEAIQsjAEGQFmsiBiQAIAZB7A5qIgkgOiAqIBEiHSBEICMQ7xYCQCAXLQBRRQ0AIBIgPU0EQCAGKAL4DiEIIAYoAvQOIQ8gBigC8A4hECAGKALsDiEOIwBBIGsiBCQAAkACQAJAAkACQAJAAkACQCAHKAIUIgwgBygCBE0EQCAMIAcoAgxLDQEgBygCcCIUIAcoAkxLDQIgBygCLCINIAcoAhxLDQMgDSAHKAIkSw0EIAcoAkQiCiAHKAI0Sw0FIAogBygCPEsNBiAHKAJ0IhggBygCVEsNByAHKAIAIRogBygCCCEbIAcoAkghFSAHKAIQIRkgBygCGCEnIAcoAiAhLSAHKAIwISEgBygCKCEiIAcoAjghJCAJIBg2AkggCSAKNgI8IAkgJDYCOCAJIAo2AjQgCSAhNgIwIAkgIjYCLCAJIA02AiggCSAtNgIkIAkgDTYCICAJICc2AhwgCSAUNgIYIAkgFTYCFCAJIBk2AhAgCSAMNgIMIAkgGzYCCCAJIAw2AgQgCSAaNgIAIAkgBygCUDYCRCAJIAcoAkA2AkAgBEEgaiQADAgLIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQcim0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakHYptAAEO8sAAsgBEEANgIYIARBATYCDCAEQfig0AA2AgggBEIENwIQIARBCGpB6KbQABDvLAALIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQfim0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakGIp9AAEO8sAAsgBEEANgIYIARBATYCDCAEQfig0AA2AgggBEIENwIQIARBCGpBmKfQABDvLAALIARBADYCGCAEQQE2AgwgBEH4oNAANgIIIARCBDcCECAEQQhqQain0AAQ7ywACyAEQQA2AhggBEEBNgIMIARB+KDQADYCCCAEQgQ3AhAgBEEIakG4p9AAEO8sAAsgKyAFIBIgDiAQIA8gCCBJIE8gCSAXIE4QpQEMAQsgBkEANgL8DiAGQQE2AvAOIAZB+KDQADYC7A4gBkIENwL0DiAGQewOakHopdAAEO8sAAsgFygCDCEQIBctAFIhGiACIEQgNSA2IDQQkRcgBkIANwPYByAGQewOaiIEIAZB2AdqQYELEIkcIAZBOGogBEHMgs4AEJ8hIAcoAhQhCSAHKAIIIQpBACEYAn9BACAHKAIMIghFDQAaQQAgCUUNABogCigCAAshFCAGKAI8IQQgBigCOCENIAcoAgQhDyAHKAIAIQ4gBygCECEMIAZB+ABqQQBB1Ab8CwAgBkEwahD9JyAGKQMwIWAgBkEANgL0DiAGQoCAgIAgNwLsDiAGQShqIAZB7A5qQYyHzgAQqiEgBkEANgLUByAGIBQ2AtAHIAZBADYCzAcgBkIBNwJwIAYgCTYCbCAGIAw2AmggBkGAAjYCZCAGIGA3AlQgBiAINgJQIAYgCjYCTCAGIA82AkggBiAONgJEIAYgBikDKDcCXCAHKAIgIRQgBygCJCIbRSAHKAIsIhVFckUEQCAUKAIAIRgLIAcoAhwhGSAHKAIYIScgBygCKCEtIAZBjAhqQQBB1Ab8CwAgBkEgahD9JyAGKQMgIWAgBkEANgL0DiAGQoCAgIAgNwLsDiAGQRhqIAZB7A5qQYyHzgAQqiEgBkEANgLoDiAGIBg2AuQOIAZBADYC4A4gBkIBNwKECCAGIBU2AoAIIAYgLTYC/AcgBkHABTYC+AcgBiBgNwLoByAGIBs2AuQHIAYgFDYC4AcgBiAZNgLcByAGICc2AtgHIAYgBikDGDcC8AcgBygCOCEUIAcoAjwiGEUgBygCRCIbRXJFBEAgFCgCACELCyAHKAI0IRUgBygCMCEZIAcoAkAhJyAGQaAPakEAQdQG/AsAIAZBEGoQ/ScgBikDECFgIAZBADYCiBYgBkKAgICAIDcCgBYgBkEIaiAGQYAWakGMh84AEKohIAZBADYC/BUgBiALNgL4FSAGQQA2AvQVIAZCATcCmA8gBiAbNgKUDyAGICc2ApAPIAZBoAQgECAQQaAETxsgECAaGzYCjA8gBiBgNwL8DiAGIBg2AvgOIAYgFDYC9A4gBiAVNgLwDiAGIBk2AuwOIAYgBikDCDcChA8gDiAPIAogCCAJIAwgDSAEIAZB8ABqIDUgNiA0EPQKIAYoAtgHIAYoAtwHIAYoAuAHIAYoAuQHIAYoAoAIIAYoAvwHIA0gBCAGQYQIaiA1IDYgNBD0CiAGKALsDiAGKALwDiAGKAL0DiAGKAL4DiAGKAKUDyAGKAKQDyANIAQgBkGYD2ogNSA2IDQQ9ApBAiAXKAIEIgmtIDUgNiA0EOUSQQQgFygCCCAJdq0gNSA2IDQQ5RIgDARAIE6tQv8BgyFgA0BBAiBgIDUgNiA0EOUSIAxBAWsiDA0ACwsCQCAHKAJwIi1FBEAgBygCeCIMQQYgDSAEIDUgNiA0ENQLDAELICsgBygCSCAHKAJMIC0gBygCeCIMIA0gBCA1IDYgNBCDCgsCQCAHKAJ0IiFFBEAgBygCgAEiDkECIA0gBCA1IDYgNBDUCwwBCyArIAcoAlAgBygCVCAhIAcoAoABIg4gDSAEIDUgNiA0EIMKCyAHKAJYIQ8gBygCXCEnQQAhCyMAQSBrIgkkAAJ/IAZBxABqIgooAiAiGiAMbCIIRQRAIAlBEGoQ/ScgCSgCECEUIAkoAhQMAQsgCUEYaiArIAgQuCkgCSgCGCEUIAkoAhwLIRsgCigCFCIYBEAgCigCECAYQQEQ+DoLIAogGzYCFCAKIBQ2AhAgCUEIaiAIELoeIAkoAgwhFSAJKAIIIQggCigCHCIYBEAgCigCGCAYQQF0QQIQ+DoLIAogFTYCHCAKIAg2AhgCQAJAAkACQCAMBEAgGkEBdCEKQQAhGEEAIRkDQCALICdGDQIgGSAbSw0DIBUgGUkNBCAPQYACIBpBgAIgDSAEIBQgGWogGCAbaiAIIBUgGGogNSA2IDQQ8gggCCAKaiEIIBggGmshGCAZIBpqIRkgD0GICGohDyAMIAtBAWoiC0cNAAsLIAlBIGokAAwDCyAnICdB5KzQABDDIQALIBkgG0H0rNAAEK87AAsgGSAVQYSt0AAQrzsACyAHKAJgIRggBygCZCEbIAcoAnwhFUEAIQsjAEEgayIMJAACfyAGQdgHaiIJKAIgIgogFWwiCEUEQCAMQRBqEP0nIAwoAhAhFCAMKAIUDAELIAxBGGogKyAIELgpIAwoAhghFCAMKAIcCyEPIAkoAhQiGgRAIAkoAhAgGkEBEPg6CyAJIA82AhQgCSAUNgIQIAxBCGogCBC6HiAMKAIMIRogDCgCCCEZIAkoAhwiCARAIAkoAhggCEEBdEECEPg6CyAJIBo2AhwgCSAZNgIYAkACQAJAAkAgFQRAIApBAXQhJ0EAIQhBACEJA0AgCyAbRg0CIAkgD0sNAyAJIBpLDQQgGEHABSAKQcAFIA0gBCAJIBRqIAggD2ogGSAIIBpqIDUgNiA0EPIIIBkgJ2ohGSAIIAprIQggCSAKaiEJIBhBiBZqIRggFSALQQFqIgtHDQALCyAMQSBqJAAMAwsgGyAbQeSs0AAQwyEACyAJIA9B9KzQABCvOwALIAkgGkGErdAAEK87AAsgBygCaCEYIAcoAmwhG0EAIQ8jAEEgayIMJAACfyAGQewOaiIJKAIgIgogDmwiCEUEQCAMQRBqEP0nIAwoAhAhCyAMKAIUDAELIAxBGGogKyAIELgpIAwoAhghCyAMKAIcCyEUIAkoAhQiGgRAIAkoAhAgGkEBEPg6CyAJIBQ2AhQgCSALNgIQIAxBCGogCBC6HiAMKAIMIRogDCgCCCEZIAkoAhwiCARAIAkoAhggCEEBdEECEPg6CyAJIBo2AhwgCSAZNgIYAkACQAJAAkAgDgRAIApBAXQhFUEAIQhBACEJA0AgDyAbRg0CIAkgFEsNAyAJIBpLDQQgGEGgBCAKIBAgDSAEIAkgC2ogCCAUaiAZIAggGmogNSA2IDQQ8gggFSAZaiEZIAggCmshCCAJIApqIQkgGEGIEWohGCAOIA9BAWoiD0cNAAsLIAxBIGokAAwDCyAbIBtB5KzQABDDIQALIAkgFEH0rNAAEK87AAsgCSAaQYSt0AAQrzsACyAGQQA2AogWIAZCgICAgMAANwKAFiAGIAZBgBZqQYyHzgAQnyEgBigCBCEJIAYoAgAhCCAEBEAgDSAEQQN0QQQQ+DoLAkAgEkUNACAHKAJUIQ8gBygCUCELIAcoAkwhECAHKAJIIRRBACEOAkADQAJAAkACQCAOID1HBEAgBkGIFmogBSAOQQR0aiIEQQhqKQIANwMAIAYgBCkCADcDgBYgBkHYB2ogBi8BjBYiDSA1IDYgNBCWFCAGQYAWaiA1IDYgNBCSDSAGKAKAFiEMIC0NAgNAIAxFDQQgHSAjcSIEICpPDQIgBkHEAGogBCA6ai0AACA1IDYgNBCWFCAMQQFrIQwgHUEBaiEdDAALAAsgPSA9Qfil0AAQwyEACyAEICpBiKbQABDDIQALA0AgDEUNASAwIQQgFiIwIAQgThDbIiEKICogHSAjcSIESwRAIAZBxABqIAQgOmotAAAiFiAKQf8BcSAUIBAgNSA2IDRBBhCsEiAMQQFrIQwgHUEBaiEdDAELCyAEICpBuKbQABDDIQALIAYoAoQWQf///w9xIgQgHWohHQJAAkAgBEUNACAdQQJrICNxIgQgKk8NAyAdQQFrICNxIgwgKk8NASAEIDpqLQAAITAgDCA6ai0AACEWIA1B/wBNDQAgBi8BjhYiBEEKdiAEQf8HcSENIAY1AogWAkAgIUUEQCAGQewOaiANIDUgNiA0EJYUDAELIAYvAYwWIgxBB3EhBAJAAkAgDEEGdiIKQQRLQQEgCnRBFXFFckUEQEEDIQwgBEEDSQ0BDAILQQMhDCAKQQdHIARBAktyDQELIAQhDAsgBkHsDmogDSAMIAsgDyA1IDYgNEECEKwSCyA1IDYgNBDlEgsgDkEBaiIOIBJHDQEMAwsLIAwgKkGoptAAEMMhAAsgBCAqQZim0AAQwyEACyAGQewOaiArEPYbIAZB2AdqICsQ9hsgBkHEAGogKxD2GyACBEAgNSA2IDQQtCkLIAkEQCAIIAlBA3RBBBD4OgsgBkHsDmoQiysgBkHYB2oQiysgBkHEAGoQiysgBkGQFmokACMAQUBqIgQkACAHICsQ4R4gB0EYaiArEOEeIAdBMGogKxDhHiAEQShqEP4nIAcoAkwhBSAEKAIoIQYgByAEKAIsNgJMIAcoAkggByAGNgJIIAUQgDEgB0EANgJwIARBIGoQ/icgBygCVCEFIAQoAiAhBiAHIAQoAiQ2AlQgBygCUCAHIAY2AlAgBRCAMSAHQQA2AnQgBEEANgI8IARCgICAgMAANwI0IARBGGogBEE0akGMh84AEKIhIAcoAlwhBSAHKAJYIQYgByAEKQMYNwJYIAUEQCAGIAVBiAhsQQQQ+DoLIAdBADYCeCAEQQA2AjwgBEKAgICAwAA3AjQgBEEQaiAEQTRqQYyHzgAQnCEgBygCZCEFIAcoAmAhBiAHIAQpAxA3AmAgBQRAIAYgBUGIFmxBBBD4OgsgB0EANgJ8IARBADYCPCAEQoCAgIDAADcCNCAEQQhqIARBNGpBjIfOABCgISAHKAJsIQUgBygCaCEGIAcgBCkDCDcCaCAFBEAgBiAFQYgRbEEEEPg6CyAHQQA2AoABIARBQGskACAHEIorIAdBGGoQiisgB0EwahCKKyAHKAJMIgQEQCAHKAJIIARBAnRBBBD4OgsgBygCVCIEBEAgBygCUCAEQQJ0QQQQ+DoLIAcoAlwiBARAIAcoAlggBEGICGxBBBD4OgsgBygCZCIEBEAgBygCYCAEQYgWbEEEEPg6CyAHKAJsIgQEQCAHKAJoIARBiBFsQQQQ+DoLDAQLQey70ABBIUGQvNAAEJ8pAAsgBSA0QaC80AAQwyEACyMAQYDJAGsiBCQAIARBjAhqIgUgOiAqIBEgRCAjEO8WAkAgJS0AUUUNACASID1NBEAgBCgCmAghBiAEKAKUCCEJIAQoApAIIQcgBCgCjAghDCAFEPMoICsgHSASIAwgByAJIAYgSSBPIAUgJUEAEKUBDAELIARBADYCnAggBEEBNgKQCCAEQfig0AA2AowIIARCBDcClAggBEGMCGpBlKvQABDvLAALICU1AgxCAX0iYHmnQT9zQQAgYEICWhshCyACIEQgNSA2IDQQkRdBDUIAIDUgNiA0EOUSAkAgEkGBAU8EQCAEQQRqIgVBAEGECPwLACAEQaPg//sHNgKICCAEQYwIaiIGQQBBhBb8CwAgBEGj4P/7BzYCkB4gBEGUHmoiCUEAQYQR/AsAIARBo+D/+wc2ApgvIARBnC9qIgdBAEGAAvwLACAEQZwxaiIMQQBBgAT8CwAgBEGcNWoiDUEAQcAF/AsAIARB3DpqIgpBAEGAC/wLACAEQdzFAGoiCEEAQYwB/AsAIARB6MYAaiIPQQBBmAL8CwAgOiAqIBEgIyAdID0gEiAFIAYgCRCSFiAFQYACIAQoAoQIQQggB0GAAiAMQYACIDUgNiA0EKMCIAZBwAUgBCgCjB5BCiANQcAFIApBwAUgNSA2IDQQowIgCUGgBCAEKAKULyALQQFqIAhBjAEgD0GMASA1IDYgNBCjAiA6ICogESAjIB0gPSASIAcgDCANIAogCEGMASAPQYwBIDUgNiA0ELENDAELQQAhByAEQYwIakEAQYAI/AsAIARB3DpqQQBBgAL8CwAgBEGUHmpBAEGABPwLACASBEAgESEFQQAhDANAAkACQCAMID1HBEAgHSAMQQR0aiIGKAIEIQ0gBigCACIGIQ4gBg0BDAILID0gPUGkq9AAEMMhAAsDQCAqIAUgI3EiCUsEQCAEQYwIaiAJIDpqLQAAQQJ0aiIJIAkoAgBBAWo2AgAgBUEBaiEFIA5BAWsiDg0BDAILCyAJICpBtKvQABDDIQALIAYgB2ohByAFIA1B////D3FqIQUgDEEBaiIMIBJHDQALCyAEQYwIakGAAiAHQQggBEHcOmoiBUGAAiAEQZQeaiIGQYACIDUgNiA0EKMCQThCg+DBscHImMkAIDUgNiA0EOUSQQNCACA1IDYgNBDlEkEcQoO4pxsgNSA2IDQQ5RIgOiAqIBEgIyAdID0gEiAFIAZBhpjiAEGQ++IAQcaX4gBBwABBkPriAEHAACA1IDYgNBCxDQsgAgRAIDUgNiA0ELQpCyAEQYDJAGokAAwBCyMAQZChAWsiBCQAIARBiMkAaiIFIDogKiARIEQgIxDvFgJAICUtAFFFDQAgEiA9TQRAIAQoApRJIQYgBCgCkEkhCSAEKAKMSSEHIAQoAohJIQwgBRDzKCArIB0gEiAMIAcgCSAGIEkgTyAFICVBABClAQwBCyAEQQA2AphJIARBATYCjEkgBEH4oNAANgKISSAEQgQ3ApBJIARBiMkAakHEq9AAEO8sAAsgBEEMaiIGQQBBhAj8CwAgBEGj4P/7BzYCkAggBEGUCGoiCUEAQYQW/AsAIARBo+D/+wc2ApgeIARBnB5qIgdBAEGEEfwLACAEQaPg//sHNgKgLyAEQaQvaiIMQQBBgAL8CwAgBEGkMWoiDUEAQYAE/AsAIARBpDVqIgpBAEHABfwLACAEQeQ6aiIIQQBBgAv8CwAgBEHkxQBqIg9BAEGMAfwLACAEQfDGAGoiC0EAQZgC/AsAIARBiMkAaiIFQQBBiNgA/AsAICUoAgwhECACIEQgNSA2IDQQkRcgOiAqIBEgIyAdID0gEiAGIAkgBxCSFkENQgAgNSA2IDQQ5RIgBkGAAkGAAkGAAiAFQYELIAxBgAIgDUGAAiA1IDYgNBDyCCAJQcAFQcAFQcAFIAVBgQsgCkHABSAIQcAFIDUgNiA0EPIIIAdBoARBjAEgECAFQYELIA9BjAEgC0GMASA1IDYgNBDyCCA6ICogESAjIB0gPSASIAwgDSAKIAggD0GMASALQYwBIDUgNiA0ELENIAIEQCA1IDYgNBC0KQsgBEGQoQFqJAALIEQgWWpBBGogNSgCAEEDdkkEQCBbIFw6AAAgXSBeOgAAICYgSSkCADcCACA1IFpB/wFxNgIAICZBCGogSUEIaikCADcCACArIAIgOiAqIBEgIyAlIEQgTyA1IDYgNEEBELUOCwsgASACRg0AQQFCASA1IDYgNBDlEkEBQgEgNSA2IDQQ5RIgNSA1KAIAQQdqIgFBeHE2AgAgNCABQQN2IgFNBEAgASA0Qczs0QAQwyEACyABIDZqQQA6AAALIBdB8AFqJAAgOygCLCIFQQN2IgEgACgCzAEiAk8NAiABQQFqIgQgAk8NAyABIAAoAsgBIgJqLQAAIQEgAiAEai0AACECIAAgBUEHcToAviogACAAKQPoASJgNwPwASAAIAEgAkEIdHI7AbgqIAApA/gBEMsrIGAQyysgACBgNwP4AU0NBSAAKAJoDQQMBQsgBCAFQbi/0AAQwyEACyACIARByL/QABCvOwALIAEgAkHYv9AAEMMhAAsgBCACQei/0AAQwyEACyBBEJQqQQA2AhgLAkACQCAAKALwKSICIAAoAowqIgFPBEACQCAAKQPwASJgUA0AIGCnIgVBAWsgI3EiBCACIAFrIgJPDQIgACAEIAAoAuwpIAFqIgZqLQAAOgC/KiBgQgFRDQAgBUECayAjcSIBIAJPDQMgACABIAZqLQAAOgDAKgsgAEIANwKUKiAAQgA3AwAgSSAmKQMANwMAIAMgOygCLEEDdjYCACBJQQhqICZBCGopAwA3AwAMBAsgASACQfi/0AAQrzsACyAEIAJBiMDQABDDIQALIAEgAkGYwNAAEMMhAAsgAyAbNgIAC0EBIRsLIDtB0ABqJAAgGw8LIAdBADYCKCAHQQE2AhwgB0GY184ANgIYIAdCBDcCICAHQRhqQfThzgAQ7ywACyASQQA2AiggEkEBNgIcIBJBmNfOADYCGCASQgQ3AiAgEkEYakH04c4AEO8sAAsgFiARQcDTzgAQwyEACyARIAVBsNHOABDDIQALIAsgFkHQ0s4AEMMhAAsgESAEQaDRzgAQwyEACyAEIAVBsM7OABDDIQALIBEgBUGwz84AEMMhAAsgC0EANgIYIAtBATYCDCALQZjXzgA2AgggC0IENwIQIAtBCGpB9ODOABDvLAALIAtBADYCGCALQQE2AgwgC0GY184ANgIIIAtCBDcCECALQQhqQYThzgAQ7ywACyAHQQA2AhggB0EBNgIMIAdBmNfOADYCCCAHQgQ3AhAgB0EIakH04M4AEO8sAAsgB0EANgIYIAdBATYCDCAHQZjXzgA2AgggB0IENwIQIAdBCGpBhOHOABDvLAALIAggBUHA0c4AEMMhAAsgCyAFQdDRzgAQwyEACyAVIAVB8NHOABDDIQALIBkgBUGA0s4AEMMhAAsgFSAWQeDSzgAQwyEACyAZIBZB8NLOABDDIQALIBYgBUHwzs4AEMMhAAsgFSAFQYDPzgAQwyEACyAZIAVBkM/OABDDIQALIBYgCEHA0M4AEMMhAAsgFSAIQdDQzgAQwyEACyAZIAhB4NDOABDDIQALIAhBADYCGEEAIAhBCGogCEEMaiAIQRhqQcjizgAQrysACyAIQQA2AhhBACAIQRBqIAhBFGogCEEYakHY4s4AEK8rAAtBAEEAQZzVzAAQwyEAC0HAAEHAAEHs28wAEMMhAAsgBkHAAEGc3MwAEMMhAAsgBkHAAEG83MwAEMMhAAtBAEEAQYzazAAQwyEACyAFQQFqIDFBnN3MABDDIQALIAUgPGogBEGs3MwAEMMhAAsgBUEBaiA5QazZzAAQwyEAC+UZAQ9/IwBBQGoiCyQAIAsgBjYCICALIAU2AhwgBEEBaiEOIAtBN2ohEyALQThqIRQgAy0AACERA0AgASgCCCEKAn8CQAJAAkAgBSAGRgRAQQAhDCAFIQcMAQsgBiAFayEMIAUhBwNAIAsgByIIQQFqIgc2AhwCQCAILQAAIgnAQQBODQAgCyAIQQJqIgc2AhwgCC0AAUE/cSEPIAlBH3EhDSAJQd8BTQRAIA1BBnQgD3IhCQwBCyALIAhBA2oiBzYCHCAILQACQT9xIA9BBnRyIQ8gCUHwAUkEQCAPIA1BDHRyIQkMAQsgCyAIQQRqIgc2AhwgDUESdEGAgPAAcSAILQADQT9xIA9BBnRyciEJCwJAAkACQAJAAkACQAJAAkAgCUEuTARAIAlBDUYgCUEJa0ECSXINASAJQSNHDQcMBAsgCUHbAEwEQCAJQS9GDQIgCUE/Rg0EDAcLIAlB3ABHBEAgCUGAgMQARw0HDAoLIAJB/wFxQQJGDQYgAS0AICINQQJGDQYgASAFIAwgBiAIayANIAIQ6hUgASgCGCIFRQ0CIAVBACABKAIcKAIUEQAADAILIAEgBSAMIAYgCGsgAS0AICACEOoVIAYgB2shDCAHIQUMBgsgAS0AICINQQJGDQQgASAFIAwgBiAIayANIAIQ6hULIAEoAgghCSABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgCUEBaiIFNgIIIAEoAgQhDCAJIApJDQIgCgRAIAogDGosAABBv39MDQMMAgsgCQ0BQQEhD0EAIQpBACEJIAcMCQsgAS0AIA0CIAEgBSAMIAYgCGtBACACEOoVIAsgBjYCICALIAg2AhwgCCEHDAYLIAkgDGosAABBv39MDQBBASEPDAYLIAwgBSAKIAlBiI3EABCjNgALIAEoAhgiDQRAIA0gASgCHCAJIAtBHGoQkAwLIAJB/wFxDQAgASgCCCIJIARNDQAgASgCBCENAkAgCSAOTQ0AIA0gDmosAABBv39KDQAgDSAJIA4gCUHYjMQAEKM2AAsgCSAOa0ECRw0AIA0gDmoiCS0AAEHfAXFBwQBrQf8BcUEZSw0AIAktAAFBOkcNACABIAUgDCAGIAhrIgwgAS0AIEEAEOoVIAEoAgghBSABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgBUEBajYCCCAKQQFqIQogCCEFCyAGIAdHDQALCyABIAUgDEEAIAEtACAgAhDqFQsgASgCBCEMIAEoAggiCSAKTwRAQQAhDyAKRSAJIApNcg0BIAogDGosAABBv39KDQELIAwgCSAKIAlB+IzEABCjNgALIAcLIQUCQAJAAkAgCiAMaiIHIAkgCmsiCEGYjcQAQQIQwS4NACAHIAhBmo3EAEEGEMEuDQAgByAIQaCNxABBBhDBLg0AIAcgCEGmjcQAQQYQwS4NACAHIAhBrI3EAEEGEMEuDQAgByAIQbKNxABBBBDBLg0AIAcgCEG2jcQAQQQQwS4NACAHIAhBuo3EAEEEEMEuDQAgByAIQb6NxABBBBDBLg0AAkAgByAIQcKNxABBARDBLg0AIAcgCEHDjcQAQQMQwS4NACAHIAhBxo3EAEEDEMEuDQAgAkH/AXEgCiAOR3IgCEECR3INAiAHLQAAQd8BcUHBAGtB/wFxQRlLDQIgBy0AASIIQfwARyAIQTpHcQ0CIAsgBzYCJCALIAkgDGo2AigCQCALQSRqEPUWIgdBgIDEAEYNAAJAAkAgASgCCCIIIA5PBEAgDkUgCCAOTXJFBEAgASgCBCAOaiwAAEG/f0wNAgsgASAONgIICwwBC0GohcQAQTBBzI3EABCfKQALIAEoAgghCiABAn9BASAHQYABSSIJDQAaQQIgB0GAEEkNABpBA0EEIAdBgIAESRsLIgwQ2C0gASgCBCABKAIIaiEIAkACQCAJRQRAIAdBgBBJDQEgB0GAgARPBEAgCCAHQT9xQYABcjoAAyAIIAdBEnZB8AFyOgAAIAggB0EGdkE/cUGAAXI6AAIgCCAHQQx2QT9xQYABcjoAAQwDCyAIIAdBP3FBgAFyOgACIAggB0EMdkHgAXI6AAAgCCAHQQZ2QT9xQYABcjoAAQwCCyAIIAc6AAAMAQsgCCAHQT9xQYABcjoAASAIIAdBBnZBwAFyOgAACyABIAogDGo2AgggASgCCCEHIAFBARDYLSABKAIEIAEoAghqQTo6AAAgASAHQQFqNgIIIA9FDQAgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIAdBAmo2AggLIBFBAXFBACERRQ0CIAEoAhgiBwRAIAdBBSABKAIcKAIUEQAACyADQQA6AAAMAgsCQAJAIAEoAggiByAKSQRAIAchCgwBCyAKRSAHIApNckUEQCABKAIEIApqLAAAQb9/TA0CCyABIAo2AggLIAEoAgQhByALQS82AiQgCgR/IAtBJGpBASAHIApqQQFrQQEQwS4NAyABKAIIBUEACyEHIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAHQQFqNgIIDAILQaiFxABBMEGMjsQAEJ8pAAsCQAJAAkAgASgCCCIHIApJBEAgByEKDAELIApFIAcgCk1yRQRAIAEoAgQgCmosAABBv39MDQILIAEgCjYCCAsgASgCBCEHIAtBLzYCJCAKRQ0BIAtBJGpBASAHIApqQQFrQQEQwS5FDQEgASgCBCENAkAgASgCCCIKQQFrIggEQCAKRQ0BIAggDWosAABBv39MDQELIAsgCDYCNEEAIQcgC0EANgIwIAsgCDYCLCALIA02AiggC0EBOgA8IAtBLzYCJCALQS82AjggCCEJA0AgC0EQaiATIAstADxqLQAAIAcgDWogCSAHaxCjCiALKAIQQQFxRQ0DAkAgCygCMCIHIAsoAhRqIgkgCy0APCIQQQFrIhJJDQAgCSASayIMIBBqIhUgDEkgCCAVSXINAAJAAkACQAJAIBBBBUkEQCAMIA1qIgcgECAUIBAQwS5FBEAgCygCMCEHDAYLIAQgDEsNCQJAIAkgEkYNACAKIAxNBEAgCiAMRg0BDAYLIAcsAABBv39MDQULIAogDEYNAyAHLQAAIghBI2siCUEcS0EBIAl0QYGggIABcUVyDQEMAgsgEEEEQZSGxAAQsDsACyAIQdwARw0BCyAKIAxrIghBAUYNAAJAAkAgBywAASIKQb9/SgRAIAhBAWsiCEECSSAKQd8BcUHBAGtB/wFxQRlLcg0DIActAAIiCkH8AEcgCkE6R3ENAyAIQQJGDQkgBy0AAyIHQSNrIghBHE0NAQwCCyAHIAhBASAIQeSUxAAQozYAC0EBIAh0QYGggIABcQ0HCyAHQdwARg0GCyABKAIIIgpFDQVBfyEHAkAgASgCBCAKaiIIQQFrLAAAQQBODQACfyAIQQJrLQAAIgnAIgxBv39KBEAgCUEfcQwBCyAMQT9xAn8gCEEDay0AACIJwCIMQb9/SgRAIAlBD3EMAQsgDEE/cSAIQQRrLQAAQQdxQQZ0cgtBBnRyCyIIQQJJDQBBfiEHIAhBIEkNAEF9QXwgCEGACEkbIQcLIAEgByAKajYCCAwFCyANIAogDCAKQcyPxAAQozYACyALIAk2AjQgCCAJSQ0DIAcgCU0NAAsMAgsgDSAKQQAgCEG8j8QAEKM2AAtBqIXEAEEwQayOxAAQnykACyABIAIgBBCuGyAPRQ0BIAEoAgghByABKAIEIQggC0EvNgIkIAcEfyALQSRqQQEgByAIakEBa0EBEMEuDQEgASgCCAVBAAshByABQQEQ2C0gASgCBCABKAIIakEvOgAAIAEgB0EBajYCCAsgDw0BCwsgAkH/AXFFBEAgASgCCCECIAEoAgQhBwJAIARFDQACQCACIARNBEAgAiAERw0BDAILIAQgB2osAABBv39KDQELQdiFxABBK0HMjsQAEJ8pAAsCQCACIARPBEAgC0EkaiACIARrIgJBAEEBQQEQoBggCygCKCEIIAsoAiRBAUcNASAIIAsoAixBzI7EABD9LwALIwBBMGsiACQAIAAgAjYCBCAAIAQ2AgAgAEEDNgIMIABBrMWJATYCCCAAQgI3AhQgACAAQQRqrUKAgICAsAeENwMoIAAgAK1CgICAgLAHhDcDICAAIABBIGo2AhAgAEEIakHMjsQAEO8sAAsgCygCLCEDIAEgBDYCCCACBEAgAyAEIAdqIAL8CgAACyALIAI2AiwgCyADNgIoIAsgCDYCJCABKAIIIQQgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIARBAWo2AgggC0EIaiADIAJBLxDJEyABIAsoAggiASABIAsoAgxqEIEmIAtBJGoQ3jsLIAAgBjYCBCAAIAU2AgAgC0FAayQAC5kZAil/F34jAEGQAWsiAyQAIAEoAgQhAiADQYABaiABKAIIIhVBAEEIQcACEKAYIAMoAoQBIRMCQCADKAKAAUEBRwRAIAMoAogBIRYCQCATRQ0AIAIgFUHAAmxqIR4gA0H+AGohFyATIRgDQCACIB5GDQEgAigCvAIiGSAZKAIAIgFBAWo2AgAgAUEASA0DIANBzABqIAJBgAJqENYeAkAgAigCjAJBgICAgHhHBEAgA0HYAGogAkGMAmoQ3SAMAQsgA0GAgICAeDYCWAsgAikD+AEhNyACKQPwASE4IAIpA+gBITkgAigC1AEhHyACKALQASEgIAIpA+ABITogAikD2AEhO0IAITJCACEzIAIoAgBBAUYEQCACKQMIITxCASEzCyACKAIQQQFGBEAgAikDGCE9QgEhMgtCCCErIAIpA2AiMEIIUgRAAn8CQAJ+AkACQAJAAkACQAJAAkACQCAwp0EBaw4HAQIDBAUGBwALIAItAIoBIQsgAi0AiQEhDCACLQCIASEBIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAi0AjQEhByACLQCMASEIQgAhKyADQeQAaiEJIAItAIsBDAkLIAMgAigCjAEiCEEIdjoAZCAIQRB2IQ0gAigCiAEhASACLQCbASEHIAItAJoBIQQgAi0AmQEhBiACLQCYASEFIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAigClAEhDiACKAKQASEPQgEhKwwHCyACQZoBai0AACEEIAItAKsBIQcgAi0AqgEhECACLQCpASERIAItAKgBIRIgAikDoAEhMSACKAKcASEKIAIvAY4BIQ0gAi0AjAEhCCACKQOAASEuIAIpA3ghLCACKQNwIS8gAikDaCEtIAIpA5ABISsgAi8BmAEgAigCiAEhASACLQCNASEGIAMgAi0AmwE6AEAgAyAGOgBkIAFBEHYhCyABQQh2IQwgBEEQdHIiBUEIdiEGICtCIIinIQ4gK6chD0ICISsgA0EwaiEJIAFBGHYMBwtBACEFQQAhASACKAKIAUEBRgRAIAIoApQBIQ4gAigCkAEhDyACLwGOASENIAItAI0BIQQgAi0AjAEhCEEBIQELIAIoApgBQQFGBEAgAikCoAEhMSACKAKcASEKQQEhBQsgAyAEOgBkIANBADoAQCACLQCrASEHIAItAKoBIRAgAi0AqQEhESACLQCoASESIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS1CAyErIANBMGohCUEAIQtBACEMQQAhBEEAIQZBAAwGCyADIAIoAowBIghBCHY6AGQgCEEQdiENIAIoApQBIQ4gAigCiAEhASACLQCbASEHIAItAJoBIQQgAi0AmQEhBiACLQCYASEFIAIpA4ABIS4gAikDeCEsIAIpA3AhLyACKQNoIS0gAigCkAEhD0IEISsMBAsgAkGaAWotAAAhBCACLQCrASEHIAItAKoBIRAgAi0AqQEhESACLQCoASESIAIpA6ABITEgAigCnAEhCiACLwGOASENIAItAIwBIQggAikDgAEhLiACKQN4ISwgAikDcCEvIAIpA2ghLSACKQOQASErIAIvAZgBIAIoAogBIQEgAi0AjQEhBiADIAItAJsBOgBAIAMgBjoAZCABQRB2IQsgAUEIdiEMIARBEHRyIgVBCHYhBiArQiCIpyEOICunIQ9CBSErIANBMGohCSABQRh2DAQLQQAhCkEAIQEgAigCiAFBAUYEQAJAIAIoAowBIgEEQCADQfAAaiACQZgBaiACKAKQASACKAKUASABKAIAEQUADAELIANBADYCcAtBASEBCyACKAKcAUEBRgRAAkAgAigCoAEiBARAIANBgAFqIAJBrAFqIAIoAqQBIAIoAqgBIAQoAgARBQAMAQsgA0EANgKAAQtBASEKC0IAISxCACEtIAIoAmhBAUYEQCACKQNwIS9CASEtCyACKAJ4QQFGBEAgAikDgAEhLkIBISwLIAMgAy0AcToAZCADIAMtAH86AEAgAi0AswEhByACLQCyASEaIAItALEBIRsgAi0AsAEhHCAXLQAAIQQgAy8BciENIAMtAHAhCCADKAJ0IQ8gAygCeCEOIAMpA4ABITEgAy0AiAEhEiADLQCJASERIAMtAIoBIRAgAy8BfCADIAMtAIsBOgAwIARBEHRyIgVBCHYhBiADQSBqIQlCBgwBC0EAIQpBACEBIAIoAogBQQFGBEACQCACKAKMASIBBEAgA0HwAGogAkGYAWogAigCkAEgAigClAEgASgCABEFAAwBCyADQQA2AnALQQEhAQsgAigCnAFBAUYEQAJAIAIoAqABIgQEQCADQYABaiACQawBaiACKAKkASACKAKoASAEKAIAEQUADAELIANBADYCgAELQQEhCgtCACEsQgAhLSACKAJoQQFGBEAgAikDcCEvQgEhLQsgAigCeEEBRgRAIAIpA4ABIS5CASEsCyADIAMtAHE6AGQgAyADLQB/OgBAIAItALMBIQcgAi0AsgEhGiACLQCxASEbIAItALABIRwgFy0AACEEIAMvAXIhDSADLQBwIQggAygCdCEPIAMoAnghDiADKQOAASExIAMtAIgBIRIgAy0AiQEhESADLQCKASEQIAMvAXwgAyADLQCLAToAMCAEQRB0ciIFQQh2IQYgA0EgaiEJQgcLISsgAygCjAEhIUEAIQtBACEMQQAMAQsgA0FAayEJQQAhC0EAIQxBAAshFCAJIAc6AAAgBUH/AXEgBkH/AXFBCHQgBEEQdHJyIQQgAUH/AXEgC0H/AXFBEHQgFEEYdHIgDEH/AXFBCHRyciEHIAMtAGQhDCADLQBAIQsgAy0AMCEJIAMtACAhBQsCQCACKAKYAkGAgICAeEcEQCADQeQAaiACQZgCahC1FgwBCyADQYCAgIB4NgJkC0IAITBCACE0IAIoAiBBAUYEQCACKQMoIT5CASE0CyACKAK8ASEUIAIoArgBIQYgAigCMEEBRgRAIAIpAzghP0IBITALIAIoAsQBISIgAigCwAEhI0IAITVCACE2IAIoAkBBAUYEQCACKQNIIUBCASE2CyACKALMASEkIAIoAsgBISUgAigCUEEBRgRAIAIpA1ghQUIBITULAkAgAigCpAJBgICAgHhHBEAgA0HwAGogAkGkAmoQpR0MAQsgA0GAgICAeDYCcAsgFiAdQcACbGohAQJAIAIoArACQYCAgIB4RwRAIANBgAFqIAJBsAJqEKUdDAELIANBgICAgHg2AoABCyAdQQFqIR0gAkHAAmohAiADQcgAaiImIANB1ABqKAIANgIAIAMgAykCTDcDQCADQThqIicgA0HgAGooAgA2AgAgAyADKQJYNwMwIANBKGoiKCADQewAaigCADYCACADIAMpAmQ3AyAgA0EYaiIpIANB+ABqKAIANgIAIAMgAykCcDcDECADQQhqIiogA0GIAWooAgA2AgAgAyADKQKAATcDACABQZoBaiAEQRB2OgAAIAEgBDsBmAEgASA3NwP4ASABIDg3A/ABIAEgOTcD6AEgASA6NwPgASABIDs3A9gBIAEgHzYC1AEgASAgNgLQASABICQ2AswBIAEgJTYCyAEgASAiNgLEASABICM2AsABIAEgFDYCvAEgASAGNgK4ASABIAU6ALMBIAEgGjoAsgEgASAbOgCxASABIBw6ALABIAEgITYCrAEgASAJOgCrASABIBA6AKoBIAEgEToAqQEgASASOgCoASABIDE3A6ABIAEgCjYCnAEgASALOgCbASABIA42ApQBIAEgDzYCkAEgASANOwGOASABIAw6AI0BIAEgCDoAjAEgASAHNgKIASABIC43A4ABIAEgLDcDeCABIC83A3AgASAtNwNoIAEgKzcDYCABIEE3A1ggASA1NwNQIAEgQDcDSCABIDY3A0AgASA/NwM4IAEgMDcDMCABID43AyggASA0NwMgIAEgPTcDGCABIDI3AxAgASA8NwMIIAEgMzcDACABQYgCaiAmKAIANgIAIAEgAykDQDcDgAIgASADKQMwNwKMAiABQZQCaiAnKAIANgIAIAEgAykDIDcDmAIgAUGgAmogKCgCADYCACABIAMpAxA3AqQCIAFBrAJqICkoAgA2AgAgAUG4AmogKigCADYCACABIAMpAwA3A7ACIAEgGTYCvAIgGEEBayIYDQALCyAAIBU2AgggACAWNgIEIAAgEzYCACADQZABaiQADwsgEyADKAKIAUHQtcIAEP0vCwAL/SYDEX8FfgF9IwBB8ABrIgokAAJAIAJFDQACQAJAIAEtAABBK2sOAwACAQILQQEhDAwBC0EBIQxBASETCwJAAkACQAJAAkACQAJ/AkACQAJAQQRBAgJ/AkACQAJAAkAgAiAMSwRAAkAgAiAMIgZrIg1BCEkNACANIQMDQCABIAZqKQAAIhRCxoyZsuTIkaPGAHwgFEKw4MCBg4aMmDB9IhSEQoCBgoSIkKDAgH+DQgBSDQEgF0KAwtcvfiAUQgp+IBRCCIh8IhRCEIhC/4GAgPAfg0KBgICAgOIJfiAUQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFyAGQQhqIQYgA0EIayIDQQdLDQALCwJAIAIgBksEQEEAIAJrIQkgBkEBaiEDIAEgBmohBgJAA0AgBi0AACIHQTBrIgRB/wFxQQlLDQEgASADakEAIAIgA0sbIQYgF0IKfiAErUL/AYN8IRcgCSADQQFqIgNqQQFHDQALIAEgDGohCCANrSEWIA0hCyACIQdBACEDIAIhBgwFCyADQQFrIQYgB0EuRg0BC0EAIQMgBiEEDAILAkAgAiADa0EISQRAIAMhBAwBCyACIANrIQsgAyEEA0AgASAEaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBdCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRcgBEEIaiEEIAtBCGsiC0EHSw0ACwsCQCACIARNDQADQCABIARqLQAAQTBrIgdB/wFxQQlLDQEgF0IKfiAHrUL/AYN8IRcgAiAEQQFqIgRHDQALIAIhBAsgASADaiESQgAgBCADayIFrX0hGEEBIQMMAQsgACAMNgIEIABBAzYCAAwOCyABIAxqIQggBiAMayILrSEWIAIgBE0EQCAEIQcMAQsgASAEai0AACIHQcEAa0H/AXFBGklBBXQgB3IiB0HlAEYgBSALaiIJRQ0DGiAHQeUARwRAIAQhBwwCCwJAIARBAWoiByACTw0AAkACQCABIAdqLQAAQStrDgMBAgACCyAEQQJqIQdBASEODAELIARBAmohBwtBBSEPIAIgB00NCCAHIQMCQANAIAEgA2otAABBMGsiBEH/AXFBCUsNASAVQgp+IAStQv8Bg3wgFSAVQoCAgIABUxshFSACIANBAWoiA0cNAAsgAiEDCyADIAdGDQhCACAVfSAVIA4bIhUgGHwhGCADIQcMAQsgBSALaiIJRQ0BC0EAIAlBEyIETQ0FGiABIAxqIQ8gDCACayEOIAlBE2shEEEAIQMDQCADIA9qLQAAIhFBMEcNAyAOIANBAWoiA2oNAAsgECANayIDQQAgAyAQTRshECACIQkMAwsgByEEQQALIANyIgMbIQ8gBCAMIAMbIQcMBAsgECADayIJQQAgCSAQTRshECACIAMgDGoiCSARQS5GIAIgCUtxIhFqIglNBEAgCSEDDAILIA8gEWogA2ohDyAOIBFqIANqIQ4gCSEDA0AgDy0AAEEwRw0CIA9BAWohDyADQQFqIQMgDkEBaiIODQALCyACIQMLIAMgCWsiESAQSQRAQQAhAwJAIAYgDEYNAANAIAMgCGotAABBMEcNASALIANBAWoiA0cNAAsgCyEDC0IAIRcCQCALIANrIgZBCEkNACAGQQhrIQYDQCADIAhqKQAAIhRCxoyZsuTIkaPGAHwgFEKw4MCBg4aMmDB9IhSEQoCBgoSIkKDAgH+DQgBSDQEgF0KAwtcvfiAUQgp+IBRCCIh8IhRCEIhC/4GAgPAfg0KBgICAgOIJfiAUQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFyADQQhqIQMgBEEIayIEQQlJDQEgBkEHSyAGQQhrIQYNAAsLIARFIQ4CQCAERSADIAtPckUEQANAIBdCCn4gAyAIai0AAEEwa61C/wGDfCEXIARBAUYhDiAEQQFrIQYgA0EBaiIDIAtPDQIgBEEBRyAGIQQNAAwCCwALIAQhBgsCQCAODQACQCASBEBBACEDAkAgBUUgF0IAUnINAANAIAMgEmotAABBMEcNASAFIANBAWoiA0cNAAsgBSEDCyAGQQlJDQEgBSADayIEQQhJDQEgBEEIayEEA0AgAyASaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0CIBdCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRcgA0EIaiEDIAZBCGsiBkEJSQ0CIARBB0sgBEEIayEEDQALDAELQcDWgAEQsjsAC0IAIRYgBkUgAyAFT3INACAGQQFrIQQDQCAXQgp+IAMgEmotAABBMGutQv8Bg3whFyADQQFqIgMgBU8NASAEIgZBAWshBCAGDQALCyAVIAOtfSAWfCEYCyAQIBFLCyEDQQIhDyACIAdGDQELIA1BA0kNA0EAIQMgAiAMayIEQQAgAiAETxshBSABIAxqIQsgDEEDaiEIA0AgA0EDRgRAQwAAwH8hGQwECyADIAVGDQIgA0Hg1oABaiEGIAMgC2ogA0EBaiEDLQAAIgQgBi0AACIBRiABIARzQSBGcg0ACwwBCyAKIAM6AEkgCiATOgBIIAogCzYCRCAKIAg2AkAgCiAFNgI8IAogEjYCOCAKIBc3AzAgCiAYPgIoIAogGEIgiD4CLCAKQSBqIQJBACEBIwBBEGsiByQAAkACfSAKQShqIgQpAwAiFUJ2UyAVQhFVcg0BIAQpAwgiFEKAgIAIVg0BIAQtACFBAXENASAVQgtZBEAgByAUQgAgFadBA3RBsPGAAWopAwBCABCoHiAHKQMIUEUNAiAHKQMAIhRCgICACFYNAiAUtUP5AhVQlAwBCyAVpyEBIBS1IRkgFUIAWQRAIAFBAnRBwO+AAWoqAgAgGZQMAQsgGUHA74ABIAFBAnRrKgIAlQsiGYwgGSAELQAgGyEZQQEhAQsgAiAZOAIEIAIgATYCACAHQRBqJAAgCigCIEEBcQRAIAoqAiQhGSAAQTE2AgAgACAZOAIEDAQLIApB0ABqIAopAygiFCAXEMALAkACQAJAIANFIAooAlgiBkEASHJFBEAgCkHgAGogFCAXQgF8EMALIAooAmggBkYEQCAKKQNQIhUgCikDYFENAwsgFKciA0HWAmoiAUGKBUsNAyAXeSIUpyECIApBEGogAUEEdEHwmIEBaiIBKQMAQgAgFyAUhiIVQgAQqB4gCikDGCIXQv//////B4NC//////8HUQRAIAopAxAhFCAKIAEpAwhCACAVQgAQqB4gCikDCEJ/hSAUVK0gF3whFwsgA0HqpA1sQRB1IBdCP4hQIgEgAmprQen+AWshBiAXIAGthiEVDAELIAopA1AhFSAGQQBODQELIApB4ABqIQ0gBkGAgAJqIQsjAEHwC2siBSQAIApBKGoiAykDACEWIAMpAwgiFEKQzgBaBEADQCAWQgR8IRYgFEL/wdcvViAUQpDOAIAhFA0ACwsgFELkAFoEQANAIBZCAnwhFiAUQo/OAFYgFELkAIAhFA0ACwsgFEIKWgRAA0AgFkIBfCEWIBRC4wBWIBRCCoAhFA0ACwsgBUH8A2oiAiADQfIAEKYBIAVBBGoiASACQfgD/AoAAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgFqcgBSgC9AdrQQFqIgdBAEgEQCAFQfgHaiABQfgD/AoAAAJ/IAtBAWsiBkFXTARAIBVBwABBASALayIBIAFBwABOG0E/ca2IQgAgAUE/TBsiFkL///8DVgwBC0IAIBVCKIhC////A4MgC0EoaiICQf4BSiIBGyEWQf8BIAIgARsLIQECfyABQRd0rSAWhKciAkGAgID8B3EiAUUEQCAWp0H///8DcSEIQep+DAELIAJB////A3FBgICABHIhCCABQRd2QZcBawshASAFQQE7AfAHIAUgCEEBdEEBcjYC/AMgBUEANgKABCAFQfwDakEAIAdrEM4KRQ0BAkAgASAHayIHQQBMBEAgB0EATg0JQQAgB2siB0EfcSIEDQEMCAsgB0EfcSIERQ0FQSAgBGshAwJAIAUvAfAHIgFFBEBBACECDAELIAFBAnQhCSAFQfwDaiEIQQAhAgNAIAggAiADdiAIKAIAIgIgBHRyNgIAIAhBBGohCCAJQQRrIgkNAAsLIAIgA3YiAkUNBSAFLwHwByIBQfwASw0GIAVB/ANqIAFBAnRqIAI2AgAgBSAFLwHwB0EBajsB8AcMBQtBICAEayEDAkAgBS8B7AsiAUUEQEEAIQIMAQsgAUECdCEJIAVB+AdqIQhBACECA0AgCCACIAN2IAgoAgAiAiAEdHI2AgAgCEEEaiEIIAlBBGsiCQ0ACwsgAiADdiICRQ0GIAUvAewLIgFB/ABLDQggBUH4B2ogAUECdGogAjYCACAFIAUvAewLQQFqOwHsCwwGCyAFQQRqIAcQzgpFDQIgB0EfcSIERQ0BQSAgBGshAwJAIAUvAfgDIgFFBEBBACECDAELIAFBAnQhCSAFQQRqIQhBACECA0AgCCACIAN2IAgoAgAiAiAEdHI2AgAgCEEEaiEIIAlBBGsiCQ0ACwsgAiADdiICRQ0BIAUvAfgDIgFB/ABLDQIgBUEEaiABQQJ0aiACNgIAIAUgBS8B+ANBAWo7AfgDDAELQYDWgAEQsjsACyAFLwH4AyEBAn4CQAJAIAdBIEkEQCABIQIMAQsgB0EFdiIDIAFqIgJB/QBLDQMgAUUEQEEAIQhCACEWQgAhFAwCCyADQQJ0IQQgAUECdCIDBEAgBUEEaiIBIARqIAEgA/wKAAALIAQEQCAFQQRqQQAgBPwLAAsgBSACOwH4AwtCACEWQgAhFAJAAn4CQAJAAkAgAkH//wNxIggOAwUBAgALIAhBAnQiCCAFQQRqaiIBQQxrKQIAIhVBICABQQRrKAIAIgNnIgFrrYggA60gAUEgc60iFIaEIRZBACEJIBUgFIZCAFINAyAFQQxrIQMDQCAIQQxGIgkNBCADIAhqIAhBBGshCCgCAEUNAAsMAwsgBSAIQQJ0aigCACIBrSABZ0Egc62GDAELIAhBAnQgBWpBBGspAgAiFCAUeYYLIRZBASEJC0EAIQMCQCACQf//A3EiAkUNACAFIAJBAnRqIgFFDQAgASgCAGchAwsgFkIoiCEUIAJBBXQgA2shCEIBIBZC//////8fgyIVQoCAgICAEFYgCSAVQoCAgICAEFJyRXINARoLIBZC//////8/g0KAgICAgDBRrQshFSANQf8BQf4AQf8AIBQgFXwiFEKAgIAIVBsgCGoiASABQf4BSyIBGzYCCCANQgAgFEL///8DgyABGzcDAAwIC0Gw1oABELI7AAsgB0EgSQ0CIAdBBXYiASAFLwHwByICaiIDQf0ASw0AIAJFDQIgAUECdCEEIAJBAnQiAgRAIAVB/ANqIgEgBGogASAC/AoAAAsgBARAIAVB/ANqQQAgBPwLAAsgBSADOwHwBwwCC0Gg1oABELI7AAsgB0EgSQ0AIAdBBXYiASAFLwHsCyICaiIDQf0ASw0BIAJFDQAgAUECdCEEIAJBAnQiAgRAIAVB+AdqIgEgBGogASAC/AoAAAsgBARAIAVB+AdqQQAgBPwLAAsgBSADOwHsCwsgBS8B7AsiAyAFLwHwByIBRg0BIAEgA0kgASADS2sMAgtBkNaAARCyOwALIAFBAnQhAiADQQJ0IQggBUH4A2ohByAFQfQHaiEEA0BBACAIRSACRXINARogAiAHaiEDIAQgCGogAkEEayECIAhBBGshCCgCACIJIAMoAgAiAUYNAAsgASAJSSABIAlLawshAiANAn8gBkFYTgRAIBVCKIghFEIAAn4CQAJAAkAgAkH/AXEOAgECAAtCAAwCCyAUQgGDDAELQgELIBR8IhRC////A4NBKEEpIBRCgICACFQbIAtqIgJB/gFKIgEbIRZB/wEgAiABGwwBC0IAIRYgFUHAAEEBIAtrIgEgAUHAAE4bQT9xrYhCACABQT9MGyEUAkACQAJAIAJB/wFxDgIAAQILIBRCAYMhFgwBC0IBIRYLIBQgFnwiFkL///8DVgs2AgggDSAWNwMACyAFQfALaiQAIAooAmghBiAKKQNgIRULIABBMTYCACAAIAZBF3StIBWEp74iGYwgGSATGzgCBAwECyABQYsFQdDWgAEQwyEACwJAIA1BCEkNACAMQQhyIQFBACEDA0AgA0EIRgRAQwAAgH8hGSABIQgMAwsgAyAFRg0BIANB5taAAWohCSADIAtqIANBAWohAy0AACIGIAktAAAiBEYgBCAGc0EgRnINAAsLQQAhAwNAIANBA0YEQEMAAIB/IRkMAgsgAyAFRg0CIANB49aAAWohBiADIAtqIANBAWohAy0AACIEIAYtAAAiAUYgASAEc0EgRnINAAsMAQsgAiAIRw0AIABBMTYCACAAIBmMIBkgExs4AgQMAQsgACAHNgIEIAAgDzYCAAsgCkHwAGokAAuaGAIGfw1+IwBB8AJrIgQkACAEIAM2AgwgBCABIAIQ9AggBCAEKAIEIgE2AhQgBCAEKAIAIgI2AhAgBEEBOwHEAiAEIAE2AsACIARBADYCvAIgBEEBOgC4AiAEQS42ArQCIAQgATYCsAIgBEEANgKsAiAEIAE2AqgCIAQgAjYCpAIgBEEuNgKgAiAEQRhqIARBoAJqENIVAkACQAJAAkACQAJAAkACQCAEKAIgIghBAk0EQCAIRQ0DIAQoAhwiBigCACEBIAYoAgQiAg0BQQAhAgwCCyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAYLAkACQCABLQAAQStrDgMBAgACC0EBIQkgAkEBRwRAIAEsAAFBv39MDQQLIAJBAWshAiABQQFqIQEMAQsgAkEBRwRAIAEsAAFBv39MDQQLIAJBAWshAiABQQFqIQELIAQgAjYCKCAEIAE2AiRBASEHIAhBAkYEQCAGKAIIIQcgBigCDCEFCyAEIAU2AjAgBCAHNgIsIAJFDQMgAS0AAEEwa0H/AXFBCkkNAyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAQLQQBBAEGUm4ABEMMhAAsgASACQQEgAkGkm4ABEKM2AAsgASACQQEgAkG0m4ABEKM2AAsCQCAFRQ0AIActAABBMGtB/wFxQQpJDQAgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwBCwJAAkACQAJAAkAgAyAFTwRAIANBACADIAVLGyIBQYCABE8NASAEIAE7AfwBIARBADYC+AEgBEHMATYC9AEgBEEBNgK0AiAEQfybgAE2ArACIARBATYCpAIgBEH0m4ABNgKgAiAEQQI2AqwCIAQgBEEsajYC8AEgBCAEQfABaiICNgKoAiAEQcABaiIBIARBoAJqIgMQmQ4gBEECNgKkAiAEQZScgAE2AqACIARCAjcCrAIgBEH+DzYC/AEgBEHMATYC9AEgBCACNgKoAiAEIAE2AvgBIAQgBEEkajYC8AEgBEE0aiADEJkOIAEQ3jsMBQsgBEGgAmoiBiAHIAUQzBAgBCgCoAJBAXENAyAEIAQpA8gCIhI3A1ggBCAEKQPAAiITNwNQIAQgBCkDuAIiFDcDSCAEIAQpA7ACIhU3A0AgBEHwAWpCCkIAELIuIAYgBCkD8AEgBCkD+AEgBCkDgAIgBCkDiAIgBSADaxDfASAEKAKgAkEBRgRAIAAgBCkCpAI3AgQgAEEMaiAEKAKsAjYCACAEKQOwAiEKIABBATYCACAAIAo3AxAMBgsgBCkDyAIhDiAEKQPAAiEPIAQpA7gCIRAgBCkDsAIhESAEQaACaiIDQgJCABCyLiADIBEgECAPIA4gBCkDoAIgBCkDqAIgBCkDsAIgBCkDuAIQmggCfiAELQCgAkEBRgRAQoCAgICAgICAgH8gBC0AoQINARoMCAsgBCkDwAIhDCAEKQO4AiEKIAQpA7ACIQ0gBCkDyAILIRYgBCANNwNgIAQgCjcDaCAEIAw3A3AgBCAWNwN4IARCACAKIA1CAFKtfH0iCjcDiAEgBEIAIA19Ig03A4ABIAQgDUIAUiAKQgBSIApQG0F/c61CAYMiCiAMQn+FfCIMNwOQASAEIAogDFatIBZCf4V8NwOYASAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCfiAELQCgAkEBRgRAIAQtAKECBEBCgICAgICAgICAfyENQgAhCkIADAILDAgLIAQpA8gCIQ0gBCkDuAIhCiAEKQOwAiELIAQpA8ACCyEMIARBoAJqIBUgFCATIBIgESAQIA8gDhCaCAJAIAQtAKACQQFGBEAgBC0AoQIEQCAEQbgBakIANwMAIARBsAFqQgA3AwAgBEIANwOoASAEQgA3A6ABDAILIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBpJSAARDvLAALIAQgBCkD6AI3A7gBIAQgBCkD4AI3A7ABIAQgBCkD2AI3A6gBIAQgBCkD0AI3A6ABCwJAIARBQGtB0JOAARD7GyIDQf8BcUECRyADwEEATnFFBEAgBEGgAWogBEGAAWoQ+xvAQQBMDQEMAwsgBEGgAWogBEHgAGoQ+xsiA0H/AXFBAkYgA8BBAEhyDQIgDSAMIAtCAXwiDiAKIA5QrXwiD4RQrXwiCiAMVK18IQ0MAwsgC0IBfSEOIAogC1CtfSEPIAwgCiALhFCtIgt9IQogDSALIAxWrX0hDQwCCyAEQQA2ArACIARBATYCpAIgBEGwl4ABNgKgAiAEQgQ3AqgCIARBoAJqQeSbgAEQ7ywACyALIQ4gCiEPIAwhCgsCfiACRQRAQgAhC0IAIQxCACERQgAMAQsgBEGgAmogASACEMwQIAQgBCgCoAJBAXEEfkIABSAEIAQpA8gCNwOYAiAEIAQpA8ACNwOQAiAEIAQpA7gCNwOIAiAEIAQpA7ACNwOAAkIBCzcD8AEgBEIANwP4ASAEQaACaiIBIARB8AFqIARBEGoQkhcgBEHAAWogASAEQQxqEOYNIAQoAsABQQFGBEAgACAEKQLEATcCBCAAQQxqIAQoAswBNgIAIAQpA9ABIQogAEEBNgIAIAAgCjcDEAwECyAEKQPoASERIAQpA+ABIQwgBCkD0AEhCyAEKQPYAQshECAEQQE2AvQBIARB9JuAATYC8AEgBEIBNwL8ASAEQf8PNgLEASAEIAsgDnwiDjcDoAIgBCALIA5WIgGtIA8gEHx8Igs3A6gCIAQgCiAMfCIKIAEgCyAQVCALIBBRG618Igs3A7ACIAQgCiALVq0gCiAMVK0gDSARfHx8NwO4AiAEIARBwAFqNgL4ASAEIARBoAJqNgLAASAEQTRqIARB8AFqEJkODAELIARBATYCpAIgBEHUnIABNgKgAiAEQgE3AqwCIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKAIANgIAIAQpAvwBIQogAEEBNgIAIAAgCjcDEAwBCyAEKAI8IQIgCQRAIARBNGpBARCELiACBEAgBCgCOCIBQQFqIAEgAvwKAAALIAQoAjhBLToAACAEIAJBAWoiAjYCPAsgBEGgAmoiASAEKAI4IAIQzBAgBCgCoAJBAXEEQCAEQQM2AqQCIARBkJ2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQeicgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogARCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIEIABBDGogBEH4AWooAgA2AgAgBCkC/AEhCiAAQQE2AgAgACAKNwMQIARBNGoQ3jsMAQsgBEGgAmogBCkDsAIgBCkDuAIgBCkDwAIgBCkDyAIQ1iMgAAJ/AkAgBCgCoAJBAXFFDQAgBCkDuAIgBCkDsAIiCkKAgICAgICAgIB/fSAKVK18QgBSDQAgACAKNwMIQQAMAQsgBEECNgKkAiAEQeSdgAE2AqACIARCAjcCrAIgBEHMATYCzAEgBEHonIABNgLIASAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIARBoAJqEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaikCADcCACAAQRRqIARBgAJqKAIANgIAQQELNgIAIARBNGoQ3jsLIARBGGoQ6jsgBEHwAmokAA8LIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBlJSAARDvLAALyhoCCn8DfiMAQdACayIEJAAgBCADNgIIAkACQAJAAkACQCACIANNBEAgBCACNgKwASAEQQI2ApwCIARB8MDPADYCmAIgBEICNwKkAiAEQTs2AuwBIARBOzYC5AEgBCAEQeABajYCoAIgBCAEQbABajYC6AEgBCAEQQhqNgLgASAAQQRqIARBmAJqEJkOIABBADYCAAwBCyABIANB4ABsaiEGAkAgAw0AIAYoAhhBAUYEQCAGKAIcDQELIARBAzsBNCAEQRE6ACAgBEEANgIcIARCgICAgMAANwIUIARBADYCDCAEIAYpAlg3AiwgBEGYAmoiASAEQQxqEMIOAkAgBCgCmAJBAUcEQCAEQeABaiICIAFBBHJBNPwKAABBPEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBNPwKAAAgACABNgIIIABCiICAgBA3AwAMAwsgBEHwAWogBEGwAmopAwA3AwAgBEHoAWogBEGoAmopAwA3AwAgBCAEKQOgAjcD4AFBzJ7PAEErIARB4AFqQbyezwBB1L/PABDVHgALDAQLIARBmAJqIQkgBigCICEKIAYoAiQhCCMAQTBrIgUkAAJAIApBAXEEQCAFIAg2AgwgCEEWTwRAIAVBATYCFCAFQcz4zgA2AhAgBUIBNwIcIAVBnAM2AiwgBSAFQShqNgIYIAUgBUEMajYCKCAJQQRqIAVBEGoQmQ4gCUEANgIADAILIAhBAWohBwsgCUEINgIAIAkgBzoABAsgBUEwaiQAIAQtAJwCIQkgBCgCmAIiBUEIRwRAIAAgBCkAnQI3AAUgAEEUaiAEQawCaigAADYAACAAQQ1qIARBpQJqKQAANwAAIAAgCToABCAAIAU2AgAMAQsCQCAGKAJAIgVBEkcEQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEQIAVBAmsgBUEBTRtBAWsOEAABAgMEBQYHCAkKCwwNDg8QCyAEQQM2ApgCDBALIARBBDYCmAIMDwsgBEEFNgKYAgwOCyAEQQY2ApgCIAQgBikCRDcCnAIMDQsgBEEHNgKYAgwMCyAEQQg2ApgCIAQgBi8BRDsBnAIMCwsgBEEJNgKYAiAEIAYvAUQ7AZwCDAoLIARBCjYCmAIgBCAGLwFEOwGcAgwJCyAEQQs2ApgCDAgLIARBDDYCmAIMBwsgBEENNgKYAgwGCyAEQQ42ApgCDAULIARBDzYCmAIMBAsgBEEQNgKYAiAEIAYvAUQ7AZwCDAMLAkAgBigCREGAgICAeEcEQCAEQeABaiAGQcQAahDdIAwBCyAEQYCAgIB4NgLgAQsgBEGkAmogBEHoAWooAgA2AgAgBCAEKQLgATcCnAIgBEERNgKYAgwCCwJAIAYoAkhBgICAgHhHBEAgBEHgAWogBkHIAGoQ3SAMAQsgBEGAgICAeDYC4AELIARBqAJqIARB6AFqKAIANgIAIAQgBTYCmAIgBCAEKQLgATcCoAIgBCAGKAJENgKcAgwBCyAEQQI2ApgCCyAEQThqIQVBBCEHQQ8hCgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRAgBEGYAmoiCCgCACILQQJrIAtBAU0bQQFrDhABAgMEBQYHCAkKCwwNDhAPAAsgBUEAOgAADBELIAVBAToAAAwQCyAFQQI6AAAMDwsgBUEDOgAADA4LIAVBBDoAACAFIAgpAgQ3AgQMDQsgBUEFOgAADAwLIAVBBjoAAAwKCyAFQQc6AAAMCQsgBUEIOgAADAgLIAVBCToAAAwICyAFQQo6AAAMBwsgBUELOgAADAYLIAVBDDoAAAwFCyAFQQ06AAAMBAsgBUEOOgAADAMLQQghB0EQIQoLIAUgCjoAACAHIAhqEIYwDAELIAUgCC0ABDoAAiAFIAgtAAU6AAELIAQtADhBCEcNASAELQA5QQhrIgVBBXQgBUH4AXFBA3ZyQf8BcSIFQQdNQQBBASAFdEGLAXEbDQEgCEE7QQBBAUEBEKAYIAQoApwCIQEgBCgCmAJBAUYNBiAEKAKgAiICQZi/zwBBO/wKAAAgAEE7NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAILIARBEToAOAsgBigCPCEFIAYoAjghCAJAAkACQAJAIAYoAhhBAUcNACAGKAIcIgdFDQBBAyEKIAEgA0HgAGxqIgYoAhBBAUcNAyAEQZgCaiAGQRBqKAIEEOUeIAQoApgCIgZBCGsOAgIDAQsCQCABIANB4ABsaiICKAIQBEAgBEGYAmogAkEQaigCBBDlHiAELQCcAiECIAQoApgCIgdBCEYNASAAIAQpAJ0CNwAFIABBFGogBEGsAmooAAA2AAAgAEENaiAEQaUCaikAADcAACAAIAI6AAQgACAHNgIADAULIARBmAJqQTVBAEEBQQEQoBggBCgCnAIhASAEKAKYAkEBRg0IIAQoAqACIgJB9L/PAEE1/AoAACAAQTU2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAsgBigCAEEBRgRAIARBmAJqIAYoAgQQ5B4gBC0AnAIhBiAEKAKYAiIHQQhHBEAgACAEKQCdAjcABSAAQRRqIARBrAJqKAAANgAAIABBDWogBEGlAmopAAA3AAAgACAGOgAEIAAgBzYCAAwFCyAEQdQAaiAEQUBrKAIANgIAIAQgBCkCODcCTCAEIAk6AG4gBCAGOgBtIAQgAjoAbCAEIAEgA0HgAGxqIgEpAlg3AlggBCABKAIMQX8gASgCCBs2AmAgBCABKAI0QX8gASgCMBs2AmQgBCABKAIsQX8gASgCKBs2AmggBCAFNgJIIAQgCDYCRCAEQZgCaiAEQcQAahDlASAEKAKYAkEBRgRAIARBhAFqIARBsAJqKQMAIg43AgAgBEH8AGogBEGoAmopAwAiDzcCACAEIAQpA6ACIhA3AnQgAEEQaiAONwIAIABBCGogDzcCACAAIBA3AgAMBQsgBEHwAGoiASAEQZgCakEEckE0/AoAACAAIAEQ5Sk2AgggACADQQFqNgIEIABBCDYCAAwECyAEQbgBaiAEQUBrKAIAIgY2AgAgBCAEKQI4Ig43A7ABIAEgA0HgAGxqKQJYIQ8gBEH8AWogBjYCACAEQQA2AvABIARCgICAgMAANwLoASAEIAU2AuQBIAQgCDYC4AEgBCAONwL0ASAEIAk6AIkCIAQgAkEDIAMbOgCIAiAEIA83AoACIARBmAJqIgEgBEHgAWoiAhDCDiAEKAKYAg0FIAIgAUEEckE0/AoAAEE8QQQQrTYiAUUNBiABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAIAE2AgggACADQQFqNgIEIABBCDYCAAwDCyAAIAQpAJ0CNwAFIABBDWogBEGlAmopAAA3AAAgAEEUaiAEQawCaigAADYAACAAIAQtAJwCOgAEIAAgBjYCAAwCCyAELQCcAiEKCyAEQQA2AqwBIARCgICAgMAANwKkASADQQFqIQYgB0EASgRAA0AgBEGYAmogASACIAYQwwEgBCgCoAIhCyAEKAKcAiEGIAQoApgCIgxBCEcEQCAAIAQpAqQCNwIMIABBFGogBEGsAmooAgA2AgAgACALNgIIIAAgBjYCBCAAIAw2AgAgBEGkAWoiABCiJyAAQQRBBBDgHgwDCyAEKAKsASIMIAQoAqQBRgRAIARBpAFqQbzAzwAQnSgLIAQoAqgBIAxBAnRqIAs2AgAgBCAMQQFqNgKsASAHQQFrIgcNAAsLIARBtAJqIARBQGsoAgA2AgAgBCAEKQI4NwKsAiAEIAk6AMECIARBADYCqAIgBEKAgICAwAA3AqACIARBADYCmAIgBCABIANB4ABsaikCWDcCuAIgBEEDOgDAAiAEQegBaiIHIARBrAFqKAIANgIAIAQgBCkCpAE3A+ABIARBsAFqIARBmAJqIgIgBEHgAWoiARDOIyAEKALUASELIAQtANgBIQkgBC0A2QEhDCAEQfwBaiAEQcwBaikCADcCACAEQfABaiINIARBwAFqKAIANgIAIAQgBCkCxAE3AvQBIAQgBCkCuAE3AugBIAQgDDoAiQIgBCAJIAogCkEDRhsgCSADGzoAiAIgBCALNgKEAiAEIAU2AuQBIAQgCDYC4AEgAiABEMIOIAQoApgCQQFGDQEgASACQQRyQTT8CgAAQTxBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAkEIaiABQTT8CgAAIAAgAjYCCCAAIAY2AgQgAEEINgIACyAEQdACaiQADwsgDSAEQbACaikDADcDACAHIARBqAJqKQMANwMAIAQgBCkDoAI3A+ABQcyezwBBKyAEQeABakG8ns8AQazAzwAQ1R4ACyAEQfABaiAEQbACaikDADcDACAEQegBaiAEQagCaikDADcDACAEIAQpA6ACNwPgAUHMns8AQSsgBEHgAWpBvJ7PAEHkv88AENUeAAtBBEE8EKM9AAsgASAEKAKgAkHko88AEP0vAAvBHQIHfwR+IwBBgANrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQcwATQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgQBCyAGQQE2AuQBIAZB+J6AATYC4AEgBkIBNwLsASAGQfQLNgLUAiAGQbyegAE2AtACIAYgBkHQAmo2AugBIABBBGogBkHgAWoQmQ4gAEGNgICAeDYCAAwNCyAGIAQ2ArABIAZBAjYC5AEgBkGsnoABNgLgASAGQgE3AuwBIAZBrwM2AtQCIAYgBkHQAmo2AugBIAYgBkGwAWo2AtACIABBBGogBkHgAWoQmQ4gAEGGgICAeDYCAAwMCyAGQRhqIAEgAigCEBEAACAGQeABaiICIAYoAhgiASAGKAIcKAIMEQAAAkAgAUUNACAGKQPgAULH2fTn3sS2nHeFIAYpA+gBQo2yzpSMypLmp3+FhFBFDQAgBiAGLQAvOgB7IAYgAzoAeiAFLQA0RQRAIAEQ0zohAyAGQeQBaiABEPk0IAYgAzYCgAIgBkEANgL8ASAGIAE2AuABIAYgBkH6AGo2AogCIAYgBkH7AGo2AoQCIAZB0AJqIQgjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohByMAQfAAayICJAAgAkEQaiIKIAEQ7RQCQAJAAkAgAikDGCACKQMQQgKFhFBFBEAgAkFAayIEIAEQwikgBEEEIAIoAkBBAWoiBUF/IAUbIgUgBUEETRtBAEEQQTAQoBggAigCRCEFIAIoAkBBAUYNAiACKAJIIgkgCkEw/AoAACACQQxqIgtBATYCACACIAk2AgggAiAFNgIEIAQgAUEw/AoAACMAQUBqIgEkACABIAQQ7RQgASkDCCABKQMAQgKFhFBFBEAgAkEEaiEFA0ACQCAFKAIIIgogBSgCAEcNACABQTRqIAQQwikgASgCNEEBaiIJQX8gCRsiCSAFKAIAIAUoAggiDGtNDQAgBSAMIAlBEEEwEN4oCyAFKAIEIApBMGxqIAFBMPwKAAAgBSAKQQFqNgIIIAEgBBDtFCABKQMIIAEpAwBCAoWEUEUNAAsLAkAgBCgCBCIFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACAEQQRqEPseCyABQUBrJAAgB0EIaiALKAIANgIAIAcgAikCBDcCAAwBCyAHQQA2AgggB0KAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQfAAaiQADAELIAUgAigCSEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAggAykCADcCACAIQRBqIANBEGooAgA2AgAgCEEIaiADQQhqKQIANwIAIAcQ5DwMAQsgCCADKQIUNwIEIAhBk4CAgHg2AgAgCEEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHcAmooAgA2AgAgBiAGKQLUAjcDsAEgBigC0AIiBEGTgICAeEYNBCAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC4AIhAgwMCyABENM6IQcgBkGAAWoiBCABEPk0IAYgBzYCnAEgBkEANgKYASAGIAE2AnwgARDTOhogARDTOiEKIAEQ0zoaIAYgARDTOiICNgK8AiAGQcACakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQV0IgghAwJAIAhBIHEiAgRAIAggAmtBQGsiAyAISQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAYoAsgCIQkgBkHcAmogBEEIaikCADcCACAGQeQCaiAEQRBqKQIANwIAIAYgATYC0AJBACECIAZBADYC/AIgBiAHNgLwAiAGQQA2AuwCIAYgBCkCADcC1AIgBiAGQfoAajYC+AIgBiAGQfsAajYC9AIgBSEEIAdFDQcgBkHgAWpBBHIhBwNAAkACQAJAAkACQCAGKALUAkUNACACIAYoAuQCTw0CIAYoAtgCIAYoAuACIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAGIAJBAWo2AuwCDAELIAYgAkEBajYC7AIgBkEQaiAGKALQAiACEI8sIAZB4AFqIAYoAhAgBigCFCAGKAL0AiwAABDWASAGKALgASIBQQFGBEAgAUUNASAHEIgRDAELIAYpA/ABIg0gBikD+AEiDiAGKQOAAiIPIAYpA4gCIhAgBigC+AItAAAQ3B0NAgsgBiAGKAL8AkEBajYC/AIgBEEYakIANwMAIARBEGpCADcDACAEQQhqQgA3AwAgBEIANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBiAGKAL8AiIBQQFqNgL8AiAEQRhqIBA3AwAgBEEQaiAPNwMAIAQgDjcDCCAEIA03AwAgCSABQQN2aiICIAItAABBASABQQdxdHI6AAALIARBIGohBCAGKALsAiICIAYoAvACRw0ACwwHC0HAACADEKM9AAtB5JSAAUEpIAZB4AFqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYC5AEgBkG0n4ABNgLgASAGQgE3AuwBIAZB9As2AtQCIAYgBkHQAmo2AugBIAYgBkEvajYC0AIgAEEEaiAGQeABahCZDiAAQY2AgIB4NgIADAoLIAZBIGogASACKAIQEQAAIAZB0AJqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPQAkKrmJHxlfrV/IB/hSAGKQPYAkKWlPir8LHps+EAhYRQRQ0AIAZB4AFqIAEgAyAGLQAvIAUQtQIgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBiAGKQLoASINNwOwASAGKALkASECIAYoAvQBIQMgAEEMaiABNgAAIAAgDTcABCAAIAM2AhAgACACNgIADAsLIAZB+ABqIAYtAOMBOgAAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZBOGogBkHwAWooAgA2AgAgBiAGLwDhATsBdiAGIAYpAvgBNwNQIAYgBikC6AE3AzAgBigC5AEhASAGKAL0ASEFDAQLQYSegAEQsjsACyAGQcgCaiABKAIAIgE2AgAgBiAGKQOwATcDwAIgBkHgAWoiAiAGKALEAiIDIAMgAUEwbGoQzwggBkHQAmogAiAGLQB6IAYtAHsQoxMgBi0A0AIiAkEpRgRAIAZBuAFqIAZB4AJqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAtgCIg03A7ABIAYgDTcDaCAGKALUAiEEIAYoAuQCIQIgBkHAAmoQ5DwMCAsgBkH4AGogBi0A0wI6AAAgBkG4AWogBkHgAmooAgAiATYCACAGQdgAaiAGQfACaikCADcDACAGQeAAaiAGQfgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A0QI7AXYgBiAGKQLYAiINNwOwASAGIAYpAugCNwNQIAYgDTcDaCAGKALUAiEBIAYoAuQCIQUgBkHAAmoQ5DwMAQsCQCAGKALUAiIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQdQCahD7HgsgBiAEIAVrQQV1IgE2ArACIAEgBigCvAJHDQIgBigCyAIhASAGKALMAiEEIAYgBikCwAI3AuwBIAZBADYC6AEgBiAENgLkASAGIAE2AuABIAZBCGogBkHgAWoiAhDXOyAGKAIIIQdBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAYpAuABNwIIIAFBEGogBkHoAWoiCSkCADcCACABQRhqIAZB8AFqIgsoAgA2AgAgBiADNgLwASAGQoCAgICACDcC6AEgBiAINgLkASAGIAU2AuABIAYgAhDXOyAGKAIAIQNBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAYpAuABNwIIIAJBEGogCSkCADcCACACQRhqIAsoAgA2AgAgBiAENgK4AiAGIAc2ArQCIAYgATYCsAJBDEEEEK02IgFFDQQgASAINgIIIAEgAzYCBCABIAI2AgAgBkEBNgLIAiAGIAE2AsQCIAZBATYCwAIgBkEANgLYAiAGQoCAgIDAADcC0AIgBkHgAWoiAkHokYABIAogBiAGQbACaiAGQcACaiAGQdACaiIBEIwTIAEgAhDFEyAGQbABaiABIAYtAHogBi0AexCjEyAGLQCwASICQSlGBEAgBkHwAGogBkHAAWooAgA2AgAgBiAGKQK4ASINNwOgASAGIA03A2ggBigCtAEhBCAGKALEASECDAcLIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzALQThBBBCtNiIDRQ0DIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBjJmAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwFCyAGQgA3AuwBIAZCgYCAgMAANwLkASAGQcSRgAE2AuABQQAgBkGwAmogBkG8AmogBkHgAWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg03A0AgAEEMaiABNgAAIAAgDTcABCAAIAI2AhAgACAENgIACyAGQYADaiQAC8EdAgd/BH4jAEGAA2siBiQAIAYgBDoALwJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkAgBEH/AXFBzABNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYC5AEgBkH4noABNgLgASAGQgE3AuwBIAZB9As2AtQCIAZBvJ6AATYC0AIgBiAGQdACajYC6AEgAEEEaiAGQeABahCZDiAAQY2AgIB4NgIADA0LIAYgBDYCsAEgBkECNgLkASAGQayegAE2AuABIAZCATcC7AEgBkGvAzYC1AIgBiAGQdACajYC6AEgBiAGQbABajYC0AIgAEEEaiAGQeABahCZDiAAQYaAgIB4NgIADAwLIAZBGGogASACKAIQEQAAIAZB4AFqIgIgBigCGCIBIAYoAhwoAgwRAAACQCABRQ0AIAYpA+ABQtPY0/j95vaSSIUgBikD6AFCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgARDUOiEDIAZB5AFqIAEQ+TQgBiADNgKAAiAGQQA2AvwBIAYgATYC4AEgBiAGQfoAajYCiAIgBiAGQfsAajYChAIgBkHQAmohCCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEHIwBB8ABrIgIkACACQRBqIgogARDuFAJAAkACQCACKQMYIAIpAxBCAoWEUEUEQCACQUBrIgQgARDAKSAEQQQgAigCQEEBaiIFQX8gBRsiBSAFQQRNG0EAQRBBMBCgGCACKAJEIQUgAigCQEEBRg0CIAIoAkgiCSAKQTD8CgAAIAJBDGoiC0EBNgIAIAIgCTYCCCACIAU2AgQgBCABQTD8CgAAIwBBQGoiASQAIAEgBBDuFCABKQMIIAEpAwBCAoWEUEUEQCACQQRqIQUDQAJAIAUoAggiCiAFKAIARw0AIAFBNGogBBDAKSABKAI0QQFqIglBfyAJGyIJIAUoAgAgBSgCCCIMa00NACAFIAwgCUEQQTAQ3igLIAUoAgQgCkEwbGogAUEw/AoAACAFIApBAWo2AgggASAEEO4UIAEpAwggASkDAEIChYRQRQ0ACwsCQCAEKAIEIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIARBBGoQ+x4LIAFBQGskACAHQQhqIAsoAgA2AgAgByACKQIENwIADAELIAdBADYCCCAHQoCAgICAAjcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB8ABqJAAMAQsgBSACKAJIQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgCCADKQIANwIAIAhBEGogA0EQaigCADYCACAIQQhqIANBCGopAgA3AgAgBxDkPAwBCyAIIAMpAhQ3AgQgCEGTgICAeDYCACAIQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQdwCaigCADYCACAGIAYpAtQCNwOwASAGKALQAiIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALgAiECDAwLIAEQ1DohByAGQYABaiIEIAEQ+TQgBiAHNgKcASAGQQA2ApgBIAYgATYCfCABENQ6GiABENQ6IQogARDUOhogBiABENQ6IgI2ArwCIAZBwAJqQX8gAkEHaiIDIAIgA0sbQQN2ENIfIAJBBXQiCCEDAkAgCEEgcSICBEAgCCACa0FAayIDIAhJDQELQcAAIQUgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBUUNAQsgBigCyAIhCSAGQdwCaiAEQQhqKQIANwIAIAZB5AJqIARBEGopAgA3AgAgBiABNgLQAkEAIQIgBkEANgL8AiAGIAc2AvACIAZBADYC7AIgBiAEKQIANwLUAiAGIAZB+gBqNgL4AiAGIAZB+wBqNgL0AiAFIQQgB0UNByAGQeABakEEciEHA0ACQAJAAkACQAJAIAYoAtQCRQ0AIAIgBigC5AJPDQIgBigC2AIgBigC4AIgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAYgAkEBajYC7AIMAQsgBiACQQFqNgLsAiAGQRBqIAYoAtACIAIQ2isgBkHgAWogBigCECAGKAIUIAYoAvQCLAAAENYBIAYoAuABIgFBAUYEQCABRQ0BIAcQiBEMAQsgBikD8AEiDSAGKQP4ASIOIAYpA4ACIg8gBikDiAIiECAGKAL4Ai0AABDcHQ0CCyAGIAYoAvwCQQFqNgL8AiAEQRhqQgA3AwAgBEEQakIANwMAIARBCGpCADcDACAEQgA3AwAMAgtBtJSAAUEgQdSUgAEQnykACyAGIAYoAvwCIgFBAWo2AvwCIARBGGogEDcDACAEQRBqIA83AwAgBCAONwMIIAQgDTcDACAJIAFBA3ZqIgIgAi0AAEEBIAFBB3F0cjoAAAsgBEEgaiEEIAYoAuwCIgIgBigC8AJHDQALDAcLQcAAIAMQoz0AC0HklIABQSkgBkHgAWpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQAC0H0nYABELI7AAsgBkEBNgLkASAGQbSfgAE2AuABIAZCATcC7AEgBkH0CzYC1AIgBiAGQdACajYC6AEgBiAGQS9qNgLQAiAAQQRqIAZB4AFqEJkOIABBjYCAgHg2AgAMCgsgBkEgaiABIAIoAhARAAAgBkHQAmogBigCICIBIAYoAiQoAgwRAAACQCABRQ0AIAYpA9ACQquYkfGV+tX8gH+FIAYpA9gCQpaU+Kvwsemz4QCFhFBFDQAgBkHgAWogASADIAYtAC8gBRC1AiAGLQDgASICQSlGBEAgBkG4AWogBkHwAWooAgAiATYCACAGIAYpAugBIg03A7ABIAYoAuQBIQIgBigC9AEhAyAAQQxqIAE2AAAgACANNwAEIAAgAzYCECAAIAI2AgAMCwsgBkH4AGogBi0A4wE6AAAgBkHYAGogBkGAAmopAgA3AwAgBkHgAGogBkGIAmopAgA3AwAgBkE4aiAGQfABaigCADYCACAGIAYvAOEBOwF2IAYgBikC+AE3A1AgBiAGKQLoATcDMCAGKALkASEBIAYoAvQBIQUMBAtBhJ6AARCyOwALIAZByAJqIAEoAgAiATYCACAGIAYpA7ABNwPAAiAGQeABaiICIAYoAsQCIgMgAyABQTBsahDPCCAGQdACaiACIAYtAHogBi0AexCjEyAGLQDQAiICQSlGBEAgBkG4AWogBkHgAmooAgAiATYCACAGQfAAaiABNgIAIAYgBikC2AIiDTcDsAEgBiANNwNoIAYoAtQCIQQgBigC5AIhAiAGQcACahDkPAwICyAGQfgAaiAGLQDTAjoAACAGQbgBaiAGQeACaigCACIBNgIAIAZB2ABqIAZB8AJqKQIANwMAIAZB4ABqIAZB+AJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDRAjsBdiAGIAYpAtgCIg03A7ABIAYgBikC6AI3A1AgBiANNwNoIAYoAtQCIQEgBigC5AIhBSAGQcACahDkPAwBCwJAIAYoAtQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZB1AJqEPseCyAGIAQgBWtBBXUiATYCsAIgASAGKAK8AkcNAiAGKALIAiEBIAYoAswCIQQgBiAGKQLAAjcC7AEgBkEANgLoASAGIAQ2AuQBIAYgATYC4AEgBkEIaiAGQeABaiICENc7IAYoAgghB0EcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBikC4AE3AgggAUEQaiAGQegBaiIJKQIANwIAIAFBGGogBkHwAWoiCygCADYCACAGIAM2AvABIAZCgICAgIAINwLoASAGIAg2AuQBIAYgBTYC4AEgBiACENc7IAYoAgAhA0EcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgBikC4AE3AgggAkEQaiAJKQIANwIAIAJBGGogCygCADYCACAGIAQ2ArgCIAYgBzYCtAIgBiABNgKwAkEMQQQQrTYiAUUNBCABIAg2AgggASADNgIEIAEgAjYCACAGQQE2AsgCIAYgATYCxAIgBkEBNgLAAiAGQQA2AtgCIAZCgICAgMAANwLQAiAGQeABaiICQeiRgAEgCiAGIAZBsAJqIAZBwAJqIAZB0AJqIgEQjBMgASACEMUTIAZBsAFqIAEgBi0AeiAGLQB7EKMTIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg03A6ABIAYgDTcDaCAGKAK0ASEEIAYoAsQBIQIMBwsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFCyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgNFDQMgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEGMmYABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAULIAZCADcC7AEgBkKBgICAwAA3AuQBIAZBxJGAATYC4AFBACAGQbACaiAGQbwCaiAGQeABakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDTcDQCAAQQxqIAE2AAAgACANNwAEIAAgAjYCECAAIAQ2AgALIAZBgANqJAALhhgCBn8NfiMAQfACayIEJAAgBCADNgIMIAQgASACEPQIIAQgBCgCBCIBNgIUIAQgBCgCACICNgIQIARBATsBxAIgBCABNgLAAiAEQQA2ArwCIARBAToAuAIgBEEuNgK0AiAEIAE2ArACIARBADYCrAIgBCABNgKoAiAEIAI2AqQCIARBLjYCoAIgBEEYaiAEQaACahDSFQJAAkACQAJAAkACQAJAAkAgBCgCICIIQQJNBEAgCEUNAyAEKAIcIgYoAgAhASAGKAIEIgINAUEAIQIMAgsgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwGCwJAAkAgAS0AAEEraw4DAQIAAgtBASEJIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBDAELIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBCyAEIAI2AiggBCABNgIkQQEhByAIQQJGBEAgBigCCCEHIAYoAgwhBQsgBCAFNgIwIAQgBzYCLCACRQ0DIAEtAABBMGtB/wFxQQpJDQMgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQhqIARBoAJqEJkOIABCgYCAgNCBgICAfzcDAAwEC0EAQQBBlJuAARDDIQALIAEgAkEBIAJBpJuAARCjNgALIAEgAkEBIAJBtJuAARCjNgALAkAgBUUNACAHLQAAQTBrQf8BcUEKSQ0AIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMAQsCQAJAAkACQAJAIAMgBU8EQCADQQAgAyAFSxsiAUGAgARPDQEgBCABOwH8ASAEQQA2AvgBIARBzAE2AvQBIARBATYCtAIgBEH8m4ABNgKwAiAEQQE2AqQCIARB9JuAATYCoAIgBEECNgKsAiAEIARBLGo2AvABIAQgBEHwAWoiAjYCqAIgBEHAAWoiASAEQaACaiIDEJkOIARBAjYCpAIgBEGUnIABNgKgAiAEQgI3AqwCIARB/g82AvwBIARBzAE2AvQBIAQgAjYCqAIgBCABNgL4ASAEIARBJGo2AvABIARBNGogAxCZDiABEN47DAULIARBoAJqIgYgByAFEMwQIAQoAqACQQFxDQMgBCAEKQPIAiISNwNYIAQgBCkDwAIiEzcDUCAEIAQpA7gCIhQ3A0ggBCAEKQOwAiIVNwNAIARB8AFqQgpCABCyLiAGIAQpA/ABIAQpA/gBIAQpA4ACIAQpA4gCIAUgA2sQ3wEgBCgCoAJBAUYEQCAAIAQpAqQCNwIEIABBDGogBCgCrAI2AgAgBCkDsAIhCiAAQQE2AgAgACAKNwMQDAYLIAQpA8gCIQ4gBCkDwAIhDyAEKQO4AiEQIAQpA7ACIREgBEGgAmoiA0ICQgAQsi4gAyARIBAgDyAOIAQpA6ACIAQpA6gCIAQpA7ACIAQpA7gCEJoIAn4gBC0AoAJBAUYEQEKAgICAgICAgIB/IAQtAKECDQEaDAgLIAQpA8ACIQwgBCkDuAIhCiAEKQOwAiENIAQpA8gCCyEWIAQgDTcDYCAEIAo3A2ggBCAMNwNwIAQgFjcDeCAEQgAgCiANQgBSrXx9Igo3A4gBIARCACANfSINNwOAASAEIA1CAFIgCkIAUiAKUBtBf3OtQgGDIgogDEJ/hXwiDDcDkAEgBCAKIAxWrSAWQn+FfDcDmAEgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAn4gBC0AoAJBAUYEQCAELQChAgRAQoCAgICAgICAgH8hDUIAIQpCAAwCCwwICyAEKQPIAiENIAQpA7gCIQogBCkDsAIhCyAEKQPAAgshDCAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCQCAELQCgAkEBRgRAIAQtAKECBEAgBEG4AWpCADcDACAEQbABakIANwMAIARCADcDqAEgBEIANwOgAQwCCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQaSUgAEQ7ywACyAEIAQpA+gCNwO4ASAEIAQpA+ACNwOwASAEIAQpA9gCNwOoASAEIAQpA9ACNwOgAQsCQCAEQUBrQdCTgAEQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIARBoAFqIARBgAFqEPsbwEEATA0BDAMLIARBoAFqIARB4ABqEPsbIgNB/wFxQQJGIAPAQQBIcg0CIA0gDCALQgF8Ig4gCiAOUK18Ig+EUK18IgogDFStfCENDAMLIAtCAX0hDiAKIAtQrX0hDyAMIAogC4RQrSILfSEKIA0gCyAMVq19IQ0MAgsgBEEANgKwAiAEQQE2AqQCIARBsJeAATYCoAIgBEIENwKoAiAEQaACakHkm4ABEO8sAAsgCyEOIAohDyAMIQoLAn4gAkUEQEIAIQtCACEMQgAhEUIADAELIARBoAJqIAEgAhDMECAEIAQoAqACQQFxBH5CAAUgBCAEKQPIAjcDmAIgBCAEKQPAAjcDkAIgBCAEKQO4AjcDiAIgBCAEKQOwAjcDgAJCAQs3A/ABIARCADcD+AEgBEGgAmoiASAEQfABaiAEQRBqEJIXIARBwAFqIAEgBEEMahDmDSAEKALAAUEBRgRAIAAgBCkCxAE3AgQgAEEMaiAEKALMATYCACAEKQPQASEKIABBATYCACAAIAo3AxAMBAsgBCkD6AEhESAEKQPgASEMIAQpA9ABIQsgBCkD2AELIRAgBEEBNgL0ASAEQfSbgAE2AvABIARCATcC/AEgBEH/DzYCxAEgBCALIA58Ig43A6ACIAQgCyAOViIBrSAPIBB8fCILNwOoAiAEIAogDHwiCiABIAsgEFQgCyAQURutfCILNwOwAiAEIAogC1atIAogDFStIA0gEXx8fDcDuAIgBCAEQcABajYC+AEgBCAEQaACajYCwAEgBEE0aiAEQfABahCZDgwBCyAEQQE2AqQCIARB1JyAATYCoAIgBEIBNwKsAiAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIARBoAJqEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaigCADYCACAEKQL8ASEKIABBATYCACAAIAo3AxAMAQsgBCgCPCECIAkEQCAEQTRqQQEQhC4gAgRAIAQoAjgiAUEBaiABIAL8CgAACyAEKAI4QS06AAAgBCACQQFqIgI2AjwLIARBoAJqIgEgBCgCOCACEMwQIAQoAqACQQFxBEAgBEEDNgKkAiAEQZCdgAE2AqACIARCAjcCrAIgBEHMATYCzAEgBEHInYABNgLIASAEQcwBNgLEASAEIARBwAFqNgKoAiAEIARBEGo2AsABIARB9AFqIAEQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKAIANgIAIAQpAvwBIQogAEEBNgIAIAAgCjcDECAEQTRqEN47DAELIARBoAJqIAQpA7ACIAQpA7gCIAQpA8ACIAQpA8gCENYjIAACfyAEKAKgAkEBcQRAIAQpA7gCIQogACAEKQOwAjcDECAAIAo3AxhBAAwBCyAEQQI2AqQCIARB5J2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQcidgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCBCAAQQxqIARB+AFqKQIANwIAIABBFGogBEGAAmooAgA2AgBBAQs2AgAgBEE0ahDeOwsgBEEYahDqOyAEQfACaiQADwsgBEEANgKAAiAEQQE2AvQBIARBjJSAATYC8AEgBEIENwL4ASAEQfABakGUlIABEO8sAAvtFwIGfw1+IwBB8AJrIgQkACAEIAM2AgwgBCABIAIQ9AggBCAEKAIEIgE2AhQgBCAEKAIAIgI2AhAgBEEBOwHEAiAEIAE2AsACIARBADYCvAIgBEEBOgC4AiAEQS42ArQCIAQgATYCsAIgBEEANgKsAiAEIAE2AqgCIAQgAjYCpAIgBEEuNgKgAiAEQRhqIARBoAJqENIVAkACQAJAAkACQAJAAkACQCAEKAIgIghBAk0EQCAIRQ0DIAQoAhwiBigCACEBIAYoAgQiAg0BQQAhAgwCCyAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBBGogBEGgAmoQmQ4gAEGNgICAeDYCAAwGCwJAAkAgAS0AAEEraw4DAQIAAgtBASEJIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBDAELIAJBAUcEQCABLAABQb9/TA0ECyACQQFrIQIgAUEBaiEBCyAEIAI2AiggBCABNgIkQQEhByAIQQJGBEAgBigCCCEHIAYoAgwhBQsgBCAFNgIwIAQgBzYCLCACRQ0DIAEtAABBMGtB/wFxQQpJDQMgBEEBNgKkAiAEQdybgAE2AqACIARCATcCrAIgBEHEDTYC9AEgBCAEQfABajYCqAIgBCAEQRBqNgLwASAAQQRqIARBoAJqEJkOIABBjYCAgHg2AgAMBAtBAEEAQZSbgAEQwyEACyABIAJBASACQaSbgAEQozYACyABIAJBASACQbSbgAEQozYACwJAIAVFDQAgBy0AAEEwa0H/AXFBCkkNACAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBBGogBEGgAmoQmQ4gAEGNgICAeDYCAAwBCwJAAkACQAJAAkAgAyAFTwRAIANBACADIAVLGyIBQYCABE8NASAEIAE7AfwBIARBADYC+AEgBEHMATYC9AEgBEEBNgK0AiAEQfybgAE2ArACIARBATYCpAIgBEH0m4ABNgKgAiAEQQI2AqwCIAQgBEEsajYC8AEgBCAEQfABaiICNgKoAiAEQcABaiIBIARBoAJqIgMQmQ4gBEECNgKkAiAEQZScgAE2AqACIARCAjcCrAIgBEH+DzYC/AEgBEHMATYC9AEgBCACNgKoAiAEIAE2AvgBIAQgBEEkajYC8AEgBEE0aiADEJkOIAEQ3jsMBQsgBEGgAmoiBiAHIAUQzBAgBCgCoAJBAXENAyAEIAQpA8gCIhI3A1ggBCAEKQPAAiITNwNQIAQgBCkDuAIiFDcDSCAEIAQpA7ACIhU3A0AgBEHwAWpCCkIAELIuIAYgBCkD8AEgBCkD+AEgBCkDgAIgBCkDiAIgBSADaxDfASAEKAKgAkEBRgRAIAAgBCkCpAI3AgAgAEEIaiAEKAKsAjYCACAAIAQpA7ACNwIMDAYLIAQpA8gCIQ4gBCkDwAIhDyAEKQO4AiEQIAQpA7ACIREgBEGgAmoiA0ICQgAQsi4gAyARIBAgDyAOIAQpA6ACIAQpA6gCIAQpA7ACIAQpA7gCEJoIAn4gBC0AoAJBAUYEQEKAgICAgICAgIB/IAQtAKECDQEaDAgLIAQpA8ACIQwgBCkDuAIhCiAEKQOwAiENIAQpA8gCCyEWIAQgDTcDYCAEIAo3A2ggBCAMNwNwIAQgFjcDeCAEQgAgCiANQgBSrXx9Igo3A4gBIARCACANfSINNwOAASAEIA1CAFIgCkIAUiAKUBtBf3OtQgGDIgogDEJ/hXwiDDcDkAEgBCAKIAxWrSAWQn+FfDcDmAEgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAn4gBC0AoAJBAUYEQCAELQChAgRAQoCAgICAgICAgH8hDUIAIQpCAAwCCwwICyAEKQPIAiENIAQpA7gCIQogBCkDsAIhCyAEKQPAAgshDCAEQaACaiAVIBQgEyASIBEgECAPIA4QmggCQCAELQCgAkEBRgRAIAQtAKECBEAgBEG4AWpCADcDACAEQbABakIANwMAIARCADcDqAEgBEIANwOgAQwCCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQaSUgAEQ7ywACyAEIAQpA+gCNwO4ASAEIAQpA+ACNwOwASAEIAQpA9gCNwOoASAEIAQpA9ACNwOgAQsCQCAEQUBrQdCTgAEQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIARBoAFqIARBgAFqEPsbwEEATA0BDAMLIARBoAFqIARB4ABqEPsbIgNB/wFxQQJGIAPAQQBIcg0CIA0gDCALQgF8Ig4gCiAOUK18Ig+EUK18IgogDFStfCENDAMLIAtCAX0hDiAKIAtQrX0hDyAMIAogC4RQrSILfSEKIA0gCyAMVq19IQ0MAgsgBEEANgKwAiAEQQE2AqQCIARBsJeAATYCoAIgBEIENwKoAiAEQaACakHkm4ABEO8sAAsgCyEOIAohDyAMIQoLAn4gAkUEQEIAIQtCACEMQgAhEUIADAELIARBoAJqIAEgAhDMECAEIAQoAqACQQFxBH5CAAUgBCAEKQPIAjcDmAIgBCAEKQPAAjcDkAIgBCAEKQO4AjcDiAIgBCAEKQOwAjcDgAJCAQs3A/ABIARCADcD+AEgBEGgAmoiASAEQfABaiAEQRBqEJIXIARBwAFqIAEgBEEMahDmDSAEKALAAUEBRgRAIAAgBCkCxAE3AgAgAEEIaiAEKALMATYCACAAIAQpA9ABNwIMDAQLIAQpA+gBIREgBCkD4AEhDCAEKQPQASELIAQpA9gBCyEQIARBATYC9AEgBEH0m4ABNgLwASAEQgE3AvwBIARB/w82AsQBIAQgCyAOfCIONwOgAiAEIAsgDlYiAa0gDyAQfHwiCzcDqAIgBCAKIAx8IgogASALIBBUIAsgEFEbrXwiCzcDsAIgBCAKIAtWrSAKIAxUrSANIBF8fHw3A7gCIAQgBEHAAWo2AvgBIAQgBEGgAmo2AsABIARBNGogBEHwAWoQmQ4MAQsgBEEBNgKkAiAEQdScgAE2AqACIARCATcCrAIgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiAEQaACahCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIAIABBCGogBEH4AWooAgA2AgAgACAEKQL8ATcCDAwBCyAEKAI8IQIgCQRAIARBNGpBARCELiACBEAgBCgCOCIBQQFqIAEgAvwKAAALIAQoAjhBLToAACAEIAJBAWoiAjYCPAsgBEGgAmoiASAEKAI4IAIQzBAgBCgCoAJBAXEEQCAEQQM2AqQCIARBkJ2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQdydgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogARCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIAIABBCGogBEH4AWooAgA2AgAgACAEKQL8ATcCDCAEQTRqEN47DAELIARBoAJqIAQpA7ACIAQpA7gCIAQpA8ACIAQpA8gCENYjAkACQCAEKAKgAkEBcUUNACAEKQOwAiIKQoCAgIAIfCILQv////8PViAEKQO4AiAKIAtWrXwiC0IAUiALUBsNACAAQZOAgIB4NgIAIAAgCj4CBAwBCyAEQQI2AqQCIARB5J2AATYCoAIgBEICNwKsAiAEQcwBNgLMASAEQdydgAE2AsgBIARBzAE2AsQBIAQgBEHAAWo2AqgCIAQgBEEQajYCwAEgBEH0AWogBEGgAmoQmQ4gBEGNgICAeDYC8AEgACAEKQLwATcCACAAQQhqIARB+AFqKQIANwIAIABBEGogBEGAAmooAgA2AgALIARBNGoQ3jsLIARBGGoQ6jsgBEHwAmokAA8LIARBADYCgAIgBEEBNgL0ASAEQYyUgAE2AvABIARCBDcC+AEgBEHwAWpBlJSAARDvLAALuB0CCH8CfiMAQYADayIGJAAgBiAEOgAvAkACQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAAkACQAJAAkAgBEH/AXFBEk0EQCABIAIoAhwRBAAiBC0AAEEYaw4DAgIDAQsgBkEBNgKUAiAGQfiegAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBkG+n4ABNgLgASAGIAZB4AFqNgKYAiAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMEgsgBiAENgKwASAGQQI2ApQCIAZBrJ6AATYCkAIgBkIBNwKcAiAGQa8DNgLkASAGIAZB4AFqNgKYAiAGIAZBsAFqNgLgASAAQQRqIAZBkAJqEJkOIABBhoCAgHg2AgAMEQsgBkEYaiABIAIoAhARAAAgBkGQAmoiAiAGKAIYIgEgBigCHCgCDBEAACABRQ0FIAYpA5ACQsfZ9OfexLacd4UgBikDmAJCjbLOlIzKkuanf4WEUEUNBSAGIAYtAC86AHsgBiADOgB6AkACQCAFLQA0RQRAIAEQ0zohAyAGQZQCaiABEPk0IAYgAzYCsAIgBkEANgKsAiAGIAE2ApACIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqIQUjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohCCMAQdAAayICJAAgAkEQaiIHIAEQsiQCQAJAAkAgAikDECIOQgJSBEAgAikDGCEPIAJBxABqIgQgARDCKSAEQQQgAigCREEBaiIEQX8gBBsiBCAEQQRNG0EAQQhBEBCgGCACKAJIIQQgAigCREEBRg0CIAIoAkwiCSAPNwMIIAkgDjcDACACQQxqIgtBATYCACACIAk2AgggAiAENgIEIAcgAUEw/AoAACMAQSBrIgEkACABIAcQsiQgASkDACIOQgJSBEAgAkEEaiEEA0AgASkDCCEPAkAgBCgCCCIJIAQoAgBHDQAgAUEUaiAHEMIpIAEoAhRBAWoiCkF/IAobIgogBCgCACAEKAIIIgxrTQ0AIAQgDCAKQQhBEBDeKAsgBCgCBCAJQQR0aiIKIA83AwggCiAONwMAIAQgCUEBajYCCCABIAcQsiQgASkDACIOQgJSDQALCwJAIAcoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgB0EEahD7HgsgAUEgaiQAIAhBCGogCygCADYCACAIIAIpAgQ3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHQAGokAAwBCyAEIAIoAkxBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAFIAMpAgA3AgAgBUEQaiADQRBqKAIANgIAIAVBCGogA0EIaikCADcCACAIEO07DAELIAUgAykCFDcCBCAFQZOAgIB4NgIAIAVBDGogA0EcaigCADYCAAsgA0HQAGokACAGQbgBaiIBIAZB7AFqKAIANgIAIAYgBikC5AE3A7ABIAYoAuABIgRBk4CAgHhGDQEgBkHwAGogASgCADYCACAGIAYpA7ABNwNoIAYoAvABIQIMEgsgARDTOiEFIAZBgAFqIgQgARD5NCAGIAU2ApwBIAZBADYCmAEgBiABNgJ8IAEQ0zoaIAEQ0zohCyABENM6GiAGIAEQ0zoiAjYC5AIgBkHoAmpBfyACQQdqIgMgAiADSxtBA3YQ0h8gAkEDdCIIIQcgCEE4cSICBEAgCCACa0FAayIHIAhJDQkLQcAAIQkgB0HAABDRNEUNCSAHBEAgB0HAABCtNiIJRQ0LCyAGKALwAiEKIAZBnAJqIARBCGopAgA3AgAgBkGkAmogBEEQaikCADcCACAGIAE2ApACQQAhAiAGQQA2ArwCIAYgBTYCsAIgBkEANgKsAiAGIAQpAgA3ApQCIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqQQRyIQwgBkGUAmohDUEAIQQDQCAGQdgCaiEBQgIhDiAEIAVHBH8gBgJ+AkACQAJAIAYoApQCRQ0AIAQgBigCpAJPDREgBigCmAIgBigCoAIgBGoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAYgBEEBajYCrAIMAQsgBiAEQQFqNgKsAiAGQRBqIAYoApACIAQQjywgBkHgAWogBigCECAGKAIUIAYoArQCLAAAEMIBIAYoAuABIgFBAUcNASABRQ0AIAwQiBELQgAMAQsgBikD6AEiDiAGKAK4Ai0AABDFKa0LNwPYAiAGIAYoArwCIgNBAWo2ArwCIAZB+AJqBSABCyAONwMAAkACQAJAIAYpA9gCIg5CAlIEQCACIAlqIQEgDqdBAXFFDQEgASAGKQP4AjcDACAKIANBA3ZqIgEgAS0AAEEBIANBB3F0cjoAAAwCCwJAIAYoApQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIA0Q+x4LIAYgAkEDdSIBNgLgASABIAYoAuQCRw0QIAYoAvACIQEgBigC9AIhAyAGIAYpAugCNwKcAiAGQQA2ApgCIAYgAzYClAIgBiABNgKQAiAGQQhqIAZBkAJqIgIQ1zsgBigCCCEEQRxBBBCtNiIBRQ0RIAFCgYCAgBA3AgAgASAGKQKQAjcCCCABQRBqIAZBmAJqIgUpAgA3AgAgAUEYaiAGQaACaiIKKAIANgIAIAYgBzYCoAIgBkKAgICAgAg3ApgCIAYgCDYClAIgBiAJNgKQAiAGIAIQ1zsgBigCACEHQRxBBBCtNiICDQJBBEEcEKM9AAsgAUIANwMACyACQQhqIQIgBigCsAIhBSAGKAKsAiEEDAELCyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAFKQIANwIAIAJBGGogCigCADYCACAGIAM2AuACIAYgBDYC3AIgBiABNgLYAkEMQQQQrTYiAUUNDiABIAg2AgggASAHNgIEIAEgAjYCACAGQQE2AvACIAYgATYC7AIgBkEBNgLoAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQdyRgAEgCyAGIAZB2AJqIAZB6AJqIAZB4AFqIgEQjBMgASACELcTIAZBsAFqIAEgBi0AeiAGLQB7EKITIAYtALABIgJBKUcNASAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg43A6ABIAYgDjcDaCAGKAK0ASEEIAYoAsQBIQIMEQsgBkHwAmogASgCACIBNgIAIAYgBikDsAE3A+gCIAZBkAJqIgIgBigC7AIiAyADIAFBBHRqEIMJIAZB4AFqIAIgBi0AeiAGLQB7EKITIAYtAOABIgJBKUcNAiAGQbgBaiAGQfABaigCACIBNgIAIAZB8ABqIAE2AgAgBiAGKQLoASIONwOwASAGIA43A2ggBigC5AEhBCAGKAL0ASECIAZB6AJqEO07DBALIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQwCCyAGQSBqIAEgAigCEBEAACAGQeABaiAGKAIgIgEgBigCJCgCDBEAACABRQ0MIAYpA+ABQquYkfGV+tX8gH+FIAYpA+gBQpaU+Kvwsemz4QCFhFBFDQwgBkGQAmogASADIAYtAC8gBRC3AiAGLQCQAiICQSlHDQIgBkG4AWogBkGgAmooAgAiATYCACAGIAYpApgCIg43A7ABIAYoApQCIQIgBigCpAIhAyAAQQxqIAE2AAAgACAONwAEIAAgAzYCECAAIAI2AgAMDwsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASIONwOwASAGIAYpAvgBNwNQIAYgDjcDaCAGKALkASEBIAYoAvQBIQUgBkHoAmoQ7TsLIAZBOGogBkHwAGooAgA2AgAgBiAGKQNoNwMwDAsLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAoLIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAsLQfSdgAEQsjsAC0GUk4ABQSNBuJOAARDLJAALQeSUgAFBKSAGQZACakHIl4ABQZCVgAEQ1R4AC0HAACAHEKM9AAtBtJSAAUEgQdSUgAEQnykACyAGQgA3ApwCIAZCgYCAgMAANwKUAiAGQcSRgAE2ApACQQAgBkHgAWogBkHkAmogBkGQAmpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQYSegAEQsjsAC0E4QQQQrTYiAwRAIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBvJqAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwCC0EEQTgQoz0ACyAGQcgAaiAGQfAAaigCACIBNgIAIAYgBikDaCIONwNAIABBDGogATYAACAAIA43AAQgACACNgIQIAAgBDYCAAsgBkGAA2okAAu4HQIIfwJ+IwBBgANrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkACQAJAAkACQCAEQf8BcUESTQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgMBCyAGQQE2ApQCIAZB+J6AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGQb6fgAE2AuABIAYgBkHgAWo2ApgCIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwSCyAGIAQ2ArABIAZBAjYClAIgBkGsnoABNgKQAiAGQgE3ApwCIAZBrwM2AuQBIAYgBkHgAWo2ApgCIAYgBkGwAWo2AuABIABBBGogBkGQAmoQmQ4gAEGGgICAeDYCAAwRCyAGQRhqIAEgAigCEBEAACAGQZACaiICIAYoAhgiASAGKAIcKAIMEQAAIAFFDQUgBikDkAJC09jT+P3m9pJIhSAGKQOYAkKi2J6I4aDq6cwAhYRQRQ0FIAYgBi0ALzoAeyAGIAM6AHoCQAJAIAUtADRFBEAgARDUOiEDIAZBlAJqIAEQ+TQgBiADNgKwAiAGQQA2AqwCIAYgATYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohBSMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQRBqIgcgARC2JAJAAkACQCACKQMQIg5CAlIEQCACKQMYIQ8gAkHEAGoiBCABEMApIARBBCACKAJEQQFqIgRBfyAEGyIEIARBBE0bQQBBCEEQEKAYIAIoAkghBCACKAJEQQFGDQIgAigCTCIJIA83AwggCSAONwMAIAJBDGoiC0EBNgIAIAIgCTYCCCACIAQ2AgQgByABQTD8CgAAIwBBIGsiASQAIAEgBxC2JCABKQMAIg5CAlIEQCACQQRqIQQDQCABKQMIIQ8CQCAEKAIIIgkgBCgCAEcNACABQRRqIAcQwCkgASgCFEEBaiIKQX8gChsiCiAEKAIAIAQoAggiDGtNDQAgBCAMIApBCEEQEN4oCyAEKAIEIAlBBHRqIgogDzcDCCAKIA43AwAgBCAJQQFqNgIIIAEgBxC2JCABKQMAIg5CAlINAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQSBqJAAgCEEIaiALKAIANgIAIAggAikCBDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAQgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAUgAykCADcCACAFQRBqIANBEGooAgA2AgAgBUEIaiADQQhqKQIANwIAIAgQ7TsMAQsgBSADKQIUNwIEIAVBk4CAgHg2AgAgBUEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHsAWooAgA2AgAgBiAGKQLkATcDsAEgBigC4AEiBEGTgICAeEYNASAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC8AEhAgwSCyABENQ6IQUgBkGAAWoiBCABEPk0IAYgBTYCnAEgBkEANgKYASAGIAE2AnwgARDUOhogARDUOiELIAEQ1DoaIAYgARDUOiICNgLkAiAGQegCakF/IAJBB2oiAyACIANLG0EDdhDSHyACQQN0IgghByAIQThxIgIEQCAIIAJrQUBrIgcgCEkNCQtBwAAhCSAHQcAAENE0RQ0JIAcEQCAHQcAAEK02IglFDQsLIAYoAvACIQogBkGcAmogBEEIaikCADcCACAGQaQCaiAEQRBqKQIANwIAIAYgATYCkAJBACECIAZBADYCvAIgBiAFNgKwAiAGQQA2AqwCIAYgBCkCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWpBBHIhDCAGQZQCaiENQQAhBANAIAZB2AJqIQFCAiEOIAQgBUcEfyAGAn4CQAJAAkAgBigClAJFDQAgBCAGKAKkAk8NESAGKAKYAiAGKAKgAiAEaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXFFDQAgBiAEQQFqNgKsAgwBCyAGIARBAWo2AqwCIAZBEGogBigCkAIgBBDaKyAGQeABaiAGKAIQIAYoAhQgBigCtAIsAAAQwgEgBigC4AEiAUEBRw0BIAFFDQAgDBCIEQtCAAwBCyAGKQPoASIOIAYoArgCLQAAEMUprQs3A9gCIAYgBigCvAIiA0EBajYCvAIgBkH4AmoFIAELIA43AwACQAJAAkAgBikD2AIiDkICUgRAIAIgCWohASAOp0EBcUUNASABIAYpA/gCNwMAIAogA0EDdmoiASABLQAAQQEgA0EHcXRyOgAADAILAkAgBigClAIiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgDRD7HgsgBiACQQN1IgE2AuABIAEgBigC5AJHDRAgBigC8AIhASAGKAL0AiEDIAYgBikC6AI3ApwCIAZBADYCmAIgBiADNgKUAiAGIAE2ApACIAZBCGogBkGQAmoiAhDXOyAGKAIIIQRBHEEEEK02IgFFDREgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogBkGYAmoiBSkCADcCACABQRhqIAZBoAJqIgooAgA2AgAgBiAHNgKgAiAGQoCAgICACDcCmAIgBiAINgKUAiAGIAk2ApACIAYgAhDXOyAGKAIAIQdBHEEEEK02IgINAkEEQRwQoz0ACyABQgA3AwALIAJBCGohAiAGKAKwAiEFIAYoAqwCIQQMAQsLIAJCgYCAgBA3AgAgAiAGKQKQAjcCCCACQRBqIAUpAgA3AgAgAkEYaiAKKAIANgIAIAYgAzYC4AIgBiAENgLcAiAGIAE2AtgCQQxBBBCtNiIBRQ0OIAEgCDYCCCABIAc2AgQgASACNgIAIAZBATYC8AIgBiABNgLsAiAGQQE2AugCIAZBADYC6AEgBkKAgICAwAA3AuABIAZBkAJqIgJB3JGAASALIAYgBkHYAmogBkHoAmogBkHgAWoiARCMEyABIAIQtxMgBkGwAWogASAGLQB6IAYtAHsQohMgBi0AsAEiAkEpRw0BIAZB8ABqIAZBwAFqKAIANgIAIAYgBikCuAEiDjcDoAEgBiAONwNoIAYoArQBIQQgBigCxAEhAgwRCyAGQfACaiABKAIAIgE2AgAgBiAGKQOwATcD6AIgBkGQAmoiAiAGKALsAiIDIAMgAUEEdGoQgwkgBkHgAWogAiAGLQB6IAYtAHsQohMgBi0A4AEiAkEpRw0CIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg43A7ABIAYgDjcDaCAGKALkASEEIAYoAvQBIQIgBkHoAmoQ7TsMEAsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFDAILIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAIAFFDQwgBikD4AFCq5iR8ZX61fyAf4UgBikD6AFClpT4q/Cx6bPhAIWEUEUNDCAGQZACaiABIAMgBi0ALyAFELcCIAYtAJACIgJBKUcNAiAGQbgBaiAGQaACaigCACIBNgIAIAYgBikCmAIiDjcDsAEgBigClAIhAiAGKAKkAiEDIABBDGogATYAACAAIA43AAQgACADNgIQIAAgAjYCAAwPCyAGQfgAaiAGLQDjAToAACAGQbgBaiAGQfABaigCACIBNgIAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDhATsBdiAGIAYpAugBIg43A7ABIAYgBikC+AE3A1AgBiAONwNoIAYoAuQBIQEgBigC9AEhBSAGQegCahDtOwsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzAMCwsgBkH4AGogBi0AkwI6AAAgBkHYAGogBkGwAmopAgA3AwAgBkHgAGogBkG4AmopAgA3AwAgBkE4aiAGQaACaigCADYCACAGIAYvAJECOwF2IAYgBikCqAI3A1AgBiAGKQKYAjcDMCAGKAKUAiEBIAYoAqQCIQUMCgsgBkEBNgKUAiAGQbSfgAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBiAGQeABajYCmAIgBiAGQS9qNgLgASAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMCwtB9J2AARCyOwALQZSTgAFBI0G4k4ABEMskAAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQcAAIAcQoz0AC0G0lIABQSBB1JSAARCfKQALIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQeQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBhJ6AARCyOwALQThBBBCtNiIDBEAgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEG8moABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAILQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg43A0AgAEEMaiABNgAAIAAgDjcABCAAIAI2AhAgACAENgIACyAGQYADaiQAC+8VAg1/A34jAEHwBGsiAiQAIAJB6AJqIAEQ2wsgAkH4A2oiByACQfgCaikDADcDACACQYAEaiIDIAJBgANqKQMANwMAIAIgAikD8AI3A/ADAkAgAikD6AIiD0ICUQRAIAAgAikD8AM3AwAgAEEQaiADKQMANwMAIABBCGogBykDADcDAAwBCyACQShqIAJBiANqQTD8CgAAIAJBGGogAkH4A2oiBykDADcDACACQSBqIAJBgARqIgUpAwA3AwAgAiAPNwMIIAIgAikD8AM3AxAgASgCgAUiAy4BGiEEIAMuARghBiABIAEpA5gCIAEpA8gDfDcDmAIgBSACQThqKAIANgIAIAcgAkEwaikDADcDACACIAIpAygiDzcD8AMgAkGMBGogAkHEAGopAgA3AgAgAkGUBGogAkHMAGooAgA2AgAgAiACKQI8NwKEBCABQbABaiEHIAFByANqIQwCQAJAAkAgD6dBAXEEQCACKAKEBEEBRw0BIAJBiAJqIgUgAkE0aikCADcDACACIAIpAiw3A4ACIAJBsAFqIgggAkHIAGopAwA3AwAgAiACKQNANwOoASADQQhqIgMgAkGAAmoiCSABQaACaiADIAkQphEgASgCgAVBCGoiAyACQagBaiIJIAFBtAJqIAMgCRCnESABLQCWBSACQZQDaiAFKQMANwIAIAJBqANqIAgpAwA3AwAgAiACKQOAAjcCjAMgAiACKQOoATcDoAMgAkEBNgKcAyACQQE2AogDIAJBgQI2ArADIAJCATcD+AIgAkIANwPoAiACIAEpA8gDNwOAA0ECRwRAIAJCAjcDWCACQegCahCnJQwECyACQdgAaiACQegCakHQAPwKAAAMAwsgAkICNwNYDAELIAJCAjcDWCACKAL0AyIDRQ0AIAJBgARqIAIoAvgDIAIoAvwDIAMoAhARAQALIAIoAoQERQ0AIAIoAogEIgNFDQAgAkGUBGogAigCjAQgAigCkAQgAygCEBEBAAsgASACQdgAakEAIAIpA1hCAlIbIAIpAwggAikDEBCRByAHIAwQ8yYgAigCCEEBRgRAIAIpAxAhDyABAn4gASgC4AFBAUYEQCABKQPoAQwBCyABQgE3A+ABQgALIA98NwPoAQsgAikDWCEPIAJBgAJqIAJB4ABqIgNByAD8CgAAAkACQCAPQgJSBEAgAiAPNwPwAyACQfgDaiADQcgA/AoAACABKAKEBUEIaiABKAKABUEIahCrEg0BIAJB8ANqEKclCyACQgg3A6gBDAELIAJB+AJqIAJBgAJqQcgA/AoAACACIA83A/ACIAJCBzcD6AIgAkGoAWogASACQegCahDjBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgChAUtAJ0BBEBBACEDIAJBADYC2AIgAkKAgICAEDcC0AJBACEHIARBAEoNAQwDCyACQoCAgIAQNwLQAiACQQA2AtgCIARBAEwNASABKAL4BCEFIAJB8ANqIgMgBCABKAL8BCIHEKsNIAMgBSAHEK4JIAJB6AJqIgQgA0GAAfwKAAAgAkHcAmoiAyAEENAQIAJB0AJqIAIoAuACIAIoAuQCEKE2IAMQ3jsMAQsgASgC+AQhBSACQfADaiIHIAQgASgC/AQiBBDtFiAHIAUgBBCuCSACQegCaiIEIAdBgAH8CgAAIAJB3AJqIgUgBBDQECACQdACaiACKALgAiACKALkAiIHEKE2IAUQ3jsMAQsgBkEASgRAIAEoAuwEIQQgAkHwA2oiAyAGIAEoAvAEIgUQqw0gAyAEIAUQrgkgAkHoAmoiBCADQYAB/AoAACACQdwCaiIDIAQQ0BAgAkHQAmogAigC4AIgAigC5AIQoTYgAxDeOwsgAkHQAmoiBSACKAIcIAIoAiAQoTYgAigC2AIhBAJAIAEoArAERQ0AIAJB6AJqIgggBEEAQQFBARCgGCACKALsAiEDIAIoAugCQQFHBEAgAkEANgL4AyACIAIoAvACNgL0AyACIAM2AvADIAggASgCsAQgAigC1AIgAigC2AIgAkHwA2oiAyABKAK0BCgCDBEHACACKALoAiIIQQhHBEAgACACKQLsAjcCBCAAQRRqIAJB/AJqKAIANgIAIABBDGogAkH0AmopAgA3AgAgACAINgIAIAMQ3jsgBRDeOwwECyACQfACaiIDIAJB+ANqKAIANgIAIAIgAikC8AM3A+gCIAJB0AJqEN47IAJB2AJqIAMoAgA2AgAgAiACKQPoAjcD0AIMAQsgAyACKALwAkHYgs8AEP0vAAsgAkH4A2ogAkHYAmooAgA2AgAgAiACKQPQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC6AMhBSACLQBUIQMgAkGAAmogAkGoAWpB0AD8CgAAIAIoAvQCIQggAigC8AIhCSACKQPoAiEPQgkhEEECIQpBAiELIAIpA/gBDAYLIAZBAEoEQCABKALsBCEEIAJB8ANqIgMgBiABKALwBCIGEO0WIAMgBCAGEK4JIAJB6AJqIgYgA0GAAfwKAAAgAkHcAmoiBCAGENAQIAJB0AJqIAIoAuACIAIoAuQCIgMQoTYgBBDeOwsgAigCICIGIAMgB2pqIQQgASgCsAQiCEUNASACKALYAiEFIAJB6AJqIAggAigCHCAGIAJB0AJqIgYgASgCtAQoAgwRBwAgAigC6AIiCEEIRg0CIAAgAikC7AI3AgQgAEEUaiACQfwCaigCADYCACAAQQxqIAJB9AJqKQIANwIAIAAgCDYCACAGEN47CyACQagBahCsKQwFCyACQdACaiACKAIcIAYQoTYMAQtBASAEIAIoAtgCIAVrSw0BGiACQdACaiIGIAUQ9DQgBiACKAIcIAIoAiAQoTYLQQALIQYgAkH4A2ogAkHYAmooAgA2AgAgAiACKQLQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC7AMhBSABKALIAyEIIAEoAugDIQkgAi0AVCENIAIpA6gBIRAgAkGAAmogAkGwAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiELIAIpA/ACIQ8gAikD6AILIREgASgCWEGAgICAeEcNASACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAJB8ANqIAEgAkHoAmoQpgogAigC8AMiB0EIRg0CIAAgAikC9AM3AgQgAEEUaiACQYQEaigCADYCACAAQQxqIAJB/ANqKQIANwIAIAAgBzYCAAsgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAFB6AJqIAJB6AJqEOogCyABQQA2AvwEIAFBADYC8AQgASABKQP4ASABNQLsA3w3A/gBIAwQ6SAgAEEINgIAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQALIAJB8ARqJAAL5xUCDX8DfiMAQfAEayICJAAgAkHoAmogARDbCyACQfgDaiIHIAJB+AJqKQMANwMAIAJBgARqIgMgAkGAA2opAwA3AwAgAiACKQPwAjcD8AMCQCACKQPoAiIPQgJRBEAgACACKQPwAzcDACAAQRBqIAMpAwA3AwAgAEEIaiAHKQMANwMADAELIAJBKGogAkGIA2pBMPwKAAAgAkEYaiACQfgDaiIHKQMANwMAIAJBIGogAkGABGoiBSkDADcDACACIA83AwggAiACKQPwAzcDECABKAKABSIDLgEaIQQgAy4BGCEGIAEgASkDmAIgASkDyAN8NwOYAiAFIAJBOGooAgA2AgAgByACQTBqKQMANwMAIAIgAikDKCIPNwPwAyACQYwEaiACQcQAaikCADcCACACQZQEaiACQcwAaigCADYCACACIAIpAjw3AoQEIAFBsAFqIQcgAUHIA2ohDAJAAkACQCAPp0EBcQRAIAIoAoQEQQFHDQEgAkGIAmoiBSACQTRqKQIANwMAIAIgAikCLDcDgAIgAkGwAWoiCCACQcgAaikDADcDACACIAIpA0A3A6gBIAJBgAJqIgkgAUGgAmogA0EIaiAJENkYIAJBqAFqIgMgAUG0AmogASgCgAVBCGogAxDaGCABLQCWBSACQZQDaiAFKQMANwIAIAJBqANqIAgpAwA3AwAgAiACKQOAAjcCjAMgAiACKQOoATcDoAMgAkEBNgKcAyACQQE2AogDIAJBgQI2ArADIAJCATcD+AIgAkIANwPoAiACIAEpA8gDNwOAA0ECRwRAIAJCAjcDWCACQegCahCnJQwECyACQdgAaiACQegCakHQAPwKAAAMAwsgAkICNwNYDAELIAJCAjcDWCACKAL0AyIDRQ0AIAJBgARqIAIoAvgDIAIoAvwDIAMoAhARAQALIAIoAoQERQ0AIAIoAogEIgNFDQAgAkGUBGogAigCjAQgAigCkAQgAygCEBEBAAsgASACQdgAakEAIAIpA1hCAlIbIAIpAwggAikDEBCRByAHIAwQ8yYgAigCCEEBRgRAIAIpAxAhDyABAn4gASgC4AFBAUYEQCABKQPoAQwBCyABQgE3A+ABQgALIA98NwPoAQsgAikDWCEPIAJBgAJqIAJB4ABqIgNByAD8CgAAAkACQCAPQgJSBEAgAiAPNwPwAyACQfgDaiADQcgA/AoAACABKAKEBUEIaiABKAKABUEIahCrEg0BIAJB8ANqEKclCyACQgg3A6gBDAELIAJB+AJqIAJBgAJqQcgA/AoAACACIA83A/ACIAJCBjcD6AIgAkGoAWogASACQegCahDjBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgChAUtAJ0BBEBBACEDIAJBADYC2AIgAkKAgICAEDcC0AJBACEHIARBAEoNAQwDCyACQoCAgIAQNwLQAiACQQA2AtgCIARBAEwNASABKAL4BCEFIAJB8ANqIgMgBCABKAL8BCIHEKsNIAMgBSAHEK4JIAJB6AJqIgQgA0GAAfwKAAAgAkHcAmoiAyAEENAQIAJB0AJqIAIoAuACIAIoAuQCEKE2IAMQ3jsMAQsgASgC+AQhBSACQfADaiIHIAQgASgC/AQiBBDtFiAHIAUgBBCuCSACQegCaiIEIAdBgAH8CgAAIAJB3AJqIgUgBBDQECACQdACaiACKALgAiACKALkAiIHEKE2IAUQ3jsMAQsgBkEASgRAIAEoAuwEIQQgAkHwA2oiAyAGIAEoAvAEIgUQqw0gAyAEIAUQrgkgAkHoAmoiBCADQYAB/AoAACACQdwCaiIDIAQQ0BAgAkHQAmogAigC4AIgAigC5AIQoTYgAxDeOwsgAkHQAmoiBSACKAIcIAIoAiAQoTYgAigC2AIhBAJAIAEoArAERQ0AIAJB6AJqIgggBEEAQQFBARCgGCACKALsAiEDIAIoAugCQQFHBEAgAkEANgL4AyACIAIoAvACNgL0AyACIAM2AvADIAggASgCsAQgAigC1AIgAigC2AIgAkHwA2oiAyABKAK0BCgCDBEHACACKALoAiIIQQhHBEAgACACKQLsAjcCBCAAQRRqIAJB/AJqKAIANgIAIABBDGogAkH0AmopAgA3AgAgACAINgIAIAMQ3jsgBRDeOwwECyACQfACaiIDIAJB+ANqKAIANgIAIAIgAikC8AM3A+gCIAJB0AJqEN47IAJB2AJqIAMoAgA2AgAgAiACKQPoAjcD0AIMAQsgAyACKALwAkHYgs8AEP0vAAsgAkH4A2ogAkHYAmooAgA2AgAgAiACKQPQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC6AMhBSACLQBUIQMgAkGAAmogAkGoAWpB0AD8CgAAIAIoAvQCIQggAigC8AIhCSACKQPoAiEPQgkhEEECIQpBAiELIAIpA/gBDAYLIAZBAEoEQCABKALsBCEEIAJB8ANqIgMgBiABKALwBCIGEO0WIAMgBCAGEK4JIAJB6AJqIgYgA0GAAfwKAAAgAkHcAmoiBCAGENAQIAJB0AJqIAIoAuACIAIoAuQCIgMQoTYgBBDeOwsgAigCICIGIAMgB2pqIQQgASgCsAQiCEUNASACKALYAiEFIAJB6AJqIAggAigCHCAGIAJB0AJqIgYgASgCtAQoAgwRBwAgAigC6AIiCEEIRg0CIAAgAikC7AI3AgQgAEEUaiACQfwCaigCADYCACAAQQxqIAJB9AJqKQIANwIAIAAgCDYCACAGEN47CyACQagBahCsKQwFCyACQdACaiACKAIcIAYQoTYMAQtBASAEIAIoAtgCIAVrSw0BGiACQdACaiIGIAUQ9DQgBiACKAIcIAIoAiAQoTYLQQALIQYgAkH4A2ogAkHYAmooAgA2AgAgAiACKQLQAjcD8AMgAkHoAmogAkHwA2oQ5xUgASgC7AMhBSABKALIAyEIIAEoAugDIQkgAi0AVCENIAIpA6gBIRAgAkGAAmogAkGwAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiELIAIpA/ACIQ8gAikD6AILIREgASgCWEGAgICAeEcNASACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAJB8ANqIAEgAkHoAmoQpgogAigC8AMiB0EIRg0CIAAgAikC9AM3AgQgAEEUaiACQYQEaigCADYCACAAQQxqIAJB/ANqKQIANwIAIAAgBzYCAAsgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACIBA3A+gCIAJB8AJqIAJBgAJqQdAA/AoAACACIAQ2AugDIAIgDToA5QMgAiAGOgDkAyACIAc2AuADIAIgDjoA3wMgAiAKOgDeAyACIAs6AN0DIAIgAzoA3AMgAiAFNgLYAyACIAg2AtQDIAIgCTYC0AMgAiAPNwPIAyACIBE3A8ADIAFB6AJqIAJB6AJqEOogCyABQQA2AvwEIAFBADYC8AQgASABKQP4ASABNQLsA3w3A/gBIAwQ6SAgAEEINgIAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQALIAJB8ARqJAAL5TACD38DfiMAQfAEayIDJAAgA0HoAmohByMAQdACayICJAAgAUGwAWoiECIEKQKcASERIARBADYCnAEgBCkCsAEhEiAEQQA2ArABIAJBEGogBEGsAWooAgA2AgAgAkEIaiAEQaQBaikCADcDACACQSBqIARBuAFqKQIANwMAIAJBKGogBEHAAWooAgA2AgAgAiARNwMAIAIgEjcDGAJAAkACQAJAAkAgBCgCAEGAgICAeEcEQCACQagBaiAEKAJYIghBA3YgCEEHcUEAR2oiBUHAACAEKAIUIgZBAWsiCUEAIAYgCU8brXmnayIGQf8BcSIJQQN2IAZBB3FBAEdqQQFqbCIKIAlBAWogBWwiBSAFIApJG0EBakEAQQFBARCgGCACKAKsASEFIAIoAqgBQQFHBEAgAigCsAEiCSAGOgAAIAJBATYCQCACIAk2AjwgAiAFNgI4IAJByABqIgpBAEHAAPwLACACQQA2ApgBIAJBADoARCACQgA3AzAgAiAGOgCkASACQgA3ApwBIAJCADcDiAEgAkJ/NwOQAQJAIAgEQCAEKAJUIQYgCEEDdCEFA0AgAigCnAEhCQJAAkAgBikDACIRIAIpA4gBUgRAIAlBB0sEQCACQTBqEL0NCyACIBE3A4gBIAJBATYCnAEMAQsgAiAJQQFqIgk2ApwBIAlBCEsNAQsgAigCmAEiCUEHSw0DIAogCUEDdGogETcDACACIAIoApgBQQFqIgk2ApgBIAlBCEcNACACQTBqEMonCyAGQQhqIQYgBUEIayIFDQALCyAEQQA2AlggBCkDSCERIARCADcDSCACQagBaiACQTBqQfgA/AoAACACKAKQAiIGIAIoApQCIgQgAigCmAIiBXJyRQ0EAkAgBQ0AIAQgBkcEQCAERSAGcg0BDAULIAQNBAsgBkEBa0EHSQRAIAJBwAFqIQQDQCAEIAZBA3RqQgA3AwAgAiACKAKQAkEBaiIGNgKQAiAGQQhJDQALIAIoApgCIQULIAIgBSAGajYCmAIgAkGoAWpBARD6CyACQQA2ApQCDAQLIAlBCEG8gs4AEMMhAAsgBSACKAKwAUGA+c0AEP0vAAsCQAJAAkACQAJAAkACQEECIAQoAmAiBkGAgICAeHMgBkEAThtBAWsOAgECAAsgBCkCZCERIARCgICAgBA3AmQgAkGwAWogBEHsAGoiCCgCADYCAEEAIQYgCEEANgIAIAIgETcDqAEMBQsgAkGoAWogBCgCcBCNDSACQThqIgYgAkG0AWopAgA3AwAgAiACKQKsATcDMCACKAKoASIIQQhHBEAgAigCvAEhBCAHIAIpAzA3AgwgByAENgIcIAcgCDYCCCAHQgI3AwAgB0EUaiAGKQMANwIADAQLIAJBqAJqIAYpAwAiETcDACACIAIpAzA3A6ACIAJBqAFqIAQoAmwiBSARpyIGakEAQQFBARCgGCACKAKsASEIIAIoAqgBQQFGDQEgAkE4aiIJQQA2AgAgAiACKAKwATYCNCACIAg2AjAgAkEwaiIIIAIoAqQCIgogBhChNiAIIAQoAmggBRChNiAEQQA2AmwgAkGwAWogCSgCADYCACACIAIpAjA3A6gBIAJBrAJqIAogBiACKAKgAigCEBEBAEEFIQYMBAsgAkGoAWogBCgCeBCNDSACQThqIgYgAkG0AWoiCCkCADcDACACIAIpAqwBNwMwIAIoAqgBIgVBCEcEQCACKAK8ASEEIAcgAikDMDcCDCAHIAQ2AhwgByAFNgIIIAdCAjcDACAHQRRqIAYpAwA3AgAMAwsgAkHIAmogBikDADcDACACIAIpAzA3A8ACIAJBqAFqIAQoAnwQjQ0gBiAIKQIANwMAIAIgAikCrAE3AzAgAigCqAEiBkEIRwRAIAIoArwBIQQgByACKQMwNwIMIAcgBDYCHCAHIAY2AgggB0ICNwMAIAdBFGogAkE4aikDADcCACACQcwCaiACKALEAiACKALIAiACKALAAigCEBEBAAwDCyACQagCaiACQThqIgYpAwAiETcDACACIAIpAzA3A6ACIAJBqAFqIAQoAmgiCSARpyIIIAIoAsgCampBAEEBQQEQoBggAigCrAEhBSACKAKoAUEBRg0BIAZBADYCACACIAIoArABNgI0IAIgBTYCMCACQTBqIgUgAigCxAIgAigCyAIQoTYgBSACKAKkAiIKIAgQoTYgBSAEKAJkIAkQoTYgBEEANgJ0IARBADYCaCACQbABaiAGKAIANgIAIAIgAikCMDcDqAEgAkGsAmogCiAIIAIoAqACKAIQEQEAIAJBzAJqIAIoAsQCIAIoAsgCIAIoAsACKAIQEQEAQQYhBgwDCyAIIAIoArABQZD3zQAQ/S8ACyAFIAIoArABQcD3zQAQ/S8ACwJAIAIoAhhFDQAgAigCHCIERQ0AIAJBKGogAigCICACKAIkIAQoAhARAQALIAIoAgBFDQMgAigCBCIERQ0DIAJBEGogAigCCCACKAIMIAQoAhARAQAMAwsgBCkDgAEhESAEQgA3A4ABIAdBEGogAkGoAWoQ5xUgByAGOgBMIAcgETcDCCAHQgE3AwAgBCgCiAEhBiAEQQA2AogBIAcgAikDADcCICAHQShqIAJBCGopAwA3AgAgB0EwaiACQRBqKAIANgIAIAcgAikDGDcCNCAHQTxqIAJBIGopAwA3AgAgB0HEAGogAkEoaigCADYCACAHIAY2AkgMAgsgAkGoAWoQvQ0LIAJBsAJqIgYgAkG4AWoiBSkDADcDACACQagCaiIJIAJBsAFqKQMANwMAIAIgAikDqAEiEjcDoAIgAi0AtAIhBCACIBI3A7gCIARBA3YgBEEHcUEAR2oiBEEJTw0BIAkgAkG4AmogBBChNiACQcgCaiAGKAIANgIAIAIgAikDqAI3A8ACIAUgAkHAAmoQ5xUgAkHQAWogAkEIaikDADcDACACQdgBaiACQRBqKAIANgIAIAJB5AFqIAJBIGopAwA3AgAgAkHsAWogAkEoaigCADYCACACQQc6APQBIAIgCDYC8AEgAiARNwOwASACQgE3A6gBIAIgAikDADcDyAEgAiACKQMYNwLcASAHIAJBqAFqQdAA/AoAAAsgAkHQAmokAAwBCyAEQQhBjILOABCwOwALIANB+ANqIgIgA0H4AmopAwA3AwAgA0GABGoiBCADQYADaikDADcDACADIAMpA/ACNwPwAwJAIAMpA+gCIhFCAlEEQCAAIAMpA/ADNwMAIABBEGogBCkDADcDACAAQQhqIAIpAwA3AwAMAQsgA0EoaiADQYgDakEw/AoAACADQRhqIANB+ANqIgQpAwA3AwAgA0EgaiADQYAEaiIHKQMANwMAIAMgETcDCCADIAMpA/ADNwMQIAEoApgFIgIuARohCCACLgEYIQYgASABKQNoIAEpA+ADfDcDaCAHIANBOGooAgA2AgAgBCADQTBqKQMANwMAIAMgAykDKCIRNwPwAyADQYwEaiADQcQAaikCADcCACADQZQEaiADQcwAaigCADYCACADIAMpAjw3AoQEIAFB4ANqIQ0CQAJAAkAgEadBAXEEQCADKAKEBEEBRw0BIANBiAJqIgcgA0E0aikCADcDACADIAMpAiw3A4ACIANBsAFqIgQgA0HIAGopAwA3AwAgAyADKQNANwOoASADQYACaiIFIAFB8ABqIAJBCGogBRDZGCADQagBaiICIAFBhAFqIAEoApgFQQhqIAIQ2hggAS0ArgUgA0GUA2ogBykDADcCACADQagDaiAEKQMANwMAIAMgAykDgAI3AowDIAMgAykDqAE3A6ADIANBATYCnAMgA0EBNgKIAyADQYECNgKwAyADQgE3A/gCIANCADcD6AIgAyABKQPgAzcDgANBAkcEQCADQgI3A1ggA0HoAmoQpyUMBAsgA0HYAGogA0HoAmpB0AD8CgAADAMLIANCAjcDWAwBCyADQgI3A1ggAygC9AMiAkUNACADQYAEaiADKAL4AyADKAL8AyACKAIQEQEACyADKAKEBEUNACADKAKIBCICRQ0AIANBlARqIAMoAowEIAMoApAEIAIoAhARAQALIANB2ABqQQAgAykDWEICUhshBCADKQMIIREgAykDECESIwBBgAFrIgIkACABLQDcAyEFAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABNQKEBCITIAEpA+ADUgRAIAVBAXFFDQcgBEUNBCAEKAIgRQ0CIAQoAjRFDQMgBEEkaiEFIARBOGohCSABKALQBEUNBiABQeQEaiEKIAFB1ARqIQsgAS0ArAUNAQwFCyAFQQFxRQ0GIAJBADYCSCACQoCAgIAQNwJAIAJBADYCWCACQoCAgIAQNwJQIAFBkANqQQEgAkFAayACQdAAaiATEJUUDAYLIAEoApgFQQhqIAsgBRCJDUUEQCABKAKYBUEIaiAKIAkQiQ1FDQQLIAFBADoArAUMAwtByIDPABCyOwALQdiAzwAQsjsACyABQQA6ANwDDAILIAEtAK0FRQ0AIAEoApgFQQhqIAUgCxCJDUUEQCABKAKYBUEIaiAJIAoQiQ1FDQELIAFBADoArQULAkAgBSgCACIFBEAgAkHgAGogBEEwaiAEKAIoIAQoAiwgBSgCABEFAAwBCyACQQA2AmALIAFB0ARqAkAgCSgCACIJBEAgAkHwAGogBEHEAGogBCgCPCAEKAJAIAkoAgARBQAMAQsgAkEANgJwCyABQZADaiEJIAJBMGoiCiACKQJwNwMAIAJBKGoiCyACQegAaikCADcDACACQThqIgwgAkH4AGopAgA3AwAgAiACKQJgNwMgEPEmIAFBATYC0AQgASACKQMgNwLUBCABQdwEaiALKQMANwIAIAFB5ARqIAopAwA3AgAgAUHsBGogDCkDADcCACABEOkfRQRAIAJBGGogBBDuJyACKAIYIgxFDQIgAkHQAGogAigCHCIFQQBBAUEBEKAYIAIoAlQhCiACKAJQQQFGDQMgAigCWCELIAUEQCALIAwgBfwKAAALIAIgBTYCSCACIAs2AkQgAiAKNgJAIAJBEGogBBDvJyACKAIQIgtFDQQgAkHQAGogAigCFCIEQQBBAUEBEKAYIAIoAlQhBSACKAJQQQFGDQUgAigCWCEKIAQEQCAKIAsgBPwKAAALIAIgBDYCWCACIAo2AlQgAiAFNgJQIAlBACACQUBrIAJB0ABqIAEpA+ADEJUUDAELIAEoApwFIgUoAjwhCiAFKAI4IQUgAkEIaiAEEO4nIAIoAggiC0UNBSACQUBrIgwgASAFIAogCyACKAIMEJ4NIAEoApwFIgUoAjwhCiAFKAI4IQUgAiAEEO8nIAIoAgAiBEUNBiACQdAAaiILIAEgBSAKIAQgAigCBBCaDCAJQQAgDCALIAEpA+ADEJUUCyABQZADaiABQegDaiABQfQDahCWEyABKAKQBEGAgICAeEcEQCABQYgEaiIEIAE1AoQEEKYnIAQgESASENcZCyACQYABaiQADAYLQeiAzwAQsjsACyAKIAIoAlhBwPXOABD9LwALQfiAzwAQsjsACyAFIAIoAlhBwPXOABD9LwALQYiBzwAQsjsAC0GYgc8AELI7AAsgASANEPMmIAMoAghBAUYEQCADKQMQIREgAQJ+IAEoAjBBAUYEQCABKQM4DAELIAFCATcDMEIACyARfDcDOAsgAykDWCERIANBgAJqIANB4ABqIgJByAD8CgAAAkACQCARQgJSBEAgAyARNwPwAyADQfgDaiACQcgA/AoAACABKAKcBUEIaiABKAKYBUEIahCrEg0BIANB8ANqEKclCyADQgg3A6gBDAELIANB+AJqIANBgAJqQcgA/AoAACADIBE3A/ACIANCBjcD6AIgA0GoAWogASADQegCahDkBgsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCnAUtAJ0BBEBBACECIANBADYC2AIgA0KAgICAEDcC0AJBACEHIAhBAEoNAQwDCyADQoCAgIAQNwLQAiADQQA2AtgCIAhBAEwNASABKAKQBSEEIANB8ANqIgIgCCABKAKUBSIHEKsNIAIgBCAHEK4JIANB6AJqIgQgAkGAAfwKAAAgA0HcAmoiAiAEENAQIANB0AJqIAMoAuACIAMoAuQCEKE2IAIQ3jsMAQsgASgCkAUhByADQfADaiIEIAggASgClAUiCBDtFiAEIAcgCBCuCSADQegCaiIHIARBgAH8CgAAIANB3AJqIgQgBxDQECADQdACaiADKALgAiADKALkAiIHEKE2IAQQ3jsMAQsgBkEASgRAIAEoAoQFIQQgA0HwA2oiAiAGIAEoAogFIggQqw0gAiAEIAgQrgkgA0HoAmoiBCACQYAB/AoAACADQdwCaiICIAQQ0BAgA0HQAmogAygC4AIgAygC5AIQoTYgAhDeOwsgA0HQAmoiCCADKAIcIAMoAiAQoTYgAygC2AIhBAJAIAEoAsgERQ0AIANB6AJqIgUgBEEAQQFBARCgGCADKALsAiECIAMoAugCQQFHBEAgA0EANgL4AyADIAMoAvACNgL0AyADIAI2AvADIAUgASgCyAQgAygC1AIgAygC2AIgA0HwA2oiAiABKALMBCgCDBEHACADKALoAiIFQQhHBEAgACADKQLsAjcCBCAAQRRqIANB/AJqKAIANgIAIABBDGogA0H0AmopAgA3AgAgACAFNgIAIAIQ3jsgCBDeOwwECyADQfACaiICIANB+ANqKAIANgIAIAMgAykC8AM3A+gCIANB0AJqEN47IANB2AJqIAIoAgA2AgAgAyADKQPoAjcD0AIMAQsgAiADKALwAkHYgs8AEP0vAAsgA0H4A2ogA0HYAmooAgA2AgAgAyADKQPQAjcD8AMgA0HoAmogA0HwA2oQ5xUgASgCgAQhCCADLQBUIQIgA0GAAmogA0GoAWpB0AD8CgAAIAMoAvQCIQUgAygC8AIhCSADKQPoAiERQgkhEkECIQpBAiELIAMpA/gBDAYLIAZBAEoEQCABKAKEBSEEIANB8ANqIgIgBiABKAKIBSIGEO0WIAIgBCAGEK4JIANB6AJqIgQgAkGAAfwKAAAgA0HcAmoiBiAEENAQIANB0AJqIAMoAuACIAMoAuQCIgIQoTYgBhDeOwsgAygCICIGIAIgB2pqIQQgASgCyAQiBUUNASADKALYAiEIIANB6AJqIAUgAygCHCAGIANB0AJqIgYgASgCzAQoAgwRBwAgAygC6AIiBUEIRg0CIAAgAykC7AI3AgQgAEEUaiADQfwCaigCADYCACAAQQxqIANB9AJqKQIANwIAIAAgBTYCACAGEN47CyADQagBahCsKQwFCyADQdACaiADKAIcIAYQoTYMAQtBASAEIAMoAtgCIAhrSw0BGiADQdACaiIGIAgQ9DQgBiADKAIcIAMoAiAQoTYLQQALIQYgA0H4A2ogA0HYAmooAgA2AgAgAyADKQLQAjcD8AMgA0HoAmogA0HwA2oQ5xUgASgChAQhCCABKALgAyEFIAEoAoAEIQkgAy0AVCEOIAMpA6gBIRIgA0GAAmogA0GwAWpB0AD8CgAAIAJBGHYhDyACQRB2IQogAkEIdiELIAMpA/ACIREgAykD6AILIRMgECgCAEGAgICAeEcNASADIBI3A+gCIANB8AJqIANBgAJqQdAA/AoAACADIAQ2AugDIAMgDjoA5QMgAyAGOgDkAyADIAc2AuADIAMgDzoA3wMgAyAKOgDeAyADIAs6AN0DIAMgAjoA3AMgAyAINgLYAyADIAU2AtQDIAMgCTYC0AMgAyARNwPIAyADIBM3A8ADIANB8ANqIAEgA0HoAmoQpQogAygC8AMiAkEIRg0CIAAgAykC9AM3AgQgAEEUaiADQYQEaigCADYCACAAQQxqIANB/ANqKQIANwIAIAAgAjYCAAsgA0EkaiADKAIcIAMoAiAgAygCGCgCEBEBAAwCCyADIBI3A+gCIANB8AJqIANBgAJqQdAA/AoAACADIAQ2AugDIAMgDjoA5QMgAyAGOgDkAyADIAc2AuADIAMgDzoA3wMgAyAKOgDeAyADIAs6AN0DIAMgAjoA3AMgAyAINgLYAyADIAU2AtQDIAMgCTYC0AMgAyARNwPIAyADIBM3A8ADIAFBgANqIANB6AJqEOogCyABQQA2ApQFIAFBADYCiAUgASABKQNIIAE1AoQEfDcDSCANEOkgIABBCDYCACADQSRqIAMoAhwgAygCICADKAIYKAIQEQEACyADQfAEaiQAC8odAgl/AX4jAEGAA2siBiQAIAYgBDoALwJAAkACQAJAAkACQCAEwEEATgRAAkACQCAEQf8BcUEJTQRAIAEgAigCHBEEACIELQAAQRhrDgMCAgQBCyAGQQE2ApQCIAZB+J6AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGQbyfgAE2AuABIAYgBkHgAWo2ApgCIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwICyAGIAQ2ArABIAZBAjYClAIgBkGsnoABNgKQAiAGQgE3ApwCIAZBrwM2AuQBIAYgBkHgAWo2ApgCIAYgBkGwAWo2AuABIABBBGogBkGQAmoQmQ4gAEGGgICAeDYCAAwHCyAGQRhqIAEgAigCEBEAACAGQZACaiICIAYoAhgiASAGKAIcKAIMEQAAAkAgAUUNACAGKQOQAkLH2fTn3sS2nHeFIAYpA5gCQo2yzpSMypLmp3+FhFBFDQAgBiAGLQAvOgB7IAYgAzoAeiAFLQA0RQRAIAEQ0zohAyAGQZQCaiABEPk0IAYgAzYCsAIgBkEANgKsAiAGIAE2ApACIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZB4AFqIQcjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohCCMAQdAAayICJAAgAkEIaiABIAJBIGoiBCABKAIsEP8KAkACQAJAIAIoAggiCUF+cUECRwRAIAIoAgwhDCAEIAEQwikgBEEEIAIoAiBBAWoiBUF/IAUbIgUgBUEETRtBAEEEQQgQoBggAigCJCEFIAIoAiBBAUYNAiACKAIoIgogDDYCBCAKIAk2AgAgAkEcaiINQQE2AgAgAiAKNgIYIAIgBTYCFCAEIAFBMPwKAAAjAEEgayIBJAAgAUEIaiAEIAFBFGogBCgCLBD/CiABKAIIIgpBfnFBAkcEQCACQRRqIQUgASgCDCEJA0ACQCAFKAIIIgwgBSgCAEcNACABQRRqIAQQwikgASgCFEEBaiILQX8gCxsiCyAFKAIAIAUoAggiDmtNDQAgBSAOIAtBBEEIEN4oCyAFKAIEIAxBA3RqIgsgCTYCBCALIAo2AgAgBSAMQQFqNgIIIAEgBCABQRRqIAQoAiwQ/wogASgCBCEJIAEoAgAiCkF+cUECRw0ACwsCQCAEKAIEIgVFDQAgBSAFKAIAIgVBAWs2AgAgBUEBRw0AIARBBGoQ+x4LIAFBIGokACAIQQhqIA0oAgA2AgAgCCACKQIUNwIADAELIAhBADYCCCAIQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgBSACKAIoQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgByADKQIANwIAIAdBEGogA0EQaigCADYCACAHQQhqIANBCGopAgA3AgAgCBDqOwwBCyAHIAMpAhQ3AgQgB0GTgICAeDYCACAHQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQewBaigCADYCACAGIAYpAuQBNwOwASAGKALgASIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALwASECDAcLIAEQ0zohAyAGQYABaiICIAEQ+TQgBiADNgKcASAGQQA2ApgBIAYgATYCfCABENM6GiABENM6IQwgARDTOhogBiABENM6IgQ2AuQCIAZB6AJqQX8gBEEHaiIFIAQgBUsbQQN2ENIfIARBAnQiCCEHAkAgCEE8cSIEBEAgCCAEa0FAayIHIAhJDQELQcAAIQogB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiCkUNAQsgBigC8AIhDSAGQZwCaiACQQhqKQIANwIAIAZBpAJqIAJBEGopAgA3AgAgBiABNgKQAiAGQQA2ArwCIAYgAzYCsAIgBkEANgKsAiAGIAIpAgA3ApQCIAYgBkH6AGo2ArgCIAYgBkH7AGo2ArQCIAZBlAJqIQtBACECQQAhBAJAAkACQANAIAZB2AJqIQFBAiEFIAMgBEcEfyAGAn8CQAJAAkAgBigClAJFDQAgBCAGKAKkAk8NASAGKAKYAiAGKAKgAiAEaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXFFDQAgBiAEQQFqNgKsAgwCCyAGIARBAWo2AqwCIAZBEGogBigCkAIgBBCPLCAGQeABaiIBIAYoAhAgBigCFCAGKAK0AiwAABDHASAGKALgAUGTgICAeEcEQCABEIgRDAILIAYoAuQBIgUgBigCuAItAAAQxCkMAgtBtJSAAUEgQdSUgAEQnykAC0EACzYC2AIgBiAGKAK8AiIJQQFqNgK8AiAGQfwCagUgAQsgBTYCAAJAAkACQCAGKALYAiIDQQJHBEAgAiAKaiEBIANBAXFFDQEgASAGKAL8AjYCACANIAlBA3ZqIgEgAS0AAEEBIAlBB3F0cjoAAAwCCwJAIAYoApQCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAsQ+x4LIAYgAkECdSIBNgLgASABIAYoAuQCRw0EIAYoAvACIQEgBigC9AIhAyAGIAYpAugCNwKcAiAGQQA2ApgCIAYgAzYClAIgBiABNgKQAiAGQQhqIAZBkAJqIgIQ1zsgBigCCCEEQRxBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgASAGKQKQAjcCCCABQRBqIAZBmAJqIgUpAgA3AgAgAUEYaiAGQaACaiIJKAIANgIAIAYgBzYCoAIgBkKAgICAgAg3ApgCIAYgCDYClAIgBiAKNgKQAiAGIAIQ1zsgBigCACEHQRxBBBCtNiICDQJBBEEcEKM9AAsgAUEANgIACyACQQRqIQIgBigCsAIhAyAGKAKsAiEEDAELCyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAFKQIANwIAIAJBGGogCSgCADYCACAGIAM2AuACIAYgBDYC3AIgBiABNgLYAkEMQQQQrTYiAUUNAiABIAg2AgggASAHNgIEIAEgAjYCACAGQQE2AvACIAYgATYC7AIgBkEBNgLoAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQYCSgAEgDCAGIAZB2AJqIAZB6AJqIAZB4AFqIgEQjBMgASACEMMTIAZBsAFqIAEgBi0AeiAGLQB7EKATIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg83A6ABIAYgDzcDaCAGKAK0ASEEIAYoAsQBIQIMDQsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFDAoLIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQeQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBwAAgBxCjPQALQeSUgAFBKSAGQZACakHIl4ABQZCVgAEQ1R4AC0GUk4ABQSNBuJOAARDLJAALQfSdgAEQsjsACyAGQQE2ApQCIAZBtJ+AATYCkAIgBkIBNwKcAiAGQfQLNgLkASAGIAZB4AFqNgKYAiAGIAZBL2o2AuABIABBBGogBkGQAmoQmQ4gAEGNgICAeDYCAAwFCyAGQSBqIAEgAigCEBEAACAGQeABaiAGKAIgIgEgBigCJCgCDBEAAAJAIAFFDQAgBikD4AFCq5iR8ZX61fyAf4UgBikD6AFClpT4q/Cx6bPhAIWEUEUNACAGQZACaiABIAMgBi0ALyAFEL0CIAYtAJACIgJBKUYEQCAGQbgBaiAGQaACaigCACIBNgIAIAYgBikCmAIiDzcDsAEgBigClAIhAiAGKAKkAiEDIABBDGogATYAACAAIA83AAQgACADNgIQIAAgAjYCAAwGCyAGQfgAaiAGLQCTAjoAACAGQdgAaiAGQbACaikCADcDACAGQeAAaiAGQbgCaikCADcDACAGQThqIAZBoAJqKAIANgIAIAYgBi8AkQI7AXYgBiAGKQKoAjcDUCAGIAYpApgCNwMwIAYoApQCIQEgBigCpAIhBQwDC0GEnoABELI7AAsgBkHwAmogASgCACIBNgIAIAYgBikDsAE3A+gCIAZBkAJqIgIgBigC7AIiAyADIAFBA3RqEPkIIAZB4AFqIAIgBi0AeiAGLQB7EKATIAYtAOABIgJBKUYEQCAGQbgBaiAGQfABaigCACIBNgIAIAZB8ABqIAE2AgAgBiAGKQLoASIPNwOwASAGIA83A2ggBigC5AEhBCAGKAL0ASECIAZB6AJqEOo7DAMLIAZB+ABqIAYtAOMBOgAAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHYAGogBkGAAmopAgA3AwAgBkHgAGogBkGIAmopAgA3AwAgBkHwAGogATYCACAGIAYvAOEBOwF2IAYgBikC6AEiDzcDsAEgBiAGKQL4ATcDUCAGIA83A2ggBigC5AEhASAGKAL0ASEFIAZB6AJqEOo7CyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgMEQCADIAI6AAggA0KBgICAEDcCACADIAYvAXY7AAkgAyABNgIMIAMgBikDMDcCECADIAU2AhwgAyAGKQNQNwIgIANBC2ogBkH4AGotAAA6AAAgA0EYaiAGQThqKAIANgIAIANBKGogBkHYAGopAwA3AgAgA0EwaiAGQeAAaikDADcCACAAQeSZgAE2AgggACADNgIEIABBk4CAgHg2AgAMAgtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDzcDQCAAQQxqIAE2AAAgACAPNwAEIAAgAjYCECAAIAQ2AgALIAZBgANqJAALyh0CCX8BfiMAQYADayIGJAAgBiAEOgAvAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQQlNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYClAIgBkH4noABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAZBvJ+AATYC4AEgBiAGQeABajYCmAIgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAgLIAYgBDYCsAEgBkECNgKUAiAGQayegAE2ApACIAZCATcCnAIgBkGvAzYC5AEgBiAGQeABajYCmAIgBiAGQbABajYC4AEgAEEEaiAGQZACahCZDiAAQYaAgIB4NgIADAcLIAZBGGogASACKAIQEQAAIAZBkAJqIgIgBigCGCIBIAYoAhwoAgwRAAACQCABRQ0AIAYpA5ACQtPY0/j95vaSSIUgBikDmAJCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgARDUOiEDIAZBlAJqIAEQ+TQgBiADNgKwAiAGQQA2AqwCIAYgATYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohByMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQQhqIAEgAkEgaiIEIAEoAiwQ/goCQAJAAkAgAigCCCIJQX5xQQJHBEAgAigCDCEMIAQgARDAKSAEQQQgAigCIEEBaiIFQX8gBRsiBSAFQQRNG0EAQQRBCBCgGCACKAIkIQUgAigCIEEBRg0CIAIoAigiCiAMNgIEIAogCTYCACACQRxqIg1BATYCACACIAo2AhggAiAFNgIUIAQgAUEw/AoAACMAQSBrIgEkACABQQhqIAQgAUEUaiAEKAIsEP4KIAEoAggiCkF+cUECRwRAIAJBFGohBSABKAIMIQkDQAJAIAUoAggiDCAFKAIARw0AIAFBFGogBBDAKSABKAIUQQFqIgtBfyALGyILIAUoAgAgBSgCCCIOa00NACAFIA4gC0EEQQgQ3igLIAUoAgQgDEEDdGoiCyAJNgIEIAsgCjYCACAFIAxBAWo2AgggASAEIAFBFGogBCgCLBD+CiABKAIEIQkgASgCACIKQX5xQQJHDQALCwJAIAQoAgQiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgBEEEahD7HgsgAUEgaiQAIAhBCGogDSgCADYCACAIIAIpAhQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHQAGokAAwBCyAFIAIoAihBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAHIAMpAgA3AgAgB0EQaiADQRBqKAIANgIAIAdBCGogA0EIaikCADcCACAIEOo7DAELIAcgAykCFDcCBCAHQZOAgIB4NgIAIAdBDGogA0EcaigCADYCAAsgA0HQAGokACAGQbgBaiIBIAZB7AFqKAIANgIAIAYgBikC5AE3A7ABIAYoAuABIgRBk4CAgHhGDQQgBkHwAGogASgCADYCACAGIAYpA7ABNwNoIAYoAvABIQIMBwsgARDUOiEDIAZBgAFqIgIgARD5NCAGIAM2ApwBIAZBADYCmAEgBiABNgJ8IAEQ1DoaIAEQ1DohDCABENQ6GiAGIAEQ1DoiBDYC5AIgBkHoAmpBfyAEQQdqIgUgBCAFSxtBA3YQ0h8gBEECdCIIIQcCQCAIQTxxIgQEQCAIIARrQUBrIgcgCEkNAQtBwAAhCiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIKRQ0BCyAGKALwAiENIAZBnAJqIAJBCGopAgA3AgAgBkGkAmogAkEQaikCADcCACAGIAE2ApACIAZBADYCvAIgBiADNgKwAiAGQQA2AqwCIAYgAikCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkGUAmohC0EAIQJBACEEAkACQAJAA0AgBkHYAmohAUECIQUgAyAERwR/IAYCfwJAAkACQCAGKAKUAkUNACAEIAYoAqQCTw0BIAYoApgCIAYoAqACIARqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAGIARBAWo2AqwCDAILIAYgBEEBajYCrAIgBkEQaiAGKAKQAiAEENorIAZB4AFqIgEgBigCECAGKAIUIAYoArQCLAAAEMcBIAYoAuABQZOAgIB4RwRAIAEQiBEMAgsgBigC5AEiBSAGKAK4Ai0AABDEKQwCC0G0lIABQSBB1JSAARCfKQALQQALNgLYAiAGIAYoArwCIglBAWo2ArwCIAZB/AJqBSABCyAFNgIAAkACQAJAIAYoAtgCIgNBAkcEQCACIApqIQEgA0EBcUUNASABIAYoAvwCNgIAIA0gCUEDdmoiASABLQAAQQEgCUEHcXRyOgAADAILAkAgBigClAIiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgCxD7HgsgBiACQQJ1IgE2AuABIAEgBigC5AJHDQQgBigC8AIhASAGKAL0AiEDIAYgBikC6AI3ApwCIAZBADYCmAIgBiADNgKUAiAGIAE2ApACIAZBCGogBkGQAmoiAhDXOyAGKAIIIQRBHEEEEK02IgFFDQUgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogBkGYAmoiBSkCADcCACABQRhqIAZBoAJqIgkoAgA2AgAgBiAHNgKgAiAGQoCAgICACDcCmAIgBiAINgKUAiAGIAo2ApACIAYgAhDXOyAGKAIAIQdBHEEEEK02IgINAkEEQRwQoz0ACyABQQA2AgALIAJBBGohAiAGKAKwAiEDIAYoAqwCIQQMAQsLIAJCgYCAgBA3AgAgAiAGKQKQAjcCCCACQRBqIAUpAgA3AgAgAkEYaiAJKAIANgIAIAYgAzYC4AIgBiAENgLcAiAGIAE2AtgCQQxBBBCtNiIBRQ0CIAEgCDYCCCABIAc2AgQgASACNgIAIAZBATYC8AIgBiABNgLsAiAGQQE2AugCIAZBADYC6AEgBkKAgICAwAA3AuABIAZBkAJqIgJBgJKAASAMIAYgBkHYAmogBkHoAmogBkHgAWoiARCMEyABIAIQwxMgBkGwAWogASAGLQB6IAYtAHsQoBMgBi0AsAEiAkEpRgRAIAZB8ABqIAZBwAFqKAIANgIAIAYgBikCuAEiDzcDoAEgBiAPNwNoIAYoArQBIQQgBigCxAEhAgwNCyAGQfgAaiAGLQCzAToAACAGQdgAaiAGQdABaikCADcDACAGQeAAaiAGQdgBaikCADcDACAGQfAAaiAGQcABaigCADYCACAGIAYvALEBOwF2IAYgBikCyAE3A1AgBiAGKQK4ATcDaCAGKAK0ASEBIAYoAsQBIQUMCgsgBkIANwKcAiAGQoGAgIDAADcClAIgBkHEkYABNgKQAkEAIAZB4AFqIAZB5AJqIAZBkAJqQcyRgAEQrysAC0EEQRwQoz0AC0EEQQwQoz0AC0HAACAHEKM9AAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAULIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPgAUKrmJHxlfrV/IB/hSAGKQPoAUKWlPir8LHps+EAhYRQRQ0AIAZBkAJqIAEgAyAGLQAvIAUQvQIgBi0AkAIiAkEpRgRAIAZBuAFqIAZBoAJqKAIAIgE2AgAgBiAGKQKYAiIPNwOwASAGKAKUAiECIAYoAqQCIQMgAEEMaiABNgAAIAAgDzcABCAAIAM2AhAgACACNgIADAYLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAMLQYSegAEQsjsACyAGQfACaiABKAIAIgE2AgAgBiAGKQOwATcD6AIgBkGQAmoiAiAGKALsAiIDIAMgAUEDdGoQ+QggBkHgAWogAiAGLQB6IAYtAHsQoBMgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg83A7ABIAYgDzcDaCAGKALkASEEIAYoAvQBIQIgBkHoAmoQ6jsMAwsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASIPNwOwASAGIAYpAvgBNwNQIAYgDzcDaCAGKALkASEBIAYoAvQBIQUgBkHoAmoQ6jsLIAZBOGogBkHwAGooAgA2AgAgBiAGKQNoNwMwC0E4QQQQrTYiAwRAIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABB5JmAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwCC0EEQTgQoz0ACyAGQcgAaiAGQfAAaigCACIBNgIAIAYgBikDaCIPNwNAIABBDGogATYAACAAIA83AAQgACACNgIQIAAgBDYCAAsgBkGAA2okAAvZHQIHfwR+IwBB8AJrIgYkACAGIAQ6AC8CQAJAAkACQAJAAkACQAJAAkACQAJAIATAQQBOBEACQAJAIARB/wFxQSZNBEAgASACKAIcEQQAIgQtAABBGGsOAwICBAELIAZBATYClAIgBkH4noABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAZBvZ+AATYC4AEgBiAGQeABajYCmAIgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADA0LIAYgBDYCsAEgBkECNgKUAiAGQayegAE2ApACIAZCATcCnAIgBkGvAzYC5AEgBiAGQeABajYCmAIgBiAGQbABajYC4AEgAEEEaiAGQZACahCZDiAAQYaAgIB4NgIADAwLIAZBGGogASACKAIQEQAAIAZBkAJqIgQgBigCGCICIAYoAhwoAgwRAAACQCACRQ0AIAYpA5ACQtPY0/j95vaSSIUgBikDmAJCotieiOGg6unMAIWEUEUNACAGIAYtAC86AHsgBiADOgB6IAUtADRFBEAgAhDUOiEBIAZBlAJqIAIQ+TQgBiABNgKwAiAGQQA2AqwCIAYgAjYCkAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgBkHgAWohBSMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBEEs/AoAACADIAM2AkwgA0EUaiEKIwBB0ABrIgIkACACQRBqIgcgARC3HQJAAkACQCACKQMYIg0gAikDECIOQgKFhFBFBEAgAikDKCEPIAIpAyAhECACQcQAaiIEIAEQwCkgBEEEIAIoAkRBAWoiBEF/IAQbIgQgBEEETRtBAEEQQSAQoBggAigCSCEIIAIoAkRBAUYNAiACKAJMIgQgDzcDGCAEIBA3AxAgBCANNwMIIAQgDjcDACACQQxqIgtBATYCACACIAQ2AgggAiAINgIEIAcgAUEw/AoAACMAQTBrIgEkACABIAcQtx0gASkDCCINIAEpAwAiDkIChYRQRQRAIAJBBGohBANAIAEpAxghDyABKQMQIRACQCAEKAIIIgkgBCgCAEcNACABQSRqIAcQwCkgASgCJEEBaiIIQX8gCBsiCCAEKAIAIAQoAggiDGtNDQAgBCAMIAhBEEEgEN4oCyAEKAIEIAlBBXRqIgggDzcDGCAIIBA3AxAgCCANNwMIIAggDjcDACAEIAlBAWo2AgggASAHELcdIAEpAwgiDSABKQMAIg5CAoWEUEUNAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQTBqJAAgCkEIaiALKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAggAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAUgAykCADcCACAFQRBqIANBEGooAgA2AgAgBUEIaiADQQhqKQIANwIAIAoQ5TwMAQsgBSADKQIUNwIEIAVBk4CAgHg2AgAgBUEMaiADQRxqKAIANgIACyADQdAAaiQAIAZBuAFqIgEgBkHsAWooAgA2AgAgBiAGKQLkATcDsAEgBigC4AEiBEGTgICAeEYNBCAGQfAAaiABKAIANgIAIAYgBikDsAE3A2ggBigC8AEhAgwMCyACENQ6IQcgBkGAAWoiBCACEPk0IAYgBzYCnAEgBkEANgKYASAGIAI2AnwgAhDUOhogAhDUOiEKIAIQ1DoaIAYgAhDUOiIBNgLUAiAGQeACakF/IAFBB2oiAyABIANLG0EDdhDSHyABQQR0IgMhBQJAIANBMHEiAQRAIAMgAWtBQGsiBSADSQ0BC0HAACEBIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgFFDQELIAYoAugCIQggBkGcAmogBEEIaikCADcCACAGQaQCaiAEQRBqKQIANwIAIAYgAjYCkAJBACECIAZBADYCvAIgBiAHNgKwAiAGQQA2AqwCIAYgBCkCADcClAIgBiAGQfoAajYCuAIgBiAGQfsAajYCtAIgASEEIAdFDQcgBkHgAWpBBHIhBwNAAkACQAJAAkACQAJAAkAgBigClAJFDQAgAiAGKAKkAk8NBCAGKAKYAiAGKAKgAiACaiIJQQN2ai0AAEH/AXMgCUEHcXZBAXFFDQAgBiACQQFqNgKsAgwBCyAGIAJBAWo2AqwCIAZBEGogBigCkAIgAhDaKyAGQeABaiAGKAIQIAYoAhQgBigCtAIsAAAQxgEgBigC4AEiAkEBRw0BIAJFDQAgBxCIEQsgBiAGKAK8AkEBajYCvAIMAQsgBikD8AEiDSAGKQP4ASIOIAYoArgCLQAAEP8gIAYgBigCvAIiAkEBajYCvAINAgsgBEIANwMIIARCADcDAAwCC0G0lIABQSBB1JSAARCfKQALIAQgDTcDACAEIA43AwggCCACQQN2aiIJIAktAABBASACQQdxdHI6AAALIARBEGohBCAGKAKsAiICIAYoArACRw0ACwwHC0HAACAFEKM9AAtB5JSAAUEpIAZBkAJqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAtB9J2AARCyOwALIAZBATYClAIgBkG0n4ABNgKQAiAGQgE3ApwCIAZB9As2AuQBIAYgBkHgAWo2ApgCIAYgBkEvajYC4AEgAEEEaiAGQZACahCZDiAAQY2AgIB4NgIADAoLIAZBIGogASACKAIQEQAAIAZB4AFqIAYoAiAiASAGKAIkKAIMEQAAAkAgAUUNACAGKQPgAUKrmJHxlfrV/IB/hSAGKQPoAUKWlPir8LHps+EAhYRQRQ0AIAZBkAJqIAEgAyAGLQAvIAUQvgIgBi0AkAIiAkEpRgRAIAZBuAFqIAZBoAJqKAIAIgE2AgAgBiAGKQKYAiINNwOwASAGKAKUAiECIAYoAqQCIQMgAEEMaiABNgAAIAAgDTcABCAAIAM2AhAgACACNgIADAsLIAZB+ABqIAYtAJMCOgAAIAZB2ABqIAZBsAJqKQIANwMAIAZB4ABqIAZBuAJqKQIANwMAIAZBOGogBkGgAmooAgA2AgAgBiAGLwCRAjsBdiAGIAYpAqgCNwNQIAYgBikCmAI3AzAgBigClAIhASAGKAKkAiEFDAQLQYSegAEQsjsACyAGQegCaiABKAIAIgE2AgAgBiAGKQOwATcD4AIgBkGQAmoiAiAGKALkAiIDIAMgAUEFdGoQ9gggBkHgAWogAiAGLQB6IAYtAHsQoRMgBi0A4AEiAkEpRgRAIAZBuAFqIAZB8AFqKAIAIgE2AgAgBkHwAGogATYCACAGIAYpAugBIg03A7ABIAYgDTcDaCAGKALkASEEIAYoAvQBIQIgBkHgAmoQ5TwMCAsgBkH4AGogBi0A4wE6AAAgBkG4AWogBkHwAWooAgAiATYCACAGQdgAaiAGQYACaikCADcDACAGQeAAaiAGQYgCaikCADcDACAGQfAAaiABNgIAIAYgBi8A4QE7AXYgBiAGKQLoASINNwOwASAGIAYpAvgBNwNQIAYgDTcDaCAGKALkASEBIAYoAvQBIQUgBkHgAmoQ5TwMAQsCQCAGKAKUAiICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAGQZQCahD7HgsgBiAEIAFrQQR1IgI2AuABIAIgBigC1AJHDQIgBigC6AIhAiAGKALsAiEEIAYgBikC4AI3ApwCIAZBADYCmAIgBiAENgKUAiAGIAI2ApACIAZBCGogBkGQAmoiBxDXOyAGKAIIIQhBHEEEEK02IgJFDQMgAkKBgICAEDcCACACIAYpApACNwIIIAJBEGogBkGYAmoiCSkCADcCACACQRhqIAZBoAJqIgsoAgA2AgAgBiAFNgKgAiAGQoCAgICACDcCmAIgBiADNgKUAiAGIAE2ApACIAYgBxDXOyAGKAIAIQVBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAYpApACNwIIIAFBEGogCSkCADcCACABQRhqIAsoAgA2AgAgBiAENgLcAiAGIAg2AtgCIAYgAjYC1AJBDEEEEK02IgJFDQQgAiADNgIIIAIgBTYCBCACIAE2AgAgBkEBNgLoAiAGIAI2AuQCIAZBATYC4AIgBkEANgLoASAGQoCAgIDAADcC4AEgBkGQAmoiAkH0kYABIAogBiAGQdQCaiAGQeACaiAGQeABaiIBEIwTIAEgAhCwEyAGQbABaiABIAYtAHogBi0AexChEyAGLQCwASICQSlGBEAgBkHwAGogBkHAAWooAgA2AgAgBiAGKQK4ASINNwOgASAGIA03A2ggBigCtAEhBCAGKALEASECDAcLIAZB+ABqIAYtALMBOgAAIAZB2ABqIAZB0AFqKQIANwMAIAZB4ABqIAZB2AFqKQIANwMAIAZB8ABqIAZBwAFqKAIANgIAIAYgBi8AsQE7AXYgBiAGKQLIATcDUCAGIAYpArgBNwNoIAYoArQBIQEgBigCxAEhBQsgBkE4aiAGQfAAaigCADYCACAGIAYpA2g3AzALQThBBBCtNiIDRQ0DIAMgAjoACCADQoGAgIAQNwIAIAMgBi8BdjsACSADIAE2AgwgAyAGKQMwNwIQIAMgBTYCHCADIAYpA1A3AiAgA0ELaiAGQfgAai0AADoAACADQRhqIAZBOGooAgA2AgAgA0EoaiAGQdgAaikDADcCACADQTBqIAZB4ABqKQMANwIAIABBtJiAATYCCCAAIAM2AgQgAEGTgICAeDYCAAwFCyAGQgA3ApwCIAZCgYCAgMAANwKUAiAGQcSRgAE2ApACQQAgBkHgAWogBkHUAmogBkGQAmpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALQQRBOBCjPQALIAZByABqIAZB8ABqKAIAIgE2AgAgBiAGKQNoIg03A0AgAEEMaiABNgAAIAAgDTcABCAAIAI2AhAgACAENgIACyAGQfACaiQAC9kdAgd/BH4jAEHwAmsiBiQAIAYgBDoALwJAAkACQAJAAkACQAJAAkACQAJAAkAgBMBBAE4EQAJAAkAgBEH/AXFBJk0EQCABIAIoAhwRBAAiBC0AAEEYaw4DAgIEAQsgBkEBNgKUAiAGQfiegAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBkG9n4ABNgLgASAGIAZB4AFqNgKYAiAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMDQsgBiAENgKwASAGQQI2ApQCIAZBrJ6AATYCkAIgBkIBNwKcAiAGQa8DNgLkASAGIAZB4AFqNgKYAiAGIAZBsAFqNgLgASAAQQRqIAZBkAJqEJkOIABBhoCAgHg2AgAMDAsgBkEYaiABIAIoAhARAAAgBkGQAmoiBCAGKAIYIgIgBigCHCgCDBEAAAJAIAJFDQAgBikDkAJCx9n0597Etpx3hSAGKQOYAkKNss6UjMqS5qd/hYRQRQ0AIAYgBi0ALzoAeyAGIAM6AHogBS0ANEUEQCACENM6IQEgBkGUAmogAhD5NCAGIAE2ArACIAZBADYCrAIgBiACNgKQAiAGIAZB+gBqNgK4AiAGIAZB+wBqNgK0AiAGQeABaiEFIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAEQSz8CgAAIAMgAzYCTCADQRRqIQojAEHQAGsiAiQAIAJBEGoiByABELkdAkACQAJAIAIpAxgiDSACKQMQIg5CAoWEUEUEQCACKQMoIQ8gAikDICEQIAJBxABqIgQgARDCKSAEQQQgAigCREEBaiIEQX8gBBsiBCAEQQRNG0EAQRBBIBCgGCACKAJIIQggAigCREEBRg0CIAIoAkwiBCAPNwMYIAQgEDcDECAEIA03AwggBCAONwMAIAJBDGoiC0EBNgIAIAIgBDYCCCACIAg2AgQgByABQTD8CgAAIwBBMGsiASQAIAEgBxC5HSABKQMIIg0gASkDACIOQgKFhFBFBEAgAkEEaiEEA0AgASkDGCEPIAEpAxAhEAJAIAQoAggiCSAEKAIARw0AIAFBJGogBxDCKSABKAIkQQFqIghBfyAIGyIIIAQoAgAgBCgCCCIMa00NACAEIAwgCEEQQSAQ3igLIAQoAgQgCUEFdGoiCCAPNwMYIAggEDcDECAIIA03AwggCCAONwMAIAQgCUEBajYCCCABIAcQuR0gASkDCCINIAEpAwAiDkIChYRQRQ0ACwsCQCAHKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAdBBGoQ+x4LIAFBMGokACAKQQhqIAsoAgA2AgAgCiACKQIENwIADAELIApBADYCCCAKQoCAgICAAjcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgCCACKAJMQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBSADKQIANwIAIAVBEGogA0EQaigCADYCACAFQQhqIANBCGopAgA3AgAgChDlPAwBCyAFIAMpAhQ3AgQgBUGTgICAeDYCACAFQQxqIANBHGooAgA2AgALIANB0ABqJAAgBkG4AWoiASAGQewBaigCADYCACAGIAYpAuQBNwOwASAGKALgASIEQZOAgIB4Rg0EIAZB8ABqIAEoAgA2AgAgBiAGKQOwATcDaCAGKALwASECDAwLIAIQ0zohByAGQYABaiIEIAIQ+TQgBiAHNgKcASAGQQA2ApgBIAYgAjYCfCACENM6GiACENM6IQogAhDTOhogBiACENM6IgE2AtQCIAZB4AJqQX8gAUEHaiIDIAEgA0sbQQN2ENIfIAFBBHQiAyEFAkAgA0EwcSIBBEAgAyABa0FAayIFIANJDQELQcAAIQEgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiAUUNAQsgBigC6AIhCCAGQZwCaiAEQQhqKQIANwIAIAZBpAJqIARBEGopAgA3AgAgBiACNgKQAkEAIQIgBkEANgK8AiAGIAc2ArACIAZBADYCrAIgBiAEKQIANwKUAiAGIAZB+gBqNgK4AiAGIAZB+wBqNgK0AiABIQQgB0UNByAGQeABakEEciEHA0ACQAJAAkACQAJAAkACQCAGKAKUAkUNACACIAYoAqQCTw0EIAYoApgCIAYoAqACIAJqIglBA3ZqLQAAQf8BcyAJQQdxdkEBcUUNACAGIAJBAWo2AqwCDAELIAYgAkEBajYCrAIgBkEQaiAGKAKQAiACEI8sIAZB4AFqIAYoAhAgBigCFCAGKAK0AiwAABDGASAGKALgASICQQFHDQEgAkUNACAHEIgRCyAGIAYoArwCQQFqNgK8AgwBCyAGKQPwASINIAYpA/gBIg4gBigCuAItAAAQ/yAgBiAGKAK8AiICQQFqNgK8Ag0CCyAEQgA3AwggBEIANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBCANNwMAIAQgDjcDCCAIIAJBA3ZqIgkgCS0AAEEBIAJBB3F0cjoAAAsgBEEQaiEEIAYoAqwCIgIgBigCsAJHDQALDAcLQcAAIAUQoz0AC0HklIABQSkgBkGQAmpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQAC0H0nYABELI7AAsgBkEBNgKUAiAGQbSfgAE2ApACIAZCATcCnAIgBkH0CzYC5AEgBiAGQeABajYCmAIgBiAGQS9qNgLgASAAQQRqIAZBkAJqEJkOIABBjYCAgHg2AgAMCgsgBkEgaiABIAIoAhARAAAgBkHgAWogBigCICIBIAYoAiQoAgwRAAACQCABRQ0AIAYpA+ABQquYkfGV+tX8gH+FIAYpA+gBQpaU+Kvwsemz4QCFhFBFDQAgBkGQAmogASADIAYtAC8gBRC+AiAGLQCQAiICQSlGBEAgBkG4AWogBkGgAmooAgAiATYCACAGIAYpApgCIg03A7ABIAYoApQCIQIgBigCpAIhAyAAQQxqIAE2AAAgACANNwAEIAAgAzYCECAAIAI2AgAMCwsgBkH4AGogBi0AkwI6AAAgBkHYAGogBkGwAmopAgA3AwAgBkHgAGogBkG4AmopAgA3AwAgBkE4aiAGQaACaigCADYCACAGIAYvAJECOwF2IAYgBikCqAI3A1AgBiAGKQKYAjcDMCAGKAKUAiEBIAYoAqQCIQUMBAtBhJ6AARCyOwALIAZB6AJqIAEoAgAiATYCACAGIAYpA7ABNwPgAiAGQZACaiICIAYoAuQCIgMgAyABQQV0ahD2CCAGQeABaiACIAYtAHogBi0AexChEyAGLQDgASICQSlGBEAgBkG4AWogBkHwAWooAgAiATYCACAGQfAAaiABNgIAIAYgBikC6AEiDTcDsAEgBiANNwNoIAYoAuQBIQQgBigC9AEhAiAGQeACahDlPAwICyAGQfgAaiAGLQDjAToAACAGQbgBaiAGQfABaigCACIBNgIAIAZB2ABqIAZBgAJqKQIANwMAIAZB4ABqIAZBiAJqKQIANwMAIAZB8ABqIAE2AgAgBiAGLwDhATsBdiAGIAYpAugBIg03A7ABIAYgBikC+AE3A1AgBiANNwNoIAYoAuQBIQEgBigC9AEhBSAGQeACahDlPAwBCwJAIAYoApQCIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAZBlAJqEPseCyAGIAQgAWtBBHUiAjYC4AEgAiAGKALUAkcNAiAGKALoAiECIAYoAuwCIQQgBiAGKQLgAjcCnAIgBkEANgKYAiAGIAQ2ApQCIAYgAjYCkAIgBkEIaiAGQZACaiIHENc7IAYoAgghCEEcQQQQrTYiAkUNAyACQoGAgIAQNwIAIAIgBikCkAI3AgggAkEQaiAGQZgCaiIJKQIANwIAIAJBGGogBkGgAmoiCygCADYCACAGIAU2AqACIAZCgICAgIAINwKYAiAGIAM2ApQCIAYgATYCkAIgBiAHENc7IAYoAgAhBUEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgBikCkAI3AgggAUEQaiAJKQIANwIAIAFBGGogCygCADYCACAGIAQ2AtwCIAYgCDYC2AIgBiACNgLUAkEMQQQQrTYiAkUNBCACIAM2AgggAiAFNgIEIAIgATYCACAGQQE2AugCIAYgAjYC5AIgBkEBNgLgAiAGQQA2AugBIAZCgICAgMAANwLgASAGQZACaiICQfSRgAEgCiAGIAZB1AJqIAZB4AJqIAZB4AFqIgEQjBMgASACELATIAZBsAFqIAEgBi0AeiAGLQB7EKETIAYtALABIgJBKUYEQCAGQfAAaiAGQcABaigCADYCACAGIAYpArgBIg03A6ABIAYgDTcDaCAGKAK0ASEEIAYoAsQBIQIMBwsgBkH4AGogBi0AswE6AAAgBkHYAGogBkHQAWopAgA3AwAgBkHgAGogBkHYAWopAgA3AwAgBkHwAGogBkHAAWooAgA2AgAgBiAGLwCxATsBdiAGIAYpAsgBNwNQIAYgBikCuAE3A2ggBigCtAEhASAGKALEASEFCyAGQThqIAZB8ABqKAIANgIAIAYgBikDaDcDMAtBOEEEEK02IgNFDQMgAyACOgAIIANCgYCAgBA3AgAgAyAGLwF2OwAJIAMgATYCDCADIAYpAzA3AhAgAyAFNgIcIAMgBikDUDcCICADQQtqIAZB+ABqLQAAOgAAIANBGGogBkE4aigCADYCACADQShqIAZB2ABqKQMANwIAIANBMGogBkHgAGopAwA3AgAgAEG0mIABNgIIIAAgAzYCBCAAQZOAgIB4NgIADAULIAZCADcCnAIgBkKBgICAwAA3ApQCIAZBxJGAATYCkAJBACAGQeABaiAGQdQCaiAGQZACakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBBEE4EKM9AAsgBkHIAGogBkHwAGooAgAiATYCACAGIAYpA2giDTcDQCAAQQxqIAE2AAAgACANNwAEIAAgAjYCECAAIAQ2AgALIAZB8AJqJAALoSYDEX8EfgF8IwBB8ABrIggkAAJAIAJFDQACQAJAIAEtAABBK2sOAwACAQILQQEhCgwBC0EBIQpBASETCwJAIAIgCk0NAAJAIAIgCiIEayILQQhJDQAgCyEDA0AgASAEaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBZCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgBEEIaiEEIANBCGsiA0EHSw0ACwsgAAJ8AkACQAJAAkACQAJAAkACfwJAIAIgBEsEQEEAIAJrIQUgBEEBaiEDIAEgBGohBAJAA0AgBC0AACIGQTBrIglB/wFxQQlLDQEgASADakEAIAIgA0sbIQQgFkIKfiAJrUL/AYN8IRYgBSADQQFqIgNqQQFHDQALIAEgCmohDyALrSEXIAshCSACIQUgAiEEDAQLIANBAWshBCAGQS5GDQELIAQhBUEADAELAkAgAiADa0EISQRAIAMhBQwBCyACIANrIQYgAyEFA0AgASAFaikAACIUQsaMmbLkyJGjxgB8IBRCsODAgYOGjJgwfSIUhEKAgYKEiJCgwIB/g0IAUg0BIBZCgMLXL34gFEIKfiAUQgiIfCIUQhCIQv+BgIDwH4NCgYCAgIDiCX4gFEL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgBUEIaiEFIAZBCGsiBkEHSw0ACwsCQCACIAVNDQADQCABIAVqLQAAQTBrIgZB/wFxQQlLDQEgFkIKfiAGrUL/AYN8IRYgAiAFQQFqIgVHDQALIAIhBQtCACAFIANrIg2tfSEVIAEgA2oLIRAgASAKaiEPIAQgCmsiCa0hFyACIAVNDQAgCSANaiIHRQ0DIAEgBWotAAAiA0HBAGtB/wFxQRpJQQV0IANyQeUARw0BAkAgBUEBaiIGIAJPDQACQAJAIAEgBmotAABBK2sOAwECAAILIAVBAmohBkEBIQwMAQsgBUECaiEGCyACIAZNDQNCACEUIAYhBQJAA0AgASAFai0AAEEwayIDQf8BcUEJSw0BIBRCCn4gA61C/wGDfCAUIBRCgICAgAFTGyEUIAIgBUEBaiIFRw0ACyACIQULIAUgBkYNA0IAIBR9IBQgDBsiFCAVfCEVDAILIAkgDWoiB0UNAgtCACEUC0EAIQNBEyIGIAdJBEAgASAKaiEMIAogAmshDiAHQRNrIQcCQAJAAkADQCADIAxqLQAAIhJBMEcNASAOIANBAWoiA2oNAAsgByALayIDQQAgAyAHTRshESACIQcMAQsgByADayIRQQAgByARTxshESACIAMgCmoiByASQS5GIAIgB0txIhJqIgdNBEAgByEDDAILIAwgEmogA2ohDCAOIBJqIANqIQ4gByEDA0AgDC0AAEEwRw0CIAxBAWohDCADQQFqIQMgDkEBaiIODQALCyACIQMLIAMgB2siByARSQRAQQAhAwJAIAQgCkYNAANAIAMgD2otAABBMEcNASAJIANBAWoiA0cNAAsgCSEDC0IAIRYCQCAJIANrIgRBCEkNACAEQQhrIQQDQCADIA9qKQAAIhVCxoyZsuTIkaPGAHwgFUKw4MCBg4aMmDB9IhWEQoCBgoSIkKDAgH+DQgBSDQEgFkKAwtcvfiAVQgp+IBVCCIh8IhZCEIhC/4GAgPAfg0KBgICAgOIJfiAWQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhFiADQQhqIQMgBkEIayIGQQlJDQEgBEEHSyAEQQhrIQQNAAsLIAZFIQ4CQCAGRSADIAlPckUEQANAIBZCCn4gAyAPai0AAEEwa61C/wGDfCEWIAZBAUYhDiAGQQFrIQQgA0EBaiIDIAlPDQIgBkEBRyAEIQYNAAwCCwALIAYhBAsCQCAODQACQCAQBEBBACEDAkAgDUUgFkIAUnINAANAIAMgEGotAABBMEcNASANIANBAWoiA0cNAAsgDSEDCyAEQQlJDQEgDSADayIGQQhJDQEgBkEIayEGA0AgAyAQaikAACIVQsaMmbLkyJGjxgB8IBVCsODAgYOGjJgwfSIVhEKAgYKEiJCgwIB/g0IAUg0CIBZCgMLXL34gFUIKfiAVQgiIfCIWQhCIQv+BgIDwH4NCgYCAgIDiCX4gFkL/gYCA8B+DQuSAgICAyNAHfnxCIIh8IRYgA0EIaiEDIARBCGsiBEEJSQ0CIAZBB0sgBkEIayEGDQALDAELQcDWgAEQsjsAC0IAIRcgBEUgAyANT3INACAEQQFrIQYDQCAWQgp+IAMgEGotAABBMGutQv8Bg3whFiADQQFqIgMgDU8NASAGIgRBAWshBiAEDQALCyAUIAOtfSAXfCEVCyAHIBFJIQMLIAIgBUYNAQtCACEWIAtBA0kNBEEAIQMgAiAKayIFQQAgAiAFTxshBSABIApqIQQgCkEDaiEJA0AgA0EDRgRARAAAAAAAAPh/IRgMBAsgAyAFRg0CIANB4NaAAWohASADIARqIANBAWohAy0AACIGIAEtAAAiAUYgASAGc0EgRnINAAsMAQsgCCADOgBJIAggEzoASCAIIAk2AkQgCCAPNgJAIAggDTYCPCAIIBA2AjggCCAWNwMwIAggFT4CKCAIIBVCIIg+AiwgCEHgAGohBUIAIRUjAEEQayIBJAACQCAIQShqIgIpAwAiFEJqUyAUQiVVcg0AIAIpAwgiF0KAgICAgICAEFYNACACLQAhQQFxDQAgBQJ8IBRCF1kEQCABIBdCACAUp0EDdEHQ8IABaikDAEIAEKgeIAEpAwhCAFINAiABKQMAIhRCgICAgICAgBBWDQIgFLpEktVNBs/wgESiDAELIBSnIQQgF7ohGCAUQgBZBEAgBEEDdEGA8IABaisDACAYogwBCyAYQYDwgAEgBEEDdGsrAwCjCyIYmiAYIAItACAbOQMIQgEhFQsgBSAVNwMAIAFBEGokACAIKAJgQQFGBEAgCCsDaAwDCyAIQdAAaiAIKQMoIhUgFhDSCwJAAkACQCADRSAIKAJYIgRBAEhyRQRAIAhB4ABqIBUgFkIBfBDSCyAIKAJoIARGBEAgCCkDUCIUIAgpA2BRDQMLIBWnIgJB1gJqIgFBigVLDQMgFnkiFKchAyAIQRBqIAFBBHRB8JiBAWoiASkDAEIAIBYgFIYiFEIAEKgeIAgpAxgiFkL/A4NC/wNRBEAgCCkDECEVIAggASkDCEIAIBRCABCoHiAIKQMIQn+FIBVUrSAWfCEWCyACQeqkDWxBEHUgFkI/iFAiASADamtBzPcBayEEIBYgAa2GIRQMAQsgCCkDUCEUIARBAE4NAQsgCEHgAGohCSAUIRYgBEGAgAJqIQYjAEHwC2siAyQAIAhBKGoiASkDACEVIAEpAwgiFEKQzgBaBEADQCAVQgR8IRUgFEL/wdcvViAUQpDOAIAhFA0ACwsgFELkAFoEQANAIBVCAnwhFSAUQo/OAFYgFELkAIAhFA0ACwsgFEIKWgRAA0AgFUIBfCEVIBRC4wBWIBRCCoAhFA0ACwsgA0H8A2oiAiABQYEGEKYBIANBBGoiASACQfgD/AoAAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgFacgAygC9AdrQQFqIgRBAEgEQCADQfgHaiABQfgD/AoAAAJ/IAZBAWsiCkF0TARAIBZBwABBASAGayIBIAFBwABOG0E/ca2IQgAgAUE/TBsiFUL/////////B1YMAQtCACAWQguIQv////////8HgyAGQQtqIgFB/g9KIgIbIRVB/w8gASACGwshASADIBVC/////////weDIhQgFEKAgICAgICACIQgAa1CNIYgFYRCgICAgICAgPj/AIMiFVAiARsiFEIfiD4CgAQgA0EBQQIgFEKAgICACFQbOwHwByADIBSnQQF0QQFyNgL8AyADQfwDakEAIARrEM4KRQ0BAkBBzXcgFUI0iKdBtAhrIAEbIARrIgRBAEwEQCAEQQBODQlBACAEayIEQR9xIgcNAQwICyAEQR9xIgdFDQVBICAHayELAkAgAy8B8AciAUUEQEEAIQEMAQsgAUECdCEFIANB/ANqIQJBACEBA0AgAiABIAt2IAIoAgAiASAHdHI2AgAgAkEEaiECIAVBBGsiBQ0ACwsgASALdiIBRQ0FIAMvAfAHIgJB/ABLDQYgA0H8A2ogAkECdGogATYCACADIAMvAfAHQQFqOwHwBwwFC0EgIAdrIQsCQCADLwHsCyIBRQRAQQAhAQwBCyABQQJ0IQUgA0H4B2ohAkEAIQEDQCACIAEgC3YgAigCACIBIAd0cjYCACACQQRqIQIgBUEEayIFDQALCyABIAt2IgFFDQYgAy8B7AsiAkH8AEsNCCADQfgHaiACQQJ0aiABNgIAIAMgAy8B7AtBAWo7AewLDAYLIANBBGogBBDOCkUNAiAEQR9xIgZFDQFBICAGayEHAkAgAy8B+AMiAUUEQEEAIQEMAQsgAUECdCEFIANBBGohAkEAIQEDQCACIAEgB3YgAigCACIBIAZ0cjYCACACQQRqIQIgBUEEayIFDQALCyABIAd2IgFFDQEgAy8B+AMiAkH8AEsNAiADQQRqIAJBAnRqIAE2AgAgAyADLwH4A0EBajsB+AMMAQtBgNaAARCyOwALIAMvAfgDIQICfgJAAkAgBEEgSQRAIAIhAQwBCyAEQQV2IgUgAmoiAUH9AEsNAyACRQRAQQAhAkIAIRVCACEUDAILIAVBAnQhBSACQQJ0IgIEQCADQQRqIgQgBWogBCAC/AoAAAsgBQRAIANBBGpBACAF/AsACyADIAE7AfgDC0IAIRVCACEUAkACfgJAAkACQCABQf//A3EiAg4DBQECAAsgAkECdCICIANBBGpqIgVBDGspAgAiFEEgIAVBBGsoAgAiBWciBGutiCAFrSAEQSBzrSIWhoQhFUEAIQUgFCAWhkIAUg0DIANBDGshBANAIAJBDEYiBQ0EIAIgBGogAkEEayECKAIARQ0ACwwDCyADIAJBAnRqKAIAIgKtIAJnQSBzrYYMAQsgAkECdCADakEEaykCACIUIBR5hgshFUEBIQULQQAhAgJAIAFB//8DcSIBRQ0AIAMgAUECdGoiBEUNACAEKAIAZyECCyAVQguIIRQgAUEFdCACayECQgEgFUL/D4MiFkKACFYgBSAWQoAIUnJFcg0BGgsgFUL/H4NCgBhRrQshFiAJQf8PQf4HQf8HIBQgFnwiFEKAgICAgICAEFQbIAJqIgEgAUH+D0siARs2AgggCUIAIBRC/////////weDIAEbNwMADAgLQbDWgAEQsjsACyAEQSBJDQIgBEEFdiIBIAMvAfAHIgJqIgVB/QBLDQAgAkUNAiABQQJ0IQEgAkECdCICBEAgA0H8A2oiBCABaiAEIAL8CgAACyABBEAgA0H8A2pBACAB/AsACyADIAU7AfAHDAILQaDWgAEQsjsACyAEQSBJDQAgBEEFdiIBIAMvAewLIgJqIgVB/QBLDQEgAkUNACABQQJ0IQEgAkECdCICBEAgA0H4B2oiBCABaiAEIAL8CgAACyABBEAgA0H4B2pBACAB/AsACyADIAU7AewLCyADLwHsCyICIAMvAfAHIgFGDQEgASACSSABIAJLawwCC0GQ1oABELI7AAsgAUECdCEBIAJBAnQhAiADQfgDaiEHIANB9AdqIQsDQEEAIAJFIAFFcg0BGiABIAdqIQQgAiALaiABQQRrIQEgAkEEayECKAIAIgUgBCgCACIERg0ACyAEIAVJIAQgBUtrCyEBIAkCfyAKQXVOBEAgFkILiCEUQgACfgJAAkACQCABQf8BcQ4CAQIAC0IADAILIBRCAYMMAQtCAQsgFHwiFEL/////////B4NBC0EMIBRCgICAgICAgBBUGyAGaiIBQf4PSiICGyEVQf8PIAEgAhsMAQtCACEVIBZBwABBASAGayICIAJBwABOG0E/ca2IQgAgAkE/TBshFAJAAkACQCABQf8BcQ4CAAECCyAUQgGDIRUMAQtCASEVCyAUIBV8IhVC/////////wdWCzYCCCAJIBU3AwALIANB8AtqJAAgCCgCaCEEIAgpA2AhFAsgBK1CNIYgFIS/IhiaIBggExsMAwsgAUGLBUHQ1oABEMMhAAsCQCALQQhJDQAgCkEIciEBQQAhAwNAIANBCEYEQEQAAAAAAADwfyEYIAEhCQwDCyADIAVGDQEgA0Hm1oABaiEGIAMgBGogA0EBaiEDLQAAIgcgBi0AACIGRiAGIAdzQSBGcg0ACwtBACEDA0AgA0EDRgRARAAAAAAAAPB/IRgMAgsgAyAFRg0DIANB49aAAWohASADIARqIANBAWohAy0AACIGIAEtAAAiAUYgASAGc0EgRnINAAsMAgsgAiAJRw0BIBiaIBggExsLOQMIQgEhFgsgACAWNwMAIAhB8ABqJAAL6BcCDH8DfiMAQZADayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCACIFKAIIQQJGBEAgBS0ALUECaw4DAgIDAQsgACABIAIgAxDsCQwNCyAAIAEgAiADEPgCDAwLIAMvAQwhCUEBIQgCQAJAAkAgBS0ALCIGQQAgBkEDRxtBAWsOAgEAAgsgBEHIAmpBFkEAQQFBARCgGCAEKALMAiECIAQoAsgCQQFGDQMgBCgC0AIiAUEOakGO188AKQAANwAAIAFBCGpBiNfPACkAADcAACABQYDXzwApAAA3AAAgAEEWNgIUIAAgATYCECAAIAI2AgwgAEEDNgIIIABBgoCAgHg2AgAMCwtBASENQQIhCAsgAy8BDiEMIARB2ABqIAVBCGoiBRCKJiAEKAJcQQFHDQIgBEHIAGogBRCKJgJAAkAgBCgCTARAIAQoAkgiBSgCACIGQQhqIgcgBigCCEECRkECdGotACBBAmsOAgIPAQtBAEEAQbDTzwAQwyEACyAEQcgCakEjQQBBAUEBEKAYIAQoAswCIQEgBCgCyAJBAUYNBCAEKALQAiICQZzWzwBBI/wKAAAgAEEjNgIUIAAgAjYCECAAIAE2AgwgAEEDNgIIIABBgoCAgHg2AgAMCgsgBEFAayAHEIomIAQoAkRBAUYNCCAEQThqIAUoAgBBCGoQiiYgBCgCPEECRw0EIARBKGogBSgCAEEIahCKJiAEKAIsRQ0FIAQoAighByAEQSBqIAUoAgBBCGoQiiYgBCgCJCICQQFNDQYgBygCACICQQhqIAIoAghBAkZBAnRqLQAgIgJBA0YNDAJAAkACQAJAAkAgAkECSQRAIAQoAiBBBGoiCigCACICQQhqIAIoAghBAkZBAnRqLQAgQQJrDgICEgELIABBDGpBxdXPAEEbEIEgIABBgoCAgHg2AgAgAEEDNgIIDA4LIAMtAABBJ2sOAwMCAQILIABBDGpBqNXPAEEdEIEgIABBgoCAgHg2AgAgAEEDNgIIDAwLIARBKToAyAJBACEGDAkLIAQgAzYCoAEgBEEBNgLMAiAEQaDVzwA2AsgCIARCATcC1AIgBEGnBDYChAIgBCAEQYACajYC0AIgBCAEQaABajYCgAIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwKCyADKAIEIgItADBBIEcEQCAEIAJBMGo2AqABIARBATYCzAIgBEHs1M8ANgLIAiAEQgE3AtQCIARBpwQ2AoQCIAQgBEGAAmo2AtACIAQgBEGgAWo2AoACIABBDGogBEHIAmoQpxggAEGCgICAeDYCACAAQQM2AggMCgsgBEEYaiACQTRqIgIQwzQgBCgCHEECRwRAIARBEGogAhDDNCAEQTs2AoQCIARBATYCzAIgBEG81M8ANgLIAiAEQgE3AtQCIAQgBCgCFDYCoAEgBCAEQaABajYCgAIgBCAEQYACajYC0AIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwKCyAEQQhqIAIQwzQCQCAEKAIMBEAgBCgCCCgCACEGIAQgAhDDNCAEKAIEIgJBAU0NASADQQRqIQsgAy0AASEOIAQoAgAoAgQgBEHIAmogBkEwahDDBiAGQQhqIQ9BCGohBgwJC0EAQQBB4NPPABDDIQALQQEgAkHw088AEMMhAAsgACABIAIgAxC7AgwKCyACIAQoAtACQeSjzwAQ/S8ACyAEQdAAaiAFEIomIARBOzYChAIgBEEBNgLMAiAEQfjWzwA2AsgCIARCATcC1AIgBCAEKAJUNgKgASAEIARBoAFqNgKAAiAEIARBgAJqNgLQAiAAQQxqIARByAJqEJkOIABBgoCAgHg2AgAgAEEDNgIIDAYLIAEgBCgC0AJB5KPPABD9LwALIARBMGogBSgCAEEIahCKJiAEQTs2AoQCIARBATYCzAIgBEGU1s8ANgLIAiAEQgE3AtQCIAQgBCgCNDYCoAEgBCAEQaABajYCgAIgBCAEQYACajYC0AIgAEEMaiAEQcgCahCnGCAAQYKAgIB4NgIAIABBAzYCCAwEC0EAQQBBwNPPABDDIQALQQEgAkHQ088AEMMhAAsgBEGIAWogBEHQAmooAgA2AgAgBCAIIAxqIgg7AY4BIAQgCUEBaiIJOwGMASAEIAQpAsgCNwOAASAEQcgCaiABIAcgBEGAAWoQ0gEgBCgCyAIiAkGCgICAeEYEQCAEQZQCaiAEQeACaikDACIQNwIAIARBjAJqIARB2AJqKQMAIhE3AgAgBCAEKQPQAiISNwKEAiAAQRhqIBA3AgAgAEEQaiARNwIAIAAgEjcCCCAAQYKAgIB4NgIADAILIARB7ABqIARB1AJqKQIANwIAIARB9ABqIARB3AJqKQIANwIAIARB/ABqIARB5AJqKAIANgIAIAQgBCkCzAI3AmQgBCACNgJgAkAgBgRAIARByAJqIAZBKGoQwwYMAQsgBEEpOgDIAgsgBEGYAWogBEHQAmooAgA2AgAgBCAIOwGeASAEIAk7AZwBIAQgBCkCyAI3A5ABIARByAJqIAEgCiAEQZABahDSASAEKALIAiIBQYKAgIB4RgRAIARBlAJqIARB4AJqKQMAIhA3AgAgBEGMAmogBEHYAmopAwAiETcCACAEIAQpA9ACIhI3AoQCIABBGGogEDcCACAAQRBqIBE3AgAgACASNwIIIABBgoCAgHg2AgAgBEHgAGoQti8MAgsgBEGYAmogBEHkAmooAgAiAjYCACAEQZACaiAEQdwCaikCACIQNwMAIARBiAJqIARB1AJqKQIAIhE3AwAgBCAEKQLMAiISNwOAAiAEQdwBaiACNgIAIARB1AFqIBA3AgAgBEHMAWogETcCACAEQagBaiAEQegAaikCADcDACAEQbABaiAEQfAAaikCADcDACAEQbgBaiAEQfgAaikCADcDACAEIBI3AsQBIAQgBCkCYCIQNwOgASAEIAE2AsABIARBwAFqIQICQCABQYGAgIB4RiAQpyIMQYGAgIB4RnJFBEAgBEHIAmoiASAHKAIAQQhqIARB4ABqIA8QqwkgAUEAOgBAIARBgAJqIgcgAUHIAPwKAAAgBxDQKSEHIAEgCigCAEEIaiACIAYQqwkgARDQKSEBAkAgCwRAIARB4AFqIAsoAgBBCGoQsS4MAQsgBEHIAmpBqJ7PABClKyAEQegBakGwnM8AKQMANwMAIARBqJzPACkDADcD4AEgBCAEKQPQAjcD+AEgBCAEKQPIAjcD8AELIAUoAgAiBUEIaiAFKAIIQQJGQQJ0aiIFKAIQIQogBSgCDCELIAQgATYChAIgBCAHNgKAAiMAQSBrIgEkACABQQhqIQYgBEGAAmoiBykCACEQQRBBBBCtNiIFRQRAQQRBEBCjPQALIAUgEDcCCCAFQoGAgIAQNwIAIAZBAjYCBCAGIAU2AgAgAUEgOgAUIAEgASkDCDcCGCAEQcgCaiIFIAsgCiABQRRqQQAQmxQgAUEgaiQAIAcgBSAEQeABahCcJSAHENApIQVBwABBBBCmLyEBIAAgDToAHCAAIAg7ARogACAJOwEYIAAgBTYCECAAIA5BAXE6AA0gAEEnOgAMIABBAjYCCCAAIAE2AgQgAEECNgIAIAFBGGogBEH4AGopAgA3AgAgAUEQaiAEQfAAaikCADcCACABQQhqIARB6ABqKQIANwIAIAEgBCkCYDcCACABIAIpAgA3AiAgAUEoaiACQQhqKQIANwIAIAFBMGogAkEQaikCADcCACABQThqIAJBGGopAgA3AgAMAQsgAEGBgICAeDYCACAMQYGAgIB4RwR/IARBrAFqEJ0MIARBoAFqEMkoIAQoAsABBSABC0GBgICAeEYNACAEQcwBahCdDCACEMkoCyADLQAAQSlHDQIMAwsgBEHQAmogA0EIaikCADcDACAEIAMpAgA3A8gCIAAgASACIARByAJqELsCDAILIAMtAABBKUYNAQsgAxCdDAsgBEGQA2okAA8LQZ+6zwBBK0HMus8AEJ8pAAvUGAINfwN+IwBBkAhrIgIkAAJAAkAgASkDACIPQgJRBEACQAJAAkACQAJAAkAgASkDECIPUEUEQCACQcQEaiEGIAJBqAJqIQcgAkGQAmohBCACQYgFaiEIIAJB8ARqIQMgASgCQEEIaiELIAEoAhwhDCACQeAEakEEciEKIAEpAwghECABKAIYIQUDQCACQeAEaiALIBAQ9A8gBCAKQQhqKQIANwMAIAIgCikCADcDiAIgAigC4AQiCUEIRwRAIAJBiAdqIAJBkAJqKQMAIg83AwAgAiACKQOIAiIQNwOAByACKAL0BCEBIABBFGogDzcCACAAIBA3AgwgACABNgIcIAAgCTYCCCAAQg03AwAMCwsgAkHABGogBCkDADcDACACIAIpA4gCNwO4BCABQQA2AhgCQCAFBEAgAiAFQYgC/AoAACAFQYgCQQgQ+DoMAQsgAkHgBGoiCSACQbgEahDyEyACKQPoBCIRQgRSBEAgAkGIB2oiDSADQQhqKQMANwMAIAJBkAdqIg4gA0EQaikDADcDACACIAMpAwA3A4AHIAIoAuAEIQUgByAIQegB/AoAACAEQRBqIA4pAwA3AwAgBEEIaiANKQMANwMAIAQgAikDgAc3AwAgAiARNwOIAiAJIAUgDxCOGiACKALgBCIJQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgCTYCCCACQYgCahD8LAwGCyABIA8gBa0iEX0iDzcDECABIBAgEXwiEDcDCCACIAJBiAJqQYgC/AoAAAwBCyACQZAHaiADQRBqKQMAIg83AwAgAkGIB2ogA0EIaikDACIQNwMAIAIgAykDACIRNwOAByAAQRhqIA83AwAgAEEQaiAQNwMAIAAgETcDCCAAQg03AwAMBAsgAkHgBGogAigC/AEgAigC+AEgDxCFGSACKALgBCIFQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgBTYCCCACEPwsDAQLIAEgDyACKAL8ASIFrSIRfSIPNwMQIAEgECARfCIQNwMIIAIgBTYClAQgAigC9AFBAUcEQCACQeAEaiIEIAVBAEEBQQEQoBggAigC5AQhAyACKALgBEEBRg0FIAJBADYCoAQgAiACKALoBDYCnAQgAiADNgKYBCACQegEaiACQcAEaikDADcDACACIAIpA7gENwPgBCACIBE3A/gEIAIgETcD8AQgAkGIAmogBCACQZgEahDTByACLQCIAkEERgRAIAIoAowCIQMMBwsgAikDiAIiD0L/AYNCBFINAyAPQiCIpyEDDAYLIAIQ/CwgBiACKAK8BCACKALABCACKAK4BCgCEBEBAEEAIQUgD1BFDQALCyAAQgw3AwAMCAsgAiAPNwOIAiAAQQhqIAJBiAJqEIErIABCDTcDACACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBAAwDCyAGIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAYLIAMgAigC6ARBiIDOABD9LwALIAIgAzYCpAQgAkHsBGogAigC5AQgAigC6AQgAigC4AQoAhARAQAgAyAFRwRAIAJBAjYC5AQgAkHEgM4ANgLgBCACQgI3AuwEIAJBOzYClAIgAkE7NgKMAiACIAJBiAJqNgLoBCACIAJBpARqNgKQAiACIAJBlARqNgKIAiAAQQxqIAJB4ARqEJkOIABCDTcDACAAQQI2AggMAQsgAkGwBGogAkGgBGooAgA2AgAgAiACKQKYBDcDqAQgAkHgBGoiAyACQYgC/AoAACACQcgEaiIEIAJBqARqEOcVIAJBiAJqIAMgBCABLQBEIAFBOGpBACABKAI4GxCuASACQYgHaiIEIAJBmAJqKQMANwMAIAJBkAdqIgMgAkGgAmopAwA3AwAgAiACKQOQAjcDgAcgAikDiAIiD0IMUgRAIAJBsAdqIAJBqAJqQeAA/AoAACACQaAHaiAEKQMANwMAIAJBqAdqIAMpAwA3AwAgAiACKQOABzcDmAcgD0IJVA0CIA+nQQlrIgNBAkkNAiADQQJHDQQgAUEAOgAgDAQLIAAgAikDgAc3AwggAEINNwMAIABBGGogAykDADcDACAAQRBqIAJBiAdqKQMANwMADAQLIAJBmARqEN47IAIQ/CwMAwsgASAMQQFqNgIcDAELIAFCADcDAAJAAn4gD6ciCkEBcQRAIAEoAhghAyABKQMIDAELIAEoAiwiA0UNASABIANBAWs2AiwgASABKAIoIgNBAWoiBCABKAIgIgVBACAEIAVPG2s2AiggASgCJCADQRhsaiIEKAIQIQMgBCkDAAshDyADQQBIBEAgAkEBNgLkBCACQay+zQA2AuAEIAJCATcC7AQgAkGmBDYCjAIgAiACQYgCajYC6AQgAiACNgKIAiAAQQxqIAJB4ARqEJkOIABBADYCCCAAQg03AwAMAwsgAkHgBGohBSABKAJAQQhqIQYjAEFAaiIEJAAgBEEoaiAGIA8Q9A8gBEEgaiIGIARBNGopAgA3AwAgBCAEKQIsNwMYAkAgBCgCKCIHQQhHBEAgBCgCPCEDIAUgBCkDGDcCBCAFIAM2AhQgBUEMaiAGKQMANwIADAELIARBEGoiCCAGKQMANwMAIAQgBCkDGDcDCCAFQQRqIARBCGogAxDNFSAEQRRqIAQoAgwgCCgCACAEKAIIKAIQEQEACyAFIAc2AgAgBEFAayQAIAJBkAJqIgMgAkHsBGopAgA3AwAgAiACKQLkBDcDiAIgAigC4AQiBEEIRwRAIAIoAvQEIQEgACACKQOIAjcCDCAAIAE2AhwgACAENgIIIABCDTcDACAAQRRqIAMpAwA3AgAMAwsgAkHABGogAykDACIPNwMAIAIgAikDiAI3A7gEIAEoAjQhBSACQeAEaiEEIAIoArwEIQYjAEGwAmsiAyQAIANCADcDCCADIA+nIgc2AgQgAyAGNgIAIANBKGogAxCPFCADQRhqIgggA0E4aikDADcDACADQSBqIgsgA0FAaykDADcDACADIAMpAzA3AxACQCADKQMoIg9CBFEEQCAEIAMpAxA3AxAgBEIENwMIIARBIGogCykDADcDACAEQRhqIAgpAwA3AwAMAQsgBEEoaiADQcgAakHoAfwKAAAgBEEgaiADQSBqKQMANwMAIARBGGogA0EYaikDADcDACAEIAMpAxA3AxAgBCAPNwMIIAQgAykDCD4CAAsgA0GwAmokACACKQPoBCIPQgRSBEAgAkEIaiIDIAJB+ARqKQMANwMAIAJBEGoiBCACQYAFaikDADcDACACIAIpA/AENwMAIAIoAuAEIQYgAkGIAmogAkGIBWpB6AH8CgAAIAJB2ARqIAQpAwA3AwAgAkHQBGogAykDADcDACACIAIpAwA3A8gEIAJB8AZqIAJBuARqIAYQ6hQgCkEBcUUEQCABIAVBAWo2AjQLIAJB8ARqIAJB0ARqKQMANwMAIAJB+ARqIAJB2ARqKQMANwMAIAIgDzcD4AQgAiACKQPIBDcD6AQgAkGABWogAkGIAmpB6AH8CgAAIAIgAkHgBGogAkHwBmogAS0ARCABQThqQQAgASgCOBsQrgEgAkGIB2oiAyACQRBqKQMANwMAIAJBkAdqIgQgAkEYaikDADcDACACIAIpAwg3A4AHIAJBxARqIQEgAikDACIPQgxRBEAgACACKQOABzcDCCAAQg03AwAgAEEYaiAEKQMANwMAIABBEGogAykDADcDACABIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAQLIAJBsAdqIAJBIGpB4AD8CgAAIAJBoAdqIAJBiAdqKQMANwMAIAJBqAdqIAJBkAdqKQMANwMAIAIgAikDgAc3A5gHIAEgAigCvAQgAigCwAQgAigCuAQoAhARAQAMAgsgAkEQaiACQYAFaikDACIPNwMAIAJBCGogAkH4BGopAwAiEDcDACACIAIpA/AEIhE3AwAgAEEYaiAPNwMAIABBEGogEDcDACAAIBE3AwggAEINNwMAIAJBxARqIAYgByACKAK4BCgCEBEBAAwCCyAAQgw3AwAMAQsgACAPNwMAIABBCGogAkGYB2pB+AD8CgAACyACQZAIaiQAC+IqAhR/BH4jAEGQA2siAiQAIAJBnAJqIAEQpQggAkG4AWoiBCACQagCaigCADYCACACIAIpAqACNwOwASACKAKwAiEFIAIoAqwCIQMCQAJAAkAgAigCnAJBAUYEQCAAIAIpA7ABNwIEIAAgBTYCFCAAIAM2AhAgAEEEOgAAIABBDGogBCgCADYCAAwBCyACQSBqIAQoAgA2AgAgAiACKQOwATcDGAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCACIAIpArQCNwIwIAIgBTYCLCACIAM2AiggAigCICIEQQRqIQUgBEF7Sw0BIAUgAigCHCIDSw0CIAJBnAJqIgUgAigCGCIGIAMgBCAEIAZqIgcoAABrEPY0IAVBBhDMIEH//wNxIgVFBEBBACEFDAoLIAQgBWoiBSADSw0NAkACQAJAAkACQAJAAkACQAJAIAUgBmotAAAiBUEBaw4DAAIBEgsgAkGwAWogAkEYahC4FCACKAKwASIBDQMgAkGcAmpBKkEAQQFBARCgGCACKAKgAiEBIAIoApwCQQFHDQIMFAsgAkGcAmoiCSAGIAMgBCAHKAAAaxD2NAJAIAlBBhDMIEH//wNxIgVFDQAgBCAFaiIFIANLDRUgBSAGai0AAEEDRw0AIAkgAkEYahCSFSACKAKcAiIFDQULIAJBnAJqQSpBAEEBQQEQoBggAigCoAIhASACKAKcAkEBRw0DDBMLIAJBnAJqIgkgBiADIAQgBygAAGsQ9jQCQCAJQQYQzCBB//8DcSIFRQ0AIAQgBWoiBSADSw0UIAUgBmotAABBAkcNACAJIAJBGGoQkhUgAigCnAIiBQ0GCyACQZwCakE0QQBBAUEBEKAYIAIoAqACIQEgAigCnAJBAUcNBAwSCyACKAKkAiIDQczNzABBKvwKAAAgAEEqNgIQIAAgAzYCDCAAIAE2AgggAEGEgICAeDYCBCAAQQQ6AAAMDwsgAiACKQK0ATcCWCACIAE2AlQgAkHgAGogAkHUAGoQtwMgAkFAayACQfgAaikDADcDACACQcgAaiACQYABaikDADcDACACIAIpA3A3AzhBASEGQQAhBSACKAJsIQEgAigCaCEEIAIpA2AhFgwMCyACKAKkAiIDQarOzABBKvwKAAAgAEEqNgIQIAAgAzYCDCAAIAE2AgggAEGMgICAeDYCBCAAQQQ6AAAMDQsgAiACKQKgAjcCjAEgAiAFNgKIASACQZwCaiIFIAYgAyAEIAcoAABrEPY0IAVBBBDMIEH//wNxIgUEfyAEIAVqIgQgA0sNBiAEIAZqLwAABUEACyEEIAEoAngiAyADKAIAIgVBAWo2AgAgAiAEOwGWASAFQQBIDQYgAigCMCEEIAIoAjQhBSACIAIpAig3AogDIAJBADYChAMgAiAFNgKAAyACIAQ2AvwCIAJBCGogAkH8AmoQ1zsgAigCCCEGQRxBBBCtNiIERQ0HIARCgYCAgBA3AgAgBCACKQL8AjcCCCAEQRBqIAJBhANqKQIANwIAIARBGGogAkGMA2ooAgA2AgAgAiAFNgLsAiACIAY2AugCIAIgBDYC5AIgAkGcAmogAkHkAmogAkGIAWogAyABQdgAaiACQZYBahDsBgJAAkAgAi0A4AJBAkYEQCACQYgCaiACQawCaigCACIBNgIAIAJBgAJqIAJBpAJqKQIAIhY3AwAgAiACKQKcAiIXNwP4ASAAQRRqIAE2AgAgAEEMaiAWNwIAIAAgFzcCBCAAQQQ6AAAMAQsgAkGQAmoiAyACQbQCaikCADcDACACQYgCaiIEIAJBrAJqKQIANwMAIAJBgAJqIgUgAkGkAmopAgA3AwAgAkHgAWogAkHMAmopAgA3AwAgAkHoAWogAkHUAmopAgA3AwAgAkHvAWogAkHbAmooAAA2AAAgAkH3AWogAkHjAmotAAA6AAAgAiACKQKcAjcD+AEgAiACKQLEAjcD2AEgAiACLwDhAjsA9QEgAkG4AWogBSkDADcDACACQcABaiAEKQMANwMAIAJByAFqIAMpAwA3AwAgAiACKQP4ATcDsAEgAiABKAIoNgLUASACIAEtAH06APQBIAEoAiAhAyACQQA6APMBIAIgASgCJEEAIANBgICAgHhHGzYC0AEgAkGYAWogAkGwAWoQkwIgAigCnAEhAyACKQKgASEWIAIoAqgBIQQgAigCrAEhASACKAKYAUEBRw0BIAAgATYCFCAAIAQ2AhAgACAWNwMIIAAgAzYCBCAAQQQ6AAAgAigC5AIhBAsgBCAEKAIAIgBBAWs2AgAgAEEBRw0OIAJB5AJqEPseDA4LIAIoAuQCIgUgBSgCACIFQQFrNgIAIAVBAUYEQCACQeQCahD7HgtBACEGQQEhBQwKCyACKAKkAiIDQfbNzABBNPwKAAAgAEE0NgIQIAAgAzYCDCAAIAE2AgggAEGEgICAeDYCBCAAQQQ6AAAMCwsgAiACKQKgAjcC9AIgAiAFNgLwAiACQZwCaiIFIAYgAyAEIAcoAABrEPY0IAIgBUEEEMwgQf//A3EiBQR/IAQgBWoiBCADSw0HIAQgBmovAAAFQQALOwHkAiACKAIwIQQgAigCNCEDIAIgAikCKDcCqAIgAkEANgKkAiACIAM2AqACIAIgBDYCnAIgAkEQaiACQZwCahDXOyACKAIQIQRBHEEEEK02IgdFDQcgB0KBgICAEDcCACAHIAIpApwCNwIIIAdBEGogAkGkAmopAgA3AgAgB0EYaiACQawCaigCADYCACACIAM2AqABIAIgBDYCnAEgAiAHNgKYASACQbABaiEDIAJBmAFqIREgASgCeEEIaiEFIAFB2ABqIQwgAkHkAmohEiABLQB9IRMjAEHgAmsiASQAIAJB8AJqIgYoAggiCkEEaiEEAkACQAJAAkACQAJAAkACQCAKQXtNBEAgBCAGKAIEIglLDQEgAUGIAmoiBCAGKAIAIg0gCSAKIAogDWoiFCgAAGsQ9jQgASAEQQQQzCBB//8DcSIEBH4gBCAKaiIEIAlLDQMgBCANaikAAAVCAAsiFjcDECMAQUBqIgYkACAGIBY3AwggBSgCACEEIAUoAgQhBSAGQQA2AiQgBkEANgIUIAYgBEEIaiIENgI0IAYgBCAFQQJ0ajYCOCAGIAZBCGo2AjwgAUEYaiEPIwBBQGoiBCQAAkACQAJAIAZBFGoiCBDLDSIOBEAgBEEUaiIFQQMgCCgCHCAIKAIUa0ECdkEAIAgoAhAbIAgoAgwgCCgCBGtBAnZBACAIKAIAG2oiCyALQQNNG0EBakEAQQRBBBCgGCAEKAIYIQsgBCgCFEEBRg0CIARBEGoiFUEBNgIAIAQoAhwiECAONgIAIAQgEDYCDCAEIAs2AgggBSAIQSz8CgAAIAUQyw0iEARAIARBCGoiCCgCCCILQQJ0IQ4DQCAIKAIAIAtGBEAgCCALIAUoAgwgBSgCBGtBAnZBACAFKAIAGyAFKAIcIAUoAhRrQQJ2QQFqQQEgBSgCEBtqQQRBBBDcKAsgCCALQQFqIgs2AgggCCgCBCAOaiAQNgIAIA5BBGohDiAFEMsNIhANAAsLIAUQ/SIgD0EIaiAVKAIANgIAIA8gBCkCCDcCAAwBCyAPQQA2AgggD0KAgICAwAA3AgAgCBD9IgsgBEFAayQADAELIAsgBCgCHEH43IcBEP0vAAsgBkFAayQAIAEoAiBFBEAgAUECNgKMAiABQcDh/gA2AogCIAFCATcClAIgAUHuBjYCxAEgASABQcABajYCkAIgASABQRBqNgLAASABQfwAaiABQYgCahCZDiADIAEpAoABNwIIIANBEGogAUGIAWooAgA2AgAgAyABKAJ8NgIEIANBjYCAgHg2AgAMCQsgASgCHCgCACIELQAoQSJHDQcgAUEkaiIFIAQoAjAQxgZByABBCBCtNiIERQ0DIARBAUEAIAVBARCbFCABQQE2AoABIAEgBDYCfCABQQE2AnggAUGIAmpBpPb+ABClKyABKQOQAiEWIAEpA4gCIRcgAUEIaiABQfgAahD+IyABKAIMIQYgASgCCCEIIAFB1AJqIgQgDSAJIAogFCgAAGsQ9jQCQCAEQQYQzCBB//8DcSIEBEAgBCAKaiIEQQRqIQUgBEF7Sw0GIAUgCU0NASAFIAlBzNX+ABCwOwALQYzh/gAQsjsACyABIAk2AtgCIAEgDTYC1AIgASAEIA1qKAAAIARqNgLcAkEwQQgQrTYiBEUNBSAEIAY2AgwgBCAINgIIIARCgYCAgBA3AwAgBCAWNwMoIAQgFzcDICAEQbD2/gApAwA3AxAgBEEYakG49v4AKQMANwMAIAFBiAJqIBEgAUHUAmogBCAMIBIQ7AYgAS0AzAJBAkYEQCABQdABaiABQZgCaigCACIENgIAIAFByAFqIAFBkAJqKQIAIhY3AwAgASABKQKIAiIXNwPAASADQRBqIAQ2AgAgA0EIaiAWNwIAIAMgFzcCAAwJCyABQcABaiIEIAFBiAJqQcMA/AoAACABQb8BaiABQc8Cai0AADoAACABIAEvAM0COwC9ASABQfgAaiIFIARBwwD8CgAAIAEgEzoAvAEgAUEAOgC7ASABQeAAaiAFEJMCIAFB0ABqIgQgAUHsAGopAgA3AwAgAUHYAGoiBSABQfQAaigCADYCACABIAEpAmQ3A0ggASgCYEEBRgRAIAMgASkDSDcCACADQRBqIAUoAgA2AgAgA0EIaiAEKQMANwIADAkLIAFBQGsgBSgCADYCACABQThqIAQpAwA3AwAgASABKQNINwMwIAFBMGpBABCPLSIFKAIAIgQgBCgCACIGQQFqNgIAIAZBAEgNBiAFKAIEIQUgASgCPCIGIAYoAgAiBkEBazYCACAGQQFGBEAgAUE8ahD4IwsgAUEwaiIGEMMnIAYQ6jsgAyAFNgIIIAMgBDYCBCADQZOAgIB4NgIADAgLIAogBEHc1f4AELE7AAsgBCAJQdzV/gAQsDsACyAEIAlBzNT+ABCvOwALQQhByAAQoz0ACyAEIAVBzNX+ABCxOwALQQhBMBCjPQsACyABQQI2AowCIAFBwOH+ADYCiAIgAUIBNwKUAiABQe4GNgLEASABIAFBwAFqNgKQAiABIAFBEGo2AsABIAFB/ABqIAFBiAJqEJkOIAEpAnwhFiADIAEpAoQBNwIMIAMgFjcCBCADQY2AgIB4NgIACyABQRhqEOk7IAFB4AJqJAAgAigCuAEhASACKAK0ASEDIAIoArABIgRBk4CAgHhHBEAgACACKQK8ATcDECAAIAE2AgwgACADNgIIIAAgBDYCBCAAQQQ6AAAgByAHKAIAIgBBAWs2AgAgAEEBRw0MIBEQ+x4MDAsgByAHKAIAIgRBAWs2AgAgAiABNgKAAyACIAM2AvwCIARBAUYEQCACQZgBahD7HgsgAkHwAmoiARCRGCEHIAEQwxghFiACKAL8AiIEIAQoAgAiAUEBajYCACABQQBIDQQgAkGcAmohBSACKAKAAyEBQQAhBiMAQZABayIDJAAgAyABNgIcIAMgBDYCGCADIBY3AxACQAJAIAdFBEAgBCAEKAIAIgdBAWo2AgAgB0EASA0BIANBCGogDCAWIAQgARClCyADIAMoAgw2AnQgAyADKAIIIgc2AnACQCAHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACADQfAAahC7IwsgBUGTgICAeDYCAAwCCwJAAkAgDCgCDEUNACAMKAIAIglBEGshCiAMKAIEIgggDEEQaiADQRBqEI0OIhencSEHIBdCGYhC/wCDQoGChIiQoMCAAX4hGQNAIAcgCWopAAAiGCAZhSIXQn+FIBdCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiF1BFBEADQCAWIAogF3qnQQN2IAdqIAhxIg1BBHRrKQMAUQ0EIBdCAX0gF4MiF1BFDQALCyAYIBhCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAZBCGoiBmogCHEhBwwACwALIANBAjYCdCADQdDg/gA2AnAgA0IBNwJ8IANB7gY2AkggAyADQcQAajYCeCADIANBEGo2AkQgA0HcAGogA0HwAGoQmQ4gBSADKQJgNwIIIAVBEGogA0HoAGooAgA2AgAgBSADKAJcNgIEIAVBjYCAgHg2AgAMAgsgA0HA3/4ANgJAIANBwN/+ADYCOCADIAlBACANa0EEdGpBCGs2AjQgAyADQRhqNgI8IANBIGogA0E0akECEJ0BIAMoAiBBk4CAgHhHBEAgA0HoAGogA0EwaigCADYCACADQeAAaiADQShqKQIANwMAIAMgAykCIDcDWCADQQE2AnQgA0GE4f4ANgJwIANCATcCfCADQecENgKMASADIANBiAFqNgJ4IAMgA0HYAGoiBzYCiAEgA0HIAGogA0HwAGoQmQ4gBxCIESADKQJIIRYgBSADKQJQNwIMIAUgFjcCBCAFQY2AgIB4NgIADAILIAMgDCAWIAMoAiQgAygCKBClCyADIAMoAgQ2AnQgAyADKAIAIgc2AnACQCAHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACADQfAAahC7IwsgBUGTgICAeDYCAAwBCwALIAMoAhgiBSAFKAIAIgVBAWs2AgAgBUEBRgRAIANBGGoQuyMLIANBkAFqJAAgAigCnAIiA0GTgICAeEcEQCAAIAIpAqACNwIIIABBEGogAkGoAmopAgA3AgAgAEEEOgAAIAAgAzYCBCAEIAQoAgAiAEEBazYCACAAQQFHDQwgAkH8AmoQuyMMDAsgAkHwAmoiBRDDGCEWIAUQkRghB0EAIQZBAiEFDAgLIABBAzoAAAwKCyAEIAVB0MzMABCxOwALIAUgA0HQzMwAELA7AAsgBCADQYzJzAAQrzsLAAtBBEEcEKM9AAsgBCADQYzJzAAQrzsAC0EEQRwQoz0ACyAAIAE2AhQgACAENgIQIAAgFjcDCCAAIAM2AgQgACAHOgABIAAgBToAACAAIAIpAzg3AxggAEEgaiACQUBrKQMANwMAIABBKGogAkHIAGopAwA3AwAgBkUNAiACQShqEM8vDAILIAIgBToAmAEgAkECNgKgAiACQbzNzAA2ApwCIAJCATcCqAIgAkGaAzYCtAEgAiACQbABajYCpAIgAiACQZgBajYCsAEgAEEIaiACQZwCahCZDiAAQQQ6AAAgAEGEgICAeDYCBAsgAkEoahDPLwsgAkGQA2okAA8LIAEgAigCpAJBsMzMABD9LwALIAUgA0GMycwAEK87AAunFQIUfwN9IwBB8AhrIgokACAAKAKMASIGIAAoAnwiCEkEQCAAIAg2AowBIAghBgsgACgCdCEJAkACQAJAAkACQAJAAkACQAJAAkAgACgChAFFBEAgASgCDEUNAiABKAIIIAY2AgAgASgCBEUNAUEAIQYgASgCAEEAOgAAIAlFDQZBGiAJayIHQQAgB0EaTRshCCAJQQJ0IREgAEEIaiELIAIhBwNAIAMgBkYEQCADIANBuPHMABDDIQALIAogB0GAAiAAKAJwEIERIAsgCigCBLMiGiAKKgIAIhsgGiAbXhsiGjgCACAGIAhHBEAgCyARaiAaOAIAIAdBiAhqIQcgC0EEaiELIAkgBkEBaiIGRw0BDAgLCyAGIAlqQRpByPHMABDDIQALIAZFDQYgCkEkakEAQTT8CwAgCkHoAGoiCEEAQYQI/AsAIApBo+D/+wc2AuwIIApB3ABqIhEgCCAJQQF0EIEcIApBGGogEUHMgs4AEKIhIAooAhwhECAKKAIYIREgCEEAQegA/AsAIApBADYCXCAKQQA2AlggCQRAIAlBiAhsIRQgAEEIaiEWIBEhCCACIQsDQAJAAkACQAJAAkAgAyAAKAKQASAHaiIGSwRAIApBEGogAiAGQYgIbGoiF0GAAiAAKAJwEIERIAdBDUYNASAHQQFqIQ8gCkEkaiAHQQJ0aiIYIAooAhSzIhogCioCECIbIBogG14bOAIAQQAhBiAKQdwAaiENQQEhDgNAIAYgCWwgB2oiDCAQTw0EIAAgBkECdGooAgAiFSAHaiESIBEgDEGICGxqIhMgF0GICPwKAAAgAyASTQ0FIBMgAiASQYgIbGooAoAIIBMoAoAIajYCgAggCCAGIBRsaiESIAsgFUGICGxqIRVBACEGA0AgBiASaiIZIAYgFWooAgAgGSgCAGo2AgAgBkEEaiIGQYAIRw0ACyAKQQhqIBNBgAIgACgCcBCBESAMQRlLDQMgDEECdCIGIApB6ABqaiAKKAIMsyIaIAoqAggiGyAaIBteGyIaOAIAIA0gDSoCACAaIBgqAgCTIAYgFmoqAgCTkjgCAEEBIQYgDiAKQdgAaiENQQAhDg0ACwwFCyAGIANB+PPMABDDIQALQQ1BDUGI9MwAEMMhAAsgDEEaQbj0zAAQwyEACyAMIBBBmPTMABDDIQALIBIgA0Go9MwAEMMhAAsgCEGICGohCCALQYgIaiELIA8iByAJRw0ACwsCQAJAAkACQAJAIAEoAhAiDyAAKAJ4TwRAIAoqAlwhGyAKKgJYIRoMAQsgCioCWCEaIAoqAlwiGyAAKgKAASIcXkUNACAaIBxeDQELIAAoAoQBIQcgASgCDCEIIBogG0MAAKDBkl1FBEAgB0EBayIHIAhPDQIgASgCCCAHQQJ0aiIHIAcoAgAgACgCjAFqNgIAAkACQAJAAkAgCQRAIAMgACgCACIMayIHQQAgAyAHTxshEiAJQQJ0IRMgAEEIaiELIAIgDEGICGxqIQ4gCkHoAGohByARIQhBACEGA0AgBiAQRg0CIAYgEkYNAyAOIAhBiAj8CgAAIAZBGkYNBCALIAcqAgAiGjgCACAPQQFGBEAgBiAJaiINQRlLDQogCyATaiAaOAIACyAGIAAoApABaiINIANPDQUgAiANQYgIbGoiDUEAQYQI/AsAIA1Bo+D/+wc2AoQIIA5BiAhqIQ4gCEGICGohCCALQQRqIQsgB0EEaiEHIAkgBkEBaiIGRw0ACwsgAEEANgKMASAAIAAoApQBQQFqIgI2ApQBIAJBAkkNDSAAIAAoAnwgACgCiAFqNgKIAQwNCyAQIBBB6PHMABDDIQALIAYgDGogA0H48cwAEMMhAAtBGkEaQYjyzAAQwyEACyANIANBqPLMABDDIQALIAcgCE8NAyABKAIIIAdBAnRqIAAoAowBNgIAIAAoAoQBIgdBAmsiBiABKAIEIghPBEAgBiAIQcjyzAAQwyEACyAHIAhJDQcgByAIQdjyzAAQwyEACyAAKAKEASIHIAEoAgwiCE8EQCAHIAhBqPPMABDDIQALIAEoAgggB0ECdGogACgCjAE2AgAgACgChAEiByABKAIEIghJDQUgByAIQbjzzAAQwyEACyAHIAhB2PHMABDDIQALIA1BGkGY8swAEMMhAAsgByAIQbjyzAAQwyEAC0EAQQBBmPHMABDDIQALQQBBAEGI8cwAEMMhAAsgASgCACAHaiAPOgAAIAAoAgAhByAAIAkgD2w2AgAgACAHNgIEAkACQAJAAkAgCQRAIABBCGoiByAJQQJ0aiEIQRogCSAJQRpPG0ECdCEOQQAhC0GYfyEGA0AgBiAOakUNBSAGIAhqQegAaiAGIAdqQegAaiIMKgIAOAIAIAZBTEYNAiAMIAYgCmpBjAFqKgIAOAIAIAZBBGohBiAJIAtBAWoiC0cNAAsLIAEgD0EBajYCECAAIAAoAoQBQQFqNgKEASAAIAAoApABIAlqIgc2ApABAkAgByAEKAIATw0AIAMgB0kNAiAAKAJ0IgggAyAHayIDSw0DIAhFDQAgAiAHQYgIbGoiBiAIQYgIbGohAgNAIAZBAEGECPwLACAGQYQIakGj4P/7BzYCACAGQYgIaiIGIAJHDQALCyAAQQA2ApQBIABBADYCjAEgACAAKAJ8NgKIAQwFC0ENQQ1B6PPMABDDIQALIAcgA0HI88wAEK87AAsgCCADQazqzAAQsDsACyAJIAtqQRpB2PPMABDDIQALIAcgASgCACIIaiAGIAhqLQAAOgAAIAAoAgQhDyAAIAAoAgA2AgQgACAPNgIAAkAgCUUNAEEaIAlrIgdBACAHQRpNGyENIAMgD2siB0EAIAMgB08bIRIgECAJayIHQQAgByAQTRshEyAAQQhqIQsgESAJQYgIbGohDiACIA9BiAhsaiEIIAlBAnQiFCAKQegAamohB0EAIQYCQANAAkAgBiATRwRAIAYgEkcNASAGIA9qIANB+PLMABDDIQALIAYgCWogEEHo8swAEMMhAAsgCCAOQYgI/AoAACAGIA1GDQEgCyAUaiALKgIAOAIAIAsgByoCADgCACADIAYgACgCkAFqIgxLBEAgAiAMQYgIbGoiDEEAQYQI/AsAIAxBo+D/+wc2AoQIIA5BiAhqIQ4gB0EEaiEHIAhBiAhqIQggC0EEaiELIAkgBkEBaiIGRw0BDAMLCyAMIANBmPPMABDDIQALIAYgCWpBGkGI88wAEMMhAAsgAEEANgKUASAAQQA2AowBIAAgACgCfDYCiAEgACAAKAKEAUEBajYChAELIBBFDQEgESAQQYgIbEEEEPg6DAELIAAgACgChAFBAWo2AoQBIAEgASgCEEEBajYCECAAIAAoApABIAlqIgc2ApABAkAgByAEKAIATw0AIAMgB0kNAiAAKAJ0IgggAyAHayIDSw0DIAhFDQAgAiAHQYgIbGoiBiAIQYgIbGohAgNAIAZBAEGECPwLACAGQYQIakGj4P/7BzYCACAGQYgIaiIGIAJHDQALCyAAQQA2AowBCyAFRQ0CIAEgACgChAE2AhQgBCABKAIQIAlsNgIADAILIAcgA0Go8cwAEK87AAsgCCADQazqzAAQsDsACyAKQfAIaiQAC9kWAgZ/DX4jAEHwAmsiBCQAIAQgAzYCDCAEIAEgAhD0CCAEIAQoAgQiATYCFCAEIAQoAgAiAjYCECAEQQE7AcQCIAQgATYCwAIgBEEANgK8AiAEQQE6ALgCIARBLjYCtAIgBCABNgKwAiAEQQA2AqwCIAQgATYCqAIgBCACNgKkAiAEQS42AqACIARBGGogBEGgAmoQ0hUCQAJAAkACQAJAAkACQAJAIAQoAiAiCEECTQRAIAhFDQMgBCgCHCIGKAIAIQEgBigCBCICDQFBACECDAILIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMBgsCQAJAIAEtAABBK2sOAwECAAILQQEhCSACQQFHBEAgASwAAUG/f0wNBAsgAkEBayECIAFBAWohAQwBCyACQQFHBEAgASwAAUG/f0wNBAsgAkEBayECIAFBAWohAQsgBCACNgIoIAQgATYCJEEBIQcgCEECRgRAIAYoAgghByAGKAIMIQULIAQgBTYCMCAEIAc2AiwgAkUNAyABLQAAQTBrQf8BcUEKSQ0DIARBATYCpAIgBEHcm4ABNgKgAiAEQgE3AqwCIARBxA02AvQBIAQgBEHwAWo2AqgCIAQgBEEQajYC8AEgAEEIaiAEQaACahCZDiAAQoGAgIDQgYCAgH83AwAMBAtBAEEAQZSbgAEQwyEACyABIAJBASACQaSbgAEQozYACyABIAJBASACQbSbgAEQozYACwJAIAVFDQAgBy0AAEEwa0H/AXFBCkkNACAEQQE2AqQCIARB3JuAATYCoAIgBEIBNwKsAiAEQcQNNgL0ASAEIARB8AFqNgKoAiAEIARBEGo2AvABIABBCGogBEGgAmoQmQ4gAEKBgICA0IGAgIB/NwMADAELAkACQAJAAkACQCADIAVPBEAgA0EAIAMgBUsbIgFBgIAETw0BIAQgATsB/AEgBEEANgL4ASAEQcwBNgL0ASAEQQE2ArQCIARB/JuAATYCsAIgBEEBNgKkAiAEQfSbgAE2AqACIARBAjYCrAIgBCAEQSxqNgLwASAEIARB8AFqIgI2AqgCIARBwAFqIgEgBEGgAmoiAxCZDiAEQQI2AqQCIARBlJyAATYCoAIgBEICNwKsAiAEQf4PNgL8ASAEQcwBNgL0ASAEIAI2AqgCIAQgATYC+AEgBCAEQSRqNgLwASAEQTRqIAMQmQ4gARDeOwwFCyAEQaACaiIGIAcgBRDMECAEKAKgAkEBcQ0DIAQgBCkDyAIiEjcDWCAEIAQpA8ACIhM3A1AgBCAEKQO4AiIUNwNIIAQgBCkDsAIiFTcDQCAEQfABakIKQgAQsi4gBiAEKQPwASAEKQP4ASAEKQOAAiAEKQOIAiAFIANrEN8BIAQoAqACQQFGBEAgACAEKQKkAjcCBCAAQQxqIAQoAqwCNgIAIAQpA7ACIQogAEEBNgIAIAAgCjcDEAwGCyAEKQPIAiEOIAQpA8ACIQ8gBCkDuAIhECAEKQOwAiERIARBoAJqIgNCAkIAELIuIAMgESAQIA8gDiAEKQOgAiAEKQOoAiAEKQOwAiAEKQO4AhCaCAJ+IAQtAKACQQFGBEBCgICAgICAgICAfyAELQChAg0BGgwICyAEKQPAAiEMIAQpA7gCIQogBCkDsAIhDSAEKQPIAgshFiAEIA03A2AgBCAKNwNoIAQgDDcDcCAEIBY3A3ggBEIAIAogDUIAUq18fSIKNwOIASAEQgAgDX0iDTcDgAEgBCANQgBSIApCAFIgClAbQX9zrUIBgyIKIAxCf4V8Igw3A5ABIAQgCiAMVq0gFkJ/hXw3A5gBIARBoAJqIBUgFCATIBIgESAQIA8gDhCaCAJ+IAQtAKACQQFGBEAgBC0AoQIEQEKAgICAgICAgIB/IQ1CACEKQgAMAgsMCAsgBCkDyAIhDSAEKQO4AiEKIAQpA7ACIQsgBCkDwAILIQwgBEGgAmogFSAUIBMgEiARIBAgDyAOEJoIAkAgBC0AoAJBAUYEQCAELQChAgRAIARBuAFqQgA3AwAgBEGwAWpCADcDACAEQgA3A6gBIARCADcDoAEMAgsgBEEANgKAAiAEQQE2AvQBIARBjJSAATYC8AEgBEIENwL4ASAEQfABakGklIABEO8sAAsgBCAEKQPoAjcDuAEgBCAEKQPgAjcDsAEgBCAEKQPYAjcDqAEgBCAEKQPQAjcDoAELAkAgBEFAa0HQk4ABEPsbIgNB/wFxQQJHIAPAQQBOcUUEQCAEQaABaiAEQYABahD7G8BBAEwNAQwDCyAEQaABaiAEQeAAahD7GyIDQf8BcUECRiADwEEASHINAiANIAwgC0IBfCIOIAogDlCtfCIPhFCtfCIKIAxUrXwhDQwDCyALQgF9IQ4gCiALUK19IQ8gDCAKIAuEUK0iC30hCiANIAsgDFatfSENDAILIARBADYCsAIgBEEBNgKkAiAEQbCXgAE2AqACIARCBDcCqAIgBEGgAmpB5JuAARDvLAALIAshDiAKIQ8gDCEKCwJ+IAJFBEBCACELQgAhDEIAIRFCAAwBCyAEQaACaiABIAIQzBAgBCAEKAKgAkEBcQR+QgAFIAQgBCkDyAI3A5gCIAQgBCkDwAI3A5ACIAQgBCkDuAI3A4gCIAQgBCkDsAI3A4ACQgELNwPwASAEQgA3A/gBIARBoAJqIgEgBEHwAWogBEEQahCSFyAEQcABaiABIARBDGoQ5g0gBCgCwAFBAUYEQCAAIAQpAsQBNwIEIABBDGogBCgCzAE2AgAgBCkD0AEhCiAAQQE2AgAgACAKNwMQDAQLIAQpA+gBIREgBCkD4AEhDCAEKQPQASELIAQpA9gBCyEQIARBATYC9AEgBEH0m4ABNgLwASAEQgE3AvwBIARB/w82AsQBIAQgCyAOfCIONwOgAiAEIAsgDlYiAa0gDyAQfHwiCzcDqAIgBCAKIAx8IgogASALIBBUIAsgEFEbrXwiCzcDsAIgBCAKIAtWrSAKIAxUrSANIBF8fHw3A7gCIAQgBEHAAWo2AvgBIAQgBEGgAmo2AsABIARBNGogBEHwAWoQmQ4MAQsgBEEBNgKkAiAEQdScgAE2AqACIARCATcCrAIgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiAEQaACahCZDiAEQY2AgIB4NgLwASAAIAQpAvABNwIEIABBDGogBEH4AWooAgA2AgAgBCkC/AEhCiAAQQE2AgAgACAKNwMQDAELIAQoAjwhAiAJBEAgBEE0akEBEIQuIAIEQCAEKAI4IgFBAWogASAC/AoAAAsgBCgCOEEtOgAAIAQgAkEBaiICNgI8CyAEQaACaiIBIAQoAjggAhDMECAEKAKgAkEBcQRAIARBAzYCpAIgBEGQnYABNgKgAiAEQgI3AqwCIARBzAE2AswBIARBtJ2AATYCyAEgBEHMATYCxAEgBCAEQcABajYCqAIgBCAEQRBqNgLAASAEQfQBaiABEJkOIARBjYCAgHg2AvABIAAgBCkC8AE3AgQgAEEMaiAEQfgBaigCADYCACAEKQL8ASEKIABBATYCACAAIAo3AxAgBEE0ahDeOwwBCyAEKQOwAiEKIAQpA7gCIQsgBCkDwAIhDCAAIAQpA8gCNwMoIAAgDDcDICAAIAs3AxggACAKNwMQIABBADYCACAEQTRqEN47CyAEQRhqEOo7IARB8AJqJAAPCyAEQQA2AoACIARBATYC9AEgBEGMlIABNgLwASAEQgQ3AvgBIARB8AFqQZSUgAEQ7ywAC5ATAgZ/CH4jAEHwAGsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQEQCAAKAIAIgAoAhRFDQEgACgCECIAKAIIRQ0CAkACQAJAAkACQCABLQA8QShGBEAgACgCBCEIIAUgASgCQCIHQTBqNgIcIActADBBA2sOAwIDBAELIAVBADYCYCAFQQE2AlQgBUGUuocBNgJQIAVCBDcCWCAFQdAAakGcuocBEO8sAAsgBUEBNgJUIAVBiLCHATYCUCAFQgE3AlwgBUGvAzYCbCAFIAVB6ABqNgJYIAUgBUEcajYCaCAFQdAAakHUuYcBEO8sAAsgASgCKCIKRQ0GIAEoAiQiBxCUGiEGIAA1AiQhDUEAIQEgBUEANgJYIAVCgICAgBA3AlAgBSAGOwFoIAUgCBDGGyADIARqIQYgBTUCBEIBfCEPIAUoAgAhBEKAgICAECEMQoCAgIAQIQ5BACEIA0ACQCANUA0AIA9CAX0iD1ANACABIQAgBC4BACIBQQBIDQkgEEIBfCEQAkACQCAAIANNIAEgA0txRQRAIAEgBk0gACADT3ENASABIAZJIAAgBk9yDQIgBS4BaCAGIABrwWoiAMEgAEcNFCAFIAA7AWggBUHQAGogBUHoAGpBAhChNiAIRQ0VIAtC/////w+DIA58IQtBASEIDAMLIAUuAWggASAGIAEgBkkbIANrwWoiAMEgAEcNECAFIAA7AWggBUHQAGogBUHoAGpBAhChNkEBIQggDCELDAELIAUuAWggASAAa8FqIgDBIABHDRAgBSAAOwFoIAVB0ABqIAVB6ABqQQIQoTYgCEUNESALQv////8PgyAQQiCGhCELQQEhCAsgDUIBfSENIAxCgYCAgBB8IQwgBEECaiEEIA5CgICAgBB8IQ4gASAGSQ0BCwsgBUEoaiAFQdgAaigCACIANgIAIAUgBSkCUDcDICAFQSBqIQMgAEUNAiAFKAIkIQEgBygCGCIEIABqIgYgBygCECIJSwRAIAdBDGogCUEBdCIEIAYQ4CoiBiAEIAZLGxDoGSAHKAIYIQQLIAAEQCAHKAIUIARqIAEgAPwKAAALIAcgBygCGCAAajYCGCAHIAcoAlggAEEBdmo2AlggCEUNESAKQQFGDRIgB0HMAWogAiALpyALQiCIpxDYGwwCCyABKAIoIgpFDQcgASgCJCIHEJIaIQEgADUCJCENIAVBADYCWCAFQoCAgIAQNwJQIAUgATYCaCAFQQhqIAgQxxsgAyAEaiEGIAU1AgxCAXwhDyAFKAIIIQRCgICAgBAhDEKAgICAECEOQQAhAUEAIQgDQAJAIA1QDQAgD0IBfSIPUA0AIAEhACAEKAIAIgFBAEgNCiAQQgF8IRACQAJAIAAgA00gASADS3FFBEAgASAGTSAAIANPcQ0BIAEgBkkgACAGT3INAiAGIABrIgBBAEggACAFKAJoIgFqIgAgAUhHDRMgBSAANgJoIAVB0ABqIAVB6ABqQQQQoTYgCEUNFCALQv////8PgyAOfCELQQEhCAwDCyABIAYgASAGSRsgA2siAEEASCAAIAUoAmgiCGoiACAISEcNDyAFIAA2AmggBUHQAGogBUHoAGpBBBChNkEBIQggDCELDAELIAEgAGsiAEEASCAAIAUoAmgiCWoiACAJSEcNDyAFIAA2AmggBUHQAGogBUHoAGpBBBChNiAIRQ0QIAtC/////w+DIBBCIIaEIQtBASEICyANQgF9IQ0gDEKBgICAEHwhDCAEQQRqIQQgDkKAgICAEHwhDiABIAZJDQELCyAFQThqIAVB2ABqKAIAIgA2AgAgBSAFKQJQNwMwIAVBMGohAyAARQ0BIAUoAjQhASAHKAIYIgQgAGoiBiAHKAIQIglLBEAgB0EMaiAJQQF0IgQgBhDgKiIGIAQgBksbEOgZIAcoAhghBAsgAARAIAcoAhQgBGogASAA/AoAAAsgByAHKAIYIABqNgIYIAcgBygCWCAAQQJ2ajYCWCAIRQ0QIApBAUYNESAHQcwBaiACIAunIAtCIIinENgbDAELIAEoAigiCkUNCCABKAIkIgcQkxohDCAANQIkIQ1BACEBIAVBADYCWCAFQoCAgIAQNwJQIAUgDDcDaCAFQRBqIAgQxRsgAyAEaiEGIAU1AhRCAXwhDyAFKAIQIQRCgICAgBAhDEKAgICAECEOQQAhCANAAkAgDVANACAPQgF9Ig9QDQAgBCkDACIRQoCAgIAQWg0LIBBCAXwhEAJAAkAgASIAIANNIAMgEaciAUlxRQRAIAEgBk0gACADT3ENASABIAZJIAAgBk9yDQIgBiAAa60iDEIAVCAMIAUpA2giDXwiDCANU0cNEiAFIAw3A2ggBUHQAGogBUHoAGpBCBChNiAIRQ0TIAtC/////w+DIA58IQtBASEIDAMLIAYgASABIAZLGyADa60iC0IAVCALIAUpA2giEXwiCyARU0cNDiAFIAs3A2ggBUHQAGogBUHoAGpBCBChNkEBIQggDCELDAELIAEgAGutIhFCAFQgESAFKQNoIhJ8IhEgElNHDQ4gBSARNwNoIAVB0ABqIAVB6ABqQQgQoTYgCEUNDyALQv////8PgyAQQiCGhCELQQEhCAsgDUIBfSENIAxCgYCAgBB8IQwgBEEIaiEEIA5CgICAgBB8IQ4gASAGSQ0BCwsgBUHIAGogBUHYAGooAgAiADYCACAFIAUpAlA3A0AgBUFAayEDIABFDQAgBSgCRCEBIAcoAhgiBCAAaiIGIAcoAhAiCUsEQCAHQQxqIAlBAXQiBCAGEOAqIgYgBCAGSxsQ6BkgBygCGCEECyAABEAgBygCFCAEaiABIAD8CgAACyAHIAcoAhggAGo2AhggByAHKAJYIABBA3ZqNgJYIAhFDQ8gCkEBRg0QIAdBzAFqIAIgC6cgC0IgiKcQ2BsLIAMQ3jsLIAVB8ABqJAAPC0EAQQBBhLmHARDDIQALQQBBAEGUuYcBEMMhAAtBAEEAQaS5hwEQwyEAC0HosIcBELI7AAtBAEEAQbS5hwEQwyEAC0HosIcBELI7AAtBAEEAQcS5hwEQwyEAC0HosIcBELI7AAtBqK+HAUEQQfC3hwEQyyQAC0Gor4cBQRBBjLWHARDLJAALQay1hwFBsQJB4LeHARDLJAALQaivhwFBEEH4sIcBEMskAAtBmLGHAUHkA0H8tIcBEMskAAtBkLiHAUE6Qcy4hwEQyyQAC0EBQQFB3LiHARDDIQAL0RQBEH8jAEHAB2siAiQAIAJBmANqIAEoAgwiAyABKAIQIgQoAhgRAAAgAigCoAMhBiACKAKcAyEFAkACQAJAIAIoApgDIgdBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAGNgIIIAAgBTYCBCAAIAc2AgAMAQsgAiAGNgIgIAIgBTYCHAJAAkACQCACQRxqEPUtRQRAIAJBEGogAyAEKAIgEQAAIAIoAhAiBw0CIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRw0BDAULIAIgARCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAgsgAigCoAMiAUEYakGc1NAAKQAANwAAIAFBEGpBlNTQACkAADcAACABQQhqQYzU0AApAAA3AAAgAUGE1NAAKQAANwAAIABBIDYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACKAIUIQUgAkEIaiADIAQoAiQRAAAgAigCCCIMRQRAIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRg0DIAIoAqADIgFBGGpBvNTQACkAADcAACABQRBqQbTU0AApAAA3AAAgAUEIakGs1NAAKQAANwAAIAFBpNTQACkAADcAACAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAMAQsgAigCDCEGIAJBHGoQ9C0aAkAgBkUNACAMLwEARQ0AIAJBmANqQSlBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRg0EIAIoAqADIgNBiNHQAEEp/AoAACAAQSk2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAQsgAkGYA2ogAkEcahD0LUEBakEAQQhBCBCgGCACKAKcAyEDAkACQAJAAkACQAJAIAIoApgDQQFHBEAgAkEANgIsIAIgAigCoAM2AiggAiADNgIkAkAgAS0AGEUEQCACQQA2AjAMAQtBwAAhBCACQRxqEPQtIgNBA3YgA0EHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQQLIAJCADcCPCACIAQ2AjggAiADNgI0IAJBwAA2AjALIAJBxABqIgQgAkEcaiINEMMtQQRBBBCtNiIDRQ0DIAJBATYCoAMgAiADNgKcAyACQQE2ApgDIAMgBDYCAEEAIQMgAkGIAWogAkGYA2pBACANEPQtEMAsIAYgBSAFIAZLGyINRQRAQQAhBEEAIQYMBQsgAS8BFsEhEEEAIQRBACEGA0ACQAJAAkACQAJAIAwuAQAiBSAQSiAFIBBIa0H/AXEOAgIBAAsgAigCLCIFIAIoAiRGBEAgAkEkakHU1NAAELMoCyACKAIoIAVBA3RqIAOtNwMAIAIgBUEBajYCLCAHLgEAIgggAS4BFCIRSARAIAQEQCACQYgBakEAIA4gAyAGahDYGwsCQCACKAIwRQ0AIAIoAkAiCUEBaiIKQQN2IApBB3FBAEdqIgUgAigCPCIESwRAIAUgBGshCyACKAI0Ig8gBUkEQCACQTBqIA9BAXQiBCAFQcD///8DcUFAayAFIAVBP3EbIg8gBCAPSxsQ6BkgAigCPCEECyALBEAgAigCOCAEakEAIAv8CwALIAIgBTYCPAsgAiAKNgJAIAhBAWpB//8DcSARQf//A3FHDQAgAigCOCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAALIAZBAWohBkEAIQQMAwsgDiADIAZqIAQbIQ4gA0EBaiEDIAIoAjBFBEBBASEEDAMLIAIoAkAiCUEBaiIKQQN2IApBB3FBAEdqIgUgAigCPCIESwRAIAUgBGshCyACKAI0IgggBUkEQCACQTBqIAhBAXQiBCAFQcD///8DcUFAayAFIAVBP3EbIgggBCAISxsQ6BkgAigCPCEECyALBEAgAigCOCAEakEAIAv8CwALIAIgBTYCPAsgAiAKNgJAQQEhBCACKAI4IAlBA3ZqIgUgBS0AAEEBIAlBB3F0cjoAAAwCCyAHLgEAIAEuARRODQEgAkGYA2pBO0EAQQFBARCgGCACKAKcAyEBIAIoApgDQQFHDQIMDgsgA0EBaiEDCyAHQQJqIQcgDEECaiEMIA1BAWsiDQ0BDAYLCyACKAKgAyIDQeTU0ABBO/wKAAAgAEE7NgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAULIAMgAigCoANBtNHQABD9LwALQZSf0ABBKSACQZgDakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAsgAigCLCIFIAIoAiRGBEAgAkEkakHU0dAAELMoCyACKAIoIAVBA3RqIAOtNwMAIAIgBUEBajYCLAJAIAZFBEAgAkHUAmogAkEcahDDLQwBCyAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLIAJBmANqIgQgAkGIAWpBzAH8CgAAIAJB1AJqIAQQ6iwLAkACQCACKAL4AiADRgRAIAJB6ARqIgMgAigCKCACKAIsQQN0EIs9IAJBuANqIAEQxAYgAkEAOwHwAyACQQA2AuwDIAJBADYC1AMgAkEANgLIAyACQgQ3ArADIAJCADcCqAMgAkKAgICAwAA3AqADIAJBADYCmAMgAiACKAIsQQFrNgLEAyACQdAFaiIEIAJBmANqIgEgAxD6IyABIAJB1AJqQcQA/AoAACACQfQEaiAEIAEQ7yUgAigCMEUNAiACIAIoAkAiAzYCsAYgAiACKAIsQQFrIgQ2ArQGIAMgBEYNASACQQA2ApgDQQAgAkGwBmogAkG0BmogAUHk0dAAEK8rAAsgAkGYA2pBKkEAQQFBARCgGCACKAKcAyEBIAIoApgDQQFGDQcgAigCoAMiA0HM0tAAQSr8CgAAIABBKjYCDCAAIAM2AgggACABNgIEIABBADYCACACQdQCahD6JiAGRQ0CDAMLIAJBmANqIgEgAkH0BGoiBEHcAPwKAAAgAkHYBWogAkE4aikCADcDACACIAIpAjA3A9AFIAIgAzYC4AUgAkG4BmoiAyACQdAFahCIGSAEIAEgAxCuFgsgAkGYA2oiASACQfQEakHcAPwKAAAgAkHEBmoiAyABEM0cIAJBiAdqIgQgAxCuHwJAQcAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTj8CgAAIABBrNPQADYCCCAAIAE2AgQgAEEINgIAIAYNASACQYgBahCXFwwBC0EEQcAAEKM9AAsgAkHEAGoQ+iYgAkEkahDjPCACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNAyACQRxqELsjDAMLIAJBiAFqEJcXCyACQcQAahD6JiACKAIwBEAgAkEwahDPLwsgAkEkahDjPAsgAigCHCIAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEcahC7IwsgAkHAB2okAA8LIAMgAigCoANBpMbQABD9LwALIAEgAigCoANBpMbQABD9LwALlRgBE38jAEGQA2siAiQAIAJBzABqIAFBDGpB0AD8CgAAQQEhEEEEIQZBASEMAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAItAIgBIgtBFGsOFQMBAwQDAwQBAQIBAQIFAQEBAQEBAgALIAtFDQELQQxBBBCtNiIGRQ0FIAIoAlQhBSACKAJYIQkgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAk2AqACIAIgBTYCnAIgAkEQaiACQZwCahDXOyACKAIQIQRBHEEEEK02IgVFDQ8gBUKBgICAEDcCACAFIAIpApwCNwIIIAVBEGogAkGkAmopAgA3AgAgBUEYaiACQawCaigCADYCACAGIAk2AgggBiAENgIEIAYgBTYCAEEBIQULIAtBIkYNA0EBIQ0gBQwLC0EYQQQQrTYiBkUNBCACKAJUIQMgAigCWCEMIAIgAikCTDcCqAIgAkEANgKkAiACIAw2AqACIAIgAzYCnAIgAkEgaiACQZwCaiIJENc7IAIoAiAhA0EcQQQQrTYiB0UNDSAHQoGAgIAQNwIAIAcgAikCnAI3AgggB0EQaiACQaQCaiIQKQIANwIAIAdBGGogAkGsAmoiBSgCADYCACACKAJkIQQgAigCaCENIAIgAikCXDcCqAIgAkEANgKkAiACIA02AqACIAIgBDYCnAIgAkEYaiAJENc7IAIoAhghCUEcQQQQrTYiCEUNDQwJCyACQYADaiABQeQAaigCADYCACACIAEpAlw3A/gCIAIoAlQhAyACKAJYIQUgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAU2AqACIAIgAzYCnAIgAkEoaiACQZwCahDXOyACKAIoIQlBHEEEEK02IgNFDQwgA0KBgICAEDcCACADIAIpApwCNwIIIANBEGogAkGkAmopAgA3AgAgA0EYaiACQawCaigCADYCACACIAU2AsgBIAIgCTYCxAEgAiADNgLAASACQfgCaiACQcABakHolocBEPkbIAIoAvwCIQYgAigCgAMhBSACKAL4AgwJCyACLQCJAQ0GQQxBBBCtNiIGRQ0DIAIoAlQhAyACKAJYIQUgAiACKQJMNwKoAkEAIQwgAkEANgKkAiACIAU2AqACIAIgAzYCnAIgAkFAayACQZwCahDXOyACKAJAIQlBHEEEEK02IgNFDQsgA0KBgICAEDcCACADIAIpApwCNwIIIANBEGogAkGkAmopAgA3AgAgA0EYaiACQawCaigCADYCACAGIAU2AgggBiAJNgIEIAYgAzYCAEEBIQ1BASEFQQEMCAtBxABBBBCtNiIJRQ0DIAEoAoABIgRBgICAgHhGDQQgCUEEaiABQYQBakHAAPwKAAAgCSAENgIAQQEhDSACQQE2AqQBIAIgCTYCoAEgAkEBNgKcASAFIQlBASEHDAgLQQRBDBCjPQALQQRBGBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC0H4locBELI7AAsCQEEYQQQQrTYiBgRAIAIoAlQhAyACKAJYIQwgAiACKQJMNwKoAiACQQA2AqQCIAIgDDYCoAIgAiADNgKcAiACQThqIAJBnAJqIgkQ1zsgAigCOCEDQRxBBBCtNiIHRQ0GIAdCgYCAgBA3AgAgByACKQKcAjcCCCAHQRBqIAJBpAJqIhApAgA3AgAgB0EYaiACQawCaiIFKAIANgIAIAIoAmQhBCACKAJoIQ0gAiACKQJcNwKoAiACQQA2AqQCIAIgDTYCoAIgAiAENgKcAiACQTBqIAkQ1zsgAigCMCEJQRxBBBCtNiIIRQ0BDAILQQRBGBCjPQALDAQLIAhCgYCAgBA3AgAgCCACKQKcAjcCCCAIQRBqIBApAgA3AgAgCEEYaiAFKAIANgIAIAYgDTYCFCAGIAk2AhAgBiAINgIMIAYgDDYCCCAGIAM2AgQgBiAHNgIAQQEhDUEAIRBBACEMQQIhBUECCyEJIAIoAnQhBCACKAJwIQMgAiACKAJsNgKkAiACIAM2AqACIAIgAzYCnAIgAiADIARBzAFsajYCqAIjAEEQayIOJAAgAkGcAmoiAygCCCETIA5BCGohDyADKAIAIgchBCADKAIMGiMAQfACayIIJAAgAygCBCIKIAMoAgwiEUcEQANAIAhByABqIhIgCkHMAfwKAAAgAyAKQcwBaiIKNgIEIAhBlAJqIhQgEhDZASAIQQRqIhIgFBDNHCAEIBJBxAD8CgAAIARBxABqIQQgCiARRw0ACwsgDyAENgIEIA8gBzYCACAIQfACaiQAIA4oAgwhESMAQRBrIggkACADQQA2AgggAygCDCEKIAMoAgQhBCADQQQ2AgAgCEKAgICAwAA3AgggCEEIakEEQcwBEOAeIANBBDYCDCADQQQ2AgQgCiAEa0HMAW4hDyAEIApHBEADQCAEEPUQIARBzAFqIQQgD0EBayIPDQALCyAIQRBqJAAgAkGcAWoiBCAHNgIEIAQgE0EDbDYCACAEIBEgB2tBxABuNgIIIwBBEGsiBCQAIAMoAgwiCiADKAIEIgdrQcwBbiEIIAcgCkcEQANAIAcQ9RAgB0HMAWohByAIQQFrIggNAAsLIAQgAygCADYCDCAEIAMoAgg2AgggBEEIakEEQcwBEOAeIARBEGokACAOQRBqJABBASEIQQAhByALRQRAQQAhAwwCC0EAIQMgC0EoRg0BC0EAIQggAigCeCIERQ0AIAIoAoQBIQsgAigCgAEhCiACIAIoAnw2AqwCIAIgBDYCqAIgAkEANgKkAiACIAs2AqACIAIgCjYCnAIgAkEIaiACQZwCaiIKENc7IAIoAgghDkEcQQQQrTYiBEUNASAEQoGAgIAQNwIAIAQgAikCnAI3AgggBEEQaiACQaQCaikCADcCACAEQRhqIAJBrAJqKAIANgIAIAIgCzYCgAMgAiAONgL8AiACIAQ2AvgCIAogAkH4AmpBACACKAKYARDyFSACQcgBaiILIAJBqAJqIg4pAgA3AwAgAkHQAWoiDyACKAKUATYCACACIAIpAqACNwPAASACKAKcAiIERQ0AIA4gCykDADcCACACQbACaiAPKAIAIgM2AgAgAiAENgKcAiACIAIpA8ABNwKgAiADRQRAIAQgBCgCACIEQQFrNgIAQQAhAyAEQQFHDQEgChD7HgwBCyACQbgBaiACQdABaigCADYCACACQbABaiACQcgBaikDADcDACACIAIpA8ABNwOoASAEIQMLIAJBxAJqIAJBiAFqIgRBCGooAgA2AgAgAkEAOwH0AiACQQA2AvACIAJBADYC2AIgAkEANgLMAiACIAIoApgBNgLIAiACQgQ3ArQCIAJCADcCrAIgAkKAgICAwAA3AqQCIAJBADYCnAIgAiAEKQIANwK8AiACIAM2AvgCIAJBhANqIAJBsAFqKQMANwIAIAJBjANqIAJBuAFqKAIANgIAIAIgAikDqAE3AvwCIAJBwAFqIgQgAkGcAmoiAyACQfgCahDCGSACQcgBaiILEMUnIAtBBEEMEOAeIAIgBTYC0AEgAiAGNgLMASACIAk2AsgBIAMgBEHcAPwKAAAgACADIAJBnAFqEPwiAkAgCEUNACACKAJ4RQ0AIAJB+ABqEM8vCyAMBEAgAkHMAGoQzy8LIBAEQCACQdwAahDPLwsCQCAHBEAgAkHsAGoiABCKFCAAQQRBzAEQ4B4gAUEEQQQQ4B4MAQsgAUEEQQQQ4B4gASgCgAFBgICAgHhGDQAgAUGYAWoQzAwgAUGAAWoiABDFJyAAQQRBDBDgHiABKAKUASIDBEAgASgCkAEhBgNAIAYQpR4gBkHEAGohBiADQQFrIgMNAAsLIAFBjAFqQQRBxAAQ4B4gASgCrAEiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUGsAWoQ+x4LIA0EQCABQdwAaiIAEMUnIABBBEEMEOAeCyABQegAaiIAEIEjIABBBEEIEOAeIAFB9ABqIgAQgSMgAEEEQQgQ4B4gASgCxAEhACABKALIASIBKAIAIgMEQCAAIAMRAwALIAEoAgQiAwRAIAAgAyABKAIIEPg6CyACQZADaiQADwtBBEEcEKM9AAu8FAEJfiAAIAEpAwAiBUJ/hSIHIAIpAwAiCSABKQMIIgQgA62FIgZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCAGQtii0e/CqeW/LX6FIgggAikDGCIKhSIEQtii0e/CqeW/LX4gBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhYUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEIARC2KLR78Kp5b8tfoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH4iBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhCAEIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQiBn6FIASJNwMYIAAgAikDCCILIAggAikDECIMhSIEQtii0e/CqeW/LX4gBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhYUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhELSgaqbq/qC16d/fiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIARC2KLR78Kp5b8tfoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCAHfiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAQgBn6FIASJNwMQIAAgCiAIIAuFIgRC2KLR78Kp5b8tfiAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEQtKBqpur+oLXp39+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFhSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEQtKBqpur+oLXp39+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgBELYotHvwqnlvy1+hSIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAd+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgBCAGfoUgBIk3AwggACAMIAggCYUiBELYotHvwqnlvy1+IARCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhIWFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhCAEQtii0e/CqeW/LX6FIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIQgB34iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhCAEIAZ+hSAEiTcDAAv2XwIMfwF+IwBBQGoiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAIoAhwiBREEACIELQAAQQJrDiUBAgMEBQYHCAkKCwAAAAAADA0AAAAAAAAAAAAAAAAAAAAODxARAAsgASAFEQQAIgQtAAAOKRgZOjo6Ojo6Ojo6OjoaGxwdHjo6HyAhIiMkJSY6Jyg6KSo0Ojo6Ois1OgsgASACELsiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNPCABIAQ2AgggASADNgIEIAEgAjYCACAAQfCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMOgsgASACEKgiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOyABIAQ2AgggASADNgIEIAEgAjYCACAAQbCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMOQsgASACELEiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOiABIAQ2AgggASADNgIEIAEgAjYCACAAQfCNgQE2AgggACABNgIEIABBk4CAgHg2AgAMOAsgASACEKQiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOSABIAQ2AgggASADNgIEIAEgAjYCACAAQZCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMNwsgASACEKoiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNOCABIAQ2AgggASADNgIEIAEgAjYCACAAQbCPgQE2AgggACABNgIEIABBk4CAgHg2AgAMNgsgASACEK0iIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNyABIAQ2AgggASADNgIEIAEgAjYCACAAQeCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMNQsgASACELciIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNiABIAQ2AgggASADNgIEIAEgAjYCACAAQfCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMNAsgASACEKIiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNSABIAQ2AgggASADNgIEIAEgAjYCACAAQZCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMMwsgASACELkiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNNCABIAQ2AgggASADNgIEIAEgAjYCACAAQfCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMMgsgASACELUiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNMyABIAQ2AgggASADNgIEIAEgAjYCACAAQYCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMMQsgASACEKYiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNMiABIAQ2AgggASADNgIEIAEgAjYCACAAQYCNgQE2AgggACABNgIEIABBk4CAgHg2AgAMMAsgBC0AAUEBaw4DBgcIBQsgBC0AAUEBaw4CCQoICyABIAIQpyIiAhDNICEEAn8jAEEwayIBJAAgAi0AAEEjRgRAIAItAAIgAUEwaiQADAELIAFBATYCECABQZSH/wA2AgwgAUIBNwIYIAFBpwQ2AiggASACNgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakGch/8AEO8sAAshBSADKAIsIQYgAygCKCEDQRBBBBCtNiIBRQ0uIAEgBToADSABIAQ6AAwgASAGNgIIIAEgAzYCBCABIAI2AgAgAEHQjYEBNgIIIAAgATYCBCAAQZOAgIB4NgIADC0LIAEgAhCrIiICENAgIQQCfyMAQTBrIgEkACACLQAAQSRGBEAgAi0AAiABQTBqJAAMAQsgAUEBNgIQIAFBnIX/ADYCDCABQgE3AhggAUGnBDYCKCABIAI2AiwgASABQSRqNgIUIAEgAUEsajYCJCABQQxqQaSF/wAQ7ywACyEFIAMoAiwhBiADKAIoIQNBEEEEEK02IgFFDS0gASAFOgANIAEgBDoADCABIAY2AgggASADNgIEIAEgAjYCACAAQeCRgQE2AgggACABNgIEIABBk4CAgHg2AgAMLAsgASACELwiIgIQziAhBAJ/IwBBMGsiASQAIAItAABBJUYEQCACLQACIAFBMGokAAwBCyABQQE2AhAgAUGYhv8ANgIMIAFCATcCGCABQacENgIoIAEgAjYCLCABIAFBJGo2AhQgASABQSxqNgIkIAFBDGpBoIb/ABDvLAALIQUgAygCLCEGIAMoAighA0EQQQQQrTYiAUUNLCABIAU6AA0gASAEOgAMIAEgBjYCCCABIAM2AgQgASACNgIAIABB0JKBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwrCyABIAIQqSIiAhDPICEEAn8jAEEwayIBJAAgAi0AAEEmRgRAIAItAAIgAUEwaiQADAELIAFBATYCECABQZCI/wA2AgwgAUIBNwIYIAFBpwQ2AiggASACNgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakGYiP8AEO8sAAshBSADKAIsIQYgAygCKCEDQRBBBBCtNiIBRQ0rIAEgBToADSABIAQ6AAwgASAGNgIIIAEgAzYCBCABIAI2AgAgAEHQj4EBNgIIIAAgATYCBCAAQZOAgIB4NgIADCoLIAEgAhCzIiECIAMoAiwhBCADKAIoIQUgAy0AMSEDQRBBBBCtNiIBRQ0qIAEgAzoADCABIAQ2AgggASAFNgIEIAEgAjYCACAAQeCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMKQsgASACEKEiIQIgAygCLCEEIAMoAighBSADLQAxIQNBEEEEEK02IgFFDSkgASADOgAMIAEgBDYCCCABIAU2AgQgASACNgIAIABBkI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwoCyABIAIQnSIhAiADKAIsIQQgAygCKCEFIAMtADEhA0EQQQQQrTYiAUUNKCABIAM6AAwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGQk4EBNgIIIAAgATYCBCAAQZOAgIB4NgIADCcLIAEgAhCuIiECIAMoAiwhBCADKAIoIQUgAy0AMSEDQRBBBBCtNiIBRQ0nIAEgAzoADCABIAQ2AgggASAFNgIEIAEgAjYCACAAQZCQgQE2AgggACABNgIEIABBk4CAgHg2AgAMJgsgASACELgiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJyABIAQ2AgggASADNgIEIAEgAjYCACAAQcCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMJQsgASACEKMiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJiABIAQ2AgggASADNgIEIAEgAjYCACAAQdCMgQE2AgggACABNgIEIABBk4CAgHg2AgAMJAsgASACEKAiIQIgAygCLCEEIAMoAighA0EMQQQQrTYiAUUNJSABIAQ2AgggASADNgIEIAEgAjYCACAAQfCPgQE2AgggACABNgIEIABBk4CAgHg2AgAMIwsjAEEgayIEJAAgBEEIaiABIAIoAhARAAAgBEEQaiAEKAIIIgIgBCgCDCgCDBEAAAJAIAIEQCAEKQMQQpC+kouvm5r/BoUgBCkDGELvzbTtqOGJ4U2FhFANAQtB9PuFAUE3Qaz8hQEQyyQACyAEQSBqJAAgAygCLCEEIAMoAighA0EUQQQQrTYiAUUNJSABIAQ2AhAgASADNgIMIAEgAjYCCCABIAQ2AgQgASADNgIAIABB4JCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwiCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiAiAEKAIMKAIMEQAAAkAgAgRAIAQpAxBCiqLN5aLCqolqhSAEKQMYQouy+d7NmrveOYWEUA0BC0GU+4UBQSJBuPuFARDLJAALIARBIGokACADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0jIAEgBDYCCCABIAM2AgQgASACNgIAIABB8JCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwhCyAELQABQQFrDgMSExQRCyABIAIQpSIhAiADKAIsIQQgAygCKCEFIAMoAgQhBiADKAIAIQNBFEEEEK02IgFFDSIgASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQcCOgQE2AgggACABNgIEIABBk4CAgHg2AgAMHwsgASACELAiIQIgAygCLCEEIAMoAighBSADKAIMIQYgAygCCCEDQRRBBBCtNiIBRQ0hIAEgBjYCECABIAM2AgwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGwkYEBNgIIIAAgATYCBCAAQZOAgIB4NgIADB4LIAQtAAEOAhITHAsgBC0AAUECaw4CExQbCyABIAIQlyIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0dIAEgBDYCCCABIAM2AgQgASACNgIAIABBoI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwbCyAIIAEgAigCEBEAACAIQSBqIAgoAgAiAiAIKAIEKAIMEQAAIAJFDRUgCCkDIELA47Xe0v6llSyFIAgpAyhC9c6oqNH+2sykf4WEUEUNFSADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0cIAEgBDYCCCABIAM2AgQgASACNgIAIABBsJOBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwaCyABIAIQliIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0bIAEgBDYCCCABIAM2AgQgASACNgIAIABBsI6BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwZCyABIAIQiyIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0aIAEgBDYCCCABIAM2AgQgASACNgIAIABBwI+BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwYCyABIAIQmSIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0ZIAEgBDYCCCABIAM2AgQgASACNgIAIABBsJCBATYCCCAAIAE2AgQgAEGTgICAeDYCAAwXCyABIAIQmCIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0YIAEgBDYCCCABIAM2AgQgASACNgIAIABBoI6BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwWCyABIAIQjCIhAiADKAIsIQQgAygCKCEDQQxBBBCtNiIBRQ0XIAEgBDYCCCABIAM2AgQgASACNgIAIABBsI2BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwVCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiBSAEKAIMKAIMEQAAAkAgBQRAIAQpAxBC++Ty4bGz7cN8hSAEKQMYQoG3yp62q+3MboWEUA0BC0Hu1oABQSBBkNeAARDLJAALIARBIGokACMAQSBrIgEkACABQQxqIAUoAgwgBSgCECICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEEIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAENgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNGCACIAc2AhAgAiADNgIMIAIgBTYCCCACIAQ2AgQgAiAGNgIAIABBwJKBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADBQLIAhBCGogASACKAIQEQAAIAhBIGogCCgCCCIHIAgoAgwoAgwRAAAgB0UNDyAIKQMgQv/Z66rX2IuM8QCFIAgpAyhCgfTho6r41uqLf4WEUEUNDyMAQTBrIgQkACAEIAc2AgQgBEEYaiEGIwBBIGsiBSQAIAVBDGogBEEEaigCACIJKAIMIAkoAhAiASgCCEEBa0F4cWpBCGogASADENsBIAUoAhQhASAFKAIQIQICfyAFKAIMIgtBk4CAgHhHBEAgBiAFKQIYNwIMIAIMAQsgBiABNgIMIAIhASAJKAIsCyECIAYgATYCCCAGIAI2AgQgBiALNgIAIAVBIGokACAEQRBqIgEgBEEkaigCADYCACAEIAQpAhw3AwgCQAJAAkAgBCgCGCICQZOAgIB4RwRAIAQoAighAyAAIAQpAwg3AgQgACADNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAMAQsgBEEgaiICIAEoAgA2AgAgBCAEKQMINwMYIAMoAiwhBSADKAIoIQNBGEEEEK02IgFFDQEgASAFNgIIIAEgAzYCBCABIAc2AgAgASAEKQMYNwIMIAFBFGogAigCADYCACAAQcCQgQE2AgggACABNgIEIABBk4CAgHg2AgALIARBMGokAAwBC0EEQRgQoz0ACwwTCyMAQSBrIgQkACAEQQhqIAEgAigCEBEAACAEQRBqIAQoAggiBSAEKAIMKAIMEQAAAkAgBQRAIAQpAxBC4//bxtnAsr/aAIUgBCkDGELrqof3kZGQlSSFhFANAQtB7taAAUEgQZDXgAEQyyQACyAEQSBqJAAjAEEgayIBJAAgAUEMaiAFKAIMIAUoAhAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBCABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBDYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDRYgAiAHNgIQIAIgAzYCDCACIAU2AgggAiAENgIEIAIgBjYCACAAQdCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwSCyABIAIQxSIhDSMAQTBrIgQkACAEIA02AgQgBEEYaiEHIwBBMGsiBSQAAkAgBEEEaigCACIBLQAMQSBGBEAgBUEIaiABENw7IAUoAgghBiAFKAIMIQkgBSABQRBqEK8uIAVBFGoiAiAGIAYgCUEDdGogBSgCACAFKAIEEMgiIAUgAzYCLCMAQUBqIgEkACABQZOAgIB4NgIAIAFBOGogAkEYaigCADYCACABQTBqIAJBEGopAgA3AwAgAUEoaiACQQhqKQIANwMAIAEgAikCADcDICABIAE2AjwgAUEUaiELIwBBQGoiAiQAIAJBEGogAUEgaiIGEIcgAkACQAJAIAIoAhAEQCACQSBqIgxBBEEAQQRBEBCgGCACKAIkIQkgAigCIEEBRg0CIAIoAigiCiACKQIQNwIAIApBCGogAkEYaikCADcCACACQQxqIg5BATYCACACIAo2AgggAiAJNgIEIAJBOGogBkEYaikCADcDACACQTBqIAZBEGopAgA3AwAgAkEoaiAGQQhqKQIANwMAIAIgBikCADcDICMAQRBrIgYkACAGIAwQhyAgBigCAARAIAJBBGohCQNAIAkoAggiCiAJKAIARgRAIAkgCkEBQQRBEBDeKAsgCSgCBCAKQQR0aiIPIAYpAgA3AgAgD0EIaiAGQQhqKQIANwIAIAkgCkEBajYCCCAGIAwQhyAgBigCAA0ACwsgBkEQaiQAIAtBCGogDigCADYCACALIAIpAgQ3AgAMAQsgC0EANgIIIAtCgICAgMAANwIACyACQUBrJAAMAQsgCSACKAIoQbi1gAEQ/S8ACwJAIAEoAgBBk4CAgHhHBEAgByABKQIANwIAIAdBEGogAUEQaigCADYCACAHQQhqIAFBCGopAgA3AgAgASgCHCICBEAgASgCGCEGA0AgBhDOKiAGQRBqIQYgAkEBayICDQALCyABQRRqQQRBEBDgHgwBCyAHIAEpAhQ3AgQgB0GTgICAeDYCACAHQQxqIAFBHGooAgA2AgALIAFBQGskACAFQTBqJAAMAQtBpO2AAUEoQZD0gAEQnykACyAEQRBqIgEgBEEkaigCADYCACAEIAQpAhw3AwgCQAJAAkAgBCgCGCICQZOAgIB4RwRAIAQoAighAyAAIAQpAwg3AgQgACADNgIQIAAgAjYCACAAQQxqIAEoAgA2AgAMAQsgBEEgaiICIAEoAgA2AgAgBCAEKQMINwMYIAMoAiwhBSADKAIoIQNBGEEEEK02IgFFDQEgASAEKQMYNwIAIAEgBTYCFCABIAM2AhAgASANNgIMIAFBCGogAigCADYCACAAQaCQgQE2AgggACABNgIEIABBk4CAgHg2AgALIARBMGokAAwBC0EEQRgQoz0ACwwRCyABIAIQxiIhCyMAQTBrIgIkACACIAs2AgQgAkEYaiEFIwBBMGsiASQAAkACQAJAIAJBBGooAgAiCS0ADEEhRgRAIAFBCGogCUEQaiINELAuIAFBEGogASgCCCIHIAEoAgwiCkYEf0EBBSAHLQAAIQQjAEEQayIGJAAgCiAHQQhqIgdHBEAgCiAHa0EDdiEKA0AgBiAHLQAAIgw6AA4gBiAEOgANIAQgDCAGQQ5qLAAAIgQgBkENaiwAACIMSiAEIAxIa8BBAEgbIQQgB0EIaiEHIApBAWsiCg0ACwsgBkEQaiQAIATAQQFqC0Gg84ABEKIaIAEgDRCwLiABKAIAIgQgASgCBCIHRg0CA0AgAUEcaiAJIAQsAAAiBhDZKCIKKAIAIAooAgQiCigCCEEBa0F4cWpBCGogCiADENsBIAEoAhwiCkGTgICAeEcEQCABKQIgIRAgBSABKQIoNwIMIAUgEDcCBCAFIAo2AgAgASgCGCIEBEAgASgCFCEGA0AgBigCAARAIAYQzioLIAZBEGohBiAEQQFrIgQNAAsLIAFBEGpBBEEQEOAeDAULIAEoAhgiCiAGTQ0CIAEoAiQhCiABKAIgIQ0gBEEEaigCACIMKAJEIQ4gDCgCQCEMIAEoAhQgBkEEdGoiBigCAARAIAZBCGoQvCoLIAYgCjYCDCAGIA02AgggBiAONgIEIAYgDDYCACAEQQhqIgQgB0cNAAsMAgtBpO2AAUEoQYj1gAEQnykACyAGIApB+PSAARDDIQALIAUgASkCEDcCBCAFQZOAgIB4NgIAIAUgCS0ADToAECAFQQxqIAFBGGooAgA2AgALIAFBMGokACACQRBqIgEgAkEkaikCADcDACACIAIpAhw3AwgCQCACKAIYIgRBk4CAgHhHBEAgACACKQMINwIEIAAgBDYCACAAQQxqIAEpAwA3AgAMAQsgAkEgaiIEIAEpAwA3AwAgAiACKQMINwMYIAMoAiwhBSADKAIoIQNBHEEEEK02IgFFDRUgASACKQMYNwIAIAEgBTYCGCABIAM2AhQgASALNgIQIAFBCGogBCkDADcCACAAQaCMgQE2AgggACABNgIEIABBk4CAgHg2AgALIAJBMGokAAwQCyABIAIQxyIhByMAQTBrIgEkACABIAc2AgQgAUEYaiEEIwBBIGsiAiQAIAJBDGogAUEEaigCACIJEPMvIgUoAgAgBSgCBCIFKAIIQQFrQXhxakEIaiAFIAMQ2wEgAigCFCEFIAIoAhAhBgJAIAIoAgwiC0GTgICAeEcEQCAEIAIpAhg3AgwgBCAFNgIIIAQgBjYCBCAEIAs2AgAMAQsgAiAFNgIIIAIgBjYCBCACQQxqIAkQ8i0iCSgCACAJKAIEIgkoAghBAWtBeHFqQQhqIAkgAxDbASACKAIUIQkgAigCECELIAIoAgwiCkGTgICAeEcEQCAEIAIpAhg3AgwgBCAJNgIIIAQgCzYCBCAEIAo2AgAgAkEEahC8KgwBCyAEIAk2AhAgBCALNgIMIAQgBTYCCCAEIAY2AgQgBEGTgICAeDYCAAsgAkEgaiQAIAFBEGoiAiABQSRqKQIANwMAIAEgASkCHDcDCAJAIAEoAhgiBEGTgICAeEcEQCAAIAEpAwg3AgQgACAENgIAIABBDGogAikDADcCAAwBCyABQSBqIgQgAikDADcDACABIAEpAwg3AxggAygCLCEFIAMoAighA0EcQQQQrTYiAkUNFCACIAEpAxg3AgAgAiAFNgIYIAIgAzYCFCACIAc2AhAgAkEIaiAEKQMANwIAIABBwJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEwaiQADA8LIAEgAhCfIiEEIwBBMGsiASQAIAEgBDYCBCABQRhqIAFBBGogAxCZGCABQRBqIgIgAUEkaikCADcDACABIAEpAhw3AwgCQCABKAIYIgVBk4CAgHhHBEAgACABKQMINwIEIAAgBTYCACAAQQxqIAIpAwA3AgAMAQsgAUEgaiIFIAIpAwA3AwAgASABKQMINwMYIAMoAiwhBiADKAIoIQNBHEEEEK02IgJFDRMgAiABKQMYNwIAIAIgBjYCGCACIAM2AhQgAiAENgIQIAJBCGogBSkDADcCACAAQZCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBMGokAAwOCyABIAIQtCIhBCMAQTBrIgEkACABIAQ2AgQgAUEYaiABQQRqIAMQmRggAUEQaiICIAFBJGopAgA3AwAgASABKQIcNwMIAkAgASgCGCIFQZOAgIB4RwRAIAAgASkDCDcCBCAAIAU2AgAgAEEMaiACKQMANwIADAELIAFBIGoiBSACKQMANwMAIAEgASkDCDcDGCADKAIsIQYgAygCKCEDQRxBBBCtNiICRQ0SIAIgASkDGDcCACACIAY2AhggAiADNgIUIAIgBDYCECACQQhqIAUpAwA3AgAgAEGAkIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQTBqJAAMDQsgASACELIiIQQjAEEwayIBJAAgASAENgIEIAFBGGogAUEEaiADEJkYIAFBEGoiAiABQSRqKQIANwMAIAEgASkCHDcDCAJAIAEoAhgiBUGTgICAeEcEQCAAIAEpAwg3AgQgACAFNgIAIABBDGogAikDADcCAAwBCyABQSBqIgUgAikDADcDACABIAEpAwg3AxggAygCLCEGIAMoAighA0EcQQQQrTYiAkUNESACIAEpAxg3AgAgAiAGNgIYIAIgAzYCFCACIAQ2AhAgAkEIaiAFKQMANwIAIABBgI+BATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEwaiQADAwLIAEgAhCsIiEEIwBBMGsiASQAIAEgBDYCBCABQRhqIAFBBGogAxCZGCABQRBqIgIgAUEkaikCADcDACABIAEpAhw3AwgCQCABKAIYIgVBk4CAgHhHBEAgACABKQMINwIEIAAgBTYCACAAQQxqIAIpAwA3AgAMAQsgAUEgaiIFIAIpAwA3AwAgASABKQMINwMYIAMoAiwhBiADKAIoIQNBHEEEEK02IgJFDRAgAiABKQMYNwIAIAIgBjYCGCACIAM2AhQgAiAENgIQIAJBCGogBSkDADcCACAAQaCTgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBMGokAAwLCyABIAIQniIhAiADKAIsIQQgAygCKCEFIAMoAiQhBiADKAIgIQNBFEEEEK02IgFFDQ0gASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQaCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMCgsgASACELYiIQIgAygCLCEEIAMoAighBSADKAIkIQYgAygCICEDQRRBBBCtNiIBRQ0MIAEgBjYCECABIAM2AgwgASAENgIIIAEgBTYCBCABIAI2AgAgAEGAkoEBNgIIIAAgATYCBCAAQZOAgIB4NgIADAkLIAEgAhCvIiECIAMoAiwhBCADKAIoIQUgAygCJCEGIAMoAiAhA0EUQQQQrTYiAUUNCyABIAY2AhAgASADNgIMIAEgBDYCCCABIAU2AgQgASACNgIAIABBkI2BATYCCCAAIAE2AgQgAEGTgICAeDYCAAwICyABIAIQuiIhAiADKAIsIQQgAygCKCEFIAMoAiQhBiADKAIgIQNBFEEEEK02IgFFDQogASAGNgIQIAEgAzYCDCABIAQ2AgggASAFNgIEIAEgAjYCACAAQbCSgQE2AgggACABNgIEIABBk4CAgHg2AgAMBwsgASAFEQQAIgQtAABBIkYNBEHwgoEBQShB7IqBARCfKQALIAEgBREEACIELQAAQShGDQJB8IKBAUEoQeCLgQEQnykAC0HoiYEBELI7AAtB+ImBARCyOwALAkACQAJAAkAgBCgCBCIELQAwQQNrDgMBAgMACyAIIARBMGo2AjggCEEBNgIkIAhByIuBATYCICAIQgE3AiwgCEGnBDYCGCAIIAhBFGo2AiggCCAIQThqNgIUIAhBIGpB0IuBARDvLAALIAEgAhCcIiEEIwBBIGsiASQAIAFBDGogBCgCICAEKAIkIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0IIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHgjYEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMBAsgASACEJoiIQQjAEEgayIBJAAgAUEMaiAEKAIgIAQoAiQiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQcgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQeCOgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwDCyABIAIQmyIhBCMAQSBrIgEkACABQQxqIAQoAiAgBCgCJCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNBiACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBgJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAILAkACQAJAAkACQAJAAkACQAJAIAQoAgQiBC0AAEECaw4IAQIDBAUGBwgACyAIIAQ2AjggCEEBNgIkIAhB1IqBATYCICAIQgE3AiwgCEGnBDYCGCAIIAhBFGo2AiggCCAIQThqNgIUIAhBIGpB3IqBARDvLAALIAEgAhDEIiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0MIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHQkIEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMCAsgASACEMEiIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQsgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQfCMgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwHCyABIAIQwCIhBCMAQSBrIgEkACABQQxqIAQoAjwgBCgCQCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNCiACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBoJGBATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAYLIAEgAhDDIiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0JIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEHQkYEBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMBQsgASACEMIiIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQggAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQeCPgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwECyABIAIQvyIhBCMAQSBrIgEkACABQQxqIAQoAjwgBCgCQCICKAIIQQFrQXhxakEIaiACIAMQ2wEgASgCFCEFIAEoAhAhBgJAIAEoAgwiAkGTgICAeEcEQCAAIAEpAhg3AgwgACAFNgIIIAAgBjYCBCAAIAI2AgAMAQsgAygCLCEHIAMoAighA0EUQQQQrTYiAkUNByACIAc2AhAgAiADNgIMIAIgBDYCCCACIAU2AgQgAiAGNgIAIABBwI2BATYCCCAAIAI2AgQgAEGTgICAeDYCAAsgAUEgaiQADAMLIAEgAhC+IiEEIwBBIGsiASQAIAFBDGogBCgCPCAEKAJAIgIoAghBAWtBeHFqQQhqIAIgAxDbASABKAIUIQUgASgCECEGAkAgASgCDCICQZOAgIB4RwRAIAAgASkCGDcCDCAAIAU2AgggACAGNgIEIAAgAjYCAAwBCyADKAIsIQcgAygCKCEDQRRBBBCtNiICRQ0GIAIgBzYCECACIAM2AgwgAiAENgIIIAIgBTYCBCACIAY2AgAgAEGAk4EBNgIIIAAgAjYCBCAAQZOAgIB4NgIACyABQSBqJAAMAgsgASACEL0iIQQjAEEgayIBJAAgAUEMaiAEKAI8IAQoAkAiAigCCEEBa0F4cWpBCGogAiADENsBIAEoAhQhBSABKAIQIQYCQCABKAIMIgJBk4CAgHhHBEAgACABKQIYNwIMIAAgBTYCCCAAIAY2AgQgACACNgIADAELIAMoAiwhByADKAIoIQNBFEEEEK02IgJFDQUgAiAHNgIQIAIgAzYCDCACIAQ2AgggAiAFNgIEIAIgBjYCACAAQaCNgQE2AgggACACNgIEIABBk4CAgHg2AgALIAFBIGokAAwBCyAIIAQ2AhAgCEECNgIkIAhBkIyBATYCICAIQgE3AiwgCEGnBDYCPCAIIAhBOGo2AiggCCAIQRBqNgI4IAhBFGohAyMAQRBrIgEkACAIQSBqIgIoAgwhBAJAAkACQAJAAkACQAJAIAIoAgQOAgABAgsgBA0BQQEhBEEAIQIMAgsgBA0AIAIoAgAiBCgCBCECIAQoAgAhBAwBCyADIAIQmQ4MAQsgAUEEaiACQQBBAUEBEKAYIAEoAgghBSABKAIEQQFGDQEgASgCDCEGIAIEQCAGIAQgAvwKAAALIAMgAjYCCCADIAY2AgQgAyAFNgIACyABQRBqJAAMAQsgBSABKAIMQbiHgQEQ/S8ACyAAQYCAgIB4NgIAIAAgCCkCFDcCBCAAQQxqIAhBHGooAgA2AgALIAhBQGskAA8LQQRBEBCjPQALQQRBDBCjPQALQQRBFBCjPQALQQRBHBCjPQAL1xUBEH8jAEHAB2siAiQAIAJBmANqIAEoAgwiAyABKAIQIgYoAhgRAAAgAigCoAMhBCACKAKcAyEFAkACQAJAIAIoApgDIgdBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAENgIIIAAgBTYCBCAAIAc2AgAMAQsgAiAENgIgIAIgBTYCHAJAAkACQCACQRxqEPUtRQRAIAJBEGogAyAGKAIgEQAAIAIoAhAiBw0CIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRw0BDAULIAIgARCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAgsgAigCoAMiAUEYakGc1NAAKQAANwAAIAFBEGpBlNTQACkAADcAACABQQhqQYzU0AApAAA3AAAgAUGE1NAAKQAANwAAIABBIDYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACKAIUIQUgAkEIaiADIAYoAiQRAAAgAigCCCIMRQRAIAJBmANqQSBBAEEBQQEQoBggAigCnAMhAyACKAKYA0EBRg0DIAIoAqADIgFBGGpBvNTQACkAADcAACABQRBqQbTU0AApAAA3AAAgAUEIakGs1NAAKQAANwAAIAFBpNTQACkAADcAACAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAMAQsgAigCDCEEAkAgAkEcahD0LUEATgRAIARFDQEgDC8BAEUNASACQZgDakEpQQBBAUEBEKAYIAIoApwDIQEgAigCmANBAUYNBSACKAKgAyIDQYjR0ABBKfwKAAAgAEEpNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAILIAJBHGoQ9C0hASACQTs2AowBIAIgATYC0AUgAkECNgKcAyACQZzT0AA2ApgDIAJCATcCpAMgAiACQdAFajYCiAEgAiACQYgBajYCoAMgAEEEaiACQZgDahCZDiAAQQA2AgAMAQsgAkGYA2ogAkEcahD0LUEBakEAQQRBBBCgGCACKAKcAyEDAkACQAJAAkACQAJAAkACQCACKAKYA0EBRwRAIAJBADYCLCACIAIoAqADNgIoIAIgAzYCJAJAIAEtABhFBEAgAkEANgIwDAELQcAAIQYgAkEcahD0LSIDQQN2IANBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0ECyACQgA3AjwgAiAGNgI4IAIgAzYCNCACQcAANgIwCyACQcQAaiIGIAJBHGoiDRDDLUEEQQQQrTYiA0UNAyACQQE2AqADIAIgAzYCnAMgAkEBNgKYAyADIAY2AgBBACEGIAJBiAFqIAJBmANqQQAgDRD0LRDALCAEIAUgBCAFSRsiDUUEQEEAIQRBACEDDAYLIAEvARbBIRBBACEDQQAhBAJAA0ACQAJAAkACQCAMLgEAIgUgEEogBSAQSGtB/wFxDgICAQALIANBAEgNCSACKAIsIgUgAigCJEYEQCACQSRqQdTU0AAQnSgLIAIoAiggBUECdGogAzYCACACIAVBAWo2AiwgBy4BACIIIAEuARQiEUgEQCAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLAkAgAigCMEUNACACKAJAIglBAWoiCkEDdiAKQQdxQQBHaiIFIAIoAjwiBEsEQCAFIARrIQsgAigCNCIPIAVJBEAgAkEwaiAPQQF0IgQgBUHA////A3FBQGsgBSAFQT9xGyIPIAQgD0sbEOgZIAIoAjwhBAsgCwRAIAIoAjggBGpBACAL/AsACyACIAU2AjwLIAIgCjYCQCAIQQFqQf//A3EgEUH//wNxRw0AIAIoAjggCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAACyAGQQFqIQZBACEEDAMLIA4gAyAGaiAEGyEOIANBAWohAyACKAIwRQRAQQEhBAwDCyACKAJAIglBAWoiCkEDdiAKQQdxQQBHaiIFIAIoAjwiBEsEQCAFIARrIQsgAigCNCIIIAVJBEAgAkEwaiAIQQF0IgQgBUHA////A3FBQGsgBSAFQT9xGyIIIAQgCEsbEOgZIAIoAjwhBAsgCwRAIAIoAjggBGpBACAL/AsACyACIAU2AjwLIAIgCjYCQEEBIQQgAigCOCAJQQN2aiIFIAUtAABBASAJQQdxdHI6AAAMAgsgBy4BACABLgEUTg0BIAJBmANqQTtBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRw0DDBALIANBAWohAwsgB0ECaiEHIAxBAmohDCANQQFrIg0NAAsgA0EATg0GQcTR0AAQsjsACyACKAKgAyIDQeTU0ABBO/wKAAAgAEE7NgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAYLIAMgAigCoANBtNHQABD9LwALQZSf0ABBKSACQZgDakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAtBxNTQABCyOwALIAIoAiwiBSACKAIkRgRAIAJBJGpB1NHQABCdKAsgAigCKCAFQQJ0aiADNgIAIAIgBUEBajYCLAJAIAZFBEAgAkHUAmogAkEcahDDLQwBCyAEBEAgAkGIAWpBACAOIAMgBmoQ2BsLIAJBmANqIgQgAkGIAWpBzAH8CgAAIAJB1AJqIAQQ6iwLIAIoAvgCIANGBEAgAkHoBGoiAyACKAIoIAIoAixBAnQQiz0gAkG4A2ogARDEBiACQQA7AfADIAJBADYC7AMgAkEANgLUAyACQQA2AsgDIAJCBDcCsAMgAkIANwKoAyACQoCAgIDAADcCoAMgAkEANgKYAyACIAIoAixBAWs2AsQDIAJB0AVqIgQgAkGYA2oiASADEPojIAEgAkHUAmpBxAD8CgAAIAJB9ARqIAQgARDvJSACKAIwRQ0DIAIgAigCQCIDNgKwBiACIAIoAixBAWsiBDYCtAYgAyAERwRAIAJBADYCmANBACACQbAGaiACQbQGaiABQeTR0AAQrysACyACQZgDaiIBIAJB9ARqIgRB3AD8CgAAIAJB2AVqIAJBOGopAgA3AwAgAiACKQIwNwPQBSACIAM2AuAFIAJBuAZqIgMgAkHQBWoQiBkgBCABIAMQrhYMAwsgAEEEaiEDIwBBEGsiASQAIAFBBGpBKkEAQQFBARCgGCABKAIIIQQCQCABKAIEQQFHBEAgASgCDCIFQczS0ABBKvwKAAAgA0EqNgIIIAMgBTYCBCADIAQ2AgAgAUEQaiQADAELIAQgASgCDEGkxtAAEP0vAAsgAEEANgIAIAJB1AJqEPomIAYNAQsgAkGIAWoQlxcLIAJBxABqEPomIAIoAjAEQCACQTBqEM8vCyACQSRqEOk7DAELIAJBmANqIgEgAkH0BGpB3AD8CgAAIAJBxAZqIgMgARDNHCACQYgHaiIBIAMQrx8gARDmKSEBIABB9NHQADYCCCAAIAE2AgQgAEEINgIAIAZFBEAgAkGIAWoQlxcLIAJBxABqEPomIAJBJGoQ6TsgAigCHCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEcahC7IwwBCyACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNACACQRxqELsjCyACQcAHaiQADwsgAyACKAKgA0GkxtAAEP0vAAsgASACKAKgA0GkxtAAEP0vAAutFgILfwN+IwBBkAhrIgIkAAJAAkACQCABKQMAIg1CAlINACACQcQEaiEGIAJBqAJqIQggAkGQAmohBCACQYgFaiEJIAJB8ARqIQMgAkHgBGpBBHIhBwJAAkACQANAIAEpAxBQBEAgAEIMNwMADAcLIAJB4ARqIAEoAkBBCGogASkDCBDhMCAEIAdBCGopAgA3AwAgAiAHKQIANwOIAiACKALgBCIFQQhHBEAgAigC9AQhASAAIAIpA4gCNwIMIAAgATYCHCAAIAU2AgggAEINNwMAIABBFGogAkGQAmopAwA3AgAMBwsgAkHABGogBCkDADcDACACIAIpA4gCNwO4BCABKAIYIQUgAUEANgIYAkAgBQRAIAIgBUGIAvwKAAAgBUGIAkEIEPg6IAEpAxAhDQwBCyACQeAEaiIKIAJBuARqIAEoAhwgAS0AIBDxEyACKQPoBCINQgRSBEAgAkGIB2oiCyADQQhqKQMANwMAIAJBkAdqIgwgA0EQaikDADcDACACIAMpAwA3A4AHIAIoAuAEIQUgCCAJQegB/AoAACAEQRBqIAwpAwA3AwAgBEEIaiALKQMANwMAIAQgAikDgAc3AwAgAiANNwOIAiAKIAUgASkDEBCOGiACKALgBCIKQQhHBEAgACACKQLkBDcCDCAAQRxqIAJB9ARqKAIANgIAIABBFGogAkHsBGopAgA3AgAgAEINNwMAIAAgCjYCCCACQYgCahD8LAwECyABIAWtIg0gASkDCHw3AwggASABKQMQIA19Ig03AxAgAiACQYgCakGIAvwKAAAMAQsgAkGQB2ogA0EQaikDACINNwMAIAJBiAdqIANBCGopAwAiDjcDACACIAMpAwAiDzcDgAcgAEEYaiANNwMAIABBEGogDjcDACAAIA83AwggAEINNwMADAILIAJB4ARqIAIoAvwBIAIoAvgBIA0QhRkgAigC4AQiBUEIRwRAIAAgAikC5AQ3AgwgAEEcaiACQfQEaigCADYCACAAQRRqIAJB7ARqKQIANwIAIABCDTcDACAAIAU2AgggAhD8LAwCCyABIAIoAvwBIgWtIg0gASkDCHw3AwggASABKQMQIA19NwMQIAIgBTYClAQgAigC9AFBAUYEQCACEPwsIAYgAigCvAQgAigCwAQgAigCuAQoAhARAQAgASkDACINQgJSDQUMAQsLIAJB4ARqIgQgBUEAQQFBARCgGCACKALkBCEDIAIoAuAEQQFGDQEgAkEANgKgBCACIAIoAugENgKcBCACIAM2ApgEIAJB6ARqIAJBwARqKQMANwMAIAIgAikDuAQ3A+AEIAIgDTcD+AQgAiANNwPwBCACQYgCaiAEIAJBmARqENMHAkACQCACAn8gAi0AiAJBBEYEQCACKAKMAgwBCyACKQOIAiINQv8Bg0IEUg0BIA1CIIinCyIDNgKkBCACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBACADIAVHBEAgAkECNgLkBCACQYDMwwA2AuAEIAJCAjcC7AQgAkE7NgKUAiACQTs2AowCIAIgAkGIAmo2AugEIAIgAkGkBGo2ApACIAIgAkGUBGo2AogCIABBDGogAkHgBGoQmQ4gAEINNwMAIABBAjYCCAwCCyACQbAEaiACQaAEaigCADYCACACIAIpApgENwOoBCACQeAEaiIDIAJBiAL8CgAAIAJByARqIgQgAkGoBGoQ5xUgAkGIAmogAyAEIAEtAEQgAUE4akEAIAEoAjgbEK4BIAJBiAdqIgQgAkGYAmopAwA3AwAgAkGQB2oiAyACQaACaikDADcDACACIAIpA5ACNwOAByACKQOIAiINQgxSBEAgAkGwB2ogAkGoAmpB4AD8CgAAIAJBoAdqIAQpAwA3AwAgAkGoB2ogAykDADcDACACIAIpA4AHNwOYByANQglUDQUgDadBCWsiA0ECSQ0FIANBAkcNByABQQA6ACAMBwsgACACKQOABzcDCCAAQg03AwAgAEEYaiADKQMANwMAIABBEGogAkGIB2opAwA3AwAMBwsgAiANNwOIAiAAQQhqIAJBiAJqEIErIABCDTcDACACQewEaiACKALkBCACKALoBCACKALgBCgCEBEBAAsgAkGYBGoQ3jsgAhD8LAwFCyAGIAIoArwEIAIoAsAEIAIoArgEKAIQEQEADAQLIAMgAigC6ARBxMvDABD9LwALIAEgASgCHEEBajYCHAwBCyABQgA3AwACQAJ+IA2nIgVBAXEEQCABKAIYIQMgASkDCAwBCyACQeAEaiABQSBqEOEcIAIoAuAEQQFHDQEgAigC+AQhAyACKQPoBAshDSADQQBIBEAgAEEIahDbJCAAQg03AwAMAwsgAkHgBGogASgCQEEIaiANIAMQzy4gAkGQAmoiAyACQewEaikCADcDACACIAIpAuQENwOIAiACKALgBCIEQQhHBEAgAigC9AQhASAAIAIpA4gCNwIMIAAgATYCHCAAIAQ2AgggAEINNwMAIABBFGogAykDADcCAAwDCyACQcAEaiADKQMAIg03AwAgAiACKQOIAjcDuAQgAkHgBGohBCACKAK8BCEGIAEoAjQaIAVBAXEhBSMAQbACayIDJAAgA0IANwMIIAMgDaciBzYCBCADIAY2AgAgA0EoaiADEI8UIANBGGoiCCADQThqKQMANwMAIANBIGoiCSADQUBrKQMANwMAIAMgAykDMDcDEAJAIAMpAygiDUIEUQRAIAQgAykDEDcDECAEQgQ3AwggBEEgaiAJKQMANwMAIARBGGogCCkDADcDAAwBCyAEQShqIANByABqQegB/AoAACAEQSBqIANBIGopAwA3AwAgBEEYaiADQRhqKQMANwMAIAQgAykDEDcDECAEIA03AwggBCADKQMIPgIACyADQbACaiQAIAIpA+gEIg1CBFIEQCACQQhqIgMgAkH4BGopAwA3AwAgAkEQaiIEIAJBgAVqKQMANwMAIAIgAikD8AQ3AwAgAigC4AQhBiACQYgCaiACQYgFakHoAfwKAAAgAkHYBGogBCkDADcDACACQdAEaiADKQMANwMAIAIgAikDADcDyAQgAkHwBmogAkG4BGogBhDqFCAFRQRAIAEgASgCNEEBajYCNAsgAkHwBGogAkHQBGopAwA3AwAgAkH4BGogAkHYBGopAwA3AwAgAiANNwPgBCACIAIpA8gENwPoBCACQYAFaiACQYgCakHoAfwKAAAgAiACQeAEaiACQfAGaiABLQBEIAFBOGpBACABKAI4GxCuASACQYgHaiIDIAJBEGopAwA3AwAgAkGQB2oiBCACQRhqKQMANwMAIAIgAikDCDcDgAcgAkHEBGohASACKQMAIg1CDFEEQCAAIAIpA4AHNwMIIABCDTcDACAAQRhqIAQpAwA3AwAgAEEQaiADKQMANwMAIAEgAigCvAQgAigCwAQgAigCuAQoAhARAQAMBAsgAkGwB2ogAkEgakHgAPwKAAAgAkGgB2ogAkGIB2opAwA3AwAgAkGoB2ogAkGQB2opAwA3AwAgAiACKQOABzcDmAcgASACKAK8BCACKALABCACKAK4BCgCEBEBAAwCCyACQRBqIAJBgAVqKQMAIg03AwAgAkEIaiACQfgEaikDACIONwMAIAIgAikD8AQiDzcDACAAQRhqIA03AwAgAEEQaiAONwMAIAAgDzcDCCAAQg03AwAgAkHEBGogBiAHIAIoArgEKAIQEQEADAILIABCDDcDAAwBCyAAIA03AwAgAEEIaiACQZgHakH4APwKAAALIAJBkAhqJAAL0BICA38SfiMAQfADayIGJAAgBiAENwOIAyAGIAM3A4ADIAYgAjcD+AIgBiABNwPwAiAGIAU2ApwDIAACfwJAIAVFBEAgBkGgA2pCAUIAELIuIAYpA7gDIQogBikDsAMhDCAGKQOoAyELIAYpA6ADIRMMAQsgBkGgA2pCAUIAELIuIAYpA7gDIQ4gBikDsAMhDSAGKQOoAyEJIAYpA6ADIRECQCAFQQFHBEADQAJ+AkACQCAFQQFxRQRAIAEgA4QhECACIASEIRIgDSEMIA4hCiARIQsgCSEPDAELQgAhDCABIAOEIhAgAiAEhCIShFAEQEIAIQpCACELQgAhDwwBC0IAIQpCACELQgAhDyANIBGEIAkgDoSEUA0AIA5CP4ciCiANhSIMIA5CP4h8Ig0gCiARhSIPIApUIgcgCSAKhSIQIApUIAlQG60iCX0hCyAMIA1WrSAKIA6FfCAJIA1WrX0hDCAEQj+HIgkgA4UiESAEQj+IfCINIAEgCYUiASAJVCIIIAIgCYUiAyAJVCACUButIgJ9IhIgDSARVK0gBCAJhXwiESACIA1WrX0iFIRQRSALIAyEQgBScQ0FIAZB4AJqIA8gCn0iAkIAIAEgCX0iD0IAEKgeIAZBwAJqIBAgCn0gB619IgpCACAPQgAQqB4gBkHQAmogAkIAIAMgCX0gCK19IhBCABCoHiAGQbACaiAKQgAgEEIAEKgeIAZBgAJqIAxCACAPQgAQqB4gBkGQAmogEEIAIAtCABCoHiAGQaACaiALQgAgD0IAEKgeIAxCAFIgEEIAUnEgBikDiAJCAFJyIAYpA5gCQgBSciAGKQOoAiILIAYpA4ACIAYpA5ACfHwiDyALVHINBSAGKQPAAiEMIAYpA+gCIQsgBikDyAIgBikDsAIhFSAGKQO4AiEWIAYpA9ACIRcgBikD2AIhGCAGKQOgAiEZIAYpA+ACIRogBkHQAWogCkIAIBJCABCoHiAGQeABaiAUQgAgAkIAEKgeIAZB8AFqIAJCACASQgAQqB4gCkIAUiAUQgBScSAGKQPYAUIAUnIgBikD6AFCAFJyIAYpA/gBIgIgBikD0AEgBikD4AF8fCISIAJUcg0FIAsgDHwiAiALVK18IhAgFXwiCiAYIAIgF3wiCyACVK18fCICIBl8IgwgAlQiByAHrSACIApUrSAWIAogEFStfHwiCiAPfHwiAiAKVCACIApRGw0FIAwgDCAGKQPwAXwiDFYiByAHrSACIBJ8fCIKIAJUIAIgClEbDQUgCiAEIA6FIgRCP4ciAoUgAn0gAiAMhSIOIAJUrX0gDiACfSIOIAIgGoUiECACVCIHIAIgC4UiDyACVCALUButIgtUrX0iCiAEhUIAUw0FIA4gC30hDCAPIAJ9IAetfSEPIBAgAn0hCwwBCyAQIBKEUARAQgAhAyALIREgDyEJIAwhDSAKIQ5CACEEQgAhAkIADAILIARCP4ciCSAEhSADIAmFIgMgBEI/iHwiDSADVK18IREgAiAJhSEDIAEgCYUhAQsgDSABIAlUIgcgAyAJVCADIAlRG62FIBGEQgBSDQMgBkHAAWogASAJfSIBQgAgAUIAEKgeIAZBsAFqIAFCACADIAl9IAetfSIBQgAQqB4gBkGgAWogAUIAIAFCABCoHiAGKQOoASAGKQO4ASIEIAYpA8gBIgIgBikDsAEiCXwiASACVK18IgIgBikDoAF8IgMgAlStfCADIAMgBCABIAl8IgIgAVStfHwiA1atfCIEQgBTDQMgCyERIA8hCSAMIQ0gCiEOIAYpA8ABQn2DCyEBIAVBA0sgBUEBdiEFDQALCyANIBGEIAkgDoSEUARAQgAhC0IAIQxCACEKDAILQgAhC0IAIQxCACEKIAEgA4QgAiAEhIRQDQEgAyAEQj+HIgOFIgsgBEI/iHwiCiABIAOFIgwgA1QiBSACIAOFIg8gA1QgAlAbrSIBfSECIAogC1StIAMgBIV8IAEgClatfSEKIA5CP4ciASANhSITIA5CP4h8Ig0gASARhSIQIAFUIgcgASAJhSISIAFUIAlQG60iCX0iCyANIBNUrSABIA6FfCAJIA1WrX0iEYRQRSACIAqEQgBScQ0AIAZBkAFqIAwgA30iCUIAIBAgAX0iDUIAEKgeIAZB8ABqIAlCACASIAF9IAetfSIBQgAQqB4gBkGAAWogDyADfSAFrX0iA0IAIA1CABCoHiAGQeAAaiADQgAgAUIAEKgeIAZBMGogEUIAIAlCABCoHiAGQUBrIANCACALQgAQqB4gBkHQAGogC0IAIAlCABCoHiARQgBSIANCAFJxIAYpAzhCAFJyIAYpA0hCAFJyIAYpA1giAyAGKQMwIAYpA0B8fCILIANUcg0AIAYpA3AhCSAGKQOYASEDIAYpA3ggBikDYCEMIAYpA2ghDyAGKQOAASETIAYpA4gBIRAgBikDUCESIAYpA5ABIRQgBiABQgAgAkIAEKgeIAZBEGogCkIAIA1CABCoHiAGQSBqIA1CACACQgAQqB4gAUIAUiAKQgBScSAGKQMIQgBSciAGKQMYQgBSciAGKQMoIgEgBikDACAGKQMQfHwiDSABVHINACADIAl8IgEgA1StfCIKIAx8IgIgECABIBN8IgMgAVStfHwiASASfCIJIAFUIgUgBa0gASACVK0gDyACIApUrXx8IgIgC3x8IgEgAlQgASACURsNACAJIAkgBikDIHwiCVYiBSAFrSABIA18fCICIAFUIAEgAlEbDQAgAiAEIA6FIgRCP4ciAYUgAX0gASAJhSICIAFUrX0gAiABfSICIAEgFIUiCSABVCIFIAEgA4UiDiABVCADUButIgNUrX0iCiAEhUIAUw0AIAIgA30hDCAOIAF9IAWtfSELIAkgAX0hEwwBCyAGQQI2AqQDIAZB8Mj/ADYCoAMgBkICNwKsAyAGQcINNgLsAyAGQYMMNgLkAyAGIAZB4ANqNgKoAyAGIAZBnANqNgLoAyAGIAZB8AJqNgLgAyAGQdADaiAGQaADahCZDiAGQYiAgIB4NgLMAyAAIAYpAswDNwIEIABBDGogBkHUA2opAgA3AgAgAEEUaiAGQdwDaigCADYCAEEBDAELIAAgDDcDICAAIBM3AxAgACAKNwMoIAAgCzcDGEEACzYCACAGQfADaiQAC9ASAgN/En4jAEHwA2siBiQAIAYgBDcDiAMgBiADNwOAAyAGIAI3A/gCIAYgATcD8AIgBiAFNgKcAyAAAn8CQCAFRQRAIAZBoANqQgFCABCyLiAGKQO4AyEKIAYpA7ADIQwgBikDqAMhCyAGKQOgAyETDAELIAZBoANqQgFCABCyLiAGKQO4AyEOIAYpA7ADIQ0gBikDqAMhCSAGKQOgAyERAkAgBUEBRwRAA0ACfgJAAkAgBUEBcUUEQCABIAOEIRAgAiAEhCESIA0hDCAOIQogESELIAkhDwwBC0IAIQwgASADhCIQIAIgBIQiEoRQBEBCACEKQgAhC0IAIQ8MAQtCACEKQgAhC0IAIQ8gDSARhCAJIA6EhFANACAOQj+HIgogDYUiDCAOQj+IfCINIAogEYUiDyAKVCIHIAkgCoUiECAKVCAJUButIgl9IQsgDCANVq0gCiAOhXwgCSANVq19IQwgBEI/hyIJIAOFIhEgBEI/iHwiDSABIAmFIgEgCVQiCCACIAmFIgMgCVQgAlAbrSICfSISIA0gEVStIAQgCYV8IhEgAiANVq19IhSEUEUgCyAMhEIAUnENBSAGQeACaiAPIAp9IgJCACABIAl9Ig9CABCoHiAGQcACaiAQIAp9IAetfSIKQgAgD0IAEKgeIAZB0AJqIAJCACADIAl9IAitfSIQQgAQqB4gBkGwAmogCkIAIBBCABCoHiAGQYACaiAMQgAgD0IAEKgeIAZBkAJqIBBCACALQgAQqB4gBkGgAmogC0IAIA9CABCoHiAMQgBSIBBCAFJxIAYpA4gCQgBSciAGKQOYAkIAUnIgBikDqAIiCyAGKQOAAiAGKQOQAnx8Ig8gC1RyDQUgBikDwAIhDCAGKQPoAiELIAYpA8gCIAYpA7ACIRUgBikDuAIhFiAGKQPQAiEXIAYpA9gCIRggBikDoAIhGSAGKQPgAiEaIAZB0AFqIApCACASQgAQqB4gBkHgAWogFEIAIAJCABCoHiAGQfABaiACQgAgEkIAEKgeIApCAFIgFEIAUnEgBikD2AFCAFJyIAYpA+gBQgBSciAGKQP4ASICIAYpA9ABIAYpA+ABfHwiEiACVHINBSALIAx8IgIgC1StfCIQIBV8IgogGCACIBd8IgsgAlStfHwiAiAZfCIMIAJUIgcgB60gAiAKVK0gFiAKIBBUrXx8IgogD3x8IgIgClQgAiAKURsNBSAMIAwgBikD8AF8IgxWIgcgB60gAiASfHwiCiACVCACIApRGw0FIAogBCAOhSIEQj+HIgKFIAJ9IAIgDIUiDiACVK19IA4gAn0iDiACIBqFIhAgAlQiByACIAuFIg8gAlQgC1AbrSILVK19IgogBIVCAFMNBSAOIAt9IQwgDyACfSAHrX0hDyAQIAJ9IQsMAQsgECAShFAEQEIAIQMgCyERIA8hCSAMIQ0gCiEOQgAhBEIAIQJCAAwCCyAEQj+HIgkgBIUgAyAJhSIDIARCP4h8Ig0gA1StfCERIAIgCYUhAyABIAmFIQELIA0gASAJVCIHIAMgCVQgAyAJURuthSARhEIAUg0DIAZBwAFqIAEgCX0iAUIAIAFCABCoHiAGQbABaiABQgAgAyAJfSAHrX0iAUIAEKgeIAZBoAFqIAFCACABQgAQqB4gBikDqAEgBikDuAEiBCAGKQPIASICIAYpA7ABIgl8IgEgAlStfCICIAYpA6ABfCIDIAJUrXwgAyADIAQgASAJfCICIAFUrXx8IgNWrXwiBEIAUw0DIAshESAPIQkgDCENIAohDiAGKQPAAUJ9gwshASAFQQNLIAVBAXYhBQ0ACwsgDSARhCAJIA6EhFAEQEIAIQtCACEMQgAhCgwCC0IAIQtCACEMQgAhCiABIAOEIAIgBISEUA0BIAMgBEI/hyIDhSILIARCP4h8IgogASADhSIMIANUIgUgAiADhSIPIANUIAJQG60iAX0hAiAKIAtUrSADIASFfCABIApWrX0hCiAOQj+HIgEgDYUiEyAOQj+IfCINIAEgEYUiECABVCIHIAEgCYUiEiABVCAJUButIgl9IgsgDSATVK0gASAOhXwgCSANVq19IhGEUEUgAiAKhEIAUnENACAGQZABaiAMIAN9IglCACAQIAF9Ig1CABCoHiAGQfAAaiAJQgAgEiABfSAHrX0iAUIAEKgeIAZBgAFqIA8gA30gBa19IgNCACANQgAQqB4gBkHgAGogA0IAIAFCABCoHiAGQTBqIBFCACAJQgAQqB4gBkFAayADQgAgC0IAEKgeIAZB0ABqIAtCACAJQgAQqB4gEUIAUiADQgBScSAGKQM4QgBSciAGKQNIQgBSciAGKQNYIgMgBikDMCAGKQNAfHwiCyADVHINACAGKQNwIQkgBikDmAEhAyAGKQN4IAYpA2AhDCAGKQNoIQ8gBikDgAEhEyAGKQOIASEQIAYpA1AhEiAGKQOQASEUIAYgAUIAIAJCABCoHiAGQRBqIApCACANQgAQqB4gBkEgaiANQgAgAkIAEKgeIAFCAFIgCkIAUnEgBikDCEIAUnIgBikDGEIAUnIgBikDKCIBIAYpAwAgBikDEHx8Ig0gAVRyDQAgAyAJfCIBIANUrXwiCiAMfCICIBAgASATfCIDIAFUrXx8IgEgEnwiCSABVCIFIAWtIAEgAlStIA8gAiAKVK18fCICIAt8fCIBIAJUIAEgAlEbDQAgCSAJIAYpAyB8IglWIgUgBa0gASANfHwiAiABVCABIAJRGw0AIAIgBCAOhSIEQj+HIgGFIAF9IAEgCYUiAiABVK19IAIgAX0iAiABIBSFIgkgAVQiBSABIAOFIg4gAVQgA1AbrSIDVK19IgogBIVCAFMNACACIAN9IQwgDiABfSAFrX0hCyAJIAF9IRMMAQsgBkECNgKkAyAGQYiYgAE2AqADIAZCAjcCrAMgBkH6DzYC7AMgBkGDDDYC5AMgBiAGQeADajYCqAMgBiAGQZwDajYC6AMgBiAGQfACajYC4AMgBkHQA2ogBkGgA2oQmQ4gBkGIgICAeDYCzAMgACAGKQLMAzcCBCAAQQxqIAZB1ANqKQIANwIAIABBFGogBkHcA2ooAgA2AgBBAQwBCyAAIAw3AyAgACATNwMQIAAgCjcDKCAAIAs3AxhBAAs2AgAgBkHwA2okAAuBHwIPfwR+IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgYgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIFQQhHBEAgAygCLCEHIAQgAykDCDcCDCAEIAc2AhwgBCAFNgIIIARCAjcDACAEQRRqIAYpAwA3AgAMAwsgA0E4aiAGKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBSABKAKMASIHKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAUgBygCEBEEAAshBiAEIAMpAzA3AzAgASgCoAEhBSABQQA2AqABIAEpAxAhESABQQA2AhAgBCARNwMQIAEpAyAhESABQQA2AiAgBCARNwMgIAEpAwAhESABQgA3AwAgBCABKQMINwMIIAQgETcDACAEQRhqIAFBGGopAwA3AwAgBEEoaiABQShqKQMANwMAIARBOGogA0E4aikDADcDACAEIAY6AEQgBCAFNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwAiEjcDACACQSBqIAJB8ANqKQMANwMAIAIgETcDCCACIAIpA+ADNwMQIAEoAugEIgMuARohCCADLgEYIQYgASABKQO4AyIUIAEpA7ACfDcDsAIgAUGoAWogAUG4A2ohDAJ/AkAgEqdBAXEEQCACKAIoQQFxDQELIAJCAjcDUEEADAELIAIoAiQhAyACKQIcIRICQCABKALoAUEBRgRAIAEpAuwBIBJVIAEoAvQBIgQgA0ogAyAERhtBAUcNAQsgASADNgL0ASABIBI3AuwBIAFBATYC6AELIAIoAjQhBCACKQIsIRMCQCABKAL4AUEBRgRAIBMgASkC/AFVIAQgASgChAIiBUogBCAFRhtBAUcNAQsgASAENgKEAiABIBM3AvwBIAFBATYC+AELIAEtAP4EQQJHBEAgAkICNwNQQQAMAQsgAkGBAjYCkAEgAiAENgKMASACIBM3AoQBIAJBATYCgAEgAiADNgJ8IAIgEjcCdCACQQE2AnAgAiAUNwNoIAJCATcDYCACQgA3A1AgAkHQAGoLIQQgAikDECESIwBBQGoiAyQAIAEtALQDIQUCQAJAAkACQAJAAkACQAJAAkACQCABNQLcAyITIAEpA7gDUgRAIAVBAXFFDQcgBEUNBCAEKAIgRQ0CIAQoAjBFDQMgBEEkaiEFIARBNGohByABKAKoBEUNBiABLQD8BA0BDAULIAVBAXFFDQYgA0EANgIoIANCgICAgBA3AiAgA0EANgI4IANCgICAgBA3AjAgAUHoAmpBASADQSBqIANBMGogExCVFAwGCwJAAkAgASgCtAQiCiAEKAIsIglGBEAgASkCrAQgBSkCAFcNAQwCCyAJIApIDQELIAEoAsAEIgogBCgCPCIJRgRAIAEpA7gEIAcpAgBXDQUMAQsgCSAKTg0ECyABQQA6APwEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgC0AwwCCyABLQD9BEUNAAJAAkAgBCgCLCIKIAEoArQEIglGBEAgBSkCACABKQKsBFcNAQwCCyAJIApIDQELIAQoAjwiCiABKALABCIJRgRAIAcpAgAgASkDuARXDQIMAQsgCSAKTg0BCyABQQA6AP0ECyABQegCaiEKIANBEGoiCSAFQQhqKAIANgIAIANBHGogB0EIaigCADYCACABQQE2AqgEIAEgBSkCACITNwKsBCADIAcpAgA3AhQgAUG0BGogCSkDADcCACABQbwEaiADQRhqKQMANwIAIAMgEzcDCCABEOofBEAgA0EgaiIJIAEgASgC7AQiCygCOCALKAI8IAVBDBCfDSADQTBqIgUgASABKALsBCILKAI4IAsoAjwgB0EMEJsMIApBACAJIAUgASkDuAMQlRQMAQsgA0EwaiIJQQxBAEEBQQEQoBggAygCNCELIAMoAjBBAUYNASADKAI4Ig1BCGogBUEIaigAADYAACANIAUpAAA3AAAgA0EMNgIoIAMgDTYCJCADIAs2AiAgCUEMQQBBAUEBEKAYIAMoAjQhBSADKAIwQQFGDQIgAygCOCILQQhqIAdBCGooAAA2AAAgCyAHKQAANwAAIANBDDYCOCADIAs2AjQgAyAFNgIwIApBACADQSBqIAkgASkDuAMQlRQLIAFB6AJqIAFBwANqIAFBzANqEJYTIAEoAugDQYCAgIB4RwRAIAFB4ANqIgUgATUC3AMQpicgBSARIBIQ1xkLIANBQGskAAwCCyALIAMoAjhBwPXOABD9LwALIAUgAygCOEHA9c4AEP0vAAsgDBD1JiACKAIIQQFGBEAgAikDECERIAECfiABKALYAUEBRgRAIAEpA+ABDAELIAFCATcD2AFCAAsgEXw3A+ABCyACKQNQIREgAkHgA2oiAyACQdgAakHAAPwKAAACQAJAIBFCAlENACABKALsBEEIaiABKALoBEEIahCrEkUNACACQegCaiADQcAA/AoAACACIBE3A+ACIAJCAzcD2AIgAkGYAWogASACQdgCahDqBgwBCyACQgg3A5gBCwJAAkACQAJ+An8CQAJAAkACQAJAAkACQCABKALsBC0AnQFBAUYEQEEAIQMgAkEANgLIAiACQoCAgIAQNwLAAkEAIQQgCEEASg0BDAMLIAJCgICAgBA3AsACIAJBADYCyAIgCEEATA0BIAEoAuAEIQUgAkHgA2oiAyAIIAEoAuQEIgQQqw0gAyAFIAQQrgkgAkHYAmoiBSADQYAB/AoAACACQcwCaiIDIAUQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwwBCyABKALgBCEFIAJB4ANqIgQgCCABKALkBCIHEO0WIAQgBSAHEK4JIAJB2AJqIgUgBEGAAfwKAAAgAkHMAmoiByAFENAQIAJBwAJqIAIoAtACIAIoAtQCIgQQoTYgBxDeOwwBCyAGQQBKBEAgASgC1AQhBSACQeADaiIDIAYgASgC2AQiBxCrDSADIAUgBxCuCSACQdgCaiIFIANBgAH8CgAAIAJBzAJqIgMgBRDQECACQcACaiACKALQAiACKALUAhChNiADEN47CyACQcACaiIHIAIoAjwgAigCQBChNiACKALIAiEFAkAgASgCoARFDQAgAkHYAmoiCCAFQQBBAUEBEKAYIAIoAtwCIQMgAigC2AJBAUcEQCACQQA2AugDIAIgAigC4AI2AuQDIAIgAzYC4AMgCCABKAKgBCACKALEAiACKALIAiACQeADaiIDIAEoAqQEKAIMEQcAIAIoAtgCIghBCEcEQCAAIAIpAtwCNwIEIABBFGogAkHsAmooAgA2AgAgAEEMaiACQeQCaikCADcCACAAIAg2AgAgAxDeOyAHEN47DAQLIAJB4AJqIgMgAkHoA2ooAgA2AgAgAiACKQLgAzcD2AIgAkHAAmoQ3jsgAkHIAmogAygCADYCACACIAIpA9gCNwPAAgwBCyADIAIoAuACQdiCzwAQ/S8ACyACQegDaiACQcgCaigCADYCACACIAIpA8ACNwPgAyACQdgCaiACQeADahDnFSABKALYAyEHIAItAEwhAyACQfABaiACQZgBakHQAPwKAAAgAigC5AIhCCACKALgAiEKIAIpA9gCIRFCCSESQQIhCUECIQsgAikD6AEMBgsgBkEASgRAIAEoAtQEIQUgAkHgA2oiAyAGIAEoAtgEIgYQ7RYgAyAFIAYQrgkgAkHYAmoiBiADQYAB/AoAACACQcwCaiIFIAYQ0BAgAkHAAmogAigC0AIgAigC1AIiAxChNiAFEN47CyACKAJAIgYgAyAEamohBSABKAKgBCIIRQ0BIAIoAsgCIQcgAkHYAmogCCACKAI8IAYgAkHAAmoiBiABKAKkBCgCDBEHACACKALYAiIIQQhGDQIgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAYQ3jsLIAJBmAFqEKwpDAULIAJBwAJqIAIoAjwgBhChNgwBC0EBIAUgAigCyAIgB2tLDQEaIAJBwAJqIgYgBxD0NCAGIAIoAjwgAigCQBChNgtBAAshBiACQegDaiACQcgCaigCADYCACACIAIpAsACNwPgAyACQdgCaiACQeADahDnFSABKALcAyEHIAEoArgDIQggASgC2AMhCiACLQBMIQ4gAikDmAEhEiACQfABaiACQaABakHQAPwKAAAgA0EYdiEPIANBEHYhCSADQQh2IQsgAikD4AIhESACKQPYAgshEyABKAJ4QYCAgIB4Rw0BIAIgEjcD2AIgAkHgAmogAkHwAWpB0AD8CgAAIAIgBTYC2AMgAiAOOgDVAyACIAY6ANQDIAIgBDYC0AMgAiAPOgDPAyACIAk6AM4DIAIgCzoAzQMgAiADOgDMAyACIAc2AsgDIAIgCDYCxAMgAiAKNgLAAyACIBE3A7gDIAIgEzcDsAMgAkHgA2ogASACQdgCahCnCiACKALgAyIDQQhGDQIgACACKQLkAzcCBCAAQRRqIAJB9ANqKAIANgIAIABBDGogAkHsA2opAgA3AgAgACADNgIACyACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAwCCyACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAU2AtgDIAIgDjoA1QMgAiAGOgDUAyACIAQ2AtADIAIgDzoAzwMgAiAJOgDOAyACIAs6AM0DIAIgAzoAzAMgAiAHNgLIAyACIAg2AsQDIAIgCjYCwAMgAiARNwO4AyACIBM3A7ADIAFB2AJqIAJB2AJqEOogCyABQQA2AuQEIAFBADYC2AQgASABKQOQAiABNQLcA3w3A5ACIAwQ6SAgAEEINgIAIAJBxABqIAIoAjwgAigCQCACKAI4KAIQEQEACyACQeAEaiQAC7QUARJ/IwBBoAdrIgIkACACQZgDaiABKAIMIAEoAhAoAhgRAAAgAigCoAMhBSACKAKcAyEEAkACQAJAIAIoApgDIgNBCEcEQCAAIAIpAqQDNwIMIABBFGogAkGsA2ooAgA2AgAgACAFNgIIIAAgBDYCBCAAIAM2AgAMAQsgAiAFNgIkIAIgBDYCIAJAAkACQAJAIAJBIGoQ9S1FBEAgAkEYaiABKAIMIAEoAhAoAiARAAAgAigCGCINDQIgAkGYA2pBH0EAQQFBARCgGCACKAKcAyEFIAIoApgDQQFHDQEMBgsgAkEIaiABEJQpIAIoAgghASAAIAIoAgw2AgggACABNgIEIABBCDYCAAwCCyACKAKgAyIBQRdqQevLzwApAAA3AAAgAUEQakHky88AKQAANwAAIAFBCGpB3MvPACkAADcAACABQdTLzwApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAU2AgQgAEEANgIADAELIAIoAhwhBiACQRBqIAEoAgwgASgCECgCJBEAACACKAIQIgVFBEAgAkGYA2pBH0EAQQFBARCgGCACKAKcAyEFIAIoApgDQQFGDQQgAigCoAMiAUEXakGKzM8AKQAANwAAIAFBEGpBg8zPACkAADcAACABQQhqQfvLzwApAAA3AAAgAUHzy88AKQAANwAAIABBHzYCDCAAIAE2AgggACAFNgIEIABBADYCAAwBCwJAIAIoAhQiCEUNACAFLwEARQ0AIAJBmANqQSlBAEEBQQEQoBggAigCnAMhASACKAKYA0EBRg0FIAIoAqADIgVB7MnPAEEp/AoAACAAQSk2AgwgACAFNgIIIAAgATYCBCAAQQA2AgAMAQsCQAJAAkACQAJ/AkACQAJAAkACQAJAAkAgAS0AHEUEQCACQQA2AigMAQtBwAAhBCACQSBqEPQtIgNBA3YgA0EHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAJCADcCNCACIAQ2AjAgAiADNgIsIAJBwAA2AigLIAJBPGoiAyACQSBqIgkQwy1BBEEEEK02IgRFDQIgAkEBNgKgAyACIAQ2ApwDIAJBATYCmAMgBCADNgIAIAJBgAFqIAJBmANqQQEgCRD0LRDALCACQQA2AswCIAJBADYC0AIgAUEUaiEJIAggBiAGIAhLGyIRRQRAQQAhCAwGCyACQcgFakEEciEOQQAhCEEAIQQCQAJAA0ACQAJAAkACQAJAIAUuAQAiAyABLgEaIgZKIAMgBkhrQf8BcQ4CAAMBCyACIAIoAswCQQFqNgLMAiACQdACaiEDDAELIAQEQCACKALQAiAJKAIARw0FCyAIQQFqIQggAkEANgLQAiANLgEAIhIgAS4BGEgEQCAEQQFxBEAgAkGAAWpBACAPIAIoAswCENgbCyACQYABaiAJKAIAEIcXIAJBzAJqIQNBACEEIAIoAihFDQEgAS8BGCETIAIoAjgiC0EBaiIMQQN2IAxBB3FBAEdqIgYgAigCNCIHSwRAIAYgB2shCiACKAIsIhAgBkkEQCACQShqIBBBAXQiByAGQcD///8DcUFAayAGIAZBP3EbIhAgByAQSxsQ6BkgAigCNCEHCyAKBEAgAigCMCAHakEAIAr8CwALIAIgBjYCNAsgAiAMNgI4IBJBAWpB//8DcSATRw0BIAIoAjAgC0EDdmoiBiAGLQAAQQEgC0EHcXRyOgAADAELIAJBATYC0AIgAigCKARAIAIoAjgiB0EBaiILQQN2IAtBB3FBAEdqIgYgAigCNCIDSwRAIAYgA2shDCACKAIsIgogBkkEQCACQShqIApBAXQiAyAGQcD///8DcUFAayAGIAZBP3EbIgogAyAKSxsQ6BkgAigCNCEDCyAMBEAgAigCMCADakEAIAz8CwALIAIgBjYCNAsgAiALNgI4IAIoAjAgB0EDdmoiAyADLQAAQQEgB0EHcXRyOgAACyAPIAIoAswCIARBAXEbIQ8gAkHMAmohA0EBIQQLIAMgAygCAEEBajYCAAwBCyANLgEAIAEuARhIDQcLIA1BAmohDSAFQQJqIQUgEUEBayIRDQALIARBAXFFDQcgDw0BIAJB1AJqIAJBIGoQwy1BAQwICyACQQM2ApwDIAJBzMzPADYCmAMgAkICNwKkAyACQTs2AuACIAIgCTYC3AIgAkE7NgLYAiACIAJB1AJqNgKgAyACIAJB0AJqNgLUAiAOIAJBmANqEJkODAULIAJBgAFqIgVBACAPIAIoAswCENgbIAJBmANqIgQgBUHMAfwKAAAgAkHUAmogBBDqLEEADAYLQeCbzwBBKSACQZgDakGsns8AQYyczwAQ1R4AC0HAACADEKM9AAtBBEEEEKM9AAsgAkGYA2pBO0EAQQFBARCgGCACKAKcAyEBIAIoApgDQQFGDQsgAigCoAMiBUHkzM8AQTv8CgAAIAJBOzYC1AUgAiAFNgLQBSACIAE2AswFCyAAIA4pAgA3AgQgAEEUaiAOQRBqKAIANgIAIABBDGogDkEIaikCADcCACAAQQA2AgAMAgsgAkGYA2oiBSACQYABakHMAfwKAAAgAkHUAmogBRDqLEEACyEFIAIoAvgCIgQgCSgCACAIbEYEQCACQbgDaiABEMMGIAJBADsB8AMgAkEANgLsAyACQQA2AtQDIAJBADYCyAMgAiAINgLEAyACQgQ3ArADIAJCADcCqAMgAkKAgICAwAA3AqADIAJBADYCmAMgAkHIBWoiASACQdQCakHEAPwKAAAgAkHsBGoiBCACQZgDaiIDIAEQ7yUgAigCKARAIAJBoAZqIAJBOGooAgA2AgAgAkGYBmogAkEwaikCADcDACACIAIpAig3A5AGIAMgBEHcAPwKAAAgASACQZAGahCIGSAEIAMgARCuFgsgAkGoBmoiASACQewEahDNHCACQewGaiIEIAEQ3BRBPEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIARBNPwKAAAgAEGYys8ANgIIIAAgATYCBCAAQQg2AgAgBQ0DDAYLIAIgBDYC6AQgAkEDNgKcAyACQbzLzwA2ApgDIAJCAjcCpAMgAkE7NgLUBSACQTs2AswFIAIgCTYCyAUgAiACQcgFajYCoAMgAiACQegEajYC0AUgAEEEaiACQZgDahCZDiAAQQA2AgAgAkHUAmoQ9yYgBUUNAwsgAkGAAWoQlhcMAgtBBEE8EKM9AAsgAkGAAWoQlhcMAgsgAkE8ahD3JiACKAIoRQ0AIAJBKGoQzy8LIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0BIAJBIGoQuyMMAQsgAkE8ahD3JiACKAIgIgAgACgCACIAQQFrNgIAIABBAUcNACACQSBqELsjCyACQaAHaiQADwsgBSACKAKgA0Hko88AEP0vAAsgASACKAKgA0Hko88AEP0vAAu/GgIOfwJ+IwBB4AJrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0A7AJBAWsOBAIABAgBCwALIAFBAToA7wIgAUEAOwDtAiABQfgAaiIHIAFB+AD8CgAAIAEgASgCwAIiBDYCyAIgA0EwaiABQbACaigCADYCACABIAEpArQCNwLMAiABQdQCaiABQbwCaigCADYCACABIAEoAsQCNgLYAiADIAEpAqgCNwMoIAEoAtwBQQhqIAQQiC0hDiABKALcAUEIahDXNCIMRQ0DIAwoAggiBEUNAyABKALIAiIGIARPDQEgDCgCBCAGQQxsaiIEKAIIIQwgBCgCBCEIDAMLQdj+wgAQ6CsACyAGIARB/P7CABDDIQALQQEhBgwBCyADQTRqIQQgAUHMAmohDSMAQSBrIgkkAAJAIAcoAlhBgICAgHhGBEAgBEGBgICAeDYCAAwBCyAHKAJgIgZFBEAgBEGBgICAeDYCAAwBCwJAIAcoAlwiBSgCACAFKAIEKAIMEQQAIgsoAgBBgICAgHhHBEAgCUEUaiALEOceDAELIAlBgICAgHg2AhQLIAlBEGogCUEcaigCADYCACAJIAkpAhQ3AwggBSAGQQN0aiELA0AgCUEIaiIGIAUoAgAgBUEEaigCACgCDBEEABCOFyAFQQhqIgUgC0cNAAsgBiANEJEUIwBBMGsiBSQAIAcoAmRBCGoQhTwiDSgCCCEPIAUgDRD7OxCKJkEAIQcgBUEIakEAIAUoAgRBjP/CABCzFQJAAkAgD0UEQCAFQQA2AhwgBUKAgICAwAA3AhQMAQsgBSgCECELAkADQCANIAcQ7BkiCiALTw0BIAUoAgwiECAKQQJ0aiIKIAooAgBBAWo2AgAgDyAHQQFqIgdHDQALQQAhByAFQQA2AhwgBUKAgICAwAA3AhQDQAJAIAYgBxDyJkUNACALIA0gBxDsGSIKSwRAIBAgCkECdGooAgBBAUcNASAFKAIcIgogBSgCFEYEQCAFQRRqQaz/wgAQlygLIAUoAhggCkECdGogBzYCACAFIApBAWo2AhwMAQsgCiALQZz/wgAQwyEACyAPIAdBAWoiB0cNAAsgBSgCHEUNASAFQShqIAVBHGooAgA2AgAgBSAFKQIUNwMgIAQgDSAFQSBqEOgVDAILIAogC0G8/8IAEMMhAAsgBEGBgICAeDYCACAFQRRqEOk7CyAFQQhqEOk7IAVBMGokACAGEIYwCyAJQSBqJAACQCADKAI0QYGAgIB4RwRAIAEgAykCNDcC3AIgAUHkAmogA0E8aigCADYCAAwBCyADQSBqIA4QhjwgAUHcAmogAygCJBD/OgsgA0H4AGoiBCABKALYAiABKALoARCTJCADQccAaiAEQTD8CgAAQcAAQQgQrTYiBARAIARBADoACCAEQoGAgIAQNwMAIARBCWogA0FAayIGQTf8CgAAIAEgBDYC6AIgDikDECERIANBGGogDhCGPCAGIAMoAhwQ/xsgASAMNgKEAiABIAg2AoACIAEgET4CiAIgASADKQJANwLwASABQfgBaiADQcgAaigCADYCACABIAEoAsgCNgKMAiABIAEoAtwBQQhqNgL8ASABIAFB6AJqNgKUAiABIAFB3AJqNgKQAiABKALQASADIAEoAtgCNgJMIANBgICAgHg2AkAgAUGYAmogBiADQShqEOsnIAFBAToA7gJBgICAgHhGDQIgAUEAOgD4AiABIAEpA5ACNwPwAiABIAEoAtQBIgQ2AswDIAEgBCABKALYAUEDdGoiCDYC0ANBACEGDAELQQhBwAAQoz0ACwNAIAZFBEAgBCAIRg0CIAEgBDYC/AIgASAEQQhqNgLMAyABQZgCaiIGEJAjRQRAIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAMBgsgBhCFNiEGIAEoAvwCIgUoAgAgBSgCBCgCDBEEACEFIAFBADoAqAMgASABQdwCajYClAMgASAGNgKMAyABIAU2AogDIAEgAUH4AGo2AoQDIAEgAUHwAWo2AoADIAEgASgC2AI2ApADQQEhBgwBCyADQUBrIgcgAUGAA2oiCSACEM8CAkAgAygCQCIIQQlHBEAgAygCVCEFIAMpAkwhESADKAJIIQYgAygCRCEEIAkQvihCBCESIAhBCEcNBiADIAFB8AJqNgKEASADIAFB5AFqNgKAASADQej+wgA2AnwgAyABQfABajYCeCAHIANB+ABqIAEoAuABIgRBCGpBACAEGyABKAL8AiIEKAIAIAQoAgQoAgwRBAAQlBggAygCSCEGIAMoAkQhBCADKAJAIghBCEcEQCADKAJUIQUgAykCTCERDAcLIAFBADoA7gIgA0GAAWogAUGgAmopAgA3AwAgAyABKQKYAjcDeCADQUBrIANB+ABqIAQgBiABKAL8AiIEKAIAIAQoAgQQrQYgAykCTCERIAMoAkghBiADKAJEIQQgAygCQCIIQQhHBEAgAygCVCEFDAcLIAEgETcDoAIgASAGNgKcAiABIAQ2ApgCIAFBAToA7gIgASgC0AMhCCABKALMAyEEDAELIABCBTcDAEEDDAcLQQAhBgwACwALIANBEGogAUGYAmoiBBCoICADKAIUIAEoAogCIgYgAygCEEEBcRsiBUUEQCABQQA6AO8CIAEpA3ghEiABKAKAASEIIAEoAoQBIQQgASgCiAEhBiABKQKMASERIAEoApQBIQUgA0GIAmogAUGYAWpB2AD8CgAADAMLIAFBADoA7gIgA0HAAWogBEEIaikCADcDACADIAQpAgA3A7gBIANBQGsgA0G4AWogBhCcLCADQZABaiADQdgAaikDADcDACADQZgBaiADQeAAaigCADYCACADIAMpA1A3A4gBIAMgASkDyAE3A3ggAyABKQPAATcDgAEgAUG8A2oiBiADQfgAahDBBSABQQE6AO0CIANBCGoiBCAGEKggIARBBHIgAUGIAmogAygCCEEBcRsoAgAhBCABKALIAQRAIAEgASgCzAEiCCAEIAVraiIFQQAgBSAITRs2AswBCyAERQRAIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAMAgsgASgCwAEEQCABIAEoAsQBIARrNgLEAQsgBhCFNiEEIAFBADoAmAMgAUEANgKEAyABIAQ2AvwCIAEgAUHMAmo2AvgCIAEgAUH4AGo2AvQCIAEgAUHwAWo2AvACIAEgASgC2AI2AoADCyADQUBrIAFB8AJqIgcgAhDPAiADKAJAIghBCUYEQCAAQgU3AwBBBAwECyADKAJUIQUgAykCTCERIAMoAkghBiADKAJEIQQgBxC+KEIEIRIgCEEIRw0AIAFBADoA7QIgA0HIAGogAUHEA2opAgA3AwAgAyABKQK8AzcDQCADQfgAaiIHIANBQGsiBhDvDiADQQE6ALQBIAMgASkDkAI3AqwBIAMgAUHkAWo2AsABIANB6P7CADYCvAEgAyABQfABaiICNgK4ASABKALgASEEIAMgA0GsAWo2AsQBIAYgA0G4AWogBEEIakEAIAQbIAFBzAJqIgkQlBggAygCSCEGIAMoAkQhBCADKAJAIghBCEcEQCADKAJUIQUgAykCTCERIAcQjzAMAQsgA0HIAWogBCAGIANB+ABqEPkUIAFBADoA7wIgASkDeCESIAEoAoABIQggASgChAEhBCABKAKIASEGIAEpAowBIREgASgClAEhBSADQYgCaiABQZgBakHYAPwKAAAgA0HwAWogA0HUAWopAgA3AwAgA0H4AWogA0HcAWopAgA3AwAgA0GAAmogA0HkAWooAgA2AgAgAyADKQLMATcD6AEgAygCyAEhDCABQQA7AO0CIAIQ9yUgAkEEQQQQ4B4gASgC6AIiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB6AJqEIkpCyABQdwCahCGMCAJEIYwIAFBADoA7wIMAgsgAS0A7QIEQCABQbwDahCOMAsgAUEAOgDtAgsgAS0A7gIEQCABQZgCahCOMAsgAUEAOgDuAiABQfABaiICEPclIAJBBEEEEOAeIAEoAugCIgIgAigCACICQQFrNgIAIAJBAUYEQCABQegCahCJKQsgAUHcAmoQhjAgAUHMAmoQhjAgAS0A7wIEQCABQfgAahCPEwsgAUEAOgDvAkGBgICAeCEMCyAAIAU2AhwgACARNwIUIAAgBjYCECAAIAQ2AgwgACAINgIIIAAgEjcDACAAQSBqIANBiAJqQdgA/AoAACAAIAw2AnggACADKQPoATcCfCAAQYQBaiADQfABaikDADcCACAAQYwBaiADQfgBaikDADcCACAAQZQBaiADQYACaigCADYCAEEBCzoA7AIgA0HgAmokAAuXGgIOfwJ+IwBBsAJrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AnAJBAWsOBAIABAgBCwALIAFBAToAnwIgAUEAOwCdAiABQdAAaiIHIAFB0AD8CgAAIAEgASgC8AEiBDYC+AEgA0EoaiABQeABaigCADYCACABIAEpAuQBNwL8ASABQYQCaiABQewBaigCADYCACABIAEoAvQBNgKIAiADIAEpAtgBNwMgIAEoAowBQQhqIAQQiC0hDiABKAKMAUEIahDXNCIMRQ0DIAwoAggiBEUNAyABKAL4ASIGIARPDQEgDCgCBCAGQQxsaiIEKAIIIQwgBCgCBCEIDAMLQdj+wgAQ6CsACyAGIARB/P7CABDDIQALQQEhBgwBCyADQSxqIQQgAUH8AWohDSMAQSBrIgkkAAJAIAcoAjBBgICAgHhGBEAgBEGBgICAeDYCAAwBCyAHKAI4IgZFBEAgBEGBgICAeDYCAAwBCwJAIAcoAjQiBSgCACAFKAIEKAIMEQQAIgsoAgBBgICAgHhHBEAgCUEUaiALEOceDAELIAlBgICAgHg2AhQLIAlBEGogCUEcaigCADYCACAJIAkpAhQ3AwggBSAGQQN0aiELA0AgCUEIaiIGIAUoAgAgBUEEaigCACgCDBEEABCOFyAFQQhqIgUgC0cNAAsgBiANEJEUIwBBMGsiBSQAIAcoAjxBCGoQhTwiDSgCCCEPIAUgDRD7OxCKJkEAIQcgBUEIakEAIAUoAgRBjP/CABCzFQJAAkAgD0UEQCAFQQA2AhwgBUKAgICAwAA3AhQMAQsgBSgCECELAkADQCANIAcQ7BkiCiALTw0BIAUoAgwiECAKQQJ0aiIKIAooAgBBAWo2AgAgDyAHQQFqIgdHDQALQQAhByAFQQA2AhwgBUKAgICAwAA3AhQDQAJAIAYgBxDyJkUNACALIA0gBxDsGSIKSwRAIBAgCkECdGooAgBBAUcNASAFKAIcIgogBSgCFEYEQCAFQRRqQaz/wgAQlygLIAUoAhggCkECdGogBzYCACAFIApBAWo2AhwMAQsgCiALQZz/wgAQwyEACyAPIAdBAWoiB0cNAAsgBSgCHEUNASAFQShqIAVBHGooAgA2AgAgBSAFKQIUNwMgIAQgDSAFQSBqEOgVDAILIAogC0G8/8IAEMMhAAsgBEGBgICAeDYCACAFQRRqEOk7CyAFQQhqEOk7IAVBMGokACAGEIYwCyAJQSBqJAACQCADKAIsQYGAgIB4RwRAIAEgAykCLDcCjAIgAUGUAmogA0E0aigCADYCAAwBCyADQRhqIA4QhjwgAUGMAmogAygCHBD/OgsgA0HwAGoiBCABKAKIAiABKAKYARCTJCADQT9qIARBMPwKAABBwABBCBCtNiIEBEAgBEEAOgAIIARCgYCAgBA3AwAgBEEJaiADQThqIgZBN/wKAAAgASAENgKYAiAOKQMQIREgA0EQaiAOEIY8IAYgAygCFBD/GyABIAw2ArQBIAEgCDYCsAEgASARPgK4ASABIAMpAjg3AqABIAFBqAFqIANBQGsoAgA2AgAgASABKAL4ATYCvAEgASABKAKMAUEIajYCrAEgASABQZgCajYCxAEgASABQYwCajYCwAEgASgCgAEgAyABKAKIAjYCRCADQYCAgIB4NgI4IAFByAFqIAYgA0EgahDrJyABQQE6AJ4CQYCAgIB4Rg0CIAFBADoAqAIgASABKQPAATcDoAIgASABKAKEASIENgL8AiABIAQgASgCiAFBA3RqIgg2AoADQQAhBgwBC0EIQcAAEKM9AAsDQCAGRQRAIAQgCEYNAiABIAQ2AqwCIAEgBEEIajYC/AIgAUHIAWoiBhCQI0UEQCABQQA6AJ8CIAEpA1AhEiABKAJYIQggASgCXCEEIAEoAmAhBiABKQJkIREgASgCbCEFIANBgAJqIAFB8ABqQTD8CgAADAYLIAYQhTYhBiABKAKsAiIFKAIAIAUoAgQoAgwRBAAhBSABQQA6ANgCIAEgAUGMAmo2AsQCIAEgBjYCvAIgASAFNgK4AiABIAFB0ABqNgK0AiABIAFBoAFqNgKwAiABIAEoAogCNgLAAkEBIQYMAQsgA0E4aiIHIAFBsAJqIgkgAhDoAgJAIAMoAjgiCEEJRwRAIAMoAkwhBSADKQJEIREgAygCQCEGIAMoAjwhBCAJEL4oQgIhEiAIQQhHDQYgAyABQaACajYCfCADIAFBlAFqNgJ4IANB6P7CADYCdCADIAFBoAFqNgJwIAcgA0HwAGogASgCkAEiBEEIakEAIAQbIAEoAqwCIgQoAgAgBCgCBCgCDBEEABCUGCADKAJAIQYgAygCPCEEIAMoAjgiCEEIRwRAIAMoAkwhBSADKQJEIREMBwsgAUEAOgCeAiADQfgAaiABQdABaikCADcDACADIAEpAsgBNwNwIANBOGogA0HwAGogBCAGIAEoAqwCIgQoAgAgBCgCBBCtBiADKQJEIREgAygCQCEGIAMoAjwhBCADKAI4IghBCEcEQCADKAJMIQUMBwsgASARNwPQASABIAY2AswBIAEgBDYCyAEgAUEBOgCeAiABKAKAAyEIIAEoAvwCIQQMAQsgAEIDNwMAQQMMBwtBACEGDAALAAsgA0EIaiABQcgBaiIEEKggIAMoAgwgASgCuAEiBiADKAIIQQFxGyIFRQRAIAFBADoAnwIgASkDUCESIAEoAlghCCABKAJcIQQgASgCYCEGIAEpAmQhESABKAJsIQUgA0GAAmogAUHwAGpBMPwKAAAMAwsgAUEAOgCeAiADQbgBaiAEQQhqKQIANwMAIAMgBCkCADcDsAEgA0E4aiADQbABaiAGEJwsIANBiAFqIANB0ABqKQMANwMAIANBkAFqIANB2ABqKAIANgIAIAMgAykDSDcDgAEgAyABKQN4NwNwIAMgASkDcDcDeCABQewCaiIGIANB8ABqEMEFIAFBAToAnQIgAyAGEKggIANBBHIgAUG4AWogAygCAEEBcRsoAgAhBCABKAJ4BEAgASABKAJ8IgggBCAFa2oiBUEAIAUgCE0bNgJ8CyABQfAAaiEHIARFBEAgAUEAOgCfAiABKQNQIRIgASgCWCEIIAEoAlwhBCABKAJgIQYgASkCZCERIAEoAmwhBSADQYACaiAHQTD8CgAADAILIAcoAgAEQCABIAEoAnQgBGs2AnQLIAYQhTYhBCABQQA6AMgCIAFBADYCtAIgASAENgKsAiABIAFB/AFqNgKoAiABIAFB0ABqNgKkAiABIAFBoAFqNgKgAiABIAEoAogCNgKwAgsgA0E4aiABQaACaiIHIAIQ6AIgAygCOCIIQQlGBEAgAEIDNwMAQQQMBAsgAygCTCEFIAMpAkQhESADKAJAIQYgAygCPCEEIAcQvihCAiESIAhBCEcNACABQQA6AJ0CIANBQGsgAUH0AmopAgA3AwAgAyABKQLsAjcDOCADQfAAaiIHIANBOGoiBhDvDiADQQE6AKwBIAMgASkDwAE3AqQBIAMgAUGUAWo2ArgBIANB6P7CADYCtAEgAyABQaABaiICNgKwASABKAKQASEEIAMgA0GkAWo2ArwBIAYgA0GwAWogBEEIakEAIAQbIAFB/AFqIgkQlBggAygCQCEGIAMoAjwhBCADKAI4IghBCEcEQCADKAJMIQUgAykCRCERIAcQjzAMAQsgA0HAAWogBCAGIANB8ABqEPkUIAFBADoAnwIgASkDUCESIAEoAlghCCABKAJcIQQgASgCYCEGIAEpAmQhESABKAJsIQUgA0GAAmogAUHwAGpBMPwKAAAgA0HoAWogA0HMAWopAgA3AwAgA0HwAWogA0HUAWopAgA3AwAgA0H4AWogA0HcAWooAgA2AgAgAyADKQLEATcD4AEgAygCwAEhDCABQQA7AJ0CIAIQ9yUgAkEEQQQQ4B4gASgCmAIiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBmAJqEIkpCyABQYwCahCGMCAJEIYwIAFBADoAnwIMAgsgAS0AnQIEQCABQewCahCOMAsgAUEAOgCdAgsgAS0AngIEQCABQcgBahCOMAsgAUEAOgCeAiABQaABaiICEPclIAJBBEEEEOAeIAEoApgCIgIgAigCACICQQFrNgIAIAJBAUYEQCABQZgCahCJKQsgAUGMAmoQhjAgAUH8AWoQhjAgAS0AnwIEQCABQdAAahDYFQsgAUEAOgCfAkGBgICAeCEMCyAAIAU2AhwgACARNwIUIAAgBjYCECAAIAQ2AgwgACAINgIIIAAgEjcDACAAQSBqIANBgAJqQTD8CgAAIAAgDDYCUCAAIAMpA+ABNwJUIABB3ABqIANB6AFqKQMANwIAIABB5ABqIANB8AFqKQMANwIAIABB7ABqIANB+AFqKAIANgIAQQELOgCcAiADQbACaiQAC4EdAg9/A34jAEHABGsiAiQAIAJBuAJqIQQjAEFAaiIDJAACQAJ/IAEoAmhBgICAgHhHBEAgA0EYaiABQSBqELwKIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIgdBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAc2AgggBEICNwMAIARBFGogBikDADcCAAwDCyADQThqIAYpAwA3AwAgAyADKQMINwMwQQcMAQsgA0EYaiABKAJ4IgcgASgCfCIFKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQcgBCADKQMINwIMIAQgBzYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAcgBSgCEBEEAAshBiAEIAMpAzA3AyAgBCAGOgA0IAEoApABIQYgAUEANgKQASABKQMQIREgAUEANgIQIAEpAxghEiABQQA2AhggASkDACETIAFCADcDACAEIBI3AxggBCARNwMQIAQgASkDCDcDCCAEIBM3AwAgBCAGNgIwIARBKGogA0E4aikDADcDAAsgA0FAayQAIAJByANqIgMgAkHIAmopAwA3AwAgAkHQA2oiBCACQdACaikDADcDACACIAIpA8ACNwPAAwJAIAIpA7gCIhFCAlEEQCAAIAIpA8ADNwMAIABBEGogBCkDADcDACAAQQhqIAMpAwA3AwAMAQsgAkE4aiACQegCaikDADcDACACQTBqIAJB4AJqKQMANwMAIAJBGGoiBiADKQMANwMAIAJBIGogBCkDADcDACACIAIpA9gCNwMoIAIgAikDwAM3AxAgAiARNwMIIAEoArgEIgMuARohCCADLgEYIQcgASABKQOQAiABKQOYA3w3A5ACIAFBmAFqIAFBmANqIQwCQAJAIAYoAgBBAUYEQCACKAIgDQELIAJCAjcDQEEAIQQMAQsgAigCJCEGIAIgAigCHCIENgLAAyACIAY2ArgCAkAgASgC2AFBAUYEQCADQQhqIAFB3AFqIAJBwANqEOwVRQ0BCyABIAQ2AtwBIAFBATYC2AELAkAgASgC4AFBAUYEQCABKAK4BEEIaiACQbgCaiABQeQBahDsFUUNAQsgASAGNgLkASABQQE2AuABCwJ/IAEtAM4EQQJHBEBCAiERQQAMAQsgAkGBAjYCcCACIAY2AmwgAkEBNgJoIAIgBDYCZCACQQE2AmAgAkIBNwNQIAIgDCkDADcDWEIAIREgAkFAawshBCACIBE3A0AgAikDCCERCyACKQMQIRIjAEEgayIDJAAgAS0AlAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1ArwDIhMgASkDmANSBEAgBUEBcUUNByAERQ0EIAQoAiBFDQIgBCgCKEUNAyAEQSRqIQUgBEEsaiEEIAEoAogERQ0GIAFBkARqIQogAUGMBGohCSABLQDMBA0BDAULIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUHIAmpBASADIANBEGogExCVFAwGCyABKAK4BEEIaiAJIAUQ7BVFBEAgASgCuARBCGogCiAEEOwVRQ0ECyABQQA6AMwEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgCUAwwCCyABLQDNBEUNACABKAK4BEEIaiAFIAkQ7BVFBEAgASgCuARBCGogBCAKEOwVRQ0BCyABQQA6AM0ECyABQcgCaiEKIAFBATYCiAQgASAEKAIANgKQBCABIAUoAgA2AowEIAEQ6B8EQCADIAEgASgCvAQiCSgCOCAJKAI8IAVBBBCdDSADQRBqIgUgASABKAK8BCIJKAI4IAkoAjwgBEEEEJkMIApBACADIAUgASkDmAMQlRQMAQsgA0EQaiIJQQRBAEEBQQEQoBggAygCFCELIAMoAhBBAUYNASADKAIYIhAgBSgCADYAACADQQQ2AgggAyAQNgIEIAMgCzYCACAJQQRBAEEBQQEQoBggAygCFCEFIAMoAhBBAUYNAiADKAIYIgsgBCgCADYAACADQQQ2AhggAyALNgIUIAMgBTYCECAKQQAgAyAJIAEpA5gDEJUUCyABQcgCaiABQaADaiABQawDahCWEyABKALIA0GAgICAeEcEQCABQcADaiIEIAE1ArwDEKYnIAQgESASENcZCyADQSBqJAAMAgsgCyADKAIYQcD1zgAQ/S8ACyAFIAMoAhhBwPXOABD9LwALIAwQ9CYgAigCCEEBRgRAIAIpAxAhESABAn4gASgCyAFBAUYEQCABKQPQAQwBCyABQgE3A8gBQgALIBF8NwPQAQsgAikDQCERIAJBwANqIgMgAkHIAGpBMPwKAAACQAJAIBFCAlENACABKAK8BEEIaiABKAK4BEEIahCrEkUNACACQcgCaiADQTD8CgAAIAIgETcDwAIgAkIBNwO4AiACQfgAaiABIAJBuAJqEOcGDAELIAJCCDcDeAsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCvAQtAJ0BQQFGBEBBACEEIAJBADYCqAIgAkKAgICAEDcCoAJBACEGIAhBAEoNAQwDCyACQoCAgIAQNwKgAiACQQA2AqgCIAhBAEwNASABKAKwBCEEIAJBwANqIgMgCCABKAK0BCIGEKsNIAMgBCAGEK4JIAJBuAJqIgQgA0GAAfwKAAAgAkGsAmoiAyAEENAQIAJBoAJqIAIoArACIAIoArQCEKE2IAMQ3jsMAQsgASgCsAQhBiACQcADaiIDIAggASgCtAQiBRDtFiADIAYgBRCuCSACQbgCaiIGIANBgAH8CgAAIAJBrAJqIgMgBhDQECACQaACaiACKAKwAiACKAK0AiIGEKE2IAMQ3jsMAQsgB0EASgRAIAEoAqQEIQQgAkHAA2oiAyAHIAEoAqgEIgUQqw0gAyAEIAUQrgkgAkG4AmoiBCADQYAB/AoAACACQawCaiIDIAQQ0BAgAkGgAmogAigCsAIgAigCtAIQoTYgAxDeOwsgAkGgAmoiBSACKAIsIAIoAjAQoTYgAigCqAIhAwJAIAEoAoAERQ0AIAJBuAJqIgggA0EAQQFBARCgGCACKAK8AiEEIAIoArgCQQFHBEAgAkEANgLIAyACIAIoAsACNgLEAyACIAQ2AsADIAggASgCgAQgAigCpAIgAigCqAIgAkHAA2oiBCABKAKEBCgCDBEHACACKAK4AiIIQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACAINgIAIAQQ3jsgBRDeOwwECyACQcACaiIEIAJByANqKAIANgIAIAIgAikCwAM3A7gCIAJBoAJqEN47IAJBqAJqIAQoAgA2AgAgAiACKQO4AjcDoAIMAQsgBCACKALAAkHYgs8AEP0vAAsgAkHIA2ogAkGoAmooAgA2AgAgAiACKQOgAjcDwAMgAkG4AmogAkHAA2oQ5xUgASgCuAMhBSACLQA8IQQgAkHQAWogAkH4AGpB0AD8CgAAIAIoAsQCIQggAigCwAIhCiACKQPIASERQgkhEkECIQlBAiELIAIpA7gCDAYLIAdBAEoEQCABKAKkBCEEIAJBwANqIgMgByABKAKoBCIHEO0WIAMgBCAHEK4JIAJBuAJqIgQgA0GAAfwKAAAgAkGsAmoiAyAEENAQIAJBoAJqIAIoArACIAIoArQCIgQQoTYgAxDeOwsgAigCMCIHIAQgBmpqIQMgASgCgAQiCEUNASACKAKoAiEFIAJBuAJqIAggAigCLCAHIAJBoAJqIgcgASgChAQoAgwRBwAgAigCuAIiCEEIRg0CIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgCDYCACAHEN47CyACQfgAahCsKQwFCyACQaACaiACKAIsIAcQoTYMAQtBASADIAIoAqgCIAVrSw0BGiACQaACaiIHIAUQ9DQgByACKAIsIAIoAjAQoTYLQQALIQcgAkHIA2ogAkGoAmooAgA2AgAgAiACKQKgAjcDwAMgAkG4AmogAkHAA2oQ5xUgASgCvAMhBSABKAKYAyEIIAEoArgDIQogAi0APCENIAIpA3ghEiACQdABaiACQYABakHQAPwKAAAgBEEYdiEOIARBEHYhCSAEQQh2IQsgAikDuAIhESACKQPAAgshEyABKAJoQYCAgIB4Rw0BIAIgEjcDuAIgAkHAAmogAkHQAWpB0AD8CgAAIAIgAzYCuAMgAiANOgC1AyACIAc6ALQDIAIgBjYCsAMgAiAOOgCvAyACIAk6AK4DIAIgCzoArQMgAiAEOgCsAyACIAU2AqgDIAIgCDYCpAMgAiAKNgKgAyACIBM3A5gDIAIgETcDkAMgAkHAA2ogASACQbgCahCoCiACKALAAyIDQQhGDQIgACACKQLEAzcCBCAAQRRqIAJB1ANqKAIANgIAIABBDGogAkHMA2opAgA3AgAgACADNgIACyACQTRqIAIoAiwgAigCMCACKAIoKAIQEQEADAILIAIgEjcDuAIgAkHAAmogAkHQAWpB0AD8CgAAIAIgAzYCuAMgAiANOgC1AyACIAc6ALQDIAIgBjYCsAMgAiAOOgCvAyACIAk6AK4DIAIgCzoArQMgAiAEOgCsAyACIAU2AqgDIAIgCDYCpAMgAiAKNgKgAyACIBM3A5gDIAIgETcDkAMgAUG4AmogAkG4AmoQ6iALIAFBADYCtAQgAUEANgKoBCABIAEpA/ABIAE1ArwDfDcD8AEgDBDpICAAQQg2AgAgAkE0aiACKAIsIAIoAjAgAigCKCgCEBEBAAsgAkHABGokAAuhFQEKfyMAQeAAayICJAAgASgCFCEEIAIgASgCGCIDQQBBAUEBEKAYIAIoAgQhBQJAAkACQAJAIAIoAgBBAUcEQCACKAIIIQYgAwRAIAYgBCAD/AoAAAsgAS0AKiEKIAEtACghCyABLQAIIgdBEUcEQAJAAkACQCAHQQRrDgUBAgAAAQILIAEtAAkhCCABLQAKIQkMAQsgAkEIaiABQRNqLQAAOgAAIAIgASkACzcDACABLQAKIQkgAS0ACSEICyACQdAAaiACQQhqLQAAOgAAIAIgAikDADcDSAsgAUEUaiEEIAJBH2ogAkHQAGotAAA6AAAgAiAKOgAhIAIgCzoAICACIAM2AhAgAiAGNgIMIAIgBTYCCCACIAk6ABYgAiAIOgAVIAIgBzoAFCACIAIpA0g3ABcgAiABKQIANwIAAkACQAJAAkACQAJAAkAgAS0AKSIDQQdGIAEoAhwiCUEASHFFBEAgAUEqaiEIIAdBEUYNCiACIAFBCGo2AiQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKRQRAAkACQAJAIAdBBGsOBQECAAABAgsgAS0ACSEFIAEtAAohBgwBCyACQThqIAFBE2otAAA6AAAgAiABKQALNwMwIAEtAAohBiABLQAJIQULIAJB0wBqIAJBOGotAAA6AAAgAiAGOgBKIAIgBToASSACIAc6AEggAiACKQMwNwBLIAIgAkHIAGoQmhA6ACEMAQsCQAJAAkAgB0EEaw4FAQIAAAECCyABLQAJIQUgAS0ACiEGDAELIAJBOGogAUETai0AADoAACACIAEpAAs3AzAgAS0ACiEGIAEtAAkhBQsgAkHTAGogAkE4ai0AADoAACACIAY6AEogAiAFOgBJIAIgBzoASCACIAIpAzA3AEsgAkHIAGoQmhBB/wFxIApHDQELIAcODgECAgMNBAUGBwgJChILFQsgAkEENgI0IAJBlLLPADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGoBDYCVCACIAg2AlAgAkGqBDYCTCACIAJByABqNgI4IAIgAkEkajYCSCAAQQxqIAJBMGoQmQ4gAEEBNgIAIABBADYCCAwWCyADQQZGDRQMEwsgAkEDNgJMIAJByK3PADYCSCACQgI3AlQgAkHMATYCPCACIAQ2AjggAkGqBDYCNCACIAJBMGo2AlAgAiACQSRqNgIwIABBDGogAkHIAGoQmQ4gAEEBNgIAIABBADYCCAwUCyADQQZGDRIMEQsgA0EBRg0RDBALIANBAWsOAggJDwsgA0ECRg0PDA4LIANBAWsOAggJDQsgA0EBRg0NDAwLIANBBkYNDAwLCyADQQZHDQoMCwsgA0EHRg0HDAkLIAJBAzYCTCACQfy1zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBnAM2AjQgAiABQRxqNgIwIAIgAkEwajYCUCAAQQxqIAJByABqEJkOIABBATYCACAAQQA2AggMCgsgAiACKAIkIgVBBGo2AiggAiAFQQhqNgIsAkAgASgCDCABKAIkRwRAIAJBBDYCNCACQfyuzwA2AjAgAkIDNwI8IAJBzAE2AlwgAiAENgJYIAJBnAM2AlQgAiABQSRqNgJQIAJBqQg2AkwgAiACQcgAajYCOCACIAJBKGo2AkggAEEMaiACQTBqEKcYQQAhBQwBCyABKAIQIAEoAiBHBEAgAkEENgI0IAJBqK7PADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGcAzYCVCACIAFBIGo2AlAgAkGpCDYCTCACIAJByABqNgI4IAIgAkEsajYCSCAAQQxqIAJBMGoQpxhBACEFDAELIAJByABqIAEQnAggAigCSCIFQQhGDQkgACACKQJMNwIMIABBHGogAkHcAGooAgA2AgAgAEEUaiACQdQAaikCADcCAAsgAEEBNgIAIAAgBTYCCAwJCyABLQAJRQ0HDAYLIAIoAiQtAAENBiACQQI2AkwgAkHUr88ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAcLIAEsAAlBIUgNBQwECyABLQAJQcAARg0EDAMLIANBB0cNAiAJQRBGDQMgAkECNgJMIAJBtLDPADYCSCACQgE3AlQgAkHMATYCNCACIAQ2AjAgAiACQTBqNgJQIABBDGogAkHIAGoQpxggAEEBNgIAIABBADYCCAwECyAJQQJGDQIgAkECNgJMIAJBmLHPADYCSCACQgE3AlQgAkHMATYCNCACIAQ2AjAgAiACQTBqNgJQIABBDGogAkHIAGoQpxggAEEBNgIAIABBADYCCAwDCyAFIAIoAghB5KPPABD9LwALIAIgAigCJDYCLCACIAM6ACggAkEENgI0IAJBwLHPADYCMCACQgM3AjwgAkHMATYCXCACIAQ2AlggAkGxAzYCVCACQaoENgJMIAIgAkHIAGo2AjggAiACQShqNgJQIAIgAkEsajYCSCAAQQxqIAJBMGoQmQ4gAEEBNgIAIABBADYCCAwBCwJAAkACQAJAAkACQAJAAkACQCAKDhcIAQAAAAMEBQUGBgYFBQUGBQUFBgEBAgALIAJBAzYCTCACQby1zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBqAQ2AjQgAiAINgIwIAIgAkEwajYCUCAAQQxqIAJByABqEKcYIABBATYCACAAQQA2AggMCAsgA0EGRw0FDAYLIANBB0YgCUEMRnENBSACQQI2AkwgAkGEtc8ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAYLIANBBkYNBCACQQI2AkwgAkH4ss8ANgJIIAJCATcCVCACQcwBNgI0IAIgBDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCnGCAAQQE2AgAgAEEANgIIDAULIAJByABqIAEQnAggAigCSCIEQQhGDQMgACACKQJMNwIMIABBHGogAkHcAGooAgA2AgAgAEEUaiACQdQAaikCADcCACAAQQE2AgAgACAENgIIDAQLIANBAUYNAiACQQM2AkwgAkHEs88ANgJIIAJCAjcCVCACQcwBNgI8IAIgBDYCOCACQagENgI0IAIgCDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCZDiAAQQE2AgAgAEEANgIIDAMLIANBAkYNASACQQM2AkwgAkGAtM8ANgJIIAJCAjcCVCACQcwBNgI8IAIgBDYCOCACQagENgI0IAIgCDYCMCACIAJBMGo2AlAgAEEMaiACQcgAahCZDiAAQQE2AgAgAEEANgIIDAILIAJBAzYCTCACQZi0zwA2AkggAkICNwJUIAJBzAE2AjwgAiAENgI4IAJBqAQ2AjQgAiAINgIwIAIgAkEwajYCUCAAQQxqIAJByABqEJkOIABBATYCACAAQQA2AggMAQsgAEEEaiACQST8CgAAIAAgAzoANCAAIAk2AiggAEEANgIAIAAgASkCIEIgiTcCLAwBCyACQQhqEN47CyACQeAAaiQAC+McAg5/BH4jAEGgBGsiAiQAIAJBmAJqIQUjAEFAaiIDJAACQAJ/IAEoAlhBgICAgHhHBEAgA0EYaiABQRBqELwKIANBEGoiCiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIgRBCEcEQCADKAIsIQcgBSADKQMINwIMIAUgBzYCHCAFIAQ2AgggBUICNwMAIAVBFGogCikDADcCAAwDCyADQThqIAopAwA3AwAgAyADKQMINwMwQQcMAQsgA0EYaiABKAJoIgQgASgCbCIHKAIcEQAAIANBEGoiCiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQQgBSADKQMINwIMIAUgBDYCHCAFIAg2AgggBUICNwMAIAVBFGogCikDADcCAAwCCyADQThqIAopAwA3AwAgAyADKQMINwMwIAQgBygCEBEEAAshCiAFIAMpAzA3AxAgBSAKOgAmIAEoAoABIQogAUEANgKAASABLwCFASEEIAFBggQ7AIUBIAEpAwAhECABQgA3AwAgBSABKQMINwMIIAUgEDcDACAFIAQ7ASQgBSAKNgIgIAVBGGogA0E4aikDADcDAAsgA0FAayQAIAJBqANqIgMgAkGoAmopAwA3AwAgAkGwA2oiBSACQbACaikDADcDACACIAIpA6ACNwOgA0ICIRECQCACKQOYAiIQQgJRBEAgACACKQOgAzcDACAAQRBqIAUpAwA3AwAgAEEIaiADKQMANwMADAELIAJBGGogAykDADcDACACQSBqIAUpAwA3AwAgAiACKQOgAzcDECACIAIpA7gCIhI3AyggAiAQNwMIIAEoApQEIgMuARohCCADLgEYIQcgASABKQOAAyITIAEpA/ABfDcD8AEgAUGIAWohBSABQYADaiEKQQAhAwJAIBJCIIinIgRB/wFxQQJGDQAgEkIoiKciBkH/AXFBAkYNACABLQCQAiIJQQJHIARBAXMgCXFBAXFFcUUEQCABIAQ6AJACCyABLQCRAiIJQQJHIAYgCUEBc3FBAXFFcUUEQCABIAY6AJECCyABLQCsBEECRw0AIAIgBjoAVSACIAQ6AFQgAkGBAjYCUCACIBM3A0ggAkIBNwNAIAJBMGohA0IAIRELIAIgETcDMCACKQMQIREjAEEgayIEJAAgAS0A/AIhBgJAAkACQAJAAkACQAJAAkACQCABNQKkAyISIAEpA4ADUgRAIAZBAXFFDQcgA0UNBCADLQAkIgZBAkYNAiADLQAlIglBAkYNAyABLQCoBCILQQJGDQYgAS0AqgQNAQwFCyAGQQFxRQ0GIARBADYCCCAEQoCAgIAQNwIAIARBADYCGCAEQoCAgIAQNwIQIAFBsAJqQQEgBCAEQRBqIBIQlRQMBgsgBkEBcUUgC0EBcXFFBEAgCUEBcSABLQCpBEEBR3INBAsgAUEAOgCqBAwDC0HIgM8AELI7AAtB2IDPABCyOwALIAFBADoA/AIMAgsgAS0AqwRFDQAgC0EBcUUgBkEBcXFFBEAgCUEBcUUNASABLQCpBEEBcQ0BCyABQQA6AKsECyABQbACaiELIAEgCToAqQQgASAGOgCoBCABEOYfBEAgBCABIAEoApgEIgYoAjggBigCPCADQSRqQQEQmw0gBEEQaiIGIAEgASgCmAQiCSgCOCAJKAI8IANBJWpBARCXDCALQQAgBCAGIAEpA4ADEJUUDAELIARBEGoiDEEBQQBBAUEBEKAYIAQoAhQhAyAEKAIQQQFGDQEgBCgCGCIPIAY6AAAgBEEBNgIIIAQgDzYCBCAEIAM2AgAgDEEBQQBBAUEBEKAYIAQoAhQhAyAEKAIQQQFGDQEgBCgCGCIGIAk6AAAgBEEBNgIYIAQgBjYCFCAEIAM2AhAgC0EAIAQgDCABKQOAAxCVFAsgAUGwAmogAUGIA2ogAUGUA2oQlhMgASgCsANBgICAgHhHBEAgAUGoA2oiAyABNQKkAxCmJyADIBAgERDXGQsgBEEgaiQADAELIAMgBCgCGEHA9c4AEP0vAAsCQCAKIgMoAhRBgICAgHhGDQAgBSgCfEGAgICAeEYNACAFQfwAaiADQRRqEPsXCwJAIAMoAghBgICAgHhGDQAgBSgCcEGAgICAeEYNACAFQfAAaiADQQhqEPsXCyACKAIIQQFGBEAgAikDECEQIAECfiABKAK4AUEBRgRAIAEpA8ABDAELIAFCATcDuAFCAAsgEHw3A8ABCyACQagDaiIDIAJBQGspAwA3AwAgAkGwA2oiBCACQcgAaikDADcDACACQbgDaiIGIAJB0ABqKQMANwMAIAIgAikDODcDoAMCQAJAIAIpAzAiEEICUQ0AIAEoApgEQQhqIAEoApQEQQhqEKsSRQ0AIAJBwAJqIAYpAwA3AwAgAkG4AmogBCkDADcDACACQbACaiADKQMANwMAIAIgAikDoAM3A6gCIAIgEDcDoAIgAkIANwOYAiACQdgAaiABIAJBmAJqEOkGDAELIAJCCDcDWAsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgCmAQtAJ0BQQFGBEBBACEDIAJBADYCiAIgAkKAgICAEDcCgAJBACEFIAhBAEoNAQwDCyACQoCAgIAQNwKAAiACQQA2AogCIAhBAEwNASABKAKMBCEEIAJBoANqIgMgCCABKAKQBCIFEKsNIAMgBCAFEK4JIAJBmAJqIgQgA0GAAfwKAAAgAkGMAmoiAyAEENAQIAJBgAJqIAIoApACIAIoApQCEKE2IAMQ3jsMAQsgASgCjAQhBCACQaADaiIFIAggASgCkAQiCBDtFiAFIAQgCBCuCSACQZgCaiIEIAVBgAH8CgAAIAJBjAJqIgggBBDQECACQYACaiACKAKQAiACKAKUAiIFEKE2IAgQ3jsMAQsgB0EASgRAIAEoAoAEIQQgAkGgA2oiAyAHIAEoAoQEIggQqw0gAyAEIAgQrgkgAkGYAmoiBCADQYAB/AoAACACQYwCaiIDIAQQ0BAgAkGAAmogAigCkAIgAigClAIQoTYgAxDeOwsgAkGAAmoiCCACKAIcIAIoAiAQoTYgAigCiAIhBAJAIAEoAugDRQ0AIAJBmAJqIgYgBEEAQQFBARCgGCACKAKcAiEDIAIoApgCQQFHBEAgAkEANgKoAyACIAIoAqACNgKkAyACIAM2AqADIAYgASgC6AMgAigChAIgAigCiAIgAkGgA2oiAyABKALsAygCDBEHACACKAKYAiIGQQhHBEAgACACKQKcAjcCBCAAQRRqIAJBrAJqKAIANgIAIABBDGogAkGkAmopAgA3AgAgACAGNgIAIAMQ3jsgCBDeOwwECyACQaACaiIDIAJBqANqKAIANgIAIAIgAikCoAM3A5gCIAJBgAJqEN47IAJBiAJqIAMoAgA2AgAgAiACKQOYAjcDgAIMAQsgAyACKAKgAkHYgs8AEP0vAAsgAkGoA2ogAkGIAmooAgA2AgAgAiACKQOAAjcDoAMgAkGYAmogAkGgA2oQ5xUgASgCoAMhCCACLQAuIQMgAkGwAWogAkHYAGpB0AD8CgAAIAIoAqQCIQYgAigCoAIhCSACKQOYAiEQQQIhC0IJIRFBAiEMIAIpA6gBDAYLIAdBAEoEQCABKAKABCEEIAJBoANqIgMgByABKAKEBCIHEO0WIAMgBCAHEK4JIAJBmAJqIgQgA0GAAfwKAAAgAkGMAmoiByAEENAQIAJBgAJqIAIoApACIAIoApQCIgMQoTYgBxDeOwsgAigCICIHIAMgBWpqIQQgASgC6AMiBkUNASACKAKIAiEIIAJBmAJqIAYgAigCHCAHIAJBgAJqIgcgASgC7AMoAgwRBwAgAigCmAIiBkEIRg0CIAAgAikCnAI3AgQgAEEUaiACQawCaigCADYCACAAQQxqIAJBpAJqKQIANwIAIAAgBjYCACAHEN47CyACQdgAahCsKQwFCyACQYACaiACKAIcIAcQoTYMAQtBASAEIAIoAogCIAhrSw0BGiACQYACaiIHIAgQ9DQgByACKAIcIAIoAiAQoTYLQQALIQcgAkGoA2ogAkGIAmooAgA2AgAgAiACKQKAAjcDoAMgAkGYAmogAkGgA2oQ5xUgASgCpAMhCCABKAKAAyEGIAEoAqADIQkgAi0ALiENIAIpA1ghESACQbABaiACQeAAakHQAPwKAAAgA0EYdiEOIANBEHYhDCADQQh2IQsgAikDoAIhECACKQOYAgshEiABKAJYQYCAgIB4Rw0BIAIgETcDmAIgAkGgAmogAkGwAWpB0AD8CgAAIAIgBDYCmAMgAiANOgCVAyACIAc6AJQDIAIgBTYCkAMgAiAOOgCPAyACIAw6AI4DIAIgCzoAjQMgAiADOgCMAyACIAg2AogDIAIgBjYChAMgAiAJNgKAAyACIBA3A/gCIAIgEjcD8AIgAkGgA2ogASACQZgCahCpCiACKAKgAyIDQQhGDQIgACACKQKkAzcCBCAAQRRqIAJBtANqKAIANgIAIABBDGogAkGsA2opAgA3AgAgACADNgIACyACQSRqIAIoAhwgAigCICACKAIYKAIQEQEADAILIAIgETcDmAIgAkGgAmogAkGwAWpB0AD8CgAAIAIgBDYCmAMgAiANOgCVAyACIAc6AJQDIAIgBTYCkAMgAiAOOgCPAyACIAw6AI4DIAIgCzoAjQMgAiADOgCMAyACIAg2AogDIAIgBjYChAMgAiAJNgKAAyACIBA3A/gCIAIgEjcD8AIgAUGgAmogAkGYAmoQ6iALIAFBADYCkAQgAUEANgKEBCABIAEpA9ABIAE1AqQDfDcD0AEgChDpICAAQQg2AgAgAkEkaiACKAIcIAIoAiAgAigCGCgCEBEBAAsgAkGgBGokAAuFHQIOfwN+IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgcgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIGQQhHBEAgAygCLCEFIAQgAykDCDcCDCAEIAU2AhwgBCAGNgIIIARCAjcDACAEQRRqIAcpAwA3AgAMAwsgA0E4aiAHKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBiABKAKMASIFKAIcEQAAIANBEGoiByADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQYgBCADKQMINwIMIAQgBjYCHCAEIAg2AgggBEICNwMAIARBFGogBykDADcCAAwCCyADQThqIAcpAwA3AwAgAyADKQMINwMwIAYgBSgCEBEEAAshByAEIAMpAzA3AzAgASgCoAEhBiABQQA2AqABIAEpAwAhECABQgA3AwAgASkDECESIAFCADcDECABKQMgIREgAUIANwMgIAQgASkDKDcDKCAEIBE3AyAgBCABKQMYNwMYIAQgEjcDECAEIAEpAwg3AwggBCAQNwMAIARBOGogA0E4aikDADcDACAEIAc6AEQgBCAGNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwA3AwAgAkEgaiACQfADaikDACIQNwMAIAIgAikD4AMiEjcDECACIBE3AwggASgC5AQiAy4BGiEIIAMuARghBiABIAEpA7ACIAEpA9ADfDcDsAIgAUGoAWohByABQdADaiEMAkACQCARp0EBcQRAIAIoAhgNAQsgAkICNwNQQQAhBAwBCyACIBI3A+ADIAIgEDcD2AICQCABKALIAUEBRgRAIANBCGogAUHQAWogAkHgA2oQ8xtFDQELIAEgEjcD0AEgAUIBNwPIAQsCQCABKALYAUEBRgRAIAEoAuQEQQhqIAJB2AJqIAFB4AFqEPMbRQ0BCyABIBA3A+ABIAFCATcD2AELAn8gAS0A+gRBAkcEQEICIRFBAAwBCyACQYECNgKQAUIBIREgAkIBNwOAASACQgA3A3AgAiAQNwNoIAJCATcDYCACIBI3A1ggAiAMKQMANwOIASACQdAAagshBCACIBE3A1ALIAIpAyghECACKQMwIRIjAEEgayIDJAAgAS0AzAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1AvQDIhEgASkD0ANSBEAgBUEBcUUNByAERQ0EIAQoAgBFDQIgBCgCEEUNAyAEQQhqIQUgBEEYaiEEIAEoAtACRQ0GIAFB4AJqIQogAUHYAmohCSABLQD4BA0BDAULIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUGAA2pBASADIANBEGogERCVFAwGCyABKALkBEEIaiAJIAUQ8xtFBEAgASgC5ARBCGogCiAEEPMbRQ0ECyABQQA6APgEDAMLQciAzwAQsjsAC0HYgM8AELI7AAsgAUEAOgDMAwwCCyABLQD5BEUNACABKALkBEEIaiAFIAkQ8xtFBEAgASgC5ARBCGogBCAKEPMbRQ0BCyABQQA6APkECyABQYADaiEKIAFCATcD0AIgASAEKQMANwPgAiABIAUpAwA3A9gCIAEQ5R8EQCADIAEgASgC6AQiCSgCOCAJKAI8IAVBCBCaDSADQRBqIgUgASABKALoBCIJKAI4IAkoAjwgBEEIEJYMIApBACADIAUgASkD0AMQlRQMAQsgA0EQaiIJQQhBAEEBQQEQoBggAygCFCELIAMoAhBBAUYNASADKAIYIg8gBSkDADcAACADQQg2AgggAyAPNgIEIAMgCzYCACAJQQhBAEEBQQEQoBggAygCFCEFIAMoAhBBAUYNAiADKAIYIgsgBCkDADcAACADQQg2AhggAyALNgIUIAMgBTYCECAKQQAgAyAJIAEpA9ADEJUUCyABQYADaiABQdgDaiABQeQDahCWEyABKAKABEGAgICAeEcEQCABQfgDaiIEIAE1AvQDEKYnIAQgECASENcZCyADQSBqJAAMAgsgCyADKAIYQcD1zgAQ/S8ACyAFIAMoAhhBwPXOABD9LwALIAcgDBD1JiACKAIoQQFGBEAgAikDMCEQIAECfiABKAL4AUEBRgRAIAEpA4ACDAELIAFCATcD+AFCAAsgEHw3A4ACCyACKQNQIRAgAkHgA2oiAyACQdgAakHAAPwKAAACQAJAIBBCAlENACABKALoBEEIaiABKALkBEEIahCrEkUNACACQegCaiADQcAA/AoAACACIBA3A+ACIAJCAjcD2AIgAkGYAWogASACQdgCahDoBgwBCyACQgg3A5gBCwJAAkACQAJ+An8CQAJAAkACQAJAAkACQCABKALoBC0AnQFBAUYEQEEAIQQgAkEANgLIAiACQoCAgIAQNwLAAkEAIQcgCEEASg0BDAMLIAJCgICAgBA3AsACIAJBADYCyAIgCEEATA0BIAEoAtwEIQQgAkHgA2oiAyAIIAEoAuAEIgcQqw0gAyAEIAcQrgkgAkHYAmoiBCADQYAB/AoAACACQcwCaiIDIAQQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwwBCyABKALcBCEHIAJB4ANqIgMgCCABKALgBCIFEO0WIAMgByAFEK4JIAJB2AJqIgcgA0GAAfwKAAAgAkHMAmoiAyAHENAQIAJBwAJqIAIoAtACIAIoAtQCIgcQoTYgAxDeOwwBCyAGQQBKBEAgASgC0AQhBCACQeADaiIDIAYgASgC1AQiBRCrDSADIAQgBRCuCSACQdgCaiIEIANBgAH8CgAAIAJBzAJqIgMgBBDQECACQcACaiACKALQAiACKALUAhChNiADEN47CyACQcACaiIFIAIoAjwgAigCQBChNiACKALIAiEDAkAgASgCuARFDQAgAkHYAmoiCCADQQBBAUEBEKAYIAIoAtwCIQQgAigC2AJBAUcEQCACQQA2AugDIAIgAigC4AI2AuQDIAIgBDYC4AMgCCABKAK4BCACKALEAiACKALIAiACQeADaiIEIAEoArwEKAIMEQcAIAIoAtgCIghBCEcEQCAAIAIpAtwCNwIEIABBFGogAkHsAmooAgA2AgAgAEEMaiACQeQCaikCADcCACAAIAg2AgAgBBDeOyAFEN47DAQLIAJB4AJqIgQgAkHoA2ooAgA2AgAgAiACKQLgAzcD2AIgAkHAAmoQ3jsgAkHIAmogBCgCADYCACACIAIpA9gCNwPAAgwBCyAEIAIoAuACQdiCzwAQ/S8ACyACQegDaiACQcgCaigCADYCACACIAIpA8ACNwPgAyACQdgCaiACQeADahDnFSABKALwAyEFIAItAEwhBCACQfABaiACQZgBakHQAPwKAAAgAigC5AIhCCACKALgAiEKIAIpA+gBIRBCCSESQQIhCUECIQsgAikD2AIMBgsgBkEASgRAIAEoAtAEIQQgAkHgA2oiAyAGIAEoAtQEIgYQ7RYgAyAEIAYQrgkgAkHYAmoiBCADQYAB/AoAACACQcwCaiIDIAQQ0BAgAkHAAmogAigC0AIgAigC1AIiBBChNiADEN47CyACKAJAIgYgBCAHamohAyABKAK4BCIIRQ0BIAIoAsgCIQUgAkHYAmogCCACKAI8IAYgAkHAAmoiBiABKAK8BCgCDBEHACACKALYAiIIQQhGDQIgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAYQ3jsLIAJBmAFqEKwpDAULIAJBwAJqIAIoAjwgBhChNgwBC0EBIAMgAigCyAIgBWtLDQEaIAJBwAJqIgYgBRD0NCAGIAIoAjwgAigCQBChNgtBAAshBiACQegDaiACQcgCaigCADYCACACIAIpAsACNwPgAyACQdgCaiACQeADahDnFSABKAL0AyEFIAEoAtADIQggASgC8AMhCiACLQBMIQ0gAikDmAEhEiACQfABaiACQaABakHQAPwKAAAgBEEYdiEOIARBEHYhCSAEQQh2IQsgAikD2AIhECACKQPgAgshESABKAJ4QYCAgIB4Rw0BIAIgEjcD2AIgAkHgAmogAkHwAWpB0AD8CgAAIAIgAzYC2AMgAiANOgDVAyACIAY6ANQDIAIgBzYC0AMgAiAOOgDPAyACIAk6AM4DIAIgCzoAzQMgAiAEOgDMAyACIAU2AsgDIAIgCDYCxAMgAiAKNgLAAyACIBE3A7gDIAIgEDcDsAMgAkHgA2ogASACQdgCahCkCiACKALgAyIDQQhGDQIgACACKQLkAzcCBCAAQRRqIAJB9ANqKAIANgIAIABBDGogAkHsA2opAgA3AgAgACADNgIACyACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAwCCyACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAM2AtgDIAIgDToA1QMgAiAGOgDUAyACIAc2AtADIAIgDjoAzwMgAiAJOgDOAyACIAs6AM0DIAIgBDoAzAMgAiAFNgLIAyACIAg2AsQDIAIgCjYCwAMgAiARNwO4AyACIBA3A7ADIAFB8AJqIAJB2AJqEOogCyABQQA2AuAEIAFBADYC1AQgASABKQOQAiABNQL0A3w3A5ACIAwQ6SAgAEEINgIAIAJBxABqIAIoAjwgAigCQCACKAI4KAIQEQEACyACQeAEaiQAC9IcAw9/A34CfSMAQcAEayICJAAgAkG4AmohBCMAQUBqIgMkAAJAAn8gASgCaEGAgICAeEcEQCADQRhqIAFBIGoQvAogA0EQaiIGIANBJGopAgA3AwAgAyADKQIcNwMIIAMoAhgiBUEIRwRAIAMoAiwhByAEIAMpAwg3AgwgBCAHNgIcIAQgBTYCCCAEQgI3AwAgBEEUaiAGKQMANwIADAMLIANBOGogBikDADcDACADIAMpAwg3AzBBBwwBCyADQRhqIAEoAngiBSABKAJ8IgcoAhwRAAAgA0EQaiIGIANBJGopAgA3AwAgAyADKQIcNwMIIAMoAhgiCEEIRwRAIAMoAiwhBSAEIAMpAwg3AgwgBCAFNgIcIAQgCDYCCCAEQgI3AwAgBEEUaiAGKQMANwIADAILIANBOGogBikDADcDACADIAMpAwg3AzAgBSAHKAIQEQQACyEGIAQgAykDMDcDICABKAKQASEFIAFBADYCkAEgASgCECEHIAFBADYCECABKAIYIQggAUEANgIYIAEpAwAhESABQgA3AwAgBCABKgIcOAIcIAQgCDYCGCAEIAEqAhQ4AhQgBCAHNgIQIAQgASkDCDcDCCAEIBE3AwAgBEEoaiADQThqKQMANwMAIAQgBjoANCAEIAU2AjALIANBQGskACACQcgDaiIDIAJByAJqKQMANwMAIAJB0ANqIgQgAkHQAmopAwA3AwAgAiACKQPAAjcDwAMCQCACKQO4AiIRQgJRBEAgACACKQPAAzcDACAAQRBqIAQpAwA3AwAgAEEIaiADKQMANwMADAELIAJBOGogAkHoAmopAwA3AwAgAkEwaiACQeACaikDADcDACACQRhqIgYgAykDADcDACACQSBqIAQpAwA3AwAgAiACKQPYAjcDKCACIAIpA8ADNwMQIAIgETcDCCABKAK4BCIDLgEaIQcgAy4BGCEEIAEgASkDmAMiEiABKQOQAnw3A5ACIAFBmAFqIAFBmANqIQwCfwJAIAYoAgBBAUYEQCACKAIgDQELIAJCAjcDQEEADAELIAIqAiQhFAJAIAIqAhwiFSAVXA0AIAEoAtgBQQFGBEAgASoC3AEgFV5FDQELIAEgFTgC3AEgAUEBNgLYAQsCQCAUIBRcDQAgASgC4AFBAUYEQCAUIAEqAuQBXkUNAQsgASAUOALkASABQQE2AuABCyABLQDOBEECRwRAIAJCAjcDQEEADAELIAJBgQI2AnAgAiAUOAJsIAJBATYCaCACIBU4AmQgAkEBNgJgIAIgEjcDWCACQgE3A1AgAkIANwNAIAJBQGsLIQYgAikDECESIwBBIGsiAyQAIAEtAJQDIQUCQAJAAkACQAJAAkACQAJAAkACQCABNQK8AyITIAEpA5gDUgRAIAVBAXFFDQcgBkUNASAGKAIgRQ0DIAYoAihFDQQgBkEkaiEIIAZBLGohBSABKAKIBA0CIAgqAgAhFAwGCyAFQQFxRQ0GIANBADYCCCADQoCAgIAQNwIAIANBADYCGCADQoCAgIAQNwIQIAFByAJqQQEgAyADQRBqIBMQlRQMBgsgAUEAOgCUAwwFCyAIKgIAIRQgAS0AzARFDQIgASoCjAQgFF5FBEAgASoCkAQgBSoCAF5FDQMLIAFBADoAzAQMAgtByIDPABCyOwALQdiAzwAQsjsACyABLQDNBEUNACAUIAEqAowEXkUEQCAFKgIAIAEqApAEXkUNAQsgAUEAOgDNBAsgAUHIAmohCyABIBQ4AowEIAFBATYCiAQgASAFKgIAOAKQBCABEOgfBEAgAyABIAEoArwEIgkoAjggCSgCPCAIQQQQnQ0gA0EQaiIIIAEgASgCvAQiCSgCOCAJKAI8IAVBBBCZDCALQQAgAyAIIAEpA5gDEJUUDAELIANBEGoiCUEEQQBBAUEBEKAYIAMoAhQhCiADKAIQQQFGDQEgAygCGCIQIAgoAgA2AAAgA0EENgIIIAMgEDYCBCADIAo2AgAgCUEEQQBBAUEBEKAYIAMoAhQhCCADKAIQQQFGDQIgAygCGCIKIAUoAgA2AAAgA0EENgIYIAMgCjYCFCADIAg2AhAgC0EAIAMgCSABKQOYAxCVFAsgAUHIAmogAUGgA2ogAUGsA2oQlhMgASgCyANBgICAgHhHBEAgAUHAA2oiBSABNQK8AxCmJyAFIBEgEhDXGQsgA0EgaiQADAILIAogAygCGEHA9c4AEP0vAAsgCCADKAIYQcD1zgAQ/S8ACyAMEPQmIAIoAghBAUYEQCACKQMQIREgAQJ+IAEoAsgBQQFGBEAgASkD0AEMAQsgAUIBNwPIAUIACyARfDcD0AELIAIpA0AhESACQcADaiIDIAJByABqQTD8CgAAAkACQCARQgJRDQAgASgCvARBCGogASgCuARBCGoQqxJFDQAgAkHIAmogA0Ew/AoAACACIBE3A8ACIAJCBDcDuAIgAkH4AGogASACQbgCahDnBgwBCyACQgg3A3gLAkACQAJAAn4CfwJAAkACQAJAAkACQAJAIAEoArwELQCdAUEBRgRAQQAhAyACQQA2AqgCIAJCgICAgBA3AqACQQAhBiAHQQBKDQEMAwsgAkKAgICAEDcCoAIgAkEANgKoAiAHQQBMDQEgASgCsAQhBSACQcADaiIDIAcgASgCtAQiBhCrDSADIAUgBhCuCSACQbgCaiIFIANBgAH8CgAAIAJBrAJqIgMgBRDQECACQaACaiACKAKwAiACKAK0AhChNiADEN47DAELIAEoArAEIQUgAkHAA2oiBiAHIAEoArQEIgcQ7RYgBiAFIAcQrgkgAkG4AmoiBSAGQYAB/AoAACACQawCaiIHIAUQ0BAgAkGgAmogAigCsAIgAigCtAIiBhChNiAHEN47DAELIARBAEoEQCABKAKkBCEFIAJBwANqIgMgBCABKAKoBCIHEKsNIAMgBSAHEK4JIAJBuAJqIgUgA0GAAfwKAAAgAkGsAmoiAyAFENAQIAJBoAJqIAIoArACIAIoArQCEKE2IAMQ3jsLIAJBoAJqIgcgAigCLCACKAIwEKE2IAIoAqgCIQUCQCABKAKABEUNACACQbgCaiIIIAVBAEEBQQEQoBggAigCvAIhAyACKAK4AkEBRwRAIAJBADYCyAMgAiACKALAAjYCxAMgAiADNgLAAyAIIAEoAoAEIAIoAqQCIAIoAqgCIAJBwANqIgMgASgChAQoAgwRBwAgAigCuAIiCEEIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgCDYCACADEN47IAcQ3jsMBAsgAkHAAmoiAyACQcgDaigCADYCACACIAIpAsADNwO4AiACQaACahDeOyACQagCaiADKAIANgIAIAIgAikDuAI3A6ACDAELIAMgAigCwAJB2ILPABD9LwALIAJByANqIAJBqAJqKAIANgIAIAIgAikDoAI3A8ADIAJBuAJqIAJBwANqEOcVIAEoArgDIQcgAi0APCEDIAJB0AFqIAJB+ABqQdAA/AoAACACKALEAiEIIAIoAsACIQsgAikDuAIhEUIJIRJBAiEJQQIhCiACKQPIAQwGCyAEQQBKBEAgASgCpAQhBSACQcADaiIDIAQgASgCqAQiBBDtFiADIAUgBBCuCSACQbgCaiIEIANBgAH8CgAAIAJBrAJqIgUgBBDQECACQaACaiACKAKwAiACKAK0AiIDEKE2IAUQ3jsLIAIoAjAiBCADIAZqaiEFIAEoAoAEIghFDQEgAigCqAIhByACQbgCaiAIIAIoAiwgBCACQaACaiIEIAEoAoQEKAIMEQcAIAIoArgCIghBCEYNAiAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAg2AgAgBBDeOwsgAkH4AGoQrCkMBQsgAkGgAmogAigCLCAEEKE2DAELQQEgBSACKAKoAiAHa0sNARogAkGgAmoiBCAHEPQ0IAQgAigCLCACKAIwEKE2C0EACyEEIAJByANqIAJBqAJqKAIANgIAIAIgAikCoAI3A8ADIAJBuAJqIAJBwANqEOcVIAEoArwDIQcgASgCmAMhCCABKAK4AyELIAItADwhDSACKQN4IRIgAkHQAWogAkGAAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiEJIAIpA8ACIREgAikDuAILIRMgASgCaEGAgICAeEcNASACIBI3A7gCIAJBwAJqIAJB0AFqQdAA/AoAACACIAU2ArgDIAIgDToAtQMgAiAEOgC0AyACIAY2ArADIAIgDjoArwMgAiAKOgCuAyACIAk6AK0DIAIgAzoArAMgAiAHNgKoAyACIAg2AqQDIAIgCzYCoAMgAiARNwOYAyACIBM3A5ADIAJBwANqIAEgAkG4AmoQqAogAigCwAMiA0EIRg0CIAAgAikCxAM3AgQgAEEUaiACQdQDaigCADYCACAAQQxqIAJBzANqKQIANwIAIAAgAzYCAAsgAkE0aiACKAIsIAIoAjAgAigCKCgCEBEBAAwCCyACIBI3A7gCIAJBwAJqIAJB0AFqQdAA/AoAACACIAU2ArgDIAIgDToAtQMgAiAEOgC0AyACIAY2ArADIAIgDjoArwMgAiAKOgCuAyACIAk6AK0DIAIgAzoArAMgAiAHNgKoAyACIAg2AqQDIAIgCzYCoAMgAiARNwOYAyACIBM3A5ADIAFBuAJqIAJBuAJqEOogCyABQQA2ArQEIAFBADYCqAQgASABKQPwASABNQK8A3w3A/ABIAwQ6SAgAEEINgIAIAJBNGogAigCLCACKAIwIAIoAigoAhARAQALIAJBwARqJAAL2DYCE38FfiMAQbAEayIDJAAgASkCyAIhGSABQQA2AsgCIANBGGogAUHYAmoiBCgCADYCACADQRBqIgIgAUHQAmoiBykCADcDACAEQQA2AgAgB0KAgICAEDcDACADIBk3AwggA0EAOwGwAiADQQA2AqwCIANBADYClAIgA0EANgKIAiADQRU6APgBIANCBDcC8AEgA0IANwLoASADQoCAgIDAADcC4AEgA0EANgLYASADIAEoAuwCNgKEAiADIAEoAqQDNgL8ASADQegDaiACEPIvIAMgAykC6AM3AogBIANBADYChAEgAyADKAL0AyICNgKAASADIAMoAvADNgJ8IAMgA0H8AGoiBxDXOyADKAIAIQYCQAJAAkACQAJAAkACQAJAAkACQAJAQRxBBBCtNiIEBEAgBEKBgICAEDcCACAEIAMpAnw3AgggBEEQaiADQYQBaikCADcCACAEQRhqIANBjAFqKAIANgIAIAMgAjYCvAIgAyAGNgK4AiADIAQ2ArQCIAcgA0HYAWoiAiADQbQCahD6IyMAQRBrIgQkAAJAIAEoAqACQYGAgIB4RwRAIARBBGogAUGgAmoQ4xwMAQsgBEEANgIECwJAAkACQCABKALoAigCFCIGQQhqIAYoAghBAkZBAnRqLQAgDgQAAQEAAQsgAkEANgIAIAQoAgQiBkUNASAGIAYoAgAiBkEBazYCACAGQQFHDQEgBEEEahD7HgwBCyACIAQpAgQ3AgAgAkEIaiAEQQxqKAIANgIACyAEQRBqJAAgA0EgaiIEIAcgAhCuFiACIAQQzRwgByACEMsSAkACQAJAAkACQAJAIAEtAJgDIgRBI2sOBAECAwQACwJAIARBCkcEQCAEQRNGDQEgA0HYAWoiBCADQfwAakE4/AoAAEHAAEEEEK02IgJFDQggAkKBgICAEDcCACACQQhqIARBOPwKAABBzJrNACEEDA0LIwBBQGoiBSQAIAUgA0H8AGo2AgQgBUEIaiINIAVBBGoiBBD2LyAFIAQQjD42AjggBUEANgI0IAUgBDYCMCAFIAVBP2o2AiwjAEEgayIEJAAgBEEUaiAFQSxqIgcoAgwiAiAHKAIIayIGQQAgAiAGTxtBAEECQQIQoBggBCgCGCECIAQoAhRBAUYNECAFQSBqIQkgBEEQaiIOQQA2AgAgBCAEKAIcNgIMIAQgAjYCCCMAQRBrIgIkACAEQQhqIgYgBygCDCIIIAcoAghrIgtBACAIIAtPGxDtLSACIAYpAgRCIIk3AgggAiAGQQhqNgIEIwBBEGsiBiQAIAJBBGoiCigCBCEIIAooAgAhDwJAAkAgBygCCCILIAcoAgwiDEkEQCAHKAIEIRAgCigCCCAIQQF0aiEKA0AgBkEIaiAQIAsQrC4gBigCDCIRQQFNDQIgCiAGKAIILwAAOwEAIApBAmohCiAIQQFqIQggDCALQQFqIgtHDQALCyAPIAg2AgAgBkEQaiQADAELQQIgEUGQ6NAAELA7AAsgAkEQaiQAIAlBCGogDigCADYCACAJIAQpAgg3AgAgBEEgaiQAIAcgCRDpGCADQdgBaiIEIAcgDRDPHSAFQUBrJABBOEEEEK02IgJFDQ8gAkKBgICAEDcCACACQQhqIARBMPwKAABB8JbNACEEQQEhBQwMCwJAAkACQCABLQCZA0EBaw4CAQIACyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiDSAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBBEEEEKAYIAQoAhghAiAEKAIUQQFGDREgBUEgaiEJIARBEGoiDkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayICJAAgBEEIaiIGIAcoAgwiCCAHKAIIayILQQAgCCALTxsQ7i0gAiAGKQIEQiCJNwIIIAIgBkEIajYCBCMAQRBrIgYkACACQQRqIgooAgQhCCAKKAIAIQ8CQAJAIAcoAggiCyAHKAIMIgxJBEAgBygCBCEQIAooAgggCEECdGohCgNAIAZBCGogECALEKwuIAYoAgwiEUEDTQ0CIAogBigCCCgAADYCACAKQQRqIQogCEEBaiEIIAwgC0EBaiILRw0ACwsgDyAINgIAIAZBEGokAAwBC0EEIBFB4OfQABCwOwALIAJBEGokACAJQQhqIA4oAgA2AgAgCSAEKQIINwIAIARBIGokACAHIAkQ6BggA0HYAWoiBCAHIA0QvR0gBUFAayQAQThBBBCtNiICRQ0QIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQciXzQAhBEEBIQUMDQsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIg4gBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQQRBCBCgGCAEKAIYIQIgBCgCFEEBRg0QIAVBIGohCSAEQRBqIg9BADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiAiQAIARBCGoiBiAHKAIMIgggBygCCGsiC0EAIAggC08bEOotIAIgBikCBEIgiTcCCCACIAZBCGo2AgQjAEEQayIGJAAgAkEEaiIKKAIEIQggCigCACEMAkACQAJAIAcoAggiCyAHKAIMIhBJBEAgBygCBCERIAooAgggCEEDdGohCgNAIAZBCGogESALEKwuIAYoAgwiDUEHTQ0CIA1BC00NAyAKIAYoAggpAAQ3AgAgCkEIaiEKIAhBAWohCCAQIAtBAWoiC0cNAAsLIAwgCDYCACAGQRBqJAAMAgtBCCANQfDn0AAQsDsAC0EMIA1BgOjQABCwOwALIAJBEGokACAJQQhqIA8oAgA2AgAgCSAEKQIINwIAIARBIGokACAHIAkQ6xggA0HYAWoiBCAHIA4Q0x0gBUFAayQAQThBBBCtNiICRQ0PIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQaCYzQAhBEEBIQUMDAsgA0HYAWpBJEEAQQFBARCgGCADKALcASEBIAMoAtgBQQFGDQcgAygC4AEiBEH4mM0AQST8CgAAIABBJDYCDCAAIAQ2AgggACABNgIEIABBATYCAAwMCyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiESAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBBEEEEKAYIAQoAhghAiAEKAIUQQFGDQ4gBUEgaiENIARBEGoiEkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIIJAAgBEEIaiICIAcoAgwiBiAHKAIIayIJQQAgBiAJTxsQ7i0gCCACKQIEQiCJNwIIIAggAkEIajYCBCMAQRBrIgkkACAIQQRqIgYoAgQhAiAGKAIAIAcoAggiCyAHKAIMIg9JBH8gBygCBCETIAIgD2ogC2sgBigCCCACQQJ0aiEOA0AgCUEIaiATIAsQrC4gDgJ/IAkoAgghCiAJKAIMIQYjAEEgayICJAACQCAGQQVJBEAgBkUNASACIAosAABBB3UiDDYCGCACIAYgCmo2AgQgAiAKNgIAIAIQgzsiEARAIBAgBiAGIBBLGyIMBEAgAiAGa0EcaiAKIAz8CgAACyACKAIYIQwLIAJBIGokACAMDAILIAJBATYCBCACQfT8zgA2AgAgAkIBNwIMIAJBOzYCHCACQaD9zgA2AhgMEwtBAEEAQYz9zgAQwyEACyICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycjYCACAOQQRqIQ4gDyALQQFqIgtHDQALBSACCzYCACAJQRBqJAAgCEEQaiQAIA1BCGogEigCADYCACANIAQpAgg3AgAgBEEgaiQAIAcgDRDoGCADQdgBaiIEIAcgERDKHSAFQUBrJAAgA0HoA2ogBCABLQCZAyABLQCaAxCgEyADLQDoAyIEQSlGDQMgA0HPAmoiBSADQfgDaikAADcAACADQcgCaiIHIANB8QNqKQAANwMAIANB4AJqIgYgA0GIBGopAgA3AwAgA0HoAmoiCCADQZAEaikCADcDACADIAMpAOkDNwPAAiADIAMpAoAENwPYAkE4QQQQrTYiAkUNDSACIAQ6AAggAkKBgICAEDcCACACIAMpA8ACNwAJIAIgAykD2AI3AiAgAkERaiAHKQMANwAAIAJBGGogBSkAADcAACACQShqIAYpAwA3AgAgAkEwaiAIKQMANwIAQZyZzQAhBEEBIQUMCgsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIhAgBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQQhBCBCgGCAEKAIYIQIgBCgCFEEBRg0NIAVBIGohDSAEQRBqIhFBADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiCSQAIARBCGoiAiAHKAIMIgYgBygCCGsiCEEAIAYgCE8bEOwtIAkgAikCBEIgiTcCCCAJIAJBCGo2AgQjAEEQayIGJAAgCUEEaiIIKAIEIQIgCCgCACAHKAIIIgsgBygCDCIPSQR/IAcoAgQhEiACIA9qIAtrIAgoAgggAkEDdGohDgNAIAYgEiALEKwuIAZBCGohDCAGKAIAIQogBigCBCEIIwBBIGsiAiQAAkACQCAIQQlJBEAgCEUNASACIAosAABBB3WsIhU3AxggAiAIIApqNgIEIAIgCjYCACAMIAIQgzsiDAR+IAwgCCAIIAxLGyIMBEAgAiAIa0EgaiAKIAz8CgAACyACKQMYBSAVCzcAACACQSBqJAAMAgsgAkEBNgIEIAJB9PzOADYCACACQgE3AgwgAkE7NgIcIAJBpP3OADYCGAwSC0EAQQBBjP3OABDDIQALIA4gBikDCCIVQjiGIBVCgP4Dg0IohoQgFUKAgPwHg0IYhiAVQoCAgPgPg0IIhoSEIBVCCIhCgICA+A+DIBVCGIhCgID8B4OEIBVCKIhCgP4DgyAVQjiIhISENwMAIA5BCGohDiAPIAtBAWoiC0cNAAsFIAILNgIAIAZBEGokACAJQRBqJAAgDUEIaiARKAIANgIAIA0gBCkCCDcCACAEQSBqJAAgByANEL0YIANB2AFqIgQgByAQEMYdIAVBQGskACADQegDaiAEIAEtAJkDIAEtAJoDEKITIAMtAOgDIgRBKUYNCCADQf8CaiIFIANB+ANqKQAANwAAIANB+AJqIgcgA0HxA2opAAA3AwAgA0GQA2oiBiADQYgEaikCADcDACADQZgDaiIIIANBkARqKQIANwMAIAMgAykA6QM3A/ACIAMgAykCgAQ3A4gDQThBBBCtNiICRQ0MIAIgBDoACCACQoGAgIAQNwIAIAIgAykD8AI3AAkgAiADKQOIAzcCICACQRFqIAcpAwA3AAAgAkEYaiAFKQAANwAAIAJBKGogBikDADcCACACQTBqIAgpAwA3AgBB9JnNACEEQQEhBQwJCyMAQUBqIgUkACAFIANB/ABqNgIEIAVBCGoiDiAFQQRqIgQQ9i8gBSAEEIw+NgI4IAVBADYCNCAFIAQ2AjAgBSAFQT9qNgIsIwBBIGsiBCQAIARBFGogBUEsaiIHKAIMIgIgBygCCGsiBkEAIAIgBk8bQQBBEEEQEKAYIAQoAhghAiAEKAIUQQFGDQwgBUEgaiELIARBEGoiD0EANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIGJAAgBEEIaiICIAcoAgwiCCAHKAIIayIJQQAgCCAJTxsQ6y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQSBrIgIkACAGQQRqIgooAgQhCSAKKAIAIAcoAggiCCAHKAIMIg1JBH8gBygCBCEMIAkgDWogCGsgCigCCCAJQQR0aiEJA0AgAkEIaiAMIAgQrC4gAkEQaiACKAIIIAIoAgwQuRQgAikDGCEVIAkgAikDECIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISENwMIIAkgFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhDcDACAJQRBqIQkgDSAIQQFqIghHDQALBSAJCzYCACACQSBqJAAgBkEQaiQAIAtBCGogDygCADYCACALIAQpAgg3AgAgBEEgaiQAIAcgCxDsGCADQdgBaiIEIAcgDhDLHSAFQUBrJAAgA0HoA2ogBCABLQCZAyABLQCaAxChEyADLQDoAyIEQSlGDQYgA0GvA2oiBSADQfgDaikAADcAACADQagDaiIHIANB8QNqKQAANwMAIANBwANqIgYgA0GIBGopAgA3AwAgA0HIA2oiCCADQZAEaikCADcDACADIAMpAOkDNwOgAyADIAMpAoAENwO4A0E4QQQQrTYiAkUNCyACIAQ6AAggAkKBgICAEDcCACACIAMpA6ADNwAJIAIgAykDuAM3AiAgAkERaiAHKQMANwAAIAJBGGogBSkAADcAACACQShqIAYpAwA3AgAgAkEwaiAIKQMANwIAQayKzQAhBEEBIQUMCAsjAEFAaiIFJAAgBSADQfwAajYCBCAFQQhqIg4gBUEEaiIEEPYvIAUgBBCMPjYCOCAFQQA2AjQgBSAENgIwIAUgBUE/ajYCLCMAQSBrIgQkACAEQRRqIAVBLGoiBygCDCICIAcoAghrIgZBACACIAZPG0EAQRBBIBCgGCAEKAIYIQIgBCgCFEEBRg0LIAVBIGohCyAEQRBqIg9BADYCACAEIAQoAhw2AgwgBCACNgIIIwBBEGsiCCQAIARBCGoiAiAHKAIMIgYgBygCCGsiCUEAIAYgCU8bEO8tIAggAikCBEIgiTcCCCAIIAJBCGo2AgQjAEHQAGsiAiQAIAhBBGoiCigCBCEGIAooAgAgBygCCCIJIAcoAgwiDUkEfyAHKAIEIQwgBiANaiAJayAKKAIIIAZBBXRqIQYDQCACQQhqIAwgCRCsLiACQRBqIgogAigCCCACKAIMELsQIAJBMGogChCmKyACKQNIIRUgAikDQCEWIAIpAzghFyAGQRhqIAIpAzAiGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAYQgiIQoCAgPgPgyAYQhiIQoCA/AeDhCAYQiiIQoD+A4MgGEI4iISEhDcDACAGQRBqIBdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQ3AwAgBiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISENwMIIAYgFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhDcDACAGQSBqIQYgDSAJQQFqIglHDQALBSAGCzYCACACQdAAaiQAIAhBEGokACALQQhqIA8oAgA2AgAgCyAEKQIINwIAIARBIGokACAHIAsQ7RggA0HYAWoiBCAHIA4Qzh0gBUFAayQAIANB6ANqIAQgAS0AmQMgAS0AmgMQoxMgAy0A6AMiBEEpRg0EIANB3wNqIgUgA0H4A2opAAA3AAAgA0HYA2oiByADQfEDaikAADcDACADQaAEaiIGIANBiARqKQIANwMAIANBqARqIgggA0GQBGopAgA3AwAgAyADKQDpAzcD0AMgAyADKQKABDcDmARBOEEEEK02IgJFDQogAiAEOgAIIAJCgYCAgBA3AgAgAiADKQPQAzcACSACIAMpA5gENwIgIAJBEWogBykDADcAACACQRhqIAUpAAA3AAAgAkEoaiAGKQMANwIAIAJBMGogCCkDADcCAEGUi80AIQRBASEFDAcLIANB0wJqIANB/ANqKAIAIgE2AAAgA0HLAmogA0H0A2opAgAiFTcAACADIAMpAuwDIhY3AMMCIANB6AFqIAE2AgAgA0HgAWogFTcDACADIBY3A9gBIAAgA0HYAWoQpiUMBwtBBEEcEKM9AAtBBEHAABCjPQALIAEgAygC4AFB1P3MABD9LwALIANB4wNqIANB/ANqKAIAIgE2AAAgA0HbA2ogA0H0A2opAgAiFTcAACADIAMpAuwDIhY3ANMDIANB6AFqIAE2AgAgA0HgAWogFTcDACADIBY3A9gBIAAgA0HYAWoQpiUMAwsgA0GzA2ogA0H8A2ooAgAiATYAACADQasDaiADQfQDaikCACIVNwAAIAMgAykC7AMiFjcAowMgA0HoAWogATYCACADQeABaiAVNwMAIAMgFjcD2AEgACADQdgBahCmJQwCCyADQYMDaiADQfwDaigCACIBNgAAIANB+wJqIANB9ANqKQIAIhU3AAAgAyADKQLsAyIWNwDzAiADQegBaiABNgIAIANB4AFqIBU3AwAgAyAWNwPYASAAIANB2AFqEKYlDAELAn9BgICAgHggASgCoAIiB0GBgICAeEYNABpBgICAgHggB0GAgICAeEYNABogASkCpAIhGSABQQA2AqgCIAFCgICAgCA3A6ACIAcLIQcgAUGAA2oQtDAgASAZNwKEAyABIAc2AoADIAEoAtwCIgdBgICAgHhHBEAgASkD4AIhGSABQQA2AuQCIAFCgICAgCA3AtwCCyABQYwDahC0MCABIBk3A5ADIAEgBzYCjAMgAUIANwLsAiAAIAQ2AgggACACNgIEIABBCDYCACAFRQ0BCyADQfwAahDZJAsgA0GwBGokAA8LQQRBOBCjPQALIAIgBCgCHEHE0swAEP0vAAsgAiACQRhqNgIIIAJB/PzOABDvLAALzxwDD38DfgJ8IwBB4ARrIgIkACACQdgCaiEEIwBBQGoiAyQAAkACfyABKAJ4QYCAgIB4RwRAIANBGGogAUEwahC8CiADQRBqIgYgA0EkaikCADcDACADIAMpAhw3AwggAygCGCIFQQhHBEAgAygCLCEHIAQgAykDCDcCDCAEIAc2AhwgBCAFNgIIIARCAjcDACAEQRRqIAYpAwA3AgAMAwsgA0E4aiAGKQMANwMAIAMgAykDCDcDMEEHDAELIANBGGogASgCiAEiBSABKAKMASIHKAIcEQAAIANBEGoiBiADQSRqKQIANwMAIAMgAykCHDcDCCADKAIYIghBCEcEQCADKAIsIQUgBCADKQMINwIMIAQgBTYCHCAEIAg2AgggBEICNwMAIARBFGogBikDADcCAAwCCyADQThqIAYpAwA3AwAgAyADKQMINwMwIAUgBygCEBEEAAshBiAEIAMpAzA3AzAgASgCoAEhBSABQQA2AqABIAEpAwAhESABQgA3AwAgASkDECESIAFCADcDECABKQMgIRMgAUIANwMgIAQgASkDKDcDKCAEIBM3AyAgBCABKwMYOQMYIAQgEjcDECAEIAErAwg5AwggBCARNwMAIARBOGogA0E4aikDADcDACAEIAY6AEQgBCAFNgJACyADQUBrJAAgAkHoA2oiAyACQegCaikDADcDACACQfADaiIEIAJB8AJqKQMANwMAIAIgAikD4AI3A+ADAkAgAikD2AIiEUICUQRAIAAgAikD4AM3AwAgAEEQaiAEKQMANwMAIABBCGogAykDADcDAAwBCyACQShqIAJB+AJqQSj8CgAAIAJBGGogAkHoA2opAwA3AwAgAkEgaiIDIAJB8ANqKQMANwMAIAIgAikD4AM3AxAgAiARNwMIIAEoAuQEIgQuARohByAELgEYIQQgASABKQPQAyISIAEpA7ACfDcDsAIgAUGoAWogAUHQA2ohDAJ/AkAgEadBAXEEQCACKAIYDQELIAJCAjcDUEEADAELIAMrAwAhFAJAIAIrAxAiFSAVYg0AIAEoAsgBQQFGBEAgASsD0AEgFWRFDQELIAEgFTkD0AEgAUIBNwPIAQsCQCAUIBRiDQAgASgC2AFBAUYEQCAUIAErA+ABZEUNAQsgASAUOQPgASABQgE3A9gBCyABLQD6BEECRwRAIAJCAjcDUEEADAELIAJBgQI2ApABIAIgEjcDiAEgAkIBNwOAASACQgA3A3AgAiAUOQNoIAJCATcDYCACIBU5A1ggAkIBNwNQIAJB0ABqCyEGIAIpAyghESACKQMwIRIjAEEgayIDJAAgAS0AzAMhBQJAAkACQAJAAkACQAJAAkACQAJAIAE1AvQDIhMgASkD0ANSBEAgBUEBcUUNByAGRQ0BIAYoAgBFDQMgBigCEEUNBCAGQQhqIQggBkEYaiEFIAEoAtACDQIgCCsDACEUDAYLIAVBAXFFDQYgA0EANgIIIANCgICAgBA3AgAgA0EANgIYIANCgICAgBA3AhAgAUGAA2pBASADIANBEGogExCVFAwGCyABQQA6AMwDDAULIAgrAwAhFCABLQD4BEUNAiABKwPYAiAUZEUEQCABKwPgAiAFKwMAZEUNAwsgAUEAOgD4BAwCC0HIgM8AELI7AAtB2IDPABCyOwALIAEtAPkERQ0AIBQgASsD2AJkRQRAIAUrAwAgASsD4AJkRQ0BCyABQQA6APkECyABQYADaiELIAEgFDkD2AIgAUIBNwPQAiABIAUrAwA5A+ACIAEQ5R8EQCADIAEgASgC6AQiCSgCOCAJKAI8IAhBCBCaDSADQRBqIgggASABKALoBCIJKAI4IAkoAjwgBUEIEJYMIAtBACADIAggASkD0AMQlRQMAQsgA0EQaiIJQQhBAEEBQQEQoBggAygCFCEKIAMoAhBBAUYNASADKAIYIhAgCCkDADcAACADQQg2AgggAyAQNgIEIAMgCjYCACAJQQhBAEEBQQEQoBggAygCFCEIIAMoAhBBAUYNAiADKAIYIgogBSkDADcAACADQQg2AhggAyAKNgIUIAMgCDYCECALQQAgAyAJIAEpA9ADEJUUCyABQYADaiABQdgDaiABQeQDahCWEyABKAKABEGAgICAeEcEQCABQfgDaiIFIAE1AvQDEKYnIAUgESASENcZCyADQSBqJAAMAgsgCiADKAIYQcD1zgAQ/S8ACyAIIAMoAhhBwPXOABD9LwALIAwQ9SYgAigCKEEBRgRAIAIpAzAhESABAn4gASgC+AFBAUYEQCABKQOAAgwBCyABQgE3A/gBQgALIBF8NwOAAgsgAikDUCERIAJB4ANqIgMgAkHYAGpBwAD8CgAAAkACQCARQgJRDQAgASgC6ARBCGogASgC5ARBCGoQqxJFDQAgAkHoAmogA0HAAPwKAAAgAiARNwPgAiACQgU3A9gCIAJBmAFqIAEgAkHYAmoQ6AYMAQsgAkIINwOYAQsCQAJAAkACfgJ/AkACQAJAAkACQAJAAkAgASgC6AQtAJ0BQQFGBEBBACEDIAJBADYCyAIgAkKAgICAEDcCwAJBACEGIAdBAEoNAQwDCyACQoCAgIAQNwLAAiACQQA2AsgCIAdBAEwNASABKALcBCEFIAJB4ANqIgMgByABKALgBCIGEKsNIAMgBSAGEK4JIAJB2AJqIgUgA0GAAfwKAAAgAkHMAmoiAyAFENAQIAJBwAJqIAIoAtACIAIoAtQCEKE2IAMQ3jsMAQsgASgC3AQhBSACQeADaiIGIAcgASgC4AQiBxDtFiAGIAUgBxCuCSACQdgCaiIFIAZBgAH8CgAAIAJBzAJqIgcgBRDQECACQcACaiACKALQAiACKALUAiIGEKE2IAcQ3jsMAQsgBEEASgRAIAEoAtAEIQUgAkHgA2oiAyAEIAEoAtQEIgcQqw0gAyAFIAcQrgkgAkHYAmoiBSADQYAB/AoAACACQcwCaiIDIAUQ0BAgAkHAAmogAigC0AIgAigC1AIQoTYgAxDeOwsgAkHAAmoiByACKAI8IAIoAkAQoTYgAigCyAIhBQJAIAEoArgERQ0AIAJB2AJqIgggBUEAQQFBARCgGCACKALcAiEDIAIoAtgCQQFHBEAgAkEANgLoAyACIAIoAuACNgLkAyACIAM2AuADIAggASgCuAQgAigCxAIgAigCyAIgAkHgA2oiAyABKAK8BCgCDBEHACACKALYAiIIQQhHBEAgACACKQLcAjcCBCAAQRRqIAJB7AJqKAIANgIAIABBDGogAkHkAmopAgA3AgAgACAINgIAIAMQ3jsgBxDeOwwECyACQeACaiIDIAJB6ANqKAIANgIAIAIgAikC4AM3A9gCIAJBwAJqEN47IAJByAJqIAMoAgA2AgAgAiACKQPYAjcDwAIMAQsgAyACKALgAkHYgs8AEP0vAAsgAkHoA2ogAkHIAmooAgA2AgAgAiACKQPAAjcD4AMgAkHYAmogAkHgA2oQ5xUgASgC8AMhByACLQBMIQMgAkHwAWogAkGYAWpB0AD8CgAAIAIoAuQCIQggAigC4AIhCyACKQPYAiERQgkhEkECIQlBAiEKIAIpA+gBDAYLIARBAEoEQCABKALQBCEFIAJB4ANqIgMgBCABKALUBCIEEO0WIAMgBSAEEK4JIAJB2AJqIgQgA0GAAfwKAAAgAkHMAmoiBSAEENAQIAJBwAJqIAIoAtACIAIoAtQCIgMQoTYgBRDeOwsgAigCQCIEIAMgBmpqIQUgASgCuAQiCEUNASACKALIAiEHIAJB2AJqIAggAigCPCAEIAJBwAJqIgQgASgCvAQoAgwRBwAgAigC2AIiCEEIRg0CIAAgAikC3AI3AgQgAEEUaiACQewCaigCADYCACAAQQxqIAJB5AJqKQIANwIAIAAgCDYCACAEEN47CyACQZgBahCsKQwFCyACQcACaiACKAI8IAQQoTYMAQtBASAFIAIoAsgCIAdrSw0BGiACQcACaiIEIAcQ9DQgBCACKAI8IAIoAkAQoTYLQQALIQQgAkHoA2ogAkHIAmooAgA2AgAgAiACKQLAAjcD4AMgAkHYAmogAkHgA2oQ5xUgASgC9AMhByABKALQAyEIIAEoAvADIQsgAi0ATCENIAIpA5gBIRIgAkHwAWogAkGgAWpB0AD8CgAAIANBGHYhDiADQRB2IQogA0EIdiEJIAIpA+ACIREgAikD2AILIRMgASgCeEGAgICAeEcNASACIBI3A9gCIAJB4AJqIAJB8AFqQdAA/AoAACACIAU2AtgDIAIgDToA1QMgAiAEOgDUAyACIAY2AtADIAIgDjoAzwMgAiAKOgDOAyACIAk6AM0DIAIgAzoAzAMgAiAHNgLIAyACIAg2AsQDIAIgCzYCwAMgAiARNwO4AyACIBM3A7ADIAJB4ANqIAEgAkHYAmoQpAogAigC4AMiA0EIRg0CIAAgAikC5AM3AgQgAEEUaiACQfQDaigCADYCACAAQQxqIAJB7ANqKQIANwIAIAAgAzYCAAsgAkHEAGogAigCPCACKAJAIAIoAjgoAhARAQAMAgsgAiASNwPYAiACQeACaiACQfABakHQAPwKAAAgAiAFNgLYAyACIA06ANUDIAIgBDoA1AMgAiAGNgLQAyACIA46AM8DIAIgCjoAzgMgAiAJOgDNAyACIAM6AMwDIAIgBzYCyAMgAiAINgLEAyACIAs2AsADIAIgETcDuAMgAiATNwOwAyABQfACaiACQdgCahDqIAsgAUEANgLgBCABQQA2AtQEIAEgASkDkAIgATUC9AN8NwOQAiAMEOkgIABBCDYCACACQcQAaiACKAI8IAIoAkAgAigCOCgCEBEBAAsgAkHgBGokAAvHMgMdfwV+AXwjAEHQDGsiAiQAAkACQAJAAkACQCAAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQCIA0EBaw4DCwIBAAsgAEHAAWogAEHAAfwKAAALAkACQAJAAkACQAJAAkACQAJAAkAgAC0A+AJBAWsOAxIKAQALIAJBKGogACgC8AIgACgC9AIQ+iggAkHAAWogAigCKCACKAIsEI81IAAgACsDwAEiJPwDIhM2AswBIAAgJEQAABAAAADwQWIiCDYCyAEgAEHQAWogAkEwakGcAfwKAAAgAEEAOgDsAiAAQewCaiEXIABByAFqIRwMAQsgAEHIAWohHCAAQewCaiEXAkAgAC0A7AJBAWsOAwsJAgALIAAoAswBIRMgACgCyAEhCAsgACATNgLUASAAIAg2AtABIABBADoA8AEgACAAKQPgAjcD2AEgAEHgAWogAEHoAmooAgA2AgAgAEHwAWohEyAAQdABaiEYDAELIABB0AFqIRggAEHwAWohEwJAIAAtAPABQQFrDgQNBwIGAAsgGCgCACEICyAAQYACOwDxASAAIAApAtgBNwLkASAAQewBaiAAQeABaigCADYCACAIQQFxRQ0BIAAoAtQBIQgMDwsgAEH0AWohECAAQYQCaiEMAkAgAC0AhAJBAWsOAwkFAAILIAAoAoACIQkMAgsgAkHYCWogAEHkAWoQ3SAgAEEAOgCEAiAAQfwBaiACQeAJaikCADcCACAAIAIpAtgJNwL0ASAAQYQCaiEMIABB9AFqIRALIAJB2AVqIgQgEEEIaigCADYCACACIBApAgA3A9AFIAJBIGohAwJAQTBBBBCtNiIHBEAgB0EAOgAsIAdBADoAKCAHQQA2AiAgB0EAOgAcIAdBADYCFCAHQQA6ABAgB0EANgIIIAdCgoCAgBA3AgAgAyAHNgIEIAMgBzYCAAwBC0EEQTAQoz0ACyACKAIkIQkgAigCICEDQbgHQQgQrTYiCEUNBSAIIAM2AqAHIAggAikD0AU3AqQHIAhBADoAsAcgCEGsB2ogBCgCADYCACAIQeTGwgAQ1BogACAJNgKAAgsgAkEYaiEHIwBBEGsiDSQAAn8CQCAJQQhqIgktACQNACANQQhqIAEoAgAiAygCBCADKAIAKAIAEQAAIAktABQgDSgCDCESIA0oAgghBCAJQQE6ABRFBEAgCSgCDCIDBEAgCSgCECADKAIMEQMACyAJQQA6ABQgCSASNgIQIAkgBDYCDCAJLQAkDQFBAgwCCyASIAQoAgwRAwALIAktAAghAyAJQQE6AAhBASADDQAaIAlBADoACCAJKAIAIAlBADYCACAJKAIEIRJBAXMLIQMgByASNgIEIAcgAzYCACANQRBqJABBAiEJAkAgAigCGCIDQQJGBEAgDEEDOgAADAELIAIoAhwhCCAAQYACahCsLCADQQFxDQcgDEEBOgAAQQAhCQsgCUECRgRAQQMhCAwRCyAQEJIuIAlBAXFFDQtBBEEEEK02IgNFBEBBBEEEEKM9AAsgAkGQCGoiASADNgIEIAMgCDYCACABQQM2AgAMDgsgAEHAAmohDCAAQdwCaiEQAkAgAC0A3AJBAWsOAwgBAAILIAAoAtgCIQkgACgC1AIhCAwMCwALIAAoAsgCIQggACkDwAIMCQtB/NzCABDoKwALQQhBuAcQoz0AC0G82sIAEOgrAAtBxMrCAEErIAJB0AVqQbTKwgBBzNrCABDVHgALQZzbwgAQ6CsAC0H01sIAEOgrAAtBjN3CABDoKwALQdzIwgAQ6CsACyAAQQA6APIBIAJB4AlqIABB7AFqKAIANgIAIAIgACkC5AE3A9gJQQxBBBCtNiIERQRAQQRBDBCjPQALIAQgAkHYCWoiAykCADcCACAEQQhqIANBCGooAgA2AgAgAkHoBGoiA0IANwMgIANBgCA2AjAgA0GImMMANgIcIAMgBDYCGCADQQA2AhAgA0KAgICAEDcDCCADQgA3AwAgAyAIrTcDKCAAQYgCaiADQTj8CgAAIABBAToA8QEgAEIDNwP4ASAAQQA6ANwCIAAgAEH4AWoiCDYCyAIgAEIANwPAAiAAQdwCaiEQIABBwAJqIQxCAAs3AswCIAJBADoAyAwgAiAINgLADCACIABBzAJqNgLEDCACQRBqIQcgAkHYCWohAwJAQfgCQQgQrTYiBARAIAQgA0H4AvwKAAAgB0HI+MIANgIEIAcgBDYCAAwBC0EIQfgCEKM9AAsgAigCECEIIAAgAigCFCIJNgLYAiAAIAg2AtQCCyACQdgJaiAIIAEgCSgCDBEBAAJAAkAgAigC2AkiBEEJRgRAIBBBAzoAAAwBCyACQaAGaiIBIAJB6AlqKQMANwMAIAIgAikD4Ak3A5gGIAIoAtwJIQMgAEHUAmoQvCoCQCAEQQhHBEAgAkHgBWogASkDADcDACACIAIpA5gGNwPYBSACIAM2AtQFIAIgBDYC0AUgACgCzAIiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEHMAmoQ+CMMAQsgAiAAKQLMAjcD2AkgAkHQBWogAyACQdgJahDtAQsgAkHIBWoiASACQdwFaigCADYCACACIAIpAtQFNwPABSACKQPgBSEfIAIoAtAFIQQgEEEBOgAAIARBCUcNAQtBBCEIDAMLIAJBuAVqIgMgASgCADYCACACIAIpA8AFNwOwBSAMEN8gAkAgBEEIRwRAIAJB5AlqIAMoAgA2AgAgAiACKQOwBTcC3AkgAiAfNwPoCSACIAQ2AtgJIAJBkAhqIAJB2AlqEMgmIAJCBTcDiAgMAQsgAkGoBWogAkG4BWooAgA2AgAgAiACKQOwBTcDoAUgAEEAOgDxASACQdAFaiIMIABB+AFqQcgA/AoAACACQYCAgIB4NgK4BiACQQA2ApgGIAJBgICAgHg2AsQGIAJBADYCqAYgAkEANgKgBiACQQA2ArAGIAJB2AlqIQQgAkGYBmohAyMAQbABayIPJAAgDyACQaAFahDFCiAPKAIMIQkgDygCCCENIA8oAgQhBwJAIA8oAgAiAUEGRwRAIAQgCTYCFCAEIA02AhAgBCAHNgIMIAQgATYCCCAEQgQ3AwACQCAMKAIYQYCAgIB4RwRAIAxBGGoQ3jsMAQsgDCgCECEHIAwoAhQiBCgCACIBBEAgByABEQMACyAEKAIEIgFFDQAgByABIAQoAggQ+DoLIAwoAighByAMKAIsIgQoAgAiAQRAIAcgAREDAAsgBCgCBCIBRQ0BIAcgASAEKAIIEPg6DAELIA9BEGoiASAMQcgA/AoAACAPQYAINgKkASAPIAk2AqABIA8gDTYCnAEgDyAHNgKYASAPQYCAgIB4NgKMASAPQYCAgIB4NgKAASAPQYCAgIB4NgJ0IA9BgICAgHg2AmggD0KAgICAgICAoAY3A6gBIA9BADYCYCAPQQA2AlgjAEGwAmsiBSQAIAMoAgBBAUYEQCABIAEoAogBKAIIIg0gAygCBCIHIAcgDUsbNgKUAQsgAygCCEEBRgRAIAFBATYCSCABIAMoAgw2AkwLIAMoAhBBAUYEQCABQQE2AlAgASADKAIUNgJUCwJAIAMoAixBgICAgHhHBEAgASgCiAFBCGoQhTwhByAFQZABaiADKAIwIAMoAjQgBxDSEyAFQdAAaiINIAVBnAFqKAIANgIAIAUgBSkClAE3A0ggBSgCkAEiB0EGRwRAIAQgBSkDSDcCDCAEIAc2AgggBEIENwMAIARBFGogDSgCADYCAAJAIAEoAhhBgICAgHhHBEAgAUEYahDeOwwBCyABKAIQIQ0gASgCFCIHKAIAIgQEQCANIAQRAwALIAcoAgQiBEUNACANIAQgBygCCBD4OgsgASgCKCENIAEoAiwiBygCACIEBEAgDSAEEQMACyAHKAIEIgQEQCANIAQgBygCCBD4OgsgAUGIAWoiBygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgBxCXFQsgASgCjAEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAFBjAFqEPgjCwJAIAEoApABIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBkAFqENseCyABQdgAahCXMCABQeQAahCGMCABQfAAahCeLyABQfwAahCOMCABKAKYASIERQ0CIAQgBCgCACIEQQFrNgIAIARBAUcNAiABQZgBahCBLAwCCyAFQTBqIhkgDSgCADYCACAFIAUpA0g3AyggBUGQAWogAUGgAfwKAAAgBUHIAGoiBiABQcgA/AoAACAFQUBrIhogAUHgAGoiCCgCADYCACAFQSBqIgwgAUH4AGoiCSgCADYCACAFQRBqIg0gAUGEAWoiBygCADYCACAFIAEpA1g3AzggBSABKQNwNwMYIAUgASkCfDcDCCAFKQOYAiEgIAUpA6ACISEgBSkDqAIhIiAFKQPYASEjIAUpA+ABIR8gBUH0AWoQhjAgASAGQcgA/AoAACABIB83A1AgASAjNwNIIAEgBSkDODcDWCAIIBooAgA2AgAgASAFKQMoNwJkIAFB7ABqIBkoAgA2AgAgASAFKQMYNwNwIAkgDCgCADYCACABIAUpAwg3AnwgByANKAIANgIAIAEgIjcDmAEgASAhNwOQASABICA3A4gBCyADKAIgQYCAgIB4RwRAIAVBkAFqIgcgAUGgAfwKAAAgBUE4aiADQSBqEIkdIAVByABqIgYgB0HIAPwKAAAgBUEwaiIJIAVB/AFqKAIANgIAIAVBIGoiDSAFQYgCaigCADYCACAFQRBqIgcgBUGUAmooAgA2AgAgBSAFKQL0ATcDKCAFIAUpA4ACNwMYIAUgBSkCjAI3AwggBSkDmAIhICAFKQOgAiEhIAUpA6gCISIgBSkD2AEhIyAFKQPgASEfIAVB6AFqEJcwIAEgBkHIAPwKAAAgASAfNwNQIAEgIzcDSCABIAUpAzg3A1ggAUHgAGogBUFAaygCADYCACABIAUpAyg3AmQgAUHsAGogCSgCADYCACABIAUpAxg3A3AgAUH4AGogDSgCADYCACABIAUpAwg3AnwgAUGEAWogBygCADYCACABICI3A5gBIAEgITcDkAEgASAgNwOIAQsgBCABQaAB/AoAAAsgBUGwAmokAAsgD0GwAWokACACQcgFaiIBIAJB6AlqKQMANwMAIAIgAikD4Ak3A8AFAkACQCACKQPYCSIfQgRRBEAgAkGYCGogASkDADcDACACIAIpA8AFNwOQCCACQgU3A4gIIAMQgSoMAQsgAkHoBmogAkHwCWoiBUGIAfwKAAAgAkHgBmogAkHIBWopAwA3AwAgAiAfNwPQBiACIAIpA8AFNwPYBiACQZgGahCBKiACQdgJaiELIwBB4AFrIgYkACAGQSBqIAJB0AZqIgooAogBIhBBCGoiARCEPCAGIAYoAiQiBDYCLCAKQYgBaiEHAkACfwJAIAooAlhBgICAgHhHBEAgBkHYAWogCkHYAGoiAUEIaigCACIbNgIAIAYgASkCADcD0AEgG0ECdCEDQQAhDCAGKALUASESA0AgAyAMRg0CIAwgEmogDEEEaiEMKAIAIARJDQALIAYgDCASakEEazYCMCAGQQI2AowBIAZB4NbDADYCiAEgBkICNwKUASAGQTs2AkwgBkHcATYCRCAGIAZBQGs2ApABIAYgBkEsajYCSCAGIAZBMGo2AkAgC0EMaiAGQYgBahCZDiALQgU3AwAgC0EANgIIIAZB0AFqEOk7IAoQ/RsgCigCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIAcQlxULIAooAowBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAKQYwBahD4IwsCQCAKKAKQASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAKQZABahDbHgsgCkHkAGoQhjAgCkHwAGoQni8gCkH8AGoQjjAgCigCmAEiAUUNAyABIAEoAgAiAUEBazYCACABQQFHDQMgCkGYAWoQgSwMAwsgBkEYaiABEIQ8IAZBiAFqIAYoAhxBkNDDABCKOyAGKAKQASEbIAYoAowBIRIgBygCACEQIAYoAogBDAELIAYoAtABCyEPIBAoAgghHSAKKAKUASEeIAZBiAFqIgQgCkHIAPwKAAAgBkHYAWoiAyAKQfgAaigCADYCACAKKQJwIR8gECAQKAIAIgFBAWo2AgAgBiAfNwPQAQJAIAFBAE4EQCAKKAKcASEZIAooApgBIRogCigCVCEIIAooAlAhDCAKKAJMIQkgCigCSCENIAooApABIRYgBkFAayAEQcgA/AoAACAGQThqIAMoAgA2AgAgBiAGKQPQATcDMAJAAn8gFgRAIBYtABRBIEcNAiAGQRBqIwBBMGsiESQAIBEgCkHkAGo2AgAgEUEEaiEUIwBBQGoiDiQAIA4gETYCDCAOQQA2AhAgFkEYaiIBKAIEIQMgASgCACEBIA4gDkEQajYCGCAOIA5BDGo2AhQgDiABQQhqIgE2AjAgDiABIANBAnRqNgI0IA4gDkEUajYCOCAOQRxqIA5BMGoQixcgDkEgaiEVAkAgDigCHCIEQZOAgIB4RwRAIBQgDigCLDYCECAUIBUpAgA3AgQgFEEMaiAVQQhqKAIANgIADAELIA5BOGogFUEIaigCACIDNgIAIA4gFSkCADcDMCAOIA4oAjQiASABIANBAnRqEJsYIA4pAwAhHyAVEPglIA5BMGpBBEEEEOAeIBQgHzcCBAsgFCAENgIAIA5BQGskACARKAIEQZOAgIB4RwRAIBFBKGogEUEUaigCADYCACARQSBqIBFBDGopAgA3AwAgESARKQIENwMYQbDQwwBBKyARQRhqQaDQwwBB2M/DABDVHgALIBEpAgg3AwAgEUEwaiQAIAYoAhAhBCAGKAIUDAELIAZBCGoQwSwgBigCCCEEIAYoAgwLIQMgBkGIAWoiASAEIAMQzhxBMEEIEK02IgNFDQIgA0KBgICAEDcDACADQQhqIAFBKPwKAAAgCyAKKQJkNwKoASALQbABaiAKQewAaigCADYCACALIAopAnw3ArQBIAtBvAFqIApBhAFqKAIANgIAIAooAogBIQEgCyAGQUBrQcgA/AoAACALIB0gHiAdIB5JGzYCyAEgCyADNgLEASALIAE2AsABIAtBgYCAgHg2AogBIAsgGzYChAEgC0EANgKAASALIBI2AnwgCyAPNgJ4IAsgGTYCcCALIBo2AmwgCyAWNgJoIAsgEDYCZCALIAg2AlQgCyAMNgJQIAsgCTYCTCALIA02AkggC0HgAGogBkE4aigCADYCACALIAYpAzA3A1ggCigCjAEiASABKAIAIgFBAWs2AgAgAUEBRw0DIApBjAFqEPgjDAMLIAZBADYCmAEgBkEBNgKMASAGQbjXwwA2AogBIAZCBDcCkAEgBkGIAWpBwNfDABDvLAsAC0EIQTAQoz0ACyAGQeABaiQAIAJB+AdqIAJB6AlqKQMANwMAIAJBgAhqIAUpAwA3AwAgAiACKQPgCTcD8AcgAkGQCGohASACKQPYCSIfQgVSDQEgASACQfAHahDIJiACQgU3A4gICyACQaAFahCyHwwBCyACQagIaiACQfgJakGwAfwKAAAgAUEQaiACQYAIaikDADcDACABQQhqIAJB+AdqKQMANwMAIAEgAikD8Ac3AwAgAkGgBWoQsh8gAEEAOwDxAQwCCyAALQDxAQRAIABB+AFqEP0bCyAAQQA6APEBCyAALQDyAQRAIABB5AFqEN47CyAAQQA6APIBQgUhHwsgAkHQAWogAkGQCGpByAH8CgAAQQEhCCATQQE6AAAgGBDNIgJ/IB9CBVEEQCACQeAJaiACQdgBaikDADcDACACIAIpA9ABNwPYCSACQdgJahDTGQwBCyACQbADaiACQeABakG4AfwKAAAgAkGoA2ogAkHYAWopAwA3AwAgAiAfNwOYAyACIAIpA9ABNwOgA0EAIQgCfyMAQRBrIgMkAEHQAUEIEK02IgEEQCABIAJBmANqQdAB/AoAACADQQhqIAFB/M/DABCAKSADKAIIIAMoAgwQzSwQgSkgA0EQaiQADAELQQhB0AEQoz0ACwshASAXQQE6AAAMAQsgEyAIOgAAIBdBAzoAAEECIQgLAkAgCEECRgRAQQMhASAAQQM6APgCDAELIBwQ9SwgAEEBOgD4AgJAIAhBAXEEQCACIAE2AogIIAJBgAE2AtgJIAIgAEGEA2ogAkHYCWogAkGICGoQwiMgAigCACACKAIEENYvIgFBhAFPBEAgARDyHwsgAigC2AkiAUGEAU8EQCABEPIfCyACKAKICCIBQYQBSQ0BIAEQ8h8MAQsgAiABNgKICCACQYABNgLYCSACQQhqIABBgANqIAJB2AlqIAJBiAhqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoAtgJIgFBhAFPBEAgARDyHwsgAigCiAgiAUGEAUkNACABEPIfCyAAKAKAAyIBQYQBTwRAIAEQ8h8LQQEhASAAKAKEAyIDQYQBSQ0AIAMQ8h8LIAAgAToAiAMgAkHQDGokACAIQQJGC/4RAx1/A30CfiMAQRBrIhYkACAHKAIUIRQgASACIAggCSANIA4gDyAQEIYPIA0oAgwiCSACSwRAIAkgDkEAIA4oAuABIhNrQQdxQRxsaiISKAIQIhFLBEBBAiEXIA0oAggiISACQQJ0aiEiAkACQCACQQJqIhggAEsNACASKgIYIA0qApQWkiAiKgIAICEgEUECdGoqAgCTkiEuIAJBFGwgD2pBLGohEUEKIQlBBCESA0AgAiAXaiAQTw0CIBFBBGsoAgAEfUMAAAAABSARKgIACyAuX0UNASAuQwAAgD+SIC4gF0EBaiIXIAlGIhsbIS4gEUEUaiERIBJBACAbGyAJaiEJIBIgG3QhEiACIBdqIABNDQALCwJAIBNFBEBBACEUDAELIAggASACaiIcIAggHEkbISNBlgFBxQIgFEELSCIBGyEoIAAgAmshJCATQQFBBSABGyIAIAAgE0sbISkgDUEQaiElIAMgBSAccSIdaiEqIAQgHWshKyAXQQFrIRsgBzUCBCEyIAcoAgghLCANKAIAISYgDSgCBCEeQQAhFEEAIRgDQAJAAkACQAJAIAIgDiAYIgAgDigC4AFrQQdxQRxsaiIZKAIQayITQQZPBEAgE0GCAU8EQCATQcIQSQ0CQRUhASATQcIwSQ0EQRZBFyATQcKwAUkbIQEMBAsgE0ECayIBZ0EgakE/c0EBayIHQQF0IAEgB3ZqIgdBAmoiAUH//wNxIREgB0EWTw0CDAQLIBMhAQwCCyATQcIAa2dBIGpBP3NBCmohAQwBCyARQRhBhLPQABDDIQALIAFB//8DcSERCyAAQQFqIRggGSoCFCARQQJ0QYif4gBqKAIAs5IgIioCACAhKgIAk5IhLiABQQN0QThxISAgAUH4/wNxQQN2QQNsISdBACEIIBshBwJAAkADQAJAIAcgJE8NACAHIB1qIg0gBE8NAiAFIA1JDQAgJiAIQQJ0aiEJIAhBG3RBgICAQGshEiADIA1qLQAAIRogCCERA0ACQCAZIBFBhLHQAGotAABBA3FBAnRqKAIAIBFBlLHQAGosAABqIh8gI0sNACAcIB9rIgggHE8NACAFIAhxIgggB2oiDSAFSw0AAkACQAJAAkACQAJAIAQgDUsEQCAaIAMgDWotAABHDQcgBCAISQ0BIAQgHUkNAiADIAhqIAQgCGsgKiArICQQsiAgCCAGEKEuIQ0gESAeTw0DAkAgByANTw0AIC4gCSoCAJIhMCASIBNyIRogB0EBaiEJIBFFIAFB//8DcUEISXFFIRUDQEH+/wMhEgJ9AkAgCUEKTwR/IAlBhgFPBEBBFyEHIAlBxhBJBEAgCUHGAGtnQSBqQT9zQQxqIQcLIAdBB3EgIHIhCCAHIRIMAgtBBCESIAlBBmsiB2dBIGpBP3NBAWsiCEEBdCAHIAh2agUgCQsgEmoiEkEHcSAgciEIIBUgEkH//wNxIgdBD0tyRQRAIAggCEHAAHIgB0EISRshEiAuIAdBAnRByKDiAGooAgCzkgwCCyAHQRhPDQgLIAggEkH4/wNxQQN2ICdqIhJBBnRBwJrIAiASQQF0dkHAAXFqQUBrIi1yQf//A3EhEiAtQcD/A3EiCEHABU8NCCAuIDAgCEGAAUkbIAdBAnRByKDiAGooAgCzkgsgAiAJaiIHIBBPDQggJSASQQJ0aioCAJIhLyAPIAdBFGxqIgcoAgAEfUMAAAAABSAHKgIECyAvXgRAIAcgGjYCECAHIB82AgwgByAvOAIEIAdBADYCACAHIAlBgICAkAFyNgIIIAkgFCAJIBRLGyEUCyAJIA1JIggEQCAIIAkiB2oiCCEJIAggDU0NAQwCCwsgCSEHCyARQQFqIQggEUEOSw0JDAoLIA0gBEG0sdAAEMMhAAsgCCAEQcSx0AAQrzsACyAdIARB1LHQABCvOwALIBEgHkG8tdAAEMMhAAsgB0EYQaSy0AAQwyEACyASQcAFQay10AAQwyEACyAHIBBB5LHQABDDIQALIAlBBGohCSASQYCAgEBrIRIgEUEBaiIRQRBHDQALCwsgCkUgAEEBS3INAUEAIRIgFyERAkADQCAMIBJGDQEgCyASQQN0aikDACExIBZBADsBCiAWQQA2AgwgMaciGUEPaiAsIDIgFkEKaiAWQQxqEJYYIBYvAQoiAUH/B3EiACAeSQRAIBEgMUIliKciByAHIBFJGyIIIAggESAHIChLGyAZICNLIh8bIhEgB00EQCAuIAFBCnazkiAmIABBAnRqKgIAkiEvIAdBAWohASARQRl0QYCAgJABaiEAIDFCIIinQR9xIgggByAIGyEaIA8gAiARakEUbGohCQNAQf7/AyEIIBogESAfGyIHIQ0CQAJAAkACQAJAIAdBCk8EfyAHQYYBTwRAQRchDSAHQcYQSQRAIAdBxgBrZ0EgakE/c0EMaiENCyANIQgMAgsgB0EGayIIZ0EgakE/c0EBayINQQF0IAggDXZqIQ1BBAUgCAsgDWoiCEH//wNxIg1BGE8NAQsgCEH4/wNxQQN2ICdqIhVBBnRBwJrIAiAVQQF0dkHAAXFqQUBrIhUgCEEHcSAgcnJB//8DcSEIIBVBwP8DcUHABU8NASACIBFqIhUgEE8NAiAJKAIADQMgLyANQQJ0Qcig4gBqKAIAs5IgJSAIQQJ0aioCAJIiMCAJQQRqIggqAgBdRQ0DIAlBADYCACAJQRBqIBM2AgAgCUEMaiAZNgIAIAggMDgCACAJQQhqIAAgB0EZdGsgEXI2AgAgESAUIBEgFEsbIRQMAwsgDUEYQaSy0AAQwyEACyAIQcAFQay10AAQwyEACyAVIBBBhLLQABDDIQALIAlBFGohCSAAQYCAgBBqIQAgASARQQFqIhFHDQALIAEhEQsgEkEBaiISIApHDQEMBAsLIAAgHkG8tdAAEMMhAAsgDCAMQfSx0AAQwyEACyANIARBpLHQABDDIQALIBggKUcNAAsLIBZBEGokACAUDwsgECAYIBAgGEsbIBBB7LTQABDDIQALIBEgCUHctdAAEMMhAAsgAiAJQcy10AAQwyEAC6xMAh5/CH4jAEHQAmsiAyQAIAMgATYCIAJAAkACQAJAAkAgAigCACIFBEAgAyAFNgIkIAUgBSgCACICQQFqNgIAIAJBAEgNAiADIAE2ArgBIAEoAjQhASADIAU2ArwBIANBgICAgHg2AqACIANBKGogAUEIaiADQaACaiAFQQhqIgEQsAoCQAJAIAMoAigiAkGCgICAeEYEQCADQfwBaiADQUBrKQMAIiE3AgAgA0H0AWogA0E4aikDACIiNwIAIAMgAykDMCIjNwLsASAAQRBqICE3AgAgAEEIaiAiNwIAIAAgIzcCAAwBCyADQYACaiADQcQAaigCACIFNgIAIANB+AFqIANBPGopAgAiITcDACADQcwBaiADQTRqKQIANwIAIANB1AFqICE3AgAgA0HcAWogBTYCACADIAMpAiw3AsQBIAMgAykDSCIhNwLgASADIAI2AsABIAMgITcChAIgA0EYaiADQYQCaiICEMM0IAMgAygCHCIFNgKMAiADQRBqIAEQwzQgAyADKAIUIgc2ApACAkAgBSAHRgRAIANBADYCnAIgA0KAgICAwAA3ApQCIANBCGogARDDNCADKAIMIQUgAygCCCEBIAMgAhDDNCADQaACaiABIAEgBUECdGogAygCACIBIAEgAygCBEECdGoQiyggAygCtAIiAiADKAKwAiIBSwRAIAIgAWshAiABQQJ0IgEgAygCoAJqIQUgAygCqAIgAWohAQNAIAUoAgBBMGogASgCAEEwahC5CEUEQCADIAUoAgBBPGo2AsQCIAMgBSgCAEEwajYCyAIgAyABKAIAQTBqNgLMAiADQQA2AvgBIANBAzYC7AEgA0H4p88ANgLoASADQa8DNgI8IANBrwM2AjQgA0GEATYCLCADIANBzAJqNgI4IAMgA0HIAmo2AjAgAyADQcQCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakGQqM8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAgsgBSgCACIILQBIIAEoAgAiBy0ASEcEfyADIAhBPGo2AswCIAMgBSgCAC0ASDoAxAIgAyABKAIALQBIOgDIAiADQQA2AvgBIANBAzYC7AEgA0HMqM8ANgLoASADQaQINgI8IANBpAg2AjQgA0GEATYCLCADIANByAJqNgI4IAMgA0HEAmo2AjAgAyADQcwCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakHkqM8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAiABKAIAIQcgBSgCAAUgCAtBCGogB0EIahDlDEUEQCADIAUoAgBBPGo2AsQCIAMgBSgCAEEIajYCyAIgAyABKAIAQQhqNgLMAiADQQA2AvgBIANBAzYC7AEgA0GQqc8ANgLoASADQaUINgI8IANBpQg2AjQgA0GEATYCLCADIANBzAJqNgI4IAMgA0HIAmo2AjAgAyADQcQCajYCKCADQQM2AvQBIAMgA0EoajYC8AEgA0G4AmogA0HoAWoQmQ4gAygCnAIiByADKAKUAkYEQCADQZQCakGoqc8AEJAoCyADKAKYAiAHQQxsaiIIIAMpArgCNwIAIAhBCGogA0HAAmooAgA2AgAgAyAHQQFqNgKcAgsgBUEEaiEFIAFBBGohASACQQFrIgINAAsLIAMoApwCIgIEQCADQegBaiIBIAMoApgCIAJBlKfPAEECEOQ6IANBATYCLCADQbynzwA2AiggA0IBNwI0IANBpgg2ArwCIAMgA0G4Amo2AjAgAyABNgK4AiAAQQRqIANBKGoQmQ4gAEEDNgIAIAEQ3jsgA0GUAmoiABDRKyAAEOg7DAILIAMoArwBIQIgAygCuAEhBwJAIAMoAsABIgFBgYCAgHhGBEBBACEFDAELQShBBBCtNiIFRQ0IIAUgATYCCCAFQoGAgIAQNwIAIAUgA0HEAWoiASkCADcCDCAFQRRqIAFBCGopAgA3AgAgBUEcaiABQRBqKQIANwIAIAVBJGogAUEYaigCADYCAAsgACAFNgIMIAAgAjYCCCAAIAc2AgQgAEEINgIAIANBlAJqIgAQ0SsgABDoOyADKAKEAiIAIAAoAgAiAEEBazYCACAAQQFHDQMgA0GEAmoQhR0MAwsgA0ECNgIsIANB+KnPADYCKCADQgI3AjQgA0E7NgL0ASADQTs2AuwBIAMgA0HoAWo2AjAgAyADQZACajYC8AEgAyADQYwCajYC6AEgA0GgAmoiASADQShqEJkOIABBBGogARDdICAAQQM2AgAgARDeOwsgAygChAIiACAAKAIAIgBBAWs2AgAgAEEBRgRAIANBhAJqEIUdCyADQcABahC2LyADKAK8ASEFCyAFIAUoAgAiAEEBazYCACAAQQFGBEAgA0G8AWoQ+CMLIAMoArgBIgAgACgCACIAQQFrNgIAIABBAUcNACADQbgBahCXFQsgAygCJCIAIAAoAgAiAEEBazYCACAAQQFHDQEgA0EkahD4IwwBC0EAIQUgAi0ABUUEQCABQRxqQQAgASgCHEGAgICAeEcbIQULIAEoAjQgA0GAgICAeDYC6AEgA0EoaiERQQhqIRwgA0HoAWohGyMAQaACayIEJAACQAJAIAVFDQAgBSgCBCIHIAUoAghBGGxqIQsjAEEwayIFJAAgBUEgakGons8AEKUrIAVBCGoiCkGwnM8AKQMANwMAIAVBGGoiDiAFKQMoNwMAIAVBEGoiCCIMIAUpAyA3AwAgBUGonM8AKQMANwMAIwBBQGoiAiQAIAVBACAIEN0rIAcgC0cEQCAHQQxqIQggCyAHa0EYbiELIAJBGGohBgNAAkAgCCgCAEGAgICAeEYNACACQQxqIgkgCEEMaxDdICAGIAgQ3SAgAkEIaiITIAZBCGooAgA2AgAgAiAGKQIANwMAIAIoAgwiEkGAgICAeEYNACACKQIQISEgAkE4aiATKAIANgIAIAIgAikDADcDMCACICE3AiggAiASNgIkIAkgBSACQSRqIAJBMGoQzgkgCRCGMAsgCEEYaiEIIAtBAWsiCw0ACwsgAkFAayQAIARB0AFqIgJBGGogDikDADcDACACQRBqIAwpAwA3AwAgAkEIaiAKKQMANwMAIAIgBSkDADcDACAFQTBqJAAgBCgC3AFFBEAgAhCTJwwBCyAEQegAaiICIARB3AFqKQIANwMAIARB8ABqIgcgBEHkAWopAgA3AwAgBEH4AGoiBSAEQewBaigCADYCACAEIAQpAtQBNwNgIAQoAtABIhBFDQAgBEEUaiACKQMANwIAIARBHGogBykDADcCACAEQSRqIAUoAgA2AgAgBCAQNgIIIAQgBCkDYDcCDAwBCyAEQdABakGons8AEKUrIARBEGpBsJzPACkDADcDACAEQaiczwApAwA3AwggBCAEKQPYATcDICAEIAQpA9ABNwMYCyAEQdQAaiEGIwBBIGsiCCQAIAhBCGohCyAEQQhqIgJBEGpBvNnPAEEMENEMISFBACEKIwBBEGsiCSQAIAIoAgAiDkEYayETIAIoAgQiDCAhp3EhBSAhQhmIQv8Ag0KBgoSIkKDAgAF+ISQCQAJAA0ACQCAFIA5qKQAAIiMgJIUiIUJ/hSAhQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIiFQRQRAA0BBvNnPAEEMIBNBACAheqdBA3YgBWogDHFrIhJBGGxqEJ82DQIgIUIBfSAhgyIhUEUNAAsLICMgI0IBhoNCgIGChIiQoMCAf4NQRQ0CIAUgCkEIaiIKaiAMcSEFDAELCyAJIA4gEkEYbGoiDjYCDEGAASEFIAIoAgAiCiAKIAlBDGooAgBrQRhtIgxqIhMpAAAiISAhQgGGg0KAgYKEiJCgwIB/g3qnQQN2IAogAigCBCAMQQhrcWoiCikAACIhICFCAYaDQoCBgoSIkKDAgH+DeadBA3ZqQQdNBEAgAiACKAIIQQFqNgIIQf8BIQULIBMgBToAACAKQQhqIAU6AAAgAiACKAIMQQFrNgIMIAsgDkEYayICKQIANwIAIAtBEGogAkEQaikCADcCACALQQhqIAJBCGopAgA3AgAMAQsgC0GAgICAeDYCAAsgCUEQaiQAAkAgCCgCCEGAgICAeEYEQCAGQYCAgIB4NgIADAELIAYgCCkCFDcCACAGQQhqIAhBHGooAgA2AgAgCEEIahDeOwsgCEEgaiQAAkACQAJAAkACQAJAAkACQAJAIAQoAlRBgICAgHhHBEAgBEGQAWogBEHcAGooAgAiBzYCACAEIAQpAlQ3A4gBIARBlAFqIRMgBCgCjAEhCyMAQSBrIg4kACAOIAdBA3EiAjYCACAOIAdBAnYgAkEAR2pBA2w2AgQgDigCACEIIA5BCGoiHSAOKAIEQYzzzgAQzhggDkEUaiEFIA4oAgwhFiAOKAIQIRRBACECQQAhCiMAQRBrIhUkAEH62c8ALQAAIRBB+dnPAC0AACEXIBVBCGohBgJAAkAgCEEBRw0AIAdBAWshCQJAIAcEQCAJIAtqLQAAIgxBPUcNAQwCCyAJQQBBrJaBARDDIQALIAxBu9rPAGotAABB/wFHDQAgBiAMrUIIhiAJrUIghoQ3AgAMAQsgByAIayIJQQAgByAJTxsiCSAJQQRrIgxBACAJIAxPGyAIGyIIQQJ2QQNsIBRNBEAgBkEFOgAAIAYgCDYCBAwBCyAGQQQ6AAALAkACQAJAAkACQAJAAkACQCAHAn8gFS0ACEEFRgRAIBUoAgwMAQsgFSkDCCIhQv8Bg0IFUg0BICFCIIinCyIMQWBxIg9PBEAgD0UNAgJAAkADQAJAAkAgFCACQRhqIghPBEACQAJAIAogC2oiCS0AACIGQbvazwBqMQAAIiFC/wFRDQAgCUEBai0AACIGQbvazwBqMQAAIiJC/wFRBEAgCkEBaiEKDAELIAlBAmotAAAiBkG72s8AajEAACIjQv8BUQRAIApBAmohCgwBCyAJQQNqLQAAIgZBu9rPAGoxAAAiJEL/AVEEQCAKQQNqIQoMAQsgCUEEai0AACIGQbvazwBqMQAAIiVC/wFRBEAgCkEEaiEKDAELIAlBBWotAAAiBkG72s8AajEAACImQv8BUQRAIApBBWohCgwBCyAJQQZqLQAAIgZBu9rPAGoxAAAiJ0L/AVEEQCAKQQZqIQoMAQsgCUEHai0AACIGQbvazwBqMQAAIihC/wFSDQEgCkEHaiEKCyAFQQI2AgAgBSAGrUIIhiAKrUIghoQ3AgQMCgsgAiAWaiINICJCNIYgIUI6hoQiISAjQi6GhCIiICRCKIaEICVCIoaEIiMgJkIchoQiJEIIiEKAgID4D4MgI0IYiEKAgPwHg4QgIkIoiEKA/gODICFCOIiEhD4AACANQQRqICQgJ0IWhoQgKEIQhoQiIUKAgPwHg0IYhiAhQoCAgPgPg0IIhoRCIIg9AABBCCEGIAlBCGotAAAiAkG72s8AajEAACIhQv8BUg0BDAILIAJBGGogFEGsl4EBELA7AAtBCSEGIAlBCWotAAAiAkG72s8AajEAACIiQv8BUQ0AQQohBiAJQQpqLQAAIgJBu9rPAGoxAAAiI0L/AVENAEELIQYgCUELai0AACICQbvazwBqMQAAIiRC/wFRDQBBDCEGIAlBDGotAAAiAkG72s8AajEAACIlQv8BUQ0AQQ0hBiAJQQ1qLQAAIgJBu9rPAGoxAAAiJkL/AVENAEEOIQYgCUEOai0AACICQbvazwBqMQAAIidC/wFRDQBBDyEGIAlBD2otAAAiAkG72s8AajEAACIoQv8BUQ0AIA1BBmogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BCmogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AAEEQIQYgCUEQai0AACICQbvazwBqMQAAIiFC/wFRDQJBESEGIAlBEWotAAAiAkG72s8AajEAACIiQv8BUQ0CQRIhBiAJQRJqLQAAIgJBu9rPAGoxAAAiI0L/AVENAkETIQYgCUETai0AACICQbvazwBqMQAAIiRC/wFRDQJBFCEGIAlBFGotAAAiAkG72s8AajEAACIlQv8BUQ0CQRUhBiAJQRVqLQAAIgJBu9rPAGoxAAAiJkL/AVENAkEWIQYgCUEWai0AACICQbvazwBqMQAAIidC/wFRDQJBFyEGIAlBF2otAAAiAkG72s8AajEAACIoQv8BUQ0CIA1BDGogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BEGogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AAEEYIQYgCUEYai0AACICQbvazwBqMQAAIiFC/wFRDQNBGSEGIAlBGWotAAAiAkG72s8AajEAACIiQv8BUQ0DQRohBiAJQRpqLQAAIgJBu9rPAGoxAAAiI0L/AVENA0EbIQYgCUEbai0AACICQbvazwBqMQAAIiRC/wFRDQNBHCEGIAlBHGotAAAiAkG72s8AajEAACIlQv8BUQ0DQR0hBiAJQR1qLQAAIgJBu9rPAGoxAAAiJkL/AVENA0EeIQYgCUEeai0AACICQbvazwBqMQAAIidC/wFRDQNBHyEGIAlBH2otAAAiAkG72s8AajEAACIoQv8BUQ0DIA1BEmogIkI0hiAhQjqGhCIhICNCLoaEIiIgJEIohoQgJUIihoQiIyAmQhyGhCIkQgiIQoCAgPgPgyAjQhiIQoCA/AeDhCAiQiiIQoD+A4MgIUI4iISEPgAAIA1BFmogJCAnQhaGhCAoQhCGhCIhQoCA/AeDQhiGICFCgICA+A+DQgiGhEIgiD0AACAIIQIgDyAKQSBqIgpHDQEMBgsLIAVBAjYCACAFIAYgCmqtQiCGIAKtQgiGhDcCBAwFCyAFQQI2AgAgBSAGIApqrUIghiACrUIIhoQ3AgQMBAsgBUECNgIAIAUgBiAKaq1CIIYgAq1CCIaENwIEDAMLIA8gB0HsloEBELA7AAsgBUECNgIAIAUgITcCBAwBCyAMQQJ2IghBA2whCSAPQQJ2IgZBA2whAiAGIAhLDQEgCSAUSw0CIAcgDEkNAwJ/AkAgDEEccSIYBEAgAiAWaiEZIAkgAmshDSALIA9qIRpBACEGQQMhAgNAIAIgDUsNCCAGIBpqIgotAAAiCEG72s8Aai0AACIeQf8BRg0CIAYgD2oiEkEBaiAKQQFqLQAAIghBu9rPAGotAAAiH0H/AUYNAxogEkECaiAKQQJqLQAAIghBu9rPAGotAAAiIEH/AUYNAxogEkEDaiAKQQNqLQAAIghBu9rPAGotAAAiCkH/AUYNAxogAiAZakEDayIIQQJqICBBDnQiEiAKQQh0ckEIdjoAACAIIBIgH0EUdCIIckEIdkGA/gNxIAggHkEadHJBGHZyOwAAIAJBA2ohAiAYIAZBBGoiBkcNAAsLIBdBAXEhGUEAIQZBACEKQQAhDUEAIRJBACEIIwBBEGsiDyQAIA9BADYCDAJAAn4CfwJAAkAgByAMTwRAQQAgByAMRg0DGiAHIAtqIRcgCyAMaiEKA0BBACELA0AgCyANaiEYIAogC2oiGi0AACICQT1HBEAgDCASaq1CIIZCgPoAhCALDQcaIAJBu9rPAGotAAAiCEH/AUYNBCAGQQRHBEAgGEEBaiENIA9BDGogBmogCDoAACAGQQFqIQYgAiEIIBpBAWoiCiAXRw0DQQAMBwtBBEEEQcyWgQEQwyEACyAYQQJPBEAgEiAYIAsbIRIgCiALQQFqIgtqIBdGDQUMAQsLCyAMIA1qIAtqrUIghkKA+gCEDAQLIAwgB0G8loEBEK87AAsgAq1CCIYgDCANaiALaq1CIIaEDAILIBcgCmsLIQ0CQAJAAkACQCAHQQAgBkECSRtFBEAgEEH/AXFBAWsOAgECAwsgBiAMaq1CIIZCAYQMBAsgBiANakEDcUUNAQwCCyANDQELIBlBASAPLQANQRR0IA8tAAxBGnRyIA8tAA5BDnRyIA8tAA9BCHRyIgsgBkEGbCICQRhxdBsEQCAGQQJPBEBBASACQQN2IgIgAkEBTRshBwNAIAkgFmohCCAKQYB+cUEFckEEIAJBgH5xQQVyIAkgFE8bIgIgAkEFcUEFRhsiCkEFcUEFRwRAIAqtIAitQiCGhAwFCyAIIAtBGHY6AAAgCUEBaiEJIAtBCHQhCyAHQQFrIgcNAAsLIAUgCTYCCCAFIAwgEmo2AgQgBSANQQBHNgIADAMLIAYgDGpBAWutQiCGIAitQv8Bg0IIhoRCAoQMAQtCAwshISAFQQI2AgAgBSAhNwIECyAPQRBqJAAMAgsgBiAPagshAiAFQQI2AgAgBSACrUIghiAIrUIIhoQ3AgQLIBVBEGokAAwECyACIAlB/JaBARCxOwALIAkgFEH8loEBELA7AAsgDCAHQYyXgQEQsDsACyACIA1BnJeBARCwOwALIA4pAhghIQJAAkACQCAOKAIUQQJGBEAgIUL/AYNCBFENAiATQYCAgIB4NgIAIBMgITcCBCAdEN47DAELIA5BCGogIUIgiKcQ9DQgE0EIaiAOQRBqKAIANgIAIBMgDikCCDcCAAsgDkEgaiQADAELIwBBIGsiACQAIABBATYCBCAAQazwzgA2AgAgAEIBNwIMIABCuPPOgMAZNwMYIAAgAEEYajYCCCAAQcDzzgAQ7ywACwJAIAQoApQBQYCAgIB4RgRAIAQgBCkCmAE3A/gBIARBAjYC1AEgBEG03c8ANgLQASAEQgI3AtwBIARBpwg2ArgBIARBzAE2ArABIARBwNzPADYCrAEgBCAEQawBajYC2AEgBCAEQfgBajYCtAEgBEHsAGogBEHQAWoQmQ5BACEFQQMhBwwBCyAEQagBaiAEQZwBaigCACIFNgIAIAQgBCkClAE3A6ABIAQoAqQBIQcCQCAFQQlJDQAgB0G73M8AEIg7RQ0AIAdBCGohByAFQQhrIQULIARBrAFqIgIgByAFELcBAn8CQCAEKAKsAUGKgICAeEcEQCAEQdABaiIFIAJBJPwKAAAgBEECNgL8ASAEQfTczwA2AvgBIARCAjcChAIgBEGoCDYCnAIgBEHMATYClAIgBEHA3M8ANgKQAiAEIARBkAJqNgKAAiAEIAU2ApgCIARB7ABqIARB+AFqEJkOQQAhBQJ/AkACQAJAAkACQAJAAkBBASAEKALQASICQYCAgIB4cyACQQBOGw4HAAECAwQFBgkLIARB4AFqEIYwIARB1AFqDAYLIARB3AFqEIYwIARB6AFqEIYwIARB0AFqDAULIARB1AFqDAQLIARB1AFqDAMLIARB4AFqEIYwIARB1AFqDAILIARB1AFqDAELIARB1AFqCyICENUmIAIQ4DsMAQsgBCgCuAEiBUEEaiEHIAVBe0sNBiAHIAQoArQBIgJLDQcgBEHQAWoiByAEKAKwASIIIAIgBSAFIAhqIhAoAABrEPY0AkAgB0EGEMwgQf//A3EiC0UNACAFIAtqIgsgAksNCSAIIAtqLQAAQQFHDQAgByAIIAIgBSAQKAAAaxD2NCAHQQgQzCBB//8DcSILRQ0AIAUgC2oiBUEEaiELIAVBe0sNCiACIAtJDQwgBCACNgJkIAQgCDYCYCAEIAUgCGooAAAgBWo2AmggByAEQeAAaiICELcDIAQoAtABRQ0AIAIgB0Eo/AoAACAEKAJgIQUgBCgCaAwCC0EAIQUgBEHgAGpBH0EAQQFBARCgGCAEKAJkIQcgBCgCYEEBRg0KIAQoAmgiAkEXakHb3c8AKQAANwAAIAJBEGpB1N3PACkAADcAACACQQhqQczdzwApAAA3AAAgAkHE3c8AKQAANwAAIARBHzYCdCAEIAI2AnAgBCAHNgJsC0EDCyEHIARBoAFqEN47CyAEQYgBahDeOyAEKAJsIRAgBCgCcCEPIAQoAnQhDSAEKAJ4IRQgBCgCfCEVIAUEQCAEKAJkIRYgBCkDgAEhIgwCCyARQYKAgIB4NgIoIBEgFTYCFCARIBQ2AhAgESANNgIMIBEgDzYCCCARIBA2AgQgESAHNgIAIARBCGoQkycgGxCGMAwCC0EAIQULIAQgIjcDSCAEIBU2AkQgBCAUNgJAIAQgDTYCPCAEIA82AjggBCAQNgI0IAQgBzYCMCAEIBY2AiwgBCAFNgIoIARB0AFqIgIgHCAbIAUEfyACIARBMGoQ+CggBEHoAGogBEHYAWopAwA3AwAgBEHwAGogBEHgAWopAwA3AwAgBCAEKQPQATcDYCAEIARBCGo2AqwBIAQoAugBIQsjAEEwayIHJAAgBEHgAGoiCSgCCCEKIAkoAhAhDiAHQSRqIRUgBEGsAWooAgAhAiAJKQMAISEDQAJAIAkgIVAEfgJAIAsEQANAIA5BwAFrIQ4gCikDACAKQQhqIQpCgIGChIiQoMCAf4MiIUKAgYKEiJCgwIB/UQ0ADAILAAsgB0EwaiQADAILIAkgCjYCCCAJIA42AhAgIUKAgYKEiJCgwIB/hQUgIQsiIiAiQgF9gyIhNwMAIAdBDGoiBSAOICJ6p0EDdkFobGoiE0EYaxDdICAHQRhqIgwhCEEAIQYgAkEQaiISIAUQ+AshIyACKAIEIg8gI6dxIRAgI0IZiEL/AINCgYKEiJCgwIABfiElIAUoAgghFiAFKAIEIRcgAigCACENAkACQANAAkAgDSAQaikAACIkICWFIiJCf4UgIkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIiUEUEQANAIA0gInqnQQN2IBBqIA9xQWhsaiIUQRRrKAIAIBRBEGsoAgAgFyAWEMEuDQIgIkIBfSAigyIiUEUNAAsLICQgJEIBhoNCgIGChIiQoMCAf4NQRQ0CIBAgBkEIaiIGaiAPcSEQDAELCyAIQYCAgIB4NgIIIAggAjYCBCAIIBQ2AgAgBRDeOwwBCyACQQEgEhDdKyAIIAI2AhQgCCAjNwMAIAhBEGogBUEIaigCADYCACAIIAUpAgA3AggLIAcoAiAiBUGAgICAeEcEQCAHKAIsIRAgBykDGCEiIAcgBykCJDcCHCAHIAU2AhggFSATQQxrEN0gIBAoAgAiCCAQKAIEIg8gIqciDXEiBWopAABCgIGChIiQoMCAf4MiIlAEQEEIIQYDQCAFIAZqIQUgBkEIaiEGIAggBSAPcSIFaikAAEKAgYKEiJCgwIB/gyIiUA0ACwsgCCAieqdBA3YgBWogD3EiBWosAAAiBkEATgRAIAggCCkDAEKAgYKEiJCgwIB/g3qnQQN2IgVqLQAAIQYLIAUgCGogDUEZdiINOgAAIAggBUEIayAPcWpBCGogDToAACAQIBAoAgggBkEBcWs2AgggECAQKAIMQQFqNgIMIAggBUFobGpBGGsiBSAMKQIANwIAIAVBCGogDEEIaikCADcCACAFQRBqIAxBEGopAgA3AgALIAtBAWshCwwBCwsgBEEoakEAIAQoAigbBUEACxCwCiAEKALQASICQYKAgIB4RgRAIARB9ABqIARB6AFqKQMAIiE3AgAgBEHsAGogBEHgAWopAwAiIjcCACAEIAQpA9gBIiM3AmQgEUEQaiAhNwIAIBFBCGogIjcCACARICM3AgAgEUGCgICAeDYCKCAEQShqEIUrIARBCGoQkycMAQsgBEH4AGogBEHsAWooAgAiBTYCACAEQfAAaiAEQeQBaikCACIhNwMAIARB6ABqIARB3AFqKQIAIiI3AwAgBCAEKQLUASIjNwNgIAQpA/ABISQgEUHEAGogBTYCACARQTxqICE3AgAgEUE0aiAiNwIAIBEgIzcCLCARQSBqIARBIGopAwA3AwAgEUEYaiAEQRhqKQMANwMAIBFBEGogBEEQaikDADcDACARIAQpAwg3AwggESACNgIoIBEgJDcDACAEQShqEIUrCyAEQaACaiQADAYLIAUgB0GEpM8AELE7AAsgByACQYSkzwAQsDsACyALIAJB0JvPABCvOwALIAUgC0H0o88AELE7AAsgByAEKAJoQeSjzwAQ/S8ACyALIAJB9KPPABCwOwALIAMoAlAiB0GCgICAeEYEQCADQdABaiADQThqKQMAIiE3AwAgA0HIAWogA0EwaikDACIiNwMAIAMgAykDKCIjNwPAASAAQRBqICE3AwAgAEEIaiAiNwMAIAAgIzcDACABIAEoAgAiAEEBazYCACAAQQFHDQEgA0EgahCXFQwBCyADQcABaiICIANBKGpBKPwKAAAgA0GwAWoiCCADQewAaigCADYCACADQagBaiILIANB5ABqKQIANwMAIANBoAFqIhAgA0HcAGopAgA3AwAgAyADKQJUNwOYASADQfAAaiIFIAJBKPwKAABBMEEIEK02IgJFDQMgAkKBgICAEDcDACACQQhqIAVBKPwKAABBACEFIAdBgYCAgHhHBEBBKEEEEK02IgVFDQUgBSAHNgIIIAVCgYCAgBA3AgAgBSADKQOYATcCDCAFQRRqIBApAwA3AgAgBUEcaiALKQMANwIAIAVBJGogCCgCADYCAAsgACAFNgIMIAAgAjYCCCAAIAE2AgQgAEEINgIACyADQdACaiQADwsAC0EEQSgQoz0AC0EIQTAQoz0AC0EEQSgQoz0AC5gUAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPUeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqENMeIAkoAkAEQCAJKQNIIhNCgIACfEKAgARUDQILIAlBkAJqQYOGjBg2AgAgCUKDhoyYsODAgQM3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAUY3AQYgAEEMaiAJQcwAaikBADcBACAAIAkvAUQ7AQQgAEGCgICAeDYCAAsgCUEMahC4LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCtKAsgCSgCECAIQQF0aiATPQEACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahDTHkEAIQogCSgCQEEBRw0AIAkpA0giFEKAgAJ8QoCABFQhCiAUpyEICyAJQQxqIAogCBDeCwwBCyANEOY6IAkoAhhFDQMgCSgCKEEBaiIOQQN2IA5BB3FBAEdqIgogCSgCJCIISwRAIAogCGshCyAJKAIcIhIgCkkEQCANIBJBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIhIgCCASSxsQ6BkgCSgCJCEICyALBEAgCSgCICAIakEAIAv8CwALIAkgCjYCJAsgCSAONgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCtKAsgCSgCECAIQQF0akEAOwEAIAkgCEEBajYCFAsgAkEgaiECIBAgB0EBaiIHRw0BDAMLCyAJIAEQgDw2AnAgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgKcASAJQTs2ApQBIAkgCUGQAWo2ArgBIAkgCUHwAGo2ApgBIAkgCUGIAmo2ApABDAQLQaCVgAEQsjsACyAJQbABaiICIAlBDGoiBxDOFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQZiggAE2AgggACABNgIEIABBk4CAgHg2AgAgBxC4LQsgCUGwAmokAA8LQQRBOBCjPQALIAlBsAFqQeSSgAEQ7ywAC5sUAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPkeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEJ0oCyAJKAIQIAhBAnRqQQA2AgAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqENMeIAkoAkBBAUYEQCAJKQNIIhNCgICAgAh8QoCAgIAQVA0CCyAJQZACakGEiJAgNgIAIAlChIiQoMCAgYIENwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAlBsAFqEJkOIAEQqQwgACAJKQJINwIIIABBEGogCUHQAGooAgA2AgAgACAJKAJENgIEIABBgoCAgHg2AgALIAlBDGoQuS0MBwsCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQnSgLIAkoAhAgCEECdGogEz4CAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIgpBEGsiCCkDACEUIAgpAwghEyAKKQMAIRUgCikDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBU3A4ABIAkgEzcDeCAJIBQ3A3ACQAJAAkAgF1BFBEAgCUGwAWoiCiAUIBMgFSAWIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAoQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAQsgCUGHgICAeDYCRAsgCUEBNgJAIAwQiBFBACEKDAELIAkpA8ABIRQgCSkDyAEhEyAJKQPQASEVIAkgCSkD2AE3A8gBIAkgFTcDwAEgCSATNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQ0x4gCSgCQCAJKQNIIhRCgICAgAh8QoCAgIAQVHEhCiAUpyEICyAJQQxqIAogCBDfCwwBCyANEOY6IAkoAhhFDQMgCSgCKEEBaiIOQQN2IA5BB3FBAEdqIgogCSgCJCIISwRAIAogCGshCyAJKAIcIhIgCkkEQCANIBJBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIhIgCCASSxsQ6BkgCSgCJCEICyALBEAgCSgCICAIakEAIAv8CwALIAkgCjYCJAsgCSAONgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCdKAsgCSgCECAIQQJ0akEANgIAIAkgCEEBajYCFAsgAkEgaiECIBAgB0EBaiIHRw0BDAMLCyAJIAEQgDw2AnAgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgKcASAJQTs2ApQBIAkgCUGQAWo2ArgBIAkgCUHwAGo2ApgBIAkgCUGIAmo2ApABDAQLQaCVgAEQsjsACyAJQbABaiICIAlBDGoiBxDQFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQfiigAE2AgggACABNgIEIABBk4CAgHg2AgAgBxC5LQsgCUGwAmokAA8LQQRBOBCjPQALIAlBsAFqQeSSgAEQ7ywAC44UAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPMeIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqEJEfIAkoAkAEQCAJKQNIIhNCgIAEVA0CCyAJQZACakGHjpw4NgIAIAlCh46cuPDgwYMHNwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAlBsAFqEJkOIAEQqQwgACAJKQFGNwEGIABBDGogCUHMAGopAQA3AQAgACAJLwFEOwEEIABBgoCAgHg2AgALIAlBDGoQuC0MBwsCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQrSgLIAkoAhAgCEEBdGogEz0BAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIgpBEGsiCCkDACEUIAgpAwghEyAKKQMAIRUgCikDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBU3A4ABIAkgEzcDeCAJIBQ3A3ACQAJAAkAgF1BFBEAgCUGwAWoiCiAUIBMgFSAWIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAoQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAQsgCUGHgICAeDYCRAsgCUEBNgJAIAwQiBFBACEKDAELIAkpA8ABIRQgCSkDyAEhEyAJKQPQASEVIAkgCSkD2AE3A8gBIAkgFTcDwAEgCSATNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQkR9BACEKIAkoAkBBAUcNACAJKQNIIhRCgIAEVCEKIBSnIQgLIAlBDGogCiAIEN4LDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEK0oCyAJKAIQIAhBAXRqQQA7AQAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHEM8UQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBwJ+AATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELgtCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALnxQCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPkeIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEzcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAPIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhEEGIgICAeAshASAAIBA3AgwgACAPNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQnSgLIAUoAmAgBEECdGpBADYCAAwDCyAFQRBqIA8gEyARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECIQNwPAASAQQoCAgIAIfCITQoCAgIAQVCAPIBAgE1atfFBxDQEgBUGYAmpBhIiQIDYCACAFQoSIkKDAgIGCBDcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkCgAI3AgggAEEQaiAFQYgCaigCADYCACAAIAUoAvwBNgIEIABBgoCAgHg2AgALIAVB3ABqELktDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCdKAsgBSgCYCAEQQJ0aiAQPgIACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAgICACHwiEEKAgICAEFQgBSkDCCAPIBBWrXxQcSEEIA+nIQYLIAVB3ABqIAQgBhDfCwwBCyAJEOY6IAUoAmhFDQMgBSgCeEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshByAFKAJsIg4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCdCEECyAHBEAgBSgCcCAEakEAIAf8CwALIAUgBjYCdAsgBSAKNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQnSgLIAUoAmAgBEECdGpBADYCACAFIARBAWo2AmQLIANBEGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP87NgKQAiAFQQI2AvwBIAVB1JKAATYC+AEgBUICNwKEAiAFQTs2AuwBIAVBOzYC5AEgBSAFQeABajYCgAIgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH4AWpB5JKAARDvLAALQaCVgAEQsjsACyAFQZABaiICIAVB3ABqIgMQ0BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEH4ooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVBoAJqJAAPC0EEQTgQoz0AC5cUAgp/BX5CCiEPIwBBoAJrIgUkACAFIAM6AFsgASACEPwhIQEgBSADwCICNgKQAiAFQgA3A+gBIAVCCjcD4AFCASERAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQQA2AlQgBUFAayARIBIgDyAQIAVB1ABqEPYMIAUoAlQNAyAFKQNIIRIgBSkDQCERIAJBAUYNAgsgBUEANgI8IAVBIGogDyAQIA8gECAFQTxqEPYMIAUoAjwNAiAFKQMoIRAgBSkDICEPIAJBAXYhAgwACwALIAVB3ABqIAFBDGoiDRDaPBD1HiAELQA0IA0Q2jwhDA0DIAxFDQQgBUHoAGohCEEAIQNBACECA0ACQAJAAkACQCABIAIQhyVFBEAgBSACNgKQAiANENo8IAJNDQcgASgCECADaiIEKQMAIQ8gBSAEKQMIIhM3A9gBIAUgDzcD0AEgBSARNwOQAiAFIBI3A5gCIBEgEoRQBH9Bh4CAgHgFIBEgEoNCf1IgDyATQoCAgICAgICAgH+FhEIAUnINAiAFQQI2ApQBIAVB9JeAATYCkAEgBUICNwKcASAFQfsPNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfwBaiAFQZABahCZDiAFKQL8ASEPIAUpAoQCIRBBiICAgHgLIQEgACAQNwIMIAAgDzcCBCAAIAE2AgAMAgsgCBDmOiAFKAJoRQ0HIAUoAnhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQogBSgCbCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAnQhBAsgCgRAIAUoAnAgBGpBACAK/AsACyAFIAY2AnQLIAUgCTYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEK0oCyAFKAJgIARBAXRqQQA7AQAMAwsgBUEQaiAPIBMgESASEIMZIAUgBSkDGCIPNwPIASAFIAUpAxAiEDcDwAEgEEKAgAJ8IhNCgIAEVCAPIBAgE1atfFBxDQEgBUGYAmpBg4aMGDYCACAFQoOGjJiw4MCBAzcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkB/gE3AQYgAEEMaiAFQYQCaikBADcBACAAIAUvAfwBOwEEIABBgoCAgHg2AgALIAVB3ABqELgtDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCtKAsgBSgCYCAEQQF0aiAQPQEACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAgAJ8IhBCgIAEVCAFKQMIIA8gEFatfFBxIQQgD6chBgsgBUHcAGogBCAGEN4LDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDOFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQZiggAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUGgAmokAA8LQQRBOBCjPQALjhQCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ8h4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRUgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFTcDmAEgCSATNwOQASAYUAR/QYeAgIB4BSAJQbABaiIIIBMgFSAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRRBiICAgHgLIQEgACAUNwIMIAAgBjcCBCAAIAE2AgAMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQnSgLIAkoAhAgCEECdGpBADYCAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFTcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFDcDcCAJIBM3A8gBIAkgFTcDwAEgCSAWNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQkR8gCSgCQEEBRgRAIAkpA0giE0KAgICAEFQNAgsgCUGQAmpBiJCgwAA2AgAgCUKIkKDAgIGChAg3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAkg3AgggAEEQaiAJQdAAaigCADYCACAAIAkoAkQ2AgQgAEGCgICAeDYCAAsgCUEMahC5LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCdKAsgCSgCECAIQQJ0aiATPgIACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahCRHyAJKAJAIAkpA0giFEKAgICAEFRxIQogFKchCAsgCUEMaiAKIAgQ3wsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQnSgLIAkoAhAgCEECdGpBADYCACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ1BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIoYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQuS0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAvvEAINfwZ+IwBBoAJrIgUkAAJAAkACQAJAAkACQAJ/AkACQAJAAkAgAUEESwRAIANBBEsEQCAFQQA2AogBIAVBiAFqIgdBBCAAQQRB3NHRABDVLCAFKAKIASEMIAVBADYCiAEgB0EEIAJBBEHc0dEAENUsQQAgDCAFKAKIAUcNBhoCQCAEQQVPBEAgAC0ABCACLQAERg0BC0EEIAQgBEEETxsMBwsgAUEFayEKIABBBWohBiADQQVrIQsgAkEFaiEIQQAhByAEQQVrIglBCEkNBCAFQgA3AwggCkEHSwRAIAVBCGoiB0EIIAZBCEH80dEAENUsIAUpAwghEyAFQgA3AwggC0EHSwRAIAdBCCAIQQhB/NHRABDVLCATIAUpAwgiElIEQCASIBOFeqdBA3YhAAwICyABQQ1rIQogAEENaiEGIANBDWshCyACQQ1qIQggBEENayIJQRBJBEBBCCEHDAYLIAVBkAJqIhBCADcDACAFQgA3A4gCIAVBEGoiEUIANwMAIAVCADcDCCAKQQ9LBEAgBUGIAmoiDUEQIAZBEEHM0tEAENUsIAtBD0sEQCABQR1rIQogAEEdaiEGIAVBCGoiB0EQIAhBEEHM0tEAENUsIARBHWshCSADQR1rIQsgAkEdaiEIQQghDkEBIQ8DQCAFQgA3A4gBIAVBiAFqIgxBCCANQQhB/NHRABDVLCAFKQOIASETIAVCADcDiAEgDEEIIAdBCEH80dEAENUsIAUpA4gBIhIgE1IEQCASIBOFeqdBA3YgDmohAAwLCyAOQQhqIQ4gD0EAIQ8gECENIBEhBw0AC0EYIQcgCUEgSQ0HQQAiDEUEQCAFQQhqQQBBgAH8CwALIAxFBEAgBUGIAWpBAEGAAfwLAAsgCkEfSwRAIAVBCGpBICAGQSBB3NLRABDVLCALQR9LBEAgAUE9ayEKIABBPWohBiAFQYgBakEgIAhBIEHc0tEAENUsIARBPWshCSADQT1rIQsgAkE9aiEIQQAhBwNAIAVCADcDiAIgBUGIAmoiDUEIIAVBCGogB2pBCEH80dEAENUsIAUpA4gCIRMgBUIANwOIAiANQQggBUGIAWogB2pBCEH80dEAENUsIAUpA4gCIhIgE1IEQCAHQRhqIQYMCgsgB0EIaiIHQSBHDQALIAlBwABJBEBBOCEHDAoLIApBP0sEQCAFQQhqQcAAIAZBwABB7NLRABDVLCALQT9LBEAgAUH9AGshCiAAQf0AaiEGIAVBiAFqQcAAIAhBwABB7NLRABDVLCAEQf0AayEJIANB/QBrIQsgAkH9AGohCEEAIQIDQCAFQgA3A4gCIAVBiAJqIgBBCCAFQQhqIAJqQQhB/NHRABDVLCAFKQOIAiETIAVCADcDiAIgAEEIIAVBiAFqIAJqQQhB/NHRABDVLCAFKQOIAiISIBNSBEAgAkE4aiEGDAwLIAJBCGoiAkHAAEcNAAsgCUGAAUkEQEH4ACEHDAwLIARB/QFrQYB/cUH4AWohB0H4ACEAA0ACQCAKQf8ASwRAIAVBCGpBgAEgBkGAAUH809EAENUsIAtB/wBNDRMgCkGAAWshCiAGQYABaiEGIAVBiAFqQYABIAhBgAFB/NPRABDVLCAAQYABaiEBIAlBgAFrIQkgC0GAAWshCyAIQYABaiEIQQAhAgNAAkAgBUIANwOIAiAFQYgCaiIDQQggBUEIaiACakEIQfzR0QAQ1SwgBSkDiAIhEyAFQgA3A4gCIANBCCAFQYgBaiACakEIQfzR0QAQ1SwgEyAFKQOIAiISUg0AIAJBCGoiAkGAAUcNAQwDCwsgACACaiEGDA0LDBILIAEhACAJQYABTw0ACwwLCwwQCwwPCwwPCwwOCwwOCwwNCwwNCwwMCyAFQQA2ApgBIAVBATYCjAEgBUG40NEANgKIASAFQgQ3ApABIAVBiAFqQbzS0QAQ7ywACyAFQQA2ApgBIAVBATYCjAEgBUG40NEANgKIASAFQgQ3ApABIAVBiAFqQazS0QAQ7ywACyASIBOFeqdBA3YgBmohAAwCCyAJQQhJDQBBACAHayECAkADQCAFQgA3AwggCkEHTQ0KIAVBCGoiAEEIIAZBCEH80dEAENUsIAUxAA8hFCAFMQAOIRUgBTEADSEWIAUxAAwhFyAFNQIIIRIgBUIANwMIIAtBB00NCiAAQQggCEEIQfzR0QAQ1SwgBSkDCCITIBdCIIYgEoQgFkIohoQgFUIwhoQgFEI4hoQiElEEQCAGQQhqIQYgCkEIayEKIAJBCGshAiAIQQhqIQggC0EIayELIAlBCGsiCUEHTQ0CDAELCyASIBOFeqdBA3YgAmshAAwCC0EAIAJrIQcLIAkgCksEQEH80tEAQS5BrNPRABCfKQALIAkgC0sNAiAHQQFrIQAgCSECA0AgAgRAIAJBAWshAiAAQQFqIQAgCC0AACEDIAYtAAAgCEEBaiEIIAZBAWohBiADRg0BDAILCyAHIAlqIQALIABBBWoLIAVBoAJqJAAPC0G809EAQS5B7NPRABCfKQALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB/NPRABDvLAALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB7NLRABDvLAALIAVBADYCmAIgBUEBNgKMAiAFQbjQ0QA2AogCIAVCBDcCkAIgBUGIAmpB3NLRABDvLAALIAVBADYCmAEgBUEBNgKMASAFQbjQ0QA2AogBIAVCBDcCkAEgBUGIAWpBzNLRABDvLAALIAVBADYCmAEgBUEBNgKMASAFQbjQ0QA2AogBIAVCBDcCkAEgBUGIAWpB7NHRABDvLAALhhQCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ8B4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRUgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFTcDmAEgCSATNwOQASAYUAR/QYeAgIB4BSAJQbABaiIIIBMgFSAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRRBiICAgHgLIQEgACAUNwIMIAAgBjcCBCAAIAE2AgAMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQoygLIAkoAhAgCGpBADoAAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFTcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFDcDcCAJIBM3A8gBIAkgFTcDwAEgCSAWNwO4ASAJIBQ3A7ABIAlBQGsgCUGwAWoQ0x4gCSgCQEEBRgRAIAkpA0giE0KAAXxCgAJUDQILIAlBkAJqQYKEiBA2AgAgCUKChIiQoMCAgQI3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAEU3AAUgAEEMaiAJQcwAaikAADcAACAAIAktAEQ6AAQgAEGCgICAeDYCAAsgCUEMahC3LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCjKAsgCSgCECAIaiATPAAACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahDTHiAJKAJAIAkpA0giFEKAAXxCgAJUcSEKIBSnIQgLIAlBDGogCiAIEPELDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEKMoCyAJKAIQIAhqQQA6AAAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHENYUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0KOAATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELctCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALihQCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPAeIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEzcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAPIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhEEGIgICAeAshASAAIBA3AgwgACAPNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQoygLIAUoAmAgBGpBADoAAAwDCyAFQRBqIA8gEyARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECIQNwPAASAQQoABfCITQoACVCAPIBAgE1atfFBxDQEgBUGYAmpBgoSIEDYCACAFQoKEiJCgwICBAjcDkAIgBUECNgKUASAFQeClgAE2ApABIAVCAjcCnAEgBUGtAzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACaiIBNgLoASAFIAVBwAFqNgLgASAFQfwBaiAFQZABahCZDiABEKkMIAAgBSkA/QE3AAUgAEEMaiAFQYQCaikAADcAACAAIAUtAPwBOgAEIABBgoCAgHg2AgALIAVB3ABqELctDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCjKAsgBSgCYCAEaiAQPAAACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohCyARIBKEIRNBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2jwgAk0NAiABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcDyAEgBSAPNwPAASAFIBE3A9ABIAUgEjcD2AECQAJAAkAgE1BFBEAgESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0CIAVBAjYC/AEgBUH0l4ABNgL4ASAFQgI3AoQCIAVB+w82ApwCIAVB+w82ApQCIAUgBUGQAmo2AoACIAUgBUHQAWo2ApgCIAUgBUHAAWo2ApACIAsgBUH4AWoQmQ4gBUGIgICAeDYC4AEgCCAFKQLgATcCACAIQQhqIAVB6AFqKQIANwIAIAhBEGogBUHwAWooAgA2AgAMAQsgBUGHgICAeDYClAELIAVBATYCkAEgCBCIEUEAIQQMAQsgBSAPIBAgESASEIMZIAUpAwAiD0KAAXwiEEKAAlQgBSkDCCAPIBBWrXxQcSEEIA+nIQYLIAVB3ABqIAQgBhDxCwwBCyAJEOY6IAUoAmhFDQMgBSgCeEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshByAFKAJsIg4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCdCEECyAHBEAgBSgCcCAEakEAIAf8CwALIAUgBjYCdAsgBSAKNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQoygLIAUoAmAgBGpBADoAACAFIARBAWo2AmQLIANBEGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP87NgKQAiAFQQI2AvwBIAVB1JKAATYC+AEgBUICNwKEAiAFQTs2AuwBIAVBOzYC5AEgBSAFQeABajYCgAIgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH4AWpB5JKAARDvLAALQaCVgAEQsjsACyAFQZABaiICIAVB3ABqIgMQ1hRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHQo4ABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQty0LIAVBoAJqJAAPC0EEQTgQoz0AC/4TAgp/Bn4jAEGwAmsiCSQAIAkgBzoACyABIAIQ4yEhASAJQbABaiADIAQgBSAGIAfAEN8BAkACQAJAIAkoArABQQFGBEAgCUHIAGogCSkCvAE3AwAgCUHQAGogCUHEAWooAgA2AgAgCSAJKQK0ATcDQCAJQQM2AhAgCUGspYABNgIMIAlCAjcCGCAJQfQLNgJ8IAlBxA02AnQgCUG0nYABNgJwIAkgCUHwAGo2AhQgCSAJQQtqNgJ4IAlBlAFqIAlBDGoQmQ4gCUGCgICAeDYCkAEgCUFAaxCIESAAQQhqIAlBmAFqKAIANgIAIAAgCSkCkAE3AgAgACAJKQKcATcCDAwBCyAJKQPYASEGIAkpA9ABIQMgCSkDyAEhBCAJKQPAASEFIAlBDGogAUEMaiIRENw8EPceIAgtADQhAiARENw8IRACQCACRQRAIBBFDQEgCUEYaiEMQRAhAiADIAWEIAQgBoSEIRhBACEHAkADQAJAAkACQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0FIAEoAhAgAmoiCEEQayIKKQMAIRMgCikDCCEVIAgpAwAhFiAIKQMIIRcgCSAGNwNYIAkgAzcDUCAJIAQ3A0ggCSAFNwNAIAkgFzcDqAEgCSAWNwOgASAJIBU3A5gBIAkgEzcDkAEgGFAEf0GHgICAeAUgCUGwAWoiCCATIBUgFiAXIAUgBCADIAYQmgggCS0AsAFBAUcNAiAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBQGs2AqgCIAkgCUGQAWo2AqACIAlBjAJqIAgQmQ4gCSkCjAIhBiAJKQKUAiEUQYiAgIB4CyEBIAAgFDcCDCAAIAY3AgQgACABNgIADAILIAwQ5jogCSgCGEUNBiAJKAIoQQFqIg1BA3YgDUEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayEOIAkoAhwiCyAKSQRAIAwgC0EBdCIIIApBwP///wNxQUBrIAogCkE/cRsiCyAIIAtLGxDoGSAJKAIkIQgLIA4EQCAJKAIgIAhqQQAgDvwLAAsgCSAKNgIkCyAJIA02AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABEKkZCyAJKAIQIAhqQQA6AAAMAwsgCSAJKQPYASITNwOIASAJIAkpA9ABIhU3A4ABIAkgCSkDyAEiFjcDeCAJIAkpA8ABIhQ3A3AgCSATNwPIASAJIBU3A8ABIAkgFjcDuAEgCSAUNwOwASAJQUBrIAlBsAFqEJEfIAkoAkBBAUYEQCAJKQNIIhNCgAJUDQILIAlBkAJqQYaMmDA2AgAgCUKGjJiw4MCBgwY3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCUGwAWoQmQ4gARCpDCAAIAkpAEU3AAUgAEEMaiAJQcwAaikAADcAACAAIAktAEQ6AAQgAEGCgICAeDYCAAsgCUEMahC3LQwHCwJAIAkoAhgEQCAJKAIoIg1BAWoiDkEDdiAOQQdxQQBHaiIIIAkoAiQiCksEQCAIIAprIQsgCSgCHCIPIAhJBEAgDCAPQQF0IgogCEHA////A3FBQGsgCCAIQT9xGyIPIAogD0sbEOgZIAkoAiQhCgsgCwRAIAkoAiAgCmpBACAL/AsACyAJIAg2AiQLIAkgDjYCKCAJKAIgIA1BA3ZqIgggCC0AAEEBIA1BB3F0cjoAAAwBCyAJIAkoAixBAWo2AiwLIAkoAhQiCCAJKAIMRgRAIAlBDGpBhJOAARCpGQsgCSgCECAIaiATPAAACyAJIAhBAWo2AhQgAkEgaiECIBAgB0EBaiIHRw0BDAQLCyAJIAEQgDw2ApABIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCTCAJQTs2AkQgCSAJQUBrNgK4ASAJIAlBkAFqNgJIIAkgCUGIAmo2AkAMBQtBoJWAARCyOwALIBBFDQAgCUEYaiENIAlBQGtBBHIhDCAJQYwCaiEPIAMgBYQgBCAGhIQhF0EQIQJBACEHAkADQAJAAkAgASAHEIclRQRAIAkgBzYCiAIgERDcPCAHTQ0CIAEoAhAgAmoiCkEQayIIKQMAIRQgCCkDCCETIAopAwAhFSAKKQMIIRYgCSAGNwOoASAJIAM3A6ABIAkgBDcDmAEgCSAFNwOQASAJIBY3A4gBIAkgFTcDgAEgCSATNwN4IAkgFDcDcAJAAkACQCAXUEUEQCAJQbABaiIKIBQgEyAVIBYgBSAEIAMgBhCaCCAJLQCwAUEBRw0CIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUGQAWo2AqgCIAkgCUHwAGo2AqACIA8gChCZDiAJQYiAgIB4NgKIAiAMIAkpAogCNwIAIAxBCGogCUGQAmopAgA3AgAgDEEQaiAJQZgCaigCADYCAAwBCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUEAIQoMAQsgCSkDwAEhFCAJKQPIASETIAkpA9ABIRUgCSAJKQPYATcDyAEgCSAVNwPAASAJIBM3A7gBIAkgFDcDsAEgCUFAayAJQbABahCRHyAJKAJAIAkpA0giFEKAAlRxIQogFKchCAsgCUEMaiAKIAgQ8AsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQqRkLIAkoAhAgCGpBADoAACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ0RRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGopIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQty0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAuVEQESfyMAQeAAayIIJAACQCAFQQAgBGtBA3EiB2siBkEAIAUgBk8bQYAmSQRAQb5/IQMMAQsgAkH/AUsEQEFSIQMMAQsgBCAHakEAIAUgB08bIglBAEGAJvwLACAJQQhqIQsgCUGAIGohBiACQQFqIg4hBSABIQQDQCAFBEAgBiAEKAIAIgdBvQEgB2drIAdBpQFJG0ECdGoiByAHLwEAQQFqOwEAIAVBAWshBSAEQQRqIQQMAQUCQEEAIQUDQCAFQYR6RgRAIAlBhiBqIQdBACEFA0AgBSAORgRAQQAhBQNAAkAgBUHoAEYEQCACQYACaiEKIAJBA3QhBQNAIApBAWshCiAFIAlqIAVBCGsiAiEFQQhqKAIAIgFFDQALIAIgCWoiDUEUakGAAjsBACANQQxqQYACOwEAIAkgDUEIaigCACABajYCiBAgCkH/AWshESAKQf4BayEHIAlBkBBqIQEgA0ELIAMbIQwgDUEXaiEGIA1BhxBqIQRBgAIgCiAKQYACTBtBgAJrIQUDQCAFRQ0CIAFBgICAgAQ2AgAgAUEIaiEBIAVBAWshBQwACwALIAUgCWoiAUGWJWovAQAgAUGUJWovAQAiAWsiBEECTgRAIAsgAUEDdGpBACAEQQFrEMgNCyAFQQRqIQUMAQsLIAlBgICAgHg2AgBBgAIhBUGAAiAKIApBgAJMGyETIAlBkBBqIQIgCkGBAmshAUGAAiEDA0AgBSATRkUEQCALIAMgCyABQQN0aigCACIPIAsgA0EDdGooAgAiEE8iFGoiEiABIA8gEElrIg8gCyAPQQN0aigCACIQIAsgEkEDdGooAgAiFU8iFhtBA3RqIhcgBUEBaiIFOwEEIAsgAyABIBQbQQN0aiIBIAU7AQQgAiAXKAIAIAEoAgBqNgIAIA8gECAVSWshASASIBZqIQMgAkEIaiECDAELCyANQY8QakEAOgAAIApBAWshBQNAIAVB/wFMBEAgB0EAIAdBAEobIQQgCUEPaiEFA0AgBARAIAUgCyAFQQNrLwEAQQN0akEHai0AAEEBajoAACAEQQFrIQQgBUEIaiEFDAELCyANQRdqLQAAIgMgDE0NBkEBIAMgDGsiCnQhAkEAIQEgAyEFA0AgBUH/AXEiBCAMTQRAA0AgB0EBayEHIAYtAAAgBkEIayIDIQYgDEYNAAsgCEHwAUE4/AsAIANBCGohBCAMIQYgByEFA0AgBUEASARAIAEgCnUhBiAIQfwAaiECA0ACQAJAIAZBAEwEQCAJQR9qIQIgCUEXaiEDIAgoAgQhBQwBC0EgIAZnIgFrIQUgAiABQQJ0ayEEA0AgBUECSQRAQQEhBQwDCyAEQQRqKAIAIgFB8OHDh39HBEAgBCgCACIDQfDhw4d/Rg0DIAsgAUEDdGooAgAgCyADQQN0aigCAEEBdE0NAwsgBUEBayEFIARBBGshBAwACwALA0AgBkEAIAZBAEobIQEgBUGQnrz4AGohBCADIAVBA3RqIQUCQANAIAEgBkYNASAEBEAgBSAFLQAAQQFrOgAAIARBAWohBCAFQQhqIQUgBkEBaiEGDAELCyAHQQFqIQQgAiAHQQN0aiEFA0AgBEEBayEEIAVBEGshByAFQQhrIgEhBSAMIActAABGDQALIAEgAS0AAEEBazoAACAGQQFqIQYgBEEBaiEFIAQhBwwBCwsgDCEDDAwLQQ0gBSAFQQ1NGyEBIAggBUECdGohBAJAA0AgASAFRgRAIAggAUECdGooAgAhAwwCCyAEKAIAIgNB8OHDh39GBEAgBEEEaiEEIAVBAWohBQwBCwsgBSEBCyALIANBA3RqQQdqIgQgBC0AAEEBajoAAEHw4cOHfyEFIAggAUEBayIEQQJ0aiIKIAMgCigCACIKIApB8OHDh39GGzYCAEF/IAR0IAZqIQYgCCABQQJ0aiADBH9B8OHDh38gA0EBayIDIAsgA0EDdGpBB2otAAAgDCABa0cbBSAFCzYCAAwACwAFIAQtAAAiAiAGSQRAIAggDCACa0ECdGogBTYCACACIQYLIARBCGshBCAFQQFrIQUMAQsACwAFIAYgDDoAACABIAJqQX8gAyAEa3RqIQEgB0EBayEHIAZBCGsiBi0AACEFDAELAAsABSAEIAsgBEEDay8BAEEDdGpBB2otAABBAWo6AAAgBEEIayEEIAVBAWshBQwBCwALAAUgByABKAIAIgRBvQEgBGdrIARBpQFJG0ECdGoiBiAGLwEAIgZBAWo7AQAgCyAGQQN0aiIGIAU6AAYgBiAENgIAIAFBBGohASAFQQFqIQUMAQsACwAFIAUgCWoiBEH6JWogBEH4JWoiBy8BACAEQfwlai8BAGoiBDsBACAHIAQ7AQAgBUEEayEFDAELAAsACwsLIANBDEsEQEF/IQMMAQsgCEEYakEAOwEAIAhBEGpCADcDACAIQgA3AwggCEIANwMAIAhB2ABqQQA7AQAgCEHQAGpCADcDACAIQgA3A0ggCEIANwNAIAlBD2ohBEF/IBEgEUEASBtBAWohBQNAIAUEQCAIIAQtAABBAXRqIgEgAS8BAEEBajsBACAFQQFrIQUgBEEIaiEEDAEFIANBAXQhBSADIQRBACEBA0AgBEEATARAIAlBD2ohBCAAQQRqIQUgDiEBA0AgAQRAIAUgBEEBay0AAEECdGogBC0AADYCACABQQFrIQEgBEEIaiEEDAEFA0AgDgRAIAhBQGsgBSgCACICQf8BcSIBQQF0aiIEIAQvAQAiBEEBajsBACABBEAgBSAEQSAgAWt0IAJyNgIACyAOQQFrIQ4gBUEEaiEFDAELCyAAIAM2AgALCwUgCEFAayAFaiABOwEAIARBAWshBCAFIAhqLwEAIAFqQf7/A3FBAXYhASAFQQJrIQUMAQsLCwsLIAhB4ABqJAAgAwuAFAIKfwV+QgohDyMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIA8gECAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIA8gECAPIBAgBUE8ahD2DCAFKAI8DQIgBSkDKCEQIAUpAyAhDyACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ8h4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAiARIBKEUAR/QYeAgIB4BSARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCdKAsgBSgCYCAEQQJ0akEANgIADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBBQIA9CgICAgBBUcQ0BIAVBmAJqQYiQoMAANgIAIAVCiJCgwICBgoQINwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQKAAjcCCCAAQRBqIAVBiAJqKAIANgIAIAAgBSgC/AE2AgQgAEGCgICAeDYCAAsgBUHcAGoQuS0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEJ0oCyAFKAJgIARBAnRqIA8+AgALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoCAgIAQVHEhBCAPpyEGCyAFQdwAaiAEIAYQ3wsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEJ0oCyAFKAJgIARBAnRqQQA2AgAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENQUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByKGAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQaACaiQADwtBBEE4EKM9AAv7EwIKfwV+QgohDyMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIA8gECAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIA8gECAPIBAgBUE8ahD2DCAFKAI8DQIgBSkDKCEQIAUpAyAhDyACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ8x4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAiARIBKEUAR/QYeAgIB4BSARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBBQIA9CgIAEVHENASAFQZgCakGHjpw4NgIAIAVCh46cuPDgwYMHNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQH+ATcBBiAAQQxqIAVBhAJqKQEANwEAIAAgBS8B/AE7AQQgAEGCgICAeDYCAAsgBUHcAGoQuC0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEK0oCyAFKAJgIARBAXRqIA89AQALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoCABFRxIQQgD6chBgsgBUHcAGogBCAGEN4LDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCtKAsgBSgCYCAEQQF0akEAOwEAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDPFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcCfgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUGgAmokAA8LQQRBOBCjPQAL8BMCCn8FfkIKIQ8jAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAPIBAgBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAPIBAgDyAQIAVBPGoQ9gwgBSgCPA0CIAUpAyghECAFKQMgIQ8gAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EPceIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhECAFIAQpAwgiEzcD2AEgBSAQNwPQASAFIBE3A5ACIAUgEjcDmAIgESAShFAEf0GHgICAeAUgESASg0J/UiAQIBNCgICAgICAgICAf4WEQgBScg0CIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIRAgBSkChAIhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQqRkLIAUoAmAgBGpBADoAAAwDCyAFQRBqIBAgEyARIBIQgxkgBSAFKQMYIhA3A8gBIAUgBSkDECIPNwPAASAQUCAPQoACVHENASAFQZgCakGGjJgwNgIAIAVChoyYsODAgYMGNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgACAFKQD9ATcABSAAQQxqIAVBhAJqKQAANwAAIAAgBS0A/AE6AAQgAEGCgICAeDYCAAsgBUHcAGoQty0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABEKkZCyAFKAJgIARqIA88AAALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELIBEgEoQhE0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCIQNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYAQJAAkACQCATUEUEQCARIBKDQn9SIA8gEEKAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQQAhBAwBCyAFIA8gECARIBIQgxkgBSkDCFAgBSkDACIPQoACVHEhBCAPpyEGCyAFQdwAaiAEIAYQ8AsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABEKkZCyAFKAJgIARqQQA6AAAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENEUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBqKSAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELctCyAFQaACaiQADwtBBEE4EKM9AAvxEwIKfwV+QgohECMAQaACayIFJAAgBSADOgBbIAEgAhD8ISEBIAUgA8AiAjYCkAIgBUIANwPoASAFQgo3A+ABQgEhEQJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEANgJUIAVBQGsgESASIBAgDyAFQdQAahD2DCAFKAJUDQMgBSkDSCESIAUpA0AhESACQQFGDQILIAVBADYCPCAFQSBqIBAgDyAQIA8gBUE8ahD2DCAFKAI8DQIgBSkDKCEPIAUpAyAhECACQQF2IQIMAAsACyAFQdwAaiABQQxqIg0Q2jwQ+B4gBC0ANCANENo8IQwNAyAMRQ0EIAVB6ABqIQhBACEDQQAhAgNAAkACQAJ/AkAgASACEIclRQRAIAUgAjYCkAIgDRDaPCACTQ0HIAEoAhAgA2oiBCkDACEQIAUgBCkDCCITNwPYASAFIBA3A9ABIAUgETcDkAIgBSASNwOYAkGHgICAeCARIBKEUA0CGiARIBKDQn9SIBAgE0KAgICAgICAgIB/hYRCAFJyDQEgBUECNgKUASAFQfSXgAE2ApABIAVCAjcCnAEgBUH7DzYC7AEgBUH7DzYC5AEgBSAFQeABajYCmAEgBSAFQZACajYC6AEgBSAFQdABajYC4AEgBUH8AWogBUGQAWoQmQ4gBSkC/AEhECAFKQKEAiEPQYiAgIB4DAILIAgQ5jogBSgCaEUNByAFKAJ4QQFqIglBA3YgCUEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEKIAUoAmwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJ0IQQLIAoEQCAFKAJwIARqQQAgCvwLAAsgBSAGNgJ0CyAFIAk2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCzKAsgBSgCYCAEQQN0akIANwMADAMLIAVBEGogECATIBEgEhCDGSAFIAUpAxgiEDcDyAEgBSAFKQMQIg83A8ABIBAgD0KAgICAgICAgIB/fSAPVK18UA0BIAVBmAJqQYWKlCg2AgAgBUKFipSo0KDBggU3A5ACIAVBAjYClAEgBUHgpYABNgKQASAFQgI3ApwBIAVBrQM2AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmoiATYC6AEgBSAFQcABajYC4AEgBUH8AWogBUGQAWoQmQ4gARCpDCAFKQL8ASEQIAUpAoQCIQ9BgoCAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAgBUHcAGoQui0MCAsCQCAFKAJoBEAgBSgCeCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJ0IgZLBEAgBCAGayEHIAUoAmwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJ0IQYLIAcEQCAFKAJwIAZqQQAgB/wLAAsgBSAENgJ0CyAFIAo2AnggBSgCcCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJ8QQFqNgJ8CyAFKAJkIgQgBSgCXEYEQCAFQdwAakGEk4ABELMoCyAFKAJgIARBA3RqIA83AwALIAUgBEEBajYCZCADQRBqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCYCAFQYiYgAE2AlwgBUICNwJoIAVB+g82ApwBIAVB+w82ApQBIAUgBUGQAWoiATYCZCAFIAVBkAJqNgKYASAFIAVB4AFqIgI2ApABIAVB/AFqIgMgBUHcAGoiBBCZDiAFQYiAgIB4NgL4ASAFQZgBaiAFQYACaiIGKAIANgIAIAUgBSkC+AE3A5ABIAUgBSkChAI3ApwBIAVBAzYCYCAFQaylgAE2AlwgBUICNwJoIAVB9As2AuwBIAVBxA02AuQBIAVByJ2AATYC4AEgBSACNgJkIAUgBUHbAGo2AugBIAMgBBCZDiAFQYKAgIB4NgL4ASABEIgRIABBCGogBigCADYCACAAIAUpAvgBNwIAIAAgBSkChAI3AgwMBAsgBSABEP87NgLgASAFQQI2ApQBIAVB1JKAATYCkAEgBUICNwKcASAFQTs2AoQCIAVBOzYC/AEgBSAFQfgBajYCmAEgBSAFQeABajYCgAIgBSAFQZACajYC+AEgBUGQAWpB5JKAARDvLAALQaCVgAEQsjsACyAMRQ0AIAVB6ABqIQkgBUGQAWpBBHIhCCAFQeQBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgLQASANENo8IAJNDQIgASgCECADaiIEKQMAIQ8gBSAEKQMIIhM3A8gBIAUgDzcDwAEgBSARNwPQASAFIBI3A9gBIAVB3ABqAn4CQAJAIBEgEoRQRQRAIBEgEoNCf1IgDyATQoCAgICAgICAgH+FhEIAUnINAiAFQQI2AvwBIAVB9JeAATYC+AEgBUICNwKEAiAFQfsPNgKcAiAFQfsPNgKUAiAFIAVBkAJqNgKAAiAFIAVB0AFqNgKYAiAFIAVBwAFqNgKQAiALIAVB+AFqEJkOIAVBiICAgHg2AuABIAggBSkC4AE3AgAgCEEIaiAFQegBaikCADcCACAIQRBqIAVB8AFqKAIANgIADAELIAVBh4CAgHg2ApQBCyAFQQE2ApABIAgQiBFCAAwBCyAFIA8gEyARIBIQgxkgBSkDACIPIBAgBSkDCCAPQoCAgICAgICAgH99IA9UrXxQIgQbIRAgBK0LIBAQ2gsMAQsgCRDmOiAFKAJoRQ0DIAUoAnhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAnQiBEsEQCAGIARrIQcgBSgCbCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAnQhBAsgBwRAIAUoAnAgBGpBACAH/AsACyAFIAY2AnQLIAUgCjYCeCAFKAJkIgQgBSgCXEYEQCAFQdwAakH0koABELMoCyAFKAJgIARBA3RqQgA3AwAgBSAEQQFqNgJkCyADQRBqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD/OzYCkAIgBUECNgL8ASAFQdSSgAE2AvgBIAVCAjcChAIgBUE7NgLsASAFQTs2AuQBIAUgBUHgAWo2AoACIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB+AFqQeSSgAEQ7ywAC0GglYABELI7AAsgBUGQAWoiAiAFQdwAaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQaACaiQADwtBBEE4EKM9AAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDtGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDtGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ/BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ/BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ/BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ/BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ/BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD8GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD8GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD2GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD2GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD1GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD1GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD7GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD7GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD0GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD0GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDuGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDuGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDxGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDxGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ7xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ7xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ7xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ7xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ7xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDvGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDvGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDwGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDwGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ9xkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ9xkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ9xkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ9xkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ9xkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD3GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD3GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ8hkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ8hkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ8hkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ8hkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ8hkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABDyGSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABDyGSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+BkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+BkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+BkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+BkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+BkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD4GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD4GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvbEgIGfwJ+IwBB4AFrIgUkACAFIAE2AmwgBSAANgJoAkAgBC0AxAFFDQAgBSABNgKkASAFIAA2AqABIAUgAjYCqAEgBSACIANBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ+RkgBSgCXCEAIAUoAlghByAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgACEGIAchCQwBCyAFKAJUIQEgByEJIAAhBgNAIAVByABqIAVBoAFqIAEQ+RkgBSgCSCIIIAcgCCAHIAUoAkwiASAAIAAgAUsbEJknIgcgASAAayAHG0EASCIKGyEHIAEgACAKGyEAIAkgCCAIIAkgASAGIAEgBkkbEJknIgkgASAGayAJG0EASCIIGyEJIAYgASAIGyEGIAVBQGsgBUGwAWoQwykgBSgCRCEBIAUoAkBBAXENAAsLIAVBsAFqIABBAEEBQQEQoBggBSgCtAEhAQJAIAUoArABQQFHBEAgBSgCuAEhCCAABEAgCCAHIAD8CgAACyAFIAA2ArgBIAUgCDYCtAEgBSABNgKwASAFQdABaiAFQbABaiIAEOcVIAAgBkEAQQFBARCgGCAFKAK0ASEAIAUoArABQQFGDQEgBSgCuAEhASAGBEAgASAJIAb8CgAACyAFIAY2ApgBIAUgATYClAEgBSAANgKQASAFQcABaiIAIAVBkAFqIggQ5xUgBUG4AWoiByAFQdgBaiIBKQIAIgs3AwAgBUH4AGogCzcDACAFQYABaiIGIAApAwA3AwAgBUGIAWoiACAFQcgBaikDADcDACAFIAUpAtABIgw3A7ABIAUgDDcDcCAFQZgBaiIJIAs3AwAgBSAMNwOQASABIAApAwA3AwAgBSAGKQMANwPQASAEQaABaiEBQQEhAAJAIAQoApwBIgZBAUYEQCABKAIARQ0BQQEhBiAFKAKQAQRAIAEgCBDGKSEGCyAGQf8BcUECRiAGwEEATHINASAEKAKcASEGCyAHIAkpAwA3AwAgBSAFKQOQATcDsAECQCAGRQ0AIAEoAgAiAEUNACAEQawBaiAEKAKkASAEKAKoASAAKAIQEQEACyAEQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQALIARBtAFqIQECQCAEKAKwASIGQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAQoArABIQYLIAVBuAFqIgcgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCAGRQ0AIAEoAgAiBkUNACAEQcABaiAEKAK4ASAEKAK8ASAGKAIQEQEACyAEQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAHKQMANwIACyAARQ0CIAUoApABIgBFDQIgBUGcAWogBSgClAEgBSgCmAEgACgCEBEBAAwCCyABIAUoArgBQbT1zQAQ/S8ACyAAIAUoArgBQbT1zQAQ/S8ACwJAIAQoApABQYCAgIB4Rg0AIAUgAjYCsAEgBSACIANBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgBEGQAWohACAFKAI8IQEDQCAFQTBqIAVB6ABqIAEQ+RkgACAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQEgBSgCKEEBcQ0ACwsCQAJAAkACQAJAIAQoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAEQdAAaiIGIAMQ7C0gA0UNASADQQJ0IQADQCAFQSBqIAVBsAFqIAIoAgAQ+RkgBCAFKAIgIAUoAiQiAxD1GyELIAQoAlgiASAEKAJQRgRAIAZB8PjNABCzKAsgAkEEaiECIAQoAlQgAUEDdGogCzcDACAEIAFBAWo2AlggBCAEKQNIIAOtfDcDSCAAQQRrIgANAAsMAQsgBSkCaCELIAQgBCgCiAEgA2o2AogBIAUgCzcC0AECQAJAAkBBAiAEKAJgIgBBgICAgHhzIABBAE4bQQFrDgIBAgALIANFDQIgBEHkAGohACADQQJ0IQYDQCAFQQhqIAVB0AFqIAIoAgAQ+RkgBSgCCCEDIAUgBSgCDCIBNgKwASAAIAVBsAFqQQQQoTYgACADIAEQoTYgBCAEKQOAASABrXw3A4ABIAJBBGohAiAGQQRrIgYNAAsMAgsgA0UNASAEQeQAaiEGIANBAnQhAANAIAVBEGogBUHQAWogAigCABD5GSAFKAIQIQMgBCgCcCEHIAUgBSgCFCIBNgKQASAFQfAAaiAHIAVBkAFqQQEQzxEgBSgCcEEIRw0DIAYgAyABEKE2IAQgBCkDgAEgAa18NwOAASACQQRqIQIgAEEEayIADQALDAELIANFDQAgBEHgAGohByACIANBAnRqIQkgBEHsAGohCANAIAVBGGogBUHQAWogAigCABD5GSAFKAIYIQZBACEBAkAgBCgCdCIAIAUoAhwiAyAAIANJGyIARQ0AIAQoAnAhCgNAIAEgCmotAAAgASAGai0AAEcNASAAIAFBAWoiAUcNAAsgACEBCyAEQQA2AnQgCCAGIAMQoTYgASADSw0DIAcgASAGaiADIAFrIgAQoTYgBCgCeCEGIAUgATYCkAEgBUHwAGoiCiAGIAVBkAFqIgZBARDPESAFKAJwQQhHDQQgBCgCfCEBIAUgADYCkAEgCiABIAZBARDPESAFKAJwQQhHDQUgBCAEKQOAASADrXw3A4ABIAJBBGoiAiAJRw0ACwsgBUHgAWokAA8LIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBoPbNABDVHgALIAEgA0HQ9s0AEK87AAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEHw9s0AENUeAAsgBUHAAWogBUGAAWopAwA3AwAgBUG4AWogBUH4AGopAwA3AwAgBSAFKQNwNwOwAUHI8c0AQSsgBUGwAWpBuPHNAEGA980AENUeAAvIEwIKfwZ+IwBBsAJrIgkkACAJIAc6AAsgASACEOMhIQEgCUGwAWogAyAEIAUgBiAHwBDfAQJAAkACQCAJKAKwAUEBRgRAIAlByABqIAkpArwBNwMAIAlB0ABqIAlBxAFqKAIANgIAIAkgCSkCtAE3A0AgCUEDNgIQIAlBrKWAATYCDCAJQgI3AhggCUH0CzYCfCAJQcQNNgJ0IAlBtJ2AATYCcCAJIAlB8ABqNgIUIAkgCUELajYCeCAJQZQBaiAJQQxqEJkOIAlBgoCAgHg2ApABIAlBQGsQiBEgAEEIaiAJQZgBaigCADYCACAAIAkpApABNwIAIAAgCSkCnAE3AgwMAQsgCSkD2AEhBiAJKQPQASEDIAkpA8gBIQQgCSkDwAEhBSAJQQxqIAFBDGoiERDcPBD4HiAILQA0IQIgERDcPCEQAkAgAkUEQCAQRQ0BIAlBGGohDEEQIQIgAyAFhCAEIAaEhCEYQQAhBwJAA0ACQAJAAkACfwJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NBSABKAIQIAJqIghBEGsiCikDACETIAopAwghFCAIKQMAIRYgCCkDCCEXIAkgBjcDWCAJIAM3A1AgCSAENwNIIAkgBTcDQCAJIBc3A6gBIAkgFjcDoAEgCSAUNwOYASAJIBM3A5ABQYeAgIB4IBhQDQIaIAlBsAFqIgggEyAUIBYgFyAFIAQgAyAGEJoIIAktALABQQFHDQEgCUECNgK0ASAJQfSXgAE2ArABIAlCAjcCvAEgCUGDDDYCrAIgCUGDDDYCpAIgCSAJQaACajYCuAEgCSAJQUBrNgKoAiAJIAlBkAFqNgKgAiAJQYwCaiAIEJkOIAkpAowCIQYgCSkClAIhFUGIgICAeAwCCyAMEOY6IAkoAhhFDQYgCSgCKEEBaiINQQN2IA1BB3FBAEdqIgogCSgCJCIISwRAIAogCGshDiAJKAIcIgsgCkkEQCAMIAtBAXQiCCAKQcD///8DcUFAayAKIApBP3EbIgsgCCALSxsQ6BkgCSgCJCEICyAOBEAgCSgCICAIakEAIA78CwALIAkgCjYCJAsgCSANNgIoIAkoAhQiCCAJKAIMRgRAIAlBDGpB9JKAARCzKAsgCSgCECAIQQN0akIANwMADAMLIAkgCSkD2AEiEzcDiAEgCSAJKQPQASIUNwOAASAJIAkpA8gBIhY3A3ggCSAJKQPAASIVNwNwIAkgEzcDyAEgCSAUNwPAASAJIBY3A7gBIAkgFTcDsAEgCUFAayAJQbABaiIIENMeIAkoAkANASAJQZACakGFipQoNgIAIAlChYqUqNCgwYIFNwOIAiAJQQI2ArQBIAlB4KWAATYCsAEgCUICNwK8ASAJQa0DNgKcASAJQYMMNgKUASAJIAlBkAFqNgK4ASAJIAlBiAJqIgE2ApgBIAkgCUHwAGo2ApABIAlBxABqIAgQmQ4gARCpDCAJKQJEIQYgCSkCTCEVQYKAgIB4CyEBIAAgFTcCDCAAIAY3AgQgACABNgIAIAlBDGoQui0MBwsgCSkDSCETAkAgCSgCGARAIAkoAigiDUEBaiIOQQN2IA5BB3FBAEdqIgggCSgCJCIKSwRAIAggCmshCyAJKAIcIg8gCEkEQCAMIA9BAXQiCiAIQcD///8DcUFAayAIIAhBP3EbIg8gCiAPSxsQ6BkgCSgCJCEKCyALBEAgCSgCICAKakEAIAv8CwALIAkgCDYCJAsgCSAONgIoIAkoAiAgDUEDdmoiCCAILQAAQQEgDUEHcXRyOgAADAELIAkgCSgCLEEBajYCLAsgCSgCFCIIIAkoAgxGBEAgCUEMakGEk4ABELMoCyAJKAIQIAhBA3RqIBM3AwALIAkgCEEBajYCFCACQSBqIQIgECAHQQFqIgdHDQEMBAsLIAkgARCAPDYCkAEgCUECNgK0ASAJQdSSgAE2ArABIAlCAjcCvAEgCUE7NgJMIAlBOzYCRCAJIAlBQGs2ArgBIAkgCUGQAWo2AkggCSAJQYgCajYCQAwFC0GglYABELI7AAsgEEUNACAJQRhqIQ0gCUFAa0EEciEMIAlBjAJqIQ8gAyAFhCAEIAaEhCEXQRAhAkEAIQcCQANAAkACQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQIgASgCECACaiIIQRBrIgopAwAhFSAKKQMIIRMgCCkDACEUIAgpAwghFiAJIAY3A6gBIAkgAzcDoAEgCSAENwOYASAJIAU3A5ABIAkgFjcDiAEgCSAUNwOAASAJIBM3A3ggCSAVNwNwIAlBDGoCfgJAIBdQRQRAIAlBsAFqIgggFSATIBQgFiAFIAQgAyAGEJoIIAktALABQQFGBEAgCUECNgK0ASAJQfSXgAE2ArABIAlCAjcCvAEgCUGDDDYCrAIgCUGDDDYCpAIgCSAJQaACajYCuAEgCSAJQZABajYCqAIgCSAJQfAAajYCoAIgDyAIEJkOIAlBiICAgHg2AogCIAwgCSkCiAI3AgAgDEEIaiAJQZACaikCADcCACAMQRBqIAlBmAJqKAIANgIADAILIAkpA8ABIRUgCSkDyAEhEyAJKQPQASEUIAkgCSkD2AE3A8gBIAkgFDcDwAEgCSATNwO4ASAJIBU3A7ABIAlBQGsgCUGwAWoQ0x4gCSkDQAwCCyAJQYeAgIB4NgJECyAJQQE2AkAgDBCIEUIACyAJKQNIENoLDAELIA0Q5jogCSgCGEUNAyAJKAIoQQFqIg5BA3YgDkEHcUEAR2oiCiAJKAIkIghLBEAgCiAIayELIAkoAhwiEiAKSQRAIA0gEkEBdCIIIApBwP///wNxQUBrIAogCkE/cRsiEiAIIBJLGxDoGSAJKAIkIQgLIAsEQCAJKAIgIAhqQQAgC/wLAAsgCSAKNgIkCyAJIA42AiggCSgCFCIIIAkoAgxGBEAgCUEMakH0koABELMoCyAJKAIQIAhBA3RqQgA3AwAgCSAIQQFqNgIUCyACQSBqIQIgECAHQQFqIgdHDQEMAwsLIAkgARCAPDYCcCAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2ApwBIAlBOzYClAEgCSAJQZABajYCuAEgCSAJQfAAajYCmAEgCSAJQYgCajYCkAEMBAtBoJWAARCyOwALIAlBsAFqIgIgCUEMaiIHENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACAHELotCyAJQbACaiQADwtBBEE4EKM9AAsgCUGwAWpB5JKAARDvLAALyRMCCn8GfiMAQbACayIJJAAgCSAHOgALIAEgAhDjISEBIAlBsAFqIAMgBCAFIAYgB8AQ3wECQAJAAkAgCSgCsAFBAUYEQCAJQcgAaiAJKQK8ATcDACAJQdAAaiAJQcQBaigCADYCACAJIAkpArQBNwNAIAlBAzYCECAJQaylgAE2AgwgCUICNwIYIAlB9As2AnwgCUHEDTYCdCAJQbSdgAE2AnAgCSAJQfAAajYCFCAJIAlBC2o2AnggCUGUAWogCUEMahCZDiAJQYKAgIB4NgKQASAJQUBrEIgRIABBCGogCUGYAWooAgA2AgAgACAJKQKQATcCACAAIAkpApwBNwIMDAELIAkpA9gBIQYgCSkD0AEhAyAJKQPIASEEIAkpA8ABIQUgCUEMaiABQQxqIhEQ3DwQ7x4gCC0ANCECIBEQ3DwhEAJAIAJFBEAgEEUNASAJQRhqIQxBECECIAMgBYQgBCAGhIQhGEEAIQcCQANAAkACQAJAAn8CQCABIAcQhyVFBEAgCSAHNgKIAiARENw8IAdNDQUgASgCECACaiIIQRBrIgopAwAhEyAKKQMIIRQgCCkDACEWIAgpAwghFyAJIAY3A1ggCSADNwNQIAkgBDcDSCAJIAU3A0AgCSAXNwOoASAJIBY3A6ABIAkgFDcDmAEgCSATNwOQAUGHgICAeCAYUA0CGiAJQbABaiIIIBMgFCAWIBcgBSAEIAMgBhCaCCAJLQCwAUEBRw0BIAlBAjYCtAEgCUH0l4ABNgKwASAJQgI3ArwBIAlBgww2AqwCIAlBgww2AqQCIAkgCUGgAmo2ArgBIAkgCUFAazYCqAIgCSAJQZABajYCoAIgCUGMAmogCBCZDiAJKQKMAiEGIAkpApQCIRVBiICAgHgMAgsgDBDmOiAJKAIYRQ0GIAkoAihBAWoiDUEDdiANQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQ4gCSgCHCILIApJBEAgDCALQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyILIAggC0sbEOgZIAkoAiQhCAsgDgRAIAkoAiAgCGpBACAO/AsACyAJIAo2AiQLIAkgDTYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQsygLIAkoAhAgCEEDdGpCADcDAAwDCyAJIAkpA9gBIhM3A4gBIAkgCSkD0AEiFDcDgAEgCSAJKQPIASIWNwN4IAkgCSkDwAEiFTcDcCAJIBM3A8gBIAkgFDcDwAEgCSAWNwO4ASAJIBU3A7ABIAlBQGsgCUGwAWoiCBCRHyAJKAJADQEgCUGQAmpBiZKkyAA2AgAgCUKJkqTIkKHChAk3A4gCIAlBAjYCtAEgCUHgpYABNgKwASAJQgI3ArwBIAlBrQM2ApwBIAlBgww2ApQBIAkgCUGQAWo2ArgBIAkgCUGIAmoiATYCmAEgCSAJQfAAajYCkAEgCUHEAGogCBCZDiABEKkMIAkpAkQhBiAJKQJMIRVBgoCAgHgLIQEgACAVNwIMIAAgBjcCBCAAIAE2AgAgCUEMahC6LQwHCyAJKQNIIRMCQCAJKAIYBEAgCSgCKCINQQFqIg5BA3YgDkEHcUEAR2oiCCAJKAIkIgpLBEAgCCAKayELIAkoAhwiDyAISQRAIAwgD0EBdCIKIAhBwP///wNxQUBrIAggCEE/cRsiDyAKIA9LGxDoGSAJKAIkIQoLIAsEQCAJKAIgIApqQQAgC/wLAAsgCSAINgIkCyAJIA42AiggCSgCICANQQN2aiIIIAgtAABBASANQQdxdHI6AAAMAQsgCSAJKAIsQQFqNgIsCyAJKAIUIgggCSgCDEYEQCAJQQxqQYSTgAEQsygLIAkoAhAgCEEDdGogEzcDAAsgCSAIQQFqNgIUIAJBIGohAiAQIAdBAWoiB0cNAQwECwsgCSABEIA8NgKQASAJQQI2ArQBIAlB1JKAATYCsAEgCUICNwK8ASAJQTs2AkwgCUE7NgJEIAkgCUFAazYCuAEgCSAJQZABajYCSCAJIAlBiAJqNgJADAULQaCVgAEQsjsACyAQRQ0AIAlBGGohDSAJQUBrQQRyIQwgCUGMAmohDyADIAWEIAQgBoSEIRdBECECQQAhBwJAA0ACQAJAIAEgBxCHJUUEQCAJIAc2AogCIBEQ3DwgB00NAiABKAIQIAJqIghBEGsiCikDACEVIAopAwghEyAIKQMAIRQgCCkDCCEWIAkgBjcDqAEgCSADNwOgASAJIAQ3A5gBIAkgBTcDkAEgCSAWNwOIASAJIBQ3A4ABIAkgEzcDeCAJIBU3A3AgCUEMagJ+AkAgF1BFBEAgCUGwAWoiCCAVIBMgFCAWIAUgBCADIAYQmgggCS0AsAFBAUYEQCAJQQI2ArQBIAlB9JeAATYCsAEgCUICNwK8ASAJQYMMNgKsAiAJQYMMNgKkAiAJIAlBoAJqNgK4ASAJIAlBkAFqNgKoAiAJIAlB8ABqNgKgAiAPIAgQmQ4gCUGIgICAeDYCiAIgDCAJKQKIAjcCACAMQQhqIAlBkAJqKQIANwIAIAxBEGogCUGYAmooAgA2AgAMAgsgCSkDwAEhFSAJKQPIASETIAkpA9ABIRQgCSAJKQPYATcDyAEgCSAUNwPAASAJIBM3A7gBIAkgFTcDsAEgCUFAayAJQbABahCRHyAJKQNADAILIAlBh4CAgHg2AkQLIAlBATYCQCAMEIgRQgALIAkpA0gQ2gsMAQsgDRDmOiAJKAIYRQ0DIAkoAihBAWoiDkEDdiAOQQdxQQBHaiIKIAkoAiQiCEsEQCAKIAhrIQsgCSgCHCISIApJBEAgDSASQQF0IgggCkHA////A3FBQGsgCiAKQT9xGyISIAggEksbEOgZIAkoAiQhCAsgCwRAIAkoAiAgCGpBACAL/AsACyAJIAo2AiQLIAkgDjYCKCAJKAIUIgggCSgCDEYEQCAJQQxqQfSSgAEQsygLIAkoAhAgCEEDdGpCADcDACAJIAhBAWo2AhQLIAJBIGohAiAQIAdBAWoiB0cNAQwDCwsgCSABEIA8NgJwIAlBAjYCtAEgCUHUkoABNgKwASAJQgI3ArwBIAlBOzYCnAEgCUE7NgKUASAJIAlBkAFqNgK4ASAJIAlB8ABqNgKYASAJIAlBiAJqNgKQAQwEC0GglYABELI7AAsgCUGwAWoiAiAJQQxqIgcQ2RRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGgooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAcQui0LIAlBsAJqJAAPC0EEQTgQoz0ACyAJQbABakHkkoABEO8sAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDbPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDyEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDbPBDuLSACKAIUIgdBAnYhCiACKAIQIQICQAJAIAdBBE8EQCAKQQJ0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQRqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQRrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EETwRAIApBAnQhBANAIANBCGogASACKAIAEIAXIANB0ABqIAMoAgggAygCDBChNiACQQRqIQIgBEEEayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2zwQ7i0gAigCFCIJQQJ2IQogAigCECECIAlBBE8EQCAKQQJ0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEEaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EEayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBBE8EQCAKQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEIAXIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENs8EO4tIAIoAhQiCkECdiELIAIoAhAhBQJAIApBBE8EQCALQQJ0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EEaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBBGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQRPBEAgC0ECdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABCAFyADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQRqIQUgBEEBaiEEIAJBBGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2zwQ7i0gAigCFCIKQQJ2IQsgAigCECEFAkACQCAKQQRPBEAgC0ECdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBBGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQRrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEETwRAIAtBAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEIAXIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGUqNCgATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClKjQoMGChYoUNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDbPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDyEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDbPBDuLSACKAIUIgdBAnYhCiACKAIQIQICQAJAIAdBBE8EQCAKQQJ0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQRqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQRrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EETwRAIApBAnQhBANAIANBCGogASACKAIAEP8WIANB0ABqIAMoAgggAygCDBChNiACQQRqIQIgBEEEayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2zwQ7i0gAigCFCIJQQJ2IQogAigCECECIAlBBE8EQCAKQQJ0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEEaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EEayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBBE8EQCAKQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEP8WIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENs8EO4tIAIoAhQiCkECdiELIAIoAhAhBQJAIApBBE8EQCALQQJ0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EEaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBBGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQRPBEAgC0ECdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABD/FiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQRqIQUgBEEBaiEEIAJBBGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2zwQ7i0gAigCFCIKQQJ2IQsgAigCECEFAkACQCAKQQRPBEAgC0ECdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBBGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQRrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEETwRAIAtBAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEP8WIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGYsODAATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmLDgwIGDhowYNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDYPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDYPBDuLSACKAIUIgdBA3YhCiACKAIQIQICQAJAIAdBCE8EQCAKQQN0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQhqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQhrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EITwRAIApBA3QhBANAIANBCGogASACKAIAEIAXIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2DwQ7i0gAigCFCIJQQN2IQogAigCECECIAlBCE8EQCAKQQN0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEIaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EIayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBCE8EQCAKQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEIAXIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENg8EO4tIAIoAhQiCkEDdiELIAIoAhAhBQJAIApBCE8EQCALQQN0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EIaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBCGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQhPBEAgC0EDdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABCAFyADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQhqIQUgBEEBaiEEIAJBCGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2DwQ7i0gAigCFCIKQQN2IQsgAigCECEFAkACQCAKQQhPBEAgC0EDdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBCGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQhrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEITwRAIAtBA3QhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEIAXIANB0ABqIAMoAhggAygCHBChNgsgBUEIaiEFIARBAWohBCAHQQhrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGUqNCgATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClKjQoMGChYoUNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAueEQIMfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBRDYPEEBakEAQQRBBBCgGCADKAI8IQcCQAJAAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBjYCMCADIAc2AiwgBwR/IAYFIANBLGpB8KuCARCdKCADKAIwC0EANgIAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkECdiEIAkACQCABELc6DQAgAhCuOg0AIANBLGogBRDYPBDuLSACKAIUIgdBA3YhCiACKAIQIQICQAJAIAdBCE8EQCAKQQN0IQkgAiEGA0AgBigCACIFQQFqIgsgCE8NAiAFIAhPDQMgDCALQQJ0aigCACAMIAVBAnRqKAIAayAEaiIEQQBIDQogAygCNCIFIAMoAixGBEAgA0EsakHQrIIBEJ0oCyAGQQhqIQYgAygCMCAFQQJ0aiAENgIAIAMgBUEBajYCNCAJQQhrIgkNAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0DQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgB0EITwRAIApBA3QhBANAIANBCGogASACKAIAEP8WIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMCQsgCyAIQbCsggEQwyEACyAFIAhBwKyCARDDIQALIAIQrjoNAiADQSxqIAUQ2DwQ7i0gAigCFCIJQQN2IQogAigCECECIAlBCE8EQCAKQQN0IQcgAiEFA0AgASAFKAIAIgYQlTsEQCAGQQFqIgsgCE8NByAGIAhPDQYgDCALQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCdKAsgBUEIaiEFIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgB0EIayIHDQALCyADQbABaiAEQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUcEQEEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIAlBCE8EQCAKQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEP8WIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAcLIAUgAygCuAFB8KyCARD9LwALIAUgAygCuAFBkKyCARD9LwALIAcgAygCQEHgq4IBEP0vAAsgARC3OgRAAkACQCADKAI4BEAgA0EsaiAFENg8EO4tIAIoAhQiCkEDdiELIAIoAhAhBQJAIApBCE8EQCALQQN0IQkgAygCSCEOQQAhAiAFIQcDQCACIA5GDQIgAygCPCACIAMoAkRqIgZBA3ZqLQAAIAZBB3F2QQFxBEAgBygCACIGQQFqIg0gCE8NBiAGIAhPDQUgDCANQQJ0aigCACAEaiAMIAZBAnRqKAIAayIEQQBIDQoLIAMoAjQiBiADKAIsRgRAIANBLGpBgK+CARCdKAsgB0EIaiEHIAMoAjAgBkECdGogBDYCACADIAZBAWo2AjQgAkEBaiECIAlBCGsiCQ0ACwsgA0GwAWogBEEAQQFBARCgGCADKAK0ASECIAMoArABQQFHBEBBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCAKQQhPBEAgC0EDdCECIAMoAkghBwNAAkAgBCAHRwRAIAMoAjwgBCADKAJEaiIGQQN2ai0AACAGQQdxdkEBcUUNASADQSBqIAEgBSgCABD/FiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAFQQhqIQUgBEEBaiEEIAJBCGsiAg0ACyADKAJYIQQLDAkLIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIAYgCEHwroIBEMMhAAsgDSAIQeCuggEQwyEACyADQSxqIAUQ2DwQ7i0gAigCFCIKQQN2IQsgAigCECEFAkACQCAKQQhPBEAgC0EDdCENQQAhBiAFIQcDQCAHKAIAIQkgAiAGEIs7BEAgCUEBaiIOIAhPDQQgCCAJTQ0DIAwgDkECdGooAgAgBGogDCAJQQJ0aigCAGsiBEEASA0HCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQnSgLIAdBCGohByADKAIwIAlBAnRqIAQ2AgAgAyAJQQFqNgI0IAZBAWohBiANQQhrIg0NAAsLIANBsAFqIARBAEEBQQEQoBggAygCtAEhByADKAKwAUEBRwRAQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAc2AlAgCkEITwRAIAtBA3QhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEP8WIANB0ABqIAMoAhggAygCHBChNgsgBUEIaiEFIARBAWohBCAHQQhrIgcNAAsgAygCWCEECwwGCyAHIAMoArgBQdCtggEQ/S8ACyAJIAhBgK6CARDDIQALIA4gCEHwrYIBEMMhAAsgBiAIQaCtggEQwyEACyALIAhBkK2CARDDIQALIAAgBDYCCCAAQZKAgIB4NgIEIABBKToAAAJAIAMoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0E4ahD7HgsgA0EsahDpOwwBCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEPIANB7ABqIANBoAFqEOgYIAMgBDYCuAEgAyAPNwOwASADQfgAaiADQbABahCTGSADQegAakGYsODAATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmLDgwIGDhowYNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAAAsgA0HAAWokAAvMIAIkfwJ+IwBBMGsiCCQAIAAoAhwiAigCIEGGAmshHSACLQAHIQQgAUH/AXEhHiACLwE2QYAISyEfAn8DQAJAIAQhIAJAAkAgAigCJCIDQYYCTwRAIAIoAhAhAwwBCyACKAIgIgRBAXQhBiAEQYYCayELA0ACQCACKAJQIAMgAigCECIFamshAwJAAkACQAJAAkACQAJAAkACQCALIAIoAiBqIAVNBEAgBiACKAIYIgVLDQEgBEEASA0CIAQEQCACKAIUIgUgBCAFaiAE/AoAAAsgAiACLwEMIgUgBEH//wNxIgdrIglBACAFIAlPGzsBDCAFIAdNBEAgAkEAOwE0CyACIAIoAhAgBGsiBTYCECACIAIoAjwgBGs2AjwgAiAFIAIoAoABIgcgBSAHSRs2AoABIAIQlBYgAyAEaiEDCyAAKAIERQRAIAAoAhwhAgwKCyADQQFNDQIgACAAKAIcIgIoAiQgAigCEGogAxDMEyECIAAoAhwiAyACIAMoAiRqIgU2AiQgBSADKAKAASICakEDSQ0IIAMoAhAiByACayEFIAMvATZBgAhNBEAgAiAHRg0IIAVBAWshAiADLQAGQQFGBEAgAyACENkZGgwJCyADKAIYIgcgAkkNBCAHIAJrIgdBA00NBSADKAIwIAMoAhQgAmooAABBsfPd8XlsQQ92Qf7/B3FqIgkvAQAiEiACQf//A3FGDQggAygCIEEBayACcSIHIAMoAiwiFk8NBiADKAIoIAdBAXRqIBI7AQAgCSACOwEADAgLIAMoAhgiAiAFTQRAIAUgAkH45/wAEMMhAAsgBUEBaiIHIAJJDQYgByACQYjo/AAQwyEACyAGIAVBuOf8ABCwOwALIAhBADYCKCAIQQE2AhwgCEHw4/wANgIYIAhCBDcCICAIQRhqQcjn/AAQ7ywACyAIQQA2AiggCEEBNgIcIAhB4Of8ADYCGCAIQgQ3AiAgCEEYakHo5/wAEO8sAAsgAiAHQZjk/AAQrzsAC0EEIAdBqOT8ABCwOwALIAcgFkG45PwAEMMhAAsgAyADKAIUIgIgBWotAABBBXQgAiAHai0AACICcyACQbHz3fF5bEEQdiADLQAGGzYChAELIAMoAoABIAMoAiRBAUZrIgJFDQACQCADLQAGQQFGBEAgAyAFIAIQ4BMMAQsgAyAFIAIQ6xQLIAMgAygCgAEgAms2AoABCyAAKAIcIgIoAiQiA0GFAksNACAAKAIEDQELCyACKAIQIgMgAigCUEGGAmtLBEAgCEEANgIoIAhBATYCHCAIQbTo/AA2AhggCEIENwIgIAhBGGpBvOj8ABDvLAALIAIoAiQiBEGGAk8NACAeRQ0CIARFBEACQCACLQAHRQ0AIANBAWsiAyACKAIYIgRJBEAgAkFAayACQaQBaiACKAIUIANqLQAAEJYjGiAAKAIcQQA6AAcgACgCHCICKAIQIQMMAQsgAyAEQfjj/AAQwyEACyACQQIgAyADQQJPGzYCgAECQCABQf8BcUEERwRAIAAoAhwoAkgNAUEBDAcLIABBARCSAUEDQQIgACgCEBsMBgsgAEEAEJIBIAAoAhBBAEcMBQsgBEEDSw0AIAIgAi8BDDsBDiAAKAIcIQJBAiEDDAELAkACQAJAAkAgAi0ABkEBRgRAIAIgAxDZGSEEDAELIAIoAhgiBCADSQ0BIAQgA2siBEEDTQ0CIAIoAjAgAigCFCADaigAAEGx893xeWxBD3ZB/v8HcWoiBi8BACIEIANB//8DcUYNACACKAIgQQFrIANxIgUgAigCLCIHTw0DIAIoAiggBUEBdGogBDsBACAGIAM7AQALIAAoAhwiAyADLwEMOwEOQQIhAyAAKAIcIgIoAhAgBEH//wNxIgVrIgZBAEwgBiAdSnIgBUVyDQMgAi8BNCACLwE4Tw0DAn8gH0UEQCAIQRBqIAIgBBCTByAIKAIQIQMgCC8BFAwBCyAIQQhqIRxBACEHQQAhDCMAQSBrIgokAAJAAkACQAJAAn8CQAJAAkAgAigCGCIPIAIoAhAiDU8EQEF/QXlBfSACLwE0IgNBAiADGyIDQQdLGyADQQNNGyADaiIJIA9LDQEgAi8BDCEWIAIoAhQiECANaiERIA8gDWshEyACKAIkIRogAi8BCCEXIAIvATYhDiANIAIoAiAiGGtBhgJqIgVBACAFIA1NGyESIAkgEGohFCACLwEKISEgA0EDSQRAIBIhCyAQDAULIBBFIAMgE09yDQIgEUEDaiEFAn8gAi0ABiILQQFGBEAgES0AAiARLQABQQV0cwwBCyARLQACQbHz3fF5bEEQdgshBiADIAVqQQJrIAVGDQMgA0ECayEZIAIoAjAhGwNAIBsgBSAMai0AACIVIAZBBXRB4P8BcXMgFUGx893xeWxBEHYgCxsiBkEBdGovAQAiFSAEQf//A3EiBCAEIBVLIhUbIQQgDEEBaiIMIAcgFRshByAMIBlHDQALDAMLIA0gD0Go4fwAEK87AAsgCSAPQbjh/AAQrzsACyAKQQA2AhggCkEBNgIMIApBzOP8ADYCCCAKQgQ3AhAgCkEIakHU4/wAEO8sAAsgBEH//wNxIAcgEmoiC0H//wNxTQ0BIBQgB0H//wNxIgVrIRQgECAFawshBSAPIAkgDWoiBk8EQCACKAJQIglBhgJrIgxBACAJIAxPGyANTwRAIA0gBEH//wNxTQ0FIBhBAWshGCAOIA5BAnYgAyAXSRshDCAGIBBqIRkgDUEBayEbIBFBAmohFSAJIBBqQQFrISIgAigCMCEjIAIoAighFyACKAIsIQ4gE0ECa0H/AUshJCACLQAGQQFxISUDQAJAAkACQAJAAkACQAJAAkAgA0EITwRAIBkpAAAhJgNAICYgFCAEQf//A3EiAmopAABRBEAgAiAFaikAACARKQAAUQ0DCyAMQQFrIgxB//8DcUUNECAOIAIgGHEiBEsEQCAXIARBAXRqLwEAIgQgC0H//wNxSw0BDBELCyAEIA5BgOL8ABDDIQALIBEpAAAhJgNAICYgBSAEQf//A3EiBmopAAAiJ1ENASAmICeFeqdBA3YiAiADSw0CIAxBAWsiDEH//wNxRQ0PIA4gBiAYcSIESwRAIBcgBEEBdGovAQAiBCALQf//A3FLDQEMEAsLIAQgDkGQ4vwAEMMhAAsgE0EBTQ0BICRFDQIgBSAEQf//A3FqQQJqIQJBACEGA0ACQCAGIBVqLQAAIAIgBmotAABHBEAgBiEJDAELQYACIQkgBkEBaiIGQYACRw0BCwsgCUECaiECCyACIBFqICJLDQICQCACIANLBEAgBCAHayEWIAIgGksEQCAaIQMMDwsgAiAhTw0NAkACQCACQQRPBEBBeUF9IAJBB0sbIAJqIgkgDWoiBiAPTQ0BDA8LIAIgG2oiBiAPSw0OIAJBAWshCSAGIBBqIRkMAQsgBiAQaiEZIAIgFkH//wNxIhRqIA1JDQILIAUgCWohFCACIQMLIAxBAWsiDEH//wNxRQ0NIAQgGHFB//8DcSIEIA5PDQQgFyAEQQF0ai8BACIEIAtB//8DcU0NDQwGCyACQQNrIQdBACEFIBYhA0EAIQQDQAJAIA4gBCAUaiAYcSIGSwRAIBcgBkEBdGovAQAiBiADQf//A3FJBEAgBCEFIAYiAyAEIBJqQf//A3FNDQ8LIAQgB0kNAQwHCyAGIA5BsOP8ABDDIQALIAQgBCAHSWoiBCAHTQ0ACwwEC0ECIBNBoOL8ABCvOwALQdjv/AAQsjsACyAKQQA2AhggCkEBNgIMIApBvOL8ADYCCCAKQgQ3AhAgCkEIakHE4vwAEO8sAAsgBCAOQeTi/AAQwyEACwJAIAJBBGsiByATTQRAIBMgB2tBAk0NASAHIBFqIgQtAAIhBgJAICMCfyAlBEAgBC0AAEEKdEGA+AFxIAQtAAFBBXRzIAZzDAELIAZBsfPd8XlsQRB2C0EBdGovAQAiBCADQf//A3FPBEAgBSASaiELIAUhByADIQQMAQsgBCAHIBJqIgtB//8DcU0NCQsgECAHQf//A3FrIgUgCWohFCACIQMMAgsgByATQfTi/AAQrzsACyAKQQA2AhggCkEBNgIMIApBmOP8ADYCCCAKQgQ3AhAgCkEIakGg4/wAEO8sAAsgDSAEQf//A3FLDQALDAULIApBADYCGCAKQQE2AgwgCkHo4fwANgIIIApCBDcCECAKQQhqQfDh/AAQ7ywACyAGIA9ByOH8ABCvOwALIBogAyADIBpLGyEDDAILIAYgD0HU4vwAEK87AAsgAiEDCyAcIBY7AQQgHCADNgIAIApBIGokACAIKAIIIQMgCC8BDAshBCAAKAIcIAQ7AQwgACgCHCECIANBBUsNA0ECIAMgAi0AA0EBRhshAwwDCyADIARBmOT8ABCvOwALQQQgBEGo5PwAELA7AAsgBSAHQbjk/AAQwyEACwJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLwE0IgVBA0kgAyAFS3IiBARAICBBAXENASACIAM7ATQgACgCHEEBOgAHIAAoAhwiAyADKAIQQQFqNgIQIAAoAhwiAyADKAIkQQFrNgIkDAwLIAIoAkQiBiACKAJIIgNJDQMgBiADayIGQQJNDQQgAi8BDiELIAIoAhAhBiACKAIkIQkgAigCQCADaiIHIAVBA2siAzoAAiAHIAYgC0F/c2oiBUEIdjoAASAHIAU6AAAgAiACKAJIQQNqNgJIIAJB/wEgAi0AOkEBaiIHIAdB/wFPGzoAOiAFQQFrIgUgAigCIEGGAmtPDQUgBRDKKkH/AXFBHk8NBSADQYACTw0GIAIgA0GY5fwAai0AAEECdGpBrAlqIgMgAy8BAEEBajsBACAFEMoqQf8BcSIDQT1PDQcgAiADQQJ0aiIDIAMvAaQTQQFqOwGkEyACKAJIIQcgAigCRCAAKAIcIgMgAy8BNEEBazsBNCAAKAIcIgMgAygCJCADLwE0azYCJEEDayELIAAoAhwiAy8BNCECIAYgCWpBA2siBiADKAIQIgVNDQIgBiAFayIGIAJBAWsiCSAGIAlJGyEGIAVBAWohBSADLQAGQQFHDQEgAyAFIAYQ4BMMAgsgAigCEEEBayIFIAIoAhgiBk8NByACQUBrIAJBpAFqIAIoAhQgBWotAAAQliMNCAwJCyADIAUgBhDrFAsgACgCHEEAOwE0IAAoAhxBADoAByAAKAIcIgMgAygCECACajYCECAHIAtHDQggAEEAEJIBQQAgACgCEEUNCxoMCAsgAyAGQcjk/AAQrzsAC0EDIAZB2OT8ABCwOwALIAhBADYCKCAIQQE2AhwgCEGA5fwANgIYIAhCBDcCICAIQRhqQYjl/AAQ7ywACyADQYACQZjn/AAQwyEACyADQT1BqOf8ABDDIQALIAUgBkGI5PwAEMMhAAsgAEEAEJIBCyAAKAIcIAM7ATQgACgCHCIDIAMoAhBBAWo2AhAgACgCHCIDIAMoAiRBAWs2AiQgACgCEEUNAQsgACgCHCECDAELC0EACyAIQTBqJAALyhMCCn8FfkIKIRAjAEGgAmsiBSQAIAUgAzoAWyABIAIQ/CEhASAFIAPAIgI2ApACIAVCADcD6AEgBUIKNwPgAUIBIRECQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBADYCVCAFQUBrIBEgEiAQIA8gBUHUAGoQ9gwgBSgCVA0DIAUpA0ghEiAFKQNAIREgAkEBRg0CCyAFQQA2AjwgBUEgaiAQIA8gECAPIAVBPGoQ9gwgBSgCPA0CIAUpAyghDyAFKQMgIRAgAkEBdiECDAALAAsgBUHcAGogAUEMaiINENo8EO8eIAQtADQgDRDaPCEMDQMgDEUNBCAFQegAaiEIQQAhA0EAIQIDQAJAAkACfwJAIAEgAhCHJUUEQCAFIAI2ApACIA0Q2jwgAk0NByABKAIQIANqIgQpAwAhDyAFIAQpAwgiEDcD2AEgBSAPNwPQASAFIBE3A5ACIAUgEjcDmAJBh4CAgHggESAShFANAhogESASg0J/UiAPIBBCgICAgICAgICAf4WEQgBScg0BIAVBAjYClAEgBUH0l4ABNgKQASAFQgI3ApwBIAVB+w82AuwBIAVB+w82AuQBIAUgBUHgAWo2ApgBIAUgBUGQAmo2AugBIAUgBUHQAWo2AuABIAVB/AFqIAVBkAFqEJkOIAUpAvwBIQ8gBSkChAIhE0GIgICAeAwCCyAIEOY6IAUoAmhFDQcgBSgCeEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCdCIESwRAIAYgBGshCiAFKAJsIgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCdCEECyAKBEAgBSgCcCAEakEAIAr8CwALIAUgBjYCdAsgBSAJNgJ4IAUoAmQiBCAFKAJcRgRAIAVB3ABqQfSSgAEQsygLIAUoAmAgBEEDdGpCADcDAAwDCyAFQRBqIA8gECARIBIQgxkgBSAFKQMYIg83A8gBIAUgBSkDECITNwPAASAPUA0BIAVBmAJqQYmSpMgANgIAIAVCiZKkyJChwoQJNwOQAiAFQQI2ApQBIAVB4KWAATYCkAEgBUICNwKcASAFQa0DNgLsASAFQfsPNgLkASAFIAVB4AFqNgKYASAFIAVBkAJqIgE2AugBIAUgBUHAAWo2AuABIAVB/AFqIAVBkAFqEJkOIAEQqQwgBSkC/AEhDyAFKQKEAiETQYKAgIB4CyEBIAAgEzcCDCAAIA83AgQgACABNgIAIAVB3ABqELotDAgLAkAgBSgCaARAIAUoAngiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCdCIGSwRAIAQgBmshByAFKAJsIgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCdCEGCyAHBEAgBSgCcCAGakEAIAf8CwALIAUgBDYCdAsgBSAKNgJ4IAUoAnAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCfEEBajYCfAsgBSgCZCIEIAUoAlxGBEAgBUHcAGpBhJOAARCzKAsgBSgCYCAEQQN0aiATNwMACyAFIARBAWo2AmQgA0EQaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AmAgBUGImIABNgJcIAVCAjcCaCAFQfoPNgKcASAFQfsPNgKUASAFIAVBkAFqIgE2AmQgBSAFQZACajYCmAEgBSAFQeABaiICNgKQASAFQfwBaiIDIAVB3ABqIgQQmQ4gBUGIgICAeDYC+AEgBUGYAWogBUGAAmoiBigCADYCACAFIAUpAvgBNwOQASAFIAUpAoQCNwKcASAFQQM2AmAgBUGspYABNgJcIAVCAjcCaCAFQfQLNgLsASAFQcQNNgLkASAFQcidgAE2AuABIAUgAjYCZCAFIAVB2wBqNgLoASADIAQQmQ4gBUGCgICAeDYC+AEgARCIESAAQQhqIAYoAgA2AgAgACAFKQL4ATcCACAAIAUpAoQCNwIMDAQLIAUgARD/OzYC4AEgBUECNgKUASAFQdSSgAE2ApABIAVCAjcCnAEgBUE7NgKEAiAFQTs2AvwBIAUgBUH4AWo2ApgBIAUgBUHgAWo2AoACIAUgBUGQAmo2AvgBIAVBkAFqQeSSgAEQ7ywAC0GglYABELI7AAsgDEUNACAFQegAaiEJIAVBkAFqQQRyIQggBUHkAWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDaPCACTQ0CIAEoAhAgA2oiBCkDACEPIAUgBCkDCCITNwPIASAFIA83A8ABIAUgETcD0AEgBSASNwPYASAFQdwAagJ+AkACQCARIBKEUEUEQCARIBKDQn9SIA8gE0KAgICAgICAgIB/hYRCAFJyDQIgBUECNgL8ASAFQfSXgAE2AvgBIAVCAjcChAIgBUH7DzYCnAIgBUH7DzYClAIgBSAFQZACajYCgAIgBSAFQdABajYCmAIgBSAFQcABajYCkAIgCyAFQfgBahCZDiAFQYiAgIB4NgLgASAIIAUpAuABNwIAIAhBCGogBUHoAWopAgA3AgAgCEEQaiAFQfABaigCADYCAAwBCyAFQYeAgIB4NgKUAQsgBUEBNgKQASAIEIgRQgAMAQsgBSAPIBMgESASEIMZIAUpAwAgECAFKQMIUCIEGyEQIAStCyAQENoLDAELIAkQ5jogBSgCaEUNAyAFKAJ4QQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJ0IgRLBEAgBiAEayEHIAUoAmwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJ0IQQLIAcEQCAFKAJwIARqQQAgB/wLAAsgBSAGNgJ0CyAFIAo2AnggBSgCZCIEIAUoAlxGBEAgBUHcAGpB9JKAARCzKAsgBSgCYCAEQQN0akIANwMAIAUgBEEBajYCZAsgA0EQaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/zs2ApACIAVBAjYC/AEgBUHUkoABNgL4ASAFQgI3AoQCIAVBOzYC7AEgBUE7NgLkASAFIAVB4AFqNgKAAiAFIAVBkAJqNgLoASAFIAVB0AFqNgLgASAFQfgBakHkkoABEO8sAAtBoJWAARCyOwALIAVBkAFqIgIgBUHcAGoiAxDZFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaCigAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC6LQsgBUGgAmokAA8LQQRBOBCjPQALhh0CDX8BfiMAQbABayIDJAAgASgCMCICQQRqIQQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkF7TQRAIAQgASgCLCIFSw0PIANB8ABqIgQgASgCKCIGIAUgAiACIAZqKAAAaxD2NAJAIARBDBDMIEH//wNxIgRFBEBBACEGDAELIAIgBGoiAkEEaiEEIAJBe0sNAiAEIAVLDQMgAiAGaigAACACaiECCyADQQA2ApABIANBADYCgAEgAyACNgJ8IAMgBTYCeCADIAY2AnQgA0EBNgJwIANBoAFqIQgjAEFAaiICJAAgAiADQfAAaiIGIgUQww8CQAJAAkAgAigCAEEBRgRAIAIpAwghDyACQTRqIgRBBEF/IAUoAhwiByAFKAIsQQAgBSgCIBsiCWoiCiAHIApLGyAJIAUoAhAbQQFqIgdBfyAHGyIHIAdBBE0bQQBBCEEIEKAYIAIoAjghByACKAI0QQFGDQIgAigCPCIJIA83AwAgAkE8aiIKQQE2AgAgAiAJNgI4IAIgBzYCNCACIAVBMPwKAAAjAEEQayIFJAAgBSACEMMPIAUoAgBBAUYEQANAIAUpAwghDyAEKAIIIgcgBCgCAEYEQCAEQX8gAigCHCIJIAIoAixBACACKAIgGyINaiILIAkgC0sbIA0gAigCEBtBAWoiCUF/IAkbEOwtCyAEKAIEIAdBA3RqIA83AwAgBCAHQQFqNgIIIAUgAhDDDyAFKAIADQALCyAFQRBqJAAgCEEIaiAKKAIANgIAIAggAikCNDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgALIAJBQGskAAwBCyAHIAIoAjxB/NT+ABD9LwALIANBADYCGCADIAMoAqgBNgIcIAMgAykCoAE3AhAgASgCMCICQQRqIQQgAkF7Sw0OIAQgASgCLCIFSw0PIAYgASgCKCIEIAUgAiACIARqKAAAaxD2NCAGQQQQzCBB//8DcSIIBH8gAiAIaiICIAVLDQQgAiAEaigAAAVBAAshAiADQQE6ACggAyACNgIkIANBATYCICABKAI0IgIgAigCACIEQQFqNgIAIARBAEgNBCABQTRqIQ0gAyACNgIsIAEoAiAiCEUNCyABKAIkIQpBACEHIANBADYCqAEgA0KAgICAwAA3AqABIANBCGogAkEIahDDNCADKAIMIgJFDQUgAygCCCIJIAJBAnRqIQ4gCkECdCEFA0ACQAJAIAoEQEEAIQYgBSEEIAghAgNAIAIoAgAgB0YNAiAGQQFqIQYgAkEEaiECIARBBGsiBA0ACwsgA0HwAGogASAJKAIAQQhqIANBEGoQygcgAygCcCICQZOAgIB4Rg0BIAAgAykCdDcCCCAAQRBqIANB/ABqKQIANwIAIAAgAjYCBAwJCyADQfAAaiABIAkoAgBBCGogA0EQahCOASADKAJ4IQIgAygCdCEEIAMoAnAiC0GTgICAeEcEQCAAIAMpAnw3AhAgACACNgIMIAAgBDYCCCAAIAs2AgQMCQsgAygCqAEiCyADKAKgAUYEQCADQaABakGk3v4AEJAoCyADKAKkASALQQxsaiIMIAI2AgggDCAENgIEIAwgBjYCACADIAtBAWo2AqgBCyAHQQFqIQcgCUEEaiIJIA5HDQALDAULDA0LIAIgBEHM1f4AELE7AAsgBCAFQczV/gAQsDsACyACIAVBzNT+ABCvOwsACyADKAKoASEEIAMoAqQBIQcgAyADQeQAajYCcAJAIARBAkkNACAEQRVPBEAgA0HwAGohBiMAQYAgayICJAACQEGq2CggBCAEQarYKE8bIgUgBCAEQQF2ayIJIAUgCUsbIglB1gJPBEAjAEEQayIFJAAgBUEEaiAJQQBBBEEMEKAYIAUoAgghCSAFKAIEQQFGBEAgCSAFKAIMQZzu/gAQ/S8ACyAFKAIMIQsgAkEANgIIIAIgCzYCBCACIAk2AgAgBUEQaiQAIAcgBCACKAIEIAIoAggiBUEMbGogAigCACAFayAEQcEASSAGEIAKIAIQ1iYgAkEEQQwQ4B4MAQsgByAEIAJB1QIgBEHBAEkgBhCACgsgAkGAIGokAAwBCwJAIAQEQCAEQQFHBEAgByAEQQxsaiELIAdBDCIFaiEGA0AgBigCACIJIAZBDGsoAgBJBEAgBikCBCEPIAUhBAJ/A0AgBCAHaiICIAJBDGsiDCkCADcCACACQQhqIAxBCGooAgA2AgAgByAEQQxGDQEaIARBDGshBCAJIAJBGGsoAgBJDQALIAQgB2oLIgIgDzcCBCACIAk2AgALIAVBDGohBSAGQQxqIgYgC0cNAAsLDAELAAsLIANB8ABqIAMoAixBCGogCCAKEKcUIANBOGoiAiADQfwAaikCADcDACADQUBrIgQgA0GEAWooAgA2AgAgAyADKQJ0NwMwIAMoAnAiBUUEQCAAIAMpAzA3AgQgAEEUaiAEKAIANgIAIABBDGogAikDADcCAAwBCyADQdAAaiICIANBkAFqKQMANwMAIAMgAykDiAE3A0hBMEEIEK02IghFDQEgCCAFNgIIIAhCgYCAgBA3AwAgCCADKQMwNwIMIAggAykDSDcDICAIQRRqIANBOGopAwA3AgAgCEEcaiADQUBrKAIANgIAIAhBKGogAikDADcDACADKAKgASEEIAMgAygCpAEiAiADKAKoAUEMbGo2AnwgAyAENgJ4IAMgAjYCdCADIAI2AnAgA0HwAGoiBCgCCCELIAQoAgAiBSEHIAQoAgQiAiAEKAIMIgZHBEADQCAHIAJBBGopAgA3AgAgB0EIaiEHIAJBDGoiAiAGRw0ACyAEIAI2AgQLIANB2ABqIQkgC0EMbCEGIwBBEGsiCiQAIARBADYCCCAEKAIMIQwgBCgCBCECIARBBDYCACAKQoCAgIDAADcCCCAKQQhqQQRBDBDgHiAEQQQ2AgwgBEEENgIEIAwgAmtBDG4hDiACIAxHBEAgAkEEaiECA0AgAigCACIMIAwoAgAiDEEBazYCACAMQQFGBEAgAhC7IwsgAkEMaiECIA5BAWsiDg0ACwsgCkEQaiQAIAUhAgJAIAtFDQAgBiAGQXhxIgpGDQAgCkUEQEEEIQIgBkUNASAFIAZBBBD4OgwBCyAFIAZBBCAKEJc1IgINAEEEIAoQoz0ACyAJIAI2AgQgCSAGQQN2NgIAIAkgByAFa0EDdjYCCCMAQRBrIgIkACAEKAIMIgcgBCgCBCIFa0EMbiEGIAUgB0cEQCAFQQRqIQUDQCAFKAIAIgcgBygCACIHQQFrNgIAIAdBAUYEQCAFELsjCyAFQQxqIQUgBkEBayIGDQALCyACIAQoAgA2AgwgAiAEKAIINgIIIAJBCGpBBEEMEOAeIAJBEGokAAJAAkAgAS0AREUEQCADKAIcRQ0BQejd/gBBLEGU3v4AEJ8pAAsgASgCMCICQQRqIQUgAkF7Sw0EIAUgASgCLCIESw0FIANB8ABqIgYgASgCKCIFIAQgAiACIAVqKAAAaxD2NEEAIQEgBkEEEMwgQf//A3EiBgRAIAIgBmoiASAESw0HIAEgBWooAAAhAQsgACADKQJYNwIEIAAgATYCFCAAIAg2AhAgAEEANgIAIABBDGogA0HgAGooAgA2AgAMAQsgACAIIANB2ABqIANBIGoQjTsLIAMoAiwiACAAKAIAIgBBAWs2AgAgAEEBRw0HIANBLGoQ+CMMBwsgAEEBNgIAIANBoAFqIgAQ1iYgAEEEQQwQ4B4MBQtBCEEwEKM9AAsgAiAFQdzV/gAQsTsACyAFIARB3NX+ABCwOwALIAEgBEHM1P4AEK87AAsgA0EANgJsIANCgICAgMAANwJkIAMgAkEIahCvLgJAIAMoAgAiAiADKAIEIgZGDQADQAJAIANB8ABqIAEgAigCAEEIaiADQRBqEI4BIAMoAnghBCADKAJ0IQUgAygCcCIIQZOAgIB4Rw0AIAMoAmwiCCADKAJkRgRAIANB5ABqQcTe/gAQmygLIAMoAmggCEEDdGoiByAENgIEIAcgBTYCACADIAhBAWo2AmwgBiACQQRqIgJHDQEMAgsLIAAgAykCfDcCECAAIAQ2AgwgACAFNgIIIAAgCDYCBCAAQQE2AgAgA0HkAGoiABDDJyAAEOo7DAELAkACQCABLQBERQRAIAMoAhxFDQFB6N3+AEEsQbTe/gAQnykACyADKAIsIQggA0GoAWogA0HsAGooAgA2AgAgAyADKQJkNwOgASABKAIwIgJBBGohBCACQXtLDQQgBCABKAIsIgVLDQUgA0HwAGoiBCABKAIoIgEgBSACIAEgAmooAABrEPY0QQAhByAEQQQQzCBB//8DcSIEBEAgAiAEaiICIAVLDQIgASACaigAACEHCyAAIAMpA6ABNwIEIABBDGogA0GoAWooAgA2AgAgACAHNgIUIAAgCDYCECAAQQA2AgAMAwsgAygCLCEBIANB+ABqIANB7ABqKAIANgIAIAMgAykCZDcDcCAAIAEgA0HwAGogA0EgahCNOwwCCyACIAVBzNT+ABCvOwALIAMoAiwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIANBLGoQ+CMLCyADQfAAaiEAIANBEGoiCCECIAMoAhwhBCMAQRBrIgEkACABQQhqIAQQ6joCQCABKAIMIgYgASgCCCIERgRAIABCADcCACAAQQhqQgA3AgAMAQsgACACKAIIIARqIgUgAigCACICQQAgAiAFTRtrIgU2AgAgBiAEayIEIAIgBWsiBk0EQCAAQgA3AgggACAEIAVqNgIEDAELIABBADYCCCAAIAI2AgQgACAEIAZrNgIMCyABQRBqJAAgCBDjPCANKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCANEPgjCyADQbABaiQADwsgAiAEQdzV/gAQsTsACyAEIAVB3NX+ABCwOwAL7CkCFH8BfiMAQZABayIIJAAgASgCCCEJIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQFqNgIIIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQJqIhM2AgggCCADNgJYIAggAjYCVCAIIAM2AmwgCCACNgJoIAEoAhwhBiABKAIYIREgBEH/AXFBAkYhDQNAAkACQAJAIAhB6ABqEO4SIglB2wBMBEACQCAJQT9rDgIEAgALIAlBI0YgCUEvRnINAwwCCyAJQdwARwRAIAlBgIDEAEcNAgwDCyANRQ0CDAELIBEEQCARQQpBAiAOGyAGKAIUEQAACyAIKAJsIQwgCCgCaCEOIAohCwsgCkEBaiEKDAELCwJAAkAgDkUEQCACIQ4gEyEHIAMhDAwBCwJAAkACQCALBEAgC0EASg0BDAMLIAggDDYCICAIIA42AhwgCEGIAWohCSAIQRxqEO4SIgJBI2siA0EcSw0BQQAhEUEBIAN0QYGggIABcUUNAUEAIQoMBAtBACERAkACQAJAA0AgAiADRg0DIAIhCQNAAn8gCSwAACICQQBOBEAgAkH/AXEhCiAJQQFqDAELIAktAAFBP3EhBiACQR9xIQogAkFfTQRAIApBBnQgBnIhCiAJQQJqDAELIAktAAJBP3EgBkEGdHIhBiACQXBJBEAgBiAKQQx0ciEKIAlBA2oMAQsgCkESdEGAgPAAcSAJLQADQT9xIAZBBnRyciIKQYCAxABGDQUgCUEEagshAkEBIAp0QYDMAHFFIApBDUtyRQRAIAMgAiIJRw0BDAULCyAIIAI2AlQCQAJ/QQEgCkGAAUkNABpBAiAKQYAQSQ0AGkEDQQQgCkGAgARJGwsiBiADIAlrIg1PBEAgBiANRg0BDAQLIAYgCWosAABBv39MDQMLIApBgIDEAEYNAwJAIBFFIApBOkZxRQRAIAEoAhgiDQRAIA0gASgCHCAKIAhB1ABqEJAMCyARQQFzIA9yIQ8gCEGAi8QANgIkIAggBjYCICAIIAk2AhwgASAIQRxqEK8eDAELIAEoAgghByALQQFGBEAgByEJIA8gEXJBAXENAwwIC0EBIREgAUEBENgtIAEoAgQgASgCCGpBOjoAACABIAdBAWo2AggLIAtBAUogC0EBayELDQALIA8gEXIhAyARQQFxRQRAIAEoAggiCSEHIANBAXENAQwGCyADQQFxRQ0FIAEoAgghCQsgAUEBENgtIAEoAgQgASgCCGpBwAA6AAAgASAJQQFqNgIIDAQLIAkgDUEAIAZBzIbEABCjNgALQeCKxAAQsjsACyACQYCAxABGIARB/wFxQQJGcg0AQQAhESATIQdBACEKIAJB3ABHDQEMAgsgEyEHCyAIIA42AogBIAhBGGohCSAHIREgDCEKCyAJIAo2AgACQAJAIAgoAogBIgNFBEAgESELDAELIAEoAgghFyAIQegAaiENIAgoAhghD0EAIQxBACEOIwBB4ABrIgYkACAGIA82AhwgBiADNgIYAkACQAJAAkACQAJAAkACQAJAIARB/wFxBEAgAyAPRw0BDAILIAZBLGogAyAPENcIIAYtADAhAyAGKAIsIgdBgYCAgHhGBEAgDUEDOgAAIA0gAzoAAQwJCyAGIAYpADEiGjcDSCAGIAZBOGooAAA2AE8gBigCPCEUIAYoAkAhFSAGQShqIAYoAEs2AAAgBiAaPgAlIAYgAzoAJCAGIAc2AiAgBkEIaiAGQSBqIhYQ3DsgBkEsaiEHIAYoAgghCSAGKAIMIQsjAEEgayIDJAAgAyALNgIcIAMgCTYCGCADQYCAgIB4NgIUIAMgA0EUahCaAwJAIAMtAABBA0YEQCAHIAMtAAE6AAEgB0EDOgAADAELIwBBEGsiCSQAAkACQAJAAkAgAy0AACIYQQFrDgIBAgALIAlBCGoiDCADQQxqKAIANgIAIAkgAykCBDcDACAHQQRqIQojAEEQayILJAACQAJAAkAgCSgCAEGAgICAeEcEQCAKIAkpAgA3AgAgCkEIaiAMKAIANgIADAELIAkoAgQhGSALQQRqIAkoAggiDEEAQQFBARCgGCALKAIIIRAgCygCBEEBRg0BIAsoAgwhEiAMBEAgEiAZIAz8CgAACyAKIAw2AgggCiASNgIEIAogEDYCAAsgC0EQaiQADAELIBAgCygCDEHssMwAEP0vAAsMAgsgByADKAABNgABDAELIAcgAykAATcAASAHQQlqIANBCWopAAA3AAALIAcgGDoAACAJQRBqJAALIANBIGokACAGLQAtIQcgBi0ALCIDQQNGBEAgDUEDOgAAIA0gBzoAASAWEIYwDAkLIAZB2gBqIAZBPmovAQA7AQAgBkHSAGogBkE2aikBADcBACAGIAYpAS43AUogBiAHOgBJIAYgAzoASCAGQcgAakEBciELAkACQAJAIANBAWsOAgABAgsgBkHGAGogC0ECai0AADoAACAGIAsvAAA7AUQgBi0ATCEMDAkLIAZBxgBqIAtBAmotAAA6AAAgBiALLwAAOwFEIAYtAFghDiAGKAJUIQsgBigCUCEPIAYoAkwhDAwICyAGKAJQIg8gBigCVCILQeyLxABBCRDBLkUEQCAGKAJMIQwMCAsgBkHMAGoQ3jtBgICAgHghDEEBIQ9BACELDAcLIAMhBwNAAn8gBywAACIJQQBOBEAgCUH/AXEhCyAHQQFqDAELIActAAFBP3EhCiAJQR9xIQsgCUFfTQRAIAtBBnQgCnIhCyAHQQJqDAELIActAAJBP3EgCkEGdHIhCiAJQXBJBEAgCiALQQx0ciELIAdBA2oMAQsgC0ESdEGAgPAAcSAHLQADQT9xIApBBnRyciELIAdBBGoLIQcCQAJAAkACQAJAAkACQAJAIAtBPkwEQEEBIQ4CQAJAAkAgC0EMTARAIAtBCWtBAkkNAQwKCyALQS5KDQIgC0ENRw0BC0EBIRQMCQsgC0EjRw0HDAkLIAtBOkYNASALQS9GDQgMBgsCQCALQdsAaw4DBAIFAAsgC0GAgMQARg0HIAtBP0cNBQwHCyASRQ0GDAELIARB/wFxQQJHDQULQQEhDiAMQQFqIQwMAwtBASESIAxBAWohDEEBIQ4MAgtBASEOIAxBAWohDEEAIRIMAQtBASEOIAxBAWohDCALQYABSQ0AQQIhDiALQYAQSQ0AQQNBBCALQYCABEkbIQ4LIA4gEGohECAHIA9HDQELCyAUDQELIA8gA2shCSAMQQFqIQcDQCAHQQFrIgcEQCAGQRhqEO4SQYCAxABHDQELCyAQRQ0CIAkgEEsNASAJIBBGDQIMBAsgBkE0aiIDQQA2AgAgBkKAgICAEDcCLCAGQSxqIAZBGGogDBCWKCAGQShqIAMoAgA2AgAgBiAGKQIsNwMgDAILIAMgEGosAABBv39MDQILIAYgEDYCKCAGIAM2AiQgBkGAgICAeDYCIAsCQAJAIARB/wFxQQFGBEAgBkEQaiAGQSBqIgMQ3DsgBigCFA0BIA1BAzsBACADEIYwDAULIAZB0ABqIAZBKGooAgA2AgAgBiAGKQMgNwNIIAZBLGohCyMAQeAAayIDJAAgA0EoaiAGQcgAaiIMENw7IAMoAiwhByADKAIoIANB2wA2AjQgByADQTRqQQEQ9C4hCSADQSBqIAwQ3DsgAygCJCEHIAMoAiAhCgJAAkAgCUUEQCAHIApqIQ8DQAJAAkACQAJAIAogD0cEQAJ/IAosAAAiB0EATgRAIAdB/wFxIQkgCkEBagwBCyAKLQABQT9xIQ4gB0EfcSEJIAdBX00EQCAJQQZ0IA5yIQkgCkECagwBCyAKLQACQT9xIA5BBnRyIQ4gB0FwSQRAIA4gCUEMdHIhCSAKQQNqDAELIAlBEnRBgIDwAHEgCi0AA0E/cSAOQQZ0cnIhCSAKQQRqCyEKAkAgCUEuTARAIAlBDU0NAQwFCyAJQS9rIgdBEU0NAgwDC0EBIAl0QYHMAHFFDQMMBAsgA0EYaiAMENw7IANBoJjEADYCXCADIAMpAxg3AlQgC0EBaiEOIANByABqIQkjAEEwayIHJAAgB0EQaiADQdQAaiIPEOURAkACQCAHKAIQIhAEQCAHKAIUIQogB0EIaiAPEOURIAcoAggiEg0BIAkgCjYCCCAJIBA2AgQgCUGAgICAeDYCAAwCCyAJQQA2AgggCUKAgICAGDcCAAwBCyAHKAIMIRYgB0EkaiAKQQBBAUEBEKAYIAcoAighFCAHKAIkQQFHBEAgBygCLCEVIAoEQCAVIBAgCvwKAAALIAdBIGoiECAKNgIAIAcgFTYCHCAHIBQ2AhggB0EYaiIKIBIgEiAWahCCJiAKIA8Qrx4gCUEIaiAQKAIANgIAIAkgBykCGDcCAAwBCyAUIAcoAixBoLHMABD9LwALIAdBMGokACADQTdqIQcgAygCSEGAgICAeEcEQCAHIAMpAkg3AAAgB0EIaiADQdAAaigCADYAACALQQA6AAAgDiADKQA0NwAAIA5BB2ogA0E7aikAADcAAAwHCyAHIAwpAAA3AAAgB0EIaiAMQQhqKAAANgAAIAtBADoAACAOIAMpADQ3AAAgDkEHaiADQTtqKQAANwAADAcLQQEgB3RBgdAOcQ0CCyAJQdsAa0EESQ0BIAlB/ABHDQIMAQsgCUEgaw4EAAEBAAELCyALQYMKOwEADAELIANB3QA2AjQCQCAHBEAgA0E0akEBIAcgCmpBAWtBARDBLg0BCyALQYMIOwEADAELIANBEGogDBDcOyADKAIUIQcgAygCECEJIANBCGogDBDcOwJAIAMoAgwiDkEBayIKRQ0AAkAgB0EBTQRAIAdBAUYNAQwCCyAJLAABQUBIDQELAkAgByAKTQRAIAcgCkcNAgwBCyAJIApqLAAAQb9/TA0BCyADQTRqIAlBAWogDkECaxCxBiALAn8gAy0ANEEBRgRAIAsgAy0ANToAAUEDDAELIAsgA0E1aiIHKQAANwABIAtBCWogB0EIaikAADcAAEECCzoAAAwBCyAJIAdBASAKQbCYxAAQozYACyAMEIYwCyADQeAAaiQAIAYtAC0hAyAGLQAsIgdBA0YNASANIAYpAS43AQIgDUESaiAGQT5qLwEAOwEAIA1BCmogBkE2aikBADcBACANIAYpAhg3AhQgDSADOgABIA0gBzoAAAwECyAGQdAAaiAGQShqKAIANgIAIAYgBikDIDcDSCAGQSxqIAZByABqEJoDIAYtAC0hAyAGLQAsIgdBA0cEQCANIAYpAS43AQIgDUESaiAGQT5qLwEAOwEAIA1BCmogBkE2aikBADcBACANIAYpAhg3AhQgDSADOgABIA0gBzoAAAwECyANQQM6AAAgDSADOgABDAMLIA1BAzoAACANIAM6AAEMAgsgAyAJQQAgEEHci8QAEKM2AAsgDSADOgAAIA0gBi8BRDsAASANIBU2AhggDSAUNgIUIA0gDjoAECANIAs2AgwgDSAPNgIIIA0gDDYCBCANQQNqIAZBxgBqLQAAOgAAIAZBIGoQhjALIAZB4ABqJAAgCC0AaSELIAgtAGgiA0EDRg0AIAhB5gBqIAhB+gBqLwEAOwEAIAhB3gBqIAhB8gBqKQEANwEAIAggCCkBajcBViAIIAs6AFUgCCADOgBUIAgoAnwhCSAIKAKAASEKIAhBATYCbCAIQZCLxAA2AmggCEIBNwJ0IAhB6QI2AowBIAggCEGIAWo2AnAgCCAIQdQAajYCiAECQAJAIAEgDRDbO0UEQCABKAIIIQYgCC0AVA0BIAhBEGogCEHYAGoQ3DsgCCgCFA0BIAggCjYCbCAIIAk2AmhBqIvEAEEBIA0QhRUhAkEAIQsgBEH/AXFBAkcNAiACRQ0BDAILQcyExABBKyAIQegAakG8hMQAQZiLxAAQ1R4ACyAIIAo2AmwgCCAJNgJoQQAhCwJAAn9BACAIQegAahDuEkE6Rw0AGiAIKAJsIQogCCgCaCEJIAEtACAhB0EAIQ5BACECAkADQCAIIAo2AmwgCCAJNgJoIAhB6ABqEO4SIgNBgIDEAEYNASADQTBrIgxBCkkEQCAIKAJsIQogCCgCaCEJQQEhDiAMIAJBCmxqIgJB//8DTQ0BDAQLCyAHDQAgA0EjayIMQRxNQQBBASAMdEGBoICAAXEbDQAgA0HcAEcNAgsCQCAOQQFxRQRAIAdBAUcNASAIIAo2AmwgCCAJNgJoIAhB6ABqEO4SQYCAxABHDQMMAQsgASgCBCEDAkACQCAFRQ0AIAEoAggiByAFTQRAIAUgB0YNAQwCCyADIAVqLAAAQb9/TA0BCyAIQQhqIQxBASEOQdAAIQcCQCADIAVBtIbEAEEEEMEuDQAgAyAFQb2GxABBAhDBLg0AQbsDIQcgAyAFQbiGxABBBRDBLg0AIAMgBUG/hsQAQQMQwS4NAEEVIQcgAyAFQcKGxABBAxDBLiEOCyAMIAc7AQIgDCAOOwEAIAgvAQhBAXEEQCAILwEKIAJB//8DcUYNAgsgASgCCCEDIAFBARDYLSABKAIEIAEoAghqQTo6AAAgASADQQFqNgIIQQAhAyAIQewAakEAOgAAIAhBADYCaCACIQcCQANAIANBBGpBBEsNASADIAhqQewAaiAHIAdB//8DcSIMQQpuIgdBCmxrQTByOgAAIANBAWshAyAMQQpPDQALIAEgAyAIQe0AaiIHaiAHEIEmQQEMAwtBf0EFQfSUxAAQwyEACyADIAdBACAFQcyLxAAQozYAC0EACyEHIAhB+ABqIAhB5ABqKAIANgIAIAhB8ABqIAhB3ABqKQIANwMAIAggCCkCVDcDaCAIQSRqIAhB6ABqEK4eIAhByABqIAhBLGopAgA3AwAgCEHQAGogCEE0ai0AADoAACAIIAgpAiQ3A0AgEyAXRwRAIAgtAEBFDQMLIAEoAgghEyAIQQE6ABwgCCABIAQgCEEcaiIDIAkgChDNDSAIKAIEIQkgCCgCACELIAMgAUEk/AoAACAAIAMgBCAFIBEgFyAGIAhBQGsgByACIBMgCyAJENEHDAMLQQIhCwsgCC0AVA0AIAhB2ABqEIYwCyAAQQI2AgAgACALOgAEIAEQ3jsLIAhBkAFqJAALhBACEH8DfiMAQfABayIDJAAgA0EwaiABENw7IAMgASgCDCIJNgI8IAMoAjQhCCADKAIwIQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMEBAALQcAAIQEgAigCPCIEQQN2IARBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBUHAABDRNEUNCSAFBEAgBUHAABCtNiIBRQ0MCyADQgA3AugBIAMgATYC5AEgAyAFNgLgAUHAACEGIANBwAA2AtwBIANBkAFqIgQgAkEQahDJNCADQdABaiAEENUJQQAhBCADIAMoAtABQQFGBH8DQCADQdwBaiADKALUASAJaiADKALYASAJaiALIAgQvxggA0HQAWogA0GQAWoQ1QkgAygC0AENAAsgAygC6AEhBCADKALkASEBIAMoAtwBIQYgAygC4AEFIAULNgKgASADIAY2ApwBIANBADYCmAEgAyAENgKUASADIAE2ApABIAMgA0GQAWoQ1zsgAygCACECQRxBBBCtNiIBRQ0KIAFCgYCAgBA3AgAgASADKQKQATcCCCAAIAQ2AgggACACNgIEDAcLIANBQGsgAkEQaiACKAI8ELEmIAMgCDYChAEgAyALNgKAASADKAJ4IQJBwAAhBCADIANBPGo2AogBIAJBBnYiCSACQT9xIghBAEdqIgFBA3QiBUHA////A3FBQGsgBSABQQdxGyIFQcAAENE0RQ0IIAUEQCAFQcAAEK02IgRFDQsLQQAhASACQcAASQ0FA0AgBkEBaiEGQgAhE0IAIRQDQCADQRhqIANBQGsQ1hACQCADKAIYQQFxBEAgAygCiAEoAgAgAygCHGoiCkEDdiIHIAMoAoQBIgtJDQEgByALQaj6ggEQwyEACwwKCyADKAKAASAHai0AACAKQQdxdkEBca0gE4YgFIQhFCATQgF8IhNCwABSDQALIAEgBGogFDcDACABQQhqIQEgBiAJRw0ACwwFC0HAACEMIAIoAgghBSACKAIMIgpBBnYiESAKQT9xIg5BAEdqIgFBA3QiAkHA////AHFBQGsgAiABQQdxGyINQcAAENE0RQ0HIA0EQCANQcAAEK02IgxFDQMLIAUhASAKQcAASQ0DIApBAnQhBiABIQQDQCAEQYACaiEBIA9BAWohD0IAIRNBACECQgAhFANAAkAgAiAGRwRAIAIgBGooAgAgCWoiEkEDdiIQIAhJDQEgECAIQaj6ggEQwyEACwwJCyALIBBqLQAAIBJBB3F2QQFxrSAThiAUhCEUIAJBBGohAiATQgF8IhNCwABSDQALIAcgDGogFDcDACAGQYACayEGIAdBCGohByABIQQgDyARRw0ACwwDC0HAACEBIAIoAjwiBUEDdiAFQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiAUUNCQsgA0IANwLoASADIAE2AuQBIAMgBTYC4AFBwAAhBiADQcAANgLcASADIAIoAgwiBwR/IAIoAggiAiAHQQN0aiEBA0AgA0HcAWogAigCACAJaiACQQRqKAIAIAlqIAsgCBC/GCACQQhqIgIgAUcNAAsgAygC6AEhBCADKALkASEBIAMoAtwBIQYgAygC4AEFIAULNgKgASADIAY2ApwBIANBADYCmAEgAyAENgKUASADIAE2ApABIANBKGogA0GQAWoQ1zsgAygCKCECQRxBBBCtNiIBRQ0HIAFCgYCAgBA3AgAgASADKQKQATcCCCAAIAQ2AgggACACNgIEDAQLQfytgwFBKEGkroMBEJ8pAAtBwAAgDRCjPQALIA4EQCAFIApBAnRqIQQgDq0hFUIAIRNCACEUA0ACQCABIARHBEAgASgCACAJaiIFQQN2IgIgCEkNASACIAhBqPqCARDDIQALDAULIAIgC2otAAAgBUEHcXZBAXGtIBOGIBSEIRQgAUEEaiEBIBNCAXwiEyAVUg0ACyAHIAxqIBQ3AAAgB0EIaiEHCyADIA02AqABIANCgICAgIAINwKYASADIAw2ApABIAMgCkEDdiAKQQdxQQBHaiIBIAcgASAHSRsiAjYClAEgA0EgaiADQZABahDXOyADKAIgIQRBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCkAE3AgggACACNgIIIAAgBDYCBAwCCwwECyAIBEAgCK0hFUIAIRNCACEUA0AgA0EQaiADQUBrENYQAkAgAygCEEEBcQRAIAMoAogBKAIAIAMoAhRqIghBA3YiBiADKAKEASIHSQ0BIAYgB0Go+oIBEMMhAAsMBAsgAygCgAEgBmotAAAgCEEHcXZBAXGtIBOGIBSEIRQgE0IBfCITIBVSDQALIAEgBGogFDcAACABQQhqIQELIAMgBTYCoAEgA0KAgICAgAg3ApgBIAMgBDYCkAEgAyACQQN2IAJBB3FBAEdqIgIgASABIAJLGyICNgKUASADQQhqIANBkAFqENc7IAMoAgghBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCkAE3AgggACACNgIIIAAgBDYCBAsgACABNgIAIAFBEGogA0GYAWopAgA3AgAgAUEYaiADQaABaigCADYCACADQfABaiQADwtBwPuCARCyOwALQbj6ggFBKSADQZABakGwgoMBQeT6ggEQ1R4AC0EEQRwQoz0AC0HAACAFEKM9AAvsEQIMfwF+QQohBiMAQcABayIFJAAgBSADOgALIAEgAhDkISELIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAasfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgBqwiESARfiIRQiCIpyARpyIGQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQYgBUH0AGogBUGsAWoiBygCADYCACAFIAUpAqQBNwJsIAUgBjYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogBygCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiALQQxqIg8Q2zwQ9R4gBC0ANCEBIA8Q2zwhDgJAIAFFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhBkEAIQICQANAAkACQAJAAkACQCALIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgCygCECAGaigCACEBIAUgAzYCsAEgBSABNgKYASADBH8gDSABQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQdBiICAgHgFQYeAgIB4CyEBIAAgBzYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCEEDdiAIQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQogBSgCHCIJIARJBEAgDCAJQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIJIAEgCUsbEOgZIAUoAiQhAQsgCgRAIAUoAiAgAWpBACAK/AsACyAFIAQ2AiQLIAUgCDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQrSgLIAUoAhAgBEEBdGpBADsBAAwDCyAFIAEgA20iBzYClAEgB0GAgAJqQYCABEkNASAFQbgBakGDhowYNgIAIAVCg4aMmLDgwIEDNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgACAFKQGiATcBBiAAQQxqIAVBqAFqKQEANwEAIAAgBS8BoAE7AQQgAEGCgICAeDYCAAsgBUEMahC4LQwHCwJAIAUoAhgEQCAFKAIoIghBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQkgBSgCHCIQIARJBEAgDCAQQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyIQIAEgEEsbEOgZIAUoAiQhAQsgCQRAIAUoAiAgAWpBACAJ/AsACyAFIAQ2AiQLIAUgCjYCKCAFKAIgIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBCAFKAIMRgRAIAVBDGpBhJOAARCtKAsgBSgCECAEQQF0aiAHOwEACyAFIARBAWo2AhQgBkEEaiEGIA4gAkEBaiICRw0BDAQLCwwFC0GglYABELI7AAsgDkUNACAFQRhqIQwgBUGgAWohCiADQX9HIQlBACEGQQAhAgJAA0ACQAJAIAsgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NAiALKAIQIAZqKAIAIQQgBSADNgKYASAFIAQ2ApQBAn8CQCADBEAgCUUgBEGAgICAeEZxRQRAIAQgA20hBEEBDAMLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCiAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEQQEMAgsgBUGHgICAeDYCQAsgBUFAaxCIEUEACyEBIAVBDGogASAEQYCAAmpBgIAESXEgBBDeCwwBCyAMEOY6IAUoAhhFDQMgBSgCKEEBaiIEQQN2IARBB3FBAEdqIgEgBSgCJCIHSwRAIAEgB2shCCAFKAIcIg0gAUkEQCAMIA1BAXQiByABQcD///8DcUFAayABIAFBP3EbIg0gByANSxsQ6BkgBSgCJCEHCyAIBEAgBSgCICAHakEAIAj8CwALIAUgATYCJAsgBSAENgIoIAUoAhQiASAFKAIMRgRAIAVBDGpB9JKAARCtKAsgBSgCECABQQF0akEAOwEAIAUgAUEBajYCFAsgBkEEaiEGIA4gAkEBaiICRw0BDAMLCwwEC0GglYABELI7AAsgBUHkAGoiAiAFQQxqIgMQzhRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGYoIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuC0LIAVBwAFqJAAPC0EEQTgQoz0ACyAFIAsQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcASAFQeQAakHkkoABEO8sAAuwEgIMfwJ+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ7x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQsygLIAUoAhAgBEEDdGpCADcDAAwDCyAFIAQgA20iCDYClAEgCEEATg0BIAVBuAFqQYmSpMgANgIAIAVCiZKkyJChwoQJNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgBSkCoAEhESAAIAUpAqgBNwIMIAAgETcCBCAAQYKAgIB4NgIACyAFQQxqELotDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABELMoCyAFKAIQIARBA3RqIAitNwMACyAFIARBAWo2AhQgB0EEaiEHIA4gAkEBaiICRw0BDAQLCyAFIAEQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcAQwFC0GglYABELI7AAsgDkUNACAFQRhqIQYgBUGgAWohCyADQX9HIQpBACEHQQAhAgNAAkAgBUEMagJ+AkACQAJAIAEgAhCHJUUEQCAFIAI2ApgBIA8Q2zwgAk0NASABKAIQIAdqKAIAIQQgBSADNgKYASAFIAQ2ApQBAkAgAwRAIApFIARBgICAgHhGcUUEQCAEIANtIQQMBgsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASALIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiEjcDQCASp0GTgICAeEcNASAFKAJEIQQMBQsgBUGHgICAeDYCQAsgBUFAaxCIEUIADAQLIAYQ5jogBSgCGEUNASAFKAIoQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAIkIghLBEAgBCAIayEJIAUoAhwiDSAESQRAIAYgDUEBdCIIIARBwP///wNxQUBrIAQgBEE/cRsiDSAIIA1LGxDoGSAFKAIkIQgLIAkEQCAFKAIgIAhqQQAgCfwLAAsgBSAENgIkCyAFIAw2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABELMoCyAFKAIQIARBA3RqQgA3AwAgBSAEQQFqNgIUDAQLIAUgARD8OzYCsAEgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQbABajYCpAEgBSAFQZgBajYCnAEMCAtBoJWAARCyOwALIAStIBEgBEEATiIEGyERIAStCyARENoLCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDZFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaCigAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC6LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC7ISAgx/AX5BCiEHIwBBwAFrIgUkACAFIAM6AAsgASACEOQhIQEgBSADwCICNgJAIAVBCjYCsAECQAJAAkACQCADQf8BcUUEQEEBIQMMAQtBASEDA0ACQCACQQFxBEAgA6wgB6x+IhFCIIinIBGnIgNBH3VHDQEgAkEBRg0DCyAHrCIRIBF+IhFCIIinIBGnIgdBH3VHDQAgAkEBdiECDAELCyAFQQI2AhAgBUGImIABNgIMIAVCAjcCGCAFQfoPNgJwIAVB/A82AmggBSAFQeQAaiIBNgIUIAUgBUFAayICNgJsIAUgBUGwAWo2AmQgBUGgAWoiAyAFQQxqIgQQmQ4gBSgCoAEhByAFQfQAaiAFQawBaiIIKAIANgIAIAUgBSkCpAE3AmwgBSAHNgJoIAVBiICAgHg2AmQgBUEDNgIQIAVBrKWAATYCDCAFQgI3AhggBUH0CzYCTCAFQcQNNgJEIAVB3J2AATYCQCAFIAI2AhQgBSAFQQtqNgJIIAMgBBCZDiABEIgRIAAgBSkCpAE3AgggAEEQaiAIKAIANgIAIAAgBSgCoAE2AgQgAEGCgICAeDYCAAwBCyAFQQxqIAFBDGoiDxDbPBDyHiAELQA0IQIgDxDbPCEOAkAgAkUEQCAORQ0BIAVBGGohDCADQX9HIQ1BACEHQQAhAgJAA0ACQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NBSABKAIQIAdqKAIAIQQgBSADNgKwASAFIAQ2ApgBIAMEfyANIARBgICAgHhHcg0CIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABajYCSCAFIAVBmAFqNgJAIAVBoAFqIAVB5ABqEJkOIAVB4ABqIAVBrAFqKAIANgIAIAUgBSkCpAE3A1ggBSgCoAEhCEGIgICAeAVBh4CAgHgLIQEgACAINgIEIAAgATYCACAAIAUpA1g3AgggAEEQaiAFQeAAaigCADYCAAwCCyAMEOY6IAUoAhhFDQYgBSgCKEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCyAFKAIcIgogBkkEQCAMIApBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgogBCAKSxsQ6BkgBSgCJCEECyALBEAgBSgCICAEakEAIAv8CwALIAUgBjYCJAsgBSAJNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCdKAsgBSgCECAEQQJ0akEANgIADAMLIAUgBCADbSIINgKUASAIQQBODQEgBUG4AWpBiJCgwAA2AgAgBUKIkKDAgIGChAg3A7ABIAVBAjYCaCAFQeClgAE2AmQgBUICNwJwIAVBrQM2AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABaiIBNgJIIAUgBUGUAWo2AkAgBUGgAWogBUHkAGoQmQ4gARCpDCAAIAUpAqQBNwIIIABBEGogBUGsAWooAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIACyAFQQxqELktDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABEJ0oCyAFKAIQIARBAnRqIAg2AgALIAUgBEEBajYCFCAHQQRqIQcgDiACQQFqIgJHDQEMBAsLIAUgARD8OzYCQCAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBQGs2AqQBIAUgBUGwAWo2ApwBDAULQaCVgAEQsjsACyAORQ0AIAVBGGohBiAFQaABaiELIANBf0chCkEAIQdBACECA0ACQCAFQQxqAn8CQAJAAkAgASACEIclRQRAIAUgAjYCmAEgDxDbPCACTQ0BIAEoAhAgB2ooAgAhBCAFIAM2ApgBIAUgBDYClAECQCADBEAgCkUgBEGAgICAeEZxRQRAIAQgA20hBAwGCyAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgK8ASAFQfwPNgK0ASAFIAVBsAFqNgJsIAUgBUGYAWo2ArgBIAUgBUGUAWo2ArABIAsgBUHkAGoQmQ4gBUHIAGogBUGkAWopAgA3AwAgBUHQAGogBUGsAWooAgA2AgAgBUGIgICAeDYCnAEgBSAFKQKcASIRNwNAIBGnQZOAgIB4Rw0BIAUoAkQhBAwFCyAFQYeAgIB4NgJACyAFQUBrEIgRQQAMBAsgBhDmOiAFKAIYRQ0BIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiCEsEQCAEIAhrIQkgBSgCHCINIARJBEAgBiANQQF0IgggBEHA////A3FBQGsgBCAEQT9xGyINIAggDUsbEOgZIAUoAiQhCAsgCQRAIAUoAiAgCGpBACAJ/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQnSgLIAUoAhAgBEECdGpBADYCACAFIARBAWo2AhQMBAsgBSABEPw7NgKwASAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBsAFqNgKkASAFIAVBmAFqNgKcAQwIC0GglYABELI7AAsgBEF/c0EfdgsgBBDfCwsgB0EEaiEHIA4gAkEBaiICRw0ACwsgBUHkAGoiAiAFQQxqIgMQ1BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHIoYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVBwAFqJAAPC0EEQTgQoz0ACyAFQeQAakHkkoABEO8sAAuZFQIMfwN+IwBB4ABrIgMkAAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgVBH3UgBUH/////B2txQQFrDgQBBAMCAAsgAyABNgJYIAMgAjYCXCACIAFrIQUCQAJAIAAoAgxBgICAgHhHBEAgAEEMaiIEIAUQ7S0gACAFEO4tIAAoAixFDQEgAiAAKAI8TQ0CQfTFzQBBKkGgxs0AEJ8pAAsgACABIAIQiTsMBwsgBCAFIAAvAUQQqSUgACABIAIQiTsMBgsgAyACNgIcIAMgAEEsaiIKNgIQIAMgAEHEAGo2AhQgAyABNgIYIwBBEGsiByQAIAQgA0EQaiICKAIMIgYgAigCCGsiCEEAIAYgCE8bEO0tIAcgBCkCBEIgiTcCCCAHIARBCGo2AgQgB0EEaiIIKAIEIQYgCCgCACACKAIIIgQgAigCDCIJSQR/IAIoAgQhCyAGIAlqIARrIAgoAgggBkEBdGohBiACKAIAIQgDQCAGIAsvAQAgCCgCBCAEIAgoAgxqIg1BA3ZqLQAAIA1BB3F2QQFxRWs7AQAgBkECaiEGIAkgBEEBaiIERw0ACwUgBgs2AgAgB0EQaiQAIANBCGogChDcOyACIAMoAgggAygCDCAAKAI4IAFqIAUQvxQgAyADQdgAajYCSCMAQRBrIgEkACACQSBqIQQDQAJAAkAgAikDKCIQUEUEQCACKQMwIQ8MAQsDQAJ+AkAgAikDECIPQgNSBEACQAJAAkAgD0ICUQ0AIAIgD1CtQgGGNwMQIA+nQQFxRQ0AIAEgAikDGDcDCAwBCyAEKAIARQ0BIAEgBBC2KiABKQMAIQ8LIA9CAFINAgsgAkIDNwMQCyACKQMAIg9CAlENBCACQgA3AwAgAikDCAwBCyABKQMICyEQIA+nQQFxRQ0CIAIgEDcDKCACIAIpAzBCQH0iDzcDMCAQUA0ACwsgAiAQQgEgEHoiEYaFNwMoIAIoAjgoAgAgEacgD6dqaiEGIAAoAggiByAAKAIARgRAIABBARDuLQsgACgCBCAHQQJ0aiAGNgIAIAAgB0EBajYCCAwBCwsgAUEQaiQADAULIAEgAkEBaiIETQRAIAAoAhBBAnYiBSAETwRAIABBFGohByAAKAIEIQUgBCABayEGIAAoAgwgAUECdGohBCAAKAIYRQ0FIAZBAkkNBwNAAkAgACgCKCABSwRAIAAoAhwgASAAKAIkaiIGQQN2ai0AACAGQQdxdkEBcUUEQCAFIAcQ0BIMAgsgBCgCACIGIARBBGooAgAiCEcEQCADIAg2AlggAyAGNgJUIAUgBiAIEJkCIAMgBzYCGCADIANB1ABqNgIUIAMgA0HYAGo2AhAgBSADQRBqEOYUDAILIAUgBxDREgwBCwwKCyAEQQRqIQQgAiABQQFqIgFHDQALDAcLIAQgBUG0ws0AELA7AAsgASAEQbTCzQAQsTsACyAAKAIMIQggACgCCCEFIAAoAhQEQCABIAJPDQUgAEEQaiEMIAhByABsIQYgA0HcAGohDgJAA0AgACgCJCABSwRAAn8gACgCGCAAKAIgIAFqIgRBA3ZqLQAAIARBB3F2QQFxRQRAAkAgCEUNACAGIQcgBSEEIApFDQADQCAEIAkgARCZAiAEQcgAaiEEIAdByABrIgcNAAsLIAsgASANQQFxGyELQQAhCkEBDAELAkAgDUEBcUUNACADIAE2AlwgAyALNgJYIAhFDQAgBiEHIAUhBANAIAMgDDYCGCADIA42AhQgAyADQdgAajYCECAEIANBEGoQ1hYgBEHIAGohBCAHQcgAayIHDQALCyAJIAEgChshCUEBIQpBAAsiBCENIAIgAUEBaiIBRw0BDAILCwwHCwJAIAQEQCADIAI2AlwgAyALNgJYIAhFDQcgA0HcAGohACAIQcgAbCEEIAUhAQNAIAMgDDYCGCADIAA2AhQgAyADQdgAajYCECABIANBEGoQ1hYgAUHIAGohASAEQcgAayIEDQALDAELIAhFDQYLIApFDQUgCEHIAGwhAQNAIAUgCSACEJkCIAVByABqIQUgAUHIAGsiAQ0ACwwFCyAIRQ0EIAhByABsIQQDQCAFIAEgAhCZAiAFQcgAaiEFIARByABrIgQNAAsMBAsgACgCECAAKAIEIQUgAyAAKAIMIgY2AlAgAEEIaiEHBEAgASACTw0EAkADQCAAKAIgIAFLBEACfwJAAkAgACgCFCABIAAoAhxqIgZBA3ZqLQAAIAZBB3F2QQFxRQRAIARBAXFFDQIgAygCUCIEDQEgAyABIAlrNgIQIAUgByADQRBqENcWDAILIAkgASAEQQFxGyEJQQEMAgsgAyABIARsIgY2AlggAyAEIAlsIgQ2AlQgBSAEIAYQmQIgAyAHNgIcIAMgA0HUAGo2AhggAyADQdgAajYCFCADIANB0ABqNgIQIAUgA0EQahD7EgsgBSAHENISQQALIQQgAUEBaiIBIAJHDQEMAgsLDAYLIARFDQQgAygCUCIARQRAIAMgAiAJazYCECAFIAcgA0EQahDXFgwFCyADIAAgAmwiATYCWCADIAAgCWwiADYCVCAFIAAgARCZAiADIAc2AhwgAyADQdQAajYCGCADIANB2ABqNgIUIAMgA0HQAGo2AhAgBSADQRBqEPsSDAQLIAZFBEAgAyACIAFrNgIQIAUgByADQRBqENcWDAQLIAMgAiAGbCIANgJYIAMgASAGbCIBNgJUIAUgASAAEJkCIAMgBzYCHCADIANB1ABqNgIYIAMgA0HYAGo2AhQgAyADQdAAajYCECAFIANBEGoQ+xIMAwsCQCABIAJBAWoiBE0EQCAAKAIQQQN2IgUgBE8EQCAAQRRqIQcgACgCBCEFIAQgAWshBiAAKAIMIAFBA3RqIQQgACgCGEUNAiAGQQJJDQUDQAJAIAAoAiggAUsEQCAAKAIcIAEgACgCJGoiBkEDdmotAAAgBkEHcXZBAXFFBEAgBSAHENASDAILIAQoAgAiBiAEQQhqKAIAIghHBEAgAyAINgJYIAMgBjYCVCAFIAYgCBCZAiADIAc2AhggAyADQdQAajYCFCADIANB2ABqNgIQIAUgA0EQahDmFAwCCyAFIAcQ0RIMAQsMCAsgBEEIaiEEIAIgAUEBaiIBRw0ACwwFCyAEIAVBtMLNABCwOwALIAEgBEG0ws0AELE7AAsgBkECSQ0CIAIgAWtBAmohAQNAAkAgBCgCACIAIARBCGoiBCgCACICRwRAIAMgAjYCWCADIAA2AlQgBSAAIAIQmQIgAyAHNgIYIAMgA0HUAGo2AhQgAyADQdgAajYCECAFIANBEGoQ5hQMAQsgBSAHENESCyABQQFrIgFBA08NAAsMAgsgBkECSQ0BIAIgAWtBAmohAQNAAkAgBCgCACIAIARBBGoiBCgCACICRwRAIAMgAjYCWCADIAA2AlQgBSAAIAIQmQIgAyAHNgIYIAMgA0HUAGo2AhQgAyADQdgAajYCECAFIANBEGoQ5hQMAQsgBSAHENESCyABQQFrIgFBA08NAAsMAQsgACgCGEGAgICAeEYNACAAQRhqIAUgAC8BRhCpJQsgA0HgAGokAA8LQYSszQBBIEGkrM0AEJ8pAAuyEgIMfwF+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ8x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQrSgLIAUoAhAgBEEBdGpBADsBAAwDCyAFIAQgA20iCDYClAEgCEGAgARJDQEgBUG4AWpBh46cODYCACAFQoeOnLjw4MGDBzcDsAEgBUECNgJoIAVB4KWAATYCZCAFQgI3AnAgBUGtAzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqIgE2AkggBSAFQZQBajYCQCAFQaABaiAFQeQAahCZDiABEKkMIAAgBSkBogE3AQYgAEEMaiAFQagBaikBADcBACAAIAUvAaABOwEEIABBgoCAgHg2AgALIAVBDGoQuC0MBwsCQCAFKAIYBEAgBSgCKCIJQQFqIgtBA3YgC0EHcUEAR2oiBiAFKAIkIgRLBEAgBiAEayEKIAUoAhwiECAGSQRAIAwgEEEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiECAEIBBLGxDoGSAFKAIkIQQLIAoEQCAFKAIgIARqQQAgCvwLAAsgBSAGNgIkCyAFIAs2AiggBSgCICAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAIsQQFqNgIsCyAFKAIUIgQgBSgCDEYEQCAFQQxqQYSTgAEQrSgLIAUoAhAgBEEBdGogCDsBAAsgBSAEQQFqNgIUIAdBBGohByAOIAJBAWoiAkcNAQwECwsgBSABEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEMBQtBoJWAARCyOwALIA5FDQAgBUEYaiEGIAVBoAFqIQsgA0F/RyEKQQAhB0EAIQIDQAJAIAVBDGoCfwJAAkACQCABIAIQhyVFBEAgBSACNgKYASAPENs8IAJNDQEgASgCECAHaigCACEEIAUgAzYCmAEgBSAENgKUAQJAIAMEQCAKRSAEQYCAgIB4RnFFBEAgBCADbSEEDAYLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCyAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEDAULIAVBh4CAgHg2AkALIAVBQGsQiBFBAAwECyAGEOY6IAUoAhhFDQEgBSgCKEEBaiIMQQN2IAxBB3FBAEdqIgQgBSgCJCIISwRAIAQgCGshCSAFKAIcIg0gBEkEQCAGIA1BAXQiCCAEQcD///8DcUFAayAEIARBP3EbIg0gCCANSxsQ6BkgBSgCJCEICyAJBEAgBSgCICAIakEAIAn8CwALIAUgBDYCJAsgBSAMNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCtKAsgBSgCECAEQQF0akEAOwEAIAUgBEEBajYCFAwECyAFIAEQ/Ds2ArABIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUGwAWo2AqQBIAUgBUGYAWo2ApwBDAgLQaCVgAEQsjsACyAEQYCABEkLIAQQ3gsLIAdBBGohByAOIAJBAWoiAkcNAAsLIAVB5ABqIgIgBUEMaiIDEM8UQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBwJ+AATYCCCAAIAE2AgQgAEGTgICAeDYCACADELgtCyAFQcABaiQADwtBBEE4EKM9AAsgBUHkAGpB5JKAARDvLAALrxICDH8BfkEKIQcjAEHAAWsiBSQAIAUgAzoACyABIAIQ5CEhASAFIAPAIgI2AkAgBUEKNgKwAQJAAkACQAJAIANB/wFxRQRAQQEhAwwBC0EBIQMDQAJAIAJBAXEEQCADrCAHrH4iEUIgiKcgEaciA0EfdUcNASACQQFGDQMLIAesIhEgEX4iEUIgiKcgEaciB0EfdUcNACACQQF2IQIMAQsLIAVBAjYCECAFQYiYgAE2AgwgBUICNwIYIAVB+g82AnAgBUH8DzYCaCAFIAVB5ABqIgE2AhQgBSAFQUBrIgI2AmwgBSAFQbABajYCZCAFQaABaiIDIAVBDGoiBBCZDiAFKAKgASEHIAVB9ABqIAVBrAFqIggoAgA2AgAgBSAFKQKkATcCbCAFIAc2AmggBUGIgICAeDYCZCAFQQM2AhAgBUGspYABNgIMIAVCAjcCGCAFQfQLNgJMIAVBxA02AkQgBUHcnYABNgJAIAUgAjYCFCAFIAVBC2o2AkggAyAEEJkOIAEQiBEgACAFKQKkATcCCCAAQRBqIAgoAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIADAELIAVBDGogAUEMaiIPENs8EPAeIAQtADQhAiAPENs8IQ4CQCACRQRAIA5FDQEgBUEYaiEMIANBf0chDUEAIQdBACECAkADQAJAAkACQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDxDbPCACTQ0FIAEoAhAgB2ooAgAhBCAFIAM2ArABIAUgBDYCmAEgAwR/IA0gBEGAgICAeEdyDQIgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqNgJIIAUgBUGYAWo2AkAgBUGgAWogBUHkAGoQmQ4gBUHgAGogBUGsAWooAgA2AgAgBSAFKQKkATcDWCAFKAKgASEIQYiAgIB4BUGHgICAeAshASAAIAg2AgQgACABNgIAIAAgBSkDWDcCCCAAQRBqIAVB4ABqKAIANgIADAILIAwQ5jogBSgCGEUNBiAFKAIoQQFqIglBA3YgCUEHcUEAR2oiBiAFKAIkIgRLBEAgBiAEayELIAUoAhwiCiAGSQRAIAwgCkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiCiAEIApLGxDoGSAFKAIkIQQLIAsEQCAFKAIgIARqQQAgC/wLAAsgBSAGNgIkCyAFIAk2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABEKMoCyAFKAIQIARqQQA6AAAMAwsgBSAEIANtIgg2ApQBIAhBgAFqQYACSQ0BIAVBuAFqQYKEiBA2AgAgBUKChIiQoMCAgQI3A7ABIAVBAjYCaCAFQeClgAE2AmQgBUICNwJwIAVBrQM2AkwgBUH8DzYCRCAFIAVBQGs2AmwgBSAFQbABaiIBNgJIIAUgBUGUAWo2AkAgBUGgAWogBUHkAGoQmQ4gARCpDCAAIAUpAKEBNwAFIABBDGogBUGoAWopAAA3AAAgACAFLQCgAToABCAAQYKAgIB4NgIACyAFQQxqELctDAcLAkAgBSgCGARAIAUoAigiCUEBaiILQQN2IAtBB3FBAEdqIgYgBSgCJCIESwRAIAYgBGshCiAFKAIcIhAgBkkEQCAMIBBBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIhAgBCAQSxsQ6BkgBSgCJCEECyAKBEAgBSgCICAEakEAIAr8CwALIAUgBjYCJAsgBSALNgIoIAUoAiAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCLEEBajYCLAsgBSgCFCIEIAUoAgxGBEAgBUEMakGEk4ABEKMoCyAFKAIQIARqIAg6AAALIAUgBEEBajYCFCAHQQRqIQcgDiACQQFqIgJHDQEMBAsLIAUgARD8OzYCQCAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBQGs2AqQBIAUgBUGwAWo2ApwBDAULQaCVgAEQsjsACyAORQ0AIAVBGGohBiAFQaABaiELIANBf0chCkEAIQdBACECA0ACQCAFQQxqAn8CQAJAAkAgASACEIclRQRAIAUgAjYCmAEgDxDbPCACTQ0BIAEoAhAgB2ooAgAhBCAFIAM2ApgBIAUgBDYClAECQCADBEAgCkUgBEGAgICAeEZxRQRAIAQgA20hBAwGCyAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgK8ASAFQfwPNgK0ASAFIAVBsAFqNgJsIAUgBUGYAWo2ArgBIAUgBUGUAWo2ArABIAsgBUHkAGoQmQ4gBUHIAGogBUGkAWopAgA3AwAgBUHQAGogBUGsAWooAgA2AgAgBUGIgICAeDYCnAEgBSAFKQKcASIRNwNAIBGnQZOAgIB4Rw0BIAUoAkQhBAwFCyAFQYeAgIB4NgJACyAFQUBrEIgRQQAMBAsgBhDmOiAFKAIYRQ0BIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiCEsEQCAEIAhrIQkgBSgCHCINIARJBEAgBiANQQF0IgggBEHA////A3FBQGsgBCAEQT9xGyINIAggDUsbEOgZIAUoAiQhCAsgCQRAIAUoAiAgCGpBACAJ/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQoygLIAUoAhAgBGpBADoAACAFIARBAWo2AhQMBAsgBSABEPw7NgKwASAFQQI2AmggBUHUkoABNgJkIAVCAjcCcCAFQTs2AqgBIAVBOzYCoAEgBSAFQZwBajYCbCAFIAVBsAFqNgKkASAFIAVBmAFqNgKcAQwIC0GglYABELI7AAsgBEGAAWpBgAJJCyAEEPELCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDWFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdCjgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC84QAg1/AX4jAEHAAWsiAyQAIANBOGogAkEMaiIEENs8QQFqQQBBCEEIEKAYIAMoAjwhBQJAAkACQAJAIAMoAjhBAUcEQCADQQA2AjQgAyADKAJAIgc2AjAgAyAFNgIsIAUEfyAHBSADQSxqQfCrggEQsyggAygCMAtCADcDACADQQE2AjQgASgCECEMIAEoAhQgA0E4aiABEJM2IAIQ8hJBA3YhBwJAIAEQtzoNACACEK46DQAgA0EsaiAEENs8EOwtIAIoAhQiCkECdiEJIAIoAhAhAiAKQQRJDQMgCUECdCEFIAIhBANAAkAgByAEKAIAIgZBAWoiC0sEQCAGIAdJDQEgBiAHQcCsggEQwyEACyALIAdBsKyCARDDIQALIAwgC0EDdGooAgAgDCAGQQN0aigCAGsgCGoiCK0hECADKAI0IgYgAygCLEYEQCADQSxqQdCsggEQsygLIARBBGohBCADKAIwIAZBA3RqIBA3AwAgAyAGQQFqNgI0IAVBBGsiBQ0ACwwDCyACEK46DQEgA0EsaiAEENs8EOwtIAIoAhQiCkECdiEJIAIoAhAhAgJAAkACQCAKQQRPBEAgCUECdCEFIAIhBANAIAEgBCgCACIGEJU7BEAgBkEBaiILIAdPDQQgBiAHTw0DIAggDCALQQN0aigCAGogDCAGQQN0aigCAGshCAsgAygCNCIGIAMoAixGBEAgA0EsakGwrYIBELMoCyAEQQRqIQQgAygCMCAGQQN0aiAIrTcDACADIAZBAWo2AjQgBUEEayIFDQALCyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBBE8EQCAJQQJ0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEPIWIANB0ABqIAMoAhAgAygCFBChNgsgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLDAYLIAYgB0GgrYIBEMMhAAsgCyAHQZCtggEQwyEACyAFIAMoArgBQfCsggEQ/S8ACyAFIAMoAkBB4KuCARD9LwALIAEQtzoEQCADKAI4BEAgA0EsaiAEENs8EOwtIAIoAhQiC0ECdiENIAIoAhAhCAJAAkACQAJAIAtBBE8EQCANQQJ0IQogAygCRCECIAMoAjwhDyADKAJIIQQgCCEFA0AgBEUNBSAPIAJBA3ZqLQAAIAJBB3F2QQFxBEAgBSgCACIJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQYCvggEQsygLIAVBBGohBSADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFrIQQgAkEBaiECIApBBGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASECIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCALQQRPBEAgDUECdCEHIAMoAkQhAiADKAI8IQUgAygCSCEEA0ACQCAEBEAgBSACQQN2ai0AACACQQdxdkEBcUUNASADQSBqIAEgCCgCABDyFiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAIQQRqIQggBEEBayEEIAJBAWohAiAHQQRrIgcNAAsgAygCWCEECwwHCyAJIAdB8K6CARDDIQALIA4gB0HgroIBEMMhAAsgAiADKAK4AUHAroIBEP0vAAtBkPSBAUEgQbD0gQEQnykAC0GgroIBELI7AAsgA0EsaiAEENs8EOwtIAIoAhQiC0ECdiENIAIoAhAhBQJAAkACQCALQQRPBEAgDUECdCEKQQAhBCAFIQgDQCAIKAIAIQkgAiAEEIs7BEAgCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGQroIBELMoCyAIQQRqIQggAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBaiEEIApBBGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASEIIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgCDYCUCALQQRPBEAgDUECdCEHA0AgAiAEEIs7BEAgA0EYaiABIAUoAgAQ8hYgA0HQAGogAygCGCADKAIcEKE2CyAFQQRqIQUgBEEBaiEEIAdBBGsiBw0ACyADKAJYIQQLDAQLIAkgB0GAroIBEMMhAAsgDiAHQfCtggEQwyEACyAIIAMoArgBQdCtggEQ/S8ACyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAUEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBBE8EQCAJQQJ0IQQDQCADQQhqIAEgAigCABDyFiADQdAAaiADKAIIIAMoAgwQoTYgAkEEaiECIARBBGsiBA0ACyADKAJYIQQLCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEQIANB7ABqIANBoAFqEL0YIAMgBDYCuAEgAyAQNwOwASADQfgAaiADQbABahCTGSADQegAakGWrNiwATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANClqzYsOHChYsWNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAACADQcABaiQADwsgBSADKAK4AUGQrIIBEP0vAAvOEAINfwF+IwBBwAFrIgMkACADQThqIAJBDGoiBBDbPEEBakEAQQhBCBCgGCADKAI8IQUCQAJAAkACQCADKAI4QQFHBEAgA0EANgI0IAMgAygCQCIHNgIwIAMgBTYCLCAFBH8gBwUgA0EsakHwq4IBELMoIAMoAjALQgA3AwAgA0EBNgI0IAEoAhAhDCABKAIUIANBOGogARCTNiACEPISQQN2IQcCQCABELc6DQAgAhCuOg0AIANBLGogBBDbPBDsLSACKAIUIgpBAnYhCSACKAIQIQIgCkEESQ0DIAlBAnQhBSACIQQDQAJAIAcgBCgCACIGQQFqIgtLBEAgBiAHSQ0BIAYgB0HArIIBEMMhAAsgCyAHQbCsggEQwyEACyAMIAtBA3RqKAIAIAwgBkEDdGooAgBrIAhqIgitIRAgAygCNCIGIAMoAixGBEAgA0EsakHQrIIBELMoCyAEQQRqIQQgAygCMCAGQQN0aiAQNwMAIAMgBkEBajYCNCAFQQRrIgUNAAsMAwsgAhCuOg0BIANBLGogBBDbPBDsLSACKAIUIgpBAnYhCSACKAIQIQICQAJAAkAgCkEETwRAIAlBAnQhBSACIQQDQCABIAQoAgAiBhCVOwRAIAZBAWoiCyAHTw0EIAYgB08NAyAIIAwgC0EDdGooAgBqIAwgBkEDdGooAgBrIQgLIAMoAjQiBiADKAIsRgRAIANBLGpBsK2CARCzKAsgBEEEaiEEIAMoAjAgBkEDdGogCK03AwAgAyAGQQFqNgI0IAVBBGsiBQ0ACwsgA0GwAWogCEEAQQFBARCgGCADKAK0ASEFIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgBTYCUCAKQQRPBEAgCUECdCEEA0AgASACKAIAIgUQlTsEQCADQRBqIAEgBRDxFiADQdAAaiADKAIQIAMoAhQQoTYLIAJBBGohAiAEQQRrIgQNAAsgAygCWCEECwwGCyAGIAdBoK2CARDDIQALIAsgB0GQrYIBEMMhAAsgBSADKAK4AUHwrIIBEP0vAAsgBSADKAJAQeCrggEQ/S8ACyABELc6BEAgAygCOARAIANBLGogBBDbPBDsLSACKAIUIgtBAnYhDSACKAIQIQgCQAJAAkACQCALQQRPBEAgDUECdCEKIAMoAkQhAiADKAI8IQ8gAygCSCEEIAghBQNAIARFDQUgDyACQQN2ai0AACACQQdxdkEBcQRAIAUoAgAiCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGAr4IBELMoCyAFQQRqIQUgAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBayEEIAJBAWohAiAKQQRrIgoNAAsLIANBsAFqIAZBAEEBQQEQoBggAygCtAEhAiADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAI2AlAgC0EETwRAIA1BAnQhByADKAJEIQIgAygCPCEFIAMoAkghBANAAkAgBARAIAUgAkEDdmotAAAgAkEHcXZBAXFFDQEgA0EgaiABIAgoAgAQ8RYgA0HQAGogAygCICADKAIkEKE2DAELQZD0gQFBIEGw9IEBEJ8pAAsgCEEEaiEIIARBAWshBCACQQFqIQIgB0EEayIHDQALIAMoAlghBAsMBwsgCSAHQfCuggEQwyEACyAOIAdB4K6CARDDIQALIAIgAygCuAFBwK6CARD9LwALQZD0gQFBIEGw9IEBEJ8pAAtBoK6CARCyOwALIANBLGogBBDbPBDsLSACKAIUIgtBAnYhDSACKAIQIQUCQAJAAkAgC0EETwRAIA1BAnQhCkEAIQQgBSEIA0AgCCgCACEJIAIgBBCLOwRAIAlBAWoiDiAHTw0EIAcgCU0NAyAGIAwgDkEDdGooAgBqIAwgCUEDdGooAgBrIQYLIAMoAjQiCSADKAIsRgRAIANBLGpBkK6CARCzKAsgCEEEaiEIIAMoAjAgCUEDdGogBq03AwAgAyAJQQFqNgI0IARBAWohBCAKQQRrIgoNAAsLIANBsAFqIAZBAEEBQQEQoBggAygCtAEhCCADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAg2AlAgC0EETwRAIA1BAnQhBwNAIAIgBBCLOwRAIANBGGogASAFKAIAEPEWIANB0ABqIAMoAhggAygCHBChNgsgBUEEaiEFIARBAWohBCAHQQRrIgcNAAsgAygCWCEECwwECyAJIAdBgK6CARDDIQALIA4gB0HwrYIBEMMhAAsgCCADKAK4AUHQrYIBEP0vAAsgA0GwAWogCEEAQQFBARCgGCADKAK0ASEFIAMoArABQQFGDQFBACEEIANBADYCWCADIAMoArgBNgJUIAMgBTYCUCAKQQRPBEAgCUECdCEEA0AgA0EIaiABIAIoAgAQ8RYgA0HQAGogAygCCCADKAIMEKE2IAJBBGohAiAEQQRrIgQNAAsgAygCWCEECwsgA0GoAWogA0E0aigCADYCACADIAMpAiw3A6ABIAMpA1AhECADQewAaiADQaABahC9GCADIAQ2ArgBIAMgEDcDsAEgA0H4AGogA0GwAWoQkxkgA0HoAGpBmbLkyAE2AgAgA0GMAWogA0FAaykCADcCACADQZQBaiADQcgAaikCADcCACADQpmy5MiRo8aMGTcDYCADIAMpAjg3AoQBIAAgA0HgAGpBPPwKAAAgA0HAAWokAA8LIAUgAygCuAFBkKyCARD9LwALzhACDX8BfiMAQcABayIDJAAgA0E4aiACQQxqIgQQ2DxBAWpBAEEIQQgQoBggAygCPCEFAkACQAJAAkAgAygCOEEBRwRAIANBADYCNCADIAMoAkAiBzYCMCADIAU2AiwgBQR/IAcFIANBLGpB8KuCARCzKCADKAIwC0IANwMAIANBATYCNCABKAIQIQwgASgCFCADQThqIAEQkzYgAhDzEkEDdiEHAkAgARC3Og0AIAIQrjoNACADQSxqIAQQ2DwQ7C0gAigCFCIKQQN2IQkgAigCECECIApBCEkNAyAJQQN0IQUgAiEEA0ACQCAHIAQoAgAiBkEBaiILSwRAIAYgB0kNASAGIAdBwKyCARDDIQALIAsgB0GwrIIBEMMhAAsgDCALQQN0aigCACAMIAZBA3RqKAIAayAIaiIIrSEQIAMoAjQiBiADKAIsRgRAIANBLGpB0KyCARCzKAsgBEEIaiEEIAMoAjAgBkEDdGogEDcDACADIAZBAWo2AjQgBUEIayIFDQALDAMLIAIQrjoNASADQSxqIAQQ2DwQ7C0gAigCFCIKQQN2IQkgAigCECECAkACQAJAIApBCE8EQCAJQQN0IQUgAiEEA0AgASAEKAIAIgYQlTsEQCAGQQFqIgsgB08NBCAGIAdPDQMgCCAMIAtBA3RqKAIAaiAMIAZBA3RqKAIAayEICyADKAI0IgYgAygCLEYEQCADQSxqQbCtggEQsygLIARBCGohBCADKAIwIAZBA3RqIAitNwMAIAMgBkEBajYCNCAFQQhrIgUNAAsLIANBsAFqIAhBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0CQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgCkEITwRAIAlBA3QhBANAIAEgAigCACIFEJU7BEAgA0EQaiABIAUQ8hYgA0HQAGogAygCECADKAIUEKE2CyACQQhqIQIgBEEIayIEDQALIAMoAlghBAsMBgsgBiAHQaCtggEQwyEACyALIAdBkK2CARDDIQALIAUgAygCuAFB8KyCARD9LwALIAUgAygCQEHgq4IBEP0vAAsgARC3OgRAIAMoAjgEQCADQSxqIAQQ2DwQ7C0gAigCFCILQQN2IQ0gAigCECEIAkACQAJAAkAgC0EITwRAIA1BA3QhCiADKAJEIQIgAygCPCEPIAMoAkghBCAIIQUDQCAERQ0FIA8gAkEDdmotAAAgAkEHcXZBAXEEQCAFKAIAIglBAWoiDiAHTw0EIAcgCU0NAyAGIAwgDkEDdGooAgBqIAwgCUEDdGooAgBrIQYLIAMoAjQiCSADKAIsRgRAIANBLGpBgK+CARCzKAsgBUEIaiEFIAMoAjAgCUEDdGogBq03AwAgAyAJQQFqNgI0IARBAWshBCACQQFqIQIgCkEIayIKDQALCyADQbABaiAGQQBBAUEBEKAYIAMoArQBIQIgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyACNgJQIAtBCE8EQCANQQN0IQcgAygCRCECIAMoAjwhBSADKAJIIQQDQAJAIAQEQCAFIAJBA3ZqLQAAIAJBB3F2QQFxRQ0BIANBIGogASAIKAIAEPIWIANB0ABqIAMoAiAgAygCJBChNgwBC0GQ9IEBQSBBsPSBARCfKQALIAhBCGohCCAEQQFrIQQgAkEBaiECIAdBCGsiBw0ACyADKAJYIQQLDAcLIAkgB0HwroIBEMMhAAsgDiAHQeCuggEQwyEACyACIAMoArgBQcCuggEQ/S8AC0GQ9IEBQSBBsPSBARCfKQALQaCuggEQsjsACyADQSxqIAQQ2DwQ7C0gAigCFCILQQN2IQ0gAigCECEFAkACQAJAIAtBCE8EQCANQQN0IQpBACEEIAUhCANAIAgoAgAhCSACIAQQizsEQCAJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQZCuggEQsygLIAhBCGohCCADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFqIQQgCkEIayIKDQALCyADQbABaiAGQQBBAUEBEKAYIAMoArQBIQggAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAINgJQIAtBCE8EQCANQQN0IQcDQCACIAQQizsEQCADQRhqIAEgBSgCABDyFiADQdAAaiADKAIYIAMoAhwQoTYLIAVBCGohBSAEQQFqIQQgB0EIayIHDQALIAMoAlghBAsMBAsgCSAHQYCuggEQwyEACyAOIAdB8K2CARDDIQALIAggAygCuAFB0K2CARD9LwALIANBsAFqIAhBAEEBQQEQoBggAygCtAEhBSADKAKwAUEBRg0BQQAhBCADQQA2AlggAyADKAK4ATYCVCADIAU2AlAgCkEITwRAIAlBA3QhBANAIANBCGogASACKAIAEPIWIANB0ABqIAMoAgggAygCDBChNiACQQhqIQIgBEEIayIEDQALIAMoAlghBAsLIANBqAFqIANBNGooAgA2AgAgAyADKQIsNwOgASADKQNQIRAgA0HsAGogA0GgAWoQvRggAyAENgK4ASADIBA3A7ABIANB+ABqIANBsAFqEJMZIANB6ABqQZas2LABNgIAIANBjAFqIANBQGspAgA3AgAgA0GUAWogA0HIAGopAgA3AgAgA0KWrNiw4cKFixY3A2AgAyADKQI4NwKEASAAIANB4ABqQTz8CgAAIANBwAFqJAAPCyAFIAMoArgBQZCsggEQ/S8AC84QAg1/AX4jAEHAAWsiAyQAIANBOGogAkEMaiIEENg8QQFqQQBBCEEIEKAYIAMoAjwhBQJAAkACQAJAIAMoAjhBAUcEQCADQQA2AjQgAyADKAJAIgc2AjAgAyAFNgIsIAUEfyAHBSADQSxqQfCrggEQsyggAygCMAtCADcDACADQQE2AjQgASgCECEMIAEoAhQgA0E4aiABEJM2IAIQ8xJBA3YhBwJAIAEQtzoNACACEK46DQAgA0EsaiAEENg8EOwtIAIoAhQiCkEDdiEJIAIoAhAhAiAKQQhJDQMgCUEDdCEFIAIhBANAAkAgByAEKAIAIgZBAWoiC0sEQCAGIAdJDQEgBiAHQcCsggEQwyEACyALIAdBsKyCARDDIQALIAwgC0EDdGooAgAgDCAGQQN0aigCAGsgCGoiCK0hECADKAI0IgYgAygCLEYEQCADQSxqQdCsggEQsygLIARBCGohBCADKAIwIAZBA3RqIBA3AwAgAyAGQQFqNgI0IAVBCGsiBQ0ACwwDCyACEK46DQEgA0EsaiAEENg8EOwtIAIoAhQiCkEDdiEJIAIoAhAhAgJAAkACQCAKQQhPBEAgCUEDdCEFIAIhBANAIAEgBCgCACIGEJU7BEAgBkEBaiILIAdPDQQgBiAHTw0DIAggDCALQQN0aigCAGogDCAGQQN0aigCAGshCAsgAygCNCIGIAMoAixGBEAgA0EsakGwrYIBELMoCyAEQQhqIQQgAygCMCAGQQN0aiAIrTcDACADIAZBAWo2AjQgBUEIayIFDQALCyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAkEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBCE8EQCAJQQN0IQQDQCABIAIoAgAiBRCVOwRAIANBEGogASAFEPEWIANB0ABqIAMoAhAgAygCFBChNgsgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLDAYLIAYgB0GgrYIBEMMhAAsgCyAHQZCtggEQwyEACyAFIAMoArgBQfCsggEQ/S8ACyAFIAMoAkBB4KuCARD9LwALIAEQtzoEQCADKAI4BEAgA0EsaiAEENg8EOwtIAIoAhQiC0EDdiENIAIoAhAhCAJAAkACQAJAIAtBCE8EQCANQQN0IQogAygCRCECIAMoAjwhDyADKAJIIQQgCCEFA0AgBEUNBSAPIAJBA3ZqLQAAIAJBB3F2QQFxBEAgBSgCACIJQQFqIg4gB08NBCAHIAlNDQMgBiAMIA5BA3RqKAIAaiAMIAlBA3RqKAIAayEGCyADKAI0IgkgAygCLEYEQCADQSxqQYCvggEQsygLIAVBCGohBSADKAIwIAlBA3RqIAatNwMAIAMgCUEBajYCNCAEQQFrIQQgAkEBaiECIApBCGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASECIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgAjYCUCALQQhPBEAgDUEDdCEHIAMoAkQhAiADKAI8IQUgAygCSCEEA0ACQCAEBEAgBSACQQN2ai0AACACQQdxdkEBcUUNASADQSBqIAEgCCgCABDxFiADQdAAaiADKAIgIAMoAiQQoTYMAQtBkPSBAUEgQbD0gQEQnykACyAIQQhqIQggBEEBayEEIAJBAWohAiAHQQhrIgcNAAsgAygCWCEECwwHCyAJIAdB8K6CARDDIQALIA4gB0HgroIBEMMhAAsgAiADKAK4AUHAroIBEP0vAAtBkPSBAUEgQbD0gQEQnykAC0GgroIBELI7AAsgA0EsaiAEENg8EOwtIAIoAhQiC0EDdiENIAIoAhAhBQJAAkACQCALQQhPBEAgDUEDdCEKQQAhBCAFIQgDQCAIKAIAIQkgAiAEEIs7BEAgCUEBaiIOIAdPDQQgByAJTQ0DIAYgDCAOQQN0aigCAGogDCAJQQN0aigCAGshBgsgAygCNCIJIAMoAixGBEAgA0EsakGQroIBELMoCyAIQQhqIQggAygCMCAJQQN0aiAGrTcDACADIAlBAWo2AjQgBEEBaiEEIApBCGsiCg0ACwsgA0GwAWogBkEAQQFBARCgGCADKAK0ASEIIAMoArABQQFGDQJBACEEIANBADYCWCADIAMoArgBNgJUIAMgCDYCUCALQQhPBEAgDUEDdCEHA0AgAiAEEIs7BEAgA0EYaiABIAUoAgAQ8RYgA0HQAGogAygCGCADKAIcEKE2CyAFQQhqIQUgBEEBaiEEIAdBCGsiBw0ACyADKAJYIQQLDAQLIAkgB0GAroIBEMMhAAsgDiAHQfCtggEQwyEACyAIIAMoArgBQdCtggEQ/S8ACyADQbABaiAIQQBBAUEBEKAYIAMoArQBIQUgAygCsAFBAUYNAUEAIQQgA0EANgJYIAMgAygCuAE2AlQgAyAFNgJQIApBCE8EQCAJQQN0IQQDQCADQQhqIAEgAigCABDxFiADQdAAaiADKAIIIAMoAgwQoTYgAkEIaiECIARBCGsiBA0ACyADKAJYIQQLCyADQagBaiADQTRqKAIANgIAIAMgAykCLDcDoAEgAykDUCEQIANB7ABqIANBoAFqEL0YIAMgBDYCuAEgAyAQNwOwASADQfgAaiADQbABahCTGSADQegAakGZsuTIATYCACADQYwBaiADQUBrKQIANwIAIANBlAFqIANByABqKQIANwIAIANCmbLkyJGjxowZNwNgIAMgAykCODcChAEgACADQeAAakE8/AoAACADQcABaiQADwsgBSADKAK4AUGQrIIBEP0vAAunEgIMfwF+QQohByMAQcABayIFJAAgBSADOgALIAEgAhDkISEBIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAesfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgB6wiESARfiIRQiCIpyARpyIHQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiCCgCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogCCgCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiABQQxqIg8Q2zwQ9x4gBC0ANCECIA8Q2zwhDgJAIAJFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhB0EAIQICQANAAkACQAJAAkACQCABIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQUgASgCECAHaigCACEEIAUgAzYCsAEgBSAENgKYASADBH8gDSAEQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQhBiICAgHgFQYeAgIB4CyEBIAAgCDYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAMAgsgDBDmOiAFKAIYRQ0GIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQsgBSgCHCIKIAZJBEAgDCAKQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIKIAQgCksbEOgZIAUoAiQhBAsgCwRAIAUoAiAgBGpBACAL/AsACyAFIAY2AiQLIAUgCTYCKCAFKAIUIgQgBSgCDEYEQCAFQQxqQfSSgAEQqRkLIAUoAhAgBGpBADoAAAwDCyAFIAQgA20iCDYClAEgCEGAAkkNASAFQbgBakGGjJgwNgIAIAVChoyYsODAgYMGNwOwASAFQQI2AmggBUHgpYABNgJkIAVCAjcCcCAFQa0DNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWoiATYCSCAFIAVBlAFqNgJAIAVBoAFqIAVB5ABqEJkOIAEQqQwgACAFKQChATcABSAAQQxqIAVBqAFqKQAANwAAIAAgBS0AoAE6AAQgAEGCgICAeDYCAAsgBUEMahC3LQwHCwJAIAUoAhgEQCAFKAIoIglBAWoiC0EDdiALQQdxQQBHaiIGIAUoAiQiBEsEQCAGIARrIQogBSgCHCIQIAZJBEAgDCAQQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIQIAQgEEsbEOgZIAUoAiQhBAsgCgRAIAUoAiAgBGpBACAK/AsACyAFIAY2AiQLIAUgCzYCKCAFKAIgIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBCAFKAIMRgRAIAVBDGpBhJOAARCpGQsgBSgCECAEaiAIOgAACyAFIARBAWo2AhQgB0EEaiEHIA4gAkEBaiICRw0BDAQLCyAFIAEQ/Ds2AkAgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQUBrNgKkASAFIAVBsAFqNgKcAQwFC0GglYABELI7AAsgDkUNACAFQRhqIQYgBUGgAWohCyADQX9HIQpBACEHQQAhAgNAAkAgBUEMagJ/AkACQAJAIAEgAhCHJUUEQCAFIAI2ApgBIA8Q2zwgAk0NASABKAIQIAdqKAIAIQQgBSADNgKYASAFIAQ2ApQBAkAgAwRAIApFIARBgICAgHhGcUUEQCAEIANtIQQMBgsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASALIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiETcDQCARp0GTgICAeEcNASAFKAJEIQQMBQsgBUGHgICAeDYCQAsgBUFAaxCIEUEADAQLIAYQ5jogBSgCGEUNASAFKAIoQQFqIgxBA3YgDEEHcUEAR2oiBCAFKAIkIghLBEAgBCAIayEJIAUoAhwiDSAESQRAIAYgDUEBdCIIIARBwP///wNxQUBrIAQgBEE/cRsiDSAIIA1LGxDoGSAFKAIkIQgLIAkEQCAFKAIgIAhqQQAgCfwLAAsgBSAENgIkCyAFIAw2AiggBSgCFCIEIAUoAgxGBEAgBUEMakH0koABEKkZCyAFKAIQIARqQQA6AAAgBSAEQQFqNgIUDAQLIAUgARD8OzYCsAEgBUECNgJoIAVB1JKAATYCZCAFQgI3AnAgBUE7NgKoASAFQTs2AqABIAUgBUGcAWo2AmwgBSAFQbABajYCpAEgBSAFQZgBajYCnAEMCAtBoJWAARCyOwALIARBgAJJCyAEEPALCyAHQQRqIQcgDiACQQFqIgJHDQALCyAFQeQAaiICIAVBDGoiAxDRFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaikgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHAAWokAA8LQQRBOBCjPQALIAVB5ABqQeSSgAEQ7ywAC50SAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBD1HiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBAAwDCyAFIBEgD38iEDcDqAEgEEKAgAJ8QoCABFQNASAFQdgBakGDhowYNgIAIAVCg4aMmLDgwIEDNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAAgBSkBZjcBBiAAQQxqIAVB7ABqKQEANwEAIAAgBS8BZDsBBCAAQYKAgIB4NgIACyAFQSxqELgtDAgLAkAgBSgCOARAIAUoAkgiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCRCIGSwRAIAQgBmshByAFKAI8IgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCRCEGCyAHBEAgBSgCQCAGakEAIAf8CwALIAUgBDYCRAsgBSAKNgJIIAUoAkAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCTEEBajYCTAsgBSgCNCIEIAUoAixGBEAgBUEsakGEk4ABEK0oCyAFKAIwIARBAXRqIBA9AQALIAUgBEEBajYCNCADQQhqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCMCAFQYiYgAE2AiwgBUICNwI4IAVB+g82AmwgBUH9DzYCZCAFIAVB4ABqNgI0IAUgBUHQAWo2AmggBSAFQbgBaiIBNgJgIAVB/ABqIAVBLGoiAhCZDiAFKQJ8IQ8gBSAFKQKEATcChAEgBSAPNwJ8IAVBiICAgHg2AnggBUEDNgIwIAVBrKWAATYCLCAFQgI3AjggBUH0CzYCxAEgBUHEDTYCvAEgBUHonIABNgK4ASAFIAE2AjQgBSAFQStqNgLAASAFQeQAaiACEJkOIAVB+ABqEIgRIAUpAmQhDyAAIAUpAmw3AgwgACAPNwIEIABBgoCAgHg2AgAMBAsgBSABEP07NgK4ASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgJsIAVBOzYCZCAFIAVB4ABqNgKAASAFIAVBuAFqNgJoIAUgBUHQAWo2AmAMBQtBoJWAARCyOwALIAxFDQAgBUE4aiEJIAVB4ABqQQRyIQggBUG8AWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDRDYPCACTQ0CIAUgASgCECADaikDACIQNwOoASAFIA83A7ABAkACQAJAIA9QRQRAIA9Cf1IgEEKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUEAIQQMAQsgECAPfyIQQoCAAnxCgIAEVCEEIBCnIQYLIAVBLGogBCAGEN4LDAELIAkQ5jogBSgCOEUNAyAFKAJIQQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEHIAUoAjwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSAGNgJECyAFIAo2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEK0oCyAFKAIwIARBAXRqQQA7AQAgBSAEQQFqNgI0CyADQQhqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD9OzYC0AEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCxAEgBUE7NgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4AQwEC0GglYABELI7AAsgBUH4AGoiAiAFQSxqIgMQzhRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGYoIABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuC0LIAVB4AFqJAAPC0EEQTgQoz0ACyAFQfgAakHkkoABEO8sAAulEgIKfwN+QgohECMAQeABayIFJAAgBSADOgArIAEgAhDoISEBIAUgA8AiAjYC0AEgBUIKNwO4AUIBIQ8CQAJAAkACQAJAAkACQAJAAkAgA0H/AXFFDQADQCACQQFxBEAgBUEQaiAPIA9CP4cgECAQQj+HEKgeIAUpAxggBSkDECIPQj+HUg0DIAJBAUYNAgsgBSAQIBBCP4ciESAQIBEQqB4gBSkDCCAFKQMAIhBCP4dSDQIgAkEBdiECDAALAAsgBUEsaiABQQxqIg0Q2DwQ+R4gBC0ANCANENg8IQwNAyAMRQ0EIAVBOGohCEEAIQNBACECA0ACQAJAAkACQCABIAIQhyVFBEAgBSACNgLQASANENg8IAJNDQcgBSABKAIQIANqKQMAIhE3A7ABIAUgDzcD0AEgD1AEf0GHgICAeAUgD0J/UiARQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4ASAFQeQAaiAFQfgAahCZDiAFKQJkIRAgBSkCbCEPQYiAgIB4CyEBIAAgDzcCDCAAIBA3AgQgACABNgIADAILIAgQ5jogBSgCOEUNByAFKAJIQQFqIglBA3YgCUEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEKIAUoAjwiByAGSQRAIAggB0EBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiByAEIAdLGxDoGSAFKAJEIQQLIAoEQCAFKAJAIARqQQAgCvwLAAsgBSAGNgJECyAFIAk2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEJ0oCyAFKAIwIARBAnRqQQA2AgAMAwsgBSARIA9/IhA3A6gBIBBCgICAgAh8QoCAgIAQVA0BIAVB2AFqQYSIkCA2AgAgBUKEiJCgwICBggQ3A9ABIAVBAjYCfCAFQeClgAE2AnggBUICNwKEASAFQa0DNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqIgE2AsABIAUgBUGoAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAEQqQwgACAFKQJoNwIIIABBEGogBUHwAGooAgA2AgAgACAFKAJkNgIEIABBgoCAgHg2AgALIAVBLGoQuS0MCAsCQCAFKAI4BEAgBSgCSCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJEIgZLBEAgBCAGayEHIAUoAjwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJEIQYLIAcEQCAFKAJAIAZqQQAgB/wLAAsgBSAENgJECyAFIAo2AkggBSgCQCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgQgBSgCLEYEQCAFQSxqQYSTgAEQnSgLIAUoAjAgBEECdGogED4CAAsgBSAEQQFqNgI0IANBCGohAyAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQkgBUHgAGpBBHIhCCAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIhA3A6gBIAUgDzcDsAECQAJAAkAgD1BFBEAgD0J/UiAQQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLcASAFQf0PNgLUASAFIAVB0AFqNgKAASAFIAVBsAFqNgLYASAFIAVBqAFqNgLQASALIAVB+ABqEJkOIAVBiICAgHg2ArgBIAggBSkCuAE3AgAgCEEIaiAFQcABaikCADcCACAIQRBqIAVByAFqKAIANgIADAELIAVBh4CAgHg2AmQLIAVBATYCYCAIEIgRQQAhBAwBCyAQIA9/IhBCgICAgAh8QoCAgIAQVCEEIBCnIQYLIAVBLGogBCAGEN8LDAELIAkQ5jogBSgCOEUNAyAFKAJIQQFqIgpBA3YgCkEHcUEAR2oiBiAFKAJEIgRLBEAgBiAEayEHIAUoAjwiDiAGSQRAIAkgDkEBdCIEIAZBwP///wNxQUBrIAYgBkE/cRsiDiAEIA5LGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSAGNgJECyAFIAo2AkggBSgCNCIEIAUoAixGBEAgBUEsakH0koABEJ0oCyAFKAIwIARBAnRqQQA2AgAgBSAEQQFqNgI0CyADQQhqIQMgDCACQQFqIgJHDQEMAwsLIAUgARD9OzYC0AEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCxAEgBUE7NgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4AQwEC0GglYABELI7AAsgBUH4AGoiAiAFQSxqIgMQ0BRBOEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEH4ooABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuS0LIAVB4AFqJAAPC0EEQTgQoz0ACyAFQfgAakHkkoABEO8sAAvUFQISfwd+IwBBQGoiECQAIBBBKGpCADcDACAQQSBqQgA3AwAgEEEYakIANwMAIBBCADcDEAJAAkACQAJAAkAgAgRAIABBBGshFyABrSEdQoCAgIBwISBBASEAA0ACQAJAAkAgHSAhUgRAIBdBBGoiFygCACILRQ0DIB9CBFQNAQwCCyABIAFB9LDQABDDIQALIBBBEGogH6dBA3RqICE3AwALIAIgC2shAiAfQgF8IR8LIABBAmohACAgQoCAgICAgEB9ISAgE0EBaiETICFCAXwhISACDQALIB9CAVYNASAQKQMQIR4LQQRCASAIIAkgChDlEiADIB4gCCAJIAoQ5RIgBSAepyIATQ0CIAAgBGpBADoAACAAIAdPDQEgBiAAQQF0akEAOwEADAQLIAUgE08EQCATBEAgBEEAIBP8CwALIBNBAWshHCAQQQhqIQsjAEEwayICJAACfyAARQRAIAJBADYCJCACQoCAgIDAADcCHCACQQhqIAJBHGpBjIfOABCfISACKAIIIQAgAigCDAwBCyACQgA3AyggAkEcaiIPIAJBKGogABCJHCACQRBqIA9BzILOABCfISACKAIQIQAgAigCFAshDyALIAA2AgAgCyAPNgIEIAJBMGokAEIAICF9ISIgECgCDCEMIBAoAgghD0EBIRYDQCAWrSEjIBchDiAcIQsgIiEdICAhHkEAIQ0DQAJAAkAgASAcSwRAIA4oAgAiAA0BDAILIAsgAUGksNAAEMMhAAsCQAJAAkAgACAWSQRAIAwgDU0NASAPIA1BA3RqIB4gI3w3AgAMAwsgDCANSw0BIA0gDEHEsNAAEMMhAAsgDSAMQbSw0AAQwyEACyAPIA1BA3RqIB4gAK18NwIACyANQQFqIQ0LIA5BBGshDiALQQFrIQsgHkKAgICAgIBAfCEeIB1CAXwiHVBFDQALAkAgDUEMTQRAIA1BAkkNAUEBIAwgDEEBTRshESAPIQJBASELA0ACQCALIBFHBEAgC0EBaiEOIA8gC0EDdGopAgAiHachEiACIQADQCAAKAIAIBJNDQIgAEEIaiAAKQIANwIAIABBCGshACALQQFrIgsNAAtBACELDAELIBEgDEH84dAAEMMhAAsgCyAMSQRAIA8gC0EDdGogHTcCACACQQhqIQIgDiILIA1HDQEMAwsLIAsgDEGM4tAAEMMhAAsgDUE5SUEBdCEUA0ACQCAUQQJ0QYiQ0gBqKAIAIg4gDU8NACAOIAwgDCAOSRshFUEAIRFBACAOQQN0IhhrIRkgDyECIA4hAAJAA0ACfwJAIAAgFUcEQCAAQQFqIRIgDyAAQQN0aikCACIdpyEaIAIhACARIQsDQCALIAxPDQUgACgCACAaTQ0CIAAgGGogACkCADcCACAAIBlqIQAgCyAOSSALIA5rIQtFDQALIAsgDmoMAgsgFSAMQczh0AAQwyEACyALIA5qCyIAIAxJBEAgDyAAQQN0aiAdNwIAIAJBCGohAiARQQFqIREgEiIAIA1HDQEMAwsLIAAgDEHs4dAAEMMhAAsgCyAMQdzh0AAQwyEACyAUQQFqIhRBBkcNAAsLIAwgDUEBaiIOTQRAIA4gDEGErtAAEMMhAAsgDyAOQQN0akJ/NwIAIAwgDU0EQCANIAxBlK7QABDDIQALIA8gDUEDdGoiC0J/NwIAAkAgDUEBayIUQQBMBEAgDUEBdCEVDAELIA1BAXQhFSANQQJqIRFBACENA0ACQAJAAkACQAJAIAwgDUsEQCAMIA5NDQEgDSAPIA1BA3RqKAIAIgAgDyAOQQN0aigCACISTWoiAiAMTw0CIA4gACASSyIAaiISIAxPDQMgDiANIAAbIgAgDE8NBCASIAIgDyACQQN0aigCACIOIA8gEkEDdGooAgAiGEsiGRsiDSAMSQ0FIA0gDEGEsNAAEMMhAAsgDSAMQbSv0AAQwyEACyAOIAxBxK/QABDDIQALIAIgDEHUr9AAEMMhAAsgEiAMQeSv0AAQwyEACyAAIAxB9K/QABDDIQALIA8gDUEDdGooAgAhGiAPIABBA3RqKAIAIRsgC0EOaiANOwEAIAtBDGogADsBACALQQhqIgAgGiAbajYCACAMIBFHBEAgAiAOIBhNaiENIBIgGWohDiALQRBqQn83AgAgEUEBaiERIAAhCyAUQQFrIhRFDQIMAQsLIAwgDEGUsNAAEMMhAAsgFkEBdCEWIBVBAWsgDyAMIAQgBUEOEIkRRQ0ACyAQQQA2AjwgEEKAgICAwAA3AjQgECAQQTRqQYyHzgAQnyEgECgCBCEAIBAoAgAhASAPIAxBA3RBBBD4OiAABEAgASAAQQN0QQQQ+DoLIAQgBSATIAYgBxCzCyAfQgVaBEAgIUIBfSEgQShC1KrVqvUfIAggCSAKEOUSIARBAWohA0EIIQtCACEfA0ACfgJAIB+nIgEgBUkEQCABIARqLQAAIQAgHyAgVA0BQgEhHSAfQgF8DAILIAEgBUGkrtAAEMMhAAsgASADaiECICEgH30iHUIBfSEiIAUgAWutQgF9ISNCACEeA0ACQAJAIB4gI1IEQCACLQAAIABGDQEgHkIBfCEdDAILIAUgBUG0rtAAEMMhAAsgAkEBaiECICIgHkIBfCIeUg0BCwsgHSAffAshHwJAAkACQAJAAkACQAJAAkACQCAARQRAIB2nIgBBwAVJDQEgAEHABUHErtAAEMMhAAsgACALQf8BcUcEQCAAQRJPDQMgAEG0l+IAai0AACAAQQJ0QcjN4gBqNQIAIAggCSAKEOUSIB1CAX0hHQsgHUICVg0DIB1QRQ0BDAcLIABBAnQiAEHIoeIAaiECIABByLfiAGohDgwFCyAAQRFLDQIgAEECdEHIzeIAaiEBA0AgAEG0l+IAai0AACABNQIAIAggCSAKEOUSIB1CAX0iHVBFDQALDAULIABBEkHUrtAAEMMhAAsgHadBA2siAUHABU8NASABQQJ0IgFBkM7iAGohAiABQZDk4gBqIQ4gACELDAILIABBEkH0rtAAEMMhAAsgAUHABUHkrtAAEMMhAAsgDigCACACNQIAIAggCSAKEOUSDAELIAAhCwsgHyAgWA0ACwwFC0ECQgEgCCAJIAoQ5RJBAiAfQgF9IAggCSAKEOUSIB+nIgZBAWshESAQQRhqIQtBACEBDAMLIBMgBUH0rdAAELA7AAsgACAHQeSw0AAQwyEACyAAIAVB1LDQABDDIQALA0ACQCABIgBBAWoiASAGTw0AIBBBEGogAEEDdGohByALIQIgESEAAkADQCACKQMAIh2nIg8gBUkEQCAFIAcpAwAiHqciDE0NAiAEIA9qLQAAIAQgDGotAABJBEAgAiAeNwMAIAcgHTcDAAsgAkEIaiECIABBAWsiAA0BDAMLCyAPIAVBlK/QABDDIQALIAwgBUGkr9AAEMMhAAsgC0EIaiELIBFBAWshESABIAZHDQALIAMgECkDECIdIAggCSAKEOUSIAMgECkDGCAIIAkgChDlEgJAIB9CAn0iHkIBWARAIB6nQQFrDQIMAQsgAyAQKQMgIAggCSAKEOUSIAMgECkDKCAIIAkgChDlEiAdpyIAIAVJBEBBASAAIARqLQAAQQFGrSAIIAkgChDlEgwCCyAAIAVBhK/QABDDIQALIAMgECkDICAIIAkgChDlEgsgEEFAayQAC5MSAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDzHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBAAwDCyAFIBEgD38iEDcDqAEgEEKAgARUDQEgBUHYAWpBh46cODYCACAFQoeOnLjw4MGDBzcD0AEgBUECNgJ8IAVB4KWAATYCeCAFQgI3AoQBIAVBrQM2AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWoiATYCwAEgBSAFQagBajYCuAEgBUHkAGogBUH4AGoQmQ4gARCpDCAAIAUpAWY3AQYgAEEMaiAFQewAaikBADcBACAAIAUvAWQ7AQQgAEGCgICAeDYCAAsgBUEsahC4LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCtKAsgBSgCMCAEQQF0aiAQPQEACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiEDcDqAEgBSAPNwOwAQJAAkACQCAPUEUEQCAPQn9SIBBCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCCAFKQK4ATcCACAIQQhqIAVBwAFqKQIANwIAIAhBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAgQiBFBACEEDAELIBAgD38iEEKAgARUIQQgEKchBgsgBUEsaiAEIAYQ3gsMAQsgCRDmOiAFKAI4RQ0DIAUoAkhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQcgBSgCPCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAkQhBAsgBwRAIAUoAkAgBGpBACAH/AsACyAFIAY2AkQLIAUgCjYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQrSgLIAUoAjAgBEEBdGpBADsBACAFIARBAWo2AjQLIANBCGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP07NgLQASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgLEASAFQTs2ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBDAQLQaCVgAEQsjsACyAFQfgAaiICIAVBLGoiAxDPFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcCfgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC4LQsgBUHgAWokAA8LQQRBOBCjPQALIAVB+ABqQeSSgAEQ7ywAC5gSAgp/A35CCiEQIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhDwJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIA8gD0I/hyAQIBBCP4cQqB4gBSkDGCAFKQMQIg9CP4dSDQMgAkEBRg0CCyAFIBAgEEI/hyIRIBAgERCoHiAFKQMIIAUpAwAiEEI/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDyHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACQAJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAPNwPQASAPUAR/QYeAgIB4BSAPQn9SIBFCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhECAFKQJsIQ9BiICAgHgLIQEgACAPNwIMIAAgEDcCBCAAIAE2AgAMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQnSgLIAUoAjAgBEECdGpBADYCAAwDCyAFIBEgD38iEDcDqAEgEEKAgICAEFQNASAFQdgBakGIkKDAADYCACAFQoiQoMCAgYKECDcD0AEgBUECNgJ8IAVB4KWAATYCeCAFQgI3AoQBIAVBrQM2AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWoiATYCwAEgBSAFQagBajYCuAEgBUHkAGogBUH4AGoQmQ4gARCpDCAAIAUpAmg3AgggAEEQaiAFQfAAaigCADYCACAAIAUoAmQ2AgQgAEGCgICAeDYCAAsgBUEsahC5LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCdKAsgBSgCMCAEQQJ0aiAQPgIACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiEDcDqAEgBSAPNwOwAQJAAkACQCAPUEUEQCAPQn9SIBBCgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCCAFKQK4ATcCACAIQQhqIAVBwAFqKQIANwIAIAhBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAgQiBFBACEEDAELIBAgD38iEEKAgICAEFQhBCAQpyEGCyAFQSxqIAQgBhDfCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCdKAsgBSgCMCAEQQJ0akEANgIAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENQUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABByKGAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALkBICCn8DfkIKIRAjAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEPAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogDyAPQj+HIBAgEEI/hxCoHiAFKQMYIAUpAxAiD0I/h1INAyACQQFGDQILIAUgECAQQj+HIhEgECAREKgeIAUpAwggBSkDACIQQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPAeIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDYPCACTQ0HIAUgASgCECADaikDACIRNwOwASAFIA83A9ABIA9QBH9Bh4CAgHgFIA9Cf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEgBUHkAGogBUH4AGoQmQ4gBSkCZCEQIAUpAmwhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAjhFDQcgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshCiAFKAI8IgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCRCEECyAKBEAgBSgCQCAEakEAIAr8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCjKAsgBSgCMCAEakEAOgAADAMLIAUgESAPfyIQNwOoASAQQoABfEKAAlQNASAFQdgBakGChIgQNgIAIAVCgoSIkKDAgIECNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAAgBSkAZTcABSAAQQxqIAVB7ABqKQAANwAAIAAgBS0AZDoABCAAQYKAgIB4NgIACyAFQSxqELctDAgLAkAgBSgCOARAIAUoAkgiCUEBaiIKQQN2IApBB3FBAEdqIgQgBSgCRCIGSwRAIAQgBmshByAFKAI8IgsgBEkEQCAIIAtBAXQiBiAEQcD///8DcUFAayAEIARBP3EbIgsgBiALSxsQ6BkgBSgCRCEGCyAHBEAgBSgCQCAGakEAIAf8CwALIAUgBDYCRAsgBSAKNgJIIAUoAkAgCUEDdmoiBCAELQAAQQEgCUEHcXRyOgAADAELIAUgBSgCTEEBajYCTAsgBSgCNCIEIAUoAixGBEAgBUEsakGEk4ABEKMoCyAFKAIwIARqIBA8AAALIAUgBEEBajYCNCADQQhqIQMgDCACQQFqIgJHDQALDAQLIAVBAjYCMCAFQYiYgAE2AiwgBUICNwI4IAVB+g82AmwgBUH9DzYCZCAFIAVB4ABqNgI0IAUgBUHQAWo2AmggBSAFQbgBaiIBNgJgIAVB/ABqIAVBLGoiAhCZDiAFKQJ8IQ8gBSAFKQKEATcChAEgBSAPNwJ8IAVBiICAgHg2AnggBUEDNgIwIAVBrKWAATYCLCAFQgI3AjggBUH0CzYCxAEgBUHEDTYCvAEgBUHonIABNgK4ASAFIAE2AjQgBSAFQStqNgLAASAFQeQAaiACEJkOIAVB+ABqEIgRIAUpAmQhDyAAIAUpAmw3AgwgACAPNwIEIABBgoCAgHg2AgAMBAsgBSABEP07NgK4ASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgJsIAVBOzYCZCAFIAVB4ABqNgKAASAFIAVBuAFqNgJoIAUgBUHQAWo2AmAMBQtBoJWAARCyOwALIAxFDQAgBUE4aiEJIAVB4ABqQQRyIQggBUG8AWohC0EAIQNBACECAkADQAJAAkAgASACEIclRQRAIAUgAjYCsAEgDRDYPCACTQ0CIAUgASgCECADaikDACIQNwOoASAFIA83A7ABAkACQAJAIA9QRQRAIA9Cf1IgEEKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUEAIQQMAQsgECAPfyIQQoABfEKAAlQhBCAQpyEGCyAFQSxqIAQgBhDxCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCjKAsgBSgCMCAEakEAOgAAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENYUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB0KOAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELctCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALiBICCn8DfkIKIRAjAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEPAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogDyAPQj+HIBAgEEI/hxCoHiAFKQMYIAUpAxAiD0I/h1INAyACQQFGDQILIAUgECAQQj+HIhEgECAREKgeIAUpAwggBSkDACIQQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPceIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQhBACEDQQAhAgNAAkACQAJAAkAgASACEIclRQRAIAUgAjYC0AEgDRDYPCACTQ0HIAUgASgCECADaikDACIRNwOwASAFIA83A9ABIA9QBH9Bh4CAgHgFIA9Cf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEgBUHkAGogBUH4AGoQmQ4gBSkCZCEQIAUpAmwhD0GIgICAeAshASAAIA83AgwgACAQNwIEIAAgATYCAAwCCyAIEOY6IAUoAjhFDQcgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshCiAFKAI8IgcgBkkEQCAIIAdBAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIgcgBCAHSxsQ6BkgBSgCRCEECyAKBEAgBSgCQCAEakEAIAr8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCpGQsgBSgCMCAEakEAOgAADAMLIAUgESAPfyIQNwOoASAQQoACVA0BIAVB2AFqQYaMmDA2AgAgBUKGjJiw4MCBgwY3A9ABIAVBAjYCfCAFQeClgAE2AnggBUICNwKEASAFQa0DNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqIgE2AsABIAUgBUGoAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAEQqQwgACAFKQBlNwAFIABBDGogBUHsAGopAAA3AAAgACAFLQBkOgAEIABBgoCAgHg2AgALIAVBLGoQty0MCAsCQCAFKAI4BEAgBSgCSCIJQQFqIgpBA3YgCkEHcUEAR2oiBCAFKAJEIgZLBEAgBCAGayEHIAUoAjwiCyAESQRAIAggC0EBdCIGIARBwP///wNxQUBrIAQgBEE/cRsiCyAGIAtLGxDoGSAFKAJEIQYLIAcEQCAFKAJAIAZqQQAgB/wLAAsgBSAENgJECyAFIAo2AkggBSgCQCAJQQN2aiIEIAQtAABBASAJQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgQgBSgCLEYEQCAFQSxqQYSTgAEQqRkLIAUoAjAgBGogEDwAAAsgBSAEQQFqNgI0IANBCGohAyAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQkgBUHgAGpBBHIhCCAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIhA3A6gBIAUgDzcDsAECQAJAAkAgD1BFBEAgD0J/UiAQQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLcASAFQf0PNgLUASAFIAVB0AFqNgKAASAFIAVBsAFqNgLYASAFIAVBqAFqNgLQASALIAVB+ABqEJkOIAVBiICAgHg2ArgBIAggBSkCuAE3AgAgCEEIaiAFQcABaikCADcCACAIQRBqIAVByAFqKAIANgIADAELIAVBh4CAgHg2AmQLIAVBATYCYCAIEIgRQQAhBAwBCyAQIA9/IhBCgAJUIQQgEKchBgsgBUEsaiAEIAYQ8AsMAQsgCRDmOiAFKAI4RQ0DIAUoAkhBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQcgBSgCPCIOIAZJBEAgCSAOQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIOIAQgDksbEOgZIAUoAkQhBAsgBwRAIAUoAkAgBGpBACAH/AsACyAFIAY2AkQLIAUgCjYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQqRkLIAUoAjAgBGpBADoAACAFIARBAWo2AjQLIANBCGohAyAMIAJBAWoiAkcNAQwDCwsgBSABEP07NgLQASAFQQI2AnwgBUHUkoABNgJ4IAVCAjcChAEgBUE7NgLEASAFQTs2ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBDAQLQaCVgAEQsjsACyAFQfgAaiICIAVBLGoiAxDRFEE4QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQaikgAE2AgggACABNgIEIABBk4CAgHg2AgAgAxC3LQsgBUHgAWokAA8LQQRBOBCjPQALIAVB+ABqQeSSgAEQ7ywAC/QRAgp/A35CCiEPIwBB4AFrIgUkACAFIAM6ACsgASACEOghIQEgBSADwCICNgLQASAFQgo3A7gBQgEhEAJAAkACQAJAAkACQAJAAkACQCADQf8BcUUNAANAIAJBAXEEQCAFQRBqIBAgEEI/hyAPIA9CP4cQqB4gBSkDGCAFKQMQIhBCP4dSDQMgAkEBRg0CCyAFIA8gD0I/hyIRIA8gERCoHiAFKQMIIAUpAwAiD0I/h1INAiACQQF2IQIMAAsACyAFQSxqIAFBDGoiDRDYPBDvHiAELQA0IA0Q2DwhDA0DIAxFDQQgBUE4aiEIQQAhA0EAIQIDQAJAAkACfwJAIAEgAhCHJUUEQCAFIAI2AtABIA0Q2DwgAk0NByAFIAEoAhAgA2opAwAiETcDsAEgBSAQNwPQAUGHgICAeCAQUA0CGiAQQn9SIBFCgICAgICAgICAf1JyDQEgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AsQBIAVB/Q82ArwBIAUgBUG4AWo2AoABIAUgBUHQAWo2AsABIAUgBUGwAWo2ArgBIAVB5ABqIAVB+ABqEJkOIAUpAmQhDyAFKQJsIRBBiICAgHgMAgsgCBDmOiAFKAI4RQ0HIAUoAkhBAWoiCUEDdiAJQQdxQQBHaiIGIAUoAkQiBEsEQCAGIARrIQogBSgCPCIHIAZJBEAgCCAHQQF0IgQgBkHA////A3FBQGsgBiAGQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCgRAIAUoAkAgBGpBACAK/AsACyAFIAY2AkQLIAUgCTYCSCAFKAI0IgQgBSgCLEYEQCAFQSxqQfSSgAEQsygLIAUoAjAgBEEDdGpCADcDAAwDCyAFIBEgEH8iDzcDqAEgD0IAWQ0BIAVB2AFqQYmSpMgANgIAIAVCiZKkyJChwoQJNwPQASAFQQI2AnwgBUHgpYABNgJ4IAVCAjcChAEgBUGtAzYCxAEgBUH9DzYCvAEgBSAFQbgBajYCgAEgBSAFQdABaiIBNgLAASAFIAVBqAFqNgK4ASAFQeQAaiAFQfgAahCZDiABEKkMIAUpAmQhDyAFKQJsIRBBgoCAgHgLIQEgACAQNwIMIAAgDzcCBCAAIAE2AgAgBUEsahC6LQwICwJAIAUoAjgEQCAFKAJIIglBAWoiCkEDdiAKQQdxQQBHaiIEIAUoAkQiBksEQCAEIAZrIQcgBSgCPCILIARJBEAgCCALQQF0IgYgBEHA////A3FBQGsgBCAEQT9xGyILIAYgC0sbEOgZIAUoAkQhBgsgBwRAIAUoAkAgBmpBACAH/AsACyAFIAQ2AkQLIAUgCjYCSCAFKAJAIAlBA3ZqIgQgBC0AAEEBIAlBB3F0cjoAAAwBCyAFIAUoAkxBAWo2AkwLIAUoAjQiBCAFKAIsRgRAIAVBLGpBhJOAARCzKAsgBSgCMCAEQQN0aiAPNwMACyAFIARBAWo2AjQgA0EIaiEDIAwgAkEBaiICRw0ACwwECyAFQQI2AjAgBUGImIABNgIsIAVCAjcCOCAFQfoPNgJsIAVB/Q82AmQgBSAFQeAAajYCNCAFIAVB0AFqNgJoIAUgBUG4AWoiATYCYCAFQfwAaiAFQSxqIgIQmQ4gBSkCfCEPIAUgBSkChAE3AoQBIAUgDzcCfCAFQYiAgIB4NgJ4IAVBAzYCMCAFQaylgAE2AiwgBUICNwI4IAVB9As2AsQBIAVBxA02ArwBIAVB6JyAATYCuAEgBSABNgI0IAUgBUErajYCwAEgBUHkAGogAhCZDiAFQfgAahCIESAFKQJkIQ8gACAFKQJsNwIMIAAgDzcCBCAAQYKAgIB4NgIADAQLIAUgARD9OzYCuAEgBUECNgJ8IAVB1JKAATYCeCAFQgI3AoQBIAVBOzYCbCAFQTs2AmQgBSAFQeAAajYCgAEgBSAFQbgBajYCaCAFIAVB0AFqNgJgDAULQaCVgAEQsjsACyAMRQ0AIAVBOGohCSAFQeAAakEEciEIIAVBvAFqIQtBACEDQQAhAgJAA0ACQAJAIAEgAhCHJUUEQCAFIAI2ArABIA0Q2DwgAk0NAiAFIAEoAhAgA2opAwAiETcDqAEgBSAQNwOwASAFQSxqAn4CQAJAIBBQRQRAIBBCf1IgEUKAgICAgICAgIB/UnINAiAFQQI2AnwgBUH0l4ABNgJ4IAVCAjcChAEgBUH9DzYC3AEgBUH9DzYC1AEgBSAFQdABajYCgAEgBSAFQbABajYC2AEgBSAFQagBajYC0AEgCyAFQfgAahCZDiAFQYiAgIB4NgK4ASAIIAUpArgBNwIAIAhBCGogBUHAAWopAgA3AgAgCEEQaiAFQcgBaigCADYCAAwBCyAFQYeAgIB4NgJkCyAFQQE2AmAgCBCIEUIADAELIBEgEH8iESAPIBFCAFkiBBshDyAErQsgDxDaCwwBCyAJEOY6IAUoAjhFDQMgBSgCSEEBaiIKQQN2IApBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAJIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAKNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCzKAsgBSgCMCAEQQN0akIANwMAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENkUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBoKKAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALvx8CE38BfiMAQZABayIHJABBuH8hBgJAIARBgIAISw0AAn8CQCAEQQJJDQACQAJAAkACQAJAAkAgAy0AACIKQQNxIg1BAWsOAwMBAAILIAAoAojqAQ0AQWIMBgsgBEEFSQ0EQQMhCyADKAAAIQYgACgCsOsBGkG6fyEJIAFBAQJ/AkACQAJAIApBAnZBA3EiCEECaw4CAQIACyAIQQBHIQwgBkEOdkH/B3EhCCAGQQR2Qf8HcQwCCyAGQRJ2IQhBASEMQQQhCyAGQQR2Qf//AHEMAQsgAy0ABEEKdCAGQRZ2ciEIQQUhC0EBIQwgBkEEdkH//w9xCyIKG0UNAiAKQYCACEsNBEFoIApBBkkgDHENBRogCCALaiIPIARLDQRBgIAIIAIgAkGAgAhPGyIGIApJDQIgACABIAIgCiAFIAZBABCYGgJAIAAoAqDrAUUgCkGBBklyDQBBACEGA0AgBkGDgAFLDQEgBkFAayEGDAALAAsCfyANQQNGBEAgAyALaiEFIAAoAgwhBiAAKAL06wEhCSAMRQRAIAkgCiAFIAggBhC/HwwCCyAJIAogBSAIIAYQqAQMAQsgAEGs1QFqIQ4gAyALaiEFIABBqNAAaiEGIAAoAvTrASEJIAxFBEACfyAGIAUgCCAOQYAUEIUEIgtBiH9LBEAgCwwBCyAIIAtLBH8gCSAKIAUgC2ogCCALayAGEL8fBUG4fwsLDAELAn9Bun8gCkUNABpBbCAIRQ0AGiAGIAUgCCAOQYAUEIUEIgtBiH9NBH9BuH8gCCALTQ0BGiAJIAogBSALaiAIIAtrIAYQqAQFIAsLCwsgACgC/OsBQQJGBEAgAEGA7AFqIAAoAvjrAUGAgARrQYCABPwKAAAgCkGAgARrIgYEQCAAKAL06wEiCUHg/wNqIAkgBvwKAAALIAAgACgC9OsBQeD/A2o2AvTrASAAIAAoAvjrAUEgazYC+OsBC0FsIQlBiH9LDQIgACAKNgKI6wEgAEEBNgKI6gEgACAAKAL06wE2AvjqASANQQJHDQMgACAAQajQAGo2AgwMAwtBAiEIAn8CQAJAAkAgCkECdkEDcUEBaw4DAQACAAtBASEIIApBA3YMAgsgAy8AAEEEdgwBCyAEQQJGDQRBAyEIIAMvAAAgAy0AAkEQdHJBBHYLIQZBun8hCSABRSAGQQBHcQ0BQYCACCACIAJBgIAITxsiCiAGSQ0BIAAgASACIAYgBSAKQQEQmBogBCAGIAhqIgVBIGpJBEBBbCEJIAQgBUkNAiADIAhqIQkgACgC9OsBIQgCQCAAKAL86wFBAkYEQCAGQYCABGsiCgRAIAggCSAK/AoAAAsgAEGA7AFqIAkgCmpBgIAE/AoAAAwBCyAGRQ0AIAggCSAG/AoAAAsgACAGNgKI6wEgACAAKAL06wE2AvjqASAFDAULIABBADYC/OsBIAAgBjYCiOsBIAAgAyAIaiIJNgL46gEgACAGIAlqNgL46wEgBQwECwJ/AkACQAJAIApBAnZBA3FBAWsOAwEAAgALIApBA3YhBkEBDAILIARBAkYNBCADLwAAQQR2IQZBAgwBCyAEQQRJDQMgAy8AACADLQACQRB0ckEEdiEGQQMLIQhBun8hCSABQQEgBhtFDQBBbCEJIAZBgIAISw0AQbp/IQkgAiAGSQ0AIAAgASACIAYgBUGAgAggAiACQYCACE8bQQEQmBogAyAIaiIKLQAAIQUgACgC9OsBIQkCQCAAKAL86wFBAkYEQCAGQYCABGsiCwRAIAkgBSAL/AsACyAAQYDsAWogCi0AAEGAgAT8CwAMAQsgBkUNACAJIAUgBvwLAAsgACAGNgKI6wEgACAAKAL06wE2AvjqASAIQQFqIQkLIAkMAgsgDwwBC0FsCyIGQYh/Sw0AIAIgACgC0OkBIgUgAiAFSRshCyAAKAK06QEhDAJ/IAdBPGohCCADIAZqIg8hA0G4fyEJAkAgBCAGayIRIgVFDQAgAy0AACIERQRAIAhBADYCAEEBQbh/IAVBAUYbDAILAn8gA0EBaiAEwCIGQQBODQAaIAZBf0YEQCAFQQNJDQIgAy8AAUGA/gFqIQQgA0EDagwBCyAFQQFGDQEgAy0AASAEQQh0ckGAgAJrIQQgA0ECagshCiAIIAQ2AgAgCkEBaiIGIAMgBWoiBUsNAEFsIQkgAEEQaiAAIAotAAAiCEEGdkEjQQkgBiAFIAZrQYC20QBBkLfRAEHAt9EAIAAoAozqASAAKAKg6wEgBCAAQazVAWoiChCGEiINQYh/Sw0AIABBmCBqIABBCGogCEEEdkEDcUEfQQggBiANaiIGIAUgBmtB0LvRAEHQvNEAQfC80QAgACgCjOoBIAAoAqDrASAEIAoQhhIiDUGIf0sNACAAQaAwaiAAQQRqIAhBAnZBA3FBNEEJIAYgDWoiBiAFIAZrQYC/0QBB4MDRAEGgwdEAIAAoAozqASAAKAKg6wEgBCAKEIYSIgRBiH9LDQAgBCAGaiADayEJCyAJCyIJQYh/SwRAIAkhBgwBC0EAIQMgBygCPCENIAFBAEcgAkEAR3FFBEBBun8hBiANQQBKDQELAkAgASALaiAMayIEQf3//x9JDQAgDQRAIARB/P//H0shAyAAKAIIIgRBCmohDiAEKAIEIQZBACEEQQAhBQNAIAUgBnZFBEAgBCAOLQAAIgggBCAISxshBCAOQQhqIQ4gBUEBaiEFDAELCyAEQRlLDQELQQAhAwsgESAJayEKIAkgD2ohCSAAQQA2AqDrAQJAAn8CQAJAAkAgACgC/OsBDgMBAgACCyAHIAAoAvjqASIINgJAIAEgAmohDyAAKAL46wEhDgJ/IA0EfyAAKAK46QEhESAAKAK06QEhEyAAKAKw6QEhBSAAQQE2AozqAUGs0AEhBANAIARBuNABRwRAIAQgB2pBrM8BayAAIARqKAIANgIAIARBBGohBAwBCwtBbCEGIAdB1ABqIgIgCSAKEN0TQYh/Sw0GIABBrNABaiEXIAdB6ABqIAIgACgCABDbLiAHQfAAaiACIAAoAggQ2y4gB0H4AGogAiAAKAIEENsuIAdByABqIAIgAxCICiABIQQCQANAIAggBygCSCIKaiISIAAoAvjrASICTQRAIAcoAkwhDCAHIAQgCmoiAiAHKAJQIhBrIgs2AkQgEkEgayEVAkACQAJAIA4gEkkNACAEIAogDGoiCWogFUsNACAJQSBqIA8gBGtNDQELIAdBOGogB0HQAGooAgA2AgAgByAHKQJINwMwAn8gB0FAayEWIAUhAkG6fyEJAkAgB0EwaiIIKAIEIgsgCCgCACIQaiIKIA8gBGtLDQBBbCAOIBYoAgAiEmsgEEkNARogCCgCCCEUIBAgEmoiGCAESyAEIBJLcQ0AIAQgEGoiDCAUayEIIAQgEiAQEP4YIBYgGDYCAAJAAkAgDCACayAUTwRAIAghAgwBC0FsIQkgFCAMIBNrSw0CIBEgESAIIAJrIglqIgggC2pPBEAgC0UNAiAMIAggC/wKAAAMAgtBACAJayIQBEAgDCAIIBD8CgAACyAJIAtqIQsgDCAJayEMCyAMIBUgAiALQQEQsRQLIAohCQsgCQshCQwBCyAIKQAAIRkgBEEIaiAIQQhqKQAANwAAIAQgGTcAACAKQRFPBEAgBEEQaiAIQRBqIApBEGtBABDRFQsgByASNgJAIAcgAjYCjAEgAiAFayAQSQRAIAIgE2sgEEkNCyARIBEgCyAFayIIaiIKIAxqTwRAIAxFDQIgAiAKIAz8CgAADAILQQAgCGsiCwRAIAIgCiAL/AoAAAsgByAFNgJEIAcgAiAIayICNgKMASAIIAxqIQwgBSELCyAQQRBPBEAgAiALIAxBABDRFQwBCyAHQYwBaiAHQcQAaiAQEMUZIAxBCUkNACAHKAKMASAHKAJEIAxBCGtBARDRFQsgCUGIf0sEQCAJIQYMCgsgBCAJaiEEIA1BAUYNAiAHQdQAaiICEP0YGiAHQcgAaiACIAMQiAogDUEBayENIAcoAkAhCAwBCwsgDUEATA0HIAIgCEcEQEG6fyEGIAIgCGsiAiAPIARrSw0IIAQgCCACEP4YIAcgCiACazYCSCACIARqIQQLIABBADYC/OsBIAdBKGogB0HQAGooAgA2AgAgByAAQYDsAWo2AkAgByAHKQJINwMgIAQgDyAHQSBqIAdBQGsgAEGA7AVqIg4gBSATIBEQhg0iBkGIf0sNByAEIAZqIQQgDUEBRg0AIAdB1ABqEP0YGkECIQIDQCAHQcgAaiAHQdQAaiIJIAMQiAogB0EYaiAHQdAAaigCADYCACAHIAcpAkg3AxAgBCAPIAdBEGogB0FAayAOIAUgEyAREIYNIgZBiX9PDQggBCAGaiEEIAIgDUYNASACQQFqIQIgCRD9GBoMAAsAC0FsIQYgB0HUAGoQ/RhBAkkNBkEAIQIDQCACQQxHBEAgAiAXaiACIAdqQYABaigCADYCACACQQRqIQIMAQsLIAcoAkAiCCAAKAL86wFBAkcNARogBAUgAQshAiAOIAhrIgMgDyACa0sNBEEAIQQgAgRAIAMEQCACIAggA/wKAAALIAIgA2ohBAsgAEEANgL86wEgAEGA7AVqIQ4gAEGA7AFqCyECIA4gAmsiACAPIARrSw0DIAQEfyAABEAgBCACIAD8CgAACyAAIARqBUEACyABayEGDAQLIAEgAmoMAQsgACgC9OsBCyEFIAcgACgC+OoBIgI2AowBIAIgACgCiOsBaiEIIAEhBCANBEAgACgCuOkBIQsgACgCtOkBIQwgACgCsOkBIQ4gAEEBNgKM6gFBrNABIQQDQCAEQbjQAUcEQCAEIAdqQazPAWsgACAEaigCADYCACAEQQRqIQQMAQsLQWwhBiAHQdQAaiICIAkgChDdE0GIf0sNAiAAQazQAWohCSAHQegAaiACIAAoAgAQ2y4gB0HwAGogAiAAKAIIENsuIAdB+ABqIAIgACgCBBDbLiANQQFrIQIgASEEA0AgB0HIAGogB0HUAGogAxCICiAHQQhqIAdB0ABqKAIANgIAIAcgBykCSDcDACAEIAUgByAHQYwBaiAIIA4gDCALEIYNIgBBiX9PBEAgACEGDAQLIAAgBGohBCACBEAgAkEBayECIAdB1ABqEP0YGgwBCwsgB0HUAGoQ/RhBAkkNAkEAIQIDQCACQQxHBEAgAiAJaiACIAdqQYABaigCADYCACACQQRqIQIMAQsLIAcoAowBIQILQbp/IQYgCCACayIAIAUgBGtLDQEgBAR/IAAEQCAEIAIgAPwKAAALIAAgBGoFQQALIAFrIQYMAQtBun8hBgsgB0GQAWokACAGC/kYBA5/CH4BfQF8IwBB4AFrIgMkAAJAAkAgAikDAEICUQRAQgghEwwBCyADQSBqIAJB2AD8CgAAIAMgAykDKEIAIAMoAiAbIhQ3A3gCQAJAAkACQAJAAkACQAJAAn8CQCAUQgBZBEAgAygCZEGAgICAeEcNASADKAJYQYCAgIB4Rw0BQSAhCUEsIQpBAQwCCyADQQE2AqwBIANB1IrOADYCqAEgA0IBNwK0ASADQe4GNgLEASADIANBwAFqNgKwASADIANB+ABqNgLAASAAQQxqIANBqAFqEJkOIABCCTcDACAAQQA2AgggA0FAaxCGMCADQcwAahCGMAwCC0EBIQ1BOCEJQcQAIQpBAAshDCADKQM4IRYgAykDMCEVIANBiAFqIAIgCmoiBUEIaigCADYCACADIAUpAgA3A4ABIANBmAFqIAIgCWoiBkEIaigCADYCACADIAYpAgA3A5ABQQQhAgJAAkACQAJAAkACQCABQf8BcSIKDgYEAgEAAgEDCyADQagBaiAFIAZBDBDvEiADKAKoASICQQhHDQQMBwtBCCECCyADQagBaiAFIAYgAhDvEiADKAKoASICQQhHDQILIBZCIIinIQkgFqchASAVpyECAkACQAJAAkACQAJAIApBAmsOBgAKAQIDBAULIwBBEGsiBCQAAkACQCADQagBaiILIAUoAgBBgICAgHhHBH4gBEEIaiAFQQhqKAIAIgc2AgAgBCAFKQIANwMAIAdBB00NASAEKAIEKQAAIREgBBDeOyALIBE3AwhCAQVCAAs3AwAgBEEQaiQADAELQQggB0Hwi84AELA7AAsgAykDsAEhFiADKQOoASEVIwBBEGsiBCQAAkACQCALIAYoAgBBgICAgHhHBH4gBEEIaiAGQQhqKAIAIgc2AgAgBCAGKQIANwMAIAdBB00NASAEKAIEKQAAIREgBBDeOyALIBE3AwhCAQVCAAs3AwAgBEEQaiQADAELQQggB0GAjM4AELA7AAsgAykDsAEhESAVpyEGIAMpA6gBIhKnIQVCAiETDAgLIANBGGohAiMAQRBrIgQkAAJAAkAgBSgCAEGAgICAeEYEf0EABSAEQQhqIAVBCGooAgAiATYCACAEIAUpAgA3AwAgAUEDTQ0BIAQoAgQqAAAhGSAEEN47QQELIQEgAiAZOAIEIAIgATYCACAEQRBqJAAMAQtBBCABQZCMzgAQsDsACyADKAIcIQogAygCGCECIANBEGohBEMAAAAAIRkjAEEQayIIJAACQAJAIAYoAgBBgICAgHhGBH9BAAUgCEEIaiAGQQhqKAIAIgE2AgAgCCAGKQIANwMAIAFBA00NASAIKAIEKgAAIRkgCBDeO0EBCyEBIAQgGTgCBCAEIAE2AgAgCEEQaiQADAELQQQgAUGgjM4AELA7AAsgAygCECIBQf8Bca0gAkEIdEGA/gNxrUKAgIQIQgAgDBuEhCEXQgQhE0IBIRIgAygCFCEJIBQhEQwLCyMAQRBrIgQkAAJAAkAgA0GoAWoiCyAFKAIAQYCAgIB4RwR+IARBCGogBUEIaigCACIHNgIAIAQgBSkCADcDACAHQQdNDQEgBCgCBCsAACEaIAQQ3jsgCyAaOQMIQgEFQgALNwMAIARBEGokAAwBC0EIIAdBsIzOABCwOwALIAMpA7ABIRYgAykDqAEhFSMAQRBrIgQkAAJAAkAgCyAGKAIAQYCAgIB4RwR+IARBCGogBkEIaigCACIHNgIAIAQgBikCADcDACAHQQdNDQEgBCgCBCsAACEaIAQQ3jsgCyAaOQMIQgEFQgALNwMAIARBEGokAAwBC0EIIAdBwIzOABCwOwALIAMpA7ABIREgFachBiADKQOoASISpyEFQgUhEwwGC0EAIQIgAygCgAEiAUGAgICAeEcEQCADIAMpAoQBNwKsASADIAE2AqgBIANBxAFqIANBqAFqEOcVQQEhAgsgAygCkAEiAUGAgICAeEcEQCADIAMpApQBNwLYASADIAE2AtQBIANBrAFqIANB1AFqEOcVQQEhCCADKAK4ASEOIAMtALUBIQYgAykCrAEhGCADLQC3ASELIAMtALQBIQUgAy0AtgEhBwsgAy0AcUEBcSEPIAMtAHBBAXEhECADKALQASIErSISQoCAgPgPgyERIAMoAswBIQkgAygCyAEhASADKALEASEKQgYhEwwHCyADKAKAASICQYCAgIB4RgR/QQAFIAMgAykChAE3AsQBIAMgAjYCwAEgA0GsAWogA0HAAWoQ5xUgAzUCuAEhEiADKAK0ASEJIAMoArABIQEgAygCrAEhCkEBCyECIAMoApABIgVBgICAgHhHBEAgAyADKQKUATcCxAEgAyAFNgLAASADQawBaiADQcABahDnFUEBIQggAygCuAEhDiADLQC1ASEGIAMpAqwBIRggAy0AtwEhCyADLQC0ASEFIAMtALYBIQcLIBJCgICA+A+DIREgAy0AcUEBcSEPIAMtAHBBAXEhECASpyEEQgchEwwGCyADQQhqIQIjAEEQayIIJAACQAJAIAUoAgBBgICAgHhGBH9BAAUgCEEIaiAFQQhqKAIAIgE2AgAgCCAFKQIANwMAIAFBA00NASAIKAIEKAAAIQQgCBDeO0EBCyEBIAIgBDYCBCACIAE2AgAgCEEQaiQADAELQQQgAUHQi84AELA7AAsgAygCDCEKIAMoAgghAkEAIQQjAEEQayIIJAACQAJAIAYoAgBBgICAgHhGBH9BAAUgCEEIaiAGQQhqKAIAIgE2AgAgCCAGKQIANwMAIAFBA00NASAIKAIEKAAAIQQgCBDeO0EBCyEBIAMgBDYCBCADIAE2AgAgCEEQaiQADAELQQQgAUHgi84AELA7AAsgAygCACIBQf8Bca0gAkEIdEGA/gNxrUKAgIQIQgAgDBuEhCEXQgEhEiADKAIEIQkgFCERQgEhEwwHCyADQagBaiAFIAZBARDvEiADKAKoASICQQhGDQULIAAgAykCrAE3AgwgAEEcaiADQbwBaigCADYCACAAQRRqIANBtAFqKQIANwIAIABCCTcDACAAIAI2AgggAygCkAFBgICAgHhHBEAgA0GQAWoQ3jsLIAMoAoABQYCAgIB4RwRAIANBgAFqEN47CyANBEAgA0FAaxCGMCADQcwAahCGMAsgDEUNCQsgA0HYAGoQhjAgA0HkAGoQhjAMCAtCASEXQQAhCiAUIRggDCIHIQsMAwtBACECAkACQCADKAKAAUGAgICAeEcEQCADQcgBaiAFQQhqKAIAIgE2AgAgAyAFKQIANwPAASADIAE2AqABIAFBDEcNASADKALEASICKAAIIQkgAigABCEBIAIoAAAhCiADQcABahDeO0EBIQILIAMoApABQYCAgIB4RgR/QQAFIANByAFqIAZBCGooAgAiBzYCACADIAYpAgA3A8ABIAMgBzYCpAEgB0EMRw0CIAMoAsQBIgcpAAQhGCAHKAAAIQggA0HAAWoQ3jtBAQshBEIDIRMgDCELIAwhByACIQYgBCEFDAILIANBADYCqAFBACADQaABakGMis4AIANBqAFqQZCKzgAQrysACyADQQA2AqgBQQAgA0GkAWpBjIrOACADQagBakGgis4AEK8rAAsgBK1C/wGDIBJCgP7/B4MgCK1CIIYgEYSEhCEXQgEhEiAUIREMAQtBAiEBQQIhCSADKAKAASICQYCAgIB4RwRAIAMgAykChAEiETcCrAEgAyACNgKoASARQv////8PWA0CIBGnLQAAQQBHIQkgA0GoAWoQ3jsLIAMoApABIgJBgICAgHhHBEAgAyADKQKUASIRNwKsASADIAI2AqgBIBFC/////w9YDQMgEactAABBAEchASADQagBahDeOwsgCUECR0EIdEGAgIQIQQAgDBtyIAFBAkdyIQIgAUEIdCAJciEKQgEhEiAUIRELIA0EQCADQUBrEIYwIANBzABqEIYwCyAMRQ0CIANB2ABqEIYwIANB5ABqEIYwDAILQQBBAEGwi84AEMMhAAtBAEEAQcCLzgAQwyEACyAAIAw6AFMgACAMOgBSIAAgDzoAUSAAIBA6AFAgACAONgJMIAAgCzoASyAAIAc6AEogACAGOgBJIAAgBToASCAAIBg3A0AgACAXNwM4IAAgCTYCNCAAIAE2AjAgACAKNgIsIAAgAjYCKCAAIBE3AyAgACASNwMYIAAgFjcDECAAIBU3AwggACATNwMACyADQeABaiQAC8IQAgp/AX4jAEGgAWsiAyQAIAIoAgwiDARAIAAgAhD9CiELCyAAIAIoAjggAigCPBC0CyEIIANB+ABqIAJBKGogASAAEJ8BAkACQCACLQAoQSJGBEAgASgCACIBBEAgAigCLCABQSBqIQQgASgCJCEGAkAgASgCKCIFRQ0AIAYgBUEDdGpBCGsiCUUNACAJKQMAQgF8IQ0LIAQoAgAgBUYEfyAEQczP/gAQsyggASgCJAUgBgsgBUEDdGogDTcDACABIAVBAWo2AiggAEEBOgA4IAAoAjAhBSACLQBBIQktAAAiAUECa0H/AXEiBEEHTQRAIABBBkEPIAR2QQFxEK4RIABBBCABwEECdEH8xf4AaigCAEEAEMoOCyAAQTBqIQEgACAFENgHIQcgAEEBOgA4IABBADYCFCAAKAIwIQUCfyANUARAIAUgAC0AOkEBRw0BGgsgAEEIIAAoAjQiBCAEQQhNGzYCNAJAQQAgBWtBB3EiBCAAKAIIIAVrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgASAEEI03IAAoAgggACgCMGtBB0siBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwa0EISQ0ACwsgAUEIEI03IANB8ABqIAAQ3DsgAygCdCEEIAMoAnAhBiADQegAaiAAKAIwEIw3IANB4ABqIAYgBCADKAJoIAMoAmxBsLf+ABDXJiADKAJkQQdNDQQgAygCYCANNwAAIAAoAjAhBiAAKAIUIgQgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgBEEDdGoiCkEEOwEEIAogBjYCACAAIARBAWo2AhQgACgCMAshBiAAQQQgACgCNCIEIARBBE0bNgI0AkBBACAGa0EDcSIEIAAoAgggBmtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyABIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyABQQQQjTcgA0HYAGogABDcOyADKAJcIQQgAygCWCEGIANB0ABqIAAoAjAQjDcgA0HIAGogBiAEIAMoAlAgAygCVEGwt/4AENcmIAMoAkwiBEEDTQ0DIAMoAkggBCAHazYAACAAQQxqIQQgACgCMCEHIAAoAhQiBiAAKAIMRgRAIARBuLb+ABCbKAsgACgCECAGQQN0aiIKQQY7AQQgCiAHNgIAIAAgBkEBajYCFCAAQQggCUEBcRCuESAAIAUQ2AchByAAQQE6ADggAEEANgIUIAAoAjAhBiAAQQQgCBD8DiAAQQQgACgCNCIFIAVBBE0bNgI0AkBBACAAKAIwIghrQQNxIgUgACgCCCAIa00NACAAKAIIIAAoAjBrIAVPDQADQCAAEPsWIAAoAgggACgCMGsgBUkNAAsLIAEgBRCNNyAAKAIIIAAoAjBrQQNLIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAFBBBCNNyADQUBrIAAQ3DsgAygCRCEBIAMoAkAhBSADQThqIAAoAjAQjDcgA0EwaiAFIAEgAygCOCADKAI8QbC3/gAQ1yYgAygCNCIBQQNNDQMgAygCMCABIAdrNgAAIAAoAjAhBSAAKAIUIgEgACgCDEYEQCAEQbi2/gAQmygLIAAoAhAgAUEDdGoiBEEMOwEEIAQgBTYCACAAIAFBAWo2AhQMAgsgA0EANgKYASADQQE2AowBIANB/MT+ADYCiAEgA0IENwKQASADQYgBakGExf4AEO8sAAsgAEEBOgA4IAAoAjAhBiAAQQQgCBD8DgsCQCADLQCEASIBRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiBSAFQQFNGzYCNCAAKAIIGiAAQTBqIgVBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIAVBARCNNyADQShqIAAQ3DsgAygCLCEFIAMoAighBCADQSBqIAAoAjAQjDcgA0EYaiAEIAUgAygCICADKAIkQbC3/gAQ1yYgAygCHEUNASADKAIYIAE6AAAgACgCMCEFIAAoAhQiASAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECABQQN0aiIEQQg7AQQgBCAFNgIAIAAgAUEBajYCFAsgAEEGIAItAEAQrhEgAygCeEEBRgRAIABBDiADKAJ8EPwOCyAAQQQgACgCNCIBIAFBBE0bNgI0IAMoAoABIQUgAEEwaiECAkBBACAAKAIwIgRrQQNxIgEgACgCCCAEa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAIgARCNNyAAKAIIIAAoAjBrQQNLIgEgAXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAJBBBCNNyADQRBqIAAQ3DsgAygCFCEBIAMoAhAhAiADQQhqIAAoAjAQjDcgAyACIAEgAygCCCADKAIMQbC3/gAQ1yYgAygCBCIBQQNNDQAgAygCACABIAVrNgAAIAAoAjAhAiAAKAIUIgEgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgAUEDdGoiBUEKOwEEIAUgAjYCACAAIAFBAWo2AhQgDARAIABBECALEPwOCyAAIAYQ2AcgAEEANgIUIABBADoAOCADQaABaiQADwsgA0EANgKYASADQQE2AowBIANB7Lf+ADYCiAEgA0IENwKQASADQYgBakHAt/4AEO8sAAvWDwEHfiAAKQMIIgMgAUEAR62FIgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAFQtii0e/CqeW/LX6FIQMgACkDACEFAkAgAUUNACAAKQMYIQcgACkDECEGIAMgAq0iCIUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUgCHxCrf7V5NSF/ajYAH4hCCACQQhNBEACfiACQQFNBEBCACEEQgAgAkEBRw0BGiABMQAAIgQMAQsgASACaiEAIAJBA00EQCABMwAAIQQgAEEBazEAAAwBCyABNQAAIQQgAEEEazUAAAshAyAFIAh8IAQgBoUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhCADIAeFIgZCf4V+IgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhISFIAZCOIYgBkKA/gODQiiGhCAGQoCA/AeDQhiGIAZCgICA+A+DQgiGhIQgB0IIiEKAgID4D4MgB0IYiEKAgPwHg4QgB0IoiEKA/gODIAdCOIiEhIQgBH6FQheJIQMMAQsgAkEQTQRAIAUgCHwgASkAACAGhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAEgAmpBCGspAAAgB4UiB0J/hX4iBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAGQgiIQoCAgPgPgyAGQhiIQoCA/AeDhCAGQiiIQoD+A4MgBkI4iISEhIUgB0I4hiAHQoD+A4NCKIaEIAdCgID8B4NCGIYgB0KAgID4D4NCCIaEhCAHQgiIQoCAgPgPgyAHQhiIQoCA/AeDhCAHQiiIQoD+A4MgB0I4iISEhCADfoVCF4khAwwBCyAFIAh8IAYgASACakEQayIAKQAAhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAcgACkACIUiBEJ/hX4iCEI4hiAIQoD+A4NCKIaEIAhCgID8B4NCGIYgCEKAgID4D4NCCIaEhCAIQgiIQoCAgPgPgyAIQhiIQoCA/AeDhCAIQiiIQoD+A4MgCEI4iISEhIUgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCADfoVCF4khAyAHQn+FIQgDQCADIAV8IAYgASkAAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABKQAIIgkgCIV+IgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhISFIAMgByAJhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEfoVCF4khAyABQRBqIQEgAkEQayICQRBLDQALCyADIAVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIR+IANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgBUJ/hX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgA4kL3g4BHX8jAEEQayISJABBBiAAKALEASIIIAhBBk8bIQlBBiAAKALIASIIIAhBBk8bIQ0gACgCBCIRIAAoAgwiEGohFSAHQQJJIgxFBEAgACgCtAEiCCgCBCIWIAgoAgxqIR4gCCgCACETCyADIARqIQ4gCUEESyEXIA1BBEshFCACKAIEIQggAigCACEKIAMgAyAVayAeIBNrRmohBAJ/IAcEQCAIIQsgCiEPQQAMAQtBACAKIAogBCARayILIBAgC0EBIAAoArgBdCIPayAQIAsgEGsgD0sbIAAoAhgbayILSyIYGyEPIApBACAYGyEcQQAgCCAIIAtLIgobIQsgCEEAIAobCyEhIA5BEGshHyAJQQQgFxshGCANQQQgFBshGSAAQQA2AtwBIAVBAkciIkUEQCAAIBEgGSAAKAIcIB8QoBoLIB8gDkEIayAFQQJGGyEaIBZBACAWIBNrIBBqIh0gDBtrISMgFiAdayEkIAdBAkkhGwNAIA8gEWohIEEAIA9rIRQCfwJAAkACQANAIAQgGk8NASAEQQFqIQgCQCAbRQRAQQAhCiAEICBrQQFqIgkgEGtBfEsNASAWIAkgHWtqIAkgEWogCSAQSSIJGyINKAAAIAgoAABHDQEgBEEFaiANQQRqIA4gEyAOIAkbIBUQzShBBGohCiAGDQEMBAtBACEKIAcgD0VyDQAgCCAUaigAACAIKAAARw0AIARBBWoiCiAKIBRqIA4QgBRBBGohCiAGRQ0DCyASQf+T69wDNgIMIAAgBCAOIBJBDGogGSAYIAUgBxC3BiIJIAogCSAKSyIJGyIKQQNNBEAgACAEIANrIghB/w9LNgLcASAEIAhBCHZqQQFqIQQMAQsLIAQgCCAJGyEIIBIoAgxBASAJGyENAkAgBkUNAANAIAQgGk8NASAEQQFqIQkCQCAHIA1FckUEQCAPRQ0BIAkoAAAgCSAUaigAAEcNASAEQQVqIgwgDCAUaiAOEIAUIgxBe0sNASANZyAKQQNsakEeayAMQQRqIgxBA2xODQFBASENIAkhCCAMIQoMAQsgGw0AIAkgIGsiDCAQa0F8Sw0AIBYgDCAda2ogDCARaiAMIBBJIgwbIhcoAAAgCSgAAEcNACAEQQVqIBdBBGogDiATIA4gDBsgFRDNKCIMQXtLDQAgDWcgCkEDbGpBHmsgDEEEaiIMQQNsTg0AQQEhDSAJIQggDCEKCyASQf+T69wDNgIIAkAgACAJIA4gEkEIaiAZIBggBSAHELcGIgxBBEkNACASKAIIIhdnIAxBAnRqQR9rIA1nIApBAnRqQRtrTA0AIBchDSAMIQogCSIIIQQMAQsgBkECRyAJIBpPcg0BIARBAmohCQJAIAcgDUVyRQRAIA9FDQEgCSgAACAJIBRqKAAARw0BIARBBmoiBCAEIBRqIA4QgBQiBEF7Sw0BIA1nIApBAnRqQR5rIARBBGoiBEECdE4NAUEBIQ0gCSEIIAQhCgwBCyAbDQAgCSAgayIMIBBrQXxLDQAgFiAMIB1raiAMIBFqIAwgEEkiDBsiFygAACAJKAAARw0AIARBBmogF0EEaiAOIBMgDiAMGyAVEM0oIgRBe0sNACANZyAKQQJ0akEeayAEQQRqIgRBAnRODQBBASENIAkhCCAEIQoLIBJB/5Pr3AM2AgQgACAJIA4gEkEEaiAZIBggBSAHELcGIgRBBEkNASASKAIEIgxnIARBAnRqQR9rIA1nIApBAnRqQRhrTA0BIAwhDSAEIQogCSIIIQQMAAsACyANQQRJDQICQCAHDQBBACANayELA0AgAyAITw0BIAggC2oiCUEDaiAVTQ0BIAhBAWsiBC0AACAJQQJqLQAARw0BIApBAWohCiAEIQgMAAsACwJAIBsNACAkIBEgCCANIBFqa0EDaiIEIBBJIgsbIARqIQQgHiAVIAsbIQkDQCAEIAlNIAMgCE9yDQEgCEEBayILLQAAIARBAWsiBC0AAEcNASAKQQFqIQogCyEIDAALAAsgDyELIA1BA2sMAwsgAiAPIBwgDxs2AgAgAiALIBwgISAPGyAhIBwbIAsbNgIEIBJBEGokACAOIANrDwtBASENCyAPCyEEIAEgCCADayADIA4gDSAKEIUSIAAoAtwBBEAgIkUEQCAAIBEgGSAAKAIcIB8QoBoLIABBADYC3AELIAggCmohAyAbRQRAA0ACQCALIQggAyAaSw0AIAMgCCARamsiCyAQa0F8Sw0AIAsgIyARIAsgEEkiCxtqIgooAAAgAygAAEcNACABQQAgAyAOQQEgA0EEaiAKQQRqIA4gEyAOIAsbIBUQzShBBGoiCxCFEiADIAtqIQMgBCELIAghBAwBCwsgCCELCyAEIQ8gAyEEIAcNAANAAkAgCyIERSADIBpLcg0AIAMoAAAgAyAEaygAAEcNACABQQAgAyAOQQEgA0EEaiIIIAggBGsgDhCAFEEEaiIIEIUSIAMgCGohAyAPIQsgBCEPDAELCyADIQQMAAsAC5oQAhJ/BX4jAEFAaiICJAAgAkEAOgAQIAJCADcDACACQoGAgIAQNwMIA0AgASACaiIDKAIAIQUgAyAAIAFqQTBqIgMoAgA2AgAgAyAFNgIAIAFBBGoiAUEYRw0AC0EAIQEgAkEANgIkIAJCATcCHANAIAJBHGogAWoiAygCACEFIAMgACABakHIAGoiAygCADYCACADIAU2AgAgAUEEaiIBQQxHDQALQcz/+wAhCkGABCEJAkACQAJAAkAgAC0AmAFBAWsOAwABAgMLIABBpAFqIQpBtAohCQwCCyAAQfQqaiEKQbQKIQkMAQsgAEHE1ABqIQpB0AQhCQtBzI/8ACEMQSAhCwJAAkACQAJAIAAtAKABQQFrDgMAAQIDCyAAQaQBaiEMQbQKIQsMAgsgAEH0KmohDEG0CiELDAELIABBxNQAaiEMQdAEIQsLIAAoAgwiA0FAaiIBQUFJBEAgAEEwaiENIABByABqIQ9CfyAANQKcAYZCfyAANQKUAYYhFSABIANLIQcCQCACLQAQIgRBCk8EQCACKQMAIRQgAigCCCEDDAELIAIgBEE4ciIFOgAQIAIgAigCCCIGIARBA3ZBB3NqIgM2AgggAiACKQMAIAYpAAAgBK2GhCIUNwMAIAUhBAsgAEEIaiEQQn+FIRcgFUJ/hSEVQQAgASAHGyEOIAIoAgwhEgJAA0ACQCACIAMgBEH/AXEiAUEDdkEHc2oiBTYCCCADKQAAIASthiAUhCETAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABIAAoApQBSQRAIAkgEyAVg6ciAUsNASABIAlBoJT8ABDDIQALIAkgFCAVg6ciAU0NAQsgBEE4ciEEIAogAUECdGoiAy8BACEGIAMtAAMhCAJAAkACQCADLQACIgENACACKAIkIgMgAigCICIBTw0EIAIoAhwgA2ogBjoAACACIANBAWoiBzYCJCAJIBMgCK2IIhMgFYOnIgFNDQUgBCAIayEEIAogAUECdGoiAS8BACEGIAEtAAMhCCABLQACIgENACAHIAIoAiAiAU8NBiACKAIcIAdqIAY6AAAgAiADQQJqIgM2AiQgCSATIAitiCITIBWDpyIBSw0BIAEgCUHQlPwAEMMhAAsgBCAIayEEIBMgCK2IIRQMAQsgBCAIIAogAUECdGoiAS0AAyIHamshBCATIAdBP3GtiCEUIAEvAQAhBiABLQACIgFFDQwLAkACQANAIAFBEHENASABQcAAcQ0CIAYgFEJ/IAGtQi+DhkJ/hYOnakH//wNxIgMgCUkEQCAEIAogA0ECdGoiAy0AAyIBayEEIBQgAUE/ca2IIRQgAy8BACEGIAMtAAIiAUUNDgwBCwsgAyAJQeCU/AAQwyEACyACIAQgAUEPcWsiBDoAECACIBQgAa1CD4MiFogiEzcDACALIBMgF4OnIgNLDQUgAyALQfCU/AAQwyEAC0EAQdOzwgAgAUEgcSIDGyEBQQxBHiADGyEJQRwhBiAFIQMMBQsgASAJQbCU/AAQwyEACyADIAFBtPH8ABDDIQALIAEgCUHAlPwAEMMhAAsgByABQbTx/AAQwyEACyAMIANBAnRqIggtAAMhESAILQACIQECfyAEQf8BcUEcTwRAIAUhAyAEDAELIAIgBSAEQfgBcUEDdkEHc2oiAzYCCCAFKQAAIASthiAThCETIARBOHILIAgvAQAhCCARayEEIBMgEa2IIRMgAUEQcUUEQANAIAFBwABxBEBB77PCACEBQRYhBkEeIQkgEyEUDAMLIAsgCCATQn8gAa1CL4OGQn+Fg6dqQf//A3EiBU0NAyAEIAwgBUECdGoiBS0AAyIBayEEIBMgAUE/ca2IIRMgBS8BACEIIAUtAAIiAUEQcUUNAAsLIAYgFEJ/IBaGQn+Fg6dqIQYgAiAEIAFBD3FrIgQ6ABAgAiATIAGtQg+DIhaIIhQ3AwAgCCATQn8gFoZCf4WDp2pB//8DcSIIIAIoAiQiBU0EQCACQRxqIAggBkH//wNxEIcNDAgLAkAgCCAFayIBIAAoAhBNBEAgACgCFCIFDQEgDiABayEHDAYLIAAtAAFBBHFFDQNB3bLCACEBQR4hCUEeIQYMAQsgASAFSw0DIAUgAWshBwwECyAAIAk6AAAMBwsgBSALQYCV/AAQwyEACyACQQA2AjggAkEBNgIsIAJB2JH8ADYCKCACQgQ3AjAgAkEoakGQlfwAEO8sAAsgDiABIAVrIgFrIQcgASAGQf//A3FPDQAgAkEcaiAQIAcgDhDUEiAGIAFrIQZBACEHIAUhAQsgAkEcaiIFIBAgByAGQf//A3EiBiABIAEgBksbIAdqENQSIAEgBk8NAiAFIAggBiABaxCHDQwCCyACKAIkIQMLIAIgBDoAECACIBQ3AwAgAyACKAIgIgFPDQMgAigCHCADaiAGOgAAIAIgA0EBajYCJCAFIQMLQQAhASASIANrIARB+AFxQQN2akEOTQ0AIAIoAiAgAigCJGtBgwJLDQELCyACQRBqIgUgBEEHcToAACACQQhqIgcgAyAEQfgBcUEDdms2AgAgDyACKQIcNwIAIA9BCGogAkEkaigCADYCACANQRBqIAUpAwA3AwAgDSAUQn8gBK1CB4OGQn+FgyITNwMAIA1BCGogBykDADcDACACIBM3AwAgAQRAIAAgBjYCiAEgACABNgKEAQsgAkFAayQADwsgAyABQbTx/AAQwyEAC0H47/wAQcoAQcTw/AAQnykAC9rXAwIQfwZ+IwBB0ABrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkUEQCASQThqQS9BAEEBQQEQoBggEigCPCEBIBIoAjhBAUYNASASKAJAIgJBkM6DAUEv/AoAACAAQS82AgwgACACNgIIIAAgATYCBCAAQY2AgIB4NgIADAMLIBIgASgCACABKAIEKAIcEQQAIhA2AhAgASACQQN0aiEIQQEhBiABIQUDQAJ/IAcEQCAFIAUgCEcNARoMBAsgBiAIIAVrQQN2Tw0DIAUgBkEDdGoLIgpBCGohBUEAIQZBASEHIAooAgAiCSAKKAIEKAIcIgoRBAAgEBC9CA0ACyASIAkgChEEADYCICASQQM2AjwgEkH4zYMBNgI4IBJCAjcCRCASQacENgIwIBJBpwQ2AiggEiASQSRqNgJAIBIgEkEgajYCLCASIBJBEGo2AiQgEkEUaiASQThqEJkOIABBjYCAgHg2AgAgACASKQIUNwIEIABBDGogEkEcaigCADYCAAwCCyABIBIoAkBB2MuDARD9LwALAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBARAIBAtAABBAmsOJQECAwQFBgcICQoLGRobHB0MDR43HyAhIiM3Nzc3NyQ3JQ4PEBE3CyASQQhqIBAQlCkgACASKQMINwIEIABBk4CAgHg2AgAMNwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNQyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1JIAIpAxBC8vypnuWPoZ0rhSACKQMYQtmLjbqZvu3vr3+FhFBFDUkgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiBzYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgIoAgQgAigCAGtBA3ZBAEEBQQEQoBggASgCGCEDIAEoAhRBAUYNRCABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiBCACKAIEIAIoAgBrQQN2EIEuIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgAiADQQRqEMASIANBEGokACAFQSxqIgNBCGogBigCADYCACADIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgAxDuGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgMgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIEIAEgAhDYHSABIBAQzQYgARCaHiADIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBBC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHQ3YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBBEEEEOAeIAVB0AFqJAAMAQsMOAsMNgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNQiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1IIAIpAxBCmcTpt9SjhcVuhSACKQMYQpiWydPQ9J6WrX+FhFBFDUggCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCcGyAFQbwBaiIBIAQQ6RggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ2h0gASAQEM0GIAEQmR4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+NGDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDcLDDULQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDUEgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRyACKQMQQqSv9PqoqZ2QLYUgAikDGELjrPqF49vQ9WyFhFBFDUcgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQvx0gASAQEM0GIAEQkh4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBmM+DATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDYLDDQLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDUAgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRiACKQMQQo2j65PMtMaQ9wCFIAIpAxhC2avs9tngxfSMf4WEUEUNRiALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDWHSABIBAQzQYgARCVHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGY2oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMNQsMMwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1FIAIpAxBC+/bY6vDijZ/GAIUgAikDGEKZhqW/+K+hjtIAhYRQRQ1FIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgc2AnAjAEEgayIBJAAgAUEUaiAFQegAaiICKAIEIAIoAgBrQQN2QQBBAUEBEKAYIAEoAhghAyABKAIUQQFGDUAgAUEQaiIGQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgMkACABQQhqIgQgAigCBCACKAIAa0EDdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAIgA0EEahDAEiADQRBqJAAgBUEsaiIDQQhqIAYoAgA2AgAgAyABKQIINwIAIAFBIGokACAFQbwBaiIBIAMQ7hggBUH4AGogBUEkaikCADcDACAFQfAAaiIDIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiBCABIAIQwR0gASAQEM0GIAEQmx4gAyAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAQQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBiNaDATYCCCAAIAE2AgQgAEGTgICAeDYCACAHQQRBBBDgHiAFQdABaiQADAELDDQLDDILQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDT4gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNRCACKQMQQsmQrefTvtn4nH+FIAIpAxhC8fLKq+fn0cbCAIWEUEUNRCALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEJwbIAVBvAFqIgEgBBDpGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDNHSABIBAQzQYgARCWHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGg0YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMMwsMMQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1DIAIpAxBC0fH3zJy66f5OhSACKQMYQtbCj5mYvPKj8QCFhFBFDUMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiBzYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYNPiABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiBCACKAIEIAIoAgBrQQN2EIUuIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgAiADQQRqEPURIANBEGokACAFQSxqIgNBCGogBigCADYCACADIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgAxDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgMgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIEIAEgAhDHHSABIBAQzQYgARCPHiADIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBBC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHY34MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAdBBEEEEOAeIAVB0AFqJAAMAQsMMgsMMAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNPCABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1CIAIpAxBC3KeGzZSXyb2Wf4UgAikDGEKF8OaFkNqf4wyFhFBFDUIgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQ5xggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ2R0gASAQEM0GIAEQkR4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+NyDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDDELDC8LQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDTsgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNQSACKQMQQofA7OjEzr/RyQCFIAIpAxhCvr+ev6/DpIL4AIWEUEUNQSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEJwbIAVBvAFqIgEgBBDpGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDPHSABIBAQzQYgARCYHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHA2YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMMAsMLgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNOiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ1AIAIpAxBCzLSi/ZWEi6FkhSACKQMYQv6Kjfy6sNua3ACFhFBFDUAgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYNOyAFQSxqIQggAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDuLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCigCBCEGIAooAgAhEQJAAkAgBCgCACIDIAQoAgQiCUcEQCAKKAIIIAZBAnRqIQogCSADa0EDdiEMIAQoAgghCwNAIAMoAgAiCSALKAIIIg9PDUIgCygCBCAJQQJ0aigCACEJIAIgA0EEaigCACIPNgIAIAlBDGoQ2zwgD00NAiAKIAkoAhAgD0ECdGoqAgA4AgAgA0EIaiEDIApBBGohCiAGQQFqIQYgDEEBayIMDQALCyARIAY2AgAgAkEwaiQADAELIAIgCRD8OzYCHAxCCyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCCDcCACABQSBqJAAgBUG8AWoiASAIEOgYIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEEL4dIAEgEBDNBiABEJMeIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQbDggwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwvCwwtC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg05IAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDT8gAikDEELut8rBy8Ln6Ll/hSACKQMYQvCO45ubiNaLEYWEUEUNPyALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIONgJwIwBBIGsiASQAIAFBFGogBUHoAGoiBCgCBCAEKAIAa0EDdkEAQQhBCBCgGCABKAIYIQMgASgCFEEBRg06IAVBLGohCCABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAiAEKAIEIAQoAgBrQQN2EOwtIAcgAikCBEIgiTcCCCAHIAJBCGo2AgQjAEEwayICJAAgB0EEaiIKKAIEIQYgCigCACERAkAgBCgCACIDIAQoAgQiCUcEQCAKKAIIIAZBA3RqIQogCSADa0EDdiEMIAQoAgghCwNAIAMoAgAiCSALKAIIIg9PDUAgCygCBCAJQQJ0aigCACEJIAIgA0EEaigCACIPNgIAIAlBDGoQ2DwgD00NQSAKIAkoAhAgD0EDdGorAwA5AwAgA0EIaiEDIApBCGohCiAGQQFqIQYgDEEBayIMDQALCyARIAY2AgAgAkEwaiQADAALIAdBEGokACAIQQhqIA0oAgA2AgAgCCABKQIINwIAIAFBIGokACAFQbwBaiIBIAgQ5xggBUH4AGogBUEkaikCADcDACAFQfAAaiICIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiAyABIAQQ2x0gASAQEM0GIAEQkB4gAiAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAMQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB4NaDATYCCCAAIAE2AgQgAEGTgICAeDYCACAOQQRBBBDgHiAFQdABaiQADAELDC4LDCwLIBAtAAFBAWsOAwYHCAULIBAtAAFBAWsOAgkKCAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNNiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ08IAIpAxBCn8K+osy/yKAhhSACKQMYQtbFlMaY/fXY+ACFhFBFDTwgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQyh0gASAQEM0GIAEQ0BggBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB6NiDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDCsLDCkLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDTUgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNOyACKQMQQrXD/r6MnKqmwwCFIAIpAxhCkvvHkL7smP6jf4WEUEUNOyALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDGHSABIBAQzQYgARDSGCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHY1IMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMKgsMKAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNNCABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ06IAIpAxBCh/nb2tfR/Jg8hSACKQMYQrbv6LX0pYK+ln+FhFBFDTogCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEQQRAQoBggASgCGCEDIAEoAhRBAUYNNSAFQSxqIQogAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDrLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCCgCBCEGIAgoAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCCgCCCAGQQR0aiEIIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw07IAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENo8IA9NDT0gCSgCECAPQQR0aiIJKQMAIRUgCCAJKQMINwMIIAggFTcDACADQQhqIQMgCEEQaiEIIAZBAWohBiAMQQFrIgwNAAsLIBEgBjYCACACQTBqJAAMAAsgB0EQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgChDsGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgIgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIDIAEgBBDLHSABIBAQzQYgARDTGCACIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgAxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo44MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIA5BBEEEEOAeIAVB0AFqJAAMAQsMKQsMJwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNMyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ05IAIpAxBC47Di8bKTqs3WAIUgAikDGEKw3+Dy+LaU9Id/hYRQRQ05IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIg42AnAjAEEgayIBJAAgAUEUaiAFQegAaiIEKAIEIAQoAgBrQQN2QQBBEEEgEKAYIAEoAhghAyABKAIUQQFGDTQgBUEsaiEKIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAM2AggjAEEQayIGJAAgAUEIaiICIAQoAgQgBCgCAGtBA3YQ7y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQTBrIgIkACAGQQRqIgMoAgQhCCADKAIAIRECQAJAIAQoAgAiByAEKAIEIglHBEAgAygCCCAIQQV0aiEDIAkgB2tBA3YhDCAEKAIIIQsDQCAHKAIAIgkgCygCCCIPTw07IAsoAgQgCUECdGooAgAhCSACIAdBBGooAgAiDzYCACAJQQxqENw8IA9NDQIgCSgCECAPQQV0aiIJKQMAIRUgCSkDCCEWIAkpAxAhFyADQRhqIAkpAxg3AwAgA0EQaiAXNwMAIAMgFjcDCCADIBU3AwAgB0EIaiEHIANBIGohAyAIQQFqIQggDEEBayIMDQALCyARIAg2AgAgAkEwaiQADAELIAIgCRCAPDYCHAw7CyAGQRBqJAAgCkEIaiANKAIANgIAIAogASkCCDcCACABQSBqJAAgBUG8AWoiASAKEO0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEEM4dIAEgEBDNBiABENEYIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQfDagwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwoCwwmC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0yIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTggAikDEEKo+Inf7v3i9xmFIAIpAxhCgoiiweW47v4WhYRQRQ04IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACELwdIAEgEBDNBiABEPIcIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQbDVgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwnCwwlC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0xIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTcgAikDEEL6mLb6kqaKwxyFIAIpAxhCo8C62dbm4aomhYRQRQ03IAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMAdIAEgEBDNBiABEPUcIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcjbgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwmCwwkC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0wIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTYgAikDEELtxZanvY/g2FSFIAIpAxhC14P/uOLrl/HcAIWEUEUNNiALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDDHSABIBAQzQYgARD6HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGo3oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMJQsMIwtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNLyABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ01IAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUEUNNSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDQHSABIBAQzQYgARD5HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEG44oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMJAsMIgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNLiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ00IAIpAxBCyeD6hKnPk5YvhSACKQMYQsvdpdKuhoKM/ACFhFBFDTQgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQvR0gASAQEM0GIAEQ9BwgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBoNyDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDCMLDCELQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDS0gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNMyACKQMQQrWospbEp++mTIUgAikDGEL384vm1Y6BzQKFhFBFDTMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEEQQgQoBggASgCGCEDIAEoAhRBAUYNLiAFQSxqIQggAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDqLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCigCBCEGIAooAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCigCCCAGQQN0aiEKIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw00IAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENg8IA9NDTUgCiAJKAIQIA9BA3RqKQIANwIAIANBCGohAyAKQQhqIQogBkEBaiEGIAxBAWsiDA0ACwsgESAGNgIAIAJBMGokAAwACyAHQRBqJAAgCEEIaiANKAIANgIAIAggASkCCDcCACABQSBqJAAgBUG8AWoiASAIEOsYIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiAiAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgMgASAEENMdIAEgEBDNBiABEPccIAIgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASADELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZDjgwE2AgggACABNgIEIABBk4CAgHg2AgAgDkEEQQQQ4B4gBUHQAWokAAwBCwwiCwwgC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0sIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDTIgAikDEELi0/LH09WDnP4AhSACKQMYQsXZuYGappOlgH+FhFBFDTIgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiDjYCcCMAQSBrIgEkACABQRRqIAVB6ABqIgQoAgQgBCgCAGtBA3ZBAEEIQRAQoBggASgCGCEDIAEoAhRBAUYNLSAFQSxqIQogAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgckACABQQhqIgIgBCgCBCAEKAIAa0EDdhDpLSAHIAIpAgRCIIk3AgggByACQQhqNgIEIwBBMGsiAiQAIAdBBGoiCCgCBCEGIAgoAgAhEQJAIAQoAgAiAyAEKAIEIglHBEAgCCgCCCAGQQR0aiEIIAkgA2tBA3YhDCAEKAIIIQsDQCADKAIAIgkgCygCCCIPTw0zIAsoAgQgCUECdGooAgAhCSACIANBBGooAgAiDzYCACAJQQxqENo8IA9NDTUgCSgCECAPQQR0aiIJKQMAIRUgCEEIaiAJQQhqKQMANwMAIAggFTcDACADQQhqIQMgCEEQaiEIIAZBAWohBiAMQQFrIgwNAAsLIBEgBjYCACACQTBqJAAMAAsgB0EQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAVBvAFqIgEgChDqGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgIgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIDIAEgBBDFHSABIBAQzQYgARDxHCACIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgAxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg4YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIA5BBEEEEOAeIAVB0AFqJAAMAQsMIQsMHwsgEC0AAUEBaw4DDQ4PDAtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNKiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0wIAIpAxBCvubD2YGShrNWhSACKQMYQry/laP9rPK1N4WEUEUNMCALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIgbIAVBvAFqIgEgBBDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDSHSABIBAQzQYgARCUHiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHI0IMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMHwsMHQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNKSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0vIAIpAxBCl9Gwm93/uJVZhSACKQMYQvyis4+I6LHY9gCFhFBFDS8gCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQxB0gASAQEM0GIAEQlx4gBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBiOGDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDB4LDBwLIBAtAAEOAg0OGgsgEC0AAUECaw4CDg8ZCyMAQbABayIGJAAgBkEAOgA0IAYgATYCECAGIAEgAkEDdGo2AhQgBiAGQTRqNgIYIwBBIGsiASQAIAFBFGogBkEQaiIFKAIEIAUoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDSYgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgckACAFKAIEIAUoAgBrQQN2IgggAUEIaiIQKAIAIBAoAggiAmtLBEAgECACIAhBBEEEEN4oIBAoAgghAgsgBkH0AGohCiAHIBAoAgQ2AgwgByACNgIIIAcgEEEIajYCBCMAQSBrIgIkACAHQQRqIgkoAgQhCCAJKAIAIRECQCAFKAIAIhAgBSgCBCILRwRAIAUoAgghDCAJKAIIIAhBAnRqIQkgCyAQa0EDdiELA0AgEEEEaigCACEPIBAoAgAhDiAMIAwtAAAEf0EBBSAOIA8oAkQRBABBAEcLOgAAIAJBCGogDiAPKAIQEQAAIAJBEGogAigCCCIPIAIoAgwoAgwRAAAgD0UNLCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUEUNLCAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQRBBBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCdKCAGKAJ4C0EANgIAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDAJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0eIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0gIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEIAXIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQ6BggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBlKjQoAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZClKjQoMGChYoUNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDSAgAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEGA5YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMHAsMGQsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0lIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSsgAikDEELCjPf26svc0YR/hSACKQMYQuWT9Jj5r/joqH+FhFBFDSsgCSAPNgIAIBBBCGohECAJQQRqIQkgCEEBaiEIIAtBAWsiCw0ACwsgESAINgIAIAJBIGokAAwACyAHQRBqJAAgCkEIaiANKAIANgIAIAogASkCCDcCACABQSBqJABBACECIAYtADRBAUYEQCAGIAQ2AhQgBiADNgIQIAYgCjYCGCAGQZgBaiIBIAQgBRDACCAFIAEQ4ScgBkGIAWogBkEcaikCADcDACAGQZABaiAGQSRqKAIANgIAIAYgBikCFDcDgAEgBigCECECCyAGQRhqIAZB/ABqKAIANgIAIAZBKGogBkGIAWopAwA3AwAgBkEwaiAGQZABaigCADYCACAGIAYpAnQ3AxAgBiACNgIcIAYgBikDgAE3AyAgBkEANgI0IAZBmAFqIARBAWpBAEEIQQgQoBggBigCnAEhAQJAIAYoApgBQQFHBEAgBkEANgJ8IAYgBigCoAEiAjYCeCAGIAE2AnQgAQR/IAIFIAZB9ABqQdDkgwEQsyggBigCeAtCADcDACAGQQE2AnwgBiADNgKYASAGIAMgBEEDdGoiBDYCnAEgBiAGQTRqNgKkASAGIAZBEGo2AqABIAZB9ABqIAZBmAFqIgEQwScgASAGKAI0QQBBAUEBEKAYIAYoApwBIQIgBigCmAFBAUYNHSAGQRxqIQEgBkEANgKIASAGIAYoAqABNgKEASAGIAI2AoABA0AgAygCACICIAYoAhgiBU8NHyAGQQhqIAYoAhQgAkECdGooAgAgA0EEaigCABDyFiAGQYABaiAGKAIIIAYoAgwQoTYgA0EIaiIDIARHDQALIAZBoAFqIgIgBkH8AGooAgA2AgAgBiAGKQJ0NwOYASAGQcQAaiAGQZgBaiIDEL0YIAIgBkGIAWooAgA2AgAgBiAGKQKAATcDmAEgBkHQAGogAxCTGSAGQUBrQZas2LABNgIAIAZB5ABqIAFBCGopAgA3AgAgBkHsAGogAUEQaikCADcCACAGQpas2LDhwoWLFjcDOCAGIAEpAgA3AlxBxABBBBCtNiIBRQ0fIAFCgYCAgBA3AgAgAUEIaiAGQThqQTz8CgAAIABBqOeDATYCCCAAIAE2AgQgAEGTgICAeDYCACAGQRBqQQRBBBDgHiAGQbABaiQADAELDBsLDBgLIwBB0AFrIgYkACAGQQA6AEAgBiABNgIAIAYgASACQQN0ajYCBCAGIAZBQGs2AggjAEEgayIBJAAgAUEUaiAGKAIEIAYoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDSQgAUEQaiIOQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgUkACAGKAIEIAYoAgBrQQN2IhAgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIBBBBEEEEN4oIAIoAgghBwsgBkGUAWohCCAFIAIoAgQ2AgwgBSAHNgIIIAUgAkEIajYCBCMAQSBrIgIkACAFQQRqIgooAgQhECAKKAIAIQ0CQCAGKAIAIgcgBigCBCIMRwRAIAYoAgghCSAKKAIIIBBBAnRqIQogDCAHa0EDdiEMA0AgB0EEaigCACELIAcoAgAhDyAJIAktAAAEf0EBBSAPIAsoAkQRBABBAEcLOgAAIAJBCGogDyALKAIQEQAAIAJBEGogAigCCCILIAIoAgwoAgwRAAAgC0UNKiACKQMQQq/zkNiUnMf7M4UgAikDGEKgpcX0zdDRpI1/hYRQRQ0qIAogCzYCACAHQQhqIQcgCkEEaiEKIBBBAWohECAMQQFrIgwNAAsLIA0gEDYCACACQSBqJAAMAAsgBUEQaiQAIAhBCGogDigCADYCACAIIAEpAgg3AgAgAUEgaiQAQQAhASAGLQBAQQFGBEAgBiAENgIEIAYgAzYCACAGIAg2AgggBkG4AWoiASAEIAYQvgggBiABEOEnIAZBqAFqIAZBDGopAgA3AwAgBkGwAWogBkEUaigCADYCACAGIAYpAgQ3A6ABIAYoAgAhAQsgBkEIaiICIAZBnAFqKAIANgIAIAZBGGogBkGoAWopAwA3AwAgBkEgaiAGQbABaigCADYCACAGIAYpApQBNwMAIAYgATYCDCAGIAYpA6ABNwMQIAZBADYCMCAGQoCAgIDAADcCKCAGQbgBaiACKAIAIgVBAWpBAEEEQQQQoBggBigCvAEhAQJAIAYoArgBQQFHBEAgBiAGKALAASICNgI4IAYgATYCNCACQQA2AgAgBkEBNgI8QQAhAiAFBEAgBigCBCEHQQIhASAFQQJ0IRBBACEFA0AgBSAHaigCACgCCCACaiECIAYoAjQgAUEBa0YEQCAGQTRqQfjugwEQnSgLIAYoAjggBWpBBGogAjYCACAGIAE2AjwgAUEBaiEBIBAgBUEEaiIFRw0ACwsgBkFAayIFIAIQqBUgBiADNgK4ASAGIAMgBEEDdGo2ArwBIAYgBkEoajYCzAEgBiAFNgLIASAGIAZBNGoiAjYCxAEgBiAGNgLAASAGQcwAaiIBIAZBuAFqIgMQ/xogBkGUAWoiBCABELoYIAZBqAFqIAZBMGooAgA2AgAgBiAGKQIoNwOgASAGQcgBaiAGQQxqIgFBEGopAgA3AwAgBkHAAWogAUEIaikCADcDACAGIAEpAgA3A7gBIAZB2ABqIgcgBCAGQaABaiADELwgQcQAQQQQrTYiAUUNHiABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQYjvgwE2AgggACABNgIEIABBk4CAgHg2AgAgBRDqOyACEOk7IAZBBEEEEOAeIAZB0AFqJAAMAQsMHgsMFwsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0jIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSkgAikDEELH2fTn3sS2nHeFIAIpAxhCjbLOlIzKkuanf4WEUEUNKSAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQRBBBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCdKCAGKAJ4C0EANgIAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDAJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0bIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0dIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEP8WIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQ6BggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBmLDgwAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZCmLDgwIGDhowYNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDR0gAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEHQ5oMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMGQsMFgsjAEGwAWsiBiQAIAZBADoANCAGIAE2AhAgBiABIAJBA3RqNgIUIAYgBkE0ajYCGCMAQSBrIgEkACABQRRqIAZBEGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0iIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIHJAAgBSgCBCAFKAIAa0EDdiIIIAFBCGoiECgCACAQKAIIIgJrSwRAIBAgAiAIQQRBBBDeKCAQKAIIIQILIAZB9ABqIQogByAQKAIENgIMIAcgAjYCCCAHIBBBCGo2AgQjAEEgayICJAAgB0EEaiIJKAIEIQggCSgCACERAkAgBSgCACIQIAUoAgQiC0cEQCAFKAIIIQwgCSgCCCAIQQJ0aiEJIAsgEGtBA3YhCwNAIBBBBGooAgAhDyAQKAIAIQ4gDCAMLQAABH9BAQUgDiAPKAJEEQQAQQBHCzoAACACQQhqIA4gDygCEBEAACACQRBqIAIoAggiDyACKAIMKAIMEQAAIA9FDSggAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUEUNKCAJIA82AgAgEEEIaiEQIAlBBGohCSAIQQFqIQggC0EBayILDQALCyARIAg2AgAgAkEgaiQADAALIAdBEGokACAKQQhqIA0oAgA2AgAgCiABKQIINwIAIAFBIGokAEEAIQIgBi0ANEEBRgRAIAYgBDYCFCAGIAM2AhAgBiAKNgIYIAZBmAFqIgEgBCAFEMAIIAUgARDhJyAGQYgBaiAGQRxqKQIANwMAIAZBkAFqIAZBJGooAgA2AgAgBiAGKQIUNwOAASAGKAIQIQILIAZBGGogBkH8AGooAgA2AgAgBkEoaiAGQYgBaikDADcDACAGQTBqIAZBkAFqKAIANgIAIAYgBikCdDcDECAGIAI2AhwgBiAGKQOAATcDICAGQQA2AjQgBkGYAWogBEEBakEAQQhBCBCgGCAGKAKcASEBAkAgBigCmAFBAUcEQCAGQQA2AnwgBiAGKAKgASICNgJ4IAYgATYCdCABBH8gAgUgBkH0AGpB0OSDARCzKCAGKAJ4C0IANwMAIAZBATYCfCAGIAM2ApgBIAYgAyAEQQN0aiIENgKcASAGIAZBNGo2AqQBIAYgBkEQajYCoAEgBkH0AGogBkGYAWoiARDBJyABIAYoAjRBAEEBQQEQoBggBigCnAEhAiAGKAKYAUEBRg0aIAZBHGohASAGQQA2AogBIAYgBigCoAE2AoQBIAYgAjYCgAEDQCADKAIAIgIgBigCGCIFTw0cIAZBCGogBigCFCACQQJ0aigCACADQQRqKAIAEPEWIAZBgAFqIAYoAgggBigCDBChNiADQQhqIgMgBEcNAAsgBkGgAWoiAiAGQfwAaigCADYCACAGIAYpAnQ3A5gBIAZBxABqIAZBmAFqIgMQvRggAiAGQYgBaigCADYCACAGIAYpAoABNwOYASAGQdAAaiADEJMZIAZBQGtBmbLkyAE2AgAgBkHkAGogAUEIaikCADcCACAGQewAaiABQRBqKQIANwIAIAZCmbLkyJGjxowZNwM4IAYgASkCADcCXEHEAEEEEK02IgFFDRwgAUKBgICAEDcCACABQQhqIAZBOGpBPPwKAAAgAEH45YMBNgIIIAAgATYCBCAAQZOAgIB4NgIAIAZBEGpBBEEEEOAeIAZBsAFqJAAMAQsMGAsMFQsjAEHQAWsiBiQAIAZBADoAQCAGIAE2AgAgBiABIAJBA3RqNgIEIAYgBkFAazYCCCMAQSBrIgEkACABQRRqIAYoAgQgBigCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNISABQRBqIg5BADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiBSQAIAYoAgQgBigCAGtBA3YiECABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgEEEEQQQQ3iggAigCCCEHCyAGQZQBaiEIIAUgAigCBDYCDCAFIAc2AgggBSACQQhqNgIEIwBBIGsiAiQAIAVBBGoiCigCBCEQIAooAgAhDQJAIAYoAgAiByAGKAIEIgxHBEAgBigCCCEJIAooAgggEEECdGohCiAMIAdrQQN2IQwDQCAHQQRqKAIAIQsgBygCACEPIAkgCS0AAAR/QQEFIA8gCygCRBEEAEEARws6AAAgAkEIaiAPIAsoAhARAAAgAkEQaiACKAIIIgsgAigCDCgCDBEAACALRQ0nIAIpAxBCq5iR8ZX61fyAf4UgAikDGEKWlPir8LHps+EAhYRQRQ0nIAogCzYCACAHQQhqIQcgCkEEaiEKIBBBAWohECAMQQFrIgwNAAsLIA0gEDYCACACQSBqJAAMAAsgBUEQaiQAIAhBCGogDigCADYCACAIIAEpAgg3AgAgAUEgaiQAQQAhASAGLQBAQQFGBEAgBiAENgIEIAYgAzYCACAGIAg2AgggBkG4AWoiASAEIAYQvgggBiABEOEnIAZBqAFqIAZBDGopAgA3AwAgBkGwAWogBkEUaigCADYCACAGIAYpAgQ3A6ABIAYoAgAhAQsgBkEIaiICIAZBnAFqKAIANgIAIAZBGGogBkGoAWopAwA3AwAgBkEgaiAGQbABaigCADYCACAGIAYpApQBNwMAIAYgATYCDCAGIAYpA6ABNwMQIAZBADYCMCAGQoCAgIDAADcCKCAGQbgBaiACKAIAIgVBAWpBAEEEQQQQoBggBigCvAEhAQJAIAYoArgBQQFHBEAgBiAGKALAASICNgI4IAYgATYCNCACQQA2AgAgBkEBNgI8QQAhAiAFBEAgBigCBCEHQQIhASAFQQJ0IRBBACEFA0AgBSAHaigCACgCCCACaiECIAYoAjQgAUEBa0YEQCAGQTRqQfjugwEQnSgLIAYoAjggBWpBBGogAjYCACAGIAE2AjwgAUEBaiEBIBAgBUEEaiIFRw0ACwsgBkFAayIFIAIQqBUgBiADNgK4ASAGIAMgBEEDdGo2ArwBIAYgBkEoajYCzAEgBiAFNgLIASAGIAZBNGoiAjYCxAEgBiAGNgLAASAGQcwAaiIBIAZBuAFqIgMQ/xogBkGUAWoiBCABELoYIAZBqAFqIAZBMGooAgA2AgAgBiAGKQIoNwOgASAGQcgBaiAGQQxqIgFBEGopAgA3AwAgBkHAAWogAUEIaikCADcDACAGIAEpAgA3A7gBIAZB2ABqIgcgBCAGQaABaiADEL0gQcQAQQQQrTYiAUUNGyABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQaDugwE2AgggACABNgIEIABBk4CAgHg2AgAgBRDqOyACEOk7IAZBBEEEEOAeIAZB0AFqJAAMAQsMGwsMFAsjAEHwAWsiBiQAIAZBADoAOCAGIAE2AkQgBiABIAJBA3RqNgJIIAYgBkE4ajYCTCMAQSBrIgEkACABQRRqIAZBxABqIgooAgQgCigCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNICABQRBqIhFBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiBSQAIAooAgQgCigCAGtBA3YiCCABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCEEEQQQQ3iggAigCCCEHCyAGQcgBaiEJIAUgAigCBDYCDCAFIAc2AgggBSACQQhqNgIEIwBBIGsiAiQAIAVBBGoiDCgCBCEIIAwoAgAhEwJAIAooAgAiByAKKAIEIg9HBEAgCigCCCELIAwoAgggCEECdGohDCAPIAdrQQN2IQ8DQCAHQQRqKAIAIQ4gBygCACENIAsgCy0AAAR/QQEFIA0gDigCRBEEAEEARws6AAAgAkEIaiANIA4oAhARAAAgAkEQaiACKAIIIg4gAigCDCgCDBEAACAORQ0mIAIpAxBCvrmqiZnSjZrgAIUgAikDGELFkYG6kcLDzTSFhFBFDSYgDCAONgIAIAdBCGohByAMQQRqIQwgCEEBaiEIIA9BAWsiDw0ACwsgEyAINgIAIAJBIGokAAwACyAFQRBqJAAgCUEIaiARKAIANgIAIAkgASkCCDcCACABQSBqJABBACECIAYtADhBAUYEQCAGIAQ2AkggBiADNgJEIAYgCTYCTEEAIQlBACEFIwBBMGsiCCQAQcAAIQwCQAJAIARBBnYiASAEQT9xIg9BAEdqIgJBA3QiB0HA////A3FBQGsgByACQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiDEUNAgsgBEHAAEkNAiABrSEZIAooAgghDiAKKAIAIQcgCigCBCIRrSEaA0AgF0IBfCEXIAchASAFIQJCACEVQgAhFgNAAkAgGiAVIBh8VgRAIAEoAgAiDSAOKAIIIhNJDQEgDSATQfj1gwEQwyEACyACIBFB6PWDARDDIQALIAFBBGohEyABQQhqIQEgAkEBaiECIA4oAgQgDUECdGooAgAgEygCABCTO60gFYYgFoQhFiAVQgF8IhVCwABSDQALIAkgDGogFjcDACAYQkB9IRggB0GABGohByAFQUBrIQUgCUEIaiEJIBcgGVINAAsMAgtB8PSDAUEpIAhBHGpBrPWDAUGc9YMBENUeAAtBwAAgCxCjPQALIA8EQCAKKAIEIgUgBEFAcSICayIBQQAgASAFTRutIRcgCigCACAEQQN0QYB8cWohASAPrSEYIAooAgghB0IAIRVCACEWA0ACQCAVIBdSBEAgASgCACIPIAcoAggiDkkNASAPIA5B+PWDARDDIQALIAIgBUHo9YMBEMMhAAsgAUEEaiEOIAFBCGohASACQQFqIQIgBygCBCAPQQJ0aigCACAOKAIAEJM7rSAVhiAWhCEWIBVCAXwiFSAYUg0ACyAJIAxqIBY3AAAgCUEIaiEJCyAGQfgAaiECIAggCzYCLCAIQoCAgICACDcCJCAIIAw2AhwgCCAEQQN2IARBB3FBAEdqIgEgCSABIAlJGyIFNgIgIAhBCGogCEEcahDXOyAIKAIIIQcCQEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAIKQIcNwIIIAFBEGogCEEkaikCADcCACABQRhqIAhBLGooAgA2AgAgCCAFNgIYIAggBzYCFCAIIAE2AhAgAiAIQRBqQQAgBBDyFSAIQTBqJAAMAQtBBEEcEKM9AAsgCiACEOEnIAZB4AFqIAZB0ABqKQIANwMAIAZB6AFqIAZB2ABqKAIANgIAIAYgBikCSDcD2AEgBigCRCECCyAGQRhqIAZB0AFqKAIANgIAIAZBKGogBkHgAWopAwA3AwAgBkEwaiAGQegBaigCADYCACAGIAYpAsgBNwMQIAYgAjYCHCAGIAYpA9gBNwMgIAZBADYCQCAGQoCAgIDAADcCOCAGQQhqIBBBBGoiBRDDNCAGQRxqIQECQAJAAkACQCAGKAIMIgoEQEEAIQIDQCAGKAIYIRAgBigCFCEHIAYgAjYC2AEgBiAHIBBBAnRqNgJIIAYgBzYCRCAGIAZB2AFqNgJMIAZB+ABqIgggBkHEAGoiB0HIy4MBEIQbIAcgBigCfCAGKAKAASADIAQQrwIgBigCTCEHIAYoAkghECAGKAJEIglBk4CAgHhHBEAgACAGKQJQNwIMIAAgBzYCCCAAIBA2AgQgACAJNgIAIAhBBEEIEOAeIAZBOGoiABDDJyAAEOo7IAZBEGpBBEEEEOAeIAYoAhwiAEUNAyAAIAAoAgAiAEEBazYCACAAQQFHDQMgARD7HgwDCyAGKAJAIgggBigCOEYEQCAGQThqQbjwgwEQmygLIAYoAjwgCEEDdGoiCSAHNgIEIAkgEDYCACAGIAhBAWo2AkAgBkH4AGpBBEEIEOAeIAogAkEBaiICRw0ACwsgBSgCACICIAIoAgAiA0EBajYCACADQQBIDQEgBSgCBCEDIAZB0AFqIAZBQGsoAgA2AgAgBiAGKQI4NwPIASAGQYgBaiABQRBqKQIANwMAIAZBgAFqIAFBCGopAgA3AwAgBiABKQIANwN4IAZBxABqIAIgAyAGQcgBaiAGQfgAahDlDyAGQeABaiIBIAZB0ABqKQIANwMAIAZB6AFqIgIgBkHYAGooAgA2AgAgBiAGKQJINwPYASAGKAJEIgNBgICAgHhGBEAgACAGKQPYATcCACAAQRBqIAIoAgA2AgAgAEEIaiABKQMANwIAIAZBEGpBBEEEEOAeDAELIAZBqAFqIgQgBkH0AGooAgA2AgAgBkGgAWoiBSAGQewAaikCADcDACAGQZgBaiIHIAZB5ABqKQIANwMAIAZBuAFqIhAgASkDADcDACAGQcABaiIIIAIoAgA2AgAgBiAGKQJcNwOQASAGIAYpA9gBNwOwAUE8QQQQrTYiAUUNAiABIAM2AgggAUKBgICAEDcCACABIAYpA7ABNwIMIAEgBikDkAE3AiAgAEHg74MBNgIIIAAgATYCBCABQRRqIBApAwA3AgAgAUEcaiAIKAIANgIAIAFBKGogBykDADcCACABQTBqIAUpAwA3AgAgAUE4aiAEKAIANgIAIABBk4CAgHg2AgAgBkEQakEEQQQQ4B4LIAZB8AFqJAAMAgsAC0EEQTwQoz0ACwwTCyASIBBBBGo2AjQgECgCBC0AAEECaw4ICQoLDA0ODxAIC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0eIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDSQgAikDEELktsqsz8HjheAAhSACKQMYQs3RnZud/LiouX+FhFBFDSQgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ1B0gASAQEM0GIAEQhRcgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBuNeDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDBMLDBELQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDR0gAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNIyACKQMQQuSpxfLdiuHGNIUgAikDGEK1yYmVqZf6txmFhFBFDSMgCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCAGyAFQbwBaiIBIAQQvRggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQyB0gASAQEM0GIAEQ/hYgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBgNSDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDBILDBALQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDRwgAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNIiACKQMQQrX4x6jW3dS3vn+FIAIpAxhCp/LU/K+vgKllhYRQRQ0iIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMkdIAEgEBDNBiABEP0WIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQcDOgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwRCwwPC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0bIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDSEgAikDEEKLtaPljNen43SFIAIpAxhCsKP53sDxp9eEf4WEUEUNISALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDRHSABIBAQzQYgARD8FiAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEHwz4MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMEAsMDgtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNGiABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0gIAIpAxBC65CWiN2g5IZghSACKQMYQrmNv6eS/6CCYYWEUEUNICALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIgbIAVBvAFqIgEgBBDoGCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDMHSABIBAQzQYgARD4HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGo04MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMDwsMDQtBACEGIwBB0AFrIgUkACAFQQA6AJsBIAUgATYCaCAFIAEgAkEDdGo2AmwgBSAFQZsBajYCcCMAQSBrIgEkACABQRRqIAVB6ABqIggoAgQgCCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYNGSABQRBqIhNBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiCiQAIAgoAgQgCCgCAGtBA3YiCSABQQhqIgIoAgAgAigCCCIHa0sEQCACIAcgCUEEQQQQ3iggAigCCCEHCyAFQZwBaiEMIAogAigCBDYCDCAKIAc2AgggCiACQQhqNgIEIwBBIGsiAiQAIApBBGoiCygCBCEJIAsoAgAhFAJAIAgoAgAiByAIKAIEIg5HBEAgCCgCCCEPIAsoAgggCUECdGohCyAOIAdrQQN2IQ4DQCAHQQRqKAIAIQ0gBygCACERIA8gDy0AAAR/QQEFIBEgDSgCRBEEAEEARws6AAAgAkEIaiARIA0oAhARAAAgAkEQaiACKAIIIg0gAigCDCgCDBEAACANRQ0fIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFBFDR8gCyANNgIAIAdBCGohByALQQRqIQsgCUEBaiEJIA5BAWsiDg0ACwsgFCAJNgIAIAJBIGokAAwACyAKQRBqJAAgDEEIaiATKAIANgIAIAwgASkCCDcCACABQSBqJAAgBS0AmwFBAUYEQCAFIAQ2AmwgBSADNgJoIAUgDDYCcCAFQbwBaiIBIAQgCBC/CCAIIAEQ4ScgBUGwAWogBUH0AGopAgA3AwAgBUG4AWogBUH8AGooAgA2AgAgBSAFKQJsNwOoASAFKAJoIQYLIAVBEGogBUGkAWooAgA2AgAgBUEgaiAFQbABaikDADcDACAFQShqIAVBuAFqKAIANgIAIAUgBSkCnAE3AwggBSAGNgIUIAUgBSkDqAE3AxggBSADNgJoIAUgAyAEQQN0ajYCbCAFIAVBCGoiAzYCcCAFQSxqIgQgBUHoAGoiAhCIGyAFQbwBaiIBIAQQ6BggBUH4AGogBUEkaikCADcDACAFQfAAaiIEIAVBHGopAgA3AwAgBSAFKQIUNwNoIAVBOGoiByABIAIQ1x0gASAQEM0GIAEQ8xwgBCAFQcQBaigCADYCACAFQfwAaiAFQcwAaigCADYCACAFQYgBaiAFQdgAaikCADcDACAFQZABaiAFQeAAaikCADcDACAFIAUpArwBNwNoIAUgBSkCRDcCdCAFIAUpAlA3A4ABIAcQuwwCQEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABBkNiDATYCCCAAIAE2AgQgAEGTgICAeDYCACADQQRBBBDgHiAFQdABaiQADAELDA4LDAwLQQAhBiMAQdABayIFJAAgBUEAOgCbASAFIAE2AmggBSABIAJBA3RqNgJsIAUgBUGbAWo2AnAjAEEgayIBJAAgAUEUaiAFQegAaiIIKAIEIAgoAgBrQQN2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGDRggAUEQaiITQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIgokACAIKAIEIAgoAgBrQQN2IgkgAUEIaiICKAIAIAIoAggiB2tLBEAgAiAHIAlBBEEEEN4oIAIoAgghBwsgBUGcAWohDCAKIAIoAgQ2AgwgCiAHNgIIIAogAkEIajYCBCMAQSBrIgIkACAKQQRqIgsoAgQhCSALKAIAIRQCQCAIKAIAIgcgCCgCBCIORwRAIAgoAgghDyALKAIIIAlBAnRqIQsgDiAHa0EDdiEOA0AgB0EEaigCACENIAcoAgAhESAPIA8tAAAEf0EBBSARIA0oAkQRBABBAEcLOgAAIAJBCGogESANKAIQEQAAIAJBEGogAigCCCINIAIoAgwoAgwRAAAgDUUNHiACKQMQQsX5y/+RruGl8wCFIAIpAxhC7vSymv2ZrpRChYRQRQ0eIAsgDTYCACAHQQhqIQcgC0EEaiELIAlBAWohCSAOQQFrIg4NAAsLIBQgCTYCACACQSBqJAAMAAsgCkEQaiQAIAxBCGogEygCADYCACAMIAEpAgg3AgAgAUEgaiQAIAUtAJsBQQFGBEAgBSAENgJsIAUgAzYCaCAFIAw2AnAgBUG8AWoiASAEIAgQvwggCCABEOEnIAVBsAFqIAVB9ABqKQIANwMAIAVBuAFqIAVB/ABqKAIANgIAIAUgBSkCbDcDqAEgBSgCaCEGCyAFQRBqIAVBpAFqKAIANgIAIAVBIGogBUGwAWopAwA3AwAgBUEoaiAFQbgBaigCADYCACAFIAUpApwBNwMIIAUgBjYCFCAFIAUpA6gBNwMYIAUgAzYCaCAFIAMgBEEDdGo2AmwgBSAFQQhqIgM2AnAgBUEsaiIEIAVB6ABqIgIQgBsgBUG8AWoiASAEEL0YIAVB+ABqIAVBJGopAgA3AwAgBUHwAGoiBCAFQRxqKQIANwMAIAUgBSkCFDcDaCAFQThqIgcgASACEMIdIAEgEBDNBiABEPscIAQgBUHEAWooAgA2AgAgBUH8AGogBUHMAGooAgA2AgAgBUGIAWogBUHYAGopAgA3AwAgBUGQAWogBUHgAGopAgA3AwAgBSAFKQK8ATcDaCAFIAUpAkQ3AnQgBSAFKQJQNwOAASAHELsMAkBBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkEw/AoAACAAQdDSgwE2AgggACABNgIEIABBk4CAgHg2AgAgA0EEQQQQ4B4gBUHQAWokAAwBCwwNCwwLC0EAIQYjAEHQAWsiBSQAIAVBADoAmwEgBSABNgJoIAUgASACQQN0ajYCbCAFIAVBmwFqNgJwIwBBIGsiASQAIAFBFGogBUHoAGoiCCgCBCAIKAIAa0EDdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRg0XIAFBEGoiE0EANgIAIAEgASgCHDYCDCABIAI2AggjAEEQayIKJAAgCCgCBCAIKAIAa0EDdiIJIAFBCGoiAigCACACKAIIIgdrSwRAIAIgByAJQQRBBBDeKCACKAIIIQcLIAVBnAFqIQwgCiACKAIENgIMIAogBzYCCCAKIAJBCGo2AgQjAEEgayICJAAgCkEEaiILKAIEIQkgCygCACEUAkAgCCgCACIHIAgoAgQiDkcEQCAIKAIIIQ8gCygCCCAJQQJ0aiELIA4gB2tBA3YhDgNAIAdBBGooAgAhDSAHKAIAIREgDyAPLQAABH9BAQUgESANKAJEEQQAQQBHCzoAACACQQhqIBEgDSgCEBEAACACQRBqIAIoAggiDSACKAIMKAIMEQAAIA1FDR0gAikDEEKGgdCQuIeTo5l/hSACKQMYQqPV46Dasvufe4WEUEUNHSALIA02AgAgB0EIaiEHIAtBBGohCyAJQQFqIQkgDkEBayIODQALCyAUIAk2AgAgAkEgaiQADAALIApBEGokACAMQQhqIBMoAgA2AgAgDCABKQIINwIAIAFBIGokACAFLQCbAUEBRgRAIAUgBDYCbCAFIAM2AmggBSAMNgJwIAVBvAFqIgEgBCAIEL8IIAggARDhJyAFQbABaiAFQfQAaikCADcDACAFQbgBaiAFQfwAaigCADYCACAFIAUpAmw3A6gBIAUoAmghBgsgBUEQaiAFQaQBaigCADYCACAFQSBqIAVBsAFqKQMANwMAIAVBKGogBUG4AWooAgA2AgAgBSAFKQKcATcDCCAFIAY2AhQgBSAFKQOoATcDGCAFIAM2AmggBSADIARBA3RqNgJsIAUgBUEIaiIDNgJwIAVBLGoiBCAFQegAaiICEIAbIAVBvAFqIgEgBBC9GCAFQfgAaiAFQSRqKQIANwMAIAVB8ABqIgQgBUEcaikCADcDACAFIAUpAhQ3A2ggBUE4aiIHIAEgAhDVHSABIBAQzQYgARD2HCAEIAVBxAFqKAIANgIAIAVB/ABqIAVBzABqKAIANgIAIAVBiAFqIAVB2ABqKQIANwMAIAVBkAFqIAVB4ABqKQIANwMAIAUgBSkCvAE3A2ggBSAFKQJENwJ0IAUgBSkCUDcDgAEgBxC7DAJAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBMPwKAAAgAEGA34MBNgIIIAAgATYCBCAAQZOAgIB4NgIAIANBBEEEEOAeIAVB0AFqJAAMAQsMDAsMCgsgEkEBNgI8IBJBmM2DATYCOCASQgE3AkQgEkHFEzYCKCASIBJBJGo2AkAgEiASQTRqNgIkIBJBOGpBoM2DARDvLAALIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0XIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCEIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQiw9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhCZGyACIAggBSAGKAIYIAYoAhwQyAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPAeIAMgBEEDdGohCwNAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiAiB0kNAQwWCyAKEOY6IAYoAkBFDRcgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQQAhBCAGKAI8IgIgBigCNEcNA0GoxYMBIQEMAgsgASAGKAIoIgdPDRcgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACaiwAACIBTQ0YIAcoAgQgAWotAAAhBAJAIAYoAkAEQCAGKAJQIgdBAWoiCUEDdiAJQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQwgBigCRCIPIAJJBEAgCiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAYoAkwhAQsgDARAIAYoAkggAWpBACAM/AsACyAGIAI2AkwLIAYgCTYCUCAGKAJIIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAGIAYoAlRBAWo2AlQLIAYoAjwiAiAGKAI0Rw0CQbjFgwEhAQwBCwwUCyAGQTRqIAEQoygLIAYoAjggAmogBDoAACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICENYUIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0VIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQfDpgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhDeOyAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBENcrIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMCQsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAgLIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0WIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCDIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQig9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhCXGyACIAggBSAGKAIYIAYoAhwQwwIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPUeIAMgBEEDdGohCwNAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiBBAXYiB0kNAQwVCyAKEOY6IAYoAkBFDRYgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQQAhBCAGKAI8IgIgBigCNEcNA0GoxYMBIQEMAgsgASAGKAIoIgdPDRYgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACQQF0ai4BACIBTQ0XIAcoAgQgAUEBdGovAQAhBAJAIAYoAkAEQCAGKAJQIgdBAWoiCUEDdiAJQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQwgBigCRCIPIAJJBEAgCiAPQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIPIAEgD0sbEOgZIAYoAkwhAQsgDARAIAYoAkggAWpBACAM/AsACyAGIAI2AkwLIAYgCTYCUCAGKAJIIAdBA3ZqIgEgAS0AAEEBIAdBB3F0cjoAAAwBCyAGIAYoAlRBAWo2AlQLIAYoAjwiAiAGKAI0Rw0CQbjFgwEhAQwBCwwTCyAGQTRqIAEQrSgLIAYoAjggAkEBdGogBDsBACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICEM4UIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0UIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQdDsgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhCdPCAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBENUrIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMCAsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAcLIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0VIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCHIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQiQ9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhD6GiACIAggBSAGKAIYIAYoAhwQxAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEPkeIAMgBEEDdGohCwNAAkACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIEQQxqIANBBGooAgAiAhCLOwRAIAIgBCgCIEECdiIHSQ0BDBULIAoQ5jogBigCQEUNFiAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0EQajFgwEhAQwDCyABIAYoAigiB08NFiAEKAIcIAJBAnRqKAIAIgIgBigCJCABQQxsaiIBKAIIIgRPDQEgASgCBCACQQJ0aigCACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQNBuMWDASEBDAILDBMLIAIgBEGI6YMBEMMhAAsgBkE0aiABEJ0oCyAGKAI4IAJBAnRqIAQ2AgAgBiACQQFqNgI8IANBCGoiAyALRw0ACyAGQbABaiIBIAZBNGoiAhDQFCAGQegAaiIDIAEgBigCLCAGKAIwEMcVQdAAQQQQrTYiAUUNEyABQoGAgIAQNwIAIAFBCGogA0HIAPwKAAAgEEH464MBNgIIIBAgATYCBCAQQZOAgIB4NgIAIAIQ6TsgBigCQARAIAoQzy8LIAZB3ABqELkMIAZBIGoiARCwKyABQQRBDBDgHiAGQRRqIgEQwicgAUEEQRQQ4B4LIAZBCGpBBEEEEOAeIAZB4AFqJAAgEigCQCEBIBIoAjwhAiASKAI4IgNBk4CAgHhHBEAgACASKQJENwIMIAAgATYCCCAAIAI2AgQgACADNgIADAcLIAIgARCaLCEBIABB+MuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyMAQeABayIGJAAjAEEgayIFJAAgBUEUaiABIAJBA3RqIgkgAWtBA3ZBAEEEQQQQoBggBSgCGCEHIAUoAhRBAUYNFCAFQRBqIg9BADYCACAFIAUoAhw2AgwgBSAHNgIIIwBBEGsiCCQAIAkgAWtBA3YiECAFQQhqIgooAgAgCigCCCIHa0sEQCAKIAcgEEEEQQQQ3iggCigCCCEHCyASQThqIRAgBkEIaiELIAggCigCBDYCDCAIIAc2AgggCCAKQQhqNgIEIAhBBGoiDCgCBCEKIAwoAgAgCSABIgdHBEAgDCgCCCAKQQJ0aiEMIAogCSABa0EDdiIJaiEKA0AgDCAHKAIAIAdBBGooAgAQhSI2AgAgB0EIaiEHIAxBBGohDCAJQQFrIgkNAAsLIAo2AgAgCEEQaiQAIAtBCGogDygCADYCACALIAUpAgg3AgAgBUEgaiQAAkAgBigCDCIIIAYoAhAiBSAEEOIPRQRAIBAgASACIAMgBBD9DwwBCyAGIAQ2AkQgBiADNgJAIAZBADYCPCAGIAg2AjQgBiAIIAVBAnRqNgI4IAZBFGoiASAGQTRqIgIQ+RogAiAIIAUgBigCGCAGKAIcEMACIAZBuAFqIgIgBkFAayIKKQIANwMAIAZBwAFqIgcgBkHIAGooAgA2AgAgBiAGKQI4NwOwASAGKAI0QQFGBEAgECAGKQOwATcCACAQQRBqIAcoAgA2AgAgEEEIaiACKQMANwIAIAEQwicgAUEEQRQQ4B4MAQsgBkEwaiAHKAIANgIAIAZBKGogAikDADcDACAGIAYpA7ABNwMgIAZBNGogBBD4HiADIARBA3RqIQwDQAJAAkAgBSADKAIAIgFLBEACQCAIIAFBAnRqKAIAIglBDGogA0EEaigCACICEIs7BEAgAiAJKAIgQQN2IgdJDQEMEwsgChDmOiAGKAJARQ0UIAYoAlBBAWoiBEEDdiAEQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQcgBigCRCIJIAJJBEAgCiAJQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIJIAEgCUsbEOgZIAYoAkwhAQsgBwRAIAYoAkggAWpBACAH/AsACyAGIAI2AkwLIAYgBDYCUEIAIRUgBigCPCIBIAYoAjRHDQNBqMWDASECDAILIAEgBigCKCIHTw0UIAYoAiQgAUEMbGoiBygCCCIEIAkoAhwgAkEDdGopAwCnIgFNDRUgBygCBCABQQN0aikDACEVAkAgBigCQARAIAYoAlAiBEEBaiIHQQN2IAdBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshCSAGKAJEIgsgAkkEQCAKIAtBAXQiASACQcD///8DcUFAayACIAJBP3EbIgsgASALSxsQ6BkgBigCTCEBCyAJBEAgBigCSCABakEAIAn8CwALIAYgAjYCTAsgBiAHNgJQIAYoAkggBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCIBIAYoAjRHDQJBuMWDASECDAELDBELIAZBNGogAhCzKAsgBigCOCABQQN0aiAVNwMAIAYgAUEBajYCPCADQQhqIgMgDEcNAAsgBkGwAWoiASAGQTRqIgIQ2xQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDRIgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBmOmDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEOM8IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1isgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwGCyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMBQsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDRMgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIkiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBCND0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEJkbIAIgCCAFIAYoAhggBigCHBDHAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ9x4gAyAEQQN0aiELA0ACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIJQQxqIANBBGooAgAiAhCLOwRAIAIgCSgCICIHSQ0BDBILIAoQ5jogBigCQEUNEyAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0DQajFgwEhAQwCCyABIAYoAigiB08NEyAGKAIkIAFBDGxqIgcoAggiBCAJKAIcIAJqLQAAIgFNDRQgBygCBCABai0AACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQJBuMWDASEBDAELDBALIAZBNGogARCpGQsgBigCOCACaiAEOgAAIAYgAkEBajYCPCADQQhqIgMgC0cNAAsgBkGwAWoiASAGQTRqIgIQ0RQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDREgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBoOuDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEN47IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1ysgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwFCyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMBAsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDRIgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIgiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBCMD0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEJcbIAIgCCAFIAYoAhggBigCHBDBAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ8x4gAyAEQQN0aiELA0ACQAJAIAUgAygCACIBSwRAAkAgCCABQQJ0aigCACIJQQxqIANBBGooAgAiAhCLOwRAIAIgCSgCIEEBdiIHSQ0BDBELIAoQ5jogBigCQEUNEiAGKAJQQQFqIgRBA3YgBEEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEHIAYoAkQiCSACSQRAIAogCUEBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCSABIAlLGxDoGSAGKAJMIQELIAcEQCAGKAJIIAFqQQAgB/wLAAsgBiACNgJMCyAGIAQ2AlBBACEEIAYoAjwiAiAGKAI0Rw0DQajFgwEhAQwCCyABIAYoAigiB08NEiAGKAIkIAFBDGxqIgcoAggiBCAJKAIcIAJBAXRqLwEAIgFNDRMgBygCBCABQQF0ai8BACEEAkAgBigCQARAIAYoAlAiB0EBaiIJQQN2IAlBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshDCAGKAJEIg8gAkkEQCAKIA9BAXQiASACQcD///8DcUFAayACIAJBP3EbIg8gASAPSxsQ6BkgBigCTCEBCyAMBEAgBigCSCABakEAIAz8CwALIAYgAjYCTAsgBiAJNgJQIAYoAkggB0EDdmoiASABLQAAQQEgB0EHcXRyOgAADAELIAYgBigCVEEBajYCVAsgBigCPCICIAYoAjRHDQJBuMWDASEBDAELDA8LIAZBNGogARCtKAsgBigCOCACQQF0aiAEOwEAIAYgAkEBajYCPCADQQhqIgMgC0cNAAsgBkGwAWoiASAGQTRqIgIQzxQgBkHoAGoiAyABIAYoAiwgBigCMBDHFUHQAEEEEK02IgFFDRAgAUKBgICAEDcCACABQQhqIANByAD8CgAAIBBBgOiDATYCCCAQIAE2AgQgEEGTgICAeDYCACACEJ08IAYoAkAEQCAKEM8vCyAGQdwAahC5DCAGQSBqIgEQ1SsgAUEEQQwQ4B4gBkEUaiIBEMInIAFBBEEUEOAeCyAGQQhqQQRBBBDgHiAGQeABaiQAIBIoAkAhASASKAI8IQIgEigCOCIDQZOAgIB4RwRAIAAgEikCRDcCDCAAIAE2AgggACACNgIEIAAgAzYCAAwECyACIAEQmiwhASAAQfjLgwE2AgggACABNgIEIABBk4CAgHg2AgAMAwsjAEHgAWsiBiQAIwBBIGsiBSQAIAVBFGogASACQQN0aiIJIAFrQQN2QQBBBEEEEKAYIAUoAhghByAFKAIUQQFGDREgBUEQaiIPQQA2AgAgBSAFKAIcNgIMIAUgBzYCCCMAQRBrIggkACAJIAFrQQN2IhAgBUEIaiIKKAIAIAooAggiB2tLBEAgCiAHIBBBBEEEEN4oIAooAgghBwsgEkE4aiEQIAZBCGohCyAIIAooAgQ2AgwgCCAHNgIIIAggCkEIajYCBCAIQQRqIgwoAgQhCiAMKAIAIAkgASIHRwRAIAwoAgggCkECdGohDCAKIAkgAWtBA3YiCWohCgNAIAwgBygCACAHQQRqKAIAEIoiNgIAIAdBCGohByAMQQRqIQwgCUEBayIJDQALCyAKNgIAIAhBEGokACALQQhqIA8oAgA2AgAgCyAFKQIINwIAIAVBIGokAAJAIAYoAgwiCCAGKAIQIgUgBBDkD0UEQCAQIAEgAiADIAQQ/Q8MAQsgBiAENgJEIAYgAzYCQCAGQQA2AjwgBiAINgI0IAYgCCAFQQJ0ajYCOCAGQRRqIgEgBkE0aiICEPoaIAIgCCAFIAYoAhggBigCHBDCAiAGQbgBaiICIAZBQGsiCikCADcDACAGQcABaiIHIAZByABqKAIANgIAIAYgBikCODcDsAEgBigCNEEBRgRAIBAgBikDsAE3AgAgEEEQaiAHKAIANgIAIBBBCGogAikDADcCACABEMInIAFBBEEUEOAeDAELIAZBMGogBygCADYCACAGQShqIAIpAwA3AwAgBiAGKQOwATcDICAGQTRqIAQQ8h4gAyAEQQN0aiELA0ACQAJAAkAgBSADKAIAIgFLBEACQCAIIAFBAnRqKAIAIgRBDGogA0EEaigCACICEIs7BEAgAiAEKAIgQQJ2IgdJDQEMEQsgChDmOiAGKAJARQ0SIAYoAlBBAWoiBEEDdiAEQQdxQQBHaiICIAYoAkwiAUsEQCACIAFrIQcgBigCRCIJIAJJBEAgCiAJQQF0IgEgAkHA////A3FBQGsgAiACQT9xGyIJIAEgCUsbEOgZIAYoAkwhAQsgBwRAIAYoAkggAWpBACAH/AsACyAGIAI2AkwLIAYgBDYCUEEAIQQgBigCPCICIAYoAjRHDQRBqMWDASEBDAMLIAEgBigCKCIHTw0SIAQoAhwgAkECdGooAgAiAiAGKAIkIAFBDGxqIgEoAggiBE8NASABKAIEIAJBAnRqKAIAIQQCQCAGKAJABEAgBigCUCIHQQFqIglBA3YgCUEHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEMIAYoAkQiDyACSQRAIAogD0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiDyABIA9LGxDoGSAGKAJMIQELIAwEQCAGKAJIIAFqQQAgDPwLAAsgBiACNgJMCyAGIAk2AlAgBigCSCAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAQsgBiAGKAJUQQFqNgJUCyAGKAI8IgIgBigCNEcNA0G4xYMBIQEMAgsMDwsgAiAEQYjpgwEQwyEACyAGQTRqIAEQnSgLIAYoAjggAkECdGogBDYCACAGIAJBAWo2AjwgA0EIaiIDIAtHDQALIAZBsAFqIgEgBkE0aiICENQUIAZB6ABqIgMgASAGKAIsIAYoAjAQxxVB0ABBBBCtNiIBRQ0PIAFCgYCAgBA3AgAgAUEIaiADQcgA/AoAACAQQajtgwE2AgggECABNgIEIBBBk4CAgHg2AgAgAhDpOyAGKAJABEAgChDPLwsgBkHcAGoQuQwgBkEgaiIBELArIAFBBEEMEOAeIAZBFGoiARDCJyABQQRBFBDgHgsgBkEIakEEQQQQ4B4gBkHgAWokACASKAJAIQEgEigCPCECIBIoAjgiA0GTgICAeEcEQCAAIBIpAkQ3AgwgACABNgIIIAAgAjYCBCAAIAM2AgAMAwsgAiABEJosIQEgAEH4y4MBNgIIIAAgATYCBCAAQZOAgIB4NgIADAILIwBB4AFrIgYkACMAQSBrIgUkACAFQRRqIAEgAkEDdGoiCSABa0EDdkEAQQRBBBCgGCAFKAIYIQcgBSgCFEEBRg0QIAVBEGoiD0EANgIAIAUgBSgCHDYCDCAFIAc2AggjAEEQayIIJAAgCSABa0EDdiIQIAVBCGoiCigCACAKKAIIIgdrSwRAIAogByAQQQRBBBDeKCAKKAIIIQcLIBJBOGohECAGQQhqIQsgCCAKKAIENgIMIAggBzYCCCAIIApBCGo2AgQgCEEEaiIMKAIEIQogDCgCACAJIAEiB0cEQCAMKAIIIApBAnRqIQwgCiAJIAFrQQN2IglqIQoDQCAMIAcoAgAgB0EEaigCABCGIjYCACAHQQhqIQcgDEEEaiEMIAlBAWsiCQ0ACwsgCjYCACAIQRBqJAAgC0EIaiAPKAIANgIAIAsgBSkCCDcCACAFQSBqJAACQCAGKAIMIgggBigCECIFIAQQ4w9FBEAgECABIAIgAyAEEP0PDAELIAYgBDYCRCAGIAM2AkAgBkEANgI8IAYgCDYCNCAGIAggBUECdGo2AjggBkEUaiIBIAZBNGoiAhD5GiACIAggBSAGKAIYIAYoAhwQwAIgBkG4AWoiAiAGQUBrIgopAgA3AwAgBkHAAWoiByAGQcgAaigCADYCACAGIAYpAjg3A7ABIAYoAjRBAUYEQCAQIAYpA7ABNwIAIBBBEGogBygCADYCACAQQQhqIAIpAwA3AgAgARDCJyABQQRBFBDgHgwBCyAGQTBqIAcoAgA2AgAgBkEoaiACKQMANwMAIAYgBikDsAE3AyAgBkE0aiAEEO8eIAMgBEEDdGohDANAAkACQCAFIAMoAgAiAUsEQAJAIAggAUECdGooAgAiCUEMaiADQQRqKAIAIgIQizsEQCACIAkoAiBBA3YiB0kNAQwPCyAKEOY6IAYoAkBFDRAgBigCUEEBaiIEQQN2IARBB3FBAEdqIgIgBigCTCIBSwRAIAIgAWshByAGKAJEIgkgAkkEQCAKIAlBAXQiASACQcD///8DcUFAayACIAJBP3EbIgkgASAJSxsQ6BkgBigCTCEBCyAHBEAgBigCSCABakEAIAf8CwALIAYgAjYCTAsgBiAENgJQQgAhFSAGKAI8IgEgBigCNEcNA0GoxYMBIQIMAgsgASAGKAIoIgdPDRAgBigCJCABQQxsaiIHKAIIIgQgCSgCHCACQQN0aikDAKciAU0NESAHKAIEIAFBA3RqKQMAIRUCQCAGKAJABEAgBigCUCIEQQFqIgdBA3YgB0EHcUEAR2oiAiAGKAJMIgFLBEAgAiABayEJIAYoAkQiCyACSQRAIAogC0EBdCIBIAJBwP///wNxQUBrIAIgAkE/cRsiCyABIAtLGxDoGSAGKAJMIQELIAkEQCAGKAJIIAFqQQAgCfwLAAsgBiACNgJMCyAGIAc2AlAgBigCSCAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgBiAGKAJUQQFqNgJUCyAGKAI8IgEgBigCNEcNAkG4xYMBIQIMAQsMDQsgBkE0aiACELMoCyAGKAI4IAFBA3RqIBU3AwAgBiABQQFqNgI8IANBCGoiAyAMRw0ACyAGQbABaiIBIAZBNGoiAhDZFCAGQegAaiIDIAEgBigCLCAGKAIwEMcVQdAAQQQQrTYiAUUNDiABQoGAgIAQNwIAIAFBCGogA0HIAPwKAAAgEEHI6oMBNgIIIBAgATYCBCAQQZOAgIB4NgIAIAIQ4zwgBigCQARAIAoQzy8LIAZB3ABqELkMIAZBIGoiARDWKyABQQRBDBDgHiAGQRRqIgEQwicgAUEEQRQQ4B4LIAZBCGpBBEEEEOAeIAZB4AFqJAAgEigCQCEBIBIoAjwhAiASKAI4IgNBk4CAgHhHBEAgACASKQJENwIMIAAgATYCCCAAIAI2AgQgACADNgIADAILIAIgARCaLCEBIABB+MuDATYCCCAAIAE2AgQgAEGTgICAeDYCAAwBCyAAIAEgAiADIAQQ/Q8LIBJB0ABqJAAPC0EEQTgQoz0ACyABIAYoAqABQcDkgwEQ/S8ACyACIAYoAqABQfDkgwEQ/S8ACyACIAVB2OWDARDDIQALQQRBxAAQoz0ACyABIAYoAsABQYDugwEQ/S8ACyACIAdB6OiDARDDIQALIAEgBUHY6IMBEMMhAAtByMWDARCyOwALIAEgB0H46IMBEMMhAAsgASAEQYjpgwEQwyEAC0EEQdAAEKM9AAsgAiABKAIcQcjLgwEQ/S8ACyADIAEoAhxByMuDARD9LwALIAcgBSgCHEHIy4MBEP0vAAtB7LSCARCyOwALIAkgD0H8tIIBEMMhAAsgAiAJEP07NgIcDAELIAIgCRD/OzYCHAsgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywAC5YRAQx/IwBBIGsiBiQAIAFB/wFxIQsCQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAkACQAJAIAAoAhwiAigCJCIDQYYCTwRAIAIoAhAhAwwBCyACKAIgIgRBAXQhCCAEQYYCayEJA0ACQCACKAJQIAMgAigCECIFamshAwJAAkACQAJAAkACQAJAAkACQCAJIAIoAiBqIAVNBEAgCCACKAIYIgVLDQEgBEEASA0CIAQEQCACKAIUIgUgBCAFaiAE/AoAAAsgAiACLwEMIgUgBEH//wNxIgdrIgpBACAFIApPGzsBDCAFIAdNBEAgAkEAOwE0CyACIAIoAhAgBGsiBTYCECACIAIoAjwgBGs2AjwgAiAFIAIoAoABIgcgBSAHSRs2AoABIAIQlBYgAyAEaiEDCyAAKAIERQRAIAAoAhwhAgwKCyADQQFNDQIgACAAKAIcIgIoAiQgAigCEGogAxDMEyEDIAAoAhwiAiADIAIoAiRqIgM2AiQgAyACKAKAASIDakEDSQ0IIAIoAhAiByADayEFIAIvATZBgAhNBEAgAyAHRg0IIAVBAWshAyACLQAGQQFGBEAgAiADENkZGgwJCyACKAIYIgcgA0kNBCAHIANrIgdBA00NBSACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgovAQAiDCADQf//A3FGDQggAigCIEEBayADcSIHIAIoAiwiDU8NBiACKAIoIAdBAXRqIAw7AQAgCiADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0H8+fwAEMMhAAsgBUEBaiIHIANJDQYgByADQYz6/AAQwyEACyAIIAVBvPn8ABCwOwALIAZBADYCGCAGQQE2AgwgBkH09fwANgIIIAZCBDcCECAGQQhqQcz5/AAQ7ywACyAGQQA2AhggBkEBNgIMIAZB5Pn8ADYCCCAGQgQ3AhAgBkEIakHs+fwAEO8sAAsgAyAHQZz2/AAQrzsAC0EEIAdBrPb8ABCwOwALIAcgDUG89vwAEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAHai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiRBAUZrIgNFDQACQCACLQAGQQFGBEAgAiAFIAMQ4BMMAQsgAiAFIAMQ6xQLIAIgAigCgAEgA2s2AoABCyAAKAIcIgIoAiQiA0GFAksNACAAKAIEDQELCyACKAIQIgMgAigCUEGGAmtLBEAgBkEANgIYIAZBATYCDCAGQbj6/AA2AgggBkIENwIQIAZBCGpBwPr8ABDvLAALIAIoAiQiBEGGAk8NACALRQRAQQAhAgwFCyAERQRAIAJBAiADIANBAk8bNgKAASABQf8BcUEERwRAIAAoAhwoAkgEQEEAIQIgAEEAEJIBIAAoAhBFDQcLQQEhAgwGCyAAQQEQkgFBA0ECIAAoAhAbIQIMBQsgBEEDSw0AIAIoAhgiBCADSwRAIAIoAhQgA2otAAAhBQwCCyADIARB/PX8ABDDIQALIANBBGohBCADQXtLDQUgBCACKAIYIgVLDQYgAigCFCADaigAACIFQbHz3fF5bEEQdkEBdCIHIAIoAjBqLwEAIgQgA0H//wNxRwRAIAIoAiBBAWsgA3EiCCACKAIsIglPDQggAigCKCAIQQF0aiAEOwEAIAIoAjAgB2ogAzsBACAAKAIcIgIoAhAhAwsgBEUNACADIARrIgNBAEwNACADIAIoAiBBhgJrSg0AIAYgAiAEEJMHIAYoAgAhAyAAKAIcIAYvAQQ7AQwgACgCHCECIANBBEkNACACKAJEIgUgAigCSCIESQ0IIAUgBGsiBUECTQ0JIAIvAQwhCCACKAIQIQcgAigCQCAEaiIFIANBA2siBDoAAiAFIAcgCGsiCEEIdjoAASAFIAg6AAAgAiACKAJIQQNqNgJIIAJB/wEgAi0AOkEBaiIFIAVB/wFPGzoAOiAIQQFrIgUgAigCIEGGAmtPDQogBRDKKkH/AXFBHk8NCiAEQYACTw0LIAIgBEGc9/wAai0AAEECdGpBrAlqIgQgBC8BAEEBajsBACAFEMoqQf8BcSIEQT1PDQwgAiAEQQJ0aiIEIAQvAaQTQQFqOwGkEyACKAJIIQUgAigCRCEIIAAoAhwiAiACKAIkIANrNgIkIAAoAhwiAi8BOCADTwRAIAIoAiRBA0sNAgsgAiACKAIQIANqNgIQIAAoAhwiAigCGCIEIAIoAhBBAWsiA0kNDSAEIANrIgRBA00NDiACKAIwIAIoAhQgA2ooAABBsfPd8XlsQQ92Qf7/B3FqIgcvAQAiCSADQf//A3FGDQIgAigCIEEBayADcSIEIAIoAiwiCk8NDyACKAIoIARBAXRqIAk7AQAgByADOwEADAILIAJBQGsgAkGkAWogBRCWIyAAKAIcIgMgAygCJEEBazYCJCAAKAIcIgMgAygCEEEBajYCEEUNA0EAIQIgAEEAEJIBIAAoAhANAwwCCyACIAIoAhBBAWo2AhAgA0EBayECIAAoAhwiAygCECEEAkAgAy0ABkEBRgRAIAMgBCACEOATDAELIAMgBCACEOsUCyAAKAIcIgMgAygCECACajYCEAsgBSAIQQNrRw0BQQAhAiAAQQAQkgEgACgCEA0BCwsgBkEgaiQAIAIPCyADIARBjPb8ABCxOwALIAQgBUGM9vwAELA7AAsgCCAJQbz2/AAQwyEACyAEIAVBzPb8ABCvOwALQQMgBUHc9vwAELA7AAsgBkEANgIYIAZBATYCDCAGQYT3/AA2AgggBkIENwIQIAZBCGpBjPf8ABDvLAALIARBgAJBnPn8ABDDIQALIARBPUGs+fwAEMMhAAsgAyAEQZz2/AAQrzsAC0EEIARBrPb8ABCwOwALIAQgCkG89vwAEMMhAAuJEAIMfwF+QQohBiMAQcABayIFJAAgBSADOgALIAEgAhDkISELIAUgA8AiAjYCQCAFQQo2ArABAkACQAJAAkAgA0H/AXFFBEBBASEDDAELQQEhAwNAAkAgAkEBcQRAIAOsIAasfiIRQiCIpyARpyIDQR91Rw0BIAJBAUYNAwsgBqwiESARfiIRQiCIpyARpyIGQR91Rw0AIAJBAXYhAgwBCwsgBUECNgIQIAVBiJiAATYCDCAFQgI3AhggBUH6DzYCcCAFQfwPNgJoIAUgBUHkAGoiATYCFCAFIAVBQGsiAjYCbCAFIAVBsAFqNgJkIAVBoAFqIgMgBUEMaiIEEJkOIAUoAqABIQcgBUH0AGogBUGsAWoiBigCADYCACAFIAUpAqQBNwJsIAUgBzYCaCAFQYiAgIB4NgJkIAVBAzYCECAFQaylgAE2AgwgBUICNwIYIAVB9As2AkwgBUHEDTYCRCAFQdydgAE2AkAgBSACNgIUIAUgBUELajYCSCADIAQQmQ4gARCIESAAIAUpAqQBNwIIIABBEGogBigCADYCACAAIAUoAqABNgIEIABBgoCAgHg2AgAMAQsgBUEMaiALQQxqIg8Q2zwQ+R4gBC0ANCEBIA8Q2zwhDgJAIAFFBEAgDkUNASAFQRhqIQwgA0F/RyENQQAhBEEAIQICQANAAkACQCAFQQxqAn8CQCALIAIQhyVFBEAgBSACNgKwASAPENs8IAJNDQQgCygCECAEaigCACEBIAUgAzYCsAEgBSABNgKYASADBH8gDSABQYCAgIB4R3INAiAFQQI2AmggBUH0l4ABNgJkIAVCAjcCcCAFQfwPNgJMIAVB/A82AkQgBSAFQUBrNgJsIAUgBUGwAWo2AkggBSAFQZgBajYCQCAFQaABaiAFQeQAahCZDiAFQeAAaiAFQawBaigCADYCACAFIAUpAqQBNwNYIAUoAqABIQdBiICAgHgFQYeAgIB4CyEBIAAgBzYCBCAAIAE2AgAgACAFKQNYNwIIIABBEGogBUHgAGooAgA2AgAgBUEMahC5LQwJCyAMEOY6IAUoAhhFDQUgBSgCKEEBaiIIQQN2IAhBB3FBAEdqIgYgBSgCJCIBSwRAIAYgAWshCiAFKAIcIgkgBkkEQCAMIAlBAXQiASAGQcD///8DcUFAayAGIAZBP3EbIgkgASAJSxsQ6BkgBSgCJCEBCyAKBEAgBSgCICABakEAIAr8CwALIAUgBjYCJAsgBSAINgIoQQAhASAFKAIUIgYgBSgCDEcNAkH0koABDAELIAEgA20hAQJAIAUoAhgEQCAFKAIoIghBAWoiCkEDdiAKQQdxQQBHaiIGIAUoAiQiB0sEQCAGIAdrIQkgBSgCHCIQIAZJBEAgDCAQQQF0IgcgBkHA////A3FBQGsgBiAGQT9xGyIQIAcgEEsbEOgZIAUoAiQhBwsgCQRAIAUoAiAgB2pBACAJ/AsACyAFIAY2AiQLIAUgCjYCKCAFKAIgIAhBA3ZqIgcgBy0AAEEBIAhBB3F0cjoAAAwBCyAFIAUoAixBAWo2AiwLIAUoAhQiBiAFKAIMRwRAIAEhBwwCCyABIQdBhJOAAQsQnSgLIAUoAhAgBkECdGogATYCACAFIAZBAWo2AhQgBEEEaiEEIA4gAkEBaiICRw0BDAQLCwwFC0GglYABELI7AAsgDkUNACAFQRhqIQcgBUGgAWohCiADQX9HIQlBACEGQQAhAgJAA0ACQAJAIAsgAhCHJUUEQCAFIAI2ArABIA8Q2zwgAk0NAiALKAIQIAZqKAIAIQQgBSADNgKYASAFIAQ2ApQBIAVBDGoCfwJAIAMEQCAJRSAEQYCAgIB4RnFFBEAgBCADbSEEQQEMAwsgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCvAEgBUH8DzYCtAEgBSAFQbABajYCbCAFIAVBmAFqNgK4ASAFIAVBlAFqNgKwASAKIAVB5ABqEJkOIAVByABqIAVBpAFqKQIANwMAIAVB0ABqIAVBrAFqKAIANgIAIAVBiICAgHg2ApwBIAUgBSkCnAEiETcDQCARp0GTgICAeEcNASAFKAJEIQRBAQwCCyAFQYeAgIB4NgJACyAFQUBrEIgRQQALIAQQ3wsMAQsgBxDmOiAFKAIYRQ0DIAUoAihBAWoiDEEDdiAMQQdxQQBHaiIEIAUoAiQiAUsEQCAEIAFrIQggBSgCHCINIARJBEAgByANQQF0IgEgBEHA////A3FBQGsgBCAEQT9xGyINIAEgDUsbEOgZIAUoAiQhAQsgCARAIAUoAiAgAWpBACAI/AsACyAFIAQ2AiQLIAUgDDYCKCAFKAIUIgEgBSgCDEYEQCAFQQxqQfSSgAEQnSgLIAUoAhAgAUECdGpBADYCACAFIAFBAWo2AhQLIAZBBGohBiAOIAJBAWoiAkcNAQwDCwsMBAtBoJWAARCyOwALIAVB5ABqIgIgBUEMaiIDENAUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB+KKAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELktCyAFQcABaiQADwtBBEE4EKM9AAsgBSALEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEgBUHkAGpB5JKAARDvLAAL3xACDH8CfkEKIQYjAEHAAWsiBSQAIAUgAzoACyABIAIQ5CEhASAFIAPAIgI2AkAgBUEKNgKwAQJAAkACQAJAIANB/wFxRQRAQQEhAwwBC0EBIQMDQAJAIAJBAXEEQCADrCAGrH4iEUIgiKcgEaciA0EfdUcNASACQQFGDQMLIAasIhEgEX4iEUIgiKcgEaciBkEfdUcNACACQQF2IQIMAQsLIAVBAjYCECAFQYiYgAE2AgwgBUICNwIYIAVB+g82AnAgBUH8DzYCaCAFIAVB5ABqIgE2AhQgBSAFQUBrIgI2AmwgBSAFQbABajYCZCAFQaABaiIDIAVBDGoiBBCZDiAFKAKgASEGIAVB9ABqIAVBrAFqIggoAgA2AgAgBSAFKQKkATcCbCAFIAY2AmggBUGIgICAeDYCZCAFQQM2AhAgBUGspYABNgIMIAVCAjcCGCAFQfQLNgJMIAVBxA02AkQgBUHcnYABNgJAIAUgAjYCFCAFIAVBC2o2AkggAyAEEJkOIAEQiBEgACAFKQKkATcCCCAAQRBqIAgoAgA2AgAgACAFKAKgATYCBCAAQYKAgIB4NgIADAELIAVBDGogAUEMaiIPENs8EPgeIAQtADQhAiAPENs8IQ4CQCACRQRAIA5FDQEgBUEYaiEMIANBf0chDUEAIQRBACECAkADQAJAAkAgBUEMagJ/AkAgASACEIclRQRAIAUgAjYCsAEgDxDbPCACTQ0EIAEoAhAgBGooAgAhBiAFIAM2ArABIAUgBjYCmAEgAwR/IA0gBkGAgICAeEdyDQIgBUECNgJoIAVB9JeAATYCZCAFQgI3AnAgBUH8DzYCTCAFQfwPNgJEIAUgBUFAazYCbCAFIAVBsAFqNgJIIAUgBUGYAWo2AkAgBUGgAWogBUHkAGoQmQ4gBUHgAGogBUGsAWooAgA2AgAgBSAFKQKkATcDWCAFKAKgASEIQYiAgIB4BUGHgICAeAshASAAIAg2AgQgACABNgIAIAAgBSkDWDcCCCAAQRBqIAVB4ABqKAIANgIAIAVBDGoQui0MCQsgDBDmOiAFKAIYRQ0FIAUoAihBAWoiCUEDdiAJQQdxQQBHaiIHIAUoAiQiBksEQCAHIAZrIQsgBSgCHCIKIAdJBEAgDCAKQQF0IgYgB0HA////A3FBQGsgByAHQT9xGyIKIAYgCksbEOgZIAUoAiQhBgsgCwRAIAUoAiAgBmpBACAL/AsACyAFIAc2AiQLIAUgCTYCKEIAIREgBSgCFCIGIAUoAgxHDQJB9JKAAQwBCyAGIANtIQgCQCAFKAIYBEAgBSgCKCIJQQFqIgtBA3YgC0EHcUEAR2oiByAFKAIkIgZLBEAgByAGayEKIAUoAhwiECAHSQRAIAwgEEEBdCIGIAdBwP///wNxQUBrIAcgB0E/cRsiECAGIBBLGxDoGSAFKAIkIQYLIAoEQCAFKAIgIAZqQQAgCvwLAAsgBSAHNgIkCyAFIAs2AiggBSgCICAJQQN2aiIGIAYtAABBASAJQQdxdHI6AAAMAQsgBSAFKAIsQQFqNgIsCyAIrCERIAUoAhQiBiAFKAIMRw0BQYSTgAELELMoCyAFKAIQIAZBA3RqIBE3AwAgBSAGQQFqNgIUIARBBGohBCAOIAJBAWoiAkcNAQwECwsgBSABEPw7NgJAIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUFAazYCpAEgBSAFQbABajYCnAEMBQtBoJWAARCyOwALIA5FDQAgBUEYaiEHIAVBoAFqIQsgA0F/RyEKQQAhBkEAIQIDQAJAIAVBDGoCfgJAAkACQCABIAIQhyVFBEAgBSACNgKYASAPENs8IAJNDQEgASgCECAGaigCACEEIAUgAzYCmAEgBSAENgKUAQJAIAMEQCAKRSAEQYCAgIB4RnFFBEAgBCADbSEEDAYLIAVBAjYCaCAFQfSXgAE2AmQgBUICNwJwIAVB/A82ArwBIAVB/A82ArQBIAUgBUGwAWo2AmwgBSAFQZgBajYCuAEgBSAFQZQBajYCsAEgCyAFQeQAahCZDiAFQcgAaiAFQaQBaikCADcDACAFQdAAaiAFQawBaigCADYCACAFQYiAgIB4NgKcASAFIAUpApwBIhE3A0AgEadBk4CAgHhHDQEgBSgCRCEEDAULIAVBh4CAgHg2AkALIAVBQGsQiBFCAAwECyAHEOY6IAUoAhhFDQEgBSgCKEEBaiIMQQN2IAxBB3FBAEdqIgQgBSgCJCIISwRAIAQgCGshCSAFKAIcIg0gBEkEQCAHIA1BAXQiCCAEQcD///8DcUFAayAEIARBP3EbIg0gCCANSxsQ6BkgBSgCJCEICyAJBEAgBSgCICAIakEAIAn8CwALIAUgBDYCJAsgBSAMNgIoIAUoAhQiBCAFKAIMRgRAIAVBDGpB9JKAARCzKAsgBSgCECAEQQN0akIANwMAIAUgBEEBajYCFAwECyAFIAEQ/Ds2ArABIAVBAjYCaCAFQdSSgAE2AmQgBUICNwJwIAVBOzYCqAEgBUE7NgKgASAFIAVBnAFqNgJsIAUgBUGwAWo2AqQBIAUgBUGYAWo2ApwBDAgLQaCVgAEQsjsACyAErCESQgELIBIQ2gsLIAZBBGohBiAOIAJBAWoiAkcNAAsLIAVB5ABqIgIgBUEMaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQcABaiQADwtBBEE4EKM9AAsgBUHkAGpB5JKAARDvLAALrhYDBn8DfgF8IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEH85s4ANgI4IARCATcCRCAEQYkINgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARCTEiAELQA8IQUgBCgCOCICQQRHBEAgBEE/ai0AACEDIAQvAD0hBiAEKQJEIQogAEELaiAEKAJAIgFBGHY6AAAgACABQQh2OwAJIAAgCjcCDCAAIAE6AAggACACNgIAIAAgA0EYdCAGQQh0ciAFcjYCBAwMCyAEKAJAIgJBAEoEQCADQQFrIQMDQCAEQThqIAEgBSADELMCIAQoAjgiBkEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBjYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqIAEQkxIgBC0APCEFIAQoAjgiAkEERwRAIARBP2otAAAhAyAELwA9IQYgBCkCRCEKIABBC2ogBCgCQCIBQRh2OgAAIAAgAUEIdjsACSAAIAo3AgwgACABOgAIIAAgAjYCACAAIANBGHQgBkEIdHIgBXI2AgQMCwsgBCgCQCICQQBKBEAgA0EBayEDA0AgBEE4aiABIAUgAxCzAiAEKAI4IgZBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAY2AgAMDQsgAkEBayICDQALCyAAQQQ2AgAMCgsgBEE4aiEFIwBBIGsiAiQAIAJBCGogAUEMahD/EwJAAkACfyACLQAIQQRGBEAgAigCDAwBCyACKQMIIgpC/wGDQgRSDQEgCkIgiKcLIglFBEAgBUEEakEQQRBBABD1NCAFQQQ2AgAMAgsgAkEIaiABEJsTIAItAAwhBiACKAIIIgdBBEcEQCAFIAIpAA03AAUgBUEMaiACQRRqKQAANwAAIAUgBjoABCAFIAc2AgAMAgsgAkEIaiAGQfABcUEEdhCuLSACLQAMIQcgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAc6AAQgBSAINgIADAILIAJBCGogBkEPcRCuLSACLQAMIQYgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAY6AAQgBSAINgIADAILIAVBBGogByAGIAkQ9TQgBUEENgIADAELIAIgCjcDCCAFIAJBCGoQ0AkLIAJBIGokACAEKQI8IQogBCgCOCICQQRHBEAgACAEKQJENwIMIAAgCjcCBCAAIAI2AgAMCgsCQAJAIAqnIgJBAEoEQCAKQiCIpyIFQf8BcUEQRg0CIApCKIinIgZB/wFxQRBGDQEgA0EBayEDA0AgBEE4aiABIAUgAxCzAiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgBEE4aiABIAYgAxCzAiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgAkEBayICDQALCyAAQQQ2AgAMCwtBwOfOAEEsQeznzgAQyyQAC0GE584AQSpBsOfOABDLJAALIARBOGogARDxJyAEQShqIgIgBEHEAGoiBSgCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgNwMIIARBCGoQhjAgBEE4aiABELIOIAIgBSkCADcDACAEQTBqIgIgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQYgBEE8aiEDA0AgBEEYaiACKAIAIgU2AgAgBEEQaiAEQShqIgcpAwA3AwAgBCAEKQMgNwMIIAVB/wFxRQ0CIARBOGogASAFIAYQswIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIAIARBCGoQhjAMDAsgBEEIahCGMCAEQThqIAEQsg4gByADQQhqKQIANwMAIAIgA0EQaigCADYCACAEIAMpAgA3AyAgBCgCOEUNAAsLIAAgBCkDIDcCACAAQRBqIAIoAgA2AgAgAEEIaiAEQShqKQMANwIADAkLIARBCGoQhjAgACABEKopDAgLIARBOGohBiMAQSBrIgUkACAFQQxqIAEQ6Q8gBSgCGCECIAUoAhQhASAFKAIQIQMCQCAFKAIMIgdBBEcEQCAGIAUoAhw2AhAgBiACNgIMIAYgATYCCCAGIAM2AgQgBiAHNgIADAELIAVBDGogASACEJ0JAkACQCAFKAIMRQRAIAKtIQogASECDAELIAUpAhAhCiADQYCAgIB4Rw0BIAEhAwsgBiAKPgIMIAYgAjYCCCAGIAM2AgQgBkEENgIADAELIAUgCjcCGCAFIAI2AhQgBSABNgIQIAUgAzYCDCAGIAVBDGoQyBwLIAVBIGokACAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAgLIARBKGogBEHEAGooAgA2AgAgBCAEKQI8NwMgIARBIGoQ3jsgAEEENgIADAcLIARBOGogARCRIyAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwHCyAAQQQ2AgAMBgsgBEE4aiABEIkmIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMBgsgAEEENgIADAULIARBOGogARCGJiAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAULIABBBDYCAAwECyAEQThqIQMjAEEQayICJAAgASgCDCIBKAIEIgetIQoCQAJAIAdC/////w8gASkDCCILIAtC/////w9aG6drIgVBACAFIAdNG0EITwRAIAEoAgAgCyAKIAogC1Ybp2orAAAhDUEEIQcMAQtBqKHQACkCACIMpyIHQQh2IQYgDEIgiKchBSAMQv8Bg0IEUg0BCyALQgh8IQoLIAEgCjcDCCADAn8gB0H/AXEiAUEERwRAIAIgBTYCDCACIAZBCHQgAXI2AgggA0EEaiACQQhqENAJQQEMAQsgAyANOQMIQQALNgIAIAJBEGokACAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwECyAAQQQ2AgAMAwsgBEE4aiABEJsTIAQoAjgiAUEERwRAIAAgBCkAPTcABSAAQQxqIARBxABqKQAANwAAIAAgBC0APDoABAsgACABNgIADAILIARBOGogARDrEyAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAILIABBBDYCAAwBCyAEIAI6ADcgBEEBNgI8IARBlOjOADYCOCAEQgE3AkQgBEG6BzYCJCAEIARBIGo2AkAgBCAEQQhqNgIgIAQgBEE3ajYCCCAAQQRqIARBOGoQmQ4gAEEAOgAQIABBATYCAAsgBEHQAGokAAvCFQIGfwF+IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEH85s4ANgI4IARCATcCRCAEQYkINgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARCSEiAELQA8IQUgBCgCOCICQQRHBEAgBEE/ai0AACEDIAQvAD0hBiAEKQJEIQogAEELaiAEKAJAIgFBGHY6AAAgACABQQh2OwAJIAAgCjcCDCAAIAE6AAggACACNgIAIAAgA0EYdCAGQQh0ciAFcjYCBAwMCyAEKAJAIgJBAEoEQCADQQFrIQMDQCAEQThqIAEgBSADELQCIAQoAjgiBkEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBjYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqIAEQkhIgBC0APCEFIAQoAjgiAkEERwRAIARBP2otAAAhAyAELwA9IQYgBCkCRCEKIABBC2ogBCgCQCIBQRh2OgAAIAAgAUEIdjsACSAAIAo3AgwgACABOgAIIAAgAjYCACAAIANBGHQgBkEIdHIgBXI2AgQMCwsgBCgCQCICQQBKBEAgA0EBayEDA0AgBEE4aiABIAUgAxC0AiAEKAI4IgZBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAY2AgAMDQsgAkEBayICDQALCyAAQQQ2AgAMCgsgBEE4aiEFIwBBIGsiAiQAIAJBCGogAUEMahCNFAJAAkACfyACLQAIQQRGBEAgAigCDAwBCyACKQMIIgpC/wGDQgRSDQEgCkIgiKcLIglFBEAgBUEEakEQQRBBABD1NCAFQQQ2AgAMAgsgAkEIaiABEMQZIAItAAwhBiACKAIIIgdBBEcEQCAFIAIpAA03AAUgBUEMaiACQRRqKQAANwAAIAUgBjoABCAFIAc2AgAMAgsgAkEIaiAGQfABcUEEdhCuLSACLQAMIQcgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAc6AAQgBSAINgIADAILIAJBCGogBkEPcRCuLSACLQAMIQYgAigCCCIIQQRHBEAgBSACKQANNwAFIAVBDGogAkEUaikAADcAACAFIAY6AAQgBSAINgIADAILIAVBBGogByAGIAkQ9TQgBUEENgIADAELIAIgCjcDCCAFIAJBCGoQ0AkLIAJBIGokACAEKQI8IQogBCgCOCICQQRHBEAgACAEKQJENwIMIAAgCjcCBCAAIAI2AgAMCgsCQAJAIAqnIgJBAEoEQCAKQiCIpyIFQf8BcUEQRg0CIApCKIinIgZB/wFxQRBGDQEgA0EBayEDA0AgBEE4aiABIAUgAxC0AiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgBEE4aiABIAYgAxC0AiAEKAI4IgdBBEcEQCAAIAQpAjw3AgQgAEEMaiAEQcQAaikCADcCACAAIAc2AgAMDgsgAkEBayICDQALCyAAQQQ2AgAMCwtBwOfOAEEsQeznzgAQyyQAC0GE584AQSpBsOfOABDLJAALIARBOGogARDxJyAEQShqIgIgBEHEAGoiBSgCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgNwMIIARBCGoQhjAgBEE4aiABELMOIAIgBSkCADcDACAEQTBqIgIgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQYgBEE8aiEDA0AgBEEYaiACKAIAIgU2AgAgBEEQaiAEQShqIgcpAwA3AwAgBCAEKQMgNwMIIAVB/wFxRQ0CIARBOGogASAFIAYQtAIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIAIARBCGoQhjAMDAsgBEEIahCGMCAEQThqIAEQsw4gByADQQhqKQIANwMAIAIgA0EQaigCADYCACAEIAMpAgA3AyAgBCgCOEUNAAsLIAAgBCkDIDcCACAAQRBqIAIoAgA2AgAgAEEIaiAEQShqKQMANwIADAkLIARBCGoQhjAgACABEKopDAgLIARBOGohBiMAQSBrIgUkACAFQQxqIAEQ6A8gBSgCGCECIAUoAhQhASAFKAIQIQMCQCAFKAIMIgdBBEcEQCAGIAUoAhw2AhAgBiACNgIMIAYgATYCCCAGIAM2AgQgBiAHNgIADAELIAVBDGogASACEJ0JAkACQCAFKAIMRQRAIAKtIQogASECDAELIAUpAhAhCiADQYCAgIB4Rw0BIAEhAwsgBiAKPgIMIAYgAjYCCCAGIAM2AgQgBkEENgIADAELIAUgCjcCGCAFIAI2AhQgBSABNgIQIAUgAzYCDCAGIAVBDGoQyBwLIAVBIGokACAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAgLIARBKGogBEHEAGooAgA2AgAgBCAEKQI8NwMgIARBIGoQ3jsgAEEENgIADAcLIARBOGogARCSIyAEKAI4QQFGBEAgACAEKQI8NwIAIABBEGogBEHMAGooAgA2AgAgAEEIaiAEQcQAaikCADcCAAwHCyAAQQQ2AgAMBgsgBEE4aiABEIgmIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMBgsgAEEENgIADAULIARBOGogARCHJiAEKAI4QQRHBEAgACAEKQI4NwIAIABBEGogBEHIAGooAgA2AgAgAEEIaiAEQUBrKQIANwIADAULIABBBDYCAAwECyMAQRBrIgIkACACQgA3AwAgAkEIaiIDIAEoAgwgAkEIEJshIARBOGoiAQJ/AkAgAi0ACEEERg0AIAIxAAhCBFENACACKAIIIQUgAiACKAIMNgIMIAIgBTYCCCABQQRqIAMQ0AlBAQwBCyABIAIrAwA5AwhBAAs2AgAgAkEQaiQAIAQoAjhBAUYEQCAAIAQpAjw3AgAgAEEQaiAEQcwAaigCADYCACAAQQhqIARBxABqKQIANwIADAQLIABBBDYCAAwDCyAEQThqIAEQxBkgBCgCOCIBQQRHBEAgACAEKQA9NwAFIABBDGogBEHEAGopAAA3AAAgACAELQA8OgAECyAAIAE2AgAMAgsgBEE4aiABEOwTIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMAgsgAEEENgIADAELIAQgAjoANyAEQQE2AjwgBEGU6M4ANgI4IARCATcCRCAEQboHNgIkIAQgBEEgajYCQCAEIARBCGo2AiAgBCAEQTdqNgIIIABBBGogBEE4ahCZDiAAQQA6ABAgAEEBNgIACyAEQdAAaiQAC9cVAgh/BH4jAEGAA2siBSQAIAUgAzoAIyAFIAI6ACIgBSABNgIcAkACQAJAAkACQAJAIAQtADRFBEAgBUHwAWoiAiAFQRxqEPopIAUgBUEiajYCmAIgBSAFQSNqNgKUAiAFQcwCaiEIIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASACQSz8CgAAIAMgAzYCTCADQRRqIQojAEHwAGsiAiQAIAJBEGoiCSABEOwUAkACQAJAIAIpAxggAikDEEIChYRQRQRAIAJBQGsiBCABEKMqIARBBCACKAJAQQFqIgZBfyAGGyIGIAZBBE0bQQBBEEEwEKAYIAIoAkQhBiACKAJAQQFGDQIgAigCSCIHIAlBMPwKAAAgAkEMaiILQQE2AgAgAiAHNgIIIAIgBjYCBCAEIAFBMPwKAAAjAEFAaiIBJAAgASAEEOwUIAEpAwggASkDAEIChYRQRQRAIAJBBGohBgNAAkAgBigCCCIJIAYoAgBHDQAgAUE0aiAEEKMqIAEoAjRBAWoiB0F/IAcbIgcgBigCACAGKAIIIgxrTQ0AIAYgDCAHQRBBMBDeKAsgBigCBCAJQTBsaiABQTD8CgAAIAYgCUEBajYCCCABIAQQ7BQgASkDCCABKQMAQgKFhFBFDQALCwJAIAQoAgQiBkUNACAGIAYoAgAiBkEBazYCACAGQQFHDQAgBEEEahD7HgsgAUFAayQAIApBCGogCygCADYCACAKIAIpAgQ3AgAMAQsgCkEANgIIIApCgICAgIACNwIAIAEoAgQiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgAUEEahD7HgsgAkHwAGokAAwBCyAGIAIoAkhBuLWAARD9LwALAkAgAygCAEGTgICAeEcEQCAIIAMpAgA3AgAgCEEQaiADQRBqKAIANgIAIAhBCGogA0EIaikCADcCACAKEOQ8DAELIAggAykCFDcCBCAIQZOAgIB4NgIAIAhBDGogA0EcaigCADYCAAsgA0HQAGokACAFQegAaiIBIAVB2AJqKAIANgIAIAUgBSkC0AI3A2AgBSgCzAIiAkGTgICAeEYNASAFKALcAiEDIAAgBSkDYDcCCCAAIAM2AhQgACACNgIEIABBKToAACAAQRBqIAEoAgA2AgAMAwsgBUEkaiICIAVBHGoQ+ikgBUGUAWoiASACQST8CgAAIAUgBUEiajYCvAEgBSAFQSNqNgK4ASABEJA7GiAFKAKwASEIIAEQkDshCiAFQcABaiICIAFBLPwKAAAgAhCQOxogBSgC3AEhASAFIAIQkDsgAWsiATYCuAIgBUG8AmpBfyABQQdqIgIgASACSxtBA3YQ0h8gAUEFdCIGIQQCQCAGQSBxIgEEQCAGIAFrQUBrIgQgBkkNAQtBwAAhASAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIBRQ0BCyAFKALEAiEJIAVBzAJqIAVBwAFqQSz8CgAAIAVBADYC+AIgASEDIAUoAugCIgIgBSgC7AJGDQQgBUHwAWpBBHIhBwNAAkACQAJAAkACQCAFKALQAkUNACACIAUoAuACTw0CIAUoAtQCIAUoAtwCIAJqIgtBA3ZqLQAAQf8BcyALQQdxdkEBcUUNACAFIAJBAWo2AugCDAELIAUgAkEBajYC6AIgBUEQaiAFQcwCaiACEK0qIAVB8AFqIAUoAhAgBSgCFCAFKALwAiwAABDWASAFKALwASICQQFGBEAgAkUNASAHEIgRDAELIAUpA4ACIg0gBSkDiAIiDiAFKQOQAiIPIAUpA5gCIhAgBSgC9AItAAAQ3B0NAgsgBSAFKAL4AkEBajYC+AIgA0EYakIANwMAIANBEGpCADcDACADQQhqQgA3AwAgA0IANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgBSAFKAL4AiICQQFqNgL4AiADQRhqIBA3AwAgA0EQaiAPNwMAIAMgDjcDCCADIA03AwAgCSACQQN2aiILIAstAABBASACQQdxdHI6AAALIANBIGohAyAFKALoAiICIAUoAuwCRw0ACwwEC0HAACAEEKM9AAtB5JSAAUEpIAVB8AFqQciXgAFBkJWAARDVHgALQZSTgAFBI0G4k4ABEMskAAsgBUHIAWogASgCACIBNgIAIAUgBSkDYDcDwAEgBUHwAWoiAiAFKALEASIDIAMgAUEwbGoQzwggBUHMAmogAiAFLQAiIAUtACMQoxMgBS0AzAIiAUEpRgRAIAVB8wBqIAVB4AJqKAIAIgE2AAAgBUHrAGogBUHYAmopAgAiDTcAACAFIAUpAtACIg43AGMgAEEUaiABNgAAIABBDGogDTcAACAAIA43AAQgAEEpOgAAIAVBwAFqEOQ8DAILIAAgBSkC5AI3AhggBUHvAGoiAiAFQdwCaikAADcAACAFQegAaiIDIAVB1QJqKQAANwMAIABBIGogBUHsAmopAgA3AgAgAEEoaiAFQfQCaikCADcCACAFIAUpAM0CIg03A2AgAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA03AAEgACABOgAAIAVBwAFqEOQ8DAELAkAgBSgC0AIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgBUHQAmoQ+x4LIAUgAyABa0EFdSICNgL8AiACIAUoArgCRw0BIAUoAsQCIQIgBSgCyAIhAyAFIAUpArwCNwL8ASAFQQA2AvgBIAUgAzYC9AEgBSACNgLwASAFQQhqIAVB8AFqIgkQ1zsgBSgCCCEHQRxBBBCtNiICRQ0CIAJCgYCAgBA3AgAgAiAFKQLwATcCCCACQRBqIAVB+AFqIgspAgA3AgAgAkEYaiAFQYACaiIMKAIANgIAIAUgBDYCgAIgBUKAgICAgAg3AvgBIAUgBjYC9AEgBSABNgLwASAFIAkQ1zsgBSgCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASAFKQLwATcCCCABQRBqIAspAgA3AgAgAUEYaiAMKAIANgIAIAUgAzYCxAIgBSAHNgLAAiAFIAI2ArwCQQxBBBCtNiICRQ0DIAIgBjYCCCACIAQ2AgQgAiABNgIAIAVBATYCyAEgBSACNgLEASAFQQE2AsABIAVBADYC1AIgBUKAgICAwAA3AswCIAVB8AFqIgJB6JGAASAKIAhrIAUgBUG8AmogBUHAAWogBUHMAmoiARCMEyABIAIQxRMgBUHgAGogASAFLQAiIAUtACMQoxMgBS0AYCIBQSlGBEAgBUHbAGogBUH0AGooAgAiATYAACAFQdMAaiAFQewAaikCACINNwAAIAUgBSkCZCIONwBLIABBFGogATYAACAAQQxqIA03AAAgACAONwAEIABBKToAAAwBCyAAIAUpAng3AhggBUHXAGoiAiAFQfAAaikAADcAACAFQdAAaiIDIAVB6QBqKQAANwMAIABBIGogBUGAAWopAgA3AgAgAEEoaiAFQYgBaikCADcCACAFIAUpAGEiDTcDSCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAALIAVBgANqJAAPCyAFQgA3AvwBIAVCgYCAgMAANwL0ASAFQcSRgAE2AvABQQAgBUH8AmogBUG4AmogBUHwAWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALuhgCDn8BfiMAQeACayICJAACQAJAAkACQAJAAkACQAJAAkACQCABKAIIIgMEQCACQfABaiEJIAEoAgQhCCMAQTBrIgQkACAEQQg2AgAgBCAIIANBA3RqNgIoIAQgCDYCJCAEIAQ2AiwgBEEYaiEHIwBBMGsiAyQAIANBCGogBEEkaiIFEPMnAkACQAJAIAMoAggiCwRAIAMoAgwhDSADQSBqIgpBBEEAQQRBCBCgGCADKAIkIQYgAygCIEEBRg0CIAMoAigiDCANNgIEIAwgCzYCACADQRxqIg5BATYCACADIAw2AhggAyAGNgIUIANBKGogBUEIaigCADYCACADIAUpAgA3AyAjAEEQayIFJAAgBUEIaiAKEPMnIAUoAggiDARAIANBFGohBiAFKAIMIQsDQCAGKAIIIg0gBigCAEYEQCAGQQEQ6i0LIAYoAgQgDUEDdGoiDyALNgIEIA8gDDYCACAGIA1BAWo2AgggBSAKEPMnIAUoAgQhCyAFKAIAIgwNAAsLIAVBEGokACAHQQhqIA4oAgA2AgAgByADKQIUNwIADAELIAdBADYCCCAHQoCAgIDAADcCAAsgA0EwaiQADAELIAYgAygCKEHIl88AEP0vAAsCQCAEKAIAQQhHBEAgCSAEKQMANwMAIAlBEGogBEEQaikDADcDACAJQQhqIARBCGopAwA3AwAgBxDDJyAHEOo7DAELIAkgBCkCGDcCBCAJQQg2AgAgCUEMaiAEQSBqKAIANgIACyAEQTBqJAAgAkEwaiIDIAJB/AFqKAIANgIAIAIgAikC9AE3AyggAigC8AEiBEEIRg0BIAIpA4ACIRAgACACKQMoNwIEIAAgEDcDECAAIAQ2AgAgAEEMaiADKAIANgIADAkLIAJBADYCMCACQoCAgIDAADcCKCMAQfAAayIBJAAgASACQShqIgMoAgA2AlAgASADKAIEIgQ2AkggASAENgJMIAEgBCADKAIIQQxsajYCVCABQegAaiIDQgQ3AgAgAUHgAGoiBEIANwIAIAFCgICAgMAANwJYIAFByABqIAFB2ABqIgUgAUHkAGoQ+h4gAUFAayADKQIANwMAIAFBOGogBCkCACIQNwMAIAFBGGogED4CACABQShqIAFBxABqKAIANgIAIAEgASkCWCIQNwMwIAEgEDcDECABIAEpAjw3AyAgAUEIaiABQRBqELYZIAEoAgwhAyABKAIIIQQgAUEANgJYIAJB8AFqIgkgBCADIAFBIGogBRDLHCABQfAAaiQAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAJQTT8CgAAIABB+NbQADYCCCAAIAE2AgQgAEEINgIADAgLIAJBIGogAygCACIDNgIAIAIgAikDKDcDGCADRQRAIAJB8AFqQTNBAEEBQQEQoBggAigC9AEhASACKALwAUEBRg0JIAIoAvgBIgNB/NfQAEEz/AoAACAAQTM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMBwsgA0EDdCEEIAIoAhwiAxD0LSEJAkADQCAERQ0BIARBCGshBCADEPQtIANBCGohAyAJRg0ACyACQfABakErQQBBAUEBEKAYIAIoAvQBIQEgAigC8AFBAUYNCSACKAL4ASIDQfTV0ABBK/wKAAAgAEErNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAcLIAJBkAJqIAFBDGoQxAYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACIAk2ApwCIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACKAIcIgMgAigCIEEDdGohCiMAQSBrIgUkACAFQRRqIAogA2tBA3ZBAEEEQcQAEKAYIAUoAhghBCAFKAIUQQFGBEAgBCAFKAIcQfyh0AAQ/S8ACyACQcwCaiEMIAVBEGoiDkEANgIAIAUgBSgCHDYCDCAFIAQ2AggjAEEQayIGJAAgBUEIaiIHIAogA2tBA3YiBBD+LSAGIAcpAgRCIIk3AgggBiAHQQhqNgIEIwBB0ABrIgskACAGQQRqIg0oAgQhByANKAIAIAMgCkcEQCANKAIIIAdBxABsaiEKIAQgB2ohBwNAIAtBDGoiDSADEMMtIAogDUHEAPwKAAAgCkHEAGohCiADQQhqIQMgBEEBayIEDQALCyAHNgIAIAtB0ABqJAAgBkEQaiQAIAxBCGogDigCADYCACAMIAUpAgg3AgAgBUEgaiQAIAJBKGogAkHwAWogDBD8IiABLQAcRQ0FIAJBEGogCCgCACAIKAIEKAIgEQAAIAIoAhAiBEUNASACKAIUIQVBwAAhBiAJQQN2IAlBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0ECyACQgA3ApABIAIgBjYCjAEgAiADNgKIASACQcAANgKEASACQQhqIAgoAgAgCCgCBCgCJBEAAAJAIAIoAggiAwRAIAIoAgwhCCACIAU2ApwBIAIgCDYCmAEgBSAIRg0BIAJBADYC8AFBACACQZgBaiACQZwBaiACQfABakHo1tAAEK8rAAsgBUUNBSAFQQF0IQUgAS4BGCEKA0AgBC4BACEMIAIoApQBIghBAWoiBkEDdiAGQQdxQQBHaiIBIAIoApABIgNLBEAgASADayEHIAIoAogBIgsgAUkEQCACQYQBaiALQQF0IgMgAUHA////A3FBQGsgASABQT9xGyILIAMgC0sbEOgZIAIoApABIQMLIAcEQCACKAKMASADakEAIAf8CwALIAIgATYCkAELIAIgBjYClAEgCiAMTARAIAIoAowBIAhBA3ZqIgEgAS0AAEEBIAhBB3F0cjoAAAsgBEECaiEEIAVBAmsiBQ0ACwwFCyAFRQ0EIAEuARghDCABLgEaIQsDQAJAIAMuAQAgC0oNACAELgEAIQ0gAigClAEiBkEBaiIHQQN2IAdBB3FBAEdqIgEgAigCkAEiCEsEQCABIAhrIQogAigCiAEiDiABSQRAIAJBhAFqIA5BAXQiCCABQcD///8DcUFAayABIAFBP3EbIg4gCCAOSxsQ6BkgAigCkAEhCAsgCgRAIAIoAowBIAhqQQAgCvwLAAsgAiABNgKQAQsgAiAHNgKUASAMIA1KDQAgAigCjAEgBkEDdmoiASABLQAAQQEgBkEHcXRyOgAACyADQQJqIQMgBEECaiEEIAVBAWsiBQ0ACwwEC0EEQTwQoz0AC0Gf1tAAQTZB2NbQABDLJAALQZSf0ABBKSACQfABakHUotAAQcCf0AAQ1R4AC0HAACADEKM9AAsCQAJAIAkgAigClAFGBEAgAkHwAWoiBCACQShqIgVB3AD8CgAAIAIoAowBIQEgAigCkAEhAyACIAIpAoQBNwLYAiACQQA2AtQCIAIgAzYC0AIgAiABNgLMAiACIAJBzAJqENc7IAIoAgAhCUEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCzAI3AgggAUEQaiACQdQCaikCADcCACABQRhqIAJB3AJqKAIANgIAIAIgAzYCqAEgAiAJNgKkASACIAE2AqABIAUgBCACQaABahCuFgwDCyACQfABakEsQQBBAUEBEKAYIAIoAvQBIQEgAigC8AFBAUYNASACKAL4ASIDQdDX0ABBLPwKAAAgAEEsNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIAIAJBhAFqEM8vIAJByABqEJ8MAkAgAigCWCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQdgAahD7HgsCQCACKAJkIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJB5ABqEPseCyACQTBqIgAQxScgABDoOyACQTxqIgAQpCwgABD1PAwDC0EEQRwQoz0ACwwDCyACQfABaiIBIAJBKGpB3AD8CgAAIAJBrAFqIgMgARDNHCABIAMQhhdBPEEEEK02IgMEQCADQoGAgIAQNwIAIANBCGogAUE0/AoAACAAQfjW0AA2AgggACADNgIEIABBCDYCACACQRhqIgAQwycgABDqOwwCC0EEQTwQoz0ACyACQRhqIgAQwycgABDqOwsgAkHgAmokAA8LIAEgAigC+AFBpMbQABD9LwALvhUCCH8CfiMAQfACayIFJAAgBSADOgAjIAUgAjoAIiAFIAE2AhwCQAJAAkACQAJAAkACQAJAAkACQCAELQA0RQRAIAVB8AFqIgIgBUEcahD6KSAFIAVBImo2ApgCIAUgBUEjajYClAIgBUGQAWohBiMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEIIwBB0ABrIgIkACACQRBqIgcgARCwJAJAAkACQCACKQMQIg1CAlIEQCACKQMYIQ4gAkHEAGoiBCABEKMqIARBBCACKAJEQQFqIgRBfyAEGyIEIARBBE0bQQBBCEEQEKAYIAIoAkghBCACKAJEQQFGDQIgAigCTCIKIA43AwggCiANNwMAIAJBDGoiC0EBNgIAIAIgCjYCCCACIAQ2AgQgByABQTD8CgAAIwBBIGsiASQAIAEgBxCwJCABKQMAIg1CAlIEQCACQQRqIQQDQCABKQMIIQ4CQCAEKAIIIgogBCgCAEcNACABQRRqIAcQoyogASgCFEEBaiIJQX8gCRsiCSAEKAIAIAQoAggiDGtNDQAgBCAMIAlBCEEQEN4oCyAEKAIEIApBBHRqIgkgDjcDCCAJIA03AwAgBCAKQQFqNgIIIAEgBxCwJCABKQMAIg1CAlINAAsLAkAgBygCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAHQQRqEPseCyABQSBqJAAgCEEIaiALKAIANgIAIAggAikCBDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAQgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAYgAykCADcCACAGQRBqIANBEGooAgA2AgAgBkEIaiADQQhqKQIANwIAIAgQ7TsMAQsgBiADKQIUNwIEIAZBk4CAgHg2AgAgBkEMaiADQRxqKAIANgIACyADQdAAaiQAIAVB6ABqIgEgBUGcAWooAgA2AgAgBSAFKQKUATcDYCAFKAKQASICQZOAgIB4Rg0BIAUoAqABIQMgACAFKQNgNwIIIAAgAzYCFCAAIAI2AgQgAEEpOgAAIABBEGogASgCADYCAAwDCyAFQSRqIgIgBUEcahD6KSAFQcABaiIBIAJBJPwKAAAgBSAFQSJqNgLoASAFIAVBI2o2AuQBIAEQkDsaIAUoAtwBIQMgARCQOyEEIAVBkAFqIgIgAUEs/AoAACACEJA7GiAFKAKsASEBIAUgAhCQOyABayIBNgK0AiAFQbgCakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQN0IgIhASACQThxIgYEQCACIAZrQUBrIgEgAkkNBAtBwAAhByABQcAAENE0RQ0EIAEEQCABQcAAEK02IgdFDQYLIAUoAsACIQggBUHwAWogBUGQAWpBLPwKAAAgBCADayEKQQAhAyAFQQA2ApwCIAVB2AJqQQRyIQsgBUH0AWohCQNAIAVB0AJqIQxCAiENIAUoAowCIgYgBSgCkAJHBH8gBQJ+AkACQAJAIAUoAvQBRQ0AIAYgBSgChAJPDQwgBSgC+AEgBSgCgAIgBmoiBEEDdmotAABB/wFzIARBB3F2QQFxRQ0AIAUgBkEBajYCjAIMAQsgBSAGQQFqNgKMAiAFQRBqIAVB8AFqIAYQrSogBUHYAmogBSgCECAFKAIUIAUoApQCLAAAEMIBIAUoAtgCIgRBAUcNASAERQ0AIAsQiBELQgAMAQsgBSkD4AIiDSAFKAKYAi0AABDFKa0LNwPQAiAFIAUoApwCIgRBAWo2ApwCIAVByAJqBSAMCyANNwMAAkACQAJAIAUpA9ACIg1CAlIEQCADIAdqIQYgDadBAXFFDQEgBiAFKQPIAjcDACAIIARBA3ZqIgYgBi0AAEEBIARBB3F0cjoAAAwCCwJAIAUoAvQBIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAkQ+x4LIAUgA0EDdSIDNgLYAiADIAUoArQCRw0LIAUoAsACIQMgBSgCxAIhBCAFIAUpArgCNwL8ASAFQQA2AvgBIAUgBDYC9AEgBSADNgLwASAFQQhqIAVB8AFqIgYQ1zsgBSgCCCEIQRxBBBCtNiIDRQ0MIANCgYCAgBA3AgAgAyAFKQLwATcCCCADQRBqIAVB+AFqIgspAgA3AgAgA0EYaiAFQYACaiIJKAIANgIAIAUgATYCgAIgBUKAgICAgAg3AvgBIAUgAjYC9AEgBSAHNgLwASAFIAYQ1zsgBSgCACEGQRxBBBCtNiIBDQJBBEEcEKM9AAsgBkIANwMACyADQQhqIQMMAQsLIAFCgYCAgBA3AgAgASAFKQLwATcCCCABQRBqIAspAgA3AgAgAUEYaiAJKAIANgIAIAUgBDYCwAIgBSAINgK8AiAFIAM2ArgCQQxBBBCtNiIDRQ0JIAMgAjYCCCADIAY2AgQgAyABNgIAIAVBATYC4AIgBSADNgLcAiAFQQE2AtgCIAVBADYCmAEgBUKAgICAwAA3ApABIAVB8AFqIgJB3JGAASAKIAUgBUG4AmogBUHYAmogBUGQAWoiARCMEyABIAIQtxMgBUHgAGogASAFLQAiIAUtACMQohMgBS0AYCIBQSlHDQEgBUHbAGogBUH0AGooAgAiATYAACAFQdMAaiAFQewAaikCACINNwAAIAUgBSkCZCIONwBLIABBFGogATYAACAAQQxqIA03AAAgACAONwAEIABBKToAAAwCCyAFQcgBaiABKAIAIgE2AgAgBSAFKQNgNwPAASAFQfABaiICIAUoAsQBIgMgAyABQQR0ahCDCSAFQZABaiACIAUtACIgBS0AIxCiEyAFLQCQASIBQSlGBEAgBUHzAGogBUGkAWooAgAiATYAACAFQesAaiAFQZwBaikCACINNwAAIAUgBSkClAEiDjcAYyAAQRRqIAE2AAAgAEEMaiANNwAAIAAgDjcABCAAQSk6AAAgBUHAAWoQ7TsMAgsgACAFKQKoATcCGCAFQe8AaiICIAVBoAFqKQAANwAAIAVB6ABqIgMgBUGZAWopAAA3AwAgAEEgaiAFQbABaikCADcCACAAQShqIAVBuAFqKQIANwIAIAUgBSkAkQEiDTcDYCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAAgBUHAAWoQ7TsMAQsgACAFKQJ4NwIYIAVB1wBqIgIgBUHwAGopAAA3AAAgBUHQAGoiAyAFQekAaikAADcDACAAQSBqIAVBgAFqKQIANwIAIABBKGogBUGIAWopAgA3AgAgBSAFKQBhIg03A0ggAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA03AAEgACABOgAACyAFQfACaiQADwtBlJOAAUEjQbiTgAEQyyQAC0HklIABQSkgBUHwAWpByJeAAUGQlYABENUeAAtBwAAgARCjPQALQbSUgAFBIEHUlIABEJ8pAAsgBUIANwL8ASAFQoGAgIDAADcC9AEgBUHEkYABNgLwAUEAIAVB2AJqIAVBtAJqIAVB8AFqQcyRgAEQrysAC0EEQRwQoz0AC0EEQQwQoz0AC9cQAg9/AX4jAEHABGsiAyQAIAEoAhghDiABKAIcIQcgA0GoAmogAkEMaiINENg8QQBBBEEEEKAYIAMoAqwCIQQgAygCqAJBAUcEQCADQQA2ApgEIAMgAygCsAIiBTYClAQgAyAENgKQBCADQQA2AqQEIANCgICAgMAANwKcBCAEBH8gBQUgA0GQBGpB8K+CARCdKCADKAKUBAtBADYCACADQQE2ApgEQcAAIQUgDRDYPCIEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgA0EANgK0AiADIAU2ArACIAMgBDYCrAIgA0HAADYCqAIgA0GoBGoiBCADQagCaiAGENIlIANBGGogBBCGPSADKAIcIQkgAygCGCEPAkACQAJAAkACQCANENg8IhAEQCAHQQJ2IQogAigCECERQQAhBANAAkACQAJAAkACQAJAAkAgAiAEEIs7RQRAIARBA3YiBSAJTw0BIAUgD2oiBSAFLQAAQX4gBEEHcXdxOgAAIAMoApgEIgUgAygCkARGBEAgA0GQBGpBgLCCARCdKAsgAygClAQgBUECdGogDDYCACADIAVBAWo2ApgEDAcLIAMgBDYCuAQgDRDYPCAETQ0BIBEgBEEDdGopAwAiEkKAgICAEFoEQEEUIQUgA0GoAmpBFEEAQQFBARCgGCADKAKsAiEIIAMoAqgCQQFGDQUgAygCsAIiBkEQakGw/4EBKAAANgAAIAZBCGpBqP+BASkAADcAACAGQaD/gQEpAAA3AAAgA0GoBGoQzy8gA0GcBGoQ6TsgA0GQBGoQ6TtBhoCAgHghBAwKCyAKIBKnIgtNDQIgC0EBaiIFIApPDQUgDiAFQQJ0aigCACIHIA4gC0ECdGooAgAiBmsgDGohDCADKAKYBCIFIAMoApAERgRAIANBkARqQbCwggEQnSgLIAMoApQEIAVBAnRqIAw2AgAgAyAFQQFqNgKYBCAGIAdIBEAgAygCpAQiCEECdCEFA0AgAygCnAQgCEYEQCADQZwEakHAsIIBEJ0oCyADKAKgBCAFaiAGNgIAIAMgCEEBaiIINgKkBCAFQQRqIQUgByAGQQFqIgZHDQALCyABIAsQkjsNBiAEQQN2IgUgCU8NAyAFIA9qIgUgBS0AAEF+IARBB3F3cToAAAwGCyAFIAlBgPSBARDDIQALIAMgAhD9OzYCvAQgA0ECNgKsAiADQYjxgQE2AqgCIANCAjcCtAIgA0E7NgIsIANBOzYCJCADIANBIGo2ArACIAMgA0G8BGo2AiggAyADQbgEajYCICADQagCakGY8YEBEO8sAAsgCyAKQZCwggEQwyEACyAFIAlBgPSBARDDIQALIAggAygCsAJBiP2BARD9LwALIAUgCkGgsIIBEMMhAAsgBEEBaiIEIBBHDQALCyADQShqIANBpARqKAIANgIAIAMgAykCnAQ3AyAgA0G0AmogA0EgaiICEJkSIANBsAJqIANBmARqKAIAIgg2AgAgAyADKQKQBCISNwOoAiADKAK0AiEGIAMoArgCIQUgAygCvAIhByADKAKsAiEEIANBiANqIgkgA0HAAmpBJPwKAAAgA0HYAGoiCiADQbAEaiILKQIANwMAIAMgAykCqAQ3A1AgEqciDEGAgICAeEYNACADQSxqIAlBJPwKAAAgCyAKKQMANwMAIAMgAykDUDcDqAQgAyAHNgIoIAMgBTYCJCADIAY2AiAgAyAINgKkBCADIAQ2AqAEIAMgDDYCnAQgA0GoAmogASgCDCABKAIQIgQoAghBAWtBeHFqQQhqIAQgAhCJASADKAKwAiEGIAMoAqwCIQggAygCqAIiBEGTgICAeEYNASAAIAMpArQCNwIQIAAgBjYCDCAAIAg2AgggACAENgIEIABBKToAACADQagEahDPLyADQZwEahDpOyACEP4kDAILIAAgBzYCFCAAIAU2AhAgACAGNgIMIAAgCDYCCCAAIAQ2AgQgAEEpOgAADAELIANBiANqIgQgA0GcBGoQ4CwgAyADKQKIAzcCtAIgA0EANgKwAiADIAMoApQDIgc2AqwCIAMgAygCkAM2AqgCIANBEGogA0GoAmoiBRDXOyADKAIQIQlBHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAMpAqgCNwIIIAJBEGogA0GwAmopAgA3AgAgAkEYaiADQbgCaigCADYCACADIAc2AmwgAyAJNgJoIAMgAjYCZCADQcgCaiABEMoGIA0Q2DwhASADQQA7AYADIANBADYC/AIgA0EANgLkAiADQQA2AtgCIAMgATYC1AIgA0IENwLAAiADQgA3ArgCIANCgICAgMAANwKwAiADQQA2AqgCIAMoArAEIQEgAygCtAQhAiADIAMpA6gENwKUAyADQQA2ApADIAMgAjYCjAMgAyABNgKIAyADQQhqIAQQ1zsgAygCCCEHQRxBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgASADKQKIAzcCCCABQRBqIANBkANqKQIANwIAIAFBGGogA0GYA2ooAgA2AgAgAyACNgJYIAMgBzYCVCADIAE2AlAgA0HMAWoiASAFIANB0ABqEK4WIANBADYCoAIgBCAIIAYQ0yMgBSABIAQQ7yUgA0HwAGoiASAFIANB5ABqEPojIANBzANqIgIgARDNHCAAIAIQrx8gA0EgahD+JAsgA0HABGokAA8LQQRBHBCjPQALQQRBHBCjPQALQcAAIAQQoz0AC0HA9IEBQSkgA0GoAmpBzPyBAUHs9IEBENUeAAsgBCADKAKwAkHgr4IBEP0vAAvXEAIMfwN+IwBBwARrIgMkACABKAIYIQsgASgCHCEIIANBqAJqIAJBDGoiChDYPEEAQQhBCBCgGCADKAKsAiEFIAMoAqgCQQFHBEAgA0EANgKYBCADIAMoArACIgY2ApQEIAMgBTYCkAQgA0EANgKkBCADQoCAgICAATcCnAQgBQR/IAYFIANBkARqQfCvggEQsyggAygClAQLQgA3AwAgA0EBNgKYBEHAACEGIAoQ2DwiBUEDdiAFQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgRBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELQQAhBSADQQA2ArQCIAMgBjYCsAIgAyAENgKsAiADQcAANgKoAiADQagEaiIEIANBqAJqIAcQ0iUgA0EYaiAEEIY9IAMoAhwhCSADKAIYIQwCQAJAAkACQAJAIAoQ2DwiDQRAIAhBA3YhCCACKAIQIQ4DQAJAAkACQAJAAkACQAJAIAIgBRCLO0UEQCAFQQN2IgQgCU8NASAEIAxqIgQgBC0AAEF+IAVBB3F3cToAACADKAKYBCIEIAMoApAERgRAIANBkARqQYCwggEQsygLIAMoApQEIARBA3RqIBA3AwAgAyAEQQFqNgKYBAwHCyADIAU2ArgEIAoQ2DwgBU0NASAOIAVBA3RqKQMAIg9CgICAgBBaBEBBFCEFIANBqAJqQRRBAEEBQQEQoBggAygCrAIhByADKAKoAkEBRg0FIAMoArACIgRBEGpBsP+BASgAADYAACAEQQhqQaj/gQEpAAA3AAAgBEGg/4EBKQAANwAAIANBqARqEM8vIANBnARqEOM8IANBkARqEOM8QYaAgIB4IQIMCgsgCCAPpyIGTQ0CIAZBAWoiBCAITw0FIAsgBEEDdGopAwAiESALIAZBA3RqKQMAIg99IBB8IRAgAygCmAQiBCADKAKQBEYEQCADQZAEakGwsIIBELMoCyADKAKUBCAEQQN0aiAQNwMAIAMgBEEBajYCmAQgDyARUwRAIAMoAqQEIgRBA3QhBwNAIAMoApwEIARGBEAgA0GcBGpBwLCCARCzKAsgAygCoAQgB2ogDzcDACADIARBAWoiBDYCpAQgB0EIaiEHIBEgD0IBfCIPUg0ACwsgASAGEJI7DQYgBUEDdiIEIAlPDQMgBCAMaiIEIAQtAABBfiAFQQdxd3E6AAAMBgsgBCAJQYD0gQEQwyEACyADIAIQ/Ts2ArwEIANBAjYCrAIgA0GI8YEBNgKoAiADQgI3ArQCIANBOzYCLCADQTs2AiQgAyADQSBqNgKwAiADIANBvARqNgIoIAMgA0G4BGo2AiAgA0GoAmpBmPGBARDvLAALIAYgCEGQsIIBEMMhAAsgBCAJQYD0gQEQwyEACyAHIAMoArACQYj9gQEQ/S8ACyAEIAhBoLCCARDDIQALIAVBAWoiBSANRw0ACwsgA0EoaiADQaQEaigCADYCACADIAMpApwENwMgIANBtAJqIANBIGoiCRCaEiADQbACaiADQZgEaigCACIHNgIAIAMgAykCkAQiDzcDqAIgAygCtAIhBCADKAK4AiEFIAMoArwCIQYgAygCrAIhAiADQYgDaiIIIANBwAJqQST8CgAAIANB2ABqIgsgA0GwBGoiDCkCADcDACADIAMpAqgENwNQIA+nIg1BgICAgHhGDQAgA0EsaiAIQST8CgAAIAwgCykDADcDACADIAMpA1A3A6gEIAMgBjYCKCADIAU2AiQgAyAENgIgIAMgBzYCpAQgAyACNgKgBCADIA02ApwEIANBqAJqIAEoAgwgASgCECICKAIIQQFrQXhxakEIaiACIAkQigEgAygCsAIhBCADKAKsAiEHIAMoAqgCIgJBk4CAgHhGDQEgACADKQK0AjcCECAAIAQ2AgwgACAHNgIIIAAgAjYCBCAAQSk6AAAgA0GoBGoQzy8gA0GcBGoQ4zwgCRD+JAwCCyAAIAY2AhQgACAFNgIQIAAgBDYCDCAAIAc2AgggACACNgIEIABBKToAAAwBCyADQYgDaiIFIANBnARqEN4sIAMgAykCiAM3ArQCIANBADYCsAIgAyADKAKUAyIJNgKsAiADIAMoApADNgKoAiADQRBqIANBqAJqIgYQ1zsgAygCECEIQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQKoAjcCCCACQRBqIANBsAJqKQIANwIAIAJBGGogA0G4AmooAgA2AgAgAyAJNgJsIAMgCDYCaCADIAI2AmQgA0HIAmogARDKBiAKENg8IQEgA0EAOwGAAyADQQA2AvwCIANBADYC5AIgA0EANgLYAiADIAE2AtQCIANCBDcCwAIgA0IANwK4AiADQoCAgIDAADcCsAIgA0EANgKoAiADKAKwBCEBIAMoArQEIQIgAyADKQOoBDcClAMgA0EANgKQAyADIAI2AowDIAMgATYCiAMgA0EIaiAFENc7IAMoAgghCkEcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCiAM3AgggAUEQaiADQZADaikCADcCACABQRhqIANBmANqKAIANgIAIAMgAjYCWCADIAo2AlQgAyABNgJQIANBzAFqIgEgBiADQdAAahCuFiADQQA2AqACIAUgByAEENMjIAYgASAFEO8lIANB8ABqIgEgBiADQeQAahD6IyADQcwDaiICIAEQzRwgACACEK4fIANBIGoQ/iQLIANBwARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAEEKM9AAtBwPSBAUEpIANBqAJqQcz8gQFB7PSBARDVHgALIAUgAygCsAJB4K+CARD9LwAL0BACD38BfiMAQcAEayIDJAAgASgCGCEOIAEoAhwhByADQagCaiACQQxqIg0Q2zxBAEEEQQQQoBggAygCrAIhBCADKAKoAkEBRwRAIANBADYCmAQgAyADKAKwAiIFNgKUBCADIAQ2ApAEIANBADYCpAQgA0KAgICAwAA3ApwEIAQEfyAFBSADQZAEakHwr4IBEJ0oIAMoApQEC0EANgIAIANBATYCmARBwAAhBSANENs8IgRBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyADQQA2ArQCIAMgBTYCsAIgAyAENgKsAiADQcAANgKoAiADQagEaiIEIANBqAJqIAYQ0iUgA0EYaiAEEIY9IAMoAhwhCiADKAIYIQ8CQAJAAkACQAJAIA0Q2zwiEARAIAdBAnYhCyACKAIQIRFBACEEA0ACQAJAAkACQAJAAkACQCACIAQQiztFBEAgBEEDdiIFIApPDQEgBSAPaiIFIAUtAABBfiAEQQdxd3E6AAAgAygCmAQiBSADKAKQBEYEQCADQZAEakGAsIIBEJ0oCyADKAKUBCAFQQJ0aiAMNgIAIAMgBUEBajYCmAQMBwsgAyAENgK4BCANENs8IARNDQEgESAEQQJ0aigCACIJQQBIBEBBFCEFIANBqAJqQRRBAEEBQQEQoBggAygCrAIhCCADKAKoAkEBRg0FIAMoArACIgZBEGpBsP+BASgAADYAACAGQQhqQaj/gQEpAAA3AAAgBkGg/4EBKQAANwAAIANBqARqEM8vIANBnARqEOk7IANBkARqEOk7QYaAgIB4IQQMCgsgCSALTw0CIAlBAWoiBSALTw0FIA4gBUECdGooAgAiByAOIAlBAnRqKAIAIgZrIAxqIQwgAygCmAQiBSADKAKQBEYEQCADQZAEakGwsIIBEJ0oCyADKAKUBCAFQQJ0aiAMNgIAIAMgBUEBajYCmAQgBiAHSARAIAMoAqQEIghBAnQhBQNAIAMoApwEIAhGBEAgA0GcBGpBwLCCARCdKAsgAygCoAQgBWogBjYCACADIAhBAWoiCDYCpAQgBUEEaiEFIAcgBkEBaiIGRw0ACwsgASAJEJI7DQYgBEEDdiIFIApPDQMgBSAPaiIFIAUtAABBfiAEQQdxd3E6AAAMBgsgBSAKQYD0gQEQwyEACyADIAIQ/Ds2ArwEIANBAjYCrAIgA0GI8YEBNgKoAiADQgI3ArQCIANBOzYCLCADQTs2AiQgAyADQSBqNgKwAiADIANBvARqNgIoIAMgA0G4BGo2AiAgA0GoAmpBmPGBARDvLAALIAkgC0GQsIIBEMMhAAsgBSAKQYD0gQEQwyEACyAIIAMoArACQYj9gQEQ/S8ACyAFIAtBoLCCARDDIQALIARBAWoiBCAQRw0ACwsgA0EoaiADQaQEaigCADYCACADIAMpApwENwMgIANBtAJqIANBIGoiAhCZEiADQbACaiADQZgEaigCACIINgIAIAMgAykCkAQiEjcDqAIgAygCtAIhBiADKAK4AiEFIAMoArwCIQcgAygCrAIhBCADQYgDaiIJIANBwAJqQST8CgAAIANB2ABqIgogA0GwBGoiCykCADcDACADIAMpAqgENwNQIBKnIgxBgICAgHhGDQAgA0EsaiAJQST8CgAAIAsgCikDADcDACADIAMpA1A3A6gEIAMgBzYCKCADIAU2AiQgAyAGNgIgIAMgCDYCpAQgAyAENgKgBCADIAw2ApwEIANBqAJqIAEoAgwgASgCECIEKAIIQQFrQXhxakEIaiAEIAIQiQEgAygCsAIhBiADKAKsAiEIIAMoAqgCIgRBk4CAgHhGDQEgACADKQK0AjcCECAAIAY2AgwgACAINgIIIAAgBDYCBCAAQSk6AAAgA0GoBGoQzy8gA0GcBGoQ6TsgAhD+JAwCCyAAIAc2AhQgACAFNgIQIAAgBjYCDCAAIAg2AgggACAENgIEIABBKToAAAwBCyADQYgDaiIEIANBnARqEOAsIAMgAykCiAM3ArQCIANBADYCsAIgAyADKAKUAyIHNgKsAiADIAMoApADNgKoAiADQRBqIANBqAJqIgUQ1zsgAygCECEJQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQKoAjcCCCACQRBqIANBsAJqKQIANwIAIAJBGGogA0G4AmooAgA2AgAgAyAHNgJsIAMgCTYCaCADIAI2AmQgA0HIAmogARDKBiANENs8IQEgA0EAOwGAAyADQQA2AvwCIANBADYC5AIgA0EANgLYAiADIAE2AtQCIANCBDcCwAIgA0IANwK4AiADQoCAgIDAADcCsAIgA0EANgKoAiADKAKwBCEBIAMoArQEIQIgAyADKQOoBDcClAMgA0EANgKQAyADIAI2AowDIAMgATYCiAMgA0EIaiAEENc7IAMoAgghB0EcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCiAM3AgggAUEQaiADQZADaikCADcCACABQRhqIANBmANqKAIANgIAIAMgAjYCWCADIAc2AlQgAyABNgJQIANBzAFqIgEgBSADQdAAahCuFiADQQA2AqACIAQgCCAGENMjIAUgASAEEO8lIANB8ABqIgEgBSADQeQAahD6IyADQcwDaiICIAEQzRwgACACEK8fIANBIGoQ/iQLIANBwARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAEEKM9AAtBwPSBAUEpIANBqAJqQcz8gQFB7PSBARDVHgALIAQgAygCsAJB4K+CARD9LwAL4REBCX8jAEHQAWsiBCQAIAQgAjYCFAJAAkAgAigCACICKAIIQQJGBEAgBEEIaiACQQhqIgoQiiYgBCgCDCICQQFHBEAgBEEBNgKMASAEQdDYzwA2AogBIARCATcClAEgBEE7NgIwIAQgAjYCQCAEIARBLGo2ApABIAQgBEFAazYCLCAAQQxqIARBiAFqEJkOIABBgoCAgHg2AgAgAEEDNgIIDAILAn8CQAJAAkAgBCgCCCIJKAIAIgJBCGoiByACKAIIIgZBAkZBAnRqLQAgQQJGBEACQCAKIAooAgBBAkZBAnRqLQAgQQFrDgMCAwAEC0Gfus8AQStBzLrPABCfKQALIARBiAFqQRtBAEEBQQEQoBggBCgCjAEhAiAEKAKIAUEBRg0GIAQoApABIgFBF2pBn9jPACgAADYAACABQRBqQZjYzwApAAA3AAAgAUEIakGQ2M8AKQAANwAAIAFBiNjPACkAADcAACAAQRs2AhQgACABNgIQIAAgAjYCDCAAQQM2AgggAEGCgICAeDYCAAwFCyADLwEOQQFqIQtBAQwCCyAEQYgBakEcQQBBAUEBEKAYIAQoAowBIQIgBCgCiAFBAUYNBCAEKAKQASIBQRhqQYTYzwAoAAA2AAAgAUEQakH8188AKQAANwAAIAFBCGpB9NfPACkAADcAACABQezXzwApAAA3AAAgAEEcNgIUIAAgATYCECAAIAI2AgwgAEEDNgIIIABBgoCAgHg2AgAMAwsgAy8BDiELQQALIQxBBCECAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAAIgVBG2sOBAEDAAECC0EIIQILIAIgA2ooAgAhBSAGQQJHDQQgBUEIaiECDAMLIAVBKUYNAQsgBCADNgJAIARBATYCjAEgBEHk188ANgKIASAEQgE3ApQBIARBpwQ2AjAgBCAEQSxqNgKQASAEIARBQGs2AiwgAEEMaiAEQYgBahCnGCAAQYKAgIB4NgIAIABBAzYCCAwLC0EAIQIgBkECRw0CCyAEIAcQiiYCQCAEKAIEQQFHDQAgBCgCACEIIAkoAgBBCGohByMAQRBrIgYkAAJ/QQAgBygCAEECRw0AGiAGQQRqIAdBBGoQiRkgBi0ABCIFQRFHBEAgBUECRgwBCyAHLQAlQQRGCyAGQRBqJAANBkEAIQUjAEEQayIGJAACQCAHKAIAQQJHDQAgBkEIaiAHEIomIAYoAgxBAUcNACAGKAIIKAIAIgVBCGogBSgCCEECRkECdGotACBBAkYhBQsgBkEQaiQAIAUNBiAJKAIAIgVBCGogBSgCCEECRkECdGoiBSgCDCAFKAIQQZbXzwBBBRDBLg0AIAkoAgAiBUEIaiAFKAIIQQJGQQJ0aiIFKAIQIQYgBSgCDCAEQQI2AowBIARBpNfPADYCiAEgBEIBNwKUASAEIAogCigCAEECRkECdGopAgw3AkAgBEHMATYCPCAEIARBOGo2ApABIAQgBEFAazYCOCAEQSxqIgcgBEGIAWoQpxggBiAEKAIwIAQoAjQQwS4gBxDeO0UNBgsgAy8BDCEFIAJFDQMgBEGIAWogAkEoahDDBgwECyADLwEMIQIgBEGIAWogBUEwahDDBgwBCyADLwEMIQIgBEEpOgCIAQsgBEEgaiAEQZABaiIFKAIANgIAIAQgCzsBJiAEIAI7ASQgBCAEKQKIATcDGCAEQYgBaiABIAkgBEEYahDsCSAEKAKIAUH/////B2pBAk8NBCAAIAQpA4gBNwMAIABBGGogBEGgAWopAwA3AwAgAEEQaiAEQZgBaikDADcDACAAQQhqIAUpAwA3AwAMBgsgBEEpOgCIAQsgBEHQAGogBEGQAWoiAigCADYCACAEIAs7AVYgBCAFOwFUIAQgBCkCiAE3A0ggBEGIAWogASAJIARByABqEPgCIAQoAogBQf////8HakECTw0BIAAgBCkDiAE3AwAgAEEYaiAEQaABaikDADcDACAAQRBqIARBmAFqKQMANwMAIABBCGogAikDADcDAAwECyALQQFqIQYgAy8BDEEBaiEHAkAgAgRAIARBiAFqIAJBKGoQwwYMAQsgBEEpOgCIAQsgBEHgAGogBEGQAWooAgA2AgAgBCAGOwFmIAQgBzsBZCAEIAQpAogBNwNYIARB6ABqIAEgCCAEQdgAahDSAQJAIAQoAmhB/////wdqQQFNBEAgACAEKQNoNwMAIABBGGogBEGAAWopAwA3AwAgAEEQaiAEQfgAaikDADcDACAAQQhqIARB8ABqKQMANwMADAELIARBiAFqIgEgCCgCAEEIaiAEQegAaiACEKsJIAEQ0CkhBQJ/An8CQAJAAkAgAy0AAEEdaw4CAQIAC0EbDAILQR0hAiADKAIEDAILQR4LIQIgBQshAUEgQQQQpi8hCCAAIAw6ABwgACAGOwEaIAAgBzsBGCAAIAU2AhQgACABNgIQIAAgAjoADCAAQQE2AgggACAINgIEIABBATYCACAIQRhqIARBgAFqKQMANwIAIAhBEGogBEH4AGopAwA3AgAgCEEIaiAEQfAAaikDADcCACAIIAQpA2g3AgALDAMLIAAgBCkDiAE3AwAgACAELwClATsAHSAAIAw6ABwgAEEYaiAEQaABaigCADYCACAAQRBqIARBmAFqKQMANwMAIABBCGogAikDADcDACAAQR9qIARBpwFqLQAAOgAADAILIAAgBCkDiAE3AwAgACAELwClATsAHSAAIAw6ABwgAEEYaiAEQaABaigCADYCACAAQRBqIARBmAFqKQMANwMAIABBCGogBSkDADcDACAAQR9qIARBpwFqLQAAOgAADAELIARBAjYCjAEgBEGM2c8ANgKIASAEQgE3ApQBIARBogg2AjAgBCAEQSxqNgKQASAEIARBFGo2AiwgAEEMaiAEQYgBahCZDiAAQYKAgIB4NgIAIABBAzYCCAsgAy0AAEEpRwRAIAMQnQwLIARB0AFqJAAPCyACIAQoApABQeSjzwAQ/S8AC4EOASt/IwBBEGsiISQAAkAgAyABKAIEIAEoAhxqSQ0AIAEgAyAEIAkgCBClCSABKAIQIgwgAyABKAIEIhNrIgpBASABKAK4AXQiC2sgDCAKIAxrIAtLGyABKAIYGyIcQQFLIQwgCkF/IAEoArwBQQFrdEF/cyIlayILIApLIRcgASgCZCIsIAogJXFBA3RqIRggASgCXCADIAEoAsABIiYgCRCjHUECdGohJ0EDQQQgCUEDRiIRGyEdIAEoAswBIg1B/x9JIRAgASgCDCESIAEoAgghGSABKALEASEOIAhBAkciLUUEQCAcIAEoArQBIhQoAgAiIiAUKAIEIiNrIh9rIRpBfyAUKAK8AUEBa3RBf3MhHiAUKALAASEmIBQoAhAhFQsgHEEBIAwbIShBACALIBcbISkgGEEEaiEXICcoAgAhDyANQf8fIBAbISogCkEJaiEWIBIgE2ohGyASIBlqISRBASAOdCEQIB8gHmsgFSAeIB8gFWtJGyAVIAhBAkYbIS5BA0EAIAZBA2pBA08bIS9BAyAGayEwIAogHGshMSADIB1qISAgCiASayEyICMgGmshMyAHQQFrIQwgBSAGQQJ0aiELIAogFSAaamshNEEAIQZBACENA0AgBiAvRwRAIAoCfyAGIDBGBEAgBSgCAEEBawwBCyALKAIACyIHayEOAkACfyAyIAdBAWsiK0sEQCAOIBxJDQIgAygAACIOQQh0IA4gERsgAyAHaygAACIOQQh0IA4gERtHDQIgICAgIAdrIAQQgBQMAQsgCEEBRgRAIA4gEmtBfEsgKyAxT3INAiADKAAAIgdBCHQgByARGyAOIBlqIgcoAAAiDkEIdCAOIBEbRw0CICAgByAdaiAEICQgGxDNKAwBCyAtICsgNE9yIA4gEmtBfEtyDQEgAygAACIHQQh0IAcgERsgDiAzaiIHKAAAIg5BCHQgDiARG0cNASAgIAcgHWogBCAiIBsQzSgLIB1qIgcgDE0NACAAIA1BA3RqIgwgBzYCBCAMIAZBAWo2AgAgDUEBaiENIAcgKksNAyAHIgwgA2ogBEYNAwsgC0EEaiELIAZBAWohBgwBCwsgAQJ/AkAgCUEDRyAMQQJLcg0AIAIoAgAiBiAKIAYgCksbIQtBICABKAIgayEFIAMoAAAhESABKAJgIQcDQCAGIAtGRQRAIAcgBiATaigAAEGA+p6tA2wgBXZBAnRqIAY2AgAgBkEBaiEGDAELCyACIAo2AgAgByARQYD6nq0DbCAFdkECdGooAgAiAiAoSQ0AIAogAmsiBUH//w9LDQACfwJAAkACQCAIDgMBAAEACyACIBJJDQELIAMgAiATaiAEEIAUDAELIAMgAiAZaiAEICQgGxDNKAsiBkEDSQ0AIAAgBjYCBCAAIAVBA2o2AgAgBiAqTQRAQQEhDSAGIQwgAyAGaiAERw0BC0EBIQ0gCkEBagwBCyAnIAo2AgAgCkEDaiEKQQAhC0EAIQUCQAJAA0AgEEUgDyAoSXINASAFIAsgBSALSRshAgJ/AkACQAJAIAgOAwEAAQALIAIgD2ogEkkNAQsgAiADaiAPIBNqIAJqIAQQgBQgAmohBiATDAELIBkgEyACIANqIA8gGWogAmogBCAkIBsQzSggAmoiBiAPaiASSRsLIQICQCAGIAxLBEAgACANQQN0aiIHIAY2AgQgByAKIA9rNgIAIAYgD2ogFiAGIBYgD2tLGyEWIA1BAWohDSADIAZqIARGIAZBgCBLcg0BIAYhDAsgLCAPICVxQQN0aiEHAkACQCACIA9qIAZqLQAAIAMgBmotAABJBEAgGCAPNgIAIA8gKUsNASAhQQxqIRgMBQsgFyAPNgIAIA8gKUsEQCAHIRcgBiELDAILICFBDGohFwwECyAGIQUgB0EEaiIYIQcLIBBBAWshECAHKAIAIQ8MAQsLIBBBACAIQQJHGyEQDAELIAwhBgsgF0EANgIAIBhBADYCAAJAIBBFIAhBAkdyDQAgFCgCXCADICYgCRCjHUECdGohByATIBpqIQkgFCgCZCEMQQAhC0EAIQUDQCAQRQ0BIAcoAgAiByAVTQ0BIAYgAyAFIAsgBSALSRsiAmogByAjaiIIIAJqIAQgIiAbEM0oIAJqIgJJBEAgACANQQN0aiIGIAI2AgQgBiAKIAcgGmoiBms2AgAgAiAGaiAWIAIgFiAGa0sbIRYgDUEBaiENIAJBgCBLDQIgAiIGIANqIARGDQILIAcgLk0NASAQQQFrIRAgAiAFIAggByAJaiACIAdqIB9JGyACai0AACACIANqLQAASSIIGyEFIAsgAiAIGyELIAwgByAecUEDdGogCEECdGohBwwACwALIBZBCGsLNgIcCyAhQRBqJAAgDQvVFQIKfwJ+IwBB4AJrIgUkACAFIAM6ACMgBSACOgAiIAUgATYCHAJAAkAgBC0ANEUEQCAFQewBaiICIAVBHGoQ+ikgBSAFQSJqNgKUAiAFIAVBI2o2ApACIAVBkAFqIQgjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAJBLPwKAAAgAyADNgJMIANBFGohByMAQdAAayICJAAgAkEIaiABIAJBIGoiBCABKAIsEIELAkACQAJAIAIoAggiC0F+cUECRwRAIAIoAgwhCiAEIAEQoyogBEEEIAIoAiBBAWoiBkF/IAYbIgYgBkEETRtBAEEEQQgQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgkgCjYCBCAJIAs2AgAgAkEcaiINQQE2AgAgAiAJNgIYIAIgBjYCFCAEIAFBMPwKAAAjAEEgayIBJAAgAUEIaiAEIAFBFGogBCgCLBCBCyABKAIIIglBfnFBAkcEQCACQRRqIQYgASgCDCELA0ACQCAGKAIIIgogBigCAEcNACABQRRqIAQQoyogASgCFEEBaiIMQX8gDBsiDCAGKAIAIAYoAggiDmtNDQAgBiAOIAxBBEEIEN4oCyAGKAIEIApBA3RqIgwgCzYCBCAMIAk2AgAgBiAKQQFqNgIIIAEgBCABQRRqIAQoAiwQgQsgASgCBCELIAEoAgAiCUF+cUECRw0ACwsCQCAEKAIEIgZFDQAgBiAGKAIAIgZBAWs2AgAgBkEBRw0AIARBBGoQ+x4LIAFBIGokACAHQQhqIA0oAgA2AgAgByACKQIUNwIADAELIAdBADYCCCAHQoCAgIDAADcCACABKAIEIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFBBGoQ+x4LIAJB0ABqJAAMAQsgBiACKAIoQbi1gAEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgCCADKQIANwIAIAhBEGogA0EQaigCADYCACAIQQhqIANBCGopAgA3AgAgBxDqOwwBCyAIIAMpAhQ3AgQgCEGTgICAeDYCACAIQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHoAGoiASAFQZwBaigCADYCACAFIAUpApQBNwNgIAUoApABIgJBk4CAgHhGDQEgBSgCoAEhAyAAIAUpA2A3AgggACADNgIUIAAgAjYCBCAAQSk6AAAgAEEQaiABKAIANgIADAILIAVBJGoiAiAFQRxqEPopIAVBwAFqIgEgAkEk/AoAACAFIAVBImo2AugBIAUgBUEjajYC5AEgARCQOxogBSgC3AEhAyABEJA7IQYgBUGQAWoiAiABQSz8CgAAIAIQkDsaIAUoAqwBIQEgBSACEJA7IAFrIgE2ArACIAVBtAJqQX8gAUEHaiICIAEgAksbQQN2ENIfIAFBAnQiAiEEAkAgAkE8cSIBBEAgAiABa0FAayIEIAJJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQsgBSgCvAIhCSAFQewBaiAFQZABakEs/AoAACAGIANrIQsgBUEANgKYAiAFQfABaiEKQQAhAwJAAkACQANAIAVByAJqIQ1BAiEBIAUoAogCIgYgBSgCjAJHBH8gBQJ/AkACQAJAIAUoAvABRQ0AIAYgBSgCgAJPDQEgBSgC9AEgBSgC/AEgBmoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAUgBkEBajYCiAIMAgsgBSAGQQFqNgKIAiAFQRBqIAVB7AFqIAYQrSogBUHMAmoiBiAFKAIQIAUoAhQgBSgCkAIsAAAQxwEgBSgCzAJBk4CAgHhHBEAgBhCIEQwCCyAFKALQAiIBIAUoApQCLQAAEMQpDAILQbSUgAFBIEHUlIABEJ8pAAtBAAs2AsgCIAUgBSgCmAIiB0EBajYCmAIgBUHEAmoFIA0LIAE2AgACQAJAAkAgBSgCyAIiBkECRwRAIAMgCGohASAGQQFxRQ0BIAEgBSgCxAI2AgAgCSAHQQN2aiIBIAEtAABBASAHQQdxdHI6AAAMAgsCQCAFKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAKEPseCyAFIANBAnUiATYCzAIgASAFKAKwAkcNBCAFKAK8AiEBIAUoAsACIQYgBSAFKQK0AjcC+AEgBUEANgL0ASAFIAY2AvABIAUgATYC7AEgBUEIaiAFQewBaiIDENc7IAUoAgghB0EcQQQQrTYiAUUNBSABQoGAgIAQNwIAIAEgBSkC7AE3AgggAUEQaiAFQfQBaiIJKQIANwIAIAFBGGogBUH8AWoiCigCADYCACAFIAQ2AvwBIAVCgICAgIAINwL0ASAFIAI2AvABIAUgCDYC7AEgBSADENc7IAUoAgAhBEEcQQQQrTYiAw0CQQRBHBCjPQALIAFBADYCAAsgA0EEaiEDDAELCyADQoGAgIAQNwIAIAMgBSkC7AE3AgggA0EQaiAJKQIANwIAIANBGGogCigCADYCACAFIAY2ArwCIAUgBzYCuAIgBSABNgK0AkEMQQQQrTYiAUUNAiABIAI2AgggASAENgIEIAEgAzYCACAFQQE2AtQCIAUgATYC0AIgBUEBNgLMAiAFQQA2ApgBIAVCgICAgMAANwKQASAFQewBaiICQYCSgAEgCyAFIAVBtAJqIAVBzAJqIAVBkAFqIgEQjBMgASACEMMTIAVB4ABqIAEgBS0AIiAFLQAjEKATIAUtAGAiAUEpRgRAIAVB2wBqIAVB9ABqKAIAIgE2AAAgBUHTAGogBUHsAGopAgAiDzcAACAFIAUpAmQiEDcASyAAQRRqIAE2AAAgAEEMaiAPNwAAIAAgEDcABCAAQSk6AAAMCAsgACAFKQJ4NwIYIAVB1wBqIgIgBUHwAGopAAA3AAAgBUHQAGoiAyAFQekAaikAADcDACAAQSBqIAVBgAFqKQIANwIAIABBKGogBUGIAWopAgA3AgAgBSAFKQBhIg83A0ggAEEQaiACKQAANwAAIABBCWogAykDADcAACAAIA83AAEgACABOgAADAcLIAVCADcC+AEgBUKBgICAwAA3AvABIAVBxJGAATYC7AFBACAFQcwCaiAFQbACaiAFQewBakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAtBwAAgBBCjPQALQeSUgAFBKSAFQewBakHIl4ABQZCVgAEQ1R4AC0GUk4ABQSNBuJOAARDLJAALIAVByAFqIAEoAgAiATYCACAFIAUpA2A3A8ABIAVB7AFqIgIgBSgCxAEiAyADIAFBA3RqEPkIIAVBkAFqIAIgBS0AIiAFLQAjEKATIAUtAJABIgFBKUYEQCAFQfMAaiAFQaQBaigCACIBNgAAIAVB6wBqIAVBnAFqKQIAIg83AAAgBSAFKQKUASIQNwBjIABBFGogATYAACAAQQxqIA83AAAgACAQNwAEIABBKToAACAFQcABahDqOwwBCyAAIAUpAqgBNwIYIAVB7wBqIgIgBUGgAWopAAA3AAAgBUHoAGoiAyAFQZkBaikAADcDACAAQSBqIAVBsAFqKQIANwIAIABBKGogBUG4AWopAgA3AgAgBSAFKQCRASIPNwNgIABBEGogAikAADcAACAAQQlqIAMpAwA3AAAgACAPNwABIAAgAToAACAFQcABahDqOwsgBUHgAmokAAv0FQIIfwR+IwBB8AJrIgUkACAFIAM6ACsgBSACOgAqIAUgATYCJAJAAkACQAJAAkACQCAELQA0RQRAIAVB+AFqIgIgBUEkahD6KSAFIAVBKmo2AqACIAUgBUErajYCnAIgBUGYAWohByMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgAkEs/AoAACADIAM2AkwgA0EUaiEKIwBB0ABrIgIkACACQRBqIgkgARC4HQJAAkACQCACKQMYIg0gAikDECIOQgKFhFBFBEAgAikDKCEPIAIpAyAhECACQcQAaiIEIAEQoyogBEEEIAIoAkRBAWoiBEF/IAQbIgQgBEEETRtBAEEQQSAQoBggAigCSCEGIAIoAkRBAUYNAiACKAJMIgQgDzcDGCAEIBA3AxAgBCANNwMIIAQgDjcDACACQQxqIghBATYCACACIAQ2AgggAiAGNgIEIAkgAUEw/AoAACMAQTBrIgEkACABIAkQuB0gASkDCCINIAEpAwAiDkIChYRQRQRAIAJBBGohBANAIAEpAxghDyABKQMQIRACQCAEKAIIIgsgBCgCAEcNACABQSRqIAkQoyogASgCJEEBaiIGQX8gBhsiBiAEKAIAIAQoAggiDGtNDQAgBCAMIAZBEEEgEN4oCyAEKAIEIAtBBXRqIgYgDzcDGCAGIBA3AxAgBiANNwMIIAYgDjcDACAEIAtBAWo2AgggASAJELgdIAEpAwgiDSABKQMAIg5CAoWEUEUNAAsLAkAgCSgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACAJQQRqEPseCyABQTBqJAAgCkEIaiAIKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAI3AgAgASgCBCIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQQRqEPseCyACQdAAaiQADAELIAYgAigCTEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAcgAykCADcCACAHQRBqIANBEGooAgA2AgAgB0EIaiADQQhqKQIANwIAIAoQ5TwMAQsgByADKQIUNwIEIAdBk4CAgHg2AgAgB0EMaiADQRxqKAIANgIACyADQdAAaiQAIAVB8ABqIgEgBUGkAWooAgA2AgAgBSAFKQKcATcDaCAFKAKYASICQZOAgIB4Rg0BIAUoAqgBIQMgACAFKQNoNwIIIAAgAzYCFCAAIAI2AgQgAEEpOgAAIABBEGogASgCADYCAAwDCyAFQSxqIgIgBUEkahD6KSAFQcgBaiIBIAJBJPwKAAAgBSAFQSpqNgLwASAFIAVBK2o2AuwBIAEQkDsaIAUoAuQBIQkgARCQOyEKIAVBmAFqIgIgAUEs/AoAACACEJA7GiAFKAK0ASEBIAUgAhCQOyABayIBNgK8AiAFQcACakF/IAFBB2oiAiABIAJLG0EDdhDSHyABQQR0IgchBAJAIAdBMHEiAQRAIAcgAWtBQGsiBCAHSQ0BC0HAACEBIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgFFDQELIAUoAsgCIQYgBUH4AWogBUGYAWpBLPwKAAAgBUEANgKkAiABIQMgBSgClAIiAiAFKAKYAkYNBCAFQdACakEEciELA0ACQAJAAkACQAJAAkACQCAFKAL8AUUNACACIAUoAowCTw0EIAUoAoACIAUoAogCIAJqIghBA3ZqLQAAQf8BcyAIQQdxdkEBcUUNACAFIAJBAWo2ApQCDAELIAUgAkEBajYClAIgBUEYaiAFQfgBaiACEK0qIAVB0AJqIAUoAhggBSgCHCAFKAKcAiwAABDGASAFKALQAiICQQFHDQEgAkUNACALEIgRCyAFIAUoAqQCQQFqNgKkAgwBCyAFKQPgAiINIAUpA+gCIg4gBSgCoAItAAAQ/yAgBSAFKAKkAiICQQFqNgKkAg0CCyADQgA3AwggA0IANwMADAILQbSUgAFBIEHUlIABEJ8pAAsgAyANNwMAIAMgDjcDCCAGIAJBA3ZqIgggCC0AAEEBIAJBB3F0cjoAAAsgA0EQaiEDIAUoApQCIgIgBSgCmAJHDQALDAQLQcAAIAQQoz0AC0HklIABQSkgBUH4AWpByJeAAUGQlYABENUeAAtBlJOAAUEjQbiTgAEQyyQACyAFQdABaiABKAIAIgE2AgAgBSAFKQNoNwPIASAFQfgBaiICIAUoAswBIgMgAyABQQV0ahD2CCAFQZgBaiACIAUtACogBS0AKxChEyAFLQCYASIBQSlGBEAgBUH7AGogBUGsAWooAgAiATYAACAFQfMAaiAFQaQBaikCACINNwAAIAUgBSkCnAEiDjcAayAAQRRqIAE2AAAgAEEMaiANNwAAIAAgDjcABCAAQSk6AAAgBUHIAWoQ5TwMAgsgACAFKQKwATcCGCAFQfcAaiICIAVBqAFqKQAANwAAIAVB8ABqIgMgBUGhAWopAAA3AwAgAEEgaiAFQbgBaikCADcCACAAQShqIAVBwAFqKQIANwIAIAUgBSkAmQEiDTcDaCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAAgBUHIAWoQ5TwMAQsCQCAFKAL8ASICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAFQfwBahD7HgsgBSADIAFrQQR1IgI2AtACIAIgBSgCvAJHDQEgBSgCyAIhAiAFKALMAiEDIAUgBSkCwAI3AoQCIAVBADYCgAIgBSADNgL8ASAFIAI2AvgBIAVBEGogBUH4AWoiBhDXOyAFKAIQIQtBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAUpAvgBNwIIIAJBEGogBUGAAmoiCCkCADcCACACQRhqIAVBiAJqIgwoAgA2AgAgBSAENgKIAiAFQoCAgICACDcCgAIgBSAHNgL8ASAFIAE2AvgBIAVBCGogBhDXOyAFKAIIIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAUpAvgBNwIIIAFBEGogCCkCADcCACABQRhqIAwoAgA2AgAgBSADNgLIAiAFIAs2AsQCIAUgAjYCwAJBDEEEEK02IgJFDQMgAiAHNgIIIAIgBDYCBCACIAE2AgAgBUEBNgLYAiAFIAI2AtQCIAVBATYC0AIgBUEANgKgASAFQoCAgIDAADcCmAEgBUH4AWoiAkH0kYABIAogCWsgBSAFQcACaiAFQdACaiAFQZgBaiIBEIwTIAEgAhCwEyAFQegAaiABIAUtACogBS0AKxChEyAFLQBoIgFBKUYEQCAFQeMAaiAFQfwAaigCACIBNgAAIAVB2wBqIAVB9ABqKQIAIg03AAAgBSAFKQJsIg43AFMgAEEUaiABNgAAIABBDGogDTcAACAAIA43AAQgAEEpOgAADAELIAAgBSkCgAE3AhggBUHfAGoiAiAFQfgAaikAADcAACAFQdgAaiIDIAVB8QBqKQAANwMAIABBIGogBUGIAWopAgA3AgAgAEEoaiAFQZABaikCADcCACAFIAUpAGkiDTcDUCAAQRBqIAIpAAA3AAAgAEEJaiADKQMANwAAIAAgDTcAASAAIAE6AAALIAVB8AJqJAAPCyAFQgA3AoQCIAVCgYCAgMAANwL8ASAFQcSRgAE2AvgBQQAgBUHQAmogBUG8AmogBUH4AWpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALrxACCn8DfkIKIQ8jAEHgAWsiBSQAIAUgAzoAKyABIAIQ6CEhASAFIAPAIgI2AtABIAVCCjcDuAFCASEQAkACQAJAAkACQAJAAkACQAJAIANB/wFxRQ0AA0AgAkEBcQRAIAVBEGogECAQQj+HIA8gD0I/hxCoHiAFKQMYIAUpAxAiEEI/h1INAyACQQFGDQILIAUgDyAPQj+HIhEgDyAREKgeIAUpAwggBSkDACIPQj+HUg0CIAJBAXYhAgwACwALIAVBLGogAUEMaiINENg8EPgeIAQtADQgDRDYPCEMDQMgDEUNBCAFQThqIQZBACECA0ACQCAFQSxqAn8CQCABIAIQhyVFBEAgBSACNgLQASANENg8IAJNDQYgBSABKAIQIApqKQMAIg83A7ABIAUgEDcD0AEgEFAEf0GHgICAeAUgEEJ/UiAPQoCAgICAgICAgH9Scg0CIAVBAjYCfCAFQfSXgAE2AnggBUICNwKEASAFQf0PNgLEASAFQf0PNgK8ASAFIAVBuAFqNgKAASAFIAVB0AFqNgLAASAFIAVBsAFqNgK4ASAFQeQAaiAFQfgAahCZDiAFKQJkIREgBSkCbCEPQYiAgIB4CyEBIAAgDzcCDCAAIBE3AgQgACABNgIAIAVBLGoQui0MCgsgBhDmOiAFKAI4RQ0GIAUoAkhBAWoiCEEDdiAIQQdxQQBHaiIDIAUoAkQiBEsEQCADIARrIQkgBSgCPCIHIANJBEAgBiAHQQF0IgQgA0HA////A3FBQGsgAyADQT9xGyIHIAQgB0sbEOgZIAUoAkQhBAsgCQRAIAUoAkAgBGpBACAJ/AsACyAFIAM2AkQLIAUgCDYCSEIAIQ8gBSgCNCIDIAUoAixHDQJB9JKAAQwBCyAPIBB/IQ8CQCAFKAI4BEAgBSgCSCIIQQFqIglBA3YgCUEHcUEAR2oiAyAFKAJEIgRLBEAgAyAEayEHIAUoAjwiCyADSQRAIAYgC0EBdCIEIANBwP///wNxQUBrIAMgA0E/cRsiCyAEIAtLGxDoGSAFKAJEIQQLIAcEQCAFKAJAIARqQQAgB/wLAAsgBSADNgJECyAFIAk2AkggBSgCQCAIQQN2aiIDIAMtAABBASAIQQdxdHI6AAAMAQsgBSAFKAJMQQFqNgJMCyAFKAI0IgMgBSgCLEcEQCAPIREMAgsgDyERQYSTgAELELMoCyAFKAIwIANBA3RqIA83AwAgBSADQQFqNgI0IApBCGohCiAMIAJBAWoiAkcNAAsMBAsgBUECNgIwIAVBiJiAATYCLCAFQgI3AjggBUH6DzYCbCAFQf0PNgJkIAUgBUHgAGo2AjQgBSAFQdABajYCaCAFIAVBuAFqIgE2AmAgBUH8AGogBUEsaiICEJkOIAUpAnwhDyAFIAUpAoQBNwKEASAFIA83AnwgBUGIgICAeDYCeCAFQQM2AjAgBUGspYABNgIsIAVCAjcCOCAFQfQLNgLEASAFQcQNNgK8ASAFQeicgAE2ArgBIAUgATYCNCAFIAVBK2o2AsABIAVB5ABqIAIQmQ4gBUH4AGoQiBEgBSkCZCEPIAAgBSkCbDcCDCAAIA83AgQgAEGCgICAeDYCAAwECyAFIAEQ/Ts2ArgBIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AmwgBUE7NgJkIAUgBUHgAGo2AoABIAUgBUG4AWo2AmggBSAFQdABajYCYAwFC0GglYABELI7AAsgDEUNACAFQThqIQggBUHgAGpBBHIhCiAFQbwBaiELQQAhA0EAIQICQANAAkACQCABIAIQhyVFBEAgBSACNgKwASANENg8IAJNDQIgBSABKAIQIANqKQMAIg83A6gBIAUgEDcDsAEgBUEsagJ+AkACQCAQUEUEQCAQQn9SIA9CgICAgICAgICAf1JyDQIgBUECNgJ8IAVB9JeAATYCeCAFQgI3AoQBIAVB/Q82AtwBIAVB/Q82AtQBIAUgBUHQAWo2AoABIAUgBUGwAWo2AtgBIAUgBUGoAWo2AtABIAsgBUH4AGoQmQ4gBUGIgICAeDYCuAEgCiAFKQK4ATcCACAKQQhqIAVBwAFqKQIANwIAIApBEGogBUHIAWooAgA2AgAMAQsgBUGHgICAeDYCZAsgBUEBNgJgIAoQiBFCAAwBCyAPIBB/IRFCAQsgERDaCwwBCyAIEOY6IAUoAjhFDQMgBSgCSEEBaiIJQQN2IAlBB3FBAEdqIgYgBSgCRCIESwRAIAYgBGshByAFKAI8Ig4gBkkEQCAIIA5BAXQiBCAGQcD///8DcUFAayAGIAZBP3EbIg4gBCAOSxsQ6BkgBSgCRCEECyAHBEAgBSgCQCAEakEAIAf8CwALIAUgBjYCRAsgBSAJNgJIIAUoAjQiBCAFKAIsRgRAIAVBLGpB9JKAARCzKAsgBSgCMCAEQQN0akIANwMAIAUgBEEBajYCNAsgA0EIaiEDIAwgAkEBaiICRw0BDAMLCyAFIAEQ/Ts2AtABIAVBAjYCfCAFQdSSgAE2AnggBUICNwKEASAFQTs2AsQBIAVBOzYCvAEgBSAFQbgBajYCgAEgBSAFQdABajYCwAEgBSAFQbABajYCuAEMBAtBoJWAARCyOwALIAVB+ABqIgIgBUEsaiIDENsUQThBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTD8CgAAIABB8KCAATYCCCAAIAE2AgQgAEGTgICAeDYCACADELotCyAFQeABaiQADwtBBEE4EKM9AAsgBUH4AGpB5JKAARDvLAALhBYCD38DfiMAQdABayIFJAAgBUGIAWoiBiACQQBBBEEIEKAYIAUoAowBIQcCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBzYCGCAGIAJBAEEEQQwQoBggBSgCjAEhByAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBzYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhBwNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQICfwJAIAcoAgAiCBCTNiIGBEAgAg0BIAYhAgtBAAwBCyAFQYgBaiAGIAIQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiECQQELIRMCQAJAAkACQCAIKAI8IAgoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIJQcAAENE0BEACQAJAIAlFBEBBwAAhCgwBCyAJQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAJNgJgIAVBwAA2AlwgBgRAQQAhESAGIAlLBEAgBUHcAGogCUEBdBDoGSAFKAJoIREgBSgCZCEKCyAGBEAgCiARakEAIAb8CwALIAUgBjYCaAsgBSAQNgJsIAJFDQIgBUGIAWogAhDINCAIKAIgQQN2IQIgCCgCHCEIA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAggBkEDdGopAwAgBUEQaiAFQdwAahCGPaciCUEDdiIGIAUoAhQiCkkNASAGIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAGaiIGIAYtAABBASAJQQdxdHI6AAAMAAsAC0HAACAJEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAgoAiAiBkEISQ0AIAgoAhwhAiAGQXhxIQYDQCACKQMAIAVBCGogBUHcAGoQhj2nIglBA3YiCCAFKAIMIgpPDQIgBSgCCCAIaiIIIAgtAABBASAJQQdxdHI6AAAgAkEIaiECIAZBCGsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgggBSkCMDcCACAIQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIIIAw2AgQgCCAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAdBBGoiByAORw0ACwwCCyAHIAUoApABQfizgwEQ/S8ACyAHIAUoApABQeizgwEQ/S8ACyAFQawBaiIKIQYjAEEgayIDJAAgA0EUakJ/IA2tQoABfHkiFIinQQFqIgJBfyACGyICQQBBCEEYEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQZyzgwEQ/S8ACyADQRBqIglBADYCACADIAMoAhw2AgwgAyAENgIIIAIiCCADQQhqIgQoAgAgBCgCCCIHa0sEQCAEIAcgAkEIQRgQ3iggBCgCCCEHCyAEIAIEfyACIAdqIAQoAgQgB0EYbGohAgNAIAJCADcDACACQRhqIQIgCEEBayIIDQALBSAHCzYCCCAGQQhqIAkoAgA2AgAgBiADKQIINwIAIANBIGokACAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgcgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAHQSz8CgAAIAMgAzYCTCADQRRqIQYjAEHQAGsiAiQAIAJBFGogARC8JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiCEEEQQBBBEEMEKAYIAIoAiQhByACKAIgQQFGDQIgAigCKCIJIAIpAhQ3AgAgCUEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCTYCDCACIAc2AgggCCABQTD8CgAAIwBBEGsiASQAIAFBBGogCBC8JSABKAIEQYCAgIB4RwRAIAJBCGohBwNAIAcoAggiCSAHKAIARgRAIAcgCUEBQQRBDBDeKAsgBygCBCAJQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAcgCUEBajYCCCABQQRqIAgQvCUgASgCBEGAgICAeEcNAAsLIAhBDGoQuSAgAUEQaiQAIAZBCGogCygCADYCACAGIAIpAgg3AgAMAQsgBkEANgIIIAZCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgByACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgBhDWKyAGQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1isgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEIQRgQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAuvFAIPfwN+IwBB0AFrIgUkACAFQYgBaiIJIAJBAEEEQQgQoBggBSgCjAEhBgJAIAUoAogBQQFHBEAgBUEANgIgIAUgBSgCkAE2AhwgBSAGNgIYIAkgAkEAQQRBDBCgGCAFKAKMASEGIAUoAogBQQFHBEAgBUEANgIsIAUgBSgCkAE2AiggBSAGNgIkIAEgAkECdGohDiACRQ0CIAVBqAFqIRIgASEJA0AgAyALQRRsakEAIAQgC0sbQQAgAxshBgJ/AkAgCSgCACIHEJM2IgIEQCAGDQEgAiEGC0EADAELIAVBiAFqIAIgBhDKIiAFQdgAaiAFQZgBaigCADYCACAFQdAAaiAFQZABaikCADcDACAFIAUpAogBNwNIIAVByABqIQZBAQshEwJAAkACQAJAIAcoAjwgBygCQCIMKAIIQQFrQXhxakEIaiIPIAwoAiQRBAAiEEEDdiAQQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIghBwAAQ0TQEQAJAAkAgCEUEQEHAACEKDAELIAhBwAAQrTYiCkUNAQsgBUIANwJoIAUgCjYCZCAFIAg2AmAgBUHAADYCXCACBEBBACERIAIgCEsEQCAFQdwAaiAIQQF0EOgZIAUoAmghESAFKAJkIQoLIAIEQCAKIBFqQQAgAvwLAAsgBSACNgJoCyAFIBA2AmwgBkUNAiAFQYgBaiAGEMg0IAcoAiBBAXYhAiAHKAIcIQgDQAJAIAUpA7ABIhVQRQRAIAUpA7gBIRQMAQsDQAJ+AkAgBSkDmAEiFEIDUgRAAkACQAJAIBRCAlENACAFIBRQrUIBhjcDmAEgFKdBAXFFDQAgBSAFKQOgATcDyAEMAQsgBSgCqAFFDQEgBUHAAWogEhC2KiAFKQPAASEUCyAUQgBSDQILIAVCAzcDmAELIAUpA4gBIhRCAlENCCAFQgA3A4gBIAUpA5ABDAELIAUpA8gBCyEVIBSnQQFxRQ0GIAUgBSkDuAFCQH0iFDcDuAEgBSAVNwOwASAVUA0ACwsgBSAVQgEgFXoiFoaFNwOwAQJAIAIgFqcgFKdqIgZLBEAgCCAGQQF0ai8BACEGIAVBEGogBUHcAGoQhj0gBSgCFCIKIAZBA3YiB0sNASAHIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAHaiIHIActAABBASAGQQdxdHI6AAAMAAsAC0HAACAIEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAcoAiAiBkECSQ0AIAcoAhwhAiAGQX5xIQYDQCACLwEAIQcgBUEIaiAFQdwAahCGPSAFKAIMIgogB0EDdiIITQ0CIAUoAgggCGoiCCAILQAAQQEgB0EHcXRyOgAAIAJBAmohAiAGQQJrIgYNAAsLIAVBiAFqIgIgBUHcAGoiBhCGFCAGEM8vIAVBMGogDyAMIAIQjQEgBSgCOCEGIAUoAiwiAiAFKAIkRgRAIAVBJGpBmLSDARCQKAsgBSgCKCACQQxsaiIHIAUpAjA3AgAgB0EIaiAFQThqKAIANgIAIAUgAkEBajYCLCAFKAIgIgIgBSgCGEYEQCAFQRhqQai0gwEQmygLIAUoAhwgAkEDdGoiByAMNgIEIAcgDzYCACAFIAJBAWo2AiAgBSgCiAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiAFqEPseCyATRQ0BIAUoAkgiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAVByABqEPseDAELIAggCkHQsoMBEMMhAAsgC0EBaiELIAYgDWohDSAJQQRqIgkgDkcNAAsMAgsgBiAFKAKQAUH4s4MBEP0vAAsgBiAFKAKQAUHos4MBEP0vAAsgBUGsAWoiCkJ/IA2tQoABfHkiFIinQQFqIgJBfyACG0Gcs4MBEKIaIAUgFD4CqAEgBUKXkpyq27a1wj83A6ABIAVC3aHxy/y2itZANwOYASAFQuyYpKfz2Zmqvn83A5ABIAVC96bAxuO8iJTFADcDiAEgBUHcAGoiBiANQQBBBEEIEKAYIAUoAmAhAiAFKAJcQQFHBEAgBUEANgJEIAUgBSgCZDYCQCAFIAI2AjwgBSgCJCEDIAUoAighAiAFKAIsIQQgBUIANwJ4IAUgAiAEQQxsajYCdCAFIAM2AnAgBSACNgJsIAUgAjYCaCAFQQA2AmQgBSAONgJgIAUgATYCXCAFIAVBPGo2AoQBIAUgBUGIAWo2AoABIAVByABqIQQjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAZBLPwKAAAgAyADNgJMIANBFGohCSMAQdAAayICJAAgAkEUaiABELYlAkACQAJAIAIoAhRBgICAgHhHBEAgAkEgaiIHQQRBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgggAikCFDcCACAIQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAINgIMIAIgBjYCCCAHIAFBMPwKAAAjAEEQayIBJAAgAUEEaiAHELYlIAEoAgRBgICAgHhHBEAgAkEIaiEGA0AgBigCCCIIIAYoAgBGBEAgBiAIQQFBBEEMEN4oCyAGKAIEIAhBDGxqIgwgASkCBDcCACAMQQhqIAFBDGooAgA2AgAgBiAIQQFqNgIIIAFBBGogBxC2JSABKAIEQYCAgIB4Rw0ACwsgB0EMahC5ICABQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgAgAUEMahC5IAsgAkHQAGokAAwBCyAGIAIoAihBiPmDARD9LwALAkAgAygCAEGTgICAeEcEQCAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAJENUrIAlBBEEMEOAeDAELIAQgAykCFDcCBCAEQZOAgIB4NgIAIARBDGogA0EcaigCADYCAAsgA0HQAGokACAFQcgBaiIBIAVB1ABqKAIANgIAIAUgBSkCTDcDwAECQCAFKAJIIgJBk4CAgHhHBEAgBSgCWCEDIAAgBSkDwAE3AgggACADNgIUIAAgAjYCBCAAQQE2AgAgAEEQaiABKAIANgIADAELIAVB0ABqIgMgBUHIAWooAgA2AgAgBSAFKQPAATcDSCAFQdwAaiAFKAIcIAUoAiAgBSgCQCAFKAJEEK8CIAUoAmQhASAFKAJgIQIgBSgCXCIEQZOAgIB4RwRAIAAgBSkCaDcCECAAIAE2AgwgACACNgIIIAAgBDYCBCAAQQE2AgAgBUHIAGoiABDVKyAAQQRBDBDgHgwBCyAAIAUpA0g3AgQgAEEMaiADKAIANgIAIAAgATYCFCAAIAI2AhAgAEEANgIACyAFQTxqQQRBCBDgHiAKQQRBEBDgHiAFQRhqQQRBCBDgHiAFQdABaiQADwsgAiAFKAJkQYi0gwEQ/S8AC68UAg9/A34jAEHQAWsiBSQAIAVBiAFqIgkgAkEAQQRBCBCgGCAFKAKMASEGAkAgBSgCiAFBAUcEQCAFQQA2AiAgBSAFKAKQATYCHCAFIAY2AhggCSACQQBBBEEMEKAYIAUoAowBIQYgBSgCiAFBAUcEQCAFQQA2AiwgBSAFKAKQATYCKCAFIAY2AiQgASACQQJ0aiEOIAJFDQIgBUGoAWohEiABIQkDQCADIAtBFGxqQQAgBCALSxtBACADGyEGAn8CQCAJKAIAIgcQkzYiAgRAIAYNASACIQYLQQAMAQsgBUGIAWogAiAGEMoiIAVB2ABqIAVBmAFqKAIANgIAIAVB0ABqIAVBkAFqKQIANwMAIAUgBSkCiAE3A0ggBUHIAGohBkEBCyETAkACQAJAAkAgBygCPCAHKAJAIgwoAghBAWtBeHFqQQhqIg8gDCgCJBEEACIQQQN2IBBBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiCEHAABDRNARAAkACQCAIRQRAQcAAIQoMAQsgCEHAABCtNiIKRQ0BCyAFQgA3AmggBSAKNgJkIAUgCDYCYCAFQcAANgJcIAIEQEEAIREgAiAISwRAIAVB3ABqIAhBAXQQ6BkgBSgCaCERIAUoAmQhCgsgAgRAIAogEWpBACAC/AsACyAFIAI2AmgLIAUgEDYCbCAGRQ0CIAVBiAFqIAYQyDQgBygCIEECdiECIAcoAhwhCANAAkAgBSkDsAEiFVBFBEAgBSkDuAEhFAwBCwNAAn4CQCAFKQOYASIUQgNSBEACQAJAAkAgFEICUQ0AIAUgFFCtQgGGNwOYASAUp0EBcUUNACAFIAUpA6ABNwPIAQwBCyAFKAKoAUUNASAFQcABaiASELYqIAUpA8ABIRQLIBRCAFINAgsgBUIDNwOYAQsgBSkDiAEiFEICUQ0IIAVCADcDiAEgBSkDkAEMAQsgBSkDyAELIRUgFKdBAXFFDQYgBSAFKQO4AUJAfSIUNwO4ASAFIBU3A7ABIBVQDQALCyAFIBVCASAVeiIWhoU3A7ABAkAgAiAWpyAUp2oiBksEQCAIIAZBAnRqKAIAIQYgBUEQaiAFQdwAahCGPSAGQQN2IgcgBSgCFCIKSQ0BIAcgCkHQsoMBEMMhAAsgBiACQci0gwEQwyEACyAFKAIQIAdqIgcgBy0AAEEBIAZBB3F0cjoAAAwACwALQcAAIAgQoz0AC0HgsoMBQSkgBUGIAWpBrLODAUGMs4MBENUeAAsgBygCICIGQQRJDQAgBygCHCECIAZBfHEhBgNAIAIoAgAhByAFQQhqIAVB3ABqEIY9IAdBA3YiCCAFKAIMIgpPDQIgBSgCCCAIaiIIIAgtAABBASAHQQdxdHI6AAAgAkEEaiECIAZBBGsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgcgBSkCMDcCACAHQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIHIAw2AgQgByAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAlBBGoiCSAORw0ACwwCCyAGIAUoApABQfizgwEQ/S8ACyAGIAUoApABQeizgwEQ/S8ACyAFQawBaiIKQn8gDa1CgAF8eSIUiKdBAWoiAkF/IAIbQZyzgwEQohogBSAUPgKoASAFQpeSnKrbtrXCPzcDoAEgBULdofHL/LaK1kA3A5gBIAVC7Jikp/PZmaq+fzcDkAEgBUL3psDG47yIlMUANwOIASAFQdwAaiIGIA1BAEEEQQgQoBggBSgCYCECIAUoAlxBAUcEQCAFQQA2AkQgBSAFKAJkNgJAIAUgAjYCPCAFKAIkIQMgBSgCKCECIAUoAiwhBCAFQgA3AnggBSACIARBDGxqNgJ0IAUgAzYCcCAFIAI2AmwgBSACNgJoIAVBADYCZCAFIA42AmAgBSABNgJcIAUgBUE8ajYChAEgBSAFQYgBajYCgAEgBUHIAGohBCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBkEs/AoAACADIAM2AkwgA0EUaiEJIwBB0ABrIgIkACACQRRqIAEQuCUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgdBBEEAQQRBDBCgGCACKAIkIQYgAigCIEEBRg0CIAIoAigiCCACKQIUNwIAIAhBCGogAkEcaigCADYCACACQRBqIgtBATYCACACIAg2AgwgAiAGNgIIIAcgAUEw/AoAACMAQRBrIgEkACABQQRqIAcQuCUgASgCBEGAgICAeEcEQCACQQhqIQYDQCAGKAIIIgggBigCAEYEQCAGIAhBAUEEQQwQ3igLIAYoAgQgCEEMbGoiDCABKQIENwIAIAxBCGogAUEMaigCADYCACAGIAhBAWo2AgggAUEEaiAHELglIAEoAgRBgICAgHhHDQALCyAHQQxqELkgIAFBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIADAELIAlBADYCCCAJQoCAgIDAADcCACABQQxqELkgCyACQdAAaiQADAELIAYgAigCKEGI+YMBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAQgAykCADcCACAEQRBqIANBEGooAgA2AgAgBEEIaiADQQhqKQIANwIAIAkQsCsgCUEEQQwQ4B4MAQsgBCADKQIUNwIEIARBk4CAgHg2AgAgBEEMaiADQRxqKAIANgIACyADQdAAaiQAIAVByAFqIgEgBUHUAGooAgA2AgAgBSAFKQJMNwPAAQJAIAUoAkgiAkGTgICAeEcEQCAFKAJYIQMgACAFKQPAATcCCCAAIAM2AhQgACACNgIEIABBATYCACAAQRBqIAEoAgA2AgAMAQsgBUHQAGoiAyAFQcgBaigCADYCACAFIAUpA8ABNwNIIAVB3ABqIAUoAhwgBSgCICAFKAJAIAUoAkQQrwIgBSgCZCEBIAUoAmAhAiAFKAJcIgRBk4CAgHhHBEAgACAFKQJoNwIQIAAgATYCDCAAIAI2AgggACAENgIEIABBATYCACAFQcgAaiIAELArIABBBEEMEOAeDAELIAAgBSkDSDcCBCAAQQxqIAMoAgA2AgAgACABNgIUIAAgAjYCECAAQQA2AgALIAVBPGpBBEEIEOAeIApBBEEQEOAeIAVBGGpBBEEIEOAeIAVB0AFqJAAPCyACIAUoAmRBiLSDARD9LwALrxQCD38DfiMAQdABayIFJAAgBUGIAWoiCSACQQBBBEEIEKAYIAUoAowBIQYCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBjYCGCAJIAJBAEEEQQwQoBggBSgCjAEhBiAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBjYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhCQNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQYCfwJAIAkoAgAiBxCTNiICBEAgBg0BIAIhBgtBAAwBCyAFQYgBaiACIAYQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiEGQQELIRMCQAJAAkACQCAHKAI8IAcoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyIIQcAAENE0BEACQAJAIAhFBEBBwAAhCgwBCyAIQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAINgJgIAVBwAA2AlwgAgRAQQAhESACIAhLBEAgBUHcAGogCEEBdBDoGSAFKAJoIREgBSgCZCEKCyACBEAgCiARakEAIAL8CwALIAUgAjYCaAsgBSAQNgJsIAZFDQIgBUGIAWogBhDINCAHKAIgQQF2IQIgBygCHCEIA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAggBkEBdGouAQAhBiAFQRBqIAVB3ABqEIY9IAZBA3YiByAFKAIUIgpJDQEgByAKQdCygwEQwyEACyAGIAJByLSDARDDIQALIAUoAhAgB2oiByAHLQAAQQEgBkEHcXRyOgAADAALAAtBwAAgCBCjPQALQeCygwFBKSAFQYgBakGss4MBQYyzgwEQ1R4ACyAHKAIgIgZBAkkNACAHKAIcIQIgBkF+cSEGA0AgAi4BACEHIAVBCGogBUHcAGoQhj0gB0EDdiIIIAUoAgwiCk8NAiAFKAIIIAhqIgggCC0AAEEBIAdBB3F0cjoAACACQQJqIQIgBkECayIGDQALCyAFQYgBaiICIAVB3ABqIgYQhhQgBhDPLyAFQTBqIA8gDCACEI0BIAUoAjghBiAFKAIsIgIgBSgCJEYEQCAFQSRqQZi0gwEQkCgLIAUoAiggAkEMbGoiByAFKQIwNwIAIAdBCGogBUE4aigCADYCACAFIAJBAWo2AiwgBSgCICICIAUoAhhGBEAgBUEYakGotIMBEJsoCyAFKAIcIAJBA3RqIgcgDDYCBCAHIA82AgAgBSACQQFqNgIgIAUoAogBIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgBahD7HgsgE0UNASAFKAJIIgIgAigCACICQQFrNgIAIAJBAUcNASAFQcgAahD7HgwBCyAIIApB0LKDARDDIQALIAtBAWohCyAGIA1qIQ0gCUEEaiIJIA5HDQALDAILIAYgBSgCkAFB+LODARD9LwALIAYgBSgCkAFB6LODARD9LwALIAVBrAFqIgpCfyANrUKAAXx5IhSIp0EBaiICQX8gAhtBnLODARCiGiAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgYgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAGQSz8CgAAIAMgAzYCTCADQRRqIQkjAEHQAGsiAiQAIAJBFGogARC6JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiB0EEQQBBBEEMEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCIIIAIpAhQ3AgAgCEEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCDYCDCACIAY2AgggByABQTD8CgAAIwBBEGsiASQAIAFBBGogBxC6JSABKAIEQYCAgIB4RwRAIAJBCGohBgNAIAYoAggiCCAGKAIARgRAIAYgCEEBQQRBDBDeKAsgBigCBCAIQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAYgCEEBajYCCCABQQRqIAcQuiUgASgCBEGAgICAeEcNAAsLIAdBDGoQuSAgAUEQaiQAIAlBCGogCygCADYCACAJIAIpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgBiACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgCRDVKyAJQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1SsgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEEQRAQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAuvFAIPfwN+IwBB0AFrIgUkACAFQYgBaiIJIAJBAEEEQQgQoBggBSgCjAEhBgJAIAUoAogBQQFHBEAgBUEANgIgIAUgBSgCkAE2AhwgBSAGNgIYIAkgAkEAQQRBDBCgGCAFKAKMASEGIAUoAogBQQFHBEAgBUEANgIsIAUgBSgCkAE2AiggBSAGNgIkIAEgAkECdGohDiACRQ0CIAVBqAFqIRIgASEJA0AgAyALQRRsakEAIAQgC0sbQQAgAxshBgJ/AkAgCSgCACIHEJM2IgIEQCAGDQEgAiEGC0EADAELIAVBiAFqIAIgBhDKIiAFQdgAaiAFQZgBaigCADYCACAFQdAAaiAFQZABaikCADcDACAFIAUpAogBNwNIIAVByABqIQZBAQshEwJAAkACQAJAIAcoAjwgBygCQCIMKAIIQQFrQXhxakEIaiIPIAwoAiQRBAAiEEEDdiAQQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIghBwAAQ0TQEQAJAAkAgCEUEQEHAACEKDAELIAhBwAAQrTYiCkUNAQsgBUIANwJoIAUgCjYCZCAFIAg2AmAgBUHAADYCXCACBEBBACERIAIgCEsEQCAFQdwAaiAIQQF0EOgZIAUoAmghESAFKAJkIQoLIAIEQCAKIBFqQQAgAvwLAAsgBSACNgJoCyAFIBA2AmwgBkUNAiAFQYgBaiAGEMg0IAcoAiBBAnYhAiAHKAIcIQgDQAJAIAUpA7ABIhVQRQRAIAUpA7gBIRQMAQsDQAJ+AkAgBSkDmAEiFEIDUgRAAkACQAJAIBRCAlENACAFIBRQrUIBhjcDmAEgFKdBAXFFDQAgBSAFKQOgATcDyAEMAQsgBSgCqAFFDQEgBUHAAWogEhC2KiAFKQPAASEUCyAUQgBSDQILIAVCAzcDmAELIAUpA4gBIhRCAlENCCAFQgA3A4gBIAUpA5ABDAELIAUpA8gBCyEVIBSnQQFxRQ0GIAUgBSkDuAFCQH0iFDcDuAEgBSAVNwOwASAVUA0ACwsgBSAVQgEgFXoiFoaFNwOwAQJAIAIgFqcgFKdqIgZLBEAgCCAGQQJ0aigCACEGIAVBEGogBUHcAGoQhj0gBkEDdiIHIAUoAhQiCkkNASAHIApB0LKDARDDIQALIAYgAkHItIMBEMMhAAsgBSgCECAHaiIHIActAABBASAGQQdxdHI6AAAMAAsAC0HAACAIEKM9AAtB4LKDAUEpIAVBiAFqQayzgwFBjLODARDVHgALIAcoAiAiBkEESQ0AIAcoAhwhAiAGQXxxIQYDQCACKAIAIQcgBUEIaiAFQdwAahCGPSAHQQN2IgggBSgCDCIKTw0CIAUoAgggCGoiCCAILQAAQQEgB0EHcXRyOgAAIAJBBGohAiAGQQRrIgYNAAsLIAVBiAFqIgIgBUHcAGoiBhCGFCAGEM8vIAVBMGogDyAMIAIQjQEgBSgCOCEGIAUoAiwiAiAFKAIkRgRAIAVBJGpBmLSDARCQKAsgBSgCKCACQQxsaiIHIAUpAjA3AgAgB0EIaiAFQThqKAIANgIAIAUgAkEBajYCLCAFKAIgIgIgBSgCGEYEQCAFQRhqQai0gwEQmygLIAUoAhwgAkEDdGoiByAMNgIEIAcgDzYCACAFIAJBAWo2AiAgBSgCiAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAVBiAFqEPseCyATRQ0BIAUoAkgiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAVByABqEPseDAELIAggCkHQsoMBEMMhAAsgC0EBaiELIAYgDWohDSAJQQRqIgkgDkcNAAsMAgsgBiAFKAKQAUH4s4MBEP0vAAsgBiAFKAKQAUHos4MBEP0vAAsgBUGsAWoiCkJ/IA2tQoABfHkiFIinQQFqIgJBfyACG0Gcs4MBEKIaIAUgFD4CqAEgBUKXkpyq27a1wj83A6ABIAVC3aHxy/y2itZANwOYASAFQuyYpKfz2Zmqvn83A5ABIAVC96bAxuO8iJTFADcDiAEgBUHcAGoiBiANQQBBBEEIEKAYIAUoAmAhAiAFKAJcQQFHBEAgBUEANgJEIAUgBSgCZDYCQCAFIAI2AjwgBSgCJCEDIAUoAighAiAFKAIsIQQgBUIANwJ4IAUgAiAEQQxsajYCdCAFIAM2AnAgBSACNgJsIAUgAjYCaCAFQQA2AmQgBSAONgJgIAUgATYCXCAFIAVBPGo2AoQBIAUgBUGIAWo2AoABIAVByABqIQQjAEHQAGsiAyQAIANBk4CAgHg2AgAgA0EgaiIBIAZBLPwKAAAgAyADNgJMIANBFGohCSMAQdAAayICJAAgAkEUaiABELslAkACQAJAIAIoAhRBgICAgHhHBEAgAkEgaiIHQQRBAEEEQQwQoBggAigCJCEGIAIoAiBBAUYNAiACKAIoIgggAikCFDcCACAIQQhqIAJBHGooAgA2AgAgAkEQaiILQQE2AgAgAiAINgIMIAIgBjYCCCAHIAFBMPwKAAAjAEEQayIBJAAgAUEEaiAHELslIAEoAgRBgICAgHhHBEAgAkEIaiEGA0AgBigCCCIIIAYoAgBGBEAgBiAIQQFBBEEMEN4oCyAGKAIEIAhBDGxqIgwgASkCBDcCACAMQQhqIAFBDGooAgA2AgAgBiAIQQFqNgIIIAFBBGogBxC7JSABKAIEQYCAgIB4Rw0ACwsgB0EMahC5ICABQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgAgAUEMahC5IAsgAkHQAGokAAwBCyAGIAIoAihBiPmDARD9LwALAkAgAygCAEGTgICAeEcEQCAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAJELArIAlBBEEMEOAeDAELIAQgAykCFDcCBCAEQZOAgIB4NgIAIARBDGogA0EcaigCADYCAAsgA0HQAGokACAFQcgBaiIBIAVB1ABqKAIANgIAIAUgBSkCTDcDwAECQCAFKAJIIgJBk4CAgHhHBEAgBSgCWCEDIAAgBSkDwAE3AgggACADNgIUIAAgAjYCBCAAQQE2AgAgAEEQaiABKAIANgIADAELIAVB0ABqIgMgBUHIAWooAgA2AgAgBSAFKQPAATcDSCAFQdwAaiAFKAIcIAUoAiAgBSgCQCAFKAJEEK8CIAUoAmQhASAFKAJgIQIgBSgCXCIEQZOAgIB4RwRAIAAgBSkCaDcCECAAIAE2AgwgACACNgIIIAAgBDYCBCAAQQE2AgAgBUHIAGoiABCwKyAAQQRBDBDgHgwBCyAAIAUpA0g3AgQgAEEMaiADKAIANgIAIAAgATYCFCAAIAI2AhAgAEEANgIACyAFQTxqQQRBCBDgHiAKQQRBEBDgHiAFQRhqQQRBCBDgHiAFQdABaiQADwsgAiAFKAJkQYi0gwEQ/S8AC5ITAgl/AX4jAEHwAGsiAiQAAkACQAJAAn8CQAJAAkACQAJAAkACQCAAIAFBKxCcFEUEQCAAIAFBLRCcFEUNAQsCQCABQQFNBEAgAUEBRg0BDAwLIAAsAAFBv39MDQsLIAIgAUEBayIDNgIoIAJBADYCJCACIAM2AiAgAkEtNgIYIAJBLTYCLCACQQE6ADAgAiAAQQFqIgM2AhwgAkHIAGogAkEYahDqDiACKAJIQQFHDQggAigCTCIGQQNNDQggBkEBaiIFRQ0IIAEgBUsiCg0BIAEgBUYNAgwJCwJAAkACQAJAIAFBCk0EQCACQSBqQQA7AQAgAkIANwMYIAIgADYCSCACIAAgAWo2AkwgAkHIAGoQgzsiA0UNDEEKIAMgA0EKTxshBEEAIQMDQCACQRhqIANqIAAgA2otAABBMGsiBToAACAFQf8BcUEKSSADQQ9xdCAGciEGIAQgA0EBaiIDRw0ACyACLQAcIgBB/QFHDQJBACEEIAZB//8DcSIAQa4DSw0BIABBrwFGDQMgAEHvAkcNDCACLQAfQf0BRw0MIAItACAhACACLQAeIAItAB1BCmxqDAsLIAJBGGpBASAAIAEQggMgAigCGEGTgICAeEYEQCACQegAaiACQSRqKAIANgIAIAIgAikCHDcDYCACQcgAaiACQRxqQQAQ9xEgAigCSCIEDQxB5MKAAUErQZDDgAEQyyQACyACQdgAaiACQShqKAIANgIAIAJB0ABqIAJBIGopAgA3AwAgAiACKQIYIgs3A0ggC6dBk4CAgHhGBEAgAigCTCEEDAwLIAJByABqEIgRDAYLIABBrwNGDQIgAEHvBkcNCiACLQAfQf0BRw0KIAItACEgAi0AIEEKbGohACACLQAeIAItAB1BCmxqDAkLQQAhBCABQQhHIAZB//8DcUH/AUdyDQkgAi0AGyACLQAZQeQAbCACLQAYQegHbGogAi0AGkEKbGpqQf//A3EgAi0AHSAAQQpsakH/AXEgAi0AHyACLQAeQQpsakH/AXEQjichBAwJCyACLQAeQf0BRw0IIAItAB8hAAwGCyACLQAeQf0BRw0HIAItACAgAi0AH0EKbGohAAwFCyAAIAVqLAAAQb9/TA0HCwJAAkACQAJAAkACQCAALQAAQStrDgMAAgECCyAFQQhLDQIMAwsgBUEJTwRAA0AgBkUNBSADLQAAQTBrIgdBCUsNCyAIrEIKfiILQiCIpyALpyIJQR91Rw0LIANBAWohAyAGQQFrIQYgCSAJIAdrIghKIAdBAEpzRQ0ACwwKCwNAIAMtAABBMGsiB0EJSw0KIANBAWohAyAIQQpsIAdrIQggBkEBayIGDQALDAMLIAAhAyAFIgZBCEkNAQsDQCAGRQ0CIAMtAABBMGsiB0EJSw0IIAisQgp+IgtCIIinIAunIglBH3VHDQggA0EBaiEDIAZBAWshBiAHQQBIIAkgByAJaiIISnNFDQALDAcLA0AgAy0AAEEwayIHQQlLDQcgA0EBaiEDIAcgCEEKbGohCCAGQQFrIgYNAAsLAkAgCkUEQCABIAVGDQEMBAsgACAFaiwAAEG/f0wNAwsgAkEQaiAAIAVqIAEgBWsQ9RIgAigCECIBRQ0FIAIoAhQhACACQQE2AkAgAkEBOwE8IAJBADYCNCACQQE6ADAgAkEtNgIsIAJBADYCJCACIAE2AhwgAkEtNgIYIAIgADYCOCACIAA2AiggAiAANgIgIAJByABqIAJBGGoQ6g4CfyACKAJIRQRAIAItAD0NAiACQQE6AD0CQCACLQA8QQFGBEAgAigCOCEGIAIoAjQhAAwBCyACKAI4IgYgAigCNCIARg0DCyAGIABrIQQgAigCHCAAagwBCyACKAI0IQAgAiACKAJQNgI0IAIoAkwgAGshBCAAIAFqCyEDAkACQAJAAkACQCAEDgIKAAELQQAhBEEBIQAgAy0AAEEraw4DCQEJAQsgAy0AAEErRgRAIARBAWshACADQQFqIQMgBEEKSQ0BDAILIAQiAEEJTw0BC0EAIQRBACEGA0AgAy0AAEEwayIBQQlLDQggA0EBaiEDIAEgBkEKbGohBiAAQQFrIgANAAsMAQtBACEGA0AgAEUNAUEAIQQgBq1CCn4iC0IgiKcNByADLQAAQTBrIgFBCUsNByADQQFqIQMgAEEBayEAIAEgC6ciBWoiBiAFTw0ACwwGCyACQQhqIQlBACEHQQAhAyMAQRBrIgQkAAJAAkACQCACQRhqIgAoAigiAQ4CAgEACyAAIAFBAWs2AiggAC0AJQ0BIAAoAgQhAyAEQQRqIAAQ6g4gBCgCBEEBRgRAIAAoAhwhASAAIAQoAgw2AhwgASADaiEHIAQoAgggAWshAwwCCyAALQAlDQEgAEEBOgAlAkAgAC0AJEEBRgRAIAAoAiAhBSAAKAIcIQEMAQsgACgCICIFIAAoAhwiAUYNAgsgBSABayEDIAAoAgQgAWohBwwBCyAAQQA2AiggAC0AJQ0AIABBAToAJQJAIAAtACRBAUYEQCAAKAIgIQUgACgCHCEBDAELIAAoAiAiBSAAKAIcIgFGDQELIAUgAWshAyAAKAIEIAFqIQcLIAkgAzYCBCAJIAc2AgAgBEEQaiQAIAIoAggiAEUNACACQcgAaiIEAn8CQAJAAkACQAJAAkACQAJAIAIoAgwiAw4CAAECCyAEQQA6AAFBAQwHC0EBIQEgAC0AAEEraw4DBQEFAQsgAC0AAEErRgRAIANBAWshASAAQQFqIQAgA0EKSQ0BDAILIAMiAUEJTw0BC0EAIQMDQCAALQAAQTBrIgVBCUsNBCAAQQFqIQAgBSADQQpsaiEDIAFBAWsiAQ0ACwwBC0EAIQMDQCABRQ0BIAAtAAAhBSADrUIKfiILQiCIpw0CIAVBMGsiA0EKTw0DIABBAWohACABQQFrIQEgAyALpyIFaiIDIAVPDQALIARBAjoAAUEBDAMLIAQgAzYCBEEADAILIAVBMGtB/wFxQQpPDQAgBEECOgABQQEMAQsgBEEBOgABQQELOgAAIAItAEhFDQELQQAhBAwECyAIIAYgAigCTBCOJyEEDAMLIAAgASAFIAFB7MWAARCjNgALIAItAB0LIQEgAi0AGyACLQAZQeQAbCACLQAYQegHbGogAi0AGkEKbGpqQf//A3EgAUH/AXEgAEH/AXEQjichBAsgAkHwAGokACAEDwsgACABQQAgBUHcxYABEKM2AAsgACABQQEgAUHMxYABEKM2AAuSDwIHfwF+IwBB4ABrIgYkACAGIAM2AiggBiACNgIkIAZBJGoQ7hIhByAGKAIoIQwgBigCJCELAkACQAJAAkACQAJAAkACQCAHQT5MBEAgB0EjRg0BIAdBL0YNAgwGCyAHQT9GDQIgB0HcAEYNASAHQYCAxABHDQUCQCAFKAIIQQFGBEAgBSgCFCEHIAUoAgwiCUUEQEEAIQkMAgsCQCAFKAIYIgIgCU0EQCACIAlHDQEMAwsgByAJaiwAAEG/f0oNAgsgByACQQAgCUGwicQAEKM2AAsgBSgCGCEJIAUoAhQhBwsgASAHIAcgCWoQgSYgAEEANgIIIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgACAFKQI0NwI0IABBPGogBUE8aikCADcCACAAQcQAaiAFQcQAai0AADoAACAAIAUoAjA2AjAgACAFKQIANwIAIAAgBSkCIDcCICAAIAUpAig3AiggACAFKAIcNgIcDAYLIAZBJGoiBCABQST8CgAAIAAgBCAFIAIgAxCPEAwFCyADIQcgAiEJA0AgBiAHNgIoIAYgCTYCJCAGQSRqEO4SIgpB3ABHIApBL0dxDQIgCEEBaiEIIAYoAighByAGKAIkIQkMAAsACwJ/IAUoAgBFBEAgBUEMaiAFKAIIDQEaIAUoAhghCSAFKAIUIQcMAwsgBUEEagsgBSgCFCEHKAIAIglFBEBBACEJDAILAkAgBSgCGCIIIAlNBEAgCCAJRg0DDAELIAcgCWosAABBv39KDQILIAcgCEEAIAlBlJXEABCjNgALAkAgCEEBTQRAIAUoAhQhAwJAIAUoAjAiCEUNACAFKAIYIgIgCE0EQCACIAhGDQEMAwsgAyAIaiwAAEG/f0wNAgsgASADIAMgCGoQgSYgASgCCCECIAFBARDYLSABKAIEIAEoAghqQS86AAAgASACQQFqNgIIIAZBAToAJCAGQRhqIAEgBCAGQSRqIgcgCCALIAwQvwEgBigCHCEDIAYoAhghAiAHIAFBJPwKAAAgACAHIAQgBSgCICAFKAIkIAUoAiggBSgCLCAFQTRqIAUvARwgBS8BHiAIIAIgAxDRBwwECwJAIAEoAhgiC0UNACABKAIcIQogBkEAOgBcIAYgAzYCWCAGIAI2AlQgBkEsaiIIQQA2AgAgBkKAgICAEDcCJCAGQSRqIAZB1ABqELocIAZB0ABqIAgoAgAiCDYCACAGIAYpAiQ3A0ggBigCTCAIQZyHxABBAhDBLiAGQcgAahDeOw0AIAtBAyAKKAIUEQAACyAFKAIUIQoCQAJAIAUoAiAiCEEBaiILRQ0AIAUoAhgiBSALTQRAIAUgC0YNAQwCCyAKIAtqLAAAQb9/TA0BCyABIAogCiALahCBJiAGIAM2AiggBiACNgIkQZyHxABBAiAGQSRqIgUQhRUEQCAGKAIoIQMgBigCJCECIAUgAUEk/AoAACAAIAUgAiADIAQgCBCUAgwFCyAGQSRqIgIgAUEk/AoAACAAIAIgCSAHIAQgCBCUAgwECyAKIAVBACALQZSVxAAQozYACyADIAJBACAIQZSVxAAQozYACyABIAcgByAJahCBJiAGQSRqIAEgBCAFKAIgIgQgAiADEM4RIAYoAiQiA0ECRgRAIAYtACghAiAAQQI2AgAgACACOgAEIAEQ3jsMAgsgBikCKCENIAYoAjAhAiAAIAM2AgAgACACNgIMIAAgBDYCICAAIA03AgQgAEEYaiABQQhqKAIANgIAIAAgASkCADcCECAAIAUpAjQ3AjQgAEE8aiAFQTxqKQIANwIAIABBxABqIAVBxABqLQAAOgAAIAAgBSgCHDYCHCAAIAUpAiw3AiwgACAFKQIkNwIkDAELAkACQCAFKAIABEAgBUEEaiEHDAELIAUoAggEQCAFQQxqIQcMAQsgBSgCFCEJIAUoAhgiCCEHDAELIAUoAhghCCAFKAIUIQkgBygCACIHRQRAQQAhBwwBCwJAIAcgCE8EQCAHIAhHDQEgByEIDAILIAcgCWosAABBv39KDQELDAILIAEgCSAHIAlqEIEmIAEgBCAFKAIwIgoQjwsCQAJAIAogASgCCEcNAAJAIAUoAiAiB0UNACAHIAhPBEAgByAIRg0BDAMLIAcgCWosAABBv39MDQILIAkgBxCPJEH/AXFBAkYEQCAGIAM2AiggBiACNgIkIAZBJGoQ7hJBgIDEAEYNAQsgASgCCCEHIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAHQQFqNgIICyAGIAM2AiggBiACNgIkAn8gBkEkaiIHEO4SQS9HBEAgBkEBOgAkIAZBEGogASAEIAcgCiACIAMQvwEgBigCECEIIAYoAhQMAQsgBigCKCEDIAYoAiQhAiAGQQE6ACQgBkEIaiABIAQgBkEkaiAKIAIgAxC/ASAGKAIIIQggBigCDAshAyAGQSRqIgIgAUEk/AoAACAAIAIgBCAFKAIgIAUoAiQgBSgCKCAFKAIsIAVBNGogBS8BHCAFLwEeIAogCCADENEHDAELDAELIAZB4ABqJAAPCyAJIAhBACAHQZSVxAAQozYAC6AUAg9/A34jAEHQAWsiBSQAIAVBiAFqIgkgAkEAQQRBCBCgGCAFKAKMASEGAkAgBSgCiAFBAUcEQCAFQQA2AiAgBSAFKAKQATYCHCAFIAY2AhggCSACQQBBBEEMEKAYIAUoAowBIQYgBSgCiAFBAUcEQCAFQQA2AiwgBSAFKAKQATYCKCAFIAY2AiQgASACQQJ0aiEOIAJFDQIgBUGoAWohEiABIQkDQCADIAtBFGxqQQAgBCALSxtBACADGyEGAn8CQCAJKAIAIgcQkzYiAgRAIAYNASACIQYLQQAMAQsgBUGIAWogAiAGEMoiIAVB2ABqIAVBmAFqKAIANgIAIAVB0ABqIAVBkAFqKQIANwMAIAUgBSkCiAE3A0ggBUHIAGohBkEBCyETAkACQAJAAkAgBygCPCAHKAJAIgwoAghBAWtBeHFqQQhqIg8gDCgCJBEEACIQQQN2IBBBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiCEHAABDRNARAAkACQCAIRQRAQcAAIQoMAQsgCEHAABCtNiIKRQ0BCyAFQgA3AmggBSAKNgJkIAUgCDYCYCAFQcAANgJcIAIEQEEAIREgAiAISwRAIAVB3ABqIAhBAXQQ6BkgBSgCaCERIAUoAmQhCgsgAgRAIAogEWpBACAC/AsACyAFIAI2AmgLIAUgEDYCbCAGRQ0CIAVBiAFqIAYQyDQgBygCHCEIIAcoAiAhAgNAAkAgBSkDsAEiFVBFBEAgBSkDuAEhFAwBCwNAAn4CQCAFKQOYASIUQgNSBEACQAJAAkAgFEICUQ0AIAUgFFCtQgGGNwOYASAUp0EBcUUNACAFIAUpA6ABNwPIAQwBCyAFKAKoAUUNASAFQcABaiASELYqIAUpA8ABIRQLIBRCAFINAgsgBUIDNwOYAQsgBSkDiAEiFEICUQ0IIAVCADcDiAEgBSkDkAEMAQsgBSkDyAELIRUgFKdBAXFFDQYgBSAFKQO4AUJAfSIUNwO4ASAFIBU3A7ABIBVQDQALCyAFIBVCASAVeiIWhoU3A7ABAkAgAiAWpyAUp2oiBksEQCAGIAhqLQAAIQYgBUEQaiAFQdwAahCGPSAFKAIUIgogBkEDdiIHSw0BIAcgCkHQsoMBEMMhAAsgBiACQci0gwEQwyEACyAFKAIQIAdqIgcgBy0AAEEBIAZBB3F0cjoAAAwACwALQcAAIAgQoz0AC0HgsoMBQSkgBUGIAWpBrLODAUGMs4MBENUeAAsgBygCICIGRQ0AIAcoAhwhAgNAIAItAAAhByAFQQhqIAVB3ABqEIY9IAUoAgwiCiAHQQN2IghNDQIgBSgCCCAIaiIIIAgtAABBASAHQQdxdHI6AAAgAkEBaiECIAZBAWsiBg0ACwsgBUGIAWoiAiAFQdwAaiIGEIYUIAYQzy8gBUEwaiAPIAwgAhCNASAFKAI4IQYgBSgCLCICIAUoAiRGBEAgBUEkakGYtIMBEJAoCyAFKAIoIAJBDGxqIgcgBSkCMDcCACAHQQhqIAVBOGooAgA2AgAgBSACQQFqNgIsIAUoAiAiAiAFKAIYRgRAIAVBGGpBqLSDARCbKAsgBSgCHCACQQN0aiIHIAw2AgQgByAPNgIAIAUgAkEBajYCICAFKAKIASICIAIoAgAiAkEBazYCACACQQFGBEAgBUGIAWoQ+x4LIBNFDQEgBSgCSCICIAIoAgAiAkEBazYCACACQQFHDQEgBUHIAGoQ+x4MAQsgCCAKQdCygwEQwyEACyALQQFqIQsgBiANaiENIAlBBGoiCSAORw0ACwwCCyAGIAUoApABQfizgwEQ/S8ACyAGIAUoApABQeizgwEQ/S8ACyAFQawBaiIKQn8gDa1CgAF8eSIUiKdBAWoiAkF/IAIbQZyzgwEQohogBSAUPgKoASAFQpeSnKrbtrXCPzcDoAEgBULdofHL/LaK1kA3A5gBIAVC7Jikp/PZmaq+fzcDkAEgBUL3psDG47yIlMUANwOIASAFQdwAaiIGIA1BAEEEQQgQoBggBSgCYCECIAUoAlxBAUcEQCAFQQA2AkQgBSAFKAJkNgJAIAUgAjYCPCAFKAIkIQMgBSgCKCECIAUoAiwhBCAFQgA3AnggBSACIARBDGxqNgJ0IAUgAzYCcCAFIAI2AmwgBSACNgJoIAVBADYCZCAFIA42AmAgBSABNgJcIAUgBUE8ajYChAEgBSAFQYgBajYCgAEgBUHIAGohBCMAQdAAayIDJAAgA0GTgICAeDYCACADQSBqIgEgBkEs/AoAACADIAM2AkwgA0EUaiEJIwBB0ABrIgIkACACQRRqIAEQuSUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgdBBEEAQQRBDBCgGCACKAIkIQYgAigCIEEBRg0CIAIoAigiCCACKQIUNwIAIAhBCGogAkEcaigCADYCACACQRBqIgtBATYCACACIAg2AgwgAiAGNgIIIAcgAUEw/AoAACMAQRBrIgEkACABQQRqIAcQuSUgASgCBEGAgICAeEcEQCACQQhqIQYDQCAGKAIIIgggBigCAEYEQCAGIAhBAUEEQQwQ3igLIAYoAgQgCEEMbGoiDCABKQIENwIAIAxBCGogAUEMaigCADYCACAGIAhBAWo2AgggAUEEaiAHELklIAEoAgRBgICAgHhHDQALCyAHQQxqELkgIAFBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIADAELIAlBADYCCCAJQoCAgIDAADcCACABQQxqELkgCyACQdAAaiQADAELIAYgAigCKEGI+YMBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAQgAykCADcCACAEQRBqIANBEGooAgA2AgAgBEEIaiADQQhqKQIANwIAIAkQ1ysgCUEEQQwQ4B4MAQsgBCADKQIUNwIEIARBk4CAgHg2AgAgBEEMaiADQRxqKAIANgIACyADQdAAaiQAIAVByAFqIgEgBUHUAGooAgA2AgAgBSAFKQJMNwPAAQJAIAUoAkgiAkGTgICAeEcEQCAFKAJYIQMgACAFKQPAATcCCCAAIAM2AhQgACACNgIEIABBATYCACAAQRBqIAEoAgA2AgAMAQsgBUHQAGoiAyAFQcgBaigCADYCACAFIAUpA8ABNwNIIAVB3ABqIAUoAhwgBSgCICAFKAJAIAUoAkQQrwIgBSgCZCEBIAUoAmAhAiAFKAJcIgRBk4CAgHhHBEAgACAFKQJoNwIQIAAgATYCDCAAIAI2AgggACAENgIEIABBATYCACAFQcgAaiIAENcrIABBBEEMEOAeDAELIAAgBSkDSDcCBCAAQQxqIAMoAgA2AgAgACABNgIUIAAgAjYCECAAQQA2AgALIAVBPGpBBEEIEOAeIApBBEEQEOAeIAVBGGpBBEEIEOAeIAVB0AFqJAAPCyACIAUoAmRBiLSDARD9LwALoBQCD38DfiMAQdABayIFJAAgBUGIAWoiCSACQQBBBEEIEKAYIAUoAowBIQYCQCAFKAKIAUEBRwRAIAVBADYCICAFIAUoApABNgIcIAUgBjYCGCAJIAJBAEEEQQwQoBggBSgCjAEhBiAFKAKIAUEBRwRAIAVBADYCLCAFIAUoApABNgIoIAUgBjYCJCABIAJBAnRqIQ4gAkUNAiAFQagBaiESIAEhCQNAIAMgC0EUbGpBACAEIAtLG0EAIAMbIQYCfwJAIAkoAgAiBxCTNiICBEAgBg0BIAIhBgtBAAwBCyAFQYgBaiACIAYQyiIgBUHYAGogBUGYAWooAgA2AgAgBUHQAGogBUGQAWopAgA3AwAgBSAFKQKIATcDSCAFQcgAaiEGQQELIRMCQAJAAkACQCAHKAI8IAcoAkAiDCgCCEEBa0F4cWpBCGoiDyAMKAIkEQQAIhBBA3YgEEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyIIQcAAENE0BEACQAJAIAhFBEBBwAAhCgwBCyAIQcAAEK02IgpFDQELIAVCADcCaCAFIAo2AmQgBSAINgJgIAVBwAA2AlwgAgRAQQAhESACIAhLBEAgBUHcAGogCEEBdBDoGSAFKAJoIREgBSgCZCEKCyACBEAgCiARakEAIAL8CwALIAUgAjYCaAsgBSAQNgJsIAZFDQIgBUGIAWogBhDINCAHKAIcIQggBygCICECA0ACQCAFKQOwASIVUEUEQCAFKQO4ASEUDAELA0ACfgJAIAUpA5gBIhRCA1IEQAJAAkACQCAUQgJRDQAgBSAUUK1CAYY3A5gBIBSnQQFxRQ0AIAUgBSkDoAE3A8gBDAELIAUoAqgBRQ0BIAVBwAFqIBIQtiogBSkDwAEhFAsgFEIAUg0CCyAFQgM3A5gBCyAFKQOIASIUQgJRDQggBUIANwOIASAFKQOQAQwBCyAFKQPIAQshFSAUp0EBcUUNBiAFIAUpA7gBQkB9IhQ3A7gBIAUgFTcDsAEgFVANAAsLIAUgFUIBIBV6IhaGhTcDsAECQCACIBanIBSnaiIGSwRAIAYgCGosAAAhBiAFQRBqIAVB3ABqEIY9IAZBA3YiByAFKAIUIgpJDQEgByAKQdCygwEQwyEACyAGIAJByLSDARDDIQALIAUoAhAgB2oiByAHLQAAQQEgBkEHcXRyOgAADAALAAtBwAAgCBCjPQALQeCygwFBKSAFQYgBakGss4MBQYyzgwEQ1R4ACyAHKAIgIgZFDQAgBygCHCECA0AgAiwAACEHIAVBCGogBUHcAGoQhj0gB0EDdiIIIAUoAgwiCk8NAiAFKAIIIAhqIgggCC0AAEEBIAdBB3F0cjoAACACQQFqIQIgBkEBayIGDQALCyAFQYgBaiICIAVB3ABqIgYQhhQgBhDPLyAFQTBqIA8gDCACEI0BIAUoAjghBiAFKAIsIgIgBSgCJEYEQCAFQSRqQZi0gwEQkCgLIAUoAiggAkEMbGoiByAFKQIwNwIAIAdBCGogBUE4aigCADYCACAFIAJBAWo2AiwgBSgCICICIAUoAhhGBEAgBUEYakGotIMBEJsoCyAFKAIcIAJBA3RqIgcgDDYCBCAHIA82AgAgBSACQQFqNgIgIAUoAogBIgIgAigCACICQQFrNgIAIAJBAUYEQCAFQYgBahD7HgsgE0UNASAFKAJIIgIgAigCACICQQFrNgIAIAJBAUcNASAFQcgAahD7HgwBCyAIIApB0LKDARDDIQALIAtBAWohCyAGIA1qIQ0gCUEEaiIJIA5HDQALDAILIAYgBSgCkAFB+LODARD9LwALIAYgBSgCkAFB6LODARD9LwALIAVBrAFqIgpCfyANrUKAAXx5IhSIp0EBaiICQX8gAhtBnLODARCiGiAFIBQ+AqgBIAVCl5Kcqtu2tcI/NwOgASAFQt2h8cv8torWQDcDmAEgBULsmKSn89mZqr5/NwOQASAFQvemwMbjvIiUxQA3A4gBIAVB3ABqIgYgDUEAQQRBCBCgGCAFKAJgIQIgBSgCXEEBRwRAIAVBADYCRCAFIAUoAmQ2AkAgBSACNgI8IAUoAiQhAyAFKAIoIQIgBSgCLCEEIAVCADcCeCAFIAIgBEEMbGo2AnQgBSADNgJwIAUgAjYCbCAFIAI2AmggBUEANgJkIAUgDjYCYCAFIAE2AlwgBSAFQTxqNgKEASAFIAVBiAFqNgKAASAFQcgAaiEEIwBB0ABrIgMkACADQZOAgIB4NgIAIANBIGoiASAGQSz8CgAAIAMgAzYCTCADQRRqIQkjAEHQAGsiAiQAIAJBFGogARC3JQJAAkACQCACKAIUQYCAgIB4RwRAIAJBIGoiB0EEQQBBBEEMEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCIIIAIpAhQ3AgAgCEEIaiACQRxqKAIANgIAIAJBEGoiC0EBNgIAIAIgCDYCDCACIAY2AgggByABQTD8CgAAIwBBEGsiASQAIAFBBGogBxC3JSABKAIEQYCAgIB4RwRAIAJBCGohBgNAIAYoAggiCCAGKAIARgRAIAYgCEEBQQRBDBDeKAsgBigCBCAIQQxsaiIMIAEpAgQ3AgAgDEEIaiABQQxqKAIANgIAIAYgCEEBajYCCCABQQRqIAcQtyUgASgCBEGAgICAeEcNAAsLIAdBDGoQuSAgAUEQaiQAIAlBCGogCygCADYCACAJIAIpAgg3AgAMAQsgCUEANgIIIAlCgICAgMAANwIAIAFBDGoQuSALIAJB0ABqJAAMAQsgBiACKAIoQYj5gwEQ/S8ACwJAIAMoAgBBk4CAgHhHBEAgBCADKQIANwIAIARBEGogA0EQaigCADYCACAEQQhqIANBCGopAgA3AgAgCRDXKyAJQQRBDBDgHgwBCyAEIAMpAhQ3AgQgBEGTgICAeDYCACAEQQxqIANBHGooAgA2AgALIANB0ABqJAAgBUHIAWoiASAFQdQAaigCADYCACAFIAUpAkw3A8ABAkAgBSgCSCICQZOAgIB4RwRAIAUoAlghAyAAIAUpA8ABNwIIIAAgAzYCFCAAIAI2AgQgAEEBNgIAIABBEGogASgCADYCAAwBCyAFQdAAaiIDIAVByAFqKAIANgIAIAUgBSkDwAE3A0ggBUHcAGogBSgCHCAFKAIgIAUoAkAgBSgCRBCvAiAFKAJkIQEgBSgCYCECIAUoAlwiBEGTgICAeEcEQCAAIAUpAmg3AhAgACABNgIMIAAgAjYCCCAAIAQ2AgQgAEEBNgIAIAVByABqIgAQ1ysgAEEEQQwQ4B4MAQsgACAFKQNINwIEIABBDGogAygCADYCACAAIAE2AhQgACACNgIQIABBADYCAAsgBUE8akEEQQgQ4B4gCkEEQRAQ4B4gBUEYakEEQQgQ4B4gBUHQAWokAA8LIAIgBSgCZEGItIMBEP0vAAueDwIEfwF+IwBB0ABrIgQkACAEIAI6AAcCQCADQf8BcUUEQCAEQQE2AjwgBEG4ps4ANgI4IARCATcCRCAEQbkHNgIkIAQgBEEgajYCQCAEIARBB2o2AiAgAEEEaiAEQThqEJkOIABBBjoAECAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXFBAmsODAoJCAcGBQQLAwIBAAsLIARBOGogARDJDyAELQBAIQYgBCgCPCECIAQoAjgiBUEERwRAIAAgBCkAQTcACSAAQRBqIARByABqKAAANgAAIAAgBjoACCAAIAI2AgQgACAFNgIADAwLIAJBAEoEQCADQQFrIQMDQCAEQThqIAEgBiADEMkCIAQoAjgiBUEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBTYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLCyAEQThqELMeIAQtAEAhBiAEKAI8IQIgBCgCOCIFQQRHBEAgACAEKQBBNwAJIABBEGogBEHIAGooAAA2AAAgACAGOgAIIAAgAjYCBCAAIAU2AgAMCwsgAkEASgRAIANBAWshAwNAIARBOGogASAGIAMQyQIgBCgCOCIFQQRHBEAgACAEKQI8NwIEIABBDGogBEHEAGopAgA3AgAgACAFNgIADA0LIAJBAWsiAg0ACwsgABCzHgwKCyAEQThqELMeIAQpAjwhCCAEKAI4IgJBBEcEQCAAIAQpAkQ3AgwgACAINwIEIAAgAjYCAAwKCwJAAkAgCKciAkEASgRAIAhCIIinIgZB/wFxQRBGDQIgCEIoiKciBUH/AXFBEEYNASADQQFrIQMDQCAEQThqIAEgBiADEMkCIAQoAjgiB0EERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBzYCAAwOCyAEQThqIAEgBSADEMkCIAQoAjgiB0EERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBzYCAAwOCyACQQFrIgINAAsLIABBBDYCAAwLC0H8ps4AQSxBqKfOABDLJAALQcCmzgBBKkHsps4AEMskAAsgBEE4aiABEPAnIARBKGoiAiAEQcQAaigCADYCACAEIAQpAjw3AyAgBCgCOCIGQQRHBEAgBCgCSCEBIAAgBCkDIDcCBCAAIAE2AhAgACAGNgIAIABBDGogAigCADYCAAwJCyAEQRBqIAIoAgA2AgAgBCAEKQMgIgg3AwggCKdBgICAgHhHBEAgBEEIahDeOwsgBEE4aiABENMJIARBKGoiAiAEQcQAaikCADcDACAEQTBqIgYgBEHMAGooAgA2AgAgBCAEKQI8NwMgAkAgBCgCOEUEQCADQQFrIQcgBEE8aiEDA0AgBEEYaiAGKAIAIgU2AgAgBEEQaiACKQMANwMAIAQgBCkDIDcDCCAFQf8BcUUNAiAEQThqIAEgBSAHEMkCIAQoAjgiBUEERwRAIAAgBCkCPDcCBCAAQQxqIARBxABqKQIANwIAIAAgBTYCACAEQQhqEIYwDAwLIARBCGoQhjAgBEE4aiABENMJIAIgA0EIaikCADcDACAGIANBEGooAgA2AgAgBCADKQIANwMgIAQoAjhFDQALCyAAIAQpAyA3AgAgAEEQaiAGKAIANgIAIABBCGogAikDADcCAAwJCyAEQQhqEIYwIAAgARCoKQwICyAEQThqIAEQwhUgBCgCOEEERwRAIAAgBCkCODcCACAAQRBqIARByABqKAIANgIAIABBCGogBEFAaykCADcCAAwICyAEQShqIARBxABqKAIANgIAIAQgBCkCPDcDICAEQSBqEN47IABBBDYCAAwHCyAEQThqIAEQwBwgBCgCOEEBRgRAIAAgBCkCPDcCACAAQRBqIARBzABqKAIANgIAIABBCGogBEHEAGopAgA3AgAMBwsgAEEENgIADAYLIARBOGogARDAHAJAIAQoAjhFDQAgBCgCPCIBQQRGDQAgBCkDQCEIIAAgBCkDSDcCDCAAIAg3AgQgACABNgIADAYLIABBBDYCAAwFCyAEQThqIAEQwBwCQCAEKAI4RQ0AIAQoAjwiAUEERg0AIAQpA0AhCCAAIAQpA0g3AgwgACAINwIEIAAgATYCAAwFCyAAQQQ2AgAMBAsgASgCECICQQdLBEAgAEEENgIAIAEgAkEIazYCECABIAEoAgxBCGo2AgwMBAtBCCACQcSzzgAQsDsACyAEQThqIAEQkhggBCgCOEEERwRAIAAgBCkCODcCACAAQRBqIARByABqKAIANgIAIABBCGogBEFAaykCADcCAAwDCyAAQQQ2AgAMAgsgBEE4aiABENoQIAQoAjhBBEcEQCAAIAQpAjg3AgAgAEEQaiAEQcgAaigCADYCACAAQQhqIARBQGspAgA3AgAMAgsgAEEENgIADAELIAQgAjoANyAEQQE2AjwgBEHQp84ANgI4IARCATcCRCAEQboHNgIkIAQgBEEgajYCQCAEIARBCGo2AiAgBCAEQTdqNgIIIABBBGogBEE4ahCZDiAAQQA6ABAgAEEBNgIACyAEQdAAaiQAC4kVAgp/BH4jAEGQA2siAiQAIAFB8ABqIQdBASEEAkACQAJAIAEoAnAiA0UEQAJAAkAgASgCbCABKAI4RwRAIAJBqAJqQSVBAEEBQQEQoBggAigCrAIhAyACKAKoAkEBRgRAIAMgAigCsAJB8MXDABD9LwALIAIoArACIgRB2cTDAEEl/AoAACAAQSU2AgwgACAENgIIIAAgAzYCBCAAQQA2AgAMAQsgASkCMCEMIAFCgICAgIABNwMwIAJBCGogAUE4aiIDKAIANgIAIANBADYCACACIAw3AwAgASgCYCIDIAMoAgAiBEEBajYCACAEQQBIDQUgAkGoAmohBCMAQRBrIgUkACAFQQRqIAMoAhBBAEEIQcACEKAYIAUoAgghBiAFKAIEQQFGBEAgBiAFKAIMQeT4zwAQ/S8ACyAFKAIMIQggBEIANwMQIARCADcDACAEQRhqQgA3AwAgBCADNgI8IARBADsBOCAEQoCAgICAgICAgH83AyggBCAINgIkIAQgBjYCICAFQRBqJAAgAkHoAWohAyAEKAIoIgYEQCAEKAIkIQUDQCAFEPASIAVBwAJqIQUgBkEBayIGDQALCyAEQSBqQQhBwAIQ4B4gBEEoaiACQQhqKAIANgIAIAQgAikCADcCICADIARBwAD8CgAAIAJBsAFqIAJB8AFqKQMANwMAIAIgAikD6AE3A6gBIAIgASkDGDcDgAIgAkHAAWogAkGAAmpBKPwKAAAgAiABKQMIQgAgASgCABs3A7gBAkAgASgCZEEIaiIFQfgAakEAIAUoAnhBgICAgHhHGyIFBEAgAyAFEJMYDAELIANBgICAgHg2AgALIAJBqAFqIgZBLGohBSAGKAIsQYCAgIB4RwRAIAVBBEEIEOAeCyAFIAMpAgA3AgAgBUEIaiADQQhqKAIANgIAIAQgBkHAAPwKAAAgAkEBOwHgAiACIAEvAXQ7AeICIAJB+AFqIAJBuAJqQTD8CgAAIAJCATcD6AEgAiABKQMgNwPwASACQegAaiEFIwBBMGsiBCQAAkAgAygCPCgCECIIIAMoAigiBkYEQCAFIANBwAD8CgAADAELIAQgCDYCGCAEIAY2AhwgBEECNgIEIARBkPnPADYCACAEQgI3AgwgBEE7NgIsIARBOzYCJCAEIARBIGo2AgggBCAEQRxqNgIoIAQgBEEYajYCICAFQQxqIAQQmQ4gBUICNwMAIAVBADYCCCAGBEAgAygCJCEFA0AgBRDwEiAFQcACaiEFIAZBAWsiBg0ACwsgA0EgakEIQcACEOAeIAMoAixBgICAgHhHBEAgA0EsakEEQQgQ4B4LIANBPGoiAygCACIFIAUoAgAiBUEBazYCACAFQQFHDQAgAxCGHwsgBEEwaiQAIAJB2ABqIgMgAkH4AGopAwA3AwAgAkHgAGoiBCACQYABaikDADcDACACIAIpA3A3A1AgAikDaCIMQgJSDQEgACACKQNQNwMAIABBEGogBCkDADcDACAAQQhqIAMpAwA3AwALIAEoAmAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAFB4ABqEIYfCyABKAJkIgAgACgCACIAQQFrNgIAIABBAUYEQCABQeQAahCuIAsCQCAHKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAcQ7h0LIAFBMGoiABCfLCAAEPM7IAFBPGoiABCGKSAAEOg7IAFByABqIgAQ1x4gAEEEQcwAEOAeIAFB1ABqIgAQ5ScgAEEEQRgQ4B4MAgsgAkHIAGogAkGgAWopAwA3AwAgAkFAayACQZgBaikDADcDACACQThqIAJBkAFqKQMANwMAIAJBIGoiAyACQdgAaikDADcDACACQShqIAJB4ABqKQMANwMAIAIgAikDiAE3AzAgAiACKQNQNwMYIAIgDDcDECACQegBaiACQTBqEMABIAMpAwAhDAJAIAIoAjxBgICAgHhHBEAgAkGoAmogAkE8ahCTGAwBCyACQYCAgIB4NgKoAgsgAikDKCENIAIoAkwiBCAEKAIAIgNBAWo2AgAgA0EASA0DIAJBsAFqIgUgAkHwAWooAgA2AgAgAkHwAGoiBiACQbACaigCADYCACACIAIpAugBNwOoASACIAIpAqgCNwNoIAIvAUohCCACLwFIIQkgAikDGCEOIAIpAxAhDwJAAkBByABBCBCtNiIDBEAgAyANNwMgIAMgDDcDGCADIA43AxAgAyAPNwMIIANCgYCAgBA3AwAgAyACKQOoATcDKCADIAIpA2g3AjQgAyAENgJEIAMgCDsBQiADIAk7AUAgA0EwaiAFKAIANgIAIANBPGogBigCADYCAAJAIAcoAgAiBEUNACAEIAQoAgAiBEEBazYCACAEQQFHDQAgBxDuHQsgASADNgJwIAEoAighBSABQQA2AiggBUUNASABKAIsIQMgASgCaCEGIAJBqAJqIgggAkEQakHAAPwKAAAgAkHwAmogAUHEAGooAgA2AgAgAkH8AmogAUHQAGooAgA2AgAgAkGMA2ogAUHcAGooAgA2AgAgAiAGNgKAAyACIAEpAjw3A+gCIAIgASkCSDcC9AIgAiABKQJUNwKEAyMAQfAAayIEJAAgBCAGNgJgIARBCGoiCSAIQcAA/AoAACAEQdAAaiACQegCaiIIQQhqKAIANgIAIARB3ABqIAJB9AJqIgpBCGooAgA2AgAgBEHsAGogAkGEA2oiC0EIaigCADYCACAEIAgpAgA3A0ggBCAKKQIANwJUIAQgCykCADcCZCACQegBaiAFIAYgCSAEQcgAaiAEQdQAaiAEQeQAaiADKAIMEQsAIAMoAgQiBgRAIAUgBiADKAIIEPg6CyAEQfAAaiQAIAIoAugBIgNBCEYNAiAAIAIpAuwBNwIEIABBFGogAkH8AWooAgA2AgAgAEEMaiACQfQBaikCADcCACAAIAM2AgAgAUHgAGoiACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABCGHwsgAUHkAGoiACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABCuIAsgAUEwaiEAAkAgBygCACIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAHEO4dCyAAEJ8sIAAQ8zsMBAtBCEHIABCjPQALIAJBEGoQ/yULIAcoAgAiA0UNAiAFRSEECyADIAMoAgAiBUEBajYCACAFQQBIDQIgAEEINgIAIAAgAzYCBCABKAJgIgAgACgCACIAQQFrNgIAIABBAUYEQCABQeAAahCGHwsgASgCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUHkAGoQriALAkAgBygCACIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAHEO4dCyABQTBqIgAQnywgABDzOyAERQ0AIAFBPGoiABCGKSAAEOg7IAFByABqIgAQ1x4gAEEEQcwAEOAeIAFB1ABqIgAQ5ScgAEEEQRgQ4B4LAkAgASgCKCIARQ0AIAEoAiwiASgCACIDBEAgACADEQMACyABKAIEIgNFDQAgACADIAEoAggQ+DoLIAJBkANqJAAPC0HAxcMAELI7CwALxg4BGn8jAEFAaiIKJAAgCkEYakIANwMAIApBEGpCADcDACAKQQhqQgA3AwAgCkIANwMAAkAgAyAETwRAIAQEQCAEQQF0IQsgAiEJA0AgCS8BACIMQRBPDQMgCiAMQQF0aiIMIAwvAQBBAWo7AQAgCUECaiEJIAtBAmsiCw0ACwsgCkE4aiAKQRhqKQMANwMAIApBMGogCkEQaikDADcDACAKQShqIApBCGopAwA3AwAgCiAKKQMANwMgIApBPmohCUEOIQ0CQAJAA0AgCS8BAARAQQEhDAJAIA1BAWoiFEECSQ0AIApBIGpBAnIhCSANIQsDQCAJLwEADQEgCUECaiEJIAxBAWohDCALQQFrIgsNAAsgFCEMCyAMIBQgByAHIBRLGyIHIAcgDEkbIQ9BAiEJQQEhCwNAIAtBAXQgCSAKai8BAGsiC0EASARAIABBfzYCAAwECyAJQQJqIglBIEcNAAsgC0EAIAFB/wFxRSANchtFBEAgCkE4akIANwMAIApBMGpCADcDACAKQShqQgA3AwAgCkIANwMgQQQhCSAKLwEiIQsDQCAKQSBqIAlqIAsgCSAKakECay8BAGoiCzsBACAJQQJqIglBIEcNAAsgBARAIARBAXQhBEEAIQsgAiEJA0ACQCAJLwEAIgdFDQAgB0EPTQRAIApBIGogB0EBdGoiByAHLwEAIgdBAWo7AQAgB0GgAkkEQCAIIAdBAXRqIAs7AQAMAgsgB0GgAkG8hf0AEMMhAAsgB0EQQayF/QAQwyEACyAJQQJqIQkgC0EBaiELIARBAmsiBA0ACwsgD0EfcSEEQQIhGUEUIRVBAiEaAkACQAJAAkAgAUH/AXEiGEEBaw4CAAECCyAEQQtPDQJBkIL9ACEaQc6C/QAhGUGBAiEVQR8hGAwBCyAEQQlLDQFBjIP9ACEaQcyD/QAhGUEgIRhBACEVC0EBIAR0IhZBAWshHyAVQQFrQf//A3EhICABQf8BcUEBayEhQQAhByAPIQ5BfyEEA0ACQCAVIAggEEEBdGovAQAiAUsEQCABQQAgASAgSSIJGyEBQQBB4AAgCRshHAwBCyABIBVrQf//A3EiASAYSQRAIBogAUEBdCIJai8BACEBIAkgGWotAAAhHAwBCyABIBhBnIT9ABDDIQALAkACQAJAAkACQAJ/AkACQAJAAkAgByASdiARaiIHIAZNBEACQEEBIAwgEmsiG3QiHUEBayAOdkEBcUEBIA50IiIgG3ZqIhMEQCAGIAdrIR4gBSAHQQJ0aiEJIB1BAnQhB0EAIQsDQCALIB5PDQIgCSABOwEAIAlBA2ogGzoAACAJQQJqIBw6AAAgByAJaiEJIAsgHWohCyATQQFrIhMNAAsLIAxBD0sNAkGAgICAeCAMQQFrdiAXaiIXQRh0IBdBgP4DcUEIdHIgF0EIdkGA/gNxIBdBGHZyciIBQQR2QY+evPgAcSABQY+evPgAcUEEdHIiAUECdkGz5syZA3EgAUGz5syZA3FBAnRyIgFBAXZB1arVqgVxIAFB1arVqgVxQQF0ciEHIBBBAWohECAKIAxBAXRqIgEgAS8BAEEBayIBOwEAAkACQCABQf//A3FFBEAgDSAMa0F/Rg0BIBBBoAJPDQYgAyAIIBBBAXRqLwEAIgFNDQcgAiABQQF0ai8BACEMCyAMIA9NDQ0gByAfcSIBIARHDQEMDQsgFw0IDAkLQQEgDCASIA8gEhsiEmsiDnQiCyAMIBRPDQYaIA0gEmtBAWohDiAKIAxBAXRqIQkgDCETA0AgCyAJLwEAayIEQQBMBEAgEyASayEODAcLIAlBAmohCSAEQQF0IQsgE0EBaiITIBRJDQALDAULIAsgHkGchf0AEMMhAAsgByAGQayE/QAQrzsACyAMQRBBvIT9ABDDIQALIBBBoAJBzIT9ABDDIQALIAEgA0HchP0AEMMhAAtBASAOdAsgFmohFgJAAkACQCAhDgIAAQILIBZBtApNDQEMCAsgFkHQBEsNBwsgASAGSQRAIAUgAUECdGoiBCAPOgADIAQgDjoAAiAEIBEgImoiETsBACABIQQMBQsgASAGQYyF/QAQwyEACyAGIBFJDQIgByAGIBFrIgFPDQEgBSARQQJ0aiAHQQJ0aiIBIBs6AAMgAUHAADoAAiABQQA7AQALIAAgFjYCCCAAIA82AgQgAEEANgIADAgLIAcgAUH8hP0AEMMhAAsgESAGQeyE/QAQrzsACyAQQaACRw0AC0GgAkGgAkGMhP0AEMMhAAsgAEEBNgIADAMLIABBfzYCAAwCCyAJQQJrIQkgDUEBayINQX9HDQALIAZFDQEgBUGAgIAKNgEAIAZBAUcEQCAAQQI2AgggBUGAgIAKNgEEIABCgICAgBA3AgAMAQtBAUEBQYCC/QAQwyEACyAKQUBrJAAPC0EAQQBB8IH9ABDDIQALIAQgA0Hggf0AELA7AAsgDEEQQcyF/QAQwyEAC+ofAjd/An4jAEEgayITJAACQCAAKAIAIgpFBEBBRCEKDAELAkAgCkEBRgRAIAEgAiAAQbgBaiAAKQPIBEIBfSAAKAKQBBCiDiIlQYh/Sw0BIABBAjYCACACICVrIQIgASAlaiEBCyAERQ0AIABB2BBqIjYgAyAEIAAoAsAREIMXRQRAIABBADYCwBEgACAAKALkEDYC9BALIAAoAowCQQFGBEAgAEGQBmogAyAEQQAQgxcaCyAAKAK8ASEKIAAoAsQEIQsgACgC3AEEQCAAQeAEaiADIAQQiQwLIABBuAFqITdBASAKdCErIABBqBRqISYgAEHUFGohLCAAQYAVaiEtIABB5AVqIRwgAEGYBGohOCABIQ0gBCEfA0ACQCALIQYgAyEQAkACQAJAAkAgHwRAQbp/IQogAkEGSQ0IIDYgOCA3IBAgECAfIAYgBiAfSxsiC2oiAxCbDgJAIAAoAvAQIgcgK2ogAyAAKALcECIOa08EQCAHIAAoAuQQRg0BC0EAIQcgAEEANgKMEiAAQQA2AvAQCwJAIBAgDmsiDiAHICtqTQRAIAAoAugQIQcMAQsgACgC6BAiByAOICtrIg5JBEAgACAONgLoECAOIQcLIAcgACgC5BBLBEAgACAHNgLkEAsgAEEANgKMEiAAQQA2AvAQCyAHIAAoAvQQSwRAIAAgBzYC9BALIAVBACAGIB9PGyEYIAAoAuwBBEAgACAQIAsQkAciBkGIf0sEQCAGIQoMCgsCQAJAIAYNAAJAIAAoAtwFDQAgHCgCBCAcKAIAa0EgSSAcKAIMIBwoAghrQQpJcUUNACAQIAsQug5FDQAgDSAQLQAAOgADIA0gC0ENdjoAAiANIBggC0EDdHJBAnI7AABBBCEGDAILIBAhF0EAIQxBACERIwBB0AJrIgkkAAJAIABB5AVqIi4gACgC0BAgACgC1BAgAEG4AWogCUEMaiAAKAK4EhCsCSIIQYh/Sw0AIAkoAgxBAkYhDiACIA1qISQgCyAQaiEwIAAoAggaIAAoAtQQIh1BjA5qITEgHUG4GWohMiAdQYgIaiEzIAAoArgSISAgACgC0BAhLyAAKALoBSI0QQhrITkgCUGgAWohOiAJQRBqITsgACgC7AEhPCAAKAL8BSEnIAAoAvgFISggACgC9AUhKSAAKALwBSE1IAAoAuwFIRlBASEUIA0hDyAAKALkBSIhIRoCQANAAn8gISA0RgRAQQEhKiA1IBlrDAELIAlByAJqIC4gGiAMQQN0aiIGEOckIAxBAWohDCA1IBlrIAkoAsgCIBFqIAYgOUYiKhsLIREgCUH/ATYCuAIgESEIAkACQAJAAkAgCSgCDA4EAwABAQILQQEhCAwCCyAgIAlBuAJqIBkgESAgQdjFABDgJUGIf0sNASAdICAgCSgCuAIQ5SMgCSgCkAFBACAOG2pBA2ohCAwBC0EAIQgLAkAgKkF/cyAMBH8gCSgCmAEgJ0EfIAwgM0EAQeCY0QBBBUEcICAQ3BUgCSgClAEgKUEjIAwgMkGgmdEAQdCZ0QBBBkEjICAQ3BVqIAkoApwBIChBNCAMIDFBoJrRAEHgmtEAQQZBNCAgENwVaiAJKAKoAkEAIBQbakEDagVBAwsgCGpBA2ogPE1xDQAgGiAMQQN0IghqQQAhFiAaIQYDQCAIQQBKBEAgCUG4AmogLiAGEOckIAhBCGshCCAGQQhqIQYgCSgCvAIgFmohFgwBCwsgD0EDaiEeICQgD2tBA2shGwJ/AkACQCARRQ0AAkACQCAJKAIMIhIOAgIAAQsgDiEHIB4gGSAREO4gDAMLIB5BA0EEIBFBgAhByAFBACAOGyIGa0kbIBFBgIABIAZrT2oiFWohBkEAIQggDkUgEkECR3JFBEAgCSgCkAEiBwRAIAYgOyAH/AoAAAsgBiAJKAKQASIIaiEGCyAkIAZrIQcCfyAVQQNGBEAgBiAHIBkgESAdEK0SDAELIAYgByAZIBEgHRCKEgsiB0EBa0GHf0sNAyAOIAcgCGoiIyARSXJFBEBBACEHIB4gGyAZIBEQ5hwMAwsgFSAjQf//AEtBBEEDICNB/wdLG2pPDQELIA4hByAeIBsgGSAREOYcDAELIBJBAyAOGyESIAYgB2ogEUEEdCEGAkACQAJAAkAgFUEEaw4CAQIACyAPIAYgEmogI0EOdGoiBjsAAyAPIAZBEHY6AAUMAgsgHiAGIBJqICNBEnRqQQhqNgAADAELIA8gI0EKdjoAByAPIAYgEmogI0EWdGpBDGo2AAMLQQAhByAeawsiCEGIf0sNAyAIRQ0AICQgCCAeaiIVa0EESA0CIAAoArwBIQYCQAJ/IAxB/wBPBEAgDEH//QFNBEAgFSAMOgABIBUgDEEIdkGAAXI6AAAgFUECagwCCyAVQf8BOgAAIBUgDEGA/gFrOwABIBVBA2oMAQsgFSAMOgAAQQEhCCAMRQRAIBQhBgwCCyAVQQFqCyEbIAZBGUshEiAbQQFqIQYCQCAUBEAgGyAJKAKYAUEEdCAJKAKUAUEGdGogCSgCnAFBAnRqOgAAIAkoAqgCIggEQCAGIDogCPwKAAALIAYgCSgCqAJqIQYMAQsgG0H8AToAAAsgBiAkIAZrIDEgKCAzICcgMiApIBogDCASEP0GIghBiH9LDQQCQCAURQ0AIAkoAqwCIhJFDQAgCCASakEESQ0CCyAGIAhqIgYgG2tBBEgNASAGIBVrIghBiH9LDQRBACEGIAhFDQELIA8gCCAVaiISIA9rIghBA3RBGGsiG0EQdjoAAiAPIBsgGEEARyAqcXJBBHI7AAAgCEGIf0sNAyAIRQ0AIAggESAWaiIWTw0AIAwgJ2ohJyAMIChqISggDCApaiEpIBEgGWohGSAWIBdqIRdBACERQQAhDCAHIQ4gBiEUIBIhDyEaCyAqRQ0ACyAOBEAgHSAvQYgI/AoAAAsgFARAQQAhCCAJKAKUAUEBa0ECSQ0CIAkoApwBQQFrQQJJDQIgCSgCmAFBA2tBfUsNAgsCQCAXIDBPDQAgMCAXayIHQQNqIgggJCAPa0sNASAPIAdBA3QgGGoiBjsAACAPIAZBEHY6AAIgBwRAIA9BA2ogFyAH/AoAAAsgCEGIf0sNAiAIIA9qIQ8gGiA0Tw0AIAlBwAJqIC9B8CNqKAIAIgw2AgAgCSAvKQLoIyI9NwO4AiA9pyEGIAkoArwCIRYDQCAaICFLBEAgISgCACEHIAlBsAJqIC4gIRDnJAJAAkAgB0EETwRAIAkgBjYCvAIgCSAWNgLAAiAHQQNrIQggFiEMDAELAn8CQAJAIAcgCSgCsAJFakEBayIHDgQEAQEAAQsgBkEBawwBCyAJQbgCaiAHQQJ0aigCAAshCCAJIAY2ArwCIAkgDCAWIAdBAUYbIgw2AsACCyAJIAg2ArgCIAYhFiAIIQYLICFBCGohIQwBCwsgHSAJKQO4AjcC6CMgHUHwI2ogCUHAAmooAgA2AgALIA8gDWshCAwBC0G6fyEICyAJQdACaiQAIAgiBkG6f0YNACAGQYh/SwRAIAYhCgwMCyAGRQ0AIAYgCyALQQcgACgC1AEiByAHQQdNG0EBa3ZrQQFqTw0AIAAgACkD0BBCIIk3A9AQDAELIAtBA2oiBiACSw0KIA0gC0ENdjoAAiANIBggC0EDdHI7AAAgCwRAIA1BA2ogECAL/AoAAAsgBiEKIAZBiH9LDQoLIAAoAtAQIgooAtwjQQJHDQQgCkEBNgLcIwwECyAAKAK4AkEBRgRAIAAgECALEJAHIgZBiH9LBEAgBiEKDAoLIAZBAUYEQCAAKALQECIGKALcI0ECRgRAIAZBATYC3CMLIAtBA2oiBiACSw0KIA0gC0ENdjoAAiANIBggC0EDdHI7AAAgC0UNAyANQQNqIBAgC/wKAAAMAwsgACgC5AUhBiAAKALoBUEAISIgE0EANgIUIBMgLTYCECAGa0EDdSIKQQVPBEAgE0EQakEAIAogACAcEIYWIBMoAhAgEygCFCIiQQJ0aiAKNgIACyATQRhqIhYgACgC0BAiBkHwI2ooAgAiCjYCACATQQhqIAo2AgAgEyAGKQLoIyI9NwMQIBMgPTcDACAsQQBBLPwLACAiRQRAIAAgHCATQRBqIBMgDSACIBAgCyAYQQAQrQkhCgwEC0EAIRIgJiAcQQAgLSgCABCvFUEAIRcgDSEIQQAhCiACIQ4DQCAXICJNBEAgJhDsHyEaIAAoAqgUIgZBBmohDyAAKAKsFCAGa0EDdSEUQQAhBkEAIQcDQCAGIBRHBEAgByAPLwEAakEDaiEHIAAoAtAUIAZGBEAgB0GAgARqIAcgACgCzBRBAkYbIQcLIA9BCGohDyAGQQFqIQYMAQsLIAcgGmohBgJ/IBcgIkYEQCALIBJrIQcgGAwBCyAsIBwgLSAXQQJ0aiIHKAIAIAdBBGooAgAQrxUgBiEHQQALIRQgACAmIBNBEGogEyAIIA4gECAHIBRBARCtCSIUQYh/SwRAIBQhCgwGCyAmICxBLPwKAAAgBiASaiESIBdBAWohFyAKIBRqIQogDiAUayEOIAggFGohCCAHIBBqIRAMAQsLIAAoAtAQIgYgEykDEDcC6CMgBkHwI2ogFigCADYCAAwDCwJ/IA1BA2ohCCACQQNrIQ5BACEHAkACQAJAAkACQEEBIAAgECALEJAHIgZBAUZBAnQgBkGJf08bDgUABAQEAQQLIAAoAswFBEAgABCKDSAAIAApA9AQQiCJNwPQEEEADAULIABB5AVqIAAoAtAQIAAoAtQQIABBuAFqIAggDiALIAAoArgSIAAoAggQqwohBwJAIAAoAtwFIAdBGEtyDQAgECALELoORQ0AIAggEC0AADoAAEEBIQcMAQsgB0ECa0GHf0kNAQsgACgC0BAhBgwBCyAAKALUECEGIAAgACgC0BA2AtQQIAAgBjYC0BALIAYoAtwjQQJGBEAgBkEBNgLcIwsgByEGCyAGCyIGQYh/SwRAIAYhCgwJCyANAn8CQAJAAkAgBg4CAAECCyALQQNqIgYgAksNCyANIAtBDXY6AAIgDSAYIAtBA3RyOwAAIAsEQCAIIBAgC/wKAAALIAYiCkGJf0kNBwwLCyAYIAtBA3RyQQJyDAELIAZBA3QgGHJBBHILIgo7AAAgDSAKQRB2OgACIAZBA2ohCgwECyAFRSABIA1PckUEQCAAQQM2AgALIA0gAWshCgwECyAGIQoLIApBiX9JDQEMBQsgBiEKCyAAQQA2AtwFIAIgCmshAiAKIA1qIQ0gHyALayEfDAELCyAKQYh/Sw0BIAAgACkD0AQgBK18Ij43A9AEIAAgACkD2AQgCiAlaiIBrXw3A9gEQbh/IAEgACkDyAQiPSA+QgF8VBsgASA9QgBSGyEKDAELICUhCgsgE0EgaiQAIAoLgg4BB34gACkDCCIDIAKtIgeFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIAd8Qq3+1eTUhf2o2AB+IQggACkDGCEHIAApAxAhBiAAKQMAIQQCQCACQQhNBEACfiACQQFNBEBCACACQQFHDQEaIAExAAAiBQwBCyABIAJqIQAgAkEDTQRAIAEzAAAhBSAAQQFrMQAADAELIAE1AAAhBSAAQQRrNQAACyEDIAQgCHwgBSAGhSIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEIAMgB4UiBkJ/hX4iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUgBkI4hiAGQoD+A4NCKIaEIAZCgID8B4NCGIYgBkKAgID4D4NCCIaEhCAHQgiIQoCAgPgPgyAHQhiIQoCA/AeDhCAHQiiIQoD+A4MgB0I4iISEhCAFfoVCF4khAwwBCyACQRBNBEAgBCAIfCABKQAAIAaFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASACakEIaykAACAHhSIHQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEhSAHQjiGIAdCgP4Dg0IohoQgB0KAgPwHg0IYhiAHQoCAgPgPg0IIhoSEIAdCCIhCgICA+A+DIAdCGIhCgID8B4OEIAdCKIhCgP4DgyAHQjiIhISEIAN+hUIXiSEDDAELIAQgCHwgBiABIAJqQRBrIgApAACFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgByAAKQAIhSIFQn+FfiIIQjiGIAhCgP4Dg0IohoQgCEKAgPwHg0IYhiAIQoCAgPgPg0IIhoSEIAhCCIhCgICA+A+DIAhCGIhCgID8B4OEIAhCKIhCgP4DgyAIQjiIhISEhSAFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAN+hUIXiSEDIAdCf4UhCANAIAMgBHwgBiABKQAAhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAEpAAgiCSAIhX4iBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhIUgAyAHIAmFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIR+hUIXiSEDIAFBEGohASACQRBrIgJBEEsNAAsLIAMgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH4gA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQn+FfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEhSADiQuxEAEOfyMAQSBrIgckACAAKAIcIgItAAUhAwJAAkACQCABQf8BcUEERwRAIAMNAkEBIQQgAigCJEUNAgwBC0ECIQQCQCADDgMBAAIACyACQdgAakGAAkHMhv0AQaACEKshQQAhAyACQQA6AAUgAiACKAIQNgI8IAAQ4hggACgCEEUNAiAAKAIcIQILIAJB2ABqQQEgAUH/AXFBBEYQjCYgACgCHCICIAQ6AAUgAiACKAIQNgI8C0ECQQEgAUH/AXEiC0EERiIMGyENA0ACQAJAAkACQAJAIAIoAmRBCGogAigCTEECdE8EQCAAEOIYIAAoAhBFDQEgACgCHCECCyACKAIkIgNBhgJPDQIgAigCICIEQQF0IQggBEGGAmshCQNAIAIoAlAgAyACKAIQIgVqayEDAkACQAJAAkACQAJAAkACQAJAIAkgAigCIGogBU0EQCAIIAIoAhgiBUsNASAEQQBIDQIgBARAIAIoAhQiBSAEIAVqIAT8CgAACyACIAIvAQwiBSAEQf//A3EiBmsiCkEAIAUgCk8bOwEMIAUgBk0EQCACQQA7ATQLIAIgAigCECAEayIFNgIQIAIgAigCPCAEazYCPCACIAUgAigCgAEiBiAFIAZJGzYCgAEgAhCUFiADIARqIQMLIAAoAgRFBEAgACgCHCECDAwLIANBAU0NAiAAIAAoAhwiAigCJCACKAIQaiADEMwTIQMgACgCHCICIAMgAigCJGoiAzYCJCACKAKAASIGIANqQQNJDQggAigCECIDIAZrIQUgAi8BNkGACE0EQCADIAZGDQggBUEBayEDIAItAAZBAUYEQCACIAMQ2RkaDAkLIAIoAhgiBiADSQ0EIAYgA2siBkEDTQ0FIAIoAhQgA2ooAABBsfPd8XlsQRB2QQF0IgogAigCMGovAQAiDiADQf//A3FGDQggAigCIEEBayADcSIGIAIoAiwiD08NBiACKAIoIAZBAXRqIA47AQAgAigCMCAKaiADOwEADAgLIAIoAhgiAyAFTQRAIAUgA0Gskf0AEMMhAAsgBUEBaiIGIANJDQYgBiADQbyR/QAQwyEACyAIIAVB7JD9ABCwOwALIAdBADYCGCAHQQE2AgwgB0Hohf0ANgIIIAdCBDcCECAHQQhqQfyQ/QAQ7ywACyAHQQA2AhggB0EBNgIMIAdBlJH9ADYCCCAHQgQ3AhAgB0EIakGckf0AEO8sAAsgAyAGQbyQ/QAQrzsAC0EEIAZBzJD9ABCwOwALIAYgD0HckP0AEMMhAAsgAiACKAIUIgMgBWotAABBBXQgAyAGai0AACIDcyADQbHz3fF5bEEQdiACLQAGGzYChAELIAIoAoABIAIoAiQiA0EBRmsiBkUNAAJAIAItAAZBAUYEQCACIAUgBhDgEwwBCyACIAUgBhDrFAsgAiACKAKAASAGazYCgAEgAigCJCEDCyADQYUCSw0CIAAoAgQNAAsMAQtBACEDIAFB/wFxQQRHDQUgACgCBA0FIAAoAhwiAC0AcA0FIAAtAAVFQQF0IQMMBQsgAigCECIEIAIoAlBBhgJrSwRAIAdBADYCGCAHQQE2AgwgB0Hokf0ANgIIIAdCBDcCECAHQQhqQfCR/QAQ7ywACyALIAIoAiQiA0GGAk9yRQRAQQAhAwwFCwJAAkAgA0UEQCACQQIgBCAEQQJPGzYCgAEgAi0ABQRAIAJB2ABqIgNBgAJBzIb9AEGgAhCrISABQf8BcUEERgRAIAMQ8BULIAJBADoABSACIAIoAhA2AjwgABDiGCAAKAIQRQ0CC0EDQQEgAUH/AXFBBEYbIQMMBwsgAi0ABQ0BIAJB2ABqQQEgDBCMJiAAKAIcIgIgDToABSACIAIoAhAiBDYCPCACKAIkIQMMAQsgAUH/AXFBBEZBAXQhAwwFCyADQQNLDQAgBCACKAIYIgNPDQEgAigCFCAEai0AACEGDAILAkACQAJAAkACQAJAIAIoAhgiBCACKAIQIgNPBEAgBCADayIEQQNNDQEgAigCFCADaigAACIGQbHz3fF5bEEQdkEBdCIIIAIoAjBqLwEAIgQgA0H//wNxRwRAIAIoAiBBAWsgA3EiBSACKAIsIglPDQMgAigCKCAFQQF0aiAEOwEAIAIoAjAgCGogAzsBACACKAIQIQMLIAMgBGsiCEEATA0IIAggAigCIEGGAmtKDQggAigCGCIFIARJDQMgBSAEayIJQQNNDQQgBiAEIAIoAhQiCmoiBCgAAEcNCCAFIANBAmoiA0kNBQJ/IAMgCmohCiAEQQJqIQQgCUECayEJAkAgBSADa0H/AUsEQCAJQf8BTQ0BQQAhAwNAIAMgAyAKai0AACADIARqLQAARw0DGiADQQFqIgNBgAJHDQALQYACDAILQdjv/AAQsjsAC0Ho7/wAELI7AAtBAmoiA0EESQ0IIAhBgIAETw0GIAJB2ABqQYICIAIoAiQiBCADIAMgBEsbIgMgA0GCAk8bIgNBA2sgCBC7EiACIAIoAiQgA2s2AiQgAiACKAIQIANqNgIQDAkLIAMgBEHcj/0AEK87AAtBBCAEQeyP/QAQsDsACyAFIAlB3JD9ABDDIQALIAQgBUH8j/0AEK87AAtBBCAJQYyQ/QAQsDsACyADIAVBnJD9ABCvOwALQfCF/QBBKyAHQQhqQZyG/QBBrJD9ABDVHgALIAQgA0HMj/0AEMMhAAsgAkHYAGpBzIb9AEGgAiAGEMkqIAAoAhwiAiACKAIQQQFqNgIQIAIgAigCJEEBazYCJAwACwALIAdBIGokACADC+4PAg1/An4jAEHQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AKEEBaw4EBgACBAELAAsgASABKAIAIgQ2AhggASABKAIINgIcIAEgASgCFDYCICABKAIEIQggASgCDCEGIAEoAhAhBSABIAQoAgwgBCgCHBCILSIHNgIkIAEoAhghBAJAIAZFDQAgBCgCECILRQ0AIAQoAhQhDCABQSxqIgkgBiAFIAQoAhgQuAkgAUEANgJAIAFCgICAgMAANwI4IAEoAhgiBCgCBCEHIAQoAgghBCADQRBqIAEoAiQQhjwgASgCHCENIAMoAhQhBSADKAIQIQogAyABQThqNgKUASADIAY2ApABIAMgCTYCjAEgAyABQSBqNgKIASADIAw2AoQBIAMgCzYCgAEgAyANNgJ8IANBADYCeCADQQA2AnAgAyAKNgJoIAMgByAEQQJ0ajYCZCADIAc2AmAgA0EANgJQIANBADYCQCADIAUgBCAEIAVLGzYCdCADIAogBUHAAmxqNgJsIANBmAFqIgQgA0FAaxCdECADQQA6AMwBIAMgCDYCpAEgA0EIaiAEEM4pIAMoAgghBCABIAMoAgwiBTYCSCABIAQ2AkQMAgsgBCgCCCEGIAQoAgQhBCABKAIcIQUgAyAHNgKoASADIAU2AqQBIANBADYCoAEgAyAENgKYASADIAQgBkECdGo2ApwBIANBQGsiBCADQZgBahDHDyADQQA6AHQgAyAINgJMIAMgBBDOKSADKAIAIQQgASADKAIEIgU2AjAgASAENgIsDAMLIAEoAkghBSABKAJEIQQLIANBQGsgBCACIAUoAgwRAQAgAygCQCICQQlHDQMgAEEJNgIAQQMhAgwICyABKAIwIQUgASgCLCEECyADQUBrIAQgAiAFKAIMEQEAIAMoAkAiAkEJRw0CIABBCTYCAEEEIQIMBgtBiP7CABDoKwALIAMpA1AhECADKAJMIQUgAygCSCEEIAMoAkQhBiABQcQAahC8KiACQQhHBEAgAUE4aiIIENYrIAgQ6DsgAUEsahDqOwwDCyADIAY2AiAgAyAENgIYIAMgBDYCHCADIAQgBUEEdGo2AiQgAyABKAI4NgKgASADIAEoAjwiAiABKAJAQQxsajYCpAEgAyACNgKcASADIAI2ApgBIAEoAhgiAigCCCIEBEAgAigCBCIGIARBAnRqIQogA0E8aiELQQAhCANAAkAgBigCAA0AIAEoAhwgCBDyJkUNACADKAKcASICIAMoAqQBRg0AIAMgAkEMajYCnAEgAigCACIMQYCAgIB4Rg0AIANBQGsgAikCBCIQQiCIpyIHQQBBBEEQEKAYIAMoAkQhAgJAIAMoAkBBAUcEQCADQQA2AjAgAyADKAJINgIsIAMgAjYCKCAQQoCAgIAQWgRAQQAhBCADKAIcIQkgAygCJCENQQAhBQNAAkAgDSAEIAlqIgJHBEAgAyACQRBqNgIcIAIoAgAiDg0BC0Go/sIAELI7AAsgA0HIAGoiDyACQQxqKAIANgIAIAMgAkEEaikCADcDQCADKAIoIAVGBEAgA0EoakG4/sIAEJ4oCyADKAIsIARqIgIgDjYCACACQQRqIAMpA0A3AgAgAkEMaiAPKAIANgIAIAMgBUEBaiIFNgIwIARBEGohBCAFIAdHDQALCyADQUBrIgQgASgCJCAIEIktEOwgIAMpA0ghESADKAIoIQkgAygCLCECIAMoAjAhBSADQgA3AmAgAyACIAVBBHRqNgJcIAMgCTYCWCADIAI2AlQgAyACNgJQIAMgEKciAiAHQQN0ajYCTCADIAw2AkggAyACNgJEIAMgAjYCQCADQTRqIAQQ9xhBHEEEEK02IgJFDQEgAkEANgIIIAJCgYCAgBA3AgAgAiADKQI0NwIMIAIgET4CGCACQRRqIAsoAgA2AgACQCAGKAIAIgRFDQAgBCAEKAIAIgVBAWs2AgAgBUEBRw0AIAYQ3xgLIAYgAjYCAAwCCyACIAMoAkhBmP7CABD9LwALQQRBHBCjPQALIAhBAWohCCAGQQRqIgYgCkcNAAsLIANBmAFqELsgIANBGGoQuxwgAUEsahDqOwwBCyADKQNQIRAgAygCTCEFIAMoAkghBCADKAJEIQYgAUEsahC8KiACQQhHDQEgAyAGNgKgASADIAQgBUEEdGo2AqQBIAMgBDYCnAEgAyAENgKYASABKAIYIgIoAggiBARAIAIoAgQhAiAEQQJ0IQVBACEEIANBIGohCANAAkAgAigCAA0AIAEoAhwgBBDyJkUNACADKAKcASIGIAMoAqQBRg0AIAMgBkEQajYCnAEgBigCACIHRQ0AIAggBkEMaigCADYCACADIAYpAgQ3AxggA0FAayABKAIkIAQQiS0Q7CAgAykDQCEQQRxBBBCtNiIGRQ0FIAYgBzYCCCAGQoGAgIAQNwIAIAYgAykDGDcCDCAGIBA+AhggBkEUaiAIKAIANgIAAkAgAigCACIHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACACEN8YCyACIAY2AgALIAJBBGohAiAEQQFqIQQgBUEEayIFDQALCyADQZgBahC7HAtBCCECCyAAIBA3AxAgACAFNgIMIAAgBDYCCCAAIAY2AgQgACACNgIAQQEhAgwBC0EEQRwQoz0ACyABIAI6ACggA0HQAWokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC6CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDmAiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDmAiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7AcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQlgkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQlgkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEI0KIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC2CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7QcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQlwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQlwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEJ8QIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrENQIIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACENQIIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCNCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQiAkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEI4JIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKQAiABKAKUAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKgAiABIAIoAvABIgU2ApwCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCmAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AKQCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCoAIgASAFNgKcAiABKAKYAiIDLgEaQQBMDQYgAkG4AmogASgCkAIgASgClAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AKQCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCmAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARC3CyACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoApACIAEoApQCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhDPEiACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ7gcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQmwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQmwkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIsJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCMCiACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCyAEgASgCzAEoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYC2AEgASACKALwASIFNgLUASACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoAtABIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgDcASABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2AtgBIAEgBTYC1AEgASgC0AEiAy4BGkEATA0GIAJBuAJqIAEoAsgBIAEoAswBKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgDcASABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoAtABIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQ6wcgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKALIASABKALMASgCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQmQkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQmQkgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIwJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKALIASABKALMASgCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgLYASABIAIoAvABIgU2AtQBIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgC0AEiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCyAEgASgCzAEoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6ANwBIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYC2AEgASAFNgLUASABKALQASIDLgEaQQBMDQYgAkG4AmogASgCyAEgASgCzAEoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6ANwBIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgC0AEhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARDqByACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAsgBIAEoAswBKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxCaCSACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhCaCSACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQigkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAsgBIAEoAswBKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2AtgBIAEgAigC8AEiBTYC1AEgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKALQASIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKALIASABKALMASgCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoA3AEgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgLYASABIAU2AtQBIAEoAtABIgMuARpBAEwNBiACQbgCaiABKALIASABKALMASgCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoA3AEgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKALQASEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BENcHIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCyAEgASgCzAEoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEJgJIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEJgJIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCGCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL6A8CC38DfiMAQfACayICJAAgAkGAAWogASgCiAIgASgCjAIoAhwRAAACQAJAAkACQAJAAkACQAJAAkACQAJAIAIpA4ABIg1CDVIEQCABQaABaiELIAJBiAFqIgUhCgNAQQAiA0UEQCACQQhqIAVB+AD8CgAACwJAAkACQCANQgxSBEAgAiANNwOAASADRQRAIAogAkEIakH4APwKAAALQQEgDadBCWsgDUIIWBsiA0ECRg0DIANBAWsNAQwCCyAAQQg2AgAgAEEAOgAEDA8LIAFBADYCmAIgASACKALwASIFNgKUAiACQZgCaiACQegAaikDADcDACACIAIpA2A3A5ACIAEoApACIgQuARghBiACLQD1ASEIIAItAPQBIQlBACEDIAQuARoiB0EATA0KIAItAPYBIQQgAkHQAmoiAyACQZACakEAEOoUIAJBuAJqIAcgBSAEIAMQnBMgAkGoAmoiDCACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEDIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgAzYCBCAAIAc2AgAgAEEQaiAMKQMANwMADAwLIAJB2AJqIAJBqAJqKQMANwMAIAIgAikDoAI3A9ACIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQcgAigCuAIiDEEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgBzoABCAAIAw2AgAgAkHcAmogAigC1AIgAigC2AIgAigC0AIoAhARAQAMDAsgASAHOgCcAiABKQMAQgRRDQQgASAEIAJB0AJqEKkpDAoLIAJBqAJqIAJB4ABqKQMANwMAIAIgAikDWDcDoAIgAiACKALoASIFNgKwAiACIAIoAuwBIgg2ArQCIAUgCEkNBCACKAL4ASEGIAIoAvQBIQQgAi0A/QEhByABQQA2ApgCIAEgBTYClAIgASgCkAIiAy4BGkEATA0GIAJBuAJqIAEoAogCIAEoAowCKAIoEQAAIAItALwCIQMgAigCuAIiCUEIRwRAIAAgAikAvQI3AAUgAEEUaiACQcwCaigAADYAACAAQQ1qIAJBxQJqKQAANwAAIAAgAzoABCAAIAk2AgAMCAsgASADOgCcAiABKQMAQgRRDQUgAkG4AmoiAyACQaACaiAGEM0VIAFBAiADEKkpIAEoApACIQMMBgsgAkGIAmogAkEQaikDADcDACACIAIpAwg3A4ACIAJBuAJqIAsgAkGAAmogAigCmAEgAi0AnAEgAi0AnQEQhQkgAigCuAIiA0EIRwRAIAAgAikCvAI3AgQgAEEUaiACQcwCaigCADYCACAAQQxqIAJBxAJqKQIANwIAIAAgAzYCAAwLCyAKIQMCQAJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAIBCyACQYABaiEDCyADEMIYCyACQYABaiABKAKIAiABKAKMAigCHBEAACACKQOAASINQg1SDQALCyACQRhqIAJBmAFqKQMAIg03AwAgAkEQaiACQZABaikDACIONwMAIAIgAikDiAEiDzcDCCAAQRBqIA03AwAgAEEIaiAONwMAIAAgDzcDAAwKC0HMlM8AELI7AAsgAkEDNgK8AiACQciVzwA2ArgCIAJCAjcCxAIgAkE7NgLcAiACQTs2AtQCIAIgAkHQAmo2AsACIAIgAkG0Amo2AtgCIAIgAkGwAmo2AtACIABBBGogAkG4AmoQmQ4gAEEANgIADAILQeyUzwAQsjsACwJAIAMuARhBAEwEQCAEIAZqIQMMAQsgASkDUEIFUQ0CIAJBuAJqIgkgAkGgAmogBiAEIAZqIgMQ0hAgAUHQAGpBAiAJENsTCyACQdACaiIBIAJBoAJqIAMQ6hQgAkG4AmogCyAHIAEgBUEBIAUgCGsQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBrAJqIAIoAqQCIAIoAqgCIAIoAqACKAIQEQEADAMLQfyUzwAQsjsACyAGQQBKBEAgAkHQAmoiBCACQZACaiADEOoUIAJBuAJqIAYgBSAIIAQQnBMgAkGoAmoiBiACQcgCaikDADcDACACIAIpA8ACNwOgAiACKAK8AiEEIAIoArgCIgdBCEcEQCAAIAIpA6ACNwMIIAAgBDYCBCAAIAc2AgAgAEEQaiAGKQMANwMADAILIAJB6AJqIAYpAwA3AwAgAiACKQOgAjcD4AIgASkDUEIFUQ0DIAFB0ABqIAggAkHgAmoQ2xMgAyAEaiEDCyACQdACaiIBIAJBkAJqIAMQ6hQgAkG4AmogCyAJIAEgBUEAIAIQ9AsgAigCuAIiA0EIRwRAIABBBGoiASACKQK8AjcCACABQRBqIAJBzAJqKAIANgIAIAFBCGogAkHEAmopAgA3AgAgACADNgIADAELIABBCDYCACAAQQE6AAQLIAJBnAJqIAIoApQCIAIoApgCIAIoApACKAIQEQEACwJAAkBBASACKQOAASINp0EJayANQghYG0EBaw4CAAMBCyACQYABaiEKCyAKEMIYDAELQdyUzwAQsjsACyACQfACaiQAC+gPAgt/A34jAEHwAmsiAiQAIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAAkACQAJAAkACQAJAAkACQAJAAkACQCACKQOAASINQg1SBEAgAUGgAWohCyACQYgBaiIFIQoDQEEAIgNFBEAgAkEIaiAFQfgA/AoAAAsCQAJAAkAgDUIMUgRAIAIgDTcDgAEgA0UEQCAKIAJBCGpB+AD8CgAAC0EBIA2nQQlrIA1CCFgbIgNBAkYNAyADQQFrDQEMAgsgAEEINgIAIABBADoABAwPCyABQQA2ApgCIAEgAigC8AEiBTYClAIgAkGYAmogAkHoAGopAwA3AwAgAiACKQNgNwOQAiABKAKQAiIELgEYIQYgAi0A9QEhCCACLQD0ASEJQQAhAyAELgEaIgdBAEwNCiACLQD2ASEEIAJB0AJqIgMgAkGQAmpBABDqFCACQbgCaiAHIAUgBCADEJwTIAJBqAJqIgwgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhAyACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAM2AgQgACAHNgIAIABBEGogDCkDADcDAAwMCyACQdgCaiACQagCaikDADcDACACIAIpA6ACNwPQAiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEHIAIoArgCIgxBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAc6AAQgACAMNgIAIAJB3AJqIAIoAtQCIAIoAtgCIAIoAtACKAIQEQEADAwLIAEgBzoAnAIgASkDAEIEUQ0EIAEgBCACQdACahCpKQwKCyACQagCaiACQeAAaikDADcDACACIAIpA1g3A6ACIAIgAigC6AEiBTYCsAIgAiACKALsASIINgK0AiAFIAhJDQQgAigC+AEhBiACKAL0ASEEIAItAP0BIQcgAUEANgKYAiABIAU2ApQCIAEoApACIgMuARpBAEwNBiACQbgCaiABKAKIAiABKAKMAigCKBEAACACLQC8AiEDIAIoArgCIglBCEcEQCAAIAIpAL0CNwAFIABBFGogAkHMAmooAAA2AAAgAEENaiACQcUCaikAADcAACAAIAM6AAQgACAJNgIADAgLIAEgAzoAnAIgASkDAEIEUQ0FIAJBuAJqIgMgAkGgAmogBhDNFSABQQIgAxCpKSABKAKQAiEDDAYLIAJBiAJqIAJBEGopAwA3AwAgAiACKQMINwOAAiACQbgCaiALIAJBgAJqIAIoApgBIAItAJwBIAItAJ0BEIcJIAIoArgCIgNBCEcEQCAAIAIpArwCNwIEIABBFGogAkHMAmooAgA2AgAgAEEMaiACQcQCaikCADcCACAAIAM2AgAMCwsgCiEDAkACQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgACAQsgAkGAAWohAwsgAxDCGAsgAkGAAWogASgCiAIgASgCjAIoAhwRAAAgAikDgAEiDUINUg0ACwsgAkEYaiACQZgBaikDACINNwMAIAJBEGogAkGQAWopAwAiDjcDACACIAIpA4gBIg83AwggAEEQaiANNwMAIABBCGogDjcDACAAIA83AwAMCgtBzJTPABCyOwALIAJBAzYCvAIgAkHIlc8ANgK4AiACQgI3AsQCIAJBOzYC3AIgAkE7NgLUAiACIAJB0AJqNgLAAiACIAJBtAJqNgLYAiACIAJBsAJqNgLQAiAAQQRqIAJBuAJqEJkOIABBADYCAAwCC0HslM8AELI7AAsCQCADLgEYQQBMBEAgBCAGaiEDDAELIAEpA1BCBVENAiACQbgCaiIJIAJBoAJqIAYgBCAGaiIDENIQIAFB0ABqQQIgCRDbEwsgAkHQAmoiASACQaACaiADEOoUIAJBuAJqIAsgByABIAVBASAFIAhrEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQawCaiACKAKkAiACKAKoAiACKAKgAigCEBEBAAwDC0H8lM8AELI7AAsgBkEASgRAIAJB0AJqIgQgAkGQAmogAxDqFCACQbgCaiAGIAUgCCAEEJwTIAJBqAJqIgYgAkHIAmopAwA3AwAgAiACKQPAAjcDoAIgAigCvAIhBCACKAK4AiIHQQhHBEAgACACKQOgAjcDCCAAIAQ2AgQgACAHNgIAIABBEGogBikDADcDAAwCCyACQegCaiAGKQMANwMAIAIgAikDoAI3A+ACIAEpA1BCBVENAyABQdAAaiAIIAJB4AJqENsTIAMgBGohAwsgAkHQAmoiASACQZACaiADEOoUIAJBuAJqIAsgCSABIAVBACACEPQLIAIoArgCIgNBCEcEQCAAQQRqIgEgAikCvAI3AgAgAUEQaiACQcwCaigCADYCACABQQhqIAJBxAJqKQIANwIAIAAgAzYCAAwBCyAAQQg2AgAgAEEBOgAECyACQZwCaiACKAKUAiACKAKYAiACKAKQAigCEBEBAAsCQAJAQQEgAikDgAEiDadBCWsgDUIIWBtBAWsOAgADAQsgAkGAAWohCgsgChDCGAwBC0HclM8AELI7AAsgAkHwAmokAAvoDwILfwN+IwBB8AJrIgIkACACQYABaiABKAKIAiABKAKMAigCHBEAAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAikDgAEiDUINUgRAIAFBoAFqIQsgAkGIAWoiBSEKA0BBACIDRQRAIAJBCGogBUH4APwKAAALAkACQAJAIA1CDFIEQCACIA03A4ABIANFBEAgCiACQQhqQfgA/AoAAAtBASANp0EJayANQghYGyIDQQJGDQMgA0EBaw0BDAILIABBCDYCACAAQQA6AAQMDwsgAUEANgKYAiABIAIoAvABIgU2ApQCIAJBmAJqIAJB6ABqKQMANwMAIAIgAikDYDcDkAIgASgCkAIiBC4BGCEGIAItAPUBIQggAi0A9AEhCUEAIQMgBC4BGiIHQQBMDQogAi0A9gEhBCACQdACaiIDIAJBkAJqQQAQ6hQgAkG4AmogByAFIAQgAxCcEyACQagCaiIMIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQMgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACADNgIEIAAgBzYCACAAQRBqIAwpAwA3AwAMDAsgAkHYAmogAkGoAmopAwA3AwAgAiACKQOgAjcD0AIgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhByACKAK4AiIMQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACAHOgAEIAAgDDYCACACQdwCaiACKALUAiACKALYAiACKALQAigCEBEBAAwMCyABIAc6AJwCIAEpAwBCBFENBCABIAQgAkHQAmoQqSkMCgsgAkGoAmogAkHgAGopAwA3AwAgAiACKQNYNwOgAiACIAIoAugBIgU2ArACIAIgAigC7AEiCDYCtAIgBSAISQ0EIAIoAvgBIQYgAigC9AEhBCACLQD9ASEHIAFBADYCmAIgASAFNgKUAiABKAKQAiIDLgEaQQBMDQYgAkG4AmogASgCiAIgASgCjAIoAigRAAAgAi0AvAIhAyACKAK4AiIJQQhHBEAgACACKQC9AjcABSAAQRRqIAJBzAJqKAAANgAAIABBDWogAkHFAmopAAA3AAAgACADOgAEIAAgCTYCAAwICyABIAM6AJwCIAEpAwBCBFENBSACQbgCaiIDIAJBoAJqIAYQzRUgAUECIAMQqSkgASgCkAIhAwwGCyACQYgCaiACQRBqKQMANwMAIAIgAikDCDcDgAIgAkG4AmogCyACQYACaiACKAKYASACLQCcASACLQCdARCJCSACKAK4AiIDQQhHBEAgACACKQK8AjcCBCAAQRRqIAJBzAJqKAIANgIAIABBDGogAkHEAmopAgA3AgAgACADNgIADAsLIAohAwJAAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAgELIAJBgAFqIQMLIAMQwhgLIAJBgAFqIAEoAogCIAEoAowCKAIcEQAAIAIpA4ABIg1CDVINAAsLIAJBGGogAkGYAWopAwAiDTcDACACQRBqIAJBkAFqKQMAIg43AwAgAiACKQOIASIPNwMIIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAoLQcyUzwAQsjsACyACQQM2ArwCIAJByJXPADYCuAIgAkICNwLEAiACQTs2AtwCIAJBOzYC1AIgAiACQdACajYCwAIgAiACQbQCajYC2AIgAiACQbACajYC0AIgAEEEaiACQbgCahCZDiAAQQA2AgAMAgtB7JTPABCyOwALAkAgAy4BGEEATARAIAQgBmohAwwBCyABKQNQQgVRDQIgAkG4AmoiCSACQaACaiAGIAQgBmoiAxDSECABQdAAakECIAkQ2xMLIAJB0AJqIgEgAkGgAmogAxDqFCACQbgCaiALIAcgASAFQQEgBSAIaxD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGsAmogAigCpAIgAigCqAIgAigCoAIoAhARAQAMAwtB/JTPABCyOwALIAZBAEoEQCACQdACaiIEIAJBkAJqIAMQ6hQgAkG4AmogBiAFIAggBBCcEyACQagCaiIGIAJByAJqKQMANwMAIAIgAikDwAI3A6ACIAIoArwCIQQgAigCuAIiB0EIRwRAIAAgAikDoAI3AwggACAENgIEIAAgBzYCACAAQRBqIAYpAwA3AwAMAgsgAkHoAmogBikDADcDACACIAIpA6ACNwPgAiABKQNQQgVRDQMgAUHQAGogCCACQeACahDbEyADIARqIQMLIAJB0AJqIgEgAkGQAmogAxDqFCACQbgCaiALIAkgASAFQQAgAhD0CyACKAK4AiIDQQhHBEAgAEEEaiIBIAIpArwCNwIAIAFBEGogAkHMAmooAgA2AgAgAUEIaiACQcQCaikCADcCACAAIAM2AgAMAQsgAEEINgIAIABBAToABAsgAkGcAmogAigClAIgAigCmAIgAigCkAIoAhARAQALAkACQEEBIAIpA4ABIg2nQQlrIA1CCFgbQQFrDgIAAwELIAJBgAFqIQoLIAoQwhgMAQtB3JTPABCyOwALIAJB8AJqJAAL+w8CBn8DfiMAQeACayIHJAAgAS0AaCEMIAcgAjoAowECQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXEOCAUABgYGAQIABgsgB0HIAmogA0EIaikCADcDACAHIAMpAgA3A8ACIAdB0AFqIAdBwAJqIAQgBSAGEJkNIAdBsAFqIAdBiAJqKQMANwMAIAdBuAFqIAdBkAJqKAIANgIAIAcgBykDgAI3A6gBIAcpA9ABIQ0gBygC2AEhCCAHKALcASEKIAcoAuABIQkgBygC5AEhBiAHKALoASECIAcoAuwBIQMgBygC8AEhBCAHKAL0ASEFIAcpA/gBIQ4gBy0AlAIhDCAHQaYBaiAHQZcCai0AADoAACAHIAcvAJUCOwGkASAHKQOYAiEPDAcLIAdByAFqIgYgA0EIaikCADcDACAHIAMpAgA3A8ABIAdBADYCuAIgB0KAgICAEDcCsAIgB0HAAmoiAiAHQbACaiIDEOcVIAdB6AFqQgA3AwAgB0HwAWpCADcDACAHQYwCakIANwIAIAdBlAJqQgA3AgAgB0GcAmpCADcCACAHQeABaiAHQcgCaikDADcDACAHQQA6AKgCIAdCADcChAIgB0EANgL4ASAHQgE3AvwBIAdBADYC0AEgB0EANgKkAiAHIAcpA8ACNwPYASADIAdBzAFqIgsgBygCxAEgBigCACAHKALAASgCABEFACACIAdB0AFqIAMQuAQCQAJAIAcoAsACIghBCEcEQCAHKALUAiEFIAcoAtACIQQgBygCzAIhAyAHKALIAiECIAcoAsQCIQYMAQsgB0GwAmpBACAHKAKIAkGEkc0AELMVIAdBwAJqIAdB0AFqIAcoArQCIgogBygCuAIiCRDoCQJAIAcoAsACIghBCEcEQCAHKALUAiEFIAcoAtACIQQgBygCzAIhAyAHKALIAiECIAcoAsQCIQYMAQsCQAJAAkAgCUUEQEEAIQIMAQsgCUECdCEGQQAhAiAKIQMDQCADKAIAIgRBAEgNAiACIARqIQIgA0EEaiEDIAZBBGsiBg0ACwsgB0HQAWoQ3hwgAmogBygCyAEiA00NBEEqIQMgB0HAAmpBKkEAQQFBARCgGCAHKALEAiEGIAcoAsACQQFGDQ4gBygCyAIiAkH4jc0AQSr8CgAADAELQSchAyAHQcACakEnQQBBAUEBEKAYIAcoAsQCIQYgBygCwAJBAUYNDSAHKALIAiICQaKOzQBBJ/wKAAALQQAhCAsgB0GwAmoQ6TsLIAdB0AFqEIItIAsgBygCxAEgBygCyAEgBygCwAEoAhARAQAMAwsgBygCzAEhBCAHKALEASECIAcoAsABIQYgBygCsAIhCCAHQdABaiIFEN4cIAUQgi1BACEFIAhBgICAgHhGDQGtQoCAgIAQQgAgDEEBcRuEIQ5CBCENDAYLIAdBuAJqIANBCGopAgA3AwAgByADKQIANwOwAiAHQdABaiAHQbACahCxBCAHKALQAUEBRgRAIAcoAuwBIQUgBygC6AEhBCAHKALkASEDIAcoAuABIQIgBygC3AEhBiAHKALYASEIDAILIAdByAJqIAdBhAJqKQIANwMAIAdB0AJqIgsgB0GMAmooAgA2AgAgByAHKQL8ATcDwAIgBygC8AEhBSAHKALsASEEIAcoAugBIQMgBygC5AEhAiAHKALgASEGIAcoAtwBIQkgBygC1AEiCEGAgICAeEcNBAsgCSEICyAHIAU2AmwgByAENgJoIAcgAzYCZCAHIAI2AmAgByAGNgJcIAcgCDYCWAwECyAHQcgCaiADQQhqKQIANwMAIAcgAykCADcDwAIgB0HQAWogB0HAAmoQ/BsgByAMOgDkASAGIAQgBUEBcRshAiAHKALQASEIIAcoAtQBIQogBygC2AEhCSAHKALkASEDQgIhDUEAIQYMAgsgB0EBNgLUASAHQdyMzQA2AtABIAdCATcC3AEgB0GuAzYCxAIgByAHQcACajYC2AEgByAHQaMBajYCwAIgB0HcAGogB0HQAWoQmQ4gB0EANgJYIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgBykC9AEhDiAHKALYASEKIAdBuAFqIAsoAgA2AgAgB0GwAWogB0HIAmopAwA3AwAgByAHKQPAAjcDqAFCBSENCyAHQYgBaiAHQbABaikDADcDACAHQZABaiAHQbgBaigCADYCACAHQZcBaiAHQaYBai0AADoAACAHIA43A3ggByAFNgJ0IAcgBDYCcCAHIAM2AmwgByACNgJoIAcgBjYCZCAHIAk2AmAgByAKNgJcIAcgCDYCWCAHIAcpA6gBNwOAASAHIAw6AJQBIAcgBy8BpAE7AJUBIAcgDzcDmAEgDUIGUQ0AIAdByABqIgMgB0HYAGoiBEEQaikDADcDACAHQUBrIgIgBEEIaikDADcDACAHIAQpAwA3AzggB0EIaiAHQfAAakEw/AoAACABEMEaIAEgDTcDACABIAcpAzg3AwggAUEQaiACKQMANwMAIAFBGGogAykDADcDACABQSBqIAdBCGpBMPwKAAAgAEEINgIADAELIAdByABqIAdB6ABqKQMAIg03AwAgB0FAayAHQeAAaikDACIONwMAIAcgBykDWCIPNwM4IABBEGogDTcDACAAQQhqIA43AwAgACAPNwMACyAHQeACaiQADwsgBiAHKALIAkHU/cwAEP0vAAusDwIPfwJ+IwBB8ARrIgMkACABKAIYIQ0gASgCHCEHIANB2AJqIAJBDGoiCBDbPEEAQQRBBBCgGCADKALcAiEFIAMoAtgCQQFHBEAgA0EANgLIBCADIAMoAuACIgQ2AsQEIAMgBTYCwAQgA0EANgLUBCADQoCAgIDAADcCzAQgBQR/IAQFIANBwARqQfCvggEQnSggAygCxAQLQQA2AgAgA0EBNgLIBEHAACEEIAgQ2zwiBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIANBADYC5AIgAyAENgLgAiADIAU2AtwCIANBwAA2AtgCIANB2ARqIgUgA0HYAmogBhDSJSADQRhqIAUQhj0gAygCHCEGIAMoAhghDiAIENs8IhAEQCAHQQJ2IQcgAigCECERQQAhBQNAAkACQAJAAkACQAJAIAIgBRCLO0UEQCAFQQN2IgQgBk8NASAEIA5qIgQgBC0AAEF+IAVBB3F3cToAACADKALIBCIEIAMoAsAERgRAIANBwARqQYCwggEQnSgLIAMoAsQEIARBAnRqIAs2AgAgAyAEQQFqNgLIBAwGCyADIAU2AugEIAgQ2zwgBU0NASARIAVBAnRqKAIAIgkgB08NAiAJQQFqIgQgB08NBCANIARBAnRqKAIAIg8gDSAJQQJ0aigCACIKayALaiELIAMoAsgEIgQgAygCwARGBEAgA0HABGpBsLCCARCdKAsgAygCxAQgBEECdGogCzYCACADIARBAWo2AsgEIAogD0gEQCADKALUBCIMQQJ0IQQDQCADKALMBCAMRgRAIANBzARqQcCwggEQnSgLIAMoAtAEIARqIAo2AgAgAyAMQQFqIgw2AtQEIARBBGohBCAPIApBAWoiCkcNAAsLIAEgCRCSOw0FIAVBA3YiBCAGTw0DIAQgDmoiBCAELQAAQX4gBUEHcXdxOgAADAULIAQgBkGA9IEBEMMhAAsgAyACEPw7NgLsBCADQQI2AtwCIANBiPGBATYC2AIgA0ICNwLkAiADQTs2AiwgA0E7NgIkIAMgA0EgajYC4AIgAyADQewEajYCKCADIANB6ARqNgIgIANB2AJqQZjxgQEQ7ywACyAJIAdBkLCCARDDIQALIAQgBkGA9IEBEMMhAAsgBCAHQaCwggEQwyEACyAFQQFqIgUgEEcNAAsLIANBKGogA0HUBGooAgA2AgAgAyADKQLMBDcDICADQeQCaiICIANBIGoQmRIgA0HgAmogA0HIBGooAgA2AgAgAyADKQLABCISNwPYAiADKQLcAiETIANBuANqIAJBMPwKAAAgA0GIAWogA0HgBGopAgA3AwAgAyADKQLYBDcDgAECQAJAAkAgEqciAkGAgICAeEYEQCADQdgAaiADQcADaigCACIBNgIAIAMgAykCuAMiEjcDUCAAQRRqIAE2AgAgACASNwIMIAAgEzcCBCAAQSk6AAAMAQsgA0HQAGogA0G4A2pBMPwKAAAgA0HgBGogA0GIAWopAwA3AwAgAyADKQOAATcD2AQgA0EgaiIEIANB0ABqQTD8CgAAIAMgEzcChAEgAyACNgKAASADQdgCaiABKAIMIAEoAhAiAigCCEEBa0F4cWpBCGogAiAEIgIQiQEgAygC4AIhBiADKALcAiEHIAMoAtgCIgVBk4CAgHhHBEAgACADKQLkAjcCECAAIAY2AgwgACAHNgIIIAAgBTYCBCAAQSk6AAAgA0HYBGoQzy8gA0GAAWoQ6TsgAhD+JAwBCyADQbgDaiIFIANBgAFqEOAsIAMgAykCuAM3AuQCIANBADYC4AIgAyADKALEAyIJNgLcAiADIAMoAsADNgLYAiADQRBqIANB2AJqIgQQ1zsgAygCECEKQRxBBBCtNiICRQ0BIAJCgYCAgBA3AgAgAiADKQLYAjcCCCACQRBqIANB4AJqKQIANwIAIAJBGGogA0HoAmooAgA2AgAgAyAJNgKcASADIAo2ApgBIAMgAjYClAEgA0H4AmogARDKBiAIENs8IQEgA0EAOwGwAyADQQA2AqwDIANBADYClAMgA0EANgKIAyADIAE2AoQDIANCBDcC8AIgA0IANwLoAiADQoCAgIDAADcC4AIgA0EANgLYAiADKALgBCEBIAMoAuQEIQIgAyADKQPYBDcCxAMgA0EANgLAAyADIAI2ArwDIAMgATYCuAMgA0EIaiAFENc7IAMoAgghCEEcQQQQrTYiAUUNAiABQoGAgIAQNwIAIAEgAykCuAM3AgggAUEQaiADQcADaikCADcCACABQRhqIANByANqKAIANgIAIAMgAjYCWCADIAg2AlQgAyABNgJQIANB/AFqIgEgBCADQdAAahCuFiADQQA2AtACIAUgByAGENMjIAQgASAFEO8lIANBoAFqIgEgBCADQZQBahD6IyADQfwDaiICIAEQzRwgACACEK8fIANBIGoQ/iQLIANB8ARqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC0HAACAFEKM9AAtBwPSBAUEpIANB2AJqQcz8gQFB7PSBARDVHgALIAUgAygC4AJB4K+CARD9LwAL6Q8CDX8CfiMAQdABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAoQQFrDgQGAAIEAQsACyABIAEoAgAiBDYCGCABIAEoAgg2AhwgASABKAIUNgIgIAEoAgQhCCABKAIMIQYgASgCECEFIAEgBCgCDCAEKAIcEIgtIgc2AiQgASgCGCEEAkAgBkUNACAEKAIQIgtFDQAgBCgCFCEMIAFBLGoiCSAGIAUgBCgCGBC4CSABQQA2AkAgAUKAgICAwAA3AjggASgCGCIEKAIEIQcgBCgCCCEEIANBGGogASgCJBCGPCABKAIcIQ0gAygCHCEFIAMoAhghCiADIAFBOGo2AswBIAMgBjYCyAEgAyAJNgLEASADIAFBIGo2AsABIAMgDDYCvAEgAyALNgK4ASADIA02ArQBIANBADYCsAEgA0EANgKoASADIAo2AqABIAMgByAEQQJ0ajYCnAEgAyAHNgKYASADQQA2AogBIANBADYCeCADIAUgBCAEIAVLGzYCrAEgAyAKIAVBwAJsajYCpAEgA0EkaiIEIANB+ABqEJ0QIANBEGogCCAEEPQXIAMoAhAhBCABIAMoAhQiBTYCSCABIAQ2AkQMAgsgBCgCCCEGIAQoAgQhBCABKAIcIQUgAyAHNgKIASADIAU2AoQBIANBADYCgAEgAyAENgJ4IAMgBCAGQQJ0ajYCfCADQdwAaiIEIANB+ABqEMcPIANBCGogCCAEEPQXIAMoAgghBCABIAMoAgwiBTYCMCABIAQ2AiwMAwsgASgCSCEFIAEoAkQhBAsgA0H4AGogBCACIAUoAgwRAQAgAygCeCICQQlHDQMgAEEJNgIAQQMhAgwICyABKAIwIQUgASgCLCEECyADQfgAaiAEIAIgBSgCDBEBACADKAJ4IgJBCUcNAiAAQQk2AgBBBCECDAYLQYj+wgAQ6CsACyADKQOIASEQIAMoAoQBIQUgAygCgAEhBCADKAJ8IQYgAUHEAGoQvCogAkEIRwRAIAFBOGoiCBDWKyAIEOg7IAFBLGoQ6jsMAwsgAyAGNgI4IAMgBDYCMCADIAQ2AjQgAyAEIAVBBHRqNgI8IAMgASgCODYCcCADIAEoAjwiAiABKAJAQQxsajYCdCADIAI2AmwgAyACNgJoIAEoAhgiAigCCCIEBEAgAigCBCIGIARBAnRqIQogA0HYAGohC0EAIQgDQAJAIAYoAgANACABKAIcIAgQ8iZFDQAgAygCbCICIAMoAnRGDQAgAyACQQxqNgJsIAIoAgAiDEGAgICAeEYNACADQfgAaiACKQIEIhBCIIinIgdBAEEEQRAQoBggAygCfCECAkAgAygCeEEBRwRAIANBADYCTCADIAMoAoABNgJIIAMgAjYCRCAQQoCAgIAQWgRAQQAhBCADKAI0IQkgAygCPCENQQAhBQNAAkAgDSAEIAlqIgJHBEAgAyACQRBqNgI0IAIoAgAiDg0BC0Go/sIAELI7AAsgA0GAAWoiDyACQQxqKAIANgIAIAMgAkEEaikCADcDeCADKAJEIAVGBEAgA0HEAGpBuP7CABCeKAsgAygCSCAEaiICIA42AgAgAkEEaiADKQN4NwIAIAJBDGogDygCADYCACADIAVBAWoiBTYCTCAEQRBqIQQgBSAHRw0ACwsgA0H4AGoiBCABKAIkIAgQiS0Q7CAgAykDgAEhESADKAJEIQkgAygCSCECIAMoAkwhBSADQgA3ApgBIAMgAiAFQQR0ajYClAEgAyAJNgKQASADIAI2AowBIAMgAjYCiAEgAyAQpyICIAdBA3RqNgKEASADIAw2AoABIAMgAjYCfCADIAI2AnggA0HQAGogBBD3GEEcQQQQrTYiAkUNASACQQA2AgggAkKBgICAEDcCACACIAMpAlA3AgwgAiARPgIYIAJBFGogCygCADYCAAJAIAYoAgAiBEUNACAEIAQoAgAiBUEBazYCACAFQQFHDQAgBhDfGAsgBiACNgIADAILIAIgAygCgAFBmP7CABD9LwALQQRBHBCjPQALIAhBAWohCCAGQQRqIgYgCkcNAAsLIANB6ABqELsgIANBMGoQuxwgAUEsahDqOwwBCyADKQOIASEQIAMoAoQBIQUgAygCgAEhBCADKAJ8IQYgAUEsahC8KiACQQhHDQEgAyAGNgJwIAMgBCAFQQR0ajYCdCADIAQ2AmwgAyAENgJoIAEoAhgiAigCCCIEBEAgAigCBCECIARBAnQhBUEAIQQgA0E4aiEIA0ACQCACKAIADQAgASgCHCAEEPImRQ0AIAMoAmwiBiADKAJ0Rg0AIAMgBkEQajYCbCAGKAIAIgdFDQAgCCAGQQxqKAIANgIAIAMgBikCBDcDMCADQfgAaiABKAIkIAQQiS0Q7CAgAykDeCEQQRxBBBCtNiIGRQ0FIAYgBzYCCCAGQoGAgIAQNwIAIAYgAykDMDcCDCAGIBA+AhggBkEUaiAIKAIANgIAAkAgAigCACIHRQ0AIAcgBygCACIHQQFrNgIAIAdBAUcNACACEN8YCyACIAY2AgALIAJBBGohAiAEQQFqIQQgBUEEayIFDQALCyADQegAahC7HAtBCCECCyAAIBA3AxAgACAFNgIMIAAgBDYCCCAAIAY2AgQgACACNgIAQQEhAgwBC0EEQRwQoz0ACyABIAI6ACggA0HQAWokAAvGDwIMfwJ+IwBBgARrIgQkACAEQcwCaiACQQxqIgkQ2DwgA2wQ8h4CQAJAAkACQCAJENg8Ig4EQCABKAIsIQ8gAigCECEHIARB2AJqIQoDQAJAAkACQAJAIAIgBRCLO0UEQCAKEOY6IAQoAtgCRQ0BIAQoAugCIANqIgxBA3YgDEEHcUEAR2oiBiAEKALkAiIISwRAIAYgCGshDSAEKALcAiILIAZJBEAgCiALQQF0IgggBhDSKiILIAggC0sbEOgZIAQoAuQCIQgLIA0EQCAEKALgAiAIakEAIA38CwALIAQgBjYC5AILIAQgDDYC6AIgBEHMAmogAxC0JQwECyAEIAU2AvwDIAkQ2DwgBU0NASAHKQMAIhBCgICAgBBaBEAgBEEQakEUQQBBAUEBEKAYIAQoAhQhAiAEKAIQQQFGDQMgBCgCGCIBQRBqQbD/gQEoAAA2AAAgAUEIakGo/4EBKQAANwAAIAFBoP+BASkAADcAACAEQRQ2AmwgBCABNgJoIAQgAjYCZCAEQYaAgIB4NgJgIARBzAJqELwtDAcLIARBzAJqIA8gEKdsIgYgAyAGahCIDwwDC0H89IEBELI7AAsgBCACEP07NgKMASAEQQI2AhQgBEGI8YEBNgIQIARCAjcCHCAEQTs2AvgDIARBOzYC8AMgBCAEQewDajYCGCAEIARBjAFqNgL0AyAEIARB/ANqNgLsAyAEQRBqQZjxgQEQ7ywACyACIAQoAhhBiP2BARD9LwALIAdBCGohByAOIAVBAWoiBUcNAAsLIARB3ABqIARBzAJqIgMQ1BQgBC0AXCEFIAMQvC0gBUEpRg0AIARBzwBqIgcgBEHsAGopAAA3AAAgBEHIAGoiBiAEQeUAaikAADcDACAEQTBqIARB/ABqKQIANwIAIARBOGogBEGEAWopAgA3AgAgBEEZaiAGKQMANwAAIARBIGogBykAADcAACAEIAQpAF0iEDcDQCAEIAQpAnQ3AiggBCAQNwARIAQgBToAECADIAEoAgwgASgCECIDKAIIQQFrQXhxakEIaiADIARBEGoQiAEgBCgC1AIhAyAEKALQAiEFIAQoAswCIgdBk4CAgHhGDQEgACAEKQLYAjcCECAAIAM2AgwgACAFNgIIIAAgBzYCBCAAQSk6AAAMAgsgBEHTAGogBEHwAGooAgAiATYAACAEQcsAaiAEQegAaikCACIQNwAAIAQgBCkCYCIRNwBDIABBFGogATYAACAAQQxqIBA3AAAgACARNwAEIABBKToAAAwCCyAEIAM2ApABIAQgBTYCjAFBwAAhBgJAIAkQ2DwiA0EDdiADQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgNBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgZFDQELQQAhBSAEQQA2AtgCIAQgBjYC1AIgBCADNgLQAiAEQcAANgLMAiAEQUBrIgMgBEHMAmogBxDSJSAEQQhqIAMQhj0gBCgCDCEDIAQoAgghCCAJENg8IgpFDQIgAigCECEHA0ACQCAEIAU2AvwDAkACQCAJENg8IAVLBEAgBykDACIQQoCAgIAQWgRAIARBzAJqQRRBAEEBQQEQoBggBCgC0AIhAiAEKALMAkEBRgRAIAIgBCgC1AJBiP2BARD9LwALIAQoAtQCIgFBEGpBsP+BASgAADYAACABQQhqQaj/gQEpAAA3AAAgAUGg/4EBKQAANwAAIABBFDYCECAAIAE2AgwgACACNgIIIABBhoCAgHg2AgQgAEEpOgAAIARBQGsQzy8gBCgCjAEiACAAKAIAIgBBAWs2AgAgAEEBRw0JIARBjAFqELsjDAkLIAIgBRCLO0UNASABIBCnEJolDQEMAgsgBCACEP07NgLsAyAEQQI2AtACIARBiPGBATYCzAIgBEICNwLYAiAEQTs2AmggBEE7NgJgIAQgBEHcAGo2AtQCIAQgBEHsA2o2AmQgBCAEQfwDajYCXCAEQcwCakGY8YEBEO8sAAsgBUEDdiIGIANPDQEgBiAIaiIGIAYtAABBfiAFQQdxd3E6AAALIAdBCGohByAKIAVBAWoiBUcNAQwECwsgBiADQYD0gQEQwyEAC0HAACADEKM9AAtBwPSBAUEpIARBzAJqQcz8gQFB7PSBARDVHgALIARB7AJqIAEQygYgCRDYPCEBIARBADsBpAMgBEEANgKgAyAEQQA2AogDIARBADYC/AIgBCABNgL4AiAEQgQ3AuQCIARCADcC3AIgBEKAgICAwAA3AtQCIARBADYCzAIgBCgCSCEBIAQoAkwhAiAEIAQpAkA3AmggBEEANgJkIAQgAjYCYCAEIAE2AlwgBCAEQdwAahDXOyAEKAIAIQNBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCXDcCCCABQRBqIARB5ABqKQIANwIAIAFBGGogBEHsAGooAgA2AgAgBCACNgL0AyAEIAM2AvADIAQgATYC7AMgBEHwAWoiAiAEQcwCaiIBIARB7ANqEK4WIARBADYCxAIgASAEKAKMASAEKAKQARDTIyAEQZQBaiIDIAIgARDvJSAEQagDaiIBIAMQzRwgACABENwUIARBEGoQ/iQMAgtBBEEcEKM9AAsgBEEQahD+JAsgBEGABGokAAv5DAEgfyMAQRBrIhgkACAAKAIEIgkgACgCHCIGaiABTQRAIAYgASAJayIPIAYgD0sbIQxBfyAAKAK8AUEBa3RBf3MhECAAKAJkIRUgACgCwAEhCyAAKAJcIQoDQCAGIAxGRQRAIAogBiAJaiALIAQQox1BAnRqIgcoAgAhCCAHIAY2AgAgFSAGIBBxQQN0aiIHQQE2AgQgByAINgIAIAZBAWohBgwBCwsgACAPNgIcQQAhECAPQX8gACgCvAFBAWt0QX9zIh5rIgdBACAHIA9NGyIfIAAoAhAiCCAPQQEgACgCuAF0IgdrIAggDyAIayAHSxsgACgCGBsiJCAfICRLGyEgQQEgACgCxAF0IhEhFyAKIAEgACgCwAEgBBCjHUECdGoiJSEGAkADQCAGKAIAIgcgIE0NASAVIAcgHnFBA3RqIgYoAgQiCEEBRyAXQQJJckUEQCAGIBA2AgQgF0EBayEXIAchEAwBCwsgCEEBRw0AIAZCADcCAAsgFUEEaiEZA0AgECINBEAgACgCCCIhIAAoAgwiGmoiEiACIA0gGkkiCxshIiAZIA0gHnFBA3RqKAIAIRAgFSANQX8gACgCvAFBAWt0QX9zIhNxQQN0aiIbKAIAIQYgDUEBIAAoArgBdCIIayAAKAIQIgcgDSAHayAISxshFCAJIBpqIRwgISAJIAsbIA1qISMgG0EEaiEOQQAhCkEAIQxBACELAkADQCAKIBdGIAYgFE1yDQECQCAFQQFHIAsgDCALIAxJGyIIIAZqIBpPciIHRSANIBpPcUUEQCAIICNqIAkgISAHGyAGaiIWIAhqICIQgBQgCGohBwwBCyAGICFqIgcgBiAJaiAIICNqIAcgCGogIiASIBwQzSggCGoiByAGaiAaSRshFgsgByAjaiIdICJGDQEgFSAGIBNxQQN0aiEIAkACQAJAIAcgFmotAAAgHS0AAEkEQCAbIAY2AgAgBiAgSw0BIBhBDGohGwwFCyAOIAY2AgAgBiAgTQ0CIAghDiAHIQwMAQsgCEEEaiIIIRsgByELCyAKQQFqIQogCCgCACEGDAELCyAYQQxqIQ4LIA5BADYCACAbQQA2AgAgF0EBaiEXDAELCyAAKAIIIRQgACgCDCESICUoAgAhBiAlIA82AgAgD0EJaiEWIAkgEmohHCASIBRqIR0gFSAPIB5xQQN0aiITQQRqIQ5BACEMIAVBAUchDUEAIQtBACEKAkADQCARRSAGICRNcg0BIAEgDCALIAsgDEsbIghqIQcCfyANRSAGIAhqIBJJcUUEQCAHIAYgCWogCGogAhCAFCAIaiEHIAkMAQsgFCAJIAcgBiAUaiAIaiACIB0gHBDNKCAIaiIHIAZqIBJJGwshEAJAIAcgCk0NACADKAIAZyAPIAZrIghBAWpnayAHIAprQQJ0SARAIAMgCEEDajYCACAHIQoLIAYgB2ogFiAHIBYgBmtLGyEWIAEgB2ogAkcNACARQQAgBUECRxshEQwCCyAVIAYgHnFBA3RqIQgCQAJAAkAgBiAQaiAHai0AACABIAdqLQAASQRAIBMgBjYCACAGIB9LDQEgGEEIaiETDAULIA4gBjYCACAGIB9NDQIgByELIAghDgwBCyAHIQwgCEEEaiITIQgLIBFBAWshESAIKAIAIQYMAQsLIBhBCGohDgsgDkEANgIAIBNBADYCAAJAIBFFIAVBAkdyDQAgACgCtAEiBSgCACIcIAUoAgQiHWsiGUF/IAUoArwBQQFrdEF/cyISayAFKAIQIhMgGSATayASSxshFCAFKAJcIAEgBSgCwAEgBBCjHUECdGohDCAJIAAoAgxqIQ0gASAJIAAoAhAgGWtqIg5rIgRBA2ohECAEQQFqIQcgBSgCZCEFQQAhC0EAIQgDQCARRQ0BIAwoAgAiCSATTQ0BIAogASALIAggCCALSxsiBmogCSAdaiIEIAZqIAIgHCANEM0oIAZqIgZJBEAgAygCAEEBamcgByAJa2drIAYgCmtBAnRIBEAgAyAQIAlrNgIAIAYhCgsgASAGaiACRg0CCyAFIAkgEnFBA3RqIQwCQCAEIAkgDmogBiAJaiAZSRsgBmotAAAgASAGai0AAEkEQCAJIBRNDQMgDEEEaiEMIAYhCyAIIQYMAQsgCSAUTQ0CCyARQQFrIREgBiEIDAALAAsgACAWQQhrNgIcCyAYQRBqJAAgCgujGQIcfwR+IwBB8ABrIgMkAAJAAkAgAkUNACABQUBrIRYgAUEQaiEYA0ACQAJAAkACQAJAAkACQAJAIAEoAjQiBgRAIAMgASgCLCAGbjYCPAJAIAEoAgxFDQAgGCADQTxqEOsMIR8gASgCACIGQQxrIQcgASgCBCIKIB+ncSEFIB9CGYhC/wCDQoGChIiQoMCAAX4hIUEAIQQgAygCPCETA0ACQCAFIAZqKQAAIiAgIYUiH0J/hSAfQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIh9QRQRAA0AgEyAHIB96p0EDdiAFaiAKcUF0bCIMaigCAEYNAiAfQgF9IB+DIh9QRQ0ACwsgICAgQgGGg0KAgYKEiJCgwIB/g1BFDQIgBSAEQQhqIgRqIApxIQUMAQsLIAYgDGoiBkEIaygCACIFIAUoAgAiBEEBajYCACAEQQBIDQYgBkEEaygCACEGDAgLIANBMGogASgCPEEIahCoISABKAIoIQUgAygCNCEEIAMgAygCPCITNgJcIAMgBTYCWEEAIQ4CQAJAIANBKGoiCCAEKAIUBH8gBEEYaiADQdgAahDnCyEfIAQoAgwiCiAfp3EhDCAfQhmIQv8Ag0KBgoSIkKDAgAF+ISEgBCgCCCEHQQAhDQNAAkAgByAMaikAACIgICGFIh9Cf4UgH0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIfUEUEQANAIAcgH3qnQQN2IAxqIApxQQR0ayIGQRBrKAIAIAVGBEAgEyAGQQxrKAIARg0DCyAfQgF9IB+DIh9QRQ0ACwtBACEGICAgIEIBhoNCgIGChIiQoMCAf4NQRQ0AIAwgDUEIaiINaiAKcSEMDAELCyAGQRBrQQAgBhsFQQALIgZBCGpBACAGGyIGBH8gBigCACIOIA4oAgAiBUEBajYCACAFQQBIDQEgBigCBAUgBgs2AgQgCCAONgIADAELAAsgAygCLCEGIAMoAighBSAEQQA6AAAgBQRAIAUgBSgCACIEQQFqNgIAIARBAEgNBiADQSBqIAEgAygCPCAFIAYQ+QogAyADKAIkNgJcIAMgAygCICIENgJYIARFDQggBCAEKAIAIgRBAWs2AgAgBEEBRw0IIANB2ABqELsjDAgLIAEoAjQiCCADKAI8IhNsIgogASgCMCIGTQRAIAEoAiQhBSABKAIgIQwMAwsgAyAKIAZrIgc2AlAgA0HYAGogASgCICIMIAcgASgCJCIFKAIcEQEAIAMoAlwhBiADKAJYIgRBCEcNAyADIAY2AlQgBiAHRw0BIAEgCjYCMAwCC0Gk1s0AEOIrDAQLIANBADYCWEEAIANB1ABqIANB0ABqIANB2ABqQbTWzQAQrysACyADQdgAaiAMIAggBSgCFBEBACADKAJcIQYgAygCWCIEQQhGDQELIANByABqIANB7ABqKAIANgIAIAMgAykCZDcDQCADKAJgIQwMAgsgBkUNBSADQdgAaiAMIAUoAhgRAAAgAygCYCEMIAMoAlwhBSADKAJYIgRBCEcEQCADQcgAaiADQewAaigCADYCACADIAMpAmQ3A0AgBSEGDAILIANBGGogASgCPEEIahCoISABKAIoIQ0gAygCHCEUIAUgBSgCACIEQQFqNgIAIARBAEgNACADIAw2AlwgAyAFNgJYAkACQCADQdgAahC8KyIZIBQoAjBqIBQoAixNBEBBACEVQQAhEUEAIQ4jAEEQayIKJAAgCiATIgc2AgwgCiANNgIIIBRBCGoiBEEQaiIIIApBCGoQ5wshICAEKAIIRQRAIwBB0ABrIgckACAHIAg2AhwgBCgCDCEQIAcgB0EcajYCIAJAAkAgECAQQQFqIghNBEACQCAEKAIEIgkgCUEBakEDdkEHbCAJQQhJGyIJQQF2IAhJBEACfyAJQQFqIgkgCCAIIAlJGyIIQQ9PBEAgCEH/////AUsNBUF/IAhBA3RBB25BAWtndkEBagwBC0EEQQhBECAIQQhJGyAIQQRJGwshCCAHQUBrIARBEGoiC0EQQQggCBCdFCAHKAJEIQkgBygCQCINRQRAIAcoAkghCAwFCyAHKQJIIR8gCUEJaiIIBEAgDUH/ASAI/AsACyAHIB9CIIg+AjwgByAfpyIaNgI4IAcgCTYCNCAHIA02AjAgB0KQgICAgAE3AiggByALNgIkIAdBMGohGyAHIBAEfyANQQhqIRwgBCgCACIXKQMAQn+FQoCBgoSIkKDAgH+DIR9BACEIA0AgH1AEQANAIAhBCGohCCAXQQhqIhcpAwBCgIGChIiQoMCAf4MiH0KAgYKEiJCgwIB/UQ0ACyAfQoCBgoSIkKDAgH+FIR8LIA0gCSAHKAIcIAQoAgAgH3qnQQN2IAhqIh1BBHRrQRBrEOcLpyIecSILaikAAEKAgYKEiJCgwIB/gyIhUARAQQghDwNAIAsgD2ohCyAPQQhqIQ8gDSAJIAtxIgtqKQAAQoCBgoSIkKDAgH+DIiFQDQALCyAfQgF9IB+DIR8gDSAheqdBA3YgC2ogCXEiC2osAABBAE4EQCANKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgCyANaiAeQRl2Ig86AAAgHCALQQhrIAlxaiAPOgAAIA0gC0F/c0EEdGoiCyAEKAIAIB1Bf3NBBHRqIg8pAAA3AAAgC0EIaiAPQQhqKQAANwAAIBBBAWsiEA0ACyAEKAIMBUEACyIINgI8IAcgGiAIazYCOCAEIBtBBBD6KiAHQSRqENAmDAELIAQgB0EgakHspc8AQRAQxQkLQYGAgIB4IQkMAgsQ4ycgBygCDCEIIAcoAgghCQwBCxDjJyAHKAIUIQggBygCECEJCyAKIAg2AgQgCiAJNgIAIAdB0ABqJAAgCigCCCENIAooAgwhBwsgA0EQaiEPIAQoAgQiCyAgp3EhCCAgQhmIIiFC/wCDQoGChIiQoMCAAX4hIiAEKAIAIQkDQAJAAn8CQAJAAkAgCCAJaikAACIgICKFIh9Cf4UgH0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIfUEUEQANAIAkgH3qnQQN2IAhqIAtxQQR0ayIQQRBrKAIAIA1GBEAgByAQQQxrKAIARg0DCyAfQgF9IB+DIh9QRQ0ACwsgIEKAgYKEiJCgwIB/gyEfIBVFBEAgH1ANAyAfeqdBA3YgCGogC3EhEQtBASAfICBCAYaDUA0DGkEAIQggCSARaiwAACIVQQBOBEAgCSAJKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhFQsgCSARaiAhp0H/AHEiDjoAACAJIBFBCGsgC3FqQQhqIA46AAAgBCAEKAIIIBVBAXFrNgIIIAQgBCgCDEEBajYCDCAJIBFBBHRrIg5BEGsgDTYCACAOQQxrIAc2AgAgDkEIayAFNgIAIA5BBGsgDDYCAAwBCyAQQQRrIgQoAgAhDiAEIAw2AgAgEEEIayIEKAIAIQggBCAFNgIACyAPIA42AgQgDyAINgIAIApBEGokAAwCC0EACyEVIAggDkEIaiIOaiALcSEIDAELCyADKAIQRQ0BQdjpzQBBJEH86c0AEJ8pAAsgBSAFKAIAIgRBAWs2AgAgBEEBRw0BIANB2ABqELsjDAELIBQgFCgCMCAZajYCMAsgFEEAOgAAIANBCGogASATIAUgDBD5CiADIAMoAgw2AlwgAyADKAIIIgU2AlgCQCAFRQ0AIAUgBSgCACIFQQFrNgIAIAVBAUcNACADQdgAahC7IwsgASABKAIwIAZqIgQ2AjAgASABKAI4IgUEfyAFIAUoAgggBmo2AgggASgCMAUgBAsgASgCLCIEayIFIAIgEmsiCiAFIApJGyIFIARqNgIsIBYgBRDZECAFIBJqIRIgBiABKAI0SQ0FDAMLAAsgACAMNgIIIAAgBjYCBCAAIAQ2AgAgACADKQNANwIMIABBFGogA0HIAGooAgA2AgAMBAsgAyAGNgJcIAYoAgghBCADIAU2AlggBSAEQQFrQXhxakEIaiAGKAIkEQQAIAEoAjQgAygCPGxqIgYgASgCLCIFTQRAIAMoAlgiASABKAIAIgFBAWs2AgAgAUEBRw0DIANB2ABqELsjDAMLIAYgBWsiBiACIBJrIgQgBCAGSxshBiABIAEoAjgiBAR/IAQgBCgCDCAGajYCDCABKAIsBSAFCyAGajYCLCAWIAYQ2RAgAygCWCIFIAUoAgAiBUEBazYCACAFQQFGBEAgA0HYAGoQuyMLIAYgEmohEgsgAiASSw0ACwsgAEEINgIAIAAgEjYCBAsgA0HwAGokAAvBDgIGfwh+IwBB8AFrIgMkACABQQxqENo8IQcgA0HYAGogARCSNhDuJSAHQQV0IgQhBQJAAkACQAJAAkACQAJAAkAgBEEgcSIGBEAgBCAGa0FAayIFIARJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgAyAGNgJ4IAMgBTYCdCADQcAANgJwIAQEQCAGQQAgBPwLAAsgAyAHNgKAASADIAQ2AnwgAygCWEUNAyADKAJsIAMoAmhGDQQgA0GQAWogA0HYAGoQyDQgA0GwAWohBCACKAIIIQUgAigCACECIAEoAhAhBwJAA0ACQCADKQO4ASIKUEUEQCADKQPAASEJDAELA0ACfgJAIAMpA6ABIglCA1IEQAJAAkACQCAJQgJRDQAgAyAJUK1CAYY3A6ABIAmnQQFxRQ0AIAMgAykDqAE3A9gBDAELIAMoArABRQ0BIANB0AFqIAQQtiogAykD0AEhCQsgCUIAUg0CCyADQgM3A6ABCyADKQOQASIJQgJRDQogA0IANwOQASADKQOYAQwBCyADKQPYAQshCiAJp0EBcUUNCCADIAMpA8ABQkB9Igk3A8ABIAMgCjcDuAEgClANAAsLIAMgCkIBIAp6IguGhTcDuAFCgICAgICAgICAfyEMQgAhDQJAAn4CQAJAIAcgC6cgCadqIghBBHRqIgEpAwAiDiABKQMIIg9CgICAgICAgICAf4WEQgBSIAIoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCUIAIQsMAQsgCSAKhFANAyADQUBrIA4gDyAKIAkQgxkgA0EwaiADKQNAIgsgAykDSCIMIAogCRCoHkIAIA4gAykDMCIQfSAJIAqDQn9RIgEbIQ1CACAPIAMpAzh9IA4gEFStfSABGyEJIA9CAFkNAQsgCyANIAIoAggiASkDAFggCSABKQMIIgpXIAkgClEbrSIKfSEJIAwgCiALVq19DAELIAwgCyANIAIoAgQiASkDAFogCSABKQMIIgpZIAkgClEbrXwiCSALVK18CyELIANB0AFqIgEgCSALELIuIAEgAykD0AEiCSADKQPYASILIAMpA+ABIgogAykD6AEiDCAFLQAAENAOIAMoAtABIgFBk4CAgHhHDQIgBiAIQQV0aiIBIAw3AxggASAKNwMQIAEgCzcDCCABIAk3AwAMAQsLQcyP/wAQ4isACyADKQLUASEJIAAgAykC3AE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQZABakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACECA0BCgICAgICAgICAfyEMAn4CQAJAIAQpAwAiDSAEKQMIIg5CgICAgICAgICAf4WEQgBSIAUoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCkIAIQlCACELDAELIAkgCoRQDQggA0EgaiANIA4gCiAJEIMZIANBEGogAykDICILIAMpAygiDCAKIAkQqB5CACANIAMpAxAiD30gCSAKg0J/USIBGyEKQgAgDiADKQMYfSANIA9UrX0gARshCSAOQgBZDQELIAsgCiAFKAIIIgEpAwBYIAkgASkDCCIKVyAJIApRG60iCn0hCSAMIAogC1atfQwBCyAMIAsgCiAFKAIEIgEpAwBaIAkgASkDCCIKWSAJIApRG618IgkgC1StfAshCyADQZABaiIBIAkgCxCyLiABIAMpA5ABIgkgAykDmAEiCyADKQOgASIKIAMpA6gBIgwgCC0AABDQDiADKAKQASIBQZOAgIB4Rw0CIAYgCTcDACAGQRhqIAw3AwAgBkEQaiAKNwMAIAYgCzcDCCAEQRBqIQQgBkEgaiEGIAcgAkEBaiICRw0ACwsgA0GQAWoiAhCXKSADQfgAaiIBKAIAIQUgAygCfCEGIAEgA0GYAWoiBCkCADcDACADKQNwIQkgAyADKQKQATcDcCADQQA2AoABIAMgCTcCnAEgA0EANgKYASADIAY2ApQBIAMgBTYCkAEgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCkAE3AgggAUEQaiAEKQIANwIAIAFBGGogA0GgAWoiBygCADYCACADIAY2AtgBIAMgBTYC1AEgAyABNgLQASADQYQBaiIBIANB0AFqEOIZIAcgA0HoAGopAgA3AwAgBCADQeAAaikCADcDACADIAMpAlg3A5ABIAAgASACEM4dIANB8ABqEM8vDAILIAMpApQBIQkgACADKQKcATcCEAsgACAJNwIIIABBKToAACAAIAE2AgQgA0HwAGoQzy8gAygCWCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQdgAahD7HgsgA0HwAWokAA8LQcyP/wAQ4isAC0EEQRwQoz0AC4APAgh/BH4jAEGQAWsiAiQAIAJB+ABqIAEQ8ScgAkHoAGoiBCACQYQBaiIFKAIANgIAIAIgAikCfDcDYAJAIAIoAngiBkEERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAY2AgggAEICNwMAIABBFGogBCgCADYCAAwBCyACQdAAaiAEKAIANgIAIAIgAikDYDcDSCACQcgAahCGMCACQYCAgIB4NgIIIAJBgICAgHg2AhggAkGAgICAeDYCKCACQYCAgIB4NgI4IAJB+ABqIAEQsw4gBCAFKQIANwMAIAJB8ABqIgYgAkGMAWooAgA2AgAgAiACKQJ8NwNgAkACQAJAAkAgAigCeEUEQCACQfwAaiEEQQIhB0ECIQgDQCACQdgAaiAGKAIAIgM2AgAgAkHQAGogAkHoAGoiBSkDADcDACACIAIpA2A3A0gCQAJAIANB/wFxBEAgAkH4AGogAkHIAGoQ/BcgAi8BfCEDIAIoAngiCUEERwRAIAAgAikBfjcBDiAAQRRqIAJBhAFqKQEANwEAIAAgAzsBDCAAIAk2AgggAEICNwMADAgLAkACQAJAAkACQAJAAkACQAJAIANBAWsOCAABAgMEBQYHCAsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERg0JIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDwsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDwsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQRhqEIYwIAJBIGogAygCADYCACACIAIpA3g3AxgMCQsgAkH4AGogARCSIyACKAJ4DQwgAikDgAEhDEIBIQoMCAsgAkH4AGogARCSIyACKAJ4DQogAikDgAEhDUIBIQsMBwsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMDAsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQShqEIYwIAJBMGogAygCADYCACACIAIpA3g3AygMBgsgAkH4AGogARDoDyAFIARBCGooAgA2AgAgAiAEKQIANwNgIAIoAngiA0EERwRAIAIoAogBIQEgACACKQNgNwIMIAAgATYCGCAAIAM2AgggAEICNwMAIABBFGogAkHoAGooAgA2AgAMCwsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQThqEIYwIAJBQGsgAygCADYCACACIAIpA3g3AzgMBQsgAkH4AGogARDsEyACLQB8IQcgAigCeCIDQQRGDQQgACACKQB9NwANIABBFGogAkGEAWopAAA3AAAgACAHOgAMIAAgAzYCCCAAQgI3AwAMCQsgAkH4AGogARDsEyACLQB8IQggAigCeCIDQQRGDQMgACACKQB9NwANIABBFGogAkGEAWopAAA3AAAgACAIOgAMIAAgAzYCCCAAQgI3AwAMCAsgAkH4AGogASACLQBYQcAAELQCIAIoAngiA0EERg0CIAAgAikCfDcCDCAAQRRqIAJBhAFqKQIANwIAIABCAjcDACAAIAM2AggMBwsgAkHIAGoQhjAgAkH4AGogARCqKSACKAJ4IgFBBEcEQCAAIAIpAnw3AgwgAEEUaiACQYQBaikCADcCACAAQgI3AwAgACABNgIIDAgLIAAgAikDCDcCICAAIAIpAxg3AiwgACACKQMoNwI4IAAgAikDODcCRCAAIAc6AFAgACAIOgBRIAAgDTcDGCAAIAs3AxAgACAMNwMIIAAgCjcDACAAQShqIAJBEGooAgA2AgAgAEE0aiACQSBqKAIANgIAIABBQGsgAkEwaigCADYCACAAQcwAaiACQUBrKAIANgIADAgLIAJBgAFqIgMgBSgCADYCACACIAIpA2A3A3ggAkEIahCGMCACQRBqIAMoAgA2AgAgAiACKQN4NwMICyACQcgAahCGMCACQfgAaiABELMOIAUgBEEIaikCADcDACAGIARBEGooAgA2AgAgAiAEKQIANwNgIAIoAnhFDQALCyAAIAIpA2A3AgggAEICNwMAIABBGGogBigCADYCACAAQRBqIAJB6ABqKQMANwIADAMLIAIoAnwhASACKQOAASEKIAAgAikDiAE3AhQgACAKNwIMIAAgATYCCCAAQgI3AwAMAQsgAigCfCEBIAIpA4ABIQogACACKQOIATcCFCAAIAo3AgwgACABNgIIIABCAjcDAAsgAkHIAGoQhjALIAJBOGoQhjAgAkEoahCGMCACQRhqEIYwIAJBCGoQhjALIAJBkAFqJAALgA8CCH8EfiMAQZABayICJAAgAkH4AGogARDxJyACQegAaiIEIAJBhAFqIgUoAgA2AgAgAiACKQJ8NwNgAkAgAigCeCIGQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgBjYCCCAAQgI3AwAgAEEUaiAEKAIANgIADAELIAJB0ABqIAQoAgA2AgAgAiACKQNgNwNIIAJByABqEIYwIAJBgICAgHg2AgggAkGAgICAeDYCGCACQYCAgIB4NgIoIAJBgICAgHg2AjggAkH4AGogARCyDiAEIAUpAgA3AwAgAkHwAGoiBiACQYwBaigCADYCACACIAIpAnw3A2ACQAJAAkACQCACKAJ4RQRAIAJB/ABqIQRBAiEHQQIhCANAIAJB2ABqIAYoAgAiAzYCACACQdAAaiACQegAaiIFKQMANwMAIAIgAikDYDcDSAJAAkAgA0H/AXEEQCACQfgAaiACQcgAahD8FyACLwF8IQMgAigCeCIJQQRHBEAgACACKQF+NwEOIABBFGogAkGEAWopAQA3AQAgACADOwEMIAAgCTYCCCAAQgI3AwAMCAsCQAJAAkACQAJAAkACQAJAAkAgA0EBaw4IAAECAwQFBgcICyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRGDQkgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwPCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwPCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBGGoQhjAgAkEgaiADKAIANgIAIAIgAikDeDcDGAwJCyACQfgAaiABEJEjIAIoAngNDCACKQOAASEMQgEhCgwICyACQfgAaiABEJEjIAIoAngNCiACKQOAASENQgEhCwwHCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwMCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBKGoQhjAgAkEwaiADKAIANgIAIAIgAikDeDcDKAwGCyACQfgAaiABEOkPIAUgBEEIaigCADYCACACIAQpAgA3A2AgAigCeCIDQQRHBEAgAigCiAEhASAAIAIpA2A3AgwgACABNgIYIAAgAzYCCCAAQgI3AwAgAEEUaiACQegAaigCADYCAAwLCyACQYABaiIDIAUoAgA2AgAgAiACKQNgNwN4IAJBOGoQhjAgAkFAayADKAIANgIAIAIgAikDeDcDOAwFCyACQfgAaiABEOsTIAItAHwhByACKAJ4IgNBBEYNBCAAIAIpAH03AA0gAEEUaiACQYQBaikAADcAACAAIAc6AAwgACADNgIIIABCAjcDAAwJCyACQfgAaiABEOsTIAItAHwhCCACKAJ4IgNBBEYNAyAAIAIpAH03AA0gAEEUaiACQYQBaikAADcAACAAIAg6AAwgACADNgIIIABCAjcDAAwICyACQfgAaiABIAItAFhBwAAQswIgAigCeCIDQQRGDQIgACACKQJ8NwIMIABBFGogAkGEAWopAgA3AgAgAEICNwMAIAAgAzYCCAwHCyACQcgAahCGMCACQfgAaiABEKopIAIoAngiAUEERwRAIAAgAikCfDcCDCAAQRRqIAJBhAFqKQIANwIAIABCAjcDACAAIAE2AggMCAsgACACKQMINwIgIAAgAikDGDcCLCAAIAIpAyg3AjggACACKQM4NwJEIAAgBzoAUCAAIAg6AFEgACANNwMYIAAgCzcDECAAIAw3AwggACAKNwMAIABBKGogAkEQaigCADYCACAAQTRqIAJBIGooAgA2AgAgAEFAayACQTBqKAIANgIAIABBzABqIAJBQGsoAgA2AgAMCAsgAkGAAWoiAyAFKAIANgIAIAIgAikDYDcDeCACQQhqEIYwIAJBEGogAygCADYCACACIAIpA3g3AwgLIAJByABqEIYwIAJB+ABqIAEQsg4gBSAEQQhqKQIANwMAIAYgBEEQaigCADYCACACIAQpAgA3A2AgAigCeEUNAAsLIAAgAikDYDcCCCAAQgI3AwAgAEEYaiAGKAIANgIAIABBEGogAkHoAGopAwA3AgAMAwsgAigCfCEBIAIpA4ABIQogACACKQOIATcCFCAAIAo3AgwgACABNgIIIABCAjcDAAwBCyACKAJ8IQEgAikDgAEhCiAAIAIpA4gBNwIUIAAgCjcCDCAAIAE2AgggAEICNwMACyACQcgAahCGMAsgAkE4ahCGMCACQShqEIYwIAJBGGoQhjAgAkEIahCGMAsgAkGQAWokAAucDQIKfwN+IwBBsAFrIgIkACABQQxqENg8IQUCQAJAAkAgARCSNiIDBEBBwAAhBiACQRBqIAMQ3DsgAygCFCEKIAMoAgwhByACKAIUIQggAigCECEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgZFDQMLIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCSAIEL8YDAELQcAAIQYgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBkUNAgsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCkUNAiAFIApGDQMgCQRAIAJB6ABqIAkgCCAHIAUQvxQgAkGIAWohCSABKAIQIQcgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogCRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgByAOpyAMp2oiCEEDdGorAwC2vCIFQf///wNxIQQgBUGAgICAeHEhAwJAIAVBgICA/AdxIgFBgICA/AdGBEAgBEENdiADQRB2ciAEQQBHQQl0ckGA+AFyIQMMAQsgA0EQdiEDIAFBgICAuARNBEAgAUGAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgAUENdiAEQQ12akGAgAFqIANyaiEDDAILIAFBgICAmANJDQEgBEGAgIAEciIFQR4gAUEXdiIEa3YhASAFQR0gBGsiBHZBAXEEfyABQQMgBHRBAWsgBXFBAEdqBSABCyADciEDDAELIANBgPgBciEDCyAGIAhBAXRqIAM7AQAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhA0EAIQkDQCADKwMAtrwiB0H///8DcSEIIAdBgICAgHhxIQECQCAHQYCAgPwHcSIEQYCAgPwHRgRAIAhBDXYgAUEQdnIgCEEAR0EJdHJBgPgBciEBDAELIAFBEHYhASAEQYCAgLgETQRAIARBgICAxANPBEAgB0EMdiAHQf/fAHFBAEdxIARBDXYgCEENdmpBgIABaiABcmohAQwCCyAEQYCAgJgDSQ0BIAhBgICABHIiB0EeIARBF3YiCGt2IQQgB0EdIAhrIgh2QQFxBH8gBEEDIAh0QQFrIAdxQQBHagUgBAsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiADQQhqIQMgBSAJQQFqIglHDQALCyACQcgAaiACQRxqIgQQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhCSACKAI8IQUgASACQfAAaiIGKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgCTYCaCACQQhqIAMQ1zsgAigCCCEJQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAGKQIANwIAIAFBGGogAkH4AGoiBygCADYCACACIAU2AqgBIAIgCTYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAcgAkHYAGooAgA2AgAgBiACQdAAaikCADcDACACIAIpAkg3A2ggAiAKNgJ8IAAgASADEM8dIAJBMGoQzy8gBBDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC5wNAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEGIAJBEGogAxDcOyADKAIUIQogAygCDCEHIAIoAhQhCCACKAIQIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBkUNAwsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAJIAgQvxgMAQtBwAAhBiAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIGRQ0CCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQMCQAJAAkAgBEE+cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAKRQ0CIAUgCkYNAyAJBEAgAkHoAGogCSAIIAcgBRC/FCACQYgBaiEJIAEoAhAhByACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAJELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAHIA6nIAynaiIIQQN0aikDALS8IgVB////A3EhBCAFQYCAgIB4cSEDAkAgBUGAgID8B3EiAUGAgID8B0YEQCAEQQ12IANBEHZyIARBAEdBCXRyQYD4AXIhAwwBCyADQRB2IQMgAUGAgIC4BE0EQCABQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSABQQ12IARBDXZqQYCAAWogA3JqIQMMAgsgAUGAgICYA0kNASAEQYCAgARyIgVBHiABQRd2IgRrdiEBIAVBHSAEayIEdkEBcQR/IAFBAyAEdEEBayAFcUEAR2oFIAELIANyIQMMAQsgA0GA+AFyIQMLIAYgCEEBdGogAzsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEDQQAhCQNAIAMpAwC0vCIHQf///wNxIQggB0GAgICAeHEhAQJAIAdBgICA/AdxIgRBgICA/AdGBEAgCEENdiABQRB2ciAIQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIARBgICAuARNBEAgBEGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgBEENdiAIQQ12akGAgAFqIAFyaiEBDAILIARBgICAmANJDQEgCEGAgIAEciIHQR4gBEEXdiIIa3YhBCAHQR0gCGsiCHZBAXEEfyAEQQMgCHRBAWsgB3FBAEdqBSAECyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIANBCGohAyAFIAlBAWoiCUcNAAsLIAJByABqIAJBHGoiBBCCFCACQegAaiIDEJcpIAJBOGoiASgCACEJIAIoAjwhBSABIAJB8ABqIgYpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAJNgJoIAJBCGogAxDXOyACKAIIIQlBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQfgAaiIHKAIANgIAIAIgBTYCqAEgAiAJNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgByACQdgAaigCADYCACAGIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAo2AnwgACABIAMQzx0gAkEwahDPLyAEEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALnA0CCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEIIAIoAhAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAkgCBC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAkEQCACQegAaiAJIAggByAFEL8UIAJBiAFqIQkgASgCECEHIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAkQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAcgDqcgDKdqIghBAnRqKAIAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAygCALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgA0EEaiEDIAUgCUEBaiIJRw0ACwsgAkHIAGogAkEcaiIEEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQkgAigCPCEFIAEgAkHwAGoiBikCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAk2AmggAkEIaiADENc7IAIoAgghCUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBikCADcCACABQRhqIAJB+ABqIgcoAgA2AgAgAiAFNgKoASACIAk2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAHIAJB2ABqKAIANgIAIAYgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCjYCfCAAIAEgAxDPHSACQTBqEM8vIAQQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuOEQIFfwF+IwBBgANrIgIkACABKQKIAiEHIAFCgICAgIABNwOIAiACQdABaiABQZACaiIDKAIANgIAIANBADYCACACIAc3A8gBIAJBBGoiBSACQcgBaiIDIAFB0AJqIgYQ3hggAkEAOwGgAiACQQA2ApwCIAJBADYChAIgAkEANgL4ASACQQw6AOgBIAJCBDcC4AEgAkIANwLYASACQoCAgIDAADcC0AEgAkEANgLIASACIAEoAqQCNgL0ASACQewAaiIEIAMgBRD6IyADIAEQ1hggAkEQaiIFIAQgAxCuFiADIAUQzRwgBCADEMcTAkACQAJAAkACQAJAAkBBOEEEEK02IgUEQCAFQoGAgIAQNwIAIAVBCGoiAyAEQTD8CgAAIAJBhOLNADYCqAIgAiAFNgKkAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGLQAAIgRBAmsOBgECHh4DBAALAkACQAJAAkAgBEEiaw4FASEXAgMACyAEQQ9GDQcMIAsgASgC2AItAABBI2sOBAoHCAkUCyADLQAAQQRrDgIVFhcLIAMtAABBBGsOAhcYGQsgA0Hc4s0AELgIRQ0cQejizQAQsjsACyADQdzizQAQuAhFDRtB0OPNABCyOwALIANB3OLNABC4CEUNGkG45M0AELI7AAsgA0Hc4s0AELgIRQ0ZQaDlzQAQsjsACyADQdzizQAQuAhFDRggAkHIAWogAkGkAmpBtMjNAEGI5s0AEOkjIAIoAtABIQMgAigCzAEhBCACKALIASIFQZOAgIB4RwRAIAIgAikC1AE3ArgCIAIgAzYCtAIgAiAENgKwAiACIAU2AqwCIAAgAkGsAmoQpiUMGwsgAiADNgJwIAIgBDYCbCACQcgBaiACQewAaiIEQbTIzQAgBhDpIyACKALQASEDIAIoAswBIQYgAigCyAEiBUGTgICAeEcEQCACIAIpAtQBNwLMAiACIAM2AsgCIAIgBjYCxAIgAiAFNgLAAiAAIAJBwAJqEKYlIAIoAmwiACAAKAIAIgBBAWs2AgAgAEEBRw0bIAQQuyMMGwsgAigCbCIEIAQoAgAiBEEBazYCACAEQQFHDRkgAkHsAGoQuyMMGQsgAy0AAEEEaw4CAwQFCyADLQAAQQRrDgIFBgcLIAMtAABBBGsOAgcICQsgAy0AAEEERg0TIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADBYLQdzmzQAQsjsAC0Hs5s0AELI7AAsgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMEwtB/ObNABCyOwALQYznzQAQsjsACyACQQI2AswBIAJBzObNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEKIYIABBAzYCAAwQC0H0580AELI7AAtBhOjNABCyOwALIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADA0LIAJByAFqIAJBpAJqQbTIzQAgBhDpIyACKALQASEDIAIoAswBIQYgAigCyAEiBEGTgICAeEYNCyACIAIpAtQBNwLkAiACIAM2AuACIAIgBjYC3AIgAiAENgLYAiAAIAJB2AJqEKYlDAwLIANB3OLNABC4CEUNCSADLQAAQQRGDQcgAkECNgLMASACQYjpzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCZDiAAQQM2AgAMCwtBmOnNABCyOwALQajpzQAQsjsACyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEJkOIABBAzYCAAwIC0G46c0AELI7AAtByOnNABCyOwALIAJBAjYCzAEgAkGI6c0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQmQ4gAEEDNgIADAULQQRBOBCjPQALQezozQAQsjsAC0GU5s0AELI7AAsgAkHIAWogAkGkAmpBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIEQZOAgIB4Rg0AIAIgAikC1AE3AvgCIAIgAzYC9AIgAiAGNgLwAiACIAQ2AuwCIAAgAkHsAmoQpiUMAQsCf0GAgICAeCABKALgASIEQYGAgIB4Rg0AGkGAgICAeCAEQYCAgIB4Rg0AGiABKQLkASEHIAFBADYC6AEgAUKAgICAIDcD4AEgBAshBCABQbgCahC0MCABIAc3ArwCIAEgBDYCuAIgASgClAIiBEGAgICAeEcEQCABKQOYAiEHIAFBADYCnAIgAUKAgICAIDcClAILIAFBxAJqELQwIAEgBzcDyAIgASAENgLEAiABQgA3AqQCIAAgAzYCCCAAIAY2AgQgAEEINgIAIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUYNAQwCCyACKAKkAiIAIAAoAgAiAEEBazYCACAAQQFHDQELIAJBpAJqELsjCyACQYADaiQAC44RAgV/AX4jAEGAA2siAiQAIAEpAogCIQcgAUKAgICAwAA3A4gCIAJB0AFqIAFBkAJqIgMoAgA2AgAgA0EANgIAIAIgBzcDyAEgAkEEaiIFIAJByAFqIgMgAUHQAmoiBhDdGCACQQA7AaACIAJBADYCnAIgAkEANgKEAiACQQA2AvgBIAJBCzoA6AEgAkIENwLgASACQgA3AtgBIAJCgICAgMAANwLQASACQQA2AsgBIAIgASgCpAI2AvQBIAJB7ABqIgQgAyAFEPojIAMgARDWGCACQRBqIgUgBCADEK4WIAMgBRDNHCAEIAMQsxMCQAJAAkACQAJAAkACQEE4QQQQrTYiBQRAIAVCgYCAgBA3AgAgBUEIaiIDIARBMPwKAAAgAkGs4c0ANgKoAiACIAU2AqQCAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYtAAAiBEECaw4GAQIeHgMEAAsCQAJAAkACQCAEQSJrDgUBIRcCAwALIARBD0YNBwwgCyABKALYAi0AAEEjaw4ECgcICRQLIAMtAABBBGsOAhUWFwsgAy0AAEEEaw4CFxgZCyADQdzizQAQuAhFDRxB6OLNABCyOwALIANB3OLNABC4CEUNG0HQ480AELI7AAsgA0Hc4s0AELgIRQ0aQbjkzQAQsjsACyADQdzizQAQuAhFDRlBoOXNABCyOwALIANB3OLNABC4CEUNGCACQcgBaiACQaQCakG0yM0AQYjmzQAQ6SMgAigC0AEhAyACKALMASEEIAIoAsgBIgVBk4CAgHhHBEAgAiACKQLUATcCuAIgAiADNgK0AiACIAQ2ArACIAIgBTYCrAIgACACQawCahCmJQwbCyACIAM2AnAgAiAENgJsIAJByAFqIAJB7ABqIgRBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIFQZOAgIB4RwRAIAIgAikC1AE3AswCIAIgAzYCyAIgAiAGNgLEAiACIAU2AsACIAAgAkHAAmoQpiUgAigCbCIAIAAoAgAiAEEBazYCACAAQQFHDRsgBBC7IwwbCyACKAJsIgQgBCgCACIEQQFrNgIAIARBAUcNGSACQewAahC7IwwZCyADLQAAQQRrDgIDBAULIAMtAABBBGsOAgUGBwsgAy0AAEEEaw4CBwgJCyADLQAAQQRGDRMgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMFgtB3ObNABCyOwALQezmzQAQsjsACyACQQI2AswBIAJBzObNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEKIYIABBAzYCAAwTC0H85s0AELI7AAtBjOfNABCyOwALIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQohggAEEDNgIADBALQfTnzQAQsjsAC0GE6M0AELI7AAsgAkECNgLMASACQczmzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCiGCAAQQM2AgAMDQsgAkHIAWogAkGkAmpBtMjNACAGEOkjIAIoAtABIQMgAigCzAEhBiACKALIASIEQZOAgIB4Rg0LIAIgAikC1AE3AuQCIAIgAzYC4AIgAiAGNgLcAiACIAQ2AtgCIAAgAkHYAmoQpiUMDAsgA0Hc4s0AELgIRQ0JIAMtAABBBEYNByACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJwIAIgAzYC1AIgAiACQewAajYC0AEgAiACQdQCajYCbCAAQQRqIAJByAFqEJkOIABBAzYCAAwLC0GY6c0AELI7AAtBqOnNABCyOwALIAJBAjYCzAEgAkGI6c0ANgLIASACQgE3AtQBIAJBrwM2AnAgAiADNgLUAiACIAJB7ABqNgLQASACIAJB1AJqNgJsIABBBGogAkHIAWoQmQ4gAEEDNgIADAgLQbjpzQAQsjsAC0HI6c0AELI7AAsgAkECNgLMASACQYjpzQA2AsgBIAJCATcC1AEgAkGvAzYCcCACIAM2AtQCIAIgAkHsAGo2AtABIAIgAkHUAmo2AmwgAEEEaiACQcgBahCZDiAAQQM2AgAMBQtBBEE4EKM9AAtB7OjNABCyOwALQZTmzQAQsjsACyACQcgBaiACQaQCakG0yM0AIAYQ6SMgAigC0AEhAyACKALMASEGIAIoAsgBIgRBk4CAgHhGDQAgAiACKQLUATcC+AIgAiADNgL0AiACIAY2AvACIAIgBDYC7AIgACACQewCahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIQcgAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgBzcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIQcgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAHNwPIAiABIAQ2AsQCIAFCADcCpAIgACADNgIIIAAgBjYCBCAAQQg2AgAgAigCpAIiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkGkAmoQuyMLIAJBgANqJAALmQ0CCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEIIAIoAhAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAkgCBC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAkEQCACQegAaiAJIAggByAFEL8UIAJBiAFqIQkgASgCECEHIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAkQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAcgDqcgDKdqQQF0IghqLgEAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIaiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAy4BALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgA0ECaiEDIAUgCUEBaiIJRw0ACwsgAkHIAGogAkEcaiIEEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQkgAigCPCEFIAEgAkHwAGoiBikCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAk2AmggAkEIaiADENc7IAIoAgghCUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBikCADcCACABQRhqIAJB+ABqIgcoAgA2AgAgAiAFNgKoASACIAk2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAHIAJB2ABqKAIANgIAIAYgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCjYCfCAAIAEgAxDPHSACQTBqEM8vIAQQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuYDQIKfwN+IwBBsAFrIgIkACABQQxqENs8IQUCQAJAAkAgARCSNiIDBEBBwAAhBiACQRBqIAMQ3DsgAygCFCEKIAMoAgwhByACKAIUIQggAigCECEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgZFDQMLIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCSAIEL8YDAELQcAAIQYgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBkUNAgsgAkIANwIoIAIgBjYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCkUNAiAFIApGDQMgCQRAIAJB6ABqIAkgCCAHIAUQvxQgAkGIAWohCSABKAIQIQcgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogCRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgByAOpyAMp2oiCEECdGooAgAiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAIQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQNBACEJA0AgAygCACIHQf///wNxIQggB0GAgICAeHEhAQJAIAdBgICA/AdxIgRBgICA/AdGBEAgCEENdiABQRB2ciAIQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIARBgICAuARNBEAgBEGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgBEENdiAIQQ12akGAgAFqIAFyaiEBDAILIARBgICAmANJDQEgCEGAgIAEciIHQR4gBEEXdiIIa3YhBCAHQR0gCGsiCHZBAXEEfyAEQQMgCHRBAWsgB3FBAEdqBSAECyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIANBBGohAyAFIAlBAWoiCUcNAAsLIAJByABqIAJBHGoiBBCCFCACQegAaiIDEJcpIAJBOGoiASgCACEJIAIoAjwhBSABIAJB8ABqIgYpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAJNgJoIAJBCGogAxDXOyACKAIIIQlBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQfgAaiIHKAIANgIAIAIgBTYCqAEgAiAJNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgByACQdgAaigCADYCACAGIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAo2AnwgACABIAMQzx0gAkEwahDPLyAEEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALlQ0CCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAIAEQkjYiAwRAQcAAIQYgAkEQaiADENw7IAMoAhQhCiADKAIMIQcgAigCFCEJIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIGRQ0DCyACQgA3AiggAiAGNgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggCRC/GAwBC0HAACEGIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgZFDQILIAJCADcCKCACIAY2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIApFDQIgBSAKRg0DIAgEQCACQegAaiAIIAkgByAFEL8UIAJBiAFqIQcgASgCECEIIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAcQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAggDqcgDKdqIglqLAAAsrwiBUH///8DcSEEIAVBgICAgHhxIQMCQCAFQYCAgPwHcSIBQYCAgPwHRgRAIARBDXYgA0EQdnIgBEEAR0EJdHJBgPgBciEDDAELIANBEHYhAyABQYCAgLgETQRAIAFBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAFBDXYgBEENdmpBgIABaiADcmohAwwCCyABQYCAgJgDSQ0BIARBgICABHIiBUEeIAFBF3YiBGt2IQEgBUEdIARrIgR2QQFxBH8gAUEDIAR0QQFrIAVxQQBHagUgAQsgA3IhAwwBCyADQYD4AXIhAwsgBiAJQQF0aiADOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQlBACEDA0AgAyAJaiwAALK8IgdB////A3EhCCAHQYCAgIB4cSEBAkAgB0GAgID8B3EiBEGAgID8B0YEQCAIQQ12IAFBEHZyIAhBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAhBDXZqQYCAAWogAXJqIQEMAgsgBEGAgICYA0kNASAIQYCAgARyIgdBHiAEQRd2IghrdiEEIAdBHSAIayIIdkEBcQR/IARBAyAIdEEBayAHcUEAR2oFIAQLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgQQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIGKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAGKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgBiACQdAAaikCADcDACACIAIpAkg3A2ggAiAKNgJ8IAAgASADEM8dIAJBMGoQzy8gBBDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC4QRAQl/IwBBoAJrIgYkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgARDzLSIILQAAQRtrDg4DDQAEDQECDQ0NDQ0HCA0LIAZBCGogARC5JiAGQbABaiIHIAYoAggiASAGKAIMKAIMEQAAIAFFDQggBikDsAFC/9nrqtfYi4zxAIUgBikDuAFCgfTho6r41uqLf4WEUEUNCCAHIAgoAghBCGogAUEMaiACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQwgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwPCyABQbjJ/gAQxSIhByAGQRhqIAhBBGoQwzQgBigCGCEBIAYoAhwhCCAGQRBqIAcQ3DsgBkGwAWogASABIAhBAnRqIAYoAhAiASABIAYoAhRBA3RqEMkiIAYoAsQBIgEgBigCwAEiCE0NCyABIAhrIQcgBigCsAEgCEECdGohASAGKAK4ASAIQQN0aiEIDAMLIAFBuMn+ABDGIiEHIAZBIGogCEEEahCwLiAGKAIgIgEgBigCJCIIRg0KDAMLIwBBIGsiByQAIAdBCGogAUHIyf4AKAIAEQAAIAdBEGogBygCCCIBIAcoAgwoAgwRAAACQCABBEAgBykDEEL75PLhsbPtw3yFIAcpAxhCgbfKnrar7cxuhYRQDQELQcj7/gBBIEHo+/4AEMskAAsgB0EgaiQAIAZBsAFqIAgoAgRBCGogAUEMaiACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQkgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwMCyMAQSBrIgckACAHQQhqIAFByMn+ACgCABEAACAHQRBqIAcoAggiASAHKAIMKAIMEQAAAkAgAQRAIAcpAxBC4//bxtnAsr/aAIUgBykDGELrqof3kZGQlSSFhFANAQtByPv+AEEgQej7/gAQyyQACyAHQSBqJAAgBkGwAWogCCgCBEEIaiABQQxqIAIgAyAEIAUQygMgBigCsAEiAUGTgICAeEYNCCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACABNgIADAsLA0ACQCAGQbABaiABKAIAQQhqIAggAiADIAQgBRDKAyAGKAKwASIJQZOAgIB4Rw0AIAFBBGohASAIQQhqIQggB0EBayIHDQEMCQsLIAAgBikCtAE3AgQgAEEMaiAGQbwBaikCADcCACAAIAk2AgAMCgsDQAJAIAcgAS0AABDZKCEJIAZBsAFqIAFBBGooAgBBCGogCSACIAMgBCAFEMoDIAYoArABIglBk4CAgHhHDQAgCCABQQhqIgFHDQEMCAsLIAAgBikCtAE3AgQgAEEMaiAGQbwBaikCADcCACAAIAk2AgAMCQsgAUG4yf4AEMciIQcCQCAIKAIEIgEtADBBIEYEQCAGQThqIAFBNGoiARDDNCAGKAI8QQJGDQEgCCgCBCEBCyAGQQE2ArQBIAZBiMv+ADYCsAEgBkIBNwK8ASAGQa8DNgJoIAYgAUEwajYClAIgBiAGQeQAajYCuAEgBiAGQZQCajYCZCAGQbABakGQy/4AEO8sAAsgBkEwaiABEMM0IAYoAjRFDQIgBigCMCEIIAZBKGogARDDNCAGKAIsIgFBAU0NAyAGKAIoIQEgBkGwAWogCCgCAEEIaiAHEPMvIAIgAyAEIAUQygMgBigCsAEiCEGTgICAeEcEQCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACAINgIADAkLIAZBsAFqIAEoAgRBCGogBxDyLSACIAMgBCAFEMoDIAYoArABIgFBk4CAgHhGDQUgACAGKQK0ATcCBCAAQQxqIAZBvAFqKQIANwIAIAAgATYCAAwICyAGQeQAaiIHIAEQwy0gBkHYAGogBxDvPCAGKAJcQQJHBEAgBkHQAGogBxDvPCAGQTs2ApgCIAZBATYCtAEgBkH0y/4ANgKwASAGQgE3ArwBIAYgBigCVDYCiAIgBiAGQYgCajYClAIgBiAGQZQCajYCuAEgAEEEaiAGQbABahCZDiAAQY2AgIB4NgIADAcLIAZByABqIAZB5ABqEO88IAYoAkwiAUEBSw0DQQEgAUGgy/4AEMMhAAtBkMr+AEErQbzK/gAQyyQAC0EAQQBBzMr+ABDDIQALQQEgAUHcyv4AEMMhDAILIAZB/AFqIAYoAkgiAUHcAGoQxQYgASgCbCEJIAEoAmghCyAGQYgCaiABQcQAahC+FSAGQZQCaiABQdAAahCACyABKAJwIgcEQCAHIAcoAgAiCkEBajYCACAKQQBIDQIgASgChAEhCiABKAKAASEMIAEoAnwhDSABKAJ4IQ4gASgCdCEBCyAGQdABaiAGQYQCaigCADYCACAGQbgBaiAGQZACaigCADYCACAGQcQBaiAGQZwCaigCADYCACAGIAYpAvwBNwPIASAGIAk2AtgBIAYgCzYC1AEgBiAGKQKIAjcDsAEgBiAGKQKUAjcCvAEgBiAKNgLwASAGIAw2AuwBIAYgDTYC6AEgBiAONgLkASAGIAE2AuABIAYgBzYC3AEgBkFAayAGQbABaiIHEKABIAYgBigCRDYCrAEgBiAGKAJAIgE2AqgBIAcgCCgCCEEIaiAGQagBaiIIIAIgAyAEIAUQygMgBigCsAEiAkGTgICAeEcEQCAAIAYpArQBNwIEIABBDGogBkG8AWopAgA3AgAgACACNgIAIAEgASgCACIAQQFrNgIAIABBAUcNAyAIELsjDAMLIAEgASgCACIBQQFrNgIAIAFBAUYEQCAGQagBahC7IwsgBkHkAGoQ/iYLIABBk4CAgHg2AgAMAgsACyAGQeQAahD+JgsgBkGgAmokAAvqDgIVfwN+IwBBgANrIgQkACADLwEOIQoCfwJAAkACQCACKAIAIgJBCGoiDSACKAIIQQJGQQJ0ai0AICICQQAgAkEDRxsiEEEBaw4CAAIBC0EBIREgCkEBaiEKCyADLwEMDAELIApBAWohCiADLwEMQQFqCyEOIARBIGogDRCKJiAEKAIkIQIgBCgCICESAkACQAJAIAMtAAAiCEEgRwRAIAhBKUcNAQwCCyAEQRhqIANBBGoiCxDDNCAEKAIcIAJGDQEgBCACNgJcIARBEGogCxDDNCAEIAQoAhQ2ArgCIARBAjYC1AEgBEHY0s8ANgLQASAEQgI3AtwBIARBOzYCNCAEQTs2AiwgBCAEQShqNgLYASAEIARBuAJqNgIwIAQgBEHcAGo2AiggAEEMaiAEQdABahCZDiAAQYKAgIB4NgIAIABBAzYCCAwCCyAEIAM2ArgCIARBATYC1AEgBEGY088ANgLQASAEQgE3AtwBIARBpwQ2AiwgBCAEQShqNgLYASAEIARBuAJqNgIoIABBDGogBEHQAWoQmQ4gAEGCgICAeDYCACAAQQM2AggMAQsgBEEoaiACEJQXIARB0AFqIgggAkEAQQRBIBCgGCAEKALUASEJAkACQAJAIAQoAtABQQFHBEAgBEEANgJkIAQgBCgC2AE2AmAgBCAJNgJcIAJFDQIgAkECdCETIARBtAFqIQkgCEEEciEMIAhBAXIhD0EAIQIgBEGAAWpBAXIiFEEHaiEVQQAhCANAAkAgAiASaiEGAn8gC0UEQEEpIQVBAAwBCyAEQQhqIAsQwzQCQCAEKAIMIgUgCEsEQCAEKAIIIAJqIgUoAgAiBygCQCAHKAJEIAYoAgAiB0EIaiAHKAIIQQJGQQJ0aiIHKAIMIAcoAhAQwS4NASAEIAYoAgAiAUEIaiABKAIIQQJGQQJ0aikCDDcCdCAEIAUoAgBBPGo2AnwgBEECNgLUASAEQZDSzwA2AtABIARCAjcC3AEgBEGEATYCxAIgBEHMATYCvAIgBCAEQbgCajYC2AEgBCAEQfwAajYCwAIgBCAEQfQAajYCuAIgAEEMaiAEQdABahCZDiAAQYKAgIB4NgIAIABBAzYCCAwICyAIIAVBuNHPABDDIQALIARB0AFqIAUoAgBBMGoQwwYgBCAPKQAANwNoIAQgD0EHaigAADYAbyAELQDQASEFIAQgCxDDNCAIIAQoAgQiB08NASAEKAIAIAJqKAIAQQhqCyEHIBQgBCkDaDcAACAVIAQoAG82AAAgBCAKOwGOASAEIA47AYwBIAQgBToAgAEgBEHQAWogASAGIARBgAFqENIBIAQoAtABIgVBgoCAgHhGBEAgBEGkAWogBEHoAWopAwAiGTcCACAEQZwBaiAEQeABaikDACIaNwIAIAQgBCkD2AEiGzcClAEgAEEYaiAZNwIAIABBEGogGjcCACAAIBs3AgggAEGCgICAeDYCAAwGCyAEQagBaiIWIAxBGGooAgA2AgAgBEGgAWoiFyAMQRBqKQIANwMAIARBmAFqIhggDEEIaikCADcDACAEIAwpAgA3A5ABIAVBgYCAgHhHBEAgCSAEKQOQATcCACAJQQhqIBgpAwA3AgAgCUEQaiAXKQMANwIAIAlBGGogFigCADYCACAEIAU2ArABIARB0AFqIgUgBigCAEEIaiAEQbABaiAHEKsJIARBKGogBRCIKSAEKAJkIgUgBCgCXEYEQCMAQRBrIgYkACAGQQhqIARB3ABqIgcgBygCAEEBQQRBIBC3ESAGKAIIIgdBgYCAgHhHBEAgByAGKAIMQcjRzwAQ/S8ACyAGQRBqJAALIAQoAmAgBUEFdGoiBiAEKQKwATcCACAGQQhqIARBuAFqKQIANwIAIAZBEGogBEHAAWopAgA3AgAgBkEYaiAEQcgBaikCADcCACAEIAVBAWo2AmQLIAhBAWohCCACQQRqIgIgE0cNAQwDCwsgCCAHQaDTzwAQwyEACyAJIAQoAtgBQajRzwAQ/S8ACyAEKAJkRQ0AIARB0AFqIgEgBEEoakEw/AoAACAEQbgCaiABEPEfIARBoAJqIgEgBEHkAGooAgA2AgAgBCAROgC0AiAEIAo7AbICIAQgDjsBsAIgBEEgOgCkAiAEIAQpAlw3A5gCIAQgBCkDuAI3A6gCIARBwAJqEJMnAkAgEEECRgRAIARB4AJqIARBmAJqIA0gDSgCAEECRkECdGoiASgCDCABKAIQENoTDAELIARB+AJqIARBsAJqKQMANwMAIARB8AJqIARBqAJqKQMANwMAIARB6AJqIAEpAwA3AwAgBCAEKQOYAjcD4AILIAAgBCkD4AI3AgAgAEEYaiAEQfgCaikDADcCACAAQRBqIARB8AJqKQMANwIAIABBCGogBEHoAmopAwA3AgAMAgsgAEGBgICAeDYCAAsgBEHcAGoiABC+HyAAQQRBIBDgHiAEQcgAaiIAEMcnIAAQ6TsgBEEoahCTJwsgAy0AAEEpRwRAIAMQnQwLIARBgANqJAAL7Q4CBn8BfiMAQbABayIEJAAgBCADNgIYIAQgAjYCFCAEIARBFGo2AhwCQAJAAkACQCADQQpPBEAgBEH4AGpCADcDACAEQfAAakIANwMAIARB6ABqQgA3AwAgBEIANwNgQSAgAyADQSBPGyEHA0AgBEHgAGoiCCAGaiACIAZqLQAAQTBrIgk6AAAgCUH/AXFBCkkgBnQgBXIhBSAHIAZBAWoiBkcNAAsgBEE4aiAEQfgAaikDADcDACAEQTBqIARB8ABqKQMANwMAIARBKGogBEHoAGopAwA3AwAgBCAEKQNgNwMgIAQgBTYCQCAEQSBqEI0cIgZFBEAgBEESNgJUIARB3MSAATYCUCAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEHQAGo2AqgBIAQgBEEUajYCoAEgBEGIAWogCBCZDiAAIAQpAowBNwIIIABBEGogBEGUAWooAgA2AgAgACAEKAKIATYCBCAAQYSAgIB4NgIADAULIANBCkYEQCAEQgA3AkggBCAGNgJEIARB4ABqIgIgASAEQcQAahCMLCAEQdAAaiACEL4sIAQoAlAEQCAAIAQpAlA3AgQgAEGTgICAeDYCACAAQQxqIARB2ABqKQIANwIADAYLIARBHzYCnAEgBEHuxIABNgKYASAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEGYAWo2AqgBIAQgBEEUajYCoAEgBEGIAWogBEHgAGoQmQ4gBEGEgICAeDYChAEgAEEQaiAEQZQBaigCADYCACAAQQhqIARBjAFqKQIANwIAIAAgBCkChAE3AgAMBQsgBC0AKiIFQSRGIAVBxABGciAFQfABRnJFBEAgBEEbNgKkASAEQdDDgAE2AqABIARBAjYCZCAEQczEgAE2AmAgBEICNwJsIARBzAE2ApABIARBzAE2AogBIAQgBEGEAWo2AmggBCAEQaABajYCjAEgBCAEQRRqNgKEASAAQQRqIARB4ABqEJkOIABBhICAgHg2AgAMBQsgBEHQAGogBEEgahCDBiAEKAJQRQRAIARBEjYCSCAEQY3FgAE2AkQgBEECNgJkIARBzMSAATYCYCAEQgI3AmwgBEHMATYCrAEgBEHMATYCpAEgBCAEQaABajYCaCAEIARBxABqNgKoASAEIARBFGo2AqABIARBiAFqIARB4ABqEJkOIAQpAogBIQogACAEKQKQATcCDCAAIAo3AgQgAEGEgICAeDYCAAwFCyAEKAJcIQUgBCAEKQJUNwJIIAQgBjYCRCADQSFJDQFBICEGIAVBIEcNAQNAIAIgBmotAABBMGtB/wFxQQlLBEAgBiEFDAMLIAMgBkEBaiIGRw0ACwwCCyAEQS02AqQBIARB/MOAATYCoAEgBEECNgJkIARBzMSAATYCYCAEQgI3AmwgBEHMATYCkAEgBEHMATYCiAEgBCAEQYQBajYCaCAEIARBoAFqNgKMASAEIARBFGo2AoQBIARBJGogBEHgAGoQmQ4gBEGEgICAeDYCICAAQRBqIARBMGooAgA2AgAgAEEIaiAEQShqKQIANwIAIAAgBCkCIDcCAAwDCyADIAVLDQELIARB4ABqIgIgASAEQcQAahCMLCAEQdAAaiACEL4sIAQoAlAEQCAAIAQpAlA3AgQgAEGTgICAeDYCACAAQQxqIARB2ABqKQIANwIADAILIARBHzYCnAEgBEHuxIABNgKYASAEQQI2AmQgBEHMxIABNgJgIARCAjcCbCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJoIAQgBEGYAWo2AqgBIAQgBEEUajYCoAEgBEGIAWogBEHgAGoQmQ4gBEGEgICAeDYChAEgAEEQaiAEQZQBaigCADYCACAAQQhqIARBjAFqKQIANwIAIAAgBCkChAE3AgAMAQsCQAJAIAIgBWotAAAiAkH6AEYEQCAFIANBAWtGDQEMAgsgBSADQQFrRyACQdoAR3INAQsgAEEEaiABIARBxABqEPAtIABBk4CAgHg2AgAMAQsgBEEIaiAEKAIUIAQoAhggBRDqJSAEIAQoAgggBCgCDBCvDiAEQeAAaiAEKAIAIAQoAgQQihggBCgCZCECIAQoAmAiA0GTgICAeEcEQCAAIAQpAmg3AgggAEEQaiAEQfAAaigCADYCACAAIAI2AgQgACADNgIADAELIAQgAjYCmAEgBEHgAGoiAiAEQZgBaiAEQcQAahCMLCAEQYQBaiIDIAIQviwgAiADIARBHGoQ3hUgBEGoAWoiAiAEQewAaikCADcDACAEIAQpAmQ3A6ABIAQoAmAiA0GTgICAeEcEQCAAIAQpA6ABNwIEIAAgAzYCACAAQQxqIAIpAwA3AgAMAQsgBEHYAGogAikDADcDACAEIAQpA6ABNwNQIABBBGogASAEQdAAahDwLSAAQZOAgIB4NgIACyAEQbABaiQAC4gOAgp/BH4jAEHAAWsiBCQAAkACfyAAIAGEUARAQSYhAyACQSZqQTA6AAAMAgsCQCABUCAAQoCAhP6m3uERVHFFBEAgBEHwAGogAEIAQu3UifOh8+uFU0IAEKgeIARBgAFqIAFCAELt1InzofPrhVNCABCoHiAEQeAAaiAAQgBC1vDNiPul2dI5QgAQqB4gBEGQAWogAUIAQtbwzYj7pdnSOUIAEKgeIARBoAFqIAAgAUIAQgAQqB4gBEGwAWogBCkDkAEiDSAEKQOIASAEKQOAASIBIAQpA3h8Ig4gAVStfCIPIAQpA2ggBCkDYCIBIA58IAFUrXx8Ig58IgEgBCkDoAF8IhBCM4ggASAQVq0gBCkDqAEgASANVK0gBCkDmAEgDiAPVK18fHx8Ig1CDYaEIgEgDUIziCINQoCA/IHZoZ5uQgAQqB4gAiAEKQOwASAAfCIAIABCkM4AgCIOQpDOAH59pyIDQf//A3FB5ABuIgVBAXQiBkHi84kBai0AADoAIyACIAZB4/OJAWotAAA6ACQgAiADIAVB5ABsa0EBdEH+/wdxIgNB4vOJAWotAAA6ACUgAiADQePziQFqLQAAOgAmIAIgDkKQzgCCpyIDQeQAbiIFQQF0IgZB4/OJAWotAAA6ACAgAiAGQeLziQFqLQAAOgAfIAIgAyAFQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAiIAIgA0Hi84kBai0AADoAISACIABCgMLXL4BCkM4AgqciA0HkAG4iBUEBdCIGQePziQFqLQAAOgAcIAIgBkHi84kBai0AADoAGyACIABCgKCUpY0dgKdBkM4AcCIGQeQAbiIHQQF0IghB4/OJAWotAAA6ABggAiAIQeLziQFqLQAAOgAXIAIgAyAFQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAeIAIgA0Hi84kBai0AADoAHSACIAYgB0HkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAGiACIANB4vOJAWotAAA6ABkgDVAgAUKAgIT+pt7hEVRxRQ0BIAEhAEEXDAILQScMAQsgBEEQaiABQgBC7dSJ86Hz64VTQgAQqB4gBEEgaiANQgBC7dSJ86Hz64VTQgAQqB4gBCABQgBC1vDNiPul2dI5QgAQqB4gBEEwaiANQgBC1vDNiPul2dI5QgAQqB4gBEFAayABIA1CAEIAEKgeIARB0ABqIAQpAzAiDSAEKQMoIAQpAyAiACAEKQMYfCIOIABUrXwiDyAEKQMIIAQpAwAiACAOfCAAVK18fCIOfCIAIAQpA0B8IhBCM4ggACAQVq0gBCkDSCAAIA1UrSAEKQM4IA4gD1StfHx8fCINQg2GhCIAIA1CM4hCgID8gdmhnm5CABCoHiACIAQpA1AgAXwiAUKQzgCAIg1CkM4AgqciA0HkAG4iBUEBdCIGQePziQFqLQAAOgAQIAIgBkHi84kBai0AADoADyACIAFCgMLXL4BCkM4AgqciBkHkAG4iB0EBdCIIQePziQFqLQAAOgAMIAIgCEHi84kBai0AADoACyACIAFCgKCUpY0dgKdBkM4AcCIIQeQAbiIJQQF0IgpB4/OJAWotAAA6AAggAiAKQeLziQFqLQAAOgAHIAIgASANQpDOAH59pyIKQf//A3FB5ABuIgtBAXQiDEHj84kBai0AADoAFCACIAxB4vOJAWotAAA6ABMgAiADIAVB5ABsa0H//wNxQQF0IgNB4/OJAWotAAA6ABIgAiADQeLziQFqLQAAOgARIAIgBiAHQeQAbGtB//8DcUEBdCIDQePziQFqLQAAOgAOIAIgA0Hi84kBai0AADoADSACIAggCUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoACiACIANB4vOJAWotAAA6AAkgAiAKIAtB5ABsa0H//wNxQQF0IgNB4/OJAWotAAA6ABYgAiADQeLziQFqLQAAOgAVQQcLIQMCQCAAQugHVARAIAAhAQwBCyACQQRrIQYDQCADIAZqIgVBAWogACAAQpDOAIAiAUKQzgB+faciB0H//wNxQeQAbiIIQQF0IglB4/OJAWotAAA6AAAgBSAJQeLziQFqLQAAOgAAIAVBA2ogByAIQeQAbGtB//8DcUEBdCIHQePziQFqLQAAOgAAIAVBAmogB0Hi84kBai0AADoAACADQQRrIQMgAEL/rOIEViABIQANAAsLIAFCCVYEQCACIANqQQFrIAGnIgUgBUH//wNxQeQAbiIFQeQAbGtB//8DcUEBdCIGQePziQFqLQAAOgAAIAIgA0ECayIDaiAGQeLziQFqLQAAOgAAIAWtIQELIAFQDQAgAiADQQFrIgNqIAGnQQF0QR5xQePziQFqLQAAOgAACyAEQcABaiQAIAML1BECE38BfiMAQZACayICJAAgAkHUAWogAUEIEN0QIAIoAtwBIQwgAigC2AEhBgJAIAIoAtQBIgRBioCAgHhHBEAgACACKQLgATcCDCAAQRxqIAJB8AFqKQIANwIAIABBFGogAkHoAWopAgA3AgAgACAMNgIIIAAgBjYCBCAAIAQ2AgAMAQsgBkEBcQRAIAJB1AFqIAEoAgAiBiAMEJMOIAIoAtgBIQUCQCACKALUASIEQYqAgIB4RwRAIAJB0AFqIAJB9AFqKAIANgIAIAJByAFqIAJB7AFqKQIANwIAIAJBwAFqIAJB5AFqKQIANwIAIAIgAikC3AE3ArgBIAIgBTYCtAEgAiAENgKwAQwBCyACQdQBaiEEIwBBMGsiAyQAIANBDGogBkF/IAUgDGoiByAFIAdLGyIFEJMOIAMoAhAhBwJAIAMoAgwiCUGKgICAeEcEQCAEIAMpAhQ3AgggBEEgaiADQSxqKAIANgIAIARBGGogA0EkaikCADcCACAEQRBqIANBHGopAgA3AgAgBCAHNgIEIAQgCTYCAAwBC0F/IAVBBGoiCSAFIAlLGyIFQQNxBEAgBCAFNgIcIARBywA2AhggBEG/5P4ANgIUIARBgICAgHg2AhAgBEIENwIIIARChICAgAg3AgAMAQsCQAJAQX8gBUF/IAdBAnQgB0H/////A0sbIglqIgcgBSAHSxsiByAGKAIETQRAIAYgBigCFCAJaiIKNgIUQYiAgIB4IQkgCiAGKAIIKAIISw0BDAILIANBDGogBSAHEL8vIAMoAgwiCUGKgICAeEYNAQsgBCADKQIQNwIEIARBHGogA0EoaikCADcCACAEQRRqIANBIGopAgA3AgAgBEEMaiADQRhqKQIANwIAIAQgCTYCAAwBCyAEIAc2AgggBCAFNgIEIARBioCAgHg2AgALIANBMGokACACKALcASEDIAIoAtgBIQQgAigC1AEiBUGKgICAeEcEQCACQcwBaiACQfABaikCADcCACACQcQBaiACQegBaikCADcCACACIAIpAuABNwK8ASACIAM2ArgBIAIgBDYCtAEgAiAFNgKwAQwBCyADIARrIgVBACADIAVPGyIDQQJ2IANBA3FBAEdqIgMEQCAEQX9zIQlBACADayEUIAJBgAFqIQ4gAkH0AGohDyACQcQBaiEQIAJB6AFqIQogAkHcAGohBSACQdgBaiERIAJBzABqIRIgAkHQAGohByACQdwBaiENA0AgAkHUAWogBiAEEJMOIAIoAtgBIQMCQCACKALUASIIQYqAgIB4RwRAIAcgDSkCADcCACAHQRhqIA1BGGooAgA2AgAgB0EQaiANQRBqKQIANwIAIAdBCGogDUEIaikCADcCACACIAM2AkwgAiAINgJIDAELIAJB1AFqIAYgAyAJIAMgCUkbIARqELQGIAJBmAFqIgMgEUEIaikCADcDACACIBEpAgA3A5ABIAIoAtQBIghBioCAgHhHBEAgBSAKKQIANwIAIAVBCGogCkEIaikCADcCACASQQhqIAMpAwA3AgAgEiACKQOQATcCACACIAg2AkgMAQsgAkGoAWogAykDADcDACACIAIpA5ABNwOgASACQdQBaiACQaABakEEEN0QIAIoAtwBIQMgAigC2AEhCAJAAn4gAigC1AEiC0GKgICAeEcEQCACQYACaiAKQQhqKQIANwMAIAIgCikCADcD+AEgAikC4AEMAQsgCEEBcUUNAQJAIANBB3EEQCACIAM2AvABIAJBAzYC7AEgAkGw5P4ANgLoASACQYCAgIB4NgLkASACQgQ3AtwBIAJChICAgAg3AtQBDAELQX8gA0EIaiIIIAMgCEsbIgsgAigCoAEiCCgCBE0EQCAIIAgoAhRBCGoiCzYCFCAIKAIIKAIIIAtPBEAgAkGKgICAeDYC1AEMAgsgAkGIgICAeDYC1AEMAQsgAkHUAWogAyALEL8vCyACQQU2AogCIAJBw+3+ADYChAIgAkGAgICAeDYCgAIgAiADNgL8ASACQQE2AvgBIAJBsAFqIAJB1AFqIAJB+AFqEIEUIAIoArABIgtBioCAgHhGDQEgAkGAAmogEEEIaikCADcDACACIBApAgA3A/gBIAIoArgBIQMgAigCtAEhCCACKQK8AQshFSAFIAIpA/gBNwIAIAVBCGogAkGAAmopAwA3AgAgAiAVNwJUIAIgAzYCUCACIAg2AkwgAiALNgJIDAELIAIgAikDqAE3AtwBIAIgAikDoAE3AtQBIAJB7ABqIAJB1AFqQe3n/gBBBEEGEK0IIAIoAnAhAyACKAJsIghBioCAgHhHBEAgByAPKQIANwIAIAUgDikCADcCACAHQQhqIA9BCGooAgA2AgAgBUEIaiAOQQhqKQIANwIAIAIgAzYCTCACIAg2AkgMAQsgAyADKAIMQQFrNgIMIAJBioCAgHg2AkgLIAIgBDYC3AEgAiATNgLYASACQQA2AtQBIAJBJGogAkHIAGogAkHUAWoQgRQgAigCJCIDQYqAgIB4RwRAIAJBzAFqIAJBQGspAgA3AgAgAkHEAWogAkE4aikCADcCACACQbwBaiACQTBqKQIANwIAIAIgAikCKDcCtAEgAiADNgKwAQwDCyAEQQRqIQQgCUEEayEJIBQgE0EBaiITag0ACwsgAkGKgICAeDYCsAELIAJBBTYC5AEgAkGf7P4ANgLgASACQYCAgIB4NgLcASACIAw2AtgBIAJBATYC1AEgAEEEaiEGIAIgAkGwAWogAkHUAWoQgRQCQCACKAIAIgRBioCAgHhHBEAgBiACKQIENwIAIAZBGGogAkEcaikCADcCACAGQRBqIAJBFGopAgA3AgAgBkEIaiACQQxqKQIANwIADAELIAYgASkCADcCACAGQQhqIAFBCGopAgA3AgALIAAgBDYCAAwBCyAAQQU2AhggAEGf7P4ANgIUIABBgICAgHg2AhAgAEIENwIIIABCgICAgAg3AgALIAJBkAJqJAALpg4CB38DfiMAQcABayIHJAAgByABOgADAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcQ4IAwAFBQUBAgAFCyAHQagBaiACQQhqKQIANwMAIAcgAikCADcDoAEgB0EwaiAHQaABaiADIAQgBRCZDSAHQRBqIAdB6ABqKQMANwMAIAdBGGogB0HwAGooAgA2AgAgByAHKQNgNwMIIAdB0wBqLQAAIQIgBykDMCEOIAcoAjghCiAHKAI8IQsgBygCQCEEIAcoAkQhAyAHKAJIIQUgBygCTCEBIActAFAhBiAHKAJUIQkgBykDWCEPIAcvAFEgB0EGaiAHQfcAai0AADoAACAHIAcvAHU7AQQgAkEQdHIhAiAHLQB0IQwgBykDeCEQDAULIAdBKGoiAyACQQhqKQIANwMAIAcgAikCADcDICAHQQA2ApgBIAdCgICAgBA3ApABIAdBoAFqIgIgB0GQAWoiARDnFSAHQcgAakIANwMAIAdB0ABqQgA3AwAgB0HsAGpCADcCACAHQfQAakIANwIAIAdB/ABqQgA3AgAgB0FAayAHQagBaikDADcDACAHQQA6AIgBIAdCADcCZCAHQQA2AlggB0IBNwJcIAdBADYCMCAHQQA2AoQBIAcgBykDoAE3AzggASAHQSxqIgogBygCJCADKAIAIAcoAiAoAgARBQAgAiAHQTBqIAEQuAQCQAJAIAcoAqABIgJBCEcEQCAHKAK0ASEJIAcoArABIQggBygCrAEhASAHKAKoASEFIAcoAqQBIQMMAQsgB0GQAWpBACAHKAJoQeiNzQAQsxUgB0GgAWogB0EwaiAHKAKUASILIAcoApgBIgQQ6AkCQCAHKAKgASICQQhHBEAgBygCtAEhCSAHKAKwASEIIAcoAqwBIQEgBygCqAEhBSAHKAKkASEDDAELAkACQAJAIARFBEBBACEBDAELIARBAnQhBUEAIQEgCyECA0AgAigCACIDQQBIDQIgASADaiEBIAJBBGohAiAFQQRrIgUNAAsLIAdBMGoQ3hwgAWogBygCKCIBTQ0EQSohASAHQaABakEqQQBBAUEBEKAYIAcoAqQBIQMgBygCoAFBAUYNDSAHKAKoASIFQfiNzQBBKvwKAAAMAQtBJyEBIAdBoAFqQSdBAEEBQQEQoBggBygCpAEhAyAHKAKgAUEBRg0MIAcoAqgBIgVBoo7NAEEn/AoAAAtBACECCyAHQZABahDpOwsgB0EwahCCLSAKIAcoAiQgBygCKCAHKAIgKAIQEQEADAcLIAcoApABIQogBygCLCEIIAcoAiQhBSAHKAIgIQMgB0EwaiICEN4cIQ0gAhCCLSAKQYCAgIB4Rw0CIAQhAgwGCyAHQZgBaiACQQhqKQIANwMAIAcgAikCADcDkAEgB0EwaiAHQZABahCxBCAHKAIwQQFGBEAgBygCSCIIQQh2IQIgBygCTCEJIAcoAkQhASAHKAJAIQUgBygCPCEDIAcoAjghBAwFCyAHQagBaiIMIAdB5ABqKQIANwMAIAdBsAFqIg0gB0HsAGooAgA2AgAgByAHKQJcNwOgASAHKAJMIghBCHYhAiAHKAJQIQkgBygCSCEBIAcoAkQhBSAHKAJAIQMgBygCPCEEIAcoAjQiCkGAgICAeEYNBCAHKQJUIQ8gBygCOCELIAdBGGogDSgCADYCACAHQRBqIAwpAwA3AwAgByAHKQOgATcDCEIFIQ4gBiEMIAghBgwDCyAFIAMgBEEBcRshASACKAIMIQMgAigCCCEEIAIoAgQhCyACKAIAIQpCAiEOQQAhBQwCCyANrUKAgICAEEIAIAYbhCEPIAhBCHYhAkIEIQ4gCCEGDAELIAdBATYCNCAHQdyMzQA2AjAgB0IBNwI8IAdBrgM2AqQBIAcgB0GgAWo2AjggByAHQQNqNgKgASAAQQxqIAdBMGoQmQ4gAEIGNwMAIABBADYCCCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAMLIAAgAjsAISAAIA83AyggACAJNgIkIAAgBjoAICAAIAE2AhwgACAFNgIYIAAgAzYCFCAAIAQ2AhAgACALNgIMIAAgCjYCCCAAIA43AwAgACAHKQMINwMwIAAgDDoARCAAQSNqIAJBEHY6AAAgAEE4aiAHQRBqKQMANwMAIABBQGsgB0EYaigCADYCACAAIBA3A0ggAEHHAGogB0EGai0AADoAACAAIAcvAQQ7AEUMAgsgACACOwAZIAAgCTYCHCAAIAg6ABggACABNgIUIAAgBTYCECAAIAM2AgwgACAENgIIIABCBjcDACAAQRtqIAJBEHY6AAAMAQsgACAJNgIcIAAgCDYCGCAAIAE2AhQgACAFNgIQIAAgAzYCDCAAIAI2AgggAEIGNwMACyAHQcABaiQADwsgAyAHKAKoAUHU/cwAEP0vAAvQDQEOfyMAQSBrIgckACAAKAIcIgIoAiAiBCACKAJcQQVrIgIgAiAESxshDSAAKAIEIQUgAUH/AXEiC0EERyEOAkADQCAAKAIEIQYgACgCECIEIAAoAhwiAi0AcEEqakH4AXFBA3YiCUkNAQJAQf//AyACKAIQIAIoAjxrIgpBACAKQQBKGyIMIAZqIgMgBCAJayIEIAMgBEkbIgkgCUH//wNPGyIEIA1PDQAgCUUEQCAOIAMgBEdyDQMMAQsgC0UgAyAER3INAgsgAkEAQQAgC0EERiADIARGcSIPEPgMAkACQAJAAkACQAJAAkACQCACKAJkIgNBA0sEQCACIANBBGsiBjYCZAJ/IAYEQCACKAJgDAELIAJBADYCYEEACyEDIAIoAlwiCSADIAZqIgNrQQFNDQEgAyAJSw0CIAIoAlggA2ogBDsAACACIAIoAmRBAmoiAzYCZCACKAJcIgYgAigCYCADaiIDa0EBTQ0DIAMgBksNBCACKAJYIANqIARBf3M7AAAgAiACKAJkQQJqNgJkIAAQ4hggCkEASgRAIAAoAhwiAygCPCIGIAMoAhgiAksNBiAAKAIMIQogBCAMIAQgDEkbIgIEQCAKIAMoAhQgBmogAvwKAAALIAAgAiAKajYCDCAAIAAoAhAgAms2AhAgACAAKAIUIAJqNgIUIAMgAygCPCACajYCPCAEIAJrIQQLIARFDQggACgCBCICRQ0IIAAoAgwhAyAAIAIgBCACIAIgBEsbIgJrNgIEIAAoAhwiBC0AAiEKIAAoAgAhBiACBEAgAyAGIAL8CgAACwJAIApBAWsOAgcACAsgBCAEKAKgASADIAIQ3Qc2AqABDAcLIAdBADYCGCAHQQE2AgwgB0Gk7/wANgIIIAdCBDcCECAHQQhqQYju/AAQ7ywACyAHQQA2AhggB0EBNgIMIAdB0O/8ADYCCCAHQgQ3AhAgB0EIakGY7vwAEO8sAAsgAyAJQZju/AAQrzsACyAHQQA2AhggB0EBNgIMIAdB0O/8ADYCCCAHQgQ3AhAgB0EIakGo7vwAEO8sAAsgAyAGQaju/AAQrzsACyAGIAJBuO78ABCvOwALIAAgACgCMCADIAIQ6Ac2AjALIAAgAiAGajYCACAAIAIgA2o2AgwgACAAKAIIIAJqNgIIIAAgACgCECACazYCECAAIAAoAhQgAmo2AhQLIA9FDQALIAAoAgQhBkEBIQgLIAUgBkcEQAJAIAUgBmsiBCAAKAIcIgIoAiAiA0kEQCAEIAIoAlAgAigCECIFa08EQCACIAUgA2siBTYCECACKAIUIAIoAhgiCyADIAMgCyADayIDIAUgAyAFSRtqQcju/AAQwh4gAi0AOiIDQQJJBEAgAiADQQFqOgA6CyACIAIoAhAiBSACKAKAASIDIAMgBUsbNgKAAQsgAkEUaiAFIAQgBWogACgCACAEaxDSJiACIAIoAhAgBGoiAzYCECACIAIoAiAgAigCgAEiBWsiCyAEIAQgC0sbIAVqNgKAAQwBCyACQQI6ADogAkEUakEAIAMgACgCACADaxDSJiACIAIoAiAiAzYCgAEgAiADNgIQCyACIAM2AjwLAkAgCARAQQMhBAwBCwJAAkACQCABQf8BcSIERQRAIAAoAhwhAgwBCyAAKAIcIQIgBEEERg0AIAZFDQELIAYgAigCUCACKAIQIgRrIgNNDQEgAigCPCIIIAIoAiAiBUgNASACIAQgBWsiBDYCECACIAggBWs2AjwgAigCFCACKAIYIgggBSAFIAggBWsiBSAEIAQgBUsbakHY7vwAEMIeIAItADoiBEEBTQRAIAIgBEEBajoAOgsgAiACKAIQIgQgAigCgAEiBSAEIAVJGzYCgAEgAigCICADaiEDDAELIAIoAhAiBCACKAI8RgRAQQEhBAwCCyACKAJQIARrIQMLAkAgBiADIAMgBksbIgZFBEAgAigCICEDDAELIAAgBCAGEMwTGiAAKAIcIgIgAigCECAGaiIENgIQIAIgAigCICIDIAIoAoABIgVrIgggBiAGIAhLGyAFajYCgAELAkAgBCACKAI8IghrIgYgA0H//wMgAigCXCACLQBwQSpqQfgBcUEDdmsiBCAEQf//A08bIgUgAyAFSRtOBEAgACgCBEUhAwwBC0EAIQQgAUH/AXEiA0EERyAGQQBMcSADRXINAUEBIQMgACgCBA0BCyACIAggBSAGIAUgBkkbIgIgCGogAUH/AXFBBEYgA3EgBSAGT3EiARD4DCAAKAIcIgQgBCgCPCACajYCPCAAEOIYQQJBACABGyEECyAHQSBqJAAgBAu5FgIRfwN+IwBB0AFrIgIkAAJAIAEoAlAiCEUEQCACIAEoAiAgASgCJCgCEBEEABCUKSACKAIAIQEgACACKAIENgIIIAAgATYCBCAAQQg2AgAMAQsgASgCLCEEIAJBKGogAUFAayIOEPwTAkACQCABKAI0IgMEQCACQQA2AkQgAkKAgICAwAA3AjwgBCAIayIFIANuIgggBEEBayIKIANuIgdLDQIgAUEQaiENA0AgASgCNCIDRQ0CIAIgAyAIbCIEIANuNgJIAkAgAyAEakEBayIDIAogAyAKSRsiCSAEIAUgBCAFSxsiBkkNACACQcwAaiIDIAJBKGogBiAFayAJIAZrQQFqIg8QpRogAxDnOkUEQCACKAJMIgQgBCgCACIEQQFrNgIAIARBAUcNASADEPseDAELIAJB8ABqIAJB3ABqKAIANgIAIAJB6ABqIAJB1ABqKQIANwMAIAIgAikCTDcDYCACQQA2AnQCQAJAIAEoAgxFDQAgDSACQcgAahDrDCETIAEoAgAiCUEMayEQIAEoAgQiCyATp3EhAyATQhmIQv8Ag0KBgoSIkKDAgAF+IRVBACEMIAIoAkghEQNAIAMgCWopAAAiFCAVhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCARIBAgE3qnQQN2IANqIAtxQXRsIhJqKAIARg0EIBNCAX0gE4MiE1BFDQALCyAUIBRCAYaDQoCBgoSIkKDAgH+DUEUNASADIAxBCGoiDGogC3EhAwwACwALQdTWzQBBwwBBmNfNABDLJAALIAJBIGogCSASaiIDQQhrKAIAIANBBGsoAgAiAygCCEEBa0F4cWpBCGogBiAEayAPIAMoAiARBQAgAiACKQMgNwKMASACQZQBaiACQYwBaiIGQbTIzQAgAkHgAGoQwhAgAigCnAEhBCACKAKYASEDIAIoApQBIglBk4CAgHhHBEAgAiACKQKgATcCtAEgAiAENgKwASACIAM2AqwBIAIgCTYCqAEgACACQagBahCmJSACKAKMASIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgAkHgAGoQzSYgAkE8aiIAEMMnIAAQ6jsgAigCKCIAIAAoAgAiAEEBazYCACAAQQFHDQYgAkEoahD7HgwGCyACKAJEIgYgAigCPEYEQCACQTxqQajXzQAQmygLIAIoAkAgBkEDdGoiCSAENgIEIAkgAzYCACACIAZBAWo2AkQgAigCjAEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBjAFqELsjCyACQeAAahDNJgsgByAITQ0DIAggByAIS2oiCCAHTQ0ACwwCC0HE1s0AEOIrAAtBpNbNABDiKwALAkACQAJAAkBBAEHAABDRNARAIA4Qzy8gAUEANgJQIAFCwAA3A0ggAULAADcDQCABKAI0IgRFDQEgAiABKAIsIARuNgJMIAEoAgwiAwRAIAEoAgAiCEEIaiEFIAgpAwBCf4VCgIGChIiQoMCAf4MhEyACQcwAaigCACEJA0AgE1AEQANAIAhB4ABrIQggBSkDACAFQQhqIQVCgIGChIiQoMCAf4MiE0KAgYKEiJCgwIB/UQ0ACyATQoCBgoSIkKDAgH+FIRMLIAkgCCATeqdBA3ZBdGxqIgRBDGsoAgBLBEAjAEEQayIHJAAgByAENgIMQYABIQYgASgCACIKIAogB0EMaigCAGtBDG0iC2oiDCkAACIUIBRCAYaDQoCBgoSIkKDAgH+DeqdBA3YgCiABKAIEIAtBCGtxaiIKKQAAIhQgFEIBhoNCgIGChIiQoMCAf4N5p0EDdmpBB00EQCABIAEoAghBAWo2AghB/wEhBgsgDCAGOgAAIApBCGogBjoAACABIAEoAgxBAWs2AgwgBEEIayIEKAIAIgYgBigCACIGQQFrNgIAIAZBAUYEQCAEELsjCyAHQRBqJAALIBNCAX0gE4MhEyADQQFrIgMNAAsLAkAgAS0AVEUNACABKAI0IgRFDQMgASgCLCAEbiIEQQJJDQAgAkEYaiABKAI8QQhqEKghIARBAWshDCACKAIcIgZBCGohBCABKAIoIQ5BACEIA0AgAiAONgKUASACIAg2ApgBIwBBEGsiAyQAIARBEGogAkGUAWoiBRDnCyETIwBBEGsiCiQAIAQoAgAiCUEQayENIAQoAgQiCyATp3EhByATQhmIQv8Ag0KBgoSIkKDAgAF+IRUgBSgCBCEPIAUoAgAhEEEAIQUCQAJAA0ACQCAHIAlqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgDSATeqdBA3YgB2ogC3EiEUEEdGsiEigCACAQRgRAIA8gEigCBEYNAwsgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0CIAcgBUEIaiIFaiALcSEHDAELCyAKIAlBACARa0EEdGoiCTYCDEGAASEFIAQoAgAiByAHIApBDGooAgBrQQR1IgtqIg0pAAAiEyATQgGGg0KAgYKEiJCgwIB/g3qnQQN2IAcgBCgCBCALQQhrcWoiBykAACITIBNCAYaDQoCBgoSIkKDAgH+DeadBA3ZqQQdNBEAgBCAEKAIIQQFqNgIIQf8BIQULIA0gBToAACAHQQhqIAU6AAAgBCAEKAIMQQFrNgIMIAMgCUEQayIFKQIANwIAIANBCGogBUEIaikCADcCAAwBCyADQQA2AggLIApBEGokACACQRBqIAMpAgg3AwAgA0EQaiQAAkAgAigCECIDRQ0AIAIoAhQhBSACIAM2AmAgAiAFNgJkIAJB4ABqIgUQvCshByAGIAYoAjAgB2s2AjAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAUQuyMLIAhBAWoiCCAMSQ0ACyAGQQA6AAALAkACQAJAIAIoAkQiAw4CAQACCyAAQQg2AgAgAiACKAI8NgJoIAIgAigCQCIBNgJgIAIgAUEIaiIENgJsIAIgBDYCZCAAIAEpAgA3AgQgAkHgAGoQshwMBgsgAkEIaiABKAIgIAEoAiQoAhARBAAQlCkgAigCCCEBIAAgAigCDDYCCCAAIAE2AgQgAEEINgIADAQLIAJBlAFqIQggAigCQCEEIwBBIGsiASQAIAFBFGogBCADQQN0aiIFIARrQQN2QQBBBEEIEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQZCyzQAQ/S8ACyABQRBqIgZBADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiAyQAIAFBCGoiByAFIARrQQN2EOotIAMgBykCBEIgiTcCCCADIAdBCGo2AgQgBCAFIANBBGoQ3xsgA0EQaiQAIAhBCGogBigCADYCACAIIAEpAgg3AgAgAUEgaiQAIAJB4ABqIAIoApgBIAIoApwBEJ0BIAIoAmghASACKAJkIQQgAigCYCIDQZOAgIB4RwRAIAIgAikCbDcCyAEgAiABNgLEASACIAQ2AsABIAIgAzYCvAEgACACQbwBahCmJSAIEOo7IAJBPGoiABDDJyAAEOo7IAIoAigiACAAKAIAIgBBAWs2AgAgAEEBRw0GIAJBKGoQ+x4MBgsgACABNgIIIAAgBDYCBCAAQQg2AgAgAkGUAWoQ6jsMAwtBtKzNAEEpIAJB4ABqQZizzQBB4KzNABDVHgALQaTWzQAQ4isAC0Gk1s0AEOIrAAsgAkE8aiIAEMMnIAAQ6jsLIAIoAigiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBKGoQ+x4LIAJB0AFqJAALvQwCE34IfyMAQeAAayIXJAACQAJ/AkACQAJAAkACQAJAAkAgASkDACIDUEUEQCABKQMIIgVQDQEgASkDECIEUA0CIAMgBHwiBCADVA0DIAMgBVQNBCAEQoCAgICAgICAIFoNBSAXIAEvARgiATsBOCAXIAMgBX0iBjcDMCAXIAYgBHkiBYYiCiAFiCIHNwNAIAYgB1INCSAXIAE7ATggFyADNwMwIBcgAyAFQj+DIgaGIgcgBogiBjcDQCADIAZSDQlBoH8gASAFp2siGGvBQdAAbEGwpwVqQc4QbSIBQdEATw0GIBdBIGogAUEEdCIBQdDciQFqKQMAIgNCACAEIAWGQgAQqB4gF0EQaiADQgAgCkIAEKgeIBcgA0IAIAdCABCoHkIBQQAgGCABQdjciQFqLwEAamtBP3GtIgmGIgdCAX0hCyAXKQMQQj+HIQ8gFykDAEI/iCEQIBcpAwghESABQdrciQFqLwEAIQEgFykDGCESIBcpAygiFCAXKQMgQj+IIhV8Ig1CAXwiCCAJiKciGEGQzgBPBEAgGEHAhD1JDQggGEGAwtcvTwRAQQhBCSAYQYCU69wDSSIWGyEZQYDC1y9BgJTr3AMgFhsMCgtBBkEHIBhBgK3iBEkiFhshGUHAhD1BgK3iBCAWGwwJCyAYQeQATwRAQQJBAyAYQegHSSIWGyEZQeQAQegHIBYbDAkLQQpBASAYQQlLIhkbDAgLQajYiQFBHEHw5okBEJ8pAAtB1NiJAUEdQYDniQEQnykAC0GE2YkBQRxBkOeJARCfKQALQejaiQFBNkGw6IkBEJ8pAAtBoNqJAUE3QaDoiQEQnykAC0Gw54kBQS1B4OeJARCfKQALIAFB0QBB4OaJARDDIQALQQRBBSAYQaCNBkkiFhshGUGQzgBBoI0GIBYbCyEWIAggC4MhBCAQIBF8IQwgGSABa0EBaiEbIA8gEn0gCHxCAXwiDiALgyEFQQAhAQJAAkACQAJAAkACQAJAAkACQANAIBggFm4hGiABQRFGDQIgASACaiIdIBpBMGoiHDoAAAJAIBggFiAabGsiGK0gCYYiEyAEfCIDIA5aBEAgASAZRw0BIAFBAWohAUIBIQMDQCAFIQogAyEGIAFBEU8NBiABIAJqIARCCn4iBCAJiKdBMGoiFjoAACABQQFqIQEgA0IKfiEDIAVCCn4iBSAEIAuDIgRYDQALIAUgBH0iDiAHVCEYIAMgCCAMfX4iCCADfCEJIAQgCCADfSILWg0IIAcgDlgNAwwICyAOIAN9IgUgFq0gCYYiBlQhFiAIIAx9IgdCAXwhCiAFIAZUIAMgB0IBfSIJWnINBSANIAx9IAQgE3wiBX0hCCANIA98IBJ9IAUgBnx9QgJ8IQwgBCAQfCARfCAVfSAUfSATfCEHQgAhBANAIAMgBnwiBSAJVCAEIAh8IAYgB3xackUEQEEAIRYMBwsgHSAcQQFrIhw6AAAgBCAMfCILIAZUIRYgBSAJWg0HIAYgB3whByAEIAZ9IQQgBSEDIAYgC1gNAAsMBgsgAUEBaiEBIBZBCkkgFkEKbiEWRQ0AC0Hw54kBEOIrAAsgASACakEBayEZIAcgDEIKfiANQgp+fSAGfnwhDEIAIAR9IQggCkIKfiAHfSEKA0AgBCAHfCIDIAtUIAggC3wgBCAMfFpyRQRAQQAhGAwGCyAZIBZBAWsiFjoAACAIIAp8Ig0gB1QhGCADIAtaDQYgCCAHfSEIIAMhBCAHIA1YDQALDAULQRFBEUGA6IkBEMMhAAsgAUERQZDoiQEQwyEACyADIQULAkAgBSAKWiAWcg0AIAogBSAGfCIDWCAKIAV9IAMgCn1UcQ0AIABBADYCAAwECyAFIA5CBH1YIAVCAlpxRQRAIABBADYCAAwECyAAIBs7AQggACABQQFqNgIEDAILIAQhAwsCQCADIAlaIBhyDQAgCSADIAd8IgRYIAkgA30gBCAJfVRxDQAgAEEANgIADAILIAMgBSAGQlh+fFggAyAGQhR+WnFFBEAgAEEANgIADAILIAAgGzsBCCAAIAE2AgQLIAAgAjYCAAsgF0HgAGokAA8LIBdBADYCSCAXQUBrIBdBMGogF0HIAGpB/NaJARCuKwAL4gwCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQYgAigCFCELIAIoAhAhCiAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBiAFIAZqIAogCxC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEAgAwRAIANBwAAQrTYiB0UNBQsgAkEANgJAIAIgBzYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAdBACAE/AsACyACKAJAIQggAigCOCEHCyACIAQ2AjwgAiAFIAhqNgJAIAlFDQIgBSAJRg0DIAoEQCACQegAaiAKIAsgBiAFEL8UIAJBiAFqIQUgASgCECEIIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAggDqcgDKdqIgZBA3RqKQMAtbwiAUH///8DcSEDAkAgAUGAgID8B3EiBEGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhBAwBCyAEQYCAgLgESwRAQYD4ASEEDAELIAFBgICAxANPBEAgBEENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohBAwBCyABQYCAgJgDSQRAQQAhBAwBCyADQYCAgARyIgNBHiABQRd2IgFrdiEEIANBHSABayIBdkEBcUUNACAEQQMgAXRBAWsgA3FBAEdqIQQLIAcgBkEBdGogBDsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhCANAIAQpAwC1vCIBQf///wNxIQMCQCABQYCAgPwHcSIGQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEDDAELIAZBgICAuARLBEBBgPgBIQMMAQsgAUGAgIDEA08EQCAGQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEDDAELIAFBgICAmANJBEBBACEDDAELIANBgICABHIiBkEeIAFBF3YiAWt2IQMgBkEdIAFrIgF2QQFxRQ0AIANBAyABdEEBayAGcUEAR2ohAwsgByADOwEAIAdBAmohByAEQQhqIQQgBSAIQQFqIghHDQALCyACQcgAaiACQRxqIgcQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhCCACKAI8IQQgASACQfAAaiIFKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgCDYCaCACQQhqIAMQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogAkH4AGoiBigCADYCACACIAQ2AqgBIAIgCDYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAYgAkHYAGooAgA2AgAgBSACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEM8dIAJBMGoQzy8gBxDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC+IMAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEGIAIoAhQhCyACKAIQIQogBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAYgBSAGaiAKIAsQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQMCQAJAAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAIAMEQCADQcAAEK02IgdFDQULIAJBADYCQCACIAc2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAHQQAgBPwLAAsgAigCQCEIIAIoAjghBwsgAiAENgI8IAIgBSAIajYCQCAJRQ0CIAUgCUYNAyAKBEAgAkHoAGogCiALIAYgBRC/FCACQYgBaiEFIAEoAhAhCCACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAIIA6nIAynaiIGQQJ0aigCALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQQMAQsgBEGAgIC4BEsEQEGA+AEhBAwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQQMAQsgAUGAgICYA0kEQEEAIQQMAQsgA0GAgIAEciIDQR4gAUEXdiIBa3YhBCADQR0gAWsiAXZBAXFFDQAgBEEDIAF0QQFrIANxQQBHaiEECyAHIAZBAXRqIAQ7AQAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQgDQCAEKAIAs7wiAUH///8DcSEDAkAgAUGAgID8B3EiBkGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIAFBgICAxANPBEAgBkENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohAwwBCyABQYCAgJgDSQRAQQAhAwwBCyADQYCAgARyIgZBHiABQRd2IgFrdiEDIAZBHSABayIBdkEBcUUNACADQQMgAXRBAWsgBnFBAEdqIQMLIAcgAzsBACAHQQJqIQcgBEEEaiEEIAUgCEEBaiIIRw0ACwsgAkHIAGogAkEcaiIHEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQggAigCPCEEIAEgAkHwAGoiBSkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAg2AmggAkEIaiADENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBSkCADcCACABQRhqIAJB+ABqIgYoAgA2AgAgAiAENgKoASACIAg2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAGIAJB2ABqKAIANgIAIAUgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDPHSACQTBqEM8vIAcQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvKDgIGfwF+IwBBsAFrIgQkACAEIAM2AhggBCACNgIUIAQgBEEUajYCHAJAAkACQAJAIANBCk8EQCAEQYABakIANwMAIARB+ABqQgA3AwAgBEHwAGpCADcDACAEQgA3A2hBICADIANBIE8bIQcDQCAEQegAaiIIIAZqIAIgBmotAABBMGsiCToAACAJQf8BcUEKSSAGdCAFciEFIAcgBkEBaiIGRw0ACyAEQThqIARBgAFqKQMANwMAIARBMGogBEH4AGopAwA3AwAgBEEoaiAEQfAAaikDADcDACAEIAQpA2g3AyAgBCAFNgJAIARBIGoQjRwiBkUEQCAEQRI2AlwgBEHcxIABNgJYIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQdgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAIEJkOIAAgBCkClAE3AgggAEEQaiAEQZwBaigCADYCACAAIAQoApABNgIEIABBhICAgHg2AgAMBQsgA0EKRgRAIARCADcCXCAEIAY2AlggBEHoAGogBEHYAGoQ7RcCQCAEKAJoDQAgBCgCbCIBRQ0AIAAgBCkCcDcCCCAAIAE2AgQgAEGTgICAeDYCAAwGCyAEQR82AkwgBEHuxIABNgJIIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQcgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAEQegAahCZDiAEQYSAgIB4NgKMASAAQRBqIARBnAFqKAIANgIAIABBCGogBEGUAWopAgA3AgAgACAEKQKMATcCAAwFCyAELQAqIgVBJEYgBUHEAEZyIAVB8AFGckUEQCAEQRs2AqQBIARB0MOAATYCoAEgBEECNgJsIARBzMSAATYCaCAEQgI3AnQgBEHMATYCmAEgBEHMATYCkAEgBCAEQYwBajYCcCAEIARBoAFqNgKUASAEIARBFGo2AowBIABBBGogBEHoAGoQmQ4gAEGEgICAeDYCAAwFCyAEQdgAaiAEQSBqEIMGIAQoAlhFBEAgBEESNgJMIARBjcWAATYCSCAEQQI2AmwgBEHMxIABNgJoIARCAjcCdCAEQcwBNgKsASAEQcwBNgKkASAEIARBoAFqNgJwIAQgBEHIAGo2AqgBIAQgBEEUajYCoAEgBEGQAWogBEHoAGoQmQ4gBCkCkAEhCiAAIAQpApgBNwIMIAAgCjcCBCAAQYSAgIB4NgIADAULIAQoAmQhBSAEIAQpAlw3AkwgBCAGNgJIIANBIUkNAUEgIQYgBUEgRw0BA0AgAiAGai0AAEEwa0H/AXFBCUsEQCAGIQUMAwsgAyAGQQFqIgZHDQALDAILIARBLTYCpAEgBEH8w4ABNgKgASAEQQI2AmwgBEHMxIABNgJoIARCAjcCdCAEQcwBNgKYASAEQcwBNgKQASAEIARBjAFqNgJwIAQgBEGgAWo2ApQBIAQgBEEUajYCjAEgBEEkaiAEQegAahCZDiAEQYSAgIB4NgIgIABBEGogBEEwaigCADYCACAAQQhqIARBKGopAgA3AgAgACAEKQIgNwIADAMLIAMgBUsNAQsgBEHoAGogBEHIAGoQ7RcCQCAEKAJoDQAgBCgCbCIBRQ0AIAAgBCkCcDcCCCAAIAE2AgQgAEGTgICAeDYCAAwCCyAEQR82AlwgBEHuxIABNgJYIARBAjYCbCAEQczEgAE2AmggBEICNwJ0IARBzAE2AqwBIARBzAE2AqQBIAQgBEGgAWo2AnAgBCAEQdgAajYCqAEgBCAEQRRqNgKgASAEQZABaiAEQegAahCZDiAEQYSAgIB4NgKMASAAQRBqIARBnAFqKAIANgIAIABBCGogBEGUAWopAgA3AgAgACAEKQKMATcCAAwBCwJAAkAgAiAFai0AACICQfoARgRAIAUgA0EBa0YNAQwCCyAFIANBAWtHIAJB2gBHcg0BCyAAQQRqIARByABqEMovIABBk4CAgHg2AgAMAQsgBEEIaiAEKAIUIAQoAhggBRDqJSAEIAQoAgggBCgCDBCvDiAEQegAaiAEKAIAIAQoAgQQihggBCgCbCECIAQoAmgiA0GTgICAeEcEQCAAIAQpAnA3AgggAEEQaiAEQfgAaigCADYCACAAIAI2AgQgACADNgIADAELIAQgAjYCVCAEQegAaiICIARB1ABqIARByABqEIwsIARBjAFqIgMgAhC+LCACIAMgBEEcahDeFSAEQagBaiICIARB9ABqKQIANwMAIAQgBCkCbDcDoAEgBCgCaCIDQZOAgIB4RwRAIAAgBCkDoAE3AgQgACADNgIAIABBDGogAikDADcCAAwBCyAEQeAAaiACKQMANwMAIAQgBCkDoAE3A1ggAEEEaiAEQdgAahDKLyAAQZOAgIB4NgIACyAEQbABaiQAC/INAQl/IwBB0AFrIgUkACAFQcwAahCGICAFQQA2ApABIAVCgICAgBA3AogBIAVBADYCnAEgBUKAgICAEDcClAEgBUEANgKoASAFQoCAgIAQNwKgAQJAAkACQAJAAkACQAJAIAMtAAAiCkUEQEECIQYMAQsgAy0AASEGIAUgBSgCfCILNgK8ASAFIAVBzABqIgk2ArgBIAVBAToAhAEgBUG4AWoiBxC7ESAHIAYQhxEgCSALENgHIQsgBUEANgJgIAVBADoAhAEgByAGEOIbQQIhBgJAIAUoArgBIgdB7f///wdqDgIAAQILIAUtALwBIQYLIAVBuAFqIAIgBUGUAWogBUGgAWogBUGIAWpCACACKAIkIgcgAigCQEEAIAIoAiwbIAYgAxCYASAFKAK4AUEBRgRAIAUoArwBIQIgBSkDwAEhASAAIAUpA8gBNwIQIAAgATcCCCAAIAI2AgQMAgsgBUEANgK0ASAFQoCAgICAATcCrAEgBUGsAWogAhCpGCAFKAKoASICIAMtAAZBAWtB/wFxIgZqIAZBf3NxIAJrIgJBwQBPDQIgBUGgAWpB/Mz+ACACEKE2IAVBzABqIgIgBSgCmAEgBSgCnAEQ1RAhCSACIAUoAowBIAUoApABENUQIQwgBSgCtAEiBgRAIAIgBSgCsAEgBhCyDSEICyAFQQE6AIQBIAUgBSgCfCINNgK8ASAFIAVBzABqIgI2ArgBIAJBBCAHrRDLDiAFQbgBaiICIAwQ8Q4gAiAJEPAOIAoEQCACIAsQ8g4LIAYEQCAFQbgBaiAIEPMOCyAFQfwAaiECIAVBzABqIggiByANENgHIQogBUEBOgCEASAFQQA2AmAgBSgCfCELIAdBBCABEMsOIAVBBCAFKAKAASIGIAZBBE0bNgKAAQJAQQAgBSgCfCIJa0EDcSIGIAcoAgggCWtNDQAgCCgCCCAFKAJ8ayAGTw0AA0AgBUHMAGoiBxD7FiAHKAIIIAUoAnxrIAZJDQALCyACIAYQjTcgBUHMAGooAgggBSgCfGtBA0siCCAIckUEQANAIAVBzABqIgYQ+xYgBigCCCAFKAJ8a0EESQ0ACwsgAkEEEI03IAVBQGsgBUHMAGoQ3DsgBSgCRCEGIAUoAkAhByAFQThqIAUoAnwQjDcgBUEwaiAHIAYgBSgCOCAFKAI8QazH/gAQ1yYgBSgCNCIGQQNNDQUgBSgCMCAGIAprNgAAIAVB2ABqIQYgBSgCfCEKIAUoAmAiByAFKAJYRgRAIAZBxMb+ABCbKAsgBSgCXCAHQQN0aiIJQQY7AQQgCSAKNgIAIAUgB0EBajYCYAJAIARFBEAgBS0AhgFBAUcNAQsgBUEBIAUoAoABIgcgB0EBTRs2AoABIAVBzABqKAIIGiACQQAQjTcgBUHMAGooAgggBSgCfEciCCAIckUEQANAIAVBzABqIgcQ+xYgBygCCCAFKAJ8Rg0ACwsgAkEBEI03IAVBKGogBUHMAGoQ3DsgBSgCLCECIAUoAighByAFQSBqIAUoAnwQjDcgBUEYaiAHIAIgBSgCICAFKAIkQazH/gAQ1yYgBSgCHEUNBiAFKAIYIAQ6AAAgBSgCfCEEIAUoAmAiAiAFKAJYRgRAIAZBxMb+ABCbKAsgBSgCXCACQQN0aiIGQQg7AQQgBiAENgIAIAUgAkEBajYCYAsgBUHMAGoiAiALENgHIQYgBUEANgJgIAVBAToAhAEgBSAFKAJ8Igc2ArwBIAUgAjYCuAEgBUG4AWoiBCADLwECEMQOIARBAhCfEiACQQogBTUCqAEQyw4gBCAGEPAOIAIgBxDYByEDIAVBADYCYCAFQQA6AIQBIAIgAxCkDCAFQRBqIAIQ3DsgBSgCFCECIAUoAhAhAyAFQQhqIAUoAnwQjDcgBSADIAIgBSgCCCAFKAIMQeTG/gAQ1yYgBSgCACEGIAQgBSgCBCICQQBBAUEBEKAYIAUoArwBIQMgBSgCuAFBAUYNAyAFKALAASEEIAIEQCAEIAYgAvwKAAALIAAgAjYCCCAAIAQ2AgQgACADNgIAIABBFGogBUGoAWooAgA2AgAgACAFKQKgATcCDCAFQawBahDjPAwECyAAIAUpAL0BNwAJIABBEGogBUHEAWopAAA3AAAgACAFLQC8AToACCAAIAc2AgQLIABBgICAgHg2AgAgBUGgAWoQ3jsMAgsgAkHAAEHczf4AELA7AAsgAyAFKALAAUGoyf4AEP0vAAsgBUGUAWpBAUEQEOAeIAVBiAFqQQFBEBDgHiAFQcwAahDMKiAFQdABaiQADwsgBUEANgLIASAFQQE2ArwBIAVB9Mj+ADYCuAEgBUIENwLAASAFQbgBakG8x/4AEO8sAAvfDAIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhBiACKAIUIQsgAigCECEKIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAGIAUgBmogCiALEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEDAkACQAJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQCADBEAgA0HAABCtNiIHRQ0FCyACQQA2AkAgAiAHNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgB0EAIAT8CwALIAIoAkAhCCACKAI4IQcLIAIgBDYCPCACIAUgCGo2AkAgCUUNAiAFIAlGDQMgCgRAIAJB6ABqIAogCyAGIAUQvxQgAkGIAWohBSABKAIQIQggAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgCCAOpyAMp2pBAXQiBmovAQCzvCIBQf///wNxIQMCQCABQYCAgPwHcSIEQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEEDAELIARBgICAuARLBEBBgPgBIQQMAQsgAUGAgIDEA08EQCAEQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEEDAELIAFBgICAmANJBEBBACEEDAELIANBgICABHIiA0EeIAFBF3YiAWt2IQQgA0EdIAFrIgF2QQFxRQ0AIARBAyABdEEBayADcUEAR2ohBAsgBiAHaiAEOwEADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEIA0AgBC8BALO8IgFB////A3EhAwJAIAFBgICA/AdxIgZBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQMMAQsgBkGAgIC4BEsEQEGA+AEhAwwBCyABQYCAgMQDTwRAIAZBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQMMAQsgAUGAgICYA0kEQEEAIQMMAQsgA0GAgIAEciIGQR4gAUEXdiIBa3YhAyAGQR0gAWsiAXZBAXFFDQAgA0EDIAF0QQFrIAZxQQBHaiEDCyAHIAM7AQAgB0ECaiEHIARBAmohBCAFIAhBAWoiCEcNAAsLIAJByABqIAJBHGoiBxCCFCACQegAaiIDEJcpIAJBOGoiASgCACEIIAIoAjwhBCABIAJB8ABqIgUpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAINgJoIAJBCGogAxDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQfgAaiIGKAIANgIAIAIgBDYCqAEgAiAINgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgBiACQdgAaigCADYCACAFIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQzx0gAkEwahDPLyAHEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL2wwCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQYgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBiAFIAZqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQF0IgQhAwJAAkACQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEAgAwRAIANBwAAQrTYiB0UNBQsgAkEANgJAIAIgBzYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAdBACAE/AsACyACKAJAIQsgAigCOCEHCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogBiAFEL8UIAJBiAFqIQUgASgCECEGIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIghqLQAAs7wiAUH///8DcSEDAkAgAUGAgID8B3EiBEGAgID8B0YEQCADQQBHQQl0IANBDXZyQYD4AXIhBAwBCyAEQYCAgLgESwRAQYD4ASEEDAELIAFBgICAxANPBEAgBEENdiADQQ12aiABQQx2IAFB/98AcUEAR3FqQYCAAWohBAwBCyABQYCAgJgDSQRAQQAhBAwBCyADQYCAgARyIgNBHiABQRd2IgFrdiEEIANBHSABayIBdkEBcUUNACAEQQMgAXRBAWsgA3FBAEdqIQQLIAcgCEEBdGogBDsBAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEIQQAhBANAIAQgCGotAACzvCIBQf///wNxIQMCQCABQYCAgPwHcSIGQYCAgPwHRgRAIANBAEdBCXQgA0ENdnJBgPgBciEDDAELIAZBgICAuARLBEBBgPgBIQMMAQsgAUGAgIDEA08EQCAGQQ12IANBDXZqIAFBDHYgAUH/3wBxQQBHcWpBgIABaiEDDAELIAFBgICAmANJBEBBACEDDAELIANBgICABHIiBkEeIAFBF3YiAWt2IQMgBkEdIAFrIgF2QQFxRQ0AIANBAyABdEEBayAGcUEAR2ohAwsgByADOwEAIAdBAmohByAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBxCCFCACQegAaiIDEJcpIAJBOGoiASgCACEGIAIoAjwhBCABIAJB8ABqIgUpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAGNgJoIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ4RkgCCACQdgAaigCADYCACAFIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQzx0gAkEwahDPLyAHEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1gwCCn8DfiMAQbABayICJAAgAUEMahDZPCEGAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAGQQN2IAZBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAGIAdqIAggChC/GAwBC0HAACEEIAZBA3YgBkEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAGEN4QCyAGQQN0IgUhBAJAIAVBOHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAENgI0IAJBwAA2AjAgBQRAIAUEQCADQQAgBfwLAAsgAigCQCELIAIoAjghAwsgAiAFNgI8IAIgBiALajYCQCAJRQ0FIAYgCUYNBiAIBEAgAkHoAGogCCAKIAcgBhC/FCACQYgBaiEGIAEoAhAhBSACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAGELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAFIA6nIAynaiIEQQF0ai8BACIBrSEMIAMgBEEDdGoCfiAMQjCGIAFB//8BcUUNABogAUH/B3EhBCAMQv8HgyEOIAxCgIACgyEMIAFBgPgBcSIBQYD4AUYEQCAMQjCGIgxCgICAgICAgPj/AIQgBEUNARogDCAOQiqGhEKAgICAgICA/P8AhAwBCyAMQjCGIgwgAUEKdkHwB2qtQjSGIA5CKoaEhCABDQAaIA4gBGciAUEQa0H//wNxQSVqrYZC/////////weDQYYIIAFrrUI0hoQgDIQLNwMADAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBkUNACABKAIQIQRBACEBA0AgAwJ+IAQvAQAiBa0iDUIwhiAFQf//AXFFDQAaIAVB/wdxIQcgDUL/B4MhDCANQoCAAoMhDSAFQYD4AXEiBUGA+AFGBEAgDUIwhiINQoCAgICAgID4/wCEIAdFDQEaIA0gDEIqhoRCgICAgICAgPz/AIQMAQsgDUIwhiINIAVBCnZB8AdqrUI0hiAMQiqGhIQgBQ0AGiAMIAdnIgVBEGtB//8DcUElaq2GQv////////8Hg0GGCCAFa61CNIaEIA2ECzcDACADQQhqIQMgBEECaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGogAkEcaiIFEIIUIAJB6ABqIgQQlykgAkE4aiIBKAIAIQcgAigCPCEGIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBjYCbCACIAc2AmggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAGNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBBDbHSACQTBqEM8vIAUQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC84NAgZ/CH4jAEHgAWsiAyQAIAFBDGoQ2jwhByADQdgAaiABEJI2EO4lIAdBBHQiBCEFAkACQAJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AnggAyAFNgJ0IANBwAA2AnAgBARAIAZBACAE/AsACyADIAc2AoABIAMgBDYCfCADKAJYRQ0DIAMoAmwgAygCaEYNBCADQZABaiADQdgAahDINCADQbABaiEEIAIoAgghBSACKAIAIQIgASgCECEHAkADQAJAIAMpA7gBIgpQRQRAIAMpA8ABIQkMAQsDQAJ+AkAgAykDoAEiCUIDUgRAAkACQAJAIAlCAlENACADIAlQrUIBhjcDoAEgCadBAXFFDQAgAyADKQOoATcD0AEMAQsgAygCsAFFDQEgA0HIAWogBBC2KiADKQPIASEJCyAJQgBSDQILIANCAzcDoAELIAMpA5ABIglCAlENCiADQgA3A5ABIAMpA5gBDAELIAMpA9ABCyEKIAmnQQFxRQ0IIAMgAykDwAFCQH0iCTcDwAEgAyAKNwO4ASAKUA0ACwsgAyAKQgEgCnoiC4aFNwO4AUKAgICAgICAgIB/IQxCACENAkACfgJAAkAgByALpyAJp2pBBHQiCGoiASkDACIOIAEpAwgiD0KAgICAgICAgIB/hYRCAFIgAigCACIBKQMIIgkgASkDACIKg0J/UnJFBEBCACEJQgAhCwwBCyAJIAqEUA0DIANBQGsgDiAPIAogCRCDGSADQTBqIAMpA0AiCyADKQNIIgwgCiAJEKgeQgAgDiADKQMwIhB9IAkgCoNCf1EiARshDUIAIA8gAykDOH0gDiAQVK19IAEbIQkgD0IAWQ0BCyALIA0gAigCCCIBKQMAWCAJIAEpAwgiClcgCSAKURutIgp9IQkgDCAKIAtWrX0MAQsgDCALIA0gAigCBCIBKQMAWiAJIAEpAwgiClkgCSAKURutfCIJIAtUrXwLIQsgA0HIAWogCSALIAUtAAAQrQ4gAygCyAEiAUGTgICAeEcNAiAGIAhqIgEgCzcDCCABIAk3AwAMAQsLQcyP/wAQ4isACyADKQLMASEJIAAgAykC1AE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQZABakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACECA0BCgICAgICAgICAfyEMAn4CQAJAIAQpAwAiDSAEKQMIIg5CgICAgICAgICAf4WEQgBSIAUoAgAiASkDCCIJIAEpAwAiCoNCf1JyRQRAQgAhCkIAIQlCACELDAELIAkgCoRQDQggA0EgaiANIA4gCiAJEIMZIANBEGogAykDICILIAMpAygiDCAKIAkQqB5CACANIAMpAxAiD30gCSAKg0J/USIBGyEKQgAgDiADKQMYfSANIA9UrX0gARshCSAOQgBZDQELIAsgCiAFKAIIIgEpAwBYIAkgASkDCCIKVyAJIApRG60iCn0hCSAMIAogC1atfQwBCyAMIAsgCiAFKAIEIgEpAwBaIAkgASkDCCIKWSAJIApRG618IgkgC1StfAshCyADQZABaiAJIAsgCC0AABCtDiADKAKQASIBQZOAgIB4Rw0CIAYgCTcDACAGIAs3AwggBEEQaiEEIAZBEGohBiAHIAJBAWoiAkcNAAsLIANBkAFqIgIQlykgA0H4AGoiASgCACEFIAMoAnwhBiABIANBmAFqIgQpAgA3AwAgAykDcCEJIAMgAykCkAE3A3AgA0EANgKAASADIAk3ApwBIANBADYCmAEgAyAGNgKUASADIAU2ApABIANBCGogAhDXOyADKAIIIQVBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAMpApABNwIIIAFBEGogBCkCADcCACABQRhqIANBoAFqIgcoAgA2AgAgAyAGNgLQASADIAU2AswBIAMgATYCyAEgA0GEAWoiASADQcgBahDiGSAHIANB6ABqKQIANwMAIAQgA0HgAGopAgA3AwAgAyADKQJYNwOQASAAIAEgAhDLHSADQfAAahDPLwwCCyADKQKUASEJIAAgAykCnAE3AhALIAAgCTcCCCAAQSk6AAAgACABNgIEIANB8ABqEM8vIAMoAlgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0HYAGoQ+x4LIANB4AFqJAAPC0HMj/8AEOIrAAtBBEEcEKM9AAubDQIKfwV+IwBBgAJrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQcgAaiAFENw7IAUoAhQhByAFKAIMIQogBCgCTCEMIAQoAkghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AmAgBCAGNgJcIAQgBTYCWCAEQcAANgJUIARB1ABqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AmAgBCAGNgJcIAQgBzYCWCAEQcAANgJUIARB1ABqIAgQ3hBBACEHCyAIQQR0IgkhBQJAIAlBMHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCeCAEIAY2AnAgBCAFNgJsIARBwAA2AmggCQRAIAkEQCAGQQAgCfwLAAsgBCgCeCENIAQoAnAhBgsgBCAJNgJ0IAQgCCANajYCeCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyACKQMIIQ4gAikDACEPIAMtAAAhAyABKAIQIQUgBEGgAWpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDiAPhFAEQCAEQoGAgIDwgICAgH83A6ABIAkQiBEMAQsgBEEQaiAFMwEAwyIQIBBCP4cgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEGgAWogCyAMIAogCBC/FCAEQeABakEEciEIIARBwAFqIQUgAikDCCEQIAIpAwAhESADLQAAIQMgASgCECEJA0ACQCAEKQPIASIPUEUEQCAEKQPQASEODAELA0ACfgJAIAQpA7ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A7ABIA6nQQFxRQ0AIAQgBCkDuAE3A+gBDAELIAQoAsABRQ0BIARB4AFqIAUQtiogBCkD4AEhDgsgDkIAUg0CCyAEQgM3A7ABCyAEKQOgASIOQgJRDQYgBEIANwOgASAEKQOoAQwBCyAEKQPoAQshDyAOp0EBcUUNBCAEIAQpA9ABQkB9Ig43A9ABIAQgDzcDyAEgD1ANAAsLIAQgD0IBIA96IhKGhTcDyAEgEqcgDqdqIQECQCAQIBGEUARAIARCgYCAgPCAgICAfzcD4AEgCBCIEQwBCyAEQTBqIAkgAUEBdGozAQDDIg4gDkI/hyARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALmQ0CCn8FfiMAQYACayIEJAAgAUEMahDbPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBTQCACIQIBBCP4cgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAFQQRqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEGgAWogCyAMIAogCBC/FCAEQeABakEEciEIIARBwAFqIQUgAikDCCEQIAIpAwAhESADLQAAIQMgASgCECEJA0ACQCAEKQPIASIPUEUEQCAEKQPQASEODAELA0ACfgJAIAQpA7ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A7ABIA6nQQFxRQ0AIAQgBCkDuAE3A+gBDAELIAQoAsABRQ0BIARB4AFqIAUQtiogBCkD4AEhDgsgDkIAUg0CCyAEQgM3A7ABCyAEKQOgASIOQgJRDQYgBEIANwOgASAEKQOoAQwBCyAEKQPoAQshDyAOp0EBcUUNBCAEIAQpA9ABQkB9Ig43A9ABIAQgDzcDyAEgD1ANAAsLIAQgD0IBIA96IhKGhTcDyAEgEqcgDqdqIQECQCAQIBGEUARAIARCgYCAgPCAgICAfzcD4AEgCBCIEQwBCyAEQTBqIAkgAUECdGo0AgAiDiAOQj+HIBEgEBCDGSAEKQMwIg4gBCkDOCIPIAMQ/yBFDQAgBiABQQR0aiIBIA83AwggASAONwMADAELIARBKGogBEHUAGoQhj0gAUEDdiICIAQoAiwiCkkEQCAEKAIoIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARBgAFqIARB1ABqIgYQghQgBEGgAWoiAhCXKSAEQfAAaiIBKAIAIQUgBCgCdCEDIAEgBEGoAWoiCCkCADcDACAEKQNoIQ4gBCAEKQKgATcDaCAEQQA2AnggBCAONwKsASAEQQA2AqgBIAQgAzYCpAEgBCAFNgKgASAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAqABNwIIIAFBEGogCCkCADcCACABQRhqIARBsAFqIgkoAgA2AgAgBCADNgLoASAEIAU2AuQBIAQgATYC4AEgBEGUAWoiASAEQeABahDiGSAJIARBkAFqKAIANgIAIAggBEGIAWopAgA3AwAgBCAEKQKAATcDoAEgBCAHNgK0ASAAIAEgAhDLHSAEQegAahDPLyAGEM8vIARBgAJqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGgAWpB7I//AEGIjP8AENUeAAuZDQIKfwV+IwBBgAJrIgQkACABQQxqENg8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQcgAaiAFENw7IAUoAhQhByAFKAIMIQogBCgCTCEMIAQoAkghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AmAgBCAGNgJcIAQgBTYCWCAEQcAANgJUIARB1ABqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AmAgBCAGNgJcIAQgBzYCWCAEQcAANgJUIARB1ABqIAgQ3hBBACEHCyAIQQR0IgkhBQJAIAlBMHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCeCAEIAY2AnAgBCAFNgJsIARBwAA2AmggCQRAIAkEQCAGQQAgCfwLAAsgBCgCeCENIAQoAnAhBgsgBCAJNgJ0IAQgCCANajYCeCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyACKQMIIQ4gAikDACEPIAMtAAAhAyABKAIQIQUgBEGgAWpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDiAPhFAEQCAEQoGAgIDwgICAgH83A6ABIAkQiBEMAQsgBEEQaiAFKQMAIhAgEEI/hyAPIA4QgxkgBCkDECIQIAQpAxgiESADEP8gRQ0AIAYgEDcDACAGIBE3AwgMAQsgBEEIaiAEQdQAahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEQaiEGIAVBCGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQaABaiALIAwgCiAIEL8UIARB4AFqQQRyIQggBEHAAWohBSACKQMIIRAgAikDACERIAMtAAAhAyABKAIQIQkDQAJAIAQpA8gBIg9QRQRAIAQpA9ABIQ4MAQsDQAJ+AkAgBCkDsAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDsAEgDqdBAXFFDQAgBCAEKQO4ATcD6AEMAQsgBCgCwAFFDQEgBEHgAWogBRC2KiAEKQPgASEOCyAOQgBSDQILIARCAzcDsAELIAQpA6ABIg5CAlENBiAEQgA3A6ABIAQpA6gBDAELIAQpA+gBCyEPIA6nQQFxRQ0EIAQgBCkD0AFCQH0iDjcD0AEgBCAPNwPIASAPUA0ACwsgBCAPQgEgD3oiEoaFNwPIASASpyAOp2ohAQJAIBAgEYRQBEAgBEKBgICA8ICAgIB/NwPgASAIEIgRDAELIARBMGogCSABQQN0aikDACIOIA5CP4cgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5QNAgp/BX4jAEGAAmsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiBSEJAkAgBUEwcSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAk2AmwgBEHAADYCaCAFBEAgBQRAIAZBACAF/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAU2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAEgBWoxAADCIhAgEEI/hyAPIA4QgxkgBCkDECIQIAQpAxgiESADEP8gRQ0AIAYgEDcDACAGIBE3AwgMAQsgBEEIaiAEQdQAahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEQaiEGIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiABIAlqMQAAwiIOIA5CP4cgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5kNAgp/BX4jAEGAAmsiBCQAIAFBDGoQ2TwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiCSEFAkAgCUEwcSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAU2AmwgBEHAADYCaCAJBEAgCQRAIAZBACAJ/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAk2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAUzAQBC//8Dg0IAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBAXRqMwEAQv//A4NCACARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALjw0CCn8FfiMAQYACayIEJAAgAUEMahDbPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBTUCAEIAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUEEaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBAnRqNQIAQgAgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC5ANAgp/BX4jAEGAAmsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARByABqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAJMIQwgBCgCSCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCYCAEIAY2AlwgBCAFNgJYIARBwAA2AlQgBEHUAGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCYCAEIAY2AlwgBCAHNgJYIARBwAA2AlQgBEHUAGogCBDeEEEAIQcLIAhBBHQiBSEJAkAgBUEwcSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJ4IAQgBjYCcCAEIAk2AmwgBEHAADYCaCAFBEAgBQRAIAZBACAF/AsACyAEKAJ4IQ0gBCgCcCEGCyAEIAU2AnQgBCAIIA1qNgJ4IAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAIpAwghDiACKQMAIQ8gAy0AACEDIAEoAhAhBSAEQaABakEEciEJQQAhB0EAIQEDQAJAAkACQCAOIA+EUARAIARCgYCAgPCAgICAfzcDoAEgCRCIEQwBCyAEQRBqIAEgBWoxAABC/wGDQgAgDyAOEIMZIAQpAxAiECAEKQMYIhEgAxD/IEUNACAGIBA3AwAgBiARNwMIDAELIARBCGogBEHUAGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBEGohBiAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAJEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQaABaiALIAwgCiAIEL8UIARB4AFqQQRyIQggBEHAAWohBSACKQMIIRAgAikDACERIAMtAAAhAyABKAIQIQkDQAJAIAQpA8gBIg9QRQRAIAQpA9ABIQ4MAQsDQAJ+AkAgBCkDsAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDsAEgDqdBAXFFDQAgBCAEKQO4ATcD6AEMAQsgBCgCwAFFDQEgBEHgAWogBRC2KiAEKQPgASEOCyAOQgBSDQILIARCAzcDsAELIAQpA6ABIg5CAlENBiAEQgA3A6ABIAQpA6gBDAELIAQpA+gBCyEPIA6nQQFxRQ0EIAQgBCkD0AFCQH0iDjcD0AEgBCAPNwPIASAPUA0ACwsgBCAPQgEgD3oiEoaFNwPIASASpyAOp2ohAQJAIBAgEYRQBEAgBEKBgICA8ICAgIB/NwPgASAIEIgRDAELIARBMGogASAJajEAAEL/AYNCACARIBAQgxkgBCkDMCIOIAQpAzgiDyADEP8gRQ0AIAYgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQShqIARB1ABqEIY9IAFBA3YiAiAEKAIsIgpJBEAgBCgCKCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQYABaiAEQdQAaiIGEIIUIARBoAFqIgIQlykgBEHwAGoiASgCACEFIAQoAnQhAyABIARBqAFqIggpAgA3AwAgBCkDaCEOIAQgBCkCoAE3A2ggBEEANgJ4IAQgDjcCrAEgBEEANgKoASAEIAM2AqQBIAQgBTYCoAEgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKgATcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQbABaiIJKAIANgIAIAQgAzYC6AEgBCAFNgLkASAEIAE2AuABIARBlAFqIgEgBEHgAWoQ4hkgCSAEQZABaigCADYCACAIIARBiAFqKQIANwMAIAQgBCkCgAE3A6ABIAQgBzYCtAEgACABIAIQyx0gBEHoAGoQzy8gBhDPLyAEQYACaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBoAFqQeyP/wBBiIz/ABDVHgALgg0CCn8EfiMAQeABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBBXQiCSEFAkAgCUEgcSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQUDQCAEQfAAaiACIAEpAwAgASkDCCABQRBqKQMAIAFBGGopAwAQ7QkCQAJAIAQoAnBBAXFFDQAgBCkDgAEiDiAEKQOIASIPIAQpA5ABIhAgBCkDmAEiESAJENwdRQ0AIAYgDjcDACAGQRhqIBE3AwAgBkEQaiAQNwMAIAYgDzcDCAwBCyAEQQhqIARBJGoQhj0gBUEDdiIDIAQoAgwiCk8NAyAEKAIIIANqIgMgAy0AAEF+IAVBB3F3cToAACAHQQFqIQcLIAZBIGohBiABQSBqIQEgCCAFQQFqIgVHDQALDAcLIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBkAFqIQggAy0AACEFIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwO4AQwBCyAEKAKQAUUNASAEQbABaiAIELYqIAQpA7ABIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQwgBEIANwNwIAQpA3gMAQsgBCkDuAELIQ8gDqdBAXFFDQogBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIARBsAFqIAIgCSAQpyAOp2oiA0EFdCIKaiIBKQMAIAEpAwggASkDECABKQMYEO0JAkAgBCgCsAFBAXFFDQAgBCkDwAEiDiAEKQPIASIPIAQpA9ABIhAgBCkD2AEiESAFENwdRQ0AIAYgCmoiASARNwMYIAEgEDcDECABIA83AwggASAONwMADAELIARBEGogBEEkahCGPSADQQN2IgEgBCgCFCIKSQRAIAQoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAdBAWohBwwBCwsgASAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCuAEgBCAFNgK0ASAEIAE2ArABIARB5ABqIgEgBEGwAWoQ4hkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEM4dIARBOGoQzy8gBhDPLyAEQeABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALjw0CCn8FfiMAQYACayIEJAAgAUEMahDYPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEHIAGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAkwhDCAEKAJIIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJgIAQgBjYCXCAEIAU2AlggBEHAADYCVCAEQdQAaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwJgIAQgBjYCXCAEIAc2AlggBEHAADYCVCAEQdQAaiAIEN4QQQAhBwsgCEEEdCIJIQUCQCAJQTBxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AnggBCAGNgJwIAQgBTYCbCAEQcAANgJoIAkEQCAJBEAgBkEAIAn8CwALIAQoAnghDSAEKAJwIQYLIAQgCTYCdCAEIAggDWo2AnggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAikDCCEOIAIpAwAhDyADLQAAIQMgASgCECEFIARBoAFqQQRyIQlBACEHQQAhAQNAAkACQAJAIA4gD4RQBEAgBEKBgICA8ICAgIB/NwOgASAJEIgRDAELIARBEGogBSkDAEIAIA8gDhCDGSAEKQMQIhAgBCkDGCIRIAMQ/yBFDQAgBiAQNwMAIAYgETcDCAwBCyAEQQhqIARB1ABqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQRBqIQYgBUEIaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARBoAFqIAsgDCAKIAgQvxQgBEHgAWpBBHIhCCAEQcABaiEFIAIpAwghECACKQMAIREgAy0AACEDIAEoAhAhCQNAAkAgBCkDyAEiD1BFBEAgBCkD0AEhDgwBCwNAAn4CQCAEKQOwASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOwASAOp0EBcUUNACAEIAQpA7gBNwPoAQwBCyAEKALAAUUNASAEQeABaiAFELYqIAQpA+ABIQ4LIA5CAFINAgsgBEIDNwOwAQsgBCkDoAEiDkICUQ0GIARCADcDoAEgBCkDqAEMAQsgBCkD6AELIQ8gDqdBAXFFDQQgBCAEKQPQAUJAfSIONwPQASAEIA83A8gBIA9QDQALCyAEIA9CASAPeiIShoU3A8gBIBKnIA6naiEBAkAgECARhFAEQCAEQoGAgIDwgICAgH83A+ABIAgQiBEMAQsgBEEwaiAJIAFBA3RqKQMAQgAgESAQEIMZIAQpAzAiDiAEKQM4Ig8gAxD/IEUNACAGIAFBBHRqIgEgDzcDCCABIA43AwAMAQsgBEEoaiAEQdQAahCGPSABQQN2IgIgBCgCLCIKSQRAIAQoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEGAAWogBEHUAGoiBhCCFCAEQaABaiICEJcpIARB8ABqIgEoAgAhBSAEKAJ0IQMgASAEQagBaiIIKQIANwMAIAQpA2ghDiAEIAQpAqABNwNoIARBADYCeCAEIA43AqwBIARBADYCqAEgBCADNgKkASAEIAU2AqABIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCoAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGwAWoiCSgCADYCACAEIAM2AugBIAQgBTYC5AEgBCABNgLgASAEQZQBaiIBIARB4AFqEOIZIAkgBEGQAWooAgA2AgAgCCAEQYgBaikCADcDACAEIAQpAoABNwOgASAEIAc2ArQBIAAgASACEMsdIARB6ABqEM8vIAYQzy8gBEGAAmokAA8LQQRBHBCjPQALQdyL/wBBKSAEQaABakHsj/8AQYiM/wAQ1R4AC6AMAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBEGogAxDcOyADKAIUIQkgAygCDCEGIAIoAhQhCiACKAIQIQggBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwIoIAIgBTYCJCACIAM2AiAgAkHAADYCHCACQRxqIAYgBCAGaiAIIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AiggAiAFNgIkIAIgAzYCICACQcAANgIcIAJBHGogBBDeEAsgBEECdCIHIQMCQAJAAkAgB0E8cSIFBEAgByAFa0FAayIDIAdJDQELQcAAIQUgA0HAABDRNARAIAMEQCADQcAAEK02IgVFDQULIAJBADYCQCACIAU2AjggAiADNgI0IAJBwAA2AjAgBwRAIAcEQCAFQQAgB/wLAAsgAigCQCELIAIoAjghBQsgAiAHNgI8IAIgBCALajYCQCAJRQ0CIAQgCUYNAyAIBEAgAkHoAGogCCAKIAYgBBC/FCACQYgBaiEHIAEoAhAhBiACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAHELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQAQJ/IAYgDqcgDKdqIghBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQEgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQiA0GAgID8B3IgAUUNARogAyABQQ10ckGAgID+B3IMAQsgBEEQdCIEIANBDXRBgICA/ABxIAFBDXRyQYCAgMADanIgAw0AGiABIAFnQRBrIgFB//8DcUEIanRB////A3EgBEGAgIDYA3IgAUEXdGtyCyEBIAUgCEECdGogATYCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgASgCECEDQQAhAQNAIAUCfyADLwEAIgZB//8BcUUEQCAGQRB0DAELIAZB/wdxIQcgBkGAgAJxIQggBkGA+AFxIgZBgPgBRgRAIAhBEHQiBkGAgID8B3IgB0UNARogBiAHQQ10ckGAgID+B3IMAQsgCEEQdCIIIAZBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgBg0AGiAHIAdnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyCzYCACAFQQRqIQUgA0ECaiEDIAQgAUEBaiIBRw0ACwsgAkHIAGogAkEcaiIHEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQYgAigCPCEEIAEgAkHwAGoiBSkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAY2AmggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBSkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAY2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAUgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAcQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAuNDQIIfwJ+IwBBQGoiAyQAAkACQAJAIAAQ9w4EQCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEAQQIhBCABKAIAIgBFDQEgAUEMaiABKAIEIAEoAgggACgCEBEBAAwBCyAAIAEQoQkiBiAALwE4cSEEAkACQAJAAkADQCAAKAIcIQgDQCAEIQdBACEEIAcgCE8NAAsgACgCGCAHQQJ0aiIILwEAIgRB//8DRg0BIAUgByAALwE4IgkgCC8BAiIIcWsgCXFNBEACQCAIIAZB//8DcUcNACAAKAIoIgggBE0NBCABKAIARSAAKAIkIARBNGxqIgkoAiAiCkEAR0YNACAJQSBqIQkgCgRAIAkgARCMNUUNASAAKAIoIQgMBwsgCS0ABCABLQAERg0GCyAHQQFqIQQgBUEBaiEFDAELCyAAKQMAIQsgA0EIaiABQQhqKQIANwMAIAMgASkCADcDACADQSBqIAJBEGoiBCgCADYCACADQRhqIAJBCGoiCCkCADcDACADIAIpAgA3AxACQCAAKAIoIgFB//8BTQRAIANBPGoiCSAEKAIANgIAIANBNGogCCkCADcCACADIAIpAgA3AiwgAEEgaiICKAIAIAFGBEAgAkHMqMMAEJMoCyAFQf8DSyALQgJScSEIIAAoAiQgAUE0bGoiAiADKQIkNwIEQQAhBSACQQA2AgAgAkEUaiADQTRqKQIANwIAIAJBDGogA0EsaikCADcCACACQRxqIAkoAgA2AgAgA0EIaikDACELIAMpAwAhDCACIAY7ATAgAiAMNwIgIAJBKGogCzcCACAAIAFBAWo2AiggACgCHCEJIAAoAhghCgNAIAchBEEAIQcgBCAJTw0AIAogBEECdGoiBy8BACICQf//A0YNAiAHIAE7AQAgBy8BAiAHIAY7AQIgBEEBaiEHIAVBAWohBSEGIAIhAQwACwALIANBHGogAygCFCADKAIYIAMoAhAoAhARAQAgAygCACIARQ0DIANBDGogAygCBCADKAIIIAAoAhARAQAMAwsgByAGOwECIAcgATsBAAJAIAhBf3MgBUGAAUlxDQAgACkDAEIAUg0AIABCATcDAAtBACEEDAQLIAAoAighBSADQQhqIAFBCGopAgA3AwAgAyABKQIANwMAIANBIGogAkEQaiIBKAIANgIAIANBGGogAkEIaiIEKQIANwMAIAMgAikCADcDEAJAIAVB//8BTQRAIANBPGoiCCABKAIANgIAIANBNGogBCkCADcCACADIAIpAgA3AiwgAEEgaiIBKAIAIAVGBEAgAUHMqMMAEJMoCyAAKAIkIAVBNGxqIgEgAykCJDcCBEEAIQQgAUEANgIAIAFBDGogA0EsaikCADcCACABQRRqIANBNGopAgA3AgAgAUEcaiAIKAIANgIAIANBCGopAwAhCyADKQMAIQwgASAGOwEwIAEgDDcCICABQShqIAs3AgAgACAFQQFqNgIoIAcgACgCHCIBTw0BIAAoAhggB0ECdGoiACAGOwECIAAgBTsBAAwFCyADQRxqIAMoAhQgAygCGCADKAIQKAIQEQEAIAMoAgAiAEUNAiADQQxqIAMoAgQgAygCCCAAKAIQEQEADAILIAcgAUG8qMMAEMMhAAsgBCAIQZyowwAQwyEAC0ECIQQMAQsgBCAITw0BIABBLGohBgJAIAAoAiQgBEE0bGoiBygCAEEBRgRAIAcoAgghCCAAKAI0IgUgACgCLEYEQCAGQfynwwAQlCgLIAAoAjAgBUEkbGoiBiAENgIMIAZBADYCCCAGIAg2AgQgBkEBNgIAIAYgAikCADcCECAGQRhqIAJBCGopAgA3AgAgBkEgaiACQRBqKAIANgIAIAAgBUEBaiICNgI0IAUgCEkNBCAHIAU2AgggB0EBNgIAIAAoAjAgCEEkbGoiACAFNgIMIABBATYCCAwBCyAAKAI0IgUgACgCLEYEQCAGQeynwwAQlCgLIAAoAjAgBUEkbGoiBiAENgIMIAZBADYCCCAGIAQ2AgQgBkEANgIAIAZBIGogAkEQaigCADYCACAGQRhqIAJBCGopAgA3AgAgBiACKQIANwIQIAcgBTYCBCAHQQE2AgAgACAFQQFqNgI0IAcgBTYCCAtBASEEIAEoAgAiAEUNACABQQxqIAEoAgQgASgCCCAAKAIQEQEACyADQUBrJAAgBA8LIAQgCEGsqMMAEMMhAAsgCCACQYyowwAQwyEAC6ISAg9/AX4jAEHwAWsiAyQAIAEoAgAiCEEwaiERAkACfyAILQAwIglBKEcEQCARIQEgCUEiRw0CIAgoAjgMAQsgCCgCOEEwagsiAS0AACEJCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAlB/wFxQRtrDg0ABgECBgMEBgYGBgYFBgsgA0GYAWogAUEEaiACEJMDIAMoApwBIQIgAygCmAEiAUGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgATYCAAwICyACDQYgAEKTgICACDcCAAwHCyADQZgBaiABQQhqIAIQkwMgAygCnAEhBiADKAKYASICQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAY2AgQgACACNgIADAcLIAYEQCABKAIEIQIMBgsgAEKTgICACDcCAAwGCyADQZgBaiABQQRqIAIQkwMgAygCnAEhAiADKAKYASIBQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAI2AgQgACABNgIADAYLIAINBCAAQpOAgIAINwIADAULIANBEGogAUEEahDDNCADKAIUIQEgAygCECEEIAMgAjYCoAEgAyAENgKYASADIAQgAUECdGo2ApwBIANBKGogA0GYAWoQixcgA0EsaiEEIAMoAigiAUGTgICAeEcEQCAAIAMoAjg2AhAgACABNgIAIAAgBCkCADcCBCAAQQxqIARBCGooAgA2AgAMBQsgA0GgAWogBEEIaigCACICNgIAIAMgBCkCADcDmAEgA0EIaiADKAKcASIBIAEgAkECdGoQmxggAyADKAIMIgY2AlQgAyADKAIIIgI2AlAgBBD4JSADQZgBakEEQQQQ4B4gAyADQdAAaiIBEMM0IAMoAgQNAyAAQpOAgIAINwIAIAIgAigCACIAQQFrNgIAIABBAUcNBCABEIUdDAQLIANBIGogAUEEahCwLiADKQMgIRIgAyACNgKgASADIBI3ApgBIANBPGohDyMAQTBrIgckACAHQZOAgIB4NgIAIAdBKGogA0GYAWoiAkEIaigCADYCACAHIAIpAgA3AyAgByAHNgIsIAdBFGohECMAQTBrIgUkACAFQRRqIAdBIGoiDBD+FwJAAkACQCAFKAIUQQFGBEAgBSgCHCEEIAUtABghAiAFQSBqIg1BBEEAQQRBCBCgGCAFKAIkIQogBSgCIEEBRg0CIAUoAigiBiAENgIEIAYgAjoAACAFQRBqIgtBATYCACAFIAY2AgwgBSAKNgIIIAVBKGogDEEIaikCADcDACAFIAwpAgA3AyAjAEEQayIOJAAgDkEEaiANEP4XIA4oAgRBAUYEQCAFQQhqIQwDQCAOKAIMIQYgDi0ACCEEIAwoAggiCiAMKAIARgRAIAwgCkEBQQRBCBDQKAsgDCgCBCAKQQN0aiICIAY2AgQgAiAEOgAAIAwgCkEBajYCCCAOQQRqIA0Q/hcgDigCBA0ACwsgDkEQaiQAIBBBCGogCygCADYCACAQIAUpAgg3AgAMAQsgEEEANgIIIBBCgICAgMAANwIACyAFQTBqJAAMAQsgCiAFKAIoQbiBwwAQ/S8ACwJAIAcoAgBBk4CAgHhHBEAgDyAHKQIANwIAIA9BEGogB0EQaigCADYCACAPQQhqIAdBCGopAgA3AgAgEBCfJSAQQQRBCBDgHgwBCyAPIAcpAhQ3AgQgD0GTgICAeDYCACAPQQxqIAdBHGooAgA2AgALIAdBMGokACADQUBrIQsgAygCPCICQZOAgIB4RwRAIAAgAygCTDYCECAAIAI2AgAgACALKQIANwIEIABBDGogC0EIaigCADYCAAwECyADQaABaiALQQhqKAIAIgQ2AgAgAyALKQIANwOYASADQRhqIAMoApwBIgIgAiAEQQN0ahCcGCADIAMoAhwiBjYCVCADIAMoAhgiAjYCUCALEJ8lIANBmAFqQQRBCBDgHiADQdAAahCOPkUEQCABLQABIQ0MAwsgAEKTgICACDcCACACIAIoAgAiAEEBazYCACAAQQFHDQMgA0HQAGoQhh0MAwsgA0GYAWogAUEEaiACEJMDIAMoApwBIQIgAygCmAEiBkGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgBjYCAAwDCyACBEAgAS0AASENDAILIABCk4CAgAg3AgAMAgsgAigCACgCACgCACACKAIEIgIoAgAQ8iYgAiACKAIAQQFqNgIAQQAhCQRAIAggCCgCACIBQQFqNgIAIAghCSABQQBIDQQLIABBk4CAgHg2AgAgACAJNgIEDAELAkACQCARLQAAIgFBIkcEQCABQShGDQEgAiEEIAYhAQwCCxDNLyEEIANBmAFqIAgoAjQQwAYgBEEIaiADQaABaigCADYCACAEIAMpApgBNwIAQQxBBBCtNiIBRQ0DIAEgBjYCCCABIAI2AgQgASANOgABIAEgCToAAEEiIQkMAQsgCCgCNCIEIAQoAgAiAUEBajYCACABQQBIDQMgA0HMAWogCCgCOCIKQTxqEN0gIANBwAFqIApBMGoQwAYgCi8BSCELIAopAyghEiADQZgBaiIBIApBCGoQsS4gAyASNwO4ASADIAs7AdgBIAMgBjYC7AEgAyACNgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiAiABIANB5AFqEKQrQdAAQQgQrTYiAUUNBCABQoGAgIAQNwMAIAFBCGogAkHIAPwKAABBKCEJCyADQcwBaiAIQTxqEN0gIANBwAFqIBEQwAYgCC8BSCERIAgpAyghEiADQZgBaiICIAhBCGoQsS4gAyASNwO4ASADIBE7AdgBIAMgATYC7AEgAyAENgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiASACIANB5AFqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogAUHIAPwKAAAgAEGTgICAeDYCACAAIAI2AgQLIANB8AFqJAAPC0EEQQwQoz0LAAtBCEHQABCjPQALQQhB0AAQoz0AC6ISAg9/AX4jAEHwAWsiAyQAIAEoAgAiCEEwaiERAkACfyAILQAwIglBKEcEQCARIQEgCUEiRw0CIAgoAjgMAQsgCCgCOEEwagsiAS0AACEJCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAlB/wFxQRtrDg0ABgECBgMEBgYGBgYFBgsgA0GYAWogAUEEaiACEJQDIAMoApwBIQIgAygCmAEiAUGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgATYCAAwICyACDQYgAEKTgICACDcCAAwHCyADQZgBaiABQQhqIAIQlAMgAygCnAEhBiADKAKYASICQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAY2AgQgACACNgIADAcLIAYEQCABKAIEIQIMBgsgAEKTgICACDcCAAwGCyADQZgBaiABQQRqIAIQlAMgAygCnAEhAiADKAKYASIBQZOAgIB4RwRAIAAgAykCoAE3AgggAEEQaiADQagBaigCADYCACAAIAI2AgQgACABNgIADAYLIAINBCAAQpOAgIAINwIADAULIANBEGogAUEEahDDNCADKAIUIQEgAygCECEEIAMgAjYCoAEgAyAENgKYASADIAQgAUECdGo2ApwBIANBKGogA0GYAWoQihcgA0EsaiEEIAMoAigiAUGTgICAeEcEQCAAIAMoAjg2AhAgACABNgIAIAAgBCkCADcCBCAAQQxqIARBCGooAgA2AgAMBQsgA0GgAWogBEEIaigCACICNgIAIAMgBCkCADcDmAEgA0EIaiADKAKcASIBIAEgAkECdGoQmxggAyADKAIMIgY2AlQgAyADKAIIIgI2AlAgBBD4JSADQZgBakEEQQQQ4B4gAyADQdAAaiIBEMM0IAMoAgQNAyAAQpOAgIAINwIAIAIgAigCACIAQQFrNgIAIABBAUcNBCABEIUdDAQLIANBIGogAUEEahCwLiADKQMgIRIgAyACNgKgASADIBI3ApgBIANBPGohDyMAQTBrIgckACAHQZOAgIB4NgIAIAdBKGogA0GYAWoiAkEIaigCADYCACAHIAIpAgA3AyAgByAHNgIsIAdBFGohECMAQTBrIgUkACAFQRRqIAdBIGoiDBD/FwJAAkACQCAFKAIUQQFGBEAgBSgCHCEEIAUtABghAiAFQSBqIg1BBEEAQQRBCBCgGCAFKAIkIQogBSgCIEEBRg0CIAUoAigiBiAENgIEIAYgAjoAACAFQRBqIgtBATYCACAFIAY2AgwgBSAKNgIIIAVBKGogDEEIaikCADcDACAFIAwpAgA3AyAjAEEQayIOJAAgDkEEaiANEP8XIA4oAgRBAUYEQCAFQQhqIQwDQCAOKAIMIQYgDi0ACCEEIAwoAggiCiAMKAIARgRAIAwgCkEBQQRBCBDQKAsgDCgCBCAKQQN0aiICIAY2AgQgAiAEOgAAIAwgCkEBajYCCCAOQQRqIA0Q/xcgDigCBA0ACwsgDkEQaiQAIBBBCGogCygCADYCACAQIAUpAgg3AgAMAQsgEEEANgIIIBBCgICAgMAANwIACyAFQTBqJAAMAQsgCiAFKAIoQbiBwwAQ/S8ACwJAIAcoAgBBk4CAgHhHBEAgDyAHKQIANwIAIA9BEGogB0EQaigCADYCACAPQQhqIAdBCGopAgA3AgAgEBCfJSAQQQRBCBDgHgwBCyAPIAcpAhQ3AgQgD0GTgICAeDYCACAPQQxqIAdBHGooAgA2AgALIAdBMGokACADQUBrIQsgAygCPCICQZOAgIB4RwRAIAAgAygCTDYCECAAIAI2AgAgACALKQIANwIEIABBDGogC0EIaigCADYCAAwECyADQaABaiALQQhqKAIAIgQ2AgAgAyALKQIANwOYASADQRhqIAMoApwBIgIgAiAEQQN0ahCcGCADIAMoAhwiBjYCVCADIAMoAhgiAjYCUCALEJ8lIANBmAFqQQRBCBDgHiADQdAAahCOPkUEQCABLQABIQ0MAwsgAEKTgICACDcCACACIAIoAgAiAEEBazYCACAAQQFHDQMgA0HQAGoQhh0MAwsgA0GYAWogAUEEaiACEJQDIAMoApwBIQIgAygCmAEiBkGTgICAeEcEQCAAIAMpAqABNwIIIABBEGogA0GoAWooAgA2AgAgACACNgIEIAAgBjYCAAwDCyACBEAgAS0AASENDAILIABCk4CAgAg3AgAMAgsgAigCACgCACgCACACKAIEIgIoAgAQ8iYgAiACKAIAQQFqNgIAQQAhCQRAIAggCCgCACIBQQFqNgIAIAghCSABQQBIDQQLIABBk4CAgHg2AgAgACAJNgIEDAELAkACQCARLQAAIgFBIkcEQCABQShGDQEgAiEEIAYhAQwCCxDNLyEEIANBmAFqIAgoAjQQwAYgBEEIaiADQaABaigCADYCACAEIAMpApgBNwIAQQxBBBCtNiIBRQ0DIAEgBjYCCCABIAI2AgQgASANOgABIAEgCToAAEEiIQkMAQsgCCgCNCIEIAQoAgAiAUEBajYCACABQQBIDQMgA0HMAWogCCgCOCIKQTxqEN0gIANBwAFqIApBMGoQwAYgCi8BSCELIAopAyghEiADQZgBaiIBIApBCGoQsS4gAyASNwO4ASADIAs7AdgBIAMgBjYC7AEgAyACNgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiAiABIANB5AFqEKQrQdAAQQgQrTYiAUUNBCABQoGAgIAQNwMAIAFBCGogAkHIAPwKAABBKCEJCyADQcwBaiAIQTxqEN0gIANBwAFqIBEQwAYgCC8BSCERIAgpAyghEiADQZgBaiICIAhBCGoQsS4gAyASNwO4ASADIBE7AdgBIAMgATYC7AEgAyAENgLoASADIA06AOUBIAMgCToA5AEgA0HQAGoiASACIANB5AFqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogAUHIAPwKAAAgAEGTgICAeDYCACAAIAI2AgQLIANB8AFqJAAPC0EEQQwQoz0LAAtBCEHQABCjPQALQQhB0AAQoz0AC/5UAg5/A34jAEGwAWsiBSQAIAUgAjYCPCAFIAE2AjggBUEANgJoIAVCgICAgMAANwJgIAVBATsBrAEgBUEANgKoASAFIAEgAmo2AqQBIAUgATYCoAEgBSACNgKcASAFIAE2ApgBIAUgAjYClAEgBUEANgKQASAFQRhqIAVBkAFqEK8LAkACQCAFKAIYIghFDQAgBSgCHCEHA0AgByAIaiELQQAhAiAIIQECQAJAAkADQCACIQQgASICIAtGDQECfyACLAAAIgFBAE4EQCABQf8BcSEGIAJBAWoMAQsgAi0AAUE/cSEKIAFBH3EhBiABQV9NBEAgBkEGdCAKciEGIAJBAmoMAQsgAi0AAkE/cSAKQQZ0ciEKIAFBcEkEQCAKIAZBDHRyIQYgAkEDagwBCyAGQRJ0QYCA8ABxIAItAANBP3EgCkEGdHJyIQYgAkEEagsiASAEIAJraiECIAZBMGtBCkkgBkEta0ECSXINAAsCQCAERQ0AIAQgB08EQCAEIAdGDQEMBwsgBCAIaiwAAEG/f0wNBgsgByAEayEGIAQgCGohASAJIAUoAmBHDQJB3M+AASECDAELIAVBEGogBUGQAWoQrwsgBSgCECIBBEAgBSgCFCEGIAUoAmAgCUcEQCAHIQQMAwtB7M+AASECIAchBAwBCyAFKAJgIAlGBEAgBUHgAGpB/M+AARCeKAsgBSgCZCAJQQR0aiIBQQA2AgggASAHNgIEIAEgCDYCACAFIAlBAWo2AmgMAwsgBUHgAGogAhCeKAsgBSgCZCAJQQR0aiICIAY2AgwgAiABNgIIIAIgBDYCBCACIAg2AgAgBSAJQQFqIgk2AmggBUEIaiAFQZABahCvCyAFKAIMIQcgBSgCCCIIDQALCyAFQcgAaiAFQegAaiIOKAIAIgE2AgAgBSAFKQJgNwNAIAUoAkQhByAFIAM2AmggBSAHIAFBBHQiD2o2AmQgBSAHNgJgIAVBkAFqIQEjAEEwayIDJAAgA0GTgICAeDYCACADQShqIAVB4ABqIgJBCGooAgA2AgAgAyACKQIANwMgIAMgAzYCLCADQRRqIQYjAEFAaiICJAAgAkEYaiADQSBqIggQhRgCQAJAAkAgAi8BKARAIAJBMGoiCkEEQQBBCEEYEKAYIAIoAjQhCSACKAIwQQFGDQIgAigCOCIEIAIpAxg3AwAgBEEQaiACQShqKQMANwMAIARBCGogAkEgaikDADcDACACQRRqIgxBATYCACACIAQ2AhAgAiAJNgIMIAJBOGogCEEIaikCADcDACACIAgpAgA3AzAjAEEgayIEJAAgBEEIaiAKEIUYIAQvARgEQCACQQxqIQgDQCAIKAIIIgkgCCgCAEYEQCAIIAlBAUEIQRgQ3igLIAgoAgQgCUEYbGoiCyAEKQMINwMAIAtBEGogBEEYaiINKQMANwMAIAtBCGogBEEQaikDADcDACAIIAlBAWo2AgggBEEIaiAKEIUYIA0vAQANAAsLIARBIGokACAGQQhqIAwoAgA2AgAgBiACKQIMNwIADAELIAZBADYCCCAGQoCAgICAATcCAAsgAkFAayQADAELIAkgAigCOEG4tYABEP0vAAsCQCADKAIAQZOAgIB4RwRAIAEgAykCADcCACABQRBqIANBEGooAgA2AgAgAUEIaiADQQhqKQIANwIAIAZBCEEYEOAeDAELIAEgAykCFDcCBCABQZOAgIB4NgIAIAFBDGogA0EcaigCADYCAAsgA0EwaiQAAkACQCAFKAKQAUGTgICAeEYEQCAFKAKcASEDIAUoApgBIQIgBSAFKAKUATYCgAEgBSACNgJ4IAUgAiADQRhsajYChAEgBSACNgJ8IAVBoAFqIgxCAjcCACAFQZgBaiINQgA3AgAgBUKAgICAgAE3ApABIAVBnAFqIQIjAEEQayIDJAACQCAFQfgAaiIEKAIMIgggBCgCBCIGRg0AIAggBmtBGG4iCCABKAIAIAEoAggiBmtLBEAgASAGIAhBCEEQEN4oCyAIIAIoAgAgAigCCCIGa00NACACIAYgCEECQQIQ3igLIANBCGogBEEIaikCADcDACADIAQpAgA3AwAjAEEQayIIJAAgAygCBCIEIAMoAgwiEEcEQCABKAIEIAEoAggiCUEEdGohBiACKAIEIAIoAggiCkEBdGohCwNAIARBEGovAQAhESAEKQMAIRIgBkEIaiAEQQhqKQMANwMAIAYgEjcDACALIBE7AQAgBkEQaiEGIAtBAmohCyAKQQFqIQogCUEBaiEJIARBGGoiBCAQRw0ACyABIAk2AgggAyAENgIEIAIgCjYCCAsgCCADKAIANgIMIAggAygCCDYCCCAIQQhqQQhBGBDgHiAIQRBqJAAgA0EQaiQAIAVB8ABqIAwpAgA3AwAgDiANKQIAIhI3AwAgBSAFKQKQASITNwNgIAVB2ABqIBI+AgAgBSATNwNQIAVBgAFqIAVB9ABqKAIAIgI2AgAgBSAFKQJsNwN4IAUoAkAhBAJAIAJFDQAgBSgCfCEBIAJBAXQhA0EAIQJBACEGA0AgAiAPRg0BIAIgB2oiCCgCAEUNASABLwEAIgkgBnFB/x9xRQRAIAFBAmohASACQRBqIQIgBiAJciEGIANBAmsiA0UNAgwBCwsgBSAIQQxqKAIAQQAgCEEIaigCACIBGzYCjAEgBSABQQEgARs2AogBIAVBAzYClAEgBUG8z4ABNgKQASAFQgI3ApwBIAVBzAE2AmwgBUHEDTYCZCAFIAVB4ABqNgKYASAFIAVBiAFqNgJoIAUgBUE4ajYCYCAFQShqIAVBkAFqIgEQmQ4gBSAHNgKUASAFIAQ2ApABIAFBBEEQEOAeIAVB+ABqQQJBAhDgHiAFQdAAakEIQRAQ4B4MAgsgBSAHNgKUASAFIAQ2ApABIAVBkAFqIgFBBEEQEOAeIAUoAlghAiAFKAKAASEDIAUoAlQhBCAFKAJ8IQcgBUEANgKgASAFIAc2ApgBIAUgBDYCkAEgBSADIAIgAiADSxs2AqQBIAUgByADQQF0ajYCnAEgBSAEIAJBBHRqNgKUASMAQSBrIgIkACACQRRqIAEoAhQgASgCEGtBAEEIQRgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBlMKAARD9LwALIAVBKGohCSACQRBqIgpBADYCACACIAIoAhw2AgwgAiADNgIIIAEoAhQiCCABKAIQIgdrIgYgAkEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAZBCEEYEN4oIAMoAgghBAsgAyAHIAhHBH8gBCAIaiAHayABKAIAIAdBBHRqIQggASgCCCAHQQF0aiEHIAMoAgQgBEEYbGohAwNAIAhBCGopAwAhEiAIKQMAIRMgA0EQaiAHLwEAOwEAIANBCGogEjcDACADIBM3AwAgCEEQaiEIIAdBAmohByADQRhqIQMgBkEBayIGDQALBSAECzYCCCAJQQhqIAooAgA2AgAgCSACKQIINwIAIAJBIGokACAFQfgAakECQQIQ4B4gBUHQAGpBCEEQEOAeIAUoAjAhAyAFKAIsIQIgBSAFKAIoNgJoIAUgAjYCYCAFIAIgA0EYbGo2AmwgBSACNgJkIAVBmAFqQgA3AwAgBUIANwOQASMAQeAAayIIJAACQCAFQeAAaiIOKAIEIgIgDigCDCINRwRAIAhBDGohCiAIQShqIQ8gCEHIAGohCwNAIAsgAikDADcDACAOIAJBGGoiAzYCBCALQRBqIAJBEGopAwA3AwAgC0EIaiACQQhqKQMANwMAIAhBQGsgAUEIaiIQKQMANwMAIAggASkDADcDOCAIQThqIQcgCCkDSCESIAgpA1AhEyAILwFYIQYjAEGQAmsiAiQAIAIgEzcDuAEgAiASNwOwASAIQSBqIgQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGaEEBaw4LAQIDBAUGBwgJCgsACyACQuQANwPIASACIBI3A8ABIAJBEGogEiASQj+HQuQAQgAQqB4gAikDECISQj+HIhQgAikDGFINCyACQgw3A8gBIAIgEjcDwAEgAiASIBRCDEIAEKgeIAIpAwggAikDACISQj+HUgRAIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwYCyACIBNCDH5CgMDK84SjAn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMGAsgE0KAgICACH1C/////29YBEAgAkECNgLsASACQdTMgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwYCyACIAcoAggiCTYCwAEgAiATpyIGNgLIASAGQQBIIAkgBiAJaiIGSkYNGCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcUQNgKMAiACQcUQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYiAgIB4NgIEDBcLIAJCCjcDyAEgAiASNwPAASACQTBqIBIgEkI/h0IKQgAQqB4gAikDMCISQj+HIhQgAikDOFINFSACQgw3A8gBIAIgEjcDwAEgAkEgaiASIBRCDEIAEKgeIAIpAyggAikDICISQj+HUgRAIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwXCyACIBNCDH5CgIDpg7HeFn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMFwsgE0KAgICACH1C/////29YBEAgAkECNgLsASACQZTNgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwXCyACIAcoAggiCTYCwAEgAiATpyIGNgLIASAGQQBIIAkgBiAJaiIGSkYNFyACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcUQNgKMAiACQcUQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYiAgIB4NgIEDBYLIAJCDDcDyAEgAiASNwPAASACQUBrIBIgEkI/h0IMQgAQqB4gAikDSCACKQNAIhJCP4dSDRMgAiATQgx+QoCAmqbqr+MBfyITNwPIASACIBI3A8ABIBNCAFMgEiASIBN8IhNVRwRAIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwWCyATQoCAgIAIfUL/////b1gEQCACQQI2AuwBIAJB0M2AATYC6AEgAkIBNwL0ASACQccQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKAAiACIAJBsAFqNgLIASACQdgBaiACQegBahCZDiAEIAIpAtwBNwIMIARBFGogAkHkAWooAgA2AgAgBCACKALYATYCCCAEQYSAgIB4NgIEDBYLIAIgBygCCCIJNgLAASACIBOnIgY2AsgBIAZBAEggCSAGIAlqIgZKRg0WIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxRA2AowCIAJBxRA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBiICAgHg2AgQMFQsgEkKAgICACH1CgICAgHBUDREgAiAHKAIIIgk2AsABIAIgEqciBjYCyAEgBkEASCAJIAYgCWoiBkpGBEAgAiAHKAIMIgw2AsABIAIgE0IDfkKAgOmDsd4Wf6ciCTYCyAEgCUEASCAMIAkgDGoiCUpGDQoLIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxRA2AowCIAJBxRA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBiICAgHg2AgQMFAsgAkIHNwPIASACIBI3A8ABIAJB0ABqIBIgEkI/h0IHQgAQqB4gAikDWCACKQNQIhJCP4dSDQ8gEkKAgICACH1C/////29YBEAgAkECNgLsASACQcDOgAE2AugBIAJCATcC9AEgAkHHEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCgAIgAiACQbABajYCyAEgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGEgICAeDYCBAwUCyAHKAIIIQYgAiAHKAIMIgw2AsABIAIgEqciCTYCyAEgCUEASCAMIAkgDGoiCUpHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHFEDYCjAIgAkHFEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGIgICAeDYCBAwUCyACIAcpAwAiFDcDwAEgAiATQqAvfkKQzgB/IhI3A8gBIBJCAFMgFCASIBR8IhJVRg0VIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwTCyASQoCAgIAIfUKAgICAcFQNDSAHKAIIIQYgAiAHKAIMIgw2AsABIAIgEqciCTYCyAEgCUEASCAMIAkgDGoiCUpHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHFEDYCjAIgAkHFEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gBCACKQLcATcCDCAEQRRqIAJB5AFqKAIANgIAIAQgAigC2AE2AgggBEGIgICAeDYCBAwTCyACIAcpAwAiFDcDwAEgAiATQuAGfkKQzgB/IhI3A8gBIBJCAFMgFCASIBR8IhJVRg0UIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwSCyACQoDA4oXj6AA3A8gBIAIgEjcDwAEgAkHgAGogEiASQj+HQoDA4oXj6ABCABCoHiACKQNoIAIpA2AiEkI/h1INCyACIBNCJH5CkM4AfyITNwPIASACIBI3A8ABIBNCAFMgEiASIBN8IhNVRwRAIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwSCyAHKAIMIQkgBygCCCEGIAIgBykDACISNwPAASACIBM3A8gBIBNCAFMgEiASIBN8IhJVRg0TIAJBAjYC7AEgAkHAwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwRCyACQoCwncLfATcDyAEgAiASNwPAASACQfAAaiASIBJCP4dCgLCdwt8BQgAQqB4gAikDeCACKQNwIhJCP4dSDQkgAiATQgZ+QqCNBn8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMEQsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNEiACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMEAsgAkKAlOvcAzcDyAEgAiASNwPAASACQYABaiASIBJCP4dCgJTr3ANCABCoHiACKQOIASACKQOAASISQj+HUg0HIAIgE0LAhD1/IhM3A8gBIAIgEjcDwAEgE0IAUyASIBIgE3wiE1VHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDBALIAcoAgwhCSAHKAIIIQYgAiAHKQMAIhI3A8ABIAIgEzcDyAEgE0IAUyASIBIgE3wiElVGDREgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA8LIAJCwIQ9NwPIASACIBI3A8ABIAJBkAFqIBIgEkI/h0LAhD1CABCoHiACKQOYASACKQOQASISQj+HUg0FIAIgE0KAlOvcA38iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDwsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNECACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDgsgAkLoBzcDyAEgAiASNwPAASACQaABaiASIBJCP4dC6AdCABCoHiACKQOoASACKQOgASISQj+HUg0DIAIgE0KAoJSljR1/IhM3A8gBIAIgEjcDwAEgE0IAUyASIBIgE3wiE1VHBEAgAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA4LIAcoAgwhCSAHKAIIIQYgAiAHKQMAIhI3A8ABIAIgEzcDyAEgE0IAUyASIBIgE3wiElVGDQ8gAkECNgLsASACQcDCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDA0LIAIgE0KAgJqm6q/jAX8iEzcDyAEgAiASNwPAASATQgBTIBIgEiATfCITVUcEQCACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDQsgBygCDCEJIAcoAgghBiACIAcpAwAiEjcDwAEgAiATNwPIASATQgBTIBIgEiATfCISVUYNDiACQQI2AuwBIAJBwMKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMDAsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAsLIAcpAwAhEgwMCyACQQI2AuwBIAJB1MKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMCQsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAgLIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAwHCyACQQI2AuwBIAJB1MKAATYC6AEgAkICNwL0ASACQcYQNgKMAiACQcYQNgKEAiACIAJBgAJqNgLwASACIAJByAFqNgKIAiACIAJBwAFqNgKAAiACQdgBaiACQegBahCZDiACKQLYASESIAQgAikC4AE3AxAgBCASNwMIIARBiICAgHg2AgQMBgsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAULIAJBAjYC7AEgAkHwzoABNgLoASACQgE3AvQBIAJB7gY2AoQCIAIgAkGAAmo2AvABIAIgAkGwAWo2AoACIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBjYCAgHg2AgQMBAsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAMLIAJBAjYC7AEgAkGEzoABNgLoASACQgE3AvQBIAJBxxA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AoACIAIgAkGwAWo2AsgBIAJB2AFqIAJB6AFqEJkOIAQgAikC3AE3AgwgBEEUaiACQeQBaigCADYCACAEIAIoAtgBNgIIIARBhICAgHg2AgQMAgsgAkECNgLsASACQdTCgAE2AugBIAJCAjcC9AEgAkHGEDYCjAIgAkHGEDYChAIgAiACQYACajYC8AEgAiACQcgBajYCiAIgAiACQcABajYCgAIgAkHYAWogAkHoAWoQmQ4gAikC2AEhEiAEIAIpAuABNwMQIAQgEjcDCCAEQYiAgIB4NgIEDAELIAJBAjYC7AEgAkHUwoABNgLoASACQgI3AvQBIAJBxhA2AowCIAJBxhA2AoQCIAIgAkGAAmo2AvABIAIgAkHIAWo2AogCIAIgAkHAAWo2AoACIAJB2AFqIAJB6AFqEJkOIAIpAtgBIRIgBCACKQLgATcDECAEIBI3AwggBEGIgICAeDYCBAtBAQwCCyAHKQMAIRIgBygCDCEJCyAEIAk2AhQgBCAGNgIQIAQgEjcDCEEACzYCACACQZACaiQAIAgoAiAEQCAIQRhqIAhBNGooAgAiAjYCACAIQRBqIAhBLGopAgAiEjcDACAIIAgpAiQiEzcDCCAAQRRqIAI2AgAgAEEMaiASNwIAIAAgEzcCBCAAQQE2AgAMAwsgCiAPKQIANwIAIApBCGoiAiAPQQhqKQIANwIAIBAgAikCADcCACABIAopAgA3AgAgAyICIA1HDQALCyAAQQA2AgAgACABKQMANwMIIABBEGogAUEIaikDADcDAAsgCEHgAGokACAFIAUoAmA2ApQBIAUgBSgCaDYCkAEgAUEIQRgQ4B4MAgsgBUGQAWoiARCIESAFQQE2ApQBIAVB1M+AATYCkAEgBUIBNwKcASAFQcQNNgJkIAUgBUHgAGo2ApgBIAUgBUE4ajYCYCAFQShqIAEQmQ4gBUFAa0EEQRAQ4B4LIAUpAighEiAAIAUpAjA3AxAgACASNwMIIABCgYCAgMCAgICAfzcDAAsgBUGwAWokAA8LIAggB0EAIARBhMKAARCjNgALtQwCBH8BfiMAQUBqIgMkACADQQxqQaD+zwBBChCAICADQSxqIAIQ8icCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyABKAIgQYCAgIB4RwRAIANBLGoiBEGq/s8AQQNBCEEBEOgcIANBGGogAiAEELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiABKAIkIAEoAigQxSAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCLEGAgICAeEcEQCADQSxqIgRBrf7PAEEDQQhBAhDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCMCABKAI0EMUgIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEoAgAEQCABKQMIIQcgA0EsaiIEQbD+zwBBCkEHQQMQ6BwgA0EYaiACIAQQsBQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwCCyADQSxqIgQQhjAgBCACIAcQsRsgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCEARAIAEpAxghByADQSxqIgRBuv7PAEEOQQdBBBDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgBxCxGyADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwCCyACENMhCyABKAI4QYCAgIB4RwRAIANBLGoiBEHI/s8AQQlBCEEFEOgcIANBGGogAiAEELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiABKAI8IAEoAkAQxSAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAgsgAhDTIQsgASgCREGAgICAeEcEQCADQSxqIgRB0f7PAEEJQQhBBhDoHCADQRhqIAIgBBCwFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCSCABKAJMEMUgIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEtAFAiBUECRwRAIANBLGoiBEHa/s8AQRJBAkEHEOgcIANBGGogAiAEELAUIAMoAhgiBkEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAGNgIAIAQQhjAMAgsgA0EsaiIEEIYwIAQgAiAFQQFxEMYVIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAILIAIQ0yELIAEtAFEiBEECRwRAIANBLGoiAUHs/s8AQRJBAkEIEOgcIANBGGogAiABELAUIAMoAhgiBUEERwRAIAAgAykCHDcCBCAAQQxqIANBJGopAgA3AgAgACAFNgIAIAEQhjAMAgsgA0EsaiIBEIYwIAEgAiAEQQFxEMYVIAMoAiwiAUEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACABNgIADAILIAIQ0yELIANBLGogAhCrKSADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwBCyAAIAIQ6igLIANBDGoQ3jsgA0FAayQAC7NBAhV/BX4jAEGQAWsiByQAAkACQAJAAkACQAJAAkACQAJAIAEtAAxBIUYEQAJAIAFBEGoiCygCBEECTwRAIAEoAgghBCABKAIEIQMgB0EANgIgIAcgAzYCGCAHIAMgBEEDdGo2AhwgB0HQAGohDSMAQdAAayIIJAACQCAHQRhqIgkoAgAiAyAJKAIEIgxHBEAgCSgCCCEKIAhBHGohDyAIQSBqIQIgCEE8aiEOA0AgCSADQQhqIgQ2AgACQAJAAkAgAygCACIGRQ0AIAhBOGogBiADKAIEIgMoAghBAWtBeHFqQQhqIAMoAjgRAAAgCCgCOCIGRQ0AIAIgDikCADcCACACQRBqIA5BEGooAgA2AgAgAkEIaiAOQQhqKQIANwIAIAggBjYCHCAIIAo6ABggCCgCMEUEQCAGIAYoAgAiA0EBazYCACADQQFGBEAgDxD7HgsgCSAJKAIIQQFqIgo2AgggCSgCBCEMIAkoAgAhAwwDCyAIQQhqIgwgAkEIaikCADcDACAIQRBqIg4gAkEQaigCADYCACAIIAIpAgA3AwAgCCgCGCEPIAkgCkEBajYCCCAIQRhqIgJBBEEAQQRBHBCgGCAIKAIcIQQgCCgCGEEBRg0BIAgoAiAiAyAIKQMANwIIIAMgBjYCBCADIA82AgAgCEFAayISQQE2AgAgA0EQaiAMKQMANwIAIANBGGogDigCADYCACAIIAM2AjwgCCAENgI4IAhBIGogCUEIaigCADYCACAIIAkpAgA3AxggCEE4aiEGIwBB0ABrIgMkAAJAIAIoAgAiBCACKAIEIg9GDQAgAigCCCEKIANBIGohEyADQSRqIQwgA0E8aiEQA0AgBCEJA0AgAiAJQQhqIgQ2AgACfwJAIAkoAgAiDkUNACADQThqIA4gCSgCBCIJKAIIQQFrQXhxakEIaiAJKAI4EQAAIAMoAjgiCUUNACAMIBApAgA3AgAgDEEQaiIOIBBBEGooAgA2AgAgDEEIaiIRIBBBCGopAgA3AgAgAyAJNgIgIAMgCjoAHCADKAI0RQRAIAkgCSgCACIEQQFrNgIAIARBAUYEQCATEPseCyACIAIoAghBAWoiCjYCCCACKAIEIQ8gAigCAAwCCyADQRBqIhQgESkCADcDACADQRhqIhUgDigCADYCACADIAwpAgA3AwggAygCHCEWIAIgCkEBaiIKNgIIIAYoAggiESAGKAIARgRAIAYgEUEBQQRBHBDeKAsgBigCBCARQRxsaiIOIAk2AgQgDiAWNgIAIA4gAykDCDcCCCAOQRBqIBQpAwA3AgAgDkEYaiAVKAIANgIAIAYgEUEBajYCCCAEIA9HDQMMBAsgAiAKQQFqIgo2AgggBAsiCSAPRw0ACwsLIANB0ABqJAAgDUEIaiASKAIANgIAIA0gCCkCODcCAAwFCyAJIApBAWoiCjYCCCAEIQMMAQsgBCAIKAIgQcj/hQEQ/S8ACyADIAxHDQALCyANQQA2AgggDUKAgICAwAA3AgALIAhB0ABqJAAgBygCWCIJRQ0EIAcoAlQiBEEUaiEGIAkhAwNAIAUgBkEEaigCACAGKAIARmohBSAGQRxqIQYgA0EBayIDDQALIAUgCygCBEYNASABKAIkRQ0GIAdBIGogB0HYAGooAgA2AgAgByAHKQJQNwMYIAdBBGogASAHQRhqEPsNDAcLIAEoAghBA3QhBSABKAIEIQYgB0HsAGohBCAHQRtqIQkgB0EvaiEIA0AgBUUNA0EAIQMCQCAGKAIAIgpFDQAgB0HQAGogCiAGQQRqKAIAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgBygCUEUNAAJAIAEQuiZFBEAgB0H4AGogB0HgAGopAgA3AwAgB0HwAGogB0HYAGopAgA3AwAgByAHKQJQNwNoDAELQRxBBBCtNiIDRQ0NIAkgBykCUDcAACAJQRBqIAdB4ABqKQIANwAAIAlBCGogB0HYAGopAgA3AAAgA0EAOgAAIAMgBykAGDcAASADQQlqIAdBIGopAAA3AAAgA0ERaiAHQShqKQAANwAAIANBGGogCCgAADYAACAHQQE2AowBIAcgAzYCiAEgB0EBNgKEASAHQRhqIgMgASAHQYQBahD7DSAHQegAaiADEOEnCyAHQUBrIARBCGopAgA3AwAgB0HIAGogBEEQaigCADYCACAHIAQpAgA3AzggBygCaCEDCyAGQQhqIQYgBUEIayEFIANFDQALIAAgAzYCACAAIAcpAzg3AgQgAEEMaiAHQUBrKQMANwIAIABBFGogB0HIAGooAgA2AgAMBwsgCUEcbCEGIARBGGshAyABKAIgIQEgBCEFAkADQCAGRQRAIAlBHGwhBiAEQRhrIQUDQCAGRQ0DIAZBHGshBiAFQRxqIQUgBCgCFCEDIARBHGohBCABIANPDQALIAAgBUEAIAEQsR8MBgsgBkEcayEGIANBHGohAyAFKAIUIQggBUEcaiEFIAEgCEcNAAsgAygCACIEIAQoAgAiBUEBajYCACAFQQBIDQkgACABNgIQIAAgBDYCACAAIANBFGooAgA2AhQgACADQQxqKAIANgIMIAAgA0EEaikCADcCBAwECyAAIAEQ5ToMAwtByIWGAUEoQfSIhgEQnykACyAAQQA2AgAMBAsgAEEANgIACyAHQdAAaiIAENsmIABBBEEcEOAeDAILIAsoAgQhAyALKAIEIQQgCygCBCEIIAdBgwI7ATQgB0GCAjsBLCAHQQE6ACQgByADQQFrNgIgIAdBgAI7ARxBACEGIAdBADYCGCAHIAggBWs2AjAgByAJNgIoIAcgBCAJRjoAJQNAIAZBIEYNAyAHQRhqIgQgBmogBkEIaiIDIQZBBWotAABBAUcNAAsgAyAEaiIGQQhrIQQCQCADQSBGBEAgBCEDDAELQSAgA2tBA3YhBSAEIQMDQCAGQQVqLQAAQQFGBEAgBiAEIAYoAgAgBCgCAEkiCRshBCAGIAMgCRshAwsgBkEIaiEGIAVBAWsiBQ0ACwsCQAJAAkACQCADLQAEQQFrDgMBAgMACyAHQfAAaiAHQdgAaigCADYCACAHIAcpAlA3A2ggB0EEaiABIAdB6ABqEPsNDAMLIAdB8ABqIAdB2ABqKAIANgIAIAcgBykCUDcDaCAHQQRqIRIjAEHgAGsiAiQAIAJBEGogB0HoAGoiDygCBCIDIAMgDygCCEEcbGoQwxsgAkEcaiACKAIUIgMgAyACKAIYQRhsahDCGyABKAIcIQggAiABKAIgIg5BA3YiAUH4////AXEiDDYCREHAACEEAkACQAJAAkACQAJAIAFBwP///wFxQUBrIAwgDkHAA3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIERQ0CCyAOQUBxIQogBCEFIA5BwABPBEAgCiEJIAghAwNAIAIoAiQiAUUNBCACKAIgIQYCfiABQRhsIgFBGEYEQEIAIRlCfwwBCyAGQRhqIRMgAUEYa0EYbiEUQQAhDUIAIRhCACEZA0AgEyANQRhsaiIBKAIUIhAgASgCEE8NByABKAIEIBBBA3RqIhUpAAAhGyABKAIMIhEEQCAVQQhqMQAAQQAgEWtBP3GthiAbIBFBP3GtiIQhGwsgASAQQQFqNgIUQgAhFyABLQAAIRAgAyEBQgAhGgNAIAEtAAAgEEatIBeGIBqEIRogAUEBaiEBIBdCAXwiF0LAAFINAAsgGCAahCEYIBogG4MgGYQhGSANQQFqIg0gFEcNAAsgGEJ/hQshGCAGKAIUIgEgBigCEE8NBiAGKAIEIAFBA3RqIhApAAAhFyAGKAIMIg0EQCAQQQhqMQAAQQAgDWtBP3GthiAXIA1BP3GtiIQhFwsgA0FAayEDIAYgAUEBajYCFCAFIBcgGIMgGYQ3AAAgBUEIaiEFIAlBQGoiCQ0ACwsgAiAFIARrIgE2AjggASAMRw0FIAIgDDYCNCACIAQ2AjAgAiALNgIsQcAAIQEgAkHAADYCKCAOQT9xIgUEQAJAIAIoAhgiEEUEQEIAIRgMAQsgCCAKaiEDIAIoAhQhCiAFrSEbQgAhGEEAIQkDQEIAIRkgCiAJQRhsaiIFKAIUIggEQCAFKAIEIAUoAhBBA3RqIgYxAAAgBSgCDCIBQT9xrYghFyABIAhqIg1BA3YgDUEHcUEAR2oiDUECTwRAQQggAWshASANQQFrIQ0gBkEBaiEGA0AgBjEAACABQT9xrYYgF4QhFyAGQQFqIQYgAUEIaiEBIA1BAWsiDQ0ACwsgF0J/IAhBP3GthkJ/hYMhGQtCACEXIAUtAAAhBSADIQFCACEaA0AgAS0AACAFRq0gF4YgGoQhGiABQQFqIQEgGyAXQgF8IhdSDQALIBkgGoMgGIQhGCAJQQFqIgkgEEcNAAsLIAsgDEEIaiIBSQR/IAJBKGogC0EBdCIDIAFBwP///wNxQUBrIAEgAUE4cRsiASABIANJGxDoGSACKAI0IQwgAigCMAUgBAsgDGogGDcAACACIAIoAjRBCGoiDDYCNCACKAIwIQQgAigCLCELIAIoAighAQsgAiALNgJYIAIgATYCVCACQQA2AlAgAiAMNgJMIAIgBDYCSCACQQhqIAJByABqENc7IAIoAgghA0EcQQQQrTYiAUUNDSABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAJB0ABqKQIANwIAIAFBGGogAkHYAGooAgA2AgAgAiAMNgJAIAIgAzYCPCACIAE2AjggEiACQThqQQAgDhDyFSACQRxqQQRBGBDgHiACQRBqQQRBGBDgHiAPENsmIA9BBEEcEOAeIAJB4ABqJAAMBgtBsP6FAUEpIAJByABqQdj/hQFB3P6FARDVHgALQcAAIAsQoz0AC0EBQQBBkIaGARCvOwALQbCGhgEQsjsAC0GghoYBELI7AAsgAkIANwJUIAJCgYCAgMAANwJMIAJBoP+FATYCSEEAIAJBOGogAkHEAGogAkHIAGpBqP+FARCvKwALDAILIAdB8ABqIAdB2ABqKAIANgIAIAcgBykCUDcDaCAHQQRqIRMjAEHgAGsiAiQAIAJBDGogB0HoAGoiDigCBCIDIAMgDigCCEEcbGoQwxsgAkEYaiACKAIQIgMgAyACKAIUQRhsahDCGyABKAIcIQggAiABKAIgIg1BA3YiA0H4////AXEiBjYCNEHAACEBAkACQAJAIANBwP///wFxQUBrIAYgDUHAA3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiIBRQ0CCyABIQMgDUHAAE8EQEEAIA1BQHFrIQsgCCEEA0AgAiACKAIcIgUgAigCIEEYbGo2AlQgAiAFNgJQIAIgBDYCWCACQThqIQ9CACEYQgAhGgJAAkAgAkHQAGoiBSgCACIQIAUoAgQiDEcEQCAFKAIIIQogDCAQa0EYbiEUQQAhDANAIBAgDEEYbGoiBSgCFCIRIAUoAhBPDQIgBSgCBCARQQN0aiIVKQAAIRkgBSgCDCISBEAgFUEIajEAAEEAIBJrQT9xrYYgGSASQT9xrYiEIRkLIAUgEUEBajYCFEIAIRsgBS0AACERIAohBUIAIRcDQCAFLQAAIBFGrSAbhiAXhCEXIAVBAWohBSAbQgF8IhtCwABSDQALIBcgGoQhGiAXIBmDIBiEIRggDEEBaiIMIBRHDQALCyAPIBg3AwggDyAaNwMADAELQYTmhAEQsjsACyADIAIpA0AgAikDOEJ/hYQ3AAAgA0EIaiEDIARBQGshBCALQUBrIgsNAAsLIAIgAyABayIDNgJQIAMgBkcNAiACIAY2AjAgAiABNgIsIAIgCTYCKEHAACEDIAJBwAA2AiQgDUE/cSIEBEAgAigCFCEFIAIoAhAhAyACIAQ2AlwgAiAIIA1BQHFqNgJYIAIgAzYCUCACIAMgBUEYbGo2AlRCACEaQgAhGUEAIQUgAkHQAGoiAygCACIKIAMoAgQiBEcEQCADKAIMIQsgAygCCCEQIAQgCmtBGG4hEQNAQgAhGEIAIRcgCiAFQRhsaiIEKAIUIgwEQCAEKAIEIAQoAhBBA3RqIggxAAAgBCgCDCIDQT9xrYghFyADIAxqIg9BA3YgD0EHcUEAR2oiD0ECTwRAQQggA2shAyAPQQFrIQ8gCEEBaiEIA0AgCDEAACADQT9xrYYgF4QhFyAIQQFqIQggA0EIaiEDIA9BAWsiDw0ACwsgF0J/IAxBP3GthkJ/hYMhFwsgCwRAQQAhAyAELQAAIQQDQCADIBBqLQAAIARGrSADQT9xrYYgGIQhGCALIANBAWoiA0cNAAsLIBggGYQhGSAXIBiDIBqEIRogBUEBaiIFIBFHDQALCyACQThqIgMgGjcDCCADIBk3AwAgAikDQCACKQM4Qn+FhCEXIAkgBkEIaiIDSQR/IAJBJGogCUEBdCIBIANBwP///wNxQUBrIAMgA0E4cRsiAyABIANLGxDoGSACKAIwIQYgAigCLAUgAQsgBmogFzcAACACIAIoAjBBCGoiBjYCMCACKAIoIQkgAigCJCEDIAIoAiwhAQsgAiAJNgJIIAIgAzYCRCACQQA2AkAgAiAGNgI8IAIgATYCOCACIAJBOGoQ1zsgAigCACEDQRxBBBCtNiIBRQ0JIAFCgYCAgBA3AgAgASACKQI4NwIIIAFBEGogAkFAaykCADcCACABQRhqIAJByABqKAIANgIAIAIgBjYCWCACIAM2AlQgAiABNgJQIBMgAkHQAGpBACANEPIVIAJBGGpBBEEYEOAeIAJBDGpBBEEYEOAeIA4Q2yYgDkEEQRwQ4B4gAkHgAGokAAwDC0Gw/oUBQSkgAkE4akHY/4UBQdz+hQEQ1R4AC0HAACAJEKM9AAsgAkIANwJEIAJCgYCAgMAANwI8IAJBoP+FATYCOEEAIAJB0ABqIAJBNGogAkE4akGo/4UBEK8rAAsMAQsgB0HwAGogB0HYAGooAgA2AgAgByAHKQJQNwNoIAdBBGohESAHQegAaiEJIwBB0AFrIgIkAAJAAkACQAJAAkACQCABLQAMQSFGBEAgAkEIaiABQRBqELAuIAIoAgwhCyACKAIIIQQgAkEwaiIMQYSAhgEQpSsgAkH4AGoiA0Go/oUBKQMAIhc3AwAgAkGIAWoiCCACKQM4NwMAIAJBgAFqIgogAikDMDcDACACQaD+hQEpAwAiGDcDcCMAQRBrIg0kACALIARrQQN2IgZBAWpBAXYgBiACQfAAaiIFKAIMGyIOIAUoAghLBEAgDUEIaiAFIA4gBUEQahCWBAsgBCALRwRAA0AgBSAELQAAEPUMIARBCGohBCAGQQFrIgYNAAsLIA1BEGokACACQShqIAgpAwA3AwAgAkEgaiAKKQMANwMAIAJBGGogAykDADcDACACIAIpA3A3AxAgCUEIaiINKAIAIQYgCSgCBCEEIAxBhICGARClKyADIBc3AwAgCCACKQM4NwMAIAogAikDMDcDACACIBg3A3AjAEEQayILJAAgBCAGQRxsaiIOIARrQRxuIgZBAWpBAXYgBiAFKAIMGyIPIAUoAghLBEAgC0EIaiAFIA8gBUEQahCWBAsgBCAORwRAA0AgBSAELQAAEPUMIARBHGohBCAGQQFrIgYNAAsLIAtBEGokACACQcgAaiAIKQMANwMAIAJBQGsgCikDADcDACACQThqIAMpAwA3AwAgAiACKQNwNwMwIAIoAhAiAykDACEXIAIoAhQhBCACIAIoAhw2AogBIAIgAzYCgAEgAiADIARqQQFqNgJ8IAIgA0EIajYCeCACIBdCf4VCgIGChIiQoMCAf4M3A3AgAiAMNgKQASACQdQAaiEIIwBBQGoiAyQAIANBCGogBRCNEgJAAkACQCADLQAIBEAgAy0ACSEGIANBGGoiCkEIQQBBAUEBEKAYIAMoAhwhBCADKAIYQQFGDQIgAygCICILIAY6AAAgA0EUaiIMQQE2AgAgAyALNgIQIAMgBDYCDCAKIAVBKPwKAAAjAEEQayIEJAAgBEEIaiAKEI0SIAQtAAgEQCADQQxqIQUgBC0ACSEGA0AgBSgCCCILIAUoAgBGBEAgBUEBEIEuCyAFKAIEIAtqIAY6AAAgBSALQQFqNgIIIAQgChCNEiAELQABIQYgBC0AAA0ACwsgBEEQaiQAIAhBCGogDCgCADYCACAIIAMpAgw3AgAMAQsgCEEANgIIIAhCgICAgBA3AgALIANBQGskAAwBCyAEIAMoAiBByP+FARD9LwALIwBBEGsiAyQAIAkoAggiCARAIAlBADYCCCADIAg2AgwgA0IANwIEIAMgCTYCAAJAIAMoAgQiBSAIRg0AIAMoAgAoAgQgBUEcbGpBFGohBANAIARBBGooAgAgBCgCAE8EQCADIAVBAWo2AgQgAyADKAIIQQFqNgIIIARBEGsiBCgCACIFIAUoAgAiBUEBazYCACAFQQFHDQIgBBD7HgwCCyAEQRxqIQQgCCAFQQFqIgVHDQALIAMgBTYCBAsgCCADKAIEIgRHBEADQAJAIAMoAgAoAgQiCiAEQRxsaiIFKAIYIAUoAhRPBEAgAyAEQQFqNgIEIAMgAygCCEEBajYCCCAFKAIEIgQgBCgCACIEQQFrNgIAIARBAUcNASAFQQRqEPseDAELIAMgBEEBajYCBCAKIAQgAygCCGtBHGxqIgQgBSkCADcCACAEQQhqIAVBCGopAgA3AgAgBEEQaiAFQRBqKQIANwIAIARBGGogBUEYaigCADYCAAsgAygCBCIEIAhHDQALCyADKAIMIQQgAygCACEFAkAgAygCCCIIRQ0AIAQgAygCBCIKa0EcbCIGRQ0AIAUoAgQiCyAKIAhrQRxsaiALIApBHGxqIAb8CgAACyAFIAQgCGs2AggLIANBEGokACACQegAaiANKAIAIgM2AgAgAiAJKQIANwNgIAJBmAFqIAIoAmQiBCAEIANBHGxqEMMbIAJBpAFqIAIoApwBIgMgAyACKAKgAUEYbGoQwhsgASgCHCEIIAIgASgCICINQQN2IgFB+P///wFxIgs2AswBQcAAIQkgAUHA////AXFBQGsgCyANQcADcRsiDEHAABDRNEUNASAMBEAgDEHAABCtNiIJRQ0DCyANQUBxIQogCSEFIA1BwABPBEAgAigCXCEOIAIoAlghEiAKIQQgCCEDA0BCACEaQgAhGSACKAKsASITBEAgAigCqAEhFEEAIQYDQCAUIAZBGGxqIgEoAhQiDyABKAIQTw0HIAEoAgQgD0EDdGoiFSkAACEbIAEoAgwiEARAIBVBCGoxAABBACAQa0E/ca2GIBsgEEE/ca2IhCEbCyABIA9BAWo2AhQgG1BFBEBCACEXIAEtAAAhDyADIQFCACEYA0AgAS0AACAPRq0gF4YgGIQhGCABQQFqIQEgF0IBfCIXQsAAUg0ACyAYIBuDIBmEIRkLIAZBAWoiBiATRw0ACwsgDgRAQQAhBgNAIAYgEmotAAAhDyADIQFCACEXQgAhGANAIAEtAAAgD0atIBeGIBiEIRggAUEBaiEBIBdCAXwiF0LAAFINAAsgGCAahCEaIAZBAWoiBiAORw0ACwsgA0FAayEDIAUgGSAahDcAACAFQQhqIQUgBEFAaiIEDQALCyACIAUgCWsiATYCwAEgASALRw0EIAIgCzYCvAEgAiAJNgK4ASACIAw2ArQBQcAAIQEgAkHAADYCsAEgDUE/cSIOBEAgCCAKaiEEQgAhGkIAIRkgAigCoAEiCgRAIAIoApwBIQ8gDq0hG0EAIQUDQCAPIAVBGGxqIgMtAAAhCCAEIQFCACEXQgAhGANAIAEtAAAgCEatIBeGIBiEIRggAUEBaiEBIBsgF0IBfCIXUg0ACyADKAIUIggEfiADKAIEIAMoAhBBA3RqIgYxAAAgAygCDCIBQT9xrYghFyABIAhqIgNBA3YgA0EHcUEAR2oiA0ECTwRAQQggAWshASADQQFrIQMgBkEBaiEGA0AgBjEAACABQT9xrYYgF4QhFyAGQQFqIQYgAUEIaiEBIANBAWsiAw0ACwsgF0J/IAhBP3GthkJ/hYMFQgALIBiDIBmEIRkgBUEBaiIFIApHDQALCyACKAJcIgUEQCACKAJYIQhBACEDA0AgAyAIai0AACEKQQAhAUIAIRcDQCABIARqLQAAIApGrSABQT9xrYYgF4QhFyAOIAFBAWoiAUcNAAsgFyAahCEaIANBAWoiAyAFRw0ACwsgDCALQQhqIgFJBH8gAkGwAWogDEEBdCIDIAFBwP///wNxQUBrIAEgAUE4cRsiASABIANJGxDoGSACKAK8ASELIAIoArgBBSAJCyALaiAZIBqENwAAIAIgAigCvAFBCGoiCzYCvAEgAigCuAEhCSACKAK0ASEMIAIoArABIQELIAIgDDYCgAEgAiABNgJ8IAJBADYCeCACIAs2AnQgAiAJNgJwIAIgAkHwAGoQ1zsgAigCACEDQRxBBBCtNiIBRQ0FIAFCgYCAgBA3AgAgASACKQJwNwIIIAFBEGogAkH4AGopAgA3AgAgAUEYaiACQYABaigCADYCACACIAs2AsgBIAIgAzYCxAEgAiABNgLAASARIAJBwAFqQQAgDRDyFSACQaQBakEEQRgQ4B4gAkGYAWpBBEEYEOAeIAJB4ABqIgEQ2yYgAUEEQRwQ4B4gAkHUAGoQ3jsgAkEwakEBQQgQ2ScgAkEQakEBQQgQ2ScgAkHQAWokAAwGCyACQQA2AoABIAJBATYCdCACQaCFhgE2AnAgAkIENwJ4IAJB8ABqQfCFhgEQ7ywAC0Gw/oUBQSkgAkHwAGpB2P+FAUHc/oUBENUeAAtBwAAgDBCjPQALQYCGhgEQsjsACyACQgA3AnwgAkKBgICAwAA3AnQgAkGg/4UBNgJwQQAgAkHAAWogAkHMAWogAkHwAGpBqP+FARCvKwALQQRBHBCjPQALCyAHQRhqIgEgB0EEahDhJyAHKAIsRQRAIABBADYCACAHKAIYIgAgACgCACIAQQFrNgIAIABBAUcNASABEPseDAELIAAgBykCGDcCACAAQRBqIAdBKGopAgA3AgAgAEEIaiAHQSBqKQIANwIACyAHQZABaiQADwtB5IiGARCyOwsAC0EEQRwQoz0AC44OAwp/BH4BbyMAQbADayICJAACQCAAAn8CQAJAAkACQAJAAn8CQAJAAkACQAJAIAAtALgGQQFrDgMCDAEACyAAQZgDaiAAQZgD/AoAAAsgAEGYA2ohCAJAAkACQAJAIAAtAKwGQQFrDgMCDgABCyAAQZAGaiEGAkAgAC0AkAZBAWsOAwMOCAALIAAoAogGIQMgACgCmANBAXFFDQUgACgCnAMhBAwECyAAQaAGaiAAKAKYBhCFIyAAQQA6AJAGIAAgACgCoAYiAzYCiAYgACAAKAKcBiIENgKcAyAAIARBAEc2ApgDIABBkAZqIQYgBA0DDAQLQZzcwgAQ6CsAC0G83MIAEOgrAAtB3MjCABDoKwALIAJB6ABqIAQQxwcCQCACKAJoIgRBAmsOAgQBAAsgAigCbCEFIAJBEGoiByACQfAAakEw/AoAACAAIAU2AqQDIAAgBDYCoAMgAEGoA2ogB0Ew/AoAACAAQaADagwBCyAAQYCAgIB4NgLAAyAAQQA2AqADIABBgICAgHg2AswDIABBADYCsAMgAEEANgKoAyAAQQA2ArgDIABBoANqCyEEIAICfiADKAIAQQFGBEAgAkGYA2ogA0EQahDdICADKAIcIgUgBSgCACIHQQFqNgIAIAdBAEgNCCACQagCaiACQaADaigCADYCACACIAIpApgDNwOgAiACIAU2AqwCIAIgAykDCDcDmAJCAQwBCyACIAMoAhAQ9Do2AqACIAIgAykDGDcDqAIgAiADKQMINwOYAkIACzcDkAIgAkHoAGoiBSACQZACaiADQSBqIAQQ8BMgAkHIAGoiAyACQfgAaikDADcDACACIAIpA3A3A0ACQAJAIAIpA2giDEICUQRAIAJB8ABqIAMpAwA3AwAgAiACKQNANwNoIAUQ0xkhAQwBCyACQZACaiIDIAJBgAFqIglB4AD8CgAAIAAgDDcD2AMgACACKQNANwPgAyAAQegDaiACQcgAaikDADcDACAAQfADaiADQeAA/AoAACAAKAK8BCIFIAUoAgAiB0EBajYCACAHQQBIDQggAEGMBmoiByAFNgIAIAMgAEHYA2pB+AD8CgAAIAJB6ABqIgUgAxDKBSACQdgAaiIDIAJB+ABqIgopAwA3AwAgAkHgAGoiCyAJKQMANwMAIAIgAikDcDcDUCACKQNoIgxCA1INASAKIAspAwA3AwAgAkHwAGogAykDADcDACACIAIpA1A3A2ggBRDSGSEBIAcoAgAiAyADKAIAIgNBAWs2AgAgA0EBRw0AIAcQ+CMLIAQQgSoMAwsgAkGQAmoiAyACQYgBakGIAfwKAAAgAkGoA2ogAkHgAGopAwAiDTcDACACQaADaiACQdgAaikDACIONwMAIAIgAikDUCIPNwOYAyAAIAw3A9AEIAAgDzcD2AQgAEHgBGogDjcDACAAQegEaiANNwMAIABB8ARqIANBiAH8CgAAIABBADYCgAYgAEKAgICAwAA3A/gFCyACQegAaiAAQdAEaiIFIAEQ5BEgAigCaCIDQQlGBEAgBkEDOgAAQQIhA0EDDAULIAIpA3ghDCACKAJ0IQYgAigCcCEBIAIoAmwhBCAFEMIKIANBCEYNAiACIAw3A3ggAiAGNgJ0IAIgATYCcCACIAQ2AmwgAiADNgJoQcTKwgBBKyACQegAakGAy8IAQczcwgAQ1R4ACyACKAJsEIAYIQELQQEhAyAGQQE6AAAgCBDIIwwBCyAAKAKMBiEFIABBoANqEIEqQQEhAyAAQQE6AJAGIARBgYCAgHhGBEBBAiEDQQMMAgsgCBDIIyAEQYCAgIB4Rg0AIAIgBTYCdCACIAY2AnAgAiABNgJsIAIgBDYCaEEAIQMjAEEgayIEJAAgBEEYaiACQegAaiIBQQhqKQIANwIAIARBADYCDCAEIAEpAgA3AhAgBEEMahCeJ0EIahAKIRAQ3xIiASAQJgEgBEEgaiQACyAAQaAGahDkKkEBCzoArAZBAyEEAkAgA0ECRiIGDQAgCBCcLwJAIANBAXEEQCACIAE2ApACIAJBgAE2AmggAiAAQbQGaiACQegAaiACQZACahDCIyACKAIAIAIoAgQQ1i8iAUGEAU8EQCABEPIfCyACKAJoIgFBhAFPBEAgARDyHwsgAigCkAIiAUGEAUkNASABEPIfDAELIAIgATYCkAIgAkGAATYCaCACQQhqIABBsAZqIAJB6ABqIAJBkAJqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoAmgiAUGEAU8EQCABEPIfCyACKAKQAiIBQYQBSQ0AIAEQ8h8LIAAoArAGIgFBhAFPBEAgARDyHwtBASEEIAAoArQGIgFBhAFJDQAgARDyHwsgACAEOgC4BiACQbADaiQAIAYPCwAL1hMCEX8BfiMAQYADayICJAAgASkCiAIhEyABQoCAgIAQNwOIAiACQfAAaiABQZACaiIDKAIANgIAIANBADYCACACIBM3A2ggAkHIAWohCCMAQTBrIgYkAEHAACEEIAJB6ABqIgkoAgQhBSAJKAIAIQoCQAJAIAkoAggiB0EDdiAHQQdxQQBHaiIDQcD///8BcUFAayADIANBP3EbIgNBwAAQ0TQEQCADBEAgA0HAABCtNiIERQ0CCyAGQgA3AhggBiAENgIUIAYgAzYCECAGQcAANgIMIAYgBSAHajYCLCAGIAo2AiggBiAFNgIkIAYgBTYCICAGQQxqIQcjAEEQayIKJAAgBkEgaiILKAIEIgMgCygCDCIQRwRAA0AgCyADQQFqIgQ2AgQgAy0AACAHKAIQIg1BAWoiDkEDdiAOQQdxQQBHaiIFIAcoAgwiA0sEQCAFIANrIQ8gBygCBCIMIAVJBEACQCAFIgNBP3EiEkUNACADIAMgEmtBQGsiA00NAEHcgs4AQSNBgIPOABDLJAALIAcgDEEBdCIMIAMgAyAMSRsQ6BkgBygCDCEDCyAPBEAgBygCCCADakEAIA/8CwALIAcgBTYCDAsgByAONgIQQQFxBEAgBygCCCANQQN2aiIDIAMtAABBASANQQdxdHI6AAALIAQiAyAQRw0ACwsgCiALKAIANgIMIAogCygCCDYCCCAKQQhqEN47IApBEGokACAIIAcQ/BMgBxDPLyAGQTBqJAAMAgtBtKzNAEEpIAZBDGpBmLPNAEHgrM0AENUeAAtBwAAgAxCjPQALIAJBCGogAkHQAWooAgA2AgAgAiACKQLIATcDACACQQA7AaACIAJBADYCnAIgAkEANgKEAiACQQA2AvgBIAJBAToA6AEgAkIENwLgASACQgA3AtgBIAJCgICAgMAANwLQASACQQA2AsgBIAIgASgCpAI2AvQBIAkgCCACEPojIAggARDWGCACQQxqIgMgCSAIEK4WIAggAxDNHCAJIAgQ0RACQAJAAkACQAJAQTRBBBCtNiIDBEAgA0KBgICAEDcCACADQQhqIAlBLPwKAAAgAkG02c0ANgKoAiACIAM2AqQCAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQdACaiIDLQAAIgVBAmsOBgECDw8DBAALAkACQCAFQSJrDgUBEAwNDgALIAVBD0YNBQwPCyABKALYAi0AAEEjaw4EBQYHCAkLQci8zQBB3OLNABC4CEUNDUHo4s0AELI7AAtByLzNAEHc4s0AELgIRQ0MQdDjzQAQsjsAC0HIvM0AQdzizQAQuAhFDQtBuOTNABCyOwALQci8zQBB3OLNABC4CEUNCkGg5c0AELI7AAtByLzNAEHc4s0AELgIRQ0JIAJByAFqIAJBpAJqQbTIzQBBiObNABDpIyACKALQASEFIAIoAswBIQQgAigCyAEiBkGTgICAeEcEQCACIAIpAtQBNwK4AiACIAU2ArQCIAIgBDYCsAIgAiAGNgKsAiAAIAJBrAJqEKYlDAwLIAIgBTYCbCACIAQ2AmggAkHIAWogAkHoAGoiBEG0yM0AIAMQ6SMgAigC0AEhAyACKALMASEFIAIoAsgBIgZBk4CAgHhHBEAgAiACKQLUATcCzAIgAiADNgLIAiACIAU2AsQCIAIgBjYCwAIgACACQcACahCmJSACKAJoIgAgACgCACIAQQFrNgIAIABBAUcNDCAEELsjDAwLIAIoAmgiBCAEKAIAIgRBAWs2AgAgBEEBRw0KIAJB6ABqELsjDAoLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAoLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAkLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAgLIAJBAjYCzAEgAkHM5s0ANgLIASACQgE3AtQBIAJBrwM2AmwgAkHIvM0ANgLUAiACIAJB6ABqNgLQASACIAJB1AJqNgJoIABBBGogAkHIAWoQohggAEEDNgIADAcLIAJByAFqIAJBpAJqQbTIzQAgAxDpIyACKALQASEDIAIoAswBIQUgAigCyAEiBEGTgICAeEYNBSACIAIpAtQBNwLkAiACIAM2AuACIAIgBTYC3AIgAiAENgLYAiAAIAJB2AJqEKYlDAYLQci8zQBB3OLNABC4CEUNAyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwFCyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwECyACQQI2AswBIAJBiOnNADYCyAEgAkIBNwLUASACQa8DNgJsIAJByLzNADYC1AIgAiACQegAajYC0AEgAiACQdQCajYCaCAAQQRqIAJByAFqEJkOIABBAzYCAAwDC0EEQTQQoz0ACyACQcgBaiACQaQCakG0yM0AIAMQ6SMgAigC0AEhAyACKALMASEFIAIoAsgBIgRBk4CAgHhGDQAgAiACKQLUATcC+AIgAiADNgL0AiACIAU2AvACIAIgBDYC7AIgACACQewCahCmJQwBCwJ/QYCAgIB4IAEoAuABIgRBgYCAgHhGDQAaQYCAgIB4IARBgICAgHhGDQAaIAEpAuQBIRMgAUEANgLoASABQoCAgIAgNwPgASAECyEEIAFBuAJqELQwIAEgEzcCvAIgASAENgK4AiABKAKUAiIEQYCAgIB4RwRAIAEpA5gCIRMgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASATNwPIAiABIAQ2AsQCIAFCADcCpAIgACADNgIIIAAgBTYCBCAAQQg2AgAgAigCpAIiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAIoAqQCIgAgACgCACIAQQFrNgIAIABBAUcNAQsgAkGkAmoQuyMLIAJBgANqJAAL53gCN38CfiMAQbABayIJJAAgCUHQAGogARDcOyAJKAJUIQIgCSgCUCAJQdsANgKAASACIAlBgAFqIilBARD0LiEDIAlByABqIAEQ3DsgCSgCTCECIAkoAkghCgJAAkACQAJ/AkACfwJAAkACQAJAAkACQAJAIANFBEAgCUHcAGohCCMAQSBrIgQkACAEIAIgCmoiAjYCECAEIAo2AgwCQAJAAkADQCAEKAIMIgMgBCgCECIFRg0BA0AgAy0AAEElRwRAIAUgA0EBaiIDRw0BDAMLCyAEIANBAWo2AgwgBEEIaiAEQQxqEKoZIAQtAAhFDQALIAQoAgwiDCACIAprIgMgBCgCECIOa2pBA2siBSADTQRAIAQtAAkhIiAEQRRqIQYjAEEQayICJAAgAkEEaiAFQQBBAUEBEKAYIAIoAgghFAJAIAIoAgRBAUcEQCACKAIMIQsgBQRAIAsgCiAF/AoAAAsgBiAFNgIIIAYgCzYCBCAGIBQ2AgAgAkEQaiQADAELIBQgAigCDEGgscwAEP0vAAsgBCgCHCICIAQoAhRGBEAgBkHQt8wAEKkZCyAEKAIYIAJqICI6AAAgBCACQQFqNgIcIwBBIGsiBiQAIAYgDjYCHCAGIAw2AhggBkEQaiAGQRhqEJchIAYtABAEQCAGLQARIRQgBEEUaiILKAIIIQIDQCALKAIAIAJGBEAgCyACIAYoAhwgBigCGGtBAmpBA25BAWoQxigLIAsgAkEBaiIFNgIIIAsoAgQgAmogFDoAACAGQQhqIAZBGGoQlyEgBi0ACSEUIAUhAiAGLQAIDQALCyAGQSBqJAAgBCgCFCICQYCAgIB4Rg0CIAggBCkCGDcCBCAIIAI2AgAMAwsgBSADQcC3zAAQsDsACyACIAprIQMLIAggAzYCCCAIIAo2AgQgCEGAgICAeDYCAAsgBEEgaiQAIAEoAgAhNCAJIAggASAJKAJcIgJBgICAgHhHIjUbKQIENwKEASAJIAIgNCA1GzYCgAEjAEEwayI2JAAgNkEMaiICQZCszAA2AhAgAkHBADoADiACQcEAOwEMIAJB0MvIADYCCCACQcieyAA2AgQgAkGggswANgIAIAJBpI3IADYCICACQZDNxgA2AhwgAkGc1scANgIYIAJBqPnFADYCFCAJQfQAaiEsIwBBIGsiGSQAIBlBADYCDCAZQoCAgIAQNwIEICkoAgQhJCApKAIIIRwgGUEEaiESQQAhBUEAIQsjAEHwCGsiDSQAIA1BADYCACANQQA2AvgHIA1BADYC/AcgDUEANgLgCAJAAkACQCAcRQ0AIBwgJGohAyAkIQQDQAJAIAUgJGoiBi0AACIKQeEAa0H/AXFBGk8EQCAKQS5HDQEgBkEBaiEECyAcIAVBAWoiBUcNAQwCCwsgDUHkCGohEyACIR0gBCEiIwBB0AhrIgckACAHQv////+HgICAkH83A4gBIAdC/////5+FoIBUNwOAASAHQQA6AJMBIA1B/AdqIhhBBGohFCAYQeQAaiElIA1BBGohCiANQfgHaiEaIBwgAyAEayImayEqIAdB1AZqITcgB0HAAmohLiAHQbQBaiEnQQEhBAJAA0AgIiECAkACQANAAkACQAJAICYEQEEAIQUCfwJAA0AgAiAFaiIGLQAAIgNBLkYNASAmIAVBAWoiBUcNAAsgJiEFIAIMAQsgBUF/cyAmaiEmIAZBAWoLISIgA0EuRyEyIARBAXENAQwCC0EBITJBACEmIAIhIkEAIQUgBEEBcUUNASAqIAtBAXFqISoMBQsCQAJAAkAgBUEDTQRAIAUNAQwCCyACLQACQS1HDQAgAi0AA0EtRg0CCyACLQAAQeEAa0H/AXFBGUsNASAFQQFHBEAgBUEBayEEIAJBAWohBgNAIAYtAAAiCEHhAGtB/wFxQRpJIAhBLUZyRSAIQTBrQf8BcUEJS3ENAyAGQQFqIQYgBEEBayIEDQALCyACIAVqQQFrIgRFDQAgBC0AAEEtRg0BC0EBIQQgKiALQQFxaiAFaiEqQQEhCyAiIQIgA0EuRg0DDAULICogC0EBcWohKgwBCyALQQFxRQ0AAn8gGigCACIEQf4BSQRAIAQhAyAKIQhB/QEhBCAaDAELIA0oAgQhAyANKAIIIQggCgshBiADIARGBH8gDRD5HyANKAIIIQggCiEGIA0oAgQFIAMLQQJ0IAhqQS42AgAgBiAGKAIAQQFqNgIACyAaKAIAIiBB/gFPBEAgCigCACEgCwJAAn8CQAJAAkACQAJAAkACQAJ/AkACQCAFBEBBACAFayEGIAIgBWohCEF/IQMCQANAIAIgA2oiEEEBaiwAACIEQQBIDQEgBiADQQFqIgNqQX9HDQALIAVBBE8NAkEBIRAgBSEDQQAMBAsgA0F/Rw0CQQEhFSACIRAgBSERQQEhCwwJCwJ/ICUoAgAiBkEJSQRAIAYhAyAUIQRBCCEGICUMAQsgGCgCBCEDIBgoAgghBCAUCyEFIAMgBkYEfyAYEPofIBgoAgghBCAUIQUgGCgCBAUgAwtBDGwgBGoiA0EANgIIIAMgAjYCBCADQQA2AgAgBSAFKAIAQQFqNgIADAkLQQEhECACKAAAQd+/f3FB2Jy16QJGDQJBACEVIAUhA0EBIQ9BACERDAMLIAUgA2sLIREgBEEfdiEVIARBAE4hDyADDQFBASELDAQLAkAgCEEBayIEBEAgBUEEayIDQdAPSw0BIAQtAABBLUYNAQwECyAFQQRrIgNB0Q9JDQMLDAELIAIhBANAIAdB4ABqIAcpA4ABIAcpA4gBIAQtAAAiBkH/AHEQxyMCQCAHKAJgQQFxRQ0AIAZBwQBrQf8BcUEZTQRAIAZBIHIhBgwBCyATQYACOwEEIBNBADYCAAwNCwJ/IBooAgAiDEH+AUkEQCAMIQggCiEOQf0BIQwgGgwBCyANKAIEIQggDSgCCCEOIAoLIQsgBEEBaiEEIAggDEYEfyANEPkfIA0oAgghDiAKIQsgDSgCBAUgCAtBAnQgDmogBjYCACALIAsoAgBBAWo2AgAgA0EBayIDDQALQQAhCwwCCyATQYACOwEEIBNBADYCAAwKCyAHQQA2AswGIAdBADYC8AJBACELQQAhFSMAQRBrIiEkACAHQfACaiIXQdwDaiIfIQwgFygC3AMiBEE8TwR/IBdBBGohDCAXKAIEBSAECwRAIAxBADYCAAsgB0GUAWohFiACQQRqIgggA2ohKEEAIQQgCCEMAkACQAJAAkACfwNAIAggAyAERg0BGiAEQQFqIQQgDEEBayIMIANqIgYtAABBLUcNAAsgCCEMIAMgBEYNASADIARrIhVBAWoiDCADSw0CIARBAWshAyAGQQFqCyEMIANFDQIgAyAMaiEoCyAXQQRqIQZByAAhG0GAASEOIBUhEQNAIA4hEEEAIBtrIS8gG0EaaiEzQSQhBEEBIQ4gCyEDAkADQAJAAkAgDC0AACIjQTBrQf8BcUEKTwRAICNBwQBrIg9B/wFxQRpJDQIgI0HhAGsiD0H/AXFBGUsNAQwCCyAjQRZrIQ8MAQsgFkEANgIADAYLIA6tIjkgD0H/AXEiDq1+IjpCIIhQRQRAIBZBADYCAAwGCyADIDqnIANqIg9LBEAgFkEANgIADAYLAkAgDkEBQRogBCAvaiAEIDNPGyAEIBtNGyIDTwRAIDlBJCADa61+IjlCIIhQDQEgFkEANgIADAcLAkACQCARQQFqIhEEQEEAISMgDyALa0ECQbwFIAsbbiIDIBFuIANqIgRByANPDQEgBCEODAILQaiexAAQ4isACwNAICNBJGohIyAEQdf8AEsgBEEjbiIOIQQNAAsLIA5BJGxB/P8DcSAOQSZqQf//A3FuIS8gDyARbiILIBBqIg4gEE8NAiAWQQA2AgAMBgsgOachDiAEQSRqIQQgDyEDIAxBAWoiDCAoRw0ACyAWQQA2AgAMBAsgDkGAgMQARiAOQYCwA3NBgIDEAGtBgJC8f0lyRQRAIB8oAgAiAyEbIAYhBCADQTxPBEAgFygCBCEbIBcoAgghBAsgDyALIBFsayEQAn8gGwRAIBtBA3QhAwNAIBAgBCgCACILTQRAIAQgC0EBajYCAAsgBEEIaiEEIANBCGsiAw0ACyAfKAIAIQMLIANBPEkEQCADIQQgBiELQTshAyAfDAELIBcoAgQhBCAXKAIIIQsgBgshDyAjIC9qIRsgAyAERgR/IBcQ+x8gFygCCCELIAYhDyAXKAIEBSAEC0EDdCALaiIDIA42AgQgAyAQNgIAIA8gDygCAEEBajYCACAQQQFqIQsgDEEBaiIMIChHDQEMAwsLIBZBADYCAAwCCyAMIANBuJ7EABCvOwALIB8oAgAiBEE7TQR/IBdBBGoFIBcoAgQhBCAXKAIICyEGICEgIUEPajYCCAJAIARBAkkNACAEQRVPBEAgIUEIaiELIwBBgCBrIgMkAAJAQcCEPSAEIARBwIQ9TxsiDCAEIARBAXZrIg4gDCAOSxsiDEGBBE8EQCADIAwQ3SMgBiAEIAMoAgQgAygCCCIGQQN0aiADKAIAIAZrIARBwQBJIAsQ+QkgA0EEQQgQ4B4MAQsgBiAEIANBgAQgBEHBAEkgCxD5CQsgA0GAIGokAAwBCyAGIAQQ1RYLIAggFWohAyAfKAIAIgRBO00EfyAXQQRqBSAXKAIEIQQgFygCCAshBiAWQgA3AhAgFiAENgIMIBYgBjYCCCAWIAM2AgQgFiAINgIAIBYgBCAVajYCGAsgIUEQaiQAAkACQCAHKAKUAQRAIAdBADYC0AYgB0EANgLACCMAQdAAayIRJAAgEUEgaiAWQRBqKQIANwMAIBFBGGogFkEIaikCADcDACARQShqIBZBGGooAgAiAzYCACARIBYpAgA3AxAgEUEIaiAHQdAGaiIPIAMgESgCJGsQnhggESgCCCARKAIMEIAtIA9B8AFqIQtBOyEEAkACQAJ/IA8oAvABIgNBO00EQCAPQQRqIQ4gCyEGIAMMAQsgD0EEaiEGIA8oAgghDiADIQQgDygCBAsiCCAESQRAIA4gCEECdGohDANAIBFBEGoQnhkiA0GAgMQARg0CIAwgAzYCACAMQQRqIQwgBCAIQQFqIghHDQALIAQhCAsgBiAINgIAIBFByABqIBFBKGooAgA2AgAgEUFAayARQSBqKQMANwMAIBFBOGogEUEYaikDADcDACARIBEpAxA3AzAgEUEwahCeGSIEQYCAxABGDQEgD0EEaiEDA0ACfyALKAIAIg5BPEkEQCAOIQwgAyEGQTshDiALDAELIA8oAgQhDCAPKAIIIQYgAwshCCAMIA5GBH8gDxD4HyAPKAIIIQYgAyEIIA8oAgQFIAwLQQJ0IAZqIAQ2AgAgCCAIKAIAQQFqNgIAIBFBMGoQnhkiBEGAgMQARw0ACwwBCyAGIAg2AgALIBFB0ABqJAACQCAdIA0gICAHKALACCIGQTxPBH8gBygC1AYhBiAHKALYBgUgNwsgBiAHQZMBahCnAw0AIAdB+ABqIA0gIEG8/cUAENYkIB0gBygCeCAHKAJ8QQFBARCxCw0AIAcoAsAIIgNBPEkNAyAHIAcpAtQGQiCJNwK0ASAHIAM2ArABIAdBsAFqQQRBBBDgHgwDCyATQYACOwEEIBNBADYCACAHKALACCICQTxJDQEgByAHKQLUBkIgiTcCtAEgByACNgKwASAHQbABakEEQQQQ4B4MAQsgE0GAAjsBBCATQQA2AgALIAcoAswGIgJBPEkNCiAHIAcpAvQCQiCJNwLUBiAHIAI2AtAGIAdB0AZqQQRBCBDgHgwKCyAHKALMBiIDQTxPBEAgByAHKQL0AkIgiTcC1AYgByADNgLQBiAHQdAGakEEQQgQ4B4LAn8gJSgCACIEQQlJBEAgBCEDIBQhCEEIIQQgJQwBCyAYKAIEIQMgGCgCCCEIIBQLIQYgAyAERgR/IBgQ+h8gGCgCCCEIIBQhBiAYKAIEBSADC0EMbCAIaiIDIAU2AgggAyACNgIEQQEhCyADQQE2AgAgBiAGKAIAQQFqNgIAQQAMAwsgDw0FCwJ/ICUoAgAiBkEJSQRAIAYhAyAUIQJBCCEGICUMAQsgGCgCBCEDIBgoAgghAiAUCyEFIAMgBkYEfyAYEPofIBgoAgghAiAUIQUgGCgCBAUgAwtBDGwgAmpBAjYCACAFIAUoAgBBAWo2AgAgB0HwAmohBSAdKAIAIQwgHSgCBCEEIB0oAgghAyAdLQAOIQ5BACEGQQAhCCMAQZABayICJAAgBCgCECEPIAQoAgwhFyAEKAIEIRYgBCgCACEbAn8gA0UEQEEBIQRBAQwBCyADKAIQIQYgAygCDCEEIAMoAgQhCCADKAIACyEDIAIgETYCXCACIBA2AlggAkEANgKEASACQQA2AkwgAkEANgIEIAJBAToAjAEgAiAGNgKAASACIAQ2AnwgAiAINgJ4IAIgAzYCdCACIA82AnAgAiAXNgJsIAIgFjYCaCACIBs2AmQgAiAMNgJgIAJC//8DNwJQIAIgDjYCiAEgAkEEaiIDKAJIIgRBEU0EfyADQQRqBSADKAIEIQQgAygCCAshBgJAIAQgAygCgAEiCEsEQCAGIAhBAnRqEN07IAMgAygCgAFBAWoiBDYCgAEgAygCSCIGQRJPBH8gAygCBAUgBgsgBEcNASADEKYpIANBADYCgAEMAQsgAygCTCEEIANBgIDEADYCTCAEQYCAxABGDQAgAyAEIAMoAlAQ1QcaCyAFIANBjAH8CgAAIAJBkAFqJAAgBUGQAWogHSgCEBDkICAFQYCAxAA2AowBIAUgHS8BDDYCnAEgB0GwAWogBUGgAfwKAAAgByAHQYABajYC0AIDQAJAQQAhBEEAIQZBACEFAkACQAJAAkACQAJAAkACQAJAIAcoArwCQYCAxABHDQAgJyEFAkAgBygC+AEiAkESTwR/IAcoArgBIQUgBygCtAEFIAILIAcoArACIgJNDQAgB0HQAGogBSACQQJ0ahCkLyAHKAJQIgVBgIDEAEYNACAHLQBUIAcgBygCsAJBAWoiAzYCsAIgBygC+AEiBkESTwR/IAcoArQBBSAGCyADRgRAIAdBsAFqEKYpIAdBADYCsAILDQIgByAFNgK8AkEAIQZBACEFDAELIAcoAvwBIQVBgIDEACEGIAdBgIDEADYC/AEgBUGAgMQARg0CIAcoAswCIAVNQQAgBygCgAIiBkGAgICABHEbDQAgB0HIAGogB0GwAWoQhQogBygCSCICQYCAxABGDQEgBygCTCEDIAcoAswCIAJNBEAgByACNgL8ASAHIAM2AoACIANBAEgNAQwCCyAHIAM2AoACIAcgAjYC/AEMAQtBACECAn8DQCAHKAK8AiEDIAdBgIDEADYCvAICQCADQYCAxABHDQAgB0GwAWogBSAGENUHIQUgAkEBcUUEQCAFIQMMAQsgB0HwAmogLhCmMAJAIAVB4SJrIgJBngFNBEAgAkEVTwRAIAVBqCNrQRtPDQIgBEGA2AJrIgJBHHAgAkGj1wBLcg0CIAQgBWpBpyNrIQMMAwsgBEGAImsiA0ETTw0BIANBzARsIAJBHGxqQYDYAmohAwwCCyAHQfACaiAEIAUQjiMiA0GAgMQARw0BCyAHIAU2ArwCIAQMAgsCQANAICchBgJAAkAgBygC+AEiAkESTwR/IAcoArgBIQYgBygCtAEFIAILIAcoArACIgJLBEAgB0FAayAGIAJBAnRqEKQvIAcoAkAiBUGAgMQARw0BCyAHQbABahCmKSAHQQA2ArACDAELIActAEQhAiAHQfACaiAuEKYwAkACQCAFQeEiayIEQZ4BTQRAIARBFU8EQCAFQagja0EbTw0CIANBgNgCayIEQRxwIARBo9cAS3INAiADIAVqQacjayEFDAMLIANBgCJrIgVBE08NASAFQcwEbCAEQRxsakGA2AJqIQUMAgsgB0HwAmogAyAFEI4jIgVBgIDEAEcNAQsgB0HwAmoiBSAHQbABaiAHKAKwAhCVFyAFEOUUIAdBADYCsAIgAkH/AXFFDQNBASEFA0AgJyEEIAcoAvgBIgZBEk8EfyAHKAK4ASEEIAcoArQBBSAGCyAFTQ0CIAdBOGogBCAFQQJ0ahCkLyAHKAI4IgRBgIDEAEYNAiAHLQA8IggiBkUNBAJAAkAgAkH/AXEgBkYEQCACIQgMAQsgB0HwAmoiBiAuEKYwIAYgAyAEEI4jIgRBgIDEAEcNAQsgBUEBaiEFIAghAgwBCyAHQbABaiAFENkaIAQhAwwACwALIAcgBygCsAJBAWo2ArACIAUhAwwBCwsgBygC+AEiAkESTwR/IAcoArQBBSACCw0AIAcoAvwBIgVBgIDEAEYNACAFIAcoAswCSQ0AIAcoAoACIgZBAE4NACAHQYCAxAA2AvwBQQEhAiADIQQMAQsLIAMLIQVBgIDEACEGIAVBgIDEAEYNAQsgBUH/AE0EQCAHQSBqIAcoAtACIgIpAwAgAikDCCAFEMcjIAcoAiBBAXENAgsgBUGAgMQARgRAIAUhBgwBCyAFQf3/A0YNASAFIQYgBUEuRw0DCyAHQRhqIA0gIEGs/MUAENYkIAcoAhxBBEkNBEG8/MUAIAcoAhhBEBCZJw0EIAdBEGogDSAgQQRqIgRBzPzFABDWJCAHLQCTASECIAcoAhQiBUUNAyAHKAIQIQMgBUECdCEFA0AgAygCAEGAAU8NAiADQQRqIQMgBUEEayIFDQALDAMLIBNBgAI7AQQgE0EANgIADAkLIBNBgAI7AQQgE0EANgIADAgLAn8gGigCACICQf4BSQRAIAIhBiAKIQRB/QEhAiAaDAELIA0oAgQhBiANKAIIIQQgCgshAyACIAZGBEAgDRD5HyANKAIEIQYgDSgCCCEEIAohAwsgBCAGQQJ0aiAFNgIADAILIAcgAjoAkwEgGigCACIDIQUgCiECIANB/gFJIghFBEAgDSgCBCEFIA0oAgghAgsCQAJAAkACQAJAIAVFDQAgAiAFQQJ0akEEayICRQ0AIAIoAgBBLUcNAQwCC0Gh+8UAQShBnP3FABCfKQALIAgEfyADBSAKKAIACyAga0HVD2tBr3BJDQEgB0EANgLMBiAHQQA2AvACIAdBCGogDSAEQez8xQAQ1iQgBygCCCELIAcoAgwhCEEAIQRBACEMIwBBEGsiKCQAIAdB8AJqIhVB3ANqIiEhAiAVKALcAyIDQTxPBH8gFUEEaiECIBUoAgQFIAMLBEAgAkEANgIACyAHQdQCaiEQIAsgCEECdCIFaiEXQQAhAgJAAkACQAJAAkACQAJ/A0AgCyAFRQ0BGiACQQFqIQIgBUEEayIFIAtqIgMoAgBBLUcNAAsgCyEPIAIgCEYNASAIIAJrIgxBAWoiBSAISw0CIAJBAWshCCADQQRqCyEPIAhFDQQgDyAIQQJ0aiEXCyAVQQRqIQNByAAhFkGAASEfIAwhEQNAIA8oAgAiAkHhAGshBSACQTBrQQpJIghFIAVBGUtxDQIgAkEWayAFIAgbIRtBACAWayEjIA9BBGohDyAWQRpqIS9BJCEFQQEhCCAEIQICQANAIAitIjkgG61+IjpCIIhQRQRAIBBBADYCAAwICyACIDqnIAJqIg5LBEAgEEEANgIADAgLAkBBAUEaIAUgI2ogBSAvTxsgBSAWTRsiAiAbTQRAIDlBJCACa61+IjlCIIhQDQEgEEEANgIADAkLAkACQCARQQFqIhEEQEEAIRsgDiAEa0ECQbwFIAQbbiICIBFuIAJqIgVByANPDQEgBSEIDAILQaiexAAQ4isACwNAIBtBJGohGyAFQdf8AEsgBUEjbiIIIQUNAAsLIAhBJGxB/P8DcSAIQSZqQf//A3FuISMgHyAOIBFuIgQgH2oiH00NAiAQQQA2AgAMCAsgDyAXRwRAIDmnIQggDygCACICQRZrIAJB4QBrIjMgAkEwa0EKSSI4GyEbIA9BBGohDyAFQSRqIQUgDiECIDgNASAzQRlLDQUMAQsLIBBBADYCAAwGCyAfQYCAxABGIB9BgLADc0GAgMQAa0GAkLx/SXINAyAhKAIAIgIhFiADIQUgAkE8TwRAIBUoAgQhFiAVKAIIIQULIA4gBCARbGshDgJ/IBYEQCAWQQN0IQIDQCAOIAUoAgAiBE0EQCAFIARBAWo2AgALIAVBCGohBSACQQhrIgINAAsgISgCACECCyACQTxJBEAgAiEFIAMhBEE7IQIgIQwBCyAVKAIEIQUgFSgCCCEEIAMLIQggGyAjaiEWIAIgBUYEfyAVEPsfIBUoAgghBCADIQggFSgCBAUgBQtBA3QgBGoiAiAfNgIEIAIgDjYCACAIIAgoAgBBAWo2AgAgDkEBaiEEIA8gF0cNAAsMAwsgBSAIQbiexAAQrzsACyAQQQA2AgAMAgsgEEEANgIADAELICEoAgAiBUE7TQR/IBVBBGoFIBUoAgQhBSAVKAIICyEDICggKEEPajYCCAJAIAVBAkkNACAFQRVPBEAgKEEIaiEEIwBBgCBrIgIkAAJAQcCEPSAFIAVBwIQ9TxsiCCAFIAVBAXZrIg4gCCAOSxsiCEGBBE8EQCACIAgQ3SMgAyAFIAIoAgQgAigCCCIDQQN0aiACKAIAIANrIAVBwQBJIAQQ+AkgAkEEQQgQ4B4MAQsgAyAFIAJBgAQgBUHBAEkgBBD4CQsgAkGAIGokAAwBCyADIAUQ1RYLIAsgDEECdGohAiAhKAIAIgVBO00EfyAVQQRqBSAVKAIEIQUgFSgCCAshAyAQQgA3AhAgECAFNgIMIBAgAzYCCCAQIAI2AgQgECALNgIAIBAgBSAMajYCGAsgKEEQaiQAIAcoAtQCIiEEQCAHQQA2AtAGIAdBADYCwAgjAEEQayIVJAAgECgCECEXIBAoAgwhGyAQKAIIIR8gECgCBCEWIBAoAgAhAyAVQQhqIAdB0AZqIg8gECgCGCAQKAIUIhBrEJ4YIBUoAgggFSgCDBCALSAPQfABaiEMQTshBQJAAkACQAJ/IA8oAvABIgJBO00EQCAPQQRqIQggDCEOIAIMAQsgD0EEaiEOIA8oAgghCCACIQUgDygCBAsiCyAFSQRAIAggC0ECdGohESAFIBBqIAtrA0ACQAJAAkAgFyAbSQRAIBAgHyAXQQN0aiICKAIARg0CIAMgFkcNAQNADAALAAsgAyAWRg0FCyADIQggA0EEaiICIQMMAQsgAkEEaiEIIBdBAWohFyADIQILIBEgCCgCADYCACARQQRqIREgEEEBaiEQIAUgC0EBaiILRw0ACyAFIQshECACIQMLIA4gCzYCACAPQQRqIQQMAQsgDiALNgIADAELA0ACQAJAIBcgG0kEQCAfIBdBA3RqIgUoAgAgEEcEQCADIBZHDQIDQAwACwALIBdBAWohFyADIQIgBUEEaiEDDAILIAMgFkYNAwsgA0EEaiECCwJ/IAwoAgAiCEE8SQRAIAghESAEIQVBOyEIIAwMAQsgDygCBCERIA8oAgghBSAECyELIAMoAgAhAyAIIBFGBEAgDxD4HyAPKAIEIREgBCELIA8oAgghBQsgBSARQQJ0aiADNgIAIAsgCygCAEEBajYCACAQQQFqIRAgAiEDDAALAAsgFUEQaiQAIBoiAigCACIDQf4BTwR/IAoiAigCAAUgAwsgIEsEQCACICA2AgALIB0gDSAgIAcoAsAIIgJBPE8EfyAHKALUBiECIAcoAtgGBSA3CyACIAdBkwFqEKcDRQRAIAcoAsAIIgJBPE8EQCAHIAcpAtQGQiCJNwLICCAHIAI2AsQIIAdBxAhqQQRBBBDgHgsgBygCzAYiAkE8TwRAIAcgBykC9AJCIIk3AtQGIAcgAjYC0AYgB0HQBmpBBEEIEOAeCyAhQQBHIhUhCwwFCyATQYACOwEEIBNBADYCACAHKALACCICQTxJDQMgByAHKQLUBkIgiTcCyAggByACNgLECCAHQcQIakEEQQQQ4B4MAwsgE0GAAjsBBCATQQA2AgAMAgsgE0GAAjsBBCATQQA2AgAMCAsgE0GAAjsBBCATQQA2AgAMBwsgBygCzAYiAkE8SQ0GIAcgBykC9AJCIIk3AtQGIAcgAjYC0AYgB0HQBmpBBEEIEOAeDAYLIAcgDSAgQYz9xQAQ1iQCfwJAIB0gBygCACAHKAIEIAtBAXEgFRCxC0UEQCAGQYCAxABGDQQgGigCACIGQf4BTw0BIAYhAyAKIQJB/QEhBiAaDAILIBNBgAI7AQQgE0EANgIADAcLIA0oAgQhAyANKAIIIQIgCgshBSADIAZGBH8gDRD5HyANKAIIIQIgCiEFIA0oAgQFIAMLQQJ0IAJqQS42AgAgBSAFKAIAQQFqNgIAIBooAgAiIEH+AU8EQCAKKAIAISALAn8gJSgCACIGQQlJBEAgBiEFIBQhAkEIIQYgJQwBCyAYKAIEIQUgGCgCCCECIBQLIQMgBSAGRgR/IBgQ+h8gGCgCCCECIBQhAyAYKAIEBSAFC0EMbCACakECNgIAQQEhFUEBIQsLIAMgAygCAEEBajYCAAwBCwsgB0GwAWoQxCggLhDaKQtBASELQQALIQQgIiECIDJFDQEMAwsLIAdBsAFqEMQoIC4Q2ikMAwsCfyAlKAIAIgRBCE0EQCAEIQMgFCELQQghBCAlDAELIBgoAgQhAyAYKAIIIQsgFAshBkECQQAgBy0AkwEiCBshDCAwIAUgCBshMCAxIAIgCBshMSADIARGBH8gGBD6HyAYKAIIIQsgFCEGIBgoAgQFIAMLQQxsIAtqIgIgMDYCCCACIDE2AgQgAiAMNgIAQQEhCyAGIAYoAgBBAWo2AgBBACEEIDJFDQELCyAKIQVBACECIBooAgAiA0H+AU8EQCANKAIIIQUgDSgCBCEDCwJAIANFDQAgA0ECdCEGIB0oAhwhCANAAkAgBSgCACIDQZALSSADQYASa0Gd5ANJciADQYDgB2tBgKAISSADQYD+A2tBgBJJcnIgA0GAoARrQYCwA0lyRQRAIAggAxDrGRCxPUGiwABxDQELIAVBBGohBSAGQQRrIgYNAQwCCwsgGigCACILQf4BTwRAIA0oAgQhCyANKAIIIQoLIActAJMBIQwCQCALRQ0AIAogC0ECdGohAgNAIAshBEEBIQUgCiIGIQMCQAJAA0AgAygCACIOQS5GIiINASAFQQFqIQVBBCEKIANBBGoiAyACRw0AC0EAIQsMAQsgBCAFayELIANBBGohCiAFQQFrIQQLAkACQAJAAkAgBEUNACAIIAYoAgAQ6xkiAxCxPUGDwABxRQRAIBNBgAI7AQQgE0EANgIADAgLIARBAnQhBQNAIAUhAiAEQQFrIgRFDQEgAkEEayEFIAggAiAGakEEaygCABDrGSIRQf8BcSIUQRFGDQALAkACQCARELE9QabAAEEFIANB/wFxIgMbcQRAIANFDQEgBUEERg0FQQAhBEEIIQUDQAJ/AkACQAJAAkAgCCAFIAZqQQRrKAIAEOsZIgMQsT1B/sgYcQRAIARB/wFxQQFrDgICAwELIBNBgAI7AQQgE0EANgIADBALIANB/wFxIgNBAkYNAiADQQVGQQF0DAMLIANB/wFxQQVHDQEgE0GAAjsBBCATQQA2AgAMDgtBAiADQf8BcUECRw0BGiATQYACOwEEIBNBADYCAAwNC0EBCyEEIAIgBUEEaiIFRw0ACwJAIARB/wFxQQFrDgIAAwQLIBRBBUcNAwwECyATQYACOwEEIBNBADYCAAwJCyAFQQRGDQFBCCEFA0AgCCAFIAZqQQRrKAIAEOsZELE9Qd2IGHEEQCAFQQRqIgUgAkcNAQwDCwsgE0GAAjsBBCATQQA2AgAMCAsgFEECRg0BCyAOQS5HDQQMAgsgE0GAAjsBBCATQQA2AgAMBQsgIkUNAgsgCiALQQJ0aiECIAsNAAsLIAcgDDoAkwFBASECCyATIActAJMBOgAFIBMgAjoABCATICo2AgALIAdB0AhqJAAgDSgC5AgiCCAcRg0CIA0tAOkIIi1BAXEEQEEBIS0MAwsCQAJ/IA0oAvgHIhRB/QFNBEAgDUEEaiEKIBQMAQsgDSgCCCEKIA0oAgQLIgIEQCAKIAJBAWsiBUECdGooAgBBLkYNAQsgFEH9AU0EQCANQQRqIQogFCEFDAELIA0oAgQhBSANKAIIIQoLIAVBAnQhBSAKQQRrIQIDQCAFBEAgAiAFaiAFQQRrIQUoAgBBLkcNAQsLIA0oAuAIIgVBCE0EfyANQYAIagUgDSgCgAghBSANKAKECAshECAFQQxsIBRB/QFNBH8gDUEEagUgDSgCBCEUIA0oAggLIQsgEGohEwNAIAshBUEAIQJBASEmAn9BACAURQ0AGiAUQQJ0IQJBACEKQQEhBgJAA0AgBSAKaiIDKAIAQS5GDQEgBkEBaiEGIAIgCkEEaiIKRw0ACyAFIQsgFCICDAELIAZBAWshAiADQQRqIQtBACEmIBQgBmsLIRQCQAJAIBAgE0cEQCAQKAIIIQQgECgCBCEDIBAoAgAhDCArRQ0CIB4NASAIQQFqIgggHEYNBAwCC0Hc+8UAELI7AAsgEigCCCEGIBJBARDYLSASKAIEIBIoAghqQS46AAAgEiAGQQFqNgIICwJAAkACQAJAAkACQAJAAkACQCAMRQRAIAQEQEEAIQYgBCEKA0AgAyAGaiIFLQAAQcEAa0H/AXFBGkkNAyAKQQFrIQogBCAGQQFqIgZHDQALCyAeDQJBACEeIAQgCGoiCCAcRw0JDAwLIAJBAnQhCiAFIQYDQCAKRQ0DIApBBGshCiAGKAIAIAZBBGohBkGAAUkNAAsMBAsCQCAeBEAgBiEEIAghAgwBCyAkIQMgBiAIaiIEIQIgBCAcSw0DCyASIAMgAyAEahCBJiASKAIIIQMDQCASQQFBAiAFLAAAIgRBAE4iCBsiDBDYLSAEIARBwQBrQf8BcUEaSUEFdHIhBiAFQQFqIQUgEigCBCASKAIIaiIOIAgEfyAGBSAOIAZBvwFxOgABIARBwAFxQQZ2QUByCzoAACASIAMgDGoiAzYCCCAKQQFrIgoNAAtBASEeIAIhCAwHCyASIAMgAyAEahCBJgwDCwJAIB5FBEAgCCAcSw0BIBIgJCAIICRqEIEmCyACRQ0DIAJBAnQhAiASKAIIIQMDQCASAn9BASAFKAIAIgRBgAFJIgoNABpBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiDBDYLSASKAIEIBIoAghqIQYCQAJAIApFBEAgBEGAEEkNASAEQYCABE8EQCAGIARBP3FBgAFyOgADIAYgBEESdkHwAXI6AAAgBiAEQQZ2QT9xQYABcjoAAiAGIARBDHZBP3FBgAFyOgABDAMLIAYgBEE/cUGAAXI6AAIgBiAEQQx2QeABcjoAACAGIARBBnZBP3FBgAFyOgABDAILIAYgBDoAAAwBCyAGIARBP3FBgAFyOgABIAYgBEEGdkHAAXI6AAALIAVBBGohBSASIAMgDGoiAzYCCCACQQRrIgINAAsMAwsgCCAcQZz8xQAQsDsACyAGIAhqIBxB7PvFABCwOwALIAxBAUYEQAJAAkAgBARAQQAhBiAEIQoDQCADIAZqIgUtAABBwQBrQf8BcUEaSQ0CIApBAWshCiAEIAZBAWoiBkcNAAsLIB4NAUEAIR4gBCAIaiIIIBxGDQkMBgsCQCAeBEAgBiEEIAghAgwBCyAkIQMgBiAIaiIEIQIgBCAcSw0ECyASIAMgAyAEahCBJiASKAIIIQMDQCASQQFBAiAFLAAAIgRBAE4iCBsiDBDYLSAEIARBwQBrQf8BcUEaSUEFdHIhBiAFQQFqIQUgEigCBCASKAIIaiIOIAgEfyAGBSAOIAZBvwFxOgABIARBwAFxQQZ2QUByCzoAACASIAMgDGoiAzYCCCAKQQFrIgoNAAtBASEeIAIhCAwFCyASIAMgAyAEahCBJgwBCyAeRQRAIAggHEsNAyASICQgCCAkahCBJgsgEkGw+sUAQbT6xQAQgSZBACEEQQAhDEEAIQ4CQAJAIAUgAkECdGoiHSAFRg0AQQEhCiAFIQYDQCAKQQJGDQIgBigCACICQf8ATQRAIBIoAgghAyASQQEQ2C0gEigCBCASKAIIaiACOgAAIBIgA0EBajYCCCAOQQFqIQ4LIApBAWshCiAGQQRqIgYgHUcNAAtBACAKayIHQY0eSw0BAkAgDkUEQEEAIQ4MAQsgEigCCCECIBJBARDYLSASKAIEIBIoAghqQS06AAAgEiACQQFqNgIICyAHIA5JDQAgBUEEaiEiIB0gBWtBBGshEUHIACEaQYABIRUgDiEEAkADQCAiIQIgESEDIAUhCgNAIAMhJyACIQYgCiAdRg0CIAJBBGohAiADQQRrIQMgCigCACEPIApBBGohCiAPIBVJDQALIAogHUcEQCAnQQJ2IQIDQCAPIAYoAgAiAyAPIAMgD0kbIAMgFUkbIQ8gBkEEaiEGIAJBAWsiAg0ACwsgBEEBaiAPIBVrbCAMaiEMIAUhKwJAA0AgDCArKAIAIgIgD0lqIQwgAiAPRgRAAkBBAUEaQSQgGmsgGkEaaiInQSRNGyAaQSRPGyIKIAwiAksNAEEAIBprIRVByAAhBgJAA0AgCkEkRwRAIAIgCmsiAiACQSQgCmsiA24iAiADbGsgCmoiA0EaSQR/QeEABSADQSRPDQNBFgshCiASKAIIIRggEkEBQQIgAyAKaiIDQYABSSIKGyIXENgtIBIoAgQgEigCCGoiFiAKBH8gAwUgFiADQT9xQYABcjoAAUHCAQs6AAAgEiAXIBhqNgIIIAYgJ0khAyAGIBVqIQogBiAaSyEYIAZBJGohBiACIApBGiADG0EBIBgbIgpPDQEMAwsLQdiexAAQ5ysAC0HonsQAQQ5B+J7EABCfKQALIAJBGkkEf0HhAAUgAkEkTw0DQRYLIQMgEigCCCEGIBJBAUECIAIgA2oiAkGAAUkiAxsiChDYLSASKAIEIBIoAghqIicgAwR/IAIFICcgAkE/cUGAAXI6AAFBwgELOgAAIBIgBiAKajYCCAJAAkAgBEEBaiICBEAgDEG8BUECIAQgDkYbbiEDQQAhDCADIAMgAm5qIgpByANPDQFBACEGIAohAwwCC0GonsQAEOIrAAtBACEGA0AgBkEkaiEGIApB1/wASyAKQSNuIgMhCg0ACwsgBiADQSRsQfz/A3EgA0EmakH//wNxbmohGiACIQQLICtBBGoiKyAdRw0ACyAPQQFqIRUgDEEBaiEMIAQgB0sNAwwBCwtB6J7EAEEOQfiexAAQnykAC0HInsQAELI7AAtBAiEECyAEQf8BcUECRwRAIwBBIGsiACQAIABBATYCBCAAQYj6xQA2AgAgAEIBNwIMIABCiPvFgKAmNwMYIAAgAEEYajYCCCAAQZD7xQAQ7ywACwtBASEeDAILIAYgCGogHEH8+8UAELA7AAsgCCAcQYz8xQAQsDsACyAQQQxqIRBBASErICZFDQALIC1Bf3NBAXEhHgwCC0EAIR4LQQAhLQsgDSgC4AgiAkEJTwRAIA0gDSkCgAhCIIk3AugIIA0gAjYC5AggDUHkCGpBBEEMEOAeCyANKAL4ByICQf4BTwRAIA0gDSkCBEIgiTcCgAggDSACNgL8ByANQfwHakEEQQQQ4B4LIBkgHjoAASAZIC1BAXE6AAAgDUHwCGokACAZLQABIQICQAJ/AkAgGS0AAARAIAJBAXFFDQFBofvFAEEoQcz7xQAQnykACwJAIAJBAXEEQCAZQRhqIgIgGUEMaigCADYCACAZIBkpAgQ3AxAgLCAZKQMQNwIAICxBCGogAigCADYCAAwBCwJAICkoAgAiAkGAgICAeEcEQCAZQRhqIClBCGooAgA2AgAgGSApKQIANwMQDAELIBkgHDYCGCAZICQ2AhQgGUGAgICAeDYCEAsgLCAZKQMQNwIAICxBCGogGUEYaigCADYCACACQYCAgIB4RwwCC0EAIQUMAgsgLEGBgICAeDYCAEEACyEFIBlBBGoQ3jsLAkAgBQ0AICkoAgBBgICAgHhGDQAgKRDeOwsgGUEgaiQAIDZBMGokACA1IDRBgICAgHhGciELIAkoAnQiAkGBgICAeEcNASAAQYMCOwEADAkLIAlB3QA2AoABIAIEQCAJQYABakEBIAIgCmpBAWtBARDBLg0CCyAAQYMIOwEAQQAMCQsgCSAJKQJ4NwJsIAkgAjYCaCAJQUBrIAlB6ABqIgIQ3DtBACAJKAJERQ0GGiAJQThqIAIQ3DsgCSgCOCEDIAkoAjwhAiAJQQE7AaQBIAkgAjYCoAEgCUEANgKcASAJQQE6AJgBIAlBLjYClAEgCSACNgKQASAJQQA2AowBIAkgAjYCiAEgCSADNgKEASAJQS42AoABIAlBMGogCUGAAWoiAhD8DSAJKAIwIgVFDQECQAJAAkACQCAJKAI0IgMNACAJQShqIAIQ/A0gCSgCKCIFRQ0CIAkoAiwiAw0AQQAhAwwBC0EAIQIDQCACIANGDQMgAiAFaiACQQFqIQItAABBMGtB/wFxQQpJDQALCyAJQSBqIAUgAxDjCCAJKAIgQQJHDQELIAlBiwFqIAlB8ABqKAIANgAAIABBADoAACAJIAkpAmg3AIMBIAAgCSkAgAE3AAEgAEEIaiAJQYcBaikAADcAAAwKCyAJQRhqIAlB6ABqENw7IAkoAhghAyAJKAIcIQIgCUEBOwGkASAJIAI2AqABIAlBADYCnAEgCUEBOgCYASAJQS42ApQBIAkgAjYCkAEgCUEANgKMASAJIAI2AogBIAkgAzYChAEgCUEuNgKAASAJQfQAaiEGIwBBQGoiAiQAIAIgCUGAAWoiBBDkCwJAAkACQCACKAIAIggEQCACKAIEIRQgAkEYaiIKQQRBAEEEQQgQoBggAigCHCEDIAIoAhhBAUYNAiACKAIgIgUgFDYCBCAFIAg2AgAgAkEUaiIMQQE2AgAgAiAFNgIQIAIgAzYCDCAKIARBKPwKAAAjAEEQayIFJAAgBUEIaiAKEOQLIAUoAggiFARAIAJBDGohBCAFKAIMIQMDQCAEKAIIIgggBCgCAEYEQCAEIAhBAUEEQQgQxSgLIAQoAgQgCEEDdGoiDiADNgIEIA4gFDYCACAEIAhBAWo2AgggBSAKEOQLIAUoAgQhAyAFKAIAIhQNAAsLIAVBEGokACAGQQhqIAwoAgA2AgAgBiACKQIMNwIADAELIAZBADYCCCAGQoCAgIDAADcCAAsgAkFAayQADAELIAMgAigCIEHwl8QAEP0vAAsgCSgCeCEDAkAgCSgCfCICRQ0AIAMgAkEDdGoiBUEIayIERQ0AIAQoAgAgBUEEaygCAEEBQQAQwS5FDQAgCSACQQFrIgI2AnwLIAJBBE0EQCAJQQA2AogBIAlCgICAgMAANwKAASAJKAJ0IQUCQCACBEAgAyACQQN0aiEGIAMhAgNAIAlBEGogAigCACACQQRqKAIAEOMIIAkoAhAiBEECRiAEQQFxRXINAiAJKAIUIQogCSgCiAEiBCAJKAKAAUYEQCAJQYABakG8mcQAEJcoCyAJKAKEASAEQQJ0aiAKNgIAIAkgBEEBajYCiAEgAkEIaiICIAZHDQALCyAJIAM2AqwBIAkgBTYCqAEgCUGoAWpBBEEIEOAeIAkoAogBIgZFDQQgCSAGQQFrIgo2AogBIAkoAoQBIgMgCkECdGooAgAiBEF/IApBA3R2Sw0GIAZBAnRBBGshAiADIQUDQCACRQRAIAoEQCAGQQJ0QQRrIQVBGCECA0AgAygCACACQRhxdCAEaiEEIAJBCGshAiADQQRqIQMgBUEEayIFDQALCyAJQYABakEEQQQQ4B4gAEEBOgAAIAAgBEEYdCAEQYD+A3FBCHRyIARBCHZBgP4DcSAEQRh2cnI2AAEgCUHoAGoQhjAMDQsgAkEEayECIAUoAgAgBUEEaiEFQf8BTQ0ACwwGCyAJIAM2AqwBIAkgBTYCqAEgCUGoAWpBBEEIEOAeDAULIAlB9ABqQQRBCBDgHgwFCyAJQQhqIAEQ3DsgCSgCDCECIAkoAgghAyAJIAEQ3DsgCSgCBCIEQQFrIgVFDQICQCACQQFNBEAgAkEBRg0BDAQLIAMsAAFBQEgNAwsCQCACIAVNBEAgAiAFRw0EDAELIAMgBWosAABBv39MDQMLIAlBgAFqIANBAWogBEECaxCxBiAAAn8gCS0AgAFBAUYEQCAAIAktAIEBOgABQQMMAQsgACAJQYEBaiICKQAANwABIABBCWogAkEIaikAADcAAEECCzoAAEEADAcLQdyYxAAQsjsAC0GQmcQAQRtBrJnEABDLJAALIAMgAkEBIAVBkJjEABCjNgALIAlBgAFqQQRBBBDgHgtBAwshAiAAQQM6AAAgACACOgABIAlB6ABqEIYwCyALQQFzCw0CIAEoAgBBgICAgHhGDQIMAQsgCyABKAIAQYCAgIB4R3FFDQELIAEQ3jsLIAlBsAFqJAALwQwCCn8DfiMAQdABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBBHQiCSEGAkAgCUEwcSIFBEAgCSAFa0FAayIGIAlJDQELQcAAIQUgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiBUUNAQsgBEEANgJIIAQgBTYCQCAEIAY2AjwgBEHAADYCOCAJBEAgCQRAIAVBACAJ/AsACyAEKAJIIQ0gBCgCQCEFCyAEIAk2AkQgBCAIIA1qNgJIAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQYDQCAEQfAAaiACIAEpAwAgASkDCCABQRBqKQMAIAFBGGopAwAQoQoCQAJAIAQoAnBBAXFFDQAgBCkDgAEiDiAEKQOIASIPIAkQ/yBFDQAgBSAONwMAIAUgDzcDCAwBCyAEQQhqIARBJGoQhj0gBkEDdiIDIAQoAgwiCk8NAyAEKAIIIANqIgMgAy0AAEF+IAZBB3F3cToAACAHQQFqIQcLIAVBEGohBSABQSBqIQEgCCAGQQFqIgZHDQALDAcLIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBkAFqIQggAy0AACEGIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwO4AQwBCyAEKAKQAUUNASAEQbABaiAIELYqIAQpA7ABIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQwgBEIANwNwIAQpA3gMAQsgBCkDuAELIQ8gDqdBAXFFDQogBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIARBsAFqIAIgCSAQpyAOp2oiAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBChCgJAIAQoArABQQFxRQ0AIAQpA8ABIg4gBCkDyAEiDyAGEP8gRQ0AIAUgAUEEdGoiASAPNwMIIAEgDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiIDIAQoAhQiCkkEQCAEKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAMgCkGIi/8AEMMhAAtBxIr/ABCyOwALIAMgCkGIi/8AEMMhAAtBwAAgBhCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArgBIAQgBTYCtAEgBCABNgKwASAEQeQAaiIBIARBsAFqEOIZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDLHSAEQThqEM8vIAYQzy8gBEHQAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC7kXAhZ/D34jAEHABWsiBCQAIAQgATYCCCAEIAJBCGoiCCABQQhqIhEQzxAgBCgCBCEMIAQoAgAhDSAEQQE6AA8gBEGQBGogDSAMIARBD2oQxw0CQCAEKAKQBEEIRgRAIAQoApgEIRIgBCgClAQhEyAEQdgBaiEFIwBBkANrIgEkAAJAIAggBEEIaigCAEEIaiIKEOcRRQRAIAFBgICAgHg2AgAMAQsgAUGIAmpB0PLNAEHw8s0AEIU1IgYoAgAgBigCBCgCDBEEABDaASABQYACakGYms8AKQIANwMAIAFCBDcD8AEgAUIANwPoASABQoCAgIAQNwPgASABQZCazwApAgA3A/gBIAEgAUHgAWpByAD8CgAAIAFBADYCWCABQoCAgICAATcDUCABQgA3A0gLIAggChDbEiEGQQEhDiABQQZBACAILQCVAUEBcRsgBkH/AXEiBiAGQQlGGyILOgCHA0KAgICAECEaQYCAgIB4IQ9BgICAgHghBwJAAkACQAJAAkACQAJAAkAgCw4HAgMDAwMAAQMLIAFB4AFqIgcQmShB4ABBCBCtNiIJRQ0FIAkgB0HgAPwKAABBgYCAgHghBwwBCyABQeABaiIHEJkoQeAAQQgQrTYiBkUNBCAGIAdB4AD8CgAAIAcQmShB4ABBCBCtNiIQRQ0EIBAgB0HgAPwKAABCASEaQQAhDkEBIQlBACEHCyABQbwBaiILQQA2AgAgAUHEAWoiFEEANgIAIAFB2AFqIhVBADYCACABQagBaiIWIBA2AgAgASAJNgLAASABQZgBaiIJIAspAgA3AwAgASAGNgLIASABQaABaiIGIBQpAgA3AwAgAUGIAWogFSkDADcDACABIBo3A5ABIAFCADcDgAEgAUH8AGogFigCADYCACABQfQAaiAGKQMANwIAIAFB7ABqIAkpAwA3AgAgASABKQOQATcCZCABIAc2AmACQCAIIAoQ0REiBkUNACABQeABaiAGKQMIIAYrAwAQ0hECQAJAIAEoAuABIglBCGsOAgECAAsgAUHgAGpBBHIhBiABKALkASEKIAEpA+gBIRogASkD8AEhGyAFQQI2ArABIAUgGzcDECAFIBo3AwggBSAKNgIEIAUgCTYCAAJAAkACQCAHQYCAgIB4c0ECIA4bDgIBAgALIAFB4ABqEN47IAFB7ABqEN47IAFB+ABqEN0pIAFB/ABqEN0pDAULIAYQ3jsMBAsgBhDeOyABQfAAahDdKQwDCyABKQPoASEaIAEoAuQBIQ8LIAggChCCEiEGIAFBwAJqIAFB4ABqQTD8CgAAIAFB4AFqIgcgAUHgAPwKAAAgBSAHQZAB/AoAACAFQQA2ApwBIAUgGjcClAEgBSAPNgKQASAFQQA2ArABIAUgBjoAxAEgBSABKQPwAiIaNwOgASAFQagBaiABQfgCaikDACIbNwMAIAUgGjcCtAEgBUG8AWogGzcCAAwCCyABQQI2AuQBIAFB8PXNADYC4AEgAUIBNwLsASABQa4DNgKMAyABIAFBiANqNgLoASABIAFBhwNqNgKIAyABQbwBaiABQeABahCZDiABQZwBaiABQcABaikDACIaNwIAIAFBpAFqIAFByAFqKQMAIhs3AgAgAUEANgK4ASABIAEpA7gBIhw3ApQBIAVBEGogGzcCACAFQQhqIBo3AgAgBSAcNwIAIAVBAjYCsAELIAEoAgBBgICAgHhGDQAgARCCKwsgAUGQA2okAAwBC0EIQeAAEKM9AAsgBCgCiANBAkYNASAEQRBqIAVByAH8CgAAIAggERCCEiEFQQAhASAEQQA2AqwDIARBADYCpAMgBEGkA2pBAhDpHiAEQdgDakEAQTT8CwACfyAFQf8BcSIFRQRAQYCAgIB4IQZBgICAgHghB0GAgICAeCEKQYCAgIB4DAELIARCADcD+AEgBEGAgICAeDYC7AEgBEGAgICAeDYC4AEgBEIANwPYASAEQeABaiEBAkAgBCgCCC4BGiIGQQBMBEAgBEGAgICAeDYCkAQMAQsgBEGQBGogBkEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAEQZgEaigCADYCACABIAQpApAENwIAIARBkARqIARB2AFqQSj8CgAAAkAgBCgCCC4BGCIBQQBMBEAgBEGAgICAeDYC2AEMAQsgBEHYAWogAUEBakH//wNxQaD5zwAQthULIARBpARqEIUwIARBrARqIARB4AFqKAIANgIAIAQgBCkC2AEiGjcCpAQgBCkDkAQhHSAEKAKYBCEGIAQpApwEIR4gBCgCsAQhFyAEKAK0BCEYIAQpA6gEIR8gBEIANwOIAiAEQgA3A/gBIARCADcD6AEgBEIANwPYASAEQZACaiAEQdADakE8/AoAACAEQYCAgIB4NgL8AiAEQYCAgIB4NgLwAiAEQQA2AtwCIARB8AJqIQECQCAEKAIILgEaIgdBAEwEQCAEQYCAgIB4NgKQBAwBCyAEQZAEaiAHQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIARBmARqKAIANgIAIAEgBCkCkAQ3AgAgBEGQBGogBEHYAWpBsAH8CgAAAkAgBCgCCC4BGCIBQQBMBEAgBEGAgICAeDYC2AEMAQsgBEHYAWogAUEBakH//wNxQaD5zwAQthULIARBtAVqEIUwIARBvAVqIARB4AFqKAIANgIAIAQgBCkC2AE3ArQFIAQpA5AEISAgBCkDmAQhISAEKQOgBCEiIAQpA6gEISMgBCkDsAQhJCAEKQO4BCElIAQpA8AEISYgBEHQA2ogBEHIBGpBPPwKAAAgGqchByAEQcgDaiAEQYwFaikCADcDACAEQbgDaiAEQaAFaikDADcDACAEIAQpAoQFNwPAAyAEIAQpA5gFNwOwAyAFQQJGIQEgBCgClAUhGSAEKAKoBSEKIAQpAqwFIScgBCkDuAUhKCAEKAK0BQshCSAIEPUVIQggACAFOgCuBSAAIAI2ApwFIABBuO3PADYCxAQgACADNgLABCAAIBI2AswEIAAgEzYCyAQgACAMNgL8AiAAIA02AvgCIABBqAVqIARBrANqKAIANgIAIAAgBCkCpAM3AqAFIAAgBCgCCDYCmAUgAEGwAWogBEEQakHIAfwKAAAgACAYNgKEBCAAIBc2AoAEIAAgHzcD+AMgACAHNgL0AyAAIB43AuwDIAAgBjYC6AMgACAdNwPgAyAAICY3AzAgACAlNwMoIAAgJDcDICAAICM3AxggACAiNwMQIAAgITcDCCAAICA3AwAgAEE4aiAEQdADakE8/AoAACAAIBk2AoQBIABBADYClAUgAEKAgICAIDcCjAUgAEICNwKEBSAAQgA3AvwEIABCgICAgMAANwL0BCAAICg3A6gBIAAgCTYCpAEgACAnNwKcASAAIAo2ApgBIABB/ABqIARByANqKQMANwIAIAAgBCkDwAM3AnQgACAEKQOwAzcDiAEgAEGQAWogBEG4A2opAwA3AwAgAEGBAjsBrAUgAEGAgICAeDYCtAQgAEIINwKsBCAAQgA3AqQEIABCgICAgMAANwKcBCAAQgg3ApQEIABBgICAgHhBACAIGzYCkAQgAEIANwOIBCAAIAE6ANwDIABBADYC2AMgAEGAgICAeDYCzAMgAEGAgICAeDYCwAMgAEIINwO4AyAAQgA3A7ADIABCgICAgMAANwOoAyAAQgQ3A6ADIABCADcDmAMgAEKAgICAEDcDkAMgAEIANwOIAyAAQoCAgICAATcDgAMgAEEANgLQBCAEQcAFaiQADwsgBEHoAWogBEGgBGopAwA3AwAgBEHgAWogBEGYBGopAwA3AwAgBCAEKQOQBDcD2AFBxO/OAEErIARB2AFqQbTvzgBBqP3OABDVHgALIARBoARqIARB6AFqKQMANwMAIARBmARqIARB4AFqKQMANwMAIAQgBCkD2AE3A5AEQcTvzgBBKyAEQZAEakG0784AQbj9zgAQ1R4AC6kMAgp/BH4jAEHAAWsiBCQAIAFBDGoQ2zwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBA3QiCSEFAkAgCUE4cSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhAyACKQMAIQ4gASgCECEFIARB8ABqQQRyIQlBACEHQQAhAQNAAkACQAJAIA5QBEAgBEKBgICA8ICAgIB/NwNwIAkQiBEMAQsgBTQCACAOfyIPIAMQxSlFDQAgBiAPNwMADAELIARBCGogBEEkahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEIaiEGIAVBBGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBqAFqQQRyIQggBEGQAWohBSADLQAAIQMgAikDACEQIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIRhoU3A5gBIBGnIA6naiEBAkAgEFAEQCAEQoGAgIDwgICAgH83A6gBIAgQiBEMAQsgCSABQQJ0ajQCACAQfyIOIAMQxSlFDQAgBiABQQN0aiAONwMADAELIARBEGogBEEkahCGPSABQQN2IgIgBCgCFCIKSQRAIAQoAhAgAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEHQAGogBEEkaiIGEIIUIARB8ABqIgIQlykgBEFAayIBKAIAIQUgBCgCRCEDIAEgBEH4AGoiCCkCADcDACAEKQM4IQ4gBCAEKQJwNwM4IARBADYCSCAEIA43AnwgBEEANgJ4IAQgAzYCdCAEIAU2AnAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogCCkCADcCACABQRhqIARBgAFqIgkoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDkGSAJIARB4ABqKAIANgIAIAggBEHYAGopAgA3AwAgBCAEKQJQNwNwIAQgBzYChAEgACABIAIQxh0gBEE4ahDPLyAGEM8vIARBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAupDAIKfwR+IwBBwAFrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQRhqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAIcIQwgBCgCGCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCMCAEIAY2AiwgBCAFNgIoIARBwAA2AiQgBEEkaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwIwIAQgBjYCLCAEIAc2AiggBEHAADYCJCAEQSRqIAgQ3hBBACEHCyAIQQN0IgkhBQJAIAlBOHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCSCAEIAY2AkAgBCAFNgI8IARBwAA2AjggCQRAIAkEQCAGQQAgCfwLAAsgBCgCSCENIAQoAkAhBgsgBCAJNgJEIAQgCCANajYCSCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyADLQAAIQMgAikDACEOIAEoAhAhBSAEQfAAakEEciEJQQAhB0EAIQEDQAJAAkACQCAOUARAIARCgYCAgPCAgICAfzcDcCAJEIgRDAELIAUyAQAgDn8iDyADEMUpRQ0AIAYgDzcDAAwBCyAEQQhqIARBJGoQhj0gAUEDdiICIAQoAgwiCk8NASAEKAIIIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBCGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAkgAUEBdGoyAQAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALqwwCCn8DfiMAQdABayIEJAAgAUEMahDcPCEIAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBMGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAjQhDCAEKAIwIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQUgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwJIIAQgBjYCRCAEIAU2AkAgBEHAADYCPCAEQTxqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBCAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AkggBCAGNgJEIAQgBzYCQCAEQcAANgI8IARBPGogCBDeEEEAIQcLIAhBAnQiCSEGAkAgCUE8cSIFBEAgCSAFa0FAayIGIAlJDQELQcAAIQUgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiBUUNAQsgBEEANgJgIAQgBTYCWCAEIAY2AlQgBEHAADYCUCAJBEAgCQRAIAVBACAJ/AsACyAEKAJgIQ0gBCgCWCEFCyAEIAk2AlwgBCAIIA1qNgJgAkACQCAHBEAgByAIRw0BIAghBwwICyAIRQRAQQAhBwwICyADLQAAIQkgASgCECEBQQAhB0EAIQYDQCAEQRhqIAIgASkDACABKQMIIAFBEGopAwAgAUEYaikDABC8CQJAAkAgBCgCGEEBcUUNACAEKAIcIgMgCRDEKUUNACAFIAM2AgAMAQsgBEEQaiAEQTxqEIY9IAZBA3YiAyAEKAIUIgpPDQMgBCgCECADaiIDIAMtAABBfiAGQQdxd3E6AAAgB0EBaiEHCyAFQQRqIQUgAUEgaiEBIAggBkEBaiIGRw0ACwwHCyALBEAgBEGIAWogCyAMIAogCBC/FCAEQagBaiEIIAMtAAAhBiABKAIQIQkDQAJAIAQpA7ABIg9QRQRAIAQpA7gBIQ4MAQsDQAJ+AkAgBCkDmAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDmAEgDqdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogCBC2KiAEKQPAASEOCyAOQgBSDQILIARCAzcDmAELIAQpA4gBIg5CAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyEPIA6nQQFxRQ0KIAQgBCkDuAFCQH0iDjcDuAEgBCAPNwOwASAPUA0ACwsgBCAPQgEgD3oiEIaFNwOwASAEQShqIAIgCSAQpyAOp2oiAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBC8CQJAIAQoAihBAXFFDQAgBCgCLCIDIAYQxClFDQAgBSABQQJ0aiADNgIADAELIARBIGogBEE8ahCGPSABQQN2IgMgBCgCJCIKSQRAIAQoAiAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAyAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAGEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB6ABqIARBPGoiBhCCFCAEQYgBaiICEJcpIARB2ABqIgEoAgAhBSAEKAJcIQMgASAEQZABaiIIKQIANwMAIAQpA1AhDiAEIAQpAogBNwNQIARBADYCYCAEIA43ApQBIARBADYCkAEgBCADNgKMASAEIAU2AogBIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAIKQIANwIAIAFBGGogBEGYAWoiCSgCADYCACAEIAM2AsgBIAQgBTYCxAEgBCABNgLAASAEQfwAaiIBIARBwAFqEOUZIAkgBEH4AGooAgA2AgAgCCAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBzYCnAEgACABIAIQyh0gBEHQAGoQzy8gBhDPLyAEQdABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALqQwCCn8EfiMAQcABayIEJAAgAUEMahDZPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIJIQUCQCAJQThxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgBTYCPCAEQcAANgI4IAkEQCAJBEAgBkEAIAn8CwALIAQoAkghDSAEKAJAIQYLIAQgCTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyAFMwEAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyACIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGoAWpBBHIhCCAEQZABaiEFIAMtAAAhAyACKQMAIRAgASgCECEJA0ACQCAEKQOYASIPUEUEQCAEKQOgASEODAELA0ACfgJAIAQpA4ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A4ABIA6nQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhDgsgDkIAUg0CCyAEQgM3A4ABCyAEKQNwIg5CAlENBiAEQgA3A3AgBCkDeAwBCyAEKQOwAQshDyAOp0EBcUUNBCAEIAQpA6ABQkB9Ig43A6ABIAQgDzcDmAEgD1ANAAsLIAQgD0IBIA96IhGGhTcDmAEgEacgDqdqIQECQCAQUARAIARCgYCAgPCAgICAfzcDqAEgCBCIEQwBCyAJIAFBAXRqMwEAIBB/Ig4gAxDFKUUNACAGIAFBA3RqIA43AwAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAiAEKAIUIgpJBEAgBCgCECACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyACIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOQZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDGHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC6kMAgp/BH4jAEHAAWsiBCQAIAFBDGoQ2zwhCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBA3QiCSEFAkAgCUE4cSIGBEAgCSAGa0FAayIFIAlJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAU2AjwgBEHAADYCOCAJBEAgCQRAIAZBACAJ/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAk2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhAyACKQMAIQ4gASgCECEFIARB8ABqQQRyIQlBACEHQQAhAQNAAkACQAJAIA5QBEAgBEKBgICA8ICAgIB/NwNwIAkQiBEMAQsgBTUCACAOfyIPIAMQxSlFDQAgBiAPNwMADAELIARBCGogBEEkahCGPSABQQN2IgIgBCgCDCIKTw0BIAQoAgggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEIaiEGIAVBBGohBSAIIAFBAWoiAUcNAQwICwsgAiAKQYiL/wAQwyEAC0HAACAFEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIAsEQCAEQfAAaiALIAwgCiAIEL8UIARBqAFqQQRyIQggBEGQAWohBSADLQAAIQMgAikDACEQIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIRhoU3A5gBIBGnIA6naiEBAkAgEFAEQCAEQoGAgIDwgICAgH83A6gBIAgQiBEMAQsgCSABQQJ0ajUCACAQfyIOIAMQxSlFDQAgBiABQQN0aiAONwMADAELIARBEGogBEEkahCGPSABQQN2IgIgBCgCFCIKSQRAIAQoAhAgAmoiAiACLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAiAKQYiL/wAQwyEAC0HEiv8AELI7AAsgBEHQAGogBEEkaiIGEIIUIARB8ABqIgIQlykgBEFAayIBKAIAIQUgBCgCRCEDIAEgBEH4AGoiCCkCADcDACAEKQM4IQ4gBCAEKQJwNwM4IARBADYCSCAEIA43AnwgBEEANgJ4IAQgAzYCdCAEIAU2AnAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogCCkCADcCACABQRhqIARBgAFqIgkoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDkGSAJIARB4ABqKAIANgIAIAggBEHYAGopAgA3AwAgBCAEKQJQNwNwIAQgBzYChAEgACABIAIQxh0gBEE4ahDPLyAGEM8vIARBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAuwDgIDfwF+IwBB0AFrIgMkACADQZQBaiABIAIQkw4gAygCmAEhBAJAIAMoApQBIgVBioCAgHhHBEAgA0EsaiADQbQBaigCADYCACADQSRqIANBrAFqKQIANwIAIANBHGogA0GkAWopAgA3AgAgAyADKQKcATcCFCADIAQ2AhAgAyAFNgIMDAELIANBlAFqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBoAFqKQIANwMAIAMgAykCmAE3AzAgAygClAEiBEGKgICAeEcEQCADQShqIANBsAFqKQIANwIAIANBGGogASkDADcCACADIAMpAqgBNwIgIAMgAykDMDcCECADIAQ2AgwMAQsgA0HIAGogASkDADcDACADIAMpAzA3A0AgA0GUAWogA0FAa0EEEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJAIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EJNgLIASADQaLn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAyADKQNINwJYIAMgAykDQDcCUCADQZQBaiADQdAAakEGEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJQIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EFNgLIASADQbTn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAyADKQJYNwJoIAMgAykCUDcCYCADQZQBaiADQeAAakEIEN0QIAMoApwBIQEgAygCmAEhBAJAAn4gAygClAEiBUGKgICAeEcEQCADQcABaiADQbABaikCADcDACADIAMpAqgBNwO4ASADKQKgAQwBCyAEQQFxRQ0BAkAgAUEDcQRAIAMgATYCsAEgA0EDNgKsASADQbzk/gA2AqgBIANBgICAgHg2AqQBIANCBDcCnAEgA0KEgICACDcClAEMAQtBfyABQQRqIgQgASAESxsiBSADKAJgIgQoAgRNBEAgBCAEKAIUQQRqIgU2AhQgBCgCCCgCCCAFTwRAIANBioCAgHg2ApQBDAILIANBiICAgHg2ApQBDAELIANBlAFqIAEgBRC/LwsgA0EINgLIASADQZHn/gA2AsQBIANBgICAgHg2AsABIAMgATYCvAEgA0EBNgK4ASADQfAAaiADQZQBaiADQbgBahCBFCADKAJwIgVBioCAgHhGDQEgA0HAAWogA0GMAWopAgA3AwAgAyADKQKEATcDuAEgAygCeCEBIAMoAnQhBCADKQJ8CyEGIANBKGogA0HAAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDuAE3AiAMAQsgAygCYCIBIAEoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0ENNgKkASADQe7o/gA2AqABIANBgICAgHg2ApwBIAMgAjYCmAEgA0ECNgKUASAAIANBDGogA0GUAWoQgRQgA0HQAWokAAumDAIKfwN+IwBBwAFrIgQkACABQQxqENw8IQgCQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEgaiAFENw7IAUoAhQhByAFKAIMIQogBCgCJCEMIAQoAiAhCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjggBCAGNgI0IAQgBTYCMCAEQcAANgIsIARBLGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0EIAcEQCAHQcAAEK02IgZFDQILIARCADcCOCAEIAY2AjQgBCAHNgIwIARBwAA2AiwgBEEsaiAIEN4QQQAhBwsgCEEDdCIJIQYCQCAJQThxIgUEQCAJIAVrQUBrIgYgCUkNAQtBwAAhBSAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIFRQ0BCyAEQQA2AlAgBCAFNgJIIAQgBjYCRCAEQcAANgJAIAkEQCAJBEAgBUEAIAn8CwALIAQoAlAhDSAEKAJIIQULIAQgCTYCTCAEIAggDWo2AlACQAJAIAcEQCAHIAhHDQEgCCEHDAgLIAhFBEBBACEHDAgLIAMtAAAhCSABKAIQIQFBACEHQQAhBgNAIARB+ABqIAIgASkDACABKQMIIAFBEGopAwAgAUEYaikDABCgCgJAAkAgBCgCeEEBRw0AIAQpA4ABIg4gCRDFKUUNACAFIA43AwAMAQsgBEEQaiAEQSxqEIY9IAZBA3YiAyAEKAIUIgpPDQMgBCgCECADaiIDIAMtAABBfiAGQQdxd3E6AAAgB0EBaiEHCyAFQQhqIQUgAUEgaiEBIAggBkEBaiIGRw0ACwwHCyALBEAgBEH4AGogCyAMIAogCBC/FCAEQZgBaiEIIAMtAAAhBiABKAIQIQkDQAJAIAQpA6ABIg9QRQRAIAQpA6gBIQ4MAQsDQAJ+AkAgBCkDiAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDiAEgDqdBAXFFDQAgBCAEKQOQATcDuAEMAQsgBCgCmAFFDQEgBEGwAWogCBC2KiAEKQOwASEOCyAOQgBSDQILIARCAzcDiAELIAQpA3giDkICUQ0MIARCADcDeCAEKQOAAQwBCyAEKQO4AQshDyAOp0EBcUUNCiAEIAQpA6gBQkB9Ig43A6gBIAQgDzcDoAEgD1ANAAsLIAQgD0IBIA96IhCGhTcDoAEgBEGwAWogAiAJIBCnIA6naiIBQQV0aiIDKQMAIAMpAwggAykDECADKQMYEKAKAkAgBCgCsAFBAUcNACAEKQO4ASIOIAYQxSlFDQAgBSABQQN0aiAONwMADAELIARBGGogBEEsahCGPSABQQN2IgMgBCgCHCIKSQRAIAQoAhggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwwBCwsgAyAKQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAKQYiL/wAQwyEAC0HAACAGEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAHEKM9AAtBwAAgBRCjPQALIARB2ABqIARBLGoiBhCCFCAEQfgAaiICEJcpIARByABqIgEoAgAhBSAEKAJMIQMgASAEQYABaiIIKQIANwMAIAQpA0AhDiAEIAQpAng3A0AgBEEANgJQIAQgDjcChAEgBEEANgKAASAEIAM2AnwgBCAFNgJ4IARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCeDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYgBaiIJKAIANgIAIAQgAzYCuAEgBCAFNgK0ASAEIAE2ArABIARB7ABqIgEgBEGwAWoQ5BkgCSAEQegAaigCADYCACAIIARB4ABqKQIANwMAIAQgBCkCWDcDeCAEIAc2AowBIAAgASACEMYdIARBQGsQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB+ABqQeyP/wBBiIz/ABDVHgALuw0CCH8EfiMAQaACayIDJAAgAUEMahDcPCEHIANBIGogARCSNhDuJSAHQQJ0IgUhBgJAAn8CQAJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgYgBUkNAQtBwAAhBCAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIERQ0BCyADIAQ2AkAgAyAGNgI8IANBwAA2AjggBQRAIARBACAF/AsACyADIAc2AkggAyAFNgJEIAMoAiBFDQMgAygCNCADKAIwRg0EIANB2ABqIANBIGoQyDQgA0H4AGohBiACKAIIIQcgAigCACEIIAEoAhAhCQNAAkAgAykDgAEiDFBFBEAgAykDiAEhCwwBCwNAAn4CQCADKQNoIgtCA1IEQAJAAkACQCALQgJRDQAgAyALUK1CAYY3A2ggC6dBAXFFDQAgAyADKQNwNwOIAgwBCyADKAJ4RQ0BIANBgAJqIAYQtiogAykDgAIhCwsgC0IAUg0CCyADQgM3A2gLIAMpA1giC0ICUQ0JIANCADcDWCADKQNgDAELIAMpA4gCCyEMIAunQQFxRQ0HIAMgAykDiAFCQH0iCzcDiAEgAyAMNwOAASAMUA0ACwsgAyAMQgEgDHoiDYaFNwOAASADQRhqIAggCSANpyALp2oiCkEFdGoiASkDACILIAEpAwgiDCABKQMQIg0gASkDGCIOELwJIAMoAhhBAXFFBEAgAigCBCEBIAMgDjcDyAEgAyANNwPAASADIAw3A7gBIAMgCzcDsAEgA0HMkf8ANgLYASADQgQ3AuQBIANBgww2ApwCIANB9As2ApQCIAMgAUEBajYCkAIgA0G7BzYCjAIgAyABNgKIAiADQcwBNgKEAiADQfiR/wA2AoACIAMgA0GAAmo2AuABIAMgA0GwAWo2ApgCIANBBDYC3AEgA0GgAWogA0HYAWoQmQ4gA0GYAWogA0GsAWooAgA2AgAgAyADKQKkATcDkAEgAygCoAEhBEGCgICAeCEFDAcLIANBgAJqIAMoAhwiASAHLQAAEOoPIAMoAoACIgVBk4CAgHhHBEAgA0GYAWogA0GQAmooAgA2AgAgAyADKQKIAjcDkAEgAygChAIhBAwHBSAEIApBAnRqIAE2AgAMAQsACwALQcAAIAYQoz0AC0Hci/8AQSkgA0HYAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEBQQAhBgNAIANBEGogCSABKQMAIgsgASkDCCIMIAFBEGopAwAiDSABQRhqKQMAIg4QvAkgAygCEEEBcUUEQCACKAIEIQEgAyAONwOYAiADIA03A5ACIAMgDDcDiAIgAyALNwOAAiADQcyR/wA2ArABIANCBDcCvAEgA0GDDDYCdCADQfQLNgJsIAMgAUEBajYCaCADQbsHNgJkIAMgATYCYCADQcwBNgJcIANB+JH/ADYCWCADIANB2ABqNgK4ASADIANBgAJqNgJwIANBBDYCtAEgA0HcAWogA0GwAWoQmQ4gA0H4AWogA0HoAWooAgA2AgAgAyADKQLgATcD8AEgAygC3AEhBEGCgICAeCEFIANB8AFqDAQLIANB2ABqIAMoAhQiCiAILQAAEOoPIAMoAlgiBUGTgICAeEcEQCADQfgBaiADQegAaigCADYCACADIAMpAmA3A/ABIAMoAlwhBCADQfABagwECyAEIAo2AgAgBEEEaiEEIAFBIGohASAHIAZBAWoiBkcNAAsLIANB2ABqIgIQlykgA0FAayIBKAIAIQUgAygCRCEEIAEgA0HgAGoiBikCADcDACADKQM4IQsgAyADKQJYNwM4IANBADYCSCADIAs3AmQgA0EANgJgIAMgBDYCXCADIAU2AlggA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJYNwIIIAFBEGogBikCADcCACABQRhqIANB6ABqIgcoAgA2AgAgAyAENgKIAiADIAU2AoQCIAMgATYCgAIgA0HMAGoiASADQYACahDlGSAHIANBMGopAgA3AwAgBiADQShqKQIANwMAIAMgAykCIDcDWCAAIAEgAhDKHSADQThqEM8vDAMLQQRBHBCjPQALIANBkAFqCyEBIAAgBDYCCCAAIAU2AgQgAEEpOgAAIAAgASkCADcCDCAAQRRqIAFBCGooAgA2AgAgA0E4ahDPLyADKAIgIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBIGoQ+x4LIANBoAJqJAALogwCCn8EfiMAQcABayIEJAAgAUEMaigCCCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIFIQkCQCAFQThxIgYEQCAFIAZrQUBrIgkgBUkNAQtBwAAhBiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgCTYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghDSAEKAJAIQYLIAQgBTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyABIAVqMQAAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgCRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAEgCWoxAAAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALogwCCn8EfiMAQcABayIEJAAgAUEMaigCCCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEEDdCIFIQkCQCAFQThxIgYEQCAFIAZrQUBrIgkgBUkNAQtBwAAhBiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgCTYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghDSAEKAJAIQYLIAQgBTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEDIAIpAwAhDiABKAIQIQUgBEHwAGpBBHIhCUEAIQdBACEBA0ACQAJAAkAgDlAEQCAEQoGAgIDwgICAgH83A3AgCRCIEQwBCyABIAVqMAAAIA5/Ig8gAxDFKUUNACAGIA83AwAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAiAEKAIMIgpPDQEgBCgCCCACaiICIAItAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQhqIQYgCCABQQFqIgFHDQEMCAsLIAIgCkGIi/8AEMMhAAtBwAAgCRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQagBakEEciEIIARBkAFqIQUgAy0AACEDIAIpAwAhECABKAIQIQkDQAJAIAQpA5gBIg9QRQRAIAQpA6ABIQ4MAQsDQAJ+AkAgBCkDgAEiDkIDUgRAAkACQAJAIA5CAlENACAEIA5QrUIBhjcDgAEgDqdBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEOCyAOQgBSDQILIARCAzcDgAELIAQpA3AiDkICUQ0GIARCADcDcCAEKQN4DAELIAQpA7ABCyEPIA6nQQFxRQ0EIAQgBCkDoAFCQH0iDjcDoAEgBCAPNwOYASAPUA0ACwsgBCAPQgEgD3oiEYaFNwOYASARpyAOp2ohAQJAIBBQBEAgBEKBgICA8ICAgIB/NwOoASAIEIgRDAELIAEgCWowAAAgEH8iDiADEMUpRQ0AIAYgAUEDdGogDjcDAAwBCyAEQRBqIARBJGoQhj0gAUEDdiICIAQoAhQiCkkEQCAEKAIQIAJqIgIgAi0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAIgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5BkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEMYdIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALmhABDn8jAEGQAmsiBiQAIAZC/////4eAgICQfzcDSCAGQv////+fhbCAVDcDQCAGQdQAaiELIAMgBEECdGohDiAAKAIAIQ0gACgCBCEKIAAoAgghCCAALQAOIQ8jAEGQAWsiByQAIAooAhAhECAKKAIMIREgCigCBCESIAooAgAhEwJ/IAhFBEBBASEKQQEMAQsgCCgCECEJIAgoAgwhCiAIKAIEIQwgCCgCAAshCCAHIA42AlwgByADNgJYIAdBADYChAEgB0EANgJMIAdBADYCBCAHQQI6AIwBIAcgCTYCgAEgByAKNgJ8IAcgDDYCeCAHIAg2AnQgByAQNgJwIAcgETYCbCAHIBI2AmggByATNgJkIAcgDTYCYCAHQv//AzcCUCAHIA82AogBIAdBBGoiCCgCSCIKQRFNBH8gCEEEagUgCCgCBCEKIAgoAggLIQkCQCAKIAgoAoABIgxLBEAgCSAMQQJ0ahDdOyAIIAgoAoABQQFqIgo2AoABIAgoAkgiCUESTwR/IAgoAgQFIAkLIApHDQEgCBCmKSAIQQA2AoABDAELIAgoAkwhCiAIQYCAxAA2AkwgCkGAgMQARg0AIAggCiAIKAJQENQHGgsgCyAIQYwB/AoAACAHQZABaiQAIAtBkAFqIAAoAhAQ5CAgC0GAgMQANgKMASALIAAvAQw2ApwBIAFBBGohDCABQfgHaiEOIAYgBkFAazYC9AEgBkHkAWohDSAGQdgAaiELAn8DQAJAQQAhCEEAIQkCQAJAAkACQAJAIAYoAuABQYCAxABHDQAgCyEJAkAgBigCnAEiAEESTwR/IAYoAlwhCSAGKAJYBSAACyAGKALUASIATQ0AIAZBOGogCSAAQQJ0ahCkLyAGKAI4IglBgIDEAEYNACAGLQA8IAYgBigC1AFBAWoiBzYC1AEgBigCnAEiCEESTwR/IAYoAlgFIAgLIAdGBEAgBkHUAGoQpikgBkEANgLUAQsNAiAGIAk2AuABQQAhCEEAIQkMAQsgBigCoAEhCSAGQYCAxAA2AqABIAlBgIDEAEYNAiAGKALwASAJTUEAIAYoAqQBIghBgICAgARxGw0AIAZBMGogBkHUAGoQ9hIgBigCMCIAQYCAxABGDQEgBigCNCEHIAYoAvABIABNBEAgBiAANgKgASAGIAc2AqQBIAdBAEgNAQwCCyAGIAc2AqQBIAYgADYCoAEMAQtBACEHQQAhCgJ/A0AgBigC4AEhACAGQYCAxAA2AuABAkAgAEGAgMQARw0AIAZB1ABqIAkgCBDUByEIIApBAXFFBEAgCCEADAELIAZB+AFqIA0QpjACQCAIQeEiayIAQZ4BTQRAIABBFU8EQCAIQagja0EbTw0CIAdBgNgCayIAQRxwIABBo9cAS3INAiAHIAhqQacjayEADAMLIAdBgCJrIgpBE08NASAKQcwEbCAAQRxsakGA2AJqIQAMAgsgBkH4AWogByAIEI4jIgBBgIDEAEcNAQsgBiAINgLgASAHDAILAkADQCALIQgCQAJAIAYoApwBIgdBEk8EfyAGKAJcIQggBigCWAUgBwsgBigC1AEiB0sEQCAGQShqIAggB0ECdGoQpC8gBigCKCIHQYCAxABHDQELIAZB1ABqEKYpIAZBADYC1AEMAQsgBi0ALCEKIAZB+AFqIA0QpjACQAJAIAdB4SJrIghBngFNBEAgCEEVTwRAIAdBqCNrQRtPDQIgAEGA2AJrIghBHHAgCEGj1wBLcg0CIAAgB2pBpyNrIQkMAwsgAEGAImsiB0ETTw0BIAdBzARsIAhBHGxqQYDYAmohCQwCCyAGQfgBaiAAIAcQjiMiCUGAgMQARw0BCyAGQfgBaiIHIAZB1ABqIAYoAtQBEJUXIAcQ5RQgBkEANgLUASAKQf8BcUUNA0EBIQkDQCALIQcgBigCnAEiCEESTwRAIAYoAlghCCAGKAJcIQcLIAggCU0NAiAGQSBqIAcgCUECdGoQpC8gBigCICIIQYCAxABGDQIgBi0AJCIHRQ0EAkACQCAKQf8BcSAHRgRAIAohBwwBCyAGQfgBaiIPIA0QpjAgDyAAIAgQjiMiCEGAgMQARw0BCyAJQQFqIQkgByEKDAELIAZB1ABqIAkQ2RogCCEADAALAAsgBiAGKALUAUEBajYC1AEgCSEADAELCyAGKAKcASIHQRJPBH8gBigCWAUgBwsNACAGKAKgASIJQYCAxABGDQAgCSAGKALwAUkNACAGKAKkASIIQQBODQAgBkGAgMQANgKgAUEBIQogACEHDAELCyAACyIJQYCAxABGDQELIAlB/wBLDQEgBkEQaiAGKAL0ASIAKQMAIAApAwggCRDHIyAGKQMQQgGDUA0CDAMLIAZB1ABqEMQoIA0Q2ikgBkEIaiABIAJBzP3FABDWJAJAIAQgBigCDCIAIAAgBEsbIgFFDQAgBigCCCEAQQAhCQNAIAAoAgAgAygCAEYEQCAAQQRqIQAgA0EEaiEDIAlBAWoiCSABRw0BDAILCyAAQf3/AzYCACABIAlLQQENBRogBUEBOgAAC0EADAQLIAlB/f8DRw0ADAELAn8gDigCACIKQf4BSQRAIAohACAOIQhB/QEhCiAMDAELIAEoAgQhACAMIQggASgCCAshByAAIApGBH8gARD5HyABKAIIIQcgDCEIIAEoAgQFIAALQQJ0IAdqIAk2AgAgCCAIKAIAQQFqNgIADAELCyAGQdQAahDEKCANENopQQELIAZBkAJqJAALjgwCB38CfiMAQeAAayIDJAACQCACLQAMIgRBAUYEQCAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIAIAJBBEEEEOAeDAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAAwiBkEBaw4CAAIBCyAAIAIpAgA3AgAgAEECIARrOgAMIAAgAi8ADTsADSAAQQhqIAJBCGooAgA2AgAgAEEPaiACQQ9qLQAAOgAADAcLIARFDQEMAgsgBEUNAQsCfyABKAIIIgQgAigCCCIFRwRAIAQgBUsgBCAFSWsMAQsgBEECdCEEIAEoAgRBBGshCCACKAIEQQRrIQkCQANAIARFDQEgBCAJaiEHIAQgCGogBEEEayEEKAIAIgUgBygCACIHRg0ACyAFIAdLIAUgB0lrDAELQX9BACAEGwtB/wFxDgICAwELIANBOGogAUEIaiIEKAIANgIAIAMgASkCACIKNwMwIANByABqIAJBCGoiBSgCADYCACADIAIpAgAiCzcDQAJ/IAqnIAunSQRAIANB2ABqIAUoAgA2AgAgAyACKQIANwNQIANBJGogA0HQAGogA0EwaiIBEO0IIAEMAQsgA0HYAGogBCgCADYCACADIAEpAgA3A1AgA0EkaiADQdAAaiADQUBrIgEQ7QggAQsiBEEEQQQQ4B4gBkEBRwRAIAZBASADKAIsGyEEDAoLIANBADYCLCADQSRqQQRBBBCeJCADKAIsIgFFDQggAygCKCICIAFBAnQiBWpBBGsiBEUNCCAEKAIADQggBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0JCyADIAQ2AiwgBCEBDAgLIANB2ABqIgQgAkEIaigCADYCACADIAIpAgA3A1AgA0HQAGogARDvFCADQcgAaiAEKAIANgIAIAMgAykDUDcDQCABQQRBBBDgHiAGQQFxRQRAQQIgBmtBASADKAJIGyEEDAcLIANBADYCSCADQUBrQQRBBBCeJCADKAJIIgFFDQUgAygCRCICIAFBAnQiBWpBBGsiBEUNBSAEKAIADQUgBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0GCyADIAQ2AkggBCEBDAULIABBCGpBlIqIASkCADcCACAAQYyKiAEpAgA3AgAgAkEEQQQQ4B4MAQsgA0HYAGoiBCABQQhqKAIANgIAIAMgASkCADcDUCADQdAAaiACEO8UIANByABqIAQoAgA2AgAgAyADKQNQNwNAIAJBBEEEEOAeIAZBAUcEQCAGQQEgAygCSBshBAwDCyADQQA2AkggA0FAa0EEQQQQniQgAygCSCIBRQ0BIAMoAkQiAiABQQJ0IgVqQQRrIgRFDQEgBCgCAA0BIAUhBCACQQRrIQYgAUH/////A3EhAgJAA0AgBEUEQEEAIQQMAgsgAkEBayECIAQgBmogBEEEayEEKAIARQ0ACyACQQFqIgQgAUsNAgsgAyAENgJIIAQhAQwBCyABQQRBBBDgHgwGC0EBIQQgASADKAJAQQJ2Tw0AIANBEGogA0FAayABQQRBBBD0FCADKAIQIgFBgYCAgHhGDQAgASADKAIUQcyNiAEQ/S8ACyAAIAMpA0A3AgAgACAEOgAMIABBCGogA0HIAGooAgA2AgAMBAtBASEEIAEgAygCQEECdk8NACADQQhqIANBQGsgAUEEQQQQ9BQgAygCCCIBQYGAgIB4Rg0AIAEgAygCDEHMjYgBEP0vAAsgACADKQNANwIAIAAgBDoADCAAQQhqIANByABqKAIANgIADAILQQEhBCABIAMoAiRBAnZPDQAgA0EYaiADQSRqIAFBBEEEEPQUIAMoAhgiAUGBgICAeEYNACABIAMoAhxBzI2IARD9LwALIAAgAykCJDcCACAAIAQ6AAwgAEEIaiADQSxqKAIANgIACyADQeAAaiQAC5ALAgp/AX4gBEUEQCAAQQA2AjwgACADNgI4IAAgAjYCNCAAIAE2AjAgAEEAOgAOIABBgQI7AQwgACACNgIIIABCADcDAA8LQQEhDEEBIQkCQAJAAkACQAJAAkACQAJAAkAgBEEBRwRAQQEhBUEBIQcDQCAGIAtqIgkgBE8NAiAHIQgCQCADIAVqLQAAIgUgAyAJai0AACIJSQRAIAYgB2pBAWoiByALayEMQQAhBgwBCyAFIAlHBEBBASEMIAhBAWohB0EAIQYgCCELDAELQQAgBkEBaiIHIAcgDEYiBRshBiAHQQAgBRsgCGohBwsgBiAHaiIFIARJDQALQQEhBUEBIQdBACEGQQEhCQNAIAYgCmoiDSAETw0DIAchCAJAIAMgBWotAAAiBSADIA1qLQAAIg1LBEAgBiAHakEBaiIHIAprIQlBACEGDAELIAUgDUcEQEEBIQkgCEEBaiEHQQAhBiAIIQoMAQtBACAGQQFqIgcgByAJRiIFGyEGIAdBACAFGyAIaiEHCyAGIAdqIgUgBEkNAAsLIAQgCyAKIAogC0kiBxsiDUkNAiAMIAkgBxsiByANaiIFIAdJDQMgBCAFSQ0EAn8gAyADIAdqIA0QmScEQCAEQQNxIQgCQCAEQQFrQQNJBEBBACEHDAELIARBfHEhDEEAIQcDQEIBIAMgB2oiBUEDajEAAIZCASAFMQAAhiAPhEIBIAVBAWoxAACGhEIBIAVBAmoxAACGhIQhDyAMIAdBBGoiB0cNAAsLIAgEQCADIAdqIQYDQEIBIAYxAACGIA+EIQ8gBkEBaiEGIAhBAWsiCA0ACwsgBCANayIHIA0gByANSxtBAWohB0F/IQogDSEMQX8MAQtBASELQQAhBkEBIQVBACEMA0AgBCAFIgggBmoiCksEQCAEIAZrIAVBf3NqIgUgBE8NCCAEIAZBf3NqIAxrIgkgBE8NCQJAIAMgBWotAAAiBSADIAlqLQAAIglJBEAgCkEBaiIFIAxrIQtBACEGDAELIAUgCUcEQCAIQQFqIQVBACEGQQEhCyAIIQwMAQtBACAGQQFqIgUgBSALRiIJGyEGIAVBACAJGyAIaiEFCyAHIAtHDQELC0EBIQtBACEGQQEhBUEAIQkDQCAEIAUiCCAGaiIOSwRAIAQgBmsgBUF/c2oiBSAETw0KIAQgBkF/c2ogCWsiCiAETw0LAkAgAyAFai0AACIFIAMgCmotAAAiCksEQCAOQQFqIgUgCWshC0EAIQYMAQsgBSAKRwRAIAhBAWohBUEAIQZBASELIAghCQwBC0EAIAZBAWoiBSAFIAtGIgobIQYgBUEAIAobIAhqIQULIAcgC0cNAQsLIAQgCSAMIAkgDEsbayEMAkAgB0UEQEEAIQdBACEKDAELIAdBA3EhBUEAIQoCQCAHQQRJBEBBACEIDAELIAdBfHEhC0EAIQgDQEIBIAMgCGoiBkEDajEAAIZCASAGMQAAhiAPhEIBIAZBAWoxAACGhEIBIAZBAmoxAACGhIQhDyALIAhBBGoiCEcNAAsLIAVFDQAgAyAIaiEGA0BCASAGMQAAhiAPhCEPIAZBAWohBiAFQQFrIgUNAAsLIAQLIQYgACAENgI8IAAgAzYCOCAAIAI2AjQgACABNgIwIAAgBjYCKCAAIAo2AiQgACACNgIgIABBADYCHCAAIAc2AhggACAMNgIUIAAgDTYCECAAIA83AwggAEEBNgIADwsgCSAEQbT8iQEQwyEACyANIARBtPyJARDDIQALIA0gBEGU/IkBELA7AAsgByAFQaT8iQEQsTsACyAFIARBpPyJARCwOwALIAUgBEHE/IkBEMMhAAsgCSAEQdT8iQEQwyEACyAFIARBxPyJARDDIQALIAogBEHU/IkBEMMhAAuRDAIKfwN+IwBBwAFrIgQkACABQQxqENk8IQgCQAJAAkACQAJAAkAgARCSNiIFBEBBwAAhBiAEQRhqIAUQ3DsgBSgCFCEHIAUoAgwhCiAEKAIcIQwgBCgCGCELIAhBA3YgCEEHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0GIAUEQCAFQcAAEK02IgZFDQQLIARCADcCMCAEIAY2AiwgBCAFNgIoIARBwAA2AiQgBEEkaiAKIAggCmogCyAMEL8YDAELQcAAIQYgCEEDdiAIQQdxQQBHaiIHQcD///8DcUFAayAHIAdBP3EbIgdBwAAQ0TRFDQUgBwRAIAdBwAAQrTYiBkUNAgsgBEIANwIwIAQgBjYCLCAEIAc2AiggBEHAADYCJCAEQSRqIAgQ3hBBACEHCyAIQQJ0IgkhBQJAIAlBPHEiBgRAIAkgBmtBQGsiBSAJSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIARBADYCSCAEIAY2AkAgBCAFNgI8IARBwAA2AjggCQRAIAkEQCAGQQAgCfwLAAsgBCgCSCENIAQoAkAhBgsgBCAJNgJEIAQgCCANajYCSCAHBEAgByAIRw0GIAghBwwHCyAIRQRAQQAhBwwHCyADLQAAIQkgAigCACECIAEoAhAhBUEAIQdBACEBA0ACQAJAAkAgAkUEQCAEQYeAgIB4NgJwIARB8ABqEIgRDAELIAUvAQAgAm0iAyAJEMQpRQ0AIAYgAzYCAAwBCyAEQQhqIARBJGoQhj0gAUEDdiIDIAQoAgwiCk8NASAEKAIIIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcLIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQEMCAsLIAMgCkGIi/8AEMMhAAtBwAAgBRCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBxCjPQALQcAAIAUQoz0ACyALBEAgBEHwAGogCyAMIAogCBC/FCAEQZABaiEIIAMtAAAhBSACKAIAIQIgASgCECEJA0ACQCAEKQOYASIPUEUEQCAEKQOgASEODAELA0ACfgJAIAQpA4ABIg5CA1IEQAJAAkACQCAOQgJRDQAgBCAOUK1CAYY3A4ABIA6nQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAgQtiogBCkDqAEhDgsgDkIAUg0CCyAEQgM3A4ABCyAEKQNwIg5CAlENBiAEQgA3A3AgBCkDeAwBCyAEKQOwAQshDyAOp0EBcUUNBCAEIAQpA6ABQkB9Ig43A6ABIAQgDzcDmAEgD1ANAAsLIAQgD0IBIA96IhCGhTcDmAEgEKcgDqdqIQECQCACRQRAIARBh4CAgHg2AqgBIARBqAFqEIgRDAELIAkgAUEBdGovAQAgAm0iAyAFEMQpRQ0AIAYgAUECdGogAzYCAAwBCyAEQRBqIARBJGoQhj0gAUEDdiIDIAQoAhQiCkkEQCAEKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAHQQFqIQcMAQsLIAMgCkGIi/8AEMMhAAtBxIr/ABCyOwALIARB0ABqIARBJGoiBhCCFCAEQfAAaiICEJcpIARBQGsiASgCACEFIAQoAkQhAyABIARB+ABqIggpAgA3AwAgBCkDOCEOIAQgBCkCcDcDOCAEQQA2AkggBCAONwJ8IARBADYCeCAEIAM2AnQgBCAFNgJwIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAgpAgA3AgAgAUEYaiAEQYABaiIJKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ5RkgCSAEQeAAaigCADYCACAIIARB2ABqKQIANwMAIAQgBCkCUDcDcCAEIAc2AoQBIAAgASACEModIARBOGoQzy8gBhDPLyAEQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALkQwCCn8DfiMAQcABayIEJAAgAUEMahDZPCEIAkACQAJAAkACQAJAIAEQkjYiBQRAQcAAIQYgBEEYaiAFENw7IAUoAhQhByAFKAIMIQogBCgCHCEMIAQoAhghCyAIQQN2IAhBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBiAFBEAgBUHAABCtNiIGRQ0ECyAEQgA3AjAgBCAGNgIsIAQgBTYCKCAEQcAANgIkIARBJGogCiAIIApqIAsgDBC/GAwBC0HAACEGIAhBA3YgCEEHcUEAR2oiB0HA////A3FBQGsgByAHQT9xGyIHQcAAENE0RQ0FIAcEQCAHQcAAEK02IgZFDQILIARCADcCMCAEIAY2AiwgBCAHNgIoIARBwAA2AiQgBEEkaiAIEN4QQQAhBwsgCEECdCIJIQUCQCAJQTxxIgYEQCAJIAZrQUBrIgUgCUkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgBTYCPCAEQcAANgI4IAkEQCAJBEAgBkEAIAn8CwALIAQoAkghDSAEKAJAIQYLIAQgCTYCRCAEIAggDWo2AkggBwRAIAcgCEcNBiAIIQcMBwsgCEUEQEEAIQcMBwsgAy0AACEJIAIoAgAhAiABKAIQIQVBACEHQQAhAQNAAkACQAJAIAJFBEAgBEGHgICAeDYCcCAEQfAAahCIEQwBCyAFLgEAIAJtIgMgCRDEKUUNACAGIAM2AgAMAQsgBEEIaiAEQSRqEIY9IAFBA3YiAyAEKAIMIgpPDQEgBCgCCCADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHCyAGQQRqIQYgBUECaiEFIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAUQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyAJIAFBAXRqLgEAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC5sLARl/IwBBEGsiECQAIAIoAgQhDCACKAIAIQ8gAEEANgLcASADIARqIg1BCGshByANQRBrIR1BBEEGIAAoAsQBIgQgBEEGTxsiBCAEQQRNGyEWQQRBBiAAKALIASIEIARBBk8bIgQgBEEETRshFyAAKAIQIAAoAgghFCADIAAoAgQiESAAKAIMIhVqIhhGIQQgACgCuAEhCiAFQQJHIh5FBEAgACARIBcgACgCHCAdEKAaCyAdIAcgBUECRhshGiAUaiEfIBQgFWohGyADIARqIQQgFUEBayEcQQEgCnQhEgNAAkACQCAEIBpJBEAgBEEBaiEKQQAhCQJAIBwgBCARayITQQFqIgggD2siC2tBA0kNACAPIAggACgCECIHIAggEmsgByAIIAdrIBJLGyAAKAIYG2tLDQAgCigAACALIBQgESALIBVJIgsbaiIHKAAARw0AIARBBWogB0EEaiANIBsgDSALGyAYEM0oQQRqIQkgBg0AQQEhBwwDCyAQQf+T69wDNgIMIAAgBCANIBBBDGogFyAWIAVBARC3BiIHIAkgByAJSyIHGyIJQQNNBEAgACAEIANrIgpB/xFLNgLcASAEIApBCHZqQQFqIQQMBAsgBCAKIAcbIQogECgCDEEBIAcbIQcCQCAGRQ0AA0AgBCAaTw0BIBNBAWohGSAEQQFqIQsCQCAHRQRAQQAhBwwBCyAcIBkgD2siDmtBA0kNACAPIBkgACgCECIIIBkgEmsgCCAZIAhrIBJLGyAAKAIYG2tLDQAgCygAACAOIBQgESAOIBVJIg4baiIIKAAARw0AIARBBWogCEEEaiANIBsgDSAOGyAYEM0oIghBe0sNACAHZyAJQQNsakEeayAIQQRqIghBA2xODQBBASEHIAshCiAIIQkLIBBB/5Pr3AM2AggCQCAAIAsgDSAQQQhqIBcgFiAFQQEQtwYiDkEESQ0AIBAoAggiCGcgDkECdGpBH2sgB2cgCUECdGpBG2tMDQAgGSETIAghByAOIQkgCyIKIQQMAQsgBkECRyALIBpPcg0BIBNBAmohEyAEQQJqIQsCQCAHRQRAQQAhBwwBCyAcIBMgD2siDmtBA0kNACAPIBMgACgCECIIIBMgEmsgCCATIAhrIBJLGyAAKAIYG2tLDQAgCygAACAOIBQgESAOIBVJIg4baiIIKAAARw0AIARBBmogCEEEaiANIBsgDSAOGyAYEM0oIgRBe0sNACAHZyAJQQJ0akEeayAEQQRqIgRBAnRODQBBASEHIAshCiAEIQkLIBBB/5Pr3AM2AgQgACALIA0gEEEEaiAXIBYgBUEBELcGIghBBEkNASAQKAIEIgRnIAhBAnRqQR9rIAdnIAlBAnRqQRhrTA0BIAQhByAIIQkgCyIKIQQMAAsACyAHQQRJDQIgFCARIAogByARamtBA2oiBCAVSSIMGyAEaiEEIB8gGCAMGyEIIAdBA2shCwNAIAQgCE0gAyAKT3INAiAKQQFrIgwtAAAgBEEBayIELQAARw0CIAlBAWohCSAMIQoMAAsACyACIAw2AgQgAiAPNgIAIBBBEGokACANIANrDwsgDyEMIAshDwsgASAKIANrIAMgDSAHIAkQhRIgACgC3AEEQCAeRQRAIAAgESAXIAAoAhwgHRCgGgsgAEEANgLcAQsgCSAKaiEDA0ACQCAMIQQgAyAaSw0AIBQgESADIBFrIgcgBGsiDCAVSSIKGyAMaiEJIBwgDGtBA0kgByAAKAIQIgwgByASayAMIAcgDGsgEksbIAAoAhgbayAESXINACADKAAAIAkoAABHDQAgAUEAIAMgDUEBIANBBGogCUEEaiANIBsgDSAKGyAYEM0oQQRqIgoQhRIgAyAKaiEDIA8hDCAEIQ8MAQsLIAQhDCADIQQMAAsAC4oMAgp/BH4jAEHgAWsiAyQAIAFBDGoQ2DwhBwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBSADQUBrIAQQ3DsgBCgCFCEGIAQoAgwhCSADKAJEIQsgAygCQCEKIAdBA3YgB0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgVFDQQLIANCADcCWCADIAU2AlQgAyAENgJQIANBwAA2AkwgA0HMAGogCSAHIAlqIAogCxC/GAwBC0HAACEFIAdBA3YgB0EHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIANCADcCWCADIAU2AlQgAyAGNgJQIANBwAA2AkwgA0HMAGogBxDeEEEAIQYLIAdBA3QiBSEEAkAgBUE4cSIIBEAgBSAIa0FAayIEIAVJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQsgA0EANgJwIAMgCDYCaCADIAQ2AmQgA0HAADYCYCAFBEAgBQRAIAhBACAF/AsACyADKAJwIQwgAygCaCEICyADIAU2AmwgAyAHIAxqNgJwAkACQCAGBEAgBiAHRw0BIAchBgwICyAHRQRAQQAhBgwICyACKQMAIQ0gASgCECEFQQAhBkEAIQQDQCADQRBqIAUpAwAiDiAOQj+HIA0gDUI/hxCoHgJAIAMpAxggAykDECIOQj+HUQRAIAggDjcDAAwBCyADQQhqIANBzABqEIY9IARBA3YiASADKAIMIgJPDQMgAygCCCABaiIBIAEtAABBfiAEQQdxd3E6AAAgBkEBaiEGCyAIQQhqIQggBUEIaiEFIAcgBEEBaiIERw0ACwwHCyAKBEAgA0GYAWogCiALIAkgBxC/FCADQbgBaiEHIAIpAwAhDyABKAIQIQQDQAJAIAMpA8ABIg5QRQRAIAMpA8gBIQ0MAQsDQAJ+AkAgAykDqAEiDUIDUgRAAkACQAJAIA1CAlENACADIA1QrUIBhjcDqAEgDadBAXFFDQAgAyADKQOwATcD2AEMAQsgAygCuAFFDQEgA0HQAWogBxC2KiADKQPQASENCyANQgBSDQILIANCAzcDqAELIAMpA5gBIg1CAlENDCADQgA3A5gBIAMpA6ABDAELIAMpA9gBCyEOIA2nQQFxRQ0KIAMgAykDyAFCQH0iDTcDyAEgAyAONwPAASAOUA0ACwsgAyAOQgEgDnoiEIaFNwPAASADQTBqIAQgEKcgDadqIgFBA3QiAmopAwAiDSANQj+HIA8gD0I/hxCoHiADKQM4IAMpAzAiDUI/h1EEQCACIAhqIA03AwAMAQsgA0EoaiADQcwAahCGPSABQQN2IgIgAygCLCIFSQRAIAMoAiggAmoiAiACLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgAiAFQYiL/wAQwyEAC0HEiv8AELI7AAsgASACQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgBBCjPQALIANB+ABqIANBzABqIgUQghQgA0GYAWoiAhCXKSADQegAaiIBKAIAIQggAygCbCEHIAEgA0GgAWoiBCkCADcDACADKQNgIQ0gAyADKQKYATcDYCADQQA2AnAgAyANNwKkASADQQA2AqABIAMgBzYCnAEgAyAINgKYASADIAIQ1zsgAygCACEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAMpApgBNwIIIAFBEGogBCkCADcCACABQRhqIANBqAFqIgkoAgA2AgAgAyAHNgLYASADIAg2AtQBIAMgATYC0AEgA0GMAWoiASADQdABahDkGSAJIANBiAFqKAIANgIAIAQgA0GAAWopAgA3AwAgAyADKQJ4NwOYASADIAY2AqwBIAAgASACENYdIANB4ABqEM8vIAUQzy8gA0HgAWokAA8LQQRBHBCjPQALQdyL/wBBKSADQZgBakHsj/8AQYiM/wAQ1R4AC4oMAgp/A34jAEHAAWsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBAnQiBSEJAkAgBUE8cSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAk2AjwgBEHAADYCOCAFBEAgBQRAIAZBACAF/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAU2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhBSACKAIAIQIgASgCECEJQQAhB0EAIQEDQAJAAkACQCACRQRAIARBh4CAgHg2AnAgBEHwAGoQiBEMAQsgASAJai0AACACbSIDIAUQxClFDQAgBiADNgIADAELIARBCGogBEEkahCGPSABQQN2IgMgBCgCDCIKTw0BIAQoAgggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEEaiEGIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyABIAlqLQAAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC4oMAgp/A34jAEHAAWsiBCQAIAFBDGooAgghCAJAAkACQAJAAkACQCABEJI2IgUEQEHAACEGIARBGGogBRDcOyAFKAIUIQcgBSgCDCEKIAQoAhwhDCAEKAIYIQsgCEEDdiAIQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiBkUNBAsgBEIANwIwIAQgBjYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAogCCAKaiALIAwQvxgMAQtBwAAhBiAIQQN2IAhBB3FBAEdqIgdBwP///wNxQUBrIAcgB0E/cRsiB0HAABDRNEUNBSAHBEAgB0HAABCtNiIGRQ0CCyAEQgA3AjAgBCAGNgIsIAQgBzYCKCAEQcAANgIkIARBJGogCBDeEEEAIQcLIAhBAnQiBSEJAkAgBUE8cSIGBEAgBSAGa0FAayIJIAVJDQELQcAAIQYgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiBkUNAQsgBEEANgJIIAQgBjYCQCAEIAk2AjwgBEHAADYCOCAFBEAgBQRAIAZBACAF/AsACyAEKAJIIQ0gBCgCQCEGCyAEIAU2AkQgBCAIIA1qNgJIIAcEQCAHIAhHDQYgCCEHDAcLIAhFBEBBACEHDAcLIAMtAAAhBSACKAIAIQIgASgCECEJQQAhB0EAIQEDQAJAAkACQCACRQRAIARBh4CAgHg2AnAgBEHwAGoQiBEMAQsgASAJaiwAACACbSIDIAUQxClFDQAgBiADNgIADAELIARBCGogBEEkahCGPSABQQN2IgMgBCgCDCIKTw0BIAQoAgggA2oiAyADLQAAQX4gAUEHcXdxOgAAIAdBAWohBwsgBkEEaiEGIAggAUEBaiIBRw0BDAgLCyADIApBiIv/ABDDIQALQcAAIAkQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAcQoz0AC0HAACAFEKM9AAsgCwRAIARB8ABqIAsgDCAKIAgQvxQgBEGQAWohCCADLQAAIQUgAigCACECIAEoAhAhCQNAAkAgBCkDmAEiD1BFBEAgBCkDoAEhDgwBCwNAAn4CQCAEKQOAASIOQgNSBEACQAJAAkAgDkICUQ0AIAQgDlCtQgGGNwOAASAOp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAIELYqIAQpA6gBIQ4LIA5CAFINAgsgBEIDNwOAAQsgBCkDcCIOQgJRDQYgBEIANwNwIAQpA3gMAQsgBCkDsAELIQ8gDqdBAXFFDQQgBCAEKQOgAUJAfSIONwOgASAEIA83A5gBIA9QDQALCyAEIA9CASAPeiIQhoU3A5gBIBCnIA6naiEBAkAgAkUEQCAEQYeAgIB4NgKoASAEQagBahCIEQwBCyABIAlqLAAAIAJtIgMgBRDEKUUNACAGIAFBAnRqIAM2AgAMAQsgBEEQaiAEQSRqEIY9IAFBA3YiAyAEKAIUIgpJBEAgBCgCECADaiIDIAMtAABBfiABQQdxd3E6AAAgB0EBaiEHDAELCyADIApBiIv/ABDDIQALQcSK/wAQsjsACyAEQdAAaiAEQSRqIgYQghQgBEHwAGoiAhCXKSAEQUBrIgEoAgAhBSAEKAJEIQMgASAEQfgAaiIIKQIANwMAIAQpAzghDiAEIAQpAnA3AzggBEEANgJIIAQgDjcCfCAEQQA2AnggBCADNgJ0IAQgBTYCcCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAIKQIANwIAIAFBGGogBEGAAWoiCSgCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOUZIAkgBEHgAGooAgA2AgAgCCAEQdgAaikCADcDACAEIAQpAlA3A3AgBCAHNgKEASAAIAEgAhDKHSAEQThqEM8vIAYQzy8gBEHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC6MNAgZ/An4jAEGwAmsiAiQAIAJB2AFqIgNBADYCACACQoCAgICAATcC0AEgAkHQAWpBARCHLSACQagBaiADKAIAIgM2AgAgAiACKQLQASIINwOgASACQTBqIAFBsAJqIgQpAgA3AwAgAkE4aiABQbgCaiIFKQIANwMAIAEpAqgCIQkgASAINwKoAiAEIAM2AgAgBUIBNwMAIAFBADYCtAIgAiAJNwMoIAJBxABqIAEQ2BgCf0GAgICAeCABKALAAiIDQYGAgIB4Rg0AGkGAgICAeCADQYCAgIB4Rg0AGiABKQLEAiEIIAFBADYCyAIgAUKAgICAIDcDwAIgAwshAyABQYgDahC0MCABIAg3AowDIAEgAzYCiAMgASgC6AIiA0GAgICAeEcEQCABKQLsAiEIIAFBADYC8AIgAUKAgICAIDcD6AILIAFBlANqELQwIAEgCDcDmAMgASADNgKUAyABQgA3A/gCAkACQAJAAkACQAJAAkACQAJAAkACQCABLQCgA0Elaw4CAQIACyACQdABaiIDIAFBoANqEMEGIAIgAkEoaiACQcQAaiADEKMLIAIoAgQhAyACKAIAIQEMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEQaiACQShqIAJBxABqIAJB0AFqIgEQowsgAiACKQMQNwKAASACQQhqIAJBgAFqIgYQuSYgASACKAIIIgMgAigCDCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI8dIAJBoAFqIAEgBSAEEKETIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAYQuyMMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEgaiACQShqIAJBxABqIAJB0AFqIgEQowsgAiACKQMgNwKAASACQRhqIAJBgAFqIgYQuSYgASACKAIYIgMgAigCHCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI4dIAJBoAFqIAEgBSAEEKMTIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAYQuyMMBwsgAkGXAWoiASACQbABaikAADcAACACQZABaiIEIAJBqQFqKQAANwMAIAJB2ABqIgUgAkHAAWopAgA3AwAgAkHgAGoiBiACQcgBaikCADcDACACQfAAaiIHIAQpAwA3AwAgAkH3AGoiBCABKQAANwAAIAIgAikCuAE3A1AgAiACKQChATcDaEE4QQQQrTYiAUUNAyABIAM6AAggAUKBgICAEDcCACABIAIpA2g3AAkgASACKQNQNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQayKzQAhAwwFCyACQZcBaiIBIAJBsAFqKQAANwAAIAJBkAFqIgQgAkGpAWopAAA3AwAgAkGIAmoiBSACQcABaikCADcDACACQZACaiIGIAJByAFqKQIANwMAIAJBoAJqIgcgBCkDADcDACACQacCaiIEIAEpAAA3AAAgAiACKQK4ATcDgAIgAiACKQChATcDmAJBOEEEEK02IgFFDQMgASADOgAIIAFCgYCAgBA3AgAgASACKQOYAjcACSABIAIpA4ACNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQZSLzQAhAwwEC0Gcis0AELI7AAtBhIvNABCyOwALQQRBOBCjPQALQQRBOBCjPQALIAAgAzYCCCAAIAE2AgQgAEEINgIACyACQbACaiQAC6MNAgZ/An4jAEGwAmsiAiQAIAJB2AFqIgNBADYCACACQoCAgIDAADcC0AEgAkHQAWpBARCGLSACQagBaiADKAIAIgM2AgAgAiACKQLQASIINwOgASACQTBqIAFBsAJqIgQpAgA3AwAgAkE4aiABQbgCaiIFKQIANwMAIAEpAqgCIQkgASAINwKoAiAEIAM2AgAgBUIBNwMAIAFBADYCtAIgAiAJNwMoIAJBxABqIAEQ2BgCf0GAgICAeCABKALAAiIDQYGAgIB4Rg0AGkGAgICAeCADQYCAgIB4Rg0AGiABKQLEAiEIIAFBADYCyAIgAUKAgICAIDcDwAIgAwshAyABQYgDahC0MCABIAg3AowDIAEgAzYCiAMgASgC6AIiA0GAgICAeEcEQCABKQLsAiEIIAFBADYC8AIgAUKAgICAIDcD6AILIAFBlANqELQwIAEgCDcDmAMgASADNgKUAyABQgA3A/gCAkACQAJAAkACQAJAAkACQAJAAkACQCABLQCgA0Elaw4CAQIACyACQdABaiIDIAFBoANqEMEGIAIgAkEoaiACQcQAaiADEKILIAIoAgQhAyACKAIAIQEMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEQaiACQShqIAJBxABqIAJB0AFqIgEQogsgAiACKQMQNwKAASACQQhqIAJBgAFqIgYQuSYgASACKAIIIgMgAigCDCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI8dIAJBoAFqIAEgBSAEEKETIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0IIAYQuyMMCAsgAS0AogMhBCABLQChAyEFIAJBFDoA0AEgAkEgaiACQShqIAJBxABqIAJB0AFqIgEQogsgAiACKQMgNwKAASACQRhqIAJBgAFqIgYQuSYgASACKAIYIgMgAigCHCgCDBEAACADRQ0DIAIpA9ABQpCes+7ZtI2S6QCFIAIpA9gBQoj0q4HgscXkwgCFhFBFDQMgASADEI4dIAJBoAFqIAEgBSAEEKMTIAItAKABIgNBKUcNASACQZsBaiACQbQBaigCACIDNgAAIAJBkwFqIAJBrAFqKQIAIgg3AAAgAiACKQKkASIJNwCLASACQeABaiADNgIAIAJB2AFqIAg3AwAgAiAJNwPQASAAIAEQpiUgAigCgAEiACAAKAIAIgBBAWs2AgAgAEEBRw0HIAYQuyMMBwsgAkGXAWoiASACQbABaikAADcAACACQZABaiIEIAJBqQFqKQAANwMAIAJB2ABqIgUgAkHAAWopAgA3AwAgAkHgAGoiBiACQcgBaikCADcDACACQfAAaiIHIAQpAwA3AwAgAkH3AGoiBCABKQAANwAAIAIgAikCuAE3A1AgAiACKQChATcDaEE4QQQQrTYiAUUNAyABIAM6AAggAUKBgICAEDcCACABIAIpA2g3AAkgASACKQNQNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQayKzQAhAwwFCyACQZcBaiIBIAJBsAFqKQAANwAAIAJBkAFqIgQgAkGpAWopAAA3AwAgAkGIAmoiBSACQcABaikCADcDACACQZACaiIGIAJByAFqKQIANwMAIAJBoAJqIgcgBCkDADcDACACQacCaiIEIAEpAAA3AAAgAiACKQK4ATcDgAIgAiACKQChATcDmAJBOEEEEK02IgFFDQMgASADOgAIIAFCgYCAgBA3AgAgASACKQOYAjcACSABIAIpA4ACNwIgIAFBEWogBykDADcAACABQRhqIAQpAAA3AAAgAUEoaiAFKQMANwIAIAFBMGogBikDADcCACACKAKAASIDIAMoAgAiA0EBazYCACADQQFGBEAgAkGAAWoQuyMLQZSLzQAhAwwEC0Gcis0AELI7AAtBhIvNABCyOwALQQRBOBCjPQALQQRBOBCjPQALIAAgAzYCCCAAIAE2AgQgAEEINgIACyACQbACaiQAC8gLAhB/An4jAEFAaiIGJAACQCABKAIMIg4gAmoiAiAOTwRAAkACQCABKAIEIgggCEEBaiIMQQN2IgRBB2wgCEEISRsiEEEBdiACSQRAIAZBMGoCfyAQQQFqIgUgAiACIAVJGyICQQ9PBEAgAkH/////AUsNBEF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwsiAkEYQQggAhCdFCAGKAI0IQkgBigCMCIFRQRAIAYoAjghAgwFCyAGKQI4IRQgCUEJaiICBEAgBUH/ASAC/AsACyAGIBRCIIg+AiwgBiAUpyIPNgIoIAYgCTYCJCAGIAU2AiAgBkEINgIcQQAhAiAOBEAgBUEYayEKIAVBCGohCyABKAIAIgRBGGshDCAEKQMAQn+FQoCBgoSIkKDAgH+DIRQDQCAUUARAA0AgAkEIaiECIARBCGoiBCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgBSAJIAMgDCAUeqdBA3YgAmoiEEFobGoQ+AunIhFxIgdqKQAAQoCBgoSIkKDAgH+DIhVQBEBBCCEIA0AgByAIaiEHIAhBCGohCCAFIAcgCXEiB2opAABCgIGChIiQoMCAf4MiFVANAAsLIBRCAX0gFIMhFCAFIBV6p0EDdiAHaiAJcSIHaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAFIAdqIBFBGXYiCDoAACALIAdBCGsgCXFqIAg6AAAgCiAHQWhsaiIHQRBqIAwgEEFobGoiCEEQaikAADcAACAHQQhqIAhBCGopAAA3AAAgByAIKQAANwAAIA5BAWsiDg0ACyABKAIMIQILIAYgAjYCLCAGIA8gAms2AigDQCABIA1qIgIoAgAhAyACIAYgDWpBIGoiAigCADYCACACIAM2AgAgDUEEaiINQRBHDQALIAYoAiQiAkUNASACIAJBGGxBH2pBeHEiAWpBCWoiAkUNASAGKAIgIAFrIAJBCBD4OgwBCyABKAIAIQUgBCAMQQdxQQBHaiIEBEAgBSECA0AgAiACKQMAIhRCf4VCB4hCgYKEiJCgwIABgyAUQv/+/fv379+//wCEfDcDACACQQhqIQIgBEEBayIEDQALCwJAAkAgDEEITwRAIAUgDGogBSkAADcAAAwBCyAMBEAgBUEIaiAFIAz8CgAACyAMRQ0BCyAFQQhqIQ8gBUEYayERQQEhBCAFIQlBACECA0AgAiEHIAQhAgJAIAUgB2oiEy0AAEGAAUcNACARIAdBaGxqIQ0CQANAIAggAyANEPgLpyIScSIKIQQgBSAKaikAAEKAgYKEiJCgwIB/gyIUUARAQQghCwNAIAQgC2ohBCALQQhqIQsgBSAEIAhxIgRqKQAAQoCBgoSIkKDAgH+DIhRQDQALCyAFIBR6p0EDdiAEaiAIcSIEaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEECyAEIAprIAcgCmtzIAhxQQhPBEAgBCAFaiIKLQAAIAogEkEZdiIKOgAAIA8gBEEIayAIcWogCjoAACAEQWhsIQRB/wFGDQIgBCAFaiEKQWghBANAIAQgCWoiCygAACESIAsgBCAKaiILKAAANgAAIAsgEjYAACAEQQRqIgQNAAsMAQsLIBMgEkEZdiIEOgAAIA8gB0EIayAIcWogBDoAAAwBCyATQf8BOgAAIA8gB0EIayAIcWpB/wE6AAAgBCARaiIEQRBqIA1BEGopAAA3AAAgBEEIaiANQQhqKQAANwAAIAQgDSkAADcAAAsgCUEYayEJIAIgAiAMSSIHaiEEIAcNAAsLIAEgECAOazYCCAtBgYCAgHghCQwCCxDjJyAGKAIMIQIgBigCCCEJDAELEOMnIAYoAgQhAiAGKAIAIQkLIAAgCTYCACAAIAI2AgQgBkFAayQAC7UMAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiBigCACIFLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkwgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwNYIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEHYAGogAxCeJSECDAwLIARB2ABqIAMQuRwhAgwLCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQsgACgCECACQQN0aikDACEHIAUoAgQiAEUNAiAEIAVBBGo2AhQgBEEYaiAAQQhqIAUoAggQihggBCgCGEGTgICAeEYNAyAEQcwAaiAHEP0XIAQoAkxFDQQgBEE4aiAEQdQAaigCADYCACAEIAQpAkw3AzAgBEEDNgJsIARBlJyEATYCaCAEQgI3AnQgBEH5FzYCZCAEQZMMNgJcIAQgBEHYAGo2AnAgBCAEQRRqNgJgIAQgBEEwajYCWCADKAIAIAMoAgQgBEHoAGoQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQogBCAAKAIQIAJBA3RqKQMAIgc3AwAgBEHoAGoiACAHEP0XIAQoAmgiAUUNBSAEIAE2AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGSDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCMAQSBrIgAkACAAQRBqQbCthgEoAgA2AgAgAEGorYYBKQIANwMIIABBFGogBxD9FyAEQdgAaiIBIAAoAhQEfyABIAApAhg3AgRBAQVBAAs2AgAgAEEIahDJDCAAQSBqJAAgBCgCWEUNBSAEIAQpAlw3AjAgBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQTBqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIARB2ABqIAcQ/RcgBCgCWARAIARBIGogBEHgAGooAgA2AgAgBCAEKQJYNwMYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkww2AjQgBCAEQTBqNgJwIAQgBEEYajYCMCADKAIAIAMoAgQgBEHoAGoQywohAgwICyADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEEwaiAHIAQoAhwQzyUgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAENgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBEEIajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMAwsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYCyAEQegAakHIl4QBEO8sAAu1DAIDfwF+IwBBgAFrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgYoAgAiBS0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgJMIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDWCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARB2ABqIAMQniUhAgwMCyAEQdgAaiADELkcIQIMCwsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0LIAAoAhAgAkEDdGopAwAhByAFKAIEIgBFDQIgBCAFQQRqNgIUIARBGGogAEEIaiAFKAIIEIoYIAQoAhhBk4CAgHhGDQMgBEHMAGogBxCBFSAEKAJMRQ0EIARBOGogBEHUAGooAgA2AgAgBCAEKQJMNwMwIARBAzYCbCAEQZSchAE2AmggBEICNwJ0IARB+Rc2AmQgBEGTDDYCXCAEIARB2ABqNgJwIAQgBEEUajYCYCAEIARBMGo2AlggAygCACADKAIEIARB6ABqEMsKIQIMCQsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0KIAQgACgCECACQQN0aikDACIHNwMAIARB6ABqIgAgBxCBFSAEKAJoIgFFDQUgBCABNgJYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkgw2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AhggAygCACADKAIEIAAQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQkgBCAAKAIQIAJBA3RqKQMAIgc3AwgjAEEgayIAJAAgAEEQakG4rIYBKAIANgIAIABBsKyGASkCADcDCCAAQRRqIAcQgRUgBEHYAGoiASAAKAIUBH8gASAAKQIYNwIEQQEFQQALNgIAIABBCGoQyQwgAEEgaiQAIAQoAlhFDQUgBCAEKQJcNwIwIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBlAw2AhwgBCAEQRhqNgJwIAQgBEEwajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwICyAEQdgAaiAHEIEVIAQoAlgEQCAEQSBqIARB4ABqKAIANgIAIAQgBCkCWDcDGCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZMMNgI0IAQgBEEwajYCcCAEIARBGGo2AjAgAygCACADKAIEIARB6ABqEMsKIQIMCAsgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBMGogByAEKAIcEMwlIAQoAjAEQCAEQeAAaiAEQThqKQIANwMAIAQgBCkCMDcDWCAEQcwAaiIAIARB2ABqEK4HIARB+hc2AkggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBCAANgJEIAQgBEHEAGo2AnAgAygCACADKAIEIARB6ABqEMsKIQIgABDeOwwGCyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAULIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBAsgBEHYAGogAxC4HCECDAQLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBDYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwDCyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIARBCGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMAgsgBCAANgIwIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEEwajYCICAEIARBzABqNgIYDAMLIARBGGoQ5RALIARBgAFqJAAgAg8LIAQgATYCWCAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARB2ABqNgIgIAQgBEEwajYCGAsgBEHoAGpByJeEARDvLAALtQwCA38BfiMAQYABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCTCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3A1ggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQdgAaiADEJ4lIQIMDAsgBEHYAGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQ1hUgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCiAEIAAoAhAgAkEDdGopAwAiBzcDACAEQegAaiIAIAcQ1hUgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCQsgACgCBCIAKAIUIQEgBCACNgIwIAIgAUEDdiIBTw0JIAQgACgCECACQQN0aikDACIHNwMIIwBBIGsiACQAIABBEGpB1K2GASgCADYCACAAQcythgEpAgA3AwggAEEUaiAHENYVIARB2ABqIgEgACgCFAR/IAEgACkCGDcCBEEBBUEACzYCACAAQQhqEMkMIABBIGokACAEKAJYRQ0FIAQgBCkCXDcCMCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZQMNgIcIAQgBEEYajYCcCAEIARBMGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMCAsgBEHYAGogBxDWFSAEKAJYBEAgBEEgaiAEQeAAaigCADYCACAEIAQpAlg3AxggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGTDDYCNCAEIARBMGo2AnAgBCAEQRhqNgIwIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQTBqIAcgBCgCHBDOJSAEKAIwBEAgBEHgAGogBEE4aikCADcDACAEIAQpAjA3A1ggBEHMAGoiACAEQdgAahCuByAEQfoXNgJIIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IAQgADYCRCAEIARBxABqNgJwIAMoAgAgAygCBCAEQegAahDLCiECIAAQ3jsMBgsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwFCyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAQLIARB2ABqIAMQuBwhAgwECyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIAQ2AhggAygCACADKAIEIARB6ABqEMsKIQIMAwsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAEQQhqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAILIAQgADYCMCAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARBMGo2AiAgBCAEQcwAajYCGAwDCyAEQRhqEOUQCyAEQYABaiQAIAIPCyAEIAE2AlggBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQdgAajYCICAEIARBMGo2AhgLIARB6ABqQciXhAEQ7ywAC7UMAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiBigCACIFLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkwgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwNYIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEHYAGogAxCeJSECDAwLIARB2ABqIAMQuRwhAgwLCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQsgACgCECACQQN0aikDACEHIAUoAgQiAEUNAiAEIAVBBGo2AhQgBEEYaiAAQQhqIAUoAggQihggBCgCGEGTgICAeEYNAyAEQcwAaiAHEP0VIAQoAkxFDQQgBEE4aiAEQdQAaigCADYCACAEIAQpAkw3AzAgBEEDNgJsIARBlJyEATYCaCAEQgI3AnQgBEH5FzYCZCAEQZMMNgJcIAQgBEHYAGo2AnAgBCAEQRRqNgJgIAQgBEEwajYCWCADKAIAIAMoAgQgBEHoAGoQywohAgwJCyAAKAIEIgAoAhQhASAEIAI2AjAgAiABQQN2IgFPDQogBCAAKAIQIAJBA3RqKQMAIgc3AwAgBEHoAGoiACAHEP0VIAQoAmgiAUUNBSAEIAE2AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGSDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCMAQSBrIgAkACAAQRBqQYythgEoAgA2AgAgAEGErYYBKQIANwMIIABBFGogBxD9FSAEQdgAaiIBIAAoAhQEfyABIAApAhg3AgRBAQVBAAs2AgAgAEEIahDJDCAAQSBqJAAgBCgCWEUNBSAEIAQpAlw3AjAgBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQTBqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIARB2ABqIAcQ/RUgBCgCWARAIARBIGogBEHgAGooAgA2AgAgBCAEKQJYNwMYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBkww2AjQgBCAEQTBqNgJwIAQgBEEYajYCMCADKAIAIAMoAgQgBEHoAGoQywohAgwICyADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEEwaiAHIAQoAhwQzSUgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAENgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARBAjYCbCAEQeychAE2AmggBEICNwJ0IARBrwM2AiQgBCAGNgIgIARB7gY2AhwgBCAEQRhqNgJwIAQgBEEIajYCGCADKAIAIAMoAgQgBEHoAGoQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMAwsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYCyAEQegAakHIl4QBEO8sAAvEDAERfyMAQbABayICJAAgAkEANgIsIAJCgICAgIABNwIkIAJBADYCMCACQaABaiABQQYgAkEwahC8FAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCoAEiCARAIAIoAqgBIgMgAigCpAEiBUsNASABKAIAIQkgAyAIaiIPKAAAIhBFBEAgASgCCCIGQQRqIQcgASgCBCEEDAwLIANBBGohAyAJIAEoAggiBmohESAGQQRqIQcgASgCBCEEA0AgCyAPKAAATw0DIANBe0sNBCADQQRqIgEgBUsNBSADIAMgCGooAAAiDGoiCkF7Sw0GIApBBGogBUsNByACQTBqIg0gCCAFIAMgDCAIIApqKAAAa2oQ9jQCQAJAIA1BCBDMICISQf//A3EiDkUNACADIAwgDmpqIg4gBUsNCiAIIA5qLQAAQQdHDQAgBkF7Sw0LIAQgB0kNDCANIAkgBCAGIBEoAABrEPY0IA1BBBDMIEH//wNxIgNFDQAgAyAGaiIDIARLDQ0gAyAJai8AAEEBRg0BCyACIAo2AqgBIAIgBTYCpAEgAiAINgKgASACQTBqIAJBoAFqEPADIAIoAiwiAyACKAIkRgRAIAJBJGpBhLr+ABC3KAsgAigCKCADQcgAbGogAkEwakHIAPwKAAAgAiADQQFqNgIsIAEhAyAQIAtBAWoiC0YNDQwBCwsgAkEANgJAIAJBATYCNCACQey5/gA2AjAgAkIENwI4IAJBMGpB9Ln+ABDvLAALQaC5/gAQsjsACyADIAVB9LX+ABCvOwALQYS2/gBBIkGotv4AEJ8pAAsgAyADQQRqQYC5/gAQsTsACyADQQRqIAVBgLn+ABCwOwALIAogCkEEakGQuf4AELE7AAsgCkEEaiAFQZC5/gAQsDsACyAMIBJB//8DcWogA2ogBUH0tf4AEK87AAsgBiAHQZC5/gAQsTsACyAHIARBkLn+ABCwOwALIAMgBEH0tf4AEK87AAsgAkGgAWoiAUHQuP4AEKUrIAJBOGpB+Lj+ACkDADcDACACQfC4/gApAwA3AzAgAiACKQOoATcDSCACIAIpA6ABNwNAIAZBe00EQCAEIAdPBEAgASAJIAQgBiAGIAlqKAAAaxD2NAJAAkACQAJAIAFBCBDMIEH//wNxIgFFDQAgASAGaiIBQQRqIQMgAUF7Sw0DIAMgBEsNAiABIAlqKAAAIAFqIgEgBEsNASABIAlqIgooAAAiDEUNACABQQRqIQtBACEGA0AgCyEBAkACQAJAAkACQCAKKAAAIAZLBEAgAUF7Sw0BIAFBBGoiCyAESw0CIAIgBDYCgAEgAiAJNgJ8IAIgASABIAlqKAAAajYChAEgAkEYaiACQfwAaiIDQQQQvRQgAigCHCEBIAIoAhghBSACQRBqIANBBhC9FCAFRQ0FIAIoAhAiDUUNBSACKAIUIQMgAkGgAWogAUEAQQFBARCgGCACKAKkASEHIAIoAqABQQFGDQMgAigCqAEhCCABBEAgCCAFIAH8CgAACyACIAE2ApwBIAIgCDYCmAEgAiAHNgKUASACQaABaiADQQBBAUEBEKAYIAIoAqQBIQEgAigCoAFBAUYNBCACKAKoASEFIAMEQCAFIA0gA/wKAAALIAIgAzYCqAEgAiAFNgKkASACIAE2AqABIAJBiAFqIgEgAkEwaiACQZQBaiACQaABahDOCSACKAKIAUGAgICAeEYNBSABEN47DAULQYS2/gBBIkGotv4AEJ8pAAsgASABQQRqQYC5/gAQsTsACyABQQRqIARBgLn+ABCwOwALIAcgAigCqAFB1Lj+ABD9LwALIAEgAigCqAFB1Lj+ABD9LwALIAwgBkEBaiIGRw0ACwsgACACKQMwNwMIIAJBqAFqIAJBLGooAgA2AgAgAEEQaiACQThqKQMANwMAIABBGGogAkFAaykDADcDACAAQSBqIAJByABqKQMANwMAIAIgAikCJDcDoAEgAkEIaiACQaABahD+IyACKAIIIQEgACACKAIMNgIEIAAgATYCACACQbABaiQADwsgASAEQfS1/gAQrzsACyADIARBgLn+ABCwOwALIAEgA0GAuf4AELE7AAsgByAEQZC5/gAQsDsACyAGIAdBkLn+ABCxOwALxhQDD38BfgFvIwBBsA1rIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0A6AVBAWsOAwgCAQALIABB8AJqIABB8AL8CgAACyAAQfACaiEMAkACQAJAAkAgAC0A2AVBAWsOAwkEAQALIAAoAtAFIQICQCAAKALUBSIEBEAgA0EgaiAEEJUaDAELIANCAjcDIAsgA0G4AWoiBCADQSBqQZgB/AoAACAMIARB2AL8CgAAIABBADoAzAUgACACNgLIBSAAQcwFaiELDAELIABBzAVqIQsCQCAALQDMBUEBaw4DBQMCAAsgACgCyAUhAgsgACkD8AIhESADQZAEaiIHIABB+AJqQZAB/AoAACADQZgIaiEEIwBBEGsiBSQAIAUgAjYCDCMAQRBrIgYkACAFQQxqKAIAJQEQBCESEN8SIgogEiYBIAZBCGoQzi1BASEIIAUCfyAGKAIIQQFxBEAgBigCDAwBC0EAIQggCgs2AgQgBSAINgIAIAZBEGokACAFKAIEIQgCQCAFKAIAQQFxRQRAIAJBhAFPBEAgAhDyHwsgBEEBOgAMIARBADYCCCAEIAg2AgQgBEEBNgIADAELIAQgAjYCCCAEIAg2AgQgBEECNgIACyAFQRBqJAAgAygCmAhBAkYNBCADQagFaiADQaAIaiICKQIANwMAIAMgAykCmAg3A6AFAkAgEUICUgRAIAMgETcDmAggAiAHQZAB/AoAAAwBCyADQZgIahCiEgsgA0HQBmogA0GoBWopAwA3AwAgAyADKQOgBTcDyAYgA0GwBWoiAiADQZgIakGYAfwKAAAgAEGIBGoiCCACQbwB/AoAACAAQQA6AMQFIABBxAVqIQoMCAsgAEGIBGohCCAAQcQFaiEKIAAtAMQFQQFrDgMEAAEHCwALIAAoAsAFIQQMBgtBnN3CABDoKwALQcnGwgBBGhCXPQALQczbwgAQ6CsAC0Gs3cIAEOgrAAtB3MjCABDoKwALIABBADoAxQUgAEEBOgDHBSADQfgGaiINIABBqAVqKQIANwMAIAMgACkCoAU3A/AGIANBgAdqIg4gCEGYAfwKAAAgAEEBOgDGBSMAQRBrIgUkABApIRIQ3xIiAiASJgEgBUEIahDOLUEBIQQgA0EYaiIGAn8gBSgCCEEBcQRAIAUoAgwMAQtBACEEIAILNgIEIAYgBDYCACAFQRBqJAAgAygCGCECIAAgAygCHCIENgK0BSAAIAI2ArAFIAJBAXENASAAIAQ2ArgFIABBuAVqIg8oAgAlARAoIRIQ3xIiBiASJgEjAEEgayIFJAAgBUEMaiECIwBBEGsiBCQAIAQgBjYCDCMAQRBrIgckACAEQQxqKAIAJQEQISESEN8SIgkgEiYBIAkhECAHQQhqEM4tQQEhCSAEAn8gBygCCEEBcQRAIAcoAgwMAQtBACEJIBALNgIEIAQgCTYCACAHQRBqJAAgBCgCBCEHAkAgBCgCAEEBcUUEQCAGQYQBTwRAIAYQ8h8LIAJBADYCECACQgA3AgggAiAHNgIEIAJBATYCAAwBCyACIAY2AgggAiAHNgIEIAJBAjYCAAsgBEEQaiQAIAUoAgwiBEECRgRAQY3ZwwBBGhCXPQALIAUpAhAhESADQZgNaiICIAUpAhg3AgwgAiARNwIEIAIgBDYCACAFQSBqJAAgDygCACUBECchEhDfEiICIBImASAAIAI2ArwFIABBAToAxQUgA0EQaiEEAkBBOEEEEK02IgIEQCACQQA6ADQgAkEAOgAwIAJBADYCKCACQQA6ACQgAkEANgIcIAJBADoAGCACQQc2AgggAkKCgICAEDcCACAEIAI2AgQgBCACNgIADAELQQRBOBCjPQALIAMoAhQhBCADKAIQIQUgAEEAOwHGBSADQbgJaiANKQMANwMAIAMgAykD8AY3A7AJIANBmAhqIgYgDkGYAfwKAABBiApBCBCtNiICRQ0FIAIgBkGUBfwKAAAgAkEAOgCwBSACIAU2ApQFIAJBlMfCABDUGiAAIAQ2AsAFCyADQZgIaiEFIwBBEGsiBiQAAkACQCAEQQhqIgItACwNACAGQQhqIAEoAgAiASgCBCABKAIAKAIAEQAAIAItABwgBigCDCEBIAYoAgghByACQQE6ABxFBEAgAigCFCIJBEAgAigCGCAJKAIMEQMACyACQQA6ABwgAiABNgIYIAIgBzYCFCACLQAsDQEgBUEINgIADAILIAEgBygCDBEDAAsgAi0AECACQQE6ABBFBEAgAigCACEBIAJBBzYCACABQQdHBEAgBSABNgIAIAJBADoAECAFIAIpAgQ3AgQgBUEMaiACQQxqKAIANgIADAILIAJBADoAEAsgBUEHNgIACyAGQRBqJAAgAygCmAgiAUEIRg0CIAMpAqAIIREgAygCnAghBCAAQcAFahCtLCABQQdGDQUgAUEGRw0BIAAoArwFIQQMBgsgA0GYCGpBIEEAQQFBARCgGCADKAKcCCEEIAMoApgIQQFGDQIgAygCoAgiAUEYakHE28IAKQAANwAAIAFBEGpBvNvCACkAADcAACABQQhqQbTbwgApAAA3AAAgAUGs28IAKQAANwAAIAGtQoCAgICABIQhEUEEIQEMBgsgAC0AxQVBAXFFDQQgACgCvAUiAkGEAUkNBCACEPIfDAQLIAtBAzoAACAKQQM6AABBAiECDAULIAQgAygCoAhB/NnCABD9LwALQQhBiAoQoz0AC0HEysIAQSsgA0GYCGpBtMrCAEHc28IAENUeAAsgAEEAOgDFBSAAKAK4BSICQYQBSQ0AIAIQ8h8LAkAgACgCsAVFDQAgACgCtAUiAkGEAUkNACACEPIfCwJAIAAtAMYFQQFHDQAgAykDgAdCAlENACADQYAHahCgKQtBACECIABBADoAxgUgAC0AxwUEQCADQfAGahD5JQsgAEEAOgDHBSAAQQE6AMQFIAgQ1R8gAUEGRwRAIAMgETcCoAggAyAENgKcCCADIAE2ApgIIANBmAhqENMZIQRBASECCyALQQE6AAALAkAgAkECRgRAQQMhASAAQQM6ANgFDAELIAwQyikgAEEBOgDYBQJAIAJBAXEEQCADIAQ2ArgBIANBgAE2ApgIIAMgAEHkBWogA0GYCGogA0G4AWoQwiMgAygCACADKAIEENYvIgFBhAFPBEAgARDyHwsgAygCmAgiAUGEAU8EQCABEPIfCyADKAK4ASIBQYQBSQ0BIAEQ8h8MAQsgAyAENgK4ASADQYABNgKYCCADQQhqIABB4AVqIANBmAhqIANBuAFqEMIjIAMoAgggAygCDBDWLyIBQYQBTwRAIAEQ8h8LIAMoApgIIgFBhAFPBEAgARDyHwsgAygCuAEiAUGEAUkNACABEPIfCyAAKALgBSIBQYQBTwRAIAEQ8h8LQQEhASAAKALkBSIEQYQBSQ0AIAQQ8h8LIAAgAToA6AUgA0GwDWokACACQQJGC9ULAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwAAgL9eRSAPQwAAgEddRXJFBEAgByAP/AE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwAAgL9eRSAPQwAAgEddRXJFBEAgByABQQF0aiAP/AE7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvjCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQJ0IgQhAwJAIARBPHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAAAAAAADwv2RFIA9EAAAAAAAA8EFjRXJFBEAgByAPqzYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBBY0VyRQRAIAcgAUECdGogD6s2AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQxx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvjCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQJ0IgQhAwJAIARBPHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAACAAAADgwWRFIA9EAAAAAAAA4EFjRXJFBEAgByAPqjYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKwMAIg9EAAAgAAAA4MFkRSAPRAAAAAAAAOBBY0VyRQRAIAcgAUECdGogD6o2AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQvx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvlCwMKfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQF0IgQhAwJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQrAwAiD0QAAAAAAADwv2RFIA9EAAAAAAAA8EBjRXJFBEAgByAP/AM7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEIaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQN0aisDACIPRAAAAAAAAPC/ZEUgD0QAAAAAAADwQGNFckUEQCAHIAFBAXRqIA/8AzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRDNHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9MLAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBA3QiBCEDAkAgBEE4cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwAAAN9gRSAPQwAAAF9dRXJFBEAgByAPrjcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAEQQRqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBAnRqKgIAIg9DAAAA32BFIA9DAAAAX11FckUEQCAHIAFBA3RqIA+uNwMADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENYdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL5QsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEBdCIEIQMCQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKwMAIg9EAAAAACAA4MBkRSAPRAAAAAAAAOBAY0VyRQRAIAcgD/wCOwEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGorAwAiD0QAAAAAIADgwGRFIA9EAAAAAAAA4EBjRXJFBEAgByABQQF0aiAP/AI7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvTCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQN0IgQhAwJAIARBOHEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQqAgAiD0MAAIC/XkUgD0MAAIBfXUVyRQRAIAcgD683AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwAAgL9eRSAPQwAAgF9dRXJFBEAgByABQQN0aiAPrzcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9ULAwp/A34BfSMAQcABayICJAAgAUEMahDbPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCoCACIPQwABAMdeRSAPQwAAAEddRXJFBEAgByAP/AA7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEEaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQJ0aioCACIPQwABAMdeRSAPQwAAAEddRXJFBEAgByABQQF0aiAP/AA7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvSCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUqAgAiD0MAAADPYEUgD0MAAABPXUVyRQRAIAcgD6g2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0IgRqKgIAIg9DAAAAz2BFIA9DAAAAT11FckUEQCAEIAdqIA+oNgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEL8dIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEDdCIFIQMCQCAFQThxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBDY0VyRQRAIAcgD7E3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEIaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQN0IgRqKwMAIg9EAAAAAAAA8L9kRSAPRAAAAAAAAPBDY0VyRQRAIAQgB2ogD7E3AwAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDkGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQ2R0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvSCwMKfwN+AX0jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUqAgAiD0MAAIC/XkUgD0MAAIBPXUVyRQRAIAcgD6k2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0IgRqKgIAIg9DAACAv15FIA9DAACAT11FckUEQCAEIAdqIA+pNgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gsDCn8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEDdCIFIQMCQCAFQThxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKwMAIg9EAAAAAAAA4MNmRSAPRAAAAAAAAOBDY0VyRQRAIAcgD7A3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEIaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQN0IgRqKwMAIg9EAAAAAAAA4MNmRSAPRAAAAAAAAOBDY0VyRQRAIAQgB2ogD7A3AwAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDkGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQ1h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvCCwIMfwF+IwBB0ABrIgQkACABKQMAIRACQAJAAkACQAJAAkACQCACKAIAQYCAgIB4RgRAIBBCBFENAQwHCyAQQgRRDQYgAS8BSCACLwEgRw0CIAIoAgghCCAEQSBqIAEgAiADEJkQIAQoAighBSAEKAIkIQYgBCgCICIBQQhHBEAgACAEKQIsNwIMIABBFGogBEE0aigCADYCACAAIAU2AgggACAGNgIEIAAgATYCAAwGCyACQQxqIQsCQCACKAIcIAVqIgEgAigCECIDQQN0TQ0AIAFBA3YgAUEHcUEAR2oiASADTQ0AIAsgA0EBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiASABIANJGxDoGQsgCCACKAIIIgFLDQEgASAIRwRAIAFBAXQgCEEBdCIBayEIIAIoAgQgAWohAQNAIAIvASAgAS8BACACKAIcIgxBAWoiDUEDdiANQQdxQQBHaiIDIAIoAhgiB0sEQCADIAdrIQkgAigCECIKIANJBEAgCyAKQQF0IgcgA0HA////A3FBQGsgAyADQT9xGyIKIAcgCksbEOgZIAIoAhghBwsgCQRAIAIoAhQgB2pBACAJ/AsACyACIAM2AhgLIAIgDTYCHEYEQCACKAIUIAxBA3ZqIgMgAy0AAEEBIAxBB3F0cjoAAAsgAUECaiEBIAhBAmsiCA0ACwsgACAFNgIIIAAgBjYCBCAAQQg2AgAMBQsgAS8BSEEBRw0CIAJBBGohCyACKAIUIQ4gA0UEQAwECyABQQhqIQ8DQAJAAkACQAJAAkAgASgCHCIGRQRAIAEoAiAiBSABKAIkIgZHDQEgASgCGCABKAIQRg0KIARBIGogDxD7CiAEKAIgIgVBCEYNBSAAIAQpAyg3AwggAEEQaiAEQTBqKQMANwMAIAAgBCgCJDYCBCAAIAU2AgAMCwsgAigCFCIJIAMgCGsiBSAGIAUgBkkbIg1qIgxBA3YgDEEHcSIHQQBHaiEFIAEtAChFBEAgAigCECIHIAVJBEAgBSAHayEJIAIoAggiCiAFSQRAIAsgCkEBdCIHIAVBwP///wNxQUBrIAUgBUE/cRsiCiAHIApLGxDoGSACKAIQIQcLIAkEQCACKAIMIAdqQQAgCfwLAAsgAiAFNgIQCyACIAw2AhQMBAsgCUEHcSIJRQ0CIARBGGogCxCGPSAEKAIcIgZFDQEgBCgCGCAGakEBayIGRQ0BIAYgBi0AAEF/IAl0cjoAAAwCCyALIAEoAhgiDEEDdCAGaiINIA0gAyAIayIHIAUgBmsiCSAHIAlJGyIHaiABKAIMIAEoAhAQvxggASAGIAdqIgY2AiQgByAIaiEIIAUgBkcNAyABIAwgBUEDdmo2AhgMAwtB0J/QABCyOwALAkAgBSACKAIQIgZNDQAgBSAGayEJIAIoAggiCiAFSQRAIAsgCkEBdCIGIAVBwP///wNxQUBrIAUgBUE/cRsiCiAGIApLGxDoGSACKAIQIQYLIAlFDQAgAigCDCAGakH/ASAJ/AsACyACIAU2AhACQCAHRQ0AIARBEGogCxCGPQJAIAQoAhQiBUUNACAEKAIQIAVqQQFrIgVFDQAgBSAFLQAAQX8gB3RBf3NxOgAADAELQeCf0AAQsjsACyACIAw2AhQgASgCHCEGCyABIAYgDWs2AhwgCCANaiEICyADIAhHDQALIAMhCAwDCyAIIAFB9M3QABCvOwALIARBADYCICABQcgAaiACQSBqIARBIGpB5M3QABCHKwALIARBADYCICABQcgAakG4zNAAIARBIGpBhM7QABCHKwALIARBCGogCxCGPSAEQSBqIgEgBCgCCCAEKAIMIA4gCBDQCCABENcjIQEgACAINgIIIAAgATYCBCAAQQg2AgALIARB0ABqJAAPCyAEQQA2AjAgBEEBNgIkIARB1M7QADYCICAEQgQ3AiggBEEgakHcztAAEO8sAAvDCwMJfwN+AXwjAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKwMAIg5EAAAAAAAgYMBkRSAORAAAAAAAAGBAY0VyRQRAIAMgCGogDvwCOgAADAELIAJBGGogAkEsahCGPSADQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gA0EHcXdxOgAAIAVBAWohBQsgAUEIaiEBIAQgA0EBaiIDRw0ACwwECyAJBEAgAkH4AGogCSAKIAcgBBC/FCACQZgBaiEDIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0JIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNByACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEDdGorAwAiDkQAAAAAACBgwGRFIA5EAAAAAAAAYEBjRXJFBEAgASAIaiAO/AI6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALswsDCX8DfgF9IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASoCACIOQwAAgL9eRSAOQwAAgENdRXJFBEAgAyAIaiAO/AE6AAAMAQsgAkEYaiACQSxqEIY9IANBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiADQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgBCADQQFqIgNHDQALDAQLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aioCACIOQwAAgL9eRSAOQwAAgENdRXJFBEAgASAIaiAO/AE6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALswsDCX8DfgF9IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASoCACIOQwAAAcNeRSAOQwAAAENdRXJFBEAgAyAIaiAO/AA6AAAMAQsgAkEYaiACQSxqEIY9IANBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiADQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgBCADQQFqIgNHDQALDAQLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aioCACIOQwAAAcNeRSAOQwAAAENdRXJFBEAgASAIaiAO/AA6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALwwsDCX8DfgF8IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASsDACIORAAAAAAAAPC/ZEUgDkQAAAAAAABwQGNFckUEQCADIAhqIA78AzoAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKwMAIg5EAAAAAAAA8L9kRSAORAAAAAAAAHBAY0VyRQRAIAEgCGogDvwDOgAADAELIAJBEGogAkEsahCGPSABQQN2IgQgAigCFCIGSQRAIAIoAhAgBGoiBCAELQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgBCAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEACwwDC0HUiv8AQSNB+Ir/ABDLJAALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhByACKAJMIQMgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAM2AnwgAiAHNgJ4IAJBCGogBBDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASAEEMEdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+oUAgp/BH4jAEHQAmsiByQAAkACQAJAAkACQAJAAkACQCACEPMtLQAAQSJGBEAgB0EcaiIIIAIQwy0gB0EQaiAIEO88IAcoAhRFDQEgBygCECEPIAdBCGogCBDvPCAHKAIMRQ0DIAdBuAJqIAcoAggiCEEYahDFBiAIKAIoIQogCCgCJCELIAdBxAJqIAgQvhUgB0GgAmogCEEMahCACyAIKAIsIgkEQCAJIAkoAgAiDEEBajYCACAMQQBIDQMgCCgCQCEMIAgoAjwhDSAIKAI4IQ4gCCgCNCEQIAgoAjAhCAsgB0HgAWogB0HAAmooAgA2AgAgB0HIAWogB0HMAmooAgA2AgAgB0HUAWogB0GoAmooAgA2AgAgByAHKQK4AjcD2AEgByAKNgLoASAHIAs2AuQBIAcgBykCxAI3A8ABIAcgBykCoAI3AswBIAcgDDYCgAIgByANNgL8ASAHIA42AvgBIAcgEDYC9AEgByAINgLwASAHIAk2AuwBIAcgB0HAAWoiCRCgASAHIAcoAgQ2AmQgByAHKAIAIgg2AmAgCSAHQeAAaiADIAQgBSAGEPcCIAcoAsABIglBk4CAgHhHBEAgACAHKQLEATcCBCAAQQxqIAdBzAFqKQIANwIAIAAgCTYCAAwICyAGKAIEIgggBigCDEYEQCAHQQE2AsQBIAdB1Mz+ADYCwAEgB0IBNwLMASAHQYQBNgLIAiAHIAFBNGo2ArgCIAcgB0HEAmo2AsgBIAcgB0G4Amo2AsQCIAdBpAJqIAdBwAFqEJkOIAcpAqQCIREgACAHKQKsAjcCDCAAIBE3AgQgAEGMgICAeDYCACAHKAJgIQgMCAsgBiAIQQhqNgIEIAdBwAFqIQYgCCkDACERIAUtAAUhDEEAIQkjAEGwAmsiASQAIAEgETcDGCABQSBqIgggAhDDLSABQRBqIAgQ7zwCQAJAAkAgASgCFARAIAQoAgxFDQEgASgCECEIIAQoAgAiCkHQAGshDSAEKAIEIgsgBEEQaiABQRhqEI0OIhKncSECIBJCGYhC/wCDQoGChIiQoMCAAX4hFANAIAIgCmopAAAiEyAUhSISQn+FIBJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiElBFBEADQCARIA1BACASeqdBA3YgAmogC3FrIg5B0ABsaikDAFENBSASQgF9IBKDIhJQRQ0ACwsgEyATQgGGg0KAgYKEiJCgwIB/g1BFDQIgAiAJQQhqIglqIAtxIQIMAAsAC0EAQQBB8ND+ABDDIQALIAFB7AFqIgIgAUEgakHEAPwKAAAgAUGoAWoiCCAEIBEgAhCmCyABKAKoAUGAgICAeEcEQCAIEP4mCyAGQYGAgIB4NgIADAELIAFBCGogCiAOQdAAbGpByABrEO88AkAgASgCDARAQYCAgIB4IQICQCABKAIIIgkgCBCiEQ0AAn8CQAJAIAkoAiQiCiAIKAIkIgtHBEAgCiALSw0BIAFB7AFqIgIgCEEAIAoQ1gggAiAJEI0+IAIQ/iZFDQEgDEUNAiABQeQAaiAIIAkoAiQiCSAIKAIkIAlrENYIIAIgAUEgakHEAPwKAAAgAUGoAWoiCCAEIBEgAhCmCyABKAKoAUGAgICAeEcEQCAIEP4mCyAGIAFB5ABqQcQA/AoAAAwHCyAJIAgQjT4NAwsgBC0ALEUEQCABQewBaiICIAFBIGpBxAD8CgAAIAFBqAFqIgggBCARIAIQpgsgASgCqAFBgICAgHhHBEAgCBD+JgsgBkGCgICAeDYCAAwGC0GUASECIAFB7AFqQZQBQQBBAUEBEKAYIAEoAvABIQQgASgC7AFBAUYNBCABKAL0ASIIQdzP/gBBlAH8CgAAIAYgCDYCDCAGIAQ2AgggBkGNgICAeDYCBEEQDAELIAQtACxFBEAgAUHsAWoiAiABQSBqQcQA/AoAACABQagBaiIIIAQgESACEKYLIAEoAqgBQYCAgIB4RwRAIAgQ/iYLIAZBgoCAgHg2AgAMBQsgBkEIaiEEIwBBEGsiAiQAIAJBBGpBlAFBAEEBQQEQoBggAigCCCEIAkAgAigCBEEBRwRAIAIoAgwiCUHcz/4AQZQB/AoAACAEQZQBNgIIIAQgCTYCBCAEIAg2AgAgAkEQaiQADAELIAggAigCDEGoyf4AEP0vAAtBjYCAgHghAkEECyAGaiACNgIAQYOAgIB4IQILIAYgAjYCACABQSBqEP4mDAILQQBBAEGA0f4AEMMhAAsgBCABKAL0AUGoyf4AEP0vAAsgAUGwAmokACAHQcQBaiEBAkACQCAHKALAASICQYOAgIB4RgRAIAdB+ABqIAFBEGooAgAiAjYCACAHQfAAaiABQQhqKQIAIhE3AwAgByABKQIAIhI3A2ggAEEQaiACNgIAIABBCGogETcCACAAIBI3AgAgBygCYCIAIAAoAgAiAEEBazYCACAAQQFGDQEMCQsgB0HoAGogAUHAAPwKAAACQAJAAkBBAyACQYCAgIB4cyACQQBOG0EBaw4DAQEACQsgByACNgLAASAHQcQBaiAHQegAakHAAPwKAAAgB0GgAmogESAHQcABaiIBIAVBARCDAyAHQZACaiICIAdBrAJqKQIANwMAIAdBmAJqIgQgB0G0AmooAgA2AgAgByAHKQKkAjcDiAIgBygCoAIiBUGAgICAeEcNAyAAIAcpA4gCNwIAIABBEGogBCgCADYCACAAQQhqIAIpAwA3AgAgARD+JgwBCyAHQcABaiARIA8gBUEAEIMDIAdBsAFqIgEgB0HMAWopAgA3AwAgB0G4AWoiAiAHQdQBaigCADYCACAHIAcpAsQBNwOoASAHKALAASIEQYCAgIB4RwRAIAMoAggiAiADKAIARgRAIANBnMz+ABCRKAsgAygCBCACQRhsaiIBIAcpA6gBNwIEIAEgBDYCACABQQxqIAdBsAFqKQMANwIAIAFBFGogB0G4AWooAgA2AgAgAyACQQFqNgIIDAgLIAAgBykDqAE3AgAgAEEQaiACKAIANgIAIABBCGogASkDADcCAAsgBygCYCIAIAAoAgAiAEEBazYCACAAQQFHDQgLIAdB4ABqELsjDAcLIAMoAggiAiADKAIARgRAIANBrMz+ABCRKAsgAygCBCACQRhsaiIBIAcpA4gCNwIEIAEgBTYCACABQQxqIAdBkAJqKQMANwIAIAFBFGogB0GYAmooAgA2AgAgAyACQQFqNgIIIAdBwAFqEP4mDAQLIAdBwAFqIAIgAyAEIAUgBhD3AiAHKALAASIBQZOAgIB4Rg0EIAAgBykCxAE3AgQgAEEMaiAHQcwBaikCADcCACAAIAE2AgAMBwtBAEEAQfzL/gAQwyELAAtBAEEAQYzM/gAQwyEACyAHKAJgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAHQeAAahC7IwsgB0EcahD+JgsgAEGTgICAeDYCAAwCCyAHQRxqEP4mDAELIAggCCgCACIAQQFrNgIAIABBAUYEQCAHQeAAahC7IwsgB0EcahD+JgsgB0HQAmokAAu/CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEBdCIEIQMCQCAEQT5xIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxCgIACfEL//wNYBEAgByAMPQEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEKAgAJ8Qv//A1gEQCAHIAFBAXRqIAw9AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQ2h0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAvHCwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxCgICAgAh8Qv////8PWARAIAcgDD4CAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBBGohByAEQQhqIQQgBSADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAFEL8UIAJBmAFqIQMgASgCECEEA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAQgDqcgDKdqIgFBA3RqKQMAIgxCgICAgAh8Qv////8PWARAIAcgAUECdGogDD4CAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIFIAIoAhwiCEkEQCACKAIYIAVqIgUgBS0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAUgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBRCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBCkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAUQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAEKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBCACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBRC/HSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC78LAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUGAgAJqQf//A00EQCAHIAE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQYCAAmpB//8DTQRAIAcgAUEBdGogBDsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7MLAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAcgAa03AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQQBOBEAgByABQQN0aiAErTcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC64OAQR/IwBBoAFrIgYkACAGIAI2AiggBiABNgIkIAYgBTYCLCAGQRhqIAZBJGoQwzQCQAJAAkACQAJAIAYoAhwiASADKAIIIgJGBEACQAJAIAQoAgAEQCAEKAIQIgIgBUcNAQsgBkEIaiAGQSRqEMM0IAMoAgQhBSAGKAIMIQcgBiAGKAIIIgI2AogBIAYgAiAHQQJ0ajYCjAEgASAGQYgBahCeNiIHIAEgB0kbIgFFDQUMAQsgBiACNgIwIAZBAjYCjAEgBkHY84UBNgKIASAGQgI3ApQBIAZBOzYCVCAGQTs2AkwgBiAGQcgAajYCkAEgBiAGQTBqNgJQIAYgBkEsajYCSCAAQQhqIAZBiAFqEJkOIABCgICAgNiBgICAfzcCAAwFCwNAIAIoAgBBMGogBSgCACAFQQRqIgcoAgAiCCgCCEEBa0F4cWpBCGogCCgCHBEEABDGCEUNAyAFKAIAIAcoAgAiCCgCCEEBa0F4cWpBCGogCCgCJBEEACAGKAIsRw0CAkAgAigCAC0ASA0AIAZBMGogBSgCACAHKAIAIgcoAghBAWtBeHFqQQhqIAcoAjgRAAAgBigCMEUNACAGQdgAaiAGQUBrKQIANwMAIAZB0ABqIAZBOGopAgA3AwAgBiAGKQIwNwNIAkACQCAEKAIABEAgBCAGQcgAahDiCA0CIAYoAlwNAQwCCyAGKAJcRQ0BCyACKAIAIQEgBkHKBDYCaCAGQaD0hQE2AogBIAZCATcClAEgBiABQTxqNgJsIAYgBkHsAGo2AmQgBiAGQeQAajYCkAEgBkEBNgKMASAAQQhqIQUjAEEQayIBJAAgBkGIAWoiAigCDCEHAkACQAJAAkACQAJAAkAgAigCBA4CAAECCyAHDQFBASEHQQAhAgwCCyAHDQAgAigCACIHKAIEIQIgBygCACEHDAELIAUgAhCZDgwBCyABQQRqIAJBAEEBQQEQoBggASgCCCEIIAEoAgRBAUYNASABKAIMIQkgAgRAIAkgByAC/AoAAAsgBSACNgIIIAUgCTYCBCAFIAg2AgALIAFBEGokAAwBCyAIIAEoAgxBpO6FARD9LwALIABCgICAgNiBgICAfzcCACAGKAJIIgAgACgCACIAQQFrNgIAIABBAUcNByAGQcgAahD7HgwHCyAGKAJIIgcgBygCACIHQQFrNgIAIAdBAUcNACAGQcgAahD7HgsgAkEEaiECIAVBCGohBSABQQFrIgENAAsMAwsgBkEQaiAGQSRqEMM0IAYgBigCFDYCZCAGIAI2AjAgBkECNgKMASAGQfj1hQE2AogBIAZCAjcClAEgBkE7NgJUIAZBOzYCTCAGIAZByABqNgKQASAGIAZBMGo2AlAgBiAGQeQAajYCSCAAQQhqIAZBiAFqEJkOIABCgICAgNiBgICAfzcCAAwDCyAGIAIoAgBBPGo2AmQgBiAFKAIAIAVBBGooAgAiASgCCEEBa0F4cWpBCGogASgCJBEEADYCMCAGQQM2AkwgBkHg9IUBNgJIIAZCAzcCVCAGQTs2ApwBIAZBOzYClAEgBkHKBDYCjAEgBiAGQYgBajYCUCAGIAZBMGo2ApgBIAYgBkEsajYCkAEgBiAGQeQAajYCiAEgAEEIaiAGQcgAahCZDiAAQoCAgIDYgYCAgH83AgAMAgsgBiACKAIAIgFBPGo2AmwgBiABQTBqNgJkIAYgBSgCACAFQQRqKAIAIgEoAghBAWtBeHFqQQhqIAEoAhwRBAA2AjAgBkEDNgJMIAZBpPWFATYCSCAGQgM3AlQgBkGnBDYCnAEgBkGnBDYClAEgBkHKBDYCjAEgBiAGQYgBajYCUCAGIAZBMGo2ApgBIAYgBkHkAGo2ApABIAYgBkHsAGo2AogBIABBCGogBkHIAGoQmQ4gAEKAgICA2IGAgIB/NwIADAELIAYoAighAiAGKAIkIQcCQCAEKAIAIgVFBEBBACEFDAELIAZBlAFqIARBBGoiAUEIaiIEKQIANwIAIAZBnAFqIAFBEGoiCCgCACIJNgIAIAYgBTYCiAEgBiABKQIANwKMASAJRQRAIAUgBSgCACIBQQFrNgIAQQAhBSABQQFHDQEgBkGIAWoQ+x4MAQsgBkGAAWogCCgCADYCACAGQfgAaiAEKQIANwMAIAYgASkCADcDcAsgACAFNgIcIAAgBigCLDYCGCAAIAI2AhQgACAHNgIQIABBIDoADCAAIAYpA3A3AiAgACADKQIANwIAIABBCGogA0EIaigCADYCACAAQShqIAZB+ABqKQMANwIAIABBMGogBkGAAWooAgA2AgAMAQsCQCAEKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAQQ+x4LIAMQwycgA0EEQQgQ4B4gBigCJCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEkahCFHQsgBkGgAWokAAuWrAIDIH8DfgF8IwBBkAVrIg4kACAOQQA2AgwgDkKAgICAEDcCBCMAQfADayIFJAAgBUGwAWoQzzUCQCADKQMAQgJSBEAgBUHYAmogA0GYAfwKAAAMAQsgBUHYAmoQshILIAVBCGoiCSAFQbABaiAFQdgCahDrHyMAQfADayIDJAAgAyACNgIEIANBCGogCUGYAfwKAAAgAyADLQCfAToArAEgA0EMNgKoASADQciBwwA2AqQBIAkoApgBQYCAgIB4RwRAIAMgCSkCnAE3AqQBCyAOQQRqIQggDkHoA2ohBiAJQZgBaiEUIANB0AFqIANBpAFqIAJBCGoiDRDQCgJAAkACQAJAAkACQCADKALQAUEBRgRAIANB/AJqIANB6AFqKQMAIiQ3AgAgA0H0AmogA0HgAWopAwAiJTcCACADIAMpA9gBIiY3AuwCIAZBGGogJDcCACAGQRBqICU3AgAgBiAmNwIIIAZBgICAgHg2AgAgA0EIahDMLAwBCyADQbgBaiADQdwBaikCADcDACADQcABaiADQeQBaikCADcDACADQcgBaiADQewBaigCADYCACADIAMpAtQBNwOwASAJLQCkAUUEQCANIANBCGoQ3g4LIAMoApgBIRMgA0HQAWoiDSADQQhqQZgB/AoAAEGgAUEIEK02IgRFDQMgBEKBgICAEDcDACAEQQhqIA1BmAH8CgAAIAMgBDYCzAEgA0GwAWoQ2i0hCiAEIAQoAgAiCUEBajYCACAJQQBIDQQjAEHgAGsiCSQAIAkgBDYCECAJIAo2AgwjAEEQayIHJAAgB0EEakGAwABBAEEBQQEQoBggBygCCCESIAcoAgRBAUYEQCASIAcoAgxB0IbDABD9LwALIAcoAgwhFSAJQRRqIhEgCDYCECARQQA6AAwgEUEANgIIIBEgFTYCBCARIBI2AgAgB0EQaiQAIAlBADYCKCAKIAooAgAiB0EBajYCAAJAAkAgB0EATgRAIAlBLGoiFSAKEKUSIAlByABqIRIjAEEQayIHJAAgB0EIaiIPIBFBxL7DAEEEEKgaAkACQCAHLQAIQQRGDQAgBykDCCIkQv8Bg0IEUQ0AIAcgJDcDCCASIA8QgSsMAQsgEkEINgIACyAHQRBqJAACQCAJKAJIIgdBCEcEQCANIAkpAkw3AgwgDUEcaiAJQdwAaigCADYCACANQRRqIAlB1ABqKQIANwIAIA1BgICAgHg2AgAgDSAHNgIIIBUQ/iggERDUKSAREN47IAQgBCgCACINQQFrNgIAIA1BAUYEQCAJQRBqEK4gCyAJKAIMIg0gDSgCACINQQFrNgIAIA1BAUcNASAJQQxqEIMgDAELIAlB2ABqIgcgCUEkaikCADcDACAJQdAAaiISIAlBHGopAgA3AwAgCSAJKQIUNwNIQSRBBBCtNiIRRQ0CIBFCgYCAgBA3AgAgESAJKQIsNwIIIA0gCSkDSDcCACARQRBqIAlBNGopAgA3AgAgEUEYaiAJQTxqKQIANwIAIBFBIGogCUHEAGooAgA2AgAgDUEIaiASKQMANwIAIA1BEGogBykDADcCACANQQA6AGQgDUEANgJgIA0gBDYCXCANIBE2AlggDSAKNgJUIA1BADYCUCANQoCAgIDAADcDSCANQgQ3A0AgDUIANwM4IA1CgICAgMAANwMwIA1CBDcDKCANQgA3AyAgDUKAgICAgAE3AxgLIAlB4ABqJAAMAgsAC0EEQSQQoz0ACyADKALQASIJQYCAgIB4Rw0BIANB5ANqIANB6AFqKQMAIiQ3AgAgA0HcA2ogA0HgAWopAwAiJTcCACADIAMpA9gBIiY3AtQDIAZBGGogJDcCACAGQRBqICU3AgAgBiAmNwIIIAZBgICAgHg2AgAgBCAEKAIAIgJBAWs2AgAgAkEBRgRAIANBzAFqEK4gCyADQbABahD+KCADKAIEIQILIBQQhjAgAiACKAIAIgJBAWs2AgAgAkEBRw0BIANBBGoQ+CMMAQsgA0HoA2oiDSADQewBaigCADYCACADQeADaiIRIANB5AFqKQIANwMAIANB2ANqIgcgA0HcAWopAgA3AwAgAyADKQLUATcD0AMgA0HoAmoiCiADQfABakHIAPwKAAAgA0G4A2oiEiAHKQMANwMAIANBwANqIgcgESkDADcDACADQcgDaiIRIA0oAgA2AgAgAyADKQPQAzcDsAMgAiACKAIAIg1BAWo2AgAgDUEASA0CIAYgAykDsAE3AmggBiADKQOwAzcCBCAGQYABaiADQcgBaigCADYCACAGQfgAaiADQcABaikDADcCACAGQfAAaiADQbgBaikDADcCACAGQQxqIBIpAwA3AgAgBkEUaiAHKQMANwIAIAZBHGogESgCADYCACAGQSBqIApByAD8CgAAIAYgEzYCpAEgBiACNgKgASAGQYCAgIB4NgKMASAGIAQ2AogBIAYgAjYChAEgBiAJNgIAIBQQhjALIANB8ANqJAAMAgtBCEGgARCjPQsACyAFQfADaiQAAkAgDigC6AMiAkGAgICAeEYEQCAOQeQCaiAOQYAEaikDACIkNwIAIA5B3AJqIA5B+ANqIgIpAwAiJTcCACAOIA4pA/ADIiY3AtQCIAIgJDcDACAOQfADaiAlNwMAIA4gJjcD6AMgACAGEMgmIAgQ3jsgARDlIAwBCyAOQegCaiIDIA5BhARqKAIANgIAIA5B4AJqIgkgDkH8A2opAgA3AwAgDkHYAmoiBiAOQfQDaikCADcDACAOIA4pAuwDNwPQAiAOQbgBaiINIA5BiARqQYgB/AoAACAOQRxqIAYpAwA3AgAgDkEkaiAJKQMANwIAIA5BLGogAygCADYCACAOIAI2AhAgDiAOKQPQAjcCFCAOQTBqIA1BiAH8CgAAIA5ByAJqIAFBCGopAgA3AwAgDiABKQIANwPAAgJAAkAgDigCxAIiASAOKALMAkYNACAOQdQCaiECIA5B0ANqIQMDQCADIAFBDGopAgA3AwAgDiABQRRqNgLEAiAOIAEpAgQ3A8gDIAEoAgAiAUGAgICAeEYNASACIA4pA8gDNwIAIAJBCGogAykDADcCACAOIAE2AtACIA5BuAFqIA5BEGoiASAOQdACaiIJEPcJIA4oArgBIgZBCEcEQCAOQfwDaiAOQcwBaigCADYCACAOQfQDaiAOQcQBaikCADcCACAOIA4pArwBNwLsAyAOIAY2AugDIAAgDkHoA2oQyCYgCRDpKyAOQcACahDlICABENQpIAEQ3jsgDigCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgDkHkAGoQgyALIA4oAmgiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5B6ABqEIYfCyAOKAJsIgAgACgCACIAQQFrNgIAIABBAUYEQCAOQewAahCuIAsgDkEoaiIAENwYIAAQ7DsgDkE0aiIAELErIABBBEEMEOAeIA5BQGsiABC6KiAAQQRBDBDgHiAOQcwAaiIAELsqIABBBEEMEOAeIA5B2ABqIgAQ4CkgABDyOwJAIA4oApwBQYCAgIB4Rg0AIA5BnAFqIgAQqwEgABD0OyAOKAKoASIAIAAoAgAiAEEBazYCACAAQQFHDQAgDkGoAWoQ+CMLIA4oArABIgAgACgCACIAQQFrNgIAIABBAUYEQCAOQbABahD4IwsgDigCkAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5BkAFqEIMgCyAOQfgAaiIAEKMnIAAQ6TsgDkGEAWoQ6TsgDigClAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIA5BlAFqEPgjCyAOKAKYASIAIAAoAgAiAEEBazYCACAAQQFHDQMgDkGYAWoQriAMAwsgDkHQAmoQ6SsgDigCxAIiASAOKALMAkcNAAsLIA5BwAJqEOUgIA5B6ANqIhQgDkEQakGoAfwKAAAgDkG4AWohHSMAQSBrIiEkACAhQQhqIBQQ/gYCQCAhKAIIIgFBCEcEQCAdICEpAgw3AgwgHUEcaiAhQRxqKAIANgIAIB1BFGogIUEUaikCADcCACAdQQM2AgAgHSABNgIIDAELQgAhJCMAQZACayIVJAACQAJAAkACQAJAIBQtAGRFBEAgFCgCYCAUKAIgRg0CQSghASAVQZgBakEoQQBBAUEBEKAYIBUoApwBIQMgFSgCmAFBAUYNBCAVKAKgASICQZTBwwBBKPwKAAAMAQtBJSEBIBVBmAFqQSVBAEEBQQEQoBggFSgCnAEhAyAVKAKYAUEBRg0DIBUoAqABIgJBvMHDAEEl/AoAAAsgHSABNgIUIB0gAjYCECAdIAM2AgwgHUEANgIIIB1BAzYCAAwBCyAVQZgBaiEbIwBBsAFrIhIkACAUQQE6AGQCQAJAAkAgFCgCICIBBEAgFCgCHCECIAFBBnQhAwNAIBJB6ABqIBQgFCgCKCAUKAIsIAIQgAcgEigCaCIBQQhHBEAgGyASKQJsNwIMIBtBHGogEkH8AGooAgA2AgAgG0EUaiASQfQAaikCADcCACAbQQM2AgAgGyABNgIIDAMLIAJBQGshAiADQUBqIgMNAAsLAn8gFCgCXEEIahDVNCIBBEAgASgCCCECIBQoAlAhAyABKAIEIQEgEiAUKAJMIgk2AnAgEiABNgJoIBIgCSADQRhsajYCdCASIAEgAkEYbGo2AmwgEkEIaiASQegAahCpFSASKQIMISQgEigCCAwBC0GAgICAeCAUKAJQRQ0AGiASQegAaiAUQcgAahDEECASKQJsISQgEigCaAshAiASQRRqIBQoAhwiASABIBQoAiBBBnRqEKQbIBIgFCgCXEEIahDlOyASKAIAIQYgEkHoAGogEigCBCIBQQBBAUEBEKAYIBIoAmwhAyASKAJoQQFGDQEgEigCcCEJIAEEQCAJIAYgAfwKAAALIBJBKGogEkEcaigCADYCACASQQA2AlggEkEANgJQIBIgATYCQCASIAk2AjwgEiADNgI4IBIgEikCFDcDICASIBQ2AkQgEiAUQdgAajYCTCASIBRB1ABqNgJIIBJBAkEBIBQoAlwtAJ0BGzYCYCASQYCAgIB4NgIsIAJBgICAgHhHBEAgEkHoAGoiASASQSBqIgNBxAD8CgAAIBJB9ABqEIcwIBIgJDcCeCASIAI2AnQgAyABQcQA/AoAAAsgEiAUKQI0NwNQIBIgFCkCQDcDWEEAIQVCACEkIwBBkAJrIg0kACASQSBqIhooAggiAgRAIBooAgRBKGohHANAIBwpAwAgJHwhJCAcQdAAaiEcIAJBAWsiAg0ACwsCQAJAAkACQCAaKAIwIh9FDQAgDUHIAGohDyAaKAI0IRkjAEEgayIKJAACQAJAIBooAggiAUUNACAaKAIEIhEgAUHQAGxqISAgGkEkaiEWAkADQAJAIBEoAjgiAQRAIAUgGU8NAyABQegDbCEIIBEoAjRBrANqIRwgHyAFQQxsaiIYKAIIIRBBACEHQX8hEwNAIBAgE0EBaiITRg0CIBgoAgQgB2oiBCgCAEGAgICAeEcEQCAWKAIAKAIUIQsgCkEIaiEMIwBB0ABrIgMkACADIBY2AiAgA0KAgICAkICAgIB/NwIIIANCgICAgCA3AgAgA0EAOwEkIANBKGohAiMAQUBqIgEkACABQQxqQf26wgBBCxCAICABQSxqIAMQ5ycCQCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyABQSxqIglBiLvCAEEKQQ1BARDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAELIAFBLGoiCRCGMCAJIANBAiAEKAIIIgYQqxQgASgCLCIJQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIAk2AgAMAQsgBgRAIAQoAgQhCQNAIAFBLGogAyAJLQAAENAZIAEoAiwiHkEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAeNgIADAMLIAlBAWohCSAGQQFrIgYNAAsLIAMQxiEgAUEsaiIJQZK7wgBBCkENQQIQ6BwgAUEYaiADIAkQrhQgASgCGCIGQQRHBEAgAiABKQIcNwIEIAJBDGogAUEkaikCADcCACACIAY2AgAgCRCGMAwBCyABQSxqIgkQhjAgCSADQQggBCgCFCIGEKsUIAEoAiwiCUEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAJNgIADAELIAYEQCAEKAIQQQhqIQkgBkEMbCEGA0AgAUEsaiADIAlBBGsoAgAgCSgCABCnGyABKAIsIh5BBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgHjYCAAwDCyAJQQxqIQkgBkEMayIGDQALCyADEMYhIAFBLGoiCUGcu8IAQQpBDUEDEOgcIAFBGGogAyAJEK4UIAEoAhgiBkEERwRAIAIgASkCHDcCBCACQQxqIAFBJGopAgA3AgAgAiAGNgIAIAkQhjAMAQsgAUEsaiIJEIYwIAkgA0EIIAQoAiAiBhCrFCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyAGBEAgBCgCHEEIaiEJIAZBDGwhBgNAIAFBLGogAyAJQQRrKAIAIAkoAgAQpxsgASgCLCIeQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIB42AgAMAwsgCUEMaiEJIAZBDGsiBg0ACwsgAxDGISABQSxqIglBprvCAEEOQQZBBBDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAELIAFBLGoiCRCGMCAJIAMgBCgCSBCrGyABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyADEMYhIAQoAiRBgICAgHhHBEAgAUEsaiIJQbS7wgBBC0ENQQUQ6BwgAUEYaiADIAkQrhQgASgCGCIGQQRHBEAgAiABKQIcNwIEIAJBDGogAUEkaikCADcCACACIAY2AgAgCRCGMAwCCyABQSxqIgkQhjAgCSADQQcgBCgCLCIGEKsUIAEoAiwiCUEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAJNgIADAILIAYEQCAEKAIoIQkgBkEDdCEGA0AgAUEsaiADIAkpAwAQrBsgASgCLCIeQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIB42AgAMBAsgCUEIaiEJIAZBCGsiBg0ACwsgAxDGIQsgBCgCMEGAgICAeEcEQCABQSxqIglBv7vCAEEbQQ1BBhDoHCABQRhqIAMgCRCuFCABKAIYIgZBBEcEQCACIAEpAhw3AgQgAkEMaiABQSRqKQIANwIAIAIgBjYCACAJEIYwDAILIAFBLGoiCRCGMCAJIANBByAEKAI4IgYQqxQgASgCLCIJQQRHBEAgAiABKQIwNwIEIAJBDGogAUE4aikCADcCACACIAk2AgAMAgsgBgRAIAQoAjQhCSAGQQN0IQYDQCABQSxqIAMgCSkDABCsGyABKAIsIh5BBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgHjYCAAwECyAJQQhqIQkgBkEIayIGDQALCyADEMYhCyAEKAI8QYCAgIB4RwRAIAFBLGoiCUHau8IAQRtBDUEHEOgcIAFBGGogAyAJEK4UIAEoAhgiBkEERwRAIAIgASkCHDcCBCACQQxqIAFBJGopAgA3AgAgAiAGNgIAIAkQhjAMAgsgAUEsaiIJEIYwIAkgA0EHIAQoAkQiBhCrFCABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwCCyAGBEAgBCgCQCEJIAZBA3QhBgNAIAFBLGogAyAJKQMAEKwbIAEoAiwiBEEERwRAIAIgASkCMDcCBCACQQxqIAFBOGopAgA3AgAgAiAENgIADAQLIAlBCGohCSAGQQhrIgYNAAsLIAMQxiELIAFBLGogAxCBNiABKAIsIglBBEcEQCACIAEpAjA3AgQgAkEMaiABQThqKQIANwIAIAIgCTYCAAwBCyACIAMQ5SgLIAFBDGoQ3jsgAUFAayQAAkAgAygCKCIBQQRHBEAgA0HIAGogA0E0aikCADcCACADIAMpAiw3AkAgAyABNgI8IAwgA0E8ahClJQwBCyAMQQg2AgALIAMQui4gA0HQAGokACAKKAIIIgJBCEcEQCAPIAopAgw3AgQgD0EUaiAKQRxqKAIANgIAIA9BDGogCkEUaikCADcCAAwICyAWKAIAKAIUIQEgHEEEa0EBNgIAIBxBlANrIAutNwMAIBxBnANrQgE3AwAgHCABIAtrNgIACyAcQegDaiEcIAdBzABqIQcgCEHoA2siCA0ACwsgBUEBaiEFICAgEUHQAGoiEUcNAQwDCwsgECAQQeCdwwAQwyEACyAFIBlB0J3DABDDIQALQQghAgsgDyACNgIAIApBIGokACANKAJIIhxBCEYNAAwBCwJAIBooAjgiHkUNACANQcgAaiEQIBooAjwhDCMAQSBrIgokAAJAAkAgGigCCCIBRQ0AIBooAgQiESABQdAAbGohIiAaQSRqIRlBACEFAkADQAJAIBEoAjgiAQRAIAUgDE8NAyARKAI0IRwgAUHoA2whCCAeIAVBDGxqIiMoAgghC0EAIQdBfyETA0AgCyATQQFqIhNGDQIgIygCBCAHaiIPKAIAQYCAgIB4RwRAIBkoAgAoAhQhHyAKQQhqISAjAEHQAGsiAyQAIAMgGTYCICADQoCAgICQgICAgH83AgggA0KAgICAIDcCACADQQA7ASQgA0EoaiEJIwBBQGoiAiQAIAJBDGpBpr3CAEELEIAgIAJBLGogAxDnJwJAIAIoAiwiAUEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSABNgIADAELIAJBLGoiAUGxvcIAQQ5BDUEBEOgcIAJBGGogAyABEK4UIAIoAhgiBkEERwRAIAkgAikCHDcCBCAJQQxqIAJBJGopAgA3AgAgCSAGNgIAIAEQhjAMAQsgAkEsaiIBEIYwIAEgA0EKIA8oAggiARCrFCACKAIsIgZBBEcEQCAJIAIpAjA3AgQgCUEMaiACQThqKQIANwIAIAkgBjYCAAwBCyABBEAgDygCBCEEIAFBGGwhFgNAIAJBLGohBiMAQUBqIgEkACABQQxqQaC/wgBBDBCAICABQSxqIAMQ5ycCQCABKAIsIhhBBEcEQCAGIAEpAjA3AgQgBkEMaiABQThqKQIANwIAIAYgGDYCAAwBCyABQSxqIhhBrL/CAEEGQQdBARDoHCABQRhqIAMgGBCuFCABKAIYIhdBBEcEQCAGIAEpAhw3AgQgBkEMaiABQSRqKQIANwIAIAYgFzYCACAYEIYwDAELIAFBLGoiGBCGMCAYIAMgBCkDABCsGyABKAIsIhhBBEcEQCAGIAEpAjA3AgQgBkEMaiABQThqKQIANwIAIAYgGDYCAAwBCyADEMYhIAFBLGoiGEGyv8IAQRRBBkECEOgcIAFBGGogAyAYEK4UIAEoAhgiF0EERwRAIAYgASkCHDcCBCAGQQxqIAFBJGopAgA3AgAgBiAXNgIAIBgQhjAMAQsgAUEsaiIYEIYwIBggAyAEKAIQEKsbIAEoAiwiGEEERwRAIAYgASkCMDcCBCAGQQxqIAFBOGopAgA3AgAgBiAYNgIADAELIAMQxiEgAUEsaiIYQca/wgBBD0EHQQMQ6BwgAUEYaiADIBgQrhQgASgCGCIXQQRHBEAgBiABKQIcNwIEIAZBDGogAUEkaikCADcCACAGIBc2AgAgGBCGMAwBCyABQSxqIhgQhjAgGCADIAQpAwgQrBsgASgCLCIYQQRHBEAgBiABKQIwNwIEIAZBDGogAUE4aikCADcCACAGIBg2AgAMAQsgAxDGISABQSxqIAMQgTYgASgCLCIYQQRHBEAgBiABKQIwNwIEIAZBDGogAUE4aikCADcCACAGIBg2AgAMAQsgBiADEOUoCyABQQxqEN47IAFBQGskACACKAIsIgFBBEcEQCAJIAIpAjA3AgQgCUEMaiACQThqKQIANwIAIAkgATYCAAwDCyAEQRhqIQQgFkEYayIWDQALCyADEMYhIA8oAgxBgICAgHhHBEAgAkEsaiIBQb+9wgBBH0ENQQIQ6BwgAkEYaiADIAEQrhQgAigCGCIGQQRHBEAgCSACKQIcNwIEIAlBDGogAkEkaikCADcCACAJIAY2AgAgARCGMAwCCyACQSxqIgEQhjAgASADQQcgDygCFCIBEKsUIAIoAiwiBkEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSAGNgIADAILIAEEQCAPKAIQIQQgAUEDdCEWA0AgAkEsaiADIAQpAwAQrBsgAigCLCIBQQRHBEAgCSACKQIwNwIEIAlBDGogAkE4aikCADcCACAJIAE2AgAMBAsgBEEIaiEEIBZBCGsiFg0ACwsgAxDGIQsgAkEsaiADEIE2IAIoAiwiAUEERwRAIAkgAikCMDcCBCAJQQxqIAJBOGopAgA3AgAgCSABNgIADAELIAkgAxDlKAsgAkEMahDeOyACQUBrJAACQCADKAIoIgFBBEcEQCADQcgAaiADQTRqKQIANwIAIAMgAykCLDcCQCADIAE2AjwgICADQTxqEKUlDAELICBBCDYCAAsgAxC6LiADQdAAaiQAIAooAggiAkEIRwRAIBAgCikCDDcCBCAQQRRqIApBHGooAgA2AgAgEEEMaiAKQRRqKQIANwIADAgLIBkoAgAoAhQhASAcQaADakEBNgIAIBxBCGogH603AwAgHEIBNwMAIBxBpANqIAEgH2s2AgALIAdBGGohByAcQegDaiEcIAhB6ANrIggNAAsLIAVBAWohBSAiIBFB0ABqIhFHDQEMAwsLIAsgC0GAnsMAEMMhAAsgBSAMQfCdwwAQwyEAC0EIIQILIBAgAjYCACAKQSBqJAAgDSgCSCIcQQhGDQAMAQsgDUEEaiAaKAIsKAIAQQhqKAIIEPQfIBooAgAhASAaKQIEISUgDUGAgICAeDYCECANQQI2AhwgDUGAgICAeDYCPCANICU3AsQBIA0gATYCwAEgGkEMaiEYAkAgGigCDEGAgICAeEcEQCANQcwBaiAYEMQQDAELIA1BgICAgHg2AswBCyAaKAJAIQEgDUHoAWoiAiAaKAIoKAIAQQhqEK4VIA1B4AFqIgMgDUH0AWooAgA2AgAgDSANKQLsATcD2AECQCANKALoASIJQQhGBEAgGkEYaiEcAkAgGigCGEGAgICAeEcEQCACIBwQ3SAMAQsgDUGAgICAeDYC6AELIA1BqAFqIA1BDGooAgA2AgAgDUHQAGogDUEkaikCADcDACANQdgAaiANQSxqKQIANwMAIA1B4ABqIA1BNGopAgA3AwAgDUG0AWogDUHEAGooAgA2AgAgDSANKQIENwOgASANIA0pAhw3A0ggDSANKQI8NwKsASANIAE2ArgBIA1B+ABqIA1B4AFqKAIANgIAIA1BhAFqIA1ByAFqKAIANgIAIA1BkAFqIA1B1AFqKAIANgIAIA1BnAFqIA1B8AFqKAIANgIAIA0gJDcDaCANIA0pA9gBNwNwIA0gDSkCwAE3AnwgDSANKQLMATcDiAEgDSANKQLoATcClAEgGigCJCgCFCEjIA1B6AFqIR4jAEHQAGsiASQAIAEgGkEkaiIiNgIgIAFCgICAgJCAgICAfzcCCCABQoCAgIAgNwIAIAFBADsBJCABQShqIREgDUHIAGohGSMAQUBqIgkkACAJQQxqQf69wgBBDBCAICAJQSxqIAEQ5ycCQCAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwBCyAJQSxqIgJBir7CAEEHQQZBARDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAELIAlBLGoiAhCGMCACIAEgGSgCcBCrGyAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwBCyABEMYhIAlBLGoiAkGRvsIAQQZBDUECEOgcIAlBGGogASACEK4UIAkoAhgiA0EERwRAIBEgCSkCHDcCBCARQQxqIAlBJGopAgA3AgAgESADNgIAIAIQhjAMAQsgCUEsaiICEIYwIAIgAUEKIBkoAjAiAhCrFCAJKAIsIgNBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAzYCAAwBCyACBEAgGSgCLCETIAJB4ABsIR8DQCAJQSxqIQQjAEFAaiIGJAAgBkEMakH3v8IAQQ0QgCAgBkEsaiABEOcnAkAgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgEygCAEEBRgRAIAZBLGoiAkGEwMIAQQRBBkEBEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASATKAIEEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAggEQCATKAIMIQMgBkEsaiICQYjAwgBBC0EGQQIQ6BwgBkEYaiABIAIQrhQgBigCGCIFQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAU2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIAMQqxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAgsgARDGIQsgEygCEARAIAZBLGoiAkGTwMIAQQ9BBkEDEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASATKAIUEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIAZBLGoiAkGiwMIAQQRBCEEEEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCADNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgASATKAJYIBMoAlwQpxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgARDGISATKAIYQQFGBEAgEygCHCEDIAZBLGoiAkGmwMIAQQxBBkEFEOgcIAZBGGogASACEK4UIAYoAhgiBUEERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASADEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAiAEQCAGQSxqIgJBssDCAEEOQQZBBhDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAEIAYpAhw3AgQgBEEMaiAGQSRqKQIANwIAIAQgAzYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgEygCJBCrGyAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyATKAIoBEAgEygCLCEDIAZBLGoiAkGVvMIAQQVBBkEHEOgcIAZBGGogASACEK4UIAYoAhgiBUEERwRAIAQgBikCHDcCBCAEQQxqIAZBJGopAgA3AgAgBCAFNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASADEKsbIAYoAiwiAkEERwRAIAQgBikCMDcCBCAEQQxqIAZBOGopAgA3AgAgBCACNgIADAILIAEQxiELIBMoAjAEQCATKAI0IQMgBkEsaiICQZq8wgBBCUEGQQgQ6BwgBkEYaiABIAIQrhQgBigCGCIFQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAU2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIAMQqxsgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAgsgARDGIQsgEygCOARAIBMoAjwhAyAGQSxqIgJBwMDCAEEIQQZBCRDoHCAGQRhqIAEgAhCuFCAGKAIYIgVBBEcEQCAEIAYpAhw3AgQgBEEMaiAGQSRqKQIANwIAIAQgBTYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyATKAJAQRJHBEAgBkEsaiICQcjAwgBBC0EKQQoQ6BwgBkEYaiABIAIQrhQgBigCGCIDQQRHBEAgBCAGKQIcNwIEIARBDGogBkEkaikCADcCACAEIAM2AgAgAhCGMAwCCyAGQSxqIgMQhjAgE0FAayEKIwBBQGoiAiQAIAJBDGpBrrzCAEELEIAgIAJBLGogARDnJwJAIAIoAiwiBUEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRAgCigCACIFQQJrIAVBAU0bQQFrDhABAgMEBQYHCAkKCwwNDg8QAAsgAkEsaiIFQbm8wgBBBkEKQQEQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwSCyACQSxqIgcQhjAjAEEgayIFJAAgBUGsucIAQQoQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDRAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMEQsgAkEsaiIFQb+8wgBBA0EKQQIQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwRCyACQSxqIgcQhjAjAEEgayIFJAAgBUG9tsIAQQcQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ8gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMEAsgAkEsaiIFQcK8wgBBBEEKQQMQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwQCyACQSxqIgcQhjAjAEEgayIFJAAgBUGmt8IAQQgQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ4gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMDwsgAkEsaiIFQca8wgBBBEEKQQQQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwPCyACQSxqIgcQhjAjAEEgayIFJAAgBUGGt8IAQQgQgCAgBUEMaiABEOcnAkAgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgBUEMaiABEIE2IAUoAgwiCkEERwRAIAcgBSkCEDcCBCAHQQxqIAVBGGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBRDeOyAFQSBqJAAgAigCLCIFQQRGDQ0gAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMDgsgAkEsaiIFQcq8wgBBB0EKQQUQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwOCyACQSxqIgcQhjAgCkEEaiEKIwBBQGoiBSQAIAVBDGpBirzCAEELEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAVBLGoiCEGVvMIAQQVBBkEBEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggASAKKAIAEKsbIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAEQxiEgBUEsaiIIQZq8wgBBCUEGQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAooAgQQqxsgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgARDGISAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNDCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwNCyACQSxqIgVB0bzCAEEEQQpBBhDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDA0LIAJBLGoiBxCGMCMAQSBrIgUkACAFQf62wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNCyADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwMCyACQSxqIgVB1bzCAEEEQQpBBxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAwLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakGSuMIAQQgQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgBUEsaiIIQZq4wgBBD0ECQQEQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAotAAAQ0BkgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgARDGISAFQSxqIghBqbjCAEEEQQpBAhDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAELIAVBLGoiCBCGMCAIIApBAWogARCmCSAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyABEMYhIAVBLGogARCBNiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyAHIAEQ5SgLIAVBDGoQ3jsgBUFAayQAIAIoAiwiBUEERg0KIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAsLIAJBLGoiBUHZvMIAQQlBCkEIEOgcIAJBGGogASAFEK4UIAIoAhgiB0EERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAHNgIAIAUQhjAMCwsgAkEsaiIHEIYwIApBBGohCiMAQUBqIgUkACAFQQxqQf/AwgBBDRCAICAFQSxqIAEQ5ycCQCAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwBCyAFQSxqIghBmrjCAEEPQQJBARDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAELIAVBLGoiCBCGMCAIIAEgCi0AABDQGSAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwBCyABEMYhIAVBLGoiCEGpuMIAQQRBCkECEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggCkEBaiABEKYJIAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAEQxiEgBUEsaiABEIE2IAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBUEMahDeOyAFQUBrJAAgAigCLCIFQQRGDQkgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMCgsgAkEsaiIFQeK8wgBBB0EKQQoQ6BwgAkEYaiABIAUQrhQgAigCGCIHQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAc2AgAgBRCGMAwKCyACQSxqIgcQhjAgCkEEaiEKIwBBQGoiBSQAIAVBDGpBprbCAEEHEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAVBLGoiCEGttsIAQQhBA0EBEOgcIAVBGGogASAIEK4UIAUoAhgiD0EERwRAIAcgBSkCHDcCBCAHQQxqIAVBJGopAgA3AgAgByAPNgIAIAgQhjAMAQsgBUEsaiIIEIYwIAggASAKLQABEIgaIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAEQxiEgBUEsaiIIQbW2wgBBCEECQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwBCyAFQSxqIggQhjAgCCABIAotAAAQ0BkgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgARDGISAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNCCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwJCyACQSxqIgVB6bzCAEEHQQpBCxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAkLIAJBLGoiBxCGMCMAQSBrIgUkACAFQa63wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNByADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwICyACQSxqIgVB8LzCAEEEQQpBDBDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAgLIAJBLGoiBxCGMCMAQSBrIgUkACAFQY63wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBiADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwHCyACQSxqIgVB9LzCAEEEQQpBDRDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAcLIAJBLGoiBxCGMCMAQSBrIgUkACAFQfa2wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBSADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwGCyACQSxqIgVB+LzCAEEEQQpBDhDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAYLIAJBLGoiBxCGMCMAQSBrIgUkACAFQca4wgBBCBCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNBCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwFCyACQSxqIgVB/LzCAEEHQQpBDxDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAULIAJBLGoiBxCGMCMAQSBrIgUkACAFQaO8wgBBCxCAICAFQQxqIAEQ5ycCQCAFKAIMIgpBBEcEQCAHIAUpAhA3AgQgB0EMaiAFQRhqKQIANwIAIAcgCjYCAAwBCyAFQQxqIAEQgTYgBSgCDCIKQQRHBEAgByAFKQIQNwIEIAdBDGogBUEYaikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFEN47IAVBIGokACACKAIsIgVBBEYNAyADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwECyACQSxqIgVBg73CAEEHQQpBEBDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAQLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakHevcIAQQsQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgCi0AAEEBRgRAIAotAAEhCCAFQSxqIgpB6b3CAEEVQQNBARDoHCAFQRhqIAEgChCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAKEIYwDAILIAVBLGoiChCGMCAKIAEgCBCIGiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwCCyABEMYhCyAFQSxqIAEQgTYgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAQsgByABEOUoCyAFQQxqEN47IAVBQGskACACKAIsIgVBBEYNAiADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBTYCAAwDCyACQSxqIgVBir3CAEEIQQpBERDoHCACQRhqIAEgBRCuFCACKAIYIgdBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBzYCACAFEIYwDAMLIAJBLGoiBxCGMCAKQQRqIQojAEFAaiIFJAAgBUEMakH5vsIAQQwQgCAgBUEsaiABEOcnAkAgBSgCLCIIQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAg2AgAMAQsgCigCAEGAgICAeEcEQCAFQSxqIghBhb/CAEEDQQhBARDoHCAFQRhqIAEgCBCuFCAFKAIYIg9BBEcEQCAHIAUpAhw3AgQgB0EMaiAFQSRqKQIANwIAIAcgDzYCACAIEIYwDAILIAVBLGoiCBCGMCAIIAEgCigCBCAKKAIIEKcbIAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAILIAEQxiELIAVBLGogARCBNiAFKAIsIgpBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCjYCAAwBCyAHIAEQ5SgLIAVBDGoQ3jsgBUFAayQAIAIoAiwiBUEERg0BIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAFNgIADAILIAJBLGoiBUGSvcIAQQlBCkESEOgcIAJBGGogASAFEK4UIAIoAhgiB0EERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAHNgIAIAUQhjAMAgsgAkEsaiIHEIYwIwBBQGoiBSQAIAVBDGpB4b/CAEENEIAgIAVBLGogARDnJwJAIAUoAiwiCEEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAINgIADAELIAooAghBgICAgHhHBEAgBUEsaiIIQYW/wgBBA0EIQQEQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwCCyAFQSxqIggQhjAgCCABIAooAgwgCigCEBCnGyAFKAIsIghBBEcEQCAHIAUpAjA3AgQgB0EMaiAFQThqKQIANwIAIAcgCDYCAAwCCyABEMYhCyAKKAIABEAgBUEsaiIIQe6/wgBBCUEGQQIQ6BwgBUEYaiABIAgQrhQgBSgCGCIPQQRHBEAgByAFKQIcNwIEIAdBDGogBUEkaikCADcCACAHIA82AgAgCBCGMAwCCyAFQSxqIggQhjAgCCABIAooAgQQqxsgBSgCLCIKQQRHBEAgByAFKQIwNwIEIAdBDGogBUE4aikCADcCACAHIAo2AgAMAgsgARDGIQsgBUEsaiABEIE2IAUoAiwiCkEERwRAIAcgBSkCMDcCBCAHQQxqIAVBOGopAgA3AgAgByAKNgIADAELIAcgARDlKAsgBUEMahDeOyAFQUBrJAAgAigCLCIFQQRGDQAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMAQsgARDGISACQSxqIAEQgTYgAigCLCIFQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAU2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAGKAIsIgJBBEcEQCAEIAYpAjA3AgQgBEEMaiAGQThqKQIANwIAIAQgAjYCAAwCCyABEMYhCyAGQSxqIAEQgTYgBigCLCICQQRHBEAgBCAGKQIwNwIEIARBDGogBkE4aikCADcCACAEIAI2AgAMAQsgBCABEOUoCyAGQQxqEN47IAZBQGskACAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwDCyATQeAAaiETIB9B4ABrIh8NAAsLIAEQxiEgCUEsaiICQdS3wgBBCEEHQQMQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwBCyAJQSxqIgIQhjAgAiABIBkpAyAQrBsgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAQsgARDGISAJQSxqIgJBl77CAEEKQQ1BBBDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAELIAlBLGoiAhCGMCACIAFBCiAZKAI8IgIQqxQgCSgCLCIDQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAM2AgAMAQsgAgRAIBkoAjghEyACQdAAbCEfA0AgCUEsaiEKIwBBQGoiBSQAIAVBDGpBtrfCAEEIEIAgIAVBLGogARDnJwJAIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAELIAVBLGoiAkG+t8IAQQdBDUEBEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAQsgBUEsaiICEIYwIAIgAUEKIBMoAjgiAhCrFCAFKAIsIgNBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAzYCAAwBCyACBEAgEygCNCEWIAJB6ANsISADQCAFQSxqIQcjAEFAaiIGJAAgBkEMakHsucIAQQsQgCAgBkEsaiABEOcnAkAgBigCLCICQQRHBEAgByAGKQIwNwIEIAdBDGogBkE4aikCADcCACAHIAI2AgAMAQsgFigC0ANBgICAgHhHBEAgBkEsaiICQfe5wgBBCUEIQQEQ6BwgBkEYaiABIAIQrhQgBigCGCIDQQRHBEAgByAGKQIcNwIEIAdBDGogBkEkaikCADcCACAHIAM2AgAgAhCGMAwCCyAGQSxqIgIQhjAgAiABIBYoAtQDIBYoAtgDEKcbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIAZBLGoiAkHrt8IAQQtBB0ECEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAQsgBkEsaiICEIYwIAIgASAWKQPIAxCsGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwBCyABEMYhIBYpAyBCAlIEQCAGQSxqIgJBgLrCAEEJQQpBAxDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiAxCGMCAWQSBqIQ8jAEFAaiICJAAgAkEMakGMwcIAQQ4QgCAgAkEsaiABEOcnAkAgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAQsgAkEsaiIEQYTAwgBBBEEGQQEQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABIA8oAvgCEKsbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAELIAEQxiEgAkEsaiIEQZrBwgBBCUENQQIQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABQQYgDygC0AIiBBCrFCACKAIsIghBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgCDYCAAwBCyAEBEAgDygCzAIhECAEQQJ0IQsDQCACQSxqIAEgECgCABCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwDCyAQQQRqIRAgC0EEayILDQALCyABEMYhIAJBLGoiBEGjwcIAQQ5BDUEDEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgAUEIIA8oAtwCIgQQqxQgAigCLCIIQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAg2AgAMAQsgBARAIA8oAtgCQQhqIRAgBEEMbCELA0AgAkEsaiABIBBBBGsoAgAgECgCABCnGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwDCyAQQQxqIRAgC0EMayILDQALCyABEMYhIAJBLGoiBEGxwcIAQQVBBkEEEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKAL8AhCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEG2wcIAQQpBB0EFEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQOoAhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEHAwcIAQRdBB0EGEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQOwAhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIAJBLGoiBEH2t8IAQRVBB0EHEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAQsgAkEsaiIEEIYwIAQgASAPKQO4AhCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwBCyABEMYhIA8oAuACQYCAgIB4RwRAIAJBLGoiBEGhvsIAQRJBDUEIEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgAUEKIA8oAugCIgQQqxQgAigCLCIIQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAg2AgAMAgsgBARAIA8oAuQCIRAgBEEYbCELA0AgAkEsaiAQIAEQ9wogAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMBAsgEEEYaiEQIAtBGGsiCw0ACwsgARDGIQsgAkEsaiIEQdfBwgBBEEEHQQkQ6BwgAkEYaiABIAQQrhQgAigCGCIIQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAg2AgAgBBCGMAwBCyACQSxqIgQQhjAgBCABIA8pA8ACEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAELIAEQxiEgDygCAEEBRgRAIA8pAwghJCACQSxqIgRB58HCAEERQQdBChDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAEgJBCsGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKAIQBEAgDykDGCEkIAJBLGoiBEH4wcIAQRZBB0ELEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgASAkEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAILIAEQxiELIA8pAzBCAlIEQCACQSxqIgRBjsLCAEEKQQpBDBDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiCBCGMCAPQTBqIRAjAEFAaiIEJAAgBEEMakHOuMIAQQoQgCAgBEEsaiABEOcnAkAgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAQsgECgCIEGAgICAeEcEQCAEQSxqIgtB2LjCAEEDQQhBARDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgECgCJCAQKAIoEKcbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAixBgICAgHhHBEAgBEEsaiILQdu4wgBBA0EIQQIQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABIBAoAjAgECgCNBCnGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQKAIABEAgECkDCCEkIARBLGoiC0HeuMIAQQpBB0EDEOgcIARBGGogASALEK4UIAQoAhgiDEEERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAMNgIAIAsQhjAMAgsgBEEsaiILEIYwIAsgASAkEKwbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAhAEQCAQKQMYISQgBEEsaiILQei4wgBBDkEHQQQQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABICQQrBsgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAgsgARDGIQsgECgCOEGAgICAeEcEQCAEQSxqIgtB9rjCAEEJQQhBBRDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgECgCPCAQKAJAEKcbIAQoAiwiC0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCALNgIADAILIAEQxiELIBAoAkRBgICAgHhHBEAgBEEsaiILQf+4wgBBCUEIQQYQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABIBAoAkggECgCTBCnGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQLQBQIgxBAkcEQCAEQSxqIgtBiLnCAEESQQJBBxDoHCAEQRhqIAEgCxCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACALEIYwDAILIARBLGoiCxCGMCALIAEgDEEBcRDQGSAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQLQBRIgtBAkcEQCAEQSxqIhBBmrnCAEESQQJBCBDoHCAEQRhqIAEgEBCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACAQEIYwDAILIARBLGoiEBCGMCAQIAEgC0EBcRDQGSAEKAIsIhBBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggEDYCAAwCCyABEMYhCyAEQSxqIAEQgTYgBCgCLCIQQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIBA2AgAMAQsgCCABEOUoCyAEQQxqEN47IARBQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKALsAkGAgICAeEcEQCACQSxqIgRBmMLCAEEOQQ1BDRDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAFBCiAPKAL0AiIEEKsUIAIoAiwiCEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAINgIADAILIAQEQCAPKALwAiEQIARBDGwhCwNAIAJBLGohCCMAQUBqIgQkACAEQQxqQf/DwgBBERCAICAEQSxqIAEQ5ycCQCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyAEQSxqIgxBkMTCAEEJQQZBARDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgECgCABCrGyAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIARBLGoiDEGZxMIAQQhBBkECEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAQsgBEEsaiIMEIYwIAwgASAQKAIEEKsbIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAEQxiEgBEEsaiIMQaHEwgBBBUEGQQMQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwBCyAEQSxqIgwQhjAgDCABIBAoAggQqxsgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgARDGISAEQSxqIAEQgTYgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgCCABEOUoCyAEQQxqEN47IARBQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwECyAQQQxqIRAgC0EMayILDQALCyABEMYhCyAPKAIgBEAgDykDKCEkIAJBLGoiBEGmwsIAQRNBB0EOEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIEEIYwIAQgASAkEKwbIAIoAiwiBEEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAENgIADAILIAEQxiELIA8oAqACBEAgDygCpAIhCCACQSxqIgRBucLCAEETQQZBDxDoHCACQRhqIAEgBBCuFCACKAIYIhBBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgEDYCACAEEIYwDAILIAJBLGoiBBCGMCAEIAEgCBCrGyACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyAPKQOIAUICUgRAIAJBLGoiBEHMwsIAQQ9BCkEQEOgcIAJBGGogASAEEK4UIAIoAhgiCEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAINgIAIAQQhjAMAgsgAkEsaiIIEIYwIA9BiAFqIRAjAEFAaiIEJAAgBEEMakHwwsIAQQ4QgCAgBEEsaiABEOcnAkAgBCgCLCILQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAs2AgAMAQsgECgCAEEBRgRAIBApAwghJCAEQSxqIgtBv73CAEEfQQdBARDoHCAEQRhqIAEgCxCuFCAEKAIYIgxBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggDDYCACALEIYwDAILIARBLGoiCxCGMCALIAEgJBCsGyAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyABEMYhCyAQKAIQQYCAgIB4RwRAIARBLGoiC0H+wsIAQRpBDUECEOgcIARBGGogASALEK4UIAQoAhgiDEEERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAMNgIAIAsQhjAMAgsgBEEsaiILEIYwIAsgAUEHIBAoAhgiDBCrFCAEKAIsIgtBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggCzYCAAwCCyAMBEAgECgCFCELIAxBA3QhDANAIARBLGogASALKQMAEKwbIAQoAiwiF0EERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAXNgIADAQLIAtBCGohCyAMQQhrIgwNAAsLIAEQxiELIBAoAhxBgICAgHhHBEAgBEEsaiILQZjDwgBBGkENQQMQ6BwgBEEYaiABIAsQrhQgBCgCGCIMQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIAw2AgAgCxCGMAwCCyAEQSxqIgsQhjAgCyABQQcgECgCJCILEKsUIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAILIAsEQCAQKAIgIQwgC0EDdCELA0AgBEEsaiABIAwpAwAQrBsgBCgCLCIQQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIBA2AgAMBAsgDEEIaiEMIAtBCGsiCw0ACwsgARDGIQsgBEEsaiABEIE2IAQoAiwiEEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAQNgIADAELIAggARDlKAsgBEEMahDeOyAEQUBrJAAgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAgsgARDGIQsgDykDsAFCA1IEQCACQSxqIgRB28LCAEEVQQpBERDoHCACQRhqIAEgBBCuFCACKAIYIghBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgCDYCACAEEIYwDAILIAJBLGoiEBCGMCAPQbABaiELIwBBQGoiDyQAIA9BDGpBxcXCAEEUEIAgIA9BLGogARDnJwJAIA8oAiwiBEEERwRAIBAgDykCMDcCBCAQQQxqIA9BOGopAgA3AgAgECAENgIADAELIAspAwBCAlIEQCAPQSxqIgRB2cXCAEEEQQpBARDoHCAPQRhqIAEgBBCuFCAPKAIYIghBBEcEQCAQIA8pAhw3AgQgEEEMaiAPQSRqKQIANwIAIBAgCDYCACAEEIYwDAILIA9BLGoiCBCGMCMAQUBqIgQkACAEQQxqQcG5wgBBCxCAICAEQSxqIAEQ5ycCQCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyAEQSxqIgxBzLnCAEEEQQRBARDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgCysDQBDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIARBLGoiDEHQucIAQQRBBEECEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAQsgBEEsaiIMEIYwIAwgASALKwNIEM4kIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAEQxiEgBEEsaiIMQdS5wgBBBEEEQQMQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwBCyAEQSxqIgwQhjAgDCABIAsrA1AQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAQsgARDGISAEQSxqIgxB2LnCAEEEQQRBBBDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAELIARBLGoiDBCGMCAMIAEgCysDWBDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwBCyABEMYhIAsoAgBBAUYEQCALKwMIIScgBEEsaiIMQdy5wgBBBEEEQQUQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwCCyAEQSxqIgwQhjAgDCABICcQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAgsgARDGIQsgCygCEARAIAsrAxghJyAEQSxqIgxB4LnCAEEEQQRBBhDoHCAEQRhqIAEgDBCuFCAEKAIYIhdBBEcEQCAIIAQpAhw3AgQgCEEMaiAEQSRqKQIANwIAIAggFzYCACAMEIYwDAILIARBLGoiDBCGMCAMIAEgJxDOJCAEKAIsIgxBBEcEQCAIIAQpAjA3AgQgCEEMaiAEQThqKQIANwIAIAggDDYCAAwCCyABEMYhCyALKAIgBEAgCysDKCEnIARBLGoiDEHkucIAQQRBBEEHEOgcIARBGGogASAMEK4UIAQoAhgiF0EERwRAIAggBCkCHDcCBCAIQQxqIARBJGopAgA3AgAgCCAXNgIAIAwQhjAMAgsgBEEsaiIMEIYwIAwgASAnEM4kIAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAILIAEQxiELIAsoAjAEQCALKwM4IScgBEEsaiIMQei5wgBBBEEEQQgQ6BwgBEEYaiABIAwQrhQgBCgCGCIXQQRHBEAgCCAEKQIcNwIEIAhBDGogBEEkaikCADcCACAIIBc2AgAgDBCGMAwCCyAEQSxqIgwQhjAgDCABICcQziQgBCgCLCIMQQRHBEAgCCAEKQIwNwIEIAhBDGogBEE4aikCADcCACAIIAw2AgAMAgsgARDGIQsgBEEsaiABEIE2IAQoAiwiDEEERwRAIAggBCkCMDcCBCAIQQxqIARBOGopAgA3AgAgCCAMNgIADAELIAggARDlKAsgBEEMahDeOyAEQUBrJAAgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAgsgARDGIQsgCygCYEGAgICAeEcEQCAPQSxqIgRB3cXCAEEQQQ1BAhDoHCAPQRhqIAEgBBCuFCAPKAIYIghBBEcEQCAQIA8pAhw3AgQgEEEMaiAPQSRqKQIANwIAIBAgCDYCACAEEIYwDAILIA9BLGoiBBCGMCAEIAFBBiALKAJoIggQqxQgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAgsgCARAIAsoAmQhBCAIQQJ0IQwDQCAPQSxqIAEgBCgCABCrGyAPKAIsIghBBEcEQCAQIA8pAjA3AgQgEEEMaiAPQThqKQIANwIAIBAgCDYCAAwECyAEQQRqIQQgDEEEayIMDQALCyABEMYhCyAPQSxqIAEQgTYgDygCLCIEQQRHBEAgECAPKQIwNwIEIBBBDGogD0E4aikCADcCACAQIAQ2AgAMAQsgECABEOUoCyAPQQxqEN47IA9BQGskACACKAIsIgRBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBDYCAAwCCyABEMYhCyACQSxqIAEQgTYgAigCLCIEQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAQ2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAIABEAgFikDCCEkIAZBLGoiAkGJusIAQRNBB0EEEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASAkEKwbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIBYoAqADBEAgFigCpAMhAyAGQSxqIgJBnLrCAEETQQZBBRDoHCAGQRhqIAEgAhCuFCAGKAIYIgRBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgBDYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAIQBEAgFikDGCEkIAZBLGoiAkGvusIAQRNBB0EGEOgcIAZBGGogASACEK4UIAYoAhgiA0EERwRAIAcgBikCHDcCBCAHQQxqIAZBJGopAgA3AgAgByADNgIAIAIQhjAMAgsgBkEsaiICEIYwIAIgASAkEKwbIAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAILIAEQxiELIBYoAqgDBEAgFigCrAMhAyAGQSxqIgJBwrrCAEETQQZBBxDoHCAGQRhqIAEgAhCuFCAGKAIYIgRBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgBDYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgAxCrGyAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKAKwA0GBgICAeEcEQCAGQSxqIgJB1brCAEEPQQpBCBDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiCBCGMCAWQbADaiEPIwBBQGoiAyQAIANBDGpB/cTCAEEUEIAgIANBLGogARDnJwJAIAMoAiwiAkEERwRAIAggAykCMDcCBCAIQQxqIANBOGopAgA3AgAgCCACNgIADAELAkACQCAPKAIAQYCAgIB4RwRAIANBLGoiAkGrxcIAQRpBCkECEOgcIANBGGogASACEK4UIAMoAhgiBEEERg0BIAggAykCHDcCBCAIQQxqIANBJGopAgA3AgAgCCAENgIAIAIQhjAMAwsgA0EsaiICQZHFwgBBGkEKQQEQ6BwgA0EYaiABIAIQrhQgAygCGCIEQQRHBEAgCCADKQIcNwIEIAhBDGogA0EkaikCADcCACAIIAQ2AgAgAhCGMAwDCyADQSxqIgQQhjAjAEEgayICJAAgAkGyxsIAQRcQgCAgAkEMaiABEOcnAkAgAigCDCIPQQRHBEAgBCACKQIQNwIEIARBDGogAkEYaikCADcCACAEIA82AgAMAQsgAkEMaiABEIE2IAIoAgwiD0EERwRAIAQgAikCEDcCBCAEQQxqIAJBGGopAgA3AgAgBCAPNgIADAELIAQgARDlKAsgAhDeOyACQSBqJAAgAygCLCICQQRGDQEgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAgsgA0EsaiIEEIYwIwBBQGoiAiQAIAJBDGpBj8bCAEEXEIAgIAJBLGogARDnJwJAIAIoAiwiEEEERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAQNgIADAELIAJBLGoiEEGjwcIAQQ5BDUEBEOgcIAJBGGogASAQEK4UIAIoAhgiC0EERwRAIAQgAikCHDcCBCAEQQxqIAJBJGopAgA3AgAgBCALNgIAIBAQhjAMAQsgAkEsaiIQEIYwIBAgAUEIIA8oAggiCxCrFCACKAIsIhBBBEcEQCAEIAIpAjA3AgQgBEEMaiACQThqKQIANwIAIAQgEDYCAAwBCyALBEAgDygCBEEIaiEQIAtBDGwhCwNAIAJBLGogASAQQQRrKAIAIBAoAgAQpxsgAigCLCIMQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIAw2AgAMAwsgEEEMaiEQIAtBDGsiCw0ACwsgARDGISAPKAIMQYCAgIB4RwRAIAJBLGoiEEGmxsIAQQxBCEECEOgcIAJBGGogASAQEK4UIAIoAhgiC0EERwRAIAQgAikCHDcCBCAEQQxqIAJBJGopAgA3AgAgBCALNgIAIBAQhjAMAgsgAkEsaiIQEIYwIBAgASAPKAIQIA8oAhQQpxsgAigCLCIPQQRHBEAgBCACKQIwNwIEIARBDGogAkE4aikCADcCACAEIA82AgAMAgsgARDGIQsgAkEsaiABEIE2IAIoAiwiD0EERwRAIAQgAikCMDcCBCAEQQxqIAJBOGopAgA3AgAgBCAPNgIADAELIAQgARDlKAsgAkEMahDeOyACQUBrJAAgAygCLCICQQRGDQAgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAQsgARDGISADQSxqIAEQgTYgAygCLCICQQRHBEAgCCADKQIwNwIEIAhBDGogA0E4aikCADcCACAIIAI2AgAMAQsgCCABEOUoCyADQQxqEN47IANBQGskACAGKAIsIgJBBEcEQCAHIAYpAjA3AgQgB0EMaiAGQThqKQIANwIAIAcgAjYCAAwCCyABEMYhCyAWKALcA0GAgICAeEcEQCAGQSxqIgJB5LrCAEEZQQhBCRDoHCAGQRhqIAEgAhCuFCAGKAIYIgNBBEcEQCAHIAYpAhw3AgQgB0EMaiAGQSRqKQIANwIAIAcgAzYCACACEIYwDAILIAZBLGoiAhCGMCACIAEgFigC4AMgFigC5AMQpxsgBigCLCICQQRHBEAgByAGKQIwNwIEIAdBDGogBkE4aikCADcCACAHIAI2AgAMAgsgARDGIQsgBkEsaiABEIE2IAYoAiwiAkEERwRAIAcgBikCMDcCBCAHQQxqIAZBOGopAgA3AgAgByACNgIADAELIAcgARDlKAsgBkEMahDeOyAGQUBrJAAgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAwsgFkHoA2ohFiAgQegDayIgDQALCyABEMYhIAVBLGoiAkHFt8IAQQ9BB0ECEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAQsgBUEsaiICEIYwIAIgASATKQMgEKwbIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAELIAEQxiEgBUEsaiICQdS3wgBBCEEHQQMQ6BwgBUEYaiABIAIQrhQgBSgCGCIDQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAM2AgAgAhCGMAwBCyAFQSxqIgIQhjAgAiABIBMpAygQrBsgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgARDGISATKAI8QYCAgIB4RwRAIAVBLGoiAkHct8IAQQ9BDUEEEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAgsgBUEsaiICEIYwIAIgAUEKIBMoAkQiAhCrFCAFKAIsIgNBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAzYCAAwCCyACBEAgEygCQCEWIAJBA3QhIANAIAVBLGohAyMAQUBqIgIkACACQQxqQdPAwgBBDRCAICACQSxqIAEQ5ycCQCACKAIsIgZBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBjYCAAwBCyACQSxqIgZB4MDCAEEKQQZBARDoHCACQRhqIAEgBhCuFCACKAIYIgRBBEcEQCADIAIpAhw3AgQgA0EMaiACQSRqKQIANwIAIAMgBDYCACAGEIYwDAELIAJBLGoiBhCGMCAGIAEgFigCABCrGyACKAIsIgZBBEcEQCADIAIpAjA3AgQgA0EMaiACQThqKQIANwIAIAMgBjYCAAwBCyABEMYhIAJBLGoiBkHqwMIAQQpBAkECEOgcIAJBGGogASAGEK4UIAIoAhgiBEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAENgIAIAYQhjAMAQsgAkEsaiIGEIYwIAYgASAWLQAEENAZIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAEQxiEgAkEsaiIGQfTAwgBBC0ECQQMQ6BwgAkEYaiABIAYQrhQgAigCGCIEQQRHBEAgAyACKQIcNwIEIANBDGogAkEkaikCADcCACADIAQ2AgAgBhCGMAwBCyACQSxqIgYQhjAgBiABIBYtAAUQ0BkgAigCLCIGQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAY2AgAMAQsgARDGISACQSxqIAEQgTYgAigCLCIGQQRHBEAgAyACKQIwNwIEIANBDGogAkE4aikCADcCACADIAY2AgAMAQsgAyABEOUoCyACQQxqEN47IAJBQGskACAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwECyAWQQhqIRYgIEEIayIgDQALCyABEMYhCyATKAIABEAgEykDCCEkIAVBLGoiAkHrt8IAQQtBB0EFEOgcIAVBGGogASACEK4UIAUoAhgiA0EERwRAIAogBSkCHDcCBCAKQQxqIAVBJGopAgA3AgAgCiADNgIAIAIQhjAMAgsgBUEsaiICEIYwIAIgASAkEKwbIAUoAiwiAkEERwRAIAogBSkCMDcCBCAKQQxqIAVBOGopAgA3AgAgCiACNgIADAILIAEQxiELIBMoAhAEQCATKQMYISQgBUEsaiICQfa3wgBBFUEHQQYQ6BwgBUEYaiABIAIQrhQgBSgCGCIDQQRHBEAgCiAFKQIcNwIEIApBDGogBUEkaikCADcCACAKIAM2AgAgAhCGMAwCCyAFQSxqIgIQhjAgAiABICQQrBsgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAgsgARDGIQsgEy8BSARAIBMvAUohAyAFQSxqIgJBi7jCAEEHQQVBBxDoHCAFQRhqIAEgAhCuFCAFKAIYIgZBBEcEQCAKIAUpAhw3AgQgCkEMaiAFQSRqKQIANwIAIAogBjYCACACEIYwDAILIAVBLGoiAhCGMCACIAEgAxCpGyAFKAIsIgJBBEcEQCAKIAUpAjA3AgQgCkEMaiAFQThqKQIANwIAIAogAjYCAAwCCyABEMYhCyAFQSxqIAEQgTYgBSgCLCICQQRHBEAgCiAFKQIwNwIEIApBDGogBUE4aikCADcCACAKIAI2AgAMAQsgCiABEOUoCyAFQQxqEN47IAVBQGskACAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwDCyATQdAAaiETIB9B0ABrIh8NAAsLIAEQxiEgGSgCQEGAgICAeEcEQCAJQSxqIgJBob7CAEESQQ1BBRDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAILIAlBLGoiAhCGMCACIAFBCiAZKAJIIgIQqxQgCSgCLCIDQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAM2AgAMAgsgAgRAIBkoAkQhEyACQRhsIR8DQCAJQSxqIBMgARD3CiAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwECyATQRhqIRMgH0EYayIfDQALCyABEMYhCyAZKAJMQYCAgIB4RwRAIAlBLGoiAkGzvsIAQQpBCEEGEOgcIAlBGGogASACEK4UIAkoAhgiA0EERwRAIBEgCSkCHDcCBCARQQxqIAlBJGopAgA3AgAgESADNgIAIAIQhjAMAgsgCUEsaiICEIYwIAIgASAZKAJQIBkoAlQQpxsgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAgsgARDGIQsgGSgCWEGAgICAeEcEQCAJQSxqIgJBvb7CAEENQQ1BBxDoHCAJQRhqIAEgAhCuFCAJKAIYIgNBBEcEQCARIAkpAhw3AgQgEUEMaiAJQSRqKQIANwIAIBEgAzYCACACEIYwDAILIAlBLGoiAhCGMCACIAFBCiAZKAJgIhMQqxQgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAgsgEwRAA0AgCUEsaiEDIwBBQGoiAiQAIAJBDGpB9bvCAEELEIAgIAJBLGogARDnJwJAIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAJBLGoiBkGAvMIAQQpBCkEBEOgcIAJBGGogASAGEK4UIAIoAhgiBEEERwRAIAMgAikCHDcCBCADQQxqIAJBJGopAgA3AgAgAyAENgIAIAYQhjAMAQsgAkEsaiIEEIYwIwBBIGsiBiQAIAZBx8PCAEEQEIAgIAZBDGogARDnJwJAIAYoAgwiBUEERwRAIAQgBikCEDcCBCAEQQxqIAZBGGopAgA3AgAgBCAFNgIADAELIAZBDGogARCBNiAGKAIMIgVBBEcEQCAEIAYpAhA3AgQgBEEMaiAGQRhqKQIANwIAIAQgBTYCAAwBCyAEIAEQ5SgLIAYQ3jsgBkEgaiQAIAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAEQxiEgAkEsaiABEIE2IAIoAiwiBkEERwRAIAMgAikCMDcCBCADQQxqIAJBOGopAgA3AgAgAyAGNgIADAELIAMgARDlKAsgAkEMahDeOyACQUBrJAAgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMBAsgE0EBayITDQALCyABEMYhCyAZKAIAQQJHBEAgCUEsaiICQcq+wgBBFEEKQQgQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwCCyAJQSxqIgQQhjAjAEFAaiIDJAAgA0EMakGmxMIAQRMQgCAgA0EsaiABEOcnAkAgAygCLCICQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAI2AgAMAQsCQAJAIBkoAgBBAUYEQCADQSxqIgJBw8TCAEEOQQpBAhDoHCADQRhqIAEgAhCuFCADKAIYIgZBBEYNASAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgBjYCACACEIYwDAMLIANBLGoiAkG5xMIAQQpBCkEBEOgcIANBGGogASACEK4UIAMoAhgiBkEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAGNgIAIAIQhjAMAwsgA0EsaiIGEIYwIBlBBGohBSMAQUBqIgIkACACQQxqQcS2wgBBCBCAICACQSxqIAEQ5ycCQCACKAIsIgdBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBzYCAAwBCyAFKAIAQYCAgIB4RwRAIAJBLGoiB0HMtsIAQQpBCEEBEOgcIAJBGGogASAHEK4UIAIoAhgiCkEERwRAIAYgAikCHDcCBCAGQQxqIAJBJGopAgA3AgAgBiAKNgIAIAcQhjAMAgsgAkEsaiIHEIYwIAcgASAFKAIEIAUoAggQpxsgAigCLCIHQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAc2AgAMAgsgARDGIQsgBSgCDEGAgICAeEcEQCACQSxqIgdB1rbCAEEPQQhBAhDoHCACQRhqIAEgBxCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAHEIYwDAILIAJBLGoiBxCGMCAHIAEgBSgCECAFKAIUEKcbIAIoAiwiB0EERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAHNgIADAILIAEQxiELIAUtABgiB0ECRwRAIAJBLGoiBUHltsIAQRFBAkEDEOgcIAJBGGogASAFEK4UIAIoAhgiCkEERwRAIAYgAikCHDcCBCAGQQxqIAJBJGopAgA3AgAgBiAKNgIAIAUQhjAMAgsgAkEsaiIFEIYwIAUgASAHQQFxENAZIAIoAiwiBUEERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAFNgIADAILIAEQxiELIAJBLGogARCBNiACKAIsIgVBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBTYCAAwBCyAGIAEQ5SgLIAJBDGoQ3jsgAkFAayQAIAMoAiwiAkEERg0BIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCACNgIADAILIANBLGoiBhCGMCAZQQRqIQUjAEFAaiICJAAgAkEMakG2ucIAQQsQgCAgAkEsaiABEOcnAkAgAigCLCIHQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAc2AgAMAQsgBSgCAEGAgICAeEcEQCACQSxqIgdBzLbCAEEKQQhBARDoHCACQRhqIAEgBxCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAHEIYwDAILIAJBLGoiBxCGMCAHIAEgBSgCBCAFKAIIEKcbIAIoAiwiB0EERwRAIAYgAikCMDcCBCAGQQxqIAJBOGopAgA3AgAgBiAHNgIADAILIAEQxiELIAUoAgxBgICAgHhHBEAgAkEsaiIHQda2wgBBD0EIQQIQ6BwgAkEYaiABIAcQrhQgAigCGCIKQQRHBEAgBiACKQIcNwIEIAZBDGogAkEkaikCADcCACAGIAo2AgAgBxCGMAwCCyACQSxqIgcQhjAgByABIAUoAhAgBSgCFBCnGyACKAIsIgdBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBzYCAAwCCyABEMYhCyAFLQAYIgdBAkcEQCACQSxqIgVB5bbCAEERQQJBAxDoHCACQRhqIAEgBRCuFCACKAIYIgpBBEcEQCAGIAIpAhw3AgQgBkEMaiACQSRqKQIANwIAIAYgCjYCACAFEIYwDAILIAJBLGoiBRCGMCAFIAEgB0EBcRDQGSACKAIsIgVBBEcEQCAGIAIpAjA3AgQgBkEMaiACQThqKQIANwIAIAYgBTYCAAwCCyABEMYhCyACQSxqIAEQgTYgAigCLCIFQQRHBEAgBiACKQIwNwIEIAZBDGogAkE4aikCADcCACAGIAU2AgAMAQsgBiABEOUoCyACQQxqEN47IAJBQGskACADKAIsIgJBBEYNACAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgAjYCAAwBCyABEMYhIANBLGogARCBNiADKAIsIgJBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgAjYCAAwBCyAEIAEQ5SgLIANBDGoQ3jsgA0FAayQAIAkoAiwiAkEERwRAIBEgCSkCMDcCBCARQQxqIAlBOGopAgA3AgAgESACNgIADAILIAEQxiELIBkoAmRBgICAgHhHBEAgCUEsaiICQd6+wgBBG0EIQQkQ6BwgCUEYaiABIAIQrhQgCSgCGCIDQQRHBEAgESAJKQIcNwIEIBFBDGogCUEkaikCADcCACARIAM2AgAgAhCGMAwCCyAJQSxqIgIQhjAgAiABIBkoAmggGSgCbBCnGyAJKAIsIgJBBEcEQCARIAkpAjA3AgQgEUEMaiAJQThqKQIANwIAIBEgAjYCAAwCCyABEMYhCyAJQSxqIAEQgTYgCSgCLCICQQRHBEAgESAJKQIwNwIEIBFBDGogCUE4aikCADcCACARIAI2AgAMAQsgESABEOUoCyAJQQxqEN47IAlBQGskAAJAIAEoAigiAkEERwRAIAFByABqIAFBNGopAgA3AgAgASABKQIsNwJAIAEgAjYCPCAeIAFBPGoQpSUMAQsgHkEINgIACyABELouIAFB0ABqJAAgDSgC6AEiAUEIRwRAIBsgDSkC7AE3AgwgG0EcaiANQfwBaigCADYCACAbQRRqIA1B9AFqKQIANwIAIBtBAzYCACAbIAE2AggMAgsgDSAiKAIAIgEoAhQgI2s2AswBIA1B6AFqIgIgASANQcwBakEEEKgaAkAgDS0A6AFBBEYNACANKQPoASIkQv8Bg0IEUQ0AIA0gJDcD6AEgG0EIaiACEIErIBtBAzYCAAwCCyANQegBaiIBICIoAgBBgPbPAEEEEKgaAkAgDS0A6AFBBEYNACANKQPoASIkQv8Bg0IEUQ0AIA0gJDcD6AEgG0EIaiABEIErIBtBAzYCAAwCCyANKAIQQYCAgIB4RwRAIA1BiAJqIgIgDUEYaigCADYCACANIA0pAhA3A4ACIA1B/ABqIgEQ9BsgARDvOyABQQhqIAIoAgA2AgAgASANKQOAAjcCAAsgGyANQcgAakH4APwKAAAgGBCHMAwECyANKQP4ASEkIBsgDSkD2AE3AgwgGyAkNwMYIBsgCTYCCCAbQQM2AgAgG0EUaiADKAIANgIAIA1BzAFqEIcwIA1BwAFqIgEQ9BsgARDvOyANQTxqEIYwIA1BHGoQuy4gDUEQahCSMCANQQRqEJEwDAILIA1ByABqEJIoIA1BEGoQkjAMAQsgGyANKQJMNwIMIBtBHGogDUHcAGooAgA2AgAgG0EUaiANQdQAaikCADcCACAbQQM2AgAgGyAcNgIIIBoQ9BsgGhDvOwsgGkEMahCHMCAaQRhqIRwLIBwQhjAgDUGQAmokAAsgEkGwAWokAAwBCyADIBIoAnBB8MXDABD9LwALIBUoApgBIgFBA0YEQCAVQYwBaiAVQbABaikDACIkNwIAIBVBhAFqIBVBqAFqKQMAIiU3AgAgFSAVKQOgASImNwJ8IB1BGGogJDcCACAdQRBqICU3AgAgHSAmNwIIIB1BAzYCAAwBCyAVQZABaiICIBVBtAFqKAIANgIAIBVBiAFqIgMgFUGsAWopAgA3AwAgFUGAAWoiCSAVQaQBaikCADcDACAVIBUpApwBNwN4IBVBIGogFUG4AWpB2AD8CgAAIBVBDGogCSkDADcCACAVQRRqIAMpAwA3AgAgFUEcaiACKAIANgIAIBUgATYCACAVIBUpA3g3AgQgFUGYAWoiASAUEMMZAkAgFS0AmAFBBEYNACAVKQOYASIkQv8Bg0IEUQ0AIBUgJDcDmAEgHUEIaiABEIErIB1BAzYCACAVENgcDAELIB0gFUH4APwKAAALIBVBkAJqJAAMAQsgAyAVKAKgAUHwxcMAEP0vAAsLICFBIGokACAUENQpIBQQ3jsgFCgCVCIBIAEoAgAiAUEBazYCACABQQFGBEAgFEHUAGoQgyALIBQoAlgiASABKAIAIgFBAWs2AgAgAUEBRgRAIBRB2ABqEIYfCyAUKAJcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAUQdwAahCuIAsgFEEYaiIBENwYIAEQ7DsgFEEkaiIBELErIAFBBEEMEOAeIBRBMGoiARC6KiABQQRBDBDgHiAUQTxqIgEQuyogAUEEQQwQ4B4gFEHIAGoiARDgKSABEPI7IBQoAowBQYCAgIB4RwRAIBRBjAFqEO8rCyAUKAKgASIBIAEoAgAiAUEBazYCACABQQFGBEAgFEGgAWoQ+CMLIBRB6ABqEP4oIBQoAoQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAUQYQBahD4IwsgFCgCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIBRBiAFqEK4gCyAOKAK4ASIBQQNGBEAgDkHcA2ogDkHQAWopAwAiJDcCACAOQdQDaiAOQcgBaikDACIlNwIAIA4gDikDwAEiJjcCzAMgDkH4A2ogJDcDACAOQfADaiAlNwMAIA4gJjcD6AMgACAUEMgmDAELIA5B4ANqIgIgDkHUAWooAgA2AgAgDkHYA2oiAyAOQcwBaikCADcDACAOQdADaiIJIA5BxAFqKQIANwMAIA4gDikCvAE3A8gDIA5B8AJqIA5B2AFqQdgA/AoAACAOQdwCaiAJKQMANwIAIA5B5AJqIAMpAwA3AgAgDkHsAmogAigCADYCACAOIAE2AtACIA4gDikDyAM3AtQCIA5B0AJqEJIoIABBDGogDkEMaigCADYCACAAIA4pAgQ3AgQgAEEGNgIADAELIA5BBGoQ3jsLIA5BkAVqJAALwQsCCX8DfiMAQcABayICJAAgAUEMahDZPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABLwEAIgZBgAFqQf//A3FB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUECaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEBdGovAQAiA0GAAWpB//8DcUH/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu5CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxC/////w9YBEAgByAMPgIADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0EEaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL/////D1gEQCAHIAFBAnRqIAw+AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQxx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu1CwIKfwN+IwBBwAFrIgIkACABQQxqENs8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEEBdCIFIQMCQCAFQT5xIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFKAIAIgFB//8BTQRAIAcgATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBAmohByAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnRqKAIAIgRB//8BTQRAIAcgAUEBdGogBDsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ULAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBQJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQQLIAJCADcCOCACIAQ2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBEUNAgsgAkIANwI4IAIgBDYCNCACIAY2AjAgAkHAADYCLCACQSxqIAUQ3hBBACEGCyAFQQF0IgQhAwJAIARBPnEiBwRAIAQgB2tBQGsiAyAESQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBARAIAQEQCAHQQAgBPwLAAsgAigCUCELIAIoAkghBwsgAiAENgJMIAIgBSALajYCUAJAAkAgBgRAIAUgBkcNASAFIQYMCAsgBUUEQEEAIQYMCAsgASgCECEEQQAhBkEAIQMDQAJAIAQpAwAiDEL//wFYBEAgByAMPQEADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0ECaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL//wFYBEAgByABQQF0aiAMPQEADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4RkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENodIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALtQsCCn8DfiMAQcABayICJAAgAUEMahDYPCEFAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNBAsgAkIANwI4IAIgBDYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIERQ0CCyACQgA3AjggAiAENgI0IAIgBjYCMCACQcAANgIsIAJBLGogBRDeEEEAIQYLIAVBAXQiBCEDAkAgBEE+cSIHBEAgBCAHa0FAayIDIARJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAEBEAgBARAIAdBACAE/AsACyACKAJQIQsgAigCSCEHCyACIAQ2AkwgAiAFIAtqNgJQAkACQCAGBEAgBSAGRw0BIAUhBgwICyAFRQRAQQAhBgwICyABKAIQIQRBACEGQQAhAwNAAkAgBCkDACIMQv//A1gEQCAHIAw9AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBEEIaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQN0aikDACIMQv//A1gEQCAHIAFBAXRqIAw9AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu5CwIKfwN+IwBBwAFrIgIkACABQQxqENg8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUECdCIEIQMCQCAEQTxxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEKQMAIgxC/////wdYBEAgByAMPgIADAELIAJBEGogAkEsahCGPSADQQN2IgEgAigCFCIITw0DIAIoAhAgAWoiASABLQAAQX4gA0EHcXdxOgAAIAZBAWohBgsgB0EEaiEHIARBCGohBCAFIANBAWoiA0cNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAUQvxQgAkGYAWohAyABKAIQIQQDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgBCAOpyAMp2oiAUEDdGopAwAiDEL/////B1gEQCAHIAFBAnRqIAw+AgAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBSACKAIcIghJBEAgAigCGCAFaiIFIAUtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAFIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgUQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgQpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAFENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBCkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDlGSAJIAJB6ABqKAIANgIAIAQgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAUQvx0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuxCwIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0ECyACQgA3AjggAiAENgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgRFDQILIAJCADcCOCACIAQ2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAFEN4QQQAhBgsgBUEDdCIEIQMCQCAEQThxIgcEQCAEIAdrQUBrIgMgBEkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAQEQCAEBEAgB0EAIAT8CwALIAIoAlAhCyACKAJIIQcLIAIgBDYCTCACIAUgC2o2AlACQAJAIAYEQCAFIAZHDQEgBSEGDAgLIAVFBEBBACEGDAgLIAEoAhAhBEEAIQZBACEDA0ACQCAEMgEAIgxCAFkEQCAHIAw3AwAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQhqIQcgBEECaiEEIAUgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBRC/FCACQZgBaiEDIAEoAhAhBANAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAEIA6nIAynaiIBQQF0ajIBACIMQgBZBEAgByABQQN0aiAMNwMADAELIAJBGGogAkEsahCGPSABQQN2IgUgAigCHCIISQRAIAIoAhggBWoiBSAFLQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBSAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIFEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIEKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBRDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACAEIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAFENkdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALtQsCCn8DfiMAQcABayICJAAgAUEMahDbPCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAXQiBSEDAkAgBUE+cSIHBEAgBSAHa0FAayIDIAVJDQELQcAAIQcgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiB0UNAQsgAkEANgJQIAIgBzYCSCACIAM2AkQgAkHAADYCQCAFBEAgBQRAIAdBACAF/AsACyACKAJQIQsgAigCSCEHCyACIAU2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQVBACEGQQAhAwNAAkAgBSgCACIBQf//A00EQCAHIAE7AQAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQJqIQcgBUEEaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQJ0aigCACIEQf//A00EQCAHIAFBAXRqIAQ7AQAMAQsgAkEYaiACQSxqEIY9IAFBA3YiBCACKAIcIghJBEAgAigCGCAEaiIEIAQtAABBfiABQQdxd3E6AAAgBkEBaiEGDAELCyAEIAhBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAMQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAYQoz0AC0HAACADEKM9AAsgAkHYAGogAkEsaiIHEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEIIAIoAkwhAyABIAJBgAFqIgUpAgA3AwAgAikDQCEMIAIgAikCeDcDQCACQQA2AlAgAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAg2AnggAkEIaiAEENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDhGSAJIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBjYCjAEgACABIAQQzR0gAkFAaxDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuxCwIKfwN+IwBBwAFrIgIkACABQQxqENk8IQQCQAJAAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEgaiADENw7IAMoAhQhBiADKAIMIQggAigCJCEKIAIoAiAhCSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogCCAEIAhqIAkgChC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiBkHA////A3FBQGsgBiAGQT9xGyIGQcAAENE0RQ0EIAYEQCAGQcAAEK02IgVFDQILIAJCADcCOCACIAU2AjQgAiAGNgIwIAJBwAA2AiwgAkEsaiAEEN4QQQAhBgsgBEECdCIFIQMCQCAFQTxxIgcEQCAFIAdrQUBrIgMgBUkNAQtBwAAhByADQcAAENE0BEACQCADBEAgA0HAABCtNiIHRQ0BCyACQQA2AlAgAiAHNgJIIAIgAzYCRCACQcAANgJAIAUEQCAFBEAgB0EAIAX8CwALIAIoAlAhCyACKAJIIQcLIAIgBTYCTCACIAQgC2o2AlACQAJAIAYEQCAEIAZHDQEgBCEGDAgLIARFBEBBACEGDAgLIAEoAhAhBUEAIQZBACEDA0ACQCAFLgEAIgFBAE4EQCAHIAE2AgAMAQsgAkEQaiACQSxqEIY9IANBA3YiASACKAIUIghPDQMgAigCECABaiIBIAEtAABBfiADQQdxd3E6AAAgBkEBaiEGCyAHQQRqIQcgBUECaiEFIAQgA0EBaiIDRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAFIA6nIAynaiIBQQF0ai4BACIEQQBOBEAgByABQQJ0aiAENgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgASAIQYiL/wAQwyEAC0HAACADEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQMgASACQYABaiIFKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALxAwCCH8EfiMAQfABayIDJAAgAUEMahDcPCEHIANBCGogARCSNhDuJSAHQQR0IgQhBQJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEFIAIoAgghBCACKAIAIQcgASgCECEIA0ACQCADKQNoIgxQRQRAIAMpA3AhCwwBCwNAAn4CQCADKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgAyALUK1CAYY3A1AgC6dBAXFFDQAgAyADKQNYNwPYAQwBCyADKAJgRQ0BIANB0AFqIAUQtiogAykD0AEhCwsgC0IAUg0CCyADQgM3A1ALIAMpA0AiC0ICUQ0JIANCADcDQCADKQNIDAELIAMpA9gBCyEMIAunQQFxRQ0HIAMgAykDcEJAfSILNwNwIAMgDDcDaCAMUA0ACwsgAyAMQgEgDHoiDYaFNwNoIANB0AFqIgkgByAIIA2nIAunaiIKQQV0aiIBKQMAIgsgASkDCCIMIAEpAxAiDSABKQMYIg4QoQogAygC0AFBAXFFBEAgAigCBCEBIAMgDjcDqAEgAyANNwOgASADIAw3A5gBIAMgCzcDkAEgA0HMkf8ANgK4ASADQgQ3AsQBIANBgww2AuwBIANB9As2AuQBIAMgAUEBajYC4AEgA0G7BzYC3AEgAyABNgLYASADQcwBNgLUASADQaCR/wA2AtABIAMgCTYCwAEgAyADQZABajYC6AEgA0EENgK8ASADQYABaiADQbgBahCZDiADKQKAASELIAMpAogBIQwMBwsgA0HQAWogAykD4AEiCyADKQPoASIMIAQtAAAQrQ4gAygC0AEiAUGTgICAeEcEQCADKQLcASEMIAMpAtQBIQsMCAUgBiAKQQR0aiIBIAw3AwggASALNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEEQQAhBQNAIANBQGsiCiAJIAQpAwAiCyAEKQMIIgwgBEEQaikDACINIARBGGopAwAiDhChCiADKAJAQQFxRQRAIAIoAgQhASADIA43A+gBIAMgDTcD4AEgAyAMNwPYASADIAs3A9ABIANBzJH/ADYCkAEgA0IENwKcASADQYMMNgJcIANB9As2AlQgAyABQQFqNgJQIANBuwc2AkwgAyABNgJIIANBzAE2AkQgA0Ggkf8ANgJAIAMgCjYCmAEgAyADQdABajYCWCADQQQ2ApQBIANBvAFqIANBkAFqEJkOIAMpArwBIQsgAykCxAEhDAwDCyADQUBrIAMpA1AiCyADKQNYIgwgCC0AABCtDiADKAJAIgFBk4CAgHhHBEAgAykCTCEMIAMpAkQhCwwECyAGIAs3AwAgBiAMNwMIIAZBEGohBiAEQSBqIQQgByAFQQFqIgVHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQQgAygCLCEFIAEgA0HIAGoiBikCADcDACADKQMgIQsgAyADKQJANwMgIANBADYCMCADIAs3AkwgA0EANgJIIAMgBTYCRCADIAQ2AkAgAyACENc7IAMoAgAhBEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBikCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAFNgLYASADIAQ2AtQBIAMgATYC0AEgA0E0aiIBIANB0AFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNAIAAgASACEMsdIANBIGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghAQsgACAMNwIQIAAgCzcCCCAAIAE2AgQgAEEpOgAAIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQfABaiQAC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAggATYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBBGohCCAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnQiBGooAgAiB0EATgRAIAQgCGogBzYCAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBC/HSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUuAQAiAUEATgRAIAggATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBAmohCCAFQQJqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAXQiBGouAQAiB0EATgRAIAQgCGogBzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDNHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQF0IgUhAwJAIAVBPnEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUuAQAiAUEATgRAIAggATsBAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBAmohCCAFQQJqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAXQiBGouAQAiB0EATgRAIAQgCGogBzsBAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOEZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDaHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2zwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQJ0IgUhAwJAIAVBPHEiCARAIAUgCGtBQGsiAyAFSQ0BC0HAACEIIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IghFDQELIAJBADYCUCACIAg2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAIQQAgBfwLAAsgAigCUCELIAIoAkghCAsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUoAgAiAUEATgRAIAggATYCAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiB08NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAhBBGohCCAFQQRqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogByAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBAnQiBGooAgAiB0EATgRAIAQgCGogBzYCAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiB0kEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgB0GIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOUZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDHHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUpAwAiDEIAWQRAIAcgDDcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAFQQhqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBA3QiBGopAwAiDEIAWQRAIAQgB2ogDDcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDWHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC7ALAgp/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhCCACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAIIAQgCGogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIGQcD///8DcUFAayAGIAZBP3EbIgZBwAAQ0TRFDQQgBgRAIAZBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAY2AjAgAkHAADYCLCACQSxqIAQQ3hBBACEGCyAEQQN0IgUhAwJAIAVBOHEiBwRAIAUgB2tBQGsiAyAFSQ0BC0HAACEHIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgdFDQELIAJBADYCUCACIAc2AkggAiADNgJEIAJBwAA2AkAgBQRAIAUEQCAHQQAgBfwLAAsgAigCUCELIAIoAkghBwsgAiAFNgJMIAIgBCALajYCUAJAAkAgBgRAIAQgBkcNASAEIQYMCAsgBEUEQEEAIQYMCAsgASgCECEFQQAhBkEAIQMDQAJAIAUpAwAiDEIAWQRAIAcgDDcDAAwBCyACQRBqIAJBLGoQhj0gA0EDdiIBIAIoAhQiCE8NAyACKAIQIAFqIgEgAS0AAEF+IANBB3F3cToAACAGQQFqIQYLIAdBCGohByAFQQhqIQUgBCADQQFqIgNHDQALDAcLIAkEQCACQfgAaiAJIAogCCAEEL8UIAJBmAFqIQMgASgCECEFA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAUgDqcgDKdqIgFBA3QiBGopAwAiDEIAWQRAIAQgB2ogDDcDAAwBCyACQRhqIAJBLGoQhj0gAUEDdiIEIAIoAhwiCEkEQCACKAIYIARqIgQgBC0AAEF+IAFBB3F3cToAACAGQQFqIQYMAQsLIAQgCEGIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgAxCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBhCjPQALQcAAIAMQoz0ACyACQdgAaiACQSxqIgcQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQggAigCTCEDIAEgAkGAAWoiBSkCADcDACACKQNAIQwgAiACKQJ4NwNAIAJBADYCUCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgCDYCeCACQQhqIAQQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOQZIAkgAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiAGNgKMASAAIAEgBBDZHSACQUBrEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC5kLAgl/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKQMAIgtCgAF8Qv8BWARAIAMgCGogCzwAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKQMAIgtCgAF8Qv8BWARAIAEgCGogCzwAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIEIAIoAhQiBkkEQCACKAIQIARqIgQgBC0AAEF+IAFBB3F3cToAACAFQQFqIQUMAQsLIAQgBkGIi/8AEMMhAAtBxIr/ABCyOwALIAYgB0GIi/8AEMMhAAsMAwtB1Ir/AEEjQfiK/wAQyyQACyACQdgAaiACQSxqIggQghQgAkH4AGoiBBCXKSACQcgAaiIBKAIAIQcgAigCTCEDIAEgAkGAAWoiBikCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiADNgJ8IAIgBzYCeCACQQhqIAQQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAGKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAM2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgBiACQeAAaikCADcDACACIAIpAlg3A3ggAiAFNgKMASAAIAEgBBDYHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAu3CwIJfwN+IwBBwAFrIgIkACABQQxqENs8IQMCQAJAAkACQAJAIAEQkjYiBARAQcAAIQUgAkEgaiAEENw7IAQoAhQhBiAEKAIMIQcgAigCJCEKIAIoAiAhCSADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgBDYCMCACQcAANgIsIAJBLGogByADIAdqIAkgChC/GAwBC0HAACEGIANBA3YgA0EHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0EIAUEQCAFQcAAEK02IgZFDQILIAJCADcCOCACIAY2AjQgAiAFNgIwIAJBwAA2AiwgAkEsaiADEN4QQQAhBgsgAyEEAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQtBACEFIAJBADYCUCACIAg2AkggAiAENgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAGDQEMCgsgAwRAIAhBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghCCAGRQ0BCyADIAZHDQEgAyEFDAgLIAEoAhAhAUEAIQQDQAJAIAEoAgAiBkGAAWpB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUEEaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUECdGooAgAiA0GAAWpB/wFNBEAgASAIaiADOgAADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIGSQRAIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgAyAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAFEKM9AAtBwAAgBBCjPQALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIDEJcpIAJByABqIgEoAgAhByACKAJMIQQgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAHNgJ4IAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBDYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASADENgdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAXQiAyEHAkAgA0E+cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHaiwAACIDQQBOBEAgBSADOwEADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUECaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBaiwAACIEQQBOBEAgBSABQQF0aiAEOwEADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4RkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEM0dIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBAnQiAyEHAkAgA0E8cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHaiwAACIDQQBOBEAgBSADNgIADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUEEaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBaiwAACIEQQBOBEAgBSABQQJ0aiAENgIADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5RkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEEMcdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALqgsCCn8DfiMAQcABayICJAAgAUEMaigCCCEEAkACQAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEIIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAggBCAIaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgZBwP///wNxQUBrIAYgBkE/cRsiBkHAABDRNEUNBCAGBEAgBkHAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgBjYCMCACQcAANgIsIAJBLGogBBDeEEEAIQYLIARBA3QiAyEHAkAgA0E4cSIFBEAgAyAFa0FAayIHIANJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgAkEANgJQIAIgBTYCSCACIAc2AkQgAkHAADYCQCADBEAgAwRAIAVBACAD/AsACyACKAJQIQsgAigCSCEFCyACIAM2AkwgAiAEIAtqNgJQAkACQCAGBEAgBCAGRw0BIAQhBgwICyAERQRAQQAhBgwICyABKAIQIQdBACEGQQAhAQNAAkAgASAHajAAACIMQgBZBEAgBSAMNwMADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIITw0DIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAZBAWohBgsgBUEIaiEFIAQgAUEBaiIBRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggBBC/FCACQZgBaiEDIAEoAhAhBwNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiADELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASAHIA6nIAynaiIBajAAACIMQgBZBEAgBSABQQN0aiAMNwMADAELIAJBGGogAkEsahCGPSABQQN2IgQgAigCHCIISQRAIAIoAhggBGoiBCAELQAAQX4gAUEHcXdxOgAAIAZBAWohBgwBCwsgBCAIQYiL/wAQwyEAC0HEiv8AELI7AAsgAyAIQYiL/wAQwyEAC0HAACAHEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAGEKM9AAtBwAAgAxCjPQALIAJB2ABqIAJBLGoiBxCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhCCACKAJMIQUgASACQYABaiIDKQIANwMAIAIpA0AhDCACIAIpAng3A0AgAkEANgJQIAIgDDcChAEgAkEANgKAASACIAU2AnwgAiAINgJ4IAJBCGogBBDXOyACKAIIIQhBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBTYCuAEgAiAINgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ5BkgCSACQegAaigCADYCACADIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAY2AowBIAAgASAEENkdIAJBQGsQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALhgwCEX8EfSMAQcAiayIHJAAgACAAKAIUIg8gACgCJCIIIAggD0kbIgw2AiQCQAJAAkACQAJAAkACQCAAKAIcIghFBEAgASgCDEUNASABKAIIIAw2AgAgASgCBEUNAiABKAIAQQA6AAAgA0UNAyAHQQhqIAJBoAQgACgCEBCBESAHKgIIIRcgBygCDCEJQQEhBiAAQQE2AhwgASABKAIQQQFqNgIQIAAgACgCKEEBaiIINgIoIAAgCbMiGCAXIBcgGF0bIhc4AgwgACAXOAIIIAQoAgAgCEsEQCADIAhNDQUgAiAIQYgRbGoiAkEAQYQR/AsAIAJBo+D/+wc2AoQRCyAAQQA2AiQMBwsgDA0EDAULQQBBAEG87cwAEMMhAAtBAEEAQcztzAAQwyEAC0EAQQBB3O3MABDDIQALIAggA0Hs7cwAEMMhAAsCQAJAAkACQAJAAkACQAJAAkACQAJAIAMgACgCKCIQSwRAIAdBGGogAiAQQYgRbGoiC0GgBCAAKAIQIhQQgREgByoCGCEXIAcoAhxBAEUEQCAHQSBqIAtBiBH8CgAACyAHQagRaiEKIAZFBEAgCiALQYgR/AoAAAsgB0EANgK0IiAHQQA2ArAiIAdBADYCvCIgB0EANgK4IrMiGCAXIBcgGF0bIRcgAEEIaiERIAdBvCJqIRIgB0G0ImohEyAHQSBqIQlBASENAkADQCAAIAZBAnQiDmooAgAiBiADTw0BIAkgAiAGQYgRbGoiFSgCgBEgCSgCgBFqNgKAEUEAIQYDQCAGIAlqIhYgBiAVaigCACAWKAIAajYCACAGQQRqIgZBgBFHDQALIAdBEGogCUGgBCAUEIERIBMgBygCFLMiGCAHKgIQIhkgGCAZXhsiGDgCACASIBggF5MgDiARaioCAJM4AgBBASEGIA0gB0G4ImohEiAHQbAiaiETQQAhDSAKIQkNAAsgByoCvCIhGCAHKgK4IiEZAkACQCABKAIQIglB/wFLDQAgGCAAKgIYIhpeRQ0AIBkgGl4NAQsgASgCDCEGIBkgGEMAAKDBkl1FBEAgCEEBayIKIAZPDQQgASgCCCAKQQJ0aiIGIAYoAgAgDGo2AgAgACgCACIGIANPDQUgAiAGQYgRbGogB0EgakGIEfwKAAAgESAHKgK0IiIXOAIAIAlBAUYEQCAAIBc4AgwLIABBADYCJCALQQBBhBH8CwAgC0Gj4P/7BzYChBEgACAAKAIsQQFqIgI2AiwgAkECSQ0PIAAgACgCICAPajYCIAwPCyAGIAhNDQcgASgCCCAIQQJ0aiAMNgIAIAhBAmsiCSABKAIEIgZPDQggBiAITQ0FIAEoAgAhDSAAKAIAIQ4gACAAKAIEIgY2AgAgACAONgIEIAggDWogCSANai0AADoAACADIAZNDQYgAiAGQYgRbGogCkGIEfwKAAAgAEEANgIkIAAgCEEBaiIGNgIcIAAgACoCCDgCDCAAIAcqArAiOAIIIAtBAEGEEfwLACAAQQA2AiwgC0Gj4P/7BzYChBEMDQsgCCABKAIMIgZPDQggASgCCCAIQQJ0aiAMNgIAIAggASgCBCIGTw0JIAAoAgAhBiAAIAk2AgAgACAGNgIEIAAqAgghGCAAIBc4AgggACAYOAIMIAAgCEEBaiIGNgIcIAEgCUEBajYCECAAIBBBAWoiCjYCKCABKAIAIAhqIAk6AAAgCiAEKAIATw0LIAMgCksNCiAKIANBjO/MABDDIQALIAYgA0Gc78wAEMMhAAsgECADQfztzAAQwyEACyAKIAZBjO7MABDDIQALIAYgA0Gc7swAEMMhAAsgCCAGQczuzAAQwyEACyAGIANB3O7MABDDIQALIAggBkGs7swAEMMhAAsgCSAGQbzuzAAQwyEACyAIIAZB7O7MABDDIQALIAggBkH87swAEMMhAAsgAiAKQYgRbGoiAkEAQYQR/AsAIAJBo+D/+wc2AoQRCyAAQQA2AiwgAEEANgIkCyAAIA82AiAMAQsgCCEGCyAFBEAgASAGNgIUIAQgASgCEDYCAAsgB0HAImokAAuGDAIRfwR9IwBBwBBrIgckACAAIAAoAhQiDyAAKAIkIgggCCAPSRsiDDYCJAJAAkACQAJAAkACQAJAIAAoAhwiCEUEQCABKAIMRQ0BIAEoAgggDDYCACABKAIERQ0CIAEoAgBBADoAACADRQ0DIAdBCGogAkGAAiAAKAIQEIERIAcqAgghFyAHKAIMIQlBASEGIABBATYCHCABIAEoAhBBAWo2AhAgACAAKAIoQQFqIgg2AiggACAJsyIYIBcgFyAYXRsiFzgCDCAAIBc4AgggBCgCACAISwRAIAMgCE0NBSACIAhBiAhsaiICQQBBhAj8CwAgAkGj4P/7BzYChAgLIABBADYCJAwHCyAMDQQMBQtBAEEAQbztzAAQwyEAC0EAQQBBzO3MABDDIQALQQBBAEHc7cwAEMMhAAsgCCADQeztzAAQwyEACwJAAkACQAJAAkACQAJAAkACQAJAAkAgAyAAKAIoIhBLBEAgB0EYaiACIBBBiAhsaiILQYACIAAoAhAiFBCBESAHKgIYIRcgBygCHEEARQRAIAdBIGogC0GICPwKAAALIAdBqAhqIQogBkUEQCAKIAtBiAj8CgAACyAHQQA2ArQQIAdBADYCsBAgB0EANgK8ECAHQQA2ArgQsyIYIBcgFyAYXRshFyAAQQhqIREgB0G8EGohEiAHQbQQaiETIAdBIGohCUEBIQ0CQANAIAAgBkECdCIOaigCACIGIANPDQEgCSACIAZBiAhsaiIVKAKACCAJKAKACGo2AoAIQQAhBgNAIAYgCWoiFiAGIBVqKAIAIBYoAgBqNgIAIAZBBGoiBkGACEcNAAsgB0EQaiAJQYACIBQQgREgEyAHKAIUsyIYIAcqAhAiGSAYIBleGyIYOAIAIBIgGCAXkyAOIBFqKgIAkzgCAEEBIQYgDSAHQbgQaiESIAdBsBBqIRNBACENIAohCQ0ACyAHKgK8ECEYIAcqArgQIRkCQAJAIAEoAhAiCUH/AUsNACAYIAAqAhgiGl5FDQAgGSAaXg0BCyABKAIMIQYgGSAYQwAAoMGSXUUEQCAIQQFrIgogBk8NBCABKAIIIApBAnRqIgYgBigCACAMajYCACAAKAIAIgYgA08NBSACIAZBiAhsaiAHQSBqQYgI/AoAACARIAcqArQQIhc4AgAgCUEBRgRAIAAgFzgCDAsgAEEANgIkIAtBAEGECPwLACALQaPg//sHNgKECCAAIAAoAixBAWoiAjYCLCACQQJJDQ8gACAAKAIgIA9qNgIgDA8LIAYgCE0NByABKAIIIAhBAnRqIAw2AgAgCEECayIJIAEoAgQiBk8NCCAGIAhNDQUgASgCACENIAAoAgAhDiAAIAAoAgQiBjYCACAAIA42AgQgCCANaiAJIA1qLQAAOgAAIAMgBk0NBiACIAZBiAhsaiAKQYgI/AoAACAAQQA2AiQgACAIQQFqIgY2AhwgACAAKgIIOAIMIAAgByoCsBA4AgggC0EAQYQI/AsAIABBADYCLCALQaPg//sHNgKECAwNCyAIIAEoAgwiBk8NCCABKAIIIAhBAnRqIAw2AgAgCCABKAIEIgZPDQkgACgCACEGIAAgCTYCACAAIAY2AgQgACoCCCEYIAAgFzgCCCAAIBg4AgwgACAIQQFqIgY2AhwgASAJQQFqNgIQIAAgEEEBaiIKNgIoIAEoAgAgCGogCToAACAKIAQoAgBPDQsgAyAKSw0KIAogA0GM78wAEMMhAAsgBiADQZzvzAAQwyEACyAQIANB/O3MABDDIQALIAogBkGM7swAEMMhAAsgBiADQZzuzAAQwyEACyAIIAZBzO7MABDDIQALIAYgA0Hc7swAEMMhAAsgCCAGQazuzAAQwyEACyAJIAZBvO7MABDDIQALIAggBkHs7swAEMMhAAsgCCAGQfzuzAAQwyEACyACIApBiAhsaiICQQBBhAj8CwAgAkGj4P/7BzYChAgLIABBADYCLCAAQQA2AiQLIAAgDzYCIAwBCyAIIQYLIAUEQCABIAY2AhQgBCABKAIQNgIACyAHQcAQaiQAC4YMAhF/BH0jAEHALGsiByQAIAAgACgCFCIPIAAoAiQiCCAIIA9JGyIMNgIkAkACQAJAAkACQAJAAkAgACgCHCIIRQRAIAEoAgxFDQEgASgCCCAMNgIAIAEoAgRFDQIgASgCAEEAOgAAIANFDQMgB0EIaiACQcAFIAAoAhAQgREgByoCCCEXIAcoAgwhCUEBIQYgAEEBNgIcIAEgASgCEEEBajYCECAAIAAoAihBAWoiCDYCKCAAIAmzIhggFyAXIBhdGyIXOAIMIAAgFzgCCCAEKAIAIAhLBEAgAyAITQ0FIAIgCEGIFmxqIgJBAEGEFvwLACACQaPg//sHNgKEFgsgAEEANgIkDAcLIAwNBAwFC0EAQQBBvO3MABDDIQALQQBBAEHM7cwAEMMhAAtBAEEAQdztzAAQwyEACyAIIANB7O3MABDDIQALAkACQAJAAkACQAJAAkACQAJAAkACQCADIAAoAigiEEsEQCAHQRhqIAIgEEGIFmxqIgtBwAUgACgCECIUEIERIAcqAhghFyAHKAIcQQBFBEAgB0EgaiALQYgW/AoAAAsgB0GoFmohCiAGRQRAIAogC0GIFvwKAAALIAdBADYCtCwgB0EANgKwLCAHQQA2ArwsIAdBADYCuCyzIhggFyAXIBhdGyEXIABBCGohESAHQbwsaiESIAdBtCxqIRMgB0EgaiEJQQEhDQJAA0AgACAGQQJ0Ig5qKAIAIgYgA08NASAJIAIgBkGIFmxqIhUoAoAWIAkoAoAWajYCgBZBACEGA0AgBiAJaiIWIAYgFWooAgAgFigCAGo2AgAgBkEEaiIGQYAWRw0ACyAHQRBqIAlBwAUgFBCBESATIAcoAhSzIhggByoCECIZIBggGV4bIhg4AgAgEiAYIBeTIA4gEWoqAgCTOAIAQQEhBiANIAdBuCxqIRIgB0GwLGohE0EAIQ0gCiEJDQALIAcqArwsIRggByoCuCwhGQJAAkAgASgCECIJQf8BSw0AIBggACoCGCIaXkUNACAZIBpeDQELIAEoAgwhBiAZIBhDAACgwZJdRQRAIAhBAWsiCiAGTw0EIAEoAgggCkECdGoiBiAGKAIAIAxqNgIAIAAoAgAiBiADTw0FIAIgBkGIFmxqIAdBIGpBiBb8CgAAIBEgByoCtCwiFzgCACAJQQFGBEAgACAXOAIMCyAAQQA2AiQgC0EAQYQW/AsAIAtBo+D/+wc2AoQWIAAgACgCLEEBaiICNgIsIAJBAkkNDyAAIAAoAiAgD2o2AiAMDwsgBiAITQ0HIAEoAgggCEECdGogDDYCACAIQQJrIgkgASgCBCIGTw0IIAYgCE0NBSABKAIAIQ0gACgCACEOIAAgACgCBCIGNgIAIAAgDjYCBCAIIA1qIAkgDWotAAA6AAAgAyAGTQ0GIAIgBkGIFmxqIApBiBb8CgAAIABBADYCJCAAIAhBAWoiBjYCHCAAIAAqAgg4AgwgACAHKgKwLDgCCCALQQBBhBb8CwAgAEEANgIsIAtBo+D/+wc2AoQWDA0LIAggASgCDCIGTw0IIAEoAgggCEECdGogDDYCACAIIAEoAgQiBk8NCSAAKAIAIQYgACAJNgIAIAAgBjYCBCAAKgIIIRggACAXOAIIIAAgGDgCDCAAIAhBAWoiBjYCHCABIAlBAWo2AhAgACAQQQFqIgo2AiggASgCACAIaiAJOgAAIAogBCgCAE8NCyADIApLDQogCiADQYzvzAAQwyEACyAGIANBnO/MABDDIQALIBAgA0H87cwAEMMhAAsgCiAGQYzuzAAQwyEACyAGIANBnO7MABDDIQALIAggBkHM7swAEMMhAAsgBiADQdzuzAAQwyEACyAIIAZBrO7MABDDIQALIAkgBkG87swAEMMhAAsgCCAGQezuzAAQwyEACyAIIAZB/O7MABDDIQALIAIgCkGIFmxqIgJBAEGEFvwLACACQaPg//sHNgKEFgsgAEEANgIsIABBADYCJAsgACAPNgIgDAELIAghBgsgBQRAIAEgBjYCFCAEIAEoAhA2AgALIAdBwCxqJAALrwsCCX8DfiMAQcABayICJAAgAUEMahDZPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABLwEAIgZB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUECaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEBdGovAQAiA0H/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuRCwIJfwN+IwBBwAFrIgIkACABQQxqENg8IQQCQAJAAkAgARCSNiIDBEBBwAAhBSACQSBqIAMQ3DsgAygCFCEGIAMoAgwhByACKAIkIQogAigCICEJIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgVFDQMLIAJCADcCOCACIAU2AjQgAiADNgIwIAJBwAA2AiwgAkEsaiAHIAQgB2ogCSAKEL8YDAELQcAAIQUgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBUUNAgsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAQQ3hALAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEIIANBwAAQ0TQEQCADBEAgA0HAABCtNiIIRQ0EC0EAIQUgAkEANgJQIAIgCDYCSCACIAM2AkQgAkHAADYCQAJAAkACQAJAIARFBEAgAkEANgJMIAYNAQwHCyAEBEAgCEEAIAT8CwALIAIgBDYCTCACIAIoAlAgBGo2AlAgAigCSCEIIAZFDQELIAQgBkcNASAEIQUMBQsgASgCECEBQQAhAwNAAkAgASkDACILQv8BWARAIAMgCGogCzwAAAwBCyACQRhqIAJBLGoQhj0gA0EDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IANBB3F3cToAACAFQQFqIQULIAFBCGohASAEIANBAWoiA0cNAAsMBAsgCQRAIAJB+ABqIAkgCiAHIAQQvxQgAkGYAWohAyABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAMQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBA3RqKQMAIgtC/wFYBEAgASAIaiALPAAADAELIAJBEGogAkEsahCGPSABQQN2IgQgAigCFCIGSQRAIAIoAhAgBGoiBCAELQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgBCAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEACwwDC0HUiv8AQSNB+Ir/ABDLJAALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIEEJcpIAJByABqIgEoAgAhByACKAJMIQMgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAM2AnwgAiAHNgJ4IAJBCGogBBDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgAzYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASAEEMEdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC5ELAgl/A34jAEHAAWsiAiQAIAFBDGoQ2DwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBIGogAxDcOyADKAIUIQYgAygCDCEHIAIoAiQhCiACKAIgIQkgBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwI4IAIgBTYCNCACIAM2AjAgAkHAADYCLCACQSxqIAcgBCAHaiAJIAoQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AjggAiAFNgI0IAIgAzYCMCACQcAANgIsIAJBLGogBBDeEAsCQAJAIAQiA0E/cSIFBEAgAyADIAVrQUBrIgNLDQELQcAAIQggA0HAABDRNARAIAMEQCADQcAAEK02IghFDQQLQQAhBSACQQA2AlAgAiAINgJIIAIgAzYCRCACQcAANgJAAkACQAJAAkAgBEUEQCACQQA2AkwgBg0BDAcLIAQEQCAIQQAgBPwLAAsgAiAENgJMIAIgAigCUCAEajYCUCACKAJIIQggBkUNAQsgBCAGRw0BIAQhBQwFCyABKAIQIQFBACEDA0ACQCABKQMAIgtC/wBYBEAgAyAIaiALPAAADAELIAJBGGogAkEsahCGPSADQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gA0EHcXdxOgAAIAVBAWohBQsgAUEIaiEBIAQgA0EBaiIDRw0ACwwECyAJBEAgAkH4AGogCSAKIAcgBBC/FCACQZgBaiEDIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogAxC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0JIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNByACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUEDdGopAwAiC0L/AFgEQCABIAhqIAs8AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiBCACKAIUIgZJBEAgAigCECAEaiIEIAQtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyAEIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALDAMLQdSK/wBBI0H4iv8AEMskAAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgQQlykgAkHIAGoiASgCACEHIAIoAkwhAyABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgAzYCfCACIAc2AnggAkEIaiAEENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiADNgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAQQ2B0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgALrwsCCX8DfiMAQcABayICJAAgAUEMahDbPCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEFIAJBIGogBBDcOyAEKAIUIQYgBCgCDCEHIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBUUNBAsgAkIANwI4IAIgBTYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAcgAyAHaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBCAFBEAgBUHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBTYCMCACQcAANgIsIAJBLGogAxDeEEEAIQYLIAMhBAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEIIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IghFDQELQQAhBSACQQA2AlAgAiAINgJIIAIgBDYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBg0BDAoLIAMEQCAIQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQggBkUNAQsgAyAGRw0BIAMhBQwICyABKAIQIQFBACEEA0ACQCABKAIAIgZB/wFNBEAgBCAIaiAGOgAADAELIAJBGGogAkEsahCGPSAEQQN2IgYgAigCHCIHTw0DIAIoAhggBmoiBiAGLQAAQX4gBEEHcXdxOgAAIAVBAWohBQsgAUEEaiEBIAMgBEEBaiIERw0ACwwHCyAJBEAgAkH4AGogCSAKIAcgAxC/FCACQZgBaiEEIAEoAhAhByAGIQUDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBBC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgByANpyALp2oiAUECdGooAgAiA0H/AU0EQCABIAhqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgZJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBUEBaiEFDAELCyADIAZBiIv/ABDDIQALQcSK/wAQsjsACyAGIAdBiIv/ABDDIQALQcAAIAQQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAUQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIIEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEHIAIoAkwhBCABIAJBgAFqIgYpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBDYCfCACIAc2AnggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAENgK4ASACIAc2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBTYCjAEgACABIAMQwR0gAkFAaxDPLyAIEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAuvCwIJfwN+IwBBwAFrIgIkACABQQxqENs8IQMCQAJAAkACQAJAIAEQkjYiBARAQcAAIQUgAkEgaiAEENw7IAQoAhQhBiAEKAIMIQcgAigCJCEKIAIoAiAhCSADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiIFRQ0ECyACQgA3AjggAiAFNgI0IAIgBDYCMCACQcAANgIsIAJBLGogByADIAdqIAkgChC/GAwBC0HAACEGIANBA3YgA0EHcUEAR2oiBUHA////A3FBQGsgBSAFQT9xGyIFQcAAENE0RQ0EIAUEQCAFQcAAEK02IgZFDQILIAJCADcCOCACIAY2AjQgAiAFNgIwIAJBwAA2AiwgAkEsaiADEN4QQQAhBgsgAyEEAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQggBEHAABDRNARAAkAgBARAIARBwAAQrTYiCEUNAQtBACEFIAJBADYCUCACIAg2AkggAiAENgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAGDQEMCgsgAwRAIAhBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghCCAGRQ0BCyADIAZHDQEgAyEFDAgLIAEoAhAhAUEAIQQDQAJAIAEoAgAiBkH/AE0EQCAEIAhqIAY6AAAMAQsgAkEYaiACQSxqEIY9IARBA3YiBiACKAIcIgdPDQMgAigCGCAGaiIGIAYtAABBfiAEQQdxd3E6AAAgBUEBaiEFCyABQQRqIQEgAyAEQQFqIgRHDQALDAcLIAkEQCACQfgAaiAJIAogByADEL8UIAJBmAFqIQQgASgCECEHIAYhBQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiAEELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0KIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASAHIA2nIAunaiIBQQJ0aigCACIDQf8ATQRAIAEgCGogAzoAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIDIAIoAhQiBkkEQCACKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAFQQFqIQUMAQsLIAMgBkGIi/8AEMMhAAtBxIr/ABCyOwALIAYgB0GIi/8AEMMhAAtBwAAgBBCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAQQoz0ACyACQdgAaiACQSxqIggQghQgAkH4AGoiAxCXKSACQcgAaiIBKAIAIQcgAigCTCEEIAEgAkGAAWoiBikCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiAENgJ8IAIgBzYCeCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAGKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAQ2ArgBIAIgBzYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgBiACQeAAaikCADcDACACIAIpAlg3A3ggAiAFNgKMASAAIAEgAxDYHSACQUBrEM8vIAgQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC68LAgl/A34jAEHAAWsiAiQAIAFBDGoQ2TwhAwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBSACQSBqIAQQ3DsgBCgCFCEGIAQoAgwhByACKAIkIQogAigCICEJIANBA3YgA0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgVFDQQLIAJCADcCOCACIAU2AjQgAiAENgIwIAJBwAA2AiwgAkEsaiAHIAMgB2ogCSAKEL8YDAELQcAAIQYgA0EDdiADQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQQgBQRAIAVBwAAQrTYiBkUNAgsgAkIANwI4IAIgBjYCNCACIAU2AjAgAkHAADYCLCACQSxqIAMQ3hBBACEGCyADIQQCQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhCCAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIIRQ0BC0EAIQUgAkEANgJQIAIgCDYCSCACIAQ2AkQgAkHAADYCQAJAAkACQAJAIANFBEAgAkEANgJMIAYNAQwKCyADBEAgCEEAIAP8CwALIAIgAzYCTCACIAIoAlAgA2o2AlAgAigCSCEIIAZFDQELIAMgBkcNASADIQUMCAsgASgCECEBQQAhBANAAkAgAS8BACIGQf8ATQRAIAQgCGogBjoAAAwBCyACQRhqIAJBLGoQhj0gBEEDdiIGIAIoAhwiB08NAyACKAIYIAZqIgYgBi0AAEF+IARBB3F3cToAACAFQQFqIQULIAFBAmohASADIARBAWoiBEcNAAsMBwsgCQRAIAJB+ABqIAkgCiAHIAMQvxQgAkGYAWohBCABKAIQIQcgBiEFA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAQQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQogAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAcgDacgC6dqIgFBAXRqLwEAIgNB/wBNBEAgASAIaiADOgAADAELIAJBEGogAkEsahCGPSABQQN2IgMgAigCFCIGSQRAIAIoAhAgA2oiAyADLQAAQX4gAUEHcXdxOgAAIAVBAWohBQwBCwsgAyAGQYiL/wAQwyEAC0HEiv8AELI7AAsgBiAHQYiL/wAQwyEAC0HAACAEEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACAFEKM9AAtBwAAgBBCjPQALIAJB2ABqIAJBLGoiCBCCFCACQfgAaiIDEJcpIAJByABqIgEoAgAhByACKAJMIQQgASACQYABaiIGKQIANwMAIAIpA0AhCyACIAIpAng3A0AgAkEANgJQIAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAHNgJ4IAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIJKAIANgIAIAIgBDYCuAEgAiAHNgK0ASACIAE2ArABIAJB7ABqIgEgAkGwAWoQ4xkgCSACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAU2AowBIAAgASADENgdIAJBQGsQzy8gCBDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4AsBEn8jAEGQAmsiAyQAIANB2AFqIAEgAhDdECADKALgASEJIAMoAtwBIQICQCADKALYASIEQYqAgIB4RwRAIAAgAykC5AE3AgwgAEEcaiADQfQBaikCADcCACAAQRRqIANB7AFqKQIANwIAIAAgCTYCCCAAIAI2AgQgACAENgIADAELIAJBAXEEQCADQdgBaiABKAIAIgwgCRCTDiADKALcASECAkAgAygC2AEiBEGKgICAeEcEQCADQcQBaiADQfgBaigCADYCACADQbwBaiADQfABaikCADcCACADQbQBaiADQegBaikCADcCACADIAMpAuABNwKsASADIAI2AqgBIAMgBDYCpAEMAQsgA0HYAWogDEF/IAIgCWoiBCACIARLGxCHDiADKALgASEEIAMoAtwBIQIgAygC2AEiBkGKgICAeEcEQCADQcABaiADQfQBaikCADcCACADQbgBaiADQewBaikCADcCACADIAMpAuQBNwKwASADIAQ2AqwBIAMgAjYCqAEgAyAGNgKkAQwBCyAEIAJrIgZBACAEIAZPGyIEQQJ2IARBA3FBAEdqIgQEQCACQX9zIQpBACAEayEUIANBgAFqIQ4gA0H0AGohDyADQbgBaiEQIANBqAFqIREgA0HcAGohBCADQewBaiESIANB3AFqIRMgA0HMAGohCyADQdAAaiEGIANB4AFqIQgDQCADQdgBaiAMIAIQkw4gAygC3AEhBQJAIAMoAtgBIgdBioCAgHhHBEAgBiAIKQIANwIAIAZBGGogCEEYaigCADYCACAGQRBqIAhBEGopAgA3AgAgBkEIaiAIQQhqKQIANwIAIAMgBTYCTCADIAc2AkgMAQsgA0HYAWogDCAFIAogBSAKSRsgAmoQtAYgA0HQAWoiBSATQQhqKQIANwMAIAMgEykCADcDyAEgAygC2AEiB0GKgICAeEcEQCAEIBIpAgA3AgAgBEEIaiASQQhqKQIANwIAIAtBCGogBSkDADcCACALIAMpA8gBNwIAIAMgBzYCSAwBCyADQYgCaiAFKQMANwMAIAMgAykDyAE3A4ACIANBpAFqIANBgAJqQcXn/gBBA0EEEK0IIANBmAFqIgUgEUEIaikCADcDACADIBEpAgA3A5ABIAMoAqQBIgdBioCAgHhHBEAgBCAQKQIANwIAIARBCGogEEEIaikCADcCACALQQhqIAUpAwA3AgAgCyADKQOQATcCACADIAc2AkgMAQsgCCAFKQMANwMAIAMgAykDkAE3A9gBIANB7ABqIANB2AFqQcjn/gBBBUEGEK0IIAMoAnAhBSADKAJsIgdBioCAgHhHBEAgBiAPKQIANwIAIAQgDikCADcCACAGQQhqIA9BCGooAgA2AgAgBEEIaiAOQQhqKQIANwIAIAMgBTYCTCADIAc2AkgMAQsgBSAFKAIMQQFrNgIMIANBioCAgHg2AkgLIAMgAjYC4AEgAyANNgLcASADQQA2AtgBIANBJGogA0HIAGogA0HYAWoQgRQgAygCJCIFQYqAgIB4RwRAIANBwAFqIANBQGspAgA3AgAgA0G4AWogA0E4aikCADcCACADQbABaiADQTBqKQIANwIAIAMgAykCKDcCqAEgAyAFNgKkAQwDCyACQQRqIQIgCkEEayEKIBQgDUEBaiINag0ACwsgA0GKgICAeDYCpAELIANBDzYC6AEgA0GZ6P4ANgLkASADQYCAgIB4NgLgASADIAk2AtwBIANBATYC2AEgAEEEaiECIAMgA0GkAWogA0HYAWoQgRQCQCADKAIAIgRBioCAgHhHBEAgAiADKQIENwIAIAJBGGogA0EcaikCADcCACACQRBqIANBFGopAgA3AgAgAkEIaiADQQxqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgBDYCAAwBCyAAQYqAgIB4NgIAIAAgASkCADcCBCAAQQxqIAFBCGopAgA3AgALIANBkAJqJAALoQsCCn8BfiMAQZACayICJAAgASgCCCIGQQRqIQUCQCAGQXtNBEAgASgCBCIEIAVPBEAgAkGoAWoiCCABKAIAIgUgBCAGIAUgBmoiCSgAAGsQ9jQCQAJAAkACQAJAAkACQAJAIAhBDBDMIEH//wNxIgMEQCADIAZqIgNBBGohByADQXtLDQggBCAHSQ0HIAMgBWooAAAhByACQSBqIAFBBBC+FCACKAIgIgpFDQYgAigCJCELIAJB8AFqIAFBARCMASAIIAUgBCAGIAkoAABrEPY0IAhBBhDMIEH//wNxIgEEfyABIAZqIgEgBEsNDCABIAVqLQAAQQBHBUEACyEIIAMgB2oiAUEEaiEDIAFBe0sNBSADIARLDQQgAkGoAWoiAyAFIAQgASABIAVqIgcoAABrEPY0IANBBBDMIEH//wNxIgMEfiABIANqIgMgBEsNBCADIAVqKQAABUIACyEMIAJBqAFqIgMgBSAEIAEgBygAAGsQ9jQgAkEoaiAKIAsgAkHwAWogCCAMIANBCBDMICIDQf//A3EEfyABIANB//8DcWoiASAESw0MIAEgBWotAABBAEcFQQALELkWDAELIAJBGGogAUEEEL4UIAIoAhgiA0UNASACKAIcIQggAkHwAWoiByABQQEQjAEgAkGoAWoiASAFIAQgBiAJKAAAaxD2NCACQShqIAMgCCAHIAFBBhDMIEH//wNxIgEEfyABIAZqIgEgBEsNCyABIAVqLQAAQQBHBUEACxCbFAsgAkGoAWoiAUGk9v4AEKUrIAJB+ABqQbj2/gApAwA3AwAgAkGw9v4AKQMANwNwIAIgAikDsAE3A4gBIAIgAikDqAE3A4ABIAEgBSAEIAYgCSgAAGsQ9jQCQAJAAkAgAUEQEMwgQf//A3EiAUUNACABIAZqIgFBBGohBiABQXtLDQIgBCAGSQ0BIAEgBWooAAAgAWoiASAESw0MIAEgBWooAAAiCEUNACABQQRqIQYDQAJAAkACQAJAIAYiAUF7TQRAIAFBBGoiBiAESw0BIAIgASABIAVqKAAAajYCmAEgAiAENgKUASACIAU2ApABIAJBEGogAkGQAWoiA0EEEL4UIAIoAhQhASACKAIQIQkgAkEIaiADQQYQvhQgCUUNBCACKAIIIgtFDQQgAigCDCEDIAJBqAFqIAFBAEEBQQEQoBggAigCrAEhByACKAKoAUEBRg0CIAIoArABIQogAQRAIAogCSAB/AoAAAsgAiABNgL4ASACIAo2AvQBIAIgBzYC8AEgAkGoAWogA0EAQQFBARCgGCACKAKsASEBIAIoAqgBQQFGDQMgAigCsAEhCSADBEAgCSALIAP8CgAACyACIAM2ArABIAIgCTYCrAEgAiABNgKoASACQZwBaiIBIAJB8ABqIAJB8AFqIAJBqAFqEM4JIAIoApwBQYCAgIB4Rg0EIAEQ3jsMBAsgASABQQRqQfD2/gAQsTsACyABQQRqIARB8Pb+ABCwOwALIAcgAigCsAFB4Pb+ABD9LwALIAEgAigCsAFB4Pb+ABD9LwALIAhBAWsiCA0ACwsgAkGoAWoiASACQShqQcgA/AoAACACQYgCaiACQYgBaikDADcDACACQYACaiACQYABaikDADcDACACQfgBaiACQfgAaikDADcDACACIAIpA3A3A/ABIAAgASACQfABahCcJSACQZACaiQADwsgBiAEQfD2/gAQsDsACyABIAZB8Pb+ABCxOwALQaD3/gAQsjsACyADIARB9PT+ABCvOwALIAMgBEGA9/4AELA7AAsgASADQYD3/gAQsTsAC0GQ9/4AELI7AAsgByAEQfD2/gAQsDsACyADIAdB8Pb+ABCxOwALIAUgBEGA9/4AELA7AAsgBiAFQYD3/gAQsTsACyABIARB9PT+ABCvOwALnQgCBn8BfiMAQTBrIgUkAAJAAkACQCACBEAgBK0gAkEMbCIGQQxrIghBDG6tfiILQiCIUARAIAunIQogASEHA0AgBkUNAyAGQQxrIQYgCiAHKAIIIApqIgpLIAdBDGohB0UNAAsLQfTehwFBNUGs34cBEMskAAsgAEEANgIIIABCgICAgBA3AgAMAQsgBUEYaiAKQQBBAUEBEKAYIAUoAhwhBwJAIAUoAhhBAUcEQCAFQQA2AhQgBSAFKAIgNgIQIAUgBzYCDCAFQQxqIAEoAgQiByAHIAEoAghqELwmIAogBSgCFCIHayEGIAUoAhAgB2ohBwJAAkACQAJAAkACQCAEDgUEAwIBAAULIAJBAUYNBiABQRRqIQEDQCAGQQNNDQkgAUEEaygCACEJIAEoAgAhAiAHIAMoAAA2AAAgBkEEayIGIAJJDQkgB0EEaiEEIAIEQCAEIAkgAvwKAAALIAFBDGohASAGIAJrIQYgAiAEaiEHIAhBDGsiCA0ACwwGCyACQQFGDQUgAUEUaiEBA0AgBkECTQ0IIAFBBGsoAgAhCSABKAIAIQIgByADLwAAOwAAIAdBAmogA0ECai0AADoAACAGQQNrIgYgAkkNCCAHQQNqIQQgAgRAIAQgCSAC/AoAAAsgAUEMaiEBIAYgAmshBiACIARqIQcgCEEMayIIDQALDAULIAJBAUYNBCABQRRqIQEDQCAGQQFNDQcgAUEEaygCACEJIAEoAgAhAiAHIAMvAAA7AAAgBkECayIGIAJJDQcgB0ECaiEEIAIEQCAEIAkgAvwKAAALIAFBDGohASAGIAJrIQYgAiAEaiEHIAhBDGsiCA0ACwwECyACQQFGDQMgAUEUaiEBA0AgBkUNBiABQQRrKAIAIQkgASgCACECIAcgAy0AADoAACAGQQFrIgYgAkkNBiAHQQFqIQQgAgRAIAQgCSAC/AoAAAsgAUEMaiEBIAYgAmshBiACIARqIQcgCEEMayIIDQALDAMLIAJBAUYNAiABQRBqIQEDQCAGIAFBBGooAgAiAkkNBSACBEAgByABKAIAIAL8CgAACyABQQxqIQEgBiACayEGIAIgB2ohByAIQQxrIggNAAsMAgsgAkEBRg0BIAFBFGohAQNAIAQgBksNBCABQQRrKAIAIQkgASgCACECIAQEQCAHIAMgBPwKAAALIAYgBGsiBiACSQ0EIAQgB2ohByACBEAgByAJIAL8CgAACyABQQxqIQEgBiACayEGIAIgB2ohByAIQQxrIggNAAsMAQsgByAFKAIgQbzfhwEQ/S8ACyAAIAUpAgw3AgAgAEEIaiAKIAZrNgIACyAFQTBqJAAPCyAFQQA2AiggBUEBNgIcIAVB6N+HATYCGCAFQgQ3AiAgBUEYakHw34cBEO8sAAupDAIHfwN+IwBB4AFrIgQkACABQQxqENg8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohByADLQAAIQMgASgCECEIIAIoAgAiAUF/RyEJA0ACQCAEKQNwIgxQRQRAIAQpA3ghCwwBCwNAAn4CQCAEKQNYIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1ggC6dBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAcQtiogBCkDqAEhCwsgC0IAUg0CCyAEQgM3A1gLIAQpA0giC0ICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyEMIAunQQFxRQ0HIAQgBCkDeEJAfSILNwN4IAQgDDcDcCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNwIAggDacgC6dqIgpBA3RqKAIAIQUgBCABNgLcASAEIAU2ApABAkACQCABRQRAQYeAgIB4IQIMAQsgCSAFQYCAgIB4R3JFBEAgBEECNgKsASAEQZiQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAEgBCgCmAEhBUGIgICAeCECDAELIARBqAFqIAUgAW0iBSADEOoPIAQoAqgBIgJBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAEhBQsgBEGAAWohBgwHCyAGIApBAnRqIAU2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQkgASgCECEBQQAhAyACKAIAIgdBf0chCgNAIAEoAgAhBSAEIAc2AsABIAQgBTYC3AECQCAHBH8gCiAFQYCAgIB4R3INASAEQQI2AkwgBEGYkP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQVBiICAgHgFQYeAgIB4CyECIARB0AFqIQYMAwsgBEHIAGogBSAHbSIFIAkQ6g8gBCgCSCICQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiAFNgIAIAZBBGohBiABQQhqIQEgCCADQQFqIgNHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCELIAQgBCkCSDcDKCAEQQA2AjggBCALNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAI2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAALogsCCX8DfiMAQcABayICJAAgAUEMaigCCCEDAkACQAJAAkACQCABEJI2IgQEQEHAACEGIAJBIGogBBDcOyAEKAIUIQcgBCgCDCEIIAIoAiQhCiACKAIgIQkgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiBkUNBAsgAkIANwI4IAIgBjYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAggAyAIaiAJIAoQvxgMAQtBwAAhBiADQQN2IANBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBCAEBEAgBEHAABCtNiIGRQ0CCyACQgA3AjggAiAGNgI0IAIgBDYCMCACQcAANgIsIAJBLGogAxDeEAsgAyEFAkAgA0E/cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQtBACEEIAJBADYCUCACIAY2AkggAiAFNgJEIAJBwAA2AkACQAJAAkACQCADRQRAIAJBADYCTCAHDQEMCgsgAwRAIAZBACAD/AsACyACIAM2AkwgAiACKAJQIANqNgJQIAIoAkghBiAHRQ0BCyADIAdHDQEgAyEEDAgLIAEoAhAhB0EAIQUDQAJAIAUgB2osAAAiAUEATgRAIAUgBmogAToAAAwBCyACQRhqIAJBLGoQhj0gBUEDdiIBIAIoAhwiCE8NAyACKAIYIAFqIgEgAS0AAEF+IAVBB3F3cToAACAEQQFqIQQLIAMgBUEBaiIFRw0ACwwHCyAJBEAgAkH4AGogCSAKIAggAxC/FCACQZgBaiEFIAEoAhAhCCAHIQQDQAJAIAIpA6ABIgxQRQRAIAIpA6gBIQsMAQsDQAJ+AkAgAikDiAEiC0IDUgRAAkACQAJAIAtCAlENACACIAtQrUIBhjcDiAEgC6dBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogBRC2KiACKQOwASELCyALQgBSDQILIAJCAzcDiAELIAIpA3giC0ICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDCALp0EBcUUNCiACIAIpA6gBQkB9Igs3A6gBIAIgDDcDoAEgDFANAAsLIAIgDEIBIAx6Ig2GhTcDoAEgCCANpyALp2oiAWosAAAiA0EATgRAIAEgBmogAzoAAAwBCyACQRBqIAJBLGoQhj0gAUEDdiIDIAIoAhQiB0kEQCACKAIQIANqIgMgAy0AAEF+IAFBB3F3cToAACAEQQFqIQQMAQsLIAMgB0GIi/8AEMMhAAtBxIr/ABCyOwALIAEgCEGIi/8AEMMhAAtBwAAgBRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgBBCjPQALQcAAIAQQoz0ACyACQdgAaiACQSxqIgYQghQgAkH4AGoiAxCXKSACQcgAaiIBKAIAIQggAigCTCEFIAEgAkGAAWoiBykCADcDACACKQNAIQsgAiACKQJ4NwNAIAJBADYCUCACIAs3AoQBIAJBADYCgAEgAiAFNgJ8IAIgCDYCeCACQQhqIAMQ1zsgAigCCCEIQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAHKQIANwIAIAFBGGogAkGIAWoiCSgCADYCACACIAU2ArgBIAIgCDYCtAEgAiABNgKwASACQewAaiIBIAJBsAFqEOMZIAkgAkHoAGooAgA2AgAgByACQeAAaikCADcDACACIAIpAlg3A3ggAiAENgKMASAAIAEgAxDBHSACQUBrEM8vIAYQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC6ILAgl/A34jAEHAAWsiAiQAIAFBDGooAgghAwJAAkACQAJAAkAgARCSNiIEBEBBwAAhBiACQSBqIAQQ3DsgBCgCFCEHIAQoAgwhCCACKAIkIQogAigCICEJIANBA3YgA0EHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgZFDQQLIAJCADcCOCACIAY2AjQgAiAENgIwIAJBwAA2AiwgAkEsaiAIIAMgCGogCSAKEL8YDAELQcAAIQYgA0EDdiADQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQQgBARAIARBwAAQrTYiBkUNAgsgAkIANwI4IAIgBjYCNCACIAQ2AjAgAkHAADYCLCACQSxqIAMQ3hALIAMhBQJAIANBP3EiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELQQAhBCACQQA2AlAgAiAGNgJIIAIgBTYCRCACQcAANgJAAkACQAJAAkAgA0UEQCACQQA2AkwgBw0BDAoLIAMEQCAGQQAgA/wLAAsgAiADNgJMIAIgAigCUCADajYCUCACKAJIIQYgB0UNAQsgAyAHRw0BIAMhBAwICyABKAIQIQdBACEFA0ACQCAFIAdqLAAAIgFBAE4EQCAFIAZqIAE6AAAMAQsgAkEYaiACQSxqEIY9IAVBA3YiASACKAIcIghPDQMgAigCGCABaiIBIAEtAABBfiAFQQdxd3E6AAAgBEEBaiEECyADIAVBAWoiBUcNAAsMBwsgCQRAIAJB+ABqIAkgCiAIIAMQvxQgAkGYAWohBSABKAIQIQggByEEA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAUQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQogAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAggDacgC6dqIgFqLAAAIgNBAE4EQCABIAZqIAM6AAAMAQsgAkEQaiACQSxqEIY9IAFBA3YiAyACKAIUIgdJBEAgAigCECADaiIDIAMtAABBfiABQQdxd3E6AAAgBEEBaiEEDAELCyADIAdBiIv/ABDDIQALQcSK/wAQsjsACyABIAhBiIv/ABDDIQALQcAAIAUQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAQQoz0AC0HAACAEEKM9AAsgAkHYAGogAkEsaiIGEIIUIAJB+ABqIgMQlykgAkHIAGoiASgCACEIIAIoAkwhBSABIAJBgAFqIgcpAgA3AwAgAikDQCELIAIgAikCeDcDQCACQQA2AlAgAiALNwKEASACQQA2AoABIAIgBTYCfCACIAg2AnggAkEIaiADENc7IAIoAgghCEEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBykCADcCACABQRhqIAJBiAFqIgkoAgA2AgAgAiAFNgK4ASACIAg2ArQBIAIgATYCsAEgAkHsAGoiASACQbABahDjGSAJIAJB6ABqKAIANgIAIAcgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBDYCjAEgACABIAMQ2B0gAkFAaxDPLyAGEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAumDAIHfwN+IwBB4AFrIgQkACABQQxqENs8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohByADLQAAIQMgASgCECEIIAIoAgAiAUF/RyEJA0ACQCAEKQNwIgxQRQRAIAQpA3ghCwwBCwNAAn4CQCAEKQNYIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1ggC6dBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAcQtiogBCkDqAEhCwsgC0IAUg0CCyAEQgM3A1gLIAQpA0giC0ICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyEMIAunQQFxRQ0HIAQgBCkDeEJAfSILNwN4IAQgDDcDcCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNwIAggDacgC6dqQQJ0IgpqKAIAIQUgBCABNgLcASAEIAU2ApABAkACQCABRQRAQYeAgIB4IQIMAQsgCSAFQYCAgIB4R3JFBEAgBEECNgKsASAEQZiQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAEgBCgCmAEhBUGIgICAeCECDAELIARBqAFqIAUgAW0iBSADEOoPIAQoAqgBIgJBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAEhBQsgBEGAAWohBgwHCyAGIApqIAU2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQkgASgCECEBQQAhAyACKAIAIgdBf0chCgNAIAEoAgAhBSAEIAc2AsABIAQgBTYC3AECQCAHBH8gCiAFQYCAgIB4R3INASAEQQI2AkwgBEGYkP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQVBiICAgHgFQYeAgIB4CyECIARB0AFqIQYMAwsgBEHIAGogBSAHbSIFIAkQ6g8gBCgCSCICQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiAFNgIAIAZBBGohBiABQQRqIQEgCCADQQFqIgNHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCELIAQgBCkCSDcDKCAEQQA2AjggBCALNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAI2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAAL7AsCCH8BfiMAQSBrIgQkACABQQxqIQggAUEYaiEJIAFBLmohBSABQSxqIQYgAS0ALCEDA0ACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQf8BcUEBaw4GAAEGBQIKAwsgAS0AOEEEcUUNCCABLQAtIgNBAU0NBwwRCyABKAIAQYCAgIB4RiIKRQRAIAEoAggiByABLwEuIgNLDQYMDwtB1MXQABCyOwALIAEoAjBFDQogAS0ALSIDQQFNDQEMCQsgAS0ALSIDQQlLDQcDQCAEQQhqIAIgBSADQf8BcSIDakEKIANrEIsZAkAgBC0ACEEERgRAIAQoAgwhAwwBCyAEKQMIIgtC/wGDQgRRBEAgC0IgiKchAwwBCyAAIAs3AgAMDQsgASABLQAtIANqIgM6AC0gA0H/AXFBCkkNAAsMBwsDQCAEQQhqIAIgBSADQf8BcSIDakECIANrEIsZAkAgBC0ACEEERgRAIAQoAgwhAwwBCyAEKQMIIgtC/wGDQgRRBEAgC0IgiKchAwwBCyAAIAs3AgAMDAsgASABLQAtIANqIgM6AC0gA0H/AXFBAkkNAAsMBwsCQCABLQA4QRBxRQ0AIAkoAgBBgICAgHhGBEAgCRCGMCABQQA2AiAgAUKAgICAEDcCGAsgBEEIaiACIAkQzxUCQCAELQAIQQRGDQAgBCkDCCILQv8Bg0IEUQ0AIAAgCzcCAAwLCyABKAIwIgNFDQAgAyABKAIcIAEoAiAQgzEgASgCMEHMtMIAQQEQgzELIAEoAjAhAyABQQA2AjAgBhDdLSABIAM2AjBBBSEDIAFBBTYCLAwNCwJAIAEtADhBCHFFDQAgCCgCAEGAgICAeEYEQCAIEIYwIAFBADYCFCABQoCAgIAQNwIMCyAEQQhqIAIgCBDPFQJAIAQtAAhBBEYNACAEKQMIIgtC/wGDQgRRDQAgACALNwIADAoLIAEoAjAiA0UNACADIAEoAhAgASgCFBCDMSABKAIwQcy0wgBBARCDMQsgASgCMCEDIAFBADYCMCAGEN0tIAEgAzYCMEEEIQMgAUEEOgAsDAwLA0AgBEEIaiACIAEoAgQgA2ogByADaxCLGQJAIAQtAAhBBEYEQCAEKAIMIQMMAQsgBCkDCCILQv8Bg0IEUQRAIAtCIIinIQMMAQsgACALNwIADAkLIAEgAS8BLiADaiIDOwEuIAEoAggiByADQf//A3EiA0sNAAsMCAsDQAJAIARBCGogAiAFIANB/wFxIgNqQQIgA2sQixkgAQJ/IAQtAAhBBEYEQCAEKAIMDAELIAQpAwgiC0L/AYNCBFINASALQiCIpwsgAS0ALWoiAzoALSADQf8BcUECSQ0BDAsLCyAAIAs3AgAMBgsgASgCMAwHCyAAQQQ6AAAMBAsCQCABLQAuQR9HDQAgAS0AL0GLAUcNACABLQAwQQhHDQAgASABLQAxIgc6ADggB0EgTw0AIAEgASgBMjYCJCABIAEtADc6AChBACEDAkAgB0ECcQRAIARBCGoQjytBGEEIEK02IgNFDQEgAyAEKQMINwMAIANBEGogBEEYaikDADcDACADQQhqIARBEGopAwA3AwAgAyAFQQoQgzELIAYQ3S0gASADNgIwQQEhAyABQQE2AiwMCQtBCEEYEKM9AAsgAEGgvvsAQRMQyxoMAwsgBS8AACABKAIwEIU7Qf//A3FHDQELIAYQ3S1BBiEDIAZBBjoAAAwFCyAAEIc7CyAEQSBqJAAPCyABKAIwIgMEfyADQQAgASAKGygCBCAHEIMxIAEoAjAFQQALCyEDIAFBADYCMCAGEN0tIAEgAzYCMEEDIQMgAUEDOgAsDAELIAEoAjAiAwRAIAMgBUECEIMxCyAEQQhqIAUvAABBxMXQABDOGCABEIYwIAFBCGogBEEQaigCADYCACABIAQpAgg3AgAgASgCMCEDIAFBADYCMCAGEN0tIAEgAzYCMCABQQA7AS5BAiEDIAFBAjoALAwACwALxgoBCX8jAEEwayIKJAACQCABKAIAQQFHDQAgASgCBCEEAkACQAJAAkACQCABKAIIQQFGBEAgBCABKAIUIgNPDQYgASgCECIGIARBAXRqLwAAIAJB//8DcUcNAyABKAIMIQUgAUEBNgIAIAEgBEEBaiICNgIEIAUNASABQQA2AgggAiADTw0GQQEhCSAGIAJBAXRqLwAAQcAASQ0GIApBCGogASACEK4PIAooAgwhBSAKKAIIIQkMBgsgBCABKAIUIgdPDQUgBEEBaiEGIAEoAhAiCCAEQQF0ai8AACIEQTBJDQEgBEE/cSIFQTBJIQsCQANAIARB//8DcSIDQcAASQ0BIATBQQBIDQQCQCADQcCAAUkNACADQcD/AU8EQCAGQQJqIQYMAQsgBkEBaiEGCyAFIQQgC0UNAAsMAgsgBiAHTw0FIAggBkEBdGovAAAgAkH//wNxRw0CIAZBAWohAiAEQf//A3FBMEYEQCABIAI2AgQgAUEBNgIAIAFBADYCCCACIAdPDQZBASEJIAggAkEBdGovAABBwABJDQYgCkEoaiABIAIQrg8gCigCLCEFIAooAighCQwGC0EBIQkgAUEBNgIIIAEgAjYCBCABQQE2AgAgASAEQf//A3FBMWs2AgwMBQtBASEJIAFBATYCCCABIAVBAWs2AgwMBAsgBAR/IAYFIAYgB08NBCAIIAZBAXRqLwAAIQQgBkEBagshAyAEQf//A3EiBUEBaiEEIAVBBU8EQCACQf//A3EhCwNAIAMgB08NBSADQQFqIQUCfyAIIANBAXRqLwAAIAtNBEAgBSAHTw0HQQJBBEEDIAggBUEBdGovAAAiBUH//wNGGyAFQYD4A0kbIANqIQMgBCAEQQF2awwBCyAFIAdPDQYCfyAIIAVBAXRqLwAAIgVBgPgDTwRAIANBAmohBiAFQf//A0cEQCAGIAdPDQkgCCAGQQF0ai8AACAFQRB0IANqakGDgIAgagwCCyAGIAdPDQggA0EDaiIFIAdPDQggCCAFQQF0ai8AACADIAggBkEBdGovAABBEHRqakEEagwBCyADIAVqQQJqCyEDIARBAXYLIgRBBUsNAAsLIAJB//8DcSELA0AgAyAHTw0EIANBAWohBiALIAggA0EBdGovAABGDQMgBiAHTw0EAn8gA0ECaiAIIAZBAXRqLwAAQf//AXEiBUGAgAFJDQAaIANBBGogBUH//wFGDQAaIANBA2oLIQMgBEEBayIEQQFLDQALIAMgB08NAyAIIANBAXRqLwAAIAJB//8DcUYNAQsgAUEANgIADAILIAFBATYCACABIANBAWoiAjYCBCACIAdPDQFBASEJIAggAkEBdGovAABBwABJDQEgCkEgaiABIAIQrg8gCigCJCEFIAooAiAhCQwBCyAGIAdPDQACQCAHAn8CQCAIIAZBAXRqLgAAIgRBAE4EQCADQQJqIQIgBEGAgAFJDQEgBEH//wFGBEAgAiAHTw0FIANBA2oiBCAHTw0FIAMgCCAEQQF0ai8AACAIIAJBAXRqLwAAQRB0cmpBBGoMAwsgAiAHTw0DIAggAkEBdGovAAAgBEEQdCADampB/f///wNrDAILIAEgBjYCBCABQQE2AgAgCkEYaiABIAYQrg8gCigCHCEFIAooAhghCQwDCyACIARB//8DcWoLIgNNDQAgASADNgIEQQEhCSABQQE2AgAgCCADQQF0ai8AAEHAAEkNASAKQRBqIAEgAxCuDyAKKAIUIQUgCigCECEJDAELCyAAIAU2AgQgACAJNgIAIApBMGokAAuGDAIGfwN+IwBB4AFrIgQkACABQQxqENk8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQcgAigCACECIAEoAhAhCANAAkAgBCkDcCILUEUEQCAEKQN4IQoMAQsDQAJ+AkAgBCkDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAQgClCtQgGGNwNYIAqnQQFxRQ0AIAQgBCkDYDcDsAEMAQsgBCgCaEUNASAEQagBaiAFELYqIAQpA6gBIQoLIApCAFINAgsgBEIDNwNYCyAEKQNIIgpCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOwAQshCyAKp0EBcUUNByAEIAQpA3hCQH0iCjcDeCAEIAs3A3AgC1ANAAsLIAQgC0IBIAt6IgyGhTcDcCAEIAggDKcgCqdqIglBAXRqLwEAIgE2ApABIAQgAjYC3AECQAJ/IAKsIAGtfiIKQiCIpyAKpyIBQR91RwRAIARBAjYCrAEgBEGskP8ANgKoASAEQgI3ArQBIARBggw2AswBIARBggw2AsQBIAQgBEHAAWo2ArABIAQgBEHcAWo2AsgBIAQgBEGQAWo2AsABIARBmAFqIARBqAFqEJkOIARBiAFqIARBpAFqKAIANgIAIAQgBCkCnAE3A4ABQYiAgIB4IQMgBCgCmAEMAQsgBEGoAWogASAHEOoPIAQoAqgBIgNBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAELIQUgBEGAAWohBgwHCyAGIAlBAnRqIAE2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgASgCECEFQQAhASACKAIAIgmsIQoDQCAEIAUvAQAiAjYC3AEgBCAJNgLAASACrSAKfiILQiCIpyALpyICQR91RwRAIARBAjYCTCAEQayQ/wA2AkggBEICNwJUIARBggw2AqABIARBggw2ApgBIAQgBEGUAWo2AlAgBCAEQcABajYCnAEgBCAEQdwBajYClAEgBEGsAWogBEHIAGoQmQ4gBEHYAWogBEG4AWooAgA2AgAgBCAEKQKwATcD0AEgBCgCrAEhBSAEQdABaiEGQYiAgIB4IQMMAwsgBEHIAGogAiAHEOoPIAQoAkgiA0GTgICAeEcEQCAEQdgBaiAEQdgAaigCADYCACAEIAQpAlA3A9ABIAQoAkwhBSAEQdABaiEGDAMLIAYgAjYCACAGQQRqIQYgBUECaiEFIAggAUEBaiIBRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBSAEKAI0IQMgASAEQdAAaiIGKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBTYCSCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAGKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAYgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAU2AgggACADNgIEIABBKToAACAAIAYpAgA3AgwgAEEUaiAGQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC4YMAgZ/A34jAEHgAWsiBCQAIAFBDGoQ2DwhCCAEQRBqIAEQkjYQ7iUgCEECdCIFIQcCQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiByAFSQ0BC0HAACEGIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgZFDQELIAQgBjYCMCAEIAc2AiwgBEHAADYCKCAFBEAgBkEAIAX8CwALIAQgCDYCOCAEIAU2AjQgBCgCEEUNAyAEKAIkIAQoAiBGDQQgBEHIAGogBEEQahDINCAEQegAaiEFIAMtAAAhByACKAIAIQIgASgCECEIA0ACQCAEKQNwIgtQRQRAIAQpA3ghCgwBCwNAAn4CQCAEKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgBCAKUK1CAYY3A1ggCqdBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAUQtiogBCkDqAEhCgsgCkIAUg0CCyAEQgM3A1gLIAQpA0giCkICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyELIAqnQQFxRQ0HIAQgBCkDeEJAfSIKNwN4IAQgCzcDcCALUA0ACwsgBCALQgEgC3oiDIaFNwNwIAQgCCAMpyAKp2oiCUEDdGooAgAiATYCkAEgBCACNgLcAQJAAn8gAawgAqx+IgpCIIinIAqnIgFBH3VHBEAgBEECNgKsASAEQayQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAFBiICAgHghAyAEKAKYAQwBCyAEQagBaiABIAcQ6g8gBCgCqAEiA0GTgICAeEYNASAEQYgBaiAEQbgBaigCADYCACAEIAQpArABNwOAASAEKAKsAQshBSAEQYABaiEGDAcLIAYgCUECdGogATYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhByABKAIQIQVBACEBIAIoAgAiCawhCgNAIAQgBSgCACICNgLcASAEIAk2AsABIAKsIAp+IgtCIIinIAunIgJBH3VHBEAgBEECNgJMIARBrJD/ADYCSCAEQgI3AlQgBEGCDDYCoAEgBEGCDDYCmAEgBCAEQZQBajYCUCAEIARBwAFqNgKcASAEIARB3AFqNgKUASAEQawBaiAEQcgAahCZDiAEQdgBaiAEQbgBaigCADYCACAEIAQpArABNwPQASAEKAKsASEFIARB0AFqIQZBiICAgHghAwwDCyAEQcgAaiACIAcQ6g8gBCgCSCIDQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEFIARB0AFqIQYMAwsgBiACNgIAIAZBBGohBiAFQQhqIQUgCCABQQFqIgFHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEFIAQoAjQhAyABIARB0ABqIgYpAgA3AwAgBCkDKCEKIAQgBCkCSDcDKCAEQQA2AjggBCAKNwJUIARBADYCUCAEIAM2AkwgBCAFNgJIIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCsAEgBCAFNgKsASAEIAE2AqgBIARBPGoiASAEQagBahDlGSAHIARBIGopAgA3AwAgBiAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDKHSAEQShqEM8vDAILQQRBHBCjPQALIAAgBTYCCCAAIAM2AgQgAEEpOgAAIAAgBikCADcCDCAAQRRqIAZBCGooAgA2AgAgBEEoahDPLyAEKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBEGoQ+x4LIARB4AFqJAALhgwCBn8DfiMAQeABayIEJAAgAUEMahDZPCEIIARBEGogARCSNhDuJSAIQQJ0IgUhBwJAAkACQAJAAkAgBUE8cSIGBEAgBSAGa0FAayIHIAVJDQELQcAAIQYgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBkUNAQsgBCAGNgIwIAQgBzYCLCAEQcAANgIoIAUEQCAGQQAgBfwLAAsgBCAINgI4IAQgBTYCNCAEKAIQRQ0DIAQoAiQgBCgCIEYNBCAEQcgAaiAEQRBqEMg0IARB6ABqIQUgAy0AACEHIAIoAgAhAiABKAIQIQgDQAJAIAQpA3AiC1BFBEAgBCkDeCEKDAELA0ACfgJAIAQpA1giCkIDUgRAAkACQAJAIApCAlENACAEIApQrUIBhjcDWCAKp0EBcUUNACAEIAQpA2A3A7ABDAELIAQoAmhFDQEgBEGoAWogBRC2KiAEKQOoASEKCyAKQgBSDQILIARCAzcDWAsgBCkDSCIKQgJRDQkgBEIANwNIIAQpA1AMAQsgBCkDsAELIQsgCqdBAXFFDQcgBCAEKQN4QkB9Igo3A3ggBCALNwNwIAtQDQALCyAEIAtCASALeiIMhoU3A3AgBCAIIAynIAqnaiIJQQF0ai4BACIBNgKQASAEIAI2AtwBAkACfyABrCACrH4iCkIgiKcgCqciAUEfdUcEQCAEQQI2AqwBIARBrJD/ADYCqAEgBEICNwK0ASAEQYIMNgLMASAEQYIMNgLEASAEIARBwAFqNgKwASAEIARB3AFqNgLIASAEIARBkAFqNgLAASAEQZgBaiAEQagBahCZDiAEQYgBaiAEQaQBaigCADYCACAEIAQpApwBNwOAAUGIgICAeCEDIAQoApgBDAELIARBqAFqIAEgBxDqDyAEKAKoASIDQZOAgIB4Rg0BIARBiAFqIARBuAFqKAIANgIAIAQgBCkCsAE3A4ABIAQoAqwBCyEFIARBgAFqIQYMBwsgBiAJQQJ0aiABNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEHIAEoAhAhBUEAIQEgAigCACIJrCEKA0AgBCAFLgEAIgI2AtwBIAQgCTYCwAEgAqwgCn4iC0IgiKcgC6ciAkEfdUcEQCAEQQI2AkwgBEGskP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQUgBEHQAWohBkGIgICAeCEDDAMLIARByABqIAIgBxDqDyAEKAJIIgNBk4CAgHhHBEAgBEHYAWogBEHYAGooAgA2AgAgBCAEKQJQNwPQASAEKAJMIQUgBEHQAWohBgwDCyAGIAI2AgAgBkEEaiEGIAVBAmohBSAIIAFBAWoiAUcNAAsLIARByABqIgIQlykgBEEwaiIBKAIAIQUgBCgCNCEDIAEgBEHQAGoiBikCADcDACAEKQMoIQogBCAEKQJINwMoIARBADYCOCAEIAo3AlQgBEEANgJQIAQgAzYCTCAEIAU2AkggBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJINwIIIAFBEGogBikCADcCACABQRhqIARB2ABqIgcoAgA2AgAgBCADNgKwASAEIAU2AqwBIAQgATYCqAEgBEE8aiIBIARBqAFqEOUZIAcgBEEgaikCADcDACAGIARBGGopAgA3AwAgBCAEKQIQNwNIIAAgASACEModIARBKGoQzy8MAgtBBEEcEKM9AAsgACAFNgIIIAAgAzYCBCAAQSk6AAAgACAGKQIANwIMIABBFGogBkEIaigCADYCACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHgAWokAAufDAIIfwR+IwBB8AFrIgMkACABQQxqENw8IQcgA0EIaiABEJI2EO4lIAdBA3QiBCEFAkACQAJAAkACQAJAIARBOHEiBgRAIAQgBmtBQGsiBSAESQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAMgBjYCKCADIAU2AiQgA0HAADYCICAEBEAgBkEAIAT8CwALIAMgBzYCMCADIAQ2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEEIAIoAgAhByABKAIQIQgDQAJAIAMpA2giDFBFBEAgAykDcCELDAELA0ACfgJAIAMpA1AiC0IDUgRAAkACQAJAIAtCAlENACADIAtQrUIBhjcDUCALp0EBcUUNACADIAMpA1g3A9gBDAELIAMoAmBFDQEgA0HQAWogBRC2KiADKQPQASELCyALQgBSDQILIANCAzcDUAsgAykDQCILQgJRDQkgA0IANwNAIAMpA0gMAQsgAykD2AELIQwgC6dBAXFFDQcgAyADKQNwQkB9Igs3A3AgAyAMNwNoIAxQDQALCyADIAxCASAMeiINhoU3A2ggA0HQAWoiCSAHIAggDacgC6dqIgpBBXRqIgEpAwAiCyABKQMIIgwgASkDECINIAEpAxgiDhCgCiADKALQAUUEQCACKAIEIQEgAyAONwOoASADIA03A6ABIAMgDDcDmAEgAyALNwOQASADQcyR/wA2ArgBIANCBDcCxAEgA0GDDDYC7AEgA0H0CzYC5AEgAyABQQFqNgLgASADQbsHNgLcASADIAE2AtgBIANBzAE2AtQBIANBoJL/ADYC0AEgAyAJNgLAASADIANBkAFqNgLoASADQQQ2ArwBIANBgAFqIANBuAFqEJkOIAMpAoABIQsgAykCiAEhDAwHCyADQdABaiADKQPYASILIAQtAAAQjRAgAygC0AEiAUGTgICAeEcEQCADKQLcASEMIAMpAtQBIQsMCAUgBiAKQQN0aiALNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQkgASgCECEEQQAhBQNAIANBQGsiCiAJIAQpAwAiCyAEKQMIIgwgBEEQaikDACINIARBGGopAwAiDhCgCiADKAJARQRAIAIoAgQhASADIA43A+gBIAMgDTcD4AEgAyAMNwPYASADIAs3A9ABIANBzJH/ADYCkAEgA0IENwKcASADQYMMNgJcIANB9As2AlQgAyABQQFqNgJQIANBuwc2AkwgAyABNgJIIANBzAE2AkQgA0Ggkv8ANgJAIAMgCjYCmAEgAyADQdABajYCWCADQQQ2ApQBIANBvAFqIANBkAFqEJkOIAMpArwBIQsgAykCxAEhDAwDCyADQUBrIAMpA0giCyAILQAAEI0QIAMoAkAiAUGTgICAeEcEQCADKQJMIQwgAykCRCELDAQLIAYgCzcDACAGQQhqIQYgBEEgaiEEIAcgBUEBaiIFRw0ACwsgA0FAayICEJcpIANBKGoiASgCACEEIAMoAiwhBSABIANByABqIgYpAgA3AwAgAykDICELIAMgAykCQDcDICADQQA2AjAgAyALNwJMIANBADYCSCADIAU2AkQgAyAENgJAIAMgAhDXOyADKAIAIQRBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBTYC2AEgAyAENgLUASADIAE2AtABIANBNGoiASADQdABahDkGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDGHSADQSBqEM8vDAMLQQRBHBCjPQALQYKAgIB4IQELIAAgDDcCECAAIAs3AgggACABNgIEIABBKToAACADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0HwAWokAAuDDAIGfwN+IwBB4AFrIgQkACABQQxqENs8IQggBEEQaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AjAgBCAHNgIsIARBwAA2AiggBQRAIAZBACAF/AsACyAEIAg2AjggBCAFNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQcgAigCACECIAEoAhAhCANAAkAgBCkDcCILUEUEQCAEKQN4IQoMAQsDQAJ+AkAgBCkDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAQgClCtQgGGNwNYIAqnQQFxRQ0AIAQgBCkDYDcDsAEMAQsgBCgCaEUNASAEQagBaiAFELYqIAQpA6gBIQoLIApCAFINAgsgBEIDNwNYCyAEKQNIIgpCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOwAQshCyAKp0EBcUUNByAEIAQpA3hCQH0iCjcDeCAEIAs3A3AgC1ANAAsLIAQgC0IBIAt6IgyGhTcDcCAEIAggDKcgCqdqQQJ0IglqKAIAIgE2ApABIAQgAjYC3AECQAJ/IAGsIAKsfiIKQiCIpyAKpyIBQR91RwRAIARBAjYCrAEgBEGskP8ANgKoASAEQgI3ArQBIARBggw2AswBIARBggw2AsQBIAQgBEHAAWo2ArABIAQgBEHcAWo2AsgBIAQgBEGQAWo2AsABIARBmAFqIARBqAFqEJkOIARBiAFqIARBpAFqKAIANgIAIAQgBCkCnAE3A4ABQYiAgIB4IQMgBCgCmAEMAQsgBEGoAWogASAHEOoPIAQoAqgBIgNBk4CAgHhGDQEgBEGIAWogBEG4AWooAgA2AgAgBCAEKQKwATcDgAEgBCgCrAELIQUgBEGAAWohBgwHCyAGIAlqIAE2AgAMAAsAC0HAACAHEKM9AAtB3Iv/AEEpIARByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgASgCECEFQQAhASACKAIAIgmsIQoDQCAEIAUoAgAiAjYC3AEgBCAJNgLAASACrCAKfiILQiCIpyALpyICQR91RwRAIARBAjYCTCAEQayQ/wA2AkggBEICNwJUIARBggw2AqABIARBggw2ApgBIAQgBEGUAWo2AlAgBCAEQcABajYCnAEgBCAEQdwBajYClAEgBEGsAWogBEHIAGoQmQ4gBEHYAWogBEG4AWooAgA2AgAgBCAEKQKwATcD0AEgBCgCrAEhBSAEQdABaiEGQYiAgIB4IQMMAwsgBEHIAGogAiAHEOoPIAQoAkgiA0GTgICAeEcEQCAEQdgBaiAEQdgAaigCADYCACAEIAQpAlA3A9ABIAQoAkwhBSAEQdABaiEGDAMLIAYgAjYCACAGQQRqIQYgBUEEaiEFIAggAUEBaiIBRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBSAEKAI0IQMgASAEQdAAaiIGKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBTYCSCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAGKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBTYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAYgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAU2AgggACADNgIEIABBKToAACAAIAYpAgA3AgwgAEEUaiAGQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC98LAgZ/BH4jAEGgAWsiAyQAIAFBDGoQ2DwhByADQQhqIAEQkjYQ7iUgB0EFdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBIHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEHIAIoAgAhBCABKAIQIQgCQANAAkAgAykDaCIKUEUEQCADKQNwIQkMAQsDQAJ+AkAgAykDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAMgCVCtQgGGNwNQIAmnQQFxRQ0AIAMgAykDWDcDiAEMAQsgAygCYEUNASADQYABaiAFELYqIAMpA4ABIQkLIAlCAFINAgsgA0IDNwNQCyADKQNAIglCAlENCiADQgA3A0AgAykDSAwBCyADKQOIAQshCiAJp0EBcUUNCCADIAMpA3BCQH0iCTcDcCADIAo3A2ggClANAAsLIAMgCkIBIAp6IguGhTcDaEKAgICAgICAgIB/IQwCQAJ+AkACQCAIIAunIAmnaiIBQQN0aikDACILQoCAgICAgICAgH9SIAQoAgApAwAiCUJ/UnJFBEBCACEKDAELIAlQDQMgCyALIAl/IgwgCX59QgAgCUJ/UhshCiALQgBZDQELIAwgCiAEKAIIKQMAV619DAELIAwgCiAEKAIEKQMAWa18CyEJIANBgAFqIgIgCSAJQj+HELIuIAIgAykDgAEiCSADKQOIASIKIAMpA5ABIgwgAykDmAEiCyAHLQAAENAOIAMoAoABIgJBk4CAgHhHDQIgBiABQQV0aiIBIAs3AxggASAMNwMQIAEgCjcDCCABIAk3AwAMAQsLQbyP/wAQ4isACyADKQKEASEJIAAgAykCjAE3AhAMBgtBwAAgBBCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQggAigCACEFIAEoAhAhBEEAIQEDQEKAgICAgICAgIB/IQwgBSgCACkDACEJAn4CQAJAIAQpAwAiCkKAgICAgICAgIB/UQRAQgAhCyAJQn9RDQELIAlQDQggCiAKIAl/IgwgCX59QgAgCUJ/UhshCyAKQgBZDQELIAwgCyAFKAIIKQMAV619DAELIAwgCyAFKAIEKQMAWa18CyEJIANBQGsiAiAJIAlCP4cQsi4gAiADKQNAIgkgAykDSCIKIAMpA1AiDCADKQNYIgsgCC0AABDQDiADKAJAIgJBk4CAgHhHDQIgBiAJNwMAIAZBGGogCzcDACAGQRBqIAw3AwAgBiAKNwMIIARBCGohBCAGQSBqIQYgByABQQFqIgFHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEEIAEgA0HIAGoiBikCADcDACADKQMgIQkgAyADKQJANwMgIANBADYCMCADIAk3AkwgA0EANgJIIAMgBDYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBDYCiAEgAyAFNgKEASADIAE2AoABIANBNGoiASADQYABahDiGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDOHSADQSBqEM8vDAILIAMpAkQhCSAAIAMpAkw3AhALIAAgCTcCCCAAQSk6AAAgACACNgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQaABaiQADwtBvI//ABDiKwALQQRBHBCjPQAL/wsCBn8DfiMAQeABayIEJAAgAUEMaigCCCEIIARBEGogARCSNhDuJSAIQQJ0IgYhBwJAAkACQAJAAkAgBkE8cSIFBEAgBiAFa0FAayIHIAZJDQELQcAAIQUgB0HAABDRNARAAkAgBwRAIAdBwAAQrTYiBUUNAQsgBCAFNgIwIAQgBzYCLCAEQcAANgIoIAYEQCAFQQAgBvwLAAsgBCAINgI4IAQgBjYCNCAEKAIQRQ0DIAQoAiQgBCgCIEYNBCAEQcgAaiAEQRBqEMg0IARB6ABqIQYgAy0AACEHIAIoAgAhAiABKAIQIQgDQAJAIAQpA3AiC1BFBEAgBCkDeCEKDAELA0ACfgJAIAQpA1giCkIDUgRAAkACQAJAIApCAlENACAEIApQrUIBhjcDWCAKp0EBcUUNACAEIAQpA2A3A7ABDAELIAQoAmhFDQEgBEGoAWogBhC2KiAEKQOoASEKCyAKQgBSDQILIARCAzcDWAsgBCkDSCIKQgJRDQkgBEIANwNIIAQpA1AMAQsgBCkDsAELIQsgCqdBAXFFDQcgBCAEKQN4QkB9Igo3A3ggBCALNwNwIAtQDQALCyAEIAtCASALeiIMhoU3A3AgBCAIIAynIAqnaiIJai0AACIBNgKQASAEIAI2AtwBAkACfyACrCABrX4iCkIgiKcgCqciA0EfdUcEQCAEQQI2AqwBIARBrJD/ADYCqAEgBEICNwK0ASAEQYIMNgLMASAEQYIMNgLEASAEIARBwAFqNgKwASAEIARB3AFqNgLIASAEIARBkAFqNgLAASAEQZgBaiAEQagBahCZDiAEQYgBaiAEQaQBaigCADYCACAEIAQpApwBNwOAAUGIgICAeCEBIAQoApgBDAELIARBqAFqIAMgBxDqDyAEKAKoASIBQZOAgIB4Rg0BIARBiAFqIARBuAFqKAIANgIAIAQgBCkCsAE3A4ABIAQoAqwBCyEDIARBgAFqIQUMBwsgBSAJQQJ0aiADNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEGIAEoAhAhB0EAIQMgAigCACIJrCEKA0AgBCADIAdqLQAAIgE2AtwBIAQgCTYCwAEgAa0gCn4iC0IgiKcgC6ciAkEfdUcEQCAEQQI2AkwgBEGskP8ANgJIIARCAjcCVCAEQYIMNgKgASAEQYIMNgKYASAEIARBlAFqNgJQIAQgBEHAAWo2ApwBIAQgBEHcAWo2ApQBIARBrAFqIARByABqEJkOIARB2AFqIARBuAFqKAIANgIAIAQgBCkCsAE3A9ABIAQoAqwBIQMgBEHQAWohBUGIgICAeCEBDAMLIARByABqIAIgBhDqDyAEKAJIIgFBk4CAgHhHBEAgBEHYAWogBEHYAGooAgA2AgAgBCAEKQJQNwPQASAEKAJMIQMgBEHQAWohBQwDCyAFIAI2AgAgBUEEaiEFIAggA0EBaiIDRw0ACwsgBEHIAGoiAhCXKSAEQTBqIgEoAgAhBiAEKAI0IQMgASAEQdAAaiIFKQIANwMAIAQpAyghCiAEIAQpAkg3AyggBEEANgI4IAQgCjcCVCAEQQA2AlAgBCADNgJMIAQgBjYCSCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogBEHYAGoiBygCADYCACAEIAM2ArABIAQgBjYCrAEgBCABNgKoASAEQTxqIgEgBEGoAWoQ5RkgByAEQSBqKQIANwMAIAUgBEEYaikCADcDACAEIAQpAhA3A0ggACABIAIQyh0gBEEoahDPLwwCC0EEQRwQoz0ACyAAIAM2AgggACABNgIEIABBKToAACAAIAUpAgA3AgwgAEEUaiAFQQhqKAIANgIAIARBKGoQzy8gBCgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRBqEPseCyAEQeABaiQAC/8LAgZ/A34jAEHgAWsiBCQAIAFBDGooAgghCCAEQRBqIAEQkjYQ7iUgCEECdCIGIQcCQAJAAkACQAJAIAZBPHEiBQRAIAYgBWtBQGsiByAGSQ0BC0HAACEFIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgVFDQELIAQgBTYCMCAEIAc2AiwgBEHAADYCKCAGBEAgBUEAIAb8CwALIAQgCDYCOCAEIAY2AjQgBCgCEEUNAyAEKAIkIAQoAiBGDQQgBEHIAGogBEEQahDINCAEQegAaiEGIAMtAAAhByACKAIAIQIgASgCECEIA0ACQCAEKQNwIgtQRQRAIAQpA3ghCgwBCwNAAn4CQCAEKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgBCAKUK1CAYY3A1ggCqdBAXFFDQAgBCAEKQNgNwOwAQwBCyAEKAJoRQ0BIARBqAFqIAYQtiogBCkDqAEhCgsgCkIAUg0CCyAEQgM3A1gLIAQpA0giCkICUQ0JIARCADcDSCAEKQNQDAELIAQpA7ABCyELIAqnQQFxRQ0HIAQgBCkDeEJAfSIKNwN4IAQgCzcDcCALUA0ACwsgBCALQgEgC3oiDIaFNwNwIAQgCCAMpyAKp2oiCWosAAAiATYCkAEgBCACNgLcAQJAAn8gAawgAqx+IgpCIIinIAqnIgNBH3VHBEAgBEECNgKsASAEQayQ/wA2AqgBIARCAjcCtAEgBEGCDDYCzAEgBEGCDDYCxAEgBCAEQcABajYCsAEgBCAEQdwBajYCyAEgBCAEQZABajYCwAEgBEGYAWogBEGoAWoQmQ4gBEGIAWogBEGkAWooAgA2AgAgBCAEKQKcATcDgAFBiICAgHghASAEKAKYAQwBCyAEQagBaiADIAcQ6g8gBCgCqAEiAUGTgICAeEYNASAEQYgBaiAEQbgBaigCADYCACAEIAQpArABNwOAASAEKAKsAQshAyAEQYABaiEFDAcLIAUgCUECdGogAzYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhBiABKAIQIQdBACEDIAIoAgAiCawhCgNAIAQgAyAHaiwAACIBNgLcASAEIAk2AsABIAGsIAp+IgtCIIinIAunIgJBH3VHBEAgBEECNgJMIARBrJD/ADYCSCAEQgI3AlQgBEGCDDYCoAEgBEGCDDYCmAEgBCAEQZQBajYCUCAEIARBwAFqNgKcASAEIARB3AFqNgKUASAEQawBaiAEQcgAahCZDiAEQdgBaiAEQbgBaigCADYCACAEIAQpArABNwPQASAEKAKsASEDIARB0AFqIQVBiICAgHghAQwDCyAEQcgAaiACIAYQ6g8gBCgCSCIBQZOAgIB4RwRAIARB2AFqIARB2ABqKAIANgIAIAQgBCkCUDcD0AEgBCgCTCEDIARB0AFqIQUMAwsgBSACNgIAIAVBBGohBSAIIANBAWoiA0cNAAsLIARByABqIgIQlykgBEEwaiIBKAIAIQYgBCgCNCEDIAEgBEHQAGoiBSkCADcDACAEKQMoIQogBCAEKQJINwMoIARBADYCOCAEIAo3AlQgBEEANgJQIAQgAzYCTCAEIAY2AkggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJINwIIIAFBEGogBSkCADcCACABQRhqIARB2ABqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEE8aiIBIARBqAFqEOUZIAcgBEEgaikCADcDACAFIARBGGopAgA3AwAgBCAEKQIQNwNIIAAgASACEModIARBKGoQzy8MAgtBBEEcEKM9AAsgACADNgIIIAAgATYCBCAAQSk6AAAgACAFKQIANwIMIABBFGogBUEIaigCADYCACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHgAWokAAvJCwIJfwR+IwBBoAFrIgMkACABQQxqENs8IQcgA0EIaiABEJI2EO4lIAdBBXQiBCEFAkACQAJAAkACQAJAAkACQCAEQSBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEIIAIoAgghCSACKAIAIQUgASgCECEKAkADQAJAIAMpA2giDVBFBEAgAykDcCEMDAELA0ACfgJAIAMpA1AiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDUCAMp0EBcUUNACADIAMpA1g3A4gBDAELIAMoAmBFDQEgA0GAAWogCBC2KiADKQOAASEMCyAMQgBSDQILIANCAzcDUAsgAykDQCIMQgJRDQogA0IANwNAIAMpA0gMAQsgAykDiAELIQ0gDKdBAXFFDQggAyADKQNwQkB9Igw3A3AgAyANNwNoIA1QDQALCyADIA1CASANeiIOhoU3A2hBgICAgHghAQJAAn8CQAJAIAogDqcgDKdqIgtBAnRqKAIAIgdBgICAgHhHIAUoAgAoAgAiAkF/R3JFBEBBACEEDAELIAJFDQMgByAHIAJtIgEgAmxrQQAgAkF/RxshBCAHQQBODQELIAEgBCAFKAIIKAIATGsMAQsgASAEIAUoAgQoAgBOagshASADQYABaiICIAGsIgwgDEI/hxCyLiACIAMpA4ABIgwgAykDiAEiDSADKQOQASIOIAMpA5gBIg8gCS0AABDQDiADKAKAASIEQZOAgIB4Rw0CIAYgC0EFdGoiASAPNwMYIAEgDjcDECABIA03AwggASAMNwMADAELC0Gsj/8AEOIrAAsgAykChAEhDCAAIAMpAowBNwIQDAYLQcAAIAUQoz0AC0Hci/8AQSkgA0FAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEKIAIoAgAhBSABKAIQIQIDQEGAgICAeCEBIAUoAgAoAgAhBAJ/AkACQCACKAIAIghBgICAgHhGBEBBACEJIARBf0YNAQsgBEUNCCAIIAggBG0iASAEbGtBACAEQX9HGyEJIAhBAE4NAQsgASAJIAUoAggoAgBMawwBCyABIAkgBSgCBCgCAE5qCyEBIANBQGsiBCABrCIMIAxCP4cQsi4gBCADKQNAIgwgAykDSCINIAMpA1AiDiADKQNYIg8gCi0AABDQDiADKAJAIgRBk4CAgHhHDQIgBiAMNwMAIAZBGGogDzcDACAGQRBqIA43AwAgBiANNwMIIAJBBGohAiAGQSBqIQYgByALQQFqIgtHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEGIAEgA0HIAGoiBCkCADcDACADKQMgIQwgAyADKQJANwMgIANBADYCMCADIAw3AkwgA0EANgJIIAMgBjYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAQpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBjYCiAEgAyAFNgKEASADIAE2AoABIANBNGoiASADQYABahDiGSAHIANBGGopAgA3AwAgBCADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDOHSADQSBqEM8vDAILIAMpAkQhDCAAIAMpAkw3AhALIAAgDDcCCCAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQaABaiQADwtBrI//ABDiKwALQQRBHBCjPQAL9woCCH8BfiMAQUBqIgQkACAEIAI2AgggBCABNgIEAn8CQCACQQRJDQACQAJAIAEgAkEDayIFaiIGLQAAQSBHDQACQAJAIAYtAAEiA0HgAE0EQCADQcEARg0BIANB0ABHDQMgBi0AAkEgckHtAEYNAgwECyADQeEARg0AIANB8ABHDQIgBi0AAkEgckHtAEcNAwwBCyAGLQACQSByQe0ARw0CQQEhCQtBASEHIAUiAkEETw0BDAILCyAEQSRqQbDgADsBACAEQbDgwIEDNgIgIAQCfyABLQABIgVBOkcEQCABLQACQTpHDQIgBCAFOgAhIAQgAS0AADoAICACQQNrIgNBAkkNAiABQQNqDAELIAQgAS0AADoAISACQQJrIQMgAUECagsiCC8AADsBIkEAIQICf0EAIANBAkYNABogA0EFSQ0BIAgtAAJBOkcNASAEIAgvAAM7ASRBACADQQVGDQAaIAgtAAVBLkcNAUEGIQEgCEEGaiEFIANBBmshBgNAIAEgA0cEQCABIAhqIAFBAWohAS0AAEE6a0H/AXFB9gFPDQEMAwsLAkACQAJAAkACQAJAAkACQAJAIANBBmsOCQoBAgMEBQYHCAALAn9BACEBIAZBCU8EQEEAIQYDQCABQQpsIAUgBmotAABBMGtB/wFxaiEBIAZBAWoiBkEJRw0ACyABDAELQQkgBkHAw4ABELA7AAsMCAsgBS0AAEEwa0H/AXFBgMLXL2wMBwtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQJHDQALIANBgK3iBGwMBgtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQNHDQALIANBwIQ9bAwFC0EAIQNBACEBA0AgA0EKbCABIAVqLQAAQTBrQf8BcWohAyABQQFqIgFBBEcNAAsgA0GgjQZsDAQLQQAhA0EAIQEDQCADQQpsIAEgBWotAABBMGtB/wFxaiEDIAFBAWoiAUEFRw0ACyADQZDOAGwMAwtBACEDQQAhAQNAIANBCmwgASAFai0AAEEwa0H/AXFqIQMgAUEBaiIBQQZHDQALIANB6AdsDAILQQAhA0EAIQEDQCADQQpsIAEgBWotAABBMGtB/wFxaiEDIAFBAWoiAUEHRw0ACyADQeQAbAwBC0EAIQNBACEBA0AgA0EKbCABIAVqLQAAQTBrQf8BcWohAyABQQFqIgFBCEcNAAsgA0EKbAshAQNAIARBIGogAmoiBSAFLQAAQTBrOgAAIAJBAWoiAkEGRw0AC0EAIQIDQCACQQZHBEAgBEEgaiACaiACQQFqIQItAABBCU0NAQwCCwsCQCAELQAhIAQtACBBCmxqIgJB/wFxQQxGBEBBAEEMIAcbQQwgCRshAgwBCyACQQFrQf8BcUELTwRAIAcNAgwBCyAHRQ0AIAIgAkEMaiAJGyECC0E7IAQtACUgBC0AJEEKbGoiBSAFQf8BcUE8RiIGGyIFQf8BcUE7SyACQf8BcUEXS3INACAELQAjIAQtACJBCmxqIgNB/wFxQTtLDQAgAUGAlOvcA2ogASAGGyIBQYCU69wDTyAFQf8BcUE7RyABQf+n1rkHS3JxDQAgAa0gAq1C/wGDQpAcfiAFrUL/AYN8IAOtQv8Bg0I8fnxCgJTr3AN+fCELQQAhAkEIDAELIARBAjYCJCAEQbzFgAE2AiAgBEIBNwIsIARBzAE2AjwgBCAEQThqNgIoIAQgBEEEajYCOCAEQRBqIARBIGoQmQ4gBCkCGCELIAAgBCkCEDcDCCAAQYSAgIB4NgIEQQEhAkEQCyAAaiALNwMAIAAgAjYCACAEQUBrJAALkAsCA38BfiMAQYABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AkwgAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQcwAaiADEMwkIQIMCwsgBEHMAGogAxDTHCECDAoLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBAnYiAU8NCyAAKAIQIAJBAnRqNAIAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQ1xsgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBAnYiAU8NCiAEIAAoAhAgAkECdGo0AgAiBzcDCCAEQegAaiIAIAcQ1xsgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCAsgACgCBCgCFCEAIAQgAjYCMCACIABBAnYiAEkNBQwICyAEQdgAaiAHENcbIAQoAlgEQCAEQSBqIARB4ABqKAIANgIAIAQgBCkCWDcDGCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZMMNgI0IAQgBEEwajYCcCAEIARBGGo2AjAgAygCACADKAIEIARB6ABqEMsKIQIMBwsgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAYLIARBMGohASAEKAIcIQIjAEEgayIAJAAgAEEUaiAHENcbAkAgACgCFCIFRQRAIAFBADYCAAwBCyAAIAApAhg3AgwgACAFNgIIIAEgAEEIahDKLyABIAI2AgwLIABBIGokACAEKAIwBEAgBEHgAGogBEE4aikCADcDACAEIAQpAjA3A1ggBEHMAGoiACAEQdgAahCuByAEQfoXNgJIIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IAQgADYCRCAEIARBxABqNgJwIAMoAgAgAygCBCAEQegAahDLCiECIAAQ3jsMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQQA2AnggBEEBNgJsIARB7JuEATYCaCAEQgQ3AnAgAyAEQegAahDROSECDAMLIARBzABqIAMQ0hwhAgwDCyAEQQI2AmwgBEHsnIQBNgJoIARCAjcCdCAEQa8DNgIkIAQgBjYCICAEQe4GNgIcIAQgBEEYajYCcCAEIARBCGo2AhggAygCACADKAIEIARB6ABqEMsKIQIMAgsgBEHwAGpBjpy48AA2AgAgBEKOnLjw4MGDhw43A2ggBEHoAGoiABDJDCAEQgA3AlggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGUDDYCHCAEIARBGGo2AnAgBCAEQdgAajYCGCADKAIAIAMoAgQgABDLCiECDAELIARBGGoQ5RALIARBgAFqJAAgAg8LIAQgADYCWAwBCyAEIAE2AlgLIARBAjYCbCAEQbiXhAE2AmggBEICNwJ0IARBOzYCJCAEQTs2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AiAgBCAEQTBqNgIYIARB6ABqQciXhAEQ7ywAC98LAgN/AX4jAEGAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIGKAIAIgUtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCTCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3A1ggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQdgAaiADEJ4lIQIMDAsgBEHYAGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAIQcgBSgCBCIARQ0CIAQgBUEEajYCFCAEQRhqIABBCGogBSgCCBCKGCAEKAIYQZOAgIB4Rg0DIARBzABqIAcQoBUgBCgCTEUNBCAEQThqIARB1ABqKAIANgIAIAQgBCkCTDcDMCAEQQM2AmwgBEGUnIQBNgJoIARCAjcCdCAEQfkXNgJkIARBkww2AlwgBCAEQdgAajYCcCAEIARBFGo2AmAgBCAEQTBqNgJYIAMoAgAgAygCBCAEQegAahDLCiECDAkLIAAoAgQiACgCFCEBIAQgAjYCMCACIAFBA3YiAU8NCiAEIAAoAhAgAkEDdGopAwAiBzcDCCAEQegAaiIAIAcQoBUgBCgCaCIBRQ0FIAQgATYCWCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEQZIMNgIcIAQgBEEYajYCcCAEIARB2ABqNgIYIAMoAgAgAygCBCAAEMsKIQIMCQsgACgCBCgCFCEAIAQgAjYCMCACIABBA3YiAEkNBSAEIAA2AlgMCgsgBEHYAGogBxCgFSAEKAJYBEAgBEEgaiAEQeAAaigCADYCACAEIAQpAlg3AxggBEEBNgJsIARB9JuEATYCaCAEQgE3AnQgBEGTDDYCNCAEIARBMGo2AnAgBCAEQRhqNgIwIAMoAgAgAygCBCAEQegAahDLCiECDAgLIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQTBqIQEgBCgCHCECIwBBIGsiACQAIABBFGogBxCgFQJAIAAoAhQiBUUEQCABQQA2AgAMAQsgACAAKQIYNwIMIAAgBTYCCCABIABBCGoQyi8gASACNgIMCyAAQSBqJAAgBCgCMARAIARB4ABqIARBOGopAgA3AwAgBCAEKQIwNwNYIARBzABqIgAgBEHYAGoQrgcgBEH6FzYCSCAEQQE2AmwgBEH0m4QBNgJoIARCATcCdCAEIAA2AkQgBCAEQcQAajYCcCADKAIAIAMoAgQgBEHoAGoQywohAiAAEN47DAYLIARBADYCeCAEQQE2AmwgBEHsm4QBNgJoIARCBDcCcCADIARB6ABqENE5IQIMBQsgBEEANgJ4IARBATYCbCAEQeybhAE2AmggBEIENwJwIAMgBEHoAGoQ0TkhAgwECyAEQdgAaiADELgcIQIMBAsgBEECNgJsIARB7JyEATYCaCAEQgI3AnQgBEGvAzYCJCAEIAY2AiAgBEHuBjYCHCAEIARBGGo2AnAgBCAEQQhqNgIYIAMoAgAgAygCBCAEQegAahDLCiECDAMLIARB8ABqQY+evPgANgIAIARCj568+PDhw4cPNwNoIARB6ABqIgAQyQwgBEIANwJYIARBATYCbCAEQfSbhAE2AmggBEIBNwJ0IARBlAw2AhwgBCAEQRhqNgJwIAQgBEHYAGo2AhggAygCACADKAIEIAAQywohAgwCCyAEIAA2AjAgBEECNgJsIARBuJeEATYCaCAEQgI3AnQgBEE7NgIkIARBOzYCHCAEIARBGGo2AnAgBCAEQTBqNgIgIAQgBEHMAGo2AhgMBAsgBEEYahDlEAsgBEGAAWokACACDwsgBCABNgJYCyAEQQI2AmwgBEG4l4QBNgJoIARCAjcCdCAEQTs2AiQgBEE7NgIcIAQgBEEYajYCcCAEIARB2ABqNgIgIAQgBEEwajYCGAsgBEHoAGpByJeEARDvLAALrgoCDn8CfgJAIAIEQCABIAJqIglBEyACIAJBE08bayELIAMoAgAiCiADKAIEIgJBImsiBUEAIAIgBU8baiEMIAMoAgQgCmohDSADKAIIIAMoAgBqIg8hBQNAAkAgAS0AACICQQ9xIghBD0YgAkHvAUtyIAFBAWoiBCALSyAFIAxPcnINAANAIAUgBCkAADcAACAFQQhqIARBCGopAAA3AAAgBSACQQR2QQ9xIgFqIgIgCEEEaiIGaiEFAkAgBiACIAprIgcgASAEaiIELwAAIgEgASAHSxsiAU0EQCACIAFrIgFBCGopAAAhEiABKQAAIRMgAkEQaiABQRBqLwAAOwAAIAJBCGogEjcAACACIBM3AAAMAQtBACABayEGIAJBADoAAANAIAIgAiAGaiIBLQAAOgAAIAJBAWogAUEBai0AADoAACACQQNqIQcgAkECaiIBIQIgBSAHSw0ACyABIAVPBEAgASEFDAELIAFBAWohBSABIAEgBmotAAA6AAALIAQtAAIiAkEPcSIIQQ9GIAJB7wFLciAEQQNqIgQgC0tyDQEgBSAMSQ0ACwsCQAJ/AkACQAJAAkACQAJAAkAgAkEQSQR/IAUFAkAgAkEEdiIBQQ9HBEAgBCEGDAELQQAhAgNAIAQgCU8NAyACIAQtAAAiAWohAiAEQQFqIgYhBCABQf8BRg0ACyACQQ9qIQEgAiEQCyABIAkgBmtLDQIgASANIAVrSw0DAkACQAJAIAFBBE8EQCABQQhJDQEgAUERSQ0CIAUgAUFwcWohByAFIQIgBiEEA0AgAiAEKQAANwAAIAJBCGogBEEIaikAADcAACAEQRBqIQQgAkEQaiICIAdJDQALIAUgAUEQayICaiIEIAIgBmoiAikAADcAACAEQQhqIAJBCGopAAA3AAAMAwsgBSAGLQAAOgAAIAFBAkkNAiAFIAYvAAA7AAAgBSABQQJrIgJqIAIgBmovAAA7AAAMAgsgBSAGKAAANgAAIAUgAUEEayICaiACIAZqKAAANgAADAELIAUgBikAADcAACAFIAFBCGsiAmogAiAGaikAADcAAAsgASAGaiEEIAEgBWoLIQIgBCAJTw0DAkACQCAJIARrQQJPBEAgBEECaiEFIAQvAAAhByAIQQRqIgZBE0YNASAFIQEMAgsMDQtBACEEA0AgBSAJTw0GIAQgBS0AACIGaiEEIAVBAWoiASEFIAZB/wFGDQALIARBE2ohBiAEIRELIAIgCmsiBSAHSQ0FIA0gAmsiBCAGSQRAIABBADYCACAAIAMoAgQ2AgggACAFIAZqNgIEDwtBACAHayEIIAZBD2oiBSAHSyAEIAVJckUEQCACIAZqIQUDQCACIAIgCGoiBCkAADcAACACQQhqIARBCGopAAA3AAAgAkEQaiICIAVJDQALDAkLIAJBADoAACACIAZqIQ4gBkECSQ0GIAIhBANAIAQgBCAIaiICLQAAOgAAIARBAWogAkEBai0AADoAACAEQQNqIARBAmoiAiEEIA5JDQALIAIgCGohBCACQQFqDAcLIAAgEDYCBAwKCyAAQQE2AgAPCyAAQQA2AgAgACADKAIENgIIIAAgBSAKayABajYCBA8LIABBBDYCACAAIAIgD2s2AgQgAyACIAprNgIIDwsgACARNgIEDAYLIABBAzYCAA8LIAIgB2shBCACQQFqCyEFIAIgDk8EQCACIQUMAQsgAiAELQAAOgAACyABIAlJDQALDAELIABBAjYCAA8LIABBAjYCAAvTCgIQfwJ+IwBBEGsiCiQAIApBADYCDCAKQQA2AghBVCEHAkAgBEHUC0kNAAJAIANB1AlqIgYgAyAKQQhqIApBDGogASACIANB6ABqEPEMIhRBiH9LDQAgCigCCCEPQQogACgCACIMQf8BcSIQIBBBCk8bQQFqIgEgCigCDCIITwRAAkAgASAITQ0AIAEgCGshCyAPIQUgBiEEA0AgBQRAIAQgC0EAIAQtAAAiAhsgAmo6AAAgBUEBayEFIARBAWohBAwBBUEKIAxB/wFxIgIgAkEKTxtBAnQgA2pBBGohBSADIAhBAnRqIQIgASEEA0AgBCALTQRAQQogDEH/AXEiAiACQQpPGyICQX9zIAhqIQQgAkECdCAIQQJ0ayADakEEaiEFA0AgBEUNBSAFQQA2AgAgBEEBaiEEIAVBBGshBQwACwAFIAUgAigCADYCACACQQRrIQIgBUEEayEFIARBAWshBAwBCwALAAsACwALIAEhCAsgCCAQQQFqSw0BIAAgDEH/gYB4cSAIQRB0QYCA/AdxcjYCACADQTRqIQtBACECIAMhBCAIQQFqIgwhBQNAIAUEQCAEQTRqIAI2AgAgBUEBayEFIAQoAgAgAmohAiAEQQRqIQQMAQsLIANB1AdqIRIgD0EDayEHQQAhAgNAIAIgB04EQANAIAIgD0gEQCALIAIgA2pB1AlqLQAAQQJ0aiIBIAEoAgAiAUEBajYCACABIBJqIAI6AAAgAkEBaiECDAELCwVBACEEA0AgBEEERwRAIAsgBCAGai0AAEECdGoiASABKAIAIgFBAWo2AgAgASASaiACIARqOgAAIARBAWohBAwBCwsgBkEEaiEGIAJBBGohAgwBCwsgA0HUB2ohESAAQQVqIRAgAEEEaiELIABBDGohDyADKAIAIQhBASENA0AgDCANRg0BIAwgDWshBSADIA1BAnRqKAIAIQkCQAJAAkACQAJAAkBBASANdEEBdSITQQFrDggAAQQCBAQEAwQLIAlBACAJQQBKGyEGIAggEWohByAQIA5BAXRqIQQDQCAGRQ0FIAQgBy0AADoAACAEQQFrIAU6AAAgB0EBaiEHIAZBAWshBiAEQQJqIQQMAAsACyAJQQAgCUEAShshBiAIIBFqIQcgACAOQQF0aiEEA0AgBkUNBCAEQQdqIActAAAiAToAACAEQQZqIAU6AAAgBEEFaiABOgAAIARBBGoiBCAFOgAAIAdBAWohByAGQQFrIQYMAAsACyAJQQAgCUEAShshBCAIIBFqIQYgCyAOQQF0aiEHIAVB/wFxrSEWA0AgBEUNAyAHIAYxAABCCIYgFoRCgYCEgJCAwAB+NwAAIAZBAWohBiAEQQFrIQQgB0EIaiEHDAALAAsgCUEAIAlBAEobIQYgCCARaiEHIA8gDkEBdGohBCAFQf8Bca0hFQNAIAZFDQIgBCAHMQAAQgiGIBWEQoGAhICQgMAAfiIWNwAAIARBCGsgFjcAACAHQQFqIQcgBkEBayEGIARBEGohBAwACwALQQAhBiAJQQAgCUEAShshAiATQQF0IQEgACAOQQF0aiEHIAVB/wFxrSEWA0AgAiAGRg0BIBIgBiAIamoxAABCCIYgFoRCgYCEgJCAwAB+IRVBACEFIAchBANAIAUgE0gEQCAEQRxqIBU3AAAgBEEUaiAVNwAAIARBDGogFTcAACAEQQRqIBU3AAAgBEEgaiEEIAVBEGohBQwBCwsgASAHaiEHIAZBAWohBgwACwALIA1BAWohDSAIIAlqIQggCSATbCAOaiEODAALAAsgFCEHCyAKQRBqJAAgBwugDAIFfwV+IwBBoAJrIgQkACABQQxqENk8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghDCACKQMAIQsgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAXRqMgEAIQkgBCAMNwOIAiAEIAs3A4ACIAQgCUI/hyIKNwPIASAEIAk3A8ABIARBADYCTCAEQTBqIAkgCiALIAwgBEHMAGoQ9gwgBCgCTARAIARBAjYC7AEgBEGskP8ANgLoASAEQgI3AvQBIARBhAw2ApwCIARBhAw2ApQCIAQgBEGQAmo2AvABIAQgBEGAAmo2ApgCIAQgBEHAAWo2ApACIARB2AFqIARB6AFqEJkOIAQpAtgBIQkgBCkC4AEhCkGIgICAeCEBDAcLIARB6AFqIAQpAzAiCSAEKQM4IgogAhCtDiAEKALoASIBQZOAgIB4RwRAIAQpAvQBIQogBCkC7AEhCQwHBSAGIAdBBHRqIgEgCjcDCCABIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCiACKQMAIQwgAy0AACEDIAEoAhAhAkEAIQUDQCACMgEAIQkgBCAKNwOYAiAEIAw3A5ACIAQgCUI/hyILNwOIAiAEIAk3A4ACIARBADYCLCAEQRBqIAkgCyAMIAogBEEsahD2DCAEKAIsBEAgBEECNgKMASAEQayQ/wA2AogBIARCAjcClAEgBEGEDDYC4AEgBEGEDDYC2AEgBCAEQdQBajYCkAEgBCAEQZACajYC3AEgBCAEQYACajYC1AEgBEHsAWogBEGIAWoQmQ4gBCkC7AEhCSAEKQL0ASEKQYiAgIB4IQEMAwsgBEGIAWogBCkDECIJIAQpAxgiCyADEK0OIAQoAogBIgFBk4CAgHhHBEAgBCkClAEhCiAEKQKMASEJDAMLIAYgCTcDACAGIAs3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBiAFqIgIQlykgBEHwAGoiASgCACEGIAQoAnQhAyABIARBkAFqIgUpAgA3AwAgBCkDaCEJIAQgBCkCiAE3A2ggBEEANgJ4IAQgCTcClAEgBEEANgKQASAEIAM2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQZgBaiIHKAIANgIAIAQgAzYC8AEgBCAGNgLsASAEIAE2AugBIARB/ABqIgEgBEHoAWoQ4hkgByAEQeAAaikCADcDACAFIARB2ABqKQIANwMAIAQgBCkCUDcDiAEgACABIAIQyx0gBEHoAGoQzy8MAgtBBEEcEKM9AAsgACAKNwIQIAAgCTcCCCAAIAE2AgQgAEEpOgAAIARB6ABqEM8vIAQoAlAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEHQAGoQ+x4LIARBoAJqJAALoAwCBX8FfiMAQaACayIEJAAgAUEMahDbPCEIIARB0ABqIAEQkjYQ7iUgCEEEdCIHIQUCQAJAAkACQAJAIAdBMHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCcCAEIAU2AmwgBEHAADYCaCAHBEAgBkEAIAf8CwALIAQgCDYCeCAEIAc2AnQgBCgCUEUNAyAEKAJkIAQoAmBGDQQgBEGIAWogBEHQAGoQyDQgBEGoAWohBSACKQMIIQwgAikDACELIAMtAAAhAiABKAIQIQMDQAJAIAQpA7ABIgpQRQRAIAQpA7gBIQkMAQsDQAJ+AkAgBCkDmAEiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDmAEgCadBAXFFDQAgBCAEKQOgATcD8AEMAQsgBCgCqAFFDQEgBEHoAWogBRC2KiAEKQPoASEJCyAJQgBSDQILIARCAzcDmAELIAQpA4gBIglCAlENCSAEQgA3A4gBIAQpA5ABDAELIAQpA/ABCyEKIAmnQQFxRQ0HIAQgBCkDuAFCQH0iCTcDuAEgBCAKNwOwASAKUA0ACwsgBCAKQgEgCnoiDYaFNwOwASADIA2nIAmnaiIHQQJ0ajQCACEJIAQgDDcDiAIgBCALNwOAAiAEIAlCP4ciCjcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJIAogCyAMIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQogAikDACEMIAMtAAAhAyABKAIQIQJBACEFA0AgAjQCACEJIAQgCjcDmAIgBCAMNwOQAiAEIAlCP4ciCzcDiAIgBCAJNwOAAiAEQQA2AiwgBEEQaiAJIAsgDCAKIARBLGoQ9gwgBCgCLARAIARBAjYCjAEgBEGskP8ANgKIASAEQgI3ApQBIARBhAw2AuABIARBhAw2AtgBIAQgBEHUAWo2ApABIAQgBEGQAmo2AtwBIAQgBEGAAmo2AtQBIARB7AFqIARBiAFqEJkOIAQpAuwBIQkgBCkC9AEhCkGIgICAeCEBDAMLIARBiAFqIAQpAxAiCSAEKQMYIgsgAxCtDiAEKAKIASIBQZOAgIB4RwRAIAQpApQBIQogBCkCjAEhCQwDCyAGIAk3AwAgBiALNwMIIAZBEGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQYgBaiICEJcpIARB8ABqIgEoAgAhBiAEKAJ0IQMgASAEQZABaiIFKQIANwMAIAQpA2ghCSAEIAQpAogBNwNoIARBADYCeCAEIAk3ApQBIARBADYCkAEgBCADNgKMASAEIAY2AogBIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAFKQIANwIAIAFBGGogBEGYAWoiBygCADYCACAEIAM2AvABIAQgBjYC7AEgBCABNgLoASAEQfwAaiIBIARB6AFqEOIZIAcgBEHgAGopAgA3AwAgBSAEQdgAaikCADcDACAEIAQpAlA3A4gBIAAgASACEMsdIARB6ABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQegAahDPLyAEKAJQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARB0ABqEPseCyAEQaACaiQAC6AMAgV/BX4jAEGgAmsiBCQAIAFBDGoQ2DwhCCAEQdAAaiABEJI2EO4lIAhBBHQiByEFAkACQAJAAkACQCAHQTBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AnAgBCAFNgJsIARBwAA2AmggBwRAIAZBACAH/AsACyAEIAg2AnggBCAHNgJ0IAQoAlBFDQMgBCgCZCAEKAJgRg0EIARBiAFqIARB0ABqEMg0IARBqAFqIQUgAikDCCEMIAIpAwAhCyADLQAAIQIgASgCECEDA0ACQCAEKQOwASIKUEUEQCAEKQO4ASEJDAELA0ACfgJAIAQpA5gBIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A5gBIAmnQQFxRQ0AIAQgBCkDoAE3A/ABDAELIAQoAqgBRQ0BIARB6AFqIAUQtiogBCkD6AEhCQsgCUIAUg0CCyAEQgM3A5gBCyAEKQOIASIJQgJRDQkgBEIANwOIASAEKQOQAQwBCyAEKQPwAQshCiAJp0EBcUUNByAEIAQpA7gBQkB9Igk3A7gBIAQgCjcDsAEgClANAAsLIAQgCkIBIAp6Ig2GhTcDsAEgAyANpyAJp2oiB0EDdGopAwAhCSAEIAw3A4gCIAQgCzcDgAIgBCAJQj+HIgo3A8gBIAQgCTcDwAEgBEEANgJMIARBMGogCSAKIAsgDCAEQcwAahD2DCAEKAJMBEAgBEECNgLsASAEQayQ/wA2AugBIARCAjcC9AEgBEGEDDYCnAIgBEGEDDYClAIgBCAEQZACajYC8AEgBCAEQYACajYCmAIgBCAEQcABajYCkAIgBEHYAWogBEHoAWoQmQ4gBCkC2AEhCSAEKQLgASEKQYiAgIB4IQEMBwsgBEHoAWogBCkDMCIJIAQpAzgiCiACEK0OIAQoAugBIgFBk4CAgHhHBEAgBCkC9AEhCiAEKQLsASEJDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQYgBakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEKIAIpAwAhDCADLQAAIQMgASgCECECQQAhBQNAIAIpAwAhCSAEIAo3A5gCIAQgDDcDkAIgBCAJQj+HIgs3A4gCIAQgCTcDgAIgBEEANgIsIARBEGogCSALIAwgCiAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgkgBCkDGCILIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiAJNwMAIAYgCzcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuZDAIFfwV+IwBBoAJrIgQkACABQQxqKAIIIQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEHIAIpAwghDCACKQMAIQsgAy0AACECIAEoAhAhAQNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAHELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAEgDacgCadqIgNqMAAAIQkgBCAMNwOIAiAEIAs3A4ACIAQgCUI/hyIKNwPIASAEIAk3A8ABIARBADYCTCAEQTBqIAkgCiALIAwgBEHMAGoQ9gwgBCgCTARAIARBAjYC7AEgBEGskP8ANgLoASAEQgI3AvQBIARBhAw2ApwCIARBhAw2ApQCIAQgBEGQAmo2AvABIAQgBEGAAmo2ApgCIAQgBEHAAWo2ApACIARB2AFqIARB6AFqEJkOIAQpAtgBIQkgBCkC4AEhCkGIgICAeCEFDAcLIARB6AFqIAQpAzAiCSAEKQM4IgogAhCtDiAEKALoASIFQZOAgIB4RwRAIAQpAvQBIQogBCkC7AEhCQwHBSAGIANBBHRqIgMgCjcDCCADIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCiACKQMAIQwgAy0AACECIAEoAhAhA0EAIQEDQCABIANqMAAAIQkgBCAKNwOYAiAEIAw3A5ACIAQgCUI/hyILNwOIAiAEIAk3A4ACIARBADYCLCAEQRBqIAkgCyAMIAogBEEsahD2DCAEKAIsBEAgBEECNgKMASAEQayQ/wA2AogBIARCAjcClAEgBEGEDDYC4AEgBEGEDDYC2AEgBCAEQdQBajYCkAEgBCAEQZACajYC3AEgBCAEQYACajYC1AEgBEHsAWogBEGIAWoQmQ4gBCkC7AEhCSAEKQL0ASEKQYiAgIB4IQUMAwsgBEGIAWogBCkDECIJIAQpAxgiCyACEK0OIAQoAogBIgVBk4CAgHhHBEAgBCkClAEhCiAEKQKMASEJDAMLIAYgCTcDACAGIAs3AwggBkEQaiEGIAggAUEBaiIBRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgBTYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENs8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAnRqNQIAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAjUCACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENg8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBA3RqKQMAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAikDACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuWDAIFfwV+IwBBoAJrIgQkACABQQxqENk8IQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAFELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAMgDacgCadqIgdBAXRqMwEAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghAQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiAUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgAjMBACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghAQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCiAEiAUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkECaiECIAggBUEBaiIFRw0ACwsgBEGIAWoiAhCXKSAEQfAAaiIBKAIAIQYgBCgCdCEDIAEgBEGQAWoiBSkCADcDACAEKQNoIQkgBCAEKQKIATcDaCAEQQA2AnggBCAJNwKUASAEQQA2ApABIAQgAzYCjAEgBCAGNgKIASAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAogBNwIIIAFBEGogBSkCADcCACABQRhqIARBmAFqIgcoAgA2AgAgBCADNgLwASAEIAY2AuwBIAQgATYC6AEgBEH8AGoiASAEQegBahDiGSAHIARB4ABqKQIANwMAIAUgBEHYAGopAgA3AwAgBCAEKQJQNwOIASAAIAEgAhDLHSAEQegAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHoAGoQzy8gBCgCUCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQdAAahD7HgsgBEGgAmokAAuJFwIQfwJ+IwBBsAFrIgIkACACQSxqIAFBGGoiDhDmCwJAAkACQAJAAkACQCACLQA4IgdFBEAgASgCBCIFIAEoAggiCUEMbGohCyMAQSBrIgQkACAEQRRqIAsgBWtBDG4iDEEAQQRBDBCgGCAEKAIYIQMgBCgCFEEBRg0GIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAM2AggjAEEQayIIJAAgBEEIaiIGKAIAIAYoAggiA2sgDEkEQCAGIAMgDEEEQQwQ3iggBigCCCEDCyAIIAYoAgQ2AgwgCCADNgIIIAggBkEIajYCBCAFIAsgCEEEahDeGSAIQRBqJAAgAkE8aiIDQQhqIAooAgA2AgAgAyAEKQIINwIADAELAkAgASgCLCIFRQRAIAJBADYCSAwBCwJAIAEoAigiBCABKAI4IgNHBEAgAUEsaiEFIAQNASACQcgAaiAFEKA2DAILIAUgBSgCACIEQQFqNgIAIARBAEgNAyACIAU2AkggAiABKQIwNwJMDAELIAJBoAFqIgcgASgCPCIIIARqEPcvIAJBIGogBxCGPSACKAIkIQcgAigCICACQRhqIAUQ3DsgByACKAIYIAIoAhwgBCADIAgQhAkaIAIoAqgBIQcgAigCrAEhBSACIAIpAqABNwJsIAJBADYCaCACIAU2AmQgAiAHNgJgIAJBEGogAkHgAGoQ1zsgAigCECEEQRxBBBCtNiIHRQ0DIAdCgYCAgBA3AgAgByACKQJgNwIIIAdBEGogAkHoAGopAgA3AgAgB0EYaiACQfAAaigCADYCACACIAU2AlAgAiAENgJMIAIgBzYCSCACLQA4IQcLIAEoAgghCSABKAIEIQUgAkHsAGogAkHQAGooAgA2AgAgAkEBNgJgIAIgAikCSDcCZCACIAU2AnAgAiAFIAlBDGxqNgJ0IwBBIGsiBCQAIAJB4ABqIggoAhAhBgJAIAgoAgAiA0ECRwRAIAZFDQEgCCgCFCAGa0EMbiADaiEDDAELIAZFBEBBACEDDAELIAgoAhQgBmtBDG4hAwsgBEEUaiADQQBBBEEMEKAYIAQoAhghAyAEKAIUQQFGDQUgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIQMjAEEQayILJAAgCCgCECEKAkACQCAIKAIAIgZBAkcEQCAKRQ0BIAgoAhQgCmtBDG4gBmohBgwBCyAKRQRAIANBCGohCgwCCyAIKAIUIAprQQxuIQYLIANBCGohCiAGIAMoAgAgAygCCCINa00NACADIA0gBkEEQQwQ3igLIAsgAykCBEIgiTcCCCALIAo2AgQgC0EEaiEDIAgoAgAiBkECRiAGQQFxRXJFBEAgAyADKAIEIgZBAWo2AgQgAygCCCAGQQxsaiIGIAgpAgQ3AgAgBkEIaiAIQQxqKAIANgIACyACQTxqIQYCQCAIKAIQIgoEQCAKIAgoAhQgAxDeGQwBCyADKAIAIAMoAgQ2AgALIAtBEGokACAGQQhqIAwoAgA2AgAgBiAEKQIINwIACyAEQSBqJAAgAkE4aiEGIAIoAjQgB0H/AXFqrSESIAItADlFBEAgAigCRCEHDAQLQQAhBCACQQA2AlwgAkKAgICAgAE3AlQgEkIBfCESIAUgCUEMbGohCEEBIQdBACEJQQEhAwNAAkAgCUEBcQRAIAUgCEcNAQwFCyADIAggBWtBDG5PDQQgBSADQQxsaiEFCyAFNQIIIRMgAigCVCAHQQFrRgRAIAJB1ABqQZSdhwEQsygLIAVBDGohBSACKAJYIARqIBM3AwAgEkIBfCESIARBCGohBCACIAc2AlxBASEJIAdBAWohB0EAIQMMAAsACwALQQRBHBCjPQALIAJB6ABqIAJB3ABqKAIANgIAIAIgAikCVDcDYCACQaABaiACQeAAahC9GCACKAJEIgcgAigCPEYEQCACQTxqQfSchwEQkCgLIAIoAkAgB0EMbGoiBSACKQKgATcCACAFQQhqIAJBqAFqKAIANgIAIAIgB0EBaiIHNgJECyACKAJAIQUgAiAGNgJ4IAIgBSAHQQxsajYCdCACIAU2AnAgAkECNgJoIAJBAjYCYCACQaABaiEIIwBBMGsiBCQAIAJB4ABqIgMoAhghCSADKAIUIQYgAygCECEFAkACQAJAAkACfwNAIAVFIAUgBkZyDQIgAyAFQQxqIgc2AhAgBSgCAARAIAVBBGooAgAMAgsgByEFIAktAABBAUcNAAtBAAshBSAEQRBqIglBBEEAQQRBBBCgGCAEKAIUIQcgBCgCEEEBRg0CIAQoAhgiBiAFNgIAIARBDGoiC0EBNgIAIAQgBjYCCCAEIAc2AgQgBEEoaiADQRhqKAIANgIAIARBIGogA0EQaikCADcDACAEQRhqIANBCGopAgA3AwAgBCADKQIANwMQIARBBGohAyAJKAIQIQcgCSgCGCEKIAkoAhQhDANAIAciBUUgBSAMRnJFBEAgCSAFQQxqIgc2AhACfyAFKAIABEAgBUEEaigCAAwBCyAKLQAAQQFHDQJBAAshDSADKAIIIgYgAygCAEYEQCADIAZBAUEEQQQQ3igLIAVBDGohByADKAIEIAZBAnRqIA02AgAgAyAGQQFqNgIIDAELCyAIQQhqIAsoAgA2AgAgCCAEKQIENwIADAELIAhBADYCCCAIQoCAgIDAADcCAAsgBEEwaiQADAELIAcgBCgCGEHUnIcBEP0vAAsgAkEIaiAIQeSchwEQmCEgAigCDCENIAIoAgghDEEAIQcgAkEANgKoASACQoCAgIDAADcCoAECQAJAAn8gDi0AACIPQSJGBEAgASgCFEUEQEEAQQBBhJ2HARDDIQALIAJB4ABqIgUgASgCEBCNBEHAAEEIEK02IgdFDQIgByAFQcAA/AoAAEEAIQlBBAwBCyABKAIUIQkgASgCEAshBSMAQSBrIgQkACAEQRRqIAUgCUHEAGxqIgYgBWtBxABuQQBBBEEEEKAYIAQoAhghAyAEKAIUQQFGBEAMAwsgBEEQaiIQQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCMAQRBrIggkACAGIAVrQcQAbiILIARBCGoiCSgCACAJKAIIIgNrSwRAIAkgAyALQQRBBBDeKCAJKAIIIQMLIAJB4ABqIQsgCCAJKAIENgIMIAggAzYCCCAIIAlBCGo2AgQjAEFAaiIJJAAgCEEEaiIKKAIEIQMgCigCACERAkACQCAFIAZHBEAgCigCCCADQQJ0aiEKIAYgBWtBxABuIQYDQCAJIAUQjQRBwABBCBCtNiIORQ0CIA4gCUHAAPwKAAAgCiAONgIAIAVBxABqIQUgCkEEaiEKIANBAWohAyAGQQFrIgYNAAsLIBEgAzYCACAJQUBrJAAMAQtBCEHAABCjPQALIAhBEGokACALQQhqIBAoAgA2AgAgCyAEKQIINwIAIARBIGokACACIAtB5JyHARCYIQJ/IA9FBEAgASgCJAwBCyABKAJAQQAgASgCLBsLIQggAigCBCEEIAIoAgAhAyACQegAaiIJIAJBxABqKAIANgIAIAIgAikCPDcDYEEgQQQQrTYiBUUNASAFIAIpA2A3AgAgBSAHNgIcIAUgAzYCFCAFIAw2AgwgBSAENgIYIAUgDTYCECAFQQhqIAkoAgA2AgAgACAFNgI4IABBxBw2AjQgACAHNgIwIAAgAzYCLCAAIAw2AiggACAErTcDICAAIBI3AxggACAIrTcDCCAAIAE1Aig3AxAgACABNQIkNwMAIAIoAqgBIgAEQCACKAKkASEBA0AgARClHiABQcQAaiEBIABBAWsiAA0ACwsgAkGgAWpBBEHEABDgHiACQSxqQQRBDBDgHiACQbABaiQADwtBCEHAABCjPQALQQRBIBCjPQALIAMgBCgCHEHUnIcBEP0vAAuPDAIFfwV+IwBBoAJrIgQkACABQQxqKAIIIQggBEHQAGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJwIAQgBTYCbCAEQcAANgJoIAcEQCAGQQAgB/wLAAsgBCAINgJ4IAQgBzYCdCAEKAJQRQ0DIAQoAmQgBCgCYEYNBCAEQYgBaiAEQdAAahDINCAEQagBaiEHIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAQNAAkAgBCkDsAEiClBFBEAgBCkDuAEhCQwBCwNAAn4CQCAEKQOYASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOYASAJp0EBcUUNACAEIAQpA6ABNwPwAQwBCyAEKAKoAUUNASAEQegBaiAHELYqIAQpA+gBIQkLIAlCAFINAgsgBEIDNwOYAQsgBCkDiAEiCUICUQ0JIARCADcDiAEgBCkDkAEMAQsgBCkD8AELIQogCadBAXFFDQcgBCAEKQO4AUJAfSIJNwO4ASAEIAo3A7ABIApQDQALCyAEIApCASAKeiINhoU3A7ABIAEgDacgCadqIgNqMQAAIQkgBCALNwOIAiAEIAw3A4ACIARCADcDyAEgBCAJNwPAASAEQQA2AkwgBEEwaiAJQgAgDCALIARBzABqEPYMIAQoAkwEQCAEQQI2AuwBIARBrJD/ADYC6AEgBEICNwL0ASAEQYQMNgKcAiAEQYQMNgKUAiAEIARBkAJqNgLwASAEIARBgAJqNgKYAiAEIARBwAFqNgKQAiAEQdgBaiAEQegBahCZDiAEKQLYASEJIAQpAuABIQpBiICAgHghBQwHCyAEQegBaiAEKQMwIgkgBCkDOCIKIAIQrQ4gBCgC6AEiBUGTgICAeEcEQCAEKQL0ASEKIAQpAuwBIQkMBwUgBiADQQR0aiIDIAo3AwggAyAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBiAFqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAiABKAIQIQNBACEBA0AgASADajEAACELIAQgCTcDmAIgBCAKNwOQAiAEQgA3A4gCIAQgCzcDgAIgBEEANgIsIARBEGogC0IAIAogCSAEQSxqEPYMIAQoAiwEQCAEQQI2AowBIARBrJD/ADYCiAEgBEICNwKUASAEQYQMNgLgASAEQYQMNgLYASAEIARB1AFqNgKQASAEIARBkAJqNgLcASAEIARBgAJqNgLUASAEQewBaiAEQYgBahCZDiAEKQLsASEJIAQpAvQBIQpBiICAgHghBQwDCyAEQYgBaiAEKQMQIgsgBCkDGCIMIAIQrQ4gBCgCiAEiBUGTgICAeEcEQCAEKQKUASEKIAQpAowBIQkMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgCCABQQFqIgFHDQALCyAEQYgBaiICEJcpIARB8ABqIgEoAgAhBiAEKAJ0IQMgASAEQZABaiIFKQIANwMAIAQpA2ghCSAEIAQpAogBNwNoIARBADYCeCAEIAk3ApQBIARBADYCkAEgBCADNgKMASAEIAY2AogBIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCiAE3AgggAUEQaiAFKQIANwIAIAFBGGogBEGYAWoiBygCADYCACAEIAM2AvABIAQgBjYC7AEgBCABNgLoASAEQfwAaiIBIARB6AFqEOIZIAcgBEHgAGopAgA3AwAgBSAEQdgAaikCADcDACAEIAQpAlA3A4gBIAAgASACEMsdIARB6ABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACAFNgIEIABBKToAACAEQegAahDPLyAEKAJQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARB0ABqEPseCyAEQaACaiQAC8sKAhR/B34jAEEwayIGJAAgA0EBayEFAkAgAwRAIANBAmshBAJAIANBAUcEQCACIAVBAnRqKAIAIRIgAiAEQQJ0ajUCACEcIAZBGGogASgCCCIIIANrIhVBAWoiCkH0o4gBEL8VIAYoAiAhCSAGKAIcIQ4gBigCGCETIAoNASABKAIAIQUMAwsgBEEBQeSjiAEQwyEACyABKAIEIg8gCEECdCADQQJ0IhZraiEQQgAgEq0iGkIghiIdfSEeAkACQAJAA0ACQAJAIAhFDQAgDyAIQQJ0aiIUQQRrIgRFDQAgCEECayEFIAhBAUsEQCAEKAIAIQQgDyAFQQJ0ajUCACEbIAetIRgCfyAHIBJPBEAgBK0gGHwhGUF/DAELIAStIBhCIIaEIhggGCAagCIYIBp+fSEZIBinCyELIBlC/////w9WDQIgHiAZQiCGfCAbfCEYA0AgGCAdfCIYIAutIBx+Wg0DIAtBAWshCyAZIBp8IhlCgICAgBBUDQALDAILIAVBAUGkpIgBEMMhAAtBlKSIARCyOwALIAggCkEBayIKSQ0BIAYgFDYCHCAGIA8gCkECdCIXaiIMNgIYAkAgBkEYahCeNiIERQ0AIAMgBCADIARJGyENIAutIRtC/////w8hGSAQIQUgAiEEA0AgBSAZIAU1AgB8IBsgBDUCAH59Qv////8ffSIYPgIAIBhCIIghGSAFQQRqIQUgBEEEaiEEIA1BAWsiDQ0ACyAHIBmnQX9zTw0AIAMgCCAKa0sNAyALQQFrIQsgBiAMNgIYIAYgDCAWaiIRNgIcIAZBGGoQnjYiBEUNACADIAQgAyAESRshDUEAIQVBACEHA0AgBSAQaiIEIAcgBCgCACIHIAIgBWooAgBqIgxqIgQ2AgAgBCAMSSAHIAxLciIEIQcgBUEEaiEFIA1BAWsiDQ0ACyAEIBEgFEdxRQ0AIBEgESgCAEEBajYCAAsgCSAVTQ0DIA4gF2ogCzYCACABIAhBAWsiCDYCCCAQQQRrIRAgDyAIQQJ0aigCACEHIAoNAAsgASgCACEFDAQLIAogCEG0pIgBEK87AAsgBkEANgIoIAZBATYCHCAGQdyiiAE2AhggBkIENwIgIAZBGGpB5KKIARDvLAALIAogCUHEpIgBEMMhAAsgBUEAQdSjiAEQwyEACyAFIAhGBEAgAUGEpIgBEJ0oCyAIQQJ0IgUgASgCBGogBzYCACABIAhBAWoiBzYCCAJAIAEoAgQiAyAHQQJ0akEEayICRQ0AIAIoAgANACAIQQJqIQQCQANAIAVBfEYEQEEAIQQMAgsgBEEBayEEIAMgBWogBUEEayEFKAIARQ0ACyAEIAdLDQELIAEgBDYCCCAEIQcLAkACQCABKAIAQQJ2IAdLBEAgBkEQaiABIAdBBEEEEPQUIAYoAhAiAkGBgICAeEcNAQsgBiAJNgIgIAYgEzYCGCAGIA42AhwgCUUNASAOIAlBAnQiBWpBBGsiAkUNASACKAIADQEgDkEEayEDIAlB/////wNxIQQCQANAIAVFBEBBACEFDAILIARBAWshBCADIAVqIAVBBGshBSgCAEUNAAsgBEEBaiIFIAlLDQILIAYgBTYCICAFIQkMAQsgAiAGKAIUQfSkiAEQ/S8ACwJAIAkgE0ECdk8NACAGQQhqIAZBGGogCUEEQQQQ9BQgBigCCCICQYGAgIB4Rg0AIAIgBigCDEH0pIgBEP0vAAsgACAGKQIYNwIAIABBCGogBkEgaigCADYCACAAQRRqIAFBCGooAgA2AgAgACABKQIANwIMIAZBMGokAAuH6wUCDH8HfiMAQZACayIIJAACQCADQcEASQRAIAIhCyAAKAIIIAAoAhhrQQN0IAAoAhwiBGsiByACIANsTw0BIAMEQCAHIANuIQsMAgtBmLfOABDiKwALQci2zgBBMEGIt84AEJ8pAAsCQAJAAkACQAJAAkACQAJAIARFIAtFcg0AIAEhBwNAIAhBiAFqIAAgAxDfDSAIKAKIAUUNAyACIAVGDQIgByAIKQOQATcDACAFQQFqIgUgC08NASAHQQhqIQcgACgCHA0ACwsgCyAFayIMQcAASQRAIAUhBwwGCyADQQN0IQ0gACgCCCIOIAAoAhgiCWshBiABIAVBA3RqIQQgACgCBCEPA0AgBUG/f0sNAyAFQUBrIgcgAksNBCAJIA5LDQUgCSAPaiEFIwBBMGsiCiQAIAogAzYCDAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMOQQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQQsgBEEAQYAE/AsADEELIAZBB00EQAxJCyAEIAUpAAAiEEI/iDcD+AMgBCAQQgGDNwMAIAQgEEI+iEIBgzcD8AMgBCAQQj2IQgGDNwPoAyAEIBBCPIhCAYM3A+ADIAQgEEI7iEIBgzcD2AMgBCAQQjqIQgGDNwPQAyAEIBBCOYhCAYM3A8gDIAQgEEI4iEIBgzcDwAMgBCAQQjeIQgGDNwO4AyAEIBBCNohCAYM3A7ADIAQgEEI1iEIBgzcDqAMgBCAQQjSIQgGDNwOgAyAEIBBCM4hCAYM3A5gDIAQgEEIyiEIBgzcDkAMgBCAQQjGIQgGDNwOIAyAEIBBCMIhCAYM3A4ADIAQgEEIviEIBgzcD+AIgBCAQQi6IQgGDNwPwAiAEIBBCLYhCAYM3A+gCIAQgEEIsiEIBgzcD4AIgBCAQQiuIQgGDNwPYAiAEIBBCKohCAYM3A9ACIAQgEEIpiEIBgzcDyAIgBCAQQiiIQgGDNwPAAiAEIBBCJ4hCAYM3A7gCIAQgEEImiEIBgzcDsAIgBCAQQiWIQgGDNwOoAiAEIBBCJIhCAYM3A6ACIAQgEEIjiEIBgzcDmAIgBCAQQiKIQgGDNwOQAiAEIBBCIYhCAYM3A4gCIAQgEEIgiEIBgzcDgAIgBCAQQh+IQgGDNwP4ASAEIBBCHohCAYM3A/ABIAQgEEIdiEIBgzcD6AEgBCAQQhyIQgGDNwPgASAEIBBCG4hCAYM3A9gBIAQgEEIaiEIBgzcD0AEgBCAQQhmIQgGDNwPIASAEIBBCGIhCAYM3A8ABIAQgEEIXiEIBgzcDuAEgBCAQQhaIQgGDNwOwASAEIBBCFYhCAYM3A6gBIAQgEEIUiEIBgzcDoAEgBCAQQhOIQgGDNwOYASAEIBBCEohCAYM3A5ABIAQgEEIRiEIBgzcDiAEgBCAQQhCIQgGDNwOAASAEIBBCD4hCAYM3A3ggBCAQQg6IQgGDNwNwIAQgEEINiEIBgzcDaCAEIBBCDIhCAYM3A2AgBCAQQguIQgGDNwNYIAQgEEIKiEIBgzcDUCAEIBBCCYhCAYM3A0ggBCAQQgiIQgGDNwNAIAQgEEIHiEIBgzcDOCAEIBBCBohCAYM3AzAgBCAQQgWIQgGDNwMoIAQgEEIEiEIBgzcDICAEIBBCA4hCAYM3AxggBCAQQgKIQgGDNwMQIAQgEEIBiEIBgzcDCAxACyAGQQ9NBEAMSAsgBCAFKQAAIhBCPog3A/gBIAQgEEIDgzcDACAEIBBCPIhCA4M3A/ABIAQgEEI6iEIDgzcD6AEgBCAQQjiIQgODNwPgASAEIBBCNohCA4M3A9gBIAQgEEI0iEIDgzcD0AEgBCAQQjKIQgODNwPIASAEIBBCMIhCA4M3A8ABIAQgEEIuiEIDgzcDuAEgBCAQQiyIQgODNwOwASAEIBBCKohCA4M3A6gBIAQgEEIoiEIDgzcDoAEgBCAQQiaIQgODNwOYASAEIBBCJIhCA4M3A5ABIAQgEEIiiEIDgzcDiAEgBCAQQiCIQgODNwOAASAEIBBCHohCA4M3A3ggBCAQQhyIQgODNwNwIAQgEEIaiEIDgzcDaCAEIBBCGIhCA4M3A2AgBCAQQhaIQgODNwNYIAQgEEIUiEIDgzcDUCAEIBBCEohCA4M3A0ggBCAQQhCIQgODNwNAIAQgEEIOiEIDgzcDOCAEIBBCDIhCA4M3AzAgBCAQQgqIQgODNwMoIAQgEEIIiEIDgzcDICAEIBBCBohCA4M3AxggBCAQQgSIQgODNwMQIAQgEEICiEIDgzcDCCAEIAUpAAgiEEI+iDcD+AMgBCAQQgODNwOAAiAEIBBCPIhCA4M3A/ADIAQgEEI6iEIDgzcD6AMgBCAQQjiIQgODNwPgAyAEIBBCNohCA4M3A9gDIAQgEEI0iEIDgzcD0AMgBCAQQjKIQgODNwPIAyAEIBBCMIhCA4M3A8ADIAQgEEIuiEIDgzcDuAMgBCAQQiyIQgODNwOwAyAEIBBCKohCA4M3A6gDIAQgEEIoiEIDgzcDoAMgBCAQQiaIQgODNwOYAyAEIBBCJIhCA4M3A5ADIAQgEEIiiEIDgzcDiAMgBCAQQiCIQgODNwOAAyAEIBBCHohCA4M3A/gCIAQgEEIciEIDgzcD8AIgBCAQQhqIQgODNwPoAiAEIBBCGIhCA4M3A+ACIAQgEEIWiEIDgzcD2AIgBCAQQhSIQgODNwPQAiAEIBBCEohCA4M3A8gCIAQgEEIQiEIDgzcDwAIgBCAQQg6IQgODNwO4AiAEIBBCDIhCA4M3A7ACIAQgEEIKiEIDgzcDqAIgBCAQQgiIQgODNwOgAiAEIBBCBohCA4M3A5gCIAQgEEIEiEIDgzcDkAIgBCAQQgKIQgODNwOIAgw/CyAGQRdNBEAMRwsgBCAFKQAAIhBCB4M3AwAgBCAQQjyIQgeDNwOgASAEIBBCOYhCB4M3A5gBIAQgEEI2iEIHgzcDkAEgBCAQQjOIQgeDNwOIASAEIBBCMIhCB4M3A4ABIAQgEEItiEIHgzcDeCAEIBBCKohCB4M3A3AgBCAQQieIQgeDNwNoIAQgEEIkiEIHgzcDYCAEIBBCIYhCB4M3A1ggBCAQQh6IQgeDNwNQIAQgEEIbiEIHgzcDSCAEIBBCGIhCB4M3A0AgBCAQQhWIQgeDNwM4IAQgEEISiEIHgzcDMCAEIBBCD4hCB4M3AyggBCAQQgyIQgeDNwMgIAQgEEIJiEIHgzcDGCAEIBBCBohCB4M3AxAgBCAQQgOIQgeDNwMIIAQgBSkACCIRQjuIQgeDNwPIAiAEIBFCOIhCB4M3A8ACIAQgEUI1iEIHgzcDuAIgBCARQjKIQgeDNwOwAiAEIBFCL4hCB4M3A6gCIAQgEUIsiEIHgzcDoAIgBCARQimIQgeDNwOYAiAEIBFCJohCB4M3A5ACIAQgEUIjiEIHgzcDiAIgBCARQiCIQgeDNwOAAiAEIBFCHYhCB4M3A/gBIAQgEUIaiEIHgzcD8AEgBCARQheIQgeDNwPoASAEIBFCFIhCB4M3A+ABIAQgEUIRiEIHgzcD2AEgBCARQg6IQgeDNwPQASAEIBFCC4hCB4M3A8gBIAQgEUIIiEIHgzcDwAEgBCARQgWIQgeDNwO4ASAEIBFCAohCB4M3A7ABIAQgEUIBhkIGgyAQQj+IhDcDqAEgBCAFKQAQIhBCPYg3A/gDIAQgEEI6iEIHgzcD8AMgBCAQQjeIQgeDNwPoAyAEIBBCNIhCB4M3A+ADIAQgEEIxiEIHgzcD2AMgBCAQQi6IQgeDNwPQAyAEIBBCK4hCB4M3A8gDIAQgEEIoiEIHgzcDwAMgBCAQQiWIQgeDNwO4AyAEIBBCIohCB4M3A7ADIAQgEEIfiEIHgzcDqAMgBCAQQhyIQgeDNwOgAyAEIBBCGYhCB4M3A5gDIAQgEEIWiEIHgzcDkAMgBCAQQhOIQgeDNwOIAyAEIBBCEIhCB4M3A4ADIAQgEEINiEIHgzcD+AIgBCAQQgqIQgeDNwPwAiAEIBBCB4hCB4M3A+gCIAQgEEIEiEIHgzcD4AIgBCAQQgGIQgeDNwPYAiAEIBBCAoZCBIMgEUI+iIQ3A9ACDD4LIAZBH00EQAxGCyAEIAUpAAAiEEI8iDcDeCAEIBBCD4M3AwAgBCAFKQAIIhFCPIg3A/gBIAQgEUIPgzcDgAEgBCAQQjiIQg+DNwNwIAQgEEI0iEIPgzcDaCAEIBBCMIhCD4M3A2AgBCAQQiyIQg+DNwNYIAQgEEIoiEIPgzcDUCAEIBBCJIhCD4M3A0ggBCAQQiCIQg+DNwNAIAQgEEIciEIPgzcDOCAEIBBCGIhCD4M3AzAgBCAQQhSIQg+DNwMoIAQgEEIQiEIPgzcDICAEIBBCDIhCD4M3AxggBCAQQgiIQg+DNwMQIAQgEEIEiEIPgzcDCCAEIBFCOIhCD4M3A/ABIAQgEUI0iEIPgzcD6AEgBCARQjCIQg+DNwPgASAEIBFCLIhCD4M3A9gBIAQgEUIoiEIPgzcD0AEgBCARQiSIQg+DNwPIASAEIBFCIIhCD4M3A8ABIAQgEUIciEIPgzcDuAEgBCARQhiIQg+DNwOwASAEIBFCFIhCD4M3A6gBIAQgEUIQiEIPgzcDoAEgBCARQgyIQg+DNwOYASAEIBFCCIhCD4M3A5ABIAQgEUIEiEIPgzcDiAEgBCAFKQAQIhBCPIg3A/gCIAQgEEIPgzcDgAIgBCAFKQAYIhFCPIg3A/gDIAQgEUIPgzcDgAMgBCAQQjiIQg+DNwPwAiAEIBBCNIhCD4M3A+gCIAQgEEIwiEIPgzcD4AIgBCAQQiyIQg+DNwPYAiAEIBBCKIhCD4M3A9ACIAQgEEIkiEIPgzcDyAIgBCAQQiCIQg+DNwPAAiAEIBBCHIhCD4M3A7gCIAQgEEIYiEIPgzcDsAIgBCAQQhSIQg+DNwOoAiAEIBBCEIhCD4M3A6ACIAQgEEIMiEIPgzcDmAIgBCAQQgiIQg+DNwOQAiAEIBBCBIhCD4M3A4gCIAQgEUI4iEIPgzcD8AMgBCARQjSIQg+DNwPoAyAEIBFCMIhCD4M3A+ADIAQgEUIsiEIPgzcD2AMgBCARQiiIQg+DNwPQAyAEIBFCJIhCD4M3A8gDIAQgEUIgiEIPgzcDwAMgBCARQhyIQg+DNwO4AyAEIBFCGIhCD4M3A7ADIAQgEUIUiEIPgzcDqAMgBCARQhCIQg+DNwOgAyAEIBFCDIhCD4M3A5gDIAQgEUIIiEIPgzcDkAMgBCARQgSIQg+DNwOIAww9CyAGQSdNBEAMRQsgBCAFKQAAIhFCH4M3AwAgBCARQjeIQh+DNwNYIAQgEUIyiEIfgzcDUCAEIBFCLYhCH4M3A0ggBCARQiiIQh+DNwNAIAQgEUIjiEIfgzcDOCAEIBFCHohCH4M3AzAgBCARQhmIQh+DNwMoIAQgEUIUiEIfgzcDICAEIBFCD4hCH4M3AxggBCARQgqIQh+DNwMQIAQgEUIFiEIfgzcDCCAEIAUpAAgiEEI4iEIfgzcDwAEgBCAQQjOIQh+DNwO4ASAEIBBCLohCH4M3A7ABIAQgEEIpiEIfgzcDqAEgBCAQQiSIQh+DNwOgASAEIBBCH4hCH4M3A5gBIAQgEEIaiEIfgzcDkAEgBCAQQhWIQh+DNwOIASAEIBBCEIhCH4M3A4ABIAQgEEILiEIfgzcDeCAEIBBCBohCH4M3A3AgBCAQQgGIQh+DNwNoIAQgEEIEhkIQgyARQjyIhDcDYCAEIAUpABAiEUI5iEIfgzcDqAIgBCARQjSIQh+DNwOgAiAEIBFCL4hCH4M3A5gCIAQgEUIqiEIfgzcDkAIgBCARQiWIQh+DNwOIAiAEIBFCIIhCH4M3A4ACIAQgEUIbiEIfgzcD+AEgBCARQhaIQh+DNwPwASAEIBFCEYhCH4M3A+gBIAQgEUIMiEIfgzcD4AEgBCARQgeIQh+DNwPYASAEIBFCAohCH4M3A9ABIAQgBSkAGCISQjqIQh+DNwOQAyAEIBJCNYhCH4M3A4gDIAQgEkIwiEIfgzcDgAMgBCASQiuIQh+DNwP4AiAEIBJCJohCH4M3A/ACIAQgEkIhiEIfgzcD6AIgBCASQhyIQh+DNwPgAiAEIBJCF4hCH4M3A9gCIAQgEkISiEIfgzcD0AIgBCASQg2IQh+DNwPIAiAEIBJCCIhCH4M3A8ACIAQgEkIDiEIfgzcDuAIgBCARQgOGQhiDIBBCPYiENwPIASAEIBJCAoZCHIMgEUI+iIQ3A7ACIAQgBSkAICIQQjuINwP4AyAEIBBCNohCH4M3A/ADIAQgEEIxiEIfgzcD6AMgBCAQQiyIQh+DNwPgAyAEIBBCJ4hCH4M3A9gDIAQgEEIiiEIfgzcD0AMgBCAQQh2IQh+DNwPIAyAEIBBCGIhCH4M3A8ADIAQgEEITiEIfgzcDuAMgBCAQQg6IQh+DNwOwAyAEIBBCCYhCH4M3A6gDIAQgEEIEiEIfgzcDoAMgBCAQQgGGQh6DIBJCP4iENwOYAww8CyAGQS9NBEAMRAsgBCAFKQAAIhFCP4M3AwAgBCARQjaIQj+DNwNIIAQgEUIwiEI/gzcDQCAEIBFCKohCP4M3AzggBCARQiSIQj+DNwMwIAQgEUIeiEI/gzcDKCAEIBFCGIhCP4M3AyAgBCARQhKIQj+DNwMYIAQgEUIMiEI/gzcDECAEIBFCBohCP4M3AwggBCAFKQAIIhBCOIhCP4M3A6ABIAQgEEIyiEI/gzcDmAEgBCAQQiyIQj+DNwOQASAEIBBCJohCP4M3A4gBIAQgEEIgiEI/gzcDgAEgBCAQQhqIQj+DNwN4IAQgEEIUiEI/gzcDcCAEIBBCDohCP4M3A2ggBCAQQgiIQj+DNwNgIAQgEEICiEI/gzcDWCAEIBBCBIZCMIMgEUI8iIQ3A1AgBCAFKQAQIhFCOog3A/gBIAQgBSkAGCISQj+DNwOAAiAEIBFCNIhCP4M3A/ABIAQgEUIuiEI/gzcD6AEgBCARQiiIQj+DNwPgASAEIBFCIohCP4M3A9gBIAQgEUIciEI/gzcD0AEgBCARQhaIQj+DNwPIASAEIBFCEIhCP4M3A8ABIAQgEUIKiEI/gzcDuAEgBCARQgSIQj+DNwOwASAEIBJCNohCP4M3A8gCIAQgEkIwiEI/gzcDwAIgBCASQiqIQj+DNwO4AiAEIBJCJIhCP4M3A7ACIAQgEkIeiEI/gzcDqAIgBCASQhiIQj+DNwOgAiAEIBJCEohCP4M3A5gCIAQgEkIMiEI/gzcDkAIgBCASQgaIQj+DNwOIAiAEIBFCAoZCPIMgEEI+iIQ3A6gBIAQgBSkAICIQQjiIQj+DNwOgAyAEIBBCMohCP4M3A5gDIAQgEEIsiEI/gzcDkAMgBCAQQiaIQj+DNwOIAyAEIBBCIIhCP4M3A4ADIAQgEEIaiEI/gzcD+AIgBCAQQhSIQj+DNwPwAiAEIBBCDohCP4M3A+gCIAQgEEIIiEI/gzcD4AIgBCAQQgKIQj+DNwPYAiAEIBBCBIZCMIMgEkI8iIQ3A9ACIAQgBSkAKCIRQjqINwP4AyAEIBFCNIhCP4M3A/ADIAQgEUIuiEI/gzcD6AMgBCARQiiIQj+DNwPgAyAEIBFCIohCP4M3A9gDIAQgEUIciEI/gzcD0AMgBCARQhaIQj+DNwPIAyAEIBFCEIhCP4M3A8ADIAQgEUIKiEI/gzcDuAMgBCARQgSIQj+DNwOwAyAEIBFCAoZCPIMgEEI+iIQ3A6gDDDsLIAZBN00EQAxDCyAEIAUpAAAiEEL/AIM3AwAgBCAQQjiIQv8AgzcDQCAEIBBCMYhC/wCDNwM4IAQgEEIqiEL/AIM3AzAgBCAQQiOIQv8AgzcDKCAEIBBCHIhC/wCDNwMgIAQgEEIViEL/AIM3AxggBCAQQg6IQv8AgzcDECAEIBBCB4hC/wCDNwMIIAQgBSkACCIRQjeIQv8AgzcDiAEgBCARQjCIQv8AgzcDgAEgBCARQimIQv8AgzcDeCAEIBFCIohC/wCDNwNwIAQgEUIbiEL/AIM3A2ggBCARQhSIQv8AgzcDYCAEIBFCDYhC/wCDNwNYIAQgEUIGiEL/AIM3A1AgBCARQgGGQv4AgyAQQj+IhDcDSCAEIAUpABAiEEI2iEL/AIM3A9ABIAQgEEIviEL/AIM3A8gBIAQgEEIoiEL/AIM3A8ABIAQgEEIhiEL/AIM3A7gBIAQgEEIaiEL/AIM3A7ABIAQgEEITiEL/AIM3A6gBIAQgEEIMiEL/AIM3A6ABIAQgEEIFiEL/AIM3A5gBIAQgBSkAGCISQjWIQv8AgzcDmAIgBCASQi6IQv8AgzcDkAIgBCASQieIQv8AgzcDiAIgBCASQiCIQv8AgzcDgAIgBCASQhmIQv8AgzcD+AEgBCASQhKIQv8AgzcD8AEgBCASQguIQv8AgzcD6AEgBCASQgSIQv8AgzcD4AEgBCAQQgKGQvwAgyARQj6IhDcDkAEgBCASQgOGQvgAgyAQQj2IhDcD2AEgBCAFKQAgIhBCNIhC/wCDNwPgAiAEIBBCLYhC/wCDNwPYAiAEIBBCJohC/wCDNwPQAiAEIBBCH4hC/wCDNwPIAiAEIBBCGIhC/wCDNwPAAiAEIBBCEYhC/wCDNwO4AiAEIBBCCohC/wCDNwOwAiAEIBBCA4hC/wCDNwOoAiAEIBBCBIZC8ACDIBJCPIiENwOgAiAEIAUpACgiEUIziEL/AIM3A6gDIAQgEUIsiEL/AIM3A6ADIAQgEUIliEL/AIM3A5gDIAQgEUIeiEL/AIM3A5ADIAQgEUIXiEL/AIM3A4gDIAQgEUIQiEL/AIM3A4ADIAQgEUIJiEL/AIM3A/gCIAQgEUICiEL/AIM3A/ACIAQgEUIFhkLgAIMgEEI7iIQ3A+gCIAQgBSkAMCIQQjmINwP4AyAEIBBCMohC/wCDNwPwAyAEIBBCK4hC/wCDNwPoAyAEIBBCJIhC/wCDNwPgAyAEIBBCHYhC/wCDNwPYAyAEIBBCFohC/wCDNwPQAyAEIBBCD4hC/wCDNwPIAyAEIBBCCIhC/wCDNwPAAyAEIBBCAYhC/wCDNwO4AyAEIBBCBoZCwACDIBFCOoiENwOwAww6CyAGQT9NBEAMQgsgBCAFKQAAIhBCOIg3AzggBCAQQv8BgzcDACAEIAUpAAgiEUI4iDcDeCAEIBFC/wGDNwNAIAQgEEIwiEL/AYM3AzAgBCAQQiiIQv8BgzcDKCAEIBBCIIhC/wGDNwMgIAQgEEIYiEL/AYM3AxggBCAQQhCIQv8BgzcDECAEIBBCCIhC/wGDNwMIIAQgEUIwiEL/AYM3A3AgBCARQiiIQv8BgzcDaCAEIBFCIIhC/wGDNwNgIAQgEUIYiEL/AYM3A1ggBCARQhCIQv8BgzcDUCAEIBFCCIhC/wGDNwNIIAQgBSkAECIQQjiINwO4ASAEIBBCMIhC/wGDNwOwASAEIBBCKIhC/wGDNwOoASAEIBBCIIhC/wGDNwOgASAEIBBCGIhC/wGDNwOYASAEIBBCEIhC/wGDNwOQASAEIBBCCIhC/wGDNwOIASAEIBBC/wGDNwOAASAEIAUpABgiEEI4iDcD+AEgBCAQQv8BgzcDwAEgBCAQQjCIQv8BgzcD8AEgBCAQQiiIQv8BgzcD6AEgBCAQQiCIQv8BgzcD4AEgBCAQQhiIQv8BgzcD2AEgBCAQQhCIQv8BgzcD0AEgBCAQQgiIQv8BgzcDyAEgBCAFKQAgIhBCOIg3A7gCIAQgEEIwiEL/AYM3A7ACIAQgEEIoiEL/AYM3A6gCIAQgEEIgiEL/AYM3A6ACIAQgEEIYiEL/AYM3A5gCIAQgEEIQiEL/AYM3A5ACIAQgEEIIiEL/AYM3A4gCIAQgEEL/AYM3A4ACIAQgBSkAKCIQQjiINwP4AiAEIBBC/wGDNwPAAiAEIBBCMIhC/wGDNwPwAiAEIBBCKIhC/wGDNwPoAiAEIBBCIIhC/wGDNwPgAiAEIBBCGIhC/wGDNwPYAiAEIBBCEIhC/wGDNwPQAiAEIBBCCIhC/wGDNwPIAiAEIAUpADAiEEI4iDcDuAMgBCAQQv8BgzcDgAMgBCAQQjCIQv8BgzcDsAMgBCAQQiiIQv8BgzcDqAMgBCAQQiCIQv8BgzcDoAMgBCAQQhiIQv8BgzcDmAMgBCAQQhCIQv8BgzcDkAMgBCAQQgiIQv8BgzcDiAMgBCAFKQA4IhBCOIg3A/gDIAQgEEL/AYM3A8ADIAQgEEIwiEL/AYM3A/ADIAQgEEIoiEL/AYM3A+gDIAQgEEIgiEL/AYM3A+ADIAQgEEIYiEL/AYM3A9gDIAQgEEIQiEL/AYM3A9ADIAQgEEIIiEL/AYM3A8gDDDkLIAZBxwBNBEAMQQsgBCAFKQAAIhBC/wODNwMAIAQgEEI2iEL/A4M3AzAgBCAQQi2IQv8DgzcDKCAEIBBCJIhC/wODNwMgIAQgEEIbiEL/A4M3AxggBCAQQhKIQv8DgzcDECAEIBBCCYhC/wODNwMIIAQgBSkACCIRQjWIQv8DgzcDaCAEIBFCLIhC/wODNwNgIAQgEUIjiEL/A4M3A1ggBCARQhqIQv8DgzcDUCAEIBFCEYhC/wODNwNIIAQgEUIIiEL/A4M3A0AgBCAFKQAQIhJCNIhC/wODNwOgASAEIBJCK4hC/wODNwOYASAEIBJCIohC/wODNwOQASAEIBJCGYhC/wODNwOIASAEIBJCEIhC/wODNwOAASAEIBJCB4hC/wODNwN4IAQgEUIBhkL+A4MgEEI/iIQ3AzggBCASQgKGQvwDgyARQj6IhDcDcCAEIAUpABgiEEIziEL/A4M3A9gBIAQgEEIqiEL/A4M3A9ABIAQgEEIhiEL/A4M3A8gBIAQgEEIYiEL/A4M3A8ABIAQgEEIPiEL/A4M3A7gBIAQgEEIGiEL/A4M3A7ABIAQgBSkAICIRQjKIQv8DgzcDkAIgBCARQimIQv8DgzcDiAIgBCARQiCIQv8DgzcDgAIgBCARQheIQv8DgzcD+AEgBCARQg6IQv8DgzcD8AEgBCARQgWIQv8DgzcD6AEgBCAFKQAoIhNCMYhC/wODNwPIAiAEIBNCKIhC/wODNwPAAiAEIBNCH4hC/wODNwO4AiAEIBNCFohC/wODNwOwAiAEIBNCDYhC/wODNwOoAiAEIBNCBIhC/wODNwOgAiAEIBBCA4ZC+AODIBJCPYiENwOoASAEIBFCBIZC8AODIBBCPIiENwPgASAEIBNCBYZC4AODIBFCO4iENwOYAiAEIAUpADAiEEIwiEL/A4M3A4ADIAQgEEIniEL/A4M3A/gCIAQgEEIeiEL/A4M3A/ACIAQgEEIViEL/A4M3A+gCIAQgEEIMiEL/A4M3A+ACIAQgEEIDiEL/A4M3A9gCIAQgEEIGhkLAA4MgE0I6iIQ3A9ACIAQgBSkAOCIRQi+IQv8DgzcDuAMgBCARQiaIQv8DgzcDsAMgBCARQh2IQv8DgzcDqAMgBCARQhSIQv8DgzcDoAMgBCARQguIQv8DgzcDmAMgBCARQgKIQv8DgzcDkAMgBCARQgeGQoADgyAQQjmIhDcDiAMgBCAFKQBAIhBCN4g3A/gDIAQgEEIuiEL/A4M3A/ADIAQgEEIliEL/A4M3A+gDIAQgEEIciEL/A4M3A+ADIAQgEEITiEL/A4M3A9gDIAQgEEIKiEL/A4M3A9ADIAQgEEIBiEL/A4M3A8gDIAQgEEIIhkKAAoMgEUI4iIQ3A8ADDDgLIAZBzwBNBEAMQAsgBCAFKQAAIhFC/weDNwMAIAQgEUIyiEL/B4M3AyggBCARQiiIQv8HgzcDICAEIBFCHohC/weDNwMYIAQgEUIUiEL/B4M3AxAgBCARQgqIQv8HgzcDCCAEIAUpAAgiEkIuiEL/B4M3A1ggBCASQiSIQv8HgzcDUCAEIBJCGohC/weDNwNIIAQgEkIQiEL/B4M3A0AgBCASQgaIQv8HgzcDOCAEIAUpABAiEEI0iEL/B4M3A5ABIAQgEEIqiEL/B4M3A4gBIAQgEEIgiEL/B4M3A4ABIAQgEEIWiEL/B4M3A3ggBCAQQgyIQv8HgzcDcCAEIBBCAohC/weDNwNoIAQgEkIEhkLwB4MgEUI8iIQ3AzAgBCAQQgiGQoAGgyASQjiIhDcDYCAEIAUpACAiEUI2iDcD+AEgBCAFKQAoIhJC/weDNwOAAiAEIAUpABgiE0IwiEL/B4M3A8ABIAQgE0ImiEL/B4M3A7gBIAQgE0IciEL/B4M3A7ABIAQgE0ISiEL/B4M3A6gBIAQgE0IIiEL/B4M3A6ABIAQgEUIsiEL/B4M3A/ABIAQgEUIiiEL/B4M3A+gBIAQgEUIYiEL/B4M3A+ABIAQgEUIOiEL/B4M3A9gBIAQgEUIEiEL/B4M3A9ABIAQgEkIyiEL/B4M3A6gCIAQgEkIoiEL/B4M3A6ACIAQgEkIeiEL/B4M3A5gCIAQgEkIUiEL/B4M3A5ACIAQgEkIKiEL/B4M3A4gCIAQgE0IChkL8B4MgEEI+iIQ3A5gBIAQgEUIGhkLAB4MgE0I6iIQ3A8gBIAQgBSkAMCIRQi6IQv8HgzcD2AIgBCARQiSIQv8HgzcD0AIgBCARQhqIQv8HgzcDyAIgBCARQhCIQv8HgzcDwAIgBCARQgaIQv8HgzcDuAIgBCARQgSGQvAHgyASQjyIhDcDsAIgBCAFKQA4IhBCNIhC/weDNwOQAyAEIBBCKohC/weDNwOIAyAEIBBCIIhC/weDNwOAAyAEIBBCFohC/weDNwP4AiAEIBBCDIhC/weDNwPwAiAEIBBCAohC/weDNwPoAiAEIBBCCIZCgAaDIBFCOIiENwPgAiAEIAUpAEAiEUIwiEL/B4M3A8ADIAQgEUImiEL/B4M3A7gDIAQgEUIciEL/B4M3A7ADIAQgEUISiEL/B4M3A6gDIAQgEUIIiEL/B4M3A6ADIAQgEUIChkL8B4MgEEI+iIQ3A5gDIAQgBSkASCIQQjaINwP4AyAEIBBCLIhC/weDNwPwAyAEIBBCIohC/weDNwPoAyAEIBBCGIhC/weDNwPgAyAEIBBCDohC/weDNwPYAyAEIBBCBIhC/weDNwPQAyAEIBBCBoZCwAeDIBFCOoiENwPIAww3CyAGQdcATQRADD8LIAQgBSkAACISQv8PgzcDACAEIBJCLIhC/w+DNwMgIAQgEkIhiEL/D4M3AxggBCASQhaIQv8PgzcDECAEIBJCC4hC/w+DNwMIIAQgBSkACCIQQi6IQv8PgzcDUCAEIBBCI4hC/w+DNwNIIAQgEEIYiEL/D4M3A0AgBCAQQg2IQv8PgzcDOCAEIBBCAohC/w+DNwMwIAQgBSkAECIRQjCIQv8PgzcDgAEgBCARQiWIQv8PgzcDeCAEIBFCGohC/w+DNwNwIAQgEUIPiEL/D4M3A2ggBCARQgSIQv8PgzcDYCAEIBBCCYZCgAyDIBJCN4iENwMoIAQgEUIHhkKAD4MgEEI5iIQ3A1ggBCAFKQAYIhBCMohC/w+DNwOwASAEIBBCJ4hC/w+DNwOoASAEIBBCHIhC/w+DNwOgASAEIBBCEYhC/w+DNwOYASAEIBBCBohC/w+DNwOQASAEIAUpACAiEkI0iEL/D4M3A+ABIAQgEkIpiEL/D4M3A9gBIAQgEkIeiEL/D4M3A9ABIAQgEkITiEL/D4M3A8gBIAQgEkIIiEL/D4M3A8ABIAQgBSkAKCITQiuIQv8PgzcDiAIgBCATQiCIQv8PgzcDgAIgBCATQhWIQv8PgzcD+AEgBCATQgqIQv8PgzcD8AEgBCAQQgWGQuAPgyARQjuIhDcDiAEgBCASQgOGQvgPgyAQQj2IhDcDuAEgBCATQgGGQv4PgyASQj+IhDcD6AEgBCAFKQAwIhBCLYhC/w+DNwO4AiAEIBBCIohC/w+DNwOwAiAEIBBCF4hC/w+DNwOoAiAEIBBCDIhC/w+DNwOgAiAEIBBCAYhC/w+DNwOYAiAEIBBCCoZCgAiDIBNCNoiENwOQAiAEIAUpADgiEUIviEL/D4M3A+gCIAQgEUIkiEL/D4M3A+ACIAQgEUIZiEL/D4M3A9gCIAQgEUIOiEL/D4M3A9ACIAQgEUIDiEL/D4M3A8gCIAQgEUIIhkKADoMgEEI4iIQ3A8ACIAQgBSkAQCIQQjGIQv8PgzcDmAMgBCAQQiaIQv8PgzcDkAMgBCAQQhuIQv8PgzcDiAMgBCAQQhCIQv8PgzcDgAMgBCAQQgWIQv8PgzcD+AIgBCAQQgaGQsAPgyARQjqIhDcD8AIgBCAFKQBIIhFCM4hC/w+DNwPIAyAEIBFCKIhC/w+DNwPAAyAEIBFCHYhC/w+DNwO4AyAEIBFCEohC/w+DNwOwAyAEIBFCB4hC/w+DNwOoAyAEIBFCBIZC8A+DIBBCPIiENwOgAyAEIAUpAFAiEEI1iDcD+AMgBCAQQiqIQv8PgzcD8AMgBCAQQh+IQv8PgzcD6AMgBCAQQhSIQv8PgzcD4AMgBCAQQgmIQv8PgzcD2AMgBCAQQgKGQvwPgyARQj6IhDcD0AMMNgsgBkHfAE0EQAw+CyAEIAUpAAAiEEL/H4M3AwAgBCAFKQAQIhFCNIg3A3ggBCAQQjCIQv8fgzcDICAEIBBCJIhC/x+DNwMYIAQgEEIYiEL/H4M3AxAgBCAQQgyIQv8fgzcDCCAEIAUpAAgiEkIsiEL/H4M3A0ggBCASQiCIQv8fgzcDQCAEIBJCFIhC/x+DNwM4IAQgEkIIiEL/H4M3AzAgBCARQiiIQv8fgzcDcCAEIBFCHIhC/x+DNwNoIAQgEUIQiEL/H4M3A2AgBCARQgSIQv8fgzcDWCAEIBJCBIZC8B+DIBBCPIiENwMoIAQgEUIIhkKAHoMgEkI4iIQ3A1AgBCAFKQAYIhBC/x+DNwOAASAEIAUpACgiEUI0iDcD+AEgBCAQQjCIQv8fgzcDoAEgBCAQQiSIQv8fgzcDmAEgBCAQQhiIQv8fgzcDkAEgBCAQQgyIQv8fgzcDiAEgBCAFKQAgIhJCLIhC/x+DNwPIASAEIBJCIIhC/x+DNwPAASAEIBJCFIhC/x+DNwO4ASAEIBJCCIhC/x+DNwOwASAEIBFCKIhC/x+DNwPwASAEIBFCHIhC/x+DNwPoASAEIBFCEIhC/x+DNwPgASAEIBFCBIhC/x+DNwPYASAEIBJCBIZC8B+DIBBCPIiENwOoASAEIBFCCIZCgB6DIBJCOIiENwPQASAEIAUpADAiEEL/H4M3A4ACIAQgEEIwiEL/H4M3A6ACIAQgEEIkiEL/H4M3A5gCIAQgEEIYiEL/H4M3A5ACIAQgEEIMiEL/H4M3A4gCIAQgBSkAOCIRQiyIQv8fgzcDyAIgBCARQiCIQv8fgzcDwAIgBCARQhSIQv8fgzcDuAIgBCARQgiIQv8fgzcDsAIgBCARQgSGQvAfgyAQQjyIhDcDqAIgBCAFKQBAIhBCNIg3A/gCIAQgEEIoiEL/H4M3A/ACIAQgEEIciEL/H4M3A+gCIAQgEEIQiEL/H4M3A+ACIAQgEEIEiEL/H4M3A9gCIAQgEEIIhkKAHoMgEUI4iIQ3A9ACIAQgBSkASCIQQv8fgzcDgAMgBCAQQjCIQv8fgzcDoAMgBCAQQiSIQv8fgzcDmAMgBCAQQhiIQv8fgzcDkAMgBCAQQgyIQv8fgzcDiAMgBCAFKQBQIhFCLIhC/x+DNwPIAyAEIBFCIIhC/x+DNwPAAyAEIBFCFIhC/x+DNwO4AyAEIBFCCIhC/x+DNwOwAyAEIBFCBIZC8B+DIBBCPIiENwOoAyAEIAUpAFgiEEI0iDcD+AMgBCAQQiiIQv8fgzcD8AMgBCAQQhyIQv8fgzcD6AMgBCAQQhCIQv8fgzcD4AMgBCAQQgSIQv8fgzcD2AMgBCAQQgiGQoAegyARQjiIhDcD0AMMNQsgBkHnAE0EQAw9CyAEIAUpAAAiE0L/P4M3AwAgBCATQieIQv8/gzcDGCAEIBNCGohC/z+DNwMQIAQgE0INiEL/P4M3AwggBCAFKQAIIhBCKIhC/z+DNwNAIAQgEEIbiEL/P4M3AzggBCAQQg6IQv8/gzcDMCAEIBBCAYhC/z+DNwMoIAQgBSkAECIRQimIQv8/gzcDaCAEIBFCHIhC/z+DNwNgIAQgEUIPiEL/P4M3A1ggBCARQgKIQv8/gzcDUCAEIAUpABgiEkIqiEL/P4M3A5ABIAQgEkIdiEL/P4M3A4gBIAQgEkIQiEL/P4M3A4ABIAQgEkIDiEL/P4M3A3ggBCAQQgyGQoAggyATQjSIhDcDICAEIBFCC4ZCgDCDIBBCNYiENwNIIAQgEkIKhkKAOIMgEUI2iIQ3A3AgBCAFKQAgIhBCK4hC/z+DNwO4ASAEIBBCHohC/z+DNwOwASAEIBBCEYhC/z+DNwOoASAEIBBCBIhC/z+DNwOgASAEIAUpACgiEUIsiEL/P4M3A+ABIAQgEUIfiEL/P4M3A9gBIAQgEUISiEL/P4M3A9ABIAQgEUIFiEL/P4M3A8gBIAQgBSkAMCITQi2IQv8/gzcDiAIgBCATQiCIQv8/gzcDgAIgBCATQhOIQv8/gzcD+AEgBCATQgaIQv8/gzcD8AEgBCAQQgmGQoA8gyASQjeIhDcDmAEgBCARQgiGQoA+gyAQQjiIhDcDwAEgBCATQgeGQoA/gyARQjmIhDcD6AEgBCAFKQA4IhBCLohC/z+DNwOwAiAEIBBCIYhC/z+DNwOoAiAEIBBCFIhC/z+DNwOgAiAEIBBCB4hC/z+DNwOYAiAEIBBCBoZCwD+DIBNCOoiENwOQAiAEIAUpAEAiEUIviEL/P4M3A9gCIAQgEUIiiEL/P4M3A9ACIAQgEUIViEL/P4M3A8gCIAQgEUIIiEL/P4M3A8ACIAQgEUIFhkLgP4MgEEI7iIQ3A7gCIAQgBSkASCIQQjCIQv8/gzcDgAMgBCAQQiOIQv8/gzcD+AIgBCAQQhaIQv8/gzcD8AIgBCAQQgmIQv8/gzcD6AIgBCAQQgSGQvA/gyARQjyIhDcD4AIgBCAFKQBQIhFCMYhC/z+DNwOoAyAEIBFCJIhC/z+DNwOgAyAEIBFCF4hC/z+DNwOYAyAEIBFCCohC/z+DNwOQAyAEIBFCA4ZC+D+DIBBCPYiENwOIAyAEIAUpAFgiEEIyiEL/P4M3A9ADIAQgEEIliEL/P4M3A8gDIAQgEEIYiEL/P4M3A8ADIAQgEEILiEL/P4M3A7gDIAQgEEIChkL8P4MgEUI+iIQ3A7ADIAQgBSkAYCIRQjOINwP4AyAEIBFCJohC/z+DNwPwAyAEIBFCGYhC/z+DNwPoAyAEIBFCDIhC/z+DNwPgAyAEIBFCAYZC/j+DIBBCP4iENwPYAww0CyAGQe8ATQRADDwLIAQgBSkAACISQv//AIM3AwAgBCASQiqIQv//AIM3AxggBCASQhyIQv//AIM3AxAgBCASQg6IQv//AIM3AwggBCAFKQAIIhBCMIhC//8AgzcDQCAEIBBCIohC//8AgzcDOCAEIBBCFIhC//8AgzcDMCAEIBBCBohC//8AgzcDKCAEIAUpABAiE0IoiEL//wCDNwNgIAQgE0IaiEL//wCDNwNYIAQgE0IMiEL//wCDNwNQIAQgBSkAGCIRQi6IQv//AIM3A4gBIAQgEUIgiEL//wCDNwOAASAEIBFCEohC//8AgzcDeCAEIBFCBIhC//8AgzcDcCAEIBBCCIZCgP4AgyASQjiIhDcDICAEIBNCAoZC/P8AgyAQQj6IhDcDSCAEIBFCCoZCgPgAgyATQjaIhDcDaCAEIAUpADAiEkIyiDcD+AEgBCAFKQAgIhNCJohC//8AgzcDqAEgBCATQhiIQv//AIM3A6ABIAQgE0IKiEL//wCDNwOYASAEIAUpACgiEEIsiEL//wCDNwPQASAEIBBCHohC//8AgzcDyAEgBCAQQhCIQv//AIM3A8ABIAQgEEICiEL//wCDNwO4ASAEIBJCJIhC//8AgzcD8AEgBCASQhaIQv//AIM3A+gBIAQgEkIIiEL//wCDNwPgASAEIBNCBIZC8P8AgyARQjyIhDcDkAEgBCAQQgyGQoDgAIMgE0I0iIQ3A7ABIAQgEkIGhkLA/wCDIBBCOoiENwPYASAEIAUpADgiEUIqiEL//wCDNwOYAiAEIBFCHIhC//8AgzcDkAIgBCARQg6IQv//AIM3A4gCIAQgEUL//wCDNwOAAiAEIAUpAEAiEEIwiEL//wCDNwPAAiAEIBBCIohC//8AgzcDuAIgBCAQQhSIQv//AIM3A7ACIAQgEEIGiEL//wCDNwOoAiAEIBBCCIZCgP4AgyARQjiIhDcDoAIgBCAFKQBIIhFCKIhC//8AgzcD4AIgBCARQhqIQv//AIM3A9gCIAQgEUIMiEL//wCDNwPQAiAEIBFCAoZC/P8AgyAQQj6IhDcDyAIgBCAFKQBQIhBCLohC//8AgzcDiAMgBCAQQiCIQv//AIM3A4ADIAQgEEISiEL//wCDNwP4AiAEIBBCBIhC//8AgzcD8AIgBCAQQgqGQoD4AIMgEUI2iIQ3A+gCIAQgBSkAWCIRQiaIQv//AIM3A6gDIAQgEUIYiEL//wCDNwOgAyAEIBFCCohC//8AgzcDmAMgBCARQgSGQvD/AIMgEEI8iIQ3A5ADIAQgBSkAYCIQQiyIQv//AIM3A9ADIAQgEEIeiEL//wCDNwPIAyAEIBBCEIhC//8AgzcDwAMgBCAQQgKIQv//AIM3A7gDIAQgEEIMhkKA4ACDIBFCNIiENwOwAyAEIAUpAGgiEUIyiDcD+AMgBCARQiSIQv//AIM3A/ADIAQgEUIWiEL//wCDNwPoAyAEIBFCCIhC//8AgzcD4AMgBCARQgaGQsD/AIMgEEI6iIQ3A9gDDDMLIAZB9wBNBEAMOwsgBCAFKQAAIhFC//8BgzcDACAEIBFCLYhC//8BgzcDGCAEIBFCHohC//8BgzcDECAEIBFCD4hC//8BgzcDCCAEIAUpAAgiEkIpiEL//wGDNwM4IAQgEkIaiEL//wGDNwMwIAQgEkILiEL//wGDNwMoIAQgBSkAECITQiWIQv//AYM3A1ggBCATQhaIQv//AYM3A1AgBCATQgeIQv//AYM3A0ggBCAFKQAYIhBCMIhC//8BgzcDgAEgBCAQQiGIQv//AYM3A3ggBCAQQhKIQv//AYM3A3AgBCAQQgOIQv//AYM3A2ggBCASQgSGQvD/AYMgEUI8iIQ3AyAgBCATQgiGQoD+AYMgEkI4iIQ3A0AgBCAQQgyGQoDgAYMgE0I0iIQ3A2AgBCAFKQAgIhJCLIhC//8BgzcDoAEgBCASQh2IQv//AYM3A5gBIAQgEkIOiEL//wGDNwOQASAEIAUpACgiE0IoiEL//wGDNwPAASAEIBNCGYhC//8BgzcDuAEgBCATQgqIQv//AYM3A7ABIAQgBSkAMCIUQiSIQv//AYM3A+ABIAQgFEIViEL//wGDNwPYASAEIBRCBohC//8BgzcD0AEgBCAFKQA4IhFCL4hC//8BgzcDiAIgBCARQiCIQv//AYM3A4ACIAQgEUIRiEL//wGDNwP4ASAEIBFCAohC//8BgzcD8AEgBCASQgGGQv7/AYMgEEI/iIQ3A4gBIAQgE0IFhkLg/wGDIBJCO4iENwOoASAEIBRCCYZCgPwBgyATQjeIhDcDyAEgBCARQg2GQoDAAYMgFEIziIQ3A+gBIAQgBSkAQCIQQiuIQv//AYM3A6gCIAQgEEIciEL//wGDNwOgAiAEIBBCDYhC//8BgzcDmAIgBCAQQgKGQvz/AYMgEUI+iIQ3A5ACIAQgBSkASCIRQieIQv//AYM3A8gCIAQgEUIYiEL//wGDNwPAAiAEIBFCCYhC//8BgzcDuAIgBCARQgaGQsD/AYMgEEI6iIQ3A7ACIAQgBSkAUCISQiOIQv//AYM3A+gCIAQgEkIUiEL//wGDNwPgAiAEIBJCBYhC//8BgzcD2AIgBCASQgqGQoD4AYMgEUI2iIQ3A9ACIAQgBSkAWCIQQi6IQv//AYM3A5ADIAQgEEIfiEL//wGDNwOIAyAEIBBCEIhC//8BgzcDgAMgBCAQQgGIQv//AYM3A/gCIAQgEEIOhkKAgAGDIBJCMoiENwPwAiAEIAUpAGAiEUIqiEL//wGDNwOwAyAEIBFCG4hC//8BgzcDqAMgBCARQgyIQv//AYM3A6ADIAQgEUIDhkL4/wGDIBBCPYiENwOYAyAEIAUpAGgiEEImiEL//wGDNwPQAyAEIBBCF4hC//8BgzcDyAMgBCAQQgiIQv//AYM3A8ADIAQgEEIHhkKA/wGDIBFCOYiENwO4AyAEIAUpAHAiEUIxiDcD+AMgBCARQiKIQv//AYM3A/ADIAQgEUITiEL//wGDNwPoAyAEIBFCBIhC//8BgzcD4AMgBCARQguGQoDwAYMgEEI1iIQ3A9gDDDILIAZB/wBNBEAMOgsgBCAFKQAAIhBCMIg3AxggBCAQQv//A4M3AwAgBCAFKQAIIhFCMIg3AzggBCARQv//A4M3AyAgBCAFKQAQIhJCMIg3A1ggBCASQv//A4M3A0AgBCAFKQAYIhNCMIg3A3ggBCATQv//A4M3A2AgBCAQQiCIQv//A4M3AxAgBCAQQhCIQv//A4M3AwggBCARQiCIQv//A4M3AzAgBCARQhCIQv//A4M3AyggBCASQiCIQv//A4M3A1AgBCASQhCIQv//A4M3A0ggBCATQiCIQv//A4M3A3AgBCATQhCIQv//A4M3A2ggBCAFKQAgIhBCMIg3A5gBIAQgEEL//wODNwOAASAEIAUpACgiEUIwiDcDuAEgBCARQv//A4M3A6ABIAQgBSkAMCISQjCINwPYASAEIBJC//8DgzcDwAEgBCAFKQA4IhNCMIg3A/gBIAQgE0L//wODNwPgASAEIBBCIIhC//8DgzcDkAEgBCAQQhCIQv//A4M3A4gBIAQgEUIgiEL//wODNwOwASAEIBFCEIhC//8DgzcDqAEgBCASQiCIQv//A4M3A9ABIAQgEkIQiEL//wODNwPIASAEIBNCIIhC//8DgzcD8AEgBCATQhCIQv//A4M3A+gBIAQgBSkAQCIQQjCINwOYAiAEIBBC//8DgzcDgAIgBCAQQiCIQv//A4M3A5ACIAQgEEIQiEL//wODNwOIAiAEIAUpAEgiEEIwiDcDuAIgBCAQQv//A4M3A6ACIAQgEEIgiEL//wODNwOwAiAEIBBCEIhC//8DgzcDqAIgBCAFKQBQIhBCMIg3A9gCIAQgEEL//wODNwPAAiAEIBBCIIhC//8DgzcD0AIgBCAQQhCIQv//A4M3A8gCIAQgBSkAWCIQQjCINwP4AiAEIBBC//8DgzcD4AIgBCAQQiCIQv//A4M3A/ACIAQgEEIQiEL//wODNwPoAiAEIAUpAGAiEEIwiDcDmAMgBCAQQv//A4M3A4ADIAQgEEIgiEL//wODNwOQAyAEIBBCEIhC//8DgzcDiAMgBCAFKQBoIhBCMIg3A7gDIAQgEEL//wODNwOgAyAEIBBCIIhC//8DgzcDsAMgBCAQQhCIQv//A4M3A6gDIAQgBSkAcCIQQjCINwPYAyAEIBBC//8DgzcDwAMgBCAQQiCIQv//A4M3A9ADIAQgEEIQiEL//wODNwPIAyAEIAUpAHgiEEIwiDcD+AMgBCAQQv//A4M3A+ADIAQgEEIgiEL//wODNwPwAyAEIBBCEIhC//8DgzcD6AMMMQsgBkGHAU0EQAw5CyAEIAUpAAAiE0L//weDNwMAIAQgE0IiiEL//weDNwMQIAQgE0IRiEL//weDNwMIIAQgBSkACCIQQiaIQv//B4M3AzAgBCAQQhWIQv//B4M3AyggBCAQQgSIQv//B4M3AyAgBCAFKQAQIhFCKohC//8HgzcDUCAEIBFCGYhC//8HgzcDSCAEIBFCCIhC//8HgzcDQCAEIAUpABgiEkIuiEL//weDNwNwIAQgEkIdiEL//weDNwNoIAQgEkIMiEL//weDNwNgIAQgEEINhkKAwAeDIBNCM4iENwMYIAQgEUIJhkKA/AeDIBBCN4iENwM4IAQgEkIFhkLg/weDIBFCO4iENwNYIAQgBSkAICIUQiGIQv//B4M3A4gBIAQgFEIQiEL//weDNwOAASAEIAUpACgiEEIliEL//weDNwOoASAEIBBCFIhC//8HgzcDoAEgBCAQQgOIQv//B4M3A5gBIAQgBSkAMCIRQimIQv//B4M3A8gBIAQgEUIYiEL//weDNwPAASAEIBFCB4hC//8HgzcDuAEgBCAFKQA4IhNCLYhC//8HgzcD6AEgBCATQhyIQv//B4M3A+ABIAQgE0ILiEL//weDNwPYASAEIBRCAYZC/v8HgyASQj+IhDcDeCAEIBBCDoZCgIAHgyAUQjKIhDcDkAEgBCARQgqGQoD4B4MgEEI2iIQ3A7ABIAQgE0IGhkLA/weDIBFCOoiENwPQASAEIAUpAEAiEUIgiEL//weDNwOAAiAEIBFCD4hC//8HgzcD+AEgBCARQgKGQvz/B4MgE0I+iIQ3A/ABIAQgBSkASCIQQiSIQv//B4M3A6ACIAQgEEITiEL//weDNwOYAiAEIBBCAohC//8HgzcDkAIgBCAQQg+GQoCABoMgEUIxiIQ3A4gCIAQgBSkAUCIRQiiIQv//B4M3A8ACIAQgEUIXiEL//weDNwO4AiAEIBFCBohC//8HgzcDsAIgBCARQguGQoDwB4MgEEI1iIQ3A6gCIAQgBSkAWCIQQiyIQv//B4M3A+ACIAQgEEIbiEL//weDNwPYAiAEIBBCCohC//8HgzcD0AIgBCAQQgeGQoD/B4MgEUI5iIQ3A8gCIAQgBSkAYCIRQh+IQv//B4M3A/gCIAQgEUIOiEL//weDNwPwAiAEIBFCA4ZC+P8HgyAQQj2IhDcD6AIgBCAFKQBoIhBCI4hC//8HgzcDmAMgBCAQQhKIQv//B4M3A5ADIAQgEEIBiEL//weDNwOIAyAEIBBCEIZCgIAEgyARQjCIhDcDgAMgBCAFKQBwIhFCJ4hC//8HgzcDuAMgBCARQhaIQv//B4M3A7ADIAQgEUIFiEL//weDNwOoAyAEIBFCDIZCgOAHgyAQQjSIhDcDoAMgBCAFKQB4IhBCK4hC//8HgzcD2AMgBCAQQhqIQv//B4M3A9ADIAQgEEIJiEL//weDNwPIAyAEIBBCCIZCgP4HgyARQjiIhDcDwAMgBCAFKQCAASIRQi+INwP4AyAEIBFCHohC//8HgzcD8AMgBCARQg2IQv//B4M3A+gDIAQgEUIEhkLw/weDIBBCPIiENwPgAwwwCyAGQY8BTQRADDgLIAQgBSkAACISQv//D4M3AwAgBCASQiSIQv//D4M3AxAgBCASQhKIQv//D4M3AwggBCAFKQAIIhBCLIhC//8PgzcDMCAEIBBCGohC//8PgzcDKCAEIBBCCIhC//8PgzcDICAEIAUpABAiE0IiiEL//w+DNwNIIAQgE0IQiEL//w+DNwNAIAQgBSkAGCIRQiqIQv//D4M3A2ggBCARQhiIQv//D4M3A2AgBCARQgaIQv//D4M3A1ggBCAQQgqGQoD4D4MgEkI2iIQ3AxggBCATQgKGQvz/D4MgEEI+iIQ3AzggBCARQgyGQoDgD4MgE0I0iIQ3A1AgBCAFKQAgIhJCIIhC//8PgzcDgAEgBCASQg6IQv//D4M3A3ggBCASQgSGQvD/D4MgEUI8iIQ3A3AgBCAFKQAoIhBCKIhC//8PgzcDoAEgBCAQQhaIQv//D4M3A5gBIAQgEEIEiEL//w+DNwOQASAEIAUpADAiE0IeiEL//w+DNwO4ASAEIBNCDIhC//8PgzcDsAEgBCAFKQA4IhFCJohC//8PgzcD2AEgBCARQhSIQv//D4M3A9ABIAQgEUICiEL//w+DNwPIASAEIBBCDoZCgIAPgyASQjKIhDcDiAEgBCATQgaGQsD/D4MgEEI6iIQ3A6gBIAQgEUIQhkKAgAyDIBNCMIiENwPAASAEIAUpAEAiEEIuiDcD+AEgBCAQQhyIQv//D4M3A/ABIAQgEEIKiEL//w+DNwPoASAEIBBCCIZCgP4PgyARQjiIhDcD4AEgBCAFKQBIIhFC//8PgzcDgAIgBCARQiSIQv//D4M3A5ACIAQgEUISiEL//w+DNwOIAiAEIAUpAFAiEEIsiEL//w+DNwOwAiAEIBBCGohC//8PgzcDqAIgBCAQQgiIQv//D4M3A6ACIAQgEEIKhkKA+A+DIBFCNoiENwOYAiAEIAUpAFgiEUIiiEL//w+DNwPIAiAEIBFCEIhC//8PgzcDwAIgBCARQgKGQvz/D4MgEEI+iIQ3A7gCIAQgBSkAYCIQQiqIQv//D4M3A+gCIAQgEEIYiEL//w+DNwPgAiAEIBBCBohC//8PgzcD2AIgBCAQQgyGQoDgD4MgEUI0iIQ3A9ACIAQgBSkAaCIRQiCIQv//D4M3A4ADIAQgEUIOiEL//w+DNwP4AiAEIBFCBIZC8P8PgyAQQjyIhDcD8AIgBCAFKQBwIhBCKIhC//8PgzcDoAMgBCAQQhaIQv//D4M3A5gDIAQgEEIEiEL//w+DNwOQAyAEIBBCDoZCgIAPgyARQjKIhDcDiAMgBCAFKQB4IhFCHohC//8PgzcDuAMgBCARQgyIQv//D4M3A7ADIAQgEUIGhkLA/w+DIBBCOoiENwOoAyAEIAUpAIABIhBCJohC//8PgzcD2AMgBCAQQhSIQv//D4M3A9ADIAQgEEICiEL//w+DNwPIAyAEIBBCEIZCgIAMgyARQjCIhDcDwAMgBCAFKQCIASIRQi6INwP4AyAEIBFCHIhC//8PgzcD8AMgBCARQgqIQv//D4M3A+gDIAQgEUIIhkKA/g+DIBBCOIiENwPgAwwvCyAGQZcBTQRADDcLIAQgBSkAACIRQv//H4M3AwAgBCARQiaIQv//H4M3AxAgBCARQhOIQv//H4M3AwggBCAFKQAIIhJCH4hC//8fgzcDKCAEIBJCDIhC//8fgzcDICAEIAUpABAiEEIriEL//x+DNwNIIAQgEEIYiEL//x+DNwNAIAQgEEIFiEL//x+DNwM4IAQgBSkAGCITQiSIQv//H4M3A2AgBCATQhGIQv//H4M3A1ggBCAFKQAgIhRCHYhC//8fgzcDeCAEIBRCCohC//8fgzcDcCAEIBJCB4ZCgP8fgyARQjmIhDcDGCAEIBBCDoZCgIAfgyASQjKIhDcDMCAEIBNCAoZC/P8fgyAQQj6IhDcDUCAEIBRCCYZCgPwfgyATQjeIhDcDaCAEIAUpACgiEEIpiEL//x+DNwOYASAEIBBCFohC//8fgzcDkAEgBCAQQgOIQv//H4M3A4gBIAQgBSkAMCISQiKIQv//H4M3A7ABIAQgEkIPiEL//x+DNwOoASAEIAUpADgiE0IbiEL//x+DNwPIASAEIBNCCIhC//8fgzcDwAEgBCAFKQBAIhFCJ4hC//8fgzcD6AEgBCARQhSIQv//H4M3A+ABIAQgEUIBiEL//x+DNwPYASAEIBBCEIZCgIAcgyAUQjCIhDcDgAEgBCASQgSGQvD/H4MgEEI8iIQ3A6ABIAQgE0ILhkKA8B+DIBJCNYiENwO4ASAEIBFCEoZCgIAQgyATQi6IhDcD0AEgBCAFKQBIIhJCIIhC//8fgzcDgAIgBCASQg2IQv//H4M3A/gBIAQgEkIGhkLA/x+DIBFCOoiENwPwASAEIAUpAFAiEEIsiEL//x+DNwOgAiAEIBBCGYhC//8fgzcDmAIgBCAQQgaIQv//H4M3A5ACIAQgEEINhkKAwB+DIBJCM4iENwOIAiAEIAUpAFgiEUIliEL//x+DNwO4AiAEIBFCEohC//8fgzcDsAIgBCARQgGGQv7/H4MgEEI/iIQ3A6gCIAQgBSkAYCISQh6IQv//H4M3A9ACIAQgEkILiEL//x+DNwPIAiAEIBJCCIZCgP4fgyARQjiIhDcDwAIgBCAFKQBoIhBCKohC//8fgzcD8AIgBCAQQheIQv//H4M3A+gCIAQgEEIEiEL//x+DNwPgAiAEIBBCD4ZCgIAegyASQjGIhDcD2AIgBCAFKQBwIhFCI4hC//8fgzcDiAMgBCARQhCIQv//H4M3A4ADIAQgEUIDhkL4/x+DIBBCPYiENwP4AiAEIAUpAHgiEkIciEL//x+DNwOgAyAEIBJCCYhC//8fgzcDmAMgBCASQgqGQoD4H4MgEUI2iIQ3A5ADIAQgBSkAgAEiEEIoiEL//x+DNwPAAyAEIBBCFYhC//8fgzcDuAMgBCAQQgKIQv//H4M3A7ADIAQgEEIRhkKAgBiDIBJCL4iENwOoAyAEIAUpAIgBIhFCIYhC//8fgzcD2AMgBCARQg6IQv//H4M3A9ADIAQgEUIFhkLg/x+DIBBCO4iENwPIAyAEIAUpAJABIhBCLYg3A/gDIAQgEEIaiEL//x+DNwPwAyAEIBBCB4hC//8fgzcD6AMgBCAQQgyGQoDgH4MgEUI0iIQ3A+ADDC4LIAZBnwFNBEAMNgsgBCAFKQAAIhBC//8/gzcDACAEIAUpACAiEUIsiDcDeCAEIBBCKIhC//8/gzcDECAEIBBCFIhC//8/gzcDCCAEIAUpAAgiEkIkiEL//z+DNwMoIAQgEkIQiEL//z+DNwMgIAQgBSkAECITQiCIQv//P4M3A0AgBCATQgyIQv//P4M3AzggBCAFKQAYIhRCHIhC//8/gzcDWCAEIBRCCIhC//8/gzcDUCAEIBFCGIhC//8/gzcDcCAEIBFCBIhC//8/gzcDaCAEIBJCBIZC8P8/gyAQQjyIhDcDGCAEIBNCCIZCgP4/gyASQjiIhDcDMCAEIBRCDIZCgOA/gyATQjSIhDcDSCAEIBFCEIZCgIA8gyAUQjCIhDcDYCAEIAUpACgiEEL//z+DNwOAASAEIAUpAEgiEUIsiDcD+AEgBCAQQiiIQv//P4M3A5ABIAQgEEIUiEL//z+DNwOIASAEIAUpADAiEkIkiEL//z+DNwOoASAEIBJCEIhC//8/gzcDoAEgBCAFKQA4IhNCIIhC//8/gzcDwAEgBCATQgyIQv//P4M3A7gBIAQgBSkAQCIUQhyIQv//P4M3A9gBIAQgFEIIiEL//z+DNwPQASAEIBFCGIhC//8/gzcD8AEgBCARQgSIQv//P4M3A+gBIAQgEkIEhkLw/z+DIBBCPIiENwOYASAEIBNCCIZCgP4/gyASQjiIhDcDsAEgBCAUQgyGQoDgP4MgE0I0iIQ3A8gBIAQgEUIQhkKAgDyDIBRCMIiENwPgASAEIAUpAFAiEEL//z+DNwOAAiAEIBBCKIhC//8/gzcDkAIgBCAQQhSIQv//P4M3A4gCIAQgBSkAWCIRQiSIQv//P4M3A6gCIAQgEUIQiEL//z+DNwOgAiAEIBFCBIZC8P8/gyAQQjyIhDcDmAIgBCAFKQBgIhBCIIhC//8/gzcDwAIgBCAQQgyIQv//P4M3A7gCIAQgEEIIhkKA/j+DIBFCOIiENwOwAiAEIAUpAGgiEUIciEL//z+DNwPYAiAEIBFCCIhC//8/gzcD0AIgBCARQgyGQoDgP4MgEEI0iIQ3A8gCIAQgBSkAcCIQQiyINwP4AiAEIBBCGIhC//8/gzcD8AIgBCAQQgSIQv//P4M3A+gCIAQgEEIQhkKAgDyDIBFCMIiENwPgAiAEIAUpAHgiEEL//z+DNwOAAyAEIBBCKIhC//8/gzcDkAMgBCAQQhSIQv//P4M3A4gDIAQgBSkAgAEiEUIkiEL//z+DNwOoAyAEIBFCEIhC//8/gzcDoAMgBCARQgSGQvD/P4MgEEI8iIQ3A5gDIAQgBSkAiAEiEEIgiEL//z+DNwPAAyAEIBBCDIhC//8/gzcDuAMgBCAQQgiGQoD+P4MgEUI4iIQ3A7ADIAQgBSkAkAEiEUIciEL//z+DNwPYAyAEIBFCCIhC//8/gzcD0AMgBCARQgyGQoDgP4MgEEI0iIQ3A8gDIAQgBSkAmAEiEEIsiDcD+AMgBCAQQhiIQv//P4M3A/ADIAQgEEIEiEL//z+DNwPoAyAEIBBCEIZCgIA8gyARQjCIhDcD4AMMLQsgBkGnAU0EQAw1CyAEIAUpAAAiEEL///8AgzcDACAEIBBCKohC////AIM3AxAgBCAQQhWIQv///wCDNwMIIAQgBSkACCIRQimIQv///wCDNwMoIAQgEUIUiEL///8AgzcDICAEIAUpABAiEkIoiEL///8AgzcDQCAEIBJCE4hC////AIM3AzggBCAFKQAYIhNCJ4hC////AIM3A1ggBCATQhKIQv///wCDNwNQIAQgBSkAICIUQiaIQv///wCDNwNwIAQgFEIRiEL///8AgzcDaCAEIBFCAYZC/v//AIMgEEI/iIQ3AxggBCASQgKGQvz//wCDIBFCPoiENwMwIAQgE0IDhkL4//8AgyASQj2IhDcDSCAEIBRCBIZC8P//AIMgE0I8iIQ3A2AgBCAFKQAoIhBCJYhC////AIM3A4gBIAQgEEIQiEL///8AgzcDgAEgBCAFKQAwIhFCJIhC////AIM3A6ABIAQgEUIPiEL///8AgzcDmAEgBCAFKQA4IhJCI4hC////AIM3A7gBIAQgEkIOiEL///8AgzcDsAEgBCAFKQBAIhNCIohC////AIM3A9ABIAQgE0INiEL///8AgzcDyAEgBCAFKQBIIhVCIYhC////AIM3A+gBIAQgFUIMiEL///8AgzcD4AEgBCAQQgWGQuD//wCDIBRCO4iENwN4IAQgEUIGhkLA//8AgyAQQjqIhDcDkAEgBCASQgeGQoD//wCDIBFCOYiENwOoASAEIBNCCIZCgP7/AIMgEkI4iIQ3A8ABIAQgFUIJhkKA/P8AgyATQjeIhDcD2AEgBCAFKQBQIhBCIIhC////AIM3A4ACIAQgEEILiEL///8AgzcD+AEgBCAQQgqGQoD4/wCDIBVCNoiENwPwASAEIAUpAFgiEUIfiEL///8AgzcDmAIgBCARQgqIQv///wCDNwOQAiAEIBFCC4ZCgPD/AIMgEEI1iIQ3A4gCIAQgBSkAYCIQQh6IQv///wCDNwOwAiAEIBBCCYhC////AIM3A6gCIAQgEEIMhkKA4P8AgyARQjSIhDcDoAIgBCAFKQBoIhFCHYhC////AIM3A8gCIAQgEUIIiEL///8AgzcDwAIgBCARQg2GQoDA/wCDIBBCM4iENwO4AiAEIAUpAHAiEEIciEL///8AgzcD4AIgBCAQQgeIQv///wCDNwPYAiAEIBBCDoZCgID/AIMgEUIyiIQ3A9ACIAQgBSkAeCIRQhuIQv///wCDNwP4AiAEIBFCBohC////AIM3A/ACIAQgEUIPhkKAgP4AgyAQQjGIhDcD6AIgBCAFKQCAASIQQhqIQv///wCDNwOQAyAEIBBCBYhC////AIM3A4gDIAQgEEIQhkKAgPwAgyARQjCIhDcDgAMgBCAFKQCIASIRQhmIQv///wCDNwOoAyAEIBFCBIhC////AIM3A6ADIAQgEUIRhkKAgPgAgyAQQi+IhDcDmAMgBCAFKQCQASIQQhiIQv///wCDNwPAAyAEIBBCA4hC////AIM3A7gDIAQgEEIShkKAgPAAgyARQi6IhDcDsAMgBCAFKQCYASIRQheIQv///wCDNwPYAyAEIBFCAohC////AIM3A9ADIAQgEUIThkKAgOAAgyAQQi2IhDcDyAMgBCAFKQCgASIQQiuINwP4AyAEIBBCFohC////AIM3A/ADIAQgEEIBiEL///8AgzcD6AMgBCAQQhSGQoCAwACDIBFCLIiENwPgAwwsCyAGQa8BTQRADDQLIAQgBSkAACIUQv///wGDNwMAIAQgFEIWiEL///8BgzcDCCAEIAUpAAgiEEIYiEL///8BgzcDICAEIBBCAohC////AYM3AxggBCAFKQAQIhFCGohC////AYM3AzggBCARQgSIQv///wGDNwMwIAQgBSkAGCISQhyIQv///wGDNwNQIAQgEkIGiEL///8BgzcDSCAEIAUpACAiE0IeiEL///8BgzcDaCAEIBNCCIhC////AYM3A2AgBCAQQhSGQoCAwAGDIBRCLIiENwMQIAQgEUIShkKAgPABgyAQQi6IhDcDKCAEIBJCEIZCgID8AYMgEUIwiIQ3A0AgBCATQg6GQoCA/wGDIBJCMoiENwNYIAQgBSkAKCIQQiCIQv///wGDNwOAASAEIBBCCohC////AYM3A3ggBCAFKQAwIhFCIohC////AYM3A5gBIAQgEUIMiEL///8BgzcDkAEgBCAFKQA4IhJCJIhC////AYM3A7ABIAQgEkIOiEL///8BgzcDqAEgBCAFKQBAIhRCJohC////AYM3A8gBIAQgFEIQiEL///8BgzcDwAEgBCAFKQBIIhVCKIhC////AYM3A+ABIAQgFUISiEL///8BgzcD2AEgBCAQQgyGQoDg/wGDIBNCNIiENwNwIAQgEUIKhkKA+P8BgyAQQjaIhDcDiAEgBCASQgiGQoD+/wGDIBFCOIiENwOgASAEIBRCBoZCwP//AYMgEkI6iIQ3A7gBIAQgFUIEhkLw//8BgyAUQjyIhDcD0AEgBCAFKQBQIhBCKog3A/gBIAQgEEIUiEL///8BgzcD8AEgBCAQQgKGQvz//wGDIBVCPoiENwPoASAEIAUpAFgiEUL///8BgzcDgAIgBCARQhaIQv///wGDNwOIAiAEIAUpAGAiEEIYiEL///8BgzcDoAIgBCAQQgKIQv///wGDNwOYAiAEIBBCFIZCgIDAAYMgEUIsiIQ3A5ACIAQgBSkAaCIRQhqIQv///wGDNwO4AiAEIBFCBIhC////AYM3A7ACIAQgEUIShkKAgPABgyAQQi6IhDcDqAIgBCAFKQBwIhBCHIhC////AYM3A9ACIAQgEEIGiEL///8BgzcDyAIgBCAQQhCGQoCA/AGDIBFCMIiENwPAAiAEIAUpAHgiEUIeiEL///8BgzcD6AIgBCARQgiIQv///wGDNwPgAiAEIBFCDoZCgID/AYMgEEIyiIQ3A9gCIAQgBSkAgAEiEEIgiEL///8BgzcDgAMgBCAQQgqIQv///wGDNwP4AiAEIBBCDIZCgOD/AYMgEUI0iIQ3A/ACIAQgBSkAiAEiEUIiiEL///8BgzcDmAMgBCARQgyIQv///wGDNwOQAyAEIBFCCoZCgPj/AYMgEEI2iIQ3A4gDIAQgBSkAkAEiEEIkiEL///8BgzcDsAMgBCAQQg6IQv///wGDNwOoAyAEIBBCCIZCgP7/AYMgEUI4iIQ3A6ADIAQgBSkAmAEiEUImiEL///8BgzcDyAMgBCARQhCIQv///wGDNwPAAyAEIBFCBoZCwP//AYMgEEI6iIQ3A7gDIAQgBSkAoAEiEEIoiEL///8BgzcD4AMgBCAQQhKIQv///wGDNwPYAyAEIBBCBIZC8P//AYMgEUI8iIQ3A9ADIAQgBSkAqAEiEUIqiDcD+AMgBCARQhSIQv///wGDNwPwAyAEIBFCAoZC/P//AYMgEEI+iIQ3A+gDDCsLIAZBtwFNBEAMMwsgBCAFKQAAIhNC////A4M3AwAgBCATQheIQv///wODNwMIIAQgBSkACCIQQhyIQv///wODNwMgIAQgEEIFiEL///8DgzcDGCAEIAUpABAiEUIhiEL///8DgzcDOCAEIBFCCohC////A4M3AzAgBCAFKQAYIhJCJohC////A4M3A1AgBCASQg+IQv///wODNwNIIAQgBSkAICIUQhSIQv///wODNwNgIAQgEEIShkKAgPADgyATQi6IhDcDECAEIBFCDYZCgMD/A4MgEEIziIQ3AyggBCASQgiGQoD+/wODIBFCOIiENwNAIAQgFEIDhkL4//8DgyASQj2IhDcDWCAEIAUpACgiEEIZiEL///8DgzcDeCAEIBBCAohC////A4M3A3AgBCAQQhWGQoCAgAODIBRCK4iENwNoIAQgBSkAMCIRQh6IQv///wODNwOQASAEIBFCB4hC////A4M3A4gBIAQgBSkAOCISQiOIQv///wODNwOoASAEIBJCDIhC////A4M3A6ABIAQgBSkAQCITQiiIQv///wODNwPAASAEIBNCEYhC////A4M3A7gBIAQgBSkASCIUQhaIQv///wODNwPQASAEIBFCEIZCgID8A4MgEEIwiIQ3A4ABIAQgEkILhkKA8P8DgyARQjWIhDcDmAEgBCATQgaGQsD//wODIBJCOoiENwOwASAEIBRCAYZC/v//A4MgE0I/iIQ3A8gBIAQgBSkAUCIQQhuIQv///wODNwPoASAEIBBCBIhC////A4M3A+ABIAQgEEIThkKAgOADgyAUQi2IhDcD2AEgBCAFKQBYIhFCIIhC////A4M3A4ACIAQgEUIJiEL///8DgzcD+AEgBCARQg6GQoCA/wODIBBCMoiENwPwASAEIAUpAGAiEEIliEL///8DgzcDmAIgBCAQQg6IQv///wODNwOQAiAEIBBCCYZCgPz/A4MgEUI3iIQ3A4gCIAQgBSkAaCIRQhOIQv///wODNwOoAiAEIBFCBIZC8P//A4MgEEI8iIQ3A6ACIAQgBSkAcCIQQhiIQv///wODNwPAAiAEIBBCAYhC////A4M3A7gCIAQgEEIWhkKAgIACgyARQiqIhDcDsAIgBCAFKQB4IhFCHYhC////A4M3A9gCIAQgEUIGiEL///8DgzcD0AIgBCARQhGGQoCA+AODIBBCL4iENwPIAiAEIAUpAIABIhBCIohC////A4M3A/ACIAQgEEILiEL///8DgzcD6AIgBCAQQgyGQoDg/wODIBFCNIiENwPgAiAEIAUpAIgBIhFCJ4hC////A4M3A4gDIAQgEUIQiEL///8DgzcDgAMgBCARQgeGQoD//wODIBBCOYiENwP4AiAEIAUpAJABIhJCFYhC////A4M3A5gDIAQgEkIChkL8//8DgyARQj6IhDcDkAMgBCAFKQCYASIQQhqIQv///wODNwOwAyAEIBBCA4hC////A4M3A6gDIAQgEEIUhkKAgMADgyASQiyIhDcDoAMgBCAFKQCgASIRQh+IQv///wODNwPIAyAEIBFCCIhC////A4M3A8ADIAQgEUIPhkKAgP4DgyAQQjGIhDcDuAMgBCAFKQCoASIQQiSIQv///wODNwPgAyAEIBBCDYhC////A4M3A9gDIAQgEEIKhkKA+P8DgyARQjaIhDcD0AMgBCAFKQCwASIRQimINwP4AyAEIBFCEohC////A4M3A/ADIAQgEUIFhkLg//8DgyAQQjuIhDcD6AMMKgsgBkG/AU0EQAwyCyAEIAUpAAAiEkL///8HgzcDACAEIAUpABAiE0IoiDcDOCAEIAUpABgiFEL///8HgzcDQCAEIBJCGIhC////B4M3AwggBCAFKQAIIhBCIIhC////B4M3AyAgBCAQQgiIQv///weDNwMYIAQgE0IQiEL///8HgzcDMCAEIBRCGIhC////B4M3A0ggBCAFKQAgIhFCIIhC////B4M3A2AgBCARQgiIQv///weDNwNYIAQgEEIQhkKAgPwHgyASQjCIhDcDECAEIBNCCIZCgP7/B4MgEEI4iIQ3AyggBCARQhCGQoCA/AeDIBRCMIiENwNQIAQgBSkAKCIQQiiINwN4IAQgEEIQiEL///8HgzcDcCAEIBBCCIZCgP7/B4MgEUI4iIQ3A2ggBCAFKQAwIhFC////B4M3A4ABIAQgBSkAQCISQiiINwO4ASAEIAUpAEgiE0L///8HgzcDwAEgBCARQhiIQv///weDNwOIASAEIAUpADgiEEIgiEL///8HgzcDoAEgBCAQQgiIQv///weDNwOYASAEIBJCEIhC////B4M3A7ABIAQgE0IYiEL///8HgzcDyAEgBCAQQhCGQoCA/AeDIBFCMIiENwOQASAEIBJCCIZCgP7/B4MgEEI4iIQ3A6gBIAQgBSkAUCIQQiCIQv///weDNwPgASAEIBBCCIhC////B4M3A9gBIAQgEEIQhkKAgPwHgyATQjCIhDcD0AEgBCAFKQBYIhFCKIg3A/gBIAQgEUIQiEL///8HgzcD8AEgBCARQgiGQoD+/weDIBBCOIiENwPoASAEIAUpAGAiEUL///8HgzcDgAIgBCARQhiIQv///weDNwOIAiAEIAUpAGgiEEIgiEL///8HgzcDoAIgBCAQQgiIQv///weDNwOYAiAEIBBCEIZCgID8B4MgEUIwiIQ3A5ACIAQgBSkAcCIRQiiINwO4AiAEIBFCEIhC////B4M3A7ACIAQgEUIIhkKA/v8HgyAQQjiIhDcDqAIgBCAFKQB4IhFC////B4M3A8ACIAQgEUIYiEL///8HgzcDyAIgBCAFKQCAASIQQiCIQv///weDNwPgAiAEIBBCCIhC////B4M3A9gCIAQgEEIQhkKAgPwHgyARQjCIhDcD0AIgBCAFKQCIASIRQiiINwP4AiAEIBFCEIhC////B4M3A/ACIAQgEUIIhkKA/v8HgyAQQjiIhDcD6AIgBCAFKQCQASIRQv///weDNwOAAyAEIBFCGIhC////B4M3A4gDIAQgBSkAmAEiEEIgiEL///8HgzcDoAMgBCAQQgiIQv///weDNwOYAyAEIBBCEIZCgID8B4MgEUIwiIQ3A5ADIAQgBSkAoAEiEUIoiDcDuAMgBCARQhCIQv///weDNwOwAyAEIBFCCIZCgP7/B4MgEEI4iIQ3A6gDIAQgBSkAqAEiEUL///8HgzcDwAMgBCARQhiIQv///weDNwPIAyAEIAUpALABIhBCIIhC////B4M3A+ADIAQgEEIIiEL///8HgzcD2AMgBCAQQhCGQoCA/AeDIBFCMIiENwPQAyAEIAUpALgBIhFCKIg3A/gDIAQgEUIQiEL///8HgzcD8AMgBCARQgiGQoD+/weDIBBCOIiENwPoAwwpCyAGQccBTQRADDELIAQgBSkAACITQv///w+DNwMAIAQgE0IZiEL///8PgzcDCCAEIAUpAAgiEEIkiEL///8PgzcDICAEIBBCC4hC////D4M3AxggBCAFKQAQIhRCFohC////D4M3AzAgBCAFKQAYIhFCIYhC////D4M3A0ggBCARQgiIQv///w+DNwNAIAQgBSkAICIVQhOIQv///w+DNwNYIAQgBSkAKCISQh6IQv///w+DNwNwIAQgEkIFiEL///8PgzcDaCAEIBBCDoZCgID/D4MgE0IyiIQ3AxAgBCAUQgOGQvj//w+DIBBCPYiENwMoIAQgEUIRhkKAgPgPgyAUQi+IhDcDOCAEIBVCBoZCwP//D4MgEUI6iIQ3A1AgBCASQhSGQoCAwA+DIBVCLIiENwNgIAQgBSkAMCIUQhCIQv///w+DNwOAASAEIAUpADgiEEIbiEL///8PgzcDmAEgBCAQQgKIQv///w+DNwOQASAEIAUpAEAiEUImiEL///8PgzcDsAEgBCARQg2IQv///w+DNwOoASAEIAUpAEgiFUIYiEL///8PgzcDwAEgBCAFKQBQIhNCI4hC////D4M3A9gBIAQgE0IKiEL///8PgzcD0AEgBCAUQgmGQoD8/w+DIBJCN4iENwN4IAQgEEIXhkKAgIAMgyAUQimIhDcDiAEgBCARQgyGQoDg/w+DIBBCNIiENwOgASAEIBVCAYZC/v//D4MgEUI/iIQ3A7gBIAQgE0IPhkKAgP4PgyAVQjGIhDcDyAEgBCAFKQBYIhFCFYhC////D4M3A+gBIAQgEUIEhkLw//8PgyATQjyIhDcD4AEgBCAFKQBgIhBCIIhC////D4M3A4ACIAQgEEIHiEL///8PgzcD+AEgBCAQQhKGQoCA8A+DIBFCLoiENwPwASAEIAUpAGgiEUISiEL///8PgzcDkAIgBCARQgeGQoD//w+DIBBCOYiENwOIAiAEIAUpAHAiEEIdiEL///8PgzcDqAIgBCAQQgSIQv///w+DNwOgAiAEIBBCFYZCgICAD4MgEUIriIQ3A5gCIAQgBSkAeCIRQg+IQv///w+DNwO4AiAEIBFCCoZCgPj/D4MgEEI2iIQ3A7ACIAQgBSkAgAEiEEIaiEL///8PgzcD0AIgBCAQQgGIQv///w+DNwPIAiAEIBBCGIZCgICACIMgEUIoiIQ3A8ACIAQgBSkAiAEiEUIliEL///8PgzcD6AIgBCARQgyIQv///w+DNwPgAiAEIBFCDYZCgMD/D4MgEEIziIQ3A9gCIAQgBSkAkAEiEkIXiEL///8PgzcD+AIgBCASQgKGQvz//w+DIBFCPoiENwPwAiAEIAUpAJgBIhBCIohC////D4M3A5ADIAQgEEIJiEL///8PgzcDiAMgBCAQQhCGQoCA/A+DIBJCMIiENwOAAyAEIAUpAKABIhFCFIhC////D4M3A6ADIAQgEUIFhkLg//8PgyAQQjuIhDcDmAMgBCAFKQCoASIQQh+IQv///w+DNwO4AyAEIBBCBohC////D4M3A7ADIAQgEEIThkKAgOAPgyARQi2IhDcDqAMgBCAFKQCwASIRQhGIQv///w+DNwPIAyAEIBFCCIZCgP7/D4MgEEI4iIQ3A8ADIAQgBSkAuAEiEEIciEL///8PgzcD4AMgBCAQQgOIQv///w+DNwPYAyAEIBBCFoZCgICADoMgEUIqiIQ3A9ADIAQgBSkAwAEiEUIniDcD+AMgBCARQg6IQv///w+DNwPwAyAEIBFCC4ZCgPD/D4MgEEI1iIQ3A+gDDCgLIAZBzwFNBEAMMAsgBCAFKQAAIhJC////H4M3AwAgBCASQhqIQv///x+DNwMIIAQgBSkACCITQg6IQv///x+DNwMYIAQgBSkAECIQQhyIQv///x+DNwMwIAQgEEICiEL///8fgzcDKCAEIAUpABgiFEIQiEL///8fgzcDQCAEIAUpACAiEUIeiEL///8fgzcDWCAEIBFCBIhC////H4M3A1AgBCAFKQAoIhVCEohC////H4M3A2ggBCATQgyGQoDg/x+DIBJCNIiENwMQIAQgEEIYhkKAgIAYgyATQiiIhDcDICAEIBRCCoZCgPj/H4MgEEI2iIQ3AzggBCARQhaGQoCAgB6DIBRCKoiENwNIIAQgFUIIhkKA/v8fgyARQjiIhDcDYCAEIAUpADAiEEIgiEL///8fgzcDgAEgBCAQQgaIQv///x+DNwN4IAQgBSkAOCITQhSIQv///x+DNwOQASAEIAUpAEAiEUIiiEL///8fgzcDqAEgBCARQgiIQv///x+DNwOgASAEIAUpAEgiFEIWiEL///8fgzcDuAEgBCAFKQBQIhJCJIhC////H4M3A9ABIAQgEkIKiEL///8fgzcDyAEgBCAQQhSGQoCAwB+DIBVCLIiENwNwIAQgE0IGhkLA//8fgyAQQjqIhDcDiAEgBCARQhKGQoCA8B+DIBNCLoiENwOYASAEIBRCBIZC8P//H4MgEUI8iIQ3A7ABIAQgEkIQhkKAgPwfgyAUQjCIhDcDwAEgBCAFKQBYIhBCGIhC////H4M3A+ABIAQgEEIChkL8//8fgyASQj6IhDcD2AEgBCAFKQBgIhFCJog3A/gBIAQgEUIMiEL///8fgzcD8AEgBCARQg6GQoCA/x+DIBBCMoiENwPoASAEIAUpAGgiEEL///8fgzcDgAIgBCAQQhqIQv///x+DNwOIAiAEIAUpAHAiEUIOiEL///8fgzcDmAIgBCARQgyGQoDg/x+DIBBCNIiENwOQAiAEIAUpAHgiEEIciEL///8fgzcDsAIgBCAQQgKIQv///x+DNwOoAiAEIBBCGIZCgICAGIMgEUIoiIQ3A6ACIAQgBSkAgAEiEUIQiEL///8fgzcDwAIgBCARQgqGQoD4/x+DIBBCNoiENwO4AiAEIAUpAIgBIhBCHohC////H4M3A9gCIAQgEEIEiEL///8fgzcD0AIgBCAQQhaGQoCAgB6DIBFCKoiENwPIAiAEIAUpAJABIhFCEohC////H4M3A+gCIAQgEUIIhkKA/v8fgyAQQjiIhDcD4AIgBCAFKQCYASIQQiCIQv///x+DNwOAAyAEIBBCBohC////H4M3A/gCIAQgEEIUhkKAgMAfgyARQiyIhDcD8AIgBCAFKQCgASIRQhSIQv///x+DNwOQAyAEIBFCBoZCwP//H4MgEEI6iIQ3A4gDIAQgBSkAqAEiEEIiiEL///8fgzcDqAMgBCAQQgiIQv///x+DNwOgAyAEIBBCEoZCgIDwH4MgEUIuiIQ3A5gDIAQgBSkAsAEiEUIWiEL///8fgzcDuAMgBCARQgSGQvD//x+DIBBCPIiENwOwAyAEIAUpALgBIhBCJIhC////H4M3A9ADIAQgEEIKiEL///8fgzcDyAMgBCAQQhCGQoCA/B+DIBFCMIiENwPAAyAEIAUpAMABIhFCGIhC////H4M3A+ADIAQgEUIChkL8//8fgyAQQj6IhDcD2AMgBCAFKQDIASIQQiaINwP4AyAEIBBCDIhC////H4M3A/ADIAQgEEIOhkKAgP8fgyARQjKIhDcD6AMMJwsgBkHXAU0EQAwvCyAEIAUpAAAiEkL///8/gzcDACAEIBJCG4hC////P4M3AwggBCAFKQAIIhNCEYhC////P4M3AxggBCAFKQAQIhBCIohC////P4M3AzAgBCAQQgeIQv///z+DNwMoIAQgBSkAGCIUQhiIQv///z+DNwNAIAQgBSkAICIVQg6IQv///z+DNwNQIAQgBSkAKCIRQh+IQv///z+DNwNoIAQgEUIEiEL///8/gzcDYCAEIBNCCoZCgPj/P4MgEkI2iIQ3AxAgBCAQQhSGQoCAwD+DIBNCLIiENwMgIAQgFEIDhkL4//8/gyAQQj2IhDcDOCAEIBVCDYZCgMD/P4MgFEIziIQ3A0ggBCARQheGQoCAgDyDIBVCKYiENwNYIAQgBSkAMCITQhWIQv///z+DNwN4IAQgBSkAOCIUQguIQv///z+DNwOIASAEIAUpAEAiEEIciEL///8/gzcDoAEgBCAQQgGIQv///z+DNwOYASAEIAUpAEgiFUISiEL///8/gzcDsAEgBCAFKQBQIhJCI4hC////P4M3A8gBIAQgEkIIiEL///8/gzcDwAEgBCATQgaGQsD//z+DIBFCOoiENwNwIAQgFEIQhkKAgPw/gyATQjCIhDcDgAEgBCAQQhqGQoCAgCCDIBRCJoiENwOQASAEIBVCCYZCgPz/P4MgEEI3iIQ3A6gBIAQgEkIThkKAgOA/gyAVQi2IhDcDuAEgBCAFKQBYIhBCGYhC////P4M3A9gBIAQgEEIChkL8//8/gyASQj6IhDcD0AEgBCAFKQBgIhFCD4hC////P4M3A+gBIAQgEUIMhkKA4P8/gyAQQjSIhDcD4AEgBCAFKQBoIhBCIIhC////P4M3A4ACIAQgEEIFiEL///8/gzcD+AEgBCAQQhaGQoCAgD6DIBFCKoiENwPwASAEIAUpAHAiEUIWiEL///8/gzcDkAIgBCARQgWGQuD//z+DIBBCO4iENwOIAiAEIAUpAHgiEkIMiEL///8/gzcDoAIgBCASQg+GQoCA/j+DIBFCMYiENwOYAiAEIAUpAIABIhBCHYhC////P4M3A7gCIAQgEEICiEL///8/gzcDsAIgBCAQQhmGQoCAgDCDIBJCJ4iENwOoAiAEIAUpAIgBIhFCE4hC////P4M3A8gCIAQgEUIIhkKA/v8/gyAQQjiIhDcDwAIgBCAFKQCQASIQQiSIQv///z+DNwPgAiAEIBBCCYhC////P4M3A9gCIAQgEEIShkKAgPA/gyARQi6IhDcD0AIgBCAFKQCYASIRQhqIQv///z+DNwPwAiAEIBFCAYZC/v//P4MgEEI/iIQ3A+gCIAQgBSkAoAEiEkIQiEL///8/gzcDgAMgBCASQguGQoDw/z+DIBFCNYiENwP4AiAEIAUpAKgBIhBCIYhC////P4M3A5gDIAQgEEIGiEL///8/gzcDkAMgBCAQQhWGQoCAgD+DIBJCK4iENwOIAyAEIAUpALABIhFCF4hC////P4M3A6gDIAQgEUIEhkLw//8/gyAQQjyIhDcDoAMgBCAFKQC4ASISQg2IQv///z+DNwO4AyAEIBJCDoZCgID/P4MgEUIyiIQ3A7ADIAQgBSkAwAEiEEIeiEL///8/gzcD0AMgBCAQQgOIQv///z+DNwPIAyAEIBBCGIZCgICAOIMgEkIoiIQ3A8ADIAQgBSkAyAEiEUIUiEL///8/gzcD4AMgBCARQgeGQoD//z+DIBBCOYiENwPYAyAEIAUpANABIhBCJYg3A/gDIAQgEEIKiEL///8/gzcD8AMgBCAQQhGGQoCA+D+DIBFCL4iENwPoAwwmCyAGQd8BTQRADC4LIAQgBSkAACIRQv////8AgzcDACAEIBFCHIhC/////wCDNwMIIAQgBSkACCISQhSIQv////8AgzcDGCAEIAUpABAiE0IMiEL/////AIM3AyggBCAFKQAYIhBCIIhC/////wCDNwNAIAQgEEIEiEL/////AIM3AzggBCAFKQAgIhRCGIhC/////wCDNwNQIAQgBSkAKCIVQhCIQv////8AgzcDYCAEIBJCCIZCgP7//wCDIBFCOIiENwMQIAQgE0IQhkKAgPz/AIMgEkIwiIQ3AyAgBCAQQhiGQoCAgPgAgyATQiiIhDcDMCAEIBRCBIZC8P///wCDIBBCPIiENwNIIAQgFUIMhkKA4P//AIMgFEI0iIQ3A1ggBCAFKQAwIhFCJIg3A3ggBCAFKQA4IhJC/////wCDNwOAASAEIBFCCIhC/////wCDNwNwIAQgEkIciEL/////AIM3A4gBIAQgBSkAQCITQhSIQv////8AgzcDmAEgBCAFKQBIIhRCDIhC/////wCDNwOoASAEIAUpAFAiEEIgiEL/////AIM3A8ABIAQgEEIEiEL/////AIM3A7gBIAQgEUIUhkKAgMD/AIMgFUIsiIQ3A2ggBCATQgiGQoD+//8AgyASQjiIhDcDkAEgBCAUQhCGQoCA/P8AgyATQjCIhDcDoAEgBCAQQhiGQoCAgPgAgyAUQiiIhDcDsAEgBCAFKQBYIhFCGIhC/////wCDNwPQASAEIBFCBIZC8P///wCDIBBCPIiENwPIASAEIAUpAGAiEEIQiEL/////AIM3A+ABIAQgEEIMhkKA4P//AIMgEUI0iIQ3A9gBIAQgBSkAaCIRQiSINwP4ASAEIBFCCIhC/////wCDNwPwASAEIBFCFIZCgIDA/wCDIBBCLIiENwPoASAEIAUpAHAiEEL/////AIM3A4ACIAQgEEIciEL/////AIM3A4gCIAQgBSkAeCIRQhSIQv////8AgzcDmAIgBCARQgiGQoD+//8AgyAQQjiIhDcDkAIgBCAFKQCAASISQgyIQv////8AgzcDqAIgBCASQhCGQoCA/P8AgyARQjCIhDcDoAIgBCAFKQCIASIQQiCIQv////8AgzcDwAIgBCAQQgSIQv////8AgzcDuAIgBCAQQhiGQoCAgPgAgyASQiiIhDcDsAIgBCAFKQCQASIRQhiIQv////8AgzcD0AIgBCARQgSGQvD///8AgyAQQjyIhDcDyAIgBCAFKQCYASIQQhCIQv////8AgzcD4AIgBCAQQgyGQoDg//8AgyARQjSIhDcD2AIgBCAFKQCgASIRQiSINwP4AiAEIBFCCIhC/////wCDNwPwAiAEIBFCFIZCgIDA/wCDIBBCLIiENwPoAiAEIAUpAKgBIhBC/////wCDNwOAAyAEIBBCHIhC/////wCDNwOIAyAEIAUpALABIhFCFIhC/////wCDNwOYAyAEIBFCCIZCgP7//wCDIBBCOIiENwOQAyAEIAUpALgBIhJCDIhC/////wCDNwOoAyAEIBJCEIZCgID8/wCDIBFCMIiENwOgAyAEIAUpAMABIhBCIIhC/////wCDNwPAAyAEIBBCBIhC/////wCDNwO4AyAEIBBCGIZCgICA+ACDIBJCKIiENwOwAyAEIAUpAMgBIhFCGIhC/////wCDNwPQAyAEIBFCBIZC8P///wCDIBBCPIiENwPIAyAEIAUpANABIhBCEIhC/////wCDNwPgAyAEIBBCDIZCgOD//wCDIBFCNIiENwPYAyAEIAUpANgBIhFCJIg3A/gDIAQgEUIIiEL/////AIM3A/ADIAQgEUIUhkKAgMD/AIMgEEIsiIQ3A+gDDCULIAZB5wFNBEAMLQsgBCAFKQAAIhFC/////wGDNwMAIAQgEUIdiEL/////AYM3AwggBCAFKQAIIhJCF4hC/////wGDNwMYIAQgBSkAECITQhGIQv////8BgzcDKCAEIAUpABgiFEILiEL/////AYM3AzggBCAFKQAgIhBCIohC/////wGDNwNQIAQgEEIFiEL/////AYM3A0ggBCAFKQAoIhVCHIhC/////wGDNwNgIAQgEkIGhkLA////AYMgEUI6iIQ3AxAgBCATQgyGQoDg//8BgyASQjSIhDcDICAEIBRCEoZCgIDw/wGDIBNCLoiENwMwIAQgEEIYhkKAgID4AYMgFEIoiIQ3A0AgBCAVQgGGQv7///8BgyAQQj+IhDcDWCAEIAUpADAiEUIWiEL/////AYM3A3AgBCAFKQA4IhJCEIhC/////wGDNwOAASAEIAUpAEAiE0IKiEL/////AYM3A5ABIAQgBSkASCIQQiGIQv////8BgzcDqAEgBCAQQgSIQv////8BgzcDoAEgBCAFKQBQIhRCG4hC/////wGDNwO4ASAEIAUpAFgiFkIViEL/////AYM3A8gBIAQgEUIHhkKA////AYMgFUI5iIQ3A2ggBCASQg2GQoDA//8BgyARQjOIhDcDeCAEIBNCE4ZCgIDg/wGDIBJCLYiENwOIASAEIBBCGYZCgICA8AGDIBNCJ4iENwOYASAEIBRCAoZC/P///wGDIBBCPoiENwOwASAEIBZCCIZCgP7//wGDIBRCOIiENwPAASAEIAUpAGAiEEIPiEL/////AYM3A9gBIAQgEEIOhkKAgP//AYMgFkIyiIQ3A9ABIAQgBSkAaCIRQgmIQv////8BgzcD6AEgBCARQhSGQoCAwP8BgyAQQiyIhDcD4AEgBCAFKQBwIhBCIIhC/////wGDNwOAAiAEIBBCA4hC/////wGDNwP4ASAEIBBCGoZCgICA4AGDIBFCJoiENwPwASAEIAUpAHgiEUIaiEL/////AYM3A5ACIAQgEUIDhkL4////AYMgEEI9iIQ3A4gCIAQgBSkAgAEiEEIUiEL/////AYM3A6ACIAQgEEIJhkKA/P//AYMgEUI3iIQ3A5gCIAQgBSkAiAEiEUIOiEL/////AYM3A7ACIAQgEUIPhkKAgP7/AYMgEEIxiIQ3A6gCIAQgBSkAkAEiEkIIiEL/////AYM3A8ACIAQgEkIVhkKAgID/AYMgEUIriIQ3A7gCIAQgBSkAmAEiEEIfiEL/////AYM3A9gCIAQgEEICiEL/////AYM3A9ACIAQgEEIbhkKAgIDAAYMgEkIliIQ3A8gCIAQgBSkAoAEiEUIZiEL/////AYM3A+gCIAQgEUIEhkLw////AYMgEEI8iIQ3A+ACIAQgBSkAqAEiEEITiEL/////AYM3A/gCIAQgEEIKhkKA+P//AYMgEUI2iIQ3A/ACIAQgBSkAsAEiEUINiEL/////AYM3A4gDIAQgEUIQhkKAgPz/AYMgEEIwiIQ3A4ADIAQgBSkAuAEiEkIHiEL/////AYM3A5gDIAQgEkIWhkKAgID+AYMgEUIqiIQ3A5ADIAQgBSkAwAEiEEIeiEL/////AYM3A7ADIAQgEEIBiEL/////AYM3A6gDIAQgEEIchkKAgICAAYMgEkIkiIQ3A6ADIAQgBSkAyAEiEUIYiEL/////AYM3A8ADIAQgEUIFhkLg////AYMgEEI7iIQ3A7gDIAQgBSkA0AEiEEISiEL/////AYM3A9ADIAQgEEILhkKA8P//AYMgEUI1iIQ3A8gDIAQgBSkA2AEiEUIMiEL/////AYM3A+ADIAQgEUIRhkKAgPj/AYMgEEIviIQ3A9gDIAQgBSkA4AEiEEIjiDcD+AMgBCAQQgaIQv////8BgzcD8AMgBCAQQheGQoCAgPwBgyARQimIhDcD6AMMJAsgBkHvAU0EQAwsCyAEIAUpAAAiEEL/////A4M3AwAgBCAQQh6IQv////8DgzcDCCAEIAUpAAgiEUIaiEL/////A4M3AxggBCAFKQAQIhJCFohC/////wODNwMoIAQgBSkAGCITQhKIQv////8DgzcDOCAEIAUpACAiFEIOiEL/////A4M3A0ggBCAFKQAoIhVCCohC/////wODNwNYIAQgEUIEhkLw////A4MgEEI8iIQ3AxAgBCASQgiGQoD+//8DgyARQjiIhDcDICAEIBNCDIZCgOD//wODIBJCNIiENwMwIAQgFEIQhkKAgPz/A4MgE0IwiIQ3A0AgBCAVQhSGQoCAwP8DgyAUQiyIhDcDUCAEIAUpADAiEUIGiEL/////A4M3A2ggBCARQhiGQoCAgPgDgyAVQiiIhDcDYCAEIAUpADgiEEIgiEL/////A4M3A4ABIAQgEEICiEL/////A4M3A3ggBCAFKQBAIhJCHIhC/////wODNwOQASAEIAUpAEgiE0IYiEL/////A4M3A6ABIAQgBSkAUCIUQhSIQv////8DgzcDsAEgBCAFKQBYIhVCEIhC/////wODNwPAASAEIBBCHIZCgICAgAODIBFCJIiENwNwIAQgEkIChkL8////A4MgEEI+iIQ3A4gBIAQgE0IGhkLA////A4MgEkI6iIQ3A5gBIAQgFEIKhkKA+P//A4MgE0I2iIQ3A6gBIAQgFUIOhkKAgP//A4MgFEIyiIQ3A7gBIAQgBSkAYCIQQgyIQv////8DgzcD0AEgBCAQQhKGQoCA8P8DgyAVQi6IhDcDyAEgBCAFKQBoIhFCCIhC/////wODNwPgASAEIBFCFoZCgICA/gODIBBCKoiENwPYASAEIAUpAHAiEEIiiDcD+AEgBCAQQgSIQv////8DgzcD8AEgBCAQQhqGQoCAgOADgyARQiaIhDcD6AEgBCAFKQB4IhBC/////wODNwOAAiAEIBBCHohC/////wODNwOIAiAEIAUpAIABIhFCGohC/////wODNwOYAiAEIBFCBIZC8P///wODIBBCPIiENwOQAiAEIAUpAIgBIhBCFohC/////wODNwOoAiAEIBBCCIZCgP7//wODIBFCOIiENwOgAiAEIAUpAJABIhFCEohC/////wODNwO4AiAEIBFCDIZCgOD//wODIBBCNIiENwOwAiAEIAUpAJgBIhBCDohC/////wODNwPIAiAEIBBCEIZCgID8/wODIBFCMIiENwPAAiAEIAUpAKABIhFCCohC/////wODNwPYAiAEIBFCFIZCgIDA/wODIBBCLIiENwPQAiAEIAUpAKgBIhJCBohC/////wODNwPoAiAEIBJCGIZCgICA+AODIBFCKIiENwPgAiAEIAUpALABIhBCIIhC/////wODNwOAAyAEIBBCAohC/////wODNwP4AiAEIBBCHIZCgICAgAODIBJCJIiENwPwAiAEIAUpALgBIhFCHIhC/////wODNwOQAyAEIBFCAoZC/P///wODIBBCPoiENwOIAyAEIAUpAMABIhBCGIhC/////wODNwOgAyAEIBBCBoZCwP///wODIBFCOoiENwOYAyAEIAUpAMgBIhFCFIhC/////wODNwOwAyAEIBFCCoZCgPj//wODIBBCNoiENwOoAyAEIAUpANABIhBCEIhC/////wODNwPAAyAEIBBCDoZCgID//wODIBFCMoiENwO4AyAEIAUpANgBIhFCDIhC/////wODNwPQAyAEIBFCEoZCgIDw/wODIBBCLoiENwPIAyAEIAUpAOABIhBCCIhC/////wODNwPgAyAEIBBCFoZCgICA/gODIBFCKoiENwPYAyAEIAUpAOgBIhFCIog3A/gDIAQgEUIEiEL/////A4M3A/ADIAQgEUIahkKAgIDgA4MgEEImiIQ3A+gDDCMLIAZB9wFNBEAMKwsgBCAFKQAAIhBC/////weDNwMAIAQgEEIfiEL/////B4M3AwggBCAFKQAIIhFCHYhC/////weDNwMYIAQgBSkAECISQhuIQv////8HgzcDKCAEIAUpABgiE0IZiEL/////B4M3AzggBCAFKQAgIhRCF4hC/////weDNwNIIAQgBSkAKCIVQhWIQv////8HgzcDWCAEIBFCAoZC/P///weDIBBCPoiENwMQIAQgEkIEhkLw////B4MgEUI8iIQ3AyAgBCATQgaGQsD///8HgyASQjqIhDcDMCAEIBRCCIZCgP7//weDIBNCOIiENwNAIAQgFUIKhkKA+P//B4MgFEI2iIQ3A1AgBCAFKQAwIhBCE4hC/////weDNwNoIAQgEEIMhkKA4P//B4MgFUI0iIQ3A2AgBCAFKQA4IhFCEYhC/////weDNwN4IAQgBSkAQCISQg+IQv////8HgzcDiAEgBCAFKQBIIhNCDYhC/////weDNwOYASAEIAUpAFAiFEILiEL/////B4M3A6gBIAQgBSkAWCIVQgmIQv////8HgzcDuAEgBCARQg6GQoCA//8HgyAQQjKIhDcDcCAEIBJCEIZCgID8/weDIBFCMIiENwOAASAEIBNCEoZCgIDw/weDIBJCLoiENwOQASAEIBRCFIZCgIDA/weDIBNCLIiENwOgASAEIBVCFoZCgICA/geDIBRCKoiENwOwASAEIAUpAGAiEEIHiEL/////B4M3A8gBIAQgEEIYhkKAgID4B4MgFUIoiIQ3A8ABIAQgBSkAaCIRQgWIQv////8HgzcD2AEgBCARQhqGQoCAgOAHgyAQQiaIhDcD0AEgBCAFKQBwIhJCA4hC/////weDNwPoASAEIBJCHIZCgICAgAeDIBFCJIiENwPgASAEIAUpAHgiEEIgiEL/////B4M3A4ACIAQgEEIBiEL/////B4M3A/gBIAQgEEIehkKAgICABIMgEkIiiIQ3A/ABIAQgBSkAgAEiEUIeiEL/////B4M3A5ACIAQgEUIBhkL+////B4MgEEI/iIQ3A4gCIAQgBSkAiAEiEEIciEL/////B4M3A6ACIAQgEEIDhkL4////B4MgEUI9iIQ3A5gCIAQgBSkAkAEiEUIaiEL/////B4M3A7ACIAQgEUIFhkLg////B4MgEEI7iIQ3A6gCIAQgBSkAmAEiEEIYiEL/////B4M3A8ACIAQgEEIHhkKA////B4MgEUI5iIQ3A7gCIAQgBSkAoAEiEUIWiEL/////B4M3A9ACIAQgEUIJhkKA/P//B4MgEEI3iIQ3A8gCIAQgBSkAqAEiEEIUiEL/////B4M3A+ACIAQgEEILhkKA8P//B4MgEUI1iIQ3A9gCIAQgBSkAsAEiEUISiEL/////B4M3A/ACIAQgEUINhkKAwP//B4MgEEIziIQ3A+gCIAQgBSkAuAEiEEIQiEL/////B4M3A4ADIAQgEEIPhkKAgP7/B4MgEUIxiIQ3A/gCIAQgBSkAwAEiEUIOiEL/////B4M3A5ADIAQgEUIRhkKAgPj/B4MgEEIviIQ3A4gDIAQgBSkAyAEiEEIMiEL/////B4M3A6ADIAQgEEIThkKAgOD/B4MgEUItiIQ3A5gDIAQgBSkA0AEiEUIKiEL/////B4M3A7ADIAQgEUIVhkKAgID/B4MgEEIriIQ3A6gDIAQgBSkA2AEiEEIIiEL/////B4M3A8ADIAQgEEIXhkKAgID8B4MgEUIpiIQ3A7gDIAQgBSkA4AEiEUIGiEL/////B4M3A9ADIAQgEUIZhkKAgIDwB4MgEEIniIQ3A8gDIAQgBSkA6AEiEEIEiEL/////B4M3A+ADIAQgEEIbhkKAgIDAB4MgEUIliIQ3A9gDIAQgBSkA8AEiEUIhiDcD+AMgBCARQgKIQv////8HgzcD8AMgBCARQh2GQoCAgIAGgyAQQiOIhDcD6AMMIgsgBkH/AU0EQAwqCyAEIAUpAAAiEEIgiDcDCCAEIBBC/////w+DNwMAIAQgBSkACCIQQiCINwMYIAQgEEL/////D4M3AxAgBCAFKQAQIhBCIIg3AyggBCAQQv////8PgzcDICAEIAUpABgiEEIgiDcDOCAEIBBC/////w+DNwMwIAQgBSkAICIQQiCINwNIIAQgEEL/////D4M3A0AgBCAFKQAoIhBCIIg3A1ggBCAQQv////8PgzcDUCAEIAUpADAiEEIgiDcDaCAEIBBC/////w+DNwNgIAQgBSkAOCIQQiCINwN4IAQgEEL/////D4M3A3AgBCAFKQBAIhBCIIg3A4gBIAQgEEL/////D4M3A4ABIAQgBSkASCIQQiCINwOYASAEIBBC/////w+DNwOQASAEIAUpAFAiEEIgiDcDqAEgBCAQQv////8PgzcDoAEgBCAFKQBYIhBC/////w+DNwOwASAEIBBCIIg3A7gBIAQgBSkAYCIQQiCINwPIASAEIBBC/////w+DNwPAASAEIAUpAGgiEEIgiDcD2AEgBCAQQv////8PgzcD0AEgBCAFKQBwIhBCIIg3A+gBIAQgEEL/////D4M3A+ABIAQgBSkAeCIQQiCINwP4ASAEIBBC/////w+DNwPwASAEIAUpAIABIhBCIIg3A4gCIAQgEEL/////D4M3A4ACIAQgBSkAiAEiEEIgiDcDmAIgBCAQQv////8PgzcDkAIgBCAFKQCQASIQQiCINwOoAiAEIBBC/////w+DNwOgAiAEIAUpAJgBIhBCIIg3A7gCIAQgEEL/////D4M3A7ACIAQgBSkAoAEiEEIgiDcDyAIgBCAQQv////8PgzcDwAIgBCAFKQCoASIQQiCINwPYAiAEIBBC/////w+DNwPQAiAEIAUpALABIhBCIIg3A+gCIAQgEEL/////D4M3A+ACIAQgBSkAuAEiEEIgiDcD+AIgBCAQQv////8PgzcD8AIgBCAFKQDAASIQQiCINwOIAyAEIBBC/////w+DNwOAAyAEIAUpAMgBIhBCIIg3A5gDIAQgEEL/////D4M3A5ADIAQgBSkA0AEiEEIgiDcDqAMgBCAQQv////8PgzcDoAMgBCAFKQDYASIQQiCINwO4AyAEIBBC/////w+DNwOwAyAEIAUpAOABIhBCIIg3A8gDIAQgEEL/////D4M3A8ADIAQgBSkA6AEiEEIgiDcD2AMgBCAQQv////8PgzcD0AMgBCAFKQDwASIQQiCINwPoAyAEIBBC/////w+DNwPgAyAEIAUpAPgBIhBCIIg3A/gDIAQgEEL/////D4M3A/ADDCELIAZBhwJNBEAMKQsgBCAFKQAAIhZC/////x+DNwMAIAQgBSkACCIQQgKIQv////8fgzcDECAEIAUpABAiEUIEiEL/////H4M3AyAgBCAFKQAYIhJCBohC/////x+DNwMwIAQgBSkAICITQgiIQv////8fgzcDQCAEIAUpACgiFEIKiEL/////H4M3A1AgBCAFKQAwIhVCDIhC/////x+DNwNgIAQgEEIfhkKAgICAGIMgFkIhiIQ3AwggBCARQh2GQoCAgIAegyAQQiOIhDcDGCAEIBJCG4ZCgICAwB+DIBFCJYiENwMoIAQgE0IZhkKAgIDwH4MgEkIniIQ3AzggBCAUQheGQoCAgPwfgyATQimIhDcDSCAEIBVCFYZCgICA/x+DIBRCK4iENwNYIAQgBSkAOCIQQg6IQv////8fgzcDcCAEIAUpAEAiEUIQiEL/////H4M3A4ABIAQgBSkASCISQhKIQv////8fgzcDkAEgBCAFKQBQIhNCFIhC/////x+DNwOgASAEIAUpAFgiFEIWiEL/////H4M3A7ABIAQgBSkAYCIWQhiIQv////8fgzcDwAEgBCAQQhOGQoCA4P8fgyAVQi2IhDcDaCAEIBFCEYZCgID4/x+DIBBCL4iENwN4IAQgEkIPhkKAgP7/H4MgEUIxiIQ3A4gBIAQgE0INhkKAwP//H4MgEkIziIQ3A5gBIAQgFEILhkKA8P//H4MgE0I1iIQ3A6gBIAQgFkIJhkKA/P//H4MgFEI3iIQ3A7gBIAQgBSkAaCIQQhqIQv////8fgzcD0AEgBCAQQgeGQoD///8fgyAWQjmIhDcDyAEgBCAFKQBwIhFCHIhC/////x+DNwPgASAEIBFCBYZC4P///x+DIBBCO4iENwPYASAEIAUpAHgiEEIeiEL/////H4M3A/ABIAQgEEIDhkL4////H4MgEUI9iIQ3A+gBIAQgBSkAgAEiEUIBhkL+////H4MgEEI/iIQ3A/gBIAQgBSkAiAEiEEIBiEL/////H4M3A4gCIAQgEEIghkKAgICAEIMgEUIgiIQ3A4ACIAQgBSkAkAEiEUIDiEL/////H4M3A5gCIAQgEUIehkKAgICAHIMgEEIiiIQ3A5ACIAQgBSkAmAEiEEIFiEL/////H4M3A6gCIAQgEEIchkKAgICAH4MgEUIkiIQ3A6ACIAQgBSkAoAEiEUIHiEL/////H4M3A7gCIAQgEUIahkKAgIDgH4MgEEImiIQ3A7ACIAQgBSkAqAEiEEIJiEL/////H4M3A8gCIAQgEEIYhkKAgID4H4MgEUIoiIQ3A8ACIAQgBSkAsAEiEUILiEL/////H4M3A9gCIAQgEUIWhkKAgID+H4MgEEIqiIQ3A9ACIAQgBSkAuAEiEEINiEL/////H4M3A+gCIAQgEEIUhkKAgMD/H4MgEUIsiIQ3A+ACIAQgBSkAwAEiEUIPiEL/////H4M3A/gCIAQgEUIShkKAgPD/H4MgEEIuiIQ3A/ACIAQgBSkAyAEiEEIRiEL/////H4M3A4gDIAQgEEIQhkKAgPz/H4MgEUIwiIQ3A4ADIAQgBSkA0AEiEUITiEL/////H4M3A5gDIAQgEUIOhkKAgP//H4MgEEIyiIQ3A5ADIAQgBSkA2AEiEEIViEL/////H4M3A6gDIAQgEEIMhkKA4P//H4MgEUI0iIQ3A6ADIAQgBSkA4AEiEUIXiEL/////H4M3A7gDIAQgEUIKhkKA+P//H4MgEEI2iIQ3A7ADIAQgBSkA6AEiEEIZiEL/////H4M3A8gDIAQgEEIIhkKA/v//H4MgEUI4iIQ3A8ADIAQgBSkA8AEiEUIbiEL/////H4M3A9gDIAQgEUIGhkLA////H4MgEEI6iIQ3A9ADIAQgBSkA+AEiEEIdiEL/////H4M3A+gDIAQgEEIEhkLw////H4MgEUI8iIQ3A+ADIAQgBSkAgAIiEUIfiDcD+AMgBCARQgKGQvz///8fgyAQQj6IhDcD8AMMIAsgBkGPAk0EQAwoCyAEIAUpAAAiFkL/////P4M3AwAgBCAFKQAIIhBCBIhC/////z+DNwMQIAQgBSkAECIRQgiIQv////8/gzcDICAEIAUpABgiEkIMiEL/////P4M3AzAgBCAFKQAgIhNCEIhC/////z+DNwNAIAQgBSkAKCIUQhSIQv////8/gzcDUCAEIAUpADAiFUIYiEL/////P4M3A2AgBCAQQh6GQoCAgIA8gyAWQiKIhDcDCCAEIBFCGoZCgICA4D+DIBBCJoiENwMYIAQgEkIWhkKAgID+P4MgEUIqiIQ3AyggBCATQhKGQoCA8P8/gyASQi6IhDcDOCAEIBRCDoZCgID//z+DIBNCMoiENwNIIAQgFUIKhkKA+P//P4MgFEI2iIQ3A1ggBCAFKQA4IhBCHIhC/////z+DNwNwIAQgBSkASCIRQgKIQv////8/gzcDiAEgBCAFKQBQIhJCBohC/////z+DNwOYASAEIAUpAFgiE0IKiEL/////P4M3A6gBIAQgBSkAYCIUQg6IQv////8/gzcDuAEgBCAQQgaGQsD///8/gyAVQjqIhDcDaCAEIAUpAEAiFUIChkL8////P4MgEEI+iIQ3A3ggBCARQiCGQoCAgIAwgyAVQiCIhDcDgAEgBCASQhyGQoCAgIA/gyARQiSIhDcDkAEgBCATQhiGQoCAgPg/gyASQiiIhDcDoAEgBCAUQhSGQoCAwP8/gyATQiyIhDcDsAEgBCAFKQBoIhBCEohC/////z+DNwPIASAEIBBCEIZCgID8/z+DIBRCMIiENwPAASAEIAUpAHAiEUIWiEL/////P4M3A9gBIAQgEUIMhkKA4P//P4MgEEI0iIQ3A9ABIAQgBSkAeCIQQhqIQv////8/gzcD6AEgBCAQQgiGQoD+//8/gyARQjiIhDcD4AEgBCAFKQCAASIRQh6INwP4ASAEIBFCBIZC8P///z+DIBBCPIiENwPwASAEIAUpAIgBIhFC/////z+DNwOAAiAEIAUpAJABIhBCBIhC/////z+DNwOQAiAEIBBCHoZCgICAgDyDIBFCIoiENwOIAiAEIAUpAJgBIhFCCIhC/////z+DNwOgAiAEIBFCGoZCgICA4D+DIBBCJoiENwOYAiAEIAUpAKABIhBCDIhC/////z+DNwOwAiAEIBBCFoZCgICA/j+DIBFCKoiENwOoAiAEIAUpAKgBIhFCEIhC/////z+DNwPAAiAEIBFCEoZCgIDw/z+DIBBCLoiENwO4AiAEIAUpALABIhBCFIhC/////z+DNwPQAiAEIBBCDoZCgID//z+DIBFCMoiENwPIAiAEIAUpALgBIhFCGIhC/////z+DNwPgAiAEIBFCCoZCgPj//z+DIBBCNoiENwPYAiAEIAUpAMABIhBCHIhC/////z+DNwPwAiAEIBBCBoZCwP///z+DIBFCOoiENwPoAiAEIAUpAMgBIhFCAoZC/P///z+DIBBCPoiENwP4AiAEIAUpANABIhBCAohC/////z+DNwOIAyAEIBBCIIZCgICAgDCDIBFCIIiENwOAAyAEIAUpANgBIhFCBohC/////z+DNwOYAyAEIBFCHIZCgICAgD+DIBBCJIiENwOQAyAEIAUpAOABIhBCCohC/////z+DNwOoAyAEIBBCGIZCgICA+D+DIBFCKIiENwOgAyAEIAUpAOgBIhFCDohC/////z+DNwO4AyAEIBFCFIZCgIDA/z+DIBBCLIiENwOwAyAEIAUpAPABIhBCEohC/////z+DNwPIAyAEIBBCEIZCgID8/z+DIBFCMIiENwPAAyAEIAUpAPgBIhFCFohC/////z+DNwPYAyAEIBFCDIZCgOD//z+DIBBCNIiENwPQAyAEIAUpAIACIhBCGohC/////z+DNwPoAyAEIBBCCIZCgP7//z+DIBFCOIiENwPgAyAEIAUpAIgCIhFCHog3A/gDIAQgEUIEhkLw////P4MgEEI8iIQ3A/ADDB8LIAZBlwJNBEAMJwsgBCAFKQAAIhVC//////8AgzcDACAEIAUpAAgiEEIGiEL//////wCDNwMQIAQgBSkAECIRQgyIQv//////AIM3AyAgBCAFKQAYIhJCEohC//////8AgzcDMCAEIAUpACAiE0IYiEL//////wCDNwNAIAQgBSkAMCIUQgGIQv//////AIM3A1ggBCAQQh2GQoCAgID+AIMgFUIjiIQ3AwggBCARQheGQoCAgPz/AIMgEEIpiIQ3AxggBCASQhGGQoCA+P//AIMgEUIviIQ3AyggBCATQguGQoDw////AIMgEkI1iIQ3AzggBCAFKQAoIhBCBYZC4P////8AgyATQjuIhDcDSCAEIBRCIoZCgICAgMAAgyAQQh6IhDcDUCAEIAUpADgiEEIHiEL//////wCDNwNoIAQgBSkAQCIRQg2IQv//////AIM3A3ggBCAFKQBIIhJCE4hC//////8AgzcDiAEgBCAFKQBQIhNCGYhC//////8AgzcDmAEgBCAFKQBgIhVCAohC//////8AgzcDsAEgBCAQQhyGQoCAgID/AIMgFEIkiIQ3A2AgBCARQhaGQoCAgP7/AIMgEEIqiIQ3A3AgBCASQhCGQoCA/P//AIMgEUIwiIQ3A4ABIAQgE0IKhkKA+P///wCDIBJCNoiENwOQASAEIAUpAFgiEEIEhkLw/////wCDIBNCPIiENwOgASAEIBVCIYZCgICAgOAAgyAQQh+IhDcDqAEgBCAFKQBoIhBCCIhC//////8AgzcDwAEgBCAQQhuGQoCAgMD/AIMgFUIliIQ3A7gBIAQgBSkAcCIRQg6IQv//////AIM3A9ABIAQgEUIVhkKAgID//wCDIBBCK4iENwPIASAEIAUpAHgiEEIUiEL//////wCDNwPgASAEIBBCD4ZCgID+//8AgyARQjGIhDcD2AEgBCAFKQCAASIRQhqIQv//////AIM3A/ABIAQgEUIJhkKA/P///wCDIBBCN4iENwPoASAEIAUpAIgBIhJCA4ZC+P////8AgyARQj2IhDcD+AEgBCAFKQCQASIQQgOIQv//////AIM3A4gCIAQgEEIghkKAgICA8ACDIBJCIIiENwOAAiAEIAUpAJgBIhFCCYhC//////8AgzcDmAIgBCARQhqGQoCAgOD/AIMgEEImiIQ3A5ACIAQgBSkAoAEiEEIPiEL//////wCDNwOoAiAEIBBCFIZCgIDA//8AgyARQiyIhDcDoAIgBCAFKQCoASIRQhWIQv//////AIM3A7gCIAQgEUIOhkKAgP///wCDIBBCMoiENwOwAiAEIAUpALABIhBCG4hC//////8AgzcDyAIgBCAQQgiGQoD+////AIMgEUI4iIQ3A8ACIAQgBSkAuAEiEUIChkL8/////wCDIBBCPoiENwPQAiAEIAUpAMABIhBCBIhC//////8AgzcD4AIgBCAQQh+GQoCAgID4AIMgEUIhiIQ3A9gCIAQgBSkAyAEiEUIKiEL//////wCDNwPwAiAEIBFCGYZCgICA8P8AgyAQQieIhDcD6AIgBCAFKQDQASIQQhCIQv//////AIM3A4ADIAQgEEIThkKAgOD//wCDIBFCLYiENwP4AiAEIAUpANgBIhFCFohC//////8AgzcDkAMgBCARQg2GQoDA////AIMgEEIziIQ3A4gDIAQgBSkA4AEiEEIciEL//////wCDNwOgAyAEIBBCB4ZCgP////8AgyARQjmIhDcDmAMgBCAFKQDoASIRQgGGQv7/////AIMgEEI/iIQ3A6gDIAQgBSkA8AEiEEIFiEL//////wCDNwO4AyAEIBBCHoZCgICAgPwAgyARQiKIhDcDsAMgBCAFKQD4ASIRQguIQv//////AIM3A8gDIAQgEUIYhkKAgID4/wCDIBBCKIiENwPAAyAEIAUpAIACIhBCEYhC//////8AgzcD2AMgBCAQQhKGQoCA8P//AIMgEUIuiIQ3A9ADIAQgBSkAiAIiEUIXiEL//////wCDNwPoAyAEIBFCDIZCgOD///8AgyAQQjSIhDcD4AMgBCAFKQCQAiIQQh2INwP4AyAEIBBCBoZCwP////8AgyARQjqIhDcD8AMMHgsgBkGfAk0EQAwmCyAEIAUpAAAiFUL//////wGDNwMAIAQgBSkACCIQQgiIQv//////AYM3AxAgBCAFKQAQIhFCEIhC//////8BgzcDICAEIAUpABgiEkIYiEL//////wGDNwMwIAQgBSkAKCITQgSIQv//////AYM3A0ggBCAFKQAwIhRCDIhC//////8BgzcDWCAEIBBCHIZCgICAgP8BgyAVQiSIhDcDCCAEIBFCFIZCgIDA//8BgyAQQiyIhDcDGCAEIBJCDIZCgOD///8BgyARQjSIhDcDKCAEIAUpACAiEEIEhkLw/////wGDIBJCPIiENwM4IAQgE0IghkKAgICA8AGDIBBCIIiENwNAIAQgFEIYhkKAgID4/wGDIBNCKIiENwNQIAQgBSkAQCIVQhyINwN4IAQgBSkASCIWQv//////AYM3A4ABIAQgBSkAOCIQQhSIQv//////AYM3A2ggBCAFKQBQIhFCCIhC//////8BgzcDkAEgBCAFKQBYIhJCEIhC//////8BgzcDoAEgBCAFKQBgIhNCGIhC//////8BgzcDsAEgBCAQQhCGQoCA/P//AYMgFEIwiIQ3A2AgBCAVQgiGQoD+////AYMgEEI4iIQ3A3AgBCARQhyGQoCAgID/AYMgFkIkiIQ3A4gBIAQgEkIUhkKAgMD//wGDIBFCLIiENwOYASAEIBNCDIZCgOD///8BgyASQjSIhDcDqAEgBCAFKQBoIhFCBIZC8P////8BgyATQjyIhDcDuAEgBCAFKQBwIhBCBIhC//////8BgzcDyAEgBCAQQiCGQoCAgIDwAYMgEUIgiIQ3A8ABIAQgBSkAeCIRQgyIQv//////AYM3A9gBIAQgEUIYhkKAgID4/wGDIBBCKIiENwPQASAEIAUpAIABIhBCFIhC//////8BgzcD6AEgBCAQQhCGQoCA/P//AYMgEUIwiIQ3A+ABIAQgBSkAiAEiEUIciDcD+AEgBCARQgiGQoD+////AYMgEEI4iIQ3A/ABIAQgBSkAkAEiEUL//////wGDNwOAAiAEIAUpAJgBIhBCCIhC//////8BgzcDkAIgBCAQQhyGQoCAgID/AYMgEUIkiIQ3A4gCIAQgBSkAoAEiEUIQiEL//////wGDNwOgAiAEIBFCFIZCgIDA//8BgyAQQiyIhDcDmAIgBCAFKQCoASIQQhiIQv//////AYM3A7ACIAQgEEIMhkKA4P///wGDIBFCNIiENwOoAiAEIAUpALABIhFCBIZC8P////8BgyAQQjyIhDcDuAIgBCAFKQC4ASIQQgSIQv//////AYM3A8gCIAQgEEIghkKAgICA8AGDIBFCIIiENwPAAiAEIAUpAMABIhFCDIhC//////8BgzcD2AIgBCARQhiGQoCAgPj/AYMgEEIoiIQ3A9ACIAQgBSkAyAEiEEIUiEL//////wGDNwPoAiAEIBBCEIZCgID8//8BgyARQjCIhDcD4AIgBCAFKQDQASIRQhyINwP4AiAEIBFCCIZCgP7///8BgyAQQjiIhDcD8AIgBCAFKQDYASIRQv//////AYM3A4ADIAQgBSkA4AEiEEIIiEL//////wGDNwOQAyAEIBBCHIZCgICAgP8BgyARQiSIhDcDiAMgBCAFKQDoASIRQhCIQv//////AYM3A6ADIAQgEUIUhkKAgMD//wGDIBBCLIiENwOYAyAEIAUpAPABIhBCGIhC//////8BgzcDsAMgBCAQQgyGQoDg////AYMgEUI0iIQ3A6gDIAQgBSkA+AEiEUIEhkLw/////wGDIBBCPIiENwO4AyAEIAUpAIACIhBCBIhC//////8BgzcDyAMgBCAQQiCGQoCAgIDwAYMgEUIgiIQ3A8ADIAQgBSkAiAIiEUIMiEL//////wGDNwPYAyAEIBFCGIZCgICA+P8BgyAQQiiIhDcD0AMgBCAFKQCQAiIQQhSIQv//////AYM3A+gDIAQgEEIQhkKAgPz//wGDIBFCMIiENwPgAyAEIAUpAJgCIhFCHIg3A/gDIAQgEUIIhkKA/v///wGDIBBCOIiENwPwAwwdCyAGQacCTQRADCULIAQgBSkAACIVQv//////A4M3AwAgBCAFKQAIIhBCCohC//////8DgzcDECAEIAUpABAiEUIUiEL//////wODNwMgIAQgBSkAICISQgOIQv//////A4M3AzggBCAFKQAoIhNCDYhC//////8DgzcDSCAEIAUpADAiFEIXiEL//////wODNwNYIAQgEEIbhkKAgIDA/wODIBVCJYiENwMIIAQgEUIRhkKAgPj//wODIBBCL4iENwMYIAQgBSkAGCIQQgeGQoD/////A4MgEUI5iIQ3AyggBCASQiKGQoCAgIDAA4MgEEIeiIQ3AzAgBCATQhiGQoCAgPj/A4MgEkIoiIQ3A0AgBCAUQg6GQoCA////A4MgE0IyiIQ3A1AgBCAFKQBAIhBCBohC//////8DgzcDcCAEIAUpAEgiEUIQiEL//////wODNwOAASAEIAUpAFAiEkIaiEL//////wODNwOQASAEIAUpAGAiE0IJiEL//////wODNwOoASAEIAUpAGgiFUITiEL//////wODNwO4ASAEIAUpADgiFkIEhkLw/////wODIBRCPIiENwNgIAQgEEIfhkKAgICA+AODIBZCIYiENwNoIAQgEUIVhkKAgID//wODIBBCK4iENwN4IAQgEkILhkKA8P///wODIBFCNYiENwOIASAEIAUpAFgiEEIBhkL+/////wODIBJCP4iENwOYASAEIBNCHIZCgICAgP8DgyAQQiSIhDcDoAEgBCAVQhKGQoCA8P//A4MgE0IuiIQ3A7ABIAQgBSkAcCIRQgiGQoD+////A4MgFUI4iIQ3A8ABIAQgBSkAeCIQQgKIQv//////A4M3A9ABIAQgEEIjhkKAgICAgAODIBFCHYiENwPIASAEIAUpAIABIhFCDIhC//////8DgzcD4AEgBCARQhmGQoCAgPD/A4MgEEIniIQ3A9gBIAQgBSkAiAEiEEIWiEL//////wODNwPwASAEIBBCD4ZCgID+//8DgyARQjGIhDcD6AEgBCAFKQCQASIRQgWGQuD/////A4MgEEI7iIQ3A/gBIAQgBSkAmAEiEEIFiEL//////wODNwOIAiAEIBBCIIZCgICAgPADgyARQiCIhDcDgAIgBCAFKQCgASIRQg+IQv//////A4M3A5gCIAQgEUIWhkKAgID+/wODIBBCKoiENwOQAiAEIAUpAKgBIhBCGYhC//////8DgzcDqAIgBCAQQgyGQoDg////A4MgEUI0iIQ3A6ACIAQgBSkAsAEiEUIChkL8/////wODIBBCPoiENwOwAiAEIAUpALgBIhBCCIhC//////8DgzcDwAIgBCAQQh2GQoCAgID+A4MgEUIjiIQ3A7gCIAQgBSkAwAEiEUISiEL//////wODNwPQAiAEIBFCE4ZCgIDg//8DgyAQQi2IhDcDyAIgBCAFKQDIASISQgmGQoD8////A4MgEUI3iIQ3A9gCIAQgBSkA0AEiEEIBiEL//////wODNwPoAiAEIBBCJIZCgICAgIACgyASQhyIhDcD4AIgBCAFKQDYASIRQguIQv//////A4M3A/gCIAQgEUIahkKAgIDg/wODIBBCJoiENwPwAiAEIAUpAOABIhBCFYhC//////8DgzcDiAMgBCAQQhCGQoCA/P//A4MgEUIwiIQ3A4ADIAQgBSkA6AEiEUIGhkLA/////wODIBBCOoiENwOQAyAEIAUpAPABIhBCBIhC//////8DgzcDoAMgBCAQQiGGQoCAgIDgA4MgEUIfiIQ3A5gDIAQgBSkA+AEiEUIOiEL//////wODNwOwAyAEIBFCF4ZCgICA/P8DgyAQQimIhDcDqAMgBCAFKQCAAiIQQhiIQv//////A4M3A8ADIAQgEEINhkKAwP///wODIBFCM4iENwO4AyAEIAUpAIgCIhFCA4ZC+P////8DgyAQQj2IhDcDyAMgBCAFKQCQAiIQQgeIQv//////A4M3A9gDIAQgEEIehkKAgICA/AODIBFCIoiENwPQAyAEIAUpAJgCIhFCEYhC//////8DgzcD6AMgBCARQhSGQoCAwP//A4MgEEIsiIQ3A+ADIAQgBSkAoAIiEEIbiDcD+AMgBCAQQgqGQoD4////A4MgEUI2iIQ3A/ADDBwLIAZBrwJNBEAMJAsgBCAFKQAAIhRC//////8HgzcDACAEIAUpAAgiEEIMiEL//////weDNwMQIAQgBSkAECIRQhiIQv//////B4M3AyAgBCAFKQAgIhJCCohC//////8HgzcDOCAEIAUpACgiE0IWiEL//////weDNwNIIAQgEEIahkKAgIDg/weDIBRCJoiENwMIIAQgEUIOhkKAgP///weDIBBCMoiENwMYIAQgBSkAGCIQQgKGQvz/////B4MgEUI+iIQ3AyggBCASQhyGQoCAgID/B4MgEEIkiIQ3AzAgBCATQhCGQoCA/P//B4MgEkIwiIQ3A0AgBCAFKQAwIhFCBIZC8P////8HgyATQjyIhDcDUCAEIAUpADgiEEIIiEL//////weDNwNgIAQgEEIehkKAgICA/AeDIBFCIoiENwNYIAQgBSkAQCIRQhSIQv//////B4M3A3AgBCAFKQBQIhJCBohC//////8HgzcDiAEgBCAFKQBYIhNCEohC//////8HgzcDmAEgBCAFKQBoIhRCBIhC//////8HgzcDsAEgBCARQhKGQoCA8P//B4MgEEIuiIQ3A2ggBCAFKQBIIhBCBoZCwP////8HgyARQjqIhDcDeCAEIBJCIIZCgICAgPAHgyAQQiCIhDcDgAEgBCATQhSGQoCAwP//B4MgEkIsiIQ3A5ABIAQgBSkAYCIQQgiGQoD+////B4MgE0I4iIQ3A6ABIAQgFEIihkKAgICAwAeDIBBCHoiENwOoASAEIAUpAHAiEEIQiEL//////weDNwPAASAEIBBCFoZCgICA/v8HgyAUQiqIhDcDuAEgBCAFKQB4IhFCCoZCgPj///8HgyAQQjaIhDcDyAEgBCAFKQCAASIQQgKIQv//////B4M3A9gBIAQgEEIkhkKAgICAgAaDIBFCHIiENwPQASAEIAUpAIgBIhFCDohC//////8HgzcD6AEgBCARQhiGQoCAgPj/B4MgEEIoiIQ3A+ABIAQgBSkAkAEiEEIaiDcD+AEgBCAQQgyGQoDg////B4MgEUI0iIQ3A/ABIAQgBSkAmAEiEUL//////weDNwOAAiAEIAUpAKABIhBCDIhC//////8HgzcDkAIgBCAQQhqGQoCAgOD/B4MgEUImiIQ3A4gCIAQgBSkAqAEiEUIYiEL//////weDNwOgAiAEIBFCDoZCgID///8HgyAQQjKIhDcDmAIgBCAFKQCwASISQgKGQvz/////B4MgEUI+iIQ3A6gCIAQgBSkAuAEiEEIKiEL//////weDNwO4AiAEIBBCHIZCgICAgP8HgyASQiSIhDcDsAIgBCAFKQDAASIRQhaIQv//////B4M3A8gCIAQgEUIQhkKAgPz//weDIBBCMIiENwPAAiAEIAUpAMgBIhJCBIZC8P////8HgyARQjyIhDcD0AIgBCAFKQDQASIQQgiIQv//////B4M3A+ACIAQgEEIehkKAgICA/AeDIBJCIoiENwPYAiAEIAUpANgBIhFCFIhC//////8HgzcD8AIgBCARQhKGQoCA8P//B4MgEEIuiIQ3A+gCIAQgBSkA4AEiEkIGhkLA/////weDIBFCOoiENwP4AiAEIAUpAOgBIhBCBohC//////8HgzcDiAMgBCAQQiCGQoCAgIDwB4MgEkIgiIQ3A4ADIAQgBSkA8AEiEUISiEL//////weDNwOYAyAEIBFCFIZCgIDA//8HgyAQQiyIhDcDkAMgBCAFKQD4ASISQgiGQoD+////B4MgEUI4iIQ3A6ADIAQgBSkAgAIiEEIEiEL//////weDNwOwAyAEIBBCIoZCgICAgMAHgyASQh6IhDcDqAMgBCAFKQCIAiIRQhCIQv//////B4M3A8ADIAQgEUIWhkKAgID+/weDIBBCKoiENwO4AyAEIAUpAJACIhJCCoZCgPj///8HgyARQjaIhDcDyAMgBCAFKQCYAiIQQgKIQv//////B4M3A9gDIAQgEEIkhkKAgICAgAaDIBJCHIiENwPQAyAEIAUpAKACIhFCDohC//////8HgzcD6AMgBCARQhiGQoCAgPj/B4MgEEIoiIQ3A+ADIAQgBSkAqAIiEEIaiDcD+AMgBCAQQgyGQoDg////B4MgEUI0iIQ3A/ADDBsLIAZBtwJNBEAMIwsgBCAFKQAAIhRC//////8PgzcDACAEIAUpAAgiEEIOiEL//////w+DNwMQIAQgBSkAGCIRQgOIQv//////D4M3AyggBCAFKQAgIhJCEYhC//////8PgzcDOCAEIAUpADAiE0IGiEL//////w+DNwNQIAQgEEIZhkKAgIDw/w+DIBRCJ4iENwMIIAQgBSkAECIUQguGQoDw////D4MgEEI1iIQ3AxggBCARQiSGQoCAgICADoMgFEIciIQ3AyAgBCASQhaGQoCAgP7/D4MgEUIqiIQ3AzAgBCAFKQAoIhBCCIZCgP7///8PgyASQjiIhDcDQCAEIBNCIYZCgICAgOAPgyAQQh+IhDcDSCAEIAUpADgiEEIUiEL//////w+DNwNgIAQgEEIThkKAgOD//w+DIBNCLYiENwNYIAQgBSkASCIRQgmIQv//////D4M3A3ggBCAFKQBQIhJCF4hC//////8PgzcDiAEgBCAFKQBgIhNCDIhC//////8PgzcDoAEgBCAFKQBAIhRCBYZC4P////8PgyAQQjuIhDcDaCAEIBFCHoZCgICAgPwPgyAUQiKIhDcDcCAEIBJCEIZCgID8//8PgyARQjCIhDcDgAEgBCAFKQBYIhBCAoZC/P////8PgyASQj6IhDcDkAEgBCATQhuGQoCAgMD/D4MgEEIliIQ3A5gBIAQgBSkAaCIRQg2GQoDA////D4MgE0IziIQ3A6gBIAQgBSkAcCIQQgGIQv//////D4M3A7gBIAQgEEImhkKAgICAgAiDIBFCGoiENwOwASAEIAUpAHgiEUIPiEL//////w+DNwPIASAEIBFCGIZCgICA+P8PgyAQQiiIhDcDwAEgBCAFKQCAASISQgqGQoD4////D4MgEUI2iIQ3A9ABIAQgBSkAiAEiEEIEiEL//////w+DNwPgASAEIBBCI4ZCgICAgIAPgyASQh2IhDcD2AEgBCAFKQCQASIRQhKIQv//////D4M3A/ABIAQgEUIVhkKAgID//w+DIBBCK4iENwPoASAEIAUpAJgBIhJCB4ZCgP////8PgyARQjmIhDcD+AEgBCAFKQCgASIQQgeIQv//////D4M3A4gCIAQgEEIghkKAgICA8A+DIBJCIIiENwOAAiAEIAUpAKgBIhFCFYhC//////8PgzcDmAIgBCARQhKGQoCA8P//D4MgEEIuiIQ3A5ACIAQgBSkAsAEiEkIEhkLw/////w+DIBFCPIiENwOgAiAEIAUpALgBIhBCCohC//////8PgzcDsAIgBCAQQh2GQoCAgID+D4MgEkIjiIQ3A6gCIAQgBSkAwAEiEUIYiEL//////w+DNwPAAiAEIBFCD4ZCgID+//8PgyAQQjGIhDcDuAIgBCAFKQDIASISQgGGQv7/////D4MgEUI/iIQ3A8gCIAQgBSkA0AEiEEINiEL//////w+DNwPYAiAEIBBCGoZCgICA4P8PgyASQiaIhDcD0AIgBCAFKQDYASIRQgyGQoDg////D4MgEEI0iIQ3A+ACIAQgBSkA4AEiEEICiEL//////w+DNwPwAiAEIBBCJYZCgICAgIAMgyARQhuIhDcD6AIgBCAFKQDoASIRQhCIQv//////D4M3A4ADIAQgEUIXhkKAgID8/w+DIBBCKYiENwP4AiAEIAUpAPABIhJCCYZCgPz///8PgyARQjeIhDcDiAMgBCAFKQD4ASIQQgWIQv//////D4M3A5gDIAQgEEIihkKAgICAwA+DIBJCHoiENwOQAyAEIAUpAIACIhFCE4hC//////8PgzcDqAMgBCARQhSGQoCAwP//D4MgEEIsiIQ3A6ADIAQgBSkAiAIiEkIGhkLA/////w+DIBFCOoiENwOwAyAEIAUpAJACIhBCCIhC//////8PgzcDwAMgBCAQQh+GQoCAgID4D4MgEkIhiIQ3A7gDIAQgBSkAmAIiEUIWiEL//////w+DNwPQAyAEIBFCEYZCgID4//8PgyAQQi+IhDcDyAMgBCAFKQCgAiISQgOGQvj/////D4MgEUI9iIQ3A9gDIAQgBSkAqAIiEEILiEL//////w+DNwPoAyAEIBBCHIZCgICAgP8PgyASQiSIhDcD4AMgBCAFKQCwAiIRQhmINwP4AyAEIBFCDoZCgID///8PgyAQQjKIhDcD8AMMGgsgBkG/Ak0EQAwiCyAEIAUpAAAiE0L//////x+DNwMAIAQgBSkAICIUQhiINwM4IAQgBSkAKCIVQv//////H4M3A0AgBCAFKQAIIhBCEIhC//////8fgzcDECAEIAUpABgiEUIIiEL//////x+DNwMoIAQgBSkAMCISQhCIQv//////H4M3A1AgBCAQQhiGQoCAgPj/H4MgE0IoiIQ3AwggBCAFKQAQIhNCCIZCgP7///8fgyAQQjiIhDcDGCAEIBFCIIZCgICAgPAfgyATQiCIhDcDICAEIBRCEIZCgID8//8fgyARQjCIhDcDMCAEIBJCGIZCgICA+P8fgyAVQiiIhDcDSCAEIAUpADgiE0IIhkKA/v///x+DIBJCOIiENwNYIAQgBSkASCIUQhiINwN4IAQgBSkAUCIVQv//////H4M3A4ABIAQgBSkAcCIWQhiINwO4ASAEIAUpAEAiEEIIiEL//////x+DNwNoIAQgBSkAWCIRQhCIQv//////H4M3A5ABIAQgBSkAaCISQgiIQv//////H4M3A6gBIAQgEEIghkKAgICA8B+DIBNCIIiENwNgIAQgFEIQhkKAgPz//x+DIBBCMIiENwNwIAQgEUIYhkKAgID4/x+DIBVCKIiENwOIASAEIAUpAGAiEEIIhkKA/v///x+DIBFCOIiENwOYASAEIBJCIIZCgICAgPAfgyAQQiCIhDcDoAEgBCAWQhCGQoCA/P//H4MgEkIwiIQ3A7ABIAQgBSkAeCIRQv//////H4M3A8ABIAQgBSkAgAEiEEIQiEL//////x+DNwPQASAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAEgBCAFKQCIASIRQgiGQoD+////H4MgEEI4iIQ3A9gBIAQgBSkAkAEiEEIIiEL//////x+DNwPoASAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AEgBCAFKQCYASIRQhiINwP4ASAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AEgBCAFKQCgASIRQv//////H4M3A4ACIAQgBSkAqAEiEEIQiEL//////x+DNwOQAiAEIBBCGIZCgICA+P8fgyARQiiIhDcDiAIgBCAFKQCwASIRQgiGQoD+////H4MgEEI4iIQ3A5gCIAQgBSkAuAEiEEIIiEL//////x+DNwOoAiAEIBBCIIZCgICAgPAfgyARQiCIhDcDoAIgBCAFKQDAASIRQhiINwO4AiAEIBFCEIZCgID8//8fgyAQQjCIhDcDsAIgBCAFKQDIASIRQv//////H4M3A8ACIAQgBSkA0AEiEEIQiEL//////x+DNwPQAiAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAIgBCAFKQDYASIRQgiGQoD+////H4MgEEI4iIQ3A9gCIAQgBSkA4AEiEEIIiEL//////x+DNwPoAiAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AIgBCAFKQDoASIRQhiINwP4AiAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AIgBCAFKQDwASIRQv//////H4M3A4ADIAQgBSkA+AEiEEIQiEL//////x+DNwOQAyAEIBBCGIZCgICA+P8fgyARQiiIhDcDiAMgBCAFKQCAAiIRQgiGQoD+////H4MgEEI4iIQ3A5gDIAQgBSkAiAIiEEIIiEL//////x+DNwOoAyAEIBBCIIZCgICAgPAfgyARQiCIhDcDoAMgBCAFKQCQAiIRQhiINwO4AyAEIBFCEIZCgID8//8fgyAQQjCIhDcDsAMgBCAFKQCYAiIRQv//////H4M3A8ADIAQgBSkAoAIiEEIQiEL//////x+DNwPQAyAEIBBCGIZCgICA+P8fgyARQiiIhDcDyAMgBCAFKQCoAiIRQgiGQoD+////H4MgEEI4iIQ3A9gDIAQgBSkAsAIiEEIIiEL//////x+DNwPoAyAEIBBCIIZCgICAgPAfgyARQiCIhDcD4AMgBCAFKQC4AiIRQhiINwP4AyAEIBFCEIZCgID8//8fgyAQQjCIhDcD8AMMGQsgBkHHAk0EQAwhCyAEIAUpAAAiFEL//////z+DNwMAIAQgBSkACCIQQhKIQv//////P4M3AxAgBCAFKQAYIhFCDYhC//////8/gzcDKCAEIAUpACgiEkIIiEL//////z+DNwNAIAQgBSkAOCITQgOIQv//////P4M3A1ggBCAQQheGQoCAgPz/P4MgFEIpiIQ3AwggBCAFKQAQIhRCBYZC4P////8/gyAQQjuIhDcDGCAEIBFCHIZCgICAgP8/gyAUQiSIhDcDICAEIAUpACAiEEIKhkKA+P///z+DIBFCNoiENwMwIAQgEkIhhkKAgICA4D+DIBBCH4iENwM4IAQgBSkAMCIQQg+GQoCA/v//P4MgEkIxiIQ3A0ggBCATQiaGQoCAgICAOIMgEEIaiIQ3A1AgBCAFKQBAIhBCFYhC//////8/gzcDaCAEIAUpAFAiEUIQiEL//////z+DNwOAASAEIAUpAGAiEkILiEL//////z+DNwOYASAEIAUpAHAiFEIGiEL//////z+DNwOwASAEIBBCFIZCgIDA//8/gyATQiyIhDcDYCAEIAUpAEgiE0IChkL8/////z+DIBBCPoiENwNwIAQgEUIZhkKAgIDw/z+DIBNCJ4iENwN4IAQgBSkAWCIQQgeGQoD/////P4MgEUI5iIQ3A4gBIAQgEkIehkKAgICA/D+DIBBCIoiENwOQASAEIAUpAGgiEEIMhkKA4P///z+DIBJCNIiENwOgASAEIBRCI4ZCgICAgIA/gyAQQh2IhDcDqAEgBCAFKQB4IhFCEYZCgID4//8/gyAUQi+IhDcDuAEgBCAFKQCAASIQQgGIQv//////P4M3A8gBIAQgEEIohkKAgICAgCCDIBFCGIiENwPAASAEIAUpAIgBIhFCE4hC//////8/gzcD2AEgBCARQhaGQoCAgP7/P4MgEEIqiIQ3A9ABIAQgBSkAkAEiEkIEhkLw/////z+DIBFCPIiENwPgASAEIAUpAJgBIhBCDohC//////8/gzcD8AEgBCAQQhuGQoCAgMD/P4MgEkIliIQ3A+gBIAQgBSkAoAEiEUIJhkKA/P///z+DIBBCN4iENwP4ASAEIAUpAKgBIhBCCYhC//////8/gzcDiAIgBCAQQiCGQoCAgIDwP4MgEUIgiIQ3A4ACIAQgBSkAsAEiEUIOhkKAgP///z+DIBBCMoiENwOQAiAEIAUpALgBIhBCBIhC//////8/gzcDoAIgBCAQQiWGQoCAgICAPIMgEUIbiIQ3A5gCIAQgBSkAwAEiEUIWiEL//////z+DNwOwAiAEIBFCE4ZCgIDg//8/gyAQQi2IhDcDqAIgBCAFKQDIASISQgGGQv7/////P4MgEUI/iIQ3A7gCIAQgBSkA0AEiEEIRiEL//////z+DNwPIAiAEIBBCGIZCgICA+P8/gyASQiiIhDcDwAIgBCAFKQDYASIRQgaGQsD/////P4MgEEI6iIQ3A9ACIAQgBSkA4AEiEEIMiEL//////z+DNwPgAiAEIBBCHYZCgICAgP4/gyARQiOIhDcD2AIgBCAFKQDoASIRQguGQoDw////P4MgEEI1iIQ3A+gCIAQgBSkA8AEiEEIHiEL//////z+DNwP4AiAEIBBCIoZCgICAgMA/gyARQh6IhDcD8AIgBCAFKQD4ASIRQhCGQoCA/P//P4MgEEIwiIQ3A4ADIAQgBSkAgAIiEEICiEL//////z+DNwOQAyAEIBBCJ4ZCgICAgIAwgyARQhmIhDcDiAMgBCAFKQCIAiIRQhSIQv//////P4M3A6ADIAQgEUIVhkKAgID//z+DIBBCK4iENwOYAyAEIAUpAJACIhJCA4ZC+P////8/gyARQj2IhDcDqAMgBCAFKQCYAiIQQg+IQv//////P4M3A7gDIAQgEEIahkKAgIDg/z+DIBJCJoiENwOwAyAEIAUpAKACIhFCCIZCgP7///8/gyAQQjiIhDcDwAMgBCAFKQCoAiIQQgqIQv//////P4M3A9ADIAQgEEIfhkKAgICA+D+DIBFCIYiENwPIAyAEIAUpALACIhFCDYZCgMD///8/gyAQQjOIhDcD2AMgBCAFKQC4AiIQQgWIQv//////P4M3A+gDIAQgEEIkhkKAgICAgD6DIBFCHIiENwPgAyAEIAUpAMACIhFCF4g3A/gDIAQgEUIShkKAgPD//z+DIBBCLoiENwPwAwwYCyAGQc8CTQRADCALIAQgBSkAACIUQv///////wCDNwMAIAQgBSkACCIQQhSIQv///////wCDNwMQIAQgBSkAGCIRQhKIQv///////wCDNwMoIAQgBSkAKCISQhCIQv///////wCDNwNAIAQgBSkAOCITQg6IQv///////wCDNwNYIAQgEEIWhkKAgID+//8AgyAUQiqIhDcDCCAEIAUpABAiFEIChkL8//////8AgyAQQj6IhDcDGCAEIBFCGIZCgICA+P//AIMgFEIoiIQ3AyAgBCAFKQAgIhBCBIZC8P//////AIMgEUI8iIQ3AzAgBCASQhqGQoCAgOD//wCDIBBCJoiENwM4IAQgBSkAMCIQQgaGQsD//////wCDIBJCOoiENwNIIAQgE0IchkKAgICA//8AgyAQQiSIhDcDUCAEIAUpAEgiEEIMiEL///////8AgzcDcCAEIAUpAFgiEUIKiEL///////8AgzcDiAEgBCAFKQBoIhJCCIhC////////AIM3A6ABIAQgBSkAeCIUQgaIQv///////wCDNwO4ASAEIAUpAEAiFUIIhkKA/v////8AgyATQjiIhDcDYCAEIBBCHoZCgICAgPz/AIMgFUIiiIQ3A2ggBCAFKQBQIhNCCoZCgPj/////AIMgEEI2iIQ3A3ggBCARQiCGQoCAgIDw/wCDIBNCIIiENwOAASAEIAUpAGAiEEIMhkKA4P////8AgyARQjSIhDcDkAEgBCASQiKGQoCAgIDA/wCDIBBCHoiENwOYASAEIAUpAHAiEEIOhkKAgP////8AgyASQjKIhDcDqAEgBCAUQiSGQoCAgICA/gCDIBBCHIiENwOwASAEIAUpAIABIhFCEIZCgID8////AIMgFEIwiIQ3A8ABIAQgBSkAiAEiEEIEiEL///////8AgzcD0AEgBCAQQiaGQoCAgICA+ACDIBFCGoiENwPIASAEIAUpAJABIhFCEoZCgIDw////AIMgEEIuiIQ3A9gBIAQgBSkAmAEiEEICiEL///////8AgzcD6AEgBCAQQiiGQoCAgICA4ACDIBFCGIiENwPgASAEIAUpAKABIhFCFog3A/gBIAQgEUIUhkKAgMD///8AgyAQQiyIhDcD8AEgBCAFKQCoASIRQv///////wCDNwOAAiAEIAUpALABIhBCFIhC////////AIM3A5ACIAQgEEIWhkKAgID+//8AgyARQiqIhDcDiAIgBCAFKQC4ASIRQgKGQvz//////wCDIBBCPoiENwOYAiAEIAUpAMABIhBCEohC////////AIM3A6gCIAQgEEIYhkKAgID4//8AgyARQiiIhDcDoAIgBCAFKQDIASIRQgSGQvD//////wCDIBBCPIiENwOwAiAEIAUpANABIhBCEIhC////////AIM3A8ACIAQgEEIahkKAgIDg//8AgyARQiaIhDcDuAIgBCAFKQDYASIRQgaGQsD//////wCDIBBCOoiENwPIAiAEIAUpAOABIhBCDohC////////AIM3A9gCIAQgEEIchkKAgICA//8AgyARQiSIhDcD0AIgBCAFKQDoASIRQgiGQoD+/////wCDIBBCOIiENwPgAiAEIAUpAPABIhBCDIhC////////AIM3A/ACIAQgEEIehkKAgICA/P8AgyARQiKIhDcD6AIgBCAFKQD4ASIRQgqGQoD4/////wCDIBBCNoiENwP4AiAEIAUpAIACIhBCCohC////////AIM3A4gDIAQgEEIghkKAgICA8P8AgyARQiCIhDcDgAMgBCAFKQCIAiIRQgyGQoDg/////wCDIBBCNIiENwOQAyAEIAUpAJACIhBCCIhC////////AIM3A6ADIAQgEEIihkKAgICAwP8AgyARQh6IhDcDmAMgBCAFKQCYAiIRQg6GQoCA/////wCDIBBCMoiENwOoAyAEIAUpAKACIhBCBohC////////AIM3A7gDIAQgEEIkhkKAgICAgP4AgyARQhyIhDcDsAMgBCAFKQCoAiIRQhCGQoCA/P///wCDIBBCMIiENwPAAyAEIAUpALACIhBCBIhC////////AIM3A9ADIAQgEEImhkKAgICAgPgAgyARQhqIhDcDyAMgBCAFKQC4AiIRQhKGQoCA8P///wCDIBBCLoiENwPYAyAEIAUpAMACIhBCAohC////////AIM3A+gDIAQgEEIohkKAgICAgOAAgyARQhiIhDcD4AMgBCAFKQDIAiIRQhaINwP4AyAEIBFCFIZCgIDA////AIMgEEIsiIQ3A/ADDBcLIAZB1wJNBEAMHwsgBCAFKQAAIhNC////////AYM3AwAgBCAFKQAQIhBCAYhC////////AYM3AxggBCAFKQAgIhFCAohC////////AYM3AzAgBCAFKQAwIhJCA4hC////////AYM3A0ggBCAFKQAIIhRCFYZCgICA////AYMgE0IriIQ3AwggBCAQQiqGQoCAgICAgAGDIBRCFoiENwMQIAQgBSkAGCITQhSGQoCAwP///wGDIBBCLIiENwMgIAQgEUIphkKAgICAgMABgyATQheIhDcDKCAEIAUpACgiEEIThkKAgOD///8BgyARQi2IhDcDOCAEIBJCKIZCgICAgIDgAYMgEEIYiIQ3A0AgBCAFKQA4IhRCEoZCgIDw////AYMgEkIuiIQ3A1AgBCAFKQBAIhBCBIhC////////AYM3A2AgBCAFKQBQIhFCBYhC////////AYM3A3ggBCAFKQBgIhJCBohC////////AYM3A5ABIAQgBSkAcCITQgeIQv///////wGDNwOoASAEIBBCJ4ZCgICAgIDwAYMgFEIZiIQ3A1ggBCAFKQBIIhRCEYZCgID4////AYMgEEIviIQ3A2ggBCARQiaGQoCAgICA+AGDIBRCGoiENwNwIAQgBSkAWCIQQhCGQoCA/P///wGDIBFCMIiENwOAASAEIBJCJYZCgICAgID8AYMgEEIbiIQ3A4gBIAQgBSkAaCIQQg+GQoCA/v///wGDIBJCMYiENwOYASAEIBNCJIZCgICAgID+AYMgEEIciIQ3A6ABIAQgBSkAeCIRQg6GQoCA/////wGDIBNCMoiENwOwASAEIAUpAIABIhBCCIhC////////AYM3A8ABIAQgEEIjhkKAgICAgP8BgyARQh2IhDcDuAEgBCAFKQCIASIRQg2GQoDA/////wGDIBBCM4iENwPIASAEIAUpAJABIhBCCYhC////////AYM3A9gBIAQgEEIihkKAgICAwP8BgyARQh6IhDcD0AEgBCAFKQCYASIRQgyGQoDg/////wGDIBBCNIiENwPgASAEIAUpAKABIhBCCohC////////AYM3A/ABIAQgEEIhhkKAgICA4P8BgyARQh+IhDcD6AEgBCAFKQCoASIRQguGQoDw/////wGDIBBCNYiENwP4ASAEIAUpALABIhBCC4hC////////AYM3A4gCIAQgEEIghkKAgICA8P8BgyARQiCIhDcDgAIgBCAFKQC4ASIRQgqGQoD4/////wGDIBBCNoiENwOQAiAEIAUpAMABIhBCDIhC////////AYM3A6ACIAQgEEIfhkKAgICA+P8BgyARQiGIhDcDmAIgBCAFKQDIASIRQgmGQoD8/////wGDIBBCN4iENwOoAiAEIAUpANABIhBCDYhC////////AYM3A7gCIAQgEEIehkKAgICA/P8BgyARQiKIhDcDsAIgBCAFKQDYASIRQgiGQoD+/////wGDIBBCOIiENwPAAiAEIAUpAOABIhBCDohC////////AYM3A9ACIAQgEEIdhkKAgICA/v8BgyARQiOIhDcDyAIgBCAFKQDoASIRQgeGQoD//////wGDIBBCOYiENwPYAiAEIAUpAPABIhBCD4hC////////AYM3A+gCIAQgEEIchkKAgICA//8BgyARQiSIhDcD4AIgBCAFKQD4ASIRQgaGQsD//////wGDIBBCOoiENwPwAiAEIAUpAIACIhBCEIhC////////AYM3A4ADIAQgEEIbhkKAgIDA//8BgyARQiWIhDcD+AIgBCAFKQCIAiIRQgWGQuD//////wGDIBBCO4iENwOIAyAEIAUpAJACIhBCEYhC////////AYM3A5gDIAQgEEIahkKAgIDg//8BgyARQiaIhDcDkAMgBCAFKQCYAiIRQgSGQvD//////wGDIBBCPIiENwOgAyAEIAUpAKACIhBCEohC////////AYM3A7ADIAQgEEIZhkKAgIDw//8BgyARQieIhDcDqAMgBCAFKQCoAiIRQgOGQvj//////wGDIBBCPYiENwO4AyAEIAUpALACIhBCE4hC////////AYM3A8gDIAQgEEIYhkKAgID4//8BgyARQiiIhDcDwAMgBCAFKQC4AiIRQgKGQvz//////wGDIBBCPoiENwPQAyAEIAUpAMACIhBCFIhC////////AYM3A+ADIAQgEEIXhkKAgID8//8BgyARQimIhDcD2AMgBCAFKQDIAiIRQgGGQv7//////wGDIBBCP4iENwPoAyAEIAUpANACIhBCFYg3A/gDIAQgEEIWhkKAgID+//8BgyARQiqIhDcD8AMMFgsgBkHfAk0EQAweCyAEIAUpAAAiE0L///////8DgzcDACAEIAUpABAiEEIEiEL///////8DgzcDGCAEIAUpACAiEUIIiEL///////8DgzcDMCAEIAUpADAiEkIMiEL///////8DgzcDSCAEIAUpAAgiFEIUhkKAgMD///8DgyATQiyIhDcDCCAEIBBCKIZCgICAgIDgA4MgFEIYiIQ3AxAgBCAFKQAYIhNCEIZCgID8////A4MgEEIwiIQ3AyAgBCARQiSGQoCAgICA/gODIBNCHIiENwMoIAQgBSkAKCIQQgyGQoDg/////wODIBFCNIiENwM4IAQgEkIghkKAgICA8P8DgyAQQiCIhDcDQCAEIAUpADgiE0IIhkKA/v////8DgyASQjiIhDcDUCAEIAUpAFAiEkIUiDcDeCAEIAUpAFgiFEL///////8DgzcDgAEgBCAFKQBAIhBCEIhC////////A4M3A2AgBCAFKQBoIhFCBIhC////////A4M3A5gBIAQgEEIchkKAgICA//8DgyATQiSIhDcDWCAEIAUpAEgiE0IEhkLw//////8DgyAQQjyIhDcDaCAEIBJCGIZCgICA+P//A4MgE0IoiIQ3A3AgBCAFKQBgIhBCFIZCgIDA////A4MgFEIsiIQ3A4gBIAQgEUIohkKAgICAgOADgyAQQhiIhDcDkAEgBCAFKQBwIhJCEIZCgID8////A4MgEUIwiIQ3A6ABIAQgBSkAeCIQQgiIQv///////wODNwOwASAEIBBCJIZCgICAgID+A4MgEkIciIQ3A6gBIAQgBSkAgAEiEUIMhkKA4P////8DgyAQQjSIhDcDuAEgBCAFKQCIASIQQgyIQv///////wODNwPIASAEIBBCIIZCgICAgPD/A4MgEUIgiIQ3A8ABIAQgBSkAkAEiEUIIhkKA/v////8DgyAQQjiIhDcD0AEgBCAFKQCYASIQQhCIQv///////wODNwPgASAEIBBCHIZCgICAgP//A4MgEUIkiIQ3A9gBIAQgBSkAoAEiEUIEhkLw//////8DgyAQQjyIhDcD6AEgBCAFKQCoASIQQhSINwP4ASAEIBBCGIZCgICA+P//A4MgEUIoiIQ3A/ABIAQgBSkAsAEiEEL///////8DgzcDgAIgBCAFKQC4ASIRQhSGQoCAwP///wODIBBCLIiENwOIAiAEIAUpAMABIhBCBIhC////////A4M3A5gCIAQgEEIohkKAgICAgOADgyARQhiIhDcDkAIgBCAFKQDIASIRQhCGQoCA/P///wODIBBCMIiENwOgAiAEIAUpANABIhBCCIhC////////A4M3A7ACIAQgEEIkhkKAgICAgP4DgyARQhyIhDcDqAIgBCAFKQDYASIRQgyGQoDg/////wODIBBCNIiENwO4AiAEIAUpAOABIhBCDIhC////////A4M3A8gCIAQgEEIghkKAgICA8P8DgyARQiCIhDcDwAIgBCAFKQDoASIRQgiGQoD+/////wODIBBCOIiENwPQAiAEIAUpAPABIhBCEIhC////////A4M3A+ACIAQgEEIchkKAgICA//8DgyARQiSIhDcD2AIgBCAFKQD4ASIRQgSGQvD//////wODIBBCPIiENwPoAiAEIAUpAIACIhBCFIg3A/gCIAQgEEIYhkKAgID4//8DgyARQiiIhDcD8AIgBCAFKQCIAiIQQv///////wODNwOAAyAEIAUpAJACIhFCFIZCgIDA////A4MgEEIsiIQ3A4gDIAQgBSkAmAIiEEIEiEL///////8DgzcDmAMgBCAQQiiGQoCAgICA4AODIBFCGIiENwOQAyAEIAUpAKACIhFCEIZCgID8////A4MgEEIwiIQ3A6ADIAQgBSkAqAIiEEIIiEL///////8DgzcDsAMgBCAQQiSGQoCAgICA/gODIBFCHIiENwOoAyAEIAUpALACIhFCDIZCgOD/////A4MgEEI0iIQ3A7gDIAQgBSkAuAIiEEIMiEL///////8DgzcDyAMgBCAQQiCGQoCAgIDw/wODIBFCIIiENwPAAyAEIAUpAMACIhFCCIZCgP7/////A4MgEEI4iIQ3A9ADIAQgBSkAyAIiEEIQiEL///////8DgzcD4AMgBCAQQhyGQoCAgID//wODIBFCJIiENwPYAyAEIAUpANACIhFCBIZC8P//////A4MgEEI8iIQ3A+gDIAQgBSkA2AIiEEIUiDcD+AMgBCAQQhiGQoCAgPj//wODIBFCKIiENwPwAwwVCyAGQecCTQRADB0LIAQgBSkAACITQv///////weDNwMAIAQgBSkAECIQQgeIQv///////weDNwMYIAQgBSkAICIRQg6IQv///////weDNwMwIAQgBSkAOCISQgKIQv///////weDNwNQIAQgBSkACCIUQhOGQoCA4P///weDIBNCLYiENwMIIAQgEEImhkKAgICAgPgHgyAUQhqIhDcDECAEIAUpABgiE0IMhkKA4P////8HgyAQQjSIhDcDICAEIBFCH4ZCgICAgPj/B4MgE0IhiIQ3AyggBCAFKQAoIhBCBYZC4P//////B4MgEUI7iIQ3AzggBCAFKQAwIhFCGIZCgICA+P//B4MgEEIoiIQ3A0AgBCASQiuGQoCAgICAgAaDIBFCFYiENwNIIAQgBSkASCIQQgmIQv///////weDNwNoIAQgBSkAWCIRQhCIQv///////weDNwOAASAEIAUpAHAiE0IEiEL///////8HgzcDoAEgBCAFKQBAIhRCEYZCgID4////B4MgEkIviIQ3A1ggBCAQQiSGQoCAgICA/geDIBRCHIiENwNgIAQgBSkAUCISQgqGQoD4/////weDIBBCNoiENwNwIAQgEUIdhkKAgICA/v8HgyASQiOIhDcDeCAEIAUpAGAiEEIDhkL4//////8HgyARQj2IhDcDiAEgBCAFKQBoIhFCFoZCgICA/v//B4MgEEIqiIQ3A5ABIAQgE0IphkKAgICAgMAHgyARQheIhDcDmAEgBCAFKQB4IhFCD4ZCgID+////B4MgE0IxiIQ3A6gBIAQgBSkAgAEiEEILiEL///////8HgzcDuAEgBCAQQiKGQoCAgIDA/weDIBFCHoiENwOwASAEIAUpAIgBIhFCCIZCgP7/////B4MgEEI4iIQ3A8ABIAQgBSkAkAEiEEISiEL///////8HgzcD0AEgBCAQQhuGQoCAgMD//weDIBFCJYiENwPIASAEIAUpAJgBIhFCAYZC/v//////B4MgEEI/iIQ3A9gBIAQgBSkAoAEiEkIUhkKAgMD///8HgyARQiyIhDcD4AEgBCAFKQCoASIQQgaIQv///////weDNwPwASAEIBBCJ4ZCgICAgIDwB4MgEkIZiIQ3A+gBIAQgBSkAsAEiEUINhkKAwP////8HgyAQQjOIhDcD+AEgBCAFKQC4ASIQQg2IQv///////weDNwOIAiAEIBBCIIZCgICAgPD/B4MgEUIgiIQ3A4ACIAQgBSkAwAEiEUIGhkLA//////8HgyAQQjqIhDcDkAIgBCAFKQDIASISQhmGQoCAgPD//weDIBFCJ4iENwOYAiAEIAUpANABIhBCAYhC////////B4M3A6gCIAQgEEIshkKAgICAgIAEgyASQhSIhDcDoAIgBCAFKQDYASIRQhKGQoCA8P///weDIBBCLoiENwOwAiAEIAUpAOABIhBCCIhC////////B4M3A8ACIAQgEEIlhkKAgICAgPwHgyARQhuIhDcDuAIgBCAFKQDoASIRQguGQoDw/////weDIBBCNYiENwPIAiAEIAUpAPABIhBCD4hC////////B4M3A9gCIAQgEEIehkKAgICA/P8HgyARQiKIhDcD0AIgBCAFKQD4ASIRQgSGQvD//////weDIBBCPIiENwPgAiAEIAUpAIACIhJCF4ZCgICA/P//B4MgEUIpiIQ3A+gCIAQgBSkAiAIiEEIDiEL///////8HgzcD+AIgBCAQQiqGQoCAgICAgAeDIBJCFoiENwPwAiAEIAUpAJACIhFCEIZCgID8////B4MgEEIwiIQ3A4ADIAQgBSkAmAIiEEIKiEL///////8HgzcDkAMgBCAQQiOGQoCAgICA/weDIBFCHYiENwOIAyAEIAUpAKACIhFCCYZCgPz/////B4MgEEI3iIQ3A5gDIAQgBSkAqAIiEEIRiEL///////8HgzcDqAMgBCAQQhyGQoCAgID//weDIBFCJIiENwOgAyAEIAUpALACIhFCAoZC/P//////B4MgEEI+iIQ3A7ADIAQgBSkAuAIiEkIVhkKAgID///8HgyARQiuIhDcDuAMgBCAFKQDAAiIQQgWIQv///////weDNwPIAyAEIBBCKIZCgICAgIDgB4MgEkIYiIQ3A8ADIAQgBSkAyAIiEUIOhkKAgP////8HgyAQQjKIhDcD0AMgBCAFKQDQAiIQQgyIQv///////weDNwPgAyAEIBBCIYZCgICAgOD/B4MgEUIfiIQ3A9gDIAQgBSkA2AIiEUIHhkKA//////8HgyAQQjmIhDcD6AMgBCAFKQDgAiIQQhOINwP4AyAEIBBCGoZCgICA4P//B4MgEUImiIQ3A/ADDBQLIAZB7wJNBEAMHAsgBCAFKQAAIhNC////////D4M3AwAgBCAFKQAQIhBCCohC////////D4M3AxggBCAFKQAoIhFCAohC////////D4M3AzggBCAFKQA4IhJCDIhC////////D4M3A1AgBCAFKQAIIhRCEoZCgIDw////D4MgE0IuiIQ3AwggBCAQQiSGQoCAgICA/g+DIBRCHIiENwMQIAQgBSkAGCITQgiGQoD+/////w+DIBBCOIiENwMgIAQgBSkAICIQQhqGQoCAgOD//w+DIBNCJoiENwMoIAQgEUIshkKAgICAgIAMgyAQQhSIhDcDMCAEIAUpADAiEEIQhkKAgPz///8PgyARQjCIhDcDQCAEIBJCIoZCgICAgMD/D4MgEEIeiIQ3A0ggBCAFKQBQIhBCBIhC////////D4M3A3AgBCAFKQBgIhFCDohC////////D4M3A4gBIAQgBSkAeCITQgaIQv///////w+DNwOoASAEIAUpAEAiFEIGhkLA//////8PgyASQjqIhDcDWCAEIAUpAEgiEkIYhkKAgID4//8PgyAUQiiIhDcDYCAEIBBCKoZCgICAgICAD4MgEkIWiIQ3A2ggBCAFKQBYIhJCDoZCgID/////D4MgEEIyiIQ3A3ggBCARQiCGQoCAgIDw/w+DIBJCIIiENwOAASAEIAUpAGgiEEIEhkLw//////8PgyARQjyIhDcDkAEgBCAFKQBwIhFCFoZCgICA/v//D4MgEEIqiIQ3A5gBIAQgE0IohkKAgICAgOAPgyARQhiIhDcDoAEgBCAFKQCAASIRQgyGQoDg/////w+DIBNCNIiENwOwASAEIAUpAIgBIhBCEIhC////////D4M3A8ABIAQgEEIehkKAgICA/P8PgyARQiKIhDcDuAEgBCAFKQCQASIRQgKGQvz//////w+DIBBCPoiENwPIASAEIAUpAJgBIhJCFIZCgIDA////D4MgEUIsiIQ3A9ABIAQgBSkAoAEiEEIIiEL///////8PgzcD4AEgBCAQQiaGQoCAgICA+A+DIBJCGoiENwPYASAEIAUpAKgBIhFCCoZCgPj/////D4MgEEI2iIQ3A+gBIAQgBSkAsAEiEEISiDcD+AEgBCAQQhyGQoCAgID//w+DIBFCJIiENwPwASAEIAUpALgBIhBC////////D4M3A4ACIAQgBSkAwAEiEUIShkKAgPD///8PgyAQQi6IhDcDiAIgBCAFKQDIASIQQgqIQv///////w+DNwOYAiAEIBBCJIZCgICAgID+D4MgEUIciIQ3A5ACIAQgBSkA0AEiEUIIhkKA/v////8PgyAQQjiIhDcDoAIgBCAFKQDYASISQhqGQoCAgOD//w+DIBFCJoiENwOoAiAEIAUpAOABIhBCAohC////////D4M3A7gCIAQgEEIshkKAgICAgIAMgyASQhSIhDcDsAIgBCAFKQDoASIRQhCGQoCA/P///w+DIBBCMIiENwPAAiAEIAUpAPABIhBCDIhC////////D4M3A9ACIAQgEEIihkKAgICAwP8PgyARQh6IhDcDyAIgBCAFKQD4ASIRQgaGQsD//////w+DIBBCOoiENwPYAiAEIAUpAIACIhJCGIZCgICA+P//D4MgEUIoiIQ3A+ACIAQgBSkAiAIiEEIEiEL///////8PgzcD8AIgBCAQQiqGQoCAgICAgA+DIBJCFoiENwPoAiAEIAUpAJACIhFCDoZCgID/////D4MgEEIyiIQ3A/gCIAQgBSkAmAIiEEIOiEL///////8PgzcDiAMgBCAQQiCGQoCAgIDw/w+DIBFCIIiENwOAAyAEIAUpAKACIhFCBIZC8P//////D4MgEEI8iIQ3A5ADIAQgBSkAqAIiEkIWhkKAgID+//8PgyARQiqIhDcDmAMgBCAFKQCwAiIQQgaIQv///////w+DNwOoAyAEIBBCKIZCgICAgIDgD4MgEkIYiIQ3A6ADIAQgBSkAuAIiEUIMhkKA4P////8PgyAQQjSIhDcDsAMgBCAFKQDAAiIQQhCIQv///////w+DNwPAAyAEIBBCHoZCgICAgPz/D4MgEUIiiIQ3A7gDIAQgBSkAyAIiEUIChkL8//////8PgyAQQj6IhDcDyAMgBCAFKQDQAiISQhSGQoCAwP///w+DIBFCLIiENwPQAyAEIAUpANgCIhBCCIhC////////D4M3A+ADIAQgEEImhkKAgICAgPgPgyASQhqIhDcD2AMgBCAFKQDgAiIRQgqGQoD4/////w+DIBBCNoiENwPoAyAEIAUpAOgCIhBCEog3A/gDIAQgEEIchkKAgICA//8PgyARQiSIhDcD8AMMEwsgBkH3Ak0EQAwbCyAEIAUpAAAiEkL///////8fgzcDACAEIAUpABAiEEINiEL///////8fgzcDGCAEIAUpACgiEUIJiEL///////8fgzcDOCAEIAUpAAgiE0IRhkKAgPj///8fgyASQi+IhDcDCCAEIBBCIoZCgICAgMD/H4MgE0IeiIQ3AxAgBCAFKQAYIhJCBIZC8P//////H4MgEEI8iIQ3AyAgBCAFKQAgIhBCFYZCgICA////H4MgEkIriIQ3AyggBCARQiaGQoCAgICA+B+DIBBCGoiENwMwIAQgBSkAMCIQQgiGQoD+/////x+DIBFCOIiENwNAIAQgBSkAOCIRQhmGQoCAgPD//x+DIBBCJ4iENwNIIAQgBSkAQCIQQgWIQv///////x+DNwNYIAQgEEIqhkKAgICAgIAfgyARQhaIhDcDUCAEIAUpAFgiEUIBiEL///////8fgzcDeCAEIAUpAGgiEkIOiEL///////8fgzcDkAEgBCAFKQBIIhNCDIZCgOD/////H4MgEEI0iIQ3A2AgBCAFKQBQIhBCHYZCgICAgP7/H4MgE0IjiIQ3A2ggBCARQi6GQoCAgICAgBCDIBBCEoiENwNwIAQgBSkAYCIQQhCGQoCA/P///x+DIBFCMIiENwOAASAEIBJCIYZCgICAgOD/H4MgEEIfiIQ3A4gBIAQgBSkAcCIQQgOGQvj//////x+DIBJCPYiENwOYASAEIAUpAHgiEUIUhkKAgMD///8fgyAQQiyIhDcDoAEgBCAFKQCAASIQQgqIQv///////x+DNwOwASAEIBBCJYZCgICAgID8H4MgEUIbiIQ3A6gBIAQgBSkAiAEiEUIHhkKA//////8fgyAQQjmIhDcDuAEgBCAFKQCQASISQhiGQoCAgPj//x+DIBFCKIiENwPAASAEIAUpAJgBIhBCBohC////////H4M3A9ABIAQgEEIphkKAgICAgMAfgyASQheIhDcDyAEgBCAFKQCgASIRQguGQoDw/////x+DIBBCNYiENwPYASAEIAUpAKgBIhJCHIZCgICAgP//H4MgEUIkiIQ3A+ABIAQgBSkAsAEiEEICiEL///////8fgzcD8AEgBCAQQi2GQoCAgICAgBiDIBJCE4iENwPoASAEIAUpALgBIhFCD4ZCgID+////H4MgEEIxiIQ3A/gBIAQgBSkAwAEiEEIPiEL///////8fgzcDiAIgBCAQQiCGQoCAgIDw/x+DIBFCIIiENwOAAiAEIAUpAMgBIhFCAoZC/P//////H4MgEEI+iIQ3A5ACIAQgBSkA0AEiEkIThkKAgOD///8fgyARQi2IhDcDmAIgBCAFKQDYASIQQguIQv///////x+DNwOoAiAEIBBCJIZCgICAgID+H4MgEkIciIQ3A6ACIAQgBSkA4AEiEUIGhkLA//////8fgyAQQjqIhDcDsAIgBCAFKQDoASISQheGQoCAgPz//x+DIBFCKYiENwO4AiAEIAUpAPABIhBCB4hC////////H4M3A8gCIAQgEEIohkKAgICAgOAfgyASQhiIhDcDwAIgBCAFKQD4ASIRQgqGQoD4/////x+DIBBCNoiENwPQAiAEIAUpAIACIhJCG4ZCgICAwP//H4MgEUIliIQ3A9gCIAQgBSkAiAIiEEIDiEL///////8fgzcD6AIgBCAQQiyGQoCAgICAgByDIBJCFIiENwPgAiAEIAUpAJACIhFCDoZCgID/////H4MgEEIyiIQ3A/ACIAQgBSkAmAIiEEIQiEL///////8fgzcDgAMgBCAQQh+GQoCAgID4/x+DIBFCIYiENwP4AiAEIAUpAKACIhFCAYZC/v//////H4MgEEI/iIQ3A4gDIAQgBSkAqAIiEkIShkKAgPD///8fgyARQi6IhDcDkAMgBCAFKQCwAiIQQgyIQv///////x+DNwOgAyAEIBBCI4ZCgICAgID/H4MgEkIdiIQ3A5gDIAQgBSkAuAIiEUIFhkLg//////8fgyAQQjuIhDcDqAMgBCAFKQDAAiISQhaGQoCAgP7//x+DIBFCKoiENwOwAyAEIAUpAMgCIhBCCIhC////////H4M3A8ADIAQgEEInhkKAgICAgPAfgyASQhmIhDcDuAMgBCAFKQDQAiIRQgmGQoD8/////x+DIBBCN4iENwPIAyAEIAUpANgCIhJCGoZCgICA4P//H4MgEUImiIQ3A9ADIAQgBSkA4AIiEEIEiEL///////8fgzcD4AMgBCAQQiuGQoCAgICAgB6DIBJCFYiENwPYAyAEIAUpAOgCIhFCDYZCgMD/////H4MgEEIziIQ3A+gDIAQgBSkA8AIiEEIRiDcD+AMgBCAQQh6GQoCAgID8/x+DIBFCIoiENwPwAwwSCyAGQf8CTQRADBoLIAQgBSkAACIQQv///////z+DNwMAIAQgBSkAECIRQhCINwMYIAQgBSkAGCISQv///////z+DNwMgIAQgBSkAKCITQhCINwM4IAQgBSkAMCIUQv///////z+DNwNAIAQgBSkACCIVQhCGQoCA/P///z+DIBBCMIiENwMIIAQgEUIghkKAgICA8P8/gyAVQiCIhDcDECAEIAUpACAiEEIQhkKAgPz///8/gyASQjCIhDcDKCAEIBNCIIZCgICAgPD/P4MgEEIgiIQ3AzAgBCAFKQA4IhBCEIZCgID8////P4MgFEIwiIQ3A0ggBCAFKQBAIhFCEIg3A1ggBCARQiCGQoCAgIDw/z+DIBBCIIiENwNQIAQgBSkASCIQQv///////z+DNwNgIAQgBSkAWCIRQhCINwN4IAQgBSkAYCISQv///////z+DNwOAASAEIAUpAHAiE0IQiDcDmAEgBCAFKQB4IhRC////////P4M3A6ABIAQgBSkAUCIVQhCGQoCA/P///z+DIBBCMIiENwNoIAQgEUIghkKAgICA8P8/gyAVQiCIhDcDcCAEIAUpAGgiEEIQhkKAgPz///8/gyASQjCIhDcDiAEgBCATQiCGQoCAgIDw/z+DIBBCIIiENwOQASAEIAUpAIABIhBCEIZCgID8////P4MgFEIwiIQ3A6gBIAQgBSkAiAEiEUIQiDcDuAEgBCARQiCGQoCAgIDw/z+DIBBCIIiENwOwASAEIAUpAJABIhBC////////P4M3A8ABIAQgBSkAmAEiEUIQhkKAgPz///8/gyAQQjCIhDcDyAEgBCAFKQCgASIQQhCINwPYASAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A9ABIAQgBSkAqAEiEEL///////8/gzcD4AEgBCAFKQCwASIRQhCGQoCA/P///z+DIBBCMIiENwPoASAEIAUpALgBIhBCEIg3A/gBIAQgEEIghkKAgICA8P8/gyARQiCIhDcD8AEgBCAFKQDAASIQQv///////z+DNwOAAiAEIAUpAMgBIhFCEIZCgID8////P4MgEEIwiIQ3A4gCIAQgBSkA0AEiEEIQiDcDmAIgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwOQAiAEIAUpANgBIhBC////////P4M3A6ACIAQgBSkA4AEiEUIQhkKAgPz///8/gyAQQjCIhDcDqAIgBCAFKQDoASIQQhCINwO4AiAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A7ACIAQgBSkA8AEiEEL///////8/gzcDwAIgBCAFKQD4ASIRQhCGQoCA/P///z+DIBBCMIiENwPIAiAEIAUpAIACIhBCEIg3A9gCIAQgEEIghkKAgICA8P8/gyARQiCIhDcD0AIgBCAFKQCIAiIQQv///////z+DNwPgAiAEIAUpAJACIhFCEIZCgID8////P4MgEEIwiIQ3A+gCIAQgBSkAmAIiEEIQiDcD+AIgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwPwAiAEIAUpAKACIhBC////////P4M3A4ADIAQgBSkAqAIiEUIQhkKAgPz///8/gyAQQjCIhDcDiAMgBCAFKQCwAiIQQhCINwOYAyAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A5ADIAQgBSkAuAIiEEL///////8/gzcDoAMgBCAFKQDAAiIRQhCGQoCA/P///z+DIBBCMIiENwOoAyAEIAUpAMgCIhBCEIg3A7gDIAQgEEIghkKAgICA8P8/gyARQiCIhDcDsAMgBCAFKQDQAiIQQv///////z+DNwPAAyAEIAUpANgCIhFCEIZCgID8////P4MgEEIwiIQ3A8gDIAQgBSkA4AIiEEIQiDcD2AMgBCAQQiCGQoCAgIDw/z+DIBFCIIiENwPQAyAEIAUpAOgCIhBC////////P4M3A+ADIAQgBSkA8AIiEUIQhkKAgPz///8/gyAQQjCIhDcD6AMgBCAFKQD4AiIQQhCINwP4AyAEIBBCIIZCgICAgPD/P4MgEUIgiIQ3A/ADDBELIAZBhwNNBEAMGQsgBCAFKQAAIhJC/////////wCDNwMAIAQgBSkAGCIQQgSIQv////////8AgzcDICAEIAUpADAiEUIIiEL/////////AIM3A0AgBCAFKQAIIhNCD4ZCgID+/////wCDIBJCMYiENwMIIAQgBSkAECISQh6GQoCAgID8//8AgyATQiKIhDcDECAEIBBCLYZCgICAgICA+ACDIBJCE4iENwMYIAQgBSkAICISQguGQoDw//////8AgyAQQjWIhDcDKCAEIAUpACgiEEIahkKAgIDg////AIMgEkImiIQ3AzAgBCARQimGQoCAgICAwP8AgyAQQheIhDcDOCAEIAUpADgiEEIHhkKA////////AIMgEUI5iIQ3A0ggBCAFKQBAIhNCFoZCgICA/v///wCDIBBCKoiENwNQIAQgBSkASCIQQgyIQv////////8AgzcDYCAEIAUpAGgiEUIBiEL/////////AIM3A4gBIAQgBSkAgAEiEkIFiEL/////////AIM3A6gBIAQgEEIlhkKAgICAgPz/AIMgE0IbiIQ3A1ggBCAFKQBQIhNCA4ZC+P///////wCDIBBCPYiENwNoIAQgBSkAWCIQQhKGQoCA8P////8AgyATQi6IhDcDcCAEIAUpAGAiE0IhhkKAgICA4P//AIMgEEIfiIQ3A3ggBCARQjCGQoCAgICAgMAAgyATQhCIhDcDgAEgBCAFKQBwIhBCDoZCgID//////wCDIBFCMoiENwOQASAEIAUpAHgiEUIdhkKAgICA/v//AIMgEEIjiIQ3A5gBIAQgEkIshkKAgICAgID8AIMgEUIUiIQ3A6ABIAQgBSkAiAEiEEIKhkKA+P//////AIMgEkI2iIQ3A7ABIAQgBSkAkAEiEUIZhkKAgIDw////AIMgEEIniIQ3A7gBIAQgBSkAmAEiEEIJiEL/////////AIM3A8gBIAQgEEIohkKAgICAgOD/AIMgEUIYiIQ3A8ABIAQgBSkAoAEiEUIGhkLA////////AIMgEEI6iIQ3A9ABIAQgBSkAqAEiEkIVhkKAgID/////AIMgEUIriIQ3A9gBIAQgBSkAsAEiEEINiEL/////////AIM3A+gBIAQgEEIkhkKAgICAgP7/AIMgEkIciIQ3A+ABIAQgBSkAuAEiEUIChkL8////////AIMgEEI+iIQ3A/ABIAQgBSkAwAEiEEIRhkKAgPj/////AIMgEUIviIQ3A/gBIAQgBSkAyAEiEUIghkKAgICA8P//AIMgEEIgiIQ3A4ACIAQgBSkA0AEiEEICiEL/////////AIM3A5ACIAQgEEIvhkKAgICAgIDgAIMgEUIRiIQ3A4gCIAQgBSkA2AEiEUINhkKAwP//////AIMgEEIziIQ3A5gCIAQgBSkA4AEiEkIchkKAgICA////AIMgEUIkiIQ3A6ACIAQgBSkA6AEiEEIGiEL/////////AIM3A7ACIAQgEEIrhkKAgICAgID+AIMgEkIViIQ3A6gCIAQgBSkA8AEiEUIJhkKA/P//////AIMgEEI3iIQ3A7gCIAQgBSkA+AEiEkIYhkKAgID4////AIMgEUIoiIQ3A8ACIAQgBSkAgAIiEEIKiEL/////////AIM3A9ACIAQgEEInhkKAgICAgPD/AIMgEkIZiIQ3A8gCIAQgBSkAiAIiEUIFhkLg////////AIMgEEI7iIQ3A9gCIAQgBSkAkAIiEkIUhkKAgMD/////AIMgEUIsiIQ3A+ACIAQgBSkAmAIiEEIOiEL/////////AIM3A/ACIAQgEEIjhkKAgICAgP//AIMgEkIdiIQ3A+gCIAQgBSkAoAIiEUIBhkL+////////AIMgEEI/iIQ3A/gCIAQgBSkAqAIiEEIQhkKAgPz/////AIMgEUIwiIQ3A4ADIAQgBSkAsAIiEUIfhkKAgICA+P//AIMgEEIhiIQ3A4gDIAQgBSkAuAIiEEIDiEL/////////AIM3A5gDIAQgEEIuhkKAgICAgIDwAIMgEUISiIQ3A5ADIAQgBSkAwAIiEUIMhkKA4P//////AIMgEEI0iIQ3A6ADIAQgBSkAyAIiEkIbhkKAgIDA////AIMgEUIliIQ3A6gDIAQgBSkA0AIiEEIHiEL/////////AIM3A7gDIAQgEEIqhkKAgICAgID/AIMgEkIWiIQ3A7ADIAQgBSkA2AIiEUIIhkKA/v//////AIMgEEI4iIQ3A8ADIAQgBSkA4AIiEkIXhkKAgID8////AIMgEUIpiIQ3A8gDIAQgBSkA6AIiEEILiEL/////////AIM3A9gDIAQgEEImhkKAgICAgPj/AIMgEkIaiIQ3A9ADIAQgBSkA8AIiEUIEhkLw////////AIMgEEI8iIQ3A+ADIAQgBSkA+AIiEEIThkKAgOD/////AIMgEUItiIQ3A+gDIAQgBSkAgAMiEUIPiDcD+AMgBCARQiKGQoCAgIDA//8AgyAQQh6IhDcD8AMMEAsgBkGPA00EQAwYCyAEIAUpAAAiEkL/////////AYM3AwAgBCAFKQAYIhBCCIhC/////////wGDNwMgIAQgBSkAOCIRQgKIQv////////8BgzcDSCAEIAUpAAgiE0IOhkKAgP//////AYMgEkIyiIQ3AwggBCAFKQAQIhJCHIZCgICAgP///wGDIBNCJIiENwMQIAQgEEIqhkKAgICAgID/AYMgEkIWiIQ3AxggBCAFKQAgIhJCBoZCwP///////wGDIBBCOoiENwMoIAQgBSkAKCIQQhSGQoCAwP////8BgyASQiyIhDcDMCAEIAUpADAiEkIihkKAgICAwP//AYMgEEIeiIQ3AzggBCARQjCGQoCAgICAgMABgyASQhCIhDcDQCAEIAUpAEAiEkIMhkKA4P//////AYMgEUI0iIQ3A1AgBCAFKQBQIhBCCohC/////////wGDNwNoIAQgBSkAcCIRQgSIQv////////8BgzcDkAEgBCAFKQBIIhNCGoZCgICA4P///wGDIBJCJoiENwNYIAQgEEIohkKAgICAgOD/AYMgE0IYiIQ3A2AgBCAFKQBYIhJCBIZC8P///////wGDIBBCPIiENwNwIAQgBSkAYCIQQhKGQoCA8P////8BgyASQi6IhDcDeCAEIAUpAGgiEkIghkKAgICA8P//AYMgEEIgiIQ3A4ABIAQgEUIuhkKAgICAgIDwAYMgEkISiIQ3A4gBIAQgBSkAeCIQQgqGQoD4//////8BgyARQjaIhDcDmAEgBCAFKQCAASIRQhiGQoCAgPj///8BgyAQQiiIhDcDoAEgBCAFKQCIASIQQgyIQv////////8BgzcDsAEgBCAQQiaGQoCAgICA+P8BgyARQhqIhDcDqAEgBCAFKQCQASIRQgKGQvz///////8BgyAQQj6IhDcDuAEgBCAFKQCYASIQQhCGQoCA/P////8BgyARQjCIhDcDwAEgBCAFKQCgASIRQh6GQoCAgID8//8BgyAQQiKIhDcDyAEgBCAFKQCoASIQQgaIQv////////8BgzcD2AEgBCAQQiyGQoCAgICAgPwBgyARQhSIhDcD0AEgBCAFKQCwASIRQgiGQoD+//////8BgyAQQjiIhDcD4AEgBCAFKQC4ASIQQhaGQoCAgP7///8BgyARQiqIhDcD6AEgBCAFKQDAASIRQg6INwP4ASAEIBFCJIZCgICAgID+/wGDIBBCHIiENwPwASAEIAUpAMgBIhBC/////////wGDNwOAAiAEIAUpANABIhFCDoZCgID//////wGDIBBCMoiENwOIAiAEIAUpANgBIhJCHIZCgICAgP///wGDIBFCJIiENwOQAiAEIAUpAOABIhBCCIhC/////////wGDNwOgAiAEIBBCKoZCgICAgICA/wGDIBJCFoiENwOYAiAEIAUpAOgBIhFCBoZCwP///////wGDIBBCOoiENwOoAiAEIAUpAPABIhBCFIZCgIDA/////wGDIBFCLIiENwOwAiAEIAUpAPgBIhFCIoZCgICAgMD//wGDIBBCHoiENwO4AiAEIAUpAIACIhBCAohC/////////wGDNwPIAiAEIBBCMIZCgICAgICAwAGDIBFCEIiENwPAAiAEIAUpAIgCIhFCDIZCgOD//////wGDIBBCNIiENwPQAiAEIAUpAJACIhJCGoZCgICA4P///wGDIBFCJoiENwPYAiAEIAUpAJgCIhBCCohC/////////wGDNwPoAiAEIBBCKIZCgICAgIDg/wGDIBJCGIiENwPgAiAEIAUpAKACIhFCBIZC8P///////wGDIBBCPIiENwPwAiAEIAUpAKgCIhBCEoZCgIDw/////wGDIBFCLoiENwP4AiAEIAUpALACIhFCIIZCgICAgPD//wGDIBBCIIiENwOAAyAEIAUpALgCIhBCBIhC/////////wGDNwOQAyAEIBBCLoZCgICAgICA8AGDIBFCEoiENwOIAyAEIAUpAMACIhFCCoZCgPj//////wGDIBBCNoiENwOYAyAEIAUpAMgCIhJCGIZCgICA+P///wGDIBFCKIiENwOgAyAEIAUpANACIhBCDIhC/////////wGDNwOwAyAEIBBCJoZCgICAgID4/wGDIBJCGoiENwOoAyAEIAUpANgCIhFCAoZC/P///////wGDIBBCPoiENwO4AyAEIAUpAOACIhBCEIZCgID8/////wGDIBFCMIiENwPAAyAEIAUpAOgCIhFCHoZCgICAgPz//wGDIBBCIoiENwPIAyAEIAUpAPACIhBCBohC/////////wGDNwPYAyAEIBBCLIZCgICAgICA/AGDIBFCFIiENwPQAyAEIAUpAPgCIhFCCIZCgP7//////wGDIBBCOIiENwPgAyAEIAUpAIADIhBCFoZCgICA/v///wGDIBFCKoiENwPoAyAEIAUpAIgDIhFCDog3A/gDIAQgEUIkhkKAgICAgP7/AYMgEEIciIQ3A/ADDA8LIAZBlwNNBEAMFwsgBCAFKQAAIhJC/////////wODNwMAIAQgBSkAGCIQQgyIQv////////8DgzcDICAEIAUpADgiEUILiEL/////////A4M3A0ggBCAFKQAIIhNCDYZCgMD//////wODIBJCM4iENwMIIAQgBSkAECISQhqGQoCAgOD///8DgyATQiaIhDcDECAEIBBCJ4ZCgICAgIDw/wODIBJCGYiENwMYIAQgBSkAICISQgGGQv7///////8DgyAQQj+IhDcDKCAEIAUpACgiEEIOhkKAgP//////A4MgEkIyiIQ3AzAgBCAFKQAwIhJCG4ZCgICAwP///wODIBBCJYiENwM4IAQgEUIohkKAgICAgOD/A4MgEkIYiIQ3A0AgBCAFKQBAIhJCAoZC/P///////wODIBFCPoiENwNQIAQgBSkAWCIQQgqIQv////////8DgzcDcCAEIAUpAHgiEUIJiEL/////////A4M3A5gBIAQgBSkASCITQg+GQoCA/v////8DgyASQjGIhDcDWCAEIAUpAFAiEkIchkKAgICA////A4MgE0IkiIQ3A2AgBCAQQimGQoCAgICAwP8DgyASQheIhDcDaCAEIAUpAGAiEkIDhkL4////////A4MgEEI9iIQ3A3ggBCAFKQBoIhBCEIZCgID8/////wODIBJCMIiENwOAASAEIAUpAHAiEkIdhkKAgICA/v//A4MgEEIjiIQ3A4gBIAQgEUIqhkKAgICAgID/A4MgEkIWiIQ3A5ABIAQgBSkAgAEiEEIEhkLw////////A4MgEUI8iIQ3A6ABIAQgBSkAiAEiEUIRhkKAgPj/////A4MgEEIviIQ3A6gBIAQgBSkAkAEiEkIehkKAgICA/P//A4MgEUIiiIQ3A7ABIAQgBSkAmAEiEEIIiEL/////////A4M3A8ABIAQgEEIrhkKAgICAgID+A4MgEkIViIQ3A7gBIAQgBSkAoAEiEUIFhkLg////////A4MgEEI7iIQ3A8gBIAQgBSkAqAEiEEIShkKAgPD/////A4MgEUIuiIQ3A9ABIAQgBSkAsAEiEUIfhkKAgICA+P//A4MgEEIhiIQ3A9gBIAQgBSkAuAEiEEIHiEL/////////A4M3A+gBIAQgEEIshkKAgICAgID8A4MgEUIUiIQ3A+ABIAQgBSkAwAEiEUIGhkLA////////A4MgEEI6iIQ3A/ABIAQgBSkAyAEiEEIThkKAgOD/////A4MgEUItiIQ3A/gBIAQgBSkA0AEiEUIghkKAgICA8P//A4MgEEIgiIQ3A4ACIAQgBSkA2AEiEEIGiEL/////////A4M3A5ACIAQgEEIthkKAgICAgID4A4MgEUITiIQ3A4gCIAQgBSkA4AEiEUIHhkKA////////A4MgEEI5iIQ3A5gCIAQgBSkA6AEiEEIUhkKAgMD/////A4MgEUIsiIQ3A6ACIAQgBSkA8AEiEUIhhkKAgICA4P//A4MgEEIfiIQ3A6gCIAQgBSkA+AEiEEIFiEL/////////A4M3A7gCIAQgEEIuhkKAgICAgIDwA4MgEUISiIQ3A7ACIAQgBSkAgAIiEUIIhkKA/v//////A4MgEEI4iIQ3A8ACIAQgBSkAiAIiEEIVhkKAgID/////A4MgEUIriIQ3A8gCIAQgBSkAkAIiEUIihkKAgICAwP//A4MgEEIeiIQ3A9ACIAQgBSkAmAIiEEIEiEL/////////A4M3A+ACIAQgEEIvhkKAgICAgIDgA4MgEUIRiIQ3A9gCIAQgBSkAoAIiEUIJhkKA/P//////A4MgEEI3iIQ3A+gCIAQgBSkAqAIiEEIWhkKAgID+////A4MgEUIqiIQ3A/ACIAQgBSkAsAIiEUIjhkKAgICAgP//A4MgEEIdiIQ3A/gCIAQgBSkAuAIiEEIDiEL/////////A4M3A4gDIAQgEEIwhkKAgICAgIDAA4MgEUIQiIQ3A4ADIAQgBSkAwAIiEUIKhkKA+P//////A4MgEEI2iIQ3A5ADIAQgBSkAyAIiEEIXhkKAgID8////A4MgEUIpiIQ3A5gDIAQgBSkA0AIiEUIkhkKAgICAgP7/A4MgEEIciIQ3A6ADIAQgBSkA2AIiEEICiEL/////////A4M3A7ADIAQgEEIxhkKAgICAgICAA4MgEUIPiIQ3A6gDIAQgBSkA4AIiEUILhkKA8P//////A4MgEEI1iIQ3A7gDIAQgBSkA6AIiEEIYhkKAgID4////A4MgEUIoiIQ3A8ADIAQgBSkA8AIiEUIlhkKAgICAgPz/A4MgEEIbiIQ3A8gDIAQgBSkA+AIiEEIBiEL/////////A4M3A9gDIAQgEEIyhkKAgICAgICAAoMgEUIOiIQ3A9ADIAQgBSkAgAMiEUIMhkKA4P//////A4MgEEI0iIQ3A+ADIAQgBSkAiAMiEEIZhkKAgIDw////A4MgEUIniIQ3A+gDIAQgBSkAkAMiEUINiDcD+AMgBCARQiaGQoCAgICA+P8DgyAQQhqIhDcD8AMMDgsgBkGfA00EQAwWCyAEIAUpAAAiEkL/////////B4M3AwAgBCAFKQAgIhBCBIhC/////////weDNwMoIAQgBSkAQCIRQgiIQv////////8HgzcDUCAEIAUpAAgiE0IMhkKA4P//////B4MgEkI0iIQ3AwggBCAFKQAQIhJCGIZCgICA+P///weDIBNCKIiENwMQIAQgBSkAGCITQiSGQoCAgICA/v8HgyASQhyIhDcDGCAEIBBCMIZCgICAgICAwAeDIBNCEIiENwMgIAQgBSkAKCISQgiGQoD+//////8HgyAQQjiIhDcDMCAEIAUpADAiEEIUhkKAgMD/////B4MgEkIsiIQ3AzggBCAFKQA4IhJCIIZCgICAgPD//weDIBBCIIiENwNAIAQgEUIshkKAgICAgID8B4MgEkIUiIQ3A0ggBCAFKQBgIhJCDIg3A3ggBCAFKQBoIhNC/////////weDNwOAASAEIAUpAIgBIhBCBIhC/////////weDNwOoASAEIAUpAEgiFEIEhkLw////////B4MgEUI8iIQ3A1ggBCAFKQBQIhFCEIZCgID8/////weDIBRCMIiENwNgIAQgBSkAWCIUQhyGQoCAgID///8HgyARQiSIhDcDaCAEIBJCKIZCgICAgIDg/weDIBRCGIiENwNwIAQgBSkAcCIRQgyGQoDg//////8HgyATQjSIhDcDiAEgBCAFKQB4IhJCGIZCgICA+P///weDIBFCKIiENwOQASAEIAUpAIABIhFCJIZCgICAgID+/weDIBJCHIiENwOYASAEIBBCMIZCgICAgICAwAeDIBFCEIiENwOgASAEIAUpAJABIhFCCIZCgP7//////weDIBBCOIiENwOwASAEIAUpAJgBIhBCFIZCgIDA/////weDIBFCLIiENwO4ASAEIAUpAKABIhFCIIZCgICAgPD//weDIBBCIIiENwPAASAEIAUpAKgBIhBCCIhC/////////weDNwPQASAEIBBCLIZCgICAgICA/AeDIBFCFIiENwPIASAEIAUpALABIhFCBIZC8P///////weDIBBCPIiENwPYASAEIAUpALgBIhBCEIZCgID8/////weDIBFCMIiENwPgASAEIAUpAMABIhFCHIZCgICAgP///weDIBBCJIiENwPoASAEIAUpAMgBIhBCDIg3A/gBIAQgEEIohkKAgICAgOD/B4MgEUIYiIQ3A/ABIAQgBSkA0AEiEEL/////////B4M3A4ACIAQgBSkA2AEiEUIMhkKA4P//////B4MgEEI0iIQ3A4gCIAQgBSkA4AEiEEIYhkKAgID4////B4MgEUIoiIQ3A5ACIAQgBSkA6AEiEUIkhkKAgICAgP7/B4MgEEIciIQ3A5gCIAQgBSkA8AEiEEIEiEL/////////B4M3A6gCIAQgEEIwhkKAgICAgIDAB4MgEUIQiIQ3A6ACIAQgBSkA+AEiEUIIhkKA/v//////B4MgEEI4iIQ3A7ACIAQgBSkAgAIiEEIUhkKAgMD/////B4MgEUIsiIQ3A7gCIAQgBSkAiAIiEUIghkKAgICA8P//B4MgEEIgiIQ3A8ACIAQgBSkAkAIiEEIIiEL/////////B4M3A9ACIAQgEEIshkKAgICAgID8B4MgEUIUiIQ3A8gCIAQgBSkAmAIiEUIEhkLw////////B4MgEEI8iIQ3A9gCIAQgBSkAoAIiEEIQhkKAgPz/////B4MgEUIwiIQ3A+ACIAQgBSkAqAIiEUIchkKAgICA////B4MgEEIkiIQ3A+gCIAQgBSkAsAIiEEIMiDcD+AIgBCAQQiiGQoCAgICA4P8HgyARQhiIhDcD8AIgBCAFKQC4AiIQQv////////8HgzcDgAMgBCAFKQDAAiIRQgyGQoDg//////8HgyAQQjSIhDcDiAMgBCAFKQDIAiIQQhiGQoCAgPj///8HgyARQiiIhDcDkAMgBCAFKQDQAiIRQiSGQoCAgICA/v8HgyAQQhyIhDcDmAMgBCAFKQDYAiIQQgSIQv////////8HgzcDqAMgBCAQQjCGQoCAgICAgMAHgyARQhCIhDcDoAMgBCAFKQDgAiIRQgiGQoD+//////8HgyAQQjiIhDcDsAMgBCAFKQDoAiIQQhSGQoCAwP////8HgyARQiyIhDcDuAMgBCAFKQDwAiIRQiCGQoCAgIDw//8HgyAQQiCIhDcDwAMgBCAFKQD4AiIQQgiIQv////////8HgzcD0AMgBCAQQiyGQoCAgICAgPwHgyARQhSIhDcDyAMgBCAFKQCAAyIRQgSGQvD///////8HgyAQQjyIhDcD2AMgBCAFKQCIAyIQQhCGQoCA/P////8HgyARQjCIhDcD4AMgBCAFKQCQAyIRQhyGQoCAgID///8HgyAQQiSIhDcD6AMgBCAFKQCYAyIQQgyINwP4AyAEIBBCKIZCgICAgIDg/weDIBFCGIiENwPwAwwNCyAGQacDTQRADBULIAQgBSkAACIRQv////////8PgzcDACAEIAUpACAiEEIJiEL/////////D4M3AyggBCAFKQAIIhJCC4ZCgPD//////w+DIBFCNYiENwMIIAQgBSkAECIRQhaGQoCAgP7///8PgyASQiqIhDcDECAEIAUpABgiEkIhhkKAgICA4P//D4MgEUIfiIQ3AxggBCAQQiyGQoCAgICAgPwPgyASQhSIhDcDICAEIAUpACgiEUIChkL8////////D4MgEEI+iIQ3AzAgBCAFKQAwIhBCDYZCgMD//////w+DIBFCM4iENwM4IAQgBSkAOCIRQhiGQoCAgPj///8PgyAQQiiIhDcDQCAEIAUpAEAiEkIjhkKAgICAgP//D4MgEUIdiIQ3A0ggBCAFKQBIIhBCB4hC/////////w+DNwNYIAQgBSkAcCIRQgWIQv////////8PgzcDiAEgBCAQQi6GQoCAgICAgPAPgyASQhKIhDcDUCAEIAUpAFAiEkIEhkLw////////D4MgEEI8iIQ3A2AgBCAFKQBYIhBCD4ZCgID+/////w+DIBJCMYiENwNoIAQgBSkAYCISQhqGQoCAgOD///8PgyAQQiaIhDcDcCAEIAUpAGgiEEIlhkKAgICAgPz/D4MgEkIbiIQ3A3ggBCARQjCGQoCAgICAgMAPgyAQQhCIhDcDgAEgBCAFKQB4IhBCBoZCwP///////w+DIBFCOoiENwOQASAEIAUpAIABIhFCEYZCgID4/////w+DIBBCL4iENwOYASAEIAUpAIgBIhBCHIZCgICAgP///w+DIBFCJIiENwOgASAEIAUpAJABIhFCJ4ZCgICAgIDw/w+DIBBCGYiENwOoASAEIAUpAJgBIhBCA4hC/////////w+DNwO4ASAEIBBCMoZCgICAgICAgA6DIBFCDoiENwOwASAEIAUpAKABIhFCCIZCgP7//////w+DIBBCOIiENwPAASAEIAUpAKgBIhBCE4ZCgIDg/////w+DIBFCLYiENwPIASAEIAUpALABIhFCHoZCgICAgPz//w+DIBBCIoiENwPQASAEIAUpALgBIhJCKYZCgICAgIDA/w+DIBFCF4iENwPYASAEIAUpAMABIhBCAYhC/////////w+DNwPoASAEIBBCNIZCgICAgICAgAiDIBJCDIiENwPgASAEIAUpAMgBIhFCCoZCgPj//////w+DIBBCNoiENwPwASAEIAUpANABIhBCFYZCgICA/////w+DIBFCK4iENwP4ASAEIAUpANgBIhFCIIZCgICAgPD//w+DIBBCIIiENwOAAiAEIAUpAOABIhBCCohC/////////w+DNwOQAiAEIBBCK4ZCgICAgICA/g+DIBFCFYiENwOIAiAEIAUpAOgBIhFCAYZC/v///////w+DIBBCP4iENwOYAiAEIAUpAPABIhBCDIZCgOD//////w+DIBFCNIiENwOgAiAEIAUpAPgBIhFCF4ZCgICA/P///w+DIBBCKYiENwOoAiAEIAUpAIACIhJCIoZCgICAgMD//w+DIBFCHoiENwOwAiAEIAUpAIgCIhBCCIhC/////////w+DNwPAAiAEIBBCLYZCgICAgICA+A+DIBJCE4iENwO4AiAEIAUpAJACIhFCA4ZC+P///////w+DIBBCPYiENwPIAiAEIAUpAJgCIhBCDoZCgID//////w+DIBFCMoiENwPQAiAEIAUpAKACIhFCGYZCgICA8P///w+DIBBCJ4iENwPYAiAEIAUpAKgCIhJCJIZCgICAgID+/w+DIBFCHIiENwPgAiAEIAUpALACIhBCBohC/////////w+DNwPwAiAEIBBCL4ZCgICAgICA4A+DIBJCEYiENwPoAiAEIAUpALgCIhFCBYZC4P///////w+DIBBCO4iENwP4AiAEIAUpAMACIhBCEIZCgID8/////w+DIBFCMIiENwOAAyAEIAUpAMgCIhFCG4ZCgICAwP///w+DIBBCJYiENwOIAyAEIAUpANACIhJCJoZCgICAgID4/w+DIBFCGoiENwOQAyAEIAUpANgCIhBCBIhC/////////w+DNwOgAyAEIBBCMYZCgICAgICAgA+DIBJCD4iENwOYAyAEIAUpAOACIhFCB4ZCgP///////w+DIBBCOYiENwOoAyAEIAUpAOgCIhBCEoZCgIDw/////w+DIBFCLoiENwOwAyAEIAUpAPACIhFCHYZCgICAgP7//w+DIBBCI4iENwO4AyAEIAUpAPgCIhJCKIZCgICAgIDg/w+DIBFCGIiENwPAAyAEIAUpAIADIhBCAohC/////////w+DNwPQAyAEIBBCM4ZCgICAgICAgAyDIBJCDYiENwPIAyAEIAUpAIgDIhFCCYZCgPz//////w+DIBBCN4iENwPYAyAEIAUpAJADIhBCFIZCgIDA/////w+DIBFCLIiENwPgAyAEIAUpAJgDIhFCH4ZCgICAgPj//w+DIBBCIYiENwPoAyAEIAUpAKADIhBCC4g3A/gDIAQgEEIqhkKAgICAgID/D4MgEUIWiIQ3A/ADDAwLIAZBrwNNBEAMFAsgBCAFKQAAIhFC/////////x+DNwMAIAQgBSkAKCIQQgSIQv////////8fgzcDMCAEIAUpAAgiEkIKhkKA+P//////H4MgEUI2iIQ3AwggBCAFKQAQIhFCFIZCgIDA/////x+DIBJCLIiENwMQIAQgBSkAGCISQh6GQoCAgID8//8fgyARQiKIhDcDGCAEIAUpACAiEUIohkKAgICAgOD/H4MgEkIYiIQ3AyAgBCAQQjKGQoCAgICAgIAegyARQg6IhDcDKCAEIAUpADAiEUIGhkLA////////H4MgEEI6iIQ3AzggBCAFKQA4IhBCEIZCgID8/////x+DIBFCMIiENwNAIAQgBSkAQCISQhqGQoCAgOD///8fgyAQQiaIhDcDSCAEIAUpAFAiEEIIiEL/////////H4M3A2AgBCAFKQCAASIRQgKIQv////////8fgzcDmAEgBCAFKQBIIhNCJIZCgICAgID+/x+DIBJCHIiENwNQIAQgEEIuhkKAgICAgIDwH4MgE0ISiIQ3A1ggBCAFKQBYIhJCAoZC/P///////x+DIBBCPoiENwNoIAQgBSkAYCIQQgyGQoDg//////8fgyASQjSIhDcDcCAEIAUpAGgiEkIWhkKAgID+////H4MgEEIqiIQ3A3ggBCAFKQBwIhBCIIZCgICAgPD//x+DIBJCIIiENwOAASAEIAUpAHgiEkIqhkKAgICAgID/H4MgEEIWiIQ3A4gBIAQgEUI0hkKAgICAgICAGIMgEkIMiIQ3A5ABIAQgBSkAiAEiEEIIhkKA/v//////H4MgEUI4iIQ3A6ABIAQgBSkAkAEiEUIShkKAgPD/////H4MgEEIuiIQ3A6gBIAQgBSkAmAEiEEIchkKAgICA////H4MgEUIkiIQ3A7ABIAQgBSkAoAEiEUImhkKAgICAgPj/H4MgEEIaiIQ3A7gBIAQgBSkAqAEiEEIGiEL/////////H4M3A8gBIAQgEEIwhkKAgICAgIDAH4MgEUIQiIQ3A8ABIAQgBSkAsAEiEUIEhkLw////////H4MgEEI8iIQ3A9ABIAQgBSkAuAEiEEIOhkKAgP//////H4MgEUIyiIQ3A9gBIAQgBSkAwAEiEUIYhkKAgID4////H4MgEEIoiIQ3A+ABIAQgBSkAyAEiEEIihkKAgICAwP//H4MgEUIeiIQ3A+gBIAQgBSkA0AEiEUIKiDcD+AEgBCARQiyGQoCAgICAgPwfgyAQQhSIhDcD8AEgBCAFKQDYASIQQv////////8fgzcDgAIgBCAFKQDgASIRQgqGQoD4//////8fgyAQQjaIhDcDiAIgBCAFKQDoASIQQhSGQoCAwP////8fgyARQiyIhDcDkAIgBCAFKQDwASIRQh6GQoCAgID8//8fgyAQQiKIhDcDmAIgBCAFKQD4ASISQiiGQoCAgICA4P8fgyARQhiIhDcDoAIgBCAFKQCAAiIQQgSIQv////////8fgzcDsAIgBCAQQjKGQoCAgICAgIAegyASQg6IhDcDqAIgBCAFKQCIAiIRQgaGQsD///////8fgyAQQjqIhDcDuAIgBCAFKQCQAiIQQhCGQoCA/P////8fgyARQjCIhDcDwAIgBCAFKQCYAiIRQhqGQoCAgOD///8fgyAQQiaIhDcDyAIgBCAFKQCgAiISQiSGQoCAgICA/v8fgyARQhyIhDcD0AIgBCAFKQCoAiIQQgiIQv////////8fgzcD4AIgBCAQQi6GQoCAgICAgPAfgyASQhKIhDcD2AIgBCAFKQCwAiIRQgKGQvz///////8fgyAQQj6IhDcD6AIgBCAFKQC4AiIQQgyGQoDg//////8fgyARQjSIhDcD8AIgBCAFKQDAAiIRQhaGQoCAgP7///8fgyAQQiqIhDcD+AIgBCAFKQDIAiIQQiCGQoCAgIDw//8fgyARQiCIhDcDgAMgBCAFKQDQAiIRQiqGQoCAgICAgP8fgyAQQhaIhDcDiAMgBCAFKQDYAiIQQgKIQv////////8fgzcDmAMgBCAQQjSGQoCAgICAgIAYgyARQgyIhDcDkAMgBCAFKQDgAiIRQgiGQoD+//////8fgyAQQjiIhDcDoAMgBCAFKQDoAiIQQhKGQoCA8P////8fgyARQi6IhDcDqAMgBCAFKQDwAiIRQhyGQoCAgID///8fgyAQQiSIhDcDsAMgBCAFKQD4AiISQiaGQoCAgICA+P8fgyARQhqIhDcDuAMgBCAFKQCAAyIQQgaIQv////////8fgzcDyAMgBCAQQjCGQoCAgICAgMAfgyASQhCIhDcDwAMgBCAFKQCIAyIRQgSGQvD///////8fgyAQQjyIhDcD0AMgBCAFKQCQAyIQQg6GQoCA//////8fgyARQjKIhDcD2AMgBCAFKQCYAyIRQhiGQoCAgPj///8fgyAQQiiIhDcD4AMgBCAFKQCgAyIQQiKGQoCAgIDA//8fgyARQh6IhDcD6AMgBCAFKQCoAyIRQgqINwP4AyAEIBFCLIZCgICAgICA/B+DIBBCFIiENwPwAwwLCyAGQbcDTQRADBMLIAQgBSkAACIRQv////////8/gzcDACAEIAUpADAiEEIBiEL/////////P4M3AzggBCAFKQAIIhJCCYZCgPz//////z+DIBFCN4iENwMIIAQgBSkAECIRQhKGQoCA8P////8/gyASQi6IhDcDECAEIAUpABgiEkIbhkKAgIDA////P4MgEUIliIQ3AxggBCAFKQAgIhFCJIZCgICAgID+/z+DIBJCHIiENwMgIAQgBSkAKCISQi2GQoCAgICAgPg/gyARQhOIhDcDKCAEIBBCNoZCgICAgICAgCCDIBJCCoiENwMwIAQgBSkAOCIRQgiGQoD+//////8/gyAQQjiIhDcDQCAEIAUpAEAiEkIRhkKAgPj/////P4MgEUIviIQ3A0ggBCAFKQBgIhBCAohC/////////z+DNwNwIAQgBSkASCIRQhqGQoCAgOD///8/gyASQiaIhDcDUCAEIAUpAFAiEkIjhkKAgICAgP//P4MgEUIdiIQ3A1ggBCAFKQBYIhFCLIZCgICAgICA/D+DIBJCFIiENwNgIAQgEEI1hkKAgICAgICAMIMgEUILiIQ3A2ggBCAFKQBoIhFCB4ZCgP///////z+DIBBCOYiENwN4IAQgBSkAcCIQQhCGQoCA/P////8/gyARQjCIhDcDgAEgBCAFKQB4IhFCGYZCgICA8P///z+DIBBCJ4iENwOIASAEIAUpAIABIhBCIoZCgICAgMD//z+DIBFCHoiENwOQASAEIAUpAIgBIhFCK4ZCgICAgICA/j+DIBBCFYiENwOYASAEIAUpAJABIhBCA4hC/////////z+DNwOoASAEIBBCNIZCgICAgICAgDiDIBFCDIiENwOgASAEIAUpAJgBIhFCBoZCwP///////z+DIBBCOoiENwOwASAEIAUpAKABIhBCD4ZCgID+/////z+DIBFCMYiENwO4ASAEIAUpAKgBIhFCGIZCgICA+P///z+DIBBCKIiENwPAASAEIAUpALABIhBCIYZCgICAgOD//z+DIBFCH4iENwPIASAEIAUpALgBIhFCKoZCgICAgICA/z+DIBBCFoiENwPQASAEIAUpAMABIhBCBIhC/////////z+DNwPgASAEIBBCM4ZCgICAgICAgDyDIBFCDYiENwPYASAEIAUpAMgBIhFCBYZC4P///////z+DIBBCO4iENwPoASAEIAUpANABIhBCDoZCgID//////z+DIBFCMoiENwPwASAEIAUpANgBIhFCF4ZCgICA/P///z+DIBBCKYiENwP4ASAEIAUpAOABIhBCIIZCgICAgPD//z+DIBFCIIiENwOAAiAEIAUpAOgBIhFCKYZCgICAgIDA/z+DIBBCF4iENwOIAiAEIAUpAPABIhBCBYhC/////////z+DNwOYAiAEIBBCMoZCgICAgICAgD6DIBFCDoiENwOQAiAEIAUpAPgBIhFCBIZC8P///////z+DIBBCPIiENwOgAiAEIAUpAIACIhBCDYZCgMD//////z+DIBFCM4iENwOoAiAEIAUpAIgCIhFCFoZCgICA/v///z+DIBBCKoiENwOwAiAEIAUpAJACIhBCH4ZCgICAgPj//z+DIBFCIYiENwO4AiAEIAUpAJgCIhFCKIZCgICAgIDg/z+DIBBCGIiENwPAAiAEIAUpAKACIhBCBohC/////////z+DNwPQAiAEIBBCMYZCgICAgICAgD+DIBFCD4iENwPIAiAEIAUpAKgCIhFCA4ZC+P///////z+DIBBCPYiENwPYAiAEIAUpALACIhBCDIZCgOD//////z+DIBFCNIiENwPgAiAEIAUpALgCIhFCFYZCgICA/////z+DIBBCK4iENwPoAiAEIAUpAMACIhBCHoZCgICAgPz//z+DIBFCIoiENwPwAiAEIAUpAMgCIhFCJ4ZCgICAgIDw/z+DIBBCGYiENwP4AiAEIAUpANACIhBCB4hC/////////z+DNwOIAyAEIBBCMIZCgICAgICAwD+DIBFCEIiENwOAAyAEIAUpANgCIhFCAoZC/P///////z+DIBBCPoiENwOQAyAEIAUpAOACIhBCC4ZCgPD//////z+DIBFCNYiENwOYAyAEIAUpAOgCIhFCFIZCgIDA/////z+DIBBCLIiENwOgAyAEIAUpAPACIhBCHYZCgICAgP7//z+DIBFCI4iENwOoAyAEIAUpAPgCIhFCJoZCgICAgID4/z+DIBBCGoiENwOwAyAEIAUpAIADIhBCCIhC/////////z+DNwPAAyAEIBBCL4ZCgICAgICA4D+DIBFCEYiENwO4AyAEIAUpAIgDIhFCAYZC/v///////z+DIBBCP4iENwPIAyAEIAUpAJADIhBCCoZCgPj//////z+DIBFCNoiENwPQAyAEIAUpAJgDIhFCE4ZCgIDg/////z+DIBBCLYiENwPYAyAEIAUpAKADIhBCHIZCgICAgP///z+DIBFCJIiENwPgAyAEIAUpAKgDIhFCJYZCgICAgID8/z+DIBBCG4iENwPoAyAEIAUpALADIhBCCYg3A/gDIAQgEEIuhkKAgICAgIDwP4MgEUISiIQ3A/ADDAoLIAZBvwNNBEAMEgsgBCAFKQAAIhBC//////////8AgzcDACAEIAUpADAiEUIIiDcDOCAEIAUpADgiEkL//////////wCDNwNAIAQgBSkACCITQgiGQoD+////////AIMgEEI4iIQ3AwggBCAFKQAQIhBCEIZCgID8//////8AgyATQjCIhDcDECAEIAUpABgiE0IYhkKAgID4/////wCDIBBCKIiENwMYIAQgBSkAICIQQiCGQoCAgIDw////AIMgE0IgiIQ3AyAgBCAFKQAoIhNCKIZCgICAgIDg//8AgyAQQhiIhDcDKCAEIBFCMIZCgICAgICAwP8AgyATQhCIhDcDMCAEIAUpAEAiEEIIhkKA/v///////wCDIBJCOIiENwNIIAQgBSkAaCIRQgiINwN4IAQgBSkAcCISQv//////////AIM3A4ABIAQgBSkASCITQhCGQoCA/P//////AIMgEEIwiIQ3A1AgBCAFKQBQIhBCGIZCgICA+P////8AgyATQiiIhDcDWCAEIAUpAFgiE0IghkKAgICA8P///wCDIBBCIIiENwNgIAQgBSkAYCIQQiiGQoCAgICA4P//AIMgE0IYiIQ3A2ggBCARQjCGQoCAgICAgMD/AIMgEEIQiIQ3A3AgBCAFKQB4IhBCCIZCgP7///////8AgyASQjiIhDcDiAEgBCAFKQCAASIRQhCGQoCA/P//////AIMgEEIwiIQ3A5ABIAQgBSkAiAEiEEIYhkKAgID4/////wCDIBFCKIiENwOYASAEIAUpAJABIhFCIIZCgICAgPD///8AgyAQQiCIhDcDoAEgBCAFKQCYASIQQiiGQoCAgICA4P//AIMgEUIYiIQ3A6gBIAQgBSkAoAEiEUIIiDcDuAEgBCARQjCGQoCAgICAgMD/AIMgEEIQiIQ3A7ABIAQgBSkAqAEiEEL//////////wCDNwPAASAEIAUpALABIhFCCIZCgP7///////8AgyAQQjiIhDcDyAEgBCAFKQC4ASIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ABIAQgBSkAwAEiEUIYhkKAgID4/////wCDIBBCKIiENwPYASAEIAUpAMgBIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AEgBCAFKQDQASIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gBIAQgBSkA2AEiEEIIiDcD+AEgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ABIAQgBSkA4AEiEEL//////////wCDNwOAAiAEIAUpAOgBIhFCCIZCgP7///////8AgyAQQjiIhDcDiAIgBCAFKQDwASIQQhCGQoCA/P//////AIMgEUIwiIQ3A5ACIAQgBSkA+AEiEUIYhkKAgID4/////wCDIBBCKIiENwOYAiAEIAUpAIACIhBCIIZCgICAgPD///8AgyARQiCIhDcDoAIgBCAFKQCIAiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A6gCIAQgBSkAkAIiEEIIiDcDuAIgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A7ACIAQgBSkAmAIiEEL//////////wCDNwPAAiAEIAUpAKACIhFCCIZCgP7///////8AgyAQQjiIhDcDyAIgBCAFKQCoAiIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ACIAQgBSkAsAIiEUIYhkKAgID4/////wCDIBBCKIiENwPYAiAEIAUpALgCIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AIgBCAFKQDAAiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gCIAQgBSkAyAIiEEIIiDcD+AIgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ACIAQgBSkA0AIiEEL//////////wCDNwOAAyAEIAUpANgCIhFCCIZCgP7///////8AgyAQQjiIhDcDiAMgBCAFKQDgAiIQQhCGQoCA/P//////AIMgEUIwiIQ3A5ADIAQgBSkA6AIiEUIYhkKAgID4/////wCDIBBCKIiENwOYAyAEIAUpAPACIhBCIIZCgICAgPD///8AgyARQiCIhDcDoAMgBCAFKQD4AiIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A6gDIAQgBSkAgAMiEEIIiDcDuAMgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A7ADIAQgBSkAiAMiEEL//////////wCDNwPAAyAEIAUpAJADIhFCCIZCgP7///////8AgyAQQjiIhDcDyAMgBCAFKQCYAyIQQhCGQoCA/P//////AIMgEUIwiIQ3A9ADIAQgBSkAoAMiEUIYhkKAgID4/////wCDIBBCKIiENwPYAyAEIAUpAKgDIhBCIIZCgICAgPD///8AgyARQiCIhDcD4AMgBCAFKQCwAyIRQiiGQoCAgICA4P//AIMgEEIYiIQ3A+gDIAQgBSkAuAMiEEIIiDcD+AMgBCAQQjCGQoCAgICAgMD/AIMgEUIQiIQ3A/ADDAkLIAZBxwNNBEAMEQsgBCAFKQAAIhFC//////////8BgzcDACAEIAUpAEAiEEIBiEL//////////wGDNwNIIAQgBSkACCISQgeGQoD/////////AYMgEUI5iIQ3AwggBCAFKQAQIhFCDoZCgID///////8BgyASQjKIhDcDECAEIAUpABgiEkIVhkKAgID//////wGDIBFCK4iENwMYIAQgBSkAICIRQhyGQoCAgID/////AYMgEkIkiIQ3AyAgBCAFKQAoIhJCI4ZCgICAgID///8BgyARQh2IhDcDKCAEIAUpADAiEUIqhkKAgICAgID//wGDIBJCFoiENwMwIAQgBSkAOCISQjGGQoCAgICAgID/AYMgEUIPiIQ3AzggBCAQQjiGQoCAgICAgICAAYMgEkIIiIQ3A0AgBCAFKQCAASIRQgKIQv//////////AYM3A5ABIAQgBSkASCISQgaGQsD/////////AYMgEEI6iIQ3A1AgBCAFKQBQIhBCDYZCgMD///////8BgyASQjOIhDcDWCAEIAUpAFgiEkIUhkKAgMD//////wGDIBBCLIiENwNgIAQgBSkAYCIQQhuGQoCAgMD/////AYMgEkIliIQ3A2ggBCAFKQBoIhJCIoZCgICAgMD///8BgyAQQh6IhDcDcCAEIAUpAHAiEEIphkKAgICAgMD//wGDIBJCF4iENwN4IAQgBSkAeCISQjCGQoCAgICAgMD/AYMgEEIQiIQ3A4ABIAQgEUI3hkKAgICAgICAwAGDIBJCCYiENwOIASAEIAUpAIgBIhBCBYZC4P////////8BgyARQjuIhDcDmAEgBCAFKQCQASIRQgyGQoDg////////AYMgEEI0iIQ3A6ABIAQgBSkAmAEiEEIThkKAgOD//////wGDIBFCLYiENwOoASAEIAUpAKABIhFCGoZCgICA4P////8BgyAQQiaIhDcDsAEgBCAFKQCoASIQQiGGQoCAgIDg////AYMgEUIfiIQ3A7gBIAQgBSkAsAEiEUIohkKAgICAgOD//wGDIBBCGIiENwPAASAEIAUpALgBIhJCL4ZCgICAgICA4P8BgyARQhGIhDcDyAEgBCAFKQDAASIQQgOIQv//////////AYM3A9gBIAQgEEI2hkKAgICAgICA4AGDIBJCCoiENwPQASAEIAUpAMgBIhFCBIZC8P////////8BgyAQQjyIhDcD4AEgBCAFKQDQASIQQguGQoDw////////AYMgEUI1iIQ3A+gBIAQgBSkA2AEiEUIShkKAgPD//////wGDIBBCLoiENwPwASAEIAUpAOABIhBCGYZCgICA8P////8BgyARQieIhDcD+AEgBCAFKQDoASIRQiCGQoCAgIDw////AYMgEEIgiIQ3A4ACIAQgBSkA8AEiEEInhkKAgICAgPD//wGDIBFCGYiENwOIAiAEIAUpAPgBIhFCLoZCgICAgICA8P8BgyAQQhKIhDcDkAIgBCAFKQCAAiIQQgSIQv//////////AYM3A6ACIAQgEEI1hkKAgICAgICA8AGDIBFCC4iENwOYAiAEIAUpAIgCIhFCA4ZC+P////////8BgyAQQj2IhDcDqAIgBCAFKQCQAiIQQgqGQoD4////////AYMgEUI2iIQ3A7ACIAQgBSkAmAIiEUIRhkKAgPj//////wGDIBBCL4iENwO4AiAEIAUpAKACIhBCGIZCgICA+P////8BgyARQiiIhDcDwAIgBCAFKQCoAiIRQh+GQoCAgID4////AYMgEEIhiIQ3A8gCIAQgBSkAsAIiEEImhkKAgICAgPj//wGDIBFCGoiENwPQAiAEIAUpALgCIhFCLYZCgICAgICA+P8BgyAQQhOIhDcD2AIgBCAFKQDAAiIQQgWIQv//////////AYM3A+gCIAQgEEI0hkKAgICAgICA+AGDIBFCDIiENwPgAiAEIAUpAMgCIhFCAoZC/P////////8BgyAQQj6IhDcD8AIgBCAFKQDQAiIQQgmGQoD8////////AYMgEUI3iIQ3A/gCIAQgBSkA2AIiEUIQhkKAgPz//////wGDIBBCMIiENwOAAyAEIAUpAOACIhBCF4ZCgICA/P////8BgyARQimIhDcDiAMgBCAFKQDoAiIRQh6GQoCAgID8////AYMgEEIiiIQ3A5ADIAQgBSkA8AIiEEIlhkKAgICAgPz//wGDIBFCG4iENwOYAyAEIAUpAPgCIhFCLIZCgICAgICA/P8BgyAQQhSIhDcDoAMgBCAFKQCAAyIQQgaIQv//////////AYM3A7ADIAQgEEIzhkKAgICAgICA/AGDIBFCDYiENwOoAyAEIAUpAIgDIhFCAYZC/v////////8BgyAQQj+IhDcDuAMgBCAFKQCQAyIQQgiGQoD+////////AYMgEUI4iIQ3A8ADIAQgBSkAmAMiEUIPhkKAgP7//////wGDIBBCMYiENwPIAyAEIAUpAKADIhBCFoZCgICA/v////8BgyARQiqIhDcD0AMgBCAFKQCoAyIRQh2GQoCAgID+////AYMgEEIjiIQ3A9gDIAQgBSkAsAMiEEIkhkKAgICAgP7//wGDIBFCHIiENwPgAyAEIAUpALgDIhFCK4ZCgICAgICA/v8BgyAQQhWIhDcD6AMgBCAFKQDAAyIQQgeINwP4AyAEIBBCMoZCgICAgICAgP4BgyARQg6IhDcD8AMMCAsgBkHPA00EQAwQCyAEIAUpAAAiEEL//////////wODNwMAIAQgBSkACCIRQgaGQsD/////////A4MgEEI6iIQ3AwggBCAFKQAQIhBCDIZCgOD///////8DgyARQjSIhDcDECAEIAUpABgiEUIShkKAgPD//////wODIBBCLoiENwMYIAQgBSkAICIQQhiGQoCAgPj/////A4MgEUIoiIQ3AyAgBCAFKQAoIhFCHoZCgICAgPz///8DgyAQQiKIhDcDKCAEIAUpADAiEEIkhkKAgICAgP7//wODIBFCHIiENwMwIAQgBSkAOCIRQiqGQoCAgICAgP//A4MgEEIWiIQ3AzggBCAFKQBAIhJCMIZCgICAgICAwP8DgyARQhCIhDcDQCAEIAUpAEgiEEIEiEL//////////wODNwNQIAQgEEI2hkKAgICAgICA4AODIBJCCoiENwNIIAQgBSkAUCIRQgKGQvz/////////A4MgEEI+iIQ3A1ggBCAFKQBYIhBCCIZCgP7///////8DgyARQjiIhDcDYCAEIAUpAGAiEUIOhkKAgP///////wODIBBCMoiENwNoIAQgBSkAaCIQQhSGQoCAwP//////A4MgEUIsiIQ3A3AgBCAFKQBwIhFCGoZCgICA4P////8DgyAQQiaIhDcDeCAEIAUpAHgiEEIghkKAgICA8P///wODIBFCIIiENwOAASAEIAUpAIABIhFCJoZCgICAgID4//8DgyAQQhqIhDcDiAEgBCAFKQCIASIQQiyGQoCAgICAgPz/A4MgEUIUiIQ3A5ABIAQgBSkAkAEiEUIyhkKAgICAgICA/gODIBBCDoiENwOYASAEIAUpAJgBIhBCAohC//////////8DgzcDqAEgBCAQQjiGQoCAgICAgICAA4MgEUIIiIQ3A6ABIAQgBSkAoAEiEUIEhkLw/////////wODIBBCPIiENwOwASAEIAUpAKgBIhBCCoZCgPj///////8DgyARQjaIhDcDuAEgBCAFKQCwASIRQhCGQoCA/P//////A4MgEEIwiIQ3A8ABIAQgBSkAuAEiEEIWhkKAgID+/////wODIBFCKoiENwPIASAEIAUpAMABIhFCHIZCgICAgP////8DgyAQQiSIhDcD0AEgBCAFKQDIASIQQiKGQoCAgIDA////A4MgEUIeiIQ3A9gBIAQgBSkA0AEiEUIohkKAgICAgOD//wODIBBCGIiENwPgASAEIAUpANgBIhBCLoZCgICAgICA8P8DgyARQhKIhDcD6AEgBCAFKQDgASIRQgaINwP4ASAEIBFCNIZCgICAgICAgPgDgyAQQgyIhDcD8AEgBCAFKQDoASIQQv//////////A4M3A4ACIAQgBSkA8AEiEUIGhkLA/////////wODIBBCOoiENwOIAiAEIAUpAPgBIhBCDIZCgOD///////8DgyARQjSIhDcDkAIgBCAFKQCAAiIRQhKGQoCA8P//////A4MgEEIuiIQ3A5gCIAQgBSkAiAIiEEIYhkKAgID4/////wODIBFCKIiENwOgAiAEIAUpAJACIhFCHoZCgICAgPz///8DgyAQQiKIhDcDqAIgBCAFKQCYAiIQQiSGQoCAgICA/v//A4MgEUIciIQ3A7ACIAQgBSkAoAIiEUIqhkKAgICAgID//wODIBBCFoiENwO4AiAEIAUpAKgCIhJCMIZCgICAgICAwP8DgyARQhCIhDcDwAIgBCAFKQCwAiIQQgSIQv//////////A4M3A9ACIAQgEEI2hkKAgICAgICA4AODIBJCCoiENwPIAiAEIAUpALgCIhFCAoZC/P////////8DgyAQQj6IhDcD2AIgBCAFKQDAAiIQQgiGQoD+////////A4MgEUI4iIQ3A+ACIAQgBSkAyAIiEUIOhkKAgP///////wODIBBCMoiENwPoAiAEIAUpANACIhBCFIZCgIDA//////8DgyARQiyIhDcD8AIgBCAFKQDYAiIRQhqGQoCAgOD/////A4MgEEImiIQ3A/gCIAQgBSkA4AIiEEIghkKAgICA8P///wODIBFCIIiENwOAAyAEIAUpAOgCIhFCJoZCgICAgID4//8DgyAQQhqIhDcDiAMgBCAFKQDwAiIQQiyGQoCAgICAgPz/A4MgEUIUiIQ3A5ADIAQgBSkA+AIiEUIyhkKAgICAgICA/gODIBBCDoiENwOYAyAEIAUpAIADIhBCAohC//////////8DgzcDqAMgBCAQQjiGQoCAgICAgICAA4MgEUIIiIQ3A6ADIAQgBSkAiAMiEUIEhkLw/////////wODIBBCPIiENwOwAyAEIAUpAJADIhBCCoZCgPj///////8DgyARQjaIhDcDuAMgBCAFKQCYAyIRQhCGQoCA/P//////A4MgEEIwiIQ3A8ADIAQgBSkAoAMiEEIWhkKAgID+/////wODIBFCKoiENwPIAyAEIAUpAKgDIhFCHIZCgICAgP////8DgyAQQiSIhDcD0AMgBCAFKQCwAyIQQiKGQoCAgIDA////A4MgEUIeiIQ3A9gDIAQgBSkAuAMiEUIohkKAgICAgOD//wODIBBCGIiENwPgAyAEIAUpAMADIhBCLoZCgICAgICA8P8DgyARQhKIhDcD6AMgBCAFKQDIAyIRQgaINwP4AyAEIBFCNIZCgICAgICAgPgDgyAQQgyIhDcD8AMMBwsgBkHXA00EQAwPCyAEIAUpAAAiEEL//////////weDNwMAIAQgBSkACCIRQgWGQuD/////////B4MgEEI7iIQ3AwggBCAFKQAQIhBCCoZCgPj///////8HgyARQjaIhDcDECAEIAUpABgiEUIPhkKAgP7//////weDIBBCMYiENwMYIAQgBSkAICIQQhSGQoCAwP//////B4MgEUIsiIQ3AyAgBCAFKQAoIhFCGYZCgICA8P////8HgyAQQieIhDcDKCAEIAUpADAiEEIehkKAgICA/P///weDIBFCIoiENwMwIAQgBSkAOCIRQiOGQoCAgICA////B4MgEEIdiIQ3AzggBCAFKQBAIhBCKIZCgICAgIDg//8HgyARQhiIhDcDQCAEIAUpAEgiEUIthkKAgICAgID4/weDIBBCE4iENwNIIAQgBSkAWCIQQgSIQv//////////B4M3A2AgBCAFKQBQIhJCMoZCgICAgICAgP4HgyARQg6IhDcDUCAEIBBCN4ZCgICAgICAgMAHgyASQgmIhDcDWCAEIAUpAGAiEUIBhkL+/////////weDIBBCP4iENwNoIAQgBSkAaCIQQgaGQsD/////////B4MgEUI6iIQ3A3AgBCAFKQBwIhFCC4ZCgPD///////8HgyAQQjWIhDcDeCAEIAUpAHgiEEIQhkKAgPz//////weDIBFCMIiENwOAASAEIAUpAIABIhFCFYZCgICA//////8HgyAQQiuIhDcDiAEgBCAFKQCIASIQQhqGQoCAgOD/////B4MgEUImiIQ3A5ABIAQgBSkAkAEiEUIfhkKAgICA+P///weDIBBCIYiENwOYASAEIAUpAJgBIhBCJIZCgICAgID+//8HgyARQhyIhDcDoAEgBCAFKQCgASIRQimGQoCAgICAwP//B4MgEEIXiIQ3A6gBIAQgBSkAqAEiEEIuhkKAgICAgIDw/weDIBFCEoiENwOwASAEIAUpALABIhFCM4ZCgICAgICAgPwHgyAQQg2IhDcDuAEgBCAFKQC4ASIQQgOIQv//////////B4M3A8gBIAQgEEI4hkKAgICAgICAgAeDIBFCCIiENwPAASAEIAUpAMABIhFCAoZC/P////////8HgyAQQj6IhDcD0AEgBCAFKQDIASIQQgeGQoD/////////B4MgEUI5iIQ3A9gBIAQgBSkA0AEiEUIMhkKA4P///////weDIBBCNIiENwPgASAEIAUpANgBIhBCEYZCgID4//////8HgyARQi+IhDcD6AEgBCAFKQDgASIRQhaGQoCAgP7/////B4MgEEIqiIQ3A/ABIAQgBSkA6AEiEEIbhkKAgIDA/////weDIBFCJYiENwP4ASAEIAUpAPABIhFCIIZCgICAgPD///8HgyAQQiCIhDcDgAIgBCAFKQD4ASIQQiWGQoCAgICA/P//B4MgEUIbiIQ3A4gCIAQgBSkAgAIiEUIqhkKAgICAgID//weDIBBCFoiENwOQAiAEIAUpAIgCIhBCL4ZCgICAgICA4P8HgyARQhGIhDcDmAIgBCAFKQCQAiIRQjSGQoCAgICAgID4B4MgEEIMiIQ3A6ACIAQgBSkAmAIiEEICiEL//////////weDNwOwAiAEIBBCOYZCgICAgICAgIAGgyARQgeIhDcDqAIgBCAFKQCgAiIRQgOGQvj/////////B4MgEEI9iIQ3A7gCIAQgBSkAqAIiEEIIhkKA/v///////weDIBFCOIiENwPAAiAEIAUpALACIhFCDYZCgMD///////8HgyAQQjOIhDcDyAIgBCAFKQC4AiIQQhKGQoCA8P//////B4MgEUIuiIQ3A9ACIAQgBSkAwAIiEUIXhkKAgID8/////weDIBBCKYiENwPYAiAEIAUpAMgCIhBCHIZCgICAgP////8HgyARQiSIhDcD4AIgBCAFKQDQAiIRQiGGQoCAgIDg////B4MgEEIfiIQ3A+gCIAQgBSkA2AIiEEImhkKAgICAgPj//weDIBFCGoiENwPwAiAEIAUpAOACIhFCK4ZCgICAgICA/v8HgyAQQhWIhDcD+AIgBCAFKQDoAiIQQjCGQoCAgICAgMD/B4MgEUIQiIQ3A4ADIAQgBSkA8AIiEUI1hkKAgICAgICA8AeDIBBCC4iENwOIAyAEIAUpAPgCIhBCAYhC//////////8HgzcDmAMgBCAQQjqGQoCAgICAgICABIMgEUIGiIQ3A5ADIAQgBSkAgAMiEUIEhkLw/////////weDIBBCPIiENwOgAyAEIAUpAIgDIhBCCYZCgPz///////8HgyARQjeIhDcDqAMgBCAFKQCQAyIRQg6GQoCA////////B4MgEEIyiIQ3A7ADIAQgBSkAmAMiEEIThkKAgOD//////weDIBFCLYiENwO4AyAEIAUpAKADIhFCGIZCgICA+P////8HgyAQQiiIhDcDwAMgBCAFKQCoAyIQQh2GQoCAgID+////B4MgEUIjiIQ3A8gDIAQgBSkAsAMiEUIihkKAgICAwP///weDIBBCHoiENwPQAyAEIAUpALgDIhBCJ4ZCgICAgIDw//8HgyARQhmIhDcD2AMgBCAFKQDAAyIRQiyGQoCAgICAgPz/B4MgEEIUiIQ3A+ADIAQgBSkAyAMiEEIxhkKAgICAgICA/weDIBFCD4iENwPoAyAEIAUpANADIhFCBYg3A/gDIAQgEUI2hkKAgICAgICA4AeDIBBCCoiENwPwAwwGCyAGQd8DTQRADA4LIAQgBSkAACIQQv//////////D4M3AwAgBCAFKQAIIhFCBIZC8P////////8PgyAQQjyIhDcDCCAEIAUpABAiEEIIhkKA/v///////w+DIBFCOIiENwMQIAQgBSkAGCIRQgyGQoDg////////D4MgEEI0iIQ3AxggBCAFKQAgIhBCEIZCgID8//////8PgyARQjCIhDcDICAEIAUpACgiEUIUhkKAgMD//////w+DIBBCLIiENwMoIAQgBSkAMCIQQhiGQoCAgPj/////D4MgEUIoiIQ3AzAgBCAFKQA4IhFCHIZCgICAgP////8PgyAQQiSIhDcDOCAEIAUpAEAiEEIghkKAgICA8P///w+DIBFCIIiENwNAIAQgBSkASCIRQiSGQoCAgICA/v//D4MgEEIciIQ3A0ggBCAFKQBwIhBCBIg3A3ggBCAFKQB4IhJC//////////8PgzcDgAEgBCAFKQBQIhNCKIZCgICAgIDg//8PgyARQhiIhDcDUCAEIAUpAFgiEUIshkKAgICAgID8/w+DIBNCFIiENwNYIAQgBSkAYCITQjCGQoCAgICAgMD/D4MgEUIQiIQ3A2AgBCAFKQBoIhFCNIZCgICAgICAgPgPgyATQgyIhDcDaCAEIBBCOIZCgICAgICAgIAPgyARQgiIhDcDcCAEIAUpAIABIhBCBIZC8P////////8PgyASQjyIhDcDiAEgBCAFKQCIASIRQgiGQoD+////////D4MgEEI4iIQ3A5ABIAQgBSkAkAEiEEIMhkKA4P///////w+DIBFCNIiENwOYASAEIAUpAJgBIhFCEIZCgID8//////8PgyAQQjCIhDcDoAEgBCAFKQCgASIQQhSGQoCAwP//////D4MgEUIsiIQ3A6gBIAQgBSkAqAEiEUIYhkKAgID4/////w+DIBBCKIiENwOwASAEIAUpALABIhBCHIZCgICAgP////8PgyARQiSIhDcDuAEgBCAFKQC4ASIRQiCGQoCAgIDw////D4MgEEIgiIQ3A8ABIAQgBSkAwAEiEEIkhkKAgICAgP7//w+DIBFCHIiENwPIASAEIAUpAMgBIhFCKIZCgICAgIDg//8PgyAQQhiIhDcD0AEgBCAFKQDQASIQQiyGQoCAgICAgPz/D4MgEUIUiIQ3A9gBIAQgBSkA2AEiEUIwhkKAgICAgIDA/w+DIBBCEIiENwPgASAEIAUpAOABIhBCNIZCgICAgICAgPgPgyARQgyIhDcD6AEgBCAFKQDoASIRQgSINwP4ASAEIBFCOIZCgICAgICAgIAPgyAQQgiIhDcD8AEgBCAFKQDwASIQQv//////////D4M3A4ACIAQgBSkA+AEiEUIEhkLw/////////w+DIBBCPIiENwOIAiAEIAUpAIACIhBCCIZCgP7///////8PgyARQjiIhDcDkAIgBCAFKQCIAiIRQgyGQoDg////////D4MgEEI0iIQ3A5gCIAQgBSkAkAIiEEIQhkKAgPz//////w+DIBFCMIiENwOgAiAEIAUpAJgCIhFCFIZCgIDA//////8PgyAQQiyIhDcDqAIgBCAFKQCgAiIQQhiGQoCAgPj/////D4MgEUIoiIQ3A7ACIAQgBSkAqAIiEUIchkKAgICA/////w+DIBBCJIiENwO4AiAEIAUpALACIhBCIIZCgICAgPD///8PgyARQiCIhDcDwAIgBCAFKQC4AiIRQiSGQoCAgICA/v//D4MgEEIciIQ3A8gCIAQgBSkAwAIiEEIohkKAgICAgOD//w+DIBFCGIiENwPQAiAEIAUpAMgCIhFCLIZCgICAgICA/P8PgyAQQhSIhDcD2AIgBCAFKQDQAiIQQjCGQoCAgICAgMD/D4MgEUIQiIQ3A+ACIAQgBSkA2AIiEUI0hkKAgICAgICA+A+DIBBCDIiENwPoAiAEIAUpAOACIhBCBIg3A/gCIAQgEEI4hkKAgICAgICAgA+DIBFCCIiENwPwAiAEIAUpAOgCIhBC//////////8PgzcDgAMgBCAFKQDwAiIRQgSGQvD/////////D4MgEEI8iIQ3A4gDIAQgBSkA+AIiEEIIhkKA/v///////w+DIBFCOIiENwOQAyAEIAUpAIADIhFCDIZCgOD///////8PgyAQQjSIhDcDmAMgBCAFKQCIAyIQQhCGQoCA/P//////D4MgEUIwiIQ3A6ADIAQgBSkAkAMiEUIUhkKAgMD//////w+DIBBCLIiENwOoAyAEIAUpAJgDIhBCGIZCgICA+P////8PgyARQiiIhDcDsAMgBCAFKQCgAyIRQhyGQoCAgID/////D4MgEEIkiIQ3A7gDIAQgBSkAqAMiEEIghkKAgICA8P///w+DIBFCIIiENwPAAyAEIAUpALADIhFCJIZCgICAgID+//8PgyAQQhyIhDcDyAMgBCAFKQC4AyIQQiiGQoCAgICA4P//D4MgEUIYiIQ3A9ADIAQgBSkAwAMiEUIshkKAgICAgID8/w+DIBBCFIiENwPYAyAEIAUpAMgDIhBCMIZCgICAgICAwP8PgyARQhCIhDcD4AMgBCAFKQDQAyIRQjSGQoCAgICAgID4D4MgEEIMiIQ3A+gDIAQgBSkA2AMiEEIEiDcD+AMgBCAQQjiGQoCAgICAgICAD4MgEUIIiIQ3A/ADDAULIAZB5wNNBEAMDQsgBCAFKQAAIhBC//////////8fgzcDACAEIAUpAAgiEUIDhkL4/////////x+DIBBCPYiENwMIIAQgBSkAECIQQgaGQsD/////////H4MgEUI6iIQ3AxAgBCAFKQAYIhFCCYZCgPz///////8fgyAQQjeIhDcDGCAEIAUpACAiEEIMhkKA4P///////x+DIBFCNIiENwMgIAQgBSkAKCIRQg+GQoCA/v//////H4MgEEIxiIQ3AyggBCAFKQAwIhBCEoZCgIDw//////8fgyARQi6IhDcDMCAEIAUpADgiEUIVhkKAgID//////x+DIBBCK4iENwM4IAQgBSkAQCIQQhiGQoCAgPj/////H4MgEUIoiIQ3A0AgBCAFKQBIIhFCG4ZCgICAwP////8fgyAQQiWIhDcDSCAEIAUpAFAiEEIehkKAgICA/P///x+DIBFCIoiENwNQIAQgBSkAWCIRQiGGQoCAgIDg////H4MgEEIfiIQ3A1ggBCAFKQBgIhBCJIZCgICAgID+//8fgyARQhyIhDcDYCAEIAUpAGgiEUInhkKAgICAgPD//x+DIBBCGYiENwNoIAQgBSkAcCIQQiqGQoCAgICAgP//H4MgEUIWiIQ3A3AgBCAFKQB4IhFCLYZCgICAgICA+P8fgyAQQhOIhDcDeCAEIAUpAIABIhBCMIZCgICAgICAwP8fgyARQhCIhDcDgAEgBCAFKQCIASIRQjOGQoCAgICAgID8H4MgEEINiIQ3A4gBIAQgBSkAkAEiEEI2hkKAgICAgICA4B+DIBFCCoiENwOQASAEIAUpAJgBIhFCOYZCgICAgICAgIAegyAQQgeIhDcDmAEgBCAFKQCgASIQQgGIQv//////////H4M3A6gBIAQgEEI8hkKAgICAgICAgBCDIBFCBIiENwOgASAEIAUpAKgBIhFCAoZC/P////////8fgyAQQj6IhDcDsAEgBCAFKQCwASIQQgWGQuD/////////H4MgEUI7iIQ3A7gBIAQgBSkAuAEiEUIIhkKA/v///////x+DIBBCOIiENwPAASAEIAUpAMABIhBCC4ZCgPD///////8fgyARQjWIhDcDyAEgBCAFKQDIASIRQg6GQoCA////////H4MgEEIyiIQ3A9ABIAQgBSkA0AEiEEIRhkKAgPj//////x+DIBFCL4iENwPYASAEIAUpANgBIhFCFIZCgIDA//////8fgyAQQiyIhDcD4AEgBCAFKQDgASIQQheGQoCAgPz/////H4MgEUIpiIQ3A+gBIAQgBSkA6AEiEUIahkKAgIDg/////x+DIBBCJoiENwPwASAEIAUpAPABIhBCHYZCgICAgP7///8fgyARQiOIhDcD+AEgBCAFKQD4ASIRQiCGQoCAgIDw////H4MgEEIgiIQ3A4ACIAQgBSkAgAIiEEIjhkKAgICAgP///x+DIBFCHYiENwOIAiAEIAUpAIgCIhFCJoZCgICAgID4//8fgyAQQhqIhDcDkAIgBCAFKQCQAiIQQimGQoCAgICAwP//H4MgEUIXiIQ3A5gCIAQgBSkAmAIiEUIshkKAgICAgID8/x+DIBBCFIiENwOgAiAEIAUpAKACIhBCL4ZCgICAgICA4P8fgyARQhGIhDcDqAIgBCAFKQCoAiIRQjKGQoCAgICAgID+H4MgEEIOiIQ3A7ACIAQgBSkAsAIiEEI1hkKAgICAgICA8B+DIBFCC4iENwO4AiAEIAUpALgCIhFCOIZCgICAgICAgIAfgyAQQgiIhDcDwAIgBCAFKQDAAiIQQgKIQv//////////H4M3A9ACIAQgEEI7hkKAgICAgICAgBiDIBFCBYiENwPIAiAEIAUpAMgCIhFCAYZC/v////////8fgyAQQj+IhDcD2AIgBCAFKQDQAiIQQgSGQvD/////////H4MgEUI8iIQ3A+ACIAQgBSkA2AIiEUIHhkKA/////////x+DIBBCOYiENwPoAiAEIAUpAOACIhBCCoZCgPj///////8fgyARQjaIhDcD8AIgBCAFKQDoAiIRQg2GQoDA////////H4MgEEIziIQ3A/gCIAQgBSkA8AIiEEIQhkKAgPz//////x+DIBFCMIiENwOAAyAEIAUpAPgCIhFCE4ZCgIDg//////8fgyAQQi2IhDcDiAMgBCAFKQCAAyIQQhaGQoCAgP7/////H4MgEUIqiIQ3A5ADIAQgBSkAiAMiEUIZhkKAgIDw/////x+DIBBCJ4iENwOYAyAEIAUpAJADIhBCHIZCgICAgP////8fgyARQiSIhDcDoAMgBCAFKQCYAyIRQh+GQoCAgID4////H4MgEEIhiIQ3A6gDIAQgBSkAoAMiEEIihkKAgICAwP///x+DIBFCHoiENwOwAyAEIAUpAKgDIhFCJYZCgICAgID8//8fgyAQQhuIhDcDuAMgBCAFKQCwAyIQQiiGQoCAgICA4P//H4MgEUIYiIQ3A8ADIAQgBSkAuAMiEUIrhkKAgICAgID+/x+DIBBCFYiENwPIAyAEIAUpAMADIhBCLoZCgICAgICA8P8fgyARQhKIhDcD0AMgBCAFKQDIAyIRQjGGQoCAgICAgID/H4MgEEIPiIQ3A9gDIAQgBSkA0AMiEEI0hkKAgICAgICA+B+DIBFCDIiENwPgAyAEIAUpANgDIhFCN4ZCgICAgICAgMAfgyAQQgmIhDcD6AMgBCAFKQDgAyIQQgOINwP4AyAEIBBCOoZCgICAgICAgIAcgyARQgaIhDcD8AMMBAsgBkHvA00EQAwMCyAEIAUpAAAiEEL//////////z+DNwMAIAQgBSkACCIRQgKGQvz/////////P4MgEEI+iIQ3AwggBCAFKQAQIhBCBIZC8P////////8/gyARQjyIhDcDECAEIAUpABgiEUIGhkLA/////////z+DIBBCOoiENwMYIAQgBSkAICIQQgiGQoD+////////P4MgEUI4iIQ3AyAgBCAFKQAoIhFCCoZCgPj///////8/gyAQQjaIhDcDKCAEIAUpADAiEEIMhkKA4P///////z+DIBFCNIiENwMwIAQgBSkAOCIRQg6GQoCA////////P4MgEEIyiIQ3AzggBCAFKQBAIhBCEIZCgID8//////8/gyARQjCIhDcDQCAEIAUpAEgiEUIShkKAgPD//////z+DIBBCLoiENwNIIAQgBSkAUCIQQhSGQoCAwP//////P4MgEUIsiIQ3A1AgBCAFKQBYIhFCFoZCgICA/v////8/gyAQQiqIhDcDWCAEIAUpAGAiEEIYhkKAgID4/////z+DIBFCKIiENwNgIAQgBSkAaCIRQhqGQoCAgOD/////P4MgEEImiIQ3A2ggBCAFKQBwIhBCHIZCgICAgP////8/gyARQiSIhDcDcCAEIAUpAHgiEUIehkKAgICA/P///z+DIBBCIoiENwN4IAQgBSkAgAEiEEIghkKAgICA8P///z+DIBFCIIiENwOAASAEIAUpAIgBIhFCIoZCgICAgMD///8/gyAQQh6IhDcDiAEgBCAFKQCQASIQQiSGQoCAgICA/v//P4MgEUIciIQ3A5ABIAQgBSkAmAEiEUImhkKAgICAgPj//z+DIBBCGoiENwOYASAEIAUpAKABIhBCKIZCgICAgIDg//8/gyARQhiIhDcDoAEgBCAFKQCoASIRQiqGQoCAgICAgP//P4MgEEIWiIQ3A6gBIAQgBSkAsAEiEEIshkKAgICAgID8/z+DIBFCFIiENwOwASAEIAUpALgBIhFCLoZCgICAgICA8P8/gyAQQhKIhDcDuAEgBCAFKQDAASIQQjCGQoCAgICAgMD/P4MgEUIQiIQ3A8ABIAQgBSkAyAEiEUIyhkKAgICAgICA/j+DIBBCDoiENwPIASAEIAUpANABIhBCNIZCgICAgICAgPg/gyARQgyIhDcD0AEgBCAFKQDYASIRQjaGQoCAgICAgIDgP4MgEEIKiIQ3A9gBIAQgBSkA4AEiEEI4hkKAgICAgICAgD+DIBFCCIiENwPgASAEIAUpAOgBIhFCOoZCgICAgICAgIA8gyAQQgaIhDcD6AEgBCAFKQDwASIQQgKINwP4ASAEIBBCPIZCgICAgICAgIAwgyARQgSIhDcD8AEgBCAFKQD4ASIQQv//////////P4M3A4ACIAQgBSkAgAIiEUIChkL8/////////z+DIBBCPoiENwOIAiAEIAUpAIgCIhBCBIZC8P////////8/gyARQjyIhDcDkAIgBCAFKQCQAiIRQgaGQsD/////////P4MgEEI6iIQ3A5gCIAQgBSkAmAIiEEIIhkKA/v///////z+DIBFCOIiENwOgAiAEIAUpAKACIhFCCoZCgPj///////8/gyAQQjaIhDcDqAIgBCAFKQCoAiIQQgyGQoDg////////P4MgEUI0iIQ3A7ACIAQgBSkAsAIiEUIOhkKAgP///////z+DIBBCMoiENwO4AiAEIAUpALgCIhBCEIZCgID8//////8/gyARQjCIhDcDwAIgBCAFKQDAAiIRQhKGQoCA8P//////P4MgEEIuiIQ3A8gCIAQgBSkAyAIiEEIUhkKAgMD//////z+DIBFCLIiENwPQAiAEIAUpANACIhFCFoZCgICA/v////8/gyAQQiqIhDcD2AIgBCAFKQDYAiIQQhiGQoCAgPj/////P4MgEUIoiIQ3A+ACIAQgBSkA4AIiEUIahkKAgIDg/////z+DIBBCJoiENwPoAiAEIAUpAOgCIhBCHIZCgICAgP////8/gyARQiSIhDcD8AIgBCAFKQDwAiIRQh6GQoCAgID8////P4MgEEIiiIQ3A/gCIAQgBSkA+AIiEEIghkKAgICA8P///z+DIBFCIIiENwOAAyAEIAUpAIADIhFCIoZCgICAgMD///8/gyAQQh6IhDcDiAMgBCAFKQCIAyIQQiSGQoCAgICA/v//P4MgEUIciIQ3A5ADIAQgBSkAkAMiEUImhkKAgICAgPj//z+DIBBCGoiENwOYAyAEIAUpAJgDIhBCKIZCgICAgIDg//8/gyARQhiIhDcDoAMgBCAFKQCgAyIRQiqGQoCAgICAgP//P4MgEEIWiIQ3A6gDIAQgBSkAqAMiEEIshkKAgICAgID8/z+DIBFCFIiENwOwAyAEIAUpALADIhFCLoZCgICAgICA8P8/gyAQQhKIhDcDuAMgBCAFKQC4AyIQQjCGQoCAgICAgMD/P4MgEUIQiIQ3A8ADIAQgBSkAwAMiEUIyhkKAgICAgICA/j+DIBBCDoiENwPIAyAEIAUpAMgDIhBCNIZCgICAgICAgPg/gyARQgyIhDcD0AMgBCAFKQDQAyIRQjaGQoCAgICAgIDgP4MgEEIKiIQ3A9gDIAQgBSkA2AMiEEI4hkKAgICAgICAgD+DIBFCCIiENwPgAyAEIAUpAOADIhFCOoZCgICAgICAgIA8gyAQQgaIhDcD6AMgBCAFKQDoAyIQQgKINwP4AyAEIBBCPIZCgICAgICAgIAwgyARQgSIhDcD8AMMAwsgBkH3A00EQAwLCyAEIAUpAAAiEEL///////////8AgzcDACAEIAUpAAgiEUIBhkL+//////////8AgyAQQj+IhDcDCCAEIAUpABAiEEIChkL8//////////8AgyARQj6IhDcDECAEIAUpABgiEUIDhkL4//////////8AgyAQQj2IhDcDGCAEIAUpACAiEEIEhkLw//////////8AgyARQjyIhDcDICAEIAUpACgiEUIFhkLg//////////8AgyAQQjuIhDcDKCAEIAUpADAiEEIGhkLA//////////8AgyARQjqIhDcDMCAEIAUpADgiEUIHhkKA//////////8AgyAQQjmIhDcDOCAEIAUpAEAiEEIIhkKA/v////////8AgyARQjiIhDcDQCAEIAUpAEgiEUIJhkKA/P////////8AgyAQQjeIhDcDSCAEIAUpAFAiEEIKhkKA+P////////8AgyARQjaIhDcDUCAEIAUpAFgiEUILhkKA8P////////8AgyAQQjWIhDcDWCAEIAUpAGAiEEIMhkKA4P////////8AgyARQjSIhDcDYCAEIAUpAGgiEUINhkKAwP////////8AgyAQQjOIhDcDaCAEIAUpAHAiEEIOhkKAgP////////8AgyARQjKIhDcDcCAEIAUpAHgiEUIPhkKAgP7///////8AgyAQQjGIhDcDeCAEIAUpAIABIhBCEIZCgID8////////AIMgEUIwiIQ3A4ABIAQgBSkAiAEiEUIRhkKAgPj///////8AgyAQQi+IhDcDiAEgBCAFKQCQASIQQhKGQoCA8P///////wCDIBFCLoiENwOQASAEIAUpAJgBIhFCE4ZCgIDg////////AIMgEEItiIQ3A5gBIAQgBSkAoAEiEEIUhkKAgMD///////8AgyARQiyIhDcDoAEgBCAFKQCoASIRQhWGQoCAgP///////wCDIBBCK4iENwOoASAEIAUpALABIhBCFoZCgICA/v//////AIMgEUIqiIQ3A7ABIAQgBSkAuAEiEUIXhkKAgID8//////8AgyAQQimIhDcDuAEgBCAFKQDAASIQQhiGQoCAgPj//////wCDIBFCKIiENwPAASAEIAUpAMgBIhFCGYZCgICA8P//////AIMgEEIniIQ3A8gBIAQgBSkA0AEiEEIahkKAgIDg//////8AgyARQiaIhDcD0AEgBCAFKQDYASIRQhuGQoCAgMD//////wCDIBBCJYiENwPYASAEIAUpAOABIhBCHIZCgICAgP//////AIMgEUIkiIQ3A+ABIAQgBSkA6AEiEUIdhkKAgICA/v////8AgyAQQiOIhDcD6AEgBCAFKQDwASIQQh6GQoCAgID8/////wCDIBFCIoiENwPwASAEIAUpAPgBIhFCH4ZCgICAgPj/////AIMgEEIhiIQ3A/gBIAQgBSkAgAIiEEIghkKAgICA8P////8AgyARQiCIhDcDgAIgBCAFKQCIAiIRQiGGQoCAgIDg/////wCDIBBCH4iENwOIAiAEIAUpAJACIhBCIoZCgICAgMD/////AIMgEUIeiIQ3A5ACIAQgBSkAmAIiEUIjhkKAgICAgP////8AgyAQQh2IhDcDmAIgBCAFKQCgAiIQQiSGQoCAgICA/v///wCDIBFCHIiENwOgAiAEIAUpAKgCIhFCJYZCgICAgID8////AIMgEEIbiIQ3A6gCIAQgBSkAsAIiEEImhkKAgICAgPj///8AgyARQhqIhDcDsAIgBCAFKQC4AiIRQieGQoCAgICA8P///wCDIBBCGYiENwO4AiAEIAUpAMACIhBCKIZCgICAgIDg////AIMgEUIYiIQ3A8ACIAQgBSkAyAIiEUIphkKAgICAgMD///8AgyAQQheIhDcDyAIgBCAFKQDQAiIQQiqGQoCAgICAgP///wCDIBFCFoiENwPQAiAEIAUpANgCIhFCK4ZCgICAgICA/v//AIMgEEIViIQ3A9gCIAQgBSkA4AIiEEIshkKAgICAgID8//8AgyARQhSIhDcD4AIgBCAFKQDoAiIRQi2GQoCAgICAgPj//wCDIBBCE4iENwPoAiAEIAUpAPACIhBCLoZCgICAgICA8P//AIMgEUISiIQ3A/ACIAQgBSkA+AIiEUIvhkKAgICAgIDg//8AgyAQQhGIhDcD+AIgBCAFKQCAAyIQQjCGQoCAgICAgMD//wCDIBFCEIiENwOAAyAEIAUpAIgDIhFCMYZCgICAgICAgP//AIMgEEIPiIQ3A4gDIAQgBSkAkAMiEEIyhkKAgICAgICA/v8AgyARQg6IhDcDkAMgBCAFKQCYAyIRQjOGQoCAgICAgID8/wCDIBBCDYiENwOYAyAEIAUpAKADIhBCNIZCgICAgICAgPj/AIMgEUIMiIQ3A6ADIAQgBSkAqAMiEUI1hkKAgICAgICA8P8AgyAQQguIhDcDqAMgBCAFKQCwAyIQQjaGQoCAgICAgIDg/wCDIBFCCoiENwOwAyAEIAUpALgDIhFCN4ZCgICAgICAgMD/AIMgEEIJiIQ3A7gDIAQgBSkAwAMiEEI4hkKAgICAgICAgP8AgyARQgiIhDcDwAMgBCAFKQDIAyIRQjmGQoCAgICAgICA/gCDIBBCB4iENwPIAyAEIAUpANADIhBCOoZCgICAgICAgID8AIMgEUIGiIQ3A9ADIAQgBSkA2AMiEUI7hkKAgICAgICAgPgAgyAQQgWIhDcD2AMgBCAFKQDgAyIQQjyGQoCAgICAgICA8ACDIBFCBIiENwPgAyAEIAUpAOgDIhFCPYZCgICAgICAgIDgAIMgEEIDiIQ3A+gDIAQgBSkA8AMiEEIBiDcD+AMgBCAQQj6GQoCAgICAgICAwACDIBFCAoiENwPwAwwCCyAGQf8DTQRADAoLIAQgBSkAADcDACAEIAUpAAg3AwggBCAFKQAQNwMQIAQgBSkAGDcDGCAEIAUpACA3AyAgBCAFKQAoNwMoIAQgBSkAMDcDMCAEIAUpADg3AzggBCAFKQBANwNAIAQgBSkASDcDSCAEIAUpAFA3A1AgBCAFKQBYNwNYIAQgBSkAYDcDYCAEIAUpAGg3A2ggBCAFKQBwNwNwIAQgBSkAeDcDeCAEIAUpAIABNwOAASAEIAUpAIgBNwOIASAEIAUpAJABNwOQASAEIAUpAJgBNwOYASAEIAUpAKABNwOgASAEIAUpAKgBNwOoASAEIAUpALABNwOwASAEIAUpALgBNwO4ASAEIAUpAMABNwPAASAEIAUpAMgBNwPIASAEIAUpANABNwPQASAEIAUpANgBNwPYASAEIAUpAOABNwPgASAEIAUpAOgBNwPoASAEIAUpAPABNwPwASAEIAUpAPgBNwP4ASAEIAUpAIACNwOAAiAEIAUpAIgCNwOIAiAEIAUpAJACNwOQAiAEIAUpAJgCNwOYAiAEIAUpAKACNwOgAiAEIAUpAKgCNwOoAiAEIAUpALACNwOwAiAEIAUpALgCNwO4AiAEIAUpAMACNwPAAiAEIAUpAMgCNwPIAiAEIAUpANACNwPQAiAEIAUpANgCNwPYAiAEIAUpAOACNwPgAiAEIAUpAOgCNwPoAiAEIAUpAPACNwPwAiAEIAUpAPgCNwP4AiAEIAUpAIADNwOAAyAEIAUpAIgDNwOIAyAEIAUpAJADNwOQAyAEIAUpAJgDNwOYAyAEIAUpAKADNwOgAyAEIAUpAKgDNwOoAyAEIAUpALADNwOwAyAEIAUpALgDNwO4AyAEIAUpAMADNwPAAyAEIAUpAMgDNwPIAyAEIAUpANADNwPQAyAEIAUpANgDNwPYAyAEIAUpAOADNwPgAyAEIAUpAOgDNwPoAyAEIAUpAPADNwPwAyAEIAUpAPgDNwP4AwwBCyAKQQE2AhQgCkH8ic8ANgIQIApCATcCHCAKQTs2AiwgCiAKQShqNgIYIAogCkEMajYCKCAKQRBqQbSKzwAQ7ywACyAKQTBqJAAgACAJIA1qIgk2AhggBiANayEGIARBgARqIQQgByEFIAxBQGoiDEE/Sw0ACwwFCyACIAJBmLrOABDDIQALQfy4zgBBGkGIus4AEMskAAsgBSAFQUBrQei5zgAQsTsACyAFQUBrIAJB6LnOABCwOwALIAkgDkH4uc4AEK87AAsCQCAMQR9NIANBIEtyDQAgCEEIaiIGQQBBgAH8CwAgACgCCCIFIAAoAhgiBE8EQCAAKAIEIARqIAUgBGsgBiADENgLIAAgBCADQQJ0ajYCGEEIIQUgCEGQAWogBkGAAfwKAAAgCEEgNgKMASAHIAIgAiAHSRshBCABIAdBA3RqIQkCQANAIAQgB0YNASAJIAhBiAFqIAVqNQIANwMAIAlBCGohCSAHQQFqIQcgBUEEaiIFQYgBRw0ACyAIQSA2AogBDAILIAQgAkHYuc4AEMMhAAsgBCAFQcy4zgAQrzsACwJAIAsgB2siDEEPTSADQRBLcg0AIAhBIGoiBkIANwMAIAhBGGoiCUIANwMAIAhBEGoiCkIANwMAIAhCADcDCCAAKAIIIgUgACgCGCIETwRAIAAoAgQgBGogBSAEayAIQQhqIAMQyBAgACAEIANBAXRqNgIYIAhBqAFqIAYpAwA3AgAgCEGgAWogCSkDADcCACAIQZgBaiAKKQMANwIAIAggCCkDCDcCkAEgASAHQQN0aiEJIAcgByACIAIgB0kbIgRrIQogCEGQAWohBkEAIQUCQANAIAUgCmpFDQEgCSAGMwEANwMAIAlBCGohCSAGQQJqIQYgBUEBaiIFQRBHDQALIAUgB2ohByAMIAVrIQwMAgsgBCACQci5zgAQwyEACyAEIAVB3LjOABCvOwALAkAgDEEHTSADQQhLcg0AIAhCADcDCCAAKAIIIgUgACgCGCIETwRAIAAoAgQgBGogBSAEayAIQQhqIAMQtBYgACADIARqNgIYIAggCCkDCDcCkAEgASAHQQN0aiEJIAcgByACIAIgB0kbIgRrIQYgCEEINgKMAUEAIQUCQANAIAUgBmpFDQEgCSAFIAhqQZABajEAADcDACAJQQhqIQkgBUEBaiIFQQhHDQALIAhBCDYCiAEgBSAHaiEHDAILIAQgAkG4uc4AEMMhAAsgBCAFQey4zgAQrzsACwJAAkAgByALSQRAIAsgB2shBiABIAdBA3RqIQkgByACIAIgB0kbIgEgB2shBQNAIAhBiAFqIAAgAxDfDSAIKAKIAUUNAyAFRQ0CIAkgCCkDkAE3AwAgBUEBayEFIAlBCGohCSAGQQFrIgYNAAsLIAhBkAJqJAAgCw8LIAEgAkGouc4AEMMhAAtB/LjOAEEaQZi5zgAQyyQAC0HU7s4AQS1BxO7OABCfKQAL7AoBB38jAEFAaiIGJAAgBiACNgIcIAYgATYCGAJAAkACQAJAAkACQCAGQRhqKAIEIgggBSgCCEYEQCAEKAIAIgpFDQIgAygCCCAEKAIIQQJ2Rw0BDAMLIAZBLGpBMkEAQQFBARCgGCAGKAIwIQEgBigCLEEBRg0FIAYoAjQiAkGcgoYBQTL8CgAAIABBMjYCECAAIAI2AgwgACABNgIIIABCgICAgNiBgICAfzcCACAEKAIAIQoMAwsgBkEsakEnQQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQQgBigCNCICQZiAhgFBJ/wKAAAgAEEnNgIQIAAgAjYCDCAAIAE2AgggAEKAgICA2IGAgIB/NwIADAILIAhBA3QhASAFKAIEIQIDQCABRQ0BIAFBCGshASACKAIEIQcgAigCACACQQhqIQIgBygCCEEBa0F4cWpBCGogBygCJBEEACADKAIIRg0ACyAGQSxqQcwAQQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQMgBigCNCICQdCBhgFBzAD8CgAAIABBzAA2AhAgACACNgIMIAAgATYCCCAAQoCAgIDYgYCAgH83AgBBACEKDAELIAZBEGogBkEYahCwLiAGQSBqQYCAgIB4IAYoAhAiAiAGKAIUIgdGBH9BAQUgAi0AACEBIAcgAkEIaiICRwRAIAcgAmtBA3YhBwNAIAIsAAAiCSABwCIBIAEgCUgbIQEgAkEIaiECIAdBAWsiBw0ACwsgAcBBAWoLQcCAhgEQsxUgBSgCBCECIAZBCGogBkEYahCwLgJAAkACQAJAIAYoAgwgBigCCCIBa0EDdiIHIAggByAISRsiCUUEQCAGKAIkIQsgBigCKCEHDAELIAYoAighBwNAIAEsAAAhCCACKAIAIAJBBGooAgAiCygCCEEBa0F4cWpBCGogCygCJBEEACEMIAcgCE0NAiAGKAIkIgsgCEECdGogDDYCACACQQhqIQIgAUEIaiEBIAlBAWsiCQ0ACwsgAygCBCIBIAMoAggiCGohCUEAIQICQAJAAkADQCACIAhGDQEgASACaiwAACIMIAdJBEAgAkEBaiECIAsgDEECdGooAgBBgICAgHhHDQELC0E0IQcgBkEsakE0QQBBAUEBEKAYIAYoAjAhASAGKAIsQQFGDQUgBigCNCICQYuBhgFBNPwKAAAMAQsgCkUNASAEKAIIIQcgBiAEKAIEIgI2AiwgBiAJNgI8IAYgATYCOCAGIAIgB0F8cWo2AjAgBkE4ahCDOyEBIAZBLGoQnjYiByABIAEgB0sbIQEgBigCOCEHIAYoAiQhCyAGKAIoIQgDQCABRQ0CIAIoAgAiDEEATgRAIAggBywAACIJTQ0FIAFBAWshASAHQQFqIQcgAkEEaiECIAwgCyAJQQJ0aigCAEgNAQsLQTshByAGQSxqQTtBAEEBQQEQoBggBigCMCEBIAYoAixBAUYNByAGKAI0IgJB0ICGAUE7/AoAAAsgACAHNgIQIAAgAjYCDCAAIAE2AgggAEKAgICA2IGAgIB/NwIAIAZBIGpBBEEEEOAeDAQLIAAgBigCGCAGKAIcIAMgBCAFEI4QIAZBIGpBBEEEEOAeDAQLIAggB0HAgYYBEMMhAAsgCSAIQdCChgEQwyEACwwCCyAFEMMnIAVBBEEIEOAeAkAgCkUNACAKIAooAgAiAEEBazYCACAAQQFHDQAgBBD7HgsgAygCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgAxD7HgsgBigCGCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEYahCGHQsgBkFAayQADwsgASAGKAI0QYiAhgEQ/S8AC6cgAhF/AX4gASgCCCABKAIESwRAQbp/DwsgAigCBCIEIAIoAggiCUkEQEG4fw8LIANBAksEQEFWDwsCQCAAKALkEkUEQCAAKAL4EiIGIAQgCWtqIQ8CQCADDQAgACgCfEEBRyAPQf//B0tyDQAgBgRAQU4hBiACKAIAIAAoAuwSRw0DIAkgACgC8BJHDQMLIAJBCGogBDYCACACKQIAIRUgACAPNgL4EiAAQfQSaiAENgIAIAAgFTcC7BJBAkEGIAAoAgwbDwsjAEHgAWsiCiQAIApBNGogAEEMaiIFQawB/AoAACAAKAKgEyEMIAAoApwTIQkgACgCmBMhCwJAAkAgACgChBMiBEUNACAAKAKQEw0AIAAoAowTIQYgACgCiBMgCkEQaiAAQcAFaigCADYCACAKIAApArgFNwMIIAQhDSEEIwBBsANrIgckACAHQdgBaiAFQawB/AoAAAJAIApBCGoiECgCACIORSAQKAIEIhNFcw0AAkAgBygCxAIiCARAIAdBuAFqIAcoAoQCQgAgBEECEIARIAcoAtABQQNrQQJNBEAgByAHKALAAUECajYCwAELIAdBuAFqIAdB3AFqEMQcDAELIAdBuAFqIAVCfyAEQQIQ9xULAkACQCAHKALQAUEDa0ECSw0AIAcoArwBIgUgBygCwAFPDQAgBUEZSQ0BC0EAIQggB0EANgLEAiAHQbgBaiAHQdgBakJ/IARBAhD3FQsgB0H0AWogB0HQAWooAgA2AgAgB0HsAWogB0HIAWopAwA3AgAgB0HkAWogB0HAAWopAwA3AgAgByAHKQO4ATcC3AECQCAHKALcAiIFDQBBAiEFIAcoAtABQQZrQX1JDQBBAUECIAcoArgBQRFLGyEFCyAHIAU2AtwCIBAoAgghECAHQbgBaiAFIAhBABD4FUGw6gBqIQgCQAJ/IA4EQCAQIAggDhECAAwBCyAIEIYvCyIRRQRAQQAhCAwBCyAHQYQDaiIUIBEgCBDLKCAHIAcoAowDIghBsCZqIhE2ApQDIAcgETYCkAMgByARNgKMAyAIQRBqIBRBLPwKAAAgCCAFNgKoJiAIQQA2AqQmIAggEDYCnCYgCCATNgKYJiAIIA42ApQmCyAHQQxqIgUgB0HYAWpBrAH8CgAAIAggBSkCBDcC+AEgCCAFKAJsNgKsASAIQZACaiAFQRxqKAIANgIAIAhBiAJqIAVBFGopAgA3AgAgCEGAAmogBUEMaikCADcCACAIIA02AgAgCCAGNgIIIAggBDYCBCAIQRBqIg1BgMQAENcnIQQgCEKEgICAgAE3AowmIAggBDYCDCAIQoCAgIAQNwKEJiAIQgA3AvwlIAhBADYCpAoCQCAIQUBrIg4gDSAFQQRqIAUoAoQBQQBBAUEAEPAIIgRBiH9LDQAgBUEBNgIgIAVBAzYCLCAIQaACaiAOQQAgDSAFIAgoAgAgCCgCBCAGQQFBASAIKAIMENsVIgRBiH9LDQAgCCAENgKgJkEAIQQLIARBiX9JDQAgCBCXE0EAIQgLIAdBsANqJAAgACAIIgQ2ApATIARFBEBBQCEEDAILIAAgBDYClBMLIABBmBNqIgRCADcDACAEQQhqQQA2AgACQCAAKAKUEyIGRQ0AIAAoApATDQAgCiAGKAKkJjYCYAsgA0ECRgRAIAAgD0EBaq03A8gECwJ/An8CQCALRQRAIAYNASAAKQPIBEIBfSEVQQAhBEEADAMLIAApA8gEQgF9IRUgCSAGDQEaIAkhBEEADAILIAApA8gEQgF9IRUgBigCBAshBCAGIApBNGogFRDmJAshBSAKQRhqIApBNGogFSAEIAUQ9xUgCkHQAGogCkEwaigCADYCACAKQcgAaiAKQShqKQIANwIAIApBQGsgCkEgaikCADcCACAKIAopAhg3AjgCQCAKKAK0ASIEDQBBAiEEIAooAlBBB0kNAEEBQQIgCigCOEEQSxshBAsgCiAENgK0AQJAIAooAogBIgQNAEECIQQgCigCUEEHSQ0AQQFBAiAKKAI4QRpLGyEECyAKIAQ2AogBAkAgCigCuAEiBA0AQQIhBCAKKAJQQQZrQX1JDQBBAUECIAooAjhBEUsbIQQLIAogBDYCuAEgCiAKKALYASIEQYCACCAEGzYC2AEgCiAKKALcASIEQQJBASAKKAJgQQpIGyAEGzYC3AEgCkE0aiENIwBB8AFrIgUkACAJIQcCQAJAIAYiBEUNACAEKAIEIgdFBEBBACEHDAELIBVCf1EgFUKAgAhUciAVIAetQgZ+VHJFBEAgBCgCpCYNAQsgDSgCPEEDRg0AIAQgDSAVEOYkBEAgBUFAayIJIA1BrAH8CgAAIAVBOGoiBiAEQZACaigCADYCACAFQTBqIgsgBEGIAmopAgA3AwAgBUEoaiIMIARBgAJqKQIANwMAIAUgBCkC+AE3AyAgCUEEciAFKAJEIQ0CQCAEKAKsAUUNACAFKAI4QQNrQQJLDQAgBUEGIAUoAihBAmsiCCAIQQZNGzYCKAsgBUEIaiAMKQMANwMAIAVBEGogCykDADcDACAFQRhqIAYoAgA2AgAgBSAFKQMgNwMAIAUgFSAHQQEgBSgCxAEQ6gsgBSANNgJEIAUgBCgCqCY2AsQBIAAgBUFAayAVQQBBABDUBSIGQYh/Sw0CIAQoAkAgBCgCRGsiCSAEKAJMRwRAIAAgBEFAazYCjBIgACAJIAAoAuQQIgtLBH8gACAJNgLoECAAIAk2AuQQIAAgACgC3BAgCWo2AtgQIAkFIAsLNgLwEAsgACAEKAKgJjYCkAQgACAEKAIENgKUBCAAKALQECAEQaACakH0I/wKAAAMAgsgBUFAayIJIA1BrAH8CgAAIAVBzABqIARBgAJqKQIANwIAIAVB1ABqIARBiAJqKQIANwIAIAVB3ABqIARBkAJqKAIANgIAIAUoAkQhBiAFIAQpAvgBNwJEIAUgBCgCqCY2AsQBIAUgBjYCREEAIQcgACAJIBVBAEEBENQFIgZBiH9LDQEgBEH4AWohCSAAIAAoAqAENgKoBAJAIAQoApACIgtBAUYNACALQQNrQQJNBEAgBCgCqCZBAUYNAQtBASAEKAL8AXQhBwsgACgCtBEgBCgCnAFBASAEKAKAAnQiCyAJEKUkAkAgACgC1AEiDEEBRg0AIAxBA2tBAk0EQCAAKAK8AkEBRg0BCyAAKAK8ESAEKAKkASAHIAkQpSQLAkAgBCgCkAJBBmtBfUkNACAEKAKoJkEBRw0AIAsEQCAAKAKAESAEKAJoIAv8CgAACyAAIAQpA5ABNwOoEQtBBCAAKAL4ECIJdEEAIAkbIgkEQCAAKAK4EUEAIAn8CwALIAAoAqQEIgkgACgCqARLBEAgACAJNgKoBAsgAEHYEGoiCSAEQUBrIgspAwA3AwAgCUEQaiALQRBqKQMANwMAIAlBCGogC0EIaikDADcDACAAIAQoAlw2AvQQIAAgBCgCWDYC8BAgACAEKAKgJjYCkAQgACAEKAIENgKUBCAAKALQECAEQaACakH0I/wKAAAMAQsgACANIBUgB0EAENQFIgZBiH9LDQAgAEG4AWohBiAAQZgEaiENIABBkAZqIQggAEHYEGohDyAAKALQECEOAn8gBARAIA4gDyAIIA0gBiAEKAIAIAQoAgQgBCgCCEEAQQAgACgCuBIQ2xUMAQsgDiAPIAggDSAGIAsgCSAMQQBBACAAKAK4EhDbFQsiBkGIf0sNACAAIAc2ApQEIAAgBjYCkARBACEGCyAFQfABaiQAIAYiBEGIf0sNACAAQgA3A8gSIAAgACgCqAIEf0EABSAAKALEBCIEIBUgBK1Rags2AtASIABCATcC5BIgAEIANwLcEkEAIQQLIApB4AFqJAAgBCIGQYh/Sw0BIAAgASACEMwoCyAAKAKoAiIFQQFGBEBBTiEGIAAoAuwSIAIoAgBHDQEgACgC9BIgAigCCEcNAQsCQCAAKAKsAkEBRw0AIAAoAvwSIAEoAgQgASgCCGtGDQBBTg8LQQAhCUEAIQQgAigCACINBEAgDSACKAIEaiEJIA0gAigCCGohBAsgASgCACIKBH8gCiABKAIEaiESIAogASgCCGoFQQALIQsgBUEBRgRAIAAoAvgSIQYgAEEANgL4EiACIAIoAgggBms2AgggBCAGayEECyADQQJHIQ8DQEEAIQUDQAJ/An8CfwJAIAVFBEBBQiEGQQAhBQJAAkAgACgC5BIOAwkBAAcLIAAoAtwSIQYgACgC4BIMBQsCQAJAAkACQAJAAkAgDw0AIAkgBGsiBhDnKSASIAtrIgVLBEAgACgCrAJBAUcNAQsgACgCzBINACAAIAsgBSAEIAYQnhMiBkGIf0sNDSAAQoCAgIAQNwLkEiAAQgA3A8gEIAYgC2ohCwwBCyAAKAKoAkUEQCAAIAAoAtASIAAoAswSIgVrIgYgCSAEayIMIAYgDEkbIgYEfyAGBEAgACgCwBIgBWogBCAG/AoAAAsgACgCzBIFIAULIAZqIgw2AswSIAQgBmpBACAEGyEEAkAgAw4CBQAGC0EBIQUgDCAAKALIEkYNCwwFCwJAIAMOAgACAwsgCSAEayIGIAAoAsQETw0EIAAgBjYC+BILQQEhBSAJIQQMCQtBASEFIAQgCUYNCAsgEiALayEGDAMLQQEhBSAMIAAoAtASSQ0GCyASIAtrIQYgACgCqAINAUEBIQwgACgCzBIgACgCyBJrDAILIAEgCyAKazYCCCACIAQgDWs2AgggACgC6BJFBEAgABCMKyIGQYh/Sw0HCyAAIAEgAhDMKCAAKALcEiAAKALgEmshBgwGC0EAIQwgCSAEayIFIAAoAsQEIgcgBSAHSRsLIgUQ5ykgBk0EQCALDAELIAsgACgCrAJBAUYNABogACgC2BIhBiAAKALUEgshBwJAIAwEQCAAKALAEiAAKALIEmohCAJ/IANBAkYgBCAJRnEiDARAIAAgByAGIAggBRCeEwwBCyAAIAcgBiAIIAUQ1DULIgZBiH9LDQUgACAMNgLoEiAAIAAoAsQEIgUgACgCzBIiCGoiDjYC0BIgACAAKALEEiAOSQR/IAAgBTYC0BIgAEEANgLMEkEABSAICzYCyBIMAQsCfyADQQJGIAQgBWoiCCAJRnEiDARAIAAgByAGIAQgBRCeEwwBCyAAIAcgBiAEIAUQ1DULIgZBiH9LDQQgACAMNgLoEiAIQQAgBBshBAsgByALRgRAIAYgC2ohC0EAIQUgDEUNAiAAQgA3A8gEIABBADYC5BJBASEFDAILIABCgICAgCA3A+ASIAAgBjYC3BJBAAshBSAAIBIgC2siDCAGIAVrIgcgByAMSxsiBgR/IAYEQCALIAAoAtQSIAVqIAb8CgAACyAAKALgEgUgBQsgBmo2AuASIAYgC2ohC0EBIQUgByAMSw0AIABCADcC3BIgACgC6BIEQCAAQgA3A8gEIABBADYC5BIMAQsLIABBATYC5BIMAAsACyAGC7kKAgh/A34jAEGQAWsiAiQAIAFBDGoQ2zwhCCACQRBqIAEQkjYQ7iUgCEEBdCIDIQQCQAJAAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCAGQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohByABKAIQIQggAikDcCELA0ACQCALUEUEQCACKQN4IQoMAQsDQAJ+AkAgAikDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAIgClCtQgGGNwNYIAqnQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiAHELYqIAIpA4ABIQoLIApCAFINAgsgAkIDNwNYCyACKQNIIgpCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCyAKp0EBcUUNByACIAIpA3hCQH0iCjcDeCACIAs3A3AgC1ANAAsLIAJCASALeiIMhiALhSILNwNwIAggDKcgCqdqIglBAnRqKAIAsrwiA0H///8DcSEFIANBgICAgHhxIQQCQCADQYCAgPwHcSIBQYCAgPwHRgRAIAVBDXYgBEEQdnIgBUEAR0EJdHJBgPgBciEEDAELIARBEHYhBCABQYCAgLgETQRAIAFBgICAxANPBEAgA0EMdiADQf/fAHFBAEdxIAFBDXYgBUENdmpBgIABaiAEcmohBAwCCyABQYCAgJgDSQ0BIAVBgICABHIiA0EeIAFBF3YiBWt2IQEgA0EdIAVrIgV2QQFxBH8gAUEDIAV0QQFrIANxQQBHagUgAQsgBHIhBAwBCyAEQYD4AXIhBAsgBiAJQQF0aiAEOwEADAALAAtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgASgCECEEA0AgBCgCALK8IgVB////A3EhByAFQYCAgIB4cSEBAkAgBUGAgID8B3EiA0GAgID8B0YEQCAHQQ12IAFBEHZyIAdBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgA0GAgIC4BE0EQCADQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSADQQ12IAdBDXZqQYCAAWogAXJqIQEMAgsgA0GAgICYA0kNASAHQYCAgARyIgVBHiADQRd2IgdrdiEDIAVBHSAHayIHdkEBcQR/IANBAyAHdEEBayAFcUEAR2oFIAMLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgBEEEaiEEIAggCUEBaiIJRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBSACKAI0IQYgASACQdAAaiIDKQIANwMAIAIpAyghCiACIAIpAkg3AyggAkEANgI4IAIgCjcCVCACQQA2AlAgAiAGNgJMIAIgBTYCSCACQQhqIAQQ1zsgAigCCCEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiADKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAY2AogBIAIgBTYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgByACQSBqKQIANwMAIAMgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAu5CgIIfwN+IwBBkAFrIgIkACABQQxqENg8IQggAkEQaiABEJI2EO4lIAhBAXQiAyEEAkACQAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgBkEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEIIAIpA3AhCwNAAkAgC1BFBEAgAikDeCEKDAELA0ACfgJAIAIpA1giCkIDUgRAAkACQAJAIApCAlENACACIApQrUIBhjcDWCAKp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEKCyAKQgBSDQILIAJCAzcDWAsgAikDSCIKQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQsgCqdBAXFFDQcgAiACKQN4QkB9Igo3A3ggAiALNwNwIAtQDQALCyACQgEgC3oiDIYgC4UiCzcDcCAIIAynIAqnaiIJQQN0aikDALS8IgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCUEBdGogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQpAwC0vCIFQf///wNxIQcgBUGAgICAeHEhAQJAIAVBgICA/AdxIgNBgICA/AdGBEAgB0ENdiABQRB2ciAHQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIANBgICAuARNBEAgA0GAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgA0ENdiAHQQ12akGAgAFqIAFyaiEBDAILIANBgICAmANJDQEgB0GAgIAEciIFQR4gA0EXdiIHa3YhAyAFQR0gB2siB3ZBAXEEfyADQQMgB3RBAWsgBXFBAEdqBSADCyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIARBCGohBCAIIAlBAWoiCUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiAykCADcDACACKQMoIQogAiACKQJINwMoIAJBADYCOCACIAo3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiAEENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEM8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALuQoCCH8DfiMAQZABayICJAAgAUEMahDYPCEIIAJBEGogARCSNhDuJSAIQQF0IgMhBAJAAkACQCADQT5xIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAZBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEHIAEoAhAhCCACKQNwIQsDQAJAIAtQRQRAIAIpA3ghCgwBCwNAAn4CQCACKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgAiAKUK1CAYY3A1ggCqdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAcQtiogAikDgAEhCgsgCkIAUg0CCyACQgM3A1gLIAIpA0giCkICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyELIAqnQQFxRQ0HIAIgAikDeEJAfSIKNwN4IAIgCzcDcCALUA0ACwsgAkIBIAt6IgyGIAuFIgs3A3AgCCAMpyAKp2oiCUEDdGorAwC2vCIDQf///wNxIQUgA0GAgICAeHEhBAJAIANBgICA/AdxIgFBgICA/AdGBEAgBUENdiAEQRB2ciAFQQBHQQl0ckGA+AFyIQQMAQsgBEEQdiEEIAFBgICAuARNBEAgAUGAgIDEA08EQCADQQx2IANB/98AcUEAR3EgAUENdiAFQQ12akGAgAFqIARyaiEEDAILIAFBgICAmANJDQEgBUGAgIAEciIDQR4gAUEXdiIFa3YhASADQR0gBWsiBXZBAXEEfyABQQMgBXRBAWsgA3FBAEdqBSABCyAEciEEDAELIARBgPgBciEECyAGIAlBAXRqIAQ7AQAMAAsAC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACABKAIQIQQDQCAEKwMAtrwiBUH///8DcSEHIAVBgICAgHhxIQECQCAFQYCAgPwHcSIDQYCAgPwHRgRAIAdBDXYgAUEQdnIgB0EAR0EJdHJBgPgBciEBDAELIAFBEHYhASADQYCAgLgETQRAIANBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIANBDXYgB0ENdmpBgIABaiABcmohAQwCCyADQYCAgJgDSQ0BIAdBgICABHIiBUEeIANBF3YiB2t2IQMgBUEdIAdrIgd2QQFxBH8gA0EDIAd0QQFrIAVxQQBHagUgAwsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiAEQQhqIQQgCCAJQQFqIglHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC8kKAhB/An4jAEFAaiIFJAACQAJAIAEoAgwiDSACaiICIA1PBEACQCABKAIEIgkgCUEBaiILQQN2IgZBB2wgCUEISRsiD0EBdiACSQRAAn8gD0EBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBCEEQIAJBCEkbCyECIAVBMGogAUEQaiIHQQFBCCACEJ0UIAUoAjQhBiAFKAIwIgRFBEAgBSgCOCECDAULIAUpAjghFCAGQQlqIgIEQCAEQf8BIAL8CwALIAUgFEIgiD4CLCAFIBSnIgs2AiggBSAGNgIkIAUgBDYCICAFQoGAgICAATcCGCAFIAc2AhQgBUEgaiEOIAUgDQR/IARBCGohCiABKAIAIggpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQIDQCAUUARAA0AgAkEIaiECIAhBCGoiCCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgBCAGIAMgFHqnQQN2IAJqQX9zIgwgASgCAGoQwxCnIg9xIgdqKQAAQoCBgoSIkKDAgH+DIhVQBEBBCCEJA0AgByAJaiEHIAlBCGohCSAEIAYgB3EiB2opAABCgIGChIiQoMCAf4MiFVANAAsLIBRCAX0gFIMhFCAEIBV6p0EDdiAHaiAGcSIHaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAEIAdqIA9BGXYiCToAACAKIAdBCGsgBnFqIAk6AAAgBCAHQX9zaiABKAIAIAxqLQAAOgAAIA1BAWsiDQ0ACyABKAIMBUEACyICNgIsIAUgCyACazYCKCABIA5BBBD6KiAFKAIkIgJFDQEgAiAFKAIcIgEgBSgCGCACQQFqbGpBAWtBACABa3EiA2pBCWoiAkUNASAFKAIgIANrIAIgARD4OgwBCyABKAIAIQQgBiALQQdxQQBHaiIIBEAgBCECA0AgAiACKQMAIhRCf4VCB4hCgYKEiJCgwIABgyAUQv/+/fv379+//wCEfDcDACACQQhqIQIgCEEBayIIDQALCwJAAkAgC0EITwRAIAQgC2ogBCkAADcAAAwBCyALBEAgBEEIaiAEIAv8CgAACyALRQ0BCyAEQQhqIQ4gBEEBayESQQEhBkEAIQIDQCACIQcgBiECAkAgBCAHaiIQLQAAQYABRw0AIBIgB2shEyAEIAdBf3NqIQYDQCAJIAMgExDDEKciEXEiCiEIIAQgCmopAABCgIGChIiQoMCAf4MiFFAEQEEIIQwDQCAIIAxqIQggDEEIaiEMIAQgCCAJcSIIaikAAEKAgYKEiJCgwIB/gyIUUA0ACwsgBCAUeqdBA3YgCGogCXEiCGosAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhCAsgCCAKayAHIAprcyAJcUEITwRAIAQgCGoiCi0AACAKIBFBGXYiCjoAACAOIAhBCGsgCXFqIAo6AAAgBCAIQX9zaiEIQf8BRgRAIBBB/wE6AAAgDiAHQQhrIAlxakH/AToAACAIIAYtAAA6AAAMAwsgBi0AACEKIAYgCC0AADoAACAIIAo6AAAMAQsLIBAgEUEZdiIGOgAAIA4gB0EIayAJcWogBjoAAAsgAiACIAtJIgdqIQYgBw0ACwsgASAPIA1rNgIIC0GBgICAeCEGDAILEOMnIAUoAgQhAiAFKAIAIQYMAQsQ4ycgBSgCDCECIAUoAgghBgsgACAGNgIAIAAgAjYCBCAFQUBrJAALqwoBB38jAEFAaiIEJAACQCACLQAMIgNBAUYEQCABLQAMIQIgACABEOkdIAAgAjoADAwBCwJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAMIgZBAWsOAgsBAAsgA0UNAQwCCyADRQ0BCwJ/IAEoAggiAyACKAIIIgVHBEAgAyAFSyADIAVJawwBCyADQQJ0IQMgASgCBEEEayEIIAIoAgRBBGshCQJAA0AgA0UNASADIAlqIQcgAyAIaiADQQRrIQMoAgAiBSAHKAIAIgdGDQALIAUgB0sgBSAHSWsMAQtBf0EAIAMbCyIDQf8BcQ4CAgMBCwJAIAEoAgggAigCCEkEQCAEQSBqIgUgAhDpHSAEQTBqIAUgARDtCAwBCyAEQSBqIgUgARDpHSAEQTBqIAUgAhDtCAsgBkEBRwRAIAZBASAEKAI4GyEDDAcLIARBADYCOCAEQTBqQQRBBBCeJCAEKAI4IgJFDQUgBCgCNCIBIAJBAnQiBWpBBGsiA0UNBSADKAIADQUgBSEDIAFBBGshBiACQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAyAGaiADQQRrIQMoAgBFDQALIAFBAWoiAyACSw0GCyAEIAM2AjggAyECDAULIARBIGoiBSACEOkdIAUgARDvFCAEQThqIARBKGooAgA2AgAgBCAEKQIgNwMwIAZBAXFFBEBBAiAGa0EBIAQoAjgbIQMMBAsgBEEANgI4IARBMGpBBEEEEJ4kIAQoAjgiAkUNAiAEKAI0IgEgAkECdCIFakEEayIDRQ0CIAMoAgANAiAFIQMgAUEEayEGIAJB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAZqIANBBGshAygCAEUNAAsgAUEBaiIDIAJLDQMLIAQgAzYCOCADIQIMAgsgAEEIakGUiogBKQIANwIAIABBjIqIASkCADcCAAwGCyAEQSBqIgUgARDpHSAFIAIQ7xQgBEE4aiAEQShqKAIANgIAIAQgBCkCIDcDMAJAIAZBAUcEQCAGQQEgBCgCOBshAwwBCyAEQQA2AjggBEEwakEEQQQQniQCQCAEKAI4IgJFDQAgBCgCNCIBIAJBAnQiBWpBBGsiA0UNACADKAIADQAgBSEDIAFBBGshBiACQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAyAGaiADQQRrIQMoAgBFDQALIAFBAWoiAyACSw0BCyAEIAM2AjggAyECC0EBIQMgAiAEKAIwQQJ2Tw0AIARBEGogBEEwaiACQQRBBBD0FCAEKAIQIgFBgYCAgHhGDQAgASAEKAIUQcyNiAEQ/S8ACyAAIAQpAzA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwFC0EBIQMgAiAEKAIwQQJ2Tw0AIARBCGogBEEwaiACQQRBBBD0FCAEKAIIIgFBgYCAgHhGDQAgASAEKAIMQcyNiAEQ/S8ACyAAIAQpAzA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwDC0EBIQMgAiAEKAIwQQJ2Tw0AIARBGGogBEEwaiACQQRBBBD0FCAEKAIYIgFBgYCAgHhGDQAgASAEKAIcQcyNiAEQ/S8ACyAAIAQpAjA3AgAgACADOgAMIABBCGogBEE4aigCADYCAAwBCyAEQSBqIAIQ6R0gACAEKQIgNwIAIARBAiADazoALCAAQQhqIARBKGopAgA3AgALIARBQGskAAu2CgIIfwN+IwBBkAFrIgIkACABQQxqENk8IQggAkEQaiABEJI2EO4lIAhBAXQiAyEEAkACQAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgBkEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEIIAIpA3AhCwNAAkAgC1BFBEAgAikDeCEKDAELA0ACfgJAIAIpA1giCkIDUgRAAkACQAJAIApCAlENACACIApQrUIBhjcDWCAKp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEKCyAKQgBSDQILIAJCAzcDWAsgAikDSCIKQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQsgCqdBAXFFDQcgAiACKQN4QkB9Igo3A3ggAiALNwNwIAtQDQALCyACQgEgC3oiDIYgC4UiCzcDcCAIIAynIAqnakEBdCIJai4BALK8IgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCWogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQuAQCyvCIFQf///wNxIQcgBUGAgICAeHEhAQJAIAVBgICA/AdxIgNBgICA/AdGBEAgB0ENdiABQRB2ciAHQQBHQQl0ckGA+AFyIQEMAQsgAUEQdiEBIANBgICAuARNBEAgA0GAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgA0ENdiAHQQ12akGAgAFqIAFyaiEBDAILIANBgICAmANJDQEgB0GAgIAEciIFQR4gA0EXdiIHa3YhAyAFQR0gB2siB3ZBAXEEfyADQQMgB3RBAWsgBXFBAEdqBSADCyABciEBDAELIAFBgPgBciEBCyAGIAE7AQAgBkECaiEGIARBAmohBCAIIAlBAWoiCUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiAykCADcDACACKQMoIQogAiACKQJINwMoIAJBADYCOCACIAo3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiAEENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEM8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALtgoCCH8DfiMAQZABayICJAAgAUEMaigCCCEIIAJBEGogARCSNhDuJSAIQQF0IgMhBAJAAkACQCADQT5xIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAZBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEHIAEoAhAhCCACKQNwIQsDQAJAIAtQRQRAIAIpA3ghCgwBCwNAAn4CQCACKQNYIgpCA1IEQAJAAkACQCAKQgJRDQAgAiAKUK1CAYY3A1ggCqdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAcQtiogAikDgAEhCgsgCkIAUg0CCyACQgM3A1gLIAIpA0giCkICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyELIAqnQQFxRQ0HIAIgAikDeEJAfSIKNwN4IAIgCzcDcCALUA0ACwsgAkIBIAt6IgyGIAuFIgs3A3AgCCAMpyAKp2oiCWosAACyvCIDQf///wNxIQUgA0GAgICAeHEhBAJAIANBgICA/AdxIgFBgICA/AdGBEAgBUENdiAEQRB2ciAFQQBHQQl0ckGA+AFyIQQMAQsgBEEQdiEEIAFBgICAuARNBEAgAUGAgIDEA08EQCADQQx2IANB/98AcUEAR3EgAUENdiAFQQ12akGAgAFqIARyaiEEDAILIAFBgICAmANJDQEgBUGAgIAEciIDQR4gAUEXdiIFa3YhASADQR0gBWsiBXZBAXEEfyABQQMgBXRBAWsgA3FBAEdqBSABCyAEciEEDAELIARBgPgBciEECyAGIAlBAXRqIAQ7AQAMAAsAC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACABKAIQIQlBACEEA0AgBCAJaiwAALK8IgVB////A3EhByAFQYCAgIB4cSEBAkAgBUGAgID8B3EiA0GAgID8B0YEQCAHQQ12IAFBEHZyIAdBAEdBCXRyQYD4AXIhAQwBCyABQRB2IQEgA0GAgIC4BE0EQCADQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSADQQ12IAdBDXZqQYCAAWogAXJqIQEMAgsgA0GAgICYA0kNASAHQYCAgARyIgVBHiADQRd2IgdrdiEDIAVBHSAHayIHdkEBcQR/IANBAyAHdEEBayAFcUEAR2oFIAMLIAFyIQEMAQsgAUGA+AFyIQELIAYgATsBACAGQQJqIQYgCCAEQQFqIgRHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC7UKAgh/A34jAEGQAWsiAiQAIAFBDGoQ2zwhCCACQRBqIAEQkjYQ7iUgCEEBdCIDIQQCQAJAAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCAGQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohByABKAIQIQggAikDcCELA0ACQCALUEUEQCACKQN4IQoMAQsDQAJ+AkAgAikDWCIKQgNSBEACQAJAAkAgCkICUQ0AIAIgClCtQgGGNwNYIAqnQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiAHELYqIAIpA4ABIQoLIApCAFINAgsgAkIDNwNYCyACKQNIIgpCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCyAKp0EBcUUNByACIAIpA3hCQH0iCjcDeCACIAs3A3AgC1ANAAsLIAJCASALeiIMhiALhSILNwNwIAggDKcgCqdqIglBAnRqKAIAIgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAUGAgID8B0YEQCAFQQ12IARBEHZyIAVBAEdBCXRyQYD4AXIhBAwBCyAEQRB2IQQgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogBHJqIQQMAgsgAUGAgICYA0kNASAFQYCAgARyIgNBHiABQRd2IgVrdiEBIANBHSAFayIFdkEBcQR/IAFBAyAFdEEBayADcUEAR2oFIAELIARyIQQMAQsgBEGA+AFyIQQLIAYgCUEBdGogBDsBAAwACwALQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAEoAhAhBANAIAQoAgAiBUH///8DcSEHIAVBgICAgHhxIQECQCAFQYCAgPwHcSIDQYCAgPwHRgRAIAdBDXYgAUEQdnIgB0EAR0EJdHJBgPgBciEBDAELIAFBEHYhASADQYCAgLgETQRAIANBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIANBDXYgB0ENdmpBgIABaiABcmohAQwCCyADQYCAgJgDSQ0BIAdBgICABHIiBUEeIANBF3YiB2t2IQMgBUEdIAdrIgd2QQFxBH8gA0EDIAd0QQFrIAVxQQBHagUgAwsgAXIhAQwBCyABQYD4AXIhAQsgBiABOwEAIAZBAmohBiAEQQRqIQQgCCAJQQFqIglHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEFIAIoAjQhBiABIAJB0ABqIgMpAgA3AwAgAikDKCEKIAIgAikCSDcDKCACQQA2AjggAiAKNwJUIAJBADYCUCACIAY2AkwgAiAFNgJIIAJBCGogBBDXOyACKAIIIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBjYCiAEgAiAFNgKEASACIAE2AoABIAJBPGoiASACQYABahDhGSAHIAJBIGopAgA3AwAgAyACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDPHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC7ALAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2zwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2oiB0ECdGo0AgAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAI0AgAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC7ALAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2TwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2oiB0EBdGoyAQAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAIyAQAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkECaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC60LAgV/BH4jAEHwAWsiBCQAIAFBDGoQ2DwhCCAEQTBqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCUCAEIAU2AkwgBEHAADYCSCAHBEAgBkEAIAf8CwALIAQgCDYCWCAEIAc2AlQgBCgCMEUNAyAEKAJEIAQoAkBGDQQgBEHoAGogBEEwahDINCAEQYgBaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQOQASIKUEUEQCAEKQOYASEJDAELA0ACfgJAIAQpA3giCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDeCAJp0EBcUUNACAEIAQpA4ABNwPIAQwBCyAEKAKIAUUNASAEQcABaiAFELYqIAQpA8ABIQkLIAlCAFINAgsgBEIDNwN4CyAEKQNoIglCAlENCSAEQgA3A2ggBCkDcAwBCyAEKQPIAQshCiAJp0EBcUUNByAEIAQpA5gBQkB9Igk3A5gBIAQgCjcDkAEgClANAAsLIAQgCkIBIAp6IgyGhTcDkAEgAiAMpyAJp2pBA3QiB2opAwAhCSAEIAs3A+gBIAQgCTcDoAEgBEEgaiAJIAlCP4cgCyALQj+HEKgeIAQpAyggBCkDICIJQj+HUgRAIARBAjYCxAEgBEGskP8ANgLAASAEQgI3AswBIARBhgw2AuQBIARBhgw2AtwBIAQgBEHYAWo2AsgBIAQgBEHoAWo2AuABIAQgBEGgAWo2AtgBIARBsAFqIARBwAFqEJkOIAQpArABIQkgBCkCuAEhCkGIgICAeCEBDAcLIARBwAFqIAkgAxCNECAEKALAASIBQZOAgIB4RwRAIAQpAswBIQogBCkCxAEhCQwHBSAGIAdqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAIpAwAhCiAEIAk3A9gBIAQgCjcD6AEgBEEQaiAKIApCP4cgCSAJQj+HEKgeIAQpAxggBCkDECIKQj+HUgRAIARBAjYCbCAEQayQ/wA2AmggBEICNwJ0IARBhgw2ArgBIARBhgw2ArABIAQgBEGsAWo2AnAgBCAEQdgBajYCtAEgBCAEQegBajYCrAEgBEHEAWogBEHoAGoQmQ4gBCkCxAEhCSAEKQLMASEKQYiAgIB4IQEMAwsgBEHoAGogCiADEI0QIAQoAmgiAUGTgICAeEcEQCAEKQJ0IQogBCkCbCEJDAMLIAYgCjcDACAGQQhqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgATYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC+4KAgZ/BH4jAEGQAWsiAyQAIAFBDGoQ2DwhByADQQhqIAEQkjYQ7iUgB0EEdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBMHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQUgAigCCCEHIAIoAgAhBCABKAIQIQECQANAAkAgAykDaCIKUEUEQCADKQNwIQkMAQsDQAJ+AkAgAykDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAMgCVCtQgGGNwNQIAmnQQFxRQ0AIAMgAykDWDcDgAEMAQsgAygCYEUNASADQfgAaiAFELYqIAMpA3ghCQsgCUIAUg0CCyADQgM3A1ALIAMpA0AiCUICUQ0KIANCADcDQCADKQNIDAELIAMpA4ABCyEKIAmnQQFxRQ0IIAMgAykDcEJAfSIJNwNwIAMgCjcDaCAKUA0ACwsgAyAKQgEgCnoiC4aFNwNoQoCAgICAgICAgH8hDAJAIANB+ABqAn4CQAJAIAEgC6cgCadqIghBA3RqKQMAIgtCgICAgICAgICAf1IgBCgCACkDACIJQn9SckUEQEIAIQoMAQsgCVANAyALIAsgCX8iDCAJfn1CACAJQn9SGyEKIAtCAFkNAQsgDCAKIAQoAggpAwBXrX0MAQsgDCAKIAQoAgQpAwBZrXwLIgkgCUI/hyIKIActAAAQrQ4gAygCeCICQZOAgIB4Rw0CIAYgCEEEdGoiAiAKNwMIIAIgCTcDAAwBCwtBvI//ABDiKwALIAMpAnwhCSAAIAMpAoQBNwIQDAYLQcAAIAQQoz0AC0Hci/8AQSkgA0FAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAdFDQAgAigCCCEIIAIoAgAhBSABKAIQIQRBACEBA0BCgICAgICAgICAfyEMIAUoAgApAwAhCSADQUBrAn4CQAJAIAQpAwAiCkKAgICAgICAgIB/UQRAQgAhCyAJQn9RDQELIAlQDQggCiAKIAl/IgwgCX59QgAgCUJ/UhshCyAKQgBZDQELIAwgCyAFKAIIKQMAV619DAELIAwgCyAFKAIEKQMAWa18CyIJIAlCP4ciCiAILQAAEK0OIAMoAkAiAkGTgICAeEcNAiAGIAk3AwAgBiAKNwMIIARBCGohBCAGQRBqIQYgByABQQFqIgFHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEEIAEgA0HIAGoiBikCADcDACADKQMgIQkgAyADKQJANwMgIANBADYCMCADIAk3AkwgA0EANgJIIAMgBDYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBDYCgAEgAyAFNgJ8IAMgATYCeCADQTRqIgEgA0H4AGoQ4hkgByADQRhqKQIANwMAIAYgA0EQaikCADcDACADIAMpAgg3A0AgACABIAIQyx0gA0EgahDPLwwCCyADKQJEIQkgACADKQJMNwIQCyAAIAk3AgggAEEpOgAAIAAgAjYCBCADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0GQAWokAA8LQbyP/wAQ4isAC0EEQRwQoz0AC/gLAQJ/IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCCCACQQE2AhQgAkGs7ocBNgIQIAJCATcCHCACQZgdNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAiACQQhqNgIMIAEoAgAgASgCBCACQRBqEMsKDBILIAIgAEEEajYCCCACQQE2AhQgAkHE7ocBNgIQIAJCATcCHCACQZkdNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAiACQQhqNgIMIAEoAgAgASgCBCACQRBqEMsKDBELIAIgAEEEajYCDCACQQE2AhQgAkHY7ocBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMEAsgAiAAQQRqNgIMIAJBATYCFCACQfDuhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwPCyACIABBBGo2AgwgAkEBNgIUIAJBiO+HATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDA4LIAIgAEEEajYCDCACQQE2AhQgAkGg74cBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMDQsgAiAAQQRqNgIMIAJBATYCFCACQbjvhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwMCyABKAIAQcDvhwFBFCABKAIEKAIMEQYADAsLIAIgAEEEajYCDCACQQE2AhQgAkHs74cBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMCgsgAiAAQQRqNgIMIAJBATYCFCACQYDwhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwJCyACIABBBGo2AgwgAkEBNgIUIAJBlPCHATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAgLIAIgADYCDCACQQE2AhQgAkGo8IcBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMBwsgAiAAQQRqNgIMIAJBATYCFCACQbzwhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwGCyACIABBBGo2AgwgAkEBNgIUIAJB3PCHATYCECACQgE3AhwgAkH0GzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAULIAIgAEEEajYCDCACQQE2AhQgAkH88IcBNgIQIAJCATcCHCACQfQbNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMBAsgAiAAQQRqNgIMIAJBATYCFCACQZzxhwE2AhAgAkIBNwIcIAJB9Bs2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwDCyABKAIAQaTxhwFBJyABKAIEKAIMEQYADAILIAEoAgBBy/GHAUEqIAEoAgQoAgwRBgAMAQsgAiAAQQRqNgIMIAJBATYCFCACQYzyhwE2AhAgAkIBNwIcIAJB/Rw2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgsgAkEwaiQAC6YLAgN/BH4jAEHgAGsiAiQAAn8CfgJAAkACQAJAAkACQAJAAkAgASgCAEEBaw4HAQIDBAUGBwALIAAgAS0ALDoALCAAIAEoAig2AiggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxAgACABKQMINwMIIAEtAC0hA0EtDAgLIAAgAS0AOjoAOiAAIAEvATg7ATggACABKQMwNwMwIAAgASkDKDcDKCAAIAEpAyA3AyAgACABKQMYNwMYIAAgASkDEDcDECAAIAEpAwg3AwggAS0AOyEDQgEhBUE7DAcLIAAgAS0ASjoASiAAIAEvAUg7AUggACABKQNANwNAIAAgASkDODcDOCAAIAEpAzA3AzAgACABKQMoNwMoIAAgASkDIDcDICAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCABLQBLIQNCAiEFQcsADAYLIAEoAihBAUYEQCACQQhqIAFBNGooAgA2AgAgAiABKQIsNwMAQQEhBAsgASgCOEEBRgRAIAJBGGogAUHEAGooAgA2AgAgAiABKQI8NwMQQQEhAwsgACAENgIoIAAgAikDADcCLCAAIAM2AjggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxAgACABKQMINwMIIABBNGogAkEIaigCADYCACABLQBLIQMgAS0ASiEEIAAgAS8BSDsBSCAAIAQ6AEogAEHEAGogAkEYaigCADYCACAAIAIpAxA3AjxCAyEFQcsADAULIAAgAS0AOjoAOiAAIAEvATg7ATggACABKgI0OAI0IAAgASgCMDYCMCAAIAEqAiw4AiwgACABKAIoNgIoIAAgASkDIDcDICAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCABLQA7IQNCBCEFQTsMBAsgACABLQBKOgBKIAAgAS8BSDsBSCAAIAEpA0A3A0AgACABKQM4NwM4IAAgASkDMDcDMCAAIAEpAyg3AyggACABKwMgOQMgIAAgASkDGDcDGCAAIAErAxA5AxAgACABKQMINwMIIAEtAEshA0IFIQVBywAMAwsgASgCKEEBRgRAAkAgASgCLCIEBEAgAkEgaiABQThqIAEoAjAgASgCNCAEKAIAEQUADAELIAJBADYCIAtBASEECyABKAI8QQFGBEACQCABKAJAIgMEQCACQTBqIAFBzABqIAEoAkQgASgCSCADKAIAEQUADAELIAJBADYCMAtBASEDCyABKAIIQQFGBEAgASkDECEHQgEhBgsgASgCGEEBRgRAIAEpAyAhCEIBIQULIAAgBDYCKCAAIAg3AyAgACAFNwMYIAAgBzcDECAAIAY3AwggACACKQIgNwIsIAAgAzYCPCAAIAIpAzA3A0AgAEE0aiACQShqKQIANwIAIABByABqIAJBOGopAwA3AwAgAS0AUyEDIAEvAVAhBCAAIAEtAFI6AFIgACAEOwFQQgYMAQsgASgCKEEBRgRAAkAgASgCLCIEBEAgAkFAayABQThqIAEoAjAgASgCNCAEKAIAEQUADAELIAJBADYCQAtBASEECyABKAI8QQFGBEACQCABKAJAIgMEQCACQdAAaiABQcwAaiABKAJEIAEoAkggAygCABEFAAwBCyACQQA2AlALQQEhAwsgASgCCEEBRgRAIAEpAxAhB0IBIQYLIAEoAhhBAUYEQCABKQMgIQhCASEFCyAAIAQ2AiggACAINwMgIAAgBTcDGCAAIAc3AxAgACAGNwMIIAAgAikCQDcCLCAAIAM2AjwgACACKQNQNwNAIABBNGogAkHIAGopAgA3AgAgAEHIAGogAkHYAGopAwA3AwAgAS0AUyEDIAEvAVAhBCAAIAEtAFI6AFIgACAEOwFQQgcLIQVB0wALIABqIAM6AAAgACAFNwMAIAJB4ABqJAALqgsCBX8EfiMAQfABayIEJAAgAUEMahDbPCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAUQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASACIAynIAmnaiIHQQJ0ajUCACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAlCACALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQEMBwsgBEHAAWogCSADEI0QIAQoAsABIgFBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgAjUCACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIApCACAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghAQwDCyAEQegAaiAKIAMQjRAgBCgCaCIBQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQegAaiICEJcpIARB0ABqIgEoAgAhBiAEKAJUIQMgASAEQfAAaiIFKQIANwMAIAQpA0ghCSAEIAQpAmg3A0ggBEEANgJYIAQgCTcCdCAEQQA2AnAgBCADNgJsIAQgBjYCaCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogBEH4AGoiBygCADYCACAEIAM2AsgBIAQgBjYCxAEgBCABNgLAASAEQdwAaiIBIARBwAFqEOQZIAcgBEFAaykCADcDACAFIARBOGopAgA3AwAgBCAEKQIwNwNoIAAgASACEMYdIARByABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQcgAahDPLyAEKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBMGoQ+x4LIARB8AFqJAALqgsCBX8EfiMAQfABayIEJAAgAUEMahDZPCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAUQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASACIAynIAmnaiIHQQF0ajMBACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAlCACALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQEMBwsgBEHAAWogCSADEI0QIAQoAsABIgFBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgAjMBACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIApCACAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghAQwDCyAEQegAaiAKIAMQjRAgBCgCaCIBQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiACQQJqIQIgCCAFQQFqIgVHDQALCyAEQegAaiICEJcpIARB0ABqIgEoAgAhBiAEKAJUIQMgASAEQfAAaiIFKQIANwMAIAQpA0ghCSAEIAQpAmg3A0ggBEEANgJYIAQgCTcCdCAEQQA2AnAgBCADNgJsIAQgBjYCaCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAmg3AgggAUEQaiAFKQIANwIAIAFBGGogBEH4AGoiBygCADYCACAEIAM2AsgBIAQgBjYCxAEgBCABNgLAASAEQdwAaiIBIARBwAFqEOQZIAcgBEFAaykCADcDACAFIARBOGopAgA3AwAgBCAEKQIwNwNoIAAgASACEMYdIARByABqEM8vDAILQQRBHBCjPQALIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQcgAahDPLyAEKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBMGoQ+x4LIARB8AFqJAALqQsCBX8EfiMAQfABayIEJAAgAUEMaigCCCEIIARBMGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJQIAQgBTYCTCAEQcAANgJIIAcEQCAGQQAgB/wLAAsgBCAINgJYIAQgBzYCVCAEKAIwRQ0DIAQoAkQgBCgCQEYNBCAEQegAaiAEQTBqEMg0IARBiAFqIQcgAy0AACEDIAIpAwAhCyABKAIQIQEDQAJAIAQpA5ABIgpQRQRAIAQpA5gBIQkMAQsDQAJ+AkAgBCkDeCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwN4IAmnQQFxRQ0AIAQgBCkDgAE3A8gBDAELIAQoAogBRQ0BIARBwAFqIAcQtiogBCkDwAEhCQsgCUIAUg0CCyAEQgM3A3gLIAQpA2giCUICUQ0JIARCADcDaCAEKQNwDAELIAQpA8gBCyEKIAmnQQFxRQ0HIAQgBCkDmAFCQH0iCTcDmAEgBCAKNwOQASAKUA0ACwsgBCAKQgEgCnoiDIaFNwOQASABIAynIAmnaiICajAAACEJIAQgCzcD6AEgBCAJNwOgASAEQSBqIAkgCUI/hyALIAtCP4cQqB4gBCkDKCAEKQMgIglCP4dSBEAgBEECNgLEASAEQayQ/wA2AsABIARCAjcCzAEgBEGGDDYC5AEgBEGGDDYC3AEgBCAEQdgBajYCyAEgBCAEQegBajYC4AEgBCAEQaABajYC2AEgBEGwAWogBEHAAWoQmQ4gBCkCsAEhCSAEKQK4ASEKQYiAgIB4IQUMBwsgBEHAAWogCSADEI0QIAQoAsABIgVBk4CAgHhHBEAgBCkCzAEhCiAEKQLEASEJDAcFIAYgAkEDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEBA0AgASACajAAACEKIAQgCTcD2AEgBCAKNwPoASAEQRBqIAogCkI/hyAJIAlCP4cQqB4gBCkDGCAEKQMQIgpCP4dSBEAgBEECNgJsIARBrJD/ADYCaCAEQgI3AnQgBEGGDDYCuAEgBEGGDDYCsAEgBCAEQawBajYCcCAEIARB2AFqNgK0ASAEIARB6AFqNgKsASAEQcQBaiAEQegAahCZDiAEKQLEASEJIAQpAswBIQpBiICAgHghBQwDCyAEQegAaiAKIAMQjRAgBCgCaCIFQZOAgIB4RwRAIAQpAnQhCiAEKQJsIQkMAwsgBiAKNwMAIAZBCGohBiAIIAFBAWoiAUcNAAsLIARB6ABqIgIQlykgBEHQAGoiASgCACEGIAQoAlQhAyABIARB8ABqIgUpAgA3AwAgBCkDSCEJIAQgBCkCaDcDSCAEQQA2AlggBCAJNwJ0IARBADYCcCAEIAM2AmwgBCAGNgJoIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCaDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQfgAaiIHKAIANgIAIAQgAzYCyAEgBCAGNgLEASAEIAE2AsABIARB3ABqIgEgBEHAAWoQ5BkgByAEQUBrKQIANwMAIAUgBEE4aikCADcDACAEIAQpAjA3A2ggACABIAIQxh0gBEHIAGoQzy8MAgtBBEEcEKM9AAsgACAKNwIQIAAgCTcCCCAAIAU2AgQgAEEpOgAAIARByABqEM8vIAQoAjAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEwahD7HgsgBEHwAWokAAvUCgIJfwN+IwBBkAFrIgMkACABQQxqENs8IQcgA0EIaiABEJI2EO4lIAdBBHQiBCEFAkACQAJAAkACQAJAAkACQCAEQTBxIgYEQCAEIAZrQUBrIgUgBEkNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyADIAY2AiggAyAFNgIkIANBwAA2AiAgBARAIAZBACAE/AsACyADIAc2AjAgAyAENgIsIAMoAghFDQMgAygCHCADKAIYRg0EIANBQGsgA0EIahDINCADQeAAaiEIIAIoAgghCSACKAIAIQUgASgCECEKAkADQAJAIAMpA2giDVBFBEAgAykDcCEMDAELA0ACfgJAIAMpA1AiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDUCAMp0EBcUUNACADIAMpA1g3A4ABDAELIAMoAmBFDQEgA0H4AGogCBC2KiADKQN4IQwLIAxCAFINAgsgA0IDNwNQCyADKQNAIgxCAlENCiADQgA3A0AgAykDSAwBCyADKQOAAQshDSAMp0EBcUUNCCADIAMpA3BCQH0iDDcDcCADIA03A2ggDVANAAsLIAMgDUIBIA16Ig6GhTcDaEGAgICAeCEBAkAgA0H4AGoCfwJAAkAgCiAOpyAMp2oiC0ECdGooAgAiB0GAgICAeEcgBSgCACgCACICQX9HckUEQEEAIQQMAQsgAkUNAyAHIAcgAm0iASACbGtBACACQX9HGyEEIAdBAE4NAQsgASAEIAUoAggoAgBMawwBCyABIAQgBSgCBCgCAE5qC6wiDCAMQj+HIg0gCS0AABCtDiADKAJ4IgRBk4CAgHhHDQIgBiALQQR0aiIBIA03AwggASAMNwMADAELC0Gsj/8AEOIrAAsgAykCfCEMIAAgAykChAE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQogAigCACEFIAEoAhAhAgNAQYCAgIB4IQEgBSgCACgCACEEIANBQGsCfwJAAkAgAigCACIIQYCAgIB4RgRAQQAhCSAEQX9GDQELIARFDQggCCAIIARtIgEgBGxrQQAgBEF/RxshCSAIQQBODQELIAEgCSAFKAIIKAIATGsMAQsgASAJIAUoAgQoAgBOagusIgwgDEI/hyINIAotAAAQrQ4gAygCQCIEQZOAgIB4Rw0CIAYgDDcDACAGIA03AwggAkEEaiECIAZBEGohBiAHIAtBAWoiC0cNAAsLIANBQGsiAhCXKSADQShqIgEoAgAhBSADKAIsIQYgASADQcgAaiIEKQIANwMAIAMpAyAhDCADIAMpAkA3AyAgA0EANgIwIAMgDDcCTCADQQA2AkggAyAGNgJEIAMgBTYCQCADIAIQ1zsgAygCACEFQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBCkCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAGNgKAASADIAU2AnwgAyABNgJ4IANBNGoiASADQfgAahDiGSAHIANBGGopAgA3AwAgBCADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDLHSADQSBqEM8vDAILIAMpAkQhDCAAIAMpAkw3AhALIAAgDDcCCCAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBrI//ABDiKwALQQRBHBCjPQALwAsCCH8BfiMAQZAEayIDJAAgA0EoaiIEIAEgAigCFBEAACADIANBQGsiBjYCeCADQYACakGWrNiwATYCACADQpas2LDhwoWLFjcD+AEgAyADQfgBaiIFNgL4AwJAAkACQAJAAkACQAJAIAYgBRC7CARAIAUQpwwgA0EgaiAEENw7IAMoAiQiBUECSQ0CIAMoAiAiBSgCDCIHIAcoAgAiBkEBajYCACAGQQBIDQEgAyAHNgJsIAMgBSkCEDcCcCADQRhqIAQQ3DsCQAJAIAMoAhwEQCADQRBqIAMoAhgQxRsgAygCECEJIAMoAhQiCEECdCIEQTxxIgUEQCAEIAQgBWtBQGsiBEsNBwtBwAAhBSAEQcAAENE0RQ0HIAQEQCAEQcAAEK02IgVFDQkLIANCADcChAEgAyAFNgKAASADIAQ2AnxBwAAhCiADQcAANgJ4QQAhBiAIBEAgCEEDdCEEA0AgCSkDACILQoCAgIAIfEL/////D1YNAyAJQQhqIQkgBkEEaiIFIAMoAnwiCEsEQCADQfgAaiAIQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAnwhCCADKAKEASIGQQRqIQULIAUgCEsEfyADQfgAaiAIQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAoQBBSAGCyADKAKAAWogCz4AACADIAMoAoQBQQRqIgY2AoQBIAMgAygCiAFBAWo2AogBIARBCGsiBA0ACyADKAKAASEFIAMoAnghCiADKAJ8IQQLIANB2AJqIgcQlykgA0GAAWogA0HgAmoiCCkCADcDACADIAMpAtgCNwN4IANBADYCiAEgAyAENgLoAiADIAo2AuQCIANBADYC4AIgAyAGNgLcAiADIAU2AtgCIANBCGogBxDXOyADKAIIIQVBHEEEEK02IgRFDQkgBEKBgICAEDcCACAEIAMpAtgCNwIIIARBEGogCCkCADcCACAEQRhqIANB6AJqKAIANgIAIAMgBjYCmAEgAyAFNgKUASADIAQ2ApABIAEgAigCMBEEACEEIAEgAigCJBEEACEBIANBgANqQZSo0KABNgIAIANClKjQoMGChYoUNwL4AiADQgQ3AvACIANCADcC6AIgA0KAgICAwAA3AuACIANBADYC2AIgA0EAOwGwAyADIAQ2AqwDIANBADYClAMgA0EANgKIAyADIAE2AoQDIANB+AFqIgEgByADQZABahD6IyADQYAEaiADQfQAaigCADYCACADIAMpAmw3A/gDIAcgASADQfgDahD6IyABIANB1ABqQQAgAygCVBsQ7iUgA0GcAWoiAiAHIAEQwhkgA0G0A2oiASACEM0cIAcgARCNDEHEAEEEEK02IgFFDQogAUKBgICAEDcCACABQQhqIAdBPPwKAAAgAEGg4f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB+ABqEM8vDAILQQBBAEG46/8AEMMhAAsgA0EFNgL8ASADQcTt/wA2AvgBIANCBDcChAIgA0HMATYC9AIgA0H07f8ANgLwAiADQcwBNgLsAiADQfjs/wA2AugCIANBzAE2AuQCIANB9O3/ADYC4AIgA0HMATYC3AIgA0GY7f8ANgLYAiADIANB2AJqNgKAAiADQfwDaiADQfgBahCZDiAAIAMpAoAENwIIIABBEGogA0GIBGooAgA2AgAgACADKAL8AzYCBCAAQYaAgIB4NgIAIANB+ABqEM8vIAcgBygCACIAQQFrNgIAIABBAUcNACADQewAahD7HgsgA0EoahCAJyADQZAEaiQADwsgA0EANgLYAiADQfgAaiADQfgDaiADQdgCakGY6/8AEKMrCwALQQEgBUGo6/8AEMMhAAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgA0HYAmpBxMj/AEHYwf8AENUeAAtBwAAgBBCjPQALQQRBHBCjPQALQQRBxAAQoz0AC8ALAgh/AX4jAEGQBGsiAyQAIANBKGoiBCABIAIoAhQRAAAgAyADQUBrIgY2AnggA0GAAmpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3A/gBIAMgA0H4AWoiBTYC+AMCQAJAAkACQAJAAkACQCAGIAUQuwgEQCAFEKcMIANBIGogBBDcOyADKAIkIgVBAkkNAiADKAIgIgUoAgwiByAHKAIAIgZBAWo2AgAgBkEASA0BIAMgBzYCbCADIAUpAhA3AnAgA0EYaiAEENw7AkACQCADKAIcBEAgA0EQaiADKAIYEMUbIAMoAhAhCSADKAIUIghBAnQiBEE8cSIFBEAgBCAEIAVrQUBrIgRLDQcLQcAAIQUgBEHAABDRNEUNByAEBEAgBEHAABCtNiIFRQ0JCyADQgA3AoQBIAMgBTYCgAEgAyAENgJ8QcAAIQogA0HAADYCeEEAIQYgCARAIAhBA3QhBANAIAkpAwAiC0KAgICACHxC/////w9WDQMgCUEIaiEJIAZBBGoiBSADKAJ8IghLBEAgA0H4AGogCEEBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJ8IQggAygChAEiBkEEaiEFCyAFIAhLBH8gA0H4AGogCEEBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAKEAQUgBgsgAygCgAFqIAs+AAAgAyADKAKEAUEEaiIGNgKEASADIAMoAogBQQFqNgKIASAEQQhrIgQNAAsgAygCgAEhBSADKAJ4IQogAygCfCEECyADQdgCaiIHEJcpIANBgAFqIANB4AJqIggpAgA3AwAgAyADKQLYAjcDeCADQQA2AogBIAMgBDYC6AIgAyAKNgLkAiADQQA2AuACIAMgBjYC3AIgAyAFNgLYAiADQQhqIAcQ1zsgAygCCCEFQRxBBBCtNiIERQ0JIARCgYCAgBA3AgAgBCADKQLYAjcCCCAEQRBqIAgpAgA3AgAgBEEYaiADQegCaigCADYCACADIAY2ApgBIAMgBTYClAEgAyAENgKQASABIAIoAjARBAAhBCABIAIoAiQRBAAhASADQYADakGYsODAATYCACADQpiw4MCBg4aMGDcC+AIgA0IENwLwAiADQgA3AugCIANCgICAgMAANwLgAiADQQA2AtgCIANBADsBsAMgAyAENgKsAyADQQA2ApQDIANBADYCiAMgAyABNgKEAyADQfgBaiIBIAcgA0GQAWoQ+iMgA0GABGogA0H0AGooAgA2AgAgAyADKQJsNwP4AyAHIAEgA0H4A2oQ+iMgASADQdQAakEAIAMoAlQbEO4lIANBnAFqIgIgByABEMIZIANBtANqIgEgAhDNHCAHIAEQjgxBxABBBBCtNiIBRQ0KIAFCgYCAgBA3AgAgAUEIaiAHQTz8CgAAIABByOv/ADYCCCAAIAE2AgQgAEGTgICAeDYCACADQfgAahDPLwwCC0EAQQBBuOv/ABDDIQALIANBBTYC/AEgA0HE7f8ANgL4ASADQgQ3AoQCIANBzAE2AvQCIANBiO3/ADYC8AIgA0HMATYC7AIgA0H47P8ANgLoAiADQcwBNgLkAiADQYjt/wA2AuACIANBzAE2AtwCIANBmO3/ADYC2AIgAyADQdgCajYCgAIgA0H8A2ogA0H4AWoQmQ4gACADKQKABDcCCCAAQRBqIANBiARqKAIANgIAIAAgAygC/AM2AgQgAEGGgICAeDYCACADQfgAahDPLyAHIAcoAgAiAEEBazYCACAAQQFHDQAgA0HsAGoQ+x4LIANBKGoQgCcgA0GQBGokAA8LIANBADYC2AIgA0H4AGogA0H4A2ogA0HYAmpBmOv/ABCjKwsAC0EBIAVBqOv/ABDDIQALQcjA/wBBI0HswP8AEMskAAtBrMH/AEEpIANB2AJqQcTI/wBB2MH/ABDVHgALQcAAIAQQoz0AC0EEQRwQoz0AC0EEQcQAEKM9AAujCwIFfwR+IwBB8AFrIgQkACABQQxqKAIIIQggBEEwaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AlAgBCAFNgJMIARBwAA2AkggBwRAIAZBACAH/AsACyAEIAg2AlggBCAHNgJUIAQoAjBFDQMgBCgCRCAEKAJARg0EIARB6ABqIARBMGoQyDQgBEGIAWohByADLQAAIQMgAikDACELIAEoAhAhAQNAAkAgBCkDkAEiClBFBEAgBCkDmAEhCQwBCwNAAn4CQCAEKQN4IglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A3ggCadBAXFFDQAgBCAEKQOAATcDyAEMAQsgBCgCiAFFDQEgBEHAAWogBxC2KiAEKQPAASEJCyAJQgBSDQILIARCAzcDeAsgBCkDaCIJQgJRDQkgBEIANwNoIAQpA3AMAQsgBCkDyAELIQogCadBAXFFDQcgBCAEKQOYAUJAfSIJNwOYASAEIAo3A5ABIApQDQALCyAEIApCASAKeiIMhoU3A5ABIAEgDKcgCadqIgJqMQAAIQkgBCALNwPoASAEIAk3A6ABIARBIGogCUIAIAsgC0I/hxCoHiAEKQMoIAQpAyAiCUI/h1IEQCAEQQI2AsQBIARBrJD/ADYCwAEgBEICNwLMASAEQYYMNgLkASAEQYYMNgLcASAEIARB2AFqNgLIASAEIARB6AFqNgLgASAEIARBoAFqNgLYASAEQbABaiAEQcABahCZDiAEKQKwASEJIAQpArgBIQpBiICAgHghBQwHCyAEQcABaiAJIAMQjRAgBCgCwAEiBUGTgICAeEcEQCAEKQLMASEKIAQpAsQBIQkMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB6ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQMgAikDACEJIAEoAhAhAkEAIQEDQCABIAJqMQAAIQogBCAJNwPYASAEIAo3A+gBIARBEGogCkIAIAkgCUI/hxCoHiAEKQMYIAQpAxAiCkI/h1IEQCAEQQI2AmwgBEGskP8ANgJoIARCAjcCdCAEQYYMNgK4ASAEQYYMNgKwASAEIARBrAFqNgJwIAQgBEHYAWo2ArQBIAQgBEHoAWo2AqwBIARBxAFqIARB6ABqEJkOIAQpAsQBIQkgBCkCzAEhCkGIgICAeCEFDAMLIARB6ABqIAogAxCNECAEKAJoIgVBk4CAgHhHBEAgBCkCdCEKIAQpAmwhCQwDCyAGIAo3AwAgBkEIaiEGIAggAUEBaiIBRw0ACwsgBEHoAGoiAhCXKSAEQdAAaiIBKAIAIQYgBCgCVCEDIAEgBEHwAGoiBSkCADcDACAEKQNIIQkgBCAEKQJoNwNIIARBADYCWCAEIAk3AnQgBEEANgJwIAQgAzYCbCAEIAY2AmggBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJoNwIIIAFBEGogBSkCADcCACABQRhqIARB+ABqIgcoAgA2AgAgBCADNgLIASAEIAY2AsQBIAQgATYCwAEgBEHcAGoiASAEQcABahDkGSAHIARBQGspAgA3AwAgBSAEQThqKQIANwMAIAQgBCkCMDcDaCAAIAEgAhDGHSAEQcgAahDPLwwCC0EEQRwQoz0ACyAAIAo3AhAgACAJNwIIIAAgBTYCBCAAQSk6AAAgBEHIAGoQzy8gBCgCMCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQTBqEPseCyAEQfABaiQAC+MJASF/IwBB0ABrIgUkAEFsIQcCQCADQQpJDQACQCABQQZJDQAgAyACLwAEIgsgAi8AACIIIAIvAAIiCmpqQQZqIglJDQAgACABQQNqQQJ2IgxqIhYgDGoiFyAMaiIOIAAgAWoiGEsNACAEKAIAIAVBPGogAkEGaiICIAgQ3RMiB0GIf0sNASAFQShqIAIgCGoiAiAKEN0TIgdBiH9LDQEgBUEUaiACIApqIgIgCxDdEyIHQYh/Sw0BIAUgAiALaiADIAlrEN0TIgdBiH9LDQEgBEEEaiEIQRB2IR0CfyAYIA5rQQRJBEAgFyEEIBYhAiAODAELIBhBA2shHiAMQQF0IR8gDEEDbCEgQQAgHWtBH3EhCiAFKAIIIQ0gBSgCHCEPIAUoAjAhECAFKAJEIREgBSgCBCEEIAUoAhghAyAFKAIsIQcgBSgCQCELIAUoAhAhISAFKAIkISIgBSgCOCEjIAUoAkwhJCAFKAIAIRIgBSgCFCETIAUoAighFCAFKAI8IRVBACEJA0ACQCAAIAxqIQIgCUEBcQ0AIAAgIGoiCSAeTw0AIAggFSALdCAKdkEBdGoiBi0AACEZIAAgBi0AAToAACAIIBQgB3QgCnZBAXRqIgYtAAAhGiACIAYtAAE6AAAgCCATIAN0IAp2QQF0aiIGLQAAIRsgACAfaiIcIAYtAAE6AAAgCCASIAR0IAp2QQF0aiIGLQAAISUgCSAGLQABOgAAIAggFSALIBlqIgt0IAp2QQF0aiIGLQAAIRkgAEEBaiAGLQABOgAAIAggFCAHIBpqIgd0IAp2QQF0aiIGLQAAIRogAkEBaiAGLQABOgAAIAggEyADIBtqIgN0IAp2QQF0aiICLQAAIQYgHEEBaiACLQABOgAAIAggEiAEICVqIht0IAp2QQF0aiICLQAAIRwgCUEBaiACLQABOgAAIAsgGWohAkEDIQQCfyARICRJBEBBAyEJIAIMAQsgESACQQN2ayIRKAAAIRVBACEJIAJBB3ELIQsgByAaaiECIBAgI0kEfyACBSAQIAJBA3ZrIhAoAAAhFEEAIQQgAkEHcQshByADIAZqIQIgBCAJciEGQQMhCQJ/IA8gIkkEQEEDIQQgAgwBCyAPIAJBA3ZrIg8oAAAhE0EAIQQgAkEHcQshAyAbIBxqIQIgBCAGciANICFJBH8gAgUgDSACQQN2ayINKAAAIRJBACEJIAJBB3ELIQQgAEECaiEAIAlyQQBHIQkMAQsLIAUgBzYCLCAFIAs2AkAgBSADNgIYIAUgBDYCBCAFIBE2AkQgBSAQNgIwIAUgDzYCHCAFIA02AgggBSAVNgI8IAUgFDYCKCAFIBM2AhQgBSASNgIAIAAgDEEBdGohBCAAIAxBA2xqCyAAIBZLIAIgF0tyDQBBbCEHIAQgDksNASAAIAVBPGogFiAIIB1B/wFxIgAQ4BggAiAFQShqIBcgCCAAEOAYIAQgBUEUaiAOIAggABDgGCAFIBggCCAAEOAYQWxBbEFsQWxBbEFsQWxBbCABIAUoAgRBIEcbIAUoAgggBSgCDEcbIAUoAhhBIEcbIAUoAhwgBSgCIEcbIAUoAixBIEcbIAUoAjAgBSgCNEcbIAUoAkBBIEcbIAUoAkQgBSgCSEcbIQcMAQtBbCEHCyAFQdAAaiQAIAcL0wkBCX8CQAJAAkAgAEUNAAJAIABBAWsgAkkEQCAAIQUgASEEA0AgByAEKAIAQQBHaiEHIARBBGohBCAFQQFrIgUNAAsgB0EQSQ0CIABBAWohCCAAQQJ0IAFqQQRrIQQDQCAIQQFGDQMgCEEBayEIIAQoAgAgBEEEayEERQ0AC0GAgICABCEEIAghBiABIQVBACEAA0AgBCAFKAIAIgkgBCAJSRsgBCAJGyEEIAVBBGohBSAAIgogCUEARyIJaiEAIAZBAWsiBg0ACyAAQQVJDQIgCEEBa0ECSSAEQQNLciAIIAkgCmprQQVLckUEQCAIQQJrIQpBACEHIAEhBANAAkACQCACIAdHBEAgBCgCAEUNAiAEQQRqIgUoAgBFDQEMAgsgByACQbCT0gAQwyEACyAEQQhqKAIARQ0AIAVBATYCAAsgBEEEaiEEIAogB0EBaiIHRw0ACwsgAEEcSQ0CIANBAEHABfwLAEEAIQcgASgCACIGIQBBACEFA0ACQAJAIAUgCEYiCg0AIAIgBUsEQCABIAVBAnRqKAIAIABHDQEgB0EBaiEHDAILIAUgAkGAk9IAEMMhAAsCQCAARSAHQQVPcUUgAEUgB0EHSXJxRQRAIAVBAWshBANAIARBwAVPDQIgAyAEakEBOgAAIARBAWshBCAHQQFrIgcNAAsLQQEhByAKDQEgAiAFSwRAIAEgBUECdGooAgAhAAwCCyAFIAJBkJPSABDDIQALIARBwAVBoJPSABDDIQALIAUgCE8NAiAFIAUgCElqIgUgCE0NAAsMAQsgAiACQcCT0gAQwyEACyACQQFGDQIgAkECTQ0BIAFBBGshDCAIQQJrIQkgASgCCCABKAIEIAZqakEIdEEDbkGkA2ohB0EAIQVBACEEQQAhBgNAIAYgCEkhCwJAAkAgBiAIRiIKDQACQCAGQcAFSQRAIAMgBmoiAC0AAA0CIAZFDQEgAEEBay0AAEUNAQwCCyAGQcAFQZCS0gAQwyEACyACIAZLBEAgASAGQQJ0aigCACIAQQh0IAdrQdgJakGwE08NASAAIARqIQQgBUEBaiIFQQNNDQIgBEEIdCAFQQF2aiAFbiIAQfgAaiAAIAVBBEYbIQcMAgsgBiACQaCS0gAQwyEACwJAIAVBA01BACAFQQNHIARyGw0AQQEgBCAFQQF2aiAFbiIAIABBAU0bQQAgBBshACAGQQFrIQQgDCAGQQJ0aiEHA0AgAiAESwRAIAcgADYCACAHQQRrIQcgBEEBayEEIAVBAWsiBQ0BDAILCyAEIAJB8JLSABDDIQALAn8gBiAJTwRAQQAgC0UNARogASAGQQJ0aigCAEEIdAwBCwJAAkAgAiAGSwRAIAZBAWoiBSACTw0BIAZBAmoiACACSQ0CIAAgAkHQktIAEMMhAAsgBiACQbCS0gAQwyEACyAFIAJBwJLSABDDIQALIAEgAEECdGooAgAgASAFQQJ0aigCACABIAZBAnRqKAIAampBCHRBA25BpANqCyEHQQAhBEEBIQUgCg0AIAIgBksEQCABIAZBAnRqKAIAIQQMAQsgBiACQeCS0gAQwyEACyAGIAhPDQEgBiALaiIGIAhNDQALCw8LQQJBAkGAktIAEMMhAAtBAUEBQfCR0gAQwyEAC9IKAgl/A34jAEGQAWsiAyQAIAFBDGoQ2zwhByADQQhqIAEQkjYQ7iUgB0ECdCIFIQQCQAJAAkACQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiBCAFSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAMgBjYCKCADIAQ2AiQgA0HAADYCICAFBEAgBkEAIAX8CwALIAMgBzYCMCADIAU2AiwgAygCCEUNAyADKAIcIAMoAhhGDQQgA0FAayADQQhqEMg0IANB4ABqIQcgAigCCCEIIAIoAgAhBSABKAIQIQkCQANAAkAgAykDaCINUEUEQCADKQNwIQwMAQsDQAJ+AkAgAykDUCIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwNQIAynQQFxRQ0AIAMgAykDWDcDgAEMAQsgAygCYEUNASADQfgAaiAHELYqIAMpA3ghDAsgDEIAUg0CCyADQgM3A1ALIAMpA0AiDEICUQ0KIANCADcDQCADKQNIDAELIAMpA4ABCyENIAynQQFxRQ0IIAMgAykDcEJAfSIMNwNwIAMgDTcDaCANUA0ACwsgAyANQgEgDXoiDoaFNwNoQYCAgIB4IQECQCADQfgAagJ/AkACQCAJIA6nIAynakECdCIKaigCACIEQYCAgIB4RyAFKAIAKAIAIgJBf0dyRQRAQQAhAgwBCyACRQ0DIAQgBCACbSIBIAJsa0EAIAJBf0cbIQIgBEEATg0BCyABIAIgBSgCCCgCAExrDAELIAEgAiAFKAIEKAIATmoLIgEgCC0AABDqDyADKAJ4IgRBk4CAgHhHDQIgBiAKaiABNgIADAELC0Gsj/8AEOIrAAsgACADKQKAATcCDCAAQRRqIANBiAFqKAIANgIAIAAgAygCfDYCCAwGC0HAACAEEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCiACKAIAIQUgASgCECECA0BBgICAgHghASAFKAIAKAIAIQQgA0FAawJ/AkACQCACKAIAIghBgICAgHhGBEBBACEJIARBf0YNAQsgBEUNCCAIIAggBG0iASAEbGtBACAEQX9HGyEJIAhBAE4NAQsgASAJIAUoAggoAgBMawwBCyABIAkgBSgCBCgCAE5qCyIBIAotAAAQ6g8gAygCQCIEQZOAgIB4Rw0CIAYgATYCACACQQRqIQIgBkEEaiEGIAcgC0EBaiILRw0ACwsgA0FAayICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANByABqIgYpAgA3AwAgAykDICEMIAMgAykCQDcDICADQQA2AjAgAyAMNwJMIANBADYCSCADIAQ2AkQgAyAFNgJAIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAMpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HQAGoiBygCADYCACADIAQ2AoABIAMgBTYCfCADIAE2AnggA0E0aiIBIANB+ABqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNAIAAgASACEModIANBIGoQzy8MAgsgACADKQJINwIMIABBFGogA0HQAGooAgA2AgAgACADKAJENgIICyAAQSk6AAAgACAENgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBrI//ABDiKwALQQRBHBCjPQALhgsCBX8IfiMAQdABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAXRqLwEAELUuIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACLwEAELUuIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDYPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBA3RqKQMAELMuIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKQMAELMuIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAXRqLwEAEJMtIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACLwEAEJMtIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDbPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAnRqKAIAEJQvIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKAIAEJQvIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDYPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBA3RqKQMAEM4vIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKQMAEM4vIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALhgsCBX8IfiMAQdABayIEJAAgAUEMahDbPCEIIARBCGogARCSNhDuJSAIQQV0IgchBQJAAkACQAJAAkAgB0EgcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSACKQMYIQwgAikDECENIAIpAwghDiACKQMAIQ8gAy0AACECIAEoAhAhAwNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDiAEMAQsgBCgCYEUNASAEQYABaiAFELYqIAQpA4ABIQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOIAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIAQgCkIBIAp6IguGhTcDaCAEQbABaiIBIAMgC6cgCadqIgdBAnRqKAIAEMktIARBgAFqIAQpA7ABIAQpA7gBIAQpA8ABIAQpA8gBIA8gDiANIAwQnAYgBCgCgAFFBEAgASAEKQOQASIJIAQpA5gBIgogBCkDoAEiCyAEKQOoASIQIAIQ0A4gBCgCsAEiAUGTgICAeEcEQCAEKQK8ASEJIAQpArQBIQoMCAsgBiAHQQV0aiIBIBA3AxggASALNwMQIAEgCjcDCCABIAk3AwAMAQsgBCgChAEiAUGTgICAeEYNAAsgBCkDkAEhCSAEKQOIASEKDAULQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDGCEJIAIpAxAhCiACKQMIIQwgAikDACENIAMtAAAhAyABKAIQIQJBACEFA0AgBEGAAWoiASACKAIAEMktIARBQGsgBCkDgAEgBCkDiAEgBCkDkAEgBCkDmAEgDSAMIAogCRCcBgJAAkAgBCgCQEUEQCABIAQpA1AiDiAEKQNYIg8gBCkDYCILIAQpA2giECADENAOIAQoAoABIgFBk4CAgHhGDQEgBCkCjAEhCSAEKQKEASEKDAULIAQoAkQiAUGTgICAeEYNASAEKQNQIQkgBCkDSCEKDAQLIAZBGGogEDcDACAGQRBqIAs3AwAgBiAPNwMIIAYgDjcDAAsgBkEgaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBTYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALjwsBB38jAEGwAmsiAiQAIAJBADYCmAIgAkKAgICAEDcCkAIgAkH4AGoiBCACQZACaiIDEOcVIAJBIGpCADcDACACQShqQgA3AwAgAkHEAGpCADcCACACQcwAakIANwIAIAJB1ABqQgA3AgAgAkEYaiACQYABaikDADcDACACQQA6AGAgAkIANwI8IAJBADYCMCACQgE3AjQgAkEANgIIIAJBADYCXCACIAIpA3g3AxAgAyABQQxqIgcgASgCBCABKAIIIAEoAgAoAgARBQAgBCACQQhqIAMQuAQCQAJAAkACQAJAIAIoAngiA0EIRwRAIAAgAikCfDcCDCAAQRxqIAJBjAFqKAIANgIAIABBFGogAkGEAWopAgA3AgAgAEEBNgIAIAAgAzYCCAwBCyACIAIoAkAiBDYCaCACQewAakEAIARB7ITNABCzFSACQfgAaiACQQhqIAIoAnAgAigCdCIGEOgJIAIoAnwhAwJAIAIoAngiBUEIRwRAIAAgAikDgAE3AxAgAEEYaiACQYgBaikDADcDACAAIAM2AgwgACAFNgIIIABBATYCAAwBCyACIAM2ApACIAMgBEcNAiACQQA2AoACIAJCgICAgBA3AvgBIAJBkAJqIgQgAkH4AWoiAxDnFSACQZABakIANwMAIAJBmAFqQgA3AwAgAkG0AWpCADcCACACQbwBakIANwIAIAJBxAFqQgA3AgAgAkGIAWogAkGYAmopAwA3AwAgAkEAOgDQASACQgA3AqwBIAJBADYCoAEgAkIBNwKkASACQQA2AnggAkEANgLMASACIAIpA5ACNwOAASADIAEgAkEIahDeHBDqFCAEIAJB+ABqIAMQuAQCQCACKAKQAiIDQQhHBEAgACACKQKUAjcCDCAAQRxqIAJBpAJqKAIANgIAIABBFGogAkGcAmopAgA3AgAgAEEBNgIAIAAgAzYCCAwBCyACIAIoArABIgM2AtwBIAJB4AFqQQAgA0GMhc0AELMVIAJBkAJqIAJB+ABqIAIoAuQBIAIoAugBIgUQ6AkgAigClAIhBAJAIAIoApACIghBCEcEQCAAIAIpA5gCNwMQIABBGGogAkGgAmopAwA3AwAgACAENgIMIAAgCDYCCCAAQQE2AgAMAQsgAiAENgL4ASADIARHDQUgAyACKAJoRgRAIAIgBjYCiAIgAiAFNgKMAiAFIAZHDQcgACABKQIANwIoIAJBmAJqIgMgAkH0AGooAgA2AgAgAkGkAmogAkHoAWooAgA2AgAgAEEwaiABQQhqKQIANwIAIAIgAikCbDcDkAIgAiACKQLgATcCnAIgAkEIaiIBEN4cIQQgAkH4AGoiBhDeHCEFIABBADYCOCAAQQA2AiQgAEKAgICAEDcCHCAAQQA2AgAgAEEUaiACQaACaikDADcCACAAQQxqIAMpAwA3AgAgACACKQOQAjcCBCAAIAQgBWo2AjwgBhCCLSABEIItDAgLIAJBAjYClAIgAkH8hc0ANgKQAiACQgI3ApwCIAJBOzYChAIgAkE7NgL8ASACIAJB+AFqNgKYAiACIAJB3AFqNgKAAiACIAJB6ABqNgL4ASACQewBaiIDIAJBkAJqEJkOIABBDGogAxDdICAAQQE2AgAgAEEANgIIIAMQ3jsLIAJB4AFqEOk7CyACQfgAahCCLQsgAkHsAGoQ6TsLIAJBCGoQgi0gByABKAIEIAEoAgggASgCACgCEBEBAAwDCyACQQA2AnhBACACQZACaiACQegAaiACQfgAakH8hM0AEK8rAAsgAkEANgKQAkEAIAJB+AFqIAJB3AFqIAJBkAJqQZyFzQAQrysACyACQQA2ApACQQAgAkGIAmogAkGMAmogAkGQAmpBrIXNABCvKwALIAJBsAJqJAALmgsCBX8EfiMAQdABayIEJAAgAUEMahDYPCEIIARBEGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AjAgBCAFNgIsIARBwAA2AiggBwRAIAZBACAH/AsACyAEIAg2AjggBCAHNgI0IAQoAhBFDQMgBCgCJCAEKAIgRg0EIARByABqIARBEGoQyDQgBEHoAGohBSADLQAAIQMgAikDACELIAEoAhAhAgNAAkAgBCkDcCIKUEUEQCAEKQN4IQkMAQsDQAJ+AkAgBCkDWCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNYIAmnQQFxRQ0AIAQgBCkDYDcDqAEMAQsgBCgCaEUNASAEQaABaiAFELYqIAQpA6ABIQkLIAlCAFINAgsgBEIDNwNYCyAEKQNIIglCAlENCSAEQgA3A0ggBCkDUAwBCyAEKQOoAQshCiAJp0EBcUUNByAEIAQpA3hCQH0iCTcDeCAEIAo3A3AgClANAAsLIARCASAKeiIMhiAKhTcDcCAEIAIgDKcgCadqQQN0IgdqKQMAIgk3A4ABIAQgCzcDyAEgC1ANBiALQn9SIAlCgICAgICAgICAf1JyRQRAIARBAjYCpAEgBEGYkP8ANgKgASAEQgI3AqwBIARBhgw2AsQBIARBhgw2ArwBIAQgBEG4AWo2AqgBIAQgBEHIAWo2AsABIAQgBEGAAWo2ArgBIARBkAFqIARBoAFqEJkOIAQpApABIQkgBCkCmAEhCkGIgICAeCEBDAgLIARBoAFqIAkgC38iCSADEI0QIAQoAqABIgFBk4CAgHhHBEAgBCkCrAEhCiAEKQKkASEJDAgFIAYgB2ogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgBCACKQMAIgo3A8gBIAQgCTcDuAEgCVANAiAJQn9SIApCgICAgICAgICAf1JyRQRAIARBAjYCTCAEQZiQ/wA2AkggBEICNwJUIARBhgw2ApgBIARBhgw2ApABIAQgBEGMAWo2AlAgBCAEQbgBajYClAEgBCAEQcgBajYCjAEgBEGkAWogBEHIAGoQmQ4gBCkCpAEhCSAEKQKsASEKQYiAgIB4IQEMBAsgBEHIAGogCiAJfyIKIAMQjRAgBCgCSCIBQZOAgIB4RwRAIAQpAlQhCiAEKQJMIQkMBAsgBiAKNwMAIAZBCGohBiACQQhqIQIgCCAFQQFqIgVHDQALCyAEQcgAaiICEJcpIARBMGoiASgCACEGIAQoAjQhAyABIARB0ABqIgUpAgA3AwAgBCkDKCEJIAQgBCkCSDcDKCAEQQA2AjggBCAJNwJUIARBADYCUCAEIAM2AkwgBCAGNgJIIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdgAaiIHKAIANgIAIAQgAzYCqAEgBCAGNgKkASAEIAE2AqABIARBPGoiASAEQaABahDkGSAHIARBIGopAgA3AwAgBSAEQRhqKQIANwMAIAQgBCkCEDcDSCAAIAEgAhDGHSAEQShqEM8vDAMLQQRBHBCjPQALQYeAgIB4IQELIAAgCjcCECAAIAk3AgggACABNgIEIABBKToAACAEQShqEM8vIAQoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEQahD7HgsgBEHQAWokAAv/CgIFfwh+IwBB0AFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBBXQiByEFAkACQAJAAkACQCAHQSBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAIpAxghDCACKQMQIQ0gAikDCCEOIAIpAwAhDyADLQAAIQIgASgCECEDA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOIAQwBCyAEKAJgRQ0BIARBgAFqIAcQtiogBCkDgAEhCQsgCUIAUg0CCyAEQgM3A1ALIAQpA0AiCUICUQ0JIARCADcDQCAEKQNIDAELIAQpA4gBCyEKIAmnQQFxRQ0HIAQgBCkDcEJAfSIJNwNwIAQgCjcDaCAKUA0ACwsgBCAKQgEgCnoiC4aFNwNoIARBsAFqIgEgAyALpyAJp2oiCGotAAAQki0gBEGAAWogBCkDsAEgBCkDuAEgBCkDwAEgBCkDyAEgDyAOIA0gDBCcBiAEKAKAAUUEQCABIAQpA5ABIgkgBCkDmAEiCiAEKQOgASILIAQpA6gBIhAgAhDQDiAEKAKwASIFQZOAgIB4RwRAIAQpArwBIQkgBCkCtAEhCgwICyAGIAhBBXRqIgEgEDcDGCABIAs3AxAgASAKNwMIIAEgCTcDAAwBCyAEKAKEASIFQZOAgIB4Rg0ACyAEKQOQASEJIAQpA4gBIQoMBQtBwAAgBRCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMYIQkgAikDECEKIAIpAwghDCACKQMAIQ0gAy0AACECIAEoAhAhA0EAIQEDQCAEQYABaiIFIAEgA2otAAAQki0gBEFAayAEKQOAASAEKQOIASAEKQOQASAEKQOYASANIAwgCiAJEJwGAkACQCAEKAJARQRAIAUgBCkDUCIOIAQpA1giDyAEKQNgIgsgBCkDaCIQIAIQ0A4gBCgCgAEiBUGTgICAeEYNASAEKQKMASEJIAQpAoQBIQoMBQsgBCgCRCIFQZOAgIB4Rg0BIAQpA1AhCSAEKQNIIQoMBAsgBkEYaiAQNwMAIAZBEGogCzcDACAGIA83AwggBiAONwMACyAGQSBqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKIASAEIAY2AoQBIAQgATYCgAEgBEE0aiIBIARBgAFqEOIZIAcgBEEYaikCADcDACAFIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEM4dIARBIGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAU2AgQgAEEpOgAAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQdABaiQAC/8KAgV/CH4jAEHQAWsiBCQAIAFBDGooAgghCCAEQQhqIAEQkjYQ7iUgCEEFdCIHIQUCQAJAAkACQAJAIAdBIHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCKCAEIAU2AiQgBEHAADYCICAHBEAgBkEAIAf8CwALIAQgCDYCMCAEIAc2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQcgAikDGCEMIAIpAxAhDSACKQMIIQ4gAikDACEPIAMtAAAhAiABKAIQIQMDQAJAIAQpA2giClBFBEAgBCkDcCEJDAELA0ACfgJAIAQpA1AiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDUCAJp0EBcUUNACAEIAQpA1g3A4gBDAELIAQoAmBFDQEgBEGAAWogBxC2KiAEKQOAASEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDiAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEIApCASAKeiILhoU3A2ggBEGwAWoiASADIAunIAmnaiIIai0AABC0LiAEQYABaiAEKQOwASAEKQO4ASAEKQPAASAEKQPIASAPIA4gDSAMEJwGIAQoAoABRQRAIAEgBCkDkAEiCSAEKQOYASIKIAQpA6ABIgsgBCkDqAEiECACENAOIAQoArABIgVBk4CAgHhHBEAgBCkCvAEhCSAEKQK0ASEKDAgLIAYgCEEFdGoiASAQNwMYIAEgCzcDECABIAo3AwggASAJNwMADAELIAQoAoQBIgVBk4CAgHhGDQALIAQpA5ABIQkgBCkDiAEhCgwFC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAxghCSACKQMQIQogAikDCCEMIAIpAwAhDSADLQAAIQIgASgCECEDQQAhAQNAIARBgAFqIgUgASADai0AABC0LiAEQUBrIAQpA4ABIAQpA4gBIAQpA5ABIAQpA5gBIA0gDCAKIAkQnAYCQAJAIAQoAkBFBEAgBSAEKQNQIg4gBCkDWCIPIAQpA2AiCyAEKQNoIhAgAhDQDiAEKAKAASIFQZOAgIB4Rg0BIAQpAowBIQkgBCkChAEhCgwFCyAEKAJEIgVBk4CAgHhGDQEgBCkDUCEJIAQpA0ghCgwECyAGQRhqIBA3AwAgBkEQaiALNwMAIAYgDzcDCCAGIA43AwALIAZBIGohBiAIIAFBAWoiAUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBiAEKAIsIQMgASAEQcgAaiIFKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBjYCQCAEIAIQ1zsgBCgCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AogBIAQgBjYChAEgBCABNgKAASAEQTRqIgEgBEGAAWoQ4hkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQzh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgBTYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARB0AFqJAALzQoCBn8EfiMAQZABayIDJAAgAUEMahDYPCEHIANBCGogARCSNhDuJSAHQQN0IgUhBAJAAkACQAJAAkACQAJAAkAgBUE4cSIGBEAgBSAGa0FAayIEIAVJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAyAGNgIoIAMgBDYCJCADQcAANgIgIAUEQCAGQQAgBfwLAAsgAyAHNgIwIAMgBTYCLCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQUBrIANBCGoQyDQgA0HgAGohBSACKAIIIQcgAigCACEEIAEoAhAhAQJAA0ACQCADKQNoIgpQRQRAIAMpA3AhCQwBCwNAAn4CQCADKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAyAJUK1CAYY3A1AgCadBAXFFDQAgAyADKQNYNwOAAQwBCyADKAJgRQ0BIANB+ABqIAUQtiogAykDeCEJCyAJQgBSDQILIANCAzcDUAsgAykDQCIJQgJRDQogA0IANwNAIAMpA0gMAQsgAykDgAELIQogCadBAXFFDQggAyADKQNwQkB9Igk3A3AgAyAKNwNoIApQDQALCyADIApCASAKeiILhoU3A2hCgICAgICAgICAfyEMAkAgA0H4AGoCfgJAAkAgASALpyAJp2pBA3QiCGopAwAiC0KAgICAgICAgIB/UiAEKAIAKQMAIglCf1JyRQRAQgAhCgwBCyAJUA0DIAsgCyAJfyIMIAl+fUIAIAlCf1IbIQogC0IAWQ0BCyAMIAogBCgCCCkDAFetfQwBCyAMIAogBCgCBCkDAFmtfAsiCSAHLQAAEI0QIAMoAngiAkGTgICAeEcNAiAGIAhqIAk3AwAMAQsLQbyP/wAQ4isACyADKQJ8IQkgACADKQKEATcCEAwGC0HAACAEEKM9AAtB3Iv/AEEpIANBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIoAgghCCACKAIAIQUgASgCECEEQQAhAQNAQoCAgICAgICAgH8hDCAFKAIAKQMAIQkgA0FAawJ+AkACQCAEKQMAIgpCgICAgICAgICAf1EEQEIAIQsgCUJ/UQ0BCyAJUA0IIAogCiAJfyIMIAl+fUIAIAlCf1IbIQsgCkIAWQ0BCyAMIAsgBSgCCCkDAFetfQwBCyAMIAsgBSgCBCkDAFmtfAsiCSAILQAAEI0QIAMoAkAiAkGTgICAeEcNAiAGIAk3AwAgBEEIaiEEIAZBCGohBiAHIAFBAWoiAUcNAAsLIANBQGsiAhCXKSADQShqIgEoAgAhBSADKAIsIQQgASADQcgAaiIGKQIANwMAIAMpAyAhCSADIAMpAkA3AyAgA0EANgIwIAMgCTcCTCADQQA2AkggAyAENgJEIAMgBTYCQCADIAIQ1zsgAygCACEFQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASADKQJANwIIIAFBEGogBikCADcCACABQRhqIANB0ABqIgcoAgA2AgAgAyAENgKAASADIAU2AnwgAyABNgJ4IANBNGoiASADQfgAahDkGSAHIANBGGopAgA3AwAgBiADQRBqKQIANwMAIAMgAykCCDcDQCAAIAEgAhDGHSADQSBqEM8vDAILIAMpAkQhCSAAIAMpAkw3AhALIAAgCTcCCCAAQSk6AAAgACACNgIEIANBIGoQzy8gAygCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQhqEPseCyADQZABaiQADwtBvI//ABDiKwALQQRBHBCjPQALtgoCCX8DfiMAQZABayIDJAAgAUEMahDbPCEHIANBCGogARCSNhDuJSAHQQN0IgQhBQJAAkACQAJAAkACQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIFIARJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgAyAGNgIoIAMgBTYCJCADQcAANgIgIAQEQCAGQQAgBPwLAAsgAyAHNgIwIAMgBDYCLCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQUBrIANBCGoQyDQgA0HgAGohCCACKAIIIQkgAigCACEFIAEoAhAhCgJAA0ACQCADKQNoIg1QRQRAIAMpA3AhDAwBCwNAAn4CQCADKQNQIgxCA1IEQAJAAkACQCAMQgJRDQAgAyAMUK1CAYY3A1AgDKdBAXFFDQAgAyADKQNYNwOAAQwBCyADKAJgRQ0BIANB+ABqIAgQtiogAykDeCEMCyAMQgBSDQILIANCAzcDUAsgAykDQCIMQgJRDQogA0IANwNAIAMpA0gMAQsgAykDgAELIQ0gDKdBAXFFDQggAyADKQNwQkB9Igw3A3AgAyANNwNoIA1QDQALCyADIA1CASANeiIOhoU3A2hBgICAgHghAQJAIANB+ABqAn8CQAJAIAogDqcgDKdqIgtBAnRqKAIAIgdBgICAgHhHIAUoAgAoAgAiAkF/R3JFBEBBACEEDAELIAJFDQMgByAHIAJtIgEgAmxrQQAgAkF/RxshBCAHQQBODQELIAEgBCAFKAIIKAIATGsMAQsgASAEIAUoAgQoAgBOagusIgwgCS0AABCNECADKAJ4IgRBk4CAgHhHDQIgBiALQQN0aiAMNwMADAELC0Gsj/8AEOIrAAsgAykCfCEMIAAgAykChAE3AhAMBgtBwAAgBRCjPQALQdyL/wBBKSADQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACACKAIIIQogAigCACEFIAEoAhAhAgNAQYCAgIB4IQEgBSgCACgCACEEIANBQGsCfwJAAkAgAigCACIIQYCAgIB4RgRAQQAhCSAEQX9GDQELIARFDQggCCAIIARtIgEgBGxrQQAgBEF/RxshCSAIQQBODQELIAEgCSAFKAIIKAIATGsMAQsgASAJIAUoAgQoAgBOagusIgwgCi0AABCNECADKAJAIgRBk4CAgHhHDQIgBiAMNwMAIAJBBGohAiAGQQhqIQYgByALQQFqIgtHDQALCyADQUBrIgIQlykgA0EoaiIBKAIAIQUgAygCLCEGIAEgA0HIAGoiBCkCADcDACADKQMgIQwgAyADKQJANwMgIANBADYCMCADIAw3AkwgA0EANgJIIAMgBjYCRCADIAU2AkAgAyACENc7IAMoAgAhBUEcQQQQrTYiAUUNBCABQoGAgIAQNwIAIAEgAykCQDcCCCABQRBqIAQpAgA3AgAgAUEYaiADQdAAaiIHKAIANgIAIAMgBjYCgAEgAyAFNgJ8IAMgATYCeCADQTRqIgEgA0H4AGoQ5BkgByADQRhqKQIANwMAIAQgA0EQaikCADcDACADIAMpAgg3A0AgACABIAIQxh0gA0EgahDPLwwCCyADKQJEIQwgACADKQJMNwIQCyAAIAw3AgggAEEpOgAAIAAgBDYCBCADQSBqEM8vIAMoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EIahD7HgsgA0GQAWokAA8LQayP/wAQ4isAC0EEQRwQoz0AC/YMAhJ/AX4jAEHAAWsiAiQAIAFBGGohDwJAAkACQAJAIAEtABhBIUYEQAJAIAEtABkEQCACQShqIAEQ3DsgAigCLA0BQQBBAEHghoYBEMMhAAsgAkEwaiABENw7IAIoAjRFDQIgAigCMCIEKAIAIgYgBigCACIDQQFqNgIAIANBAEgNBCACIAY2AkggAiAEKQIENwJMIAJBkAFqIAJByABqIAEoAiggASgCJBDdJgwDCyACKAIoIgQoAgAiBiAGKAIAIgNBAWo2AgAgA0EASA0DIAIgBjYCSCACIAQpAgQ3AkwgAkGoAWogAkHIAGoiBiABKAIoIAEoAiQQ3SYgAkEgaiABENw7IAIoAiQiA0EBSwRAIAIoAiAiBCgCDCIOIA4oAgAiA0EBajYCACADQQBIDQQgAiAONgJIIAIgBCkCEDcCTCACQbQBaiAGIAEoAiggASgCJBCAHSACQZgBaiACQbABaigCADYCACACIAIpAqgBNwOQASACKAK0ASEOIAIpArgBIRQMAwtBASADQfCGhgEQwyEACyACIA82AqgBIAJBATYCTCACQdSHhgE2AkggAkIBNwJUIAJBpwQ2ArgBIAIgAkG0AWo2AlAgAiACQagBajYCtAEgAkHIAGpB3IeGARDvLAwCC0EAQQBB0IaGARDDIQALIAJBGGogAUEcaiINELAuIAIoAhgiBCACKAIcIgNGBH9BAQUgBC0AACEGIAMgBEEIaiIFRwRAIAMgBWtBA3YhDANAIAUsAAAiBCAGwCIDIAMgBEgbIQYgBUEIaiEFIAxBAWsiDA0ACwsgBsBBAWoLIQMjAEEgayIHJAAgB0EUaiADQQBBBEEIEKAYIAcoAhghCSAHKAIUQQFGBEAgCSAHKAIcQYCHhgEQ/S8ACyACQTxqIQYgB0EQaiIEQQA2AgAgByAHKAIcNgIMIAcgCTYCCCMAQRBrIgkkACAJIAI2AgwgCUEANgIIIAdBCGoiCigCACAKKAIIIghrIANJBEAgCiAIIANBBEEIEN4oIAooAgghCAsgCigCBCAIQQN0aiELAkACQCADQQJPBEAgA0EBayIDIAhqIQgDQCALQQA2AgAgC0EEaiACNgIAIAtBCGohCyADQQFrIgMNAAsMAQsgAw0AIAogCDYCCAwBCyALIAI2AgQgC0EANgIAIAogCEEBajYCCAsgCUEQaiQAIAZBCGogBCgCADYCACAGIAcpAgg3AgAgB0EgaiQAIAJBEGogARDvPCACKAIQIQUgAigCFCEEIAJBCGogDRCwLiACKAIMIAIoAgghDCACIAUgBEHEAGxqNgJMIAIgBTYCSCAMa0EDdiIEIAJByABqIgMoAgQgAygCAGtBxABuIgMgAyAESxsiCgRAIAJB1ABqIQsgAkHgAGohCQNAIAwsAAAhByACQZwBaiAFQRhqENcGIAVBKGooAgAhBiAFQSRqKAIAIQQgAkGoAWogBRC+FSACQbQBaiAFQQxqEIALIAVBLGooAgAiCARAIAggCCgCACIDQQFqNgIAIANBAEgNAyAFQTxqKAIAIRAgBUE4aigCACERIAVBNGooAgAhEyAFQUBrKAIAIQ0gBUEwaigCACESCyAJIAIpApwBNwIAIAsgAikCtAE3AgAgCUEIaiACQaQBaigCADYCACACQdAAaiACQbABaigCADYCACALQQhqIAJBvAFqKAIANgIAIAIgBjYCcCACIAQ2AmwgAiACKQKoATcDSCACIA02AogBIAIgEDYChAEgAiARNgKAASACIBM2AnwgAiASNgJ4IAIgCDYCdCACIAJByABqEKABIAIoAkQiAyAHTQ0DIAIoAgQhDSACKAIAIRACQCACKAJAIAdBA3RqIgQoAgAiA0UNACADIAMoAgAiEUEBazYCACARQQFHDQAgBBC7IwsgBCANNgIEIAQgEDYCACAFQcQAaiEFIAxBCGohDCAKQQFrIgoNAAsLIABBDGogDxDXBiAAIBQ3AiggACAONgIkIABBCGogAkHEAGooAgA2AgAgACACKQI8NwIAIAAgAikDkAE3AhggAEEgaiACQZgBaigCADYCACAPEMYMIAEQxScgARDoOyABQQxqIgAQpCwgABD1PAJAIAEoAiwiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEsahD7HgsgAkHAAWokAA8LAAsgByADQZCHhgEQwyEAC70NAgR/An4jAEEwayIDJAAgA0EQaiIEQgA3AwAgA0EYaiIFQgA3AwAgA0EIaiIGIAJBCGopAgA3AwAgAyACKQIANwMAIAFBFGogASgCDCABQRBqIgIoAgAgASgCCCgCEBEBACABQSBqIAUpAwA3AwAgAUEYaiAEKQMANwMAIAIgBikDADcDACABIAMpAwA3AwggAUEBOgBYIAMgAUEIaiICEKUYAkACQAJAIAMoAgBFBEAgA0EmQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQIgAygCCCICQZSlzQBBJvwKAAAgACACrUKAgICA4ASENwMIIAAgATYCBCAAQQI2AgAMAQsgAygCDARAIANBFEEAQQFBARCgGCADKAIEIQIgAygCAEEBRg0DIAMoAggiAUEQakHKpc0AKAAANgAAIAFBCGpBwqXNACkAADcAACABQbqlzQApAAA3AAAgAEEUNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAELIAEgAygCCDYCNCADIAIQpRggAygCAEUEQCADQTFBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBzqXNAEEx/AoAACAAIAKtQoCAgICQBoQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EfQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQRdqQZamzQApAAA3AAAgAUEQakGPps0AKQAANwAAIAFBCGpBh6bNACkAADcAACABQf+lzQApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAELIAEgAygCCDYCPCADIAIQpRggAygCAEUEQCADQSdBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBnqbNAEEn/AoAACAAIAKtQoCAgIDwBIQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EVQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQQ1qQdKmzQApAAA3AAAgAUEIakHNps0AKQAANwAAIAFBxabNACkAADcAACAAQRU2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI4IANBIGogAhCFJiADKQMgIQcgAykDKCEIIwBBEGsiAiQAAkACQAJAIAenQQFxBEAgA0EINgIAIAMgCDcDCAwBCyACQQRqQSdBAEEBQQEQoBggAigCCCEEIAIoAgRBAUYNASACKAIMIgVB2qbNAEEn/AoAACADQSc2AgwgAyAFNgIIIAMgBDYCBCADQQI2AgALIAJBEGokAAwBCyAEIAIoAgxB1P3MABD9LwALIAMoAgAiAkEIRwRAIAMoAgQhASADKQMIIQcgACADKQMQNwMQIAAgBzcDCCAAIAE2AgQgACACNgIADAELIAMpAwgiB0KAgICACHxCgICAgBBUIQQgB6chBSMAQRBrIgIkAAJAAkACQCAEBEAgA0EINgIAIAMgBTYCBAwBCyACQQRqQRVBAEEBQQEQoBggAigCCCEFIAIoAgRBAUYNASACKAIMIgRBDWpBjqfNACkAADcAACAEQQhqQYmnzQApAAA3AAAgBEGBp80AKQAANwAAIANBFTYCDCADIAQ2AgggAyAFNgIEIANBADYCAAsgAkEQaiQADAELIAUgAigCDEHU/cwAEP0vAAsgAygCBCECIAMoAgAiBEEIRwRAIAAgAykDCDcDCCAAQRBqIANBEGopAwA3AwAgACACNgIEIAAgBDYCAAwBCyABQTRqIQQgASACNgIEIAFBATYCAAJAIAEoAjQiAkH/AHFFBEAgAUE8aiIGKAIAIgVFDQEgAiAFIAIgBW4iBWxHBEAgA0ECNgIEIANB0KTNADYCACADQgI3AgwgA0E7NgIsIAMgBjYCKCADQTs2AiQgAyAENgIgIAMgA0EgajYCCCAAQQRqIAMQoRggAEEANgIADAMLIAEgBTYCQCABQgA3AkwgAUEANgIwIAVBH3FFBEAgAEEINgIADAMLIANBATYCBCADQYSkzQA2AgAgA0IBNwIMIANBOzYCJCADIAFBQGs2AiAgAyADQSBqNgIIIABBBGogAxChGCAAQQA2AgAMAgsgA0EBNgIEIANBjKXNADYCACADQgE3AgwgA0E7NgIkIAMgBDYCICADIANBIGo2AgggAEEEaiADEKEYIABBADYCAAwBC0G8o80AEOcrAAsgA0EwaiQADwsgASADKAIIQdT9zAAQ/S8ACyACIAMoAghB1P3MABD9LwALqwwCA38BfiMAQTBrIgMkACADQRBqIgRCADcDACADQRhqIgVCADcDACADQQhqIgYgAkEIaikCADcDACADIAIpAgA3AwAgAUEUaiABKAIMIAFBEGoiAigCACABKAIIKAIQEQEAIAFBIGogBSkDADcDACABQRhqIAQpAwA3AwAgAiAGKQMANwMAIAEgAykDADcDCCABQQE6AFggAyABQQhqIgIQpRgCQAJAAkAgAygCAEUEQCADQSZBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBsMHOAEEm/AoAACAAIAKtQoCAgIDgBIQ3AwggACABNgIEIABBAjYCAAwBCyADKAIMBEAgA0EUQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQMgAygCCCIBQRBqQebBzgAoAAA2AAAgAUEIakHewc4AKQAANwAAIAFB1sHOACkAADcAACAAQRQ2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI0IAMgAhClGCADKAIARQRAIANBMUEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkHqwc4AQTH8CgAAIAAgAq1CgICAgJAGhDcDCCAAIAE2AgQgAEECNgIADAELIAMoAgwEQCADQR9BAEEBQQEQoBggAygCBCECIAMoAgBBAUYNAyADKAIIIgFBF2pBssLOACkAADcAACABQRBqQavCzgApAAA3AAAgAUEIakGjws4AKQAANwAAIAFBm8LOACkAADcAACAAQR82AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAQsgASADKAIINgI8IAMgAhClGCADKAIARQRAIANBJ0EAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkG6ws4AQSf8CgAAIAAgAq1CgICAgPAEhDcDCCAAIAE2AgQgAEECNgIADAELIAMoAgwEQCADQRVBAEEBQQEQoBggAygCBCECIAMoAgBBAUYNAyADKAIIIgFBDWpB7sLOACkAADcAACABQQhqQenCzgApAAA3AAAgAUHhws4AKQAANwAAIABBFTYCDCAAIAE2AgggACACNgIEIABBADYCAAwBCyABIAMoAgg2AjggA0EgaiACEIUmIAMgAykDICADKQMoEKwaIAMoAgAiAkEIRwRAIAMoAgQhASADKQMIIQcgACADKQMQNwMQIAAgBzcDCCAAIAE2AgQgACACNgIADAELIAMpAwgiB0KAgICACHxCgICAgBBUIQQgB6chBSMAQRBrIgIkAAJAAkACQCAEBEAgA0EINgIAIAMgBTYCBAwBCyACQQRqQRVBAEEBQQEQoBggAigCCCEFIAIoAgRBAUYNASACKAIMIgRBDWpBqsPOACkAADcAACAEQQhqQaXDzgApAAA3AAAgBEGdw84AKQAANwAAIANBFTYCDCADIAQ2AgggAyAFNgIEIANBADYCAAsgAkEQaiQADAELIAUgAigCDEHYp84AEP0vAAsgAygCBCECIAMoAgAiBEEIRwRAIAAgAykDCDcDCCAAQRBqIANBEGopAwA3AwAgACACNgIEIAAgBDYCAAwBCyABQTRqIQQgASACNgIEIAFBATYCAAJAIAEoAjQiAkH/AHFFBEAgAUE8aiIGKAIAIgVFDQEgAiAFIAIgBW4iBWxHBEAgA0ECNgIEIANB7MDOADYCACADQgI3AgwgA0E7NgIsIAMgBjYCKCADQTs2AiQgAyAENgIgIAMgA0EgajYCCCAAQQRqIAMQoxggAEEANgIADAMLIAEgBTYCQCABQgA3AkwgAUEANgIwIAVBH3FFBEAgAEEINgIADAMLIANBATYCBCADQaDAzgA2AgAgA0IBNwIMIANBOzYCJCADIAFBQGs2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAgsgA0EBNgIEIANBqMHOADYCACADQgE3AgwgA0E7NgIkIAMgBDYCICADIANBIGo2AgggAEEEaiADEKMYIABBADYCAAwBC0HYv84AEOcrAAsgA0EwaiQADwsgASADKAIIQdinzgAQ/S8ACyACIAMoAghB2KfOABD9LwAL+BECEX8CfiMAQeAAayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4NAQIDBAUGBwgJCgsNDAALIAIgACkDCDcDICACIAApAxA3A1AgAkEDNgI0IAJBgJT+ADYCMCACQgI3AjwgAkE8NgIMIAJBPDYCBCACIAI2AjggAiACQdAAajYCCCACIAJBIGo2AgAgASgCACABKAIEIAJBMGoQywohAAwNCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQdyU/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMDAsgASgCAEH0lP4AQR0gASgCBCgCDBEGACEADAsLIAEoAgBBkZX+AEEmIAEoAgQoAgwRBgAhAAwKCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQYSW/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMCQsgAiAAKQMINwMYIAIgACkDEDcDICACIAApAxg3A1AgAkEENgIEIAJB+Jb+ADYCACACQgM3AgwgAkE8NgJEIAJBPDYCPCACQTw2AjQgAiACQTBqNgIIIAIgAkHQAGo2AkAgAiACQSBqNgI4IAIgAkEYajYCMCABKAIAIAEoAgQgAhDLCiEADAgLIAIgACkDCDcDICACIAApAxA3A1AgAkEDNgI0IAJBzJf+ADYCMCACQgI3AjwgAkE8NgIMIAJBPDYCBCACIAI2AjggAiACQdAAajYCCCACIAJBIGo2AgAgASgCACABKAIEIAJBMGoQywohAAwHCyACIAApAwg3AyAgAiAAKQMQNwNQIAJBAzYCNCACQZyY/gA2AjAgAkICNwI8IAJBPDYCDCACQTw2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMBgsgAiAAKQMINwMgIAIgACkDEDcDUCACQQM2AjQgAkGAmf4ANgIwIAJCAjcCPCACQTw2AgwgAkE8NgIEIAIgAjYCOCACIAJB0ABqNgIIIAIgAkEgajYCACABKAIAIAEoAgQgAkEwahDLCiEADAULIAIgAC0AAToAUCACQQI2AjQgAkHsmf4ANgIwIAJCATcCPCACQbsHNgIEIAIgAjYCOCACIAJB0ABqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMBAsgAiAAKAIIIgMgACgCDGo2AkwgAiADNgJIIAJBADYCPCACQQA2AjAgAkHYAGoiDkEANgIAIAJCgICAgBA3AlAjAEEgayIAJAAgAkEwaiIDKAIcIQUgAygCGCEHIAMvARYhBiADKAIQIQggAy8BCiEJIAMoAgQhCiADLQAVIgsgAy0AFCIMa0H/AXFBACADKAIMIg1BAXEbIAMtAAkiDyADLQAIIhBrQf8BcUEAIAMoAgAiA0EBcRtqIhEgAkHQAGoiBCgCACAEKAIIIhJrSwRAIAQgEiARQQFBARDQKAsgACAFNgIcIAAgBzYCGCAAIAY7ARYgACALOgAVIAAgDDoAFCAAIAg2AhAgACANNgIMIAAgCTsBCiAAIA86AAkgACAQOgAIIAAgCjYCBCAAIAM2AgAjAEEgayIDJAAgACgCHCEFIAAoAhghByAAKQIQIRMgACgCDCEKIAApAgQhFCAAKAIAIQYgAyAENgIMAkAgBkEBcUUNACADIBQ3AxAgAyADQQxqNgIcIBRCIIinQf8BcSIEIBRCKIinQf8BcSIGTw0AA0AgA0EcaiADQRBqIARqLQAAEKQdIARBAWoiBEH/AXEgBkcNAAsLIAcEQEEAIQYjAEEQayIEJAAgBSAHRwRAIANBDGohCyAFIAdrIQwDQCAGIAdqLQAAIghBjYqKAWosAAAiDUH/AHEhBSAEQQRqIgkCf0EBIA1BAE4NABogBUUEQCAIQfABcUEEdkGu7YkBai0AAEEQdCAIQQ9xQa7tiQFqLQAAQRh0ckHc8AFyIQVBBAwBCyAFQQh0QdwAciEFQQILOgAFIAlBADoABCAJIAU2AgAgBCALNgIMIAQtAAgiBSAELQAJIghJBEADQCAEQQxqIARBBGogBWotAAAQpB0gCCAFQQFqIgVHDQALCyAGQQFqIgYgDEcNAAsLIARBEGokAAsCQCAKQQFxRQ0AIAMgEzcDECADIANBDGo2AhwgE0IgiKdB/wFxIgQgE0IoiKdB/wFxIgVPDQADQCADQRxqIANBEGogBGotAAAQpB0gBEEBaiIEQf8BcSAFRw0ACwsgA0EgaiQAIABBIGokACACQShqIA4oAgA2AgAgAiACKQJQNwMgIAJBqgs2AhwgAkECNgIEIAJBvJr+ADYCACACQgE3AgwgAiACQSBqIgM2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKIQAgA0EBQQEQ4B4MAwsgAiAALQABOgBQIAJBAjYCNCACQfya/gA2AjAgAkIBNwI8IAJBuwc2AgQgAiACNgI4IAIgAkHQAGo2AgAgASgCACABKAIEIAJBMGoQywohAAwCCyACIAAoAgQ2AiAgAiAAKAIINgJQIAJBAzYCNCACQdCc/gA2AjAgAkICNwI8IAJBOzYCDCACQTs2AgQgAiACNgI4IAIgAkHQAGo2AgggAiACQSBqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMAQsgAC0AAUUEQCACIAApAwg3A1AgAkECNgI0IAJBwJv+ADYCMCACQgE3AjwgAkE8NgIEIAIgAjYCOCACIAJB0ABqNgIAIAEoAgAgASgCBCACQTBqEMsKIQAMAQsgAiAAKQMINwNQIAJBAjYCNCACQYic/gA2AjAgAkIBNwI8IAJBPDYCBCACIAI2AjggAiACQdAAajYCACABKAIAIAEoAgQgAkEwahDLCiEACyACQeAAaiQAIAAL2woCD38CfiMAQSBrIgwkACALQQA2AgwgAiAEIAdxIhBqIRQgAyAQayEVIAAoAjQhFyALKQMAIRwgCygCCCESA0AgAiAQIBJqIg9qIRYgDiENAkACQAJAAkACQAJAA0AgDUGEys4Aai0AACIOQRBJBEACQCAGIA5BAnRqKAIAIA1BpMrOAGosAABqIhMgCUsNACAEIA9JIAcgE2siDiAHT3INACAEIA5xIg4gEmoiESAESw0AIAMgD00NAyADIBFNDQQgFi0AACACIBFqLQAARw0AIAMgDkkNBSADIBBJDQYgAiAOaiADIA5rIBQgFSAIELIgIg9BAk0gD0ECRyANQQFLcnENByAcAn4gDyAOIAUQoS4hDiANQQ9NBEAgDUECdEGomtIAajUCACAXrSAOrX58QgKIDAELIA1BEEHomtIAEMMhAAsiG1oNByALIBM2AhAgCyAONgIIIAsgGzcDAEEBIRggDiESIBshHAwHCyANQQFqIg1BEEcNAQwHCwsgDkEQQZTKzgAQwyEACyAPIANBtMrOABDDIQALIBEgA0HEys4AEMMhAAsgDiADQdTKzgAQrzsACyAQIANB5MrOABCvOwALIA1BAWohDiANQQ9JDQELCwJAAn8CQCAIQQNNDQAgECASaiIGIARLDQAgAyAQTwRAIAxBADYCBCAVQQNLBEAgDEEEakEEIBRBBEG02c4AENUsIAAoAgwiDyAMKAIEQb3P1vEBbEERdiINQQh0Ig5PBEAgDyAOa0H/AUsEQCAAKAIEIg8gDUsEQCADIAZLBEAgACgCCCAOQQJ0aiERAkAgACgCACANQQF0aiIPLwEAIg5BgAJrQQAgDkGAAksbIhYgDk8NACACIAZqLQAAIRkDQCAHIBEgDkEBayIGQf8BcUECdGooAgAiDWsiGiAJSw0BAkACQAJAAkACQCAEIA1xIg0gEmoiEyAESw0AIAMgE00NAiAZIAIgE2otAABHDQAgAyANSQ0DIAIgDWogAyANayAUIBUgCBCyICIGQQNNDQQgHCAXrSAGIA0gBRChLiIGrX4gGmdBIGpBP3NB+ABsrX1CgDx8QgKIIhtaDQQgCyAaNgIQIAsgBjYCCCALIBs3AwAgBiAQaiINIARLDQEgAyANSwRAIAIgDWotAAAhGUEBIRggBiESIBshHAwFCyANIANB5MnOABDDIQALIAYiDiAWSw0EDAULIBEgDy0AAEECdGogBzYCAEEBIQ0gDyAPLwEAQQFqOwEADA0LIBMgA0HEyc4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB1MnOABDvLAALIA5BAWsiDiAWSw0ACwsgESAPLQAAQQJ0aiAHNgIAIA8gDy8BAEEBajsBAEEBDAcLIAYgA0G0yc4AEMMhAAsgDSAPQaTJzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakGUyc4AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBhMnOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQaTZzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakH0yM4AEO8sAAtBAQshDSAYDQAgAUUEQEEAIQ0MAQsgAyAQTwRAIAEgACAUIBUgCCAJIAogCxDoFCENDAELIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQfTJzgAQ7ywACyAMQSBqJAAgDQv/CQIHfwN+IwBBkAFrIgIkACABQQxqENs8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIQQJ0aigCALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABKAIAs7wiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUEEaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAv/CQIHfwN+IwBBkAFrIgIkACABQQxqENg8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIQQN0aikDALW8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABKQMAtbwiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUEIaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAulCgERfyMAQYACayIFJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAggEQCAFQSBqIAAoAgQQ3DsgBSgCJCIGIAAoAihBAnQiB08EQCABKAIIRQ0DIAUoAiAhDiAFQRhqIAEoAgQQ3DsgBSgCHCIIIAEoAihBAnQiC0kNAiAHIA5qIQkgBiAHayEMIAUoAhgiDSALaiEKIAggC2shCCAAKAIsRQ0QIAVBEGogAEEsaiIGENw7IAVB6ABqIg8gBSgCECAFKAIUIAAoAjggAmoiECAEEPoTIAVB9AFqIA8Q1QkCQCAFKAL0AUEBRgRAIAUoAvgBDQEgBSgC/AEgBEcNAQwSCyAERQ0RCyAAKAJAuCAAKAIkuKNEmpmZmZmZ2T9mRQRAIAVBCGogBhDcOyAFQShqIgAgBSgCCCAFKAIMIBAgBBD6EyABKAIsRQ0FIAUgAUEsahDcOyAFQagBaiILIAUoAgAgBSgCBCABKAI4IANqIAQQ+hMgBUHoAGogAEHAAPwKAAAgBUIANwPoAQNAIAVB9AFqIgQgBUHoAGoQ1QkCQCAFKAL0AUEBRgRAIAUoAvwBIQAgBSgC+AEhASAEIAsQ1QkgBSgC9AENAQtBASEEDBQLQQAhBCABIAUoAvgBRw0TIAAgBSgC/AFHDRMgACABa0ECdCIAIAEgAmpBAnQiB2oiBiAASQ0HIAYgDEsNCCAAIAEgA2pBAnQiBmoiASAASQ0JIAEgCEsNCiAHIAlqIAAgBiAKaiAAEJ87DQALDBILIAEoAixFDQkCQCAERQRAQQAhAAwBC0EAIQYgASgCPCIJIANrIgpBACAJIApPGyEPIAAoAjwiCSACayIKQQAgCSAKTxshESACQQJ0IglBfHMhEiADQQJ0IgpBfHMhEyABKAI4IANqIRQgDiAHIAlqaiEHIA0gCiALamohCyABKAIwIQEgACgCMCEOQQAhAANAIAAgEUYNDCAAIA9GDQ0CQAJAIA4gACAQaiINQQN2ai0AAEEBIA1BB3F0cSINRQ0AIAEgACAUaiIVQQN2ai0AAEEBIBVBB3F0cUUNACAGIBJGDRAgBiAJakEEaiAMSw0RIAYgE0YNEiAGIApqQQRqIAhLDRMgBiAHakEEIAYgC2pBBBCfOw0BDAMLIA0NAgsgBkEEaiEGIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBAwRCyAHIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgCyAIQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAHIAZB+L2HARCxOwALIAYgDEH4vYcBELA7AAsgBiABQYi+hwEQsTsACyABIAhBiL6HARCwOwALQei9hwEQsjsAC0HovIcBQSBBiL2HARCfKQALQei8hwFBIEGIvYcBEJ8pAAtBfCACQQJ0IAZqQQRqQfi9hwEQsTsACyACQQJ0IAZqQQRqIAxB+L2HARCwOwALQXwgA0ECdCAGakEEakGIvocBELE7AAsgA0ECdCAGakEEaiAIQYi+hwEQsDsACyAEQQJ0IgAgAkECdCICaiIBIABJDQEgASAMSw0CIAAgA0ECdCIDaiIBIABJDQMgASAISw0EIAIgCWogACADIApqIAAQnzshBAsgBUGAAmokACAEDwsgAiABQfi9hwEQsTsACyABIAxB+L2HARCwOwALIAMgAUGIvocBELE7AAsgASAIQYi+hwEQsDsAC6UKARF/IwBBgAJrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIAVBIGogACgCBBDcOyAFKAIkIgYgACgCKEEDdCIHTwRAIAEoAghFDQMgBSgCICEOIAVBGGogASgCBBDcOyAFKAIcIgggASgCKEEDdCILSQ0CIAcgDmohCSAGIAdrIQwgBSgCGCINIAtqIQogCCALayEIIAAoAixFDRAgBUEQaiAAQSxqIgYQ3DsgBUHoAGoiDyAFKAIQIAUoAhQgACgCOCACaiIQIAQQ+hMgBUH0AWogDxDVCQJAIAUoAvQBQQFGBEAgBSgC+AENASAFKAL8ASAERw0BDBILIARFDRELIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgBUEIaiAGENw7IAVBKGoiACAFKAIIIAUoAgwgECAEEPoTIAEoAixFDQUgBSABQSxqENw7IAVBqAFqIgsgBSgCACAFKAIEIAEoAjggA2ogBBD6EyAFQegAaiAAQcAA/AoAACAFQgA3A+gBA0AgBUH0AWoiBCAFQegAahDVCQJAIAUoAvQBQQFGBEAgBSgC/AEhACAFKAL4ASEBIAQgCxDVCSAFKAL0AQ0BC0EBIQQMFAtBACEEIAEgBSgC+AFHDRMgACAFKAL8AUcNEyAAIAFrQQN0IgAgASACakEDdCIHaiIGIABJDQcgBiAMSw0IIAAgASADakEDdCIGaiIBIABJDQkgASAISw0KIAcgCWogACAGIApqIAAQnzsNAAsMEgsgASgCLEUNCQJAIARFBEBBACEADAELQQAhBiABKAI8IgkgA2siCkEAIAkgCk8bIQ8gACgCPCIJIAJrIgpBACAJIApPGyERIAJBA3QiCUF4cyESIANBA3QiCkF4cyETIAEoAjggA2ohFCAOIAcgCWpqIQcgDSAKIAtqaiELIAEoAjAhASAAKAIwIQ5BACEAA0AgACARRg0MIAAgD0YNDQJAAkAgDiAAIBBqIg1BA3ZqLQAAQQEgDUEHcXRxIg1FDQAgASAAIBRqIhVBA3ZqLQAAQQEgFUEHcXRxRQ0AIAYgEkYNECAGIAlqQQhqIAxLDREgBiATRg0SIAYgCmpBCGogCEsNEyAGIAdqQQggBiALakEIEJ87DQEMAwsgDQ0CCyAGQQhqIQYgBCAAQQFqIgBHDQALIAQhAAsgACAETyEEDBELIAcgBkGovYcBEK87AAtBAEEAQZi9hwEQwyEACyALIAhByL2HARCvOwALQQBBAEG4vYcBEMMhAAtB2L2HARCyOwALIAcgBkH4vYcBELE7AAsgBiAMQfi9hwEQsDsACyAGIAFBiL6HARCxOwALIAEgCEGIvocBELA7AAtB6L2HARCyOwALQei8hwFBIEGIvYcBEJ8pAAtB6LyHAUEgQYi9hwEQnykAC0F4IAJBA3QgBmpBCGpB+L2HARCxOwALIAJBA3QgBmpBCGogDEH4vYcBELA7AAtBeCADQQN0IAZqQQhqQYi+hwEQsTsACyADQQN0IAZqQQhqIAhBiL6HARCwOwALIARBA3QiACACQQN0IgJqIgEgAEkNASABIAxLDQIgACADQQN0IgNqIgEgAEkNAyABIAhLDQQgAiAJaiAAIAMgCmogABCfOyEECyAFQYACaiQAIAQPCyACIAFB+L2HARCxOwALIAEgDEH4vYcBELA7AAsgAyABQYi+hwEQsTsACyABIAhBiL6HARCwOwALpQoBEX8jAEGAAmsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIIBEAgBUEgaiAAKAIEENw7IAUoAiQiBiAAKAIoQQF0IgdPBEAgASgCCEUNAyAFKAIgIQ4gBUEYaiABKAIEENw7IAUoAhwiCCABKAIoQQF0IgtJDQIgByAOaiEJIAYgB2shDCAFKAIYIg0gC2ohCiAIIAtrIQggACgCLEUNECAFQRBqIABBLGoiBhDcOyAFQegAaiIPIAUoAhAgBSgCFCAAKAI4IAJqIhAgBBD6EyAFQfQBaiAPENUJAkAgBSgC9AFBAUYEQCAFKAL4AQ0BIAUoAvwBIARHDQEMEgsgBEUNEQsgACgCQLggACgCJLijRJqZmZmZmdk/ZkUEQCAFQQhqIAYQ3DsgBUEoaiIAIAUoAgggBSgCDCAQIAQQ+hMgASgCLEUNBSAFIAFBLGoQ3DsgBUGoAWoiCyAFKAIAIAUoAgQgASgCOCADaiAEEPoTIAVB6ABqIABBwAD8CgAAIAVCADcD6AEDQCAFQfQBaiIEIAVB6ABqENUJAkAgBSgC9AFBAUYEQCAFKAL8ASEAIAUoAvgBIQEgBCALENUJIAUoAvQBDQELQQEhBAwUC0EAIQQgASAFKAL4AUcNEyAAIAUoAvwBRw0TIAAgAWtBAXQiACABIAJqQQF0IgdqIgYgAEkNByAGIAxLDQggACABIANqQQF0IgZqIgEgAEkNCSABIAhLDQogByAJaiAAIAYgCmogABCfOw0ACwwSCyABKAIsRQ0JAkAgBEUEQEEAIQAMAQtBACEGIAEoAjwiCSADayIKQQAgCSAKTxshDyAAKAI8IgkgAmsiCkEAIAkgCk8bIREgAkEBdCIJQX5zIRIgA0EBdCIKQX5zIRMgASgCOCADaiEUIA4gByAJamohByANIAogC2pqIQsgASgCMCEBIAAoAjAhDkEAIQADQCAAIBFGDQwgACAPRg0NAkACQCAOIAAgEGoiDUEDdmotAABBASANQQdxdHEiDUUNACABIAAgFGoiFUEDdmotAABBASAVQQdxdHFFDQAgBiASRg0QIAYgCWpBAmogDEsNESAGIBNGDRIgBiAKakECaiAISw0TIAYgB2pBAiAGIAtqQQIQnzsNAQwDCyANDQILIAZBAmohBiAEIABBAWoiAEcNAAsgBCEACyAAIARPIQQMEQsgByAGQai9hwEQrzsAC0EAQQBBmL2HARDDIQALIAsgCEHIvYcBEK87AAtBAEEAQbi9hwEQwyEAC0HYvYcBELI7AAsgByAGQfi9hwEQsTsACyAGIAxB+L2HARCwOwALIAYgAUGIvocBELE7AAsgASAIQYi+hwEQsDsAC0HovYcBELI7AAtB6LyHAUEgQYi9hwEQnykAC0HovIcBQSBBiL2HARCfKQALQX4gAkEBdCAGakECakH4vYcBELE7AAsgAkEBdCAGakECaiAMQfi9hwEQsDsAC0F+IANBAXQgBmpBAmpBiL6HARCxOwALIANBAXQgBmpBAmogCEGIvocBELA7AAsgBEEBdCIAIAJBAXQiAmoiASAASQ0BIAEgDEsNAiAAIANBAXQiA2oiASAASQ0DIAEgCEsNBCACIAlqIAAgAyAKaiAAEJ87IQQLIAVBgAJqJAAgBA8LIAIgAUH4vYcBELE7AAsgASAMQfi9hwEQsDsACyADIAFBiL6HARCxOwALIAEgCEGIvocBELA7AAv8CQIHfwN+IwBBkAFrIgIkACABQQxqENk8IQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnakEBdCIIai8BALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQEDQCABLwEAs7wiA0H///8DcSEEAkAgA0GAgID8B3EiBkGAgID8B0YEQCAEQQBHQQl0IARBDXZyQYD4AXIhAwwBCyAGQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgBkENdiAEQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAEQYCAgARyIgRBHiADQRd2IgZrdiEDIARBHSAGayIGdkEBcUUNACADQQMgBnRBAWsgBHFBAEdqIQMLIAUgAzsBACAFQQJqIQUgAUECaiEBIAcgCEEBaiIIRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6AsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6AsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ/g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ/g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ5g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ5g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQnA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQnA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ5w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ5w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6hEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6hEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6xEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6xEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ0A0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ0A0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQpw4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQpw4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+A0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+A0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQng4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQng4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ1w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ1w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQvQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQvQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQxA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQxA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7BEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7BEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ2w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ2w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7REMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7REgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7hEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7hEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ6Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ6Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQixIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQixIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjBEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjBEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQhw8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQhw8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlQ4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlQ4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQoREMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQoREgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ/w4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ/w4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQuAsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQuAsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3xAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3xAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8g0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8g0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqA4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqA4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQtQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQtQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqwsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqwsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQqRIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQqRIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+Q0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+Q0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3A4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3A4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQiw0MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQiw0gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ7xEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ7xEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQuQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQuQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ+QwMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ+QwgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9Q4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9Q4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrAsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrAsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjREMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjREgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQgA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQgA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ4BAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ4BAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2jwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ1wsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ1wsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ9g4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ9g4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrxEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrxEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrQsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrQsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQtA8MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQtA8gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ3DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkECdCIFIQMCQCAFQTxxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ3wwMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ3wwgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5RkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjg4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjg4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQlw4MAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQlw4gAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2DwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8BEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8BEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEEdCIFIQMCQCAFQTBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQ8hAMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQ8hAgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQyx0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2TwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQrgsMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQrgsgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGoQ2zwhAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEDdCIFIQMCQCAFQThxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQwBEMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQwBEgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ5BkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQxh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAv/CQIIfwN+IwBB0AFrIgQkACAEIAM2AiAgBCACNgIcIAFBDGooAgghAgJAAkACQAJAAkACQCABEJI2IgUEQEHAACEDIARBEGogBRDcOyAFKAIUIQcgBSgCDCEIIAQoAhQhCiAEKAIQIQkgAkEDdiACQQdxQQBHaiIFQcD///8DcUFAayAFIAVBP3EbIgVBwAAQ0TRFDQYgBQRAIAVBwAAQrTYiA0UNBAsgBEIANwIwIAQgAzYCLCAEIAU2AiggBEHAADYCJCAEQSRqIAggAiAIaiAJIAoQvxgMAQtBwAAhAyACQQN2IAJBB3FBAEdqIgVBwP///wNxQUBrIAUgBUE/cRsiBUHAABDRNEUNBSAFBEAgBUHAABCtNiIDRQ0CCyAEQgA3AjAgBCADNgIsIAQgBTYCKCAEQcAANgIkIARBJGogAhDeEAsgAkEFdCIFIQMCQCAFQSBxIgYEQCAFIAZrQUBrIgMgBUkNAQtBwAAhBiADQcAAENE0BEACQCADBEAgA0HAABCtNiIGRQ0BCyAEQQA2AkggBCAGNgJAIAQgAzYCPCAEQcAANgI4IAUEQCAFBEAgBkEAIAX8CwALIAQoAkghCyAEKAJAIQYLIAQgBTYCRCAEIAIgC2oiAzYCSCAEIAc2AkwgBCADNgJcIAQgBjYCWCAEIAE2AlQgBCAEQSRqNgJkIAQgBEHMAGo2AmAgBCAEQRxqNgJQIAdFDQUgAiAHRg0GIAkEQCAEQYgBaiAJIAogCCACEL8UIARBqAFqIQEDQAJAIAQpA7ABIg1QRQRAIAQpA7gBIQwMAQsDQAJ+AkAgBCkDmAEiDEIDUgRAAkACQAJAIAxCAlENACAEIAxQrUIBhjcDmAEgDKdBAXFFDQAgBCAEKQOgATcDyAEMAQsgBCgCqAFFDQEgBEHAAWogARC2KiAEKQPAASEMCyAMQgBSDQILIARCAzcDmAELIAQpA4gBIgxCAlENDCAEQgA3A4gBIAQpA5ABDAELIAQpA8gBCyENIAynQQFxRQ0KIAQgBCkDuAFCQH0iDDcDuAEgBCANNwOwASANUA0ACwsgBCANQgEgDXoiDoaFNwOwASAEQdAAaiAOpyAMp2oQjBIMAAsAC0HEiv8AELI7AAtBwAAgAxCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBRCjPQALQcAAIAUQoz0ACyACRQ0AQQAhAwNAIARB0ABqIAMQjBIgAiADQQFqIgNHDQALCyAEQegAaiAEQSRqIgcQghQgBEGIAWoiAhCXKSAEQUBrIARBkAFqIgMpAgA3AwAgBCkDOCEMIAQgBCkCiAE3AzggBEEANgJIIAQgDDcClAEgBEEANgKQASAEIAU2AowBIAQgBjYCiAEgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQKIATcCCCABQRBqIAMpAgA3AgAgAUEYaiAEQZgBaiIIKAIANgIAIAQgBTYCWCAEIAY2AlQgBCABNgJQIARB/ABqIgEgBEHQAGoQ4hkgBCgCTCEFIAggBEH4AGooAgA2AgAgAyAEQfAAaikCADcDACAEIAQpAmg3A4gBIAQgBTYCnAEgACABIAIQzh0gBEE4ahDPLyAHEM8vIARB0AFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgBEGIAWpB7I//AEGIjP8AENUeAAuECQIXfwF+IwBBgAJrIhAkACABIAAoAgQiGGsiDkEBIAAoArgBdCIHayAOIAAoAhAiCWsgB0shDSAAKAIYIRFBASAGdCEZIAAoAgwhEiAAKAIIIRwgACgCxAEiByAGSSEaIAAoArQBIQggACkDUCEeIAAoAiQhCiAAKAIoIQsgACgCXCEPAkACQAJ/IAVBA0YEQEEBIAcgBmt0QQAgBiAHSRshEyABIAgoAsABQQJrIAQQox1BAnQhFEEADAELIAVBAkYNAUEACyEWDAELIAgoAlwgCCgCKCABIAgoAiRBCGogBBCjHSIdQQh2IAZ0IhRBAnQhFyAUaiEbIBdqIRdBACEUQQEhFkEAIRMLIAkgDRshDSAHIAYgGhshByAZQQFrIQwCQCAAKALcAUUEQCAAIAEgBCAGIAxBARCwICAAQSxqIBggDiAKIAQgHhCnKCEEDAELIAEgCkEIaiAEIB4Q5iMhBCAAIA42AhwLIAkgDSARGyERIBIgHGohGiASIBhqIQ1BASAHdCEJIAAgACgCWCAEajYCWCAPIARBCHYgBnQiB0ECdGohCkEAIQYgByALaiIHIARB/wFxIAwgBy0AACILcSIPIBkQmBchHgNAAkAgCUUgHlByDQAgHqciFWggHkIgiKdoQSBqIBUbIA9qIAxxIhUEQCAKIBVBAnRqKAIAIhUgEUkNASAQIAZBAnRqIBU2AgAgCUEBayEJIAZBAWohBgsgHkIBfSAegyEeDAELCyAHQQAgDCALQT9qIAxxIgsbIAtqIgs6AAAgByALaiAEOgAAIAAgACgCHCIAQQFqNgIcIAogC0ECdGogADYCAEEDIQAgDkEDaiEPIAFBBGohCyABQQNrIREgECEEA0ACQCAGRQRAIAAhBwwBCwJAAn8gBUEBRiAEKAIAIgogEklxRQRAIAogGGoiByAAakEDaygAACAAIBFqKAAARw0CIAEgByACEIAUDAELIAogHGoiBygAACABKAAARw0BIAsgB0EEaiACIBogDRDNKEEEagsiByAATQ0AIAMgDyAKazYCACAHIgAgAWogAkYNAQsgBEEEaiEEIAZBAWshBgwBCwsCQCAFQQNGBEAgAyAHIAkgE2ogCCABIAIgDSAOIBIgFBCgDSEADAELAkAgFkUNACAIKAIAIQUgCCgCBCEKIAgoAgwhAEEAIQYgGyAdQf8BcSAMIBstAABxIgQgGRCYFyEeA0ACQCAJRSAeUHINACAepyIIaCAeQiCIp2hBIGogCBsgBGogDHEiCARAIBcgCEECdGooAgAiCCAASQ0BIBAgBkECdGogCDYCACAJQQFrIQkgBkEBaiEGCyAeQgF9IB6DIR4MAQsLIAogEmohCCAFIA5qQQNqIQwgECEEA0AgBkUNAQJAIAogBCgCACIJaiIAKAAAIAEoAABHDQAgCyAAQQRqIAIgBSANEM0oQQRqIgAgB00NACADIAwgCCAJams2AgAgACIHIAFqIAJGDQMLIARBBGohBCAGQQFrIQYMAAsACyAHIQALIBBBgAJqJAAgAAv8CQIHfwN+IwBBkAFrIgIkACABQQxqKAIIIQcgAkEQaiABEJI2EO4lIAdBAXQiBCEDAkACQAJAIARBPnEiBQRAIAQgBWtBQGsiAyAESQ0BC0HAACEFIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgVFDQELIAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBUEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQcgASgCECEGIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBxC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcCAGIAunIAmnaiIIai0AALO8IgFB////A3EhAwJAIAFBgICA/AdxIgRBgICA/AdGBEAgA0EAR0EJdCADQQ12ckGA+AFyIQEMAQsgBEGAgIC4BEsEQEGA+AEhAQwBCyABQYCAgMQDTwRAIARBDXYgA0ENdmogAUEMdiABQf/fAHFBAEdxakGAgAFqIQEMAQsgAUGAgICYA0kEQEEAIQEMAQsgA0GAgIAEciIDQR4gAUEXdiIEa3YhASADQR0gBGsiBHZBAXFFDQAgAUEDIAR0QQFrIANxQQBHaiEBCyAFIAhBAXRqIAE7AQAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgB0UNACABKAIQIQhBACEBA0AgASAIai0AALO8IgNB////A3EhBAJAIANBgICA/AdxIgZBgICA/AdGBEAgBEEAR0EJdCAEQQ12ckGA+AFyIQMMAQsgBkGAgIC4BEsEQEGA+AEhAwwBCyADQYCAgMQDTwRAIAZBDXYgBEENdmogA0EMdiADQf/fAHFBAEdxakGAgAFqIQMMAQsgA0GAgICYA0kEQEEAIQMMAQsgBEGAgIAEciIEQR4gA0EXdiIGa3YhAyAEQR0gBmsiBnZBAXFFDQAgA0EDIAZ0QQFrIARxQQBHaiEDCyAFIAM7AQAgBUECaiEFIAcgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhByACKAI0IQUgASACQdAAaiIEKQIANwMAIAIpAyghCSACIAIpAkg3AyggAkEANgI4IAIgCTcCVCACQQA2AlAgAiAFNgJMIAIgBzYCSCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBigCADYCACACIAU2AogBIAIgBzYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgBiACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQzx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvfCQIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiAyEEAkACQAJAIANBOHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEGIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAGIAqnIAinaiIEQQF0ai8BACIBrSEIIAUgBEEDdGoCfiAIQjCGIAFB//8BcUUNABogAUH/B3EhBCAIQv8HgyEKIAhCgIACgyEIIAFBgPgBcSIBQYD4AUYEQCAIQjCGIghCgICAgICAgPj/AIQgBEUNARogCCAKQiqGhEKAgICAgICA/P8AhAwBCyAIQjCGIgggAUEKdkHwB2qtQjSGIApCKoaEhCABDQAaIAogBGciAUEQa0H//wNxQSVqrYZC/////////weDQYYIIAFrrUI0hoQgCIQLNwMADAALAAtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAUCfiAELwEAIgOtIglCMIYgA0H//wFxRQ0AGiADQf8HcSEHIAlC/weDIQggCUKAgAKDIQkgA0GA+AFxIgNBgPgBRgRAIAlCMIYiCUKAgICAgICA+P8AhCAHRQ0BGiAJIAhCKoaEQoCAgICAgID8/wCEDAELIAlCMIYiCSADQQp2QfAHaq1CNIYgCEIqhoSEIAMNABogCCAHZyIDQRBrQf//A3FBJWqthkL/////////B4NBhgggA2utQjSGhCAJhAs3AwAgBUEIaiEFIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEFIAEgAkHQAGoiAykCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBTYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogAykCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAFNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACADIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALtw0BCn8jAEHAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIgA0EQaiIFKAIQTwRAAkACQAJAAkACQAJAIAMoAgBBAWsOBQECAwUFAAsgBEH4AGoiBiADKAI8QQBBAkECEKAYIAQoAnwhAyAEKAJ4QQFGDQYgBEEANgIsIAQgBCgCgAE2AiggBCADNgIkIAYgBRDJNCAEQewAaiAGENUJIAQoAmxBAUYEQANAIAQoAnQiAyAEKAJwIgVJDRAgAiADSQ0RIARBJGogAyAFayIDEO0tIANBAXQiBgRAIAQoAiggBCgCLEEBdGogASAFQQF0aiAG/AoAAAsgBCAEKAIsIANqNgIsIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAAgBEH4AGoQthgMAwsgBEH4AGoiBiAFIAMoAjwQsSYgBEEwaiAGQTj8CgAAIAQoArQBIQMgBCAEKAKwASIIQQF0IgU2AiQgBSEGIAVBPnEiBwRAIAUgB2tBQGsiBiAFSQ0HC0HAACEHIAZBwAAQ0TRFDQcgBgRAIAZBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCEFA0AgBSAEKAK8ASIBTw0LIAMgBCgCuAEgBUEBdGovAQA7AAAgA0ECaiEDIARBEGogBEH4AGoQ1hAgBCgCFCEFIAQoAhBBAXENAAsgBCgCJCEFCyAEIAMgB2siATYCbCABIAVHDQogBCAGNgKIASAEQoCAgICACDcCgAEgBCAFNgJ8IAQgBzYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNCyABQoGAgIAQNwIAIAEgBCkCeDcCCCAAIAU2AgggACACNgIEIAAgATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEFIAMoAgwhAyAEIAI2AoQBIAQgATYCgAEgBCAFIANBAnRqNgJ8IAQgBTYCeCMAQSBrIgIkACACQRRqIARB+ABqIgEoAgQgASgCAGtBAnZBAEECQQIQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBoIKDARD9LwALIARB7ABqIQcgAkEQaiILQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgUgASgCBCABKAIAa0ECdhDtLSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIANBBGoiCCgCBCEFIAgoAgAhDAJAAkAgASgCACIGIAEoAgQiCkcEQCABKAIMIQkgASgCCCENIAgoAgggBUEBdGohASAKIAZrQQJ2IQgDQCAGKAIAIgogCU8NAiABIA0gCkEBdGovAQA7AQAgBkEEaiEGIAFBAmohASAFQQFqIQUgCEEBayIIDQALCyAMIAU2AgAMAQsgCiAJQby0ggEQwyEACyADQRBqJAAgB0EIaiALKAIANgIAIAcgAikCCDcCACACQSBqJAAgACAHELYYDAELIARB+ABqIAMoAjxBAEECQQIQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7S0gBUEBdCIIBEAgBCgCcCAEKAJ0QQF0aiABIAZBAXRqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahC2GAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAGEKM9AAsgBSABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAucDAEGfyMAQcABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiADQRBqIgUoAhBPBEACQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDBQUACyAEQfgAaiIGIAMoAjxBAEEEQQQQoBggBCgCfCEDIAQoAnhBAUYNBiAEQQA2AiwgBCAEKAKAATYCKCAEIAM2AiQgBiAFEMk0IARB7ABqIAYQ1QkgBCgCbEEBRgRAA0AgBCgCdCIDIAQoAnAiBUkNECACIANJDREgBEEkaiADIAVrIgMQ7i0gA0ECdCIGBEAgBCgCKCAEKAIsQQJ0aiABIAVBAnRqIAb8CgAACyAEIAQoAiwgA2o2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggACAEQfgAahDxGAwDCyAEQfgAaiIGIAUgAygCPBCxJiAEQTBqIAZBOPwKAAAgBCgCtAEhAyAEIAQoArABIghBAnQiBTYCJCAFIQYgBUE8cSIHBEAgBSAHa0FAayIGIAVJDQcLQcAAIQcgBkHAABDRNEUNByAGBEAgBkHAABCtNiIHRQ0JCyAEQfgAaiIJIARBMGpBOPwKAAAgBCACNgK8ASAEIAE2ArgBIAQgAzYCtAEgBCAINgKwASAEQRhqIAkQ1hAgByEDIAQoAhhBAXEEQCAEKAIcIQUDQCAFIAQoArwBIgFPDQsgAyAEKAK4ASAFQQJ0aigCADYAACADQQRqIQMgBEEQaiAEQfgAahDWECAEKAIUIQUgBCgCEEEBcQ0ACyAEKAIkIQULIAQgAyAHayIBNgJsIAEgBUcNCiAEIAY2AogBIARCgICAgIAINwKAASAEIAU2AnwgBCAHNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAAgBTYCCCAAIAI2AgQgACABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQUgAygCDCEDIAQgAjYChAEgBCABNgKAASAEIAUgA0ECdGo2AnwgBCAFNgJ4IwBBIGsiASQAIAFBFGogBEH4AGoiAigCBCACKAIAa0ECdkEAQQRBBBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEGggoMBEP0vAAsgAUEQaiIGQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgMkACABQQhqIgUgAigCBCACKAIAa0ECdhDuLSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIAIgA0EEahDbGSADQRBqJAAgBEHsAGoiAkEIaiAGKAIANgIAIAIgASkCCDcCACABQSBqJAAgACACEPEYDAELIARB+ABqIAMoAjxBAEEEQQQQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7i0gBUECdCIIBEAgBCgCcCAEKAJ0QQJ0aiABIAZBAnRqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahDxGAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAGEKM9AAsgBSABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAuKCgIGfwN+IwBB8AFrIgIkACABKAIMIgEgASgCACIDQQFqNgIAAkACQAJAAkAgA0EATgRAIAIgATYCRCACQQA2AuwBIAJBKToA4AEgAkGAgICAeDYC0AEgAkEANgLcASACQcgAaiACQdABaiACQcQAaiACQeABahDSAQJAIAIoAkgiA0GCgICAeEcEQCACQcgBaiIEIAJB5ABqKAIANgIAIAJBwAFqIgUgAkHcAGopAgA3AwAgAkG4AWoiBiACQdQAaikCADcDACACIAIpAkw3A7ABIANBgYCAgHhHDQFBrNnPABCyOwALIAJBxAFqIAJB4ABqKQMAIgg3AgAgAkG8AWogAkHYAGopAwAiCTcCACACQZwBaiIBIAk3AgAgAkGkAWoiAyAINwIAIAIgAikDUCIINwK0ASACIAg3ApQBIAJB0AFqEIYwIAJBNGogASkCACIINwIAIAJBPGogAykCACIJNwIAIAIgAikClAEiCjcCLCAAQRBqIAk3AgAgAEEIaiAINwIAIAAgCjcCACAAQYCAgIB4NgI0IAIoAkQiACAAKAIAIgBBAWs2AgAgAEEBRw0FIAJBxABqEIMgDAULIAJBqAFqIgcgBCgCADYCACACQaABaiIEIAUpAwA3AwAgAkGYAWoiBSAGKQMANwMAIAIgAikDsAE3A5ABIAJB0AFqEIYwIAJBQGsgBygCACIGNgIAIAJBOGogBCkDACIINwMAIAJBMGogBSkDACIJNwMAIAJBFGogCTcCACACQRxqIAg3AgAgAkEkaiAGNgIAIAIgAikDkAEiCDcDKCACIAM2AgggAiAINwIMIAIoAkQiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAJBxABqEIMgCyACQcgAaiABQQhqIgMgASgCCEECRkECdGoiBCgCDCAEKAIQIAJBFGogAi0AJBCbFCABKAIIIQEgAkGwAWoiBEGons8AEKUrIAIpA7gBIQkgAikDsAEhCiAEIAJBKGpBGEEIQQQQnRQgAyABQQJGQQJ0aiEBIAIoArQBIQMCQCACKAKwASIERQRAIAI1ArgBIQgMAQsgAikCuAEhCCADQQlqIgVFDQAgBEH/ASAF/AsACyACIAk3A6gBIAIgCjcDoAEgAiADNgKUASACIAQ2ApABIAIgCDcDmAEgASgCAEUEQCAIQiCIpyEBDAQLIAJBsAFqIgNBEEEAQQFBARCgGCACKAK0ASEEIAIoArABQQFGDQEgAigCuAEiBUEIakGk2c8AKQAANwAAIAVBnNnPACkAADcAACACQRA2AjAgAiAFNgIsIAIgBDYCKCABKAIARQ0CIAIgASgCBDYC0AEgAyACQdABahCkEiACQeABaiIBIAJBkAFqIAJBKGogAxDOCSABEIYwIAIoApwBIQEMAwsACyAEIAIoArgBQeSjzwAQ/S8AC0Hcus8AQSNBgLvPABCfKQALAkAgAQRAIAJByAFqIgEgAkGoAWopAwA3AwAgAkHAAWoiAyACQaABaikDADcDACACQbgBaiIEIAJBmAFqKQMANwMAIAIgAikDkAE3A7ABIAJByABqIgUQkycgAkHgAGogASkDADcDACACQdgAaiADKQMANwMAIAJB0ABqIAQpAwA3AwAgAiACKQOwATcDSCAAIAVByAD8CgAADAELIAAgAkHIAGpByAD8CgAAIAJBkAFqEJMnCyACQQhqEMkoCyACQfABaiQAC+oJAgl/A34jAEHAAWsiAyQAIAMgAjYCECABQQxqENg8IQUCQAJAAkACQAJAAkAgARCSNiIEBEBBwAAhAiADQQhqIAQQ3DsgBCgCFCEHIAQoAgwhCCADKAIMIQogAygCCCEJIAVBA3YgBUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0GIAQEQCAEQcAAEK02IgJFDQQLIANCADcCICADIAI2AhwgAyAENgIYIANBwAA2AhQgA0EUaiAIIAUgCGogCSAKEL8YDAELQcAAIQIgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQUgBARAIARBwAAQrTYiAkUNAgsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAUQ3hALIAVBA3QiBCECAkAgBEE4cSIGBEAgBCAGa0FAayICIARJDQELQcAAIQYgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBkUNAQsgA0EANgI4IAMgBjYCMCADIAI2AiwgA0HAADYCKCAEBEAgBARAIAZBACAE/AsACyADKAI4IQsgAygCMCEGCyADIAQ2AjQgAyAFIAtqIgI2AjggAyAHNgI8IAMgAjYCTCADIAY2AkggAyABNgJEIAMgA0EUajYCVCADIANBPGo2AlAgAyADQRBqNgJAIAdFDQUgBSAHRg0GIAkEQCADQfgAaiAJIAogCCAFEL8UIANBmAFqIQEDQAJAIAMpA6ABIg1QRQRAIAMpA6gBIQwMAQsDQAJ+AkAgAykDiAEiDEIDUgRAAkACQAJAIAxCAlENACADIAxQrUIBhjcDiAEgDKdBAXFFDQAgAyADKQOQATcDuAEMAQsgAygCmAFFDQEgA0GwAWogARC2KiADKQOwASEMCyAMQgBSDQILIANCAzcDiAELIAMpA3giDEICUQ0MIANCADcDeCADKQOAAQwBCyADKQO4AQshDSAMp0EBcUUNCiADIAMpA6gBQkB9Igw3A6gBIAMgDTcDoAEgDVANAAsLIAMgDUIBIA16Ig6GhTcDoAEgA0FAayAOpyAMp2oQkxAMAAsAC0HEiv8AELI7AAtBwAAgAhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgBBCjPQALQcAAIAQQoz0ACyAFRQ0AQQAhAgNAIANBQGsgAhCTECAFIAJBAWoiAkcNAAsLIANB2ABqIANBFGoiBxCCFCADQfgAaiICEJcpIANBMGogA0GAAWoiBSkCADcDACADKQMoIQwgAyADKQJ4NwMoIANBADYCOCADIAw3AoQBIANBADYCgAEgAyAENgJ8IAMgBjYCeCADIAIQ1zsgAygCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiAFKQIANwIAIAFBGGogA0GIAWoiCCgCADYCACADIAQ2AkggAyAGNgJEIAMgATYCQCADQewAaiIBIANBQGsQ5BkgAygCPCEEIAggA0HoAGooAgA2AgAgBSADQeAAaikCADcDACADIAMpAlg3A3ggAyAENgKMASAAIAEgAhDWHSADQShqEM8vIAcQzy8gA0HAAWokAA8LQQRBHBCjPQALQdyL/wBBKSADQfgAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBAXRqLgEAsjgCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBC4BALI4AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGooAgC3OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAtzkDACAGQQhqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBA3QiBCEDAkACQAJAIARBOHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUEDdGogASAFQQF0ai4BALc5AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQuAQC3OQMAIAZBCGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENsdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAnRqKgIAuzkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCoCALs5AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGooAgC4OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAuDkDACAGQQhqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENk8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUECdGogASAFQQF0ai8BALM4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQvAQCzOAIAIAZBBGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAXRqLwEAuDkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBC8BALg5AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL6gkCCX8DfiMAQcABayIDJAAgAyACNgIQIAFBDGoQ2DwhBQJAAkACQAJAAkACQCABEJI2IgQEQEHAACECIANBCGogBBDcOyAEKAIUIQcgBCgCDCEIIAMoAgwhCiADKAIIIQkgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQYgBARAIARBwAAQrTYiAkUNBAsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhAiAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiICRQ0CCyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogBRDeEAsgBUEDdCIEIQICQCAEQThxIgYEQCAEIAZrQUBrIgIgBEkNAQtBwAAhBiACQcAAENE0BEACQCACBEAgAkHAABCtNiIGRQ0BCyADQQA2AjggAyAGNgIwIAMgAjYCLCADQcAANgIoIAQEQCAEBEAgBkEAIAT8CwALIAMoAjghCyADKAIwIQYLIAMgBDYCNCADIAUgC2oiAjYCOCADIAc2AjwgAyACNgJMIAMgBjYCSCADIAE2AkQgAyADQRRqNgJUIAMgA0E8ajYCUCADIANBEGo2AkAgB0UNBSAFIAdGDQYgCQRAIANB+ABqIAkgCiAIIAUQvxQgA0GYAWohAQNAAkAgAykDoAEiDVBFBEAgAykDqAEhDAwBCwNAAn4CQCADKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwOIASAMp0EBcUUNACADIAMpA5ABNwO4AQwBCyADKAKYAUUNASADQbABaiABELYqIAMpA7ABIQwLIAxCAFINAgsgA0IDNwOIAQsgAykDeCIMQgJRDQwgA0IANwN4IAMpA4ABDAELIAMpA7gBCyENIAynQQFxRQ0KIAMgAykDqAFCQH0iDDcDqAEgAyANNwOgASANUA0ACwsgAyANQgEgDXoiDoaFNwOgASADQUBrIA6nIAynahCUEAwACwALQcSK/wAQsjsAC0HAACACEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAEEKM9AAtBwAAgBBCjPQALIAVFDQBBACECA0AgA0FAayACEJQQIAUgAkEBaiICRw0ACwsgA0HYAGogA0EUaiIHEIIUIANB+ABqIgIQlykgA0EwaiADQYABaiIFKQIANwMAIAMpAyghDCADIAMpAng3AyggA0EANgI4IAMgDDcChAEgA0EANgKAASADIAQ2AnwgAyAGNgJ4IAMgAhDXOyADKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiADQYgBaiIIKAIANgIAIAMgBDYCSCADIAY2AkQgAyABNgJAIANB7ABqIgEgA0FAaxDkGSADKAI8IQQgCCADQegAaigCADYCACAFIANB4ABqKQIANwMAIAMgAykCWDcDeCADIAQ2AowBIAAgASACENYdIANBKGoQzy8gBxDPLyADQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIANB+ABqQeyP/wBBiIz/ABDVHgALyAkCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEDdGopAwC1OAIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKQMAtTgCACAGQQRqIQYgBEEIaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvqCQIJfwN+IwBBwAFrIgMkACADIAI2AhAgAUEMahDYPCEFAkACQAJAAkACQAJAIAEQkjYiBARAQcAAIQIgA0EIaiAEENw7IAQoAhQhByAEKAIMIQggAygCDCEKIAMoAgghCSAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBiAEBEAgBEHAABCtNiICRQ0ECyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogCCAFIAhqIAkgChC/GAwBC0HAACECIAVBA3YgBUEHcUEAR2oiBEHA////A3FBQGsgBCAEQT9xGyIEQcAAENE0RQ0FIAQEQCAEQcAAEK02IgJFDQILIANCADcCICADIAI2AhwgAyAENgIYIANBwAA2AhQgA0EUaiAFEN4QCyAFQQN0IgQhAgJAIARBOHEiBgRAIAQgBmtBQGsiAiAESQ0BC0HAACEGIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgZFDQELIANBADYCOCADIAY2AjAgAyACNgIsIANBwAA2AiggBARAIAQEQCAGQQAgBPwLAAsgAygCOCELIAMoAjAhBgsgAyAENgI0IAMgBSALaiICNgI4IAMgBzYCPCADIAI2AkwgAyAGNgJIIAMgATYCRCADIANBFGo2AlQgAyADQTxqNgJQIAMgA0EQajYCQCAHRQ0FIAUgB0YNBiAJBEAgA0H4AGogCSAKIAggBRC/FCADQZgBaiEBA0ACQCADKQOgASINUEUEQCADKQOoASEMDAELA0ACfgJAIAMpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAyAMUK1CAYY3A4gBIAynQQFxRQ0AIAMgAykDkAE3A7gBDAELIAMoApgBRQ0BIANBsAFqIAEQtiogAykDsAEhDAsgDEIAUg0CCyADQgM3A4gBCyADKQN4IgxCAlENDCADQgA3A3ggAykDgAEMAQsgAykDuAELIQ0gDKdBAXFFDQogAyADKQOoAUJAfSIMNwOoASADIA03A6ABIA1QDQALCyADIA1CASANeiIOhoU3A6ABIANBQGsgDqcgDKdqEJUQDAALAAtBxIr/ABCyOwALQcAAIAIQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAQQoz0AC0HAACAEEKM9AAsgBUUNAEEAIQIDQCADQUBrIAIQlRAgBSACQQFqIgJHDQALCyADQdgAaiADQRRqIgcQghQgA0H4AGoiAhCXKSADQTBqIANBgAFqIgUpAgA3AwAgAykDKCEMIAMgAykCeDcDKCADQQA2AjggAyAMNwKEASADQQA2AoABIAMgBDYCfCADIAY2AnggAyACENc7IAMoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASADKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIANBiAFqIggoAgA2AgAgAyAENgJIIAMgBjYCRCADIAE2AkAgA0HsAGoiASADQUBrEOQZIAMoAjwhBCAIIANB6ABqKAIANgIAIAUgA0HgAGopAgA3AwAgAyADKQJYNwN4IAMgBDYCjAEgACABIAIQ1h0gA0EoahDPLyAHEM8vIANBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgA0H4AGpB7I//AEGIjP8AENUeAAvICQIKfwN+IwBBsAFrIgIkACABQQxqENg8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2oiBUECdGogASAFQQN0aisDALY4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQrAwC2OAIAIAZBBGohBiAEQQhqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8gJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBA3RqKQMAtDgCAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCkDALQ4AgAgBkEEaiEGIARBCGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL6gkCCX8DfiMAQcABayIDJAAgAyACNgIQIAFBDGoQ2DwhBQJAAkACQAJAAkACQCABEJI2IgQEQEHAACECIANBCGogBBDcOyAEKAIUIQcgBCgCDCEIIAMoAgwhCiADKAIIIQkgBUEDdiAFQQdxQQBHaiIEQcD///8DcUFAayAEIARBP3EbIgRBwAAQ0TRFDQYgBARAIARBwAAQrTYiAkUNBAsgA0IANwIgIAMgAjYCHCADIAQ2AhggA0HAADYCFCADQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhAiAFQQN2IAVBB3FBAEdqIgRBwP///wNxQUBrIAQgBEE/cRsiBEHAABDRNEUNBSAEBEAgBEHAABCtNiICRQ0CCyADQgA3AiAgAyACNgIcIAMgBDYCGCADQcAANgIUIANBFGogBRDeEAsgBUEDdCIEIQICQCAEQThxIgYEQCAEIAZrQUBrIgIgBEkNAQtBwAAhBiACQcAAENE0BEACQCACBEAgAkHAABCtNiIGRQ0BCyADQQA2AjggAyAGNgIwIAMgAjYCLCADQcAANgIoIAQEQCAEBEAgBkEAIAT8CwALIAMoAjghCyADKAIwIQYLIAMgBDYCNCADIAUgC2oiAjYCOCADIAc2AjwgAyACNgJMIAMgBjYCSCADIAE2AkQgAyADQRRqNgJUIAMgA0E8ajYCUCADIANBEGo2AkAgB0UNBSAFIAdGDQYgCQRAIANB+ABqIAkgCiAIIAUQvxQgA0GYAWohAQNAAkAgAykDoAEiDVBFBEAgAykDqAEhDAwBCwNAAn4CQCADKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAMgDFCtQgGGNwOIASAMp0EBcUUNACADIAMpA5ABNwO4AQwBCyADKAKYAUUNASADQbABaiABELYqIAMpA7ABIQwLIAxCAFINAgsgA0IDNwOIAQsgAykDeCIMQgJRDQwgA0IANwN4IAMpA4ABDAELIAMpA7gBCyENIAynQQFxRQ0KIAMgAykDqAFCQH0iDDcDqAEgAyANNwOgASANUA0ACwsgAyANQgEgDXoiDoaFNwOgASADQUBrIA6nIAynahCWEAwACwALQcSK/wAQsjsAC0HAACACEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACAEEKM9AAtBwAAgBBCjPQALIAVFDQBBACECA0AgA0FAayACEJYQIAUgAkEBaiICRw0ACwsgA0HYAGogA0EUaiIHEIIUIANB+ABqIgIQlykgA0EwaiADQYABaiIFKQIANwMAIAMpAyghDCADIAMpAng3AyggA0EANgI4IAMgDDcChAEgA0EANgKAASADIAQ2AnwgAyAGNgJ4IAMgAhDXOyADKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiADQYgBaiIIKAIANgIAIAMgBDYCSCADIAY2AkQgAyABNgJAIANB7ABqIgEgA0FAaxDkGSADKAI8IQQgCCADQegAaigCADYCACAFIANB4ABqKQIANwMAIAMgAykCWDcDeCADIAQ2AowBIAAgASACENYdIANBKGoQzy8gBxDPLyADQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIANB+ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEBdGovAQA2AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQvAQA2AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBAnRqIAEgBUEBdGouAQA2AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQuAQA2AgAgBkEEaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGo0AgA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQ0AgA3AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUEBdGoyAQA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQyAQA3AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDZPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUEBdGozAQA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQzAQA3AwAgBkEIaiEGIARBAmohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxgkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqIgVBA3RqIAEgBUECdGo1AgA3AwAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQ1AgA3AwAgBkEIaiEGIARBBGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxQkCCn8DfiMAQbABayICJAAgAUEMahDbPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhAwJAAkACQCAEQTxxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqQQJ0IgVqIAEgBWooAgCyOAIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKAIAsjgCACAGQQRqIQYgBEEEaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvFCQIKfwN+IwBBsAFrIgIkACABQQxqENs8IQUCQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0DIAMEQCADQcAAEK02IgRFDQMLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQIgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQCADBEAgA0HAABCtNiIGRQ0FCyACQQA2AkAgAiAGNgI4IAIgAzYCNCACQcAANgIwIAQEQCAEBEAgBkEAIAT8CwALIAIoAkAhCyACKAI4IQYLIAIgBDYCPCACIAUgC2o2AkAgCUUNAiAFIAlGDQMgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohAyABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogAxC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQkgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQcgAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgBiAOpyAMp2pBAnQiBWogASAFaigCALM4AgAMAAsAC0HEiv8AELI7AAsMBAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AIAEoAhAhBEEAIQMDQCAGIAQoAgCzOAIAIAZBBGohBiAEQQRqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEL4dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAXRqMwEANwMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEMwEANwMAIAZBCGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2zwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQN0aiABIAVBAnRqNQIANwMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAENQIANwMAIAZBCGohBiAEQQRqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8YJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2TwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQMCQAJAAkAgBEE8cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynaiIFQQJ0aiABIAVBAXRqLwEANgIADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAELwEANgIAIAZBBGohBiAEQQJqIQQgBSADQQFqIgNHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiAxCXKSACQThqIgEoAgAhByACKAI8IQUgASACQfAAaiIEKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAFNgJsIAIgBzYCaCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiAEKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAU2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOUZIAggAkHYAGooAgA2AgAgBCACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASADEMcdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8UJAgp/A34jAEGwAWsiAiQAIAFBDGoQ2DwhBQJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQMCQAJAAkAgBEE4cSIGBEAgBCAGa0FAayIDIARJDQELQcAAIQYgA0HAABDRNARAIAMEQCADQcAAEK02IgZFDQULIAJBADYCQCACIAY2AjggAiADNgI0IAJBwAA2AjAgBARAIAQEQCAGQQAgBPwLAAsgAigCQCELIAIoAjghBgsgAiAENgI8IAIgBSALajYCQCAJRQ0CIAUgCUYNAyAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEDIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiADELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENCSACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNByACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASAGIA6nIAynakEDdCIFaiABIAVqKQMAujkDAAwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIAVFDQAgASgCECEEQQAhAwNAIAYgBCkDALo5AwAgBkEIaiEGIARBCGohBCAFIANBAWoiA0cNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIDEJcpIAJBOGoiASgCACEHIAIoAjwhBSABIAJB8ABqIgQpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAU2AmwgAiAHNgJoIAJBCGogAxDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBTYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACAEIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAMQ2x0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALxQkCCn8DfiMAQbABayICJAAgAUEMahDYPCEFAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIERQ0DCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhAwJAAkACQCAEQThxIgYEQCAEIAZrQUBrIgMgBEkNAQtBwAAhBiADQcAAENE0BEAgAwRAIANBwAAQrTYiBkUNBQsgAkEANgJAIAIgBjYCOCACIAM2AjQgAkHAADYCMCAEBEAgBARAIAZBACAE/AsACyACKAJAIQsgAigCOCEGCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQIgBSAJRg0DIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQMgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAMQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0JIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0HIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAYgDqcgDKdqQQN0IgVqIAEgBWopAwC5OQMADAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBUUNACABKAIQIQRBACEDA0AgBiAEKQMAuTkDACAGQQhqIQYgBEEIaiEEIAUgA0EBaiIDRw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgMQlykgAkE4aiIBKAIAIQcgAigCPCEFIAEgAkHwAGoiBCkCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBTYCbCACIAc2AmggAkEIaiADENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogBCkCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAFNgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAQgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgAxDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQcAAIAMQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvNCgEGfyMAQcABayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiADQRBqIgUoAhBPBEACQAJAAkACQAJAAkAgAygCAEEBaw4FAQIDBQUACyAEQfgAaiIGIAMoAjxBAEEIQQgQoBggBCgCfCEDIAQoAnhBAUYNBiAEQQA2AiwgBCAEKAKAATYCKCAEIAM2AiQgBiAFEMk0IARB7ABqIAYQ1QkgBCgCbEEBRgRAA0AgBCgCdCIDIAQoAnAiBUkNECACIANJDREgBEEkaiADIAVrIgMQ7C0gA0EDdCIGBEAgBCgCKCAEKAIsQQN0aiABIAVBA3RqIAb8CgAACyAEIAQoAiwgA2o2AiwgBEHsAGogBEH4AGoQ1QkgBCgCbA0ACwsgBEGAAWogBEEsaigCADYCACAEIAQpAiQ3A3ggACAEQfgAahDzGAwDCyAEQfgAaiIGIAUgAygCPBCxJiAEQTBqIAZBOPwKAAAgBCgCtAEhAyAEIAQoArABIghBA3QiBjYCJCAGIgVBOHEiBwRAIAUgBSAHa0FAayIFSw0HC0HAACEHIAVBwAAQ0TRFDQcgBQRAIAVBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCECA0AgAiAEKAK8ASIBTw0LIAMgBCgCuAEgAkEDdGopAwA3AAAgA0EIaiEDIARBEGogBEH4AGoQ1hAgBCgCFCECIAQoAhBBAXENAAsLIAQgAyAHayIBNgJsIAEgBkcNCiAEIAU2AogBIARCgICAgIAINwKAASAEIAY2AnwgBCAHNgJ4IARBCGogBEH4AGoQ1zsgBCgCCCECQRxBBBCtNiIBRQ0LIAFCgYCAgBA3AgAgASAEKQJ4NwIIIAAgBjYCCCAAIAI2AgQgACABNgIAIAFBEGogBEGAAWopAgA3AgAgAUEYaiAEQYgBaigCADYCAAwCCyADKAIIIQUgAygCDCEDIAQgAjYChAEgBCABNgKAASAEIAUgA0ECdGo2AnwgBCAFNgJ4IARB7ABqIgEgBEH4AGoQ/RogACABEPMYDAELIARB+ABqIAMoAjxBAEEIQQgQoBggBCgCfCEFIAQoAnhBAUYNCiAEQQA2AnQgBCAEKAKAATYCcCAEIAU2AmwgAygCDCIFBEAgAygCCCIDIAVBA3RqIQcDQCADQQRqKAIAIgUgAygCACIGSQ0PIAIgBUkNECAEQewAaiAFIAZrIgUQ7C0gBUEDdCIIBEAgBCgCcCAEKAJ0QQN0aiABIAZBA3RqIAj8CgAACyAEIAQoAnQgBWo2AnQgA0EIaiIDIAdHDQALCyAEQYABaiAEQfQAaigCADYCACAEIAQpAmw3A3ggACAEQfgAahDzGAsgBEHAAWokAA8LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyADIAQoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSAEQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgAiABQeyvgwEQwyEACyAEQgA3AoQBIARCgYCAgMAANwJ8IARBqPuCATYCeEEAIARB7ABqIARBJGogBEH4AGpBsPuCARCvKwALQQRBHBCjPQALIAUgBCgCgAFBrK+DARD9LwALIAUgA0GMr4MBELE7AAsgAyACQYyvgwEQsDsACyAGIAVBvK+DARCxOwALIAUgAkG8r4MBELA7AAvaCQEJfyMAQUBqIgQkACABKAIAIQgCQAJAAkAgAkUEQCABKAIEIQYCQCAIQYCAgIB4RwRAIAQgASgCCDYCICAEIAY2AhwgBCAINgIYDAELIARBGGogBhDpHQsgA0H/AXENASAEQThqIARBIGooAgAiBjYCACAEIAQpAxg3AzACQCAGRQ0AIAQoAjQiASAGQQJ0IgVqQQRrIgJFDQAgAigCAA0AIAFBBGshASAGQf////8DcSEDAkADQCAFRQRAQQAhBQwCCyADQQFrIQMgASAFaiAFQQRrIQUoAgBFDQALIANBAWoiBSAGSw0BCyAEIAU2AjggBSEGCwJAIAQoAjBBAnYgBksEQCAEIARBMGogBkEEQQQQ9BQgBCgCACIBQYGAgIB4Rw0BCyAAIAQpAzA3AgAgAEEIaiAEQThqKAIANgIADAQLIAEgBCgCBEHUpYgBEP0vAAsgBEEwakF/IAEoAgQgASAIQYCAgIB4RhsiBigCCCACakEBaiIFIAIgBUsbQQBBBEEEEKAYIAQoAjQhBQJAIAQoAjBBAUcEQCAEQSxqIgdBADYCACAEIAQoAjg2AiggBCAFNgIkIARBJGoiBSACENMaIAUgBigCBCIFIAUgBigCCEECdGoQniQgBEEgaiIGIAcoAgA2AgAgBCAEKQIkNwMYIANB/wFxDQIgBEE4aiAGKAIAIgY2AgAgBCAEKQMYNwMwAkAgBkUNACAEKAI0IgIgBkECdCIFakEEayIDRQ0AIAMoAgANACACQQRrIQIgBkH/////A3EhAwJAA0AgBUUEQEEAIQUMAgsgA0EBayEDIAIgBWogBUEEayEFKAIARQ0ACyADQQFqIgUgBksNAQsgBCAFNgI4IAUhBgsgBCgCMEECdiAGSwRAIARBEGogBEEwaiAGQQRBBBD0FCAEKAIQIgJBgYCAgHhHDQILIAAgBCkDMDcCACAAQQhqIARBOGooAgA2AgAgCEGAgICAeEYNBAwDCyAFIAQoAjhBlKWIARD9LwALIAIgBCgCFEHUpYgBEP0vAAsCQCAEKAIgIgcgAk8EQAJAIAIgB0YNACAEKAIcIQYgB0ECdCEJIAJBAnQhBSADQR9xIQpBACADa0EfcSELQQAhAwNAIAUgBmoiDCADIAwoAgAiAyAKdHI2AgAgAyALdiEDIAkgBUEEaiIFRw0ACyADRQ0AIAQoAhggB0YEfyAEQRhqQbSliAEQnSggBCgCHAUgBgsgB0ECdGogAzYCACAEIAdBAWo2AiALIARBOGogBEEgaigCACIGNgIAIAQgBCkDGDcDMCAGRQ0BIAQoAjQiAyAGQQJ0IgdqQQRrIgVFDQEgBSgCAA0BIAchBSADQQRrIQcgBkH/////A3EhAwJAA0AgBUUEQEEAIQUMAgsgA0EBayEDIAUgB2ogBUEEayEFKAIARQ0ACyADQQFqIgUgBksNAgsgBCAFNgI4IAUhBgwBCyACIAdBpKWIARCvOwALAkAgBiAEKAIwQQJ2Tw0AIARBCGogBEEwaiAGQQRBBBD0FCAEKAIIIgNBgYCAgHhGDQAgAyAEKAIMQdSliAEQ/S8ACyAAIAQpAzA3AgAgAEEIaiAEQThqKAIANgIAIAJFIAhBgICAgHhGcg0BCyABQQRBBBDgHgsgBEFAayQAC4gLAgR/AX4jAEHQAWsiAyQAIANBrAFqIAEgAhCTDiADKAKwASEEAkAgAygCrAEiBUGKgICAeEcEQCADQSxqIANBzAFqKAIANgIAIANBJGogA0HEAWopAgA3AgAgA0EcaiADQbwBaikCADcCACADIAMpArQBNwIUIAMgBDYCECADIAU2AgwMAQsgA0GsAWogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0G4AWopAgA3AwAgAyADKQKwATcDMCADKAKsASIEQYqAgIB4RwRAIANBKGogA0HIAWopAgA3AgAgA0EYaiABKQMANwIAIAMgAykCwAE3AiAgAyADKQMwNwIQIAMgBDYCDAwBCyADQcgAaiABKQMANwMAIAMgAykDMDcDQCADQawBaiADQUBrQQQQ3RAgAygCtAEhASADKAKwASEEAkACfiADKAKsASIFQYqAgIB4RwRAIANB6ABqIANByAFqKQIANwMAIAMgAykCwAE3A2AgAykCuAEMAQsgBEEBcUUNAQJAIAFBAXEEQCADIAE2AsgBIANBAzYCxAEgA0G55P4ANgLAASADQYCAgIB4NgK8ASADQgQ3ArQBIANChICAgAg3AqwBDAELQX8gAUECaiIEIAEgBEsbIgUgAygCQCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKsAQwCCyADQYiAgIB4NgKsAQwBCyADQawBaiABIAUQvy8LIANBBDYCcCADQYbn/gA2AmwgA0GAgICAeDYCaCADIAE2AmQgA0EBNgJgIANBiAFqIANBrAFqIANB4ABqEIEUIAMoAogBIgVBioCAgHhGDQEgA0HoAGogA0GkAWopAgA3AwAgAyADKQKcATcDYCADKAKQASEBIAMoAowBIQQgAykClAELIQcgA0EoaiADQegAaikDADcCACADIAc3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQNgNwIgDAELIAMgAykDSDcCWCADIAMpA0A3AlAgA0GsAWogA0HQAGpBBhDdECADKAK0ASEBIAMoArABIQQCQAJ+IAMoAqwBIgVBioCAgHhHBEAgA0GQAWogA0HIAWopAgA3AwAgAyADKQLAATcDiAEgAykCuAEMAQsgBEEBcUUNASADQawBaiADKAJQIgUgARCTDiADKAKwASEEAkAgAygCrAEiBkGKgICAeEcEQCADQagBaiADQcwBaigCADYCACADQaABaiADQcQBaikCADcCACADQZgBaiADQbwBaikCADcCACADIAMpArQBNwKQASADIAQ2AowBIAMgBjYCiAEMAQsgA0GsAWogBUF/IAEgBGoiBSAEIAVLGxCIDiADKAKsASIEQYqAgIB4RwRAIANBnAFqIANBwAFqKQIANwIAIANBpAFqIANByAFqKQIANwIAIAMgAykCuAE3ApQBIAMgAykCsAE3AowBCyADIAQ2AogBCyADQQc2ArwBIANBiuf+ADYCuAEgA0GAgICAeDYCtAEgAyABNgKwASADQQE2AqwBIANB4ABqIANBiAFqIANBrAFqEIEUIAMoAmAiBUGKgICAeEYNASADQZABaiADQfwAaikCADcDACADIAMpAnQ3A4gBIAMoAmghASADKAJkIQQgAykCbAshByADQShqIANBkAFqKQMANwIAIAMgBzcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA4gBNwIgDAELIAMoAlAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBCzYCvAEgA0HD6f4ANgK4ASADQYCAgIB4NgK0ASADIAI2ArABIANBAjYCrAEgACADQQxqIANBrAFqEIEUIANB0AFqJAAL4gkCCn8DfiMAQcABayICJAAgAUEMahDZPCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEIaiADENw7IAMoAhQhByADKAIMIQggAigCDCEKIAIoAgghCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAFEN4QCyAFQQJ0IgMhBAJAIANBPHEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAJBADYCOCACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAMEQCAGQQAgA/wLAAsgAigCOCELIAIoAjAhBgsgAiADNgI0IAIgBSALaiIENgI4IAIgBzYCPCACIAQ2AkwgAiAGNgJIIAIgATYCRCACIAJBFGo2AlQgAiACQTxqNgJQIAIgAkH4AGoiATYCQCAHRQ0FIAUgB0YNBiAJBEAgASAJIAogCCAFEL8UIAJBmAFqIQEDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogARC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgAkFAayAOpyAMp2oQrw8MAAsAC0HEiv8AELI7AAtBwAAgBBCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AQQAhBANAIAJBQGsgBBCvDyAFIARBAWoiBEcNAAsLIAJB2ABqIAJBFGoiBxCCFCACQfgAaiIEEJcpIAJBMGogAkGAAWoiBSkCADcDACACKQMoIQwgAiACKQJ4NwMoIAJBADYCOCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBjYCeCACIAQQ1zsgAigCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCCgCADYCACACIAM2AkggAiAGNgJEIAIgATYCQCACQewAaiIBIAJBQGsQ5RkgAigCPCEDIAggAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiADNgKMASAAIAEgBBC/HSACQShqEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+IJAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBCGogAxDcOyADKAIUIQcgAygCDCEIIAIoAgwhCiACKAIIIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogBRDeEAsgBUEDdCIDIQQCQCADQThxIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACQQA2AjggAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCADBEAgBkEAIAP8CwALIAIoAjghCyACKAIwIQYLIAIgAzYCNCACIAUgC2oiBDYCOCACIAc2AjwgAiAENgJMIAIgBjYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgB0UNBSAFIAdGDQYgCQRAIAEgCSAKIAggBRC/FCACQZgBaiEBA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAJBQGsgDqcgDKdqELAPDAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNAEEAIQQDQCACQUBrIAQQsA8gBSAEQQFqIgRHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiBBCXKSACQTBqIAJBgAFqIgUpAgA3AwAgAikDKCEMIAIgAikCeDcDKCACQQA2AjggAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAY2AnggAiAEENc7IAIoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiADNgJIIAIgBjYCRCACIAE2AkAgAkHsAGoiASACQUBrEOQZIAIoAjwhAyAIIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgAzYCjAEgACABIAQQ1h0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAviCQIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQQhqIAMQ3DsgAygCFCEHIAMoAgwhCCACKAIMIQogAigCCCEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAUQ3hALIAVBA3QiAyEEAkAgA0E4cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAkEANgI4IAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgAwRAIAZBACAD/AsACyACKAI4IQsgAigCMCEGCyACIAM2AjQgAiAFIAtqIgQ2AjggAiAHNgI8IAIgBDYCTCACIAY2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAdFDQUgBSAHRg0GIAkEQCABIAkgCiAIIAUQvxQgAkGYAWohAQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASACQUBrIA6nIAynahCxDwwACwALQcSK/wAQsjsAC0HAACAEEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQBBACEEA0AgAkFAayAEELEPIAUgBEEBaiIERw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgQQlykgAkEwaiACQYABaiIFKQIANwMAIAIpAyghDCACIAIpAng3AyggAkEANgI4IAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAGNgJ4IAIgBBDXOyACKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgAzYCSCACIAY2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDkGSACKAI8IQMgCCACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAM2AowBIAAgASAEENkdIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL4gkCCn8DfiMAQcABayICJAAgAUEMahDZPCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEIaiADENw7IAMoAhQhByADKAIMIQggAigCDCEKIAIoAgghCSAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogCCAFIAhqIAkgChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAFEN4QCyAFQQF0IgMhBAJAIANBPnEiBgRAIAMgBmtBQGsiBCADSQ0BC0HAACEGIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgZFDQELIAJBADYCOCACIAY2AjAgAiAENgIsIAJBwAA2AiggAwRAIAMEQCAGQQAgA/wLAAsgAigCOCELIAIoAjAhBgsgAiADNgI0IAIgBSALaiIENgI4IAIgBzYCPCACIAQ2AkwgAiAGNgJIIAIgATYCRCACIAJBFGo2AlQgAiACQTxqNgJQIAIgAkH4AGoiATYCQCAHRQ0FIAUgB0YNBiAJBEAgASAJIAogCCAFEL8UIAJBmAFqIQEDQAJAIAIpA6ABIg1QRQRAIAIpA6gBIQwMAQsDQAJ+AkAgAikDiAEiDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDiAEgDKdBAXFFDQAgAiACKQOQATcDuAEMAQsgAigCmAFFDQEgAkGwAWogARC2KiACKQOwASEMCyAMQgBSDQILIAJCAzcDiAELIAIpA3giDEICUQ0MIAJCADcDeCACKQOAAQwBCyACKQO4AQshDSAMp0EBcUUNCiACIAIpA6gBQkB9Igw3A6gBIAIgDTcDoAEgDVANAAsLIAIgDUIBIA16Ig6GhTcDoAEgAkFAayAOpyAMp2oQsg8MAAsAC0HEiv8AELI7AAtBwAAgBBCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AQQAhBANAIAJBQGsgBBCyDyAFIARBAWoiBEcNAAsLIAJB2ABqIAJBFGoiBxCCFCACQfgAaiIEEJcpIAJBMGogAkGAAWoiBSkCADcDACACKQMoIQwgAiACKQJ4NwMoIAJBADYCOCACIAw3AoQBIAJBADYCgAEgAiADNgJ8IAIgBjYCeCACIAQQ1zsgAigCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAng3AgggAUEQaiAFKQIANwIAIAFBGGogAkGIAWoiCCgCADYCACACIAM2AkggAiAGNgJEIAIgATYCQCACQewAaiIBIAJBQGsQ4RkgAigCPCEDIAggAkHoAGooAgA2AgAgBSACQeAAaikCADcDACACIAIpAlg3A3ggAiADNgKMASAAIAEgBBDNHSACQShqEM8vIAcQzy8gAkHAAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC+IJAgp/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBCGogAxDcOyADKAIUIQcgAygCDCEIIAIoAgwhCiACKAIIIQkgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAggBSAIaiAJIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiAgAiAENgIcIAIgAzYCGCACQcAANgIUIAJBFGogBRDeEAsgBUECdCIDIQQCQCADQTxxIgYEQCADIAZrQUBrIgQgA0kNAQtBwAAhBiAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIGRQ0BCyACQQA2AjggAiAGNgIwIAIgBDYCLCACQcAANgIoIAMEQCADBEAgBkEAIAP8CwALIAIoAjghCyACKAIwIQYLIAIgAzYCNCACIAUgC2oiBDYCOCACIAc2AjwgAiAENgJMIAIgBjYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgB0UNBSAFIAdGDQYgCQRAIAEgCSAKIAggBRC/FCACQZgBaiEBA0ACQCACKQOgASINUEUEQCACKQOoASEMDAELA0ACfgJAIAIpA4gBIgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A4gBIAynQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhDAsgDEIAUg0CCyACQgM3A4gBCyACKQN4IgxCAlENDCACQgA3A3ggAikDgAEMAQsgAikDuAELIQ0gDKdBAXFFDQogAiACKQOoAUJAfSIMNwOoASACIA03A6ABIA1QDQALCyACIA1CASANeiIOhoU3A6ABIAJBQGsgDqcgDKdqELMPDAALAAtBxIr/ABCyOwALQcAAIAQQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNAEEAIQQDQCACQUBrIAQQsw8gBSAEQQFqIgRHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiBBCXKSACQTBqIAJBgAFqIgUpAgA3AwAgAikDKCEMIAIgAikCeDcDKCACQQA2AjggAiAMNwKEASACQQA2AoABIAIgAzYCfCACIAY2AnggAiAEENc7IAIoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBSkCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiADNgJIIAIgBjYCRCACIAE2AkAgAkHsAGoiASACQUBrEOUZIAIoAjwhAyAIIAJB6ABqKAIANgIAIAUgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgAzYCjAEgACABIAQQxx0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkH4AGpB7I//AEGIjP8AENUeAAviCQIKfwN+IwBBwAFrIgIkACABQQxqENk8IQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQQhqIAMQ3DsgAygCFCEHIAMoAgwhCCACKAIMIQogAigCCCEJIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCICACIAQ2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAIIAUgCGogCSAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIgIAIgBDYCHCACIAM2AhggAkHAADYCFCACQRRqIAUQ3hALIAVBAXQiAyEEAkAgA0E+cSIGBEAgAyAGa0FAayIEIANJDQELQcAAIQYgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBkUNAQsgAkEANgI4IAIgBjYCMCACIAQ2AiwgAkHAADYCKCADBEAgAwRAIAZBACAD/AsACyACKAI4IQsgAigCMCEGCyACIAM2AjQgAiAFIAtqIgQ2AjggAiAHNgI8IAIgBDYCTCACIAY2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAdFDQUgBSAHRg0GIAkEQCABIAkgCiAIIAUQvxQgAkGYAWohAQNAAkAgAikDoAEiDVBFBEAgAikDqAEhDAwBCwNAAn4CQCACKQOIASIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwOIASAMp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQwLIAxCAFINAgsgAkIDNwOIAQsgAikDeCIMQgJRDQwgAkIANwN4IAIpA4ABDAELIAIpA7gBCyENIAynQQFxRQ0KIAIgAikDqAFCQH0iDDcDqAEgAiANNwOgASANUA0ACwsgAiANQgEgDXoiDoaFNwOgASACQUBrIA6nIAynahC1DwwACwALQcSK/wAQsjsAC0HAACAEEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQBBACEEA0AgAkFAayAEELUPIAUgBEEBaiIERw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgQQlykgAkEwaiACQYABaiIFKQIANwMAIAIpAyghDCACIAIpAng3AyggAkEANgI4IAIgDDcChAEgAkEANgKAASACIAM2AnwgAiAGNgJ4IAIgBBDXOyACKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgAzYCSCACIAY2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDhGSACKAI8IQMgCCACQegAaigCADYCACAFIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAM2AowBIAAgASAEENodIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL2QkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhBgJAIARBPHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQJ0aiABIARqLQAAszgCAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AALM4AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRC+HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9kJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUECdCIEIQYCQCAEQTxxIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEECdGogASAEaiwAALI4AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGosAACyOAIAIANBBGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQvh0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvZCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBA3QiBCEGAkAgBEE4cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBA3RqIAEgBGotAAC4OQMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqLQAAuDkDACADQQhqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENsdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL2QkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqLAAAtzkDAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEaiwAALc5AwAgA0EIaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDkGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDbHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9QKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAEgCqcgCKdqIgVBAnRqKgIAIgs4AoABIAtDAAEAx15FIAtDAAAAR11FckUEQCAEIAVBAXRqIAv8ADsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAEAx15FIAtDAAAAR11Fcg0CIAQgC/wAOwEAIARBAmohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2h0gAkEoahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYUMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAvUCgMGfwN+AX0jAEHQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPnEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBjYCOCACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinaiIFQQJ0aioCACILOAKAASALQwAAgL9eRSALQwAAgEddRXJFBEAgBCAFQQF0aiAL/AE7AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASoCACILOAKwASALQwAAgL9eRSALQwAAgEddRXINAiAEIAv8ATsBACAEQQJqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEM0dIAJBKGoQzy8MAgsgAkHIAWpBh46cODYCACACQoeOnLjw4MGDBzcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqMQAANwMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqMQAANwMAIANBCGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQ2R0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEGAkAgBEE8cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAnRqIAEgBGotAAA2AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGotAAA2AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRC/HSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQYCQCAEQT5xIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEBdGogASAEai0AADsBAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AADsBACADQQJqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFEM0dIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQJ0IgQhBgJAIARBPHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQJ0aiABIARqLAAANgIADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqLAAANgIAIANBBGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5RkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQvx0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAnQiBCEGAkAgBEE8cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAnRqIAEgBGotAAA2AgAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGotAAA2AgAgA0EEaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDlGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDHHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEDdCIEIQYCQCAEQThxIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEDdGogASAEajAAADcDAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEajAAADcDACADQQhqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOQZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENYdIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgAL1wkCCn8DfiMAQbABayICJAAgAUEMaigCCCEFAkACQAJAAkACQAJAIAEQkjYiAwRAQcAAIQQgAkEQaiADENw7IAMoAhQhCSADKAIMIQcgAigCFCEKIAIoAhAhCCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBiADBEAgA0HAABCtNiIERQ0ECyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogByAFIAdqIAggChC/GAwBC0HAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0FIAMEQCADQcAAEK02IgRFDQILIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAFEN4QCyAFQQN0IgQhBgJAIARBOHEiAwRAIAQgA2tBQGsiBiAESQ0BC0HAACEDIAZBwAAQ0TQEQAJAIAYEQCAGQcAAEK02IgNFDQELIAJBADYCQCACIAM2AjggAiAGNgI0IAJBwAA2AjAgBARAIAQEQCADQQAgBPwLAAsgAigCQCELIAIoAjghAwsgAiAENgI8IAIgBSALajYCQCAJRQ0FIAUgCUYNBiAIBEAgAkHoAGogCCAKIAcgBRC/FCACQYgBaiEFIAEoAhAhASACKQOQASENA0ACQCANUEUEQCACKQOYASEMDAELA0ACfgJAIAIpA3giDEIDUgRAAkACQAJAIAxCAlENACACIAxQrUIBhjcDeCAMp0EBcUUNACACIAIpA4ABNwOoAQwBCyACKAKIAUUNASACQaABaiAFELYqIAIpA6ABIQwLIAxCAFINAgsgAkIDNwN4CyACKQNoIgxCAlENDCACQgA3A2ggAikDcAwBCyACKQOoAQshDSAMp0EBcUUNCiACIAIpA5gBQkB9Igw3A5gBIAIgDTcDkAEgDVANAAsLIAJCASANeiIOhiANhSINNwOQASADIA6nIAynaiIEQQN0aiABIARqMQAANwMADAALAAtBxIr/ABCyOwALQcAAIAYQoz0ACwwFC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAMQoz0AC0HAACADEKM9AAsgBUUNACABKAIQIQFBACEEA0AgAyABIARqMQAANwMAIANBCGohAyAFIARBAWoiBEcNAAsLIAJByABqIAJBHGoiBhCCFCACQegAaiIFEJcpIAJBOGoiASgCACEHIAIoAjwhBCABIAJB8ABqIgMpAgA3AwAgAikDMCEMIAIgAikCaDcDMCACQQA2AkAgAiAMNwJ0IAJBADYCcCACIAQ2AmwgAiAHNgJoIAJBCGogBRDXOyACKAIIIQdBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCaDcCCCABQRBqIAMpAgA3AgAgAUEYaiACQfgAaiIIKAIANgIAIAIgBDYCqAEgAiAHNgKkASACIAE2AqABIAJB3ABqIgEgAkGgAWoQ5BkgCCACQdgAaigCADYCACADIAJB0ABqKQIANwMAIAIgAikCSDcDaCACIAk2AnwgACABIAUQ1h0gAkEwahDPLyAGEM8vIAJBsAFqJAAPC0EEQRwQoz0AC0Hci/8AQSkgAkHoAGpB7I//AEGIjP8AENUeAAvXCQIKfwN+IwBBsAFrIgIkACABQQxqKAIIIQUCQAJAAkACQAJAAkAgARCSNiIDBEBBwAAhBCACQRBqIAMQ3DsgAygCFCEJIAMoAgwhByACKAIUIQogAigCECEIIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0GIAMEQCADQcAAEK02IgRFDQQLIAJCADcCKCACIAQ2AiQgAiADNgIgIAJBwAA2AhwgAkEcaiAHIAUgB2ogCCAKEL8YDAELQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQUgAwRAIANBwAAQrTYiBEUNAgsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAUQ3hALIAVBAXQiBCEGAkAgBEE+cSIDBEAgBCADa0FAayIGIARJDQELQcAAIQMgBkHAABDRNARAAkAgBgRAIAZBwAAQrTYiA0UNAQsgAkEANgJAIAIgAzYCOCACIAY2AjQgAkHAADYCMCAEBEAgBARAIANBACAE/AsACyACKAJAIQsgAigCOCEDCyACIAQ2AjwgAiAFIAtqNgJAIAlFDQUgBSAJRg0GIAgEQCACQegAaiAIIAogByAFEL8UIAJBiAFqIQUgASgCECEBIAIpA5ABIQ0DQAJAIA1QRQRAIAIpA5gBIQwMAQsDQAJ+AkAgAikDeCIMQgNSBEACQAJAAkAgDEICUQ0AIAIgDFCtQgGGNwN4IAynQQFxRQ0AIAIgAikDgAE3A6gBDAELIAIoAogBRQ0BIAJBoAFqIAUQtiogAikDoAEhDAsgDEIAUg0CCyACQgM3A3gLIAIpA2giDEICUQ0MIAJCADcDaCACKQNwDAELIAIpA6gBCyENIAynQQFxRQ0KIAIgAikDmAFCQH0iDDcDmAEgAiANNwOQASANUA0ACwsgAkIBIA16Ig6GIA2FIg03A5ABIAMgDqcgDKdqIgRBAXRqIAEgBGosAAA7AQAMAAsAC0HEiv8AELI7AAtBwAAgBhCjPQALDAULQdSK/wBBI0H4iv8AEMskAAtBwAAgAxCjPQALQcAAIAMQoz0ACyAFRQ0AIAEoAhAhAUEAIQQDQCADIAEgBGosAAA7AQAgA0ECaiEDIAUgBEEBaiIERw0ACwsgAkHIAGogAkEcaiIGEIIUIAJB6ABqIgUQlykgAkE4aiIBKAIAIQcgAigCPCEEIAEgAkHwAGoiAykCADcDACACKQMwIQwgAiACKQJoNwMwIAJBADYCQCACIAw3AnQgAkEANgJwIAIgBDYCbCACIAc2AmggAkEIaiAFENc7IAIoAgghB0EcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJoNwIIIAFBEGogAykCADcCACABQRhqIAJB+ABqIggoAgA2AgAgAiAENgKoASACIAc2AqQBIAIgATYCoAEgAkHcAGoiASACQaABahDhGSAIIAJB2ABqKAIANgIAIAMgAkHQAGopAgA3AwAgAiACKQJINwNoIAIgCTYCfCAAIAEgBRDaHSACQTBqEM8vIAYQzy8gAkGwAWokAA8LQQRBHBCjPQALQdyL/wBBKSACQegAakHsj/8AQYiM/wAQ1R4AC8MJAgl/A34jAEHAAWsiAiQAIAFBDGoQ2TwhBAJAAkACQCABEJI2IgMEQEHAACEFIAJBCGogAxDcOyADKAIUIQYgAygCDCEHIAIoAgwhCSACKAIIIQggBEEDdiAEQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQMgAwRAIANBwAAQrTYiBUUNAwsgAkIANwIgIAIgBTYCHCACIAM2AhggAkHAADYCFCACQRRqIAcgBCAHaiAIIAkQvxgMAQtBwAAhBSAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAiADBEAgA0HAABCtNiIFRQ0CCyACQgA3AiAgAiAFNgIcIAIgAzYCGCACQcAANgIUIAJBFGogBBDeEAsCQAJAAkAgBCIDQT9xIgUEQCADIAMgBWtBQGsiA0sNAQtBwAAhBSADQcAAENE0BEAgAwRAIANBwAAQrTYiBUUNBQsgAkEANgI4IAIgBTYCMCACIAM2AiwgAkHAADYCKCAEBEAgBARAIAVBACAE/AsACyACKAI4IQogAigCMCEFCyACIAQ2AjQgAiAEIApqIgM2AjggAiAGNgI8IAIgAzYCTCACIAU2AkggAiABNgJEIAIgAkEUajYCVCACIAJBPGo2AlAgAiACQfgAaiIBNgJAIAZFDQIgBCAGRg0DIAgEQCABIAggCSAHIAQQvxQgAkGYAWohAQNAAkAgAikDoAEiDFBFBEAgAikDqAEhCwwBCwNAAn4CQCACKQOIASILQgNSBEACQAJAAkAgC0ICUQ0AIAIgC1CtQgGGNwOIASALp0EBcUUNACACIAIpA5ABNwO4AQwBCyACKAKYAUUNASACQbABaiABELYqIAIpA7ABIQsLIAtCAFINAgsgAkIDNwOIAQsgAikDeCILQgJRDQkgAkIANwN4IAIpA4ABDAELIAIpA7gBCyEMIAunQQFxRQ0HIAIgAikDqAFCQH0iCzcDqAEgAiAMNwOgASAMUA0ACwsgAiAMQgEgDHoiDYaFNwOgASACQUBrIA2nIAunahDQDwwACwALQcSK/wAQsjsACwwEC0HUiv8AQSNB+Ir/ABDLJAALIARFDQBBACEDA0AgAkFAayADENAPIAQgA0EBaiIDRw0ACwsgAkHYAGogAkEUaiIHEIIUIAJB+ABqIgMQlykgAkEwaiACQYABaiIGKQIANwMAIAIpAyghCyACIAIpAng3AyggAkEANgI4IAIgCzcChAEgAkEANgKAASACIAQ2AnwgAiAFNgJ4IAIgAxDXOyACKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQYgBaiIIKAIANgIAIAIgBDYCSCACIAU2AkQgAiABNgJAIAJB7ABqIgEgAkFAaxDjGSACKAI8IQQgCCACQegAaigCADYCACAGIAJB4ABqKQIANwMAIAIgAikCWDcDeCACIAQ2AowBIAAgASADEMEdIAJBKGoQzy8gBxDPLyACQcABaiQADwtBBEEcEKM9AAtBwAAgAxCjPQALQdyL/wBBKSACQfgAakHsj/8AQYiM/wAQ1R4AC9cJAgp/A34jAEGwAWsiAiQAIAFBDGooAgghBQJAAkACQAJAAkACQCABEJI2IgMEQEHAACEEIAJBEGogAxDcOyADKAIUIQkgAygCDCEHIAIoAhQhCiACKAIQIQggBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQYgAwRAIANBwAAQrTYiBEUNBAsgAkIANwIoIAIgBDYCJCACIAM2AiAgAkHAADYCHCACQRxqIAcgBSAHaiAIIAoQvxgMAQtBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNBSADBEAgA0HAABCtNiIERQ0CCyACQgA3AiggAiAENgIkIAIgAzYCICACQcAANgIcIAJBHGogBRDeEAsgBUEBdCIEIQYCQCAEQT5xIgMEQCAEIANrQUBrIgYgBEkNAQtBwAAhAyAGQcAAENE0BEACQCAGBEAgBkHAABCtNiIDRQ0BCyACQQA2AkAgAiADNgI4IAIgBjYCNCACQcAANgIwIAQEQCAEBEAgA0EAIAT8CwALIAIoAkAhCyACKAI4IQMLIAIgBDYCPCACIAUgC2o2AkAgCUUNBSAFIAlGDQYgCARAIAJB6ABqIAggCiAHIAUQvxQgAkGIAWohBSABKAIQIQEgAikDkAEhDQNAAkAgDVBFBEAgAikDmAEhDAwBCwNAAn4CQCACKQN4IgxCA1IEQAJAAkACQCAMQgJRDQAgAiAMUK1CAYY3A3ggDKdBAXFFDQAgAiACKQOAATcDqAEMAQsgAigCiAFFDQEgAkGgAWogBRC2KiACKQOgASEMCyAMQgBSDQILIAJCAzcDeAsgAikDaCIMQgJRDQwgAkIANwNoIAIpA3AMAQsgAikDqAELIQ0gDKdBAXFFDQogAiACKQOYAUJAfSIMNwOYASACIA03A5ABIA1QDQALCyACQgEgDXoiDoYgDYUiDTcDkAEgAyAOpyAMp2oiBEEBdGogASAEai0AADsBAAwACwALQcSK/wAQsjsAC0HAACAGEKM9AAsMBQtB1Ir/AEEjQfiK/wAQyyQAC0HAACADEKM9AAtBwAAgAxCjPQALIAVFDQAgASgCECEBQQAhBANAIAMgASAEai0AADsBACADQQJqIQMgBSAEQQFqIgRHDQALCyACQcgAaiACQRxqIgYQghQgAkHoAGoiBRCXKSACQThqIgEoAgAhByACKAI8IQQgASACQfAAaiIDKQIANwMAIAIpAzAhDCACIAIpAmg3AzAgAkEANgJAIAIgDDcCdCACQQA2AnAgAiAENgJsIAIgBzYCaCACQQhqIAUQ1zsgAigCCCEHQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAmg3AgggAUEQaiADKQIANwIAIAFBGGogAkH4AGoiCCgCADYCACACIAQ2AqgBIAIgBzYCpAEgAiABNgKgASACQdwAaiIBIAJBoAFqEOEZIAggAkHYAGooAgA2AgAgAyACQdAAaikCADcDACACIAIpAkg3A2ggAiAJNgJ8IAAgASAFENodIAJBMGoQzy8gBhDPLyACQbABaiQADwtBBEEcEKM9AAtB3Iv/AEEpIAJB6ABqQeyP/wBBiIz/ABDVHgALwwkCCX8DfiMAQcABayICJAAgAUEMahDZPCEEAkACQAJAIAEQkjYiAwRAQcAAIQUgAkEIaiADENw7IAMoAhQhBiADKAIMIQcgAigCDCEJIAIoAgghCCAEQQN2IARBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNAyADBEAgA0HAABCtNiIFRQ0DCyACQgA3AiAgAiAFNgIcIAIgAzYCGCACQcAANgIUIAJBFGogByAEIAdqIAggCRC/GAwBC0HAACEFIARBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0CIAMEQCADQcAAEK02IgVFDQILIAJCADcCICACIAU2AhwgAiADNgIYIAJBwAA2AhQgAkEUaiAEEN4QCwJAAkACQCAEIgNBP3EiBQRAIAMgAyAFa0FAayIDSw0BC0HAACEFIANBwAAQ0TQEQCADBEAgA0HAABCtNiIFRQ0FCyACQQA2AjggAiAFNgIwIAIgAzYCLCACQcAANgIoIAQEQCAEBEAgBUEAIAT8CwALIAIoAjghCiACKAIwIQULIAIgBDYCNCACIAQgCmoiAzYCOCACIAY2AjwgAiADNgJMIAIgBTYCSCACIAE2AkQgAiACQRRqNgJUIAIgAkE8ajYCUCACIAJB+ABqIgE2AkAgBkUNAiAEIAZGDQMgCARAIAEgCCAJIAcgBBC/FCACQZgBaiEBA0ACQCACKQOgASIMUEUEQCACKQOoASELDAELA0ACfgJAIAIpA4gBIgtCA1IEQAJAAkACQCALQgJRDQAgAiALUK1CAYY3A4gBIAunQQFxRQ0AIAIgAikDkAE3A7gBDAELIAIoApgBRQ0BIAJBsAFqIAEQtiogAikDsAEhCwsgC0IAUg0CCyACQgM3A4gBCyACKQN4IgtCAlENCSACQgA3A3ggAikDgAEMAQsgAikDuAELIQwgC6dBAXFFDQcgAiACKQOoAUJAfSILNwOoASACIAw3A6ABIAxQDQALCyACIAxCASAMeiINhoU3A6ABIAJBQGsgDacgC6dqENEPDAALAAtBxIr/ABCyOwALDAQLQdSK/wBBI0H4iv8AEMskAAsgBEUNAEEAIQMDQCACQUBrIAMQ0Q8gBCADQQFqIgNHDQALCyACQdgAaiACQRRqIgcQghQgAkH4AGoiAxCXKSACQTBqIAJBgAFqIgYpAgA3AwAgAikDKCELIAIgAikCeDcDKCACQQA2AjggAiALNwKEASACQQA2AoABIAIgBDYCfCACIAU2AnggAiADENc7IAIoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogBikCADcCACABQRhqIAJBiAFqIggoAgA2AgAgAiAENgJIIAIgBTYCRCACIAE2AkAgAkHsAGoiASACQUBrEOMZIAIoAjwhBCAIIAJB6ABqKAIANgIAIAYgAkHgAGopAgA3AwAgAiACKQJYNwN4IAIgBDYCjAEgACABIAMQ2B0gAkEoahDPLyAHEM8vIAJBwAFqJAAPC0EEQRwQoz0AC0HAACADEKM9AAtB3Iv/AEEpIAJB+ABqQeyP/wBBiIz/ABDVHgAL1goCDX8CfiMAQeAAayICJAAgAkEQaiABQRhqKQIANwMAIAIgASkCECIPNwMIIAEoAgwhByABKAIIIQwgASgCBCEGIAEoAgAhBCABKAIgIQgCQCAPp0GAgICAeEYNACACKAIQQQN0IQEgAigCDCEDA0AgAQRAIAFBCGshASADLQAEIANBCGohAw0BDAILCyACQoSAgIDAADcCUCACQoCAgIDAADcCWCACQUBrIAJB0ABqEOcMIAIoAghBgICAgHhHBEAgAkEIakEEQQgQ4B4LIAJBEGogAkHIAGooAgA2AgAgAiACKQJANwMICwJAAkACQCAEBEACQCAGIAhNBEACQAJAIAIoAggiBUGAgICAeEYNACACKQIMIQ8gAiAFNgI0IAIgDzcCOCAGBEACQAJAIA9CgICAgBBaBEAgD6ciASAPQiCIpyINQQN0IgRqIQ5BACEDA0AgASgCACEJAkAgAUEEai0AAEEBRgRAIAkgCmohCgwBCyAJIAtqIgsgBksNAwsgAUEIaiEBIANBAWohAyAEQQhrIgQNAAsLIAJBADYCPCACKQI4IQ8MAQsgAkHQAGogDSADa0EBakEAQQRBCBCgGCACKAJUIQQgAigCUEEBRg0HIAJBADYCSCACIAIoAlgiAzYCRCACIAQ2AkAgBEUEQCACQUBrQeyCzQAQmyggAigCRCEDCyADQQE6AAQgAyAGIApqNgIAIAJBATYCSCACKAJAQQFGBEAgAkFAa0H8gs0AEJsoCyACKAJEIgMgCyAGazYCCCADQQA6AAwgAkECNgJIIA4gAUEIaiIJayIEQQN2IgUgAkFAayIBKAIAIAEoAggiA2tLBEAgASADIAVBBEEIENAoIAEoAgghAwsgBARAIAEoAgQgA0EDdGogCSAE/AoAAAsgASABKAIIIAVqNgIIIAIpAkQhDyACKAJAIQUgAkE0akEEQQgQ4B4LIAVBgICAgHhGDQELIAIgDzcCICACIAU2AhwMAQtBEEEEEK02IgFFDQUgAUEAOgAMIAEgCCAGazYCCCABQQE6AAQgASAGNgIAIAJBAjYCWCACIAE2AlAgAiABQRBqNgJcIAIgATYCVCACQRxqIAJB0ABqEOcMCyACQcgAaiACQSRqKAIANgIAIAIgAikCHDcDQAwBCyACQoSAgIDAADcCUCACQoCAgIDAADcCWCACQRxqIAJB0ABqEOcMIAJByABqIAJBJGooAgA2AgAgAiACKQIcNwNAIAIoAghBgICAgHhGDQAgAkEIakEEQQgQ4B4LIAJBEGogAkHIAGooAgA2AgAgAiACKQNANwMICyAMBEACQCACKAIIIgZBgICAgHhHBEAgAikCDCEQAkAgB0UEQCAQQv////8PgyEQDAELIBBCgICAgBBUDQAgEEIgiKciCEEDdCEEIBCnIgGtQoCAgIAQhCEPQQAhAwNAAkAgAUEEai0AAEUEQCAHIAEoAgAiBU0NASAHIAVrIQcLIAFBCGohASADQQFqIQMgD0KAgICAEHwhDyAEQQhrIgQNAQwCCwsgASAHNgIAIAMgCE8NACAPIRALIAIgEDcCLCACIAY2AigMAQtBCEEEEK02IgFFDQQgAUEAOgAEIAEgCCAHIAcgCEsbNgIAIAJBATYCWCACIAE2AlAgAiABQQhqNgJcIAIgATYCVCACQShqIAJB0ABqEOcMCyACQRBqIAJBMGooAgA2AgAgAiACKQIoNwMICyAAIAIpAwg3AgAgAEEIaiACQRBqKQMANwIAIAJB4ABqJAAPCyAEIAIoAlhB3ILNABD9LwALQQRBEBCjPQALQQRBCBCjPQAL3AoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQMgAkEQaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoAkAgA0UEQCACQgA3AjQgAigCEA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgI4IAIgAzYCNCACKAIQRQ0ECyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinaiIEQQJ0aioCACILOAKAASALQwAAgL9eRSALQwAAgENdRXJFBEAgBCAFaiAL/AE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQqAgAiCzgCsAEgC0MAAIC/XkUgC0MAAIBDXUVyDQIgASAFaiAL/AE6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL3AoDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAXQiBSEDAkACQCAAAn8CQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aisDACILOQN4IAtEAAAAAAAA8L9kRSALRAAAAAAAAPBAY0VyRQRAIAQgBUEBdGogC/wDOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYkMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQGNFcg0CIAQgC/wDOwEAIARBAmohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDhGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDNHSACQSBqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL2goDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQCAAAn8CQAJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aisDACILOQN4IAtEAAAgAAAA4MFkRSALRAAAAAAAAOBBY0VyRQRAIAQgBUECdGogC6o2AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKwMAIgs5A7ABIAtEAAAgAAAA4MFkRSALRAAAAAAAAOBBY0VyDQIgBCALqjYCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQvx0gAkEgahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGorAwAiCzkDeCALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQWNFckUEQCAEIAVBAnRqIAurNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGJDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAErAwAiCzkDsAEgC0QAAAAAAADwv2RFIAtEAAAAAAAA8EFjRXINAiAEIAurNgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDHHSACQSBqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGorAwAiCzkDeCALRAAAAAAgAODAZEUgC0QAAAAAAADgQGNFckUEQCAEIAVBAXRqIAv8AjsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGJDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAErAwAiCzkDsAEgC0QAAAAAIADgwGRFIAtEAAAAAAAA4EBjRXINAiAEIAv8AjsBACAEQQJqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ2h0gAkEgahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYkMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9wKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgASAKpyAIp2oiBEECdGoqAgAiCzgCgAEgC0MAAAHDXkUgC0MAAABDXUVyRQRAIAQgBWogC/wAOgAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYUMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKgIAIgs4ArABIAtDAAABw15FIAtDAAAAQ11Fcg0CIAEgBWogC/wAOgAAIARBBGohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9EKAwZ/A34BfSMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAEgCqcgCKdqQQJ0IgVqKgIAIgs4AoABIAtDAACAv15FIAtDAACAT11FckUEQCAEIAVqIAupNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAACAv15FIAtDAACAT11Fcg0CIAQgC6k2AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDHHSACQShqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYUMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAvPCgMGfwN+AX0jAEHQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBjYCOCACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiABIAqnIAinakECdCIFaioCACILOAKAASALQwAAAM9gRSALQwAAAE9dRXJFBEAgBCAFaiALqDYCAAwBCwsgAkG4AWpBhIiQIDYCACACQoSIkKDAgIGCBDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAAAz2BFIAtDAAAAT11Fcg0CIAQgC6g2AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC/HSACQShqEM8vDAILIAJByAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC4sNAhV/AX4jAEGQAWsiAiQAIAJBGGogASgCYCIIQQhqIgMQhDwgAiACKAIcIgY2AiQgAUHgAGohBAJAAn8CQCABKAIwQYCAgIB4RwRAIAJB4ABqIAFBMGoiA0EIaigCACIKNgIAIAIgAykCADcDWCAKQQJ0IQVBACEDIAIoAlwhCQNAIAMgBUYNAiADIAlqIANBBGohAygCACAGSQ0ACyACIAMgCWpBBGs2AiggAkECNgJsIAJB4NbDADYCaCACQgI3AnQgAkE7NgJEIAJB3AE2AjwgAiACQThqNgJwIAIgAkEkajYCQCACIAJBKGo2AjggAEEMaiACQegAahCZDiAAQgM3AwAgAEEANgIIIAJB2ABqEOk7IAEQ+yUgASgCYCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBBCXFQsgASgCZCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUHkAGoQ+CMLAkAgASgCaCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQegAahDbHgsgAUE8ahCGMCABQcgAahCeLyABQdQAahCOMCABKAJwIgBFDQMgACAAKAIAIgBBAWs2AgAgAEEBRw0DIAFB8ABqEIEsDAMLIAJBEGogAxCEPCACQegAaiACKAIUQZDQwwAQijsgAigCcCEKIAIoAmwhCSAEKAIAIQggAigCaAwBCyACKAJYCyEOIAgoAgghDCABKAJsIQ0gAkGAAWoiAyABQRhqKQMANwMAIAJB+ABqIgQgAUEQaikDADcDACACQfAAaiIGIAFBCGopAwA3AwAgAiABKQMANwNoIAJB4ABqIgUgAUHQAGooAgA2AgAgASkCSCEXIAggCCgCACIHQQFqNgIAIAIgFzcDWAJAIAdBAE4EQCACQUBrIAYpAwA3AwAgAkHIAGogBCkDADcDACACQdAAaiADKQMANwMAIAJBMGogBSgCADYCACACIAIpA2g3AzggAiACKQNYNwMoIAEoAnQhDyABKAJwIRAgASgCLCERIAEoAighEiABKAIkIRMgASgCICEUAkACfyABKAJoIgcEQCAHLQAUQSBHDQIjAEEwayIEJAAgBCABQTxqNgIAIARBBGohBiMAQUBqIgMkACADIAQ2AgwgA0EANgIQIAdBGGoiBSgCBCELIAUoAgAhBSADIANBEGo2AhggAyADQQxqNgIUIAMgBUEIaiIFNgIwIAMgBSALQQJ0ajYCNCADIANBFGo2AjggA0EcaiADQTBqEIoXIANBIGohBQJAIAMoAhwiC0GTgICAeEcEQCAGIAMoAiw2AhAgBiAFKQIANwIEIAZBDGogBUEIaigCADYCAAwBCyADQThqIAVBCGooAgAiFTYCACADIAUpAgA3AzAgAyADKAI0IhYgFiAVQQJ0ahCbGCADKQMAIRcgBRD4JSADQTBqQQRBBBDgHiAGIBc3AgQLIAYgCzYCACADQUBrJAAgBCgCBEGTgICAeEcEQCAEQShqIARBFGooAgA2AgAgBEEgaiAEQQxqKQIANwMAIAQgBCkCBDcDGEGw0MMAQSsgBEEYakGg0MMAQdjPwwAQ1R4ACyACQQhqIAQpAgg3AwAgBEEwaiQAIAIoAgghAyACKAIMDAELIAIQwSwgAigCACEDIAIoAgQLIQQgAkHoAGoiBiADIAQQzhxBMEEIEK02IgNFDQIgA0KBgICAEDcDACADQQhqIAZBKPwKAAAgACACKQM4NwMAIABBCGogAkFAaykDADcDACAAQRBqIAJByABqKQMANwMAIABBGGogAkHQAGopAwA3AwAgAEE4aiACQTBqKAIANgIAIAAgAikDKDcDMCAAIAEpAjw3AoABIABBiAFqIAFBxABqKAIANgIAIAAgASkCVDcCjAEgAEGUAWogAUHcAGooAgA2AgAgASgCYCEEIAAgDCANIAwgDUkbNgKgASAAIAM2ApwBIAAgBDYCmAEgAEGBgICAeDYCYCAAIAo2AlwgAEEANgJYIAAgCTYCVCAAIA42AlAgACAPNgJIIAAgEDYCRCAAIAc2AkAgACAINgI8IAAgETYCLCAAIBI2AiggACATNgIkIAAgFDYCICABKAJkIgAgACgCACIAQQFrNgIAIABBAUcNAyABQeQAahD4IwwDCyACQQA2AnggAkEBNgJsIAJBuNfDADYCaCACQgQ3AnAgAkHoAGpBwNfDABDvLAsAC0EIQTAQoz0ACyACQZABaiQAC+QKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEDIAJBCGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCKCACIAQ2AiQgAkHAADYCIAJAIANFBEAgAkIANwIsIAIoAggNAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCMCACIAM2AiwgAigCCEUNBAsgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIEQQN0aisDACILOQN4IAtEAAAAAAAA8L9kRSALRAAAAAAAAHBAY0VyRQRAIAQgBWogC/wDOgAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYkMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQrAwAiCzkDsAEgC0QAAAAAAADwv2RFIAtEAAAAAAAAcEBjRXINAiABIAVqIAv8AzoAACAEQQhqIQQgAyABQQFqIgFHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDjGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDBHSACQSBqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQAL5AoDBn8DfgF8IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKwMAIgs5A3ggC0QAAAAAACBgwGRFIAtEAAAAAAAAYEBjRXJFBEAgBCAFaiAL/AI6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCsDACILOQOwASALRAAAAAAAIGDAZEUgC0QAAAAAAABgQGNFcg0CIAEgBWogC/wCOgAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGJDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuICgIEfwZ+IwBB0ABrIgIkACACQUBrQgA3AwAgAkIANwM4IAIgACkDCCIGNwMwIAIgACkDACIHNwMoIAIgBkLzytHLp4zZsvQAhTcDICACIAZC7d6R85bM3LfkAIU3AxggAiAHQuHklfPW7Nm87ACFNwMQIAIgB0L1ys2D16zbt/MAhTcDCCACIAEoAgAiAC0AACIBNgJMIAJBCGogAkHMAGpBBBC7CQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQQ1rDhwAFBQBAgMEFAUUFBQUFAYHCAkKCwwNDg8QERITFAsgAiAALQABNgJMIAJBCGoiAyACQcwAaiIEQQQQuwkgAiAAKAIEIgFBAEc2AkwgAyAEQQQQuwkgAUUNEyADIAFBCGogACgCCBC7CSACQf8BOgBMIAMgBEEBELsJDBMLIAIgAC0AATYCTCACQQhqIAJBzABqQQQQuwkMEgsgAiAALQABNgJMIAJBCGogAkHMAGpBBBC7CQwRCyACIAAtAAE2AkwgAkEIaiACQcwAakEEELsJDBALIAIgAC0AATYCTCACQQhqIAJBzABqQQQQuwkMDwsgAiAAKAIENgJMIAJBCGogAkHMAGpBBBC7CQwOCyAAKAIEQQhqIAJBCGoQ2QoMDQsgACgCBEEIaiACQQhqENkKDAwLIAAoAghBCGogAkEIaiIBENkKIAIgACgCBDYCTCABIAJBzABqQQQQuwkMCwsgACgCBEEIaiACQQhqENkKDAoLIAAoAgRBCGogAkEIahDZCgwJCyAAQQRqIAJBCGoQ2iAMCAsgACgCBCACIAAoAggiBDYCTCACQQhqIgMgAkHMAGoiBUEEELsJQQhqIAQgAxDQIyACIAAtAAE2AkwgAyAFQQQQuwkMBwsgACgCBCACQQhqIgEQkwkgACgCCCABEJMJDAYLIAIgAC0AAToATCACQQhqIgEgAkHMAGoiA0EBELsJIAIgAC0AAjoATCABIANBARC7CQwFCyACIAAtAAE6AEwgAkEIaiIBIAJBzABqIgNBARC7CSACIAAtAAI6AEwgASADQQEQuwkMBAsgAiAALQABOgBMIAJBCGoiASACQcwAaiIDQQEQuwkgAiAALQACOgBMIAEgA0EBELsJDAMLIAIgAC0AAToATCACQQhqIgEgAkHMAGoiA0EBELsJIAIgAC0AAjoATCABIANBARC7CQwCCyAAKAIEQQhqIAJBCGoiARDZCiACIAAtAAE6AEwgASACQcwAakEBELsJDAELIAAoAgRBCGogAkEIaiIBENkKIAAoAghBCGogARDZCgsgAikDCCEHIAIpAxghBiACNQJAIQogAikDOCEIIAIpAyAgAikDECELIAJB0ABqJAAgCCAKQjiGhCIKhSIIQhCJIAggC3wiCIUiCUIViSAJIAYgB3wiB0IgiXwiCYUiC0IQiSALIAggBkINiSAHhSIGfCIHQiCJQv8BhXwiCIUiC0IViSALIAcgBkIRiYUiBiAJIAqFfCIHQiCJfCIKhSIJQhCJIAkgByAGQg2JhSIGIAh8IgdCIIl8IgiFIglCFYkgCSAHIAZCEYmFIgYgCnwiB0IgiXwiCoUiCUIQiSAJIAZCDYkgB4UiBiAIfCIHQiCJfCIIhUIViSAGQhGJIAeFIgZCDYkgBiAKfIUiBkIRiYUgBiAIfCIGQiCJhSAGhQu3CgIFfwR+IwBB8AFrIgMkACABQQxqENg8IQcgA0EwaiABEJI2EO4lIAdBA3QiBiEEAkACQAJ+AkACQAJAAkAgBkE4cSIFBEAgBiAFa0FAayIEIAZJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAyAFNgJQIAMgBDYCTCADQcAANgJIIAYEQCAFQQAgBvwLAAsgAyAHNgJYIAMgBjYCVCADKAIwRQ0DIAMoAkQgAygCQEYNBCADQegAaiADQTBqEMg0IANBiAFqIQQgAikDACEKIAEoAhAhASADKQOQASEJA0ACQCAJUEUEQCADKQOYASEIDAELA0ACfgJAIAMpA3giCEIDUgRAAkACQAJAIAhCAlENACADIAhQrUIBhjcDeCAIp0EBcUUNACADIAMpA4ABNwPIAQwBCyADKAKIAUUNASADQcABaiAEELYqIAMpA8ABIQgLIAhCAFINAgsgA0IDNwN4CyADKQNoIghCAlENCSADQgA3A2ggAykDcAwBCyADKQPIAQshCSAIp0EBcUUNByADIAMpA5gBQkB9Igg3A5gBIAMgCTcDkAEgCVANAAsLIANCASAJeiILhiAJhSIJNwOQASABIAunIAinakEDdCICaikDACEIIAMgCjcD6AEgAyAINwOgASADQSBqIAggCEI/hyAKIApCP4cQqB4gAykDKCADKQMgIghCP4dRBEAgAiAFaiAINwMADAELCyADQQI2AsQBIANBrJD/ADYCwAEgA0ICNwLMASADQYYMNgLkASADQYYMNgLcASADIANB2AFqNgLIASADIANB6AFqNgLgASADIANBoAFqNgLYASADQbABaiADQcABahCZDiADKQK4ASEJIAMpArABDAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HoAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAIpAwAhCSABKAIQIQFBACEEA0AgASkDACEIIAMgCTcD2AEgAyAINwPoASADQRBqIAggCEI/hyAJIAlCP4cQqB4gAykDGCADKQMQIghCP4dSDQIgBSAINwMAIAVBCGohBSABQQhqIQEgByAEQQFqIgRHDQALCyADQegAaiICEJcpIANB0ABqIgEoAgAhBiADKAJUIQQgASADQfAAaiIFKQIANwMAIAMpA0ghCSADIAMpAmg3A0ggA0EANgJYIAMgCTcCdCADQQA2AnAgAyAENgJsIAMgBjYCaCADQQhqIAIQ1zsgAygCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASADKQJoNwIIIAFBEGogBSkCADcCACABQRhqIANB+ABqIgcoAgA2AgAgAyAENgLIASADIAY2AsQBIAMgATYCwAEgA0HcAGoiASADQcABahDkGSAHIANBQGspAgA3AwAgBSADQThqKQIANwMAIAMgAykCMDcDaCAAIAEgAhDWHSADQcgAahDPLwwCCyADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYYMNgK4ASADQYYMNgKwASADIANBrAFqNgJwIAMgA0HYAWo2ArQBIAMgA0HoAWo2AqwBIANBxAFqIANB6ABqEJkOIAMpAswBIQkgAykCxAELIQggACAJNwIQIAAgCDcCCCAAQYiAgIB4NgIEIABBKToAACADQcgAahDPLyADKAIwIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBMGoQ+x4LIANB8AFqJAAPC0EEQRwQoz0AC54LAhN/A34jAEEgayIMJAAgCygCCCEPIAtCADcDCAJAIAQgB3EiFyADTQRAIAspAwAhICAAKAJEIRogAyAXayESIAIgF2ohFAJAIAAoAiAiE0UNAANAQRAgDSANQRBNGyEVIA8gFGohGCAGIA1BAnRqIRAgDyAXaiAESyEZA0ACQAJAIA0gFUcEQCAQKAIAIhYgCUsNAiAHIBZrIg4gB08gGXINAiAEIA5xIg4gD2oiESAETQ0BDAILIBVBEEG81c4AEMMhAAsCQAJAAkACQAJAIA8gEkkEQCADIBFNDQEgGC0AACACIBFqLQAARw0GIAMgDkkNAiACIA5qIAMgDmsgFCASIAgQsiAiEEECTSAQQQJHIA1BAUtycQ0FICAgECAOIAUQoS4iDiAaEPI0Ih9aDQUgDQ0DDAQLIA8gEkHM1c4AEMMhAAsgESADQdzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHs1c4AEO8sAAsgHyANEP8wfSEfCyAfICBYDQAgCyAWNgIQIAsgDjYCCCALIB83AwBBASEbIA4hDyAfISALIA1BAWoiDSATSQ0CDAMLIBBBBGohECANQQFqIg0gE0kNAAsLCyAANQI0IR8gFCASEO8gISECQAJAIAAoAgQiDiAhIB+IpyIGSwRAIAAoAgwiDSAGIAAoAkAiEHQiDkkNAkEBIBB0IhAgDSAOa0sNASAAKAI8IhUgEEkEQCAAKAIIIA5BAnRqIRggACgCACAGQQF0aiIZLwEAIgZFBEBBACEGDAYLIAYgEGsiDkEAIA5BAEobIRwgBiEOA0AgDyAUaiEdIA8gF2ogBEshHiAOIQ0CQAJAAkACQANAIA0gHE0NCyAQIA1BAWsiDiAVcSIRSwRAIAcgGCARQQJ0aigCACITayERAkAgHg0AIAQgE3EiEyAPaiIWIARLDQAgDyASTw0DIAMgFk0NBCAdLQAAIAIgFmotAABHDQAgCSARSQ0NIAMgE0kNBSACIBNqIAMgE2sgFCASIAgQ9AEiDUUNBiAgIA0gEyAFEKEuIg0gESAaEIwtIh9aDQYgCyARNgIQIAsgDTYCCCALIB83AwBBASEbIA0hDyAfISAMBgsgDUEBayENIAkgEUkNDAwBCwsgESAQQezUzgAQwyEACyAPIBJB/NTOABDDIQALIBYgA0GM1c4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBnNXOABDvLAALIAAoAjwhFQwACwALQZDUzgBBygBB3NTOABCfKQALIAYgDkHg084AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQfDTzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHQ084AEO8sAAsCfwJAIBAgBiAVcSICSwRAIBggAkECdGogBzYCACAZIBkvAQBBAWo7AQBBASAbDQIaIAENAUEADAILIAIgEEGs1c4AEMMhAAsgASECQQAhAUEAIQcgACgCMCIPIAAoAiwiA0EHdk8EQCAAKAJEIQ5BgIACIBQgEhDKICIGQQF0IgRrIgVBACAFQYCAAk0bIQ0gA0EBaiEFIAZBAnRBmJvSAGohBgNAAkAgDSABIgNHBEAgACAFNgIsIAYvAQAiAUUNASACIAEgFCASIAggCSAKIA4gCxDEEkUNAUEBIQcgACAPQQFqIg82AjAMAQsgBEGAgAJBhOLOABDDIQALQQEhASAFQQFqIQUgBkECaiEGIARBAWohBCADQQFxRQ0ACwsgBwsgDEEgaiQAC80KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAXRqLwEAIgE7AYIBIAFBgAFqQf//A3FB/wFNBEAgBSAGaiABOgAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAELwEAIgY7AbABIAZBgAFqQf//A3FB/wFLDQIgASAFaiAGOgAAIARBAmohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBigw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC9UJAgh/An4jAEHQAGsiAyQAAkAgAi0ADCIFQQFGBEAgACABKQIANwIAIABBCGogAUEIaikCADcCACACQQRBBBDgHgwBCwJAAkACQAJAAkACQAJAAkACQAJAIAEtAAwiBkEBaw4CAAIBCyAAIAIpAgA3AgAgAEEIaiACQQhqKQIANwIADAQLIAVFDQEMAgsgBUUNAQsgA0EoaiABQQhqIgQoAgA2AgAgAyABKQIAIgs3AyAgA0E4aiACQQhqIgUoAgA2AgAgAyACKQIAIgw3AzACfyALpyAMp0kEQCADQcgAaiAFKAIANgIAIAMgAikCADcDQCADQRRqIANBQGsgA0EgaiIBEO0IIAEMAQsgA0HIAGogBCgCADYCACADIAEpAgA3A0AgA0EUaiADQUBrIANBMGoiARDtCCABCyIEQQRBBBDgHiAGQQFHBEAgBkEBIAMoAhwbIQQMBgsgA0EANgIcIANBFGpBBEEEEJ4kIAMoAhwiAUUNBCADKAIYIgIgAUECdCIFakEEayIERQ0EIAQoAgANBCAFIQQgAkEEayEGIAFB/////wNxIQICQANAIARFBEBBACEEDAILIAJBAWshAiAEIAZqIARBBGshBCgCAEUNAAsgAkEBaiIEIAFLDQULIAMgBDYCHCAEIQEMBAsCQAJAAkACfyABKAIIIgQgAigCCCIHRwRAIAQgB0sgBCAHSWsMAQsgBEECdCEEIAEoAgRBBGshCSACKAIEQQRrIQoCQANAIARFDQEgBCAKaiEIIAQgCWogBEEEayEEKAIAIgcgCCgCACIIRg0ACyAHIAhLIAcgCElrDAELQX9BACAEGwtB/wFxDgIBAgALIANByABqIgQgAkEIaigCADYCACADIAIpAgA3A0AgA0FAayABEO8UIAQoAgAhAiADKQNAIQsgAUEEQQQQ4B4gACAFQQEgAhs6AAwgACACNgIIIAAgCzcCAAwHCyAAQQhqQZSKiAEpAgA3AgAgAEGMiogBKQIANwIAIAJBBEEEEOAeDAELIANByABqIgQgAUEIaigCADYCACADIAEpAgA3A0AgA0FAayACEO8UIANBOGogBCgCADYCACADIAMpA0A3AzAgAkEEQQQQ4B4gBkEBRwRAIAZBASADKAI4GyEEDAMLIANBADYCOCADQTBqQQRBBBCeJCADKAI4IgFFDQEgAygCNCICIAFBAnQiBWpBBGsiBEUNASAEKAIADQEgBSEEIAJBBGshBiABQf////8DcSECAkADQCAERQRAQQAhBAwCCyACQQFrIQIgBCAGaiAEQQRrIQQoAgBFDQALIAJBAWoiBCABSw0CCyADIAQ2AjggBCEBDAELIAFBBEEEEOAeDAQLQQEhBCABIAMoAjBBAnZPDQAgA0EIaiADQTBqIAFBBEEEEPQUIAMoAggiAUGBgICAeEYNACABIAMoAgxBzI2IARD9LwALIAAgAykDMDcCACAAIAQ6AAwgAEEIaiADQThqKAIANgIADAILQQEhBCABIAMoAhRBAnZPDQAgAyADQRRqIAFBBEEEEPQUIAMoAgAiAUGBgICAeEYNACABIAMoAgRBzI2IARD9LwALIAAgAykCFDcCACAAIAQ6AAwgAEEIaiADQRxqKAIANgIACyADQdAAaiQAC70KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIDIQQCQAJAIAACfwJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiAEIAqnIAinaiIGQQF0ai4BACIBOwGCASABQQBOBEAgBSAGQQJ0aiABQf//A3E2AgAMAQsLIAJBuAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQKMATcCDCAAQRRqIAJBlAFqKAIANgIAIAIoAogBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMuAQAiBDsBsAEgBEEASA0CIAUgBEH//wNxNgIAIAVBBGohBSADQQJqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQxx0gAkEoahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALvwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E+cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFBgIACakH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEGAgAJqQf//A0sNAiAFIAQ7AQAgBUECaiEFIANBBGohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDaHSACQShqEM8vDAILIAJByAFqQYOGjBg2AgAgAkKDhoyYsODAgQM3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBggw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7UOAhJ/AX4jAEFAaiIHJAAgAEEBNgLcBSAAQbgBaiABQawB/AoAACAAQYwCaiEBIAAoAowCQQFGBEAgASAAQbwBaigCACIGNgIUIAEoAgxFBEAgAUHAADYCDAsgASgCBCIFRQRAIAFBBiAGQQdrIgUgBUEGTRsiBTYCBAsgASgCCCEIIAEoAhBFBEAgASAGIAVrIgtBACAGIAtPGzYCEAsgASAIQQMgCBsiBiAFIAUgBksbNgIIC0EBIQkgACgC3AIiBkIBIAA1ArwBhiIXIAIgAiAXVhunIgVBASAFGyIFIAUgBksbIghBA0EDQQQgACgC2AIbIAAoAswBQQNGG24hCyAAKAKsAkUEQCAIEOcpQQFqIQ0LQQAgBSAIaiAAKAKoAhshDyAAQbwBaiEGIAdBKGogAUEQaikCADcDACAHQSBqIAFBCGopAgA3AwAgByABKQIANwMYIAdBGGogCBDaLiEQAkAgA0H/////BUsNACAAKADYECAAKADcEGtBgICA+HlLDQAgACgC4AVFIQkLIAAoAsgFQQBHIREgACgCvAIhCiAAKALYAiEOIAAoAtwCIQUjAEEwayIDJAAgBigCECESIAY1AgAhFyAGIApBAEEBEPgVIRMgA0EoaiABQRBqIhQpAgA3AwAgA0EgaiABQQhqIhUpAgA3AwAgAyABKQIANwMYQQEgA0EYaiIKKAIEIgwgCigCCGsiFkEAIAwgFk8bdEEIIAx0akEAIAooAgBBAUYbIQogA0EQaiAUKQIANwMAIANBCGogFSkCADcDACADIAEpAgA3AwAgAyAFQYCACCAFGyIFQQFCASAXhiIXIAIgAiAXVhunIAJQGyIMIAUgDEkbIgUQ2i4hDCABKAIAIQEgA0EwaiQAAkAgCiATIA9BiKsBQcCNASARG2ogDWogBUEDQQNBBCASQQNGGyAOG24iA0EDbGpqaiADQQN0QT9qQUBxaiAFaiAMQQxsQT9qQUBxQQAgAUEBRhtqIAVBA25BBHRBzwBqQUBxQQAgDhtqQSBqIgNBiH9LBEAgAyEBDAELIAAoAsgFIg5FBEAgACAAKAK4BEEBajYCuAQLIABBmARqIQUgACgCrAQgACgCpARrIANBA2xPBH8gACgCuARBgAFKBUEAC0UgAyAAKAKcBCAAKAKYBCIKa01xRQRAQUAhASAODQEgB0E4aiIJIABBwAVqKAAANgIAIAcgACkAuAU3AzAgBUEAQSz8CwAgB0EQaiAJKAIANgIAIAcgBykDMDcDCCAKIAdBCGoQiy0CfyAAKAC4BSIJBEAgACgAwAUgAyAJEQIADAELIAMQhi8LIglFDQEgBSAJIAMQyyggACAFQfQjENcnIgM2AtAQIANFDQEgACAFQfQjENcnIgM2AtQQIANFDQEgACAFQdjFABDXJyIDNgK4EkEBIQkgA0UNAQsgBRCELCAAQgA3A9AEIAAgAkIBfCICNwPIBCAAQdgEakIANwMAIABBqBJqIAZBGGooAgA2AgAgAEGgEmogBkEQaikCADcCACAAQZgSaiAGQQhqKQIANwIAIAAgBikCADcCkBIgACAAKALQAkEBRjYCsBIgAlAEQCAAQQA2AtgBCyAAIAg2AsQEIABB4ARqQQBB2AD8CwAgAEIANwOQBCAAQQE2AgAgAEL56tDQ58mh5OEANwOABSAAQs/W077Sx6vZQjcD8AQgAELW64Lu6v2J9eAANwPoBCAAKALQECIBQQg2AvAjIAFCgYCAgMAANwLoIyABQQA2AuQjIAFCADcC3CMgAUEANgKECCAAQdgQaiAFIAYgACgCvAIgBCAJQQEQ8AgiAUGIf0sNACAAIAUgC0EDdBDVNTYC5AUgACgCjAJBAUYEQCAAIAVBCCAAKAKQAnQiARDVNSIDNgKoBiABBEAgA0EAIAH8CwALIAUgEEEMbBDVNSEBIAAgEDYCuBAgACABNgK0ECAAQoKAgIAgNwKcBiAAQcu0wgA2ApgGIABBy7TCADYClAYgAEEANgKsBiAAQQA2AqQGIABBzbTCADYCkAYLIAAoAtgCBEAgACAIQQNuQQFqIgE2AsAdIAAgBSABQQR0ENU1NgK8HQsgBSAIQSBqEJA8IQEgACAPNgLEEiAAQQE2ArwSIAAgCDYChAYgACABNgLsBSAFIA8QkDwhASAAIA02AtgSIAAgATYCwBIgACAFIA0QkDw2AtQSAkAgACgCjAJBAUcNACAAIAVBASAAKAKQAiAAKAKUAmt0IgEQkDwiAzYCsAYgAUUNACADQQAgAfwLAAtBACEBAkAgACgCAEEBRw0AIAAoAowCQQFGDQAgAEEANgLMECAAQQA2AsgQIABBADYCvBAgAEIANwLAEAsgACALNgKABiAAIAUgCxCQPDYC9AUgACAFIAsQkDw2AvgFIAUgCxCQPCEDIABBATYC4AUgACADNgL8BQsgB0FAayQAIAELtwoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQoCAAnxC//8DWARAIAQgBUEBdGogCD0BAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGGDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEKAgAJ8Qv//A1YNAiAEIAg9AQAgBEECaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOEZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENodIAJBIGoQzy8MAgsgAkHIAWpBg4aMGDYCACACQoOGjJiw4MCBAzcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAvBCQIHfwN+IwBBkAFrIgIkACABQQxqENk8IQcgAkEQaiABEJI2EO4lIAdBAnQiBCEDAkACQAJAIARBPHEiBgRAIAQgBmtBQGsiAyAESQ0BC0HAACEGIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgZFDQELIAIgBjYCMCACIAM2AiwgAkHAADYCKCAEBEAgBkEAIAT8CwALIAIgBDYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQUgASgCECEHIAIpA3AhCgNAAkAgClBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogBRC2KiACKQOAASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQogCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAKNwNwIApQDQALCyACQgEgCnoiC4YgCoUiCjcDcAJ/IAcgC6cgCadqIghBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQEgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQiA0GAgID8B3IgAUUNARogAyABQQ10ckGAgID+B3IMAQsgBEEQdCIEIANBDXRBgICA/ABxIAFBDXRyQYCAgMADanIgAw0AGiABIAFnQRBrIgFB//8DcUEIanRB////A3EgBEGAgIDYA3IgAUEXdGtyCyEBIAYgCEECdGogATYCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAHRQ0AIAEoAhAhA0EAIQEDQCAGAn8gAy8BACIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSEEIAVBgIACcSEIIAVBgPgBcSIFQYD4AUYEQCAIQRB0IgVBgICA/AdyIARFDQEaIAUgBEENdHJBgICA/gdyDAELIAhBEHQiCCAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAUNABogBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIARBF3Rrcgs2AgAgBkEEaiEGIANBAmohAyAHIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQUgAigCNCEGIAEgAkHQAGoiBCkCADcDACACKQMoIQkgAiACKQJINwMoIAJBADYCOCACIAk3AlQgAkEANgJQIAIgBjYCTCACIAU2AkggAkEIaiADENc7IAIoAgghBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAGNgKIASACIAU2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQALvwoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQoCAgIAIfEL/////D1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhgw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhCgICAgAh8Qv////8PVg0CIAQgCD4CACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQvx0gAkEgahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC8MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2zwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFBgAFqQf8BTQRAIAUgBmogAToAAAwBCwsgAkG4AWpBgoSIEDYCACACQoKEiJCgwICBAjcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGCDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikAiQE3AAkgAEEQaiACQZABaikAADcAACACLQCIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCgCACIGNgKwASAGQYABakH/AUsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGCDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALtAoCBn8DfiMAQdABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZBAnRqIAFB/wFxNgIADAELCyACQbgBakGIkKDAADYCACACQoiQoMCAgYKECDcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGBDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgwFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikCjAE3AgwgAEEUaiACQZQBaigCADYCACACKAKIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQRBACEBA0AgAiABIARqLAAAIgM6ALABIANBAEgNAiAFIANB/wFxNgIAIAVBBGohBSAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDlGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDHHSACQShqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYEMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wNLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQzR0gAkEoahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYIMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wNNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYwMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wNLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQzR0gAkEoahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu1CgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH//wFNBEAgBSAGQQF0aiABOwEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYwMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEH//wFLDQIgBSAEOwEAIAVBAmohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ4RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQ2h0gAkEoahDPLwwCCyACQcgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu7CgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKQMAIgg3A3ggCEKAAXxC/wFYBEAgBCAFaiAIPAAADAELCyACQbgBakGChIgQNgIAIAJCgoSIkKDAgIECNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQpAwAiCDcDsAEgCEKAAXxC/wFWDQIgASAFaiAIPAAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAv5CAIFfwN+AkACQAJAIAFBCE8EQCABQQdxIgJFDQEgACgCoAEiA0EpTw0CIANFBEAgAEEANgKgAQwCCyADQQFrQf////8DcSIFQQFqIgRBA3EhBiACQQJ0QbjpiQFqKAIAIAJ2rSEJAkAgBUEDSQRAIAAhAgwBCyAEQfz///8HcSEFIAAhAgNAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgAgCX4gB0IgiHwiBz4CACACQQxqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAdCIIghCCACQRBqIQIgBUEEayIFDQALCyAGBEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEIIAZBAWsiBg0ACwsgACAHQoCAgIAQWgR/IANBKEYNBCAAIANBAnRqIAg+AgAgA0EBagUgAws2AqABDAELIAAoAqABIgNBKU8NASADRQRAIABBADYCoAEPCyABQQJ0QbjpiQFqNQIAIQkgA0EBa0H/////A3EiAUEBaiICQQNxIQYCQCABQQNJBEAgACECDAELIAJB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIBIAE1AgAgCX4gB0IgiHwiBz4CACACQQhqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBDGoiASABNQIAIAl+IAdCIIh8Igc+AgAgB0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAHQiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0DIAAgA0ECdGogCD4CACADQQFqBSADCzYCoAEPCwJAIAFBCHEEQCAAKAKgASIDQSlPDQICQCADRQRAQQAhAwwBCyADQQFrQf////8DcSICQQFqIgVBA3EhBgJAIAJBA0kEQEIAIQcgACECDAELIAVB/P///wdxIQVCACEHIAAhAgNAIAIgAjUCAELh6xd+IAd8Igc+AgAgAkEEaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBCGoiBCAENQIAQuHrF34gB0IgiHwiBz4CACACQQxqIgQgBDUCAELh6xd+IAdCIIh8Igg+AgAgCEIgiCEHIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCAELh6xd+IAd8Igg+AgAgAkEEaiECIAhCIIghByAGQQFrIgYNAAsLIAhCgICAgBBUDQAgA0EoRg0CIAAgA0ECdGogBz4CACADQQFqIQMLIAAgAzYCoAELIAFBEHEEQCAAQYzXiQFBAhC2CAsgAUEgcQRAIABBlNeJAUEDELYICyABQcAAcQRAIABBoNeJAUEFELYICyABQYABcQRAIABBtNeJAUEKELYICyABQYACcQRAIABB3NeJAUETELYICyAAIAEQtgYaDwsMAQsgA0EoQZCMigEQsDsAC0EoQShBkIyKARDDIQALtQoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJ+AkACQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAEgCqcgCadqIgVBAnRqKgIAIgs4AoABIAtDAAAA32BFIAtDAAAAX11FckUEQCAEIAVBA3RqIAuuNwMADAELCyACQbgBakGFipQoNgIAIAJChYqUqNCgwYIFNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYUMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKgIAIgs4ArABIAtDAAAA32BFIAtDAAAAX11Fcg0CIAQgC643AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDWHSACQShqEM8vDAILIAJByAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBhQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAIpAqQBIQggAikCnAELIQkgACAINwIQIAAgCTcCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALtwoDBn8DfgF9IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJ+AkACQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAGNgI4IAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAEgCqcgCadqIgVBAnRqKgIAIgs4AoABIAtDAACAv15FIAtDAACAX11FckUEQCAEIAVBA3RqIAuvNwMADAELCyACQbgBakGJkqTIADYCACACQomSpMiQocKECTcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGFDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgAFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAIpApABIQggAikCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASoCACILOAKwASALQwAAgL9eRSALQwAAgF9dRXINAiAEIAuvNwMAIARBCGohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2R0gAkEoahDPLwwCCyACQcgBakGJkqTIADYCACACQomSpMiQocKECTcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGFDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAu7CwIHfwF+IwBBkAVrIgIkAAJAAn8CQAJAAkACQAJAAkACQAJAAkAgAC0AuAFBAWsOAwcCAQALIABB2ABqIABB2AD8CgAACyAAQdgAaiEEAkACQCAALQCoAUEBaw4DBAIBAAsgAkEoaiAAKAKgASAAKAKkARD6KCACQegAaiACKAIoIAIoAiwQjzUgBCACQTBqQcQA/AoAACAAQQA6AJwBDAcLAkAgAC0AnAFBAWsOAwUBAAcLIABB8ABqIQcgAEGMAWohBQJAIAAtAIwBQQFrDgMEAQACCyAAKAKIASEGIAAoAoQBIQMMCAsACyAAKQNwIQkgACgCeAwFC0Gc3MIAEOgrAAtB9NbCABDoKwALQYzcwgAQ6CsAC0HcyMIAEOgrAAsgAkGwAWoiAyAAQZgBaigCADYCACACIAApApABNwOoASAAEOgmNgJsIABBADoAjAEgACAENgJ4IABCADcDcCAAQoCAwAA3A1ggAEHoAGogAygCADYCACAAIAIpA6gBNwJgIABBjAFqIQUgAEHwAGohByAECyEDIAAgCTcCfCACQQA6AIwFIAIgAzYCiAUgAkEgaiEDIAJBoAJqIQgCQEHwAkEIEK02IgYEQCAGIAhB8AL8CgAAIANB3N3CADYCBCADIAY2AgAMAQtBCEHwAhCjPQALIAIoAiAhAyAAIAIoAiQiBjYCiAEgACADNgKEAQsgAkGgAmogAyABIAYoAgwRAQACQAJAIAIoAqACIgFBCUYEQCAFQQM6AAAMAQsgAkGAAmoiBiACQbACaikDADcDACACIAIpA6gCNwP4ASACKAKkAiEDIABBhAFqELwqAkAgAUEIRwRAIAJBmAJqIAYpAwA3AwAgAiACKQP4ATcDkAIgAiADNgKMAiACIAE2AogCIAAoAnwiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEH8AGoQ+CMMAQsgAiAAKQJ8NwOgAiACQYgCaiADIAJBoAJqEO0BCyACQcABaiIDIAJBlAJqKAIANgIAIAIgAikCjAI3A7gBIAIpA5gCIQkgAigCiAIhASAFQQE6AAAgAUEJRg0AIAJB0AFqIgUgAygCADYCACACIAIpA7gBNwPIASAHEN8gAn4gAUEIRwRAIAJBrAJqIAUoAgA2AgAgAiACKQPIATcCpAIgAiAJNwOwAiACIAE2AqACIAJBoAJqENIZIQEgBBC9KkICDAELIAJB4AFqIABB5ABqKQIANwMAIAJB6AFqIABB7ABqKAIANgIAIAJB9AFqIAJB0AFqKAIANgIAIAIgAikDyAE3AuwBIAIgACkCXDcD2AEgACgCWCEBQgELIQlBASEDIABBAToAnAEgAkGMAWogAkHgAWopAwA3AgAgAkGUAWogAkHoAWopAwA3AgAgAkGcAWogAkHwAWopAwA3AgAgAiABNgKAASACIAk3A3ggAiACKQPYATcChAEgBBCrLCACQRhqIAJB+ABqEPUfIAIoAhwhBCACKAIYIQUgAEEBOgCoAUEDIQEgBUECRg0BAkAgBUEBcQRAIAIgBDYCMCACQYABNgKgAiACQQhqIABBtAFqIAJBoAJqIAJBMGoQwiMgAigCCCACKAIMENYvIgFBhAFPBEAgARDyHwsgAigCoAIiAUGEAU8EQCABEPIfCyACKAIwIgFBhAFJDQEgARDyHwwBCyACIAQ2AjAgAkGAATYCoAIgAkEQaiAAQbABaiACQaACaiACQTBqEMIjIAIoAhAgAigCFBDWLyIBQYQBTwRAIAEQ8h8LIAIoAqACIgFBhAFPBEAgARDyHwsgAigCMCIBQYQBSQ0AIAEQ8h8LIAAoArABIgFBhAFPBEAgARDyHwtBASEBQQAhAyAAKAK0ASIEQYQBSQ0BIAQQ8h8MAQtBAyEBIABBAzoAnAEgAEEDOgCoAUEBIQMLIAAgAToAuAEgAkGQBWokACADC7MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL/////D1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQKMATcCDCAAQRRqIAJBlAFqKAIANgIAIAIoAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQv////8PVg0CIAQgCD4CACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQxx0gAkEgahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuuCgIGfwN+IwBB0AFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBAXQiAyEEAkACQCAAAn8CQAJAAkACQCADQT5xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2pBAXQiBmouAQAiATsBggEgAUEATgRAIAUgBmogATsBAAwBCwsgAkG4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGIDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBggFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgAiADLgEAIgQ7AbABIARBAEgNAiAFIAQ7AQAgBUECaiEFIANBAmohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDaHSACQShqEM8vDAILIAJByAFqQYOGjBg2AgAgAkKDhoyYsODAgQM3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBiAw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC64KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQQCQAJAIAACfwJAAkACQAJAIANBPnEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgAiAEIAqnIAinakEBdCIGai4BACIBOwGCASABQQBOBEAgBSAGaiABOwEADAELCyACQbgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMuAQAiBDsBsAEgBEEASA0CIAUgBDsBACAFQQJqIQUgA0ECaiEDIAYgAUEBaiIBRw0ACwsgAkHIAGoiBRCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIEKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAUQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOEZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAFEM0dIAJBKGoQzy8MAgsgAkHIAWpBh46cODYCACACQoeOnLjw4MGDBzcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALswoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQv////8PWARAIAQgBUECdGogCD4CAAwBCwsgAkG4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC/////w9WDQIgBCAIPgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDHHSACQSBqEM8vDAILIAJByAFqQYiQoMAANgIAIAJCiJCgwICBgoQINwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYsMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikCoAE3AgwgAEEUaiACQagBaigCADYCACACKAKcAQs2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7sKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2zwhAyACQRBqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AigCQCADRQRAIAJCADcCNCACKAIQDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjggAiADNgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZBAnRqKAIAIgE2AoABIAFB/wFNBEAgBSAGaiABOgAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYIMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGAAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKAIAIgY2ArABIAZB/wFLDQIgASAFaiAGOgAAIARBBGohBCADIAFBAWoiAUcNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDBHSACQShqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBggw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7EKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL/////B1gEQCAEIAVBAnRqIAg+AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC/////wdWDQIgBCAIPgIAIARBBGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxC/HSACQSBqEM8vDAILIAJByAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBigw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AUsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGKDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALrQoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQF0IgUhAwJAAkAgAAJ/AkACQAJAAkAgBUE+cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBUEDdGopAwAiCDcDeCAIQv//A1gEQCAEIAVBAXRqIAg9AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBhgw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgAiABKQMAIgg3A7ABIAhC//8DVg0CIAQgCD0BACAEQQJqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQzR0gAkEgahDPLwwCCyACQcgBakGHjpw4NgIAIAJCh46cuPDgwYMHNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC60KAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAIAACfwJAAkACQAJAIAVBPnEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgVBA3RqKQMAIgg3A3ggCEL//wFYBEAgBCAFQQF0aiAIPQEADAELCyACQbgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYsMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQGKATcBCiAAQRBqIAJBkAFqKQEANwEAIAIvAYgBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQv//AVYNAiAEIAg9AQAgBEECaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOEZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENodIAJBIGoQzy8MAgsgAkHIAWpBg4aMGDYCACACQoOGjJiw4MCBAzcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGLDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAZ4BNwEKIABBEGogAkGkAWopAQA3AQAgAi8BnAELOwEIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAutCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAXQiBSEDAkACQCAAAn8CQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIFQQN0aikDACIINwN4IAhC//8DWARAIAQgBUEBdGogCD0BAAwBCwsgAkG4AWpBh46cODYCACACQoeOnLjw4MGDBzcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGLDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikBigE3AQogAEEQaiACQZABaikBADcBACACLwGIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEL//wNWDQIgBCAIPQEAIARBAmohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDhGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDNHSACQSBqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQGeATcBCiAAQRBqIAJBpAFqKQEANwEAIAIvAZwBCzsBCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQoAgAiBjYCsAEgBkH/AUsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGMDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDbPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkECdGooAgAiATYCgAEgAUH/AE0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQoAgAiBjYCsAEgBkH/AEsNAiABIAVqIAY6AAAgBEEEaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGMDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AU0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AUsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEMEdIAJBKGoQzy8MAgsgAkHIAWpBhoyYMDYCACACQoaMmLDgwIGDBjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGIDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALrgoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqQQJ0IgZqKAIAIgE2AoABIAFBAE4EQCAFIAZqIAE2AgAMAQsLIAJBuAFqQYSIkCA2AgAgAkKEiJCgwICBggQ3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAIgAygCACIENgKwASAEQQBIDQIgBSAENgIAIAVBBGohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQvx0gAkEoahDPLwwCCyACQcgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYwMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCAAIAIpAqABNwIMIABBFGogAkGoAWooAgA2AgAgAigCnAELNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBKGoQzy8gAigCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQRBqEPseCyACQdABaiQADwtBBEEcEKM9AAuwCgIGfwN+IwBB0AFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBAnQiAyEEAkACQCAAAn8CQAJAAkACQCADQTxxIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2pBAnQiBmooAgAiATYCgAEgAUEATgRAIAUgBmogATYCAAwBCwsgAkG4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBggw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAowBNwIMIABBFGogAkGUAWooAgA2AgAgAigCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAIgAygCACIENgKwASAEQQBIDQIgBSAENgIAIAVBBGohBSADQQRqIQMgBiABQQFqIgFHDQALCyACQcgAaiIFEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgQpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBRDXOyACKAIIIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAEKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AqABIAIgBjYCnAEgAiABNgKYASACQTxqIgEgAkGYAWoQ5RkgByACQSBqKQIANwMAIAQgAkEYaikCADcDACACIAIpAhA3A0ggACABIAUQxx0gAkEoahDPLwwCCyACQcgBakGIkKDAADYCACACQoiQoMCAgYKECDcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGCDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQKgATcCDCAAQRRqIAJBqAFqKAIANgIAIAIoApwBCzYCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALuwoCBn8DfiMAQdABayICJAAgAUEMahDZPCEDIAJBEGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKAJAIANFBEAgAkIANwI0IAIoAhANAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCOCACIAM2AjQgAigCEEUNBAsgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAIgBCAKpyAIp2oiBkEBdGovAQAiATsBggEgAUH/AE0EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiAw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYIBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQvAQAiBjsBsAEgBkH/AEsNAiABIAVqIAY6AAAgBEECaiEEIAMgAUEBaiIBRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOMZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENgdIAJBKGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJMIAJB+JL/ADYCSCACQgI3AlQgAkGtAzYCkAEgAkGIDDYCiAEgAiACQYQBajYCUCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJByABqEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALqQoCA38BfiMAQTBrIgMkACADQRBqIgRCADcDACADQRhqIgVCADcDACADQQhqIgYgAkEIaikCADcDACADIAIpAgA3AwAgAUEcaiABKAIUIAFBGGoiAigCACABKAIQKAIQEQEAIAFBKGogBSkDADcDACABQSBqIAQpAwA3AwAgAiAGKQMANwMAIAEgAykDADcDECABQQE6AGggAyABQRBqIgIQpRgCQAJAAkACQAJAIAMoAgBFBEAgA0EmQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQQgAygCCCICQbDBzgBBJvwKAAAgACACrUKAgICA4ASENwMIIAAgATYCBCAAQQI2AgAMAwsgAygCDARAIANBFEEAQQFBARCgGCADKAIEIQIgAygCAEEBRg0FIAMoAggiAUEQakHmwc4AKAAANgAAIAFBCGpB3sHOACkAADcAACABQdbBzgApAAA3AAAgAEEUNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAMLIAEgAygCCDYCTCADIAIQpRggAygCAEUEQCADQTFBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNBCADKAIIIgJB6sHOAEEx/AoAACAAIAKtQoCAgICQBoQ3AwggACABNgIEIABBAjYCAAwDCyADKAIMBEAgA0EfQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQUgAygCCCIBQRdqQbLCzgApAAA3AAAgAUEQakGrws4AKQAANwAAIAFBCGpBo8LOACkAADcAACABQZvCzgApAAA3AAAgAEEfNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAMLIAEgAygCCDYCVCADIAIQpRggAygCAEUEQCADQSdBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNBCADKAIIIgJBusLOAEEn/AoAACAAIAKtQoCAgIDwBIQ3AwggACABNgIEIABBAjYCAAwDCyADKAIMBEAgA0EVQQBBAUEBEKAYIAMoAgQhAiADKAIAQQFGDQUgAygCCCIBQQ1qQe7CzgApAAA3AAAgAUEIakHpws4AKQAANwAAIAFB4cLOACkAADcAACAAQRU2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAwsgASADKAIINgJQIANBIGogAhCFJiADIAMpAyAgAykDKBCsGiADKAIAIgJBCEcEQCADKAIEIQEgAykDCCEHIAAgAykDEDcDECAAIAc3AwggACABNgIEIAAgAjYCAAwDCyABQcwAaiECIAEgAykDCDcDCCABQgE3AwAgASgCTCIEQf8AcQ0AIAFB1ABqIgYoAgAiBUUNASAEIAQgBW4iBCAFbEcEQCADQQI2AgQgA0HswM4ANgIAIANCAjcCDCADQTs2AiwgAyAGNgIoIANBOzYCJCADIAI2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAwsgASAENgJYIAFCADcDYCABQQA2AkggBEEfcUUEQCAAQQg2AgAMAwsgA0EBNgIEIANBoMDOADYCACADQgE3AgwgA0E7NgIkIAMgAUHYAGo2AiAgAyADQSBqNgIIIABBBGogAxCjGCAAQQA2AgAMAgsgA0EBNgIEIANBqMHOADYCACADQgE3AgwgA0E7NgIkIAMgAjYCICADIANBIGo2AgggAEEEaiADEKMYIABBADYCAAwBC0HYv84AEOcrAAsgA0EwaiQADwsgASADKAIIQdinzgAQ/S8ACyACIAMoAghB2KfOABD9LwALiQsCE38CfiMAQSBrIgwkACALKAIIIQ8gC0IANwMIAkAgBCAHcSIXIANNBEAgCykDACEgIAAoAkwhGiADIBdrIRIgAiAXaiEUAkAgACgCOCITRQ0AA0BBECANIA1BEE0bIRUgDyAUaiEYIAYgDUECdGohECAPIBdqIARLIRkDQAJAAkAgDSAVRwRAIBAoAgAiFiAJSw0CIAcgFmsiDiAHTyAZcg0CIAQgDnEiDiAPaiIRIARNDQEMAgsgFUEQQbzVzgAQwyEACwJAAkACQAJAAkAgDyASSQRAIAMgEU0NASAYLQAAIAIgEWotAABHDQYgAyAOSQ0CIAIgDmogAyAOayAUIBIgCBCyICIQQQJNIBBBAkcgDUEBS3JxDQUgICAQIA4gBRChLiIOIBoQ8jQiH1oNBSANDQMMBAsgDyASQczVzgAQwyEACyARIANB3NXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQezVzgAQ7ywACyAfIA0Q/zB9IR8LIB8gIFgNACALIBY2AhAgCyAONgIIIAsgHzcDAEEBIRsgDiEPIB8hIAsgDUEBaiINIBNJDQIMAwsgEEEEaiEQIA1BAWoiDSATSQ0ACwsLAkACQAJAAkACQCAAIBQgEhCXHSIGIAAoAgQiDkkEQAJAIAAoAgwiDSAGIAAoAiQiEHQiDk8EQEEBIBB0IhAgDSAOa0sNASAQIAAoAiAiFk0NAyAAKAIIIA5BAnRqIRggACgCACAGQQF0aiIZLwEAIgZFBEBBACEGDAoLIAYgEGsiDkEAIA5BAEobIRwgBiEOA0AgDyAUaiEdIA8gF2ogBEshHgNAIA4hDQNAIA0gHE0NDCANQQFrIg4gFnEiESAQTw0HIAcgGCARQQJ0aigCACITayERAkAgHg0AIAQgE3EiEyAPaiIVIARLDQAgDyASTw0JIAMgFU0NCiAdLQAAIAIgFWotAABHDQAgCSARSQ0NIAMgE0kNCyACIBNqIAMgE2sgFCASIAgQ9AEiDUUNAiAgIA0gEyAFEKEuIg0gESAaEIwtIh9aDQIgCyARNgIQIAsgDTYCCCALIB83AwBBASEbIA0hDyAfISAMAwsgDUEBayENIAkgEU8NAAsLCwwJCyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHw084AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAYgDkHg084AEMMhAAtBkNTOAEHKAEHc1M4AEJ8pAAsgESAQQezUzgAQwyEACyAPIBJB/NTOABDDIQALIBUgA0GM1c4AEMMhAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBnNXOABDvLAALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQdDTzgAQ7ywACwJ/AkAgECAGIBZxIgJLBEAgGCACQQJ0aiAHNgIAIBkgGS8BAEEBajsBAEEBIBsNAhogAQ0BQQAMAgsgAiAQQazVzgAQwyEACyABIQJBACEBQQAhByAAKAJIIg8gACgCRCIDQQd2TwRAIAAoAkwhDkGAgAIgFCASEMogIgZBAXQiBGsiBUEAIAVBgIACTRshDSADQQFqIQUgBkECdEGYm9IAaiEGA0ACQCANIAEiA0cEQCAAIAU2AkQgBi8BACIBRQ0BIAIgASAUIBIgCCAJIAogDiALEMQSRQ0BQQEhByAAIA9BAWoiDzYCSAwBCyAEQYCAAkGE4s4AEMMhAAtBASEBIAVBAWohBSAGQQJqIQYgBEEBaiEEIANBAXFFDQALCyAHCyAMQSBqJAALqgoCBn8DfiMAQdABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBAJAAkAgAAJ/AkACQAJAAkAgA0E+cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZBAXRqIAE7AQAMAQsLIAJBuAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBgQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAYoBNwEKIABBEGogAkGQAWopAQA3AQAgAi8BiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAIgASAEaiwAACIDOgCwASADQQBIDQIgBSADOwEAIAVBAmohBSAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDhGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDNHSACQShqEM8vDAILIAJByAFqQYeOnDg2AgAgAkKHjpy48ODBgwc3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikBngE3AQogAEEQaiACQaQBaikBADcBACACLwGcAQs7AQggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7MKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhAyACQQhqIAEQkjYQ7iUgAyEEAkACQCAAAn8CQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiACQCADRQRAIAJCADcCLCACKAIIDQEMBgsgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIoAghFDQQLIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohAyABKAIQIQEgAikDaCEJA0ACQCAJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDoAEMAQsgAigCYEUNASACQZgBaiADELYqIAIpA5gBIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOgAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAJCASAJeiIKhiAJhSIJNwNoIAIgASAKpyAIp2oiBEEDdGopAwAiCDcDeCAIQv8AWARAIAQgBWogCDwAAAwBCwsgAkG4AWpBgoSIEDYCACACQoKEiJCgwICBAjcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGLDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJB+ABqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAAgAikAiQE3AAkgAEEQaiACQZABaikAADcAACACLQCIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyABKAIQIQRBACEBA0AgAiAEKQMAIgg3A7ABIAhC/wBWDQIgASAFaiAIPAAAIARBCGohBCADIAFBAWoiAUcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOMZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENgdIAJBIGoQzy8MAgsgAkHIAWpBgoSIEDYCACACQoKEiJCgwICBAjcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGLDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCAAIAIpAJ0BNwAJIABBEGogAkGkAWopAAA3AAAgAi0AnAELOgAIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuzCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQMgAkEIaiABEJI2EO4lIAMhBAJAAkAgAAJ/AkACQAJAAkAgA0E/cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIoIAIgBDYCJCACQcAANgIgAkAgA0UEQCACQgA3AiwgAigCCA0BDAYLIAMEQCAFQQAgA/wLAAsgAiADNgIwIAIgAzYCLCACKAIIRQ0ECyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCQNAAkAgCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDaCACIAEgCqcgCKdqIgRBA3RqKQMAIgg3A3ggCEL/AVgEQCAEIAVqIAg8AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgASgCECEEQQAhAQNAIAIgBCkDACIINwOwASAIQv8BVg0CIAEgBWogCDwAACAEQQhqIQQgAyABQQFqIgFHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDjGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDBHSACQSBqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgACACKQCdATcACSAAQRBqIAJBpAFqKQAANwAAIAItAJwBCzoACCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALswoCBn8DfiMAQdABayICJAAgAUEMahDYPCEDIAJBCGogARCSNhDuJSADIQQCQAJAIAACfwJAAkACQAJAIANBP3EiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCKCACIAQ2AiQgAkHAADYCIAJAIANFBEAgAkIANwIsIAIoAggNAQwGCyADBEAgBUEAIAP8CwALIAIgAzYCMCACIAM2AiwgAigCCEUNBAsgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQkDQAJAIAlQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A2ggAiABIAqnIAinaiIEQQN0aikDACIINwN4IAhC/wFYBEAgBCAFaiAIPAAADAELCyACQbgBakGGjJgwNgIAIAJChoyYsODAgYMGNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgACACKQCJATcACSAAQRBqIAJBkAFqKQAANwAAIAItAIgBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBEEAIQEDQCACIAQpAwAiCDcDsAEgCEL/AVYNAiABIAVqIAg8AAAgBEEIaiEEIAMgAUEBaiIBRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQwR0gAkEgahDPLwwCCyACQcgBakGGjJgwNgIAIAJChoyYsODAgYMGNwPAASACQQI2AkQgAkH4kv8ANgJAIAJCAjcCTCACQa0DNgKQASACQYYMNgKIASACIAJBhAFqNgJIIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkFAaxCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7wKAwZ/A34BfCMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACfgJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQMgASgCECEBIAIpA2ghCANAAkAgCFBFBEAgAikDcCEJDAELA0ACfgJAIAIpA1AiCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDUCAJp0EBcUUNACACIAIpA1g3A6ABDAELIAIoAmBFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDUAsgAikDQCIJQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQNwQkB9Igk3A3AgAiAINwNoIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDaCACIAEgCqcgCadqQQN0IgVqKwMAIgs5A3ggC0QAAAAAAADwv2RFIAtEAAAAAAAA8ENjRXJFBEAgBCAFaiALsTcDAAwBCwsgAkG4AWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAPC/ZEUgC0QAAAAAAADwQ2NFcg0CIAQgC7E3AwAgBEEIaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOQZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENkdIAJBIGoQzy8MAgsgAkHIAWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiQw2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAu6CgMGfwN+AXwjAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaisDACILOQN4IAtEAAAAAAAA4MNmRSALRAAAAAAAAOBDY0VyRQRAIAQgBWogC7A3AwAMAQsLIAJBuAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASsDACILOQOwASALRAAAAAAAAODDZkUgC0QAAAAAAADgQ2NFcg0CIAQgC7A3AwAgBEEIaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKgASACIAY2ApwBIAIgATYCmAEgAkE0aiIBIAJBmAFqEOQZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENYdIAJBIGoQzy8MAgsgAkHIAWpBhYqUKDYCACACQoWKlKjQoMGCBTcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGJDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7IKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBCACQRBqIAEQkjYQ7iUgBCEDAkACQCAAAn8CQAJAAkACQCAEQT9xIgUEQCAEIAVrQUBrIgMgBEkNAQtBwAAhBSADQcAAENE0BEACQCADBEAgA0HAABCtNiIFRQ0BCyACIAU2AjAgAiADNgIsIAJBwAA2AigCQCAERQRAIAJCADcCNCACKAIQDQEMBgsgBARAIAVBACAE/AsACyACIAQ2AjggAiAENgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBgQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBkEAIQMDQCACIAMgBmosAAAiAToAsAEgAUEASA0CIAMgBWogAToAACAEIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDBHSACQShqEM8vDAILIAJByAFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC7IKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBCACQRBqIAEQkjYQ7iUgBCEDAkACQCAAAn8CQAJAAkACQCAEQT9xIgUEQCAEIAVrQUBrIgMgBEkNAQtBwAAhBSADQcAAENE0BEACQCADBEAgA0HAABCtNiIFRQ0BCyACIAU2AjAgAiADNgIsIAJBwAA2AigCQCAERQRAIAJCADcCNCACKAIQDQEMBgsgBARAIAVBACAE/AsACyACIAQ2AjggAiAENgI0IAIoAhBFDQQLIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCACIAQgCqcgCKdqIgZqLAAAIgE6AIMBIAFBAE4EQCAFIAZqIAE6AAAMAQsLIAJBuAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBjQw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYMBajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCAAIAIpAIkBNwAJIABBEGogAkGQAWopAAA3AAAgAi0AiAEMBgtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAEoAhAhBkEAIQMDQCACIAMgBmosAAAiAToAsAEgAUEASA0CIAMgBWogAToAACAEIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDjGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDYHSACQShqEM8vDAILIAJByAFqQYKEiBA2AgAgAkKChIiQoMCAgQI3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBjQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAAgAikAnQE3AAkgAEEQaiACQaQBaikAADcAACACLQCcAQs6AAggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC88JAg1/A34jAEHQBGsiAiQAAkACQCABKQMAIg9CAlYNAAJAAkAgD6dBAWsOAgIAAQsgASkDECIPUEUEQCABQRhqIQYgASgCQEEIaiELIAJBwAJqQQRyIQogASkDCCEQIAJBDGohByACQUBrIQwgAkEoaiEDIAJB6AJqIQ0gAkHQAmohBCABKAIYIghFIQUDQAJAAkACQCAFRQRAIAJBwAJqIgUgCBDgFCACKALAAkEIRg0BIAYQny8gBkEANgIAIAIoAsACQQhHBEAgBRDJIwtBACEIDAMLIAJBwAJqIAsgEBD0DyADIApBCGopAgA3AwAgAiAKKQIANwMgIAIoAsACIgVBCEcEQCACQRhqIAJBKGopAwAiDzcDACACIAIpAyAiEDcDECACKALUAiEBIABBDGogDzcCACAAIBA3AgQgACABNgIUIAAgBTYCAAwICyACQQhqIAMpAwA3AwAgAiACKQMgNwMAIAJBwAJqIAIQ8hMCQAJAIAIpA8gCIhFCBFEEQCACQbgCaiAEQRBqKQMAIg83AwAgAkGwAmogBEEIaikDACIQNwMAIAIgBCkDACIRNwOoAiAAQRBqIA83AwAgAEEIaiAQNwMAIAAgETcDAAwBCyACQbACaiIJIARBCGopAwA3AwAgAkG4AmoiDiAEQRBqKQMANwMAIAIgBCkDADcDqAIgAigCwAIhBSAMIA1B6AH8CgAAIANBEGogDikDADcDACADQQhqIAkpAwA3AwAgAyACKQOoAjcDACACIBE3AyAgAkHAAmogBSAPEI4aIAIoAsACIglBCEYNASAAIAIpAsQCNwIEIABBFGogAkHUAmooAgA2AgAgAEEMaiACQcwCaikCADcCACAAIAk2AgAgAkEgahD8LAsgByACKAIEIAIoAgggAigCACgCEBEBAAwICyABIA8gBa0iEX0iDzcDECABIBAgEXwiEDcDCCACQcACaiIFIAJBIGoiCRDgFCACKALAAkEIRgRAIAJBuAJqIgQgAkHUAmooAgA2AgAgAkGwAmoiAyACQcwCaikCADcDACACIAIpAsQCNwOoAiAFIAlBiAL8CgAAQYgCQQgQrTYiAUUNAiABIAVBiAL8CgAAIAYQny8gAEEINgIAIAYgATYCACAAIAIpA6gCNwIEIABBDGogAykDADcCACAAQRRqIAQoAgA2AgAgByACKAIEIAIoAgggAigCACgCEBEBAAwICyACQcACahDJIyACQSBqEPwsIAcgAigCBCACKAIIIAIoAgAoAhARAQAMAgsgACACKQLEAjcCBCAAQQg2AgAgAEEUaiACQdQCaigCADYCACAAQQxqIAJBzAJqKQIANwIADAYLQQhBiAIQoz0AC0EBIQUgD1BFDQALCyAAQoiAgIAgNwMADAILIAEoAiwiBwRAIAEoAigiAyABKAIgIgRBACADIARPG2shCiABKAIkIQYgB0EBRiIHRQRAIAYgA0EBaiIDIARBACADIARPG2tBGGxqKAIIIQgLIABBADoAFCAAQQA2AgwgAEKIgICAEDcDACAAIAEoAjAgCCAHGyAGIApBGGxqKAIIazYCCAwCCyAAQoiAgIAgNwMADAELIABBAToAFCAAQQA2AgwgAEIINwMACyACQdAEaiQAC5gKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQQCQAJAIAACfwJAAkACQAJAIAVBPHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAIgAzYCKCACIAQ2AiQgAkHAADYCICAFBEAgA0EAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQQgASgCECEBA0ACQCACKQNoIglQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOoAQwBCyACKAJgRQ0BIAJBoAFqIAQQtiogAikDoAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6gBCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAiAJQgEgCXoiCoaFNwNoIAJB+ABqIAEgCqcgCKdqIgVBA3RqKQMAIggQ/RcgAigCeCIGBEAgAyAFQQJ0aiAGEMUkNgIADAELCyACIAg3A5gBIAJBJzYCzAEgAkGDj/8ANgLIASACQQM2AqQBIAJBxJL/ADYCoAEgAkICNwKsASACQe4GNgLEASACQcwBNgK8ASACIAJBuAFqNgKoASACIAJBmAFqNgLAASACIAJByAFqNgK4ASACQYgBaiACQaABahCZDiACKAKIASEDIAIpAowBIQggAigClAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEEA0AgAkG4AWogASkDACIIEP0XIAIoArgBIgVFDQIgAyAFEMUkNgIAIANBBGohAyABQQhqIQEgBiAEQQFqIgRHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJBNGoiASACQaABahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDSHSACQSBqEM8vDAILIAIgCDcDyAEgAkEnNgJ8IAJBg4//ADYCeCACQQM2AkQgAkHEkv8ANgJAIAJCAjcCTCACQe4GNgKQASACQcwBNgKIASACIAJBhAFqNgJIIAIgAkHIAWo2AowBIAIgAkH4AGo2AoQBIAJBpAFqIAJBQGsQmQ4gAigCpAEhAyACKQKoASEIIAIoArABCzYCFCAAIAg3AgwgACADNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuYCgIGfwN+IwBB0AFrIgIkACABQQxqENg8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEEAkACQCAAAn8CQAJAAkACQCAFQTxxIgMEQCAFIANrQUBrIgQgBUkNAQtBwAAhAyAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIDRQ0BCyACIAM2AiggAiAENgIkIAJBwAA2AiAgBQRAIANBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEEIAEoAhAhAQNAAkAgAikDaCIJUEUEQCACKQNwIQgMAQsDQAJ+AkAgAikDUCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNQIAinQQFxRQ0AIAIgAikDWDcDqAEMAQsgAigCYEUNASACQaABaiAEELYqIAIpA6ABIQgLIAhCAFINAgsgAkIDNwNQCyACKQNAIghCAlENCSACQgA3A0AgAikDSAwBCyACKQOoAQshCSAIp0EBcUUNByACIAIpA3BCQH0iCDcDcCACIAk3A2ggCVANAAsLIAIgCUIBIAl6IgqGhTcDaCACQfgAaiABIAqnIAinaiIFQQN0aikDACIIEIEVIAIoAngiBgRAIAMgBUECdGogBhDFJDYCAAwBCwsgAiAINwOYASACQSw2AswBIAJBgI7/ADYCyAEgAkEDNgKkASACQcSS/wA2AqABIAJCAjcCrAEgAkHuBjYCxAEgAkHMATYCvAEgAiACQbgBajYCqAEgAiACQZgBajYCwAEgAiACQcgBajYCuAEgAkGIAWogAkGgAWoQmQ4gAigCiAEhAyACKQKMASEIIAIoApQBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhBANAIAJBuAFqIAEpAwAiCBCBFSACKAK4ASIFRQ0CIAMgBRDFJDYCACADQQRqIQMgAUEIaiEBIAYgBEEBaiIERw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqgBIAIgBjYCpAEgAiABNgKgASACQTRqIgEgAkGgAWoQ5RkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ0h0gAkEgahDPLwwCCyACIAg3A8gBIAJBLDYCfCACQYCO/wA2AnggAkEDNgJEIAJBxJL/ADYCQCACQgI3AkwgAkHuBjYCkAEgAkHMATYCiAEgAiACQYQBajYCSCACIAJByAFqNgKMASACIAJB+ABqNgKEASACQaQBaiACQUBrEJkOIAIoAqQBIQMgAikCqAEhCCACKAKwAQs2AhQgACAINwIMIAAgAzYCCCAAQYKAgIB4NgIEIABBKToAACACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAWokAA8LQQRBHBCjPQALmAoCBn8DfiMAQdABayICJAAgAUEMahDYPCEGIAJBCGogARCSNhDuJSAGQQJ0IgUhBAJAAkAgAAJ/AkACQAJAAkAgBUE8cSIDBEAgBSADa0FAayIEIAVJDQELQcAAIQMgBEHAABDRNARAAkAgBARAIARBwAAQrTYiA0UNAQsgAiADNgIoIAIgBDYCJCACQcAANgIgIAUEQCADQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACKAIIRQ0DIAIoAhwgAigCGEYNBCACQUBrIAJBCGoQyDQgAkHgAGohBCABKAIQIQEDQAJAIAIpA2giCVBFBEAgAikDcCEIDAELA0ACfgJAIAIpA1AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDUCAIp0EBcUUNACACIAIpA1g3A6gBDAELIAIoAmBFDQEgAkGgAWogBBC2KiACKQOgASEICyAIQgBSDQILIAJCAzcDUAsgAikDQCIIQgJRDQkgAkIANwNAIAIpA0gMAQsgAikDqAELIQkgCKdBAXFFDQcgAiACKQNwQkB9Igg3A3AgAiAJNwNoIAlQDQALCyACIAlCASAJeiIKhoU3A2ggAkH4AGogASAKpyAIp2oiBUEDdGopAwAiCBD9FSACKAJ4IgYEQCADIAVBAnRqIAYQxSQ2AgAMAQsLIAIgCDcDmAEgAkErNgLMASACQdiO/wA2AsgBIAJBAzYCpAEgAkHEkv8ANgKgASACQgI3AqwBIAJB7gY2AsQBIAJBzAE2ArwBIAIgAkG4AWo2AqgBIAIgAkGYAWo2AsABIAIgAkHIAWo2ArgBIAJBiAFqIAJBoAFqEJkOIAIoAogBIQMgAikCjAEhCCACKAKUAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQQDQCACQbgBaiABKQMAIggQ/RUgAigCuAEiBUUNAiADIAUQxSQ2AgAgA0EEaiEDIAFBCGohASAGIARBAWoiBEcNAAsLIAJBQGsiAxCXKSACQShqIgEoAgAhBiACKAIsIQQgASACQcgAaiIFKQIANwMAIAIpAyAhCCACIAIpAkA3AyAgAkEANgIwIAIgCDcCTCACQQA2AkggAiAENgJEIAIgBjYCQCACIAMQ1zsgAigCACEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJANwIIIAFBEGogBSkCADcCACABQRhqIAJB0ABqIgcoAgA2AgAgAiAENgKoASACIAY2AqQBIAIgATYCoAEgAkE0aiIBIAJBoAFqEOUZIAcgAkEYaikCADcDACAFIAJBEGopAgA3AwAgAiACKQIINwNAIAAgASADENIdIAJBIGoQzy8MAgsgAiAINwPIASACQSs2AnwgAkHYjv8ANgJ4IAJBAzYCRCACQcSS/wA2AkAgAkICNwJMIAJB7gY2ApABIAJBzAE2AogBIAIgAkGEAWo2AkggAiACQcgBajYCjAEgAiACQfgAajYChAEgAkGkAWogAkFAaxCZDiACKAKkASEDIAIpAqgBIQggAigCsAELNgIUIAAgCDcCDCAAIAM2AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC5gKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkECdCIFIQQCQAJAIAACfwJAAkACQAJAIAVBPHEiAwRAIAUgA2tBQGsiBCAFSQ0BC0HAACEDIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgNFDQELIAIgAzYCKCACIAQ2AiQgAkHAADYCICAFBEAgA0EAIAX8CwALIAIgBjYCMCACIAU2AiwgAigCCEUNAyACKAIcIAIoAhhGDQQgAkFAayACQQhqEMg0IAJB4ABqIQQgASgCECEBA0ACQCACKQNoIglQRQRAIAIpA3AhCAwBCwNAAn4CQCACKQNQIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1AgCKdBAXFFDQAgAiACKQNYNwOoAQwBCyACKAJgRQ0BIAJBoAFqIAQQtiogAikDoAEhCAsgCEIAUg0CCyACQgM3A1ALIAIpA0AiCEICUQ0JIAJCADcDQCACKQNIDAELIAIpA6gBCyEJIAinQQFxRQ0HIAIgAikDcEJAfSIINwNwIAIgCTcDaCAJUA0ACwsgAiAJQgEgCXoiCoaFNwNoIAJB+ABqIAEgCqcgCKdqIgVBA3RqKQMAIggQ1hUgAigCeCIGBEAgAyAFQQJ0aiAGEMUkNgIADAELCyACIAg3A5gBIAJBLDYCzAEgAkGsjv8ANgLIASACQQM2AqQBIAJBxJL/ADYCoAEgAkICNwKsASACQe4GNgLEASACQcwBNgK8ASACIAJBuAFqNgKoASACIAJBmAFqNgLAASACIAJByAFqNgK4ASACQYgBaiACQaABahCZDiACKAKIASEDIAIpAowBIQggAigClAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEEA0AgAkG4AWogASkDACIIENYVIAIoArgBIgVFDQIgAyAFEMUkNgIAIANBBGohAyABQQhqIQEgBiAEQQFqIgRHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCqAEgAiAGNgKkASACIAE2AqABIAJBNGoiASACQaABahDlGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDSHSACQSBqEM8vDAILIAIgCDcDyAEgAkEsNgJ8IAJBrI7/ADYCeCACQQM2AkQgAkHEkv8ANgJAIAJCAjcCTCACQe4GNgKQASACQcwBNgKIASACIAJBhAFqNgJIIAIgAkHIAWo2AowBIAIgAkH4AGo2AoQBIAJBpAFqIAJBQGsQmQ4gAigCpAEhAyACKQKoASEIIAIoArABCzYCFCAAIAg3AgwgACADNgIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAuiCgIGfwN+IwBB0AFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiAyEEAkACQAJ+AkACQAJAAkAgA0E4cSIFBEAgAyAFa0FAayIEIANJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAiAFNgIwIAIgBDYCLCACQcAANgIoIAMEQCAFQQAgA/wLAAsgAiAGNgI4IAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEEIAIpA3AhCANAAkAgCFBFBEAgAikDeCEJDAELA0ACfgJAIAIpA1giCUIDUgRAAkACQAJAIAlCAlENACACIAlQrUIBhjcDWCAJp0EBcUUNACACIAIpA2A3A6ABDAELIAIoAmhFDQEgAkGYAWogAxC2KiACKQOYASEJCyAJQgBSDQILIAJCAzcDWAsgAikDSCIJQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDoAELIQggCadBAXFFDQcgAiACKQN4QkB9Igk3A3ggAiAINwNwIAhQDQALCyACQgEgCHoiCoYgCIUiCDcDcCACIAQgCqcgCadqIgZBAXRqLgEAIgE7AYIBIAFBAE4EQCAFIAZBA3RqIAGtQv//A4M3AwAMAQsLIAJBuAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYoMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkGCAWo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACAEEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgAiADLgEAIgQ7AbABIARBAEgNAiAFIAStQv//A4M3AwAgBUEIaiEFIANBAmohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDZHSACQShqEM8vDAILIAJByAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYoMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC+0IAgR/DH4jAEHAAWsiBCQAAkACQCACQSdPBEBBWiEFQgEhESABIAJBJmsiBmotAABBMGtB/wFxQQlLDQEgASACaiECA0AgBQRAIARBADYCjAEgBEHwAGogDiAPQgpCACAEQYwBahD2DCACIAVqLQAAQTBrIgdBCUsNBCAEKAKMAQ0EIAVBAWohBSAEKQN4IghCf4UgCCAIIAQpA3AiCiAHrXwiDiAKVK18Ig+Fg0IAWQ0BDAQLCyAEQZABaiABIAYgAxCCBiAEKAKQAUEBcQ0BAn4gBCkDsAEiCyAEKQOgASIIhCAEKQO4ASIKIAQpA6gBIgmEhFAEQEIAIQpCACELQgAMAQsgBEHgAGogCCAKQj+HIgiFIgwgCH0iEEIAQoCAgICAyIjFCUIAEKgeIARBQGsgCCAJhSISIAh9IAggDFYiAa19IgxCAEKAgICAgMiIxQlCABCoHiAEQdAAaiAQQgBC+oib1IWV053LAEIAEKgeIARBMGogDEIAQvqIm9SFldOdywBCABCoHiAEQRBqIAggC4UiDCAKQj+IfCILIAxUrSAIIAqFfCALIAEgCCASViAJUButIglUrX0iDEIAQoCAgICAyIjFCUIAEKgeIAQgCyAJfSIJQgBC+oib1IWV053LAEIAEKgeIARBIGogCUIAQoCAgICAyIjFCUIAEKgeIAQpAwggDCAEKQMYhIRCAFIgBCkDKCIJIAQpAxAgBCkDAHx8IhAgCVRyDQMgBCkDSCAEKQNoIgsgBCkDQHwiCSALVK18IhIgBCkDMHwiCyAEKQNYIAkgCSAEKQNQfCIJVq18fCIMIAQpAyB8IhMgDFQiASABrSALIAxWrSAEKQM4IAsgElStfHwiCyAQfHwiDCALVCALIAxRGw0DIAogCCAMhSAIfSAIIBOFIgogCFStfSAKIAh9IgsgBCkDYEKAgICAgHiDIAiFIgwgCFQiASAIIAmFIhAgCFQgCVAbrSIJVK19IgqFQgBTDQMgCyAJfSENIAwgCH0hCyAQIAh9IAGtfQshCSAKQgAgDyAOQgBSrXx9IA8gAxsiD0I/hyIMfCAMIA18IgggDVStfCAIIAtCACAOfSAOIAMbfCIQIAtUIgEgAa0gCSAPfHwiDyAJVCAJIA9RIgEbIgKtfCIOIAhUrXwhCAJAIAxCAFMEQCACIA0gDlYgCCAKUyAIIApRGyANIA6FIAggCoWEUBtFDQMMAQsgCyAQWCAJIA9YIAEbIA0gDlggCCAKWSAIIApRGyANIA6FIAggCoWEUBtBAUcNAgsgACAONwMgIAAgEDcDECAAIAg3AyggACAPNwMYQgAhEQwBCyAEQZABaiABIAIQ+gggBC0AkAFFBEAgBCkDqAEhDSAEKQOgASEIIABCACADrX0iCjcDKCAAIAo3AyAgAEIAIAh9IAggAxs3AxAgAEIAIA0gCEIAUq18fSANIAMbNwMYDAELQgEhEQwBC0IAIQ0LIAAgETcDACAAIA03AwggBEHAAWokAAuMCQEHfwJAAkAgAAJ/AkACQCABKAIgIgJBC3ZB/wFxIgRBP0cEQCAEQdsBRw0EIAEtAA1BCkcNBCABLQAQQQpHDQQgAS0AEiABLQARQQpsaiEGIAEtAA8gAS0ADkEKbGohBCABLQAMIAEtAAtBCmxqIQUgAS0AE0H+AUYNAiAFQf8BcSIDQRdLIARB/wFxIghBO0tyIQEgBkH/AXEiB0E8Rw0BQQAhAiABDQUgA0GQHGwgCEE8bGpBO2ohAkGAlOvcAyEBQRMMAwsgAS0ADCABLQALQQpsaiIEQf8BcUEXSyABLQAOIAEtAA1BCmxqIgVB/wFxQTtLciEGIAEtABAgAS0AD0EKbGoiAUH/AXFBPEYEQEEAIQIgBg0FIARB/wFxQZAcbCAFQf8BcUE8bGpBO2ohAkGAlOvcAyEBQREMAwtBACECIAYgAUH/AXEiAUE7S3INBCAFQf8BcUE8bCAEQf8BcUGQHGxqIAFqIQJBACEBQREMAgtBACECIAEgB0E7S3INAyAEQf8BcUE8bCAFQf8BcUGQHGxqIAZB/wFxaiECQQAhAUETDAELIAJBFHZBf3NoIgchAgJAAkACQAJAAkACQAJAAkACQAJAIAcOCQwBAgMEBQYHCAALIAFBFGohA0EAIQFBACECA0AgAiADai0AACABQQpsaiEBIAJBAWoiAkEJRw0ACwwICyABLQAUQYDC1y9sIQEMBwsgAUEUaiEDQQAhAkEAIQEDQCABIANqLQAAIAJBCmxqIQIgAUEBaiIBQQJHDQALIAJBgK3iBGwhAQwGCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBA0cNAAsgAkHAhD1sIQEMBQsgAUEUaiEDQQAhAkEAIQEDQCABIANqLQAAIAJBCmxqIQIgAUEBaiIBQQRHDQALIAJBoI0GbCEBDAQLIAFBFGohA0EAIQJBACEBA0AgASADai0AACACQQpsaiECIAFBAWoiAUEFRw0ACyACQZDOAGwhAQwDCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBBkcNAAsgAkHoB2whAQwCCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBB0cNAAsgAkHkAGwhAQwBCyABQRRqIQNBACECQQAhAQNAIAEgA2otAAAgAkEKbGohAiABQQFqIgFBCEcNAAsgAkEKbCEBCwJ/IAZB/wFxIgNBPEYEQCAFQf8BcSIDQRdLIARB/wFxIgRBO0tyDQNBACECIAFBgJTr3ANrQYDYqcZ4SQ0EIAFBgJTr3ANqIQEgA0GQHGwgBEE8bGpBO2oMAQsgBUH/AXEiBUEXSyAEQf8BcUE7S3IgBkH/AXEiAkE7S3INAiABQYCU69wDTwRAIAJBO0cNA0EAIQIgAUH/p9a5B0sNBAsgBEH/AXFBPGwgBUGQHGxqIANqCyECIAdBFGoLNgIMIAAgATYCCCAAIAI2AgRBASECDAELQQAhAgsgACACNgIAC5kKAgZ/A34jAEHQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEDdCIDIQQCQAJAAn4CQAJAAkACQCADQThxIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AjAgAiAENgIsIAJBwAA2AiggAwRAIAVBACAD/AsACyACIAY2AjggAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQQgAikDcCEIA0ACQCAIUEUEQCACKQN4IQkMAQsDQAJ+AkAgAikDWCIJQgNSBEACQAJAAkAgCUICUQ0AIAIgCVCtQgGGNwNYIAmnQQFxRQ0AIAIgAikDYDcDoAEMAQsgAigCaEUNASACQZgBaiADELYqIAIpA5gBIQkLIAlCAFINAgsgAkIDNwNYCyACKQNIIglCAlENCSACQgA3A0ggAikDUAwBCyACKQOgAQshCCAJp0EBcUUNByACIAIpA3hCQH0iCTcDeCACIAg3A3AgCFANAAsLIAJCASAIeiIKhiAIhSIINwNwIAIgBCAKpyAJp2oiBmosAAAiAToAgwEgAUEATgRAIAUgBkEDdGogAa1C/wGDNwMADAELCyACQbgBakGJkqTIADYCACACQomSpMiQocKECTcDsAEgAkECNgKcASACQfiS/wA2ApgBIAJCAjcCpAEgAkGtAzYCzAEgAkGBDDYCxAEgAiACQcABajYCoAEgAiACQbABaiIBNgLIASACIAJBgwFqNgLAASACQYgBaiACQZgBahCZDiABEKUMIAIpApABIQggAikCiAEMBgtBwAAgBBCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEEQQAhAQNAIAIgASAEaiwAACIDOgCwASADQQBIDQIgBSADrUL/AYM3AwAgBUEIaiEFIAYgAUEBaiIBRw0ACwsgAkHIAGoiBRCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIEKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAUQ1zsgAigCCCEGQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBCkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKgASACIAY2ApwBIAIgATYCmAEgAkE8aiIBIAJBmAFqEOQZIAcgAkEgaikCADcDACAEIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAFENkdIAJBKGoQzy8MAgsgAkHIAWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A8ABIAJBAjYCTCACQfiS/wA2AkggAkICNwJUIAJBrQM2ApABIAJBgQw2AogBIAIgAkGEAWo2AlAgAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQcgAahCZDiABEKUMIAIpAqQBIQggAikCnAELIQkgACAINwIQIAAgCTcCCCAAQYKAgIB4NgIEIABBKToAACACQShqEM8vIAIoAhAiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEQahD7HgsgAkHQAWokAA8LQQRBHBCjPQALmAoCBn8DfiMAQdABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBAJAAkACfgJAAkACQAJAIANBOHEiBQRAIAMgBWtBQGsiBCADSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAIgBTYCMCACIAQ2AiwgAkHAADYCKCADBEAgBUEAIAP8CwALIAIgBjYCOCACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhBCACKQNwIQgDQAJAIAhQRQRAIAIpA3ghCQwBCwNAAn4CQCACKQNYIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1ggCadBAXFFDQAgAiACKQNgNwOgAQwBCyACKAJoRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1gLIAIpA0giCUICUQ0JIAJCADcDSCACKQNQDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDeEJAfSIJNwN4IAIgCDcDcCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A3AgAiAEIAqnIAmnaiIGQQJ0aigCACIBNgKAASABQQBOBEAgBSAGQQN0aiABrTcDAAwBCwsgAkG4AWpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBggw2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQYABajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAQQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCACIAMoAgAiBDYCsAEgBEEASA0CIAUgBK03AwAgBUEIaiEFIANBBGohAyAGIAFBAWoiAUcNAAsLIAJByABqIgUQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBCkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAFENc7IAIoAgghBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAQpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCoAEgAiAGNgKcASACIAE2ApgBIAJBPGoiASACQZgBahDkGSAHIAJBIGopAgA3AwAgBCACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBRDZHSACQShqEM8vDAILIAJByAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwPAASACQQI2AkwgAkH4kv8ANgJIIAJCAjcCVCACQa0DNgKQASACQYIMNgKIASACIAJBhAFqNgJQIAIgAkHAAWoiATYCjAEgAiACQbABajYChAEgAkGcAWogAkHIAGoQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEoahDPLyACKAIQIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBEGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC/sLAgZ/AX4jAEHAAWsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIgA0EQaiIFKAIQTwRAAkACQAJAAkACQAJAIAMoAgBBAWsOBQECAwUFAAsgBEH4AGoiBiADKAI8QQBBEEEQEKAYIAQoAnwhAyAEKAJ4QQFGDQYgBEEANgIsIAQgBCgCgAE2AiggBCADNgIkIAYgBRDJNCAEQewAaiAGENUJIAQoAmxBAUYEQANAIAQoAnQiAyAEKAJwIgVJDRAgAiADSQ0RIARBJGogASAFQQR0aiABIANBBHRqEOsjIARB7ABqIARB+ABqENUJIAQoAmwNAAsLIARBgAFqIARBLGooAgA2AgAgBCAEKQIkNwN4IAAgBEH4AGoQ7xgMAwsgBEH4AGoiBiAFIAMoAjwQsSYgBEEwaiAGQTj8CgAAIAQoArQBIQMgBCAEKAKwASIIQQR0IgU2AiQgBSEGIAVBMHEiBwRAIAUgB2tBQGsiBiAFSQ0HC0HAACEHIAZBwAAQ0TRFDQcgBgRAIAZBwAAQrTYiB0UNCQsgBEH4AGoiCSAEQTBqQTj8CgAAIAQgAjYCvAEgBCABNgK4ASAEIAM2ArQBIAQgCDYCsAEgBEEYaiAJENYQIAchAyAEKAIYQQFxBEAgBCgCHCEBA0AgASAEKAK8ASICTw0LIAQoArgBIAFBBHRqIgEpAwAhCiADIAEpAwg3AAggAyAKNwAAIANBEGohAyAEQRBqIARB+ABqENYQIAQoAhQhASAEKAIQQQFxDQALCyAEIAMgB2siATYCbCABIAVHDQogBCAGNgKIASAEQoCAgICACDcCgAEgBCAFNgJ8IAQgBzYCeCAEQQhqIARB+ABqENc7IAQoAgghAkEcQQQQrTYiAUUNCyABQoGAgIAQNwIAIAEgBCkCeDcCCCAAIAU2AgggACACNgIEIAAgATYCACABQRBqIARBgAFqKQIANwIAIAFBGGogBEGIAWooAgA2AgAMAgsgAygCCCEFIAMoAgwhAyAEIAI2AoQBIAQgATYCgAEgBCAFIANBAnRqNgJ8IAQgBTYCeCMAQSBrIgIkACACQRRqIARB+ABqIgEoAgQgASgCAGtBAnZBAEEQQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBoIKDARD9LwALIARB7ABqIQYgAkEQaiIIQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACABKAIEIAEoAgBrQQJ2IgkgAkEIaiIFKAIAIAUoAggiB2tLBEAgBSAHIAlBEEEQEN4oIAUoAgghBwsgAyAFKAIENgIMIAMgBzYCCCADIAVBCGo2AgQgASADQQRqEJEZIANBEGokACAGQQhqIAgoAgA2AgAgBiACKQIINwIAIAJBIGokACAAIAYQ7xgMAQsgBEH4AGogAygCPEEAQRBBEBCgGCAEKAJ8IQUgBCgCeEEBRg0KIARBADYCdCAEIAQoAoABNgJwIAQgBTYCbCADKAIMIgUEQCADKAIIIgMgBUEDdGohBwNAIANBBGooAgAiBSADKAIAIgZJDQ8gAiAFSQ0QIARB7ABqIAEgBkEEdGogASAFQQR0ahDrIyADQQhqIgMgB0cNAAsLIARBgAFqIARB9ABqKAIANgIAIAQgBCkCbDcDeCAAIARB+ABqEO8YCyAEQcABaiQADwtB/K2DAUEoQdyvgwEQnykAC0G0roMBQThB7K6DARCfKQALIAMgBCgCgAFB/K6DARD9LwALQfT5ggFBI0GY+oIBEMskAAtBuPqCAUEpIARB+ABqQbCCgwFB5PqCARDVHgALQcAAIAYQoz0ACyABIAJB7K+DARDDIQALIARCADcChAEgBEKBgICAwAA3AnwgBEGo+4IBNgJ4QQAgBEHsAGogBEEkaiAEQfgAakGw+4IBEK8rAAtBBEEcEKM9AAsgBSAEKAKAAUGsr4MBEP0vAAsgBSADQYyvgwEQsTsACyADIAJBjK+DARCwOwALIAYgBUG8r4MBELE7AAsgBSACQbyvgwEQsDsAC/4RAgt/An4jAEHgAGsiAiQAIAEoAhAhBwJAAkACfwJAAkACQAJAAkAgASgCAEGAgICAeEYiA0UEQCAHRQ0CQQAgASADGyEDDAELIAJByABqIAEoAhQgByABKAIYKAIUEQEAIAIoAkgiA0EIRg0BIAJBMGogAkHYAGopAwA3AwAgAiACKQNQNwMoIAIgAigCTDYCJCACIAM2AiAMAwsCQANAIAEoAgxFDQIDQAJAIAMoAgwiBUUEQEECIQQMAQsgAyAFQQFrNgIMIAMgAygCCCIEQQFqIgUgAygCACIGQQAgBSAGTxtrNgIIIAMoAgQgBEEDdGoiBS0ABCEEIAUoAgAhBQsgAiAEOgAEIAIgBTYCACACLQAEIgVBAkYNAiACIAIoAgAiBDYCQCACIAVBAXEiBToARAJAAkAgBUUEQCAERQ0BAkAgBCAHIAprIgVJDQAgBCAFayILRQ0AIAMgAygCDCIEIAMoAgAiBkYEfyADKAIAIQQgA0GYqs8AEJsoAkAgAygCCCIIIAQgAygCDCIJa00NACAEIAhrIgYgCSAGayIJSyADKAIAIgwgBGsgCU9xRQRAIAwgBmshBCAGQQN0IgYEQCADKAIEIgkgBEEDdGogCSAIQQN0aiAG/AoAAAsgAyAENgIIDAELIAlBA3QiBkUNACADKAIEIgggBEEDdGogCCAG/AoAAAsgAygCACEGIAMoAgwFIAQLQQFqNgIMIAMgBiADKAIIQQFrIgRqIgYgBCAEIAZLGyIENgIIIAMoAgQgBEEDdGoiBEEAOgAEIAQgCzYCACAFIQQLIAJByABqIAEoAhQgBCABKAIYKAIUEQEAIAIoAkwhBCACKAJIIgVBCEcEQCACQTBqIAJB2ABqKQMANwMAIAIgAikDUDcDKCACIAQ2AiQgAiAFNgIgDAgLIARFDQYgBCAKaiIKIAdPDQYMBAsgAkHIAGogASgCFCAEIAEoAhgoAhwRAQAgAigCTCEFIAIoAkgiBkEIRwRAIAJBMGogAkHYAGopAwA3AwAgAiACKQNQNwMoIAIgBTYCJCACIAY2AiAMBwsgAiAFNgI8IAQgBUcNAQsgASgCDA0BDAQLCwsgAkECNgJMIAJBzKrPADYCSCACQgI3AlQgAkE7NgIUIAJBOzYCDCACIAJBCGo2AlAgAiACQTxqNgIQIAIgAkFAazYCCCACQSBqQQRyIAJByABqEJkOIAJBADYCIAwCC0GIqs8AELI7AAsgAkHIAGogASgCFCABKAIYKAIYEQAAIAIoAlAhAyACKAJMIQEgAigCSCIEQQhHBEAgAkE0aiACQdwAaigCADYCACACIAIpAlQ3AiwgAiADNgIoIAIgATYCJCACIAQ2AiAMAQsgAiADNgJEIAIgATYCQCMAQSBrIgMkACADQQhqIAJBQGsiBCgCACAEKAIEIgUoAghBAWtBeHFqQQhqIAUoAhARAAAgA0EQaiADKAIIIgUgAygCDCgCDBEAACADKQMYIQ0gAykDECEOIANBIGokACAFQQAgDkK+uaqJmdKNmuAAhSANQsWRgbqRwsPNNIWEUBsiB0UEQCACQcgAaiIDQS5BAEEBQQEQoBggAigCTCEBIAIoAkhBAUYNBiACKAJQIgVB3KrPAEEu/AoAACACQS42AlQgAiAFNgJQIAIgATYCTCACQY6AgIB4NgJIIAJBIGogAxCmJSACKAJAIgEgASgCACIBQQFrNgIAIAFBAUcNASAEELsjDAELIAcoAhgEfyACQcgAaiEFQQAhCkEAIQZBACEJQQAhBEEAIQEjAEFAaiIDJAAgBygCGCELIANBNGogB0EMahDTBgJAAkAgBygCHCIIBEAgCCAIKAIAIgFBAWo2AgAgAUEASA0BIAcoAiwhBiAHKAIoIQkgBygCJCEEIAcoAjAhCiAHKAIgIQELIAMgBxC8FSADQRRqIANBPGooAgA2AgAgAyALNgIYIAMgCjYCMCADIAY2AiwgAyAJNgIoIAMgBDYCJCADIAE2AiAgAyAINgIcIAMgAykCNDcCDCAFIQEjAEEwayIEJAACQAJAIAMtAAxBIEYEQCADKAIYIQogAygCFCEGIAMoAhAhCAJAIAMoAhwiBQRAIARBFGogA0EoaikCADcCACAEQRxqIANBMGooAgAiBzYCACAEIAU2AgggBCADKQIgNwIMIAUgBSgCACIFQQFrNgIAIAVBAUYEQCAEQQhqEPseCyAEIAc2AgQgBw0BCyAEQQhqIgcgCCAGEM4cQTBBCBCtNiIFRQ0CIAVCgYCAgBA3AwAgBUEIaiAHQSj8CgAAIAEgBTYCDCABIAo2AhAgASADKQIANwIAIAFBCGogA0EIaigCADYCACAEQTBqJAAMAwsgBEIANwIUIARCgYCAgMAANwIMIARBiIGFATYCCEEAIARBBGpBsICFASAEQQhqQZCBhQEQrysAC0H49oUBQShBoPeFARCfKQALQQhBMBCjPQALIANBQGskAAwBCwALIAJBEGogAkHUAGopAgA3AwAgAiACKQJMNwMIIAIoAkAhASACKAJIBUGAgICAeAshAyACQQg2AiAgAkEwaiACQRBqKQMANwMAIAIgAzYCJCACIAIpAwg3AyggASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBQGsQuyMLIAIoAiBBCEYNAQsgAkHYAGogAkEwaikDADcDACACQdAAaiACQShqKQMANwMAIAIgAikDIDcDSCMAQSBrIgMkACADQQE2AgQgA0HE9c0ANgIAIANCATcCDCADQTU2AhwgAyACQcgAaiIENgIYIAMgA0EYajYCCCACQQxqIgFBBGogAxCZDiABQY6AgIB4NgIAIAQQySMgA0EgaiQAQQEMAQsgAkEcaiACQTRqKAIANgIAIAJBFGogAkEsaikCADcCACACIAIpAiQiDTcCDEECIQQgDadBgICAgHhGDQEgAkEMaiEBQQALIQQgACABKQIANwIEIABBFGogAUEQaigCADYCACAAQQxqIAFBCGopAgA3AgALIAAgBDYCACACQeAAaiQADwsgASACKAJQQeSjzwAQ/S8AC4sKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaikDACIJNwN4IAlCAFkEQCAEIAVqIAk3AwAMAQsLIAJBuAFqQYmSpMgANgIAIAJCiZKkyJChwoQJNwOwASACQQI2ApwBIAJB+JL/ADYCmAEgAkICNwKkASACQa0DNgLMASACQYYMNgLEASACIAJBwAFqNgKgASACIAJBsAFqIgE2AsgBIAIgAkH4AGo2AsABIAJBiAFqIAJBmAFqEJkOIAEQpQwgAikCkAEhCCACKQKIAQwGC0HAACADEKM9AAtB3Iv/AEEpIAJBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCACIAEpAwAiCDcDsAEgCEIAUw0CIAQgCDcDACAEQQhqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkFAayIDEJcpIAJBKGoiASgCACEGIAIoAiwhBCABIAJByABqIgUpAgA3AwAgAikDICEIIAIgAikCQDcDICACQQA2AjAgAiAINwJMIAJBADYCSCACIAQ2AkQgAiAGNgJAIAIgAxDXOyACKAIAIQZBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogAkHQAGoiBygCADYCACACIAQ2AqABIAIgBjYCnAEgAiABNgKYASACQTRqIgEgAkGYAWoQ5BkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A0AgACABIAMQ2R0gAkEgahDPLwwCCyACQcgBakGJkqTIADYCACACQomSpMiQocKECTcDwAEgAkECNgJEIAJB+JL/ADYCQCACQgI3AkwgAkGtAzYCkAEgAkGGDDYCiAEgAiACQYQBajYCSCACIAJBwAFqIgE2AowBIAIgAkGwAWo2AoQBIAJBnAFqIAJBQGsQmQ4gARClDCACKQKkASEIIAIpApwBCyEJIAAgCDcCECAAIAk3AgggAEGCgICAeDYCBCAAQSk6AAAgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0AFqJAAPC0EEQRwQoz0AC4kKAgZ/A34jAEHQAWsiAiQAIAFBDGoQ2DwhBiACQQhqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAn4CQAJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIoAghFDQMgAigCHCACKAIYRg0EIAJBQGsgAkEIahDINCACQeAAaiEDIAEoAhAhASACKQNoIQgDQAJAIAhQRQRAIAIpA3AhCQwBCwNAAn4CQCACKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgAiAJUK1CAYY3A1AgCadBAXFFDQAgAiACKQNYNwOgAQwBCyACKAJgRQ0BIAJBmAFqIAMQtiogAikDmAEhCQsgCUIAUg0CCyACQgM3A1ALIAIpA0AiCUICUQ0JIAJCADcDQCACKQNIDAELIAIpA6ABCyEIIAmnQQFxRQ0HIAIgAikDcEJAfSIJNwNwIAIgCDcDaCAIUA0ACwsgAkIBIAh6IgqGIAiFIgg3A2ggAiABIAqnIAmnakEDdCIFaikDACIJNwN4IAlCAFkEQCAEIAVqIAk3AwAMAQsLIAJBuAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A7ABIAJBAjYCnAEgAkH4kv8ANgKYASACQgI3AqQBIAJBrQM2AswBIAJBiww2AsQBIAIgAkHAAWo2AqABIAIgAkGwAWoiATYCyAEgAiACQfgAajYCwAEgAkGIAWogAkGYAWoQmQ4gARClDCACKQKQASEIIAIpAogBDAYLQcAAIAMQoz0AC0Hci/8AQSkgAkFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAIgASkDACIINwOwASAIQgBTDQIgBCAINwMAIARBCGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQUBrIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHIAGoiBSkCADcDACACKQMgIQggAiACKQJANwMgIAJBADYCMCACIAg3AkwgAkEANgJIIAIgBDYCRCACIAY2AkAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdAAaiIHKAIANgIAIAIgBDYCoAEgAiAGNgKcASACIAE2ApgBIAJBNGoiASACQZgBahDkGSAHIAJBGGopAgA3AwAgBSACQRBqKQIANwMAIAIgAikCCDcDQCAAIAEgAxDWHSACQSBqEM8vDAILIAJByAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A8ABIAJBAjYCRCACQfiS/wA2AkAgAkICNwJMIAJBrQM2ApABIAJBiww2AogBIAIgAkGEAWo2AkggAiACQcABaiIBNgKMASACIAJBsAFqNgKEASACQZwBaiACQUBrEJkOIAEQpQwgAikCpAEhCCACKQKcAQshCSAAIAg3AhAgACAJNwIIIABBgoCAgHg2AgQgAEEpOgAAIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdABaiQADwtBBEEcEKM9AAusCwMHfwF+AXwjAEHABGsiAiQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQCAALQCYAUEBaw4DCwIBAAsgAEHIAGogAEHIAPwKAAALIABByABqIQUCQAJAAkACQCAALQCMAUEBaw4DCAQAAQsCQCAALQCEAUEBaw4DDAQDAAsgACgCgAEhAwwBCyAAQQA6AIQBIAAgACgCiAEiAzYCgAELIAIgAzYCuAEjAEEQayIEJAAgBCACQbgBaigCACUBEB45AwggBEEIaisDACEKIARBEGokACAAQQA6AHwgACAFNgJoIABCADcDYCAAQoAINwNYIAAgAzYCUCAAIAr8BzcDSCAAQfwAaiEEIABB4ABqIQcgBQwDCyAAQeAAaiEHIABB/ABqIQQCQCAALQB8QQFrDgMIAQACCyAAKAJ4IQYgACgCdCEDDAMLAAsgACkDYCEJIAAoAmgLIQMgACAJNwJsIAMpAwAhCSACQQA6ALwEIAIgCTcDuAEgAiADNgK4BCACQRhqIQMgAkG4AWohCAJAQYgDQQgQrTYiBgRAIAYgCEGIA/wKAAAgA0GM3sIANgIEIAMgBjYCAAwBC0EIQYgDEKM9AAsgAigCGCEDIAAgAigCHCIGNgJ4IAAgAzYCdAsgAkG4AWogAyABIAYoAgwRAQAgAigCuAEiAUEJRgRAIARBAzoAAAwHCyACQZgBaiIGIAJByAFqKQMANwMAIAIgAikDwAE3A5ABIAIoArwBIQMgAEH0AGoQvCoCQCABQQhHBEAgAkGwAWogBikDADcDACACIAIpA5ABNwOoASACIAM2AqQBIAIgATYCoAEgACgCbCIBRQ0BIAEgASgCACIBQQFrNgIAIAFBAUcNASAAQewAahD4IwwBCyACIAApAmw3A7gBIAJBoAFqIAMgAkG4AWoQ7QELIAJB2ABqIgMgAkGsAWooAgA2AgAgAiACKQKkATcDUCACKQOwASEJIAIoAqABIQEgBEEBOgAAIAFBCUYNBiACQegAaiIEIAMoAgA2AgAgAiACKQNQNwNgIAcQ3yAgAUEIRg0BIAJBxAFqIAQoAgA2AgAgAiACKQNgNwK8ASACIAk3A8gBIAIgATYCuAEgAkG4AWoQ0hkhA0ICIQkgACgCUCIBQYQBSQ0CIAEQ8h8MAgtBnNzCABDoKwALIAJB+ABqIABB1ABqKQIANwMAIAJBgAFqIABB3ABqKAIANgIAIAJBjAFqIAJB6ABqKAIANgIAIAIgAikDYDcChAEgAiAAKQJMNwNwIAAoAkghA0IAIQkLQQEhASAAQQE6AIQBIAJBNGogAkH4AGopAwA3AgAgAkE8aiACQYABaikDADcCACACQcQAaiACQYgBaikDADcCACACIAM2AiggAiAJNwMgIAIgAikDcDcCLCAFEIAqIAJBEGogAkEgaiIHEPUfIAIoAhQhBSACKAIQIQQgAEEBOgCMAUEDIQMgBEECRg0EAkAgBEEBcQRAIAIgBTYCICACQYABNgK4ASACIABBlAFqIAJBuAFqIAcQwiMgAigCACACKAIEENYvIgFBhAFPBEAgARDyHwsgAigCuAEiAUGEAU8EQCABEPIfCyACKAIgIgFBhAFJDQEgARDyHwwBCyACIAU2AiAgAkGAATYCuAEgAkEIaiAAQZABaiACQbgBaiACQSBqEMIjIAIoAgggAigCDBDWLyIBQYQBTwRAIAEQ8h8LIAIoArgBIgFBhAFPBEAgARDyHwsgAigCICIBQYQBSQ0AIAEQ8h8LIAAoApABIgFBhAFPBEAgARDyHwtBASEDQQAhASAAKAKUASIFQYQBSQ0EIAUQ8h8MBAtB9NbCABDoKwALQazcwgAQ6CsAC0HcyMIAEOgrAAtBAyEDIABBAzoAhAEgAEEDOgCMAUEBIQELIAAgAzoAmAEgAkHABGokACABC6cJAgN/AX4jAEHgAGsiBCQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AkAgAiAAQQR2IgBPDQkgBCABKAIQIAJBBHRqIgApAwg3AzggBCAAKQMANwMwIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEwaiADENQfIQIMDAsgBEEwaiADEI8WIQIMCwsgACgCBCIAKAIUIQEgBCACNgJEIAIgAUEEdiIBTw0LIAAoAhAgAkEEdGoiACkDCCAAKQMAIgdCgICAgICAgICAf30gB1StfFBFDQkgBigCBCIARQ0CIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQMgBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQA2AlggBEEBNgJMIARB7JuEATYCSCAEQgQ3AlAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCRCACIAFBBHYiAU8NCiAAKAIQIAJBBHRqIgApAwggACkDACIHQoCAgICAgICAgH99IAdUrXxQDQVBrJyEARCyOwALIAAoAgQiACgCFCEBIAQgAjYCRCACIAFBBHYiAU8NCSAAKAIQIAJBBHRqIgApAwggACkDACIHQoCAgICAgICAgH99IAdUrXxQDQVB/JyEARCyOwALIARB0ABqQfSshgEoAgA2AgAgBEHsrIYBKQIANwNIIARByABqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQdAAakH0rIYBKAIANgIAIARB7KyGASkCADcDSCAEQcgAaiIAEMkMIARBADYCWCAEQQE2AkwgBEHsm4QBNgJIIARCBDcCUCADIAAQ0TkLIQIgBEEcahDlEAwFCyAEQTBqIAMQjhYhAgwECyAEIAc3AwggBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQI2AkwgBEHsnIQBNgJIIARCAjcCVCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCUCAEIARBCGo2AhwgAygCACADKAIEIAAQywohAgwDCyAEIAc3AxAgBEHQAGpB9KyGASgCADYCACAEQeyshgEpAgA3A0ggBEHIAGoiABDJDCAEQQI2AkwgBEHsnIQBNgJIIARCAjcCVCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCUCAEIARBEGo2AhwgAygCACADKAIEIAAQywohAgwCCyAEIAA2AkQgBEECNgJMIARBuJeEATYCSCAEQgI3AlQgBEE7NgIoIARBOzYCICAEIARBHGo2AlAgBCAEQcQAajYCJCAEIARBQGs2AhwMAwtB2JuEARCyOwALIARB4ABqJAAgAg8LIAQgATYCMCAEQQI2AkwgBEG4l4QBNgJIIARCAjcCVCAEQTs2AiggBEE7NgIgIAQgBEEcajYCUCAEIARBMGo2AiQgBCAEQcQAajYCHAsgBEHIAGpByJeEARDvLAAL3wgBC38jAEHgAGsiAiQAAkACQAJ/QQEgASgCBCIEKAIEIAQoAgggACgCACgCACIFKAIAIAUoAgQQwS4NABpBACAEKAIEIAQoAgggBSgCACAFKAIEEK07RQ0AGiACIAQoAgQgBCgCCCAFKAIAIAUoAgQQqQMCQAJAIAIoAgBBAUYEQCACQQhqIQAgAigCPCEBIAIoAjghAyACKAI0IQYgAigCMCEHIAIoAiRBf0YNASACQUBrIAAgByAGIAMgAUEAEPkLDAILAkAgAi0ADg0AIAItAAwhByACKAI0IQAgAigCMCEIIAIoAgQhAQJAA0ACQCABRQ0AIAAgAU0EQCAAIAFGDQEMCQsgASAIaiwAAEFASA0ICyAAIAFHBEACfyABIAhqIgYsAAAiA0EATgRAIANB/wFxDAELIAYtAAFBP3EhCSADQR9xIQogCkEGdCAJciADQV9NDQAaIAYtAAJBP3EgCUEGdHIhCSAJIApBDHRyIANBcEkNABogCkESdEGAgPAAcSAGLQADQT9xIAlBBnRycgshAyAHQQFxBEAgASEADAMLQQEhBwJ/QQEgA0GAAUkNABpBAiADQYAQSQ0AGkEDQQQgA0GAgARJGwsgAWohAQwBCwsgB0EBcUUNAQsgAiAANgJEQQEhCwsgAiALNgJADAELIAJBQGsgACAHIAYgAyABQQEQ+QsLAkAgAigCQARAIAQoAgQiAyAEKAIIIgdqIQQgBSgCBCACKAJEaiIGQSBJDQFBACEFAkAgBkEgRiAHQSBJcg0AIAMgB0FgcWohDCACQQhqIQggAkHYAGohCyACQdAAaiEJIAMhAANAIAtCADcDACAJQgA3AwAgAkHIAGpCADcDACACQgA3A0BBACEBA0AgAkFAayABaiAAIAFqLAAAQb9/SjoAACABQQFqIgFBIEcNAAsgCCACKQNANwAAIAhBGGogCykDADcAACAIQRBqIAkpAwA3AABBCCEBIAhBCGogAkHIAGopAwA3AABBACEKA0AgASACai0AACAKaiEKIAFBAWoiAUEoRw0ACyAFQSBqIQUgBiAKQf8BcWsiBkEhSQ0BIABBIGoiACAMRw0ACwsgAyAFaiEDIAUgB0YNASAHIAVrIQEDQCADLAAAQb9/Sg0CIANBAWohAyABQQFrIgENAAsgBCEDDAELQZzKwwAQsjsACyAGBEADQCADIARGDQMgAyADLQAAQbTHwwBqLQAAaiEDIAZBAWsiBg0ACwsgAyAERg0BAkAgAywAACIAQQBOBEAgAEH/AXEhAQwBCyADLQABQT9xIQQgAEEfcSEBIABBX00EQCABQQZ0IARyIQEMAQsgAy0AAkE/cSAEQQZ0ciEEIABBcEkEQCAEIAFBDHRyIQEMAQsgAUESdEGAgPAAcSADLQADQT9xIARBBnRyciIBQYCAxABGDQILIAFBLkYLIAJB4ABqJAAPC0GsysMAELI7AAsgCCAAIAEgAEGkx8MAEKM2AAuBCgMOfwN9AX4jAEEgayIVJAAgFUEANgIMAkACQCAKRQ0AIAZBBGohEQNAAkAgECIOQQFqIhAgCk8NAAJAIAcgDksEQCAGIA5BAnRqIRIgESEPIBAhDgwBCyAOIAdB3ObMABDDIQALA0AgByAORwRAIAAgASACIAMgEigCACAPKAIAIA0gCCAJIBVBDGoQ0QggD0EEaiEPIA5BAWoiDiAKRw0BDAILCyAHIAdB7ObMABDDIQALIBFBBGohESAKIBBHDQALQQEhESAKQQFGDQAgCUUNASAKIRFBASEKA0AgEUEBayIZIRcDQCAdIAgqAgxfBEBDmXaWfiEdIBEgDCIKTQ0DDAILIAgoAgAiEiEOAkAgCCgCBCIWIg8gAUkEQCABIA5LBEAgACAOQYgWbGoiECAQKAKAFiAAIA9BiBZsaiIPKAKAFmo2AoAWQQAhDgNAIA4gEGoiEyAOIA9qKAIAIBMoAgBqNgIAIA5BBGoiDkGAFkcNAAsMAgsgDiABQezqzAAQwyEACyAPIAFB3OrMABDDIQALAkAgASASSwRAIAAgEkGIFmxqIAgqAgg4AoQWIAMgFksEQCADIBJLBEAgAiASQQJ0aiIOIA4oAgAgAiAWQQJ0aigCAGo2AgAgCwRAQQAhDyAEIQ4DQAJAAkAgBSAPRwRAIA4oAgAgFkYNAQwCCyAFIAVBzObMABDDIQALIA4gEjYCAAsgDkEEaiEOIAsgD0EBaiIPRw0ACwtBACEOIAYhDwJAAkACQAJAA0AgByAORwRAIAYgDkECdGooAgAgFkYNAiAPQQRqIQ8gDkEBaiIOIBFHDQEMAwsLIAcgB0Hs5cwAEMMhAAsgESAOQX9zaiITRQ0AQQAhEANAIA4gEGoiFEEBaiAHTw0CIA8gD0EEaiIPKAIANgIAIBBBAWoiECATSQ0ACwsgFSgCDCIbDQFBACEQDAULIBRBAWogB0G85swAEMMhAAtBACEQIAghDkEAIQ8DQAJAAkACQAJAAkACQCAJIA9HBEAgDigCACITIBJGDQUgDkEEaigCACIUIBZGIBMgFkZyIBIgFEZyDQUgDkEIaigCACEaIAgqAgwiHiAOQQxqKgIAIhxbDQEgHCAeXUUNAgwDCyAJIAlBjObMABDDIQALIAgoAgQgCCgCAGsgFCATa0sNAQsgCSAQSwRAIAggEEEEdGoiGCAcOAIMIBggGjYCCCAYIBQ2AgQgGCATNgIADAILIBAgCUGc5swAEMMhAAsgCCkCACEfIAggFDYCBCAIIBM2AgAgFUEYaiITIAhBCGoiFCkCADcDACAIIBw4AgwgFCAaNgIAIBUgHzcDECAJIBBNDQIgCCAQQQR0aiIUIBUpAxA3AgAgFEEIaiATKQMANwIACyAQQQFqIRALIA5BEGohDiAPQQFqIg8gG0cNAQwFCwsgECAJQazmzAAQwyEACyASIANB3OXMABDDIQALIBYgA0HM5cwAEMMhAAsgEiABQbzlzAAQwyEACyAVIBA2AgwCQCARQQFrIhFFDQBBACEOIAYhDwNAIAcgDkcEQCAAIAEgAiADIBIgDygCACANIAggCSAVQQxqENEIIA9BBGohDyAOQQFqIg4gF0cNAQwCCwsgByAHQfzlzAAQwyEACyAXQQFrIRcgCiARSQ0ACwsgCiAZIAogGUkbIRELIBVBIGokACARDwtBAEEAQazlzAAQwyEAC4EKAw5/A30BfiMAQSBrIhUkACAVQQA2AgwCQAJAIApFDQAgBkEEaiERA0ACQCAQIg5BAWoiECAKTw0AAkAgByAOSwRAIAYgDkECdGohEiARIQ8gECEODAELIA4gB0Hc5swAEMMhAAsDQCAHIA5HBEAgACABIAIgAyASKAIAIA8oAgAgDSAIIAkgFUEMahDTCCAPQQRqIQ8gDkEBaiIOIApHDQEMAgsLIAcgB0Hs5swAEMMhAAsgEUEEaiERIAogEEcNAAtBASERIApBAUYNACAJRQ0BIAohEUEBIQoDQCARQQFrIhkhFwNAIB0gCCoCDF8EQEOZdpZ+IR0gESAMIgpNDQMMAgsgCCgCACISIQ4CQCAIKAIEIhYiDyABSQRAIAEgDksEQCAAIA5BiBFsaiIQIBAoAoARIAAgD0GIEWxqIg8oAoARajYCgBFBACEOA0AgDiAQaiITIA4gD2ooAgAgEygCAGo2AgAgDkEEaiIOQYARRw0ACwwCCyAOIAFB7OrMABDDIQALIA8gAUHc6swAEMMhAAsCQCABIBJLBEAgACASQYgRbGogCCoCCDgChBEgAyAWSwRAIAMgEksEQCACIBJBAnRqIg4gDigCACACIBZBAnRqKAIAajYCACALBEBBACEPIAQhDgNAAkACQCAFIA9HBEAgDigCACAWRg0BDAILIAUgBUHM5swAEMMhAAsgDiASNgIACyAOQQRqIQ4gCyAPQQFqIg9HDQALC0EAIQ4gBiEPAkACQAJAAkADQCAHIA5HBEAgBiAOQQJ0aigCACAWRg0CIA9BBGohDyAOQQFqIg4gEUcNAQwDCwsgByAHQezlzAAQwyEACyARIA5Bf3NqIhNFDQBBACEQA0AgDiAQaiIUQQFqIAdPDQIgDyAPQQRqIg8oAgA2AgAgEEEBaiIQIBNJDQALCyAVKAIMIhsNAUEAIRAMBQsgFEEBaiAHQbzmzAAQwyEAC0EAIRAgCCEOQQAhDwNAAkACQAJAAkACQAJAIAkgD0cEQCAOKAIAIhMgEkYNBSAOQQRqKAIAIhQgFkYgEyAWRnIgEiAURnINBSAOQQhqKAIAIRogCCoCDCIeIA5BDGoqAgAiHFsNASAcIB5dRQ0CDAMLIAkgCUGM5swAEMMhAAsgCCgCBCAIKAIAayAUIBNrSw0BCyAJIBBLBEAgCCAQQQR0aiIYIBw4AgwgGCAaNgIIIBggFDYCBCAYIBM2AgAMAgsgECAJQZzmzAAQwyEACyAIKQIAIR8gCCAUNgIEIAggEzYCACAVQRhqIhMgCEEIaiIUKQIANwMAIAggHDgCDCAUIBo2AgAgFSAfNwMQIAkgEE0NAiAIIBBBBHRqIhQgFSkDEDcCACAUQQhqIBMpAwA3AgALIBBBAWohEAsgDkEQaiEOIA9BAWoiDyAbRw0BDAULCyAQIAlBrObMABDDIQALIBIgA0Hc5cwAEMMhAAsgFiADQczlzAAQwyEACyASIAFBvOXMABDDIQALIBUgEDYCDAJAIBFBAWsiEUUNAEEAIQ4gBiEPA0AgByAORwRAIAAgASACIAMgEiAPKAIAIA0gCCAJIBVBDGoQ0wggD0EEaiEPIA5BAWoiDiAXRw0BDAILCyAHIAdB/OXMABDDIQALIBdBAWshFyAKIBFJDQALCyAKIBkgCiAZSRshEQsgFUEgaiQAIBEPC0EAQQBBrOXMABDDIQALgQoDDn8DfQF+IwBBIGsiFSQAIBVBADYCDAJAAkAgCkUNACAGQQRqIREDQAJAIBAiDkEBaiIQIApPDQACQCAHIA5LBEAgBiAOQQJ0aiESIBEhDyAQIQ4MAQsgDiAHQdzmzAAQwyEACwNAIAcgDkcEQCAAIAEgAiADIBIoAgAgDygCACANIAggCSAVQQxqENIIIA9BBGohDyAOQQFqIg4gCkcNAQwCCwsgByAHQezmzAAQwyEACyARQQRqIREgCiAQRw0AC0EBIREgCkEBRg0AIAlFDQEgCiERQQEhCgNAIBFBAWsiGSEXA0AgHSAIKgIMXwRAQ5l2ln4hHSARIAwiCk0NAwwCCyAIKAIAIhIhDgJAIAgoAgQiFiIPIAFJBEAgASAOSwRAIAAgDkGICGxqIhAgECgCgAggACAPQYgIbGoiDygCgAhqNgKACEEAIQ4DQCAOIBBqIhMgDiAPaigCACATKAIAajYCACAOQQRqIg5BgAhHDQALDAILIA4gAUHs6swAEMMhAAsgDyABQdzqzAAQwyEACwJAIAEgEksEQCAAIBJBiAhsaiAIKgIIOAKECCADIBZLBEAgAyASSwRAIAIgEkECdGoiDiAOKAIAIAIgFkECdGooAgBqNgIAIAsEQEEAIQ8gBCEOA0ACQAJAIAUgD0cEQCAOKAIAIBZGDQEMAgsgBSAFQczmzAAQwyEACyAOIBI2AgALIA5BBGohDiALIA9BAWoiD0cNAAsLQQAhDiAGIQ8CQAJAAkACQANAIAcgDkcEQCAGIA5BAnRqKAIAIBZGDQIgD0EEaiEPIA5BAWoiDiARRw0BDAMLCyAHIAdB7OXMABDDIQALIBEgDkF/c2oiE0UNAEEAIRADQCAOIBBqIhRBAWogB08NAiAPIA9BBGoiDygCADYCACAQQQFqIhAgE0kNAAsLIBUoAgwiGw0BQQAhEAwFCyAUQQFqIAdBvObMABDDIQALQQAhECAIIQ5BACEPA0ACQAJAAkACQAJAAkAgCSAPRwRAIA4oAgAiEyASRg0FIA5BBGooAgAiFCAWRiATIBZGciASIBRGcg0FIA5BCGooAgAhGiAIKgIMIh4gDkEMaioCACIcWw0BIBwgHl1FDQIMAwsgCSAJQYzmzAAQwyEACyAIKAIEIAgoAgBrIBQgE2tLDQELIAkgEEsEQCAIIBBBBHRqIhggHDgCDCAYIBo2AgggGCAUNgIEIBggEzYCAAwCCyAQIAlBnObMABDDIQALIAgpAgAhHyAIIBQ2AgQgCCATNgIAIBVBGGoiEyAIQQhqIhQpAgA3AwAgCCAcOAIMIBQgGjYCACAVIB83AxAgCSAQTQ0CIAggEEEEdGoiFCAVKQMQNwIAIBRBCGogEykDADcCAAsgEEEBaiEQCyAOQRBqIQ4gD0EBaiIPIBtHDQEMBQsLIBAgCUGs5swAEMMhAAsgEiADQdzlzAAQwyEACyAWIANBzOXMABDDIQALIBIgAUG85cwAEMMhAAsgFSAQNgIMAkAgEUEBayIRRQ0AQQAhDiAGIQ8DQCAHIA5HBEAgACABIAIgAyASIA8oAgAgDSAIIAkgFUEMahDSCCAPQQRqIQ8gDkEBaiIOIBdHDQEMAgsLIAcgB0H85cwAEMMhAAsgF0EBayEXIAogEUkNAAsLIAogGSAKIBlJGyERCyAVQSBqJAAgEQ8LQQBBAEGs5cwAEMMhAAvQCQIFfwV+IwBBwAFrIgQkACABQQxqENk8IQggBEE4aiABEJI2EO4lIAhBBHQiByEFAkACQAJAAkACQCAHQTBxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AlggBCAFNgJUIARBwAA2AlAgBwRAIAZBACAH/AsACyAEIAg2AmAgBCAHNgJcIAQoAjhFDQMgBCgCTCAEKAJIRg0EIARB8ABqIARBOGoQyDQgBEGQAWohBSACKQMIIQsgAikDACEMIAMtAAAhAiABKAIQIQMDQAJAIAQpA5gBIgpQRQRAIAQpA6ABIQkMAQsDQAJ+AkAgBCkDgAEiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDgAEgCadBAXFFDQAgBCAEKQOIATcDsAEMAQsgBCgCkAFFDQEgBEGoAWogBRC2KiAEKQOoASEJCyAJQgBSDQILIARCAzcDgAELIAQpA3AiCUICUQ0JIARCADcDcCAEKQN4DAELIAQpA7ABCyEKIAmnQQFxRQ0HIAQgBCkDoAFCQH0iCTcDoAEgBCAKNwOYASAKUA0ACwsgBEIBIAp6Ig2GIAqFNwOYASALIAyEUARAQYeAgIB4IQEMBwsgBEEgaiADIA2nIAmnaiIHQQF0ajIBACIJIAlCP4cgDCALEIMZIARBqAFqIAQpAyAiCSAEKQMoIgogAhCtDiAEKAKoASIBQZOAgIB4RwRAIAQpArQBIQkgBCkCrAEhCgwHBSAGIAdBBHRqIgEgCjcDCCABIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEHwAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAIpAwghCSACKQMAIQogAy0AACEDIAEoAhAhAkEAIQUDQCAJIAqEUARAQYeAgIB4IQEMAwsgBEEQaiACMgEAIgsgC0I/hyAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAAL0AkCBX8FfiMAQcABayIEJAAgAUEMahDbPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0ECdGo0AgAiCSAJQj+HIAwgCxCDGSAEQagBaiAEKQMgIgkgBCkDKCIKIAIQrQ4gBCgCqAEiAUGTgICAeEcEQCAEKQK0ASEJIAQpAqwBIQoMBwUgBiAHQQR0aiIBIAo3AwggASAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAyABKAIQIQJBACEFA0AgCSAKhFAEQEGHgICAeCEBDAMLIARBEGogAjQCACILIAtCP4cgCiAJEIMZIARB8ABqIAQpAxAiCyAEKQMYIgwgAxCtDiAEKAJwIgFBk4CAgHhHBEAgBCkCfCEJIAQpAnQhCgwDCyAGIAs3AwAgBiAMNwMIIAZBEGohBiACQQRqIQIgCCAFQQFqIgVHDQALCyAEQfAAaiICEJcpIARB2ABqIgEoAgAhBiAEKAJcIQMgASAEQfgAaiIFKQIANwMAIAQpA1AhCSAEIAQpAnA3A1AgBEEANgJgIAQgCTcCfCAEQQA2AnggBCADNgJ0IAQgBjYCcCAEQQhqIAIQ1zsgBCgCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAnA3AgggAUEQaiAFKQIANwIAIAFBGGogBEGAAWoiBygCADYCACAEIAM2ArABIAQgBjYCrAEgBCABNgKoASAEQeQAaiIBIARBqAFqEOIZIAcgBEHIAGopAgA3AwAgBSAEQUBrKQIANwMAIAQgBCkCODcDcCAAIAEgAhDLHSAEQdAAahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEHQAGoQzy8gBCgCOCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQThqEPseCyAEQcABaiQAC9AJAgV/BX4jAEHAAWsiBCQAIAFBDGoQ2DwhCCAEQThqIAEQkjYQ7iUgCEEEdCIHIQUCQAJAAkACQAJAIAdBMHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCWCAEIAU2AlQgBEHAADYCUCAHBEAgBkEAIAf8CwALIAQgCDYCYCAEIAc2AlwgBCgCOEUNAyAEKAJMIAQoAkhGDQQgBEHwAGogBEE4ahDINCAEQZABaiEFIAIpAwghCyACKQMAIQwgAy0AACECIAEoAhAhAwNAAkAgBCkDmAEiClBFBEAgBCkDoAEhCQwBCwNAAn4CQCAEKQOAASIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwOAASAJp0EBcUUNACAEIAQpA4gBNwOwAQwBCyAEKAKQAUUNASAEQagBaiAFELYqIAQpA6gBIQkLIAlCAFINAgsgBEIDNwOAAQsgBCkDcCIJQgJRDQkgBEIANwNwIAQpA3gMAQsgBCkDsAELIQogCadBAXFFDQcgBCAEKQOgAUJAfSIJNwOgASAEIAo3A5gBIApQDQALCyAEQgEgCnoiDYYgCoU3A5gBIAsgDIRQBEBBh4CAgHghAQwHCyAEQSBqIAMgDacgCadqIgdBA3RqKQMAIgkgCUI/hyAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIpAwAiCyALQj+HIAogCRCDGSAEQfAAaiAEKQMQIgsgBCkDGCIMIAMQrQ4gBCgCcCIBQZOAgIB4RwRAIAQpAnwhCSAEKQJ0IQoMAwsgBiALNwMAIAYgDDcDCCAGQRBqIQYgAkEIaiECIAggBUEBaiIFRw0ACwsgBEHwAGoiAhCXKSAEQdgAaiIBKAIAIQYgBCgCXCEDIAEgBEH4AGoiBSkCADcDACAEKQNQIQkgBCAEKQJwNwNQIARBADYCYCAEIAk3AnwgBEEANgJ4IAQgAzYCdCAEIAY2AnAgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogBSkCADcCACABQRhqIARBgAFqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDiGSAHIARByABqKQIANwMAIAUgBEFAaykCADcDACAEIAQpAjg3A3AgACABIAIQyx0gBEHQAGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAE2AgQgAEEpOgAAIARB0ABqEM8vIAQoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEE4ahD7HgsgBEHAAWokAAubCQIDfwJ+IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQZithgEoAgA2AgAgBEGQrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFPDQkgBCAAKAIQIAJBA3RqKQMAIgc3AwggBEFAa0GYrYYBKAIANgIAIARBkK2GASkCADcDOCAHIAdCgJTr3AN/IgdCgJTr3AN+fSIIQgBTDQUgB6ciAEH/ogVLDQUgBEE4aiIBEMkMIAQgCD4CLCAEIAA2AiggBEEBNgI8IARB9JuEATYCOCAEQgE3AkQgBEGUDDYCGCAEIARBFGo2AkAgBCAEQShqNgIUIAMoAgAgAygCBCABEMsKIQIMCAsgBEFAa0GYrYYBKAIANgIAIARBkK2GASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQZithgEoAgA2AgAgBEGQrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBmK2GASgCADYCACAEQZCthgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC5kJAgN/An4jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtB6KyGASgCADYCACAEQeCshgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCSAEIAAoAhAgAkEDdGopAwAiBzcDCCAEQUBrQeishgEoAgA2AgAgBEHgrIYBKQIANwM4IARBOGoiAhDJDCAHQsCEPX8iCKciAEH/ogVLDQUgByAIQsCEPX59p0HoB2wiAUH/p9a5B0sNBSAEIAE2AiwgBCAANgIoIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AhggBCAEQRRqNgJAIAQgBEEoajYCFCADKAIAIAMoAgQgAhDLCiECDAgLIARBQGtB6KyGASgCADYCACAEQeCshgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEFAa0HorIYBKAIANgIAIARB4KyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRRqEOUQDAULIARBKGogAxC4HCECDAQLIAQgACgCECACQQN0aikDADcDACAEQUBrQeishgEoAgA2AgAgBEHgrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIARBOGoQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC8UKAgN/AX4jAEHAAWsiAyQAIANBhAFqIAEgAhCTDiADKAKIASEEAkAgAygChAEiBUGKgICAeEcEQCADQSxqIANBpAFqKAIANgIAIANBJGogA0GcAWopAgA3AgAgA0EcaiADQZQBaikCADcCACADIAMpAowBNwIUIAMgBDYCECADIAU2AgwMAQsgA0GEAWogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0GQAWopAgA3AwAgAyADKQKIATcDMCADKAKEASIEQYqAgIB4RwRAIANBKGogA0GgAWopAgA3AgAgA0EYaiABKQMANwIAIAMgAykCmAE3AiAgAyADKQMwNwIQIAMgBDYCDAwBCyADQcgAaiABKQMANwMAIAMgAykDMDcDQCADQYQBaiADQUBrQQQQ3RAgAygCjAEhASADKAKIASEEAkACfiADKAKEASIFQYqAgIB4RwRAIANBsAFqIANBoAFqKQIANwMAIAMgAykCmAE3A6gBIAMpApABDAELIARBAXFFDQECQCABQQFxBEAgAyABNgKgASADQQM2ApwBIANBueT+ADYCmAEgA0GAgICAeDYClAEgA0IENwKMASADQoSAgIAINwKEAQwBC0F/IAFBAmoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBAmoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYChAEMAgsgA0GIgICAeDYChAEMAQsgA0GEAWogASAFEL8vCyADQQQ2ArgBIANBuef+ADYCtAEgA0GAgICAeDYCsAEgAyABNgKsASADQQE2AqgBIANB4ABqIANBhAFqIANBqAFqEIEUIAMoAmAiBUGKgICAeEYNASADQbABaiADQfwAaikCADcDACADIAMpAnQ3A6gBIAMoAmghASADKAJkIQQgAykCbAshBiADQShqIANBsAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA6gBNwIgDAELIAMgAykDSDcCWCADIAMpA0A3AlAgA0GEAWogA0HQAGpBBhDdECADKAKMASEBIAMoAogBIQQCQAJ+IAMoAoQBIgVBioCAgHhHBEAgA0GwAWogA0GgAWopAgA3AwAgAyADKQKYATcDqAEgAykCkAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2AqABIANBAzYCnAEgA0G85P4ANgKYASADQYCAgIB4NgKUASADQgQ3AowBIANChICAgAg3AoQBDAELQX8gAUEEaiIEIAEgBEsbIgUgAygCUCIEKAIETQRAIAQgBCgCFEEEaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKEAQwCCyADQYiAgIB4NgKEAQwBCyADQYQBaiABIAUQvy8LIANBCDYCuAEgA0GR5/4ANgK0ASADQYCAgIB4NgKwASADIAE2AqwBIANBATYCqAEgA0HgAGogA0GEAWogA0GoAWoQgRQgAygCYCIFQYqAgIB4Rg0BIANBsAFqIANB/ABqKQIANwMAIAMgAykCdDcDqAEgAygCaCEBIAMoAmQhBCADKQJsCyEGIANBKGogA0GwAWopAwA3AgAgAyAGNwIYIAMgATYCFCADIAQ2AhAgAyAFNgIMIAMgAykDqAE3AiAMAQsgAygCUCIBIAEoAgxBAWs2AgwgA0GKgICAeDYCDAsgA0EKNgKUASADQYXp/gA2ApABIANBgICAgHg2AowBIAMgAjYCiAEgA0ECNgKEASAAIANBDGogA0GEAWoQgRQgA0HAAWokAAvACAEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjQgAiAAQQJ2IgBPDQsgBCABKAIQIAJBAnRqKAIANgIwIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEwaiADEMwkIQIMCgsgBEEwaiADENMcIQIMCQsgACgCBCgCFCEAIAQgAjYCNCACIABBAnYiAE8NCiAGKAIEIgBFDQIgBEEcaiAAQQhqIAYoAggQihggBCgCHEGTgICAeEcNAyAEQUBrQeCthgEoAgA2AgAgBEHYrYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBAnYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQJ2IgFPDQcgBCAAKAIQIAJBAnRqKAIAIgCsNwMIIARBQGtB4K2GASgCADYCACAEQdithgEpAgA3AzggBEE4aiICEMkMIABB6AdtIgFB/6IFSw0FIAAgAUHoB2xrQcCEPWwiAEH/p9a5B0sNBSAEIAA2AhggBCABNgIUIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AiAgBCAEQRxqNgJAIAQgBEEUajYCHCADKAIAIAMoAgQgAhDLCiECDAYLIARBQGtB4K2GASgCADYCACAEQdithgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEFAa0HgrYYBKAIANgIAIARB2K2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRxqEOUQDAMLIARBMGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQUBrQeCthgEoAgA2AgAgBEHYrYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIAQ2AhwgAygCACADKAIEIAAQywohAgwBCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIARBCGo2AhwgAygCACADKAIEIARBOGoQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AhQMAQsgBCAANgIUCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiggBEE7NgIgIAQgBEEcajYCQCAEIARBFGo2AiQgBCAEQTRqNgIcIARBOGpByJeEARDvLAALyQkCBX8FfiMAQcABayIEJAAgAUEMaigCCCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQcgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEBA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAcQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEFDAcLIARBIGogASANpyAJp2oiA2owAAAiCSAJQj+HIAwgCxCDGSAEQagBaiAEKQMgIgkgBCkDKCIKIAIQrQ4gBCgCqAEiBUGTgICAeEcEQCAEKQK0ASEJIAQpAqwBIQoMBwUgBiADQQR0aiIDIAo3AwggAyAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARB8ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACACKQMIIQkgAikDACEKIAMtAAAhAiABKAIQIQNBACEBA0AgCSAKhFAEQEGHgICAeCEFDAMLIARBEGogASADajAAACILIAtCP4cgCiAJEIMZIARB8ABqIAQpAxAiCyAEKQMYIgwgAhCtDiAEKAJwIgVBk4CAgHhHBEAgBCkCfCEJIAQpAnQhCgwDCyAGIAs3AwAgBiAMNwMIIAZBEGohBiAIIAFBAWoiAUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDYPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0EDdGopAwBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIpAwBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBCGohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDbPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0ECdGo1AgBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAI1AgBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBBGohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALxgkCBX8FfiMAQcABayIEJAAgAUEMahDZPCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQUgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEDA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAUQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEBDAcLIARBIGogAyANpyAJp2oiB0EBdGozAQBCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgFBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgB0EEdGoiASAKNwMIIAEgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQMgASgCECECQQAhBQNAIAkgCoRQBEBBh4CAgHghAQwDCyAEQRBqIAIzAQBCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCADEK0OIAQoAnAiAUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARB8ABqIgIQlykgBEHYAGoiASgCACEGIAQoAlwhAyABIARB+ABqIgUpAgA3AwAgBCkDUCEJIAQgBCkCcDcDUCAEQQA2AmAgBCAJNwJ8IARBADYCeCAEIAM2AnQgBCAGNgJwIARBCGogAhDXOyAEKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCcDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQYABaiIHKAIANgIAIAQgAzYCsAEgBCAGNgKsASAEIAE2AqgBIARB5ABqIgEgBEGoAWoQ4hkgByAEQcgAaikCADcDACAFIARBQGspAgA3AwAgBCAEKQI4NwNwIAAgASACEMsdIARB0ABqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQdAAahDPLyAEKAI4IgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBOGoQ+x4LIARBwAFqJAALvAgBA38jAEHgAGsiBCQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgJYIAIgAEEFdiIATw0IIAQgASgCECACQQV0aiIAKQMYNwNIIAQgACkDEDcDQCAEIAApAwg3AzggBCAAKQMANwMwIARBMGogAxD/IyECDAoLIAAoAgQiACgCFCEBIAQgAjYCWCACIAFBBXYiAU8NCiAEQTBqIgEgACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjBFDQggBigCBCIARQ0EIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQIgBEE4akHErIYBKAIANgIAIARBvKyGASkCADcDMCABEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAEQ0TkMAwsgACgCBCIAKAIUIQEgBCACNgJYIAIgAUEFdiIBTw0JIARBMGogACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjANBEGsnIQBELI7AAsgACgCBCIAKAIUIQEgBCACNgJYIAIgAUEFdiIBTw0IIARBMGogACgCECACQQV0aiIAKQMAIAApAwggACkDECAAKQMYEMAjIAQoAjANBEH8nIQBELI7AAsgBEE4akHErIYBKAIANgIAIARBvKyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRxqEOUQDAULIARBOGpBxKyGASgCADYCACAEQbyshgEpAgA3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBAsgBCAEKQM4NwMIIARBOGpBxKyGASgCADYCACAEQbyshgEpAgA3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiggBCAFNgIkIARB7gY2AiAgBCAEQRxqNgI4IAQgBEEIajYCHCADKAIAIAMoAgQgABDLCiECDAMLIAQgBCkDODcDECAEQThqQcSshgEoAgA2AgAgBEG8rIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCOCAEIARBEGo2AhwgAygCACADKAIEIAAQywohAgwCCyAEIAA2AlwMAwtB2JuEARCyOwALIARB4ABqJAAgAg8LIAQgATYCXAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIoIARBOzYCICAEIARBHGo2AjggBCAEQdwAajYCJCAEIARB2ABqNgIcIARBMGpByJeEARDvLAALtQgCA38IfiMAQaACayIJJAAgCSAENwO4ASAJIAM3A7ABIAkgAjcDqAEgCSABNwOgASAJIAg3A9gBIAkgBzcD0AEgCSAGNwPIASAJIAU3A8ABIAACfwJAAn4gASADhCACIASEhFAEQEIADAELQgAgBSAHhCAGIAiEhFANABogByAIQj+HIgeFIg0gCEI/iHwiDCAFIAeFIg4gB1QiCiAGIAeFIg8gB1QgBlAbrSIGfSEFIAwgDVStIAcgCIV8IAYgDFatfSEGIAMgBEI/hyIDhSIQIARCP4h8IgwgASADhSIRIANUIgsgAiADhSISIANUIAJQG60iAX0iDSAMIBBUrSADIASFfCABIAxWrX0iDIRQRSAFIAaEQgBScQ0BIAlBkAFqIA4gB30iAUIAIBEgA30iAkIAEKgeIAlB8ABqIAFCACASIAN9IAutfSIDQgAQqB4gCUGAAWogDyAHfSAKrX0iB0IAIAJCABCoHiAJQeAAaiAHQgAgA0IAEKgeIAlBMGogDEIAIAFCABCoHiAJQUBrIAdCACANQgAQqB4gCUHQAGogDUIAIAFCABCoHiAMQgBSIAdCAFJxIAkpAzhCAFJyIAkpA0hCAFJyIAkpA1giASAJKQMwIAkpA0B8fCIHIAFUcg0BIAkpA3AhDCAJKQOYASEBIAkpA3ggCSkDYCEOIAkpA2ghDyAJKQOAASEQIAkpA4gBIREgCSkDUCESIAkpA5ABIRMgCSADQgAgBUIAEKgeIAlBEGogBkIAIAJCABCoHiAJQSBqIAJCACAFQgAQqB4gA0IAUiAGQgBScSAJKQMIQgBSciAJKQMYQgBSciAJKQMoIgIgCSkDACAJKQMQfHwiBiACVHINASABIAEgDHwiAVatfCIMIA58IgIgESABIBB8IgMgAVStfHwiASASfCIFIAFUIgogCq0gASACVK0gDyACIAxUrXx8IgIgB3x8IgEgAlQgASACURsNASAFIAUgCSkDIHwiBVYiCiAKrSABIAZ8fCICIAFUIAEgAlEbDQEgAiAEIAiFIgRCP4ciAYUgAX0gASAFhSICIAFUrX0gAiABfSICIAEgE4UiBSABVCIKIAEgA4UiBiABVCADUButIgNUrX0iDiAEhUIAUw0BIAIgA30hDyAGIAF9IAqtfSENIAUgAX0LIQwgACAPNwMgIAAgDDcDECAAIA43AyggACANNwMYQQAMAQsgCUECNgL8ASAJQayQ/wA2AvgBIAlCAjcChAIgCUGDDDYCnAIgCUGDDDYClAIgCSAJQZACajYCgAIgCSAJQcABajYCmAIgCSAJQaABajYCkAIgCUHoAWogCUH4AWoQmQ4gCUGIgICAeDYC5AEgACAJKQLkATcCBCAAQQxqIAlB7AFqKQIANwIAIABBFGogCUH0AWooAgA2AgBBAQs2AgAgCUGgAmokAAvICQILfwN+IwBBwARrIgIkAAJAAkAgASkDACINQgJWDQACQAJAIA2nQQFrDgICAAELIAEpAxBQRQRAIAFBGGohBSACQQxqIQggAkEwaiEKIAJBGGohBCACQdgCaiELIAJBwAJqIQMgAkGwAmpBBHIhCQNAAkACQAJAIAUoAgAiBgRAIAJBsAJqIgcgBhDgFCACKAKwAkEIRg0BIAUQny8gBUEANgIAIAIoArACQQhGDQMgBxDJIwwDCyACQbACaiABKAJAQQhqIAEpAwgQ4TAgBCAJQQhqKQIANwMAIAIgCSkCADcDECACKAKwAiIGQQhHBEAgAigCxAIhASAAIAIpAxA3AgQgACABNgIUIAAgBjYCACAAQQxqIAJBGGopAwA3AgAMCAsgAkEIaiAEKQMANwMAIAIgAikDEDcDACACQbACaiACIAEoAhwgAS0AIBDxEwJAAkAgAikDuAIiDUIEUQRAIAJBqAJqIANBEGopAwAiDTcDACACQaACaiADQQhqKQMAIg43AwAgAiADKQMAIg83A5gCIABBEGogDTcDACAAQQhqIA43AwAgACAPNwMADAELIAJBoAJqIgcgA0EIaikDADcDACACQagCaiIMIANBEGopAwA3AwAgAiADKQMANwOYAiACKAKwAiEGIAogC0HoAfwKAAAgBEEQaiAMKQMANwMAIARBCGogBykDADcDACAEIAIpA5gCNwMAIAIgDTcDECACQbACaiAGIAEpAxAQjhogAigCsAIiB0EIRg0BIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBzYCACACQRBqEPwsCyAIIAIoAgQgAigCCCACKAIAKAIQEQEADAgLIAEgBq0iDSABKQMIfDcDCCABIAEpAxAgDX03AxAgAkGwAmoiBiACQRBqIgcQ4BQgAigCsAJBCEYEQCACQagCaiIDIAJBxAJqKAIANgIAIAJBoAJqIgQgAkG8AmopAgA3AwAgAiACKQK0AjcDmAIgBiAHQYgC/AoAAEGIAkEIEK02IgFFDQIgASAGQYgC/AoAACAFEJ8vIABBCDYCACAFIAE2AgAgACACKQOYAjcCBCAAQQxqIAQpAwA3AgAgAEEUaiADKAIANgIAIAggAigCBCACKAIIIAIoAgAoAhARAQAMCAsgAkGwAmoQySMgAkEQahD8LCAIIAIoAgQgAigCCCACKAIAKAIQEQEADAILIAAgAikCtAI3AgQgAEEINgIAIABBFGogAkHEAmooAgA2AgAgAEEMaiACQbwCaikCADcCAAwGC0EIQYgCEKM9AAsgASkDEFBFDQALCyAAQoiAgIAgNwMADAILIAFBIGoiAygCDAR/IAMoAgQgAygCCCIFIAMoAgAiA0EAIAMgBU0ba0EYbGoFQQALIgMEQCABKAIsIgVBAk8EQCABKAIkIAEoAihBAWoiBCABKAIgIghBACAEIAhPG2tBGGxqKAIIIQQLIABBADoAFCAAQQA2AgwgAEKIgICAEDcDACAAIAQgASgCMCAFQQFLGyADKAIIazYCCAwCCyAAQoiAgIAgNwMADAELIABBAToAFCAAQQA2AgwgAEIINwMACyACQcAEaiQAC9gOAwd/A34BbyMAQZABayICJAAgAiABNgIIIAJBMGogAkEIahDHEiACKAIwIQECQAJAAkACQAJAAkACQCACLQA0IgNBAmsOAgIAAQsgAEEANgIAIAAgATYCBCACKAIIIgBBgwFLDQMMBAsgAiADOgAYIAIgATYCFCACQQA2AgwgAkHQAGpBwMbMABClKyACQgA3AzggAkEANgI0IAJB+MbMADYCMCACIAIpA1g3A0ggAiACKQNQNwNAAkADQAJAIAJB+ABqIQMjAEEgayIBJAAgAUEIaiACQQxqIgRBCGoQ/CkCQAJAIAEoAggiBkECRwRAIAEoAgwhBSAGQQFxBEAgA0GBgICAeDYCACADIAU2AgQMAwsgASAFEKQlIAEoAgQhBSABKAIAIQYCQCAEKAIARQ0AIAQoAgQiB0GEAUkNACAHEPIfCyAEIAU2AgQgBEEBNgIAIAFBFGogBhDdGyABKAIUIgRBgICAgHhHDQEgASgCGCEEIANBgYCAgHg2AgAgAyAENgIEDAILIANBgICAgHg2AgAMAQsgAyABKQIYNwIEIAMgBDYCAAsgAUEgaiQAAkACQAJAAkAgAigCeCIBQYCAgIB4aw4CBAABCyACKAJ8IQEMAQsgAiACKQJ8Igk3AogBIAIgATYChAEgAigCDCACQQA2AgxFDQkgAkHQAGogAigCEBDdGyACKAJQQYCAgIB4Rw0BIAIoAlQhASACQYQBahDeOwsgAEEANgIAIAAgATYCBCACQTBqEJMnDAMLIAJB8ABqIAJB2ABqKAIANgIAIAIgAikCUDcDaCACIAk3AiggAiABNgIkIAJB0ABqIgEgAkEwaiACQSRqIAJB6ABqEM4JIAEQhjAMAQsLIAAgAikDMDcDACAAQRhqIAJByABqKQMANwMAIABBEGogAkFAaykDADcDACAAQQhqIAJBOGopAwA3AwALIAIoAhQiAEGEAU8EQCAAEPIfCyACKAIMRQ0BIAIoAhAiAEGEAUkNASAAEPIfDAELIAJBCGoiARCqOwR/IAEoAgAlARBMIQwQ3xIiASAMJgFBAQVBAAshAyACIAE2AgQgAiADNgIAIAIoAgBBAXEEQCACIAIoAgQ2AiQgAkEUaiACQSRqENEvQQAhAyACQQA2AiAgAkEANgIMQQAhASACKAIUBEAgAigCHCIBIAIoAhhrIgRBACABIARPGyEBCyACQdAAakHAxswAEKUrIAIpA1ghCiACKQNQIQsCQCABRQRAQfjGzAAhAQwBCyACQdAAaiACQYQBakEYQQggAUEPTwR/QX9BqtUCIAEgAUGq1QJPG0EDdEEHbkEBa2d2QQFqBUEEQQhBECABQQhJGyABQQRJGwsQnRQgAigCVCEDIAIoAlAiAUUEQCACNQJYIQlBACEBDAELIAIpAlghCSADQQlqIgRFDQAgAUH/ASAE/AsACyACIAo3A0ggAiALNwNAIAIgCTcDOCACIAM2AjQgAiABNgIwIAJB3ABqIQYCQAJAA0ACQCACQdAAaiEDIwBBQGoiASQAIAFBBGohB0EAIQgjAEEQayIEJAACQCACQQxqIgUoAghFDQAgBEEIaiAFQQhqELsoIAQoAghBAXFFDQAgBCAEKAIMEKQlIAcgBCkDADcCBCAFIAUoAhRBAWo2AhRBASEICyAHIAg2AgAgBEEQaiQAAkAgASgCBEEBRgRAIAEoAgwhBCABQRxqIAEoAggQ3RsgASgCHEGAgICAeEYEQCADIAEoAiA2AgQgA0GBgICAeDYCACAEQYQBSQ0CIAQQ8h8MAgsgAUEYaiIFIAFBJGoiBygCADYCACABIAEpAhw3AxAgAUEcaiAEEN0bIAEoAhxBgICAgHhGBEAgAyABKAIgNgIEIANBgYCAgHg2AgAgAUEQahDeOwwCCyABQTxqIAcoAgA2AgAgAUEwaiIEIAUoAgA2AgAgASABKQIcNwI0IAMgASkDECIJNwIAIANBCGogBCkDADcCACADQRBqIAFBOGopAwA3AgAgASAJNwMoDAELIANBgICAgHg2AgALIAFBQGskAAJAAkAgAigCUCIBQYCAgIB4aw4CAgABCyAAIAIoAlQ2AgQgAEEANgIAIAJBMGoQkycgAigCDEUNBCACKAIQIgBBgwFLDQMMBAsgAkGAAWogBkEIaigCADYCACACIAIpAlQ3AmwgAiABNgJoIAIgBikCADcDeCACQYQBaiIBIAJBMGogAkHoAGogAkH4AGoQzgkgARCGMAwBCwsgACACKQMwNwMAIABBGGogAkHIAGopAwA3AwAgAEEQaiACQUBrKQMANwMAIABBCGogAkE4aikDADcDACACKAIMRQ0BIAIoAhAiAEGEAUkNAQsgABDyHwsgAigCJCIAQYQBSQ0BIAAQ8h8MAQsgAkEIaiACQYQBakGAxcwAENELIQEgAEEANgIAIAAgATYCBAsgAigCCCIAQYQBSQ0BCyAAEPIfCyACQZABaiQADwtBsMfMAEExEJc9AAvKJAIbfwV+IwBB4ABrIgYkAAJAAkACQCABKAJgIgVBgICAgHhHBEAgAS0AcUUNAiABKAJkIRAgBkEYaiIIIAEoAmgiCUEAQQRBDBCgGCAGKAIcIQQgBigCGEEBRwRAIAFBEGpBACAFQYCAgIB4RxshDyAGQQA2AgggBiAGKAIgNgIEIAYgBDYCACAJRQ0CIBAgCUEGdGohHCAIQQRyIRUDQCAGQRhqIBAoAihBAEEEQRgQoBggBigCHCEJAkACQAJAAkACQCAGKAIYQQFHBEAgBkEANgIUIAYgBigCIDYCECAGIAk2AgwgECgCKCIJRQ0FIAlBwAJsIRkgECgCJEHEAWohEQNAAkACQCARQZQBaygCAEEBRw0AIBFBjAFrKQMAIh9CAFMNACARQQRrKAIAQQFHDQAgESgCACIEQQBIDQAgHyADfSIfQv////8PWA0BIAZBATYCPCAGQay+zQA2AjggBkIBNwJEIAZBpgQ2AlggBiAGQdQAajYCQCAGIAZB3wBqNgJUIABBBGogBkE4ahCZDiAAQQA2AgAMBwsgBkE4akEUQQBBAUEBEKAYIAYoAjwhCSAGKAI4QQFGDQMgBigCQCECIAZBADYCICACQRBqQdj1zwAoAAA2AAAgAkEIakHQ9c8AKQAANwAAIAJByPXPACkAADcAACAGQRQ2AiwgBiACNgIoIAYgCTYCJCAGQQE2AhgMBQsgHyAErXwiIEKAgICAEFoEQCAGQQE2AjwgBkGsvs0ANgI4IAZCATcCRCAGQaYENgJYIAYgBkHUAGo2AkAgBiAGQd8AajYCVCAAQQRqIAZBOGoQmQ4gAEEANgIADAYLIAIoAggiCSAgpyIFSQ0DIAZBGGohEiACKAIEIB+naiEFIwBBQGoiCSQAIAkgBSAEEJ0fIAlBKGohCCMAQaABayIEJAAgBEHoAGogCRDwJyAEQdAAaiIFIARB9ABqIgcoAgA2AgAgBCAEKQJsNwNIAkAgBCgCaCILQQRHBEAgBCgCeCEHIAggBCkDSDcCCCAIIAc2AhQgCCALNgIEIAhBgICAgHg2AgAgCEEQaiAFKAIANgIADAELIARBMGogBSgCADYCACAEIAQpA0g3AyggBEEoahCGMCAEQYCAgIB4NgIIIARBgICAgHg2AhggBEHoAGogCRDTCSAFIAcpAgA3AwAgBEHYAGoiFiAEQfwAaigCADYCACAEIAQpAmw3A0gCQAJAIAQoAmhFBEAgBEHMAGohFCAEQfAAaiEXIARB7ABqIRgDQCAEQThqIBYoAgAiBTYCACAEQTBqIARB0ABqIhopAwA3AwAgBCAEKQNINwMoAkACQAJAAkACQCAFQf8BcQRAIARB6ABqIARBKGoQ/BcgBC8BbCEFIAQoAmgiB0EERwRAIAggBCkBbjcBCiAIQRBqIARB9ABqKQEANwEAIAggBTsBCCAIIAc2AgQgCEGAgICAeDYCAAwJCwJAAkACQCAFQQFrDgIAAQILIARB6ABqIAkQyQ8gBCgCbCELIAQoAmgiBUEERwRAIAggBCkAcTcADSAIQRRqIARB+ABqKAAANgAAIAggBC0AcDoADCAIIAs2AgggCCAFNgIEIAhBgICAgHg2AgAMCwsgBEHoAGogC0EAQQhBGBCgGCAEKAJsIQUgBCgCaEEBRg0DIARBADYCRCAEIAQoAnA2AkAgBCAFNgI8IAtBAEwNBgNAIARB6ABqIQdCACEfQQAhDEEAIRtCACEiQgAhIEIAISEjAEHwAGsiBSQAIAVB2ABqIAkQ8CcgBUHIAGoiDSAFQeQAaiIKKAIANgIAIAUgBSkCXDcDQAJAIAUoAlgiE0EERwRAIAUoAmghDCAHIAUpA0A3AgggByAMNgIUIAcgEzYCBCAHQQE2AgAgB0EQaiANKAIANgIADAELIAVBMGogDSgCADYCACAFIAUpA0A3AyggBUEoahCGMCAFQdgAaiAJENMJIA0gCikCADcDACAFQdAAaiIKIAVB7ABqKAIANgIAIAUgBSkCXDcDQAJAAkAgBSgCWEUEQCAFQdwAaiETQQAhDQNAIAVBOGogCigCACIONgIAIAVBMGogBUHIAGoiHSkDADcDACAFIAUpA0A3AygCQCAOQf8BcQRAIAVB2ABqIAVBKGoQ/BcgBS8BXCEOIAUoAlgiHkEERwRAIAcgBSkBXjcBCiAHQRBqIAVB5ABqKQEANwEAIAcgDjsBCCAHIB42AgQMBgsCQAJAAkACQCAOQQFrDgMBAAIDCyAFQdgAaiAJEMAcIAUoAlhFBEAgBSgCYCEMQQEhDQwFCyAFKQNgIiOnIQxBASENIAUoAlwiDkEERg0EIAcgBSkDaDcDECAHIAw2AgggByAONgIEIAcgI0IgiD4CDAwICyAFQdgAaiAJEMAcIAUoAlhFBEAgBSkDYCEgQgEhHwwECyAFKAJcIQwgBSkDYCEfIAcgBSkDaDcDECAHIB83AwggByAMNgIEDAcLIAVB2ABqIAkQwBwgBSgCWA0FIAUpA2AhIUEBIRtCASEiDAILIAVB2ABqIAkgBS0AOEHAABDJAiAFKAJYIg5BBEYNASAHIAUpAlw3AgggB0EQaiAFQeQAaikCADcCACAHIA42AgQMBQsgBSAhNwMgIAUgIjcDGCAFIAw2AhQgBSANNgIQIAUgIDcDCCAFIB83AwAgBUEoahCGMCAFQdgAaiAJEKgpIAUoAlgiCkEERwRAIAcgBSkCXDcCCCAHQRBqIAVB5ABqKQIANwIAIAdBATYCACAHIAo2AgQMBgsgBUHYAGpB8pXQAEETIAUQ5h4gBSgCWCIKQQRHBEAgByAFKQJcNwIIIAdBEGogBUHkAGopAgA3AgAgB0EBNgIAIAcgCjYCBAwGCyAFQdgAakGFltAAQSEgBUEQahDmHiAFKAJYIgpBBEcEQCAHIAUpAlw3AgggB0EQaiAFQeQAaikCADcCACAHQQE2AgAgByAKNgIEDAYLIAVB2ABqQaaW0ABBHCAFQRhqEOYeIAUoAlgiCkEERwRAIAcgBSkCXDcCCCAHQRBqIAVB5ABqKQIANwIAIAdBATYCACAHIAo2AgQMBgsCQAJAIB9QRQRAIA1FDQEgG0UNAiAHIAw2AhggByAhNwMQIAcgIDcDCCAHQQA2AgAMCAtB+PzPAEHHAEHEltAAEMskAAtB+PzPAEHHAEHUltAAEMskAAtB+PzPAEHHAEHkltAAEMskAAsgBUEoahCGMCAFQdgAaiAJENMJIB0gE0EIaikCADcDACAKIBNBEGooAgA2AgAgBSATKQIANwNAIAUoAlhFDQALCyAHIAUpA0A3AgQgB0EBNgIAIAdBFGogCigCADYCACAHQQxqIAVByABqKQMANwIADAILIAUoAlwhDCAFKQNgIR8gByAFKQNoNwMQIAcgHzcDCCAHIAw2AgQLIAdBATYCACAFQShqEIYwCyAFQfAAaiQAIAQoAmgEQCAEQdgAaiAEQfwAaigCACIFNgIAIARB0ABqIARB9ABqKQIAIh83AwAgBCAEKQJsIiA3A0ggCEEUaiAFNgIAIAhBDGogHzcCACAIICA3AgQgCEGAgICAeDYCACAEQTxqQQhBGBDgHgwMCyAUIBcpAgA3AgAgFEEQaiIFIBdBEGopAgA3AgAgFEEIaiIHIBdBCGopAgA3AgAgBEGQAWoiDCAHKQIANwMAIARBmAFqIg0gBSkCADcDACAEIBQpAgA3A4gBIAQoAkQiByAEKAI8RgRAIwBBEGsiBSQAIAVBCGogBEE8aiIKIAooAgBBAUEIQRgQtxEgBSgCCCIKQYGAgIB4RwRAIAogBSgCDEGEl9AAEP0vAAsgBUEQaiQACyAEKAJAIAdBGGxqIgUgBCkDiAE3AwAgBUEIaiAMKQMANwMAIAVBEGogDSkDADcDACAEIAdBAWo2AkQgC0EBayILDQALDAYLIARB6ABqIAkQyQ8gBCgCbCELIAQoAmgiBUEERwRAIAggBCkAcTcADSAIQRRqIARB+ABqKAAANgAAIAggBC0AcDoADCAIIAs2AgggCCAFNgIEIAhBgICAgHg2AgAMCgsgBEHoAGogC0EAQQhBCBCgGCAEKAJsIQUgBCgCaEEBRg0DIARBADYCUCAEIAQoAnA2AkwgBCAFNgJIIAtBAEoEQANAIARB6ABqIAkQwBwgBCgCaARAIAQoAmwhBSAEKQNwIR8gCCAEKQN4NwIQIAggHzcCCCAIIAU2AgQgCEGAgICAeDYCACAEQcgAahDjPAwMCyAEKQNwIR8gBCgCUCIFIAQoAkhGBEAgBEHIAGpBpJfQABCzKAsgBCgCTCAFQQN0aiAfNwMAIAQgBUEBajYCUCALQQFrIgsNAAsLIARB8ABqIgUgGigCADYCACAEIAQpAkg3A2ggBEEYahCFMCAEQSBqIAUoAgA2AgAgBCAEKQNoNwMYDAYLIARB6ABqIAkgBC0AOEHAABDJAiAEKAJoIgVBBEYNBSAIIAQpAmw3AgggCEEQaiAEQfQAaikCADcCACAIQYCAgIB4NgIAIAggBTYCBAwICyAEQShqEIYwIARB6ABqIAkQqCkgBCgCaCIFQQRHBEAgCCAEKQJsNwIIIAhBEGogBEH0AGopAgA3AgAgCEGAgICAeDYCACAIIAU2AgQMCQsgBEHoAGpBtJfQAEEaIARBCGoQ9R0gBCgCaCIFQQRHBEAgCCAEKQJsNwIIIAhBEGogBEH0AGopAgA3AgAgCEGAgICAeDYCACAIIAU2AgQMCQsgBCgCCCIFQYCAgIB4Rg0CIAggBCkDGDcCDCAIIAQpAgw3AgQgCCAFNgIAIAhBFGogBEEgaigCADYCAAwJCyAFIAQoAnBB9JbQABD9LwALIAUgBCgCcEGUl9AAEP0vAAtB+PzPAEHHAEHQl9AAEMskAAsgBEHwAGoiBSAEQcQAaigCADYCACAEIAQpAjw3A2ggBCgCCEGAgICAeEcEQCAEQQhqQQhBGBDgHgsgBEEQaiAFKAIANgIAIAQgBCkDaDcDCAsgBEEoahCGMCAEQegAaiAJENMJIBogGEEIaikCADcDACAWIBhBEGooAgA2AgAgBCAYKQIANwNIIAQoAmhFDQALCyAIIAQpA0g3AgQgCEGAgICAeDYCACAIQRRqIBYoAgA2AgAgCEEMaiAEQdAAaikDADcCAAwBCyAEQShqEIYwCyAEQRhqEIUwIAQoAghBgICAgHhGDQAgBEEIakEIQRgQ4B4LIARBoAFqJAAgCUEgaiIEIAlBPGooAgA2AgAgCSAJKQI0NwMYIAkpAiwhHwJ/IAkoAigiBUGAgICAeEYEQCAJQThqIAQoAgA2AgAgCSAJKQMYNwMwIAkgHzcDKCASQQhqIAgQpSVBAQwBCyASIAkpAxg3AhAgEkEYaiAEKAIANgIAIBIgHzcDCCASIAU2AgRBAAshBCAJEJ08IBIgBDYCACAJQUBrJAAgBigCGA0EIAYoAhQiCSAGKAIMRgRAIAZBDGpB7PXPABCRKAsgBigCECAJQRhsaiIEIBUpAgA3AgAgBEEIaiAVQQhqKQIANwIAIARBEGogFUEQaikCADcCACAGIAlBAWo2AhQgEUHAAmohESAZQcACayIZDQALDAULIAkgBigCIEGo9c8AEP0vAAsgCSAGKAJAQbDozwAQ/S8ACyAFIAlB3PXPABCwOwALIAZByABqIAZBMGopAwA3AwAgBkFAayAGQShqKQMANwMAIAYgBikDIDcDOCABLQBxQQJHBEAgD0E4ahC4LyAPQYCAgIB4NgI4IA9BxABqELkvIABBCDYCACAPQYCAgIB4NgJEIAZBOGoQySMMAQsgACAGQSBqIgEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDAAsgBkEMaiIAEOQpIABBBEEYEOAeIAYQxyogBkEEQQwQ4B4MBgsgBkEgaiIEIAZBFGooAgA2AgAgBiAGKQIMNwMYIAYoAggiCSAGKAIARgRAIAZBuPXPABCQKAsgBigCBCAJQQxsaiIFIAYpAxg3AgAgBUEIaiAEKAIANgIAIAYgCUEBajYCCCAQQUBrIhAgHEcNAAsMAgsgBCAGKAIgQZj1zwAQ/S8AC0GI9c8AELI7AAsgBkEgaiIBIAZBCGooAgA2AgAgBiAGKQIANwMYIA9BxABqELkvIA9BzABqIAEoAgA2AgAgDyAGKQMYNwJECyAAQQg2AgALIAZB4ABqJAALvwkCBX8FfiMAQcABayIEJAAgAUEMaigCCCEIIARBOGogARCSNhDuJSAIQQR0IgchBQJAAkACQAJAAkAgB0EwcSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgJYIAQgBTYCVCAEQcAANgJQIAcEQCAGQQAgB/wLAAsgBCAINgJgIAQgBzYCXCAEKAI4RQ0DIAQoAkwgBCgCSEYNBCAEQfAAaiAEQThqEMg0IARBkAFqIQcgAikDCCELIAIpAwAhDCADLQAAIQIgASgCECEBA0ACQCAEKQOYASIKUEUEQCAEKQOgASEJDAELA0ACfgJAIAQpA4ABIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A4ABIAmnQQFxRQ0AIAQgBCkDiAE3A7ABDAELIAQoApABRQ0BIARBqAFqIAcQtiogBCkDqAEhCQsgCUIAUg0CCyAEQgM3A4ABCyAEKQNwIglCAlENCSAEQgA3A3AgBCkDeAwBCyAEKQOwAQshCiAJp0EBcUUNByAEIAQpA6ABQkB9Igk3A6ABIAQgCjcDmAEgClANAAsLIARCASAKeiINhiAKhTcDmAEgCyAMhFAEQEGHgICAeCEFDAcLIARBIGogASANpyAJp2oiA2oxAABCACAMIAsQgxkgBEGoAWogBCkDICIJIAQpAygiCiACEK0OIAQoAqgBIgVBk4CAgHhHBEAgBCkCtAEhCSAEKQKsASEKDAcFIAYgA0EEdGoiAyAKNwMIIAMgCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAikDCCEJIAIpAwAhCiADLQAAIQIgASgCECEDQQAhAQNAIAkgCoRQBEBBh4CAgHghBQwDCyAEQRBqIAEgA2oxAABCACAKIAkQgxkgBEHwAGogBCkDECILIAQpAxgiDCACEK0OIAQoAnAiBUGTgICAeEcEQCAEKQJ8IQkgBCkCdCEKDAMLIAYgCzcDACAGIAw3AwggBkEQaiEGIAggAUEBaiIBRw0ACwsgBEHwAGoiAhCXKSAEQdgAaiIBKAIAIQYgBCgCXCEDIAEgBEH4AGoiBSkCADcDACAEKQNQIQkgBCAEKQJwNwNQIARBADYCYCAEIAk3AnwgBEEANgJ4IAQgAzYCdCAEIAY2AnAgBEEIaiACENc7IAQoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJwNwIIIAFBEGogBSkCADcCACABQRhqIARBgAFqIgcoAgA2AgAgBCADNgKwASAEIAY2AqwBIAQgATYCqAEgBEHkAGoiASAEQagBahDiGSAHIARByABqKQIANwMAIAUgBEFAaykCADcDACAEIAQpAjg3A3AgACABIAIQyx0gBEHQAGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAU2AgQgAEEpOgAAIARB0ABqEM8vIAQoAjgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEE4ahD7HgsgBEHAAWokAAuuCQIHfwN+IwBBsAFrIgQkACABQQxqENk8IQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQMgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCADRQRAQYeAgIB4IQIMAQsgBEGIAWogASANpyALp2oiCEEBdGovAQAgA20iCSAHEOoPIAQoAogBIgJBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiEDDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEJIAIoAgAhByABKAIQIQVBACEBA0AgBEGgAWohAyAHRQRAQYeAgIB4IQIMAwsgBEFAayAFLwEAIAdtIgogCRDqDyAEKAJAIgJBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQUgBCgCLCEDIAEgBEHIAGoiBikCADcDACAEKQMgIQsgBCAEKQJANwMgIARBADYCMCAEIAs3AkwgBEEANgJIIAQgAzYCRCAEIAU2AkAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBikCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKQASAEIAU2AowBIAQgATYCiAEgBEE0aiIBIARBiAFqEOUZIAcgBEEYaikCADcDACAGIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEModIARBIGoQzy8MAgtBBEEcEKM9AAsgACAGNgIIIAAgAjYCBCAAQSk6AAAgACADKQIANwIMIABBFGogA0EIaigCADYCACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGwAWokAAuuCQIHfwN+IwBBsAFrIgQkACABQQxqENk8IQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQMgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCADRQRAQYeAgIB4IQIMAQsgBEGIAWogASANpyALp2oiCEEBdGouAQAgA20iCSAHEOoPIAQoAogBIgJBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiEDDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEJIAIoAgAhByABKAIQIQVBACEBA0AgBEGgAWohAyAHRQRAQYeAgIB4IQIMAwsgBEFAayAFLgEAIAdtIgogCRDqDyAEKAJAIgJBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAFQQJqIQUgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQUgBCgCLCEDIAEgBEHIAGoiBikCADcDACAEKQMgIQsgBCAEKQJANwMgIARBADYCMCAEIAs3AkwgBEEANgJIIAQgAzYCRCAEIAU2AkAgBCACENc7IAQoAgAhBUEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBikCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKQASAEIAU2AowBIAQgATYCiAEgBEE0aiIBIARBiAFqEOUZIAcgBEEYaikCADcDACAGIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEModIARBIGoQzy8MAgtBBEEcEKM9AAsgACAGNgIIIAAgAjYCBCAAQSk6AAAgACADKQIANwIMIABBFGogA0EIaigCADYCACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGwAWokAAvyDQIIfwR+IwBB8ABrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUQAAAAAAAAAAGZFBEAgAkEwaiABmhDxCCACKAIwIgRBgICAgHhGDQIgAiACKQI0Igo3AhQgAiAENgIQIApC/////w9YBEAgAkEQahDpO0EBIQZCBCEKQQAhBAsMAQsgAkHgAGogARDxCCACKAJgIgRBgICAgHhGDQEgAkE4aiACQegAaigCACIDNgIAIAIgAikCYDcDMAJ/IAMEQCACKQJkIQpBAgwBCyACQTBqEOk7QQAhBEIEIQpBAQshBgsgAkEOaiIDQQA6AAAgAkEAOwEMIAJBH2ogAy0AADoAACACIAY6ABwgAiAENgIQIAIgAi8BDDsAHSACIAo3AhQCQCAKQoCAgIAQWgRAQgAhCiMAQSBrIgMkAAJAAkAgAkEQaiIGKAIIIgUEQCAGKAIEIAVBAnRqQQRrIgRFDQEgBa1CBYYgBCgCAGetfSEKCyADQRRqQX8gCkIDiCILIAogC0IDhlKtfCIKpyAKQoCAgIAQWhtBAEEBQQEQoBggAygCGCEHIAMoAhRBAUcEQCAFQQFrIQQgA0EANgIQIAMgAygCHDYCDCADIAc2AgggBQRAIAYoAgQiBiAEQQJ0aiEHQQAhBSAERQ0DA0AgBigCACEEQQAhCANAIAMoAgggBUYEQCADQQhqQcCPiAEQqRkLIAMoAgwgBWogBDoAACADIAVBAWoiBTYCECAEQQh2IQQgCEEBaiIIQf8BcUEESQ0ACyAHIAZBBGoiBkcNAAsMAwsgBEEAQaCPiAEQsDsACyAHIAMoAhxBkI+IARD9LwALQfChiAEQsjsACyAHKAIAIgQEQANAIAMoAgggBUYEQCADQQhqQbCPiAEQqRkLIAMoAgwgBWogBDoAACADIAVBAWoiBTYCECAEQQh2IgQNAAsLIAJB4ABqIgUgAykCCDcCACAFQQhqIANBEGooAgA2AgAgA0EgaiQAIAIoAmghBiACKAJkIQQMAQtBASEGQQFBARCtNiIERQ0CIARBADoAACACQQE2AmggAiAENgJkIAJBATYCYAsgAkEIaiIFIAQgBmpBAWsiB0EAIAYbIgMEfyADLQAABUEACzoAASAFIANBAEc6AAAgAi0ACUEAIAItAAgbwCIDQQBODQMgA0GAf0cNAiACQQA2AjggAiAENgIwIAIgByAEIAYbNgI0IAYEQCACQTBqIgUoAgRBAWshAyAFKAIAIQcDQCAHIANBAWoiCEcEQCAFIAM2AgQgAy0AACADQQFrIQNFDQELCyAHIAhHDQMLIAItABwNAgwECyAAQgA3AwggAEIANwMADAULQQFBARCjPQALIAIoAmAgBkYEfyACQeAAakHQ8ocBEKkZIAIoAmQFIAQLIAZqQQA6AAAgAiAGQQFqIgY2AmgLIAItABwNASACKAJkIQQLIAZFDQBBASEDA0AgBCAELQAAIgdBf3M6AAAgA0EAIQMEQCAEQQAgB2s6AAAgB0UhAwsgBEEBaiEEIAZBAWsiBg0ACwsgAkEoaiIFIAJB6ABqIgQoAgAiAzYCACACIAIpAmA3AyACQAJ/AkACQAJAIANBIEsgA0EgSWtB/wFxDgIAAQILIAQgBSgCADYCACACIAIpAyA3A2AgAkEwaiIDAn8gAkHgAGoiBSgCCEEgRwRAIAMgBSkCADcCBCADQQxqIAVBCGooAgA2AgBBAQwBCyAFQQA2AgggAyAFKAIEIgQpAAA3AAEgA0EJaiAEQQhqKQAANwAAIANBEWogBEEQaikAADcAACADQRlqIARBGGopAAA3AAAgBRDeO0EACzoAACACLQAwQQFGDQUgAkE5aikAACEKIAIpAEkhCyACKQBBIQwgAikAMSENQQAhBAwDCyADQR9NDQUgAigCJCIDKQAYIQsgAykAECEMIAMpAAghCiADKQAAIQ1BAQwBCwJAIAItABwEQCACQcgAakIANwMAIAJBQGtCADcDACACQgA3AzggAkIANwMwDAELIAJByABqQn83AwAgAkFAa0J/NwMAIAJCfzcDOCACQn83AzALIANBIU8NBSADBEAgAkEwaiACKAIkIAP8CgAACyACKQNIIQsgAikDQCEMIAIpAzghCiACKQMwIQ1BAAshBCACQSBqEN47CyACQRBqEOk7IAAgBAR+QgAFIAAgDDcDICAAIA03AxAgACALNwMoIAAgCjcDGEIBCzcDACAAQgA3AwgLIAJB8ABqJAAPCyACQegAaiACQTxqKAIANgIAIAIgAikCNDcDYEGM84cBQSsgAkHgAGpBuPOHAUGA9IcBENUeAAtBICADQZD0hwEQsDsACyADQSBB8POHARCwOwAL9AgBB38jAEEwayIDJAACQCACLQAMIgRBAUYEQCAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIADAELAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAMIgZBAWsOAgACAQsgA0EQaiACEOkdIAAgAykCEDcCACADQQIgBGs6ABwgAEEIaiADQRhqKQIANwIADAkLIARFDQEMAgsgBEUNAQsCfyABKAIIIgQgAigCCCIFRwRAIAQgBUsgBCAFSWsMAQsgBEECdCEEIAEoAgRBBGshCCACKAIEQQRrIQkCQANAIARFDQEgBCAJaiEHIAQgCGogBEEEayEEKAIAIgUgBygCACIHRg0ACyAFIAdLIAUgB0lrDAELQX9BACAEGwtB/wFxDgICAwELIANBGGogAUEIaigCADYCACADIAEpAgA3AxAgA0EgaiADQRBqIAIQ7QggACADKQIgNwIAIABBCGogA0EoaigCACIBNgIAIAAgBkEBIAEbOgAMDAYLQQIhBAJAAkACQCAGQQFrDgICAAELQQAhBAsgA0EYaiABQQhqKAIANgIAIAMgASkCADcDECADQSBqIAIgA0EQahDyCiAEQQEgAygCKBshBAwECyADQRhqIAFBCGooAgA2AgAgAyABKQIANwMQIANBIGoiASACIANBEGoQ8gogA0EANgIoIAFBBEEEEJ4kIAMoAigiAkUNAiADKAIkIgEgAkECdCIFakEEayIERQ0CIAQoAgANAiAFIQQgAUEEayEGIAJB/////wNxIQECQANAIARFBEBBACEEDAILIAFBAWshASAEIAZqIARBBGshBCgCAEUNAAsgAUEBaiIEIAJLDQMLIAMgBDYCKCAEIQIMAgsgAEEIakGUiogBKQIANwIAIABBjIqIASkCADcCAAwDCyADQRhqIgQgAUEIaigCADYCACADIAEpAgA3AxAgA0EQaiACEO8UIANBKGogBCgCADYCACADIAMpAxA3AyACQCAGQQFHBEAgBkEBIAMoAigbIQQMAQsgA0EANgIoIANBIGpBBEEEEJ4kAkAgAygCKCICRQ0AIAMoAiQiASACQQJ0IgVqQQRrIgRFDQAgBCgCAA0AIAUhBCABQQRrIQYgAkH/////A3EhAQJAA0AgBEUEQEEAIQQMAgsgAUEBayEBIAQgBmogBEEEayEEKAIARQ0ACyABQQFqIgQgAksNAQsgAyAENgIoIAQhAgtBASEEIAIgAygCIEECdk8NACADQQhqIANBIGogAkEEQQQQ9BQgAygCCCIBQYGAgIB4Rg0AIAEgAygCDEHMjYgBEP0vAAsgACADKQMgNwIAIAAgBDoADCAAQQhqIANBKGooAgA2AgAMAwtBASEEIAIgAygCIEECdk8NACADIANBIGogAkEEQQQQ9BQgAygCACIBQYGAgIB4Rg0AIAEgAygCBEHMjYgBEP0vAAsgACADKQIgNwIAIAAgBDoADCAAQQhqIANBKGooAgA2AgAMAQsgAUEEQQQQ4B4LIANBMGokAAvhCQIHfwF+IwBBgAFrIgIkACACQdAAaiABEPAnIAJBQGsiBCACQdwAaiIFKAIANgIAIAIgAikCVDcDOAJAIAIoAlAiBkEERwRAIAIoAmAhASAAIAIpAzg3AgggACABNgIUIAAgBjYCBCAAQYGAgIB4NgIAIABBEGogBCgCADYCAAwBCyACQShqIAQoAgA2AgAgAiACKQM4NwMgIAJBIGoQhjAgAkGAgICAeDYCACACQYCAgIB4NgIQIAJB0ABqIAEQ0wkgBCAFKQIANwMAIAJByABqIgYgAkHkAGooAgA2AgAgAiACKQJUNwM4AkACQCACKAJQRQRAIAJB1ABqIQRBAiEHA0AgAkEwaiAGKAIAIgM2AgAgAkEoaiACQUBrIgUpAwA3AwAgAiACKQM4NwMgAkACQCADQf8BcQRAIAJB0ABqIAJBIGoQ/BcgAi8BVCEDIAIoAlAiCEEERwRAIAAgAikBVjcBCiAAQRBqIAJB3ABqKQEANwEAIAAgAzsBCCAAIAg2AgQgAEGBgICAeDYCAAwGCwJAAkACQAJAIANBAWsOAwABAgMLIAJB0ABqIAEQpREgBSAEQQhqKAIANgIAIAIgBCkCADcDOCACKAJQIgNBBEYNBCACKAJgIQEgACACKQM4NwIIIAAgATYCFCAAIAM2AgQgAEGBgICAeDYCACAAQRBqIAJBQGsoAgA2AgAMCAsgAkHQAGogARClESAFIARBCGooAgA2AgAgAiAEKQIANwM4IAIoAlAiA0EERwRAIAIoAmAhASAAIAIpAzg3AgggACABNgIUIAAgAzYCBCAAQYGAgIB4NgIAIABBEGogAkFAaygCADYCAAwICyACQdgAaiIDIAUoAgA2AgAgAiACKQM4NwNQIAJBEGoQhjAgAkEYaiADKAIANgIAIAIgAikDUDcDEAwECyACQdAAaiABENoQIAItAFQhByACKAJQIgNBBEYNAyAAIAIpAFU3AAkgAEEQaiACQdwAaikAADcAACAAIAc6AAggACADNgIEIABBgYCAgHg2AgAMBgsgAkHQAGogASACLQAwQcAAEMkCIAIoAlAiA0EERg0CIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIAIABBgYCAgHg2AgAgACADNgIEDAULIAJBIGoQhjAgAkHQAGogARCoKSACKAJQIgFBBEcEQCAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCACAAQYGAgIB4NgIAIAAgATYCBAwGCyACQfAAaiIBIAJBCGooAgA2AgAgAkH8AGogAkEYaigCADYCACAAIAIpAwAiCTcCACAAIAc6ABggAiACKQMQNwJ0IABBCGogASkDADcCACAAQRBqIAJB+ABqKQMANwIAIAIgCTcDaAwGCyACQdgAaiIDIAUoAgA2AgAgAiACKQM4NwNQIAIQhjAgAkEIaiADKAIANgIAIAIgAikDUDcDAAsgAkEgahCGMCACQdAAaiABENMJIAUgBEEIaikCADcDACAGIARBEGooAgA2AgAgAiAEKQIANwM4IAIoAlBFDQALCyAAIAIpAzg3AgQgAEGBgICAeDYCACAAQRRqIAYoAgA2AgAgAEEMaiACQUBrKQMANwIADAELIAJBIGoQhjALIAJBEGoQhjAgAhCGMAsgAkGAAWokAAuBDAIQfwJ+IwBBgARrIgEkAAJAAn8CQAJAAkACQCAALQBYQQFrDgMCBQEACyAAQTBqIABBKPwKAAALAkACQAJAAkACQAJAAkACQCAALQBUQQFrDgMHCwABCyAALQBQQQFxDQUgACgCTCECIAAoAkRBAXFFDQIgACgCSCEDDAELIABBOGogACgCMBCFIyAAQQA6AFAgACAAKAI4IgI2AkwgACAAKAI0IgM2AkggACADQQBHNgJEIANFDQELIAFByABqIAMQxwcCQCABKAJIIgNBAmsOAgcBAAsgASgCTCEEIAFBGGogAUHQAGoiBUEw/AoAACABIAQ2AhQgASADNgIQQQEgASgCLCIDIANBAU0bQQEgASgCKEEBcRshCSABKAIwQYCAgIB4Rg0BIAFByABqIAFBMGoQiR0gASgCSEGAgICAeEYNASABQYgBaiAFKAIANgIAIAEgASkCSDcDgAEMAgsgAUGAgICAeDYCMCABQQA2AhAgAUGAgICAeDYCPCABQQA2AiAgAUEANgIYIAFBADYCKEEBIQkLIAFBgAFqIAIoAiBBCGooAlhB3MnCABCKOwsCfiACKAIAQQFGBEAgAUHIAGogAkEQahDdICACKAIcIgMgAygCACIEQQFqNgIAIARBAEgNByABKAJQIQogASgCTCEOIAEoAkghC0IBIRIgAikDCAwBCyACKAIQEPQ6IQsgAigCHCEDIAIoAhghCiACKQMICyETIAIoAiAiDCAMKAIAIgRBAWo2AgAgBEEASA0FIAIoAiQiDSANKAIAIgRBAWo2AgAgBEEASA0FIAIoAigiBgRAIAYgBigCACICQQFqNgIAIAJBAEgNBgsgASgCgAEhDyABKAKEASEHIAEoAogBIRAgAUGgAmohCCMAQRBrIgUkAAJAAkBB4AFBCBCtNiICBEAgAkIANwPIASACQgM3AwggAkKBgICAEDcDACACQQE7AdwBIAJBfzYC2AEgAkHQAWpCADcDACAFQQRqEOs6QSBBBBCtNiIERQ0BIAQgAjYCCCAEQoGAgIAQNwIAIAQgBSkCBDcCDCAEIAJBCGoiAjYCHCAEIAI2AhggBEEUaiAFQQxqKAIANgIAIAhBADoACCAIQQA2AgQgCCAENgIAIAVBEGokAAwCC0EIQeABEKM9AAtBBEEgEKM9AAsgAUGYAmpCADcDACABQQA2ArQCIAFCgICAgIABNwKsAiABQgA3A5ACIAEgAzYCrAEgASAKNgKoASABIA42AqQBIAEgCzYCoAEgASATNwOYASABIBI3A5ABIAFBsAFqIAFBEGpBOPwKAAAgASAJNgK4AiABQQA6AIgCIAEgByAQQQJ0ajYChAIgASAPNgKAAiABIAc2AvwBIAEgBzYC+AEgASAGNgLwASABIA02AuwBIAEgDDYC6AEgAUHAAmoiBCABQZABakGwAfwKAAAgAUEANgLwAwJ/IwBBEGsiAiQAQcABQQgQrTYiAwRAIAMgBEHAAfwKAAAgAkEIaiADQejPwwAQgCkgAigCCCACKAIMEM0sEIEpIAJBEGokAAwBC0EIQcABEKM9AAsMBAtB3NzCABDoKwALQZzcwgAQ6CsAC0HcyMIAEOgrAAtBASERIAEoAkwQgBgLIQIgAEEBOgBQIABBOGoQ5CogAEEBOgBUIABBMGoQ/ykCQCARBEAgASACNgKQASABQYABNgLAAiABIABBLGogAUHAAmogAUGQAWoQwiMgASgCACABKAIEENYvIgJBhAFPBEAgAhDyHwsgASgCwAIiAkGEAU8EQCACEPIfCyABKAKQASICQYQBSQ0BIAIQ8h8MAQsgASACNgKQASABQYABNgLAAiABQQhqIABBKGogAUHAAmogAUGQAWoQwiMgASgCCCABKAIMENYvIgJBhAFPBEAgAhDyHwsgASgCwAIiAkGEAU8EQCACEPIfCyABKAKQASICQYQBSQ0AIAIQ8h8LIAAoAigiAkGEAU8EQCACEPIfCyAAKAIsIgJBhAFPBEAgAhDyHwsgAEEBOgBYIAFBgARqJABBAA8LAAv0BwIEfwV+IwBBsAFrIgUkAAJAAkACQAJAIAR5IAN5QkB9IARCAFIbpyIHIAJ5IAF5QkB9IAJCAFIbpyIGSwRAIAZBP0sNASAHQd8ASw0CIAcgBmtBIEkNAyAFQaABaiADIARB4AAgB2siCBDHIyAFNQKgAUIBfCEMAkACQAJAAkADQCAFQZABaiABIAJBwAAgBmsiBhDHIyAFKQOQASEJIAYgCEkEQCAFQdAAaiADIAQgBhDHIyAFKQNQIgxQRQRAIAkgDIAhCQsgBUFAayADIAQgCUIAEKgeIAEgBSkDQCIMVCIGIAIgBSkDSCINVCACIA1RG0UEQCACIA19IAatfSECIAEgDH0hASALIAkgCnwiCSAKVK18IQsMCwsgASABIAN8IgFWrSACIAR8fCANfSABIAxUrX0hAiABIAx9IQEgCyAJIAp8QgF9IgkgClStfCELDAoLIAVBgAFqIAkgDIAiCUIAIAYgCGsiBhDGIyAFQfAAaiADIAQgCUIAEKgeIAVB4ABqIAUpA3AgBSkDeCAGEMYjIAUpA4ABIgkgCnwiCiAJVK0gBSkDiAEgC3x8IQsgByACIAUpA2h9IAEgBSkDYCIJVK19IgJ5IAEgCX0iAXlCQH0gAkIAUhunIgZNDQEgBkE/TQ0ACyADUEUNAQwCCyABIANUIgYgAiAEVCACIARRG0UNAiAKIQkMBwsgASADgCECCyABIAOCIQEgCyACIAp8IgkgClStfCELQgAhAgwFCyACIAR9IAatfSECIAEgA30hASALIApCAXwiCVCtfCELDAQLIAIgBEIAIAEgA1ogAiAEWiACIARRGyIGG30gASADQgAgBhsiA1StfSECIAEgA30hASAGrSEJDAMLIAEgASADgCIJIAN+fSEBQgAhAgwCCyABQiCIIgkgAiACIANC/////w+DIgKAIgogA359QiCGhCACgCIEQiCGIAFC/////w+DIAkgAyAEfn1CIIaEIgEgAoAiA4QhCSABIAIgA359IQEgBEIgiCAKhCELQgAhAgwBCyAFQTBqIAMgBEHAACAGayIGEMcjIAVBIGogASACIAYQxyMgBUEQaiADQgAgBSkDICAFKQMwgCIJQgAQqB4gBSAEQgAgCUIAEKgeIAUpAxAhCgJAIAUpAwggBSkDGCINIAUpAwB8IgwgDVStfFAEQCABIApUIgYgAiAMVCACIAxRG0UNAQsgASADfCIBIANUrSACIAR8fCAMfSABIApUrX0hAiAJQgF9IQkgASAKfSEBDAELIAIgDH0gBq19IQIgASAKfSEBCyAAIAE3AxAgACAJNwMAIAAgAjcDGCAAIAs3AwggBUGwAWokAAunCQIHfwN+IwBBsAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBAnQiBSEHAkACQAJAAkACQCAFQTxxIgYEQCAFIAZrQUBrIgcgBUkNAQtBwAAhBiAHQcAAENE0BEACQCAHBEAgB0HAABCtNiIGRQ0BCyAEIAY2AiggBCAHNgIkIARBwAA2AiAgBQRAIAZBACAF/AsACyAEIAg2AjAgBCAFNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhByACKAIAIQIgASgCECEBA0ACQCAEKQNoIgxQRQRAIAQpA3AhCwwBCwNAAn4CQCAEKQNQIgtCA1IEQAJAAkACQCALQgJRDQAgBCALUK1CAYY3A1AgC6dBAXFFDQAgBCAEKQNYNwOQAQwBCyAEKAJgRQ0BIARBiAFqIAUQtiogBCkDiAEhCwsgC0IAUg0CCyAEQgM3A1ALIAQpA0AiC0ICUQ0JIARCADcDQCAEKQNIDAELIAQpA5ABCyEMIAunQQFxRQ0HIAQgBCkDcEJAfSILNwNwIAQgDDcDaCAMUA0ACwsgBCAMQgEgDHoiDYaFNwNoAkACQCACRQRAQYeAgIB4IQMMAQsgBEGIAWogASANpyALp2oiCGotAAAgAm0iCSAHEOoPIAQoAogBIgNBk4CAgHhGDQEgBEGAAWogBEGYAWooAgA2AgAgBCAEKQKQATcDeCAEKAKMASEGCyAEQfgAaiECDAcLIAYgCEECdGogCTYCAAwACwALQcAAIAcQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEHIAIoAgAhBSABKAIQIQlBACEBA0AgBEGgAWohAiAFRQRAQYeAgIB4IQMMAwsgBEFAayABIAlqLQAAIAVtIgogBxDqDyAEKAJAIgNBk4CAgHhHBEAgBEGoAWogBEHQAGooAgA2AgAgBCAEKQJINwOgASAEKAJEIQYMAwsgBiAKNgIAIAZBBGohBiAIIAFBAWoiAUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBSAEKAIsIQMgASAEQcgAaiIGKQIANwMAIAQpAyAhCyAEIAQpAkA3AyAgBEEANgIwIAQgCzcCTCAEQQA2AkggBCADNgJEIAQgBTYCQCAEIAIQ1zsgBCgCACEFQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2ApABIAQgBTYCjAEgBCABNgKIASAEQTRqIgEgBEGIAWoQ5RkgByAEQRhqKQIANwMAIAYgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQyh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAY2AgggACADNgIEIABBKToAACAAIAIpAgA3AgwgAEEUaiACQQhqKAIANgIAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQbABaiQAC6cJAgd/A34jAEGwAWsiBCQAIAFBDGooAgghCCAEQQhqIAEQkjYQ7iUgCEECdCIFIQcCQAJAAkACQAJAIAVBPHEiBgRAIAUgBmtBQGsiByAFSQ0BC0HAACEGIAdBwAAQ0TQEQAJAIAcEQCAHQcAAEK02IgZFDQELIAQgBjYCKCAEIAc2AiQgBEHAADYCICAFBEAgBkEAIAX8CwALIAQgCDYCMCAEIAU2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQUgAy0AACEHIAIoAgAhAiABKAIQIQEDQAJAIAQpA2giDFBFBEAgBCkDcCELDAELA0ACfgJAIAQpA1AiC0IDUgRAAkACQAJAIAtCAlENACAEIAtQrUIBhjcDUCALp0EBcUUNACAEIAQpA1g3A5ABDAELIAQoAmBFDQEgBEGIAWogBRC2KiAEKQOIASELCyALQgBSDQILIARCAzcDUAsgBCkDQCILQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDkAELIQwgC6dBAXFFDQcgBCAEKQNwQkB9Igs3A3AgBCAMNwNoIAxQDQALCyAEIAxCASAMeiINhoU3A2gCQAJAIAJFBEBBh4CAgHghAwwBCyAEQYgBaiABIA2nIAunaiIIaiwAACACbSIJIAcQ6g8gBCgCiAEiA0GTgICAeEYNASAEQYABaiAEQZgBaigCADYCACAEIAQpApABNwN4IAQoAowBIQYLIARB+ABqIQIMBwsgBiAIQQJ0aiAJNgIADAALAAtBwAAgBxCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQcgAigCACEFIAEoAhAhCUEAIQEDQCAEQaABaiECIAVFBEBBh4CAgHghAwwDCyAEQUBrIAEgCWosAAAgBW0iCiAHEOoPIAQoAkAiA0GTgICAeEcEQCAEQagBaiAEQdAAaigCADYCACAEIAQpAkg3A6ABIAQoAkQhBgwDCyAGIAo2AgAgBkEEaiEGIAggAUEBaiIBRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEFIAQoAiwhAyABIARByABqIgYpAgA3AwAgBCkDICELIAQgBCkCQDcDICAEQQA2AjAgBCALNwJMIARBADYCSCAEIAM2AkQgBCAFNgJAIAQgAhDXOyAEKAIAIQVBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCkAEgBCAFNgKMASAEIAE2AogBIARBNGoiASAEQYgBahDlGSAHIARBGGopAgA3AwAgBiAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDKHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgBjYCCCAAIAM2AgQgAEEpOgAAIAAgAikCADcCDCAAQRRqIAJBCGooAgA2AgAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBsAFqJAALoQgBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgI0IAIgAEECdiIATw0LIAQgASgCECACQQJ0aigCADYCMCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBMGogAxDMJCECDAoLIARBMGogAxDTHCECDAkLIAAoAgQoAhQhACAEIAI2AjQgAiAAQQJ2IgBPDQogBigCBCIARQ0CIARBHGogAEEIaiAGKAIIEIoYIAQoAhxBk4CAgHhHDQMgBEFAa0HIrYYBKAIANgIAIARBwK2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUECdiIBTw0HIAQgACgCECACQQJ0aigCACIArDcDCCAEQUBrQcithgEoAgA2AgAgBEHArYYBKQIANwM4IARBOGoiARDJDCAAQf+iBUsNBSAEQQA2AhggBCAANgIUIARBATYCPCAEQfSbhAE2AjggBEIBNwJEIARBlAw2AiAgBCAEQRxqNgJAIAQgBEEUajYCHCADKAIAIAMoAgQgARDLCiECDAYLIARBQGtByK2GASgCADYCACAEQcCthgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEFAa0HIrYYBKAIANgIAIARBwK2GASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRxqEOUQDAMLIARBMGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQUBrQcithgEoAgA2AgAgBEHArYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIAQ2AhwgAygCACADKAIEIAAQywohAgwBCyAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIoIAQgBTYCJCAEQe4GNgIgIAQgBEEcajYCQCAEIARBCGo2AhwgAygCACADKAIEIARBOGoQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AhQMAQsgBCAANgIUCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiggBEE7NgIgIAQgBEEcajYCQCAEIARBFGo2AiQgBCAEQTRqNgIcIARBOGpByJeEARDvLAAL3ggCEX8CfiMAQSBrIgwkACALKAIIIQ8gC0IANwMIAkAgBCAHcSIXIANNBEAgCykDACEeIAAoAjQhGiADIBdrIRIgAiAXaiETAkAgACgCICIURQ0AA0BBECANIA1BEE0bIRUgDyATaiEYIAYgDUECdGohECAPIBdqIARLIRkDQAJAAkAgDSAVRwRAIBAoAgAiFiAJSw0CIAcgFmsiDiAHTyAZcg0CIAQgDnEiDiAPaiIRIARNDQEMAgsgFUEQQbzVzgAQwyEACwJAAkACQAJAAkAgDyASSQRAIAMgEU0NASAYLQAAIAIgEWotAABHDQYgAyAOSQ0CIAIgDmogAyAOayATIBIgCBCyICIQQQJNIBBBAkcgDUEBS3JxDQUgHiAQIA4gBRChLiIOIBoQ8jQiHVoNBSANDQMMBAsgDyASQczVzgAQwyEACyARIANB3NXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQezVzgAQ7ywACyAdIA0Q/zB9IR0LIB0gHlgNACALIBY2AhAgCyAONgIIIAsgHTcDAEEBIRsgDiEPIB0hHgsgDUEBaiINIBRJDQIMAwsgEEEEaiEQIA1BAWoiDSAUSQ0ACwsLAkACQAJAAkACQCATIBIQxiAiBiAAKAIEIg1JBEAgACgCDCIOIAZBBnQiDUkNAiAOIA1rQT9LDQEgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpBgNTOABDvLAALIAYgDUHg084AEMMhAAsgACgCCCANQQJ0aiEVIAAoAgAgBkEBdGoiFi8BACIORQ0FIA5BQGoiBkEAIAYgDk0bIRggDiEGA0AgDyATaiEZIA8gF2ogBEshHANAIAYhDQNAIA0gGE0NCCAHIBUgDUEBayIGQT9xQQJ0aigCACIRayEQAkAgHA0AIAQgEXEiESAPaiIUIARLDQAgDyASTw0FIAMgFE0NBiAZLQAAIAIgFGotAABHDQAgCSAQSQ0JIAMgEUkNByACIBFqIAMgEWsgEyASIAgQ9AEiDUUNAiAeIA0gESAFEKEuIg0gECAaEIwtIh1aDQIgCyAQNgIQIAsgDTYCCCALIB03AwBBASEbIA0hDyAdIR4MAwsgDUEBayENIAkgEE8NAAsLCwwFCyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHw084AEO8sAAsgDyASQfzUzgAQwyEACyAUIANBjNXOABDDIQALIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQZzVzgAQ7ywACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHQ084AEO8sAAsgFSAOQT9xQQJ0aiAHNgIAIBYgFi8BAEEBajsBAAJ/QQEgGw0AGkEAIAFFDQAaIAEgACATIBIgCCAJIAogCxDoFAsgDEEgaiQAC94IAhF/An4jAEEgayIMJAAgCygCCCEPIAtCADcDCAJAIAQgB3EiFyADTQRAIAspAwAhHiAAKAI0IRogAyAXayESIAIgF2ohEwJAIAAoAiAiFEUNAANAQRAgDSANQRBNGyEVIA8gE2ohGCAGIA1BAnRqIRAgDyAXaiAESyEZA0ACQAJAIA0gFUcEQCAQKAIAIhYgCUsNAiAHIBZrIg4gB08gGXINAiAEIA5xIg4gD2oiESAETQ0BDAILIBVBEEG81c4AEMMhAAsCQAJAAkACQAJAIA8gEkkEQCADIBFNDQEgGC0AACACIBFqLQAARw0GIAMgDkkNAiACIA5qIAMgDmsgEyASIAgQsiAiEEECTSAQQQJHIA1BAUtycQ0FIB4gECAOIAUQoS4iDiAaEPI0Ih1aDQUgDQ0DDAQLIA8gEkHM1c4AEMMhAAsgESADQdzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakHs1c4AEO8sAAsgHSANEP8wfSEdCyAdIB5YDQAgCyAWNgIQIAsgDjYCCCALIB03AwBBASEbIA4hDyAdIR4LIA1BAWoiDSAUSQ0CDAMLIBBBBGohECANQQFqIg0gFEkNAAsLCwJAAkACQAJAAkAgEyASEMcgIgYgACgCBCINSQRAIAAoAgwiDiAGQQR0Ig1JDQIgDiANa0EPSw0BIAxBADYCGCAMQQE2AgwgDEGY184ANgIIIAxCBDcCECAMQQhqQYDUzgAQ7ywACyAGIA1B4NPOABDDIQALIAAoAgggDUECdGohFSAAKAIAIAZBAXRqIhYvAQAiDkUNBSAOQRBrIgZBACAGIA5NGyEYIA4hBgNAIA8gE2ohGSAPIBdqIARLIRwDQCAGIQ0DQCANIBhNDQggByAVIA1BAWsiBkEPcUECdGooAgAiEWshEAJAIBwNACAEIBFxIhEgD2oiFCAESw0AIA8gEk8NBSADIBRNDQYgGS0AACACIBRqLQAARw0AIAkgEEkNCSADIBFJDQcgAiARaiADIBFrIBMgEiAIEPQBIg1FDQIgHiANIBEgBRChLiINIBAgGhCMLSIdWg0CIAsgEDYCECALIA02AgggCyAdNwMAQQEhGyANIQ8gHSEeDAMLIA1BAWshDSAJIBBPDQALCwsMBQsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB8NPOABDvLAALIA8gEkH81M4AEMMhAAsgFCADQYzVzgAQwyEACyAMQQA2AhggDEEBNgIMIAxBmNfOADYCCCAMQgQ3AhAgDEEIakGc1c4AEO8sAAsgDEEANgIYIAxBATYCDCAMQZjXzgA2AgggDEIENwIQIAxBCGpB0NPOABDvLAALIBUgDkEPcUECdGogBzYCACAWIBYvAQBBAWo7AQACf0EBIBsNABpBACABRQ0AGiABIAAgEyASIAggCSAKIAsQ6BQLIAxBIGokAAvvFwIOfwJ+IwBB8AFrIgYkACABKAIMIQcCQCABKAIAQYCAgIB4RwRAIAZBxAFqIAEQoB0MAQsgBkGAgICAeDYCxAELIAZB8ABqIAZBzAFqKAIANgIAIAYgBzYCdCAGIAYpAsQBNwNoIAZBxAFqIgcgBkHoAGoQ7w4gBkEYaiIJIAIgAyAHEPkUIAZBADYCFCAGQoCAgIDAADcCDCAFKAIQIQwgBkE4aiAJEIcGAkACQCAGKAI4IglBAkYNACAGQYABaiEDIAZB7ABqIQUgBkHcAWohByAGQcgBaiEKIAZBPGohAgJAA0AgCUEBcQRAIAAgAhCmJQwCCyAGQdgAaiACQQhqKQIANwMAIAZB4ABqIAJBEGooAgAiCTYCACAGIAIpAgA3A1AgBiAJNgJkIAZBxAFqIAQgBkHQAGogDBEBACAGQaABaiILIApBCGopAgA3AwAgBkGoAWoiCCAKQRBqKAIANgIAIAYgCikCADcDmAEgBigCxAEiDUUEQCAAIAZBmAFqEKYlDAILIAMgBykCADcCACADQRBqIAdBEGooAgA2AgAgA0EIaiAHQQhqKQIANwIAIAVBEGogCCgCADYCACAFQQhqIAspAwA3AgAgBSAGKQOYATcCACAGIA02AmggCSAGQegAaiILKAIQRgRAAkAgCxDLOkUEQCAGQcQBaiALQSz8CgAAIAYoAhQiCSAGKAIMRgRAIAZBDGpB8P7MABCiKAsgBigCECAJQSxsaiAGQcQBakEs/AoAACAGIAlBAWo2AhQMAQsgBkHEAWogBkHoAGoQ2icgBigCFCIJIAYoAgxGBEAgBkEMakGA/8wAEKIoCyAGKAIQIAlBLGxqIAZBxAFqQSz8CgAAIAYgCUEBajYCFCAGQegAahDNJgsgBkE4aiAGQRhqEIcGIAYoAjgiCUECRw0BDAMLCyAGIAZB6ABqIgIoAhA2ArABIAZBAjYCyAEgBkHE/8wANgLEASAGQgI3AtABIAZBOzYCwAEgBkE7NgK4ASAGIAZBtAFqNgLMASAGIAZB5ABqNgK8ASAGIAZBsAFqNgK0ASAAQQRqIAZBxAFqEJkOIABBAzYCACACEM0mCyAGQRhqENEbIAZBDGoiABCFHyAAQQRBLBDgHiABKAIAQYCAgIB4Rg0BIAFBBEEIEOAeDAELIAZBGGoiBBDRGyAGKAIQIQIgBigCFCEDQQAhCSMAQbABayIKJAAgCkEANgIMIAMEQCACIQUgAyEHA0AgCSAFKAIQaiEJIAVBLGohBSAHQQFrIgcNAAsLIApCAzcDWCAKQgM3AxAgCiACNgKgASAKIAIgA0EsbGo2AqQBIAogCkEMajYCqAEjAEHgAmsiBSQAIApBEGoiBykDSCEUIAcpAwAhFQJAAkAgBygCkAEiAwRAIAVB+AFqIQIgFUIDUiAUQgNScg0CIAcoApQBIANGDQEMAgsgBUH4AWohAiAVQgNSIBRCA1JyDQELIAVBuAFqIQILQQAhAyACQQA2AgAgBUEYaiILQQBBAEEEQQgQoBggBSgCHCECAkAgBSgCGEEBRwRAIAVBADYCFCAFIAUoAiA2AhAgBSACNgIMIAsgB0GgAfwKAAAgBUHgAGohDSAFQSBqIQ4gBUGAAmohDwNAIAUpAxhCA1EhAgNAAkACQAJAAkACQAJAAkACfwJAIAJFBEAgBUH4AWogBUEYahDjPSAFKAL4AQ0BIAVCAzcDGEEBIQIMCgsCQCAFKAKoASICRQ0AIAIgBSgCrAFGDQAgBSACQSxqNgKoASAFKAKwASIHKAIAIQsgByACKAIQIAcoAgBqNgIAIAUgAhDLOiIHNgLEAiAHDQggBUH4AWogAhDJNCAFIAs2ArgCIAUpA/gBIRRBACICRQRAIAVBuAFqIA9BwAD8CgAACyAUQgNRDQAgBSAUNwMYIA4gBUG4AWpBwAD8CgAADAoLIAUpA2BCA1ENAiAFQfgBaiANEOM9IAUoAvgBQQFHDQIgBSgCoAEiByAFKAKAAmohAiAHIAUoAvwBagwBCyAFKAJYIgcgBSgCgAJqIQIgByAFKAL8AWoLIgcgAkYNCCACIAdrIQsgAyAHSSADIAdLa0H/AXEOAgIDAQsgAyAJRwRAIAUoAhQiAiAFKAIMRgRAIAVBDGpB+P/MABCbKAsgBSgCECACQQN0aiIHQQE6AAQgByAJIANrNgIAIAUgAkEBajYCFAsgBCAFKQIMNwIAIARBCGogBUEUaigCADYCACAFQeACaiQADAkLIAVBADYCiAIgBUEBNgL8ASAFQZSAzQA2AvgBIAVCBDcCgAIgBUH4AWpBnIDNABDvLAALIAUoAhQiA0EDdCEHIAUoAhAhDCADBEAgByAMakEIayIIDQILIAUoAgwgA0YEfyAFQQxqQayAzQAQmyggBSgCEAUgDAsgB2oiB0EAOgAEIAcgCzYCACAFIANBAWo2AhQgAiEDDAULIAUoAhQiDCAFKAIMRgRAIAVBDGpBzIDNABCbKAsgBSgCECAMQQN0aiIIQQE6AAQgCCAHIANrNgIAIAUgDEEBaiIDNgIUIAUoAgwgA0YEQCAFQQxqQdyAzQAQmygLIAUoAhAgA0EDdGoiA0EAOgAEIAMgCzYCACAFIAxBAmo2AhQgAiEDDAQLIAgoAgAiAyALaiIHIANJDQEgCCAHNgIAIAIhAwwDCyAFQQA2AsgCQQAgBUHEAmpB1P/MACAFQcgCakHY/8wAEK8rAAsLC0G8gM0AELI7AAsgAiAFKAIgQej/zAAQ/S8ACyAKQbABaiQAIAEoAgAhAiABQYCAgIB4NgIAAkAgAkGAgICAeEcEQCAGIAEpAgQ3AsgBIAYgAjYCxAEgBkHoAGohEEEAIQ1BACEKQQAhCSMAQTBrIggkACAIQQA2AhQgCEKAgICAwAA3AgwgBCgCBCIMIAQoAghBA3RqIRIgBkHEAWoiEyICKAIEIg4gAigCCEEDdGohEUEDIQJBAyEEAkACQAJAA0BBACEPAkADQAJAAkAgAkH/AXFBAmsOAgMAAQsgDCASRg0CIAwtAAQhAiAMKAIAIQkgDEEIaiEMCyACIQMgCSELAkACQCAEQf8BcUECaw4CBQABCyAOIBFGDQQgDi0ABCEEIA4oAgAhCiAOQQhqIQ4LIAQhBSAKIQdBACEJQQMhAiALRQ0AQQAhCkEDIQQgAyECIAshCSAHRQ0AAkACQCAFQQFxBEAgByEKDAELIAsgCyAHIAcgC0sbIgJrIQkgByACayEKIANBAXFFDQEgBSEEIAIhBwsgByAPaiEPIAMhAgwBCwsgCCgCDCEEIA8EfyAEIA1GBEAgCEEMakHcgc0AEJsoCyAIKAIQIA1BA3RqIgRBAToABCAEIA82AgAgCCANQQFqIg02AhQgCCgCDAUgBAsgDUYEQCAIQQxqQeyBzQAQmygLIAgoAhAgDUEDdGoiBEEAOgAEIAQgAjYCACAIIA1BAWoiDTYCFCADIQIgBSEEDAELCwNAAkACQCAEQf8BcUEDRwRAIAohAiAEIQwMAQsgDiARRg0BIA4tAAQhDCAOKAIAIQIgDkEIaiEOC0EDIQQgAkUNASAMQQFxRQ0DIAIgD2ohDwwBCwsgDwRAIAgoAgwgDUYEQCAIQQxqQfyBzQAQmygLIAgoAhAgDUEDdGoiAkEBOgAEIAIgDzYCACAIIA1BAWo2AhQLIBAgCCkCDDcCACAQQQhqIAhBFGooAgA2AgAgCEEwaiQADAILQZyBzQBBLUHMgc0AEMskAAsgCEEANgIoIAhBATYCHCAIQcSCzQA2AhggCEIENwIgIAhBGGpBzILNABDvLAALIBNBBEEIEOAeIAEoAgBBgICAgHhHBEAgAUEEQQgQ4B4LIAEgBikCaDcCACABQQhqIgIgBkHwAGooAgA2AgAgAEEMaiACKQIANwIAIAAgASkCADcCBCAGQRhqQQRBCBDgHgwBCyABIAYpAhg3AgAgAUEIaiICIAZBIGooAgA2AgAgAEEMaiACKQIANwIAIAAgASkCADcCBAsgAEEINgIAIAZBDGoiABCFHyAAQQRBLBDgHgsgBkHwAWokAAu1CQIKfwF+IwBB8ANrIgMkACADQSRqIgQgASACKAIUEQAAIAMgA0E8aiIGNgKgAyADQfABakGUqNCgATYCACADQpSo0KDBgoWKFDcD6AEgAyADQegBaiIFNgJoAkACQAJAAkACQAJAAkACQCAGIAUQuwgEQCAFEKcMIANBGGogBBDcOyADKAIcIgVBAkkNAiADKAIYIgUoAgwiCSAJKAIAIgZBAWo2AgAgBkEASA0BIAUoAhQhCyAFKAIQIQwgA0EQaiAEENw7IAMoAhRFDQYgA0EIaiADKAIQEMcbIAMoAgghCCADKAIMIgdBA3QiBEE4cSIFBEAgBCAEIAVrQUBrIgRLDQQLQcAAIQUgBEHAABDRNEUNBCAEBEAgBEHAABCtNiIFRQ0GCyADQgA3AnQgAyAFNgJwIAMgBDYCbEHAACEKIANBwAA2AmhBACEGIAcEQCAHQQJ0IQQDQCAINAIAIQ0gCEEEaiEIIAZBCGoiBSADKAJsIgdLBEAgA0HoAGogB0EBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJsIQcgAygCdCIGQQhqIQULIAUgB0sEfyADQegAaiAHQQF0IgYgBRDNKiIFIAUgBkkbEOgZIAMoAnQFIAYLIAMoAnBqIA03AAAgAyADKAJ0QQhqIgY2AnQgAyADKAJ4QQFqNgJ4IARBBGsiBA0ACyADKAJwIQUgAygCaCEKIAMoAmwhBAsgA0HEAmoiBxCXKSADQfAAaiADQcwCaiIIKQIANwMAIAMgAykCxAI3A2ggA0EANgJ4IAMgBDYC1AIgAyAKNgLQAiADQQA2AswCIAMgBjYCyAIgAyAFNgLEAiADIAcQ1zsgAygCACEFQRxBBBCtNiIERQ0HIARCgYCAgBA3AgAgBCADKQLEAjcCCCAEQRBqIAgpAgA3AgAgBEEYaiADQdQCaigCADYCACADIAY2AogBIAMgBTYChAEgAyAENgKAASABIAIoAjARBAAhBCABIAIoAiQRBAAhASADQewCakGWrNiwATYCACADQpas2LDhwoWLFjcC5AIgA0IENwLcAiADQgA3AtQCIANCgICAgMAANwLMAiADQQA2AsQCIANBADsBnAMgAyAENgKYAyADQQA2AoADIANBADYC9AIgAyABNgLwAiADQegBaiIBIAcgA0GAAWoQ+iMgAyALNgKoAyADIAw2AqQDIAMgCTYCoAMgByABIANBoANqEPojIAEgA0HQAGpBACADKAJQGxDuJSADQYwBaiICIAcgARDCGSADQawDaiIBIAIQzRwgByABEIsMQcQAQQQQrTYiAUUNCCABQoGAgIAQNwIAIAFBCGogB0E8/AoAACAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAgA0HoAGoQzy8gA0EkahCAJyADQfADaiQADwsgA0EANgLEAiADQaADaiADQegAaiADQcQCakGY6/8AEKMrCwALQQEgBUGo6/8AEMMhAAtByMD/AEEjQezA/wAQyyQAC0Gswf8AQSkgA0HEAmpBxMj/AEHYwf8AENUeAAtBwAAgBBCjPQALQQBBAEG46/8AEMMhAAtBBEEcEKM9AAtBBEHEABCjPQALtQkCCn8BfiMAQfADayIDJAAgA0EkaiIEIAEgAigCFBEAACADIANBPGoiBjYCoAMgA0HwAWpBmLDgwAE2AgAgA0KYsODAgYOGjBg3A+gBIAMgA0HoAWoiBTYCaAJAAkACQAJAAkACQAJAAkAgBiAFELsIBEAgBRCnDCADQRhqIAQQ3DsgAygCHCIFQQJJDQIgAygCGCIFKAIMIgkgCSgCACIGQQFqNgIAIAZBAEgNASAFKAIUIQsgBSgCECEMIANBEGogBBDcOyADKAIURQ0GIANBCGogAygCEBDHGyADKAIIIQggAygCDCIHQQN0IgRBOHEiBQRAIAQgBCAFa0FAayIESw0EC0HAACEFIARBwAAQ0TRFDQQgBARAIARBwAAQrTYiBUUNBgsgA0IANwJ0IAMgBTYCcCADIAQ2AmxBwAAhCiADQcAANgJoQQAhBiAHBEAgB0ECdCEEA0AgCDQCACENIAhBBGohCCAGQQhqIgUgAygCbCIHSwRAIANB6ABqIAdBAXQiBiAFEM0qIgUgBSAGSRsQ6BkgAygCbCEHIAMoAnQiBkEIaiEFCyAFIAdLBH8gA0HoAGogB0EBdCIGIAUQzSoiBSAFIAZJGxDoGSADKAJ0BSAGCyADKAJwaiANNwAAIAMgAygCdEEIaiIGNgJ0IAMgAygCeEEBajYCeCAEQQRrIgQNAAsgAygCcCEFIAMoAmghCiADKAJsIQQLIANBxAJqIgcQlykgA0HwAGogA0HMAmoiCCkCADcDACADIAMpAsQCNwNoIANBADYCeCADIAQ2AtQCIAMgCjYC0AIgA0EANgLMAiADIAY2AsgCIAMgBTYCxAIgAyAHENc7IAMoAgAhBUEcQQQQrTYiBEUNByAEQoGAgIAQNwIAIAQgAykCxAI3AgggBEEQaiAIKQIANwIAIARBGGogA0HUAmooAgA2AgAgAyAGNgKIASADIAU2AoQBIAMgBDYCgAEgASACKAIwEQQAIQQgASACKAIkEQQAIQEgA0HsAmpBmbLkyAE2AgAgA0KZsuTIkaPGjBk3AuQCIANCBDcC3AIgA0IANwLUAiADQoCAgIDAADcCzAIgA0EANgLEAiADQQA7AZwDIAMgBDYCmAMgA0EANgKAAyADQQA2AvQCIAMgATYC8AIgA0HoAWoiASAHIANBgAFqEPojIAMgCzYCqAMgAyAMNgKkAyADIAk2AqADIAcgASADQaADahD6IyABIANB0ABqQQAgAygCUBsQ7iUgA0GMAWoiAiAHIAEQwhkgA0GsA2oiASACEM0cIAcgARCMDEHEAEEEEK02IgFFDQggAUKBgICAEDcCACABQQhqIAdBPPwKAAAgAEGg7P8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIANB6ABqEM8vIANBJGoQgCcgA0HwA2okAA8LIANBADYCxAIgA0GgA2ogA0HoAGogA0HEAmpBmOv/ABCjKwsAC0EBIAVBqOv/ABDDIQALQcjA/wBBI0HswP8AEMskAAtBrMH/AEEpIANBxAJqQcTI/wBB2MH/ABDVHgALQcAAIAQQoz0AC0EAQQBBuOv/ABDDIQALQQRBHBCjPQALQQRBxAAQoz0AC5YJAQx/IwBBgAJrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIIBEAgBUEgaiAAKAIEENw7IAUoAiQiBiAAKAIoIgdPBEAgASgCCEUNAyAFKAIgIQwgBUEYaiABKAIEENw7IAUoAhwiCCABKAIoIglJDQIgByAMaiENIAYgB2shDiAFKAIYIgogCWohCyAIIAlrIQggACgCLEUNDiAFQRBqIABBLGoiBhDcOyAFQegAaiIPIAUoAhAgBSgCFCAAKAI4IAJqIhAgBBD6EyAFQfQBaiAPENUJAkAgBSgC9AFBAUYEQCAFKAL4AQ0BIAUoAvwBIARHDQEMEAsgBEUNDwsgACgCQLggACgCJLijRJqZmZmZmdk/ZkUEQCAFQQhqIAYQ3DsgBUEoaiIAIAUoAgggBSgCDCAQIAQQ+hMgASgCLEUNBSAFIAFBLGoQ3DsgBUGoAWoiDCAFKAIAIAUoAgQgASgCOCADaiAEEPoTIAVB6ABqIABBwAD8CgAAIAVCADcD6AEDQCAFQfQBaiIAIAVB6ABqENUJAkAgBSgC9AFBAUYEQCAFKAL8ASEBIAUoAvgBIQQgACAMENUJIAUoAvQBDQELQQEhAAwSC0EAIQAgBCAFKAL4AUcNESABIAUoAvwBRw0RIAEgAmoiBiACIARqIgdJDQcgBiAOSw0IIAEgA2oiBiADIARqIglJDQkgBiAISw0KIAcgDWogASAEayIBIAkgC2ogARCfOw0ACwwQCyABKAIsRQ0JAkAgBEUEQEEAIQYMAQtBACEGIAEoAjwiDSADayILQQAgCyANTRshDSAAKAI8IgsgAmsiD0EAIAsgD08bIQsgDCACIAdqaiEHIAEoAjggA2ohDCAKIAMgCWpqIQkgASgCMCEBIAAoAjAhAANAIAYgC0YNDCAGIA1GDQ0CQAJAIAAgBiAQaiIKQQN2ai0AAEEBIApBB3F0cSIKRQ0AIAEgBiAMaiIPQQN2ai0AAEEBIA9BB3F0cUUNACACIAZqIgogDk8NECADIAZqIgogCE8NESAGIAdqQQEgBiAJakEBEJ87DQEMAwsgCg0CCyAEIAZBAWoiBkcNAAsgBCEGCyAEIAZNIQAMDwsgByAGQai9hwEQrzsAC0EAQQBBmL2HARDDIQALIAkgCEHIvYcBEK87AAtBAEEAQbi9hwEQwyEAC0HYvYcBELI7AAsgByAGQfi9hwEQsTsACyAGIA5B+L2HARCwOwALIAkgBkGIvocBELE7AAsgBiAIQYi+hwEQsDsAC0HovYcBELI7AAtB6LyHAUEgQYi9hwEQnykAC0HovIcBQSBBiL2HARCfKQALIApBAWogDkH4vYcBELA7AAsgCkEBaiAIQYi+hwEQsDsACyACIARqIgAgBEkNASAAIA5LDQIgAyAEaiIAIARJDQMgACAISw0EIAIgDWogBCADIAtqIAQQnzshAAsgBUGAAmokACAADwsgAiAAQfi9hwEQsTsACyAAIA5B+L2HARCwOwALIAMgAEGIvocBELE7AAsgACAIQYi+hwEQsDsAC4wIAQp/IwBBEGsiBiQAIAZBCGpCADcDACAGQgA3AwAgAAJ/AkAgAkECSQ0AAkACQAJAAkACQAJAAn8gAS0AAEE6RwRAQQAMAQsgAS0AAUE6Rw0HQQEhCkECCyIDIAJPBEBBAiEDQQEhDCAKIQQMAQsgCiEEQQEhDANAQQggBCAEQQhNGyEJA0AgBEEIRg0IIAEgA2otAABBOkYEQCAKDQlBASEKIARBAWoiBCEMIANBAWoiAyACSQ0CDAMLQQAhByADIQUCQCADIANBBGoiCCACIAIgCEsbIghPDQADQCABIAVqLQAAIgtBwQBrQV9xQQpqIAtBMGsgC0E5SxsiC0EPSw0BIAdBBHQgC3IhByAIIAVBAWoiBUcNAAsgCCEFCwJAIAIgBU0EQCAFIQMMAQsgASAFai0AACIIQTpHBEAgCEEuRyACIANNciADIAVGIARBBktycg0KQQAhCQJAA0AgCUEASgRAIAlBBE8NDSABIANqLQAAQS5HDQ0gA0EBaiEDCyACIANNDQxBACEHAkADQAJAAkAgASADai0AAEEwayILQf8BcSIIQQlNBEAgB0EBcUUNASAFQf//A3FFDREgBUEKbCALQf8BcWoiBUH//wNxQf8BSw0RDAILIAdBAXFFDRAMAwsgCCEFC0EBIQcgAiADQQFqIgNHDQALIAIhAwsgBEEITw0BIAYgBEEBdGoiCCAILwEAQQh0IAVqOwEAAkACQCAJQQFrDgMAAQABCyAEQQFqIQQLIAlBAWohCSACIANLDQALIAlBBEcNCwwFCyAEQQhB7JnEABDDIQALIAVBAWoiAyACRg0JCyAEIAlGDQMgBiAEQQF0aiAHOwEAIARBAWohBCACIANLDQALCwsgAiADSw0FIApFDQEgBCAMRg0EIARBAXQhCCAEQQFrIQogDCAEayEDIAZBDmohBUEAIQcDQCAHQQdqQQdLDQMgByAKakEITw0EIAUvAQAhAiAFIAUgCGpBEGsiAS8BADsBACABIAI7AQAgBUECayEFIAMgB0EBayIHRw0ACwwECyAJQQhBzJnEABDDIQALIARBCEcNAwwCC0F/QQhB3JnEABDDIQALIAQgB2pBAWtBCEHcmcQAEMMhAAsgACAGLwEOIgFBCHQgAUEIdnI7AA8gACAGLwEMIgFBCHQgAUEIdnI7AA0gACAGLwEKIgFBCHQgAUEIdnI7AAsgACAGLwEIIgFBCHQgAUEIdnI7AAkgACAGLwEGIgFBCHQgAUEIdnI7AAcgACAGLwEEIgFBCHQgAUEIdnI7AAUgACAGLwECIgFBCHQgAUEIdnI7AAMgACAGLwEAIgFBCHQgAUEIdnI7AAFBAAwBCyAAQQQ6AAFBAQs6AAAgBkEQaiQAC8oJAQZ/IwBB8ABrIgIkACACQdgAaiABEPAnIAJByABqIgQgAkHkAGoiBSgCADYCACACIAIpAlw3A0ACQCACKAJYIgZBBEcEQCACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAY2AgQgAEGAgICAeDYCACAAQRBqIAQoAgA2AgAMAQsgAkEwaiAEKAIANgIAIAIgAikDQDcDKCACQShqEIYwIAJBgICAgHg2AgggAkGAgICAeDYCGCACQdgAaiABENMJIAQgBSkCADcDACACQdAAaiIGIAJB7ABqKAIANgIAIAIgAikCXDcDQAJAAkAgAigCWEUEQCACQdwAaiEEA0AgAkE4aiAGKAIAIgM2AgAgAkEwaiACQcgAaiIFKQMANwMAIAIgAikDQDcDKAJAAkACQCADQf8BcQRAIAJB2ABqIAJBKGoQ/BcgAi8BXCEDIAIoAlgiB0EERwRAIAAgAikBXjcBCiAAQRBqIAJB5ABqKQEANwEAIAAgAzsBCCAAIAc2AgQgAEGAgICAeDYCAAwHCwJAAkACQCADQQFrDgIAAQILIAJB2ABqIAEQwhUgBSAEQQhqKAIANgIAIAIgBCkCADcDQCACKAJYIgNBBEYNAyACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAM2AgQgAEGAgICAeDYCACAAQRBqIAJByABqKAIANgIADAgLIAJB2ABqIAEQwhUgBSAEQQhqKAIANgIAIAIgBCkCADcDQCACKAJYIgNBBEcEQCACKAJoIQEgACACKQNANwIIIAAgATYCFCAAIAM2AgQgAEGAgICAeDYCACAAQRBqIAJByABqKAIANgIADAgLIAJB4ABqIgMgBSgCADYCACACIAIpA0A3A1ggAkEYahCGMCACQSBqIAMoAgA2AgAgAiACKQNYNwMYDAQLIAJB2ABqIAEgAi0AOEHAABDJAiACKAJYIgNBBEYNAyAAIAIpAlw3AgggAEEQaiACQeQAaikCADcCACAAQYCAgIB4NgIAIAAgAzYCBAwGCyACQShqEIYwIAJB2ABqIAEQqCkgAigCWCIBQQRHBEAgACACKQJcNwIIIABBEGogAkHkAGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQMBwsgAkHYAGpB8YvQAEEMIAJBCGoQ9R0gAigCWCIBQQRHBEAgACACKQJcNwIIIABBEGogAkHkAGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQMBwsgAigCCCIBQYCAgIB4Rg0BIAAgAikDGDcCDCAAIAIpAgw3AgQgACABNgIAIABBFGogAkEgaigCADYCAAwHCyACQeAAaiIDIAUoAgA2AgAgAiACKQNANwNYIAJBCGoQhjAgAkEQaiADKAIANgIAIAIgAikDWDcDCAwBC0H4/M8AQccAQYCM0AAQyyQACyACQShqEIYwIAJB2ABqIAEQ0wkgBSAEQQhqKQIANwMAIAYgBEEQaigCADYCACACIAQpAgA3A0AgAigCWEUNAAsLIAAgAikDQDcCBCAAQYCAgIB4NgIAIABBFGogBigCADYCACAAQQxqIAJByABqKQMANwIADAELIAJBKGoQhjALIAJBGGoQhjAgAkEIahCGMAsgAkHwAGokAAuFCAEZf0ECIRMgBgRAQQEgACgCzAEiBiAGQQFNG0EBaiETCyAAKALAASEOIAAoAlwhC0EAIAIoAgAiFiAWIAMgAyAAKAIEIgogACgCDCIGIAMgCmsgBGoiCUEBIAAoArgBdCIIayAGIAkgBmsgCEsbIAAoAhgiBxsiGGoiG0ZqIgAgCmsiCSAGIAkgCGsgBiAJIAZrIAhLGyAHG2siBksiGRshCEEAIAIoAgQiGiAGIBpJIhwbIQkgCkECaiEdIAMgBGoiEUEIayEUA0ACQAJAIBQgACATaiISQQFqIg9LBEAgACAOIAUQox0hDCAAQQFqIg0gDiAFEKMdIRUgCyAMQQJ0aigCACEGQQAgCGshHiAAQYABaiEXIBMhBANAIA8hECASIgcgHmoiEigAACEfIAsgDEECdGogACAKayIPNgIAAn8CQAJAIAgEQCAHKAAAIB9GDQELAkACQAJAAkAgBiAYSQ0AIAAoAAAgBiAKaigAAEcNACANIQcgFSEMIAAhDQwBCyALIBVBAnRqIgAoAgAhBiAHIA4gBRCjHSEMIAAgDSAKayIPNgIAIAYgGEkNAiANKAAAIAYgCmooAABHDQIgBEEFTw0BCyALIAxBAnRqIAcgCms2AgALIA0gBiAKaiIGayIEQQNqIQxBACEAA0AgACAGaiIJIhAgG00gACANaiIHIANNcg0HIAdBAWstAAAgCUEBay0AAEcNByAAQQFrIQAMAAsACyALIAxBAnRqKAIAIQYgECAOIAUQox0hFSAEIAdqIhIgF08NASAEDAILIBJBAWstAAAhACAHQQFrLQAAIQQgCyAVQQJ0aiANIAprNgIAQQVBBCAAIARGIgQbIQAgEiAEayEQIAcgBGshB0EBIQwgCCEEIAkhCAwFCyAXQYABaiEXIARBAWoLIAQgEGohDyEEIBAhDSAHIQAgDyAUSQ0ACwsgAiAIIBZBACAZGyAIGzYCACACIAkgFiAaQQAgHBsiACAIGyAAIBkbIAkbNgIEIBEgA2sPC0EEIABrIQALIAghBiABIAcgA2sgAyARIAwgACAHaiAAIBBqIBEQgBQgAGoiABCFEiAEIQggBiEJIAAgB2oiACEDIAAgFEsNACALIA8gHWogDiAFEKMdQQJ0aiAPQQJqNgIAIAsgAEECayIDIA4gBRCjHUECdGogAyAKazYCAEEAIQkgACEDIAZFDQADQAJAIAQhCCAAIBRLDQAgACgAACAAIAZrKAAARw0AIABBBGoiAyADIAZrIBEQgBQhAyALIAAgDiAFEKMdQQJ0aiAAIAprNgIAIAFBACAAIBFBASADQQRqIgMQhRIgACADaiEAIAYhBCAIIQYMAQsLIAYhCSAAIQMMAAsAC6MJAQl/IwBBMGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkEDcQRAIAQgAjYCKCAEQQM2AiRBhICAgHghCUEEIQdBgICAgHghA0G85P4AIQJBACEBDAELQX8gAkEEaiIDIAIgA0sbIgMgASgCBCIGTQRAIAEgASgCFEEEaiIDNgIUIAMgASgCCCgCCE0NAkGIgICAeCEJDAELIARBDGogAiADEL8vIAQoAgwiCUGKgICAeEYNASAEKAIgIQIgBCgCHCEDIAQoAhghCiAEKAIUIQcgBCgCECEBCyAEQQhqIARBLGooAgA2AgAgBCAEKQIkNwMADAELIAIgBk8NAiACQQFyIgMgBk8NAyACQQJyIgUgBk8NBCACQQNyIgcgBk8NBQJ/IAEoAgAiCCADai0AAEEIdCACIAhqLQAAciAFIAhqLQAAQRB0ciAHIAhqLQAAQRh0ciIDQQBMBEAgAiADayIFIAJPDAELIAIgA2shBSACIANPC0GGgICAeCEJQQQhB0EAIAUgBkkbDQFBACEBCyAAIAI2AhQgACADNgIQIAAgCjYCDCAAIAc2AgggACABNgIEIAAgCTYCACAAIAQpAwA3AhggAEEgaiAEQQhqKAIANgIADAkLIAVBAXEEQCAEIAU2AiggBEEDNgIkIARBs+T+ADYCICAEQoCAgICAgICAgH83AhggBEKAgICAwAA3AhBBhICAgHghA0EAIQIMCAsCQCAGQX8gBUECaiIDIAMgBUkbIgNPBEAgASABKAIUQQJqIgM2AhQgAyABKAIIKAIITQ0BQYiAgIB4IQMMCQsgBEEMaiAFIAMQvy8gBCgCDCIDQYqAgIB4Rg0AIAQvARAhAgwICyAFQQFyIgMgBk8NBUF/IAUgBSAIai0AACADIAhqLQAAQQh0ciIIaiIDIAMgBUkbIgNBAXEEQCAAIAM2AhwgAEEDNgIYIABBs+T+ADYCFCAAQYCAgIB4NgIQIABCBDcCCCAAQoSAgIAINwIADAkLAkAgAyAGTQRAIAEgASgCFCAIaiIGNgIUQYiAgIB4IQMgBiABKAIIIgcoAghNDQEMCAsgBEEMaiAFIAMQvy8gBCgCDCIDQYqAgIB4Rw0HIAEoAgghBwsgASABKAIQQQFqIgM2AhAgAyAHKAIESw0EIAEgASgCDEEBaiIDNgIMIAcoAgAgA08EQCAAIAg2AhAgACAFNgIMIAAgAjYCCCAAIAE2AgQgAEGKgICAeDYCAAwJCyAAQYmAgIB4NgIADAgLIAIgBkGw4v4AEMMhAAsgAyAGQcDi/gAQwyEACyAFIAZB0OL+ABDDIQALIAcgBkHg4v4AEMMhAAsgAEGHgICAeDYCAAwDCyADIAZB8OL+ABDDIQALIAAgBCkCEDcCBCAAQRxqIARBKGopAgA3AgAgAEEUaiAEQSBqKQIANwIAIABBDGogBEEYaikCADcCACAAIAM2AgAMAQsgACAEKQESNwEGIABBHGogBEEoaikBADcBACAAQRZqIARBImopAQA3AQAgAEEOaiAEQRpqKQEANwEAIAAgAjsBBCAAIAM2AgALIARBMGokAAujCQEJfyMAQTBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAJBA3EEQCAEIAI2AiggBEEDNgIkQYSAgIB4IQlBBCEHQYCAgIB4IQNBzPb+ACECQQAhAQwBC0F/IAJBBGoiAyACIANLGyIDIAEoAgQiBk0EQCABIAEoAhRBBGoiAzYCFCADIAEoAggoAghNDQJBiICAgHghCQwBCyAEQQxqIAIgAxC/LyAEKAIMIglBioCAgHhGDQEgBCgCICECIAQoAhwhAyAEKAIYIQogBCgCFCEHIAQoAhAhAQsgBEEIaiAEQSxqKAIANgIAIAQgBCkCJDcDAAwBCyACIAZPDQIgAkEBciIDIAZPDQMgAkECciIFIAZPDQQgAkEDciIHIAZPDQUCfyABKAIAIgggA2otAABBCHQgAiAIai0AAHIgBSAIai0AAEEQdHIgByAIai0AAEEYdHIiA0EATARAIAIgA2siBSACTwwBCyACIANrIQUgAiADTwtBhoCAgHghCUEEIQdBACAFIAZJGw0BQQAhAQsgACACNgIUIAAgAzYCECAAIAo2AgwgACAHNgIIIAAgATYCBCAAIAk2AgAgACAEKQMANwIYIABBIGogBEEIaigCADYCAAwJCyAFQQFxBEAgBCAFNgIoIARBAzYCJCAEQcP2/gA2AiAgBEKAgICAgICAgIB/NwIYIARCgICAgMAANwIQQYSAgIB4IQNBACECDAgLAkAgBkF/IAVBAmoiAyADIAVJGyIDTwRAIAEgASgCFEECaiIDNgIUIAMgASgCCCgCCE0NAUGIgICAeCEDDAkLIARBDGogBSADEL8vIAQoAgwiA0GKgICAeEYNACAELwEQIQIMCAsgBUEBciIDIAZPDQVBfyAFIAUgCGotAAAgAyAIai0AAEEIdHIiCGoiAyADIAVJGyIDQQFxBEAgACADNgIcIABBAzYCGCAAQcP2/gA2AhQgAEGAgICAeDYCECAAQgQ3AgggAEKEgICACDcCAAwJCwJAIAMgBk0EQCABIAEoAhQgCGoiBjYCFEGIgICAeCEDIAYgASgCCCIHKAIITQ0BDAgLIARBDGogBSADEL8vIAQoAgwiA0GKgICAeEcNByABKAIIIQcLIAEgASgCEEEBaiIDNgIQIAMgBygCBEsNBCABIAEoAgxBAWoiAzYCDCAHKAIAIANPBEAgACAINgIQIAAgBTYCDCAAIAI2AgggACABNgIEIABBioCAgHg2AgAMCQsgAEGJgICAeDYCAAwICyACIAZBxPX+ABDDIQALIAMgBkHU9f4AEMMhAAsgBSAGQeT1/gAQwyEACyAHIAZB9PX+ABDDIQALIABBh4CAgHg2AgAMAwsgAyAGQYT2/gAQwyEACyAAIAQpAhA3AgQgAEEcaiAEQShqKQIANwIAIABBFGogBEEgaikCADcCACAAQQxqIARBGGopAgA3AgAgACADNgIADAELIAAgBCkBEjcBBiAAQRxqIARBKGopAQA3AQAgAEEWaiAEQSJqKQEANwEAIABBDmogBEEaaikBADcBACAAIAI7AQQgACADNgIACyAEQTBqJAAL0AgBCH8CQCABQYAKSQRAIAFBBXYhBwJAAkAgACgCoAEiBQRAIAVBAWshAyAFQQJ0IABqQQRrIQIgBSAHakECdCAAakEEayEGIAVBKUkhBQNAIAVFDQIgAyAHaiIEQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRrIQIgA0EBayIDQX9HDQALCyABQSBJDQMgAEEANgIAIAdBAWoiAkECRg0DIABBADYCBCACQQNGDQMgAEEANgIIIAJBBEYNAyAAQQA2AgwgAkEFRg0DIABBADYCECACQQZGDQMgAEEANgIUIAJBB0YNAyAAQQA2AhggAkEIRg0DIABBADYCHCACQQlGDQMgAEEANgIgIAJBCkYNAyAAQQA2AiQgAkELRg0DIABBADYCKCACQQxGDQMgAEEANgIsIAJBDUYNAyAAQQA2AjAgAkEORg0DIABBADYCNCACQQ9GDQMgAEEANgI4IAJBEEYNAyAAQQA2AjwgAkERRg0DIABBADYCQCACQRJGDQMgAEEANgJEIAJBE0YNAyAAQQA2AkggAkEURg0DIABBADYCTCACQRVGDQMgAEEANgJQIAJBFkYNAyAAQQA2AlQgAkEXRg0DIABBADYCWCACQRhGDQMgAEEANgJcIAJBGUYNAyAAQQA2AmAgAkEaRg0DIABBADYCZCACQRtGDQMgAEEANgJoIAJBHEYNAyAAQQA2AmwgAkEdRg0DIABBADYCcCACQR5GDQMgAEEANgJ0IAJBH0YNAyAAQQA2AnggAkEgRg0DIABBADYCfCACQSFGDQMgAEEANgKAASACQSJGDQMgAEEANgKEASACQSNGDQMgAEEANgKIASACQSRGDQMgAEEANgKMASACQSVGDQMgAEEANgKQASACQSZGDQMgAEEANgKUASACQSdGDQMgAEEANgKYASACQShGDQMgAEEANgKcASACQSlGDQNBKEEoQZCMigEQwyEACyADQShBkIyKARDDIQALIARBKEGQjIoBEMMhAAtBuoyKAUEdQZCMigEQnykACyAAKAKgASIDIAdqIQIgAUEfcSIGRQRAIAAgAjYCoAEgAA8LAkAgAkEBayIEQSdNBEAgAiEFIAAgBEECdGooAgBBACABayIBdiIERQ0BIAJBJ00EQCAAIAJBAnRqIAQ2AgAgAkEBaiEFDAILIAJBKEGQjIoBEMMhAAsgBEEoQZCMigEQwyEACwJAIAdBAWoiCCACTw0AIAFBH3EhASADQQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2AgALIANBAkYNACACQQJ0IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2AgAgBCAJIAZ0IAMoAgAgAXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIAIAZ0NgIAIAAgBTYCoAEgAAu0DAACQAJAAkACQCAHQQFrDgMBAgMACwJAAkACQCAGQQFrDgIBAgALAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQAQ9QgPCyAAIAEgAiADQQVBABD1CA8LIAAgASACIANBBkEAEPUIDwsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBABDqAg8LIAAgASACIANBBUEAEOoCDwsgACABIAIgA0EGQQAQ6gIPCwJAAkACQCAEQQVrDgIBAgALAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EEQQBBBBCGBQ8LIAAgASACIANBBEEAQQUQhgUPCyAAIAEgAiADQQRBAEEGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQVBAEEEEIYFDwsgACABIAIgA0EFQQBBBRCGBQ8LIAAgASACIANBBUEAQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBkEAQQQQhgUPCyAAIAEgAiADQQZBAEEFEIYFDwsgACABIAIgA0EGQQBBBhCGBQ8LAkACQAJAIAZBAWsOAgECAAsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBARD1CA8LIAAgASACIANBBUEBEPUIDwsgACABIAIgA0EGQQEQ9QgPCwJAAkACQCAEQQVrDgIBAgALIAAgASACIANBBEEBEOoCDwsgACABIAIgA0EFQQEQ6gIPCyAAIAEgAiADQQZBARDqAg8LAkACQAJAIARBBWsOAgECAAsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQRBAUEEEIYFDwsgACABIAIgA0EEQQFBBRCGBQ8LIAAgASACIANBBEEBQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBUEBQQQQhgUPCyAAIAEgAiADQQVBAUEFEIYFDwsgACABIAIgA0EFQQFBBhCGBQ8LAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EGQQFBBBCGBQ8LIAAgASACIANBBkEBQQUQhgUPCyAAIAEgAiADQQZBAUEGEIYFDwsCQAJAAkAgBkEBaw4CAQIACwJAAkACQCAEQQVrDgIBAgALIAAgASACIANBBEECEPUIDwsgACABIAIgA0EFQQIQ9QgPCyAAIAEgAiADQQZBAhD1CA8LAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQIQ6gIPCyAAIAEgAiADQQVBAhDqAg8LIAAgASACIANBBkECEOoCDwsCQAJAAkAgBEEFaw4CAQIACwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBEECQQQQhgUPCyAAIAEgAiADQQRBAkEFEIYFDwsgACABIAIgA0EEQQJBBhCGBQ8LAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EFQQJBBBCGBQ8LIAAgASACIANBBUECQQUQhgUPCyAAIAEgAiADQQVBAkEGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQZBAkEEEIYFDwsgACABIAIgA0EGQQJBBRCGBQ8LIAAgASACIANBBkECQQYQhgUPCwJAAkACQCAGQQFrDgIBAgALAkACQAJAIARBBWsOAgECAAsgACABIAIgA0EEQQMQ9QgPCyAAIAEgAiADQQVBAxD1CA8LIAAgASACIANBBkEDEPUIDwsCQAJAAkAgBEEFaw4CAQIACyAAIAEgAiADQQRBAxDqAg8LIAAgASACIANBBUEDEOoCDwsgACABIAIgA0EGQQMQ6gIPCwJAAkACQCAEQQVrDgIBAgALAkACQAJAIAVBBWsOAgECAAsgACABIAIgA0EEQQNBBBCGBQ8LIAAgASACIANBBEEDQQUQhgUPCyAAIAEgAiADQQRBA0EGEIYFDwsCQAJAAkAgBUEFaw4CAQIACyAAIAEgAiADQQVBA0EEEIYFDwsgACABIAIgA0EFQQNBBRCGBQ8LIAAgASACIANBBUEDQQYQhgUPCwJAAkACQCAFQQVrDgIBAgALIAAgASACIANBBkEDQQQQhgUPCyAAIAEgAiADQQZBA0EFEIYFDwsgACABIAIgA0EGQQNBBhCGBQvKCQEKfyMAQYADayICJAAgAUEYaiEGAkACQAJAAkACQAJAAkACQCABLQAYQSdGBEAgAkEwaiABENw7IAIoAjRBAUcNASACQShqIAEQ7zwgAigCLEEBRw0CIAJBGGogARDvPCACKAIcRQ0EIAJB6AJqIAIoAhgiA0EYahDUBiADKAIoIQcgAygCJCEIIAJB9AJqIAMQvhUgAkGwAWogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQQgAygCQCEFIAMoAjwhCSADKAI4IQogAygCNCELIAMoAjAhAwsgAkHYAGogAkHwAmooAgA2AgAgAkFAayACQfwCaigCADYCACACQcwAaiACQbgBaigCADYCACACIAIpAugCNwNQIAIgBzYCYCACIAg2AlwgAiACKQL0AjcDOCACIAIpArABNwJEIAIgBTYCeCACIAk2AnQgAiAKNgJwIAIgCzYCbCACIAM2AmggAiAENgJkIAItAFBBIEcNBSACQRBqIAJB1ABqIgMQwzQgAigCFEECRwRAIAJBCGogAxDDNCACQTs2AvgCIAJBAjYCtAEgAkGA34UBNgKwASACQgE3ArwBIAIgAigCDDYC6AIgAiACQegCajYC9AIgAiACQfQCajYCuAEMBwsgAkGwAWoiAyACQThqQcQA/AoAACACQfwAaiADEIYXIAJB+AFqIAEQshggAkG4AmogBhDUBgJAIAEoAiwiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNBSACIAM2AtACIAIgASgCQDYC5AIgAiABKQI4NwLcAiACIAEpAjA3AtQCDAELIAJBADYC0AILIAJBhAJqIgQgAkH8AGpBNPwKAAAgAkHMAmogAkGAAmooAgA2AgAgAiACKQL4ATcCxAIgAigChAIgARCJJ0GAgICAeEYNCCAAIARB5AD8CgAAIAJBgANqJAAPCyACQQE2ArQBIAJBnOGFATYCsAEgAkIBNwK8ASACQacENgI8IAIgBjYC9AIgAiACQThqNgK4ASACIAJB9AJqNgI4IAJBjAJqIAJBsAFqEJkOIAJBjYCAgHg2AogCDAYLIAJBATYCtAEgAkHg4IUBNgKwASACQgE3ArwBIAJBOzYCPCACIAEoAiQ2AvQCIAIgAkE4ajYCuAEgAiACQfQCajYCOCACQYwCaiACQbABahCZDiACQY2AgIB4NgKIAgwFCyACQSBqIAEQ7zwgAkE7NgI8IAJBATYCtAEgAkGQ4IUBNgKwASACQgE3ArwBIAIgAigCJDYC9AIgAiACQfQCajYCOCACIAJBOGo2ArgBIAJBjAJqIAJBsAFqEJkOIAJBjYCAgHg2AogCDAQLAAtBAEEAQazehQEQwyEACyACQQE2ArQBIAJBxN+FATYCsAEgAkIBNwK8ASACQa8DNgL4AiACIAJB0ABqNgLoAiACIAJB9AJqNgK4ASACIAJB6AJqNgL0AgsgAkGMAmogAkGwAWoQmQ4gAkGNgICAeDYCiAIgAkE4ahCJJwsgARCJJwsgAkHAAWogAkGYAmooAgA2AgAgAkG4AWogAkGQAmopAgA3AwAgAiACKQKIAjcDsAFB3N2FAUE+IAJBsAFqQZzPhQFBnN6FARDVHgALrQgBC38jAEHgAGsiBiQAAkAgA0EhSQRAIAIhCSAAKAIIIAAoAhhrQQN0IAAoAhwiBWsiBCACIANsTw0BIAMEQCAEIANuIQkMAgtBmLfOABDiKwALQci2zgBBMEGIt84AEJ8pAAtBACEEAkACQAJAAkACQAJAAkAgBUUgCUVyDQAgASEFA0AgBkEQaiAAIAMQjw0gBigCEEEBcUUNAyACIARGDQIgBSAGKAIUNgIAIARBAWoiBCAJTw0BIAVBBGohBSAAKAIcDQALCyAJIARrIgpBIEkEQCAEIQUMBgsgA0ECdCEMIAAoAggiDSAAKAIYIgdrIQggASAEQQJ0aiELIAAoAgQhDgNAIARBX0sNAyAEQSBqIgUgAksNBCAHIA1LDQUgByAOaiAIIAsgAxDYCyAAIAcgDGoiBzYCGCAIIAxrIQggC0GAAWohCyAFIQQgCkEgayIKQR9LDQALDAULIAIgAkGYus4AEMMhAAtB/LjOAEEaQYi6zgAQyyQACyAEIARBIGpBrLjOABCxOwALIARBIGogAkGsuM4AELA7AAsgByANQby4zgAQrzsACwJAIApBD00gA0EQS3INACAGQTBqIgpCADcDACAGQShqIgtCADcDAEEIIQQgBkEgaiIMQgA3AwAgBkIANwMYIAAoAggiCCAAKAIYIgdPBEAgACgCBCAHaiAIIAdrIAZBGGogAxDIECAAIAcgA0EBdGo2AhggBkHYAGogCikDADcCACAGQdAAaiALKQMANwIAIAZByABqIAwpAwA3AgAgBiAGKQMYNwJAIAUgAiACIAVJGyEIIAEgBUECdGohBwNAIAUgCEcEQCAHIAZBOGogBGovAQA2AgAgB0EEaiEHIAVBAWohBSAEQQJqIgRBKEcNAQwDCwsgCCACQci5zgAQwyEACyAHIAhB3LjOABCvOwALAkAgCSAFa0EHTSADQQhLcg0AIAZCADcDGCAAKAIIIgcgACgCGCIETwRAIAAoAgQgBGogByAEayAGQRhqIAMQtBYgACADIARqNgIYIAYgBikDGDcCQCABIAVBAnRqIQcgBSAFIAIgAiAFSRsiCGshCiAGQQg2AjxBACEEAkADQCAEIApqRQ0BIAcgBCAGakFAay0AADYCACAHQQRqIQcgBEEBaiIEQQhHDQALIAZBCDYCOCAEIAVqIQUMAgsgCCACQbi5zgAQwyEACyAEIAdB7LjOABCvOwALAkACQCAFIAlJBEAgCSAFayEIIAEgBUECdGohByAFIAIgAiAFSRsiASAFayEEA0AgBkEIaiAAIAMQjw0gBigCCEEBcUUNAyAERQ0CIAcgBigCDDYCACAEQQFrIQQgB0EEaiEHIAhBAWsiCA0ACwsgBkHgAGokACAJDwsgASACQai5zgAQwyEAC0H8uM4AQRpBmLnOABDLJAALuQ4BEX8jAEGgAWsiAyQAIAMgAjYCGCADQQA2AhwgA0EANgIgQcAAIQUCQAJAAkACQAJAAkAgASgCDCABKAIEayIHQQZ2IAdBOHFBAEdqIgRBwP//P3FBQGsgBCAEQT9xGyIEQcAAENE0BEAgBARAIARBwAAQrTYiBUUNAgsgA0EANgIwIAMgBTYCLCADIAQ2AiggA0HAADYCJCAHQQN2IAJsIgRBP3EiAgRAIAQgBCACa0FAayIESw0DCyAEQcAAENE0RQ0GQcAAIQIgBARAIARBwAAQrTYiAkUNBAsgA0EANgJAIAMgAjYCPCADIAQ2AjggA0HAADYCNCADIANBNGoiETYCmAEgAyADQRxqNgKUASADIANBGGo2ApABIAMgA0EkaiISNgKMASADIANBIGo2AogBIANB8ABqIQsgA0GIAWohBiMAQdAAayICJABBk4CAgHghDgJAIAEoAgQiBSABKAIMIghGDQAgBigCECEEIAYoAgwhDCAGKAIIIQ8gBigCBCEHIAYoAgAhEANAIAUoAgQhBiAFKAIAIQogASAFQQhqIg02AgQgECAQKAIAIgUEfyAFBSAHKAIMIgVBAWoiCSAHKAIEIhNLBH8gByATQQF0IgUgCRDVKiIJIAUgCUsbEOgZIAcoAgwFIAULIAcoAghqQQA6AAAgByAHKAIMQQFqNgIMQQgLQQFrNgIAIA8oAgAhBQJAAn8CQCAKBEAgBSAGRg0BIAIgBjYCPCACQQI2AiggAkHI94MBNgIkIAJCAjcCMCACQTs2AkwgAkGcAzYCRCACIA82AkAgAiACQUBrNgIsIAIgAkE8ajYCSCACQRRqIAJBJGoQmQ4gC0EMaiACQRxqKQIANwIAIAsgAikCFDcCBEGNgICAeCEODAULAkAgBCgCDCIGIAVqIgogBk0NACAEKAIEIgkgCkkEQCAEIAlBAXQiBiAKENUqIgkgBiAJSxsQ6BkgBCgCDCEGCyAFRQ0AIAQoAgggBmpBACAF/AsACyAEIAo2AgwgDQwBCyACQQhqIAcQhj0gDCgCACIIQQN2IgUgAigCDCINTw0BIAIoAgggBWoiBSAFLQAAQQEgCEEHcXRyOgAAIAQoAgwiBSAGaiIIIAQoAgQiDUsEQCAEIA1BAXQiBSAIENUqIgggBSAISxsQ6BkgBCgCDCEFCyAGBEAgBCgCCCAFaiAKIAb8CgAACyAEIAQoAgwgBmo2AgwgASgCDCEIIAEoAgQLIQUgDCAMKAIAQQFqNgIAIAUgCEcNAQwCCwsgBSANQYz4gwEQwyEACyALIA42AgAgAkHQAGokAAJAIAMoAnAiAkGTgICAeEcEQCAAIAMpAnQ3AgggAEEQaiADQfwAaikCADcCACAAQSk6AAAgACACNgIEIBEQzy8gEhDPLwwBCyADKAIsIQIgAygCMCEEIAMgAykCJDcClAEgA0EANgKQASADIAQ2AowBIAMgAjYCiAEgA0EQaiADQYgBaiIFENc7IAMoAhAhB0EcQQQQrTYiAkUNBSACQoGAgIAQNwIAIAIgAykCiAE3AgggAkEQaiADQZABaikCADcCACACQRhqIANBmAFqKAIANgIAIAMgBDYCeCADIAc2AnQgAyACNgJwIANBxABqIgIgA0HwAGpBACADKAIcEPIVIAUgAhDhJyADQfgAaiIHIANBlAFqIgYpAgA3AwAgA0GAAWoiCyADQZwBaiIMKAIANgIAIAMgAykCjAE3A3BBACEEAkAgAygCiAEiAkUNACAGIAcpAwA3AgAgDCALKAIAIgQ2AgAgAyACNgKIASADIAMpA3A3AowBIARFBEAgAiACKAIAIgJBAWs2AgBBACEEIAJBAUcNASAFEPseDAELIANB6ABqIANBgAFqKAIANgIAIANB4ABqIANB+ABqKQMANwMAIAMgAykDcDcDWCACIQQLIAMoAhghByADKAI8IQIgAygCQCEFIAMgAykCNDcClAEgA0EANgKQASADIAU2AowBIAMgAjYCiAEgA0EIaiADQYgBahDXOyADKAIIIQZBHEEEEK02IgJFDQYgAkKBgICAEDcCACACIAMpAogBNwIIIAJBEGogA0GQAWopAgA3AgAgAkEYaiADQZgBaigCADYCACAAIAMpA1g3AhwgAEEkaiADQeAAaikDADcCACAAQSxqIANB6ABqKAIANgIAIAAgAygCGDYCNCAAIAMoAhw2AjAgACAENgIYIAAgBTYCFCAAIAY2AhAgACACNgIMIAAgBzYCBCAAQRU6AAALIwBBEGsiACQAIAAgASgCADYCDCAAIAEoAgg2AgggAEEIakEEQQgQ4B4gAEEQaiQAIANBoAFqJAAPCwwFC0HAACAEEKM9AAtB/PyDAUEjQaD9gwEQyyQAC0HAACAEEKM9AAtBBEEcEKM9AAtBBEEcEKM9AAtBsP2DAUEpIANBiAFqQfz9gwFB3P2DARDVHgALg0YCHX8DfiMAQdAAayIPJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBUEBcQRAIAQgBCgCCCIZIAZqEI4tIAQoAggiDCAZSQ0BIAMiB0EISQ0HIAQoAgQgGWohEiACIQggByEKIAwgGWsiDiELA0AgCkEDTQ0DIApBB00NBCAHQQhrIg0gCCgABCIHQRh0IAdBgP4DcUEIdHIgB0EIdkGA/gNxIAdBGHZyciIMSQ0FAkACQCAIKAAAIgdBGHQgB0GA/gNxQQh0ciAHQQh2QYD+A3EgB0EYdnJyIgkgDk0EQCAKQQhrIgogDEkNCSAPQQA2AjggDyALNgI0IA8gEjYCMCAPQSRqIAhBCGoiCCAMIA9BMGoQhAQgDygCJEEERg0CQQxBBBCtNiIHDQFBBEEMEKM9AAsgD0EQakGM3NAAQSoQyhoMDAsgByAPKQIkNwIAIAdBCGogD0EsaigCADYCACAPQYza0AA2AjggDyAHNgI0IA9BBTYCMEEYQQgQrTYiB0UEQEEIQRgQoz0ACyAHIA9BMGoiCCkDADcDACAHQRBqIAhBEGopAwA3AwAgB0EIaiAIQQhqKQMANwMAIA9BCGoiCEGw880ANgIEIAggBzYCACAPQRBqQSggDygCCCAPKAIMEMkpDAsLAkAgCSAPKAIoRgRAIAkgEGohECANIAxrIgcgDEsNAQwKCyAPQRBqQfDb0ABBHBDKGgwLCyAJIAtLDQcgCSASaiESIAsgCWshCyAOIAlrIQ4gCiAMayEKIAggDGohCCAHQQdLDQALDAgLIA9BMGpBMkEAQQFBARCgGCAPKAI0IQIgDygCMEEBRg0LIA8oAjgiAUHX3NAAQTL8CgAAIABBMjYCDCAAIAE2AgggACACNgIEIABBADYCAAwKCyAZIAxBnN3QABCvOwALQQQgCkGU29AAELA7AAtBCCAKQaTb0AAQsDsACyAPQRBqQbbc0ABBIRDKGgwECyAMIApBtNvQABCwOwALIAkgC0Hg29AAEK87AAsgB0UNAgsgD0EQakHE29AAQRoQyhoLIA8tABBBBEYEQCAPKAIUIRAMAQsgAS0AAEUEQCAPIA8pAxA3AxggACAPQRhqEIErDAILIAQgGRD0NCAPQTBqISBBACEBIwBBkCFrIgkkACAJQShqENMmIAlB/ABqQgA3AgAgCUGEAWpBADYCACAJIAM2AiQgCSACNgIgIAlCADcCdCAJQQE2AnAgCUIANwNoIAlCgICAgBA3A2AgCUIANwNYIAlCAjcDACAJQYgBakEAQYAg/AsAAkACQAJAA0ACQCAJQYghaiEbIAlBiAFqISIjAEEQayIcJAACQANAAkACQAJAAkAgCSgChAEiCCAJKAKAASIHTQRAIBxBCGohEiMAQRBrIh0kAAJAAkAgCSkDAEICUg0AIB1BCGohFEEAIQ1CACEmQgAhJUEAIRojAEGgAWsiDCQAIAxBF2pBADYAACAMQRBqQgA3AwAgDEIANwMIQQQgCSgCJCIIIAhBBE8bIQsgCSgCICEOAkACQAJAAkACQAJAAkACQCAIQQFHBEAgCwRAIAxBCGogDiAL/AoAAAsgCSAIIAtrIgo2AiQgCSALIA5qIgc2AiACQAJAIAsOBQQAAAABAAsgCEEESQ0CQQQgC2siCARAIAxBCGogC2ogByAI/AoAAAsgCSAKIAhrIgo2AiQgCSAOQQRqIgc2AiALIAwoAghBgsKwwgFHDQQgCiEIDAcLIAwgDi0AADoACEEBIAtrIQoLQQAhCCAJQQA2AiQgCSALIA5qIApqIgc2AiBBqKHQACkDACIkQv8Bg0IEUg0BIAwoAghBgsKwwgFGDQUgDEEIakEEciEIQQAhEEEAIQoMAwsgFEEEOgAAIBRBADYCBAwFCyAUICQ3AgAMBAtBAyAKIApBA08bIRAgCkEBRwRAIAxBCGpBBHIhCAwBCyAJQQEgEGsiFzYCJCAJIAcgEGoiEzYCICAMIActAAA6AAxBASEKDAELIBAEQCAIIAcgEPwKAAALIAkgCiAQayIXNgIkIAkgByAQaiITNgIgIAoNACAUQQQ6AAAgFEEANgIEDAILIAcgEGohByAQQQNzIgsgF00EQCAMIBBqQQxqIQ4gFyALayEIIAcgC2ohBwJAIApBAkcEQCALRQ0BIA4gEyAL/AoAAAwBCyAOIBMtAAA6AAALIAkgCDYCJCAJIAc2AiAMAQtBACEIIAlBADYCJCAJIAcgF2oiBzYCIEGoodAAKQMAIiRC/wGDQgRRDQAgFCAkNwIADAELIAxBIGoiCgJ/IAoCf0EEIAxBCGoiCygAACIKQYLCsMIBRg0AGkEIIApBcHFB0NS0wgFGDQAaQQUgCkGExLTCAUcNARpBD0EHIAstAAQiCkEIcRsgCkECdEEEcWoLNgIEQQ8LOgAAIAwtACAiCkEPRwRAIAxBgAFqIAxBMGopAwA3AwAgDCAMLQAjOgBzIAwgDC8AITsAcSAMIAwpAyg3A3ggDCAMKAIkNgJ0IAwgCjoAcCAUIAxB8ABqEIspDAELAkACQCAMKAIkIhFBBGsOBAEAAAEACwJAIBFBB08EQCARQRNLDQEgEUEHayIKIAhNBEAgCCAKayEIIAcgCmohCwJAIApBAUcEQCAKRQ0BIAxBCGpBB3IgByAK/AoAAAwBCyAMIActAAA6AA8LIAkgCDYCJCAJIAs2AiAMAwsgCUEANgIkIAkgByAIajYCIEGoodAAKQMAIiRC/wGDQgRRDQIgFCAkNwIADAMLQQcgEUG0yNAAELE7AAsgEUETQbTI0AAQsDsACyAMQfAAaiEOIAxBCGohB0EAIRcjAEEwayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCARQQNNBEBBqMfRACkDACIkQv8Bg0IEUQ0BIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADA0LIAcoAAAiCkGCwrDCAUYNBSARQQRrIRAgB0EEaiEIIApBcHFB0NS0wgFGDQEgCkGExLTCAUYNAgsgDkICNwMAIA5BBToACAwLCyAQQQRJDQEgCCgAACEIDAILIBBBAU0EQEGox9EAKQMAIiRC/wGDQgRRDQQgCyAkNwMAIA5BCGogCxCHFiAOQgI3AwAMCgsgBy0ABCIYQcABcSINQcAARw0DIActAAUiCiAYQQJxckGPAXFFBEAgCkEEdkEHcSIeQQNNBEAgDiAeOgAJIA5BAzoACCAOQgI3AwAMCwsgEUEGayENAkACQAJAAn8CQAJAAkACQCAYQQhxBH8gDUEISQ0BIBFBDmshDSAHKQAGISZCASElIAdBDmoFIAdBBmoLIQcgGEEBcQ0BQQAMBAtBqMfRACkDACIkQv8Bg0IEUg0OQgEhJSAYQQFxDQFBfyETQQAhDQwGCyANQQNLDQFBqMfRACkDACEkCyAkQv8Bg0IEUg0CQX8hE0EBIRdBACENDAQLIA1BBGshDSAHKAAAIRogB0EEaiEHQQELIRcgDUUNAUEAIA1rIRMgBy0AACENDAILIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADAwLQQAhDUF/IRNBqMfRACkDACIkQv8Bg0IEUg0KCyALENMmIBEgE2oiB0EESQ0FIAcgEUsNBiAHQQRrIQogC0EcaiEfAkACQAJAIAsoAixFBEAgCiEHDAELIAsoAiwiB0ERTw0BIApBECAHayIQIAogEEkbIhAEQCAHIB9qIAggEPwKAAALIAsgCygCLCAQaiIHQQAgB0EQRyITGzYCLCAKIBBrIQcgCCAQaiEIIBMNACALIAsoAgAgCygCHEH3lK+veGxqQQ13QbHz3fF5bDYCACALIAsoAgQgCygCIEH3lK+veGxqQQ13QbHz3fF5bDYCBCALIAsoAgggCygCJEH3lK+veGxqQQ13QbHz3fF5bDYCCCALIAsoAgwgCygCKEH3lK+veGxqQQ13QbHz3fF5bDYCDAsgB0EQTwRAIAsoAgwhEyALKAIIIRAgCygCBCEWIAsoAgAhFQNAIAgoAABB95Svr3hsIBVqQQ13QbHz3fF5bCEVIAhBDGooAABB95Svr3hsIBNqQQ13QbHz3fF5bCETIAhBCGooAABB95Svr3hsIBBqQQ13QbHz3fF5bCEQIAhBBGooAABB95Svr3hsIBZqQQ13QbHz3fF5bCEWIAhBEGohCCAHQRBrIgdBD0sNAAsgCyATNgIMIAsgEDYCCCALIBY2AgQgCyAVNgIACyAHBEAgBwRAIB8gCCAH/AoAAAsgCyAHNgIsCyALIAspAxAgCq18NwMQDAELIAdBEEHgyNEAEK87AAsgDUH/AXECfiALKQMQISQgCygCGCEKIAtBHGohCCALKAIsIgdBEUkEQAJ/ICRCEFoEQCALKAIEQQd3IAsoAgBBAXdqIAsoAghBDHdqIAsoAgxBEndqDAELIApBsc/ZsgFqCyAkp2ohECAHQQRPBEADQCAIKAAAQb3cypV8bCAQakERd0Gv1tO+AmwhECAIQQRqIQggB0EEayIHQQNLDQALCyAHBEADQCAILQAAENQ9QbHP2bIBbCAQakELd0Gx893xeWwhECAIQQFqIQggB0EBayIHDQALCyAQQQ92IBBzQfeUr694bCIHQQ12IAdzQb3cypV8bCIHQRB2IAdzrQwBCyAHQRBB8MjRABCwOwALp0EIdkH/AXFGBEAgDiAeOgAcIA5BADoAGyAOIBo2AhQgDiAXNgIQIA4gJjcDCCAOICU3AwAgDiAYQQJ2QQFxOgAaIA4gGEEEdkEBcToAGSAOIBhBf3NBBXZBAXE6ABgMCwsgDkICNwMAIA5BCToACAwKCyAOQgI3AwAgDkEGOgAIDAkLQQAhCEGox9EAKQMAIiRC/wGDQgRSDQYLIA4gCDYCDCAOQQw6AAggDkICNwMADAcLIA5BCDoAHCAOQYCAgAg2AhggDkEANgIQIA5CADcDAAwGCyAOIA06AAkgDkEEOgAIIA5CAjcDAAwFC0EEIAdBmMzRABCxOwALIAcgEUGYzNEAELA7AAsgCyAkNwMAQejH0QBBKyALQZTI0QBBiMzRABDVHgALIAsgJDcDACAOQQhqIAsQhxYgDkICNwMADAELIAsgJDcDACAOQQhqIAsQhxYgDkICNwMACyALQTBqJAAgDEHIAGoiByAMQYABaiIKKQMANwMAIAxB0ABqIgggDEGIAWopAwA3AwAgDCAMKQN4NwNAIAwpA3AiJEICUQRAIAogCCkDADcDACAMQfgAaiAHKQMANwMAIAwgDCkDQDcDcCAUIA4QiykMAQsgDEHoAGoiCiAIKQMAIiY3AwAgDEHgAGoiCCAHKQMAIiU3AwAgDEEwaiAlNwMAIAxBOGogJjcDACAMIAwpA0AiJjcDWCAMICQ3AyAgDCAmNwMoICWnRQRAIAxBPGoQ6CkhByAJQQA2AnQgCUEANgJoIAwtADghCyAJQeAAaiAHQcTI0AAQ5zUgCUHsAGogB0EBdEGAgARqIAcgCxtB1MjQABDnNSAJICQ3AwAgCSAMKQNYNwMIIAlBEGogCCkDADcDACAJQRhqIAopAwA3AwAgDEHwAGoiBxDTJiAJQShqIAdBMPwKAAAgCUEANgKEASAJQgA3AnwgCUIANwNYIBQgETYCBCAUQQQ6AAAMAQsgDEENOgBwIBQgDEHwAGoQiykLIAxBoAFqJAACQCAdLQAIQQRGBEAgHSgCDCEIDAELIB0pAwgiJEL/AYNCBFEEQCAkQiCIpyEIDAELIBIgJDcCAAwCCyAIDQAgEkEEOgAAIBJBADYCBAwBC0EAIQtBACEOIwBBQGoiDSQAAkACQCAJKQMAQgJSBEAgCUEcahDoKSEKIAktABhFBEAgCUIANwOAAQwDCyAJKAJsIAkoAoABIgggCmpJDQEgCCAJKAJ8IgdqIghBgIAETQ0CIAkgByAIQYCABGsiCCAHIAcgCEsbIgdrNgJ8IAkgCSgCeCAHajYCeAwCC0G0x9AAELI7AAsgCUEANgKEASAJQoCABDcCfCAJIAhBgIAEazYCeAsgDUEANgIMIAkoAiAhBwJAAkACQCAJKAIkIghBBE8EQCAJIAhBBGs2AiQgCSAHQQRqNgIgIA0gBygAADYCDAwBCyAJQQA2AiQgCSAHIAhqNgIgQaih0AApAwAiJEL/AYNCBFINAQsgDUEQaiEHIwBBEGsiDCQAAkAgDUEMaigAACIIRQRAIAdBDzoAACAHQQI2AgQMAQsgCEEATgRAIAcgCDYCCCAHQQA2AgQgB0EPOgAADAELIAdBATYCBCAHQQ86AAAgByAIQf////8HcTYCCAsgDEEQaiQAIA0tABAiB0EPRwRAIA1BPGogDUEkaigCADYCACANIA0tABM6ACsgDSANLwAROwApIA0gDSkCHDcCNCANIA0pAhQ3AiwgDSAHOgAoIBIgDUEoahCLKQwCCyANKAIYIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA0oAhRBAWsOAgECAAsCQAJAAkACQAJAIAcgCk0EQCAJKAJoIgggB0kEQCAJQeAAaiAHEI4tIAkoAmghCAsgByAISw0IIAkoAiAhCCAJKAIkIgwgB0kNASAJKAJkIREgDCAHayELIAcgCGohECAHQQFGDQIgB0UNAyARIAggB/wKAAAMAwsgDUEIOgAoIBIgDUEoahCLKQwZCyAJQQA2AiQgCSAIIAxqIgg2AiBBqKHQACkDACIkQv8Bg0IEUQ0CIBIgJDcCAAwYCyARIAgtAAA6AAALIAkgCzYCJCAJIBA2AiAgCS0AGQ0BDAwLIAktABlBAUcNCyAJIAg2AiAMCgsgC0EETwRAIAkgC0EEazYCJCAJIBBBBGo2AiAgECgAACELDAoLQQAhCyAJQQA2AiQgCSAIIAxqNgIgQaih0AApAwAiJEL/AYNCBFENCSASICQ3AgAMFAsCQAJAAkACQAJAIAcgCk0EQCAJQewAaiEMIAkoAoABIgsgB2oiCCAJKAJ0IgpLBEAgDCAIEI4tIAkoAnQhCgsgCCALSQ0IIAggCksNCSAJKAIgIQogCSgCJCIOIAdJDQEgCSgCcCALaiEQIA4gB2shCCAHIApqIQsgB0EBRg0CIAdFDQMgECAKIAf8CgAADAMLIA1BCDoAKCASIA1BKGoQiykMGAsgCUEANgIkIAkgCiAOaiIINgIgQaih0AApAwAiJEL/AYNCBFENAiASICQ3AgAMFwsgECAKLQAAOgAACyAJIAg2AiQgCSALNgIgIAktABlFDQwgCEEESQ0BIAkgCEEEazYCJCAJIAtBBGo2AiAgCygAACEIDAkLIAktABlBAUcNCyAJIAg2AiBBACEIDAgLQQAhCCAJQQA2AiQgCSAKIA5qNgIgQaih0AApAwAiJEL/AYNCBFENByASICQ3AgAMEwsgCSgCAARAIAkpA1giJCAJKQMIIiVSDQQLIAktABpFDQUgCSgCICEHIAkoAiQiCkEETwRAIAkgCkEEazYCJCAJIAdBBGo2AiAgBygAACEIDAULQQAhCCAJQQA2AiQgCSAHIApqNgIgQaih0AApAwAiJEL/AYNCBFENBCASICQ3AgAMEgsgByAIQfTI0AAQsDsACyALIAhB9MjQABCxOwALIAggCkH0yNAAELA7AAsgDSAkNwM4IA0gJTcDMCANQQ46ACggEiANQShqEIspDA4LIAggCUEoahC0EqdGDQAgDUELOgAoIBIgDUEoahCLKQwNCyASQQA2AgQgCUICNwMAIBJBBDoAAAwMCwJAAkAgCSgCgAEiCiILIAcgCmoiCk0EQCAKIAwoAggiDksNASAMKAIEIQwgDSAKIAtrNgIEIA0gCyAMajYCAAwCCyALIApBlMjQABCxOwALIAogDkGUyNAAELA7AAsgDUEoaiANKAIAIA0oAgQgCBCkJCANLQAoQQRGDQIgDSkDKCIkQv8Bg0IEUQ0CIBIgJDcCAAwLCyAJKAJoIgggB08EQCANQShqIAkoAmQgByALEKQkIA0tAChBBEYNASANKQMoIiRC/wGDQgRRDQEgEiAkNwIADAsLIAcgCEHEx9AAELA7AAsCQAJAIAktABgEQCAJKAJ8IhQNAQsgByAJKAJoIghLDQMgCSgCZCEOIAlB7ABqIgwgCSgCgAEiCCAKahCOLSAMKAIIIgsgCEkEQCAIIAtBxMbQABCwOwALIAwoAgQhDCANQShqIgogCDYCCCAKIAs2AgQgCiAMNgIAIA1BEGogDiAHIAoQhAQMAQsgCSgCdCIKIAkoAngiCEkNAyAUIAogCGsiCksNBCAHIAkoAmgiCksNBSAJKAKAASIKIAhLDQYgCSgCcCEMIAkoAmQhCyANIAo2AjAgDSAINgIsIA0gDDYCKCANQRBqIREgDUEoaiETIAggDGohHkEAIRACQAJAAkAgBwRAIAcgC2oiF0ETIAcgB0ETTxtrIR8gEygCACIYIBMoAgQiB0EzayIIQQAgByAITxtqISEgEygCBCAYaiEaIBMoAgggEygCAGoiIyEKDAELDAELA0ACQCALLQAAIghBD3EiFUEPRiAIQe8BS3IgHyALQQFqIgdJIAogIU9ycg0AA0AgCiAHKQAANwAAIApBCGogB0EIaikAADcAACAVQQRqIQwCQAJAIAogCEEEdkEPcSILaiIIIBhrIhUgFGoiCiAHIAtqIhYvAAAiByAHIApLGyIKIBVLBEAgFCAIIBRqIAogGGprIhVrIgsgDCALIAxJGyIHBEAgCCAVIB5qIAf8CgAACyAHIAhqIQggCyAMTw0BIAwgB2shDAsgCCAMaiELIAhBACAKayIVaiEHAn8CQCAKIAxJBEAgCEEAOgAAIAxBAkkNASAIIQcDQCAHIAcgFWoiCC0AADoAACAHQQFqIAhBAWotAAA6AAAgB0EDaiAHQQJqIgghByALSQ0ACyAIIBVqIQcgCEEBagwCCyAHQQhqKQAAISQgBykAACElIAhBEGogB0EQai8AADsAACAIQQhqICQ3AAAgCCAlNwAAIAshCgwDCyAIQQFqCyEKIAggC08NACAIIActAAA6AAAMAQsgCCEKCyAWLQACIghBD3EiFUEPRiAIQe8BS3IgHyAWQQNqIgdJcg0BIAogIUkNAAsLAkACfwJAAkACQAJAAkACQAJAIAhBEE8EQAJAIAhBBHYiC0EPRwRAIAchDAwBC0EAIQgDQCAHIBdPDQMgCCAHLQAAIgtqIQggB0EBaiIMIQcgC0H/AUYNAAsgCEEPaiELIAghEAsgCyAXIAxrSw0CIAsgGiAKa0sNAwJAAkACQCALQQRPBEAgC0EISQ0BIAtBEUkNAiAKIAtBcHFqIRYgCiEHIAwhCANAIAcgCCkAADcAACAHQQhqIAhBCGopAAA3AAAgCEEQaiEIIAdBEGoiByAWSQ0ACyAKIAtBEGsiB2oiCCAHIAxqIgcpAAA3AAAgCEEIaiAHQQhqKQAANwAADAMLIAogDC0AADoAACALQQJJDQIgCiAMLwAAOwAAIAogC0ECayIHaiAHIAxqLwAAOwAADAILIAogDCgAADYAACAKIAtBBGsiB2ogByAMaigAADYAAAwBCyAKIAwpAAA3AAAgCiALQQhrIgdqIAcgDGopAAA3AAALIAogC2ohCiALIAxqIQcLIAcgF08NAwJAAkAgFyAHa0ECTwRAIAdBAmohCCAHLwAAIRYgFUEEaiIMQRNGDQEgCCELDAILDAwLQQAhBwNAIAggF08NBiAHIAgtAAAiDGohByAIQQFqIgshCCAMQf8BRg0ACyAHQRNqIQwgByEOCyAKIBhrIgcgFGogFkkNBSAaIAprIgggDEkEQCARQQA2AgAgESATKAIENgIIIBEgByAMajYCBAwMCwJAIAcgFkkEQCAUIAogFGogFiAYamsiFWsiCCAMIAggDEkbIgcEQCAKIBUgHmogB/wKAAALIAcgCmohCiAIIAxPDQEgDCAHayEMIBogCmshCAsgCiEHQQAgFmshFSAMQQ9qIgogFksgCCAKSXJFBEAgByAMaiEKA0AgByAHIBVqIggpAAA3AAAgB0EIaiAIQQhqKQAANwAAIAdBEGoiByAKSQ0ACwwKCyAHQQA6AAAgByAMaiEWIAxBAkkNByAHIQgDQCAIIAggFWoiBy0AADoAACAIQQFqIAdBAWotAAA6AAAgCEEDaiAIQQJqIgchCCAWSQ0ACyAHQQFqIQogByAVagwICyALIBdJDQkMCgsgESAQNgIEDAkLIBFBATYCAAwJCyARQQA2AgAgESATKAIENgIIIBEgCiAYayALajYCBAwICyARQQQ2AgAgESAKICNrNgIEIBMgCiAYazYCCAwHCyARIA42AgQMBQsgEUEDNgIADAULIAdBAWohCiAHIBVqCyEIIAcgFk8EQCAHIQoMAQsgByAILQAAOgAACyALIBdJDQALIBFBAjYCAAwBCyARQQI2AgALCyANKAIQIgdBBEcEQCANIA0pAhQ3AzAgDSAHNgIsIA1BAToAKCASIA1BKGoQiykMCgsgDSgCFCEHCyAJIAkoAoQBIAdqIgg2AoQBIAkgCSkDWCAHrXw3A1ggCSgCgAEhByAJLQAaBEAgByAISw0GIAggCSgCdCIKSw0HIAlBKGogCSgCcCAHaiAIIAdrEN0LIAkoAoQBIQggCSgCgAEhBwsgEkEEOgAAIBIgCCAHazYCBAwICyAHIAhB1MfQABCwOwALIA1BADYCOCANQQE2AiwgDUH4oNAANgIoIA1CBDcCMCANQShqQeTH0AAQ7ywACyAUIApB9MfQABCwOwALIAcgCkGEyNAAELA7AAsgCiAIQcTG0AAQsDsACyAHIAhBpMjQABCxOwALIAggCkGkyNAAELA7AAsgDSAkNwMoICRCIIinIQcCQAJAAn8CQAJAICSnQf8BcUEBaw4DAAEBAwsgJEIIiKcMAQsgBy0ACAtB/wFxQSVGDQELIBIgJDcCAAwBCyASQQQ6AAAgEkEANgIEIA1BKGoQuS4LIA1BQGskAAsgHUEQaiQAIBwtAAhBBEYEQCAcKAIMIQgMBQsgHCkDCCIkQv8Bg0IEUg0BICRCIIinIQgMBAtBgCAgCCAHayIIIAhBgCBLGyIIIAdqIgogCEkNASAKIAkoAnQiDEsNAiAIBEAgIiAJKAJwIAdqIAj8CgAACyAbIAg2AgQgCSAKNgKAASAbQQQ6AAAMBQsgGyAkNwIADAQLIAcgCkGUxtAAELE7AAsgCiAMQZTG0AAQsDsACyAIDQALIBtBBDoAACAbQQA2AgQLIBxBEGokAAJ/IAktAIghQQRGBEAgCSgCjCEMAQsgCSkDiCEiJEL/AYNCBFINASAkQiCIpwsiB0UEQCAgQQg2AgAgICABNgIEDAMLIAdBgSBPDQMgBCAJQYgBaiAHEKE2IAEgB2ohAQwBCwsgCSAkNwOIISAgIAlBiCFqEIErCyAJQeAAahDeOyAJQewAahDeOyAJQZAhaiQADAELIAdBgCBBrILOABCwOwALAkAgDygCMCIBQQhGBEAgACAPKAI0NgIEIABBCDYCAAwBCyAEIBkQ9DQgACAPIAIgAyAEIAUgBhC/DQJAAkACQAJAAkAgAQ4GAAECAwUEBQsgD0EwakEEchDeOwwECyAPQTBqQQRyEN47DAMLIA9BMGpBBHIQ3jsMAgsgD0EwakEEchDeOwwBCyAPQTBqQQRyELwqCyAPQRBqELkuDAELIAYgEEYEQCAAQQg2AgAgACAGNgIEDAELIA9BMGpBNkEAQQFBARCgGCAPKAI0IQIgDygCMEEBRwRAIA8oAjgiAUGs3dAAQTb8CgAAIABBNjYCDCAAIAE2AgggACACNgIEIABBADYCAAwBCwwBCyAPQdAAaiQADwsgAiAPKAI4QaTG0AAQ/S8AC/s0Agx/AX4jAEHwBWsiByQAIAcgAkGIAfwKAAAgB0GoA2ohCyMAQfACayICJAAgAiAHKAKAASIGNgIIIAIgB0EBIAcpAwAiD6dBCWsgD0IIWBsiCEECdEGYls8AaigCAGooAggiAzYCDAJAIAZBAE4EQAJAAkACQAJAIANBAE4EQCAIQQFrDgICAwELIAJBATYCFCACQaSPzwA2AhAgAkIBNwIcIAJBOzYCnAIgAiACQZgCajYCGCACIAJBDGo2ApgCIAtBDGogAkEQahCZDiALQgQ3AwAgC0EANgIIDAULIAcoAnAhCCAHLQB0IAIgAzYCjAIgAiAGNgKIAiACQQA2AoQCIAJBADYC8AEgAkEAOgCQAiACQgM3AxAgAkEDOgCAAiACQgM3A3ggBy0AdSEGIActAHYhAyACQZgCaiAHQQhqQQAgBykDCEIIUhsQtwhBAnRBpJbPAGooAgAhBCADQQJ0QaSWzwBqKAIAIQMgBkECdEGkls8AaigCACEGIAIpAxBCA1IEQCACQRBqEPErCyACQRBqIAJBmAJqQdgA/AoAACACIAM2AnQgAiAGNgJwIAIgBDYCbCACIAg2AmgMAgsgBygCaCEIIActAH0gAiADNgKMAiACIAY2AogCIAJBAzYChAIgAkEANgLwASACQQA6AJACIAJCAzcDECACQQM6AIACIAJCAzcDeCAHKAJsIQMgBygCcCEKIAcoAnQhBSAHKAJ4IQkgBy0AfCENIAJBmAJqIAdBACAPQghSGxC3CEECdEGkls8AaigCACEEIAJB+ABqIQYgAikDeEIDUgRAIAYQ8SsLIAYgAkGYAmpB2AD8CgAAIAIgDToA6AEgAiAJNgLkASACIAU2AuABIAIgBDYC3AEgAiAKNgLYASACIAM2AtQBIAIgCDYC0AEMAQsgBy0AHCEIIAcoAhghBCACIAM2AowCIAIgBjYCiAIgAkEANgLwASACQQA6AJACIAJCAzcDECACQgM3A3ggAiAENgL4ASACIActAB06AIACIAJBAjYChAIgAiAIQQJ0QaSWzwBqKAIANgL8AQsgCyACQRBqQYgC/AoAAAwBCyACQQE2AhQgAkHQj88ANgIQIAJCATcCHCACQTs2ApwCIAIgAkGYAmo2AhggAiACQQhqNgKYAiALQQxqIAJBEGoQmQ4gC0IENwMAIAtBADYCCAsgAkHwAmokACAHQZgDaiICIAdBuANqKQMANwMAIAdBoANqIgYgB0HAA2opAwA3AwAgByAHKQOwAzcDkAMgB0EIaiELAkACQAJAIAcpA6gDIg9CBFEEQCAAIAcpA5ADNwMAIABBBDoAHCAAQRBqIAYpAwA3AwAgAEEIaiACKQMANwMADAELIAdBqAFqIAdByANqQegB/AoAACAHQZgBaiAHQZgDaikDADcDACAHQaABaiAHQaADaikDADcDACAHIA83A4gBIAcgBykDkAM3A5ABIAdBqANqIgJBgAhBAEEBQQEQoBggBygCrAMhBiAHKAKoA0EBRg0BIAdBADYCyAUgByAHKAKwAzYCxAUgByAGNgLABSAHQoCAgICQgICAgH83ArADIAdCgICAgCA3AqgDIAdBADsBzAMgByAHQcAFaiINNgLIAyAHQcwFaiEIIAdBiAFqIg4hCiMAQUBqIgYkACAGQQxqQeyK0ABBChCAICAGQSxqIAIQ8icCQCAGKAIsIgNBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggAzYCAAwBCyAGQSxqIgNB9orQAEEEQQZBARDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC9AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAGQSxqIgNB+orQAEEWQQZBAhDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC+AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAGQSxqIgNBkIvQAEEUQQZBAxDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAELIAZBLGoiAxCGMCADIAIgCigC/AEQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAQsgAhDTISAKKALgAUEBRgRAIAooAuQBIQQgBkEsaiIDQaSL0ABBA0EGQQQQ6BwgBkEYaiACIAMQsBQgBigCGCIFQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAU2AgAgAxCGMAwCCyAGQSxqIgMQhjAgAyACIAQQsBsgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgCikDAEIDUgRAIAZBLGoiA0Gni9AAQRBBCkEFEOgcIAZBGGogAiADELAUIAYoAhgiBEEERwRAIAggBikCHDcCBCAIQQxqIAZBJGopAgA3AgAgCCAENgIAIAMQhjAMAgsgBkEsaiIEEIYwIwBBQGoiAyQAIANBDGpB/ITQAEEOEIAgIANBLGogAhDyJwJAIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIANBLGoiBUGKhdAAQQpBBkEBEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJYELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQZSF0ABBCEEGQQIQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAlwQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISADQSxqIgVBnIXQAEEZQQZBAxDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCYBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUG1hdAAQRlBBkEEEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJkELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgCikDAEICUgRAIANBLGoiBUHOhdAAQQpBCkEFEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAgsgA0EsaiIFEIYwIAUgCiACEJYDIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAILIAIQ0yELIANBLGogAhCrKSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyAEIAIQ6igLIANBDGoQ3jsgA0FAayQAIAYoAiwiA0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCADNgIADAILIAIQ0yELIAotAIACBEAgBkEsaiIDQbeL0ABBEUEKQQYQ6BwgBkEYaiACIAMQsBQgBigCGCIEQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAQ2AgAgAxCGMAwCCyAGQSxqIgQQhjAjAEEgayIDJAAgA0HYhdAAQQ8QgCAgA0EMaiACEPInAkAgAygCDCIFQQRHBEAgBCADKQIQNwIEIARBDGogA0EYaikCADcCACAEIAU2AgAMAQsgA0EMaiACEKspIAMoAgwiBUEERwRAIAQgAykCEDcCBCAEQQxqIANBGGopAgA3AgAgBCAFNgIADAELIAQgAhDqKAsgAxDeOyADQSBqJAAgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgCi0A8AFBA0cEQCAGQSxqIgNByIvQAEEWQQpBBxDoHCAGQRhqIAIgAxCwFCAGKAIYIgRBBEcEQCAIIAYpAhw3AgQgCEEMaiAGQSRqKQIANwIAIAggBDYCACADEIYwDAILIAZBLGoiBBCGMCAKQegBaiEFIwBBQGoiAyQAIANBDGpBxIbQAEEUEIAgIANBLGogAhDyJwJAIAMoAiwiCUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAJNgIADAELIANBLGoiCUGKhdAAQQpBBkEBEOgcIANBGGogAiAJELAUIAMoAhgiDEEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAMNgIAIAkQhjAMAQsgA0EsaiIJEIYwIAkgAiAFKAIAELAbIAMoAiwiCUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAJNgIADAELIAIQ0yEgA0EsaiIJQZSF0ABBCEEGQQIQ6BwgA0EYaiACIAkQsBQgAygCGCIMQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAw2AgAgCRCGMAwBCyADQSxqIgkQhjAgCSACIAUoAgQQsBsgAygCLCIJQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAk2AgAMAQsgAhDTISAFLQAIIglBAkcEQCADQSxqIgVB2IbQAEEJQQJBAxDoHCADQRhqIAIgBRCwFCADKAIYIgxBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgDDYCACAFEIYwDAILIANBLGoiBRCGMCAFIAIgCUEBcRDGFSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwCCyACENMhCyADQSxqIAIQqykgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgBCACEOooCyADQQxqEN47IANBQGskACAGKAIsIgNBBEcEQCAIIAYpAjA3AgQgCEEMaiAGQThqKQIANwIAIAggAzYCAAwCCyACENMhCyAKKQNoQgNSBEAgBkEsaiIDQd6L0ABBE0EKQQgQ6BwgBkEYaiACIAMQsBQgBigCGCIEQQRHBEAgCCAGKQIcNwIEIAhBDGogBkEkaikCADcCACAIIAQ2AgAgAxCGMAwCCyAGQSxqIgQQhjAgCkHoAGohCiMAQUBqIgMkACADQQxqQYSJ0ABBEBCAICADQSxqIAIQ8icCQCADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyADQSxqIgVBioXQAEEKQQZBARDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCWBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUGUidAAQQlBBkECEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJcELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQZ2J0ABBCEEGQQMQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAmAQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISADQSxqIgVBlIXQAEEIQQZBBBDoHCADQRhqIAIgBRCwFCADKAIYIglBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgCTYCACAFEIYwDAELIANBLGoiBRCGMCAFIAIgCigCZBCwGyADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwBCyACENMhIANBLGoiBUGlidAAQR1BBkEFEOgcIANBGGogAiAFELAUIAMoAhgiCUEERwRAIAQgAykCHDcCBCAEQQxqIANBJGopAgA3AgAgBCAJNgIAIAUQhjAMAQsgA0EsaiIFEIYwIAUgAiAKKAJoELAbIAMoAiwiBUEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAFNgIADAELIAIQ0yEgA0EsaiIFQcKJ0ABBHUEGQQYQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwBCyADQSxqIgUQhjAgBSACIAooAmwQsBsgAygCLCIFQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAU2AgAMAQsgAhDTISAKLQBwIglBAkcEQCADQSxqIgVB34nQAEENQQJBBxDoHCADQRhqIAIgBRCwFCADKAIYIgxBBEcEQCAEIAMpAhw3AgQgBEEMaiADQSRqKQIANwIAIAQgDDYCACAFEIYwDAILIANBLGoiBRCGMCAFIAIgCUEBcRDGFSADKAIsIgVBBEcEQCAEIAMpAjA3AgQgBEEMaiADQThqKQIANwIAIAQgBTYCAAwCCyACENMhCyAKKQMAQgJSBEAgA0EsaiIFQc6F0ABBCkEKQQgQ6BwgA0EYaiACIAUQsBQgAygCGCIJQQRHBEAgBCADKQIcNwIEIARBDGogA0EkaikCADcCACAEIAk2AgAgBRCGMAwCCyADQSxqIgUQhjAgBSAKIAIQlgMgAygCLCIKQQRHBEAgBCADKQIwNwIEIARBDGogA0E4aikCADcCACAEIAo2AgAMAgsgAhDTIQsgA0EsaiACEKspIAMoAiwiCkEERwRAIAQgAykCMDcCBCAEQQxqIANBOGopAgA3AgAgBCAKNgIADAELIAQgAhDqKAsgA0EMahDeOyADQUBrJAAgBigCLCIDQQRHBEAgCCAGKQIwNwIEIAhBDGogBkE4aikCADcCACAIIAM2AgAMAgsgAhDTIQsgBkEsaiACEKspIAYoAiwiA0EERwRAIAggBikCMDcCBCAIQQxqIAZBOGopAgA3AgAgCCADNgIADAELIAggAhDqKAsgBkEMahDeOyAGQUBrJAAgBygCzAUiBkEERwRAIAdBnANqIAdB2AVqKQIANwIAIAcgBykC0AU3ApQDIAcgBjYCkAMgACAHQZADahClJSAAQQQ6ABwgAhC6LiANEN47IA4Q/CwMAQsgB0GoA2oiAhC6LiAHQbADaiAHQcgFaigCADYCACAHIAcpAsAFNwOoAyAHQbAFaiACEOcVIAEoAgAiBi0ACCAGQQE6AAhBAUYNAiAHQeAAaiECAkACQAJAQQEgBykDACIPp0EJayAPQghYG0EBaw4CAAECCyAHQdgAaiECDAELIAshAgsgB0HoAGohASAHQeAFaiACQQxqIAIoAgQgAigCCCACKAIAKAIAEQUAIAcoArgFIgogBygC6AVqIQJBAyEDAkACQAJAQQEgBykDACIPp0EJayAPQghYG0EBaw4CAgEACyAHQfAAaiEBQQAhAwwBCyAHQRhqIQFBAiEDCyABKAIAIQUgBygCgAEhCSAGIAYoAhgiDSACajYCGCAGQQxqIQggBigCFCIBIAYoAgxGBEAgCEG46c8AEJ4oCyAGKAIQIAFBBHRqIgQgBykCsAU3AgAgBEEIaiAHQbgFaikCADcCACAGIAFBAWoiBDYCFCAGKAIMIARGBEAgCEHI6c8AEJ4oCyAGKAIQIARBBHRqIgggBykC4AU3AgAgCEEIaiAHQegFaikCADcCACAAIAM6ABwgACAFNgIYIAAgAjYCFCAAIAkgCmo2AhAgACACrTcDCCAAIA2tNwMAIAYgAUECajYCFCAGQQA6AAggB0GIAWoQ/CwLAkACQAJAAkBBASAHKQMAIg+nQQlrIA9CCFgbDgIBAgALIAdBFGogBygCDCAHKAIQIAcoAggoAhARAQAMAgsgB0HsAGogBygCZCAHKAJoIAcoAmAoAhARAQAgCxDCGAwBCyAHQeQAaiAHKAJcIAcoAmAgBygCWCgCEBEBACAHEMIYCyAHQfAFaiQADwsgBiAHKAKwA0GY6c8AEP0vAAsgB0EANgKoA0HY5s8AQSsgB0GoA2pByObPAEGo6c8AENUeAAvGCAIDfwF+IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIwIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxDjKCECDAwLIARBKGogAxC5HCECDAsLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCyAAKAIQIAJBA3RqKQMAQgBTDQkgBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEFAa0GJkqTIADYCACAEQomSpMiQocKECTcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFPDQogACgCECACQQN0aikDACIHQgBZDQVBrJyEARCyOwALIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAU8NCSAAKAIQIAJBA3RqKQMAIgdCAFkNBUH8nIQBELI7AAsgBEFAa0GJkqTIADYCACAEQomSpMiQocKECTcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQYmSpMgANgIAIARCiZKkyJChwoQJNwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAHNwMAIARBQGtBiZKkyAA2AgAgBEKJkqTIkKHChAk3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgBzcDCCAEQUBrQYmSpMgANgIAIARCiZKkyJChwoQJNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwDC0HYm4QBELI7AAsgBEHQAGokACACDwsgBCABNgIoIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALrAgBBn8jAEEgayIHJAACQCACRQ0AIAEgAkECdCIGakEEayIFRQ0AIAUoAgANACAGIQUgAUEEayEIIAJB/////wNxIQYDQCAFRQRAQQAhAgwCCyAGQQFrIQYgBSAIaiAFQQRrIQUoAgBFDQALIAIgBkEBaiIFTwRAIAUhAgwBCyAFIAJBkI2IARCwOwALAkAgAyAEQQJ0IgZqQQRrIgVFDQAgBSgCAA0AIAYhBSADQQRrIQggBCEGA0AgBUUEQEEAIQQMAgsgBkEBayEGIAUgCGogBUEEayEFKAIARQ0ACyAEIAZBAWoiBU8EQCAFIQQMAQsgBSAEQaCNiAEQsDsACwJAAkACQAJAAkACQAJAAn8gAiAESyACIARJayACIARHDQAaIAFBBGshCSADQQRrIQogAkECdCEFAkADQCAFRQ0BIAUgCmohCCAFIAlqIAVBBGshBSgCACIGIAgoAgAiCEYNAAsgBiAISyAGIAhJawwBC0F/QQAgBRsLQf8BcQ4CAQIACyAHQRRqIARBAEEEQQQQoBggBygCGCEIIAcoAhRBAUYNBSAHKAIcIQYgBEECdCIFBEAgBiADIAX8CgAACyAGIAQgASACEM0QIAcgBDYCHCAHIAY2AhggByAINgIUIARFDQMgBSAGakEEayIBRQ0DIAEoAgANAyAEQQJ0IQUgBkEEayEBIARB/////wNxIQYCQANAIAVFBEBBACEFDAILIAZBAWshBiABIAVqIAVBBGshBSgCAEUNAAsgBkEBaiIFIARLDQQLIAcgBTYCHCAFIQQMAwsgAEEBOgAAIABBsI2IASkCADcCBCAAQQxqQbiNiAEoAgA2AgAMAwsgB0EUaiACQQBBBEEEEKAYIAcoAhghCCAHKAIUQQFGDQMgBygCHCEGIAJBAnQiBQRAIAYgASAF/AoAAAsgBiACIAMgBBDNECAHIAI2AhwgByAGNgIYIAcgCDYCFCACRQ0AIAUgBmpBBGsiAUUNACABKAIADQAgAkECdCEFIAZBBGshASACQf////8DcSEGAkADQCAFRQRAQQAhBQwCCyAGQQFrIQYgASAFaiAFQQRrIQUoAgBFDQALIAZBAWoiBSACSw0BCyAHIAU2AhwgBSECDAALAkAgAiAIQQJ2Tw0AIAdBCGogB0EUaiACQQRBBBD0FCAHKAIIIgFBgYCAgHhGDQAgASAHKAIMQcyNiAEQ/S8ACyAAIAcpAhQ3AgQgAEEMaiAHQRxqKAIANgIAIABBAjoAAAwBCwJAIAQgCEECdk8NACAHIAdBFGogBEEEQQQQ9BQgBygCACIBQYGAgIB4Rg0AIAEgBygCBEHMjYgBEP0vAAsgACAHKQIUNwIEIABBDGogB0EcaigCADYCACAAQQA6AAALIAdBIGokAA8LIAggBygCHEH8iYgBEP0vAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQvwYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEL8GIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDABiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQwAYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMEGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDBBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQwgYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMIGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDDBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQwwYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMQGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDEBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQxQYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMUGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDGBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQxgYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMcGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDHBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQyAYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMgGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDJBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQyQYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEMoGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDKBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQywYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEMsGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDMBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQzAYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEEM0GIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDNBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQzgYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIEM4GIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDPBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQzwYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENAGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDQBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ0QYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENEGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDSBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ0gYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENMGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDTBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ1AYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENQGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDVBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ1QYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENYGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDWBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ1wYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENcGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDYBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ2AYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENkGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDZBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvsCQEFfyMAQRBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyAAQQA6AAAMKAsgAEEBOgAADCcLIABBAjoAAAwmCyAAQQM6AAAMJQsgAEEEOgAADCQLIABBBToAAAwjCyAAQQY6AAAMIgsgAEEHOgAADCELIABBCDoAAAwgCyAAQQk6AAAMHwsgAEEKOgAADB4LIABBCzoAAAwdCyAAQQw6AAAMHAsgAS0AASEDIAAgASgCBCICBH8gAiACKAIAIgVBAWo2AgAgBUEASA0dIAEoAggFIAELNgIIIAAgAjYCBCAAIAM6AAEgAEENOgAADBsLIABBDjoAAAwaCyAAQQ86AAAMGQsgAEEQOgAAIAAgAS0AAToAAQwYCyAAQRE6AAAgACABLQABOgABDBcLIABBEjoAACAAIAEtAAE6AAEMFgsgAEETOgAAIAAgAS0AAToAAQwVCyAAQRQ6AAAMFAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwTCyAAQRY6AAAMEgsgAEEXOgAADBELIABBGDoAAAwQCyAAQRk6AAAMDwsgAEEaOgAADA4LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0OIABBGzoAACAAIAE2AgQMDQsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ0gAEEcOgAAIAAgATYCBAwMCyABKAIIIgIgAigCACIDQQFqNgIAIANBAEgNDCAAIAI2AgggAEEdOgAAIAAgASgCBDYCBAwLCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCyAAQR46AAAgACABNgIEDAoLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0KIABBHzoAACAAIAE2AgQMCQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQkgACACNgIEIABBIDoAACAAIAEoAgg2AggMCAsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQggACACNgIEIABBIToAACAAIAEoAgg2AgggACABLQABOgABDAcLEM0vIQIgBEEEaiIGIAEoAgQQ2gYgAkEIaiAEQQxqIgUoAgA2AgAgAiAEKQIENwIAEM0vIQMgBiABKAIIENoGIANBCGogBSgCADYCACADIAQpAgQ3AgAgACADNgIIIAAgAjYCBCAAQSI6AAAMBgsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwFCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAwsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwCCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNAiAAIAI2AgQgAEEnOgAAIAAgAS0AAToAAQwBCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNASABKAIIIgEgASgCACIDQQFqNgIAIANBAEgNASAAIAE2AgggACACNgIEIABBKDoAAAsgBEEQaiQADwsAC+wJAQV/IwBBEGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIABBADoAAAwoCyAAQQE6AAAMJwsgAEECOgAADCYLIABBAzoAAAwlCyAAQQQ6AAAMJAsgAEEFOgAADCMLIABBBjoAAAwiCyAAQQc6AAAMIQsgAEEIOgAADCALIABBCToAAAwfCyAAQQo6AAAMHgsgAEELOgAADB0LIABBDDoAAAwcCyABLQABIQMgACABKAIEIgIEfyACIAIoAgAiBUEBajYCACAFQQBIDR0gASgCCAUgAQs2AgggACACNgIEIAAgAzoAASAAQQ06AAAMGwsgAEEOOgAADBoLIABBDzoAAAwZCyAAQRA6AAAgACABLQABOgABDBgLIABBEToAACAAIAEtAAE6AAEMFwsgAEESOgAAIAAgAS0AAToAAQwWCyAAQRM6AAAgACABLQABOgABDBULIABBFDoAAAwUCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADBMLIABBFjoAAAwSCyAAQRc6AAAMEQsgAEEYOgAADBALIABBGToAAAwPCyAAQRo6AAAMDgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQ4gAEEbOgAAIAAgATYCBAwNCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDSAAQRw6AAAgACABNgIEDAwLIAEoAggiAiACKAIAIgNBAWo2AgAgA0EASA0MIAAgAjYCCCAAQR06AAAgACABKAIENgIEDAsLIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0LIABBHjoAACAAIAE2AgQMCgsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQogAEEfOgAAIAAgATYCBAwJCyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCSAAIAI2AgQgAEEgOgAAIAAgASgCCDYCCAwICyABKAIEIgIgAigCACIDQQFqNgIAIANBAEgNCCAAIAI2AgQgAEEhOgAAIAAgASgCCDYCCCAAIAEtAAE6AAEMBwsQzS8hAiAEQQRqIgYgASgCBBDbBiACQQhqIARBDGoiBSgCADYCACACIAQpAgQ3AgAQzS8hAyAGIAEoAggQ2wYgA0EIaiAFKAIANgIAIAMgBCkCBDcCACAAIAM2AgggACACNgIEIABBIjoAAAwGCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwDCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAILIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0CIAAgAjYCBCAAQSc6AAAgACABLQABOgABDAELIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0BIAEoAggiASABKAIAIgNBAWo2AgAgA0EASA0BIAAgATYCCCAAIAI2AgQgAEEoOgAACyAEQRBqJAAPCwAL7AkBBX8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAEEAOgAADCgLIABBAToAAAwnCyAAQQI6AAAMJgsgAEEDOgAADCULIABBBDoAAAwkCyAAQQU6AAAMIwsgAEEGOgAADCILIABBBzoAAAwhCyAAQQg6AAAMIAsgAEEJOgAADB8LIABBCjoAAAweCyAAQQs6AAAMHQsgAEEMOgAADBwLIAEtAAEhAyAAIAEoAgQiAgR/IAIgAigCACIFQQFqNgIAIAVBAEgNHSABKAIIBSABCzYCCCAAIAI2AgQgACADOgABIABBDToAAAwbCyAAQQ46AAAMGgsgAEEPOgAADBkLIABBEDoAACAAIAEtAAE6AAEMGAsgAEEROgAAIAAgAS0AAToAAQwXCyAAQRI6AAAgACABLQABOgABDBYLIABBEzoAACAAIAEtAAE6AAEMFQsgAEEUOgAADBQLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMEwsgAEEWOgAADBILIABBFzoAAAwRCyAAQRg6AAAMEAsgAEEZOgAADA8LIABBGjoAAAwOCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNDiAAQRs6AAAgACABNgIEDA0LIAEoAgQiASABKAIAIgJBAWo2AgAgAkEASA0NIABBHDoAACAAIAE2AgQMDAsgASgCCCICIAIoAgAiA0EBajYCACADQQBIDQwgACACNgIIIABBHToAACAAIAEoAgQ2AgQMCwsgASgCBCIBIAEoAgAiAkEBajYCACACQQBIDQsgAEEeOgAAIAAgATYCBAwKCyABKAIEIgEgASgCACICQQFqNgIAIAJBAEgNCiAAQR86AAAgACABNgIEDAkLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0JIAAgAjYCBCAAQSA6AAAgACABKAIINgIIDAgLIAEoAgQiAiACKAIAIgNBAWo2AgAgA0EASA0IIAAgAjYCBCAAQSE6AAAgACABKAIINgIIIAAgAS0AAToAAQwHCxDNLyECIARBBGoiBiABKAIEENwGIAJBCGogBEEMaiIFKAIANgIAIAIgBCkCBDcCABDNLyEDIAYgASgCCBDcBiADQQhqIAUoAgA2AgAgAyAEKQIENwIAIAAgAzYCCCAAIAI2AgQgAEEiOgAADAYLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBQsgACABKQIANwIAIABBCGogAUEIaigCADYCAAwECyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAMLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMAgsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQIgACACNgIEIABBJzoAACAAIAEtAAE6AAEMAQsgASgCBCICIAIoAgAiA0EBajYCACADQQBIDQEgASgCCCIBIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIIIAAgAjYCBCAAQSg6AAALIARBEGokAA8LAAvYCAIFfwR+IwBBkAFrIgQkACABQQxqENs8IQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAUQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEBDAcLIARB+ABqIAIgDKcgCadqIgdBAnRqNQIAIAt/IgkgAxCNECAEKAJ4IgFBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiAHQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAlQBEBBh4CAgHghAQwDCyAEQUBrIAI1AgAgCX8iCiADEI0QIAQoAkAiAUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEGIAQoAiwhAyABIARByABqIgUpAgA3AwAgBCkDICEJIAQgBCkCQDcDICAEQQA2AjAgBCAJNwJMIARBADYCSCAEIAM2AkQgBCAGNgJAIAQgAhDXOyAEKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCgAEgBCAGNgJ8IAQgATYCeCAEQTRqIgEgBEH4AGoQ5BkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQxh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBkAFqJAAL2AgCBX8EfiMAQZABayIEJAAgAUEMahDZPCEIIARBCGogARCSNhDuJSAIQQN0IgchBQJAAkACQAJAAkAgB0E4cSIGBEAgByAGa0FAayIFIAdJDQELQcAAIQYgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBkUNAQsgBCAGNgIoIAQgBTYCJCAEQcAANgIgIAcEQCAGQQAgB/wLAAsgBCAINgIwIAQgBzYCLCAEKAIIRQ0DIAQoAhwgBCgCGEYNBCAEQUBrIARBCGoQyDQgBEHgAGohBSADLQAAIQMgAikDACELIAEoAhAhAgNAAkAgBCkDaCIKUEUEQCAEKQNwIQkMAQsDQAJ+AkAgBCkDUCIJQgNSBEACQAJAAkAgCUICUQ0AIAQgCVCtQgGGNwNQIAmnQQFxRQ0AIAQgBCkDWDcDgAEMAQsgBCgCYEUNASAEQfgAaiAFELYqIAQpA3ghCQsgCUIAUg0CCyAEQgM3A1ALIAQpA0AiCUICUQ0JIARCADcDQCAEKQNIDAELIAQpA4ABCyEKIAmnQQFxRQ0HIAQgBCkDcEJAfSIJNwNwIAQgCjcDaCAKUA0ACwsgBEIBIAp6IgyGIAqFNwNoIAtQBEBBh4CAgHghAQwHCyAEQfgAaiACIAynIAmnaiIHQQF0ajMBACALfyIJIAMQjRAgBCgCeCIBQZOAgIB4RwRAIAQpAoQBIQkgBCkCfCEKDAcFIAYgB0EDdGogCTcDAAwBCwALAAtBwAAgBRCjPQALQdyL/wBBKSAEQUBrQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgCEUNACADLQAAIQMgAikDACEJIAEoAhAhAkEAIQUDQCAJUARAQYeAgIB4IQEMAwsgBEFAayACMwEAIAl/IgogAxCNECAEKAJAIgFBk4CAgHhHBEAgBCkCTCEJIAQpAkQhCgwDCyAGIAo3AwAgBkEIaiEGIAJBAmohAiAIIAVBAWoiBUcNAAsLIARBQGsiAhCXKSAEQShqIgEoAgAhBiAEKAIsIQMgASAEQcgAaiIFKQIANwMAIAQpAyAhCSAEIAQpAkA3AyAgBEEANgIwIAQgCTcCTCAEQQA2AkggBCADNgJEIAQgBjYCQCAEIAIQ1zsgBCgCACEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAQpAkA3AgggAUEQaiAFKQIANwIAIAFBGGogBEHQAGoiBygCADYCACAEIAM2AoABIAQgBjYCfCAEIAE2AnggBEE0aiIBIARB+ABqEOQZIAcgBEEYaikCADcDACAFIARBEGopAgA3AwAgBCAEKQIINwNAIAAgASACEMYdIARBIGoQzy8MAgtBBEEcEKM9AAsgACAJNwIQIAAgCjcCCCAAIAE2AgQgAEEpOgAAIARBIGoQzy8gBCgCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQQhqEPseCyAEQZABaiQAC9gIAgV/BH4jAEGQAWsiBCQAIAFBDGoQ2TwhCCAEQQhqIAEQkjYQ7iUgCEEDdCIHIQUCQAJAAkACQAJAIAdBOHEiBgRAIAcgBmtBQGsiBSAHSQ0BC0HAACEGIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgZFDQELIAQgBjYCKCAEIAU2AiQgBEHAADYCICAHBEAgBkEAIAf8CwALIAQgCDYCMCAEIAc2AiwgBCgCCEUNAyAEKAIcIAQoAhhGDQQgBEFAayAEQQhqEMg0IARB4ABqIQUgAy0AACEDIAIpAwAhCyABKAIQIQIDQAJAIAQpA2giClBFBEAgBCkDcCEJDAELA0ACfgJAIAQpA1AiCUIDUgRAAkACQAJAIAlCAlENACAEIAlQrUIBhjcDUCAJp0EBcUUNACAEIAQpA1g3A4ABDAELIAQoAmBFDQEgBEH4AGogBRC2KiAEKQN4IQkLIAlCAFINAgsgBEIDNwNQCyAEKQNAIglCAlENCSAEQgA3A0AgBCkDSAwBCyAEKQOAAQshCiAJp0EBcUUNByAEIAQpA3BCQH0iCTcDcCAEIAo3A2ggClANAAsLIARCASAKeiIMhiAKhTcDaCALUARAQYeAgIB4IQEMBwsgBEH4AGogAiAMpyAJp2oiB0EBdGoyAQAgC38iCSADEI0QIAQoAngiAUGTgICAeEcEQCAEKQKEASEJIAQpAnwhCgwHBSAGIAdBA3RqIAk3AwAMAQsACwALQcAAIAUQoz0AC0Hci/8AQSkgBEFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAhFDQAgAy0AACEDIAIpAwAhCSABKAIQIQJBACEFA0AgCVAEQEGHgICAeCEBDAMLIARBQGsgAjIBACAJfyIKIAMQjRAgBCgCQCIBQZOAgIB4RwRAIAQpAkwhCSAEKQJEIQoMAwsgBiAKNwMAIAZBCGohBiACQQJqIQIgCCAFQQFqIgVHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACABNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAvYCAIFfwR+IwBBkAFrIgQkACABQQxqENs8IQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEFIAMtAAAhAyACKQMAIQsgASgCECECA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAUQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEBDAcLIARB+ABqIAIgDKcgCadqIgdBAnRqNAIAIAt/IgkgAxCNECAEKAJ4IgFBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiAHQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhBQNAIAlQBEBBh4CAgHghAQwDCyAEQUBrIAI0AgAgCX8iCiADEI0QIAQoAkAiAUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgAkEEaiECIAggBUEBaiIFRw0ACwsgBEFAayICEJcpIARBKGoiASgCACEGIAQoAiwhAyABIARByABqIgUpAgA3AwAgBCkDICEJIAQgBCkCQDcDICAEQQA2AjAgBCAJNwJMIARBADYCSCAEIAM2AkQgBCAGNgJAIAQgAhDXOyAEKAIAIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgBCkCQDcCCCABQRBqIAUpAgA3AgAgAUEYaiAEQdAAaiIHKAIANgIAIAQgAzYCgAEgBCAGNgJ8IAQgATYCeCAEQTRqIgEgBEH4AGoQ5BkgByAEQRhqKQIANwMAIAUgBEEQaikCADcDACAEIAQpAgg3A0AgACABIAIQxh0gBEEgahDPLwwCC0EEQRwQoz0ACyAAIAk3AhAgACAKNwIIIAAgATYCBCAAQSk6AAAgBEEgahDPLyAEKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBCGoQ+x4LIARBkAFqJAAL9ggBBX8jAEHwAGsiBiQAIAYgAjYCCCAGIAE2AgQgBiAENgIQIAYgAzYCDAJAAkAgAkEASARAIAZBATYCXCAGQaCfhgE2AlggBkIBNwJkIAZBnAM2AhwgBiAGQRhqNgJgIAYgBkEIajYCGCAGQTRqIAZB2ABqEJkOIAAgBikCODcCDCAAQRRqIAZBQGsoAgA2AgAgACAGKAI0NgIIIABBjYCAgHg2AgQgAEEpOgAADAELAkAgAkUEQCAFKAIQQQAgBSgCABshCCAEKAIIQQFrQXhxIQcMAQsgBiADIAQoAghBAWtBeHEiB2pBCGogBCgCJBEEACACbiIINgIUIAUoAgBFDQAgBSgCECIJIAhGDQAgBiAJNgIYIAZBAjYCXCAGQaCkhgE2AlggBkICNwJkIAZBOzYCPCAGQTs2AjQgBiAGQTBqNgJgIAYgBkEYajYCOCAGIAZBFGo2AjAgAEEIaiAGQdgAahCZDiAAQSk6AAAgAEGNgICAeDYCBAwBCyABQTBqIgkgAyAHakEIaiIHIAQoAhwiChEEABDICARAIAZBGGogByAEKAI4EQAAIAYoAhgEQCAGQUBrIAZBKGopAgA3AwAgBkE4aiAGQSBqKQIANwMAIAYgBikCGDcDMAJAIAEtAEgNACAFKAIABH8gBkHYAGoiAyAFIAIQig4gAyAGQTBqEOIIIAYoAlgiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAMQ+x4LDQEgBSgCAEUFQQELBEAgBigCREUNAQsgBkHwpIYBNgJYIAZCATcCZCAGQcoENgJQIAYgBigCBEE8ajYCVCAGIAZBzABqNgJgIAYgBkHUAGo2AkwgBkEBNgJcIABBCGogBkHYAGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQgBigCMCIAIAAoAgAiAEEBazYCACAAQQFHDQMgBkEwahD7HgwDCyAGKAIwIgEgASgCACIBQQFrNgIAIAFBAUYEQCAGQTBqEPseCyAGKAIQIQQgBigCDCEDIAYoAgghAiAGKAIEIQELIAAgCDYCMCAAIAI2AiwgACAENgIQIAAgAzYCDCAAIAE2AgggACACNgIEIABBHToAACAAIAUpAgA3AhQgAEEkaiAFQRBqKQIANwIAIABBHGogBUEIaikCADcCAAwCCyAGIAk2AlQgBiAHIAoRBAA2AkwgBiABQTxqNgIYIAZBAzYCNCAGQaSlhgE2AjAgBkIDNwI8IAZBygQ2AmwgBkGnBDYCZCAGQacENgJcIAYgBkHYAGo2AjggBiAGQRhqNgJoIAYgBkHMAGo2AmAgBiAGQdQAajYCWCAAQQhqIAZBMGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQLAkAgBSgCACIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAFEPseCyAGKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQQxqELsjCyAGKAIEIgAgACgCACIAQQFrNgIAIABBAUcNACAGQQRqEPIlCyAGQfAAaiQAC8MJAgh/An4jAEGwAWsiBSQAAkAgAgRAIAJBBHQhCiAFQSBqQQRyIQwgBUEoaiELA0AgBSAINgIYIAUgASkDACIOpyICNgIcIAEpAwghDQJAAkACQCACQQ1PBEAgBSACNgIgIAUgDkIgiD4CJCAFIA2nIgY2AiggBSANQiCIpyIHNgIsIAQgBk0EQCAFIAQ2ApwBIAVBrMeHATYCWCAFQgM3AmQgBUE7NgKEASAFQTs2AnwgBSALNgJ4IAVBOzYCdCAFIAVB8ABqNgJgIAUgBUGcAWo2AoABIAUgBUEYajYCcCAFQQQ2AlwgBUHIAGogBUHYAGoQmQ4gACAFKQJMNwIIIABBEGogBUHUAGooAgA2AgAgACAFKAJINgIEIABBjYCAgHg2AgAMBwsgBSAHNgI8IAUgAiAHaiIJNgJAIAVBEGogAyAGQQxsaiIGENw7AkACQCAHIAlLDQAgCSAFKAIUSw0AIAUoAhAiCQ0BCyAFIAYoAgg2ApwBIAVBBTYCXCAFQYTIhwE2AlggBUIFNwJkIAVBOzYClAEgBUE7NgKMASAFIAs2AogBIAVBOzYChAEgBUE7NgJ8IAVBOzYCdCAFIAVB8ABqNgJgIAUgBUGcAWo2ApABIAUgBUFAazYCgAEgBSAFQTxqNgJ4IAUgBUEYajYCcCAFQcgAaiAFQdgAahCZDiAFKQJIIQ0gACAFKQJQNwIMIAAgDTcCBCAAQY2AgIB4NgIADAcLIAUgBSgCJDYCcCAHIAlqIgcgAiAFQfAAaiIGQQQQ9C5FBEAgBkEpQQBBAUEBEKAYIAUoAnQhASAFKAJwQQFGDQIgBSgCeCICQfjFhwFBKfwKAAAgAEEpNgIMIAAgAjYCCCAAIAE2AgQgAEGNgICAeDYCAAwHCyAFIAUoAhg2ApgBIAVBnAFqIAcgAhCdCSAFKAKcAUUNAyAFIAUpAqABNwOoASAFQQI2AnQgBUHoxYcBNgJwIAVCAjcCfCAFQbADNgJQIAVBOzYCSCAFIAVBxABqNgJ4IAUgBUGoAWo2AkwgBSAFQZgBajYCRCAFQdwAaiAFQfAAahCZDiAFKQJcIQ0gACAFKQJkNwIMIAAgDTcCBCAAQY2AgIB4NgIADAYLIAJBDEYNASAFIA4gDSACQQN0QSBqEMcjIAUpAwAgBSkDCIRQDQEgBUECNgJ0IAVB4MaHATYCcCAFQgI3AnwgBUE7NgJkIAVBOzYCXCAFIAVB2ABqNgJ4IAUgBUEcajYCYCAFIAVBGGo2AlggAEEEaiAFQfAAahCZDiAAQY2AgIB4NgIADAULIAEgBSgCeEGgxIcBEP0vAAsgBSAONwMgIAUgDTcDKCAFIAg2ApgBIAVBnAFqIAwgAhCdCSAFKAKcAUUNACAFIAUpAqABNwOoASAFQQI2AnQgBUHoxYcBNgJwIAVCAjcCfCAFQbADNgJQIAVBOzYCSCAFIAVBxABqNgJ4IAUgBUGoAWo2AkwgBSAFQZgBajYCRCAFQdwAaiAFQfAAahCZDiAFKQJcIQ0gACAFKQJkNwIMIAAgDTcCBCAAQY2AgIB4NgIADAMLIAFBEGohASAIQQFqIQggCkEQayIKDQALCyAAQZOAgIB4NgIACyAFQbABaiQAC8QIAQR/IwBB8AFrIgMkACABKAKABUEIahCqJUH/AXEhBgJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEEGaw4CAAEICyACKAIoRQ0HIAIoAjxFDQcgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAYLIAIoAihFDQYgAigCPEUNBiABEOcfRQ0GIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwECyADKAJsRQ0HIAMoAnAiAkUNBCADQbgBaiIFIAEgASgChAUiBCgCQCAEKAJEIAIgAygCdBCcDSADQQhqIANBwAFqKAIANgIAIAMgAykCuAE3AwAgAygCfEEBRw0BIAMoAoABRQ0HIAMoAoQBIgJFDQEgAy0AxAEhBCAFIAEgASgChAUiASgCQCABKAJEIAIgAygCiAEQmAwgA0EYaiADQcABaigCADYCACADIAMpArgBNwMQIAMtAMQBIQEgA0EgakEEciADEOcVIANBATYCICADQThqIANBEGoQ5xUgACAGRSICOgBTIAAgAjoAUiAAIARBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDIDcDKCAAQTBqIANBKGopAwA3AwAgAEE4aiADQTBqKAIANgIAIABBxABqIANBPGopAgA3AgAgAEHMAGogA0HEAGooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYCNCAAIAMpAjQ3AjwgAEIGNwMAIANByABqEKclDAYLIAMoAmxFDQYgAygCcCICRQ0CIANBuAFqIgUgASABKAKEBSIEKAJAIAQoAkQgAiADKAJ0EJwNIANBoAFqIANBwAFqKAIANgIAIAMgAykCuAE3A5gBIAMoAnxBAUcNASADKAKAAUUNBiADKAKEASICRQ0BIAMtAMQBIQQgBSABIAEoAoQFIgEoAkAgASgCRCACIAMoAogBEJgMIANBsAFqIANBwAFqKAIANgIAIAMgAykCuAE3A6gBIAMtAMQBIQEgA0HIAWpBBHIgA0GYAWoQ5xUgA0EBNgLIASADQeABaiADQagBahDnFSAAIAZFIgI6AFMgACACOgBSIAAgBEF/c0EBcToAUSAAIAFBAXM6AFAgACADKQPIATcDKCAAQTBqIANB0AFqKQMANwMAIABBOGogA0HYAWooAgA2AgAgAEHEAGogA0HkAWopAgA3AgAgAEHMAGogA0HsAWooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYC3AEgACADKQLcATcCPCAAQgc3AwAgA0HIAGoQpyUMBQtB+IHPABCyOwALQZiCzwAQsjsAC0GIgs8AELI7AAtB6IHPABCyOwALIAAgAkHYAPwKAAALIANB8AFqJAAPC0Hkh84AQSBBhIjOABDLJAALxAgBBH8jAEHwAWsiAyQAIAEoApgFQQhqEKolQf8BcSEGAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQZrDgIAAQgLIAIoAihFDQcgAigCPEUNByADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBgsgAigCKEUNBiACKAI8RQ0GIAEQ6R9FDQYgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAQLIAMoAmxFDQcgAygCcCICRQ0EIANBuAFqIgUgASABKAKcBSIEKAJAIAQoAkQgAiADKAJ0EJ4NIANBCGogA0HAAWooAgA2AgAgAyADKQK4ATcDACADKAJ8QQFHDQEgAygCgAFFDQcgAygChAEiAkUNASADLQDEASEEIAUgASABKAKcBSIBKAJAIAEoAkQgAiADKAKIARCaDCADQRhqIANBwAFqKAIANgIAIAMgAykCuAE3AxAgAy0AxAEhASADQSBqQQRyIAMQ5xUgA0EBNgIgIANBOGogA0EQahDnFSAAIAZFIgI6AFMgACACOgBSIAAgBEF/c0EBcToAUSAAIAFBAXM6AFAgACADKQMgNwMoIABBMGogA0EoaikDADcDACAAQThqIANBMGooAgA2AgAgAEHEAGogA0E8aikCADcCACAAQcwAaiADQcQAaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgI0IAAgAykCNDcCPCAAQgY3AwAgA0HIAGoQpyUMBgsgAygCbEUNBiADKAJwIgJFDQIgA0G4AWoiBSABIAEoApwFIgQoAkAgBCgCRCACIAMoAnQQng0gA0GgAWogA0HAAWooAgA2AgAgAyADKQK4ATcDmAEgAygCfEEBRw0BIAMoAoABRQ0GIAMoAoQBIgJFDQEgAy0AxAEhBCAFIAEgASgCnAUiASgCQCABKAJEIAIgAygCiAEQmgwgA0GwAWogA0HAAWooAgA2AgAgAyADKQK4ATcDqAEgAy0AxAEhASADQcgBakEEciADQZgBahDnFSADQQE2AsgBIANB4AFqIANBqAFqEOcVIAAgBkUiAjoAUyAAIAI6AFIgACAEQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpA8gBNwMoIABBMGogA0HQAWopAwA3AwAgAEE4aiADQdgBaigCADYCACAAQcQAaiADQeQBaikCADcCACAAQcwAaiADQewBaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgLcASAAIAMpAtwBNwI8IABCBzcDACADQcgAahCnJQwFC0H4gc8AELI7AAtBmILPABCyOwALQYiCzwAQsjsAC0Hogc8AELI7AAsgACACQdgA/AoAAAsgA0HwAWokAA8LQeSHzgBBIEGEiM4AEMskAAvRCAIFfwR+IwBBkAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAMtAAAhAyACKQMAIQsgASgCECEBA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAcQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEFDAcLIARB+ABqIAEgDKcgCadqIgJqMAAAIAt/IgkgAxCNECAEKAJ4IgVBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhAQNAIAlQBEBBh4CAgHghBQwDCyAEQUBrIAEgAmowAAAgCX8iCiADEI0QIAQoAkAiBUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAvRCAIFfwR+IwBBkAFrIgQkACABQQxqKAIIIQggBEEIaiABEJI2EO4lIAhBA3QiByEFAkACQAJAAkACQCAHQThxIgYEQCAHIAZrQUBrIgUgB0kNAQtBwAAhBiAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIGRQ0BCyAEIAY2AiggBCAFNgIkIARBwAA2AiAgBwRAIAZBACAH/AsACyAEIAg2AjAgBCAHNgIsIAQoAghFDQMgBCgCHCAEKAIYRg0EIARBQGsgBEEIahDINCAEQeAAaiEHIAMtAAAhAyACKQMAIQsgASgCECEBA0ACQCAEKQNoIgpQRQRAIAQpA3AhCQwBCwNAAn4CQCAEKQNQIglCA1IEQAJAAkACQCAJQgJRDQAgBCAJUK1CAYY3A1AgCadBAXFFDQAgBCAEKQNYNwOAAQwBCyAEKAJgRQ0BIARB+ABqIAcQtiogBCkDeCEJCyAJQgBSDQILIARCAzcDUAsgBCkDQCIJQgJRDQkgBEIANwNAIAQpA0gMAQsgBCkDgAELIQogCadBAXFFDQcgBCAEKQNwQkB9Igk3A3AgBCAKNwNoIApQDQALCyAEQgEgCnoiDIYgCoU3A2ggC1AEQEGHgICAeCEFDAcLIARB+ABqIAEgDKcgCadqIgJqMQAAIAt/IgkgAxCNECAEKAJ4IgVBk4CAgHhHBEAgBCkChAEhCSAEKQJ8IQoMBwUgBiACQQN0aiAJNwMADAELAAsAC0HAACAFEKM9AAtB3Iv/AEEpIARBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAIRQ0AIAMtAAAhAyACKQMAIQkgASgCECECQQAhAQNAIAlQBEBBh4CAgHghBQwDCyAEQUBrIAEgAmoxAAAgCX8iCiADEI0QIAQoAkAiBUGTgICAeEcEQCAEKQJMIQkgBCkCRCEKDAMLIAYgCjcDACAGQQhqIQYgCCABQQFqIgFHDQALCyAEQUBrIgIQlykgBEEoaiIBKAIAIQYgBCgCLCEDIAEgBEHIAGoiBSkCADcDACAEKQMgIQkgBCAEKQJANwMgIARBADYCMCAEIAk3AkwgBEEANgJIIAQgAzYCRCAEIAY2AkAgBCACENc7IAQoAgAhBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASAEKQJANwIIIAFBEGogBSkCADcCACABQRhqIARB0ABqIgcoAgA2AgAgBCADNgKAASAEIAY2AnwgBCABNgJ4IARBNGoiASAEQfgAahDkGSAHIARBGGopAgA3AwAgBSAEQRBqKQIANwMAIAQgBCkCCDcDQCAAIAEgAhDGHSAEQSBqEM8vDAILQQRBHBCjPQALIAAgCTcCECAAIAo3AgggACAFNgIEIABBKToAACAEQSBqEM8vIAQoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEIahD7HgsgBEGQAWokAAu4CAEFfyMAQfABayIDJAAgASgCuARBCGoQqiVB/wFxIQcCQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAgBBBmsOAgABCAsgAigCKEUNByACKAI8RQ0HIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwGCyACKAIoRQ0GIAIoAjxFDQYgARDoH0UNBiADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBAsgAygCbEUNByADKAJwIgRFDQQgA0G4AWoiBSABIAEoArwEIgIoAkAgAigCRCAEIAMoAnQQnQ0gA0EIaiADQcABaigCADYCACADIAMpArgBNwMAIAMoAnxBAUcNASADKAKAAUUNByADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJkMIANBGGogA0HAAWooAgA2AgAgAyADKQK4ATcDECADLQDEASEBIANBIGpBBHIgAxDnFSADQQE2AiAgA0E4aiADQRBqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpAyA3AyggAEEwaiADQShqKQMANwMAIABBOGogA0EwaigCADYCACAAQcQAaiADQTxqKQIANwIAIABBzABqIANBxABqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AjQgACADKQI0NwI8IABCBjcDACADQcgAahCnJQwGCyADKAJsRQ0GIAMoAnAiBEUNAiADQbgBaiIFIAEgASgCvAQiAigCQCACKAJEIAQgAygCdBCdDSADQaABaiADQcABaigCADYCACADIAMpArgBNwOYASADKAJ8QQFHDQEgAygCgAFFDQYgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCZDCADQbABaiADQcABaigCADYCACADIAMpArgBNwOoASADLQDEASEBIANByAFqQQRyIANBmAFqEOcVIANBATYCyAEgA0HgAWogA0GoAWoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDyAE3AyggAEEwaiADQdABaikDADcDACAAQThqIANB2AFqKAIANgIAIABBxABqIANB5AFqKQIANwIAIABBzABqIANB7AFqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AtwBIAAgAykC3AE3AjwgAEIHNwMAIANByABqEKclDAULQfiBzwAQsjsAC0GYgs8AELI7AAtBiILPABCyOwALQeiBzwAQsjsACyAAIAJB2AD8CgAACyADQfABaiQADwtB5IfOAEEgQYSIzgAQyyQAC7gIAQV/IwBB8AFrIgMkACABKALkBEEIahCqJUH/AXEhBwJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCAEEGaw4CAAEICyACKAIoRQ0HIAIoAjxFDQcgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAYLIAIoAihFDQYgAigCPEUNBiABEOUfRQ0GIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwECyADKAJsRQ0HIAMoAnAiBEUNBCADQbgBaiIFIAEgASgC6AQiAigCQCACKAJEIAQgAygCdBCaDSADQQhqIANBwAFqKAIANgIAIAMgAykCuAE3AwAgAygCfEEBRw0BIAMoAoABRQ0HIAMoAoQBIgRFDQEgAy0AxAEhBiAFIAEgAigCQCACKAJEIAQgAygCiAEQlgwgA0EYaiADQcABaigCADYCACADIAMpArgBNwMQIAMtAMQBIQEgA0EgakEEciADEOcVIANBATYCICADQThqIANBEGoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDIDcDKCAAQTBqIANBKGopAwA3AwAgAEE4aiADQTBqKAIANgIAIABBxABqIANBPGopAgA3AgAgAEHMAGogA0HEAGooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYCNCAAIAMpAjQ3AjwgAEIGNwMAIANByABqEKclDAYLIAMoAmxFDQYgAygCcCIERQ0CIANBuAFqIgUgASABKALoBCICKAJAIAIoAkQgBCADKAJ0EJoNIANBoAFqIANBwAFqKAIANgIAIAMgAykCuAE3A5gBIAMoAnxBAUcNASADKAKAAUUNBiADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJYMIANBsAFqIANBwAFqKAIANgIAIAMgAykCuAE3A6gBIAMtAMQBIQEgA0HIAWpBBHIgA0GYAWoQ5xUgA0EBNgLIASADQeABaiADQagBahDnFSAAIAdFIgI6AFMgACACOgBSIAAgBkF/c0EBcToAUSAAIAFBAXM6AFAgACADKQPIATcDKCAAQTBqIANB0AFqKQMANwMAIABBOGogA0HYAWooAgA2AgAgAEHEAGogA0HkAWopAgA3AgAgAEHMAGogA0HsAWooAgA2AgAgACADKQNgNwMgIAAgAykDWDcDGCAAIAMpA1A3AxAgACADKQNINwMIIANBATYC3AEgACADKQLcATcCPCAAQgc3AwAgA0HIAGoQpyUMBQtB+IHPABCyOwALQZiCzwAQsjsAC0GIgs8AELI7AAtB6IHPABCyOwALIAAgAkHYAPwKAAALIANB8AFqJAAPC0Hkh84AQSBBhIjOABDLJAALuAgBBX8jAEHwAWsiAyQAIAEoApQEQQhqEKolQf8BcSEHAkACQAJAAkACQAJAAkACQAJAAkACQCACKAIAQQZrDgIAAQgLIAIoAihFDQcgAigCPEUNByADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBgsgAigCKEUNBiACKAI8RQ0GIAEQ5h9FDQYgA0HIAGogAkEIakHQAPwKAAAgAygCaEEBRg0BDAQLIAMoAmxFDQcgAygCcCIERQ0EIANBuAFqIgUgASABKAKYBCICKAJAIAIoAkQgBCADKAJ0EJsNIANBCGogA0HAAWooAgA2AgAgAyADKQK4ATcDACADKAJ8QQFHDQEgAygCgAFFDQcgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCXDCADQRhqIANBwAFqKAIANgIAIAMgAykCuAE3AxAgAy0AxAEhASADQSBqQQRyIAMQ5xUgA0EBNgIgIANBOGogA0EQahDnFSAAIAdFIgI6AFMgACACOgBSIAAgBkF/c0EBcToAUSAAIAFBAXM6AFAgACADKQMgNwMoIABBMGogA0EoaikDADcDACAAQThqIANBMGooAgA2AgAgAEHEAGogA0E8aikCADcCACAAQcwAaiADQcQAaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgI0IAAgAykCNDcCPCAAQgY3AwAgA0HIAGoQpyUMBgsgAygCbEUNBiADKAJwIgRFDQIgA0G4AWoiBSABIAEoApgEIgIoAkAgAigCRCAEIAMoAnQQmw0gA0GgAWogA0HAAWooAgA2AgAgAyADKQK4ATcDmAEgAygCfEEBRw0BIAMoAoABRQ0GIAMoAoQBIgRFDQEgAy0AxAEhBiAFIAEgAigCQCACKAJEIAQgAygCiAEQlwwgA0GwAWogA0HAAWooAgA2AgAgAyADKQK4ATcDqAEgAy0AxAEhASADQcgBakEEciADQZgBahDnFSADQQE2AsgBIANB4AFqIANBqAFqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpA8gBNwMoIABBMGogA0HQAWopAwA3AwAgAEE4aiADQdgBaigCADYCACAAQcQAaiADQeQBaikCADcCACAAQcwAaiADQewBaigCADYCACAAIAMpA2A3AyAgACADKQNYNwMYIAAgAykDUDcDECAAIAMpA0g3AwggA0EBNgLcASAAIAMpAtwBNwI8IABCBzcDACADQcgAahCnJQwFC0H4gc8AELI7AAtBmILPABCyOwALQYiCzwAQsjsAC0Hogc8AELI7AAsgACACQdgA/AoAAAsgA0HwAWokAA8LQeSHzgBBIEGEiM4AEMskAAu4CAEFfyMAQfABayIDJAAgASgC6ARBCGoQqiVB/wFxIQcCQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAgBBBmsOAgABCAsgAigCKEUNByACKAI8RQ0HIANByABqIAJBCGpB0AD8CgAAIAMoAmhBAUYNAQwGCyACKAIoRQ0GIAIoAjxFDQYgARDqH0UNBiADQcgAaiACQQhqQdAA/AoAACADKAJoQQFGDQEMBAsgAygCbEUNByADKAJwIgRFDQQgA0G4AWoiBSABIAEoAuwEIgIoAkAgAigCRCAEIAMoAnQQnw0gA0EIaiADQcABaigCADYCACADIAMpArgBNwMAIAMoAnxBAUcNASADKAKAAUUNByADKAKEASIERQ0BIAMtAMQBIQYgBSABIAIoAkAgAigCRCAEIAMoAogBEJsMIANBGGogA0HAAWooAgA2AgAgAyADKQK4ATcDECADLQDEASEBIANBIGpBBHIgAxDnFSADQQE2AiAgA0E4aiADQRBqEOcVIAAgB0UiAjoAUyAAIAI6AFIgACAGQX9zQQFxOgBRIAAgAUEBczoAUCAAIAMpAyA3AyggAEEwaiADQShqKQMANwMAIABBOGogA0EwaigCADYCACAAQcQAaiADQTxqKQIANwIAIABBzABqIANBxABqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AjQgACADKQI0NwI8IABCBjcDACADQcgAahCnJQwGCyADKAJsRQ0GIAMoAnAiBEUNAiADQbgBaiIFIAEgASgC7AQiAigCQCACKAJEIAQgAygCdBCfDSADQaABaiADQcABaigCADYCACADIAMpArgBNwOYASADKAJ8QQFHDQEgAygCgAFFDQYgAygChAEiBEUNASADLQDEASEGIAUgASACKAJAIAIoAkQgBCADKAKIARCbDCADQbABaiADQcABaigCADYCACADIAMpArgBNwOoASADLQDEASEBIANByAFqQQRyIANBmAFqEOcVIANBATYCyAEgA0HgAWogA0GoAWoQ5xUgACAHRSICOgBTIAAgAjoAUiAAIAZBf3NBAXE6AFEgACABQQFzOgBQIAAgAykDyAE3AyggAEEwaiADQdABaikDADcDACAAQThqIANB2AFqKAIANgIAIABBxABqIANB5AFqKQIANwIAIABBzABqIANB7AFqKAIANgIAIAAgAykDYDcDICAAIAMpA1g3AxggACADKQNQNwMQIAAgAykDSDcDCCADQQE2AtwBIAAgAykC3AE3AjwgAEIHNwMAIANByABqEKclDAULQfiBzwAQsjsAC0GYgs8AELI7AAtBiILPABCyOwALQeiBzwAQsjsACyAAIAJB2AD8CgAACyADQfABaiQADwtB5IfOAEEgQYSIzgAQyyQAC7sJAgd/AX4jAEGwAmsiBiQAAkACQAJAAkACQAJAAkACQAJAAkAgBQRAIAIpAAghDSACKAAAIQcgBCgCACICIAIoAgAiCEEBajYCACAIQQBIDQkgBiACNgLIASAGIAQpAgQ3AswBAkAgDUIAVwRAIAIgAigCACICQQFrNgIAIAZBADYCACACQQFHDQEgBkHIAWoQ+x4MAQsgBkEIaiAGQdABaigCADYCACAGIAYpAsgBNwMACyADLQAAIgJBAmsOJQgICAgICAgICAgIAwMDAwMDAwEDAQIBAQIDAwMDAwMDAwgICAgDC0EAQQBB1Nj+ABDDIQALIAZB6AFqIAMQxgYgBkEAOwGgAiAGQQA2ApwCIAZBADYChAIgBkEANgL4ASAGIAc2AvQBIAZCBDcC4AEgBkIANwLYASAGQoCAgIDAADcC0AEgBkEANgLIASAFQQJNDQIgBkHsAGpBAkEAQQRBDBCgGCAGKAJwIQUgBigCbEEBRg0DIAYoAnQhB0EAIQIgBSEDA0AgAkEYRwRAIAIgBGoiCkEMaigCACIIIAgoAgAiCUEBajYCACAJQQBIDQkgAiAHaiIJIAg2AgAgCUEEaiAKQRBqKQIANwIAIAJBDGohAiADQQFrIgMNAQsLIAZBAjYCrAIgBiAHNgKoAiAGIAU2AqQCIAZB7ABqIgIgBkHIAWogBkGkAmoQlikMCAsgBkHoAWogAxDGBiAGQQA7AaACIAZBADYCnAIgBkEANgKEAiAGQQA2AvgBIAYgBzYC9AEgBkIENwLgASAGQgA3AtgBIAZCgICAgMAANwLQASAGQQA2AsgBIAZB7ABqIAVBAWsiCkEAQQRBDBCgGCAGKAJwIQcgBigCbEEBRg0DIAYoAnQhCAJAIAdFDQAgBUEMbEEMayEJQQAhAiAHIQMDQCACIAlGDQEgAiAEaiIMQQxqKAIAIgUgBSgCACILQQFqNgIAIAtBAEgNCCACIAhqIgsgBTYCACALQQRqIAxBEGopAgA3AgAgAkEMaiECIANBAWsiAw0ACwsgBiAKNgKsAiAGIAg2AqgCIAYgBzYCpAIgBkHsAGoiAiAGQcgBaiAGQaQCahCWKQwHCyACQQ1rQQdPDQMMBAtBAyAFQeTY/gAQsDsACyAFIAYoAnRBjNX+ABD9LwALIAcgBigCdEGM1f4AEP0vAAsgAkEBRiACQRVGcg0AIAYgAzYCpAIgBkECNgLMASAGQczZ/gA2AsgBIAZCATcC1AEgBkGvAzYCcCAGIAZB7ABqNgLQASAGIAZBpAJqNgJsIAZByAFqQdzZ/gAQ7ywACyAGQegBaiADEMYGIAZBADsBoAIgBkEANgKcAiAGQQA2AoQCIAZBADYC+AEgBiAHNgL0ASAGQgQ3AuABIAZCADcC2AEgBkKAgICAwAA3AtABIAZBADYCyAEgBUEBRwRAIAQoAgwiAiACKAIAIgNBAWo2AgAgA0EASA0BIAYgAjYCpAIgBiAEKQIQNwKoAiAGQewAaiICIAZByAFqIAZBpAJqEPojDAILQQFBAUHs2f4AEMMhCwALIAZBEGogAiAGEK4WIAYgDT4CFCAGQQE2AhAgACABIAZBEGoQyxAgBkGwAmokAAvPCAEKfyMAQTBrIggkACAIIAM2AgwgAigCCCIGQQRqIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkF7TQRAIAogAigCBCIJSw0BIAhBEGoiByACKAIAIgogCSAGIAYgCmoiDSgAAGsQ9jQCQAJAIAdBCBDMIEH//wNxIgwEQCAGIAxqIgxBBGohCyAMQXtLDQUgCSALTw0BIAsgCUHM1f4AELA7AAsgCEEQakEqQQBBAUEBEKAYIAgoAhQhASAIKAIQQQFGDQ4gCCgCGCICQZDd/gBBKvwKAAAgAEEqNgIMIAAgAjYCCCAAIAE2AgQgAEGMgICAeDYCAAwBCyAKIAxqKAAAIQ4gCEEQaiIHIAogCSAGIA0oAABrEPY0AkAgB0EGEMwgQf//A3EiCwRAIAYgC2oiC0EEaiEHIAtBe0sNBiAHIAlNDQEgByAJQczV/gAQsDsACyAIQRBqQS5BAEEBQQEQoBggCCgCFCEBIAgoAhBBAUYNDiAIKAIYIgJBut3+AEEu/AoAACAAQS42AgwgACACNgIIIAAgATYCBCAAQYyAgIB4NgIADAELIAogC2ooAAAhDyAIQRBqIgcgCiAJIAYgDSgAAGsQ9jQCQAJAIAdBChDMIEH//wNxIgcEQCAGIAdqIgZBBGohByAGQXtLDQggByAJSw0JIAYgCmooAAAgBmoiBkEEaiEHIAZBe0sNCiAHIAlLDQsgCEEkaiIHIAogCSAGIAYgCmooAABrEPY0IAhBEGogB0EEEMwgQf//A3EiBwR/IAYgB2oiBiAJSw0NIAYgCmotAAAFQQALEOIbQQIhBgJAIAgoAhAiB0Ht////B2oOAgACAwsgCC0AFCEGDAELQQIhBgsgCyAPaiILIAlLDQsgDCAOaiIMIAlLDQwgBS8BACEFIAogC2ooAAAhByAAQQA2AiAgACAJNgIUIAAgCjYCECAAIAc2AgwgACAJNgIEIAAgCjYCACAAQQA7AEMgACAGOgBCIAAgBTsBQCAAIAE2AjwgACAENgI4IAAgAzYCNCAAIAxBBGo2AhggACALQQRqNgIIIAAgAikCADcCKCAAIAogDGooAAA2AhwgAEEwaiACQQhqKAIANgIADA0LIAAgCCkAFTcABSAAQQxqIAhBHGopAAA3AAAgACAILQAUOgAEIAAgBzYCAAsgAEECOgBEIAMgAygCACIAQQFrNgIAIABBAUcNCyAIQQxqEPgjDAsLIAYgCkHc1f4AELE7AAsgCiAJQdzV/gAQsDsACyAMIAtBzNX+ABCxOwALIAsgB0HM1f4AELE7AAsgBiAHQczV/gAQsTsACyAHIAlBzNX+ABCwOwALIAYgB0Hc1f4AELE7AAsgByAJQdzV/gAQsDsACyAGIAlBzNT+ABCvOwALIAsgCUHM1P4AEK87AAsgDCAJQczU/gAQrzsACyAIQTBqJAAPCyABIAgoAhhBnNX+ABD9LwALkggBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwJCyAEQUBrQaSthgEoAgA2AgAgBEGcrYYBKQIANwM4IARBOGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0GkrYYBKAIANgIAIARBnK2GASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAwsgBCAAKAIQIAJBA3RqKQMANwMIIARBQGtBpK2GASgCADYCACAEQZythgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAILIAQgADYCNCAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBNGo2AhwgBCAEQTBqNgIUDAQLIAQgADYCKAwCCyAEQdAAaiQAIAIPCyAEIAE2AigLIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALkggBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAoLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwJCyAEQUBrQdCshgEoAgA2AgAgBEHIrIYBKQIANwM4IARBOGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAcLIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0HQrIYBKAIANgIAIARByKyGASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAwsgBCAAKAIQIAJBA3RqKQMANwMIIARBQGtB0KyGASgCADYCACAEQcishgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAILIAQgADYCNCAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBNGo2AhwgBCAEQTBqNgIUDAQLIAQgADYCKAwCCyAEQdAAaiQAIAIPCyAEIAE2AigLIARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEEoajYCHCAEIARBNGo2AhQLIARBOGpByJeEARDvLAALwAcBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIsIAIgAEECdiIATw0LIAQgASgCECACQQJ0aigCADYCKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxDMJCECDAoLIARBKGogAxDTHCECDAkLIAAoAgQoAhQhACAEIAI2AiwgAiAAQQJ2IgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAcLIARBOGpB3KyGASgCADYCACAEQdSshgEpAgA3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBKGogAxDSHCECDAILIAQgACgCECACQQJ0ajQCADcDACAEQThqQdyshgEoAgA2AgAgBEHUrIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkECdGo0AgA3AwggBEE4akHcrIYBKAIANgIAIARB1KyGASkCADcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAAsgBEHQAGokACACDwsgBCABNgJMDAELIAQgADYCTAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIgIARBOzYCGCAEIARBFGo2AjggBCAEQcwAajYCHCAEIARBLGo2AhQgBEEwakHIl4QBEO8sAAuSCAEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIwIAIgAEEDdiIATw0JIAQgASgCECACQQN0aikDADcDKCADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKGogAxCeJSECDAwLIARBKGogAxC5HCECDAsLIAAoAgQoAhQhACAEIAI2AjQgAiAAQQN2IgBPDQkgBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCgsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAkLIARBQGtBoKyGASgCADYCACAEQZishgEpAgA3AzggBEE4ahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBwsgBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQshAiAEQRRqEOUQDAULIARBKGogAxC4HCECDAQLIAQgACgCECACQQN0aikDADcDACAEQUBrQaCshgEoAgA2AgAgBEGYrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEIAAoAhAgAkEDdGopAwA3AwggBEFAa0GgrIYBKAIANgIAIARBmKyGASkCADcDOCAEQThqIgAQyQwgBEECNgI8IARB7JyEATYCOCAEQgI3AkQgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AkAgBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAgsgBCAANgI0IARBAjYCPCAEQbiXhAE2AjggBEICNwJEIARBOzYCICAEQTs2AhggBCAEQRRqNgJAIAQgBEE0ajYCHCAEIARBMGo2AhQMBAsgBCAANgIoDAILIARB0ABqJAAgAg8LIAQgATYCKAsgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQShqNgIcIAQgBEE0ajYCFAsgBEE4akHIl4QBEO8sAAvABwEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AiwgAiAAQQJ2IgBPDQsgBCABKAIQIAJBAnRqKAIANgIoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEMwkIQIMCgsgBEEoaiADENMcIQIMCQsgACgCBCgCFCEAIAQgAjYCLCACIABBAnYiAE8NCiAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAnYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMBwsgBEE4akGArYYBKAIANgIAIARB+KyGASkCADcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5CyECIARBFGoQ5RAMAwsgBEEoaiADENIcIQIMAgsgBCAAKAIQIAJBAnRqNAIANwMAIARBOGpBgK2GASgCADYCACAEQfishgEpAgA3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACQQJ0ajQCADcDCCAEQThqQYCthgEoAgA2AgAgBEH4rIYBKQIANwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC5IIAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCQsgBEFAa0GsrIYBKAIANgIAIARBpKyGASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBrKyGASgCADYCACAEQaSshgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgACgCECACQQN0aikDADcDCCAEQUBrQayshgEoAgA2AgAgBEGkrIYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC5IIAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AjAgAiAAQQN2IgBPDQkgBCABKAIQIAJBA3RqKQMANwMoIAMoAggiAEGAgIAQcQ0GIABBgICAIHFFBEAgBEEoaiADEJ4lIQIMDAsgBEEoaiADELkcIQIMCwsgACgCBCgCFCEAIAQgAjYCNCACIABBA3YiAE8NCSAGKAIEIgBFDQIgBEEUaiAAQQhqIAYoAggQihggBCgCFEGTgICAeEcNAyAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCNCACIAFBA3YiAUkNBQwKCyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCQsgBEFAa0G8rYYBKAIANgIAIARBtK2GASkCADcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQA2AkggBEEBNgI8IARB7JuEATYCOCAEQgQ3AkAgAyAAENE5CyECIARBFGoQ5RAMBQsgBEEoaiADELgcIQIMBAsgBCAAKAIQIAJBA3RqKQMANwMAIARBQGtBvK2GASgCADYCACAEQbSthgEpAgA3AzggBEE4aiIAEMkMIARBAjYCPCAEQeychAE2AjggBEICNwJEIARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgJAIAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAMLIAQgACgCECACQQN0aikDADcDCCAEQUBrQbythgEoAgA2AgAgBEG0rYYBKQIANwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC8oHAgp/BX5BfyEHAkAgAUELIAEbIgpBBUkNACAKQQxLBEBBVA8LIApBICADZ2siAUEhIARnayIIIAEgCEkbSQ0AQX9BASAFGyEMIAMgCnYhDkKAgICAgICAgMAAIAOtgCERQT4gCmutIhBCFH0hEiAAIQUgAiEHQQAhAUEBIAp0Ig8hCQNAIAEgBE0EQCADIAcoAgAiCEYEQEEADwUCQCAIRQRAIAVBADsBAAwBCyAIIA5NBEAgBSAMOwEAIAlBAWshCQwBCyARIAitfiITIBCIIhSnIghB//8DcSINQQdNBEAgEyAUQv//A4MgEIZ9IA1BAnRBkPLQAGo1AgAgEoZWIAhqIQgLIAUgCDsBACAIQf//A3EiCCALQf//A3EiCyAIIAtLIg0bIQsgASAGIA0bIQYgCSAIayEJCyAFQQJqIQUgB0EEaiEHIAFBAWohAQwCCwALCwJAQQAgCWsgACAGQQF0aiIBLgEAIgVBAXVOBEAgA0EDbCAKQQFqdiELIARBAWohCEF/IQEgAiEHIAAhBUEAIQkDQAJAAkAgASAERwRAIAcoAgAiBkUEQCAFQQA7AQAMAwsgBiAOTQRAIAUgDDsBAAwCCyAGIAtNBEAgBUEBOwEADAILIAVB/v8DOwEADAILIA8gCWsiBkUNBCALIAMgBm5JBEAgA0EDbCAGQQF0biEGIAghByAAIQEgAiEFA0AgBwRAAkAgAS8BAEH+/wNHDQAgBSgCACIMIAZLDQAgAUEBOwEAIAMgDGshAyAJQQFqIQkLIAdBAWshByABQQJqIQEgBUEEaiEFDAELCyAPIAlrIQYLIAggCUYEQEEAIQVBACEHQQAhAQNAIAEgCEZFBEAgAigCACIDIAcgAyAHSyIDGyEHIAEgBSADGyEFIAJBBGohAiABQQFqIQEMAQsLIAAgBUEBdGoiACAALwEAIAZqOwEADAULIANFBEBBACEBA0AgBkUNBiAAIAFBAXRqIgIuAQAiA0EASgRAIAIgA0EBajsBACAGQQFrIQYLIAFBAWpBACABIARHGyEBDAALAAtCfyAQQgF9hkJ/hSIRIAatIBCGfCADrYAhEkEAIQEDQCABIARLDQUgAC8BAEH+/wNGBEAgESAQiCITIBIgAjUCAH4gEXwiESAQiCIUUQRAQX8PCyAAIBSnIBOnazsBAAsgAEECaiEAIAJBBGohAiABQQFqIQEMAAsACyADIAZrIQMgCUEBaiEJCyABQQFqIQEgB0EEaiEHIAVBAmohBQwACwALIAEgBSAJajsBAAsgCiEHCyAHC78HAgh/CH4jAEHwAGsiBSQAIAFBLGohCSABKAIsIQcCfwJAAkACQAJAAkACfgJAIAAoAiwEQCAAQSxqIQYgB0UNAyAFQRhqIAYQ3DsgBSgCHCEHIAUoAhghBiAFQRBqIAkQ3DsgASgCOCAFKAIUIQkgBSgCECEIIAVBMGogBiAHIAAoAjggAmogBBCHHSADaiEHIAUoAjwhCyAFKAI4IQYgBSgCMCEKIAUoAkAiAg0BQgAMAgtBASAHRQ0HGiAFIAkQ3DsgBUEwaiIAIAUoAgAgBSgCBCABKAI4IANqIAQQ+hMgBUEkaiAAENUJQQEhASAFKAIkQQFHDQMgBSgCKA0GIAUoAiwgBEchAQwGCyAKIAtBA3RqIgAxAAAgBkE/ca2IIQ0gAiAGaiIBQQN2IAFBB3FBAEdqIgNBAk8EQEEIIAZrIQEgA0EBayEDIABBAWohAANAIAAxAAAgAUE/ca2GIA2EIQ0gAEEBaiEAIAFBCGohASADQQFrIgMNAAsLIA1CfyACQT9xrYZCf4WDCyEQIAVBMGogCCAJIAcgBBCHHSAFKAI8IQwgBSgCOCEIIAUoAjAhAwJ+IAUoAkAiAkUEQCAIQT9xrSEPQgAMAQsgAyAMQQN0aiIAMQAAIAhBP3GtIg+IIQ0gAiAIaiIBQQN2IAFBB3FBAEdqIgRBAk8EQEEIIAhrIQEgBEEBayEEIABBAWohAANAIAAxAAAgAUE/ca2GIA2EIQ0gAEEBaiEAIAFBCGohASAEQQFrIgQNAAsLIA1CfyACQT9xrYZCf4WDCyERIAZBP3GtIRJBACEAQQAgCGtBP3GtIRNBACAGa0E/ca0hFEEBIQlBACEBQQEhAgNAAkAgCkUgASALT3JFBEAgCiABQQN0aiIEKQAAIQ0gBgRAIARBCGoxAAAgFIYgDSASiIQhDQsgAUEBaiEBDAELIAJBAXEhB0EAIQJBACEKIBAhDUEBIAdFDQcaCwJAIANFIAAgDE9yRQRAIAMgAEEDdGoiBCkAACEOIAgEQCAEQQhqMQAAIBOGIA4gD4iEIQ4LIABBAWohAAwBCyAJIQdBACEJQQAhAyARIQ5BASAHRQ0HGgsgDSAOUQ0AC0EADAULIAVBCGogBhDcOyAFQTBqIgEgBSgCCCAFKAIMIAAoAjggAmogBBD6EyAFQSRqIAEQ1QlBASEBIAUoAiRBAUcNASAFKAIoDQIgBSgCLCAERyEBDAILIARBAEchAQwCCyAEQQBHIQELIAFBAXMMAQsgAUEBcwsgBUHwAGokAAv6CQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgAtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyABQYHJhwFBBBD7NQwoCyABQYXJhwFBBxD7NQwnCyABQYzJhwFBBBD7NQwmCyABQZDJhwFBBRD7NQwlCyABQZXJhwFBBRD7NQwkCyABQZrJhwFBBRD7NQwjCyABQZ/JhwFBBRD7NQwiCyABQaTJhwFBBhD7NQwhCyABQarJhwFBBhD7NQwgCyABQbDJhwFBBhD7NQwfCyABQbbJhwFBBxD7NQweCyABQb3JhwFBBxD7NQwdCyABQcTJhwFBBxD7NQwcCyACIABBBGo2AgwgAUHsyYcBQQkgAEEBakHMyYcBIAJBDGpB3MmHARCDDwwbCyABQfXJhwFBBhD7NQwaCyABQfvJhwFBBhD7NQwZCyACIABBAWo2AgwgAUGUyocBQQYgAkEMakGEyocBENATDBgLIAIgAEEBajYCDCABQZrKhwFBBiACQQxqQYTKhwEQ0BMMFwsgAiAAQQFqNgIMIAFBoMqHAUEIIAJBDGpBhMqHARDQEwwWCyACIABBAWo2AgwgAUG4yocBQQggAkEMakGoyocBENATDBULIAFBwMqHAUEGEPs1DBQLIAIgAEEEajYCDCABQdjKhwFBDyACQQxqQcjKhwEQ0BMMEwsgAUHnyocBQQsQ+zUMEgsgAUHyyocBQQoQ+zUMEQsgAUH8yocBQQQQ+zUMEAsgAUGAy4cBQQkQ+zUMDwsgAUGJy4cBQQgQ+zUMDgsgAiAAQQRqNgIMIAFBpMuHAUEEIAJBDGpBlMuHARDQEwwNCyACIABBBGo2AgwgAUGoy4cBQQggAkEMakGUy4cBENATDAwLIAIgAEEEajYCDCABQcDLhwFBDSAAQQhqQbDLhwEgAkEMakHIyocBEIMPDAsLIAIgAEEEajYCDCABQc3LhwFBCSACQQxqQZTLhwEQ0BMMCgsgAiAAQQRqNgIMIAFB1suHAUENIAJBDGpBlMuHARDQEwwJCyACIABBBGo2AgwgAUH0y4cBQQYgAkEMakHky4cBENATDAgLIAIgAEEBajYCDCABQZzMhwFBBSAAQQRqQfzLhwEgAkEMakGMzIcBEIMPDAcLIAIgAEEIajYCDCABQcTMhwFBCiAAQQRqQaTMhwEgAkEMakG0zIcBEIMPDAYLIAIgAEECajYCDCABQfDMhwFBCSAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAULIAIgAEECajYCDCABQfnMhwFBCSAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAQLIAIgAEECajYCDCABQYLNhwFBCiAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAMLIAIgAEECajYCDCABQYzNhwFBCiAAQQFqQdDMhwEgAkEMakHgzIcBEIMPDAILIAIgAEEBajYCDCABQajNhwFBAyAAQQRqQbDLhwEgAkEMakGYzYcBEIMPDAELIAIgAEEIajYCDCABQavNhwFBDSAAQQRqQbDLhwEgAkEMakGUy4cBEIMPCyACQRBqJAAL+gkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIALQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAUHc54cBQQQQ+zUMKAsgAUHg54cBQQcQ+zUMJwsgAUHn54cBQQQQ+zUMJgsgAUHr54cBQQUQ+zUMJQsgAUHw54cBQQUQ+zUMJAsgAUH154cBQQUQ+zUMIwsgAUH654cBQQUQ+zUMIgsgAUH/54cBQQYQ+zUMIQsgAUGF6IcBQQYQ+zUMIAsgAUGL6IcBQQYQ+zUMHwsgAUGR6IcBQQcQ+zUMHgsgAUGY6IcBQQcQ+zUMHQsgAUGf6IcBQQcQ+zUMHAsgAiAAQQRqNgIMIAFByOiHAUEJIABBAWpBqOiHASACQQxqQbjohwEQgw8MGwsgAUHR6IcBQQYQ+zUMGgsgAUHX6IcBQQYQ+zUMGQsgAiAAQQFqNgIMIAFB8OiHAUEGIAJBDGpB4OiHARDQEwwYCyACIABBAWo2AgwgAUH26IcBQQYgAkEMakHg6IcBENATDBcLIAIgAEEBajYCDCABQfzohwFBCCACQQxqQeDohwEQ0BMMFgsgAiAAQQFqNgIMIAFBlOmHAUEIIAJBDGpBhOmHARDQEwwVCyABQZzphwFBBhD7NQwUCyACIABBBGo2AgwgAUG06YcBQQ8gAkEMakGk6YcBENATDBMLIAFBw+mHAUELEPs1DBILIAFBzumHAUEKEPs1DBELIAFB2OmHAUEEEPs1DBALIAFB3OmHAUEJEPs1DA8LIAFB5emHAUEIEPs1DA4LIAIgAEEEajYCDCABQYDqhwFBBCACQQxqQfDphwEQ0BMMDQsgAiAAQQRqNgIMIAFBhOqHAUEIIAJBDGpB8OmHARDQEwwMCyACIABBBGo2AgwgAUGc6ocBQQ0gAEEIakGM6ocBIAJBDGpBpOmHARCDDwwLCyACIABBBGo2AgwgAUGp6ocBQQkgAkEMakHw6YcBENATDAoLIAIgAEEEajYCDCABQbLqhwFBDSACQQxqQfDphwEQ0BMMCQsgAiAAQQRqNgIMIAFB0OqHAUEGIAJBDGpBwOqHARDQEwwICyACIABBAWo2AgwgAUH46ocBQQUgAEEEakHY6ocBIAJBDGpB6OqHARCDDwwHCyACIABBCGo2AgwgAUGg64cBQQogAEEEakGA64cBIAJBDGpBkOuHARCDDwwGCyACIABBAmo2AgwgAUHM64cBQQkgAEEBakGs64cBIAJBDGpBvOuHARCDDwwFCyACIABBAmo2AgwgAUHV64cBQQkgAEEBakGs64cBIAJBDGpBvOuHARCDDwwECyACIABBAmo2AgwgAUHe64cBQQogAEEBakGs64cBIAJBDGpBvOuHARCDDwwDCyACIABBAmo2AgwgAUHo64cBQQogAEEBakGs64cBIAJBDGpBvOuHARCDDwwCCyACIABBAWo2AgwgAUGE7IcBQQMgAEEEakGM6ocBIAJBDGpB9OuHARCDDwwBCyACIABBCGo2AgwgAUGH7IcBQQ0gAEEEakGM6ocBIAJBDGpB8OmHARCDDwsgAkEQaiQAC4wJAQN/IwBBkAFrIgMkACADQdQAaiABIAIQkw4gAygCWCEEAkAgAygCVCIFQYqAgIB4RwRAIAAgAykCXDcCCCAAQSBqIANB9ABqKAIANgIAIABBGGogA0HsAGopAgA3AgAgAEEQaiADQeQAaikCADcCACAAIAQ2AgQgACAFNgIADAELIANB1ABqIAFBfyACIARqIgEgASAESRsQtAYgA0EIaiIBIANB4ABqKQIANwMAIAMgAykCWDcDACADKAJUIgJBioCAgHhHBEAgACADKQJoNwIUIABBHGogA0HwAGopAgA3AgAgAEEMaiABKQMANwIAIAAgAykDADcCBCAAIAI2AgAMAQsgA0EYaiABKQMANwMAIAMgAykDADcDECADQdQAaiADQRBqQQQQ3RAgAygCXCECIAMoAlghAQJAIAACfiADKAJUIgRBioCAgHhHBEAgA0GAAWogA0HwAGopAgA3AwAgAyADKQJoNwN4IAMpAmAMAQsgAUEBcUUNAQJAIAJBA3EEQCADIAI2AnAgA0EDNgJsIANBvOT+ADYCaCADQYCAgIB4NgJkIANCBDcCXCADQoSAgIAINwJUDAELQX8gAkEEaiIBIAEgAkkbIgQgAygCECIBKAIETQRAIAEgASgCFEEEaiIENgIUIAEoAggoAgggBE8EQCADQYqAgIB4NgJUDAILIANBiICAgHg2AlQMAQsgA0HUAGogAiAEEL8vCyADQQg2AogBIANBkef+ADYChAEgA0GAgICAeDYCgAEgAyACNgJ8IANBATYCeCADQTBqIANB1ABqIANB+ABqEIEUIAMoAjAiBEGKgICAeEYNASADQYABaiADQcwAaikCADcDACADIAMpAkQ3A3ggAygCOCECIAMoAjQhASADKQI8CzcCDCAAIAI2AgggACABNgIEIAAgBDYCACAAIAMpA3g3AhQgAEEcaiADQYABaikDADcCAAwBCyADIAMpAxg3AiggAyADKQMQNwIgIANB1ABqIANBIGpBBhDdECADKAJcIQIgAygCWCEBAkAgAAJ+IAMoAlQiBEGKgICAeEcEQCADQYABaiADQfAAaikCADcDACADIAMpAmg3A3ggAykCYAwBCyABQQFxRQ0BAkAgAkEBaiIBQX8gARsiBCADKAIgIgEoAgRNBEAgASABKAIUQQFqIgQ2AhQgASgCCCgCCCAETwRAIANBioCAgHg2AlQMAgsgA0GIgICAeDYCVAwBCyADQdQAaiACIAQQvy8LIANBCTYCiAEgA0GZ5/4ANgKEASADQYCAgIB4NgKAASADIAI2AnwgA0EBNgJ4IANBMGogA0HUAGogA0H4AGoQgRQgAygCMCIEQYqAgIB4Rg0BIANBgAFqIANBzABqKQIANwMAIAMgAykCRDcDeCADKAI4IQIgAygCNCEBIAMpAjwLNwIMIAAgAjYCCCAAIAE2AgQgACAENgIAIAAgAykDeDcCFCAAQRxqIANBgAFqKQMANwIADAELIAMoAiAiASABKAIMQQFrNgIMIABBioCAgHg2AgALIANBkAFqJAAL9QkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIAFBgKmAAUEEEPs1DCgLIAFBhKmAAUEHEPs1DCcLIAFBi6mAAUEEEPs1DCYLIAFBj6mAAUEFEPs1DCULIAFBlKmAAUEFEPs1DCQLIAFBmamAAUEFEPs1DCMLIAFBnqmAAUEFEPs1DCILIAFBo6mAAUEGEPs1DCELIAFBqamAAUEGEPs1DCALIAFBr6mAAUEGEPs1DB8LIAFBtamAAUEHEPs1DB4LIAFBvKmAAUEHEPs1DB0LIAFBw6mAAUEHEPs1DBwLIAIgAEEEajYCDCABQeypgAFBCSAAQQFqQcypgAEgAkEMakHcqYABEIMPDBsLIAFB9amAAUEGEPs1DBoLIAFB+6mAAUEGEPs1DBkLIAIgAEEBajYCDCABQZSqgAFBBiACQQxqQYSqgAEQ0BMMGAsgAiAAQQFqNgIMIAFBmqqAAUEGIAJBDGpBhKqAARDQEwwXCyACIABBAWo2AgwgAUGgqoABQQggAkEMakGEqoABENATDBYLIAIgAEEBajYCDCABQbiqgAFBCCACQQxqQaiqgAEQ0BMMFQsgAUHAqoABQQYQ+zUMFAsgAiAAQQRqNgIMIAFB2KqAAUEPIAJBDGpByKqAARDQEwwTCyABQeeqgAFBCxD7NQwSCyABQfKqgAFBChD7NQwRCyABQfyqgAFBBBD7NQwQCyABQYCrgAFBCRD7NQwPCyABQYmrgAFBCBD7NQwOCyACIABBBGo2AgwgAUGkq4ABQQQgAkEMakGUq4ABENATDA0LIAIgAEEEajYCDCABQairgAFBCCACQQxqQZSrgAEQ0BMMDAsgAiAAQQRqNgIMIAFBwKuAAUENIABBCGpBsKuAASACQQxqQciqgAEQgw8MCwsgAiAAQQRqNgIMIAFBzauAAUEJIAJBDGpBlKuAARDQEwwKCyACIABBBGo2AgwgAUHWq4ABQQ0gAkEMakGUq4ABENATDAkLIAIgAEEEajYCDCABQfSrgAFBBiACQQxqQeSrgAEQ0BMMCAsgAiAAQQFqNgIMIAFBnKyAAUEFIABBBGpB/KuAASACQQxqQYysgAEQgw8MBwsgAiAAQQhqNgIMIAFBxKyAAUEKIABBBGpBpKyAASACQQxqQbSsgAEQgw8MBgsgAiAAQQJqNgIMIAFB8KyAAUEJIABBAWpB0KyAASACQQxqQeCsgAEQgw8MBQsgAiAAQQJqNgIMIAFB+ayAAUEJIABBAWpB0KyAASACQQxqQeCsgAEQgw8MBAsgAiAAQQJqNgIMIAFBgq2AAUEKIABBAWpB0KyAASACQQxqQeCsgAEQgw8MAwsgAiAAQQJqNgIMIAFBjK2AAUEKIABBAWpB0KyAASACQQxqQeCsgAEQgw8MAgsgAiAAQQFqNgIMIAFBqK2AAUEDIABBBGpBsKuAASACQQxqQZitgAEQgw8MAQsgAiAAQQhqNgIMIAFBq62AAUENIABBBGpBsKuAASACQQxqQZSrgAEQgw8LIAJBEGokAAv1CQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDigBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoAAsgAUH/3YYBQQQQ+zUMKAsgAUGD3oYBQQcQ+zUMJwsgAUGK3oYBQQQQ+zUMJgsgAUGO3oYBQQUQ+zUMJQsgAUGT3oYBQQUQ+zUMJAsgAUGY3oYBQQUQ+zUMIwsgAUGd3oYBQQUQ+zUMIgsgAUGi3oYBQQYQ+zUMIQsgAUGo3oYBQQYQ+zUMIAsgAUGu3oYBQQYQ+zUMHwsgAUG03oYBQQcQ+zUMHgsgAUG73oYBQQcQ+zUMHQsgAUHC3oYBQQcQ+zUMHAsgAiAAQQRqNgIMIAFB7N6GAUEJIABBAWpBzN6GASACQQxqQdzehgEQgw8MGwsgAUH13oYBQQYQ+zUMGgsgAUH73oYBQQYQ+zUMGQsgAiAAQQFqNgIMIAFBlN+GAUEGIAJBDGpBhN+GARDQEwwYCyACIABBAWo2AgwgAUGa34YBQQYgAkEMakGE34YBENATDBcLIAIgAEEBajYCDCABQaDfhgFBCCACQQxqQYTfhgEQ0BMMFgsgAiAAQQFqNgIMIAFBuN+GAUEIIAJBDGpBqN+GARDQEwwVCyABQcDfhgFBBhD7NQwUCyACIABBBGo2AgwgAUHY34YBQQ8gAkEMakHI34YBENATDBMLIAFB59+GAUELEPs1DBILIAFB8t+GAUEKEPs1DBELIAFB/N+GAUEEEPs1DBALIAFBgOCGAUEJEPs1DA8LIAFBieCGAUEIEPs1DA4LIAIgAEEEajYCDCABQaTghgFBBCACQQxqQZTghgEQ0BMMDQsgAiAAQQRqNgIMIAFBqOCGAUEIIAJBDGpBlOCGARDQEwwMCyACIABBBGo2AgwgAUHA4IYBQQ0gAEEIakGw4IYBIAJBDGpByN+GARCDDwwLCyACIABBBGo2AgwgAUHN4IYBQQkgAkEMakGU4IYBENATDAoLIAIgAEEEajYCDCABQdbghgFBDSACQQxqQZTghgEQ0BMMCQsgAiAAQQRqNgIMIAFB9OCGAUEGIAJBDGpB5OCGARDQEwwICyACIABBAWo2AgwgAUGc4YYBQQUgAEEEakH84IYBIAJBDGpBjOGGARCDDwwHCyACIABBCGo2AgwgAUHE4YYBQQogAEEEakGk4YYBIAJBDGpBtOGGARCDDwwGCyACIABBAmo2AgwgAUHw4YYBQQkgAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwFCyACIABBAmo2AgwgAUH54YYBQQkgAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwECyACIABBAmo2AgwgAUGC4oYBQQogAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwDCyACIABBAmo2AgwgAUGM4oYBQQogAEEBakHQ4YYBIAJBDGpB4OGGARCDDwwCCyACIABBAWo2AgwgAUGo4oYBQQMgAEEEakGw4IYBIAJBDGpBmOKGARCDDwwBCyACIABBCGo2AgwgAUGr4oYBQQ0gAEEEakGw4IYBIAJBDGpBlOCGARCDDwsgAkEQaiQAC/UJAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOKAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygACyABQYDPhwFBBBD7NQwoCyABQYTPhwFBBxD7NQwnCyABQYvPhwFBBBD7NQwmCyABQY/PhwFBBRD7NQwlCyABQZTPhwFBBRD7NQwkCyABQZnPhwFBBRD7NQwjCyABQZ7PhwFBBRD7NQwiCyABQaPPhwFBBhD7NQwhCyABQanPhwFBBhD7NQwgCyABQa/PhwFBBhD7NQwfCyABQbXPhwFBBxD7NQweCyABQbzPhwFBBxD7NQwdCyABQcPPhwFBBxD7NQwcCyACIABBBGo2AgwgAUHsz4cBQQkgAEEBakHMz4cBIAJBDGpB3M+HARCDDwwbCyABQfXPhwFBBhD7NQwaCyABQfvPhwFBBhD7NQwZCyACIABBAWo2AgwgAUGU0IcBQQYgAkEMakGE0IcBENATDBgLIAIgAEEBajYCDCABQZrQhwFBBiACQQxqQYTQhwEQ0BMMFwsgAiAAQQFqNgIMIAFBoNCHAUEIIAJBDGpBhNCHARDQEwwWCyACIABBAWo2AgwgAUG40IcBQQggAkEMakGo0IcBENATDBULIAFBwNCHAUEGEPs1DBQLIAIgAEEEajYCDCABQdjQhwFBDyACQQxqQcjQhwEQ0BMMEwsgAUHn0IcBQQsQ+zUMEgsgAUHy0IcBQQoQ+zUMEQsgAUH80IcBQQQQ+zUMEAsgAUGA0YcBQQkQ+zUMDwsgAUGJ0YcBQQgQ+zUMDgsgAiAAQQRqNgIMIAFBpNGHAUEEIAJBDGpBlNGHARDQEwwNCyACIABBBGo2AgwgAUGo0YcBQQggAkEMakGU0YcBENATDAwLIAIgAEEEajYCDCABQcDRhwFBDSAAQQhqQbDRhwEgAkEMakHI0IcBEIMPDAsLIAIgAEEEajYCDCABQc3RhwFBCSACQQxqQZTRhwEQ0BMMCgsgAiAAQQRqNgIMIAFB1tGHAUENIAJBDGpBlNGHARDQEwwJCyACIABBBGo2AgwgAUH00YcBQQYgAkEMakHk0YcBENATDAgLIAIgAEEBajYCDCABQZzShwFBBSAAQQRqQfzRhwEgAkEMakGM0ocBEIMPDAcLIAIgAEEIajYCDCABQcTShwFBCiAAQQRqQaTShwEgAkEMakG00ocBEIMPDAYLIAIgAEECajYCDCABQfDShwFBCSAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAULIAIgAEECajYCDCABQfnShwFBCSAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAQLIAIgAEECajYCDCABQYLThwFBCiAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAMLIAIgAEECajYCDCABQYzThwFBCiAAQQFqQdDShwEgAkEMakHg0ocBEIMPDAILIAIgAEEBajYCDCABQajThwFBAyAAQQRqQbDRhwEgAkEMakGY04cBEIMPDAELIAIgAEEIajYCDCABQavThwFBDSAAQQRqQbDRhwEgAkEMakGU0YcBEIMPCyACQRBqJAAL9QkBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4oAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKAALIAFBn+GHAUEEEPs1DCgLIAFBo+GHAUEHEPs1DCcLIAFBquGHAUEEEPs1DCYLIAFBruGHAUEFEPs1DCULIAFBs+GHAUEFEPs1DCQLIAFBuOGHAUEFEPs1DCMLIAFBveGHAUEFEPs1DCILIAFBwuGHAUEGEPs1DCELIAFByOGHAUEGEPs1DCALIAFBzuGHAUEGEPs1DB8LIAFB1OGHAUEHEPs1DB4LIAFB2+GHAUEHEPs1DB0LIAFB4uGHAUEHEPs1DBwLIAIgAEEEajYCDCABQYzihwFBCSAAQQFqQezhhwEgAkEMakH84YcBEIMPDBsLIAFBleKHAUEGEPs1DBoLIAFBm+KHAUEGEPs1DBkLIAIgAEEBajYCDCABQbTihwFBBiACQQxqQaTihwEQ0BMMGAsgAiAAQQFqNgIMIAFBuuKHAUEGIAJBDGpBpOKHARDQEwwXCyACIABBAWo2AgwgAUHA4ocBQQggAkEMakGk4ocBENATDBYLIAIgAEEBajYCDCABQdjihwFBCCACQQxqQcjihwEQ0BMMFQsgAUHg4ocBQQYQ+zUMFAsgAiAAQQRqNgIMIAFB+OKHAUEPIAJBDGpB6OKHARDQEwwTCyABQYfjhwFBCxD7NQwSCyABQZLjhwFBChD7NQwRCyABQZzjhwFBBBD7NQwQCyABQaDjhwFBCRD7NQwPCyABQanjhwFBCBD7NQwOCyACIABBBGo2AgwgAUGx44cBQQQgAkEMakG44IcBENATDA0LIAIgAEEEajYCDCABQbXjhwFBCCACQQxqQbjghwEQ0BMMDAsgAiAAQQRqNgIMIAFB0OOHAUENIABBCGpBwOOHASACQQxqQejihwEQgw8MCwsgAiAAQQRqNgIMIAFB3eOHAUEJIAJBDGpBuOCHARDQEwwKCyACIABBBGo2AgwgAUHm44cBQQ0gAkEMakG44IcBENATDAkLIAIgAEEEajYCDCABQYTkhwFBBiACQQxqQfTjhwEQ0BMMCAsgAiAAQQFqNgIMIAFBrOSHAUEFIABBBGpBjOSHASACQQxqQZzkhwEQgw8MBwsgAiAAQQhqNgIMIAFB1OSHAUEKIABBBGpBtOSHASACQQxqQcTkhwEQgw8MBgsgAiAAQQJqNgIMIAFB8OSHAUEJIABBAWpB4OSHASACQQxqQajghwEQgw8MBQsgAiAAQQJqNgIMIAFB+eSHAUEJIABBAWpB4OSHASACQQxqQajghwEQgw8MBAsgAiAAQQJqNgIMIAFBguWHAUEKIABBAWpB4OSHASACQQxqQajghwEQgw8MAwsgAiAAQQJqNgIMIAFBjOWHAUEKIABBAWpB4OSHASACQQxqQajghwEQgw8MAgsgAiAAQQFqNgIMIAFBqOWHAUEDIABBBGpBwOOHASACQQxqQZjlhwEQgw8MAQsgAiAAQQhqNgIMIAFBq+WHAUENIABBBGpBwOOHASACQQxqQbjghwEQgw8LIAJBEGokAAuGCAEDfyMAQdAAayILJAAgCyAANgJIIAsgADYCRCALIAAgAWpBBGs2AkxBun8hAAJAIAFBBUkNACALQSxqIAIgAyAJQQFrIgBqIgwtAAAQhx8gC0EcaiAEIAAgBWoiAS0AABCHHyALQQxqIAYgACAHaiIELQAAEIcfIAggAEEDdGoiAi8BBCEAIAsgBC0AAEHwltEAai0AACIENgJAIAsgACAEQQJ0QeCX0QBqKAIAcTYCPCALQTxqIgAQiyYgCyALKAJAIgQgDC0AAEGgl9EAai0AACIGajYCQCALIAsoAjwgBkECdEHgl9EAaigCACACLwEGcSAEdHI2AjwgABCLJgJ/IAoEQEEYIQBBACEGAkAgAS0AACIBQRhJBEAgASEADAELIAFBGEYNACALIAsoAkAiBCABQRhrIgZqNgJAIAsgCygCPCAGQQJ0QeCX0QBqKAIAIAIoAgBxIAR0cjYCPCALQTxqEIsmCyACKAIAIAZ2DAELIAEtAAAhACACKAIACyEBIAsgCygCQCICIABqNgJAIAsgCygCPCAAQQJ0QeCX0QBqKAIAIAFxIAJ0cjYCPCAJQQJrIQAgCUEDdCAIakEQayEBIAtBPGoQiyYDQCAAIAlJBEAgACAHai0AACEGIAAgA2otAAAhDCALQTxqIgQgC0EcaiAAIAVqLQAAIgIQ4iUgBCALQSxqIAwQ4iUgBBCLJiAEIAtBDGogBhDiJSAGQfCW0QBqLQAAIQggBBCLJiALIAggCygCQCINaiIGNgJAIAsgCygCPCAIQQJ0QeCX0QBqKAIAIAFBBGovAQBxIA10ciINNgI8IAggDEGgl9EAai0AACIMakEZTwRAIAQQiyYgCygCPCENIAsoAkAhBgsgCyAGIAxqNgJAIAsgDEECdEHgl9EAaigCACABQQZqLwEAcSAGdCANcjYCPCALQTxqEIsmAn8gCgRAQQAhBgJAIAJBGEkEQCACIQgMAQtBGCEIIAJBGEYNACALIAsoAkAiBCACQRhrIgZqNgJAIAsgCygCPCAGQQJ0QeCX0QBqKAIAIAEoAgBxIAR0cjYCPCALQTxqEIsmCyABKAIAIAZ2DAELIAIhCCABKAIACyECIAsgCygCQCIEIAhqNgJAIAsgCygCPCAIQQJ0QeCX0QBqKAIAIAJxIAR0cjYCPCABQQhrIQEgAEEBayEAIAtBPGoQiyYMAQsLIAtBPGoiACALQSxqENY1IAAgC0EcahDWNSAAIAtBDGoQ1jUgCyALKAJAIgFBAWo2AkAgCyALKAI8QQEgAXRyNgI8IAAQiyYgCygCSCIAIAsoAkxJBEAgACALKAJEayALKAJAQQBHaiIADQELQbp/IQALIAtB0ABqJAAgAAv9JwIQfwx+IwBBgAZrIgUkACABKAKMASEDIAFBgICAgHg2AowBAkACQAJAIANBgICAgHhHBEAgBUEYaiABQZgBaikCADcCACAFIAM2AgwgBSABKQKQATcCECAFQYgFaiEDIwBB0ABrIgckAAJAAkACQAJAAkACQAJAAkAgAS0AZEUEQCABKAJgIgggASgCIEYNAkEoIQIgB0EoakEoQQBBAUEBEKAYIAcoAiwhASAHKAIoQQFGDQUgBygCMCIEQZTBwwBBKPwKAAAMAQtBJSECIAdBKGpBJUEAQQFBARCgGCAHKAIsIQEgBygCKEEBRg0DIAcoAjAiBEG8wcMAQSX8CgAACyADIAI2AhQgAyAENgIQIAMgATYCDCADQQA2AgggA0ICNwMADAELIAcgCDYCDCAIQYCAAk8EQCAHQQM2AiwgB0HswMMANgIoIAdCAjcCNCAHQTs2AkwgB0HNATYCRCAHQaTAwwA2AkAgByAHQUBrNgIwIAcgB0EMajYCSCAHQRBqQQRyIAdBKGoQmQ4gAyAHKQEWNwEOIANBFmogB0EeaikBADcBACADQR5qIAdBJmovAQA7AQAgAyAHLwEUOwEMIANBADYCCCADQgI3AwAMAQsgASAIQQFqNgJgIAEoAlwiCS0AnAEhAiABKAJYIgYgBigCACIEQQFqNgIAIARBAEgNAyAJIAkoAgAiBEEBajYCACAEQQBIDQNBFEEEEK02IgRFDQQgBCACOgAQIAQgAUEYajYCDCAEIAFBPGo2AgggBCABQTBqNgIEIAQgAUEkajYCACMAQRBrIgIkACABNQIUIRIgAkEEaiINIAZBCGooAggiCkEAQQhBwAIQoBggAigCCCELAkACQAJAAkAgAigCBEEBRwRAIAIoAgwhDyANIApBAEEEQQwQoBggAigCCCEOIAIoAgRBAUYNASACKAIMIRAgDSAKQQBBBEHMABCgGCACKAIIIQwgAigCBEEBRg0CIAIoAgwhESANIApBAEEEQRgQoBggAigCCCENIAIoAgRBAUYNAyACKAIMIQogAyABNgJoIAMgCTYCZCADIAY2AmAgA0IANwJsIANCADcDACADQgA3AxAgA0EYakIANwMAIAMgCDsBdCADQQA2AlwgAyAKNgJYIAMgDTYCVCADQQA2AlAgAyARNgJMIAMgDDYCSCADQQA2AkQgAyAQNgJAIAMgDjYCPCADQQA2AjggAyAPNgI0IAMgCzYCMCADQdS/wwA2AiwgAyAENgIoIAMgEjcDICACQRBqJAAMBAsgCyACKAIMQYDFwwAQ/S8ACyAOIAIoAgxBkMXDABD9LwALIAwgAigCDEGgxcMAEP0vAAsgDSACKAIMQbDFwwAQ/S8ACwsgB0HQAGokAAwECyABIAcoAjBB8MXDABD9LwALIAEgBygCMEHwxcMAEP0vCwALQQRBFBCjPQALIAVB+ARqIgEgBUGYBWopAwA3AwAgBUGABWoiAyAFQaAFaikDADcDACAFIAUpA5AFNwPwBCAFKQOIBSISQgJRBEAgACAFKQPwBDcDACAAQRBqIAMpAwA3AwAgAEEIaiABKQMANwMAIAVBDGoQ7ysMBAsgBUFAayAFQagFakHYAPwKAAAgBUEwaiAFQfgEaiIBKQMANwMAIAVBOGogBUGABWoiAykDADcDACAFIBI3AyAgBSAFKQPwBDcDKCADIAVBHGooAgA2AgAgASAFQRRqKQIANwMAIAUgBSkCDDcD8AQgBUGIBWogBUHwBGoQgiAgBSgClAUhAyAFKAKQBSEBIAUoAowFIQcgBSgCiAUiAkEIRwRAIAAgBSkDmAU3AxAgACADNgIMIAAgATYCCCAAIAc2AgQgACACNgIADAMLIAUgBzYC+AQgBSABNgLwBCAFIAEgA0HQA2xqIgc2AvwEIANFDQEgBUGgAWohDgNAAkAgASkDACISQgJSBEAgBSASNwOYASAOIAFBCGpByAP8CgAAIwBBwANrIgMkACADIAVBmAFqIgJBwAP8CgAAIAVBiAVqIQggAkHAA2oiDSEEQgAhEyMAQZAOayICJAACQAJAAkACQAJAIAVBIGoiCSgCbCAJKAI4RwRAIAJB0ApqQSVBAEEBQQEQoBggAigC1AohCSACKALQCkEBRg0EIAIoAtgKIgRB2cTDAEEl/AoAACAIQSU2AgwMAQsgCRDcHiIGRQRAIAJB0ApqQS1BAEEBQQEQoBggAigC1AohCSACKALQCkEBRg0EIAIoAtgKIgRBrMTDAEEt/AoAACAIQS02AgwMAQsgAiAGNgIMIAJBEGoiBiADQcAC/AoAACACIAYQhzw2ApAIIAIgAigCDEEIajYC0AoCQCACQZAIaiACQdAKaiIGEMwSRQRAIAkoAmg1AhQhHCACKQP4ASESIAYgBCACKQMoIAIpA4gCIhQgAikDICIVpxsiHRDiHCACKALQCgRAIAJBpAhqIAJB6ApqKQMAIhI3AgAgAkGcCGogAkHgCmopAwAiHDcCACACIAIpA9gKIhM3ApQIIAhBEGogEjcCACAIQQhqIBw3AgAgCCATNwIADAILIAJBkAhqIgQgAkHQCmoiBkEEckEk/AoAACACQeACaiAEQST8CgAAIAIgEjcD2AIgAiASNwPQAiACQdACaiEKIwBBoMAAayIEJAAgBEEANgKMQCAEQoDAADcChEAgBCAENgKAQCAJQegAaigCACEMA0ACQCAEQZDAAGogCiAEQYBAaxCvFAJAIAQtAJBAIgtBBEYNAANAAkACQAJAAkACQCALQQFrDgMAAgEECyAELQCRQEEjRw0DDAILIAQoApRALQAIQSNGDQEMAgsgBCgClEAtAAhBI0cNAQsgBCAEKQOQQDcDmEAgBEGYwABqELkuIARBkMAAaiAKIARBgEBrEK8UIAQtAJBAIgtBBEcNAQwCCwsgBiAEKQOQQDcCBCAGQQE2AgAMAQsgBCgCiEAiC0UEQCAGQQA2AgAgBiATNwMIDAELIARBmMAAaiAMIAQoAoBAIAsQqBogBC0AmEBBBEcEQCAEKQOYQCETIAZBATYCACAGIBM3AgQFIARBADYCiEAgEyALrXwhEwwCCwsLIARBoMAAaiQAAkAgAigC0ApBAUYEQCACIAIpAtQKNwPQCiAIIAYQgSsMAQsgAikD2AogElEEQCACQfgEaiIEIAJBEGoiBhDcLRCiHSACIAIpA+ABNwPIBiACQZAIaiIKIAJBkAJqENYeIAJB0ApqIAQgChCXKiACIAIpA/gBIhc3A7gMIAIpA9AKIRMgAikD2AohFiACQcgEaiACQfAKakEw/AoAACACQcgDaiACQbALakGAAfwKAAAgAkGIA2ogAkHQDGpBwAD8CgAAIBQgHX0gHHwhFCACKQNoIRggAikDYCEZIAIpA/ABIRogAikDgAIhGwJAIAYQ2jQiBEUEQCAcIRIMAQsgAiAcNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBClHSACQZAIaiACQdAKaiAMEIgrIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDbNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBClHSACQZAIaiACQdAKaiAMEIkrIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDYNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBCgBCACQZAIaiACQdAKaiAMEKAsIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgAkEQahDZNCIEBEAgAiASNwPoCiACIBU3A+AKIAIgFjcD2AogAiATNwPQCiACQfAKaiACQcgEaiIGQTD8CgAAIAIgGDcDqAsgAiAZNwOgCyACQbALaiACQcgDaiIKQYAB/AoAACACIBQ3A8gMIAIgGzcDwAwgAiAXNwO4DCACIBo3A7AMIAJB0AxqIAJBiANqIgtBwAD8CgAAIAJBuAdqIgwgBBC1FiACQZAIaiACQdAKaiAMENUnIAIpA5AIIRMgAikDmAghFiACKQOgCCEVIAIpA6gIIRIgBiACQbAIakEw/AoAACACKQPoCCEYIAIpA+AIIRkgCiACQfAIakGAAfwKAAAgAikDiAohFCACKQOACiEbIAIpA/gJIRcgAikD8AkhGiALIAJBkApqQcAA/AoAAAsgE0ICUQRAIAggEjcDECAIIBU3AwggCCAWNwMADAILIAMgEjcDGCADIBU3AxAgAyAWNwMIIAMgEzcDACADQSBqIAJByARqQTD8CgAAIAMgGDcDWCADIBk3A1AgA0HgAGogAkHIA2pBgAH8CgAAIAMgFDcD+AEgAyAbNwPwASADIBc3A+gBIAMgGjcD4AEgA0GAAmogAkGIA2pBwAD8CgAAAkAgAygCwAJBgICAgHhGDQAgAygCyAIiBkUNACADKALEAiEEIAZBGGwhBiAcIB19IRIDQCAEIBIgBCkDAHw3AwAgBEEYaiEEIAZBGGsiBg0ACwsgCSgCaCEKQRxBBBCtNiIERQRAQQRBHBCjPQALIAQgCTYCGCACQdAKaiIGQeTBwwA2AgggBiAENgIEIAYgCjYCACAEIAlB1ABqNgIUIAQgCUHIAGo2AhAgBCAJQTxqNgIMIAQgCUEwajYCCCAEIAlBGGo2AgQgBCAJQRBqNgIAIAIoAtgKIQQgAigC1AohCSAGIANBwAP8CgAAIAggCSAEIAYQ0ycgAkHQAmoQ9yogAkEQahDYEiACKAIMIgQgBCgCACIEQQFrNgIAIARBAUcNBiACQQxqENkhDAYLIAhBBGoQ9h8gCEEANgIACyACQdACahD3KgwBCyACIAJBEGoQhzw2ArgHIAJBAjYC1AogAkGcxMMANgLQCiACQgI3AtwKIAJBzgE2ApwIIAJBzwE2ApQIIAIgAkGQCGo2AtgKIAIgAkG4B2o2ApgIIAIgAkEMajYCkAggCEEEaiACQdAKahCZDiAIQQA2AgALIAJBEGoQ2BIgAigCDCIEIAQoAgAiBEEBazYCACAEQQFHDQEgAkEMahDZIQwBCyAIIAQ2AgggCCAJNgIEIAhBADYCACADENgSCyADQegCahCWMCADQfQCahDmJiADQcACahC9LgsgAkGQDmokAAwBCyAJIAIoAtgKQfDFwwAQ/S8ACyANENQnIA0Q7jsgA0HAA2okACAFKAKIBSIDQQhGDQEgACAFKQKMBTcCBCAAQQxqIAVBlAVqKQIANwIAIABBFGogBUGcBWooAgA2AgAgBSABQdADajYC9AQgACADNgIAIAVB8ARqEJoTDAULIAFB0ANqIQEMAwsgAUHQA2oiASAHRw0ACyAHIQEMAQsgAEEINgIADAILIAUgATYC9AQgBUHwBGoiARCaEyAFQYgFaiIDIAVBIGpB+AD8CgAAIAEgAxDKAiAFKAL0BCEBIAUoAvAEIgNBCEcEQCAAIAUpA/gENwMIIABBEGogBUGABWopAwA3AwAgACABNgIEIAAgAzYCAAwCCyAFIAE2AuwEIAEgASgCACIBQQFrNgIAIAFBAUYEQCAFQewEahDuHQsgAEEINgIADAELIAUoAoABIgAgACgCACIAQQFrNgIAIABBAUYEQCAFQYABahCGHwsgBSgChAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBhAFqEK4gCwJAIAUoApABIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAVBkAFqEO4dCyAFQdAAaiIAEJ8sIAAQ8zsgBUHcAGoiABCGKSAAEOg7IAVB6ABqIgAQ1x4gAEEEQcwAEOAeIAVB9ABqIgAQ5ScgAEEEQRgQ4B4gBSgCSCIARQ0AIAUoAkwiASgCACIDBEAgACADEQMACyABKAIEIgNFDQAgACADIAEoAggQ+DoLIAVBgAZqJAAL/icCEH8MfiMAQYAGayIFJAAgASgClAEhAyABQYCAgIB4NgKUAQJAAkACQCADQYCAgIB4RwRAIAVBGGogAUGgAWopAgA3AgAgBSADNgIMIAUgASkCmAE3AhAgBUGIBWohAyMAQdAAayIHJAACQAJAAkACQAJAAkACQAJAIAEtAGxFBEAgASgCaCIIIAEoAihGDQJBKCECIAdBKGpBKEEAQQFBARCgGCAHKAIsIQEgBygCKEEBRg0FIAcoAjAiBEGUwcMAQSj8CgAADAELQSUhAiAHQShqQSVBAEEBQQEQoBggBygCLCEBIAcoAihBAUYNAyAHKAIwIgRBvMHDAEEl/AoAAAsgAyACNgIUIAMgBDYCECADIAE2AgwgA0EANgIIIANCAjcDAAwBCyAHIAg2AgwgCEGAgAJPBEAgB0EDNgIsIAdB7MDDADYCKCAHQgI3AjQgB0E7NgJMIAdBzQE2AkQgB0GkwMMANgJAIAcgB0FAazYCMCAHIAdBDGo2AkggB0EQakEEciAHQShqEJkOIAMgBykBFjcBDiADQRZqIAdBHmopAQA3AQAgA0EeaiAHQSZqLwEAOwEAIAMgBy8BFDsBDCADQQA2AgggA0ICNwMADAELIAEgCEEBajYCaCABKAJkIgktAJwBIQIgASgCYCIGIAYoAgAiBEEBajYCACAEQQBIDQMgCSAJKAIAIgRBAWo2AgAgBEEASA0DQRRBBBCtNiIERQ0EIAQgAjoAECAEIAFBIGo2AgwgBCABQcQAajYCCCAEIAFBOGo2AgQgBCABQSxqNgIAIwBBEGsiAiQAIAE1AhwhEiACQQRqIg0gBkEIaigCCCIKQQBBCEHAAhCgGCACKAIIIQsCQAJAAkACQCACKAIEQQFHBEAgAigCDCEPIA0gCkEAQQRBDBCgGCACKAIIIQ4gAigCBEEBRg0BIAIoAgwhECANIApBAEEEQcwAEKAYIAIoAgghDCACKAIEQQFGDQIgAigCDCERIA0gCkEAQQRBGBCgGCACKAIIIQ0gAigCBEEBRg0DIAIoAgwhCiADIAE2AmggAyAJNgJkIAMgBjYCYCADQgA3AmwgA0IANwMAIANCADcDECADQRhqQgA3AwAgAyAIOwF0IANBADYCXCADIAo2AlggAyANNgJUIANBADYCUCADIBE2AkwgAyAMNgJIIANBADYCRCADIBA2AkAgAyAONgI8IANBADYCOCADIA82AjQgAyALNgIwIANBxL/DADYCLCADIAQ2AiggAyASNwMgIAJBEGokAAwECyALIAIoAgxBgMXDABD9LwALIA4gAigCDEGQxcMAEP0vAAsgDCACKAIMQaDFwwAQ/S8ACyANIAIoAgxBsMXDABD9LwALCyAHQdAAaiQADAQLIAEgBygCMEHwxcMAEP0vAAsgASAHKAIwQfDFwwAQ/S8LAAtBBEEUEKM9AAsgBUH4BGoiASAFQZgFaikDADcDACAFQYAFaiIDIAVBoAVqKQMANwMAIAUgBSkDkAU3A/AEIAUpA4gFIhJCAlEEQCAAIAUpA/AENwMAIABBEGogAykDADcDACAAQQhqIAEpAwA3AwAgBUEMahDvKwwECyAFQUBrIAVBqAVqQdgA/AoAACAFQTBqIAVB+ARqIgEpAwA3AwAgBUE4aiAFQYAFaiIDKQMANwMAIAUgEjcDICAFIAUpA/AENwMoIAMgBUEcaigCADYCACABIAVBFGopAgA3AwAgBSAFKQIMNwPwBCAFQYgFaiAFQfAEahCCICAFKAKUBSEDIAUoApAFIQEgBSgCjAUhByAFKAKIBSICQQhHBEAgACAFKQOYBTcDECAAIAM2AgwgACABNgIIIAAgBzYCBCAAIAI2AgAMAwsgBSAHNgL4BCAFIAE2AvAEIAUgASADQdADbGoiBzYC/AQgA0UNASAFQaABaiEOA0ACQCABKQMAIhJCAlIEQCAFIBI3A5gBIA4gAUEIakHIA/wKAAAjAEHAA2siAyQAIAMgBUGYAWoiAkHAA/wKAAAgBUGIBWohCCACQcADaiINIQRCACETIwBBkA5rIgIkAAJAAkACQAJAAkAgBUEgaiIJKAJsIAkoAjhHBEAgAkHQCmpBJUEAQQFBARCgGCACKALUCiEJIAIoAtAKQQFGDQQgAigC2AoiBEHZxMMAQSX8CgAAIAhBJTYCDAwBCyAJENweIgZFBEAgAkHQCmpBLUEAQQFBARCgGCACKALUCiEJIAIoAtAKQQFGDQQgAigC2AoiBEGsxMMAQS38CgAAIAhBLTYCDAwBCyACIAY2AgwgAkEQaiIGIANBwAL8CgAAIAIgBhCHPDYCkAggAiACKAIMQQhqNgLQCgJAIAJBkAhqIAJB0ApqIgYQzBJFBEAgCSgCaDUCHCEcIAIpA/gBIRIgBiAEIAIpAyggAikDiAIiFCACKQMgIhWnGyIdEOIcIAIoAtAKBEAgAkGkCGogAkHoCmopAwAiEjcCACACQZwIaiACQeAKaikDACIcNwIAIAIgAikD2AoiEzcClAggCEEQaiASNwIAIAhBCGogHDcCACAIIBM3AgAMAgsgAkGQCGoiBCACQdAKaiIGQQRyQST8CgAAIAJB4AJqIARBJPwKAAAgAiASNwPYAiACIBI3A9ACIAJB0AJqIQojAEGgwABrIgQkACAEQQA2AoxAIARCgMAANwKEQCAEIAQ2AoBAIAlB6ABqKAIAIQwDQAJAIARBkMAAaiAKIARBgEBrEK8UAkAgBC0AkEAiC0EERg0AA0ACQAJAAkACQAJAIAtBAWsOAwACAQQLIAQtAJFAQSNHDQMMAgsgBCgClEAtAAhBI0YNAQwCCyAEKAKUQC0ACEEjRw0BCyAEIAQpA5BANwOYQCAEQZjAAGoQuS4gBEGQwABqIAogBEGAQGsQrxQgBC0AkEAiC0EERw0BDAILCyAGIAQpA5BANwIEIAZBATYCAAwBCyAEKAKIQCILRQRAIAZBADYCACAGIBM3AwgMAQsgBEGYwABqIAwgBCgCgEAgCxCnGiAELQCYQEEERwRAIAQpA5hAIRMgBkEBNgIAIAYgEzcCBAUgBEEANgKIQCATIAutfCETDAILCwsgBEGgwABqJAACQCACKALQCkEBRgRAIAIgAikC1Ao3A9AKIAggBhCBKwwBCyACKQPYCiASUQRAIAJB+ARqIgQgAkEQaiIGENwtEKIdIAIgAikD4AE3A8gGIAJBkAhqIgogAkGQAmoQ1h4gAkHQCmogBCAKEJcqIAIgAikD+AEiFzcDuAwgAikD0AohEyACKQPYCiEWIAJByARqIAJB8ApqQTD8CgAAIAJByANqIAJBsAtqQYAB/AoAACACQYgDaiACQdAMakHAAPwKAAAgFCAdfSAcfCEUIAIpA2ghGCACKQNgIRkgAikD8AEhGiACKQOAAiEbAkAgBhDaNCIERQRAIBwhEgwBCyACIBw3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKUdIAJBkAhqIAJB0ApqIAwQiCsgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENs0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKUdIAJBkAhqIAJB0ApqIAwQiSsgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENg0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEEKAEIAJBkAhqIAJB0ApqIAwQoCwgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyACQRBqENk0IgQEQCACIBI3A+gKIAIgFTcD4AogAiAWNwPYCiACIBM3A9AKIAJB8ApqIAJByARqIgZBMPwKAAAgAiAYNwOoCyACIBk3A6ALIAJBsAtqIAJByANqIgpBgAH8CgAAIAIgFDcDyAwgAiAbNwPADCACIBc3A7gMIAIgGjcDsAwgAkHQDGogAkGIA2oiC0HAAPwKAAAgAkG4B2oiDCAEELUWIAJBkAhqIAJB0ApqIAwQ1ScgAikDkAghEyACKQOYCCEWIAIpA6AIIRUgAikDqAghEiAGIAJBsAhqQTD8CgAAIAIpA+gIIRggAikD4AghGSAKIAJB8AhqQYAB/AoAACACKQOICiEUIAIpA4AKIRsgAikD+AkhFyACKQPwCSEaIAsgAkGQCmpBwAD8CgAACyATQgJRBEAgCCASNwMQIAggFTcDCCAIIBY3AwAMAgsgAyASNwMYIAMgFTcDECADIBY3AwggAyATNwMAIANBIGogAkHIBGpBMPwKAAAgAyAYNwNYIAMgGTcDUCADQeAAaiACQcgDakGAAfwKAAAgAyAUNwP4ASADIBs3A/ABIAMgFzcD6AEgAyAaNwPgASADQYACaiACQYgDakHAAPwKAAACQCADKALAAkGAgICAeEYNACADKALIAiIGRQ0AIAMoAsQCIQQgBkEYbCEGIBwgHX0hEgNAIAQgEiAEKQMAfDcDACAEQRhqIQQgBkEYayIGDQALCyAJKAJoIQpBHEEEEK02IgRFBEBBBEEcEKM9AAsgBCAJNgIYIAJB0ApqIgZB9MHDADYCCCAGIAQ2AgQgBiAKNgIAIAQgCUHUAGo2AhQgBCAJQcgAajYCECAEIAlBPGo2AgwgBCAJQTBqNgIIIAQgCUEYajYCBCAEIAlBEGo2AgAgAigC2AohBCACKALUCiEJIAYgA0HAA/wKAAAgCCAJIAQgBhDTJyACQdACahD3KiACQRBqENgSIAIoAgwiBCAEKAIAIgRBAWs2AgAgBEEBRw0GIAJBDGoQ2SEMBgsgCEEEahD2HyAIQQA2AgALIAJB0AJqEPcqDAELIAIgAkEQahCHPDYCuAcgAkECNgLUCiACQZzEwwA2AtAKIAJCAjcC3AogAkHOATYCnAggAkHPATYClAggAiACQZAIajYC2AogAiACQbgHajYCmAggAiACQQxqNgKQCCAIQQRqIAJB0ApqEJkOIAhBADYCAAsgAkEQahDYEiACKAIMIgQgBCgCACIEQQFrNgIAIARBAUcNASACQQxqENkhDAELIAggBDYCCCAIIAk2AgQgCEEANgIAIAMQ2BILIANB6AJqEJYwIANB9AJqEOYmIANBwAJqEL0uCyACQZAOaiQADAELIAkgAigC2ApB8MXDABD9LwALIA0Q1CcgDRDuOyADQcADaiQAIAUoAogFIgNBCEYNASAAIAUpAowFNwIEIABBDGogBUGUBWopAgA3AgAgAEEUaiAFQZwFaigCADYCACAFIAFB0ANqNgL0BCAAIAM2AgAgBUHwBGoQmhMMBQsgAUHQA2ohAQwDCyABQdADaiIBIAdHDQALIAchAQwBCyAAQQg2AgAMAgsgBSABNgL0BCAFQfAEaiIBEJoTIAVBiAVqIgMgBUEgakH4APwKAAAgASADEMoCIAUoAvQEIQEgBSgC8AQiA0EIRwRAIAAgBSkD+AQ3AwggAEEQaiAFQYAFaikDADcDACAAIAE2AgQgACADNgIADAILIAUgATYC7AQgASABKAIAIgFBAWs2AgAgAUEBRgRAIAVB7ARqEO4dCyAAQQg2AgAMAQsgBSgCgAEiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAVBgAFqEIYfCyAFKAKEASIAIAAoAgAiAEEBazYCACAAQQFGBEAgBUGEAWoQriALAkAgBSgCkAEiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBUGQAWoQ7h0LIAVB0ABqIgAQnywgABDzOyAFQdwAaiIAEIYpIAAQ6DsgBUHoAGoiABDXHiAAQQRBzAAQ4B4gBUH0AGoiABDlJyAAQQRBGBDgHiAFKAJIIgBFDQAgBSgCTCIBKAIAIgMEQCAAIAMRAwALIAEoAgQiA0UNACAAIAMgASgCCBD4OgsgBUGABmokAAvdHgIUfwN+IwBBkAprIgYkAAJAAkACQCAELwE4BEAgBC4BOiIHQQBIBEAgBkECNgKkBSAGQbS/wwA2AqAFIAZCATcCrAUgBkHNATYCtAEgBiAHOwEwIAYgBkGwAWo2AqgFIAYgBkEwajYCsAEgBkHgAmpBBHIgBkGgBWoQmQ4gACAGKQHmAjcBBiAAQQ5qIAZB7gJqKQEANwEAIABBFmogBkH2AmovAQA7AQAgACAGLwHkAjsBBCAAQQA2AgAMBAsgBiAEEIY8IAYoAgQiBEUNAiADIAdNDQEgBigCACEUIAZBoARqIRUgBkHoAmohDiAGQYADaiEWIARBwAJsIRcgAiAHQQxsaiIYKAIIIQ9BfyEQQQAhAgNAIBBBAWoiECAPRgRAIA8gD0GEv8MAEMMhAAsgGCgCBCARaiIDKAIAIQQgA0GAgICAeDYCAAJAIARBgICAgHhGDQAgBiADQQRqKQIANwIQIAYgBDYCDCABKAIUIRIgBkGgBWohDSMAQaABayIHJAAgByABNgIMIAdCgICAgJCAgICAfzcCGCAHQoCAgIAgNwIQIAdBADsBNCAHIAdBDGo2AjAgByAGQQxqIhMQ9js2AjggB0E8aiELIAdBOGohBSMAQUBqIggkACAIQQxqQdfDwgBBERCAICAIQSxqIAdBEGoiAxDnJwJAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAhBLGoiBEHow8IAQQhBBkEBEOgcIAhBGGogAyAEEK4UIAgoAhgiCUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAJNgIAIAQQhjAMAQsgCEEsaiIEEIYwIAQgAyAFKAIAEKsbIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiIEQe6/wgBBCUEKQQIQ6BwgCEEYaiADIAQQrhQgCCgCGCIFQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAU2AgAgBBCGMAwBCyAIQSxqIgkQhjAjAEFAaiIFJAAgBUEMakHkxMIAQRQQgCAgBUEsaiADEOcnAkAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgBUEsaiIEQfjEwgBBBUEKQQEQ6BwgBUEYaiADIAQQrhQgBSgCGCIKQQRHBEAgCSAFKQIcNwIEIAlBDGogBUEkaikCADcCACAJIAo2AgAgBBCGMAwBCyAFQSxqIgQQhjAjAEEgayIKJAAgCkHRxMIAQRMQgCAgCkEMaiADEOcnAkAgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgCkEMaiADEIE2IAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIAQgAxDlKAsgChDeOyAKQSBqJAAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgAxDGISAFQSxqIAMQgTYgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgCSADEOUoCyAFQQxqEN47IAVBQGskACAIKAIsIgRBBEcEQCALIAgpAjA3AgQgC0EMaiAIQThqKQIANwIAIAsgBDYCAAwBCyADEMYhIAhBLGoiBEHww8IAQQRBCkEDEOgcIAhBGGogAyAEEK4UIAgoAhgiBUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAFNgIAIAQQhjAMAQsgCEEsaiIJEIYwIwBBQGoiBSQAIAVBDGpBssPCAEEPEIAgIAVBLGogAxDnJwJAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAVBLGoiBEHBw8IAQQZBCkEBEOgcIAVBGGogAyAEEK4UIAUoAhgiCkEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAKNgIAIAQQhjAMAQsgBUEsaiIEEIYwIwBBIGsiCiQAIApBoLbCAEEGEIAgIApBDGogAxDnJwJAIAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIApBDGogAxCBNiAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAEIAMQ5SgLIAoQ3jsgCkEgaiQAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAMQxiEgBUEsaiADEIE2IAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIgRB9MPCAEELQQpBBBDoHCAIQRhqIAMgBBCuFCAIKAIYIgVBBEcEQCALIAgpAhw3AgQgC0EMaiAIQSRqKQIANwIAIAsgBTYCACAEEIYwDAELIAhBLGoiCRCGMCMAQUBqIgUkACAFQQxqQe3FwgBBFhCAICAFQSxqIAMQ5ycCQCAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAFQSxqIgRBg8bCAEEMQQpBARDoHCAFQRhqIAMgBBCuFCAFKAIYIgpBBEcEQCAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgCjYCACAEEIYwDAELIAVBLGoiBBCGMCMAQSBrIgokACAKQdW/wgBBDBCAICAKQQxqIAMQ5ycCQCAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAKQQxqIAMQgTYgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgBCADEOUoCyAKEN47IApBIGokACAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyADEMYhIAVBLGogAxCBNiAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAJIAMQ5SgLIAVBDGoQ3jsgBUFAayQAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiADEIE2IAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAsgAxDlKAsgCEEMahDeOyAIQUBrJAACQCAHKAI8QQRHBEAgB0H4AGogB0HMAGooAgA2AgAgB0HwAGogB0HEAGopAgA3AwAgByAHKQI8NwNoIAdBATYChAEgB0GYlMMANgKAASAHQgE3AowBIAdBhwE2ApwBIAcgB0GYAWo2AogBIAcgB0HoAGoiAzYCmAEgB0HQAGpBBHIgB0GAAWoQmQ4gAxDTLSANQRRqIAdB5ABqKAIANgIAIA1BDGogB0HcAGopAgA3AgAgDSAHKQJUNwIEIA1BADYCAAwBCyAHQdAAaiEEIwBBEGsiAyQAIANBCGoiCCAHQRBqKAIgKAIAEMMZAkACQCADLQAIQQRGDQAgAykDCCIZQv8Bg0IEUQ0AIAMgGTcDCCAEIAgQ0AkMAQsgBEEENgIACyADQRBqJAAgBygCUCIDQQRHBEAgB0GMAWogB0HcAGopAgA3AgAgByAHKQJUNwKEASAHIAM2AoABIA0gB0GAAWoQpSUMAQsjAEHQAGsiAyQAIANBCGogB0EMaigCACATKAIEIBMoAghBBXQQqBogB0GAAWoiBCADLQAIQQRHBH8gAyADKQMINwMoIANBATYCNCADQeiTwwA2AjAgA0IBNwI8IANBhgE2AkwgAyADQcgAajYCOCADIANBKGoiCDYCSCADQRBqQQRyIANBMGoQmQ4gCBC5LiAEQRRqIANBJGooAgA2AgAgBEEMaiADQRxqKQIANwIAIAQgAykCFDcCBEEABUEICzYCACADQdAAaiQAIAcoAoABIgNBCEcEQCANIAcpAoQBNwIEIA1BFGogB0GUAWooAgA2AgAgDUEMaiAHQYwBaikCADcCACANIAM2AgAMAQsgDUEINgIACyAHQRBqELouIAdBoAFqJAACQCAGKAKgBSIDQQhHBEAgACAGKQKkBTcCBCAAQRRqIAZBtAVqKAIANgIAIABBDGogBkGsBWopAgA3AgAgACADNgIADAELIAEoAhQhCCAGQaAFaiIEIAIgFGoiAxC0CCAGQeACaiAEENA1IAZB0AJqIgQgDkEIaikDADcDACAGQdgCaiIHIA5BEGopAwA3AwAgBiASrTcDiAMgBkIBNwOAAyAGIA4pAwA3A8gCIAYpA+ACIRkgBkGwAWogFkGYAfwKAAAgBkEwaiAVQYAB/AoAACAZQgJRBEAgBkEoaiAHKQMAIhk3AwAgBkEgaiAEKQMAIho3AwAgBiAGKQPIAiIbNwMYIABBEGogGTcDACAAQQhqIBo3AwAgACAbNwMADAELIAZBKGoiCyAHKQMANwMAIAZBIGoiByAEKQMANwMAIAYgBikDyAI3AxggBkHgCGoiBCAGQbABakGYAfwKAAAgBkHgB2oiBSAGQTBqQYAB/AoAACAGQYAKaiIJIAcpAwA3AwAgBkGICmoiByALKQMANwMAIAYgBikDGDcD+AkgAxDYEiADIBk3AwAgA0EIaiAGKQP4CTcDACADQRBqIAkpAwA3AwAgA0EYaiAHKQMANwMAIANBIGogBEGYAfwKAAAgA0G8AWogCCASazYCACADQbgBakEBNgIAIANBwAFqIAVBgAH8CgAAIAZBDGoQ8DsMAQsgBkEMahDwOwwFCyARQQxqIREgFyACQcACaiICRw0ACwwCC0HIvsMAQRlB5L7DABDLJAALIAcgA0H0vsMAEMMhAAsgAEEINgIACyAGQZAKaiQAC90eAhR/A34jAEGQCmsiBiQAAkACQAJAIAQvATgEQCAELgE6IgdBAEgEQCAGQQI2AqQFIAZBtL/DADYCoAUgBkIBNwKsBSAGQc0BNgK0ASAGIAc7ATAgBiAGQbABajYCqAUgBiAGQTBqNgKwASAGQeACakEEciAGQaAFahCZDiAAIAYpAeYCNwEGIABBDmogBkHuAmopAQA3AQAgAEEWaiAGQfYCai8BADsBACAAIAYvAeQCOwEEIABBADYCAAwECyAGIAQQhjwgBigCBCIERQ0CIAMgB00NASAGKAIAIRQgBkGgBGohFSAGQegCaiEOIAZBgANqIRYgBEHAAmwhFyACIAdBDGxqIhgoAgghD0F/IRBBACECA0AgEEEBaiIQIA9GBEAgDyAPQYS/wwAQwyEACyAYKAIEIBFqIgMoAgAhBCADQYCAgIB4NgIAAkAgBEGAgICAeEYNACAGIANBBGopAgA3AhAgBiAENgIMIAEoAhwhEiAGQaAFaiENIwBBoAFrIgckACAHIAE2AgwgB0KAgICAkICAgIB/NwIYIAdCgICAgCA3AhAgB0EAOwE0IAcgB0EMajYCMCAHIAZBDGoiExD2OzYCOCAHQTxqIQsgB0E4aiEFIwBBQGoiCCQAIAhBDGpB18PCAEEREIAgIAhBLGogB0EQaiIDEOcnAkAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgCEEsaiIEQejDwgBBCEEGQQEQ6BwgCEEYaiADIAQQrRQgCCgCGCIJQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAk2AgAgBBCGMAwBCyAIQSxqIgQQhjAgBCADIAUoAgAQqhsgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIgRB7r/CAEEJQQpBAhDoHCAIQRhqIAMgBBCtFCAIKAIYIgVBBEcEQCALIAgpAhw3AgQgC0EMaiAIQSRqKQIANwIAIAsgBTYCACAEEIYwDAELIAhBLGoiCRCGMCMAQUBqIgUkACAFQQxqQeTEwgBBFBCAICAFQSxqIAMQ5ycCQCAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAFQSxqIgRB+MTCAEEFQQpBARDoHCAFQRhqIAMgBBCtFCAFKAIYIgpBBEcEQCAJIAUpAhw3AgQgCUEMaiAFQSRqKQIANwIAIAkgCjYCACAEEIYwDAELIAVBLGoiBBCGMCMAQSBrIgokACAKQdHEwgBBExCAICAKQQxqIAMQ5ycCQCAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAKQQxqIAMQgDYgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgBCADEOUoCyAKEN47IApBIGokACAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyADEMYhIAVBLGogAxCANiAFKAIsIgRBBEcEQCAJIAUpAjA3AgQgCUEMaiAFQThqKQIANwIAIAkgBDYCAAwBCyAJIAMQ5SgLIAVBDGoQ3jsgBUFAayQAIAgoAiwiBEEERwRAIAsgCCkCMDcCBCALQQxqIAhBOGopAgA3AgAgCyAENgIADAELIAMQxiEgCEEsaiIEQfDDwgBBBEEKQQMQ6BwgCEEYaiADIAQQrRQgCCgCGCIFQQRHBEAgCyAIKQIcNwIEIAtBDGogCEEkaikCADcCACALIAU2AgAgBBCGMAwBCyAIQSxqIgkQhjAjAEFAaiIFJAAgBUEMakGyw8IAQQ8QgCAgBUEsaiADEOcnAkAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgBUEsaiIEQcHDwgBBBkEKQQEQ6BwgBUEYaiADIAQQrRQgBSgCGCIKQQRHBEAgCSAFKQIcNwIEIAlBDGogBUEkaikCADcCACAJIAo2AgAgBBCGMAwBCyAFQSxqIgQQhjAjAEEgayIKJAAgCkGgtsIAQQYQgCAgCkEMaiADEOcnAkAgCigCDCIMQQRHBEAgBCAKKQIQNwIEIARBDGogCkEYaikCADcCACAEIAw2AgAMAQsgCkEMaiADEIA2IAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIAQgAxDlKAsgChDeOyAKQSBqJAAgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgAxDGISAFQSxqIAMQgDYgBSgCLCIEQQRHBEAgCSAFKQIwNwIEIAlBDGogBUE4aikCADcCACAJIAQ2AgAMAQsgCSADEOUoCyAFQQxqEN47IAVBQGskACAIKAIsIgRBBEcEQCALIAgpAjA3AgQgC0EMaiAIQThqKQIANwIAIAsgBDYCAAwBCyADEMYhIAhBLGoiBEH0w8IAQQtBCkEEEOgcIAhBGGogAyAEEK0UIAgoAhgiBUEERwRAIAsgCCkCHDcCBCALQQxqIAhBJGopAgA3AgAgCyAFNgIAIAQQhjAMAQsgCEEsaiIJEIYwIwBBQGoiBSQAIAVBDGpB7cXCAEEWEIAgIAVBLGogAxDnJwJAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAVBLGoiBEGDxsIAQQxBCkEBEOgcIAVBGGogAyAEEK0UIAUoAhgiCkEERwRAIAkgBSkCHDcCBCAJQQxqIAVBJGopAgA3AgAgCSAKNgIAIAQQhjAMAQsgBUEsaiIEEIYwIwBBIGsiCiQAIApB1b/CAEEMEIAgIApBDGogAxDnJwJAIAooAgwiDEEERwRAIAQgCikCEDcCBCAEQQxqIApBGGopAgA3AgAgBCAMNgIADAELIApBDGogAxCANiAKKAIMIgxBBEcEQCAEIAopAhA3AgQgBEEMaiAKQRhqKQIANwIAIAQgDDYCAAwBCyAEIAMQ5SgLIAoQ3jsgCkEgaiQAIAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAMQxiEgBUEsaiADEIA2IAUoAiwiBEEERwRAIAkgBSkCMDcCBCAJQQxqIAVBOGopAgA3AgAgCSAENgIADAELIAkgAxDlKAsgBUEMahDeOyAFQUBrJAAgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgAxDGISAIQSxqIAMQgDYgCCgCLCIEQQRHBEAgCyAIKQIwNwIEIAtBDGogCEE4aikCADcCACALIAQ2AgAMAQsgCyADEOUoCyAIQQxqEN47IAhBQGskAAJAIAcoAjxBBEcEQCAHQfgAaiAHQcwAaigCADYCACAHQfAAaiAHQcQAaikCADcDACAHIAcpAjw3A2ggB0EBNgKEASAHQZiUwwA2AoABIAdCATcCjAEgB0GHATYCnAEgByAHQZgBajYCiAEgByAHQegAaiIDNgKYASAHQdAAakEEciAHQYABahCZDiADENMtIA1BFGogB0HkAGooAgA2AgAgDUEMaiAHQdwAaikCADcCACANIAcpAlQ3AgQgDUEANgIADAELIAdB0ABqIQQjAEEQayIDJAAgA0EIaiIIIAdBEGooAiAoAgAQnRkCQAJAIAMtAAhBBEYNACADKQMIIhlC/wGDQgRRDQAgAyAZNwMIIAQgCBDQCQwBCyAEQQQ2AgALIANBEGokACAHKAJQIgNBBEcEQCAHQYwBaiAHQdwAaikCADcCACAHIAcpAlQ3AoQBIAcgAzYCgAEgDSAHQYABahClJQwBCyMAQdAAayIDJAAgA0EIaiAHQQxqKAIAIBMoAgQgEygCCEEFdBCnGiAHQYABaiIEIAMtAAhBBEcEfyADIAMpAwg3AyggA0EBNgI0IANB6JPDADYCMCADQgE3AjwgA0GGATYCTCADIANByABqNgI4IAMgA0EoaiIINgJIIANBEGpBBHIgA0EwahCZDiAIELkuIARBFGogA0EkaigCADYCACAEQQxqIANBHGopAgA3AgAgBCADKQIUNwIEQQAFQQgLNgIAIANB0ABqJAAgBygCgAEiA0EIRwRAIA0gBykChAE3AgQgDUEUaiAHQZQBaigCADYCACANQQxqIAdBjAFqKQIANwIAIA0gAzYCAAwBCyANQQg2AgALIAdBEGoQui4gB0GgAWokAAJAIAYoAqAFIgNBCEcEQCAAIAYpAqQFNwIEIABBFGogBkG0BWooAgA2AgAgAEEMaiAGQawFaikCADcCACAAIAM2AgAMAQsgASgCHCEIIAZBoAVqIgQgAiAUaiIDELQIIAZB4AJqIAQQ0DUgBkHQAmoiBCAOQQhqKQMANwMAIAZB2AJqIgcgDkEQaikDADcDACAGIBKtNwOIAyAGQgE3A4ADIAYgDikDADcDyAIgBikD4AIhGSAGQbABaiAWQZgB/AoAACAGQTBqIBVBgAH8CgAAIBlCAlEEQCAGQShqIAcpAwAiGTcDACAGQSBqIAQpAwAiGjcDACAGIAYpA8gCIhs3AxggAEEQaiAZNwMAIABBCGogGjcDACAAIBs3AwAMAQsgBkEoaiILIAcpAwA3AwAgBkEgaiIHIAQpAwA3AwAgBiAGKQPIAjcDGCAGQeAIaiIEIAZBsAFqQZgB/AoAACAGQeAHaiIFIAZBMGpBgAH8CgAAIAZBgApqIgkgBykDADcDACAGQYgKaiIHIAspAwA3AwAgBiAGKQMYNwP4CSADENgSIAMgGTcDACADQQhqIAYpA/gJNwMAIANBEGogCSkDADcDACADQRhqIAcpAwA3AwAgA0EgaiAEQZgB/AoAACADQbwBaiAIIBJrNgIAIANBuAFqQQE2AgAgA0HAAWogBUGAAfwKAAAgBkEMahDwOwwBCyAGQQxqEPA7DAULIBFBDGohESAXIAJBwAJqIgJHDQALDAILQci+wwBBGUHkvsMAEMskAAsgByADQfS+wwAQwyEACyAAQQg2AgALIAZBkApqJAAL/AcCCH8BfiMAQTBrIgQkAAJAIAItAAwiBUEBRgRAIAEtAAwhAiAAIAEQ6R0gACACOgAMDAELAkACQAJAAkACQAJAAkAgAS0ADCIGQQFrDgIGAQALIAVFDQEMAgsgBUUNAQsCQCABKAIIIAIoAghJBEAgBEEgaiIDIAIQ6R0gBEEQaiADIAEQ7QgMAQsgBEEgaiIDIAEQ6R0gBEEQaiADIAIQ7QgLIAZBAUcEQCAGQQEgBCgCGBshAwwDCyAEQQA2AhggBEEQakEEQQQQniQgBCgCGCICRQ0BIAQoAhQiASACQQJ0IgVqQQRrIgNFDQEgAygCAA0BIAUhAyABQQRrIQUgAkH/////A3EhAQJAA0AgA0UEQEEAIQMMAgsgAUEBayEBIAMgBWogA0EEayEDKAIARQ0ACyABQQFqIgMgAksNAgsgBCADNgIYIAMhAgwBCwJAAkACQAJ/IAEoAggiAyACKAIIIgdHBEAgAyAHSyADIAdJawwBCyADQQJ0IQMgASgCBEEEayEJIAIoAgRBBGshCgJAA0AgA0UNASADIApqIQggAyAJaiADQQRrIQMoAgAiByAIKAIAIghGDQALIAcgCEsgByAISWsMAQtBf0EAIAMbCyIDQf8BcQ4CAQIACyAEQSBqIgMgAhDpHSADIAEQ7xQgBCkDICELIAAgBUEBIAQoAigiARs6AAwgACABNgIIIAAgCzcCAAwFCyAAQQhqQZSKiAEpAgA3AgAgAEGMiogBKQIANwIADAQLIARBIGoiBSABEOkdIAUgAhDvFCAEQRhqIARBKGooAgA2AgAgBCAEKQIgNwMQAkAgBkEBRwRAIAZBASAEKAIYGyEDDAELIARBADYCGCAEQRBqQQRBBBCeJAJAIAQoAhgiAkUNACAEKAIUIgEgAkECdCIFakEEayIDRQ0AIAMoAgANACAFIQMgAUEEayEFIAJB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAVqIANBBGshAygCAEUNAAsgAUEBaiIDIAJLDQELIAQgAzYCGCADIQILQQEhAyACIAQoAhBBAnZPDQAgBEEIaiAEQRBqIAJBBEEEEPQUIAQoAggiAUGBgICAeEYNACABIAQoAgxBzI2IARD9LwALIAAgBCkDEDcCACAAIAM6AAwgAEEIaiAEQRhqKAIANgIADAMLQQEhAyACIAQoAhBBAnZPDQAgBCAEQRBqIAJBBEEEEPQUIAQoAgAiAUGBgICAeEYNACABIAQoAgRBzI2IARD9LwALIAAgBCkCEDcCACAAIAM6AAwgAEEIaiAEQRhqKAIANgIADAELIAAgAhDpHSAAIAU6AAwLIARBMGokAAv4BwEUfyMAQSBrIg8kACADIARxIhMgAk0EQCAPQQA2AgQgAiATa0EDSwRAIA9BBGpBBCABIBNqQQRBtNnOABDVLCAPKAIEQb3P1vEBbEEPdiILIAAoAgQiDUkEQCAAKAIQIhYgA3FBAXQhDSAAKAIAIAtBAnRqIgsoAgAhECAGQf8ASwRAIAsgAzYCAAsgACgCDCEMIAAoAgghESANQQFyIQ4CQAJAAkACQAJAIAMgEGsiGkEBayAHTw0AQYABIAYgBkGAAU8bIR4gCCgCACEbQUEhFyAGQf8ASyEcA0ACQAJAIBkgGCAYIBlLGyILIBNqIhQgAk0EQCACIAsgBCAQcSIdaiIVSQ0BIAogEkYgASAUaiACIBRrIAEgFWogAiAVayAGIAtrELIgIAtqIB0gBRChLiILIBtNcg0CIAggCzYCACAKIBJLBEAgCSASQQN0aiAarSALrUIlhoQ3AwAgEkEBaiESIAshGwwDCyASIApBpN/OABDDIQALIBQgAkGE384AEK87AAsgFSACQZTfzgAQrzsACwJ/AkACQCALIB5JBEACQAJAAkAgAiALIBNqIhRLBEAgCyAdaiIVIAJPDQEgASAUai0AACABIBVqLQAASw0DIBwNAgwGCyAUIAJBtN/OABDDIQALIBUgAkHE384AEMMhAAsgDCAOSwRAIBEgDkECdGogEDYCAAwECyAOIAxB1N/OABDDIQALIBxFDQEgDCANSwRAIBEgDUECdGogEDYCAAwCCyANIAxB9N/OABDDIQALIAZB/wBNDQcCQAJAAkAgDCAQIBZxQQF0IgBLBEAgDCANTQ0BIBEgDUECdGogESAAQQJ0aigCADYCACAAQQFyIgAgDE8NAiAMIA5NDQMgESAAQQJ0aigCACELDAoLIAAgDEGU4M4AEMMhAAsgDSAMQaTgzgAQwyEACyAAIAxBtODOABDDIQALIA4gDEHE4M4AEMMhAAsgDCAQIBZxQQF0QQFyIg1LBEAgCyEYIA0MAgsgDSAMQYTgzgAQwyEACyAQIBZxQQF0Ig4gDE8NAyALIRkgDgshCyAXRQ0BIBdBAWohFyADIBEgC0ECdGooAgAiEGsiGkEBayAHSQ0ACwsgBkH/AE0NAiAMIA1NDQMgESANQQJ0aiAAKAI8Igs2AgAgDCAOSw0BIA4gDEHk4M4AEMMhAAsgDiAMQeTfzgAQwyEACyARIA5BAnRqIAs2AgALIA9BIGokACASDwsgDSAMQdTgzgAQwyEACyALIA1B9N7OABDDIQALIA9BADYCGCAPQQE2AgwgD0GY184ANgIIIA9CBDcCECAPQQhqQaTZzgAQ7ywACyATIAJB5N7OABCvOwAL8QcCBn8DfiMAQdAEayICJAACQAJAAkACQAJAAkAgASkDACIIQgJWDQACQCAIp0EBaw4CAQACCyABKAIYIQMgAUEANgIYAkACQAJAIAMEQCACQcACaiADKAL8ASADKAL4ASABKQMQIggQhRkgAigCwAIiBEEIRwRAIAAgAikCxAI3AgQgAEEUaiACQdQCaigCADYCACAAQQxqIAJBzAJqKQIANwIAIAAgBDYCACADEPwsIANBiAJBCBD4OgwKCyABIAggAzQC/AEiCH03AxAgASAIIAEpAwh8NwMIIAMQ/CwgA0GIAkEIEPg6IAEtACBBAXENAiABKAIcIQMMAQsgAkHAAmogASgCQEEIaiABKQMIIgkQ9A8gAkEoaiIDIAJBzAJqKQIANwMAIAIgAikCxAI3AyAgAigCwAIiBEEIRwRAIAJBGGogAykDACIINwMAIAIgAikDICIJNwMQIAIoAtQCIQEgAEEMaiAINwIAIAAgCTcCBCAAIAE2AhQgACAENgIADAkLIAJBCGogAykDADcDACACIAIpAyA3AwAgAS0AICABKAIcIQMgAkHAAmogAhDyEyACKQPIAiIIQgRRBEAgAkG4AmogAkHgAmopAwAiCDcDACACQbACaiACQdgCaikDACIJNwMAIAIgAikD0AIiCjcDqAIgAEEQaiAINwMAIABBCGogCTcDACAAIAo3AwAMCAsgAkGwAmoiBSACQdgCaikDADcDACACQbgCaiIHIAJB4AJqKQMANwMAIAIgAikD0AI3A6gCIAIoAsACIQQgAkFAayACQegCakHoAfwKAAAgAkEwaiAFKQMANwMAIAJBOGogBykDADcDACACIAg3AyAgAiACKQOoAjcDKCACQcACaiAEIAEpAxAiCBCOGiACKALAAiIFQQhHBEAMBwsgAkHAAmogAigCnAIgAigCmAIgCBCFGSACKALAAiIFQQhHBEAMBwsgASAIIAI0ApwCIAStfCIIfTcDECABIAggCXw3AwggAkEgahD8LCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEAQQFxDQELIAEgA0EBajYCHAwBCyABQQA6ACALIABBCDYCAAwFCyABQgA3AwAMAQsgASgCLCIDRQ0AIAEgA0EBazYCLCABIAEoAjRBAWo2AjQgASABKAIoQQFqIgMgASgCICIBQQAgASADTRtrNgIoCyAAQQg2AgAMAgsgACACKQLEAjcCBCAAQRRqIAJB1AJqKAIANgIAIABBDGogAkHMAmopAgA3AgAgACAFNgIAIAJBIGoQ/CwLIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAJB0ARqJAALuwcBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQCAAKAIAIgUoAgAiBi0AAEENaw4FAQICAwMACyABKAIUIQAgBCACNgIsIAIgAEEBdiIATw0LIAQgASgCECACQQF0ai8BADsBKiADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBKmogAxC/ECECDAoLIARBKmogAxC3HCECDAkLIAAoAgQoAhQhACAEIAI2AiwgAiAAQQF2IgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akGDhowYNgIAIARCg4aMmLDgwIEDNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAXYiAUkNBQwICyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQF2IgFJDQUMBwsgBEE4akGDhowYNgIAIARCg4aMmLDgwIEDNwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBg4aMGDYCACAEQoOGjJiw4MCBAzcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBKmogAxC0HCECDAILIAQgACgCECACQQF0ajIBADcDACAEQThqQYOGjBg2AgAgBEKDhoyYsODAgQM3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACQQF0ajIBADcDCCAEQThqQYOGjBg2AgAgBEKDhoyYsODAgQM3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALjQgBA38jAEHQAGsiBCQAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCMCACIABBA3YiAE8NCSAEIAEoAhAgAkEDdGopAwA3AyggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQniUhAgwMCyAEQShqIAMQuRwhAgwLCyAAKAIEKAIUIQAgBCACNgI0IAIgAEEDdiIATw0JIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBQGtBhYqUKDYCACAEQoWKlKjQoMGCBTcDOCAEQThqIgAQyQwgBEEANgJIIARBATYCPCAEQeybhAE2AjggBEIENwJAIAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AjQgAiABQQN2IgFJDQUMCgsgACgCBCIAKAIUIQEgBCACNgI0IAIgAUEDdiIBSQ0FDAkLIARBQGtBhYqUKDYCACAEQoWKlKjQoMGCBTcDOCAEQThqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwHCyAEQUBrQYWKlCg2AgAgBEKFipSo0KDBggU3AzggBEE4aiIAEMkMIARBADYCSCAEQQE2AjwgBEHsm4QBNgI4IARCBDcCQCADIAAQ0TkLIQIgBEEUahDlEAwFCyAEQShqIAMQuBwhAgwECyAEIAAoAhAgAkEDdGopAwA3AwAgBEFAa0GFipQoNgIAIARChYqUqNCgwYIFNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwDCyAEIAAoAhAgAkEDdGopAwA3AwggBEFAa0GFipQoNgIAIARChYqUqNCgwYIFNwM4IARBOGoiABDJDCAEQQI2AjwgBEHsnIQBNgI4IARCAjcCRCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCQCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwCCyAEIAA2AjQgBEECNgI8IARBuJeEATYCOCAEQgI3AkQgBEE7NgIgIARBOzYCGCAEIARBFGo2AkAgBCAEQTRqNgIcIAQgBEEwajYCFAwECyAEIAA2AigMAgsgBEHQAGokACACDwsgBCABNgIoCyAEQQI2AjwgBEG4l4QBNgI4IARCAjcCRCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCQCAEIARBKGo2AhwgBCAEQTRqNgIUCyAEQThqQciXhAEQ7ywAC7sHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAXYiAE8NCyAEIAEoAhAgAkEBdGovAQA7ASogAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQSpqIAMQnBIhAgwKCyAEQSpqIAMQtxwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEEBdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBh46cODYCACAEQoeOnLjw4MGDBzcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQF2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUEBdiIBSQ0FDAcLIARBOGpBh46cODYCACAEQoeOnLjw4MGDBzcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYeOnDg2AgAgBEKHjpy48ODBgwc3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQSpqIAMQtBwhAgwCCyAEIAAoAhAgAkEBdGozAQA3AwAgBEE4akGHjpw4NgIAIARCh46cuPDgwYMHNwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkEBdGozAQA3AwggBEE4akGHjpw4NgIAIARCh46cuPDgwYMHNwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC7sHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AiggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQzCQhAgwKCyAEQShqIAMQ0xwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEECdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBhIiQIDYCACAEQoSIkKDAgIGCBDcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIgAoAhQhASAEIAI2AiwgAiABQQJ2IgFJDQUMCAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAcLIARBOGpBhIiQIDYCACAEQoSIkKDAgIGCBDcDMCAEQTBqEMkMIAMoAgBB6JuEAUEEIAMoAgQoAgwRBgAhAgwFCyAEQThqQYSIkCA2AgAgBEKEiJCgwICBggQ3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQShqIAMQ0hwhAgwCCyAEIAAoAhAgAkECdGo0AgA3AwAgBEE4akGEiJAgNgIAIARChIiQoMCAgYIENwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIAQ2AhQgAygCACADKAIEIAAQywohAgwBCyAEIAAoAhAgAkECdGo0AgA3AwggBEE4akGEiJAgNgIAIARChIiQoMCAgYIENwMwIARBMGoiABDJDCAEQQI2AjQgBEHsnIQBNgIwIARCAjcCPCAEQa8DNgIgIAQgBTYCHCAEQe4GNgIYIAQgBEEUajYCOCAEIARBCGo2AhQgAygCACADKAIEIAAQywohAgwACyAEQdAAaiQAIAIPCyAEIAE2AkwMAQsgBCAANgJMCyAEQQI2AjQgBEG4l4QBNgIwIARCAjcCPCAEQTs2AiAgBEE7NgIYIAQgBEEUajYCOCAEIARBzABqNgIcIAQgBEEsajYCFCAEQTBqQciXhAEQ7ywAC8AHAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCLCACIABBAnYiAE8NCyAEIAEoAhAgAkECdGooAgA2AiggAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQShqIAMQ/CghAgwKCyAEQShqIAMQ0xwhAgwJCyAAKAIEKAIUIQAgBCACNgIsIAIgAEECdiIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkMBAsgACgCBCIAKAIUIQEgBCACNgIsIAIgAUECdiIBSQ0FDAgLIAAoAgQiACgCFCEBIAQgAjYCLCACIAFBAnYiAUkNBQwHCyAEQThqQYiQoMAANgIAIARCiJCgwICBgoQINwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBADYCQCAEQQE2AjQgBEHsm4QBNgIwIARCBDcCOCADIAAQ0TkLIQIgBEEUahDlEAwDCyAEQShqIAMQ0hwhAgwCCyAEIAAoAhAgAkECdGo1AgA3AwAgBEE4akGIkKDAADYCACAEQoiQoMCAgYKECDcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAQsgBCAAKAIQIAJBAnRqNQIANwMIIARBOGpBiJCgwAA2AgAgBEKIkKDAgIGChAg3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALpgwCB38DfiMAQdABayICJAAgAkHIAGohBCMAQYACayIDJAAgAUGwAWoiBSgCACEGIAVBgICAgHg2AgACQAJAIAZBgICAgHhHBEAgAyAGNgIAIANBBHIgBUEEakHcAPwKAAAgAygCWARAIANB+ABqQTBBAEEBQQEQoBggAygCfCEFIAMoAnhBAUYNAiADKAKAASIGQbj7zQBBMPwKAAAgBEEwNgIUIAQgBjYCECAEIAU2AgwgBEEANgIIIARBATYCACADEIIrDAMLIANB+ABqIANB4AD8CgAAIANB6AFqIANBEGopAwA3AwAgA0HgAWogA0EIaiIGKQMANwMAIAMgAykDADcD2AEgAygCHCIFBEAgAygCGCAFQQN0QQ9qQXhxIgdrIAUgB2pBCWpBCBD4OgsgA0H4AWogBigCADYCACADIAMpAwA3A/ABIANB4ABqIANB8AFqEOcVIANB8ABqIgUgAygC7AE2AgAgA0EAOgB0IANB5AFqQQRBCBDgHiADQcgBahDjPCAEQRRqIAUpAgA3AgAgBEEMaiADQegAaikCADcCACAEIAMpAmA3AgQgBEEANgIADAILIARBADYCACAEQQI6ABgMAQsgBSADKAKAAUG09c0AEP0vAAsgA0GAAmokAAJAIAIoAkhBAUYEQCACKQNQIQkgAikDWCEKIAAgAikDYDcDECAAIAo3AwggACAJNwMADAELAkACfwJAAkACQAJAIAIoAmAiBEH/AXFBAkYEQCACQcgAakEdQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQEgAigCUCIBQRVqQY2EzwApAAA3AAAgAUEQakGIhM8AKQAANwAAIAFBCGpBgITPACkAADcAACABQfiDzwApAAA3AAAgAEEdNgIMIAAgATYCCCAAIAM2AgQgAEEANgIADAcLIAIoAlwhBSACKAJYIQcgAigCVCEDIAIoAlAhBiACKAJMIQggAiAENgI8IAIgBTYCOCACIAc2AjQgAiADNgIwIAIgBjYCLCACIAg2AiggASgCyAQiBwRAIAJByABqIgggA0EAQQFBARCgGCACKAJMIQQgAigCSEEBRg0CIAJBNGohBSACQQA2AiQgAiACKAJQNgIgIAIgBDYCHCAIIAcgBiADIAJBHGoiBCABKALMBCgCDBEHACACKAJIIgZBCEcEQCAAIAIpAkw3AgQgAEEUaiACQdwAaigCADYCACAAQQxqIAJB1ABqKQIANwIAIAAgBjYCACAEEN47IAUgAigCLCACKAIwIAIoAigoAhARAQAMCAsgAkEQaiACQSRqKAIANgIAIAIgAikCHDcDCCACQcgAaiACQQhqEOcVIAUgAigCLCACQTBqIgQoAgAgAigCKCgCEBEBACAEIAJB0ABqKQIANwMAIAIgAikCSDcDKCACKAI4IQUgAi0APCEECyACQRBqIgcgAkEwaikDADcDACACIAIpAyg3AwggAUGgBWpBABDpHiABKAL8BCIGIAEoAvQERgRAIAFB9ARqQeiDzwAQmygLIAEoAvgEIAZBA3RqQoGAgICAwAA3AgAgASAGQQFqNgL8BCABKALABCEGIAEoAsQEIQggAkHYAGogBykDADcDACACQgs3A0ggAiACKQMINwNQIAIgAzYCyAEgAiAEOgBlIAJBADoAZCACIAU2AmAgAkEoaiAGIAJByABqIAgoAgwRAQAgAigCPCEDIAIoAjghBCACKQMwIQkgAikDKCEKIAItAEQiBUEERgRAIAAgAzYCFCAAIAQ2AhAgACAJNwMIIAAgCjcDAAwHCyACNQJAIQsgASABKQNQIAStfDcDUCABIAEpA1ggA618NwNYIAEgASkDQCAJfDcDQAJAAkAgBUEBaw4CBwABCyABKQMAUEUNAyABQgE3AwBBCAwFCyABIAEpA2AgC3w3A2AgASkDEFANAwwFCyADIAIoAlBBwPXOABD9LwALIAQgAigCUEHYg88AEP0vAAsgAkEANgJYIAJBATYCTCACQbiEzwA2AkggAkIENwJQIAJByABqQcCEzwAQ7ywACyABQgE3AxBBGAsgAWogCjcDAAsgAEEINgIACyACQdABaiQAC4cIAg5/A34jAEEwayIDJAACQCABKAJcIgYEQCABQdwAaiEKIAEoAkQhBSABKAJIIQRC////////////ACERAkACQAJAAkACQAJAAkACQANAIAIgBEYNASAFKQMAIhAgESAQIBFTGyERIAVBCGohBSAGIAJBAWoiAkcNAAsgAUEYaiARQgGGIBFCP4eFEKoSIAEoAlghBiABLQAsIQQgAyABKQMYNwMQIARBA3YgBEEHcUEAR2oiBEEJTw0BIAFBIGoiCyADQRBqIAQQoTYgAUEAOgAsIAFCADcDGCABKAIoIQ0gA0EIaiAGEPo3IAsgAygCCCADLQAMEI8pIAEoAlwhAiABKAJYIg5FDQcgDSEEQQAhBgNAIAIgASgCVCIHIAIgB0kbIgkEQCAGQQFqIAYgB2whAiABKAJEIAcgDGxqIQUgASgCSCEIQoCAgICAgICAgH8hECAJIQcDQCACIAhPDQYgBSkDACISIBAgECASUxshECAFQQhqIQUgAkEBaiECIAdBAWsiBw0ACyAGIA1qIgcgASgCKCICTw0GIAEoAiQgB2pBwAAgECARfUL/////D4N5p2siBzoAAEEAIQUDQCAFIAYgASgCVGxqIgIgASgCSCIITw0IIAEoAkQgAkEDdGopAwAhECABIAEtACwiCCAHaiICOgAsIAEgASkDGCAQIBF9Qv////8PgyISIAhBP3GthoQiEDcDGCACQf8BcUHAAE8EQCADIBA3AxAgCyADQRBqQQgQoTYgASACQUBqIgI6ACwgASASIAcgAmsiCK2IQgAgCEH/AXFBwABJGyIQNwMYCyAJIAVBAWoiBUcNAAsgCSABKAJUIgZJBEAgBiAJayEFA0AgASACIAdqIgI6ACwgAkH/AXFBwABPBEAgAyAQNwMQIAsgA0EQakEIEKE2IAFCADcDGCABIAJBQGoiAjoALEIAIRALIAVBAWsiBQ0ACwsgCiAKKAIAIAlrIgI2AgAgDEEIaiEMIARBAWohBCIGIA5HDQEMCQsLIAYgASgCWCIFTw0HIAEoAiQhCSABKAIoIQEDQCABIARNDQMgBCAJakEAOgAAIARBAWohBCAFQQFrIgUgBkcNAAsMBgsgBCAGQQFrIgAgACAESxsgBEHwns4AEMMhAAsgBEEIQeiOzgAQsDsACyAEIAFBiLbOABDDIQALIAIgCEHgns4AEMMhAAsgByACQYi2zgAQwyEACyACIAhB0J7OABDDIQALIAooAgAhAgsgAg0BCyAAQQg2AgAgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQbiezgA2AhAgA0E7NgIsIAMgCjYCKCADIANBKGo2AhhBACAKQciGzgAgA0EQakHAns4AEK8rAAv6DQIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJ4IQMgAUGAgICAeDYCeAJAAkAgA0GAgICAeEcEQCAEIAFBMGpByAD8CgAAIARB1ABqIAFBhAFqKAIANgIAIAQgAzYCSCAEIAEpAnw3AkwCQAJAIAEoAqABRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQoCAgIAQNwMgIAQoAjghByADQQA2AiggA0EgaiIGIAQoAjQgB0EDdBChNiADLQAcIQcgAyADKQMINwMwIAdBA3YgB0EHcUEAR2oiB0EJTwRAIAdBCEHojs4AELA7AAsgA0EQaiADQTBqIgkgBxChNiADQQA6ABwgA0IANwMIIAYgAygCFCADKAIYEKE2IANBADoAHCADQgA3AwggA0EANgIYIANBOGogBkEIaigCADYCACADIAYpAgA3AzAgA0EANgIoIANCgICAgBA3AyAgCEEEaiAJEOcVIAhBCDYCACADQQhqEMouIANBQGskACAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQggBSAEKQNYNwIMIAUgCDYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEENMsDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghCCACKAJUIQQgAigCUCEGIAIoAkwhByACIAM2AjwgAiAFNgI4IAIgCDYCNCACIAQ2AjAgAiAGNgIsIAIgBzYCKCABKAK4BCIIBEAgAkHIAGoiByAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAcgCCAGIAQgAkEcaiIDIAEoArwEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiCCACQTBqKQMANwMAIAIgAikDKDcDCCABQewEakEAEOkeIAEoAsgEIgYgASgCwARGBEAgAUHABGpB6IPPABCbKAsgASgCxAQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2AsgEIAEoArAEIQYgASgCtAQhByACQdgAaiAIKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogBygCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA5gCIAOtfDcDmAIgASABKQOgAiAErXw3A6ACIAEgASkDiAIgCnw3A4gCAkACQCAFQQFrDgIHAAELIAEpA6gBUEUNAyABQgE3A6gBQbABDAULIAEgASkDqAIgDHw3A6gCIAEpA7gBUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDuAFBwAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAvFDgIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJYIQMgAUGAgICAeDYCWAJAAkAgA0GAgICAeEcEQCAEIAFBEGpByAD8CgAAIARB1ABqIAFB5ABqKAIANgIAIAQgAzYCSCAEIAEpAlw3AkwCQAJAIAEoAqgBRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQQA2AiggA0KAgICAEDcDICADQSBqIQcCQAJAAkAgBCgCOCIJBEAgBCgCNCIGIAlBBHRqIQkDQCAGKAIARQ0CIAcgBkEEaigCACAGQQhqKAIAEKE2IAZBEGoiBiAJRw0ACwsgAy0AHCEGIAMgAykDCDcDMCAGQQN2IAZBB3FBAEdqIgZBCU8NASADQRBqIANBMGoiCSAGEKE2IANBADoAHCADQgA3AwggByADKAIUIAMoAhgQoTYgA0EAOgAcIANCADcDCCADQQA2AhggA0E4aiAHQQhqKAIANgIAIAMgBykCADcDMCADQQA2AiggA0KAgICAEDcDICAIQQRqIAkQ5xUgCEEINgIAIANBCGoQyi4gA0FAayQADAILQeSHzgBBIEGEiM4AEMskAAsgBkEIQeiOzgAQsDsACyAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQcgBSAEKQNYNwIMIAUgBzYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEEJ4sDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghByACKAJUIQQgAigCUCEGIAIoAkwhCCACIAM2AjwgAiAFNgI4IAIgBzYCNCACIAQ2AjAgAiAGNgIsIAIgCDYCKCABKAKwBCIHBEAgAkHIAGoiCCAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAggByAGIAQgAkEcaiIDIAEoArQEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiByACQTBqKQMANwMAIAIgAikDKDcDCCABQYgFakEAEOkeIAEoAuQEIgYgASgC3ARGBEAgAUHcBGpB6IPPABCbKAsgASgC4AQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2AuQEIAEoAqgEIQYgASgCrAQhCCACQdgAaiAHKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogCCgCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA4ACIAOtfDcDgAIgASABKQOIAiAErXw3A4gCIAEgASkD8AEgCnw3A/ABAkACQCAFQQFrDgIHAAELIAEpA7ABUEUNAyABQgE3A7ABQbgBDAULIAEgASkDkAIgDHw3A5ACIAEpA8ABUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDwAFByAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAv6DQIIfwN+IwBB0AFrIgIkACACQcgAaiEFIwBBgAFrIgQkACABKAJoIQMgAUGAgICAeDYCaAJAAkAgA0GAgICAeEcEQCAEIAFBIGpByAD8CgAAIARB1ABqIAFB9ABqKAIANgIAIAQgAzYCSCAEIAEpAmw3AkwCQAJAIAEoApABRQRAIARB6ABqIQgjAEFAaiIDJAAgA0EIakGAAhDoICADQoCAgIAQNwMgIAQoAjghByADQQA2AiggA0EgaiIGIAQoAjQgB0ECdBChNiADLQAcIQcgAyADKQMINwMwIAdBA3YgB0EHcUEAR2oiB0EJTwRAIAdBCEHojs4AELA7AAsgA0EQaiADQTBqIgkgBxChNiADQQA6ABwgA0IANwMIIAYgAygCFCADKAIYEKE2IANBADoAHCADQgA3AwggA0EANgIYIANBOGogBkEIaigCADYCACADIAYpAgA3AzAgA0EANgIoIANCgICAgBA3AyAgCEEEaiAJEOcVIAhBCDYCACADQQhqEMouIANBQGskACAEQeAAaiIDIARB9ABqKQIANwMAIAQgBCkCbDcDWCAEKAJoIgZBCEYNASAEKAJ8IQggBSAEKQNYNwIMIAUgCDYCHCAFIAY2AgggBUEBNgIAIAVBFGogAykDADcCAAwCCyAEQegAakEwQQBBAUEBEKAYIAQoAmwhAyAEKAJoQQFGDQMgBCgCcCIGQZiJzgBBMPwKAAAgBUEwNgIUIAUgBjYCECAFIAM2AgwgBUEANgIIIAVBATYCAAwBCyAFIAQpA1g3AgQgBUEMaiADKQMANwIAIAVBADoAGCAFIAQoAjg2AhQgBUEANgIACyAEENIsDAILIAVBADYCACAFQQI6ABgMAQsgAyAEKAJwQZyHzgAQ/S8ACyAEQYABaiQAAkAgAigCSEEBRgRAIAIpA1AhCiACKQNYIQsgACACKQNgNwMQIAAgCzcDCCAAIAo3AwAMAQsCQAJ/AkACQAJAAkAgAigCYCIDQf8BcUECRgRAIAJByABqQR1BAEEBQQEQoBggAigCTCEEIAIoAkhBAUYNASACKAJQIgFBFWpBjYTPACkAADcAACABQRBqQYiEzwApAAA3AAAgAUEIakGAhM8AKQAANwAAIAFB+IPPACkAADcAACAAQR02AgwgACABNgIIIAAgBDYCBCAAQQA2AgAMBwsgAigCXCEFIAIoAlghCCACKAJUIQQgAigCUCEGIAIoAkwhByACIAM2AjwgAiAFNgI4IAIgCDYCNCACIAQ2AjAgAiAGNgIsIAIgBzYCKCABKAKABCIIBEAgAkHIAGoiByAEQQBBAUEBEKAYIAIoAkwhAyACKAJIQQFGDQIgAkE0aiEFIAJBADYCJCACIAIoAlA2AiAgAiADNgIcIAcgCCAGIAQgAkEcaiIDIAEoAoQEKAIMEQcAIAIoAkgiBkEIRwRAIAAgAikCTDcCBCAAQRRqIAJB3ABqKAIANgIAIABBDGogAkHUAGopAgA3AgAgACAGNgIAIAMQ3jsgBSACKAIsIAIoAjAgAigCKCgCEBEBAAwICyACQRBqIAJBJGooAgA2AgAgAiACKQIcNwMIIAJByABqIAJBCGoQ5xUgBSACKAIsIAJBMGoiAygCACACKAIoKAIQEQEAIAMgAkHQAGopAgA3AwAgAiACKQJINwMoIAIoAjghBSACLQA8IQMLIAJBEGoiCCACQTBqKQMANwMAIAIgAikDKDcDCCABQcAEakEAEOkeIAEoApwEIgYgASgClARGBEAgAUGUBGpB6IPPABCbKAsgASgCmAQgBkEDdGpCgYCAgIDAADcCACABIAZBAWo2ApwEIAEoAvgDIQYgASgC/AMhByACQdgAaiAIKQMANwMAIAJCCzcDSCACIAIpAwg3A1AgAiAENgLIASACIAM6AGUgAkEAOgBkIAIgBTYCYCACQShqIAYgAkHIAGogBygCDBEBACACKAI8IQQgAigCOCEDIAIpAzAhCiACKQMoIQsgAi0ARCIFQQRGBEAgACAENgIUIAAgAzYCECAAIAo3AwggACALNwMADAcLIAI1AkAhDCABIAEpA/gBIAOtfDcD+AEgASABKQOAAiAErXw3A4ACIAEgASkD6AEgCnw3A+gBAkACQCAFQQFrDgIHAAELIAEpA5gBUEUNAyABQgE3A5gBQaABDAULIAEgASkDiAIgDHw3A4gCIAEpA6gBUA0DDAULIAQgAigCUEHA9c4AEP0vAAsgAyACKAJQQdiDzwAQ/S8ACyACQQA2AlggAkEBNgJMIAJBuITPADYCSCACQgQ3AlAgAkHIAGpBwITPABDvLAALIAFCATcDqAFBsAELIAFqIAs3AwALIABBCDYCAAsgAkHQAWokAAudDwIKfwN+IwBB0AFrIgIkACACQcgAaiEGIwBBgAFrIgUkACABKAJYIQQgAUGAgICAeDYCWAJAAkAgBEGAgICAeEcEQCAFIAFBEGpByAD8CgAAIAVB1ABqIAFB5ABqKAIANgIAIAUgBDYCSCAFIAEpAlw3AkwCQAJAIAEoAoABRQRAIAVB6ABqIQkjAEFAaiIDJAAgA0EIakGAAhDoICADQQA2AiggA0KAgICAEDcDIAJAIAUoAjgiCkUEQCADKQMIIQwgAy0AHCEEDAELIAUoAjQhCCADQRBqIQsgAykDCCEMIAMtABwhBANAIAMgBEEBaiIHOgAcIAMgCDEAACINIASthiAMhCIMNwMIIAdB/wFxQcAASUUEQCADIAw3AzAgCyADQTBqQQgQoTYgAyAEQT9rIgc6ABwgAyANQcAAIARrIgStiEIAIARB/wFxQcAASRsiDDcDCAsgByEEIAhBAWohCCAKQQFrIgoNAAsLIAMgDDcDMCAEQfgBcUEDdiAEQQdxQQBHaiIEQQlPBEAgBEEIQeiOzgAQsDsACyADQRBqIANBMGoiByAEEKE2IANBADoAHCADQgA3AwggA0EgaiIEIAMoAhQgAygCGBChNiADQQA6ABwgA0IANwMIIANBADYCGCADQThqIARBCGooAgA2AgAgAyAEKQIANwMwIANBADYCKCADQoCAgIAQNwMgIAlBBGogBxDnFSAJQQg2AgAgA0EIahDKLiADQUBrJAAgBUHgAGoiBCAFQfQAaikCADcDACAFIAUpAmw3A1ggBSgCaCIHQQhGDQEgBSgCfCEDIAYgBSkDWDcCDCAGIAM2AhwgBiAHNgIIIAZBATYCACAGQRRqIAQpAwA3AgAMAgsgBUHoAGpBMEEAQQFBARCgGCAFKAJsIQQgBSgCaEEBRg0DIAUoAnAiB0GYic4AQTD8CgAAIAZBMDYCFCAGIAc2AhAgBiAENgIMIAZBADYCCCAGQQE2AgAMAQsgBiAFKQNYNwIEIAZBDGogBCkDADcCACAGQQA6ABggBiAFKAI4NgIUIAZBADYCAAsgBRDRLAwCCyAGQQA2AgAgBkECOgAYDAELIAQgBSgCcEGch84AEP0vAAsgBUGAAWokAAJAIAIoAkhBAUYEQCACKQNQIQwgAikDWCENIAAgAikDYDcDECAAIA03AwggACAMNwMADAELAkACfwJAAkACQAJAIAIoAmAiBEH/AXFBAkYEQCACQcgAakEdQQBBAUEBEKAYIAIoAkwhBSACKAJIQQFGDQEgAigCUCIBQRVqQY2EzwApAAA3AAAgAUEQakGIhM8AKQAANwAAIAFBCGpBgITPACkAADcAACABQfiDzwApAAA3AAAgAEEdNgIMIAAgATYCCCAAIAU2AgQgAEEANgIADAcLIAIoAlwhByACKAJYIQYgAigCVCEFIAIoAlAhAyACKAJMIQggAiAENgI8IAIgBzYCOCACIAY2AjQgAiAFNgIwIAIgAzYCLCACIAg2AiggASgC6AMiBgRAIAJByABqIgggBUEAQQFBARCgGCACKAJMIQQgAigCSEEBRg0CIAJBNGohByACQQA2AiQgAiACKAJQNgIgIAIgBDYCHCAIIAYgAyAFIAJBHGoiBCABKALsAygCDBEHACACKAJIIgNBCEcEQCAAIAIpAkw3AgQgAEEUaiACQdwAaigCADYCACAAQQxqIAJB1ABqKQIANwIAIAAgAzYCACAEEN47IAcgAigCLCACKAIwIAIoAigoAhARAQAMCAsgAkEQaiACQSRqKAIANgIAIAIgAikCHDcDCCACQcgAaiACQQhqEOcVIAcgAigCLCACQTBqIgQoAgAgAigCKCgCEBEBACAEIAJB0ABqKQIANwMAIAIgAikCSDcDKCACKAI4IQcgAi0APCEECyACQRBqIgYgAkEwaikDADcDACACIAIpAyg3AwggAUGcBGpBABDpHiABKAL4AyIDIAEoAvADRgRAIAFB8ANqQeiDzwAQmygLIAEoAvQDIANBA3RqQoGAgICAwAA3AgAgASADQQFqNgL4AyABKALgAyEDIAEoAuQDIQggAkHYAGogBikDADcDACACQgs3A0ggAiACKQMINwNQIAIgBTYCyAEgAiAEOgBlIAJBADoAZCACIAc2AmAgAkEoaiADIAJByABqIAgoAgwRAQAgAigCPCEFIAIoAjghBCACKQMwIQwgAikDKCENIAItAEQiB0EERgRAIAAgBTYCFCAAIAQ2AhAgACAMNwMIIAAgDTcDAAwHCyACNQJAIQ4gASABKQPYASAErXw3A9gBIAEgASkD4AEgBa18NwPgASABIAEpA8gBIAx8NwPIAQJAAkAgB0EBaw4CBwABCyABKQOIAVBFDQMgAUIBNwOIAUGQAQwFCyABIAEpA+gBIA58NwPoASABKQOYAVANAwwFCyAFIAIoAlBBwPXOABD9LwALIAQgAigCUEHYg88AEP0vAAsgAkEANgJYIAJBATYCTCACQbiEzwA2AkggAkIENwJQIAJByABqQcCEzwAQ7ywACyABQgE3A5gBQaABCyABaiANNwMACyAAQQg2AgALIAJB0AFqJAALwRkCNX8BfiMAQSBrIhAkAAJAIAJBBk0EQCAAQbwQaiEBIAAoAtQBQQdPBEAgASACEIgfQQEhBAwCCyABIAIgACgCzAEQqBhBASEEDAELIABBADYCiAYgACAAKALsBTYC8AUgACAAKALkBTYC6AUgACAAKALQECIGNgKEEiAAIAAoAvgBNgKIEiABIAAoAtwQayIDIAAoAvQQIgVBgANqSwRAIAAgA0HAASADIAVrQYADayIDIANBwAFPG2s2AvQQCwJ/QQEgACgA6BAgACgA5BBJDQAaQQAgACgCjBIiA0UNABpBA0ECIAMoAmwbCyEFIABB2BBqIRkgAEHkBWohGiAGQegjaiEGIAAoAtQQQegjaiEDA0AgBEEMRwRAIAMgBGogBCAGaigCADYCACAEQQRqIQQMAQsLAn8gACgCwBAgACgCyBBJBEBBVyEEIAAoAtgCDQIgAEG8EGogGSAaIAMgACgCvAIgASACEMIJDAELIAAoAowCQQFGBEAgEEEUakEANgIAIBBCADcCDEFXIQQgACgC2AINAiAQIAAoArQQNgIIIBAgACgCuBA2AhggEEEIaiEKIwBBIGsiFSQAIAJBFHYgAkH//z9xQQBHaiEuIABBkAZqIgdBsAJqIRsgB0GkAmohLyAHQSRqIRMgASACaiEwQQEgAEGMAmoiESgCFHQhHANAAkAgIyAuRg0AIAooAgwiKiAKKAIQTw0AAn8gMCABICNBFHQiA2oiCUGAgEBrIAIgA2tBgIDAAEkbIh0gBygABCIWayIIQYCAgIB6TQRAIAcoAhwMAQsgByAJQQJrIgMgHGs2AgQgByAHKAIUQQFqNgIUIAcgAyAWIBxqayIEIAcoAghqNgIIIAdBAiAHKAIQIgMgBGsgAyAEQQJqIgVJGzYCECAHQQIgBygCDCIDIARrIAMgBUkbNgIMQQEgESgCBHQhCCAHKAIYIQMDQCAIBEAgAyADKAIAIgUgBGsiBkEAIAUgBk8bNgIAIAhBAWshCCADQQhqIQMMAQsLIAdBADYCHCAdIAcoAgQiFmshCEEACyEDAkAgAyAcaiAITwRAIAcoABAhAyAHKAAMIQUMAQsgBygCECIDIAggHGsiBEkEQCAHIAQ2AhAgBCEDCyADIAcoAgwiBUsEQCAHIAM2AgwgAyEFCyAHQQA2AhwLIBEoAgghBCARKAIEIQYgESgCDCEXQQAhHiAFIgsgA00iMUUEQCAHKAIIIR4gAyELCyAdIAlrIiQhAyAXICRNBEAgBSAWaiElIAUgHmohKyALIB5qISYgCSAkaiIfQQhrISwgFUEQaiAREPwnQQAgF2shMiAJIBdqIRRBfyAGIARrdEF/cyEzQQEgBHRBA3QhNANAIBQgLEkEQCAVQQA2AgwgFCAyaiEGIBVBEGogFCAsIBRrIBMgFUEMahD8CiEnIBUoAgwiNSEIIBMhBCAbIQMDQCAIBEAgBiAEKAIAaiIMIBcQ0z0hOCADQQxrIAw2AgAgA0EEayA4QiCIPgIAIANBCGsgOKcgM3EiDDYCACADIAcoAhggDCARKAAIdEEDdGo2AgAgCEEBayEIIARBBGohBCADQRBqIQMMAQUgFCAnaiE2QQAhIANAAkACQCAgIDVHBH8gLyAgQQR0aiIDKAIAIg4gFmshKCADKAIEISEgAygCCCEpIAkgDksNASADKAIMIgMgNGohN0EAIRhBACEGQQAhDEEAIRIDQCADIDdJBEACQCADQQRqKAIAIClHDQAgAygCACIEIAtNDQACQCAxRQRAIA4gHiAWIAQgBUkiCBsgBGoiDyAOICsgHyAIGyIiIA9raiIEIB8gBCAdSRsQgBQiBCAPaiAiRgRAIAQgDmogJSAfEIAUIARqIQQLIAQgF0kNAiAOIAkgDyAmICUgCBsiIhD8JiEIICIgJkYgDyAIayAiR3INASAOIAhrIAkgKyAmEPwmIAhqIQgMAQsgDiAEIBZqIgggHxCAFCIEIBdJDQEgDiAJIAggJRD8JiEICyAEIAhqIg8gGE0NACAPIRggAyEGIAghDCAEIRILIANBCGohAwwBCwsgBkUNASAKKAIMIgMgCigCEEYEQEG6fyENDAoLIAogA0EBajYCDCAKKAIAIANBDGxqIgMgDCASajYCCCADIA4gDGsgCWs2AgQgAyAoIAYoAgBrNgIAIAcoAhggISARKAAIIgN0QQN0aiAHKAIgICFqIgQtAAAiBkEDdGogKK0gKa1CIIaENwIAIAQgBkEBakF/IAN0QX9zcToAACAOIBJqIgkgNk0NAiAJICdrBSAUCyAnaiEUDAYLIAcoAhggISARKAAIIgN0QQN0aiAHKAIgICFqIgQtAAAiBkEDdGogKK0gKa1CIIaENwIAIAQgBkEBakF/IAN0QX9zcToAAAsgIEEBaiEgDAALAAsACwALCyAdIAlrIQMLIANBiH9LBH8gAwUCfyAKKAIMICpLBEAgCigCACAqQQxsaiIEIAQoAgQgLWo2AgQgAwwBCyAkIC1qCyEtICNBAWohIwwCCyENCwsgFUEgaiQAIA0iBEGJf08NAiAKIBkgGiAAKALUEEHoI2ogACgCvAIgASACEMIJDAELIAAoAtgCBEBBln8hBAJAAkAgACgCtB0gACgCvB0gACgCwB0gASACQQBBACAAKALkAUEBIAAoArwBdCAAKAK4HREzACIDQQFrIAAoAsAdIgtPDQAgACgCvB0gA0EEdGoiBkEQaygCACAGQQhrKAIAcgRAIAMgC0YNASAGQgA3AgAgBkEIakIANwIAIANBAWohAwsgA0GIf00NASADIQQLIAAoAtQCRQ0DIABBADYCrBIgGSAaIAAoAtQQQegjaiABIAIgBUEobCAAKALUASIDQQJ0akGw9NAAaiIEIAQgBUEMbCADQQNrIgNBAnRqQdD10ABqIAAoArwCQQFHGyADQQJLGygCABEJAAwCCyAQQRBqQQA2AgAgEEIANwMIIAAoArwdIgxBCGohBCADIQVBACEGA0AgBQRAIAVBAWshBSAEKAIAIA1qIQ0gBEEEaygCACAGaiEGIARBEGohBAwBCwtBlX8hBCAGIA1qIAJLDQIgASEEIAAoAuACIRgjAEEQayIFJAAgEEEIaiIIKAIAIQsCfyAAKAKUEyIBBEAgASgCBAwBC0EAIAAoApgTRQ0AGiAAKAKcEwshByACIARqIRsgBUEIaiAAKALQECIBQfAjaigCADYCACAFIAEpAugjNwMAIAsgAyADIAtJGyECIABB5AVqIQkgDCALQQR0aiEDIBhBAkchDiALIQECQAJAAkACQANAAkACQCABIAJHBEAgA0EIaigCACISDQEgAygCAA0BIAEhAgsgAiALRiAYQQJHcg0EIAJBAWsiASALQQJqIgNJDQEgBSAMIAJBBHRqIgNBMGsoAgA2AgggBSADQSBrKAIANgIEDAMLIANBBGooAgAhEwJAIA5FBEAgAygCAEEDaiENDAELIAUCfyADKAIAIQYCfyATRSIPIg1FBEBBASAGIAUoAgBGDQEaC0ECIA1rIAUoAgQgBkYNARogDUEDcyAFKAIIIAZGDQEaIAZBA2oiCiANRQ0AGkEDIAogBiAFKAIAQQFrRhsLCyINIA8Q5RwLIAAoArQCBEAgCCAIKAIIIBIgE2pqIg82AghBlX8hBiANQQEgACgCvAF0IgogByAPaiAKIA9JG0EDaksNBiASQQNBA0EEIAAoAswBQQNGGyAAKALYAhtJDQYLIAAoAoAGIAEgCCgCAGtNDQQgCSATIAQgGyANIBIQhRIgA0EQaiEDIAFBAWohASAEIBJqIBNqIQQMAQsLIAIgA0YEQCAFIAUoAgA2AgggBSAMIAJBBHRqQSBrKAIANgIEDAELIAUgBSkDADcCBAsgBSAMIAFBBHRqKAIANgIACyAAKALUECIBIAUpAwA3AugjIAFB8CNqIAVBCGooAgA2AgAgDCACQQR0aiIDKAIEIgEEfyABBEAgACgC8AUgBCAB/AoAAAsgACAAKALwBSABajYC8AUgCCADQQRqKAIAIgEgCCgCCGo2AgggASAEagUgBAsgG0cNACAIIAJBAWo2AgBBACEGDAELQZV/IQYLIAVBEGokACAGIgRBiH9LDQJBACEEIABBADYCrBIMAgsgAEEANgKsEiAZIBogAyABIAIgBUEobCAAKALUASIDQQJ0akGw9NAAaiIEIAQgBUEMbCADQQNrIgNBAnRqQdD10ABqIAAoArwCQQFHGyADQQJLGygCABEJAAsiAwRAIAAoAvAFIAEgAmogA2sgA/wKAAALIAAgACgC8AUgA2o2AvAFQQAhBAsgEEEgaiQAIAQL5ggCBn8BfiMAQYABayIEJAAgAC0AxAMhBQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAA1AuwDIgogACkDyANSBEAgBUEBcUUNByABRQ0EIAEoAiBFDQIgASgCNEUNAyABQSRqIQUgAUE4aiEIIAAoArgERQ0GIABBzARqIQYgAEG8BGohByAALQCUBQ0BDAULIAVBAXFFDQYgBEEANgJIIARCgICAgBA3AkAgBEEANgJYIARCgICAgBA3AlAgAEH4AmpBASAEQUBrIARB0ABqIAoQlRQMBgsgACgCgAVBCGogByAFEIkNRQRAIAAoAoAFQQhqIAYgCBCJDUUNBAsgAEEAOgCUBQwDC0HIgM8AELI7AAtB2IDPABCyOwALIABBADoAxAMMAgsgAC0AlQVFDQAgACgCgAVBCGogBSAHEIkNRQRAIAAoAoAFQQhqIAggBhCJDUUNAQsgAEEAOgCVBQsCQCAFKAIAIgUEQCAEQeAAaiABQTBqIAEoAiggASgCLCAFKAIAEQUADAELIARBADYCYAsgAEG4BGoCQCAIKAIAIggEQCAEQfAAaiABQcQAaiABKAI8IAEoAkAgCCgCABEFAAwBCyAEQQA2AnALIABB+AJqIQggBEEwaiIGIAQpAnA3AwAgBEEoaiIHIARB6ABqKQIANwMAIARBOGoiCSAEQfgAaikCADcDACAEIAQpAmA3AyAQ8SYgAEEBNgK4BCAAIAQpAyA3ArwEIABBxARqIAcpAwA3AgAgAEHMBGogBikDADcCACAAQdQEaiAJKQMANwIAIAAQ5x9FBEAgBEEYaiABEO4nIAQoAhgiCUUNAiAEQdAAaiAEKAIcIgVBAEEBQQEQoBggBCgCVCEGIAQoAlBBAUYNAyAEKAJYIQcgBQRAIAcgCSAF/AoAAAsgBCAFNgJIIAQgBzYCRCAEIAY2AkAgBEEQaiABEO8nIAQoAhAiB0UNBCAEQdAAaiAEKAIUIgFBAEEBQQEQoBggBCgCVCEFIAQoAlBBAUYNBSAEKAJYIQYgAQRAIAYgByAB/AoAAAsgBCABNgJYIAQgBjYCVCAEIAU2AlAgCEEAIARBQGsgBEHQAGogACkDyAMQlRQMAQsgACgChAUiBSgCPCEGIAUoAjghBSAEQQhqIAEQ7icgBCgCCCIHRQ0FIARBQGsiCSAAIAUgBiAHIAQoAgwQnA0gACgChAUiBSgCPCEGIAUoAjghBSAEIAEQ7ycgBCgCACIBRQ0GIARB0ABqIgcgACAFIAYgASAEKAIEEJgMIAhBACAJIAcgACkDyAMQlRQLIABB+AJqIABB0ANqIABB3ANqEJYTIAAoAvgDQYCAgIB4RwRAIABB8ANqIgEgADUC7AMQpicgASACIAMQ1xkLIARBgAFqJAAPC0HogM8AELI7AAsgBiAEKAJYQcD1zgAQ/S8AC0H4gM8AELI7AAsgBSAEKAJYQcD1zgAQ/S8AC0GIgc8AELI7AAtBmIHPABCyOwAL+QcCDn8DfiMAQTBrIgMkAAJAIAEoAlwiBgRAIAFB3ABqIQogASgCRCEFIAEoAkghBEL///////////8AIRECQAJAAkACQAJAAkACQAJAA0AgAiAERg0BIAUpAwAiECARIBAgEVMbIREgBUEIaiEFIAYgAkEBaiICRw0ACyABQRhqIBFCAYYgEUI/h4UQqhIgASgCWCEGIAEtACwhBCADIAEpAxg3AxAgBEEDdiAEQQdxQQBHaiIEQQlPDQEgAUEgaiILIANBEGogBBChNiABQQA6ACwgAUIANwMYIAEoAighDSADQQhqIAYQ+jcgCyADKAIIIAMtAAwQjykgASgCXCECIAEoAlgiDkUNByANIQRBACEGA0AgAiABKAJUIgcgAiAHSRsiCQRAIAZBAWogBiAHbCECIAEoAkQgByAMbGohBSABKAJIIQhCgICAgICAgICAfyEQIAkhBwNAIAIgCE8NBiAFKQMAIhIgECAQIBJTGyEQIAVBCGohBSACQQFqIQIgB0EBayIHDQALIAYgDWoiByABKAIoIgJPDQYgASgCJCAHakHAACAQIBF9eadrIgc6AABBACEFA0AgBSAGIAEoAlRsaiICIAEoAkgiCE8NCCABKAJEIAJBA3RqKQMAIRAgASABLQAsIgggB2oiAjoALCABIAEpAxggECARfSISIAhBP3GthoQiEDcDGCACQf8BcUHAAE8EQCADIBA3AxAgCyADQRBqQQgQoTYgASACQUBqIgI6ACwgASASIAcgAmsiCK2IQgAgCEH/AXFBwABJGyIQNwMYCyAJIAVBAWoiBUcNAAsgCSABKAJUIgZJBEAgBiAJayEFA0AgASACIAdqIgI6ACwgAkH/AXFBwABPBEAgAyAQNwMQIAsgA0EQakEIEKE2IAFCADcDGCABIAJBQGoiAjoALEIAIRALIAVBAWsiBQ0ACwsgCiAKKAIAIAlrIgI2AgAgDEEIaiEMIARBAWohBCIGIA5HDQEMCQsLIAYgASgCWCIFTw0HIAEoAiQhCSABKAIoIQEDQCABIARNDQMgBCAJakEAOgAAIARBAWohBCAFQQFrIgUgBkcNAAsMBgsgBCAGQQFrIgAgACAESxsgBEHwns4AEMMhAAsgBEEIQeiOzgAQsDsACyAEIAFBiLbOABDDIQALIAIgCEHgns4AEMMhAAsgByACQYi2zgAQwyEACyACIAhB0J7OABDDIQALIAooAgAhAgsgAg0BCyAAQQg2AgAgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQbiezgA2AhAgA0E7NgIsIAMgCjYCKCADIANBKGo2AhhBACAKQciGzgAgA0EQakHAns4AEK8rAAv3BwIYfwJ+IwBBIGsiBSQAIAEoAhgiCCABKAIQIgZPBEAgCEF/QXlBfSABLwE0IgNBAiADGyIDQQdLGyADQQNNGyADaiIJTwRAIAggBiAJaiIHTwRAIAEoAlAiC0GGAmsiCkEAIAogC00bIAZPBEAgASgCICIEQQFrIQ0gAS8BDCEKIAEoAiQhECAGIARrQYYCaiIEQQAgBCAGTRshDiABLwEKIRQgAS8BNiIEIARBAnYgAyABLwEISRshDCABKAIUIgQgBmoiD0ECaiEVIARBAmohFiAEIAlqIREgBCAHaiESIAQgC2pBAWshFyABKAIoIQsgASgCLCEHIAggBmsiE0ECa0H/AUshGCABLAAEQQVIIRkCQANAAkAgBiACQf//A3FNDQACQAJAAkACQAJAAkACQCADQQhPBEAgEikAACEbA0AgGyARIAJB//8DcSIBaikAAFEEQCABIARqKQAAIA8pAABRDQMLIAxBAWsiDEH//wNxRQ0JIAcgASANcSIBSwRAIAsgAUEBdGovAQAiAiAOQf//A3FLDQEMCgsLIAEgB0GA4vwAEMMhAAsgDykAACEbA0AgGyAEIAJB//8DcSIJaikAACIcUQ0BIBsgHIV6p0EDdiIBIANLDQIgDEEBayIMQf//A3FFDQggByAJIA1xIgFLBEAgCyABQQF0ai8BACICIA5B//8DcUsNAQwJCwsgASAHQZDi/AAQwyEACyATQQFNDQEgGEUNAiAWIAJB//8DcWohGkEAIQEDQAJAIAEgFWotAAAgASAaai0AAEcEQCABIQkMAQtBgAIhCSABQQFqIgFBgAJHDQELCyAJQQJqIQELIAEgD2ogF0sNAgJAIAEgA0sEQCABIBBNDQEgAiEKIBAhAwwHCyAZDQYMBQsgASAUTwRAIAIhCiABIQMMBgtBf0F5QX0gAUEHSxsgAUEDTRsgAWoiCiAGaiIDIAhLDQMgBCAKaiERIAMgBGohEiABIQMgAiEKDAQLQQIgE0Gg4vwAEK87AAtB2O/8ABCyOwALIAVBADYCGCAFQQE2AgwgBUG84vwANgIIIAVCBDcCECAFQQhqQcTi/AAQ7ywACyADIAhB1OL8ABCvOwALIAxBAWsiDEH//wNxRQ0AIAIgDXFB//8DcSIBIAdPDQIgCyABQQF0ai8BACICIA5B//8DcUsNAQsLIAAgCjsBBCAAIAM2AgAgBUEgaiQADwsgASAHQeTi/AAQwyEACyAFQQA2AhggBUEBNgIMIAVB6OH8ADYCCCAFQgQ3AhAgBUEIakHw4fwAEO8sAAsgByAIQcjh/AAQrzsACyAJIAhBuOH8ABCvOwALIAYgCEGo4fwAEK87AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGooAgghBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahCzDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxCzDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDbPCEGIARBGGogARCSNhDuJSAGQQV0IgMhAgJAAkACQAJAAkACQAJAIANBIHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEKENIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEKENIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ4hkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQzh0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBAnQiAyECAkACQAJAAkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQvBEgBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQvBEgBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDlGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDSHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGooAgghBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahC0DSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxC0DSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQJ0IgMhAgJAAkACQAJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEL0RIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEL0RIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ5RkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQ0h0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBBXQiAyECAkACQAJAAkACQAJAAkAgA0EgcSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQog0gBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQog0gBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDiGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDOHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGoQ2zwhBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahCjDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxCjDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQJ0IgMhAgJAAkACQAJAAkACQAJAIANBPHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEL4RIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEL4RIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ5RkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQ0h0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENk8IQYgBEEYaiABEJI2EO4lIAZBBXQiAyECAkACQAJAAkACQAJAAkAgA0EgcSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQpA0gBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQpA0gBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDiGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDOHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAumCAIEfwN+IwBBsAFrIgQkACAEIAM2AhQgBCACNgIQIAFBDGoQ2TwhBiAEQRhqIAEQkjYQ7iUgBkEFdCIDIQICQAJAAkACQAJAAkACQCADQSBxIgUEQCADIAVrQUBrIgIgA0kNAQtBwAAhBSACQcAAENE0BEACQCACBEAgAkHAABCtNiIFRQ0BCyAEIAU2AjggBCACNgI0IARBwAA2AjAgAwRAIAVBACAD/AsACyAEIAY2AkAgBCADNgI8IAQgATYCUCAEIAY2AkggBCAFNgJEIAQgBEEQajYCTCAEKAIYRQ0DIAQoAiwgBCgCKEYNBCAEQeAAaiAEQRhqEMg0IARBgAFqIQEDQAJAIAQpA4gBIglQRQRAIAQpA5ABIQgMAQsDQAJ+AkAgBCkDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAQgCFCtQgGGNwNwIAinQQFxRQ0AIAQgBCkDeDcDoAEMAQsgBCgCgAFFDQEgBEGYAWogARC2KiAEKQOYASEICyAIQgBSDQILIARCAzcDcAsgBCkDYCIIQgJRDQkgBEIANwNgIAQpA2gMAQsgBCkDoAELIQkgCKdBAXFFDQcgBCAEKQOQAUJAfSIINwOQASAEIAk3A4gBIAlQDQALCyAEIAlCASAJeiIKhoU3A4gBIARBmAFqIARBxABqIAqnIAinahClDSAEKAKYASICQZOAgIB4Rg0ACyAAIAQpApwBNwIIIABBEGogBEGkAWopAgA3AgAMBgtBwAAgAhCjPQALQdyL/wBBKSAEQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEDA0AgBEHgAGogBEHEAGogAxClDSAEKAJgIgJBk4CAgHhHDQIgBiADQQFqIgNHDQALCyAEQeAAaiICEJcpIARBOGoiASgCACEFIAQoAjwhAyABIARB6ABqIgYpAgA3AwAgBCkDMCEIIAQgBCkCYDcDMCAEQQA2AkAgBCAINwJsIARBADYCaCAEIAM2AmQgBCAFNgJgIARBCGogAhDXOyAEKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAQpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogBEHwAGoiBygCADYCACAEIAM2AqABIAQgBTYCnAEgBCABNgKYASAEQdQAaiIBIARBmAFqEOIZIAcgBEEoaikCADcDACAGIARBIGopAgA3AwAgBCAEKQIYNwNgIAAgASACEM4dIARBMGoQzy8MAgsgACAEKQJkNwIIIABBEGogBEHsAGopAgA3AgALIABBKToAACAAIAI2AgQgBEEwahDPLyAEKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIARBGGoQ+x4LIARBsAFqJAAPC0EEQRwQoz0AC6YIAgR/A34jAEGwAWsiBCQAIAQgAzYCFCAEIAI2AhAgAUEMahDYPCEGIARBGGogARCSNhDuJSAGQQV0IgMhAgJAAkACQAJAAkACQAJAIANBIHEiBQRAIAMgBWtBQGsiAiADSQ0BC0HAACEFIAJBwAAQ0TQEQAJAIAIEQCACQcAAEK02IgVFDQELIAQgBTYCOCAEIAI2AjQgBEHAADYCMCADBEAgBUEAIAP8CwALIAQgBjYCQCAEIAM2AjwgBCABNgJQIAQgBjYCSCAEIAU2AkQgBCAEQRBqNgJMIAQoAhhFDQMgBCgCLCAEKAIoRg0EIARB4ABqIARBGGoQyDQgBEGAAWohAQNAAkAgBCkDiAEiCVBFBEAgBCkDkAEhCAwBCwNAAn4CQCAEKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgBCAIUK1CAYY3A3AgCKdBAXFFDQAgBCAEKQN4NwOgAQwBCyAEKAKAAUUNASAEQZgBaiABELYqIAQpA5gBIQgLIAhCAFINAgsgBEIDNwNwCyAEKQNgIghCAlENCSAEQgA3A2AgBCkDaAwBCyAEKQOgAQshCSAIp0EBcUUNByAEIAQpA5ABQkB9Igg3A5ABIAQgCTcDiAEgCVANAAsLIAQgCUIBIAl6IgqGhTcDiAEgBEGYAWogBEHEAGogCqcgCKdqEKYNIAQoApgBIgJBk4CAgHhGDQALIAAgBCkCnAE3AgggAEEQaiAEQaQBaikCADcCAAwGC0HAACACEKM9AAtB3Iv/AEEpIARB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQMDQCAEQeAAaiAEQcQAaiADEKYNIAQoAmAiAkGTgICAeEcNAiAGIANBAWoiA0cNAAsLIARB4ABqIgIQlykgBEE4aiIBKAIAIQUgBCgCPCEDIAEgBEHoAGoiBikCADcDACAEKQMwIQggBCAEKQJgNwMwIARBADYCQCAEIAg3AmwgBEEANgJoIAQgAzYCZCAEIAU2AmAgBEEIaiACENc7IAQoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgBCkCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiAEQfAAaiIHKAIANgIAIAQgAzYCoAEgBCAFNgKcASAEIAE2ApgBIARB1ABqIgEgBEGYAWoQ4hkgByAEQShqKQIANwMAIAYgBEEgaikCADcDACAEIAQpAhg3A2AgACABIAIQzh0gBEEwahDPLwwCCyAAIAQpAmQ3AgggAEEQaiAEQewAaikCADcCAAsgAEEpOgAAIAAgAjYCBCAEQTBqEM8vIAQoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgBEEYahD7HgsgBEGwAWokAA8LQQRBHBCjPQALpggCBH8DfiMAQbABayIEJAAgBCADNgIUIAQgAjYCECABQQxqENg8IQYgBEEYaiABEJI2EO4lIAZBAnQiAyECAkACQAJAAkACQAJAAkAgA0E8cSIFBEAgAyAFa0FAayICIANJDQELQcAAIQUgAkHAABDRNARAAkAgAgRAIAJBwAAQrTYiBUUNAQsgBCAFNgI4IAQgAjYCNCAEQcAANgIwIAMEQCAFQQAgA/wLAAsgBCAGNgJAIAQgAzYCPCAEIAE2AlAgBCAGNgJIIAQgBTYCRCAEIARBEGo2AkwgBCgCGEUNAyAEKAIsIAQoAihGDQQgBEHgAGogBEEYahDINCAEQYABaiEBA0ACQCAEKQOIASIJUEUEQCAEKQOQASEIDAELA0ACfgJAIAQpA3AiCEIDUgRAAkACQAJAIAhCAlENACAEIAhQrUIBhjcDcCAIp0EBcUUNACAEIAQpA3g3A6ABDAELIAQoAoABRQ0BIARBmAFqIAEQtiogBCkDmAEhCAsgCEIAUg0CCyAEQgM3A3ALIAQpA2AiCEICUQ0JIARCADcDYCAEKQNoDAELIAQpA6ABCyEJIAinQQFxRQ0HIAQgBCkDkAFCQH0iCDcDkAEgBCAJNwOIASAJUA0ACwsgBCAJQgEgCXoiCoaFNwOIASAEQZgBaiAEQcQAaiAKpyAIp2oQvxEgBCgCmAEiAkGTgICAeEYNAAsgACAEKQKcATcCCCAAQRBqIARBpAFqKQIANwIADAYLQcAAIAIQoz0AC0Hci/8AQSkgBEHgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAwNAIARB4ABqIARBxABqIAMQvxEgBCgCYCICQZOAgIB4Rw0CIAYgA0EBaiIDRw0ACwsgBEHgAGoiAhCXKSAEQThqIgEoAgAhBSAEKAI8IQMgASAEQegAaiIGKQIANwMAIAQpAzAhCCAEIAQpAmA3AzAgBEEANgJAIAQgCDcCbCAEQQA2AmggBCADNgJkIAQgBTYCYCAEQQhqIAIQ1zsgBCgCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASAEKQJgNwIIIAFBEGogBikCADcCACABQRhqIARB8ABqIgcoAgA2AgAgBCADNgKgASAEIAU2ApwBIAQgATYCmAEgBEHUAGoiASAEQZgBahDlGSAHIARBKGopAgA3AwAgBiAEQSBqKQIANwMAIAQgBCkCGDcDYCAAIAEgAhDSHSAEQTBqEM8vDAILIAAgBCkCZDcCCCAAQRBqIARB7ABqKQIANwIACyAAQSk6AAAgACACNgIEIARBMGoQzy8gBCgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACAEQRhqEPseCyAEQbABaiQADwtBBEEcEKM9AAvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKAFiIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQcAFRw0ACyABQQFrDgQFBAMCAQsgAUEFQdjD0AAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgBZHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0HABU8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQcAFQZjE0AAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0HABUkEQCACKAIUIgFBwAVPBEAgAUHABUH4w9AAEMMhAAsgAigCGCIEQcAFSQ0BIARBwAVBiMTQABDDIQALIANBwAVB6MPQABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKACCIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQYACRw0ACyABQQFrDgQFBAMCAQsgAUEFQdjD0AAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgAhHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0GAAk8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQYACQZjE0AAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0GAAkkEQCACKAIUIgFBgAJPBEAgAUGAAkH4w9AAEMMhAAsgAigCGCIEQYACSQ0BIARBgAJBiMTQABDDIQALIANBgAJB6MPQABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQvQBwIIfwN9IwBB8ABrIgIkACACQSBqQQA2AgAgAkEYakIANwMAIAJCADcDEEMAAEBBIQkCQCAAKAKAESIFRQ0AIAAhAwJAAkACQAJAAkADQCADKAIABEAgAUEFTw0CIAJBEGogAUECdGogBDYCACABQQRGDQMgAUEBaiEBCyADQQRqIQMgBEEBaiIEQaAERw0ACyABQQFrDgQFBAMCAQsgAUEFQcSX0gAQwyEACyACQShqQQBByAD8CwACfSAFQYACTwRAIAWzEOoSDAELIAVBAnRBwIfzAGoqAgALIQpDAAAAACEJQQAhA0EAIQFBASEGQQAhBANAIAAgBGooAgAiBQR/AkAgAUUNACABQQNPBEAgAUECayEBA0AgCUMAAEBAkiEJIANBAWohAyABQQdLIAFBA3YhAQ0ACwwBCyACIAIoAiggAWo2AigLIAJBKGpBDyAKIAVB//8DcUECdEHMhuMAaioCAJMiC0MAAAA/kvwBIgEgAUEPTxsiAUECdGoiByAHKAIAQQFqNgIAIAYgASABIAZJGyEGIAkgCyAFs5SSIQlBAAUgAUEBagshASAEQQRqIgRBgBFHDQALIAIgAzYCbCACQQhqIAJBKGpBEkESEIERIAkgBkEBdEESarOSIAIoAgyzIgkgAioCCCIKIAkgCl4bkiEJDAMLIAJBMGpCADcDACACQgA3AyhBACEBAkACQANAIAJBEGogAWooAgAiA0GgBE8NASACQShqIgQgAWogACADQQJ0aigCADYCACABQQRqIgFBEEcNAAsgBEEEciEAQQMhBQwBCyADQaAEQYSY0gAQwyEACwNAIAZBAk0EQCACQShqIAZBAnRqIggoAgAhBCAAIQEgBSEDA0AgBCABKAIAIgdJBEAgASAENgIAIAggBzYCACAHIQQLIAFBBGohASADQQFrIgMNAAsLIABBBGohACAFQQFrIQUgBkEBaiIGQQRHDQALIAIoAjQgAigCMGoiAEEDbLNDAAAUQpIgAigCKCIDIAIoAixqQQF0s5IgAyAAIAAgA0kbs5MhCQwCCwJAIAIoAhAiA0GgBEkEQCACKAIUIgFBoARPBEAgAUGgBEHkl9IAEMMhAAsgAigCGCIEQaAESQ0BIARBoARB9JfSABDDIQALIANBoARB1JfSABDDIQALIAAgBEECdGooAgAiBCAAIAFBAnRqKAIAIgEgACADQQJ0aigCACIAampBAXSzQwAA4EGSIAQgASABIARJGyIDIAAgACADSRuzkyEJDAELIAWzQwAAoEGSIQkLIAJB8ABqJAAgCQufCAIFfwN+IwBBsAFrIgMkACADIAI2AhQgAUEMahDYPCEGIANBGGogARCSNhDuJSAGQQN0IgIhBAJAAkACQAJAAkACQAJAIAJBOHEiBQRAIAIgBWtBQGsiBCACSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAMgBTYCOCADIAQ2AjQgA0HAADYCMCACBEAgBUEAIAL8CwALIAMgBjYCQCADIAI2AjwgAyABNgJQIAMgBjYCSCADIAU2AkQgAyADQRRqNgJMIAMoAhhFDQMgAygCLCADKAIoRg0EIANB4ABqIANBGGoQyDQgA0GAAWohAQNAAkAgAykDiAEiCVBFBEAgAykDkAEhCAwBCwNAAn4CQCADKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A3AgCKdBAXFFDQAgAyADKQN4NwOgAQwBCyADKAKAAUUNASADQZgBaiABELYqIAMpA5gBIQgLIAhCAFINAgsgA0IDNwNwCyADKQNgIghCAlENCSADQgA3A2AgAykDaAwBCyADKQOgAQshCSAIp0EBcUUNByADIAMpA5ABQkB9Igg3A5ABIAMgCTcDiAEgCVANAAsLIAMgCUIBIAl6IgqGhTcDiAEgA0GYAWogA0HEAGogCqcgCKdqEMwPIAMoApgBIgRBk4CAgHhGDQALIAAgAykCnAE3AgggAEEQaiADQaQBaikCADcCAAwGC0HAACAEEKM9AAtB3Iv/AEEpIANB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQIDQCADQeAAaiADQcQAaiACEMwPIAMoAmAiBEGTgICAeEcNAiAGIAJBAWoiAkcNAAsLIANB4ABqIgIQlykgA0E4aiIBKAIAIQUgAygCPCEEIAEgA0HoAGoiBikCADcDACADKQMwIQggAyADKQJgNwMwIANBADYCQCADIAg3AmwgA0EANgJoIAMgBDYCZCADIAU2AmAgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQfAAaiIHKAIANgIAIAMgBDYCoAEgAyAFNgKcASADIAE2ApgBIANB1ABqIgEgA0GYAWoQ5BkgByADQShqKQIANwMAIAYgA0EgaikCADcDACADIAMpAhg3A2AgACABIAIQ1h0gA0EwahDPLwwCCyAAIAMpAmQ3AgggAEEQaiADQewAaikCADcCAAsgAEEpOgAAIAAgBDYCBCADQTBqEM8vIAMoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahD7HgsgA0GwAWokAA8LQQRBHBCjPQALnwgCBX8DfiMAQbABayIDJAAgAyACNgIUIAFBDGoQ2DwhBiADQRhqIAEQkjYQ7iUgBkEDdCICIQQCQAJAAkACQAJAAkACQCACQThxIgUEQCACIAVrQUBrIgQgAkkNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyADIAU2AjggAyAENgI0IANBwAA2AjAgAgRAIAVBACAC/AsACyADIAY2AkAgAyACNgI8IAMgATYCUCADIAY2AkggAyAFNgJEIAMgA0EUajYCTCADKAIYRQ0DIAMoAiwgAygCKEYNBCADQeAAaiADQRhqEMg0IANBgAFqIQEDQAJAIAMpA4gBIglQRQRAIAMpA5ABIQgMAQsDQAJ+AkAgAykDcCIIQgNSBEACQAJAAkAgCEICUQ0AIAMgCFCtQgGGNwNwIAinQQFxRQ0AIAMgAykDeDcDoAEMAQsgAygCgAFFDQEgA0GYAWogARC2KiADKQOYASEICyAIQgBSDQILIANCAzcDcAsgAykDYCIIQgJRDQkgA0IANwNgIAMpA2gMAQsgAykDoAELIQkgCKdBAXFFDQcgAyADKQOQAUJAfSIINwOQASADIAk3A4gBIAlQDQALCyADIAlCASAJeiIKhoU3A4gBIANBmAFqIANBxABqIAqnIAinahDNDyADKAKYASIEQZOAgIB4Rg0ACyAAIAMpApwBNwIIIABBEGogA0GkAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSADQeAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACECA0AgA0HgAGogA0HEAGogAhDNDyADKAJgIgRBk4CAgHhHDQIgBiACQQFqIgJHDQALCyADQeAAaiICEJcpIANBOGoiASgCACEFIAMoAjwhBCABIANB6ABqIgYpAgA3AwAgAykDMCEIIAMgAykCYDcDMCADQQA2AkAgAyAINwJsIANBADYCaCADIAQ2AmQgAyAFNgJgIANBCGogAhDXOyADKAIIIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAmA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HwAGoiBygCADYCACADIAQ2AqABIAMgBTYCnAEgAyABNgKYASADQdQAaiIBIANBmAFqEOQZIAcgA0EoaikCADcDACAGIANBIGopAgA3AwAgAyADKQIYNwNgIAAgASACENYdIANBMGoQzy8MAgsgACADKQJkNwIIIABBEGogA0HsAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EwahDPLyADKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBGGoQ+x4LIANBsAFqJAAPC0EEQRwQoz0AC58IAgV/A34jAEGwAWsiAyQAIAMgAjYCFCABQQxqENg8IQYgA0EYaiABEJI2EO4lIAZBA3QiAiEEAkACQAJAAkACQAJAAkAgAkE4cSIFBEAgAiAFa0FAayIEIAJJDQELQcAAIQUgBEHAABDRNARAAkAgBARAIARBwAAQrTYiBUUNAQsgAyAFNgI4IAMgBDYCNCADQcAANgIwIAIEQCAFQQAgAvwLAAsgAyAGNgJAIAMgAjYCPCADIAE2AlAgAyAGNgJIIAMgBTYCRCADIANBFGo2AkwgAygCGEUNAyADKAIsIAMoAihGDQQgA0HgAGogA0EYahDINCADQYABaiEBA0ACQCADKQOIASIJUEUEQCADKQOQASEIDAELA0ACfgJAIAMpA3AiCEIDUgRAAkACQAJAIAhCAlENACADIAhQrUIBhjcDcCAIp0EBcUUNACADIAMpA3g3A6ABDAELIAMoAoABRQ0BIANBmAFqIAEQtiogAykDmAEhCAsgCEIAUg0CCyADQgM3A3ALIAMpA2AiCEICUQ0JIANCADcDYCADKQNoDAELIAMpA6ABCyEJIAinQQFxRQ0HIAMgAykDkAFCQH0iCDcDkAEgAyAJNwOIASAJUA0ACwsgAyAJQgEgCXoiCoaFNwOIASADQZgBaiADQcQAaiAKpyAIp2oQzg8gAygCmAEiBEGTgICAeEYNAAsgACADKQKcATcCCCAAQRBqIANBpAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HgAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAgNAIANB4ABqIANBxABqIAIQzg8gAygCYCIEQZOAgIB4Rw0CIAYgAkEBaiICRw0ACwsgA0HgAGoiAhCXKSADQThqIgEoAgAhBSADKAI8IQQgASADQegAaiIGKQIANwMAIAMpAzAhCCADIAMpAmA3AzAgA0EANgJAIAMgCDcCbCADQQA2AmggAyAENgJkIAMgBTYCYCADQQhqIAIQ1zsgAygCCCEFQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASADKQJgNwIIIAFBEGogBikCADcCACABQRhqIANB8ABqIgcoAgA2AgAgAyAENgKgASADIAU2ApwBIAMgATYCmAEgA0HUAGoiASADQZgBahDkGSAHIANBKGopAgA3AwAgBiADQSBqKQIANwMAIAMgAykCGDcDYCAAIAEgAhDWHSADQTBqEM8vDAILIAAgAykCZDcCCCAAQRBqIANB7ABqKQIANwIACyAAQSk6AAAgACAENgIEIANBMGoQzy8gAygCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQRhqEPseCyADQbABaiQADwtBBEEcEKM9AAufCAIFfwN+IwBBsAFrIgMkACADIAI2AhQgAUEMahDYPCEGIANBGGogARCSNhDuJSAGQQN0IgIhBAJAAkACQAJAAkACQAJAIAJBOHEiBQRAIAIgBWtBQGsiBCACSQ0BC0HAACEFIARBwAAQ0TQEQAJAIAQEQCAEQcAAEK02IgVFDQELIAMgBTYCOCADIAQ2AjQgA0HAADYCMCACBEAgBUEAIAL8CwALIAMgBjYCQCADIAI2AjwgAyABNgJQIAMgBjYCSCADIAU2AkQgAyADQRRqNgJMIAMoAhhFDQMgAygCLCADKAIoRg0EIANB4ABqIANBGGoQyDQgA0GAAWohAQNAAkAgAykDiAEiCVBFBEAgAykDkAEhCAwBCwNAAn4CQCADKQNwIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A3AgCKdBAXFFDQAgAyADKQN4NwOgAQwBCyADKAKAAUUNASADQZgBaiABELYqIAMpA5gBIQgLIAhCAFINAgsgA0IDNwNwCyADKQNgIghCAlENCSADQgA3A2AgAykDaAwBCyADKQOgAQshCSAIp0EBcUUNByADIAMpA5ABQkB9Igg3A5ABIAMgCTcDiAEgCVANAAsLIAMgCUIBIAl6IgqGhTcDiAEgA0GYAWogA0HEAGogCqcgCKdqEM8PIAMoApgBIgRBk4CAgHhGDQALIAAgAykCnAE3AgggAEEQaiADQaQBaikCADcCAAwGC0HAACAEEKM9AAtB3Iv/AEEpIANB4ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQIDQCADQeAAaiADQcQAaiACEM8PIAMoAmAiBEGTgICAeEcNAiAGIAJBAWoiAkcNAAsLIANB4ABqIgIQlykgA0E4aiIBKAIAIQUgAygCPCEEIAEgA0HoAGoiBikCADcDACADKQMwIQggAyADKQJgNwMwIANBADYCQCADIAg3AmwgA0EANgJoIAMgBDYCZCADIAU2AmAgA0EIaiACENc7IAMoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCYDcCCCABQRBqIAYpAgA3AgAgAUEYaiADQfAAaiIHKAIANgIAIAMgBDYCoAEgAyAFNgKcASADIAE2ApgBIANB1ABqIgEgA0GYAWoQ5BkgByADQShqKQIANwMAIAYgA0EgaikCADcDACADIAMpAhg3A2AgACABIAIQ1h0gA0EwahDPLwwCCyAAIAMpAmQ3AgggAEEQaiADQewAaikCADcCAAsgAEEpOgAAIAAgBDYCBCADQTBqEM8vIAMoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgA0EYahD7HgsgA0GwAWokAA8LQQRBHBCjPQALqXMCKH8GfiMAQfAAayIUJAAgAUEwaiEkIAFB/ABqISsgAUHMAGohFyABQcgAaiEYAkADQAJAAkACQAJAAkACQAJAAkBBgICAgHggGCgCACIFIAVBgICAgHhNG0H/////B3FBAWsOBAIDAQQACyAUQTBqIBggARD2AwJAIBQtADBBBEYNACAUKQMwIixC/wGDQgRRDQAgACAsNwIADAkLIBRBMGoiBSAYQTz8CgAAIAFBADoAgAEgAUEGOgB0IAFBADoAcCABQQA2AmwgAUGAgICAeDYCYCABQYCAgIB4NgJUIAFBgICAgHg2AkggFEEEaiIGIAUQkCsgGBCzGyABQYGAgIB4NgJIIBcgBkEs/AoAAAwHCyAXKQIAISwgF0KB0AA3AgAgGBCzGyAXQYGAgIB4NgIAIBhBhICAgHg2AgAgACAsNwIADAcLAkAgAwRAIBRBMGohJSMAQRBrIiIkACAiQQhqISMgAUEYaiEaIwBBEGsiGSQAIBlBBGogARDbFgJAAkAgGSgCBEUEQANAIBopAwghMCAaKQMAITEgGUEEaiEbIBkoAgghJyAZKAIMIighBSMAQTBrIhYkACAaKAIQIhFBADYCGCARIAM2AhAgESACNgIMIBEgBTYCBCARICc2AgAgKEVBAnQhBUF+IQYCQCARRQ0AIBEoAiBFDQAgESgCJEUNACARKAIcRQ0AAn9CgICIgMCggQMgBa1CA4aIp0EAIAVBB0kbISkjAEEwayIKJABBfiEFAkACQCARKAIMIglFDQAgESgCACIGQQEgESgCBCIIG0UNACARKAIcIgQtAAAiBUEMRgRAIARBDToAAEENIQULIAQgBjYCOCAEICk6AAQgBCAINgJwIARBADYCUCAEIAk2AkggBCAGIAhqNgI8IAQgESgCECIGNgJ0IAQgBjYCTCAEQQhqISogBEGE7ABqISYgBEGE5wBqIRwgBEGkAWohHSAEQfQqaiEeIARBxNQAaiEhIARByABqIQ4gBEHBAGohEAJAAkACQANAAkAgBSEHQRIhBUF8IQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgB0H/AXFBAWsOHiEgHw8ODQwLAiQcGwoaIwklGRgXCAcWFQABFBMSERALAkAgBCgCJCIFIAQoAhgiCEkEQEETIAUgBUETTRshDCAEKAI4IQkgBCkDMCEtIAQtAEAhBiAEKAI8IQsDQAJAIAZB/wFxQQJLBEAgLSEsIAYhBwwBCyAJIAtGBEBBACEGQRkhBwwoCyAEIAlBAWoiDTYCOCAEIAZBCHIiBzoAQCAEIAkxAAAgBq2GIC2EIiw3AzAgDSEJCyAFIAxGDQIgBCAHQQNrIgY6AEAgBCAsQgOIIi03AzAgBCAFQQFqIgc2AiQgHCAFQdiS/ABqLQAAQQF0aiAsp0EHcTsBACAHIgUgCEcNAAsgCCEFCyAFQRJLDQYDQCAcIAVB2JL8AGotAABBAXRqQQA7AQAgBUEBaiIFQRNHDQALDAULIAxBE0HskvwAEMMhAAsgBCgCJCIPIAQoAiAiDSAEKAIcIgxqIghPDQIDQEJ/IAQ1ApQBhkJ/hSEtIAQoAjghBSAELQBAIQYgBCgCPCESIAQpAzAhLCAELQCYASETIAQCfwJAAkACQAJAAkACQAJAAkACQANAICwgLYOnIQdBzP/7ACELQYAEIQkCQAJAAkACQCATQQFrDgMAAQIDC0G0CiEJIB0hCwwCC0G0CiEJIB4hCwwBC0HQBCEJICEhCwsgByAJTw0BIAsgB0ECdGooAQAiCUEYdiILIAZB/wFxSwRAIAUgEkYNDiAEIAVBAWoiCTYCOCAEIAZBCGoiBzoAQCAEIAUxAAAgBq2GICyEIiw3AzAgCSEFIAchBgwBCwsgCUH//wNxIgdBEE8EQCAGQf8BcSEJAkACQAJAAkACQAJAAkACQAJAAkAgB0EQaw4CAQIACwJAIAkgC0EHaiITTwRAIAYhCQwBCwNAIAUgEkYNGCAEIAVBAWoiBzYCOCAEIAZBCGoiCToAQCAEIAUxAAAgBq2GICyEIiw3AzAgByEFIBMgCSIGQf8BcUsNAAsLIAQgCSALa0EHazoAQCAEICwgC62IIixCB4g3AzAgCCAsp0H/AHEiBkELaiIFIA9qIglJDQggD0HBAk8NECAFQcACIA9rIghLDREgBkEBdEEWaiIFDQYMBwsCQCAJIAtBAmoiDU8EQCAGIQkMAQsDQCAFIBJGDRcgBCAFQQFqIgc2AjggBCAGQQhqIgk6AEAgBCAFMQAAIAathiAshCIsNwMwIAchBSANIAkiBkH/AXFLDQALCyAEIAkgC2siBjoAQCAEICwgC62IIiw3AzAgDw0BIARBGjYCiAEgBEHkgMAANgKEAQw0CwJAIAkgC0EDaiITTwRAIAYhCQwBCwNAIAUgEkYNFiAEIAVBAWoiBzYCOCAEIAZBCGoiCToAQCAEIAUxAAAgBq2GICyEIiw3AzAgByEFIBMgCSIGQf8BcUsNAAsLQX0hBiAEIAkgC2tBA2s6AEAgBCAsIAutiCIsQgOINwMwIAggLKdBB3EiCUEDaiIFIA9qIgdJDQMgD0HBAk8NDCAFQcACIA9rIgZLDQ0gCUEBdEEGaiIFDQEMAgsgD0EBayEFIA9BwAJLDQggHCAFQQF0ai8BACEHIAQgBkECazoAQCAEICxCAog3AzAgCCAsp0EDcSIFQQNqIgkgD2pJDQogCUHAAiAPayIGSw0JIAVBAXRBBmohBiAcIA9BAXRqIQUDQCAFIAc7AQAgBUECaiEFIAZBAmsiBg0ACyAEKAIgIQ0gBCgCHCEMIAQoAiQgCWoMEAsgHCAPQQF0akEAIAX8CwALIAcMDgsgBEEaNgKIASAEQeSAwAA2AoQBQR4hBwwxCyAcIA9BAXRqQQAgBfwLAAsgCQwLCyAEQRo2AogBIARB5IDAADYChAEMLAsgBCAGIAtrOgBAIAQgLCALrYg3AzAgD0HAAkkNCCAPQcACQeyT/AAQwyEACyAHIAlBzJD8ABDDIQALIAVBwAJBjJP8ABDDIQALIAkgBkGck/wAELA7AAsgBEEaNgKIASAEQeSAwAA2AoQBDCcLIA9BwAJBrJP8ABCvOwALIAUgBkG8k/wAELA7AAsgD0HAAkHMk/wAEK87AAsgBSAIQdyT/AAQsDsACyAcIA9BAXRqIAk7AQAgD0EBagsiDzYCJCAMIA1qIgggD0sNAAsMAgtBfiEGDCELQQAhBkEaIQcMIAsgBC8BhGtFBEAgBEElNgKIASAEQfWxwgA2AoQBDB4LIApBGGoiBkEBIBxBwAIgDCAeQbQKQQogJhDLAiAKKAIYRQRAIAooAiAhBSAEIAooAhw2ApQBIARBAjoAmAEgBCAFNgIoIAQoAhwiBUHBAkkEQCAGQQIgHCAFQQF0akHAAiAFayAEKAIgICFB0ARBCSAmEMsCIAooAhhFBEAgCigCICEFIAooAhwhBiAEQQM6AKABIAQgBjYCnAEgBCAFIAQoAihqNgIoQREhBSAELQAEQQZHDSNBACEGQREhBwwiCyAEQRY2AogBIARBzoDAADYChAEMHwsgBUHAAkH8kvwAEK87AAsgBEEcNgKIASAEQYCAwAA2AoQBDB0LIARBEzYCJAsgCkEYakEAIBxBwAJBEyAdQbQKQQcgJhDLAiAKKAIYRQRAIAooAhwhBSAKKAIgIQYgBEEBOgCYASAEIAY2AiggBCAFNgKUASAEQQA2AiRBGiEFDB8LIARBGTYCiAEgBEGcgMAANgKEAQwbC0EXIQUgBCgCYCINRQ0dIAQpAzAhLAJAIAQtAEAiByANTwRAIAchCQwBCyAEKAI4IQYgBCgCPCEMA0AgBiAMRgRAQQAhBkEWIQcMHwsgBCAGQQFqIgg2AjggBCAHQQhqIgk6AEAgBCAGMQAAIAethiAshCIsNwMwIAghBiAJIQcgDSAJQf8BcUsNAAsLIAQgCSANazoAQCAEICwgDa2INwMwIAQgBCgCZCANajYCZCAEIAQoAlwgLEJ/IA1BP3GthkJ/hYOnajYCXAwdCyAEIAQpAzBCfyAENQKcAYZCf4WDpxDcISEGAkAgBC0AQCIFIAZBGHYiB0kEQANAIAQoAjgiBiAEKAI8Rg0CIAQgBkEBajYCOCAEIAVBCGo6AEAgBCAEKQMwIAYxAAAgBa2GhCIsNwMwIAQgLEJ/IAQ1ApwBhkJ/hYOnENwhIQYgBC0AQCIFIAZBGHYiB0kNAAsLIAQpAzAhLAJAIAZBEHYiC0H/AXFBD0sEQCAHIQkMAQsgByAEIAZB//8DcSIIICxCfyAHIAtqQT9xrYZCf4UiLYOnIAd2ahDcISIGQRh2IglqQf8BcSAELQBAIgVLBEAgB0EfcSENA0AgBCgCOCIGIAQoAjxGDQMgBCAGQQFqNgI4IAQgBUEIajoAQCAEIAQpAzAgBjEAACAFrYaEIiw3AzAgByAEICwgLYOnIA12IAhqENwhIgZBGHYiCWpB/wFxIAQtAEAiBUsNAAsLIAQgBCgCZCAHajYCZCAFIAdrIQUgBkEQdiELIAQpAzAgB62IISwLIAQgBSAJazoAQCAEICwgCa2INwMwIAtBwABxRQRAIAQgC0EPcTYCYCAEIAZB//8DcTYCXEEWIQUMHgsgBEEWNgKIASAEQe+zwgA2AoQBDBoLQQAhBkEVIQcMGwtBCyEFIAQtAAMiCUUNGyAEMQBAIixCH1gEQCAEKAI4IQYgBCgCPCEHIAQpAzAhLQNAIAYgB0YEQEEAIQZBECEHDB0LIAQgBkEBaiIINgI4IAQgLEIIfCIuPABAIAQgBjEAACAshiAthCItNwMwICxCGFQgLiEsIAghBg0ACwsgBCAEKAJQIgYgBCgCVGo2AlQgBCgCeCEHAn8gCUEEcUUEQCAEKAJ8IQlBAQwBCwJAIAcEQCAEIAQoAoABIAQoAkggBhDdByIJNgKAAQwBCyAEKAJ8IAQoAkggBhDoByEJCyAEIAk2AnwgBCgCUCEGIAQoAnghByAELQADQQRxRQshCCAEIAQoAkwgBms2AnQCQCAIRQRAIAQoAjAiBiAGQRh0IAZBgP4DcUEIdHIgBkEIdkGA/gNxIAZBGHZyciAHGyAJRw0BCyAEQQA6AEAgBEIANwMwDBwLIARBFTYCiAEgBEHIssIANgKEAQwYCyAELQBAIgWtIS0gBC0AASIIQQFxBEAgBCAFQfgBcToAQCAEIAQpAzAgLUIHg4g3AzBBECEFDBsLIAQpAzAhLCAFQf8BcUECTQRAIAQoAjgiBiAEKAI8RgRAQQAhBkENIQcMGwsgBCAGQQFqNgI4IAYxAAAgLYYgLIQhLCAFQQhyIQULIAQgBUEBazoAQCAEICxCAYgiLTcDMCAEICynQQFxIAhyOgABAkACQAJAAkAgLadBA3FBAWsOAwECAwALIAQgBUEDazoAQCAEICxCA4g3AzBBDiEFDB0LQQAhBiAEQQA6AKABIARBBTYCnAEgBEEAOgCYASAEQQk2ApQBIAQgBUEDazoAQCAEICxCA4g3AzBBESEFQREhByAELQAEQQZHDRwMGwsgBCAFQQNrOgBAIAQgLEIDiDcDMEEYIQUMGwsgBEETNgKIASAEQcCzwgA2AoQBQX0hBiAEIAVBA2s6AEAgBCAsQgOINwMwQR4hBwwZCwJAIAQoAngiC0GABHFFDQAgBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCCAEKQMwIS0DQCAFIAhGBEBBACEGQQghBwwcCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLAkAgBC0AA0EEcQRAIAQvAXwgBCgCMEcNAQsgBEEAOgBAIARCADcDMAwBCyAEQRQ2AogBIARB+7LCADYChAEMFwsgBCgCjAEiBQRAIAUgC0EJdkEBcTYCLCAEKAKMAUEBNgIwIAQoAnghCwtBDCEFIAQtAANBBHFFIAtFcg0ZIARCADcCfAwZCwJAAkAgBCgCeCISQYAgcQRAQQchByAEKAJwRQ0TIAQoAjwiCCAEKAI4IgZHDQFBACELDAILQQghBSAEKAKMASIGRQ0aIAZBADYCJAwaCyAIIAZrIQtBACEFA0AgBSAGai0AAARAIAYgBUEBaiIFaiAIRw0BDAILCyAFQQFqIQsLAkAgBCgCjAEiBUUNACAFKAIkIglFDQAgBSgCKCIIIAQoAlgiBU8EQCAIIAVrIgggCyAIIAtJGyIIBEAgBSAJaiAGIAj8CgAACyAEIAQoAlggCGo2AlggBCgCeCESDAELQaSS/ABBEkG4kvwAEMskAAsCQCASQYAEcUUNACAELQADQQRxRQ0AIAQgBCgCfCAGIAsQ3Qc2AnwLAkACQCALBEAgBiALakEBayIFDQELIAQgBCgCPCIGIAQoAjggC2oiBSAFIAZLGyIJNgI4DAELIAUtAAAgBCAEKAI8IgYgBCgCOCALaiIFIAUgBksbIgk2AjhBCCEFRQ0ZC0EIIQUgBiAJRw0YDBALAkACQCAEKAJ4IhJBgBBxBEBBBiEHIAQoAnANAQwSCyAEKAKMASIFRQ0BIAVBADYCHAwBCwJAIAQoAjwiCCAEKAI4IgZGBEBBACELDAELIAggBmshC0EAIQUDQCAFIAZqLQAABEAgBiAFQQFqIgVqIAhHDQEMAgsLIAVBAWohCwsCQCAEKAKMASIFRQ0AIAUoAhwiCUUNACAFKAIgIgggBCgCWCIFTwRAIAggBWsiCCALIAggC0kbIggEQCAFIAlqIAYgCPwKAAALIAQgBCgCWCAIajYCWCAEKAJ4IRIMAQtBgJL8AEESQZSS/AAQyyQACwJAIBJBgARxRQ0AIAQtAANBBHFFDQAgBCAEKAJ8IAYgCxDdBzYCfAsCQAJAIAsEQCAGIAtqQQFrIgUNAQsgBCAEKAI8IgUgBCgCOCALaiIGIAUgBkkbIgY2AjgMAQsgBS0AACAEIAQoAjwiBSAEKAI4IAtqIgYgBSAGSRsiBjYCOEUNAQsgBSAGRg0QCyAEQQA2AlhBByEFDBcLAkAgBCgCeCIHQYAIcUUNACAEKAI8IAQoAjgiDWsiBiAEKAJYIgUgBSAGSxsiBgRAAkAgBCgCjAEiCEUNACAIKAIQIgxFDQAgBiAIKAIYIgkgCCgCFCAFayIFayIIQQAgCCAJTRsiCCAGIAhJGyIIBEAgDCAJIAUgBSAJSxtqIA0gCPwKAAALIAQoAnghBwsCQCAHQYAEcUUNACAELQADQQRxRQ0AIAQoAjwgBCgCOCIFayIIIAZPBEAgBCAEKAJ8IAUgBhDdBzYCfAwBCyAGIAhB8JH8ABCwOwALIAQgBCgCcCAGazYCcCAEIAQoAlggBmsiBTYCWCAEIAQoAjwiCCAEKAI4IAZqIgYgBiAISxs2AjgLIAVFDQBBACEGQQUhBwwWCyAEQQA2AlhBBiEFDBYLIAQoAngiCEGACHEEQCAEKQMwIS0gBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCQNAIAUgCUYEQEEAIQZBBCEHDBgLIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCCFQgLiEsIAYhBQ0ACwsgBCAtpyIFNgJYAkAgBCgCjAEiBgR/IAYgBTYCFCAEKAJ4BSAIC0GABHFFDQAgBC0AA0EEcUUNACAKIAQpAzA9ARggBCAEKAJ8IApBGGpBAhDdBzYCfAsgBEEAOgBAIARCADcDMEEFIQUMFgtBBSEFIAQoAowBIgZFDRUgBkEANgIQDBULQQ0hBSAELQADIghFDRQgBCkDMCEtIAQxAEAiLEIPWARAIAQoAjghBSAEKAI8IQkDQCAFIAlGBEBBACEHDA8LIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCCFQgLiEsIAYhBQ0ACwsCQCAIQQJxQQAgLUKflgJRG0UEQCAEKAKMASIFBH8gBUF/NgIwIAQtAAMFIAgLQQFxBEAgBCkDMCIsQgiGQoD+A4MgLEIIiHxCH4JQDQILIARBFzYCiAEgBEGassIANgKEAQwTCyAELQACRQRAIARBDzoAAgsgCkGflgI7ABggBEEAIApBGGpBAhDdBzYCfCAEQQA6AEAgBEIANwMwQQEhBQwVCyAsQg+DQghRBEAgBCAsQgSIIi03AzAgBCAELQBAQQRrOgBAIC2nQQ9xIgZBCGohBSAELQACIggEfyAIBSAEIAU6AAIgBQsgBUkgBkEHS3JFBEAgBEKAgICAEDcDeCAEQQA6AEAgBEIANwMwIARBASAFdDYCkAFBDEEbICxCgMAAg1AbIQUMFgsgBEEUNgKIASAEQY+zwgA2AoQBDBILIARBGzYCiAEgBEGFtMIANgKEAQwRCyAEQR02AogBIARBo7PCADYChAEMEAtB/JP8AEETQZCU/AAQnykAC0ECIQYgBC0AAUECcUUEQEEcIQcMEQsgBEEBNgJ8QQwhBQwRCyAEKQMwIS0gBDEAQCIsQh9YBEAgBCgCOCEFIAQoAjwhCANAIAUgCEYEQEEAIQZBGyEHDBILIAQgBUEBaiIGNgI4IAQgLEIIfCIuPABAIAQgBTEAACAshiAthCItNwMwICxCGFQgLiEsIAYhBQ0ACwsgBEEAOgBAIARCADcDMCAEIC2nIgVBGHQgBUGA/gNxQQh0ciAFQQh2QYD+A3EgBUEYdnJyNgJ8QRwhBQwQCyAEKQMwIS0gBCAELQBAIgVBDU0EfyAFrSEsIAQoAjghBSAEKAI8IQgDQCAFIAhGBEBBACEGQRghBwwRCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQgZUIC4hLCAGIQUNAAsgLKcFIAULQQ5rOgBAIAQgLUIOiDcDMCAEIC2nIgVBH3EiBkGBAmo2AhwgBCAFQQV2QR9xIghBAWo2AiAgBCAFQQp2QQ9xQQRqNgIYIAZBHUsgCEEdS3JFBEAgBEEANgIkQRkhBQwQCyAEQSQ2AogBIARBmrHCADYChAEMDAsDQCAEKAJMIgYgBCgCUCIIRgRAQQAhBkEXIQcMDwsgBiAIayEGAkAgCCAEKAJcIglPBEAgDiAJIAYgBCgCWCIIIAYgCEkbIgYQhw0MAQsgCSAIayIIIAQoAhBNBEAgBCgCDCIHQUBqIglBQU8NFiAOICogCUEAIAcgCU8bIAggBCgCFCIJayIHayAJIAhrIAggCUsiCRsiDSANIAYgBCgCWCIMIAcgCCAJGyIIIAggDEsbIgggBiAISRsiBmoQ1BIMAQsgBC0AAUEEcQRAQR4hByAEQR42AogBIARB3bLCADYChAFBfSEGDBALIApBADYCKCAKQQE2AhwgCkHYkfwANgIYIApCBDcCICAKQRhqQciS/AAQ7ywACyAEIAQoAlgiCCAGazYCWCAGIAhHDQALDA4LAkAgBCgCYCIJRQRAIAQoAlghBQwBCyAEKQMwISwCQCAELQBAIgYgCU8EQCAGIQcMAQsgBCgCOCEFIAQoAjwhDQNAIAUgDUYEQEEAIQZBFCEHDBALIAQgBUEBaiIINgI4IAQgBkEIaiIHOgBAIAQgBTEAACAGrYYgLIQiLDcDMCAIIQUgCSAHIgZB/wFxSw0ACwsgBCAHIAlrOgBAIAQgLCAJrYg3AzAgBCAEKAJkIAlqNgJkIAQgBCgCWCAsQn8gCUE/ca2GQn+Fg6dqIgU2AlgLIAQgBTYCaEEVIQUMDQsgBCgCUCAEKAJMRgRAQQAhBkETIQcMDAsgBCgCWCEIAkAgDigCCCIGIA4oAgQiCUkEQCAOIAZBAWo2AgggDigCACAGaiAIOgAADAELIAYgCUG08fwAEMMhAAsMDAsgBEESOgAAAkAgBCgCPCIJIAQoAjgiCGtBD0kNACAEKAJMIAQoAlBrQYMCTQ0AIAQQrgIgBC0AACIFQRJHDQwgBCgCPCEJIAQoAjghCAsgCkEIaiAOQQhqKAIANgIAIARBADYCUCAOKQIAISwgBEIBNwNIIAogLDcDACAKIBAoAAA2AhAgCiAQQQNqKAAANgATQcz/+wAhD0GABCEgAkACQAJAAkAgBC0AmAFBAWsOAwABAgMLQbQKISAgHSEPDAILQbQKISAgHiEPDAELQdAEISAgISEPC0HMj/wAIRJBICELAkACQAJAAkAgBC0AoAFBAWsOAwABAgMLQbQKIQsgHSESDAILQbQKIQsgHiESDAELQdAEIQsgISESCyAELQBAIQ0gBCkDMCEsAkACQANAQRIhBwNAAkACQAJAIAQCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgB0H/AXFBE2sOBQUBCQIMAAsgCSAIa0EPTwRAIAooAgQgCigCCGtBgwJLDQMLIARBADYCZCAIIQYgDSEFICAgLEJ/IAQ1ApQBhkJ/hSItg6ciB0sNAwwaCyAEKAJgIgdFBEAgBCgCWCEFDAcLIAghBSAHIA0iBkH/AXFLDQQgBSEMDAULQRchByAEKAJgIgxFDRUgCCEFIAwgDSIGQf8BcUsNByAFIRMMCAsgBEESOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBBCuAiAELQAAIQUMIwsDQCAPIAdBAnRqIgwtAAMiByAFQf8BcU0NEyAGIAlHBEAgBa0hLiAGMQAAIS8gBkEBaiEGIAVBCGohBSAgIC8gLoYgLIQiLCAtg6ciB00NGAwBCwtBEiEHIARBEjoAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADBoLIAooAggiBSAKKAIEIgZHBEAgBSAGTw0IIAooAgAgBWogBCgCWDoAACAKIAVBAWo2AggMFAtBEyEHIARBEzoAACAEIA06AEAgBCAJNgI8IAQgCDYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIADBkLA0AgBSAJRg0IIAUxAAAgBq2GICyEISwgBUEBaiIMIQUgByAGQQhqIgZB/wFxSw0ACwsgBCAEKAJkIAdqNgJkIAQgBCgCWCAsQn8gB0E/ca2GQn+Fg6dqIgU2AlggBiAHayENICwgB62IISwgDCEICyAEIAU2AmhBFSEHDA8LIAghBiANIQUgCyAsQn8gBDUCnAGGQn+FIi2DpyIHTQ0MA0AgEiAHQQJ0aiIMLQADIgcgBUH/AXFNDQogBiAJRwRAIAWtIS4gBjEAACEvIAZBAWohBiAFQQhqIQUgCyAvIC6GICyEIiwgLYOnIgdNDQ4MAQsLQRUhByAEQRU6AAAgBCAJNgI8IAQgCTYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAIAQgDSAJQQN0aiAIQQN0azoAQAwVCwNAIAUgCUYNBSAFMQAAIAathiAshCEsIAVBAWoiEyEFIAwgBkEIaiIGQf8BcUsNAAsLIAQgBCgCZCAMajYCZCAEIAQoAlwgLEJ/IAxBP3GthkJ/hYOnajYCXCAGIAxrIQ0gLCAMrYghLCATIQgMDAsgCigCBCIFIAooAggiBkYNAyAFIAZrIQUgBiAEKAJcIgdPBEAgCiAHIAUgBCgCWCIGIAUgBkkbIgUQhw0MBgsgByAGayIGIAQoAhBNBEAgBCgCDCIMQUBqIgdBQU8NICAKICogB0EAIAcgDE0bIAYgBCgCFCIHayIMayAHIAZrIAYgB0siBxsiEyATIAUgBCgCWCIfIAwgBiAHGyIGIAYgH0sbIgYgBSAGSRsiBWoQ1BIMBgsgBC0AAUEEcUUNBCAOIAopAwA3AgAgBCANOgBAIAQgCTYCPCAEIAg2AjggBCAsNwMwIBAgCigCEDYAACAEQR42AogBIARB3bLCADYChAEgEEEDaiAKKAATNgAAIA5BCGogCkEIaigCADYCAEEeDAcLIAUgBkG08fwAEMMhAAtBFCEHIARBFDoAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADBALQRYhByAEQRY6AAAgBCAJNgI8IAQgCTYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAIAQgDSAJQQN0aiAIQQN0azoAQAwPC0EXIQcgBEEXOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAMDgsgCkEANgIoIApBATYCHCAKQdiR/AA2AhggCkIENwIgIApBGGpB4JH8ABDvLAALIAQgBCgCWCIGIAVrNgJYQRJBFyAFIAZGGyEHDAULIAwvAQAhEwJAIAwtAAIiFUEPSwRAIAchDAwBCyAsQn8gByAVakE/ca2GQn+FIi2DpyAHdiATaiIMIAtPDQIgB0EfcSEVAkADQCASIAxBAnRqIh8tAAMiDCAHakH/AXEgBUH/AXFNDQEgBiAJRwRAIAWtIS4gBjEAACAGQQFqIQYgBUEIaiEFIC6GICyEIiwgLYOnIBV2IBNqIgwgC08NBQwBCwtBFSEHIARBFToAACAEIAk2AjwgBCAJNgI4IAQgLDcDMCAQIAooAhA2AAAgEEEDaiAKKAATNgAAIA4gCikDADcCACAOQQhqIApBCGooAgA2AgAgBCANIAlBA3RqIAhBA3RrOgBADA0LIB8tAAIhFSAfLwEAIRMgBCAEKAJkIAdqNgJkIAUgB2shBSAsIAetiCEsCyAFIAxrIQ0gLCAMrYghLCAVQcAAcUUEQCAEIBVBD3E2AmAgBCATQf//A3E2AlxBFiEHIAYhCAwFCyAOIAopAwA3AgAgBCANOgBAIAQgCTYCPCAEIAY2AjggBCAsNwMwIBAgCigCEDYAACAEQRY2AogBIARB77PCADYChAEgEEEDaiAKKAATNgAAIA5BCGogCkEIaigCADYCAEEeCyIHOgAAQX0hBgwRCyAMIAtBnJH8ABDDIQALIAcgC0GMkfwAEMMhAAsgDC8BACETAkAgDC0AAiIVRQRAQQAhDCAGIQhBACEVDAELQQAhDCAVQQ9LBEAgBiEIDAELAkAgICAsQn8gByAVakE/ca2GQn+FIi2Dp0H//wNxIAdBD3EiFXYgE2pB//8DcSIMTQ0AAkADQCAPIAxBAnRqIgwtAAMiHyAHakH/AXEgBUH/AXFNDQEgBiAJRwRAIAWtIS4gBjEAACEvIAZBAWohBiAFQQhqIQUgICAvIC6GICyEIiwgLYOnQf//A3EgFXYgE2pB//8DcSIMTQ0DDAELC0ESIQcgBEESOgAAIAQgCTYCPCAEIAk2AjggBCAsNwMwIBAgCigCEDYAACAQQQNqIAooABM2AAAgDiAKKQMANwIAIA5BCGogCkEIaigCADYCACAEIA0gCUEDdGogCEEDdGs6AEAMCgsgBSAHayEFICwgB62IISwgDC0AAiEVIAwvAQAhEyAHIQwgBiEIIB8hBwwBCyAMICBB/JD8ABDDIQALIAQgE0H//wNxNgJYIAQgDCAHQf8BcWo2AmQgBSAHayENICwgB62IISxBEyEHIBVFDQAgFUEgcQ0CIBVBwABxRQRAIAQgFUEPcTYCYEEUIQcMAQsLC0EeIQcgBEEeOgAAIAQgDToAQCAEIAk2AjwgBCAINgI4IAQgLDcDMCAQIAooAhA2AAAgBEEcNgKIASAEQdOzwgA2AoQBIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIAQX0hBgwMC0EMIQUgBEEMOgAAIARBfzYCZCAEIA06AEAgBCAJNgI8IAQgCDYCOCAEICw3AzAgECAKKAIQNgAAIBBBA2ogCigAEzYAACAOIAopAwA3AgAgDkEIaiAKQQhqKAIANgIADAwLIAcgIEHskPwAEMMhAAsgBCAELQBAIgVB+AFxOgBAIAQgBCkDMCAFQQdxrYgiLTcDMAJAAkAgBUEfTQRAIAWtQhiDISwgBCgCOCEFIAQoAjwhCANAIAUgCEYEQEEAIQYMAwsgBCAFQQFqIgY2AjggBTEAACEvIAQgLEIIfCIuPABAIAQgLyAshiAthCItNwMwICxCGFQgLiEsIAYhBQ0ACwsgLUIQiCAthUL//wODQv//A1INAUEAIQYgBEEAOgBAIARCADcDMCAEIC2nQf//A3E2AlhBDyEFIAQtAARBBkcNDAtBDiEHDAoLIARBHTYCiAEgBEG+scIANgKEAQwHC0ENIQUgBC0ABEEFa0H/AXFBAk8NCUEAIQZBDCEHDAgLQQEhBkELIQcgBC0AAyIJRQ0HIAQoAnhFDQcgBDEAQCIsQh9YBEAgBCgCOCEFIAQoAjwhDSAEKQMwIS0DQCAFIA1GDQIgBCAFQQFqIgg2AjggBCAsQgh8Ii48AEAgBCAFMQAAICyGIC2EIi03AzAgLEIYVCAuISwgCCEFDQALCyAJQQRxBEAgBCkDMCAENQJUUg0CCyAEQQA6AEAgBEIANwMwDAcLQQAhBgwGCyAEQRc2AogBIARBsbLCADYChAEMAwsgBDEAQCIsQg9YBEAgBCgCOCEFIAQoAjwhCCAEKQMwIS0DQCAFIAhGBEBBACEGQQMhBwwHCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLIAQoAowBIgUEQCAFIAQtADA2AgggBCgCjAEgBCkDMEIIiD4CDAsCQCAELQB5QQJxRQ0AIAQtAANBBHFFDQAgCiAEKQMwPQEYIAQgBCgCfCAKQRhqQQIQ3Qc2AnwLIARBADoAQCAEQgA3AzBBBCEFDAULIAQxAEAiLEIfWARAIAQoAjghBSAEKAI8IQggBCkDMCEtA0AgBSAIRgRAQQAhBkECIQcMBgsgBCAFQQFqIgY2AjggBCAsQgh8Ii48AEAgBCAFMQAAICyGIC2EIi03AzAgLEIYVCAuISwgBiEFDQALCyAEKAKMASIFBEAgBSAEKQMwPgIECwJAIAQtAHlBAnFFDQAgBC0AA0EEcUUNACAKIAQpAzA+AhggBCAEKAJ8IApBGGpBBBDdBzYCfAsgBEEAOgBAIARCADcDMEEDIQUMBAsgBCkDMCEtIAQxAEAiLEIPWARAIAQoAjghBSAEKAI8IQgDQCAFIAhGBEBBACEGQQEhBwwFCyAEIAVBAWoiBjYCOCAEICxCCHwiLjwAQCAEIAUxAAAgLIYgLYQiLTcDMCAsQghUIC4hLCAGIQUNAAsLIAQgLaciBTYCeAJAAkAgBUH/AXFBCEYEQCAFQYDAA3ENASAEKAKMASIGBH8gBiAFQQh2QQFxNgIAIAQoAngFIAULQYAEcUUNAiAELQADQQRxRQ0CIAQoAnwhBSAKIAQpAzA9ABggBCAFIApBGGpBAhDdBzYCfAwCCyAEQRs2AogBIARBhbTCADYChAEMAgsgBEEZNgKIASAEQbWAwAA2AoQBDAELIARBADoAQCAEQgA3AzBBAiEFDAMLQX0hBkEeIQcMAQtBDCEFIAQoAlgiB0UNASAEKAI4IRIgBCgCPCELIAQoAlAhCQNAIAsgEmsiBiAEKAJMIgggCWsiDSAHIAcgDUsbIgcgBiAHSRsiBkUEQEEAIQZBDyEHDAILIAggCUkNAyAGBEAgBCgCSCAJaiASIAb8CgAACyAEIAQoAlAgBmoiCTYCUCAEIAQoAlggBmsiBzYCWCAEIAQoAjwiCyAEKAI4IAZqIgYgBiALSxsiEjYCOCAHDQALDAELCyAEIAc6AAAgESgCACEEIBEgESgCHCIFKAI4IiE2AgAgESAFKAI8ICFrNgIEIBEgBSgCTCIIIAUoAlAiB2s2AhAgESAHIAUoAkhqNgIMIBEgESgCCCAhIARrajYCCCAFIAUoAnQgByAIa2oiDSAFKAJUaiIINgJUIBEgCDYCFCARIAUoAnw2AjAgBSgCDCIIQUBqQUFPDQQCQCAIQcAATQRAIA1FDQQCQAJAAkAgBS0AACIIQQlrDggHBwECAgICAQALIAhBHkcNAQwGCyAFLQAEQQRGDQULAkBBASAFLQACdEFAayIJQQBIDQAgBS0AAyEIIBFBIGogCRCBGiIHRQ0AIAVCADcDECAFIAk2AgwgBSAHNgIIIAUoAlAhBwwCCyAFQQo6AABBfCEGDAQLIAUtAAMhCAsgByANSQ0BIAUoAkghDyAFKAJ4IRMgCEEEcUECdiEfIAVB/ABqIRIgBUGAAWohHQJAAkACQAJAAkACQAJAAkACQAJAIAVBCGoiCSgCBCIMQUBqIghBQUkEQCAIQQAgCCAMTRsiByANSwRAIA0gByAJKAIMIgtrIg4gDSAOSRshCCAJKAIAIR4CQCAfRQRAIAsgDEsNBCAIIAwgC2siEEsNBSAIRQ0BIAsgHmogDyAI/AoAAAwBCyALIAxLDQUgCCAMIAtrIhBLDQYgCyAeaiEQIBNFBEAgEiASKAIAIBAgCCAPIAgQzis2AgAMAQsgHSAQIAggDyAIEJ0qCyANIA5LBEAgDSAIayILIAxLDQcgCCAPaiEIIB9FBEAgC0UNDCAeIAggC/wKAAAMDAsgE0UNCiAdIB4gCyAIIAsQnSoMCwsgCSAIIAtqIgxBACAHIAxHGzYCDCAHIAkoAggiDEsEQCAJIAggDGo2AggLDAsLIA8gDSAHayILaiEIIB9FBEAgB0UNCCAJKAIAIAggB/wKAAAMCAsgE0UNBiAdIB0oAgAgDyALEN0HNgIAIB0gCSgCACAHIAggBxCdKgwHC0H47/wAQcoAQcTw/AAQnykACyALIAxB5PD8ABCvOwALIAggEEH08PwAELA7AAsgCyAMQYTx/AAQrzsACyAIIBBBlPH8ABCwOwALIAsgDEGk8fwAELA7AAsgEiASKAIAIA8gCxDoByAJKAIAIAwgCCAHEM4rNgIACyAJIAc2AgggCUEANgIMDAILIBIgEigCACAeIAsgCCALEM4rNgIACyAJIAc2AgggCSALNgIMCwwCCyAJIAhBuP/7ABCvOwALIA0gB0HMlfwAELA7AAsCQCAFKAKEASIIRQ0AIAUoAogBIQkgCkEANgIYAkAgCUUNACAKQRhqQQEgCCAJakEBa0EBEMEuRQ0AIBEgCDYCGAwBC0HclfwAQSVBhJb8ABCfKQALIBEgBS0AAEEMa0H/AXEiCEEFTQR/IAhBAnRBlJb8AGooAgAFQQALIAUtAEAgBS0AAUEGdEHAAHFycjYCLCAGQXsgBhsiBSAGIAUgDRsgBiAEICFGGyApQf8BcUEERhshBQsgCkEwaiQAIAUMAQtB+O/8AEHKAEHE8PwAEJ8pAAshBgsgESgCDCEFIBFCADcCDCARKAIAIQggEUIANwIAIBogGikDACAIICdrrXw3AwAgGiAaKQMIIAUgAmutfDcDCAJAAkACQAJAAkACQAJAIAZBBWoOCAMBAQEAAgQFAAsgFiAGNgIMIBZBATYCFCAWQei9+wA2AhAgFkIBNwIcIBZBnAM2AiwgFiAWQShqNgIYIBYgFkEMajYCKCAWQRBqQfC9+wAQ7ywACyAWIBoQpyQgGyAWKQMANwIEIBtBADYCAAwECyAbQQI2AgAgG0EAOgAEDAMLIBtBAjYCACAbQQE6AAQMAgsgG0ECNgIAIBtBAjoABAwBCyAbQQE2AgAgGyARKAIwNgIECyAWQTBqJAAgGS0ACCEFIBkoAgQgGikDCCEsIAEgASgCFCIIIAEoAhAgGikDACAxfadqIgkgCCAJSRs2AhBBAkcEQCAjQRRByPTNAEEWEM0aDAQLICwgMH2nIgYgKEUgA0VyciAFQQJGcg0CIBlBBGogARDbFiAZKAIERQ0ACwsgIyAZKQIINwIADAELICNBBDoAACAjIAY2AgQLIBlBEGokAAJAAkACQAJ/ICItAAhBBEYEQCAiKAIMDAELICIpAwgiLEL/AYNCBFINASAsQiCIpwsiBSADSw0BIAFBMGogAiAFEIMxICVBBDoAACAlIAU2AgQMAgsgJSAsNwIADAELIAUgA0G8mc8AELA7AAsgIkEQaiQAIBQtADBBBEYEQCAUKAI0IQUMBwsgFCkDMCIsQv8Bg0IEUg0BICxCIIinIQUMBgsgAEEEOgAAIABBADYCBAwHCyAAICw3AgAMBgsCQAJAIAEoAngiBUEITwRAIAEoAoABIQUgASgCfCAkEIU7RgRAIAUgASgCQEYNAgsgFEEwaiICIBdBLPwKAAAgAUEAOgB0IAFBADYCcCABQYCAgIB4NgJkIAFBgICAgHg2AlggAUGAgICAeDYCTCAYELMbIAFBhICAgHg2AkggFyACQSz8CgAAIAAQhzsMCAsgFEEwaiABIAUgK2pBCCAFaxCLGSAULQAwQQRGBEAgFCgCNCEFDAULIBQpAzAiLEL/AYNCBFINASAsQiCIpyEFDAQLIAEtAIQBRQRAIBRBMGoiBSAXQSz8CgAAIAFBADoAdCABQQA2AnAgAUGAgICAeDYCZCABQYCAgIB4NgJYIAFBgICAgHg2AkwgGBCzGyABQYSAgIB4NgJIIBcgBUEs/AoAAAwGCyAUQTBqIAEQ2xYCQCAUKAIwRQRAIBQoAjgNAQwECyAUKQI0IixC/wGDQgRSBEAgACAsNwIADAgLICxCgAKDQgBSDQMLICRBADYCECAkEIc3IwBBIGsiBSQAIAVBCGoQwB8gAUEoaiIGKAIAEJIrIAYQhjsgBiAFQRhqKQMANwMAIAFBIGogBUEQaikDADcDACABIAUpAwg3AxggBUEgaiQAIBRBMGoiBRDNKyAYELMbIBggBUE8/AoAAAwFCyAAICw3AgAMBQsgAEEEOgAAIABBADYCBAwECyAUQTBqIgUgF0Es/AoAACABQQA6AHQgAUEANgJwIAFBgICAgHg2AmQgAUGAgICAeDYCWCABQYCAgIB4NgJMIBgQsxsgAUGEgICAeDYCSCAXIAVBLPwKAAAMAgsgASABKAJ4IAVqNgJ4DAELIAVFBEAgFEEwaiIFIBdBLPwKAAAgAUEAOgB0IAFBADYCcCABQYCAgIB4NgJkIAFBgICAgHg2AlggAUGAgICAeDYCTCAYELMbIAFBgoCAgHg2AkggFyAFQSz8CgAAIAFCADcCfCABQQA2AngMAQsLIABBBDoAACAAIAU2AgQLIBRB8ABqJAALjggCBn8DfiMAQaABayICJAAgAUEMahDZPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACQAJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAiABNgJAIAIgBjYCOCACIAQ2AjQgAiACQdAAaiIBNgI8IAIoAghFDQMgAigCHCACKAIYRg0EIAEgAkEIahDINCACQfAAaiEBA0ACQCACKQN4IglQRQRAIAIpA4ABIQgMAQsDQAJ+AkAgAikDYCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNgIAinQQFxRQ0AIAIgAikDaDcDkAEMAQsgAigCcEUNASACQYgBaiABELYqIAIpA4gBIQgLIAhCAFINAgsgAkIDNwNgCyACKQNQIghCAlENCSACQgA3A1AgAikDWAwBCyACKQOQAQshCSAIp0EBcUUNByACIAIpA4ABQkB9Igg3A4ABIAIgCTcDeCAJUA0ACwsgAiAJQgEgCXoiCoaFNwN4IAJBiAFqIAJBNGogCqcgCKdqEPYNIAIoAogBIgNBk4CAgHhGDQALIAAgAikCjAE3AgggAEEQaiACQZQBaikCADcCAAwGC0HAACADEKM9AAtB3Iv/AEEpIAJB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQEDQCACQdAAaiACQTRqIAEQ9g0gAigCUCIDQZOAgIB4Rw0CIAYgAUEBaiIBRw0ACwsgAkHQAGoiAxCXKSACQShqIgEoAgAhBCACKAIsIQUgASACQdgAaiIGKQIANwMAIAIpAyAhCCACIAIpAlA3AyAgAkEANgIwIAIgCDcCXCACQQA2AlggAiAFNgJUIAIgBDYCUCACIAMQ1zsgAigCACEEQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJQNwIIIAFBEGogBikCADcCACABQRhqIAJB4ABqIgcoAgA2AgAgAiAFNgKQASACIAQ2AowBIAIgATYCiAEgAkHEAGoiASACQYgBahDkGSAHIAJBGGopAgA3AwAgBiACQRBqKQIANwMAIAIgAikCCDcDUCAAIAEgAxDZHSACQSBqEM8vDAILIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIACyAAQSk6AAAgACADNgIEIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQaABaiQADwtBBEEcEKM9AAuOCAIGfwN+IwBBoAFrIgIkACABQQxqENk8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAAkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACIAE2AkAgAiAGNgI4IAIgBDYCNCACIAJB0ABqIgE2AjwgAigCCEUNAyACKAIcIAIoAhhGDQQgASACQQhqEMg0IAJB8ABqIQEDQAJAIAIpA3giCVBFBEAgAikDgAEhCAwBCwNAAn4CQCACKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A2AgCKdBAXFFDQAgAiACKQNoNwOQAQwBCyACKAJwRQ0BIAJBiAFqIAEQtiogAikDiAEhCAsgCEIAUg0CCyACQgM3A2ALIAIpA1AiCEICUQ0JIAJCADcDUCACKQNYDAELIAIpA5ABCyEJIAinQQFxRQ0HIAIgAikDgAFCQH0iCDcDgAEgAiAJNwN4IAlQDQALCyACIAlCASAJeiIKhoU3A3ggAkGIAWogAkE0aiAKpyAIp2oQwA0gAigCiAEiA0GTgICAeEYNAAsgACACKQKMATcCCCAAQRBqIAJBlAFqKQIANwIADAYLQcAAIAMQoz0AC0Hci/8AQSkgAkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAQNAIAJB0ABqIAJBNGogARDADSACKAJQIgNBk4CAgHhHDQIgBiABQQFqIgFHDQALCyACQdAAaiIDEJcpIAJBKGoiASgCACEEIAIoAiwhBSABIAJB2ABqIgYpAgA3AwAgAikDICEIIAIgAikCUDcDICACQQA2AjAgAiAINwJcIAJBADYCWCACIAU2AlQgAiAENgJQIAIgAxDXOyACKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogAkHgAGoiBygCADYCACACIAU2ApABIAIgBDYCjAEgAiABNgKIASACQcQAaiIBIAJBiAFqEOUZIAcgAkEYaikCADcDACAGIAJBEGopAgA3AwAgAiACKQIINwNQIAAgASADEMcdIAJBIGoQzy8MAgsgACACKQJUNwIIIABBEGogAkHcAGopAgA3AgALIABBKToAACAAIAM2AgQgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJBoAFqJAAPC0EEQRwQoz0AC44IAgZ/A34jAEGgAWsiAiQAIAFBDGoQ2TwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAAkACQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIgATYCQCACIAY2AjggAiAENgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAQNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogARC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDBDSACKAKIASIDQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgAxCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEBA0AgAkHQAGogAkE0aiABEMENIAIoAlAiA0GTgICAeEcNAiAGIAFBAWoiAUcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQQgAigCLCEFIAEgAkHYAGoiBikCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBTYCVCACIAQ2AlAgAiADENc7IAIoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBTYCkAEgAiAENgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4RkgByACQRhqKQIANwMAIAYgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQ2h0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgAzYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALjggCBn8DfiMAQaABayICJAAgAUEMahDZPCEGIAJBCGogARCSNhDuJSAGQQN0IgUhAwJAAkACQAJAAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCKCACIAM2AiQgAkHAADYCICAFBEAgBEEAIAX8CwALIAIgBjYCMCACIAU2AiwgAiABNgJAIAIgBjYCOCACIAQ2AjQgAiACQdAAaiIBNgI8IAIoAghFDQMgAigCHCACKAIYRg0EIAEgAkEIahDINCACQfAAaiEBA0ACQCACKQN4IglQRQRAIAIpA4ABIQgMAQsDQAJ+AkAgAikDYCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNgIAinQQFxRQ0AIAIgAikDaDcDkAEMAQsgAigCcEUNASACQYgBaiABELYqIAIpA4gBIQgLIAhCAFINAgsgAkIDNwNgCyACKQNQIghCAlENCSACQgA3A1AgAikDWAwBCyACKQOQAQshCSAIp0EBcUUNByACIAIpA4ABQkB9Igg3A4ABIAIgCTcDeCAJUA0ACwsgAiAJQgEgCXoiCoaFNwN4IAJBiAFqIAJBNGogCqcgCKdqEPcNIAIoAogBIgNBk4CAgHhGDQALIAAgAikCjAE3AgggAEEQaiACQZQBaikCADcCAAwGC0HAACADEKM9AAtB3Iv/AEEpIAJB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNAEEAIQEDQCACQdAAaiACQTRqIAEQ9w0gAigCUCIDQZOAgIB4Rw0CIAYgAUEBaiIBRw0ACwsgAkHQAGoiAxCXKSACQShqIgEoAgAhBCACKAIsIQUgASACQdgAaiIGKQIANwMAIAIpAyAhCCACIAIpAlA3AyAgAkEANgIwIAIgCDcCXCACQQA2AlggAiAFNgJUIAIgBDYCUCACIAMQ1zsgAigCACEEQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQJQNwIIIAFBEGogBikCADcCACABQRhqIAJB4ABqIgcoAgA2AgAgAiAFNgKQASACIAQ2AowBIAIgATYCiAEgAkHEAGoiASACQYgBahDkGSAHIAJBGGopAgA3AwAgBiACQRBqKQIANwMAIAIgAikCCDcDUCAAIAEgAxDWHSACQSBqEM8vDAILIAAgAikCVDcCCCAAQRBqIAJB3ABqKQIANwIACyAAQSk6AAAgACADNgIEIAJBIGoQzy8gAigCCCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQaABaiQADwtBBEEcEKM9AAuOCAIGfwN+IwBBoAFrIgIkACABQQxqENk8IQYgAkEIaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAAkACQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIoIAIgAzYCJCACQcAANgIgIAUEQCAEQQAgBfwLAAsgAiAGNgIwIAIgBTYCLCACIAE2AkAgAiAGNgI4IAIgBDYCNCACIAJB0ABqIgE2AjwgAigCCEUNAyACKAIcIAIoAhhGDQQgASACQQhqEMg0IAJB8ABqIQEDQAJAIAIpA3giCVBFBEAgAikDgAEhCAwBCwNAAn4CQCACKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A2AgCKdBAXFFDQAgAiACKQNoNwOQAQwBCyACKAJwRQ0BIAJBiAFqIAEQtiogAikDiAEhCAsgCEIAUg0CCyACQgM3A2ALIAIpA1AiCEICUQ0JIAJCADcDUCACKQNYDAELIAIpA5ABCyEJIAinQQFxRQ0HIAIgAikDgAFCQH0iCDcDgAEgAiAJNwN4IAlQDQALCyACIAlCASAJeiIKhoU3A3ggAkGIAWogAkE0aiAKpyAIp2oQwg0gAigCiAEiA0GTgICAeEYNAAsgACACKQKMATcCCCAAQRBqIAJBlAFqKQIANwIADAYLQcAAIAMQoz0AC0Hci/8AQSkgAkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AQQAhAQNAIAJB0ABqIAJBNGogARDCDSACKAJQIgNBk4CAgHhHDQIgBiABQQFqIgFHDQALCyACQdAAaiIDEJcpIAJBKGoiASgCACEEIAIoAiwhBSABIAJB2ABqIgYpAgA3AwAgAikDICEIIAIgAikCUDcDICACQQA2AjAgAiAINwJcIAJBADYCWCACIAU2AlQgAiAENgJQIAIgAxDXOyACKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAIpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogAkHgAGoiBygCADYCACACIAU2ApABIAIgBDYCjAEgAiABNgKIASACQcQAaiIBIAJBiAFqEOUZIAcgAkEYaikCADcDACAGIAJBEGopAgA3AwAgAiACKQIINwNQIAAgASADEL8dIAJBIGoQzy8MAgsgACACKQJUNwIIIABBEGogAkHcAGopAgA3AgALIABBKToAACAAIAM2AgQgAkEgahDPLyACKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJBoAFqJAAPC0EEQRwQoz0AC44IAgZ/A34jAEGgAWsiAiQAIAFBDGoQ2TwhBiACQQhqIAEQkjYQ7iUgBkEBdCIFIQMCQAJAAkACQAJAAkACQCAFQT5xIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AiggAiADNgIkIAJBwAA2AiAgBQRAIARBACAF/AsACyACIAY2AjAgAiAFNgIsIAIgATYCQCACIAY2AjggAiAENgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAQNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogARC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDDDSACKAKIASIDQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgAxCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQBBACEBA0AgAkHQAGogAkE0aiABEMMNIAIoAlAiA0GTgICAeEcNAiAGIAFBAWoiAUcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQQgAigCLCEFIAEgAkHYAGoiBikCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBTYCVCACIAQ2AlAgAiADENc7IAIoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAYpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBTYCkAEgAiAENgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4RkgByACQRhqKQIANwMAIAYgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQzR0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgAzYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALkwgBB38jAEHQAGsiAiQAIAJBMGoiA0EgQQBBAUEBEKAYIAIoAjQhBAJAAkAgAigCMEEBRwRAIAJBADYCFCACIAIoAjg2AhAgAiAENgIMIAJBGGogASABKAIMIgcQtREgAiACKAIYIgRBDXUiATYCJAJAIAFBkM4ATwRAIAJBATYCRCACQezDhQE2AkAgAkEBNgI0IAJB5MOFATYCMCACQQE2AjwgAkGcAzYCTCACIAJByABqNgI4IAIgAkEkajYCSCACQQxqIAMQ7jxFDQEMBAsgAkEMaiIDIAFB//8DcUHkAG4iBRCLGA0DIAMgASAFQeQAbGsQixgNAwsgAigCFCEBIAJBDGoiA0EBEIQuIAIoAhAgAigCFGpBLToAACACIAFBAWo2AhQgBEEDdiIEQf8HcSIBQd0FTw0BIAMgASABQfS9hQFqLQAAIgVqQQZ2EIsYDQIgAigCFCEBIANBARCELiACKAIQIAIoAhRqQS06AAAgAiABQQFqNgIUIAMgBCAFakEBdkEfcRCLGA0CIAIoAhQhASADQQEQhC4gAigCECACKAIUakHUADoAACACIAFBAWo2AhQgAigCHCEEIAIgAigCICIBQYCU69wDayABIAFB/5Pr3ANLIgUbIgE2AiggAyAEQZAcbhCLGA0CIAIoAhQhBiADQQEQhC4gAigCECACKAIUakE6OgAAIAIgBkEBajYCFCADIARBPG4iBkE8cBCLGA0CIAIoAhQhCCADQQEQhC4gAigCECACKAIUakE6OgAAIAIgCEEBajYCFCADIAQgBkE8bGsgBWoQixgNAgJAIAFFDQAgASABQcCEPW4iBEHAhD1sRgRAIAJBATYCRCACQZDEhQE2AkAgAkEBNgI0IAJBiMSFATYCMCACQQE2AjwgAkE7NgJMIAIgBDYCLCACIAJByABqNgI4IAIgAkEsajYCSCADIAJBMGoQ7jwNBAwBCyABIAFB6AduIgRB6AdsRgRAIAJBATYCRCACQajEhQE2AkAgAkEBNgI0IAJBiMSFATYCMCACQQE2AjwgAkE7NgJMIAIgBDYCLCACIAJByABqNgI4IAIgAkEsajYCSCACQQxqIAJBMGoQ7jwNBAwBCyACQQE2AkQgAkHAxIUBNgJAIAJBATYCNCACQYjEhQE2AjAgAkEBNgI8IAJBOzYCTCACIAJByABqNgI4IAIgAkEoajYCSCACQQxqIAJBMGoQ7jwNAwsgAkGAgoQINgAwIAJBMGogAkEMaiAHEP4HDQIgACACKQIMNwIAIABBCGogAkEUaigCADYCACACQdAAaiQADwsgBCACKAI4Qay9hQEQ/S8ACyABQd0FQdTDhQEQwyEAC0HYxIUBQTQgAkEwakHEvIUBQYzFhQEQ1R4AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQzAsgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDMCyADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQnwogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCfCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ0QkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDRCSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ4gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDiDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxgkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDGCSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQygogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDKCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQigwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCKDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ2gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDaDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ4wwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDjDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQzQogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDNCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEDdCIGIQQCQAJAAkACQAJAAkACQCAGQThxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ7QwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDtDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOQZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMYdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQugkgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARC6CSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQrQogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARCtCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ9gogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARD2CiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUECdCIGIQQCQAJAAkACQAJAAkACQCAGQTxxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ3QogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDdCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOUZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEModIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2jwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxAogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDECiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQyQ0gAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDJDSADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ3DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ5AwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDkDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2zwhBSADQQhqIAEQkjYQ7iUgBUEEdCIGIQQCQAJAAkACQAJAAkACQCAGQTBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQxwogAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDHCiADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEMsdIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC4wIAgV/A34jAEGgAWsiAyQAIAFBDGoQ2DwhBSADQQhqIAEQkjYQ7iUgBUEFdCIGIQQCQAJAAkACQAJAAkACQCAGQSBxIgcEQCAGIAdrQUBrIgQgBkkNAQtBwAAhByAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIHRQ0BCyADIAc2AiggAyAENgIkIANBwAA2AiAgBgRAIAdBACAG/AsACyADIAU2AjAgAyAGNgIsIAMgATYCQCADIAI2AjwgAyAFNgI4IAMgBzYCNCADKAIIRQ0DIAMoAhwgAygCGEYNBCADQdAAaiADQQhqEMg0IANB8ABqIQEDQAJAIAMpA3giCVBFBEAgAykDgAEhCAwBCwNAAn4CQCADKQNgIghCA1IEQAJAAkACQCAIQgJRDQAgAyAIUK1CAYY3A2AgCKdBAXFFDQAgAyADKQNoNwOQAQwBCyADKAJwRQ0BIANBiAFqIAEQtiogAykDiAEhCAsgCEIAUg0CCyADQgM3A2ALIAMpA1AiCEICUQ0JIANCADcDUCADKQNYDAELIAMpA5ABCyEJIAinQQFxRQ0HIAMgAykDgAFCQH0iCDcDgAEgAyAJNwN4IAlQDQALCyADIAlCASAJeiIKhoU3A3ggA0GIAWogA0E0aiAKpyAIp2oQ7gwgAygCiAEiBEGTgICAeEYNAAsgACADKQKMATcCCCAAQRBqIANBlAFqKQIANwIADAYLQcAAIAQQoz0AC0Hci/8AQSkgA0HQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAFRQ0AQQAhAQNAIANB0ABqIANBNGogARDuDCADKAJQIgRBk4CAgHhHDQIgBSABQQFqIgFHDQALCyADQdAAaiICEJcpIANBKGoiASgCACEFIAMoAiwhBCABIANB2ABqIgYpAgA3AwAgAykDICEIIAMgAykCUDcDICADQQA2AjAgAyAINwJcIANBADYCWCADIAQ2AlQgAyAFNgJQIAMgAhDXOyADKAIAIQVBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAlA3AgggAUEQaiAGKQIANwIAIAFBGGogA0HgAGoiBygCADYCACADIAQ2ApABIAMgBTYCjAEgAyABNgKIASADQcQAaiIBIANBiAFqEOIZIAcgA0EYaikCADcDACAGIANBEGopAgA3AwAgAyADKQIINwNQIAAgASACEM4dIANBIGoQzy8MAgsgACADKQJUNwIIIABBEGogA0HcAGopAgA3AgALIABBKToAACAAIAQ2AgQgA0EgahDPLyADKAIIIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBCGoQ+x4LIANBoAFqJAAPC0EEQRwQoz0AC54HAQN/IwBB0ABrIgQkAAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkAgACgCACIFKAIAIgYtAABBDWsOBQECAgMDAAsgBCACNgIsIAIgASgCFCIATw0LIAQgASgCECACai0AADoAKyADKAIIIgBBgICAEHENBiAAQYCAgCBxRQRAIARBK2ogAxDBGCECDAoLIARBK2ogAxC1HCECDAkLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgBPDQogBigCBCIARQ0CIARBFGogAEEIaiAGKAIIEIoYIAQoAhRBk4CAgHhHDQMgBEE4akGGjJgwNgIAIARChoyYsODAgYMGNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5DAQLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgFJDQUMCAsgACgCBCEAIAQgAjYCLCACIAAoAhQiAUkNBQwHCyAEQThqQYaMmDA2AgAgBEKGjJiw4MCBgwY3AzAgBEEwahDJDCADKAIAQeibhAFBBCADKAIEKAIMEQYAIQIMBQsgBEE4akGGjJgwNgIAIARChoyYsODAgYMGNwMwIARBMGoiABDJDCAEQQA2AkAgBEEBNgI0IARB7JuEATYCMCAEQgQ3AjggAyAAENE5CyECIARBFGoQ5RAMAwsgBEEraiADELYcIQIMAgsgBCAAKAIQIAJqMQAANwMAIARBOGpBhoyYMDYCACAEQoaMmLDgwIGDBjcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAENgIUIAMoAgAgAygCBCAAEMsKIQIMAQsgBCAAKAIQIAJqMQAANwMIIARBOGpBhoyYMDYCACAEQoaMmLDgwIGDBjcDMCAEQTBqIgAQyQwgBEECNgI0IARB7JyEATYCMCAEQgI3AjwgBEGvAzYCICAEIAU2AhwgBEHuBjYCGCAEIARBFGo2AjggBCAEQQhqNgIUIAMoAgAgAygCBCAAEMsKIQIMAAsgBEHQAGokACACDwsgBCABNgJMDAELIAQgADYCTAsgBEECNgI0IARBuJeEATYCMCAEQgI3AjwgBEE7NgIgIARBOzYCGCAEIARBFGo2AjggBCAEQcwAajYCHCAEIARBLGo2AhQgBEEwakHIl4QBEO8sAAueBwEDfyMAQdAAayIEJAACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAAoAgAiBSgCACIGLQAAQQ1rDgUBAgIDAwALIAQgAjYCLCACIAEoAhQiAE8NCyAEIAEoAhAgAmotAAA6ACsgAygCCCIAQYCAgBBxDQYgAEGAgIAgcUUEQCAEQStqIAMQxRUhAgwKCyAEQStqIAMQtRwhAgwJCyAAKAIEIQAgBCACNgIsIAIgACgCFCIATw0KIAYoAgQiAEUNAiAEQRRqIABBCGogBigCCBCKGCAEKAIUQZOAgIB4Rw0DIARBOGpBgoSIEDYCACAEQoKEiJCgwICBAjcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQwECyAAKAIEIQAgBCACNgIsIAIgACgCFCIBSQ0FDAgLIAAoAgQhACAEIAI2AiwgAiAAKAIUIgFJDQUMBwsgBEE4akGChIgQNgIAIARCgoSIkKDAgIECNwMwIARBMGoQyQwgAygCAEHom4QBQQQgAygCBCgCDBEGACECDAULIARBOGpBgoSIEDYCACAEQoKEiJCgwICBAjcDMCAEQTBqIgAQyQwgBEEANgJAIARBATYCNCAEQeybhAE2AjAgBEIENwI4IAMgABDROQshAiAEQRRqEOUQDAMLIARBK2ogAxC2HCECDAILIAQgACgCECACajAAADcDACAEQThqQYKEiBA2AgAgBEKChIiQoMCAgQI3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBDYCFCADKAIAIAMoAgQgABDLCiECDAELIAQgACgCECACajAAADcDCCAEQThqQYKEiBA2AgAgBEKChIiQoMCAgQI3AzAgBEEwaiIAEMkMIARBAjYCNCAEQeychAE2AjAgBEICNwI8IARBrwM2AiAgBCAFNgIcIARB7gY2AhggBCAEQRRqNgI4IAQgBEEIajYCFCADKAIAIAMoAgQgABDLCiECDAALIARB0ABqJAAgAg8LIAQgATYCTAwBCyAEIAA2AkwLIARBAjYCNCAEQbiXhAE2AjAgBEICNwI8IARBOzYCICAEQTs2AhggBCAEQRRqNgI4IAQgBEHMAGo2AhwgBCAEQSxqNgIUIARBMGpByJeEARDvLAALiQgCBn8DfiMAQaABayICJAAgAUEMahDZPCEDIAJBCGogARCSNhDuJSADIQQCQAJAAkACQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiAgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIgATYCQCACIAM2AjggAiAFNgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAwNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogAxC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDODSACKAKIASIBQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIANFDQBBACEEA0AgAkHQAGogAkE0aiAEEM4NIAIoAlAiAUGTgICAeEcNAiADIARBAWoiBEcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHYAGoiBSkCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBDYCVCACIAY2AlAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBDYCkAEgAiAGNgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQwR0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgATYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQALiQgCBn8DfiMAQaABayICJAAgAUEMahDZPCEDIAJBCGogARCSNhDuJSADIQQCQAJAAkACQAJAAkACQCADQT9xIgUEQCADIAVrQUBrIgQgA0kNAQtBwAAhBSAEQcAAENE0BEACQCAEBEAgBEHAABCtNiIFRQ0BCyACIAU2AiggAiAENgIkIAJBwAA2AiAgAwRAIAVBACAD/AsACyACIAM2AjAgAiADNgIsIAIgATYCQCACIAM2AjggAiAFNgI0IAIgAkHQAGoiATYCPCACKAIIRQ0DIAIoAhwgAigCGEYNBCABIAJBCGoQyDQgAkHwAGohAwNAAkAgAikDeCIJUEUEQCACKQOAASEIDAELA0ACfgJAIAIpA2AiCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDYCAIp0EBcUUNACACIAIpA2g3A5ABDAELIAIoAnBFDQEgAkGIAWogAxC2KiACKQOIASEICyAIQgBSDQILIAJCAzcDYAsgAikDUCIIQgJRDQkgAkIANwNQIAIpA1gMAQsgAikDkAELIQkgCKdBAXFFDQcgAiACKQOAAUJAfSIINwOAASACIAk3A3ggCVANAAsLIAIgCUIBIAl6IgqGhTcDeCACQYgBaiACQTRqIAqnIAinahDPDSACKAKIASIBQZOAgIB4Rg0ACyAAIAIpAowBNwIIIABBEGogAkGUAWopAgA3AgAMBgtBwAAgBBCjPQALQdyL/wBBKSACQdAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIANFDQBBACEEA0AgAkHQAGogAkE0aiAEEM8NIAIoAlAiAUGTgICAeEcNAiADIARBAWoiBEcNAAsLIAJB0ABqIgMQlykgAkEoaiIBKAIAIQYgAigCLCEEIAEgAkHYAGoiBSkCADcDACACKQMgIQggAiACKQJQNwMgIAJBADYCMCACIAg3AlwgAkEANgJYIAIgBDYCVCACIAY2AlAgAiADENc7IAIoAgAhBkEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikCUDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQeAAaiIHKAIANgIAIAIgBDYCkAEgAiAGNgKMASACIAE2AogBIAJBxABqIgEgAkGIAWoQ4xkgByACQRhqKQIANwMAIAUgAkEQaikCADcDACACIAIpAgg3A1AgACABIAMQ2B0gAkEgahDPLwwCCyAAIAIpAlQ3AgggAEEQaiACQdwAaikCADcCAAsgAEEpOgAAIAAgATYCBCACQSBqEM8vIAIoAggiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkGgAWokAA8LQQRBHBCjPQAL5xoCEX8BfiMAQdAAayICJAAgAiABNgIUAkAgAkEUaiIBEKo7RQRAIAEgAkEYakGQxsMAENELIQEgAEECNgIAIAAgATYCBCACKAIUIgBBhAFJDQEgABDyHwwBCyACKAIUIQEgAkEYaiIEQezKwwA2AgggBCABNgIQIARBADYCACAEQZzLwwA2AgwgAkGBgICAeDYCLCACQYGAgIB4NgI4IAJBxABqIAQQ9hACQAJAIAItAERFBEBBAiELQQIhDEECIQ1BAiEOA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0ARUEBaw4HAwQFBgcCAAELIAAgAikCPDcCMCAAIAIpAjA3AiQgACAPNgIcIAAgEDYCFCAAIBE2AgwgACASNgIEIABBgICAgHggAigCOCIBIAFBgYCAgHhGGzYCLCAAQYCAgIB4IAIoAiwiASABQYGAgIB4Rhs2AiAgACAOQQAgDkECRxs2AhggACANQQAgDUECRxs2AhAgACAMQQAgDEECRxs2AgggACALQQAgC0ECRxs2AgAMDgsgC0ECRg0IQbzKwwBBCRCOJCEBDAwLIAJBGGoiBCgCACAEQQA2AgAgBCgCBBClLyIBQYQBTwRAIAEQ8h8LIAJBCGpBADYCAAwICyACKAIsQYGAgIB4RwRAQcXKwwBBCRCOJCEBDAsLIAIoAhggAkEANgIYIAJBxABqIQggAigCHBClLyEEIwBBEGsiCiQAIAogBDYCAAJAIAoQzyxFBEAgCkEEaiEBIwBBIGsiCSQAIAkgBDYCDAJAIAlBDGoiBhDuOgRAIAlBEGoiBCAGENEvIAlBADYCHEEAIQMjAEEgayIHJAAgBCgCAARAIAQoAggiAyAEKAIEayIGQQAgAyAGTxshAwsgB0EUaiIGQYCAECADIANBgIAQTxtBAEEEQQQQoBggBygCGCEDAkAgBygCFEEBRwRAIAdBADYCECAHIAcoAhw2AgwgByADNgIIIAYgBBCXHwJAAkAgBygCFCIDQQJHBEADQCADQQFxRQ0CIAcoAhghBiAHKAIQIgMgBygCCEYEQCAHQQhqQbikwwAQlygLIAcoAgwgA0ECdGogBjYCACAHIANBAWo2AhAgB0EUaiAEEJcfIAcoAhQiA0ECRw0ACwsgASAHKAIYNgIEIAFBgICAgHg2AgAgB0EIahDpOwwBCyABIAcpAgg3AgAgAUEIaiAHQRBqKAIANgIACyAHQSBqJAAMAQsgAyAHKAIcQaikwwAQ/S8ACwwBCyAJQRBqIAlBDGoQxxIgCSgCECEGAkACQAJAIAktABQiBEECaw4CAQACCyABQYCAgIB4NgIAIAEgBjYCBAwCCyAJQQxqIAlBEGpBoMbDABDRCyEEIAFBgICAgHg2AgAgASAENgIEDAELIwBBIGsiAyQAIAMgBEEBcToABCADIAY2AgAgA0EUaiIEQQBBAEEEQQQQoBggAygCGCEGAkAgAygCFEEBRwRAIANBADYCECADIAMoAhw2AgwgAyAGNgIIIAQgAxDOGwJAAkACQCADKAIUIgRBAkcEQANAIARBAXFFDQIgAygCGCEEIAMoAhAiBiADKAIIRgRAIANBCGpBuKTDABCXKAsgAygCDCAGQQJ0aiAENgIAIAMgBkEBajYCECADQRRqIAMQzhsgAygCFCIEQQJHDQALCyABIAMoAhg2AgQgAUGAgICAeDYCACADQQhqEOk7IAMoAgAiBEGDAUsNAQwCCyABIAMpAgg3AgAgAUEIaiADQRBqKAIANgIAIAMoAgAiBEGEAUkNAQsgBBDyHwsgA0EgaiQADAELIAYgAygCHEGopMMAEP0vAAsLIAkoAgwiAUGDAUsEQCABEPIfCyAJQSBqJAAgCigCBEGAgICAeEYEQCAIIAooAgg2AgQgCEGBgICAeDYCAAwCCyAIIAopAgQ3AgAgCEEIaiAKQQxqKAIANgIADAELIAhBgICAgHg2AgAgBEGEAUkNACAEEPIfCyAKQRBqJAAgAigCSCEBIAIoAkQiBkGBgICAeEYNCiACKAJMIQQgAigCLEGBgICAeEcEQCACQSxqEJcwCyACIAQ2AjQgAiABNgIwIAIgBjYCLAwHCyAMQQJGDQRBzsrDAEEFEI4kIQEMCQsgDUECRg0CQdPKwwBBBhCOJCEBDAgLIAIoAjhBgYCAgHhHBEBB2crDAEEHEI4kIQEMCAsgAigCGCACQQA2AhggAkHEAGohCiACKAIcEKUvIQQjAEEQayIJJAAgCSAENgIAAkAgCRDPLEUEQCAJQQRqIQEjAEEgayIHJAAgByAENgIMAkAgB0EMaiIGEO46BEAgB0EQaiIEIAYQ0S8gB0EANgIcQQAhBiMAQSBrIgUkACAEKAIABEAgBCgCCCIDIAQoAgRrIgZBACADIAZPGyEGCyAFQRRqQdWqBSAGIAZB1aoFTxtBAEEEQQwQoBggBSgCGCEGAkAgBSgCFEEBRwRAIAVBADYCECAFIAUoAhw2AgwgBSAGNgIIAkADQAJAIAVBFGohAyMAQSBrIggkAAJAAkAgBCgCAEUNACAIQQhqIAQQuyggCCgCCEEBcUUNACAIKAIMIQYgBCAEKAIMQQFqNgIMIAhBFGogBhC0PSAIKAIUQYCAgIB4RgRAIAMgCCgCGDYCBCADQYGAgIB4NgIADAILIAMgCCkCFDcCACADQQhqIAhBHGooAgA2AgAMAQsgA0GAgICAeDYCAAsgCEEgaiQAAkACQCAFKAIUIgNBgICAgHhrDgICAAELIAEgBSgCGDYCBCABQYCAgIB4NgIAIAVBCGoiARDRKyABEOg7DAMLIAUpAhghEyAFKAIQIgggBSgCCEYEQCAFQQhqELwoCyAFKAIMIAhBDGxqIgYgEzcCBCAGIAM2AgAgBSAIQQFqNgIQDAELCyABIAUpAgg3AgAgAUEIaiAFQRBqKAIANgIACyAFQSBqJAAMAQsgBiAFKAIcQaikwwAQ/S8ACwwBCyAHQRBqIAdBDGoQxxIgBygCECEGAkACQAJAIActABQiBEECaw4CAQACCyABQYCAgIB4NgIAIAEgBjYCBAwCCyAHQQxqIAdBEGpBsMbDABDRCyEEIAFBgICAgHg2AgAgASAENgIEDAELIwBBIGsiBSQAIAUgBEEBcToABCAFIAY2AgAgBUEUakEAQQBBBEEMEKAYIAUoAhghBAJAIAUoAhRBAUcEQCAFQQA2AhAgBSAFKAIcNgIMIAUgBDYCCAJAAkADQAJAIAVBFGohAyMAQSBrIggkACAIQQhqIAUQ/CkCQAJAIAgoAggiBEECRwRAIAgoAgwhBiAEQQFxRQ0BIANBgYCAgHg2AgAgAyAGNgIEDAILIANBgICAgHg2AgAMAQsgCEEUaiAGELQ9IAgoAhQiBEGAgICAeEcEQCADIAgpAhg3AgQgAyAENgIADAELIAgoAhghBCADQYGAgIB4NgIAIAMgBDYCBAsgCEEgaiQAAkACQCAFKAIUIgZBgICAgHhrDgICAAELIAEgBSgCGDYCBCABQYCAgIB4NgIAIAVBCGoiARDRKyABEOg7IAUoAgAiAUGDAUsNAwwECyAFKQIYIRMgBSgCECIDIAUoAghGBEAgBUEIahC8KAsgBSgCDCADQQxsaiIEIBM3AgQgBCAGNgIAIAUgA0EBajYCEAwBCwsgASAFKQIINwIAIAFBCGogBUEQaigCADYCACAFKAIAIgFBhAFJDQELIAEQ8h8LIAVBIGokAAwBCyAEIAUoAhxBqKTDABD9LwALCyAHKAIMIgFBgwFLBEAgARDyHwsgB0EgaiQAIAkoAgRBgICAgHhGBEAgCiAJKAIINgIEIApBgYCAgHg2AgAMAgsgCiAJKQIENwIAIApBCGogCUEMaigCADYCAAwBCyAKQYCAgIB4NgIAIARBhAFJDQAgBBDyHwsgCUEQaiQAIAIoAkghASACKAJEIgZBgYCAgHhGDQcgAigCTCEEIAIoAjhBgYCAgHhHBEAgAkE4ahCYMAsgAiAENgJAIAIgATYCPCACIAY2AjgMBAsgDkECRwRAQeDKwwBBCxCOJCEBDAcLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiDyEBIAIoAkQiDkECRw0DDAYLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiECEBIAIoAkQiDUECRw0CDAULIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiESEBIAIoAkQiDEECRw0BDAQLIAIoAhghASACQQA2AhggAkHEAGogASACKAIcEKUvENIiIAIoAkgiEiEBIAIoAkQiC0ECRg0DCyACQcQAaiACQRhqEPYQIAItAERFDQALCyACKAJIIQELIABBAjYCACAAIAE2AgQgAigCOEGBgICAeEcEQCACQThqEJgwCyACKAIsQYGAgIB4Rg0AIAJBLGoQlzALIAIoAigiAEGEAU8EQCAAEPIfCyACKAIYRQ0AIAIoAhwiAEGEAUkNACAAEPIfCyACQdAAaiQAC5AHAg1/AX5BVCEHAkAgBa0gAkECaiIFrUIBIAOthnxCAYZCfINCCHxUDQBBASADdCIKQQN2IApBAXYiBmpBA2ohDiAGQQEgAxshECACQQFqIQsgAEEEaiERIAQgAkEBdGpBBGohDCAAIAI7AQIgACADOwEAIARBADsBAEEBIAUgBUEBTRtBAWshDyAEIQUgASEGIApBAWsiDSEJA0AgCCAPRkUEQCAFLwEAIQcCQCAGLwEAIhJB//8DRgRAIAVBAmogB0EBajsBACAJIAxqIAg6AAAgCUEBayEJDAELIAVBAmogByASajsBAAsgBUECaiEFIAZBAmohBiAIQQFqIQgMAQsLIAQgC0EBdGogCkEBajsBAAJAIAkgDUcEQEEAIQVBACEGA0AgBiALRg0CQQAhCCABIAZBAXRqLgEAIgJBACACQQBKGyECA0AgAiAIRkUEQCAFIAxqIAY6AAADQCAFIA5qIA1xIgUgCUsNAAsgCEEBaiEIDAELCyAGQQFqIQYMAAsACyAKIAxqIQggBCAKIAJBAXRqaiEJQQAhB0EAIQIDQCAHIAtGBEAgDkEBdCECQQAhB0EAIQYDQCAGIApPDQNBACEFIAchCQNAIAVBAkZFBEAgDCAJIA1xaiAFIAhqLQAAOgAAIAkgDmohCSAFQQFqIQUMAQsLIAhBAmohCCAGQQJqIQYgAiAHaiANcSEHDAALAAUgAiAIaiATNwAAIAIgCWohDyABIAdBAXRqLgEAIQZBCCEFA0AgBSAGTkUEQCAFIA9qQQRqIBM3AAAgBUEIaiEFDAELCyATQoGChIiQoMCAAXwhEyAHQQFqIQcgAiAGaiECDAELAAsAC0EAIQUDQCAFIApGBEAgA0EfayEEIBBBAnQgAGpBCGohBSADQRB0IAprIgNBgIAEaiEGQQAhB0EAIQADQCALRQ0DAkACQAJAAkACQCABLwEAIgIOAgACAQsgBSAGNgIADAMLIAJB//8DRw0BCyAFIAM2AgAgBUEEayAAQQFrNgIAIABBAWohAAwBCyAFQQRrIAAgAsEiAms2AgAgBSAEIAJBAWtnaiIJQRB0IAIgCXRrNgIAIAAgAmohAAsgAUECaiEBIAVBCGohBSALQQFrIQsMAAsABSAEIAUgDGotAABBAXRqIgIgAi8BACICQQFqOwEAIBEgAkEBdGogBSAKajsBACAFQQFqIQUMAQsACwALIAcLuwcCBH8DfiMAQcAEayICJAACQAJAAkACQAJAAkACQCABKQMAIgZCAlYNAAJAIAanQQFrDgIBAAILIAEoAhghAyABQQA2AhggAwRAIAJBsAJqIAMoAvwBIAMoAvgBIAEpAxAQhRkgAigCsAIiBEEIRwRAIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBDYCACADEPwsIANBiAJBCBD4OgwICyABIAEpAwggAzQC/AF8NwMIIAEgASkDECADNAL8AX03AxAgAxD8LCADQYgCQQgQ+DoMBgsgAkGwAmogASgCQEEIaiABKQMIEOEwIAJBGGoiAyACQbwCaikCADcDACACIAIpArQCNwMQIAIoArACIgRBCEcEQCACKALEAiEBIAAgAikDEDcCBCAAIAE2AhQgACAENgIAIABBDGogAykDADcCAAwHCyACQQhqIAMpAwA3AwAgAiACKQMQNwMAIAJBsAJqIAIgASgCHCABLQAgEPETIAIpA7gCIgZCBFEEQCACQagCaiACQdACaikDACIGNwMAIAJBoAJqIAJByAJqKQMAIgc3AwAgAiACKQPAAiIINwOYAiAAQRBqIAY3AwAgAEEIaiAHNwMAIAAgCDcDAAwFCyACQaACaiIEIAJByAJqKQMANwMAIAJBqAJqIgUgAkHQAmopAwA3AwAgAiACKQPAAjcDmAIgAigCsAIhAyACQTBqIAJB2AJqQegB/AoAACACQSBqIAQpAwA3AwAgAkEoaiAFKQMANwMAIAIgBjcDECACIAIpA5gCNwMYIAJBsAJqIAMgASkDEBCOGiACKAKwAiIEQQhHBEAMBAsgAkGwAmogAigCjAIgAigCiAIgASkDEBCFGSACKAKwAiIEQQhHBEAMBAsgASACNAKMAiADrXwiBiABKQMIfDcDCCABIAEpAxAgBn03AxAgAkEQahD8LCACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAULIAFCADcDAAwBCyACQbACaiABQSBqEOEcIAIpA7ACUA0AIAEgASgCNEEBajYCNAsgAEEINgIADAMLIAAgAikCtAI3AgQgAEEUaiACQcQCaigCADYCACAAQQxqIAJBvAJqKQIANwIAIAAgBDYCACACQRBqEPwsCyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELAkAgAS0AIEUEQCABIAEoAhxBAWo2AhwMAQsgAUEAOgAgCyAAQQg2AgALIAJBwARqJAALhwgCBX8BfiMAQdAAayIEJAAgBEEsaiABIAIQ8RUCQCAEKAIsIgVBk4CAgHhHBEAgACAEKQI0NwIIIABBEGogBEE8aigCADYCACAAIAQoAjA2AgQgACAFNgIADAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAItACgiBUEUaw4VBAEEAgQEAgkBBgkBAwgBAQEBAQkKAAsgBUUNCgsgARDqKSABEOopDAkLIAJBKGohBSADKAIMIgIEQCADIAJBAWs2AgwgAyADKAIIIgZBAWoiByADKAIAIghBACAHIAhPG2s2AgggAygCBCAGQQN0aikDAEICfCEJCyAEQQI2AjAgBEHc1v4ANgIsIARCATcCOCAEQacENgJIIAQgBTYCTCAEIARBxABqNgI0IAQgBEHMAGo2AkQgBEEcaiAEQSxqEJkOIARBjICAgHg2AhggAg0CIAQpAhwhCSAAIAQpAiQ3AgwgACAJNwIEIABBjICAgHg2AgAMCQsgARDqKSAEQQhqIAJBLGoQry4gBCgCCCICIAQoAgwiBUYNBwwDC0EDIQIDQCABEOopIAJBAWsiAg0ACwwGCyAEQRhqEIgRIAlCAFcNBQNAIAEQ6ikgCUIBfSIJUEUNAAsMBQsgARDqKSAEQSxqIAEgAigCMEEIaiADEMoHIAQoAiwiAUGTgICAeEYNBCAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwFCwNAAkAgBEEsaiABIAIoAgBBCGogAxDKByAEKAIsIgZBk4CAgHhHDQAgBSACQQRqIgJHDQEMBQsLIAAgBCkCMDcCBCAAQQxqIARBOGopAgA3AgAgACAGNgIADAQLIAEQ6ikgAi0AKQRAIAEQ6ikLIARBEGogAkEsahCwLiAEKAIQIgIgBCgCFCIFRg0CA0AgBEEsaiABIAJBBGooAgBBCGogAxDKByAEKAIsIgZBk4CAgHhHBEAgACAEKQIwNwIEIABBDGogBEE4aikCADcCACAAIAY2AgAMBQsgBSACQQhqIgJHDQALDAILIAEQ6ikgARDqKSAEQSxqIAEgAigCLEEIaiADEMoHIAQoAiwiAUGTgICAeEYNASAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwCCyAEQSxqIAEgAigCLEEIaiADEMoHIAQoAiwiBUGTgICAeEcEQCAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgBTYCAAwCCyAEQSxqIAEgAigCMEEIaiADEMoHIAQoAiwiAUGTgICAeEYNACAAIAQpAjA3AgQgAEEMaiAEQThqKQIANwIAIAAgATYCAAwBCyAAQZOAgIB4NgIACyAEQdAAaiQAC+4HAQ9/IwBBQGoiAyQAAkACQAJAIAAoAgAiC0ECRgRAIAAoAhAhAiAALQAkIQQgA0E0aiAAKAIUIgZBAEEBQQEQoBggAygCOCEIIAMoAjRFDQEgCCADKAI8QeSjzwAQ/S8ACyAAKAIkIQQgAC0AMCEMIAAoAiwhCCAAKAIoIQkCQAJAAkACQCAALQAgIgJBAWsOAwECAAMLQZ+6zwBBK0HMus8AEJ8pAAtBASECDAELQQIhAgsgACgCDCEFIANBNGogACgCECIGQQBBAUEBEKAYIAMoAjghByADKAI0QQFGDQEgAygCPCEKIAYEQCAKIAUgBvwKAAALIAAoAgQhDSAALQAhIANBNGoiDyAAEIkZQQJ0IgBBrOTPAGooAgAhDiAAQdDjzwBqKAIAIRACQCADLQA0QRFHBEAgA0EMaiAPEP0TDAELIANBEjYCDAsgASgCCCIFIAEoAgBGBEAgAUGgwc8AEJ8oCyABKAIEIAVB4ABsaiIAIA02AjwgACALQQBHNgI4IAAgCDYCNCAAIAhBf3NBH3Y2AjAgACAJNgIsIAAgCUF/c0EfdjYCKCAAIBA2AiQgACAONgIgIABBADYCGCAAIAI2AhQgAEEBNgIQIAAgBDYCDCAAIARBf3NBH3Y2AgggACAMNgIEIABBATYCACAAIAMpAgw3AkAgAEHIAGogA0EUaikCADcCACAAQdAAaiADQRxqKAIANgIAIAAgBjYCXCAAIAo2AlggACAHNgJUIAEgBUEBajYCCAwCCyAEQQJ0IgRBwOPPAGooAgAhCiAEQbDjzwBqKAIAIQUgAygCPCEJIAYEQCAJIAIgBvwKAAALIAAoAgghCyAAKAIEIQwgACgCMCEEIAAtACUgA0E0aiIHIABBBGoQiRlBAnQiAkGs5M8AaigCACENIAJB0OPPAGooAgAhDgJAIAMtADRBEUcEQCADQSBqIAcQ/RMMAQsgA0ESNgIgCyABKAIIIgcgASgCAEYEQCABQbDBzwAQnygLIAEoAgQgB0HgAGxqIgIgCzYCPCACIAw2AjggAkEANgIwIAJBADYCKCACIA42AiQgAiANNgIgIAIgBDYCHCACQQE2AhggAiAFNgIUIAIgCjYCECACQQA2AgggAkEANgIAIAIgAykCIDcCQCACIAY2AlwgAiAJNgJYIAIgCDYCVCACQcgAaiADQShqKQIANwIAIAJB0ABqIANBMGooAgA2AgAgASAHQQFqNgIIIARFDQEgACgCLCEAIARBAnQhAgNAIAAoAgBBCGogARDLByAAQQRqIQAgAkEEayICDQALDAELIAcgAygCPEHko88AEP0vAAsgA0FAayQAC4wHAgt/CX4jAEGAAWsiBiQAIAYgACgCCCIHNgIIIAYgASACaiIIQQFqIgI2AgwCQAJAAkACQAJAIAIgB0YEQCAAIAMgAUEBaiIJaiIHEIctIAA1AhQhFSAGQRBqIAQgBRDgHCAGQgA3A3ggBiABNgJwIAYgCDYCdCABIAhPDQEgBigCaCEMIAYpAzAhEyAGKAJkIQogBigCYCEFIAYpA1AhESAGKQNAIRQgBigCICENIAYpAxghEiAGKAI4IQ8gBigCKCEQIAYpA1ghGCAGKQNIIRkgBikDECEWAkACQAJAA0AgFqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIBJQRQ0BQgAhEkIAIRZBASECDAQLAn4CQCAUQgJ9IhdCAVgEQCAXp0EBaw0BDAULIBSnIBRQrUIBhiEUQQFxRQ0AIBkMAQsgEUIDUQRAQgMhEQwECyAFRSAFIApGckUEQCAKQQhrIgopAwAMAQtBACEFIBFCAlEEQEICIREMBAsgEadCACERQQFxRQ0DIBgLIRJCASEWIAxBQGoiDCENDAELIA0gEnmnQT9zIgJqIQNCASACrYYgEoUhEgwDC0EAIQIMAQsLIBAgE0IAUnFFDQYgDyATeadBP3MiAmohA0IBIAKthiAThSETCyAIQQFrIgQgA0sEQEGYy9AAQShBwMvQABCfKQALIAMgB0kEQCAIIAAoAggiAk8NAiACIAdJDQMgACgCBCILIARBA3RqKQMAIRUgCyADQQN0Ig5qQQhqIgIgCyAHQQN0IgdqRwRAIAsgCEEDdGopAwAhFyAHIA5rQQhrIQcDQCACIBc3AwAgAkEIaiECIAdBCGsiBw0ACwsgAyAERg0IIAMgACgCCCICTw0EIAAoAgQgDmogFTcDACADIQcgBCIIIAFNDQcMAQsLQdDL0ABBJkH4y9AAEJ8pAAsgCCACQYjM0AAQwyEACyAHIAJBmMzQABCwOwALIAMgAkGozNAAEMMhAAsgBkEANgIQQQAgBkEIaiAGQQxqIAZBEGpB6MrQABCvKwALIAchAwsgAyAJSQ0BIAMgACgCCCICSw0CIAMgCUYNACADQQN0IAFBA3RrQQhrIQcgACgCBCAJQQN0aiECA0AgAiAVNwMAIAJBCGohAiAHQQhrIgcNAAsLIAZBgAFqJAAPCyAJIANBiMvQABCxOwALIAMgAkGIy9AAELA7AAuMBwIMfwh+IwBBgAFrIgYkACAGIAAoAggiBzYCCCAGIAEgAmoiCEEBaiICNgIMAkACQAJAAkACQCACIAdGBEAgACADIAFBAWoiCWoiBxCGLSAAKAIUIQogBkEQaiAEIAUQ4BwgBkIANwN4IAYgATYCcCAGIAg2AnQgASAITw0BIAYoAmghDSAGKQMwIRQgBigCZCELIAYoAmAhBSAGKQNQIRIgBikDQCEVIAYoAiAhDiAGKQMYIRMgBigCOCEQIAYoAighESAGKQNYIRcgBikDSCEYIAYpAxAhFgJAAkACQANAIBanQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCATUEUNAUIAIRNCACEWQQEhAgwECwJ+AkAgFUICfSIZQgFYBEAgGadBAWsNAQwFCyAVpyAVUK1CAYYhFUEBcUUNACAYDAELIBJCA1EEQEIDIRIMBAsgBUUgBSALRnJFBEAgC0EIayILKQMADAELQQAhBSASQgJRBEBCAiESDAQLIBKnQgAhEkEBcUUNAyAXCyETQgEhFiANQUBqIg0hDgwBCyAOIBN5p0E/cyICaiEDQgEgAq2GIBOFIRMMAwtBACECDAELCyARIBRCAFJxRQ0GIBAgFHmnQT9zIgJqIQNCASACrYYgFIUhFAsgCEEBayIEIANLBEBBmMvQAEEoQcDL0AAQnykACyADIAdJBEAgCCAAKAIIIgJPDQIgAiAHSQ0DIAAoAgQiDCAEQQJ0aigCACEKIAwgA0ECdCIPakEEaiICIAwgB0ECdCIHakcEQCAMIAhBAnRqKAIAIQggByAPa0EEayEHA0AgAiAINgIAIAJBBGohAiAHQQRrIgcNAAsLIAMgBEYNCCADIAAoAggiAk8NBCAAKAIEIA9qIAo2AgAgAyEHIAQiCCABTQ0HDAELC0HQy9AAQSZB+MvQABCfKQALIAggAkGIzNAAEMMhAAsgByACQZjM0AAQsDsACyADIAJBqMzQABDDIQALIAZBADYCEEEAIAZBCGogBkEMaiAGQRBqQejK0AAQrysACyAHIQMLIAMgCUkNASADIAAoAggiAksNAiADIAlGDQAgA0ECdCABQQJ0a0EEayEHIAAoAgQgCUECdGohAgNAIAIgCjYCACACQQRqIQIgB0EEayIHDQALCyAGQYABaiQADwsgCSADQYjL0AAQsTsACyADIAJBiMvQABCwOwALlggBCH8jAEHQAGsiAiQAIAJBOGogARDwJyACQShqIgMgAkHEAGoiBSgCADYCACACIAIpAjw3AyACQCACKAI4IgZBBEcEQCACKAJIIQEgACACKQMgNwIEIAAgATYCECAAIAY2AgAgAEEMaiADKAIANgIADAELIAJBEGogAygCADYCACACIAIpAyA3AwggAkEIahCGMCACQThqIAEQ0wkgAyAFKQIANwMAIAJBMGoiBiACQcwAaigCADYCACACIAIpAjw3AyACQCACKAI4RQRAIAJBPGohB0EAIQVBAyEDA0AgAkEYaiAGKAIAIgQ2AgAgAkEQaiACQShqIggpAwA3AwAgAiACKQMgNwMIAkACQCAEQf8BcQRAIAJBOGogAkEIahD8FyACLwE8IQQgAigCOCIJQQRHBEAgACACKQE+NwEGIABBDGogAkHEAGopAQA3AQAgACAEOwEEIAAgCTYCAAwGCwJAAkACQAJAIARBAWsOAwABAgMLIAJBOGogARD6CiACKAI4IgRBBEYNBCAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAQ2AgAMCAsgAkE4aiABEPoKIAIoAjgiBEEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgBDYCAAwIC0EBIAMgA0H/AXFBA0YbIQMMBAsgAkE4aiABEPoKIAIoAjgiBEEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgBDYCAAwHC0ECIAMgA0H/AXFBA0YbIQMMAwsgAkE4aiABIAItABhBwAAQyQIgAigCOCIEQQRGDQIgACACKQI8NwIEIABBDGogAkHEAGopAgA3AgAgACAENgIADAULIAJBCGoQhjAgAkE4aiABEKgpIAIoAjgiAUEERwRAIAAgAikCPDcCBCAAQQxqIAJBxABqKQIANwIAIAAgATYCAAwGCyAFRQRAIABBBGpBxP/PAEEpEKIfIABBATYCAAwGCyAFQQFMBEAjAEEgayIBJAACQCADQf8BcUEDRwRAIABBBDYCACAAIAM6AAQMAQsgAUEQakGkgNAAQSkQoh8gAEEIaiABQRRqKQIANwIAIABBEGogAUEcaigCADYCACABQQE2AgwgACABKQIMNwIACyABQSBqJAAMBgsgAEEEakHt/88AQTcQoh8gAEEBNgIADAULIANBACADQf8BcUEDRxshAwsgAkEIahCGMCACQThqIAEQ0wkgCCAHQQhqKQIANwMAIAYgB0EQaigCADYCACACIAcpAgA3AyAgBUEBaiEFIAIoAjhFDQALCyAAIAIpAyA3AgAgAEEQaiAGKAIANgIAIABBCGogAkEoaikDADcCAAwBCyACQQhqEIYwCyACQdAAaiQAC7cRAg5/AX4jAEHwAWsiBCQAIARBEGogASACKAIQEQAAIARBoAFqIgEgBCgCECIKIAQoAhQoAgwRAAACQAJAIApFDQAgBCkDoAFCkJ6z7tm0jZLpAIUgBCkDqAFCiPSrgeCxxeTCAIWEUEUNACABIAoQtBQjAEHwAGsiBSQAIAVByABqIgIgAUEUaigCADYCACAFQdQAaiIGIAFBIGooAgA2AgAgBUHgAGoiByABQSxqKQIANwMAIAVB6ABqIgggAUE0aikCADcDACAFIAEpAgw3A0AgBSABKQIYNwJMIAUgASkCJDcDWCABELMMIAVBEGogAigCADYCACAFQSBqIAYoAgA2AgAgBUEwaiAHKQMANwMAIAVBOGogCCkDADcDACAFIAUpA0A3AwggBSAFKQJMNwMYIAUgBSkDWDcDKCAEQRxqIQYgBUEoaiEIIwBB4ABrIgIkACACIAVBCGoiCSgCCEECdkEBayIQNgIAIAJBIGohByMAQeAAayIBJAAgAUEIaiAFQRhqIg0Q3DsgAUEUaiABKAIIIAEoAgwQnQkCQCABKAIUQQFGBEAgASABKQIYNwM4IAFBATYCRCABQYjSgAE2AkAgAUIBNwJMIAFBsAM2AlwgASABQdgAajYCSCABIAFBOGo2AlggAUEoaiABQUBrEJkOIAEpAighEiAHIAEpAjA3AgwgByASNwIEIAdBjYCAgHg2AgAMAQsgCSgCCCILQQRPBEAgASgCHCEMIAEoAhghESAJKAIEIQ4gC0F8cSEPA0AgASAOKAIAIgs2AiACQCALRQ0AIAsgDE8EQCALIAxGDQEgASAMNgIUIAFBAjYCRCABQbTRgAE2AkAgAUICNwJMIAFBOzYCMCABQTs2AiggASABQSRqNgJIIAEgAUEUajYCLCABIAFBIGo2AiQgB0EEaiABQUBrEJkOIAdBjYCAgHg2AgAMBAsgCyARaiwAAEG/f0oNACABQQE2AkQgAUHk0YABNgJAIAFCATcCTCABQTs2AiggASABQSRqNgJIIAEgAUEgajYCJCAHQQRqIAFBQGsQmQ4gB0GNgICAeDYCAAwDCyAOQQRqIQ4gD0EEayIPDQALCyAHQZOAgIB4NgIACyABQeAAaiQAAkACQAJAIAIoAiAiAUGTgICAeEYEQAJAIAgoAgAiAQRAIBAgCCgCECIHRw0BCyACQShqQZiw4MABNgIAIAJBNGogCUEIaigCADYCACACQUBrIA1BCGooAgA2AgAgAkHMAGogCEEIaikCADcCACACQdQAaiAIQRBqKQIANwIAIAJCmLDgwIGDhowYNwMgIAIgCSkCADcCLCACIA0pAgA3AzggAiAIKQIANwJEIAYgAkEgakE8/AoAAAwECyACIAc2AhwgAkEENgIIIAJBjPeAATYCBCACQgQ3AhAgAkE7NgI8IAJBOzYCNCACQcwBNgIsIAJByPaAATYCKCACQcwBNgIkIAJBrPeAATYCICACIAJBIGo2AgwgAiACQRxqNgI4IAIgAjYCMCAGQQhqIAJBBGoQmQ4gBkEpOgAAIAZBjYCAgHg2AgQMAQsgBiACKQIkNwIIIAZBEGogAkEsaikCADcCACAGQSk6AAAgBiABNgIEIAgoAgAiAUUNAQsgASABKAIAIgFBAWs2AgAgAUEBRw0AIAgQ+x4LIA0oAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIA0Q+x4LIAkoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0AIAkQ+x4LIAJB4ABqJAAgBUHwAGokAAJAAkAgBC0AHEEpRgRAIARB6ABqIARBMGooAgA2AgAgBEHgAGogBEEoaikCADcDACAEIAQpAiA3A1ggAy0ANA0BIAAgBEEgaiIBKQIANwIAIABBEGogAUEQaigCADYCACAAQQhqIAFBCGopAgA3AgAMBAtBxABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAEQRxqQTz8CgAAIABB0Pv/ADYCCCAAIAE2AgQgAEGTgICAeDYCAAwDCyAKENM6IQEgBEEIaiAKEKwqIARB7ABqIAEgBCgCDBCmFCAKENM6IQUgBEGkAWoiDSAKEPk0IAQgBTYCwAEgBEEANgK8ASAEIAo2AqABIAQoAqQBIQMgBQRAIARB+ABqIQsgBEGEAWohB0EAIQIDQAJAAkACQAJAAkACQCADRQ0AIAIgBCgCtAFPDQIgBCgCqAEgBCgCsAEgAmoiAUEDdmotAABB/wFzIAFBB3F2QQFxRQ0AIAQgAkEBaiICNgK8AQwBCyAEIAJBAWoiATYCvAEgBCAKIAIQjywgBEHkAWogBCgCACAEKAIEEJ0JIAQoAuQBRQ0CIAEhAgsgBxDmOiAEKAKEAUUNAiAEKAKUAUEBaiIIQQN2IAhBB3FBAEdqIgEgBCgCkAEiBksEQCABIAZrIQkgBCgCiAEiDCABSQRAIAcgDEEBdCIGIAFBwP///wNxQUBrIAEgAUE/cRsiDCAGIAxLGxDoGSAEKAKQASEGCyAJBEAgBCgCjAEgBmpBACAJ/AsACyAEIAE2ApABCyAEIAg2ApQBIAQoAnQhBiAEKAKAASIBIAQoAnhGBEAgC0HA9P8AEJ0oCyAEKAJ8IAFBAnRqIAY2AgAgBCABQQFqNgKAAQwDC0HM9v8AQSBB7Pb/ABCfKQALIARB7ABqIAQoAugBIAQoAuwBEL0SIAEhAgwBC0G49/8AELI7AAsgAiAFRw0ACwsCQCADRQ0AIAMgAygCACIBQQFrNgIAIAFBAUcNACANEPseCyAEQaABaiICIARB7ABqIgMQ7Q5BxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEHQ+/8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAMQuiwgBEHYAGoQiBEMAwtBBEHEABCjPQALQQRBxAAQoz0AC0GojoABELI7AAsgBEHwAWokAAu3EQIOfwF+IwBB8AFrIgQkACAEQRBqIAEgAigCEBEAACAEQaABaiIBIAQoAhAiCiAEKAIUKAIMEQAAAkACQCAKRQ0AIAQpA6ABQsKM9/bqy9zRhH+FIAQpA6gBQuWT9Jj5r/joqH+FhFBFDQAgASAKELIUIwBB8ABrIgUkACAFQcgAaiICIAFBFGooAgA2AgAgBUHUAGoiBiABQSBqKAIANgIAIAVB4ABqIgcgAUEsaikCADcDACAFQegAaiIIIAFBNGopAgA3AwAgBSABKQIMNwNAIAUgASkCGDcCTCAFIAEpAiQ3A1ggARCzDCAFQRBqIAIoAgA2AgAgBUEgaiAGKAIANgIAIAVBMGogBykDADcDACAFQThqIAgpAwA3AwAgBSAFKQNANwMIIAUgBSkCTDcDGCAFIAUpA1g3AyggBEEcaiEGIAVBKGohCCMAQeAAayICJAAgAiAFQQhqIgkoAghBA3ZBAWsiEDYCACACQSBqIQcjAEHgAGsiASQAIAFBCGogBUEYaiINENw7IAFBFGogASgCCCABKAIMEJ0JAkAgASgCFEEBRgRAIAEgASkCGDcDOCABQQE2AkQgAUGI0oABNgJAIAFCATcCTCABQbADNgJcIAEgAUHYAGo2AkggASABQThqNgJYIAFBKGogAUFAaxCZDiABKQIoIRIgByABKQIwNwIMIAcgEjcCBCAHQY2AgIB4NgIADAELIAkoAggiC0EITwRAIAEoAhwhDCABKAIYIREgCSgCBCEOIAtBeHEhDwNAIAEgDigCACILNgIgAkAgC0UNACALIAxPBEAgCyAMRg0BIAEgDDYCFCABQQI2AkQgAUG00YABNgJAIAFCAjcCTCABQTs2AjAgAUE7NgIoIAEgAUEkajYCSCABIAFBFGo2AiwgASABQSBqNgIkIAdBBGogAUFAaxCZDiAHQY2AgIB4NgIADAQLIAsgEWosAABBv39KDQAgAUEBNgJEIAFB5NGAATYCQCABQgE3AkwgAUE7NgIoIAEgAUEkajYCSCABIAFBIGo2AiQgB0EEaiABQUBrEJkOIAdBjYCAgHg2AgAMAwsgDkEIaiEOIA9BCGsiDw0ACwsgB0GTgICAeDYCAAsgAUHgAGokAAJAAkACQCACKAIgIgFBk4CAgHhGBEACQCAIKAIAIgEEQCAQIAgoAhAiB0cNAQsgAkEoakGZsuTIATYCACACQTRqIAlBCGooAgA2AgAgAkFAayANQQhqKAIANgIAIAJBzABqIAhBCGopAgA3AgAgAkHUAGogCEEQaikCADcCACACQpmy5MiRo8aMGTcDICACIAkpAgA3AiwgAiANKQIANwM4IAIgCCkCADcCRCAGIAJBIGpBPPwKAAAMBAsgAiAHNgIcIAJBBDYCCCACQYz3gAE2AgQgAkIENwIQIAJBOzYCPCACQTs2AjQgAkHMATYCLCACQcj2gAE2AiggAkHMATYCJCACQbj2gAE2AiAgAiACQSBqNgIMIAIgAkEcajYCOCACIAI2AjAgBkEIaiACQQRqEJkOIAZBKToAACAGQY2AgIB4NgIEDAELIAYgAikCJDcCCCAGQRBqIAJBLGopAgA3AgAgBkEpOgAAIAYgATYCBCAIKAIAIgFFDQELIAEgASgCACIBQQFrNgIAIAFBAUcNACAIEPseCyANKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCANEPseCyAJKAIAIgEgASgCACIBQQFrNgIAIAFBAUcNACAJEPseCyACQeAAaiQAIAVB8ABqJAACQAJAIAQtABxBKUYEQCAEQegAaiAEQTBqKAIANgIAIARB4ABqIARBKGopAgA3AwAgBCAEKQIgNwNYIAMtADQNASAAIARBIGoiASkCADcCACAAQRBqIAFBEGooAgA2AgAgAEEIaiABQQhqKQIANwIADAQLQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogBEEcakE8/AoAACAAQcD8/wA2AgggACABNgIEIABBk4CAgHg2AgAMAwsgChDUOiEBIARBCGogChCsKiAEQewAaiABIAQoAgwQpRQgChDUOiEFIARBpAFqIg0gChD5NCAEIAU2AsABIARBADYCvAEgBCAKNgKgASAEKAKkASEDIAUEQCAEQfgAaiELIARBhAFqIQdBACECA0ACQAJAAkACQAJAAkAgA0UNACACIAQoArQBTw0CIAQoAqgBIAQoArABIAJqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcUUNACAEIAJBAWoiAjYCvAEMAQsgBCACQQFqIgE2ArwBIAQgCiACENorIARB5AFqIAQoAgAgBCgCBBCdCSAEKALkAUUNAiABIQILIAcQ5jogBCgChAFFDQIgBCgClAFBAWoiCEEDdiAIQQdxQQBHaiIBIAQoApABIgZLBEAgASAGayEJIAQoAogBIgwgAUkEQCAHIAxBAXQiBiABQcD///8DcUFAayABIAFBP3EbIgwgBiAMSxsQ6BkgBCgCkAEhBgsgCQRAIAQoAowBIAZqQQAgCfwLAAsgBCABNgKQAQsgBCAINgKUASAENQJ0IRIgBCgCgAEiASAEKAJ4RgRAIAtBwPT/ABCzKAsgBCgCfCABQQN0aiASNwMAIAQgAUEBajYCgAEMAwtBzPb/AEEgQez2/wAQnykACyAEQewAaiAEKALoASAEKALsARC8EiABIQIMAQtBuPf/ABCyOwALIAIgBUcNAAsLAkAgA0UNACADIAMoAgAiAUEBazYCACABQQFHDQAgDRD7HgsgBEGgAWoiAiAEQewAaiIDEO4OQcQAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABBwPz/ADYCCCAAIAE2AgQgAEGTgICAeDYCACADELssIARB2ABqEIgRDAMLQQRBxAAQoz0AC0EEQcQAEKM9AAtBqI6AARCyOwALIARB8AFqJAAL2g8CC38BfiMAQSBrIhQkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0EBaiAKRwRAIAogA0EDakcNBiABKAIIIQ0gASgCBCEOIAMgCksNCyADRQ0FIAMgDUkNASADIA1HDQsMBQsgASgCCCENIAEoAgQhDgJAIApFDQAgCiANTwRAIAogDUYNAQwFCyAKIA5qLAAAQb9/TA0ECyAKIA5qIA0gCmtBnIfEAEECEPQuIAEoAgghDQ0BDAILIAMgDmosAABBv39KDQMMCQsCQAJAIApFDQAgCiANTwRAIAogDUYNAQwCCyABKAIEIApqLAAAQb9/TA0BCyABQQIQ2C0gDSAKayIOBEAgASgCBCAKaiIPQQJqIA8gDvwKAAALIAEoAgQgCmpBr9wAOwAAIAEgDUECaiINNgIIIApBAmohCgwBC0H8hMQAQSxBiJLEABCfKQALIAEoAgQhDgJAAkAgA0UNACADIA1PBEAgAyANRg0BDAILIAMgDmosAABBv39MDQELIAMgDmogDSADa0GEkcQAQQMQ9C5FDQNBh5HEAEHPAEGoksQAEJ8pAAsgDiANIAMgDUGYksQAEKM2AAsgDiANIAogDUH4kcQAEKM2AAsCQCAKRQ0AIAogDU8EQCAKIA1HDQcMAQsgCiAOaiwAAEG/f0wNBgsgAyAOaiAKIANrQcyQxABBAxDBLkUNACAKIAEoAggiDU8NASABKAIEIg4gCmoiDy0AAEEvRw0CAkAgDSAKQQFqIg9LBEAgDiAPai0AAEEvRg0BCyMAQUBqIg4kACAOIAo2AhAgDiADNgIMIAEoAgghDSABKAIEIRACQCADRQ0AAkAgAyANTwRAIAMgDUcNAQwCCyADIBBqLAAAQb9/Sg0BC0GsmsQAQSpB5JDEABCfKQALAkAgCkUNAAJAIAogDU8EQCAKIA1HDQEMAgsgCiAQaiwAAEG/f0oNAQtBrJrEAEEqQeSQxAAQnykACyAOIA5BEGo2AjwgDkEBNgI4IA5BADYCMCAOIA5BDGo2AjQgDkEwaiISKAIEIQ8CQAJAAkAgEigCAEEBaw4CAQIACyAPKAIAIREMAQsgDygCACIPQX9HBEAgD0EBaiERDAELIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHo+IkBNgIIIABCBDcCECAAQQhqQeibxAAQ7ywACyASKAIMIRMgDSEPAkACQAJAIBIoAghBAWsOAgECAAsgEygCACIPQX9HBEAgD0EBaiEPDAILIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEGc+YkBNgIIIABCBDcCECAAQQhqQfibxAAQ7ywACyATKAIAIQ8LAkAgDyARTwRAIA0gD08NASAPIA1BqJzEABCwOwALIBEgD0GonMQAELE7AAsgDiAPNgIEIA4gETYCACAOKAIEIQ8gASAOKAIAIhE2AgggDiABNgIcIA4gDzYCICAOIA0gD2s2AiQgDkGoi8QANgIoIA5BqYvEADYCLCAOIA8gEGo2AhggDiAQIBFqNgIUIwBBEGsiESQAIA5BFGoiFiINQoGAgIAQNwIAAkAgDSgCEEUEQCANKAIIIA1BFGoQyyMMAQsgDSANQRRqIhAQjR1FDQAgDSgCGCIPIA0oAhQiEkcEQCANIA8gEmsQ3CMgDSAQEI0dRQ0BCyMAQSBrIg8kACAPQRRqIBAoAgQgECgCAGtBAEEBQQEQoBggDygCGCESIA8oAhRBAUYEQCASIA8oAhxBiJzEABD9LwALIA9BEGoiE0EANgIAIA8gDygCHDYCDCAPIBI2AgggD0EIaiAQEMsjIBFBBGoiEEEIaiATKAIANgIAIBAgDykCCDcCACAPQSBqJAAgESgCCCEPIBEoAgQhFwJAIBEoAgwiEEUNACANIBAQ3CMgDSgCDCITIA0oAggiEigCCCINRg0AIBMgDWshFSASKAIEIA1qIRMgDyENA0AgEEUNASATIA0tAAA6AAAgEiASKAIIQQFqNgIIIBBBAWshECANQQFqIQ0gE0EBaiETIBVBAWsiFQ0ACwsgESAPNgIIIBEgFzYCBCARQQRqEN47CyARQRBqJAAgFhCdGCAOQUBrJAAgCkECayEKIAEoAgghDSABKAIEIQ4LAkAgA0UNACADIA1PBEAgAyANRg0BDAYLIAMgDmosAABBv39MDQULIAMgDmogDSADa0GEkcQAQQMQ9C4NAwsgFEEIaiABIAIgAyALIAwQzhECQCAUKAIIIgJBAkYEQCAAIBQtAAw6AAQgARDeOwwBCyAUKQIMIRggFCgCFCELIAAgCjYCMCAAIAY2AiwgACAFNgIoIAAgBDYCJCAAIAM2AiAgACAJOwEeIAAgCDsBHCAAIAs2AgwgACAYNwIEIABBGGogAUEIaigCADYCACAAIAEpAgA3AhAgACAHKQAANwA0IABBPGogB0EIaikAADcAACAAQcQAaiAHQRBqLQAAOgAACyAAIAI2AgAgFEEgaiQADwsgCiANQdCQxAAQwyEACyAUQQA2AggjAEEQayIAJAAgAEHgkMQANgIMIAAgDzYCCEEAIABBCGpBmJzEACAAQQxqQZicxAAgFEEIakHokcQAEOYPAAtBh5HEAEHPAEHYkcQAEJ8pAAsgDiANIAMgDUH0kMQAEKM2AAsgDiANIAMgCkG8kMQAEKM2AAu7HgEQfyMAQfACayIZJAACQAJAIA0EQCAMIA1BAWtNDQEgDSEPIAshFQNAIBUoAgAgEmohEiAVQRBqIRUgD0EBayIPDQALCyAOQfgAaiEbIA5B2ABqIQ9BASEVAkAgCEEBRgRAIBlB2AFqIRYgDyEVIwBBsAhrIhEkAAJAAkACQCAOKAIEIhAgEkEJdkEBaiIUSQRAIA4oAgAhEiAQIBQgEBshDwNAIA8iE0EBdCEPIBMgFEkNAAsgEUEQaiAAIBMQuCkgESgCFCEPIBEoAhAhEyAQBH8gDyAQSQ0CIBMgECASIBBBvOzMABDVLCAOKAIAIRIgDigCBAVBAAshECAOIA82AgQgDiATNgIAIAAgEiAQEOA1CyAUIA4oAgwiEksEQCAOKAIIIRAgEiAUIBIbIQ8DQCAPIhNBAXQhDyATIBRJDQALIBFBCGogACATELkpIBIgESgCDCIPSw0CIBEoAgghEyASQQJ0IhIEQCATIBAgEvwKAAALIA4oAgwhEiAOIA82AgwgDigCCCAOIBM2AgggEhCAMQsgG0GBAiAUIBRBgQJPGyIPNgIAIA4gFDYCFCARQShqIhNBAEGECPwLACARQaPg//sHNgKsCCARQRxqIhQgEyAPEIEcIBEgFEHMgs4AEKIhIBEoAgAhDyAVKAIEIRMgFSARKAIEIhQ2AgQgFSgCACESIBUgDzYCACATBEAgEiATQYgIbEEEEPg6CyAUBEAgD0EAQYQI/AsAIA9Bo+D/+wc2AoQIIBZBCGpCADcCACAWQgA3AgAgFkEANgIsIBZCADcCJCAWQYAENgIgIBZBADYCHCAWQwAAyEM4AhggFkGABDYCFCAWQYACNgIQIBFBsAhqJAAMAwsMBgsgECAPQazszAAQsDsACyASIA9BzOzMABCwOwALQQAhFQwBCyAZQdgBaiEUIA8hEyMAQbAIayIWJAACQAJAAkACQCAIQQ5JBEAgCEUNAUGAAiAIQf//A3FuIRggDigCBCIQIBJBCXZBAWoiEkkEQCAOKAIAIRcgECASIBAbIQ8DQCAPIhFBAXQhDyARIBJJDQALIBZBEGogACARELgpIBYoAhQhDyAWKAIQIREgEAR/IA8gEEkNBCARIBAgFyAQQdjwzAAQ1SwgDigCACEXIA4oAgQFQQALIRAgDiAPNgIEIA4gETYCACAAIBcgEBDgNQsgDigCDCIQIBJPDQQgDigCCCEXIBAgEiAQGyEPA0AgDyIRQQF0IQ8gESASSQ0ACyAWQQhqIAAgERC5KSAWKAIMIQ8gFigCCCERIBAEfyAPIBBJDQQgEEECdCIQBEAgESAXIBD8CgAACyAOKAIIIRcgDigCDAVBAAshECAOIA82AgwgDiARNgIIIBcgEBCAMQwEC0Hs78wAQTxBqPDMABCfKQALQbjwzAAQ4isACyAQIA9ByPDMABCwOwALIBAgD0Ho8MwAELA7AAsgDiASNgIUIBsgGEEBaiIPIBIgDyASSRsgCGwiDzYCACAWQShqIhFBAEGECPwLACAWQaPg//sHNgKsCCAWQRxqIhIgESAPEIEcIBYgEkHMgs4AEKIhIBYoAgQhESAWKAIAIQ8gEygCBCISBEAgEygCACASQYgIbEEEEPg6CyATIBE2AgQgEyAPNgIAAkAgCCARTQRAIA8gCEGICGxqIRMDQCAPQQBBhAj8CwAgD0GECGpBo+D/+wc2AgAgD0GICGoiDyATRw0ACyAUQQBB8AD8CwAgFEEANgKUASAUQgA3AowBIBRBgAQ2AogBIBRBADYChAEgFEMAAMhDOAKAASAUQYAENgJ8IBQgGDYCeCAUIAg2AnQgFEGAAjYCcCAWQbAIaiQADAELIAggEUGs6swAELA7AAsLIBkgFTYCDCAZQRBqIhYgGUHYAWoiE0GYAfwKAAAgGUGoAWohEiAOQeAAaiEYIA5B/ABqIRwjAEGwFmsiESQAAkACQAJAIA5BGGoiHSIUKAIEIhcgDUEKdkEBaiIQSQRAIBQoAgAhGiAXIBAgFxshDwNAIA8iFUEBdCEPIBAgFUsNAAsgEUEQaiAAIBUQuCkgESgCFCEPIBEoAhAhFSAXBH8gDyAXSQ0CIBUgFyAaIBdBvOzMABDVLCAUKAIAIRogFCgCBAVBAAshFyAUIA82AgQgFCAVNgIAIAAgGiAXEOA1CyAQIBQoAgwiF0sEQCAUKAIIIRogFyAQIBcbIQ8DQCAPIhVBAXQhDyAQIBVLDQALIBFBCGogACAVELkpIBcgESgCDCIPSw0CIBEoAgghFSAXQQJ0IhcEQCAVIBogF/wKAAALIBQoAgwhFyAUIA82AgwgFCgCCCAUIBU2AgggFxCAMQsgHEGBAiAQIBBBgQJPGyIPNgIAIBQgEDYCFCARQShqIhVBAEGEFvwLACARQaPg//sHNgKsFiARQRxqIhQgFSAPEIQcIBEgFEHMgs4AEJwhIBEoAgAhDyAYKAIEIRUgGCARKAIEIhQ2AgQgGCgCACEQIBggDzYCACAVBEAgECAVQYgWbEEEEPg6CyAUBEAgD0EAQYQW/AsAIA9Bo+D/+wc2AoQWIBJBCGpCADcCACASQgA3AgAgEkEANgIsIBJCADcCJCASQYAINgIgIBJBADYCHCASQwAA+kM4AhggEkGACDYCFCASQcAFNgIQIBFBsBZqJAAMAwsMBAsgFyAPQazszAAQsDsACyAXIA9BzOzMABCwOwALIBMhFSAOQegAaiEXIA5BgAFqIRojAEGwEWsiESQAAkACQAJAIA5BMGoiFCgCBCIQIA1BCXZBAWoiEkkEQCAUKAIAIRggECASIBAbIQ8DQCAPIhNBAXQhDyASIBNLDQALIBFBEGogACATELgpIBEoAhQhDyARKAIQIRMgEAR/IA8gEEkNAiATIBAgGCAQQbzszAAQ1SwgFCgCACEYIBQoAgQFQQALIRAgFCAPNgIEIBQgEzYCACAAIBggEBDgNQsgEiAUKAIMIhBLBEAgFCgCCCEYIBAgEiAQGyEPA0AgDyITQQF0IQ8gEiATSw0ACyARQQhqIAAgExC5KSAQIBEoAgwiD0sNAiARKAIIIRMgEEECdCIQBEAgEyAYIBD8CgAACyAUKAIMIRAgFCAPNgIMIBQoAgggFCATNgIIIBAQgDELIBpBgQIgEiASQYECTxsiDzYCACAUIBI2AhQgEUEoaiITQQBBhBH8CwAgEUGj4P/7BzYCrBEgEUEcaiISIBMgDxCCHCARIBJBzILOABCgISARKAIAIQ8gFygCBCETIBcgESgCBCISNgIEIBcoAgAhECAXIA82AgAgEwRAIBAgE0GIEWxBBBD4OgsgEgRAIA9BAEGEEfwLACAPQaPg//sHNgKEESAVQQhqQgA3AgAgFUIANwIAIBVBADYCLCAVQgA3AiQgFUGABDYCICAVQQA2AhwgFUMAAMhCOAIYIBVBgAQ2AhQgFUHAADYCECARQbARaiQADAMLDAQLIBAgD0Gs7MwAELA7AAsgECAPQczszAAQsDsACwJAAkAgDQRAQQAhDyAHQf8BcSEQA0ACQAJAIAwgD0cEQCALIA9BBHRqIgcvAQ4hFyAHKAIEIRggBygCACESIA4oAmAhFSAHLwEMIR4CQCAZQagBaiIHKAIoIhMgDigCZCIRSQRAIBUgE0GIFmxqIB4QtykgByAHKAIkQQFqIhM2AiQgBygCICATRgRAIAcgHSAVIBEgHEEAEOgDCwwBCyATIBFBrO3MABDDIQALIBINAQwCCyAMIAxByPTMABDDIQALAkADQCADIARxIgcgAk8NASABIAdqLQAAIQcCQAJAIBkoAgxFBEAgDigCWCEGIBYoAigiFSAOKAJcIhNJBEAgBiAVQYgIbGogBxC2KSAWIBYoAiRBAWoiFTYCJCAWKAIgIBVGBEAgFiAOIAYgEyAbQQAQ5wMLDAILIBUgE0Gs7cwAEMMhAAsgCgJ/AkACQAJAAkAgEEEBaw4DAQIDAAsgBUE/cQwDCyAFQfwBcUECdgwCCyAGQf8BcUG0k+IAai0AACAFQf8BcUG0keIAai0AAHIMAQsgBkH/AXFBtJXiAGotAAAgBUH/AXFBtJXiAGotAABBA3RqC0H/AXEiBk0NASAOKAJYIRUCQCAJIAZBAnRqKAIAIBYoApABaiIGIA4oAlwiE0kEQCAVIAZBiAhsaiAHELYpIBYgFigCjAFBAWoiBjYCjAEgFigCiAEgBkYEQCAWIA4gFSATIBtBABDVAQsMAQsgBiATQfjwzAAQwyEACwsgA0EBaiEDIAUhBiAHIQUgEkEBayISRQ0DDAELCyAGIApBiPXMABDDIQALIAcgAkH49MwAEMMhAAsgAyAYQf///w9xIgdqIQMCQCAHRQ0AIANBAmsgBHEiBSACTw0DIANBAWsgBHEiByACTw0EIAEgBWotAAAhBiABIAdqLQAAIQUgHkH/AE0NACAOKAJoIRUgF0H/B3EhEgJAIBlB2AFqIgcoAigiEyAOKAJsIhFJBEAgFSATQYgRbGogEhC1KSAHIAcoAiRBAWoiEzYCJCAHKAIgIBNGBEAgByAUIBUgESAaQQAQ5gMLDAELIBMgEUGs7cwAEMMhAAsLIA9BAWoiDyANRw0ACwsgDigCXCEBIA4oAlghAgJAIBkoAgxBAUYEQCAWIA4gAiABIBtBARDVAQwBCyAWIA4gAiABIBtBARDnAwsgGUGoAWogHSAOKAJgIA4oAmQgHEEBEOgDIBlB2AFqIBQgDigCaCAOKAJsIBpBARDmAyAIQQFLBEBBACEGIwBBEGsiAyQAIA4gDigCECIHQQZ0IgE2AnAgA0EIaiAAIAEQuSkgDigCTCEBIAMoAgghACAOIAMoAgwiCzYCTCAOKAJIIA4gADYCSCABEIAxIAcEQEEAIQQDQCAEIAhsIQwgBEEBaiEEIAkhASAAIQJBACEFAkACQANAIAUgCkYNASALIAUgBmoiDUsEQCACIAEoAgAgDGo2AgAgAUEEaiEBIAJBBGohAiAFQQFqIgVBwABGDQMMAQsLIA0gC0H87MwAEMMhAAsgCiAKQezszAAQwyEACyAAQYACaiEAIAZBQGshBiAEIAdHDQALCyADQRBqJAALIBlB8AJqJAAPCyAFIAJB2PTMABDDIQALIAcgAkHo9MwAEMMhAAsgDCAMQZj1zAAQwyEAC0EAQQBB3OzMABDDIQALuAYCCn8BfiMAQTBrIgMkAEGAwAAhBgJAAkAgAigCACILIAIoAggiCWtBIE8EQCAJIQQMAQsgA0EQaiABIAIQkxMCQCADLQAQQQRGBEAgAygCFCEEDAELIAMpAxAiDUIgiKchBCANpyIFQf8BcUEERg0AIAAgBDYCBCAAIAU6AAAgAEEDaiAFQRh2OgAAIAAgBUEIdjsAAQwCCyAEBEAgAigCCCEEDAELIABBBDoAACAAQQA2AgQMAQsDQAJAIAQgAigCACIFRyAFIAtHcg0AIANBEGogASACEJMTAkAgAy0AEEEERgRAIAMoAhQhBQwBCyADKQMQIg1CIIinIQUgDaciBEH/AXFBBEYNACAAIAU2AgQgACAEOgAAIABBA2ogBEEYdjoAACAAIARBCHY7AAEMAwsgAigCCCEEIAUEQCACKAIAIQUMAQsgAEEEOgAAIAAgBCAJazYCBAwCCwJAAkACQAJAIAQgBUYEQCADQQhqIAIgBRC0ICADKAIIQYGAgIB4Rw0BIAIoAgAhBSACKAIIIQQLIAIoAgQhByADIAg2AhwgA0EANgIYIAMgBCAHajYCECADIAYgBSAEayIEIAQgBksbIgc2AhQgA0EgaiABIANBEGoQ5xQgAy0AICIEQQRHDQEMAgsgAEKBzAA3AgAMBAsDQEEAIQUCQAJAAkACQCAEQf8BcUEBaw4DAQIABgsgAygCJC0ACEEjRw0FDAILIAMtACFBI0YNAQwECyADKAIkLQAIQSNHDQMLIAMgAykDIDcDKCADQShqELkuIANBIGogASADQRBqEOcUIAMtACAiBEEERw0ACwtBASEFCyACIAMoAhgiCCACKAIIaiIENgIIIAMoAhwhCgJAIAUNACADKQMgIg2nIgVB/wFxQQRGDQAgACAFOgAAIABBB2ogDUI4iDwAACAAQQVqIA1CKIg9AAAgACANQgiIPgABDAILIAgEQCAHIAhHIAdBfyAGIAxBAWpBACAHIAhLGyIMQQFKGyAGIAcgCkcbIgZJckUEQEF/IAZBAXQgBkEASBshBgsgCiAIayEIDAEFIABBBDoAACAAIAQgCWs2AgQLCwsgA0EwaiQAC7kPAQl/IwBBkAFrIggkAAJAIAJB/////wNxIgNFDQACQAJAAkACQCACQeD/A3FBACACQYCA/P8DcSIEG0UEQCAERQ0EIAJBEHEhCSACQQ9xIQQgA0EQdkEBayIDIAAoAmQiAkkNASADIAAoAmwiASACaiIFSQ0CIAMgACgCdCICIAVqIgFJDQMgCEEgaiAAIAMgAWsgBEEBaiAJQQBHIAAoAnggACgCfBDGCyAIKAIkIQUgCCgCICEBDAULIAJBD3ZB//8BcRCyPSEJQREhAQJ/IAAoAkgiBEERTQRAIABBBGohByAEIQMgAEHIAGoMAQsgACgCBCEDIAAoAgghByAEIQEgAEEEagshBCABIANGBEAgABD8HyAAKAIEIQMgACgCCCEHIABBBGohBAsgAkH//wFxIQEgByADQQJ0aiAJNgIAIAQgBCgCAEEBajYCAAwECyAIQQhqIAAgAyAEQQJqIAlBAEcgACgCYCACEMYKIAgoAgwhBSAIKAIIIQEMAwsgCEEQaiAAIAMgAmsgBEEBaiAJQQBHIAAoAmggARDGCyAIKAIUIQUgCCgCECEBDAILIAhBGGogACADIAVrIARBAmogCUEARyAAKAJwIAIQxgogCCgCHCEFIAgoAhghAQwBCwJAIAFBgNgCayIEQaTXAE8EQCACQf//A3EiAUEBRw0BIAhB7gBqIgJB1I3IAEEi/AoAACAIQShqIgEgAhC9GiAAIAEQ7QtBtQwhAUERIQUMAgsgAEHIAGohAiAEQf//A3EiAUEccCEGIAQgAUHMBG4iCUHMBGxrQf//A3FBHG5B4SJqIQNBESEFAn8gACgCSCIBQRFNBEAgAEEEaiEHIAIhBCABDAELIABBBGohBCAAKAIIIQcgASEFIAAoAgQLIgEgBUYEfyAAEPwfIABBBGohBCAAKAIIIQcgACgCBAUgAQtBAnQgB2ogAzYCAEEBIQUgBCAEKAIAQQFqNgIAIAlBgCJyIQEgBkUNASAGQacjaiEJQREhBQJ/IAIoAgAiBEERTQRAIABBBGohAyAEDAELIABBBGohAiAAKAIIIQMgBCEFIAAoAgQLIQQgBCAFRgRAIAAQ/B8gACgCBCEEIAAoAgghAyAAQQRqIQILQQIhBSADIARBAnRqIAk2AgAgAiACKAIAQQFqNgIADAELQf3/AyABIAFBgLC/f3NBgJC8f0kbIQELIAUhCSMAQSBrIgokACAAIgZBBGohAiAAQcgAaiELA0ACQCAGKAJMIQMgBkGAgMQANgJMAkACQAJ/IANBgIDEAEcEQCAGKAJQDAELIApBEGogBhD2EiAKKAIQIgNBgIDEAEYNASAKKAIUCyIAQYD8//8DcUGAsANGDQEgBiAANgJQIAYgAzYCTAsgCkEIaiAGIAkQ1yQCQCAKKAIMIgNBAkkNACAGKAJcIQIgCigCCCEEIANBAnQhAEEAIQUDQCAEIAVqIAIQ2ykgACAFQQRqIgVHDQALIAogCkEfajYCGCADQRVPBEAgBCADIApBGGoQrxsMAQsgBCADEPYWCyAKQSBqJAAMAQsCfyAAQYCyA3FBgLIDRwRAIAMgABCjLwwBCwJ/AkACQAJAAkACQAJAAkACQAJAAkAgA0HyHkwEQCADQcAGaw4FAgUBAwQBCwJAIANB8x5rDgMGAQcACwJAIANBnv8Daw4CCQoACyADQYEfRg0HC0H9/wMQsj0MCQtBgAZB5gEQ/DoMCAtBkwZB5gEQ/DoMBwtBiAZB5gEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAC0GBBkHmARD8OgwFC0HxHkGBARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgBB8h5BggEQ/DoMBAtB8R5BgQEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAQfQeQYQBEPw6DAMLQfEeQYEBEPw6IQcCfyALKAIAIgRBEkkEQCAEIQMgAiEFQREhBCALDAELIAYoAgQhAyAGKAIIIQUgAgshACADIARGBEAgBhD8HyAGKAIEIQMgBigCCCEFIAIhAAsgBSADQQJ0aiAHNgIAIAAgACgCAEEBajYCAEGAH0GCARD8OgwCC0GZ4QBBCBD8OgwBC0Ga4QBBCBD8OgsLIQcCfyALKAIAIgRBEkkEQCAEIQAgAiEFQREhBCALDAELIAYoAgQhACAGKAIIIQUgAgshAyAAIARGBH8gBhD8HyAGKAIIIQUgAiEDIAYoAgQFIAALQQJ0IAVqIAc2AgAgAyADKAIAQQFqNgIADAELCyAIQZABaiQAIAELuQ8BCX8jAEGQAWsiCCQAAkAgAkH/////A3EiA0UNAAJAAkACQAJAIAJB4P8DcUEAIAJBgID8/wNxIgQbRQRAIARFDQQgAkEQcSEJIAJBD3EhBCADQRB2QQFrIgMgACgCZCICSQ0BIAMgACgCbCIBIAJqIgVJDQIgAyAAKAJ0IgIgBWoiAUkNAyAIQSBqIAAgAyABayAEQQFqIAlBAEcgACgCeCAAKAJ8EMYLIAgoAiQhBSAIKAIgIQEMBQsgAkEPdkH//wFxELI9IQlBESEBAn8gACgCSCIEQRFNBEAgAEEEaiEHIAQhAyAAQcgAagwBCyAAKAIEIQMgACgCCCEHIAQhASAAQQRqCyEEIAEgA0YEQCAAEPwfIAAoAgQhAyAAKAIIIQcgAEEEaiEECyACQf//AXEhASAHIANBAnRqIAk2AgAgBCAEKAIAQQFqNgIADAQLIAhBCGogACADIARBAmogCUEARyAAKAJgIAIQxgogCCgCDCEFIAgoAgghAQwDCyAIQRBqIAAgAyACayAEQQFqIAlBAEcgACgCaCABEMYLIAgoAhQhBSAIKAIQIQEMAgsgCEEYaiAAIAMgBWsgBEECaiAJQQBHIAAoAnAgAhDGCiAIKAIcIQUgCCgCGCEBDAELAkAgAUGA2AJrIgRBpNcATwRAIAJB//8DcSIBQQFHDQEgCEHuAGoiAkHUjcgAQSL8CgAAIAhBKGoiASACEL0aIAAgARDtC0G1DCEBQREhBQwCCyAAQcgAaiECIARB//8DcSIBQRxwIQYgBCABQcwEbiIJQcwEbGtB//8DcUEcbkHhImohA0ERIQUCfyAAKAJIIgFBEU0EQCAAQQRqIQcgAiEEIAEMAQsgAEEEaiEEIAAoAgghByABIQUgACgCBAsiASAFRgR/IAAQ/B8gAEEEaiEEIAAoAgghByAAKAIEBSABC0ECdCAHaiADNgIAQQEhBSAEIAQoAgBBAWo2AgAgCUGAInIhASAGRQ0BIAZBpyNqIQlBESEFAn8gAigCACIEQRFNBEAgAEEEaiEDIAQMAQsgAEEEaiECIAAoAgghAyAEIQUgACgCBAshBCAEIAVGBEAgABD8HyAAKAIEIQQgACgCCCEDIABBBGohAgtBAiEFIAMgBEECdGogCTYCACACIAIoAgBBAWo2AgAMAQtB/f8DIAEgAUGAsL9/c0GAkLx/SRshAQsgBSEJIwBBIGsiCiQAIAAiBkEEaiECIABByABqIQsDQAJAIAYoAkwhAyAGQYCAxAA2AkwCQAJAAn8gA0GAgMQARwRAIAYoAlAMAQsgCkEQaiAGEIUKIAooAhAiA0GAgMQARg0BIAooAhQLIgBBgPz//wNxQYCwA0YNASAGIAA2AlAgBiADNgJMCyAKQQhqIAYgCRDXJAJAIAooAgwiA0ECSQ0AIAYoAlwhAiAKKAIIIQQgA0ECdCEAQQAhBQNAIAQgBWogAhDbKSAAIAVBBGoiBUcNAAsgCiAKQR9qNgIYIANBFU8EQCAEIAMgCkEYahCvGwwBCyAEIAMQ9hYLIApBIGokAAwBCwJ/IABBgLIDcUGAsgNHBEAgAyAAEKMvDAELAn8CQAJAAkACQAJAAkACQAJAAkACQCADQfIeTARAIANBwAZrDgUCBQEDBAELAkAgA0HzHmsOAwYBBwALAkAgA0Ge/wNrDgIJCgALIANBgR9GDQcLQf3/AxCyPQwJC0GABkHmARD8OgwIC0GTBkHmARD8OgwHC0GIBkHmARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgALQYEGQeYBEPw6DAULQfEeQYEBEPw6IQcCfyALKAIAIgRBEkkEQCAEIQMgAiEFQREhBCALDAELIAYoAgQhAyAGKAIIIQUgAgshACADIARGBEAgBhD8HyAGKAIEIQMgBigCCCEFIAIhAAsgBSADQQJ0aiAHNgIAIAAgACgCAEEBajYCAEHyHkGCARD8OgwEC0HxHkGBARD8OiEHAn8gCygCACIEQRJJBEAgBCEDIAIhBUERIQQgCwwBCyAGKAIEIQMgBigCCCEFIAILIQAgAyAERgRAIAYQ/B8gBigCBCEDIAYoAgghBSACIQALIAUgA0ECdGogBzYCACAAIAAoAgBBAWo2AgBB9B5BhAEQ/DoMAwtB8R5BgQEQ/DohBwJ/IAsoAgAiBEESSQRAIAQhAyACIQVBESEEIAsMAQsgBigCBCEDIAYoAgghBSACCyEAIAMgBEYEQCAGEPwfIAYoAgQhAyAGKAIIIQUgAiEACyAFIANBAnRqIAc2AgAgACAAKAIAQQFqNgIAQYAfQYIBEPw6DAILQZnhAEEIEPw6DAELQZrhAEEIEPw6CwshBwJ/IAsoAgAiBEESSQRAIAQhACACIQVBESEEIAsMAQsgBigCBCEAIAYoAgghBSACCyEDIAAgBEYEfyAGEPwfIAYoAgghBSACIQMgBigCBAUgAAtBAnQgBWogBzYCACADIAMoAgBBAWo2AgAMAQsLIAhBkAFqJAAgAQvPBgEIfwJAAkAgASAAQQNqQXxxIgMgAGsiCEkNACABIAhrIgZBBEkNACAGQQNxIQdBACEBAkAgACADRiIJDQACQCAAIANrIgVBfEsEQEEAIQMMAQtBACEDA0AgASAAIANqIgIsAABBv39KaiACQQFqLAAAQb9/SmogAkECaiwAAEG/f0pqIAJBA2osAABBv39KaiEBIANBBGoiAw0ACwsgCQ0AIAAgA2ohAgNAIAEgAiwAAEG/f0pqIQEgAkEBaiECIAVBAWoiBQ0ACwsgACAIaiEAAkAgB0UNACAAIAZBfHFqIgMsAABBv39KIQQgB0EBRg0AIAQgAywAAUG/f0pqIQQgB0ECRg0AIAQgAywAAkG/f0pqIQQLIAZBAnYhBSABIARqIQQDQCAAIQMgBUUNAkHAASAFIAVBwAFPGyIGQQNxIQcgBkECdCEIQQAhAiAFQQRPBEAgACAIQfAHcWohCSAAIQEDQCABKAIAIgBBf3NBB3YgAEEGdnJBgYKECHEgAmogAUEEaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQhqKAIAIgBBf3NBB3YgAEEGdnJBgYKECHFqIAFBDGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWohAiABQRBqIgEgCUcNAAsLIAUgBmshBSADIAhqIQAgAkEIdkH/gfwHcSACQf+B/AdxakGBgARsQRB2IARqIQQgB0UNAAsCfyADIAZB/AFxQQJ0aiIAKAIAIgFBf3NBB3YgAUEGdnJBgYKECHEiASAHQQFGDQAaIAEgACgCBCIBQX9zQQd2IAFBBnZyQYGChAhxaiIBIAdBAkYNABogACgCCCIAQX9zQQd2IABBBnZyQYGChAhxIAFqCyIBQQh2Qf+BHHEgAUH/gfwHcWpBgYAEbEEQdiAEag8LIAFFBEBBAA8LIAFBA3EhAwJAIAFBBEkEQAwBCyABQXxxIQUDQCAEIAAgAmoiASwAAEG/f0pqIAFBAWosAABBv39KaiABQQJqLAAAQb9/SmogAUEDaiwAAEG/f0pqIQQgBSACQQRqIgJHDQALCyADRQ0AIAAgAmohAQNAIAQgASwAAEG/f0pqIQQgAUEBaiEBIANBAWsiAw0ACwsgBAv+DAIEfgh/IwBB4AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUHoAGpBK0EAQQFBARCgGCAFKAJsIQMgBSgCaEEBRg0BIAUoAnAiAUGYqs4AQSv8CgAAIABBKzYCDCAAIAE2AgggACADNgIEIABBADYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIARB/wFxQQdHBEAgBUEBNgJsIAVByKnOADYCaCAFQgE3AnQgBUGuAzYCFCAFIAVBEGo2AnAgBSAFQQ9qNgIQIABBBGogBUHoAGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAVB1AFqQgA3AgAgBUHIAWoiCyACQQxqKAIANgIAIAVCADcCzAEgBSACKQIENwPAASACKAIAIQQgBUEAOgBgIAVCgICAgBA3A1AgBUIANwNYIAVCAjcDEEHAAEEIEK02IgJFDQEgAiAENgIAIAIgBSkDwAE3AgQgAiAMNgI4IAJBADYCNCACIAM2AjAgAkEANgIgIAJBDGogCykDADcCACACQRRqIAVB0AFqKQMANwIAIAJBHGogBUHYAWooAgA2AgAgBUHoAGohCyMAQSBrIgokACAKQdCpzgA2AgQgCiACNgIAAkAgAkHoqc4AKAIAEQQAIgwgBUEQaiIEKAJIIgNNBEAgBCAMNgJIDAELIARBQGsgDCADaxCGHCAEKAJIIQwLIApBCGogAiAEKAJEIAxB4KnOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAmgiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCqCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQfSpzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFB9KnOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAmw3AgQgAEEUaiAFQfwAaigCADYCACAAQQxqIAVB9ABqKQIANwIAIAAgAjYCACAFQRBqEJouDAMLIAMgBSgCcEHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQeABaiQAC+QKAQ5/IwBB8ABrIgMkACMAQTBrIgIkACAAQQQgACgCNCIHIAdBBE0bNgI0IABBMGohBwJAQQAgACgCMCIFa0EDcSIEIAAoAgggBWtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAHIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAHQQQQjTcgAkEQaiAAENw7IAIoAhQhBCACKAIQIQUgAkEIaiAAKAIwEIw3IAIgBSAEIAIoAgggAigCDEHg/f4AENcmIAIoAgRBA00EQCACQQA2AiggAkEBNgIcIAJByP7+ADYCGCACQgQ3AiAgAkEYakHw/f4AEO8sAAsgAigCAEHw4cOHfzYAACAHKAIAIQcgAkEwaiQAIAAoAhQiBQR/IAAoAhAiAi8BBCEEIAVBAUcEQCACQQxqIQIgBUEBa0H/////AXEhBQNAIAIvAQAiBiAEQf//A3EiBCAEIAZJGyEEIAJBCGohAiAFQQFrIgUNAAsLIARB//8DcUECagVBBAsiBSAAKAIIIAAoAjBrIgJNIAIgBU9yRQRAA0AgABD7FiAAKAIIIAAoAjBrIAVJDQALCyAAQTBqIgogBRCNNyAAKAIwIQkgA0HYAGogABDcOyADQdAAaiADKAJYIAMoAlwgCSAJIAVrIgxBqPz+ABDXJgJAAkACQAJAAkAgAygCVCIGQQFLBEAgAygCUCIIIAU7AAAgBkEDTQ0BIAggByABazsAAiAAKAIUIgEEQCAAKAIQIQIgAUEDdCEEA0AgAkEEai8BACIBQQJqIgsgBksNBCABIAhqIAcgAigCAGs7AAAgAkEIaiECIARBCGsiBA0ACwsgA0HIAGogABDcOyADQUBrIAMoAkggAygCTCAJIAxBuPz+ABDXJiAAKAIcIQFBACECIAMoAkQhBiADKAJAIQgCQAJAAkACQAJAIAAoAiAiBA4CAgEACwNAIAAoAgghCyABIARBAXYiDSACaiIOQQJ0aigCACEPIANBOGogABDcOyADIAsgD2s2AmwgAyADKQM4NwJkIANBMGogA0HkAGoQ8CAgAiAOIAggBiADKAIwIAMoAjQQlCxB/wFxQQFGGyECIAQgDWsiBEEBSw0ACwsgACgCCCEEIAEgAkECdGooAgAhASADQShqIAAQ3DsgAyAEIAFrNgJsIAMgAykDKDcCZCADQSBqIANB5ABqEPAgIAggBiADKAIgIAMoAiQQlCxB/wFxIgFFDQEgAiABQf8BRmohBAsgCigCACEFAkAgBCAAQRhqIgIoAggiAU0EQCACKAIAIAFGBEAgAkHo/P4AEJ0oCyACKAIEIARBAnRqIQYCQCABIARNDQAgASAEa0ECdCIERQ0AIAZBBGogBiAE/AoAAAsgBiAFNgIAIAIgAUEBajYCCAwBCyAEIAFB6Pz+ABDCIQALDAELIANBGGogABDcOyADQRBqIAMoAhggAygCHCAJIAxByPz+ABDXJiADKAIUIgEEQCADKAIQQQAgAfwLAAsgCiAKKAIAIAVrNgIAIAIgACgCICIBTw0EIAAoAhwgAkECdGooAgAhBQsgACgCCCADQQhqIAAQ3DsgB2siAUEEaiECIAFBe0sNBCACIAMoAgwiBEsNBSADKAIIIAFqIAUgB2s2AAAgAEEANgIUIANB8ABqJAAgBw8LQQIgBkGY/P4AELA7AAtBBCAGQYj8/gAQsDsACyALIAZB+Pv+ABCwOwALIAIgAUHY/P4AEMMhAAsgASACQfj8/gAQsTsACyACIARB+Pz+ABCwOwALuSICHX8CfiMAQeABayIFJAAgBUEANgIMIAVCgICAgBA3AgQgASgCDCEGIAVBzAFqIgIQvS8gBUH4AGoiByAFQQRqIgMgBkEIaiACEKoVIAFBDGohEQJAIAUoAqABIgZBgICAgHhGBEAgBUHgAGogBUGIAWoiBigCACICNgIAIAVB2ABqIAVBgAFqIgQpAwAiHzcDACAFIAUpA3giIDcDUCAGIAI2AgAgBCAfNwMAIAUgIDcDeCAHENQZIQYgAEGAgICAeDYCACAAIAY2AgQgAxDeOyARKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAREPgjCyABEN4jIAFBBEEUEOAeDAELIAVB0ABqIgIgBUH4AGpBKPwKAAAgBUHMAGogBUG0AWooAgA2AgAgBUHEAGogBUGsAWopAgA3AgAgBSAFKQKkATcCPCAFQRBqIAJBKPwKAAAgBSAGNgI4IAEoAgghBiABKAIEIQ0gBSABKAIANgLEASAFIA02AsABIAUgDTYCvAEgBSANIAZBFGxqIhQ2AsgBIAVBOGohGAJAAkACQCAGBEAgBUHQAWoiGkEIaiEbA0ACQAJAIA0oAgAiAUGAgICAeEcEQCAFIAE2AswBIBogDUEEaikCADcCACAbIA1BDGopAgA3AgAgBUHQAGohDCAFQcwBaiIcIQYjAEHwAGsiByQAAkACQAJAIAVBEGoiAS0APEUEQCAHQSBqIQsgAUEIaiESQQAhBEEAIQhCACEfQQAhE0EAIRUjAEGgAmsiAiQAIAIgBhDxLSIWNgI4IAJBMGogFkEIaiIdEMM0IAIoAjQhAyACIAIoAjAiCTYC5AEgAkEANgLUASACQQA2AsQBIAIgCSADQQJ0ajYC6AEgAkHYAGohDyMAQUBqIgokAAJ/IAJBxAFqIgMoAgAEQCADKAIEIQggAygCDCEEQQAMAQtBAQshCQNAAkACQAJAAkACfwJAIAlFBEAgBCAIRw0BIAMQ3isgA0EANgIAQQEhCQwHCwJAIAMoAiAiBEUNACAEIAMoAiRGDQAgAyAEQQRqNgIgIApBGGogBCgCAEEIahCDFSAKKAIYIglBgICAgHhGDQAgCigCHCIIIAooAiBBAnRqIQQgAygCAARAIAMQ3isLIAMgBDYCDCADIAk2AgggAyAINgIEIAMgCDYCAAwFCwJAIAMoAhAEQCADKAIUIgQgAygCHCIIRw0BIANBEGoiBBDeKyAEQQA2AgALIA9BADYCCCAPQoCAgIDAADcCACADEOYtDAMLIAMgBEEEaiIONgIUIAMoAgwgAygCBGtBAnZBACADKAIAGyEJIAggDmtBAnYhDiAEKAIADAELIAMgCEEEaiIJNgIEIAMoAhwgAygCFGtBAnZBACADKAIQGyEOIAQgCWtBAnYhCSAIKAIACyEQIApBGGoiBEEDIAkgDmoiCCAIQQNNG0EBakEAQQRBBBCgGCAKKAIcIQggCigCGEEBRg0BIAooAiAiCSAQNgIAIApBFGoiHkEBNgIAIAogCTYCECAKIAg2AgwgBCADQSj8CgAAIApBDGohDkEAIQgjAEEQayIQJAAgBEEQaiEXA0ACQAJ/IAQoAgAEQCAEKAIEIQggBCgCDCETQQAMAQtBAQshCQNAAkACQAJAIAlFBEAgCCATRw0BIAQQ3isgBEEANgIAQQEhCQwECwJAIAQoAiAiCUUNACAJIAQoAiRGDQAgBCAJQQRqNgIgIBBBBGogCSgCAEEIahCDFSAQKAIEIglBgICAgHhGDQAgECgCCCIIIBAoAgxBAnRqIRMgBCgCAARAIAQQ3isLIAQgEzYCDCAEIAk2AgggBCAINgIEIAQgCDYCAAwCCwJAIBcoAgAEQCAEKAIUIgkgBCgCHEcNASAXEN4rIBdBADYCAAsgBBDmLSAQQRBqJAAMBQsgBCAJQQRqNgIUIAkoAgAhCQwCCyAEIAhBBGo2AgQgCCgCACEJDAELQQAhCQwBCwsgDigCCCIZIA4oAgBGBEAgDiAEKAIcIAQoAhRrQQJ2QQAgBCgCEBsgBCgCDCAEKAIEa0ECdkEBakEBIAQoAgAbahCALgsgDigCBCAZQQJ0aiAJNgIAIA4gGUEBajYCCAwBCwsgD0EIaiAeKAIANgIAIA8gCikCDDcCAAsgCkFAayQADAILIAggCigCIEHYyP4AEP0vAAtBACEJDAELCyADIAIoAmBBAEEEQRgQoBggAigCyAEhBAJAAkACQAJAIAIoAsQBQQFHBEAgAkEANgJEIAIgAigCzAE2AkAgAiAENgI8IA8Q6TsgAyASQSBqEKUdIAIgAigCxAE2AlAgAiACKALIASIDNgJIIAIgAzYCTCACIAMgAigCzAFBA3RqNgJUIAJBKGogHRDDNCACKAIsIgMEQCACKAIoIQQgA0ECdCEJQQAhAwNAIAYgAxCPLSEIIAJBxAFqIAQoAgBBCGogCCACQTxqIBIgASACQcgAahDKAyACKALEASIIQZOAgIB4RwRAIAsgAikCyAE3AgggC0EQaiACQdABaikCADcCACALIAg2AgQMBgsgBEEEaiEEIANBAWohAyAJQQRrIgkNAAsLIAJB2ABqEIYgIAJBADYCnAEgAkKAgICAEDcClAEgAkEANgKoASACQoCAgIAQNwKgASACQQA2ArQBIAJCgICAgBA3AqwBAkACQAJAAkAgAS0AACIJRQRAQQIhCAwBCyABLQABIQMgAiACKAKIASIINgLIASACIAJB2ABqIgo2AsQBIAJBAToAkAEgAkHEAWoiBBC7ESAEIAMQhxEgCiAIENgHIRIgAkEANgJsIAJBADoAkAEgBCADEOIbQQIhCAJAIAIoAsQBIgNB7f///wdqDgIAAQILIAItAMgBIQgLIAJBADYCwAEgAkKAgICAgAE3ArgBIAJBIGogBhDcOyACKAIkIgMEQCACKAIgIQQgA0EDdCEDA0AgAkHEAWoiCiAEEMMtIAJBiAJqIAogAkGgAWogAkGsAWogAkGUAWogHyAEEPQtIAQQ+C0gCCABEJgBIAIoAogCBEAgAikDkAIiH6ciBEEIdiEJIB9CIIinIQYgAikDmAIhHyACKAKMAiEDIAoQ/iYgAkG4AWoQ4zwMBAsgBEEIaiEEIAIpA5ACIR8gAkG4AWogAkHEAWoiChCpGCAKEP4mIANBCGsiAw0ACwsgAigCtAEiAyABLQAGQQFrQf8BcSIEaiAEQX9zcSADayIDQcEATw0EIAJBrAFqQfzM/gAgAxChNiACQdgAaiIDIAIoAqQBIAIoAqgBENUQIQggAyACKAKYASACKAKcARDVECEKIAIoAsABIgQEQCADIAIoArwBIAQQsg0hFQsgAkEBOgCQASACIAIoAogBIgM2AsgBIAIgAkHYAGoiDzYCxAEgD0EEIAY1AhAQyw4gAkHEAWoiBiAKEPEOIAYgCBDwDiAJBEAgBiASEPIOCyAEBEAgAkHEAWogFRDzDgsgAkHYAGoiBiADENgHIQQgAkEANgJsIAJBAToAkAEgAiACKAKIASIINgKMAiACIAY2AogCIAJBiAJqIgMgAS8BAhDEDiADQQMQnxIgBkEKIAI1ArQBEMsOIAMgBBDwDiAGIAgQ2AchAyACQQA2AmwgAkEAOgCQASAGIAMQpAwgAkEYaiAGENw7IAIoAhwhBiACKAIYIQMgAkEQaiACKAKIARCMNyACQQhqIAMgBiACKAIQIAIoAhRB5Mb+ABDXJiACKAIIIQYgAkHEAWogAigCDCIEQQBBAUEBEKAYIAIoAsgBIQggAigCxAFBAUYNBSACKALMASEDIAQEQCADIAYgBPwKAAALIARBCHYhCSACKQKwASEfIAIoAqwBIQYgAkG4AWoQ4zwMAgsgAi8AyQEgAkHLAWotAABBEHRyIQkgAikC0AEhHyACKALMASEGIAItAMgBIQQLIAJBrAFqEN47QYCAgIB4IQgLIAJBoAFqQQFBEBDgHiACQZQBakEBQRAQ4B4gBK1C/wGDIAmtQv///weDQgiGhCAGrUIghoQhICACQdgAahDMKiAIQYCAgIB4RgRAIAsgHzcCECALICA3AgggCyADNgIEDAQLIAsgAikCPDcCACALIB83AhwgCyAgNwIUIAsgAzYCECALIAg2AgwgC0EIaiACQcQAaigCADYCACACIAIoAkg2AsgBIAIgAigCUDYCxAEgAkHEAWoQ4zwMBAsgBCACKALMAUHczP4AEP0vAAsgA0HAAEG8zf4AELA7AAsgCCACKALMAUGoyf4AEP0vAAsgC0GAgICAeDYCACACIAIoAkg2AsgBIAIgAigCUDYCxAEgAkHEAWoQ4zwgAkE8aiIEIgYoAggiAwRAIAYoAgQhBgNAIAYQ3jsgBkEMahDeOyAGQRhqIQYgA0EBayIDDQALCyAEQQRBGBDgHgsgFiAWKAIAIgZBAWs2AgAgBkEBRgRAIAJBOGoQ+CMLIAJBoAJqJAACQAJAIAcoAiAiBEGAgICAeEcEQCAHKAIkIQYgBygCKCEDIAdBGGoiCCAHQTxqKQIANwMAIAdBEGogB0E0aikCADcDACAHIAcpAiw3AwggByAGIANBGGxqIgI2AmggByAENgJkIAcgBjYCYCAHIAY2AlwgA0UNAiABQThqIQQgB0HIAGoiA0EIaiEJIANBEGohCgNAAkAgBigCACILQYCAgIB4RwRAIAMgBkEEaikCADcCACAJIAZBDGopAgA3AgAgCiAGQRRqKAIANgIAIAcgCzYCRCAHQSBqIAQgB0HEAGogARDaCiAHKAIgIgtBk4CAgHhGDQEgByAGQRhqNgJgIAcpAiQhHyAMIAcpAiw3AgwgDCAfNwIEIAwgCzYCACAHQdwAahCAHyAHQQhqEN47IAdBFGoQ3jsMBwsgBkEYaiECDAMLIAZBGGoiBiACRw0ACwwBCyAHQRhqIAdBNGooAgA2AgAgB0EQaiAHQSxqKQIANwMAIAcgBykCJDcDCEG8vswAQcEAIAdBCGpB8LjMAEGAv8wAENUeAAsgByACNgJgCyAHQdwAaiIGEIAfIAdBMGogCCkDADcDACAHQShqIAdBEGopAwA3AwAgByAHKQMINwMgIAYgAUE4aiAHQSBqIAEQ2gogBygCXCIBQZOAgIB4RwRAIAcpAmAhHyAMIAcpAmg3AgwgDCAfNwIEIAwgATYCAAwCCyAMQZOAgIB4NgIADAELIAdBIGpBOkEAQQFBARCgGCAHKAIkIQEgBygCIEEBRg0BIAcoAigiBkGQv8wAQTr8CgAAIAxBOjYCDCAMIAY2AgggDCABNgIEIAxBjICAgHg2AgALIAdB8ABqJAAMAQsgASAHKAIoQey7zAAQ/S8ACyAFKAJQIgFBk4CAgHhGDQEgBSANQRRqNgLAASAFQYQBaiAFQdwAaikCADcCACAFIAUpAlQ3AnwgBSABNgJ4IAVB+ABqENQZIQEgAEGAgICAeDYCACAAIAE2AgQgHBDpKyAFQbwBahDlIAwFCyANQRRqIRQMAQsgBUHMAWoQ6SsgDUEUaiINIBRHDQELCyAFIBQ2AsABCyAFQbwBahDlICAFQdAAaiAFQRBqEKsVIAUoAlAiAUGTgICAeEYNASAFQYQBaiAFQdwAaikCADcCACAFIAUpAlQ3AnwgBSABNgJ4IAVB+ABqENQZIQEgAEGAgICAeDYCACAAIAE2AgQLIAVBGGoQ7SYgGBDjPCAFQQRqEN47IBEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRg0BDAILIAVBGGoQ7SYgGBDjPCAAQQhqIAVBDGooAgA2AgAgACAFKQIENwIAIBEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRw0BCyAREPgjCyAFQeABaiQAC/ENAgl/AX4jAEEQayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0ECTQRAIAEgA0ECdGooAhAhDSALQQA2AgQgDUECSQ0LIANBuAhsIQYgAEUEQCABKAIEIgkgBkkNAiABKAIAIAIpAwAhDyACKAIIIgdBME8EQCACKAIMIgBBCGohCiAAQXdLDQQgBSAKSQ0FIAIgAEEGajYCDCACIAIoAhBBBms2AhAgAiAAIARqIgA1AABCEIYgD0IwiIQgADEABEIwhoQgADEABUI4hoQiDzcDACAHQTBzIQcLIA8gB0E/ca2IpyIOQf8BcSIIIAkgBmsiCU8NBSAGQQJ0aiIMIAhBAnRqIgAvAQAhCiAALQACIgBBCEsEQCAAQQhrQf8BcSIAQSFPDQcgCCAKaiAAQQJ0Qfic8wBqKAIAIA5BCHZxaiIAIAlPDQggB0EIaiEHIAwgAEECdGoiCi0AAiEAIAovAQAhCgsgAiAHIABB/wFxajYCCCABKAIMIgAgBkkNCCABIANBAnRqAn8gASgCCCAGQQJ0aiEMIAAgBmshByACKQMAIQ8CQAJAAkACQAJAAkACQAJAAkAgAigCCCIAQTBPBEAgAigCDCIGQQhqIQggBkF3Sw0BIAUgCEkNGCACIAZBBmo2AgwgAiACKAIQQQZrNgIQIAIgBCAGaiIGNQAAQhCGIA9CMIiEIAYxAARCMIaEIAYxAAVCOIaEIg83AwAgAEEwcyEACyAPIABBP3GtiKciDkH/AXEiCCAHTw0BIAwgCEECdGoiCS8BACEGIAktAAIiCUEISwRAIAlBCGtB/wFxIglBIU8NAyAGIAhqIAlBAnRB+JzzAGooAgAgDkEIdnFqIgYgB08NBCAMIAZBAnRqIgYtAAIhCSAGLwEAIQYgAEEIaiEACyAGQRlNBEAgBkECdCIGQdCh8wBqLwEAIQwCfgJ/AkAgBkHSofMAai0AACIGQQlJIAAgCWoiAEE4T3FFBEAgBkERSSAAQTBPcQ0BIABBH0sEQCACKAIMIghBBGohByAIQXtLDQwgBSAHSQ0NIAIgBzYCDCACIAIoAhBBBGs2AhAgAiAEIAhqNQAAQiCGIA9CIIiEIg83AwAgAEEgcyEACyAGQSFPDQ0gDyAAQT9xrYgMAwsgAigCDCIHQQhqIQggB0F3Sw0IIAUgCEkNGyACIAdBB2o2AgwgAiACKAIQQQdrNgIQIAQgB2oiBDUAAEIIhiAPQjiIhCAEMQAEQiiGhCAEMQAFQjCGhCAEMQAGQjiGhCEPIABBOHMMAQsgAigCDCIHQQhqIQggB0F3Sw0IIAUgCEkNGiACIAdBBmo2AgwgAiACKAIQQQZrNgIQIAQgB2oiBDUAAEIQhiAPQjCIhCAEMQAEQjCGhCAEMQAFQjiGhCEPIABBMHMLIQAgAiAPNwMAIA8gAEE/ca2ICyEPIAIgACAGajYCCCAGQQJ0Qfic8wBqKAIAIA+ncSAMagwKCyAGQRpBwKHzABDDIQALIAYgCEGcnvMAELE7AAsgCCAHQaye8wAQwyEACyAJQSFB/J3zABDDIQALIAYgB0G8nvMAEMMhAAsgByAIQZye8wAQsTsACyAHIAhBnJ7zABCxOwALIAggB0GMnvMAELE7AAsgByAFQYye8wAQsDsACyAGQSFB/J3zABDDIQALNgIgIAohAgwLCyABKAIEIgAgBkkNCCACKAIQIQogAigCDCEIIAIoAgghCSACKQMAIQ8gASgCACAGQQJ0aiAAIAZrIAIgC0EEaiAEIAUQnxNFDQsgC0EANgIIIAEoAgwiACAGSQ0JAn8gAS0ARARAQQEhACABKAIcDAELIAEoAgggC0EANgIMIAZBAnRqIAAgBmsgAiALQQxqIAQgBRCfEyEAIAsoAgxBACAAGwshBiABIAIgC0EIaiAAIAYgBCAFENQbRQRAIAIgCjYCECACIAg2AgwgAiAJNgIIIAIgDzcDAEEAIQcgAUEAOgBEDAwLIAEgA0ECdGogCygCCDYCICALKAIEIQIMCgsgA0EDQYSk8wAQwyEACyAGIAlBlKTzABCvOwALIAAgCkGcnvMAELE7AAsgCiAFQZye8wAQsDsACyAIIAlBrJ7zABDDIQALIABBIUH8nfMAEMMhAAsgACAJQbye8wAQwyEACyAGIABBpKTzABCvOwALIAYgAEG0pPMAEK87AAsgBiAAQcSk8wAQrzsACyABIANBA3RqQSxqIQACfwJAAkACQCACDgICAAELIAAoAgRBAWoMAgsgAkECawwBCyAAKAIACyEBIAAgACgCBDYCACAAIAEgDUEAIAEgDU8bazYCBEEBIQcLIAtBEGokACAHDwsgCCAFQZye8wAQsDsAC5QIAgJ/AX4jAEEQayIGJAACQCAAIAQQqCggBEcEQEG4fyEFDAELIAAgASACEIopIAAgACkD8OkBIAStfDcD8OkBQX8hBQJAAkACQAJAAkACQAJAAkAgACgChOoBDggAAQIDAwQFBggLAkAgACgC7OoBIgENACADKAAAQXBxQdDUtMIBRw0AIAQEQCAAQaDsBWogAyAE/AoAAAsgAEEGNgKE6gEgAEEIIARrNgK86QFBACEFDAgLIAAgAyAEIAEQsSAiBTYC6OoBIAVBiH9LDQcgBARAIABBoOwFaiADIAT8CgAACyAAQQE2AoTqASAAIAUgBGs2ArzpAUEAIQUMBwsgAEGg7AVqIQEgACgC6OoBIQIgBARAIAEgAiAEa2ogAyAE/AoAAAsgACABIAIQkBciBUGIf0sNBiAAQQI2AoTqASAAQQM2ArzpAUEAIQUMBgsgA0EDIAZBBGoQlCMiAUGIf0sEQCABIQUMBgtBbCEFIAEgACgC0OkBSw0FIAAgATYCvOkBIAAgBigCBDYCgOoBIAAgBigCDDYCjOsBIAYoAgghAiAAAn9BBEEDIAIbIAENABogAgRAIAAoAuDpAQRAIABBBDYCvOkBQQUMAgsgAEEANgK86QFBAAwBCyAAQQM2ArzpAUECCzYChOoBQQAhBQwFC0FsIQUCQAJ/AkACQAJAIAAoAoDqAQ4DAQIACQsgACABIAIgAyAEQQEQqQIMAgsgAiAESQRAQbp/IQUMCAsCQCABRQRAIARFDQFBtn8hBQwJCyAEBEAgASADIAT8CgAACyAEQYh/TQ0AIAQhBQwICyAAIAAoArzpASAEayICNgK86QEgBCEFDAILQbp/IAIgACgCjOsBIgJJDQAaQbZ/QQAgAhsgAUUNABogAgRAIAEgAy0AACAC/AsACyACCyEFQQAhAiAAQQA2ArzpASAFQYh/Sw0FCyAFIgMgACgC0OkBSwRAQWwhBQwFCyAAIAApA/jpASADrXw3A/jpASAAKAL06gEEQCAAQZDqAWogASADEIkMIAAoArzpASECCyAAIAEgA2o2AqzpASACDQMgACgChOoBQQRGBEAgACkDwOkBIgdCf1IEQEFsIQUgACkD+OkBIAdSDQYLIAAoAuDpAQRAIABBBTYChOoBIABBBDYCvOkBDAULIABBADYChOoBIABBADYCvOkBDAQLIABBAzYCvOkBIABBAjYChOoBDAMLIAAoAvTqAUUNASADKAAAIABBkOoBahDuFqdGDQFBaiEFDAMLIAQEQCAAIARrQajsBWogAyAE/AoAAAsgAEEHNgKE6gEgACAAKACk7AU2ArzpAUEAIQUMAgtBACEFIABBADYChOoBIABBADYCvOkBDAELIAMhBQsgBkEQaiQAIAUL1QYBD38jAEEQayIJJABBASEMAkAgAigCACIKQSIgAigCBCIOKAIQIg8RAgANAAJAIAFFBEBBACECDAELQQAgAWshECAAIQggASEGA0AgBiAIaiERQQAhAgJAAkADQCACIAhqIgUtAAAiB0H/AGtB/wFxQaEBSSAHQSJGciAHQdwARnINASAGIAJBAWoiAkcNAAsgBCAGaiEEDAELIAVBAWohCCACIARqIQYCfwJAIAUsAAAiB0EATgRAIAdB/wFxIQUMAQsgCC0AAEE/cSELIAdBH3EhDSAFQQJqIQggB0FfTQRAIA1BBnQgC3IhBQwBCyAILQAAQT9xIAtBBnRyIQsgBUEDaiEIIAdBcEkEQCALIA1BDHRyIQUMAQsgCC0AACEHIAVBBGohCCANQRJ0QYCA8ABxIAdBP3EgC0EGdHJyIgVBgIDEAEcNACAGDAELIAkgBUGBgAQQjwkCQCAJLQANIAktAAxrQf8BcUEBRg0AAkACQAJAIAMgBksNAAJAIANFDQAgASADTQRAIAEgA0cNAgwBCyAAIANqLAAAQb9/TA0BCwJAIAZFDQAgASAGTQRAIAYgEGpFDQEMAgsgACAEaiACaiwAAEG/f0wNAQsgCiAAIANqIAQgA2sgAmogDigCDCIDEQYARQ0BDAILIAAgASADIAIgBGpBkPeJARCjNgALAkAgCS0ADSIGQYEBTwRAIAogCSgCACAPEQIADQIMAQsgCiAJIAktAAwiB2ogBiAHayADEQYADQELAn9BASAFQYABSQ0AGkECIAVBgBBJDQAaQQNBBCAFQYCABEkbCyAEaiACaiEDDAELDAULAn9BASAFQYABSQ0AGkECIAVBgBBJDQAaQQNBBCAFQYCABEkbCyAEaiACagshBCARIAhrIgYNAQsLAkAgAyAESw0AQQAhAgJAIANFDQAgASADTQRAIAMhAiABIANHDQIMAQsgAyECIAAgA2osAABBv39MDQELIARFBEBBACEEDAILIAEgBE0EQCABIARGDQIgAiEDDAELIAAgBGosAABBv39KDQEgAiEDCyAAIAEgAyAEQaD3iQEQozYACyAKIAAgAmogBCACayAOKAIMEQYADQAgCkEiIA8RAgAhDAsgCUEQaiQAIAwLzwYBC38jAEGwKGsiAyQAAkAgAUEDakF8cSABayIFIAJLBEBBASEKQQQhBwwBCyABIAVqIgcgAiAFayICQXxxaiEKIAJBA3EhCyACQQJ2IQQgBSECCyAAQX9zIQAgAgRAA0AgAS0AACAAc0H/AXFBAnRB0Nb8AGooAgAgAEEIdnMhACABQQFqIQEgAkEBayICDQALCyADQQxqQgA3AgAgA0IANwIEIAMgADYCAEEAIQUgBEEFbiIBQQFrIgJBACABIAJPGyEMIARBCk8EQCAHIQgDQCAEIAUgBCAFSRshAiAJQQFqIQlBACEBIAUhAAJAAkADQCACIARGDQEgA0EUaiABaiABIANqKAIAIAEgCGooAgBzNgIAIABBAWohACACQQFqIQIgAUEEaiIBQRRHDQALIANBwCBqIANBJGooAgA2AgAgA0G4IGogA0EcaikCADcDACADQQhqQgA3AwBBACEGIANBEGpBADYCACADIAMpAhQ3A7AgIANCADcDAANAIAZBCnRB0Lb8AGohAEEAIQEDQCADQbAgaiABaiICIAIoAgAiAkEIdjYCACABIANqIg0gDSgCACAAIAJB/wFxQQJ0aigCAHM2AgAgAUEEaiIBQRRHDQALIAZBAWoiBkEERw0ACwwBCyAAIARBwLb8ABDDIQALIAhBFGohCCAFQQVqIQUgCSAMSQ0ACyADKAIAIQALIANBADYCACAMQQVsIgEgBE0EQCABIARHBEAgBCABayEIIAcgAUECdGohByADQRxqIQQgA0GkIGohBUEAIQYDQCADIAAgByAGQQJ0IgBqKAIAc0GstvwAIAAgA2ogBkEFTxsoAgBzNgKkICADQoCAgIDAADcCnCAgBEGslvwAQYAg/AoAACADQgA3AqggQQAhAEEIIQIgBSEBA0AgAS0AACADQbAgaiIMIANBFGogAmpBgAj8CgAAIAFBAWohAUECdCAMaigCACAAcyEAIAJBgAhqIgJBiCBHDQALIAZBAWoiBiAIRw0ACwsgCwRAA0AgCi0AACAAc0H/AXFBAnRB0Nb8AGooAgAgAEEIdnMhACAKQQFqIQogC0EBayILDQALCyADQbAoaiQAIABBf3MPCyABIARBsLb8ABCvOwALk4wBAhV/CH4jAEEgayIZJABBASEFAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAYQQFrDigAAQIVFgMEBQYHCAkWFRYVFhYKCwwNDgsNDhgPEBEPEhMUFRYaFxgZJgsgAiEFIwBB8ABrIgwkAAJ/AkACQAJAAkACQCAAKAIIBEAgDEEYaiAAKAIEENw7IAEoAggEQCAMKAIcIREgDCgCGCEWIAxBEGogASgCBBDcOyAMKAIUIRggDCgCECETIAAoAixFDQIgDEEIaiAAQSxqIgcQ3DsgDEEgaiIGIAwoAgggDCgCDCAAKAI4IAVqIgIgBBD6EyAMQeAAaiAGENUJAkAgDCgCYEEBRgRAIAwoAmQNASAMKAJoIARHDQEMBAsgBEUNAwsgDCAHENw7IAxBIGogDCgCACAMKAIEIAIgBBC/FCABKAIoIANqIQQgACgCKCAFaiEDIAxBQGshAiAMKQNIIRsCQANAAkAgG1BFBEAgDCkDUCEaDAELA0ACfgJAIAwpAzAiGkIDUgRAAkACQAJAIBpCAlENACAMIBpQrUIBhjcDMCAap0EBcUUNACAMIAwpAzg3A2gMAQsgDCgCQEUNASAMQeAAaiACELYqIAwpA2AhGgsgGkIAUg0CCyAMQgM3AzALIAwpAyAiGkICUQ0JIAxCADcDICAMKQMoDAELIAwpA2gLIRtBASAap0EBcUUNCxogDCAMKQNQQkB9Iho3A1AgDCAbNwNIIBtQDQALCyAMQgEgG3oiHIYgG4UiGzcDSCARIAMgHKcgGqdqIgBqIgFBA3YiBksEQCAAIARqIgBBA3YiBSAYTw0CIAYgFmotAAAgAUEHcXZBAXEgBSATai0AACAAQQdxdkEBcUYNAQwJCwsgBiARQay6hwEQwyEACyAFIBhBrLqHARDDIQALQQBBAEGgu4cBEMMhAAtBAEEAQZC7hwEQwyEACyABKAIoIgdBB3EgAyAFckEHcSAAKAIoIgZBB3Fycg0BAkAgBEEHTQ0AAkAgESAGQQN2IAVBA3ZqIgIgBEEDdiILaiIATwRAIAdBA3YgA0EDdmoiASALaiIAIBhLDQEgAiAWaiALIAEgE2ogCxCfOw0CDAYLIAAgEUHIvIcBELA7AAsgACAYQdi8hwEQsDsACyAEQQdxIgBFDQAgBEF4cSIBIANqIQMgASAFaiEFDAILQQEMAwsgBCEACyAMQSBqIBYgESAFIAZqIAAQhx0gAyAHaiEDIAwoAiwhBiAMKAIoIQsgDCgCICEFIAwoAjAiBAR+IAUgBkEDdGoiAjEAACALQT9xrYghGiAEIAtqIgFBA3YgAUEHcUEAR2oiAUECTwRAQQggC2shFiABQQFrIREgAkEBaiEJA0AgCTEAACAWQT9xrYYgGoQhGiAJQQFqIQkgFkEIaiEWIBFBAWsiEQ0ACwsgGkJ/IARBP3GthkJ/hYMFQgALIR0gDEEgaiATIBggAyAAEIcdIAwoAiwhAyAMKAIoIQcgDCgCICEEAn4gDCgCMCICRQRAIAdBP3GtIR5CAAwBCyAEIANBA3RqIgExAAAgB0E/ca0iHoghGiACIAdqIgBBA3YgAEEHcUEAR2oiAEECTwRAQQggB2shFiAAQQFrIREgAUEBaiEJA0AgCTEAACAWQT9xrYYgGoQhGiAJQQFqIQkgFkEIaiEWIBFBAWsiEQ0ACwsgGkJ/IAJBP3GthkJ/hYMLIRwgC0E/ca0hH0EAIRFBACAHa0E/ca0hIEEAIAtrQT9xrSEhQQEhAkEAIQlBASEAA0ACQCAFRSAGIAlNckUEQCAFIAlBA3RqIgEpAAAhGiALBEAgAUEIajEAACAhhiAaIB+IhCEaCyAJQQFqIQkMAQsgACEBQQAhAEEAIQUgHSEaQQEgAUUNAxoLAkAgBEUgAyARTXJFBEAgBCARQQN0aiIBKQAAIRsgBwRAIAFBCGoxAAAgIIYgGyAeiIQhGwsgEUEBaiERDAELIAIhAUEAIQJBACEEIBwhG0EBIAFFDQMaCyAaIBtRDQALC0EACyAMQfAAaiQAIQUMJQsgACABIAIgAyAEELAGIQUMJAsgACABIAIgAyAEEMAEIQUMIwsgACABIAIgAyAEELAGIQUMIgsgACABIAIgAyAEEMAEIQUMIQsgACABIAIgAyAEEL4EIQUMIAsgACABIAIgAyAEEL8EIQUMHwsgACABIAIgAyAEEMAEIQUMHgsgACABIAIgAyAEEL4EIQUMHQsgACABIAIgAyAEEL8EIQUMHAsgAC0AGUEBaw4CCw8KCyMAQYABayIKJAAgCkEoaiAAQQAQ5x0gCigCLCENIAooAighFyAKQSBqIAFBABDnHQJ/AkACQCAAKAIIIgVBAk8EQCAKKAIkIQ8gCigCICEVIApBGGogACgCBEEMahDcOyABKAIIIgVBAU0NASAKKAIcIQggCigCGCEOIApBEGogASgCBEEMahDcOyAKKAIUIRAgCigCECEUIAAoAixFDQIgCkEIaiAAQSxqENw7IApBQGsiBSAKKAIIIAooAgwgACgCOCACaiIJIAQQ+hMgCkE0aiAFENUJAkACQCAKKAI0QQFGBEAgCigCOEUEQCAKKAI8IARGDQYLIAQNAUEAIQUMAgsgBEUNBAtBACEFIAAoAjwiByACayIGQQAgBiAHTRshESABKAI4IANqIRggASgCMCEWIAEoAjwhEyABKAIsIQsgACgCMCEHA0AgBSARRg0hIAMgBWohDCAHIAUgCWoiBkEDdmotAAAhAQJAIAsEfyAMIBNPDSMgFiAFIBhqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEgAUH/AXMgBkEHcXYiAEEBcXJFBEAgDiAIIBQgECAXIA0gFSAPIAIgBWogDEEBENgQDQEMAwsgAEEBcUUNAgsgBCAFQQFqIgVHDQALIAQhBQsgBCAFTQwDC0EBIAVBtK6HARDDIQALQQEgBUHErocBEMMhAAsgDiAIIBQgECAXIA0gFSAPIAIgAyAEENgQCyAKQYABaiQAIQUMGgsCfyMAQYACayIKJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAYQRVGBEAgACgCCEUNAiAAKAIcIQ0gCkEgaiAAKAIEENw7IAooAiQiBiANIAAoAigiE2wiB0kNASABKAIIRQ0EIAooAiAhCCAKQRhqIAEoAgQQ3DsgCigCHCIFIAEoAigiCyANbCIRSQ0DIAcgCGohGCAGIAdrIQ8gCigCGCIHIBFqIRYgBSARayEVIAAoAixFDREgCkEQaiAAQSxqIgYQ3DsgCkHoAGoiBSAKKAIQIAooAhQgACgCOCACaiIOIAQQ+hMgCkH0AWogBRDVCQJAIAooAvQBQQFGBEAgCigC+AENASAKKAL8ASAERw0BDBMLIARFDRILIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgCkEIaiAGENw7IApBKGoiACAKKAIIIAooAgwgDiAEEPoTIAEoAixFDQYgCiABQSxqENw7IApBqAFqIgUgCigCACAKKAIEIAEoAjggA2ogBBD6EyAKQegAaiAAQcAA/AoAACAKQgA3A+gBA0AgCkH0AWoiACAKQegAahDVCQJAIAooAvQBQQFGBEAgCigC/AEhASAKKAL4ASEEIAAgBRDVCSAKKAL0AQ0BC0EBIQYMFQtBACEGIAQgCigC+AFHDRQgASAKKAL8AUcNFCABIARrIA1sIgcgAiAEaiANbCIBaiIAIAdJDQggACAPSw0JIAcgAyAEaiANbCIAaiIEIAdJDQogBCAVSw0LIAEgGGogByAAIBZqIAcQnzsNAAsMEwsgASgCLEUNCgJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshECAAKAI8IgYgAmsiBUEAIAUgBk0bIRQgAiANbCEMIAMgDWwhCSANIAJBAWpsIREgDSADQQFqbCEYIAEoAjggA2ohFiAIIA0gAiATamxqIRMgByANIAMgC2psaiELIAEoAjAhByAAKAIwIQZBACEAA0AgACAURg0NIAAgEEYNDgJAAkAgBiAAIA5qIgFBA3ZqLQAAQQEgAUEHcXRxIgVFDQAgByAAIBZqIgFBA3ZqLQAAQQEgAUEHcXRxRQ0AIBEgF2oiBSAMIBdqIgFJDREgBSAPSw0SIBcgGGoiBSAJIBdqIgFJDRMgBSAVSw0UIBMgF2ogDSALIBdqIA0QnzsNAQwDCyAFDQILIA0gF2ohFyAEIABBAWoiAEcNAAsgBCEACyAAIARPIQYMEgtBkLyHAUEoQbi8hwEQnykACyAHIAZBwLuHARCvOwALQQBBAEGwu4cBEMMhAAsgESAFQeC7hwEQrzsAC0EAQQBB0LuHARDDIQALQfC7hwEQsjsACyABIABByLyHARCxOwALIAAgD0HIvIcBELA7AAsgACAEQdi8hwEQsTsACyAEIBVB2LyHARCwOwALQYC8hwEQsjsAC0G8uocBQSBB3LqHARCfKQALQby6hwFBIEHcuocBEJ8pAAsgASANIAJBAWpsIBdqQci8hwEQsTsACyANIAJBAWpsIBdqIA9ByLyHARCwOwALIAEgDSADQQFqbCAXakHYvIcBELE7AAsgDSADQQFqbCAXaiAVQdi8hwEQsDsACyAEIA1sIgQgAiANbCIBaiIAIARJDQEgACAPSw0CIAQgAyANbCIAaiICIARJDQMgAiAVSw0EIAEgGGogBCAAIBZqIAQQnzshBgsgCkGAAmokACAGDAQLIAEgAEHIvIcBELE7AAsgACAPQci8hwEQsDsACyAAIAJB2LyHARCxOwALIAIgFUHYvIcBELA7AAshBQwZCyMAQYABayIKJAAgCkEoaiAAEOMdIAooAiwhDSAKKAIoIRcgCkEgaiABEOMdAn8CQAJAIAAoAggiBUECTwRAIAooAiQhDyAKKAIgIRUgCkEYaiAAKAIEQQxqENw7IAEoAggiBUEBTQ0BIAooAhwhCCAKKAIYIQ4gCkEQaiABKAIEQQxqENw7IAooAhQhECAKKAIQIRQgACgCLEUNAiAKQQhqIABBLGoQ3DsgCkFAayIFIAooAgggCigCDCAAKAI4IAJqIgkgBBD6EyAKQTRqIAUQ1QkCQAJAIAooAjRBAUYEQCAKKAI4RQRAIAooAjwgBEYNBgsgBA0BQQAhBQwCCyAERQ0EC0EAIQUgACgCPCIHIAJrIgZBACAGIAdNGyERIAEoAjggA2ohGCABKAIwIRYgASgCPCETIAEoAiwhCyAAKAIwIQcDQCAFIBFGDR8gAyAFaiEMIAcgBSAJaiIGQQN2ai0AACEBAkAgCwR/IAwgE08NISAWIAUgGGoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcSABQf8BcyAGQQdxdiIAQQFxckUEQCAOIAggFCAQIBcgDSAVIA8gAiAFaiAMQQEQoxANAQwDCyAAQQFxRQ0CCyAEIAVBAWoiBUcNAAsgBCEFCyAEIAVNDAMLQQEgBUG0rocBEMMhAAtBASAFQcSuhwEQwyEACyAOIAggFCAQIBcgDSAVIA8gAiADIAQQoxALIApBgAFqJAAhBQwYCyMAQSBrIhUkACAVQRhqIAAQ5h0CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBCACIARqIgZNBEAgBiAVKAIcIgVLDQEgACgCCCILRQ0CIBUoAhggACgCBCEGIBVBEGogARDmHSADIARqIhMgBEkNAyATIBUoAhQiBUsNBCABKAIIIgVFDQUgBEUNCyACQQR0aiEIIAtBAWshCSAGQQxqIQsgBUEBayERIAEoAgRBDGohByAVKAIQIANBBHRqIQ4gACgCOCEGIAAoAjAhBSAAKAI8IQMgACgCLCECA0ACQCACBEAgAyAQTQ0pIAUgBiAQaiIAQQN2ai0AACAAQQdxdkEBcUUNAQsgCCkDACIdIA4pAwAiHFINDiAOKQMIIRogCCkDCCEbIB2nIhRBDU8EQCAJIBunIgBNDQkgGqciEyARSQRAIBVBCGogCyAAQQxsahDcOyAbQiCIpyIAIBRqIgEgAEEEaiIWSQ0LIAEgFSgCDCIASw0MIBUoAgggFSAHIBNBDGxqENw7IBpCIIinIgAgFGoiDCAAQQRqIhNJDQ0gDCAVKAIEIgBLDQ4gFmogFEEEayIAIBUoAgAgE2ogABDBLg0CDBALIBMgEUGAxYcBEMMhAAsgHCAdhSAaIBuFhFBFDQ4LIA5BEGohDiAIQRBqIQggEEEBaiIQIARHDQALDAsLIAIgBkGwxIcBELE7AAsgBiAFQbDEhwEQsDsAC0EBQQBBwMSHARCvOwALIAMgE0HQxIcBELE7AAsgEyAFQdDEhwEQsDsAC0EBQQBB4MSHARCvOwALIAAgCUHwxIcBEMMhAAsgFiABQZDFhwEQsTsACyABIABBkMWHARCwOwALIBMgDEGgxYcBELE7AAsgDCAAQaDFhwEQsDsAC0EBIRgLIBVBIGokACAYIQUMFwsgGUEANgIYIBlBATYCDCAZQdjChwE2AgggGUIENwIQIBlBCGpB4MKHARDvLAALIwBB4ABrIhAkAAJ/AkACQAJAAkACQAJAIAAtABhBHUYEQCAAKAIURQ0BIAEoAhRFDQIgACgCECEJIAAoAhwhFCABKAIQIREgACgCLEUNBiAQQQhqIABBLGoQ3DsgEEEgaiIFIBAoAgggECgCDCAAKAI4IAJqIhggBBD6EyAQQRRqIAUQ1QkCQCAQKAIUQQFGBEAgECgCGA0BIBAoAhwgBEcNAQwICyAERQ0HCyABKAIsRQ0DAkAgBEUEQEEAIQAMAQsgASgCPCIGIANrIgVBACAFIAZNGyEWIAAoAjwiBiACayIFQQAgBSAGTRshEyABKAI4IANqIQsgFCABKAIoIANqbCEHIBQgACgCKCACamwhBiABKAIwIQUgACgCMCEDQQAhAANAIAAgE0YNBiAAIBZGDQcCQAJAIAMgACAYaiIBQQN2ai0AAEEBIAFBB3F0cSICRQ0AIAUgACALaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAJIBEgBiAMaiAHIAxqIBQQ6ywNAQwDCyACDQILIAwgFGohDCAEIABBAWoiAEcNAAsgBCEACyAAIARPDAcLQcimhwFBKEHwpocBEJ8pAAtBAEEAQZimhwEQwyEAC0EAQQBBqKaHARDDIQALQbimhwEQsjsAC0HIpIcBQSBB6KSHARCfKQALQcikhwFBIEHopIcBEJ8pAAsgCSARIAAoAiggAmogFGwgASgCKCADaiAUbCAEIBRsEOssCyAQQeAAaiQAIQUMFQsjAEEQayIIJAAgCEEIaiAAIgUQ4x0gCCgCDCEXIAgoAgghACAIIAEQ4x1BASEPAkAgBEUNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBcgAiAEaiIRSwRAIAAgEUEDdGopAwAiGkKAgICAEFQEQCACIBdPDQMgACACQQN0aiIVKQMAIhtCgICAgBBaDQIgAyAEaiIYIAgoAgQiDU8NBSAIKAIAIgAgGEEDdGopAwAiHUKAgICAEFoNBAJAIAMgDUkEQCAAIANBA3RqIgApAwAiHEKAgICAEFoNCCAapyAbp2siEyAdpyAcp2siC0cgGiAbUnINAQwaCyADIA1BpKuHARDDIQALIAUoAhRFDQcCQAJAAkAgASgCFARAIAUoAhAhDiABKAIQIRACQCAEAn8gBSgCLCIHBEAgBCAFQSxqIAUoAjggAmogBBDTH2shFiABKAIsRQ0CIAFBLGoMAQsgASgCLEUNBCABQSxqCyABKAI4IANqIhQgBBDTHyIGayAWRg0CDBwLQQAhDyALIBNHIBZyDRwMAwtBAEEAQdSrhwEQwyEACyAEIAZGDQAgB0UNCkEAIQYgDSADayIHQQAgByANTRshDCAXIAJrIgdBACAHIBdNGyEJIAEoAjwiCyADayIHQQAgByALTRshESAFKAI8IgsgAmsiB0EAIAcgC00bIRggBSgCOCACaiEWIAEoAjAhEyAFKAIwIQsDQCAGIBhGIAYgEUZyDTFBACEPIAsgBiAWaiIBQQN2ai0AAEEBIAFBB3F0cSIFRSATIAYgFGoiAUEDdmotAAAgAUEHcXZBAXFFcw0bIAYgCUYNDSAVKQMAIhpCgICAgBBaDQwgAiAGaiIBQQFqIBdPDQ8gFUEIaiIVKQMAIhtCgICAgBBaDQ4gBiAMRg0RIAApAwAiHUKAgICAEFoNECADIAZqQQFqIA1PDRMgAEEIaiIAKQMAIhxCgICAgBBaDRIgBQRAIBunIBqnIgdrIgUgHKcgHaciAWtHDRwgDiAQIAcgASAFEOssRQ0cCyAEIAZBAWoiBkcNAAtBASEPDBoLIAsgE0cNGAsgAiARSw0RIAMgGEsNEiAVKQMAIhtQRQ0TQgAhHCAAKQMAQgBSDRNBACEPIBUgACAEQQN0EJknDRgMFAtB1KqHARCyOwALIBEgF0HEqocBEMMhAAtB9KqHARCyOwALIAIgF0HkqocBEMMhAAtBlKuHARCyOwALIBggDUGEq4cBEMMhAAtBtKuHARCyOwALQQBBAEHEq4cBEMMhAAtBpKyHARCyOwALQcSshwEQsjsACyACIAZqIBdBtKyHARDDIQALQeSshwEQsjsACyABQQFqIBdB1KyHARDDIQALQYSthwEQsjsACyADIAZqIA1B9KyHARDDIQALQaSthwEQsjsACyANIANBAWoiACAAIA1JGyANQZSthwEQwyEACyACIBFB5KuHARCxOwALIAMgGEH0q4cBELE7AAsgACEGA0AgBEEBayIEBEAgBikDACEdIBUpAwAhHCAVQQhqIgIhFSAGQQhqIgEhBiACKQMAIBx9IAEpAwAgHX1RDQEMBQsLIBtCgICAgBBaDQEgACkDACIcQoCAgIAQWg0CIBunIQ8LIA4gECAPIBynIBMQ6ywhDwwDC0GErIcBELI7AAtBlKyHARCyOwALQQAhDwsgCEEQaiQAIA8hBQwUCyMAQeAAayIJJAACQAJAAkAgACgCLEUNACAJQQhqIABBLGoQ3DsgCUEgaiIFIAkoAgggCSgCDCAAKAI4IhYgAmogBBD6EyAJQRRqIAUQ1QkgCSgCFEEBRgRAIAkoAhgNAiAJKAIcIARGDQEMAgsgBA0BCyAAIAEgAiADIAQQ8B8hBQwBCwJAIAEoAiwEQCAERQRAQQEhBQwDCyABKAI8IgYgA2siBUEAIAUgBk0bIREgACgCPCIGIAJrIgVBACAFIAZNGyEYIAEoAjghEyABKAIwIQsgACgCMCEHA0AgGEUgEUVyDRkCQCAHIAIgFmoiBUEDdmotAABBASAFQQdxdHEiBkUgCyADIBNqIgVBA3ZqLQAAQQEgBUEHcXRxIgVFckUEQCAAIAEgAiADQQEQ8B8NAQwECyAGRSAFRXMNAwsgGEEBayEYIBFBAWshEUEBIQUgA0EBaiEDIAJBAWohAiAEQQFrIgQNAAsMAgtBsMWHARCyOwALQQAhBQsgCUHgAGokAAwTCwJ/IwBB0ABrIg0kACANQTBqIAAiBRDSHiANKAI0IQYgDSgCMCEHIA1BKGogARDSHgJAAn8CQAJAAkACQAJAAkACQAJAIAQgAiAEaiITTQRAIAYgE0kNASADIARqIgsgBEkNAiALIA0oAiwiBksNAyAALQAYQSFHDQogAS0AGEEhRw0KIAIgB2ohCCANKAIoIANqIQ4gAS0AGSEGAkAgAC0AGUEBRgRAIAZBAXENAQwMCyAGQQFxDQsgCCAOIAQQmScNCQJAIAEoAhQiBiAFKAIUIgAgACAGSxsiAEUEQEEAIQEMAQsgASgCECEPIAUoAhAhFyABKAIoIANqIQMgBSgCKCACaiECQQAhAQNAIBcgDyACIAMgBBDrLEUNASAXQcQAaiEXIA9BxABqIQ8gACABQQFqIgFHDQALIAAhAQsgACABTQwKCyANQSBqIAVBARDnHSANKAIgIA0oAiQhACANQRhqIAFBARDnHSAAIBNJDQQgCyANKAIcIgBLDQUgDSgCGCEAIAggDiAEEJknDQggAkECdGohDCAFQRxqIQkgAUEcaiERIAAgA0ECdGohGCABKAIQIQMgASgCFCEQIAUoAhQhFCAFKAIQIQJBACEFA0ACQCAEIAUiAEYEQCAEIQAMAQsgDUEQaiAJELAuAkAgDSgCECIXIA0oAhQiB0cEQCAAQQFqIQUgGCAAQQJ0IgFqIRYgASAMaiETQQAhDyAAIAhqLQAAIQYgAiEBA0AgFy0AACAGRg0CIAFBxABqIQEgD0EBaiEPIBdBCGoiFyAHRw0ACwtByJ6HARCyOwALIA1BCGogERCwLgJAIA0oAggiFyANKAIMIgtHBEBBACEVIAAgDmotAAAhByADIQYDQCAXLQAAIAdGDQIgBkHEAGohBiAVQQFqIRUgF0EIaiIXIAtHDQALC0HYnocBELI7AAsgDyAUTw0IIBAgFU0NCSABIAYgEygCACAWKAIAQQEQ6ywNAQsLIAAgBE8MCQsgAiATQYifhwEQsTsACyATIAZBiJ+HARCwOwALIAMgC0GYn4cBELE7AAsgCyAGQZifhwEQsDsACyATIABBqJ+HARCwOwALIAsgAEG4n4cBELA7AAsgDyAUQeiehwEQwyEACyAVIBBB+J6HARDDIQALQQALIA1B0ABqJAAMAQsgDUEANgJIIA1BATYCPCANQaSghwE2AjggDUIENwJAIA1BOGpBrKCHARDvLAALIQUMEgsgACgCHC0AAEECaw4IBwgJCgsMDQ4GCyAAIAEgAiADIAQQvgQhBQwQCyAAIAEgAiADIAQQvwQhBQwPCwJ/IwBBgAJrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIBJBIGogACgCBBDcOyASKAIkIgYgACgCKEEFdCIPTwRAIAEoAghFDQMgEigCICEIIBJBGGogASgCBBDcOyASKAIcIgUgASgCKEEFdCIVSQ0CIAggD2ohEyAGIA9rIQ0gEigCGCIHIBVqIQsgBSAVayEXIAAoAixFDQwgEkEQaiAAQSxqIgYQ3DsgEkHoAGoiBSASKAIQIBIoAhQgACgCOCACaiIOIAQQ+hMgEkH0AWogBRDVCQJAIBIoAvQBQQFGBEAgEigC+AENASASKAL8ASAERw0BDA4LIARFDQ0LIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgEkEIaiAGENw7IBJBKGoiACASKAIIIBIoAgwgDiAEEPoTIAEoAixFDQUgEiABQSxqENw7IBJBqAFqIgUgEigCACASKAIEIAEoAjggA2ogBBD6EyASQegAaiAAQcAA/AoAACASQgA3A+gBA0AgEkH0AWoiACASQegAahDVCQJAIBIoAvQBQQFGBEAgEigC/AEhASASKAL4ASEEIAAgBRDVCSASKAL0AQ0BC0EBIQYMEAtBACEGIAQgEigC+AFHDQ8gASASKAL8AUcNDyABIARrQQV0IgcgAiAEakEFdCIBaiIAIAdJDSQgACANSw0lIAcgAyAEakEFdCIAaiIEIAdJDQcgBCAXSw0IIAEgE2ogByAAIAtqIAcQnzsNAAsMDgsgASgCLEUNBwJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshDCAAKAI8IgYgAmsiBUEAIAUgBk0bIQkgAkEFdCIQQWBzIREgA0EFdCIUQWBzIRggASgCOCADaiEWIAggDyAQamohEyAHIBQgFWpqIQsgASgCMCEHIAAoAjAhBkEAIQADQCAAIAlGIAAgDEZyDSYCQAJAIAYgACAOaiIBQQN2ai0AAEEBIAFBB3F0cSIFRQ0AIAcgACAWaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAKIBFGDQwgCiAQakEgaiANSw0NIAogGEYNDiAKIBRqQSBqIBdLDQ8gCiATakEgIAogC2pBIBCfOw0BDAMLIAUNAgsgCkEgaiEKIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBgwNCyAPIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgFSAFQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAAIARBiL6HARCxOwALIAQgF0GIvocBELA7AAtB6L2HARCyOwALQWAgAkEFdCAKakEgakH4vYcBELE7AAsgAkEFdCAKakEgaiANQfi9hwEQsDsAC0FgIANBBXQgCmpBIGpBiL6HARCxOwALIANBBXQgCmpBIGogF0GIvocBELA7AAsgBEEFdCIEIAJBBXQiAWoiACAESQ0VIAAgDUsNFiAEIANBBXQiAGoiAiAESQ0BIAIgF0sNAiABIBNqIAQgACALaiAEEJ87IQYLIBJBgAJqJAAgBgwCCyAAIAJBiL6HARCxOwALIAIgF0GIvocBELA7AAshBQwOCyMAQRBrIg8kACAPQQhqIAAiBUEAEOcdIA8oAgwhCiAPKAIIIQAgDyABQQAQ5x1BASENAkAgBEUNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAogAiAEaiIRSwRAIAAgEUECdGooAgAiE0EATgRAIAIgCk8NAyAAIAJBAnRqIhcoAgAiC0EASA0CIAMgBGoiGCAPKAIEIhJPDQUgDygCACIAIBhBAnRqKAIAIgdBAEgNBAJAIAMgEkkEQCAAIANBAnRqIgAoAgAiBkEASA0IIAsgE0cgEyALayIWIAcgBmsiE0dyDQEMGgsgAyASQaSrhwEQwyEACyAFKAIURQ0HAkACQAJAIAEoAhQEQCAFKAIQIRUgASgCECEIAkAgBAJ/IAUoAiwiCwRAIAQgBUEsaiAFKAI4IAJqIAQQ0x9rIQYgASgCLEUNAiABQSxqDAELIAEoAixFDQRBACEGIAFBLGoLIAEoAjggA2oiFCAEENMfIgdrIAZGDQIMHAtBACENIBMgFkcgBnINHAwDC0EAQQBB1KuHARDDIQALIAQgB0YNACALRQ0KQQAhBiASIANrIgdBACAHIBJNGyEMIAogAmsiB0EAIAcgCk0bIQkgASgCPCILIANrIgdBACAHIAtNGyERIAUoAjwiCyACayIHQQAgByALTRshGCAFKAI4IAJqIRYgASgCMCETIAUoAjAhCwNAIAYgGEYgBiARRnINKkEAIQ0gCyAGIBZqIgFBA3ZqLQAAQQEgAUEHcXRxIgdFIBMgBiAUaiIBQQN2ai0AACABQQdxdkEBcUVzDRsgBiAJRg0NIBcoAgAiDkEASA0MIAIgBmoiAUEBaiAKTw0PIBdBBGoiFygCACIBQQBIDQ4gBiAMRg0RIAAoAgAiEEEASA0QIAMgBmpBAWogEk8NEyAAQQRqIgAoAgAiBUEASA0SIAcEQCABIA5rIgEgBSAQa0cNHCAVIAggDiAQIAEQ6yxFDRwLIAQgBkEBaiIGRw0AC0EBIQ0MGgsgEyAWRw0YCyACIBFLDREgAyAYSw0SIBcoAgAiBw0TIAAoAgANE0EAIQ0gFyAAIARBAnQQmScNGAwUC0HUqocBELI7AAsgESAKQcSqhwEQwyEAC0H0qocBELI7AAsgAiAKQeSqhwEQwyEAC0GUq4cBELI7AAsgGCASQYSrhwEQwyEAC0G0q4cBELI7AAtBAEEAQcSrhwEQwyEAC0GkrIcBELI7AAtBxKyHARCyOwALIAIgBmogCkG0rIcBEMMhAAtB5KyHARCyOwALIAFBAWogCkHUrIcBEMMhAAtBhK2HARCyOwALIAMgBmogEkH0rIcBEMMhAAtBpK2HARCyOwALIBIgA0EBaiIAIAAgEkkbIBJBlK2HARDDIQALIAIgEUHkq4cBELE7AAsgAyAYQfSrhwEQsTsACyAAIQYDQCAEQQFrIgQEQCAGKAIAIQUgFygCACEDIBdBBGoiAiEXIAZBBGoiASEGIAIoAgAgA2sgASgCACAFa0YNAQwFCwsgB0EASA0BIAAoAgAiDUEASA0CCyAVIAggByANIBYQ6ywhDQwDC0GErIcBELI7AAtBlKyHARCyOwALQQAhDQsgD0EQaiQAIA0hBQwNCyACIANyDQogACgCJCIDIARGIAEoAiQiAiAERnJFDQogACgCKA0KIAEoAigNCkEAIQUgAiADRw0MAkACQAJAAkACQCAAKAIUDgIAAgELQQBBAEH4v4cBEMMhAAsgASgCFA4CAQ4CC0EBQQFBiMCHARDDIQALQQBBAEGYwIcBEMMhAAsgACgCECICKAIkIgAgASgCECIBKAIkRw0MIAIoAmggASgCaEcNDCACIAFBAEEAIAAQ6yxFDQwgAkHEAGogAUHEAGpBAEEAIAEoAmgQ6ywhBQwMCwJ/IwBBgAJrIhIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCCARAIBJBIGogACgCBBDcOyASKAIkIgYgACgCKEEEdCIPTwRAIAEoAghFDQMgEigCICEIIBJBGGogASgCBBDcOyASKAIcIgUgASgCKEEEdCIVSQ0CIAggD2ohEyAGIA9rIQ0gEigCGCIHIBVqIQsgBSAVayEXIAAoAixFDQwgEkEQaiAAQSxqIgYQ3DsgEkHoAGoiBSASKAIQIBIoAhQgACgCOCACaiIOIAQQ+hMgEkH0AWogBRDVCQJAIBIoAvQBQQFGBEAgEigC+AENASASKAL8ASAERw0BDA4LIARFDQ0LIAAoAkC4IAAoAiS4o0SamZmZmZnZP2ZFBEAgEkEIaiAGENw7IBJBKGoiACASKAIIIBIoAgwgDiAEEPoTIAEoAixFDQUgEiABQSxqENw7IBJBqAFqIgUgEigCACASKAIEIAEoAjggA2ogBBD6EyASQegAaiAAQcAA/AoAACASQgA3A+gBA0AgEkH0AWoiACASQegAahDVCQJAIBIoAvQBQQFGBEAgEigC/AEhASASKAL4ASEEIAAgBRDVCSASKAL0AQ0BC0EBIQYMEAtBACEGIAQgEigC+AFHDQ8gASASKAL8AUcNDyABIARrQQR0IgcgAiAEakEEdCIBaiIAIAdJDSEgACANSw0iIAcgAyAEakEEdCIAaiIEIAdJDQcgBCAXSw0IIAEgE2ogByAAIAtqIAcQnzsNAAsMDgsgASgCLEUNBwJAIARFBEBBACEADAELIAEoAjwiBiADayIFQQAgBSAGTRshDCAAKAI8IgYgAmsiBUEAIAUgBk0bIQkgAkEEdCIQQXBzIREgA0EEdCIUQXBzIRggASgCOCADaiEWIAggDyAQamohEyAHIBQgFWpqIQsgASgCMCEHIAAoAjAhBkEAIQADQCAAIAlGIAAgDEZyDSMCQAJAIAYgACAOaiIBQQN2ai0AAEEBIAFBB3F0cSIFRQ0AIAcgACAWaiIBQQN2ai0AAEEBIAFBB3F0cUUNACAKIBFGDQwgCiAQakEQaiANSw0NIAogGEYNDiAKIBRqQRBqIBdLDQ8gCiATakEQIAogC2pBEBCfOw0BDAMLIAUNAgsgCkEQaiEKIAQgAEEBaiIARw0ACyAEIQALIAAgBE8hBgwNCyAPIAZBqL2HARCvOwALQQBBAEGYvYcBEMMhAAsgFSAFQci9hwEQrzsAC0EAQQBBuL2HARDDIQALQdi9hwEQsjsACyAAIARBiL6HARCxOwALIAQgF0GIvocBELA7AAtB6L2HARCyOwALQXAgAkEEdCAKakEQakH4vYcBELE7AAsgAkEEdCAKakEQaiANQfi9hwEQsDsAC0FwIANBBHQgCmpBEGpBiL6HARCxOwALIANBBHQgCmpBEGogF0GIvocBELA7AAsgBEEEdCIEIAJBBHQiAWoiACAESQ0SIAAgDUsNEyAEIANBBHQiAGoiAiAESQ0BIAIgF0sNAiABIBNqIAQgACALaiAEEJ87IQYLIBJBgAJqJAAgBgwCCyAAIAJBiL6HARCxOwALIAIgF0GIvocBELA7AAshBQwLC0HwwocBQShBmMOHARCfKQALAn8jAEHwAGsiDyQAIA9BGGogABDSHiAPKAIcIRUgDygCGCEUIA9BEGogARDSHgJAAkACQAJAAkAgACgCFARAIAEoAhRFDRcgACgCECEMIA8oAhQhCCAPKAIQIQkgASgCECERIAAoAixFDQIgD0EIaiAAQSxqENw7IA9BMGoiBSAPKAIIIA8oAgwgACgCOCIYIAJqIAQQ+hMgD0EkaiAFENUJAkAgDygCJEEBRgRAIA8oAigNASAPKAIsIARHDQEMBAsgBEUNAwsgASgCLEUNGCAERQRAQQAhBQwFC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyABKAI4IQsgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINGgJAAkAgBiACIAVqIg4gGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAMgBWoiECALaiIAQQN2ai0AAEEBIABBB3F0cUUNACAOIBVPDQQgDiAUaiwAACIBQQBIDR0gCCAQSwRAIAkgEGosAAAiAEEASA0fIAwgESABIABBARDrLA0CDAgLIBAgCEHYv4cBEMMhAAsgAQ0GCyAFQQFqIgUgBEcNAAsMAwsMFQsgDiAVQbi/hwEQwyEAC0EAIARrIRYgAyAJaiETIAIgFGohCyAVIAIgAiAVSxsgFWshByAIIAMgAyAISxsgCGshBkF/IQUDQCAFIBZqQX9GDQEgBSAHakF/Rg0DIAUgC2pBAWosAAAiAUEASA0bAkAgBSAGakF/RwRAIAUgE2pBAWosAAAiAEEATg0BDBwLIAMgBWpBAWogCEGYv4cBEMMhAAsgBUEBaiEFIAwgESABIABBARDrLA0ACwwBCyAEIQULIA9B8ABqJAAgBCAFTQwBCyACIAVqQQFqIBVB+L6HARDDIQALIQUMCQsjAEHwAGsiCCQAIAhBGGogABDkHSAIKAIcIRAgCCgCGCELIAhBEGogARDkHQJAAkACQCAAKAIUBEAgASgCFEUNEyAAKAIQIQwgCCgCFCEUIAgoAhAhCSABKAIQIREgACgCLEUNASAIQQhqIABBLGoQ3DsgCEEwaiIFIAgoAgggCCgCDCAAKAI4IAJqIhggBBD6EyAIQSRqIAUQ1QkCQCAIKAIkQQFGBEAgCCgCKA0BIAgoAiwgBEcNAQwDCyAERQ0CCyABKAIsRQ0UIARFBEBBACEFDAQLQQAhBSABKAI8IgcgA2siBkEAIAYgB00bIRYgACgCPCIHIAJrIgZBACAGIAdNGyETIAsgAkEBdGohDiABKAI4IANqIQsgCSADQQF0aiEJIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRYCQAJAIAYgBSAYaiIAQQN2ai0AAEEBIABBB3F0cSIBRQ0AIAcgBSALaiIAQQN2ai0AAEEBIABBB3F0cUUNACACIAVqIgAgEE8NHiAOLgEAIgFBAEgNGSAUIAMgBWoiAEsEQCAJLgEAIgBBAEgNGyAMIBEgASAAQQEQ6ywNAgwHCwwdCyABDQULIA5BAmohDiAJQQJqIQkgBCAFQQFqIgVHDQALDAILDBELQQAhBSAUIANrIgBBACAAIBRNGyEHIBAgAmsiAEEAIAAgEE0bIQYgCSADQQF0aiEJIAsgAkEBdGohDgJAA0AgBCAFRg0CIAUgBkYNASAOLgEAIgFBAEgNGQJAIAUgB0cEQCAJLgEAIgBBAE4NAQwaCwwdCyAFQQFqIQUgCUECaiEJIA5BAmohDiAMIBEgASAAQQEQ6ywNAAsgBUEBayEFDAILDBsLIAQhBQsgCEHwAGokACAEIAVNIQUMCAsjAEHwAGsiCCQAIAhBGGogAEEAEOcdIAgoAhwhECAIKAIYIQsgCEEQaiABQQAQ5x0CQAJAAkAgACgCFARAIAEoAhRFDRIgACgCECEMIAgoAhQhFCAIKAIQIQkgASgCECERIAAoAixFDQEgCEEIaiAAQSxqENw7IAhBMGoiBSAIKAIIIAgoAgwgACgCOCACaiIYIAQQ+hMgCEEkaiAFENUJAkAgCCgCJEEBRgRAIAgoAigNASAIKAIsIARHDQEMAwsgBEUNAgsgASgCLEUNEyAERQRAQQAhBQwEC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyALIAJBAnRqIQ4gASgCOCADaiELIAkgA0ECdGohCSABKAIwIQcgACgCMCEGA0AgBSATRiAFIBZGcg0VAkACQCAGIAUgGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAUgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgAiAFaiIAIBBPDR0gDigCACIBQQBIDRggFCADIAVqIgBLBEAgCSgCACIAQQBIDRogDCARIAEgAEEBEOssDQIMBwsMHAsgAQ0FCyAOQQRqIQ4gCUEEaiEJIAQgBUEBaiIFRw0ACwwCCwwQC0EAIQUgFCADayIAQQAgACAUTRshByAQIAJrIgBBACAAIBBNGyEGIAkgA0ECdGohCSALIAJBAnRqIQ4CQANAIAQgBUYNAiAFIAZGDQEgDigCACIBQQBIDRgCQCAFIAdHBEAgCSgCACIAQQBODQEMGQsMHAsgBUEBaiEFIAlBBGohCSAOQQRqIQ4gDCARIAEgAEEBEOssDQALIAVBAWshBQwCCwwaCyAEIQULIAhB8ABqJAAgBCAFTSEFDAcLIwBB8ABrIggkACAIQRhqIAAQ4x0gCCgCHCEQIAgoAhghCyAIQRBqIAEQ4x0CQAJAAkAgACgCFARAIAEoAhRFDREgACgCECEMIAgoAhQhFCAIKAIQIQkgASgCECERIAAoAixFDQEgCEEIaiAAQSxqENw7IAhBMGoiBSAIKAIIIAgoAgwgACgCOCACaiIYIAQQ+hMgCEEkaiAFENUJAkAgCCgCJEEBRgRAIAgoAigNASAIKAIsIARHDQEMAwsgBEUNAgsgASgCLEUNEiAERQRAQQAhBQwEC0EAIQUgASgCPCIHIANrIgZBACAGIAdNGyEWIAAoAjwiByACayIGQQAgBiAHTRshEyALIAJBA3RqIQ4gASgCOCADaiELIAkgA0EDdGohCSABKAIwIQcgACgCMCEGA0AgBSATRiAFIBZGcg0UAkACQCAGIAUgGGoiAEEDdmotAABBASAAQQdxdHEiAUUNACAHIAUgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgAiAFaiIAIBBPDRwgDikDACIdQoCAgIAQWg0XIBQgAyAFaiIASwRAIAkpAwAiHEKAgICAEFoNGSAMIBEgHacgHKdBARDrLA0CDAcLDBsLIAENBQsgDkEIaiEOIAlBCGohCSAEIAVBAWoiBUcNAAsMAgsMDwtBACEFIBQgA2siAEEAIAAgFE0bIQEgECACayIAQQAgACAQTRshACAJIANBA3RqIQkgCyACQQN0aiEOAkADQCAEIAVGDQIgACAFRg0BIA4pAwAiHUKAgICAEFoNFwJAIAEgBUcEQCAJKQMAIhxCgICAgBBUDQEMGAsMGwsgBUEBaiEFIAlBCGohCSAOQQhqIQ4gDCARIB2nIBynQQEQ6ywNAAsgBUEBayEFDAILDBkLIAQhBQsgCEHwAGokACAEIAVNIQUMBgsCfyMAQfAAayIPJAAgD0EYaiAAENIeIA8oAhwhFSAPKAIYIRQgD0EQaiABENIeAkACQAJAAkACQAJAIAAoAhQEQCABKAIURQ0UIAAoAhAhDCAPKAIUIQggDygCECEJIAEoAhAhESAAKAIsRQ0CIA9BCGogAEEsahDcOyAPQTBqIgUgDygCCCAPKAIMIAAoAjgiGCACaiAEEPoTIA9BJGogBRDVCQJAIA8oAiRBAUYEQCAPKAIoDQEgDygCLCAERw0BDAQLIARFDQMLIAEoAixFDRUgBEUEQEEAIQUMBQtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgASgCOCELIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRcCQAJAIAYgAiAFaiIOIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByADIAVqIhAgC2oiAEEDdmotAABBASAAQQdxdHFFDQAgDiAVTw0EIAggEEsEQCAMIBEgDiAUai0AACAJIBBqLQAAQQEQ6ywNAgwICyAQIAhB2L+HARDDIQALIAENBgsgBUEBaiIFIARHDQALDAMLDBILIA4gFUG4v4cBEMMhAAtBACAEayEWIAMgCWohEyACIBRqIQsgFSACIAIgFUsbIBVrIQcgCCADIAMgCEsbIAhrIQZBfyEFA0AgBSAWakF/Rg0BIAUgB2pBf0YNAyAFIAZqQX9GDQQgBSATaiEBIAUgC2ohACAFQQFqIQUgDCARIABBAWotAAAgAUEBai0AAEEBEOssDQALDAELIAQhBQsgD0HwAGokACAEIAVNDAILIAIgBWpBAWogFUH4vocBEMMhAAsgAyAFakEBaiAIQZi/hwEQwyEACyEFDAULAn8jAEHwAGsiCCQAIAhBGGogABDkHSAIKAIcIRAgCCgCGCELIAhBEGogARDkHQJAAkACQAJAIAAoAhQEQCABKAIURQ0RIAAoAhAhDCAIKAIUIRQgCCgCECEJIAEoAhAhESAAKAIsRQ0BIAhBCGogAEEsahDcOyAIQTBqIgUgCCgCCCAIKAIMIAAoAjggAmoiGCAEEPoTIAhBJGogBRDVCQJAIAgoAiRBAUYEQCAIKAIoDQEgCCgCLCAERw0BDAMLIARFDQILIAEoAixFDRIgBEUEQEEAIQUMBAtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgCyACQQF0aiEOIAEoAjggA2ohCyAJIANBAXRqIQkgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINFAJAAkAgBiAFIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByAFIAtqIgBBA3ZqLQAAQQEgAEEHcXRxRQ0AIAIgBWoiACAQTw0cIBQgAyAFaiIASwRAIAwgESAOLwEAIAkvAQBBARDrLA0CDAcLDBsLIAENBQsgDkECaiEOIAlBAmohCSAEIAVBAWoiBUcNAAsMAgsMDwtBACEFIBQgA2siAEEAIAAgFE0bIQcgECACayIAQQAgACAQTRshBiAJIANBAXRqIQ4gCyACQQF0aiEJA0AgBCAFRg0BIAUgBkYNGiAFIAdGDQMgBUEBaiEFIA4vAQAhASAJLwEAIQAgDkECaiEOIAlBAmohCSAMIBEgACABQQEQ6ywNAAsgBUEBayEFDAELIAQhBQsgCEHwAGokACAEIAVNDAELDBULIQUMBAsCfyMAQfAAayIIJAAgCEEYaiAAQQAQ5x0gCCgCHCEQIAgoAhghCyAIQRBqIAFBABDnHQJAAkACQAJAIAAoAhQEQCABKAIURQ0QIAAoAhAhDCAIKAIUIRQgCCgCECEJIAEoAhAhESAAKAIsRQ0BIAhBCGogAEEsahDcOyAIQTBqIgUgCCgCCCAIKAIMIAAoAjggAmoiGCAEEPoTIAhBJGogBRDVCQJAIAgoAiRBAUYEQCAIKAIoDQEgCCgCLCAERw0BDAMLIARFDQILIAEoAixFDREgBEUEQEEAIQUMBAtBACEFIAEoAjwiByADayIGQQAgBiAHTRshFiAAKAI8IgcgAmsiBkEAIAYgB00bIRMgCyACQQJ0aiEOIAEoAjggA2ohCyAJIANBAnRqIQkgASgCMCEHIAAoAjAhBgNAIAUgE0YgBSAWRnINEwJAAkAgBiAFIBhqIgBBA3ZqLQAAQQEgAEEHcXRxIgFFDQAgByAFIAtqIgBBA3ZqLQAAQQEgAEEHcXRxRQ0AIAIgBWoiACAQTw0bIBQgAyAFaiIASwRAIAwgESAOKAIAIAkoAgBBARDrLA0CDAcLDBoLIAENBQsgDkEEaiEOIAlBBGohCSAEIAVBAWoiBUcNAAsMAgsMDgtBACEFIBQgA2siAEEAIAAgFE0bIQcgECACayIAQQAgACAQTRshBiAJIANBAnRqIQ4gCyACQQJ0aiEJA0AgBCAFRg0BIAUgBkYNGSAFIAdGDQMgBUEBaiEFIA4oAgAhASAJKAIAIQAgDkEEaiEOIAlBBGohCSAMIBEgACABQQEQ6ywNAAsgBUEBayEFDAELIAQhBQsgCEHwAGokACAEIAVNDAELDBQLIQUMAwsjAEHwAGsiCCQAIAhBGGogABDlHSAIKAIcIRAgCCgCGCELIAhBEGogARDlHQJAAkACQCAAKAIUBEAgASgCFEUNDSAAKAIQIQwgCCgCFCEUIAgoAhAhCSABKAIQIREgACgCLEUNASAIQQhqIABBLGoQ3DsgCEEwaiIFIAgoAgggCCgCDCAAKAI4IAJqIhggBBD6EyAIQSRqIAUQ1QkCQCAIKAIkQQFGBEAgCCgCKA0BIAgoAiwgBEcNAQwDCyAERQ0CCyABKAIsRQ0OIARFBEBBACEFDAQLQQAhBSABKAI8IgcgA2siBkEAIAYgB00bIRYgACgCPCIHIAJrIgZBACAGIAdNGyETIAsgAkEDdGohDiABKAI4IANqIQsgCSADQQN0aiEJIAEoAjAhByAAKAIwIQYDQCAFIBNGIAUgFkZyDRACQAJAIAYgBSAYaiIAQQN2ai0AAEEBIABBB3F0cSIBRQ0AIAcgBSALaiIAQQN2ai0AAEEBIABBB3F0cUUNACACIAVqIgAgEE8NGCAOKQMAIh1CgICAgBBaDRMgFCADIAVqIgBLBEAgCSkDACIcQoCAgIAQWg0VIAwgESAdpyAcp0EBEOssDQIMBwsMFwsgAQ0FCyAOQQhqIQ4gCUEIaiEJIAQgBUEBaiIFRw0ACwwCCwwLC0EAIQUgFCADayIAQQAgACAUTRshASAQIAJrIgBBACAAIBBNGyEAIAkgA0EDdGohCSALIAJBA3RqIQ4CQANAIAQgBUYNAiAAIAVGDQEgDikDACIdQoCAgIAQWg0TAkAgASAFRwRAIAkpAwAiHEKAgICAEFQNAQwUCwwXCyAFQQFqIQUgCUEIaiEJIA5BCGohDiAMIBEgHacgHKdBARDrLA0ACyAFQQFrIQUMAgsMFQsgBCEFCyAIQfAAaiQAIAQgBU0hBQwCCyAZQQA2AhggGUEBNgIMIBlB+MCHATYCCCAZQgQ3AhAgGUEIakGAwYcBEO8sAAtBAUEBQajAhwEQwyEACyAZQSBqJAAgBQ8LQZSqhwFBIEG0qocBEJ8pAAtBqMOHAUEgQcjDhwEQnykACyABIABB+L2HARCxOwALIAAgDUH4vYcBELA7AAtB6LyHAUEgQYi9hwEQnykAC0EAQQBByL6HARDDIQALQQBBAEHYvocBEMMhAAtB6L6HARCyOwALQZi+hwFBIEG4vocBEJ8pAAtByL+HARCyOwALQei/hwEQsjsAC0Gov4cBELI7AAtBiL+HARCyOwALIAAgFEHYv4cBEMMhAAsgACAQQbi/hwEQwyEACyADIAVqIBRBmL+HARDDIQALIAIgBWogEEH4vocBEMMhAAuvBwEGfyMAQfABayICJAAgAkEIaiABQShqKAIANgIAIAIgASkCIDcDACACIAEoAiwiBDYCECACIAEpAgA3AhQgAkGEAWogAUE4aigCADYCACACIAEpAjA3AnwgASgCPCEDIAIgASgCVCIFNgIcIAJBKGogAUEQaigCADYCACACIAEpAgg3AyAgAkE4aiABQRxqKAIANgIAIAIgASkCFDcDMCABLQBYIAEtAFkhByACIAJBFGo2AnggAiACQRBqNgJ0IAIgAkEcajYCcAJAAkACQCADBEAgAkHoAGogAUHQAGooAgA2AgAgAkHgAGogAUHIAGopAgA3AwAgAiABKQJANwNYIAIoAnwiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAkH8AGoQ+x4MAQsgAigCfCIBRQ0BIAIgAikCgAE3AtQBIAIgATYC0AEgAkHcAWogAkHQAWogBSAEEPIVAkAgAigCFEEBRgRAIAJBkAFqIAJB5AFqKQIANwMAIAJBmAFqIAJB7AFqKAIANgIAIAIgAikC3AE3A4gBIAIgAigCGDYCnAEMAQsgAkGIAWogAkHcAWoQ4ScLIAJB4ABqIAJBlAFqKQIANwMAIAJB6ABqIAJBnAFqKAIANgIAIAIgAikCjAE3A1ggAigCiAEiA0UNAQsgAkGUAWogAkHgAGoiASkDADcCACACQZwBaiACQegAaiIEKAIAIgU2AgAgAiADNgKIASACIAIpA1g3AowBIAVFBEAgAyADKAIAIgFBAWs2AgAgAUEBRw0BIAJBiAFqEPseDAELIAJB0ABqIAQoAgA2AgAgAkHIAGogASkDADcDACACIAIpA1g3A0AMAQtBACEDCyACQagBaiACQQhqKAIANgIAIAJBkAFqIAJBKGooAgA2AgAgAkGcAWogAkE4aigCADYCACACIAIpAwA3A6ABIAIgAigCEDYCrAEgAiACKAIcNgKwASACIAIpAyA3A4gBIAIgAikDMDcClAEgAiADNgK0ASACQcgBaiACQdAAaigCADYCACACQcABaiACQcgAaikDADcDACACIAIpA0A3A7gBQQFxBEAgAkGIAWoQvhALAkACQCAHQQFxDQAgAkHwAGogAkGIAWoiAxDnFiACKAJwIgFBk4CAgHhGDQAgACACKQJ0NwIIIABBEGogAkH8AGopAgA3AgAgAEGAgICAeDYCACAAIAE2AgQgAxCkHgwBCyAAIAJBiAFqQcQA/AoAAAsgAkHwAWokAAvLBwIBfwJ+IwBBkAFrIgMkACADIAI2AhAgAyABNgIMIANBIDsBFiADQfAAaiABIAIgA0EWahCVAwJAIAMoAnBBAUYEQCADQegAaiADQYQBaigCACIBNgIAIANB4ABqIANB/ABqKQIAIgQ3AwAgAyADKQJ0IgU3A1ggAEEQaiABNgIAIABBCGogBDcCACAAIAU3AgAMAQsgA0EgaiADQYABaikDACIENwMAIAMgAykDeDcDGCADQR42AogBIAMgBD4CPAJAIATEQh5+IgRCIIinIASnIgFBH3VHBEAgA0ECNgJ0IANB1MKAATYCcCADQgI3AnwgA0HFEDYCTCADQcUQNgJEIAMgA0FAazYCeCADIANBiAFqNgJIIAMgA0E8ajYCQCADQdwAaiADQfAAahCZDiADQThqIANB6ABqKAIANgIAIAMgAykCYDcCMCADQYiAgIB4NgIoIAMgAygCXDYCLAwBCyADIAMoAiQiAjYCiAEgAyABNgI8IAJBAEggASABIAJqIgFKRwRAIANBAjYCdCADQcDCgAE2AnAgA0ICNwJ8IANBxRA2AkwgA0HFEDYCRCADIANBQGs2AnggAyADQYgBajYCSCADIANBPGo2AkAgA0HcAGogA0HwAGoQmQ4gA0E4aiADQegAaigCADYCACADIAMpAmA3AjAgA0GIgICAeDYCKCADIAMoAlw2AiwMAQsgAykDGCIEIARCwIQ9fyIFQsCEPX5RBEAgBUKAgICACH1CgICAgHBUBEAgA0ECNgJ0IANBlMyAATYCcCADQgE3AnwgA0HuBjYCRCADIANBQGs2AnggAyADQRhqNgJAIANB3ABqIANB8ABqEJkOIANBOGogA0HoAGooAgA2AgAgAyADKQJgNwIwIANBjYCAgHg2AiggAyADKAJcNgIsDAILIAAgBT4CCCAAIAE2AgQgAEGTgICAeDYCAAwCCyADIAQ3A0AgA0ECNgJ0IANB0MuAATYCcCADQgE3AnwgA0HuBjYCXCADIANB2ABqNgJ4IAMgA0FAazYCWCADQSxqIANB8ABqEJkOIANBjYCAgHg2AigLIANB6ABqIANBOGooAgA2AgAgA0HgAGogA0EwaikCADcDACADIAMpAig3A1ggA0ECNgJ0IANBpMeAATYCcCADQgE3AnwgA0HMATYCjAEgAyADQYgBajYCeCADIANBDGo2AogBIANBxABqIANB8ABqEJkOIANB2ABqEIgRIAMpAkQhBCAAIAMpAkw3AgwgACAENwIEIABBgoCAgHg2AgALIANBkAFqJAALwBMCE38DfiMAQZAMayIJJAAgCUEMaiIPQQBBwAX8CwAgCUHMBWoiEEEAQcAF/AsAIAlBADYCjAsgCUGgC2pBADsBACAJQZgLakIANwMAIAlCADcDkAsgCUGkC2pBAEEk/AsAIAlByAtqQQBByAD8CwAgACEVIAEhDiAJQYwLaiETQQAhAQJAIAJFDQAgAEEBayEAIAJBAWsgDkkhDAJ/An8CQAJAAkADQCAMRQ0BIAAgAmotAAAEQCACIAFrIREgAkEySw0DQQAMBgsgAEEBayEAIAIgAUEBaiIBRw0ACyACQTJNDQUMAgsgAUF/cyACaiAOQeCV0gAQwyEACyABIAJGDQAgAiABayECIBVBAWohFkEBIQxBASEUA0ACQAJAIAggDkkEQEEBIQ0gCEEBaiARTw0CIAggFmohEiACIAhrIQ0gCEF/cyIAIA5qIRcgACACaiEaQQAhACAIIBVqLQAAIQEDQAJAIAAgF0cEQCAAIBJqLQAAIAFGDQEgAEEBaiENDAQLIA4gDkHgk9IAEMMhAAsgGiAAQQFqIgBHDQALDAELIAggDkHQk9IAEMMhAAsgAUUgDUECS3FFBEAgAUUgDUEESXINASAUQQFqIRQgCyANaiELDAELIAxBAWohDCAKIA1qIQoLIAggDWoiCCARSQ0ACyAUQQF0IQAgDEEBdAwBC0ECIQBBACERQQILIApJIRQgACALSQshFiARRQ0AIBMoAgAhAUEIIQxBACENAkACQANAAkACQAJAAkACQAJAAkACQAJ/An8CQAJAAkACQAJAAkACQCANIA5JBEAgDUEBaiEIIA0gFWoiCi0AACICBEBBASELIBYgCCARSXFFDQMMAgtBASELIBQgCCARSXENAQwQCyANIA5B8JXSABDDIQALIBEgDWshAAJAA0AgCyANaiAOTw0FIAogC2otAAAgAkcNASAAIAtBAWoiC0cNAAsgACELCyACRQ0BCyAMQf8BcSACRw0BIAEhCCALDAULAn8gC0ELRgRAIAFBwAVPDQQgASAPakEAOgAAIAFBwAVJBEAgASAQakEAOgAAIAFBAWohAUEHDAILIAFBwAVBkJXSABDDIQALIAtBA0kNDCALQQNrCyEKIAFBwAVJBH9BwAUgASABQcAFTRshCCABIQADQCAAIA9qQRE6AAACQCAAIAhHBEAgEyAAQQFqIgI2AgAgACAQaiAKQQdxOgAAIApBCE8NASAPIAEgAhDGHCAQIAEgAhDGHCACIQEMEQsgCEHABUGwldIAEMMhAAsgCkEDdkEBayEKIAIiAEHABUcNAAtBwAUFIAELQcAFQaCV0gAQwyEACyABQcAFTwRAIAFBwAVBgJTSABDDIQALIAEgD2ogAjoAACABQcAFSQ0CIAFBwAVBkJTSABDDIQALIA4gCCAIIA5JGyAOQYCW0gAQwyEACyABQcAFQYCV0gAQwyEACyATIAFBAWoiCDYCACABIBBqQQA6AAAgC0EBawsiAUEHRgRAIAhBwAVPDQIgCCAPaiACOgAAIAhBwAVJBEAgCCAQakEAOgAAIAhBAWohCEEDDAILIAhBwAVBsJTSABDDIQALIAFBA0kNAiABQQNrCyEKIAhBwAVJBH9BwAUgCCAIQcAFTRshDCAIIQADQCAAIA9qQRA6AAACQCAAIAxHBEAgEyAAQQFqIgE2AgAgACAQaiAKQQNxOgAAIApBBE8NASAPIAggARDGHCAQIAggARDGHAwGCyAMQcAFQdCU0gAQwyEACyAKQQJ2QQFrIQogASIAQcAFRw0AC0HABQUgCAtBwAVBwJTSABDDIQALIAhBwAVBoJTSABDDIQALIAFFBEAgCCEBDAELQQAhAEHABSAIayIMQQAgDEHABU0iEhshCiAMQQAgEhshDCAIIA9qIRIgCCAQaiEXA0AgACAMRg0DIAAgEmogAjoAACAAIApGDQIgACAXakEAOgAAIBMgACAIakEBajYCACAAQQFqIgAgAUcNAAsgACAIaiEBCyACIQwMBAsgACAIakHABUHwlNIAEMMhAAsgACAIakHABUHglNIAEMMhAAsgCw0AQQAhCwwBC0EAIQBBwAUgAWsiAkEAIAJBwAVNIgobIQggAkEAIAobIQIgASAPaiEKIAEgEGohEgNAIAAgAkYNBCAAIApqQQA6AAAgACAIRg0DIAAgEmpBADoAACATIAAgAWpBAWo2AgAgAEEBaiIAIAtHDQALIAAgAWohAQsgCyANaiINIBFJDQALDAILIAAgAWpBwAVB0JXSABDDIQALIAAgAWpBwAVBwJXSABDDIQALAkACQCAJKAKMCyIBBEBBACECA0AgAkHABUYNAyAJQQxqIAJqLQAAIgBBEk8NAiAJQcgLaiAAQQJ0aiIAIAAoAgBBAWo2AgAgASACQQFqIgJHDQALC0EAIQEgCUHIC2ohAgNAAkACQCACKAIARQRAIBghCCAZIQAMAQtBASEAIAEhCCAZRQ0AQQIhACAYIQgMAQsgAkEEaiECIAAhGSAIIRggAUEBaiIBQRJHDQELCyAJQcgLakESQRJBBSADIAQgCUGQC2oiAUESEOsIIAFBEkESIAlBpAtqQRIQswtCEiEcAkAgAEECSQ0AQhIhG0GN49EAIQIDQAJAIAItAAAiAUERTQRAIAlBkAtqIAFqLQAARQ0BIBshHAwDCyABQRJBvObRABDDIQALIAJBAWshAkIAIRwgG0IBfSIbQgBSDQALC0ECQgBCAkIDIAktAJMLGyAJLQCRCyAJLQCSC3IbIh0gBSAGIAcQ5RICQAJAAkACQAJAIBwgHVYEQCAcIB19IRsgHachAgNAIAJBEUsNAiACQfzi0QBqLQAAIgFBEk8NAyAJQZALaiABai0AACIBQQZPDQQgAUGU49EAai0AACABQY7j0QBqMQAAIAUgBiAHEOUSIAJBAWohAiAbQgF9IhtQRQ0ACwsgAEEBRgRAIAlBkAtqIAhqQQA6AAALIAkoAowLIgMEQEEAIQIDQCACQcAFRg0FIAlBDGogAmotAAAiAUESTw0GIAlBkAtqIAFqLQAAIAlBpAtqIAFBAXRqMwEAIAUgBiAHEOUSQQMhAAJAAkACQCABQRBrDgIAAQILQQIhAAsgACAJQcwFaiACajEAACAFIAYgBxDlEgsgAyACQQFqIgJHDQALCyAJQZAMaiQADwtBEkESQczm0QAQwyEACyABQRJB3ObRABDDIQALIAFBBkHs5tEAEMMhAAtBwAVBwAVB/ObRABDDIQALIAFBEkGM59EAEMMhAAsgAEESQazn0QAQwyEAC0HABUHABUGc59EAEMMhAAu+BQEGfyMAQdAOayIGJAAgBkEIaiIIQQBBiAj8CwAgBkGQCGoiB0EAQcAF/AsAIAZB0A1qIglBAEGAAfwLACAAQYABQcAAQQ8gCEGBASABQYABEOsIIABBgAJqQcAAQcAAQQ4gCEGBASABQUBrIghBwAAQ6wggB0EYIAFBGEHoiNIAENUsIAZBqAhqQQggAUEoakEIQeiI0gAQ1SwgBkGwCGpBCCABQRhqIgpBCEHoiNIAENUsIAZBuAhqQQggAUEwakEIQeiI0gAQ1SwgBkHACGpBCCABQSBqIgtBCEHoiNIAENUsIAZByAhqQQggAUE4aiIAQQhB6IjSABDVLCAHQcAFQcAAIAlBwAAQswsgAiAJQTD8CgAAIAIgBikBkA43ATAgAkE4aiAGQZgOaikBADcBACACIAYpAbAONwFAIAJByABqIAZBuA5qKQEANwEAIAIgBikBgA43AVAgAkHYAGogBkGIDmopAQA3AQAgAiAGKQGgDjcBYCACQegAaiAGQagOaikBADcBACACIAYpAcAONwFwIAJB+ABqIAZByA5qKQEANwEAIAhBwABBwAAgAkGAAWpBwAAQswtBACECIAdBAEHAAPwLACAHQQggAUEIQeiI0gAQ1SwgBkHQCGpBCCABQQhqQQhB6IjSABDVLCAGQZAJakEIIAFBEGpBCEHoiNIAENUsIAZB0AlqQQggCkEIQeiI0gAQ1SwgBkGQC2pBCCALQQhB6IjSABDVLCAAIQEDQCAGQZAIaiIHIAJqIgBBgAFqIAFBEGstAAA6AAAgAEGAAmogAUEIay0AADoAACAAQcADaiABLQAAOgAAIAFBAWohASACQQhqIgJBwABHDQALIAdBwAVBwAUgBkEIaiIAQYEBIAMgBCAFEOEHIAhBwABBwAAgAEGBASADIAQgBRDhByAGQdAOaiQAC+UHAgN/AX4jAEHQAWsiAyQAIANBlAFqIAEgAhCTDiADKAKYASEEAkAgAygClAEiBUGKgICAeEcEQCADQShqIANBtAFqKAIANgIAIANBIGogA0GsAWopAgA3AgAgA0EYaiADQaQBaikCADcCACADIAMpApwBNwIQIAMgBDYCDCADIAU2AggMAQsgA0GUAWogAUF/IAIgBGoiASABIARJGxC0BiADQdgAaiIBIANBoAFqKQIANwMAIAMgAykCmAE3A1AgAygClAEiBEGKgICAeEcEQCADQSRqIANBsAFqKQIANwIAIANBFGogASkDADcCACADIAMpAqgBNwIcIAMgAykDUDcCDCADIAQ2AggMAQsgA0HoAGogASkDADcDACADIAMpA1A3A2AgA0GUAWogA0HgAGpBBBDdECADKAKcASEBIAMoApgBIQQCQAJ+IAMoApQBIgVBioCAgHhHBEAgA0HAAWogA0GwAWopAgA3AwAgAyADKQKoATcDuAEgAykCoAEMAQsgBEEBcUUNAQJAIAFBAXEEQCADIAE2ArABIANBAzYCrAEgA0G55P4ANgKoASADQYCAgIB4NgKkASADQgQ3ApwBIANChICAgAg3ApQBDAELQX8gAUECaiIEIAEgBEsbIgUgAygCYCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgKUAQwCCyADQYiAgIB4NgKUAQwBCyADQZQBaiABIAUQvy8LIANBBDYCyAEgA0G55/4ANgLEASADQYCAgIB4NgLAASADIAE2ArwBIANBATYCuAEgA0HwAGogA0GUAWogA0G4AWoQgRQgAygCcCIFQYqAgIB4Rg0BIANBwAFqIANBjAFqKQIANwMAIAMgAykChAE3A7gBIAMoAnghASADKAJ0IQQgAykCfAshBiADQSRqIANBwAFqKQMANwIAIAMgBjcCFCADIAE2AhAgAyAENgIMIAMgBTYCCCADIAMpA7gBNwIcDAELIAMgAykDaDcCnAEgAyADKQNgNwKUASADQSxqIANBlAFqQb3n/gBBCEEGEK0IIAMoAjAhASADKAIsIgRBioCAgHhHBEAgA0EYaiADQTxqKAIANgIAIANBJGogA0HIAGopAgA3AgAgAyADKQI0NwIQIAMgAykCQDcCHCADIAE2AgwgAyAENgIIDAELIAEgASgCDEEBazYCDCADQYqAgIB4NgIICyADQQ82AqQBIANBj+n+ADYCoAEgA0GAgICAeDYCnAEgAyACNgKYASADQQI2ApQBIAAgA0EIaiADQZQBahCBFCADQdABaiQAC+YHAQV/IwBB4ABrIgYkACAGIAQ2AhAgBiADNgIMIAYgATYCCCAGIAIoAggiB0ECdkEBayIJNgIUAkACQAJAAkACQCAHQQRJDQAgAigCBCAHQXxxakEEayIHRQ0AIAYgBygCACIINgIYAkACQCADIAQoAghBAWtBeHFqQQhqIgcgBCgCJCIKEQQAIAhPBEACQCAFKAIAIggEQCAJIAUoAhAiCUcNAQsgAS0ASEUEQCAHIAQoAkwRBAANAwsgAUEwaiIJIAcgBCgCHCIKEQQAEMUIRQ0DIAAgBDYCECAAIAM2AgwgACABNgIEIABBGzoAACAAIAUpAgA3AiAgACACKQIANwIUIABBMGogBUEQaikCADcCACAAQShqIAVBCGopAgA3AgAgAEEcaiACQQhqKAIANgIADAgLIAYgCTYCPCAGQQM2AiAgBkGs04UBNgIcIAZCAzcCKCAGQTs2AlQgBkE7NgJMIAZBxwI2AkQgBkHk0oUBNgJAIAYgBkFAazYCJCAGIAZBPGo2AlAgBiAGQRRqNgJIIABBCGogBkEcahCZDiAAQSk6AAAgAEGNgICAeDYCBAwFCyAGIAcgChEEADYCPCAGQQI2AkQgBkGA1YUBNgJAIAZCAjcCTCAGQTs2AiggBkE7NgIgIAYgBkEcajYCSCAGIAZBPGo2AiQgBiAGQRhqNgIcIABBCGogBkFAaxCZDiAAQSk6AAAgAEGNgICAeDYCBCAFKAIAIQgMAwsgBiABQTxqNgI8IAZBAzYCRCAGQfzThQE2AkAgBkICNwJMIAZBygQ2AiggBkHHAjYCICAGQeTShQE2AhwgBiAGQRxqNgJIIAYgBkE8ajYCJCAAQQhqIAZBQGsQmQ4gAEEpOgAAIABBjYCAgHg2AgQMAgsgBiAJNgI0IAYgByAKEQQANgI4IAYgAUE8ajYCPCAGQQQ2AiAgBkG41IUBNgIcIAZCBDcCKCAGQcoENgJcIAZBpwQ2AlQgBkGnBDYCTCAGQccCNgJEIAZB5NKFATYCQCAGIAZBQGs2AiQgBiAGQTxqNgJYIAYgBkE4ajYCUCAGIAZBNGo2AkggAEEIaiAGQRxqEJkOIABBKToAACAAQY2AgIB4NgIEDAELQdTShQEQsjsACyAIRQ0BCyAIIAgoAgAiAEEBazYCACAAQQFHDQAgBRD7HgsgBigCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBkEMahC7IwsgAigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgAhD7HgsgBigCCCIAIAAoAgAiAEEBazYCACAAQQFHDQAgBkEIahDyJQsgBkHgAGokAAvmBwEFfyMAQeAAayIGJAAgBiAENgIQIAYgAzYCDCAGIAE2AgggBiACKAIIIgdBA3ZBAWsiCTYCFAJAAkACQAJAAkAgB0EISQ0AIAIoAgQgB0F4cWpBCGsiB0UNACAGIAcoAgAiCDYCGAJAAkAgAyAEKAIIQQFrQXhxakEIaiIHIAQoAiQiChEEACAITwRAAkAgBSgCACIIBEAgCSAFKAIQIglHDQELIAEtAEhFBEAgByAEKAJMEQQADQMLIAFBMGoiCSAHIAQoAhwiChEEABDFCEUNAyAAIAQ2AhAgACADNgIMIAAgATYCBCAAQR46AAAgACAFKQIANwIgIAAgAikCADcCFCAAQTBqIAVBEGopAgA3AgAgAEEoaiAFQQhqKQIANwIAIABBHGogAkEIaigCADYCAAwICyAGIAk2AjwgBkEDNgIgIAZBrNOFATYCHCAGQgM3AiggBkE7NgJUIAZBOzYCTCAGQccCNgJEIAZBmNWFATYCQCAGIAZBQGs2AiQgBiAGQTxqNgJQIAYgBkEUajYCSCAAQQhqIAZBHGoQmQ4gAEEpOgAAIABBjYCAgHg2AgQMBQsgBiAHIAoRBAA2AjwgBkECNgJEIAZBgNWFATYCQCAGQgI3AkwgBkE7NgIoIAZBOzYCICAGIAZBHGo2AkggBiAGQTxqNgIkIAYgBkEYajYCHCAAQQhqIAZBQGsQmQ4gAEEpOgAAIABBjYCAgHg2AgQgBSgCACEIDAMLIAYgAUE8ajYCPCAGQQM2AkQgBkH804UBNgJAIAZCAjcCTCAGQcoENgIoIAZBxwI2AiAgBkGY1YUBNgIcIAYgBkEcajYCSCAGIAZBPGo2AiQgAEEIaiAGQUBrEJkOIABBKToAACAAQY2AgIB4NgIEDAILIAYgCTYCNCAGIAcgChEEADYCOCAGIAFBPGo2AjwgBkEENgIgIAZBuNSFATYCHCAGQgQ3AiggBkHKBDYCXCAGQacENgJUIAZBpwQ2AkwgBkHHAjYCRCAGQZjVhQE2AkAgBiAGQUBrNgIkIAYgBkE8ajYCWCAGIAZBOGo2AlAgBiAGQTRqNgJIIABBCGogBkEcahCZDiAAQSk6AAAgAEGNgICAeDYCBAwBC0HU0oUBELI7AAsgCEUNAQsgCCAIKAIAIgBBAWs2AgAgAEEBRw0AIAUQ+x4LIAYoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAZBDGoQuyMLIAIoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAIQ+x4LIAYoAggiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAZBCGoQ8iULIAZB4ABqJAALqwcBCn8jAEFAaiIEJAACQAJAAkACQAJAAkACQAJAIAIoAhQiBUUNACACKAIQIAVBDGxqIgZBDEYNACAGQQhrKAIAIAEoAgRHDQAgBkEEaygCACABKAIIRg0BCyABKAIAIgUgBSgCACIGQQFqNgIAIAZBAEgNAiABKAIIIQcgASgCBCEIIAIoAhQiCiACKAIMRgRAIAJBDGpBjITNABCQKAsgAigCECAKQQxsaiIGIAc2AgggBiAINgIEIAYgBTYCACACIApBAWo2AhQMAQsgBUEBayEKCyABKAIQIQUgBCABENw7IAQoAgQhDSAEKAIAIQsgAiAFIAMgAyAFSxsiCBDrLSABKAIMIQMgCEUNASADIAEoAggiCU8NASAIQQFrIQwgAyEFA0ACQAJAAkAgCSADQQRqIgdPBEAgAyALaigAACIJIAdqIgYgDUsNASAJQYABSQ0DIAEtABRBAXENAgwDCyAEQSBqQRdBAEEBQQEQoBggBCgCJCECIAQoAiBBAUYNCCAEKAIoIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwHCyAEQSBqQRdBAEEBQQEQoBggBCgCJCECIAQoAiBBAUYNByAEKAIoIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwGCyAEQQxqIAUgC2ogAyAFaxCdCSAEKAIMQQFGBEAgBCAEKQIQNwMYIARBATYCJCAEQfCIzQA2AiAgBEIBNwIsIARBsAM2AjwgBCAEQThqNgIoIAQgBEEYajYCOCAAQQRqIARBIGoQmQ4gAEEANgIADAYLIAchBQwACyACIAogByAJEI0aIAEgBjYCDCAGIAEoAggiCU8NAyAMQQBHIAxBAWshDCAGIQMNAAsMAgsACyADIgUhBgsCQCABLQAURQ0AIARBDGogBSALaiAGIAVrEJ0JIAQoAgxBAUcNACAEIAQpAhA3AxggBEEBNgIkIARB8IjNADYCICAEQgE3AiwgBEGwAzYCPCAEIARBOGo2AiggBCAEQRhqNgI4IABBBGogBEEgahCZDiAAQQA2AgAMAQsgACAINgIEIABBCDYCACABIAEoAhAgCGs2AhALIARBQGskAA8LIAIgBCgCKEHU/cwAEP0vAAvGBwIHfwV+IwBB8AhrIgQkACABvSELAn9BAyABmUQAAAAAAADwf2ENABpBAiALQoCAgICAgID4/wCDIgxCgICAgICAgPj/AFENABogC0L/////////B4MiD0KAgICAgICACIQgC0IBhkL+////////D4MgC0I0iKdB/w9xIgUbIg1CAYMhDiAMUARAQQQgD1ANARogBUGzCGshBUIBIQwgDlAMAQtCgICAgICAgCAgDUIBhiANQoCAgICAgIAIUSIIGyENQgJCASAIGyEMQct3Qcx3IAgbIAVqIQUgDlALIQYgA0H//wNxIQggBCAFOwHoCCAEIAw3A+AIIARCATcD2AggBCANNwPQCCAEIAY6AOoIAn8CQAJAIAZB/wFxIgdBAU0EQEF0QQUgBcEiBUEASBsgBWwiBUHA/QBJDQFB/euJAUElQaTsiQEQnykACyAHQQJGDQFBASEFQe7riQFB7+uJASALQgBTIgcbQe7riQFBASAHGyACGyEHQQEgC0I/iKcgAhshAiAGQf8BcUEERwRAIARBAzYCmAggBEHz64kBNgKUCCAEQQI7AZAIIARBkAhqDAMLQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAMLIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAgtB7uuJAUEBIAtCAFMiBhshB0Hu64kBQe/riQEgBhsgC0I/iKchCSAEQZAIaiAEQdAIaiAEQRBqIAVBBHZBFWoiCkGAgH5BACADayADwUEASBsiBRCZCCAFwSEFAkAgBCgCkAgEQCAEQcgIaiAEQZgIaigCADYCACAEIAQpApAINwPACAwBCyAEQcAIaiAEQdAIaiAEQRBqIAogBRCaAQsgByACGyEHQQEgCSACGyECIAUgBC4ByAgiBkgEQCAEQQhqIAQoAsAIIAQoAsQIIAYgCCAEQZAIahDtDyAEKAIMIQUgBCgCCAwCC0ECIQUgBEECOwGQCCADQf//A3FFBEBBASEFIARBATYCmAggBEH264kBNgKUCCAEQZAIagwCCyAEIAg2AqAIIARBADsBnAggBEECNgKYCCAEQcXriQE2ApQIIARBkAhqDAELIARBAzYCmAggBEHw64kBNgKUCCAEQQI7AZAIQQEhB0EAIQJBASEFIARBkAhqCyEDIAQgBTYCzAggBCADNgLICCAEIAI2AsQIIAQgBzYCwAggACAEQcAIahC1CiAEQfAIaiQAC68GAQV/IABB//8DcSEEIABBEHYhAwJAAkACQCACDgICAAELIAQgAS0AAGoiACAAQfH/A2sgAEHx/wNJGyIAIANqQfH/A3BBEHQgAGoPCwJAAkAgAkEQTwRAIAIgAkGwK3AiB2siAkGwK0kNAiABIQUgAiEGDAELA0AgBCABLQAAaiIEIANqIQMgAUEBaiEBIAJBAWsiAg0ACyAEQfH/A3AgA0Hx/wNwQRB0cg8LA0BBACEAA0AgAyAEIAAgBWoiAy0AAGoiBGogBCADQQFqLQAAaiIEaiAEIANBAmotAABqIgRqIAQgA0EDai0AAGoiBGogBCADQQRqLQAAaiIEaiAEIANBBWotAABqIgRqIAQgA0EGai0AAGoiBGogBCADQQdqLQAAaiIEaiAEIANBCGotAABqIgRqIAQgA0EJai0AAGoiBGogBCADQQpqLQAAaiIEaiAEIANBC2otAABqIgRqIAQgA0EMai0AAGoiBGogBCADQQ1qLQAAaiIEaiAEIANBDmotAABqIgRqIAQgA0EPai0AAGoiBGohAyAAQRBqIgBBsCtHDQALIANB8f8DcCEDIARB8f8DcCEEIAVBsCtqIQUgBkGwK2siBkGwK08NAAsLIAEgAmohASAHQQ9xIQAgB0HwP3EiBgRAQQAgBmshBSABIQIDQCADIAQgAi0AAGoiA2ogAyACQQFqLQAAaiIDaiADIAJBAmotAABqIgNqIAMgAkEDai0AAGoiA2ogAyACQQRqLQAAaiIDaiADIAJBBWotAABqIgNqIAMgAkEGai0AAGoiA2ogAyACQQdqLQAAaiIDaiADIAJBCGotAABqIgNqIAMgAkEJai0AAGoiA2ogAyACQQpqLQAAaiIDaiADIAJBC2otAABqIgNqIAMgAkEMai0AAGoiA2ogAyACQQ1qLQAAaiIDaiADIAJBDmotAABqIgNqIAMgAkEPai0AAGoiBGohAyACQRBqIQIgBUEQaiIFDQALCyAABEAgASAGaiECA0AgBCACLQAAaiIEIANqIQMgAkEBaiECIABBAWsiAA0ACwsgBEHx/wNwIANB8f8DcEEQdHIhAAsgAAukBwIHfwN+IwBB8AhrIgQkACABvCEHAn9BAyABi0MAAIB/Ww0AGkECIAdBgICA/AdxIgVBgICA/AdGDQAaIAdB////A3EiCEGAgIAEciAHQQF0Qf7//wdxIAdBF3ZB/wFxIgYbIgmtIgtCAYMhDCAFRQRAQQQgCEUNARogBkGWAWshBkIBIQ0gDFAMAQtCgICAECALQgGGIAlBgICABEYiCBshC0ICQgEgCBshDUHofkHpfiAIGyAGaiEGIAxQCyEFIANB//8DcSEIIAQgBjsB6AggBCANNwPgCCAEQgE3A9gIIAQgCzcD0AggBCAFOgDqCAJ/AkACQCAFQf8BcUEBTQRAQXRBBSAGwSIFQQBIGyAFbCIFQcD9AEkNAUH964kBQSVBpOyJARCfKQALIAVB/wFxIglBAkYNAUEBIQVB7uuJAUHv64kBIAdBAEgiBhtB7uuJAUEBIAYbIAIbIQZBASAHQR92IAIbIQIgCUEERwRAIARBAzYCmAggBEHz64kBNgKUCCAEQQI7AZAIIARBkAhqDAMLQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAMLIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAgtB7uuJAUEBIAdBAEgiBhshCUHu64kBQe/riQEgBhsgB0EfdiEHIARBkAhqIARB0AhqIARBEGogBUEEdkEVaiIKQYCAfkEAIANrIAPBQQBIGyIFEJkIIAXBIQUCQCAEKAKQCARAIARByAhqIARBmAhqKAIANgIAIAQgBCkCkAg3A8AIDAELIARBwAhqIARB0AhqIARBEGogCiAFEJoBCyAJIAIbIQZBASAHIAIbIQIgBSAELgHICCIHSARAIARBCGogBCgCwAggBCgCxAggByAIIARBkAhqEO0PIAQoAgwhBSAEKAIIDAILQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQfbriQE2ApQIIARBkAhqDAILIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBxeuJATYClAggBEGQCGoMAQsgBEEDNgKYCCAEQfDriQE2ApQIIARBAjsBkAhBASEGQQAhAkEBIQUgBEGQCGoLIQMgBCAFNgLMCCAEIAM2AsgIIAQgAjYCxAggBCAGNgLACCAAIARBwAhqELUKIARB8AhqJAALqgwCBH4IfyMAQdABayIFJAAgBUEHIAQgBEH/AXFBAkkbIgQ6AA8CQAJAAkACQAJAIAEoAgxFDQAgAUEQaiAFQQ9qEOwMIQYgASgCACIQQQxrIREgASgCBCIMIAancSELIAZCGYhC/wCDQoGChIiQoMCAAX4hCCAFLQAPIQQDQAJAIAsgEGopAAAiByAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIBEgBnqnQQN2IAtqIAxxQXRsai0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgByAHQgGGg0KAgYKEiJCgwIB/g1BFDQIgCyAKQQhqIgpqIAxxIQsMAQsLIAVB+ABqQStBAEEBQQEQoBggBSgCfCEDIAUoAnhBAUYNASAFKAKAASIBQZiqzgBBK/wKAAAgAEErNgIMIAAgATYCCCAAIAM2AgQgAEEANgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgBEH/AXFBB0cEQCAFQQE2AnwgBUHIqc4ANgJ4IAVCATcChAEgBUGuAzYCFCAFIAVBEGo2AoABIAUgBUEPajYCECAAQQRqIAVB+ABqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIAEoAiBBCGoQ3iUhESACKAIAIQogBUHwAGoiBCACQQxqKAIANgIAIAUgAikCBDcDaCAFQQA6AGAgBUKAgICAwAA3A1AgBUIANwNYIAVCAjcDEEHAAEEIEK02IgJFDQEgAiAKNgIgIAJBADYCACACIAUpA2g3AiQgAiARNgI4IAJBADYCNCACIAM2AjAgAkEsaiAEKAIANgIAIAVB+ABqIQQjAEEgayIKJAAgCiACNgIAIApBxKrOADYCBCAFQRBqIgNBQGsgAkHcqs4AKAIAEQQAEIYtIApBCGogAiADKAJEIAMoAkhB1KrOACgCABEFAAJAIAooAggiAkEIRwRAIAQgCikDEDcDCCAEQRBqIApBGGopAwA3AwAgBCAKKAIMNgIEDAELIANBAToAUAsgChC8KiAEIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiAEIANB2AD8CgAAQdgAQQgQrTYiA0UNAyADIARB2AD8CgAAQQAhC0EAIREjAEEQayIMJAAgDCACOgAPIAFBEGoiBCAMQQ9qEOwMIQYgASgCCEUEQCAMIAEgBBCnCCAMLQAPIQILIAEoAgQiECAGp3EhDSAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIQ4gAkH/AXEhBANAAkACfwJAAkACQCANIA5qKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAOIAZ6p0EDdiANaiAQcUF0bGoiCkEMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIAtFBEAgBlANAyAGeqdBA3YgDWogEHEhDwtBASAGIAlCAYaDUA0DGkEAIQ0gDiAPaiwAACILQQBOBEAgDiAOKQMAQoCBgoSIkKDAgH+DeqdBA3YiD2otAAAhCwsgDiAPaiAHp0H/AHEiBDoAACAOIA9BCGsgEHFqQQhqIAQ6AAAgASABKAIIIAtBAXFrNgIIIAEgASgCDEEBajYCDCAOIA9BdGxqIgRBCGsgAzYCACAEQQRrQeiqzgA2AgAgBEEMayACOgAADAELIApBBGsiASgCACEEIAFB6KrOADYCACAKQQhrIgEoAgAhDSABIAM2AgALIAUgBDYCBCAFIA02AgAgDEEQaiQADAILQQALIQsgDSARQQhqIhFqIBBxIQ0MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEJsuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAvMDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAIoAgAhCyAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgIDAADcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAs2AiAgAkEANgIAIAIgBSkDaDcCJCACIAw2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohCyMAQSBrIgokACAKQYyrzgA2AgQgCiACNgIAAkAgAkGkq84AKAIAEQQAIgwgBUEQaiIEKAJIIgNNBEAgBCAMNgJIDAELIARBQGsgDCADaxCEHyAEKAJIIQwLIApBCGogAiAEKAJEIAxBnKvOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCsCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQbCrzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFBsKvOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEJsuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAvhDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIgpBDGshDCABKAIEIg4gBqdxIQ0gBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCiANaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgDCAGeqdBA3YgDWogDnFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiANIAtBCGoiC2ogDnEhDQwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSEMIAIoAgAhCyAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgIDAADcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAs2AiAgAkEANgIAIAIgBSkDaDcCJCACIAw2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohCyMAQSBrIgokACAKQdSrzgA2AgQgCiACNgIAIAJB7KvOACgCABEEACEMIApBADYCECAKQgA3AggCQCAFQRBqIgQoAkgiAyAMTwRAIAQgDDYCSAwBCyAEQUBrIAwgA2sgCkEIahCEGCAEKAJIIQwLIApBCGogAiAEKAJEIAxB5KvOACgCABEFAAJAIAooAggiAkEIRwRAIAsgCikDEDcDCCALQRBqIApBGGopAwA3AwAgCyAKKAIMNgIEDAELIARBAToAUAsgChC8KiALIAI2AgAgCkEgaiQAIAUoAngiAkEIRgRAIAUtAA8hAiALIARB2AD8CgAAQdgAQQgQrTYiA0UNAyADIAtB2AD8CgAAQQAhDUEAIQwjAEEQayIOJAAgDiACOgAPIAFBEGoiBCAOQQ9qEOwMIQYgASgCCEUEQCAOIAEgBBCpCCAOLQAPIQILIAEoAgQiCiAGp3EhDyAGQhmIIgdC/wCDQoGChIiQoMCAAX4hCCABKAIAIRAgAkH/AXEhBANAAkACfwJAAkACQCAPIBBqKQAAIgkgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAQIAZ6p0EDdiAPaiAKcUF0bGoiC0EMay0AAEYNAiAGQgF9IAaDIgZQRQ0ACwsgCUKAgYKEiJCgwIB/gyEGIA1FBEAgBlANAyAGeqdBA3YgD2ogCnEhEQtBASAGIAlCAYaDUA0DGkEAIQ8gECARaiwAACINQQBOBEAgECAQKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhDQsgECARaiAHp0H/AHEiBDoAACAQIBFBCGsgCnFqQQhqIAQ6AAAgASABKAIIIA1BAXFrNgIIIAEgASgCDEEBajYCDCAQIBFBdGxqIgRBCGsgAzYCACAEQQRrQfirzgA2AgAgBEEMayACOgAADAELIAtBBGsiASgCACEEIAFB+KvOADYCACALQQhrIgEoAgAhDyABIAM2AgALIAUgBDYCBCAFIA82AgAgDkEQaiQADAILQQALIQ0gDyAMQQhqIgxqIApxIQ8MAQsLAkAgBSgCACIDRQ0AIAUoAgQiAigCACIBBEAgAyABEQMACyACKAIEIgFFDQAgAyABIAIoAggQ+DoLIABBCDYCAAwECyAAIAUpAnw3AgQgAEEUaiAFQYwBaigCADYCACAAQQxqIAVBhAFqKQIANwIAIAAgAjYCACAFQRBqEMwuDAMLIAMgBSgCgAFB2KfOABD9LwALQQhBwAAQoz0AC0EIQdgAEKM9AAsgBUHQAWokAAuqDAIEfgh/IwBB0AFrIgUkACAFQQcgBCAEQf8BcUECSRsiBDoADwJAAkACQAJAAkAgASgCDEUNACABQRBqIAVBD2oQ7AwhBiABKAIAIhBBDGshESABKAIEIgwgBqdxIQsgBkIZiEL/AINCgYKEiJCgwIABfiEIIAUtAA8hBANAAkAgCyAQaikAACIHIAiFIgZCf4UgBkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIGUEUEQANAIAQgESAGeqdBA3YgC2ogDHFBdGxqLQAARg0CIAZCAX0gBoMiBlBFDQALCyAHIAdCAYaDQoCBgoSIkKDAgH+DUEUNAiALIApBCGoiCmogDHEhCwwBCwsgBUH4AGpBK0EAQQFBARCgGCAFKAJ8IQMgBSgCeEEBRg0BIAUoAoABIgFBmKrOAEEr/AoAACAAQSs2AgwgACABNgIIIAAgAzYCBCAAQQA2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyAEQf8BcUEHRwRAIAVBATYCfCAFQcipzgA2AnggBUIBNwKEASAFQa4DNgIUIAUgBUEQajYCgAEgBSAFQQ9qNgIQIABBBGogBUH4AGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMBAsgASgCIEEIahDeJSERIAIoAgAhCiAFQfAAaiIEIAJBDGooAgA2AgAgBSACKQIENwNoIAVBADoAYCAFQoCAgICAATcDUCAFQgA3A1ggBUICNwMQQcAAQQgQrTYiAkUNASACIAo2AiAgAkEANgIAIAIgBSkDaDcCJCACIBE2AjggAkEANgI0IAIgAzYCMCACQSxqIAQoAgA2AgAgBUH4AGohBCMAQSBrIgokACAKIAI2AgAgCkGcrM4ANgIEIAVBEGoiA0FAayACQbSszgAoAgARBAAQhy0gCkEIaiACIAMoAkQgAygCSEGsrM4AKAIAEQUAAkAgCigCCCICQQhHBEAgBCAKKQMQNwMIIARBEGogCkEYaikDADcDACAEIAooAgw2AgQMAQsgA0EBOgBQCyAKELwqIAQgAjYCACAKQSBqJAAgBSgCeCICQQhGBEAgBS0ADyECIAQgA0HYAPwKAABB2ABBCBCtNiIDRQ0DIAMgBEHYAPwKAABBACELQQAhESMAQRBrIgwkACAMIAI6AA8gAUEQaiIEIAxBD2oQ7AwhBiABKAIIRQRAIAwgASAEEKgIIAwtAA8hAgsgASgCBCIQIAancSENIAZCGYgiB0L/AINCgYKEiJCgwIABfiEIIAEoAgAhDiACQf8BcSEEA0ACQAJ/AkACQAJAIA0gDmopAAAiCSAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIA4gBnqnQQN2IA1qIBBxQXRsaiIKQQxrLQAARg0CIAZCAX0gBoMiBlBFDQALCyAJQoCBgoSIkKDAgH+DIQYgC0UEQCAGUA0DIAZ6p0EDdiANaiAQcSEPC0EBIAYgCUIBhoNQDQMaQQAhDSAOIA9qLAAAIgtBAE4EQCAOIA4pAwBCgIGChIiQoMCAf4N6p0EDdiIPai0AACELCyAOIA9qIAenQf8AcSIEOgAAIA4gD0EIayAQcWpBCGogBDoAACABIAEoAgggC0EBcWs2AgggASABKAIMQQFqNgIMIA4gD0F0bGoiBEEIayADNgIAIARBBGtBwKzOADYCACAEQQxrIAI6AAAMAQsgCkEEayIBKAIAIQQgAUHArM4ANgIAIApBCGsiASgCACENIAEgAzYCAAsgBSAENgIEIAUgDTYCACAMQRBqJAAMAgtBAAshCyANIBFBCGoiEWogEHEhDQwBCwsCQCAFKAIAIgNFDQAgBSgCBCICKAIAIgEEQCADIAERAwALIAIoAgQiAUUNACADIAEgAigCCBD4OgsgAEEINgIADAQLIAAgBSkCfDcCBCAAQRRqIAVBjAFqKAIANgIAIABBDGogBUGEAWopAgA3AgAgACACNgIAIAVBEGoQmS4MAwsgAyAFKAKAAUHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQdABaiQAC8wMAgR+CH8jAEHQAWsiBSQAIAVBByAEIARB/wFxQQJJGyIEOgAPAkACQAJAAkACQCABKAIMRQ0AIAFBEGogBUEPahDsDCEGIAEoAgAiCkEMayEMIAEoAgQiDiAGp3EhDSAGQhmIQv8Ag0KBgoSIkKDAgAF+IQggBS0ADyEEA0ACQCAKIA1qKQAAIgcgCIUiBkJ/hSAGQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgZQRQRAA0AgBCAMIAZ6p0EDdiANaiAOcUF0bGotAABGDQIgBkIBfSAGgyIGUEUNAAsLIAcgB0IBhoNCgIGChIiQoMCAf4NQRQ0CIA0gC0EIaiILaiAOcSENDAELCyAFQfgAakErQQBBAUEBEKAYIAUoAnwhAyAFKAJ4QQFGDQEgBSgCgAEiAUGYqs4AQSv8CgAAIABBKzYCDCAAIAE2AgggACADNgIEIABBADYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAQLIARB/wFxQQdHBEAgBUEBNgJ8IAVByKnOADYCeCAFQgE3AoQBIAVBrgM2AhQgBSAFQRBqNgKAASAFIAVBD2o2AhAgAEEEaiAFQfgAahCZDiAAQQE2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwECyABKAIgQQhqEN4lIQwgAigCACELIAVB8ABqIgQgAkEMaigCADYCACAFIAIpAgQ3A2ggBUEAOgBgIAVCgICAgIABNwNQIAVCADcDWCAFQgI3AxBBwABBCBCtNiICRQ0BIAIgCzYCICACQQA2AgAgAiAFKQNoNwIkIAIgDDYCOCACQQA2AjQgAiADNgIwIAJBLGogBCgCADYCACAFQfgAaiELIwBBIGsiCiQAIApB5KzOADYCBCAKIAI2AgACQCACQfyszgAoAgARBAAiDCAFQRBqIgQoAkgiA00EQCAEIAw2AkgMAQsgBEFAayAMIANrEIMfIAQoAkghDAsgCkEIaiACIAQoAkQgDEH0rM4AKAIAEQUAAkAgCigCCCICQQhHBEAgCyAKKQMQNwMIIAtBEGogCkEYaikDADcDACALIAooAgw2AgQMAQsgBEEBOgBQCyAKELwqIAsgAjYCACAKQSBqJAAgBSgCeCICQQhGBEAgBS0ADyECIAsgBEHYAPwKAABB2ABBCBCtNiIDRQ0DIAMgC0HYAPwKAABBACENQQAhDCMAQRBrIg4kACAOIAI6AA8gAUEQaiIEIA5BD2oQ7AwhBiABKAIIRQRAIA4gASAEEKsIIA4tAA8hAgsgASgCBCIKIAancSEPIAZCGYgiB0L/AINCgYKEiJCgwIABfiEIIAEoAgAhECACQf8BcSEEA0ACQAJ/AkACQAJAIA8gEGopAAAiCSAIhSIGQn+FIAZCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBlBFBEADQCAEIBAgBnqnQQN2IA9qIApxQXRsaiILQQxrLQAARg0CIAZCAX0gBoMiBlBFDQALCyAJQoCBgoSIkKDAgH+DIQYgDUUEQCAGUA0DIAZ6p0EDdiAPaiAKcSERC0EBIAYgCUIBhoNQDQMaQQAhDyAQIBFqLAAAIg1BAE4EQCAQIBApAwBCgIGChIiQoMCAf4N6p0EDdiIRai0AACENCyAQIBFqIAenQf8AcSIEOgAAIBAgEUEIayAKcWpBCGogBDoAACABIAEoAgggDUEBcWs2AgggASABKAIMQQFqNgIMIBAgEUF0bGoiBEEIayADNgIAIARBBGtBiK3OADYCACAEQQxrIAI6AAAMAQsgC0EEayIBKAIAIQQgAUGIrc4ANgIAIAtBCGsiASgCACEPIAEgAzYCAAsgBSAENgIEIAUgDzYCACAOQRBqJAAMAgtBAAshDSAPIAxBCGoiDGogCnEhDwwBCwsCQCAFKAIAIgNFDQAgBSgCBCICKAIAIgEEQCADIAERAwALIAIoAgQiAUUNACADIAEgAigCCBD4OgsgAEEINgIADAQLIAAgBSkCfDcCBCAAQRRqIAVBjAFqKAIANgIAIABBDGogBUGEAWopAgA3AgAgACACNgIAIAVBEGoQmS4MAwsgAyAFKAKAAUHYp84AEP0vAAtBCEHAABCjPQALQQhB2AAQoz0ACyAFQdABaiQAC/tIARh/IwBBwAFrIhkkACAJKAIUIQwDQCAZQRBqIBJqQf////8ANgIAIBJBBGoiEkGYAUcNAAsgBCAGcSEOQQEhDwJAIAZBAWsiECAGQcAAQRAgDEELRhtrIgxBACAGIAxPGyIXTQ0AIAMgDmshFSACIA5qIREgAiAOQQFqIhNqIRpBASESA0AgCCASSQ0BAkACQCADIA5LBEAgAyAEIBBxIgxNDQEgES0AACACIAxqIhYtAABHDQICQAJAIAMgE0sEQCAMQQFqIg0gA08NASAaLQAAIAIgDWotAABGDQIMBQsgEyADQbSz0AAQwyEACyANIANBxLPQABDDIQALIBYgAyAMayARIBUgBxCyICIMIA9NDQIgCyAYSwRAIAogGEEDdGogEq0gDK1CJYaENwMAIBhBAWohGCAMIQ8MAwsgGCALQdSz0AAQwyEACyAOIANBlLPQABDDIQALIAwgA0Gks9AAEMMhAAsgEEEBayIQIBdNDQEgEkEBaiESIA9BA0kNAAsLIBkgDzYCDAJAIAcgD0sEQCALIBhJDQEgACACIAMgBiAEIAUgByAIIBlBDGogCiAYQQN0aiALIBhrEIMHIBhqIRgLQQAhEgNAAkAgGUEQaiASQQJ0akH/////ADYCACASQSVGIgANAEElIBJBAWogABsiEkEmSQ0BCwsCQAJAAkAgAUUNACADIA5JDQICfyABIQQgAiAOaiERQQQgGSgCDEEBaiIAIABBBE0bIRIgGUEQaiEQQQAhASMAQSBrIgYkACAGQQA2AgQCQAJAAkACQAJAAkACQCADIA5rIg9BA0sEQCAGQQRqQQQgEUEEQdzR0QAQ1SwgBigCBEG9z9bxAWxBEHZB/v8DcUHQotYAai8BACITRQ0BQdn3ASATIBNB2fcBTRshFyAEKAIIIRUgBCgCBCEaIAQoAgAhFgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAA0ACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCATIBdHBEAgE0ECdEHQotoAaiIALQAAIhtBH3EiAkEZTw0BIAIgFmotAAAiFEEfcSEOIAAvAAEgAEEDai0AAEEQdHIiAEEIdiEMIABB/wFxIgNFDQIgBCAAQQh0IAJyIBEgDyAHENkLRQ0SIAJBJk8NUSAQIAJBAnRqIgFBCUEsIANBCkYiABsgDnQgDGpBBXQgAnIiAyABKAIAIgEgASADSxs2AgBBASEBIAJBAWoiBSAHTw0SIAIgD0sNDCACIA9GDQMgDyACayEDIAIgEWoiDS0AACIUQSBrDg8EEgUSEhISCAkSEhIHEgYKCyAXQdn3AUGc1dEAEMMhAAsgAkEZQazV0QAQwyEACyAaIAJBAnQiBWooAgAgAiAMbGoiAEGhvwdPDQggACAVakGgvwcgAGsgESAPIAcgAiACIAdLGxCyICIDIAJHDQ0gAkEmTw1OIAUgEGoiACAMQQV0IAJyIgEgACgCACIAIAAgAUsbNgIAQQEhAQwNC0EAQQBB7N7RABDDIQALIAVBJk8NTUEEQcQAIAAbDAwLIAVBJk8NTCAQIAVBAnRqIgVBwgBB1wAgABsgDnQgDGpBBXQgAnIiFCAFKAIAIgUgBSAUSxs2AgAgA0EBRg0HIA0tAAFBPkcNDCACQQJqIgVBJk8NTEHFAEHhACAAGwwLCyAFQSZPDUsgECAFQQJ0aiIFQc8AQeUAIAAbIA50IAxqQQV0IAJyIhQgBSgCACIFIAUgFEsbNgIAIANBAUYNByANLQABQSBHDQsgAkECaiIFQSZPDUtB2ABB8gAgABsMCgsgBUEmTw1KIBAgBUECdGoiBUHjAEHwACAAGyAOdCAMakEFdCACciIUIAUoAgAiBSAFIBRLGzYCACADQQFGDQcgDS0AAUEgRw0KIAJBAmoiBUEmTw1KQTpB6wAgABsMCQsgBUEmTw1JQcoAQd4AIAAbDAgLIAVBJk8NSEHOAEHxACAAGwwHCyAUQT1HDQcCQCADQQFHBEAgDS0AASIDQSJGDQEgA0EnRw0JIAJBAmoiBUEmTw1JQewAQfQAIAAbDAgLQQFBAUGs39EAEMMhAAsgAkECaiIFQSZPDUdB6ABB6QAgABsMBgsgBkEANgIYIAZBATYCDCAGQbjQ0QA2AgggBkIENwIQIAZBCGpBjNXRABDvLAALIAZBADYCGCAGQQE2AgwgBkG40NEANgIIIAZCBDcCECAGQQhqQdze0QAQ7ywAC0EBQQFB/N7RABDDIQALQQFBAUGM39EAEMMhAAtBAUEBQZzf0QAQwyEACwJAIAMgAkEBayIASQ0AAkACQAJAAkACQCAAQSZJBEAgECAAQQJ0aiIBQQwgDnQgDGpBBXQgAnIiBSABKAIAIgEgASAFSxs2AgBBASEBIAJBAmoiBSAHTw0GIAAgD08NASAAIBFqLQAAQekARw0GIAIgD08NAiACIBFqLQAAQe4ARw0GIAJBAWoiACAPTw0DIAAgEWotAABB5wBHDQYgBSAPTw0EIAUgEWotAABBIEcNBiACQQNqIgBBJk8NBSAQIABBAnRqIgBBMSAOdCAMakEFdCACciIFIAAoAgAiACAAIAVLGzYCAAwGCwxICyAAIA9BvNXRABDDIQALIAIgD0HM1dEAEMMhAAsgACAPQdzV0QAQwyEACyAFIA9B7NXRABDDIQALDEMLAkAgAkEJayIAIBIgACASSxsgEiACQQlLGyIFIAJBAmsiACADIAAgA0kbIgBLDQACQANAIAIgBWsiAUEKSQRAIAVBJk8NAiAQIAVBAnRqIg0gAUGi0NEAai0AACAOdCAMakEFdCACciIBIA0oAgAiDSABIA1JGzYCAEEBIQEgACAFTQ0DIAAgBSAAIAVLaiIFTw0BDAMLCyABQQpBzN7RABDDIQALDEILIAIgA0sNASACQQZqIgUgB08NASACIA9LDQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAiAPRwRAIA8gAmshACACIBFqIgMtAAAiDUE5TQRAIA1BIGsODwISAxISEhIHCRISEgUSBAYLAkAgDUHhAGsODwsSEhIMDRISDhISDxISEAALAkAgDUE6aw4ECBISCgALIA1B3QBHDREgAkEBaiIFQSZPDVFBGAwQC0EAQQBBjNbRABDDIQALIAJBAWoiDUEmTw1RIBAgDUECdGoiDUEBIBR0IAxqQQV0IAJyIhQgDSgCACINIA0gFEsbNgIAAkACQAJAAkACQAJAAkACQCAAQQFHBEACQCADLQABIg1B4QBrDg8CAxkZGQUZGQQZGRkZBwYACyANQfQAaw4EBxgYCBgLQQFBAUGc1tEAEMMhAAsgAEEDSQ0ZAkACQAJAAkAgAy0AAiIFQe4Aaw4HAxoaGhoBAgALIAVBIEcNGUEcIAJBA2oiBUEmSQ0YGgxZCyAAQQNGDRwgAy0AA0EgRw0YQS4gAkEEaiIFQSZJDRcaDFgLIABBA0YNHCADLQADQSBHDRdBPCACQQRqIgVBJkkNFhoMVwsgAEEDRg0cIAMtAANB5ABHDRYgAEEFSQ0dIAMtAARBIEcNFkEKIAJBBWoiBUEmSQ0VGgxWCyAAQQNJDR0gAy0AAkH5AEcNFSAAQQNGDR4gAy0AA0EgRw0VQSYgAkEEaiIFQSZJDRQaDFULAkACQCAAQQNPBEAgAy0AAiIFQe4ARg0BIAVB8wBHDRcgAEEDRg0iIAMtAANBIEcNFyACQQRqIgVBJk8NAkEvDBYLQQJBAkGc19EAEMMhAAsgAEEDRg0fIAMtAANBIEcNFUEQIAJBBGoiBUEmSQ0UGgxVCwxUCwJAAkAgAEEDTwRAIAMtAAJB7wBrDgQBFhYCFgtBAkECQczX0QAQwyEACyAAQQNGDSAgAy0AA0HyAEcNFCAAQQVJDSEgAy0ABEEgRw0UQRkgAkEFaiIFQSZJDRMaDFQLIABBA0YNISADLQADQe8ARw0TIABBBUkNIiADLQAEQe0ARw0TIABBBUYNIyADLQAFQSBHDRNBJSAFQSZJDRIaDFMLAkACQCAAQQNPBEAgAy0AAiIFQeYARg0BIAVB7gBHDRUgAEEDRg0nIAMtAANBIEcNFSACQQRqIgVBJk8NAkEtDBQLQQJBAkGs2NEAEMMhAAsgAEEDRg0kIAMtAANBIEcNE0EIIAJBBGoiBUEmSQ0SGgxTCwxSCyAAQQNJDSQgAy0AAkHvAEcNESAAQQNGDSUgAy0AA0H0AEcNESAAQQVJDSYgAy0ABEEgRw0RQdAAIAJBBWoiBUEmSQ0QGgxRCwJAAkAgAEEDTwRAIAMtAAIiDUHoAEYNASANQe8ARw0TIABBA0YNLCADLQADQSBHDRMgAkEEaiIFQSZPDQJBEQwSC0ECQQJBjNnRABDDIQALAkACQCAAQQNHBEAgAy0AA0HhAGsOBQIUFBQBFAtBA0EDQZzZ0QAQwyEACyAAQQVJDSggAy0ABEEgRw0SQQUgAkEFaiIFQSZJDREaDFILIABBBUkNKCADLQAEQfQARw0RIABBBUYNKSADLQAFQSBHDRFBHSAFQSZJDRAaDFELDFALIABBA0kNKSADLQACQekARw0PIABBA0YNKiADLQADQfQARw0PIABBBUkNKyADLQAEQegARw0PIABBBUYNLCADLQAFQSBHDQ9BIyAFQSZJDQ4aDE8LIAJBAWoiBUEmTw1OIBAgBUECdGoiBUETIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNLCADLQABQT5HDQ5BFSACQQJqIgVBJkkNDRoMTgsgAkEBaiINQSZPDU8gECANQQJ0aiINQRQgDnQgDGpBBXQgAnIiFCANKAIAIg0gDSAUSxs2AgAgAEEBRg0sIAMtAAFBIEcNDSACQQJqIg1BJk8NTyAQIA1BAnRqIg1BHyAOdCAMakEFdCACciIUIA0oAgAiDSANIBRLGzYCACAAQQNJDS0gAy0AAkHUAEcNDSAAQQNGDS4gAy0AA0HoAEcNDQJAAkAgAEEFTwRAIAMtAARB5QBrDgUBEBAQAhALQQRBBEHs2tEAEMMhAAsgAEEFRg0wIAMtAAVBIEcNDkErIAVBJkkNDRoMTgsgAEEFRg0wIAMtAAVB8wBHDQ0gAEEHSQ0xIAMtAAZBIEcNDUHLACACQQdqIgVBJkkNDBoMTQsgAkEBaiIFQSZPDUwgECAFQQJ0aiIFQcwAIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNMSADLQABQSBHDQxBDiACQQJqIgVBJkkNCxoMTAsgDUEKRw0LIAJBAWoiBUEmTw1LIBAgBUECdGoiBUEWIA50IAxqQQV0IAJyIg0gBSgCACIFIAUgDUsbNgIAIABBAUYNMSADLQABQQlHDQtBMiACQQJqIgVBJkkNChoMSwtBJCACQQFqIgVBJkkNCRoMSgtBMyACQQFqIgVBJkkNCBoMSQtBOSACQQFqIgVBJkkNBxoMSAsCQAJAIABBAUcEQCADLQABIgBBIkYNASAAQSdHDQogAkECaiIFQSZPDQJB1gAMCQtBAUEBQczb0QAQwyEAC0HGACACQQJqIgVBJkkNBxoMSAsMRwsgAEEBRg0tIAMtAAFB7ABHDQYgAEEDSQ0uIAMtAAJBIEcNBkHUACACQQNqIgVBJkkNBRoMRgsgAEEBRg0uAkACQAJAIAMtAAEiBUHyAGsOAgECAAsgBUHkAEcNByAAQQNJDTEgAy0AAkEgRw0HQTUgAkEDaiIFQSZJDQYaDEcLIABBA0kNMSADLQACQSBHDQZB0gAgAkEDaiIFQSZJDQUaDEYLIABBA0kNMSADLQACQfQARw0FIABBA0YNMiADLQADQSBHDQVB3wAgAkEEaiIFQSZJDQQaDEULIABBAUYNMiADLQABQfUARw0EIABBA0kNMyADLQACQewARw0EIABBA0YNNCADLQADQSBHDQRB2gAgAkEEaiIFQSZJDQMaDEQLAkACQCAAQQFHBEAgAy0AAUH2AGsOBQEGBgYCBgtBAUEBQfzc0QAQwyEACyAAQQNJDTUgAy0AAkHlAEcNBCAAQQNGDTYgAy0AA0EgRw0EQdwAIAJBBGoiBUEmSQ0DGgxECyAAQQNJDTYgAy0AAkHlAEcNAyAAQQNGDTcgAy0AA0EgRw0DQeQAIAJBBGoiBUEmSQ0CGgxDCwJAAkAgAEEBRwRAIAMtAAEiBUHlAEYNASAFQfkARw0FIABBA0kNPSADLQACQSBHDQUgAkEDaiIFQSZPDQJBPQwEC0EBQQFBzN3RABDDIQALIABBA0kNOCADLQACQfMARw0DIABBA0YNOSADLQADQfMARw0DIABBBUkNOiADLQAEQSBHDQNB3QAgAkEFaiIFQSZJDQIaDEMLDEILIABBAUYNOiADLQABQfUARw0BIABBA0kNOyADLQACQfMARw0BIABBA0YNPCADLQADQSBHDQEgAkEEaiIFQSZPDT1B6gALIQAgECAFQQJ0aiIDIAAgDnQgDGpBBXQgAnIiACADKAIAIgIgACACSRs2AgALIBNBAWohEyAbwEEATg0BDD0LCyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakH81dEAEO8sAAtBAkECQazW0QAQwyEAC0EDQQNBvNbRABDDIQALQQNBA0HM1tEAEMMhAAtBA0EDQdzW0QAQwyEAC0EEQQRB7NbRABDDIQALQQJBAkH81tEAEMMhAAtBA0EDQYzX0QAQwyEAC0EDQQNBrNfRABDDIQALQQNBA0G819EAEMMhAAtBA0EDQdzX0QAQwyEAC0EEQQRB7NfRABDDIQALQQNBA0H819EAEMMhAAtBBEEEQYzY0QAQwyEAC0EFQQVBnNjRABDDIQALQQNBA0G82NEAEMMhAAtBA0EDQczY0QAQwyEAC0ECQQJB3NjRABDDIQALQQNBA0Hs2NEAEMMhAAtBBEEEQfzY0QAQwyEAC0EEQQRBrNnRABDDIQALQQRBBEG82dEAEMMhAAtBBUEFQczZ0QAQwyEAC0EDQQNB3NnRABDDIQALQQJBAkHs2dEAEMMhAAtBA0EDQfzZ0QAQwyEAC0EEQQRBjNrRABDDIQALQQVBBUGc2tEAEMMhAAtBAUEBQaza0QAQwyEAC0EBQQFBvNrRABDDIQALQQJBAkHM2tEAEMMhAAtBA0EDQdza0QAQwyEAC0EFQQVB/NrRABDDIQALQQVBBUGM29EAEMMhAAtBBkEGQZzb0QAQwyEAC0EBQQFBrNvRABDDIQALQQFBAUG829EAEMMhAAtBAUEBQdzb0QAQwyEAC0ECQQJB7NvRABDDIQALQQFBAUH829EAEMMhAAtBAkECQYzc0QAQwyEAC0ECQQJBnNzRABDDIQALQQJBAkGs3NEAEMMhAAtBA0EDQbzc0QAQwyEAC0EBQQFBzNzRABDDIQALQQJBAkHc3NEAEMMhAAtBA0EDQezc0QAQwyEAC0ECQQJBjN3RABDDIQALQQNBA0Gc3dEAEMMhAAtBAkECQazd0QAQwyEAC0EDQQNBvN3RABDDIQALQQJBAkHc3dEAEMMhAAtBA0EDQezd0QAQwyEAC0EEQQRB/N3RABDDIQALQQJBAkGM3tEAEMMhAAtBAUEBQZze0QAQwyEAC0ECQQJBrN7RABDDIQALQQNBA0G83tEAEMMhAAsMAwsMBQsCQAJAIAdBBE0NAAJAIBEtAAAiE0EuRyATQSBHcQ0AIAZBADYCBCAPQQRGDQcgBkEEakEEIBFBAWoiG0EEQdzR0QAQ1SwgBigCBEG9z9bxAWxBEHZB/v8DcUHQotYAai8BACIARQ0AIA9BAWshFEECQc0AIBNBIEYiGhshAkHZAEHDACAaGyEDQQZBICAaGyEgIAdBAWshHSAAQQJ0QdCi2gBqIQVB2fcBIAAgAEHZ9wFNGyIhIABrQQFqIR4gBCgCACEiA0ACQAJAAkACQAJAAkACQAJAAkACQCAeQQFrIh4EQCAFLQAAIiNBH3EiDkEZTw0BIAVBAWovAAAgBUEDai0AAEEQdHIiAEEIdiENIABBCHQgDnIhDCAOICJqLQAAQR9xIRcCQAJAAkACQAJAAkACQAJAAkACQAJAIABB/wFxIhxFBEAgBCAMIBsgFCAdENkLRQ0WIA5BAWoiAEEmTw0dIBAgAEECdGoiASAgIBd0IA1qQQV0IA5yIgwgASgCACIBIAEgDEsbNgIAQQEhASAOQQJqIgwgB08NFiAOIA9PDQ4gACAPRg0BIAAgEWoiFS0AACIWQSBGDQIgFkEoRw0DIAxBJk8NICADIQAMFQsgGkUNFSAEIAwgGyAUIB0Q2QtFDRUgDkEBaiIVQSZPDRAgECAVQQJ0aiIBQR5B1QAgHEEKRiIAGyAXdCANakEFdCAOciIMIAEoAgAiASABIAxLGzYCAEEBIQEgDkECaiIMIAdPDRUgDiAPTw0RIA8gFUYNBCAPIBVrIRYgESAVaiIVLQAAIh9BLGsOAwYVBwMLQQBBAEHs39EAEMMhAAsgDEEmSQRAIAIhAAwTCwwdCyATQSBHDRIgDyAAayEAAkACQAJAIBZBLGsOAwAVAQILIAxBJk8NHiAQIAxBAnRqIgxB5wAgF3QgDWpBBXQgDnIiFiAMKAIAIgwgDCAWSxs2AgAgAEEBRg0NIBUtAAFBIEcNFCAOQQNqIgxBJkkEQEEhIQAMFAsMHgsgDEEmTw0dIBAgDEECdGoiDEHHACAXdCANakEFdCAOciIWIAwoAgAiDCAMIBZLGzYCACAAQQFGDQ0gFS0AAUEgRw0TIA5BA2oiDEEmSQRAQTQhAAwTCwwdCyAWQT1HDRICQAJAIABBAUcEQCAVLQABIgBBIkYNASAAQSdHDRUgDkEDaiIMQSZPDQJB4gAhAAwUC0EBQQFBnODRABDDIQALIA5BA2oiDEEmSQRAQdEAIQAMEwsMHQsMHAsgH0EgRg0BIB9BPUcNESAWQQFGDQQgFS0AASIMQSJGDQUgDEEnRg0GDBELQQBBAEG84NEAEMMhAAsgDEEmTw0ZQQ9B0wAgABshAAwOCyAcQQpGBEAgDEEmTw0ZIBAgDEECdGoiDEHtACAXdCANakEFdCAOciIcIAwoAgAiDCAMIBxLGzYCAAsgFkEBRg0LIBUtAAFBIEcNDiAOQQNqIgxBJk8NGEHBAEHvACAAGyEADA0LIAxBJk8NFyAQIAxBAnRqIgxB4ABB8wAgABsgF3QgDWpBBXQgDnIiHCAMKAIAIgwgDCAcSxs2AgAgFkEBRg0LIBUtAAFBIEcNDSAOQQNqIgxBJk8NF0HbAEH1ACAAGyEADAwLQQFBAUHs4NEAEMMhAAsgDkEDaiIMQSZPDRVB9gBB7gAgABshAAwKCyAOQQNqIgxBJk8NFEH4AEH3ACAAGyEADAkLICFB2fcBQbzf0QAQwyEACyAOQRlBzN/RABDDIQALIAZBADYCGCAGQQE2AgwgBkG40NEANgIIIAZCBDcCECAGQQhqQdzf0QAQ7ywAC0EBQQFB/N/RABDDIQALQQFBAUGM4NEAEMMhAAsgFUEmQfzU0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakGs4NEAEO8sAAtBAUEBQczg0QAQwyEAC0EBQQFB3ODRABDDIQALIBAgDEECdGoiASAAIBd0IA1qQQV0IA5yIgAgASgCACIBIAAgAUkbNgIAQQEhAQsgBUEEaiEFICPAQQBODQALCyAHQQVGDQACQAJAIBEtAAEiDkEgRgRAIBNBLEYgE0HzAEZyDQEgE0HlAEcNAgwBCyATQcIBRw0BIA5BoAFGDQAMAQsgBkEANgIEIA9BAmsiF0EDTQ0HIAZBBGpBBCARQQJqIhVBBEHc0dEAENUsIAYoAgRBvc/W8QFsQRB2Qf7/A3FB0KLWAGovAQAiAEUNAEESQQdBDSATQfMARhsgE0HlAEYbIQIgB0ECayEaIABBAnRB0KLaAGohBUHZ9wEgACAAQdn3AU0bIhYgAGtBAWohACAEKAIAIRsgE0HCAUYhFANAAkACQAJAAkAgAEEBayIABEAgBS0AACIdQR9xIgNBGU8NASAFQQFqLwAAIAVBA2otAABBEHRyIg1B/wFxDQQgAyAbai0AACEeIAQgDUEIdCADciAVIBcgGhDZC0UNBCADQQJqIQwgFARAQeYAIQEgDEEmSQ0EDA8LIAcgDE0NBCAMIA9PDQIgDCARai0AAEEgRw0EIANBA2oiDEEmSQRAIAIhAQwECwwOCyAWQdn3AUH84NEAEMMhAAsgA0EZQYzh0QAQwyEACyAMIA9BnOHRABDDIQALIBAgDEECdGoiDCABIB50IA1BCHZqQQV0IANyIgEgDCgCACIDIAEgA0kbNgIAQQEhAQsgBUEEaiEFIB3AQQBODQALCyAHQQhNDQACQAJAIBNBIEYEQCAOQfQARw0DIBEtAAJB6ABHDQMgES0AA0HlAEcNAyAPQQRGDQEgES0ABEEgRw0DDAILIBNBLkcgDkHjAEdyDQIgES0AAkHvAEcNAiARLQADQe0ARw0CIA9BBEcEQCARLQAEQS9GDQIMAwtBBEEEQbzh0QAQwyEAC0EEQQRBrOHRABDDIQALIAZBADYCBCAPQQVrIhVBA00NASAGQQRqQQQgEUEFaiIaQQRB3NHRABDVLCAGKAIEQb3P1vEBbEEQdkH+/wNxQdCi1gBqLwEAIgBFDQBBKUHIACATQSBGGyEWIAdBBWshGyAAQQJ0QdCi2gBqIQVB2fcBIAAgAEHZ9wFNGyIUIABrQQFqIQAgBCgCACEdA0ACQAJAAkACQAJAAkACQAJAAkACQAJAIABBAWsiAARAIAUtAAAiHkEfcSIDQRlPDQEgBUEBai8AACAFQQNqLQAAQRB0ciIMQf8BcQ0LIAMgHWotAAAhDSAEIAxBCHQgA3IgGiAVIBsQ2QtFDQsgA0EFaiICQSZPDQ8gECACQQJ0aiIBIAxBCHYiDiAWIA1BH3EiF3RqQQV0IANyIgwgASgCACIBIAEgDEsbNgIAQQEhASACIAdPDQsgAiAPSw0CIBNBIEcgA0EIaiAHT3INCyACIA9GDQMgAiARaiIMLQAAQSBHDQsgDyACayICQQFGDQQgDC0AAUHvAEcNCyACQQNJDQUgDC0AAkHmAEcNCyACQQNGDQYgDC0AA0EgRw0LIANBCWoiDUEmTw0SIBAgDUECdGoiDUE+IBd0IA5qQQV0IANyIhwgDSgCACINIA0gHEsbNgIAIANBDGogB08NCyACQQVJDQcgDC0ABEH0AEcNCyACQQVGDQggDC0ABUHoAEcNCyACQQdJDQkgDC0ABkHlAEcNCyACQQdGDQogDC0AB0EgRw0LIANBDWoiAkEmTw0PIBAgAkECdGoiAkHJACAXdCAOakEFdCADciIDIAIoAgAiAiACIANLGzYCAAwLCyAUQdn3AUHM4dEAEMMhAAsgA0EZQdzh0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakHs4dEAEO8sAAtBAEEAQfzh0QAQwyEAC0EBQQFBjOLRABDDIQALQQJBAkGc4tEAEMMhAAtBA0EDQazi0QAQwyEAC0EEQQRBvOLRABDDIQALQQVBBUHM4tEAEMMhAAtBBkEGQdzi0QAQwyEAC0EHQQdB7OLRABDDIQALIAVBBGohBSAewEEATg0ACwsgBkEgaiQAIAEMBwsMBAsgAkEmQfzU0QAQwyEACyAFQSZB/NTRABDDIQALIABBJkH81NEAEMMhAAsgDUEmQfzU0QAQwyEACyAGQQA2AhggBkEBNgIMIAZBuNDRADYCCCAGQgQ3AhAgBkEIakHM0dEAEO8sAAsgDEEmQfzU0QAQwyEAC0UNACAJLQBVRQ0BIBJBJSAHIAdBJU8bIgBLDQAgCEEBaiECIAkoAhAhAwNAAkAgGUEQaiASQQJ0aigCACIBQf////8ATw0AIAIgAUEFdmoiBCADSw0AIAsgGEsEQCAKIBhBA3RqIAStIBJBBXQgAUEfcSIBQQAgASASRxtyrUIghoQ3AwAgGEEBaiEYDAELIBggC0G8tNAAEMMhAAsgACASTQ0BIBIgACASS2oiEiAATQ0ACwsgGUHAAWokACAYDwtBhLTQAEEnQay00AAQnykACyAOIANB9LPQABCvOwALIBlBADYCuAEgGUEBNgKsASAZQfig0AA2AqgBIBlCBDcCsAEgGUGoAWpB5LPQABDvLAALyQgBA38jAEHgAGsiBSQAAkAgAAJ/AkACQAJAAkAgAkH/AXFBAWsOAwECAwALIwBBgAJrIgYkACAGQbwBaiICIAEQqC4gBkHgAGoiByACEKEbIAZBBGoiASAHQYSD/wAQjBggByABEM0cIAVBMGoiAiAHEL8TIAZBgAJqJAAgBUEoaiIGIAVBxABqKAIANgIAIAVBEGoiByAFQdAAaikCADcDACAFQRhqIgEgBUHYAGopAgA3AwAgBSAFKQI8NwMgIAUgBSkCSDcDCCACEKUMQThBBBCtNiICRQ0EIAIgBDYCECACIAM2AgwgAkENOwEIIAJCgYCAgBA3AgAgAiAFKQMgNwIUIAIgBSkDCDcCICACQRxqIAYoAgA2AgAgAkEoaiAHKQMANwIAIAJBMGogASkDADcCAEGo2P8ADAMLIAVBMGoiAiABEPUkIAVBKGoiBiAFQcQAaigCADYCACAFQRBqIgcgBUHQAGopAgA3AwAgBUEYaiIBIAVB2ABqKQIANwMAIAUgBSkCPDcDICAFIAUpAkg3AwggAhClDEE4QQQQrTYiAkUNAyACIAQ2AhAgAiADNgIMIAJBjQI7AQggAkKBgICAEDcCACACIAUpAyA3AhQgAiAFKQMINwIgIAJBHGogBigCADYCACACQShqIAcpAwA3AgAgAkEwaiABKQMANwIAQYDZ/wAMAgsjAEGAAmsiBiQAIAZBvAFqIgIgARCoLiAGQeAAaiIHIAIQoRsgBkEEaiIBIAdBlIT/ABCMGCAHIAEQzRwgBUEwaiICIAcQqBMgBkGAAmokACAFQShqIgYgBUHEAGooAgA2AgAgBUEQaiIHIAVB0ABqKQIANwMAIAVBGGoiASAFQdgAaikCADcDACAFIAUpAjw3AyAgBSAFKQJINwMIIAIQpQxBOEEEEK02IgJFDQIgAiAENgIQIAIgAzYCDCACQY0EOwEIIAJCgYCAgBA3AgAgAiAFKQMgNwIUIAIgBSkDCDcCICACQRxqIAYoAgA2AgAgAkEoaiAHKQMANwIAIAJBMGogASkDADcCAEHY2f8ADAELIwBBgAJrIgYkACAGQbwBaiICIAEQqC4gBkHgAGoiByACEKEbIAZBBGoiASAHQayE/wAQjBggByABEM0cIAVBMGoiAiAHELQTIAZBgAJqJAAgBUEoaiIGIAVBxABqKAIANgIAIAVBEGoiByAFQdAAaikCADcDACAFQRhqIgEgBUHYAGopAgA3AwAgBSAFKQI8NwMgIAUgBSkCSDcDCCACEKUMQThBBBCtNiICRQ0BIAIgBDYCECACIAM2AgwgAkGNBjsBCCACQoGAgIAQNwIAIAIgBSkDIDcCFCACIAUpAwg3AiAgAkEcaiAGKAIANgIAIAJBKGogBykDADcCACACQTBqIAEpAwA3AgBBsNr/AAs2AgQgACACNgIAIAVB4ABqJAAPC0EEQTgQoz0AC6EJAgt/A34jAEEwayIEJAAgASgCACECAkADQAJAAkACQAJAAkAgAgRAIAEoAgQiAiABKAIMRw0BIAEQvSsgAUEANgIACyABKAIgIgNFDQQgASgCMCICIAEoAjQiCE8NBCADIAJBAnRqIQUgASgCKCACQcACbGohBiABKAI4IQMgASgCPCEJA0ACQCABIAJBAWoiAjYCMCABIAUoAgAEfyADBSAJIAMQ8iYgASgCOCEHDQEgBwtBAWoiAzYCOCAFQQRqIQUgBkHAAmohBiACIAhHDQEMBgsLIAEgB0EBajYCOCAEQQA2AhAgBEKAgICAgAE3AgggBEEgaiAGEOwgIAMgASgCRCICTw0BIAEoAkAgA0EYbGoiAigCCEUNAyACKAIEKQMAIg0gBCkDICIOUg0CDAMLIABCATcDACABIAJBEGo2AgQgACACKQMINwMQIAAgAikDADcDCAwFCyADIAJBoLXCABDDIQALIARBCGpBsLXCABCVKCAEKAIMIgUgDTcDCCAFIA43AwAgBEEBNgIQCwJAAkACQCABKAJIKAIAIgVFBEAgAigCCCEFIAIoAgQhAgwBCyAFIAMQ8iYgAigCCCEFIAIoAgQhAg0BCyAEQRRqIAEoAlAgAiAFEPsIDAELIARBFGogASgCTCACIAUQ+wgLIAQgBCgCFDYCKCAEIAQoAhgiAjYCICAEIAI2AiQgBCACIAQoAhxBBHRqNgIsIARBIGoiBSgCDCAFKAIEIgZrIgdBBHYiCCAEQQhqIgIoAgAgAigCCCIDa0sEQCACIAMgCEEIQRAQ0CggAigCCCEDCyAHBEAgAigCBCADQQR0aiAGIAf8CgAACyAFIAY2AgwgAiACKAIIIAhqNgIIIAUQvSsgASgCVCEFIAQoAgwiAiAEKAIQQQR0aiEGIwBBIGsiAyQAIANBFGogBiACa0EEdkEAQQhBCBCgGCADKAIYIQcgAygCFEEBRgRAIAcgAygCHEHgtMIAEP0vAAsgBEEgaiEKIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAc2AgggA0EIaiIHIAYgAmtBBHYiCBDsLSAHKAIIIQkgByACIAZHBH8gCCAJaiAHKAIEIAlBA3RqIQYDQCAGIAIpAwA3AwAgAkEQaiECIAZBCGohBiAIQQFrIggNAAsFIAkLNgIIIApBCGogCygCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUoAggiAiAFKAIARgRAIAVBwLXCABCQKAsgBSgCBCACQQxsaiIDIAQpAiA3AgAgA0EIaiAEQShqKAIANgIAIAUgAkEBajYCCCAEKAIIIgNBgICAgHhGDQAgBCkCDCINpyICIA1CIIinQQR0aiEFIAEoAgAEQCABEL0rCyABIAU2AgwgASADNgIIIAEgAjYCBCABIAI2AgAMAQsLAn4CQCABKAIQBEAgASgCFCICIAEoAhxGDQEgASACQRBqNgIUIAIpAwghDSACKQMAIQ5CAQwCCyAAQgA3AwAMAgsgAUEQaiIBEL0rIAFBADYCAEIACyEPIAAgDTcDECAAIA43AwggACAPNwMACyAEQTBqJAALyAcBB38jAEEQayIIJAACQAJAAkAgAyADQQNrIgRBACADIARPGyIFSwRAIAMhBANAAkAgAiAETQRAIAIgBEYNBAwBCyABIARqLAAAQb9/TA0AIAQhAgwDCyAFIARBAWsiBEkNAAsLIANBBEkNAQJAIAIgBU0EQCACIAVHDQEMAgsgBSICIAFqLAAAQb9/Sg0BCyAAQYCAgIB4NgIADAILIAEgAmohBANAAn8CfwJAIARBAWsiAywAACIFQQBIBEAgBEECayIDLQAAIgbAIgdBQEgNASAGQR9xDAILQQEhBiADDAILIAdBP3ECfyAEQQNrIgMtAAAiBsAiB0G/f0oEQCAGQQ9xDAELIAdBP3EgBEEEayIDLQAAQQdxQQZ0cgtBBnRyCyEEIAVBP3EgBEEGdHIhBQJ/QQEgBEECSQ0AGkECIARBIEkNABpBA0EEIARBgAhJGwshBiADCyEEAkAgBUEBaiIDQYCwA3NBgIDEAGtBgJC8f08EQAJ/QQEgBUH/AEkNABpBAiAFQf8PSQ0AGkEDQQQgBUH//wNJGwsgBkYNAQsgASAERg0CDAELCwJAAkACQAJAIAIgBCABayIHIAZqIgRPBEAgCEEEaiAEQQBBAUEBEKAYIAgoAgghCSAIKAIEQQFGDQEgCCgCDCECIAQEQCACIAEgBPwKAAALIAQgB0kNAiACIAdqIQEgBUH/AE8EQEECQQNBBCAFQf//A0kbIAVB/w9JIgcbIgogBk0EQCAHDQUgBUH//wNPBEAgASADQT9xQYABcjoAAyABIANBEnZB8AFyOgAAIAEgA0EGdkE/cUGAAXI6AAIgASADQQx2QT9xQYABcjoAAQwHCyABIANBP3FBgAFyOgACIAEgA0EMdkHgAXI6AAAgASADQQZ2QT9xQYABcjoAAQwGCyMAQUBqIgAkACAAIAo2AgggACADNgIEIAAgBjYCDCAAQQM2AiQgAEHEjYoBNgIgIABBAzYCFCAAQayNigE2AhAgAEEDNgIcIAAgAEEMaq1CgICAgLAHhDcDOCAAIABBBGqtQoCAgICg5AOENwMwIAAgAEEIaq1CgICAgLAHhDcDKCAAIABBKGo2AhggAEEQakGE784AEO8sAAsgASADOgAADAQLIAQgAkGghc8AELA7AAsgCSAIKAIMQcD1zgAQ/S8ACyAHIARBsIXPABCvOwALIAEgA0E/cUGAAXI6AAEgASADQQZ2QcABcjoAAAsgACAENgIIIAAgAjYCBCAAIAk2AgAMAQsgAEGAgICAeDYCAAsgCEEQaiQAC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGouAQCyOAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgAS4BALI4AgAgBEEEaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQN0aisDALY4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKwMAtjgCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBAnQiBSEDAkACQAJAIAVBPHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVBAXRqLwEAszgCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQCzOAIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC+HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGooAgC4OQMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALg5AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQN0aikDALU4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKQMAtTgCACAEQQRqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAXRqLgEAtzkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEuAQC3OQMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2DwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEDdGopAwC0OAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASkDALQ4AgAgBEEEaiEEIAFBCGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL6QYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQJ0aioCALs5AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKgIAuzkDACAEQQhqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvpBgIGfwN+IwBBkAFrIgIkACABQQxqENk8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAXRqLwEAuDkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQC4OQMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+kGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGooAgC3OQMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALc5AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENsdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL0gUBDH8jAEEQayINJAACQCAEQQdNBEAgDUIANwMIIAQEQCANQQhqIAMgBPwKAAALQWwgACABIAIgDUEIakEIEP0HIgAgACAESxsgACAAQYl/SRshAgwBCyABKAIAQQFqIg9BAXQiBwRAIABBACAH/AsACyADKAAAIglBD3EiBkEKSwRAQVQhAgwBCyACIAZBBWo2AgAgAyAEaiICQQRrIQcgAkEHayEOIAZBBmohEEEEIQUgCUEEdiECQSAgBnQiC0EBciEMQQAhBkEBIQogAyEEA0ACQAJAIApBAXEEQCAGIQkMAQsDQCACQX9zQYCAgIB4cmgiCEEYSUUEQCAGQSRqIQYgBCAOTQR/IARBA2oFIAQgDmtBA3QgBWpBH3EhBSAHCyIEKAAAIAV2IQIMAQsLIAUgCEEecSIJakECaiEFIA8gCEEBdkEDbCIIIAIgCXYiAkEDcWogBmoiCU0EQCACQQNxIAhqIAZqIQYMAgsCfyAEIA5LIAVBA3YgBGoiAiAHS3FFBEAgBUEHcSEFIAIMAQsgBCAHa0EDdCAFakEfcSEFIAcLIgQoAAAgBXYhAgsgAiALQQFrcSIKIAtBAXRBAWsiCCAMayIGSQR/IBBBAWsFIAIgCHEiAiAGQQAgAiALThtrIQogEAsgACAJQQF0aiAKQQFrIgg7AQAgCUEBaiEGIAVqIQUgC0EBIAprIAggCkEAShsgDGoiDEoEQCAMQQJIDQFBICAMZyICayEQQQEgAkEfc3QhCwsgBiAPTw0AIAhBAEchCgJ/IAQgDksgBUEDdSAEaiICIAdLcUUEQCAFQQdxIQUgAgwBCyAFIAQgB2tBA3RqQR9xIQUgBwsiBCgAACAFdiECDAELC0FsIQIgDEEBRw0AIAYgD0sEQEFQIQIMAQsgBUEgSg0AIAEgBkEBazYCACAEIAVBB2pBA3VqIANrIQILIA1BEGokACACC5UGAQh/AkACQAJ/AkACQAJAAkAgAkUEQCAALQAAQQFxDQELIAIgAkEfdSIDcyADayEDQS1BKyACQQBIGyEHQQEgAC0AAyICdCIEQTRxDQEgBEEKcQ0CIAIhBiACIQQMBQsgASgCCCICIQAgAiABKAIARgR/IAEgAkEBENsoIAEoAggFIAALIAEoAgRqQdoAOgAAIAEgAkEBajYCCEEAIQAMBQsgA0E8bSIGQTxvIQQgAyAGQTxsayIGRSACQQJHcQ0BQQIhAkEBIQUMAwsgA0EeaiIDQTxtQTxvIgRBACACQQNHIARBAEdyIgIbDAELIARBACAEQQBHIAJBBUdyIgIbCyEEQQAhBgsgAC0AASEIAkAgA0GQHG0iCUH/AXFBCkkEQCABKAIIIQMgAC0AAiIKQQJGBEAgAyIAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAAsgASgCBGpBIDoAACABIANBAWoiAzYCCAsgAyIAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAAsgASgCBGogBzoAACABIANBAWoiADYCCCAKQQFGBEAgACABKAIARgR/IAEgAEEBENsoIAEoAggFIAALIAEoAgRqQTA6AAAgASADQQJqIgA2AggLIAAhAyAAIAEoAgBGBH8gASAAQQEQ2yggASgCCAUgAwsgASgCBGogCUEwcjoAACABIABBAWo2AggMAQsgASgCCCIDIQAgAyABKAIARgR/IAEgA0EBENsoIAEoAggFIAALIAEoAgRqIAc6AABBASEAIAEgA0EBajYCCCABIAkQixgNAQsCQCACQQFrQQJPBEBBACEAIAVFDQIMAQsgCEEBRgRAIAEoAggiAiEAIAIgASgCAEYEfyABIAJBARDbKCABKAIIBSAACyABKAIEakE6OgAAIAEgAkEBajYCCAsgASAEEIsYIgAgBUVyDQELIAhBAUYEQCABKAIIIgIhACACIAEoAgBGBH8gASACQQEQ2yggASgCCAUgAAsgASgCBGpBOjoAACABIAJBAWo2AggLIAEgBhCLGA8LIAAL5gYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2pBAnQiBWogASAFaigCALM4AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKAIAszgCACAEQQRqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQvh0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvmBgIGfwN+IwBBkAFrIgIkACABQQxqENg8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinakEDdCIFaiABIAVqKQMAujkDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEpAwC6OQMAIARBCGohBCABQQhqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUECdGo1AgA3AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABNQIANwMAIARBCGohBCABQQRqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDZHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGouAQA2AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABLgEANgIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxC/HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBUEBdGovAQA2AgAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABLwEANgIAIARBBGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDHHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+cGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2TwhBiACQRBqIAEQkjYQ7iUgBkEDdCIFIQMCQAJAAkAgBUE4cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBUEBdGoyAQA3AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABMgEANwMAIARBCGohBCABQQJqIQEgBiADQQFqIgNHDQALCyACQcgAaiIDEJcpIAJBMGoiASgCACEGIAIoAjQhBCABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAQ2AkwgAiAGNgJIIAJBCGogAxDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgBDYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgAxDWHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+YGAgZ/A34jAEGQAWsiAiQAIAFBDGoQ2zwhBiACQRBqIAEQkjYQ7iUgBkECdCIFIQMCQAJAAkAgBUE8cSIEBEAgBSAEa0FAayIDIAVJDQELQcAAIQQgA0HAABDRNARAAkAgAwRAIANBwAAQrTYiBEUNAQsgAiAENgIwIAIgAzYCLCACQcAANgIoIAUEQCAEQQAgBfwLAAsgAiAFNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqQQJ0IgVqIAEgBWooAgCyOAIADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgASgCALI4AgAgBEEEaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQF0ajMBADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEzAQA3AwAgBEEIaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENYdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQJ0IgUhAwJAAkACQCAFQTxxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFQQF0ai8BADYCAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEvAQA2AgAgBEEEaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADEL8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDbPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQJ0ajQCADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAE0AgA3AwAgBEEIaiEEIAFBBGohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENYdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5wYCBn8DfiMAQZABayICJAAgAUEMahDZPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFQQF0ajMBADcDAAwACwALQcAAIAMQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhAUEAIQMDQCAEIAEzAQA3AwAgBEEIaiEEIAFBAmohASAGIANBAWoiA0cNAAsLIAJByABqIgMQlykgAkEwaiIBKAIAIQYgAigCNCEEIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgBDYCTCACIAY2AkggAkEIaiADENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiAENgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOQZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASADENkdIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL5gYCBn8DfiMAQZABayICJAAgAUEMahDYPCEGIAJBEGogARCSNhDuJSAGQQN0IgUhAwJAAkACQCAFQThxIgQEQCAFIARrQUBrIgMgBUkNAQtBwAAhBCADQcAAENE0BEACQCADBEAgA0HAABCtNiIERQ0BCyACIAQ2AjAgAiADNgIsIAJBwAA2AiggBQRAIARBACAF/AsACyACIAU2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2pBA3QiBWogASAFaikDALk5AwAMAAsAC0HAACADEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQFBACEDA0AgBCABKQMAuTkDACAEQQhqIQQgAUEIaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvnBgIGfwN+IwBBkAFrIgIkACABQQxqENs8IQYgAkEQaiABEJI2EO4lIAZBA3QiBSEDAkACQAJAIAVBOHEiBARAIAUgBGtBQGsiAyAFSQ0BC0HAACEEIANBwAAQ0TQEQAJAIAMEQCADQcAAEK02IgRFDQELIAIgBDYCMCACIAM2AiwgAkHAADYCKCAFBEAgBEEAIAX8CwALIAIgBTYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVBAnRqNQIANwMADAALAAtBwAAgAxCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEBQQAhAwNAIAQgATUCADcDACAEQQhqIQQgAUEEaiEBIAYgA0EBaiIDRw0ACwsgAkHIAGoiAxCXKSACQTBqIgEoAgAhBiACKAI0IQQgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiAENgJMIAIgBjYCSCACQQhqIAMQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAQ2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAMQ1h0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAviBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLAAAsjgCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2osAACyOAIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4gYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBQJAAkACQCADQThxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFaiwAALc5AwAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAAtzkDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDbHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+IGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEDdCIDIQUCQAJAAkAgA0E4cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBA3RqIAEgBWotAAC4OQMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADai0AALg5AwAgBEEIaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQ2x0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAviBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLQAAszgCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAACzOAIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL4dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQF0IgMhBQJAAkACQCADQT5xIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEBdGogASAFai0AADsBAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAAA7AQAgBEECaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ4RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQzR0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBA3QiAyEFAkACQAJAIANBOHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVqMQAANwMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADajEAADcDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDWHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQUCQAJAAkAgA0E+cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAXRqIAEgBWosAAA7AQAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAAOwEAIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENodIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQN0IgMhBQJAAkACQCADQThxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUEDdGogASAFajAAADcDAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2owAAA3AwAgBEEIaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5BkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQ1h0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBA3QiAyEFAkACQAJAIANBOHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQN0aiABIAVqMQAANwMADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADajEAADcDACAEQQhqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDkGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBDZHSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkEBdCIDIQUCQAJAAkAgA0E+cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAXRqIAEgBWotAAA7AQAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLQAAOwEAIARBAmohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOEZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEENodIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL4AYCBn8DfiMAQZABayICJAAgAUEMaigCCCEGIAJBEGogARCSNhDuJSAGQQJ0IgMhBQJAAkACQCADQTxxIgQEQCADIARrQUBrIgUgA0kNAQtBwAAhBCAFQcAAENE0BEACQCAFBEAgBUHAABCtNiIERQ0BCyACIAQ2AjAgAiAFNgIsIAJBwAA2AiggAwRAIARBACAD/AsACyACIAM2AjQgAigCEEUNAyACKAIkIAIoAiBGDQQgAkHIAGogAkEQahDINCACQegAaiEDIAEoAhAhASACKQNwIQkDQAJAIAlQRQRAIAIpA3ghCAwBCwNAAn4CQCACKQNYIghCA1IEQAJAAkACQCAIQgJRDQAgAiAIUK1CAYY3A1ggCKdBAXFFDQAgAiACKQNgNwOIAQwBCyACKAJoRQ0BIAJBgAFqIAMQtiogAikDgAEhCAsgCEIAUg0CCyACQgM3A1gLIAIpA0giCEICUQ0JIAJCADcDSCACKQNQDAELIAIpA4gBCyEJIAinQQFxRQ0HIAIgAikDeEJAfSIINwN4IAIgCTcDcCAJUA0ACwsgAkIBIAl6IgqGIAmFIgk3A3AgBCAKpyAIp2oiBUECdGogASAFai0AADYCAAwACwALQcAAIAUQoz0AC0Hci/8AQSkgAkHIAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAGRQ0AIAEoAhAhA0EAIQEDQCAEIAEgA2otAAA2AgAgBEEEaiEEIAYgAUEBaiIBRw0ACwsgAkHIAGoiBBCXKSACQTBqIgEoAgAhBiACKAI0IQMgASACQdAAaiIFKQIANwMAIAIpAyghCCACIAIpAkg3AyggAkEANgI4IAIgCDcCVCACQQA2AlAgAiADNgJMIAIgBjYCSCACQQhqIAQQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAkg3AgggAUEQaiAFKQIANwIAIAFBGGogAkHYAGoiBygCADYCACACIAM2AogBIAIgBjYChAEgAiABNgKAASACQTxqIgEgAkGAAWoQ5RkgByACQSBqKQIANwMAIAUgAkEYaikCADcDACACIAIpAhA3A0ggACABIAQQxx0gAkEoahDPLyACQZABaiQADwtBBEEcEKM9AAvgBgIGfwN+IwBBkAFrIgIkACABQQxqKAIIIQYgAkEQaiABEJI2EO4lIAZBAnQiAyEFAkACQAJAIANBPHEiBARAIAMgBGtBQGsiBSADSQ0BC0HAACEEIAVBwAAQ0TQEQAJAIAUEQCAFQcAAEK02IgRFDQELIAIgBDYCMCACIAU2AiwgAkHAADYCKCADBEAgBEEAIAP8CwALIAIgAzYCNCACKAIQRQ0DIAIoAiQgAigCIEYNBCACQcgAaiACQRBqEMg0IAJB6ABqIQMgASgCECEBIAIpA3AhCQNAAkAgCVBFBEAgAikDeCEIDAELA0ACfgJAIAIpA1giCEIDUgRAAkACQAJAIAhCAlENACACIAhQrUIBhjcDWCAIp0EBcUUNACACIAIpA2A3A4gBDAELIAIoAmhFDQEgAkGAAWogAxC2KiACKQOAASEICyAIQgBSDQILIAJCAzcDWAsgAikDSCIIQgJRDQkgAkIANwNIIAIpA1AMAQsgAikDiAELIQkgCKdBAXFFDQcgAiACKQN4QkB9Igg3A3ggAiAJNwNwIAlQDQALCyACQgEgCXoiCoYgCYUiCTcDcCAEIAqnIAinaiIFQQJ0aiABIAVqLQAANgIADAALAAtBwAAgBRCjPQALQdyL/wBBKSACQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIAZFDQAgASgCECEDQQAhAQNAIAQgASADai0AADYCACAEQQRqIQQgBiABQQFqIgFHDQALCyACQcgAaiIEEJcpIAJBMGoiASgCACEGIAIoAjQhAyABIAJB0ABqIgUpAgA3AwAgAikDKCEIIAIgAikCSDcDKCACQQA2AjggAiAINwJUIAJBADYCUCACIAM2AkwgAiAGNgJIIAJBCGogBBDXOyACKAIIIQZBHEEEEK02IgEEQCABQoGAgIAQNwIAIAEgAikCSDcCCCABQRBqIAUpAgA3AgAgAUEYaiACQdgAaiIHKAIANgIAIAIgAzYCiAEgAiAGNgKEASACIAE2AoABIAJBPGoiASACQYABahDlGSAHIAJBIGopAgA3AwAgBSACQRhqKQIANwMAIAIgAikCEDcDSCAAIAEgBBC/HSACQShqEM8vIAJBkAFqJAAPC0EEQRwQoz0AC+AGAgZ/A34jAEGQAWsiAiQAIAFBDGooAgghBiACQRBqIAEQkjYQ7iUgBkECdCIDIQUCQAJAAkAgA0E8cSIEBEAgAyAEa0FAayIFIANJDQELQcAAIQQgBUHAABDRNARAAkAgBQRAIAVBwAAQrTYiBEUNAQsgAiAENgIwIAIgBTYCLCACQcAANgIoIAMEQCAEQQAgA/wLAAsgAiADNgI0IAIoAhBFDQMgAigCJCACKAIgRg0EIAJByABqIAJBEGoQyDQgAkHoAGohAyABKAIQIQEgAikDcCEJA0ACQCAJUEUEQCACKQN4IQgMAQsDQAJ+AkAgAikDWCIIQgNSBEACQAJAAkAgCEICUQ0AIAIgCFCtQgGGNwNYIAinQQFxRQ0AIAIgAikDYDcDiAEMAQsgAigCaEUNASACQYABaiADELYqIAIpA4ABIQgLIAhCAFINAgsgAkIDNwNYCyACKQNIIghCAlENCSACQgA3A0ggAikDUAwBCyACKQOIAQshCSAIp0EBcUUNByACIAIpA3hCQH0iCDcDeCACIAk3A3AgCVANAAsLIAJCASAJeiIKhiAJhSIJNwNwIAQgCqcgCKdqIgVBAnRqIAEgBWosAAA2AgAMAAsAC0HAACAFEKM9AAtB3Iv/AEEpIAJByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBkUNACABKAIQIQNBACEBA0AgBCABIANqLAAANgIAIARBBGohBCAGIAFBAWoiAUcNAAsLIAJByABqIgQQlykgAkEwaiIBKAIAIQYgAigCNCEDIAEgAkHQAGoiBSkCADcDACACKQMoIQggAiACKQJINwMoIAJBADYCOCACIAg3AlQgAkEANgJQIAIgAzYCTCACIAY2AkggAkEIaiAEENc7IAIoAgghBkEcQQQQrTYiAQRAIAFCgYCAgBA3AgAgASACKQJINwIIIAFBEGogBSkCADcCACABQRhqIAJB2ABqIgcoAgA2AgAgAiADNgKIASACIAY2AoQBIAIgATYCgAEgAkE8aiIBIAJBgAFqEOUZIAcgAkEgaikCADcDACAFIAJBGGopAgA3AwAgAiACKQIQNwNIIAAgASAEEL8dIAJBKGoQzy8gAkGQAWokAA8LQQRBHBCjPQAL2gYCCX8GfiMAQRBrIgokAAJAAkACfwJAAkACQAJAIAEpAwAiDlBFBEAgDkKAgICAgICAgCBaDQEgA0UNAkGgfyABLwEYIA55Ig+nayIFa8FB0ABsQbCnBWpBzhBtIgFB0QBPDQMgCiABQQR0IgFB0NyJAWopAwBCACAOIA+GQgAQqB4gCikDCCAKKQMAQj+IfCIQQUAgBSABQdjciQFqLwEAamsiCEE/ca0iDoinIQUgAUHa3IkBai8BACEBQgEgDoYiEUIBfSISIBCDIg9QBEAgA0EKSw0HIANBAnRBtOmJAWooAgAgBUsNBwsgBUGQzgBPBEAgBUHAhD1JDQUgBUGAwtcvTwRAQQhBCSAFQYCU69wDSSIGGyEHQYDC1y9BgJTr3AMgBhsMBwtBBkEHIAVBgK3iBEkiBhshB0HAhD1BgK3iBCAGGwwGCyAFQeQATwRAQQJBAyAFQegHSSIGGyEHQeQAQegHIAYbDAYLQQpBASAFQQlLIgcbDAULQajYiQFBHEHk6IkBEJ8pAAtB9OiJAUEkQZjpiQEQnykAC0HA6IkBQSFBqOmJARCfKQALIAFB0QBB4OaJARDDIQALQQRBBSAFQaCNBkkiBhshB0GQzgBBoI0GIAYbCyEGAkACQAJAAkAgByABa0EBasEiCSAEwSIBSgRAIAhB//8DcSEMIAkgBGvBIAMgCSABayADSRsiCEEBayENQQAhAQNAIAUgBm4hCyABIANGDQMgBSAGIAtsayEFIAEgAmogC0EwajoAACABIA1GDQQgASAHRg0CIAFBAWohASAGQQpJIAZBCm4hBkUNAAtB4OmJARDiKwALIAAgAiADQQAgCSAEIBBCCoAgBq0gDoYgERDMDQwFCyABQQFqIQEgDEEBa0E/ca0hE0IBIRADQCAQIBOIUEUEQCAAQQA2AgAMBgsgASADTw0DIAEgAmogD0IKfiIPIA6Ip0EwajoAACAQQgp+IRAgDyASgyEPIAggAUEBaiIBRw0ACyAAIAIgAyAIIAkgBCAPIBEgEBDMDQwECyADIANB8OmJARDDIQALIAAgAiADIAggCSAEIAWtIA6GIA98IAatIA6GIBEQzA0MAgsgASADQYDqiQEQwyEACyAAQQA2AgALIApBEGokAAuoFgIXfwJ+IwBBwAFrIgwkACAAAn8CQAJAAkACQCAFIAaEUARAIAcgCIRQRQ0BIABBADoAAUEBDAULIAUgB4MgBiAIg4NCf1IgASAChEIAUnINACADIARCgICAgICAgICAf4WEUA0BCyAMIAEgBEI/hyIghSIBICB9NwOAASAMIAIgIIUiISAgfSABICBUIgqtfTcDiAEgDCADICCFIgMgBEI/iHwiASAKICAgIVYgAlAbrSICfTcDkAEgDCABIANUrSAEICCFfCABIAJUrX03A5gBIAwgCEI/hyIBIAiFIAEgB4UiAyAIQj+IfCICIANUrXwgAiABIAWFIgMgAVQiCiABIAaFIgUgAVQgBlAbrSIGVK19NwO4ASAMIAIgBn03A7ABIAwgBSABfSAKrX03A6gBIAwgAyABfTcDoAEgDEFAayEOIAxBoAFqIRAjAEFAaiIPJAAgDEGAAWoiC0EYaiENQcB9IQoCfwNAQQAgCkFARg0BGiAKQUBrIQogDSkDACEBIA1BCGshDSABUA0AC0EAIAF5pyAKamsLIREgEEEYaiENQcB9IQoCQAJAA0AgCkFARgRAIA9BADYCDAwCCyAKQUBrIQogDSkDACEBIA1BCGshDSABUA0ACyAPQQAgAXmnayIJIAprIg02AgwgCSAKRg0AAkAgDSARTQRAIA1BwQBPBEAjAEHwAWsiCSQAIA1BBnYgDUE/cUEAR2oiCiITIBFBBnYgEUE/cUEAR2ogCmsiDWpBBUkEQCATQQFrIgpBA00EQCAJQagBaiAQIBAgCkEDdCIRaikDAHmnIhUQ1RIgCUHYAGogCUHAAWoiGykDADcDACAJQdAAaiAJQbgBaiIcKQMANwMAIAlByABqIAlBsAFqIh0pAwA3AwAgCSAJKQOoATcDQCAJQeAAaiIQIAsgFRDVEiATQQJrIgpBBEkEQCARIAlBQGsiC2opAwAhAyAKQQN0IAtqKQMAIQUgCUGgAWpCADcDACAJQZgBakIANwMAIAlBkAFqQgA3AwAgCUIANwOIAUEFIA1rIRQgE0EBaiEXIA1BA3QgEGohESANQQZJIR4gDSEKAkACQANAAkACQCAKIhAgE2oiCkEBayISQQRNBEBCfyECIAlB4ABqIgsgCkEDdGoiGCkDACIBIANaDQIgCkECayIKQQVPDQEgCUEwaiASQQN0IAtqKQMAIgYgASADEOMqIAlBIGogCSkDMCICIAkpAzggA0IAEKgeIAYgCSkDIH0hASAKQQN0IAtqKQMAIQYDQCAJQRBqIAJCACAFQgAQqB4CQCAJKQMYIgcgAVIEQCABIAdUDQEMBQsgBiAJKQMQWg0ECyACQgF9IQIgASABIAN8IgFYDQALDAILQX9BBUG894cBEMMhAAsgCkEFQcz3hwEQwyEACyAUIBcgFCAXSRshGSATIBQgEyAUSRshGiAQQQFrIQpCACEBIAlB6AFqIhJCADcDACAJQeABaiIWQgA3AwAgCUHYAWoiH0IANwMAIAlCADcD0AFBACELA0AgCSAJQUBrIAtqKQMAQgAgAkIAEKgeIAlB0AFqIAtqIAEgCSkDACIGfCIBNwMAIAkpAwggASAGVK18IQEgC0EIaiILQSBHDQALIBsgEikDADcDACAcIBYpAwA3AwAgHSAfKQMANwMAIAkgCSkD0AE3A6gBIAkgATcDyAEgHkUNAgJAIBBBBUYNAEIAIQEgCUGoAWohEiARIQsDQCALIAspAwAiBiABIBIpAwAiB3wiAX03AwAgASAHVCABIAZWciIWrSEBIAtBCGohCyASQQhqIRIgGUEBayIZDQALIBZFDQAgAkIBfSECIBggE0EFIBBrIgsgCyATSxsEfkIAIQFBACELA0AgCyARaiISIBIpAwAiBiABIAlBQGsgC2opAwAiB3wiAXwiIDcDACABIAdUIAYgIFZyIhKtIQEgC0EIaiELIBpBAWsiGg0ACyASrQVCAAsgGCkDAHw3AwALIA1BBE8NASAJQYgBaiAQQQN0aiACNwMAIBRBAWohFCARQQhrIREgEA0ACyAOQSBqIQogCUHgAGohC0EAIRACQCAVRQRAIAogCykDADcDACAKQRhqIAtBGGopAwA3AwAgCkEQaiALQRBqKQMANwMAIApBCGogC0EIaikDADcDAAwBCyMAQSBrIg1BEGpCADcDACANQQhqQgA3AwAgDUIANwMAIBVBP3GtIQFBACAVa0E/ca0hAgNAIA0gEGogCyAQaiIRQQhqKQMAIAKGIBEpAwAgAYiENwMAIBBBCGoiEEEYRw0ACyAKIA0pAwA3AwAgCkEIaiANQQhqKQMANwMAIApBEGogDUEQaikDADcDACAKQRhqIAspAxggAYg3AwALIA5BGGogCUGgAWopAwA3AwAgDkEQaiAJQZgBaikDADcDACAOQQhqIAlBkAFqKQMANwMAIA4gCSkDiAE3AwAgCUHwAWokAAwHCyANQQRB7PeHARDDIQALIA1BBUHc94cBEK87AAsgCkEEQaz3hwEQwyEACyAKQQRBnPeHARDDIQALQfD2hwFBHEGM94cBEJ8pAAsgDyAQKQMANwMQIA9CADcDGCAPQThqIhAgC0EYaikDADcDACAPQTBqIhEgC0EQaikDADcDACAPQShqIgkgC0EIaikDADcDACAPIAspAwA3AyAgD0EYaiENIA9BEGohEyMAQSBrIgokAAJAAkAgD0EgaiIUIA9BQGsiC0cEQCANKQMAIQIgEykDACEBA0AgAVANAiAKQRBqIAtBCGsiCykDACIDIAIgARDjKiAKIAopAxAiAiAKKQMYIAFCABCoHiALIAI3AwAgDSADIAopAwB9IgI3AwAgCyAURw0ACwsgCkEgaiQADAELQfz3hwEQ4isACyAOQThqQgA3AwAgDkEwakIANwMAIA5CADcDKCAOIA8pAyA3AwAgDkEIaiAJKQMANwMAIA5BEGogESkDADcDACAOQRhqIBApAwA3AwAgDiAPKQMYNwMgDAELIA5CADcDACAOQRhqQgA3AwAgDkEQakIANwMAIA5BCGpCADcDACAOIAspAwA3AyAgDkEoaiALQQhqKQMANwMAIA5BMGogC0EQaikDADcDACAOQThqIAtBGGopAwA3AwALIA9BQGskAAwBCyAPQgA3AiwgD0KBgICAwAA3AiQgD0HY9ocBNgIgQQEgD0EMakHE9ocBIA9BIGpB4PaHARCvKwALIAxBGGogDEHYAGopAwA3AwAgDEEQaiAMQdAAaikDADcDACAMQQhqIAxByABqKQMANwMAIAxBKGogDEHoAGopAwA3AwAgDEEwaiAMQfAAaikDADcDACAMQThqIAxB+ABqKQMANwMAIAwgDCkDQDcDACAMIAwpA2A3AyAgDiAMEIMuIAwpA1ghBiAMKQNQIQUgDCkDSCEgIAwpA0AhASAOIAxBIGoQgy4gBCAIhUIAUw0BIAEhAwwCCyAAQQE6AAFBAQwCC0IAIAF9IgNCAFJCACAgIAFCAFKtfH0iIEIAUiAgUBtBf3OtQgGDIgEgBUJ/hXwiBSABVK0gBkJ/hXwhBgsgDCkDWCEHIAwpA1AhAiAMKQNIIQggDCkDQCEBAkAgBEIAWQRAIAEhBAwBC0IAIAF9IgRCAFJCACAIIAFCAFKtfH0iCEIAUiAIUBtBf3OtQgGDIgEgAkJ/hXwiAiABVK0gB0J/hXwhBwsgACACNwNAIAAgBDcDMCAAIAU3AyAgACADNwMQIAAgBzcDSCAAIAg3AzggACAGNwMoIAAgIDcDGEEACzoAACAMQcABaiQAC7wHAgV/AX4jAEGQAmsiAiQAIAEpAqgCIQcgAUKAgICAgAI3A6gCIAJBIGogAUG4AmoiAykCADcDACACQRhqIAFBsAJqIgQpAgA3AwAgA0IENwMAIARCADcDACACIAc3AxAgAkEsaiABENgYAn9BgICAgHggASgCwAIiA0GBgICAeEYNABpBgICAgHggA0GAgICAeEYNABogASkCxAIhByABQQA2AsgCIAFCgICAgCA3A8ACIAMLIQMgAUGIA2oQtDAgASAHNwKMAyABIAM2AogDIAEoAugCIgNBgICAgHhHBEAgASkC7AIhByABQQA2AvACIAFCgICAgCA3A+gCCyABQZQDahC0MCABIAc3A5gDIAEgAzYClAMgAUIANwP4AiACIAFBoANqIgQ2AjggAigCGCEDIAJByABqIAJBEGoQ3SwgAiACKQJINwKwASACQQA2AqwBIAIgAigCVCIFNgKoASACIAIoAlA2AqQBIAJBCGogAkGkAWoQ1zsgAigCCCEGQRxBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAqQBNwIIIAFBEGogAkGsAWopAgA3AgAgAUEYaiACQbQBaigCADYCACACIAU2AkQgAiAGNgJAIAIgATYCPCACAn8CQAJAAkAgBC0AAEEXaw4EAQAAAgALIAJBATYCqAEgAkHUhM0ANgKkASACQgE3ArABIAJBrwM2AkwgAiACQcgAajYCrAEgAiACQThqNgJIIAJBpAFqQdyEzQAQ7ywACyACQQA7AfwBIAJBADYC+AEgAkEANgLgASACQQA2AtQBIAIgAzYC0AEgAkEXOgDEASACQgQ3ArwBIAJCADcCtAEgAkKAgICAwAA3AqwBIAJBADYCpAEgAkHIAGoiAyACQaQBaiIBIAJBPGoQ+iMgAkGIAmogAkEkaigCADYCACACIAIpAhw3A4ACIAEgAyACQYACahCYJCADIAEgAkEsahCuFiABIAMQzRwgAQwBCyACQQA7AfwBIAJBADYC+AEgAkEANgLgASACQQA2AtQBIAIgAzYC0AEgAkEaOgDEASACQgQ3ArwBIAJCADcCtAEgAkKAgICAwAA3AqwBIAJBADYCpAEgAkHIAGoiAyACQaQBaiIBIAJBPGoQ+iMgAkGIAmogAkEkaigCADYCACACIAIpAhw3A4ACIAEgAyACQYACahCYJCADIAEgAkEsahCuFiABIAMQzRwgAQsQoAEgACACKQMANwIEIABBCDYCACACQZACaiQADwtBBEEcEKM9AAuJCwMGfwd8An4jAEFAaiICJAACQAJAAkACQAJAIAEtACkiA0EHTUEAQQEgA3RBxgFxG0UEQCACQShqQcsAQQBBAUEBEKAYIAIoAiwhASACKAIoQQFGDQEgAigCMCIEQdS5zwBBywD8CgAAIABBywA2AgwgACAENgIIIAAgATYCBCAAQQA2AgAMBQsgAUEgaiEEIAEoAiAiBUEATA0BIAFBJGohBiABKAIkIgdBAEgNAgJAAkACQAJAIAUgB08EQCADQQFrDgcCAQgICAgECAsgAkEDNgIsIAJB+LjPADYCKCACQgI3AjQgAkGcAzYCHCACIAQ2AhggAkGcAzYCFCACIAY2AhAgAiACQRBqNgIwIABBBGogAkEoahCZDiAAQQA2AgAMCAsgBUESSw0BDAYLIAVBCU0NBSACQQE2AiwgAkHIts8ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEKcYIABBADYCAAwGCyACQQE2AiwgAkGEt88ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEKcYIABBADYCAAwFCyABKAIcIQMgAkECNgIsIAJBqLfPADYCKCACQgE3AjQgAkGcAzYCCCACIAFBHGoiBjYCBCACIAJBBGo2AjAgAkEQakEEciACQShqEJkOIAJBADYCECADQYCAgIABakGAgICAAk8EQCAAIAIpAxg3AwggAEEQaiACQSBqKQMANwMAIAAgAigCFDYCBCAAQQA2AgAMBQsCfAJAAkACf0QAAAAAAAAAQCADQQN0QQFrEN4gRAAAAAAAAPC/oCIIvSIPQoCAgICAgIAIWQRAIA9C//////////f/AFYNA0GBeCEBIA9CIIgiEEKAgMD/A1IEQCAQpwwCC0GAgMD/AyAPpw0BGkQAAAAAAAAAAAwEC0QAAAAAAADwvyAIIAiioyAIRAAAAAAAAAAAYQ0DGiAPQgBTDQFBy3chASAIRAAAAAAAAFBDor0iD0IgiKcLIQMgASADQeK+JWoiAUEUdmq3IgtEAGCfUBNE0z+iIgwgD0L/////D4MgAUH//z9xQZ7Bmv8Daq1CIIaEv0QAAAAAAADwv6AiCCAIIAhEAAAAAAAA4D+ioiIJob1CgICAgHCDvyIKRAAAIBV7y9s/oiINoCIOIA0gDCAOoaAgCCAKoSAJoSAIIAhEAAAAAAAAAECgoyIIIAkgCCAIoiIJIAmiIgggCCAIRJ/GeNAJmsM/okSveI4dxXHMP6CiRAT6l5mZmdk/oKIgCSAIIAggCEREUj7fEvHCP6JE3gPLlmRGxz+gokRZkyKUJEnSP6CiRJNVVVVVVeU/oKKgoKKgIghEAAAgFXvL2z+iIAtENivxEfP+WT2iIAggCqBE1a2ayjiUuz2ioKCgoAwCCyAIIAihRAAAAAAAAAAAoyEICyAICyEIIAJBEGoiARDwGyACIAic/AIiAzYCDCADIAVODQMgAkEDNgIUIAJBpLjPADYCECACQgM3AhwgAkGcAzYCPCACQZwDNgI0IAIgBDYCMCACQZwDNgIsIAIgBjYCKCACIAJBKGo2AhggAiACQQxqNgI4IABBBGogARCnGCAAQQA2AgAMBAsgASACKAIwQeSjzwAQ/S8ACyACQQE2AiwgAkHMuc8ANgIoIAJCATcCNCACQZwDNgIUIAIgBDYCECACIAJBEGo2AjAgAEEEaiACQShqEJkOIABBADYCAAwCCyACQQE2AiwgAkGouc8ANgIoIAJCATcCNCACQZwDNgIUIAIgBjYCECACIAJBEGo2AjAgAEEEaiACQShqEJkOIABBADYCAAwBCyAAQQg2AgALIAJBQGskAAuVBwIJfwF+IwBBkAJrIgIkACACQRhqIAEQ3DsgAiACKAIcIgM2AiACQAJAAkACQCADQQFGBEAgAkEQaiABEO88IAIgAigCFCIDNgIkIANBAUcNASABLQAYQSJHDQIgAiABQRxqNgIoIAJB+AFqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBzOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxC4EyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlQcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGChIgQNgIAIAJCgoSIkKDAgIECNwPwASACIAJB8AFqIgQ2AiwgAiABKAIcIgM2AjAgBCADEMMIRQ0DIAQQwAwgAkEIaiABEO88IAIoAgwEQCAEIAIoAggiA0EYahDSBiADKAIoIQYgAygCJCEHIAJBgAJqIAMQvhUgAkE0aiADQQxqEIALIAMoAiwiBARAIAQgBCgCACIFQQFqNgIAIAVBAEgNBiADKAJAIQUgAygCPCEIIAMoAjghCSADKAI0IQogAygCMCEDCyACQbABaiACQfgBaigCADYCACACQZgBaiACQYgCaigCADYCACACQaQBaiACQTxqKAIANgIAIAIgAikC8AE3A6gBIAIgBjYCuAEgAiAHNgK0ASACIAIpAoACNwOQASACIAIpAjQ3ApwBIAIgBTYC0AEgAiAINgLMASACIAk2AsgBIAIgCjYCxAEgAiADNgLAASACIAQ2ArwBIAIgAkGQAWoiBBCgASACKQMAIQsgACABQRhqENIGIAJBNGoiAyABQcQA/AoAACAEIAMQoRsgAyAEQdjphAEQjBggAkEANgKIAiACQoCAgIDAADcCgAIgBCADIAJBgAJqEPwiIAMgBBDNHCAAQQxqIAMQthMgAEEAOgBEIAAgCzcCPCACQZACaiQADwtBAEEAQdjqhAEQwyEACyACQgA3ApwBIAJCgYCAgMAANwKUASACQcjshAE2ApABQQAgAkEgakH86YQBIAJBkAFqQdDshAEQrysACyACQgA3ApwBIAJCgYCAgMAANwKUASACQfDrhAE2ApABQQAgAkEkakH86YQBIAJBkAFqQfjrhAEQrysACyACQQA2AqABIAJBATYClAEgAkGY64QBNgKQASACQgQ3ApgBIAJBkAFqQaDrhAEQ7ywACyACQYgCakGChIgQNgIAIAJCgoSIkKDAgIECNwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5UHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBh46cODYCACACQoeOnLjw4MGDBzcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEHk6YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEKoTIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBh46cODYCACACQoeOnLjw4MGDBzcDgAIgAkICNwKcASACQQI2ApQBIAJBuOqEATYCkAEgAkHFEzYCQCACQa0DNgI4IAIgAkE0ajYCmAEgAiACQShqNgI8IAIgAkGAAmo2AjQgAkEsaiACQTBqIAJBkAFqQcjqhAEQoysLAAuVBwIJfwF+IwBBkAJrIgIkACACQRhqIAEQ3DsgAiACKAIcIgM2AiACQAJAAkACQCADQQFGBEAgAkEQaiABEO88IAIgAigCFCIDNgIkIANBAUcNASABLQAYQSJHDQIgAiABQRxqNgIoIAJB+AFqQYWKlCg2AgAgAkKFipSo0KDBggU3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBwOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxCxEyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYWKlCg2AgAgAkKFipSo0KDBggU3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlwcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGJkqTIADYCACACQomSpMiQocKECTcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEG06YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEK4TIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A4ACIAJCAjcCnAEgAkECNgKUASACQbjqhAE2ApABIAJBxRM2AkAgAkGtAzYCOCACIAJBNGo2ApgBIAIgAkEoajYCPCACIAJBgAJqNgI0IAJBLGogAkEwaiACQZABakHI6oQBEKMrCwALlQcCCX8BfiMAQZACayICJAAgAkEYaiABENw7IAIgAigCHCIDNgIgAkACQAJAAkAgA0EBRgRAIAJBEGogARDvPCACIAIoAhQiAzYCJCADQQFHDQEgAS0AGEEiRw0CIAIgAUEcajYCKCACQfgBakGEiJAgNgIAIAJChIiQoMCAgYIENwPwASACIAJB8AFqIgQ2AiwgAiABKAIcIgM2AjAgBCADEMMIRQ0DIAQQwAwgAkEIaiABEO88IAIoAgwEQCAEIAIoAggiA0EYahDSBiADKAIoIQYgAygCJCEHIAJBgAJqIAMQvhUgAkE0aiADQQxqEIALIAMoAiwiBARAIAQgBCgCACIFQQFqNgIAIAVBAEgNBiADKAJAIQUgAygCPCEIIAMoAjghCSADKAI0IQogAygCMCEDCyACQbABaiACQfgBaigCADYCACACQZgBaiACQYgCaigCADYCACACQaQBaiACQTxqKAIANgIAIAIgAikC8AE3A6gBIAIgBjYCuAEgAiAHNgK0ASACIAIpAoACNwOQASACIAIpAjQ3ApwBIAIgBTYC0AEgAiAINgLMASACIAk2AsgBIAIgCjYCxAEgAiADNgLAASACIAQ2ArwBIAIgAkGQAWoiBBCgASACKQMAIQsgACABQRhqENIGIAJBNGoiAyABQcQA/AoAACAEIAMQoRsgAyAEQZzphAEQjBggAkEANgKIAiACQoCAgIDAADcCgAIgBCADIAJBgAJqEPwiIAMgBBDNHCAAQQxqIAMQrRMgAEEAOgBEIAAgCzcCPCACQZACaiQADwtBAEEAQdjqhAEQwyEACyACQgA3ApwBIAJCgYCAgMAANwKUASACQcjshAE2ApABQQAgAkEgakH86YQBIAJBkAFqQdDshAEQrysACyACQgA3ApwBIAJCgYCAgMAANwKUASACQfDrhAE2ApABQQAgAkEkakH86YQBIAJBkAFqQfjrhAEQrysACyACQQA2AqABIAJBATYClAEgAkGY64QBNgKQASACQgQ3ApgBIAJBkAFqQaDrhAEQ7ywACyACQYgCakGEiJAgNgIAIAJChIiQoMCAgYIENwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5cHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A/ABIAIgAkHwAWoiBDYCLCACIAEoAhwiAzYCMCAEIAMQwwhFDQMgBBDADCACQQhqIAEQ7zwgAigCDARAIAQgAigCCCIDQRhqENIGIAMoAighBiADKAIkIQcgAkGAAmogAxC+FSACQTRqIANBDGoQgAsgAygCLCIEBEAgBCAEKAIAIgVBAWo2AgAgBUEASA0GIAMoAkAhBSADKAI8IQggAygCOCEJIAMoAjQhCiADKAIwIQMLIAJBsAFqIAJB+AFqKAIANgIAIAJBmAFqIAJBiAJqKAIANgIAIAJBpAFqIAJBPGooAgA2AgAgAiACKQLwATcDqAEgAiAGNgK4ASACIAc2ArQBIAIgAikCgAI3A5ABIAIgAikCNDcCnAEgAiAFNgLQASACIAg2AswBIAIgCTYCyAEgAiAKNgLEASACIAM2AsABIAIgBDYCvAEgAiACQZABaiIEEKABIAIpAwAhCyAAIAFBGGoQ0gYgAkE0aiIDIAFBxAD8CgAAIAQgAxChGyADIARBqOmEARCMGCACQQA2AogCIAJCgICAgMAANwKAAiAEIAMgAkGAAmoQ/CIgAyAEEM0cIABBDGogAxC5EyAAQQA6AEQgACALNwI8IAJBkAJqJAAPC0EAQQBB2OqEARDDIQALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJByOyEATYCkAFBACACQSBqQfzphAEgAkGQAWpB0OyEARCvKwALIAJCADcCnAEgAkKBgICAwAA3ApQBIAJB8OuEATYCkAFBACACQSRqQfzphAEgAkGQAWpB+OuEARCvKwALIAJBADYCoAEgAkEBNgKUASACQZjrhAE2ApABIAJCBDcCmAEgAkGQAWpBoOuEARDvLAALIAJBiAJqQYiQoMAANgIAIAJCiJCgwICBgoQINwOAAiACQgI3ApwBIAJBAjYClAEgAkG46oQBNgKQASACQcUTNgJAIAJBrQM2AjggAiACQTRqNgKYASACIAJBKGo2AjwgAiACQYACajYCNCACQSxqIAJBMGogAkGQAWpByOqEARCjKwsAC5UHAgl/AX4jAEGQAmsiAiQAIAJBGGogARDcOyACIAIoAhwiAzYCIAJAAkACQAJAIANBAUYEQCACQRBqIAEQ7zwgAiACKAIUIgM2AiQgA0EBRw0BIAEtABhBIkcNAiACIAFBHGo2AiggAkH4AWpBg4aMGDYCACACQoOGjJiw4MCBAzcD8AEgAiACQfABaiIENgIsIAIgASgCHCIDNgIwIAQgAxDDCEUNAyAEEMAMIAJBCGogARDvPCACKAIMBEAgBCACKAIIIgNBGGoQ0gYgAygCKCEGIAMoAiQhByACQYACaiADEL4VIAJBNGogA0EMahCACyADKAIsIgQEQCAEIAQoAgAiBUEBajYCACAFQQBIDQYgAygCQCEFIAMoAjwhCCADKAI4IQkgAygCNCEKIAMoAjAhAwsgAkGwAWogAkH4AWooAgA2AgAgAkGYAWogAkGIAmooAgA2AgAgAkGkAWogAkE8aigCADYCACACIAIpAvABNwOoASACIAY2ArgBIAIgBzYCtAEgAiACKQKAAjcDkAEgAiACKQI0NwKcASACIAU2AtABIAIgCDYCzAEgAiAJNgLIASACIAo2AsQBIAIgAzYCwAEgAiAENgK8ASACIAJBkAFqIgQQoAEgAikDACELIAAgAUEYahDSBiACQTRqIgMgAUHEAPwKAAAgBCADEKEbIAMgBEHw6YQBEIwYIAJBADYCiAIgAkKAgICAwAA3AoACIAQgAyACQYACahD8IiADIAQQzRwgAEEMaiADEL0TIABBADoARCAAIAs3AjwgAkGQAmokAA8LQQBBAEHY6oQBEMMhAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHI7IQBNgKQAUEAIAJBIGpB/OmEASACQZABakHQ7IQBEK8rAAsgAkIANwKcASACQoGAgIDAADcClAEgAkHw64QBNgKQAUEAIAJBJGpB/OmEASACQZABakH464QBEK8rAAsgAkEANgKgASACQQE2ApQBIAJBmOuEATYCkAEgAkIENwKYASACQZABakGg64QBEO8sAAsgAkGIAmpBg4aMGDYCACACQoOGjJiw4MCBAzcDgAIgAkICNwKcASACQQI2ApQBIAJBuOqEATYCkAEgAkHFEzYCQCACQa0DNgI4IAIgAkE0ajYCmAEgAiACQShqNgI8IAIgAkGAAmo2AjQgAkEsaiACQTBqIAJBkAFqQcjqhAEQoysLAAumDAIJfwR+IwBBkAFrIgIkACACQcgAaiEEIwBBQGoiAyQAIAEpAwghDCABKAIEIQggA0EANgIEQQQhBSAIrSELIAEoAgAhCiABAn4CQCAIQv////8PIAwgDEL/////D1obp2siB0EAIAcgCE0bQQRPBEAgAyAKIAwgCyALIAxWG6dqKAAAIgc2AgQMAQtBACEHQbi4zAApAgAiDaciBUEIdiEJIA1CIIinIQYgCyANQv8Bg0IEUg0BGgsgDEIEfAsiDDcDCAJAAkACQAJAAkAgBUH/AXEiBUEERwRAAn8CQAJAIAVBAWsOAwABBAULIAkMAQsgBi0ACAtB/wFxQSVHDQIgBEKTgICACDcCAAwFCyADQQRqQfzPzAAQiDsEQEEEIQUCQAJAIAggDCALIAsgDFYbpyIGa0EETwRAIAMgBiAKaigAACIHNgIEQgAhDQwBC0G4uMwAKQIAIg5CCIghDSAOpyEFIA5C/wGDQgRSDQELIAxCBHwhCwsgASALNwMIIAVB/wFxQQRHDQQLIAMgBzYCCCAHRQRAIARCk4CAgAg3AgAMBQsgB0EASARAIANBATYCJCADQZzQzAA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgA0EIajYCOCADQRBqIANBIGoQmQ4gBCADKQIUNwIIIARBEGogA0EcaigCADYCACAEIAMoAhA2AgQgBEGEgICAeDYCAAwFCyAEIAc2AgggBEKTgICAGDcCAAwECyAGLQAIQSVGDQELIAMgBjYCJCADIAlBCHQgBXI2AiAgBCADQSBqEJAfDAILIARCk4CAgAg3AgAgBigCACEEIAYoAgQiBSgCACIHBEAgBCAHEQMACyAFKAIEIgcEQCAEIAcgBSgCCBD4OgsgBkEMQQQQ+DoMAQsgAyAFrUL/AYMgDUIIhoQ3AyAgBCADQSBqEJAfCyADQUBrJAAgAigCUCEDIAIoAkwhBAJAIAIoAkgiBkGTgICAeEcEQCAAIAIpAlQ3AhAgACADNgIMIAAgBDYCCCAAIAY2AgQgAEEBNgIADAELAkACQAJAIARBAXEEQAJAIAFBEGoiBCgCCCIGIANPBEAgBCADNgIIDAELIAQgAyAGaxCMHAsgAkHIAGoiAyABIAEoAhQgASgCGBCfGQJAIAItAEhBBEYNACACKQNIIgtC/wGDQgRRDQAgAiALNwNIIABBBGogAxCQHyAAQQE2AgAMBQsgAkEQaiIDIAEoAhQgASgCGBC3ASACKAIQQYqAgIB4RwRAIAJByABqIgEgA0Ek/AoAACACQfTPzAA2AnAgAkIBNwJ8IAJBmwM2AowBIAIgAkGIAWo2AnggAiABNgKIASACQQE2AnQgAkE4aiACQfAAahCZDgJAAn8CQAJAAkACQAJAAkACQEEBIAIoAkgiAUGAgICAeHMgAUEAThsOBwABAgMEBQYICyACQdgAahCGMCACQcwAagwGCyACQdQAahCGMCACQeAAahCGMCACQcgAagwFCyACQcwAagwECyACQcwAagwDCyACQdgAahCGMCACQcwAagwCCyACQcwAagwBCyACQcwAagsiARDVJiABEOA7CyACKQI4IQsgACACKQJANwIQIAAgCzcCCCAAQoGAgIDAgICAgH83AgAMBQsgAigCHCIDQQRqIQYgA0F7Sw0BIAYgAigCGCIESw0CIAJBEGoiBSACKAIUIgYgBCADIAMgBmooAABrEPY0IAVBChDMIEH//wNxIgUEfyADIAVqIgUgBEsNBCAFIAZqKAAABUEACyEHIAJByABqIgUgBxDSHyACQQhqIAUQhj0gAkEQaiIHIAEgAigCCCACKAIMEJ8ZAkAgAi0AEEEERg0AIAIpAxAiC0L/AYNCBFENACACIAs3AxAgAEEEaiAHEJAfIABBATYCACAFEM8vDAULIAAgAikCSDcCECAAIAM2AgwgACAENgIIIAAgBjYCBCAAQQA2AgAgAEEYaiACQdAAaikCADcCAAwECyAAQQA2AgAgAEEANgIQDAMLIAMgBkHQzMwAELE7AAsgBiAEQdDMzAAQsDsACyAFIARBjMnMABCvOwALIAJBkAFqJAALoQYBC38jAEEwayIHJAACQCADQRFJBEAgAiEJIAAoAgggACgCGGtBA3QgACgCHCIGayIEIAIgA2xPDQEgAwRAIAQgA24hCQwCC0GYt84AEOIrAAtByLbOAEEwQYi3zgAQnykAC0EAIQQCQAJAAkACQAJAAkACQCAGRSAJRXINACABIQUDQCAHQRBqIAAgAxCRDSAHLwEQQQFxRQ0DIAIgBEYNAiAFIAcvARI7AQAgBEEBaiIEIAlPDQEgBUECaiEFIAAoAhwNAAsLIAkgBGsiCkEQSQRAIAQhBgwGCyADQQF0IQwgACgCCCINIAAoAhgiBWshCCABIARBAXRqIQsgACgCBCEOA0AgBEFvSw0DIARBEGoiBiACSw0EIAUgDUsNBSAFIA5qIAggCyADEMgQIAAgBSAMaiIFNgIYIAggDGshCCALQSBqIQsgBiEEIApBEGsiCkEPSw0ACwwFCyACIAJBmLrOABDDIQALQfy4zgBBGkGIus4AEMskAAsgBCAEQRBqQYy4zgAQsTsACyAEQRBqIAJBjLjOABCwOwALIAUgDUGcuM4AEK87AAsCQCAKQQdNIANBCEtyDQAgB0IANwMYIAAoAggiBSAAKAIYIgRPBEAgACgCBCAEaiAFIARrIAdBGGogAxC0FiAAIAMgBGo2AhggByAHKQMYNwIoIAEgBkEBdGohBSAGIAYgAiACIAZJGyIKayELIAdBCDYCJCAHQShqIQxBACEEAkADQCAHIARBAWoiCDYCICAEIAxqLQAAIQ0gBCALakUNASAFIA07AQAgBUECaiEFIAgiBEEIRw0ACyAEIAZqIQYMAgsgCiACQbi5zgAQwyEACyAEIAVB7LjOABCvOwALAkACQCAGIAlJBEAgCSAGayEIIAEgBkEBdGohBSAGIAIgAiAGSRsiASAGayEEA0AgB0EIaiAAIAMQkQ0gBy8BCEEBcUUNAyAERQ0CIAUgBy8BCjsBACAEQQFrIQQgBUECaiEFIAhBAWsiCA0ACwsgB0EwaiQAIAkPCyABIAJBqLnOABDDIQALQfy4zgBBGkGYuc4AEMskAAu1BgIMfwJ+IwBB0ABrIgMkACADIAI2AhwgASgCDCEIIAMgA0EcajYCIAJAAkAgCCAIQQFqIgJNBEACQCABKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAJJBEACfyAEQQFqIgQgAiACIARJGyICQQ9PBEAgAkH/////AUsNBUF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwshAiADQUBrIAFBEGoiBUEMQQggAhCdFCADKAJEIQQgAygCQCIGRQRAIAMoAkghAgwFCyADKQJIIQ8gBEEJaiICBEAgBkH/ASAC/AsACyADIA9CIIg+AjwgAyAPpyIKNgI4IAMgBDYCNCADIAY2AjAgA0KMgICAgAE3AiggAyAFNgIkIANBMGohCyADIAgEfyAGQQhqIQwgASgCACIJKQMAQn+FQoCBgoSIkKDAgH+DIQ9BACECA0AgD1AEQANAIAJBCGohAiAJQQhqIgkpAwBCgIGChIiQoMCAf4MiD0KAgYKEiJCgwIB/UQ0ACyAPQoCBgoSIkKDAgH+FIQ8LIAYgBCADKAIcIAEoAgAgD3qnQQN2IAJqIg1BdGxqQQxrEOwMpyIOcSIFaikAAEKAgYKEiJCgwIB/gyIQUARAQQghBwNAIAUgB2ohBSAHQQhqIQcgBiAEIAVxIgVqKQAAQoCBgoSIkKDAgH+DIhBQDQALCyAPQgF9IA+DIQ8gBiAQeqdBA3YgBWogBHEiBWosAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhBQsgBSAGaiAOQRl2Igc6AAAgDCAFQQhrIARxaiAHOgAAIAYgBUF/c0EMbGoiBSABKAIAIA1Bf3NBDGxqIgcpAAA3AAAgBUEIaiAHQQhqKAAANgAAIAhBAWsiCA0ACyABKAIMBUEACyICNgI8IAMgCiACazYCOCABIAtBBBD6KiADQSRqENAmDAELIAEgA0EgakGUpM8AQQwQxQkLQYGAgIB4IQQMAgsQ4ycgAygCDCECIAMoAgghBAwBCxDjJyADKAIUIQIgAygCECEECyAAIAI2AgQgACAENgIAIANB0ABqJAALtQYCDH8CfiMAQdAAayIDJAAgAyACNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiICTQRAAkAgASgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiACSQRAAn8gBEEBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIQIgA0FAayABQRBqIgVBDEEIIAIQnRQgAygCRCEEIAMoAkAiBkUEQCADKAJIIQIMBQsgAykCSCEPIARBCWoiAgRAIAZB/wEgAvwLAAsgAyAPQiCIPgI8IAMgD6ciCjYCOCADIAQ2AjQgAyAGNgIwIANCjICAgIABNwIoIAMgBTYCJCADQTBqIQsgAyAIBH8gBkEIaiEMIAEoAgAiCSkDAEJ/hUKAgYKEiJCgwIB/gyEPQQAhAgNAIA9QBEADQCACQQhqIQIgCUEIaiIJKQMAQoCBgoSIkKDAgH+DIg9CgIGChIiQoMCAf1ENAAsgD0KAgYKEiJCgwIB/hSEPCyAGIAQgAygCHCABKAIAIA96p0EDdiACaiINQXRsakEMaxDsDKciDnEiBWopAABCgIGChIiQoMCAf4MiEFAEQEEIIQcDQCAFIAdqIQUgB0EIaiEHIAYgBCAFcSIFaikAAEKAgYKEiJCgwIB/gyIQUA0ACwsgD0IBfSAPgyEPIAYgEHqnQQN2IAVqIARxIgVqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQULIAUgBmogDkEZdiIHOgAAIAwgBUEIayAEcWogBzoAACAGIAVBf3NBDGxqIgUgASgCACANQX9zQQxsaiIHKQAANwAAIAVBCGogB0EIaigAADYAACAIQQFrIggNAAsgASgCDAVBAAsiAjYCPCADIAogAms2AjggASALQQQQ+iogA0EkahDQJgwBCyABIANBIGpBjKXPAEEMEMUJC0GBgICAeCEEDAILEOMnIAMoAgwhAiADKAIIIQQMAQsQ4ycgAygCFCECIAMoAhAhBAsgACACNgIEIAAgBDYCACADQdAAaiQAC7UGAgx/An4jAEHQAGsiAyQAIAMgAjYCHCABKAIMIQggAyADQRxqNgIgAkACQCAIIAhBAWoiAk0EQAJAIAEoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgAkkEQAJ/IARBAWoiBCACIAIgBEkbIgJBD08EQCACQf////8BSw0FQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCyECIANBQGsgAUEQaiIFQQxBCCACEJ0UIAMoAkQhBCADKAJAIgZFBEAgAygCSCECDAULIAMpAkghDyAEQQlqIgIEQCAGQf8BIAL8CwALIAMgD0IgiD4CPCADIA+nIgo2AjggAyAENgI0IAMgBjYCMCADQoyAgICAATcCKCADIAU2AiQgA0EwaiELIAMgCAR/IAZBCGohDCABKAIAIgkpAwBCf4VCgIGChIiQoMCAf4MhD0EAIQIDQCAPUARAA0AgAkEIaiECIAlBCGoiCSkDAEKAgYKEiJCgwIB/gyIPQoCBgoSIkKDAgH9RDQALIA9CgIGChIiQoMCAf4UhDwsgBiAEIAMoAhwgASgCACAPeqdBA3YgAmoiDUF0bGpBDGsQ7AynIg5xIgVqKQAAQoCBgoSIkKDAgH+DIhBQBEBBCCEHA0AgBSAHaiEFIAdBCGohByAGIAQgBXEiBWopAABCgIGChIiQoMCAf4MiEFANAAsLIA9CAX0gD4MhDyAGIBB6p0EDdiAFaiAEcSIFaiwAAEEATgRAIAYpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIAZqIA5BGXYiBzoAACAMIAVBCGsgBHFqIAc6AAAgBiAFQX9zQQxsaiIFIAEoAgAgDUF/c0EMbGoiBykAADcAACAFQQhqIAdBCGooAAA2AAAgCEEBayIIDQALIAEoAgwFQQALIgI2AjwgAyAKIAJrNgI4IAEgC0EEEPoqIANBJGoQ0CYMAQsgASADQSBqQZymzwBBDBDFCQtBgYCAgHghBAwCCxDjJyADKAIMIQIgAygCCCEEDAELEOMnIAMoAhQhAiADKAIQIQQLIAAgAjYCBCAAIAQ2AgAgA0HQAGokAAu1BgIMfwJ+IwBB0ABrIgMkACADIAI2AhwgASgCDCEIIAMgA0EcajYCIAJAAkAgCCAIQQFqIgJNBEACQCABKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAJJBEACfyAEQQFqIgQgAiACIARJGyICQQ9PBEAgAkH/////AUsNBUF/IAJBA3RBB25BAWtndkEBagwBC0EEQQhBECACQQhJGyACQQRJGwshAiADQUBrIAFBEGoiBUEMQQggAhCdFCADKAJEIQQgAygCQCIGRQRAIAMoAkghAgwFCyADKQJIIQ8gBEEJaiICBEAgBkH/ASAC/AsACyADIA9CIIg+AjwgAyAPpyIKNgI4IAMgBDYCNCADIAY2AjAgA0KMgICAgAE3AiggAyAFNgIkIANBMGohCyADIAgEfyAGQQhqIQwgASgCACIJKQMAQn+FQoCBgoSIkKDAgH+DIQ9BACECA0AgD1AEQANAIAJBCGohAiAJQQhqIgkpAwBCgIGChIiQoMCAf4MiD0KAgYKEiJCgwIB/UQ0ACyAPQoCBgoSIkKDAgH+FIQ8LIAYgBCADKAIcIAEoAgAgD3qnQQN2IAJqIg1BdGxqQQxrEOwMpyIOcSIFaikAAEKAgYKEiJCgwIB/gyIQUARAQQghBwNAIAUgB2ohBSAHQQhqIQcgBiAEIAVxIgVqKQAAQoCBgoSIkKDAgH+DIhBQDQALCyAPQgF9IA+DIQ8gBiAQeqdBA3YgBWogBHEiBWosAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhBQsgBSAGaiAOQRl2Igc6AAAgDCAFQQhrIARxaiAHOgAAIAYgBUF/c0EMbGoiBSABKAIAIA1Bf3NBDGxqIgcpAAA3AAAgBUEIaiAHQQhqKAAANgAAIAhBAWsiCA0ACyABKAIMBUEACyICNgI8IAMgCiACazYCOCABIAtBBBD6KiADQSRqENAmDAELIAEgA0EgakGEps8AQQwQxQkLQYGAgIB4IQQMAgsQ4ycgAygCDCECIAMoAgghBAwBCxDjJyADKAIUIQIgAygCECEECyAAIAI2AgQgACAENgIAIANB0ABqJAALtQYCDH8CfiMAQdAAayIDJAAgAyACNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiICTQRAAkAgASgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiACSQRAAn8gBEEBaiIEIAIgAiAESRsiAkEPTwRAIAJB/////wFLDQVBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIQIgA0FAayABQRBqIgVBDEEIIAIQnRQgAygCRCEEIAMoAkAiBkUEQCADKAJIIQIMBQsgAykCSCEPIARBCWoiAgRAIAZB/wEgAvwLAAsgAyAPQiCIPgI8IAMgD6ciCjYCOCADIAQ2AjQgAyAGNgIwIANCjICAgIABNwIoIAMgBTYCJCADQTBqIQsgAyAIBH8gBkEIaiEMIAEoAgAiCSkDAEJ/hUKAgYKEiJCgwIB/gyEPQQAhAgNAIA9QBEADQCACQQhqIQIgCUEIaiIJKQMAQoCBgoSIkKDAgH+DIg9CgIGChIiQoMCAf1ENAAsgD0KAgYKEiJCgwIB/hSEPCyAGIAQgAygCHCABKAIAIA96p0EDdiACaiINQXRsakEMaxDsDKciDnEiBWopAABCgIGChIiQoMCAf4MiEFAEQEEIIQcDQCAFIAdqIQUgB0EIaiEHIAYgBCAFcSIFaikAAEKAgYKEiJCgwIB/gyIQUA0ACwsgD0IBfSAPgyEPIAYgEHqnQQN2IAVqIARxIgVqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQULIAUgBmogDkEZdiIHOgAAIAwgBUEIayAEcWogBzoAACAGIAVBf3NBDGxqIgUgASgCACANQX9zQQxsaiIHKQAANwAAIAVBCGogB0EIaigAADYAACAIQQFrIggNAAsgASgCDAVBAAsiAjYCPCADIAogAms2AjggASALQQQQ+iogA0EkahDQJgwBCyABIANBIGpBzKbPAEEMEMUJC0GBgICAeCEEDAILEOMnIAMoAgwhAiADKAIIIQQMAQsQ4ycgAygCFCECIAMoAhAhBAsgACACNgIEIAAgBDYCACADQdAAaiQAC7UGAgx/An4jAEHQAGsiAyQAIAMgAjYCHCABKAIMIQggAyADQRxqNgIgAkACQCAIIAhBAWoiAk0EQAJAIAEoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgAkkEQAJ/IARBAWoiBCACIAIgBEkbIgJBD08EQCACQf////8BSw0FQX8gAkEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAJBCEkbIAJBBEkbCyECIANBQGsgAUEQaiIFQQxBCCACEJ0UIAMoAkQhBCADKAJAIgZFBEAgAygCSCECDAULIAMpAkghDyAEQQlqIgIEQCAGQf8BIAL8CwALIAMgD0IgiD4CPCADIA+nIgo2AjggAyAENgI0IAMgBjYCMCADQoyAgICAATcCKCADIAU2AiQgA0EwaiELIAMgCAR/IAZBCGohDCABKAIAIgkpAwBCf4VCgIGChIiQoMCAf4MhD0EAIQIDQCAPUARAA0AgAkEIaiECIAlBCGoiCSkDAEKAgYKEiJCgwIB/gyIPQoCBgoSIkKDAgH9RDQALIA9CgIGChIiQoMCAf4UhDwsgBiAEIAMoAhwgASgCACAPeqdBA3YgAmoiDUF0bGpBDGsQ7AynIg5xIgVqKQAAQoCBgoSIkKDAgH+DIhBQBEBBCCEHA0AgBSAHaiEFIAdBCGohByAGIAQgBXEiBWopAABCgIGChIiQoMCAf4MiEFANAAsLIA9CAX0gD4MhDyAGIBB6p0EDdiAFaiAEcSIFaiwAAEEATgRAIAYpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIAZqIA5BGXYiBzoAACAMIAVBCGsgBHFqIAc6AAAgBiAFQX9zQQxsaiIFIAEoAgAgDUF/c0EMbGoiBykAADcAACAFQQhqIAdBCGooAAA2AAAgCEEBayIIDQALIAEoAgwFQQALIgI2AjwgAyAKIAJrNgI4IAEgC0EEEPoqIANBJGoQ0CYMAQsgASADQSBqQdSlzwBBDBDFCQtBgYCAgHghBAwCCxDjJyADKAIMIQIgAygCCCEEDAELEOMnIAMoAhQhAiADKAIQIQQLIAAgAjYCBCAAIAQ2AgAgA0HQAGokAAvJBgEHfyMAQfAAayIFJAAgBUHMAGogASAEEN0QIAUoAlQhCSAFKAJQIQQCQCAFKAJMIgZBioCAgHhHBEAgACAFKQJYNwIMIABBHGogBUHoAGopAgA3AgAgAEEUaiAFQeAAaikCADcCACAAIAk2AgggACAENgIEIAAgBjYCAAwBCwJAAkAgBEEBcQRAIAVBzABqIAEoAgAiByAJEJMOIAUoAlAhBCAFKAJMIgZBioCAgHhHBEAgBUHIAGogBUHsAGooAgA2AgAgBUFAayAFQeQAaikCADcCACAFQThqIAVB3ABqKQIANwIAIAUgBSkCVDcCMCAFIAQ2AiwgBSAGNgIoDAMLIAVBzABqIAdBfyAEIAlqIgYgBCAGSxsQoRAgBSgCVCEEIAUoAlAhBiAFKAJMIghBioCAgHhHBEAgBUHEAGogBUHoAGopAgA3AgAgBUE8aiAFQeAAaikCADcCACAFIAUpAlg3AjQgBSAENgIwIAUgBjYCLCAFIAg2AigMAwsgBygCACEIIAcoAgQiCyAESwRAIAQgCGotAABFIQoLAkAgBCAGTwRAIAQgC0sNASAFQcwAaiAGIAhqIAQgBmsQnQkgBSgCTEEBRgRAIAVBxABqIQcgBUFAayEIIAUgBSkCUDcCOCAFQgQ3AjAgBUKCgICACDcCKAwECyAKIAcoAggtAAxyQQFxRQRAIAVBPGohByAFQThqIQggBUIENwIwIAVCg4CAgAg3AigMBAsgBUGKgICAeDYCKAwECyAGIARBjOX+ABCxOwALIAQgC0GM5f4AELA7AAsgAEGKgICAeDYCACAAIAEpAgA3AgQgAEEMaiABQQhqKQIANwIADAILIAcgBDYCACAIIAY2AgALIAUgAzYCXCAFIAI2AlggBUGAgICAeDYCVCAFIAk2AlAgBUEBNgJMIABBBGohAiAFQQRqIAVBKGogBUHMAGoQgRQCQCAFKAIEIgNBioCAgHhHBEAgAiAFKQIINwIAIAJBGGogBUEgaikCADcCACACQRBqIAVBGGopAgA3AgAgAkEIaiAFQRBqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgAzYCAAsgBUHwAGokAAvJBgEHfyMAQfAAayIFJAAgBUHMAGogASAEEN0QIAUoAlQhCSAFKAJQIQQCQCAFKAJMIgZBioCAgHhHBEAgACAFKQJYNwIMIABBHGogBUHoAGopAgA3AgAgAEEUaiAFQeAAaikCADcCACAAIAk2AgggACAENgIEIAAgBjYCAAwBCwJAAkAgBEEBcQRAIAVBzABqIAEoAgAiByAJEJQOIAUoAlAhBCAFKAJMIgZBioCAgHhHBEAgBUHIAGogBUHsAGooAgA2AgAgBUFAayAFQeQAaikCADcCACAFQThqIAVB3ABqKQIANwIAIAUgBSkCVDcCMCAFIAQ2AiwgBSAGNgIoDAMLIAVBzABqIAdBfyAEIAlqIgYgBCAGSxsQoRAgBSgCVCEEIAUoAlAhBiAFKAJMIghBioCAgHhHBEAgBUHEAGogBUHoAGopAgA3AgAgBUE8aiAFQeAAaikCADcCACAFIAUpAlg3AjQgBSAENgIwIAUgBjYCLCAFIAg2AigMAwsgBygCACEIIAcoAgQiCyAESwRAIAQgCGotAABFIQoLAkAgBCAGTwRAIAQgC0sNASAFQcwAaiAGIAhqIAQgBmsQnQkgBSgCTEEBRgRAIAVBxABqIQcgBUFAayEIIAUgBSkCUDcCOCAFQgQ3AjAgBUKCgICACDcCKAwECyAKIAcoAggtAAxyQQFxRQRAIAVBPGohByAFQThqIQggBUIENwIwIAVCg4CAgAg3AigMBAsgBUGKgICAeDYCKAwECyAGIARB0Pb+ABCxOwALIAQgC0HQ9v4AELA7AAsgAEGKgICAeDYCACAAIAEpAgA3AgQgAEEMaiABQQhqKQIANwIADAILIAcgBDYCACAIIAY2AgALIAUgAzYCXCAFIAI2AlggBUGAgICAeDYCVCAFIAk2AlAgBUEBNgJMIABBBGohAiAFQQRqIAVBKGogBUHMAGoQgRQCQCAFKAIEIgNBioCAgHhHBEAgAiAFKQIINwIAIAJBGGogBUEgaikCADcCACACQRBqIAVBGGopAgA3AgAgAkEIaiAFQRBqKQIANwIADAELIAIgASkCADcCACACQQhqIAFBCGopAgA3AgALIAAgAzYCAAsgBUHwAGokAAu8BQEGfyMAQdAOayIGJAAgBkEIaiIIQQBBiAj8CwAgBkGQCGoiB0EAQcAF/AsAIAZB0A1qIglBAEGAAfwLACAAQYABQcAAQQ8gCEGBASABQYABEOsIIABBgAJqQcAAQcAAQQ4gCEGBASABQUBrIgBBwAAQ6wggB0EYIAFBGGoiCEEYQeiI0gAQ1SwgBkGoCGpBCCABQQhB6IjSABDVLCAGQbAIakEIIAFBMGoiCkEIQeiI0gAQ1SwgBkG4CGpBCCABQQhqQQhB6IjSABDVLCAGQcAIakEIIAFBOGoiC0EIQeiI0gAQ1SwgBkHICGpBCCABQRBqQQhB6IjSABDVLCAHQcAFQcAAIAlBwAAQswsgAiAGKQGADjcBACACIAYpAaAONwEQIAJBCGogBkGIDmopAQA3AQAgAkEYaiAGQagOaikBADcBACACIAYpAcAONwEgIAJBKGogBkHIDmopAQA3AQAgAkEwaiAJQeAA/AoAACACQegAaiAGQZgOaikBADcBACACIAYpAZAONwFgIAIgBikBsA43AXAgAkH4AGogBkG4DmopAQA3AQAgAEHAAEHAACACQYABakHAABCzC0EAIQIgB0EAQcAA/AsAIAdBCCAIQQhB6IjSABDVLCAGQdAIakEIIAFBIGpBCEHoiNIAENUsIAZBkAlqQQggAUEoakEIQeiI0gAQ1SwgBkHQCWpBCCAKQQhB6IjSABDVLCAGQZALakEIIAtBCEHoiNIAENUsA0AgBkGQCGoiCCACaiIHQYABaiABLQAAOgAAIAdBgAJqIAFBCGotAAA6AAAgB0HAA2ogAUEQai0AADoAACABQQFqIQEgAkEIaiICQcAARw0ACyAIQcAFQcAFIAZBCGoiAUGBASADIAQgBRDhByAAQcAAQcAAIAFBgQEgAyAEIAUQ4QcgBkHQDmokAAuHBgEIfyABKAIAQQJ0QQRqIQogA0UEQCAKBEAgAEEAIAr8CwALIAFBADYCAEEADwsgBUEAQYAg/AsAIAVBgBhqIQggBUGAEGohCSAFQYAIaiELIAIgA2oiDEEPayENIAIoAAAhAwN/IA0gAkEEaiIHTQR/A38gAiAMTwR/QQAhA0EAIQgDfyADQYAIRgR/IAVB/AdqIQJBgAIhAwNAIANBAWshAyACKAIAIAJBBGshAkUNAAsCfyAEBEBBUCADIAEoAgBLDQEaCyABIAM2AgAgCgRAIAAgBSAK/AoAAAsgCAsFIAMgBWoiAiACKAIAIAJBgBhqKAIAIAJBgBBqKAIAIAJBgAhqKAIAampqIgI2AgAgAiAIIAIgCEsbIQggA0EEaiEDDAELCwUgBSACLQAAQQJ0aiIDIAMoAgBBAWo2AgAgAkEBaiECDAELCwUgBygAACEHIAUgA0H/AXFBAnRqIgYgBigCAEEBajYCACALIANBBnZB/AdxaiIGIAYoAgBBAWo2AgAgCSADQQ52QfwHcWoiBiAGKAIAQQFqNgIAIAggA0EWdkH8B3FqIgMgAygCAEEBajYCACACQQhqKAAAIQMgBSAHQf8BcUECdGoiBiAGKAIAQQFqNgIAIAsgB0EGdkH8B3FqIgYgBigCAEEBajYCACAJIAdBDnZB/AdxaiIGIAYoAgBBAWo2AgAgCCAHQRZ2QfwHcWoiByAHKAIAQQFqNgIAIAJBDGooAAAhByAFIANB/wFxQQJ0aiIGIAYoAgBBAWo2AgAgCyADQQZ2QfwHcWoiBiAGKAIAQQFqNgIAIAkgA0EOdkH8B3FqIgYgBigCAEEBajYCACAIIANBFnZB/AdxaiIDIAMoAgBBAWo2AgAgAkEQaiICKAAAIQMgBSAHQf8BcUECdGoiBiAGKAIAQQFqNgIAIAsgB0EGdkH8B3FqIgYgBigCAEEBajYCACAJIAdBDnZB/AdxaiIGIAYoAgBBAWo2AgAgCCAHQRZ2QfwHcWoiByAHKAIAQQFqNgIADAELCwuYBgENfyMAQdAAayICJAAgAiABKAIYIgU2AgQgAkE4aiABKAIgIAEoAiQiBCgCCEEBa0F4cWpBCGogBCgCOBEAAAJAAkACQAJAAkAgAigCOCILRQRAIABBADYCAAwBCyACQRxqIAJBzABqKAIANgIAIAJBFGogAkHEAGopAgA3AgAgAiACKQI8NwIMIAIgCzYCCEHAACEEIAVBA3YgBUEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAJCADcCLCACIAQ2AiggAiADNgIkIAJBwAA2AiAgASgCECIMIAEoAhRBeHFqIQ4gASgCHCENQQAhBEEAIQFBACEDA0AgASEIIAZBAWshBiAMIQECQANAIAEgDkYNASAGQQFqIQYgASgCACEJIAFBCGoiDCEBIAkgDUkNAAsgBiACKAIYTw0FIAUgCSANayIJIAUgCUkbIQEgAigCDCACKAIUIAZqIgpBA3ZqLQAAIApBB3F2QQFxRQRAIAMgCEkEQCACQSBqIAggA2sQ6BAgAigCMCEHIAIoAiwhBAsgBCAHIAEgCGtqIgdBA3YgB0EHcUEAR2oiA0kEQCADIARrIQggAigCJCIKIANJBEAgAkEgaiAKQQF0IgQgA0HA////A3FBQGsgAyADQT9xGyIKIAQgCksbEOgZIAIoAiwhBAsgCARAIAIoAiggBGpBACAI/AsACyACIAM2AiwgAyEECyACIAc2AjAgASEDCyAGQQFqIQYgBSAJSw0BCwsgAyAFSQRAIAJBIGogBSADaxDoECACKAIwIQcLIAIgBzYCNCAFIAdHDQQgAkE4aiIBIAJBIGoiBBCIFCAAIAEQ4ScgBBDPLyALIAsoAgAiAEEBazYCACAAQQFHDQAgAkEIahD7HgsgAkHQAGokAA8LQfT0hAFBKSACQThqQdD2hAFBoPWEARDVHgALQcAAIAMQoz0AC0HE9IQBQSBB5PSEARCfKQALIAJBADYCOEEAIAJBNGogAkEEaiACQThqQYz7hAEQrysAC5gGAQ1/IwBB0ABrIgIkACACIAEoAhgiBTYCBCACQThqIAEoAiAgASgCJCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAI4IgtFBEAgAEEANgIADAELIAJBHGogAkHMAGooAgA2AgAgAkEUaiACQcQAaikCADcCACACIAIpAjw3AgwgAiALNgIIQcAAIQQgBUEDdiAFQQdxQQBHaiIDQcD///8DcUFAayADIANBP3EbIgNBwAAQ0TRFDQEgAwRAIANBwAAQrTYiBEUNAwsgAkIANwIsIAIgBDYCKCACIAM2AiQgAkHAADYCICABKAIQIgwgASgCFEF8cWohDiABKAIcIQ1BACEEQQAhAUEAIQMDQCABIQggBkEBayEGIAwhAQJAA0AgASAORg0BIAZBAWohBiABKAIAIQkgAUEEaiIMIQEgCSANSQ0ACyAGIAIoAhhPDQUgBSAJIA1rIgkgBSAJSRshASACKAIMIAIoAhQgBmoiCkEDdmotAAAgCkEHcXZBAXFFBEAgAyAISQRAIAJBIGogCCADaxDoECACKAIwIQcgAigCLCEECyAEIAcgASAIa2oiB0EDdiAHQQdxQQBHaiIDSQRAIAMgBGshCCACKAIkIgogA0kEQCACQSBqIApBAXQiBCADQcD///8DcUFAayADIANBP3EbIgogBCAKSxsQ6BkgAigCLCEECyAIBEAgAigCKCAEakEAIAj8CwALIAIgAzYCLCADIQQLIAIgBzYCMCABIQMLIAZBAWohBiAFIAlLDQELCyADIAVJBEAgAkEgaiAFIANrEOgQIAIoAjAhBwsgAiAHNgI0IAUgB0cNBCACQThqIgEgAkEgaiIEEIgUIAAgARDhJyAEEM8vIAsgCygCACIAQQFrNgIAIABBAUcNACACQQhqEPseCyACQdAAaiQADwtB9PSEAUEpIAJBOGpB0PaEAUGg9YQBENUeAAtBwAAgAxCjPQALQcT0hAFBIEHk9IQBEJ8pAAsgAkEANgI4QQAgAkE0aiACQQRqIAJBOGpBjPuEARCvKwALmAYBDX8jAEHQAGsiAiQAIAIgASgCGCIFNgIEIAJBOGogASgCICABKAIkIgQoAghBAWtBeHFqQQhqIAQoAjgRAAACQAJAAkACQAJAIAIoAjgiC0UEQCAAQQA2AgAMAQsgAkEcaiACQcwAaigCADYCACACQRRqIAJBxABqKQIANwIAIAIgAikCPDcCDCACIAs2AghBwAAhBCAFQQN2IAVBB3FBAEdqIgNBwP///wNxQUBrIAMgA0E/cRsiA0HAABDRNEUNASADBEAgA0HAABCtNiIERQ0DCyACQgA3AiwgAiAENgIoIAIgAzYCJCACQcAANgIgIAEoAhAiDCABKAIUQX5xaiEOIAEoAhwhDUEAIQRBACEBQQAhAwNAIAEhCCAGQQFrIQYgDCEBAkADQCABIA5GDQEgBkEBaiEGIAEuAQAhCSABQQJqIgwhASAJIA1JDQALIAYgAigCGE8NBSAFIAkgDWsiCSAFIAlJGyEBIAIoAgwgAigCFCAGaiIKQQN2ai0AACAKQQdxdkEBcUUEQCADIAhJBEAgAkEgaiAIIANrEOgQIAIoAjAhByACKAIsIQQLIAQgByABIAhraiIHQQN2IAdBB3FBAEdqIgNJBEAgAyAEayEIIAIoAiQiCiADSQRAIAJBIGogCkEBdCIEIANBwP///wNxQUBrIAMgA0E/cRsiCiAEIApLGxDoGSACKAIsIQQLIAgEQCACKAIoIARqQQAgCPwLAAsgAiADNgIsIAMhBAsgAiAHNgIwIAEhAwsgBkEBaiEGIAUgCUsNAQsLIAMgBUkEQCACQSBqIAUgA2sQ6BAgAigCMCEHCyACIAc2AjQgBSAHRw0EIAJBOGoiASACQSBqIgQQiBQgACABEOEnIAQQzy8gCyALKAIAIgBBAWs2AgAgAEEBRw0AIAJBCGoQ+x4LIAJB0ABqJAAPC0H09IQBQSkgAkE4akHQ9oQBQaD1hAEQ1R4AC0HAACADEKM9AAtBxPSEAUEgQeT0hAEQnykACyACQQA2AjhBACACQTRqIAJBBGogAkE4akGM+4QBEK8rAAv6BgIKfxF+IwBBoAFrIgIkACABKAK8AiIEIAQoAgAiA0EBajYCACADQQBOBEAgAkEIaiABQYACahDWHgJAIAEoAowCQYCAgIB4RwRAIAJBFGogAUGMAmoQ3SAMAQsgAkGAgICAeDYCFAsgASgCAEEBRgRAIAEpAwghEkIBIQ0LIAEoAhBBAUYEQCABKQMYIRNCASEMCyABKQP4ASEUIAEpA/ABIRUgASkD6AEhFiABKALUASEDIAEoAtABIQUgASkD4AEhFyABKQPYASEYAkAgASkDYEIIUgRAIAJBIGogAUHgAGoQoAQMAQsgAkIINwMgCwJAIAEoApgCQYCAgIB4RwRAIAJB/ABqIAFBmAJqELUWDAELIAJBgICAgHg2AnwLIAEoAiBBAUYEQCABKQMoIRlCASEPCyABKAIwQQFGBEAgASkDOCEaQgEhDgsgASgCQEEBRgRAIAEpA0ghG0IBIRELIAEoAlBBAUYEQCABKQNYIRxCASEQCyABKAK8ASEGIAEoArgBIQcgASgCxAEhCCABKALAASEJIAEoAswBIQogASgCyAEhCwJAIAEoAqQCQYCAgIB4RwRAIAJBiAFqIAFBpAJqEKUdDAELIAJBgICAgHg2AogBCwJAIAEoArACQYCAgIB4RwRAIAJBlAFqIAFBsAJqEKUdDAELIAJBgICAgHg2ApQBCyAAIAQ2ArwCIAAgAikCCDcCgAIgACACKQIUNwKMAiAAIBc3A+ABIAAgGDcD2AEgACAUNwP4ASAAIBU3A/ABIAAgFjcD6AEgACADNgLUASAAIAU2AtABIAAgEzcDGCAAIAw3AxAgACASNwMIIAAgDTcDACAAQYgCaiACQRBqKAIANgIAIABBlAJqIAJBHGooAgA2AgAgAEHgAGogAkEgakHYAPwKAAAgACAGNgK8ASAAIAc2ArgBIAAgGTcDKCAAIA83AyAgACAINgLEASAAIAk2AsABIAAgGjcDOCAAIA43AzAgACAKNgLMASAAIAs2AsgBIAAgGzcDSCAAIBE3A0AgACAcNwNYIAAgEDcDUCAAQaACaiACQYQBaigCADYCACAAIAIpAnw3ApgCIAAgAikCiAE3AqQCIABBrAJqIAJBkAFqKAIANgIAIABBuAJqIAJBnAFqKAIANgIAIAAgAikClAE3ArACIAJBoAFqJAAPCwALhwYCDn8CfiMAQSBrIg8kAAJAAkACQCAEIAdxIhAgA00EQCALKAIIIQwgACgCLCEYIAIgEGoiFSADIBBrIhYQth4hEiAMIBBqIg4gA08NASACIA5qLQAAIQ4gCykDACEaIAtBADYCDCAHIAYoAgAiEWsiBiAHTw0DAkAgAyAEIAZxIgYgDGoiDUsEQCAOIAIgDWotAABGDQEMBQsgDSADQdTLzgAQwyEACyADIAZJDQIgAiAGaiADIAZrIBUgFiAIEPQBIg1FDQMgDSAGIAUQoS4iDCAYEPI0IRogCyARNgIQIAsgDDYCCCALIBo3AwAgAyAMIBBqIgZLBEAgAiAGai0AACEOQQEhFwwECyAGIANB9MvOABDDIQALIBAgA0Gky84AEK87AAsgDiADQbTLzgAQwyEACyAGIANB5MvOABCvOwALAkACQAJAAkAgEiAAKAIEIg1NBEAgDSASayIGQQNNDQEgACgCACASQQJ0aiEZQQAhEQJAAkADQCARQRBHBEAgESAZaigCACITIARxIgYgDGoiFCADTw0CIBFBBGohESAHIBNrIhNBAWsgCU8NASAOIAIgFGotAABHDQEgAyAGSQ0HIAIgBmogAyAGayAVIBYgCBD0ASIURQ0BIBogFCAGIAUQoS4iBiATIBgQjC0iG1oNASALIBM2AhAgCyAGNgIIIAsgGzcDACAGIBBqIgwgA08NAyACIAxqLQAAIQ5BASEXIBshGiAGIQwMAQsLIBcgAUVyRQ0EIBcgAUEAR3IhBgwGCyAUIANB9MzOABDDIQALIAwgA0GUzc4AEMMhAAsgD0EANgIYIA9BATYCDCAPQZjXzgA2AgggD0IENwIQIA9BCGpBxMzOABDvLAALQQQgBkHUzM4AELA7AAsgASAAIBUgFiAIIAkgCiALEOkUIQYgACgCBCENDAELIAYgA0GEzc4AEK87AAsgDSASIAdBA3ZBA3FqIgFNBEAgASANQeTMzgAQwyEACyAAKAIAIAFBAnRqIAc2AgAgD0EgaiQAIAZBAXEL3AUCDH8DfiMAQaABayIJJAAgCUEAQaAB/AsAAkACQAJAIAIgACgCoAEiBU0EQCAFQSlPDQEgASACQQJ0aiEMAkACQCAFBEAgBUEBaiENIAVBAnQhCgNAIAkgBkECdGohAwNAIAYhAiADIQQgASAMRg0IIANBBGohAyACQQFqIQYgASgCACEHIAFBBGoiCyEBIAdFDQALIAetIRFCACEPIAohByACIQEgACEDA0AgAUEoTw0EIAQgDyAENQIAfCADNQIAIBF+fCIQPgIAIBBCIIghDyAEQQRqIQQgAUEBaiEBIANBBGohAyAHQQRrIgcNAAsgCCAQQoCAgIAQWgR/IAIgBWoiAUEoTw0DIAkgAUECdGogDz4CACANBSAFCyACaiIBIAEgCEkbIQggCyEBDAALAAsDQCABIAxGDQYgBEEBaiEEIAEoAgAgAUEEaiEBRQ0AIAggBEEBayICIAIgCEkbIQgMAAsACyABQShBkIyKARDDIQALIAFBKEGQjIoBEMMhAAsgBUEpTw0BIAJBAnQhDCACQQFqIQ0gACAFQQJ0aiEOIAAhAwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdBAWohByADKAIAIQogA0EEaiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIgBCAPIAQ1AgB8IAY1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsiCg0ACwJAIAggEEKAgICAEFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIAhJGyEIIAUhAwwBCwsgA0EoQZCMigEQwyEACyADQShBkIyKARDDIQALIAVBKEGQjIoBELA7AAsgBUEoQZCMigEQsDsACyAAIAlBoAH8CgAAIAAgCDYCoAEgCUGgAWokAAuWDQIKfwJ+IwBBkAFrIgIkAAJAIAFFBEAgAEICNwMADAELIAEgASgCAEECdCIDQeCkzgBqKAIAaigCACEEIAEgA0GApc4AaigCAGopAwAhDCABIANBoKTOAGooAgBqKAIAIQcgASADQcCkzgBqKAIAaikDACENQYCAgIB4IQkgAkGAgICAeDYCPCACQYCAgIB4NgIwIAJBggQ7AWAgAkGAgICAeDYCVCACQYCAgIB4NgJIIAIgDTcDKCACIAcgDUIAWXGtNwMgIAIgDDcDGCACIAQgDEIAWXGtNwMQIwBBEGsiAyQAIAJBCGoiBAJ/AkACQAJAAkACQAJAAkACQCABKAIAQQFrDgcBAgMEBQYHAAtBASEFIAFBLGpBACABLQAsQQJHGwwHC0EEIQUgAUEsakEAIAEoAigbDAYLQQghBSABQRBqQQAgASgCCBsMBQtBDCEFIAFBLGpBACABKAIoGwwEC0EEIQUgAUEsakEAIAEoAigbDAMLQQghBSABQRBqQQAgASgCCBsMAgsgAyABQQhqEO4nIAMoAgQhBSADKAIADAELIANBCGogAUEIahDuJyADKAIMIQUgAygCCAs2AgAgBCAFNgIEIANBEGokAAJAAkACQAJAAkAgAigCCCIGRQRAQYCAgIB4IQoMAQsgAkGEAWogAigCDCIHQQBBAUEBEKAYIAIoAogBIQogAigChAFBAUYNASACKAKMASEIIAdFDQAgCCAGIAf8CgAACyMAQRBrIgQkACACAn8CQAJAAkACQAJAAkACQAJAIAEoAgBBAWsOBwECAwQFBgcAC0EBIQMgAUEtakEAIAEtAC1BAkcbDAcLQQQhAyABQTRqQQAgASgCMBsMBgtBCCEDIAFBIGpBACABKAIYGwwFC0EMIQMgAUE8akEAIAEoAjgbDAQLQQQhAyABQTRqQQAgASgCMBsMAwtBCCEDIAFBIGpBACABKAIYGwwCCyAEIAFBCGoQ7ycgBCgCBCEDIAQoAgAMAQsgBEEIaiABQQhqEO8nIAQoAgwhAyAEKAIICzYCACACIAM2AgQgBEEQaiQAAkAgAigCACIERQ0AIAJBhAFqIAIoAgQiBkEAQQFBARCgGCACKAKIASEJIAIoAoQBQQFGDQIgAigCjAEhCyAGRQ0AIAsgBCAG/AoAAAsCfwJAAkACQAJAAkACQAJAAkACQAJAIAEoAgBBAWsOBwECAwQFBgcACyABLQApIAEtACxBAkdxDAkLIAEoAiggAS0AOXEMCAsgASgCCCABLQBJcQwHCyABKAIoIAEtAElxDAYLIAEoAiggAS0AOXEMBQsgASgCCCABLQBJcQwECyABKAIoDQEMAgsgASgCKEUNAQsgAS0AUQwBC0EAC0EBcSEFAn8CQAJAAkACQAJAAkACQAJAAkACQCABKAIAQQFrDgcBAgMEBQYHAAsgAS0AKCABLQAtQQJHcQwJCyABKAIwIAEtADhxDAgLIAEoAhggAS0ASHEMBwsgASgCOCABLQBIcQwGCyABKAIwIAEtADhxDAULIAEoAhggAS0ASHEMBAsgASgCPA0BDAILIAEoAjxFDQELIAEtAFAMAQtBAAtBAXEhAyACIAc2AnQgAiAINgJwIAIgCjYCbCACIAY2AoABIAIgCzYCfCACIAk2AnggASABKAIAQQJ0QYCkzgBqKAIAai0AAEUNA0GAgICAeCEHIApBgICAgHhHBEAgAkGEAWogAkHsAGoQ5x4gAigChAEhByACKQKIASEMCyACQTBqIQggAkE8ahCGMCACIAw3A0AgAiAHNgI8IAlBgICAgHhHIgQgAigCMEGAgICAeEdxDQJBgICAgHghBiAEBEAgAkGEAWogAkH4AGoQ5x4gAigChAEhBiACKQKIASEMCyAIEIYwIAIgDDcCNCACIAY2AjAMAwsgCiACKAKMAUGch84AEP0vAAsgCSACKAKMAUGch84AEP0vAAsgAkEANgI4IAggCyAGIAtqEL0mCyABIAEoAgBBAnRB4KPOAGooAgBqLQAARQRAIAJB1ABqIgEQhjAgAUEIaiACQfQAaigCADYCACABIAIpAmw3AgAgAkHIAGoiARCGMCABQQhqIAJBgAFqKAIANgIAIAEgAikCeDcCACACIAU6AGEgAiADOgBgIAAgAkEQakHYAPwKAAAMAQsgAiADOgBgIAIgBToAYSAAIAJBEGpB2AD8CgAAIAJB+ABqEIYwIAJB7ABqEIYwCyACQZABaiQAC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC4CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC5CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC6CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC7CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC8CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBC9CEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC4IGAg1/Bn4jAEEwayIDJABBwAAhCgJAAkAgAUEGdiIEIAFBP3EiCEEAR2oiBUEDdCIGQcD///8DcUFAayAGIAVBB3EbIgtBwAAQ0TQEQCALBEAgC0HAABCtNiIKRQ0CCyABQcAASQ0CIAStIRQgAigCCCENIAIoAgAhBiACKAIEIg+tIRUDQCASQgF8IRIgBiEEIAkhBUIAIRBCACERA0ACQCAVIBAgE3xWBEAgBCgCACIOIA0oAggiDEkNASAOIAxB+PWDARDDIQALIAUgD0Ho9YMBEMMhAAsgBEEEaiEMIARBCGohBCAFQQFqIQUgDSgCBCAOQQJ0aigCACAMKAIAEI87rSAQhiARhCERIBBCAXwiEELAAFINAAsgByAKaiARNwMAIBNCQH0hEyAGQYAEaiEGIAlBQGshCSAHQQhqIQcgEiAUUg0ACwwCC0Hw9IMBQSkgA0EcakGs9YMBQZz1gwEQ1R4AC0HAACALEKM9AAsgCARAIAIoAgQiBiABQUBxIgVrIgRBACAEIAZNG60hEiACKAIAIAFBA3RBgHxxaiEEIAitIRMgAigCCCECQgAhEEIAIREDQAJAIBAgElIEQCAEKAIAIgkgAigCCCIISQ0BIAkgCEH49YMBEMMhAAsgBSAGQej1gwEQwyEACyAEQQRqIQggBEEIaiEEIAVBAWohBSACKAIEIAlBAnRqKAIAIAgoAgAQjzutIBCGIBGEIREgEEIBfCIQIBNSDQALIAcgCmogETcAACAHQQhqIQcLIAMgCzYCLCADQoCAgICACDcCJCADIAo2AhwgAyABQQN2IAFBB3FBAEdqIgIgByACIAdJGyIENgIgIANBCGogA0EcahDXOyADKAIIIQVBHEEEEK02IgIEQCACQoGAgIAQNwIAIAIgAykCHDcCCCACQRBqIANBJGopAgA3AgAgAkEYaiADQSxqKAIANgIAIAMgBDYCGCADIAU2AhQgAyACNgIQIAAgA0EQakEAIAEQ8hUgA0EwaiQADwtBBEEcEKM9AAuCBgINfwZ+IwBBMGsiAyQAQcAAIQoCQAJAIAFBBnYiBCABQT9xIghBAEdqIgVBA3QiBkHA////A3FBQGsgBiAFQQdxGyILQcAAENE0BEAgCwRAIAtBwAAQrTYiCkUNAgsgAUHAAEkNAiAErSEUIAIoAgghDSACKAIAIQYgAigCBCIPrSEVA0AgEkIBfCESIAYhBCAJIQVCACEQQgAhEQNAAkAgFSAQIBN8VgRAIAQoAgAiDiANKAIIIgxJDQEgDiAMQfj1gwEQwyEACyAFIA9B6PWDARDDIQALIARBBGohDCAEQQhqIQQgBUEBaiEFIA0oAgQgDkECdGooAgAgDCgCABCLO60gEIYgEYQhESAQQgF8IhBCwABSDQALIAcgCmogETcDACATQkB9IRMgBkGABGohBiAJQUBrIQkgB0EIaiEHIBIgFFINAAsMAgtB8PSDAUEpIANBHGpBrPWDAUGc9YMBENUeAAtBwAAgCxCjPQALIAgEQCACKAIEIgYgAUFAcSIFayIEQQAgBCAGTRutIRIgAigCACABQQN0QYB8cWohBCAIrSETIAIoAgghAkIAIRBCACERA0ACQCAQIBJSBEAgBCgCACIJIAIoAggiCEkNASAJIAhB+PWDARDDIQALIAUgBkHo9YMBEMMhAAsgBEEEaiEIIARBCGohBCAFQQFqIQUgAigCBCAJQQJ0aigCACAIKAIAEIs7rSAQhiARhCERIBBCAXwiECATUg0ACyAHIApqIBE3AAAgB0EIaiEHCyADIAs2AiwgA0KAgICAgAg3AiQgAyAKNgIcIAMgAUEDdiABQQdxQQBHaiICIAcgAiAHSRsiBDYCICADQQhqIANBHGoQ1zsgAygCCCEFQRxBBBCtNiICBEAgAkKBgICAEDcCACACIAMpAhw3AgggAkEQaiADQSRqKQIANwIAIAJBGGogA0EsaigCADYCACADIAQ2AhggAyAFNgIUIAMgAjYCECAAIANBEGpBACABEPIVIANBMGokAA8LQQRBHBCjPQALggYCDX8GfiMAQTBrIgMkAEHAACEKAkACQCABQQZ2IgQgAUE/cSIIQQBHaiIFQQN0IgZBwP///wNxQUBrIAYgBUEHcRsiC0HAABDRNARAIAsEQCALQcAAEK02IgpFDQILIAFBwABJDQIgBK0hFCACKAIIIQ0gAigCACEGIAIoAgQiD60hFQNAIBJCAXwhEiAGIQQgCSEFQgAhEEIAIREDQAJAIBUgECATfFYEQCAEKAIAIg4gDSgCCCIMSQ0BIA4gDEH49YMBEMMhAAsgBSAPQej1gwEQwyEACyAEQQRqIQwgBEEIaiEEIAVBAWohBSANKAIEIA5BAnRqKAIAIAwoAgAQlTutIBCGIBGEIREgEEIBfCIQQsAAUg0ACyAHIApqIBE3AwAgE0JAfSETIAZBgARqIQYgCUFAayEJIAdBCGohByASIBRSDQALDAILQfD0gwFBKSADQRxqQaz1gwFBnPWDARDVHgALQcAAIAsQoz0ACyAIBEAgAigCBCIGIAFBQHEiBWsiBEEAIAQgBk0brSESIAIoAgAgAUEDdEGAfHFqIQQgCK0hEyACKAIIIQJCACEQQgAhEQNAAkAgECASUgRAIAQoAgAiCSACKAIIIghJDQEgCSAIQfj1gwEQwyEACyAFIAZB6PWDARDDIQALIARBBGohCCAEQQhqIQQgBUEBaiEFIAIoAgQgCUECdGooAgAgCCgCABCVO60gEIYgEYQhESAQQgF8IhAgE1INAAsgByAKaiARNwAAIAdBCGohBwsgAyALNgIsIANCgICAgIAINwIkIAMgCjYCHCADIAFBA3YgAUEHcUEAR2oiAiAHIAIgB0kbIgQ2AiAgA0EIaiADQRxqENc7IAMoAgghBUEcQQQQrTYiAgRAIAJCgYCAgBA3AgAgAiADKQIcNwIIIAJBEGogA0EkaikCADcCACACQRhqIANBLGooAgA2AgAgAyAENgIYIAMgBTYCFCADIAI2AhAgACADQRBqQQAgARDyFSADQTBqJAAPC0EEQRwQoz0AC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDBCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDCCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDDCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDECEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDFCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDGCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDHCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDICEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDJCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDKCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDLCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEJ47IQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQnTtFDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDMCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEL8jIQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQsB9FDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC9gGAQR/IwBBEGsiAyQAAkACQCAALQAAIgQgAS0AAEcNAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkBBASECAkAgBEENaw4cARYWAwQFBhYHFhYWFhYICQoLDA0OAA8QERITFBYLIAAoAgQgASgCBBDNCEUNFCAAKAIIIgAtAAAiBCABKAIIIgEtAABGDQEMFAsLIAMgAEEEajYCCCADIAFBBGo2AgxBACECIAAtAAEgAS0AAUcNEyADQQhqIANBDGoQ7CchAgwTCyAALQABIAEtAAFGIQIMEgsgAC0AASABLQABRiECDBELIAAtAAEgAS0AAUYhAgwQCyAALQABIAEtAAFGIQIMDwsgACgCBCABKAIERiECDA4LIAAoAgQiACABKAIEIgFGDQ0gAEEIaiABQQhqEN8nIQIMDQsgACgCBCIAIAEoAgQiAUYNDCAAQQhqIAFBCGoQ3ychAgwMC0EAIQIgACgCBCABKAIERw0LQQEhAiAAKAIIIgAgASgCCCIBRg0LIABBCGogAUEIahDfJyECDAsLIAAoAgQiACABKAIEIgFGDQogAEEIaiABQQhqEN8nIQIMCgsgACgCBCIAIAEoAgQiAUYNCSAAQQhqIAFBCGoQ3ychAgwJCyAAKAIEQQhqIAAoAgggASgCBEEIaiABKAIIEL8jIQIMCAtBACECIAAoAgRBCGogACgCCCABKAIEQQhqIAEoAggQsB9FDQcgAC0AASABLQABRiECDAcLQQAhAiAALQABIAEtAAFHDQYgAC0AAiABLQACRiECDAYLQQAhAiAALQABIAEtAAFHDQUgAC0AAiABLQACRiECDAULQQAhAiAALQABIAEtAAFHDQQgAC0AAiABLQACRiECDAQLQQAhAiAALQABIAEtAAFHDQMgAC0AAiABLQACRiECDAMLQQAhAiAALQABIAEtAAFHDQJBASECIAAoAgQiACABKAIEIgFGDQIgAEEIaiABQQhqEN8nIQIMAgsgACgCBCIEIAEoAgQiBUcEQEEAIQIgBEEIaiAFQQhqEN8nRQ0CC0EBIQIgACgCCCIAIAEoAggiAUYNASAAQQhqIAFBCGoQ3ychAgwBC0EAIQILIANBEGokACACC88GAgx/AX4jAEGQAWsiAiQAIAEoAgQhBiABKAIAIQwgAiABKAIIIgQ2AmQgAkHoAGogBEEHakEDdhDSH0HAACEFAkACQCAEQQR0IgtBwP///wdxQUBrIAsgBEEDcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAIoAnAhCSAFIQEgBEUNAiAEQRhsIQogBiEDA0AgAykDACIOQgJRDQMCQCAOp0EBcQRAIANBCGopAwAhDiABQQhqIANBEGopAwA3AwAgASAONwMAIAkgB0EDdmoiDSANLQAAQQEgB0EHcXRyOgAADAELIAFCADcDACABQQhqQgA3AwALIANBGGohAyAHQQFqIQcgAUEQaiEBIApBGGsiCg0ACwwCC0H89v8AQSkgAkH4AGpB+Pr/AEGo9/8AENUeAAtBwAAgCBCjPQALIAIgBjYCfCACIAw2AnggAkH4AGoiAxD1OyACIAEgBWtBBHUiATYCWAJAAkAgASAERgRAIAIoAnQhBiACIAIpAmg3AoQBIAJBADYCgAEgAiAGNgJ8IAIgCTYCeCACQQhqIAMQ1zsgAigCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogAkGAAWoiCSkCADcCACABQRhqIAJBiAFqIgooAgA2AgAgAiAINgKIASACQoCAgICACDcCgAEgAiALNgJ8IAIgBTYCeCACIAMQ1zsgAigCACEFQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyACKQJ4NwIIIANBEGogCSkCADcCACADQRhqIAooAgA2AgAgAiAGNgJgIAIgBzYCXCACIAE2AlhBDEEEEK02IgFFDQIgASALNgIIIAEgBTYCBCABIAM2AgAgAkEBNgJwIAIgATYCbCACQQE2AmggAkEANgKAASACQoCAgIDAADcCeCACQRRqIgNB0PL/ACAEIAEgAkHYAGogAkHoAGogAkH4AGoQjBMgACADEL4TIAJBkAFqJAAPCyACQgA3AoQBIAJCgYCAgMAANwJ8IAJBlPL/ADYCeEEAIAJB2ABqIAJB5ABqIAJB+ABqQZzy/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC8sGAgl/An4jAEGQAWsiAyQAIAMgAiABa0EwbiIGNgJkIANB6ABqIAZBB2pBA3YQ0h9BwAAhBQJAAkAgBkEFdCIKQUBxQUBrIAogBkEBcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAnAhCSAFIQQgASACRg0CA0ACQCABKAIAQQFxBEAgAUEgaikDACEMIAQgAUEQaikDADcDACABQShqKQMAIQ0gBCABQRhqKQMANwMIIARBEGogDDcDACAEQRhqIA03AwAgCSAHQQN2aiILIAstAABBASAHQQdxdHI6AAAMAQsgBEIANwMAIARBGGpCADcDACAEQRBqQgA3AwAgBEEIakIANwMACyAHQQFqIQcgBEEgaiEEIAFBMGoiASACRw0ACwwCC0HklIABQSkgA0H4AGpByJeAAUGQlYABENUeAAtBwAAgCBCjPQALIAMgBCAFa0EFdSIBNgJYAkACQCABIAZGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAJNgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQdBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIJKQIANwIAIAFBGGogA0GIAWoiCygCADYCACADIAg2AogBIANCgICAgIAINwKAASADIAo2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAJKQIANwIAIAJBGGogCygCADYCACADIAQ2AmAgAyAHNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAo2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkHokYABIAYgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQxRMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQAL4wUCBX8EfiMAQRBrIgUkAAJ/IARFBEAgAEIINwMgIABCADcDACAAQgA3AyhBEAwBCwJAAn8CQCACIAQgA0EHcSIHaiIIQQN2IAhBB3FBAEdqIgYgA0EDdiIDaiIJTwRAIAEgA2ohA0J/IAethiELAkACQCAGQQlPBEAgBkERSQ0BIAYgA0EHakF4cSIBIANrIghrIglBA3YhBkEAIQIgByABIANHcg0CQgAhCwwECyAFQgA3AwggBgRAIAVBCGogAyAG/AoAAAsgBSkDCCEMIABBwAAgCEE/cSIBa0EAIAEbNgIsIAAgBzYCKCAAQgg3AyAgAEIBNwMAIAAgDEJ/IAGthkJ/hUJ/IAEbgyALgzcDCEEQDAYLIAMpAAAhCiAFQgA3AwggBkEIayIBBEAgBUEIaiADQQhqIAH8CgAACyAFKQMIIABBwAAgCEE/cSIBa0EAIAEbNgIsIAAgBzYCKCAAQgg3AyAgACAKIAuDNwMIIABCATcDACAAQgE3AxBCfyABrYZCf4VCfyABG4MhCgwECyABIANHBEAgBUIANwMIIAgEQCAFQQhqIAMgCPwKAAALIAUpAwggC4NBwAAgCEEDdGsiAkE4ca2GIQ1CASELDAILIAZBAWshBiABKQMAIAuDIQ1CASELIAFBCGoMAgsgCSACQbz5hwEQsDsACyABCyEDAkAgAiAHaiIHIARqQT9xIgJFBEAMAQtCfyACrYZCf4UhCiAJQQdxIgQEQCAFQgA3AwggBARAIAVBCGogASAJQfj///8DcWogBPwKAAALIAUpAwggCoMhCkIBIQwMAQsgBkEBayEBIAYEQCADIAFBA3RqKQMAIAqDIQpCASEMIAEhBgwBCyABQQBBzPmHARDDIQALIABBwAAgAmtBACACGzYCLCAAIAc2AiggACAGNgIkIAAgAzYCICAAIA03AwggACALNwMAIAAgDDcDEAtBGAsgAGogCjcDACAFQRBqJAALnAYCBn0CfyMAQZAWayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgWbGoiAioChBYiCpMgACAEQYgWbGoiACoChBYiC5MhDCACKAKAFkUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoAWIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgW/AoAACARIBEoAogWIANqNgKIFkEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGAFkcNAAsgAhCgByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkBZqJAALnAYCBn0CfyMAQZAIayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgIbGoiAioChAgiCpMgACAEQYgIbGoiACoChAgiC5MhDCACKAKACEUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoAIIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgI/AoAACARIBEoAogIIANqNgKICEEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGACEcNAAsgAhChByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkAhqJAALnAYCBn0CfyMAQZARayIRJAACQCAEIAVGDQACQAJAAkACQAJAIAMgBSAEIAQgBUsbIhBLBEAgBSAEIAQgBUkbIgQgA08NASACIARBAnRqKAIAIQMgAiAQQQJ0aigCACICsyELAn0gAkGAAk8EQCALEOoSDAELIAJBAnRBwIfzAGoqAgALIAIgA2ohAiADsyEKAn0gA0GAAk8EQCAKEOoSDAELIANBAnRBwIfzAGoqAgALIQ4gArMhDAJ9IAJBgAJPBEAgDBDqEgwBCyACQQJ0QcCH8wBqKgIACyEPIAEgEE0NAiABIARNDQMgC5QgDiAKlJIgDyAMlJNDAAAAP5QgACAQQYgRbGoiAioChBEiCpMgACAEQYgRbGoiACoChBEiC5MhDCACKAKAEUUEQCAJKAIAIQEMBgsgCSgCACEBIAAoAoARIgNFBEAgCiELDAYLIAEEfSAIRQ0FIAcqAgwQ/i8FQ5l2ln4LIQogEUEIaiACQYgR/AoAACARIBEoAogRIANqNgKIEUEAIQUDQCARQQhqIgIgBWoiAyAAIAVqKAIAIAMoAgBqNgIAIAVBBGoiBUGAEUcNAAsgAhCiByILIAogDJNdDQUMBgsgECADQazpzAAQwyEACyAEIANBvOnMABDDIQALIBAgAUHM6cwAEMMhAAsgBCABQdzpzAAQwyEAC0EAQQBB7OnMABDDIQALIAwgC5IhCgJAAkAgAUUNACAIRQRAQQBBAEH86cwAEMMhAAsgCiAHKgIMIgxcBEAgCiAMXUUNAQwCCyAHKAIEIAcoAgBrIAQgEGtLDQELIAEgBk8NASABIAhJBEAgCSABQQFqNgIAIAcgAUEEdGoiACAKOAIMIAAgCzgCCCAAIAQ2AgQgACAQNgIADAILIAEgCEGM6swAEMMhAAsCQCABIAZJBEAgASAITw0BIAkgAUEBajYCACAHIAFBBHRqIgAgBykCADcCACAAQQhqIAdBCGopAgA3AgALIAcgCjgCDCAHIAs4AgggByAENgIEIAcgEDYCAAwBCyABIAhBnOrMABDDIQALIBFBkBFqJAALwgYCAX8CfiMAQcABayIHJAAgByACOgAPAkACQAJAAkACQAJ+AkACQAJAIAJB/wFxDgkAAQUFBQUEAQIFCyAHQcgAaiADQQhqKQIANwMAIAcgAykCADcDQEICDAILIAdBuAFqIANBCGopAgA3AwAgByADKQIANwOwASAHQdAAaiAHQbABaiAEIAUgBhCZDSAHQcgAaiAHQeAAaikDADcDACAHQShqIAdB/ABqKQIANwMAIAdBMGogB0GEAWopAgA3AwAgB0E4aiAHQYwBaikCADcDACAHQRhqIAdBnAFqKAIANgIAIAcgBykDWDcDQCAHIAcpAnQ3AyAgByAHKQKUATcDECAHKQNQIQggBygCaCEDIAcpAmwhCQwFCyAHQcgAaiADQQhqKQIANwMAIAcgAykCADcDQEIFCyEIQQAhAwwDCyAHQbgBaiADQQhqKQIANwMAIAcgAykCADcDsAEgB0HQAGogB0GwAWoQsQQgBygCUA0BIAdBqAFqIAdB3ABqKQIAIgg3AwAgB0EoaiAHQfgAaikDADcDACAHQTBqIAdBgAFqKQMANwMAIAdBOGogB0GIAWopAwA3AwAgB0HIAGogCDcDACAHIAcpA3A3AyAgByAHKQJUNwNAIAcoAmQhAyAHKQNoIQlCBCEIDAILIAdBATYCVCAHQYidzQA2AlAgB0IBNwJcIAdBrgM2ArQBIAcgB0GwAWo2AlggByAHQQ9qNgKwASAAQQRqIAdB0ABqEJkOIABBADYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAdBrAFqIAdB4ABqKAIAIgE2AgAgByAHKQNYIgg3AqQBIAcoAmQhAiAHKQNoIQkgAEEIaiABNgIAIAAgCDcCACAAIAk3AxAgACACNgIMDAELIAEQgh8gASAINwMAIAEgCTcCHCABIAM2AhggASAHKQNANwMIIAFBEGogB0HIAGopAwA3AwAgASAHKQMgNwIkIAFBLGogB0EoaikDADcCACABQTRqIAdBMGopAwA3AgAgAUE8aiAHQThqKQMANwIAIAEgBykDEDcCRCABQcwAaiAHQRhqKAIANgIAIABBCDYCAAsgB0HAAWokAAuKCQEPfyMAQSBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AaEEBaw4DCQIBAAsgAEE4aiAAQTD8CgAACyAAQThqIQgCQAJAIAAtAGRBAWsOAwgCAQALIAgoAgAiAigCCA0JIAJBfzYCCCAAIAJBCGo2AkQgACACQQxqIgI2AkAgAEEAOgBgIAAgAjYCSCAAIAAoAjwiBDYCTCAAQeAAaiEGIABByABqIQoMAwsgAEHIAGohCiAAQeAAaiEGIAAtAGBBAWsOAwUAAwELAAsgACgCTCEEIAAoAkghAgsgACACNgJQIAIoAgBFDQEgACACNgJcIAAgBDYCWCAAQQE2AlQLIANBEGohCyMAQRBrIgIkAAJAAkAgAEHUAGoiBygCAEUNACMAQRBrIgQkACAEQQhqIAcoAggiCSgCACABIAkoAgQoAgwRAQBBAiEFAkACQCACQQhqIg4Cf0EAIAQoAggiD0ECRg0AGkEBIQUgD0EBcQRAIAQoAgwMAQsgBygCACAHQQA2AgBFDQEgBCAJKAIAIAcoAgQgCSgCBCgCEBEBACAEKAIAQQFxIQUgBCgCBAs2AgQgDiAFNgIAIARBEGokAAwBC0GF3MMAQRxBpNzDABDLJAALQQIhBCACKAIIIgVBAkYNAUEBIQQgBUEBcUUNACACKAIMIQwMAQsgAiAHKAIIIgQoAgAgASAEKAIEKAIUEQEAQQIhBCACKAIAIgFBAkYNACACKAIEIQwgAUEBcSEECyALIAw2AgQgCyAENgIAIAJBEGokAAJAIAMoAhAiAkECRgRAIAZBAzoAAEECIQIMAQsgAygCFCEQAkAgBygCAEUNACAAKAJYIgFBhAFJDQAgARDyHwsCQCACQQFxRQRAQQAhAgwBCyAAKAJQIgEoAgAEfyABELwqIAAoAlAFIAELQQA2AgALIAZBAToAAAtBAyEEQQMhBkECIQEgAkECRwRAIAoQhipBASEGIAAoAkQiASABKAIAQQFqNgIAIAAoAjgiASABKAIAQQFrIgE2AgAgEEGAASACQQFxGyENIAFFBEAgCBDUIgsgAiEBCyAAIAY6AGQCQCABQQJGDQAgCBDeHwJAIAFBAXEEQCADIA02AhggA0GAATYCHCADIABBNGogA0EcaiADQRhqEMIjIAMoAgBBAXENBwJAIAMoAgQiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQEgAhDyHwwBCyADIA02AhggA0GAATYCHCADQQhqIABBMGogA0EcaiADQRhqEMIjIAMoAghBAXENBgJAIAMoAgwiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQAgAhDyHwsgACgCMCICQYQBTwRAIAIQ8h8LQQEhBCAAKAI0IgJBhAFJDQAgAhDyHwsgACAEOgBoIANBIGokACABQQJGDwtB5tnDAEExEJc9AAtB+N3DABDoKwALQajewwAQ6CsAC0Ho3cMAEOgrAAtB1NvDAEExEJc9AAuWCQEOfyMAQaABayIEJAAgBCADNgIMIAQgAjYCCAJAIAEoAiQgAiADak8EQCABQRhqIQUCQCABLQAYQSBGBEAgASgCKCENIARBiAFqIAUQ2gYgBEGUAWogARC+FSABKAIUIQMgBCABKAIQIgU2AiggBCAFIANBxABsajYCLCAEIARBDGo2AjQgBCAEQQhqNgIwIwBBIGsiBSQAIAVBFGogBEEoaiIDKAIEIAMoAgBrQcQAbkEAQQRBxAAQoBggBSgCGCEGIAUoAhRBAUYEQCAGIAUoAhxByNqGARD9LwALIARB8ABqIQsgBUEQaiIOQQA2AgAgBSAFKAIcNgIMIAUgBjYCCCMAQRBrIggkACADKAIEIAMoAgBrQcQAbiIKIAVBCGoiBygCACAHKAIIIgZrSwRAIAcgBiAKQQRBxAAQ3iggBygCCCEGCyAIIAcoAgQ2AgwgCCAGNgIIIAggB0EIajYCBCMAQdAAayIKJAAgCEEEaiIJKAIEIQcgCSgCACADKAIAIgYgAygCBCIMRwRAIAMoAgwhECADKAIIIREgCSgCCCAHQcQAbGohAyAHIAwgBmtBxABuIglqIQcDQCAKQQxqIgwgBiARKAIAIBAoAgAQ1gggAyAMQcQA/AoAACAGQcQAaiEGIANBxABqIQMgCUEBayIJDQALCyAHNgIAIApB0ABqJAAgCEEQaiQAIAtBCGogDigCADYCACALIAUpAgg3AgAgBUEgaiQAAkAgASgCLARAIARBEGogAUEsaiAEKAIIIAQoAgwQsR8MAQsgBEEANgIQCyAEQcgAaiAEQZABaigCADYCACAEQTBqIARBnAFqKAIANgIAIARBPGogBEH4AGooAgA2AgAgBCAEKQKIATcDQCAEIAQpApQBNwMoIAQgBCkCcDcCNCAEKAIMIQEgACAEQShqQST8CgAAIAAgAiANajYCKCAAIAE2AiQgACAEKQIQNwIsIABBNGogBEEYaikCADcCACAAQTxqIARBIGopAgA3AgAMAQsgBEGIAWogBRDaBiABKAIoIQYgBEGUAWogARC+FSAEQfAAaiABQQxqEIALIAEoAiwiBQRAIAUgBSgCACIIQQFqNgIAIAhBAEgNAyABKAI0IQcgASgCMCELIAEoAkAhCiABKAI8IQkgASgCOCEICyAEQcgAaiAEQZABaigCADYCACAEQTBqIARBnAFqKAIANgIAIARBPGogBEH4AGooAgA2AgAgBCAEKQKIATcDQCAEIAQpApQBNwMoIAQgBCkCcDcCNCAEIAo2AmggBCAJNgJkIAQgCDYCYCAEIAc2AlwgBCALNgJYIAQgBTYCVCAEIAM2AkwgBCACIAZqNgJQIARB1ABqIQYCQCAFRQRAIARBADYCcAwBCyAEQfAAaiABQSxqIAIgAxCxHyAFIAUoAgAiAUEBazYCACABQQFHDQAgBhD7HgsgBiAEKQJwNwIAIAZBEGogBEGAAWopAgA3AgAgBkEIaiAEQfgAaikCADcCACAAIARBKGpBxAD8CgAACyAEQaABaiQADwtB3OOGAUExQZDkhgEQnykLAAvoBQEIfyMAQTBrIgQkAAJAAkACQCABIAJHBEAgASEFA0ACfyAFLAAAIgNBAE4EQCADQf8BcSEDIAVBAWoMAQsgBS0AAUE/cSEJIANBH3EhByADQV9NBEAgB0EGdCAJciEDIAVBAmoMAQsgBS0AAkE/cSAJQQZ0ciEJIANBcEkEQCAJIAdBDHRyIQMgBUEDagwBCyAHQRJ0QYCA8ABxIAUtAANBP3EgCUEGdHJyIQMgBUEEagshBUEBIQcCQAJAAkACQAJAIANBDEwEQCADQQlrQQJJDQEMAwsgA0EiSg0BIANBDUcNAgtBASEKDAILIANBPkwEQCADQSNGIANBL0ZyDQMMAQsgA0E/RiADQYCAxABGciADQdwARnINAgsgCEEBaiEIIANBgAFJDQBBAiEHIANBgBBJDQBBA0EEIANBgIAESRshBwsgBiAHaiEGIAIgBUcNAQsLIAQgAjYCICAEIAE2AhwgCkUNASAEQSxqIgVBADYCACAEQoCAgIAQNwIkIARBJGogBEEcaiAIEJYoIARBGGogBSgCADYCACAEIAQpAiQ3AxAMAgsgBCACNgIgIAQgATYCHAsgAiABayEDIAhBAWohBQNAIAVBAWsiBQRAIARBHGoQ7hJBgIDEAEcNAQsLAkAgBkUNACADIAZNBEAgAyAGRg0BDAMLIAEgBmosAABBv39MDQILIAQgBjYCGCAEIAE2AhQgBEGAgICAeDYCEAsgBEEIaiAEQRBqENw7AkACQAJAIAQoAgxBAkcNACAEKAIIIgUtAABB3wFxQcEAa0H/AXFBGUsNACAFLQABIgVBOkYgBUH8AEZyDQELIAAgBCkDEDcCACAAIAQpAhw3AhAgAEEBOgAMIABBCGogBEEYaigCADYCAAwBCyAAIAI2AhQgACABNgIQIABBADoADCAAQQA2AgggAEKAgICAGDcCACAEQRBqEIYwCyAEQTBqJAAPCyABIANBACAGQYiMxAAQozYAC+IFAQV/IwBBEGsiDSQAIA0gBDYCDAJAIAhBACAHa0EDcSIOayIPQQAgCCAPTxtBhDZJBEBBvn8hDAwBCyABRSADRXINACADQYCACEsEQEG4fyEMDAELIAVBDEsEQEFUIQwMAQsgBEH/AUsEQEFSIQwMAQsgBEUEQCANQf8BNgIMQf8BIQQLIAAgAWohDwJAIApFIAtBBHFFciIQRQRAIAooAgBBAkYNAQsgByAOakEAIAggDk8bIQ4gC0EIcUUgA0GAwAJJckUEQCANIAQ2AgggDiANQQhqIAJBgCAQmBUiB0GIf0sEQCAHIQwMAwsgDSAENgIEIA4gDUEEaiACIANqQYAga0GAIBCYFSIEQYh/SwRAIAQhDAwDCyAEIAdqQcUASQ0CCyAOIA1BDGogAiADIA5BhBBqIgdBgCAQ4CUiBEGIf0sEQCAEIQwMAgsgAyAERgRAIAAgAi0AADoAAEEBIQwMAgsgBCADQQd2QQRqTQ0BAkAgCkUNAAJAIBAgCigCACIMQQFGBH8gCSAOIA0oAgwQkyMNASAKQQA2AgBBAAUgDAtFckUNAgwBCyAQRQ0BCyAFQQsgBRsgAyANKAIMIAdBgCYgDkGACGoiBCAOIAsQ2hUhBSAEIA4gDSgCDCAFIAdBgCYQ+AEiDEGIf0sNAUH8ByANKAIMIgVBAnQiCGsiCwRAIAQgCGpBCGpBACAL/AsACyAAIAEgBCAFIAwgB0HsBRCkCSIMQYh/Sw0BAkACQAJAIAoEQAJAIAooAgBFBEAgDEEMaiEIDAELIAkgDiANKAIMIgEQ5SMgBCAOIAEQ5SMgDGpNIAxBDGoiCCADT3INBQsgAyAISw0BDAMLIAxBDGogA08NAgwBCyAKQQA2AgALIAkEQCAJIARBhAj8CgAACyAAIAAgDGogDyACIAMgBiAEENshIQwMAgtBACEMDAELIAAgACAPIAIgAyAGIAkQ2yEhDAsgDUEQaiQAIAwLwQYBDH8jAEGQAWsiAiQAIAEoAgQhByABKAIAIQsgAiABKAIIIgU2AmQgAkHoAGogBUEHakEDdhDSH0HAACEEAn8CQAJAIAVBA3QiDEHA////B3FBQGsgDCAFQQdxGyIIQcAAENE0BEAgCARAIAhBwAAQrTYiBEUNAgsgAigCcCEJIAVFBEAgBCEDQQAMBAsgBUEMbCEKIAchASAEIQMDQCABKAIAIg1BAkYNAwJAIA1BAXEEQCADIAFBBGopAgA3AgAgCSAGQQN2aiINIA0tAABBASAGQQdxdHI6AAAMAQsgA0IANwIACyABQQxqIQEgBkEBaiEGIANBCGohAyAKQQxrIgoNAAsMAgtB/Pb/AEEpIAJB+ABqQfj6/wBBqPf/ABDVHgALQcAAIAgQoz0ACyACKAJkCyEBIAIgBzYCfCACIAs2AnggAkH4AGoiBxDoOyACIAMgBGtBA3UiAzYCWAJAAkAgASADRgRAIAIoAnQhBiACIAIpAmg3AoQBIAJBADYCgAEgAiAGNgJ8IAIgCTYCeCACQQhqIAcQ1zsgAigCCCEJQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQJ4NwIIIAFBEGogAkGAAWoiCikCADcCACABQRhqIAJBiAFqIgsoAgA2AgAgAiAINgKIASACQoCAgICACDcCgAEgAiAMNgJ8IAIgBDYCeCACIAcQ1zsgAigCACEEQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyACKQJ4NwIIIANBEGogCikCADcCACADQRhqIAsoAgA2AgAgAiAGNgJgIAIgCTYCXCACIAE2AlhBDEEEEK02IgFFDQIgASAMNgIIIAEgBDYCBCABIAM2AgAgAkEBNgJwIAIgATYCbCACQQE2AmggAkEANgKAASACQoCAgIDAADcCeCACQRRqIgFBhPT/ACAFIAIgAkHYAGogAkHoAGogAkH4AGoQjBMgACABEKwTIAJBkAFqJAAPCyACQgA3AoQBIAJCgYCAgMAANwJ8IAJBlPL/ADYCeEEAIAJB2ABqIAJB5ABqIAJB+ABqQZzy/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC/kFAQV/IwBBgBVrIgkkACAJQQBBgAL8CwAgCUGAAmpBAEGABPwLACAJQYAGakEAQYAI/AsAIAlBgA5qQQBBgAH8CwAgCUGAD2pBAEGAAvwLACAJQYARakEAQYAE/AsAAkACQAJAAkACQCACBEADQCABIApGDQIgCUGABmogACAKai0AAEECdGoiCyALKAIAQQFqNgIAIAIgCkEBaiIKRw0ACwsgCUGABmpBgAIgAkEIIAlBgAIgCUGAAmpBgAIgBiAHIAgQowIgBUUNA0EAIQogAyECA0AgBCAKRg0DIAItAAAiC0GAAU8NAiAJQYARaiIMIAtBAnRqIgsgCygCAEEBajYCACACQQRqIQIgBSAKQQFqIgpHDQALIAkgCSgC0BNBAWo2AtATIAkgCSgCgBNBAWo2AoATIAkgCSgCiBFBAWo2AogRIAkgCSgChBFBAWo2AoQRIAwgCUGADmogCUGAD2ogBiAHIAgQrwhBACEMA0ACQAJAAkACQAJAIAQgDEcEQCADIAxBAnRqKAIAIgpB/wFxIgJBgAFPDQEgCUGADmogAmotAAAgCUGAD2ogAkEBdGozAQAgBiAHIAgQ3xMgAkECdCILQZiJ0gBqKAIAIApBCHYiCq0gBiAHIAgQ3xMgAkEYTw0FIAEgC0GYjdIAaigCACAKaiILSQ0DIAAhCiALIgINAgwECyAEIARBuOXOABDDIQALIAJBgAFByOXOABDDIQALA0AgCSAKLQAAIg1qLQAAIAlBgAJqIA1BAXRqMwEAIAYgByAIEN8TIApBAWohCiACQQFrIgINAAsMAQsgCyABQdjlzgAQsDsACyAAIAtqIQAgASALayEBCyAMQQFqIgwgBUcNAAsMBAsgASABQYjmzgAQwyEACyALQYABQfjlzgAQwyEACyAEIARB6OXOABDDIQALIAlBATYC0BMgCUEBNgKAEyAJQoGAgIAQNwKEESAJQYARaiAJQYAOaiAJQYAPaiAGIAcgCBCvCAsgCUGAFWokAAuABgEEfyMAQeAAayIDJAAgAEEEIAAoAjQiBSAFQQRNGzYCNCAAQTBqIQUCQCACQX9zIAAoAjAiBmtBA3EiBCAAKAIIIAZrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBSAEEI03IABBASAAKAI0IgQgBEEBTRs2AjQgACgCCBogBUEAEI03IAAoAgggACgCMEciBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwRg0ACwsgBUEBEI03IANBQGsgABDcOyADKAJEIQQgAygCQCEGIANBOGogACgCMBCMNyADQTBqIAYgBCADKAI4IAMoAjxBhIH/ABDXJgJAAkACQCADKAI0BEAgAygCMEEAOgAAAkAgACgCCCAAKAIwayACTyIEDQAgAkGAgICAeEsNAiAEDQADQCAAEPsWIAAoAgggACgCMGsgAkkNAAsLIAUgAhCNNyAAKAIwIQQgA0EoaiAAENw7IANBIGogAygCKCADKAIsIAQgBCACa0HkgP8AENcmIAMoAiQiBCACRw0CIAIEQCADKAIgIAEgAvwKAAALIANBGGogABDcOyAAQQQgACgCNCIBIAFBBE0bNgI0AkBBACAAKAIwIgRrQQNxIgEgACgCCCAEa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAUgARCNNyAAKAIIIAAoAjBrQQNLIgEgAXJFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAVBBBCNNyADQRBqIAAQ3DsgAygCFCEBIAMoAhAhBCADQQhqIAAoAjAQjDcgAyAEIAEgAygCCCADKAIMQYSB/wAQ1yYgAygCBEEDTQ0DIAMoAgAgAjYAACAFKAIAIANB4ABqJAAPCwwCC0GsgP8AQSVB1ID/ABCfKQALIAQgAkH0gP8AELM7AAsgA0EANgJYIANBATYCTCADQbCB/wA2AkggA0IENwJQIANByABqQZSB/wAQ7ywAC+UMAh1/AnwjAEHgAGsiCyQAIAtBAEHAAPwLAEEBIQ0CQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQCAEKAIAIgpBAUYEQCAEKAIIIgcgBCgCBCIISQ0EIAdBD0sNBSAHIAhrIRsgACAIQQR0aiEVIAUoAgAiBg0BQQghEgwCC0EIIRUgBSgCACIGQQFGDQBBCCESQQAMAgsgBSgCCCIHIAUoAgQiCEkNBCAHQQ9LDQUgByAIayEcIAAgCEEEdGohEkEAIApFDQEaIAQoAgghByAEKAIEIQgLIAcgCEkNBSAHQQ9LDQYgAEHwAWogCGohDSAHIAhrCyEdQQAhBEEBIQggBgRAIAUoAggiByAFKAIEIgVJDQcgB0EPSw0IIAcgBWshHiAAQfABaiAFaiEICyALIQcgAiEFA0AgCyAcNgJMIAsgEjYCSCALIBs2AkQgCyAVNgJAIAsgHjYCXCALIAg2AlggCyAdNgJUIAsgDTYCUCALQUBrIR8gC0HQAGohIEEAIRNBACEUIwBBIGsiCiQAIAUoAgAiDiAFKAIEIhBBAnQiEWohFiAEQf8BcSEhA0AgHyAUQQN0IgxqIgYoAgAgBigCBCEGIAogDCAgaiIMKAIAIhcgDCgCBGo2AgwgCiAXNgIIIApBCGoQgzsiDCAGIAYgDEsbIRhBEGshIkEAIQwCQANAA0AgDCAYIAwgGEsbIQkgIiAMQQR0aiEGA0AgCSAMRg0DIAwgF2ogBkEQaiEGIAxBAWohDC0AACAhRw0ACyATBEAgBigCACIJIQ8gCSAGQQRqKAIAQQJ0aiEZIwBBEGsiCSQAIAkgFjYCDCAJIA42AgggCUEIahCeNiEaIApBCGoiBkEANgIQIAYgGTYCDCAGIA82AgggBiAWNgIEIAYgDjYCACAGIBkgD2tBAnYiBiAaIAYgGkkbNgIUIAlBEGokACAKKAIcIgkgCigCGCIGTQ0BIAkgBmshDyAGQQJ0IgkgCigCCGohBiAKKAIQIAlqIQkDQCAGIAYoAgAgCSgCAGo2AgAgBkEEaiEGIAlBBGohCSAPQQFrIg8NAAsMAQsLIAZBBGooAgAiCSAQRgRAIBEEQCAOIAYoAgAgEfwKAAALQQEhEwwBCwsgECAJQZTZzgAQszsACyAUQQFqIhRBAkcNAAsCQCATBEAgBSAOIBAQ/BI5AwgMAQsgBUIANwMIIBBFIBFFcg0AIA5BACAR/AsACyAKQSBqJAAgByAFQQhqKwMAOQMAIAVBEGohBSAHQQhqIQcgBEEBaiIEQQhHDQALIAEoAgAhBSABKAIEIQcgASgCDCEEIAEoAhAjAEEQayIIJAAgCEIANwMAIARqIQ0gBSAHaiEMIAhBAXIhDgJAA0ACfyAFRSAFIAxGckUEQCAFQQFqIQEgBAwBCyAEIA1GBEBBACEEA0AgAiAEaiIBQQhqIAEoAgAgAUEEaigCABD8EjkDACAEQRBqIgRBgAFHDQALIAhBEGokAAwDC0EAIQEgBCIFQQFqCyEHQQAhBiACIQQCQANAIAUtAAAgBiAIai0AAEEIdHIiCiAEQQRqKAIAIhBPDQEgBCgCACAKQQJ0aiIKIAooAgBBAWo2AgAgBEEQaiEEIAZBAWoiBkEIRw0ACyAIQQA2AAsgCEEANgIIIAhBCGoiBEEHIAhBB0H0184AENUsIA5BByAEQQdBhNjOABDVLCAIIAUtAAA6AAAgASEFIAchBAwBCwsgCiAQQZTYzgAQwyEACyACQRhqIQUgAisDCCALKwMAoSEjIAtBCGohBEEAIQ1BASEHA0AgBSsDACAEKwMAoSIkICMgIyAkZCIBGyEjIAcgDSABGyENIAVBEGohBSAEQQhqIQQgB0EBaiIHQQhHDQALIANBD08NCCAAIANBBHRqIgQoAgQiASACIA1BBHRqIgIoAgQiBUcNCSABQQJ0IgEEQCAEKAIAIAIoAgAgAfwKAAALIAAgA2ogDToA8AEgC0HgAGokAA8LIAggB0Gk2M4AELE7AAsgB0EPQaTYzgAQsDsACyAIIAdBtNjOABCxOwALIAdBD0G02M4AELA7AAsgCCAHQcTYzgAQsTsACyAHQQ9BxNjOABCwOwALIAUgB0HU2M4AELE7AAsgB0EPQdTYzgAQsDsACyADQQ9B5NjOABDDIQALIAEgBUGE2c4AELM7AAvOBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2ApABIANBAzYCjAEgA0G85P4ANgKIASADQYCAgIB4NgKEASADQgQ3AnwgA0KEgICACDcCdAwBC0F/IAFBBGoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBBGoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYCdAwCCyADQYiAgIB4NgJ0DAELIANB9ABqIAEgBRC/LwsgA0EINgKoASADQfTm/gA2AqQBIANBgICAgHg2AqABIAMgATYCnAEgA0EBNgKYASADQdAAaiADQfQAaiADQZgBahCBFCADKAJQIgVBioCAgHhGDQEgA0GgAWogA0HsAGopAgA3AwAgAyADKQJkNwOYASADKAJYIQEgAygCVCEEIAMpAlwLIQYgA0EoaiADQaABaikDADcCACADIAY3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQOYATcCIAwBCyADKAJAIgEgASgCDEEBazYCDCADQYqAgIB4NgIMCyADQRM2AoQBIANB4+n+ADYCgAEgA0GAgICAeDYCfCADIAI2AnggA0ECNgJ0IAAgA0EMaiADQfQAahCBFCADQbABaiQAC84GAgN/AX4jAEGwAWsiAyQAIANB9ABqIAEgAhCTDiADKAJ4IQQCQCADKAJ0IgVBioCAgHhHBEAgA0EsaiADQZQBaigCADYCACADQSRqIANBjAFqKQIANwIAIANBHGogA0GEAWopAgA3AgAgAyADKQJ8NwIUIAMgBDYCECADIAU2AgwMAQsgA0H0AGogAUF/IAIgBGoiASABIARJGxC0BiADQThqIgEgA0GAAWopAgA3AwAgAyADKQJ4NwMwIAMoAnQiBEGKgICAeEcEQCADQShqIANBkAFqKQIANwIAIANBGGogASkDADcCACADIAMpAogBNwIgIAMgAykDMDcCECADIAQ2AgwMAQsgA0HIAGogASkDADcDACADIAMpAzA3A0AgA0H0AGogA0FAa0EEEN0QIAMoAnwhASADKAJ4IQQCQAJ+IAMoAnQiBUGKgICAeEcEQCADQaABaiADQZABaikCADcDACADIAMpAogBNwOYASADKQKAAQwBCyAEQQFxRQ0BAkAgAUEBcQRAIAMgATYCkAEgA0EDNgKMASADQbnk/gA2AogBIANBgICAgHg2AoQBIANCBDcCfCADQoSAgIAINwJ0DAELQX8gAUECaiIEIAEgBEsbIgUgAygCQCIEKAIETQRAIAQgBCgCFEECaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgJ0DAILIANBiICAgHg2AnQMAQsgA0H0AGogASAFEL8vCyADQQk2AqgBIANBouf+ADYCpAEgA0GAgICAeDYCoAEgAyABNgKcASADQQE2ApgBIANB0ABqIANB9ABqIANBmAFqEIEUIAMoAlAiBUGKgICAeEYNASADQaABaiADQewAaikCADcDACADIAMpAmQ3A5gBIAMoAlghASADKAJUIQQgAykCXAshBiADQShqIANBoAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA5gBNwIgDAELIAMoAkAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBEzYChAEgA0G76P4ANgKAASADQYCAgIB4NgJ8IAMgAjYCeCADQQI2AnQgACADQQxqIANB9ABqEIEUIANBsAFqJAALywYCA38BfiMAQbABayIFJAAgBUH0AGogASAEEJMOIAUoAnghBgJAIAUoAnQiB0GKgICAeEcEQCAFQSxqIAVBlAFqKAIANgIAIAVBJGogBUGMAWopAgA3AgAgBUEcaiAFQYQBaikCADcCACAFIAUpAnw3AhQgBSAGNgIQIAUgBzYCDAwBCyAFQfQAaiABQX8gBCAGaiIBIAEgBkkbELQGIAVBOGoiASAFQYABaikCADcDACAFIAUpAng3AzAgBSgCdCIGQYqAgIB4RwRAIAVBKGogBUGQAWopAgA3AgAgBUEYaiABKQMANwIAIAUgBSkCiAE3AiAgBSAFKQMwNwIQIAUgBjYCDAwBCyAFQcgAaiABKQMANwMAIAUgBSkDMDcDQCAFQfQAaiAFQUBrQQQQ3RAgBSgCfCEBIAUoAnghBgJAAn4gBSgCdCIHQYqAgIB4RwRAIAVBoAFqIAVBkAFqKQIANwMAIAUgBSkCiAE3A5gBIAUpAoABDAELIAZBAXFFDQECQCABQQFxBEAgBSABNgKQASAFQQM2AowBIAVBueT+ADYCiAEgBUGAgICAeDYChAEgBUIENwJ8IAVChICAgAg3AnQMAQtBfyABQQJqIgYgASAGSxsiByAFKAJAIgYoAgRNBEAgBiAGKAIUQQJqIgc2AhQgBigCCCgCCCAHTwRAIAVBioCAgHg2AnQMAgsgBUGIgICAeDYCdAwBCyAFQfQAaiABIAcQvy8LIAVBBDYCqAEgBUG55/4ANgKkASAFQYCAgIB4NgKgASAFIAE2ApwBIAVBATYCmAEgBUHQAGogBUH0AGogBUGYAWoQgRQgBSgCUCIHQYqAgIB4Rg0BIAVBoAFqIAVB7ABqKQIANwMAIAUgBSkCZDcDmAEgBSgCWCEBIAUoAlQhBiAFKQJcCyEIIAVBKGogBUGgAWopAwA3AgAgBSAINwIYIAUgATYCFCAFIAY2AhAgBSAHNgIMIAUgBSkDmAE3AiAMAQsgBSgCQCIBIAEoAgxBAWs2AgwgBUGKgICAeDYCDAsgBSADNgKEASAFIAI2AoABIAVBgICAgHg2AnwgBSAENgJ4IAVBAjYCdCAAIAVBDGogBUH0AGoQgRQgBUGwAWokAAvOBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBA3EEQCADIAE2ApABIANBAzYCjAEgA0G85P4ANgKIASADQYCAgIB4NgKEASADQgQ3AnwgA0KEgICACDcCdAwBC0F/IAFBBGoiBCABIARLGyIFIAMoAkAiBCgCBE0EQCAEIAQoAhRBBGoiBTYCFCAEKAIIKAIIIAVPBEAgA0GKgICAeDYCdAwCCyADQYiAgIB4NgJ0DAELIANB9ABqIAEgBRC/LwsgA0EJNgKoASADQavn/gA2AqQBIANBgICAgHg2AqABIAMgATYCnAEgA0EBNgKYASADQdAAaiADQfQAaiADQZgBahCBFCADKAJQIgVBioCAgHhGDQEgA0GgAWogA0HsAGopAgA3AwAgAyADKQJkNwOYASADKAJYIQEgAygCVCEEIAMpAlwLIQYgA0EoaiADQaABaikDADcCACADIAY3AhggAyABNgIUIAMgBDYCECADIAU2AgwgAyADKQOYATcCIAwBCyADKAJAIgEgASgCDEEBazYCDCADQYqAgIB4NgIMCyADQRU2AoQBIANBzun+ADYCgAEgA0GAgICAeDYCfCADIAI2AnggA0ECNgJ0IAAgA0EMaiADQfQAahCBFCADQbABaiQAC7UGAQx/IwBBkAFrIgIkACABKAIEIQcgASgCACELIAIgASgCCCIFNgJkIAJB6ABqIAVBB2pBA3YQ0h9BwAAhBAJ/AkACQCAFQQJ0IgxBwP///wNxQUBrIAwgBUEPcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgRFDQILIAIoAnAhCSAFRQRAIAQhA0EADAQLIAVBA3QhCiAHIQEgBCEDA0ACQCABKAIABEAgAyABQQRqKAIANgIAIAkgBkEDdmoiDSANLQAAQQEgBkEHcXRyOgAADAELIANBADYCAAsgAUEIaiEBIAZBAWohBiADQQRqIQMgCkEIayIKDQALDAILQfz2/wBBKSACQfgAakH4+v8AQaj3/wAQ1R4AC0HAACAIEKM9AAsgAigCZAshASACIAc2AnwgAiALNgJ4IAJB+ABqIgcQ6jsgAiADIARrQQJ1IgM2AlgCQAJAIAEgA0YEQCACKAJ0IQYgAiACKQJoNwKEASACQQA2AoABIAIgBjYCfCACIAk2AnggAkEIaiAHENc7IAIoAgghCUEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCeDcCCCABQRBqIAJBgAFqIgopAgA3AgAgAUEYaiACQYgBaiILKAIANgIAIAIgCDYCiAEgAkKAgICAgAg3AoABIAIgDDYCfCACIAQ2AnggAiAHENc7IAIoAgAhBEEcQQQQrTYiA0UEQEEEQRwQoz0ACyADQoGAgIAQNwIAIAMgAikCeDcCCCADQRBqIAopAgA3AgAgA0EYaiALKAIANgIAIAIgBjYCYCACIAk2AlwgAiABNgJYQQxBBBCtNiIBRQ0CIAEgDDYCCCABIAQ2AgQgASADNgIAIAJBATYCcCACIAE2AmwgAkEBNgJoIAJBADYCgAEgAkKAgICAwAA3AnggAkEUaiIDQfjz/wAgBSABIAJB2ABqIAJB6ABqIAJB+ABqEIwTIAAgAxCvEyACQZABaiQADwsgAkIANwKEASACQoGAgIDAADcCfCACQZTy/wA2AnhBACACQdgAaiACQeQAaiACQfgAakGc8v8AEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAuhBQIIfgt/IwBBIGsiCyQAAn9BASABKAIURQ0AGiALQQxqIAAoAgQgACgCCCAAKAIMIAAoAhAQhx0gCygCGCETIAsoAhQhDiALKAIMIRIgCygCHCIMBH4gEiATQQN0aiIPMQAAIA5BP3GtiCECIAwgDmoiAEEDdiAAQQdxQQBHaiIRQQJPBEBBCCAOayEAIBFBAWshDSAPQQFqIQoDQCAKMQAAIABBP3GthiAChCECIApBAWohCiAAQQhqIQAgDUEBayINDQALCyACQn8gDEE/ca2GQn+FgwVCAAshBSALQQxqIAEoAgQgASgCCCABKAIMIAEoAhAQhx0gCygCGCEUIAsoAhQhECALKAIMIQ0CfiALKAIcIgxFBEAgEEE/ca0hBEIADAELIA0gFEEDdGoiDzEAACAQQT9xrSIEiCECIAwgEGoiAEEDdiAAQQdxQQBHaiIBQQJPBEBBCCAQayEAIAFBAWshASAPQQFqIQoDQCAKMQAAIABBP3GthiAChCECIApBAWohCiAAQQhqIQAgAUEBayIBDQALCyACQn8gDEE/ca2GQn+FgwshBiAOQT9xrSEHQQAhCkEAIBBrQT9xrSEIQQAgDmtBP3GtIQlBASEMQQAhAEEBIQ8DQAJAIBJFIAAgE09yRQRAIBIgAEEDdGoiASkAACECIA4EQCABQQhqMQAAIAmGIAIgB4iEIQILIABBAWohAAwBCyAPIRFBACEPQQAhEiAFIQJBASARRQ0CGgsCQCANRSAKIBRPckUEQCANIApBA3RqIgEpAAAhAyAQBEAgAUEIajEAACAIhiADIASIhCEDCyAKQQFqIQoMAQsgDCERQQAhDEEAIQ0gBiEDQQEgEUUNAhoLIAIgA0J/hYNQDQALQQALIAtBIGokAAvGBQIIfwJ+IwBBEGsiCSQAAkAgAkUEQEECIQUMAQsCQAJAAkACQAJAAkAgASACQeyYxABBAhD0Lg0AIAEgAkHumMQAQQIQ9C4NACACQQFGDQMgCUEwNgIMIAEgAiAJQQxqQQEQ9C5FDQMgASwAAUG/f0wNASACQQFrIgIhAyABQQFqIgEhBANAIANFBEBBCCEEDAcLIANBAWshAyAELQAAIQYgBEEBaiEEIAZB+AFxQTBGDQALDAQLIAJBAk0EQCACQQJHDQJBASEFDAYLIAEsAAJBv39MDQFBASEIIAJBAmsiAiEEIAFBAmoiASEDA0AgBEUEQEEQIQQMBgsgBEEBayEEIAMtAAAiB0FfcUHBAGshCkECIQUgA0EBaiEDIAdBMGtB/wFxQQpJIApB/wFxQQZJcg0ACwwFCyABIAJBASACQfCYxAAQozYACyABIAJBAiACQYCZxAAQozYAC0EKIQQDQCACIANGDQIgASADaiADQQFqIQMtAABBMGtB/wFxQQpJDQALC0ECIQVBACEGDAELQQEhAyABLQAAIQcCQAJAIAJBAUYEQEEAIQUgB0Eraw4DAwEDAQsgB0ErRgRAIAJBAWshAyABQQFqIQEgAkEKSQ0BDAILIAIhAyACQQlPDQELQQAhBgNAIAQgAS0AACICQcEAa0FfcUEKaiACQTBrIgUgAkE5SxsgBSAIGyICTQRAQQAhBQwDC0EBIQUgAUEBaiEBIAIgBCAGbGohBiADQQFrIgMNAAsMAQtBACEGIAStIQsDQCADRQRAQQEhBQwCC0EAIQUCQCAGrSALfiIMQiCIpw0AIAEtAAAiAkHBAGtBX3FBCmogAkEwayIGIAJBOUsbIAYgCBsiAiAETw0AIAFBAWohASADQQFrIQMgAiAMpyIHaiIGIAdPDQELCwsgACAGNgIEIAAgBTYCACAJQRBqJAALtQsCDX8EfiMAQZABayIDJAAgAkEMaiIFENg8IQgCQAJAIAIQkjYiBEUNACAEKAIURQ0AIANBEGoiBiAIEPcvIANBCGogBhCGPSADKAIMIQYgAygCCCEHIANBIGogBBDINCADQUBrIQsgASgCDCEJIAEoAgQhCiABKAIQIQwgAigCECENAkACQAJAAkADQAJAAkAgAykDSCIRUEUEQCADKQNQIRAMAQsDQAJ+AkAgAykDMCIQQgNSBEACQAJAAkAgEEICUQ0AIAMgEFCtQgGGNwMwIBCnQQFxRQ0AIAMgAykDODcDaAwBCyADKAJARQ0BIANB4ABqIAsQtiogAykDYCEQCyAQQgBSDQILIANCAzcDMAsgAykDICIQQgJRDQQgA0IANwMgIAMpAygMAQsgAykDaAshESAQp0EBcUUNAiADIAMpA1BCQH0iEDcDUCADIBE3A0ggEVANAAsLIAMgEUIBIBF6IhKGhTcDSCADIBKnIBCnaiIBNgJcIAUQ2DwgAU0NAiAMIA0gAUEDdGooAgAiBE0NAyAKIAQgCWoiBEEDdmotAAAgBEEHcXZBAXFFDQEgAUEDdiIEIAZPDQQgBCAHaiIEIAQtAABBASABQQdxdHI6AAAMAQsLIAMoAhghASADKAIcIQIgAyADKQIQNwIsIANBADYCKCADIAI2AiQgAyABNgIgIAMgA0EgahDXOyADKAIAIQRBHEEEEK02IgFFDQMgAUKBgICAEDcCACABIAMpAiA3AgggAUEQaiADQShqKQIANwIAIAFBGGogA0EwaigCADYCACADIAI2AmggAyAENgJkIAMgATYCYCAAIANB4ABqQQAgCBDyFQwFCyADIAIQ/Ts2AnwgA0ECNgJkIANBiPGBATYCYCADQgI3AmwgA0E7NgKMASADQTs2AoQBIAMgA0GAAWo2AmggAyADQfwAajYCiAEgAyADQdwAajYCgAEgA0HgAGpBmPGBARDvLAALQZD0gQFBIEGw9IEBEJ8pAAsgBCAGQfDzgQEQwyEAC0EEQRwQoz0ACyABIQYjAEEwayIFJABBwAAhCwJAAkACQAJAAkAgCEEGdiIBIAhBP3EiCkEAR2oiBEEDdCIJQcD///8DcUFAayAJIARBB3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiILRQ0CCyAIQcAATwRAIAGtIRMgBigCDCEMIAYoAgQhDSAGKAIQIQ8gAigCECEBA0AgEUIBfCERIAEhBEIAIRJCACEQA0AgDyAEKAIAIg5NDQYgDSAMIA5qIg5BA3ZqLQAAIA5BB3F2QQFxrSAShiAQhCEQIARBCGohBCASQgF8IhJCwABSDQALIAcgC2ogEDcDACABQYAEaiEBIAdBCGohByARIBNSDQALCyAKBEAgAigCECAIQQN0QYB8cWohBCAKrSERIAYoAgwhASAGKAIEIQIgBigCECEGQgAhEkIAIRADQCAGIAQoAgAiCk0NBCACIAEgCmoiCkEDdmotAAAgCkEHcXZBAXGtIBKGIBCEIRAgBEEIaiEEIBEgEkIBfCISUg0ACyAHIAtqIBA3AAAgB0EIaiEHCyAFIAk2AiwgBUKAgICAgAg3AiQgBSALNgIcIAUgCEEDdiAIQQdxQQBHaiIBIAcgASAHSRsiAjYCICAFQQhqIAVBHGoQ1zsgBSgCCCEEQRxBBBCtNiIBRQ0EIAFCgYCAgBA3AgAgASAFKQIcNwIIIAFBEGogBUEkaikCADcCACABQRhqIAVBLGooAgA2AgAgBSACNgIYIAUgBDYCFCAFIAE2AhAgACAFQRBqQQAgCBDyFSAFQTBqJAAMBQtB8PSDAUEpIAVBHGpBrPWDAUGc9YMBENUeAAtBwAAgCRCjPQALQcD0gwFBIEHg9IMBEJ8pAAtBwPSDAUEgQeD0gwEQnykAC0EEQRwQoz0ACwsgA0GQAWokAAu1CwINfwR+IwBBkAFrIgMkACACQQxqIgUQ2zwhCAJAAkAgAhCSNiIERQ0AIAQoAhRFDQAgA0EQaiIGIAgQ9y8gA0EIaiAGEIY9IAMoAgwhBiADKAIIIQcgA0EgaiAEEMg0IANBQGshCyABKAIMIQkgASgCBCEKIAEoAhAhDCACKAIQIQ0CQAJAAkACQANAAkACQCADKQNIIhFQRQRAIAMpA1AhEAwBCwNAAn4CQCADKQMwIhBCA1IEQAJAAkACQCAQQgJRDQAgAyAQUK1CAYY3AzAgEKdBAXFFDQAgAyADKQM4NwNoDAELIAMoAkBFDQEgA0HgAGogCxC2KiADKQNgIRALIBBCAFINAgsgA0IDNwMwCyADKQMgIhBCAlENBCADQgA3AyAgAykDKAwBCyADKQNoCyERIBCnQQFxRQ0CIAMgAykDUEJAfSIQNwNQIAMgETcDSCARUA0ACwsgAyARQgEgEXoiEoaFNwNIIAMgEqcgEKdqIgE2AlwgBRDbPCABTQ0CIA0gAUECdGooAgAiBCAMTw0DIAogBCAJaiIEQQN2ai0AACAEQQdxdkEBcUUNASABQQN2IgQgBk8NBCAEIAdqIgQgBC0AAEEBIAFBB3F0cjoAAAwBCwsgAygCGCEBIAMoAhwhAiADIAMpAhA3AiwgA0EANgIoIAMgAjYCJCADIAE2AiAgAyADQSBqENc7IAMoAgAhBEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAykCIDcCCCABQRBqIANBKGopAgA3AgAgAUEYaiADQTBqKAIANgIAIAMgAjYCaCADIAQ2AmQgAyABNgJgIAAgA0HgAGpBACAIEPIVDAULIAMgAhD8OzYCfCADQQI2AmQgA0GI8YEBNgJgIANCAjcCbCADQTs2AowBIANBOzYChAEgAyADQYABajYCaCADIANB/ABqNgKIASADIANB3ABqNgKAASADQeAAakGY8YEBEO8sAAtBkPSBAUEgQbD0gQEQnykACyAEIAZB8POBARDDIQALQQRBHBCjPQALIAEhBiMAQTBrIgUkAEHAACELAkACQAJAAkACQCAIQQZ2IgEgCEE/cSIKQQBHaiIEQQN0IglBwP///wNxQUBrIAkgBEEHcRsiCUHAABDRNARAIAkEQCAJQcAAEK02IgtFDQILIAhBwABPBEAgAa0hEyAGKAIMIQwgBigCBCENIAYoAhAhDyACKAIQIQEDQCARQgF8IREgASEEQgAhEkIAIRADQCAEKAIAIg4gD08NBiANIAwgDmoiDkEDdmotAAAgDkEHcXZBAXGtIBKGIBCEIRAgBEEEaiEEIBJCAXwiEkLAAFINAAsgByALaiAQNwMAIAFBgAJqIQEgB0EIaiEHIBEgE1INAAsLIAoEQCACKAIQIAhBAnRBgH5xaiEEIAqtIREgBigCDCEBIAYoAgQhAiAGKAIQIQZCACESQgAhEANAIAQoAgAiCiAGTw0EIAIgASAKaiIKQQN2ai0AACAKQQdxdkEBca0gEoYgEIQhECAEQQRqIQQgESASQgF8IhJSDQALIAcgC2ogEDcAACAHQQhqIQcLIAUgCTYCLCAFQoCAgICACDcCJCAFIAs2AhwgBSAIQQN2IAhBB3FBAEdqIgEgByABIAdJGyICNgIgIAVBCGogBUEcahDXOyAFKAIIIQRBHEEEEK02IgFFDQQgAUKBgICAEDcCACABIAUpAhw3AgggAUEQaiAFQSRqKQIANwIAIAFBGGogBUEsaigCADYCACAFIAI2AhggBSAENgIUIAUgATYCECAAIAVBEGpBACAIEPIVIAVBMGokAAwFC0Hw9IMBQSkgBUEcakGs9YMBQZz1gwEQ1R4AC0HAACAJEKM9AAtBwPSDAUEgQeD0gwEQnykAC0HA9IMBQSBB4PSDARCfKQALQQRBHBCjPQALCyADQZABaiQAC8IFAgp/AX4gAkEBaiEOIABBCGohD0GAgAQgBUEBa3RBEHUhECABIQcgBiEIQQAhAkEBIQpBASAFdCIMQQFrIg0hCwNAIAIgDkcEQAJAIAcvAQAiCUH//wNGBEAgDyALQQN0akEEaiACNgIAIAtBAWshC0EBIQkMAQsgCkEAIBAgCcFKGyEKCyAIIAk7AQAgB0ECaiEHIAhBAmohCCACQQFqIQIMAQsLIAAgBTYCBCAAIAo2AgACQCALIA1GBEAgBkHqAGohCEEAIQlBACEKA0AgCSAORgRAIAxBA3YgDEEBdmpBA2oiAUEBdCELQQAhCkEAIQkDQCAJIAxPDQRBACECIAohBwNAIAJBAkcEQCAPIAcgDXFBA3RqQQRqIAIgCGotAAA2AgAgASAHaiEHIAJBAWohAgwBCwsgCEECaiEIIAlBAmohCSAKIAtqIA1xIQoMAAsABSAIIApqIBE3AAAgBiAKaiELIAEgCUEBdGouAQAhB0HyACECA0AgByACQeoAa0oEQCACIAtqIBE3AAAgAkEIaiECDAELCyARQoGChIiQoMCAAXwhESAJQQFqIQkgByAKaiEKDAELAAsACyAMQQN2IAxBAXZqQQNqIQpBACEIQQAhBwNAIAggDkYNAUEAIQIgASAIQQF0ai4BACIJQQAgCUEAShshCQNAIAIgCUcEQCAPIAdBA3RqQQRqIAg2AgADQCAHIApqIA1xIgcgC0sNAAsgAkEBaiECDAELCyAIQQFqIQgMAAsACyAAQQxqIQIgBUEfayEFIAwhBwNAIAcEQCAGIAIoAgAiAEEBdGoiASABLwEAIgFBAWo7AQAgAkEBayAFIAFnaiIIOgAAIAJBBGsgASAIdCAMazsBACACQQJrIAAgBGotAAA6AAAgAiADIABBAnRqKAIANgIAIAdBAWshByACQQhqIQIMAQsLC9sGAgV/An4jAEHQAGsiAyQAIAMgAjYCACADQThqIAEQkCcgAygCQCEEIAMoAjwhBQJAIAMoAjgiBkGTgICAeEcEQCAAIAMpAkQ3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgBEUEQCAAQZOAgIB4NgIADAELIAUpAwAiCEKAgICAEFoEQCADQQI2AjwgA0Gk74YBNgI4IANCAjcCRCADQa0DNgIYIAMgAUEYajYCFCADQe4GNgIQIAMgBTYCDCADIANBDGo2AkAgA0EkaiADQThqEJkOIAAgAykCKDcCCCAAQRBqIANBMGooAgA2AgAgACADKAIkNgIEIABBjYCAgHg2AgAMAQsgAyAIpyIHNgIEAkACQCAEIAEoAiQiBksEQCAFIAZBA3RqIgQpAwAiCUKAgICAEFoEQCADQQM2AiQgA0HQ74YBNgIgIANCAzcCLCADQa0DNgJMIAMgAUEYajYCSCADQe4GNgJEIAMgBDYCQCADQTs2AjwgAyABQSRqNgI4IAMgA0E4ajYCKCADQRBqIANBIGoQmQ4gACADKQIUNwIIIABBEGogA0EcaigCADYCACAAIAMoAhA2AgQgAEGNgICAeDYCAAwECyADIAmnIgQ2AgggAiAHSQ0BIAIgBEkNAiAIIAlYBEAgAEGTgICAeDYCAAwECyADQQM2AiQgA0GE7oYBNgIgIANCAzcCLCADQTs2AkwgA0GtAzYCRCADIAFBGGo2AkAgA0E7NgI8IAMgA0E4ajYCKCADIANBCGo2AkggAyADQQRqNgI4IABBBGogA0EgahC7GCAAQY2AgIB4NgIADAMLIAYgBEHE7YYBEMMhAAsgA0EDNgIkIANB4O6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADNgJIIAMgA0EEajYCOCAAQQRqIANBIGoQmQ4gAEGNgICAeDYCAAwBCyADQQM2AiQgA0HI7oYBNgIgIANCAzcCLCADQTs2AkwgA0GtAzYCRCADIAFBGGo2AkAgA0E7NgI8IAMgA0E4ajYCKCADIAM2AkggAyADQQhqNgI4IABBBGogA0EgahC7GCAAQY2AgIB4NgIACyADQdAAaiQAC/kIAgt/AX4jAEHgAGsiAyQAIAIoAgAiBCkDACEOIAIoAgQhBSADIAIoAgw2AjAgAyAENgIoIAMgBCAFakEBajYCJCADIARBCGo2AiAgAyAOQn+FQoCBgoSIkKDAgH+DNwMYIwBBMGsiBCQAAkACQAJAIANBGGoiBSgCGARAIAUQ+hshByAFIAUoAhgiBkEBazYCGCAEQRBqIgJBBCAGQX8gBhsiBiAGQQRNG0EAQQRBCBCgGCAEKAIUIQYgBCgCEEEBRg0CIAQoAhgiCCAHQQxrNgIEIAggB0EYazYCACAEQQxqIgxBATYCACAEIAg2AgggBCAGNgIEIARBKGogBUEYaikDADcDACAEQSBqIAVBEGopAwA3AwAgBEEYaiAFQQhqKQMANwMAIAQgBSkDADcDECACKAIYBEAgBEEEaiIHKAIIIgZBA3QhCANAIAIQ+hshCSACIAIoAhhBAWsiCjYCGCAHKAIAIAZGBEAgByAGIApBAWoiC0F/IAsbQQRBCBDcKAsgByAGQQFqIgY2AgggBygCBCAIaiILIAlBGGs2AgAgC0EEaiAJQQxrNgIAIAhBCGohCCAKDQALCyADQQhqIAwoAgA2AgAgAyAEKQIENwIADAELIANBADYCCCADQoCAgIDAADcCAAsgBEEwaiQADAELIAYgBCgCGEG81YcBEP0vAAsCQAJ/IAMoAggiBwRAIANBADYCFCADQoCAgIAQNwIMIANCgICAgMAANwIYIAMgBzYCICADQQxqIAUQph4gAygCBCIEIAdBA3RqIQsgAygCACEGIAQhAgNAAkACQCACKAIAIggoAggiBUEASARAIAMgBTYCTCADQQM2AhwgA0Gc14cBNgIYDAELIAJBBGooAgAiCSgCCCIKQQBODQEgAyAKNgJMIANBAzYCHCADQdTXhwE2AhgLIANCAjcCJCADQTs2AlwgA0GcAzYCVCADQeDWhwE2AlAgAyADQdAAajYCICADIANBzABqNgJYIANBPGogA0EYaiICEJkOIAAgAykCQDcCDCAAQRRqIANByABqKAIANgIAIAAgAygCPDYCCCAAQoGAgIDwgYCAgH83AwAgAyAENgIcIAMgBjYCGCACQQRBCBDgHiADQQxqQQFBARDgHiABKAIoIgBFDQQgASAAEQMADAQLIAMgBTYCICADQoCAgIDAADcCGCADQQxqIgUgA0EYaiIMEKYeIAUgCCgCBCINIA0gCCgCCGoQvCYgAyAKNgIgIANCgICAgMAANwIYIAUgDBCmHiAFIAkoAgQiBSAFIAkoAghqELwmIAJBCGoiAiALRw0ACyADIAQ2AhwgAyAGNgIYIAxBBEEIEOAeIAEgAygCEDYCCCADKQIQIQ4gAygCDAwBCyABQQA2AghBgICAgHgLIQQgASgCLCICKAIAQYCAgIB4RwRAIAJBAUEBEOAeCyACIA43AgQgAiAENgIAIAEgAjYCLCAAQQhqIAFBMPwKAAAgAEEANgIAIAcNACADQQRBCBDgHgsgA0HgAGokAAvxBQILfwF+IwBBIGsiBCQAIAIoAhQhDCACIAEoAhQiByADIAMgB0sbIgYQ7i0CQAJAIAEoAggiCCABKAIQIgNGBEAgAEIINwMADAELAkACQAJAAkACQAJAIAJBDGogCCADa60gBq1+Ig9CIIhQBH8gB0UNASAPpyAHbgUgBQsQ5S0gAS0AGCEJIAZFIAMgCE9yDQMgASgCBCELIAZBAWshCiAJQQFxIQ0DQAJAAkAgCCADQQRqIgVPBEAgA0F8Tw0FIAMgC2ooAAAiDiAFaiIDIAhLDQEgAyAFSQ0GIARBCGogAiAFIAtqIA4gDRCfFCAEKAIIIgVBCEYNAiAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCACAAIAU2AgAMCgsgBEEIakEXQQBBAUEBEKAYIAQoAgwhAiAEKAIIQQFGDQogBCgCECIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMCQsgBEEIakEXQQBBAUEBEKAYIAQoAgwhAiAEKAIIQQFGDQkgBCgCECIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMCAsgASADNgIQIAMgCEkEQCAKQQBHIApBAWshCg0BCwsgASAHIAZrNgIUIAlBAXENBAwFC0HIjc0AEOIrAAsgAyAFQaiNzQAQsTsACyAFIANBuI3NABCxOwALIAEgByAGazYCFCAJQQFxRQ0BCyAEQQhqIAIgDBCuGSAEKAIIIgFBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCACAAIAE2AgAMAQsgAEEINgIAIAAgBjYCBAsgBEEgaiQADwsgAiAEKAIQQdT9zAAQ/S8AC/EFAgt/AX4jAEEgayIEJAAgAigCFCEMIAIgASgCFCIHIAMgAyAHSxsiBhDsLQJAAkAgASgCCCIIIAEoAhAiA0YEQCAAQgg3AwAMAQsCQAJAAkACQAJAAkAgAkEMaiAIIANrrSAGrX4iD0IgiFAEfyAHRQ0BIA+nIAduBSAFCxDlLSABLQAYIQkgBkUgAyAIT3INAyABKAIEIQsgBkEBayEKIAlBAXEhDQNAAkACQCAIIANBBGoiBU8EQCADQXxPDQUgAyALaigAACIOIAVqIgMgCEsNASADIAVJDQYgBEEIaiACIAUgC2ogDiANEJcUIAQoAggiBUEIRg0CIAAgBCkCDDcCBCAAQRRqIARBHGooAgA2AgAgAEEMaiAEQRRqKQIANwIAIAAgBTYCAAwKCyAEQQhqQRdBAEEBQQEQoBggBCgCDCECIAQoAghBAUYNCiAEKAIQIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwJCyAEQQhqQRdBAEEBQQEQoBggBCgCDCECIAQoAghBAUYNCSAEKAIQIgFBD2pB24bNACkAADcAACABQQhqQdSGzQApAAA3AAAgAUHMhs0AKQAANwAAIABBFzYCDCAAIAE2AgggACACNgIEIABBAjYCAAwICyABIAM2AhAgAyAISQRAIApBAEcgCkEBayEKDQELCyABIAcgBms2AhQgCUEBcQ0EDAULQciNzQAQ4isACyADIAVBqI3NABCxOwALIAUgA0G4jc0AELE7AAsgASAHIAZrNgIUIAlBAXFFDQELIARBCGogAiAMEK4ZIAQoAggiAUEIRg0AIAAgBCkCDDcCBCAAQRRqIARBHGooAgA2AgAgAEEMaiAEQRRqKQIANwIAIAAgATYCAAwBCyAAQQg2AgAgACAGNgIECyAEQSBqJAAPCyACIAQoAhBB1P3MABD9LwAL/AkCEH8BfiACQQFrIRYgAkECdCAAakEEayEXQQEhEAJAAkACQAJAAkACQAJAAkACQANAQQAhCgJAIAJFDQAgFyEAIBYhCwNAAkACQCABIBZLBEAgACgCACIIDQEMAgsgCyABQdCR0gAQwyEACyAFIApLBEAgBCAKQQN0aiAQIAggCCAQSRutIAutQjCGhEKAgICA8P8/hDcCACAKQQFqIQoMAQsgCiAFQeCR0gAQwyEACyAAQQRrIQAgC0EBayILQX9HDQALIApBAUcNACAFRQRAQQBBAEGgkNIAEMMhAAsgBC4BBiIAIAdJBEAgACAGakEBOgAADAULIAAgB0GwkNIAEMMhAAsCQCAKQQxNBEAgCkECSQ0BQQEgBSAFQQFNGyEMIAQhC0EBIQgDQAJAIAggDEcEQCAIQQFqIQkgBCAIQQN0aikCACIYpyENIBhCMIinwSEOIAshAANAIABBBmouAQAgDkggACgCACIPIA1LIA0gD0YbRQ0CIABBCGogACkCADcCACAAQQhrIQAgCEEBayIIDQALQQAhCAwBCyAMIAVB6I/SABDDIQALIAUgCEsEQCAEIAhBA3RqIBg3AgAgC0EIaiELIAkiCCAKRw0BDAMLCyAIIAVB+I/SABDDIQALIApBOUlBAXQhDgNAAkAgDkECdEGIkNIAaigCACIJIApPDQAgCSAFIAUgCUkbIQ9BACEMQQAgCUEDdCISayETIAQhCyAJIQACQANAAn8CQCAAIA9HBEAgAEEBaiENIAQgAEEDdGopAgAiGKchESAYQjCIp8EhFCALIQAgDCEIA0AgBSAITQ0FIABBBmouAQAgFEggACgCACIVIBFLIBEgFUYbRQ0CIAAgEmogACkCADcCACAAIBNqIQAgCCAJSSAIIAlrIQhFDQALIAggCWoMAgsgDyAFQbiP0gAQwyEACyAIIAlqCyIAIAVJBEAgBCAAQQN0aiAYNwIAIAtBCGohCyAMQQFqIQwgDSIAIApHDQEMAwsLIAAgBUHYj9IAEMMhAAsgCCAFQciP0gAQwyEACyAOQQFqIg5BBkcNAAsLIAUgCksEQCAEIApBA3RqIgtCfzcCACAKQQFqIgAgBU8NAiAEIABBA3RqQn83AgBBASEJIApBAUcEQEEBIQ4gCkEBdEEAIQkDQCAFIAlNDQcgACAFTw0IIAkgBCAJQQN0aigCACIIIAQgAEEDdGooAgAiDU1qIgwgBU8NCSAAIAggDUsiCGoiDSAFTw0KIAAgCSAIGyIAIAVPDQsgDSAMIAQgDEEDdGooAgAiCSAEIA1BA3RqKAIAIhFLIhIbIgggBU8NDCAEIAhBA3RqKAIAIRMgBCAAQQN0aigCACEUIAtBDmogCDsBACALQQxqIAA7AQAgC0EIaiIIIBMgFGo2AgAgCiAOakEBaiAFTw0FIAwgCSARTWohCSANIBJqIQAgC0EQakJ/NwIAIAghCyAKIA5BAWoiDkcNAAtBAWshCQsgEEEBdCEQIAkgBCAFIAYgByADEIkRRQ0BDAQLCyAKIAVBwJDSABDDIQALIAAgBUHQkNIAEMMhAAsgBSAFQcCR0gAQwyEACw8LIAkgBUHgkNIAEMMhAAsgACAFQfCQ0gAQwyEACyAMIAVBgJHSABDDIQALIA0gBUGQkdIAEMMhAAsgACAFQaCR0gAQwyEACyAIIAVBsJHSABDDIQALywYBBX8jAEHQAGsiAyQAIAMgAjYCACADQThqIAEQjycgAygCQCEEIAMoAjwhBQJAIAMoAjgiBkGTgICAeEcEQCAAIAMpAkQ3AgwgACAENgIIIAAgBTYCBCAAIAY2AgAMAQsgBEUEQCAAQZOAgIB4NgIADAELIAUoAgAiBkEASARAIANBAjYCPCADQaTvhgE2AjggA0ICNwJEIANBrQM2AhggAyABQRhqNgIUIANBnAM2AhAgAyAFNgIMIAMgA0EMajYCQCADQSRqIANBOGoQmQ4gACADKQIoNwIIIABBEGogA0EwaigCADYCACAAIAMoAiQ2AgQgAEGNgICAeDYCAAwBCyADIAY2AgQCQAJAIAQgASgCJCIHSwRAIAUgB0ECdGoiBSgCACIEQQBIBEAgA0EDNgIkIANB0O+GATYCICADQgM3AiwgA0GtAzYCTCADIAFBGGo2AkggA0GcAzYCRCADIAU2AkAgA0E7NgI8IAMgAUEkajYCOCADIANBOGo2AiggA0EQaiADQSBqEJkOIAAgAykCFDcCCCAAQRBqIANBHGooAgA2AgAgACADKAIQNgIEIABBjYCAgHg2AgAMBAsgAyAENgIIIAIgBkkNASACIARJDQIgBCAGTwRAIABBk4CAgHg2AgAMBAsgA0EDNgIkIANBhO6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADQQhqNgJIIAMgA0EEajYCOCAAQQRqIANBIGoQuxggAEGNgICAeDYCAAwDCyAHIARBxO2GARDDIQALIANBAzYCJCADQeDuhgE2AiAgA0IDNwIsIANBOzYCTCADQa0DNgJEIAMgAUEYajYCQCADQTs2AjwgAyADQThqNgIoIAMgAzYCSCADIANBBGo2AjggAEEEaiADQSBqEJkOIABBjYCAgHg2AgAMAQsgA0EDNgIkIANByO6GATYCICADQgM3AiwgA0E7NgJMIANBrQM2AkQgAyABQRhqNgJAIANBOzYCPCADIANBOGo2AiggAyADNgJIIAMgA0EIajYCOCAAQQRqIANBIGoQmQ4gAEGNgICAeDYCAAsgA0HQAGokAAu/BQEKfyMAQSBrIgQkACACKAIEIQggASgCBCEDAkACQAJAAkAgASgCCCIGIAIoAggiCU8EQCAEIAM2AgggBCADIAlBAnRqIgc2AgwgCSAEQQhqEJ42IgIgAiAJSxsiBUUNAgNAIAMgCiADKAIAIgogCCgCAGoiAmoiCzYCACACIApJIAIgC0tyIgIhCiADQQRqIQMgCEEEaiEIIAVBAWsiBQ0ACyACRQ0CIAZBAnQgCUECdGshAwNAIANFDQIgByAHKAIAQQFqIgI2AgAgA0EEayEDIAdBBGohByACRQ0ACwwCCyAEIAM2AgggBCADIAZBAnQiCmo2AgxBACECIAYgBEEIahCeNiIFIAUgBksbIgcEQCAIIQUDQCADIAIgAygCACILIAUoAgBqIgJqIgw2AgAgAiALSSACIAxLciECIANBBGohAyAFQQRqIQUgB0EBayIHDQALCyABIAggCmogCCAJQQJ0ahCeJCAGIAEoAggiCEsNAiAGIAhGDQMgBCABKAIEIAZBAnRqIgM2AgggBCADQQRqIgc2AgwgBEEIahCeNiIJRQ0BQQAhBSAJQQBHIQoDQCADIAUgAygCACIJIAJqIgVqIgs2AgAgBSAJSSAFIAtLciEFIANBBGohAyAKQQFrIgoNAAsgBUUNASAIQQJ0IAZBAnRrQQRrIQMDQCADBEAgByAHKAIAQQFqIgI2AgAgA0EEayEDIAdBBGohByACRQ0BDAMLCyABKAIIIQYLIAEoAgAgBkYEQCABQaSJiAEQnSgLIAEoAgQgBkECdGpBATYCACABIAZBAWo2AggLIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgBEEgaiQADwsgBiAIQZSJiAEQrzsACyAEQQA2AhggBEEBNgIMIARB/IiIATYCCCAEQgQ3AhAgBEEIakGEiYgBEO8sAAvNBQIOfwJ+IwBBIGsiDSQAAkACQAJAIAMgBnEiDiACTQRAIAkoAgghCiAAKAIsIRIgASAOaiITIAIgDmsiFBCWGiEQIAogDmoiDCACTw0BIAEgDGotAAAhDCAJKQMAIRggCUEANgIMIAYgBSgCACIPayIFIAZPDQMCQCACIAMgBXEiBSAKaiILSwRAIAwgASALai0AAEYNAQwFCyALIAJB1MvOABDDIQALIAIgBUkNAiABIAVqIAIgBWsgEyAUIAcQ9AEiC0UNAyALIAUgBBChLiIKIBIQ8jQhGCAJIA82AhAgCSAKNgIIIAkgGDcDACACIAogDmoiBUsEQCABIAVqLQAAIQxBASEVDAQLIAUgAkH0y84AEMMhAAsgDiACQaTLzgAQrzsACyAMIAJBtMvOABDDIQALIAUgAkHky84AEK87AAsCQAJAAkAgECAAKAIEIgtNBEAgCyAQayIFQQNNDQEgACgCACIWIBBBAnRqIRdBACEAAkACQANAIABBEEcEQCAAIBdqKAIAIhEgA3EiBSAKaiIPIAJPDQIgAEEEaiEAIAYgEWsiEUEBayAITw0BIAwgASAPai0AAEcNASACIAVJDQcgASAFaiACIAVrIBMgFCAHEPQBIg9FDQEgGCAPIAUgBBChLiIFIBEgEhCMLSIZWg0BIAkgETYCECAJIAU2AgggCSAZNwMAIAUgDmoiCiACTw0DIAEgCmotAAAhDEEBIRUgGSEYIAUhCgwBCwsgECAGQQN2QQNxaiIAIAtJDQQgACALQeTMzgAQwyEACyAPIAJB9MzOABDDIQALIAogAkGUzc4AEMMhAAsgDUEANgIYIA1BATYCDCANQZjXzgA2AgggDUIENwIQIA1BCGpBxMzOABDvLAALQQQgBUHUzM4AELA7AAsgFiAAQQJ0aiAGNgIAIA1BIGokACAVDwsgBSACQYTNzgAQrzsAC80FAg5/An4jAEEgayINJAACQAJAAkAgAyAGcSIOIAJNBEAgCSgCCCEKIAAoAiwhEiABIA5qIhMgAiAOayIUELceIRAgCiAOaiIMIAJPDQEgASAMai0AACEMIAkpAwAhGCAJQQA2AgwgBiAFKAIAIg9rIgUgBk8NAwJAIAIgAyAFcSIFIApqIgtLBEAgDCABIAtqLQAARg0BDAULIAsgAkHUy84AEMMhAAsgAiAFSQ0CIAEgBWogAiAFayATIBQgBxD0ASILRQ0DIAsgBSAEEKEuIgogEhDyNCEYIAkgDzYCECAJIAo2AgggCSAYNwMAIAIgCiAOaiIFSwRAIAEgBWotAAAhDEEBIRUMBAsgBSACQfTLzgAQwyEACyAOIAJBpMvOABCvOwALIAwgAkG0y84AEMMhAAsgBSACQeTLzgAQrzsACwJAAkACQCAQIAAoAgQiC00EQCALIBBrIgVBAU0NASAAKAIAIhYgEEECdGohF0EAIQACQAJAA0AgAEEIRwRAIAAgF2ooAgAiESADcSIFIApqIg8gAk8NAiAAQQRqIQAgBiARayIRQQFrIAhPDQEgDCABIA9qLQAARw0BIAIgBUkNByABIAVqIAIgBWsgEyAUIAcQ9AEiD0UNASAYIA8gBSAEEKEuIgUgESASEIwtIhlaDQEgCSARNgIQIAkgBTYCCCAJIBk3AwAgBSAOaiIKIAJPDQMgASAKai0AACEMQQEhFSAZIRggBSEKDAELCyAQIAZBA3ZBAXFqIgAgC0kNBCAAIAtB5MzOABDDIQALIA8gAkH0zM4AEMMhAAsgCiACQZTNzgAQwyEACyANQQA2AhggDUEBNgIMIA1BmNfOADYCCCANQgQ3AhAgDUEIakHEzM4AEO8sAAtBAiAFQdTMzgAQsDsACyAWIABBAnRqIAY2AgAgDUEgaiQAIBUPCyAFIAJBhM3OABCvOwALnAYBBX8gAigCGCEHAkACQCAGRQRAIAAoAmwNAQsgB0EBRg0BIANBAUcNACAHQQNrQQNJDQELQQQgAigCBHQhCAtBACEHAkAgBkUNACACKAIQQQNHDQBBESACKAIAIgcgB0ERTxshBwsgAigCCCEJAn8gBUUEQCABKAIIIQUgACgCACEKIAAoAgQMAQsgAEHLtMIANgIIIABBy7TCADYCBCAAQQA2AhRBzbTCACEKIABBzbTCADYCACABIAEoAggiBTYCEEHLtMIACyELIABBADYC3AEgACAHNgIgIABBADYCtAEgAEEANgKMASAAQQA2AhggASAFNgIMIAAgCiALayIFNgIQIAAgBTYCHCAAIAU2AgwgACABQQQgCXQQ+yc2AlwgACABIAgQ+yc2AmQgACABQQQgB3RBACAHGxD7JzYCYEFAIQcgAS0AHAR/IAcFAkAgBA0AIAEoAhAiBSABKAIMIgdJBH8gByAFayIEBEAgBUEAIAT8CwALIAEoAgwhByABKAIQBSAFCyAHTw0AIAEgBzYCEAsCQCADQQFHDQAgAigCGEEGa0F9SQ0AQQEgCXQhAwJAIAYEQAJAIAEgA0E/akFAcSIEQQEQpiQiA0UNACADIAEoAhgiBU8NACAFIANrIgUgBCAEIAVLGyIEBEAgA0EAIAT8CwALIAEgAzYCGAsgACADNgIoIAAgACkDUEIIEMgqIAA1AlhCBBDIKoU3A1AMAQsgACABIAMQ1TUiBDYCKCADBEAgBEEAIAP8CwALIABCADcDUAsgACACKAIIQQRBBiACKAIMIgMgA0EGTxsiAyADQQRNG2s2AiQLAkAgBkUNACACKAIYQQdJDQAgACABQYAIENU1NgJwIAAgAUGQARDVNTYCdCAAIAFB1AEQ1TU2AnggACABQYABENU1NgJ8IAAgAUGIgAIQ1TU2AoABIAAgAUGcgAcQ1TU2AoQBCyAAIAIpAgA3ArgBIABB0AFqIAJBGGooAgA2AgAgAEHIAWogAkEQaikCADcCACAAQcABaiACQQhqKQIANwIAQUBBACABLQAcGwsLtwYCBn8BfiMAQUBqIgIkAAJAIAG9Qv///////////wCDQoCAgICAgID4/wBaBEAgAEGAgICAeDYCAAwBCwJAIAGdIgFEAAAAAAAAAABiBEAgAkEIaiIEQQFBfyABvSIIQgBZGzoACiAEIAhCNIinQf8PcSIDQbMIazsBCCAEIAhC/////////weDQoCAgICAgIAIhCAIQgGGQv7///////8PgyADGzcDACACLQASQf8BRgRAIABBgICAgHg2AgAMAwsgAi4BECEEIAIpAwghCCACQRBqIgZB+PKHASgCADYCACACQfDyhwEpAgA3AwggCFBFBEBBASEDA0AgAigCCCADQQFrRgRAIAJBCGpB/PKHARCdKAsgAigCDCAFaiAIPgIAIAVBBGohBSACIAM2AhAgA0EBaiEDIAhC/////w9WIAhCIIghCA0ACwsgAkEgaiAGKAIANgIAIAIgAikDCDcDGAJAAkAgBEEASiAEQQBIa0H/AXEOAgMBAAsgAkEgaiIDKAIAIQUgA0H48ocBKAIANgIAIAJBMGoiAyAFNgIAIAIgAikDGDcDKCACQfDyhwEpAgA3AxgCQCACQShqIgUQ9TUoAggEQCACQTRqIAVBACAEayIEwUEFdiAEQR9xEJUJDAELIAJBEGogAygCADYCACACIAIpAyg3AwggAkE0aiACQQhqEKcrCyACQRhqEOk7IAJBIGogAkE8aigCADYCACACIAIpAjQ3AxgMAgsgAkEgaiIDKAIAIQUgA0H48ocBKAIANgIAIAJBMGoiAyAFNgIAIAIgAikDGDcDKCACQfDyhwEpAgA3AxgCQCACQShqEPU1KAIIBEAgAkEQaiADKAIANgIAIAIgAikDKDcDCCACQTRqIAJBCGogBEEFdiAEQR9xEKgFDAELIAJBEGogAygCADYCACACIAIpAyg3AwggAkE0aiACQQhqEKcrCyACQRhqEOk7IAJBIGogAkE8aigCADYCACACIAIpAjQ3AxgMAQsgAEEIakH48ocBKAIANgIAIABB8PKHASkCADcCAAwBCyAAIAIpAxg3AgAgAEEIaiACQSBqKAIANgIACyACQUBrJAAL1QUBBH8jAEEQayINJAAgDUEIakIANwMAIA1CADcDAAJAIAJFDQAgACEPA0ACQAJAIAEgEEcEQCAPKAIARQ0CIA5BBE8EQCAOQQRHDQUMAgsgDSAOQQJ0aiAQNgIADAELIAEgAUH86NEAEMMhAAsgDkEBaiEOCyAPQQRqIQ8gAiAQQQFqIhBHDQALC0EgIANBAWsiA2drQQAgAxshDwJAIA5BAk8EQCACIAdNBEAgAgRAIAZBACAC/AsACyAAIAEgAkEPIAQgBSAGIAcQ6wggBiAHIAIgCCAJELMLIA5BBU8EQCAGIAcgAiAEIAUgCiALIAwQ4QcMAwtBAkIBIAogCyAMEOUSQQIgDkEBayIJrSAKIAsgDBDlEiANQQRyIQhBACEDA0ACQCADIgBBAWoiAyAOTw0AIA0gAEECdGohBCAIIRAgCSEBAkADQCAHIBAoAgAiAEsEQCAEKAIAIgIgB08NAiAAIAZqLQAAIAIgBmotAABJBEAgECACNgIAIAQgADYCAAsgEEEEaiEQIAFBAWsiAQ0BDAMLCyAAIAdB3OjRABDDIQALIAIgB0Hs6NEAEMMhAAsgCEEEaiEIIAlBAWshCSADIA5HDQALIA8gDSgCACIArSAKIAsgDBDlEiAPIA01AgQgCiALIAwQ5RICQAJAIA5BAmsOAgQBAAsgDyANNQIIIAogCyAMEOUSIA8gDTUCDCAKIAsgDBDlEiAAIAdJBEBBASAAIAZqLQAAQQFGrSAKIAsgDBDlEgwECyAAIAdBzOjRABDDIQALIA8gDTUCCCAKIAsgDBDlEgwCCyACIAdBjOnRABCwOwALQQRCASAKIAsgDBDlEiAPIA0oAgAiAK0gCiALIAwQ5RIgACAHTwRAIAAgB0Gc6dEAEMMhAAsgACAGakEAOgAAIAAgCU8EQCAAIAlBrOnRABDDIQALIAggAEEBdGpBADsBAAsgDUEQaiQAC5MGAgl/AX4jAEGQAWsiAyQAIAMgAiABa0EYbiIGNgJkIANB6ABqIAZBB2pBA3YQ0h9BwAAhBQJAAkAgBkEEdCIKQUBxQUBrIAogBkEDcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAnAhCSAFIQQgASACRg0CA0ACQCABKAIABEAgAUEIaikDACEMIARBCGogAUEQaikDADcDACAEIAw3AwAgCSAHQQN2aiILIAstAABBASAHQQdxdHI6AAAMAQsgBEIANwMAIARBCGpCADcDAAsgB0EBaiEHIARBEGohBCABQRhqIgEgAkcNAAsMAgtBrMH/AEEpIANB+ABqQcTI/wBB2MH/ABDVHgALQcAAIAgQoz0ACyADIAQgBWtBBHUiATYCWAJAAkAgASAGRgRAIAMoAnQhBCADIAMpAmg3AoQBIANBADYCgAEgAyAENgJ8IAMgCTYCeCADQQhqIANB+ABqIgIQ1zsgAygCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASADKQJ4NwIIIAFBEGogA0GAAWoiCSkCADcCACABQRhqIANBiAFqIgsoAgA2AgAgAyAINgKIASADQoCAgICACDcCgAEgAyAKNgJ8IAMgBTYCeCADIAIQ1zsgAygCACEFQRxBBBCtNiICRQRAQQRBHBCjPQALIAJCgYCAgBA3AgAgAiADKQJ4NwIIIAJBEGogCSkCADcCACACQRhqIAsoAgA2AgAgAyAENgJgIAMgBzYCXCADIAE2AlhBDEEEEK02IgFFDQIgASAKNgIIIAEgBTYCBCABIAI2AgAgA0EBNgJwIAMgATYCbCADQQE2AmggA0EANgKAASADQoCAgIDAADcCeCADQRRqIgJB5Lv/ACAGIAEgA0HYAGogA0HoAGogA0H4AGoQjBMgACACEL4TIANBkAFqJAAPCyADQgA3AoQBIANCgYCAgMAANwJ8IANBwLv/ADYCeEEAIANB2ABqIANB5ABqIANB+ABqQci7/wAQrysAC0EEQRwQoz0AC0EEQQwQoz0AC5MFAQZ/IAEgAmohBgJAAkAgAkUEQCABIQIMAQsgASECA0AgBCIIAn8gAiIELAAAIgVBAE4EQCAFQf8BcSEDIAJBAWoMAQsgBC0AAUE/cSEDIAVBH3EhAiAFQV9NBEAgAkEGdCADciEDIARBAmoMAQsgBC0AAkE/cSADQQZ0ciEDIAVBcEkEQCADIAJBDHRyIQMgBEEDagwBCyACQRJ0QYCA8ABxIAQtAANBP3EgA0EGdHJyIQMgBEEEagsiAiAEa2ohBAJAIANBIEYgA0EJa0EFSXINACADQYABSQ0CAkAgA0EIdiIFQR9NBEAgBUUNASAFQRZHIANBgC1Hcg0EDAILIAVBIEcEQCAFQTBHIANBgOAAR3INBAwCCyADQf8BcUH71IkBai0AAEECcUUNAwwBCyADQf8BcUH71IkBai0AAEEBcUUNAgsgAiAGRw0AC0EAIQhBACEEDAELIAIgBkYNAANAIAYiBUEBayIGLAAAIgNBAEgEQCADQT9xAn8gBUECayIGLQAAIgfAIgNBQE4EQCAHQR9xDAELIANBP3ECfyAFQQNrIgYtAAAiB8AiA0FATgRAIAdBD3EMAQsgA0E/cSAFQQRrIgYtAABBB3FBBnRyC0EGdHILQQZ0ciEDCwJAIANBIEYgA0EJa0EFSXINAAJAIANBgAFJDQACQAJAIANBCHYiB0EfTQRAIAdFDQEgB0EWRw0DIANBgC1GDQQMAwsgB0EgRg0BIAdBMEcNAiADQYDgAEYNAwwCCyADQf8BcUH71IkBai0AAEEBcUUNAQwCCyADQf8BcUH71IkBai0AAEECcQ0BCyAEIAJrIAVqIQQMAgsgAiAGRw0ACwsgACAEIAhrNgIEIAAgASAIajYCAAu5BQETfyABIAAoAgQiEWsiCkEBIAAoArwBdCISayIJIApLIQsgCkEBIAAoArgBdCIHayAAKAIQIgYgCiAGayAHSxshDCAAKAIYIQ0gACgCxAEhDiAAKAIMIQ8gACgCCCETQQMhByAAKAK0ASEIIAAoAmQhFCAFQQNGBEAgASAIKALAAUECayAEEKMdQQJ0IRALQQAgCSALGyEVIAYgDCANGyEMQQEgDnQhCSAPIBNqIQ0gDyARaiELIBJBAWshDiAKQQNqIRYgAUEEaiESIAFBA2shFyAAIABBuAFqIAEgBCAAKALcARC8GSEAIAVBAUchGAJAA0ACQCAJRSAAIAxJcg0AAkAgBwJ/IBhFIAAgD0lxRQRAIAAgEWoiBiAHakEDaygAACAHIBdqKAAARw0CIAEgBiACEIAUDAELIAAgE2oiBigAACABKAAARw0BIBIgBkEEaiACIA0gCxDNKEEEagsiBk8NACADIBYgAGs2AgAgBiIHIAFqIAJGDQMLIAAgFU0NACAJQQFrIQkgFCAAIA5xQQJ0aigCACEADAELCyAHIQYLAkAgBUEDRgRAIAMgBiAJIAggASACIAsgCiAPIBAQoA0hAAwBCwJAIAVBAkcNAEEAIQcgCCgCACIRIAgoAgQiE2siBUEBIAgoArwBdCIQayIAQQAgACAFTRshDCAIKAIMIQ0gCCgCZCEOIAgoAlwgASAIKALAASAEEKMdQQJ0aiEAIBBBAWshCCAFIApqQQNqIQUDQCAHIAlGDQEgACgCACIEIA1JDQECQCAEIBNqIgAoAAAgASgAAEcNACASIABBBGogAiARIAsQzShBBGoiACAGTQ0AIAMgBSAEIA9qazYCACAAIgYgAWogAkYNAwsgBCAMTQ0BIAdBAWohByAOIAQgCHFBAnRqIQAMAAsACyAGDwsgAAuRBgEJfyMAQZABayIDJAAgAyACIAFrIgRBBXYiCTYCZCADQegAaiAJQQdqQQN2ENIfQcAAIQUCQAJAIARBAXYiCkHA////B3FBQGsgCiAEQf4AcRsiB0HAABDRNARAIAcEQCAHQcAAEK02IgVFDQILIAMoAnAhCCAFIQQgASACRg0CA0ACQCABKAIAQQFxBEAgBCABQRBqKQMANwMAIAQgAUEYaikDADcDCCAIIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwggBEIANwMACyAGQQFqIQYgBEEQaiEEIAFBIGoiASACRw0ACwwCC0HklIABQSkgA0H4AGpByJeAAUGQlYABENUeAAtBwAAgBxCjPQALIAMgBCAFa0EEdSIBNgJYAkACQCABIAlGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAINgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIIKQIANwIAIAFBGGogA0GIAWoiCygCADYCACADIAc2AogBIANCgICAgIAINwKAASADIAo2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAIKQIANwIAIAJBGGogCygCADYCACADIAQ2AmAgAyAGNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAo2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkH0kYABIAkgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQsBMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALlisCG38BfiMAQRBrIh0kACAGQYABaiEZIAZB/A9qIRYgBkHwDWohGCAGQbQQaiEVIAZBgAJqIRQgAEH/D3EhGiAGLQCMESEAIAZB8hBqIhBBEGohGyAGQaANaiIXQRhqIR4DQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEH/AXFBAWsOBQMBBAUGAAtBAiEKIBhBAiAWIAcgCBDtHw0BDAkLQQMhAAJ/IwBBEGsiEyQAIAYoArQQIg5BAWoiEiAGKAL8DyINTwRAIBJB0AVNBEAgBkGAAmohEQJAAkACfyANIBJHBEBBICAaQQFrIglna0EAIAkbIQkgDkEBdCANQQF0IgprQQJqIQwgBkHwDWohDyAKIBFqIQsDQCATQQA2AgwgDyAJIBNBDGogByAIEO0fRQRAIAZBAjoAjBEgBiANNgL8D0ECDAMLQXwgASATKAIMIgpNDQIaIAsgCjsBACANQQFqIQ0gC0ECaiELIAxBAmsiDA0ACwsgDkHRBU8NAUEBIA5FDQAaIAYgDkEBdCIKakGAAmohHEEAIQ8gESEJA0AgDyASRg0DIAlBAmohDCARIA9BAWoiD0EBdGohDSAKIQsDQCALRQRAIApBAmshCiAMIgkgHEcNAkEBDAMLIAtBAmshCyANLwEAIA1BAmohDSAJLwEARw0ACwtBewsgE0EQaiQADAQLIA5B0AVBrJ/zABCwOwALIA5BAmogEkG8n/MAELE7AAsgEkHQBUGcn/MAELA7AAsgDSASQZyf8wAQsTsACyIKQQFHDQgMBwtBASEAIBYoAgBBAUYNBiAGQoCAgICABDcDuBAgF0IANwMAIBBCADcBACAXQQhqQQA2AgAgEEEIakIANwEAIBtBADsBAEEEIQAMBgsgGEECIBUgByAIEO0fRQRAIAZBAToAjBFBAiEKDAcLIBZBADYCAEECIQAMBQsgFSgCACIAQQNGBEAgHUEANgIMIBhBASAdQQxqIAcgCBDtH0UEQCAGQQM6AIwRQQIhCgwHCyAVIBUoAgAgHSgCDGoiADYCAAsgAyAESQ0CAn8gAiAEQQJ0aiECIAMgBGshB0EAIQkjAEEQayIIJAACQAJAAkACQAJAAkACQCAAQQVJBEACQAJAAkACQAJAIABBAWsOBAECAwQACyAHRQ0FIAJBADoAAiACIBQvAQA7AQBBASEEDAsLIAdFDQUgAkEBOgACIAdBAUYNBiACQQE6AAYgAiAULwECIgAgFC8BACIBIAAgAUsbOwEEIAIgACABIAAgAUkbOwEAQQIhBAwKCyAHRQ0GIAJBAToAAiACIBQvAQAiADsBACAHQQNJDQcgAiAAOwEIIAJBAToACgJAIBQvAQQiASAULwECIgBNBEAgAiABOwEEIAdBA0cNAUEDQQNBxOfzABDDIQALIAIgADsBBCABIQAgB0EDRg0JCyACQQI6AA4gAkECOgAGIAIgADsBDEEEIQQMCQsgCCAULwEGOwEOIAggFC8BBDsBDCAIIBQoAQA2AQhBAiEEA0AgCEEIaiAJQQF0aiIKLwEAIQEgBCEAA0AgCEEIaiAAaiILLwEAIgMgAUH//wNxSQRAIAsgATsBACAKIAM7AQAgAyEBCyAAQQJqIgBBCEcNAAsgBEECaiEEIAlBAWoiCUEDRw0ACyACQQJqIQFBACEAAkADQCAAIAdGDQEgAUECOgAAIAFBBGohASAAQQFqIgBBBEcNAAsgAiAILwEIOwEAIAIgCC8BCjsBCCACIAgvAQw7AQQgAiAILwEOOwEMQQQhBAwJCyAHIAdBlOjzABDDIQALIBQvAQAhBCAULwECIQMgFC8BBiIAIBQvAQQiASAAIAFLGyEJIAAgASAAIAFJGyEKQQAhACACIQECQANAIAAgB0YNASABIAQ7AQAgAUECaiAAQQFxQQFqOgAAIAFBBGohASAAQQFqIgBBB0cNAAsgAiADOwEUIAIgCjsBDCACIAM7AQRBCCEEIAdBCE8EQCACQQM6AB4gAkEDOgAOIAIgCTsBHAwJC0EHIAdB5OjzABDDIQALIAcgB0GU6fMAEMMhAAtBgObzAEEiQaTm8wAQnykAC0EAQQBBtObzABDDIQALQQBBAEHU5vMAEMMhAAtBAUEBQeTm8wAQwyEAC0EAQQBBhOfzABDDIQALQQIgB0Gk5/MAEMMhAAtBA0EDQdTn8wAQwyEACwJAAkAgBEGAAkcEQANAIAQEQEEAIQEgByAEayIAQQAgACAHTRshAyAEQQJ0IQkgAiEAA0AgASAHRg0EIAEgA0YNBSAAIAlqIgogAC8BADsBACAKQQJqIABBAmotAAA6AAAgAEEEaiEAIAQgAUEBaiIBRw0ACwsgBEEBdCIEQYACRw0ACwsgCEEQaiQAQYACDAILIAcgB0H06PMAEMMhAAsgASAEaiAHQYTp8wAQwyEACyEAIAUEQCAFIAA2AgALIAZBADoAjBFBASEKDAULAn8gBigC/A8iCUETSQRAIAYoArgQIREgBigCvBAhDQJAIAlBEkYNACAGQaANaiESIAZB8hBqIRMgBkHwDWohDANAIAkiAEEBaiEJIABBrKDzAGotAAAhDgJAAkADQCAGKAL4DSIKQcEAa0F8SQ0BIAwgByAIEMsgDQALQcAAIAYoAvgNIgprQQAhDyAKQcAARwRAIAwpAwAgCkE/ca2Ip0EPcSEPCyAPQdCg8wBqLQAAIgtPDQEgBkEEOgCMESAGIA02ArwQIAYgETYCuBAgBiAANgL8D0ECDAULIAwpAwAgCkE/ca2Ip0EPcSIPQdCg8wBqLQAAIQsLIAYgCiALajYC+A0CQAJAIA5BEU0EQCAOIBNqIA9B4KDzAGotAAAiADoAACAARQ0CIABBD0sNASASIABBAXRqIgogCi8BAEEBajsBACARQQFqIREgDUEgIAB2ayINQSFrQWBPDQIMBAsgDkESQfCg8wAQwyEACyAAQRBBgKHzABDDIQALIAlBEkcNAAsLQQFBekEBIA0bIBFBAUYbDAELIAlBEkHAoPMAELE7AAsiCkEBRw0EQQAhCSMAQeAAayILJAAgC0EAQcgA/AsAIAtB3ABqQQA2AgAgC0HUAGpCADcCACALQgA3AkxBfyEPIBdBAmohDiALQcwAaiEMAkACQAJAAkADQCAJQQ9GDQEgDCAPIA4vAQBqIg82AgAgDkECaiEOIAxBBGohDCAJQQFqIglBBUcNAAtBESEJIAtBETYCSEEAIQwCQAJAA0ACQAJAAkAgCUESSQRAIAkgEGotAAAiAEEGTw0BIAtByABqIABBAnRqIgAgACgCACIAQQFrNgIAIABBEk8NAyALIABBAnRqIAk2AgAgDEEBaiIMQQZHDQJBACEMIAkNAiALKAJIRQRAIAsoAgAhAEEAIQkDQCAGIAlqIgogADsBACAKQQJqQQA6AAAgCUEEaiIJQYABRw0ACwwJCyAGQYIBaiEcQYABIQxBASENQQAhAEEAIQpBAiEPAkADQCAXIA1BAXRqLwEAIhEEQEESIAAgAEESTRshEkEAIA9rIR8gHCAPQQJ0IglrISBBACAJayEhIAAhCQNAIAkgEkYNAyAKQYACTw0JIAlBAWohACALIAlBAnRqKAIAISIgHyAKQYDg8wBqLQAAIhNqISMgICATQQJ0aiEJQSAhDgNAIA4gI2pBIE8NCyAJIA06AAAgCUECayAiOwEAIAkgIWohCSAOIA9rIg5BAEoNAAsgCiAMaiEKIAAhCSARQQFrIhENAAsLIA1BBUYNCiAPQQF0IQ8gDEEBdiEMIA1BAWoiDUEQRw0ACwwKCyASQRJB0OLzABDDIQALIAlBEkHg4vMAEMMhAAsgAEEGQfDi8wAQwyEACyAJQQFrIQkMAQsLIABBEkGA4/MAEMMhAAsgCkGAAkGA4vMAEMMhAAsgEyAPayAOakEgQZDi8wAQwyEACyAJQQFqQRBBkOPzABDDIQALIAtB4ABqJAAMAQtBEEEQQcDi8wAQwyEACyAeQgA3AwAgF0EQakIANwMAIBdBCGpCADcDACAXQgA3AwBBcCEAQQAhCgJAA0AgCiAZaiAANgIAIAAgBigCwBBqIglB0AVPDQEgFCAJQQF0akH//wM7AQAgAEEBaiEAIApBBGoiCkHAAEcNAAsgBkIANwK0ECAGQYCAAjYCvBAgBkKAgICAgAE3ApwQQQUhAAwECyAJQdAFQaCh8wAQwyEAC0ECIQojAEEgayIQJAAgECAGKAK0ECIRNgIMIBAgBigCuBAiDzYCECAQIAYoArwQIgs2AhQgECAGKAKgECINNgIYIBAgBigCnBAiCTYCHCAGQfANaiEAAkAgBigC+A1BwABGBEBBAiEMIAAgByAIEMsgRQ0BC0EBIQwCQCALRSABIBFNcg0AIAYgBigCgA5BBE8EfyAGQYABaiENIAZBoA1qIQ8gBkGAAmohDgNAAkACQAJAIAAoAggiCUEgTwRAIAAgCUEgczYCCCAAKAIMIgtBBGohCSALQXtLDQEgCCAJSQ0CIAApAwAhJCAAIAk2AgwgACAAKAIQQQRrNgIQIAAgByALajUAAEIghiAkQiCIhDcDAAsMAgsgCyAJQZiq+wAQsTsACyAJIAhBmKr7ABCwOwALIAYgBigC+A0iCSAGIAYpA/ANIiQgCUE/ca2Ip0EfcUECdGoiCS0AAmoiCzYC+A0CQCAJLwEAIglBEE8EQCAGIAtBAkEDIAlBEEYbIhFqNgL4DSAJIBFBAnRB+JzzAGooAgAgJCALQT9xrYincSABIBBBDGogEEEQaiAQQRRqIBBBGGogEEEcaiAOIAYoAsAQIA8gDRCbEAwBCyAJIBBBDGogEEEQaiAQQRRqIBBBGGogDiAGKALAECAPIA0QlxgLIBAoAhQiC0UgECgCDCIRIAFPcg0CIAYoAoAOQQNLDQALIBAoAhwhCSAQKAIYIQ0gECgCEAUgDws2ArgQIAYgETYCtBAgBiANNgKgECAGIAk2ApwQQQIhDAsgBiALNgK8EAsgEEEgaiQAIAxBAkYEQEEBIRUCQCAGKAK0ECABTw0AIAYoArwQRQ0AIAZBvBBqIQkgBkG0EGohCyAGQYABaiENIAZBoA1qIQ8gBkGAAmohDiAGQZwQaiEYIAZBoBBqIRIgBkG4EGohEyAGQfANaiEWAkADQAJAAkACQEHAACAGKAL4DSIAayIZIAYgBikD8A0gAEE/ca2Ip0EAIABBwABHGyIaQR9xQQJ0aiIRLQACIhBPBEAgES8BACIRQRBPDQEgBiAAIBBqNgL4DSARIAsgEyAJIBIgDiAGKALAECAPIA0QlxgMAgsgFiAHIAgQyyANAQwECyARQQ5rIgxBIU8NASAZIAwgEGoiG08EQCAGIAAgG2o2AvgNIBEgDEECdEH4nPMAaigCACAaIBB2cSABIAsgEyAJIBIgGCAOIAYoAsAQIA8gDRCbEAwBCyAWIAcgCBDLIEUNAwsgCygCACABTw0DIAkoAgANAQwDCwsgDEEhQfyd8wAQwyEAC0ECIRULIBVBAUcNBAtBeSEKIAYoArwQDQMgAyAESQ0BAn8gAiAEQQJ0aiEQIAMgBGshDkEAIRICQCAGKALAECITQQFrIgBB0AVJBH8gE0EBdCAUakECayEAQQ8hEQNAIAAvAQBB//8DRw0CIABBAmshACATIBFBAWsiEWoiAUEQa0HQBUkNAAsgAUEQawUgAAtB0AVBgOXzABDDIQALQQEgEXRBgAIiBCARQQhIGyEIQQggESARQQhKGyEDQYABIQ9BASELQQIhDAJAAkACQAJAAkACQANAAkAgFyALQQF0ai8BACIKRQ0AIAggDGshB0EAIAxrIQkgC0EQayENQQAgDEECdGshFQJAA0AgDSATaiIAQdAFTwRAIABB0AVB8OXzABDDIQALIBJBgAJJBEAgFCAAQQF0ai8BACENIAkgEkGA4PMAai0AACICaiEWIBAgAiAHakECdGohACAIIQEDQCABIBZqIA5PDQMgACANOwEAIABBAmogCzoAACAAIBVqIQAgASAMayIBQQBKDQALIA8gEmohEiAKQQFrIgoNAQwDCwsgEkGAAkGA4vMAEMMhAAsgAiAMayABaiAOQZDi8wAQwyEACyADIAtBAWoiC0gEQCAIQYACRwRAA0AgCEEASgRAQQAhASAOIAhrIgBBACAAIA5NGyECIAhBAnQhAyAQIQADQCABIA5GDQcgASACRg0IIAAgA2oiByAALwEAOwEAIAdBAmogAEECai0AADoAACAAQQRqIQAgCCABQQFqIgFHDQALCyAIQQF0IghBgAJHDQALCyARQQhKDQJBgAIMCAsgDEEBdCEMIA9BAXYhDyALQRBHDQALQRBBEEGQ5fMAEMMhAAtBgAEhD0EJIQAgF0ESaiEJQQAhCEGAAiEWQQIhDEEIIQFBgAIhCgJAA0AgACICQRBPDQYgFyAAQQF0aiIYLwEAIhUEQEEBIABBCGsiC3QhA0EAIAxrIRkgAUEPayENQQAgDEECdGshGiAAQQ5KIRsDQAJAAkAgCkGAAkYEQCADIQAgCyEHIBtFBEAgCSEBIAIhACADIQcDQAJAAkAgAEEQRwRAIAcgAS8BAGsiB0EASg0BIAAhCgwCC0EQQRBBoOLzABDDIQALIAFBAmohASAHQQF0IQdBDyEKIABBAWoiAEEPRw0BCwtBASAKQQhrIgd0IQALIBJBgAJPDQkgDiASQYDg8wBqLQAAIgFLDQEgASAOQbDl8wAQwyEACyANIBNqIgFB0AVPDQUgCkGAAkkNASAKQYACQYDi8wAQwyEACyAQIAFBAnRqIgogBCAIaiIIIAFrOwEAIAogB0EIajoAAiANIBNqIgFB0AVPDQQgACAWaiEWIBJBAWohEkEAIQogACEECyAQIApBgODzAGotAAAiByAIIBlqaiIeIARqQQJ0aiEAIBQgAUEBdGovAQAhDSAEIQEDQCABIB5qIA5PDQggACANOwEAIABBAmogCzoAACAAIBpqIQAgASAMayIBQQBKDQALIBggFUEBayIVOwEAIAogD2ohCiAVQf//A3ENAAsLIAlBAmohCSAPQQF2IQ8gDEEBdCEMIAIiAUEBaiIAIBFMDQALIBYMBgsgAUHQBUHA5fMAEMMhAAsgDiAOQdDl8wAQwyEACyABIAhqIA5B4OXzABDDIQALIBJBgAJBgOLzABDDIQALIAggDGsgB2ogAWogDkGQ4vMAEMMhAAsgAkEQQaDl8wAQwyEACyEAIAUEQCAFIAA2AgALIAZBADoAjBFBASEKDAMLIAQgA0GQofMAEK87AAsgBCADQbCh8wAQrzsACyAGIAA6AIwRDAELCyAdQRBqJAAgCgvSBQEGfyMAQSBrIgMkACADIAE2AgACQAJAIAFBgAJGBEAgAkEPcSEEIAJB/wFxIgFBBHQhBiAAIAFBBXRqIQUDQCAEQQFqIQRBACEBIAYhAgNAIAJB/wFLDQMgASAFaiIHIAcvAQAgAUH089EAai8BAGo7AQAgAkEBaiECIAFBAmoiAUEgRw0ACyAFQSBqIQUgBkEQaiEGIARBEEcNAAtBACEFIAAhBkEAIQQDQCAEQQFqQXAhAiAGIQECQAJAA0ACQAJAIARFBEAgAS8BAA0BIANBADYCCCABIANBCGpBxPPRABCNKwALIAIgBWoiCEH/AUsNASABLwEAIAFBIGsvAQBGDQMLIAFBAmohASACQQFqIgINAQwDCwsgCEGAAkHU89EAEMMhAAsgA0EAOwEEIANBADYCCCADQQRqIANBCGpB5PPRABCNKwALIAZBIGohBiAFQRBqIQUiBEEQRw0AC0EAIQUgACEEDAILIANBADYCCEEAIANBvPHRACADQQhqQaT00QAQrysACyACQYACQZT00QAQwyEACwNAIAAgBUEBdCIBakHgA2ovAQAgAUGE89EAai8BAE8EQEFgIQIgBCEBA0AgASACQcTz0QBqLwEAIAEvAQBqIgYgBkH8/wNxQQJ2azsBACABQSBqIQEgAkECaiICDQALCyAEQQJqIQQgBUEBaiIFQRBHDQALQQAhBUEAIQQDQCAEQQFqQXAhAiAAIQECQAJAA0ACQAJAIARFBEAgAS8BAA0BIANBADYCCCABIANBCGpB1PLRABCNKwALIAIgBWoiB0H/AUsNASABLwEAIAFBIGsvAQBGDQMLIAFBAmohASACQQFqIgINAQwDCwsgB0GAAkHk8tEAEMMhAAsgA0EAOwEGIANBADYCCCADQQZqIANBCGpB9PLRABCNKwALIABBIGohACAFQRBqIQUiBEEQRw0ACyADQSBqJAALjQYBCX8jAEGQAWsiAyQAIAMgAiABayIEQQN2Igs2AmQgA0HoAGogC0EHakEDdhDSH0HAACEFAn8CQAJAIARBAXYiCUHA////B3FBQGsgCSAEQf4AcRsiB0HAABDRNARAIAcEQCAHQcAAEK02IgVFDQILIAMoAnAhCCABIAJGBEAgBSEEQQAMBAsgBSEEA0ACQCABKAIABEAgBCABQQRqKAIANgIAIAggBkEDdmoiCiAKLQAAQQEgBkEHcXRyOgAADAELIARBADYCAAsgBkEBaiEGIARBBGohBCACIAFBCGoiAUcNAAsMAgtB5JSAAUEpIANB+ABqQciXgAFBkJWAARDVHgALQcAAIAcQoz0ACyADKAJkCyEBIAMgBCAFa0ECdSICNgJYAkACQCABIAJGBEAgAygCdCEEIAMgAykCaDcChAEgA0EANgKAASADIAQ2AnwgAyAINgJ4IANBCGogA0H4AGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAng3AgggAUEQaiADQYABaiIIKQIANwIAIAFBGGogA0GIAWoiCigCADYCACADIAc2AogBIANCgICAgIAINwKAASADIAk2AnwgAyAFNgJ4IAMgAhDXOyADKAIAIQVBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAMpAng3AgggAkEQaiAIKQIANwIAIAJBGGogCigCADYCACADIAQ2AmAgAyAGNgJcIAMgATYCWEEMQQQQrTYiAUUNAiABIAk2AgggASAFNgIEIAEgAjYCACADQQE2AnAgAyABNgJsIANBATYCaCADQQA2AoABIANCgICAgMAANwJ4IANBFGoiAkGAkoABIAsgASADQdgAaiADQegAaiADQfgAahCMEyAAIAIQwxMgA0GQAWokAA8LIANCADcChAEgA0KBgICAwAA3AnwgA0HEkYABNgJ4QQAgA0HYAGogA0HkAGogA0H4AGpBzJGAARCvKwALQQRBHBCjPQALQQRBDBCjPQALlQUCBH4CfyMAQeAAayIHJAAgAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIIQStrDgMCAQIBCyABLQAAIQgLAkACQAJAAkACQAJAAkACQAJAIAhB/wFxQStrDgMAAgECCyACQQFrIQggAUEBaiEBIAJBIUkNAiAIIQIMBgsgAkEBayEIIAFBAWohASACQSFPBEADQCAIRQ0IIAdBADYCXCAHQUBrIAQgA0IKQgAgB0HcAGoQ9gwgAS0AAEEwayICQQlLDQkgBygCXA0EIAFBAWohASAIQQFrIQggBykDQCIDIAKtIgZ9IQQgBykDSCIFIAUgBSADIAZUrX0iA4WDQgBZDQALIABBAzoAAUEBDAoLIAhFDQQDQCABLQAAQTBrIgJBCUsNCCAHQTBqIAQgA0IKQgAQqB4gAUEBaiEBIAcpAzAiAyACrSIFfSEEIAcpAzggAyAFVK19IQMgCEEBayIIDQALDAYLIAJBH0sNBAwCCyAIIgJFDQIMAQsgAEEDOgABQQEMBgsDQCABLQAAQTBrIghBCUsNBCAHIAQgA0IKQgAQqB4gAUEBaiEBIAcpAwggBykDACIDIAitfCIEIANUrXwhAyACQQFrIgINAAsMAgsMAQsDQCACRQ0BIAdBADYCLCAHQRBqIAQgA0IKQgAgB0EsahD2DCABLQAAQTBrIghBCUsNAiAHKAIsDQMgAUEBaiEBIAJBAWshAiAHKQMYIgVCf4UgBSAFIAcpAxAiAyAIrXwiBCADVK18IgOFg0IAWQ0ACyAAQQI6AAFBAQwDCyAAIAQ3AxAgACADNwMYQQAMAgsgAEEBOgABQQEMAQsgAEECOgABQQELOgAAIAdB4ABqJAALhwUCDH8CfiMAQSBrIgUkACAFQQA2AhQgBUKAgICAgAE3AgwCQCABKAIIIgZFDQAgBSABKAIEIgQtAAQiDDoAHCAFIAQoAgA2AhggA0UNACACIANBGGxqIQ0gBCAGQQN0aiEPIAJBGGohASAEQQhqIQkgBUEYaiEDQQAhBgNAAkACQAJAAkACQCADLQAEIgsgB0EBcXIEQAJAIAYEQCABIQQgCCEBDAELIAEgDUYEQEEBIQYMBQsgAUEYaiEEQQEhBgsgAQ0BIAQhAQwDCyACKQMAIhAgAjQCEHwhESAFKAIMIA5GBEAgBUEMakHsgM0AEJUoCyAFKAIQIA5BBHRqIgQgETcDCCAEIBA3AwAgBSAOQQFqIg42AhQCQCAGBEAgASEEIAghAQwBCyABIA1GBEBBASEGQQAhCEEBIQcMBQsgAUEYaiEEQQEhBgtBASEHIAFFDQELAn8CQCADKAIAIApqIgsgASIIKAIIIgpNBEAgCiALRg0BIAQMAgsgAyALIAprNgIAIAZBACEGBEAgBCEBQQAhByAIIQIMBgtBACAEIAQgDUYiARshAiAEQQBBGCABG2ohAUEAIQcMBQsgBkEAIQYEQEEAIQcgCCECIAQMAQtBACAEIAQgDUYiARshAkEAIQcgBEEAQRggARtqCyEBIAshCgwCC0EAIQggBCEBDAELIAtBAXMgB3IhB0EAIQgLAn8gCSAPRgRAQQIhDCAPDAELIAktAAQhDCAJKAIAIQMgCUEIagshCSAFIAw6ABwgBSADNgIYCyACRQ0BQQAgBUEYaiAMQQJGIgQbIQMgBEUNAAsLIAAgBSkCDDcCACAAQQhqIAVBFGooAgA2AgAgBUEgaiQAC9AGAgd/AX4jAEEwayICJAACfyMAQRBrIgMkAAJAIAEtAAwEf0EABSADAn4CQCABKAIIIgVFDQAgASgCBCEEIAVBAnQhBQNAIAQoAgBFBEAgCUIgfSEJIARBBGohBCAFQQRrIgUNAQwCCwsgAyAEKAIAaK0gCX03AwhCAQwBC0IACzcDACADKAIARQ0BIAMpAwhQCyADQRBqJAAMAQtB+KWIAUEcQZSmiAEQyyQACyEDAkAgASgCBCIEIAEgASgCAEGAgICAeEYiBRsoAggEQCACQRBqIAFBAEEBEJUJDAELIAVFBEAgAkEYaiABQQhqKAIANgIAIAIgASkCADcDEAwBCyACQRBqIAQQ6R0LAkAgA0UNACACKAIYIgZFBEAgAigCEEUEQCACQRBqQayKiAEQnSgLIAIoAhRBADYCACACQQE2AhhBASEGCyACIAIoAhQiA0EEaiIFNgIkIAIgAzYCICACQSBqEJ42IgRFDQAgBEEARyEEA0AgAyAHIAMoAgBBAWoiCGoiBzYCACAIRSAHIAhJciEHIANBBGohAyAEQQFrIgQNAAsgB0UNACAGQQJ0QQRrIQMDQCADBEAgBSAFKAIAQQFqIgQ2AgAgA0EEayEDIAVBBGohBSAERQ0BDAILCyACKAIYIgMgAigCEEYEQCACQRBqQbyKiAEQnSgLIAIoAhQgA0ECdGpBATYCACACIANBAWo2AhgLIAJBKGogAkEYaigCADYCACACIAIpAxA3AyACQCABLQAMIgFBAUcEQCABQQEgAigCKBshAwwBCyACQQA2AiggAkEgakEEQQQQniQCQCACKAIoIgRFDQAgAigCJCIBIARBAnQiA2pBBGsiBUUNACAFKAIADQAgAUEEayEFIARB/////wNxIQECQANAIANFBEBBACEDDAILIAFBAWshASADIAVqIANBBGshAygCAEUNAAsgAUEBaiIDIARLDQELIAIgAzYCKCADIQQLQQEhAyAEIAIoAiBBAnZPDQAgAkEIaiACQSBqIARBBEEEEPQUIAIoAggiAUGBgICAeEYNACABIAIoAgxBzI2IARD9LwALIAAgAikDIDcCACAAIAM6AAwgAEEIaiACQShqKAIANgIAIAJBMGokAAvvBQIEfwV+IwBBgAFrIgQkACABvSEIAn9BAyABmUQAAAAAAADwf2ENABpBAiAIQoCAgICAgID4/wCDIglCgICAgICAgPj/AFENABogCEL/////////B4MiDEKAgICAgICACIQgCEIBhkL+////////D4MgCEI0iKdB/w9xIgUbIgpCAYMhCyAJUARAQQQgDFANARogBUGzCGshBUIBIQkgC1AMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIGGyEKQgJCASAGGyEJQct3Qcx3IAYbIAVqIQUgC1ALIQcgBCAFOwF4IAQgCTcDcCAEQgE3A2ggBCAKNwNgIAQgBzoAegJ/AkACQAJAAkACQCAHQf8BcSIGQQFNBEAgA0H//wNxIQcgBEEgaiAEQeAAaiAEQQ9qEP8CQe7riQFBASAIQgBTIgMbIQVB7uuJAUHv64kBIAMbIQYgCEI/iKchAyAEKAIgRQ0BIARB2ABqIARBKGooAgA2AgAgBCAEKQIgNwNQDAILIAZBAkYNA0EBIQVB7uuJAUHv64kBIAhCAFMiBhtB7uuJAUEBIAYbIAIbIQZBASAIQj+IpyACGyECIAdB/wFxQQRGDQIgBEEDNgIoIARB8+uJATYCJCAEQQI7ASAgBEEgagwFCyAEQdAAaiAEQeAAaiAEQQ9qEJQBCyAGIAUgAhshBkEBIAMgAhshAiAEIAQoAlAgBCgCVCAELwFYIAcgBEEgahDtDyAEKAIEIQUgBCgCAAwDC0ECIQUgBEECOwEgIANB//8DcUUNASAEQQE2AjAgBEEAOwEsIARBAjYCKCAEQcXriQE2AiQgBEEgagwCCyAEQQM2AiggBEHw64kBNgIkIARBAjsBIEEBIQZBACECQQEhBSAEQSBqDAELQQEhBSAEQQE2AiggBEH264kBNgIkIARBIGoLIQcgBCAFNgJcIAQgBzYCWCAEIAI2AlQgBCAGNgJQIAAgBEHQAGoQtQogBEGAAWokAAvRBQIOfwJ+IwBBgAFrIgIkACABKAIEIQsgAkHwAGogASgCCCIIQQBBCEHQABCgGCACKAJ0IQEgAigCcEEBRwRAIAIoAnghCQJAIAFFDQAgCEHQAGwhDCABIQoDQCAGIAxGDQFBACEEQQAhBSAGIAtqIgNBEGooAgBBAUYEQAJAIANBFGooAgAiBQRAIAJB4ABqIANBIGogA0EYaigCACADQRxqKAIAIAUoAgARBQAMAQsgAkEANgJgC0EBIQULIANBJGooAgBBAUYEQAJAIANBKGooAgAiBARAIAJB8ABqIANBNGogA0EsaigCACADQTBqKAIAIAQoAgARBQAMAQsgAkEANgJwC0EBIQQLQgAhECADKAIAQQFGBEAgA0EIaikDACERQgEhEAsCQCADQThqIgcoAgBBgICAgHhHBEAgAkHIAGogBxClHQwBCyACQYCAgIB4NgJICwJAIANBxABqIgMoAgBBgICAgHhHBEAgAkHUAGogAxClHQwBCyACQYCAgIB4NgJUCyACQUBrIgcgAkHoAGopAgA3AwAgAiACKQJgNwM4IAJBMGoiDSACQfgAaikCADcDACACIAIpAnA3AyggAkEgaiIOIAJB0ABqKAIANgIAIAIgAikCSDcDGCACQRBqIg8gAkHcAGooAgA2AgAgAiACKQJUNwMIIAYgCWoiA0EQaiAFNgIAIANBCGogETcDACADIBA3AwAgA0EkaiAENgIAIANBFGogAikDODcCACADQRxqIAcpAwA3AgAgA0EoaiACKQMoNwMAIANBMGogDSkDADcDACADQThqIAIpAxg3AwAgA0FAayAOKAIANgIAIANBxABqIAIpAwg3AgAgA0HMAGogDygCADYCACAGQdAAaiEGIApBAWsiCg0ACwsgACAINgIIIAAgCTYCBCAAIAE2AgAgAkGAAWokAA8LIAEgAigCeEHQtcIAEP0vAAv/BQEGfyMAQZABayIEJAACQAJAAkACQAJAAkACQAJAIAEoAgAiBSgCACIGIAUoAggiCGtBH00EQCAGIAEoAggiB0YgB0EfS3ENASABIAg2AgQgBUEgEOUtCyAEQQhqIgcgARDhICAEKAIQIgUgBCgCDCIGSw0BIARBIGogAiADIAcQmg4gBCAEKAAhNgIYIAQgBEEkaigAADYAGyAEKAIQIgMgBCgCDCICSw0CIAQtACAhAiADIAVrIQMMBwsgBEEANgJQIARCIDcCSCAEIARBIGo2AkQgBEHgAGogAiADIARBxABqEJoOIAQgBCgAYTYCGCAEIARB5ABqKAAANgAbIAQoAkwiAyAEKAJIIgJLDQIgBC0AYCECIAQoAkQhCSAEQQhqIAEQ4SAgBCgCDCIIIAQoAhAiBmsiByADSQRAIAUoAgAgBSgCCCIGa0EfTQRAIAEgBjYCBCAFQSAQ5S0LIARBCGogARDhICAEKAIMIgggBCgCECIGayEHCyADIAdLDQMgAyAGaiIFIAZJDQQgBSAISw0FIAMEQCAEKAIIIAZqIAkgA/wKAAALIAUgBCgCFEsEQCAEIAU2AhQLIAQgBTYCEAwGCyAFIAZB8M3DABCwOwALIAMgAkHwzcMAELA7AAsgAyACQfDNwwAQsDsACyAEIAM2AnggBCAHNgJ8IARBAjYCZCAEQdDOwwA2AmAgBEICNwJsIARBOzYCjAEgBEE7NgKEASAEIARBgAFqNgJoIAQgBEH8AGo2AogBIAQgBEH4AGo2AoABIARB4ABqQZjNwwAQ7ywACyAGIAVBmM3DABCxOwALIAUgCEGYzcMAELA7AAsgBEEoaiAEQRBqKQIANwMAIAQgBCkCCDcDICAEQdQAaiIHIARBIGoQ5iUgASAHENojAkACQAJAAkAgAkH/AXFBBGsOAgIAAQsgAEEFOgAADAILIAAgBCgCGDYAASAAIAI6AAAgAEEEaiAEKAAbNgAADAELIAAgAzYCBCAAQQQ6AAALIARBkAFqJAAL/wUBBn8jAEGQAWsiBCQAAkACQAJAAkACQAJAAkACQCABKAIAIgUoAgAiBiAFKAIIIghrQR9NBEAgBiABKAIIIgdGIAdBH0txDQEgASAINgIEIAVBIBDlLQsgBEEIaiIHIAEQ4SAgBCgCECIFIAQoAgwiBksNASAEQSBqIAIgAyAHEJEOIAQgBCgAITYCGCAEIARBJGooAAA2ABsgBCgCECIDIAQoAgwiAksNAiAELQAgIQIgAyAFayEDDAcLIARBADYCUCAEQiA3AkggBCAEQSBqNgJEIARB4ABqIAIgAyAEQcQAahCRDiAEIAQoAGE2AhggBCAEQeQAaigAADYAGyAEKAJMIgMgBCgCSCICSw0CIAQtAGAhAiAEKAJEIQkgBEEIaiABEOEgIAQoAgwiCCAEKAIQIgZrIgcgA0kEQCAFKAIAIAUoAggiBmtBH00EQCABIAY2AgQgBUEgEOUtCyAEQQhqIAEQ4SAgBCgCDCIIIAQoAhAiBmshBwsgAyAHSw0DIAMgBmoiBSAGSQ0EIAUgCEsNBSADBEAgBCgCCCAGaiAJIAP8CgAACyAFIAQoAhRLBEAgBCAFNgIUCyAEIAU2AhAMBgsgBSAGQfDNwwAQsDsACyADIAJB8M3DABCwOwALIAMgAkHwzcMAELA7AAsgBCADNgJ4IAQgBzYCfCAEQQI2AmQgBEHQzsMANgJgIARCAjcCbCAEQTs2AowBIARBOzYChAEgBCAEQYABajYCaCAEIARB/ABqNgKIASAEIARB+ABqNgKAASAEQeAAakGYzcMAEO8sAAsgBiAFQZjNwwAQsTsACyAFIAhBmM3DABCwOwALIARBKGogBEEQaikCADcDACAEIAQpAgg3AyAgBEHUAGoiByAEQSBqEOYlIAEgBxDaIwJAAkACQAJAIAJB/wFxQQRrDgICAAELIABBBToAAAwCCyAAIAQoAhg2AAEgACACOgAAIABBBGogBCgAGzYAAAwBCyAAIAM2AgQgAEEEOgAACyAEQZABaiQAC9sFAgd/AX4CfyABRQRAIAAoAgghB0EtIQsgBUEBagwBC0ErQYCAxAAgACgCCCIHQYCAgAFxIgEbIQsgAUEVdiAFagshCQJAIAdBgICABHFFBEBBACECDAELAkAgA0EQTwRAIAIgAxDWByEBDAELIANFBEBBACEBDAELIANBA3EhCgJAIANBBEkEQEEAIQEMAQsgA0EMcSEMQQAhAQNAIAEgAiAIaiIGLAAAQb9/SmogBkEBaiwAAEG/f0pqIAZBAmosAABBv39KaiAGQQNqLAAAQb9/SmohASAMIAhBBGoiCEcNAAsLIApFDQAgAiAIaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAlqIQkLAkAgAC8BDCIIIAlLBEACQAJAIAdBgICACHFFBEAgCCAJayEIQQAhAUEAIQkCQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgCCEJDAELIAhB/v8DcUEBdiEJCyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAJQf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBECAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQ4ioNA0EAIQEgCCAJa0H//wNxIQIDQCABQf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAgBFDQALDAMLQQEhBiAAIAcgCyACIAMQ4ioNAiAAIAQgBSAHKAIMEQYADQJBACEBIAggCWtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEBaiEBIAAgCiAHKAIQEQIARQ0ACwwCCyAHIAQgBSAKKAIMEQYADQEgACANNwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIgAxDiKg0AIAEgBCAFIAAoAgwRBgAhBgsgBguIBgIDfwF+IwBBsAFrIgMkACADQfQAaiABIAIQkw4gAygCeCEEAkAgAygCdCIFQYqAgIB4RwRAIANBLGogA0GUAWooAgA2AgAgA0EkaiADQYwBaikCADcCACADQRxqIANBhAFqKQIANwIAIAMgAykCfDcCFCADIAQ2AhAgAyAFNgIMDAELIANB9ABqIAFBfyACIARqIgEgASAESRsQtAYgA0E4aiIBIANBgAFqKQIANwMAIAMgAykCeDcDMCADKAJ0IgRBioCAgHhHBEAgA0EoaiADQZABaikCADcCACADQRhqIAEpAwA3AgAgAyADKQKIATcCICADIAMpAzA3AhAgAyAENgIMDAELIANByABqIAEpAwA3AwAgAyADKQMwNwNAIANB9ABqIANBQGtBBBDdECADKAJ8IQEgAygCeCEEAkACfiADKAJ0IgVBioCAgHhHBEAgA0GgAWogA0GQAWopAgA3AwAgAyADKQKIATcDmAEgAykCgAEMAQsgBEEBcUUNAQJAIAFBAWoiBEF/IAQbIgUgAygCQCIEKAIETQRAIAQgBCgCFEEBaiIFNgIUIAQoAggoAgggBU8EQCADQYqAgIB4NgJ0DAILIANBiICAgHg2AnQMAQsgA0H0AGogASAFEL8vCyADQQo2AqgBIANB/Ob+ADYCpAEgA0GAgICAeDYCoAEgAyABNgKcASADQQE2ApgBIANB0ABqIANB9ABqIANBmAFqEIEUIAMoAlAiBUGKgICAeEYNASADQaABaiADQewAaikCADcDACADIAMpAmQ3A5gBIAMoAlghASADKAJUIQQgAykCXAshBiADQShqIANBoAFqKQMANwIAIAMgBjcCGCADIAE2AhQgAyAENgIQIAMgBTYCDCADIAMpA5gBNwIgDAELIAMoAkAiASABKAIMQQFrNgIMIANBioCAgHg2AgwLIANBCTYChAEgA0H26f4ANgKAASADQYCAgIB4NgJ8IAMgAjYCeCADQQI2AnQgACADQQxqIANB9ABqEIEUIANBsAFqJAAL+gUBCX8jAEGQAWsiAyQAIAMgAiABayIEQQR2Igk2AmQgA0HoAGogCUEHakEDdhDSH0HAACEFAkACQCAEQQF2IgpBwP///wdxQUBrIAogBEH+AHEbIgdBwAAQ0TQEQCAHBEAgB0HAABCtNiIFRQ0CCyADKAJwIQggBSEEIAEgAkYNAgNAAkAgASgCAARAIAQgAUEIaikDADcDACAIIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwALIAZBAWohBiAEQQhqIQQgAUEQaiIBIAJHDQALDAILQeSUgAFBKSADQfgAakHIl4ABQZCVgAEQ1R4AC0HAACAHEKM9AAsgAyAEIAVrQQN1IgE2AlgCQAJAIAEgCUYEQCADKAJ0IQQgAyADKQJoNwKEASADQQA2AoABIAMgBDYCfCADIAg2AnggA0EIaiADQfgAaiICENc7IAMoAgghBkEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAykCeDcCCCABQRBqIANBgAFqIggpAgA3AgAgAUEYaiADQYgBaiILKAIANgIAIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgCjYCfCADIAU2AnggAyACENc7IAMoAgAhBUEcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgAykCeDcCCCACQRBqIAgpAgA3AgAgAkEYaiALKAIANgIAIAMgBDYCYCADIAY2AlwgAyABNgJYQQxBBBCtNiIBRQ0CIAEgCjYCCCABIAU2AgQgASACNgIAIANBATYCcCADIAE2AmwgA0EBNgJoIANBADYCgAEgA0KAgICAwAA3AnggA0EUaiICQdyRgAEgCSABIANB2ABqIANB6ABqIANB+ABqEIwTIAAgAhC3EyADQZABaiQADwsgA0IANwKEASADQoGAgIDAADcCfCADQcSRgAE2AnhBACADQdgAaiADQeQAaiADQfgAakHMkYABEK8rAAtBBEEcEKM9AAtBBEEMEKM9AAvqBAIHfwF+IwBBEGsiCSQAAkAgBCAGaiABQQN0TQRAIAUgBmogA0EDdE0EQCAGRQRADAMLA0AgBCALaiIDQQdxIQEgA0EDdiEIIAUgC2oiB0EHcSEDIAdBA3YhCgJ/IAYgC2siB0E/TQRAIAdBAUYEQEEBIQcgACAIaiIIIAgtAAAgAiAKai0AACADdkEBcSIDIAF0cjoAACADRQwCCyAJQgA3AwhBwAAgASADIAEgA0sbayIMIAcgByAMSxsiByADaiIMQQN2IAxBB3FBAEdqIgwEQCAJQQhqIAIgCmogDPwKAAALIAkgCSkDCCADrYhCf0EAIAdrQT9xrYiDIAGthiIONwMIIAEgB2oiAUEDdiABQQdxQQBHaiIBBEBBByABQQFrIgEgAUEHTxtBAWohCiAAIAhqIQEgCUEIaiEDA0AgASABLQAAIAMtAAByOgAAIANBAWohAyABQQFqIQEgCkEBayIKDQALCyAHIA57p2sMAQsgAiAKaikAACEOAkACQCADBEAgAQ0BIAAgCGogDiADrYhC//////////8AgyIONwAAQTghB0E4IA57p2sMAwsgAUUNASAAIAhqIgMgDiABrYYiDiADMQAAhDcAAEHAACABayIHIA57p2sMAgsgACAIaiIHIA4gA62IIAGthiIOIAcxAACENwAAQcAAIAEgAyABIANLG2siByAOe6drDAELIAAgCGogDjcAAEHAACEHIA5Cf4V7pwsgDWohDSAHIAtqIgsgBkkNAAsMAgtB2PiHAUE1QZD5hwEQnykAC0GM+IcBQTxByPiHARCfKQALIAlBEGokACANC/QFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB//8DTQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKMLIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL8wUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H/AU0EQCAFQThqIgRBADYCACAFQoCAgIDAADcCMCAFQTBqIgZBARCGLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOkIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENovDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCiCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/MFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB/wBNBEAgBUE4aiIEQQA2AgAgBUKAgICAwAA3AjAgBUEwaiIGQQEQhi0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDpCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDaLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAv0BQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQf//A00EQCAFQThqIgRBADYCACAFQoCAgIDAADcCMCAFQTBqIgZBARCGLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOkIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENovDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCiCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/QFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANB//8BTQRAIAVBOGoiBEEANgIAIAVCgICAgMAANwIwIAVBMGoiBkEBEIYtIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6QggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2i8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKILIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL9AUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H//wFNBEAgBUE4aiIEQQA2AgAgBUKAgICAgAE3AjAgBUEwaiIGQQEQhy0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDqCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDbLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQowsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAvyBQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQQBOBEAgBUE4aiIEQQA2AgAgBUKAgICAwAA3AjAgBUEwaiIGQQEQhi0gBUEgaiIHIAQoAgA2AgAgBUEANgIsIAVCgICAgBA3AiQgBSAFKQIwNwMYIAQgAkEIaikCADcDACAFQQA2AkAgBSADNgJEIAUgAikCADcDMCAFIAEtAGQ6AEggBUHQAGogBiAFQRhqIgJBfxDpCCAFKAJQIgNBCEYNASAAIAUpA1g3AwggAEEQaiAFQeAAaikDADcDACAAIAUoAlQ2AgQgACADNgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAgAhDaLwwFCyAFQTBqQSNBAEEBQQEQoBggBSgCNCEBIAUoAjBBAUYNASAFKAI4IgNB5NPNAEEj/AoAACAAQSM2AgwgACADNgIIIAAgATYCBCAAQQA2AgAMAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAMLIAEgBSgCOEH8u80AEP0vAAtBBEEQEKM9AAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAsgBUGAAWokAAvzBQECfyMAQYABayIFJAAgBSAEOgAXAkACQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCAAwBCwJAAkACQCADQf8BTQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhGDQEgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MBQsgBUEwakEjQQBBAUEBEKAYIAUoAjQhASAFKAIwQQFGDQEgBSgCOCIDQeTTzQBBI/wKAAAgAEEjNgIMIAAgAzYCCCAAIAE2AgQgAEEANgIADAMLIAVB4ABqIAVBKGopAwA3AwAgBUHYAGogBykDADcDACAFIAUpAxg3A1AgBUEANgJoIAVB9ABqIgIgAUHYAGoQwgYgBUEIaiAFQdAAaiAFQegAaiACEKMLIAUoAgwhAyAFKAIIIQRBEEEEEK02IgJFDQEgAiAENgIIIAJCgYCAgBA3AgAgAiADNgIMAkAgASgCUCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACABQdAAahC7IwsgAUG0yM0ANgJUIAEgAjYCUCAAQQg2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBAAwDCyABIAUoAjhB/LvNABD9LwALQQRBEBCjPQALIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQALIAVBgAFqJAAL8wUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AjQgBUG81M0ANgIwIAVCATcCPCAFQa4DNgJUIAUgBUHQAGo2AjggBSAFQRdqNgJQIABBBGogBUEwahCZDiAAQQE2AgAMAQsCQAJAAkAgA0H/AE0EQCAFQThqIgRBADYCACAFQoCAgICAATcCMCAFQTBqIgZBARCHLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOoIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENsvDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCjCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC/IFAQJ/IwBBgAFrIgUkACAFIAQ6ABcCQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgI0IAVBvNTNADYCMCAFQgE3AjwgBUGuAzYCVCAFIAVB0ABqNgI4IAUgBUEXajYCUCAAQQRqIAVBMGoQmQ4gAEEBNgIADAELAkACQAJAIANBAE4EQCAFQThqIgRBADYCACAFQoCAgICAATcCMCAFQTBqIgZBARCHLSAFQSBqIgcgBCgCADYCACAFQQA2AiwgBUKAgICAEDcCJCAFIAUpAjA3AxggBCACQQhqKQIANwMAIAVBADYCQCAFIAM2AkQgBSACKQIANwMwIAUgAS0AZDoASCAFQdAAaiAGIAVBGGoiAkF/EOoIIAUoAlAiA0EIRg0BIAAgBSkDWDcDCCAAQRBqIAVB4ABqKQMANwMAIAAgBSgCVDYCBCAAIAM2AgAgBUE8aiAFKAI0IAUoAjggBSgCMCgCEBEBACACENsvDAULIAVBMGpBI0EAQQFBARCgGCAFKAI0IQEgBSgCMEEBRg0BIAUoAjgiA0Hk080AQSP8CgAAIABBIzYCDCAAIAM2AgggACABNgIEIABBADYCAAwDCyAFQeAAaiAFQShqKQMANwMAIAVB2ABqIAcpAwA3AwAgBSAFKQMYNwNQIAVBADYCaCAFQfQAaiICIAFB2ABqEMIGIAVBCGogBUHQAGogBUHoAGogAhCjCyAFKAIMIQMgBSgCCCEEQRBBBBCtNiICRQ0BIAIgBDYCCCACQoGAgIAQNwIAIAIgAzYCDAJAIAEoAlAiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAUHQAGoQuyMLIAFBtMjNADYCVCABIAI2AlAgAEEINgIAIAVBPGogBSgCNCAFKAI4IAUoAjAoAhARAQAMAwsgASAFKAI4Qfy7zQAQ/S8AC0EEQRAQoz0ACyACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEACyAFQYABaiQAC7kKAQV/IwBBIGsiBCQAIAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAQ4oAgEBAQEBAQEBAwUBAQQBAQEBAQEBAQEBAQEBAQEBAQEBAQgBAQEBBwALIAFB3ABGDQULIAJBAXFFIAFB/wVNcg0HQRFBACABQa+wBE8bIgIgAkEIciIDIAFBC3QiAiADQQJ0QZiTigFqKAIAQQt0SRsiAyADQQRyIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQJyIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEGYk4oBaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEGYk4oBaigCAEELdCACSxsiA0ECdEGYk4oBaigCAEELdCIGIAJGIAIgBktqIANqIgZBAnRBmJOKAWoiBygCAEEVdiECQe8FIQMCQCAGQSBNBEAgBygCBEEVdiEDIAZFDQELIAdBBGsoAgBB////AHEhBQsCQCADIAJBf3NqRQ0AIAEgBWshBSADQQFrIQZBACEDA0AgAyACQYzPiQFqLQAAaiIDIAVLDQEgBiACQQFqIgJHDQALCyACQQFxRQ0HIARBDmpBADoAACAEQQA7AQwgBCABQRR2Qa7tiQFqLQAAOgAPIAQgAUEEdkEPcUGu7YkBai0AADoAEyAEIAFBCHZBD3FBru2JAWotAAA6ABIgBCABQQx2QQ9xQa7tiQFqLQAAOgARIAQgAUEQdkEPcUGu7YkBai0AADoAECABQQFyZ0ECdiICIARBDGoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQRRqIgMgAUEPcUGu7YkBai0AADoAACAAIAQpAQw3AAAgBEH9ADoAFQwICyAAQgA3AQIgAEHc4AA7AQAMCgsgAEIANwECIABB3OgBOwEADAkLIABCADcBAiAAQdzkATsBAAwICyAAQgA3AQIgAEHc3AE7AQAMBwsgAEIANwECIABB3LgBOwEADAYLIAJBgAJxRQ0BIABCADcBAiAAQdzOADsBAAwFCyACQf///wdxQYCABE8NAwsCf0EAIAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSABQcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSABQdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQeT+iQFBLEG8/4kBQdABQYyBigFB5gMQixAMAQsgAUHyhIoBQShBwoWKAUGiAkHkh4oBQakCEIsQCw0BIARBGGpBADoAACAEQQA7ARYgBCABQRR2Qa7tiQFqLQAAOgAZIAQgAUEEdkEPcUGu7YkBai0AADoAHSAEIAFBCHZBD3FBru2JAWotAAA6ABwgBCABQQx2QQ9xQa7tiQFqLQAAOgAbIAQgAUEQdkEPcUGu7YkBai0AADoAGiABQQFyZ0ECdiICIARBFmoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQR5qIgMgAUEPcUGu7YkBai0AADoAACAAIAQpARY3AAAgBEH9ADoAHwsgAEEIaiADLwEAOwAAQQoMAwsgACABNgIAQYABIQJBgQEMAgsgAEIANwECIABB3MQAOwEAC0EAIQJBAgs6AA0gACACOgAMIARBIGokAAvNBQIGfwN+IwBBgAFrIgQkACABvCEGAn9BAyABi0MAAIB/Ww0AGkECIAZBgICA/AdxIgVBgICA/AdGDQAaIAZB////A3EiCEGAgIAEciAGQQF0Qf7//wdxIAZBF3ZB/wFxIgcbIgmtIgpCAYMhCyAFRQRAQQQgCEUNARogB0GWAWshB0IBIQwgC1AMAQtCgICAECAKQgGGIAlBgICABEYiCBshCkICQgEgCBshDEHofkHpfiAIGyAHaiEHIAtQCyEFIAQgBzsBeCAEIAw3A3AgBEIBNwNoIAQgCjcDYCAEIAU6AHoCfwJAAkACQAJAAkAgBUH/AXFBAU0EQCADQf//A3EhAyAEQSBqIARB4ABqIARBD2oQ/wJB7uuJAUEBIAZBAEgiBRshB0Hu64kBQe/riQEgBRshBSAGQR92IQYgBCgCIEUNASAEQdgAaiAEQShqKAIANgIAIAQgBCkCIDcDUAwCCyAFQf8BcSIIQQJGDQNBASEFQe7riQFB7+uJASAGQQBIIgcbQe7riQFBASAHGyACGyEHQQEgBkEfdiACGyEGIAhBBEYNAiAEQQM2AiggBEHz64kBNgIkIARBAjsBICAEQSBqDAULIARB0ABqIARB4ABqIARBD2oQlAELIAUgByACGyEHQQEgBiACGyEGIAQgBCgCUCAEKAJUIAQvAVggAyAEQSBqEO0PIAQoAgQhBSAEKAIADAMLQQIhBSAEQQI7ASAgA0H//wNxRQ0BIARBATYCMCAEQQA7ASwgBEECNgIoIARBxeuJATYCJCAEQSBqDAILIARBAzYCKCAEQfDriQE2AiQgBEECOwEgQQEhB0EAIQZBASEFIARBIGoMAQtBASEFIARBATYCKCAEQfbriQE2AiQgBEEgagshAiAEIAU2AlwgBCACNgJYIAQgBjYCVCAEIAc2AlAgACAEQdAAahC1CiAEQYABaiQAC+oFAgh/AX4jAEGQAWsiBCQAIARBDGpBgAhBgAgQphQgBEHUAGogASACIAMQ2wEgBCgCXCEFIAQoAlghBgJAAkAgBCgCVCIHQZOAgIB4RwRAIAAgBCkCYCIMPgIMIAAgBTYCCCAAIAY2AgQgACAMQiCIPgIQIAAgBzYCAAwBCyAEIAU2AkQgBCAGNgJAIAQgAy0AMDYCSCABIAIoAjQRBAAhAwJAIAEgAigCJBEEACIKRQ0AIARBGGohCyAEQSRqIQZBACECAkADQAJAAkACQAJAIAMEQCACIAMoAhBPDQQgAygCBCACIAMoAgxqIgFBA3ZqLQAAQf8BcyABQQdxdkEBcQ0BCyAEIAI2AlAgBCAEQUBrIgE2AkwgBEHUAGogBEHMAGogBEEMakGo/P8AENMVIAQoAlQiBUGTgICAeEYNASAAIAQpAlg3AgQgAEEMaiAEQeAAaikCADcCACAAIAU2AgAgARC8KgwHCyAGEOY6IAQoAiRFDQQgBCgCNEEBaiIHQQN2IAdBB3FBAEdqIgEgBCgCMCIFSwRAIAEgBWshCSAEKAIoIgggAUkEQCAGIAhBAXQiBSABQcD///8DcUFAayABIAFBP3EbIgggBSAISxsQ6BkgBCgCMCEFCyAJBEAgBCgCLCAFakEAIAn8CwALIAQgATYCMAsgBCAHNgI0IAQoAhQhBSAEKAIgIgEgBCgCGEYEQCALQcD0/wAQnSgLIAQoAhwgAUECdGogBTYCACAEIAFBAWo2AiAMAQsgBEEMakEBQQAQvRILIAogAkEBaiICRw0BDAMLC0HM9v8AQSBB7Pb/ABCfKQALQbj3/wAQsjsACyAEQdQAaiICIARBDGoQ7Q5BxABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTz8CgAAIABB0Pv/ADYCCCAAIAE2AgQgAEGTgICAeDYCACAEQUBrELwqCyAEQQxqELosIARBkAFqJAAPC0EEQcQAEKM9AAvqBQIIfwF+IwBBkAFrIgQkACAEQQxqQYAIQYAIEKUUIARB1ABqIAEgAiADENsBIAQoAlwhBSAEKAJYIQYCQAJAIAQoAlQiB0GTgICAeEcEQCAAIAQpAmAiDD4CDCAAIAU2AgggACAGNgIEIAAgDEIgiD4CECAAIAc2AgAMAQsgBCAFNgJEIAQgBjYCQCAEIAMtADA2AkggASACKAI0EQQAIQMCQCABIAIoAiQRBAAiCkUNACAEQRhqIQsgBEEkaiEGQQAhAgJAA0ACQAJAAkACQCADBEAgAiADKAIQTw0EIAMoAgQgAiADKAIMaiIBQQN2ai0AAEH/AXMgAUEHcXZBAXENAQsgBCACNgJQIAQgBEFAayIBNgJMIARB1ABqIARBzABqIARBDGpBmP3/ABDTFSAEKAJUIgVBk4CAgHhGDQEgACAEKQJYNwIEIABBDGogBEHgAGopAgA3AgAgACAFNgIAIAEQvCoMBwsgBhDmOiAEKAIkRQ0EIAQoAjRBAWoiB0EDdiAHQQdxQQBHaiIBIAQoAjAiBUsEQCABIAVrIQkgBCgCKCIIIAFJBEAgBiAIQQF0IgUgAUHA////A3FBQGsgASABQT9xGyIIIAUgCEsbEOgZIAQoAjAhBQsgCQRAIAQoAiwgBWpBACAJ/AsACyAEIAE2AjALIAQgBzYCNCAENQIUIQwgBCgCICIBIAQoAhhGBEAgC0HA9P8AELMoCyAEKAIcIAFBA3RqIAw3AwAgBCABQQFqNgIgDAELIARBDGpBAUEAELwSCyAKIAJBAWoiAkcNAQwDCwtBzPb/AEEgQez2/wAQnykAC0G49/8AELI7AAsgBEHUAGoiAiAEQQxqEO4OQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQcD8/wA2AgggACABNgIEIABBk4CAgHg2AgAgBEFAaxC8KgsgBEEMahC7LCAEQZABaiQADwtBBEHEABCjPQALlQYBBH8jAEEQayICJAACQAJAAkACQAJAAkADQAJAIAIgAC0AACIDNgIMIAEgAkEMakEEELsJAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQQ1rDhwAFRUBAgMEFQUVFRUVFQYHCAkKCwwNDhAREhMUFQsgAiAALQABNgIMIAEgAkEMaiIEQQQQuwkgAiAAKAIEIgNBAEc2AgwgASAEQQQQuwkgA0UNFCABIAAoAgRBCGogACgCCBC7CSACQf8BOgAMIAEgBEEBELsJDBQLIAIgAC0AATYCDCABIAJBDGpBBBC7CQwTCyACIAAtAAE2AgwgASACQQxqQQQQuwkMEgsgAiAALQABNgIMIAEgAkEMakEEELsJDBELIAIgAC0AATYCDCABIAJBDGpBBBC7CQwQCyACIAAoAgQ2AgwgASACQQxqQQQQuwkMDwsgACgCBEEIaiABENkKDA4LIAAoAgRBCGogARDZCgwNCyAAKAIIQQhqIAEQ2QogAiAAKAIENgIMIAEgAkEMakEEELsJDAwLIAAoAgRBCGogARDZCgwLCyAAKAIEQQhqIAEQ2QoMCgsgAEEEaiABENogDAkLIAAoAgQgAiAAKAIIIgQ2AgwgASACQQxqIgVBBBC7CUEIaiAEIAEQ0CMgAiAALQABNgIMIAEgBUEEELsJDAgLIAAoAgQgARCTCSAAKAIIIQAMAQsLIAIgAC0AAToADCABIAJBDGoiA0EBELsJIAIgAC0AAjoADCABIANBARC7CQwFCyACIAAtAAE6AAwgASACQQxqIgNBARC7CSACIAAtAAI6AAwgASADQQEQuwkMBAsgAiAALQABOgAMIAEgAkEMaiIDQQEQuwkgAiAALQACOgAMIAEgA0EBELsJDAMLIAIgAC0AAToADCABIAJBDGoiA0EBELsJIAIgAC0AAjoADCABIANBARC7CQwCCyAAKAIEQQhqIAEQ2QogAiAALQABOgAMIAEgAkEMakEBELsJDAELIAAoAgRBCGogARDZCiAAKAIIQQhqIAEQ2QoLIAJBEGokAAv2BQEGfyMAQSBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAFBBAWsOAwsCAQALIABBLGogAEEk/AoAAAsgAEEsaiEGAkACQCAALQBMQQFrDgMHAgEACyAGKAIAIgQoAggNCyAEQX82AgggAEEAOgBIIAAgBEEMaiICNgI4IAAgBEEIajYCNCAAIAI2AjAgAEHIAGohBQwDCyAAQcgAaiEFAkAgAC0ASEEBaw4DBQEAAgsgACgCRCICKAIAIQQMAwsACyAAKAI4IQILIAIoAgAhBCACQQA2AgAgBEUNBSAAIAIoAgQ2AkAgACAENgI8IAAgAEE8aiICNgJECyADQRBqIAQgASACKAIEKAIYEQEAQQIhAiADKAIQIgRBAkcNAkEDIQEgBUEDOgAADAMLQYjewwAQ6CsAC0G43sMAEOgrAAsgAygCFCAAQTxqELwqQQEhASAAQQE6AEggACgCNCIFIAUoAgBBAWo2AgAgACgCLCIFIAUoAgBBAWsiBzYCAEGAASAEQQFxGyEFIAdFBEAgBhDUIgsgBCECCyAAIAE6AExBAyEEAkAgAkECRiIBDQAgBhDiIAJAIAJBAXEEQCADIAU2AhggA0GAATYCHCADIABBKGogA0EcaiADQRhqEMIjIAMoAgBBAXENBQJAIAMoAgQiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQEgAhDyHwwBCyADIAU2AhggA0GAATYCHCADQQhqIABBJGogA0EcaiADQRhqEMIjIAMoAghBAXENBAJAIAMoAgwiAkGEAUkNACACEPIfIAMoAhwiAkGEAUkNACACEPIfCyADKAIYIgJBhAFJDQAgAhDyHwsgACgCJCICQYQBTwRAIAIQ8h8LQQEhBCAAKAIoIgJBhAFJDQAgAhDyHwsgACAEOgBQIANBIGokACABDwtB5tnDAEExEJc9AAtB6N3DABDoKwALQdTbwwBBMRCXPQALxQUBB38jAEEwayIEJAACQAJAAkACQAJAAkACQCABKAIEIgUgASABKAIAQYCAgIB4RiIGGygCCCACSwRAIAYNASAEQRBqIAFBCGooAgAiBTYCACAEIAEpAgA3AwggAiAFSw0DIARBADYCECAEIAQoAgwiATYCGCAEIAI2AiQgBCAFIAJrNgIoIAQgASACQQJ0ajYCHCAEIARBCGo2AiAgBEEYahD2FSAEKAIIIQcgBCgCDCEGIAQoAhAhBQwCCwJAIAZFBEAgBCABKQIANwMYDAELIARBGGogBRDpHQsgACAEKQMYNwIAIABBCGpBADYCAAwGCyAFKAIIIgEgAkkNAiAFKAIEIQggBEEYaiABIAJrIgVBAEEEQQQQoBggBCgCHCEHIAQoAhhBAUYNAyAEKAIgIQYgBUECdCIBRQ0AIAYgCCACQQJ0aiAB/AoAAAsgA0H/AXFFIAVFcg0DIAZBBGshCCAFQQJ0IQEgA0EfcSEJQQAhAkEAIANrQR9xIQMDQCABIAhqIgogAiAKKAIAIgIgCXZyNgIAIAIgA3QhAiABQQRrIgENAAsMAwsgAiAFQaCiiAEQsDsACyACIAFBxKWIARCvOwALIAcgBCgCIEGEpYgBEP0vAAsgBCAFNgIgIAQgBzYCGCAEIAY2AhwCQCAFRQ0AIAYgBUECdCICakEEayIBRQ0AIAEoAgANACACIQEgBkEEayEDIAVB/////wNxIQICQANAIAFFBEBBACEBDAILIAJBAWshAiABIANqIAFBBGshASgCAEUNAAsgAkEBaiIBIAVLDQELIAQgATYCICABIQULAkAgBSAHQQJ2Tw0AIAQgBEEYaiAFQQRBBBD0FCAEKAIAIgFBgYCAgHhGDQAgASAEKAIEQdSliAEQ/S8ACyAAIAQpAhg3AgAgAEEIaiAEQSBqKAIANgIACyAEQTBqJAALuAsCDH8EfiMAQTBrIggkACAIIAI6AAcCQAJAAn8CQCACQf8BcSIHQQdHBEAgB0EBRw0BIAhBBzoABwsCQAJAIAEoAgxFDQAgAUEQaiAIQQdqEOwMIRMgASgCACIHQQxrIQogASgCBCIJIBOncSECIBNCGYhC/wCDQoGChIiQoMCAAX4hFQNAIAIgB2opAAAiFCAVhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAKQQAgE3qnQQN2IAJqIAlxayILQQxsai0AAEEHRg0EIBNCAX0gE4MiE1BFDQALCyAUIBRCAYaDQoCBgoSIkKDAgH+DUEUNASACIAxBCGoiDGogCXEhAgwACwALQaytzgBBJUHUrc4AEMskAAsgByALQQxsagwBCyAIQQhqIQkjAEEQayIKJAAgCiACIgc6AA8gAUEQaiIOIApBD2oQ7AwhFCABKAIAIgxBDGshDyABKAIEIg0gFKdxIQsgFEIZiEL/AINCgYKEiJCgwIABfiEWIAdB/wFxIRACQAJAA0ACQCALIAxqKQAAIhUgFoUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgD0EAIBN6p0EDdiALaiANcWsiEUEMbGotAAAgEEYNAiATQgF9IBODIhNQRQ0ACwsgFSAVQgGGg0KAgYKEiJCgwIB/g1BFDQIgCyASQQhqIhJqIA1xIQsMAQsLIAkgATYCBCAJIAwgEUEMbGo2AgBBCSEHDAELIAEoAghFBEAgCiABIA4QqQggCi0ADyEHCyAJIAE2AgggCSAUNwMACyAJIAc6AAwgCkEQaiQAIAgoAggiDCAILQAUIg1BCUYNABogCCgCECAIKAIMIQ8gASgCICIKIAooAgAiB0EBajYCACAHQQBIDQIjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhBB9ABxDQMgEEGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAlBBGogB0EQahCZDiAJQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCUHUq84ANgIIIAkgAjYCBCAJQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCUE1NgIMIAkgCzYCCCAJIAI2AgQgCUEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAJQQRqIAdBEGoQmQ4gCUEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALIAgoAhAhAiAIKAIMIQcgCCgCCCIJQQhHBEAgACAIKQIUNwIMIABBFGogCEEcaigCADYCACAAIAI2AgggACAHNgIEIAAgCTYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAggAjYCECAIIAc2AgwgCCANOgAIIAytIA+tQiCGhCAIQQhqEPoSCyICQQhrKAIAIQcgAkEEaygCACECIAhBKGogA0EIaikCADcDACAIIAMpAgA3AyAgCEEIaiAHIAhBIGogBiAEIAVBAXEbIAIoAgwRBQAgCCgCCCICQQhHBEAgACAIKQIMNwIEIABBFGogCEEcaigCADYCACAAQQxqIAhBFGopAgA3AgAgACACNgIADAELIAEgCC0ABzoAJCAAQQg2AgALIAhBMGokAA8LAAuYDgIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgsgE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogC3FrIgpBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgDEEIaiIMaiALcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIApBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCzoADyABQRBqIg8gB0EPahDsDCEUIAEoAgAiDUEMayEQIAEoAgQiDiAUp3EhCiAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEQJAAkADQAJAIAogDWopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAQQQAgE3qnQQN2IApqIA5xayISQQxsai0AACARRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAKIAxBCGoiDGogDnEhCgwBCwsgCCABNgIEIAggDSASQQxsajYCAEEJIQsMAQsgASgCCEUEQCAHIAEgDxCoCCAHLQAPIQsLIAggATYCCCAIIBQ3AwALIAggCzoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgsgCygCACIHQQFqNgIAIAdBAEgNAiMAQeAAayIKJAAgCiALNgIEAkACQAJAAkAgCAJ/AkACQAJAIAJB/wFxQQRrDgUBAAAAAgALIwBBMGsiByQAIAcgAjoADiAHIAs2AggCQAJAAkACQAJAAkACQCACQf8BcSIMQQdNBEBBASAMdCIRQfQAcQ0DIBFBggFxDQIgDEUNAQsgByACOgAPIAdBAjYCFCAHQcy9zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EPajYCKCAIQQRqIAdBEGoQmQ4gCEEBNgIADAMLIAtBCGoQ3iUhDEHAAEEIEK02IgJFDQMgAiAMNgI4IAJCADcDMCACQQA2AiAgAkEANgIAIAhBnKzOADYCCCAIIAI2AgQgCEEINgIADAILIAdBEGpBNUEAQQFBARCgGCAHKAIUIQIgBygCEEEBRg0DIAcoAhgiDEGEvc4AQTX8CgAAIAhBNTYCDCAIIAw2AgggCCACNgIEIAhBADYCAAwBCyAHQQI2AhQgB0H0vM4ANgIQIAdCATcCHCAHQa4DNgIsIAcgB0EoajYCGCAHIAdBDmo2AiggCEEEaiAHQRBqEJkOIAhBADYCAAsgCyALKAIAIgJBAWs2AgAgAkEBRgRAIAdBCGoQ2SELIAdBMGokAAwCC0EIQcAAEKM9AAsgAiAHKAIYQdinzgAQ/S8ACwwDCyAKQQA2AlwgCkKAgICAEDcCVCAKQTBqIApB1ABqEOcVIApBIGpCADcDACAKQShqQgA3AwAgCkEYaiAKQThqKQMANwMAIAogCikDMDcDEEHwAEEIEK02IgJFDQMgAkIANwMAIAJBCGogCkEIakEo/AoAACACQThqQgA3AwAgAkIANwMwIAJBQGtCgICAgBA3AwAgAkHIAGpBAEEh/AsAQci+zgAMAQtBGEEEEK02IgJFDQMgAkIANwIIIAJBATYCBCACQYjTzAA2AgAgAkEQakIANwIAQey+zgALNgIIIAggAjYCBCAIQQg2AgAgCyALKAIAIgJBAWs2AgAgAkEBRw0AIApBBGoQ2SELIApB4ABqJAAMAgtBCEHwABCjPQALQQRBGBCjPQALIAkoAhAhAiAJKAIMIQggCSgCCCILQQhHBEAgACAJKQIUNwIMIABBFGogCUEcaigCADYCACAAIAI2AgggACAINgIEIAAgCzYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAkgAjYCECAJIAg2AgwgCSAOOgAIIA2tIBCtQiCGhCAJQQhqEPoSCyICQQhrKAIAIQggAkEEaygCACECIAlBKGogA0EIaikCADcDACAJIAMpAgA3AyAgCUEIaiAIIAlBIGogBiAEIAVBAXEbIAIoAgwRBQAgCSgCCCICQQhHBEAgACAJKQIMNwIEIABBFGogCUEcaigCADYCACAAQQxqIAlBFGopAgA3AgAgACACNgIADAELIAEgCS0ABzoAJCAAQQg2AgALIAlBMGokAA8LAAveDAIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgogE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogCnFrIgxBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgC0EIaiILaiAKcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIAxBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCjoADyABQRBqIg4gB0EPahDsDCEUIAEoAgAiC0EMayEPIAEoAgQiDSAUp3EhDCAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEAJAAkADQAJAIAsgDGopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAPQQAgE3qnQQN2IAxqIA1xayIRQQxsai0AACAQRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAMIBJBCGoiEmogDXEhDAwBCwsgCCABNgIEIAggCyARQQxsajYCAEEJIQoMAQsgASgCCEUEQCAHIAEgDhCqCCAHLQAPIQoLIAggATYCCCAIIBQ3AwALIAggCjoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgogCigCACIHQQFqNgIAIAdBAEgNAiMAQRBrIgwkACAMIAo2AgwCQAJAAkAgAkH/AXFBAkYEQEHIAEEIEK02IgJFDQIgAkEANgJAIAJBAToAPCACQQA2AjggAkIANwMwIAJBADYCECACQgA3AwAgCEHcvc4ANgIIIAggAjYCBCAIQQg2AgAgCiAKKAIAIgJBAWs2AgAgAkEBRw0BIAxBDGoQ2SEMAQsjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhFB9ABxDQMgEUGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEHQqc4ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCEE1NgIMIAggCzYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALCyAMQRBqJAAMAQtBCEHIABCjPQALIAkoAhAhAiAJKAIMIQggCSgCCCIKQQhHBEAgACAJKQIUNwIMIABBFGogCUEcaigCADYCACAAIAI2AgggACAINgIEIAAgCjYCACADQQxqIAMoAgQgAygCCCADKAIAKAIQEQEADAILIAkgAjYCECAJIAg2AgwgCSAOOgAIIA2tIBCtQiCGhCAJQQhqEPoSCyICQQhrKAIAIQggAkEEaygCACECIAlBKGogA0EIaikCADcDACAJIAMpAgA3AyAgCUEIaiAIIAlBIGogBiAEIAVBAXEbIAIoAgwRBQAgCSgCCCICQQhHBEAgACAJKQIMNwIEIABBFGogCUEcaigCADYCACAAQQxqIAlBFGopAgA3AgAgACACNgIADAELIAEgCS0ABzoAJCAAQQg2AgALIAlBMGokAA8LAAvUDAIMfwR+IwBBMGsiCSQAIAkgAjoABwJAAkACfwJAIAJB/wFxIghBB0cEQCAIQQFHDQEgCUEHOgAHCwJAAkAgASgCDEUNACABQRBqIAlBB2oQ7AwhEyABKAIAIghBDGshByABKAIEIgogE6dxIQIgE0IZiEL/AINCgYKEiJCgwIABfiEVA0AgAiAIaikAACIUIBWFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIAdBACATeqdBA3YgAmogCnFrIgxBDGxqLQAAQQdGDQQgE0IBfSATgyITUEUNAAsLIBQgFEIBhoNCgIGChIiQoMCAf4NQRQ0BIAIgC0EIaiILaiAKcSECDAALAAtBrK3OAEElQdStzgAQyyQACyAIIAxBDGxqDAELIAlBCGohCCMAQRBrIgckACAHIAIiCjoADyABQRBqIg4gB0EPahDsDCEUIAEoAgAiC0EMayEPIAEoAgQiDSAUp3EhDCAUQhmIQv8Ag0KBgoSIkKDAgAF+IRYgAkH/AXEhEAJAAkADQAJAIAsgDGopAAAiFSAWhSITQn+FIBNCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiE1BFBEADQCAPQQAgE3qnQQN2IAxqIA1xayIRQQxsai0AACAQRg0CIBNCAX0gE4MiE1BFDQALCyAVIBVCAYaDQoCBgoSIkKDAgH+DUEUNAiAMIBJBCGoiEmogDXEhDAwBCwsgCCABNgIEIAggCyARQQxsajYCAEEJIQoMAQsgASgCCEUEQCAHIAEgDhCsCCAHLQAPIQoLIAggATYCCCAIIBQ3AwALIAggCjoADCAHQRBqJAAgCSgCCCINIAktABQiDkEJRg0AGiAJKAIQIAkoAgwhECABKAIgIgogCigCACIHQQFqNgIAIAdBAEgNAiMAQRBrIgwkACAMIAo2AgwCQAJAAkAgAkH/AXFBCEYEQEEYQQQQrTYiAkUNAiACQgA3AgggAkEBNgIEIAJBiNPMADYCACAIQZC/zgA2AgggCCACNgIEIAhBCDYCACACQRBqQgA3AgAgCiAKKAIAIgJBAWs2AgAgAkEBRw0BIAxBDGoQ2SEMAQsjAEEwayIHJAAgByACOgAOIAcgCjYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgtBB00EQEEBIAt0IhFB9ABxDQMgEUGCAXENAiALRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgCkEIahDeJSELQcAAQQgQrTYiAkUNAyACIAs2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEGMq84ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCILQYS9zgBBNfwKAAAgCEE1NgIMIAggCzYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyAKIAooAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALCyAMQRBqJAAMAQtBBEEYEKM9AAsgCSgCECECIAkoAgwhCCAJKAIIIgpBCEcEQCAAIAkpAhQ3AgwgAEEUaiAJQRxqKAIANgIAIAAgAjYCCCAAIAg2AgQgACAKNgIAIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgCSACNgIQIAkgCDYCDCAJIA46AAggDa0gEK1CIIaEIAlBCGoQ+hILIgJBCGsoAgAhCCACQQRrKAIAIQIgCUEoaiADQQhqKQIANwMAIAkgAykCADcDICAJQQhqIAggCUEgaiAGIAQgBUEBcRsgAigCDBEFACAJKAIIIgJBCEcEQCAAIAkpAgw3AgQgAEEUaiAJQRxqKAIANgIAIABBDGogCUEUaikCADcCACAAIAI2AgAMAQsgASAJLQAHOgAkIABBCDYCAAsgCUEwaiQADwsAC4MOAgx/BH4jAEEwayIJJAAgCSACOgAHAkACQAJ/AkAgAkH/AXEiCEEHRwRAIAhBAUcNASAJQQc6AAcLAkACQCABKAIMRQ0AIAFBEGogCUEHahDsDCETIAEoAgAiCEEMayEHIAEoAgQiCyATp3EhAiATQhmIQv8Ag0KBgoSIkKDAgAF+IRUDQCACIAhqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgB0EAIBN6p0EDdiACaiALcWsiCkEMbGotAABBB0YNBCATQgF9IBODIhNQRQ0ACwsgFCAUQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAMQQhqIgxqIAtxIQIMAAsAC0Gsrc4AQSVB1K3OABDLJAALIAggCkEMbGoMAQsgCUEIaiEIIwBBEGsiByQAIAcgAiILOgAPIAFBEGoiDyAHQQ9qEOwMIRQgASgCACINQQxrIRAgASgCBCIOIBSncSEKIBRCGYhC/wCDQoGChIiQoMCAAX4hFiACQf8BcSERAkACQANAAkAgCiANaikAACIVIBaFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIBBBACATeqdBA3YgCmogDnFrIhJBDGxqLQAAIBFGDQIgE0IBfSATgyITUEUNAAsLIBUgFUIBhoNCgIGChIiQoMCAf4NQRQ0CIAogDEEIaiIMaiAOcSEKDAELCyAIIAE2AgQgCCANIBJBDGxqNgIAQQkhCwwBCyABKAIIRQRAIAcgASAPEKcIIActAA8hCwsgCCABNgIIIAggFDcDAAsgCCALOgAMIAdBEGokACAJKAIIIg0gCS0AFCIOQQlGDQAaIAkoAhAgCSgCDCEQIAEoAiAiCyALKAIAIgdBAWo2AgAgB0EASA0CIwBB4ABrIgokACAKIAs2AggCQAJAAkACQCAIAn8CQAJAAkAgAkH/AXFBBGsOBQEAAAACAAsjAEEwayIHJAAgByACOgAOIAcgCzYCCAJAAkACQAJAAkACQAJAIAJB/wFxIgxBB00EQEEBIAx0IhFB9ABxDQMgEUGCAXENAiAMRQ0BCyAHIAI6AA8gB0ECNgIUIAdBzL3OADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ9qNgIoIAhBBGogB0EQahCZDiAIQQE2AgAMAwsgC0EIahDeJSEMQcAAQQgQrTYiAkUNAyACIAw2AjggAkIANwMwIAJBADYCICACQQA2AgAgCEHEqs4ANgIIIAggAjYCBCAIQQg2AgAMAgsgB0EQakE1QQBBAUEBEKAYIAcoAhQhAiAHKAIQQQFGDQMgBygCGCIMQYS9zgBBNfwKAAAgCEE1NgIMIAggDDYCCCAIIAI2AgQgCEEANgIADAELIAdBAjYCFCAHQfS8zgA2AhAgB0IBNwIcIAdBrgM2AiwgByAHQShqNgIYIAcgB0EOajYCKCAIQQRqIAdBEGoQmQ4gCEEANgIACyALIAsoAgAiAkEBazYCACACQQFGBEAgB0EIahDZIQsgB0EwaiQADAILQQhBwAAQoz0ACyACIAcoAhhB2KfOABD9LwALDAMLIApBADYCXCAKQoCAgIAQNwJUIApBMGogCkHUAGoQ5xUgCkEgakIANwIAIApBKGpCADcCACAKQRhqIApBOGopAwA3AgAgCiAKKQMwNwIQQeAAQQgQrTYiAkUNAyACQQA2AgAgAkEEaiAKQQxqQST8CgAAIAJCgICAgBA3AyggAkEwakEAQSn8CwBBgL7OAAwBC0EYQQQQrTYiAkUNAyACQgA3AgggAkEBNgIEIAJBiNPMADYCACACQRBqQgA3AgBBpL7OAAs2AgggCCACNgIEIAhBCDYCACALIAsoAgAiAkEBazYCACACQQFHDQAgCkEIahDZIQsgCkHgAGokAAwCC0EIQeAAEKM9AAtBBEEYEKM9AAsgCSgCECECIAkoAgwhCCAJKAIIIgtBCEcEQCAAIAkpAhQ3AgwgAEEUaiAJQRxqKAIANgIAIAAgAjYCCCAAIAg2AgQgACALNgIAIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgCSACNgIQIAkgCDYCDCAJIA46AAggDa0gEK1CIIaEIAlBCGoQ+hILIgJBCGsoAgAhCCACQQRrKAIAIQIgCUEoaiADQQhqKQIANwMAIAkgAykCADcDICAJQQhqIAggCUEgaiAGIAQgBUEBcRsgAigCDBEFACAJKAIIIgJBCEcEQCAAIAkpAgw3AgQgAEEUaiAJQRxqKAIANgIAIABBDGogCUEUaikCADcCACAAIAI2AgAMAQsgASAJLQAHOgAkIABBCDYCAAsgCUEwaiQADwsAC9QMAgx/BH4jAEEwayIJJAAgCSACOgAHAkACQAJ/AkAgAkH/AXEiCEEHRwRAIAhBAUcNASAJQQc6AAcLAkACQCABKAIMRQ0AIAFBEGogCUEHahDsDCETIAEoAgAiCEEMayEHIAEoAgQiCiATp3EhAiATQhmIQv8Ag0KBgoSIkKDAgAF+IRUDQCACIAhqKQAAIhQgFYUiE0J/hSATQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhNQRQRAA0AgB0EAIBN6p0EDdiACaiAKcWsiDEEMbGotAABBB0YNBCATQgF9IBODIhNQRQ0ACwsgFCAUQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiALQQhqIgtqIApxIQIMAAsAC0Gsrc4AQSVB1K3OABDLJAALIAggDEEMbGoMAQsgCUEIaiEIIwBBEGsiByQAIAcgAiIKOgAPIAFBEGoiDiAHQQ9qEOwMIRQgASgCACILQQxrIQ8gASgCBCINIBSncSEMIBRCGYhC/wCDQoGChIiQoMCAAX4hFiACQf8BcSEQAkACQANAAkAgCyAMaikAACIVIBaFIhNCf4UgE0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyITUEUEQANAIA9BACATeqdBA3YgDGogDXFrIhFBDGxqLQAAIBBGDQIgE0IBfSATgyITUEUNAAsLIBUgFUIBhoNCgIGChIiQoMCAf4NQRQ0CIAwgEkEIaiISaiANcSEMDAELCyAIIAE2AgQgCCALIBFBDGxqNgIAQQkhCgwBCyABKAIIRQRAIAcgASAOEKsIIActAA8hCgsgCCABNgIIIAggFDcDAAsgCCAKOgAMIAdBEGokACAJKAIIIg0gCS0AFCIOQQlGDQAaIAkoAhAgCSgCDCEQIAEoAiAiCiAKKAIAIgdBAWo2AgAgB0EASA0CIwBBEGsiDCQAIAwgCjYCDAJAAkACQCACQf8BcUEIRgRAQRhBBBCtNiICRQ0CIAJCADcCCCACQQE2AgQgAkGI08wANgIAIAhBtL/OADYCCCAIIAI2AgQgCEEINgIAIAJBEGpCADcCACAKIAooAgAiAkEBazYCACACQQFHDQEgDEEMahDZIQwBCyMAQTBrIgckACAHIAI6AA4gByAKNgIIAkACQAJAAkACQAJAAkAgAkH/AXEiC0EHTQRAQQEgC3QiEUH0AHENAyARQYIBcQ0CIAtFDQELIAcgAjoADyAHQQI2AhQgB0HMvc4ANgIQIAdCATcCHCAHQa4DNgIsIAcgB0EoajYCGCAHIAdBD2o2AiggCEEEaiAHQRBqEJkOIAhBATYCAAwDCyAKQQhqEN4lIQtBwABBCBCtNiICRQ0DIAIgCzYCOCACQgA3AzAgAkEANgIgIAJBADYCACAIQeSszgA2AgggCCACNgIEIAhBCDYCAAwCCyAHQRBqQTVBAEEBQQEQoBggBygCFCECIAcoAhBBAUYNAyAHKAIYIgtBhL3OAEE1/AoAACAIQTU2AgwgCCALNgIIIAggAjYCBCAIQQA2AgAMAQsgB0ECNgIUIAdB9LzOADYCECAHQgE3AhwgB0GuAzYCLCAHIAdBKGo2AhggByAHQQ5qNgIoIAhBBGogB0EQahCZDiAIQQA2AgALIAogCigCACICQQFrNgIAIAJBAUYEQCAHQQhqENkhCyAHQTBqJAAMAgtBCEHAABCjPQALIAIgBygCGEHYp84AEP0vAAsLIAxBEGokAAwBC0EEQRgQoz0ACyAJKAIQIQIgCSgCDCEIIAkoAggiCkEIRwRAIAAgCSkCFDcCDCAAQRRqIAlBHGooAgA2AgAgACACNgIIIAAgCDYCBCAAIAo2AgAgA0EMaiADKAIEIAMoAgggAygCACgCEBEBAAwCCyAJIAI2AhAgCSAINgIMIAkgDjoACCANrSAQrUIghoQgCUEIahD6EgsiAkEIaygCACEIIAJBBGsoAgAhAiAJQShqIANBCGopAgA3AwAgCSADKQIANwMgIAlBCGogCCAJQSBqIAYgBCAFQQFxGyACKAIMEQUAIAkoAggiAkEIRwRAIAAgCSkCDDcCBCAAQRRqIAlBHGooAgA2AgAgAEEMaiAJQRRqKQIANwIAIAAgAjYCAAwBCyABIAktAAc6ACQgAEEINgIACyAJQTBqJAAPCwALiQYBAX8jAEEwayIFJAAgBSACNwMAAkACQAJAAkACQAJAAkACQAJAAkACQCAERQRAIANB/wFxQQFrDgICAwELIANB/wFxQQFrDgIEBQMLIAVBATYCHCAFQfSuhgE2AhggBUIBNwIkIAVB7gY2AgwgBSAFQQhqNgIgIAUgBTYCCAwJCyABQYCABE8NBCAFIAE7ARQgBUEANgIQIAVB7gY2AgwgBUEBNgIsIAVBjK+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBAjYCJCAFIAU2AgggBSAFQQhqNgIgDAgLIAFBgIAETw0EIAUgATsBFCAFQQA2AhAgBUHuBjYCDCAFQQE2AiwgBUG0r4YBNgIoIAVBATYCHCAFQfSuhgE2AhggBUECNgIkIAUgBTYCCCAFIAVBCGo2AiAMBwsgBUEBNgIsIAVBzK+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBATYCJCAFQe4GNgIMIAUgBUEIajYCICAFIAU2AggMBgsgAUEBaiIBQYCABE8NAyAFIAE7ARQgBUEANgIQIAVB7gY2AgwgBUEBNgIsIAVB9K+GATYCKCAFQQE2AhwgBUH0roYBNgIYIAVBAjYCJCAFIAU2AgggBSAFQQhqNgIgDAULIAFBAWoiAUGAgARPDQMgBSABOwEUIAVBADYCECAFQe4GNgIMIAVBATYCLCAFQZywhgE2AiggBUEBNgIcIAVB9K6GATYCGCAFQQI2AiQgBSAFNgIIIAUgBUEIajYCIAwECyAFQQA2AiggBUEBNgIcIAVB3K6GATYCGCAFQgQ3AiAgBUEYakH8roYBEO8sAAsgBUEANgIoIAVBATYCHCAFQdyuhgE2AhggBUIENwIgIAVBGGpBpK+GARDvLAALIAVBADYCKCAFQQE2AhwgBUHcroYBNgIYIAVCBDcCICAFQRhqQeSvhgEQ7ywACyAFQQA2AiggBUEBNgIcIAVB3K6GATYCGCAFQgQ3AiAgBUEYakGMsIYBEO8sAAsgACAFQRhqEO48IAVBMGokAAvQBQIGfwJ+AkAgAkUNACACQQdrIgNBACACIANPGyEHIAFBA2pBfHEgAWshCEEAIQMDQAJAAkACQCABIANqLQAAIgXAIgZBAE4EQCAIIANrQQNxDQEgAyAHTw0CA0AgASADaiIEQQRqKAIAIAQoAgByQYCBgoR4cQ0DIANBCGoiAyAHSQ0ACwwCC0KAgICAgCAhCkKAgICAECEJAkACQAJ+AkACQAJAAkACQAJAAkACQAJAIAVBlPqJAWotAABBAmsOAwABAgoLIANBAWoiBCACSQ0CQgAhCkIAIQkMCQtCACEKIANBAWoiBCACSQ0CQgAhCQwIC0IAIQogA0EBaiIEIAJJDQJCACEJDAcLIAEgBGosAABBv39KDQYMBwsgASAEaiwAACEEAkACQCAFQeABayIFBEAgBUENRgRADAIFDAMLAAsgBEFgcUGgf0YNBAwDCyAEQZ9/Sg0CDAMLIAZBH2pB/wFxQQxPBEAgBkF+cUFuRw0CIARBQEgNAwwCCyAEQUBIDQIMAQsgASAEaiwAACEEAkACQAJAAkAgBUHwAWsOBQEAAAACAAsgBkEPakH/AXFBAksgBEFATnINAwwCCyAEQfAAakH/AXFBME8NAgwBCyAEQY9/Sg0BCyACIANBAmoiBE0EQEIAIQkMBQsgASAEaiwAAEG/f0oNAkIAIQkgA0EDaiIEIAJPDQQgASAEaiwAAEFASA0FQoCAgICA4AAMAwtCgICAgIAgDAILQgAhCSADQQJqIgQgAk8NAiABIARqLAAAQb9/TA0DC0KAgICAgMAACyEKQoCAgIAQIQkLIAAgCiADrYQgCYQ3AgQgAEEBNgIADwsgBEEBaiEDDAILIANBAWohAwwBCyACIANNDQADQCABIANqLAAAQQBIDQEgAiADQQFqIgNHDQALDAILIAIgA0sNAAsLIAAgAjYCCCAAIAE2AgQgAEEANgIAC+sFAgx/AX4jAEGgAWsiAiQAAkACQAJAAkAgAS0AGEEoRgRAIAJBGGogARDvPCACKAIcRQ0BIAIgAigCGCIDQRhqIgQ2AnggAkGYAWpBhIiQIDYCACACQoSIkKDAgIGCBDcDkAEgAiACQZABaiIFNgKEASAEIAUQxAhFDQIgBRDBDCACQRBqIAMQ3DsgAigCFEUNBCACKAIQIgQoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0DIAIgAzYCMCACIAQpAgQ3AjQgAkEkaiACQTBqEOUZIAEoAiQhBiABKAIoIQggAkEIaiABEO88IAIoAgwiA0EBSwRAIAJB+ABqIAIoAggiA0HcAGoQ0wYgAygCbCEJIAMoAmghCiACQYQBaiADQcQAahC+FSAFIANB0ABqEIALIAMoAnAiBARAIAQgBCgCACIHQQFqNgIAIAdBAEgNBSADKAKEASEHIAMoAoABIQsgAygCfCEMIAMoAnghDSADKAJ0IQMLIAJB0ABqIAJBgAFqKAIANgIAIAJBOGogAkGMAWooAgA2AgAgAkHEAGogAkGYAWooAgA2AgAgAiACKQJ4NwNIIAIgCTYCWCACIAo2AlQgAiACKQKEATcDMCACIAIpApABNwI8IAIgBzYCcCACIAs2AmwgAiAMNgJoIAIgDTYCZCACIAM2AmAgAiAENgJcIAIgAkEwahCgASACKQMAIQ4gACABQRhqENMGIAAgDjcCICAAIAg2AhwgACAGNgIYIABBFGogAkEsaigCADYCACAAIAIpAiQ3AgwgARCHJyACQaABaiQADwtBASADQdz3hAEQwyEACyACQQA2AkAgAkEBNgI0IAJBvPiEATYCMCACQgQ3AjggAkEwakHE+IQBEO8sAAtBAEEAQYz3hAEQwyEACyACQgA3AjwgAkKBgICAwAA3AjQgAkG094QBNgIwIAJB+ABqIAJBhAFqIAJBMGpBvPeEARCjKwsAC0EAQQBBzPeEARDDIQAL6wUCDH8BfiMAQaABayICJAACQAJAAkACQCABLQAYQShGBEAgAkEYaiABEO88IAIoAhxFDQEgAiACKAIYIgNBGGoiBDYCeCACQZgBakGDhowYNgIAIAJCg4aMmLDgwIEDNwOQASACIAJBkAFqIgU2AoQBIAQgBRDECEUNAiAFEMEMIAJBEGogAxDcOyACKAIURQ0EIAIoAhAiBCgCACIDIAMoAgAiBkEBajYCACAGQQBIDQMgAiADNgIwIAIgBCkCBDcCNCACQSRqIAJBMGoQ4RkgASgCJCEGIAEoAighCCACQQhqIAEQ7zwgAigCDCIDQQFLBEAgAkH4AGogAigCCCIDQdwAahDTBiADKAJsIQkgAygCaCEKIAJBhAFqIANBxABqEL4VIAUgA0HQAGoQgAsgAygCcCIEBEAgBCAEKAIAIgdBAWo2AgAgB0EASA0FIAMoAoQBIQcgAygCgAEhCyADKAJ8IQwgAygCeCENIAMoAnQhAwsgAkHQAGogAkGAAWooAgA2AgAgAkE4aiACQYwBaigCADYCACACQcQAaiACQZgBaigCADYCACACIAIpAng3A0ggAiAJNgJYIAIgCjYCVCACIAIpAoQBNwMwIAIgAikCkAE3AjwgAiAHNgJwIAIgCzYCbCACIAw2AmggAiANNgJkIAIgAzYCYCACIAQ2AlwgAiACQTBqEKABIAIpAwAhDiAAIAFBGGoQ0wYgACAONwIgIAAgCDYCHCAAIAY2AhggAEEUaiACQSxqKAIANgIAIAAgAikCJDcCDCABEIcnIAJBoAFqJAAPC0EBIANB3PeEARDDIQALIAJBADYCQCACQQE2AjQgAkG8+IQBNgIwIAJCBDcCOCACQTBqQcT4hAEQ7ywAC0EAQQBBjPeEARDDIQALIAJCADcCPCACQoGAgIDAADcCNCACQbT3hAE2AjAgAkH4AGogAkGEAWogAkEwakG894QBEKMrCwALQQBBAEHM94QBEMMhAAvrBQIMfwF+IwBBoAFrIgIkAAJAAkACQAJAIAEtABhBKEYEQCACQRhqIAEQ7zwgAigCHEUNASACIAIoAhgiA0EYaiIENgJ4IAJBmAFqQYWKlCg2AgAgAkKFipSo0KDBggU3A5ABIAIgAkGQAWoiBTYChAEgBCAFEMQIRQ0CIAUQwQwgAkEQaiADENw7IAIoAhRFDQQgAigCECIEKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAyACIAM2AjAgAiAEKQIENwI0IAJBJGogAkEwahDkGSABKAIkIQYgASgCKCEIIAJBCGogARDvPCACKAIMIgNBAUsEQCACQfgAaiACKAIIIgNB3ABqENMGIAMoAmwhCSADKAJoIQogAkGEAWogA0HEAGoQvhUgBSADQdAAahCACyADKAJwIgQEQCAEIAQoAgAiB0EBajYCACAHQQBIDQUgAygChAEhByADKAKAASELIAMoAnwhDCADKAJ4IQ0gAygCdCEDCyACQdAAaiACQYABaigCADYCACACQThqIAJBjAFqKAIANgIAIAJBxABqIAJBmAFqKAIANgIAIAIgAikCeDcDSCACIAk2AlggAiAKNgJUIAIgAikChAE3AzAgAiACKQKQATcCPCACIAc2AnAgAiALNgJsIAIgDDYCaCACIA02AmQgAiADNgJgIAIgBDYCXCACIAJBMGoQoAEgAikDACEOIAAgAUEYahDTBiAAIA43AiAgACAINgIcIAAgBjYCGCAAQRRqIAJBLGooAgA2AgAgACACKQIkNwIMIAEQhycgAkGgAWokAA8LQQEgA0Hc94QBEMMhAAsgAkEANgJAIAJBATYCNCACQbz4hAE2AjAgAkIENwI4IAJBMGpBxPiEARDvLAALQQBBAEGM94QBEMMhAAsgAkIANwI8IAJCgYCAgMAANwI0IAJBtPeEATYCMCACQfgAaiACQYQBaiACQTBqQbz3hAEQoysLAAtBAEEAQcz3hAEQwyEAC7gFAgZ+An8jAEHQAGsiCCQAAkAgACkDAEICUQRAIAhBQGtCADcDACAIQgA3AzggCCAAKQMQIgI3AzAgCCAAKQMIIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAggASgCACIAQQBHNgJMIAhBCGoiCSAIQcwAakEEELsJAkAgAARAIAkgASgCBCABKAIIELsJDAELIAggAS0ABDYCTCAIQQhqIAhBzABqQQQQuwkLIAgpAzggCDUCQEI4hoQiAiAIKQMghSIDQhCJIAMgCCkDEHwiA4UiBUIViSAFIAgpAxgiBCAIKQMIfCIGQiCJfCIFhSIHQhCJIAcgAyAEQg2JIAaFIgR8IgNCIIlC/wGFfCIGhSIHQhWJIAcgAyAEQhGJhSIDIAIgBYV8IgJCIIl8IgWFIgRCEIkgBCACIANCDYmFIgIgBnwiA0IgiXwiBIUiBkIViSAGIAMgAkIRiYUiAiAFfCIDQiCJfCIFhSIGQhCGIAYgAkINiSADhSICIAR8IgNCIIl8IgSFQiuIIAJCEYkgA4UiAkINiSACIAV8hSICQi+IhSACIAR8IgJCIIiFIAKFIQIMAQtBACEAIAggASgCACIJQQBHNgIIQqXGiKHInKf5SyECA0AgAiAIQQhqIABqMQAAhUKzg4CAgCB+IQIgAEEBaiIAQQRHDQALIAkEQCABKAIIIglFDQEgASgCBCEAA0AgAiAAMQAAhUKzg4CAgCB+IQIgAEEBaiEAIAlBAWsiCQ0ACwwBCyAIIAEtAAQ2AghBACEAA0AgAiAIQQhqIABqMQAAhUKzg4CAgCB+IQIgAEEBaiIAQQRHDQALCyAIQdAAaiQAIAKnQf//AXELvAUBBX8CQAJAAkACQAJAAkACQAJAIAVB+ABNBEAgBUEDbEHk2fMAai0AACIHQdEBTw0CQdABIAdrIQggB0HQAUcNAQwICyAFQfkAQdDc8wAQwyEACwJAA0AgBiAHakHg3PMAai0AACIJRQRAIAMgBUEDbEHl2fMAai0AACIIQQtrQQAgCEEMTxsiByAEIAQgB0obIgdJDQQCQAJAIAQgCEEAIAhBCkkbIAdqayIEQQBKBEAgAiAHaiEJIAMgB2shAiAAIAZqIQdBACEDA0AgAiADRg0CIAMgBmoiCiABTw0DIAMgB2ogAyAJai0AADoAACAEIANBAWoiA0cNAAsgAyAGaiEGCyABIAYgBGsiAkkNByAAIAJqIQcgASACayECAkAgCEEKaw4CCQALCyAEQQBMDQpBACEDA0AgAiADSQ0KIAMgB2ogAiADaxDGGSIIIANqIQMgBCAIayIEQQBKDQALDAoLIAIgAkGw3/MAEMMhAAsgCiABQcDf8wAQwyEACyABIAZGDQEgACAGaiAJOgAAIAcgBkEBaiIGakHQAUcNAAsgCCEGDAcLIAEgAUHQ3/MAEMMhAAsgB0HQAUGw3vMAEK87AAsgByADQdDe8wAQrzsACyACIAFB4N7zABCvOwALIAcgAhDGGRoMAQsgAyACQfDe8wAQrzsACwJAAkAgBUEDbEHm2fMAai0AACIDQdEBSQRAQdABIANrIQIgA0HQAUYEQEEAIQYMAwsgBiABIAEgBksbIQQCQANAIANB4NzzAGotAAAiBUUNAyABIARGDQEgACAGaiAFOgAAIARBAWohBCAGQQFqIQYgA0EBaiIDQdABRw0ACyACIQYMAwsgBiABQaDf8wAQwyEACyADQdABQYDf8wAQrzsACyAGDwsgBiACQZDf8wAQwyEACyAGIAhBwN7zABDDIQAL5AkCC38DfiMAQbABayIDJAAgAyACNgIAAkACQAJAAkACQAJAAkAgASgCCCIGIAJLBEACQCABKAIEIAJBAnRqIgQoAgAEQAJAAkAgASgCECIFRQ0AIAEoAhQiBkUNACACIAZPDQUgA0EEaiAFIAJBGGxqEM4VDAELIANBgICAgHg2AgQLIAEoAhwiBiABKAIMIgUoAlgiB08NBCACIAUoAlQgBkEGdGoiBigCKCIFTw0FIAYoAiQhCSAEKAIAIgYgBigCACIEQQFqNgIAIARBAEgNBiABKAIYIQFBDEEEEK02IghFBEBBBEEMEKM9AAsgCEEBOwEIIAhCgYCAgBA3AgAgA0EoaiEEIANBBGohByMAQSBrIgUkACAFIAg2AgQgBSAGNgIAIAVBCGogCSACQcACbGoiAigC0AEgAigC1AEgCEEIahDHDSAFKAIQIQwgBSgCDCENAkAgBSgCCCIJQQhHBEAgBCAFKQIUNwIUIARBHGogBUEcaigCADYCACAEIAw2AhAgBCANNgIMIAQgCTYCCCAEQgM3AwAgCCAIKAIAIgFBAWs2AgAgAUEBRgRAIAVBBGoQgiwLIAcoAgBBgICAgHhHBEAgB0EIQRgQ4B4LIAUoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAUQ3xgMAQsgBUEIaiACEOwgIAUpAwghDgJAAn4CQCAHKAIAIghBgICAgHhHBEAgBygCBCEJIAcoAggiCw0BQgAMAgsgBSkDECEQIAItABAhCEICIQ8MAgtCACAJKQMAIg8gDlENABogDyAOfachCkIBCyEPIAhBCHYhBwsgAigCvAJBCGoQ3SUhAiAEQSNqIAdBEHY6AAAgBCAHOwAhIAQgBjYCQCAEIAw2AjwgBCANNgI4IARBADYCNCAEIAE2AjAgBCALNgIsIARBADYCKCAEIAk2AiQgBCAIOgAgIARBADYCHCAEIAo2AhggBCAQNwMQIAQgDjcDCCAEIA83AwAgBCACOgBEIAUoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQgiwLIAVBIGokACADQRhqIgEgA0E4aikDADcDACADQSBqIgIgA0FAaykDADcDACADIAMpAzA3AxAgAykDKCIOQgNSDQEgACADKQMQNwMAIABBEGogAikDADcDACAAQQhqIAEpAwA3AwAMCQsgA0ECNgIsIANBsOTQADYCKCADQgE3AjQgA0E7NgIUIAMgA0EQajYCMCADIAM2AhAgAEEEaiADQShqEJkOIABBADYCAAwICyADQfAAaiICIANByABqQSj8CgAAIANBoAFqIgYgA0EYaikDADcDACADQagBaiIEIANBIGopAwA3AwAgAyADKQMQNwOYAUHIAEEIEK02IgFFDQUgASAONwMAIAEgAykDmAE3AwggAUEQaiAGKQMANwMAIAFBGGogBCkDADcDACABQSBqIAJBKPwKAABBGEEIEK02IgJFDQYgAkHA5NAANgIIIAIgATYCBCACQQg2AgAgAEHs5NAANgIIIAAgAjYCBCAAQQg2AgAMBwsgAiAGQfDj0AAQwyEACyACIAZBiOXQABDDIQALIAYgB0Hk988AEMMhAAsgAiAFQfT3zwAQwyELAAtBCEHIABCjPQALQQhBGBCjPQALIANBsAFqJAAL/QgBCX8jAEEQayIKJAACQAJAIAZBACAFa0EDcSIHayIJQQAgBiAJTxtB7AVJDQAgA0H/AUsEQEFSIQQMAgsgAkEEaiECIAUgB2pBACAGIAdPGyIJQQA6AOADQQEgBEEBaiIFIAVBAU0bQQFrIQYgCUHhA2ohBSAJQeADaiEHA0AgBgRAIAUgBDoAACAFQQFqIQUgBEEBayEEIAZBAWshBgwBBSAJQe0DaiEGQQAhBANAIAMgBEcEQCAEIAZqIAcgAi0AAGotAAA6AAAgAkEEaiECIARBAWohBAwBCwtBun8hBCABRQ0DIApBDDYCDEEAIQRBACAJa0EDcSICDQIgAEEBaiEFAkAgA0ECSQ0AIAMgAiAJaiICQZADaiIHIApBDGogBiADEJgVIghGBEBBASEEDAELIAhBAUYNACACQcQDaiIIQQYgAyAKKAIMEIE7IgwgByADIAooAgxBABD0BiIEQYh/Sw0EIAUgAUEBayINIAggCigCDCAMEPsmIgdBiH9LBEAgByEEDAULIAIgCCAKKAIMIAwgAkHsAWpBpAEQyAciBEGIf0sNBCAFIAdqIg4hCCANIAdrIgQhByAEIAMgA0EHdmpBCGpPIQxBACENIwBBQGoiBCQAAkAgA0EDSQ0AIAQgCDYCOCAEIAg2AjQgBEIANwIsIAQgByAIakEEazYCPCAHQQVJDQAgAyAGaiIIQQJrIQcgCEEBay0AACELAkAgA0EBcQRAIARBHGoiDyACIAsQhx8gBEEMaiACIActAAAQhx8gBEEsaiAPIAhBA2siBy0AABDhJSAMBEAgBCgCOCIIIAQoAiwiCzYAACAEIAQoAjAiAkEHcTYCMCAEIAggAkEDdmo2AjggBCALIAJBeHF2NgIsDAILIARBLGoQiyYMAQsgBEEMaiACIAsQhx8gBEEcaiACIActAAAQhx8LA0AgBiAHSQRAIARBLGoiAiAEQQxqIAdBAWstAAAQ4SUgAiAEQRxqIAdBAmsiBy0AABDhJSAMBEAgBCgCOCIIIAQoAiwiCzYAACAEIAQoAjAiAkEHcTYCMCAEIAggAkEDdmo2AjggBCALIAJBeHF2NgIsBSAEQSxqEIsmCwwBCwsgBEEsaiICIARBDGoQ0zUgAiAEQRxqENM1IAQgBCgCMCIHQQFqNgIwIAQgBCgCLEEBIAd0cjYCLCACEIsmIAQoAjgiAiAEKAI8Tw0AIAIgBCgCNGsgBCgCMEEAR2ohDQsgBEFAayQAIA0iBEGIf0sNBCAERQRAQQAhBAwBCyAEIA5qIAVrIgRBiH9LDQQLIARBAkkgBCADQQF2T3JFBEAgACAEOgAAIARBAWohBAwECyADQYABSw0CQbp/IQQgASADQQFqQQF2IgJNDQMgAkEBaiEEIAAgA0H/AGo6AABBACECIAMgBmpBADoAAANAIAIgA08NBCAFIAIgCWoiAEHtA2otAABBBHQgAEHuA2otAABqOgAAIAVBAWohBSACQQJqIQIMAAsACwALAAtBfyEECyAKQRBqJAAgBAv9BAEYfyMAQRBrIg8kACABIAAoAgQiCWshDCAAKAIcIQYgBEEBRyEYA0AgBiAMT0UEQCAAKAJcIAYgCWoiFCAAKALAASADEKMdQQJ0aiIFKAIAIQEgACgCZCEVIAAoAgghECAAKAIMIQ0gACgCvAEhCCAAKALEASEKIAAoAhghESAAKAK4ASEHIAAoAhAhBCAFIAY2AgBBACESIAZBfyAIQQFrdEF/cyIWayIFQQAgBSAGTRshFyAEIAxBASAHdCIFayAEIAwgBGsgBUsbIBEbIRkgBkEJaiEHIAkgDWohGiANIBBqIRtBASAKdCETIBUgBiAWcUEDdGoiDkEEaiEIQQghC0EAIQoCQANAIBNFIAEgGUlyDQEgFCAKIBIgCiASSRsiBGohBQJ/IBhFIAEgBGogDUlxRQRAIAUgASAJaiAEaiACEIAUIARqIgQgAWohBSAJDAELIBAgCSAFIAEgEGogBGogAiAbIBoQzSggBGoiBCABaiIFIA1JGwshESAFIAcgBCAHIAFrSxsgByAEIAtLIgUbIQcgBCALIAUbIQsgBCAUaiIcIAJGDQEgFSABIBZxQQN0aiEFAkACQAJAIAEgEWogBGotAAAgHC0AAEkEQCAOIAE2AgAgASAXSw0BIA9BDGohDgwFCyAIIAE2AgAgASAXTQ0CIAQhEiAFIQgMAQsgBCEKIAVBBGoiDiEFCyATQQFrIRMgBSgCACEBDAELCyAPQQxqIQgLIAhBADYCACAOQQA2AgBBwAEgC0GAA2siASABQcABTxsiBCAHIAZrQQhrIgEgASAESRsgASALQYADSxsgBmohBgwBCwsgACAMNgIcIA9BEGokAAvRCAEDfyMAQUBqIgMkACADQQxqQa24wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCwJAAkACQAJAIAEtAABBAWsOAgECAAsgA0EsaiIBQbW4wgBBBkEKQQEQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwECyADQSxqIgQQhjAjAEEgayIBJAAgAUGUv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQIgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAwsgA0EsaiIBQbu4wgBBBkEKQQIQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwDCyADQSxqIgQQhjAjAEEgayIBJAAgAUGIv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQEgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAgsgA0EsaiIBQcG4wgBBBUEKQQMQ6BwgA0EYaiACIAEQrhQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwCCyADQSxqIgQQhjAjAEEgayIBJAAgAUGbvcIAQQsQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIE2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgAhDGISADQSxqIAIQgTYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAvRCAEDfyMAQUBqIgMkACADQQxqQa24wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCwJAAkACQAJAIAEtAABBAWsOAgECAAsgA0EsaiIBQbW4wgBBBkEKQQEQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwECyADQSxqIgQQhjAjAEEgayIBJAAgAUGUv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQIgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAwsgA0EsaiIBQbu4wgBBBkEKQQIQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwDCyADQSxqIgQQhjAjAEEgayIBJAAgAUGIv8IAQQwQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQEgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAgsgA0EsaiIBQcG4wgBBBUEKQQMQ6BwgA0EYaiACIAEQrRQgAygCGCIEQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAQ2AgAgARCGMAwCCyADQSxqIgQQhjAjAEEgayIBJAAgAUGbvcIAQQsQgCAgAUEMaiACEOcnAkAgASgCDCIFQQRHBEAgBCABKQIQNwIEIARBDGogAUEYaikCADcCACAEIAU2AgAMAQsgAUEMaiACEIA2IAEoAgwiBUEERwRAIAQgASkCEDcCBCAEQQxqIAFBGGopAgA3AgAgBCAFNgIADAELIAQgAhDlKAsgARDeOyABQSBqJAAgAygCLCIBQQRGDQAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgAhDGISADQSxqIAIQgDYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAuOBQEDfyMAQeAAayIFJAAgBSACNgIEAkACQCACQYACRgRAIAVBIGogASAEQQ9xIgZBBXRqIgJBGGopAQA3AwAgBUEYaiACQRBqKQEANwMAIAVBEGogAkEIaikBADcDACAFIAIpAQA3AwggAyAGQQF0ai8BACEHIARB/wFxRQ0CIAZBAWsiBEEEdCICQYECTw0BIAVBQGsgASACQQF0aiICQRhqKQEANwMAIAVBOGogAkEQaikBADcDACAFQTBqIAJBCGopAQA3AwAgBSACKQEANwMoQQAhAgNAIAVBCGogAmoiBiAGLwEAIAVBKGogAmovAQBrOwEAIAJBAmoiAkEgRw0ACyAEQQ9NBEAgByADIARBAXRqLwEAayEHDAMLQX9BEEHQ8dEAEMMhAAsgBUEANgIoQQAgBUEEakG88dEAIAVBKGpBhPLRABCvKwALIAVBADYCOCAFQQE2AiwgBUGA8NEANgIoIAVCBDcCMCAFQShqQcDx0QAQ7ywACyAFQUBrIAFB+ANqKQEANwMAIAVBOGogAUHwA2opAQA3AwAgBUEwaiABQegDaikBADcDACAFIAEpAeADNwMoIAMvAR5BgMABbCEBIAdB//8DcUGAwAFsIQNBACECAkACQANAIAVBCGogAmoiBC8BACIHRQ0BIAVBKGogAmoiBC8BACIGRQ0CIAAgACoCACAHQQ10IANqQQ12Qfz/D3FBzIbjAGoqAgAgBkENdCABakENdkH8/w9xQcyG4wBqKgIAk5M4AgAgAEEEaiEAIAJBAmoiAkEgRw0ACyAFQeAAaiQADwsgBUEANgJIIAQgBUHIAGpB5PHRABCNKwALIAVBADYCSCAEIAVByABqQfTx0QAQjSsAC6kFAQd/IwBBMGsiBCQAIARBADYCCCAEQoCAgIDAADcCACAEQQA2AhQgBEKAgICAwAA3AgxBBCEGAkAgAwRAIAIgA0EEdGohCCABQdABaiEJA0ACQCACKAIABEAgAigCBCEGIAIoAggiByABKALYASIDIAMgB0sbIgVFBEBBACEDDAILIAEoAtQBIQpBACEDA0AgAyAKai0AACADIAZqLQAARw0CIAUgA0EBaiIDRw0ACyAFIQMMAQtB5IfOAEEgQYSIzgAQyyQACyAEKAIIIgUgBCgCAEYEQCAEQaShzgAQnSgLIAQoAgQgBUECdGogAzYCACAEIAVBAWo2AgggAigCAEUNAiAEQRhqIAIgAyACKAIIENIQIAQoAhQiAyAEKAIMRgRAIARBDGpBtKHOABCeKAsgBCgCECADQQR0aiIFIAQpAhg3AgAgBUEIaiAEQSBqKQIANwIAIAQgA0EBajYCFCABQQA2AtgBIAkgBiAHEKE2IAJBEGoiAiAIRw0ACyAEKAIEIQYgBCgCCCEFCyAEQRhqIAEgBiAFEM8RAkAgBCgCGCIDQQhHBEAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAMAQsgBEEYaiABQeAAaiAEKAIQIAQoAhQQoBAgBCgCGCIDQQhHBEAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAMAQtBCCEDCyAAIAM2AgAgBCgCFCIFBEAgBCgCECEDA0AgAygCACIABEAgA0EMaiADQQRqKAIAIANBCGooAgAgACgCEBEBAAsgA0EQaiEDIAVBAWsiBQ0ACwsgBEEMakEEQRAQ4B4gBBDpOyAEQTBqJAAPC0Gsh84AQSVB1IfOABCfKQALvQUCB38BfiMAQaABayIFJAACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCACKAIEIQYgBSACKAIIIgc2AgAgB0EBRw0BIAVB2ABqIAEgBiADEJ4BIAUoAmAhByAFKAJcIQMgBSgCWCIBQQhHBEAgACAFKQJkNwIMIABBFGogBUHsAGooAgA2AgAgACAHNgIIIAAgAzYCBCAAIAE2AgAMBwsgA0UEQEEAIQIMBgsgBUEEaiADIAcoAhARBAAQwwYCQAJAAkACQCACLQAMIglBG2sOBAEAAAIAC0GYxM8AQShB9MXPABCfKQALIAVBjAFqIAIoAhAiAUE8ahDdICAFQYABaiABQTBqEMMGIAEvAUghBiABKQMoIQwgBUHYAGoiCCABQQhqELEuIAUgDDcDeCAFIAY7AZgBIAVBEGoiBiAIIAVBBGoQpCtB0ABBCBCtNiIBRQ0EDAELIAVBjAFqIAIoAhAiAUE8ahDdICAFQYABaiABQTBqEMMGIAEvAUghBiABKQMoIQwgBUHYAGoiCCABQQhqELEuIAUgDDcDeCAFIAY7AZgBIAVBEGoiBiAIIAVBBGoQpCtB0ABBCBCtNiIBRQ0ECyABQoGAgIAQNwMAIAFBCGogBkHIAPwKAAAgAi0AHCEIIAIvARghCiACLwEaIQtBHEEEEK02IQIgBEUEQCACBEBBpMXPACEGDAYLQQRBHBCjPQALIAIEQEHMxc8AIQYMBQtBBEEcEKM9AAtBkMXPABCyOwALIAVBADYCWEEAIAVBoMXPACAFQdgAakGExs8AEK8rAAtBCEHQABCjPQALQQhB0AAQoz0ACyACIAg6ABggAiAKOwEWIAIgCzsBFCACIAc2AhAgAiADNgIMIAIgATYCBCACIAk6AAALIAAgBjYCCCAAIAI2AgQgAEEINgIACyAFQaABaiQAC7YFAgN/A34jAEGAAmsiBCQAIAEgASgCAEECRkECdGoiASgCECEFIAEoAgwhBiAEQQRqIAJBDGoQwwYgAi0AHCECAkACQAJAAkACQCADBEAgAy0AKEEiRgRAIAQtAARBIkYNAgsgBEEQaiAGIAUgBEEEaiACQQFxEJsUDAILIARB2ABqIAYgBSAEQQRqIAJBAXEQmxQgASgCAEUNAyAEQeABaiICQaiezwAQpSsgBCkD6AEhCCAEKQPgASEJIAIgBEHQAWpBGEEIQQQQnRQgBCgC5AEhAgJAIAQoAuABIgNFBEAgBDUC6AEhBwwBCyAEKQLoASEHIAJBCWoiBUUNACADQf8BIAX8CwALIAQgCDcDuAEgBCAJNwOwASAEIAc3A6gBIAQgAjYCpAEgBCADNgKgASAEQeABaiICQRBBAEEBQQEQoBggBCgC5AEhAyAEKALgAUEBRg0CIAQoAugBIgVBCGpBpNnPACkAADcAACAFQZzZzwApAAA3AAAgBCAFNgLUASAEIAM2AtABIARBEDYC2AEgBCABKAIENgLcASACIARB3AFqEKQSIARBxAFqIgEgBEGgAWogBEHQAWogAhDOCSABEIYwIARB+AFqIgEgBEG4AWopAwA3AwAgBEHwAWoiAiAEQbABaikDADcDACAEQegBaiIDIARBqAFqKQMANwMAIAQgBCkDoAE3A+ABIARB2ABqEJMnIARB8ABqIAEpAwA3AwAgBEHoAGogAikDADcDACAEQeAAaiADKQMANwMAIAQgBCkD4AE3A1gMAwsgBEEQaiAGIAUgBEEEaiACQQFxIAMpAyAgAy0AQRC5FgsgBEHYAGoiASADELEuIAAgBEEQaiABEJwlDAILIAMgBCgC6AFB5KPPABD9LwALIAAgBEHYAGpByAD8CgAACyAEQYACaiQAC5UFAQd/IwBBIGsiByQAIAMoAhwhCyAAKAIIIQYgACgCDCEIIAMQySshDCAHQf8BNgIIIAEoAoQIIQogAiABQYgI/AoAAAJAAkACQAJAAkAgDA0AIAggBmsiCEEGQT8gASgChAhBAkYbTQ0AIAUgB0EIaiAGIAggBUHYxQAQ4CUiBkGIf0sNAUEBIQkgBiAIRg0AQQAhCSAGIAhBB3ZBBGpNDQAgCkEBRgRAIAEgBSAHKAIIEJMjQQBHIQoLIAJBAEGECPwLAEELIAggBygCCCAFQYAIaiIJQdg9IAIgBSALQQdLQQF0ENoVIQYgAiAFIAcoAgggBiAJQdg9EPgBIgZBiH9LDQEgAiAFIAcoAggQ5SMhCyAEQQRqQYABIAIgBygCCCAGIAlB2D0QpAkhBgJAAkAgCkUNACABIAUgBygCCBDlIyIKIAhPDQBBAyEJIAogBiALak0gBkEMaiAIT3INAQtBACEJIAYgC2ogCEkNAwsgAiABQYgI/AoAAAsgBCAJNgIAIARBADYChAEMAgsgBCAGNgKEAQwCCyACQQE2AoQIIARBAjYCACAEIAY2AoQBIAZBiH9LDQELAkACfyAAKAIEIgYgACgCACIIRgRAIAJCADcC3CNBACEDIAJBADYC5CNBACECQQAhAEEAIQVBAAwBCyAHQQhqIAAgBiAIa0EDdSABQYgIaiACQYgIaiAEQZQBaiAEQZkCaiADKAIcIAUgBUHUAWoQ8wogBygCFCIAQYh/Sw0BIAcoAhghBSAHKAIQIQIgBygCCCEDIAcoAgwLIQEgBCAFNgKgAiAEIAI2ApABIAQgATYCjAEgBCADNgKIAQsgBCAANgKcAiAAQQAgAEGJf08bIQYLIAdBIGokACAGC6gFAQl/IwBBEGsiCiQAIApBCGogAkEIaigCADYCACAKIAIpAgA3AwACQCAJRQ0AIAEoAgQgASgCAGtBA3UiDiEMIAEoAiRBAUYEQCABKAIoIQwLA0AgDkUNASABKAIAIA9qIhFBBGovAQBFIAxBAEdxIRAgESgCACIJIQsCQCAJQQFrIg1BAksNAAJ/IA0gEGoiC0EDRgRAIAMoAgBBAWshDSACKAIAQQFrDAELIAMgC0ECdCILaigCACENIAIgC2ooAgALIRIgCSELIA0gEkYNACARIA1BA2oiCzYCAAsgDEEBayEMIAIgCyAQEOUcIAMgCSAQEOUcIA5BAWshDiAPQQhqIQ8MAAsAC0G6fyEJAkAgBUEDSQ0AIAEgACgC0BAgACgC1BAgAEG4AWogBEEDaiIDIAVBA2sgByAAKAK4EiAAKAIIEKsKIgFBiH9LBEAgASEJDAELAkAgAUEYSw0AIAAoAtwFDQBBASABIAYgBxC6DhshAQsgACgCzAUEQCAAEIoNIAAgACkD0BBCIIk3A9AQQQAhCQwBCwJAAkACQAJAAkAgAQ4CAAECCyAHQQNqIgEgBUsNBCAEIAdBDXY6AAIgBCAIIAdBA3RyOwAAIAcEQCADIAYgB/wKAAALIAFBiH9LDQMgAiAKKQMANwIAIAJBCGogCkEIaigCADYCAAwCCyAFQQNGDQMgBCAGLQAAOgADIAQgB0ENdjoAAiAEIAggB0EDdHJBAnI7AAAgAkEIaiAKQQhqKAIANgIAIAIgCikDADcCAEEEIQEMAQsgACAAKQPQEEIgiTcD0BAgBCABQQ12OgACIAQgAUEDdCAIckEEcjsAACABQQNqIQELIAAoAtAQIgAoAtwjQQJHDQAgAEEBNgLcIwsgASEJCyAKQRBqJAAgCQuMBQIFfwJ+IwBBEGsiBSQAAkACQAJAAkAgAC0AAEECTwRAIAINASAAKQMIIQggAC0AHCECDAILIABBCGohBAJAIAIEQCACQQF0IQIgAEEgaiEGA0AgACgCdCEDAkACQCABMgEAIgggACkDYFIEQCADQQdLBEAgBBC9DQsgACAINwNgIABBATYCdAwBCyAAIANBAWoiAzYCdCADQQhLDQELIAAoAnAiA0EHSw0DIAYgA0EDdGogCDcDACAAIAAoAnBBAWoiAzYCcCADQQhHDQAgBBDKJwsgAUECaiEBIAJBAmsiAg0ACwsgACgCdCICIAAoAngiA3IgACgCcCIBckUNBAJAIAMNACABIAJHBEAgAkUgAXINAQwFCyACDQQLIAFBAWtBB0kEQCAAQSBqIQIDQCACIAFBA3RqQgA3AwAgACAAKAJwQQFqIgE2AnAgAUEISQ0ACyAAKAJ4IQMLIAAgASADajYCeCAEQQEQ+gsgAEEANgJ0DAQLIANBCEGUi88AEMMhAAsgAC0AASEDIAJBAXQhBiAAQRBqIQcgACkDCCEIIAAtABwhAgNAIAAgAiADaiIEOgAcIAAgATIBACIJIAKthiAIhCIINwMIAkAgBEH/AXFBwABJBEAgBCECDAELIAUgCDcDCCAHIAVBCGpBCBChNiAAIARBQGoiAjoAHCAAIAkgAyACayIErYhCACAEQf8BcUHAAEkbIgg3AwgLIAFBAmohASAGQQJrIgYNAAsLIAUgCDcDCCACQfgBcUEDdiACQQdxQQBHaiIBQQlJBEAgAEEQaiAFQQhqIAEQoTYgAEEAOgAcIABCADcDCAwCCyABQQhBkInPABCwOwALIAQQvQ0LIAVBEGokAAu2HgQNfwN+AnwBfSMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiENIAdBlAFqIQ4jAEHwAWsiBSQAIAFBDGoQ2zwhBCAFQRBqIAEQkjYQ7iUgBEECdCIDIQkCQAJ/AkACQAJAAkAgA0E8cSICBEAgAyACa0FAayIJIANJDQELQcAAIQsgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiC0UNAQsgBSALNgIwIAUgCTYCLCAFQcAANgIoIAMEQCALQQAgA/wLAAsgBSAENgI4IAUgAzYCNCAFKAIQRQ0DIAUoAiQgBSgCIEYNBCAFQcgAaiAFQRBqEMg0IAVB6ABqIQggDigCBCEJIA4oAgAhBCABKAIQIQMDQAJAIAUpA3AiE1BFBEAgBSkDeCESDAELA0ACfgJAIAUpA1giEkIDUgRAAkACQAJAIBJCAlENACAFIBJQrUIBhjcDWCASp0EBcUUNACAFIAUpA2A3A8gBDAELIAUoAmhFDQEgBUHAAWogCBC2KiAFKQPAASESCyASQgBSDQILIAVCAzcDWAsgBSkDSCISQgJRDQkgBUIANwNIIAUpA1AMAQsgBSkDyAELIRMgEqdBAXFFDQcgBSAFKQN4QkB9IhI3A3ggBSATNwNwIBNQDQALCyAFIBNCASATeiIUhoU3A3AgBSADIBSnIBKnakECdCICaioCACIXOAKQASAEKwMAIBe7ohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgDigCCCEBIAVBzJH/ADYCqAEgBUIENwK0ASAFQYUMNgLcASAFQfQLNgLUASAFIAE2AtABIAVBuwc2AswBIAUgCTYCyAEgBUHMATYCxAEgBUH4kf8ANgLAASAFIAVBwAFqNgKwASAFIAVBkAFqNgLYASAFQQQ2AqwBIAVBmAFqIAVBqAFqEJkOIAVBiAFqIAVBpAFqKAIANgIAIAUgBSkCnAE3A4ABIAUoApgBIQhBgoCAgHghCgwHCyAFQcABaiAVqiIBIAktAAAQ6g8gBSgCwAEiCkGTgICAeEcEQCAFQYgBaiAFQdABaigCADYCACAFIAUpAsgBNwOAASAFKALEASEIDAcFIAIgC2ogATYCAAwBCwALAAtBwAAgCRCjPQALQdyL/wBBKSAFQcgAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgDigCBCEDIA4oAgAhAiABKAIQIQhBACEJA0AgBSAIKgIAIhc4ApQBAkACfyACKwMAIBe7ohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgDigCCCEBIAVBzJH/ADYCwAEgBUIENwLMASAFQYUMNgJkIAVB9As2AlwgBSABNgJYIAVBuwc2AlQgBSADNgJQIAVBzAE2AkwgBUH4kf8ANgJIIAUgBUHIAGo2AsgBIAUgBUGUAWo2AmAgBUEENgLEASAFQawBaiAFQcABahCZDiAFQegBaiAFQbgBaigCADYCACAFIAUpArABNwPgAUGCgICAeCEKIAUoAqwBDAELIAVByABqIBWqIgEgAy0AABDqDyAFKAJIIgpBk4CAgHhGDQEgBUHoAWogBUHYAGooAgA2AgAgBSAFKQJQNwPgASAFKAJMCyEIIAVB4AFqDAQLIAsgATYCACALQQRqIQsgCEEEaiEIIAQgCUEBaiIJRw0ACwsgBUHIAGoiCBCXKSAFQTBqIgIoAgAhASAFKAI0IQQgAiAFQdAAaiIDKQIANwMAIAUpAyghFCAFIAUpAkg3AyggBUEANgI4IAUgFDcCVCAFQQA2AlAgBSAENgJMIAUgATYCSCAFQQhqIAgQ1zsgBSgCCCEBQRxBBBCtNiIJBEAgCUKBgICAEDcCACAJIAUpAkg3AgggCUEQaiADKQIANwIAIAlBGGogBUHYAGoiAigCADYCACAFIAQ2AsgBIAUgATYCxAEgBSAJNgLAASAFQTxqIgEgBUHAAWoQ5RkgAiAFQSBqKQIANwMAIAMgBUEYaikCADcDACAFIAUpAhA3A0ggDSABIAgQyh0gBUEoahDPLwwDC0EEQRwQoz0ACyAFQYABagshASANIAg2AgggDSAKNgIEIA1BKToAACANIAEpAgA3AgwgDUEUaiABQQhqKAIANgIAIAVBKGoQzy8gBSgCECIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQRBqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEOIAdBEGohCyAHQQ5qIQ0jAEHAAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCERIAYoAiQhCiAGKAIgIQUgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBEgBCARaiAFIAoQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBAnQiECEMAkAgEEE8cSIIBEAgECAIa0FAayIMIBBJDQELQcAAIQ8gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiD0UNAQsgBkEANgJQIAYgDzYCSCAGIAw2AkQgBkHAADYCQCAQBEAgEARAIA9BACAQ/AsACyAGKAJIIQ8gBigCUCEJCyAGIBA2AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyANLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCoCALuiEKEkIhZEAAAgAAAA4MFkRSAWRAAAAAAAAOBBY0VyDQAgFqoiASAIEMQpRQ0AIA8gATYCAAwBCyAGQRBqIAZBLGoQhj0gCkEDdiIJIAYoAhQiAU8NAyAGKAIQIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIA9BBGohDyAMQQRqIQwgBCAKQQFqIgpHDQALDAcLIAUEQCAGQfgAaiAFIAogESAEEL8UIAZBmAFqIQogDS0AACEJIAsrAwAhFSABKAIQIQgDQAJAIAYpA6ABIhNQRQRAIAYpA6gBIRIMAQsDQAJ+AkAgBikDiAEiEkIDUgRAAkACQAJAIBJCAlENACAGIBJQrUIBhjcDiAEgEqdBAXFFDQAgBiAGKQOQATcDuAEMAQsgBigCmAFFDQEgBkGwAWogChC2KiAGKQOwASESCyASQgBSDQILIAZCAzcDiAELIAYpA3giEkICUQ0MIAZCADcDeCAGKQOAAQwBCyAGKQO4AQshEyASp0EBcUUNCiAGIAYpA6gBQkB9IhI3A6gBIAYgEzcDoAEgE1ANAAsLIAYgE0IBIBN6IhSGhTcDoAECQCAVIAggFKcgEqdqIg1BAnQiBGoqAgC7ohChJCIWRAAAIAAAAODBZEUgFkQAAAAAAADgQWNFcg0AIBaqIgEgCRDEKUUNACAEIA9qIAE2AgAMAQsgBkEYaiAGQSxqEIY9IA1BA3YiBCAGKAIcIgFJBEAgBigCGCAEaiIBIAEtAABBfiANQQdxd3E6AAAgAkEBaiECDAELCyAEIAFBiIv/ABDDIQALQcSK/wAQsjsACyAJIAFBiIv/ABDDIQALQcAAIAwQoz0ACwwEC0HUiv8AQSNB+Ir/ABDLJAALQcAAIAIQoz0AC0HAACAIEKM9AAsgBkHYAGogBkEsaiIIEIIUIAZB+ABqIg0QlykgBkHIAGoiBCgCACEBIAYoAkwhCiAEIAZBgAFqIgkpAgA3AwAgBikDQCEUIAYgBikCeDcDQCAGQQA2AlAgBiAUNwKEASAGQQA2AoABIAYgCjYCfCAGIAE2AnggBkEIaiANENc7IAYoAgghAUEcQQQQrTYiCwRAIAtCgYCAgBA3AgAgCyAGKQJ4NwIIIAtBEGogCSkCADcCACALQRhqIAZBiAFqIgQoAgA2AgAgBiAKNgK4ASAGIAE2ArQBIAYgCzYCsAEgBkHsAGoiASAGQbABahDlGSAEIAZB6ABqKAIANgIAIAkgBkHgAGopAgA3AwAgBiAGKQJYNwN4IAYgAjYCjAEgDiABIA0Qyh0gBkFAaxDPLyAIEM8vIAZBwAFqJAAMAgtBBEEcEKM9AAtB3Iv/AEEpIAZB+ABqQeyP/wBBiIz/ABDVHgALIAdBGGogDiAHLQAOIAMQoBMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAILQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABB5JmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAwBCyAHQdcAaiICIAdB9ABqKQAANwAAIAdB0ABqIgEgB0HtAGopAAA3AwAgB0HAAWogB0GEAWopAgA3AgAgB0HIAWogB0GMAWopAgA3AgAgB0GpAWogASkDADcAACAHQbABaiACKQAANwAAIAcgBykAZSIUNwNIIAcgBykCfDcCuAEgByADOgCgASAHIBQ3AKEBIAdBGGogB0GgAWogBy0ADiAHLQAPEKATIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwBC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQeSZgAE2AgggACABNgIEIABBk4CAgHg2AgALIAdB0AFqJAAPC0EEQTgQoz0AC0EEQTgQoz0AC6oeAw1/A34CfCMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiEMIAdBlAFqIQojAEHwAWsiBSQAIAFBDGoQ2DwhBCAFQQhqIAEQkjYQ7iUgBEECdCIDIQkCQAJ/AkACQAJAAkAgA0E8cSICBEAgAyACa0FAayIJIANJDQELQcAAIQsgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiC0UNAQsgBSALNgIoIAUgCTYCJCAFQcAANgIgIAMEQCALQQAgA/wLAAsgBSAENgIwIAUgAzYCLCAFKAIIRQ0DIAUoAhwgBSgCGEYNBCAFQUBrIAVBCGoQyDQgBUHgAGohCCAKKAIEIQkgCigCACEEIAEoAhAhAwNAAkAgBSkDaCITUEUEQCAFKQNwIRIMAQsDQAJ+AkAgBSkDUCISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwNQIBKnQQFxRQ0AIAUgBSkDWDcDyAEMAQsgBSgCYEUNASAFQcABaiAIELYqIAUpA8ABIRILIBJCAFINAgsgBUIDNwNQCyAFKQNAIhJCAlENCSAFQgA3A0AgBSkDSAwBCyAFKQPIAQshEyASp0EBcUUNByAFIAUpA3BCQH0iEjcDcCAFIBM3A2ggE1ANAAsLIAUgE0IBIBN6IhSGhTcDaCAFIAMgFKcgEqdqIgJBA3RqKwMAIhU5A4gBIBUgBCsDAKIQoSQiFUQAACAAAADgwWQgFUQAAAAAAADgQWNxRQRAIAooAgghASAFQcyR/wA2AqgBIAVCBDcCtAEgBUGJDDYC3AEgBUH0CzYC1AEgBSABNgLQASAFQbsHNgLMASAFIAk2AsgBIAVBzAE2AsQBIAVB+JH/ADYCwAEgBSAFQcABajYCsAEgBSAFQYgBajYC2AEgBUEENgKsASAFQZQBaiAFQagBahCZDiAFQYABaiAFQaABaigCADYCACAFIAUpApgBNwN4IAUoApQBIQhBgoCAgHghDwwHCyAFQcABaiAVqiIBIAktAAAQ6g8gBSgCwAEiD0GTgICAeEcEQCAFQYABaiAFQdABaigCADYCACAFIAUpAsgBNwN4IAUoAsQBIQgMBwUgCyACQQJ0aiABNgIADAELAAsAC0HAACAJEKM9AAtB3Iv/AEEpIAVBQGtB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAERQ0AIAooAgQhAyAKKAIAIQIgASgCECEIQQAhCQNAIAUgCCsDACIVOQOQAQJAAn8gFSACKwMAohChJCIVRAAAIAAAAODBZCAVRAAAAAAAAOBBY3FFBEAgCigCCCEBIAVBzJH/ADYCwAEgBUIENwLMASAFQYkMNgJcIAVB9As2AlQgBSABNgJQIAVBuwc2AkwgBSADNgJIIAVBzAE2AkQgBUH4kf8ANgJAIAUgBUFAazYCyAEgBSAFQZABajYCWCAFQQQ2AsQBIAVBrAFqIAVBwAFqEJkOIAVB6AFqIAVBuAFqKAIANgIAIAUgBSkCsAE3A+ABQYKAgIB4IQ8gBSgCrAEMAQsgBUFAayAVqiIBIAMtAAAQ6g8gBSgCQCIPQZOAgIB4Rg0BIAVB6AFqIAVB0ABqKAIANgIAIAUgBSkCSDcD4AEgBSgCRAshCCAFQeABagwECyALIAE2AgAgC0EEaiELIAhBCGohCCAEIAlBAWoiCUcNAAsLIAVBQGsiCBCXKSAFQShqIgIoAgAhASAFKAIsIQQgAiAFQcgAaiIDKQIANwMAIAUpAyAhFCAFIAUpAkA3AyAgBUEANgIwIAUgFDcCTCAFQQA2AkggBSAENgJEIAUgATYCQCAFIAgQ1zsgBSgCACEBQRxBBBCtNiIJBEAgCUKBgICAEDcCACAJIAUpAkA3AgggCUEQaiADKQIANwIAIAlBGGogBUHQAGoiAigCADYCACAFIAQ2AsgBIAUgATYCxAEgBSAJNgLAASAFQTRqIgEgBUHAAWoQ5RkgAiAFQRhqKQIANwMAIAMgBUEQaikCADcDACAFIAUpAgg3A0AgDCABIAgQyh0gBUEgahDPLwwDC0EEQRwQoz0ACyAFQfgAagshASAMIAg2AgggDCAPNgIEIAxBKToAACAMIAEpAgA3AgwgDEEUaiABQQhqKAIANgIAIAVBIGoQzy8gBSgCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQhqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEPIAdBEGohDCAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACENIAZBIGogCBDcOyAIKAIUIQIgCCgCDCERIAYoAiQhCyAGKAIgIQUgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDUUNBAsgBkIANwI4IAYgDTYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBEgBCARaiAFIAsQvxgMAQtBwAAhDSAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiINRQ0CCyAGQgA3AjggBiANNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBAnQiECENAkAgEEE8cSIIBEAgECAIa0FAayINIBBJDQELQcAAIQ4gDUHAABDRNARAAkAgDQRAIA1BwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIA02AkQgBkHAADYCQCAQBEAgEARAIA5BACAQ/AsACyAGKAJIIQ4gBigCUCEJCyAGIBA2AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggDCsDACEVIAEoAhAhDUEAIQJBACEKA0ACQAJAIBUgDSsDAKIQoSQiFkQAACAAAADgwWRFIBZEAAAAAAAA4EFjRXINACAWqiIBIAgQxClFDQAgDiABNgIADAELIAZBEGogBkEsahCGPSAKQQN2IgkgBigCFCIBTw0DIAYoAhAgCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDkEEaiEOIA1BCGohDSAEIApBAWoiCkcNAAsMBwsgBQRAIAZB+ABqIAUgCyARIAQQvxQgBkGYAWohCSAKLQAAIQggDCsDACEVIAEoAhAhBANAAkAgBikDoAEiE1BFBEAgBikDqAEhEgwBCwNAAn4CQCAGKQOIASISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwOIASASp0EBcUUNACAGIAYpA5ABNwO4AQwBCyAGKAKYAUUNASAGQbABaiAJELYqIAYpA7ABIRILIBJCAFINAgsgBkIDNwOIAQsgBikDeCISQgJRDQwgBkIANwN4IAYpA4ABDAELIAYpA7gBCyETIBKnQQFxRQ0KIAYgBikDqAFCQH0iEjcDqAEgBiATNwOgASATUA0ACwsgBiATQgEgE3oiFIaFNwOgAQJAIBUgBCAUpyASp2oiDEEDdGorAwCiEKEkIhZEAAAgAAAA4MFkRSAWRAAAAAAAAOBBY0VyDQAgFqoiASAIEMQpRQ0AIA4gDEECdGogATYCAAwBCyAGQRhqIAZBLGoQhj0gDEEDdiIKIAYoAhwiAUkEQCAGKAIYIApqIgEgAS0AAEF+IAxBB3F3cToAACACQQFqIQIMAQsLIAogAUGIi/8AEMMhAAtBxIr/ABCyOwALIAkgAUGIi/8AEMMhAAtBwAAgDRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgAhCjPQALQcAAIAgQoz0ACyAGQdgAaiAGQSxqIggQghQgBkH4AGoiDBCXKSAGQcgAaiIEKAIAIQEgBigCTCEKIAQgBkGAAWoiCSkCADcDACAGKQNAIRQgBiAGKQJ4NwNAIAZBADYCUCAGIBQ3AoQBIAZBADYCgAEgBiAKNgJ8IAYgATYCeCAGQQhqIAwQ1zsgBigCCCEBQRxBBBCtNiILBEAgC0KBgICAEDcCACALIAYpAng3AgggC0EQaiAJKQIANwIAIAtBGGogBkGIAWoiBCgCADYCACAGIAo2ArgBIAYgATYCtAEgBiALNgKwASAGQewAaiIBIAZBsAFqEOUZIAQgBkHoAGooAgA2AgAgCSAGQeAAaikCADcDACAGIAYpAlg3A3ggBiACNgKMASAPIAEgDBDKHSAGQUBrEM8vIAgQzy8gBkHAAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkH4AGpB7I//AEGIjP8AENUeAAsgB0EYaiAPIActAA4gAxCgEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEHkmYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoBMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABB5JmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALuh4EDX8DfgJ8AX0jAEHQAWsiByQAIAcgAzoADyAHIAI6AA4gB0QAAAAAAAAkQCADwBDeIDkDEAJAAkACQAJAIAQtADRFBEAgByAHQQ9qNgKcASAHIAdBDmo2ApgBIAcgB0EQajYClAEgB0HkAGohDiAHQZQBaiEKIwBB8AFrIgUkACABQQxqENs8IQQgBUEwaiABEJI2EO4lIARBBHQiAyEIAkACQAJAAkACQAJAIANBMHEiAgRAIAMgAmtBQGsiCCADSQ0BC0HAACELIAhBwAAQ0TQEQAJAIAgEQCAIQcAAEK02IgtFDQELIAUgCzYCUCAFIAg2AkwgBUHAADYCSCADBEAgC0EAIAP8CwALIAUgBDYCWCAFIAM2AlQgBSgCMEUNAyAFKAJEIAUoAkBGDQQgBUHoAGogBUEwahDINCAFQYgBaiEEIAooAgQhCCAKKAIAIQMgASgCECECA0ACQCAFKQOQASISUEUEQCAFKQOYASETDAELA0ACfgJAIAUpA3giE0IDUgRAAkACQAJAIBNCAlENACAFIBNQrUIBhjcDeCATp0EBcUUNACAFIAUpA4ABNwPYAQwBCyAFKAKIAUUNASAFQdABaiAEELYqIAUpA9ABIRMLIBNCAFINAgsgBUIDNwN4CyAFKQNoIhNCAlENCSAFQgA3A2ggBSkDcAwBCyAFKQPYAQshEiATp0EBcUUNByAFIAUpA5gBQkB9IhM3A5gBIAUgEjcDkAEgElANAAsLIAUgEkIBIBJ6IhSGhTcDkAEgBSACIBSnIBOnaiIBQQJ0aioCACIXOAKgASADKwMAIBe7ohChJCIVRAAAAAAAAODHZiAVRAAAAAAAAOBHY3FFBEAgCigCCCEBIAVBzJH/ADYCuAEgBUIENwLEASAFQYUMNgLsASAFQfQLNgLkASAFIAE2AuABIAVBuwc2AtwBIAUgCDYC2AEgBUHMATYC1AEgBUGgkf8ANgLQASAFIAVB0AFqNgLAASAFIAVBoAFqNgLoASAFQQQ2ArwBIAVBqAFqIAVBuAFqEJkOIAUpAqgBIRMgBSkCsAEhEgwHCyAFQSBqIBUQ6RYgBUHQAWogBSkDICISIAUpAygiFCAILQAAEK0OIAUoAtABIglBk4CAgHhHBEAgBSkC3AEhEiAFKQLUASETDAgFIAsgAUEEdGoiASAUNwMIIAEgEjcDAAwBCwALAAtBwAAgCBCjPQALQdyL/wBBKSAFQegAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKgIAIhc4AqQBIAIrAwAgF7uiEKEkIhVEAAAAAAAA4MdmIBVEAAAAAAAA4EdjcUUEQCAKKAIIIQEgBUHMkf8ANgLQASAFQgQ3AtwBIAVBhQw2AoQBIAVB9As2AnwgBSABNgJ4IAVBuwc2AnQgBSADNgJwIAVBzAE2AmwgBUGgkf8ANgJoIAUgBUHoAGo2AtgBIAUgBUGkAWo2AoABIAVBBDYC1AEgBUG8AWogBUHQAWoQmQ4gBSkCvAEhEyAFKQLEASESDAMLIAVBEGogFRDpFiAFQegAaiAFKQMQIhIgBSkDGCIUIAMtAAAQrQ4gBSgCaCIJQZOAgIB4RwRAIAUpAnQhEiAFKQJsIRMMBAsgCyAUNwMIIAsgEjcDACALQRBqIQsgAUEEaiEBIAQgCEEBaiIIRw0ACwsgBUHoAGoiCBCXKSAFQdAAaiICKAIAIQEgBSgCVCEEIAIgBUHwAGoiAykCADcDACAFKQNIIRQgBSAFKQJoNwNIIAVBADYCWCAFIBQ3AnQgBUEANgJwIAUgBDYCbCAFIAE2AmggBUEIaiAIENc7IAUoAgghAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJoNwIIIAlBEGogAykCADcCACAJQRhqIAVB+ABqIgIoAgA2AgAgBSAENgLYASAFIAE2AtQBIAUgCTYC0AEgBUHcAGoiASAFQdABahDiGSACIAVBQGspAgA3AwAgAyAFQThqKQIANwMAIAUgBSkCMDcDaCAOIAEgCBDLHSAFQcgAahDPLwwDC0EEQRwQoz0AC0GCgICAeCEJCyAOIBI3AhAgDiATNwIIIA4gCTYCBCAOQSk6AAAgBUHIAGoQzy8gBSgCMCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQTBqEPseCyAFQfABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEjcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiASNwAAIAAgFDcAAAwCCyAHQeQAaiEOIAdBEGohCyAHQQ5qIQojAEHgAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBQGsgCBDcOyAIKAIUIQIgCCgCDCEQIAYoAkQhBSAGKAJAIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwJYIAYgDDYCVCAGIAg2AlAgBkHAADYCTCAGQcwAaiAQIAQgEGogESAFEL8YDAELQcAAIQwgBEEDdiAEQQdxQQBHaiICQcD///8DcUFAayACIAJBP3EbIgJBwAAQ0TRFDQQgAgRAIAJBwAAQrTYiDEUNAgsgBkIANwJYIAYgDDYCVCAGIAI2AlAgBkHAADYCTCAGQcwAaiAEEN4QQQAhAgsgBEEEdCIPIQ0CQCAPQTBxIggEQCAPIAhrQUBrIg0gD0kNAQtBwAAhDCANQcAAENE0BEACQCANBEAgDUHAABCtNiIMRQ0BCyAGQQA2AnAgBiAMNgJoIAYgDTYCZCAGQcAANgJgIA8EQCAPBEAgDEEAIA/8CwALIAYoAmghDCAGKAJwIQkLIAYgDzYCbCAGIAQgCWo2AnACQAJAIAIEQCACIARHDQEgBCECDAgLIARFBEBBACECDAgLIAotAAAhCCALKwMAIRUgASgCECENQQAhAkEAIQoDQAJAAkAgFSANKgIAu6IQoSQiFkQAAAAAAADgx2ZFIBZEAAAAAAAA4EdjRXINACAGQRBqIBYQ6RYgBikDECISIAYpAxgiFCAIEP8gRQ0AIAwgEjcDACAMIBQ3AwgMAQsgBkEIaiAGQcwAahCGPSAKQQN2IgkgBigCDCIBTw0DIAYoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDEEQaiEMIA1BBGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAZBmAFqIBEgBSAQIAQQvxQgBkG4AWohCSAKLQAAIQggCysDACEVIAEoAhAhBANAAkAgBikDwAEiElBFBEAgBikDyAEhEwwBCwNAAn4CQCAGKQOoASITQgNSBEACQAJAAkAgE0ICUQ0AIAYgE1CtQgGGNwOoASATp0EBcUUNACAGIAYpA7ABNwPYAQwBCyAGKAK4AUUNASAGQdABaiAJELYqIAYpA9ABIRMLIBNCAFINAgsgBkIDNwOoAQsgBikDmAEiE0ICUQ0MIAZCADcDmAEgBikDoAEMAQsgBikD2AELIRIgE6dBAXFFDQogBiAGKQPIAUJAfSITNwPIASAGIBI3A8ABIBJQDQALCyAGIBJCASASeiIUhoU3A8ABAkAgFSAEIBSnIBOnaiILQQJ0aioCALuiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEwaiAWEOkWIAYpAzAiEiAGKQM4IhQgCBD/IEUNACAMIAtBBHRqIgEgFDcDCCABIBI3AwAMAQsgBkEoaiAGQcwAahCGPSALQQN2IgogBigCLCIBSQRAIAYoAiggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB+ABqIAZBzABqIggQghQgBkGYAWoiCxCXKSAGQegAaiIEKAIAIQEgBigCbCEKIAQgBkGgAWoiCSkCADcDACAGKQNgIRQgBiAGKQKYATcDYCAGQQA2AnAgBiAUNwKkASAGQQA2AqABIAYgCjYCnAEgBiABNgKYASAGIAsQ1zsgBigCACEBQRxBBBCtNiIFBEAgBUKBgICAEDcCACAFIAYpApgBNwIIIAVBEGogCSkCADcCACAFQRhqIAZBqAFqIgQoAgA2AgAgBiAKNgLYASAGIAE2AtQBIAYgBTYC0AEgBkGMAWoiASAGQdABahDiGSAEIAZBiAFqKAIANgIAIAkgBkGAAWopAgA3AwAgBiAGKQJ4NwOYASAGIAI2AqwBIA4gASALEMsdIAZB4ABqEM8vIAgQzy8gBkHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkGYAWpB7I//AEGIjP8AENUeAAsgB0EYaiAOIActAA4gAxChEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG0mIABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoRMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBtJiAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALuh4DDX8DfgJ8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQ4gB0GUAWohCiMAQYACayIFJAAgAUEMahDYPCEEIAVBOGogARCSNhDuJSAEQQR0IgMhCAJAAkACQAJAAkACQCADQTBxIgIEQCADIAJrQUBrIgggA0kNAQtBwAAhCyAIQcAAENE0BEACQCAIBEAgCEHAABCtNiILRQ0BCyAFIAs2AlggBSAINgJUIAVBwAA2AlAgAwRAIAtBACAD/AsACyAFIAQ2AmAgBSADNgJcIAUoAjhFDQMgBSgCTCAFKAJIRg0EIAVB8ABqIAVBOGoQyDQgBUGQAWohBCAKKAIEIQggCigCACEDIAEoAhAhAgNAAkAgBSkDmAEiElBFBEAgBSkDoAEhEwwBCwNAAn4CQCAFKQOAASITQgNSBEACQAJAAkAgE0ICUQ0AIAUgE1CtQgGGNwOAASATp0EBcUUNACAFIAUpA4gBNwPoAQwBCyAFKAKQAUUNASAFQeABaiAEELYqIAUpA+ABIRMLIBNCAFINAgsgBUIDNwOAAQsgBSkDcCITQgJRDQkgBUIANwNwIAUpA3gMAQsgBSkD6AELIRIgE6dBAXFFDQcgBSAFKQOgAUJAfSITNwOgASAFIBI3A5gBIBJQDQALCyAFIBJCASASeiIUhoU3A5gBIAUgAiAUpyATp2oiAUEDdGorAwAiFTkDqAEgFSADKwMAohChJCIVRAAAAAAAAODHZiAVRAAAAAAAAOBHY3FFBEAgCigCCCEBIAVBzJH/ADYCyAEgBUIENwLUASAFQYkMNgL8ASAFQfQLNgL0ASAFIAE2AvABIAVBuwc2AuwBIAUgCDYC6AEgBUHMATYC5AEgBUGgkf8ANgLgASAFIAVB4AFqNgLQASAFIAVBqAFqNgL4ASAFQQQ2AswBIAVBtAFqIAVByAFqEJkOIAUpArQBIRMgBSkCvAEhEgwHCyAFQSBqIBUQ6RYgBUHgAWogBSkDICISIAUpAygiFCAILQAAEK0OIAUoAuABIglBk4CAgHhHBEAgBSkC7AEhEiAFKQLkASETDAgFIAsgAUEEdGoiASAUNwMIIAEgEjcDAAwBCwALAAtBwAAgCBCjPQALQdyL/wBBKSAFQfAAakHsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKwMAIhU5A7ABIBUgAisDAKIQoSQiFUQAAAAAAADgx2YgFUQAAAAAAADgR2NxRQRAIAooAgghASAFQcyR/wA2AuABIAVCBDcC7AEgBUGJDDYCjAEgBUH0CzYChAEgBSABNgKAASAFQbsHNgJ8IAUgAzYCeCAFQcwBNgJ0IAVBoJH/ADYCcCAFIAVB8ABqNgLoASAFIAVBsAFqNgKIASAFQQQ2AuQBIAVBzAFqIAVB4AFqEJkOIAUpAswBIRMgBSkC1AEhEgwDCyAFQRBqIBUQ6RYgBUHwAGogBSkDECISIAUpAxgiFCADLQAAEK0OIAUoAnAiCUGTgICAeEcEQCAFKQJ8IRIgBSkCdCETDAQLIAsgFDcDCCALIBI3AwAgC0EQaiELIAFBCGohASAEIAhBAWoiCEcNAAsLIAVB8ABqIggQlykgBUHYAGoiAigCACEBIAUoAlwhBCACIAVB+ABqIgMpAgA3AwAgBSkDUCEUIAUgBSkCcDcDUCAFQQA2AmAgBSAUNwJ8IAVBADYCeCAFIAQ2AnQgBSABNgJwIAVBCGogCBDXOyAFKAIIIQFBHEEEEK02IgkEQCAJQoGAgIAQNwIAIAkgBSkCcDcCCCAJQRBqIAMpAgA3AgAgCUEYaiAFQYABaiICKAIANgIAIAUgBDYC6AEgBSABNgLkASAFIAk2AuABIAVB5ABqIgEgBUHgAWoQ4hkgAiAFQcgAaikCADcDACADIAVBQGspAgA3AwAgBSAFKQI4NwNwIA4gASAIEMsdIAVB0ABqEM8vDAMLQQRBHBCjPQALQYKAgIB4IQkLIA4gEjcCECAOIBM3AgggDiAJNgIEIA5BKToAACAFQdAAahDPLyAFKAI4IgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBOGoQ+x4LIAVBgAJqJAAgBy0AZCIDQSlHDQEgB0HbAGogB0H4AGooAgAiATYAACAHQdMAaiAHQfAAaikCACISNwAAIAcgBykCaCIUNwBLIABBEGogATYAACAAQQhqIBI3AAAgACAUNwAADAILIAdB5ABqIQ4gB0EQaiELIAdBDmohCiMAQeABayIGJAAgAUEMahDYPCEEAkACQAJAAkACQAJAIAEQkjYiCARAQcAAIQwgBkFAayAIENw7IAgoAhQhAiAIKAIMIRAgBigCRCEFIAYoAkAhESAEQQN2IARBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiCEHAABDRNEUNBSAIBEAgCEHAABCtNiIMRQ0ECyAGQgA3AlggBiAMNgJUIAYgCDYCUCAGQcAANgJMIAZBzABqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AlggBiAMNgJUIAYgAjYCUCAGQcAANgJMIAZBzABqIAQQ3hBBACECCyAEQQR0Ig8hDQJAIA9BMHEiCARAIA8gCGtBQGsiDSAPSQ0BC0HAACEMIA1BwAAQ0TQEQAJAIA0EQCANQcAAEK02IgxFDQELIAZBADYCcCAGIAw2AmggBiANNgJkIAZBwAA2AmAgDwRAIA8EQCAMQQAgD/wLAAsgBigCaCEMIAYoAnAhCQsgBiAPNgJsIAYgBCAJajYCcAJAAkAgAgRAIAIgBEcNASAEIQIMCAsgBEUEQEEAIQIMCAsgCi0AACEIIAsrAwAhFSABKAIQIQ1BACECQQAhCgNAAkACQCAVIA0rAwCiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEQaiAWEOkWIAYpAxAiEiAGKQMYIhQgCBD/IEUNACAMIBI3AwAgDCAUNwMIDAELIAZBCGogBkHMAGoQhj0gCkEDdiIJIAYoAgwiAU8NAyAGKAIIIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIAxBEGohDCANQQhqIQ0gBCAKQQFqIgpHDQALDAcLIBEEQCAGQZgBaiARIAUgECAEEL8UIAZBuAFqIQkgCi0AACEIIAsrAwAhFSABKAIQIQQDQAJAIAYpA8ABIhJQRQRAIAYpA8gBIRMMAQsDQAJ+AkAgBikDqAEiE0IDUgRAAkACQAJAIBNCAlENACAGIBNQrUIBhjcDqAEgE6dBAXFFDQAgBiAGKQOwATcD2AEMAQsgBigCuAFFDQEgBkHQAWogCRC2KiAGKQPQASETCyATQgBSDQILIAZCAzcDqAELIAYpA5gBIhNCAlENDCAGQgA3A5gBIAYpA6ABDAELIAYpA9gBCyESIBOnQQFxRQ0KIAYgBikDyAFCQH0iEzcDyAEgBiASNwPAASASUA0ACwsgBiASQgEgEnoiFIaFNwPAAQJAIBUgBCAUpyATp2oiC0EDdGorAwCiEKEkIhZEAAAAAAAA4MdmRSAWRAAAAAAAAOBHY0VyDQAgBkEwaiAWEOkWIAYpAzAiEiAGKQM4IhQgCBD/IEUNACAMIAtBBHRqIgEgFDcDCCABIBI3AwAMAQsgBkEoaiAGQcwAahCGPSALQQN2IgogBigCLCIBSQRAIAYoAiggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB+ABqIAZBzABqIggQghQgBkGYAWoiCxCXKSAGQegAaiIEKAIAIQEgBigCbCEKIAQgBkGgAWoiCSkCADcDACAGKQNgIRQgBiAGKQKYATcDYCAGQQA2AnAgBiAUNwKkASAGQQA2AqABIAYgCjYCnAEgBiABNgKYASAGIAsQ1zsgBigCACEBQRxBBBCtNiIFBEAgBUKBgICAEDcCACAFIAYpApgBNwIIIAVBEGogCSkCADcCACAFQRhqIAZBqAFqIgQoAgA2AgAgBiAKNgLYASAGIAE2AtQBIAYgBTYC0AEgBkGMAWoiASAGQdABahDiGSAEIAZBiAFqKAIANgIAIAkgBkGAAWopAgA3AwAgBiAGKQJ4NwOYASAGIAI2AqwBIA4gASALEMsdIAZB4ABqEM8vIAgQzy8gBkHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBkGYAWpB7I//AEGIjP8AENUeAAsgB0EYaiAOIActAA4gAxChEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG0mIABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoRMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBtJiAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALrxoDDX8EfgF8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQwgB0GUAWohAyMAQaABayIGJAAgAUEMahDYPCEEIAZBCGogARCSNhDuJSAEQQV0IgghCQJAAkACQAJAAkACQAJAAkAgCEEgcSICBEAgCCACa0FAayIJIAhJDQELQcAAIQIgCUHAABDRNARAAkAgCQRAIAlBwAAQrTYiAkUNAQsgBiACNgIoIAYgCTYCJCAGQcAANgIgIAgEQCACQQAgCPwLAAsgBiAENgIwIAYgCDYCLCAGIAE2AkAgBiADNgI8IAYgBDYCOCAGIAI2AjQgBigCCEUNAyAGKAIcIAYoAhhGDQQgBkHQAGogBkEIahDINCAGQfAAaiEBA0ACQCAGKQN4IhNQRQRAIAYpA4ABIRIMAQsDQAJ+AkAgBikDYCISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwNgIBKnQQFxRQ0AIAYgBikDaDcDkAEMAQsgBigCcEUNASAGQYgBaiABELYqIAYpA4gBIRILIBJCAFINAgsgBkIDNwNgCyAGKQNQIhJCAlENCSAGQgA3A1AgBikDWAwBCyAGKQOQAQshEyASp0EBcUUNByAGIAYpA4ABQkB9IhI3A4ABIAYgEzcDeCATUA0ACwsgBiATQgEgE3oiFIaFNwN4IAZBiAFqIAZBNGogFKcgEqdqEIkOIAYoAogBIglBk4CAgHhGDQALIAwgBikCjAE3AgggDEEQaiAGQZQBaikCADcCAAwGC0HAACAJEKM9AAtB3Iv/AEEpIAZB0ABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBEUNAEEAIQEDQCAGQdAAaiAGQTRqIAEQiQ4gBigCUCIJQZOAgIB4Rw0CIAQgAUEBaiIBRw0ACwsgBkHQAGoiCBCXKSAGQShqIgIoAgAhASAGKAIsIQQgAiAGQdgAaiIDKQIANwMAIAYpAyAhFCAGIAYpAlA3AyAgBkEANgIwIAYgFDcCXCAGQQA2AlggBiAENgJUIAYgATYCUCAGIAgQ1zsgBigCACEBQRxBBBCtNiIJRQ0DIAlCgYCAgBA3AgAgCSAGKQJQNwIIIAlBEGogAykCADcCACAJQRhqIAZB4ABqIgIoAgA2AgAgBiAENgKQASAGIAE2AowBIAYgCTYCiAEgBkHEAGoiASAGQYgBahDiGSACIAZBGGopAgA3AwAgAyAGQRBqKQIANwMAIAYgBikCCDcDUCAMIAEgCBDOHSAGQSBqEM8vDAILIAwgBikCVDcCCCAMQRBqIAZB3ABqKQIANwIACyAMQSk6AAAgDCAJNgIEIAZBIGoQzy8gBigCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQhqEPseCyAGQaABaiQADAELQQRBHBCjPQALIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiEzcAACAHIAcpAmgiFDcASyAAQRBqIAE2AAAgAEEIaiATNwAAIAAgFDcAAAwCCyAHQeQAaiEMIAdBEGohDiAHQQ5qIQYjAEHgAWsiBSQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEKIAVBGGogCBDcOyAIKAIUIQIgCCgCDCEQIAUoAhwhDyAFKAIYIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiCkUNBAsgBUIANwIwIAUgCjYCLCAFIAg2AiggBUHAADYCJCAFQSRqIBAgBCAQaiARIA8QvxgMAQtBwAAhCiAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIKRQ0CCyAFQgA3AjAgBSAKNgIsIAUgAjYCKCAFQcAANgIkIAVBJGogBBDeEEEAIQILIARBBXQiCiENAkAgCkEgcSIIBEAgCiAIa0FAayINIApJDQELQcAAIQsgDUHAABDRNARAAkAgDQRAIA1BwAAQrTYiC0UNAQsgBUEANgJIIAUgCzYCQCAFIA02AjwgBUHAADYCOCAKBEAgCgRAIAtBACAK/AsACyAFKAJAIQsgBSgCSCEJCyAFIAo2AkQgBSAEIAlqNgJIAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAGLQAAIQggDisDACEWIAEoAhAhDUEAIQJBACEKA0AgBUHwAGogFiANKwMAohChJBCjBgJAAkAgBSgCcEEBcUUNACAFKQOAASIVIAUpA4gBIhIgBSkDkAEiEyAFKQOYASIUIAgQ3B1FDQAgCyAVNwMAIAtBGGogFDcDACALQRBqIBM3AwAgCyASNwMIDAELIAVBCGogBUEkahCGPSAKQQN2IgkgBSgCDCIBTw0DIAUoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgC0EgaiELIA1BCGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAVB8ABqIBEgDyAQIAQQvxQgBUGQAWohCSAGLQAAIQggDisDACEWIAEoAhAhBANAAkAgBSkDmAEiE1BFBEAgBSkDoAEhEgwBCwNAAn4CQCAFKQOAASISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwOAASASp0EBcUUNACAFIAUpA4gBNwO4AQwBCyAFKAKQAUUNASAFQbABaiAJELYqIAUpA7ABIRILIBJCAFINAgsgBUIDNwOAAQsgBSkDcCISQgJRDQwgBUIANwNwIAUpA3gMAQsgBSkDuAELIRMgEqdBAXFFDQogBSAFKQOgAUJAfSISNwOgASAFIBM3A5gBIBNQDQALCyAFIBNCASATeiIUhoU3A5gBIAVBsAFqIBYgBCAUpyASp2oiDkEDdGorAwCiEKEkEKMGAkAgBSgCsAFBAXFFDQAgBSkDwAEiFSAFKQPIASISIAUpA9ABIhMgBSkD2AEiFCAIENwdRQ0AIAsgDkEFdGoiASAUNwMYIAEgEzcDECABIBI3AwggASAVNwMADAELIAVBEGogBUEkahCGPSAOQQN2IgYgBSgCFCIBSQRAIAUoAhAgBmoiASABLQAAQX4gDkEHcXdxOgAAIAJBAWohAgwBCwsgBiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACANEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAVB0ABqIAVBJGoiCBCCFCAFQfAAaiIOEJcpIAVBQGsiBCgCACEBIAUoAkQhBiAEIAVB+ABqIgkpAgA3AwAgBSkDOCEUIAUgBSkCcDcDOCAFQQA2AkggBSAUNwJ8IAVBADYCeCAFIAY2AnQgBSABNgJwIAUgDhDXOyAFKAIAIQFBHEEEEK02Ig8EQCAPQoGAgIAQNwIAIA8gBSkCcDcCCCAPQRBqIAkpAgA3AgAgD0EYaiAFQYABaiIEKAIANgIAIAUgBjYCuAEgBSABNgK0ASAFIA82ArABIAVB5ABqIgEgBUGwAWoQ4hkgBCAFQeAAaigCADYCACAJIAVB2ABqKQIANwMAIAUgBSkCUDcDcCAFIAI2AoQBIAwgASAOEM4dIAVBOGoQzy8gCBDPLyAFQeABaiQADAILQQRBHBCjPQALQdyL/wBBKSAFQfAAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIAwgBy0ADiADEKMTIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQYyZgAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiFDcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByAUNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCjEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEGMmYABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAuxGgMNfwR+AXwjAEHQAWsiByQAIAcgAzoADyAHIAI6AA4gB0QAAAAAAAAkQCADwBDeIDkDEAJAAkACQAJAIAQtADRFBEAgByAHQQ9qNgKcASAHIAdBDmo2ApgBIAcgB0EQajYClAEgB0HkAGohDCAHQZQBaiEDIwBBoAFrIgYkACABQQxqENs8IQQgBkEIaiABEJI2EO4lIARBBXQiCCEJAkACQAJAAkACQAJAAkACQCAIQSBxIgIEQCAIIAJrQUBrIgkgCEkNAQtBwAAhAiAJQcAAENE0BEACQCAJBEAgCUHAABCtNiICRQ0BCyAGIAI2AiggBiAJNgIkIAZBwAA2AiAgCARAIAJBACAI/AsACyAGIAQ2AjAgBiAINgIsIAYgATYCQCAGIAM2AjwgBiAENgI4IAYgAjYCNCAGKAIIRQ0DIAYoAhwgBigCGEYNBCAGQdAAaiAGQQhqEMg0IAZB8ABqIQEDQAJAIAYpA3giE1BFBEAgBikDgAEhEgwBCwNAAn4CQCAGKQNgIhJCA1IEQAJAAkACQCASQgJRDQAgBiASUK1CAYY3A2AgEqdBAXFFDQAgBiAGKQNoNwOQAQwBCyAGKAJwRQ0BIAZBiAFqIAEQtiogBikDiAEhEgsgEkIAUg0CCyAGQgM3A2ALIAYpA1AiEkICUQ0JIAZCADcDUCAGKQNYDAELIAYpA5ABCyETIBKnQQFxRQ0HIAYgBikDgAFCQH0iEjcDgAEgBiATNwN4IBNQDQALCyAGIBNCASATeiIUhoU3A3ggBkGIAWogBkE0aiAUpyASp2oQpg4gBigCiAEiCUGTgICAeEYNAAsgDCAGKQKMATcCCCAMQRBqIAZBlAFqKQIANwIADAYLQcAAIAkQoz0AC0Hci/8AQSkgBkHQAGpB7I//AEGIjP8AENUeAAtB1Ir/AEEjQfiK/wAQyyQACyAERQ0AQQAhAQNAIAZB0ABqIAZBNGogARCmDiAGKAJQIglBk4CAgHhHDQIgBCABQQFqIgFHDQALCyAGQdAAaiIIEJcpIAZBKGoiAigCACEBIAYoAiwhBCACIAZB2ABqIgMpAgA3AwAgBikDICEUIAYgBikCUDcDICAGQQA2AjAgBiAUNwJcIAZBADYCWCAGIAQ2AlQgBiABNgJQIAYgCBDXOyAGKAIAIQFBHEEEEK02IglFDQMgCUKBgICAEDcCACAJIAYpAlA3AgggCUEQaiADKQIANwIAIAlBGGogBkHgAGoiAigCADYCACAGIAQ2ApABIAYgATYCjAEgBiAJNgKIASAGQcQAaiIBIAZBiAFqEOIZIAIgBkEYaikCADcDACADIAZBEGopAgA3AwAgBiAGKQIINwNQIAwgASAIEM4dIAZBIGoQzy8MAgsgDCAGKQJUNwIIIAxBEGogBkHcAGopAgA3AgALIAxBKToAACAMIAk2AgQgBkEgahDPLyAGKAIIIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBCGoQ+x4LIAZBoAFqJAAMAQtBBEEcEKM9AAsgBy0AZCIDQSlHDQEgB0HbAGogB0H4AGooAgAiATYAACAHQdMAaiAHQfAAaikCACITNwAAIAcgBykCaCIUNwBLIABBEGogATYAACAAQQhqIBM3AAAgACAUNwAADAILIAdB5ABqIQwgB0EQaiEOIAdBDmohBiMAQeABayIFJAAgAUEMahDbPCEEAkACQAJAAkACQAJAIAEQkjYiCARAQcAAIQogBUEYaiAIENw7IAgoAhQhAiAIKAIMIRAgBSgCHCEPIAUoAhghESAEQQN2IARBB3FBAEdqIghBwP///wNxQUBrIAggCEE/cRsiCEHAABDRNEUNBSAIBEAgCEHAABCtNiIKRQ0ECyAFQgA3AjAgBSAKNgIsIAUgCDYCKCAFQcAANgIkIAVBJGogECAEIBBqIBEgDxC/GAwBC0HAACEKIARBA3YgBEEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0RQ0EIAIEQCACQcAAEK02IgpFDQILIAVCADcCMCAFIAo2AiwgBSACNgIoIAVBwAA2AiQgBUEkaiAEEN4QQQAhAgsgBEEFdCIKIQ0CQCAKQSBxIggEQCAKIAhrQUBrIg0gCkkNAQtBwAAhCyANQcAAENE0BEACQCANBEAgDUHAABCtNiILRQ0BCyAFQQA2AkggBSALNgJAIAUgDTYCPCAFQcAANgI4IAoEQCAKBEAgC0EAIAr8CwALIAUoAkAhCyAFKAJIIQkLIAUgCjYCRCAFIAQgCWo2AkgCQAJAIAIEQCACIARHDQEgBCECDAgLIARFBEBBACECDAgLIAYtAAAhCCAOKwMAIRYgASgCECENQQAhAkEAIQoDQCAFQfAAaiAWIA0qAgC7ohChJBCjBgJAAkAgBSgCcEEBcUUNACAFKQOAASIVIAUpA4gBIhIgBSkDkAEiEyAFKQOYASIUIAgQ3B1FDQAgCyAVNwMAIAtBGGogFDcDACALQRBqIBM3AwAgCyASNwMIDAELIAVBCGogBUEkahCGPSAKQQN2IgkgBSgCDCIBTw0DIAUoAgggCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgC0EgaiELIA1BBGohDSAEIApBAWoiCkcNAAsMBwsgEQRAIAVB8ABqIBEgDyAQIAQQvxQgBUGQAWohCSAGLQAAIQggDisDACEWIAEoAhAhBANAAkAgBSkDmAEiE1BFBEAgBSkDoAEhEgwBCwNAAn4CQCAFKQOAASISQgNSBEACQAJAAkAgEkICUQ0AIAUgElCtQgGGNwOAASASp0EBcUUNACAFIAUpA4gBNwO4AQwBCyAFKAKQAUUNASAFQbABaiAJELYqIAUpA7ABIRILIBJCAFINAgsgBUIDNwOAAQsgBSkDcCISQgJRDQwgBUIANwNwIAUpA3gMAQsgBSkDuAELIRMgEqdBAXFFDQogBSAFKQOgAUJAfSISNwOgASAFIBM3A5gBIBNQDQALCyAFIBNCASATeiIUhoU3A5gBIAVBsAFqIBYgBCAUpyASp2oiDkECdGoqAgC7ohChJBCjBgJAIAUoArABQQFxRQ0AIAUpA8ABIhUgBSkDyAEiEiAFKQPQASITIAUpA9gBIhQgCBDcHUUNACALIA5BBXRqIgEgFDcDGCABIBM3AxAgASASNwMIIAEgFTcDAAwBCyAFQRBqIAVBJGoQhj0gDkEDdiIGIAUoAhQiAUkEQCAFKAIQIAZqIgEgAS0AAEF+IA5BB3F3cToAACACQQFqIQIMAQsLIAYgAUGIi/8AEMMhAAtBxIr/ABCyOwALIAkgAUGIi/8AEMMhAAtBwAAgDRCjPQALDAQLQdSK/wBBI0H4iv8AEMskAAtBwAAgAhCjPQALQcAAIAgQoz0ACyAFQdAAaiAFQSRqIggQghQgBUHwAGoiDhCXKSAFQUBrIgQoAgAhASAFKAJEIQYgBCAFQfgAaiIJKQIANwMAIAUpAzghFCAFIAUpAnA3AzggBUEANgJIIAUgFDcCfCAFQQA2AnggBSAGNgJ0IAUgATYCcCAFIA4Q1zsgBSgCACEBQRxBBBCtNiIPBEAgD0KBgICAEDcCACAPIAUpAnA3AgggD0EQaiAJKQIANwIAIA9BGGogBUGAAWoiBCgCADYCACAFIAY2ArgBIAUgATYCtAEgBSAPNgKwASAFQeQAaiIBIAVBsAFqEOIZIAQgBUHgAGooAgA2AgAgCSAFQdgAaikCADcDACAFIAUpAlA3A3AgBSACNgKEASAMIAEgDhDOHSAFQThqEM8vIAgQzy8gBUHgAWokAAwCC0EEQRwQoz0AC0Hci/8AQSkgBUHwAGpB7I//AEGIjP8AENUeAAsgB0EYaiAMIActAA4gAxCjEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAgtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEGMmYABNgIIIAAgATYCBCAAQZOAgIB4NgIADAELIAdB1wBqIgIgB0H0AGopAAA3AAAgB0HQAGoiASAHQe0AaikAADcDACAHQcABaiAHQYQBaikCADcCACAHQcgBaiAHQYwBaikCADcCACAHQakBaiABKQMANwAAIAdBsAFqIAIpAAA3AAAgByAHKQBlIhQ3A0ggByAHKQJ8NwK4ASAHIAM6AKABIAcgFDcAoQEgB0EYaiAHQaABaiAHLQAOIActAA8QoxMgBy0AGEEpRgRAIAAgBykCHDcCACAAQRBqIAdBLGooAgA2AgAgAEEIaiAHQSRqKQIANwIADAELQThBBBCtNiIBRQ0CIAFCgYCAgBA3AgAgAUEIaiAHQRhqQTD8CgAAIABBjJmAATYCCCAAIAE2AgQgAEGTgICAeDYCAAsgB0HQAWokAA8LQQRBOBCjPQALQQRBOBCjPQALox0DDX8DfgJ8IwBB0AFrIgckACAHIAM6AA8gByACOgAOIAdEAAAAAAAAJEAgA8AQ3iA5AxACQAJAAkACQCAELQA0RQRAIAcgB0EPajYCnAEgByAHQQ5qNgKYASAHIAdBEGo2ApQBIAdB5ABqIQ0gB0GUAWohCiMAQdABayIFJAAgAUEMahDYPCEEIAVBCGogARCSNhDuJSAEQQN0IgMhCAJAAkACQAJAAkACQCADQThxIgIEQCADIAJrQUBrIgggA0kNAQtBwAAhCyAIQcAAENE0BEACQCAIBEAgCEHAABCtNiILRQ0BCyAFIAs2AiggBSAINgIkIAVBwAA2AiAgAwRAIAtBACAD/AsACyAFIAQ2AjAgBSADNgIsIAUoAghFDQMgBSgCHCAFKAIYRg0EIAVBQGsgBUEIahDINCAFQeAAaiEEIAooAgQhCCAKKAIAIQMgASgCECECA0ACQCAFKQNoIhRQRQRAIAUpA3AhEgwBCwNAAn4CQCAFKQNQIhJCA1IEQAJAAkACQCASQgJRDQAgBSASUK1CAYY3A1AgEqdBAXFFDQAgBSAFKQNYNwO4AQwBCyAFKAJgRQ0BIAVBsAFqIAQQtiogBSkDsAEhEgsgEkIAUg0CCyAFQgM3A1ALIAUpA0AiEkICUQ0JIAVCADcDQCAFKQNIDAELIAUpA7gBCyEUIBKnQQFxRQ0HIAUgBSkDcEJAfSISNwNwIAUgFDcDaCAUUA0ACwsgBSAUQgEgFHoiE4aFNwNoIAUgAiATpyASp2pBA3QiAWorAwAiFTkDeCAVIAMrAwCiEKEkIhVEAAAAAAAA4MNmIBVEAAAAAAAA4ENjcUUEQCAKKAIIIQEgBUHMkf8ANgKYASAFQgQ3AqQBIAVBiQw2AswBIAVB9As2AsQBIAUgATYCwAEgBUG7BzYCvAEgBSAINgK4ASAFQcwBNgK0ASAFQaCS/wA2ArABIAUgBUGwAWo2AqABIAUgBUH4AGo2AsgBIAVBBDYCnAEgBUGEAWogBUGYAWoQmQ4gBSkChAEhEiAFKQKMASEUDAcLIAVBsAFqIBWwIhMgCC0AABCNECAFKAKwASIJQZOAgIB4RwRAIAUpArwBIRQgBSkCtAEhEgwIBSABIAtqIBM3AwAMAQsACwALQcAAIAgQoz0AC0Hci/8AQSkgBUFAa0Hsj/8AQYiM/wAQ1R4AC0HUiv8AQSNB+Ir/ABDLJAALIARFDQAgCigCBCEDIAooAgAhAiABKAIQIQFBACEIA0AgBSABKwMAIhU5A4ABIBUgAisDAKIQoSQiFUQAAAAAAADgw2YgFUQAAAAAAADgQ2NxRQRAIAooAgghASAFQcyR/wA2ArABIAVCBDcCvAEgBUGJDDYCXCAFQfQLNgJUIAUgATYCUCAFQbsHNgJMIAUgAzYCSCAFQcwBNgJEIAVBoJL/ADYCQCAFIAVBQGs2ArgBIAUgBUGAAWo2AlggBUEENgK0ASAFQZwBaiAFQbABahCZDiAFKQKcASESIAUpAqQBIRQMAwsgBUFAayAVsCITIAMtAAAQjRAgBSgCQCIJQZOAgIB4RwRAIAUpAkwhFCAFKQJEIRIMBAsgCyATNwMAIAtBCGohCyABQQhqIQEgBCAIQQFqIghHDQALCyAFQUBrIggQlykgBUEoaiICKAIAIQEgBSgCLCEEIAIgBUHIAGoiAykCADcDACAFKQMgIRMgBSAFKQJANwMgIAVBADYCMCAFIBM3AkwgBUEANgJIIAUgBDYCRCAFIAE2AkAgBSAIENc7IAUoAgAhAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJANwIIIAlBEGogAykCADcCACAJQRhqIAVB0ABqIgIoAgA2AgAgBSAENgK4ASAFIAE2ArQBIAUgCTYCsAEgBUE0aiIBIAVBsAFqEOQZIAIgBUEYaikCADcDACADIAVBEGopAgA3AwAgBSAFKQIINwNAIA0gASAIEMYdIAVBIGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghCQsgDSAUNwIQIA0gEjcCCCANIAk2AgQgDUEpOgAAIAVBIGoQzy8gBSgCCCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQhqEPseCyAFQdABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiFDcAACAHIAcpAmgiEzcASyAAQRBqIAE2AAAgAEEIaiAUNwAAIAAgEzcAAAwCCyAHQeQAaiENIAdBEGohCyAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2DwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCEQIAYoAiQhBSAGKAIgIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBA3QiDyEMAkAgD0E4cSIIBEAgDyAIa0FAayIMIA9JDQELQcAAIQ4gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIAw2AkQgBkHAADYCQCAPBEAgDwRAIA5BACAP/AsACyAGKAJIIQ4gBigCUCEJCyAGIA82AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCsDAKIQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgDiATNwMADAELIAZBEGogBkEsahCGPSAKQQN2IgkgBigCFCIBTw0DIAYoAhAgCWoiASABLQAAQX4gCkEHcXdxOgAAIAJBAWohAgsgDkEIaiEOIAxBCGohDCAEIApBAWoiCkcNAAsMBwsgEQRAIAZB+ABqIBEgBSAQIAQQvxQgBkGYAWohCSAKLQAAIQggCysDACEVIAEoAhAhBANAAkAgBikDoAEiFFBFBEAgBikDqAEhEgwBCwNAAn4CQCAGKQOIASISQgNSBEACQAJAAkAgEkICUQ0AIAYgElCtQgGGNwOIASASp0EBcUUNACAGIAYpA5ABNwO4AQwBCyAGKAKYAUUNASAGQbABaiAJELYqIAYpA7ABIRILIBJCAFINAgsgBkIDNwOIAQsgBikDeCISQgJRDQwgBkIANwN4IAYpA4ABDAELIAYpA7gBCyEUIBKnQQFxRQ0KIAYgBikDqAFCQH0iEjcDqAEgBiAUNwOgASAUUA0ACwsgBiAUQgEgFHoiE4aFNwOgAQJAIBUgBCATpyASp2oiC0EDdCIBaisDAKIQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgASAOaiATNwMADAELIAZBGGogBkEsahCGPSALQQN2IgogBigCHCIBSQRAIAYoAhggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACAMEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB2ABqIAZBLGoiCBCCFCAGQfgAaiILEJcpIAZByABqIgQoAgAhASAGKAJMIQogBCAGQYABaiIJKQIANwMAIAYpA0AhEyAGIAYpAng3A0AgBkEANgJQIAYgEzcChAEgBkEANgKAASAGIAo2AnwgBiABNgJ4IAZBCGogCxDXOyAGKAIIIQFBHEEEEK02IgUEQCAFQoGAgIAQNwIAIAUgBikCeDcCCCAFQRBqIAkpAgA3AgAgBUEYaiAGQYgBaiIEKAIANgIAIAYgCjYCuAEgBiABNgK0ASAGIAU2ArABIAZB7ABqIgEgBkGwAWoQ5BkgBCAGQegAaigCADYCACAJIAZB4ABqKQIANwMAIAYgBikCWDcDeCAGIAI2AowBIA0gASALEMYdIAZBQGsQzy8gCBDPLyAGQcABaiQADAILQQRBHBCjPQALQdyL/wBBKSAGQfgAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIA0gBy0ADiADEKITIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQbyagAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiEzcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByATNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCiEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG8moABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAu2HQQNfwN+AnwBfSMAQdABayIHJAAgByADOgAPIAcgAjoADiAHRAAAAAAAACRAIAPAEN4gOQMQAkACQAJAAkAgBC0ANEUEQCAHIAdBD2o2ApwBIAcgB0EOajYCmAEgByAHQRBqNgKUASAHQeQAaiENIAdBlAFqIQojAEHQAWsiBSQAIAFBDGoQ2zwhBCAFQRBqIAEQkjYQ7iUgBEEDdCIDIQgCQAJAAkACQAJAAkAgA0E4cSICBEAgAyACa0FAayIIIANJDQELQcAAIQsgCEHAABDRNARAAkAgCARAIAhBwAAQrTYiC0UNAQsgBSALNgIwIAUgCDYCLCAFQcAANgIoIAMEQCALQQAgA/wLAAsgBSAENgI4IAUgAzYCNCAFKAIQRQ0DIAUoAiQgBSgCIEYNBCAFQcgAaiAFQRBqEMg0IAVB6ABqIQQgCigCBCEIIAooAgAhAyABKAIQIQIDQAJAIAUpA3AiFFBFBEAgBSkDeCESDAELA0ACfgJAIAUpA1giEkIDUgRAAkACQAJAIBJCAlENACAFIBJQrUIBhjcDWCASp0EBcUUNACAFIAUpA2A3A7gBDAELIAUoAmhFDQEgBUGwAWogBBC2KiAFKQOwASESCyASQgBSDQILIAVCAzcDWAsgBSkDSCISQgJRDQkgBUIANwNIIAUpA1AMAQsgBSkDuAELIRQgEqdBAXFFDQcgBSAFKQN4QkB9IhI3A3ggBSAUNwNwIBRQDQALCyAFIBRCASAUeiIThoU3A3AgBSACIBOnIBKnaiIBQQJ0aioCACIXOAKAASADKwMAIBe7ohChJCIVRAAAAAAAAODDZiAVRAAAAAAAAOBDY3FFBEAgCigCCCEBIAVBzJH/ADYCmAEgBUIENwKkASAFQYUMNgLMASAFQfQLNgLEASAFIAE2AsABIAVBuwc2ArwBIAUgCDYCuAEgBUHMATYCtAEgBUGgkv8ANgKwASAFIAVBsAFqNgKgASAFIAVBgAFqNgLIASAFQQQ2ApwBIAVBiAFqIAVBmAFqEJkOIAUpAogBIRIgBSkCkAEhFAwHCyAFQbABaiAVsCITIAgtAAAQjRAgBSgCsAEiCUGTgICAeEcEQCAFKQK8ASEUIAUpArQBIRIMCAUgCyABQQN0aiATNwMADAELAAsAC0HAACAIEKM9AAtB3Iv/AEEpIAVByABqQeyP/wBBiIz/ABDVHgALQdSK/wBBI0H4iv8AEMskAAsgBEUNACAKKAIEIQMgCigCACECIAEoAhAhAUEAIQgDQCAFIAEqAgAiFzgChAEgAisDACAXu6IQoSQiFUQAAAAAAADgw2YgFUQAAAAAAADgQ2NxRQRAIAooAgghASAFQcyR/wA2ArABIAVCBDcCvAEgBUGFDDYCZCAFQfQLNgJcIAUgATYCWCAFQbsHNgJUIAUgAzYCUCAFQcwBNgJMIAVBoJL/ADYCSCAFIAVByABqNgK4ASAFIAVBhAFqNgJgIAVBBDYCtAEgBUGcAWogBUGwAWoQmQ4gBSkCnAEhEiAFKQKkASEUDAMLIAVByABqIBWwIhMgAy0AABCNECAFKAJIIglBk4CAgHhHBEAgBSkCVCEUIAUpAkwhEgwECyALIBM3AwAgC0EIaiELIAFBBGohASAEIAhBAWoiCEcNAAsLIAVByABqIggQlykgBUEwaiICKAIAIQEgBSgCNCEEIAIgBUHQAGoiAykCADcDACAFKQMoIRMgBSAFKQJINwMoIAVBADYCOCAFIBM3AlQgBUEANgJQIAUgBDYCTCAFIAE2AkggBUEIaiAIENc7IAUoAgghAUEcQQQQrTYiCQRAIAlCgYCAgBA3AgAgCSAFKQJINwIIIAlBEGogAykCADcCACAJQRhqIAVB2ABqIgIoAgA2AgAgBSAENgK4ASAFIAE2ArQBIAUgCTYCsAEgBUE8aiIBIAVBsAFqEOQZIAIgBUEgaikCADcDACADIAVBGGopAgA3AwAgBSAFKQIQNwNIIA0gASAIEMYdIAVBKGoQzy8MAwtBBEEcEKM9AAtBgoCAgHghCQsgDSAUNwIQIA0gEjcCCCANIAk2AgQgDUEpOgAAIAVBKGoQzy8gBSgCECIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQRBqEPseCyAFQdABaiQAIActAGQiA0EpRw0BIAdB2wBqIAdB+ABqKAIAIgE2AAAgB0HTAGogB0HwAGopAgAiFDcAACAHIAcpAmgiEzcASyAAQRBqIAE2AAAgAEEIaiAUNwAAIAAgEzcAAAwCCyAHQeQAaiENIAdBEGohCyAHQQ5qIQojAEHAAWsiBiQAIAFBDGoQ2zwhBAJAAkACQAJAAkACQCABEJI2IggEQEHAACEMIAZBIGogCBDcOyAIKAIUIQIgCCgCDCEQIAYoAiQhBSAGKAIgIREgBEEDdiAEQQdxQQBHaiIIQcD///8DcUFAayAIIAhBP3EbIghBwAAQ0TRFDQUgCARAIAhBwAAQrTYiDEUNBAsgBkIANwI4IAYgDDYCNCAGIAg2AjAgBkHAADYCLCAGQSxqIBAgBCAQaiARIAUQvxgMAQtBwAAhDCAEQQN2IARBB3FBAEdqIgJBwP///wNxQUBrIAIgAkE/cRsiAkHAABDRNEUNBCACBEAgAkHAABCtNiIMRQ0CCyAGQgA3AjggBiAMNgI0IAYgAjYCMCAGQcAANgIsIAZBLGogBBDeEEEAIQILIARBA3QiDyEMAkAgD0E4cSIIBEAgDyAIa0FAayIMIA9JDQELQcAAIQ4gDEHAABDRNARAAkAgDARAIAxBwAAQrTYiDkUNAQsgBkEANgJQIAYgDjYCSCAGIAw2AkQgBkHAADYCQCAPBEAgDwRAIA5BACAP/AsACyAGKAJIIQ4gBigCUCEJCyAGIA82AkwgBiAEIAlqNgJQAkACQCACBEAgAiAERw0BIAQhAgwICyAERQRAQQAhAgwICyAKLQAAIQggCysDACEVIAEoAhAhDEEAIQJBACEKA0ACQAJAIBUgDCoCALuiEKEkIhZEAAAAAAAA4MNmRSAWRAAAAAAAAOBDY0VyDQAgFrAiEyAIEMUpRQ0AIA4gEzcDAAwBCyAGQRBqIAZBLGoQhj0gCkEDdiIJIAYoAhQiAU8NAyAGKAIQIAlqIgEgAS0AAEF+IApBB3F3cToAACACQQFqIQILIA5BCGohDiAMQQRqIQwgBCAKQQFqIgpHDQALDAcLIBEEQCAGQfgAaiARIAUgECAEEL8UIAZBmAFqIQkgCi0AACEIIAsrAwAhFSABKAIQIQQDQAJAIAYpA6ABIhRQRQRAIAYpA6gBIRIMAQsDQAJ+AkAgBikDiAEiEkIDUgRAAkACQAJAIBJCAlENACAGIBJQrUIBhjcDiAEgEqdBAXFFDQAgBiAGKQOQATcDuAEMAQsgBigCmAFFDQEgBkGwAWogCRC2KiAGKQOwASESCyASQgBSDQILIAZCAzcDiAELIAYpA3giEkICUQ0MIAZCADcDeCAGKQOAAQwBCyAGKQO4AQshFCASp0EBcUUNCiAGIAYpA6gBQkB9IhI3A6gBIAYgFDcDoAEgFFANAAsLIAYgFEIBIBR6IhOGhTcDoAECQCAVIAQgE6cgEqdqIgtBAnRqKgIAu6IQoSQiFkQAAAAAAADgw2ZFIBZEAAAAAAAA4ENjRXINACAWsCITIAgQxSlFDQAgDiALQQN0aiATNwMADAELIAZBGGogBkEsahCGPSALQQN2IgogBigCHCIBSQRAIAYoAhggCmoiASABLQAAQX4gC0EHcXdxOgAAIAJBAWohAgwBCwsgCiABQYiL/wAQwyEAC0HEiv8AELI7AAsgCSABQYiL/wAQwyEAC0HAACAMEKM9AAsMBAtB1Ir/AEEjQfiK/wAQyyQAC0HAACACEKM9AAtBwAAgCBCjPQALIAZB2ABqIAZBLGoiCBCCFCAGQfgAaiILEJcpIAZByABqIgQoAgAhASAGKAJMIQogBCAGQYABaiIJKQIANwMAIAYpA0AhEyAGIAYpAng3A0AgBkEANgJQIAYgEzcChAEgBkEANgKAASAGIAo2AnwgBiABNgJ4IAZBCGogCxDXOyAGKAIIIQFBHEEEEK02IgUEQCAFQoGAgIAQNwIAIAUgBikCeDcCCCAFQRBqIAkpAgA3AgAgBUEYaiAGQYgBaiIEKAIANgIAIAYgCjYCuAEgBiABNgK0ASAGIAU2ArABIAZB7ABqIgEgBkGwAWoQ5BkgBCAGQegAaigCADYCACAJIAZB4ABqKQIANwMAIAYgBikCWDcDeCAGIAI2AowBIA0gASALEMYdIAZBQGsQzy8gCBDPLyAGQcABaiQADAILQQRBHBCjPQALQdyL/wBBKSAGQfgAakHsj/8AQYiM/wAQ1R4ACyAHQRhqIA0gBy0ADiADEKITIActABhBKUYEQCAAIAcpAhw3AgAgAEEQaiAHQSxqKAIANgIAIABBCGogB0EkaikCADcCAAwCC0E4QQQQrTYiAUUNAiABQoGAgIAQNwIAIAFBCGogB0EYakEw/AoAACAAQbyagAE2AgggACABNgIEIABBk4CAgHg2AgAMAQsgB0HXAGoiAiAHQfQAaikAADcAACAHQdAAaiIBIAdB7QBqKQAANwMAIAdBwAFqIAdBhAFqKQIANwIAIAdByAFqIAdBjAFqKQIANwIAIAdBqQFqIAEpAwA3AAAgB0GwAWogAikAADcAACAHIAcpAGUiEzcDSCAHIAcpAnw3ArgBIAcgAzoAoAEgByATNwChASAHQRhqIAdBoAFqIActAA4gBy0ADxCiEyAHLQAYQSlGBEAgACAHKQIcNwIAIABBEGogB0EsaigCADYCACAAQQhqIAdBJGopAgA3AgAMAQtBOEEEEK02IgFFDQIgAUKBgICAEDcCACABQQhqIAdBGGpBMPwKAAAgAEG8moABNgIIIAAgATYCBCAAQZOAgIB4NgIACyAHQdABaiQADwtBBEE4EKM9AAtBBEE4EKM9AAu7HAIgfwN+IwBBkAFrIgYkAAJAIAECfwJAAkACQAJAAkACQAJAAkACQCABLQCQAUEBaw4DBQEAAgsgAUH8AGohGgJAIAEtAHxBAWsOAwoBBAALIAEpAxAhIyABKAIMIQkgASgCCCEHIAEoAgQhAyABKAIAIQgMAgsACyABKAKAASIDKQMAISMgAUEAOgB8IAEgIzcDECABIANBFGoiCTYCDCABIANBCGoiBzYCCCABIAEoAowBIgM2AgQgASABKAKIASIINgIAIAFB/ABqIRoLIAEgAzYCHCABIAg2AhggAUHwAGogCCADICMQ4AkgASgCeCENIAEoAnQhCyAGQShqIQUjAEEQayIEJAACQAJAQfgAQQgQrTYiAwRAIANCADcDYCADQgA3AwggA0KBgICAEDcDACADQQE7AXQgA0F/NgJwIANB6ABqQgA3AwAgBEEEahDrOkEgQQQQrTYiCEUNASAIIAM2AgggCEKBgICAEDcCACAIIAQpAgQ3AgwgCCADQQhqIgM2AhwgCCADNgIYIAhBFGogBEEMaigCADYCACAFQQA6AAggBUEANgIEIAUgCDYCACAEQRBqJAAMAgtBCEH4ABCjPQALQQRBIBCjPQALIAZBIGpCADcDACAGQQA2AjwgBkKAgICAgAE3AjQgBkIANwMYIAZBCjYCVCAGQQA6AFAgBiAJNgJMIAYgBzYCSCAGIAs2AkAgBiALIA1BBHRqNgJEIAFBIGogBkEYakHAAPwKAAAgAUEANgJoIAFCgICAgMAANwNgCyAGQdgAaiEPIwBBMGsiCyQAIAFBIGoiCUFAayEXIAtBHGohGyALQSBqIRwCQANAAkAgC0EYaiERIwBBwAFrIg0kACAJQRBqIQcgCUEoaiEIIA1BEGohEANAAkAgCSgCPCAJKAIUIgMEfyAHKAIAKAIIQQhqIQQDQCADKAJYIARGDQALIAMoAmAFQQALIAkoAiRqTQ0AIA1BCGohDiMAQaABayIKJAACQCAILQAQRQRAIApB0ABqIQVCACEjQgAhJCMAQdAAayIEJAACQAJAIAgiAygCACIMIAMoAgRGBH5CAAUgAyAMQRBqNgIAIAwpAwAhIyAMKQMIISQgBEHEAGogAygCCBDdICADKAIMKAIAIgMgAygCACIMQQFqNgIAIAxBAEgNASAEQRhqIARBzABqKAIANgIAIAQgBCkCRDcDEEIBCyElIAUgJDcDECAFICM3AwggBSAlNwMAIAVBGGogBEEgakEk/AoAACAFIAM2AjwgBUEAOgBMIAUgBCkDEDcDQCAFQcgAaiAEQRhqKAIANgIAIAUgBC8ADTsATSAFQc8AaiAEQQ9qLQAAOgAAIARB0ABqJAAMAQsACyAKKQNQIiNCAlEEQCAOQgI3AwAMAgsgCkEIaiAKQdgAakHIAPwKAAAgI1AEQCAIQQE6ABALIA4gIzcDACAOQQhqIApBCGpByAD8CgAADAELIA5CADcDAAsgCkGgAWokACANKQMIIiNCAlEgI6dBAXFFcg0AIA1B8ABqIgQgEEHIAPwKAAAgCSAJKQMAIiNCAXw3AwAgDSAjNwO4ASAHKAIAKAIIIQUgBxCNJCEKAkBB+ABBCBCtNiIDBEAgA0IBNwMIIANCgYCAgBA3AwAgA0EQaiAEQdAA/AoAACADQQE7AXQgAyAKNgJwIANBADYCbCADQgA3AmQgAyAFQQhqNgJgIAdBADoACCAHKAIEIQQgByADQQhqIgU2AgQCQCAERQRAIANBADYCYCADQQE2AmgMAQsgBygCACgCCEEIaiEKA0AgBCgCWCAKRg0ACyAEKAJgIQogAyAENgJgIAMgCkEBajYCaCAEIAU2AlwLIANBADYCbCAHKAIAIgMoAhggAyAFNgIYIAU2AmQMAQtBCEH4ABCjPQALDAELCyANQdgAaiEOIwBB4ABrIgMkACAJQRxqIR0CQAJAIAkoAiQEQCAJKAIgKQMYIiMgCSkDCFENAQsgCUEQaiEIIANBIGpBBHIhFCADQQRyIRUDQEEAIRhBACEZQQAhHiMAQUBqIgckACAIKAIEIgQEQCAIKAIAKAIIQQhqIQUDQCAEKAJYIAVGDQALIAQoAmAhGAsgCCgCACIEQQxqIAIoAgAiFhCLFANAAkAgByAEQQhqEM0ZAkACQAJAAkACQCAHKAIAIgQEQCAEQQJrDQEgFigCBCAWKAIAKAIIEQMAIANBCjYCAAwDCyAHKAIEIgQoAgBFBEAgByAEQQhrIgQ2AgggBCAEKAIAIgRBAWs2AgAgBEEBRw0FIAdBCGoQtx8MBQsgCCAEEIsdIgotAHQgCkEAOgB0RQ0DIApBADoAdSAHIApBCGoiHzYCLCAHQeiAwwA2AiggB0EANgI4IAcgB0EoaiIFNgI0IAcgBTYCMCAHQQhqIRAgB0EwaiEgIwBBQGoiBSQAIARBCGoiBCkDSCEjAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQtAERBAWsOAwUBAAILAkACQCAELQAwQQFrDgMLAgABCyAEKAIsIRIMBAsgBCgCKCETDAILAAsgBUEYaiIMIARBQGsoAgA2AgAgBSAEKQI4NwMQIAQoAjQhEyAFQRxqIAQpAwAiJCAEKQMIICR9ENgfIARBADoAMCAEIBM2AiggBEEgaiAFQSBqKQMANwIAIARBGGogDCkDADcCACAEIAUpAxA3AhALIAVBMGoiISAEQRhqKAIANgIAIAVBPGogBEEkaigCADYCACAFIAQpAxA3AyggBSAEKQIcNwI0IAVBCGoQziIgBSgCDCESIAUoAgghIkGwB0EIEK02IgxFDQUgDCAFKQMoNwMAIAxBADoAICAMICI2AhwgDCATNgIYIAxBEGogBUE4aikDADcDACAMQQhqICEpAwA3AwAgDEHIpMMAENQaIAQgEjYCLAsgBUEoaiITIBJBCGogIBCoFCAFKAIoDQEgBSkCNCEkIAUoAjAhEiAFKAIsIQwgBEEsahCuLCAMDQJB4KbDAEErIBNBrKfDAEG8usMAENUeAAtB3LjDABDoKwALIARBAzoARCAEQQM6ADAgEEEJNgIADAELIARBAToARCAEQQE6ADAgECAjNwMYIBAgJDcCDCAQIBI2AgggECAMNgIEIBBBCDYCAAsgBUFAayQADAILQQhBsAcQoz0AC0GsusMAEOgrAAsgBygCCEEJRw0BIAgoAgQhBCAIIB82AgQgGSAKLQB1QQBHaiEZAkAgBEUEQCAKQQA2AmAgCkEBNgJoDAELIAgoAgAoAghBCGohBQNAIAQoAlggBUYNAAsgBCgCYCEFIAogBDYCYCAKIAVBAWo2AmggBCAfNgJcCyAZQQFNBEAgHkEBaiIeIBhHDQULIBYoAgQgFigCACgCCBEDACADQQo2AgAMAgsgCCgCBARAIANBCjYCAAwCCyADQQk2AgAgCEEBOgAIDAELIAMgBykDCDcDACADQRhqIAdBIGopAwA3AwAgA0EQaiAHQRhqKQMANwMAIANBCGogB0EQaikDADcDACAKEIgkCyAHQUBrJAAMAgtBm4DDAEEWQbSAwwAQnykACyAIKAIAIQQMAQsLAkACQAJAIAMoAgAiBEEJaw4CAQACCyAOQQo2AgAMBAsgDkEJNgIADAMLIBRBGGogFUEYaigCADYCACAUQRBqIBVBEGopAgA3AgAgFCAVKQIANwIAIBRBCGogFUEIaikCADcCACADIAQ2AiAgAykDOCIjIAkpAwhSBEAgHSADQSBqELkfDAELCyAOIAMpAyA3AwAgCSAjQgF8NwMIIA5BCGogA0EoaikDADcDACAOQRBqIANBMGopAwA3AwAMAQsgCSAjQgF8NwMIIANBQGsgHRCEFSAOQRBqIANB0ABqKQMANwMAIA5BCGogA0HIAGopAwA3AwAgDiADKQNANwMACyADQeAAaiQAAkACQAJAAkAgDSgCWEEJaw4CAgABCyARQQo2AgAMAgsgESANKQNYNwMAIBFBEGogDUHoAGopAwA3AwAgEUEIaiANQeAAaikDADcDAAwBCyARQQlBCiAJLQA4GzYCAAsgDUHAAWokACALKAIYIgNBCEcEQAJAAkAgA0EJaw4CAwEACyALQRBqIAtBLGooAgAiAjYCACALIAspAiQiIzcDCCALKQIcISQgD0EUaiACNgIAIA8gIzcCDCAPICQ3AgQgDyADNgIADAQLIA9BCTYCAAwDCyALQRBqIgMgHEEIaigCADYCACALIBwpAgA3AwggCygCHCIIRQ0AIBsgCykDCDcCACAbQQhqIAMoAgA2AgAgCyAINgIYIBcgC0EYahCFJAwBCwsgDyAXKQIANwIEIA9BDGogF0EIaigCADYCACAJQQA2AkggCUKAgICAwAA3A0AgD0EINgIACyALQTBqJAAgBigCWCICQQlGDQEgBkH4AGoiAyAGQeQAaigCADYCACAGIAYpAlw3A3AgBikDaCEjIAkQxCYgAkEIRg0CIAZBiAFqIAMoAgA2AgAgBiAGKQNwNwOAASABQfAAahDtOwwDC0G89MIAEOgrAAsgGkEDOgAAIABBCTYCAEEDDAILIAZBEGogAygCADYCACAGIAYpA3A3AwggASgCGCEDIAEoAhwhCCAGIAFB8ABqIgQ2AmAgBiADIAhBBHRqNgJcIAYgAzYCWCAGIAZBCGoiAzYCZCAGQYABaiAGQdgAahDVGiADENQnIAMQ7jsgBBDtOwsgAUEBOgB8IAEQoy0gAUGEAWoQ7TsgACACNgIAIAAgIzcDECAAIAYpA4ABNwIEIABBDGogBkGIAWooAgA2AgBBAQs6AJABIAZBkAFqJAAPC0Gs3sIAEOgrAAv7CwEKfyMAQTBrIgUkAAJAIAJFBEAgACABEKAdDAELIAVBADYCECAFQoCAgIDAADcCCAJAIAEoAggiBkUNACABKAIEIQEgBkEDdCEJA0AgAUEEai0AAEUEQCADIAEoAgAgCGoiCyACbiIGIAsgAiAGbEdqIAJsIgYgAyAGSRshDCAIIAggAnBrIQsgBSgCCCAHRgRAIAVBCGpBrIPNABCbKAsgBSgCDCAHQQN0aiIGIAw2AgQgBiALNgIAIAUgB0EBaiIHNgIQCyABKAIAIAhqIQggAUEIaiEBIAlBCGsiCQ0ACyAFKAIMIQwgBSAFQRRqNgIgIAdBAkkNACAHQRVPBEAgBUEgaiELIwBBgCBrIgEkAAJAQcCEPSAHIAdBwIQ9TxsiBiAHIAdBAXZrIgIgAiAGSRsiAkGBBE8EQCMAQRBrIgkkACAJQQRqIAJBAEEEQQgQoBggCSgCCCEGIAkoAgRBAUYEQCAGIAkoAgxBnJnPABD9LwALIAkoAgwhAiABQQA2AgggASACNgIEIAEgBjYCACAJQRBqJAAgDCAHIAEoAgQgASgCCCICQQN0aiABKAIAIAJrIAdBwQBJIAsQ+wkgAUEEQQgQ4B4MAQsgDCAHIAFBgAQgB0HBAEkgCxD7CQsgAUGAIGokAAwBCyAMIAcQ1RYLIAVBADYCHCAFQoCAgIDAADcCFCAFKAIMIQIgBSgCCCEMIAUoAhAiAQRAIAIgAUEDdGohCyACIQEDQCAFKAIcIgRBA3QhDSAFKAIYIQogAUEEaigCACEIIAEoAgAhBwJAAkACQCAERQ0AIAogDWoiBkEIRg0AIAcgBkEEayIGKAIAIglNDQEgBSgCFCAERgR/IAVBFGpBjIPNABCbKCAFKAIYBSAKCyANaiIGIAg2AgQgBiAHNgIAIAUgBEEBajYCHAwCCyAFKAIUIARGBH8gBUEUakGcg80AEJsoIAUoAhgFIAoLIA1qIgYgCDYCBCAGIAc2AgAgBSAEQQFqNgIcDAELIAYgCCAJIAggCUsbNgIACyABQQhqIgEgC0cNAAsLIAUgAjYCJCAFIAw2AiAgBUEgaiIBQQRBCBDgHiAFIAUoAhQ2AiggBSAFKAIYIgI2AiAgBSACNgIkIAUgAiAFKAIcQQN0ajYCLCAAIQIjAEEwayIEJAAgBEEYaiABKAIMIgkgASgCBCIIa0EDdkEAQQRBCBCgGCAEKAIcIQACQAJAIAQoAhhBAUcEQCAEQQA2AhQgBCAEKAIgNgIQIAQgADYCDCABKAIIIQwgASgCACELQQAhAANAAkACQAJAAkACQCAIIAlHBEAgCEEEaiEBIAgoAgAhCiAIQQhqIQggCiABKAIAIgFGDQYgASAKayENIAAgCkkgACAKS2tB/wFxDgICAwELIAQgCzYCHCAEIAw2AhggBEEYakEEQQgQ4B4gACADRwRAIAQoAhQiBiAEKAIMRgRAIARBDGpB+P/MABCbKAsgBCgCECAGQQN0aiIBQQE6AAQgASADIABrNgIAIAQgBkEBajYCFAsgAiAEKQIMNwIAIAJBCGogBEEUaigCADYCACAEQTBqJAAMCAsgBEEANgIoIARBATYCHCAEQZSAzQA2AhggBEIENwIgIARBGGpBnIDNABDvLAALIAQoAhQiCkEDdCEGIAQoAhAhACAKBEAgACAGakEIayIHDQILIAQoAgwgCkYEfyAEQQxqQayAzQAQmyggBCgCEAUgAAsgBmoiAEEAOgAEIAAgDTYCACAEIApBAWo2AhQMAgsgBCgCFCIHIAQoAgxGBEAgBEEMakHMgM0AEJsoCyAEKAIQIAdBA3RqIgZBAToABCAGIAogAGs2AgAgBCAHQQFqIgA2AhQgBCgCDCAARgRAIARBDGpB3IDNABCbKAsgBCgCECAAQQN0aiIAQQA6AAQgACANNgIAIAQgB0ECajYCFAwBCyAHKAIAIgYgDWoiACAGSQ0DIAcgADYCAAsgASEADAALAAsgACAEKAIgQej/zAAQ/S8AC0G8gM0AELI7AAsLIAVBMGokAAvuBQEBfyMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIEIAJBATYCDCACQeS8zQA2AgggAkIBNwIUIAJBhAE2AiQgAiACQSBqNgIQIAIgAkEEajYCICABKAIAIAEoAgQgAkEIahDLCgwHCyACIABBBGo2AgQgAkEBNgIMIAJB9LzNADYCCCACQgE3AhQgAkGEATYCJCACIAJBIGo2AhAgAiACQQRqNgIgIAEoAgAgASgCBCACQQhqEMsKDAYLIAIgAEEEajYCBCACQQE2AgwgAkGEvc0ANgIIIAJCATcCFCACQYQBNgIkIAIgAkEgajYCECACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMBQsgAiAAQQRqNgIEIAJBATYCDCACQZS9zQA2AgggAkIBNwIUIAJBhAE2AiQgAiACQSBqNgIQIAIgAkEEajYCICABKAIAIAEoAgQgAkEIahDLCgwECyACIABBBGo2AgAgAiAAQQhqNgIEIAJBAjYCDCACQbS9zQA2AgggAkICNwIUIAJB3AE2AiwgAkHcATYCJCACIAJBIGo2AhAgAiACQQRqNgIoIAIgAjYCICABKAIAIAEoAgQgAkEIahDLCgwDCyACIABBBGo2AgQgAkEBNgIMIAJB0L3NADYCCCACQgE3AhQgAkGlBDYCJCACIAJBIGo2AhAgAiACQQRqNgIgIAEoAgAgASgCBCACQQhqEMsKDAILIAIgAEEEajYCBCACQQE2AgwgAkHovc0ANgIIIAJCATcCFCACQdwBNgIkIAIgAkEgajYCECACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMAQsgAkECNgIMIAJBiL7NADYCCCACQgI3AhQgAkE8NgIsIAIgAEEQajYCKCACQTw2AiQgAiAAQQhqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCgsgAkEwaiQAC78FAgR/CH4jAEGQAWsiAyQAQoCAgICAgICAgH8hDAJAAn4CQAJAIAEoAgwoAhAgAkEEdGoiBSkDACIKIAUpAwgiC0KAgICAgICAgIB/hYRCAFIgASgCCCIFKAIAIgQoAgAiBikDCCIHIAYpAwAiCINCf1JyRQRAQgAhBwwBCyAHIAiEUA0DIANBEGogCiALIAggBxCDGSADIAMpAxAiCSADKQMYIgwgCCAHEKgeQgAgCiADKQMAIg59IAcgCINCf1EiBhshDUIAIAsgAykDCH0gCiAOVK19IAYbIQcgC0IAWQ0BCyAJIA0gBCgCCCIEKQMAWCAHIAQpAwgiCFcgByAIURutIgh9IQcgDCAIIAlWrX0MAQsgDCAJIA0gBCgCBCIEKQMAWiAHIAQpAwgiCFkgByAIURutfCIHIAlUrXwLIQkCQAJAIAACfyAHQoCAgIAIfCIIQoCAgIAQVCAJIAcgCFatfFBxRQRAIAUoAgQhASADIAs3A0ggAyAKNwNAIANBzJH/ADYCWCADQgQ3AmQgA0GEDDYCjAEgA0H0CzYChAEgAyABQQFqNgKAASADQbsHNgJ8IAMgATYCeCADQcwBNgJ0IANB+JH/ADYCcCADIANB8ABqNgJgIAMgA0FAazYCiAEgA0EENgJcIANBMGogA0HYAGoQmQ4gA0EoaiADQTxqKAIANgIAIAMgAykCNDcDIEGCgICAeCEFIAMoAjAMAQsgA0HwAGogB6ciBCAFKAIILQAAEOoPIAMoAnAiBUGTgICAeEYNASADQShqIANBgAFqKAIANgIAIAMgAykCeDcDICADKAJ0CzYCBCAAIAU2AgAgACADKQMgNwIIIABBEGogA0EoaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkECdGogBDYCAAsgA0GQAWokAA8LQcyP/wAQ4isAC9QEAgZ+BH8gACAAKAI4IAJqNgI4AkACQCAAKAI8IgtFBEAMAQtBBCEJAn5BCCALayIKIAIgAiAKSxsiDEEESQRAQQAhCUIADAELIAE1AAALIQMgDCAJQQFySwRAIAEgCWozAAAgCUEDdK2GIAOEIQMgCUECciEJCyAAIAApAzAgCSAMSQR+IAEgCWoxAAAgCUEDdK2GIAOEBSADCyALQQN0QThxrYaEIgM3AzAgAiAKTwRAIAAgACkDGCADhSIEIAApAwh8IgYgACkDECIFQg2JIAUgACkDAHwiBYUiB3wiCCAHQhGJhTcDECAAIAhCIIk3AwggACAGIARCEImFIgRCFYkgBCAFQiCJfCIEhTcDGCAAIAMgBIU3AwAMAQsgAiALaiEJDAELIAIgCmsiAkEHcSEJIAJBeHEiAiAKSwRAIAApAwghBCAAKQMQIQMgACkDGCEGIAApAwAhBQNAIAQgASAKaikAACIHIAaFIgR8IgYgAyAFfCIFIANCDYmFIgN8IgggA0IRiYUhAyAGIARCEImFIgRCFYkgBCAFQiCJfCIFhSEGIAhCIIkhBCAFIAeFIQUgCkEIaiIKIAJJDQALIAAgAzcDECAAIAY3AxggACAENwMIIAAgBTcDAAtBBCECAn4gCUEESQRAQQAhAkIADAELIAEgCmo1AAALIQMgCSACQQFySwRAIAEgCmogAmozAAAgAkEDdK2GIAOEIQMgAkECciECCyAAIAIgCUkEfiABIAIgCmpqMQAAIAJBA3SthiADhAUgAws3AzALIAAgCTYCPAuqBQICfwR+IwBBkAFrIgYkACAGIAQ3AxAgBiAFNwMYIAYgAjcDACAGIAM3AwggBkFAayACIAMgBCAFIAEoAgAiBykDACAHKQMIIAcpAxAgBykDGBCaCAJ+IAYtAEBBAUYEQCAGLQBBBEBCgICAgICAgICAfyEIQgAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBvIv/ABDvLAALIAYpA2ghCCAGKQNgIQkgBikDWCEKIAYpA1ALIQsgBkFAayACIAMgBCAFIAcpAwAgBykDCCAHKQMQIAcpAxgQmggCQCAGLQBAQQFGBEAgBi0AQQRAIAZBOGpCADcDACAGQTBqQgA3AwAgBkIANwMoIAZCADcDIAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakHMi/8AEO8sAAsgBiAGKQOIATcDOCAGIAYpA4ABNwMwIAYgBikDeDcDKCAGIAYpA3A3AyALIAZB2ABqQgA3AwAgBkHQAGpCADcDACAGQgA3A0ggBkIANwNAAkACQAJAIAYgBkFAaxD7GyIHQf8BcUECRyAHwEEATnFFBEAgBkEgaiABKAIIEPsbwEEATA0BDAILIAZBIGogASgCBBD7GyIBQf8BcUECRiABwEEASHINASAIIAkgC0IBfCIEIAogBFCtfCIChFCtfCIFIAlUrXwhCAwCCyALQgF9IQQgCiALUK19IQIgCSAKIAuEUK0iA30hBSAIIAMgCVatfSEIDAELIAkhBSALIQQgCiECCyAGQUBrIAQgAiAFIAgQ1iMgBigCQCEBIAYpA1ghAyAAIAYpA1AiAj4CBCAAIAEgAkKAgICACHwiBEKAgICAEFQgAyACIARWrXxQcXE2AgAgBkGQAWokAAvMBQEFfyMAQeAAayIFJAAgBSABIAIQ9RICfyAFKAIAIghFBEBBASEJIAEhCCACDAELQeTGhQEhCUEBIQcgBSgCBAshBiAFIAk2AgggBSAINgIQIAUgBjYCFCAFIAc2AgwCQAJAIAYgAyADIAZLGyAHaiIDRQ0AIAIgA00EQCACIANGDQEMAgsgASADaiwAAEG/f0wNAQsgBSADNgIcIAUgATYCGAJAAkACQAJAIARB/wFxRQRAIAVByABqIANBAEEBQQEQoBggBSgCTCECIAUoAkhBAUYNASAFKAJQIQQgAwRAIAQgASAD/AoAAAsgACADNgIIIAAgBDYCBCAAIAI2AgAMBAsgBMBBAEgNASAEQf8BcSICIAZPBEAgBUECNgJEIAVBjMeFATYCQCAFQQI2AjQgBUH8xoUBNgIwIAVBAzYCPCAFIAI7AVwgBUEANgJYIAVBxwI2AlQgBUHHAjYCTCAFIAVByABqNgI4IAUgBUEQajYCUCAFIAVBCGo2AkggACAFQTBqEJkODAQLIAMgAmshBCACIANHBEAgAiADSw0DIAEgBGosAABBv39MDQMLIAUgBDYCJCAFIAE2AiAgBSACNgIsIAUgASAEajYCKCAFQQI2AkwgBUG8x4UBNgJIIAVCAjcCVCAFQccCNgI8IAVBxwI2AjQgBSAFQTBqNgJQIAUgBUEoajYCOCAFIAVBIGo2AjAgACAFQcgAahCZDgwDCyACIAUoAlBBnMWFARD9LwALIAVBATYCXCAFQczHhQE2AlggBUEBNgJMIAVB5MOFATYCSCAFQQI2AlQgBUHHAjYCNCAFQQA2AjggBSADQQAgBGtB/wFxajsBPCAFIAVBMGo2AlAgBSAFQRhqNgIwIAAgBUHIAGoQmQ4MAQsgASADQQAgBEGcvYUBEKM2AAsgBUHgAGokAA8LIAEgAkEAIANB6MaFARCjNgAL+gQCCX8BfgJAAkACQAJAAkACQCAEIAdxIgwgA00EQCALKAIIIQ8gACgCLCETIAIgDGoiESADIAxrIhIQtx4hDSAMIA9qIhAgA08NASACIBBqLQAAIRAgC0EANgIMIAcgBigCACIUayIGIAdPDQQCQCADIAQgBnEiBiAPaiIOSwRAIBAgAiAOai0AAEYNAQwGCyAOIANB1MvOABDDIQALIAMgBkkNAiACIAZqIAMgBmsgESASIAgQ9AEiDkUNBCAOIAYgBRChLiIBIBMQ8jQhFSALIBQ2AhAgCyABNgIIIAsgFTcDACABIAxqIgEgA08NAyAAKAIEIgEgDUsEQCAAKAIAIA1BAnRqIAc2AgAMBgsgDSABQYTMzgAQwyEACyAMIANBpMvOABCvOwALIBAgA0G0y84AEMMhAAsgBiADQeTLzgAQrzsACyABIANB9MvOABDDIQALIAAoAgQiBiANTQRAIA0gBkGUzM4AEMMhAAsgACgCACANQQJ0aiIOKAIAIQwgDiAHNgIAAkAgAyAEIAxxIgQgD2oiD0sEQEEAIQ4gByAMayIMQQFrIAlPDQMgECACIA9qLQAARw0DIAMgBEkNASACIARqIAMgBGsgESASIAgQ9AEiAgRAIAIgBCAFEKEuIQAgCyAMNgIQIAsgADYCCCALIAAgDCATEIwtNwMADAMLAkAgAUUEQEEAIQMMAQsgASAAIBEgEiAIIAkgCiALEOkUIQMgACgCBCEGCyAGIA1LBEAgACgCACANQQJ0aiAHNgIAIAMPCyANIAZB5MzOABDDIQALIA8gA0GkzM4AEMMhAAsgBCADQbTMzgAQrzsAC0EBIQ4LIA4LlgcBDX8jAEEQayIFJAACQAJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBG2sODgQABgECCAkKDw8PDwsDDwsgAS0AAEEcRw0ODAQLIAEtAABBHkcNDQwDCyABLQAAQR9HDQwMAgsgAS0AAEEoRg0IDAsLIAEtAABBG0cNCgsgACgCBCIALQBIIAEoAgQiAS0ASEYNAQwHCyABLQAAQR1HDQggACgCBCABKAIERw0JIAAoAggiAC0ASCABKAIIIgEtAEhHDQkgAUEwaiEBIABBMGohAAwHCyABQTBqIQEgAEEwaiEADAYLIAEtAABBIEcNBiAAKAIIIgIgASgCCEcNBCABKAIEQQhqIQEgACgCBEEIaiEAQQAhAwNAAkAgAyIEIAJGBEAgAiEEDAELIAAoAgAiBi0ASCABKAIAIgctAEhHDQAgAUEEaiEBIABBBGohACAEQQFqIQMgBkEwaiAHQTBqEL8JDQELCyACIARNIQQMBwsgAS0AAEEhRw0FIAAtAAEgAS0AAUcNBiAAKAIIIgIgASgCCEcNBiAFIAAoAgRBCGoiADYCCCAFIAAgAkEDdGo2AgwjAEEQayIDJAAgAUEEaiIAKAIAQQhqIgkgACgCBEEDdGohCiAFQQhqIgYoAgAhASAGKAIEIQcDQCAHIAEiAEcEQCAGIAFBCGoiATYCACAALQAAIQQgAyAAQQRqIgI2AgQgAyAEOgAAIAMgCjYCDCADIAk2AggCfyADQQhqIggoAgAiBCAIKAIEIgtHBEAgAigCACIMQTBqIQ0gAy0AACEOA0AgCCAEIgJBCGoiBDYCAAJAIA4gAi0AAEcNACAMLQBIIAJBBGooAgAiAi0ASEcNACANIAJBMGoQvwlFDQBBAQwDCyAEIAtHDQALC0EACw0BCwsgA0EQaiQAIAAgB0YhBAwGCyABLQAAQSJHDQQgACgCBCABKAIEEL8JRQ0CIAEoAgghASAAKAIIIQAMAwsgAS0AAEEnRw0DIAAoAgQiAi0ASCABKAIEIgMtAEhHDQQgAkEwaiADQTBqEL8JRQ0EIAAtAAEgAS0AAUYhBAwECyAAKAIEIgItAEggASgCBCIDLQBIRw0DIAJBMGogA0EwahC/CUUNAyAAKAIIIgAtAEggASgCCCIBLQBIRw0DIAFBMGohASAAQTBqIQAMAQsLDAELIAAgARDMCCEECyAFQRBqJAAgBAvjBQEOfyMAQYABayIEJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0EIIAIbIgVB/wFxIgZFBEAgBEE4ahD+JyAEKAI8IQIgBCgCOCEDDAELIARB+ABqIAFBgIAEELkpIAQoAnwhAiAEKAJ4IQMgBkEBRw0BCyAEQTBqEP4nIAQoAjQhBiAEKAIwIQoMAQsgBEHwAGogAUGAgAQQuSkgBCgCdCEGIAQoAnAhCiAFQf8BcSIHQQJLDQELIARBKGoQ/icgBCgCLCELIAQoAighDAwBCyAEQegAaiABQYCABBC5KSAEKAJsIQsgBCgCaCEMIAdBA0cNAQsgBEEgahD+JyAEKAIkIQcgBCgCICENDAELIARB4ABqIAFBgIAEELkpIAQoAmQhByAEKAJgIQ0gBUH/AXEiCEEESw0BCyAEQRhqEP4nIAQoAhwhDiAEKAIYIQ8MAQsgBEHYAGogAUGAgAQQuSkgBCgCXCEOIAQoAlghDyAIQQVHDQELIARBEGoQ/icgBCgCFCEIIAQoAhAhEAwBCyAEQdAAaiABQYCABBC5KSAEKAJUIQggBCgCUCEQIAVB/wFxIglBBksNAQsgBEEIahD+JyAEKAIMIQUgBCgCCCERDAELIARByABqIAFBgIAEELkpIAQoAkwhBSAEKAJIIREgCUEHRw0BCyAEEP4nIAQoAgAhCSAEKAIEDAELIARBQGsgAUGAgAQQuSkgBCgCQCEJIAQoAkQLIQEgAEIANwN4IAAgCTYCcCAAQgA3A2ggACAFNgJkIAAgETYCYCAAQgA3A1ggACAINgJUIAAgEDYCUCAAQgA3A0ggACAONgJEIAAgDzYCQCAAQgA3AzggACAHNgI0IAAgDTYCMCAAQgA3AyggACALNgIkIAAgDDYCICAAQgA3AxggACAGNgIUIAAgCjYCECAAQgA3AwggACACNgIEIAAgAzYCACAAIAE2AnQgBEGAAWokAAuXBQIIfwF+IwBBIGsiAiQAAkACQAJAAkAgASgCTEEBaiIDIAEoAjBPBEAgAkEQaiIEIAFBCGoiAxClGCACKAIQRQRAIARBJUEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0FIAIoAhgiA0GCo80AQSX8CgAAIAAgA61CgICAgNAEhDcDCCAAIAE2AgQgAEECNgIADAQLIAIpAxgiCkIBiEIAIApCAYN9hSIKQoCAgIAIfEKAgICAEFoEQCACQRBqQRVBAEEBQQEQoBggAigCFCEDIAIoAhBBAUYNAiACKAIYIgFBDWpBtKPNACkAADcAACABQQhqQa+jzQApAAA3AAAgAUGno80AKQAANwAAIABBFTYCDCAAIAE2AgggACADNgIEIABBADYCAAwECyABQQA2AjAgASAKPgJEIAMgAUEoaiIFIAEoAjwQ/h8gASgCOCEDIAEoAiAgASgCJCEEIAJBCGogBRD0LyAEQQN2aiAEQQdxQQBHaiEFIAIoAggiBCACKAIMIgdGDQIDQAJ/IAMEQCAELQAADAELIARBADoAAEEACyADIAEoAkAiCGsiCUEAIAMgCU8bIQMgCGxBA3YgBWohBSAEQQFqIgQgB0cNAAsMAgsgASADNgJMIABBCDYCACABIAEoAkA2AlAMAgsgAyACKAIYQdT9zAAQ/S8ACyABIAU2AkggASgCMCABKAI8RgRAIAFBADYCTCAAQQg2AgAgASABKAJANgJQDAELIAJBEGpBIkEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0BIAIoAhgiA0Hgos0AQSL8CgAAIABBIjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEgaiQADwsgASACKAIYQdT9zAAQ/S8AC78FAgh/AX4gASgCyAEhDCABKALQASEHAn9BASABKAAQIAEoAAxJDQAaQQAgASgCtAEiCUUNABpBA0ECIAkoAmwbCyIJQShsIAdBAnRqQbD00ABqIgggCCAJQQxsIAdBA2siB0ECdGpB0PXQAGogBEEBRxsgB0ECSxsoAgAhCiABKALQAUEGTQRAIAUgBmoiDUEgayEEIANBBGohDgNAIA0gBWshBgJAAkAgACgCBCIHIAAoAgxPIAUgDU9yDQAgACgCACAHQQxsaiIIKAIAIQkCQCAIKAIIIgsgCCgCBCIIaiAGTQRAIAAgB0EBajYCBAwBCyAAIAYgDBCoGCAGIAhNDQEgCUEAIAYgCGsiCyAMTxshCQsgCUUNACABIAUQsikgASAFENQsIAEgAiADIAUgCCAKEQkAIQcgAykCACEPIAMgCTYCACAOIA83AgAgBSAIaiIIIAdrIQUgAigCDCEGIAQgCE8EQCAFKQAAIQ8gBkEIaiAFQQhqKQAANwAAIAYgDzcAACAHQRFJDQIgAigCDEEQaiAFQRBqIAdBEGsQ2BkMAgsgBCAFTwRAIAYgBSAEIAVrIgUQ2BkgBSAGaiEGIAQhBQsDQCAFIAhPDQIgBiAFLQAAOgAAIAZBAWohBiAFQQFqIQUMAAsACyABIAUQsikgASAFENQsIAEgAiADIAUgBiAKEQkADwsgCUEDaiEGIAIgAigCDCAHajYCDAJAIAdB//8DTQRAIAIoAgQhBQwBCyACQQE2AiQgAiACKAIEIgUgAigCAGtBA3U2AigLIAUgBjYCACAFIAc7AQQgC0EDayIGQYCABE8EQCACQQI2AiQgAiAFIAIoAgBrQQN1NgIoCyAFIAY7AQYgAiAFQQhqNgIEIAggC2ohBQwACwALIAEgADYC1AEgASACIAMgBSAGIAoRCQAgACAGEIgfC4MGAgF/AXwjAEEwayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDhEBAgMEBQYHCAkKCwwNDg8QEQALIAIgAC0AAToACCACQQI2AhQgAkHYpYkBNgIQIAJCATcCHCACQcgLNgIsIAIgAkEoajYCGCACIAJBCGo2AiggASgCACABKAIEIAJBEGoQywoMEQsgAiAAKQMINwMIIAJBAjYCFCACQfSliQE2AhAgAkIBNwIcIAJBPDYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDBALIAIgACkDCDcDCCACQQI2AhQgAkH0pYkBNgIQIAJCATcCHCACQe4GNgIsIAIgAkEoajYCGCACIAJBCGo2AiggASgCACABKAIEIAJBEGoQywoMDwsgACsDCCEDIAJBAjYCFCACQZSmiQE2AhAgAkIBNwIcIAJB7B02AgwgAiADOQMoIAIgAkEIajYCGCACIAJBKGo2AgggASgCACABKAIEIAJBEGoQywoMDgsgAiAAKAIENgIIIAJBAjYCFCACQbCmiQE2AhAgAkIBNwIcIAJB7xs2AiwgAiACQShqNgIYIAIgAkEIajYCKCABKAIAIAEoAgQgAkEQahDLCgwNCyACIAApAgQ3AgggAkEBNgIUIAJByKaJATYCECACQgE3AhwgAkHEDTYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDAwLIAFBxKWJAUEKEPs1DAsLIAFB0KaJAUEKEPs1DAoLIAFB2qaJAUEMEPs1DAkLIAFB5qaJAUEOEPs1DAgLIAFB9KaJAUEIEPs1DAcLIAFB/KaJAUEDEPs1DAYLIAFB/6aJAUEEEPs1DAULIAFBg6eJAUEMEPs1DAQLIAFBj6eJAUEPEPs1DAMLIAFBnqeJAUENEPs1DAILIAFBq6eJAUEOEPs1DAELIAEgACgCBCAAKAIIEPs1CyACQTBqJAAL0wcCCH8BfiMAQdAAayIDJAACQAJAAkACQAJAAkACQAJAAkACQCABLQAUQQFrDgQEAAMBAgsACyABKAIkIQQMBAsgAUIANwMYIAEgASgCEDYCKCABIAEpAwA3AyALIANBEGohBSMAQRBrIgYkAAJAIAFBGGoiCCIEKQMAQgNSBEAgBiAEKAIQEN0eIAYoAgAiB0ECRgRAIAVBAjYCAAwCCyAHQQFxBEAgBSAGKQIENwIEIAVBATYCAAwCCyAEKQMAIQsgBCgCECIHIAQpAwg3AwggByALNwMAIARCAzcDACAFIAQoAhAQ3R4MAQsgBSAEKAIQEN0eCyAGQRBqJAAgAygCECIEQQJHDQEgAEEJNgIAQQMhAAwFC0HQ+sIAEOgrAAsgBEEBcQRAIAMgAykCFDcDECADQThqIANBEGoQgSsMAgsgASABKQMIIAEpAwB9Igs3AzggC0KAgICAEFoEQCADQThqENskDAILIANBEGogC6dBAEEBQQEQoBggAygCFCEEIAMoAhBBAUYNAiADKAIYIQUgAUEANgIgIAEgBTYCHCABIAQ2AhggAUEANgI0IAEgBDYCMCABQQA2AiwgASAINgIoIAEgAUFAayIENgIkIAEgASgCEDYCSCABIAEpAzg3A0ALIANBEGohBiMAQRBrIgUkACABQTRqIgcoAgAhCCAFQQhqIAFBKGoiCiAEIAIQ/wgCQCAFLQAIIglBBUcEQANAIAlBBEcEQCAGIAUpAwg3AgAMAwsgBSgCDCIJRQRAIAYgCDYCBCAGQQQ6AAAgB0EANgIADAMLIAcgCCAJaiIINgIAIAVBCGogCiAEIAIQ/wggBS0ACCIJQQVHDQALCyAGQQU6AAALIAVBEGokACADLQAQQQVGBEAgAEEJNgIAQQQhAAwDCwJAIAMpAxAiC0L/AYNCBFIEQCADIAs3AxAgA0E4aiADQRBqEIErDAELIAMgC0IgiCILPgIMIAsgASkDOFEEQCADQRhqIAFBIGooAgA2AgAgAyABKQIYNwMQIANBOGpBBHIgA0EQahDnFSADQQg2AjgMAgsgA0ECNgIUIANBkPvCADYCECADQgI3AhwgA0E7NgI0IANBPDYCLCADIAFBOGo2AiggAyADQShqNgIYIAMgA0EMajYCMCADQThqQQRyIANBEGoQmQ4gA0ECNgI4CyABQRhqEN47CyAAIAMpAzg3AwAgAEEQaiADQcgAaikDADcDACAAQQhqIANBQGspAwA3AwBBASEADAELIAQgAygCGEHg+sIAEP0vAAsgASAAOgAUIANB0ABqJAAL7AUCCn8BfiAAKAIAIQUgACgCBEEBaiIIQQN2IAhBB3FBAEdqIgkEQCAFIQQDQCAEIAQpAwAiDkJ/hUIHiEKBgoSIkKDAgAGDIA5C//79+/fv37//AIR8NwMAIARBCGohBCAJQQFrIgkNAAsLIAACfwJAIAhBCE8EQCAFIAhqIAUpAAA3AAAMAQsgCARAIAVBCGogBSAI/AoAAAsgCA0AQQAMAQsgAigCFCENQQEhAkEAIQkDQCAJIQUgAiEJAkAgBSAAKAIAIgJqLQAAQYABRw0AIAIgAyAFQX9zbGohCwNAIAEgACAFIA0RDQAhDiAAKAIEIgYgDqciDHEiByECIAAoAgAiBCAHaikAAEKAgYKEiJCgwIB/gyIOUARAQQghCgNAIAIgCmohAiAKQQhqIQogBCACIAZxIgJqKQAAQoCBgoSIkKDAgH+DIg5QDQALCyAEIA56p0EDdiACaiAGcSICaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiECCyACIAdrIAUgB2tzIAZxQQhPBEAgAiAEaiIHLQAAIAcgDEEZdiIHOgAAIAAoAgAgAkEIayAGcWpBCGogBzoAACAEIAMgAkF/c2xqIQJB/wFGBEAgACgCBCEEIAAoAgAgBWpB/wE6AAAgACgCACAEIAVBCGtxakEIakH/AToAACADRQ0DIAIgCyAD/AoAAAwDCyALIAIgA0ECdhD6KgJAIANBA3EiBkUNACACIANB/ABxIgRqIQIgBCALaiEEIAQgBkEBRgR/QQAFIAQvAAAhBiAEIAIvAAA7AAAgAiAGOwAAIANBAXFFDQFBAgsiBmoiBC0AACEHIAQgAiAGaiICLQAAOgAAIAIgBzoAAAsMAQsLIAQgBWogDEEZdiICOgAAIAAoAgAgBiAFQQhrcWpBCGogAjoAAAsgCSAIIAlLIgVqIQIgBQ0ACyAAKAIEIgEgAUEBakEDdkEHbCABQQhJGwsgACgCDGs2AggLwwUCBX8GfiMAQZABayIDJAAgASgCCCIFKAIAIQYgA0HwAGoiByABKAIMKAIQIAJBBXRqIgQpAwAiCiAEKQMIIgsgBCkDECIMIAQpAxgiDRDWIwJAAkAgAAJ/AkAgAygCcEEBcUUNACADKQOAASIIQoCAgIAIfCIJQv////8PViADKQOIASAIIAlWrXwiCUIAUiAJUBsNACADIAYoAgAoAgAiBDYCCCADIAg+AhgCQCAErCAIxH4iCEIgiKcgCKciBEEfdUcEQCADQQI2AnQgA0GskP8ANgJwIANCAjcCfCADQYIMNgIoIANBggw2AiAgAyADQRxqNgJ4IAMgA0EIajYCJCADIANBGGo2AhwgA0E0aiAHEJkOIANB4ABqIANBOGopAgA3AwAgA0HoAGogA0FAaygCADYCACADQYiAgIB4NgIwIAMgAykCMCIINwNYIAinQZOAgIB4Rw0BIAMoAlwhBAsgA0HwAGogBCAFKAIILQAAEOoPIAMoAnAiBUGTgICAeEYNAyADQRBqIANBgAFqKAIANgIAIAMgAykCeDcDCCADKAJ0DAILIANB2ABqEIgRCyAFKAIEIQEgAyANNwNIIAMgDDcDQCADIAs3AzggAyAKNwMwIANBzJH/ADYCWCADQgQ3AmQgA0GDDDYCjAEgA0H0CzYChAEgAyABQQFqNgKAASADQbsHNgJ8IAMgATYCeCADQcwBNgJ0IANB+JH/ADYCcCADIANB8ABqNgJgIAMgA0EwajYCiAEgA0EENgJcIANBIGogA0HYAGoQmQ4gA0EQaiADQSxqKAIANgIAIAMgAykCJDcDCEGCgICAeCEFIAMoAiALNgIEIAAgBTYCACAAIAMpAwg3AgggAEEQaiADQRBqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIACyADQZABaiQAC+sFAgp/AX4gACgCACEFIAAoAgRBAWoiCEEDdiAIQQdxQQBHaiIJBEAgBSEEA0AgBCAEKQMAIg5Cf4VCB4hCgYKEiJCgwIABgyAOQv/+/fv379+//wCEfDcDACAEQQhqIQQgCUEBayIJDQALCyAAAn8CQCAIQQhPBEAgBSAIaiAFKQAANwAADAELIAgEQCAFQQhqIAUgCPwKAAALIAgNAEEADAELIAIoAhQhDUEBIQJBACEJA0AgCSEFIAIhCQJAIAUgACgCACICai0AAEGAAUcNACACIAMgBUF/c2xqIQsDQCABIAAgBSANEQ0AIQ4gACgCBCIGIA6nIgxxIgchAiAAKAIAIgQgB2opAABCgIGChIiQoMCAf4MiDlAEQEEIIQoDQCACIApqIQIgCkEIaiEKIAQgAiAGcSICaikAAEKAgYKEiJCgwIB/gyIOUA0ACwsgBCAOeqdBA3YgAmogBnEiAmosAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhAgsgAiAHayAFIAdrcyAGcUEITwRAIAIgBGoiBy0AACAHIAxBGXYiBzoAACAAKAIAIAJBCGsgBnFqQQhqIAc6AAAgBCADIAJBf3NsaiECQf8BRgRAIAAoAgQhBCAAKAIAIAVqQf8BOgAAIAAoAgAgBCAFQQhrcWpBCGpB/wE6AAAgA0UNAyACIAsgA/wKAAAMAwsgCyACIANBAnYQ+ioCQCADQQNxIgZFDQAgAiADQTxxIgRqIQIgBCALaiEEIAQgBkEBRgR/QQAFIAQvAAAhBiAEIAIvAAA7AAAgAiAGOwAAIANBAXFFDQFBAgsiBmoiBC0AACEHIAQgAiAGaiICLQAAOgAAIAIgBzoAAAsMAQsLIAQgBWogDEEZdiICOgAAIAAoAgAgBiAFQQhrcWpBCGogAjoAAAsgCSAIIAlLIgVqIQIgBQ0ACyAAKAIEIgEgAUEBakEDdkEHbCABQQhJGwsgACgCDGs2AggLzAQCCH8IfiMAQfAAayIGJAACQCABIANqIgMgACgCCCIHTQRAIAAgAzYCCAwBCyAAIAMgB2sQix8LIAYgBCAFEOAcIAZCADcDaCAGIAE2AmAgBiABIAJqIgIiAzYCZAJAAkACQCABIANPDQAgAkEDdEEIayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQN0aiADIAVqKQMANwMAIAVBCGshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAvMBAIIfwh+IwBB8ABrIgYkAAJAIAEgA2oiAyAAKAIIIgdNBEAgACADNgIIDAELIAAgAyAHaxDMGgsgBiAEIAUQ4BwgBkIANwNoIAYgATYCYCAGIAEgAmoiAiIDNgJkAkACQAJAIAEgA08NACACQQF0QQJrIQUgBigCWCEKIAYpAyAhECAGKAJUIQggBigCUCEHIAYpA0AhDiAGKQMwIREgBigCECELIAYpAwghDyAGKAIoIQwgBigCGCENIAYpA0ghEyAGKQM4IRQgBikDACESA0AgEqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIA9QRQ0BQgAhD0IAIRJBASECDAQLAn4CQCARQgJ9IhVCAVgEQCAVp0EBaw0BDAULIBGnIBFQrUIBhiERQQFxRQ0AIBQMAQsgDkIDUQRAQgMhDgwECyAHRSAHIAhGckUEQCAIQQhrIggpAwAMAQtBACEHIA5CAlEEQEICIQ4MBAsgDqdCACEOQQFxRQ0DIBMLIQ9CASESIApBQGoiCiELDAELIAsgD3mnQT9zIgRqIQJCASAErYYgD4UhDwwDC0EAIQIMAQsLIA0gEEIAUnFFDQIgDCAQeadBP3MiBGohAkIBIASthiAQhSEQCyACIANBAWsiBE0NASAEIAAoAggiCU8NAiACIAlPDQMgACgCBCIDIAJBAXRqIAMgBWovAQA7AQAgBUECayEFIAQiAyABSw0ACwsgBkHwAGokAA8LIANBAWsgCUGwms8AEMMhAAsgAiAJQcCazwAQwyEAC88EAQp/IwBBMGsiASQAIAAoAiQhAyABIAAoAjwgACgCQCICKAIIQQFrQXhxakEIaiACKAI4EQAAIAEoAgAhAgJAAkACQCADBEAgAkUNASABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIDQQJPBEAgACgCHCEFIANBAXYhByAAKAIwIQMgACgCKCEGIAAoAjQhACABKAIkIQggASgCHCEJIAEoAighCgNAIABFDQVBASEEIAYgA0EDdmotAAAgA0EHcXZBAXEEQCAKIAUvAQAiBE0NBiAJIAQgCGoiBEEDdmotAABB/wFzIARBB3F2QQFxIQQLIAVBAmohBSAAQQFrIQAgA0EBaiEDIAIgBGohAiAHQQFrIgcNAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBGGoQ+x4MAgsgAkUEQEEAIQIMAgsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiBUECTwRAIAAoAhwhAyAFQQF2IQAgASgCJCEFIAEoAhwhByABKAIoIQQDQCAEIAMvAQAiBk0NBCACIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQIgA0ECaiEDIABBAWsiAA0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAKAI4IQIMAAsgAUEwaiQAIAIPC0Hk5oQBQSBBhOeEARCfKQALzwQBCn8jAEEwayIBJAAgACgCJCEDIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAIAMEQCACRQ0BIAFBKGogAUEQaikCADcDACABQSBqIAFBCGopAgA3AwAgASABKQIANwMYQQAhAiAAKAIgIgNBAk8EQCAAKAIcIQUgA0EBdiEHIAAoAjAhAyAAKAIoIQYgACgCNCEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgAEUNBUEBIQQgBiADQQN2ai0AACADQQdxdkEBcQRAIAogBS4BACIETQ0GIAkgBCAIaiIEQQN2ai0AAEH/AXMgBEEHcXZBAXEhBAsgBUECaiEFIABBAWshACADQQFqIQMgAiAEaiECIAdBAWsiBw0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQIgAUEYahD7HgwCCyACRQRAQQAhAgwCCyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIFQQJPBEAgACgCHCEDIAVBAXYhACABKAIkIQUgASgCHCEHIAEoAighBANAIAQgAy4BACIGTQ0EIAIgByAFIAZqIgZBA3ZqLQAAQf8BcyAGQQdxdkEBcWohAiADQQJqIQMgAEEBayIADQALCyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAoAjghAgwACyABQTBqJAAgAg8LQeTmhAFBIEGE54QBEJ8pAAvPBAEKfyMAQTBrIgEkACAAKAIkIQMgASAAKAI8IAAoAkAiAigCCEEBa0F4cWpBCGogAigCOBEAACABKAIAIQICQAJAAkAgAwRAIAJFDQEgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiA0EETwRAIAAoAhwhBSADQQJ2IQcgACgCMCEDIAAoAighBiAAKAI0IQAgASgCJCEIIAEoAhwhCSABKAIoIQoDQCAARQ0FQQEhBCAGIANBA3ZqLQAAIANBB3F2QQFxBEAgBSgCACIEIApPDQYgCSAEIAhqIgRBA3ZqLQAAQf8BcyAEQQdxdkEBcSEECyAFQQRqIQUgAEEBayEAIANBAWohAyACIARqIQIgB0EBayIHDQALCyABKAIYIgAgACgCACIAQQFrNgIAIABBAUcNAiABQRhqEPseDAILIAJFBEBBACECDAILIAFBKGogAUEQaikCADcDACABQSBqIAFBCGopAgA3AwAgASABKQIANwMYQQAhAiAAKAIgIgVBBE8EQCAAKAIcIQMgBUECdiEAIAEoAiQhBSABKAIcIQcgASgCKCEEA0AgAygCACIGIARPDQQgAiAHIAUgBmoiBkEDdmotAABB/wFzIAZBB3F2QQFxaiECIANBBGohAyAAQQFrIgANAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0BIAFBGGoQ+x4MAQsgACgCOCECDAALIAFBMGokACACDwtB5OaEAUEgQYTnhAEQnykAC88EAQp/IwBBMGsiASQAIAAoAiQhAyABIAAoAjwgACgCQCICKAIIQQFrQXhxakEIaiACKAI4EQAAIAEoAgAhAgJAAkACQCADBEAgAkUNASABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGEEAIQIgACgCICIDQQhPBEAgACgCHCEFIANBA3YhByAAKAIwIQMgACgCKCEGIAAoAjQhACABKAIkIQggASgCHCEJIAEoAighCgNAIABFDQVBASEEIAYgA0EDdmotAAAgA0EHcXZBAXEEQCAKIAUoAgAiBE0NBiAJIAQgCGoiBEEDdmotAABB/wFzIARBB3F2QQFxIQQLIAVBCGohBSAAQQFrIQAgA0EBaiEDIAIgBGohAiAHQQFrIgcNAAsLIAEoAhgiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAFBGGoQ+x4MAgsgAkUEQEEAIQIMAgsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxhBACECIAAoAiAiBUEITwRAIAAoAhwhAyAFQQN2IQAgASgCJCEFIAEoAhwhByABKAIoIQQDQCAEIAMoAgAiBk0NBCACIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQIgA0EIaiEDIABBAWsiAA0ACwsgASgCGCIAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAKAI4IQIMAAsgAUEwaiQAIAIPC0Hk5oQBQSBBhOeEARCfKQAL/QQCBH4LfyMAQSBrIgokACABQRBqIgggAhD4CyEEIAEoAghFBEAgCiABQQEgCBCyAwsgASgCBCIJIASncSEIIARCGYgiBkL/AINCgYKEiJCgwIABfiEHIAIoAgghDyACKAIEIRAgASgCACEMA0ACfwJAAkACQCAIIAxqKQAAIgUgB4UiBEJ/hSAEQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgRQRQRAA0AgECAPIAEoAgBBACAEeqdBA3YgCGogCXFrIhFBGGxqIhJBFGsoAgAgEkEQaygCABDBLg0CIARCAX0gBIMiBFBFDQALCyAFQoCBgoSIkKDAgH+DIQQgDUUEQCAEUA0DIAR6p0EDdiAIaiAJcSELC0EBIAQgBUIBhoNQDQMaIAsgDGosAABBAE4EQCAMKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgASgCACIIIAtqIgktAAAhDCACQQhqKAIAIQ0gAikCACEEIAkgBqdB/wBxIgI6AAAgCCABKAIEIAtBCGtxakEIaiACOgAAIApBEGoiCSANNgIAIApBHGogA0EIaigCADYCACABIAEoAgxBAWo2AgwgCCALQWhsakEYayICIAQ3AgAgCiADKQIANwIUIAJBCGogCSkDADcCACACQRBqIApBGGopAwA3AgAgASABKAIIIAxBAXFrNgIIIABBgICAgHg2AgAMAQsgACABKAIAIBFBGGxqQQxrIgEpAgA3AgAgASADKQIANwIAIABBCGogAUEIaiIAKAIANgIAIAAgA0EIaigCADYCACACQQFBARDgHgsgCkEgaiQADwtBAAshDSAIIA5BCGoiDmogCXEhCAwACwALliICHH8DfiMAQRBrIhskACAAEPgOAkACQAJAIAAoAqwqIg1Bf0cEQCABQf8BcUEDRw0DIAIoAgAgDUYNAQwDCyABQf8BcUEDRw0BCyAAKAIoRQRAIABCgICAgAQgACkD6AEgACkD+AF9IicgJ0KAgICABFobPgIoCwJ/IwBBEGsiDyQAAkACQAJAAkACQAJAAkACQCACKAIAIg1BgICACEsNAAJAIAAoAugpIgFFBEAgAEEDNgLoKSAAIA02AqwqDAELIAFBA2tBAUsNAQsgAEHYKWohDANAIAAgBiAHIAggCSAKENsQDQAgACgCqCoiAUEARyELIAENASAAKQPoASAAKQPwAVEEQCAAKALoKUEDRgRAIABCATcDAEEAIRNCACEnIwBBEGsiASQAIAAoAqwqIREgASAAIAAoAsgBIAAoAswBIABB2ClqEOoeIAEoAgQhCyABKAIAIRIgASAALQC+KjYCDAJAIAsEQCASIAAtALgqOgAAAkACQAJAIAtBAUcEQCASIAAtALkqOgABIABBADoAviogAEEAOwG4KkEBQgAgAUEMaiIQIBIgCxDfE0ECQgMgECASIAsQ3xNBAUIAIBAgEiALEN8TIBEOAgEDAgtBAUEBQcjC0AAQwyEAC0ECQgAgAUEMaiASIAsQ3xMMAwsgEUEBayIRZ0EgakE4c0EIakEDdiETIBGtIScLQQIgE60gAUEMaiIRIBIgCxDfEyATQQN0ICcgESASIAsQ3xMMAQtBAEEAQbjC0AAQwyEACyABKAIMIAFBEGokAEEHakEDdiEBIABBBDYC6CkgACABNgKoKgwCCyAAKAKsKiIBRQRAIABBADYC6CkgAEF/NgKsKkEBIQsMAwsgBigCACITRQRAIABCATcDACAPIAAgACgCyAEgACgCzAEgDBDqHkEQIAEgAUEQTxsiASAPKAIEIg1LDQQgBSgCACINIAFqIgsgDUkNBSAEIAtJDQYgDygCACABIAMgDWogAUHYwNAAENUsIAAgATYCqCogBSAFKAIAIAFqNgIAIAIgAigCACABayINNgIAIAAgACgCrCogAWs2AqwqDAILIAkoAgAiESATIAEgASATSxsiAWoiCyARSQ0GIAggC0kNByAFKAIAIhAgAWoiEiAQSQ0IIAQgEkkNCSAHIBFqIAEgAyAQaiABQYjB0AAQ1SwgAiANIAFrIg02AgAgBSASNgIAIAkgCzYCACAGIBMgAWs2AgAgACAAKAKsKiABazYCrCoMAQsgD0EANgIMIABBAEEBIA9BDGoQvgEgACAPKAIMNgKoKg0ACwsgD0EQaiQAIAsMBwsgASANQbjA0AAQsDsACyANIAtByMDQABCxOwALIAsgBEHIwNAAELA7AAsgESALQejA0AAQsTsACyALIAhB6MDQABCwOwALIBAgEkH4wNAAELE7AAsgEiAEQfjA0AAQsDsACyESDAELIAAoAugpIg1BA2tBAkkNACANQQAgAigCACITGw0AAkAgACgCHEEBSw0AIAAtAFwNACMAQeAAayIMJAAgACgCICENIAIiESgCACEPIAxB0ABqEP4nIAwoAlQhAiAMKAJQIQsgDEHIAGoQ/ScgDCgCTCESIAwoAkghEAJAAkACQCAAKAIcIhlBAU0EQEEBIA10IRggGUEBRg0BIBAhDyACIQ0gCyETIBIhCwwCCyASBEAgECASQQEQ+DoLIAJFDQIgCyACQQJ0QQQQ+DoMAgsgACgC3AEiDSAYIA8gDyAYSxsiD0GAgAhJckUEQCAMQUBrIABBvipqIg1BgIAIELkpIAwoAkQhEyAMKAJAIRQgACgC3AEiDgRAIAAoAtgBIA5BAnRBBBD4OgsgACATNgLcASAAIBQ2AtgBIAxBOGogDUGAgAgQuCkgDCgCPCENIAwoAjghEyAAKALkASIUBEAgACgC4AEgFEEBEPg6CyAAIA02AuQBIAAgEzYC4AEgACgC3AEhDQsCQCANBEAgACgC2AEhEyAMQTBqEP4nIAwoAjAhDyAAIAwoAjQ2AtwBIAAgDzYC2AEgAgRAIAsgAkECdEEEEPg6CyAMQShqEP0nIAAoAuABIQ8gACAMKAIoNgLgASAAKALkASELIAAgDCgCLDYC5AEgEg0BDAILIAxBIGogAEG+KmoiFEGAgAggDyAPQYCACE8bIg8QuSkgDCgCJCENIAwoAiAhEyACBEAgCyACQQJ0QQQQ+DoLIAxBGGogFCAPELgpIAwoAhwhCyAMKAIYIQ8gEkUNAQsgECASQQEQ+DoLIABB0CVqISAgAEGkKmohISAAQdAjaiEiIABB0CJqISMgAEHQAWohJCAAQdACaiElIABBvipqIR0gAEHoKWohFSABQf8BcSIaQQFGIRIgGkECRiEQA0AgACAGIAcgCCAJIAoQ2xANAAJAAkACQAJAAkACQAJAAkACQAJAIAAoAqgqIAAoAugpckUEQCARKAIAIg4gGnINAQsgDUGAgAhGBEAgACgC3AFFDQILIBMgDRCAMSAdIA8gCxDgNSAVIAAoAqgqIAAQ3C4MCwsgDCAdLQAANgJYQQAhASAMQQA2AlxBACECAkAgDiAYSw0AQQEhFCAQIQEgEiECIBpBAUcNACAORQ0JCwJ/IA4gGCAOIBhJGyIWQQF0QfcDaiIeIAYoAgAiJksEQCAAIB4QyRogACgCyAEhFCAAKALMAQwBCyAIIAkoAgAiDkkNAiAHIA5qIRQgCCAOawsiF0UNAiAUIAAtALgqOgAAIBdBAUYNAyAUIAAtALkqOgABIAxBEGogJSAkIAAoAhwgFiAMQdwAahC8ECAFKAIAIQ4gDCgCFCEcIAwoAhAhHwJAIAAoAhxFBEAgBCAOSQ0GIAMgDmogBCAOayAWIAEgHyAcIAwoAlwgIyAiICEgICAMQdgAaiAUIBcQghcMAQsgBCAOSQ0GIAMgDmogBCAOayAWIAEgEyANIA8gCyAfIBwgDCgCXCAMQdgAaiAUIBcQ4QwLIAUgBSgCACAWajYCACARIBEoAgAgFms2AgAgDCgCWCIcQQN2IQ4gHiAmSwRAIAAgDjYCqCogAEIANwMADAgLIAkgCSgCACAOajYCACAGIAYoAgAgDms2AgAgACAAKQPQKSAOrXwiJzcD0CkgCigCAA0GDAcLIAxBCGoQ/icgDCgCDCEBIAwoAgggACgC3AEiAgRAIAAoAtgBIAJBAnRBBBD4OgsgAEGAgAg2AtwBIAAgEzYC2AEgDBD9JyAMKAIEIQIgDCgCACEEIAAoAuQBIgUEQCAAKALgASAFQQEQ+DoLIAAgCzYC5AEgACAPNgLgASAVIAAoAqgqIAAQ3C4gAgRAIAQgAkEBEPg6CyABRQ0JIAFBAnRBBBD4OgwJCyAOIAhByMHQABCvOwALQQBBAEHYwdAAEMMhAAtBAUEBQejB0AAQwyEACyAOIARB+MHQABCvOwALIA4gBEGIwtAAEK87AAsgCiAnPgIECwJAIA4gF0kEQCAXIA5BAWoiFksEQCAOIBRqLQAAIQ4gFCAWai0AACEUIAAgHEEHcToAviogACAOIBRBCHRyOwG4KiABIAJyDQIMBAsgFiAXQajC0AAQwyEACyAOIBdBmMLQABDDIQALQQJBASABGyEUCyAVIBQ2AgAMAAsACyAMQeAAaiQAIBlBAkkhEgwBCyAAQegpaiEaIAUoAgAhEiABQf8BcSEYA0AgE0UiASAYQQFGcSILIBhBAkYgAXEiDXIhD0ECQQEgDRshESATrSEnA0ACQCAAKQP4ASEoIAApA+gBISkgABD4DgJAQQEgACgCJHQiASApICh9Iiina0EAICggAa1UGyIBQQAgExtFBEAgACAGIAcgCCAJIAoQ2xANAyAAKAKoKiIQIBhFIAFBAEdxckUEQCAAKALoKUUNAgsgGiAQIAAQ3C5BASESDAULIAQgEkkNASAAEPgOIABBvipqIQsgAyASaiEUIAQgEmshDyATIAEgASATSxsiGSENAkACQAJAAkACQAJAAkAgAEHsKWoiASgCHCIWDQAgDSABKAIQTw0AIAEgDTYCHCALIA0gARCEDyABKAIgIgsgDWoiESALSQ0BIBEgASgCBCIQSw0CIA0gD0sNAyABKAIAIAtqIA0gFCANQcy40AAQ1SwMBgsgASgCFCIRIAEoAhhNBEAgASgCICERIAEoAgghFwwFCyALIBEgARCEDyABKAIIIhcgASgCICIRaiIMQQJrIhAgASgCBCILTwRAIBAgC0HcuNAAEMMhAAsgASgCACIOIBBqQQA6AAAgDEEBayIQIAtJDQMgECALQey40AAQwyEACyALIBFBrLjQABCxOwALIBEgEEGsuNAAELA7AAsgDSAPQby40AAQsDsACyAOIBBqQQA6AAAgASgCHCEWCyABKAIMIQ4CQAJAAkACQCABKAIQIgwgASgCDCABKAIccSILSwRAIAEoAiAgASgCCCALamoiECAMIAtrIgsgDSALIA1JGyILaiIMIBBJDQEgDCABKAIEIhVLDQIgCyAPSw0DIAEoAgAgEGogCyAUIAtB7LrQABDVLAsMAwsgECAMQcy60AAQsTsACyAMIBVBzLrQABCwOwALIAsgD0HcutAAELA7AAsgESAOIBZxIhVqIRACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBcgDSAVakkEQCABKAIUIBVrIgsgDSALIA1JGyIOIBBqIgwgDkkNAiAMIAEoAgQiC0sNAyAOIA9LDQQgECABKAIAIgxqIA4gFCAOQZy50AAQ1SwgDSAXIBVrIhBrIg4gEWoiFSAOSQ0FIAsgFUkNBiANIBBJDQcgDSAPSw0IIAwgEWogDiAQIBRqIA5BzLnQABDVLAwBCyANIBBqIgwgEEkNCCAMIAEoAgQiC0sNCSANIA9LDQogECABKAIAIgxqIA0gFCANQfy50AAQ1SwLIBEgF2oiFEECayIPIAtPDQogEUECayIQIAtPDQsgDCAQaiAMIA9qLQAAOgAAIBRBAWsiDyALTw0MAkAgCyARQQFrIhFLBEAgASANIBZqIg02AhwgDCARaiAMIA9qLQAAOgAAIA1BgICAgARLDQEMDwsgESALQby60AAQwyEACyABIA1B/////wNxQYCAgIAEcjYCHAwNCyAQIAxB/LjQABCxOwALIAwgC0H8uNAAELA7AAsgDiAPQYy50AAQsDsACyARIBVBrLnQABCxOwALIBUgC0GsudAAELA7AAsgECANQby50AAQsTsACyANIA9BvLnQABCwOwALIBAgDEHcudAAELE7AAsgDCALQdy50AAQsDsACyANIA9B7LnQABCwOwALIA8gC0GMutAAEMMhAAsgECALQZy60AAQwyEACyAPIAtBrLrQABDDIQALIAAgACkD6AEgGa18NwPoAQJAAkACQCAAKAKIKiIBIAAoAvgpTQRAIAAoAowqIAFqIgFBB2ohDSABQXhLDQEgDSAAKALwKSILSw0CIAAoAuwpIAFqIgFBADYAACABQQNqQQA2AAALDAILIAEgDUHYwtAAELE7AAsgDSALQdjC0AAQsDsACyACIBMgGWsiEzYCACAFIBIgGWoiEjYCAAwDCyAAKAIoRQRAIABBgICAgARBgICAgARCgICAgAQgACkD6AEgACkD+AF9IiggJ3wiKSApQoCAgIAEWhunIChCgICAgARaGyATQYCAgIAETxs2AigLIBtBADYCDCAAIA0gCyAbQQxqEL4BIAAgGygCDDYCqCpFBEBBACESDAQLIA9FDQEgGiARNgIADAELCwsgEiAEQajA0AAQrzsACyAbQRBqJAAgEguQBQECfyMAQSBrIgIkAAJAAkACQAJAAkACQAJ/AkACQAJAIAEtAABBAWsOAwABAgQLIAFBAWoMAgsgASgCBEEIagwBCyABKAIEQQhqCy0AACIDQQtNBEAgA0EHRyADQQJrQQJPcQ0BIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NBiAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIAQQEhAwwFCyADQQxGDQEgA0EWRg0CIANBJUYNAwtBACEDIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NBCAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIADAMLIAJBADYCCCACQoCAgIAQNwIAIAJB+Kj+ADYCECACQqCAgIAONwIUIAIgAjYCDCABIAJBDGoQ1A4NAyAAIAIpAgA3AgQgAEEMaiACQQhqKAIANgIAQQIhAwwCCyACQQA2AgggAkKAgICAEDcCACACQfio/gA2AhAgAkKggICADjcCFCACIAI2AgwgASACQQxqENQODQIgACACKQIANwIEIABBDGogAkEIaigCADYCAEEDIQMMAQsgAkEANgIIIAJCgICAgBA3AgAgAkH4qP4ANgIQIAJCoICAgA43AhQgAiACNgIMIAEgAkEMahDUDg0BIAAgAikCADcCBCAAQQxqIAJBCGooAgA2AgBBBCEDCyAAQQA2AgAgACADOgAQIAEtAABBA0YEQCABKAIEIgAQvCogAEEMQQQQ+DoLIAJBIGokAA8LQaCp/gBBNyACQR9qQZCp/gBB2Kn+ABDVHgAL2wUCBX8IfiMAQcABayIDJAAgASgCCCIFKAIAIQYgA0GgAWoiByABKAIMKAIQIAJBBXRqIgQpAwAiCyAEKQMIIgwgBCkDECINIAQpAxgiDhDWIwJAAkACfgJAIAMoAqABQQFxBEAgAykDuAEhCCADKQOwASEJIAYoAgAiBCkDACEKIAMgBCkDCCIPNwM4IAMgCjcDMCADIAg3AyggAyAJNwMgIANBADYCHCADIAkgCCAKIA8gA0EcahD2DCADKAIcRQ0BIANBAjYCZCADQayQ/wA2AmAgA0ICNwJsIANBhAw2AlggA0GEDDYCUCADIANBzABqNgJoIAMgA0EwajYCVCADIANBIGo2AkwgA0GMAWogA0HgAGoQmQ4gA0G0AWogA0GYAWooAgA2AgAgA0GIgICAeDYCiAEgAyADQZABaikCADcCrAEgAyADKQKIATcCpAEgA0EBNgKgASAHQQRyEIgRCyAFKAIEIQEgAyAONwN4IAMgDTcDcCADIAw3A2ggAyALNwNgIANBzJH/ADYCiAEgA0IENwKUASADQYMMNgK8ASADQfQLNgK0ASADIAFBAWo2ArABIANBuwc2AqwBIAMgATYCqAEgA0HMATYCpAEgA0Ggkf8ANgKgASADIANBoAFqNgKQASADIANB4ABqNgK4ASADQQQ2AowBIANB0ABqIANBiAFqEJkOIANBOGogA0HUAGooAgA2AgAgA0GCgICAeDYCTCADIAMpAkw3AzAgAykCWAwBCyADQaABaiADKQMAIgggAykDCCIJIAUoAggtAAAQrQ4gAygCoAFBk4CAgHhGDQEgA0E4aiADQagBaigCADYCACADIAMpAqABNwMwIAMpAqwBCyEIIAAgAykDMDcCACAAIAg3AgwgAEEIaiADQThqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQR0aiIAIAk3AwggACAINwMACyADQcABaiQAC68FAgZ/An4jAEGAAWsiAyQAAkACQAJAAkACQAJAIAEtADRBAWsOAwIAAwELAAsgA0EwaiABKAIIQQBBBEEQEKAYIAMoAjQhBCADKAIwQQFGDQIgAygCOCEFIAFBADYCGCABIAU2AhQgASAENgIQIAEgASgCADYCJCABIAEoAgQiBDYCICABIAQ2AhwgASAEIAEoAghBBHRqIgY2AihBACEFDAMLQej9wgAQ6CsACyABKAIwIQggASgCLCEHQQEhBQwBCyAEIAMoAjhB2P3CABD9LwALA0ACQAJAAkACQAJAIAVFBEAgBCAGRg0BIAEgBEEQajYCICABKAIMIQUgBCkDACEJIAQpAwghCiADQQA6AEQgAyAKNwM4IAMgCTcDMCADIAU2AkAgA0EIaiADQTBqEM0pIAMoAgghByABIAMoAgwiCDYCMCABIAc2AiwMBAsgA0EwaiAHIAIgCCgCDBEBACADKAIwIgRBCUYEQCAAQQk2AgBBAyEEDAULIANBGGoiBiADQTxqKQIANwMAIAMgAykCNDcDECADKAJEIQUgAUEsahC8KiAEQQhHBEAgA0EoaiAGKQMANwMAIAMgAykDEDcDICABQRxqEL0rIAFBEGoiAhDUJyACEO47DAILIAEoAhgiBCABKAIQRgRAIAFBEGpB+P3CABCeKAsgASgCFCAEQQR0aiIFIAMpAxA3AgAgBUEIaiADQRhqKQMANwIAIAEgBEEBajYCGCABKAIgIQQgASgCKCEGDAILIAFBHGoQvStBCCEEIANBKGogAUEYaigCADYCACADIAEpAhA3AyALIAAgBDYCACAAIAMpAyA3AgQgACAFNgIUIABBDGogA0EoaikDADcCAEEBIQQMAgtBACEFDAILQQEhBQwBCwsgASAEOgA0IANBgAFqJAALnAUCBX8BfiMAQUBqIgIkACAAAn8CQAJAIAEoAhAiBEUEQCACQRhqELQeIAIoAhgiA0EERg0BIAAgAikCIDcCDCAAQRRqIAJBKGooAgA2AgAgAEELaiACKAIcIgFBGHY6AAAgACABQQh2OwAJIAAgAToACCAAIAM2AgRBAQwDCyABKAIMIQMgASAEQQFrNgIQIAEgA0EBajYCDCACIAMtAAAiBEEEdiIGOgADAkACQAJAIARBD3EiA0EBaw4CAQACC0EAIQMLIAEgAzoAFkECIQMMAgsgAkEYaiADEKMSIAItABwhAyACKAIYIgVBBEcEQCAAIAIpAB03AAkgAEEQaiACQSRqKQAANwAAIAAgAzoACCAAIAU2AgRBAQwDCyADDQEgAkGAgICAeDYCGCAAQQRqIAJBGGogAhCvLUEADAILQQFBAEHUs84AEK87AAsCQAJAIARBD00EQCACQRhqIAEQwBwgAigCGEUEQCACLwEgIQQMAgsgAikDICIHpyEEIAIoAhwiBUEERg0BIAAgAikDKDcCECAAIAQ7AQggACAFNgIEIABBDmogB0IwiD0BACAAIAdCEIg+AQpBAQwDCyABQRRqIQUgAS4BFCAGaiIEwSAERgRAIAUgBDsBAAwCCyACQQI2AhwgAkH4ss4ANgIYIAJCAjcCJCACQc0BNgI8IAIgBTYCOCACQbsHNgI0IAIgAkEwajYCICACIAJBA2o2AjAgAkEIaiACQRhqEJkOIAAgAikBCjcBCiACQQE6ABQgAEEQaiACQRBqKQEANwEAIAAgAi8BCDsBCCAAQQE2AgRBAQwCCyABIAQ7ARQLIAAgAzoAFCAAIAQ7ARIgAEEBOwEQIABBgICAgHg2AgRBAAs2AgAgAkFAayQAC+AEAgd/Bn4jAEEgayIIJABCB0KKASABLwECIgYbIQ9CBEIDIAYbIRBBfyEFAkACQANAIAYhCkJ1IQxCfyENAkADQCANIREgCyAEIAlJcg0BIAlBAWoiBiACTw0DIAxCAXwhDiAEIAlNIQsgCSAEIAlLaiEJIAEgBkECdGovAQIhBiAPIAxCDHxWBEAgDUIBfSENIA4hDCAKQf//A3EgBkYNAQsLAkAgECAOQgt8IgxWBEAgCkH//wNxIQcDQCAAIAcgA0EnEKshIBFCAXwiEVBFDQALDAELIA5CCnwhDSAKQf//A3EiB0UEQCANQgpaBEAgAEESIANBJxCrISAALQAYIgdBB2oiBUH/AXFBwABPBEAgACAOIAUQ8BAMAwsgACAFOgAYIAAgACkDECAOIAethoQ3AxAMAgsgAEERIANBJxCrISAOQgh8IQwgAC0AGCIHQQNqIgVB/wFxQcAATwRAIAAgDCAFEPAQDAILIAAgBToAGCAAIAApAxAgDCAHrYaENwMQDAELIAUgB0cEfiAAIAcgA0EnEKshIA0FIAwLQgN9IgxCBFoNBCAAQRAgA0EnEKshIAAtABgiB0ECaiIFQf8BcUHAAE8EQCAAIAwgBRDwEAwBCyAAIAU6ABggACAAKQMQIAwgB62GhDcDEAtCBkIHIAYgCkH//wNxIgVGIgobQooBIAYbIQ9CA0IEIAobQgMgBhshEAwBCwsgCEEgaiQADwsgBiACQYTv+wAQwyEACyAIQQA2AhggCEEBNgIMIAhBnO/7ADYCCCAIQgQ3AhAgCEEIakGk7/sAEO8sAAvuBAIIfgV/AkAgASgCOCIORQ0AAkAgASkDMCIDUEUEQCABKQMoIQYMAQsgASkDCCEHIAEoAiQhDSABKQMYIQggASkDKCEGIAEpAwAhBSABKAIgIQogASkDECECA0ACQAJAAkACQAJAIAJCAn0iA0IBWARAIAIhBCADp0EBaw0BDAQLIAEgAlCtQgGGIgQ3AxAgAqdBAXENAQsgCkUgCiANRnINASABIApBCGoiCzYCICAKKQMAIQMgCyEKIAQhAgwDCyACUA0AQgAhAiAIIQMMAgsgAUIDNwMQCyAFQgJRDQMgAUIANwMAIAWnQgMhAkIAIQUgByEDQQFxRQ0DCyABIAM3AzAgASAGQkB9IgY3AyggA1ANAAsLIAEgA0J/IAN6IgSGQn+FhCICNwMwIASnIQwgBiEFAkACQCACQn9RBEAgASkDCCEIIAEoAiQhDSABKQMYIQkgASkDACEEIAEoAiAhCiABKQMQIQMDQAJAAkACQAJAAkAgA0ICfSICQgFYBEAgAyEHIAKnQQFrDQEMBAsgASADUK1CAYYiBzcDECADp0EBcQ0BCyAKRSAKIA1Gcg0BIAEgCkEIaiILNgIgIAopAwAhAiALIQogByEDDAMLIANQDQBCACEDIAkhAgwCCyABQgM3AxALIARCAlENAyABQgA3AwAgBKdCAyEDQgAhBCAIIQJBAXFFDQMLIAEgAjcDMCABIAVCQH0iBTcDKCACQn9RDQALCyABIAJCfyACQn+FeiIChoM3AzAgAqcgBadqIQ4MAQsgAUEANgI4CyAAIA42AgggACAMIAanajYCBEEBIQwLIAAgDDYCAAvgBAEGfwJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkACQAJAIAdBgICAgAFxBEAgAC8BDiIDDQFBACECDAILIAJBEE8EQCABIAIQ1gchAwwECyACRQRAQQAhAgwECyACQQNxIQYCQCACQQRJBEAMAQsgAkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEECaiwAAEG/f0pqIARBA2osAABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNAyABIAVqIQQDQCADIAQsAABBv39KaiEDIARBAWohBCAGQQFrIgYNAAsMAwsgASACaiEIQQAhAiABIQQgAyEFA0AgBCIGIAhGDQICfyAGQQFqIAYsAAAiBEEATg0AGiAGQQJqIARBYEkNABogBkEDaiAEQXBJDQAaIAZBBGoLIgQgBmsgAmohAiAFQQFrIgUNAAsLQQAhBQsgAyAFayEDCyADIAAvAQwiBE8NACAEIANrIQZBACEDQQAhBQJAAkACQCAHQR12QQNxQQFrDgIAAQILIAYhBQwBCyAGQf7/A3FBAXYhBQsgB0H///8AcSEIIAAoAgQhByAAKAIAIQADQCADQf//A3EgBUH//wNxSQRAQQEhBCADQQFqIQMgACAIIAcoAhARAgBFDQEMAwsLQQEhBCAAIAEgAiAHKAIMEQYADQFBACEDIAYgBWtB//8DcSEBA0AgA0H//wNxIgIgAUkhBCABIAJNDQIgA0EBaiEDIAAgCCAHKAIQEQIARQ0ACwwBCyAAKAIAIAEgAiAAKAIEKAIMEQYAIQQLIAQL8xkCIH8EfiMAQZABayIGJAACQCABAn8CQAJAAkACQAJAAkACQAJAAkAgAS0AkAFBAWsOAwUBAAILIAFB+ABqIRsCQCABLQB4QQFrDgMKAQQACyABKQMIISMgASgCaCEFIAEoAgQhAyABKAIAIQkMAgsACyABKAKAASIFKQMQISMgAUEAOgB4IAEgBTYCaCABICM3AwggASABKAKMASIDNgIEIAEgASgCiAEiCTYCACABQfgAaiEbCyABIAM2AhQgASAJNgIQIAFB7ABqIAkgAyAjEOAJIAEoAnQhDCABKAJwIQQgBkE4aiEKIwBBEGsiCCQAAkACQEHYAEEIEK02IgMEQCADQgA3A0AgA0IANwMIIANCgYCAgBA3AwAgA0EBOwFUIANBfzYCUCADQcgAakIANwMAIAhBBGoQ6zpBIEEEEK02IglFDQEgCSADNgIIIAlCgYCAgBA3AgAgCSAIKQIENwIMIAkgA0EIaiIDNgIcIAkgAzYCGCAJQRRqIAhBDGooAgA2AgAgCkEAOgAIIApBADYCBCAKIAk2AgAgCEEQaiQADAILQQhB2AAQoz0AC0EEQSAQoz0ACyAGQTBqQgA3AwAgBkKAgICAgAE3AkQgBkIANwMoIAZCgICAgKABNwJMIAZBADoAJCAGIAU2AiAgBiAENgIYIAYgBCAMQQR0ajYCHCABQRhqIAZBGGpBwAD8CgAAIAFBADYCYCABQoCAgIDAADcDWAsgBkHYAGohECMAQTBrIgokACABQRhqIglBQGshFiAKQRxqIRwgCkEgaiEdAkADQAJAIApBGGohEiMAQYABayIMJAAgCUEgaiEIIAlBEGohDyAMQRBqIQ4DQAJAIAkoAjggCSgCJCIDBH8gCCgCACgCCEEIaiEFA0AgAygCOCAFRg0ACyADKAJABUEACyAJKAI0ak0NACAMQQhqIQcjAEHgAGsiBCQAAkAgCS0ADEUEQCAEQTBqIQVCACEjQgAhJEIAISUjAEEQayINJAAgCSIDKAIAIgsgAygCBEYEfkIABSADIAtBEGo2AgAgCykDACEjIAspAwghJCADKAIIIgsoAggQ9DohAyALKQMAISVCAQshJiAFQQA6ACwgBSAkNwMgIAUgIzcDGCAFIAM2AhAgBSAlNwMIIAUgJjcDACAFIA0vAA07AC0gBUEvaiANQQ9qLQAAOgAAIA1BEGokACAEKQMwIiNCAlEEQCAHQgI3AwAMAgsgBEEIaiAEQThqQSj8CgAAICNQBEAgCUEBOgAMCyAHICM3AwAgB0EIaiAEQQhqQSj8CgAADAELIAdCADcDAAsgBEHgAGokACAMKQMIIiNCAlEgI6dBAXFFcg0AIAxB0ABqIgUgDkEo/AoAACAPIA8pAwAiI0IBfDcDACAMICM3A3ggCCgCACgCCCEEIAgQjSQhBwJAQdgAQQgQrTYiAwRAIANCATcDCCADQoGAgIAQNwMAIANBEGogBUEw/AoAACADQQE7AVQgAyAHNgJQIANBADYCTCADQgA3AkQgAyAEQQhqNgJAIAhBADoACCAIKAIEIQUgCCADQQhqIgQ2AgQCQCAFRQRAIANBADYCQCADQQE2AkgMAQsgCCgCACgCCEEIaiEHA0AgBSgCOCAHRg0ACyAFKAJAIQcgAyAFNgJAIAMgB0EBajYCSCAFIAQ2AjwLIANBADYCTCAIKAIAIgMoAhggAyAENgIYIAQ2AkQMAQtBCEHYABCjPQALDAELCyAMQThqIQsjAEHgAGsiAyQAIA9BHGohHgJAAkAgDygCJARAIA8oAiApAxgiIyAPKQMIUQ0BCyAPQRBqIQggA0EgakEEciETIANBBHIhFANAQQAhF0EAIRhBACEfIwBBQGoiBSQAIAgoAgQiBARAIAgoAgAoAghBCGohBwNAIAQoAjggB0YNAAsgBCgCQCEXCyAIKAIAIgRBDGogAigCACIVEIsUA0ACQCAFIARBCGoQzhkCQAJAAkACQAJAIAUoAgAiBARAIARBAmsNASAVKAIEIBUoAgAoAggRAwAgA0EKNgIADAMLIAUoAgQiBygCAEUEQCAFIAdBCGsiBDYCCCAEIAQoAgAiBEEBazYCACAEQQFHDQUgBUEIahC4HwwFCyAIIAcQjB0iDS0AVCANQQA6AFRFDQMgDUEAOgBVIAUgDUEIaiIgNgIsIAVB+IDDADYCKCAFQQA2AjggBSAFQShqIgQ2AjQgBSAENgIwIAVBCGohESAFQTBqISEjAEEwayIEJAAgB0EIaiIHKQMoISMCQAJAAkACQAJAAkACQCAHLQAkQQFrDgMFAQACCyAHKAIgIRkMAgsACyAHKQMYISQgBykDECElIAcoAgghGiAHKQMAISYgBBDOIiAEKAIEIRkgBCgCACEiQcgAQQgQrTYiDkUNASAOQQA6AEQgDiAiNgJAIA4gJDcDGCAOICU3AxAgDiAaNgIIIA4gJjcDACAOQdikwwAQ1BogByAZNgIgCyAEQQxqIhogGUEIaiAhEKgUAkACQCAEKAIMRQRAIARBKGogBEEcaigCADYCACAEIAQpAhQ3AyAgBCgCECEOIAdBIGoQriwgDg0BQeCmwwBBKyAaQaynwwBB/LnDABDVHgALIAdBAzoAJCARQQk2AgAMAQsgESAEKQMgNwIIIBFBEGogBEEoaigCADYCACAHQQE6ACQgESAjNwMYIBEgDjYCBCARQQg2AgALIARBMGokAAwCC0EIQcgAEKM9AAtB7LnDABDoKwALIAUoAghBCUcNASAIKAIEIQQgCCAgNgIEIBggDS0AVUEAR2ohGAJAIARFBEAgDUEANgJAIA1BATYCSAwBCyAIKAIAKAIIQQhqIQcDQCAEKAI4IAdGDQALIAQoAkAhByANIAQ2AkAgDSAHQQFqNgJIIAQgIDYCPAsgGEEBTQRAIB9BAWoiHyAXRw0FCyAVKAIEIBUoAgAoAggRAwAgA0EKNgIADAILIAgoAgQEQCADQQo2AgAMAgsgA0EJNgIAIAhBAToACAwBCyADIAUpAwg3AwAgA0EYaiAFQSBqKQMANwMAIANBEGogBUEYaikDADcDACADQQhqIAVBEGopAwA3AwAgDRCJJAsgBUFAayQADAILQZuAwwBBFkG0gMMAEJ8pAAsgCCgCACEEDAELCwJAAkACQCADKAIAIgVBCWsOAgEAAgsgC0EKNgIADAQLIAtBCTYCAAwDCyATQRhqIBRBGGooAgA2AgAgE0EQaiAUQRBqKQIANwIAIBMgFCkCADcCACATQQhqIBRBCGopAgA3AgAgAyAFNgIgIAMpAzgiIyAPKQMIUgRAIB4gA0EgahC5HwwBCwsgCyADKQMgNwMAIA8gI0IBfDcDCCALQQhqIANBKGopAwA3AwAgC0EQaiADQTBqKQMANwMADAELIA8gI0IBfDcDCCADQUBrIB4QhBUgC0EQaiADQdAAaikDADcDACALQQhqIANByABqKQMANwMAIAsgAykDQDcDAAsgA0HgAGokAAJAAkACQAJAIAwoAjhBCWsOAgIAAQsgEkEKNgIADAILIBIgDCkDODcDACASQRBqIAxByABqKQMANwMAIBJBCGogDEFAaykDADcDAAwBCyASQQlBCiAJLQAMGzYCAAsgDEGAAWokACAKKAIYIgNBCEcEQAJAAkAgA0EJaw4CAwEACyAKQRBqIApBLGooAgAiAjYCACAKIAopAiQiIzcDCCAKKQIcISQgEEEUaiACNgIAIBAgIzcCDCAQICQ3AgQgECADNgIADAQLIBBBCTYCAAwDCyAKQRBqIgMgHUEIaigCADYCACAKIB0pAgA3AwggCigCHCIIRQ0AIBwgCikDCDcCACAcQQhqIAMoAgA2AgAgCiAINgIYIBYgCkEYahCFJAwBCwsgECAWKQIANwIEIBBBDGogFkEIaigCADYCACAJQQA2AkggCUKAgICAwAA3A0AgEEEINgIACyAKQTBqJAAgBigCWCICQQlGDQEgBkH4AGoiAyAGQeQAaigCADYCACAGIAYpAlw3A3AgBikDaCEjIAkQwyYgAkEIRg0CIAZBiAFqIAMoAgA2AgAgBiAGKQNwNwOAASABQewAahDtOwwDC0Gs9sIAEOgrAAsgG0EDOgAAIABBCTYCAEEDDAILIAZBEGogAygCADYCACAGIAYpA3A3AwggASgCECEDIAEoAhQhCSAGIAFB7ABqIgg2AmAgBiADIAlBBHRqNgJcIAYgAzYCWCAGIAZBCGoiAzYCZCAGQYABaiAGQdgAahDVGiADENQnIAMQ7jsgCBDtOwsgAUEBOgB4IAEQoi0gAUGEAWoQ7TsgACACNgIAIAAgIzcDECAAIAYpA4ABNwIEIABBDGogBkGIAWooAgA2AgBBAQs6AJABIAZBkAFqJAAPC0Gs3sIAEOgrAAv9BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdChoyYsODAgYMGNwIAIAdBCGpBhoyYMDYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KGjJiw4MCBgwY3AgAgA0EIakGGjJgwNgIAIAZBEGogBBDHBkEMQQQQrTYiBEUNASAEIAYpAhA3AgAgBEEIaiAGQRhqKAIANgIAIAYgBDYCOCAGIAM2AjQgBkEiOgAwIAAgASAHQQFrQXhxakEIaiACIAZBMGogBRCGASABIAEoAgAiAEEBazYCACAAQQFGBEAgBkEIahC7IwsgBigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgBkEwahCmDAsgBkFAayQADwtBBEEMEKM9AAv9BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdCgoSIkKDAgIECNwIAIAdBCGpBgoSIEDYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KChIiQoMCAgQI3AgAgA0EIakGChIgQNgIAIAZBEGogBBDHBkEMQQQQrTYiBEUNASAEIAYpAhA3AgAgBEEIaiAGQRhqKAIANgIAIAYgBDYCOCAGIAM2AjQgBkEiOgAwIAAgASAHQQFrQXhxakEIaiACIAZBMGogBRCGASABIAEoAgAiAEEBazYCACAAQQFGBEAgBkEIahC7IwsgBigCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgBhC7IwsgBkEwahCmDAsgBkFAayQADwtBBEEMEKM9AAv/BAEEfyMAQUBqIgYkACAGQRBqIAEgAiADIAUQhgEgBigCGCEBIAYoAhQhAgJAAkAgBigCECIHQZOAgIB4RwRAIAAgBikCHDcCDCAAIAE2AgggACACNgIEIAAgBzYCACADEKYMDAELIAYgAjYCACAGIAE2AgQgASgCCCEIQQxBBBCtNiIHRQ0BIAdCiZKkyJChwoQJNwIAIAdBCGpBiZKkyAA2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCiZKkyJChwoQJNwIAIANBCGpBiZKkyAA2AgAgBkEQaiAEEMcGQQxBBBCtNiIERQ0BIAQgBikCEDcCACAEQQhqIAZBGGooAgA2AgAgBiAENgI4IAYgAzYCNCAGQSI6ADAgACABIAdBAWtBeHFqQQhqIAIgBkEwaiAFEIYBIAEgASgCACIAQQFrNgIAIABBAUYEQCAGQQhqELsjCyAGKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAGELsjCyAGQTBqEKYMCyAGQUBrJAAPC0EEQQwQoz0AC/8EAQR/IwBBQGoiBiQAIAZBEGogASACIAMgBRCGASAGKAIYIQEgBigCFCECAkACQCAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgATYCCCAAIAI2AgQgACAHNgIAIAMQpgwMAQsgBiACNgIAIAYgATYCBCABKAIIIQhBDEEEEK02IgdFDQEgB0KIkKDAgIGChAg3AgAgB0EIakGIkKDAADYCACAGQThqIgkgA0EIaigCADYCACAGIAMpAgA3AzBBDEEEEK02IgNFDQEgAyAGKQMwNwIAIANBCGogCSgCADYCACAGIAM2AiwgBiAHNgIoIAZBIjoAJCAGQRBqIAIgCEEBa0F4cWpBCGogASAGQSRqIgMgBRCGASAGKAIYIQIgBigCFCEBIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACACNgIIIAAgATYCBCAAIAc2AgAgAxCmDCAGKAIAIgAgACgCACIAQQFrNgIAIABBAUcNASAGELsjDAELIAYgATYCCCAGIAI2AgwgBkEkahCmDCACKAIIIQdBDEEEEK02IgNFDQEgA0KIkKDAgIGChAg3AgAgA0EIakGIkKDAADYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoSIkKDAgIGCBDcCACAHQQhqQYSIkCA2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANChIiQoMCAgYIENwIAIANBCGpBhIiQIDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoWKlKjQoMGCBTcCACAHQQhqQYWKlCg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANChYqUqNCgwYIFNwIAIANBCGpBhYqUKDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoeOnLjw4MGDBzcCACAHQQhqQYeOnDg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCh46cuPDgwYMHNwIAIANBCGpBh46cODYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQAL/QQBBH8jAEFAaiIGJAAgBkEQaiABIAIgAyAFEIYBIAYoAhghASAGKAIUIQICQAJAIAYoAhAiB0GTgICAeEcEQCAAIAYpAhw3AgwgACABNgIIIAAgAjYCBCAAIAc2AgAgAxCmDAwBCyAGIAI2AgAgBiABNgIEIAEoAgghCEEMQQQQrTYiB0UNASAHQoOGjJiw4MCBAzcCACAHQQhqQYOGjBg2AgAgBkE4aiIJIANBCGooAgA2AgAgBiADKQIANwMwQQxBBBCtNiIDRQ0BIAMgBikDMDcCACADQQhqIAkoAgA2AgAgBiADNgIsIAYgBzYCKCAGQSI6ACQgBkEQaiACIAhBAWtBeHFqQQhqIAEgBkEkaiIDIAUQhgEgBigCGCECIAYoAhQhASAGKAIQIgdBk4CAgHhHBEAgACAGKQIcNwIMIAAgAjYCCCAAIAE2AgQgACAHNgIAIAMQpgwgBigCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBhC7IwwBCyAGIAE2AgggBiACNgIMIAZBJGoQpgwgAigCCCEHQQxBBBCtNiIDRQ0BIANCg4aMmLDgwIEDNwIAIANBCGpBg4aMGDYCACAGQRBqIAQQxwZBDEEEEK02IgRFDQEgBCAGKQIQNwIAIARBCGogBkEYaigCADYCACAGIAQ2AjggBiADNgI0IAZBIjoAMCAAIAEgB0EBa0F4cWpBCGogAiAGQTBqIAUQhgEgASABKAIAIgBBAWs2AgAgAEEBRgRAIAZBCGoQuyMLIAYoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQuyMLIAZBMGoQpgwLIAZBQGskAA8LQQRBDBCjPQALvwgCB38CfiMAQTBrIgQkAAJAIAIEQCAEQSRqIAJBAEEIQRAQoBggBCgCKCEFIAQoAiRBAUcEQCACQQR0IQkgBCgCLCEIIAUhBgNAIAcgCUcEQCAHIAhqIgogASkDADcDACAKQQhqIAEpAwg3AwAgB0EQaiEHIAFBEGohASAGQQFrIgYNAQsLIAQgCDYCECAEIAU2AgwgBCACNgIUIAQgBEEYajYCJAJAIAJBAUYNACACQRVPBEAgCCEBIARBJGohBwJAIAJBAkkNAAJAAkACQCABKQMQIgsgASkDAFQiCUUEQEECIQUgAkECRg0BIAFBIGohBgNAIAsgBikDACILVg0CIAZBEGohBiACIAVBAWoiBUcNAAsMAgtBAiEFIAJBAkYNACABQSBqIQYDQCALIAYpAwAiC1gNASAGQRBqIQYgAiAFQQFqIgVHDQALDAELIAIgBUcNAQsgCUUNASACQQF2IQYgAkEEdCABakEQayEFA0AgASkDACELIAEgBSkDADcDACABQQhqIgcpAwAhDCAHIAVBCGoiBykDADcDACAFIAs3AwAgByAMNwMAIAVBEGshBSABQRBqIQEgBkEBayIGDQALDAELIAEgAkEAIAJBAXJnQQF0QT5zIAcQyA8LDAELAkAgAgRAIAJBAUcEQCAIIAJBBHRqIQkgCEEQIgVqIQYDQCAGKQMAIgsgBkEQaykDAFQEQCAGKQMIIQwgBSEBAn8DQCABIAhqIgcgB0EQayIKKQMANwMAIAdBCGogCkEIaikDADcDACAIIAFBEEYNARogAUEQayEBIAsgB0EgaykDAFQNAAsgASAIagsiASAMNwMIIAEgCzcDAAsgBUEQaiEFIAZBEGoiBiAJRw0ACwsMAQsACwtBACEFIARBJGogAkEAQQhBEBCgGCAEKAIoIQEgBCgCJEEBRwRAIARBADYCICAEIAQoAiw2AhwgBCABNgIYQQAhAUEBIQcDQAJ/AkACQCABIAJJBEAgCCABQQR0aiIJKQMIIQsgAiAHRg0CIAIgByACIAdLGyEGIAggB0EEdGohAQNAIAYgB0YNAiAHIAEpAwAiDCALVCAMIAt9IANYckUNBBogAUEIaikDACIMIAsgCyAMVBshCyABQRBqIQEgB0EBaiIHIAJHDQALDAILIAEgAkGk7sMAEMMhAAsgBiACQbTuwwAQwyEACyACCyEBIAkpAwAhDCAEKAIYIAVGBEAgBEEYakHE7sMAEJUoCyAEKAIcIAVBBHRqIgYgCzcDCCAGIAw3AwAgBCAFQQFqIgU2AiAgAUEBaiEHIAEgAkcNAAsgACAEKQIYNwIAIABBCGogBEEgaigCADYCACAEQQxqQQhBEBDgHgwDCyABIAQoAixBlO7DABD9LwALIAUgBCgCLEGE7sMAEP0vAAsgAEEANgIIIABCgICAgIABNwIACyAEQTBqJAAL8AQCBH8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBCE8EQCABQQxqIQcgASgCECEDIAJBeHEhBUEAIQIDQCADKQMAIghCAFkgBiAIp0txRQRAIAEgAhCLOw0DCyADQQhqIQMgAkEBaiECIAVBCGsiBQ0ACwsgBEHIAGogBEEYaigCADYCACAEIAQpAhA3A0AgBEHMAGogAUEw/AoAACAEKQIIIQggACAEQUBrQTz8CgAAIABBADoARCAAIAg3AjwMAQsgBCACNgIgIAQgAzYCJCAEQQM2AiwgBEGsgoQBNgIoIARCAzcCNCAEQTs2AlQgBEE7NgJMIARByBA2AkQgBCAEQUBrNgIwIAQgBEEcajYCUCAEIARBIGo2AkggBCAEQSRqNgJAIABBBGogBEEoahCZDiAAQQI6AEQgAEGNgICAeDYCACAEQRBqELwMIAQoAggiACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBCGoQuyMLIAEQvAwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBxD7HgsgASgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPseCyAEQYABaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvvBAIFfwF+IwBBgAFrIgQkACAEIAM2AgwgBCACNgIIIARBQGsiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAkA3AgAgAkEIaiAEQcgAaiIFKAIANgIAIAMgBEEIaiIGEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCQDcCACADQQhqIAUoAgA2AgAgBCADNgIYIAQgAjYCFCAEQSI6ABAgBCAGEPQtIgY2AhwCQAJAIAEoAhQiAkECTwRAIAFBDGohByABKAIQIQMgAkF+cSEFQQAhAgNAIAMuAQAiCEEATiAGIAhLcUUEQCABIAIQizsNAwsgA0ECaiEDIAJBAWohAiAFQQJrIgUNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEJIAAgBEFAa0E8/AoAACAAQQA6AEQgACAJNwI8DAELIAQgAjYCICAEIAM2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQfcXNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAcQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL7wQCBX8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBBE8EQCABQQxqIQcgASgCECEDIAJBfHEhBUEAIQIDQCADKAIAIghBAE4gBiAIS3FFBEAgASACEIs7DQMLIANBBGohAyACQQFqIQIgBUEEayIFDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCSAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCTcCPAwBCyAEIAI2AiAgBCADNgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEHtBjYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAHEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC94EAQl/IwBBEGsiBCQAAn8CQCACKAIEIgVFDQAgACACKAIAIAUgASgCDBEGAEUNAEEBDAELIAIoAgwiAwRAIAIoAggiBSADQQxsaiEJIARBDGohCgNAAkACQAJAAkAgBS8BAEEBaw4CAgEACwJAIAUoAgQiAkHBAE8EQCABQQxqKAIAIQMDQEEBIABBlPaJAUHAACADEQYADQgaIAJBQGoiAkHAAEsNAAsMAQsgAkUNAwsgAEGU9okBIAIgAUEMaigCABEGAEUNAkEBDAULIAAgBSgCBCAFKAIIIAFBDGooAgARBgBFDQFBAQwECyAFLwECIQIgCkEAOgAAIARBADYCCAJAIAJFBEBBASEHDAELIAJB9v8XaiACQZz/H2pxIAJBmPg3aiACQfCxH2pxcyIDQRF2QQFqIQcgA0GAgChJDQAgB0EFQdT2iQEQsDsACyAEQQhqIgggB2oiA0EBayIGIAIgAkEKbiILQQpsa0EwcjoAAAJAIAYgCEYNACADQQJrIgYgC0EKcEEwcjoAACAEQQhqIAZGDQAgA0EDayIGIAJB5ABuQQpwQTByOgAAIARBCGogBkYNACADQQRrIgYgAkHoB25BCnBBMHI6AAAgBEEIaiAGRg0AIANBBWsiBiACQZDOAG5BMHI6AAAgBEEIaiAGRg0AIANBBmsiAkEwOgAAIAIgCEYNACADQQdrIgJBMDoAACAEQQhqIAJGDQAgA0EIa0EwOgAACyAAIARBCGogByABQQxqKAIAEQYARQ0AQQEMAwsgBUEMaiIFIAlHDQALC0EACyAEQRBqJAAL0AQBCn8jAEEwayIBJAAgACgCJCEEIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAAkACQCAEBEAgAkUNAyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGCAAKAIgIgcNAUEAIQAMAgsgAkUEQEEAIQAMBAsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxgCQCAAKAIgIgRFBEBBACEADAELIAAoAhwhAkEAIQAgASgCJCEFIAEoAhwhByABKAIoIQMDQCADIAItAAAiBk0NBiAAIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQAgAkEBaiECIARBAWsiBA0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQMgAUEYahD7HgwDCyAAKAIcIQUgACgCMCECIAAoAighBiAAKAI0IQRBACEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgBEUNBEEBIQMgBiACQQN2ai0AACACQQdxdkEBcQRAIAogBS0AACIDTQ0FIAkgAyAIaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXEhAwsgBUEBaiEFIARBAWshBCACQQFqIQIgACADaiEAIAdBAWsiBw0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQEgAUEYahD7HgwBCyAAKAI4IQAMAAsgAUEwaiQAIAAPC0Hk5oQBQSBBhOeEARCfKQAL0AQBCn8jAEEwayIBJAAgACgCJCEEIAEgACgCPCAAKAJAIgIoAghBAWtBeHFqQQhqIAIoAjgRAAAgASgCACECAkACQAJAAkACQCAEBEAgAkUNAyABQShqIAFBEGopAgA3AwAgAUEgaiABQQhqKQIANwMAIAEgASkCADcDGCAAKAIgIgcNAUEAIQAMAgsgAkUEQEEAIQAMBAsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgA3AxgCQCAAKAIgIgRFBEBBACEADAELIAAoAhwhAkEAIQAgASgCJCEFIAEoAhwhByABKAIoIQMDQCADIAIsAAAiBk0NBiAAIAcgBSAGaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFqIQAgAkEBaiECIARBAWsiBA0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQMgAUEYahD7HgwDCyAAKAIcIQUgACgCMCECIAAoAighBiAAKAI0IQRBACEAIAEoAiQhCCABKAIcIQkgASgCKCEKA0AgBEUNBEEBIQMgBiACQQN2ai0AACACQQdxdkEBcQRAIAogBSwAACIDTQ0FIAkgAyAIaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXEhAwsgBUEBaiEFIARBAWshBCACQQFqIQIgACADaiEAIAdBAWsiBw0ACwsgASgCGCICIAIoAgAiAkEBazYCACACQQFHDQEgAUEYahD7HgwBCyAAKAI4IQAMAAsgAUEwaiQAIAAPC0Hk5oQBQSBBhOeEARCfKQAL8QQCBH8CfiMAQRBrIgYkAAJAIAEgAkVyRQRAQX8hBAwBCwJAQQFBBSADGyIEIAJLBEAgAkUgA0EBRnINAiAGQajqvmk2AgwgAkUiAEUEQCAGQQxqIAEgAvwKAAALIAYoAgxBqOq+aUYNAiAGQdDUtMIBNgIMIABFBEAgBkEMaiABIAL8CgAACyAGKAIMQXBxQdDUtMIBRg0CDAELIABBAEEw/AsAAkAgA0EBRg0AIAEoAAAiBUGo6r5pRg0AIAVBcHFB0NS0wgFHDQFBCCEEIAJBCEkNAiABNQAEIQggAEEBNgIUIAAgCDcDAEEAIQQMAgsgAiABIAIgAxCxICICSQRAIAIhBAwCCyAAIAI2AhggASAEaiIFQQFrLQAAIgJBCHEEQEFyIQQMAgsgAkEgcSIDRQRAIAUtAAAiBUGnAUsEQEFwIQQMAwsgBUEHca1CASAFQQN2QQpqrYYiCEIDiH4gCHwhCSAEQQFqIQQLIAJBBnYhBSACQQJ2AkACQAJAAkAgAkEDcSICQQFrDgMAAQIDCyABIARqLQAAIQIgBEEBaiEEDAILIAEgBGovAAAhAiAEQQJqIQQMAQsgASAEaigAACECIARBBGohBAtBAXEhBwJ+AkACQAJAAkAgBUEBaw4DAQIDAAtCfyADRQ0DGiABIARqMQAADAMLIAEgBGozAABCgAJ8DAILIAEgBGo1AAAMAQsgASAEaikAAAshCCAAIAc2AiAgACACNgIcIAAgCDcDAEEAIQQgAEEANgIUIAAgCCAJIAMbIgg3AwggAEKAgAggCCAIQoCACFobPgIQDAELQXYhBAsgBkEQaiQAIAQL+AQBCX8jAEEwayIEJAACQAJAAkAgAS0AWARAIAMEQCABKAIAIAFBADYCACABKAI4IgcgAyADIAdLGyEJRQ0CIAIgASgCBCIGNgIAIAEgBjYCVCABIAdBAWs2AjhBASEGDAILIABBADYCBAwCCyAEQQA2AhggBEEBNgIMIARByKLNADYCCCAEQgQ3AhAgBEEIakGYp80AEO8sAAsCQAJAAkACQCAGIAlHBEAgAUEIaiELIAEoAlAhBQNAAkAgBQ0AIARBCGogARDBCSAEKAIIIgVBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwICyABKAJMIgcgASgCMCIFTw0CIAEoAiwgB2otAAAhBSAEIAkgBmsiByABKAJQIgggByAISRsiCDYCACAGIAhqIgcgCEkNAyADIAdJDQQgBCALIAIgBkECdGoiBiAIIAUQuQYiBTYCBCAFIAhHDQUgCARAIAhBAnQhCiABKAJUIQUgASgCRCEMA0AgBiAGKAIAIAUgDGpqIgU2AgAgBkEEaiEGIApBBGsiCg0ACyABIAU2AlQLIAEgASgCUCAIayIFNgJQIAEgASgCOCAIazYCOCAHIgYgCUcNAAsLIAAgCTYCBAwECyAHIAVBqKfNABDDIQALIAYgB0G4p80AELE7AAsgByADQbinzQAQsDsACyAEQQI2AgwgBEH0p80ANgIIIARCAjcCFCAEQTs2AiwgBEE7NgIkIAQgBEEgajYCECAEIARBBGo2AiggBCAENgIgIABBBGogBEEIahCZDkEAIQUMAQtBCCEFCyAAIAU2AgAgBEEwaiQAC/oEAgd/An4jAEEwayIEJAACQAJAAkAgAS0AaARAIAMEQCABKAIAIAFCADcDACABKAJQIgYgAyADIAZLGyEJRQ0CIAIgASkDCCILNwMAIAEgCzcDOCABIAZBAWs2AlBBASEHDAILIABBADYCBAwCCyAEQQA2AhggBEEBNgIMIARByKLNADYCCCAEQgQ3AhAgBEEIakGYp80AEO8sAAsCQAJAAkACQCAHIAlHBEAgAUEQaiEKIAEoAmQhBQNAAkAgBQ0AIARBCGogARCNCyAEKAIIIgVBCEYNACAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwICyABKAJgIgYgASgCSCIFTw0CIAEoAkQgBmotAAAhBSAEIAkgB2siBiABKAJkIgggBiAISRsiCDYCACAHIAhqIgYgCEkNAyADIAZJDQQgBCAKIAIgB0EDdGoiByAIIAUQkAQiBTYCBCAFIAhHDQUgCARAIAhBA3QhBSABKQM4IQsgASkDMCEMA0AgByAHKQMAIAsgDHx8Igs3AwAgB0EIaiEHIAVBCGsiBQ0ACyABIAs3AzgLIAEgASgCZCAIayIFNgJkIAEgASgCUCAIazYCUCAGIgcgCUcNAAsLIAAgCTYCBAwECyAGIAVBqKfNABDDIQALIAcgBkG4p80AELE7AAsgBiADQbinzQAQsDsACyAEQQI2AgwgBEH0p80ANgIIIARCAjcCFCAEQTs2AiwgBEE7NgIkIAQgBEEgajYCECAEIARBBGo2AiggBCAENgIgIABBBGogBEEIahCZDkEAIQUMAQtBCCEFCyAAIAU2AgAgBEEwaiQAC7oEAgZ/CH4jAEHwAGsiBiQAAkAgASADaiIDIAAoAggiCE0EQCAAIAM2AggMAQsgACADIAhrEMggCyAGIAQgBRDgHCAGQgA3A2ggBiABNgJgIAYgASACaiICNgJkAkACQAJAIAEgAk8NACACQQFrIQIgBigCWCEJIAYpAyAhDiAGKAJUIQggBigCUCEFIAYpA0AhDCAGKQMwIQ8gBigCECEDIAYpAwghDSAGKAIoIQogBigCGCELIAYpA0ghESAGKQM4IRIgBikDACEQA0AgEKdBAXEEf0EABUEBCyEEAkADQAJAAkACQCAERQRAIA1QRQ0BQgAhDUIAIRBBASEEDAQLAn4CQCAPQgJ9IhNCAVgEQCATp0EBaw0BDAULIA+nIA9QrUIBhiEPQQFxRQ0AIBIMAQsgDEIDUQRAQgMhDAwECyAFRSAFIAhGckUEQCAIQQhrIggpAwAMAQtBACEFIAxCAlEEQEICIQwMBAsgDKdCACEMQQFxRQ0DIBELIQ1CASEQIAlBQGoiCSEDDAELIAMgDXmnQT9zIgdqIQRCASAHrYYgDYUhDQwDC0EAIQQMAQsLIAsgDkIAUnFFDQIgCiAOeadBP3MiB2ohBEIBIAethiAOhSEOCyACIARPDQEgAiAAKAIIIgdPDQIgBCAHTw0DIAQgACgCBCIEaiACIARqLQAAOgAAIAEgAkkgAkEBayECDQALCyAGQfAAaiQADwsgAiAHQbCazwAQwyEACyAEIAdBwJrPABDDIQAL4QQCCX8BfiAAKAIAIQMgACgCBCIKQQFqIgZBA3YgBkEHcUEAR2oiBARAIAMhBQNAIAUgBSkDACIMQn+FQgeIQoGChIiQoMCAAYMgDEL//v379+/fv/8AhHw3AwAgBUEIaiEFIARBAWsiBA0ACwsgAAJ/AkAgBkEITwRAIAMgBmogAykAADcAAAwBCyAGBEAgA0EIaiADIAb8CgAACyAGDQBBAAwBCyACKAIUIQtBACEEA0ACQCAAKAIAIgIgBCIFai0AAEGAAUcNACACIAVBA3RrQQhrIQgCQANAIAEgACAFIAsRDQAhDCAAKAIEIgYgDKciCXEiAyECIAAoAgAiBCADaikAAEKAgYKEiJCgwIB/gyIMUARAQQghBwNAIAIgB2ohAiAHQQhqIQcgBCACIAZxIgJqKQAAQoCBgoSIkKDAgH+DIgxQDQALCyAEIAx6p0EDdiACaiAGcSICaiwAAEEATgRAIAQpAwBCgIGChIiQoMCAf4N6p0EDdiECCyACIANrIAUgA2tzIAZxQQhJDQEgAiAEaiIDLQAAIAMgCUEZdiIDOgAAIAQgAkEIayAGcWpBCGogAzoAACAEIAJBA3RrQQhrIQJB/wFHBEAgCCACQQIQ+ioMAQsLIAAoAgAiAyAFakH/AToAACADIAAoAgQgBUEIa3FqQQhqQf8BOgAAIAIgCCkAADcAAAwBCyAEIAVqIAlBGXYiAjoAACAEIAYgBUEIa3FqQQhqIAI6AAALIAVBAWohBCAFIApHDQALIAAoAgQiASABQQFqQQN2QQdsIAFBCEkbCyAAKAIMazYCCAvnGgIMfwJ+IwBBkAFrIgQkACABIAEoAgwiDEEBajYCDAJAIAEgDBDyJkUEQCAAQYGAgIB4NgIAIAMtAABBKUYNASADEJ0MDAELIAMvAQ4hAQJ/AkACQAJAIAIoAgAiC0EIaiICIAsoAghBAkZBAnRqLQAgIgdBACAHQQNHGyINQQFrDgIAAgELQQEhDiABQQFqIQELIAMvAQwMAQsgAUEBaiEBIAMvAQxBAWoLIQ8gBEE4aiADQQhqKAIANgIAIAQgAykCADcDMCAEQRhqIQcgBEEwaiEKIwBBwAFrIgMkAAJAAkACQAJAAkAgAwJ/AkAgAwJ/AkACQAJAAkAgAigCAEECRwRAAkACQAJAAkACQAJAAkACQCACLQAwQQFrDgcAAQIDBAUGBwsgAigCLCEGIAIoAighCCADQfgAaiACEIkZIANB8ABqIANBgAFqIgkoAgA2AgAgAyADKQJ4NwNoIAMgAi0AISIFOgB0AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQB4QQRrDg4MDRABDg8BAQEBAQEBAAELIAUOEwEAAAAAAAIDBAAAAAUGBwAICQoACyADQZABaiAJKAIANgIAIAMgAykCeDcDiAEgAyAFOgCHASADQQI2ApwBIANB2OvNADYCmAEgA0ICNwKkASADQagENgK8ASADQakENgK0ASADIANBsAFqNgKgASADIANBhwFqNgK4ASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOIANBAzYCMAwhCyADQQg2AjAgA0EEOgA0DCALIANBMGogCCAGELEQDB8LIANBCDYCMCADQQ46ADQMHgsgA0EINgIwIANBkAI7ATQMHQsgA0EINgIwIANBBjoANAwcCyADQQg2AjAgA0EHOgA0DBsLIANBCDYCMCADQQg6ADQMGgsgA0EINgIwIANBAjoANAwZCyADQQg2AjAgA0EDOgA0DBgLIANBCDYCMCADQQQ6ADQMFwsgA0EwaiADKAJ8IAMoAoABELEQDBYLIANBCDYCMCADQQ46ADQMFQsgAy0AeSEFIAMtAHohBiADIANB6ABqNgKIASAFQQhGDQIgBUEQRg0DIAVBIEYNBCADQQE2ApwBIANBkOvNADYCmAEgA0IBNwKkASADQaoENgK0ASADIANBsAFqNgKgASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOQQMMEQsgA0EINgIwIANBADoANAwTCyADIAMtAHkiBToAiAEgBUUNECADQQE2ApwBIANBkOvNADYCmAEgA0IBNwKkASADQasENgK0ASADIANBsAFqNgKgASADIANBiAFqNgKwASADQTBqQQRyIANBmAFqEJkOQQMMEQsgBkEBcUUEQCADQQY6ADQMDgsgA0ECOgA0DA0LIAZBAXFFBEAgA0EHOgA0DA0LIANBAzoANAwMCyAGQQFxRQRAIANBCDoANEEIDA0LIANBBDoANAwLCyACKAIsIQUgAigCKCEIIANBiAFqIAIQiRkgAi0AISEGAkACfwJAAkACQAJAAkACQAJAAkAgAy0AiAEiCUEEaw4FARMCAwkACyAJQRFHDRICQAJAAkACQAJAAkACQCAGQQZrDg4BGRkCAwQZGRkFGRkZBgALIAYNGCADQQg2AjAgA0EFOgA0DB0LIANBMGogCCAFELEQDBwLIANBCDYCMCADQZEEOwE0DBsLIANBCGpB6OvNAEEDEJQnIANBjQI7ATQgA0EINgIwIAMgAykDCDcDOAwaCyADQRBqQejrzQBBAxCUJyADQY0EOwE0IANBCDYCMCADIAMpAxA3AzgMGQsgA0EINgIwIANBCToANAwYCyADQQg2AjAgA0EFOgA0DBcLIANBMGogAygCjAEgAygCkAEQsRAMFgsgAy0AiQFBAWsOAgIDAQsgAy0AiQFBAWohBiADLQCKAQ0DQQAMBAsgA0GYAWpBKUEAQQFBARCgGCADKAKcASEFIAMoApgBQQFGDRYgAygCoAEiBkHr680AQSn8CgAAIANBKTYCPCADIAY2AjggAyAFNgI0IANBAzYCMAwTCyADQQg2AjAgA0GRBDsBNAwSCyADQQg2AjAgA0GRBjsBNAwRCyADQRhqQejrzQBBAxCUJyADKAIcIQUgAygCGAshCCADIAU2AjwgAyAINgI4IAMgBjoANSADQQ06ADQgA0EINgIwDA8LIAMtAIkBQcAARw0JIAMtAIoBRQRAIANBCDYCMCADQQk6ADQMDwsgA0EINgIwIANBBToANAwOCyADQQA2AjggA0GNBjsBNAwOCyADQQs6ADQMDQsgA0EMOgA0DAwLIAIoAighBiACKAIsIQggA0GIAWogAhCJGSACLQAhIQUCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQCIASIJDgwIAQEJCgEBAQEBCwwACyAJQRFHDQACQCAFDgcCAwEBAQQFAAsgBUEUaw4CBQYACyADQfAAaiADQZABaigCADYCACADIAMpAogBNwNoIAMgBToAeCADQQI2ApwBIANBiO3NADYCmAEgA0ICNwKkASADQagENgK8ASADQakENgK0ASADIANBsAFqNgKgASADIANB+ABqNgK4ASADIANB6ABqNgKwASADQTBqQQRyIANBmAFqEJkOIANBAzYCMAwVCyADQQg2AjAgA0EUOgA0DBQLIANBCDYCMCADQRg6ADQMEwsgA0EINgIwIANBFDoANAwSCyADQTBqIAYgCBDJLgwRCyADQQg2AjAgA0EYOgA0DBALIANBCDYCMCADQRQ6ADQMDwsgA0EINgIwIANBGDoANAwOCyADQQg2AjAgA0EUOgA0DA0LIANBMGogAygCjAEgAygCkAEQyS4MDAsgA0EINgIwIANBGDoANAwLCyADQQg2AjAgA0EUOgA0DAoLIAIoAiQhBSACKAIsIQYgAigCKCEIIANBsAFqIAIQiRkCQAJAAkAgAy0AsAEiCUENaw4FAgYGBgABCyACLQAhIglBBkcEQCAJQRZHDQYgA0EINgIwIANBkwI7ATQMDAsgBUERTgRAIANBMGogCCAGELIQDAwLIANBMGogCCAGELEQDAsLIAlBBEcNBCADKAK4ASEGIAMoArQBIQggBUERTgRAIANBMGogCCAGELIQDAsLIANBMGogCCAGELEQDAoLIAVBAkYNAiADQZgBakHCAEEAQQFBARCgGCADKAKcASEFIAMoApgBQQFGDQwgAygCoAEiBkGY7c0AQcIA/AoAACADQcIANgI8IAMgBjYCOCADIAU2AjQgA0EANgIwDAkLIANBAToANAwJC0HMwc0AQShBjOrNABCfKQALIANBCDYCMCADQQo6ADQMBgsgAyAFNgI4IANBFToANCADQQg2AjAMBQsgA0HwAGogA0GQAWooAgA2AgAgAyADKQKIATcDaCADIAY6AHggA0ECNgKcASADQcTszQA2ApgBIANCAjcCpAEgA0GoBDYCvAEgA0GpBDYCtAEgAyADQbABajYCoAEgAyADQfgAajYCuAEgAyADQegAajYCsAEgA0EwakEEciADQZgBahCZDiADQQM2AjAMBAtBCAs2AjAMAgsgA0GQAjsBNEEICzYCMAsgAygCMCIFQQhGDQAgA0EoaiADQTxqKAIAIgY2AgAgAyADKQI0IhA3AyAgAykDQCERIAdBDGogBjYCACAHIBA3AgQgByARNwMQIAcgBTYCACAKLQAAQSlGDQEgChCVDAwBCyADQdAAaiIFIANBPGooAgA2AgAgAyADKQI0NwNIAkAgCi0AAEEpRwRAIANB4ABqIApBCGooAgA2AgAgAyAKKQIANwNYIANBmAFqIANByABqIANB2ABqENEKDAELIANBoAFqIAUoAgA2AgAgAyADKQNINwOYAQsgByADKQOYATcCBCAHQQg2AgAgB0EMaiADQaABaigCADYCAAsgA0HAAWokAAwBCyAFIAMoAqABQfy7zQAQ/S8ACyAEQRBqIgMgBEEkaigCADYCACAEIAQpAhw3AwggBCgCGCIHQQhHBEAgBCkDKCEQIAAgBCkDCDcCDCAAIBA3AxggACAHNgIIIABBgoCAgHg2AgAgAEEUaiADKAIANgIADAELIARByABqIgcgAygCADYCACAEIAQpAwg3A0AgCyALKAIAIgNBAWo2AgAgA0EATgRAIARB5ABqIAcoAgA2AgAgBCAOOgBsIAQgATsBaiAEIA87AWggBCAEKQNANwJcIAQgDDYCWCAEIAs2AlQgBEGAgICAeDYCUAJAIA1BAkYEQCAEQfAAaiAEQdAAaiACIAIoAgBBAkZBAnRqIgEoAgwgASgCEBDaEwwBCyAEQYgBaiAEQegAaikCADcDACAEQYABaiAEQeAAaikCADcDACAEQfgAaiAEQdgAaikCADcDACAEIAQpAlA3A3ALIAAgBCkDcDcCACAAQRhqIARBiAFqKQMANwIAIABBEGogBEGAAWopAwA3AgAgAEEIaiAEQfgAaikDADcCAAwBCwALIARBkAFqJAALhQUCAn8EfiMAQZABayIGJAAgBiAENwMQIAYgBTcDGCAGIAI3AwAgBiADNwMIIAZBQGsgAiADIAQgBSABKAIAIgcpAwAgBykDCCAHKQMQIAcpAxgQmggCfiAGLQBAQQFGBEAgBi0AQQRAQoCAgICAgICAgH8hCEIADAILIAZBADYCMCAGQQE2AiQgBkG0i/8ANgIgIAZCBDcCKCAGQSBqQbyL/wAQ7ywACyAGKQNoIQggBikDYCEJIAYpA1ghCiAGKQNQCyELIAZBQGsgAiADIAQgBSAHKQMAIAcpAwggBykDECAHKQMYEJoIAkAgBi0AQEEBRgRAIAYtAEEEQCAGQThqQgA3AwAgBkEwakIANwMAIAZCADcDKCAGQgA3AyAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBzIv/ABDvLAALIAYgBikDiAE3AzggBiAGKQOAATcDMCAGIAYpA3g3AyggBiAGKQNwNwMgCyAGQdgAakIANwMAIAZB0ABqQgA3AwAgBkIANwNIIAZCADcDQAJAAkACQCAGIAZBQGsQ+xsiB0H/AXFBAkcgB8BBAE5xRQRAIAZBIGogASgCCBD7G8BBAEwNAQwCCyAGQSBqIAEoAgQQ+xsiAUH/AXFBAkYgAcBBAEhyDQEgCCAJIAtCAXwiBCAKIARQrXwiAoRQrXwiBSAJVK18IQgMAgsgC0IBfSEEIAogC1CtfSECIAkgCiALhFCtIgN9IQUgCCADIAlWrX0hCAwBCyAJIQUgCyEEIAohAgsgACAFNwMgIAAgBDcDECAAQgA3AwggAEIBNwMAIAAgCDcDKCAAIAI3AxggBkGQAWokAAvhBAIJfwF+IAAoAgAhAyAAKAIEIgpBAWoiBkEDdiAGQQdxQQBHaiIEBEAgAyEFA0AgBSAFKQMAIgxCf4VCB4hCgYKEiJCgwIABgyAMQv/+/fv379+//wCEfDcDACAFQQhqIQUgBEEBayIEDQALCyAAAn8CQCAGQQhPBEAgAyAGaiADKQAANwAADAELIAYEQCADQQhqIAMgBvwKAAALIAYNAEEADAELIAIoAhQhC0EAIQQDQAJAIAAoAgAiAiAEIgVqLQAAQYABRw0AIAIgBUECdGtBBGshCAJAA0AgASAAIAUgCxENACEMIAAoAgQiBiAMpyIJcSIDIQIgACgCACIEIANqKQAAQoCBgoSIkKDAgH+DIgxQBEBBCCEHA0AgAiAHaiECIAdBCGohByAEIAIgBnEiAmopAABCgIGChIiQoMCAf4MiDFANAAsLIAQgDHqnQQN2IAJqIAZxIgJqLAAAQQBOBEAgBCkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgA2sgBSADa3MgBnFBCEkNASACIARqIgMtAAAgAyAJQRl2IgM6AAAgBCACQQhrIAZxakEIaiADOgAAIAQgAkECdGtBBGshAkH/AUcEQCAIIAJBARD6KgwBCwsgACgCACIDIAVqQf8BOgAAIAMgACgCBCAFQQhrcWpBCGpB/wE6AAAgAiAIKAAANgAADAELIAQgBWogCUEZdiICOgAAIAQgBiAFQQhrcWpBCGogAjoAAAsgBUEBaiEEIAUgCkcNAAsgACgCBCIBIAFBAWpBA3ZBB2wgAUEISRsLIAAoAgxrNgIIC5ASAQx/IwBBIGsiESQAAkACQCABQSFJDQACQANAIARBAWshBANAIARBf0YEQCAAIAEgAiADQQEgBhCBCgwFCyAAIAFBA3YiB0EcbGohDyAAIAdBBHRqIQkgEQJ/IAFBwABPBEAgACAJIA8gByAGEMkRDAELIAAgACgCACIHKAIEIgggCSgCACILKAIEIgwgBygCCCIHIAsoAggiCyAHIAtJGxCZJyIKIAcgC2sgChsiCkEASiAKQQBIayIKIAggDygCACIIKAIEIg0gByAIKAIIIgggByAISRsQmSciDiAHIAhrIA4bIgdBAEogB0EASGtzQQBIDQAaIA8gCSAKIAwgDSALIAggCCALSxsQmSciByALIAhrIAcbIgdBAEogB0EASGtzQQBIGwsiCygCACIHNgIEIAsgAGtBAnYhCwJAAkAgBQRAIAUoAgAiCCgCBCAHKAIEIAgoAggiCCAHKAIIIgcgByAISxsQmSciDyAIIAdrIA8bQQBODQELAn9BACEJIAEgA0sgCyIHIAFPckUEQCACIAFBAnRqIQ8gACAHQQJ0aiEMIAAhCANAIAAgB0EDayIKQQAgByAKTxtBAnRqIhIgCEsEQANAIAlBAnQgAiAPQQRrIAgoAgAiCigCBCAMKAIAIg4oAgQgCigCCCINIA4oAggiDiANIA5JGxCZJyIQIA0gDmsgEBsiDUEASBtqIAo2AgAgDUEfdiAJaiIOQQJ0IAIgD0EIayAIQQRqKAIAIgkoAgQgDCgCACINKAIEIAkoAggiCiANKAIIIg0gCiANSRsQmSciECAKIA1rIBAbIgpBAEgbaiAJNgIAIApBH3YgDmoiDkECdCACIA9BDGsgCEEIaigCACIJKAIEIAwoAgAiDSgCBCAJKAIIIgogDSgCCCINIAogDUkbEJknIhAgCiANayAQGyIKQQBIG2ogCTYCACAKQR92IA5qIg5BAnQgAiAPQRBrIg8gCEEMaigCACIJKAIEIAwoAgAiDSgCBCAJKAIIIgogDSgCCCINIAogDUkbEJknIhAgCiANayAQGyIKQQBIG2ogCTYCACAKQR92IA5qIQkgCEEQaiIIIBJJDQALCyAAIAdBAnRqIhIgCEsEQANAIAlBAnQgAiAPQQRrIg8gCCgCACIKKAIEIAwoAgAiDigCBCAKKAIIIg0gDigCCCIOIA0gDkkbEJknIhAgDSAOayAQGyINQQBIG2ogCjYCACANQR92IAlqIQkgCEEEaiIIIBJJDQALCyABIAdHBEAgD0EEayIPIAlBAnRqIAgoAgA2AgAgCEEEaiEIIAEhBwwBCwsgCUECdCIHBEAgACACIAf8CgAACyABIAlHBEAgASAJayEHIAAgCUECdGohCCABQQJ0IAJqQQRrIQ8DQCAIIA8oAgA2AgAgD0EEayEPIAhBBGohCCAHQQFrIgcNAAsLIAkMAQsACyIHRQ0AIAEgB08NASARQQA2AhggEUEBNgIMIBFBzN6HATYCCCARQgQ3AhAgEUEIakHU3ocBEO8sAAsgAQJ/QQAhCCABIANLIAsiBSABT3JFBEAgAiABQQJ0aiELIAAgBUECdGohDyAAIQcDQCAAIAVBA2siCUEAIAUgCU8bQQJ0aiINIAdLBEADQCAIQQJ0IAIgC0EEayAPKAIAIgwoAgQgBygCACIJKAIEIAwoAggiDCAJKAIIIgogCiAMSxsQmSciDiAMIAprIA4bQQBOIgwbaiAJNgIAIAggDGoiCkECdCACIAtBCGsgDygCACIJKAIEIAdBBGooAgAiCCgCBCAJKAIIIgkgCCgCCCIMIAkgDEkbEJknIg4gCSAMayAOG0EATiIJG2ogCDYCACAJIApqIgpBAnQgAiALQQxrIA8oAgAiCSgCBCAHQQhqKAIAIggoAgQgCSgCCCIJIAgoAggiDCAJIAxJGxCZJyIOIAkgDGsgDhtBAE4iCRtqIAg2AgAgCSAKaiIKQQJ0IAIgC0EQayILIA8oAgAiCSgCBCAHQQxqKAIAIggoAgQgCSgCCCIJIAgoAggiDCAJIAxJGxCZJyIOIAkgDGsgDhtBAE4iCRtqIAg2AgAgCSAKaiEIIAdBEGoiByANSQ0ACwsgACAFQQJ0aiINIAdLBEADQCAIQQJ0IAIgC0EEayILIA8oAgAiDCgCBCAHKAIAIgkoAgQgDCgCCCIMIAkoAggiCiAKIAxLGxCZJyIOIAwgCmsgDhtBAE4iDBtqIAk2AgAgCCAMaiEIIAdBBGoiByANSQ0ACwsgASAFRwRAIAhBAnQgAiALQQRrIgtBARtqIAcoAgA2AgAgB0EEaiEHIAhBAWohCCABIQUMAQsLIAhBAnQiBQRAIAAgAiAF/AoAAAsgASAIRwRAIAEgCGshBSAAIAhBAnRqIQcgAUECdCACakEEayELA0AgByALKAIANgIAIAtBBGshCyAHQQRqIQcgBUEBayIFDQALCyAIDAELAAsiB0kNAyAAIAdBAnRqIQBBACEFIAEgB2siAUEhTw0CDAQLIAAgB0ECdGogASAHayACIAMgBCARQQRqIAYQ7wkgBEEBayEEIAciAUEhTw0ACwsMAQsgByABQeTehwEQrzsACyAAIQQjAEEQayIGJAAgAUECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEFIAFBD0sNASABQQdLBEAgACACEOUNIAAgBUECdCIDaiACIANqEOUNQQQMAwsgAiAEKAIANgIAIAIgBUECdCIAaiAAIARqKAIANgIAQQEMAgsACyAEIAIgAiABQQJ0aiIAEMgtIAQgBUECdCIDaiACIANqIABBIGoQyC1BCAshB0EAIQAgBkEANgIIQQAgB2shDyAEIAdBAnQiA2ohCSACIANqIQwgBiAFNgIMIAEgBWshCiAGQQhqIQ0DQCAAIAogBSANIABBAnRqKAIAIgAbIgsgB0sEQCACIABBAnQiAGohDiALIA9qIQggACAJaiELIAAgDGohAANAIAAgCygCADYCACAOIAAQ5xkgC0EEaiELIABBBGohACAIQQFrIggNAAsLQQEhAEEBcUUNAAsgAiABIAQQ4g4LIAZBEGokAAsgEUEgaiQAC9cFAQN/IAAQmj4iACAAKAIEQXhxIgEQmD4hAgJAAkACQAJAIAAoAgQiA0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQEgACADEJY+IgBB0POKASgCAEYEQCACKAIEQQNxQQNHDQFByPOKASABNgIAIAAgASACEIkuDwsgACADEIUPCwJAAkAgAigCBCIDQQJxRQRAIAJB1POKASgCAEYNAiACQdDzigEoAgBGDQUgAiADQXhxIgIQhQ8gACABIAJqIgEQ0DQgAEHQ84oBKAIARw0BQcjzigEgATYCAA8LIAAgASACEIkuCyABQYACSQ0CIAAgARDsEEEAIQBB6POKAUHo84oBKAIAQQFrIgE2AgAgAQ0BQbDxigEoAgAiAQRAA0AgAEEBaiEAIAEoAggiAQ0ACwtB6POKAUH/HyAAIABB/x9NGzYCAA8LQdTzigEgADYCAEHM84oBQczzigEoAgAgAWoiATYCACAAIAFBAXI2AgRB0POKASgCACAARgRAQcjzigFBADYCAEHQ84oBQQA2AgALIAFB4POKASgCAE0NAEHU84oBKAIAIgJFDQBBACEAAkBBzPOKASgCAEEpSQ0AQajxigEhAQNAIAIgASgCAE8EQCABEK47IAJLDQILIAEoAggiAQ0ACwtBsPGKASgCACIBBEADQCAAQQFqIQAgASgCCCIBDQALC0Ho84oBQf8fIAAgAEH/H00bNgIAQczzigEoAgBB4POKASgCAE0NAEHg84oBQX82AgALDwsCf0HA84oBKAIAIgJBASABQQN2dCIDcUUEQEHA84oBIAIgA3I2AgAgAUH4AXFBuPGKAWoiAQwBCyABQfgBcSICQbjxigFqIQEgAkHA8YoBaigCAAshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggPC0HQ84oBIAA2AgBByPOKAUHI84oBKAIAIAFqIgE2AgAgACABENA0C+YEAgR/AX4jAEGAAWsiBCQAIAQgAzYCDCAEIAI2AgggBEFAayIDIAEQzgYCQEEMQQQQrTYiAgRAIAIgBCkCQDcCACACQQhqIARByABqIgUoAgA2AgAgAyAEQQhqIgYQ8y0QzgZBDEEEEK02IgNFDQEgAyAEKQJANwIAIANBCGogBSgCADYCACAEIAM2AhggBCACNgIUIARBIjoAECAEIAYQ9C0iBjYCHAJAAkAgASgCFCICQQhPBEAgAUEMaiEHIAEoAhAhAyACQXhxIQVBACECA0AgAygCACAGTwRAIAEgAhCLOw0DCyADQQhqIQMgAkEBaiECIAVBCGsiBQ0ACwsgBEHIAGogBEEYaigCADYCACAEIAQpAhA3A0AgBEHMAGogAUEw/AoAACAEKQIIIQggACAEQUBrQTz8CgAAIABBADoARCAAIAg3AjwMAQsgBCACNgIgIAQgAzYCJCAEQQM2AiwgBEGsgoQBNgIoIARCAzcCNCAEQTs2AlQgBEE7NgJMIARBuhM2AkQgBCAEQUBrNgIwIAQgBEEcajYCUCAEIARBIGo2AkggBCAEQSRqNgJAIABBBGogBEEoahCZDiAAQQI6AEQgAEGNgICAeDYCACAEQRBqELwMIAQoAggiACAAKAIAIgBBAWs2AgAgAEEBRgRAIARBCGoQuyMLIAEQvAwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBxD7HgsgASgCGCIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACABQRhqEPseCyAEQYABaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvmBAIEfwF+IwBBgAFrIgQkACAEIAM2AgwgBCACNgIIIARBQGsiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAkA3AgAgAkEIaiAEQcgAaiIFKAIANgIAIAMgBEEIaiIGEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCQDcCACADQQhqIAUoAgA2AgAgBCADNgIYIAQgAjYCFCAEQSI6ABAgBCAGEPQtIgY2AhwCQAJAIAEoAhQiAkEETwRAIAFBDGohByABKAIQIQMgAkF8cSEFQQAhAgNAIAYgAygCAE0EQCABIAIQizsNAwsgA0EEaiEDIAJBAWohAiAFQQRrIgUNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEIIAAgBEFAa0E8/AoAACAAQQA6AEQgACAINwI8DAELIAQgAjYCICAEIAM2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQbsTNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAcQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL5gQCBH8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSIGNgIcAkACQCABKAIUIgJBAk8EQCABQQxqIQcgASgCECEDIAJBfnEhBUEAIQIDQCADLwEAIAZPBEAgASACEIs7DQMLIANBAmohAyACQQFqIQIgBUECayIFDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCCAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCDcCPAwBCyAEIAI2AiAgBCADNgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEH4FzYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAHEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC4EFAQl/IwBBQGoiAyQAIAMgAiABayIEQQR2Igc2AhAgA0EUaiAHQQdqQQN2ENIfQcAAIQUCQAJAIARBAXYiCkHA////B3FBQGsgCiAEQf4AcRsiCEHAABDRNARAIAgEQCAIQcAAEK02IgVFDQILIAMoAhwhCSAFIQQgASACRg0CA0ACQCABKAIABEAgBCABQQhqKQMANwMAIAkgBkEDdmoiCyALLQAAQQEgBkEHcXRyOgAADAELIARCADcDAAsgBkEBaiEGIARBCGohBCABQRBqIgEgAkcNAAsMAgtBrMH/AEEpIANBKGpBxMj/AEHYwf8AENUeAAtBwAAgCBCjPQALIAMgBCAFa0EDdSIBNgIkAkACQCABIAdGBEAgAygCICEEIAMgAykCFDcCNCADQQA2AjAgAyAENgIsIAMgCTYCKCADQQhqIANBKGoiAhDXOyADKAIIIQZBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAMpAig3AgggAUEQaiADQTBqIgcpAgA3AgAgAUEYaiADQThqIgkoAgA2AgAgAyAINgI4IANCgICAgIAINwIwIAMgCjYCLCADIAU2AiggAyACENc7IAMoAgAhBUEcQQQQrTYiAkUNAiACQoGAgIAQNwIAIAIgAykCKDcCCCACQRBqIAcpAgA3AgAgAkEYaiAJKAIANgIAIAAgCjYCFCAAIAU2AhAgACACNgIMIAAgBDYCCCAAIAY2AgQgACABNgIAIANBQGskAA8LIANCADcCNCADQoGAgIDAADcCLCADQcC7/wA2AihBACADQSRqIANBEGogA0EoakHIu/8AEK8rAAtBBEEcEKM9AAtBBEEcEKM9AAuBBQEJfyMAQUBqIgMkACADIAIgAWsiBEEEdiIHNgIQIANBFGogB0EHakEDdhDSH0HAACEFAkACQCAEQQF2IgpBwP///wdxQUBrIAogBEH+AHEbIghBwAAQ0TQEQCAIBEAgCEHAABCtNiIFRQ0CCyADKAIcIQkgBSEEIAEgAkYNAgNAAkAgASgCAARAIAQgAUEIaikDADcDACAJIAZBA3ZqIgsgCy0AAEEBIAZBB3F0cjoAAAwBCyAEQgA3AwALIAZBAWohBiAEQQhqIQQgAUEQaiIBIAJHDQALDAILQfz2/wBBKSADQShqQfj6/wBBqPf/ABDVHgALQcAAIAgQoz0ACyADIAQgBWtBA3UiATYCJAJAAkAgASAHRgRAIAMoAiAhBCADIAMpAhQ3AjQgA0EANgIwIAMgBDYCLCADIAk2AiggA0EIaiADQShqIgIQ1zsgAygCCCEGQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASADKQIoNwIIIAFBEGogA0EwaiIHKQIANwIAIAFBGGogA0E4aiIJKAIANgIAIAMgCDYCOCADQoCAgICACDcCMCADIAo2AiwgAyAFNgIoIAMgAhDXOyADKAIAIQVBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAMpAig3AgggAkEQaiAHKQIANwIAIAJBGGogCSgCADYCACAAIAo2AhQgACAFNgIQIAAgAjYCDCAAIAQ2AgggACAGNgIEIAAgATYCACADQUBrJAAPCyADQgA3AjQgA0KBgICAwAA3AiwgA0GU8v8ANgIoQQAgA0EkaiADQRBqIANBKGpBnPL/ABCvKwALQQRBHBCjPQALQQRBHBCjPQAL4gQBBn8jAEHgAGsiAyQAAkAgAigCECIIRQRAIABBCDYCAAwBCyABQZQBaiEEIAEoApQBQYCAgIB4RgRAIANByABqIAFB8ABqIAEoAigQuhQgA0EQaiIFIANB1ABqKQIANwMAIANBGGoiBiADQdwAaigCADYCACADIAMpAkw3AwggAygCSCIHQQhHBEAgACADKQMINwIEIAAgBzYCACAAQRRqIAYoAgA2AgAgAEEMaiAFKQMANwIADAILIAQoAgBBgICAgHhHBEAgBBDvKwsgBCADKQMINwIAIARBEGogA0EYaigCADYCACAEQQhqIANBEGopAwA3AgALIAEoAqwBIgUgASgCpAEiBiAIak8EQCADQcgAaiAEIAIQtwogAygCSCICQQhHBEAgACADKQJMNwIEIABBFGogA0HcAGooAgA2AgAgAEEMaiADQdQAaikCADcCACAAIAI2AgAMAgsCQCABKAKkASABKAKsAUkNACADQcgAaiABEP8GIAMoAkgiAUEIRg0AIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACABNgIADAILIABBCDYCAAwBCyADQSBqIgcgAkEAIAUgBmsiBBDOFiADQTRqIAIgBCAIIARrEM4WIANByABqIAEgBxD2CQJAIAMoAkgiAkEIRwRAIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACACNgIADAELIAAgASADQTRqEPYJCyADQTRqEOkrIANBIGoQ6SsLIANB4ABqJAAL4gQBBn8jAEHgAGsiAyQAAkAgAigCECIIRQRAIABBCDYCAAwBCyABQYwBaiEEIAEoAowBQYCAgIB4RgRAIANByABqIAFB6ABqIAEoAiAQuhQgA0EQaiIFIANB1ABqKQIANwMAIANBGGoiBiADQdwAaigCADYCACADIAMpAkw3AwggAygCSCIHQQhHBEAgACADKQMINwIEIAAgBzYCACAAQRRqIAYoAgA2AgAgAEEMaiAFKQMANwIADAILIAQoAgBBgICAgHhHBEAgBBDvKwsgBCADKQMINwIAIARBEGogA0EYaigCADYCACAEQQhqIANBEGopAwA3AgALIAEoAqQBIgUgASgCnAEiBiAIak8EQCADQcgAaiAEIAIQtwogAygCSCICQQhHBEAgACADKQJMNwIEIABBFGogA0HcAGooAgA2AgAgAEEMaiADQdQAaikCADcCACAAIAI2AgAMAgsCQCABKAKcASABKAKkAUkNACADQcgAaiABEP4GIAMoAkgiAUEIRg0AIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACABNgIADAILIABBCDYCAAwBCyADQSBqIgcgAkEAIAUgBmsiBBDOFiADQTRqIAIgBCAIIARrEM4WIANByABqIAEgBxD3CQJAIAMoAkgiAkEIRwRAIAAgAykCTDcCBCAAQRRqIANB3ABqKAIANgIAIABBDGogA0HUAGopAgA3AgAgACACNgIADAELIAAgASADQTRqEPcJCyADQTRqEOkrIANBIGoQ6SsLIANB4ABqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCXDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJcNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJcNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQlw0LIA5B0AJqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCWDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJYNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJYNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQlg0LIA5B0AJqJAALhQoCE38CfiMAQdACayISJAACQCABQQJJDQBCgICAgICAgIDAACABrSIZgCIaIBl+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEUIBp8IRkgEkGNAmohF0EBIQoDQEEBIQtBACEVIAEgD0sEQCAPrSIaAn8gACAPQQJ0aiEIAkAgASAPayILIBRJDQACQCALQQJJBEAgCyEGDAELAn8CQAJAIAgoAgRBGHYgCCgCAEEYdkkiCUUEQEECIQYgC0ECRg0EIAhBBGohBwNAIAdBB2otAAAgBy0AA0kNAyAHQQRqIQcgCyAGQQFqIgZHDQALDAELQQIhBkEBIAtBAkYNAhogCEEEaiEHA0AgB0EHai0AACAHLQADTw0CIAdBBGohByALIAZBAWoiBkcNAAsLIAshBgsgBiAUSQ0CIAlFDQEgBkECSQRAQQEhBgwCCyAGQQF2CyEHIAZBAnQgCGpBBGshCwNAIAgoAgAhCSAIIAsoAgA2AgAgCyAJNgIAIAtBBGshCyAIQQRqIQggB0EBayIHDQALCyAGQQF0QQFyDAELIAsgFCALIBRJG0EBdCAERQ0AGiAIQSAgCyALQSBPGyIGIAIgA0EAQQAgBRCFDSAGQQF0QQFyCyILQQF2IA9qrXwgGX4gDyAKQQF2a60gGnwgGX6FeachFQsCQAJAIBFBAkkNACASIBFBAnRqIRYDQCARIBdqLQAAIBVJDQECfyADIBYoAgAiCEEBdiIJIApBAXYiDmoiBk8gCCAKckEBcUVxRQRAIAAgDyAGa0ECdGohByAIQQFxRQRAIAcgCSACIAMgCUEBcmdBAXRBPnNBACAFEIUNCyAKQQFxRQRAIAcgCUECdGogDiACIAMgDkEBcmdBAXRBPnNBACAFEIUNCyAHIQogAiEHIwBBEGsiDiQAAkAgCUUgBiAJTXINACADIAYgCWsiECAJIAkgEEsiDBsiDUkNACAKIAlBAnRqIgggCiAMGyEMIA1BAnQiDQRAIAcgDCAN/AoAAAsgDiAMNgIMIA4gByANaiIMNgIIIA4gBzYCBAJAIAkgEEsEQCAGQQJ0IApqQQRrIQkDQCAJIAhBBGsiCCgCACIQIAxBBGsiDCgCACINIA1BGHYiDSAQQRh2IhBJIhMbNgIAIAwgE0ECdGohDCAIIA0gEE9BAnRqIgggCkYNAiAJQQRrIQkgByAMRw0ACwwBCyAOQQRqIQcCQCAKIAZBAnRqIgwgCEYNACAHKAIAIgogBygCBCIQRg0AIAcoAgghCQNAAkAgCSAIKAIAIg0gCigCACITIA1BGHYiDSATQRh2IhNJIhgbNgIAIAlBBGohCSAKIA0gE09BAnRqIgogEEYNACAIIBhBAnRqIgggDEcNAQsLIAcgCTYCCCAHIAo2AgALIA4oAgwhCCAOKAIEIQcgDigCCCEMCyAMIAdrIgpFDQAgCCAHIAr8CgAACyAOQRBqJAAgBkEBdEEBcgwBCyAGQQF0CyEKIBZBBGshFkEBIQYgEUEBayIRQQFLDQALDAELIBEhBgsgEkGOAmogBmogFToAACASQQRqIAZBAnRqIAo2AgAgASAPSwRAIAZBAWohESALQQF2IA9qIQ8gCyEKDAELCyAKQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQhQ0LIBJB0AJqJAAL2AYCDn8DfiMAQdACayIOJAACQCABQQJJDQBCgICAgICAgIDAACABrSIUgCIVIBR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyEPIBV8IRYgDkGNAmohE0EBIQsDQEEBIQZBACEIIAEgCksEQCAKrSIVAn8gACAKQQN0aiEIAkAgASAKayIGIA9JDQACQCAGQQJJBEAgBiEHDAELAn8CQAJAIAgoAggiDCAIKAIASSIQRQRAQQIhByAGQQJGDQQgCEEQaiEJA0AgDCAJKAIAIgxLDQMgCUEIaiEJIAYgB0EBaiIHRw0ACwwBC0ECIQdBASAGQQJGDQIaIAhBEGohCQNAIAwgCSgCACIMTQ0CIAlBCGohCSAGIAdBAWoiB0cNAAsLIAYhBwsgByAPSQ0CIBBFDQEgB0ECSQRAQQEhBwwCCyAHQQF2CyEJIAdBA3QgCGpBCGshBgNAIAgpAgAhFCAIIAYpAgA3AgAgBiAUNwIAIAZBCGshBiAIQQhqIQggCUEBayIJDQALCyAHQQF0QQFyDAELIAYgDyAGIA9JG0EBdCAERQ0AGiAIQSAgBiAGQSBPGyIGIAIgA0EAQQAgBRCYDSAGQQF0QQFyCyIGQQF2IApqrXwgFn4gCiALQQF2a60gFXwgFn6FeachCAsCQAJAIA1BAkkNACAOIA1BAnRqIQkDQCANIBNqLQAAIAhJDQECfyADIAkoAgAiEEEBdiIRIAtBAXYiB2oiEk8gCyAQckEBcUVxRQRAIAAgCiASa0EDdGohDCAQQQFxRQRAIAwgESACIAMgEUEBcmdBAXRBPnNBACAFEJgNCyALQQFxRQRAIAwgEUEDdGogByACIAMgB0EBcmdBAXRBPnNBACAFEJgNCyAMIBIgAiADIBEQmBAgEkEBdEEBcgwBCyASQQF0CyELIAlBBGshCUEBIQcgDUEBayINQQFLDQALDAELIA0hBwsgDkGOAmogB2ogCDoAACAOQQRqIAdBAnRqIAs2AgAgASAKSwRAIAdBAWohDSAGQQF2IApqIQogBiELDAELCyALQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQmA0LIA5B0AJqJAALrgQCCH8IfiMAQfAAayIGJAAgACABIANqEIUtIAYgBCAFEOAcIAZCADcDaCAGIAEgAmoiAiIDNgJkIAYgATYCYAJAAkACQCABIANPDQAgAkEBdEECayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQF0aiADIAVqLwEAOwEAIAVBAmshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAuuBAIIfwh+IwBB8ABrIgYkACAAIAEgA2oQhi0gBiAEIAUQ4BwgBkIANwNoIAYgASACaiICIgM2AmQgBiABNgJgAkACQAJAIAEgA08NACACQQJ0QQRrIQUgBigCWCEKIAYpAyAhECAGKAJUIQggBigCUCEHIAYpA0AhDiAGKQMwIREgBigCECELIAYpAwghDyAGKAIoIQwgBigCGCENIAYpA0ghEyAGKQM4IRQgBikDACESA0AgEqdBAXEEf0EABUEBCyECAkADQAJAAkACQCACRQRAIA9QRQ0BQgAhD0IAIRJBASECDAQLAn4CQCARQgJ9IhVCAVgEQCAVp0EBaw0BDAULIBGnIBFQrUIBhiERQQFxRQ0AIBQMAQsgDkIDUQRAQgMhDgwECyAHRSAHIAhGckUEQCAIQQhrIggpAwAMAQtBACEHIA5CAlEEQEICIQ4MBAsgDqdCACEOQQFxRQ0DIBMLIQ9CASESIApBQGoiCiELDAELIAsgD3mnQT9zIgRqIQJCASAErYYgD4UhDwwDC0EAIQIMAQsLIA0gEEIAUnFFDQIgDCAQeadBP3MiBGohAkIBIASthiAQhSEQCyACIANBAWsiBE0NASAEIAAoAggiCU8NAiACIAlPDQMgACgCBCIDIAJBAnRqIAMgBWooAgA2AgAgBUEEayEFIAQiAyABSw0ACwsgBkHwAGokAA8LIANBAWsgCUGwms8AEMMhAAsgAiAJQcCazwAQwyEAC64EAgh/CH4jAEHwAGsiBiQAIAAgASADahCHLSAGIAQgBRDgHCAGQgA3A2ggBiABIAJqIgIiAzYCZCAGIAE2AmACQAJAAkAgASADTw0AIAJBA3RBCGshBSAGKAJYIQogBikDICEQIAYoAlQhCCAGKAJQIQcgBikDQCEOIAYpAzAhESAGKAIQIQsgBikDCCEPIAYoAighDCAGKAIYIQ0gBikDSCETIAYpAzghFCAGKQMAIRIDQCASp0EBcQR/QQAFQQELIQICQANAAkACQAJAIAJFBEAgD1BFDQFCACEPQgAhEkEBIQIMBAsCfgJAIBFCAn0iFUIBWARAIBWnQQFrDQEMBQsgEacgEVCtQgGGIRFBAXFFDQAgFAwBCyAOQgNRBEBCAyEODAQLIAdFIAcgCEZyRQRAIAhBCGsiCCkDAAwBC0EAIQcgDkICUQRAQgIhDgwECyAOp0IAIQ5BAXFFDQMgEwshD0IBIRIgCkFAaiIKIQsMAQsgCyAPeadBP3MiBGohAkIBIASthiAPhSEPDAMLQQAhAgwBCwsgDSAQQgBScUUNAiAMIBB5p0E/cyIEaiECQgEgBK2GIBCFIRALIAIgA0EBayIETQ0BIAQgACgCCCIJTw0CIAIgCU8NAyAAKAIEIgMgAkEDdGogAyAFaikDADcDACAFQQhrIQUgBCIDIAFLDQALCyAGQfAAaiQADwsgA0EBayAJQbCazwAQwyEACyACIAlBwJrPABDDIQALrgQCCH8IfiMAQfAAayIGJAAgACABIANqEJUtIAYgBCAFEOAcIAZCADcDaCAGIAEgAmoiAiIDNgJkIAYgATYCYAJAAkACQCABIANPDQAgAkECdEEEayEFIAYoAlghCiAGKQMgIRAgBigCVCEIIAYoAlAhByAGKQNAIQ4gBikDMCERIAYoAhAhCyAGKQMIIQ8gBigCKCEMIAYoAhghDSAGKQNIIRMgBikDOCEUIAYpAwAhEgNAIBKnQQFxBH9BAAVBAQshAgJAA0ACQAJAAkAgAkUEQCAPUEUNAUIAIQ9CACESQQEhAgwECwJ+AkAgEUICfSIVQgFYBEAgFadBAWsNAQwFCyARpyARUK1CAYYhEUEBcUUNACAUDAELIA5CA1EEQEIDIQ4MBAsgB0UgByAIRnJFBEAgCEEIayIIKQMADAELQQAhByAOQgJRBEBCAiEODAQLIA6nQgAhDkEBcUUNAyATCyEPQgEhEiAKQUBqIgohCwwBCyALIA95p0E/cyIEaiECQgEgBK2GIA+FIQ8MAwtBACECDAELCyANIBBCAFJxRQ0CIAwgEHmnQT9zIgRqIQJCASAErYYgEIUhEAsgAiADQQFrIgRNDQEgBCAAKAIIIglPDQIgAiAJTw0DIAAoAgQiAyACQQJ0aiADIAVqKAIANgIAIAVBBGshBSAEIgMgAUsNAAsLIAZB8ABqJAAPCyADQQFrIAlBsJrPABDDIQALIAIgCUHAms8AEMMhAAuaCQITfwJ+IwBB0AJrIhIkAAJAIAFBAkkNAEKAgICAgICAgMAAIAGtIhmAIhogGX5CgICAgICAgIDAAFKtAn8gAUGBIE8EQCABEJYsDAELQcAAIAEgAUEBdmsiBiAGQcAATxsLIRUgGnwhGiASQY0CaiEYQQEhCQNAQQEhCkEAIRYgASAMSwRAIAytIhkCfyAAIAxBDGxqIQcCQCABIAxrIgYgFUkNAAJAIAZBAkkEQCAGIQoMAQsCfwJAAkAgBygCDCINIAcoAgBJIgtFBEBBAiEKIAZBAkYNBCAHQRhqIQgDQCANIAgoAgAiDUsNAyAIQQxqIQggBiAKQQFqIgpHDQALDAELQQIhCkEBIAZBAkYNAhogB0EYaiEIA0AgDSAIKAIAIg1NDQIgCEEMaiEIIAYgCkEBaiIKRw0ACwsgBiEKCyAKIBVJDQIgC0UNASAKQQJJBEBBASEKDAILIApBAXYLIQggCkEMbCAHakEMayEGA0AgByAGQQMQ+iogBkEMayEGIAdBDGohByAIQQFrIggNAAsLIApBAXRBAXIMAQsgBiAVIAYgFUkbQQF0IARFDQAaIAdBICAGIAZBIE8bIgYgAiADQQBBACAFEIMNIAZBAXRBAXILIgpBAXYgDGqtfCAafiAMIAlBAXZrrSAZfCAafoV5pyEWCwJAAkAgEUECSQ0AIBIgEUECdGohFwNAIBEgGGotAAAgFkkNAQJ/IAMgFygCACIIQQF2IgsgCUEBdiIHaiINTyAIIAlyQQFxRXFFBEAgACAMIA1rQQxsaiEGIAhBAXFFBEAgBiALIAIgAyALQQFyZ0EBdEE+c0EAIAUQgw0LIAlBAXFFBEAgBiALQQxsaiAHIAIgAyAHQQFyZ0EBdEE+c0EAIAUQgw0LIAIhCAJAIAtFIAsgDSIJT3INACADIAkgC2siDiALIAsgDksiExsiD0kNACAGIAtBDGxqIQcgD0EMbCIQBEAgCCAHIAYgExsgEPwKAAALIAggEGohFAJAAkAgCyAOSwRAIAlBDGwgBmpBDGshDgNAIA4gB0EMayIPIBRBDGsiECAQKAIAIhMgDygCACIHSSILGyIJKQIANwIAIA5BCGogCUEIaigCADYCACAQIAtBDGxqIRQgDyAHIBNNQQxsaiIHIAZGDQIgDkEMayEOIAggFEcNAAsMAQsgD0UNASAGIAlBDGxqIQ8DQCAGIAcgCCAHKAIAIhAgCCgCACITSSILGyIJKQIANwIAIAZBCGogCUEIaigCADYCACAGQQxqIQYgCCAQIBNPQQxsaiIIIBRGDQIgByALQQxsaiIHIA9HDQALDAELIAchBgsgFCAIayIJRQ0AIAYgCCAJ/AoAAAsgDUEBdEEBcgwBCyANQQF0CyEJIBdBBGshF0EBIQYgEUEBayIRQQFLDQALDAELIBEhBgsgEkGOAmogBmogFjoAACASQQRqIAZBAnRqIAk2AgAgASAMSwRAIAZBAWohESAKQQF2IAxqIQwgCiEJDAELCyAJQQFxDQAgACABIAIgAyABQQFyZ0EBdEE+c0EAIAUQgw0LIBJB0AJqJAAL0wsCE38CfiMAQdACayIUJAACQCABQQJJDQBCgICAgICAgIDAACABrSIZgCIaIBl+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARCWLAwBC0HAACABIAFBAXZrIgogCkHAAE8bCyEVIBp8IRkgFEGNAmohF0EBIQsDQEEBIQpBACERIAEgEksEQCASrSIaAn8gACASQQJ0aiEPAkAgASASayIGIBVJDQACQCAGQQJJBEAgBiEJDAELAn8CQAJAIA8oAgQiBygCBCIKIA8oAgAiCSgCBCAHKAIIIgcgCSgCCCIJIAcgCUkbEJknIgggByAJayAIGyIOQQBOBEBBAiEJIAZBAkYNBCAPQQhqIQwDQCAMKAIAIhEoAgQiCCAKIBEoAggiCiAHIAcgCksbEJknIhEgCiAHayARG0EASA0DIAxBBGohDCAKIQcgCCEKIAYgCUEBaiIJRw0ACwwBC0ECIQlBASAGQQJGDQIaIA9BCGohDANAIAwoAgAiESgCBCIIIAogESgCCCIKIAcgByAKSxsQmSciESAKIAdrIBEbQQBODQIgDEEEaiEMIAohByAIIQogBiAJQQFqIglHDQALCyAGIQkLIAkgFUkNAiAOQQBODQEgCUECSQRAQQEhCQwCCyAJQQF2CyEGIAlBAnQgD2pBBGshBwNAIA8oAgAhCiAPIAcoAgA2AgAgByAKNgIAIAdBBGshByAPQQRqIQ8gBkEBayIGDQALCyAJQQF0QQFyDAELIAYgFSAGIBVJG0EBdCAERQ0AGiAPQSAgBiAGQSBPGyIKIAIgA0EAQQAgBRDvCSAKQQF0QQFyCyIKQQF2IBJqrXwgGX4gEiALQQF2a60gGnwgGX6FeachEQsCQAJAIBNBAkkNACAUIBNBAnRqIQ8DQCATIBdqLQAAIBFJDQECfyADIA8oAgAiBkEBdiIIIAtBAXYiDGoiCU8gBiALckEBcUVxRQRAIAAgEiAJa0ECdGohByAGQQFxRQRAIAcgCCACIAMgCEEBcmdBAXRBPnNBACAFEO8JCyALQQFxRQRAIAcgCEECdGogDCACIAMgDEEBcmdBAXRBPnNBACAFEO8JCyMAQRBrIgwkAAJAIAhFIAggCU9yDQAgAyAJIAhrIg4gCCAIIA5LIgYbIg1JDQAgByAIQQJ0aiILIAcgBhshBiANQQJ0Ig0EQCACIAYgDfwKAAALIAwgBjYCDCAMIAIgDWo2AgggDCACNgIEIAcgCUECdGohBgJAIAggDksEQCAGQQRrIQsgDEEEaiIIKAIEIQYgCCgCCCEOA0ACQCALIAZBBGsiBiAOQQRrIg4gBigCACINKAIEIA4oAgAiECgCBCANKAIIIg0gECgCCCIQIA0gEEkbEJknIhYgDSAQayAWGyINQQBOIhAbKAIANgIAIAYgDUEddkEEcWohBiAOIBBBAnRqIg4gB0YNACALQQRrIQsgAiAGRw0BCwsgCCAGNgIEIAggDjYCCAwBCyAMQQRqIQgCQCAGIAsiB0YNACAIKAIAIgsgCCgCBCIWRg0AIAgoAgghDgNAAkAgDiALIAcgBygCACINKAIEIAsoAgAiECgCBCANKAIIIg0gECgCCCIQIA0gEEkbEJknIhggDSAQayAYGyINQQBOIhAbKAIANgIAIA5BBGohDiALIBBBAnRqIgsgFkYNACAHIA1BHXZBBHFqIgcgBkcNAQsLIAggDjYCCCAIIAs2AgALCyAMKAIIIAwoAgQiB2siBkUNACAMKAIMIAcgBvwKAAALIAxBEGokACAJQQF0QQFyDAELIAlBAXQLIQsgD0EEayEPQQEhBiATQQFrIhNBAUsNAAsMAQsgEyEGCyAUQY4CaiAGaiAROgAAIBRBBGogBkECdGogCzYCACABIBJLBEAgBkEBaiETIApBAXYgEmohEiAKIQsMAQsLIAtBAXENACAAIAEgAiADIAFBAXJnQQF0QT5zQQAgBRDvCQsgFEHQAmokAAuJBgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDg0BAgMEBQYHCAkKCwwNAAsgAiAAQRBqNgIMIAFB9LPNAEEGQfqzzQBBBSAAQQhqQdSzzQBB/7PNAEEDIAJBDGpB5LPNABCOGAwNCyACIABBEGo2AgwgAUGCtM0AQQ5B+rPNAEEFIABBCGpB1LPNAEGQtM0AQQMgAkEMakHks80AEI4YDAwLIAFBk7TNAEEFEPs1DAsLIAFBmLTNAEEGEPs1DAoLIAIgAEEQajYCDCABQZ60zQBBDkGstM0AQQwgAEEIakHUs80AQbi0zQBBByACQQxqQeSzzQAQjhgMCQsgAiAAQRhqNgIMIAFBv7TNAEEHQca0zQBBAyAAQQhqQdSzzQBBybTNAEEHIABBEGpB1LPNAEHQtM0AQQcgAkEMakHks80AEIkXDAgLIAIgAEEQajYCDCABQde0zQBBCEHGtM0AQQMgAEEIakHUs80AQcm0zQBBByACQQxqQeSzzQAQjhgMBwsgAiAAQRBqNgIMIAFB37TNAEEJQca0zQBBAyAAQQhqQdSzzQBB0LTNAEEHIAJBDGpB5LPNABCOGAwGCyACIABBEGo2AgwgAUHotM0AQQZB7rTNAEEGIABBCGpB1LPNAEH0tM0AQQcgAkEMakHks80AEI4YDAULIAIgAEEBajYCDCABQYy1zQBBDEGYtc0AQQQgAkEMakH8tM0AEPYYDAQLIAIgAEEEajYCDCABQay1zQBBFEHAtc0AQQUgAkEMakGctc0AEPYYDAMLIAIgAEEBajYCDCABQcW1zQBBFEGYtc0AQQQgAkEMakH8tM0AEPYYDAILIAIgAEEBajYCDCABQey1zQBBFkHGtM0AQQMgAEEIakHUs80AQYK2zQBBBiACQQxqQdy1zQAQjhgMAQsgAiAAQQhqNgIMIAFBqLbNAEEIQbC2zQBBCCAAQQRqQYi2zQBBuLbNAEEDIAJBDGpBmLbNABCOGAsgAkEQaiQAC4kOAQt/IwBBkA9rIgwkACAMQQY2AhggDEEANgIcIAxBIGpBAEGQAvwLACAMQbACakEAQaAE/AsAIARBAWutIAcgCCAJEJUjIARBAUcEQCABIQogAiEOAn8gA0UEQCAMQQhqEP4nIAwoAgwhCyAMKAIIDAELIAxBEGogACADELkpIAwoAhQhCyAMKAIQCyEAIwBBgAJrIhAkACAQQQBBgAL8CwACQAJAAkACQAJAIAMEQAJAIA4EQCAKKAIAIQICQCADQQFHBEAgDkEBayADQQJrTQ0BIApBBGohASADQQFrIQ0DQCABKAIAIg8gAiACIA9JGyECIAFBBGohASANQQFrIg0NAAsLQQAhAQNAIAFBgAJJBEAgASAQaiABOgAAIAEgAk8NBCABIAEgAklqIgEgAk0NAQwECwsgAUGAAkGc69EAEMMhAAsgDiAOQazr0QAQwyEAC0EAQQBB7OrRABDDIQALIAJBAWohDSAQQQFqIRFBACECA0AgAiIPIA5GDQQgAkEBaiECQQAhASAKIA9BAnQiEmooAgBB/wFxIRMCQANAIAFBgAJGDQUgASAQai0AACATRg0BIA0gAUEBaiIBRw0ACyANIQELIAsgD0YNAiAAIBJqIAE2AgAgAUH/AUsNBSABIBBqLQAAIQ8gAQRAIBEgECAB/AoAAAsgECAPOgAAIAIgA0cNAAsLIBBBgAJqJAAMBAsgCyALQYzr0QAQwyEAC0GAAkGAAkHM6tEAEMMhAAsgDiAOQfzq0QAQwyEACyABQYACQdzq0QAQwyEACyAMQRxqIRAgDEEYaiEOQQAhCkEAIQECQCADRQ0AQQAgA2shDwJAA0AgAyAKQQFqIgIgAiADSRshESAKIAsgCiALSxshDSAAIApBAnRqIQICQAJ/AkAgAQJ/AkADQCAKIA1GDQcgAigCAEUNASACQQRqIQIgESAKQQFqIgpHDQALQQAMAQtBACADIApNDQIaIAogD2ohESAKIAogCyAKIAtLGyISayETQQAhDQNAIA0gE0YNBCACKAIADQIgAkEEaiECIBEgDUEBayINRw0ACyADIAprCyICIAEgAksbIQEMBQsgCiANayEKQQAgDWsLIQIgASACIAEgAksbIQEgAyAKSw0BDAMLCyASIAtBnOzRABDDIQALIA0gC0GM7NEAEMMhAAsgEEEANgIAIA4gDigCACICIAFnQR9zIg4gAiAOSRtBACABQQJPGyIPNgIAIAMEQCAAQQRqIRJBAiAPdCERQX8gD3RBf3NBCXQgD3IhE0EAIQFBACEKA0ACQAJAAkACfwJAAkAgASALSQRAIAAgAUECdCINaigCACICRQRAQQEhAiABQQFqIg4gA08NAyALIAFrIRQgAyABayEOIA0gEmohDQNAAkAgAiAURwRAIA0oAgBFDQEMBQsgCyALQczr0QAQwyEACyANQQRqIQ0gDiACQQFqIgJHDQALIA4hAgwCCyAKIAtJBEAgACAKQQJ0aiACIA9qNgIAIAFBAWoMBAsgCiALQfzr0QAQwyEACyABIAtBvOvRABDDIQALIAEgAmohDiACRQ0DCyAKIAsgCiALSxshASAAIApBAnRqIQ0CQANAIAIgEUkNASABIApHBEAgDSATNgIAIBAgCkEBaiIKNgIAIA1BBGohDSACIBFrQQFqIgJFDQUMAQsLIAEgC0Hc69EAEMMhAAsgCiALTw0BIA1BfyACZ0Efc0EAIAJBAUcbIgF0IAJqQQl0IAFyNgIAIA4LIQEgECAKQQFqIgo2AgAMAgsgCiALQezr0QAQwyEACyAOIQELIAEgA0kNAAsLIAxB0AZqQQBBwAj8CwACQAJAAkACQCAMKAIcIg4EQEEAIQMgACECA0AgAyALRg0CIAIoAgBB/wNxIgFBkAJPDQMgDEHQBmogAUECdGoiASABKAIAQQFqNgIAIAJBBGohAiAOIANBAWoiA0cNAAsLQQEgDCgCGCIBQQBHrSAHIAggCRDlEiABDQIMAwsgCyALQcil0AAQwyEACyABQZACQdil0AAQwyEAC0EEIAwoAhhBAWutIAcgCCAJEOUSCyAMQdAGakGQAiAMKAIYIARqIgEgASAFIAYgDEEgakGQAiAMQbACakGQAiAHIAggCRDyCCAMKAIcIgUEQEEAIQIgACEBA0AgAiALRgRAIAsgC0GopdAAEMMhAAsCQCABKAIAIgRB/wNxIgNBjwJNBEAgDEEgaiADai0AACAMQbACaiADQQF0ajMBACAHIAggCRDlEiAMKAIYIANBAWtNDQEgBCAEQQl2rSAHIAggCRDlEgwBCyADQZACQbil0AAQwyEACyABQQRqIQEgBSACQQFqIgJHDQALC0EBQgEgByAIIAkQ5RIgACALEIAxCyAMQZAPaiQAC98EAgZ/AX4jAEGAAWsiBCQAIAQgAzYCDCAEIAI2AgggBEFAayIDIAEQzgYCQEEMQQQQrTYiAgRAIAIgBCkCQDcCACACQQhqIARByABqIgUoAgA2AgAgAyAEQQhqIgYQ8y0QzgZBDEEEEK02IgNFDQEgAyAEKQJANwIAIANBCGogBSgCADYCACAEIAM2AhggBCACNgIUIARBIjoAECAEIAYQ9C0iAjYCHAJAAkAgASgCFCIFBEAgAUEMaiEGIAEoAhAhB0EAIQMDQCADIAdqIggsAAAiCUEATiACIAlLcUUEQCABIAMQizsNAwsgBSADQQFqIgNHDQALCyAEQcgAaiAEQRhqKAIANgIAIAQgBCkCEDcDQCAEQcwAaiABQTD8CgAAIAQpAgghCiAAIARBQGtBPPwKAAAgAEEAOgBEIAAgCjcCPAwBCyAEIAM2AiAgBCAINgIkIARBAzYCLCAEQayChAE2AiggBEIDNwI0IARBOzYCVCAEQTs2AkwgBEGRCjYCRCAEIARBQGs2AjAgBCAEQRxqNgJQIAQgBEEgajYCSCAEIARBJGo2AkAgAEEEaiAEQShqEJkOIABBAjoARCAAQY2AgIB4NgIAIARBEGoQvAwgBCgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgBEEIahC7IwsgARC8DCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCAGEPseCyABKAIYIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBGGoQ+x4LIARBgAFqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC/sHAQl/IAFB1ABqIQYCQAJAA0ACQAJ/AkAgASgCWCIIQQRJDQAgBigCACIFLAAAIgJB/wFxIQMgAkEATgRAIAEgCEEBazYCWCABIAVBAWo2AlQMAwsgBS0AASEEIAJBPmpB/wFxQR1NBEAgBMAiAkFATg0BIAEgCEECazYCWCABIAVBAmo2AlQgA0EGdEHAD3EgAkE/cXIhAwwDCyAFLQACIQcCQCACQW9NBEAgA0GAgMYAai0AACAEQYD/xQBqLQAAcSAHQQZ2ckECRg0BDAILIANBgIDGAGotAAAgBEGA/8UAai0AAHEgB0EGdnIgBS0AAyICQcABcUECdHJBggRHDQEgASAIQQRrNgJYIAEgBUEEajYCVCACQT9xIAdBBnRBwB9xIARBDHRBgOAPcSADQRJ0QYCA8ABxcnJyDAILIAEgCEEDazYCWCABIAVBA2o2AlQgB0E/cSAEQQZ0QcAfcSADQQx0QYDgA3FyciEDDAILAn9BgIDEACAGKAIEIglFDQAaIAYoAgAiCiwAACIHQf8BcSEEAkACQCAHQQBIBEAgCUEBRyAHQQtqQf8BcUHNAU9xRQRAIAYgCUEBazYCBCAGIApBAWo2AgAMAwsgCi0AASEDQYABIQJBvwEhBQJAAkACQAJAIARB8AFrDgUBAwMDAgALIARB7QFHBEAgBEHgAUcNA0GgASECDAMLQZ8BIQUMAgtBkAEhAgwBC0GPASEFCyADIAJrQf8BcSAFIAJrQf8BcUsEQCAGIApBAWo2AgAgBiAJQQFrNgIEDAMLIApBAmohAiAHQWBJDQEgCUECRgRAIAZBADYCBCAGIAI2AgAMAwsgAiwAACIFQUBOBEAgBiACNgIAIAYgCUECazYCBAwDCyAGIAlBA2s2AgQgBiAKQQNqNgIAIAdBb0sNAiAFQT9xIANBBnRBwB9xIARBDHRBgOADcXJyDAMLIAYgCUEBazYCBCAGIApBAWo2AgAgBAwCCyAGIAI2AgAgBiAJQQJrNgIEIARBBnRBwA9xIANBP3FyDAELQf3/AwsLIQNBgIDEACEFIANBgIDEAEYNAwsgASgChAEgA0sEQEEAIQgMAgsCf0H/H0H//wMgASgCXCIELQAsGyADTwRAIANBBnYiAiAEKAIISQRAIAQoAgQgAkEBdGovAAAgA0E/cWoMAgsgBCgCFEEBawwBCyAEIAMQwC4LIgcgBCgCFCICSQR/IAQoAhAgB0ECdGooAAAFIAULIAQoAgAgAiAHSxsiCEF/Rw0BIAEtAIgBIgJBAUYNAAtBfyEIIAMhBQJAAkAgAkEBaw4CAAEDCwALQf3/g4AEIQgLIAMhBQsgACAINgIEIAAgBTYCAAvvBgIIfgJ/IwBBIGsiCiQAIApCADcDECAKQvnq0NDnyaHk4QA3AxggCkLP1tO+0ser2UI3AwggCkLW64Lu6v2J9eAANwMAQsXP2bLx5brqJyECAkAgAUEgSQRAIAEhCwwBCyAKKQMYIQIgCikDECEDIAopAwghBCAKKQMAIQUgASELA0AgACkAAELP1tO+0ser2UJ+IAV8Qh+JIgZCh5Wvr5i23puef34hBSAAQRhqKQAAQs/W077Sx6vZQn4gAnxCH4kiB0KHla+vmLbem55/fiECIABBEGopAABCz9bTvtLHq9lCfiADfEIfiSIIQoeVr6+Ytt6bnn9+IQMgAEEIaikAAELP1tO+0ser2UJ+IAR8Qh+JIglCh5Wvr5i23puef34hBCAAQSBqIQAgC0EgayILQR9LDQALIAogBTcDACAKIAQ3AwggCiADNwMQIAogAjcDGCAEQgeJIAVCAYl8IANCDIl8IAJCEol8IAZCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCUKp2eX7kODW+V5+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAIQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAdCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0hAgsgAiABrXwhAgJAIAtBCEkEQCAAIQEMAQsDQCAAKQAAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef34gAoVCG4lCh5Wvr5i23puef35CnaO16oOxjYr6AH0hAiAAQQhqIgEhACALQQhrIgtBB0sNAAsLIAtBA00EfyABBSALQQRrIQsgATUAAEKHla+vmLbem55/fiAChUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqCyEAIAsEQANAIAAxAABC/wGDQsXP2bLx5brqJ34gAoVCC4lCh5Wvr5i23puef34hAiAAQQFqIQAgC0EBayILDQALCyAKQSBqJAAgAkIhiCAChULP1tO+0ser2UJ+IgJCHYggAoVC+fPd8Zn2masWfiICQiCIIAKFC5gSAQZ/IwBBoAFrIggkAAJAAkACQAJAIARBAXEEQCAIIAU2AgwgCEFAayIEIAMQyi8gCEEQaiIDIAhBDGogBBDwLSAGRQ0BIAhBADoAhAEgCEIENwJ8IAggBzYCeCAIIAY2AnQgCEGIAWogAyAIKAIcELURIAgoAogBIQkgCCAIKQKMATcCmAEgCEEBNgKUASMAQSBrIgUkACAFQQA2AgggBUKAgICAEDcCACAFQez3gAE2AhAgBUKggICADjcCFCAFIAU2AgwgBUEMaiEGIwBB0ABrIgMkACADQS1BKyAIQRxqIgooAgAiB0EASBs2AgggAyAHIAdBH3UiDHMgDGsiByAHQTxtIgdBPGxrIgxBH3UiC0E8cSAMaiIMNgIMIAMgByALaiIHIAdBPG0iB0E8bGsiC0EfdSINQTxxIAtqNgIQIAMgByANajYCFAJ/IAxFBEAgA0EDNgIsIANBkMOGATYCKCADQQM2AhwgA0H4woYBNgIYIANBAzYCJCADQZwDNgJEIANBnAM2AjwgA0HvGzYCNCADIANBMGo2AiAgAyADQRBqNgJAIAMgA0EUajYCOCADIANBCGo2AjAgBigCACAGKAIEIANBGGoQywoMAQsgA0EENgIsIANB+MOGATYCKCADQQQ2AhwgA0HYw4YBNgIYIANBBDYCJCADQZwDNgJMIANBnAM2AkQgA0GcAzYCPCADQe8bNgI0IAMgA0EwajYCICADIANBDGo2AkggAyADQRBqNgJAIAMgA0EUajYCOCADIANBCGo2AjAgBigCACAGKAIEIANBGGoQywoLIANB0ABqJAAEQEGU+IABQTcgBUEfakGE+IABQcz4gAEQ1R4ACyAEIAUpAgA3AgwgBEEUaiAFQQhqKAIANgIAIAQgCTYCMCAEIAhBlAFqIgMpAgA3AgAgBEEIaiADQQhqKAIANgIAIAQgCigCADYCGCAEIAhB9ABqIgMpAgA3AhwgBEEkaiADQQhqKQIANwIAIARBLGogA0EQaigCADYCACAFQSBqJAAgCEGRDDYCJCAIQQE2AiwgCEGs94ABNgIoIAhCATcCNCAIIAQ2AiAgCCAIQSBqNgIwIAEgCEEoaiACKAIUEQIARQ0CIABBk4CAgHg2AgAgBBCJLwwECwJAIAYEQCAIQgE3AjQgCEEBNgIsIAhBrPeAATYCKCAIQZEMNgJ4IAhBADoAbCAIQgQ3AmQgCCAHNgJgIAggBjYCXCAIQYCAgIB4NgJMIAhBATYCQCAIIAMoAgA2AnAgCCADKQIENwJEIAggCEH0AGo2AjAgCCAIQUBrIgM2AnQgASAIQShqIAIoAhQRAgBFDQEgAEGTgICAeDYCACADEIkvDAULIAhBATYCRCAIQaz3gAE2AkAgCEIBNwJMIAhBkww2AiwgCCADNgIoIAggCEEoajYCSCABIAhBQGsgAigCFBECAEUNAyAAQZOAgIB4NgIADAQLIAhBQGsQiS8MAgsgCEEoaiEGIAhBEGohBCMAQUBqIgMkACADQSBqIglBJkEAQQFBARCgGCADKAIkIQUCQAJAAkACQCADKAIgQQFHBEAgA0EANgIQIAMgAygCKDYCDCADIAU2AgggCSAEIAQoAgwiDBD3ESADKAIgIgpFDQEgAygCKCEFIAMoAiQhByADIApBDXUiBDYCFAJAIARBkM4ATwRAIANBATYCNCADQaC/gAE2AjAgA0EBNgIkIANBmL+AATYCICADQQE2AiwgA0GcAzYCPCADIANBOGo2AiggAyADQRRqNgI4IANBCGogCRDuPEUNAQwFCyADQQhqIgkgBEH//wNxQeQAbiILEIsYDQQgCSAEIAtB5ABsaxCLGA0ECyADKAIQIQkgA0EIaiIEQQEQhC4gAygCDCADKAIQakEtOgAAIAMgCUEBajYCECAKQQN2IgpB/wdxIglB3QVPDQIgBCAJIAlBqLmAAWotAAAiC2pBBnYQixgNAyADKAIQIQkgBEEBEIQuIAMoAgwgAygCEGpBLToAACADIAlBAWo2AhAgBCAKIAtqQQF2QR9xEIsYDQMgAygCECEJIARBARCELiADKAIMIAMoAhBqQdQAOgAAIAMgCUEBajYCECADIAVBgJTr3ANrIAUgBUH/k+vcA0siCRsiBTYCGCAEIAdBkBxuEIsYDQMgAygCECEKIARBARCELiADKAIMIAMoAhBqQTo6AAAgAyAKQQFqNgIQIAQgB0E8biIKQTxwEIsYDQMgAygCECELIARBARCELiADKAIMIAMoAhBqQTo6AAAgAyALQQFqNgIQIAQgByAKQTxsayAJahCLGA0DAkAgBUUNACAFIAVBwIQ9biIHQcCEPWxGBEAgA0EBNgI0IANBxL+AATYCMCADQQE2AiQgA0G8v4ABNgIgIANBATYCLCADQTs2AjwgAyAHNgIcIAMgA0E4ajYCKCADIANBHGo2AjggBCADQSBqEO48DQUMAQsgBSAFQegHbiIEQegHbEYEQCADQQE2AjQgA0Hcv4ABNgIwIANBATYCJCADQby/gAE2AiAgA0EBNgIsIANBOzYCPCADIAQ2AhwgAyADQThqNgIoIAMgA0EcajYCOCADQQhqIANBIGoQ7jwNBQwBCyADQQE2AjQgA0H0v4ABNgIwIANBATYCJCADQby/gAE2AiAgA0EBNgIsIANBOzYCPCADIANBOGo2AiggAyADQRhqNgI4IANBCGogA0EgahDuPA0ECyADQQE6ACEgA0GBAjsAIiADQQE6ACAgA0EgaiADQQhqIAwQ/gcNAyAGIAMpAgg3AgAgBkEIaiADQRBqKAIANgIAIANBQGskAAwECyAFIAMoAihBmLmAARD9LwALQcTAgAFBK0HwwIABEMskAAsgCUHdBUGIv4ABEMMhAAtBgMGAAUE0IANBIGpBsLiAAUG0wYABENUeAAsgCEGFETYCeCAIQQE2AkQgCEGs94ABNgJAIAhCATcCTCAIIAY2AnQgCCAIQfQAajYCSCABIAhBQGsgAigCFBECAARAIABBk4CAgHg2AgAgBhDeOwwDCyAIQShqEN47DAELIAhBQGsQiS8LIABBlICAgHg2AgALIAhBoAFqJAALuAQCDX8BfiAAIAEoAiggASgCJEEDdGoiAygCBCIJNgIEIAAgASgCGCABKAIUQQN0aiIEKAIEIgY2AgAgBC0AAiEHIAMtAAIhCCABKAIgIAEoAhxBA3RqIgUtAAMhCiADLQADIQsgBC0AAyEMIAUvAQAhDSADLwEAIQ4gBC8BACEPIAUoAgQhBAJAIAUtAAIiA0ECTwRAAn8gAkUgA0EZSXJFBEAgASADQQVrEKAuIAEQ/RgaIAEgASgCBCIDQQVqNgIEQQV0IARqIAEoAgAgA3RBG3ZqDAELIAEgAxCgLiABEP0YGiAEagshAiABKQIsIRAgASACNgIsIAEgEDcCMAwBCyAGRSECIANFBEAgAUEsaiIDIAZBAEdBAnRqKAIAIQQgASADIAJBAnRqKAIAIgI2AiwgASAENgIwDAELIAEgASgCBCIFQQFqNgIEIAFBLGohAwJAAkAgAiAEaiABKAIAIAV0QR92aiIEQQNGBEBBASADKAIAQQFrIgIgAkEBTRshAgwBC0EBIAMgBEECdGooAgAiAiACQQFNGyECIARBAUYNAQsgASABKAIwNgI0CyABIAEoAiw2AjAgASACNgIsCyAAIAI2AgggCARAIAAgASAIEKAuIAlqNgIECyAHIAhqQRRPBEAgARD9GBoLIAcEQCAAIAEgBxCgLiAGajYCAAsgARD9GBogAUEUaiABIA8gDBCPNiABQSRqIAEgDiALEI82IAEQ/RgaIAFBHGogASANIAoQjzYLzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBjNHDAEERIAJBDGpB/NDDABDQEwwSCyACIABBBGo2AgwgAUGw0cMAQQ0gAkEMakGg0cMAENATDBELIAIgAEEEajYCDCABQb3RwwBBCSACQQxqQfzQwwAQ0BMMEAsgAiAAQQRqNgIMIAFBxtHDAEELIAJBDGpB/NDDABDQEwwPCyACIABBBGo2AgwgAUHR0cMAQQogAkEMakH80MMAENATDA4LIAIgAEEEajYCDCABQdvRwwBBCyACQQxqQfzQwwAQ0BMMDQsgAiAAQQRqNgIMIAFB5tHDAEEMIAJBDGpB/NDDABDQEwwMCyABQfLRwwBBDBD7NQwLCyACIABBBGo2AgwgAUH+0cMAQRIgAkEMakH80MMAENATDAoLIAIgAEEEajYCDCABQZDSwwBBCCACQQxqQfzQwwAQ0BMMCQsgAiAAQQRqNgIMIAFBmNLDAEEJIAJBDGpB/NDDABDQEwwICyACIABBDGo2AgwgAUHE0sMAQQcgAEGk0sMAIAJBDGpBtNLDABCDDwwHCyACIABBBGo2AgwgAUHL0sMAQQggAkEMakH80MMAENATDAYLIAIgAEEEajYCDCABQdPSwwBBFCACQQxqQfzQwwAQ0BMMBQsgAiAAQQRqNgIMIAFB59LDAEEMIAJBDGpB/NDDABDQEwwECyACIABBBGo2AgwgAUHz0sMAQQ4gAkEMakH80MMAENATDAMLIAFBgdPDAEEaEPs1DAILIAFBm9PDAEEYEPs1DAELIAIgAEEEajYCDCABQcTTwwBBEyACQQxqQbTTwwAQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGQucwAQREgAkEMakGAucwAENATDBILIAIgAEEEajYCDCABQbS5zABBDSACQQxqQaS5zAAQ0BMMEQsgAiAAQQRqNgIMIAFBwbnMAEEJIAJBDGpBgLnMABDQEwwQCyACIABBBGo2AgwgAUHKucwAQQsgAkEMakGAucwAENATDA8LIAIgAEEEajYCDCABQdW5zABBCiACQQxqQYC5zAAQ0BMMDgsgAiAAQQRqNgIMIAFB37nMAEELIAJBDGpBgLnMABDQEwwNCyACIABBBGo2AgwgAUHqucwAQQwgAkEMakGAucwAENATDAwLIAFB9rnMAEEMEPs1DAsLIAIgAEEEajYCDCABQYK6zABBEiACQQxqQYC5zAAQ0BMMCgsgAiAAQQRqNgIMIAFBlLrMAEEIIAJBDGpBgLnMABDQEwwJCyACIABBBGo2AgwgAUGcuswAQQkgAkEMakGAucwAENATDAgLIAIgAEEMajYCDCABQci6zABBByAAQai6zAAgAkEMakG4uswAEIMPDAcLIAIgAEEEajYCDCABQc+6zABBCCACQQxqQYC5zAAQ0BMMBgsgAiAAQQRqNgIMIAFB17rMAEEUIAJBDGpBgLnMABDQEwwFCyACIABBBGo2AgwgAUHruswAQQwgAkEMakGAucwAENATDAQLIAIgAEEEajYCDCABQfe6zABBDiACQQxqQYC5zAAQ0BMMAwsgAUGFu8wAQRoQ+zUMAgsgAUGfu8wAQRgQ+zUMAQsgAiAAQQRqNgIMIAFByLvMAEETIAJBDGpBuLvMABDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQZS5zQBBESACQQxqQYS5zQAQ0BMMEgsgAiAAQQRqNgIMIAFBuLnNAEENIAJBDGpBqLnNABDQEwwRCyACIABBBGo2AgwgAUHFuc0AQQkgAkEMakGEuc0AENATDBALIAIgAEEEajYCDCABQc65zQBBCyACQQxqQYS5zQAQ0BMMDwsgAiAAQQRqNgIMIAFB2bnNAEEKIAJBDGpBhLnNABDQEwwOCyACIABBBGo2AgwgAUHjuc0AQQsgAkEMakGEuc0AENATDA0LIAIgAEEEajYCDCABQe65zQBBDCACQQxqQYS5zQAQ0BMMDAsgAUH6uc0AQQwQ+zUMCwsgAiAAQQRqNgIMIAFBhrrNAEESIAJBDGpBhLnNABDQEwwKCyACIABBBGo2AgwgAUGYus0AQQggAkEMakGEuc0AENATDAkLIAIgAEEEajYCDCABQaC6zQBBCSACQQxqQYS5zQAQ0BMMCAsgAiAAQQxqNgIMIAFBzLrNAEEHIABBrLrNACACQQxqQby6zQAQgw8MBwsgAiAAQQRqNgIMIAFB07rNAEEIIAJBDGpBhLnNABDQEwwGCyACIABBBGo2AgwgAUHbus0AQRQgAkEMakGEuc0AENATDAULIAIgAEEEajYCDCABQe+6zQBBDCACQQxqQYS5zQAQ0BMMBAsgAiAAQQRqNgIMIAFB+7rNAEEOIAJBDGpBhLnNABDQEwwDCyABQYm7zQBBGhD7NQwCCyABQaO7zQBBGBD7NQwBCyACIABBBGo2AgwgAUHMu80AQRMgAkEMakG8u80AENATCyACQRBqJAALgAUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHS0EBIAR0QYMBcUVyRQRAIAVBOGoiBEEANgIAIAVCgICAgIABNwIwIAVBMGoiBkEBEIctIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6gggBSgCUCIDQQhHBEAgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2y8MAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQowsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAILIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELQQRBEBCjPQALIAVBgAFqJAALgAUBAn8jAEGAAWsiBSQAIAUgBDoAFwJAAkAgBEH/AXEiBEEHS0EBIAR0QYMBcUVyRQRAIAVBOGoiBEEANgIAIAVCgICAgMAANwIwIAVBMGoiBkEBEIYtIAVBIGoiByAEKAIANgIAIAVBADYCLCAFQoCAgIAQNwIkIAUgBSkCMDcDGCAEIAJBCGopAgA3AwAgBUEANgJAIAUgAzYCRCAFIAIpAgA3AzAgBSABLQBkOgBIIAVB0ABqIAYgBUEYaiICQX8Q6QggBSgCUCIDQQhHBEAgACAFKQNYNwMIIABBEGogBUHgAGopAwA3AwAgACAFKAJUNgIEIAAgAzYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEAIAIQ2i8MAwsgBUHgAGogBUEoaikDADcDACAFQdgAaiAHKQMANwMAIAUgBSkDGDcDUCAFQQA2AmggBUH0AGoiAiABQdgAahDCBiAFQQhqIAVB0ABqIAVB6ABqIAIQogsgBSgCDCEDIAUoAgghBEEQQQQQrTYiAkUNASACIAQ2AgggAkKBgICAEDcCACACIAM2AgwCQCABKAJQIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFB0ABqELsjCyABQbTIzQA2AlQgASACNgJQIABBCDYCACAFQTxqIAUoAjQgBSgCOCAFKAIwKAIQEQEADAILIAVBATYCNCAFQbzUzQA2AjAgBUIBNwI8IAVBrgM2AlQgBSAFQdAAajYCOCAFIAVBF2o2AlAgAEEEaiAFQTBqEJkOIABBATYCACACQQxqIAIoAgQgAigCCCACKAIAKAIQEQEADAELQQRBEBCjPQALIAVBgAFqJAAL0AcCDX8CfiMAQbABayIDJAAgASgCECECAkACQAJAIAEoAhQiBkEISQ0AIAIgBkF4cWpBCGsiBEUNACAEKAIAQX9GDQELIAMgARDUOiIINgIMIANBEGoiBSAIEMQbIAEoAhgiBCAEKAIAIgdBAWo2AgACQAJAIAdBAE4EQCADIAQ2AogBIAMgASkCHDcCjAEgBSADQYgBahDZICENIAZBEEkNAiAGQQN2IQcgA0HIAGohDiADQewAaiEKQQAhBANAIAJBCGoiBikDACEPIAIpAwAhEAJAIAEgBBCWJUUEQCADQRBqIA0gEKciAiAPpyACaxCJEAwBCyAKEOY6IAMoAmxFDQMgAygCfEEBaiILQQN2IAtBB3FBAEdqIgIgAygCeCIFSwRAIAIgBWshDCADKAJwIgkgAkkEQCAKIAlBAXQiBSACENAqIgkgBSAJSxsQ6BkgAygCeCEFCyAMBEAgAygCdCAFakEAIAz8CwALIAMgAjYCeAsgAyALNgJ8IAMoAlAiAiADKAJIRgRAIA5B/OmAARCxKAsgAygCTCACQQR0aiIFQgA3AwggBUIANwMAIAMgAkEBajYCUAsgBEEBaiEEIAYhAiAHQQFrIgdBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAIRgRAIAAgARDbDCABEOklDAILIANBADYCmAFBACADQZQBaiADQQxqIANBmAFqQezsgAEQrysACyABENQ6IQIgA0EUaiABEPk0IAMgAjYCMCADQQA2AiwgAyABNgIQIwBBsAFrIgEkACADQRBqIgIoAgAhBiABQaABaiACQRRqKQIANwIAIAFBmAFqIAJBDGopAgA3AgAgASACKQIENwKQASACKAIgIQUgAigCHCECIAYQ1DohBCAGENQ6GiABQRBqIAQgAmsQxBsgASAFNgKsASABIAI2AqgBIAEgBjYCjAEgASgCkAEhBAJAAkAgAiAFRwRAA0AgAUEQagJ/AkAgBARAIAIgASgCoAFPDQUgASgClAEgAiABKAKcAWoiB0EDdmotAABB/wFzIAdBB3F2QQFxDQELIAEgAkEBajYCqAEgAUEIaiAGIAIQ2isgASgCDCEIIAEoAggMAQsgASACQQFqNgKoAUEACyAIELsBIAUgAkEBaiICRw0ACwsCQCAERQ0AIAQgBCgCACICQQFrNgIAIAJBAUcNACABQZABahD7HgsgACABQRBqIgAQ2wwgABDpJSABQbABaiQADAELQazsgAFBIEHM7IABEJ8pAAsLIANBsAFqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBzPmAAUERIAJBDGpBvPmAARDQEwwSCyACIABBBGo2AgwgAUHw+YABQQ0gAkEMakHg+YABENATDBELIAIgAEEEajYCDCABQf35gAFBCSACQQxqQbz5gAEQ0BMMEAsgAiAAQQRqNgIMIAFBhvqAAUELIAJBDGpBvPmAARDQEwwPCyACIABBBGo2AgwgAUGR+oABQQogAkEMakG8+YABENATDA4LIAIgAEEEajYCDCABQZv6gAFBCyACQQxqQbz5gAEQ0BMMDQsgAiAAQQRqNgIMIAFBpvqAAUEMIAJBDGpBvPmAARDQEwwMCyABQbL6gAFBDBD7NQwLCyACIABBBGo2AgwgAUG++oABQRIgAkEMakG8+YABENATDAoLIAIgAEEEajYCDCABQdD6gAFBCCACQQxqQbz5gAEQ0BMMCQsgAiAAQQRqNgIMIAFB2PqAAUEJIAJBDGpBvPmAARDQEwwICyACIABBDGo2AgwgAUGE+4ABQQcgAEHk+oABIAJBDGpB9PqAARCDDwwHCyACIABBBGo2AgwgAUGL+4ABQQggAkEMakG8+YABENATDAYLIAIgAEEEajYCDCABQZP7gAFBFCACQQxqQbz5gAEQ0BMMBQsgAiAAQQRqNgIMIAFBp/uAAUEMIAJBDGpBvPmAARDQEwwECyACIABBBGo2AgwgAUGz+4ABQQ4gAkEMakG8+YABENATDAMLIAFBwfuAAUEaEPs1DAILIAFB2/uAAUEYEPs1DAELIAIgAEEEajYCDCABQYT8gAFBEyACQQxqQfT7gAEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUHY/oMBQREgAkEMakHI/oMBENATDBILIAIgAEEEajYCDCABQfz+gwFBDSACQQxqQez+gwEQ0BMMEQsgAiAAQQRqNgIMIAFBif+DAUEJIAJBDGpByP6DARDQEwwQCyACIABBBGo2AgwgAUGS/4MBQQsgAkEMakHI/oMBENATDA8LIAIgAEEEajYCDCABQZ3/gwFBCiACQQxqQcj+gwEQ0BMMDgsgAiAAQQRqNgIMIAFBp/+DAUELIAJBDGpByP6DARDQEwwNCyACIABBBGo2AgwgAUGy/4MBQQwgAkEMakHI/oMBENATDAwLIAFBvv+DAUEMEPs1DAsLIAIgAEEEajYCDCABQcr/gwFBEiACQQxqQcj+gwEQ0BMMCgsgAiAAQQRqNgIMIAFB3P+DAUEIIAJBDGpByP6DARDQEwwJCyACIABBBGo2AgwgAUHk/4MBQQkgAkEMakHI/oMBENATDAgLIAIgAEEMajYCDCABQZCAhAFBByAAQfD/gwEgAkEMakGAgIQBEIMPDAcLIAIgAEEEajYCDCABQZeAhAFBCCACQQxqQcj+gwEQ0BMMBgsgAiAAQQRqNgIMIAFBn4CEAUEUIAJBDGpByP6DARDQEwwFCyACIABBBGo2AgwgAUGzgIQBQQwgAkEMakHI/oMBENATDAQLIAIgAEEEajYCDCABQb+AhAFBDiACQQxqQcj+gwEQ0BMMAwsgAUHNgIQBQRoQ+zUMAgsgAUHngIQBQRgQ+zUMAQsgAiAAQQRqNgIMIAFBkIGEAUETIAJBDGpBgIGEARDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQfjPhQFBESACQQxqQejPhQEQ0BMMEgsgAiAAQQRqNgIMIAFBnNCFAUENIAJBDGpBjNCFARDQEwwRCyACIABBBGo2AgwgAUGp0IUBQQkgAkEMakHoz4UBENATDBALIAIgAEEEajYCDCABQbLQhQFBCyACQQxqQejPhQEQ0BMMDwsgAiAAQQRqNgIMIAFBvdCFAUEKIAJBDGpB6M+FARDQEwwOCyACIABBBGo2AgwgAUHH0IUBQQsgAkEMakHoz4UBENATDA0LIAIgAEEEajYCDCABQdLQhQFBDCACQQxqQejPhQEQ0BMMDAsgAUHe0IUBQQwQ+zUMCwsgAiAAQQRqNgIMIAFB6tCFAUESIAJBDGpB6M+FARDQEwwKCyACIABBBGo2AgwgAUH80IUBQQggAkEMakHoz4UBENATDAkLIAIgAEEEajYCDCABQYTRhQFBCSACQQxqQejPhQEQ0BMMCAsgAiAAQQxqNgIMIAFBsNGFAUEHIABBkNGFASACQQxqQaDRhQEQgw8MBwsgAiAAQQRqNgIMIAFBt9GFAUEIIAJBDGpB6M+FARDQEwwGCyACIABBBGo2AgwgAUG/0YUBQRQgAkEMakHoz4UBENATDAULIAIgAEEEajYCDCABQdPRhQFBDCACQQxqQejPhQEQ0BMMBAsgAiAAQQRqNgIMIAFB39GFAUEOIAJBDGpB6M+FARDQEwwDCyABQe3RhQFBGhD7NQwCCyABQYfShQFBGBD7NQwBCyACIABBBGo2AgwgAUGw0oUBQRMgAkEMakGg0oUBENATCyACQRBqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBvOuFAUERIAJBDGpBrOuFARDQEwwSCyACIABBBGo2AgwgAUHg64UBQQ0gAkEMakHQ64UBENATDBELIAIgAEEEajYCDCABQe3rhQFBCSACQQxqQazrhQEQ0BMMEAsgAiAAQQRqNgIMIAFB9uuFAUELIAJBDGpBrOuFARDQEwwPCyACIABBBGo2AgwgAUGB7IUBQQogAkEMakGs64UBENATDA4LIAIgAEEEajYCDCABQYvshQFBCyACQQxqQazrhQEQ0BMMDQsgAiAAQQRqNgIMIAFBluyFAUEMIAJBDGpBrOuFARDQEwwMCyABQaLshQFBDBD7NQwLCyACIABBBGo2AgwgAUGu7IUBQRIgAkEMakGs64UBENATDAoLIAIgAEEEajYCDCABQcDshQFBCCACQQxqQazrhQEQ0BMMCQsgAiAAQQRqNgIMIAFByOyFAUEJIAJBDGpBrOuFARDQEwwICyACIABBDGo2AgwgAUH07IUBQQcgAEHU7IUBIAJBDGpB5OyFARCDDwwHCyACIABBBGo2AgwgAUH77IUBQQggAkEMakGs64UBENATDAYLIAIgAEEEajYCDCABQYPthQFBFCACQQxqQazrhQEQ0BMMBQsgAiAAQQRqNgIMIAFBl+2FAUEMIAJBDGpBrOuFARDQEwwECyACIABBBGo2AgwgAUGj7YUBQQ4gAkEMakGs64UBENATDAMLIAFBse2FAUEaEPs1DAILIAFBy+2FAUEYEPs1DAELIAIgAEEEajYCDCABQfTthQFBEyACQQxqQeTthQEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGAjIYBQREgAkEMakHwi4YBENATDBILIAIgAEEEajYCDCABQaSMhgFBDSACQQxqQZSMhgEQ0BMMEQsgAiAAQQRqNgIMIAFBsYyGAUEJIAJBDGpB8IuGARDQEwwQCyACIABBBGo2AgwgAUG6jIYBQQsgAkEMakHwi4YBENATDA8LIAIgAEEEajYCDCABQcWMhgFBCiACQQxqQfCLhgEQ0BMMDgsgAiAAQQRqNgIMIAFBz4yGAUELIAJBDGpB8IuGARDQEwwNCyACIABBBGo2AgwgAUHajIYBQQwgAkEMakHwi4YBENATDAwLIAFB5oyGAUEMEPs1DAsLIAIgAEEEajYCDCABQfKMhgFBEiACQQxqQfCLhgEQ0BMMCgsgAiAAQQRqNgIMIAFBhI2GAUEIIAJBDGpB8IuGARDQEwwJCyACIABBBGo2AgwgAUGMjYYBQQkgAkEMakHwi4YBENATDAgLIAIgAEEMajYCDCABQbiNhgFBByAAQZiNhgEgAkEMakGojYYBEIMPDAcLIAIgAEEEajYCDCABQb+NhgFBCCACQQxqQfCLhgEQ0BMMBgsgAiAAQQRqNgIMIAFBx42GAUEUIAJBDGpB8IuGARDQEwwFCyACIABBBGo2AgwgAUHbjYYBQQwgAkEMakHwi4YBENATDAQLIAIgAEEEajYCDCABQeeNhgFBDiACQQxqQfCLhgEQ0BMMAwsgAUH1jYYBQRoQ+zUMAgsgAUGPjoYBQRgQ+zUMAQsgAiAAQQRqNgIMIAFBuI6GAUETIAJBDGpBqI6GARDQEwsgAkEQaiQAC80FAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEELIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOEgECAwQFBgcICQoLDA0ODxAREgALIAIgAEEEajYCDCABQbCchgFBESACQQxqQaCchgEQ0BMMEgsgAiAAQQRqNgIMIAFB1JyGAUENIAJBDGpBxJyGARDQEwwRCyACIABBBGo2AgwgAUHhnIYBQQkgAkEMakGgnIYBENATDBALIAIgAEEEajYCDCABQeqchgFBCyACQQxqQaCchgEQ0BMMDwsgAiAAQQRqNgIMIAFB9ZyGAUEKIAJBDGpBoJyGARDQEwwOCyACIABBBGo2AgwgAUH/nIYBQQsgAkEMakGgnIYBENATDA0LIAIgAEEEajYCDCABQYqdhgFBDCACQQxqQaCchgEQ0BMMDAsgAUGWnYYBQQwQ+zUMCwsgAiAAQQRqNgIMIAFBop2GAUESIAJBDGpBoJyGARDQEwwKCyACIABBBGo2AgwgAUG0nYYBQQggAkEMakGgnIYBENATDAkLIAIgAEEEajYCDCABQbydhgFBCSACQQxqQaCchgEQ0BMMCAsgAiAAQQxqNgIMIAFB6J2GAUEHIABByJ2GASACQQxqQdidhgEQgw8MBwsgAiAAQQRqNgIMIAFB752GAUEIIAJBDGpBoJyGARDQEwwGCyACIABBBGo2AgwgAUH3nYYBQRQgAkEMakGgnIYBENATDAULIAIgAEEEajYCDCABQYuehgFBDCACQQxqQaCchgEQ0BMMBAsgAiAAQQRqNgIMIAFBl56GAUEOIAJBDGpBoJyGARDQEwwDCyABQaWehgFBGhD7NQwCCyABQb+ehgFBGBD7NQwBCyACIABBBGo2AgwgAUHonoYBQRMgAkEMakHYnoYBENATCyACQRBqJAALzQUBAn8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgACgCACIDQYCAgIB4cyADQQBOG0EBaw4SAQIDBAUGBwgJCgsMDQ4PEBESAAsgAiAAQQRqNgIMIAFBtNuGAUERIAJBDGpBpNuGARDQEwwSCyACIABBBGo2AgwgAUHY24YBQQ0gAkEMakHI24YBENATDBELIAIgAEEEajYCDCABQeXbhgFBCSACQQxqQaTbhgEQ0BMMEAsgAiAAQQRqNgIMIAFB7tuGAUELIAJBDGpBpNuGARDQEwwPCyACIABBBGo2AgwgAUH524YBQQogAkEMakGk24YBENATDA4LIAIgAEEEajYCDCABQYPchgFBCyACQQxqQaTbhgEQ0BMMDQsgAiAAQQRqNgIMIAFBjtyGAUEMIAJBDGpBpNuGARDQEwwMCyABQZrchgFBDBD7NQwLCyACIABBBGo2AgwgAUGm3IYBQRIgAkEMakGk24YBENATDAoLIAIgAEEEajYCDCABQbjchgFBCCACQQxqQaTbhgEQ0BMMCQsgAiAAQQRqNgIMIAFBwNyGAUEJIAJBDGpBpNuGARDQEwwICyACIABBDGo2AgwgAUHs3IYBQQcgAEHM3IYBIAJBDGpB3NyGARCDDwwHCyACIABBBGo2AgwgAUHz3IYBQQggAkEMakGk24YBENATDAYLIAIgAEEEajYCDCABQfvchgFBFCACQQxqQaTbhgEQ0BMMBQsgAiAAQQRqNgIMIAFBj92GAUEMIAJBDGpBpNuGARDQEwwECyACIABBBGo2AgwgAUGb3YYBQQ4gAkEMakGk24YBENATDAMLIAFBqd2GAUEaEPs1DAILIAFBw92GAUEYEPs1DAELIAIgAEEEajYCDCABQezdhgFBEyACQQxqQdzdhgEQ0BMLIAJBEGokAAvNBQECfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyAAKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyACIABBBGo2AgwgAUGYjIcBQREgAkEMakGIjIcBENATDBILIAIgAEEEajYCDCABQbyMhwFBDSACQQxqQayMhwEQ0BMMEQsgAiAAQQRqNgIMIAFByYyHAUEJIAJBDGpBiIyHARDQEwwQCyACIABBBGo2AgwgAUHSjIcBQQsgAkEMakGIjIcBENATDA8LIAIgAEEEajYCDCABQd2MhwFBCiACQQxqQYiMhwEQ0BMMDgsgAiAAQQRqNgIMIAFB54yHAUELIAJBDGpBiIyHARDQEwwNCyACIABBBGo2AgwgAUHyjIcBQQwgAkEMakGIjIcBENATDAwLIAFB/oyHAUEMEPs1DAsLIAIgAEEEajYCDCABQYqNhwFBEiACQQxqQYiMhwEQ0BMMCgsgAiAAQQRqNgIMIAFBnI2HAUEIIAJBDGpBiIyHARDQEwwJCyACIABBBGo2AgwgAUGkjYcBQQkgAkEMakGIjIcBENATDAgLIAIgAEEMajYCDCABQdCNhwFBByAAQbCNhwEgAkEMakHAjYcBEIMPDAcLIAIgAEEEajYCDCABQdeNhwFBCCACQQxqQYiMhwEQ0BMMBgsgAiAAQQRqNgIMIAFB342HAUEUIAJBDGpBiIyHARDQEwwFCyACIABBBGo2AgwgAUHzjYcBQQwgAkEMakGIjIcBENATDAQLIAIgAEEEajYCDCABQf+NhwFBDiACQQxqQYiMhwEQ0BMMAwsgAUGNjocBQRoQ+zUMAgsgAUGnjocBQRgQ+zUMAQsgAiAAQQRqNgIMIAFB0I6HAUETIAJBDGpBwI6HARDQEwsgAkEQaiQAC+gKAhJ/AX4jAEEwayILJAAgCyAFNwMoIAsgBDcDICALIAM3AxggCyACNwMQIAFBEGoiCCALQRBqEK0MIQMgASgCCEUEQCALQQhqIRAjAEHQAGsiByQAIAcgCDYCHCABKAIMIQ4gByAHQRxqNgIgAkACQCAOIA5BAWoiCE0EQAJAIAEoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgCEkEQAJ/IAlBAWoiCSAIIAggCUkbIghBD08EQCAIQf////8BSw0FQX8gCEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAhBCEkbIAhBBEkbCyEIIAdBQGsgAUEQaiIMQTBBECAIEJ0UIAcoAkQhCSAHKAJAIgpFBEAgBygCSCEIDAULIAcpAkghAiAJQQlqIggEQCAKQf8BIAj8CwALIAcgAkIgiD4CPCAHIAKnIhI2AjggByAJNgI0IAcgCjYCMCAHQrCAgICAAjcCKCAHIAw2AiQgB0EwaiETIAcgDgR/IApBCGohFCABKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhAkEAIQgDQCACUARAA0AgCEEIaiEIIBFBCGoiESkDAEKAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhAgsgCiAJIAcoAhwgASgCACACeqdBA3YgCGoiFUFQbGpBMGsQrQynIhZxIgxqKQAAQoCBgoSIkKDAgH+DIgRQBEBBCCEPA0AgDCAPaiEMIA9BCGohDyAKIAkgDHEiDGopAABCgIGChIiQoMCAf4MiBFANAAsLIAogBHqnQQN2IAxqIAlxIgxqLAAAQQBOBEAgCikDAEKAgYKEiJCgwIB/g3qnQQN2IQwLIAogDGogFkEZdiIPOgAAIBQgDEEIayAJcWogDzoAACAKIAxBf3NBMGxqIAEoAgAgFUF/c0EwbGpBMPwKAAAgAkIBfSACgyECIA5BAWsiDg0ACyABKAIMBUEACyIINgI8IAcgEiAIazYCOCABIBNBBBD6KiAHQSRqENAmDAELIAEgB0EgakHQ3YABQTAQxwkLQYGAgIB4IQkMAgsQ4ycgBygCDCEIIAcoAgghCQwBCxDjJyAHKAIUIQggBygCECEJCyAQIAg2AgQgECAJNgIAIAdB0ABqJAALIAEoAgQiCCADp3EhByADQhmIIgRC/wCDQoGChIiQoMCAAX4hGSABKAIAIQkDQAJ/AkACQAJAIAcgCWopAAAiAyAZhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBVBFBEADQCALQRBqQSAgASgCAEEAIAV6p0EDdiAHaiAIcWsiCkEwbGpBMGtBIBCfOw0CIAVCAX0gBYMiBVBFDQALCyADQoCBgoSIkKDAgH+DIQIgF0UEQCACUA0DIAJ6p0EDdiAHaiAIcSENC0EBIAIgA0IBhoNQDQMaQQAhByAJIA1qLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQ0LIAEoAgAiCCANaiIJLQAAIQogCykDECECIAspAxghAyALKQMgIQUgCykDKCEZIAkgBKdB/wBxIgk6AAAgCCABKAIEIA1BCGtxakEIaiAJOgAAIAEgASgCDEEBajYCDCAIIA1BUGxqIghBIGsiCSAZNwMIIAkgBTcDACAIQTBrIgkgAzcDCCAJIAI3AwAgASABKAIIIApBAXFrNgIIIAhBEGsgBjYCAAwBCyABKAIAIApBMGxqQRBrIgcoAgAhASAHIAY2AgBBASEHCyAAIAE2AgQgACAHNgIAIAtBMGokAA8LQQALIRcgByAYQQhqIhhqIAhxIQcMAAsAC6EFAQZ/IwBB0ABrIgIkACACQRNBFCAAELomIgQbNgIQIAJBmImGAUGEiYYBIAQbNgIMIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBxwI2AhwgAiACQRhqIgU2AkAgAiACQQxqNgIYAkACQCABKAIAIgQgASgCBCIDIAJBOGoiBxDLCg0AIARBvImGAUETIAMoAgwiBhEGAA0AIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBrxs2AhwgAiAAQRhqNgIYIAIgBTYCQCAEIAMgBxDLCg0AIAAoAiQEQCACIABBJGo2AjQgBEHPiYYBQRMgBhEGAA0BIAJBAjYCPCACQayJhgE2AjggAkIBNwJEIAJBsBs2AhwgAiAFNgJAIAIgAkE0ajYCGCAEIAMgAkE4ahDLCg0BCyAALQAMQSFGBEAgAiAAQRBqELAuIAIoAgQhBiACKAIAIQQDQAJAIAQgBkcEQCACIAQtAAAiAzoAFyAAIAMQ2SghAyACIARBBGooAgAiBUE8ajYCMCACIAVBMGo2AjQgAkEENgIcIAJBgIqGATYCGCACQgM3AiQgAkGvAzYCTCACQYQBNgJEIAJB9As2AjwgAiACQThqNgIgIAIgAkE0ajYCSCACIAJBMGo2AkAgAiACQRdqNgI4IAEoAgAgASgCBCACQRhqEMsKDQQgAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAEgAygCDBECAEUNAQwECyACQQA2AkggAkEBNgI8IAJB5ImGATYCOCACQgQ3AkAgASACQThqENE5IQMMBAsgBEEIaiEEQQEhAyABKAIAQauJhgFBASABKAIEKAIMEQYARQ0ACwwCC0HIhYYBQShBoIqGARCfKQALQQEhAwsgAkHQAGokACADC9YEAQN/IwBBQGoiBCQAIARBKGoiBSACKAIMIgJBCGogAigCCEECRkECdGoQiRkCQAJAIAQtAChBDUcNAAJAAkACQCABKAIABEAgASgCCEECRw0BIAQgASgCBC8AADsBKCAFQdiJzgAQjShFDQQgA7wiBkH///8DcSEFIAZBgICAgHhxIQIgBkGAgID8B3EiAUGAgID8B0YEQCAFQQ12IAJBEHZyIAVBAEdBCXRyQYD4AXIhAgwECyACQRB2IQIgAUGAgIC4BEsNAiABQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSABQQ12IAVBDXZqQYCAAWogAnJqIQIMBAsgAUGAgICYA0kNAyAFQYCAgARyIgZBHiABQRd2IgVrdiEBIAZBHSAFayIFdkEBcQR/IAFBAyAFdEEBayAGcUEAR2oFIAELIAJyIQIMAwtB5IfOAEEgQYSIzgAQyyQAC0HQg84AQSsgBEEoakH8g84AQciJzgAQ1R4ACyACQYD4AXIhAgsgBCACOwEmIARBCGogBEEmakECEL8cIAQoAghBCEYEQCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIADAILIARBOGogBEEYaikDADcDACAEQTBqIARBEGopAwA3AwAgBCAEKQMINwMoQdCDzgBBKyAEQShqQcCDzgBB3InOABDVHgALAkAgASgCACICBEAgBEEoaiABQQxqIAEoAgQgASgCCCACKAIAEQUADAELIARBADYCKAsgACAEKQIoNwIAIABBCGogBEEwaikCADcCAAsgBEFAayQAC5EEAQN/AkACQAJAAkACQAJAIABBBk8EQCAAQYIBTwRAIABBwhBPBEAgAS0APSACMwF6IAQgBSAGEN8TQQwgAK1CwhB9IAQgBSAGEN8TIAMgAygC9AFBAWo2AvQBDwsgAEHCAGsiCGdBIGpBP3MiB0EyaiIAQYABTw0CIABBgAFPDQMgACABai0AACACIABBAXRqMwEAIAQgBSAGEN8TIAcgCK1CfyAHrYZ8IAQgBSAGEN8TIABBgAFJDQcgAEGAAUHElPMAEMMhAAsgAEECayIIIAhnQSBqQT9zQQFrIgd2IgkgB0EBdGpBKmoiAEGAAU8NAyAAQYABTwRAIABBgAFB5JTzABDDIQALIAAgAWotAAAgAiAAQQF0ajMBACAEIAUgBhDfEyAHIAitIAmtIAethn0gBCAFIAYQ3xMgAEGAAUkNBSAAQYABQfSU8wAQwyEACyAAQShyIgBBgAFPDQMgAEGAAU8EQCAAQYABQZSV8wAQwyEACyAAIAFqLQAAIAIgAEEBdGozAQAgBCAFIAYQ3xMgAEGAAUkNBSAAQYABQaSV8wAQwyEACyAAQYABQaSU8wAQwyEACyAAQYABQbSU8wAQwyEACyAAQYABQdSU8wAQwyEACyAAQYABQYSV8wAQwyEACyADIABBAnRqIgAgACgCAEEBajYCAA8LIAMgAEECdGoiACAAKAIAQQFqNgIAC6gEAgJ+An8jAEEgayIGJAAgAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIFQStrDgMCAQIBCyABLQAAIQULAkACQAJAAkACQAJAAkACQAJAIAVB/wFxQStrDgMAAgECCyACQQFrIQUgAUEBaiEBIAJBEUkNAiAFIQIMBgsgAkEBayEFIAFBAWohASACQRFPBEADQCAFRQ0IIAZBEGogAyADQj+HQgpCABCoHiABLQAAQTBrIgJBCUsNCSAGKQMYIAYpAxAiA0I/h1INBCABQQFqIQEgBUEBayEFIAKtIgRCAFIgAyADIAR9IgNVc0UNAAsgAEEDOgABQQEMCgsgBUUNBANAIAEtAABBMGsiAkEJSw0IIAFBAWohASADQgp+IAKtfSEDIAVBAWsiBQ0ACwwGCyACQQ9LDQQMAgsgBSICRQ0CDAELIABBAzoAAUEBDAYLA0AgAS0AAEEwayIFQQlLDQQgAUEBaiEBIAWtIANCCn58IQMgAkEBayICDQALDAILDAELA0AgAkUNASAGIAMgA0I/h0IKQgAQqB4gAS0AAEEwayIFQQlLDQIgBikDCCAGKQMAIgNCP4dSDQMgAUEBaiEBIAJBAWshAiAFrSIEQgBUIAMgAyAEfCIDVXNFDQALIABBAjoAAUEBDAMLIAAgAzcDCEEADAILIABBAToAAUEBDAELIABBAjoAAUEBCzoAACAGQSBqJAALygcBDX8jAEGwAWsiAyQAIAEoAhAhAgJAAkACQCABKAIUIgZBBEkNACACIAZBfHFqQQRrIgVFDQAgBSgCAEF/Rg0BCyADIAEQ0zoiCDYCDCADQRBqIgQgCBDEGyABKAIYIgUgBSgCACIHQQFqNgIAAkACQCAHQQBOBEAgAyAFNgKIASADIAEpAhw3AowBIAQgA0GIAWoQ2SAhDSAGQQhJDQIgBkECdiEHIANByABqIQ4gA0HsAGohCkEAIQUDQCACQQRqIgYoAgAhBCACKAIAIQICQCABIAUQliVFBEAgA0EQaiANIAIgBCACaxCJEAwBCyAKEOY6IAMoAmxFDQMgAygCfEEBaiILQQN2IAtBB3FBAEdqIgIgAygCeCIESwRAIAIgBGshDCADKAJwIgkgAkkEQCAKIAlBAXQiBCACENAqIgkgBCAJSxsQ6BkgAygCeCEECyAMBEAgAygCdCAEakEAIAz8CwALIAMgAjYCeAsgAyALNgJ8IAMoAlAiAiADKAJIRgRAIA5B/OmAARCxKAsgAygCTCACQQR0aiIEQgA3AwggBEIANwMAIAMgAkEBajYCUAsgBUEBaiEFIAYhAiAHQQFrIgdBAk8NAAsMAgsAC0Hc7IABELI7AAsgAyADQRBqIgEQ0TwiAjYClAEgAiAIRgRAIAAgARDbDCABEOklDAILIANBADYCmAFBACADQZQBaiADQQxqIANBmAFqQezsgAEQrysACyABENM6IQIgA0EUaiABEPk0IAMgAjYCMCADQQA2AiwgAyABNgIQIwBBsAFrIgEkACADQRBqIgIoAgAhBiABQaABaiACQRRqKQIANwIAIAFBmAFqIAJBDGopAgA3AgAgASACKQIENwKQASACKAIgIQQgAigCHCECIAYQ0zohBSAGENM6GiABQRBqIAUgAmsQxBsgASAENgKsASABIAI2AqgBIAEgBjYCjAEgASgCkAEhBQJAAkAgAiAERwRAA0AgAUEQagJ/AkAgBQRAIAIgASgCoAFPDQUgASgClAEgAiABKAKcAWoiB0EDdmotAABB/wFzIAdBB3F2QQFxDQELIAEgAkEBajYCqAEgAUEIaiAGIAIQjywgASgCDCEIIAEoAggMAQsgASACQQFqNgKoAUEACyAIELsBIAQgAkEBaiICRw0ACwsCQCAFRQ0AIAUgBSgCACICQQFrNgIAIAJBAUcNACABQZABahD7HgsgACABQRBqIgAQ2wwgABDpJSABQbABaiQADAELQazsgAFBIEHM7IABEJ8pAAsLIANBsAFqJAAL1gQCBX8BfiMAQYABayIEJAAgBCADNgIMIAQgAjYCCCAEQUBrIgMgARDOBgJAQQxBBBCtNiICBEAgAiAEKQJANwIAIAJBCGogBEHIAGoiBSgCADYCACADIARBCGoiBhDzLRDOBkEMQQQQrTYiA0UNASADIAQpAkA3AgAgA0EIaiAFKAIANgIAIAQgAzYCGCAEIAI2AhQgBEEiOgAQIAQgBhD0LSICNgIcAkACQCABKAIUIgUEQCABQQxqIQYgASgCECEHQQAhAwNAIAMgB2oiCC0AACACTwRAIAEgAxCLOw0DCyAFIANBAWoiA0cNAAsLIARByABqIARBGGooAgA2AgAgBCAEKQIQNwNAIARBzABqIAFBMPwKAAAgBCkCCCEJIAAgBEFAa0E8/AoAACAAQQA6AEQgACAJNwI8DAELIAQgAzYCICAEIAg2AiQgBEEDNgIsIARBrIKEATYCKCAEQgM3AjQgBEE7NgJUIARBOzYCTCAEQcMKNgJEIAQgBEFAazYCMCAEIARBHGo2AlAgBCAEQSBqNgJIIAQgBEEkajYCQCAAQQRqIARBKGoQmQ4gAEECOgBEIABBjYCAgHg2AgAgBEEQahC8DCAEKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAEQQhqELsjCyABELwMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAEoAhgiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEYahD7HgsgBEGAAWokAA8LQQRBDBCjPQALQQRBDBCjPQAL3gQBBH8jAEHQAGsiAyQAAkACfwJAAkACQAJAAkACQAJAAkAgACgCFCIFIAAoAhAiBkkEQAJAIAAoAgwgBWotAAAiBEHlAE0EQCAEQSJGDQYgBEEtRg0FIARB2wBHDQEgA0EKOgBAIANBQGsgASACENEcDAsLIARB8wBNBEAgBEHmAEYNBCAEQe4ARw0BIAAgBUEBajYCFCAAQfyxiAFBAxDJFSIEDQwgA0EHOgBAIANBQGsgASACENEcDAsLIARB9ABGDQcgBEH7AEYNAgsgBEEwa0H/AXFBCkkNBQsgA0EKNgJAIANBCGogAEEMaiAFQQFqIgEgBiABIAZJGxDqDCADQUBrIAMoAgggAygCDBD7KAwICyADQQs6AEAgA0FAayABIAIQ0RwMBwsgACAFQQFqNgIUIABBgrKIAUEEEMkVIgQNByADQQA7AUAgA0FAayABIAIQ0RwMBgsgACAFQQFqNgIUIANBEGoiBCAAQQAQxAsgAykDEEIDUQ0DIAQgASACENwgDAULIABBADYCCCAAIAVBAWo2AhQgA0E0aiAAQQxqIAAQvg8gAygCOCEEIAMoAjRBAkYNBSADIAMoAjw2AkggAyAENgJEIANBBToAQCADQUBrIAEgAhDRHAwECyADQSBqIABBARDECyADKQMgQgNRBEAgAygCKCEEDAULIANBIGogASACENwgDAMLIAAgBUEBajYCFCAAQf+xiAFBAxDJFSIERQ0BDAMLIAMoAhghBAwCCyADQYACOwFAIANBQGsgASACENEcCyAAEIcuIQQLIANB0ABqJAAgBAv/BAIEfwh+IwBBkAFrIgMkAEKAgICAgICAgIB/IQwCQAJ+AkACQCABKAIMKAIQIAJBBHRqIgQpAwAiCiAEKQMIIgtCgICAgICAgICAf4WEQgBSIAEoAggiBCgCACIFKAIAIgYpAwgiByAGKQMAIgiDQn9SckUEQEIAIQcMAQsgByAIhFANAyADQRBqIAogCyAIIAcQgxkgAyADKQMQIgkgAykDGCIMIAggBxCoHkIAIAogAykDACIOfSAHIAiDQn9RIgYbIQ1CACALIAMpAwh9IAogDlStfSAGGyEHIAtCAFkNAQsgCSANIAUoAggiBSkDAFggByAFKQMIIghXIAcgCFEbrSIIfSEHIAwgCCAJVq19DAELIAwgCSANIAUoAgQiBSkDAFogByAFKQMIIghZIAcgCFEbrXwiByAJVK18CyEJAkACQAJ+IAkgB0KAgICAgICAgIB/fSAHVK18UEUEQCAEKAIEIQEgAyALNwNIIAMgCjcDQCADQcyR/wA2AlggA0IENwJkIANBhAw2AowBIANB9As2AoQBIAMgAUEBajYCgAEgA0G7BzYCfCADIAE2AnggA0HMATYCdCADQaCS/wA2AnAgAyADQfAAajYCYCADIANBQGs2AogBIANBBDYCXCADQTBqIANB2ABqEJkOIAMpAjghCUGCgICAeCEEIAMpAjAMAQsgA0HwAGogByAEKAIILQAAEI0QIAMoAnAiBEGTgICAeEYNASADKQJ8IQkgAykCdAshByAAIAk3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0GQAWokAA8LQcyP/wAQ4isAC7EFAgJ/BH4jAEGQAWsiBiQAIAYgBDcDECAGIAU3AxggBiACNwMAIAYgAzcDCCAGQUBrIAIgAyAEIAUgASgCACIHKQMAIAcpAwggBykDECAHKQMYEJoIAn4gBi0AQEEBRgRAIAYtAEEEQEKAgICAgICAgIB/IQhCAAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakG8i/8AEO8sAAsgBikDaCEIIAYpA2AhCSAGKQNYIQsgBikDUAshCiAGQUBrIAIgAyAEIAUgBykDACAHKQMIIAcpAxAgBykDGBCaCAJAIAYtAEBBAUYEQCAGLQBBBEAgBkE4akIANwMAIAZBMGpCADcDACAGQgA3AyggBkIANwMgDAILIAZBADYCMCAGQQE2AiQgBkG0i/8ANgIgIAZCBDcCKCAGQSBqQcyL/wAQ7ywACyAGIAYpA4gBNwM4IAYgBikDgAE3AzAgBiAGKQN4NwMoIAYgBikDcDcDIAsgBkHYAGpCADcDACAGQdAAakIANwMAIAZCADcDSCAGQgA3A0ACQAJAAkAgBiAGQUBrEPsbIgdB/wFxQQJHIAfAQQBOcUUEQCAGQSBqIAEoAggQ+xvAQQBMDQEMAgsgBkEgaiABKAIEEPsbIgFB/wFxQQJGIAHAQQBIcg0BIAggCSAKQgF8IgQgCyAEUK18IgKEUK18IgUgCVStfCEIDAILIApCAX0hBCALIApQrX0hAiAJIAogC4RQrSIDfSEFIAggAyAJVq19IQgMAQsgCSEFIAohBCALIQILIwBBIGsiASQAIAEgBCACIAUgCBDWIyAAIAEoAgBBAXEEfiABKQMYIAAgASkDECICNwMIIAJCgICAgICAgICAf30gAlStfFCtBUIACzcDACABQSBqJAAgBkGQAWokAAvoBAICfwR+IwBBkAFrIgYkACAGIAQ3AxAgBiAFNwMYIAYgAjcDACAGIAM3AwggBkFAayACIAMgBCAFIAEoAgAiBykDACAHKQMIIAcpAxAgBykDGBCaCAJ+IAYtAEBBAUYEQCAGLQBBBEBCgICAgICAgICAfyEIQgAMAgsgBkEANgIwIAZBATYCJCAGQbSL/wA2AiAgBkIENwIoIAZBIGpBvIv/ABDvLAALIAYpA2ghCCAGKQNgIQkgBikDWCEKIAYpA1ALIQsgBkFAayACIAMgBCAFIAcpAwAgBykDCCAHKQMQIAcpAxgQmggCQCAGLQBAQQFGBEAgBi0AQQRAIAZBOGpCADcDACAGQTBqQgA3AwAgBkIANwMoIAZCADcDIAwCCyAGQQA2AjAgBkEBNgIkIAZBtIv/ADYCICAGQgQ3AiggBkEgakHMi/8AEO8sAAsgBiAGKQOIATcDOCAGIAYpA4ABNwMwIAYgBikDeDcDKCAGIAYpA3A3AyALIAZB2ABqQgA3AwAgBkHQAGpCADcDACAGQgA3A0ggBkIANwNAAkACQAJAIAYgBkFAaxD7GyIHQf8BcUECRyAHwEEATnFFBEAgBkEgaiABKAIIEPsbwEEATA0BDAILIAZBIGogASgCBBD7GyIBQf8BcUECRiABwEEASHINASAIIAkgC0IBfCIEIAogBFCtfCIChFCtfCIFIAlUrXwhCAwCCyALQgF9IQQgCiALUK19IQIgCSAKIAuEUK0iA30hBSAIIAMgCVatfSEIDAELIAkhBSALIQQgCiECCyAAIAQgAiAFIAgQ1iMgBkGQAWokAAuTAwEBfyMAQUBqIgQkAAJAAkACQAJAAkACQCAAKAIAKAIALQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AgwgAiAAQQR2IgBJDQMMBAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NA0HYm4QBELI7AAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NAkGsnIQBELI7AAsgACgCBCgCFCEAIAQgAjYCDCACIABBBHYiAE8NAUH8nIQBELI7AAsgBEEYaiIAIAEoAhAgAkEEdGoiAUEIaikDADcDACAEIAEpAwA3AxAgBCAANgIwIANBwI6EAUEUQdSOhAFBBiAEQRBqIgBB8I2EAUGfjoQBQQQgAEEEckHwjYQBQdqOhAFBCyAEQTBqQbCOhAEQiRcgBEFAayQADwsgBCAANgIsIARBAjYCFCAEQbiXhAE2AhAgBEICNwIcIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIYIAQgBEEsajYCOCAEIARBDGo2AjAgBEEQakHIl4QBEO8sAAuPBAEGfyADIAMgAkEDakF8cSACayIIa0EHcUEAIAMgCE8bIgVrIQkCfwJAAkAgAyAFTwRAAkAgBUUNAAJ/IAVBAWsgAiADaiIGQQFrIgQtAAAgAUH/AXFGDQAaIAIgCWoiByAERg0BIAVBAmsgBkECayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUEDayAGQQNrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQRrIAZBBGsiBC0AACABQf8BcUYNABogBCAHRg0BIAVBBWsgBkEFayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUEGayAGQQZrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQdrIAZBB2siBC0AACABQf8BcUYNABogBCAHRg0BIAVBeHILIAlqIQQMAwsgCCADIAMgCEsbIQYgAUH/AXFBgYKECGwhBQNAIAYgCSIESQRAIARBCGshCUGAgoQIIAIgBGoiB0EIaygCACAFcyIIayAIckGAgoQIIAdBBGsoAgAgBXMiCGsgCHJxQYCBgoR4cUGAgYKEeEYNAQsLIAMgBEkNASACQQFrIQMgAUH/AXEhAgNAQQAgBEUNBBogAyAEaiEBIARBAWshBCACIAEtAABHDQALDAILIAkgA0Gw94kBEK87AAsgBCADQcD3iQEQsDsAC0EBCyEJIAAgBDYCBCAAIAk2AgALgwUCB38DfiMAQbABayIDJAAgAUHsBGogAkEBIAIpAwAiCqdBCWsgCkIIWBsiBEECdEG4js8AaiIJKAIAai0AABDpHiABKALEBCEGAkACQCABKALIBCIFRQ0AIAYgBUEDdGoiB0EIayIIRQ0AIAdBA2stAABBgIYIIARBA3RB+P//B3F2QQNxRw0AIAdBBGstAAAgAiAEQQJ0QbiOzwBqKAIAai0AAEcNACAIIAgoAgBBAWo2AgAMAQsgBEEDdEGgjs8AaikDACEKIAIgCSgCAGoxAAAhCyABQcAEaiIEKAIAIAVGBH8gBEHIg88AEJsoIAEoAsQEBSAGCyAFQQN0aiALQiCGIAqEQgGENwIAIAEgBUEBajYCyAQLIAEoArAEIQUgASgCtAQhBCADQShqIgYgAkGIAfwKAAAgA0EIaiAFIAYgBCgCDBEBACADKAIcIQIgAygCGCEFIAMpAxAhCyADKQMIIQoCQCADLQAkIgRBBEYEQCAAIAI2AhQgACAFNgIQIAAgCzcDCCAAIAo3AwAMAQsgAzUCICEMIAEoAoAEQYCAgIB4RwRAIAFB+ANqIAogAhCtIAsgASABKQOYAiAFrXw3A5gCIAEgASkDoAIgAq18NwOgAiABIAEpA4gCIAt8NwOIAgJAAn8CQAJAAkACQCAEQQFrDgIFAAELIAEpA6gBUEUNASABQgE3A6gBQbABDAMLIAEgASkDqAIgDHw3A6gCIAEpA7gBUA0BDAMLIANBADYCOCADQQE2AiwgA0G4hM8ANgIoIANCBDcCMCADQShqQcCEzwAQ7ywACyABQgE3A7gBQcABCyABaiAKNwMACyAAQQg2AgALIANBsAFqJAAL9QQCB38DfiMAQbABayIDJAAgAUGgBWogAkEBIAIpAwAiCqdBCWsgCkIIWBsiBEECdEG4js8AaiIJKAIAai0AABDpHiABKAL4BCEGAkACQCABKAL8BCIFRQ0AIAYgBUEDdGoiB0EIayIIRQ0AIAdBA2stAABBgIYIIARBA3RB+P//B3F2QQNxRw0AIAdBBGstAAAgAiAEQQJ0QbiOzwBqKAIAai0AAEcNACAIIAgoAgBBAWo2AgAMAQsgBEEDdEGgjs8AaikDACEKIAIgCSgCAGoxAAAhCyABQfQEaiIEKAIAIAVGBH8gBEHIg88AEJsoIAEoAvgEBSAGCyAFQQN0aiALQiCGIAqEQgGENwIAIAEgBUEBajYC/AQLIAEoAsAEIQUgASgCxAQhBCADQShqIgYgAkGIAfwKAAAgA0EIaiAFIAYgBCgCDBEBACADKAIcIQIgAygCGCEFIAMpAxAhCyADKQMIIQoCQCADLQAkIgRBBEYEQCAAIAI2AhQgACAFNgIQIAAgCzcDCCAAIAo3AwAMAQsgAzUCICEMIAEoApAEQYCAgIB4RwRAIAFBiARqIAogAhCtIAsgASABKQNQIAWtfDcDUCABIAEpA1ggAq18NwNYIAEgASkDQCALfDcDQAJAAn8CQAJAAkACQCAEQQFrDgIFAAELIAEpAwBQRQ0BIAFCATcDAEEIDAMLIAEgASkDYCAMfDcDYCABKQMQUA0BDAMLIANBADYCOCADQQE2AiwgA0G4hM8ANgIoIANCBDcCMCADQShqQcCEzwAQ7ywACyABQgE3AxBBGAsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBiAVqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgC4AQhBgJAAkAgASgC5AQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHcBGoiBCgCACAFRgR/IARByIPPABCbKCABKALgBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AuQECyABKAKoBCEFIAEoAqwEIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKAL4A0GAgICAeEcEQCABQfADaiAKIAIQrSALIAEgASkDgAIgBa18NwOAAiABIAEpA4gCIAKtfDcDiAIgASABKQPwASALfDcD8AECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOwAVBFDQEgAUIBNwOwAUG4AQwDCyABIAEpA5ACIAx8NwOQAiABKQPAAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwPAAUHIAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFB8ARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgCyAQhBgJAAkAgASgCzAQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHEBGoiBCgCACAFRgR/IARByIPPABCbKCABKALIBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AswECyABKAKYBCEFIAEoApwEIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKALoA0GAgICAeEcEQCABQeADaiAKIAIQrSALIAEgASkDmAIgBa18NwOYAiABIAEpA6ACIAKtfDcDoAIgASABKQOIAiALfDcDiAICQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOoAVBFDQEgAUIBNwOoAUGwAQwDCyABIAEpA6gCIAx8NwOoAiABKQO4AVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwO4AUHAAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBwARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgCmAQhBgJAAkAgASgCnAQiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUGUBGoiBCgCACAFRgR/IARByIPPABCbKCABKAKYBAUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2ApwECyABKAL4AyEFIAEoAvwDIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKALIA0GAgICAeEcEQCABQcADaiAKIAIQrSALIAEgASkD+AEgBa18NwP4ASABIAEpA4ACIAKtfDcDgAIgASABKQPoASALfDcD6AECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOYAVBFDQEgAUIBNwOYAUGgAQwDCyABIAEpA4gCIAx8NwOIAiABKQOoAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwOoAUGwAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC4MFAgd/A34jAEGwAWsiAyQAIAFBnARqIAJBASACKQMAIgqnQQlrIApCCFgbIgRBAnRBuI7PAGoiCSgCAGotAAAQ6R4gASgC9AMhBgJAAkAgASgC+AMiBUUNACAGIAVBA3RqIgdBCGsiCEUNACAHQQNrLQAAQYCGCCAEQQN0Qfj//wdxdkEDcUcNACAHQQRrLQAAIAIgBEECdEG4js8AaigCAGotAABHDQAgCCAIKAIAQQFqNgIADAELIARBA3RBoI7PAGopAwAhCiACIAkoAgBqMQAAIQsgAUHwA2oiBCgCACAFRgR/IARByIPPABCbKCABKAL0AwUgBgsgBUEDdGogC0IghiAKhEIBhDcCACABIAVBAWo2AvgDCyABKALgAyEFIAEoAuQDIQQgA0EoaiIGIAJBiAH8CgAAIANBCGogBSAGIAQoAgwRAQAgAygCHCECIAMoAhghBSADKQMQIQsgAykDCCEKAkAgAy0AJCIEQQRGBEAgACACNgIUIAAgBTYCECAAIAs3AwggACAKNwMADAELIAM1AiAhDCABKAKwA0GAgICAeEcEQCABQagDaiAKIAIQrSALIAEgASkD2AEgBa18NwPYASABIAEpA+ABIAKtfDcD4AEgASABKQPIASALfDcDyAECQAJ/AkACQAJAAkAgBEEBaw4CBQABCyABKQOIAVBFDQEgAUIBNwOIAUGQAQwDCyABIAEpA+gBIAx8NwPoASABKQOYAVANAQwDCyADQQA2AjggA0EBNgIsIANBuITPADYCKCADQgQ3AjAgA0EoakHAhM8AEO8sAAsgAUIBNwOYAUGgAQsgAWogCjcDAAsgAEEINgIACyADQbABaiQAC5wEAgZ/CH4jAEHwAGsiBiQAIAAgASADahCOLSAGIAQgBRDgHCAGQgA3A2ggBiABNgJgIAYgASACaiICNgJkAkACQAJAIAEgAk8NACACQQFrIQIgBigCWCEJIAYpAyAhDiAGKAJUIQggBigCUCEFIAYpA0AhDCAGKQMwIQ8gBigCECEDIAYpAwghDSAGKAIoIQogBigCGCELIAYpA0ghESAGKQM4IRIgBikDACEQA0AgEKdBAXEEf0EABUEBCyEEAkADQAJAAkACQCAERQRAIA1QRQ0BQgAhDUIAIRBBASEEDAQLAn4CQCAPQgJ9IhNCAVgEQCATp0EBaw0BDAULIA+nIA9QrUIBhiEPQQFxRQ0AIBIMAQsgDEIDUQRAQgMhDAwECyAFRSAFIAhGckUEQCAIQQhrIggpAwAMAQtBACEFIAxCAlEEQEICIQwMBAsgDKdCACEMQQFxRQ0DIBELIQ1CASEQIAlBQGoiCSEDDAELIAMgDXmnQT9zIgdqIQRCASAHrYYgDYUhDQwDC0EAIQQMAQsLIAsgDkIAUnFFDQIgCiAOeadBP3MiB2ohBEIBIAethiAOhSEOCyACIARPDQEgAiAAKAIIIgdPDQIgBCAHTw0DIAQgACgCBCIEaiACIARqLQAAOgAAIAEgAkkgAkEBayECDQALCyAGQfAAaiQADwsgAiAHQbCazwAQwyEACyAEIAdBwJrPABDDIQALpwgBE38jAEEgayINJAAgB0HUAWohFCAAKAIMIAAoAggiCmshCSAAKAIEIhUgACgCACITa0EDdSEMIAAoAhQhFiAAKAIQIRcgACgCGCEYIAMoAhwhDyATIBVGBH9BAQUgCSAMbkETSwshECADEMkrIQsjAEEQayIRJAAgAiABQYgI/AoAAAJ/AkAgCw0AIAlBBkEIQQNBCSAPayILIAtBA04bdCABKAKECCIOQQJGG0kNAEG6fyAFIAlB//8AS0EEQQMgCUH/B0sbaiILTQ0BGiARIA42AgwCQCAEIAtqIAUgC2sgCiAJQf8BQQsgFEGExAAgAiARQQxqIA9BB0siEkEBdCAPQQRJQQJ0QQAgCUGBCEkbciAQQQBHQQN0ciAIQQBHckHsCkHtCiAOQQJHIAtBA0dyIAlB/wFLcSIZGxEYACIIQQFrQYd/TQRAIAggCSAJIA9BByASG0EBa3ZrQQJrSQ0BCyACIAFBiAj8CgAADAELIBEoAgwhEgJAAkACQAJAAkAgCEEBRgRAIAlBB0sNASAJQQFrIQ4gCkEBaiEQIAotAAAhGgNAIA5FDQIgDkEBayEOIBAtAAAhGyAQQQFqIRAgGiAbRg0ACwsgEkUEQCACQQE2AoQIC0EDQQIgEhshCiALQQRrDgICAwELIAIgAUGICPwKAAAgBCAKIAkQ7iAMBQsgBCAJQQR0QQRBACAZG3IgCEEOdGoiCUEQdjoAAiAEIAkgCnI7AAAMAgsgBCAIQRJ0IAlBBHRqIApyQQhyNgAADAELIAQgCEEKdjoABCAEIAhBFnQgCUEEdGogCnJBDHI2AAALIAggC2oMAQsgBCAFIAogCRDmHAshCCARQRBqJAACQAJAAkAgCCIJQYh/Sw0AQbp/IQggBSAJa0EESA0AIAQgCWohCAJ/IAxB/wBNBEAgCCAMOgAAIAhBAWoMAQsgDEH//QFNBEAgCCAMOgABIAggDEEIdkGAAXI6AAAgCEECagwBCyAIQf8BOgAAIAggDEGA/gFrOwABIAhBA2oLIQkgAkGICGohCgJAIBMgFUYEQCAKIAFBiAhqQeAb/AoAAAwBCyANQQhqIAAgDCABQYgIaiAKIAlBAWoiASAEIAVqIgsgDyAHIBQQ8wogDSgCFCIIQYl/Tw0BIAkgDSgCDEEEdCANKAIIQQZ0aiANKAIQQQJ0ajoAACANKAIYIQAgASAIaiIBIAsgAWsgAkGMDmogFiAKIBggAkG4GWogFyATIAwgDSgCHBD9BiIIQYh/Sw0BIABBACAAIAhqQQRJGw0CIAEgCGohCQsgCSAEayIIRQ0BCyAIQbp/RiAFIAZPcQ0AIAhBiH9LDQEgCEEAIAggBiAGQQcgAygCHCIAIABBB00bQQFrdmtBAmtJGyEIDAELQQAhCAsgDUEgaiQAIAgL9AQCBH8CfiMAQTBrIgMkAAJAAkACQAJAIAEEQCAAKAIoIgJBAU0NASAAKAIkIgJBzAFqQQEQhxcCQAJAAkACQAJAIAAtADxBKEYEQCADIAAoAkAiAEEwajYCDCAALQAwQQNrDgMCAwQBCyADQQA2AiAgA0EBNgIUIANB0LCHATYCECADQgQ3AhggA0EQakHYsIcBEO8sAAsgA0EBNgIUIANBiLCHATYCECADQgE3AhwgA0GvAzYCLCADIANBKGo2AhggAyADQQxqNgIoIANBEGpBkLCHARDvLAALIAIQlBrBIAHBaiIAwSAARw0FIAIoAhgiAUECaiIEIAIoAhAiBUsEfyACQQxqIAVBAXQiASAEEOAqIgQgASAESxsQ6BkgAigCGAUgAQsgAigCFGogADsAACACIAIoAhhBAmo2AhgMAgsgAUEASCACEJIaIgAgAWoiASAASEcNBSACKAIYIgBBBGoiBCACKAIQIgVLBH8gAkEMaiAFQQF0IgAgBBDgKiIEIAAgBEsbEOgZIAIoAhgFIAALIAIoAhRqIAE2AAAgAiACKAIYQQRqNgIYDAELIAGtIgZCAFQgBiACEJMaIgZ8IgcgBlNHDQUgAigCGCIAQQhqIgEgAigCECIESwR/IAJBDGogBEEBdCIAIAEQ4CoiASAAIAFLGxDoGSACKAIYBSAACyACKAIUaiAHNwAAIAIgAigCGEEIajYCGAsgAiACKAJYQQFqNgJYCyADQTBqJAAPC0EBIAJBiK+HARDDIQALQaivhwFBEEGYr4cBEMskAAtBqK+HAUEQQbivhwEQyyQAC0Gor4cBQRBByK+HARDLJAALgAUCA38DfiMAQYABayIDJAAgASgCCCEFAkACQCAAAn8gASgCDCgCECACQQR0aiIEKQMAIgdCgICAgAh8IgZC/////w9WIAQpAwgiCCAGIAdUrXwiBkIAUiAGUBtFBEAgAyAFKAIAKAIAKAIAIgQ2AgggAyAHPgIUAkAgBKwgB8R+IgZCIIinIAanIgRBH3VHBEAgA0ECNgJkIANBrJD/ADYCYCADQgI3AmwgA0GCDDYCPCADQYIMNgI0IAMgA0EwajYCaCADIANBCGo2AjggAyADQRRqNgIwIANBzABqIANB4ABqEJkOIANBIGogA0HQAGopAgA3AwAgA0EoaiADQdgAaigCADYCACADQYiAgIB4NgJIIAMgAykCSCIGNwMYIAanQZOAgIB4Rw0BIAMoAhwhBAsgA0HgAGogBCAFKAIILQAAEOoPIAMoAmAiBUGTgICAeEYNAyADQRBqIANB8ABqKAIANgIAIAMgAykCaDcDCCADKAJkDAILIANBGGoQiBELIAUoAgQhASADIAg3AzggAyAHNwMwIANBzJH/ADYCSCADQgQ3AlQgA0GEDDYCfCADQfQLNgJ0IAMgAUEBajYCcCADQbsHNgJsIAMgATYCaCADQcwBNgJkIANB+JH/ADYCYCADIANB4ABqNgJQIAMgA0EwajYCeCADQQQ2AkwgA0EcaiADQcgAahCZDiADQRBqIANBKGooAgA2AgAgAyADKQIgNwMIQYKAgIB4IQUgAygCHAs2AgQgACAFNgIAIAAgAykDCDcCCCAAQRBqIANBEGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANBgAFqJAALrQQCA38DfiMAQYACayIFJAAgBCgCACEEAkACQAJAIAEoAgAiBy0AAEUNACAEKAJAIAQoAkQgAiADEMEuBEAgBy0AACEGDAELIAVBhAFqIARBPGoQ3SAgBUH4AGogBEEwahDDBiAELwFIIQYgBCkDKCEIIAVB0ABqIgEgBEEIahCxLiAFIAg3A3AgBSAGOwGQASAFQQhqIgQgASACIAMQshsgASAEIActAAAQlQEgBSgCUEUEQCAFQZgBaiICIAFBBHJBNPwKAABBPEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQQg2AgAgACABNgIEIAQQgy8MAwtBBEE8EKM9AAsgBUGsAWogBUHoAGopAwAiCDcCACAFQaQBaiAFQeAAaikDACIJNwIAIAUgBSkDWCIKNwKcASAAQRBqIAg3AgAgAEEIaiAJNwIAIAAgCjcCACAFQQhqEIMvDAELIAVB0ABqIARBCGogBkEBcRCVASAFKAJQBEAgBUHgAWogBUHoAGopAwAiCDcCACAFQdgBaiAFQeAAaikDACIJNwIAIAUgBSkDWCIKNwLQASAAQRBqIAg3AgAgAEEIaiAJNwIAIAAgCjcCAAwBCyAFQcwBaiICIAVB0ABqQQRyQTT8CgAAQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiACQTT8CgAAIABBCDYCACAAIAE2AgQLIAVBgAJqJAAPC0EEQTwQoz0AC48FAgJ/AX4jAEGAA2siCCQAIAggAzYCDCACKQAIIQogBCgCACIDIAMoAgAiCUEBajYCAAJAAkACQCAJQQBIDQAgCCADNgKkAiAIIAQpAgQ3AqgCAkAgCkIAVwRAIAMgAygCACIDQQFrNgIAIAhBADYCECADQQFHDQEgCEGkAmoQ+x4MAQsgCEEYaiAIQawCaigCADYCACAIIAgpAqQCNwMQCyACKAAAIQIgCEEcaiAGIAcQ0yMCQAJAAkACQCAIKAIMIgMtAAAiBkEbaw4EAQUCAQALIAZBJ0cNBAsgCEHEAmogAxDGBiAIQQA7AfwCIAhBADYC+AIgCEEANgLgAiAIQQA2AtQCIAggAjYC0AIgCEIENwK8AiAIQgA3ArQCIAhCgICAgMAANwKsAiAIQQA2AqQCIAVBAUsNAUEBQQFB/Nn+ABDDIQALIAhBxAJqIAMQxgYgCEEAOwH8AiAIQQA2AvgCIAhBADYC4AIgCEEANgLUAiAIIAI2AtACIAhCBDcCvAIgCEIANwK0AiAIQoCAgIDAADcCrAIgCEEANgKkAiAIQcgBaiICIAhBpAJqIAhBHGoQ7yUMAwsgBCgCDCICIAIoAgAiA0EBajYCACADQQBIDQAgCCACNgK8ASAIIAQpAhA3AsABIAhByAFqIgMgCEGkAmoiAiAIQbwBahD6IyACIAMgCEEcahDvJQwCCwALIAhBATYCqAIgCEHc2v4ANgKkAiAIQgE3ArACIAhBrwM2AswBIAggCEHIAWo2AqwCIAggCEEMajYCyAEgCEGkAmpB5Nr+ABDvLAALIAhB4ABqIAIgCEEQahCuFiAIIAo+AmQgCEEBNgJgIAAgASAIQeAAahDLECAIQYADaiQAC+gEAgN/An4jAEHgAGsiBCQAIARBQGsgAkEIaigCADYCACAEQQA2AkQgBCACKQIANwM4AkAgAwR/IAMoAgAiAiACKAIAIgVBAWo2AgAgBUEASA0BIAMoAgQhBUEgBUEpCyEDIAQgBTYCVCAEIAI2AlAgBCADOgBMIARBADYCWCABKAIYIgEgASgCACICQQFqNgIAIAJBAEgNACAEIAE2AlwgBEEYaiAEQThqIgEgBEHcAGoiAiAEQcwAahDSASABEIYwIAQoAlwiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQgyALIARBJWohASAELQAkIQICQCAEKAIYIgNBgoCAgHhGBEAgBEEWaiABQQJqLQAAIgM6AAAgBCABLwAAIgE7ARQgBCgCICEFIAQpAyghByAEKQMwIQggAEEPaiADOgAAIAAgATsADSAAIAg3AxggACAHNwMQIAAgAjoADCAAIAU2AgggAEGCgICAeDYCAAwBCyAEQRZqIgYgAUECai0AADoAACAEIAEvAAA7ARQgA0GBgICAeEcEQCACQSBGBEAgBCkCHCEHIAQoAiwhAiAEKQMwIQggBCgCKCIBIAEoAgAiBUEBajYCACAFQQBIDQMgACAELwEUOwANIAAgAjYCJCAAIAE2AiAgACAINwMYIAAgAjYCFCAAIAE2AhAgAEEgOgAMIAAgBzcCBCAAIAM2AgAgAEEPaiAGLQAAOgAADAILQZjEzwBBKEHo2c8AEJ8pAAsgBEEIahDBLCAEKAIIIQEgACAEKAIMNgIkIAAgATYCICAAQYGAgIB4NgIACyAEQeAAaiQADwsAC4wKAgh/AX4jAEGQAWsiAyQAIAMgAjYCBCADQegAaiABEI8nIAMoAnAhBCADKAJsIQECQCADKAJoIgVBk4CAgHhHBEAgACADKQJ0NwIMIAAgBDYCCCAAIAE2AgQgACAFNgIADAELIANCADcCGCADIAEgBEECdGo2AgwgAyADQQRqNgIUAkACQCAEBEAgA0EcaiEEIANBGGohBSADQQE2AhAgAyABQQRqNgIIIANBADYCSCADIAE2AkwCfyABKAIAIgFBAEgEQCADQQI2AmwgA0HE/oYBNgJoIANCAjcCdCADQTs2AowBIANBqQg2AoQBIAMgA0GAAWo2AnAgAyADQcgAajYCiAEgAyADQcwAajYCgAEgA0HUAGogA0HoAGoQmQ4gA0HEAGogA0HgAGooAgA2AgAgAyADKQJYNwI8IAMoAlQMAQsgASACTQ0CIANBAzYCVCADQeD9hgE2AlAgA0IDNwJcIANBOzYCfCADQakINgJ0IANBOzYCbCADIANB6ABqNgJYIAMgA0EEajYCeCADIANBzABqNgJwIAMgA0HIAGo2AmggA0E4aiADQdAAahCZDiADKAI4CyEBIAMgAykCQDcCLCADIAMoAjw2AiggAyABNgIkIANBjYCAgHg2AiAgA0EgahCIEQwCCyAAQZOAgIB4NgIADAILIAMgATYCGAsgAyAFNgJUIAMgBDYCUCADIANBNGo2AlggA0HoAGohBSADQdAAaiEGIwBB8ABrIgEkAAJAAn8CQCADQQhqIgQoAgAiAiAEKAIEIgpHBEAgBigCBCEIIAQoAgwhCSAEKAIIIQYDQCABIAY2AjggASACNgJUIAIoAgAiB0EASARAIAQgAkEEajYCACABQQI2AlwgAUGAh4cBNgJYIAFCAjcCZCABQTs2AiwgAUGpCDYCJCABIAFBIGo2AmAgASABQThqNgIoIAEgAUHUAGo2AiAgAUFAayABQdgAahCZDiABQRxqIAFBzABqKAIANgIAIAEgASkCRDcCFCABKAJAIQIMAwsgCSgCACAHSQRAIAQgAkEEajYCACABQQM2AkAgAUGchocBNgI8IAFCAzcCSCABQTs2AmwgASAJNgJoIAFBqQg2AmQgAUE7NgJcIAEgAUHYAGo2AkQgASABQdQAajYCYCABIAFBOGo2AlggAUEQaiABQTxqEJkOIAEoAhAhAgwDCyABIAg2AjQgByAIKAIASQRAIAQgAkEEajYCACABIAc2AjggASAGQQFrNgJUIAFBAzYCQCABQcyHhwE2AjwgAUIDNwJIIAFBOzYCbCABQf8bNgJkIAFBOzYCXCABIAFB2ABqNgJEIAEgAUE4ajYCaCABIAFBNGo2AmAgASABQdQAajYCWCABQSRqIAFBPGoQmQ4gASgCMCEHIAEoAighCCABKAIkIQIgASgCLAwECyAIIAc2AgAgBCAGQQFqIgY2AgggAkEEaiICIApHDQALIAQgAjYCAAsgBUGUgICAeDYCAAwCCyABKQIYIgtCIIinIQcgASgCFCEIIAunCyEJIAUgBzYCECAFIAk2AgwgBSAINgIIIAUgAjYCBCAFQY2AgIB4NgIAIAQgBkEBajYCCAsgAUHwAGokACADKAJoQZSAgIB4RwRAIAAgAykCaDcCACAAQRBqIANB+ABqKAIANgIAIABBCGogA0HwAGopAgA3AgAMAQsgAEGTgICAeDYCAAsgA0GQAWokAAuaCgIIfwF+IwBBkAFrIgMkACADIAI2AgQgA0HoAGogARCQJyADKAJwIQQgAygCbCEBAkAgAygCaCIFQZOAgIB4RwRAIAAgAykCdDcCDCAAIAQ2AgggACABNgIEIAAgBTYCAAwBCyADQgA3AhggAyABIARBA3RqNgIMIAMgA0EEajYCFAJAAkAgBARAIANBHGohBCADQRhqIQUgA0EBNgIQIAMgAUEIajYCCCADQQA2AkggAyABNgJMAn8gASkDACILQoCAgIAQWgRAIANBAjYCbCADQcT+hgE2AmggA0ICNwJ0IANBOzYCjAEgA0HHEDYChAEgAyADQYABajYCcCADIANByABqNgKIASADIANBzABqNgKAASADQdQAaiADQegAahCZDiADQcQAaiADQeAAaigCADYCACADIAMpAlg3AjwgAygCVAwBCyACIAunIgFPDQIgA0EDNgJUIANB4P2GATYCUCADQgM3AlwgA0E7NgJ8IANBxxA2AnQgA0E7NgJsIAMgA0HoAGo2AlggAyADQQRqNgJ4IAMgA0HMAGo2AnAgAyADQcgAajYCaCADQThqIANB0ABqEJkOIAMoAjgLIQEgAyADKQJANwIsIAMgAygCPDYCKCADIAE2AiQgA0GNgICAeDYCICADQSBqEIgRDAILIABBk4CAgHg2AgAMAgsgAyABNgIYCyADIAU2AlQgAyAENgJQIAMgA0E0ajYCWCADQegAaiEFIANB0ABqIQYjAEHwAGsiASQAAkACfwJAIANBCGoiBCgCACICIAQoAgQiCkcEQCAGKAIEIQcgBCgCDCEJIAQoAgghBgNAIAEgBjYCOCABIAI2AlQgAikDACILQoCAgIAQWgRAIAQgAkEIajYCACABQQI2AlwgAUGAh4cBNgJYIAFCAjcCZCABQTs2AiwgAUHHEDYCJCABIAFBIGo2AmAgASABQThqNgIoIAEgAUHUAGo2AiAgAUFAayABQdgAahCZDiABQRxqIAFBzABqKAIANgIAIAEgASkCRDcCFCABKAJAIQIMAwsgC6ciCCAJKAIASwRAIAQgAkEIajYCACABQQM2AkAgAUGchocBNgI8IAFCAzcCSCABQTs2AmwgASAJNgJoIAFBxxA2AmQgAUE7NgJcIAEgAUHYAGo2AkQgASABQdQAajYCYCABIAFBOGo2AlggAUEQaiABQTxqEJkOIAEoAhAhAgwDCyABIAc2AjQgCCAHKAIASQRAIAQgAkEIajYCACABIAg2AjggASAGQQFrNgJUIAFBAzYCQCABQcyHhwE2AjwgAUIDNwJIIAFBOzYCbCABQf8bNgJkIAFBOzYCXCABIAFB2ABqNgJEIAEgAUE4ajYCaCABIAFBNGo2AmAgASABQdQAajYCWCABQSRqIAFBPGoQmQ4gASgCMCEHIAEoAighCCABKAIkIQIgASgCLAwECyAHIAg2AgAgBCAGQQFqIgY2AgggAkEIaiICIApHDQALIAQgAjYCAAsgBUGUgICAeDYCAAwCCyABKQIYIgtCIIinIQcgASgCFCEIIAunCyEJIAUgBzYCECAFIAk2AgwgBSAINgIIIAUgAjYCBCAFQY2AgIB4NgIAIAQgBkEBajYCCAsgAUHwAGokACADKAJoQZSAgIB4RwRAIAAgAykCaDcCACAAQRBqIANB+ABqKAIANgIAIABBCGogA0HwAGopAgA3AgAMAQsgAEGTgICAeDYCAAsgA0GQAWokAAu9BAEHfyMAQUBqIgMkAAJAIAEoAjgiBCACIAIgBEsbIgdFBEAgAEIINwMADAELIAEoAgAgAUEANgIAQQFGBEAgASABKAIENgJUIAEgBEEBazYCOEEBIQYLIANBIDYCBCADQQhqQQBBIEGEqM0AELMVAkACQAJAAkAgBiAHSQRAIAFBCGohCSABKAJQIQIDQAJAIAINACADQRhqIAEQwQkgAygCGCICQQhGDQAgACADKQIcNwIEIABBFGogA0EsaigCADYCACAAQQxqIANBJGopAgA3AgAMBgsgASgCTCIFIAEoAjAiAk8NAiAHIAZrIgIgASgCUCIEIAIgBEkbIgQgAygCECICSw0DIAMgCSADKAIMIgIgBCABKAIsIAVqLQAAELkGIgU2AhQgBCAFRw0EIAQEQCAEQQJ0IQggASgCVCEFA0AgAiABKAJEIAIoAgAgBWpqIgU2AgAgASAFNgJUIAJBBGohAiAIQQRrIggNAAsLIAEgASgCUCAEayICNgJQIAEgASgCOCAEazYCOCAEIAZqIgYgB0kNAAsLIABBCDYCACAAIAc2AgQgA0EIahDpOwwECyAFIAJBlKjNABDDIQALIAQgAkGkqM0AELA7AAsgA0EDNgIcIANB5KjNADYCGCADQgI3AiQgA0E7NgI8IANBOzYCNCADIANBMGo2AiAgAyADQRRqNgI4IAMgA0EEajYCMCAAQQRqIANBGGoQmQ5BACECCyAAIAI2AgAgA0EIahDpOwsgA0FAayQAC78EAgZ/AX4jAEFAaiIDJAACQCABKAJQIgQgAiACIARLGyIHRQRAIABCCDcDAAwBCyABKAIAIAFCADcDAEEBRgRAIAEgASkDCDcDOCABIARBAWs2AlBBASEGCyADQcAANgIEIANBCGpBwABBhKjNABC2FQJAAkACQAJAIAYgB0kEQCABQRBqIQggASgCZCECA0ACQCACDQAgA0EYaiABEI0LIAMoAhgiAkEIRg0AIAAgAykCHDcCBCAAQRRqIANBLGooAgA2AgAgAEEMaiADQSRqKQIANwIADAYLIAEoAmAiBSABKAJIIgJPDQIgByAGayICIAEoAmQiBCACIARJGyIEIAMoAhAiAksNAyADIAggAygCDCICIAQgASgCRCAFai0AABCQBCIFNgIUIAQgBUcNBCAEBEAgBEEDdCEFIAEpAzghCQNAIAIgASkDMCACKQMAIAl8fCIJNwMAIAEgCTcDOCACQQhqIQIgBUEIayIFDQALCyABIAEoAmQgBGsiAjYCZCABIAEoAlAgBGs2AlAgBCAGaiIGIAdJDQALCyAAQQg2AgAgACAHNgIEIANBCGoQ4zwMBAsgBSACQZSozQAQwyEACyAEIAJBpKjNABCwOwALIANBAzYCHCADQeSozQA2AhggA0ICNwIkIANBOzYCPCADQTs2AjQgAyADQTBqNgIgIAMgA0EUajYCOCADIANBBGo2AjAgAEEEaiADQRhqEJkOQQAhAgsgACACNgIAIANBCGoQ4zwLIANBQGskAAvpBAIHfwF+IwBBEGsiAyQAAkAgAC8BDCICRQRAIAAoAgAgACgCBCABEOQJIQEMAQsgA0EIaiABQQhqKQIANwMAIAMgASkCADcDAAJAAn8gACkCCCIJpyIGQYCAgAhxRQRAIAMoAgQMAQsgACgCACADKAIAIAMoAgQiASAAKAIEKAIMEQYADQEgACAGQYCAgP95cUGwgICAAnIiBjYCCCADQgE3AwAgAiABQf//A3FrIgFBACABIAJNGyECQQALIQcCQCADKAIMIghFBEAMAQsgAygCCCEBA0ACfwJAAkACQAJAIAEvAQBBAWsOAgECAAsgAUEEaigCAAwDCyABQQJqLwEAIgUNAUEBDAILIAFBCGooAgAMAQsgBUH2/xdqIAVBnP8fanEgBUGY+DdqIAVB8LEfanFzQRF2QQFqCyEFIAFBDGohASAEIAVqIQQgCEEBayIIDQALCwJAIAQgB2oiASACQf//A3FJBEAgAiABayEEQQAhAUEAIQICQAJAAkAgBkEddkEDcUEBaw4DAAEAAgsgBCECDAELIARB/v8DcUEBdiECCyAGQf///wBxIQggACgCBCEFIAAoAgAhBwNAIAFB//8DcSACQf//A3FPDQIgAUEBaiEBIAcgCCAFKAIQEQIARQ0ACwwCCyAAKAIAIAAoAgQgAxDkCSEBIAAgCTcCCAwCCyAHIAUgAxDkCQ0AQQAhBiAEIAJrQf//A3EhAgNAAkAgBkH//wNxIgQgAkkhASACIARNDQAgBkEBaiEGIAcgCCAFKAIQEQIARQ0BCwsgACAJNwIIDAELQQEhAQsgA0EQaiQAIAELsAQBDn8jAEEgayIIJAACQCABQYCAAksiDQ0AIAAoAhwiBUECdCEGIAAoAhghCQJAIAVFDQAgAC8BOCEKIAYhAiAJIQMDQCADLwEAQf//A0cEQCAEIANBAmovAQAgCnFrIApxRQ0CCyADQQRqIQMgBEEBaiEEIAJBBGsiAg0AC0EAIQQLIAhBFGoiAyABQfjhwwAQsTYgCEEIaiADQYjiwwAQliEgCCgCCCELIAgoAgwhByAAIAFBAWsiDDsBOCAAIAc2AhwgACALNgIYAkACQCAEIAVNBEAgCSAEQQJ0aiEKIAQgBUYNAiAGIAlqIQYgCiEBA0AgAS8BACIOQf//A0cEQCAMIAEvAQIiD3EhAgNAIAIhA0EAIQIgAyAHTw0AIAsgA0ECdGoiAi8BAEH//wNHBEAgA0EBaiECDAELCyACIA87AQIgAiAOOwEACyAGIAFBBGoiAUcNAAsMAQsgBCAFQZjiwwAQrzsACyAAKAIcIQcLIAQEQCAAKAIYIQYgAC8BOCEEIAkhAQNAIAEvAQAiC0H//wNHBEAgBCABLwECIgxxIQIDQCACIQNBACECIAMgB08NACAGIANBAnRqIgIvAQBB//8DRwRAIANBAWohAgwBCwsgAiAMOwECIAIgCzsBAAsgAUEEaiIBIApHDQALCyAAQSBqIAAoAigiACAHIAAgB0ECdmprQQRBNEGo4sMAEMMoIAVFDQAgCSAFQQJ0QQIQ+DoLIAhBIGokACANC/uRAwMpfwN+AXwjAEHQAWsiGiQAIAEgASgCECACKAIQajYCECABKAIEISMgASgCCCEEIBpBEGogASgCDEEIahDDNCAaKAIQIQEgGigCFCEGIBpBCGogAhDcOyAaQfAAaiABIAEgBkECdGogGigCCCIBIAEgGigCDEEDdGoQySICQAJAAkAgGigCgAEiAiAaKAKEASImTw0AICMgBEG4BWxqIScgGigCeCEoIBooAnAhKSAaQfQAaiEqA0AgGkHwAGohCSApIAJBAnRqKAIAQQhqIQojAEEgayIEJAAgBEEIaiEGIwBB4AFrIgEkACABQZgBaiAKQQBBACAoIAJBA3RqIgoQtgECQCABKAKYASILQYSAgIB4RgRAIAFB5ABqIAFBsAFqKQMAIiw3AgAgAUHcAGogAUGoAWopAwAiLTcCACABIAEpA6ABIi43AlQgBkEQaiAsNwIAIAZBCGogLTcCACAGIC43AgAMAQsgAUHoAGoiECABQbQBaigCADYCACABQeAAaiITIAFBrAFqKQIANwMAIAFB2ABqIhEgAUGkAWopAgA3AwAgASABKQKcATcDUCABQfAAaiIDIAFBuAFqQSj8CgAAIAFBFGogESkDADcCACABQRxqIBMpAwA3AgAgAUEkaiAQKAIANgIAIAEgCzYCCCABIAEpA1A3AgwgAUEoaiADQSj8CgAAIAFBCGoiC0EAIAoQ9C0QmQIgAUGYAWoiCiALQcgA/AoAACAGQQRqIAoQygsgBkEINgIACyABQeABaiQAIAQoAhQhBiAEKAIQIQEgBCgCDCEKAkAgBCgCCCIDQQhHBEAgCSAEKQMYNwMQIAkgBjYCDCAJIAE2AgggCSAKNgIEDAELIAQgCjYCECAEIAE2AgwgBCABNgIIIAQgASAGQcgAbGo2AhQgBEEIaiIBKAIIIRcgASgCACIQIQogASgCBCIGIAEoAgwiC0cEQANAIAogBkHIAPwKAAAgCkHIAGohCiAGQcgAaiIGIAtHDQALIAEgBjYCBAsjAEEQayILJAAgAUEANgIIIAEoAgwhEyABKAIEIQYgAUEENgIAIAtCgICAgMAANwIIIAtBCGpBBEHIABDgHiABQQQ2AgwgAUEENgIEIBMgBmtByABuIREgBiATRwRAA0AgBhDCICAGQcgAaiEGIBFBAWsiEQ0ACwsgC0EQaiQAIAlBBGoiBiAQNgIEIAYgFzYCACAGIAogEGtByABuNgIIIAEQ5yALIAkgAzYCACAEQSBqJAAgGigCfCEEIBooAnghASAaKAJ0IQYgGigCcCIJQQhHBEAgACAaKQOAATcDECAAIAQ2AgwgACABNgIIIAAgBjYCBCAAIAk2AgAMAwsgGiAGNgIkIBogATYCICAaIAE2AhwgGiABIARByABsajYCKAJAAkAgBEUNAANAIBogAUHIAGo2AiAgASgCACEEIBpBLGoiBiABQQRqQcQA/AoAACAEQYCAgIB4Rg0BIBogBDYCcCAqIAZBxAD8CgAAICMgJ0YNAiAaQbgBaiEhIBpB8ABqIishC0EAIQlBACEDQgAhLEEAIREjAEHgAWsiByQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAICMiBikDAEICUQRAIAsoAiQgCygCKCIEKAIIQQFrQXhxakEIaiEKIAsoAgghBSALKAIEIQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYoAghBAWsOBwECAwQFBgcACyAKIAQQxS8hCiAHQdAAaiAFQQBBAUEBEKAYIAcoAlQhBCAHKAJQQQFGDS8gB0EANgK8ASAHIAcoAlg2ArgBIAcgBDYCtAEgBQRAIAVBAnQhCQNAIAogASgCABCEGiEQIAcoArwBIgQgBygCtAFGBEAgB0G0AWpB6PHPABCjKAsgAUEEaiEBIAcoArgBIARqIBA6AAAgByAEQQFqNgK8ASAJQQRrIgkNAAsLIAdB2ABqIAdBvAFqKAIAIhQ2AgAgByAHKQK0ATcDUCAHQThqIQwgBkEQaiEOIAcoAlQhFiALKAIQQQAgCygCDEGAgICAeEcbIRUgCygCFCEBIAsoAhxBACALKAIYQYCAgIB4RxshEiALKAIgIRcjAEEwayIIJAACQAJAIBVBACASG0UEQCAUIRAgFUUNASABIRAMAQsgFyABIhBGDQAgCCABNgIAIAggFzYCBCAIQQI2AhwgCEGI/s4ANgIYIAhCAjcCJCAIQTs2AhQgCEE7NgIMIAggCEEIajYCICAIIAhBBGo2AhAgCCAINgIIIAxBBGogCEEYahCZDiAMQQA2AgAMAQsgDigCgAFFBEAgDkIANwOwAQsgDkIANwOoAQJAAkACQCAQBEAgDigCmAQoApQBIRkDQAJAIBJFIAMgGWoiBCAQIAQgEEkbIhMgF09yDQAgEiATQQF0aiEEA0AgBC8BAEUNASAEQQJqIQQgFyATQQFqIhNHDQALIBchEwtBACEEQQAhCiAVBEAgAyATSw0DIAEgE0kNVCAVIANBAXRqIQoLIBIEQCADIBNLDQQgEyAXSw0FIBIgA0EBdGohBAsgCEEYaiEFIAohCSMAQUBqIg0kACATIANrIgshDwJAAkAgDigClAQiAy4BGCIGQQBKBH8gCUUEQCANQQE2AhwgDUH4/84ANgIYIA1CATcCJCANQc0BNgI4IA0gBjsBPiANIA1BNGo2AiAgDSANQT5qNgI0IA1BBHIgDUEYahCZDiAFIA0pAgw3AgwgBUEUaiANQRRqKAIANgIAIAUgDSkCBDcCBCAFQQA2AgAMAwtBACEPIAsEQCAGQf//A3EhAyAJIQYgCyEKA0AgDyAGLwEAIANGaiEPIAZBAmohBiAKQQFrIgoNAAsLIA4gDikDgAMgCyAPa618NwOAAyAOKAKUA0GAgICAeEcEQCAOQZQDaiAJIAsQ1yELIA5B/ANqIAkgCxD4KSAOKAKUBAUgAwsuARoiBkEATARAIA4gDigCpAMgC2o2AqQDDAELIAQEQCALBEAgBC8BAARAIA1BATYCHCANQZD/zgA2AhggDUIBNwIkIA1BzQE2AgQgDSAENgIAIA0gDTYCICAFQQRqIA1BGGoQmQ4gBUEANgIADAQLIAtBAXQhAyAOKAKkAyEKIAQhBgNAIAogBi8BAEVqIQogBkECaiEGIANBAmsiAw0ACyAOIAo2AqQDCyAOKAKIA0GAgICAeEcEQCAOQYgDaiAEIAsQ1yELIA5BiARqIAQgCxD4KQwBCyANQQE2AhwgDUHAgM8ANgIYIA1CATcCJCANQc0BNgI4IA0gBjsBPiANIA1BNGo2AiAgDSANQT5qNgI0IA1BBHIgDUEYahCZDiAFIA0pAgw3AgwgBUEUaiANQRRqKAIANgIAIAUgDSkCBDcCBCAFQQA2AgAMAQsgDUEYaiEGIwBB0ABrIgQkACAOIA4oAoABIA9qNgKAASAEIA82AgQCQCAPIA8gEWoiCU0gCSAUTXFFBEAgBCAUIBFrNgI8IARBAjYCKCAEQYiJzgA2AiQgBEICNwIwIARBOzYCTCAEQTs2AkQgBCAEQUBrNgIsIAQgBEE8ajYCSCAEIARBBGo2AkAgBEEIakEEciAEQSRqEJkOIAYgBCkCFDcCDCAGQRRqIARBHGooAgA2AgAgBiAEKQIMNwIEIAZBADYCAAwBCyAGIA4gESAWaiAPELgRCyAEQdAAaiQAIA0oAhgiBEEIRwRAIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCyAOIA4oAqADIAtqIgQ2AqADAkAgBEUNACAOKAKkAyAOKAKYBCIEKAKQAUkEQCAOELwcIAQoAowBSQ0BCyANQRhqIA4Q5gEgDSgCGCIEQQhGDQAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELAkAgDigCWEGAgICAeEYNACAOKAJMIA4oApgEQQhqIA4oApQEQQhqENARSQ0AIA1BGGohCSMAQcABayIGJAACQAJAIA4oAqADRQ0AIAZBIGogDhDmASAGKAIgIgRBCEYNACAJIAYpAiQ3AgQgCUEUaiAGQTRqKAIANgIAIAlBDGogBkEsaikCADcCACAJIAQ2AgAMAQsgBkEgaiAOEI8HIAYoAiAiBEEIRwRAIAkgBikCJDcCBCAJQRRqIAZBNGooAgA2AgAgCUEMaiAGQSxqKQIANwIAIAkgBDYCAAwBCwJAAkAgDigCoANFDQAgBkGoAWogDhDmASAGKAKoASIEQQhGDQAMAQsCQCAOKAKsAiIERQ0AIAZBKGohCgNAIA4gBEEBazYCrAIgDiAOKAKoAiIEQQFqIgsgDigCoAIiA0EAIAMgC00bazYCqAIgDigCpAIgBEGIAWxqIgQpAwAiLEIMUQ0BIAYgLDcDICAKIARBCGpBgAH8CgAAIAZBqAFqIA4gBkEgahCpCiAGKAKoASIEQQhHDQIgDigCrAIiBA0ACwsgCUEINgIADAELIAZBGGoiCiAGQbwBaigCADYCACAGQRBqIgsgBkG0AWopAgA3AwAgBiAGKQKsATcDCCAJIAQ2AgAgCSAGKQMINwIEIAlBDGogCykDADcCACAJQRRqIAooAgA2AgALIAZBwAFqJAAgDSgCGCIEQQhGDQAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELIAVBCDYCACAFIA82AgQLIA1BQGskACAIKAIcIQQgCCgCGCIGQQhHBEAgDCAIKQMgNwMIIAxBEGogCEEoaikDADcDACAMIAQ2AgQgDCAGNgIADAYLIAQgEWohESAQIBMiA0sNAAsLIAxBCDYCACAMIBE2AgQMAwsgAyATQZj+zgAQsTsACyADIBNBqP7OABCxOwALDFcLIAhBMGokACAHQdAAahDeOwxGCyAGQRBqIQECQCAKIAQoAhwRBAAiCS0AACIGQSJrDgUICQoLDAALIAZBCEYNBiAGQQ9GDQwgB0HQAGoiCSAKIARBsO7PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEYNEiAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDEULIAZBEGohAQJAIAogBCgCHBEEACIJLQAAIgZBImsOBRcUGBkaAAsgBkEFaw4FFBMTExUSCyAHQQA2AmAgB0EBNgJUIAdBqO/PADYCUCAHQgQ3AlggB0HQAGpBsO/PABDvLAALIAdBOGohFSAGQRBqIQ4gCiAEEO8hIgQoAhAhICAEKAIUQQJ2IRQgASEPIAsoAhBBACALKAIMQYCAgIB4RxshGyALKAIUIQEgCygCHEEAIAsoAhhBgICAgHhHGyEWIAsoAiAhFyMAQTBrIhIkAAJAAkAgG0EAIBYbRQRAIBQhECAbRQ0BIAEhEAwBCyAXIAEiEEYNACASIAE2AgAgEiAXNgIEIBJBAjYCHCASQYj+zgA2AhggEkICNwIkIBJBOzYCFCASQTs2AgwgEiASQQhqNgIgIBIgEkEEajYCECASIBI2AgggFUEEaiASQRhqEJkOIBVBADYCAAwBCyAOKAKQAUUEQCAOQgA3A8ABCyAOQgA3A7gBAkACQAJAIBAEQCAOKAK8BCgClAEhJANAAkAgFkUgCSAkaiIEIBAgBCAQSRsiEyAXT3INACAWIBNBAXRqIQoDQCAKLwEARQ0BIApBAmohCiAXIBNBAWoiE0cNAAsgFyETC0EAIQpBACERIBsEQCAJIBNLDQMgASATSQ1QIBsgCUEBdGohEQsgFgRAIAkgE0sNBCATIBdLDQUgFiAJQQF0aiEKCyASQRhqIQwjAEFAaiINJAAgEyAJayIGIQgCQAJAAkACQAJAIA4oArgEIgkuARgiBEEASgR/IBFFBEAgDUEBNgIcIA1B+P/OADYCGCANQgE3AiQgDUHNATYCOCANIAQ7AT4gDSANQTRqNgIgIA0gDUE+ajYCNCANQQRyIA1BGGoQmQ4gDCANKQIMNwIMIAxBFGogDUEUaigCADYCACAMIA0pAgQ3AgQgDEEANgIADAMLQQAhCCAGBEAgBEH//wNxIQkgESEEIAYhCwNAIAggBC8BACAJRmohCCAEQQJqIQQgC0EBayILDQALCyAOIA4pA5gDIAYgCGutfDcDmAMgDigCrANBgICAgHhHBEAgDkGsA2ogESAGENchCyAOQaAEaiARIAYQ+CkgDigCuAQFIAkLLgEaIgRBAEwEQCAOIA4oArwDIAZqNgK8AwwBCyAKBEAgBgRAIAovAQAEQCANQQE2AhwgDUGQ/84ANgIYIA1CATcCJCANQc0BNgIEIA0gCjYCACANIA02AiAgDEEEaiANQRhqEJkOIAxBADYCAAwECyAGQQF0IQkgDigCvAMhCyAKIQQDQCALIAQvAQBFaiELIARBAmohBCAJQQJrIgkNAAsgDiALNgK8AwsgDigCoANBgICAgHhHBEAgDkGgA2ogCiAGENchCyAOQawEaiAKIAYQ+CkMAQsgDUEBNgIcIA1BwIDPADYCGCANQgE3AiQgDUHNATYCOCANIAQ7AT4gDSANQTRqNgIgIA0gDUE+ajYCNCANQQRyIA1BGGoQmQ4gDCANKQIMNwIMIAxBFGogDUEUaigCADYCACAMIA0pAgQ3AgQgDEEANgIADAELAkAgDwRAIAMgCGoiBCAISQ0DIAQgBUsNBCMAQSBrIgskACAOIA4oApABIAhqNgKQASALIBQ2AhwgCyAgNgIYIAsgDyADQQJ0aiIENgIQIAsgBCAIQQJ0ajYCFCMAQSBrIgkkACAJQRRqIAtBEGoiESgCBCARKAIAa0ECdkEAQQRBBBCgGCAJKAIYIQQgCSgCFEEBRg1WIAtBBGohHiAJQRBqIiVBADYCACAJIAkoAhw2AgwgCSAENgIIIwBBEGsiHSQAIAlBCGoiBCARKAIEIBEoAgBrQQJ2EO4tIB0gBCkCBEIgiTcCCCAdIARBCGo2AgQgHUEEaiIZKAIEIQQgGSgCACEYAkACQCARKAIAIgogESgCBCIfRwRAIBEoAgwhIiARKAIIIRwgGSgCCCAEQQJ0aiERIB8gCmtBAnYhGQNAIAooAgAiHyAiTw0CIBEgHCAfQQJ0aioCADgCACAKQQRqIQogEUEEaiERIARBAWohBCAZQQFrIhkNAAsLIBggBDYCAAwBCyAfICJB3OXQABDDIQALIB1BEGokACAeQQhqICUoAgA2AgAgHiAJKQIINwIAIAlBIGokACANQRhqIA4gCygCCCALKAIMEPsQIB4Q6TsgC0EgaiQAIA0oAhgiBEEIRg0BIAwgDSkCHDcCBCAMQRRqIA1BLGooAgA2AgAgDEEMaiANQSRqKQIANwIAIAwgBDYCAAwCCyANQRhqIQkjAEHQAGsiBCQAIA4gDigCkAEgCGo2ApABIAQgCDYCBAJAIAggAyAIaiIKTSAKIBRNcUUEQCAEIBQgA2s2AjwgBEECNgIoIARBiInOADYCJCAEQgI3AjAgBEE7NgJMIARBOzYCRCAEIARBQGs2AiwgBCAEQTxqNgJIIAQgBEEEajYCQCAEQQhqQQRyIARBJGoQmQ4gCSAEKQIUNwIMIAlBFGogBEEcaigCADYCACAJIAQpAgw3AgQgCUEANgIADAELIAkgDiAgIANBAnRqIAgQ+xALIARB0ABqJAAgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELIA4gDigCuAMgBmoiBDYCuAMCQCAERQ0AIA4oArwDIA4oArwEIgQoApABSQRAIA4QvRwgBCgCjAFJDQELIA1BGGogDhDoASANKAIYIgRBCEYNACAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAQsCQCAOKAJoQYCAgIB4Rg0AIA4oAlwgDigCvARBCGogDigCuARBCGoQ0BFJDQAgDUEYaiEGIwBBwAFrIgQkAAJAAkAgDigCuANFDQAgBEEgaiAOEOgBIAQoAiAiCUEIRg0AIAYgBCkCJDcCBCAGQRRqIARBNGooAgA2AgAgBkEMaiAEQSxqKQIANwIAIAYgCTYCAAwBCyAEQSBqIA4QjgcgBCgCICIJQQhHBEAgBiAEKQIkNwIEIAZBFGogBEE0aigCADYCACAGQQxqIARBLGopAgA3AgAgBiAJNgIADAELAkACQCAOKAK4A0UNACAEQagBaiAOEOgBIAQoAqgBIgpBCEYNAAwBCwJAIA4oAsQCIgpFDQAgBEEoaiEJA0AgDiAKQQFrNgLEAiAOIA4oAsACIgpBAWoiCyAOKAK4AiIRQQAgCyARTxtrNgLAAiAOKAK8AiAKQYgBbGoiCikDACIsQgxRDQEgBCAsNwMgIAkgCkEIakGAAfwKAAAgBEGoAWogDiAEQSBqEKgKIAQoAqgBIgpBCEcNAiAOKALEAiIKDQALCyAGQQg2AgAMAQsgBEEYaiIJIARBvAFqKAIANgIAIARBEGoiCyAEQbQBaikCADcDACAEIAQpAqwBNwMIIAYgCjYCACAGIAQpAwg3AgQgBkEMaiALKQMANwIAIAZBFGogCSgCADYCAAsgBEHAAWokACANKAIYIgRBCEYNACAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAQsgDEEINgIAIAwgCDYCBAsgDUFAayQADAILIAMgBEGo/84AELE7AAsgBCAFQaj/zgAQsDsACyASKAIcIQQgEigCGCIGQQhHBEAgFSASKQMgNwMIIBVBEGogEkEoaikDADcDACAVIAQ2AgQgFSAGNgIADAYLIAMgBGohAyAQIBMiCUsNAAsLIBVBCDYCACAVIAM2AgQMAwsgCSATQZj+zgAQsTsACyAJIBNBqP7OABCxOwALDFMLIBJBMGokAAxCCyAHQThqIRUgBkEQaiEOIAogBBCCIiIEKAIQISAgBCgCFEEDdiEUIAEhDyALKAIQQQAgCygCDEGAgICAeEcbIRsgCygCFCEBIAsoAhxBACALKAIYQYCAgIB4RxshFiALKAIgIRcjAEEwayISJAACQAJAIBtBACAWG0UEQCAUIRAgG0UNASABIRAMAQsgFyABIhBGDQAgEiABNgIAIBIgFzYCBCASQQI2AhwgEkGI/s4ANgIYIBJCAjcCJCASQTs2AhQgEkE7NgIMIBIgEkEIajYCICASIBJBBGo2AhAgEiASNgIIIBVBBGogEkEYahCZDiAVQQA2AgAMAQsgDigCoAFFBEAgDkIANwPwAQsgDkIANwPoAQJAAkACQCAQBEAgDigC6AQoApQBISQDQAJAIBZFIAkgJGoiBCAQIAQgEEkbIhMgF09yDQAgFiATQQF0aiEKA0AgCi8BAEUNASAKQQJqIQogFyATQQFqIhNHDQALIBchEwtBACEKQQAhESAbBEAgCSATSw0DIAEgE0kNTyAbIAlBAXRqIRELIBYEQCAJIBNLDQQgEyAXSw0FIBYgCUEBdGohCgsgEkEYaiEMIwBBQGoiDSQAIBMgCWsiBiEIAkACQAJAAkACQCAOKALkBCIJLgEYIgRBAEoEfyARRQRAIA1BATYCHCANQfj/zgA2AhggDUIBNwIkIA1BzQE2AjggDSAEOwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAwgDSkCDDcCDCAMQRRqIA1BFGooAgA2AgAgDCANKQIENwIEIAxBADYCAAwDC0EAIQggBgRAIARB//8DcSEJIBEhBCAGIQsDQCAIIAQvAQAgCUZqIQggBEECaiEEIAtBAWsiCw0ACwsgDiAOKQPQAyAGIAhrrXw3A9ADIA4oAuQDQYCAgIB4RwRAIA5B5ANqIBEgBhDXIQsgDkHMBGogESAGEPgpIA4oAuQEBSAJCy4BGiIEQQBMBEAgDiAOKAL0AyAGajYC9AMMAQsgCgRAIAYEQCAKLwEABEAgDUEBNgIcIA1BkP/OADYCGCANQgE3AiQgDUHNATYCBCANIAo2AgAgDSANNgIgIAxBBGogDUEYahCZDiAMQQA2AgAMBAsgBkEBdCEJIA4oAvQDIQsgCiEEA0AgCyAELwEARWohCyAEQQJqIQQgCUECayIJDQALIA4gCzYC9AMLIA4oAtgDQYCAgIB4RwRAIA5B2ANqIAogBhDXIQsgDkHYBGogCiAGEPgpDAELIA1BATYCHCANQcCAzwA2AhggDUIBNwIkIA1BzQE2AjggDSAEOwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAwgDSkCDDcCDCAMQRRqIA1BFGooAgA2AgAgDCANKQIENwIEIAxBADYCAAwBCwJAIA8EQCADIAhqIgQgCEkNAyAEIAVLDQQjAEEgayILJAAgDiAOKAKgASAIajYCoAEgCyAUNgIcIAsgIDYCGCALIA8gA0ECdGoiBDYCECALIAQgCEECdGo2AhQjAEEgayIJJAAgCUEUaiALQRBqIhEoAgQgESgCAGtBAnZBAEEIQQgQoBggCSgCGCEEIAkoAhRBAUYNVSALQQRqIR4gCUEQaiIlQQA2AgAgCSAJKAIcNgIMIAkgBDYCCCMAQRBrIh0kACAJQQhqIgQgESgCBCARKAIAa0ECdhDsLSAdIAQpAgRCIIk3AgggHSAEQQhqNgIEIB1BBGoiGSgCBCEEIBkoAgAhGAJAAkAgESgCACIKIBEoAgQiH0cEQCARKAIMISIgESgCCCEcIBkoAgggBEEDdGohESAfIAprQQJ2IRkDQCAKKAIAIh8gIk8NAiARIBwgH0EDdGorAwA5AwAgCkEEaiEKIBFBCGohESAEQQFqIQQgGUEBayIZDQALCyAYIAQ2AgAMAQsgHyAiQdzl0AAQwyEACyAdQRBqJAAgHkEIaiAlKAIANgIAIB4gCSkCCDcCACAJQSBqJAAgDUEYaiAOIAsoAgggCygCDBD8ECAeEOM8IAtBIGokACANKAIYIgRBCEYNASAMIA0pAhw3AgQgDEEUaiANQSxqKAIANgIAIAxBDGogDUEkaikCADcCACAMIAQ2AgAMAgsgDUEYaiEJIwBB0ABrIgQkACAOIA4oAqABIAhqNgKgASAEIAg2AgQCQCAIIAMgCGoiCk0gCiAUTXFFBEAgBCAUIANrNgI8IARBAjYCKCAEQYiJzgA2AiQgBEICNwIwIARBOzYCTCAEQTs2AkQgBCAEQUBrNgIsIAQgBEE8ajYCSCAEIARBBGo2AkAgBEEIakEEciAEQSRqEJkOIAkgBCkCFDcCDCAJQRRqIARBHGooAgA2AgAgCSAEKQIMNwIEIAlBADYCAAwBCyAJIA4gICADQQN0aiAIEPwQCyAEQdAAaiQAIA0oAhgiBEEIRg0AIAwgDSkCHDcCBCAMQRRqIA1BLGooAgA2AgAgDEEMaiANQSRqKQIANwIAIAwgBDYCAAwBCyAOIA4oAvADIAZqIgQ2AvADAkAgBEUNACAOKAL0AyAOKALoBCIEKAKQAUkEQCAOEL4cIAQoAowBSQ0BCyANQRhqIA4Q6gEgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELAkAgDigCeEGAgICAeEYNACAOKAJsIA4oAugEQQhqIA4oAuQEQQhqENARSQ0AIA1BGGohBiMAQcABayIEJAACQAJAIA4oAvADRQ0AIARBIGogDhDqASAEKAIgIglBCEYNACAGIAQpAiQ3AgQgBkEUaiAEQTRqKAIANgIAIAZBDGogBEEsaikCADcCACAGIAk2AgAMAQsgBEEgaiAOEIwHIAQoAiAiCUEIRwRAIAYgBCkCJDcCBCAGQRRqIARBNGooAgA2AgAgBkEMaiAEQSxqKQIANwIAIAYgCTYCAAwBCwJAAkAgDigC8ANFDQAgBEGoAWogDhDqASAEKAKoASIKQQhGDQAMAQsCQCAOKAL8AiIKRQ0AIARBKGohCQNAIA4gCkEBazYC/AIgDiAOKAL4AiIKQQFqIgsgDigC8AIiEUEAIAsgEU8bazYC+AIgDigC9AIgCkGIAWxqIgopAwAiLEIMUQ0BIAQgLDcDICAJIApBCGpBgAH8CgAAIARBqAFqIA4gBEEgahCkCiAEKAKoASIKQQhHDQIgDigC/AIiCg0ACwsgBkEINgIADAELIARBGGoiCSAEQbwBaigCADYCACAEQRBqIgsgBEG0AWopAgA3AwAgBCAEKQKsATcDCCAGIAo2AgAgBiAEKQMINwIEIAZBDGogCykDADcCACAGQRRqIAkoAgA2AgALIARBwAFqJAAgDSgCGCIEQQhGDQAgDCANKQIcNwIEIAxBFGogDUEsaigCADYCACAMQQxqIA1BJGopAgA3AgAgDCAENgIADAELIAxBCDYCACAMIAg2AgQLIA1BQGskAAwCCyADIARBqP/OABCxOwALIAQgBUGo/84AELA7AAsgEigCHCEEIBIoAhgiBkEIRwRAIBUgEikDIDcDCCAVQRBqIBJBKGopAwA3AwAgFSAENgIEIBUgBjYCAAwGCyADIARqIQMgECATIglLDQALCyAVQQg2AgAgFSADNgIEDAMLIAkgE0GY/s4AELE7AAsgCSATQaj+zgAQsTsACwxSCyASQTBqJAAMQQsgB0EANgJgIAdBATYCVCAHQYTwzwA2AlAgB0IENwJYIAdB0ABqQYzwzwAQ7ywACwJAIAogBCgCHBEEACIJLQAAIhBBI2sOBCEiIyQACyAQQRNrDgMeHB8bCyAHIAogBBD1IUEMahDHGyAHQThqIAEgBygCACAHKAIEIAsQ9icMPgsgCSgCCCIGLQAAQSNrDgQFBgcICQsgB0HQAGoiBiAKIAQQ5CEQlyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMPAsgB0HQAGoiBiAKIAQQ6CEQnyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOwsgB0HQAGoiBiAKIAQQ/CEQmCAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOgsgB0HQAGoiBiAKIAQQ4yEQpSAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAYQ5CQMOQsgB0HQAGoiCSAKIARBzO3PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDkLIAcgBDYC1AEgByAGNgLQASAHQdAAaiIJIAdB0AFqIgpB2O3PAEGw7s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIQQZOAgIB4RwRAIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgEDYCUCAHQThqIAkQpiUgBygC0AEiASABKAIAIgFBAWs2AgAgAUEBRw05IAoQuyMMOQsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIMeIgQoAhAgBCgCFEECdiALEPYnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUYEQCABELsjCyAHKALQASIBIAEoAgAiAUEBazYCACABQQFHDTggB0HQAWoQuyMMOAsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDgLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQiB4QlyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw03IAYQuyMMNwsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDcLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQjR4QnyAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw02IAYQuyMMNgsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDYLIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQhh4QmCAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw01IAYQuyMMNQsgB0HQAGoiCSAKIAQgBhDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDULIAcgBDYCuAEgByAGNgK0ASAHQdAAaiIEIAdBtAFqIgYQgB4QpSAgB0E4aiABIAcoAmAgBygCZEECdiALEPYnIAQQ5CQgBygCtAEiASABKAIAIgFBAWs2AgAgAUEBRw00IAYQuyMMNAsgB0HQAGoiCSAKIARBsO7PABDpIyAHKAJYIQQgBygCVCEGIAcoAlAiCkGTgICAeEcEQCAHIAcpAlw3AlwgByAENgJYIAcgBjYCVCAHIAo2AlAgB0E4aiAJEKYlDDQLIAcgBDYCuAEgByAGNgK0ASAHQThqIAEgB0G0AWoiARCDHiIEKAIQIAQoAhRBAnYgCxD2JyAHKAK0ASIEIAQoAgAiBEEBazYCACAEQQFHDTMgARC7IwwzCyAHIAQ2ArgBIAcgBjYCtAEgB0E4aiABIAdBtAFqIgEQgx4iBCgCECAEKAIUQQJ2IAsQ9icgBygCtAEiBCAEKAIAIgRBAWs2AgAgBEEBRw0yIAEQuyMMMgsgBkEPRg0HCyAHQdAAaiIJIAogBEG87s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIKQZOAgIB4Rg0LIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgCjYCUCAHQThqIAkQpiUMMAsgB0E4aiABIAogBBDzISIBKAIQIAEoAhRBA3YgCxD3JwwvCyAHQQhqIAogBBDsIUEMahDFGyAHQThqIAEgBygCCCAHKAIMIAsQ9ycMLgsgCSgCCCIGLQAAQSRrDgMEBQYHCyAHQdAAaiIGIAogBBDoIRCdICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwsCyAHQdAAaiIGIAogBBD8IRCgICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwrCyAHQdAAaiIGIAogBBDjIRCmICAHQThqIAEgBygCYCAHKAJkQQN2IAsQ9ycgBhDkJAwqCyAHQdAAaiIJIAogBEG87s8AEOkjIAcoAlghBCAHKAJUIQYgBygCUCIKQZOAgIB4RwRAIAcgBykCXDcCXCAHIAQ2AlggByAGNgJUIAcgCjYCUCAHQThqIAkQpiUMKgsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIoeIgQoAhAgBCgCFEEDdiALEPcnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUcNKSABELsjDCkLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwpCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEI0eEJ0gIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNKCAGELsjDCgLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwoCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEIYeEKAgIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNJyAGELsjDCcLIAdB0ABqIgkgCiAEIAYQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwnCyAHIAQ2ArgBIAcgBjYCtAEgB0HQAGoiBCAHQbQBaiIGEIAeEKYgIAdBOGogASAHKAJgIAcoAmRBA3YgCxD3JyAEEOQkIAcoArQBIgEgASgCACIBQQFrNgIAIAFBAUcNJiAGELsjDCYLIAdB0ABqIgkgCiAEQbzuzwAQ6SMgBygCWCEEIAcoAlQhBiAHKAJQIgpBk4CAgHhHBEAgByAHKQJcNwJcIAcgBDYCWCAHIAY2AlQgByAKNgJQIAdBOGogCRCmJQwmCyAHIAQ2ArgBIAcgBjYCtAEgB0E4aiABIAdBtAFqIgEQih4iBCgCECAEKAIUQQN2IAsQ9ycgBygCtAEiBCAEKAIAIgRBAWs2AgAgBEEBRw0lIAEQuyMMJQsgByAENgK4ASAHIAY2ArQBIAdBOGogASAHQbQBaiIBEIoeIgQoAhAgBCgCFEEDdiALEPcnIAcoArQBIgQgBCgCACIEQQFrNgIAIARBAUcNJCABELsjDCQLIBBBCkYNAQsgB0HQAGpBPUEAQQFBARCgGCAHKAJUIQEgBygCUEEBRg0MIAcoAlgiBEGY8c8AQT38CgAAIAdBPTYCRCAHIAQ2AkAgByABNgI8IAdBATYCOAwiCyAKIAQQ9CEhBCAHQdAAaiAFQQBBBEEQEKAYIAcoAlQhCSAHKAJQQQFGDQwgB0EANgKsASAHIAcoAlg2AqgBIAcgCTYCpAEgBQRAIAVBAnQhCSAEQQxqIRAgBCgCECETA0AgByABKAIAIgo2AswBIBAQ2TwgCk0NDyATIApBAXRqLwEAIQogB0HQAGoiEUECQQBBAUEBEKAYIAcoAlQhAyAHKAJQQQFGDScgBygCWCIXIAo7AAAgB0ECNgLYASAHIBc2AtQBIAcgAzYC0AEgESAHQdABahDnFSAHKAKsASIKIAcoAqQBRgRAIAdBpAFqQaj0zwAQnigLIAFBBGohASAHKAKoASAKQQR0aiIRIAcpAlA3AgAgEUEIaiAHQdgAaikCADcCACAHIApBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMIAsgByAJQQFqNgLQASAJLQABQQFrDgIGBwULIAdBKGogCiAEKAIQEQAAIAdB0ABqIgQgBygCKCIKIAcoAiwoAgwRAAAgCkUNDCAHKQNQQsDjtd7S/qWVLIUgBykDWEL1zqio0f7azKR/hYRQRQ0MIAQgBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0NIAdBADYC2AEgByAHKAJYNgLUASAHIAQ2AtABIAUEQCAFQQJ0IQkDQCAHQSBqIAogASgCABCgGyAHKAIgIRMgB0HQAGogBygCJCIEQQBBAUEBEKAYIAcoAlQhAyAHKAJQQQFGDSUgBygCWCEQIAQEQCAQIBMgBPwKAAALIAcgBDYCvAEgByAQNgK4ASAHIAM2ArQBIAdB0ABqIAdBtAFqEOcVIAcoAtgBIgQgBygC0AFGBEAgB0HQAWpByPTPABCeKAsgAUEEaiEBIAcoAtQBIARBBHRqIhAgBykCUDcCACAQQQhqIAdB2ABqKQIANwIAIAcgBEEBajYC2AEgCUEEayIJDQALCyAHQZABaiAHQdgBaigCADYCACAHIAcpAtABNwOIAQweCyAKIAQQ5CEhCiAHQdAAaiAFQQBBBEEQEKAYIAcoAlQhBCAHKAJQQQFGDQ0gB0EANgKsASAHIAcoAlg2AqgBIAcgBDYCpAFEAAAAAAAAJEAgChDNIEH/AXEQ3iBEAAAAAAAA8D+gEOcPIS8gBQRAIAVBAnQhCSAKQQxqIRNBBCAvRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMiBGsiESAHQbABamohFyAKKAIQIRQgBEEFSSEPA0AgByABKAIAIhA2AswBIBMQ2zwgEE0NECAHIBQgEEECdGooAgAiEEEYdCAQQYD+A3FBCHRyIBBBCHZBgP4DcSAQQRh2cnI2ArABIA9FDREgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0kIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AtgBIAcgEDYC1AEgByADNgLQASAHQdAAaiAHQdABahDnFSAHKAKsASIQIAcoAqQBRgRAIAdBpAFqQfjyzwAQnigLIAFBBGohASAHKAKoASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMHQsgCiAEEOghIQogB0HQAGogBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0PIAdBADYCrAEgByAHKAJYNgKoASAHIAQ2AqQBRAAAAAAAACRAIAoQ0CBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgCkEMaiETQQggL0QAAAAAAADwP6BEAAAAAAAAwD+im/wDIgRrIhEgB0GYAWpqIRcgCigCECEUIARBCUkhDwNAIAcgASgCACIQNgKwASATENg8IBBNDRIgByAUIBBBA3RqKQMAIixCOIYgLEKA/gODQiiGhCAsQoCA/AeDQhiGICxCgICA+A+DQgiGhIQgLEIIiEKAgID4D4MgLEIYiEKAgPwHg4QgLEIoiEKA/gODICxCOIiEhIQ3A5gBIA9FDRMgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0jIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AtgBIAcgEDYC1AEgByADNgLQASAHQdAAaiAHQdABahDnFSAHKAKsASIQIAcoAqQBRgRAIAdBpAFqQajzzwAQnigLIAFBBGohASAHKAKoASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqwBIAlBBGsiCQ0ACwsgB0GQAWogB0GsAWooAgA2AgAgByAHKQKkATcDiAEMHAsgCiAEEPwhIQogB0HQAGogBUEAQQRBEBCgGCAHKAJUIQQgBygCUEEBRg0RIAdBADYCoAEgByAHKAJYNgKcASAHIAQ2ApgBRAAAAAAAACRAIAoQziBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgCkEMaiETQRAgL0QAAAAAAADwP6BEAAAAAAAAwD+im/wDIgRrIhEgB0HQAWpqIRcgCigCECEUIARBEUkhDwNAIAcgASgCACIQNgKwASATENo8IBBNDRQgByAUIBBBBHRqIhApAwAiLEI4hiAsQoD+A4NCKIaEICxCgID8B4NCGIYgLEKAgID4D4NCCIaEhCAsQgiIQoCAgPgPgyAsQhiIQoCA/AeDhCAsQiiIQoD+A4MgLEI4iISEhDcD2AEgByAQKQMIIixCOIYgLEKA/gODQiiGhCAsQoCA/AeDQhiGICxCgICA+A+DQgiGhIQgLEIIiEKAgID4D4MgLEIYiEKAgPwHg4QgLEIoiEKA/gODICxCOIiEhIQ3A9ABIA9FDRUgB0HQAGogBEEAQQFBARCgGCAHKAJUIQMgBygCUEEBRg0iIAcoAlghECAEBEAgECAXIAT8CgAACyAHIAQ2AqwBIAcgEDYCqAEgByADNgKkASAHQdAAaiAHQaQBahDnFSAHKAKgASIQIAcoApgBRgRAIAdBmAFqQdjzzwAQnigLIAFBBGohASAHKAKcASAQQQR0aiIDIAcpAlA3AgAgA0EIaiAHQdgAaikCADcCACAHIBBBAWo2AqABIAlBBGsiCQ0ACwsgB0GQAWogB0GgAWooAgA2AgAgByAHKQKYATcDiAEMGwsgB0EwaiAKIAQoAhARAAAgB0HQAGoiECAHKAIwIgQgBygCNCgCDBEAACAERQ0TIAcpA1BC47Di8bKTqs3WAIUgBykDWEKw3+Dy+LaU9Id/hYRQRQ0TIBAgBUEAQQRBEBCgGCAHKAJUIQkgBygCUEEBRg0UIAdBADYCoAEgByAHKAJYNgKcASAHIAk2ApgBRAAAAAAAACRAIAQQzyBB/wFxEN4gRAAAAAAAAPA/oBDnDyEvIAUEQCAFQQJ0IQkgBEEMaiERIBBBICAvRAAAAAAAAPA/oEQAAAAAAADAP6Kb/AMiCmsiA2ohFyAEKAIQIRQgCkEhSSEPA0AgByABKAIAIhA2ArABIBEQ3DwgEE0NFyAHIBQgEEEFdGoiECkDACIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNoIAcgECkDCCIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNgIAcgECkDECIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNYIAcgECkDGCIsQjiGICxCgP4Dg0IohoQgLEKAgPwHg0IYhiAsQoCAgPgPg0IIhoSEICxCCIhCgICA+A+DICxCGIhCgID8B4OEICxCKIhCgP4DgyAsQjiIhISENwNQIA9FDRggB0G0AWogCkEAQQFBARCgGCAHKAK4ASEQIAcoArQBQQFGDRkgBygCvAEhEyAKBEAgEyAXIAr8CgAACyAHIAo2AqwBIAcgEzYCqAEgByAQNgKkASAHQbQBaiAHQaQBahDnFSAHKAKgASIQIAcoApgBRgRAIAdBmAFqQYj0zwAQnigLIAFBBGohASAHKAKcASAQQQR0aiITIAcpArQBNwIAIBNBCGogB0G8AWopAgA3AgAgByAQQQFqNgKgASAJQQRrIgkNAAsLIAdBkAFqIAdBoAFqKAIANgIAIAcgBykCmAE3A4gBDBoLIAdBEGogCiAEKAIQEQAAIAdB0ABqIAcoAhAiCiAHKAIUKAIMEQAAIApFDRcgBykDUELJ4PqEqc+Tli+FIAcpA1hCy92l0q6Ggoz8AIWEUEUNFyAHQYgBaiERIwBB0ABrIgkkACAJQShqIAVBAEEEQRAQoBggCSgCLCEEAkACQAJAIAkoAihBAUcEQCAJQQA2AgwgCSAJKAIwNgIIIAkgBDYCBCAFBEAgBUECdCEEIApBDGohAyAKKAIQIRcDQCAJIAEoAgAiEDYCECADENs8IBBNDQMgFyAQQQJ0aigCACEUIAlBKGpBBEEAQQFBARCgGCAJKAIsIRMgCSgCKEEBRg0EIAlBGGoiEEEENgIAIAkoAjAiDyAUNgAAIAkgDzYCFCAJIBM2AhAgCUEcakEIQYjyzwAQzhggCSgCICEUIAlBEGogCSgCJCITEOUtIBMEQCAJKAIUIBAoAgBqIBQgE/wKAAALIBAgECgCACATaiIQNgIAIAlBADYCJCAJQcgAaiAQNgIAIAkgCSkCEDcDQCAJQShqIAlBQGsQ5xUgCSgCDCIQIAkoAgRGBEAgCUEEakGo8s8AEJ4oCyABQQRqIQEgCSgCCCAQQQR0aiITIAkpAig3AgAgE0EIaiAJQTBqKQIANwIAIAkgEEEBajYCDCAJQRxqEN47IARBBGsiBA0ACwsgESAJKQIENwIAIBFBCGogCUEMaigCADYCACAJQdAAaiQADAMLIAQgCSgCMEH48c8AEP0vAAsgCSAKEPw7NgIcIAlBAjYCLCAJQdDlzwA2AiggCUICNwI0IAlBOzYCTCAJQTs2AkQgCSAJQUBrNgIwIAkgCUEcajYCSCAJIAlBEGo2AkAgCUEoakHg5c8AEO8sAAsgEyAJKAIwQbDozwAQ/S8ACwwZCyAHQRhqIAogBCgCEBEAACAHQdAAaiAHKAIYIgkgBygCHCgCDBEAACAJRQ0XIAcpA1BCtaiylsSn76ZMhSAHKQNYQvfzi+bVjoHNAoWEUEUNFyAHQYgBaiETIwBBQGoiBCQAIARBFGogBUEAQQRBEBCgGCAEKAIYIQoCQAJAAkAgBCgCFEEBRwRAIARBADYCDCAEIAQoAhw2AgggBCAKNgIEIAUEQCAFQQJ0IQogCUEMaiEDIAkoAhAhFwNAIAQgASgCACIQNgIQIAMQ2DwgEE0NAyAXIBBBA3RqIhAoAgQhFCAQKAIAIQ8gBEEUaiINQQxBAEEBQQEQoBggBCgCGCERIAQoAhRBAUYNBCAEKAIcIhAgFDYACCAQIA82AAQgEEEANgAAIARBDDYCOCAEIBA2AjQgBCARNgIwIA0gBEEwahDnFSAEKAIMIhAgBCgCBEYEQCAEQQRqQcjyzwAQnigLIAFBBGohASAEKAIIIBBBBHRqIhEgBCkCFDcCACARQQhqIARBHGopAgA3AgAgBCAQQQFqNgIMIApBBGsiCg0ACwsgEyAEKQIENwIAIBNBCGogBEEMaigCADYCACAEQUBrJAAMAwsgCiAEKAIcQbjyzwAQ/S8ACyAEIAkQ/Ts2AiwgBEECNgIYIARB0OXPADYCFCAEQgI3AiAgBEE7NgI8IARBOzYCNCAEIARBMGo2AhwgBCAEQSxqNgI4IAQgBEEQajYCMCAEQRRqQeDlzwAQ7ywACyARIAQoAhxBsOjPABD9LwALDBgLIAdBAjYCVCAHQejwzwA2AlAgB0IBNwJcIAdBzAk2ArgBIAcgB0G0AWo2AlggByAHQdABajYCtAEgB0E4akEEciEEIwBBEGsiASQAIAdB0ABqIgYoAgwhCQJAAkACQAJAAkACQAJAIAYoAgQOAgABAgsgCQ0BQQEhCUEAIRMMAgsgCQ0AIAYoAgAiBigCBCETIAYoAgAhCQwBCyAEIAYQmQ4MAQsgAUEEaiATQQBBAUEBEKAYIAEoAgghBiABKAIEQQFGDQEgASgCDCEKIBMEQCAKIAkgE/wKAAALIAQgEzYCCCAEIAo2AgQgBCAGNgIACyABQRBqJAAMAQsgBiABKAIMQbDozwAQ/S8ACyAHQQE2AjgMGAsgB0HQAGohHSAGIRQgCygCJCALKAIoIhUoAghBAWtBeHFqQQhqIRYgCygCBCEiIAsoAgghHyALKAIQQQAgCygCDEGAgICAeEcbISAgCygCFCEXIAsoAhxBACALKAIYQYCAgIB4RxshHiALKAIgIQ4jAEEwayIbJAACQAJAICBBACAeG0UEQCAXIRMgIA0BIBYgFSgCJBEEACETDAELIA4gFyITRg0AIBsgEzYCACAbIA42AgQgG0ECNgIcIBtBiP7OADYCGCAbQgI3AiQgG0E7NgIUIBtBOzYCDCAbIBtBCGo2AiAgGyAbQQRqNgIQIBsgGzYCCCAdQQRqIBtBGGoQmQ4gHUEANgIADAELAn8gFCgCsAFBgICAgHhHBEAgFCgCiAIMAQsgFCgCuAILRQRAIBRCADcDKAsgFEIANwMgAkAgE0UNACAUKAKcBSgClAEhJAJAAkACQANAAkAgHkUgCSAkaiIBIBMgASATSRsiECAOT3INACAeIBBBAXRqIQQDQCAELwEARQ0BIARBAmohBCAOIBBBAWoiEEcNAAsgDiEQC0EAIQRBACEDAkAgIARAIAkgEEsNASAQIBdLDQMgICAJQQF0aiEDCyAeBEAgCSAQSw0EIA4gEEkNBSAeIAlBAXRqIQQLIBtBGGohGSAEIQEjAEFAaiISJAAgECAJayINIQwCQAJAIBQoApgFIgYuARgiBEEASgR/IANFBEAgEkEBNgIcIBJB+P/OADYCGCASQgE3AiQgEkHNATYCOCASIAQ7AT4gEiASQTRqNgIgIBIgEkE+ajYCNCASQQRyIBJBGGoQmQ4gGSASKQIMNwIMIBlBFGogEkEUaigCADYCACAZIBIpAgQ3AgQgGUEANgIADAMLQQAhDCANBEAgBEH//wNxIQYgAyEEIA0hDwNAIAwgBC8BACAGRmohDCAEQQJqIQQgD0EBayIPDQALCyAUIBQpA+ADIA0gDGutfDcD4AMgFCgC9ANBgICAgHhHBEAgFEH0A2ogAyANENchCyAUQYAFaiADIA0Q+CkgFCgCmAUFIAYLLgEaIgRBAEwEQCAUIBQoAoQEIA1qNgKEBAwBCyABBEAgDQRAIAEvAQAEQCASQQE2AhwgEkGQ/84ANgIYIBJCATcCJCASQc0BNgIEIBIgATYCACASIBI2AiAgGUEEaiASQRhqEJkOIBlBADYCAAwECyANQQF0IQMgFCgChAQhDyABIQQDQCAPIAQvAQBFaiEPIARBAmohBCADQQJrIgMNAAsgFCAPNgKEBAsgFCgC6ANBgICAgHhHBEAgFEHoA2ogASANENchCyAUQYwFaiABIA0Q+CkMAQsgEkEBNgIcIBJBwIDPADYCGCASQgE3AiQgEkHNATYCOCASIAQ7AT4gEiASQTRqNgIgIBIgEkE+ajYCNCASQQRyIBJBGGoQmQ4gGSASKQIMNwIMIBlBFGogEkEUaigCADYCACAZIBIpAgQ3AgQgGUEANgIADAELICJFBEAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQdz5zQA2AgggAEIENwIQIABBCGpB5PnNABDvLAALAkACQAJAIAwgDCARaiIBTQRAIAEgH0sNASASQRhqISUgFEGwAWohCCAiIBFBAnRqIQsjAEHwCmsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgFiAVKAIcEQQAIgEtAABBFGsODwEAAgMEBQYAAAAAAAAABwALIAMgATYC4AogA0ECNgLECiADQaj7zQA2AsAKDA4LIANB6ABqIBYgFSgCEBEAACADQcAKaiIEIAMoAmgiASADKAJsKAIMEQAAIAFFDQ4gAykDwApCkJ6z7tm0jZLpAIUgAykDyApCiPSrgeCxxeTCAIWEUEUNDiADIAE2AvwJIAgtAMQBRQ0LIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANB4ABqIANBuApqEMMpIAMoAmBBAXFFDQsgA0HYAGogA0G0CmogAygCZBCpKiADKAJcIQEgAygCWCEJIAMgAykCuAo3AsAKIANB0ABqIAQQwykCQCADKAJQQQFxRQRAIAEhBiAJIQQMAQsgAygCVCEKIAkhBCABIQYDQCADQcgAaiADQbQKaiAKEKkqIAMoAkgiDyAJIA8gCSADKAJMIgogASABIApLGxCZJyIJIAogAWsgCRtBAEgiBRshCSAKIAEgBRshASAEIA8gDyAEIAogBiAGIApLGxCZJyIEIAogBmsgBBtBAEgiDxshBCAGIAogDxshBiADQUBrIANBwApqEMMpIAMoAkQhCiADKAJAQQFxDQALCyADQcAKaiABQQBBAUEBEKAYIAMoAsQKIQogAygCwApBAUYNDyADKALICiEPIAEEQCAPIAkgAfwKAAALIAMgATYCyAogAyAPNgLECiADIAo2AsAKIANB4ApqIANBwApqIgEQ5xUgASAGQQBBAUEBEKAYIAMoAsQKIQEgAygCwApBAUYNECADKALICiEJIAYEQCAJIAQgBvwKAAALIAMgBjYCqAogAyAJNgKkCiADIAE2AqAKIANB0ApqIgEgA0GgCmoiCRDnFSADQcgKaiIKIANB6ApqIgQpAgAiLDcDACADQYgKaiAsNwMAIANBkApqIgYgASkDADcDACADQZgKaiIBIANB2ApqKQMANwMAIAMgAykC4AoiLTcDwAogAyAtNwOACiADQagKaiIPICw3AwAgAyAtNwOgCiAEIAEpAwA3AwAgAyAGKQMANwPgCiAIQaABaiEEQQEhAQJAIAgoApwBIgZBAUYEQCAEKAIARQ0BQQEhBiADKAKgCgRAIAQgCRDGKSEGCyAGQf8BcUECRiAGwEEATHINASAIKAKcASEGCyAKIA8pAwA3AwAgAyADKQOgCjcDwAoCQCAGRQ0AIAQoAgAiAUUNACAIQawBaiAIKAKkASAIKAKoASABKAIQEQEACyAIQQE2ApwBIAQgAykDwAo3AgAgBEEIaiADQcgKaikDADcCAEEAIQELIAhBtAFqIQQCQCAIKAKwASIGQQFGBEAgAygC4AohBgJAIAQoAgAEQCAGRQ0DIAQgA0HgCmoQxinAQQBIDQEgAygC4AoiBEUNAyADQewKaiADKALkCiADKALoCiAEKAIQEQEADAMLIAZFDQILIAgoArABIQYLIANByApqIgkgA0HoCmopAwA3AwAgAyADKQPgCjcDwAoCQCAGRQ0AIAQoAgAiBkUNACAIQcABaiAIKAK4ASAIKAK8ASAGKAIQEQEACyAIQQE2ArABIAQgAykDwAo3AgAgBEEIaiAJKQMANwIACyABRQ0LIAMoAqAKIgFFDQsgA0GsCmogAygCpAogAygCqAogASgCEBEBAAwLCyADQdABaiAWIBUoAhARAAAgA0HACmoiBCADKALQASIBIAMoAtQBKAIMEQAAIAFFDQ0gAykDwApCwoz39urL3NGEf4UgAykDyApC5ZP0mPmv+Oiof4WEUEUNDSADIAE2AvwJIAgtAMQBRQ0JIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANByAFqIANBuApqEMMpIAMoAsgBQQFxRQ0JIANBwAFqIANBtApqIAMoAswBEKoqIAMoAsQBIQEgAygCwAEhCSADIAMpArgKNwLACiADQbgBaiAEEMMpAkAgAygCuAFBAXFFBEAgASEGIAkhBAwBCyADKAK8ASEKIAkhBCABIQYDQCADQbABaiADQbQKaiAKEKoqIAMoArABIg8gCSAPIAkgAygCtAEiCiABIAEgCksbEJknIgkgCiABayAJG0EASCIFGyEJIAogASAFGyEBIAQgDyAPIAQgCiAGIAYgCksbEJknIgQgCiAGayAEG0EASCIPGyEEIAYgCiAPGyEGIANBqAFqIANBwApqEMMpIAMoAqwBIQogAygCqAFBAXENAAsLIANBwApqIAFBAEEBQQEQoBggAygCxAohCiADKALACkEBRg0OIAMoAsgKIQ8gAQRAIA8gCSAB/AoAAAsgAyABNgLICiADIA82AsQKIAMgCjYCwAogA0HgCmogA0HACmoiARDnFSABIAZBAEEBQQEQoBggAygCxAohASADKALACkEBRg0PIAMoAsgKIQkgBgRAIAkgBCAG/AoAAAsgAyAGNgKoCiADIAk2AqQKIAMgATYCoAogA0HQCmoiASADQaAKaiIJEOcVIANByApqIgogA0HoCmoiBCkCACIsNwMAIANBiApqICw3AwAgA0GQCmoiBiABKQMANwMAIANBmApqIgEgA0HYCmopAwA3AwAgAyADKQLgCiItNwPACiADIC03A4AKIANBqApqIg8gLDcDACADIC03A6AKIAQgASkDADcDACADIAYpAwA3A+AKIAhBoAFqIQRBASEBAkAgCCgCnAEiBkEBRgRAIAQoAgBFDQFBASEGIAMoAqAKBEAgBCAJEMYpIQYLIAZB/wFxQQJGIAbAQQBMcg0BIAgoApwBIQYLIAogDykDADcDACADIAMpA6AKNwPACgJAIAZFDQAgBCgCACIBRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAEoAhARAQALIAhBATYCnAEgBCADKQPACjcCACAEQQhqIANByApqKQMANwIAQQAhAQsgCEG0AWohBAJAIAgoArABIgZBAUYEQCADKALgCiEGAkAgBCgCAARAIAZFDQMgBCADQeAKahDGKcBBAEgNASADKALgCiIERQ0DIANB7ApqIAMoAuQKIAMoAugKIAQoAhARAQAMAwsgBkUNAgsgCCgCsAEhBgsgA0HICmoiCSADQegKaikDADcDACADIAMpA+AKNwPACgJAIAZFDQAgBCgCACIGRQ0AIAhBwAFqIAgoArgBIAgoArwBIAYoAhARAQALIAhBATYCsAEgBCADKQPACjcCACAEQQhqIAkpAwA3AgALIAFFDQkgAygCoAoiAUUNCSADQawKaiADKAKkCiADKAKoCiABKAIQEQEADAkLIANBuAJqIBYgFSgCEBEAACADQcAKaiIEIAMoArgCIgEgAygCvAIoAgwRAAAgAUUNDCADKQPACkKv85DYlJzH+zOFIAMpA8gKQqClxfTN0NGkjX+FhFBFDQwgAyABNgL8CSAILQDEAUUNByADIAE2ArQKIAMgCzYCuAogAyALIAxBAnRqNgK8CiADQbACaiADQbgKahDDKSADKAKwAkEBcUUNByADQagCaiADQbQKaiADKAK0AhClKiADKAKsAiEBIAMoAqgCIQkgAyADKQK4CjcCwAogA0GgAmogBBDDKQJAIAMoAqACQQFxRQRAIAEhBiAJIQQMAQsgAygCpAIhCiAJIQQgASEGA0AgA0GYAmogA0G0CmogChClKiADKAKYAiIPIAkgDyAJIAMoApwCIgogASABIApLGxCZJyIJIAogAWsgCRtBAEgiBRshCSAKIAEgBRshASAEIA8gDyAEIAogBiAGIApLGxCZJyIEIAogBmsgBBtBAEgiDxshBCAGIAogDxshBiADQZACaiADQcAKahDDKSADKAKUAiEKIAMoApACQQFxDQALCyADQcAKaiABQQBBAUEBEKAYIAMoAsQKIQogAygCwApBAUYNDSADKALICiEPIAEEQCAPIAkgAfwKAAALIAMgATYCyAogAyAPNgLECiADIAo2AsAKIANB4ApqIANBwApqIgEQ5xUgASAGQQBBAUEBEKAYIAMoAsQKIQEgAygCwApBAUYNDiADKALICiEJIAYEQCAJIAQgBvwKAAALIAMgBjYCqAogAyAJNgKkCiADIAE2AqAKIANB0ApqIgEgA0GgCmoiCRDnFSADQcgKaiIKIANB6ApqIgQpAgAiLDcDACADQYgKaiAsNwMAIANBkApqIgYgASkDADcDACADQZgKaiIBIANB2ApqKQMANwMAIAMgAykC4AoiLTcDwAogAyAtNwOACiADQagKaiIPICw3AwAgAyAtNwOgCiAEIAEpAwA3AwAgAyAGKQMANwPgCiAIQaABaiEEQQEhAQJAIAgoApwBIgZBAUYEQCAEKAIARQ0BQQEhBiADKAKgCgRAIAQgCRDGKSEGCyAGQf8BcUECRiAGwEEATHINASAIKAKcASEGCyAKIA8pAwA3AwAgAyADKQOgCjcDwAoCQCAGRQ0AIAQoAgAiAUUNACAIQawBaiAIKAKkASAIKAKoASABKAIQEQEACyAIQQE2ApwBIAQgAykDwAo3AgAgBEEIaiADQcgKaikDADcCAEEAIQELIAhBtAFqIQQCQCAIKAKwASIGQQFGBEAgAygC4AohBgJAIAQoAgAEQCAGRQ0DIAQgA0HgCmoQxinAQQBIDQEgAygC4AoiBEUNAyADQewKaiADKALkCiADKALoCiAEKAIQEQEADAMLIAZFDQILIAgoArABIQYLIANByApqIgkgA0HoCmopAwA3AwAgAyADKQPgCjcDwAoCQCAGRQ0AIAQoAgAiBkUNACAIQcABaiAIKAK4ASAIKAK8ASAGKAIQEQEACyAIQQE2ArABIAQgAykDwAo3AgAgBEEIaiAJKQMANwIACyABRQ0HIAMoAqAKIgFFDQcgA0GsCmogAygCpAogAygCqAogASgCEBEBAAwHCyADQaADaiAWIBUoAhARAAAgA0HACmoiBCADKAKgAyIBIAMoAqQDKAIMEQAAIAFFDQsgAykDwApCx9n0597Etpx3hSADKQPICkKNss6UjMqS5qd/hYRQRQ0LIAMgATYC/AkgCC0AxAFFDQUgAyABNgK0CiADIAs2ArgKIAMgCyAMQQJ0ajYCvAogA0GYA2ogA0G4CmoQwykgAygCmANBAXFFDQUgA0GQA2ogA0G0CmogAygCnAMQqCogAygClAMhASADKAKQAyEJIAMgAykCuAo3AsAKIANBiANqIAQQwykCQCADKAKIA0EBcUUEQCABIQYgCSEEDAELIAMoAowDIQogCSEEIAEhBgNAIANBgANqIANBtApqIAoQqCogAygCgAMiDyAJIA8gCSADKAKEAyIKIAEgASAKSxsQmSciCSAKIAFrIAkbQQBIIgUbIQkgCiABIAUbIQEgBCAPIA8gBCAKIAYgBiAKSxsQmSciBCAKIAZrIAQbQQBIIg8bIQQgBiAKIA8bIQYgA0H4AmogA0HACmoQwykgAygC/AIhCiADKAL4AkEBcQ0ACwsgA0HACmogAUEAQQFBARCgGCADKALECiEKIAMoAsAKQQFGDQwgAygCyAohDyABBEAgDyAJIAH8CgAACyADIAE2AsgKIAMgDzYCxAogAyAKNgLACiADQeAKaiADQcAKaiIBEOcVIAEgBkEAQQFBARCgGCADKALECiEBIAMoAsAKQQFGDQ0gAygCyAohCSAGBEAgCSAEIAb8CgAACyADIAY2AqgKIAMgCTYCpAogAyABNgKgCiADQdAKaiIBIANBoApqIgkQ5xUgA0HICmoiCiADQegKaiIEKQIAIiw3AwAgA0GICmogLDcDACADQZAKaiIGIAEpAwA3AwAgA0GYCmoiASADQdgKaikDADcDACADIAMpAuAKIi03A8AKIAMgLTcDgAogA0GoCmoiDyAsNwMAIAMgLTcDoAogBCABKQMANwMAIAMgBikDADcD4AogCEGgAWohBEEBIQECQCAIKAKcASIGQQFGBEAgBCgCAEUNAUEBIQYgAygCoAoEQCAEIAkQxikhBgsgBkH/AXFBAkYgBsBBAExyDQEgCCgCnAEhBgsgCiAPKQMANwMAIAMgAykDoAo3A8AKAkAgBkUNACAEKAIAIgFFDQAgCEGsAWogCCgCpAEgCCgCqAEgASgCEBEBAAsgCEEBNgKcASAEIAMpA8AKNwIAIARBCGogA0HICmopAwA3AgBBACEBCyAIQbQBaiEEAkAgCCgCsAEiBkEBRgRAIAMoAuAKIQYCQCAEKAIABEAgBkUNAyAEIANB4ApqEMYpwEEASA0BIAMoAuAKIgRFDQMgA0HsCmogAygC5AogAygC6AogBCgCEBEBAAwDCyAGRQ0CCyAIKAKwASEGCyADQcgKaiIJIANB6ApqKQMANwMAIAMgAykD4Ao3A8AKAkAgBkUNACAEKAIAIgZFDQAgCEHAAWogCCgCuAEgCCgCvAEgBigCEBEBAAsgCEEBNgKwASAEIAMpA8AKNwIAIARBCGogCSkDADcCAAsgAUUNBSADKAKgCiIBRQ0FIANBrApqIAMoAqQKIAMoAqgKIAEoAhARAQAMBQsgA0GIBGogFiAVKAIQEQAAIANBwApqIgQgAygCiAQiASADKAKMBCgCDBEAACABRQ0KIAMpA8AKQtPY0/j95vaSSIUgAykDyApCotieiOGg6unMAIWEUEUNCiADIAE2AvwJIAgtAMQBRQ0DIAMgATYCtAogAyALNgK4CiADIAsgDEECdGo2ArwKIANBgARqIANBuApqEMMpIAMoAoAEQQFxRQ0DIANB+ANqIANBtApqIAMoAoQEEKsqIAMoAvwDIQEgAygC+AMhCSADIAMpArgKNwLACiADQfADaiAEEMMpAkAgAygC8ANBAXFFBEAgASEGIAkhBAwBCyADKAL0AyEKIAkhBCABIQYDQCADQegDaiADQbQKaiAKEKsqIAMoAugDIg8gCSAPIAkgAygC7AMiCiABIAEgCksbEJknIgkgCiABayAJG0EASCIFGyEJIAogASAFGyEBIAQgDyAPIAQgCiAGIAYgCksbEJknIgQgCiAGayAEG0EASCIPGyEEIAYgCiAPGyEGIANB4ANqIANBwApqEMMpIAMoAuQDIQogAygC4ANBAXENAAsLIANBwApqIAFBAEEBQQEQoBggAygCxAohCiADKALACkEBRg0LIAMoAsgKIQ8gAQRAIA8gCSAB/AoAAAsgAyABNgLICiADIA82AsQKIAMgCjYCwAogA0HgCmogA0HACmoiARDnFSABIAZBAEEBQQEQoBggAygCxAohASADKALACkEBRg0MIAMoAsgKIQkgBgRAIAkgBCAG/AoAAAsgAyAGNgKoCiADIAk2AqQKIAMgATYCoAogA0HQCmoiASADQaAKaiIJEOcVIANByApqIgogA0HoCmoiBCkCACIsNwMAIANBiApqICw3AwAgA0GQCmoiBiABKQMANwMAIANBmApqIgEgA0HYCmopAwA3AwAgAyADKQLgCiItNwPACiADIC03A4AKIANBqApqIg8gLDcDACADIC03A6AKIAQgASkDADcDACADIAYpAwA3A+AKIAhBoAFqIQRBASEBAkAgCCgCnAEiBkEBRgRAIAQoAgBFDQFBASEGIAMoAqAKBEAgBCAJEMYpIQYLIAZB/wFxQQJGIAbAQQBMcg0BIAgoApwBIQYLIAogDykDADcDACADIAMpA6AKNwPACgJAIAZFDQAgBCgCACIBRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAEoAhARAQALIAhBATYCnAEgBCADKQPACjcCACAEQQhqIANByApqKQMANwIAQQAhAQsgCEG0AWohBAJAIAgoArABIgZBAUYEQCADKALgCiEGAkAgBCgCAARAIAZFDQMgBCADQeAKahDGKcBBAEgNASADKALgCiIERQ0DIANB7ApqIAMoAuQKIAMoAugKIAQoAhARAQAMAwsgBkUNAgsgCCgCsAEhBgsgA0HICmoiCSADQegKaikDADcDACADIAMpA+AKNwPACgJAIAZFDQAgBCgCACIGRQ0AIAhBwAFqIAgoArgBIAgoArwBIAYoAhARAQALIAhBATYCsAEgBCADKQPACjcCACAEQQhqIAkpAwA3AgALIAFFDQMgAygCoAoiAUUNAyADQawKaiADKAKkCiADKAKoCiABKAIQEQEADAMLIANB8ARqIBYgFSgCEBEAACADQcAKaiIEIAMoAvAEIgEgAygC9AQoAgwRAAAgAUUNCSADKQPACkKrmJHxlfrV/IB/hSADKQPICkKWlPir8LHps+EAhYRQRQ0JIAMgATYC/AkgCC0AxAFFDQEgAyABNgK0CiADIAs2ArgKIAMgCyAMQQJ0ajYCvAogA0HoBGogA0G4CmoQwykgAygC6ARBAXFFDQEgA0HgBGogA0G0CmogAygC7AQQpCogAygC5AQhASADKALgBCEJIAMgAykCuAo3AsAKIANB2ARqIAQQwykCQCADKALYBEEBcUUEQCABIQYgCSEEDAELIAMoAtwEIQogCSEEIAEhBgNAIANB0ARqIANBtApqIAoQpCogAygC0AQiDyAJIA8gCSADKALUBCIKIAEgASAKSxsQmSciCSAKIAFrIAkbQQBIIgUbIQkgCiABIAUbIQEgBCAPIA8gBCAKIAYgBiAKSxsQmSciBCAKIAZrIAQbQQBIIg8bIQQgBiAKIA8bIQYgA0HIBGogA0HACmoQwykgAygCzAQhCiADKALIBEEBcQ0ACwsgA0HACmogAUEAQQFBARCgGCADKALECiEKIAMoAsAKQQFGDQogAygCyAohDyABBEAgDyAJIAH8CgAACyADIAE2AsgKIAMgDzYCxAogAyAKNgLACiADQeAKaiADQcAKaiIBEOcVIAEgBkEAQQFBARCgGCADKALECiEBIAMoAsAKQQFGDQsgAygCyAohCSAGBEAgCSAEIAb8CgAACyADIAY2AqgKIAMgCTYCpAogAyABNgKgCiADQdAKaiIBIANBoApqIgkQ5xUgA0HICmoiCiADQegKaiIEKQIAIiw3AwAgA0GICmogLDcDACADQZAKaiIGIAEpAwA3AwAgA0GYCmoiASADQdgKaikDADcDACADIAMpAuAKIi03A8AKIAMgLTcDgAogA0GoCmoiDyAsNwMAIAMgLTcDoAogBCABKQMANwMAIAMgBikDADcD4AogCEGgAWohBEEBIQECQCAIKAKcASIGQQFGBEAgBCgCAEUNAUEBIQYgAygCoAoEQCAEIAkQxikhBgsgBkH/AXFBAkYgBsBBAExyDQEgCCgCnAEhBgsgCiAPKQMANwMAIAMgAykDoAo3A8AKAkAgBkUNACAEKAIAIgFFDQAgCEGsAWogCCgCpAEgCCgCqAEgASgCEBEBAAsgCEEBNgKcASAEIAMpA8AKNwIAIARBCGogA0HICmopAwA3AgBBACEBCyAIQbQBaiEEAkAgCCgCsAEiBkEBRgRAIAMoAuAKIQYCQCAEKAIABEAgBkUNAyAEIANB4ApqEMYpwEEASA0BIAMoAuAKIgRFDQMgA0HsCmogAygC5AogAygC6AogBCgCEBEBAAwDCyAGRQ0CCyAIKAKwASEGCyADQcgKaiIJIANB6ApqKQMANwMAIAMgAykD4Ao3A8AKAkAgBkUNACAEKAIAIgZFDQAgCEHAAWogCCgCuAEgCCgCvAEgBigCEBEBAAsgCEEBNgKwASAEIAMpA8AKNwIAIARBCGogCSkDADcCAAsgAUUNASADKAKgCiIBRQ0BIANBrApqIAMoAqQKIAMoAqgKIAEoAhARAQAMAQsCQAJAAkACQAJAAkAgASgCCCIELQAAQRRrDgYEAwIFAQAFCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcYCyADQYAJaiAWIBUoAhARAAAgA0HACmogAygCgAkiASADKAKECSgCDBEAACABRQ0UIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRQgA0H4CGogARDWISADKAL4CCIBRQ0UIAEgAygC/AggCyAMIAgQ/QEMEgsgA0GQCWogFiAVKAIQEQAAIANBwApqIAMoApAJIgEgAygClAkoAgwRAAAgAUUNEyADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNEyADQYgJaiABENYhIAMoAogJIgFFDRMgASADKAKMCSALIAwgCBD+AQwRCyADQaAJaiAWIBUoAhARAAAgA0HACmogAygCoAkiASADKAKkCSgCDBEAACABRQ0SIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNEiADQZgJaiABENYhIAMoApgJIgFFDRIgASADKAKcCSALIAwgCBD/AQwQCyADQbAJaiAWIBUoAhARAAAgA0HACmogAygCsAkiASADKAK0CSgCDBEAACABRQ0RIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNESADQagJaiABENYhIAMoAqgJIgFFDREgASADKAKsCSALIAwgCBCAAgwPCyADQcAJaiAWIBUoAhARAAAgA0HACmogAygCwAkiASADKALECSgCDBEAACABRQ0QIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNECADQbgJaiABENYhIAMoArgJIgFFDRAgASADKAK8CSALIAwgCBCBAgwOCyADQdAJaiAWIBUoAhARAAAgA0HACmogAygC0AkiASADKALUCSgCDBEAACABRQ0PIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0PIANByAlqIAEQ1iEgAygCyAkiAUUNDyABIAMoAswJIAsgDCAIEIICDA0LIANB4AlqIBYgFSgCEBEAACADQcAKaiADKALgCSIBIAMoAuQJKAIMEQAAIAFFDQ4gAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0OIANB2AlqIAEQ1iEgAygC2AkiAUUNDiABIAMoAtwJIAsgDCAIEP8BDAwLIANB8AlqIBYgFSgCEBEAACADQcAKaiADKALwCSIBIAMoAvQJKAIMEQAAIAFFDQ0gAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQ0gA0HoCWogARDWISADKALoCSIBBEAgASADKALsCSALIAwgCBCAAgwMCwwNCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcXCyADQYAIaiAWIBUoAhARAAAgA0HACmogAygCgAgiASADKAKECCgCDBEAACABRQ0TIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRMgA0H4B2ogARDhISADKAL4ByIBRQ0TIAEgAygC/AcgCyAMIAgQgwIMEQsgA0GQCGogFiAVKAIQEQAAIANBwApqIAMoApAIIgEgAygClAgoAgwRAAAgAUUNEiADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNEiADQYgIaiABEOEhIAMoAogIIgFFDRIgASADKAKMCCALIAwgCBCEAgwQCyADQaAIaiAWIBUoAhARAAAgA0HACmogAygCoAgiASADKAKkCCgCDBEAACABRQ0RIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNESADQZgIaiABEOEhIAMoApgIIgFFDREgASADKAKcCCALIAwgCBCFAgwPCyADQbAIaiAWIBUoAhARAAAgA0HACmogAygCsAgiASADKAK0CCgCDBEAACABRQ0QIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNECADQagIaiABEOEhIAMoAqgIIgFFDRAgASADKAKsCCALIAwgCBCGAgwOCyADQcAIaiAWIBUoAhARAAAgA0HACmogAygCwAgiASADKALECCgCDBEAACABRQ0PIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDyADQbgIaiABEOEhIAMoArgIIgFFDQ8gASADKAK8CCALIAwgCBCHAgwNCyADQdAIaiAWIBUoAhARAAAgA0HACmogAygC0AgiASADKALUCCgCDBEAACABRQ0OIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0OIANByAhqIAEQ4SEgAygCyAgiAUUNDiABIAMoAswIIAsgDCAIEIgCDAwLIANB4AhqIBYgFSgCEBEAACADQcAKaiADKALgCCIBIAMoAuQIKAIMEQAAIAFFDQ0gAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0NIANB2AhqIAEQ4SEgAygC2AgiAUUNDSABIAMoAtwIIAsgDCAIEIUCDAsLIANB8AhqIBYgFSgCEBEAACADQcAKaiADKALwCCIBIAMoAvQIKAIMEQAAIAFFDQwgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQwgA0HoCGogARDhISADKALoCCIBBEAgASADKALsCCALIAwgCBCGAgwLCwwMCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcWCyADQYAHaiAWIBUoAhARAAAgA0HACmogAygCgAciASADKAKEBygCDBEAACABRQ0SIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRIgA0H4BmogARDVISADKAL4BiIBRQ0SIAEgAygC/AYgCyAMIAgQ/QEMEAsgA0GQB2ogFiAVKAIQEQAAIANBwApqIAMoApAHIgEgAygClAcoAgwRAAAgAUUNESADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNESADQYgHaiABENUhIAMoAogHIgFFDREgASADKAKMByALIAwgCBD+AQwPCyADQaAHaiAWIBUoAhARAAAgA0HACmogAygCoAciASADKAKkBygCDBEAACABRQ0QIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNECADQZgHaiABENUhIAMoApgHIgFFDRAgASADKAKcByALIAwgCBD/AQwOCyADQbAHaiAWIBUoAhARAAAgA0HACmogAygCsAciASADKAK0BygCDBEAACABRQ0PIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDyADQagHaiABENUhIAMoAqgHIgFFDQ8gASADKAKsByALIAwgCBCAAgwNCyADQcAHaiAWIBUoAhARAAAgA0HACmogAygCwAciASADKALEBygCDBEAACABRQ0OIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDiADQbgHaiABENUhIAMoArgHIgFFDQ4gASADKAK8ByALIAwgCBCBAgwMCyADQdAHaiAWIBUoAhARAAAgA0HACmogAygC0AciASADKALUBygCDBEAACABRQ0NIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0NIANByAdqIAEQ1SEgAygCyAciAUUNDSABIAMoAswHIAsgDCAIEIICDAsLIANB4AdqIBYgFSgCEBEAACADQcAKaiADKALgByIBIAMoAuQHKAIMEQAAIAFFDQwgAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0MIANB2AdqIAEQ1SEgAygC2AciAUUNDCABIAMoAtwHIAsgDCAIEP8BDAoLIANB8AdqIBYgFSgCEBEAACADQcAKaiADKALwByIBIAMoAvQHKAIMEQAAIAFFDQsgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQsgA0HoB2ogARDVISADKALoByIBBEAgASADKALsByALIAwgCBCAAgwKCwwLCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcVCyADQYAGaiAWIBUoAhARAAAgA0HACmogAygCgAYiASADKAKEBigCDBEAACABRQ0RIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDREgA0H4BWogARDUISADKAL4BSIBRQ0RIAMoAvwFIQYgCyEEIwBB4AFrIgUkACAFIAY2AmwgBSABNgJoAkAgCC0AxAFFDQAgBSAGNgKkASAFIAE2AqABIAUgBDYCqAEgBSAEIAxBAnRqNgKsASAFQeAAaiAFQagBahDDKSAFKAJgQQFxRQ0AIAVB2ABqIAVBoAFqIAUoAmQQ/hkgBSgCXCEKIAUoAlghASAFIAUpAqgBNwKwASAFQdAAaiAFQbABahDDKQJAIAUoAlBBAXFFBEAgCiELIAEhBgwBCyAFKAJUIQkgASEGIAohCwNAIAVByABqIAVBoAFqIAkQ/hkgBSgCSCIPIAEgDyABIAUoAkwiCSAKIAkgCkkbEJknIgEgCSAKayABG0EASCIYGyEBIAkgCiAYGyEKIAYgDyAPIAYgCSALIAkgC0kbEJknIgYgCSALayAGG0EASCIPGyEGIAsgCSAPGyELIAVBQGsgBUGwAWoQwykgBSgCRCEJIAUoAkBBAXENAAsLIAVBsAFqIApBAEEBQQEQoBggBSgCtAEhDwJAIAUoArABQQFHBEAgBSgCuAEhCSAKBEAgCSABIAr8CgAACyAFIAo2ArgBIAUgCTYCtAEgBSAPNgKwASAFQdABaiAFQbABaiIBEOcVIAEgC0EAQQFBARCgGCAFKAK0ASEKIAUoArABQQFGDQEgBSgCuAEhASALBEAgASAGIAv8CgAACyAFIAs2ApgBIAUgATYClAEgBSAKNgKQASAFQcABaiIBIAVBkAFqIgYQ5xUgBUG4AWoiCSAFQdgBaiIKKQIAIiw3AwAgBUH4AGogLDcDACAFQYABaiILIAEpAwA3AwAgBUGIAWoiASAFQcgBaikDADcDACAFIAUpAtABIi03A7ABIAUgLTcDcCAFQZgBaiIPICw3AwAgBSAtNwOQASAKIAEpAwA3AwAgBSALKQMANwPQASAIQaABaiEBQQEhCgJAIAgoApwBIgtBAUYEQCABKAIARQ0BQQEhCyAFKAKQAQRAIAEgBhDGKSELCyALQf8BcUECRiALwEEATHINASAIKAKcASELCyAJIA8pAwA3AwAgBSAFKQOQATcDsAECQCALRQ0AIAEoAgAiBkUNACAIQawBaiAIKAKkASAIKAKoASAGKAIQEQEACyAIQQE2ApwBIAEgBSkDsAE3AgAgAUEIaiAFQbgBaikDADcCAEEAIQoLIAhBtAFqIQECQCAIKAKwASILQQFGBEAgBSgC0AEhBgJAIAEoAgAEQCAGRQ0DIAEgBUHQAWoQxinAQQBIDQEgBSgC0AEiAUUNAyAFQdwBaiAFKALUASAFKALYASABKAIQEQEADAMLIAZFDQILIAgoArABIQsLIAVBuAFqIgYgBUHYAWopAwA3AwAgBSAFKQPQATcDsAECQCALRQ0AIAEoAgAiCUUNACAIQcABaiAIKAK4ASAIKAK8ASAJKAIQEQEACyAIQQE2ArABIAEgBSkDsAE3AgAgAUEIaiAGKQMANwIACyAKRQ0CIAUoApABIgFFDQIgBUGcAWogBSgClAEgBSgCmAEgASgCEBEBAAwCCwwbCwwbCwJAIAgoApABQYCAgIB4Rg0AIAUgBDYCsAEgBSAEIAxBAnRqNgK0ASAFQThqIAVBsAFqEMMpIAUoAjhBAXFFDQAgCEGQAWohASAFKAI8IQkDQCAFQTBqIAVB6ABqIAkQ/hkgASAFKAIwIAUoAjQQhgoQohUgBUEoaiAFQbABahDDKSAFKAIsIQkgBSgCKEEBcQ0ACwsCQCAIKAIAQYCAgIB4RwRAIAUgBSkCaDcCsAEgCEHQAGoiBiAMEOwtIAxFDQEgDEECdCEKA0AgBUEgaiAFQbABaiAEKAIAEP4ZIAggBSgCICAFKAIkIgkQ9RshLCAIKAJYIgEgCCgCUEYEQCAGQfD4zQAQsygLIARBBGohBCAIKAJUIAFBA3RqICw3AwAgCCABQQFqNgJYIAggCCkDSCAJrXw3A0ggCkEEayIKDQALDAELIAUpAmghLCAIIAgoAogBIAxqNgKIASAFICw3AtABAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0CIAhB5ABqIQEgDEECdCELA0AgBUEIaiAFQdABaiAEKAIAEP4ZIAUoAgghCSAFIAUoAgwiBjYCsAEgASAFQbABakEEEKE2IAEgCSAGEKE2IAggCCkDgAEgBq18NwOAASAEQQRqIQQgC0EEayILDQALDAILIAxFDQEgCEHkAGohBiAMQQJ0IQoDQCAFQRBqIAVB0AFqIAQoAgAQ/hkgBSgCECEJIAgoAnAhCyAFIAUoAhQiATYCkAEgBUHwAGogCyAFQZABakEBEM8RIAUoAnBBCEcNHiAGIAkgARChNiAIIAgpA4ABIAGtfDcDgAEgBEEEaiEEIApBBGsiCg0ACwwBCyAMRQ0AIAhB4ABqIQsgBCAMQQJ0aiEPIAhB7ABqIRgDQCAFQRhqIAVB0AFqIAQoAgAQ/hkgBSgCGCEGQQAhCQJAIAgoAnQiASAFKAIcIgogASAKSRsiAUUNACAIKAJwIRwDQCAJIBxqLQAAIAYgCWotAABHDQEgASAJQQFqIglHDQALIAEhCQsgCEEANgJ0IBggBiAKEKE2IAkgCksNHiALIAYgCWogCiAJayIBEKE2IAgoAnghBiAFIAk2ApABIAVB8ABqIgkgBiAFQZABaiIGQQEQzxEgBSgCcEEIRw0fIAgoAnwhHCAFIAE2ApABIAkgHCAGQQEQzxEgBSgCcEEIRw0gIAggCCkDgAEgCq18NwOAASAEQQRqIgQgD0cNAAsLIAVB4AFqJAAMDwsgA0GQBmogFiAVKAIQEQAAIANBwApqIAMoApAGIgEgAygClAYoAgwRAAAgAUUNECADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNECADQYgGaiABENQhIAMoAogGIgFFDRAgAygCjAYhBiALIQQjAEHgAWsiBSQAIAUgBjYCbCAFIAE2AmgCQCAILQDEAUUNACAFIAY2AqQBIAUgATYCoAEgBSAENgKoASAFIAQgDEECdGo2AqwBIAVB4ABqIAVBqAFqEMMpIAUoAmBBAXFFDQAgBUHYAGogBUGgAWogBSgCZBDzGSAFKAJcIQogBSgCWCEBIAUgBSkCqAE3ArABIAVB0ABqIAVBsAFqEMMpAkAgBSgCUEEBcUUEQCAKIQsgASEGDAELIAUoAlQhCSABIQYgCiELA0AgBUHIAGogBUGgAWogCRDzGSAFKAJIIg8gASAPIAEgBSgCTCIJIAogCSAKSRsQmSciASAJIAprIAEbQQBIIhgbIQEgCSAKIBgbIQogBiAPIA8gBiAJIAsgCSALSRsQmSciBiAJIAtrIAYbQQBIIg8bIQYgCyAJIA8bIQsgBUFAayAFQbABahDDKSAFKAJEIQkgBSgCQEEBcQ0ACwsgBUGwAWogCkEAQQFBARCgGCAFKAK0ASEPAkAgBSgCsAFBAUcEQCAFKAK4ASEJIAoEQCAJIAEgCvwKAAALIAUgCjYCuAEgBSAJNgK0ASAFIA82ArABIAVB0AFqIAVBsAFqIgEQ5xUgASALQQBBAUEBEKAYIAUoArQBIQogBSgCsAFBAUYNASAFKAK4ASEBIAsEQCABIAYgC/wKAAALIAUgCzYCmAEgBSABNgKUASAFIAo2ApABIAVBwAFqIgEgBUGQAWoiBhDnFSAFQbgBaiIJIAVB2AFqIgopAgAiLDcDACAFQfgAaiAsNwMAIAVBgAFqIgsgASkDADcDACAFQYgBaiIBIAVByAFqKQMANwMAIAUgBSkC0AEiLTcDsAEgBSAtNwNwIAVBmAFqIg8gLDcDACAFIC03A5ABIAogASkDADcDACAFIAspAwA3A9ABIAhBoAFqIQFBASEKAkAgCCgCnAEiC0EBRgRAIAEoAgBFDQFBASELIAUoApABBEAgASAGEMYpIQsLIAtB/wFxQQJGIAvAQQBMcg0BIAgoApwBIQsLIAkgDykDADcDACAFIAUpA5ABNwOwAQJAIAtFDQAgASgCACIGRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAYoAhARAQALIAhBATYCnAEgASAFKQOwATcCACABQQhqIAVBuAFqKQMANwIAQQAhCgsgCEG0AWohAQJAIAgoArABIgtBAUYEQCAFKALQASEGAkAgASgCAARAIAZFDQMgASAFQdABahDGKcBBAEgNASAFKALQASIBRQ0DIAVB3AFqIAUoAtQBIAUoAtgBIAEoAhARAQAMAwsgBkUNAgsgCCgCsAEhCwsgBUG4AWoiBiAFQdgBaikDADcDACAFIAUpA9ABNwOwAQJAIAtFDQAgASgCACIJRQ0AIAhBwAFqIAgoArgBIAgoArwBIAkoAhARAQALIAhBATYCsAEgASAFKQOwATcCACABQQhqIAYpAwA3AgALIApFDQIgBSgCkAEiAUUNAiAFQZwBaiAFKAKUASAFKAKYASABKAIQEQEADAILDBoLDBoLAkAgCCgCkAFBgICAgHhGDQAgBSAENgKwASAFIAQgDEECdGo2ArQBIAVBOGogBUGwAWoQwykgBSgCOEEBcUUNACAIQZABaiEBIAUoAjwhCQNAIAVBMGogBUHoAGogCRDzGSABIAUoAjAgBSgCNBCGChCiFSAFQShqIAVBsAFqEMMpIAUoAiwhCSAFKAIoQQFxDQALCwJAIAgoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAIQdAAaiIGIAwQ7C0gDEUNASAMQQJ0IQoDQCAFQSBqIAVBsAFqIAQoAgAQ8xkgCCAFKAIgIAUoAiQiCRD1GyEsIAgoAlgiASAIKAJQRgRAIAZB8PjNABCzKAsgBEEEaiEEIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAmtfDcDSCAKQQRrIgoNAAsMAQsgBSkCaCEsIAggCCgCiAEgDGo2AogBIAUgLDcC0AECQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQsDQCAFQQhqIAVB0AFqIAQoAgAQ8xkgBSgCCCEJIAUgBSgCDCIGNgKwASABIAVBsAFqQQQQoTYgASAJIAYQoTYgCCAIKQOAASAGrXw3A4ABIARBBGohBCALQQRrIgsNAAsMAgsgDEUNASAIQeQAaiEGIAxBAnQhCgNAIAVBEGogBUHQAWogBCgCABDzGSAFKAIQIQkgCCgCcCELIAUgBSgCFCIBNgKQASAFQfAAaiALIAVBkAFqQQEQzxEgBSgCcEEIRw0dIAYgCSABEKE2IAggCCkDgAEgAa18NwOAASAEQQRqIQQgCkEEayIKDQALDAELIAxFDQAgCEHgAGohCyAEIAxBAnRqIQ8gCEHsAGohGANAIAVBGGogBUHQAWogBCgCABDzGSAFKAIYIQZBACEJAkAgCCgCdCIBIAUoAhwiCiABIApJGyIBRQ0AIAgoAnAhHANAIAkgHGotAAAgBiAJai0AAEcNASABIAlBAWoiCUcNAAsgASEJCyAIQQA2AnQgGCAGIAoQoTYgCSAKSw0dIAsgBiAJaiAKIAlrIgEQoTYgCCgCeCEGIAUgCTYCkAEgBUHwAGoiCSAGIAVBkAFqIgZBARDPESAFKAJwQQhHDR4gCCgCfCEcIAUgATYCkAEgCSAcIAZBARDPESAFKAJwQQhHDR8gCCAIKQOAASAKrXw3A4ABIARBBGoiBCAPRw0ACwsgBUHgAWokAAwOCyADQaAGaiAWIBUoAhARAAAgA0HACmogAygCoAYiASADKAKkBigCDBEAACABRQ0PIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNDyADQZgGaiABENQhIAMoApgGIgFFDQ8gASADKAKcBiALIAwgCBCJAgwNCyADQbAGaiAWIBUoAhARAAAgA0HACmogAygCsAYiASADKAK0BigCDBEAACABRQ0OIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDiADQagGaiABENQhIAMoAqgGIgFFDQ4gASADKAKsBiALIAwgCBCKAgwMCyADQcAGaiAWIBUoAhARAAAgA0HACmogAygCwAYiASADKALEBigCDBEAACABRQ0NIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDSADQbgGaiABENQhIAMoArgGIgFFDQ0gAygCvAYhBiALIQQjAEHgAWsiBSQAIAUgBjYCbCAFIAE2AmgCQCAILQDEAUUNACAFIAY2AqQBIAUgATYCoAEgBSAENgKoASAFIAQgDEECdGo2AqwBIAVB4ABqIAVBqAFqEMMpIAUoAmBBAXFFDQAgBUHYAGogBUGgAWogBSgCZBD9GSAFKAJcIQogBSgCWCEBIAUgBSkCqAE3ArABIAVB0ABqIAVBsAFqEMMpAkAgBSgCUEEBcUUEQCAKIQsgASEGDAELIAUoAlQhCSABIQYgCiELA0AgBUHIAGogBUGgAWogCRD9GSAFKAJIIg8gASAPIAEgBSgCTCIJIAogCSAKSRsQmSciASAJIAprIAEbQQBIIhgbIQEgCSAKIBgbIQogBiAPIA8gBiAJIAsgCSALSRsQmSciBiAJIAtrIAYbQQBIIg8bIQYgCyAJIA8bIQsgBUFAayAFQbABahDDKSAFKAJEIQkgBSgCQEEBcQ0ACwsgBUGwAWogCkEAQQFBARCgGCAFKAK0ASEPAkAgBSgCsAFBAUcEQCAFKAK4ASEJIAoEQCAJIAEgCvwKAAALIAUgCjYCuAEgBSAJNgK0ASAFIA82ArABIAVB0AFqIAVBsAFqIgEQ5xUgASALQQBBAUEBEKAYIAUoArQBIQogBSgCsAFBAUYNASAFKAK4ASEBIAsEQCABIAYgC/wKAAALIAUgCzYCmAEgBSABNgKUASAFIAo2ApABIAVBwAFqIgEgBUGQAWoiBhDnFSAFQbgBaiIJIAVB2AFqIgopAgAiLDcDACAFQfgAaiAsNwMAIAVBgAFqIgsgASkDADcDACAFQYgBaiIBIAVByAFqKQMANwMAIAUgBSkC0AEiLTcDsAEgBSAtNwNwIAVBmAFqIg8gLDcDACAFIC03A5ABIAogASkDADcDACAFIAspAwA3A9ABIAhBoAFqIQFBASEKAkAgCCgCnAEiC0EBRgRAIAEoAgBFDQFBASELIAUoApABBEAgASAGEMYpIQsLIAtB/wFxQQJGIAvAQQBMcg0BIAgoApwBIQsLIAkgDykDADcDACAFIAUpA5ABNwOwAQJAIAtFDQAgASgCACIGRQ0AIAhBrAFqIAgoAqQBIAgoAqgBIAYoAhARAQALIAhBATYCnAEgASAFKQOwATcCACABQQhqIAVBuAFqKQMANwIAQQAhCgsgCEG0AWohAQJAIAgoArABIgtBAUYEQCAFKALQASEGAkAgASgCAARAIAZFDQMgASAFQdABahDGKcBBAEgNASAFKALQASIBRQ0DIAVB3AFqIAUoAtQBIAUoAtgBIAEoAhARAQAMAwsgBkUNAgsgCCgCsAEhCwsgBUG4AWoiBiAFQdgBaikDADcDACAFIAUpA9ABNwOwAQJAIAtFDQAgASgCACIJRQ0AIAhBwAFqIAgoArgBIAgoArwBIAkoAhARAQALIAhBATYCsAEgASAFKQOwATcCACABQQhqIAYpAwA3AgALIApFDQIgBSgCkAEiAUUNAiAFQZwBaiAFKAKUASAFKAKYASABKAIQEQEADAILDBcLDBcLAkAgCCgCkAFBgICAgHhGDQAgBSAENgKwASAFIAQgDEECdGo2ArQBIAVBOGogBUGwAWoQwykgBSgCOEEBcUUNACAIQZABaiEBIAUoAjwhCQNAIAVBMGogBUHoAGogCRD9GSABIAUoAjAgBSgCNBCGChCiFSAFQShqIAVBsAFqEMMpIAUoAiwhCSAFKAIoQQFxDQALCwJAIAgoAgBBgICAgHhHBEAgBSAFKQJoNwKwASAIQdAAaiIGIAwQ7C0gDEUNASAMQQJ0IQoDQCAFQSBqIAVBsAFqIAQoAgAQ/RkgCCAFKAIgIAUoAiQiCRD1GyEsIAgoAlgiASAIKAJQRgRAIAZB8PjNABCzKAsgBEEEaiEEIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAmtfDcDSCAKQQRrIgoNAAsMAQsgBSkCaCEsIAggCCgCiAEgDGo2AogBIAUgLDcC0AECQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQsDQCAFQQhqIAVB0AFqIAQoAgAQ/RkgBSgCCCEJIAUgBSgCDCIGNgKwASABIAVBsAFqQQQQoTYgASAJIAYQoTYgCCAIKQOAASAGrXw3A4ABIARBBGohBCALQQRrIgsNAAsMAgsgDEUNASAIQeQAaiEGIAxBAnQhCgNAIAVBEGogBUHQAWogBCgCABD9GSAFKAIQIQkgCCgCcCELIAUgBSgCFCIBNgKQASAFQfAAaiALIAVBkAFqQQEQzxEgBSgCcEEIRw0aIAYgCSABEKE2IAggCCkDgAEgAa18NwOAASAEQQRqIQQgCkEEayIKDQALDAELIAxFDQAgCEHgAGohCyAEIAxBAnRqIQ8gCEHsAGohGANAIAVBGGogBUHQAWogBCgCABD9GSAFKAIYIQZBACEJAkAgCCgCdCIBIAUoAhwiCiABIApJGyIBRQ0AIAgoAnAhHANAIAkgHGotAAAgBiAJai0AAEcNASABIAlBAWoiCUcNAAsgASEJCyAIQQA2AnQgGCAGIAoQoTYgCSAKSw0aIAsgBiAJaiAKIAlrIgEQoTYgCCgCeCEGIAUgCTYCkAEgBUHwAGoiCSAGIAVBkAFqIgZBARDPESAFKAJwQQhHDRsgCCgCfCEcIAUgATYCkAEgCSAcIAZBARDPESAFKAJwQQhHDRwgCCAIKQOAASAKrXw3A4ABIARBBGoiBCAPRw0ACwsgBUHgAWokAAwLCyADQdAGaiAWIBUoAhARAAAgA0HACmogAygC0AYiASADKALUBigCDBEAACABRQ0MIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0MIANByAZqIAEQ1CEgAygCyAYiAUUNDCADKALMBiEGIAshBCMAQeABayIFJAAgBSAGNgJsIAUgATYCaAJAIAgtAMQBRQ0AIAUgBjYCpAEgBSABNgKgASAFIAQ2AqgBIAUgBCAMQQJ0ajYCrAEgBUHgAGogBUGoAWoQwykgBSgCYEEBcUUNACAFQdgAaiAFQaABaiAFKAJkEPoZIAUoAlwhCiAFKAJYIQEgBSAFKQKoATcCsAEgBUHQAGogBUGwAWoQwykCQCAFKAJQQQFxRQRAIAohCyABIQYMAQsgBSgCVCEJIAEhBiAKIQsDQCAFQcgAaiAFQaABaiAJEPoZIAUoAkgiDyABIA8gASAFKAJMIgkgCiAJIApJGxCZJyIBIAkgCmsgARtBAEgiGBshASAJIAogGBshCiAGIA8gDyAGIAkgCyAJIAtJGxCZJyIGIAkgC2sgBhtBAEgiDxshBiALIAkgDxshCyAFQUBrIAVBsAFqEMMpIAUoAkQhCSAFKAJAQQFxDQALCyAFQbABaiAKQQBBAUEBEKAYIAUoArQBIQ8CQCAFKAKwAUEBRwRAIAUoArgBIQkgCgRAIAkgASAK/AoAAAsgBSAKNgK4ASAFIAk2ArQBIAUgDzYCsAEgBUHQAWogBUGwAWoiARDnFSABIAtBAEEBQQEQoBggBSgCtAEhCiAFKAKwAUEBRg0BIAUoArgBIQEgCwRAIAEgBiAL/AoAAAsgBSALNgKYASAFIAE2ApQBIAUgCjYCkAEgBUHAAWoiASAFQZABaiIGEOcVIAVBuAFqIgkgBUHYAWoiCikCACIsNwMAIAVB+ABqICw3AwAgBUGAAWoiCyABKQMANwMAIAVBiAFqIgEgBUHIAWopAwA3AwAgBSAFKQLQASItNwOwASAFIC03A3AgBUGYAWoiDyAsNwMAIAUgLTcDkAEgCiABKQMANwMAIAUgCykDADcD0AEgCEGgAWohAUEBIQoCQCAIKAKcASILQQFGBEAgASgCAEUNAUEBIQsgBSgCkAEEQCABIAYQxikhCwsgC0H/AXFBAkYgC8BBAExyDQEgCCgCnAEhCwsgCSAPKQMANwMAIAUgBSkDkAE3A7ABAkAgC0UNACABKAIAIgZFDQAgCEGsAWogCCgCpAEgCCgCqAEgBigCEBEBAAsgCEEBNgKcASABIAUpA7ABNwIAIAFBCGogBUG4AWopAwA3AgBBACEKCyAIQbQBaiEBAkAgCCgCsAEiC0EBRgRAIAUoAtABIQYCQCABKAIABEAgBkUNAyABIAVB0AFqEMYpwEEASA0BIAUoAtABIgFFDQMgBUHcAWogBSgC1AEgBSgC2AEgASgCEBEBAAwDCyAGRQ0CCyAIKAKwASELCyAFQbgBaiIGIAVB2AFqKQMANwMAIAUgBSkD0AE3A7ABAkAgC0UNACABKAIAIglFDQAgCEHAAWogCCgCuAEgCCgCvAEgCSgCEBEBAAsgCEEBNgKwASABIAUpA7ABNwIAIAFBCGogBikDADcCAAsgCkUNAiAFKAKQASIBRQ0CIAVBnAFqIAUoApQBIAUoApgBIAEoAhARAQAMAgsMFgsMFgsCQCAIKAKQAUGAgICAeEYNACAFIAQ2ArABIAUgBCAMQQJ0ajYCtAEgBUE4aiAFQbABahDDKSAFKAI4QQFxRQ0AIAhBkAFqIQEgBSgCPCEJA0AgBUEwaiAFQegAaiAJEPoZIAEgBSgCMCAFKAI0EIYKEKIVIAVBKGogBUGwAWoQwykgBSgCLCEJIAUoAihBAXENAAsLAkAgCCgCAEGAgICAeEcEQCAFIAUpAmg3ArABIAhB0ABqIgYgDBDsLSAMRQ0BIAxBAnQhCgNAIAVBIGogBUGwAWogBCgCABD6GSAIIAUoAiAgBSgCJCIJEPUbISwgCCgCWCIBIAgoAlBGBEAgBkHw+M0AELMoCyAEQQRqIQQgCCgCVCABQQN0aiAsNwMAIAggAUEBajYCWCAIIAgpA0ggCa18NwNIIApBBGsiCg0ACwwBCyAFKQJoISwgCCAIKAKIASAMajYCiAEgBSAsNwLQAQJAAkACQEECIAgoAmAiAUGAgICAeHMgAUEAThtBAWsOAgECAAsgDEUNAiAIQeQAaiEBIAxBAnQhCwNAIAVBCGogBUHQAWogBCgCABD6GSAFKAIIIQkgBSAFKAIMIgY2ArABIAEgBUGwAWpBBBChNiABIAkgBhChNiAIIAgpA4ABIAatfDcDgAEgBEEEaiEEIAtBBGsiCw0ACwwCCyAMRQ0BIAhB5ABqIQYgDEECdCEKA0AgBUEQaiAFQdABaiAEKAIAEPoZIAUoAhAhCSAIKAJwIQsgBSAFKAIUIgE2ApABIAVB8ABqIAsgBUGQAWpBARDPESAFKAJwQQhHDRkgBiAJIAEQoTYgCCAIKQOAASABrXw3A4ABIARBBGohBCAKQQRrIgoNAAsMAQsgDEUNACAIQeAAaiELIAQgDEECdGohDyAIQewAaiEYA0AgBUEYaiAFQdABaiAEKAIAEPoZIAUoAhghBkEAIQkCQCAIKAJ0IgEgBSgCHCIKIAEgCkkbIgFFDQAgCCgCcCEcA0AgCSAcai0AACAGIAlqLQAARw0BIAEgCUEBaiIJRw0ACyABIQkLIAhBADYCdCAYIAYgChChNiAJIApLDRkgCyAGIAlqIAogCWsiARChNiAIKAJ4IQYgBSAJNgKQASAFQfAAaiIJIAYgBUGQAWoiBkEBEM8RIAUoAnBBCEcNGiAIKAJ8IRwgBSABNgKQASAJIBwgBkEBEM8RIAUoAnBBCEcNGyAIIAgpA4ABIAqtfDcDgAEgBEEEaiIEIA9HDQALCyAFQeABaiQADAoLIANB4AZqIBYgFSgCEBEAACADQcAKaiADKALgBiIBIAMoAuQGKAIMEQAAIAFFDQsgAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0LIANB2AZqIAEQ1CEgAygC2AYiAUUNCyABIAMoAtwGIAsgDCAIEIkCDAkLIANB8AZqIBYgFSgCEBEAACADQcAKaiADKALwBiIBIAMoAvQGKAIMEQAAIAFFDQogAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQogA0HoBmogARDUISADKALoBiIBBEAgASADKALsBiALIAwgCBCKAgwJCwwKCwJAAkACQAJAAkACQAJAAkAgASgCBC0AAEECaw4IAAECAwQFBgcUCyADQYAFaiAWIBUoAhARAAAgA0HACmogAygCgAUiASADKAKEBSgCDBEAACABRQ0QIAMpA8AKQsbMuueM6qCFvH+FIAMpA8gKQrrSke+K9vT4zACFhFBFDRAgA0H4BGogARDgISADKAL4BCIBRQ0QIAEgAygC/AQgCyAMIAgQgwIMDgsgA0GQBWogFiAVKAIQEQAAIANBwApqIAMoApAFIgEgAygClAUoAgwRAAAgAUUNDyADKQPACkKTk+716KiClmeFIAMpA8gKQpiS4em4iOKWaYWEUEUNDyADQYgFaiABEOAhIAMoAogFIgFFDQ8gASADKAKMBSALIAwgCBCEAgwNCyADQaAFaiAWIBUoAhARAAAgA0HACmogAygCoAUiASADKAKkBSgCDBEAACABRQ0OIAMpA8AKQtrOgMmrxer9xwCFIAMpA8gKQpv03beZi9OOP4WEUEUNDiADQZgFaiABEOAhIAMoApgFIgFFDQ4gASADKAKcBSALIAwgCBCFAgwMCyADQbAFaiAWIBUoAhARAAAgA0HACmogAygCsAUiASADKAK0BSgCDBEAACABRQ0NIAMpA8AKQvzrueK87/jQcoUgAykDyApC2uOfjcyP4YGpf4WEUEUNDSADQagFaiABEOAhIAMoAqgFIgFFDQ0gASADKAKsBSALIAwgCBCGAgwLCyADQcAFaiAWIBUoAhARAAAgA0HACmogAygCwAUiASADKALEBSgCDBEAACABRQ0MIAMpA8AKQvz2+K7xiNShFYUgAykDyApC78rT/aPRvtHwAIWEUEUNDCADQbgFaiABEOAhIAMoArgFIgFFDQwgASADKAK8BSALIAwgCBCHAgwKCyADQdAFaiAWIBUoAhARAAAgA0HACmogAygC0AUiASADKALUBSgCDBEAACABRQ0LIAMpA8AKQoaymNmdqbemboUgAykDyApC3a+72du2z9ZmhYRQRQ0LIANByAVqIAEQ4CEgAygCyAUiAUUNCyABIAMoAswFIAsgDCAIEIgCDAkLIANB4AVqIBYgFSgCEBEAACADQcAKaiADKALgBSIBIAMoAuQFKAIMEQAAIAFFDQogAykDwApC8sj6w/TpjJjzAIUgAykDyApC8LiQ7cOE2/1OhYRQRQ0KIANB2AVqIAEQ4CEgAygC2AUiAUUNCiABIAMoAtwFIAsgDCAIEIUCDAgLIANB8AVqIBYgFSgCEBEAACADQcAKaiADKALwBSIBIAMoAvQFKAIMEQAAIAFFDQkgAykDwApCpJvx8abpgqoQhSADKQPICkLNu9rE68fEghiFhFBFDQkgA0HoBWogARDgISADKALoBSIBBEAgASADKALsBSALIAwgCBCGAgwICwwJCyADIAQ2AuAKIANBAjYCxAogA0GI+80ANgLACgwHCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQcAEaiADQcAKahDDKSADKALABEEBcUUNACAIQZABaiEBIAMoAsQEIQoDQCADQbgEaiADQfwJaiAKEKQqIAEgAygCuAQgAygCvAQQhgoQohUgA0GwBGogA0HACmoQwykgAygCtAQhCiADKAKwBEEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBiAMQQJ0IQUDQCADQagEaiADQcAKaiALKAIAEKQqIAggAygCqAQgAygCrAQiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBgsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0HIAhB5ABqIQEgDEECdCEFA0AgA0GQBGogA0GgCmogCygCABCkKiADKAKQBCEGIAMgAygClAQiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAcLIAxFDQYgCEHkAGohBCAMQQJ0IQUDQCADQZgEaiADQaAKaiALKAIAEKQqIAMoApgEIQYgCCgCcCEJIAMgAygCnAQiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQ0gBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBgsgDEUNBSAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQaAEaiADQaAKaiALKAIAEKQqIAMoAqAEIQRBACEKAkAgCCgCdCIBIAMoAqQEIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDiAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDyAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwGCwwOCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQdgDaiADQcAKahDDKSADKALYA0EBcUUNACAIQZABaiEBIAMoAtwDIQoDQCADQdADaiADQfwJaiAKEKsqIAEgAygC0AMgAygC1AMQhgoQohUgA0HIA2ogA0HACmoQwykgAygCzAMhCiADKALIA0EBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBSAMQQJ0IQUDQCADQcADaiADQcAKaiALKAIAEKsqIAggAygCwAMgAygCxAMiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBQsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0GIAhB5ABqIQEgDEECdCEFA0AgA0GoA2ogA0GgCmogCygCABCrKiADKAKoAyEGIAMgAygCrAMiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAYLIAxFDQUgCEHkAGohBCAMQQJ0IQUDQCADQbADaiADQaAKaiALKAIAEKsqIAMoArADIQYgCCgCcCEJIAMgAygCtAMiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQwgBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBQsgDEUNBCAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQbgDaiADQaAKaiALKAIAEKsqIAMoArgDIQRBACEKAkAgCCgCdCIBIAMoArwDIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDSAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDiAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwFCwwNCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQfACaiADQcAKahDDKSADKALwAkEBcUUNACAIQZABaiEBIAMoAvQCIQoDQCADQegCaiADQfwJaiAKEKgqIAEgAygC6AIgAygC7AIQhgoQohUgA0HgAmogA0HACmoQwykgAygC5AIhCiADKALgAkEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNBCAMQQJ0IQUDQCADQdgCaiADQcAKaiALKAIAEKgqIAggAygC2AIgAygC3AIiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMBAsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0FIAhB5ABqIQEgDEECdCEFA0AgA0HAAmogA0GgCmogCygCABCoKiADKALAAiEGIAMgAygCxAIiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAULIAxFDQQgCEHkAGohBCAMQQJ0IQUDQCADQcgCaiADQaAKaiALKAIAEKgqIAMoAsgCIQYgCCgCcCEJIAMgAygCzAIiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQsgBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMBAsgDEUNAyAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQdACaiADQaAKaiALKAIAEKgqIAMoAtACIQRBACEKAkAgCCgCdCIBIAMoAtQCIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNDCAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDSAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwECwwMCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQYgCaiADQcAKahDDKSADKAKIAkEBcUUNACAIQZABaiEBIAMoAowCIQoDQCADQYACaiADQfwJaiAKEKUqIAEgAygCgAIgAygChAIQhgoQohUgA0H4AWogA0HACmoQwykgAygC/AEhCiADKAL4AUEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNAyAMQQJ0IQUDQCADQfABaiADQcAKaiALKAIAEKUqIAggAygC8AEgAygC9AEiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMAwsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0EIAhB5ABqIQEgDEECdCEFA0AgA0HYAWogA0GgCmogCygCABClKiADKALYASEGIAMgAygC3AEiBDYCwAogASADQcAKakEEEKE2IAEgBiAEEKE2IAggCCkDgAEgBK18NwOAASALQQRqIQsgBUEEayIFDQALDAQLIAxFDQMgCEHkAGohBCAMQQJ0IQUDQCADQeABaiADQaAKaiALKAIAEKUqIAMoAuABIQYgCCgCcCEJIAMgAygC5AEiATYC4AogA0GACmogCSADQeAKakEBEM8RIAMoAoAKQQhHDQogBCAGIAEQoTYgCCAIKQOAASABrXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMAwsgDEUNAiAIQeAAaiEGIAsgDEECdGohCSAIQewAaiEPAkADQCADQegBaiADQaAKaiALKAIAEKUqIAMoAugBIQRBACEKAkAgCCgCdCIBIAMoAuwBIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNCyAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNDCAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQEgCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwwDCwwLCwJAIAgoApABQYCAgIB4Rg0AIAMgCzYCwAogAyALIAxBAnRqNgLECiADQaABaiADQcAKahDDKSADKAKgAUEBcUUNACAIQZABaiEBIAMoAqQBIQoDQCADQZgBaiADQfwJaiAKEKoqIAEgAygCmAEgAygCnAEQhgoQohUgA0GQAWogA0HACmoQwykgAygClAEhCiADKAKQAUEBcQ0ACwsgCCgCAEGAgICAeEcEQCADIAMoAvwJNgLACiAIQdAAaiIEIAwQ7C0gDEUNAiAMQQJ0IQUDQCADQYgBaiADQcAKaiALKAIAEKoqIAggAygCiAEgAygCjAEiBhD1GyEsIAgoAlgiASAIKAJQRgRAIARB8PjNABCzKAsgC0EEaiELIAgoAlQgAUEDdGogLDcDACAIIAFBAWo2AlggCCAIKQNIIAatfDcDSCAFQQRrIgUNAAsMAgsgAygC/AkhASAIIAgoAogBIAxqNgKIASADIAE2AqAKAkACQAJAQQIgCCgCYCIBQYCAgIB4cyABQQBOG0EBaw4CAQIACyAMRQ0DIAhB5ABqIQEgDEECdCEFA0AgA0HwAGogA0GgCmogCygCABCqKiADKAJwIQYgAyADKAJ0IgQ2AsAKIAEgA0HACmpBBBChNiABIAYgBBChNiAIIAgpA4ABIAStfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwDCyAMRQ0CIAhB5ABqIQQgDEECdCEFA0AgA0H4AGogA0GgCmogCygCABCqKiADKAJ4IQYgCCgCcCEJIAMgAygCfCIBNgLgCiADQYAKaiAJIANB4ApqQQEQzxEgAygCgApBCEcNCSAEIAYgARChNiAIIAgpA4ABIAGtfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwCCyAMRQ0BIAhB4ABqIQYgCyAMQQJ0aiEJIAhB7ABqIQ8CQANAIANBgAFqIANBoApqIAsoAgAQqiogAygCgAEhBEEAIQoCQCAIKAJ0IgEgAygChAEiBSABIAVJGyIBRQ0AIAgoAnAhGANAIAogGGotAAAgBCAKai0AAEcNASABIApBAWoiCkcNAAsgASEKCyAIQQA2AnQgDyAEIAUQoTYgBSAKSQ0KIAYgBCAKaiAFIAprIgEQoTYgCCgCeCEEIAMgCjYC4AogA0GACmoiCiAEIANB4ApqIgRBARDPESADKAKACkEIRw0LIAgoAnwhGCADIAE2AuAKIAogGCAEQQEQzxEgAygCgApBCEcNASAIIAgpA4ABIAWtfDcDgAEgC0EEaiILIAlHDQALDAILDAoLAkAgCCgCkAFBgICAgHhGDQAgAyALNgLACiADIAsgDEECdGo2AsQKIANBOGogA0HACmoQwykgAygCOEEBcUUNACAIQZABaiEBIAMoAjwhCgNAIANBMGogA0H8CWogChCpKiABIAMoAjAgAygCNBCGChCiFSADQShqIANBwApqEMMpIAMoAiwhCiADKAIoQQFxDQALCyAIKAIAQYCAgIB4RwRAIAMgAygC/Ak2AsAKIAhB0ABqIgQgDBDsLSAMRQ0BIAxBAnQhBQNAIANBIGogA0HACmogCygCABCpKiAIIAMoAiAgAygCJCIGEPUbISwgCCgCWCIBIAgoAlBGBEAgBEHw+M0AELMoCyALQQRqIQsgCCgCVCABQQN0aiAsNwMAIAggAUEBajYCWCAIIAgpA0ggBq18NwNIIAVBBGsiBQ0ACwwBCyADKAL8CSEBIAggCCgCiAEgDGo2AogBIAMgATYCoAoCQAJAAkBBAiAIKAJgIgFBgICAgHhzIAFBAE4bQQFrDgIBAgALIAxFDQIgCEHkAGohASAMQQJ0IQUDQCADQQhqIANBoApqIAsoAgAQqSogAygCCCEGIAMgAygCDCIENgLACiABIANBwApqQQQQoTYgASAGIAQQoTYgCCAIKQOAASAErXw3A4ABIAtBBGohCyAFQQRrIgUNAAsMAgsgDEUNASAIQeQAaiEEIAxBAnQhBQNAIANBEGogA0GgCmogCygCABCpKiADKAIQIQYgCCgCcCEJIAMgAygCFCIBNgLgCiADQYAKaiAJIANB4ApqQQEQzxEgAygCgApBCEcNCCAEIAYgARChNiAIIAgpA4ABIAGtfDcDgAEgC0EEaiELIAVBBGsiBQ0ACwwBCyAMRQ0AIAhB4ABqIQYgCyAMQQJ0aiEJIAhB7ABqIQ8DQCADQRhqIANBoApqIAsoAgAQqSogAygCGCEEQQAhCgJAIAgoAnQiASADKAIcIgUgASAFSRsiAUUNACAIKAJwIRgDQCAKIBhqLQAAIAQgCmotAABHDQEgASAKQQFqIgpHDQALIAEhCgsgCEEANgJ0IA8gBCAFEKE2IAUgCkkNCCAGIAQgCmogBSAKayIBEKE2IAgoAnghBCADIAo2AuAKIANBgApqIgogBCADQeAKaiIEQQEQzxEgAygCgApBCEcNCSAIKAJ8IRggAyABNgLgCiAKIBggBEEBEM8RIAMoAoAKQQhHDQogCCAIKQOAASAFrXw3A4ABIAtBBGoiCyAJRw0ACwsgJUEINgIAIANB8ApqJAAMDwsgA0IBNwLMCiADQacENgKECiADIANBgApqNgLICiADIANB4ApqNgKACiADQcAKakH0+c0AEO8sAAtB9PnNABCyOwALIAogAygCyApBtPXNABD9LwALIAEgAygCyApBtPXNABD9LwALQYT6zQBBKEH0+c0AEJ8pAAsgA0HQCmogA0GQCmopAwA3AwAgA0HICmogA0GICmopAwA3AwAgAyADKQOACjcDwApByPHNAEErIANBwApqQbjxzQBBoPbNABDVHgALIAogBUHQ9s0AEK87AAsgA0HQCmogA0GQCmopAwA3AwAgA0HICmogA0GICmopAwA3AwAgAyADKQOACjcDwApByPHNAEErIANBwApqQbjxzQBB8PbNABDVHgALIANB0ApqIANBkApqKQMANwMAIANByApqIANBiApqKQMANwMAIAMgAykDgAo3A8AKQcjxzQBBKyADQcAKakG48c0AQYD3zQAQ1R4ACyAPIAUoArgBQbT1zQAQ/S8ACyAKIAUoArgBQbT1zQAQ/S8ACyAFQcABaiAFQYABaikDADcDACAFQbgBaiAFQfgAaikDADcDACAFIAUpA3A3A7ABQcjxzQBBKyAFQbABakG48c0AQaD2zQAQ1R4ACyAJIApB0PbNABCvOwALIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBB8PbNABDVHgALIAVBwAFqIAVBgAFqKQMANwMAIAVBuAFqIAVB+ABqKQMANwMAIAUgBSkDcDcDsAFByPHNAEErIAVBsAFqQbjxzQBBgPfNABDVHgALIBIoAhgiAUEIRwRAIBkgEikCHDcCBCAZQRRqIBJBLGooAgA2AgAgGUEMaiASQSRqKQIANwIAIBkgATYCAAwFCyAUIBQoAoAEIA1qIgE2AoAEIAENAgwDCyARIAFBqP/OABCxOwALIAEgH0Go/84AELA7AAsgFCgChAQgFCgCnAUoApABSQRAAn8gCCgCAEGAgICAeEcEQCAIKAJYIgFBA3YgAUEHcUEAR2oiAUEgIAgoAhQiBEEBayIGQQAgBCAGTxtnIgRrIgZBA3YgBkEHcUEAR2pBAWpsIgYgAUEhIARrbCIBIAEgBkkbQQFqDAELAn8CQAJAAkBBAiAIQeAAaiIBKAIAIgRBgICAgHhzIARBAE4bQQFrDgIBAgALIAEoAgwMAgsgASgCECIEKAIoIAEoAgxqIAQtACwiAUEDdiABQQdxQQBHamoMAQsgASgCHCIEKAIoIAEoAhgiBigCKCABKAIIamogBi0ALCIBQQN2IAFBB3FBAEdqaiAELQAsIgFBA3YgAUEHcUEAR2pqCwsgFCgCnAUoAowBSQ0BCyASQRhqIBQQzAEgEigCGCIBQQhGDQAgGSASKQIcNwIEIBlBFGogEkEsaigCADYCACAZQQxqIBJBJGopAgA3AgAgGSABNgIADAELAkAgCCgCAEGAgICAeEYNACAUKAK4ASAUKAKcBUEIaiAUKAKYBUEIahDQEUkNACASQRhqIQQjAEHAAWsiASQAAkACQCAUKAKABEUNACABQSBqIBQQzAEgASgCICIGQQhGDQAgBCABKQIkNwIEIARBFGogAUE0aigCADYCACAEQQxqIAFBLGopAgA3AgAgBCAGNgIADAELIAFBIGogFBCKByABKAIgIgZBCEcEQCAEIAEpAiQ3AgQgBEEUaiABQTRqKAIANgIAIARBDGogAUEsaikCADcCACAEIAY2AgAMAQsCQAJAIBQoAoAERQ0AIAFBqAFqIBQQzAEgASgCqAEiCUEIRg0ADAELAkAgFCgCjAMiCUUNACABQShqIQYDQCAUIAlBAWs2AowDIBQgFCgCiAMiCUEBaiIKIBQoAoADIgtBACAKIAtPG2s2AogDIBQoAoQDIAlBiAFsaiIJKQMAIixCDFENASABICw3AyAgBiAJQQhqQYAB/AoAACABQagBaiAUIAFBIGoQpQogASgCqAEiCUEIRw0CIBQoAowDIgkNAAsLIARBCDYCAAwBCyABQRhqIgYgAUG8AWooAgA2AgAgAUEQaiIKIAFBtAFqKQIANwMAIAEgASkCrAE3AwggBCAJNgIAIAQgASkDCDcCBCAEQQxqIAopAwA3AgAgBEEUaiAGKAIANgIACyABQcABaiQAIBIoAhgiAUEIRg0AIBkgEikCHDcCBCAZQRRqIBJBLGooAgA2AgAgGUEMaiASQSRqKQIANwIAIBkgATYCAAwBCyAZQQg2AgAgGSAMNgIECyASQUBrJAAgGygCHCEBIBsoAhgiBEEIRwRAIB0gGykDIDcDCCAdQRBqIBtBKGopAwA3AwAgHSABNgIEIB0gBDYCAAwHCyABIBFqIREgEyAQIglNDQUMAQsLIAkgEEGY/s4AELE7AAsgECAXQZj+zgAQsDsACyAJIBBBqP7OABCxOwALIBAgDkGo/s4AELA7AAsgHUEINgIAIB0gETYCBAsgG0EwaiQAIAcoAlAiAUEIRg0YICEgBykDWDcDCCAhQRBqIAdB4ABqKQMANwMAICEgBygCVDYCBCAhIAE2AgAMGQsgBCAHKAJYQdjxzwAQ/S8ACyABIAcoAlhBsOjPABD9LwALIAkgBygCWEGY9M8AEP0vAAsgByAEEP47NgKYAQwWC0H48M8AELI7AAsgBCAHKAJYQbj0zwAQ/S8ACyAEIAcoAlhB2PLPABD9LwALIAcgChD8OzYCmAEMEgsgEUEEQejyzwAQrzsACyAEIAcoAlhBiPPPABD9LwALIAcgChD9OzYCzAEMEQsgEUEIQZjzzwAQrzsACyAEIAcoAlhBuPPPABD9LwALIAcgChD/OzYCzAEMDgsgEUEQQcjzzwAQrzsAC0GI8c8AELI7AAsgCSAHKAJYQejzzwAQ/S8ACyAHIAQQgDw2AswBIAdBAjYCuAEgB0HQ5c8ANgK0ASAHQgI3AsABIAdBOzYC3AEgB0E7NgLUASAHIAdB0AFqNgK8ASAHIAdBzAFqNgLYASAHIAdBsAFqNgLQASAHQbQBakHg5c8AEO8sAAsgA0EgQfjzzwAQrzsACyAQIAcoArwBQbDozwAQ/S8AC0Gc8M8AELI7AAtBrPDPABCyOwALIAdBOGohDCAGQRBqIQ4gBygCjAEhASAHKAKQASEQIAsoAhBBACALKAIMQYCAgIB4RxshFSALKAIUIRcgCygCHEEAIAsoAhhBgICAgHhHGyESIAsoAiAhFEEAIQZBACEKIwBBMGsiCCQAAkACQCAVQQAgEhtFBEAgECETIBVFDQEgFyETDAELIBQgFyITRg0AIAggEzYCACAIIBQ2AgQgCEECNgIcIAhBiP7OADYCGCAIQgI3AiQgCEE7NgIUIAhBOzYCDCAIIAhBCGo2AiAgCCAIQQRqNgIQIAggCDYCCCAMQQRqIAhBGGoQmQ4gDEEANgIADAELIA4oAqgBRQRAIA4gLDcD2AELIA5CADcD0AECQAJAAkACQCATBEAgDigChAUoApQBIRYDQAJAIBJFIAYgFmoiBCATIAQgE0kbIgkgFE9yDQAgEiAJQQF0aiEEA0AgBC8BAEUNASAEQQJqIQQgFCAJQQFqIglHDQALIBQhCQtBACEEQQAhAyAVBEAgBiAJSw0DIAkgF0sNBCAVIAZBAXRqIQMLIBIEQCAGIAlLDQUgCSAUSw0GIBIgBkEBdGohBAsgCEEYaiEFIwBBQGoiDSQAIAkgBmsiBiELAkACQCAOKAKABSIPLgEYIhFBAEoEfyADRQRAIA1BATYCHCANQfj/zgA2AhggDUIBNwIkIA1BzQE2AjggDSAROwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAUgDSkCDDcCDCAFQRRqIA1BFGooAgA2AgAgBSANKQIENwIEIAVBADYCAAwDC0EAIQsgBgRAIBFB//8DcSEZIAMhESAGIQ8DQCALIBEvAQAgGUZqIQsgEUECaiERIA9BAWsiDw0ACwsgDiAOKQPIAyAGIAtrrXw3A8gDIA4oAtwDQYCAgIB4RwRAIA5B3ANqIAMgBhDXIQsgDkHoBGogAyAGEPgpIA4oAoAFBSAPCy4BGiIRQQBMBEAgDiAOKALsAyAGajYC7AMMAQsgBARAIAYEQCAELwEABEAgDUEBNgIcIA1BkP/OADYCGCANQgE3AiQgDUHNATYCBCANIAQ2AgAgDSANNgIgIAVBBGogDUEYahCZDiAFQQA2AgAMBAsgBkEBdCEDIA4oAuwDIQ8gBCERA0AgDyARLwEARWohDyARQQJqIREgA0ECayIDDQALIA4gDzYC7AMLIA4oAtADQYCAgIB4RwRAIA5B0ANqIAQgBhDXIQsgDkH0BGogBCAGEPgpDAELIA1BATYCHCANQcCAzwA2AhggDUIBNwIkIA1BzQE2AjggDSAROwE+IA0gDUE0ajYCICANIA1BPmo2AjQgDUEEciANQRhqEJkOIAUgDSkCDDcCDCAFQRRqIA1BFGooAgA2AgAgBSANKQIENwIEIAVBADYCAAwBCyANQRhqIREjAEHQAGsiBCQAIA4gDigCqAEgC2o2AqgBIAQgCzYCBAJAIAsgCiALaiIDTSADIBBNcUUEQCAEIBAgCms2AjwgBEECNgIoIARBiInOADYCJCAEQgI3AjAgBEE7NgJMIARBOzYCRCAEIARBQGs2AiwgBCAEQTxqNgJIIAQgBEEEajYCQCAEQQhqQQRyIARBJGoQmQ4gESAEKQIUNwIMIBFBFGogBEEcaigCADYCACARIAQpAgw3AgQgEUEANgIADAELIBEgDiABIApBBHRqIAsQhA4LIARB0ABqJAAgDSgCGCIEQQhHBEAgBSANKQIcNwIEIAVBFGogDUEsaigCADYCACAFQQxqIA1BJGopAgA3AgAgBSAENgIADAELIA4gDigC6AMgBmoiBDYC6AMCQCAERQ0AIA4oAuwDIA4oAoQFKAKQAUkEQCAOELwcIA4oAoQFKAKMAUkNAQsgDUEYaiAOEMoBIA0oAhgiBEEIRg0AIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCwJAIA4oAlhBgICAgHhGDQAgDigCTCAOKAKEBUEIaiAOKAKABUEIahDQEUkNACANQRhqIREjAEHAAWsiBCQAAkACQCAOKALoA0UNACAEQSBqIA4QygEgBCgCICIGQQhGDQAgESAEKQIkNwIEIBFBFGogBEE0aigCADYCACARQQxqIARBLGopAgA3AgAgESAGNgIADAELIARBIGogDhCNByAEKAIgIgZBCEcEQCARIAQpAiQ3AgQgEUEUaiAEQTRqKAIANgIAIBFBDGogBEEsaikCADcCACARIAY2AgAMAQsCQAJAIA4oAugDRQ0AIARBqAFqIA4QygEgBCgCqAEiBkEIRg0ADAELAkAgDigC9AIiBkUNACAEQShqIQMDQCAOIAZBAWs2AvQCIA4gDigC8AIiBkEBaiIPIA4oAugCIhlBACAPIBlPG2s2AvACIA4oAuwCIAZBiAFsaiIGKQMAIixCDFENASAEICw3AyAgAyAGQQhqQYAB/AoAACAEQagBaiAOIARBIGoQpgogBCgCqAEiBkEIRw0CIA4oAvQCIgYNAAsLIBFBCDYCAAwBCyAEQRhqIgMgBEG8AWooAgA2AgAgBEEQaiIPIARBtAFqKQIANwMAIAQgBCkCrAE3AwggESAGNgIAIBEgBCkDCDcCBCARQQxqIA8pAwA3AgAgEUEUaiADKAIANgIACyAEQcABaiQAIA0oAhgiBEEIRg0AIAUgDSkCHDcCBCAFQRRqIA1BLGooAgA2AgAgBUEMaiANQSRqKQIANwIAIAUgBDYCAAwBCyAFQQg2AgAgBSALNgIECyANQUBrJAAgCCgCHCEEIAgoAhgiBkEIRwRAIAwgCCkDIDcDCCAMQRBqIAhBKGopAwA3AwAgDCAENgIEIAwgBjYCAAwHCyAEIApqIQogEyAJIgZLDQALCyAMQQg2AgAgDCAKNgIEDAQLIAYgCUGY/s4AELE7AAsgCSAXQZj+zgAQsDsACyAGIAlBqP7OABCxOwALIAkgFEGo/s4AELA7AAsgCEEwaiQAIBAEQANAIAEoAgAiBARAIAFBDGogAUEEaigCACABQQhqKAIAIAQoAhARAQALIAFBEGohASAQQQFrIhANAAsLIAdBiAFqQQRBEBDgHgsgBygCOCIBQQhGDQAgISAHKQNANwMIICFBEGogB0HIAGopAwA3AwAgISAHKAI8NgIEICEgATYCAAwBCyAhQQg2AgALIAdB4AFqJAAMBgsgB0ECNgJUIAdB0OXPADYCUCAHQgI3AlwgB0E7NgLAASAHQTs2ArgBIAcgB0G0AWo2AlggByAHQZgBajYCvAEgByAHQcwBajYCtAEMAgsgAyAHKAJYQbDozwAQ/S8ACyAHQQI2AlQgB0HQ5c8ANgJQIAdCAjcCXCAHQTs2AsABIAdBOzYCuAEgByAHQbQBajYCWCAHIAdBzAFqNgK8ASAHIAdBsAFqNgK0AQsgB0HQAGpB4OXPABDvLAALIBMgAUGY/s4AELA7AAsgBCAJKAIcQaCDzgAQ/S8ACyAaKAK4ASIBQQhHBEAgACAaKQK8ATcCBCAAQRRqIBpBzAFqKAIANgIAIABBDGogGkHEAWopAgA3AgAgACABNgIAICsQwiAgGkEcahDnIAwGCyAjQbgFaiEjIBpB8ABqEMIgIBooAiAiASAaKAIoRw0ACwsgGkEcahDnICACQQFqIgIgJkcNAQwCCwtB6OnPABCyOwALIABBCDYCAAsgGkHQAWokAA8LIBMgF0Go/s4AELA7AAurBAECfyMAQeAAayIEJAAgBCACNgIEAkACQCACQYACRgRAIARBIGogASADQQR0QfABcSIFQQF0aiICQRhqKQEANwMAIARBGGogAkEQaikBADcDACAEQRBqIAJBCGopAQA3AwAgBCACKQEANwMIIANB/wFxRQ0CIAVBEGsiAkGBAk8NASAEQUBrIAEgAkEBdGoiAkEYaikBADcDACAEQThqIAJBEGopAQA3AwAgBEEwaiACQQhqKQEANwMAIAQgAikBADcDKEEAIQIDQCAEQQhqIAJqIgMgAy8BACAEQShqIAJqLwEAazsBACACQQJqIgJBIEcNAAsMAgsgBEEANgIoQQAgBEEEakG88dEAIARBKGpBxPLRABCvKwALIARBADYCOCAEQQE2AiwgBEGA8NEANgIoIARCBDcCMCAEQShqQZTy0QAQ7ywACyAEQUBrIAFB+ANqKQEANwMAIARBOGogAUHwA2opAQA3AwAgBEEwaiABQegDaikBADcDACAEIAEpAeADNwMoQQAhAgJAAkADQCAEQQhqIAJqIgEvAQAiA0UNASAEQShqIAJqIgEvAQAiBUUNAiAAIAAqAgAgA0ECdEHMhuMAaioCACAFQQJ0QcyG4wBqKgIAk5M4AgAgAEEEaiEAIAJBAmoiAkEgRw0ACyAEQeAAaiQADwsgBEEANgJIIAEgBEHIAGpBpPLRABCNKwALIARBADYCSCABIARByABqQbTy0QAQjSsAC/8PAQV/IwBBEGsiBSQAAkACQAJAAkACQAJAAkACQCACQQFrDggCAwEEAQEBBQALIAJBEEYNBQtB4PHQAEEbQfzx0AAQnykACyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINBCABQRVPBEAgBUEMaiEDAkAgAg0AAkACQAJAIABBAWogACADKAIAIgQoAgAoAgARAgAiBkEATgRAQQIhAiABQQJGDQEgBCgCACEEA0AgACACaiIHIAdBAWsgBCgCABECAEEASA0CIAEgAkEBaiICRw0ACwwCC0ECIQIgAUECRg0AIAQoAgAhBANAIAAgAmoiByAHQQFrIAQoAgARAgBBAE4NASABIAJBAWoiAkcNAAsMAQsgASACRw0BCyAGQQBODQEgAUEBdiEDIAAgAWpBAWshAgNAIAAtAAAhASAAIAItAAA6AAAgAiABOgAAIAJBAWshAiAAQQFqIQAgA0EBayIDDQALDAELIAAgAUEAIAFBAXJnQQF0QT5zIAMQ5Q4LDAULQQEhAgNAIAAgACACaiAFQQxqEMAeIAEgAkEBaiICRw0ACwwECyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINAyABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBAmoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQJqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBAmohAiADKAIAIQgDQCACQQJqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELIAdBAE4NASABQQF2IQIgAUEBdCAAakECayEEA0AgAC8AACEBIAAgBC8AADsAACAEIAE7AAAgBEECayEEIABBAmohACACQQFrIgINAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC2DgsMBAsgAUEBdCEBQQIhAgNAIAAgACACaiAFQQxqEL8eIAEgAkECaiICRw0ACwwDCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINAiABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBBGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQRqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBBGohAiADKAIAIQgDQCACQQRqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELIAdBAE4NASABQQF2IQIgAUECdCAAakEEayEEA0AgACgAACEBIAAgBCgAADYAACAEIAE2AAAgBEEEayEEIABBBGohACACQQFrIgINAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC5DgsMAwsgAUECdCEBQQQhAgNAIAAgACACaiAFQQxqEL4eIAEgAkEEaiICRw0ACwwCCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINASABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBCGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQQhqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBCGohAiADKAIAIQgDQCACQQhqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELQQAhAiAHQQBODQEgAUEBdiEDIAFBA3QgAGpBCGshAQNAQQAhBANAIAAgBGoiBigAACEHIAYgASAEaiIGKAAANgAAIAYgBzYAACAEQQRqIgRBCEcNAAsgAEEIaiEAIAFBCGshASACQQFqIgIgA0cNAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC4DgsMAgsgAUEDdCEBQQghAgNAIAAgACACaiAFQQxqEMEeIAEgAkEIaiICRw0ACwwBCyAFIAM2AgQgBSAFQQRqNgIIIAUgBUEIajYCDCABQQJJIgINACABQRVPBEAgBUEMaiEGAkAgAg0AAkACQAJAIABBEGoiAiAAIAYoAgAiAygCACgCABECACIHQQBOBEBBAiEEIAFBAkYNASADKAIAIQgDQCACQRBqIgMgAiAIKAIAEQIAQQBIDQIgAyECIAEgBEEBaiIERw0ACwwCC0ECIQQgAUECRg0AIABBEGohAiADKAIAIQgDQCACQRBqIgMgAiAIKAIAEQIAQQBODQEgAyECIAEgBEEBaiIERw0ACwwBCyABIARHDQELQQAhAiAHQQBODQEgAUEBdiEDIAFBBHQgAGpBEGshAQNAQQAhBANAIAAgBGoiBigAACEHIAYgASAEaiIGKAAANgAAIAYgBzYAACAEQQRqIgRBEEcNAAsgAEEQaiEAIAFBEGshASACQQFqIgIgA0cNAAsMAQsgACABQQAgAUEBcmdBAXRBPnMgBhC3DgsMAQsgAUEEdCEBQRAhAgNAIAAgACACaiAFQQxqEIwZIAEgAkEQaiICRw0ACwsgBUEQaiQAC5sFAQN/IwBBMGsiAiQAAkAgACABRwRAA0BBASEEAkACQAJAAkACQCAAKAIAIgMtADBBF2sOCgcEBAcABAECBAMECwJAAkACQAJAIAMoAjQiAy0AMEEXaw4KCgcHCgAHAQIHAwcLIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQYMCQsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNBQwICyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0EDAcLIAIgA0E0ahDDNCACKAIAIgMgAyACKAIEQQJ0ahC6CkUNAwwGCwJAAkACQAJAIAMoAjgiAy0AMEEXaw4KCQYGCQAGAQIGAwYLIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQUMCAsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNBAwHCyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0DDAYLIAJBCGogA0E0ahDDNCACKAIIIgMgAyACKAIMQQJ0ahC6CkUNAgwFCwJAAkACQAJAIAMoAjQiAy0AMEEXaw4KCAUFCAAFAQIFAwULIAJCgICAgBA3AiQgAiADQTRqNgIsIAJBJGoQtxRFDQQMBwsgAkKAgICAEDcCJCACIANBOGo2AiwgAkEkahC3FEUNAwwGCyACQoCAgIAQNwIkIAIgA0E0ajYCLCACQSRqELcURQ0CDAULIAJBEGogA0E0ahDDNCACKAIQIgMgAyACKAIUQQJ0ahC6CkUNAQwECyACQRhqIANBNGoQwzQgAigCGCIDIAMgAigCHEECdGoQugoNAwsgAEEEaiIAIAFHDQALC0EAIQQLIAJBMGokACAEC7YWAQJ/AkAgACkDAEICUgRAIAAoApgFIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZgFahDZIQsgACgCnAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAVqEK4gCyAAQcAEahC8KiAAQcgEahDXKSAAQbABaiEBAkACQAJAAkBBAiAAKAKQAiICQYCAgIB4cyACQQBOGw4CAQIACyAAQZACahDeOyAAQZwCahDeOyAAKAKoAiICEJ0sIAJB4ABBCBD4OiAAKAKsAiICEJ0sIAJB4ABBCBD4OgwCCyAAQZQCahDeOwwBCyAAQZQCahDeOyAAKAKgAiICEJ0sIAJB4ABBCBD4OgsgASgCAEGAgICAeEcEQCAAQcgBakEIEO4oIAEQ3jsgAEG8AWpBBEEIEOAeIABBgAJqEOM8CwJAIAAoAswCRQ0AIAAoAtACIgFFDQAgAEHcAmogACgC1AIgACgC2AIgASgCEBEBAAsCQCAAKALgAkUNACAAKALkAiIBRQ0AIABB8AJqIAAoAugCIAAoAuwCIAEoAhARAQALIAAoAsACQYCAgIB4RwRAIABBwAJqQQRBIBDgHgsgAEHoA2oQhTAgAEH0A2oQhTAgABDSISAAQaAFahDDHCAAQfQEakEEQQgQ4B4gAEGABWoQnTwgAEGMBWoQnTwgAEGAA2oiARCHGSABQQhBiAEQ4B4gAEGQA2oQ7ScgAEGIBGoQxyggAEHQBGoQ8SYMAQsCQAJAAkACQAJAAkACQCAAQQhqIgEoAgBBAWsOBwQFAgQFAwABCyABKAKIBSICIAIoAgAiAkEBazYCACACQQFGBEAgAUGIBWoQ2SELIAEoAowFIgIgAigCACICQQFrNgIAIAJBAUYEQCABQYwFahCuIAsgAUGwBGoQvCogAUG4BGoQ1ykgAUHwAGoQvCogASgCYEGAgICAeEcEQCABQRhqEJ4sCyABKAKsASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGsAWoQ2SELAkAgASgCeEUNACABKAJ8IgJFDQAgAUGIAWogASgCgAEgASgChAEgAigCEBEBAAsCQCABKAKMAUUNACABKAKQASICRQ0AIAFBnAFqIAEoApQBIAEoApgBIAIoAhARAQALIAEoAqABQYCAgIB4RwRAIAFBoAFqQQRBIBDgHgsgAUHYA2oQhTAgAUHkA2oQhTACQCABKAKoAkUNACABKAKsAiICRQ0AIAFBuAJqIAEoArACIAEoArQCIAIoAhARAQALAkAgASgCvAJFDQAgASgCwAIiAkUNACABQcwCaiABKALEAiABKALIAiACKAIQEQEACyABQdACahCFMCABQdwCahCFMCABQZAFahDDHCABQeQEakEEQQgQ4B4gAUHwBGoQnTwgAUH8BGoQnTwgAUHwAmoiAhCHGSACQQhBiAEQ4B4gAUGAA2oQ7ScgAUH4A2oQxyggASgCwARFDQUgASgCxAQiAgRAIAFB0ARqIAEoAsgEIAEoAswEIAIoAhARAQALIAEoAtQEIgJFDQUgAUHgBGogASgC2AQgASgC3AQgAigCEBEBAAwFCyABKAKcBCICIAIoAgAiAkEBazYCACACQQFGBEAgAUGcBGoQ2SELIAEoAqAEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQaAEahCuIAsgAUHoA2oQvCogAUHwA2oQ1ykgAUHwAGoQvCogASgCYEGAgICAeEcEQCABQRhqENEsCyABKAKEASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGEAWoQ2SELIAEoAnhBgICAgHhHBEAgAUH4AGpBBEEgEOAeCyABQZADahCFMCABQZwDahCFMCABQYACahCFMCABQYwCahCFMCABQaQEahDDHCABQfgDakEEQQgQ4B4gAUGEBGoQnTwgAUGQBGoQnTwgAUGoAmoiAhCHGSACQQhBiAEQ4B4gAUG4AmoQ7ScgAUGwA2oQxygMBAsgASgC8AQiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB8ARqENkhCyABKAL0BCICIAIoAgAiAkEBazYCACACQQFGBEAgAUH0BGoQriALIAFBoARqELwqIAFBqARqENcpIAFBkAFqELwqIAEoAoABQYCAgIB4RwRAIAFBOGoQgy0LIAEoAqQBIgIgAigCACICQQFrNgIAIAJBAUYEQCABQaQBahDZIQsgASgCmAFBgICAgHhHBEAgAUGYAWpBBEEgEOAeCyABQcgDahCFMCABQdQDahCFMCABQcACahCFMCABQcwCahCFMCABQfgEahDDHCABQcwEakEEQQgQ4B4gAUHYBGoQnTwgAUHkBGoQnTwgAUHgAmoiAhCHGSACQQhBiAEQ4B4gAUHwAmoQ7ScgAUHoA2oQxygMAwsgASgCiAUiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBiAVqENkhCyABKAKMBSICIAIoAgAiAkEBazYCACACQQFGBEAgAUGMBWoQriALIAFBsARqELwqIAFBuARqENcpIAFB8ABqELwqIAEoAmBBgICAgHhHBEAgAUEYahCeLAsgASgCrAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBrAFqENkhCwJAIAEoAnhFDQAgASgCfCICRQ0AIAFBiAFqIAEoAoABIAEoAoQBIAIoAhARAQALAkAgASgCjAFFDQAgASgCkAEiAkUNACABQZwBaiABKAKUASABKAKYASACKAIQEQEACyABKAKgAUGAgICAeEcEQCABQaABakEEQSAQ4B4LIAFB2ANqEIUwIAFB5ANqEIUwIAFBuAFqENIhIAFBkAVqEMMcIAFB5ARqQQRBCBDgHiABQfAEahCdPCABQfwEahCdPCABQfACaiICEIcZIAJBCEGIARDgHiABQYADahDtJyABQfgDahDHKCABQcAEahDxJgwCCyABKALABCICIAIoAgAiAkEBazYCACACQQFGBEAgAUHABGoQ2SELIAEoAsQEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQcQEahCuIAsgAUGABGoQvCogAUGIBGoQ1ykgAUGAAWoQvCogASgCcEGAgICAeEcEQCABQShqENIsCyABKAKUASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGUAWoQ2SELIAEoAogBQYCAgIB4RwRAIAFBiAFqQQRBIBDgHgsgAUGoA2oQhTAgAUG0A2oQhTAgAUGgAmoQhTAgAUGsAmoQhTAgAUHIBGoQwxwgAUGcBGpBBEEIEOAeIAFBqARqEJ08IAFBtARqEJ08IAFBwAJqIgIQhxkgAkEIQYgBEOAeIAFB0AJqEO0nIAFByANqEMcoDAELIAEoAuwEIgIgAigCACICQQFrNgIAIAJBAUYEQCABQewEahDZIQsgASgC8AQiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFB8ARqEK4gCyABQbgEahC8KiABQcAEahDXKSABQZABahC8KiABKAKAAUGAgICAeEcEQCABQThqENMsCyABKAKkASICIAIoAgAiAkEBazYCACACQQFGBEAgAUGkAWoQ2SELIAEoApgBQYCAgIB4RwRAIAFBmAFqQQRBIBDgHgsgAUHgA2oQhTAgAUHsA2oQhTAgAUHAAmoQhTAgAUHMAmoQhTAgAUH0BGoQwxwgAUHIBGpBBEEIEOAeIAFB1ARqEJ08IAFB4ARqEJ08IAFB+AJqIgIQhxkgAkEIQYgBEOAeIAFBiANqEO0nIAFBgARqEMcoCwsgACgCsAUiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBsAVqEIgcCwu2BAIGfwF+IwBBkAJrIgIkACACQZgBaiABKAJQIgZBA3YgBkEHcUEAR2oiBEHAACABKAI4IgVBAWsiA0EAIAMgBU0brXmnayIFQf8BcSIDQQN2IAVBB3FBAEdqQQFqbCIHIANBAWogBGwiBCAEIAdJG0EAQQFBARCgGCACKAKcASEEIAIoApgBQQFHBEAgAkEANgIMIAIgAigCoAEiAzYCCCACIAQ2AgQgBAR/IAMFIAJBBGpBxJDOABCpGSACKAIICyAFOgAAIAJBDGpBATYCACACQSBqQQE2AgAgAiACKQIENwMYIAJBKGoiBEEAQcAA/AsAIAJBADYCeCACQQA6ACQgAkIANwMQIAIgBToAhAEgAkIANwJ8IAJCADcDaCACQn83A3ACQCAGBEAgASgCTCEFIAZBA3QhBgNAIAIoAnwhAwJAAkAgBSkDACIIIAIpA2hSBEAgA0EHSwRAIAJBEGoQvQ0LIAIgCDcDaCACQQE2AnwMAQsgAiADQQFqIgM2AnwgA0EISw0BCyACKAJ4IgNBB0sNAyAEIANBA3RqIAg3AwAgAiACKAJ4QQFqIgM2AnggA0EIRw0AIAJBEGoQyicLIAVBCGohBSAGQQhrIgYNAAsLIAFBADYCUCACQZgBaiIBIAJBEGpB+AD8CgAAIAJBjAFqIgMgARD9ECAAQQRqIAMQ5xUgAEEINgIAIAJBkAJqJAAPCyADQQhB6KLOABDDIQALIAQgAigCoAFBtJDOABD9LwALswQBBX8jAEHgAGsiAiQAIAJBCGogASgCPCABKAJAIgMoAghBAWtBeHFqQQhqIAMoAjgRAAACQAJAAkACQAJAIAIoAggEQCACQTBqIAJBGGopAgA3AwAgAkEoaiACQRBqKQIANwMAIAIgAikCCDcDIEHAACEEIAEoAiAiBUEEdiAFQQ5xQQBHaiIDQcD///8BcUFAayADIANBP3EbIgNBwAAQ0TRFDQQgAwRAIANBwAAQrTYiBEUNBAsgBUEBdiEGIAJCADcCRCACIAQ2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAGEOcQCyAFQQJPBEAgASgCHCEBIAZBAXQhBUEAIQMDQAJAIAEuAQAiBCACKAIwTw0AIAIoAiQgAigCLCAEaiIEQQN2ai0AACAEQQdxdkEBcQ0AIAIgAkE4ahCGPSADQQN2IgQgAigCBCIGSQRAIAIoAgAgBGoiBCAELQAAQX4gA0EHcXdxOgAADAELIAQgBkHU5oQBEMMhAAsgAUECaiEBIANBAWohAyAFQQJrIgUNAAsLIAJBzABqIgEgAkE4aiIDEIcUIAAgARDhJyADEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC7MEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIDKAIIQQFrQXhxakEIaiADKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBCABKAIgIgVBBXYgBUEccUEAR2oiA0HA////AHFBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgRFDQQLIAVBAnYhBiACQgA3AkQgAiAENgJAIAIgAzYCPCACQcAANgI4IAEoAiRFDQEgAkE4aiABQSRqEJUvDAILIAAgAUEkakEAIAEoAiQbEO4lDAQLIAJBOGogBhDnEAsgBUEETwRAIAEoAhwhASAGQQJ0IQVBACEDA0ACQCABKAIAIgQgAigCME8NACACKAIkIAIoAiwgBGoiBEEDdmotAAAgBEEHcXZBAXENACACIAJBOGoQhj0gA0EDdiIEIAIoAgQiBkkEQCACKAIAIARqIgQgBC0AAEF+IANBB3F3cToAAAwBCyAEIAZB1OaEARDDIQALIAFBBGohASADQQFqIQMgBUEEayIFDQALCyACQcwAaiIBIAJBOGoiAxCHFCAAIAEQ4ScgAxDPLyACKAIgIgAgACgCACIAQQFrNgIAIABBAUcNAiACQSBqEPseDAILQcAAIAMQoz0AC0GU54QBQSkgAkHMAGpB8OiEAUHA54QBENUeAAsgAkHgAGokAAuzBAEFfyMAQeAAayICJAAgAkEIaiABKAI8IAEoAkAiAygCCEEBa0F4cWpBCGogAygCOBEAAAJAAkACQAJAAkAgAigCCARAIAJBMGogAkEYaikCADcDACACQShqIAJBEGopAgA3AwAgAiACKQIINwMgQcAAIQQgASgCICIFQQR2IAVBDnFBAEdqIgNBwP///wFxQUBrIAMgA0E/cRsiA0HAABDRNEUNBCADBEAgA0HAABCtNiIERQ0ECyAFQQF2IQYgAkIANwJEIAIgBDYCQCACIAM2AjwgAkHAADYCOCABKAIkRQ0BIAJBOGogAUEkahCVLwwCCyAAIAFBJGpBACABKAIkGxDuJQwECyACQThqIAYQ5xALIAVBAk8EQCABKAIcIQEgBkEBdCEFQQAhAwNAAkAgAS8BACIEIAIoAjBPDQAgAigCJCACKAIsIARqIgRBA3ZqLQAAIARBB3F2QQFxDQAgAiACQThqEIY9IANBA3YiBCACKAIEIgZJBEAgAigCACAEaiIEIAQtAABBfiADQQdxd3E6AAAMAQsgBCAGQdTmhAEQwyEACyABQQJqIQEgA0EBaiEDIAVBAmsiBQ0ACwsgAkHMAGoiASACQThqIgMQhxQgACABEOEnIAMQzy8gAigCICIAIAAoAgAiAEEBazYCACAAQQFHDQIgAkEgahD7HgwCC0HAACADEKM9AAtBlOeEAUEpIAJBzABqQfDohAFBwOeEARDVHgALIAJB4ABqJAALsgQBBX8jAEHgAGsiAiQAIAJBCGogASgCPCABKAJAIgMoAghBAWtBeHFqQQhqIAMoAjgRAAACQAJAAkACQAJAIAIoAggEQCACQTBqIAJBGGopAgA3AwAgAkEoaiACQRBqKQIANwMAIAIgAikCCDcDIEHAACEEIAEoAiAiBUEGdiAFQThxQQBHaiIDQcD//z9xQUBrIAMgA0E/cRsiA0HAABDRNEUNBCADBEAgA0HAABCtNiIERQ0ECyAFQQN2IQYgAkIANwJEIAIgBDYCQCACIAM2AjwgAkHAADYCOCABKAIkRQ0BIAJBOGogAUEkahCVLwwCCyAAIAFBJGpBACABKAIkGxDuJQwECyACQThqIAYQ5xALIAVBCE8EQCABKAIcIQEgBkEDdCEFQQAhAwNAAkAgASgCACIEIAIoAjBPDQAgAigCJCACKAIsIARqIgRBA3ZqLQAAIARBB3F2QQFxDQAgAiACQThqEIY9IANBA3YiBCACKAIEIgZJBEAgAigCACAEaiIEIAQtAABBfiADQQdxd3E6AAAMAQsgBCAGQdTmhAEQwyEACyABQQhqIQEgA0EBaiEDIAVBCGsiBQ0ACwsgAkHMAGoiASACQThqIgMQhxQgACABEOEnIAMQzy8gAigCICIAIAAoAgAiAEEBazYCACAAQQFHDQIgAkEgahD7HgwCC0HAACADEKM9AAtBlOeEAUEpIAJBzABqQfDohAFBwOeEARDVHgALIAJB4ABqJAALhhEBCH8jAEEQayIIJAAgCEEEaiEFIwBBEGsiAyQAAkAgACgCCCIGIAAoAgRJBEAgBUEAOgAAIAAgBkEBajYCCCAFIAAoAgAgBmotAAA6AAEMAQsgA0EENgIEIAUgACADQQRqEJ0pCyADQRBqJAACfyAILQAEQQFGBEAgCCgCCAwBCwJAAkACQAJAAkACQAJAAkACQAJAIAgtAAUiBUHtAE0EQCAFQeEATQRAIAVBIkYNAiAFQS9GDQQgBUHcAEYNAwwLCyAFQeIAaw4FBAoKCgUKCyAFQe4Aaw4IBQkJCQYJBwgJCyACKAIIIgAgAigCAEYEQCACQejGiAEQqRkLIAIoAgQgAGpBIjoAACACIABBAWo2AghBAAwJCyACKAIIIgAgAigCAEYEQCACQfjGiAEQqRkLIAIoAgQgAGpB3AA6AAAgAiAAQQFqNgIIQQAMCAsgAigCCCIAIAIoAgBGBEAgAkGIx4gBEKkZCyACKAIEIABqQS86AAAgAiAAQQFqNgIIQQAMBwsgAigCCCIAIAIoAgBGBEAgAkGYx4gBEKkZCyACKAIEIABqQQg6AAAgAiAAQQFqNgIIQQAMBgsgAigCCCIAIAIoAgBGBEAgAkGox4gBEKkZCyACKAIEIABqQQw6AAAgAiAAQQFqNgIIQQAMBQsgAigCCCIAIAIoAgBGBEAgAkG4x4gBEKkZCyACKAIEIABqQQo6AAAgAiAAQQFqNgIIQQAMBAsgAigCCCIAIAIoAgBGBEAgAkHIx4gBEKkZCyACKAIEIABqQQ06AAAgAiAAQQFqNgIIQQAMAwsgAigCCCIAIAIoAgBGBEAgAkHYx4gBEKkZCyACKAIEIABqQQk6AAAgAiAAQQFqNgIIQQAMAgsgASEJIAIhAyMAQSBrIgQkAAJ/AkACQAJAIAAiBigCBCICIAAoAggiAE8EQAJAIAIgAGtBA00EQCAGIAI2AgggBEEENgIUIARBDGogBiAEQRRqEJwpIAIhBQwBCyAGIABBBGoiBTYCCCAGKAIAIABqIgAtAAFBAXRB+MeIAWovAQAgAC0AAEEBdEH4y4gBai8BAHLBQQh0IAAtAAJBAXRB+MuIAWouAQByIAAtAANBAXRB+MeIAWouAQByIgBBAE4EQCAEQQA7AQwgBCAAOwEODAELIARBDDYCFCAEQQxqIAYgBEEUahCcKQsgBC8BDEEBRg0DAn8CQAJAAkACQAJAAkACQAJAIAlBACAELwEOIgBBgPgDcUGAuANGG0UEQCAAQYDIAGpB//8DcUGA+ANPDQEgACEBDAILIARBFDYCFCAGIARBFGoQrCsMDQsgBigCACEKA0AgBEEUaiIHIAYQviYgBC0AFEEBRg0LIAQtABVB3ABHDQUgBiAFQQFqNgIIIAcgBhC+JiAELQAUDQsgBC0AFUH1AEcNBCACIAVBAmoiAUkNCgJAIAIgAWtBA00EQCAGIAI2AgggBEEENgIUIARBDGogBiAHEJwpIAIhBQwBCyAGIAVBBmoiBTYCCCABIApqIgEtAAFBAXRB+MeIAWovAQAgAS0AAEEBdEH4y4gBai8BAHLBQQh0IAEtAAJBAXRB+MuIAWouAQByIAEtAANBAXRB+MeIAWouAQByIgFBAE4EQCAEQQA7AQwgBCABOwEODAELIARBDDYCFCAEQQxqIAYgBEEUahCcKQsgBC8BDA0MIAQvAQ4iAUGAQGtB//8DcUH/9wNLDQIgCQ0DIAMoAgAgAygCCCIHa0EDTQR/IAMgB0EEEOAoIAMoAggFIAcLIAMoAgRqIgdB7QE6AAAgB0ECaiAAQT9xQYABcjoAACAHIABBBnZBL3FBgAFyOgABIAMgAygCCEEDajYCCCABIgBBgMgAakH//wNxQYD4A08NAAsLIAFB//8DcUGAAUkNBCADKAIAIAMoAggiAGtBA00EfyADIABBBBDgKCADKAIIBSAACyADKAIEaiECIAFB//8DcUGAEE8NBSABQQZ2QUByIQBBAgwGCyABQYDIAGpB//8DcSAAQYDQAGpB//8DcUEKdHIiBUGAgARqIQIgAygCACADKAIIIgBrQQNNBH8gAyAAQQQQ4CggAygCCAUgAAsgAygCBGoiACACQRJ2QfABcjoAACAAQQNqIAFBP3FBgAFyOgAAIAAgBUEGdkE/cUGAAXI6AAIgACACQQx2QT9xQYABcjoAASADIAMoAghBBGo2AghBAAwKCyAEQRQ2AhQgBiAEQRRqEKwrDAkLIAlFBEAgAygCACADKAIIIgFrQQNNBH8gAyABQQQQ4CggAygCCAUgAQsgAygCBGoiAUHtAToAACABQQJqIABBP3FBgAFyOgAAIAEgAEEGdkEvcUGAAXI6AAEgAyADKAIIQQNqNgIIIAZBACADEMEKDAkLIAYgBUECajYCCCAEQRc2AhQgBiAEQRRqEKwrDAgLIAlFBEAgAygCACADKAIIIgFrQQNNBH8gAyABQQQQ4CggAygCCAUgAQsgAygCBGoiAUHtAToAACABQQJqIABBP3FBgAFyOgAAIAEgAEEGdkEvcUGAAXI6AAEgAyADKAIIQQNqNgIIQQAMCAsgBiAFQQFqNgIIIARBFzYCFCAGIARBFGoQrCsMBwsgAygCCCIAIAMoAgBGBEAgA0Hox4gBEKkZCyADKAIEIABqIAE6AAAgAyAAQQFqNgIIQQAMBgsgAiABQQZ2QT9xQYABcjoAASABQYDgA3FBDHZBYHIhAEEDCyEFIAIgADoAACACIAVqQQFrIAFBP3FBgAFyOgAAIAMgAygCCCAFajYCCEEADAQLIAAgAkHYxogBEK87AAsgASACQdjGiAEQrzsACyAEKAIYDAELIAQoAhALIARBIGokAAwBCyAIQQw2AgQgACAIQQRqEKwrCyAIQRBqJAAL3gQBBH8jAEEQayIEJAAgACgCmAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAFqEJcVCyAAKAKcASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGcAWoQ+CMLIAQgAEHQAGoiASAAKAJcEPgYIAEQ6TsgACgCgAFBgICAgHhHBEAgAEGAAWoQ3jsLIAAoAowBQYCAgIB4RwRAIABBjAFqEOo7CwJAIAApAwBCAlENACAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEJcVCwJAIAAoAkAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEFAaxDbHgsCQCAAKAIARQRAIAAoAhAiAUGEAUkNASABEPIfDAELIABBCGoQvSoLIAAoAjBBgICAgHhHBEAgAEEwaiIBEIEjIAFBBEEIEOAeCyAAKAJEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBxABqEIEsCwJAAkACQEEBIAAoAmAiAUH/////B2ogAUGAgICAeE0bQQFrDgIAAQILIAAoAnQhASAAKAJ4IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAnwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB/ABqEPgjCyAAQeAAaiIBKAIAQYCAgIB4Rg0BIAEQ0C4gARDqOwwBCyAAKAJkIQEgACgCaCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAkUNACABIAIgAygCCBD4OgsgAEGoAWoiABDeIyAAEOA7IARBEGokAAu8BAEOfyMAQRBrIgokAAJAAkAgBCADIARqIgdNBEAgByAAKAIEIgtLDQEgACgCACEMIAEoAgwiBSAEaiIGIAEoAgQiCEsEQCABIAhBAXQiCCAGEN8qIgYgBiAISRsQ6BkgASgCDCEFCyAEBEAgASgCCCAFaiADIAxqIAT8CgAACyABIAEoAgwgBGo2AgwgAyAHSQRAIAFBEGohDyAAKAIMIRAgACgCCCERIAAoAhAiDSADIAMgDUkbIQ4DQAJAIAMgC0cEQCADIAxqLQAAIQYgCkEIaiARELAuIAooAggiBCAKKAIMIglHBEAgA0EBaiEIQQAhAEEAIQUDQCAELQAAIAZGDQMgAEHMAWohACAFQQFqIQUgBEEIaiIEIAlHDQALC0HYqIcBQRVB8KiHARDLJAALIAsgC0HIqIcBEMMhAAsCQCADIA5HBEAgBSABKAIoIgRPDQYgECADQQJ0aigCACEDIAEoAiQgAGpB2ABqKAIAIQYgASgCHCIEQQRqIgkgASgCFCISSwR/IA8gEkEBdCIEIAkQ3yoiCSAEIAlLGxDoGSABKAIcBSAECyABKAIYaiAGNgAAIAEgASgCHEEEajYCHCAFIAEoAigiBEkNASAFIARBoKmHARDDIQALIA4gDUGAqYcBEMMhAAsgASgCJCAAaiACIAMgA0EBahDYGyAIIgMgB0cNAAsLIApBEGokAA8LIAMgB0G4qIcBELE7AAsgByALQbiohwEQsDsACyAFIARBkKmHARDDIQALiQUCBn8EfiMAQbABayIDJAAgASgCDCgCECACQQR0aiIEKQMAIQkgBCkDCCEKIAEoAggiBCgCACgCACIFKQMAIQsgAyAFKQMIIgw3AzggAyALNwMwIAMgCjcDKCADIAk3AyAgA0EANgIcIAMgCSAKIAsgDCADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AnwgA0GskP8ANgJ4IANCAjcChAEgA0GEDDYCbCADQYQMNgJkIAMgA0HgAGoiBjYCgAEgAyADQTBqNgJoIAMgA0EgajYCYCADQdAAaiICIANB+ABqIgcQmQ4gA0GkAWogA0HcAGooAgA2AgAgA0GIgICAeDYCTCADIANB1ABqIgUpAgA3ApwBIAMgAykCTDcClAEgA0EBNgKQASADQZABaiIIQQRyEIgRIAQoAgQhASADIAo3A2ggAyAJNwNgIANBBDYCfCADQcyR/wA2AnggA0IENwKEASADQYQMNgKsASADQfQLNgKkASADIAFBAWo2AqABIANBuwc2ApwBIAMgATYCmAEgA0HMATYClAEgA0Ggkf8ANgKQASADIAg2AoABIAMgBjYCqAEgAiAHEJkOIANBOGogBSgCADYCACADQYKAgIB4NgJMIAMgAykCTDcDMCADKQJYDAELIANBkAFqIAMpAwAiCSADKQMIIgogBCgCCC0AABCtDiADKAKQAUGTgICAeEYNASADQThqIANBmAFqKAIANgIAIAMgAykCkAE3AzAgAykCnAELIQkgACADKQMwNwIAIAAgCTcCDCAAQQhqIANBOGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCjcDCCAAIAk3AwALIANBsAFqJAAL5gQCBX8BfiMAQdAAayICJAAgAkEQaiABKAIEIgNBCGoiBRDDNAJAAkACQCACKAIQIgQgBCACKAIUQQJ0ahC6CkUEQCABKAIAIgUgBSgCACIEQQFqNgIAIARBAEgNAiADIAMoAgAiBEEBajYCACAEQQBIDQIgASgCCCIBBEAgASABKAIAIgRBAWo2AgAgBEEASA0DCyAAIAE2AgwgACADNgIIIAAgBTYCBCAAQQY2AgAMAQsgAkEIaiAFEMM0IAJBIGoiBCACKAIIIgUgBSACKAIMQQJ0ahClGyACQTBqIgUgA0EQahCxLiACIAQQthkgAigCBCEEIAIoAgAhBkEwQQgQrTYiA0UNAiADIAY2AgggA0KBgICAEDcDACADIAIpAzA3AxAgAyAENgIMIANBGGogAkE4aikDADcDACADQSBqIAJBQGspAwA3AwAgA0EoaiACQcgAaikDADcDACACQQA2AjAgAkEAOwE0IAJBGGoiBCADNgIAIARBAToABSAEIAUtAAQ6AAQCQCAFKAIAIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAUQ+CMLIAEoAgAiASABKAIAIgNBAWo2AgAgA0EASA0BIAUgASAEEO0BIAJBKGoiASACQTxqIgMoAgA2AgAgAiACKQI0NwMgIAIoAjAiBEEIRwRAIAIpA0AhByADIAEoAgA2AgAgAiACKQMgNwI0IAIgBzcDQCACIAQ2AjAgACAFEMgmDAELIAAgAikDIDcCBCAAQQY2AgAgAEEMaiACQShqKAIANgIACyACQdAAaiQADwsAC0EIQTAQoz0AC54IAQd/IwBBIGsiCCQAQf3/AyELAn8CQCADRQ0AIAIgA2oiCSADSQ0AQQEgBiAJSQ0BGkH9/wMgBSACQQF0aiICLwAAIgUgBUGAsL9/c0GAkLx/SRshCyADQQFrIQcgAkECagwBC0EBCyECIAIgB0EBdGohAwJAIARFBEAgCCADNgIcIAggAjYCGCAIQRBqIAhBGGoQpSlBACEGIAgvARBBAXFFDQEgAUEEaiEJIAFByABqIQogCC8BEiEDQQEhAgNAQf3/AyADQf//A3EiAyADQYCwv39zQYCQvH9JGyIFAn8gASgCXCIDLQAsQQFGIAVB/x9LcUUEQCAFQQZ2IgcgAygCCEkEQCADKAIEIAdBAXRqLwAAIAVBP3FqDAILIAMoAhRBAWsMAQsgAyAFEMAuCyIFIAMoAhQiB0kEfyADKAIQIAVBAnRqKAAABSAECyADKAIAIAUgB0kbIgwQoy8hDQJ/IAooAgAiB0ESSQRAIAchAyAKIQVBESEHIAkMAQsgASgCBCEDIAkhBSABKAIICyEEIAMgB0YEfyABEPwfIAEoAgghBCAJIQUgASgCBAUgAwtBAnQgBGogDTYCACAFIAUoAgBBAWo2AgAgBiACIAwQ+zobIQYgAkEBaiECIAhBCGogCEEYahClKSAILwEKIQMgCC8BCEEBcQ0ACwwBCyMAQUBqIgckACAHIAM2AjAgByACNgIsIAdBNGoiAkEBNgIEIAIgB0EsaiIDKAIEIAMoAgBrQQF2IgM2AgggAiADNgIAIAdBIGogASIEIAcoAjQQnxggBygCICAHKAIkEIAtIAFByABqIQlBESEBAkACQAJ/IAQoAkgiAkERTQRAIARBBGohBiAJIQMgAgwBCyAEQQRqIQMgBCgCCCEGIAIhASAEKAIECyICIAFJBEAgBiACQQJ0aiEFA0AgB0EYaiAHQSxqEKUpIAcvARhBAXFFDQIgBUH9/wMgBy8BGiIGIAZBgLC/f3NBgJC8f0kbELI9NgIAIAVBBGohBSABIAJBAWoiAkcNAAsgASECCyADIAI2AgAgByAHKQIsNwI0IAdBEGogB0E0ahClKSAHLwEQQQFxRQ0BIARBBGohAyAHLwESIQUDQEH9/wMgBUH//wNxIgEgAUGAsL9/c0GAkLx/SRsQsj0hCgJ/IAkoAgAiBkESSQRAIAYhBSADIQFBESEGIAkMAQsgBCgCBCEFIAQoAgghASADCyECIAUgBkYEQCAEEPwfIAQoAgQhBSADIQIgBCgCCCEBCyABIAVBAnRqIAo2AgAgAiACKAIAQQFqNgIAIAdBCGogB0E0ahClKSAHLwEKIQUgBy8BCEEBcQ0ACwwBCyADIAI2AgALIAdBQGskAEEAIQYLIAAgBjYCBCAAIAs2AgAgCEEgaiQAC/8EAgd/BH4jAEGgAWsiAyQAIAEoAgwoAhAgAkECdGooAgAhBSABKAIIIgYoAgAoAgAiBCkDACEKIAMgBCkDCCIMNwM4IAMgCjcDMCADIAWsIgtCP4ciDTcDKCADIAs3AyAgA0EANgIcIAMgCyANIAogDCADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYQMNgJMIANBhAw2AkQgAyADQUBrNgJwIAMgA0EwaiIHNgJIIAMgA0EgajYCQCADQdgAaiICIANB6ABqIggQmQ4gA0GUAWogA0HkAGooAgA2AgAgA0GIgICAeDYCVCADIANB3ABqIgQpAgA3AowBIAMgAykCVDcChAEgA0EBNgKAASADQYABaiIJQQRyEIgRIAYoAgQhASADIAU2AjAgA0EENgJsIANBzJH/ADYCaCADQgQ3AnQgA0GCDDYCnAEgA0H0CzYClAEgAyABQQFqNgKQASADQbsHNgKMASADIAE2AogBIANBzAE2AoQBIANBoJH/ADYCgAEgAyAJNgJwIAMgBzYCmAEgAiAIEJkOIANByABqIAQoAgA2AgAgA0GCgICAeDYCVCADIAMpAlQ3A0AgAykCYAwBCyADQYABaiADKQMAIgogAykDCCILIAYoAggtAAAQrQ4gAygCgAFBk4CAgHhGDQEgA0HIAGogA0GIAWooAgA2AgAgAyADKQKAATcDQCADKQKMAQshCiAAIAMpA0A3AgAgACAKNwIMIABBCGogA0HIAGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCzcDCCAAIAo3AwALIANBoAFqJAALqGsBDH8jAEGgAWsiBCQAIARB9ABqIQcgBEEEaiEDIwBBEGsiCiQAQQMhBgJAIAJFDQACQCACQcAATQRAA0AgAyAFaiABIAVqLQAAQbzvwwBqLQAAOgAAIAIgBUEBaiIFRw0ACwJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkECaw4iHQoUCwAMFhUPGA0DAQIRDhcQGRsIEhocHgYFBwkeBB4eEx4LAkACQAJAAkACQAJAAkAgAy0AACIBQeEAaw4FASQCJAMACyABQe8Aaw4FAwQjIwUjCyADLQABQeMARw0iIAMtAAJB4wBHDSIgAy0AA0HlAEcNIiADLQAEQfAARw0iIAMtAAVB9ABHDSJBAAwjCyADLQABQe8ARw0hIAMtAAJB7wBHDSEgAy0AA0HrAEcNISADLQAEQekARw0hIAMtAAVB5QBHDSFBHgwiCyADLQABQfgARw0gIAMtAAJB8ABHDSAgAy0AA0HlAEcNICADLQAEQeMARw0gIAMtAAVB9ABHDSBBIgwhCyADLQABQfIARw0fIAMtAAJB6QBHDR8gAy0AA0HnAEcNHyADLQAEQekARw0fIAMtAAVB7gBHDR9BMAwgCyADLQABQfIARw0eIAMtAAJB4QBHDR4gAy0AA0HnAEcNHiADLQAEQe0ARw0eIAMtAAVB4QBHDR5BMQwfCyADLQABQeUARw0dIAMtAAJB8gBHDR0gAy0AA0H2AEcNHSADLQAEQeUARw0dIAMtAAVB8gBHDR1BwAAMHgsCQAJAIAMtAABB4QBrDgMAHgEeCyADLQABQeMARw0dIAMtAAJB4wBHDR0gAy0AA0HlAEcNHSADLQAEQfAARw0dIAMtAAVB9ABHDR0gAy0ABkEtRw0dIAMtAAdB4wBHDR0gAy0ACEHoAEcNHSADLQAJQeEARw0dIAMtAApB8gBHDR0gAy0AC0HzAEcNHSADLQAMQeUARw0dIAMtAA1B9ABHDR1BAQweCyADLQABQe8ARw0cIAMtAAJB7gBHDRwgAy0AA0H0AEcNHCADLQAEQeUARw0cIAMtAAVB7gBHDRwgAy0ABkH0AEcNHCADLQAHQS1HDRwgAy0ACEHsAEcNHCADLQAJQeUARw0cIAMtAApB7gBHDRwgAy0AC0HnAEcNHCADLQAMQfQARw0cIAMtAA1B6ABHDRxBGAwdCwJAAkACQAJAIAMtAAAiAUHwAGsOAwEfAgALIAFB+ABGDQIgAUHhAEcNHiADLQABQeMARw0eIAMtAAJB4wBHDR4gAy0AA0HlAEcNHiADLQAEQfAARw0eIAMtAAVB9ABHDR4gAy0ABkEtRw0eIAMtAAciAUHsAEcEQCABQeUARw0fIAMtAAhB7gBHDR8gAy0ACUHjAEcNHyADLQAKQe8ARw0fIAMtAAtB5ABHDR8gAy0ADEHpAEcNHyADLQANQe4ARw0fIAMtAA5B5wBHDR9BAgwgCyADLQAIQeEARw0eIAMtAAlB7gBHDR4gAy0ACkHnAEcNHiADLQALQfUARw0eIAMtAAxB4QBHDR4gAy0ADUHnAEcNHiADLQAOQeUARw0eQQMMHwsgAy0AAUH1AEcNHSADLQACQeIARw0dIAMtAANB7ABHDR0gAy0ABEHpAEcNHSADLQAFQeMARw0dIAMtAAZBLUcNHSADLQAHQesARw0dIAMtAAhB5QBHDR0gAy0ACUH5AEcNHSADLQAKQS1HDR0gAy0AC0HwAEcNHSADLQAMQekARw0dIAMtAA1B7gBHDR0gAy0ADkHzAEcNHUE0DB4LIAMtAAFB5QBHDRwgAy0AAkHmAEcNHCADLQADQeUARw0cIAMtAARB8gBHDRwgAy0ABUHyAEcNHCADLQAGQeUARw0cIAMtAAdB8gBHDRwgAy0ACEEtRw0cIAMtAAlB8ABHDRwgAy0ACkHvAEcNHCADLQALQewARw0cIAMtAAxB6QBHDRwgAy0ADUHjAEcNHCADLQAOQfkARw0cQTgMHQsgAy0AAUEtRw0bIAMtAAJB5gBHDRsgAy0AA0HyAEcNGyADLQAEQeEARw0bIAMtAAVB7QBHDRsgAy0ABkHlAEcNGyADLQAHQS1HDRsgAy0ACEHvAEcNGyADLQAJQfAARw0bIAMtAApB9ABHDRsgAy0AC0HpAEcNGyADLQAMQe8ARw0bIAMtAA1B7gBHDRsgAy0ADkHzAEcNG0HPAAwcCwJAAkACQAJAAkACQAJAIAMtAAAiAUHhAGsOAwEhAgALIAFB6QBrDgQEICAFIAsgAy0AASIBQeMARg0BIAFB9QBHDR8gAy0AAkH0AEcNHyADLQADQegARw0fIAMtAARB7wBHDR8gAy0ABUHyAEcNHyADLQAGQekARw0fIAMtAAdB+gBHDR8gAy0ACEHhAEcNHyADLQAJQfQARw0fIAMtAApB6QBHDR8gAy0AC0HvAEcNHyADLQAMQe4ARw0fQRAMIAsgAy0AASIBQeEARg0BIAFB7wBHDR4gAy0AAkHuAEcNHiADLQADQfQARw0eIAMtAARB5QBHDR4gAy0ABUHuAEcNHiADLQAGQfQARw0eIAMtAAdBLUcNHiADLQAIQfIARw0eIAMtAAlB4QBHDR4gAy0ACkHuAEcNHiADLQALQecARw0eIAMtAAxB5QBHDR5BGgwfCyADLQACQeMARw0dIAMtAANB5QBHDR0gAy0ABEHwAEcNHSADLQAFQfQARw0dIAMtAAZBLUcNHSADLQAHQfIARw0dIAMtAAhB4QBHDR0gAy0ACUHuAEcNHSADLQAKQecARw0dIAMtAAtB5QBHDR0gAy0ADEHzAEcNHUEEDB4LIAMtAAJB4wBHDRwgAy0AA0HoAEcNHCADLQAEQeUARw0cIAMtAAVBLUcNHCADLQAGQeMARw0cIAMtAAdB7wBHDRwgAy0ACEHuAEcNHCADLQAJQfQARw0cIAMtAApB8gBHDRwgAy0AC0HvAEcNHCADLQAMQewARw0cQREMHQsgAy0AAUHmAEcNGyADLQACQS1HDRsgAy0AA0HuAEcNGyADLQAEQe8ARw0bIAMtAAVB7gBHDRsgAy0ABkHlAEcNGyADLQAHQS1HDRsgAy0ACEHtAEcNGyADLQAJQeEARw0bIAMtAApB9ABHDRsgAy0AC0HjAEcNGyADLQAMQegARw0bQSkMHAsgAy0AAUHhAEcNGiADLQACQfMARw0aIAMtAANB9ABHDRogAy0ABEEtRw0aIAMtAAVB7QBHDRogAy0ABkHvAEcNGiADLQAHQeQARw0aIAMtAAhB6QBHDRogAy0ACUHmAEcNGiADLQAKQekARw0aIAMtAAtB5QBHDRogAy0ADEHkAEcNGkEsDBsLIAMtAABB4QBHDRkgAy0AAUHjAEcNGSADLQACQeMARw0ZIAMtAANB5QBHDRkgAy0ABEHzAEcNGSADLQAFQfMARw0ZIAMtAAZBLUcNGSADLQAHQeMARw0ZIAMtAAhB7wBHDRkgAy0ACUHuAEcNGSADLQAKQfQARw0ZIAMtAAtB8gBHDRkgAy0ADEHvAEcNGSADLQANQewARw0ZIAMtAA5BLUcNGSADLQAPQeEARw0ZIAMtABBB7ABHDRkgAy0AEUHsAEcNGSADLQASQe8ARw0ZIAMtABNB9wBHDRkgAy0AFEEtRw0ZIAMtABVB4wBHDRkgAy0AFkHyAEcNGSADLQAXQeUARw0ZIAMtABhB5ABHDRkgAy0AGUHlAEcNGSADLQAaQe4ARw0ZIAMtABtB9ABHDRkgAy0AHEHpAEcNGSADLQAdQeEARw0ZIAMtAB5B7ABHDRkgAy0AH0HzAEcNGUEFDBoLIAMtAABB4QBHDRggAy0AAUHjAEcNGCADLQACQeMARw0YIAMtAANB5QBHDRggAy0ABEHzAEcNGCADLQAFQfMARw0YIAMtAAZBLUcNGCADLQAHQeMARw0YIAMtAAhB7wBHDRggAy0ACUHuAEcNGCADLQAKQfQARw0YIAMtAAtB8gBHDRggAy0ADEHvAEcNGCADLQANQewARw0YIAMtAA5BLUcNGCADLQAPQeEARw0YIAMtABBB7ABHDRggAy0AEUHsAEcNGCADLQASQe8ARw0YIAMtABNB9wBHDRggAy0AFEEtRw0YIAMtABUiAUHtAEcEQCABQegARw0ZIAMtABZB5QBHDRkgAy0AF0HhAEcNGSADLQAYQeQARw0ZIAMtABlB5QBHDRkgAy0AGkHyAEcNGSADLQAbQfMARw0ZQQYMGgsgAy0AFkHlAEcNGCADLQAXQfQARw0YIAMtABhB6ABHDRggAy0AGUHvAEcNGCADLQAaQeQARw0YIAMtABtB8wBHDRhBBwwZCyADLQAAIgFB8ABHBEAgAUHhAEcNGCADLQABQeMARw0YIAMtAAJB4wBHDRggAy0AA0HlAEcNGCADLQAEQfMARw0YIAMtAAVB8wBHDRggAy0ABkEtRw0YIAMtAAdB4wBHDRggAy0ACEHvAEcNGCADLQAJQe4ARw0YIAMtAApB9ABHDRggAy0AC0HyAEcNGCADLQAMQe8ARw0YIAMtAA1B7ABHDRggAy0ADkEtRw0YIAMtAA9B4QBHDRggAy0AEEHsAEcNGCADLQARQewARw0YIAMtABJB7wBHDRggAy0AE0H3AEcNGCADLQAUQS1HDRggAy0AFUHvAEcNGCADLQAWQfIARw0YIAMtABdB6QBHDRggAy0AGEHnAEcNGCADLQAZQekARw0YIAMtABpB7gBHDRhBCAwZCyADLQABQfUARw0XIAMtAAJB4gBHDRcgAy0AA0HsAEcNFyADLQAEQekARw0XIAMtAAVB4wBHDRcgAy0ABkEtRw0XIAMtAAdB6wBHDRcgAy0ACEHlAEcNFyADLQAJQfkARw0XIAMtAApBLUcNFyADLQALQfAARw0XIAMtAAxB6QBHDRcgAy0ADUHuAEcNFyADLQAOQfMARw0XIAMtAA9BLUcNFyADLQAQQfIARw0XIAMtABFB5QBHDRcgAy0AEkHwAEcNFyADLQATQe8ARw0XIAMtABRB8gBHDRcgAy0AFUH0AEcNFyADLQAWQS1HDRcgAy0AF0HvAEcNFyADLQAYQe4ARw0XIAMtABlB7ABHDRcgAy0AGkH5AEcNF0E1DBgLIAMtAABB4QBHDRYgAy0AAUHjAEcNFiADLQACQeMARw0WIAMtAANB5QBHDRYgAy0ABEHzAEcNFiADLQAFQfMARw0WIAMtAAZBLUcNFiADLQAHQeMARw0WIAMtAAhB7wBHDRYgAy0ACUHuAEcNFiADLQAKQfQARw0WIAMtAAtB8gBHDRYgAy0ADEHvAEcNFiADLQANQewARw0WIAMtAA5BLUcNFiADLQAPIgFB8gBHBEAgAUHlAEcNFyADLQAQQfgARw0XIAMtABFB8ABHDRcgAy0AEkHvAEcNFyADLQATQfMARw0XIAMtABRB5QBHDRcgAy0AFUEtRw0XIAMtABZB6ABHDRcgAy0AF0HlAEcNFyADLQAYQeEARw0XIAMtABlB5ABHDRcgAy0AGkHlAEcNFyADLQAbQfIARw0XIAMtABxB8wBHDRdBCQwYCyADLQAQQeUARw0WIAMtABFB8QBHDRYgAy0AEkH1AEcNFiADLQATQeUARw0WIAMtABRB8wBHDRYgAy0AFUH0AEcNFiADLQAWQS1HDRYgAy0AF0HtAEcNFiADLQAYQeUARw0WIAMtABlB9ABHDRYgAy0AGkHoAEcNFiADLQAbQe8ARw0WIAMtABxB5ABHDRZBDAwXCyADLQAAIgFB+ABHBEAgAUHzAEcEQCABQeEARw0XIAMtAAFB4wBHDRcgAy0AAkHjAEcNFyADLQADQeUARw0XIAMtAARB8wBHDRcgAy0ABUHzAEcNFyADLQAGQS1HDRcgAy0AB0HjAEcNFyADLQAIQe8ARw0XIAMtAAlB7gBHDRcgAy0ACkH0AEcNFyADLQALQfIARw0XIAMtAAxB7wBHDRcgAy0ADUHsAEcNFyADLQAOQS1HDRcgAy0AD0HtAEcNFyADLQAQQeEARw0XIAMtABFB+ABHDRcgAy0AEkEtRw0XIAMtABNB4QBHDRcgAy0AFEHnAEcNFyADLQAVQeUARw0XQQoMGAsgAy0AAUHlAEcNFiADLQACQeMARw0WIAMtAANBLUcNFiADLQAEQfcARw0WIAMtAAVB5QBHDRYgAy0ABkHiAEcNFiADLQAHQfMARw0WIAMtAAhB7wBHDRYgAy0ACUHjAEcNFiADLQAKQesARw0WIAMtAAtB5QBHDRYgAy0ADEH0AEcNFiADLQANQS1HDRYgAy0ADkHwAEcNFiADLQAPQfIARw0WIAMtABBB7wBHDRYgAy0AEUH0AEcNFiADLQASQe8ARw0WIAMtABNB4wBHDRYgAy0AFEHvAEcNFiADLQAVQewARw0WQT4MFwsgAy0AAUEtRw0VAkACQCADLQACQeMAaw4CAAEXCyADLQADQe8ARw0WIAMtAARB7gBHDRYgAy0ABUH0AEcNFiADLQAGQeUARw0WIAMtAAdB7gBHDRYgAy0ACEH0AEcNFiADLQAJQS1HDRYgAy0ACkH0AEcNFiADLQALQfkARw0WIAMtAAxB8ABHDRYgAy0ADUHlAEcNFiADLQAOQS1HDRYgAy0AD0HvAEcNFiADLQAQQfAARw0WIAMtABFB9ABHDRYgAy0AEkHpAEcNFiADLQATQe8ARw0WIAMtABRB7gBHDRYgAy0AFUHzAEcNFkHNAAwXCyADLQADQe4ARw0VIAMtAARB8wBHDRUgAy0ABUEtRw0VIAMtAAZB8ABHDRUgAy0AB0HyAEcNFSADLQAIQeUARw0VIAMtAAlB5gBHDRUgAy0ACkHlAEcNFSADLQALQfQARw0VIAMtAAxB4wBHDRUgAy0ADUHoAEcNFSADLQAOQS1HDRUgAy0AD0HjAEcNFSADLQAQQe8ARw0VIAMtABFB7gBHDRUgAy0AEkH0AEcNFSADLQATQfIARw0VIAMtABRB7wBHDRUgAy0AFUHsAEcNFUHOAAwWCyADLQAAQeEARw0UIAMtAAFB4wBHDRQgAy0AAkHjAEcNFCADLQADQeUARw0UIAMtAARB8wBHDRQgAy0ABUHzAEcNFCADLQAGQS1HDRQgAy0AB0HjAEcNFCADLQAIQe8ARw0UIAMtAAlB7gBHDRQgAy0ACkH0AEcNFCADLQALQfIARw0UIAMtAAxB7wBHDRQgAy0ADUHsAEcNFCADLQAOQS1HDRQgAy0AD0HyAEcNFCADLQAQQeUARw0UIAMtABFB8QBHDRQgAy0AEkH1AEcNFCADLQATQeUARw0UIAMtABRB8wBHDRQgAy0AFUH0AEcNFCADLQAWQS1HDRQgAy0AF0HoAEcNFCADLQAYQeUARw0UIAMtABlB4QBHDRQgAy0AGkHkAEcNFCADLQAbQeUARw0UIAMtABxB8gBHDRQgAy0AHUHzAEcNFEELDBULAkACQAJAIAMtAAAiAUHhAGsOBAEWFgIACyABQfYARw0VIAMtAAFB6QBHDRUgAy0AAkHhAEcNFUHKAAwWCyADLQABQecARw0UIAMtAAJB5QBHDRRBDQwVCyADLQABQe4ARw0TIAMtAAJB9ABHDRNBHwwUCyADLQAAIgFB8gBHBEAgAUHhAEcNEyADLQABQewARw0TIAMtAAJB7ABHDRMgAy0AA0HvAEcNEyADLQAEQfcARw0TQQ4MFAsgAy0AAUHhAEcNEiADLQACQe4ARw0SIAMtAANB5wBHDRIgAy0ABEHlAEcNEkE2DBMLAkACQAJAAkACQCADLQAAIgFB8gBrDgYBFgIDFgQACwJAAkAgAUHhAGsOBQAXFxcBFwsgAy0AAUHsAEcNFiADLQACQfQARw0WIAMtAANBLUcNFiADLQAEQfMARw0WIAMtAAVB9gBHDRYgAy0ABkHjAEcNFkEPDBcLIAMtAAFB+ABHDRUgAy0AAkHwAEcNFSADLQADQekARw0VIAMtAARB8gBHDRUgAy0ABUHlAEcNFSADLQAGQfMARw0VQSMMFgsgAy0AAUHlAEcNFCADLQACQeYARw0UIAMtAAMiAUHyAEcEQCABQeUARw0VIAMtAARB8gBHDRUgAy0ABUHlAEcNFSADLQAGQfIARw0VQTcMFgsgAy0ABEHlAEcNFCADLQAFQfMARw0UIAMtAAZB6ABHDRRBOQwVCyADLQABQfIARw0TIAMtAAJB4QBHDRMgAy0AA0HpAEcNEyADLQAEQewARw0TIAMtAAVB5QBHDRMgAy0ABkHyAEcNE0HEAAwUCyADLQABQfAARw0SIAMtAAJB5wBHDRIgAy0AA0HyAEcNEiADLQAEQeEARw0SIAMtAAVB5ABHDRIgAy0ABkHlAEcNEkHHAAwTCyADLQABQeEARw0RIAMtAAJB8gBHDREgAy0AA0HuAEcNESADLQAEQekARw0RIAMtAAVB7gBHDREgAy0ABkHnAEcNEUHLAAwSCyADLQAAIgFB7QBHBEAgAUHjAEcNESADLQABIgFB4QBHBEAgAUHvAEcNEiADLQACQe4ARw0SIAMtAANB9ABHDRIgAy0ABEHlAEcNEiADLQAFQe4ARw0SIAMtAAZB9ABHDRIgAy0AB0EtRw0SIAMtAAhB9ABHDRIgAy0ACUH5AEcNEiADLQAKQfAARw0SIAMtAAtB5QBHDRJBHQwTCyADLQACQeMARw0RIAMtAANB6ABHDREgAy0ABEHlAEcNESADLQAFQS1HDREgAy0ABkHzAEcNESADLQAHQfQARw0RIAMtAAhB4QBHDREgAy0ACUH0AEcNESADLQAKQfUARw0RIAMtAAtB8wBHDRFBEgwSCyADLQABQeEARw0QIAMtAAJB+ABHDRAgAy0AA0EtRw0QIAMtAARB5gBHDRAgAy0ABUHvAEcNECADLQAGQfIARw0QIAMtAAdB9wBHDRAgAy0ACEHhAEcNECADLQAJQfIARw0QIAMtAApB5ABHDRAgAy0AC0HzAEcNEEEvDBELAkACQAJAIAMtAAAiAUHzAGsOAgECAAsgAUHpAEcEQCABQeMARw0SIAMtAAFB5ABHDRIgAy0AAkHuAEcNEiADLQADQS1HDRIgAy0ABEHjAEcNEiADLQAFQeEARw0SIAMtAAZB4wBHDRIgAy0AB0HoAEcNEiADLQAIQeUARw0SIAMtAAlBLUcNEiADLQAKQeMARw0SIAMtAAtB7wBHDRIgAy0ADEHuAEcNEiADLQANQfQARw0SIAMtAA5B8gBHDRIgAy0AD0HvAEcNEiADLQAQQewARw0SQRMMEwsgAy0AAUHmAEcNESADLQACQS1HDREgAy0AA0HtAEcNESADLQAEQe8ARw0RIAMtAAVB5ABHDREgAy0ABkHpAEcNESADLQAHQeYARw0RIAMtAAhB6QBHDREgAy0ACUHlAEcNESADLQAKQeQARw0RIAMtAAtBLUcNESADLQAMQfMARw0RIAMtAA1B6QBHDREgAy0ADkHuAEcNESADLQAPQeMARw0RIAMtABBB5QBHDRFBKAwSCyADLQABQeUARw0QIAMtAAJB4wBHDRAgAy0AA0EtRw0QIAMtAARB9wBHDRAgAy0ABUHlAEcNECADLQAGQeIARw0QIAMtAAdB8wBHDRAgAy0ACEHvAEcNECADLQAJQeMARw0QIAMtAApB6wBHDRAgAy0AC0HlAEcNECADLQAMQfQARw0QIAMtAA1BLUcNECADLQAOQesARw0QIAMtAA9B5QBHDRAgAy0AEEH5AEcNEEE9DBELIAMtAAFB8gBHDQ8gAy0AAkHhAEcNDyADLQADQe4ARw0PIAMtAARB8wBHDQ8gAy0ABUHmAEcNDyADLQAGQeUARw0PIAMtAAdB8gBHDQ8gAy0ACEEtRw0PIAMtAAlB5QBHDQ8gAy0ACkHuAEcNDyADLQALQeMARw0PIAMtAAxB7wBHDQ8gAy0ADUHkAEcNDyADLQAOQekARw0PIAMtAA9B7gBHDQ8gAy0AEEHnAEcND0HFAAwQCwJAAkACQCADLQAAIgFB8wBrDgMBEQIACyABQeMARw0QIAMtAAFB7wBHDRAgAy0AAkHuAEcNECADLQADQe4ARw0QIAMtAARB5QBHDRAgAy0ABUHjAEcNECADLQAGQfQARw0QIAMtAAdB6QBHDRAgAy0ACEHvAEcNECADLQAJQe4ARw0QQRQMEQsgAy0AAUHlAEcNDyADLQACQfQARw0PIAMtAANBLUcNDyADLQAEQeMARw0PIAMtAAVB7wBHDQ8gAy0ABkHvAEcNDyADLQAHQesARw0PIAMtAAhB6QBHDQ8gAy0ACUHlAEcND0HBAAwQCyADLQABQfMARw0OIAMtAAJB5QBHDQ4gAy0AA0HyAEcNDiADLQAEQS1HDQ4gAy0ABUHhAEcNDiADLQAGQecARw0OIAMtAAdB5QBHDQ4gAy0ACEHuAEcNDiADLQAJQfQARw0OQcYADA8LIAMtAAAiAUHwAEcEQCABQekARwRAIAFB4wBHDQ8gAy0AAUHvAEcNDyADLQACQe4ARw0PIAMtAANB9ABHDQ8gAy0ABEHlAEcNDyADLQAFQe4ARw0PIAMtAAZB9ABHDQ8gAy0AB0EtRw0PIAMtAAhB5ABHDQ8gAy0ACUHpAEcNDyADLQAKQfMARw0PIAMtAAtB8ABHDQ8gAy0ADEHvAEcNDyADLQANQfMARw0PIAMtAA5B6QBHDQ8gAy0AD0H0AEcNDyADLQAQQekARw0PIAMtABFB7wBHDQ8gAy0AEkHuAEcND0EVDBALIAMtAAFB5gBHDQ4gAy0AAkEtRw0OIAMtAANB9QBHDQ4gAy0ABEHuAEcNDiADLQAFQe0ARw0OIAMtAAZB7wBHDQ4gAy0AB0HkAEcNDiADLQAIQekARw0OIAMtAAlB5gBHDQ4gAy0ACkHpAEcNDiADLQALQeUARw0OIAMtAAxB5ABHDQ4gAy0ADUEtRw0OIAMtAA5B8wBHDQ4gAy0AD0HpAEcNDiADLQAQQe4ARw0OIAMtABFB4wBHDQ4gAy0AEkHlAEcNDkErDA8LIAMtAAFB8gBHDQ0gAy0AAkHvAEcNDSADLQADQfgARw0NIAMtAARB+QBHDQ0gAy0ABUEtRw0NIAMtAAZB4QBHDQ0gAy0AB0H1AEcNDSADLQAIQfQARw0NIAMtAAlB6ABHDQ0gAy0ACkHvAEcNDSADLQALQfIARw0NIAMtAAxB6QBHDQ0gAy0ADUH6AEcNDSADLQAOQeEARw0NIAMtAA9B9ABHDQ0gAy0AEEHpAEcNDSADLQARQe8ARw0NIAMtABJB7gBHDQ1BMwwOCwJAAkACQAJAIAMtAAAiAUH3AGsOAgEDAAsgAUHjAEcNDyADLQABQe8ARw0PIAMtAAJB7gBHDQ8gAy0AA0H0AEcNDyADLQAEQeUARw0PIAMtAAVB7gBHDQ8gAy0ABkH0AEcNDyADLQAHQS1HDQ8gAy0ACCIBQewARg0BIAFB5QBHDQ8gAy0ACUHuAEcNDyADLQAKQeMARw0PIAMtAAtB7wBHDQ8gAy0ADEHkAEcNDyADLQANQekARw0PIAMtAA5B7gBHDQ8gAy0AD0HnAEcND0EWDBALIAMtAAFB9wBHDQ4gAy0AAkH3AEcNDiADLQADQS1HDQ4gAy0ABEHhAEcNDiADLQAFQfUARw0OIAMtAAZB9ABHDQ4gAy0AB0HoAEcNDiADLQAIQeUARw0OIAMtAAlB7gBHDQ4gAy0ACkH0AEcNDiADLQALQekARw0OIAMtAAxB4wBHDQ4gAy0ADUHhAEcNDiADLQAOQfQARw0OIAMtAA9B5QBHDQ5BzAAMDwsgAy0ACSIBQeEARwRAIAFB7wBHDQ4gAy0ACkHjAEcNDiADLQALQeEARw0OIAMtAAxB9ABHDQ4gAy0ADUHpAEcNDiADLQAOQe8ARw0OIAMtAA9B7gBHDQ5BGQwPCyADLQAKQe4ARw0NIAMtAAtB5wBHDQ0gAy0ADEH1AEcNDSADLQANQeEARw0NIAMtAA5B5wBHDQ0gAy0AD0HlAEcNDUEXDA4LIAMtAAFBLUcNDCADLQACQfgARw0MIAMtAANB8wBHDQwgAy0ABEHzAEcNDCADLQAFQS1HDQwgAy0ABkHwAEcNDCADLQAHQfIARw0MIAMtAAhB7wBHDQwgAy0ACUH0AEcNDCADLQAKQeUARw0MIAMtAAtB4wBHDQwgAy0ADEH0AEcNDCADLQANQekARw0MIAMtAA5B7wBHDQwgAy0AD0HuAEcNDEHQAAwNCyADLQAAQeMARw0LIAMtAAFB7wBHDQsgAy0AAkHuAEcNCyADLQADQfQARw0LIAMtAARB5QBHDQsgAy0ABUHuAEcNCyADLQAGQfQARw0LIAMtAAdBLUcNCyADLQAIQfMARw0LIAMtAAlB5QBHDQsgAy0ACkHjAEcNCyADLQALQfUARw0LIAMtAAxB8gBHDQsgAy0ADUHpAEcNCyADLQAOQfQARw0LIAMtAA9B+QBHDQsgAy0AEEEtRw0LIAMtABFB8ABHDQsgAy0AEkHvAEcNCyADLQATQewARw0LIAMtABRB6QBHDQsgAy0AFUHjAEcNCyADLQAWQfkARw0LQRsMDAsgAy0AAEHjAEcNCiADLQABQe8ARw0KIAMtAAJB7gBHDQogAy0AA0H0AEcNCiADLQAEQeUARw0KIAMtAAVB7gBHDQogAy0ABkH0AEcNCiADLQAHQS1HDQogAy0ACEHzAEcNCiADLQAJQeUARw0KIAMtAApB4wBHDQogAy0AC0H1AEcNCiADLQAMQfIARw0KIAMtAA1B6QBHDQogAy0ADkH0AEcNCiADLQAPQfkARw0KIAMtABBBLUcNCiADLQARQfAARw0KIAMtABJB7wBHDQogAy0AE0HsAEcNCiADLQAUQekARw0KIAMtABVB4wBHDQogAy0AFkH5AEcNCiADLQAXQS1HDQogAy0AGEHyAEcNCiADLQAZQeUARw0KIAMtABpB8ABHDQogAy0AG0HvAEcNCiADLQAcQfIARw0KIAMtAB1B9ABHDQogAy0AHkEtRw0KIAMtAB9B7wBHDQogAy0AIEHuAEcNCiADLQAhQewARw0KIAMtACJB+QBHDQpBHAwLCwJAAkACQAJAAkACQCADLQAAIgFB5ABrDgkBAgMPBA8PDwUACyABQfYARw0OIAMtAAFB4QBHDQ4gAy0AAkHyAEcNDiADLQADQfkARw0OQckADA8LIAMtAAFB4QBHDQ0gAy0AAkH0AEcNDSADLQADQeUARw0NQSAMDgsgAy0AAUH0AEcNDCADLQACQeEARw0MIAMtAANB5wBHDQxBIQwNCyADLQABQfIARw0LIAMtAAJB7wBHDQsgAy0AA0HtAEcNC0ElDAwLIAMtAAFB7wBHDQogAy0AAkHzAEcNCiADLQADQfQARw0KQSYMCwsgAy0AAUHpAEcNCSADLQACQe4ARw0JIAMtAANB6wBHDQlBLQwKCyADLQAAQeYARw0IIAMtAAFB7wBHDQggAy0AAkHyAEcNCCADLQADQfcARw0IIAMtAARB4QBHDQggAy0ABUHyAEcNCCADLQAGQeQARw0IIAMtAAdB5QBHDQggAy0ACEHkAEcNCEEkDAkLAkACQCADLQAAQekAaw4EAAkJAQkLIAMtAAFB5gBHDQggAy0AAkEtRw0IIAMtAAMiAUHyAEcEQCABQe0ARw0JIAMtAARB4QBHDQkgAy0ABUH0AEcNCSADLQAGQeMARw0JIAMtAAdB6ABHDQlBJwwKCyADLQAEQeEARw0IIAMtAAVB7gBHDQggAy0ABkHnAEcNCCADLQAHQeUARw0IQSoMCQsgAy0AAUHvAEcNByADLQACQeMARw0HIAMtAANB4QBHDQcgAy0ABEH0AEcNByADLQAFQekARw0HIAMtAAZB7wBHDQcgAy0AB0HuAEcNB0EuDAgLIAMtAABB8ABHDQYgAy0AAUHyAEcNBiADLQACQe8ARw0GIAMtAANB+ABHDQYgAy0ABEH5AEcNBiADLQAFQS1HDQYgAy0ABkHhAEcNBiADLQAHQfUARw0GIAMtAAhB9ABHDQYgAy0ACUHoAEcNBiADLQAKQeUARw0GIAMtAAtB7gBHDQYgAy0ADEH0AEcNBiADLQANQekARw0GIAMtAA5B4wBHDQYgAy0AD0HhAEcNBiADLQAQQfQARw0GIAMtABFB5QBHDQZBMgwHCyADLQAAQfIARw0FIAMtAAFB5QBHDQUgAy0AAkH0AEcNBSADLQADQfIARw0FIAMtAARB+QBHDQUgAy0ABUEtRw0FIAMtAAZB4QBHDQUgAy0AB0HmAEcNBSADLQAIQfQARw0FIAMtAAlB5QBHDQUgAy0ACkHyAEcNBUE6DAYLIAMtAABB8wBHDQQgAy0AAUHlAEcNBCADLQACQeMARw0EIAMtAANBLUcNBCADLQAEQfcARw0EIAMtAAVB5QBHDQQgAy0ABkHiAEcNBCADLQAHQfMARw0EIAMtAAhB7wBHDQQgAy0ACUHjAEcNBCADLQAKQesARw0EIAMtAAtB5QBHDQQgAy0ADEH0AEcNBCADLQANQS1HDQQgAy0ADkHhAEcNBCADLQAPQeMARw0EIAMtABBB4wBHDQQgAy0AEUHlAEcNBCADLQASQfAARw0EIAMtABNB9ABHDQRBOwwFCyADLQAAQfMARw0DIAMtAAFB5QBHDQMgAy0AAkHjAEcNAyADLQADQS1HDQMgAy0ABEH3AEcNAyADLQAFQeUARw0DIAMtAAZB4gBHDQMgAy0AB0HzAEcNAyADLQAIQe8ARw0DIAMtAAlB4wBHDQMgAy0ACkHrAEcNAyADLQALQeUARw0DIAMtAAxB9ABHDQMgAy0ADUEtRw0DIAMtAA5B5QBHDQMgAy0AD0H4AEcNAyADLQAQQfQARw0DIAMtABFB5QBHDQMgAy0AEkHuAEcNAyADLQATQfMARw0DIAMtABRB6QBHDQMgAy0AFUHvAEcNAyADLQAWQe4ARw0DIAMtABdB8wBHDQNBPAwECyADLQAAQfMARw0CIAMtAAFB5QBHDQIgAy0AAkHjAEcNAiADLQADQS1HDQIgAy0ABEH3AEcNAiADLQAFQeUARw0CIAMtAAZB4gBHDQIgAy0AB0HzAEcNAiADLQAIQe8ARw0CIAMtAAlB4wBHDQIgAy0ACkHrAEcNAiADLQALQeUARw0CIAMtAAxB9ABHDQIgAy0ADUEtRw0CIAMtAA5B9gBHDQIgAy0AD0HlAEcNAiADLQAQQfIARw0CIAMtABFB8wBHDQIgAy0AEkHpAEcNAiADLQATQe8ARw0CIAMtABRB7gBHDQJBPwwDCwJAAkACQCADLQAAQfMAaw4DAQQABAsgAy0AAUHwAEYNAQwDCyADLQABQfQARw0CIAMtAAJB8gBHDQIgAy0AA0HpAEcNAiADLQAEQeMARw0CIAMtAAVB9ABHDQIgAy0ABkEtRw0CIAMtAAdB9ABHDQIgAy0ACEHyAEcNAiADLQAJQeEARw0CIAMtAApB7gBHDQIgAy0AC0HzAEcNAiADLQAMQfAARw0CIAMtAA1B7wBHDQIgAy0ADkHyAEcNAiADLQAPQfQARw0CIAMtABBBLUcNAiADLQARQfMARw0CIAMtABJB5QBHDQIgAy0AE0HjAEcNAiADLQAUQfUARw0CIAMtABVB8gBHDQIgAy0AFkHpAEcNAiADLQAXQfQARw0CIAMtABhB+QBHDQJBwgAMAwsgAy0AAkHnAEcNASADLQADQfIARw0BIAMtAARB4QBHDQEgAy0ABUHkAEcNASADLQAGQeUARw0BIAMtAAdBLUcNASADLQAIQekARw0BIAMtAAlB7gBHDQEgAy0ACkHzAEcNASADLQALQeUARw0BIAMtAAxB4wBHDQEgAy0ADUH1AEcNASADLQAOQfIARw0BIAMtAA9B5QBHDQEgAy0AEEEtRw0BIAMtABFB8gBHDQEgAy0AEkHlAEcNASADLQATQfEARw0BIAMtABRB9QBHDQEgAy0AFUHlAEcNASADLQAWQfMARw0BIAMtABdB9ABHDQEgAy0AGEHzAEcNAUHIAAwCCyADLQAAQfQARw0AIAMtAAFB5QBHDQBBwwAMAQtB0QALQf8BcSIBQdEARg0BIAcgAToAAEECIQYMAgsgAkH//wNLDQEgByACNgIEIAcgATYCAEEAIQYMAQsCQCACQQdNBEAgAyEFIAIhAQNAIAUtAABFDQMgBUEBaiEFIAFBAWsiAQ0ACwwBCyAKQQhqQQAgAyACEJ0SIAooAghBAUYNAQsgByACNgIEIAcgAzYCAEEBIQYLIAcgBjoACCAKQRBqJAACQCAELQB8IgNBA0YEQCAAQQE2AgAMAQsgBCgCdCECAkACQAJAIANBAkcEQCAEKAJ4IQEgA0EBcQ0CIARB9ABqIAFBAEEBQQEQoBggBCgCeCEDIAQoAnRBAUYNASAEQQA2AkggBCAEKAJ8IgU2AkQgBCADNgJMIARBB0EgIANBCnZnayIHIAdBB08bQQJ0QQFyIgc2AlAgAQRAA0AgAi0AAEG878MAai0AACIDRQRAIABBATYCACMAQRBrIgAkAAJAIARBxABqIgEoAgwiAkEBcQRAIAAgAkEFdiICIAEoAgRqNgIMIAAgASgCACACazYCCCAAIAEoAgggAmo2AgQgAEEEakEBQQEQ4B4MAQsgAhDDLAsgAEEQaiQADAcLIAQgAzoAdCMAQRBrIgokACAEQcQAaiIDKAIIIAMoAgQiCGsiBUUEQCMAQSBrIgUkACADKAIEIQgCQAJAAkACQAJAAkAgAygCDCIHQQFxRQRAIAhBAWoiBiAISQ0BIAcoAhBBAUYNAiAFQRRqQQEgBygCDCIIQQlqdCIJIAYgBiAJSRsgBiAIG0EAQQFBARCgGCAFKAIYIQYgBSgCFEEBRg0EIAVBADYCECAFIAUoAhw2AgwgBSAGNgIIIAVBCGogAygCACIGIAYgAygCBGoQvSYgBxDDLCADIAhBAnRBAXI2AgwgAyAFKAIMNgIAIAMgBSgCCDYCCAwGCyADKAIIIgsgB0EFdiIGaiIJIAhHIAYgCE9xDQIgBSAJNgIUIAUgBiAIaiIMNgIcIAUgAygCACAGayIHNgIYIAMgCCALRgR/IAVBFGogDEEBQQFBARDeKCAFKAIYIQcgBSgCFAUgCQsgBms2AgggAyAGIAdqNgIADAULQaSIiAFBCEGsiIgBEJ8pAAsgBygCACIJIAMoAgAiDiAHKAIEIgtrIgwgBmoiDUkNAiADIAY2AggMAwsgAygCACILIAZrIQYgCARAIAYgCyAI/AoAAAsgAyAHQR9xNgIMIAMgBjYCACADIAk2AggMAgsgBiAFKAIcQbyIiAEQ/S8ACwJAIAYgCU0gCCAMTXFFBEAgBiANSw0BIAcgCCAMaiIINgIIIAMgDSAJQQF0IgYgBiANSRsgCGsiBiAJIAhrSwR/IAcgCCAGQQFBARDeKCAHKAIEIQsgBygCAAUgCQsgDGs2AgggAyALIAxqNgIADAILIAgEQCALIA4gCPwKAAALIAMgCzYCACADIAcoAgA2AggMAQtBpIiIAUEIQcyIiAEQyyQACyAFQSBqJAAgAygCCCADKAIEIghrIQULIAMoAgAgCGogBEH0AGotAAA6AAAgBUUEQCAKIAU2AgwgCkEBNgIIIApBCGoQ8yUACyADIAhBAWo2AgQgCkEQaiQAIAJBAWohAiABQQFrIgENAAsgBCgCSCEIIAQoAkQhBSAEKAJQIQcgBCgCTCEDCyAHQQFxBH8gBEHUAGoiAiAHQQV2IgEgCGo2AgggAiAFIAFrNgIEIAIgASADajYCACAEQeAAaiACEOcVIAQgATYCcCAEKAJoIgIgAUkNBCAEKAJkIAFqIQUgAiABayEIIAQoAmwhByAEKAJgBUHciIgBCyEBIAAgBzYCECAAIAg2AgwgACAFNgIIIAAgATYCBCAAQQA2AgAMBAsgACACOgAIIABCADcCAAwDCyADIAQoAnxB5O7DABD9LwALIABBBGogAiABEPweIABBADYCAAwBCyAEIAI2AowBIARBAjYCeCAEQZzvwwA2AnQgBEICNwKAASAEQcUCNgKcASAEQcUCNgKUASAEIARBkAFqNgJ8IAQgBEGMAWo2ApgBIAQgBEHwAGo2ApABIARB9ABqQazvwwAQ7ywACyAEQaABaiQAC/YDAhB/AX4jAEEQayIFJAAgAUECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEGIAFBD0sNASABQQdLBEAgACACENQWIAAgBkEDdCIDaiACIANqENQWQQQMAwsgAiAAKQIANwIAIAIgBkEDdCIDaiAAIANqKQIANwIAQQEMAgsACyAAIAIgAiABQQN0aiIDEKgtIAAgBkEDdCIEaiACIARqIANBQGsQqC1BCAshCSAFQgI3AgQgCUEDdCELIAlBAWohDiAFIAY2AgwgASAGayEPIAVBCGohEEEAIQNBAiEHA0AgBSADQQFqIgQ2AgAgA0ECdCEIIAQhAyAPIAYgCCAQaigCACIEGyIRIAlLBEAgACAEQQN0IgNqIRJBCCEIIAIgA2oiDSEMIA4hAyAJIQQDQCADIQcgDSAEQQN0IgNqIgQgAyASaikCACIUNwIAIBSnIhMgBEEIaygCAEkEQCAIIQQgDCEDAn8DQCADIAtqIgogCkEIaykCADcCACANIAQgC0YNARogBEEIaiEEIANBCGshAyAKQRBrKAIAIBNLDQALIAMgC2oLIBQ3AgALIAhBCGshCCAMQQhqIQwgByAHIBFJIgpqIQMgByEEIAoNAAsgBSgCBCEHIAUoAgAhAwsgAyAHRw0ACyACIAEgABD/EQsgBUEQaiQAC/wEAgZ/BH4jAEGgAWsiAyQAIAEoAgwoAhAgAkEDdGopAwAhCSABKAIIIgUoAgAoAgAiBCkDACEKIAMgBCkDCCILNwM4IAMgCjcDMCADIAlCP4ciDDcDKCADIAk3AyAgA0EANgIcIAMgCSAMIAogCyADQRxqEPYMAkACQAJ+IAMoAhwEQCADQQI2AmwgA0GskP8ANgJoIANCAjcCdCADQYQMNgJMIANBhAw2AkQgAyADQUBrNgJwIAMgA0EwaiIGNgJIIAMgA0EgajYCQCADQdgAaiICIANB6ABqIgcQmQ4gA0GUAWogA0HkAGooAgA2AgAgA0GIgICAeDYCVCADIANB3ABqIgQpAgA3AowBIAMgAykCVDcChAEgA0EBNgKAASADQYABaiIIQQRyEIgRIAUoAgQhASADIAk3AzAgA0EENgJsIANBzJH/ADYCaCADQgQ3AnQgA0GGDDYCnAEgA0H0CzYClAEgAyABQQFqNgKQASADQbsHNgKMASADIAE2AogBIANBzAE2AoQBIANBoJH/ADYCgAEgAyAINgJwIAMgBjYCmAEgAiAHEJkOIANByABqIAQoAgA2AgAgA0GCgICAeDYCVCADIAMpAlQ3A0AgAykCYAwBCyADQYABaiADKQMAIgkgAykDCCIKIAUoAggtAAAQrQ4gAygCgAFBk4CAgHhGDQEgA0HIAGogA0GIAWooAgA2AgAgAyADKQKAATcDQCADKQKMAQshCSAAIAMpA0A3AgAgACAJNwIMIABBCGogA0HIAGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBHRqIgAgCjcDCCAAIAk3AwALIANBoAFqJAALugQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAAQQN0aiEEIABBAWtB/////wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIAIAUgAygCBCgCDBEGAEUNAEEBDAULQQEgASgCACADIAFBBGooAgARAgANBBogAEEIaiEAIAQgAUEIaiIBRw0ACwwCCyAAQRhsIQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRqKAIAIgFFDQAgAygCACAAKAIAIAEgAygCBCgCDBEGAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJaiIBQQhqLwEAQQFrDgIBAgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJAIAEvAQBBAWsOAgECAAsgAUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMgCDsBDCADIAFBFGooAgA2AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABKAIEEQIADQMaIABBCGohACAFQRhqIgUgCkcNAAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAoAgQgAygCBCgCDBEGAEUNAEEBDAELQQALIANBEGokAAuVBAEMfyABQQFrIQ4gACgCBCEKIAAoAgAhCyAAKAIIIQwCQANAIAUNAQJ/AkAgAiADSQ0AA0AgASADaiEFAkACQAJAIAIgA2siB0EHTQRAIAIgA0cNASACIQMMBQsCQCAFQQNqQXxxIgYgBWsiBARAQQAhAANAIAAgBWotAABBCkYNBSAEIABBAWoiAEcNAAsgBCAHQQhrIgBNDQEMAwsgB0EIayEACwNAQYCChAggBigCACIJQYqUqNAAc2sgCXJBgIKECCAGQQRqKAIAIglBipSo0ABzayAJcnFBgIGChHhxQYCBgoR4Rw0CIAZBCGohBiAEQQhqIgQgAE0NAAsMAQtBACEAA0AgACAFai0AAEEKRg0CIAcgAEEBaiIARw0ACyACIQMMAwsgBCAHRgRAIAIhAwwDCwNAIAQgBWotAABBCkYEQCAEIQAMAgsgByAEQQFqIgRHDQALIAIhAwwCCyAAIANqIgZBAWohAwJAIAIgBk0NACAAIAVqLQAAQQpHDQBBACEFIAMhBiADDAMLIAIgA08NAAsLIAIgCEYNAkEBIQUgCCEGIAILIQACQCAMLQAABEAgC0HI8YkBQQQgCigCDBEGAA0BC0EAIQQgACAIRwRAIAAgDmotAABBCkYhBAsgACAIayEAIAEgCGohByAMIAQ6AAAgBiEIIAsgByAAIAooAgwRBgBFDQELC0EBIQ0LIA0LkAUCBX8GfiMAQaABayIDJAAgASgCCCIFKAIAIQYgA0GAAWoiByABKAIMKAIQIAJBBXRqIgQpAwAiCiAEKQMIIgsgBCkDECIMIAQpAxgiDRDWIwJAAkACfgJAAkAgAygCgAFBAXFFDQAgAykDmAEgAykDkAEiCEKAgICAgICAgIB/fSAIVK18QgBSDQAgAyAGKAIAKQMAIgk3AyAgAyAINwMYIAMgCCAIQj+HIAkgCUI/hxCoHiADKQMIIAMpAwAiCEI/h1ENASADQQI2AoQBIANBrJD/ADYCgAEgA0ICNwKMASADQYYMNgI4IANBhgw2AjAgAyADQSxqNgKIASADIANBIGo2AjQgAyADQRhqNgIsIANB7ABqIAcQmQ4gA0HMAGogA0HwAGopAgA3AgAgA0HUAGogA0H4AGooAgA2AgAgA0GIgICAeDYCaCADIAMpAmg3AkQgA0EBNgJAIANBQGtBBHIQiBELIAUoAgQhASADIA03A1ggAyAMNwNQIAMgCzcDSCADIAo3A0AgA0HMkf8ANgJoIANCBDcCdCADQYMMNgKcASADQfQLNgKUASADIAFBAWo2ApABIANBuwc2AowBIAMgATYCiAEgA0HMATYChAEgA0Ggkv8ANgKAASADIANBgAFqNgJwIAMgA0FAazYCmAEgA0EENgJsIANBMGogA0HoAGoQmQ4gAykCOCEJQYKAgIB4IQQgAykCMAwBCyADQYABaiAIIAUoAggtAAAQjRAgAygCgAEiBEGTgICAeEYNASADKQKMASEJIAMpAoQBCyEIIAAgCTcCDCAAIAg3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQN0aiAINwMACyADQaABaiQAC7kLAg9/A34jAEGACGsiDCQAAkACQCABQYcBTwRAIAxBEGohDwNAIAxBDGohDSAALwH0AyEEQgAhESMAQfALayIFJAAgBUH4B2oiAkH87IABQSj8CgAAIAVBCjsB7AsgBUEIaiIDIAJB+AP8CgAAAkACQCAERQ0AAkACQAJAIAUvAfwDIgJFDQAgAkECdCECIAA1AgAhEwNAIAMgAzUCACATfiARfCISPgIAIANBBGohAyASQiCIIREgAkEEayICDQALIBJCgICAgBBUDQAgBS8B/AMiAkH8AEsNASAFQQhqIAJBAnRqIBE+AgAgBSAFLwH8A0EBajsB/AMLIARBAUcNAQwCCyANQQA2AgAMAgtBAiAEIARBAk0bIRBBASEEA0ACQCAAIARBAnRqKAIAIgNFDQAgBUH4B2oiAkH87IABQSj8CgAAIAVBCjsB7AsgBUGABGogAkH4A/wKAAACQAJAIAUvAfQHIgJFBEBBACEDDAELIAJBAnQhAiADrSETIAVBgARqIQNCACERA0AgAyADNQIAIBN+IBF8IhI+AgAgA0EEaiEDIBJCIIghESACQQRrIgINAAsgBS8B9AchAyASQoCAgIAQVA0AIANB/ABLDQEgBUGABGogA0ECdGogET4CACAFIAUvAfQHQQFqIgM7AfQHCwJ/IAVBgARqIQpBACECAkACQAJAIANB//8DcSIDIAVBCGoiCC8B9AMiCSAEayIGQQAgBiAJTRtLBEAgAyAEaiIGQf0ASw0CAkAgBiAJTQ0AIAYgCWtBAnQiAkUNACAIIAlBAnRqQQAgAvwLAAsgCCAGOwH0AwwBCyADRQ0CCyAIIARBAnRqIQdBACEGIAMhAiAEIQkDQCAILwH0AyILIAlNBEAgCSALQdyYgQEQwyEACyAHIAcoAgAiCyAKKAIAaiIONgIAIAsgDkshCyAGQQFxBH8gByAOQQFqIgY2AgAgCyAGRXIFIAsLIQYgB0EEaiEHIAlBAWohCSAKQQRqIQogAkEBayICDQALIAZFDQEgAyAEaiICQQFrIQogCCACQQJ0aiEHA0AgCkEBaiIKIAgvAfQDIgJPBEBBACACQfwASw0EGiAIIAJBAnRqQQE2AgAgCCAILwH0A0EBajsB9ANBAQwEC0EBIQIgByAHKAIAQQFqIgM2AgAgB0EEaiEHIANFDQALCyACDAELQQELDQELIA1BADYCAAwDCyAEQQFqIgQgEEcNAAsLAkAgBS8B/AMiA0UNACAFQQRqIgQgA0ECdGoiAkUNAANAIAIoAgANASAFIANBAWsiAzsB/AMgA0H//wNxIgJFDQEgBCACQQJ0aiICDQALCyANQQRqIAVBCGpB+AP8CgAAIA1BATYCAAsgBUHwC2okACAMKAIMRQ0CIAxBiARqIgIgD0H4A/wKAAAgACACQfgD/AoAACABQYcBayIBQYcBTw0ACwtBASEDQQUhBEENIQIDQAJAIAJBAXEEQCADIARsIQMgAkEBRg0BCyACQQF2IQIgBCAEbCEEDAELCyABQQ1PBEAgA60hEwNAAkAgAC8B9AMiAkUNACACQQJ0IQRCACERIAAhAgNAIAIgAjUCACATfiARfCISPgIAIAJBBGohAiASQiCIIREgBEEEayIEDQALIBJCgICAgBBUDQAgAC8B9AMiAkH8AEsNAyAAIAJBAnRqIBE+AgAgACAALwH0A0EBajsB9AMLIAFBDWsiAUENTw0ACwtBASEDIAFFDQEgAC8B9AMiAkUNASACQQJ0IQQgAUEDdEHg7YABajUCACETQgAhESAAIQIDQCACIBMgAjUCAH4gEXwiEj4CACACQQRqIQIgEkIgiCERIARBBGsiBA0ACyASQoCAgIAQVA0BIAAvAfQDIgFB/ABLDQAgACABQQJ0aiARPgIAIAAgAC8B9ANBAWo7AfQDDAELQQAhAwsgDEGACGokACADC4sEAgJ/AX4gAAJ/AkACQAJAAkACQAJAIAIOAgABAgsgAEEAOgABQQEMBQsgAS0AACIDQStrDgMCAQIBCyABLQAAIQMLAkACQAJAAkACQAJAAkACQAJAIANB/wFxQStrDgMAAgECCyACQQFrIQMgAUEBaiEBIAJBCUkNAiADIQIMBgsgAkEBayEEIAFBAWohASACQQlPBEBBACEDA0AgBEUNCCABLQAAQTBrIgJBCUsNCSADrEIKfiIFQiCIpyAFpyIDQR91Rw0EIAFBAWohASAEQQFrIQQgAkEASiADIAMgAmsiA0pzRQ0ACyAAQQM6AAFBAQwKCyAERQ0EQQAhAwNAIAEtAABBMGsiAkEJSw0IIAFBAWohASADQQpsIAJrIQMgBEEBayIEDQALDAYLIAJBB0sNBAwCCyADIgJFDQIMAQsgAEEDOgABQQEMBgtBACEDA0AgAS0AAEEwayIEQQlLDQQgAUEBaiEBIAQgA0EKbGohAyACQQFrIgINAAsMAgtBACEDDAELQQAhAwNAIAJFDQEgAS0AAEEwayIEQQlLDQIgA6xCCn4iBUIgiKcgBaciA0EfdUcNAyABQQFqIQEgAkEBayECIARBAEggAyADIARqIgNKc0UNAAsgAEECOgABQQEMAwsgACADNgIEQQAMAgsgAEEBOgABQQEMAQsgAEECOgABQQELOgAAC/kIAgp/A34jAEGQAmsiAyQAIANBCGogAhDDNCADKAIMIQQgAygCCCECIAMgATYCHCADIAI2AhQgAyACIARBAnRqNgIYIANByABqIQcjAEFAaiIEJAAgBEEINgIIIARBOGogA0EUaiICQQhqKAIANgIAIAQgAikCADcDMCAEIARBCGo2AjwgBEEkaiEIIwBBMGsiAiQAIAJBCGogBEEwaiIFIAJBIGoiCSAFKAIMEOMSAkACQAJAAkAgAigCCEEBcUUNACACKAIMIgpFDQAgCUEEQQBBBEEEEKAYIAIoAiQhBiACKAIgQQFGDQIgAigCKCILIAo2AgAgAkEcaiIMQQE2AgAgAiALNgIYIAIgBjYCFCACQShqIAVBCGopAgA3AwAgAiAFKQIANwMgIAJBFGohBiMAQSBrIgUkACAFQRBqIAkgBUEfaiAJKAIMEOMSAkAgBSgCEEEBcUUNACAFKAIUIgtFDQADQCAGKAIIIgogBigCAEYEQCAGIApBAUEEQQQQ0CgLIAYoAgQgCkECdGogCzYCACAGIApBAWo2AgggBUEIaiAJIAVBH2ogCSgCDBDjEiAFKAIIQQFxRQ0BIAUoAgwiCw0ACwsgBUEgaiQAIAhBCGogDCgCADYCACAIIAIpAhQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyACQTBqJAAMAQsgBiACKAIoQciXzwAQ/S8ACwJAIAQoAghBCEcEQCAHIAQpAwg3AwAgB0EQaiAEQRhqKQMANwMAIAdBCGogBEEQaikDADcDACAIEKInIAhBBEEEEOAeDAELIAcgBCkCJDcCBCAHQQg2AgAgB0EMaiAEQSxqKAIANgIACyAEQUBrJAAgA0G4AWoiAiADQdQAaigCADYCACADIAMpAkw3A7ABAkACQCADKAJIIgRBCEcEQCADKQNYIQ0gACADKQOwATcCDCAAIA03AxggACAENgIIIABBATYCACAAQRRqIAIoAgA2AgAMAQsgA0GUAWogAigCADYCACADIAMpA7ABNwKMASADQQM7AawBIANBAzsB2AEgA0EROgDEASADQQA2AsABIANCgICAgMAANwK4ASADQQA2ArABIAMgASgCBCIENgLUASADIAEoAgAiATYC0AEgAyABNgKkASADIAQ2AqgBIANBoAFqIANBzAFqKAIANgIAIAMgAykCxAE3ApgBIANBADYChAEgAhCiJyACQQRBBBDgHiADQcgAaiADQYQBahDCDiADKAJIQQFGBEAgA0EoaiADQeAAaikDACINNwIAIANBIGogA0HYAGopAwAiDjcCACADIAMpA1AiDzcCGCAAQRhqIA03AgAgAEEQaiAONwIAIAAgDzcCCCAAQQE2AgAMAQsgA0EUaiIBIANByABqQQRyQTT8CgAAIANB3AFqIgIgAUE0/AoAAEE8QQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE0/AoAACAAQQRqIAEQpRIgAEEANgIACyADQZACaiQADwtBBEE8EKM9AAvvBAECfyMAQTBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0AAEENaw4aABIBEAIDBBISBQYHCAkSEhISEhISDwoLEgwSCyABLQAAIgRBBGtBAkkNECAEQQ1HDREgAigCBA0MIAItAAEhBAwNCyABLQAAIgRBBUYNDyAEQQ5HDRAMDwsgAS0AAEEFRw0PDA4LIAEtAABBBUcNDgwNCyABLQAAQRNHDQ0MDAsgAS0AAEEURw0MDAsLIAEtAABBFEcNCwwKCyABLQAAQRRHDQoMCQsgAS0AAEEUaw4FCAkJCQgJCyABLQAAQRRrDgUHCAgIBwgLIAEtAABBJUcNBwwGCyABLQAAQSVHDQYMBQsgAS0AAEElRg0EDAULIAItAAEiBCABLQABRg0DCwJAAkACQCAEQQFrDgMBAgYACyABLQABQQNHDQUgASgCBA0FDAQLIAEtAAFBA0cNBCABKAIEDQQMAwsgAS0AAUEDRw0DIAEoAgQNAwwCCyADQSBqIAFBCGooAgA2AgAgAyABKQIANwMYIANBJGoiASACKAIIEMIGIANBDGoiBCADQRhqIAEQ0QogBCACKAIIELgIRQRAIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgAhCVDAwECyAAIAIpAgA3AgAgAEEIaiACQQhqKAIANgIAIANBDGoQlQwMAwsgAS0AAEEERw0BCyAAIAIpAgA3AgAgAEEIaiACQQhqKAIANgIAIAEQlQwMAQsgACABKQIANwIAIABBCGogAUEIaigCADYCACACEJUMCyADQTBqJAAL0yMCK38CfiMAQTBrIgokACABQRxqISpBASEGAkACQANAAkACQAJAAkACQCABLQAgIgQEQCAEQQJHBEACf0EAIAEtACINABogCkEgakElQeDnzwBBEBDNGiAKLQAgQQRGBEAgCigCJAwBCyAKKQMgIi9C/wGDQgRSDQMgL0IgiKcLRQRAIAFBAjoAIAsgAEEEOgAAIABBADYCBAwICyAAQQQ6AAAgAEEANgIEDAcLQQEhB0EAIQwgBkUEQCABKAIAIQkgASgCCCIHIAEoAgwiDE8EQCABKAIQIQggASgCFCEHIAEoAhgiBiABKAIEIgQgBCAGSxsiDARAIAkgByAM/AoAAAsgASAGIAxrNgIYIAEgByAMajYCFCABIAw2AgwgAUEANgIIIAEgDCAIIAggDEkbNgIQQQAhBwsgCkEgaiIEQQA2AgAgBCAMIAdrNgIIIAQgByAJajYCBCAKKAIgQQFGBEAgACAKKQIkNwIADAgLIAooAigiDEUNAiAKKAIkIQcLIApBADYCFCAKIAw2AhAgCiAHNgIMIApBADYCKCAKIAM2AiQgCiACNgIgIAxFDQIgAS0AIkEBcUUNAiAKQRhqIQYjAEEQayIHJAAgKigCACIEQQA2AuDrASAEQQA2ArTrAUEAENI9IQQgB0EANgIEIAcgBEEARzYCAAJAAkAgBygCAEEBcUUNACAHQQhqIAcoAgQQ4hogBy0ACEEERg0AIAcpAwgiL0L/AYNCBFENACAGIC83AgAMAQsgBkEEOgAACyAHQRBqJAAgCi0AGEEERwRAIAopAxgiL0L/AYNCBFINBAsgAUEAOgAiDAILIAAgLzcCAAwFCyABQQE6ACBBACEGDAMLIwBBEGsiICQAIwBBMGsiESQAIApBIGoiBigCACEEIBEgBigCBDYCGCARIAQ2AhQgESAGNgIQIBEgBigCCDYCHCARQSBqIi0gCkEMahDfLyAqKAIAIQVBACEIIwBBIGsiDiQAIBFBJGoiEygCCCEhIBMoAgQhIiATKAIAIQcgEUEUaiIXKAIEISMgDiAXKAIAIgQgFygCCCInaiIuNgIcAkAgISAiSwRAQbh/IQYMAQsCQCAjICdJDQACQCAFKALk6wFBAUcNACAFKAK06wFFDQBBmH8hBiAFKALo6wEgBEcNAiAFKALw6wEgJ0cNAiAFKALs6wEgI0cNAgsgBCAjaiEbIAcgImohGCAFQejrAWohJCAFQfzqAWohKCAiICFrIQwgBUGg7AVqIRwgBUHA6QFqIR0gBUHQ6wFqISkgByAhaiIWIQQDQAJAIAQhBwJ/AkAgCEEBcUUEQEF/IQYCQAJAAkAgHSAcAn8CQAJAIAUoArTrAQ4FAQADBAUMCyAFKALY6wEMAQsgBUEANgLA6wEgBUEBNgK06wEgKUIANwMAIClBCGpCADcDACAkIBcpAgA3AgAgJEEIaiAXQQhqKAIANgIAQQALIAUoAuzqARDnCSEEAkAgBSgCrOsBRQ0AIAUoAqjrAUUNACAFEMUcCyAEQYh/SwRAIAQhBgwKCyAEBEAgBCAFKALY6wEiBmsiCSAYIAdrIghLBEAgByAYRwRAIAgEQCAGIBxqIAcgCPwKAAALIAUgBiAIaiIGNgLY6wELIBMgEygCBDYCCCAdIBwgBiAFKALs6gEQ5wkiBkGIf0sNC0ECQQYgBSgC7OoBGyIGIAQgBCAGSRsgBSgC2OsBa0EDaiEGDAsLIAkEQCAGIBxqIAcgCfwKAAALIAUgBDYC2OsBIAcgCWohBEEAIQgMCAsCQCAdKQMAIi9Cf1ENACAFKALU6QFBAUYNACAvIBsgDigCHCIQayIlrVYNACMAQRBrIgskAEEAIQ0jAEFAaiIJJAACQAJAIAxBCEkNACAWKAAAQXBxQdDUtMIBRw0AIAtCADcDCCALQQA2AgAgC0FyQbh/IBYoAAQiBkEIaiIEIAQgDEsbIAZBd0sbNgIEDAELIAlBEGogFiAMQQAQ5wkiBEGJf08EQCALQn43AwggCyAENgIEDAELIAQEQCALQn43AwggC0G4fzYCBAwBCyAMIAkoAigiBGshCCAEIBZqIQYDQAJAIAYgCCAJQQRqEJQjIhJBiH9NBEAgCCASQQNqIgRPDQFBuH8hEgsgC0J+NwMIIAsgEjYCBAwCCyANQQFqIQ0gCCAEayEIIAQgBmohBiAJKAIIRQ0ACyAJKAIwBEAgCEEDTQRAIAtCfjcDCCALQbh/NgIEDAILIAZBBGohBgsgCyANNgIAIAsgBiAWazYCBCALIAk1AiAgDa1+IAkpAxAiLyAvQn9RGzcDCAsgCUFAayQAIAsoAgQhDyALQRBqJAAgDCAPSQ0AIBYhEiAPIQkgBRCtLSEeQQAhFEEAIRlBACErIwBBEGsiHyQAIB4EQCAeKAIEIRQgHigCCCEZCyAFQZDqAWohLCAQIQYDQEEBQQUgBSgC7OoBGyEHAkACQAJAAkACQANAIAcgCUsNAQJAIAlBBEkNACASKAAAQXBxQdDUtMIBRw0AQbh/IQggCUEISQ0GIBIoAAQiC0F3SwRAQXIhCAwHCyAJIAtBCGoiBEkNBiALQYB/SwRAIAQhCAwHCyAJIARrIQkgBCASaiESDAELCwJAIB4EQCAFIB4Q8igMAQsgBRDhGwJ/QQAgFEUgGUVyDQAaAn8gFCAZQQhJDQAaIBQgFCgAAEG3yMLhfkcNABogBSAUKAAENgKc6wFBYiAFQRBqIBQgGRD3CyIEQYh/Sw0BGiAFQoGAgIAQNwOI6gEgBCAUagshCCAFIAUoAqzpASIHNgK46QEgBSgCsOkBIQQgBSAINgKw6QEgBSAUIBlqNgKs6QEgBSAIIAQgB2tqNgK06QFBAAsiCEGIf0sNBQsgBSAGICUQiilBuH8hCCAJQQVBCSAFKALs6gEiBBtJDQIgEkEBQQUgBBsgBBCxICIEQYh/Sw0DIAkgBEEDakkNAiAFIBIgBBCQFyIHQYh/SwRAIAchBAwECyAGICVqISYgCSAEayELIAQgEmohFSAGIQ0DQCAVIAsgH0EEahCUIyIHQYh/SwRAIAchBAwFCyALQQNrIgsgB0kNAyAVQQNqIhogJiAaICZJGyAmIA0gGk0bIRVBbCEEAkACQAJAAkACQAJAAkACQCAfKAIEDgMBAgAMCyAFIA0gFSANayAaIAdBABCpAiEEDAQLIAcgJiANa0sNCCANRQRAIAcNAgwFCyAHIgRFDQUgDSAaIAT8CgAADAULIB8oAgwiBCAVIA1rSw0HIA0NASAERQ0DC0G2fyEEDAgLIARFDQAgDSAaLQAAIAT8CwALIARBiH9LDQYMAQtBACEECyAFKAL06gEEQCAsIA0gBBCJDAsgCyAHayELIAcgGmohFSAEIA1qIQ0gHygCCEUNAAsgBSkDwOkBIi9Cf1IEQEFsIQQgLyANIAZrrFINBAsCfyAFKALg6QFFBEAgCyEJIBUMAQtBaiEEIAtBBEkNBCAFKALw6gFFBEAgFSgAACAsEO4Wp0cNBQsgC0EEayEJIBVBBGoLIRIgDSAGayEEDAMLIAkEQEG4fyEIDAQLIAYgEGshCAwDC0G6fyEEDAELQbh/IQQLICtBACAEa0EAIARBiX9PG0EKRnENACAEQYh/SwRAIAQhCAwBCyAlIARrISUgBCAGaiEGQQEhKwwBCwsgH0EQaiQAIAgiBkGIf0sNCiAFQQA2ArTrASAFQQA2ArzpASAOIAYgEGpBACAQGzYCHCAPIBZqIQRBASEIDAgLAkAgBSgC5OsBQQFHDQAgBSgC1OkBQQFGDQAgHSkDACIvQn9RDQAgLyAbIA4oAhxrrVYNCQsgBSAFEK0tEPIoIAUCfyAFKACg7AVBcHFB0NS0wgFGBEAgBSgApOwFIQhBBwwBCyAFIBwgBSgC2OsBEJAXIgZBiH9LDQpBAyEIQQILNgKE6gEgBSAINgK86QEgBUKACCAFKQPI6QEiLyAvQoAIWBsiLzcDyOkBIAU1AsTrASAvVARAQXAhBgwKC0EEIAUoAtDpASIEIARBBE0bIRBBACEGQQAhBCAFKALk6wFFBEBBcCAdKQMAIjAgL0KAgAggLyAvQoCACFobfELAgAh8Ii8gLyAwVhsiL6cgL0KAgICAEFobIQQLIAUoAszrASIJIAUoArzrASIIaiAEIBBqIg9BA2xPBEAgBSgCtOwFQQFqIQYLIAUgBjYCtOwFIAggEEkgBCAJS3JFIAZBgAFJcUUEQAJAAkAgBSgCkOsBIgYEQCAPIAZBuOwFa00NAQwKCyAFKAK46wEgDkEYaiAoQQhqIgYoAgA2AgAgDiAoKQIANwMQIA5BEGoQiy0gBUEANgLM6wEgBUEANgK86wEgDkEIaiAGKAIANgIAIA4gKCkCADcDACAFIA8gDhDZLiIGNgK46wEgBkUNCQwBCyAFKAK46wEhBgsgBSAENgLM6wEgBSAQNgK86wEgBSAGIBBqNgLI6wELIAVBAjYCtOsBCyAFIBggB2siBBCoKCIGRQRAIAVBADYCtOsBQQEhCCAHIQQMBwsgBCAGTwRAIAYgB2ohBEEAIQggBSAOQRxqIBsgByAGEJkXIgZBiX9JDQcMCQtBASEIIAcgGCIERg0GIAVBAzYCtOsBCyAFKAK86QEiCSAFKALA6wEiCGshDwJAIAUoAoTqAUEHRwRAIAUoArzrASAIayAPSQRAQWwhBgwKCyAPIBggB2siBCAEIA9LGyIGRQ0EIAYEQCAFKAK46wEgCGogByAG/AoAAAsgBSgCwOsBIQgMAQsgDyAYIAdrIgQgBCAPSxsiBkUNAwsgBSAGIAhqNgLA6wEgBiAHagwDCyApIBsgDigCHCIIayIPIAUoAtTrASAFKALQ6wEiBGsiBiAGIA9LGyIQBH8gEARAIAggBSgCyOsBIARqIBD8CgAACyAFKALQ6wEFIAQLIBBqIgk2AgAgDiAIIBBqQQAgCBs2AhxBASEIIAchBCAGIA9LDQQgBUECNgK06wFBACEIIAUpA8DpASAFKALM6wEiBq1YDQQgBSgC0OkBIAlqIAZNDQQgBUIANwPQ6wEMBAsgEyAHIBMoAgBrNgIIIBdBCGogDigCHCIGIBcoAgBrIgQ2AgAgJEEIaiAENgIAICQgFykCADcCAAJAIAcgFkcgBiAuR3JFBEAgBSAFKALg6wEiBEEBajYC4OsBIARBD0gNASAjICdGBEBBsH8hBgwICyAhICJHDQFBrn8hBgwHCyAFQQA2AuDrAQsgBSgCvOkBIgRFBEAgBSgC3OsBIQQCQAJAIAUoAtTrASAFKALQ6wFGBEBBACEGIARFDQkgEygCCCIEIBMoAgRPBEAgBUECNgK06wEMAgsgEyAEQQFqNgIIDAkLIARFDQELQQEhBgwHC0EBIQYgBUEBNgLc6wEgEyATKAIIQQFrNgIIDAYLIAQgBSgCwOsBa0EDQQAgBSgChOoBQQJrIgRBBU0EfyAEQQJ0QeC10QBqKAIABUEAC0ECRhtqIQYMBQtBACEGIAcLIQRBASEIIAYgD0kNAUEAIQggBUEANgLA6wEgBSAOQRxqIBsgBSgCuOsBIAkQmRciBkGJf0kNAQwDCwtBQCEGDAELQbp/IQYLIA5BIGokACARQQhqIAYQ3i8gESgCDCEIIBEoAgghByAtEIotIBEoAhwiBiARKAIQIgQoAgRLBEBB/OLQAEEsQajj0AAQnykACyAKQRhqIQkgBCAGNgIIICBBCGoiBCAINgIEIAQgBzYCACARQTBqJAAgICgCDCEEAkAgICgCCEEBcQRAIAkgBBDiGgwBCyAJQQQ6AAAgCSAENgIECyAgQRBqJAAgCi0AGEEERgRAIAooAhwhDAwCCyAKKQMYIi9C/wGDQgRSDQAgL0IgiKchDAwBCyAAIC83AgAMAgsCQCAMDQAgAUEBOgAiIAEtACFFDQAgAUECOgAgCyAKKAIoIgcgCigCJEsNAiABIAEoAgwiBiABKAIIIAooAhRqIgQgBCAGSxs2AghBACEGIAdFDQALIABBBDoAACAAIAc2AgQLIApBMGokAA8LQbji0ABBMUHs4tAAEJ8pAAvhBgELfyMAQSBrIggkAAJAAkAgACgCACIJQQhqIgAgCSgCCEECRkECdGoiBy0AIEEDRwRAIAcoAhAhCiAHKAIMIQwgBigCCCIHIAYoAgBGBEAgBkHwvc8AEJsoCyAGKAIEIAdBA3RqIgsgCjYCBCALIAw2AgAgBiAHQQFqIgc2AggCQAJAAkACQCAAIAAoAgAiCkECRkECdGotACBBAWsOAwIBAAMLQZ+6zwBBK0HMus8AEJ8pAAsgAkEBaiECCyADQQFqIQMLAkAgCkECRgRAIAkoAjgiB0UNASAJKAI0IQAgB0ECdCEJA0AgACABIAIgAyAEIAUgBhDTCiAGKAIIIgcEQCAGIAdBAWs2AggLIABBBGohACAJQQRrIgkNAAsMAQsgCEEANgIMIAhCgICAgMAANwIEIAYoAgQhACMAQRBrIgokACAIQQRqIgYgACAHQQN0aiILIABrQQN2EIIuIAogBikCBEIgiTcCCCAKIAZBCGo2AgQjAEEQayIGJAAgCkEEaiIHKAIEIQwgBygCACEQAkACQCAAIAtHBEAgBygCCCAMQQxsaiEHIAsgAGtBA3YhDQNAIAAoAgAhESAGQQRqIABBBGooAgAiC0EAQQFBARCgGCAGKAIIIQ4gBigCBEEBRg0CIAYoAgwhDyALBEAgDyARIAv8CgAACyAHQQhqIAs2AgAgB0EEaiAPNgIAIAcgDjYCACAAQQhqIQAgB0EMaiEHIAxBAWohDCANQQFrIg0NAAsLIBAgDDYCACAGQRBqJAAMAQsgDiAGKAIMQfSOzwAQ/S8ACyAKQRBqJAAgCSAJKAIAIgBBAWo2AgAgAEEASA0CIAhBGGoiBiAIQQxqKAIANgIAIAggCCkCBDcDEEEcQQQQrTYiAEUNAyAAQoGAgIAQNwIAIAAgCCkDEDcCCCAAIAI7ARogACADOwEYIAAgCTYCFCAAQRBqIAYoAgA2AgAgBCgCCCICIAQoAgBGBEAgBEGQvs8AEJ0oCyAEKAIEIAJBAnRqIAA2AgAgBCACQQFqNgIIIAUoAggiACAFKAIARgRAIAVBoL7PABCdKAsgBSgCBCAAQQJ0aiABNgIAIAUgAEEBajYCCAsgCEEgaiQADwtBqL3PAEE2QeC9zwAQnykLAAtBBEEcEKM9AAvtCgISfwN+IwBBIGsiCyQAIAsgAzcDGCALIAI3AxAgAUEQaiIGIAtBEGoQsAwhAyABKAIIRQRAIAtBCGohDiMAQdAAayIFJAAgBSAGNgIcIAEoAgwhDSAFIAVBHGo2AiACQAJAIA0gDUEBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAn8gB0EBaiIHIAYgBiAHSRsiBkEPTwRAIAZB/////wFLDQVBfyAGQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBkEISRsgBkEESRsLIQYgBUFAayABQRBqIghBIEEQIAYQnRQgBSgCRCEHIAUoAkAiCUUEQCAFKAJIIQYMBQsgBSkCSCECIAdBCWoiBgRAIAlB/wEgBvwLAAsgBSACQiCIPgI8IAUgAqciEDYCOCAFIAc2AjQgBSAJNgIwIAVCoICAgIACNwIoIAUgCDYCJCAFQTBqIREgBSANBH8gCUEIaiESIAEoAgAiDykDAEJ/hUKAgYKEiJCgwIB/gyECQQAhBgNAIAJQBEADQCAGQQhqIQYgD0EIaiIPKQMAQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAJIAcgBSgCHCABKAIAIAJ6p0EDdiAGaiITQQV0a0EgaxCwDKciFHEiCGopAABCgIGChIiQoMCAf4MiF1AEQEEIIQoDQCAIIApqIQggCkEIaiEKIAkgByAIcSIIaikAAEKAgYKEiJCgwIB/gyIXUA0ACwsgAkIBfSACgyECIAkgF3qnQQN2IAhqIAdxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogFEEZdiIKOgAAIBIgCEEIayAHcWogCjoAACAJIAhBf3NBBXRqIgggASgCACATQX9zQQV0aiIKKQAANwAAIAhBGGogCkEYaikAADcAACAIQRBqIApBEGopAAA3AAAgCEEIaiAKQQhqKQAANwAAIA1BAWsiDQ0ACyABKAIMBUEACyIGNgI8IAUgECAGazYCOCABIBFBBBD6KiAFQSRqENAmDAELIAEgBUEgakGg2oABQSAQxwkLQYGAgIB4IQcMAgsQ4ycgBSgCDCEGIAUoAgghBwwBCxDjJyAFKAIUIQYgBSgCECEHCyAOIAY2AgQgDiAHNgIAIAVB0ABqJAALIAEoAgQiBiADp3EhBSADQhmIIhhC/wCDQoGChIiQoMCAAX4hGSABKAIAIQcDQAJ/AkACQAJAIAUgB2opAAAiFyAZhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiA1BFBEADQCALQRBqQRAgASgCACADeqdBA3YgBWogBnEiCUEFdGtBIGtBEBCfOw0CIANCAX0gA4MiA1BFDQALCyAXQoCBgoSIkKDAgH+DIQIgFUUEQCACUA0DIAJ6p0EDdiAFaiAGcSEMC0EBIAIgF0IBhoNQDQMaQQAhBSAHIAxqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQwLIAEoAgAiBiAMaiIHLQAAIQkgCykDECECIAspAxghAyAHIBinQf8AcSIHOgAAIAYgASgCBCAMQQhrcWpBCGogBzoAACABIAEoAgxBAWo2AgwgBiAMQQV0ayIGQSBrIgcgAzcDCCAHIAI3AwAgASABKAIIIAlBAXFrNgIIIAZBEGsgBDYCAAwBCyABKAIAQQAgCWtBBXRqQRBrIgUoAgAhASAFIAQ2AgBBASEFCyAAIAE2AgQgACAFNgIAIAtBIGokAA8LQQALIRUgBSAWQQhqIhZqIAZxIQUMAAsAC9MEAQh/IwBBEGsiBCQAAkACQAJAAkACQAJAAkAgASgCIARAAkAgASgCMCIHIAMgAyAHSxsiB0EMbCIIIAEoAiggASgCNCIFa00EQCAEIAFBIGogBSAFIAhqENIQIAEgASgCNCAIajYCNCAEKAIIIQYgBCgCBCEJAkAgB0UNACADQQxsIQpBACEDIAchCANAIAMgCkYNASADQXxGDQYgA0EEaiIFIAZLDQcgBSADQQhqIgVLDQggBSAGSw0JIAUgA0EMaiIFSw0KIAUgBksNCyADIAlqIgMoAAAhCyACIANBBGooAAA2AgQgAiALNgIAIAIgA0EIaigAADYCCCAFIQMgAkEMaiECIAhBAWsiCA0ACwsgASABKAIwIAdrNgIwIAAgBzYCBCAAQQg2AgAgBEEMaiAJIAYgBCgCACgCEBEBAAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNAiAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGU/swAEMskAAsgAiAEKAIIQdT9zAAQ/S8AC0F8QQBBpP7MABCxOwALIANBBGogBkGk/swAELA7AAsgA0EEaiADQQhqQbT+zAAQsTsACyADQQhqIAZBtP7MABCwOwALIANBCGogA0EMakHE/swAELE7AAsgA0EMaiAGQcT+zAAQsDsAC9MEAQh/IwBBEGsiBCQAAkACQAJAAkACQAJAAkAgASgCIARAAkAgASgCMCIHIAMgAyAHSxsiB0EMbCIIIAEoAiggASgCNCIFa00EQCAEIAFBIGogBSAFIAhqENIQIAEgASgCNCAIajYCNCAEKAIIIQYgBCgCBCEJAkAgB0UNACADQQxsIQpBACEDIAchCANAIAMgCkYNASADQXxGDQYgA0EEaiIFIAZLDQcgBSADQQhqIgVLDQggBSAGSw0JIAUgA0EMaiIFSw0KIAUgBksNCyADIAlqIgMoAAAhCyACIANBBGooAAA2AgQgAiALNgIAIAIgA0EIaigAADYCCCAFIQMgAkEMaiECIAhBAWsiCA0ACwsgASABKAIwIAdrNgIwIAAgBzYCBCAAQQg2AgAgBEEMaiAJIAYgBCgCACgCEBEBAAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNAiAEKAIIIgFBGGpB8KjOAC8AADsAACABQRBqQeiozgApAAA3AAAgAUEIakHgqM4AKQAANwAAIAFB2KjOACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQfinzgBBIEGYqM4AEMskAAsgAiAEKAIIQdinzgAQ/S8AC0F8QQBBqKjOABCxOwALIANBBGogBkGoqM4AELA7AAsgA0EEaiADQQhqQbiozgAQsTsACyADQQhqIAZBuKjOABCwOwALIANBCGogA0EMakHIqM4AELE7AAsgA0EMaiAGQciozgAQsDsAC+QDAQZ/IAEgBE0gASADS3JFBEAgAiABQQN0aiEGIAAgBEEDdGohCCAAIQMDQCAAIARBA2siCUEAIAQgCU8bQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayADKAIAIAgoAgBJIgcbaiADKQIANwIAIAUgB2oiBUEDdCACIAZBEGsgA0EIaiIHKAIAIAgoAgBJIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBGGsgA0EQaiIHKAIAIAgoAgBJIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBIGsiBiADQRhqIgcoAgAgCCgCAEkiChtqIAcpAgA3AgAgBSAKaiEFIANBIGoiAyAJSQ0ACwsgACAEQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayIGIAMoAgAgCCgCAEkiBxtqIAMpAgA3AgAgBSAHaiEFIANBCGoiAyAJSQ0ACwsgASAERwRAIAZBCGsiBiAFQQN0aiADKQIANwIAIANBCGohAyABIQQMAQsLIAVBA3QiAwRAIAAgAiAD/AoAAAsgASAFRwRAIAEgBWshBCAAIAVBA3RqIQMgAUEDdCACakEIayEGA0AgAyAGKQIANwIAIAZBCGshBiADQQhqIQMgBEEBayIEDQALCyAFDwsAC/ADAQZ/IAEgBE0gASADS3JFBEAgAiABQQN0aiEGIAAgBEEDdGohCCAAIQMDQCAAIARBA2siCUEAIAQgCU8bQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayAIKAIAIAMoAgBPIgcbaiADKQIANwIAIAUgB2oiBUEDdCACIAZBEGsgCCgCACADQQhqIgcoAgBPIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBGGsgCCgCACADQRBqIgcoAgBPIgobaiAHKQIANwIAIAUgCmoiBUEDdCACIAZBIGsiBiAIKAIAIANBGGoiBygCAE8iChtqIAcpAgA3AgAgBSAKaiEFIANBIGoiAyAJSQ0ACwsgACAEQQN0aiIJIANLBEADQCAFQQN0IAIgBkEIayIGIAgoAgAgAygCAE8iBxtqIAMpAgA3AgAgBSAHaiEFIANBCGoiAyAJSQ0ACwsgASAERwRAIAVBA3QgAiAGQQhrIgZBARtqIAMpAgA3AgAgA0EIaiEDIAVBAWohBSABIQQMAQsLIAVBA3QiAwRAIAAgAiAD/AoAAAsgASAFRwRAIAEgBWshBCAAIAVBA3RqIQMgAUEDdCACakEIayEGA0AgAyAGKQIANwIAIAZBCGshBiADQQhqIQMgBEEBayIEDQALCyAFDwsAC7IEAgt/A34jAEFAaiICJAAgASAAKAI4IAAoAjwQuwkgAkH/AToAGCABIAJBGGoiBUEBELsJIABBKGogARCTCSACIAAtAEA6ABggASAFQQEQuwkgBSAAEPgoIAJBDGogBUHUgoQBEMoSIAIoAhAhAwJAIAIoAhQiBEECSQ0AIARBFU8EQCADIAQgBRDJGwwBCyADIAQQlScLIAIgAigCDDYCICACIAM2AhwgAiADNgIYIAIgAyAEQQJ0aiIINgIkIAQEQCAAQRBqIQkgACgCACIGQRhrIQogACgCBCEEIAAoAgwhCwNAIAIgA0EEaiIANgIcIAEgAygCACIFKAIEIAUoAggQuwkgAkH/AToAPyABIAJBP2pBARC7CQJAAkAgC0UNACAEIAkgBRD4CyINp3EhAyANQhmIQv8Ag0KBgoSIkKDAgAF+IQ9BACEHA0AgAyAGaikAACIOIA+FIg1Cf4UgDUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyINUEUEQANAIAUgCiANeqdBA3YgA2ogBHFBaGwiDGoQjDUNBCANQgF9IA2DIg1QRQ0ACwsgDiAOQgGGg0KAgYKEiJCgwIB/g1BFDQEgAyAHQQhqIgdqIARxIQMMAAsAC0HkgoQBQQlB8IKEARDLJAALIAEgBiAMaiIDQQhrKAIAIANBBGsoAgAQuwkgAkH/AToAPyABIAJBP2pBARC7CSAAIgMgCEcNAAsLIAJBGGoQ3isgAkFAayQAC8YHAQt/IwBBMGsiBSQAIAUgATYCDAJAAkACQAJAAkAgAy0ABiIKBEACQCACKAIUIg0gCnBFBEAgBUEYaiACQQhqKAIAIgc2AgAgBSACKQIANwMQIAVBHGohCyAFQQxqIQYgB0EEQQggAy0ABBsiBGoiDiAKQQFrQf8BcSIIaiAIQX9zcSIIIARrIQwjAEEwayIEJAACQAJAAkACQAJAIAMvAQIiCQ4FAQEBAgMACyAEIAk7AQ4gBEEBNgIUIARBpL7MADYCECAEQgE3AhwgBEH4AjYCLCAEIARBKGo2AhggBCAEQQ5qNgIoIARBEGpBrL7MABDvLAALIARBADYCICAEQQE2AhQgBEHkvcwANgIQIARCBDcCGCAEQRBqQey9zAAQ7ywACyAGKAIAIQlBCCEGIAMtAARFBEAgCSgCAEH8vcwAQQQQoTZBBCEGCyAEIAw2AhAgCSgCACAEQRBqQQQQoTYMAQsgBigCACIDKAIAQfy9zABBBBChNiAEIAw2AhAgAygCACAEQRBqQQQQoTZBCCEGCyALQZOAgIB4NgIAIAsgBjYCBCAEQTBqJAAgBSgCHCIEQZOAgIB4Rg0BIAAgBSkCJDcCCCAAQRBqIAVBLGooAgA2AgAgBSgCICEDDAULIAVBHGpBFkEAQQFBARCgGCAFKAIgIQMgBSgCHEEBRg0CIAUoAiQiAUEOakHqvMwAKQAANwAAIAFBCGpB5LzMACkAADcAACABQdy8zAApAAA3AAAgAEEWNgIMIAAgATYCCCAAIAM2AgQgAEGDgICAeDYCACACEN47DAYLIAggDmshAyAHRQ0CIAEoAgAgBSgCFCAHEKE2DAILQfy7zAAQ5ysACyADIAUoAiRB7LvMABD9LwALIANBwQBPBEAgA0HAAEHMvMwAELA7AAsgASgCAEGMvMwAIAMQoTYgDUUEQEEAIQMMAgsgBUEcaiEDIAVBDGooAgAiBygCACACKAIQIAIoAhQiARChNgJAAkAgASABIApBAWtB/wFxIgRqIARBf3NxIgRHBEAgBCABayIBQcEATw0BIAcoAgBBjLzMACABEKE2CyADQZOAgIB4NgIAIAMgBDYCBAwBCyABQcAAQfS8zAAQsDsACyAFKAIgIQMgBSgCHCIEQZOAgIB4Rg0BIAAgBSkCJDcCCCAAQRBqIAVBLGooAgA2AgALIAAgAzYCBCAAIAQ2AgAgBUEQahDeOwwBCyAAIAM2AgggACAINgIEIABBk4CAgHg2AgAgBUEQahDeOwsgAkEMahDeOyAFQTBqJAALugQCCX8BfiMAQSBrIgYkAAJAIANFBEAMAQsgAUEQaiEJA0AgAyAEayEKIAIgBEEDdGohCwJAAkAgASgCNCIMDQAgASgCOCEHAkACQAJAAkADQCAHRQRAIAkoAgBFDQIgBiAJEKUYIAYoAgBBAUcNCSAGKQMIIg1QDQkgDUIBg1BFBEAgASANp0ECdEF4cTYCOAwICyABIA1CAYg+AjQgBkEQaiAJIAEtADwiBUEDdiAFQQdxQQBHahDBHCAGKQMQIQ0gASAGKQMYNwMIIAEgDTcDACANpw0HQcD6zABBLkHw+swAEJ8pAAsgCSgCAEUNAiAHIAogByAKSRsiBSAEaiIIIAVJDQMgAyAISQ0EIAkgCyAFIAEtADwQkAQiBUUEQEEAIQcgAUEANgI4IAEoAjQiDEUNAQwGCwsgASABKAI4IAVrNgI4IAQgBWohBAwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBCAIQcT4zAAQsTsACyAIIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgDCAKIAogDEsbIgggBGoiBSAITwRAIAMgBUkNASADIARHBEAgASkDCCENIAhBA3QhBwNAIAsgDTcDACALQQhqIQsgB0EIayIHDQALCyABIAwgCGs2AjQgBSEEDAILIAQgBUHk+MwAELE7AAsgBSADQeT4zAAQsDsACyADIARLDQALCyAAQQg2AgAgACAENgIEIAZBIGokAAu6BAIJfwF+IwBBIGsiBiQAAkAgA0UEQAwBCyABQRBqIQkDQCADIARrIQogAiAEQQJ0aiELAkACQCABKAI0IgwNACABKAI4IQcCQAJAAkACQANAIAdFBEAgCSgCAEUNAiAGIAkQpRggBigCAEEBRw0JIAYpAwgiDVANCSANQgGDUEUEQCABIA2nQQJ0QXhxNgI4DAgLIAEgDUIBiD4CNCAGQRBqIAkgAS0APCIFQQN2IAVBB3FBAEdqEMEcIAYpAxAhDSABIAYpAxg3AwggASANNwMAIA2nDQdBwPrMAEEuQfD6zAAQnykACyAJKAIARQ0CIAcgCiAHIApJGyIFIARqIgggBUkNAyADIAhJDQQgCSALIAUgAS0APBC5BiIFRQRAQQAhByABQQA2AjggASgCNCIMRQ0BDAYLCyABIAEoAjggBWs2AjggBCAFaiEEDAULQZz4zABBGEGw+swAEMskAAtBnPjMAEEYQbT4zAAQyyQACyAEIAhBxPjMABCxOwALIAggA0HE+MwAELA7AAsgASgCAEUEQEHU+MwAELI7AAsCQCAMIAogCiAMSxsiCCAEaiIFIAhPBEAgAyAFSQ0BIAMgBEcEQCABKAIIIQQgCEECdCEHA0AgCyAENgIAIAtBBGohCyAHQQRrIgcNAAsLIAEgDCAIazYCNCAFIQQMAgsgBCAFQeT4zAAQsTsACyAFIANB5PjMABCwOwALIAMgBEsNAAsLIABBCDYCACAAIAQ2AgQgBkEgaiQAC9kEAgN/An4jAEHwAGsiAyQAIAEoAgghBAJAAkAgAAJ/IAEoAgwoAhAgAkEDdGopAwAiBkKAgICACHxC/////w9YBEAgAyAEKAIAKAIAKAIAIgU2AjAgAyAGPgIEAkAgBiAFrH4iB0IgiKcgB6ciBUEfdUcEQCADQQI2AlQgA0GskP8ANgJQIANCAjcCXCADQYIMNgIUIANBggw2AgwgAyADQQhqNgJYIAMgA0EwajYCECADIANBBGo2AgggA0E8aiADQdAAahCZDiADQSBqIANBQGspAgA3AwAgA0EoaiADQcgAaigCADYCACADQYiAgIB4NgI4IAMgAykCOCIHNwMYIAenQZOAgIB4Rw0BIAMoAhwhBQsgA0HQAGogBSAEKAIILQAAEOoPIAMoAlAiBEGTgICAeEYNAyADQRBqIANB4ABqKAIANgIAIAMgAykCWDcDCCADKAJUDAILIANBGGoQiBELIAQoAgQhASADIAY3AzAgA0HMkf8ANgI4IANCBDcCRCADQYYMNgJsIANB9As2AmQgAyABQQFqNgJgIANBuwc2AlwgAyABNgJYIANBzAE2AlQgA0H4kf8ANgJQIAMgA0HQAGo2AkAgAyADQTBqNgJoIANBBDYCPCADQRxqIANBOGoQmQ4gA0EQaiADQShqKAIANgIAIAMgAykCIDcDCEGCgICAeCEEIAMoAhwLNgIEIAAgBDYCACAAIAMpAwg3AgggAEEQaiADQRBqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQJ0aiAFNgIACyADQfAAaiQAC7MEAQR/IwBBsAFrIgckACAHIAI2AmAgB0EIaiADQcAA/AoAACAHQewAaiAGQQhqKAIANgIAIAdB0ABqIARBCGoiCSgCADYCACAHQdwAaiAFQQhqKAIANgIAIAcgBikCADcCZCAHIAQpAgA3A0ggByAFKQIANwJUIAEoAgAiAygCCCIIIAMoAgBGBEAgA0Hkv8MAEJAoCyADKAIEIAhBDGxqIgogBCkCADcCACAKQQhqIAkoAgA2AgAgAyAIQQFqNgIIIAEoAgQiBCgCCCIIIAQoAgBGBEAgBEH0v8MAEJAoCyAEKAIEIAhBDGxqIgkgBSkCADcCACAJQQhqIAVBCGooAgA2AgAgBCAIQQFqNgIIIAEoAggiBCgCCCIFIAQoAgBGBEAgBEGEwMMAEJAoCyAEKAIEIAVBDGxqIgggBikCADcCACAIQQhqIAZBCGooAgA2AgAgBCAFQQFqNgIIAkACQCABLQAQQQFGDQAgB0HwAGogAiADKAIEIAMoAgggB0EIaiIDEIAHIAcoAnAiAkEIRg0AIAAgBykCdDcCBCAAQRRqIAdBhAFqKAIANgIAIABBDGogB0H8AGopAgA3AgAgACACNgIAIAMQ/yUMAQsgASgCDCEBIAdB8ABqIAdBCGpBwAD8CgAAIAEoAggiAiABKAIARgRAIAFBlMDDABCcKAsgASgCBCACQQZ0aiAHQfAAakHAAPwKAAAgASACQQFqNgIIIABBCDYCAAsgB0GwAWokAAuzBAEEfyMAQbABayIHJAAgByACNgJgIAdBCGogA0HAAPwKAAAgB0HsAGogBkEIaigCADYCACAHQdAAaiAEQQhqIgkoAgA2AgAgB0HcAGogBUEIaigCADYCACAHIAYpAgA3AmQgByAEKQIANwNIIAcgBSkCADcCVCABKAIAIgMoAggiCCADKAIARgRAIANB5L/DABCQKAsgAygCBCAIQQxsaiIKIAQpAgA3AgAgCkEIaiAJKAIANgIAIAMgCEEBajYCCCABKAIEIgQoAggiCCAEKAIARgRAIARB9L/DABCQKAsgBCgCBCAIQQxsaiIJIAUpAgA3AgAgCUEIaiAFQQhqKAIANgIAIAQgCEEBajYCCCABKAIIIgQoAggiBSAEKAIARgRAIARBhMDDABCQKAsgBCgCBCAFQQxsaiIIIAYpAgA3AgAgCEEIaiAGQQhqKAIANgIAIAQgBUEBajYCCAJAAkAgAS0AEEEBRg0AIAdB8ABqIAIgAygCBCADKAIIIAdBCGoiAxCBByAHKAJwIgJBCEYNACAAIAcpAnQ3AgQgAEEUaiAHQYQBaigCADYCACAAQQxqIAdB/ABqKQIANwIAIAAgAjYCACADEP8lDAELIAEoAgwhASAHQfAAaiAHQQhqQcAA/AoAACABKAIIIgIgASgCAEYEQCABQZTAwwAQnCgLIAEoAgQgAkEGdGogB0HwAGpBwAD8CgAAIAEgAkEBajYCCCAAQQg2AgALIAdBsAFqJAALqgQBBX8gACgCACAAKAIIakFwIAIgA2siBEEEdCAEQQ9PGzoAACAAIAAoAghBAWo2AgggBEEOSwRAIARBD2siBUH8B08EQCAAKAIAIQcgBUH8B24iCEECdCIGBEAgByAAKAIIakH/ASAG/AsACyAAIAAoAgggBmo2AgggBSAIQfwHbGshBQsgACgCACAAKAIIakF/NgAAIAAgBUH//wNxQf8BbiIGIAAoAghqQQFqNgIIIAAoAgAgACgCCGpBAWsgBSAGajoAAAsCQAJAIAIgA08EQCAAKAIIIgYgBGoiBSAGSQ0BIAUgACgCBCIHSw0CAkAgAiADRg0AIAEgA2ohASAAKAIAIAZqIQICQAJAAkAgBEEETwRAIARBCEkNASAEQRFJDQIgBEEhSQ0DIARFDQQgAiABIAT8CgAADAQLIAIgAS0AADoAACAEQQFGDQMgAiABLwAAOwAAIAIgBEECayIDaiABIANqLwAAOwAADAMLIAIgASgAADYAACACIARBBGsiA2ogASADaigAADYAAAwCCyACIAEpAAA3AAAgAiAEQQhrIgNqIAEgA2opAAA3AAAMAQsgAiABKQAANwAAIAJBCGogAUEIaikAADcAACACIARBEGsiA2oiAiABIANqIgEpAAA3AAAgAkEIaiABQQhqKQAANwAACyAAIAU2AggPCyADIAJBxPbOABCvOwALIAYgBUGM8s4AELE7AAsgBSAHQYzyzgAQsDsAC5sEAQh/IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCqDgwDCyAAIAFBA3YiBUEcbGohByAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggByAFIAQQphMMAQsgACgCACIGIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAcoAgAiCyAFTw0DIAAgByAIIAwoAgAiBSAGQQJ0aigCACIHIAUgCUECdGooAgAiCEkiBiAIIAUgC0ECdGooAgAiBUlzGyAGIAUgB0tzGwsgAGsiBkECdiEHIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgBmooAgAiBiAFTw0EIAkoAgAiBSAIQQJ0aigCACAFIAZBAnRqKAIASQ0GIAogBDYCDCAAIAEgByAKQQxqEKUfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgBiAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAGIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgByAEEKsfIgUgAiADIAQQ4QogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQghMLIApBEGokAAudBAIIfwN+IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCrDgwDCyAAIAFBA3YiBUEcbGohBiAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggBiAFIAQQpxMMAQsgACgCACIHIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAYoAgAiCyAFTw0DIAAgBiAIIAwoAgAiBSAHQQN0aikDACINIAUgCUEDdGopAwAiDlQiBiAOIAUgC0EDdGopAwAiD1RzGyAGIA0gD1RzGwsgAGsiB0ECdiEGIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgB2ooAgAiByAFTw0EIAkoAgAiBSAIQQN0aikDACAFIAdBA3RqKQMAVA0GIAogBDYCDCAAIAEgBiAKQQxqEKYfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgByAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAHIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgBiAEEKofIgUgAiADIAQQ4gogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQgRMLIApBEGokAAubBAEIfyMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQqg4MAwsgACABQQN2IgVBHGxqIQcgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAcgBSAEEKYTDAELIAAoAgAiBiAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAHKAIAIgsgBU8NAyAAIAcgCCAMKAIAIgUgBkECdGooAgAiByAFIAlBAnRqKAIAIghJIgYgCCAFIAtBAnRqKAIAIgVJcxsgBiAFIAdLcxsLIABrIgZBAnYhByACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAZqKAIAIgYgBU8NBCAJKAIAIgUgCEECdGooAgAgBSAGQQJ0aigCAEkNBiAKIAQ2AgwgACABIAcgCkEMahClHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAYgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgBiAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAcgBBCrHyIFIAIgAyAEEOMKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIITCyAKQRBqJAALmwQBCH8jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKkODAMLIAAgAUEDdiIFQRxsaiEHIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAHIAUgBBClEwwBCyAAKAIAIgYgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBygCACILIAVPDQMgACAHIAggDCgCACIFIAZBAnRqKAIAIgcgBSAJQQJ0aigCACIISCIGIAggBSALQQJ0aigCACIFSHMbIAYgBSAHSnMbCyAAayIGQQJ2IQcgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAGaigCACIGIAVPDQQgCSgCACIFIAhBAnRqKAIAIAUgBkECdGooAgBIDQYgCiAENgIMIAAgASAHIApBDGoQqR8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAGIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAYgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAHIAQQpx8iBSACIAMgBBDkCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBD/EgsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKwODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCkEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOUyIGIA4gBSALQQN0aikDACIPU3MbIAYgDSAPU3MbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBTDQYgCiAENgIMIAAgASAGIApBDGoQqB8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQpB8iBSACIAMgBBDlCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCAEwsgCkEQaiQAC5sEAQh/IwBBEGsiCiQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCAAIAEgBBCpDgwDCyAAIAFBA3YiBUEcbGohByAAIAVBBHRqIQgCQAJAAkACQAJAAkACQAJAAn8gAUHAAE8EQCAAIAggByAFIAQQpRMMAQsgACgCACIGIAQoAgAiDCgCBCIFTw0BIAgoAgAiCSAFTw0CIAcoAgAiCyAFTw0DIAAgByAIIAwoAgAiBSAGQQJ0aigCACIHIAUgCUECdGooAgAiCEgiBiAIIAUgC0ECdGooAgAiBUhzGyAGIAUgB0pzGwsgAGsiBkECdiEHIAJFDQYgAigCACIIIAQoAgAiCSgCBCIFTw0DIAAgBmooAgAiBiAFTw0EIAkoAgAiBSAIQQJ0aigCACAFIAZBAnRqKAIASA0GIAogBDYCDCAAIAEgByAKQQxqEKkfIgVBAWohAiABIAVNDQUgASACayEBIAAgAkECdGohAEEAIQIMBwsgBiAFQZCDhAEQwyEACyAJIAVBoIOEARDDIQALIAsgBUGgg4QBEMMhAAsgCCAFQZCDhAEQwyEACyAGIAVBoIOEARDDIQALIAIgAUGwg4QBEK87AAsgACAAIAEgByAEEKcfIgUgAiADIAQQ5gogASAFQX9zaiEBIAAgBUECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACABIAQQ/xILIApBEGokAAubBAEIfyMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQqg4MAwsgACABQQN2IgVBHGxqIQcgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAcgBSAEEKYTDAELIAAoAgAiBiAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAHKAIAIgsgBU8NAyAAIAcgCCAMKAIAIgUgBkECdGooAgAiByAFIAlBAnRqKAIAIghJIgYgCCAFIAtBAnRqKAIAIgVJcxsgBiAFIAdLcxsLIABrIgZBAnYhByACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAZqKAIAIgYgBU8NBCAJKAIAIgUgCEECdGooAgAgBSAGQQJ0aigCAEkNBiAKIAQ2AgwgACABIAcgCkEMahClHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAYgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgBiAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAcgBBCrHyIFIAIgAyAEEOcKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIITCyAKQRBqJAALnQQCCH8DfiMAQRBrIgokAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgACABIAQQrA4MAwsgACABQQN2IgVBHGxqIQYgACAFQQR0aiEIAkACQAJAAkACQAJAAkACQAJ/IAFBwABPBEAgACAIIAYgBSAEEKQTDAELIAAoAgAiByAEKAIAIgwoAgQiBU8NASAIKAIAIgkgBU8NAiAGKAIAIgsgBU8NAyAAIAYgCCAMKAIAIgUgB0EDdGopAwAiDSAFIAlBA3RqKQMAIg5TIgYgDiAFIAtBA3RqKQMAIg9TcxsgBiANIA9TcxsLIABrIgdBAnYhBiACRQ0GIAIoAgAiCCAEKAIAIgkoAgQiBU8NAyAAIAdqKAIAIgcgBU8NBCAJKAIAIgUgCEEDdGopAwAgBSAHQQN0aikDAFMNBiAKIAQ2AgwgACABIAYgCkEMahCoHyIFQQFqIQIgASAFTQ0FIAEgAmshASAAIAJBAnRqIQBBACECDAcLIAcgBUGQg4QBEMMhAAsgCSAFQaCDhAEQwyEACyALIAVBoIOEARDDIQALIAggBUGQg4QBEMMhAAsgByAFQaCDhAEQwyEACyACIAFBsIOEARCvOwALIAAgACABIAYgBBCkHyIFIAIgAyAEEOgKIAEgBUF/c2ohASAAIAVBAnRqIgJBBGohAAsgA0EBayEDIAFBIU8NAAsLIAAgASAEEIATCyAKQRBqJAALmwQBCH8jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKkODAMLIAAgAUEDdiIFQRxsaiEHIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAHIAUgBBClEwwBCyAAKAIAIgYgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBygCACILIAVPDQMgACAHIAggDCgCACIFIAZBAnRqKAIAIgcgBSAJQQJ0aigCACIISCIGIAggBSALQQJ0aigCACIFSHMbIAYgBSAHSnMbCyAAayIGQQJ2IQcgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAGaigCACIGIAVPDQQgCSgCACIFIAhBAnRqKAIAIAUgBkECdGooAgBIDQYgCiAENgIMIAAgASAHIApBDGoQqR8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAGIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAYgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAHIAQQpx8iBSACIAMgBBDpCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBD/EgsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKsODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCnEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOVCIGIA4gBSALQQN0aikDACIPVHMbIAYgDSAPVHMbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBUDQYgCiAENgIMIAAgASAGIApBDGoQph8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQqh8iBSACIAMgBBDqCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCBEwsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKwODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCkEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOUyIGIA4gBSALQQN0aikDACIPU3MbIAYgDSAPU3MbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBTDQYgCiAENgIMIAAgASAGIApBDGoQqB8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQpB8iBSACIAMgBBDrCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCAEwsgCkEQaiQAC50EAgh/A34jAEEQayIKJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAAgASAEEKsODAMLIAAgAUEDdiIFQRxsaiEGIAAgBUEEdGohCAJAAkACQAJAAkACQAJAAkACfyABQcAATwRAIAAgCCAGIAUgBBCnEwwBCyAAKAIAIgcgBCgCACIMKAIEIgVPDQEgCCgCACIJIAVPDQIgBigCACILIAVPDQMgACAGIAggDCgCACIFIAdBA3RqKQMAIg0gBSAJQQN0aikDACIOVCIGIA4gBSALQQN0aikDACIPVHMbIAYgDSAPVHMbCyAAayIHQQJ2IQYgAkUNBiACKAIAIgggBCgCACIJKAIEIgVPDQMgACAHaigCACIHIAVPDQQgCSgCACIFIAhBA3RqKQMAIAUgB0EDdGopAwBUDQYgCiAENgIMIAAgASAGIApBDGoQph8iBUEBaiECIAEgBU0NBSABIAJrIQEgACACQQJ0aiEAQQAhAgwHCyAHIAVBkIOEARDDIQALIAkgBUGgg4QBEMMhAAsgCyAFQaCDhAEQwyEACyAIIAVBkIOEARDDIQALIAcgBUGgg4QBEMMhAAsgAiABQbCDhAEQrzsACyAAIAAgASAGIAQQqh8iBSACIAMgBBDsCiABIAVBf3NqIQEgACAFQQJ0aiICQQRqIQALIANBAWshAyABQSFPDQALCyAAIAEgBBCBEwsgCkEQaiQAC+wCAQF/IwBBMGsiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCACACIABBA3YiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEEDdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkEDdGopAgA3AgQgBCAEQQhqNgIgIANBkI6EAUEPQZ+OhAFBBCAEQQRqQfCNhAFBo46EAUEMIARBIGpBgI6EARCOGCAEQTBqJAAPCyAEIAA2AhwgBEECNgIIIARBuJeEATYCBCAEQgI3AhAgBEE7NgIsIARBOzYCJCAEIARBIGo2AgwgBCAEQRxqNgIoIAQgBDYCICAEQQRqQciXhAEQ7ywAC5oEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBSABKAIgIgRBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgVFDQQLIAJCADcCRCACIAU2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAEEOcQCyAEBEAgASgCHCEFQQAhAQNAAkAgASAFaiwAACIDIAIoAjBPDQAgAigCJCACKAIsIANqIgNBA3ZqLQAAIANBB3F2QQFxDQAgAiACQThqEIY9IAFBA3YiAyACKAIEIgZJBEAgAigCACADaiIDIAMtAABBfiABQQdxd3E6AAAMAQsgAyAGQdTmhAEQwyEACyAEIAFBAWoiAUcNAAsLIAJBzABqIgEgAkE4aiIEEIcUIAAgARDhJyAEEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC5oEAQV/IwBB4ABrIgIkACACQQhqIAEoAjwgASgCQCIEKAIIQQFrQXhxakEIaiAEKAI4EQAAAkACQAJAAkACQCACKAIIBEAgAkEwaiACQRhqKQIANwMAIAJBKGogAkEQaikCADcDACACIAIpAgg3AyBBwAAhBSABKAIgIgRBA3YgBEEHcUEAR2oiA0HA////A3FBQGsgAyADQT9xGyIDQcAAENE0RQ0EIAMEQCADQcAAEK02IgVFDQQLIAJCADcCRCACIAU2AkAgAiADNgI8IAJBwAA2AjggASgCJEUNASACQThqIAFBJGoQlS8MAgsgACABQSRqQQAgASgCJBsQ7iUMBAsgAkE4aiAEEOcQCyAEBEAgASgCHCEFQQAhAQNAAkAgASAFai0AACIDIAIoAjBPDQAgAigCJCACKAIsIANqIgNBA3ZqLQAAIANBB3F2QQFxDQAgAiACQThqEIY9IAFBA3YiAyACKAIEIgZJBEAgAigCACADaiIDIAMtAABBfiABQQdxd3E6AAAMAQsgAyAGQdTmhAEQwyEACyAEIAFBAWoiAUcNAAsLIAJBzABqIgEgAkE4aiIEEIcUIAAgARDhJyAEEM8vIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRw0CIAJBIGoQ+x4MAgtBwAAgAxCjPQALQZTnhAFBKSACQcwAakHw6IQBQcDnhAEQ1R4ACyACQeAAaiQAC9sEAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg4NAQIDBAUGBwgJCgsMDQALIAAgA60gBK1CIIaENwMIIAAgAq0gATUAAEIghoQ3AwAPCyAAQgA3AwAgAEEIakIANwMADwsgAEIANwAFIABBATYCACAAQQxqQQA2AAAgACABLQAAOgAEDwsgAEIANwEGIABBAjYCACAAQQ5qQQA7AQAgACABLwAAOwEEDwsgAEIANwAHIABBAzYCACAAQQ9qQQA6AAAgACABLwAAOwAEIABBBmogAUECai0AADoAAA8LIABCADcDCCAAQQQ2AgAgACABKAAANgIEDwsgAEEANgAJIABBBTYCACAAQQxqQQA2AAAgACABKAAANgAEIABBCGogAUEEai0AADoAAA8LIABBADYBCiAAQQY2AgAgAEEOakEAOwEAIAAgASgAADYABCAAQQhqIAFBBGovAAA7AAAPCyAAQQA2AAsgAEEHNgIAIABBD2pBADoAACAAIAEoAAA2AAQgAEEHaiABQQNqKAAANgAADwsgAEEANgIMIABBCDYCACAAIAEpAAA3AgQPCyAAQQA7AA0gAEEJNgIAIABBD2pBADoAACAAIAEpAAA3AAQgAEEMaiABQQhqLQAAOgAADwsgAEEAOwEOIABBCjYCACAAIAEpAAA3AAQgAEEMaiABQQhqLwAAOwAADwsgAEEAOgAPIABBCzYCACAAIAEpAAA3AAQgAEELaiABQQdqKAAANgAADwsgAEEMNgIAIAAgASkAADcABCAAQQxqIAFBCGooAAA2AAALsAQCBH4QfwJAAkAgACgCOCAAKAI8IAEoAjggASgCPBDBLkUNACAAQShqIAFBKGoQwQ5FDQAgAC0AQSABLQBBRw0AIAAtAEBFBEAgAS0AQA0BCyAAQRBqIQ4gACgCACIMQRhrIQ8gASgCACIHQQhqIQogBykDAEJ/hUKAgYKEiJCgwIB/gyECIAAoAgQhCyAAKAIMIRAgASgCDCEBA0AgAUUhACABRQ0CIAJQBEADQCAHQcABayEHIAopAwAgCkEIaiEKQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAQRQ0CIAFBAWshASACQgF9IAKDIAcgAnqnQQN2QWhsaiIIQRBrIREgCEEUayESIAsgDiAIQRhrEPgLIgKncSEJIAJCGYhC/wCDQoGChIiQoMCAAX4hBUEAIQ0DQAJAIAkgDGopAAAiAyAFhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEAgESgCACEGIBIoAgAhEwNAIBMgBiAPIAJ6p0EDdiAJaiALcUFobCIUaiIVKAIEIBUoAggQwS4NAiACQgF9IAKDIgJQRQ0ACwtBACEGIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0DIAkgDUEIaiINaiALcSEJDAELCyECIAAhBiAIQQhrKAIAIAhBBGsoAgAgDCAUaiIAQQhrKAIAIABBBGsoAgAQwS4NAAsLIAYPCyAAC5gGAQx/IwBBIGsiBSQAIAIoAgQhAyABKAIEIQcCQCACKAIIIgYgASgCCCIJTwRAIwBBIGsiASQAIAEgAzYCCCABIAMgBiAJIAYgCUkbIghBAnRqIgo2AgwCQAJAAkACQCABQQhqEJ42IgQgCCAEIAhJGyILBEBBACEEA0AgAyAHKAIAIgwgAygCACINayIOIARrNgIAIAwgDUkgBCAOS3IhBCAHQQRqIQcgA0EEaiEDIAtBAWsiCw0ACyAGIAlJDQEgBA0DDAILIAYgCU8NAQtBkKeIAUEhQbSniAEQnykACyAGQQJ0IAhBAnRrIQMDQCADRQ0CIANBBGshAyAKKAIAIApBBGohCkUNAAsLIAFBADYCGCABQQE2AgwgAUH4pogBNgIIIAFCBDcCECABQQhqQcSniAEQ7ywACyABQSBqJAAMAQsgBSADNgIQIAUgAyAGQQJ0IgFqNgIUIAEgB2ohCgJAIAVBEGoQnjYiASAGIAEgBkkbIgQEQEEAIQEgByEIA0AgAyAIKAIAIgsgAygCACIMayINIAFrNgIAIAsgDEkgASANS3IhASAIQQRqIQggA0EEaiEDIARBAWsiBA0ACyACIAogByAJQQJ0ahCeJCABRQ0CIAIoAggiASAGSQ0BIAIoAgQgBkECdGogASAGa0HEiYgBQQEQzRAMAgsgAiAKIAcgCUECdGoQniQMAQsgBiABQbSJiAEQrzsACyAFQRhqIAJBCGooAgAiBDYCACAFIAIpAgA3AxACQCAERQ0AIAUoAhQiASAEQQJ0IgNqQQRrIgJFDQAgAigCAA0AIAFBBGshAiAEQf////8DcSEBAkADQCADRQRAQQAhAwwCCyABQQFrIQEgAiADaiADQQRrIQMoAgBFDQALIAFBAWoiAyAESw0BCyAFIAM2AhggAyEECwJAIAQgBSgCEEECdk8NACAFQQhqIAVBEGogBEEEQQQQ9BQgBSgCCCIBQYGAgIB4Rg0AIAEgBSgCDEHYiYgBEP0vAAsgACAFKQMQNwIAIABBCGogBUEYaigCADYCACAFQSBqJAALzQYBD38jAEEQayILJAAgAEEANgIQIAEoAhQhEiABKAIYIRMgASgCECEUIAEoAgQgASgCACIKa0EDdSENIAEoAhghDiABKAIUIhchDyABKAIQIhghEANAIA0EQEEfIAooAgBnayEVIApBBmovAQAhESAQAn8gCkEEai8BACIWQcAATwRAQTIgFmdrDAELIBZBgPbQAGotAAALOgAAIA4gFToAACAPIBFBgAFPBH9BwwAgEWdrBSARQcD20ABqLQAACzoAAEEBIAwgFUEYSxshDCAPQQFqIQ8gDkEBaiEOIBBBAWohECAKQQhqIQogDUEBayENDAELCyABKAIkIgpBAUYEfyAYIAEoAihqQSM6AAAgASgCJAUgCgtBAkYEQCAXIAEoAihqQTQ6AAALIAAgDDYCFCALQSM2AgwgCCALQQxqIBQgAiAJQYTEABD5JyEBIAQgAygC3Bs2AtwbIAAgBEHcG2ogCCALKAIMIAEgAkEJIANBsBFqIgFBwPfQAEEGQQEgBxCMDiIKNgIAAkACQAJAIAUgBiAFayAEQbARakEJIAogCCALKAIMIBQgAkHA99AAQQZBIyABQaQKIAkQ3BMiAUGIf00EQCAKQQJGBEAgACABNgIQCyALQR82AgggCCALQQhqIBMgAiAJQYTEABD5JyEKIAQgAygC1Bs2AtQbIAAgBEHUG2ogCCALKAIIIgwgCiACQQggA0GQ+NAAQQUgDEEdSSAHEIwOIgo2AgQgASAFaiIMIAYgDGsgBEEIIAogCCALKAIIIBMgAkGQ+NAAQQVBHCADQYQGIAkQ3BMiAUGIf0sNASAKQQJGBEAgACABNgIQCyALQTQ2AgQgCCALQQRqIBIgAiAJQYTEABD5JyEKIAQgAygC2Bs2AtgbIAAgBEHYG2ogCCALKAIEIAogAkEJIANBhAZqIgpB0PjQAEEGQQEgBxCMDiIDNgIIIAEgDGoiByAGIAdrIARBhAZqQQkgAyAIIAsoAgQgEiACQdD40ABBBkE0IApBrAsgCRDcEyIBQYh/Sw0CIANBAkYEQCAAIAE2AhALIAAgASAHaiAFazYCDAwDCyAAIAE2AgwMAgsgACABNgIMDAELIAAgATYCDAsgC0EQaiQAC4oEAQp/IwBB8AhrIg0kACANQQBBiAj8CwAgDUGICGpBAEHoAPwLAAJAAkACQCAEBEBBASEQA0AgECETAkACQCABIA5HBEAgACAOai0AACEQIA4NAQwCCyABIAFB7OnRABDDIQALIA1BASAQQQJqQQAgDCAQRxsgE0EBaiAQRhtBAnRqIgwgDCgCAEEBajYCAAsgAyAORg0CQRRBDiACIA5BAnRqKAIAIhFB8AVLG0EHQQAgEUEoSxsgEUGwAUsbIg9BAWshDCAPQQN0QeTj0QBqIRIgDUGICGogD0ECdGohFAJAA0AgFCEPIAxBGEYNASAPQQRqIRQgDEEBaiEMIBIoAgAhFSASQQhqIRIgESAVTw0ACyAMQRpPDQQLIA8gDygCAEEBajYCACATIQwgDkEBaiIOIARHDQALCyAFQQFrrSAJIAogCxCVIwJAIAVBAUsEQCANQYICIAVBAmoiBCAEIAYgByAIQcAEakGCAiAIQQhqQYICIAkgCiALEPIIIA1BiAhqQRpBGkEaIAYgByAIQcIGakEaIAhBjARqQRogCSAKIAsQ8gggA0UNBCABRQ0BIAggAigCACAALQAAQQEgCSAKIAsQnhILIA1B8AhqJAAPC0EAQQBB3OnRABDDIQALIAMgA0H86dEAEMMhAAsgDEEaQYzq0QAQwyEAC0EAQQBBzOnRABDDIQAL0wQCBH8CfiMAQfACayIFJAAgASgCoAIiBiAGKAIAIgRBAWo2AgACQCAEQQBIDQAgBUHgAmpBoKXOABClKyAFKQPoAiEIIAUpA+ACIQlBACEEAkACQAJAAkAgBi8BGCIHDgIAAQILIAVCBTcDCAwCCyAGLwEaDQAgBigCFCIEQQhqIAQoAghBAkZBAnRqLQAgIgRBA0cgBEEAR3EhBAsgBUEIaiAHIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDWAwBCyAFQdgAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBIDQAgBUHoAmpBADoAACAFQgA3A+ACQQAiBEUEQCAFQYACaiAFQQhqQdAA/AoAAAsgBEUEQCAFQbABaiAFQdgAakHQAPwKAAALIAVB2AJqQbilzgApAwA3AwAgBUGwpc4AKQMANwPQAiABKQMAQgVSBEAgASgC0AEiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAFB0AFqENkhCyABQcgBahC8KiABQdAAahCTKiABEP0uIAEoAsABIgQgBCgCACIEQQFrNgIAIARBAUYEQCABQcABahDZIQsgAUGgAWoQ9iYLIAEgBUGwAWpBsAH8CgAAIAEgBjYC0AEgASADNgLMASABIAI2AsgBIAFBCToAxAEgASAGNgLAASABIAg3A7gBIAEgCTcDsAEgASAFKQPgAjcC1AEgAUHcAWogBUHoAmotAAA6AAAgASAFLwCtATsA3QEgAUHfAWogBUGvAWotAAA6AAAgAEEINgIAIAVB8AJqJAAPCwALxAQCBH8BfiMAQfAAayIDJAAgASgCDCgCECACQQJ0aigCACEFIAMgASgCCCIGKAIAKAIAKAIAIgQ2AjQgAyAFNgIMAkAgAAJ/AkAgBawgBKx+IgdCIIinIAenIgRBH3VHBEAgA0ECNgJUIANBrJD/ADYCUCADQgI3AlwgA0GCDDYCHCADQYIMNgIUIAMgA0EQajYCWCADIANBNGo2AhggAyADQQxqNgIQIANBPGogA0HQAGoQmQ4gA0EoaiADQUBrKQIANwMAIANBMGoiBCADQcgAaigCADYCACADQYiAgIB4NgI4IAMgAykCOCIHNwMgIAenQZOAgIB4Rw0BIAMoAiQhBAsgA0HQAGogBCAGKAIILQAAEOoPIAMoAlAiBUGTgICAeEcEQCADQRhqIANB4ABqKAIANgIAIAMgAykCWDcDECADKAJUDAILIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIADAILIANBIGoQiBEgBigCBCEBIAMgBTYCNCADQcyR/wA2AjggA0IENwJEIANBggw2AmwgA0H0CzYCZCADIAFBAWo2AmAgA0G7BzYCXCADIAE2AlggA0HMATYCVCADQfiR/wA2AlAgAyADQdAAajYCQCADIANBNGo2AmggA0EENgI8IANBJGogA0E4ahCZDiADQRhqIAQoAgA2AgAgAyADKQIoNwMQQYKAgIB4IQUgAygCJAs2AgQgACAFNgIAIAAgAykDEDcCCCAAQRBqIANBGGooAgA2AgALIANB8ABqJAALhAQBA38jAEFAaiIDJAAgA0EMakGWt8IAQQgQgCAgA0EsaiACEOcnAkAgAygCLCIEQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAQ2AgAMAQsgA0EsaiIEQZ63wgBBA0EIQQEQ6BwgA0EYaiACIAQQrhQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwBCyADQSxqIgQQhjAgBCACIAEoAgQgASgCCBCnGyADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyACEMYhIAEoAgxBgICAgHhHBEAgA0EsaiIEQaG3wgBBBUEIQQIQ6BwgA0EYaiACIAQQrhQgAygCGCIFQQRHBEAgACADKQIcNwIEIABBDGogA0EkaikCADcCACAAIAU2AgAgBBCGMAwCCyADQSxqIgQQhjAgBCACIAEoAhAgASgCFBCnGyADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwCCyACEMYhCyADQSxqIAIQgTYgAygCLCIBQQRHBEAgACADKQIwNwIEIABBDGogA0E4aikCADcCACAAIAE2AgAMAQsgACACEOUoCyADQQxqEN47IANBQGskAAuEBAEDfyMAQUBqIgMkACADQQxqQZa3wgBBCBCAICADQSxqIAIQ5ycCQCADKAIsIgRBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgBDYCAAwBCyADQSxqIgRBnrfCAEEDQQhBARDoHCADQRhqIAIgBBCtFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAELIANBLGoiBBCGMCAEIAIgASgCBCABKAIIEKYbIAMoAiwiBEEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACAENgIADAELIAIQxiEgASgCDEGAgICAeEcEQCADQSxqIgRBobfCAEEFQQhBAhDoHCADQRhqIAIgBBCtFCADKAIYIgVBBEcEQCAAIAMpAhw3AgQgAEEMaiADQSRqKQIANwIAIAAgBTYCACAEEIYwDAILIANBLGoiBBCGMCAEIAIgASgCECABKAIUEKYbIAMoAiwiAUEERwRAIAAgAykCMDcCBCAAQQxqIANBOGopAgA3AgAgACABNgIADAILIAIQxiELIANBLGogAhCANiADKAIsIgFBBEcEQCAAIAMpAjA3AgQgAEEMaiADQThqKQIANwIAIAAgATYCAAwBCyAAIAIQ5SgLIANBDGoQ3jsgA0FAayQAC6wKAhB/BH4jAEEQayIKJAAgCiACNgIMIAFBEGoiBSAKQQxqEOsMIRYgASgCCEUEQCMAQdAAayICJAAgAiAFNgIcIAEoAgwhDCACIAJBHGo2AiACQAJAIAwgDEEBaiIFTQRAAkAgASgCBCIGIAZBAWpBA3ZBB2wgBkEISRsiBkEBdiAFSQRAAn8gBkEBaiIGIAUgBSAGSRsiBUEPTwRAIAVB/////wFLDQVBfyAFQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBUEISRsgBUEESRsLIQUgAkFAayABQRBqIgdBDEEIIAUQnRQgAigCRCEGIAIoAkAiCEUEQCACKAJIIQUMBQsgAikCSCEVIAZBCWoiBQRAIAhB/wEgBfwLAAsgAiAVQiCIPgI8IAIgFaciDzYCOCACIAY2AjQgAiAINgIwIAJCjICAgIABNwIoIAIgBzYCJCACQTBqIRAgAiAMBH8gCEEIaiERIAEoAgAiDikDAEJ/hUKAgYKEiJCgwIB/gyEVQQAhBQNAIBVQBEADQCAFQQhqIQUgDkEIaiIOKQMAQoCBgoSIkKDAgH+DIhVCgIGChIiQoMCAf1ENAAsgFUKAgYKEiJCgwIB/hSEVCyAIIAYgAigCHCABKAIAIBV6p0EDdiAFaiISQXRsakEMaxDrDKciE3EiB2opAABCgIGChIiQoMCAf4MiF1AEQEEIIQkDQCAHIAlqIQcgCUEIaiEJIAggBiAHcSIHaikAAEKAgYKEiJCgwIB/gyIXUA0ACwsgFUIBfSAVgyEVIAggF3qnQQN2IAdqIAZxIgdqLAAAQQBOBEAgCCkDAEKAgYKEiJCgwIB/g3qnQQN2IQcLIAcgCGogE0EZdiIJOgAAIBEgB0EIayAGcWogCToAACAIIAdBf3NBDGxqIgcgASgCACASQX9zQQxsaiIJKQAANwAAIAdBCGogCUEIaigAADYAACAMQQFrIgwNAAsgASgCDAVBAAsiBTYCPCACIA8gBWs2AjggASAQQQQQ+iogAkEkahDQJgwBCyABIAJBIGpB/KbPAEEMEMUJC0GBgICAeCEGDAILEOMnIAIoAgwhBSACKAIIIQYMAQsQ4ycgAigCFCEFIAIoAhAhBgsgCiAFNgIEIAogBjYCACACQdAAaiQAIAooAgwhAgsgASgCBCIIIBancSEFIBZCGYgiF0L/AINCgYKEiJCgwIABfiEYIAEoAgAhBgNAAn8CQAJAAkAgBSAGaikAACIWIBiFIhVCf4UgFUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIVUEUEQANAIAIgBiAVeqdBA3YgBWogCHFBdGxqIgdBDGsoAgBGDQIgFUIBfSAVgyIVUEUNAAsLIBZCgIGChIiQoMCAf4MhFSANRQRAIBVQDQMgFXqnQQN2IAVqIAhxIQsLQQEgFSAWQgGGg1ANAxpBACEFIAYgC2osAAAiDUEATgRAIAYgBikDAEKAgYKEiJCgwIB/g3qnQQN2IgtqLQAAIQ0LIAYgC2ogF6dB/wBxIgc6AAAgBiALQQhrIAhxakEIaiAHOgAAIAEgASgCCCANQQFxazYCCCABIAEoAgxBAWo2AgwgBiALQXRsaiIBQQxrIAI2AgAgAUEIayADNgIAIAFBBGsgBDYCAAwBCyAHQQRrIgIoAgAhASACIAQ2AgAgB0EIayICKAIAIQUgAiADNgIACyAAIAE2AgQgACAFNgIAIApBEGokAA8LQQALIQ0gBSAUQQhqIhRqIAhxIQUMAAsAC5EEAQZ/IwBB0ABrIgIkACACQThqIAEQ8CcgAkEoaiIDIAJBxABqIgUoAgA2AgAgAiACKQI8NwMgAkAgAigCOCIEQQRHBEAgAigCSCEBIAAgAikDIDcCBCAAIAE2AhAgACAENgIAIABBDGogAygCADYCAAwBCyACQRBqIAMoAgA2AgAgAiACKQMgNwMIIAJBCGoQhjAgAkE4aiABENMJIAMgBSkCADcDACACQTBqIgMgAkHMAGooAgA2AgAgAiACKQI8NwMgAkACQCACKAI4RQRAIAJBPGohBQNAIAJBGGogAygCACIENgIAIAJBEGogAkEoaiIGKQMANwMAIAIgAikDIDcDCCAEQf8BcUUNAyACQThqIgcgASAEQcAAEMkCIAIoAjgiBEEERw0CIAJBCGoQhjAgByABENMJIAYgBUEIaikCADcDACADIAVBEGooAgA2AgAgAiAFKQIANwMgIAIoAjhFDQALCyAAIAIpAyA3AgAgAEEQaiADKAIANgIAIABBCGogAkEoaikDADcCAAwCCyAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAQ2AgAgAkEIahCGMAwBCyACQQhqEIYwIAJBOGogARCoKSACKAI4IgFBBEcEQCAAIAIpAjw3AgQgAEEMaiACQcQAaikCADcCACAAIAE2AgAMAQsgAEEENgIACyACQdAAaiQAC4wEAgV/BH4jAEEQayICJAAgASgCBCEEIAEoAggiBa0hCiABKAIQIgOtIQkCQAJAAkACQANAAkACfiAHQsYAUQRAQQAhBCACQQRqQRZBAEEBQQEQoBggAigCCCEBIAIoAgRBAUYNByACKAIMIgNBDmpBvM/QACkAADcAACADQQhqQbbP0AApAAA3AAAgA0Guz9AAKQAANwAAQoCAgIDgAgwBCyAEQQAgCSAKVBsNASACQQRqQcMAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQYgAigCDCIDQcTP0ABBwwD8CgAAQQIhBEKAgICAsAgLIQcgACABNgIEIAAgBDYCACAAIAcgA62ENwMIDAQLIAlCAXwhCSADIARqLAAAIgZB/wBxrSAHhiAIhCEIIAdCB3whByADQQFqIQMgBkEASA0ACyABIAM2AhAgCEIBg1BFBEAgAUEANgIcIAEgCKdBAnRBeHE2AhgMAgsgASAIQgGIPgIUIAMgBUkNACACQQRqQcIAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQMgAigCDCIDQezO0ABBwgD8CgAAIABBwgA2AgwgACADNgIIIAAgATYCBCAAQQI2AgAMAgsgASADQQFqNgIQIAEgAyAEai0AAEEARzoAIAwACyAAQQg2AgALIAJBEGokAA8LIAEgAigCDEGkxtAAEP0vAAv5AwIFfwJ+IAApAwghCyAAKQMAIQoCQAJAAkACQAJAA0AgAiAHIgVBA2oiB00EQANAIAIgBU0NByAFQQFqIQcgASAFai0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDUARAIAQgBCgCACIIQQFqIgY2AgAgAyAIQQJ0aiAHNgIAIAZBwABGDQcLIAchBQwACwALIAEgBWoiCC0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDUARAIAQgBCgCACIGQQFqIgk2AgAgAyAGQQJ0aiAFQQFqNgIAIAlBwABGDQMLIAhBAWotAABBA3RB0JvRAGopAwAgCkIBhnwiCiALg1AEQCAEIAQoAgAiBkEBaiIJNgIAIAMgBkECdGogBUECajYCACAJQcAARg0ECyAIQQJqLQAAQQN0QdCb0QBqKQMAIApCAYZ8IgogC4NQBEAgBCAEKAIAIgZBAWoiCTYCACADIAZBAnRqIAc2AgAgCUHAAEYNAgsgBUEEaiIFIQcgCEEDai0AAEEDdEHQm9EAaikDACAKQgGGfCIKIAuDQgBSDQAgBCAEKAIAIghBAWoiBjYCACADIAhBAnRqIAc2AgAgBkHAAEcNAAsMBAsgBUEDaiEFDAMLIAVBAWohBQwCCyAFQQJqIQUMAQsgBUEBaiEFCyAAIAo3AwAgBQufCAITfwN+IwBB0ABrIgMkACADQTBqIgIgARD4KCADQRhqIAJB0Lf+ABDKEiADKAIcIQUCQCADKAIgIgRBAkkNACAEQRVPBEAgBSAEIAIQyRsMAQsgBSAEEJUnCyADKAIYIQIgAyAANgJEIAMgATYCQCADIAUgBEECdGo2AjwgAyACNgI4IAMgBTYCNCADIAU2AjAgA0EkaiEGIwBBEGsiCCQAIANBMGoiBCgCDCIBIAQoAgQiC2tBAnYhDCAEKAIIIRAgBCgCACENIAEgC0cEQCAEKAIQIgpBEGohESAEKAIUIQJBACEBA0ACQAJAIAooAgxFDQAgAUEBaiEFIA0gAUECdCIBaiESIBEgASALaigCACIHEPgLIRUgCigCACIJQRhrIRMgCigCBCIOIBWncSEBIBVCGYhC/wCDQoGChIiQoMCAAX4hF0EAIQ8DQCABIAlqKQAAIhYgF4UiFUJ/hSAVQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhVQRQRAA0AgByATIBV6p0EDdiABaiAOcUFobCIUahCMNQ0EIBVCAX0gFYMiFVBFDQALCyAWIBZCAYaDQoCBgoSIkKDAgH+DUEUNASABIA9BCGoiD2ogDnEhAQwACwALQbiB/wAQsjsACyACIAcoAgQgBygCCBDbCCEBIAIgCSAUaiIHQQhrKAIAIAdBBGsoAgAQ2wghByACQQE6ADggAigCMCEJIAJBBCABEP0OIAJBBiAHEP0OIAIgCRDYByEBIAJBADYCFCACQQA6ADggEiABNgIAIAUiASAMRw0ACwsgBEEANgIIIARBBDYCACAIQoCAgIDAADcCCCAIQQhqEOk7IARBBDYCDCAEQQQ2AgQgBiAMNgIIIAYgDTYCBCAGIBA2AgAgBBDeKyAIQRBqJAAgAEEEIAAoAjQiASABQQRNGzYCNCADKAIoIQUgAEEwaiEGIAMoAiwiBEECdCECAkBBACAAKAIwIghrQQNxIgEgACgCCCAIa00NACAAKAIIIAAoAjBrIAFPDQADQCAAEPsWIAAoAgggACgCMGsgAUkNAAsLIAYgARCNNwJAAkAgAkEEaiIBIAAoAgggACgCMGsiB00NACABQYCAgIB4Sw0BIAEgB00NAANAIAAQ+xYgACgCCCAAKAIwayABSQ0ACwsgBiACEI03IAAoAjAhASADQRBqIAAQ3DsgA0EIaiADKAIQIAMoAhQgACgCMCIGIAYgAmtByLb+ABDXJiADKAIMQQJ2IgIgBCACIARJGyIGBEAgAygCCCECA0AgAiABIAUoAgBrNgAAIAVBBGohBSACQQRqIQIgAUEEayEBIAZBAWsiBg0ACwsgACAEEKkRIANBJGpBBEEEEOAeIANB0ABqJAAPC0HYtv4AQSVBgLf+ABCfKQALvQQCA38BfiMAQZABayICJAACQAJ/QQMgASgCHCIEIAEoAiBGDQAaAkAgASgCBEUNACAEIAEoAhRPDQIgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEIaiABKAIAIAQQ2isgASgCKCEEIAEoAiQhBSACKAIIIQEgAiACKAIMIgY2AhQgAiABNgIQIAJBGGogASAGIAUsAAAQxwECfyACKAIYQZOAgIB4RwRAIAJB0ABqIAJBKGooAgA2AgAgAkHIAGogAkEgaikCADcDACACIAIpAhg3A0AgAkH4AGpB/K6AASgCADYCACACQfSugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEQajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAigCNCEFIAIpAjghB0GCgICAeCEEIAIoAjAMAQsgAkHYAGogAigCHCIBIAQtAAAQ6g9BASACKAJYIgRBk4CAgHhGDQEaIAIpAmQhByACKAJgIQUgAigCXAshASADKAIAQZOAgIB4RwRAIAMQiBELIAMgBzcCDCADIAU2AgggAyABNgIEIAMgBDYCAEECCyEEIAAgATYCBCAAIAQ2AgAgAkGQAWokAA8LQfSngAFBIEGUqIABEJ8pAAu9BAIDfwF+IwBBkAFrIgIkAAJAAn9BAyABKAIcIgQgASgCIEYNABoCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCABKAIoIQQgASgCJCEFIAIoAgghASACIAIoAgwiBjYCFCACIAE2AhAgAkEYaiABIAYgBSwAABDHAQJ/IAIoAhhBk4CAgHhHBEAgAkHQAGogAkEoaigCADYCACACQcgAaiACQSBqKQIANwMAIAIgAikCGDcDQCACQfgAakH8roABKAIANgIAIAJB9K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQRBqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKAI0IQUgAikCOCEHQYKAgIB4IQQgAigCMAwBCyACQdgAaiACKAIcIgEgBC0AABDqD0EBIAIoAlgiBEGTgICAeEYNARogAikCZCEHIAIoAmAhBSACKAJcCyEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAHNwIMIAMgBTYCCCADIAE2AgQgAyAENgIAQQILIQQgACABNgIEIAAgBDYCACACQZABaiQADwtB9KeAAUEgQZSogAEQnykAC/oDARN/IwBB0ABrIgIkACABKAIEIQcgAkHEAGogASgCCCIIQQBBBEHEABCgGCACKAJIIQQCQCACKAJEQQFHBEAgAigCTCEJAkAgBEUNACAIQcQAbCEOIAJBFGohCiACQSBqIQsgByEBIAQhDANAIAUgDkYNASACQSxqIAFBGGoQ2wYgASgCKCEPIAEoAiQhECACQThqIAEQvhUgAkHEAGogAUEMahCACyABKAIsIgYEQCAGIAYoAgAiA0EBajYCACADQQBIDQQgBSAHaiIDQUBrKAIAIREgA0E0aigCACESIANBMGooAgAhEyADQTxqKAIAIRQgA0E4aigCACENCyALIAIpAiw3AgAgCiACKQJENwIAIAtBCGogAkE0aigCADYCACACQRBqIAJBQGsoAgA2AgAgCkEIaiACQcwAaigCADYCACACIAIpAjg3AwggBSAJaiIDIAJBCGpBJPwKAAAgAUHEAGohASADQUBrIBE2AgAgA0E8aiAUNgIAIANBOGogDTYCACADQTRqIBI2AgAgA0EwaiATNgIAIANBLGogBjYCACADQShqIA82AgAgA0EkaiAQNgIAIAVBxABqIQUgDEEBayIMDQALCyAAIAg2AgggACAJNgIEIAAgBDYCACACQdAAaiQADwsgBCACKAJMQciKhwEQ/S8LAAu6BAIDfwF+IwBBkAFrIgIkAAJAAn9BAyABKAIcIgQgASgCIEYNABoCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiABKAIoIQQgASgCJCEFIAIoAgghASACIAIoAgwiBjYCFCACIAE2AhAgAkEYaiABIAYgBSwAABDHAQJ/IAIoAhhBk4CAgHhHBEAgAkHQAGogAkEoaigCADYCACACQcgAaiACQSBqKQIANwMAIAIgAikCGDcDQCACQfgAakH8roABKAIANgIAIAJB9K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQRBqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKAI0IQUgAikCOCEHQYKAgIB4IQQgAigCMAwBCyACQdgAaiACKAIcIgEgBC0AABDqD0EBIAIoAlgiBEGTgICAeEYNARogAikCZCEHIAIoAmAhBSACKAJcCyEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAHNwIMIAMgBTYCCCADIAE2AgQgAyAENgIAQQILIQQgACABNgIEIAAgBDYCACACQZABaiQADwtB9KeAAUEgQZSogAEQnykAC5sKAhB/BH4jAEEQayIIJAAgCCACOwEOIAFBEGoiBCAIQQ5qEK4MIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCuDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQZjegAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBDmpBAiABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0ECEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAILwEOIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY7AQAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAubCgIQfwR+IwBBEGsiCCQAIAggAjsBDiABQRBqIgQgCEEOahCuDCEVIAEoAghFBEAjAEHQAGsiAiQAIAIgBDYCHCABKAIMIQogAiACQRxqNgIgAkACQCAKIApBAWoiBE0EQAJAIAEoAgQiBSAFQQFqQQN2QQdsIAVBCEkbIgVBAXYgBEkEQAJ/IAVBAWoiBSAEIAQgBUkbIgRBD08EQCAEQf////8BSw0FQX8gBEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIARBCEkbIARBBEkbCyEEIAJBQGsgAUEQaiIGQQhBCCAEEJ0UIAIoAkQhBSACKAJAIgdFBEAgAigCSCEEDAULIAIpAkghFCAFQQlqIgQEQCAHQf8BIAT8CwALIAIgFEIgiD4CPCACIBSnIg02AjggAiAFNgI0IAIgBzYCMCACQoiAgICAATcCKCACIAY2AiQgAkEwaiEOIAIgCgR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQQDQCAUUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgByAFIAIoAhwgASgCACAUeqdBA3YgBGoiEEEDdGtBCGsQrgynIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCELA0AgBiALaiEGIAtBCGohCyAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiFlANAAsLIBRCAX0gFIMhFCAHIBZ6p0EDdiAGaiAFcSIGaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAdqIBFBGXYiCzoAACAPIAZBCGsgBXFqIAs6AAAgByAGQX9zQQN0aiABKAIAIBBBf3NBA3RqKQAANwAAIApBAWsiCg0ACyABKAIMBUEACyIENgI8IAIgDSAEazYCOCABIA5BBBD6KiACQSRqENAmDAELIAEgAkEgakGo34ABQQgQxwkLQYGAgIB4IQUMAgsQ4ycgAigCDCEEIAIoAgghBQwBCxDjJyACKAIUIQQgAigCECEFCyAIIAQ2AgQgCCAFNgIAIAJB0ABqJAALIAEoAgQiBCAVp3EhAiAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQUDQAJ/AkACQAJAIAIgBWopAAAiFSAXhSIUQn+FIBRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFFBFBEADQCAIQQ5qQQIgASgCACAUeqdBA3YgAmogBHEiB0EDdGtBCGtBAhCfOw0CIBRCAX0gFIMiFFBFDQALCyAVQoCBgoSIkKDAgH+DIRQgEkUEQCAUUA0DIBR6p0EDdiACaiAEcSEJC0EBIBQgFUIBhoNQDQMaQQAhAiAFIAlqLAAAQQBOBEAgBSkDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAEoAgAiBCAJaiIFLQAAIQcgCC8BDiEGIAUgFqdB/wBxIgU6AAAgBCABKAIEIAlBCGtxakEIaiAFOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBCAJQQN0ayIBQQRrIAM2AgAgAUEIayAGOwEADAELIAEoAgBBACAHa0EDdGpBBGsiAigCACEBIAIgAzYCAEEBIQILIAAgATYCBCAAIAI2AgAgCEEQaiQADwtBAAshEiACIBNBCGoiE2ogBHEhAgwACwALrwoCEX8EfiMAQRBrIgkkACAJIAI5AwggAUEQaiIFIAlBCGoQrAwhFiABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCEMIAQgBEEcajYCIAJAAkAgDCAMQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiB0EQQQggBRCdFCAEKAJEIQYgBCgCQCIIRQRAIAQoAkghBQwFCyAEKQJIIRUgBkEJaiIFBEAgCEH/ASAF/AsACyAEIBVCIIg+AjwgBCAVpyIONgI4IAQgBjYCNCAEIAg2AjAgBEKQgICAgAE3AiggBCAHNgIkIARBMGohDyAEIAwEfyAIQQhqIRAgASgCACINKQMAQn+FQoCBgoSIkKDAgH+DIRVBACEFA0AgFVAEQANAIAVBCGohBSANQQhqIg0pAwBCgIGChIiQoMCAf4MiFUKAgYKEiJCgwIB/UQ0ACyAVQoCBgoSIkKDAgH+FIRULIAggBiAEKAIcIAEoAgAgFXqnQQN2IAVqIhFBBHRrQRBrEKwMpyIScSIHaikAAEKAgYKEiJCgwIB/gyIXUARAQQghCgNAIAcgCmohByAKQQhqIQogCCAGIAdxIgdqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyAVQgF9IBWDIRUgCCAXeqdBA3YgB2ogBnEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiASQRl2Igo6AAAgECAHQQhrIAZxaiAKOgAAIAggB0F/c0EEdGoiByABKAIAIBFBf3NBBHRqIgopAAA3AAAgB0EIaiAKQQhqKQAANwAAIAxBAWsiDA0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakGI2oABQRAQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAWp3EhBCAWQhmIIhdC/wCDQoGChIiQoMCAAX4hGCABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFiAYhSIVQn+FIBVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFVBFBEADQCAJQQhqQQggASgCACAVeqdBA3YgBGogBXEiCEEEdGtBEGtBCBCfOw0CIBVCAX0gFYMiFVBFDQALCyAWQoCBgoSIkKDAgH+DIRUgE0UEQCAVUA0DIBV6p0EDdiAEaiAFcSELC0EBIBUgFkIBhoNQDQMaQQAhBCAGIAtqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQsLIAEoAgAiBSALaiIGLQAAIQggCSsDCCECIAYgF6dB/wBxIgY6AAAgBSABKAIEIAtBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggCEEBcWs2AgggBSALQQR0ayIBQQhrIAM2AgAgAUEQayACOQMADAELIAEoAgBBACAIa0EEdGpBCGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALrwoCEX8DfiMAQRBrIgkkACAJIAI3AwggAUEQaiIFIAlBCGoQrAwhFSABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCEMIAQgBEEcajYCIAJAAkAgDCAMQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiB0EQQQggBRCdFCAEKAJEIQYgBCgCQCIIRQRAIAQoAkghBQwFCyAEKQJIIQIgBkEJaiIFBEAgCEH/ASAF/AsACyAEIAJCIIg+AjwgBCACpyIONgI4IAQgBjYCNCAEIAg2AjAgBEKQgICAgAE3AiggBCAHNgIkIARBMGohDyAEIAwEfyAIQQhqIRAgASgCACINKQMAQn+FQoCBgoSIkKDAgH+DIQJBACEFA0AgAlAEQANAIAVBCGohBSANQQhqIg0pAwBCgIGChIiQoMCAf4MiAkKAgYKEiJCgwIB/UQ0ACyACQoCBgoSIkKDAgH+FIQILIAggBiAEKAIcIAEoAgAgAnqnQQN2IAVqIhFBBHRrQRBrEKwMpyIScSIHaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCgNAIAcgCmohByAKQQhqIQogCCAGIAdxIgdqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyACQgF9IAKDIQIgCCAWeqdBA3YgB2ogBnEiB2osAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgByAIaiASQRl2Igo6AAAgECAHQQhrIAZxaiAKOgAAIAggB0F/c0EEdGoiByABKAIAIBFBf3NBBHRqIgopAAA3AAAgB0EIaiAKQQhqKQAANwAAIAxBAWsiDA0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakGg4IABQRAQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAVp3EhBCAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFSAXhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAJQQhqQQggASgCACACeqdBA3YgBGogBXEiCEEEdGtBEGtBCBCfOw0CIAJCAX0gAoMiAlBFDQALCyAVQoCBgoSIkKDAgH+DIQIgE0UEQCACUA0DIAJ6p0EDdiAEaiAFcSELC0EBIAIgFUIBhoNQDQMaQQAhBCAGIAtqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQsLIAEoAgAiBSALaiIGLQAAIQggCSkDCCECIAYgFqdB/wBxIgY6AAAgBSABKAIEIAtBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggCEEBcWs2AgggBSALQQR0ayIBQQhrIAM2AgAgAUEQayACNwMADAELIAEoAgBBACAIa0EEdGpBCGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALmwoCEH8EfiMAQRBrIggkACAIIAI7AQ4gAUEQaiIEIAhBDmoQrgwhFSABKAIIRQRAIwBB0ABrIgIkACACIAQ2AhwgASgCDCEKIAIgAkEcajYCIAJAAkAgCiAKQQFqIgRNBEACQCABKAIEIgUgBUEBakEDdkEHbCAFQQhJGyIFQQF2IARJBEACfyAFQQFqIgUgBCAEIAVJGyIEQQ9PBEAgBEH/////AUsNBUF/IARBA3RBB25BAWtndkEBagwBC0EEQQhBECAEQQhJGyAEQQRJGwshBCACQUBrIAFBEGoiBkEIQQggBBCdFCACKAJEIQUgAigCQCIHRQRAIAIoAkghBAwFCyACKQJIIRQgBUEJaiIEBEAgB0H/ASAE/AsACyACIBRCIIg+AjwgAiAUpyINNgI4IAIgBTYCNCACIAc2AjAgAkKIgICAgAE3AiggAiAGNgIkIAJBMGohDiACIAoEfyAHQQhqIQ8gASgCACIMKQMAQn+FQoCBgoSIkKDAgH+DIRRBACEEA0AgFFAEQANAIARBCGohBCAMQQhqIgwpAwBCgIGChIiQoMCAf4MiFEKAgYKEiJCgwIB/UQ0ACyAUQoCBgoSIkKDAgH+FIRQLIAcgBSACKAIcIAEoAgAgFHqnQQN2IARqIhBBA3RrQQhrEK4MpyIRcSIGaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCwNAIAYgC2ohBiALQQhqIQsgByAFIAZxIgZqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyAUQgF9IBSDIRQgByAWeqdBA3YgBmogBXEiBmosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhBgsgBiAHaiARQRl2Igs6AAAgDyAGQQhrIAVxaiALOgAAIAcgBkF/c0EDdGogASgCACAQQX9zQQN0aikAADcAACAKQQFrIgoNAAsgASgCDAVBAAsiBDYCPCACIA0gBGs2AjggASAOQQQQ+iogAkEkahDQJgwBCyABIAJBIGpBmOGAAUEIEMcJC0GBgICAeCEFDAILEOMnIAIoAgwhBCACKAIIIQUMAQsQ4ycgAigCFCEEIAIoAhAhBQsgCCAENgIEIAggBTYCACACQdAAaiQACyABKAIEIgQgFadxIQIgFUIZiCIWQv8Ag0KBgoSIkKDAgAF+IRcgASgCACEFA0ACfwJAAkACQCACIAVqKQAAIhUgF4UiFEJ/hSAUQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhRQRQRAA0AgCEEOakECIAEoAgAgFHqnQQN2IAJqIARxIgdBA3RrQQhrQQIQnzsNAiAUQgF9IBSDIhRQRQ0ACwsgFUKAgYKEiJCgwIB/gyEUIBJFBEAgFFANAyAUeqdBA3YgAmogBHEhCQtBASAUIBVCAYaDUA0DGkEAIQIgBSAJaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyABKAIAIgQgCWoiBS0AACEHIAgvAQ4hBiAFIBanQf8AcSIFOgAAIAQgASgCBCAJQQhrcWpBCGogBToAACABIAEoAgxBAWo2AgwgASABKAIIIAdBAXFrNgIIIAQgCUEDdGsiAUEEayADNgIAIAFBCGsgBjsBAAwBCyABKAIAQQAgB2tBA3RqQQRrIgIoAgAhASACIAM2AgBBASECCyAAIAE2AgQgACACNgIAIAhBEGokAA8LQQALIRIgAiATQQhqIhNqIARxIQIMAAsAC5sKAhB/BH4jAEEQayIIJAAgCCACOgAPIAFBEGoiBCAIQQ9qEK8MIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCvDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQcjYgAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBD2pBASABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0EBEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAILQAPIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY6AAAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAubCgIQfwR+IwBBEGsiCCQAIAggAjYCDCABQRBqIgQgCEEMahCrDCEVIAEoAghFBEAjAEHQAGsiAiQAIAIgBDYCHCABKAIMIQogAiACQRxqNgIgAkACQCAKIApBAWoiBE0EQAJAIAEoAgQiBSAFQQFqQQN2QQdsIAVBCEkbIgVBAXYgBEkEQAJ/IAVBAWoiBSAEIAQgBUkbIgRBD08EQCAEQf////8BSw0FQX8gBEEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIARBCEkbIARBBEkbCyEEIAJBQGsgAUEQaiIGQQhBCCAEEJ0UIAIoAkQhBSACKAJAIgdFBEAgAigCSCEEDAULIAIpAkghFCAFQQlqIgQEQCAHQf8BIAT8CwALIAIgFEIgiD4CPCACIBSnIg02AjggAiAFNgI0IAIgBzYCMCACQoiAgICAATcCKCACIAY2AiQgAkEwaiEOIAIgCgR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhFEEAIQQDQCAUUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyIUQoCBgoSIkKDAgH9RDQALIBRCgIGChIiQoMCAf4UhFAsgByAFIAIoAhwgASgCACAUeqdBA3YgBGoiEEEDdGtBCGsQqwynIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCELA0AgBiALaiEGIAtBCGohCyAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiFlANAAsLIBRCAX0gFIMhFCAHIBZ6p0EDdiAGaiAFcSIGaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAdqIBFBGXYiCzoAACAPIAZBCGsgBXFqIAs6AAAgByAGQX9zQQN0aiABKAIAIBBBf3NBA3RqKQAANwAAIApBAWsiCg0ACyABKAIMBUEACyIENgI8IAIgDSAEazYCOCABIA5BBBD6KiACQSRqENAmDAELIAEgAkEgakHY3IABQQgQxwkLQYGAgIB4IQUMAgsQ4ycgAigCDCEEIAIoAgghBQwBCxDjJyACKAIUIQQgAigCECEFCyAIIAQ2AgQgCCAFNgIAIAJB0ABqJAALIAEoAgQiBCAVp3EhAiAVQhmIIhZC/wCDQoGChIiQoMCAAX4hFyABKAIAIQUDQAJ/AkACQAJAIAIgBWopAAAiFSAXhSIUQn+FIBRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFFBFBEADQCAIQQxqQQQgASgCACAUeqdBA3YgAmogBHEiB0EDdGtBCGtBBBCfOw0CIBRCAX0gFIMiFFBFDQALCyAVQoCBgoSIkKDAgH+DIRQgEkUEQCAUUA0DIBR6p0EDdiACaiAEcSEJC0EBIBQgFUIBhoNQDQMaQQAhAiAFIAlqLAAAQQBOBEAgBSkDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAEoAgAiBCAJaiIFLQAAIQcgCCgCDCEGIAUgFqdB/wBxIgU6AAAgBCABKAIEIAlBCGtxakEIaiAFOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBCAJQQN0ayIBQQRrIAM2AgAgAUEIayAGNgIADAELIAEoAgBBACAHa0EDdGpBBGsiAigCACEBIAIgAzYCAEEBIQILIAAgATYCBCAAIAI2AgAgCEEQaiQADwtBAAshEiACIBNBCGoiE2ogBHEhAgwACwALmwoCEH8EfiMAQRBrIggkACAIIAI6AA8gAUEQaiIEIAhBD2oQrwwhFSABKAIIRQRAIwBB0ABrIgIkACACIAQ2AhwgASgCDCEKIAIgAkEcajYCIAJAAkAgCiAKQQFqIgRNBEACQCABKAIEIgUgBUEBakEDdkEHbCAFQQhJGyIFQQF2IARJBEACfyAFQQFqIgUgBCAEIAVJGyIEQQ9PBEAgBEH/////AUsNBUF/IARBA3RBB25BAWtndkEBagwBC0EEQQhBECAEQQhJGyAEQQRJGwshBCACQUBrIAFBEGoiBkEIQQggBBCdFCACKAJEIQUgAigCQCIHRQRAIAIoAkghBAwFCyACKQJIIRQgBUEJaiIEBEAgB0H/ASAE/AsACyACIBRCIIg+AjwgAiAUpyINNgI4IAIgBTYCNCACIAc2AjAgAkKIgICAgAE3AiggAiAGNgIkIAJBMGohDiACIAoEfyAHQQhqIQ8gASgCACIMKQMAQn+FQoCBgoSIkKDAgH+DIRRBACEEA0AgFFAEQANAIARBCGohBCAMQQhqIgwpAwBCgIGChIiQoMCAf4MiFEKAgYKEiJCgwIB/UQ0ACyAUQoCBgoSIkKDAgH+FIRQLIAcgBSACKAIcIAEoAgAgFHqnQQN2IARqIhBBA3RrQQhrEK8MpyIRcSIGaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCwNAIAYgC2ohBiALQQhqIQsgByAFIAZxIgZqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyAUQgF9IBSDIRQgByAWeqdBA3YgBmogBXEiBmosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhBgsgBiAHaiARQRl2Igs6AAAgDyAGQQhrIAVxaiALOgAAIAcgBkF/c0EDdGogASgCACAQQX9zQQN0aikAADcAACAKQQFrIgoNAAsgASgCDAVBAAsiBDYCPCACIA0gBGs2AjggASAOQQQQ+iogAkEkahDQJgwBCyABIAJBIGpBuNqAAUEIEMcJC0GBgICAeCEFDAILEOMnIAIoAgwhBCACKAIIIQUMAQsQ4ycgAigCFCEEIAIoAhAhBQsgCCAENgIEIAggBTYCACACQdAAaiQACyABKAIEIgQgFadxIQIgFUIZiCIWQv8Ag0KBgoSIkKDAgAF+IRcgASgCACEFA0ACfwJAAkACQCACIAVqKQAAIhUgF4UiFEJ/hSAUQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhRQRQRAA0AgCEEPakEBIAEoAgAgFHqnQQN2IAJqIARxIgdBA3RrQQhrQQEQnzsNAiAUQgF9IBSDIhRQRQ0ACwsgFUKAgYKEiJCgwIB/gyEUIBJFBEAgFFANAyAUeqdBA3YgAmogBHEhCQtBASAUIBVCAYaDUA0DGkEAIQIgBSAJaiwAAEEATgRAIAUpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyABKAIAIgQgCWoiBS0AACEHIAgtAA8hBiAFIBanQf8AcSIFOgAAIAQgASgCBCAJQQhrcWpBCGogBToAACABIAEoAgxBAWo2AgwgASABKAIIIAdBAXFrNgIIIAQgCUEDdGsiAUEEayADNgIAIAFBCGsgBjoAAAwBCyABKAIAQQAgB2tBA3RqQQRrIgIoAgAhASACIAM2AgBBASECCyAAIAE2AgQgACACNgIAIAhBEGokAA8LQQALIRIgAiATQQhqIhNqIARxIQIMAAsAC5sKAhB/BH4jAEEQayIIJAAgCCACNgIMIAFBEGoiBCAIQQxqEKsMIRUgASgCCEUEQCMAQdAAayICJAAgAiAENgIcIAEoAgwhCiACIAJBHGo2AiACQAJAIAogCkEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgAkFAayABQRBqIgZBCEEIIAQQnRQgAigCRCEFIAIoAkAiB0UEQCACKAJIIQQMBQsgAikCSCEUIAVBCWoiBARAIAdB/wEgBPwLAAsgAiAUQiCIPgI8IAIgFKciDTYCOCACIAU2AjQgAiAHNgIwIAJCiICAgIABNwIoIAIgBjYCJCACQTBqIQ4gAiAKBH8gB0EIaiEPIAEoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyEUQQAhBANAIBRQBEADQCAEQQhqIQQgDEEIaiIMKQMAQoCBgoSIkKDAgH+DIhRCgIGChIiQoMCAf1ENAAsgFEKAgYKEiJCgwIB/hSEUCyAHIAUgAigCHCABKAIAIBR6p0EDdiAEaiIQQQN0a0EIaxCrDKciEXEiBmopAABCgIGChIiQoMCAf4MiFlAEQEEIIQsDQCAGIAtqIQYgC0EIaiELIAcgBSAGcSIGaikAAEKAgYKEiJCgwIB/gyIWUA0ACwsgFEIBfSAUgyEUIAcgFnqnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiILOgAAIA8gBkEIayAFcWogCzoAACAHIAZBf3NBA3RqIAEoAgAgEEF/c0EDdGopAAA3AAAgCkEBayIKDQALIAEoAgwFQQALIgQ2AjwgAiANIARrNgI4IAEgDkEEEPoqIAJBJGoQ0CYMAQsgASACQSBqQajZgAFBCBDHCQtBgYCAgHghBQwCCxDjJyACKAIMIQQgAigCCCEFDAELEOMnIAIoAhQhBCACKAIQIQULIAggBDYCBCAIIAU2AgAgAkHQAGokAAsgASgCBCIEIBWncSECIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBQNAAn8CQAJAAkAgAiAFaikAACIVIBeFIhRCf4UgFEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIUUEUEQANAIAhBDGpBBCABKAIAIBR6p0EDdiACaiAEcSIHQQN0a0EIa0EEEJ87DQIgFEIBfSAUgyIUUEUNAAsLIBVCgIGChIiQoMCAf4MhFCASRQRAIBRQDQMgFHqnQQN2IAJqIARxIQkLQQEgFCAVQgGGg1ANAxpBACECIAUgCWosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgASgCACIEIAlqIgUtAAAhByAIKAIMIQYgBSAWp0H/AHEiBToAACAEIAEoAgQgCUEIa3FqQQhqIAU6AAAgASABKAIMQQFqNgIMIAEgASgCCCAHQQFxazYCCCAEIAlBA3RrIgFBBGsgAzYCACABQQhrIAY2AgAMAQsgASgCAEEAIAdrQQN0akEEayICKAIAIQEgAiADNgIAQQEhAgsgACABNgIEIAAgAjYCACAIQRBqJAAPC0EACyESIAIgE0EIaiITaiAEcSECDAALAAuvCgIRfwN+IwBBEGsiCSQAIAkgAjcDCCABQRBqIgUgCUEIahCsDCEVIAEoAghFBEAjAEHQAGsiBCQAIAQgBTYCHCABKAIMIQwgBCAEQRxqNgIgAkACQCAMIAxBAWoiBU0EQAJAIAEoAgQiBiAGQQFqQQN2QQdsIAZBCEkbIgZBAXYgBUkEQAJ/IAZBAWoiBiAFIAUgBkkbIgVBD08EQCAFQf////8BSw0FQX8gBUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAVBCEkbIAVBBEkbCyEFIARBQGsgAUEQaiIHQRBBCCAFEJ0UIAQoAkQhBiAEKAJAIghFBEAgBCgCSCEFDAULIAQpAkghAiAGQQlqIgUEQCAIQf8BIAX8CwALIAQgAkIgiD4CPCAEIAKnIg42AjggBCAGNgI0IAQgCDYCMCAEQpCAgICAATcCKCAEIAc2AiQgBEEwaiEPIAQgDAR/IAhBCGohECABKAIAIg0pAwBCf4VCgIGChIiQoMCAf4MhAkEAIQUDQCACUARAA0AgBUEIaiEFIA1BCGoiDSkDAEKAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhAgsgCCAGIAQoAhwgASgCACACeqdBA3YgBWoiEUEEdGtBEGsQrAynIhJxIgdqKQAAQoCBgoSIkKDAgH+DIhZQBEBBCCEKA0AgByAKaiEHIApBCGohCiAIIAYgB3EiB2opAABCgIGChIiQoMCAf4MiFlANAAsLIAJCAX0gAoMhAiAIIBZ6p0EDdiAHaiAGcSIHaiwAAEEATgRAIAgpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAHIAhqIBJBGXYiCjoAACAQIAdBCGsgBnFqIAo6AAAgCCAHQX9zQQR0aiIHIAEoAgAgEUF/c0EEdGoiCikAADcAACAHQQhqIApBCGopAAA3AAAgDEEBayIMDQALIAEoAgwFQQALIgU2AjwgBCAOIAVrNgI4IAEgD0EEEPoqIARBJGoQ0CYMAQsgASAEQSBqQZjbgAFBEBDHCQtBgYCAgHghBgwCCxDjJyAEKAIMIQUgBCgCCCEGDAELEOMnIAQoAhQhBSAEKAIQIQYLIAkgBTYCBCAJIAY2AgAgBEHQAGokAAsgASgCBCIFIBWncSEEIBVCGYgiFkL/AINCgYKEiJCgwIABfiEXIAEoAgAhBgNAAn8CQAJAAkAgBCAGaikAACIVIBeFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAlBCGpBCCABKAIAIAJ6p0EDdiAEaiAFcSIIQQR0a0EQa0EIEJ87DQIgAkIBfSACgyICUEUNAAsLIBVCgIGChIiQoMCAf4MhAiATRQRAIAJQDQMgAnqnQQN2IARqIAVxIQsLQQEgAiAVQgGGg1ANAxpBACEEIAYgC2osAABBAE4EQCAGKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgASgCACIFIAtqIgYtAAAhCCAJKQMIIQIgBiAWp0H/AHEiBjoAACAFIAEoAgQgC0EIa3FqQQhqIAY6AAAgASABKAIMQQFqNgIMIAEgASgCCCAIQQFxazYCCCAFIAtBBHRrIgFBCGsgAzYCACABQRBrIAI3AwAMAQsgASgCAEEAIAhrQQR0akEIayIEKAIAIQEgBCADNgIAQQEhBAsgACABNgIEIAAgBDYCACAJQRBqJAAPC0EACyETIAQgFEEIaiIUaiAFcSEEDAALAAubCgIRfwR+IwBBEGsiCSQAIAkgAjgCDCABQRBqIgUgCUEMahCrDCEWIAEoAghFBEAjAEHQAGsiBCQAIAQgBTYCHCABKAIMIQsgBCAEQRxqNgIgAkACQCALIAtBAWoiBU0EQAJAIAEoAgQiBiAGQQFqQQN2QQdsIAZBCEkbIgZBAXYgBUkEQAJ/IAZBAWoiBiAFIAUgBkkbIgVBD08EQCAFQf////8BSw0FQX8gBUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAVBCEkbIAVBBEkbCyEFIARBQGsgAUEQaiIIQQhBCCAFEJ0UIAQoAkQhBiAEKAJAIgdFBEAgBCgCSCEFDAULIAQpAkghFSAGQQlqIgUEQCAHQf8BIAX8CwALIAQgFUIgiD4CPCAEIBWnIg42AjggBCAGNgI0IAQgBzYCMCAEQoiAgICAATcCKCAEIAg2AiQgBEEwaiEPIAQgCwR/IAdBCGohECABKAIAIg0pAwBCf4VCgIGChIiQoMCAf4MhFUEAIQUDQCAVUARAA0AgBUEIaiEFIA1BCGoiDSkDAEKAgYKEiJCgwIB/gyIVQoCBgoSIkKDAgH9RDQALIBVCgIGChIiQoMCAf4UhFQsgByAGIAQoAhwgASgCACAVeqdBA3YgBWoiEUEDdGtBCGsQqwynIhJxIghqKQAAQoCBgoSIkKDAgH+DIhdQBEBBCCEMA0AgCCAMaiEIIAxBCGohDCAHIAYgCHEiCGopAABCgIGChIiQoMCAf4MiF1ANAAsLIBVCAX0gFYMhFSAHIBd6p0EDdiAIaiAGcSIIaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEICyAHIAhqIBJBGXYiDDoAACAQIAhBCGsgBnFqIAw6AAAgByAIQX9zQQN0aiABKAIAIBFBf3NBA3RqKQAANwAAIAtBAWsiCw0ACyABKAIMBUEACyIFNgI8IAQgDiAFazYCOCABIA9BBBD6KiAEQSRqENAmDAELIAEgBEEgakHg3oABQQgQxwkLQYGAgIB4IQYMAgsQ4ycgBCgCDCEFIAQoAgghBgwBCxDjJyAEKAIUIQUgBCgCECEGCyAJIAU2AgQgCSAGNgIAIARB0ABqJAALIAEoAgQiBSAWp3EhBCAWQhmIIhdC/wCDQoGChIiQoMCAAX4hGCABKAIAIQYDQAJ/AkACQAJAIAQgBmopAAAiFiAYhSIVQn+FIBVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFVBFBEADQCAJQQxqQQQgASgCACAVeqdBA3YgBGogBXEiB0EDdGtBCGtBBBCfOw0CIBVCAX0gFYMiFVBFDQALCyAWQoCBgoSIkKDAgH+DIRUgE0UEQCAVUA0DIBV6p0EDdiAEaiAFcSEKC0EBIBUgFkIBhoNQDQMaQQAhBCAGIApqLAAAQQBOBEAgBikDAEKAgYKEiJCgwIB/g3qnQQN2IQoLIAEoAgAiBSAKaiIGLQAAIQcgCSoCDCECIAYgF6dB/wBxIgY6AAAgBSABKAIEIApBCGtxakEIaiAGOgAAIAEgASgCDEEBajYCDCABIAEoAgggB0EBcWs2AgggBSAKQQN0ayIBQQRrIAM2AgAgAUEIayACOAIADAELIAEoAgBBACAHa0EDdGpBBGsiBCgCACEBIAQgAzYCAEEBIQQLIAAgATYCBCAAIAQ2AgAgCUEQaiQADwtBAAshEyAEIBRBCGoiFGogBXEhBAwACwALgAQCCH8BfiMAQSBrIgIkAAJAAkACQCABKAJgQQFqIgMgASgCSE8EQCACQRBqIgQgAUEQaiIDEKUYIAIoAhBFBEAgBEElQQBBAUEBEKAYIAIoAhQhASACKAIQQQFGDQQgAigCGCIDQYKjzQBBJfwKAAAgACADrUKAgICA0ASENwMIIAAgATYCBCAAQQI2AgAMAwsgAikDGCEKIAFBADYCSCABQgAgCkIBg30gCkIBiIU3AzAgAyABQUBrIgUgASgCVBD+HyABKAJQIQMgASgCKCABKAIsIQQgAkEIaiAFEPQvIARBA3ZqIARBB3FBAEdqIQUgAigCCCIEIAIoAgwiB0YNAQNAAn8gAwRAIAQtAAAMAQsgBEEAOgAAQQALIAMgASgCWCIIayIJQQAgAyAJTxshAyAIbEEDdiAFaiEFIARBAWoiBCAHRw0ACwwBCyABIAM2AmAgAEEINgIAIAEgASgCWDYCZAwBCyABIAU2AlwgASgCSCABKAJURgRAIAFBADYCYCAAQQg2AgAgASABKAJYNgJkDAELIAJBEGpBIkEAQQFBARCgGCACKAIUIQEgAigCEEEBRg0BIAIoAhgiA0Hgos0AQSL8CgAAIABBIjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEgaiQADwsgASACKAIYQdT9zAAQ/S8AC5QEAgR/CH4jAEHQAGsiAiQAQoCAgICAgICAgH8hCQJAAkACfgJAAkAgACgCBCgCECABQQR0aiIDKQMAIgsgAykDCCIMQoCAgICAgICAgH+FhEIAUiAAKAIAIgUoAgAiAygCACIEKQMIIgYgBCkDACIHg0J/UnJFBEBCACEGDAELIAYgB4RQDQMgAkEgaiALIAwgByAGEIMZIAJBEGogAikDICIIIAIpAygiCSAHIAYQqB5CACALIAIpAxAiDX0gBiAHg0J/USIEGyEKQgAgDCACKQMYfSALIA1UrX0gBBshBiAMQgBZDQELIAggCiADKAIIIgMpAwBYIAYgAykDCCIHVyAGIAdRG60iB30hBiAJIAcgCFatfQwBCyAJIAggCiADKAIEIgMpAwBaIAYgAykDCCIHWSAGIAdRG618IgYgCFStfAshCCACQTBqIAYgCBCyLgJAIAIpAzAiBiACKQM4IgggAikDQCIHIAIpA0giCSAFKAIELQAAENwdBEAgACgCCCABQQV0aiIAIAk3AxggACAHNwMQIAAgCDcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQIgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB0ABqJAAPC0HMj/8AEOIrAAsgACADQYiL/wAQwyEAC48EAQx/IwBBMGsiAyQAAkAgACgCCCIEIAJNDQAgACgCBCEFAkAgAgRAIAIgBWosAABBv39MDQELIANBADYCICADQQE6ACwgA0EvNgIUIANBLzYCKCADIAQgAmsiCjYCJCADIAo2AhwgAyACIAVqIgs2AhggA0EnaiEMIANBKGohDSAKIQYDQAJAIANBCGogDCADLQAsai0AACAHIAtqIAYgB2sQowogAygCCEEBcUUNAAJAIAMoAiAiByADKAIMaiIGIAMtACwiCEEBayIJSQ0AIAYgCWsiCSAIaiIOIAlJIAogDklyDQACQAJAIAhBBUkEQCAJIAtqIAggDSAIEMEuRQRAIAMoAiAhBwwECyACIAlqQQFqIQICQCABQf8BcQ0AAkAgAkUNACACIARPBEAgAiAERg0BDAULIAIgBWosAABBv39MDQQLIAQgAmtBAkcNACACIAVqIgEtAABB3wFxQcEAa0H/AXFBGUsNACABLQABQTpGDQgLIAIgBEsNByACRSACIARPckUEQCACIAVqLAAAQb9/TA0CCyAAIAI2AggMBwsgCEEEQZSGxAAQsDsAC0GohcQAQTBBnJDEABCfKQALIAUgBCACIARBjJDEABCjNgALIAMgBjYCJCAGIApLDQAgBiAHTw0BCwtB/I/EABCyOwALIAUgBCACIARB7I/EABCjNgALIANBMGokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhCRECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDLJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ7w8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQ0CcgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgICAATcCNCACQTRqIgVBARCHLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDFGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGELYQIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDbLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIctCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEM4nIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhDwDyACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDRJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgMAANwI0IAJBNGoiBUEBEIYtIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMcbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ8Q8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENovDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhi0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzScgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgIDAADcCNCACQTRqIgVBARCGLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDHGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEO4PIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDaLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIYtCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEM8nIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAgAE3AjQgAkE0aiIFQQEQhy0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxRsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhDKECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2y8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCHLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDMJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQkhAgAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzCcgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgICAATcCNCACQTRqIgVBARCHLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDFGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEPIPIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDbLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIctCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABENInIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuYBAEIfyMAQZABayICJAACQCABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQMAQsgAkE8aiIDQQA2AgAgAkKAgICAwAA3AjQgAkE0aiIFQQEQhi0gAkEgaiADKAIANgIAIAJBADYCLCACQoCAgIAQNwIkIAIgAikCNDcDGCAFIAFBEGoiAxDDLSACQRBqIAUQ3DsCQAJAAkAgAigCFCIEBEAgAkEIaiACKAIQIgYQxxsgBEEBRg0BIAIoAgwhBCACKAIIIQcgAiAGQQxqENw7IAIoAgQhBiACKAIAIQggAxD1LQ0CIAJB+ABqIAJBGGoiCSABKAIIIAEoAgwgByAEIAggBhC3ECACKAJ4IgNBCEYNAyAAIAIpAnw3AgQgAEEUaiACQYwBaigCADYCACAAQQxqIAJBhAFqKQIANwIAIAAgAzYCACAFEO8mIAkQ2i8MBAtBAEEAQazHzQAQwyEAC0EBQQFBvMfNABDDIQALIAJBGGogASgCDEEBahCGLQsgAkGIAWoiAyACQShqKQMANwMAIAJBgAFqIgQgAkEgaikDADcDACACIAIpAxg3A3ggARDNJyABQRBqIAMpAwA3AgAgAUEIaiAEKQMANwIAIAEgAikDeDcCACABKAIAQYCAgIB4RwRAIABBCDYCACAAIAE2AgQgAkE0ahDvJgwBC0HMwc0AQShB3MfNABCfKQALIAJBkAFqJAALmAQBCH8jAEGQAWsiAiQAAkAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEDAELIAJBPGoiA0EANgIAIAJCgICAgIABNwI0IAJBNGoiBUEBEIctIAJBIGogAygCADYCACACQQA2AiwgAkKAgICAEDcCJCACIAIpAjQ3AxggBSABQRBqIgMQwy0gAkEQaiAFENw7AkACQAJAIAIoAhQiBARAIAJBCGogAigCECIGEMUbIARBAUYNASACKAIMIQQgAigCCCEHIAIgBkEMahDcOyACKAIEIQYgAigCACEIIAMQ9S0NAiACQfgAaiACQRhqIgkgASgCCCABKAIMIAcgBCAIIAYQ8w8gAigCeCIDQQhGDQMgACACKQJ8NwIEIABBFGogAkGMAWooAgA2AgAgAEEMaiACQYQBaikCADcCACAAIAM2AgAgBRDvJiAJENsvDAQLQQBBAEGsx80AEMMhAAtBAUEBQbzHzQAQwyEACyACQRhqIAEoAgxBAWoQhy0LIAJBiAFqIgMgAkEoaikDADcDACACQYABaiIEIAJBIGopAwA3AwAgAiACKQMYNwN4IAEQzicgAUEQaiADKQMANwIAIAFBCGogBCkDADcCACABIAIpA3g3AgAgASgCAEGAgICAeEcEQCAAQQg2AgAgACABNgIEIAJBNGoQ7yYMAQtBzMHNAEEoQdzHzQAQnykACyACQZABaiQAC5gEAQh/IwBBkAFrIgIkAAJAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBAwBCyACQTxqIgNBADYCACACQoCAgIDAADcCNCACQTRqIgVBARCGLSACQSBqIAMoAgA2AgAgAkEANgIsIAJCgICAgBA3AiQgAiACKQI0NwMYIAUgAUEQaiIDEMMtIAJBEGogBRDcOwJAAkACQCACKAIUIgQEQCACQQhqIAIoAhAiBhDHGyAEQQFGDQEgAigCDCEEIAIoAgghByACIAZBDGoQ3DsgAigCBCEGIAIoAgAhCCADEPUtDQIgAkH4AGogAkEYaiIJIAEoAgggASgCDCAHIAQgCCAGEMkQIAIoAngiA0EIRg0DIAAgAikCfDcCBCAAQRRqIAJBjAFqKAIANgIAIABBDGogAkGEAWopAgA3AgAgACADNgIAIAUQ7yYgCRDaLwwEC0EAQQBBrMfNABDDIQALQQFBAUG8x80AEMMhAAsgAkEYaiABKAIMQQFqEIYtCyACQYgBaiIDIAJBKGopAwA3AwAgAkGAAWoiBCACQSBqKQMANwMAIAIgAikDGDcDeCABEMsnIAFBEGogAykDADcCACABQQhqIAQpAwA3AgAgASACKQN4NwIAIAEoAgBBgICAgHhHBEAgAEEINgIAIAAgATYCBCACQTRqEO8mDAELQczBzQBBKEHcx80AEJ8pAAsgAkGQAWokAAuVBAEJfyMAQRBrIgckAAJAIANBCUkEQCACIQggACgCCCAAKAIYa0EDdCAAKAIcIgprIgUgAiADbE8NASADBEAgBSADbiEIDAILQZi3zgAQ4isAC0HIts4AQTBBiLfOABCfKQALAkACQAJAAkACQAJAAkAgCkUgCEVyDQADQCAHQQhqIAAgAxCQDSAHLQAIRQ0DIAIgBEYNAiABIARqIActAAk6AAAgBEEBaiIEIAhPDQEgACgCHA0ACwsgCCAEayILQQhJBEAgBCEFDAYLIAAoAggiDCAAKAIYIgZrIQkgACgCBCEKA0AgBEF3Sw0DIARBCGoiBSACSw0EIAYgDEsNBSAGIApqIAkgASAEaiADELQWIAAgAyAGaiIGNgIYIAkgA2shCSAFIQQgC0EIayILQQdLDQALDAULIAIgAkGYus4AEMMhAAtB/LjOAEEaQYi6zgAQyyQACyAEIARBCGpB7LfOABCxOwALIARBCGogAkHst84AELA7AAsgBiAMQfy3zgAQrzsACwJAAkAgBSAISQRAIAggBWshCSABIAVqIQYgBSACIAIgBUkbIgEgBWshBANAIAcgACADEJANIActAABFDQMgBEUNAiAGIActAAE6AAAgBEEBayEEIAZBAWohBiAJQQFrIgkNAAsLIAdBEGokACAIDwsgASACQai5zgAQwyEAC0H8uM4AQRpBmLnOABDLJAAL+kgCJn8BfiMAQRBrIhQkACAUQQA2AgQgFCADNgIIIBQgASgCuBMgASgCtBNrNgIMIAFBGGohBCABQbATaiEgIAFBtBNqIRsCQAJAAkADQAJAIBRBDGohGiABKAIAIRYgASgCBCESIBRBCGohHSAUQQRqIR5BACEFIwBB0ABrIgwkACAMIAQpA4gONwMoAkAgBCgC7BBBAEgNAAJAAkACQAJAAkACQCASIBsoAgAiFSAaKAIAIhhqTwRAIB0oAgAgHigCAGogA0sNASAEQYgOaiEiIAQoAtQPIghFBEAgBCAYNgKADkEBIQcgFSEFIBIhCSAWIQ0MBwtBCCEJQQIhByAMQShqIQ0gGEEIIAhrIgYgBiAYSxsiBkUNBiAGIAhqIgkgBkkNAiAJQQhLDQMgBiAVaiIJIAZJDQQgCSASSw0FIBUgFmohCSAGRSIKRQRAIAggDWogCSAG/AoAAAsgCkUEQCAIICJqIAkgBvwKAAALQQghCQwGCyAEQWw2AuwQDAYLIARBbDYC7BAMBQsgCCAJQcTX8wAQsTsACyAJQQhBxNfzABCwOwALIBUgCUHU1/MAELE7AAsgCSASQdTX8wAQsDsACyAEIAU2AvwNIARBqA9qISUgBEHgEGohHCAEQY4RaiEmIARB8A1qIRAgBEGID2ohJCAEQZgPaiEhIARBwA5qIScgBEGoDmohKCAEQZAOaiEpIARBkBNqISMDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQQFrDgIAAgELIAQtAIoRIQUDQEEBIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkADQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAVB/wFxQQFrDhgBAgMMBAUODg4ODxASERISFBUGBwgXGBkACyAEKAL4DUHAAEcNCCAQIA0gCRDLIA0IDDALIBBBBiAcIA0gCRDtH0UNLyAcKAIAQR9rQWtPDQhBcyEHDDALIARBASAEKALgEHRBEGsiBTYC3A8gBCAFIAQoAtwQazYC4A8gDEE0aiIFQagZEPcbIAxBCGogBUHUqPsAEJYhIAwoAgwhBSAMKAIIIQYgBCgCjA8iCARAICQoAgAgCEECdEECEPg6CyAEIAU2AowPIAQgBjYCiA8gBQ0IQWIhBwwvCyMAQTBrIgUkACAEQYCAgAg2ArAPIARCgICAiICAgIABNwOoDyAEQQA2AogQIARCATcCxA8gBEIBNwK8DyAEQgE3ArQPIARBATYCoA8gBEKBgICAEDcDmA8gBUEANgIsIAVCgICAgBA3AiQgBUEYaiAFQSRqQfSo+wAQkCEgBCgC/A4hBiAEKAL4DiEIIAQgBSkDGDcD+A4gBgRAIAggBkEBEPg6CyAFQQA2AiwgBUKAgICAEDcCJCAFQRBqIAVBJGpB9Kj7ABCQISAEKAKEDyEGIAQoAoAPIQggBCAFKQMQNwOADyAGBEAgCCAGQQEQ+DoLIAVBADYCLCAFQoCAgIAQNwIkIAVBCGogBUEkakH0qPsAEJAhIAQoAuQOIQYgBCgC4A4hCCAEIAUpAwg3A+AOIAYEQCAIIAZBARD4OgsgBEIANwL0DyAEQQA7AYQRIARBxKv7ADYC6BAgBEGQDmogBEGEEWoiBhCAGiAEQagOaiAGEIAaIARBwA5qIAYQgBogBUEwaiQAQQQhBSAEQQQ6AIoRDA8LIAxBADYCTCAQQQYgDEHMAGogDSAJEO0fRQ0sIAQgDCgCTCIGQQNxIgU2AowQIAQgBkECdiAFdEEQajYCkBAgBCAFQQJ0Qfic8wBqKAIANgKUECAMQTRqIgUgBCgCmA9BxKj7ABDOGCAMQRBqIAVB1Kj7ABCQISAMKAIUIQUgDCgCECEGIAQoAoQPIggEQCAEKAKADyAIQQEQ+DoLIAQgBTYChA8gBCAGNgKADyAFDQhBayEHDC0LIwBBEGsiByQAAkACQCAEKAKYDyIFIAQoAtAPIgtPBEAgBSAEKAKEDyIGSw0BQQEhBiAFIAtGDQIgBCgCgA8hCCAEQfANaiEKA0AgB0EANgIMIApBAiAHQQxqIA0gCRDtH0UEQCAEIAs2AtAPQQIhBgwECyAIIAtqIAcoAgw6AAAgBSALQQFqIgtHDQALDAILIAsgBUG0p/MAELE7AAsgBSAGQbSn8wAQsDsACyAHQRBqJAAgBkEBRw0rQRUhBQwfCyAEKALQDyEHIAxBADYCPCAMQoCAgIAgNwI0IAxBIGogDEE0akH0qPsAEJYhIAQoApQPIQUgBCgCkA8hBiAEIAwpAyA3A5APQRpBGiAGIAUgB0G4CGxBACAEIA0gCRD3CCEHIAQoApQPIQggBCAFNgKUDyAEKAKQDyEFIAQgBjYCkA8gCARAIAUgCEECdEECEPg6CyAHQQFHDStBFCEFDB4LIAQoAtAPIQUgDEEANgJMIAQoApQPIgYgBUG4CGwiBUkNEgJ/IAQtAMwPBEBBASEFIAQoAqQPDAELIAQoApAPIAxBADYCNCAFQQJ0aiAGIAVrIBAgDEE0aiANIAkQnxMhBSAMKAI0QQAgBRsLIQYgJCAQIAxBzABqIAUgBiANIAkQ1BsEfyAEKALQDyIFQQNPDQ8gJSAFQQJ0aiAMKAJMNgIAIARBEToAihEgBCAEKALQD0EBajYC0A8gBwVBAgshBwwqCyAEKAKYD0EGdEEAIAQgDSAJEKEMIgdBAUcNKUEAIQggBEIANwPADSAEQdgNakIANwMAIARB0A1qQgA3AwAgBEHIDWpCADcDAAJAAkACQAJAAkACQAJAIAQoApgPIgoEQCAEQcANaiEfA0AgCEEGdCIPIAQoAvwOIgVPDQcgBCgC+A4iByAPai0AACEOQQAhEUF8IQsDQCALQQRqIgsgD3IiBiAFTw0DIAZBAXIiEyAFTw0EIAZBAnIiFyAFTw0FIAZBA3IiGSAFTw0GIBEgByATai0AACAOcyAGIAdqLQAAIA5zciAHIBdqLQAAIA5zciAHIBlqLQAAIA5zcnIhESALQTxJDQALIBFFBEAgCEEFdiEFIAhB/wFLDQcgHyAFQQJ0aiIFIAUoAgBBASAIdHI2AgAgBCgCmA8hCgsgCEEBaiIIIApJDQALCwwGCyAGIAVB9KTzABDDIQALIBMgBUGEpfMAEMMhAAsgFyAFQZSl8wAQwyEACyAZIAVBpKXzABDDIQALIAVBCEHkpPMAEMMhAAsgDyAFQdSk8wAQwyEAC0EWIQUMHAsCfyAjLQAAIQYgI0EAOgAAQQEhDiAQIBAoAggiBUEBaiIHNgIIAkAgECkDACIqIAVBP3GtiKdBAXFFBEAgHEEQNgIADAELIBAgBUEEaiIINgIIICogB0E/ca2Ip0EHcSIHBEAgHCAHQRFqNgIAQQEMAgsgECAFQQdqIgc2AggCQAJAAkAgKiAIQT9xrYinQQdxIggOAgEAAgtBcyEOIAZBAXFFDQIgECAFQQhqNgIIICogB0E/ca2Ip0EBcQ0CICNBAToAAEEBDAMLIBxBETYCAEEBDAILIBwgCEEIcjYCAEEBDAELIA4LIgdBAUcNKEEBIQcgBEEBQQIgBC0AkBMbIgU6AIoRDAkLQQIhBSAEQQI6AIoRDAgLIAxBNGoiBUGoGRD3GyAMIAVB1Kj7ABCWISAMKAIEIQYgDCgCACEIIAQoApQPIgUEQCAEKAKQDyAFQQJ0QQIQ+DoLQQMhBSAEQQM6AIoRIAQgBjYClA8gBCAINgKQDwwHCyMAQRBrIgUkACAFQQA2AgwgBEHwDWohByAELQCLESELAn8DQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgC0H/AXFBAWsOBwELAgcDBQQACyAHQQEgBUEMaiANIAkQ7R8NCQwMCyAHQQEgBUEMaiANIAkQ7R9FDQsgBSgCDA0HQQIhCwwKCyAEKALQDyIKIAQtAIkRSA0FQQQhCwwJCyAHQQEgBUEMaiANIAkQ7R9FDQkgBSgCDEUNAkF+DAsLQQQhCyAEKALQDyIKIAQtAIkRTg0HIApBA3QhBgNAIAdBCCAFQQxqIA0gCRDtH0UEQCAEIAo2AtAPDAoLQX0gBSgCDCIOIAQtAIkRIghBAkkgCCAKQQFqIgpHcnJFDQsaIAQgBCgCiBAgDiAGQRhxdHI2AogQIAZBCGohBiAIIApKDQALDAcLQQIgB0ECIAVBDGogDSAJEO0fRQ0JGiAFKAIMIgZFBEAgBEEAOgCLEUEBDAoLIAQgBjoAiRFBByELDAYLQQYhCwwFCyAELQCGESAELQCIEXJFBEAgB0EBIAVBDGogDSAJEO0fRQ0GIAQgBSgCDDoAhxELIARBADoAixEgBCAEKAKIEEEBajYCiBBBAQwHCyAKQQJ0IQYDQCAHQQQgBUEMaiANIAkQ7R9FBEAgBCAKNgLQDwwGC0F/IAUoAgwiDiAELQCJESIIQQVJIAggCkEBaiIKR3JyRQ0HGiAEIAQoAogQIA4gBkEccXRyNgKIEEEEIQsgBkEEaiEGIAggCkoNAAsMAwsgBEEAOgCLEUEBDAULIAQgBS0ADCIGOgCGESAEQQA7AIcRIARBADYCiBBBAUECIAYbIQsMAQtBAiAHQQIgBUEMaiANIAkQ7R9FDQMaIARBADYC0A8gBCAFKAIMIgZBBGo6AIkRQQMhCyAGQQNHDQAgBEEBOgCIEUEFIQsLIAQgCzoAixEMAQsLQQILIQcgBUEQaiQAIAdBAUcNJSAELQCIESIIIAQtAIcRIgpyBEBBACAEKAL4DSIFa0EHcSIGBEAgBCAFIAZqNgL4DUFxIQcgBkECdEGEqfsAaigCACAEKQPwDSAFQT9xrYincQ0nCyAIDQ8LIAQoAogQRQ0XIAQoAtwOBH8gCgVBZSEHAn8jAEEgayIPJAAgBEEBIAQoAuAQdCIGNgLoDyAELQCGESEKIAQtAIcRBEBBASAKAn8gBCgCiBAhBUHAACAEQfANaiIIKAIIIg5rIgtBB3FFBEACQAJ/IAtBA3YiCyAFTQRAQX8gBSALayIFIAgoAhBPDQEaIAgoAgwgBWoiBSAJTw0CIAUgDWotAAAMBAsgCCkDACAOQT9xrYggBUEDdEE4ca2Ip0H/AXELDAILIAUgCUHIqvsAEMMhAAtB2Kr7AEErQYSr+wAQnykACyIFQQNxQQNGGyAKIAVBf0cbIQoLIAQoAvQOIQgCQAJAAkACQAJAAkACQAJAIAQoAtwQIg4gBkEQayIFTQRAIAggDkkNAiAEKALwDiELDAELIAggDkkNAiAEIAU2AtwQIAQoAvAOIA4gBWtqIQsgBSEOCwJAIApB/wFxRSAGQSFIcg0AIAYgBCgCiBAgDmpBAXRBIGoiCkgNACAGIQUDQAJAIAVBAXYhCCAFQcIASQ0AIAgiBSAKTg0BCwsgBCAIIAYgBiAIShsiBjYC6A8LIAQgBkEBayIINgLsDyAPQRRqIgUgBkHCAGpBxKj7ABDOGCAPQQhqIAVB1Kj7ABCQISAPKAIMIQUgDygCCCEGIAQoAtwOIgoEQCAEKALYDiAKQQEQ+DoLIAQgBTYC3A4gBCAGNgLYDgJAIAVFDQAgBSAITQ0DIAYgCGpBADoAACAEKALoD0ECayIIIAQoAtwOIgZPDQQgCCAEKALYDiITakEAOgAAAkAgDkUNACAEKALsD0EAIAQoAtwQIghrcSIKIAhqIhEgCkkNBiAGIBFJDQcgCCAORw0IIA5FDQAgCiATaiALIA78CgAACyAEKAL0DiIGRQ0AIA9BADYCHCAPQoCAgIAQNwIUIA8gD0EUakH0qPsAEJAhIAQoAvAOIAQgDykDADcD8A4gBkEBEPg6CyAPQSBqJAAgBUEARwwHCyAOIAhB1KbzABCwOwALIA4gCEHkpvMAELA7AAsgCCAFQfSm8wAQwyEACyAIIAZBhKfzABDDIQALIAogEUGUp/MAELE7AAsgESAGQZSn8wAQsDsACyAIIA5BpKfzABCzOwALRQ0mIAQtAIcRC0H/AXFFBEAgBEEROgCKESAEQQA2AtAPQQEhBwwmCyAEQQs6AIoRQQEhBwwlC0EGIQUgBEEGOgCKESAEQQA2AtAPDAULQQAgBCANIAkQqgEiB0ECRw0jQQEgBCANIAkQqgEhBwwjCwJ/IwBBEGsiEyQAIARB8A1qIREgBC0AlBMhCwJAAkADQAJAAkAgC0EBcQRAIBNBBGogHSACIAMgHiAgQQAgBBCSDiATKAIEIgtBAUcNBEEAIQsgBCgC6A9BASAEKALgEHRHDQEgBCAEKALcDzYC5A8MAQsgBCgC3A4iBSAEKALYDyIGSQ0EIAQoAtgOIAZqIRkgBSAGayELQQAhBUEAIQcCQCAEKALoDyIIIAZrIAQoAoAOQcAAIAQoAvgNa0EDdmoiCiAEKAKIECIOIAogDkgbIgogBiAKaiAIShsiFyIIRQ0AIBEoAggiBkHBAGtBd0sNACAIQQFrIQ4gESkDACEqAkADQCAHIAtHBEAgESAGQQhqIgo2AgggByAZaiAqIAZBP3GtiDwAACAHQQFqIQUgBkE5a0F3Sw0CIAcgDkcgBSEHIAohBg0BDAILCyALIAtBtKv7ABDDIQALIAggBWshCAsgESgCDCEOAkACQAJAIAgEQCAOIAkgCSAOSxshByAFIAsgBSALSRshBiAIIQ8gDiEKA0AgByAJRg0DIAYgC0YNAiAFIBlqIAogDWotAAA6AAAgCkEBaiEKIAdBAWohByAGQQFqIQYgBUEBaiEFIA9BAWsiDw0ACwsgESAIIA5qNgIMIBEgESgCECAIazYCEAwCCyAFIAtBpKv7ABDDIQALIAogCUGUq/sAEMMhAAsgBCAXIAQoAtgPaiIFNgLYDyAEIAQoAogQIgYgF2s2AogQQQEhCyAFQQEgBCgC4BB0SA0BCyAEIAs6AJQTDAELC0EBQQIgBiAXRhshCwsgE0EQaiQAIAsMAQsgBiAFQcSm8wAQrzsACyIHQQFHDSIMFAsgBCgCiBBBAEwNEgNAIAxBADYCNCAQQQggDEE0aiANIAkQ7R9FDSEgBCAEKAKIEEEBayIFNgKIECAFQQBKDQALDBILIAQQyhMgBC0AhhFFDRACQEEAIAQoAvgNIgZrQQdxIghFBEAgBiEFDAELIAQgBiAIaiIFNgL4DUFxIAcgCEECdEGEqfsAaigCACAEKQPwDSAGQT9xrYincRshBwsgBCgC1A9FBEAgBEHAACAFayIGQQN2IgggBCgCgA5qIhg2AoAOIAQgBCgC/A0gCGsiFTYC/A0gBCAFIAZBeHEiCGo2AvgNIBogGDYCACAbIBU2AgAgBCAEKQPwDSAGQThxrYZCACAIQcAARxs3A/ANC0EYIQUgBEEYOgCKEQwBCwsgDEE0aiAdIAIgAyAeICBBACAEEJIOIAwoAjQiB0EBRw0eIwBBIGsiBSQAAkACQAJAAkAgBC0AkRMEQCAEKALcDiIIIAQoAugPIgZJDQEgBCgC2A8iByAGSw0CIAcgCCAGa0sNAyAHBEAgBCgC2A4iCCAGIAhqIAf8CgAACyAEQQA6AJETCyAFQSBqJAAMAwsgBUEANgIYIAVBATYCDCAFQfCc8wA2AgggBUIENwIQIAVBCGpBlKbzABDvLAALIAVBADYCGCAFQQE2AgwgBUHwnPMANgIIIAVCBDcCECAFQQhqQaSm8wAQ7ywACyAFQQA2AhggBUEBNgIMIAVB8JzzADYCCCAFQgQ3AhAgBUEIakG0pvMAEO8sAAsgBCgC6A9BASAEKALgEHRGBEAgBCAEKALcDzYC5A8LAkACQAJAIAQtAIoRQQ9rDgIAAQILQQEhByAEQQ5BByAEKAKIEEEATBs6AIoRDCALIARBCjoAihFBASEHDB8LIAQoAtAPRQ0NIARBCDoAihFBASEHDB4LIAQoAtAPIgVBAkoNByAFQQNPDQhBAiEHICYgECAhIAVBAnRqIA0gCRDuE0EBRw0dIAQoAtAPIgVBAksNCSAhIAVBAnRqIgUgBSgCAEEBajYCACAEKALQDyIFQQNPDQogISAFQQJ0aigCAEECTwRAQRIhBQwRC0EBIQcgBCAFQQFqNgLQDwwdCyAEKALQDyEIIAxBADYCPCAMQoCAgIAgNwI0IAxBGGogDEE0akH0qPsAEJYhIAQoAowPIQUgBCgCiA8hBiAEIAwpAxg3A4gPIAQoAtAPIgdBA0kNCiAHQQNBlNjzABDDIQALIAVBA0G02PMAEMMhAAsgBCgCkBAiBkE+QRggBC0AkBMiCBsgBCgCjBAiB0EBanRqIgohBSAIBEAgBkEQayEFIwBBIGsiBiQAIAZCjICAgMADNwIIIAZCgICAgMAANwIAIAZC5IGAgIA1NwIYIAZCyYCAgOAPNwIQAkAgB0EDTQRAQQEgB3QhCCAGIAdBAnQiB2ooAgAiDiAFTQRAIAZBEGogB2ooAgAhByAIIA5qIgggBU8EQCAHIAhqIQUMAwsgBSAHaiEFDAILIAZBEGogB2ooAgAgBSAIamohBQwBCyAHQQRBtNfzABDDIQALIAZBIGokAAsgBCgCoA9BAnRBASAEIA0gCRChDCIHQQFHDRogKUGAAkGAAiAEKALkEBDeFiAoQcAFQcAFIAQoApwPEN4WICcgCiAFIAQoApgQEN4WAkACQCAEKAKcDkUNACAEKAK0DkUNACAEKALMDg0BCyAEQWE2AuwQQQAhBQwcC0EXIQUgBEEXOgCKESAEQQA2AtAPDA4LAn8gBCgC0A8hGUEAIQgjAEFAaiIHJAACQAJAAkACQAJAIBlBAk0EQCAHQQA2AjwgB0KAgICAIDcCNCAHQShqIAdBNGoiBkH0qPsAEJYhIAQgGUEYbGoiBSgCnA4hESAFKAKYDiETIAUgBykDKDcDmA4gB0EANgI8IAdCgICAgMAANwI0IAdBIGogBkH0qPsAEJghIAUoApQOIQogBSgCkA4hFyAFIAcpAyA3A5AOIAUvAaIOIR8gBS8BpA4hBiAFLwGgDiEFIAQtAJMTRQ0CIAQoAsQQIgggBksNAQwDC0FhIQ8gBEFhNgLsEAwDCyAIIAZB6KLzABCxOwALIARBAToAkxMgBEIANwLEEAsgBiAKSw0BQQEhDwJAIAYgCEYNACAGQQJ0IAhBAnQiBmshCCAGIBdqIQ4gBCgCyBAhCwNAIAdBADYCNCAFIB8gEyARIAsgB0E0aiAEIA0gCRD3CCIPQQFHDQEgDiAEKALIECIGNgIAIAQgBiAHKAI0aiILNgLIEEEBIQ8gBCAEKALEEEEBajYCxBAgDkEEaiEOIAhBBGsiCA0ACwsgB0EANgI8IAdCgICAgCA3AjQgB0EYaiAHQTRqQfSo+wAQliEgBygCHCEOIAcoAhgCQAJAAkACQAJAIBkOAgABAgsgBCgCnA4hBSAEIBE2ApwOIAQoApgOIQYgBCATNgKYDiAFBEAgBiAFQQJ0QQIQ+DoLIAdBADYCPCAHQoCAgIDAADcCNCAHQQhqIAdBNGpB9Kj7ABCYISAHKAIMIQsgBygCCCEGIAQoApQOIQggBCAKNgKUDiAEKAKQDiEFIAQgFzYCkA4gCA0CDAMLIAQoArQOIQUgBCARNgK0DiAEKAKwDiEGIAQgEzYCsA4gBQRAIAYgBUECdEECEPg6CyAHQQA2AjwgB0KAgICAwAA3AjQgB0EQaiAHQTRqQfSo+wAQmCEgBygCFCELIAcoAhAhBiAEKAKsDiEIIAQgCjYCrA4gBCgCqA4hBSAEIBc2AqgOIAgNAQwCCyAEKALMDiEFIAQgETYCzA4gBCgCyA4hBiAEIBM2AsgOIAUEQCAGIAVBAnRBAhD4OgsgB0EANgI8IAdCgICAgMAANwI0IAcgB0E0akH0qPsAEJghIAcoAgQhCyAHKAIAIQYgBCgCxA4hCCAEIAo2AsQOIAQoAsAOIQUgBCAXNgLADiAIRQ0BCyAFIAhBAnRBBBD4OgsgD0EBRgRAIARBADoAkxMLIAsEQCAGIAtBAnRBBBD4OgsgDkUNACAOQQJ0QQIQ+DoLIAdBQGskACAPDAELIAYgCkHoovMAELA7AAsiB0EBRw0ZQQEhByAEIAQoAtAPQQFqIgU2AtAPIAVBA0gNGSAEELEZIARBBzoAihEgBEEAOwHwECAEQQA2AvgPDBkLAkAgBCgC3A4EQCAMQTRqIB0gAiADIB4gIEEBIAQQkg4gDCgCNCIHQQFHDRogBEEBNgLsEAwBCyAEIAc2AuwQQQAhBSAHQQFHDRoLQQEhBQwZCyAFIAZBpNjzABCvOwALIARBDDoAihFBASEHDBYLIARBBToAihEMFQsgBUEDQeTX8wAQwyEACyAFQQNB9NfzABDDIQALIAVBA0GE2PMAEMMhAAsgISAHQQJ0aigCAEECaiIHIAcgBiAFIAhBuAhsQQAgBCANIAkQ9wghByAEKAKMDyEIIAQgBTYCjA8gBCgCiA8hBSAEIAY2AogPIAgEQCAFIAhBAnRBAhD4OgsgB0EBRw0RQRMhBQwEC0EBIQcgBEEOQQkgBCgCiBBBAEwbOgCKEQwQCyAEQQM6AIoRDA8LIAdBAUcNDgsgBEEOOgCKEUEBIQcMDQsgBCAFOgCKEQwACwALIAQoAtQPBEAgBEEANgLUDwwCCyAQQcAAIBAoAggiCWsiBUEDdiINIBAoAhBqNgIQIBAgECgCDCANazYCDCAQIAkgBUF4cSINajYCCCAQIBApAwAgBUE4ca2GQgAgDUHAAEcbNwMAIBogBCgCgA42AgAgGyAEKAL8DTYCAAwBCyAEKALcDgRAIAxBNGogHSACIAMgHiAgQQEgBBCSDiAMKAI0IgdBAEgNAQsgBCgC1A8iBUUEQCAbIAQoAvwNIg02AgACQCAEKAKADiIGBEAgDSASIA0gEksbIQhBACEHIAYhCSANIQUDQCAFIAhGDQUgB0EITw0CIAcgImogBSAWai0AADoAACAbIAVBAWoiBTYCACAEIAQoAtQPQQFqIgc2AtQPIAlBAWsiCQ0ACwsgGkEANgIADAkLIBogCTYCACAHQQhB1NjzABDDIQALIAQoAoAORQ0GIBhFDQcgEiAVTQ0CIAwgFSAWai0AACIGOgAzIAVBCE8NAyAFICJqIAY6AAAgBCgC1A8iBUEITw0EIAYgDEEoaiAFaiIHLQAARw0FQQEhByAEIAVBAWoiBTYCgA4gBCAFNgLUDyAbIBVBAWoiFTYCACAaIBhBAWsiGDYCAAwJCyAEIAc2AuwQQQNBACAHQQNGGyEFDAkLIBogBiANaiAIazYCACAIIBJBxNjzABDDIQALIBUgEkHk2PMAEMMhAAsgBUEIQfTY8wAQwyEACyAFQQhBhNnzABDDIQALIAxBADYCNCMAQRBrIgAkACAAIAxBM2o2AgwgACAHNgIIQQAgAEEIakHkqPsAIABBDGpB5Kj7ACAMQTRqQZTZ8wAQ5g8ACyAEIBg2AoAOIARBADYC1A8gBCAVNgL8DUEBIQcgEiEJIBYhDQwCC0ECIQUgBEECNgLsEAwCC0ECIQcMAAsACyAMQdAAaiQAIAVBAkcEQAJAAkACQCAFQQFrDgMCAAQBCwALIAEpAxAhKiABQQQ6ABAgAEIEICogKkL+AYNCBFEbNwIADAYLIBQoAgQiAkUNAwwECyMAQSBrIgUkAAJAAkACQCABKAIEIhIgASgCtBMiCUcEQCAJQYACaiASTSABKAK4EyAJayINIAlPcg0DIAkgEksNASABKAIAIRYgASANNgK4EyANIBIgCWsiEksNAiAWIA0gCSAWaiANQayg0AAQ1SwgAUEANgK0EwwDCyABQgA3ArQTDAILIAVBADYCGCAFQQE2AgwgBUH4oNAANgIIIAVCBDcCECAFQQhqQYyg0AAQ7ywACyANIBJBnKDQABCwOwALIAVBIGokACAUKAIEIgUEQCAAQQQ6AAAgACAFNgIEDAULAkAgASgCBCISIAEoArgTIgVPBEAgASgCACAFaiEWIAEoAgghCSABKAIMIg0gEiAFayIFIAUgDUsbIgVBAUYEQCAWIAktAAA6AAAgASANQQFrNgIMIAEgCUEBajYCCAwCCyAFBEAgFiAJIAX8CgAACyABIA0gBWs2AgwgASAFIAlqNgIIIAUNASABKQMQISogAUEEOgAQIABCBCAqICpC/gGDQgRRGzcCAAwGCyAFIBJB8J/QABCvOwALIAEgASgCuBMgBWoiBTYCuBMgFCAFIAEoArQTazYCDCAUKAIIIANGDQELCyAAIBQoAgQ2AgQgAEEEOgAADAILIAEtALwTRQRAIAFBAToAvBMMAQsgASgCuBMgASgCtBNGDQAgASkDECEqIAFBBDoAECAAQgQgKiAqQv4Bg0IEURs3AgAMAQsgAEEEOgAAIAAgAjYCBAsgFEEQaiQAC8ECAQF/IwBBQGoiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCDCACIABBA3YiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIMIAIgAEEDdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkEDdGorAwA5AxAgBEEQaiADEJAgIARBQGskAA8LIAQgADYCLCAEQQI2AhQgBEG4l4QBNgIQIARCAjcCHCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCGCAEIARBLGo2AjggBCAEQQxqNgIwIARBEGpByJeEARDvLAAL/wMBCX8CQCABKAIEIgggASgCACIGRgRAQQIhBwwBCyAIIAZrIQQgAUEIaiEKIAYhAgJAA0AgASACQQFqIgU2AgACQCACLQAAIgPAQQBODQAgASACQQJqIgU2AgAgAi0AAUE/cSEJIANBH3EhByADQd8BTQRAIAdBBnQgCXIhAwwBCyABIAJBA2oiBTYCACACLQACQT9xIAlBBnRyIQkgA0HwAUkEQCAJIAdBDHRyIQMMAQsgASACQQRqIgU2AgAgB0ESdEGAgPAAcSACLQADQT9xIAlBBnRyciEDC0EAIQcCQAJAAkACQCADQSJMBEAgA0ENRyADQQlrQQJPcQ0DIAUgCEF/c2oiAiAEaiIBDQEMBAsgA0EjRg0BIANBgIDEAEYNBQwCCwJAIAEgBE8EQCACRQ0EDAELIAEgBmosAABBv39KDQMLIAYgBEEAIAFBzJPEABCjNgALIAEtABBBAUcNAEEBIQcCQCAFIAhBf3NqIgIgBGoiAUUNAAJAIAEgBE8EQCACRQ0CDAELIAEgBmosAABBv39KDQELIAYgBEEAIAFB3JPEABCjNgALIAEhBAwDCyAKKAIABEAgCkHsk8QAIAMgARCQDCABKAIEIQggASgCACEFCyAFIgIgCEcNAQwCCwsgASEECyAAIAQ2AgQgACAGNgIACyAAIAc6AAgLowQCCH8BfiMAQSBrIgckAAJAIANFBEAMAQsgAUEQaiEIA0AgAiAFaiELIAMgBWshCQJAAkAgASgCNCIKDQAgASgCOCEEAkACQAJAAkADQCAERQRAIAgoAgBFDQIgByAIEKUYIAcoAgBBAUcNCSAHKQMIIgxQDQkgDEIBg1BFBEAgASAMp0ECdEF4cTYCOAwICyABIAxCAYg+AjQgB0EQaiAIIAEtADwiBEEDdiAEQQdxQQBHahDBHCAHKQMQIQwgASAHKQMYNwMIIAEgDDcDACAMpw0HQcD6zABBLkHw+swAEJ8pAAsgCCgCAEUNAiAEIAkgBCAJSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAggCyAEIAEtADwQoQsiBEUEQEEAIQQgAUEANgI4IAEoAjQiCkUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgCiAJIAkgCksbIgYgBWoiBCAGTwRAIAMgBEkNASAGRSADIAVGckUEQCALIAEtAAhBAEcgBvwLAAsgASAKIAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAALmAQBCH8CQCADQQlJBEAgAiEHIAAoAgggACgCGGtBA3QgACgCHCIJayIFIAIgA2xPDQEgAwRAIAUgA24hBwwCC0GYt84AEOIrAAtByLbOAEEwQYi3zgAQnykACwJAAkACQAJAAkACQAJAAkAgCUUgB0VyDQADQCAAIAMQ0w1B/wFxIgVBAkYNAyACIARGDQIgASAEaiAFOgAAIARBAWoiBCAHTw0BIAAoAhwNAAsLIANBAUsNAiAHIARrIgpBCEkEQCAEIQUMBwsgACgCCCILIAAoAhgiBmshCCAAKAIEIQkDQCAEQXdLDQQgBEEIaiIFIAJLDQUgBiALSw0GIAYgCWogCCABIARqIAMQtBYgACADIAZqIgY2AhggCCADayEIIAUhBCAKQQhrIgpBB0sNAAsMBgsgAiACQZi6zgAQwyEAC0H8uM4AQRpBiLrOABDLJAALQay3zgBBLUHct84AEJ8pAAsgBCAEQQhqQey3zgAQsTsACyAEQQhqIAJB7LfOABCwOwALIAYgC0H8t84AEK87AAsCQAJAIAUgB0kEQCAHIAVrIQggASAFaiEGIAUgAiACIAVJGyIJIAVrIQQDQCAAIAMQ0w1B/wFxIgFBAkYNAyAERQ0CIAYgAToAACAEQQFrIQQgBkEBaiEGIAhBAWsiCA0ACwsgBw8LIAkgAkGouc4AEMMhAAtB/LjOAEEaQZi5zgAQyyQAC8EEAQV/IwBBkANrIgQkACAEQfwBaiADQQhqKAIANgIAIARCBDcC7AEgBEIANwLkASAEQoCAgIDAADcC3AEgBEEANgLUASAEQQA7AawCIARBADYCqAIgBEEANgKQAiAEQQA2AoQCIAQgAykCADcC9AEgBCABKAIIQQFrNgKAAiAEQYADaiIFIAEQ4CwgBCAEKQKAAzcChAEgBEEANgKAASAEIAQoAowDIgY2AnwgBCAEKAKIAzYCeCAEQRBqIARB+ABqIggQ1zsgBCgCECEHAkBBHEEEEK02IgMEQCADQoGAgIAQNwIAIAMgBCkCeDcCCCADQRBqIARBgAFqKQIANwIAIANBGGogBEGIAWooAgA2AgAgBCAGNgK4AiAEIAc2ArQCIAQgAzYCsAIgCCAEQdQBaiIDIARBsAJqIgYQ+iMgBSABQQxqEPIvIAQgBCkCgAM3AuABIARBADYC3AEgBCAEKAKMAyIFNgLYASAEIAQoAogDNgLUASAEQQhqIAMQ1zsgBCgCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAEKQLUATcCCCABQRBqIARB3AFqKQIANwIAIAFBGGogBEHkAWooAgA2AgAgBCAFNgK4AiAEIAc2ArQCIAQgATYCsAIgAyAIIAYQ+iMgBEEcaiIBIAMgAhCuFiAEQbwCaiICIAEQzRwgBCACEKABIAQoAgQhASAAIAQoAgA2AgAgACABNgIEIARBkANqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC8EEAQV/IwBBkANrIgQkACAEQfwBaiADQQhqKAIANgIAIARCBDcC7AEgBEIANwLkASAEQoCAgIDAADcC3AEgBEEANgLUASAEQQA7AawCIARBADYCqAIgBEEANgKQAiAEQQA2AoQCIAQgAykCADcC9AEgBCABKAIIQQFrNgKAAiAEQYADaiIFIAEQ3iwgBCAEKQKAAzcChAEgBEEANgKAASAEIAQoAowDIgY2AnwgBCAEKAKIAzYCeCAEQRBqIARB+ABqIggQ1zsgBCgCECEHAkBBHEEEEK02IgMEQCADQoGAgIAQNwIAIAMgBCkCeDcCCCADQRBqIARBgAFqKQIANwIAIANBGGogBEGIAWooAgA2AgAgBCAGNgK4AiAEIAc2ArQCIAQgAzYCsAIgCCAEQdQBaiIDIARBsAJqIgYQ+iMgBSABQQxqEPIvIAQgBCkCgAM3AuABIARBADYC3AEgBCAEKAKMAyIFNgLYASAEIAQoAogDNgLUASAEQQhqIAMQ1zsgBCgCCCEHQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASAEKQLUATcCCCABQRBqIARB3AFqKQIANwIAIAFBGGogBEHkAWooAgA2AgAgBCAFNgK4AiAEIAc2ArQCIAQgATYCsAIgAyAIIAYQ+iMgBEEcaiIBIAMgAhCuFiAEQbwCaiICIAEQzRwgBCACEKABIAQoAgQhASAAIAQoAgA2AgAgACABNgIEIARBkANqJAAPC0EEQRwQoz0AC0EEQRwQoz0AC6wEAQp/IwBBMGsiBSQAAkACQAJAAkACQAJAIAEoAggiBCABKAI0IgNrIgYgAiACIAZLGyIGIANqIgIgBk8EQCACIARLDQEgAiABKAIUIgRLDQIgBUEMaiADQQJ0IgMgASgCBGoiBCAEIAZBAnQiB2ogASgCECADaiIDIAMgB2oQiygCQCAFKAIgIgQgBSgCHCIDSwRAIAEoAiwhCSABKAIoIQwgBCADayEKIAFBGGohCyADQQJ0IgMgBSgCFGohAiAFKAIMIANqIQMgASgCOCEEA0AgASgCLCAEIAIoAgAiBGpJDQIgCyADKAIAEPQ0IAEoAjgiByAEaiIIIAdJDQYgCCAJSw0HIAsgByAMaiAEEKE2IAEgASgCOCAEaiIENgI4IAJBBGohAiADQQRqIQMgCkEBayIKDQALIAEoAjQgBmohAgsgACAGNgIEIAEgAjYCNCAAQQg2AgAMBwsgBUEkakEXQQBBAUEBEKAYIAUoAighAiAFKAIkQQFGDQUgBSgCLCIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMBgsgAyACQeSGzQAQsTsACyACIARB5IbNABCwOwALIAIgBEH0hs0AELA7AAsgByAIQYSHzQAQsTsACyAIIAlBhIfNABCwOwALIAIgBSgCLEHU/cwAEP0vAAsgBUEwaiQAC6UKAhF/BH4jAEEQayIMJAAgDCACNwMIIAFBEGoiBiAMQQhqEI0OIRcgASgCCEUEQCMAQdAAayIFJAAgBSAGNgIcIAEoAgwhDSAFIAVBHGo2AiACQAJAIA0gDUEBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAn8gB0EBaiIHIAYgBiAHSRsiBkEPTwRAIAZB/////wFLDQVBfyAGQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBkEISRsgBkEESRsLIQYgBUFAayABQRBqIghBEEEIIAYQnRQgBSgCRCEHIAUoAkAiCUUEQCAFKAJIIQYMBQsgBSkCSCEWIAdBCWoiBgRAIAlB/wEgBvwLAAsgBSAWQiCIPgI8IAUgFqciEDYCOCAFIAc2AjQgBSAJNgIwIAVCkICAgIABNwIoIAUgCDYCJCAFQTBqIREgBSANBH8gCUEIaiESIAEoAgAiDykDAEJ/hUKAgYKEiJCgwIB/gyEWQQAhBgNAIBZQBEADQCAGQQhqIQYgD0EIaiIPKQMAQoCBgoSIkKDAgH+DIhZCgIGChIiQoMCAf1ENAAsgFkKAgYKEiJCgwIB/hSEWCyAJIAcgBSgCHCABKAIAIBZ6p0EDdiAGaiITQQR0a0EQaxCNDqciFHEiCGopAABCgIGChIiQoMCAf4MiGFAEQEEIIQoDQCAIIApqIQggCkEIaiEKIAkgByAIcSIIaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgFkIBfSAWgyEWIAkgGHqnQQN2IAhqIAdxIghqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQgLIAggCWogFEEZdiIKOgAAIBIgCEEIayAHcWogCjoAACAJIAhBf3NBBHRqIgggASgCACATQX9zQQR0aiIKKQAANwAAIAhBCGogCkEIaikAADcAACANQQFrIg0NAAsgASgCDAVBAAsiBjYCPCAFIBAgBms2AjggASARQQQQ+iogBUEkahDQJgwBCyABIAVBIGpBpPT+AEEQEMUJC0GBgICAeCEHDAILEOMnIAUoAgwhBiAFKAIIIQcMAQsQ4ycgBSgCFCEGIAUoAhAhBwsgDCAGNgIEIAwgBzYCACAFQdAAaiQACyABKAIEIgcgF6dxIQUgF0IZiCIYQv8Ag0KBgoSIkKDAgAF+IRkgASgCACEGA0ACfwJAAkACQCAFIAZqKQAAIhcgGYUiFkJ/hSAWQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhZQRQRAA0AgAiAGIBZ6p0EDdiAFaiAHcUEEdGsiCUEQaykDAFENAiAWQgF9IBaDIhZQRQ0ACwsgF0KAgYKEiJCgwIB/gyEWIA5FBEAgFlANAyAWeqdBA3YgBWogB3EhCwtBASAWIBdCAYaDUA0DGkEAIQUgBiALaiwAACIOQQBOBEAgBiAGKQMAQoCBgoSIkKDAgH+DeqdBA3YiC2otAAAhDgsgBiALaiAYp0H/AHEiCToAACAGIAtBCGsgB3FqQQhqIAk6AAAgASABKAIIIA5BAXFrNgIIIAEgASgCDEEBajYCDCAGIAtBBHRrIgFBEGsgAjcDACABQQhrIAM2AgAgAUEEayAENgIADAELIAlBBGsiBSgCACEBIAUgBDYCACAJQQhrIgQoAgAhBSAEIAM2AgALIAAgATYCBCAAIAU2AgAgDEEQaiQADwtBAAshDiAFIBVBCGoiFWogB3EhBQwACwALiAoCEX8EfiMAQRBrIgokACAKIAI3AwggAUEQaiIFIApBCGoQjQ4hFiABKAIIRQRAIwBB0ABrIgQkACAEIAU2AhwgASgCDCELIAQgBEEcajYCIAJAAkAgCyALQQFqIgVNBEACQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEACfyAGQQFqIgYgBSAFIAZJGyIFQQ9PBEAgBUH/////AUsNBUF/IAVBA3RBB25BAWtndkEBagwBC0EEQQhBECAFQQhJGyAFQQRJGwshBSAEQUBrIAFBEGoiCEHQAEEIIAUQnRQgBCgCRCEGIAQoAkAiB0UEQCAEKAJIIQUMBQsgBCkCSCEVIAZBCWoiBQRAIAdB/wEgBfwLAAsgBCAVQiCIPgI8IAQgFaciDjYCOCAEIAY2AjQgBCAHNgIwIARC0ICAgIABNwIoIAQgCDYCJCAEQTBqIQ8gBCALBH8gB0EIaiEQIAEoAgAiDSkDAEJ/hUKAgYKEiJCgwIB/gyEVQQAhBQNAIBVQBEADQCAFQQhqIQUgDUEIaiINKQMAQoCBgoSIkKDAgH+DIhVCgIGChIiQoMCAf1ENAAsgFUKAgYKEiJCgwIB/hSEVCyAHIAYgBCgCHCABKAIAIBV6p0EDdiAFaiIRQbB/bGpB0ABrEI0OpyIScSIIaikAAEKAgYKEiJCgwIB/gyIXUARAQQghDANAIAggDGohCCAMQQhqIQwgByAGIAhxIghqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyAHIBd6p0EDdiAIaiAGcSIIaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEICyAHIAhqIBJBGXYiDDoAACAQIAhBCGsgBnFqIAw6AAAgByAIQX9zQdAAbGogASgCACARQX9zQdAAbGpB0AD8CgAAIBVCAX0gFYMhFSALQQFrIgsNAAsgASgCDAVBAAsiBTYCPCAEIA4gBWs2AjggASAPQQQQ+iogBEEkahDQJgwBCyABIARBIGpBvPT+AEHQABDFCQtBgYCAgHghBgwCCxDjJyAEKAIMIQUgBCgCCCEGDAELEOMnIAQoAhQhBSAEKAIQIQYLIAogBTYCBCAKIAY2AgAgBEHQAGokAAsgASgCBCIGIBancSEEIBZCGYgiF0L/AINCgYKEiJCgwIABfiEYIAEoAgAhBQNAAn8CQAJAAkAgBCAFaikAACIWIBiFIhVCf4UgFUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIVUEUEQANAIAIgBSAVeqdBA3YgBGogBnFBsH9saiIHQdAAaykDAFENAiAVQgF9IBWDIhVQRQ0ACwsgFkKAgYKEiJCgwIB/gyEVIBNFBEAgFVANAyAVeqdBA3YgBGogBnEhCQtBASAVIBZCAYaDUA0DGiAFIAlqLAAAIgRBAE4EQCAFIAUpAwBCgIGChIiQoMCAf4N6p0EDdiIJai0AACEECyAFIAlqIBenQf8AcSIHOgAAIAUgCUEIayAGcWpBCGogBzoAACABIAEoAgggBEEBcWs2AgggASABKAIMQQFqNgIMIAUgCUGwf2xqIgFB0ABrIAI3AwAgAUHIAGsgA0HEAPwKAAAgAEGAgICAeDYCAAwBCyAHQcgAayEBIAAgAUHEAPwKAAAgASADQcQA/AoAAAsgCkEQaiQADwtBAAshEyAEIBRBCGoiFGogBnEhBAwACwAL0AQCAX8EfiMAQfAAayICJAAgAiAAKQMANwIIIAIgACkDCCIEQoDA4oXj6AB/IgM3AxAgAiAEQoCwncLfAX8iBSADQkR+fCIGNwMYIARCgJTr3AN/IQMCfwJAAkAgBEL/v+KF4+gAfEL+/8SLxtEBVgRAIAJBAzYCVCACQciTgQE2AlAgAkICNwJcIAJB7gY2AjQgAkHMATYCLCACIAJBKGo2AlggAiACQRBqNgIwIAIgAkEIajYCKCABKAIAIAEoAgQgAkHQAGoQywoNASACQQE2AgwgAkHgk4EBNgIICyAGUA0BIAJBAzYCVCACQeiTgQE2AlAgAkICNwJcIAJB7gY2AjQgAkHMATYCLCACIAJBKGo2AlggAiACQRhqNgIwIAIgAkEIajYCKCABKAIAIAEoAgQgAkHQAGoQywoNACACQQE2AgwgAkHgk4EBNgIIDAELQQEMAQtBACAFQkR+IAN8IgUgBCADQoCU69wDfn0iBIQiA1ANABogAiADQj+IPgIkIAJBgJSBAUEBIANCAFMbNgIgIAIgBSAFQj+HIgOFIAN9NwNAIAIgBCAEQj+HIgOFIAN9NwNIIAJBBDYCPCACQbCUgQE2AjggAkEFNgIsIAJBiJSBATYCKCACQQQ2AjQgAkHuBjYCbCACQe4GNgJkIAJBzAE2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkHIAGo2AmggAiACQUBrNgJgIAIgAkEgajYCWCACIAJBCGo2AlAgASgCACABKAIEIAJBKGoQywoLIAJB8ABqJAALoAQCCH8BfiMAQSBrIgckAAJAIANFBEAMAQsgAUEQaiEIA0AgAiAFaiELIAMgBWshCQJAAkAgASgCNCIKDQAgASgCOCEEAkACQAJAAkADQCAERQRAIAgoAgBFDQIgByAIEKUYIAcoAgBBAUcNCSAHKQMIIgxQDQkgDEIBg1BFBEAgASAMp0ECdEF4cTYCOAwICyABIAxCAYg+AjQgB0EQaiAIIAEtADwiBEEDdiAEQQdxQQBHahDBHCAHKQMQIQwgASAHKQMYNwMIIAEgDDcDACAMpw0HQcD6zABBLkHw+swAEJ8pAAsgCCgCAEUNAiAEIAkgBCAJSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAggCyAEIAEtADwQnAsiBEUEQEEAIQQgAUEANgI4IAEoAjQiCkUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgCiAJIAkgCksbIgYgBWoiBCAGTwRAIAMgBEkNASAGRSADIAVGckUEQCALIAEtAAggBvwLAAsgASAKIAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQN0aikDABDOLyACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQJ0aigCABDJLSACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQJ0aigCABCULyACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQN0aikDABCzLiACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQF0ai8BABC1LiACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL0wQCBH8IfiMAQYACayICJAAgACgCACEEIAJBgAFqIgUgACgCBCgCECABQQF0ai8BABCTLSACKQOAASEJIAIpA4gBIQogAikDkAEhCyACKQOYASEMIAQoAgAiAykDACEGIAMpAwghByADKQMQIQggAiADKQMYIg03A3ggAiAINwNwIAIgBzcDaCACIAY3A2AgAiAMNwNYIAIgCzcDUCACIAo3A0ggAiAJNwNAAkACQAJAAkACQCAGIAiEIAcgDYSEUEUEQCAFIAkgCiALIAwgBiAHIAggDRCaCCACLQCAAUEBRw0CIAJBAjYChAEgAkGYkP8ANgKAASACQgI3AowBIAJBgww2AvwBIAJBgww2AvQBIAIgAkHwAWo2AogBIAIgAkHgAGo2AvgBIAIgAkFAazYC8AEgAkHgAWogBRCZDiACQSRqIAJB7AFqKAIANgIAIAJBiICAgHg2AtwBIAIgAkHkAWopAgA3AhwgAiACKQLcATcCFAwBCyACQYeAgIB4NgIUCyACQQE2AhAgAkEQakEEchCIEQwBCyACKQOQASIGIAIpA5gBIgcgAikDoAEiCCACKQOoASIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBgAJqJAAPCyAAIANBiIv/ABDDIQAL6AMBB38CQCABLQAdBEAMAQsgASgCCCEHIAEoAhAiAyABKAIUIghHBEAgASgCGCECA0AgAiIGAn8gAyICLAAAIgRBAE4EQCAEQf8BcSEEIAJBAWoMAQsgAi0AAUE/cSEDIARBH3EhBSAEQV9NBEAgBUEGdCADciEEIAJBAmoMAQsgAi0AAkE/cSADQQZ0ciEDIARBcEkEQCADIAVBDHRyIQQgAkEDagwBCyAFQRJ0QYCA8ABxIAItAANBP3EgA0EGdHJyIQQgAkEEagsiAyACa2ohAgJAAkAgBEEJayIFQRdNQQBBASAFdEGfgIAEcRsNACAEQYABSQ0BAkACQCAEQQh2IgVBH00EQCAFRQ0BIAVBFkcgBEGALUdyDQQMAwsgBUEgRg0BIAVBMEcgBEGA4ABHcg0DDAILIARB/wFxQfvUiQFqLQAAQQFxDQEMAgsgBEH/AXFB+9SJAWotAABBAnFFDQELIAEgAjYCGCABIAM2AhAgASgCACEFIAEgAjYCACAFIAdqIQMgBiAFayEBDAMLIAMgCEcNAAsgASACNgIYIAEgAzYCEAsgAUEBOgAdIAcgASgCACICaiIGIAZBACABKAIEIgYgAkcbIAEtABwbIQMgBiACayEBCyAAIAE2AgQgACADNgIAC7gEAQR/IwBB4ABrIgIkACACIAApAgA3AgggAiAAKAIIIgBBgN3bAW0iAzYCECACIABB4NQDbSIEIANBRGxqIgU2AhQgAEHoB20hAwJ/AkACQCAAQf/c2wFqQf65twNLBEAgAkEDNgJEIAJByJOBATYCQCACQgI3AkwgAkGcAzYCLCACQcwBNgIkIAIgAkEgajYCSCACIAJBEGo2AiggAiACQQhqNgIgIAEoAgAgASgCBCACQUBrEMsKDQEgAkEBNgIMIAJB4JOBATYCCAsgBUUNASACQQM2AkQgAkHok4EBNgJAIAJCAjcCTCACQZwDNgIsIAJBzAE2AiQgAiACQSBqNgJIIAIgAkEUajYCKCACIAJBCGo2AiAgASgCACABKAIEIAJBQGsQywoNACACQQE2AgwgAkHgk4EBNgIIDAELQQEMAQtBACAEQURsIANqIgQgACADQegHbGsiAHIiA0UNABogAiADQR92NgIcIAJBgJSBAUEBIANBAEgbNgIYIAIgBCAEQR91IgNzIANrNgI4IAIgACAAQR91IgNzIANrNgI8IAJBBDYCNCACQZCVgQE2AjAgAkEFNgIkIAJBiJSBATYCICACQQQ2AiwgAkGcAzYCXCACQZwDNgJUIAJBzAE2AkwgAkHMATYCRCACIAJBQGs2AiggAiACQTxqNgJYIAIgAkE4ajYCUCACIAJBGGo2AkggAiACQQhqNgJAIAEoAgAgASgCBCACQSBqEMsKCyACQeAAaiQAC8EFAQl/AkACQCACRSADRXINAEEBIQZBAQJ/An8gASgCACIFQf8fQf//AyAAKAIYIgMtACgbTQRAIAVBBnYiByADKAIESQRAIAMoAgAgB0EBdGovAAAgBUE/cWoMAgsgAygCEEEBawwBCyADKAIYIAVLBEAgAyAFEMAPDAELIAMoAhBBAmsLIgUgAygCEEkEQCADKAIMIAVqLQAADAELIAMtACwLdEHAA3FFDQAMAQsgAkUgBEVyRQRAIAFBBGohAyABQQRrIQogAEEUaiELIAJBAnRBBGshBCAAKAIgIQlBACEGA0ACQCABIAhBAnRqIgAoAgAiDEH+//8AcUGMwABHDQACQCAIRQ0AIABBBGsiAEUNAEEAIQcCfwJAIAAoAgAiBUH/H0H//wMgCygCACIALQAsG0sEQCAFQYCAxABJDQEgACgCFEEBawwCCyAFQQZ2IgcgACgCCEkEQCAAKAIEIAdBAXRqLwAAIAVBP3FqDAILIAAoAhRBAWsMAQsgACgCHCAFSwRAIAAgBRDBDwwBCyAAKAIUQQJrCyIFIAAoAhQiDUkEfyAAKAIQIAVBAnRqKAAABSAHCyAAKAIAIAUgDUkbIgBBACAAQYD8//8DcUGAsANGG0H/AXFBCUYNASAGIQAgDEGNwABGDQADQCAARQ0BIAkgACAKaigCABDrGSIFELE9QQxxRQRAIABBBGshACAFQf8BcUEFRw0CDAELCyADIQUgBCEAA0AgAEUNASAJIAUoAgAQ6xkiBxCxPUEUcQ0CIAVBBGohBSAAQQRrIQAgB0H/AXFBBUYNAAsLQQEPCyADQQRqIQMgBEEEayEEIAZBBGohBiAIQQFqIgggAkcNAAsLIAJBAnQhCCABIQADQEEAIQYgCEUNASAIQQRrIQggACgCACAAQQRqIQBBgAFJDQALIAJB6AdLIQYLIAYLlQQBA38jAEEwayIHJAACQCADIARPBEAgBEUEQCAHQRhqIAEgAiABKAJAIgIgAyACIANJGxCgCyAHKAIcIQICQCAHKAIYIgNBCEcEQCAAIAcpAyA3AwggAEEQaiAHQShqKQMANwMADAELIAEgASgCQCACazYCQAsgACADNgIAIAAgAjYCBAwCCyAHIAMgBGsiBDYCACAHQRhqIAEgAiABKAJAIgggAyADIAhLGxCgCyAHKAIcIQggBygCGCIJQQhHBEAgACAHKQMgNwMIIABBEGogB0EoaikDADcDACAAIAg2AgQgACAJNgIADAILIAcgCDYCBCABIAEoAkAgCGs2AkAgBCAIRgRAIANBAWshAQNAAkACQCAGIAFBA3YiCEsEQCABQQdxQfzEzgBqLQAAIAUgCGotAABxRQ0CIARBAWsiBCADTw0BIAEgAmoiCC0AACEJIAggAiAEaiIILQAAOgAAIAggCToAAAwCCyAIIAZBxIjNABDDIQALIAQgA0GkoM0AEMMhAAsgAUEBayIBQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIcIAdB6KDNADYCGCAHQgI3AiQgB0E7NgIUIAdBOzYCDCAHIAdBCGo2AiAgByAHNgIQIAcgB0EEajYCCCAAQQRqIAdBGGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC+ADAQZ/IwBBQGoiBiQAIAZBGGpCADcDACAGQRBqQgA3AwAgBkEIakIANwMAIAZCADcDACAGQThqQgA3AwAgBkEwakIANwMAIAZBKGpCADcDACAGQgA3AyACQAJAIAIEQANAIAEgBUYNAyAAIAVqLQAAIgdBEE8NAiAGIAdBAXRqIgcgBy8BAEEBajsBACACIAVBAWoiBUcNAAsLQQAhBSAGQQA7AQADQCAFIAZqQSJqIAggBSAGai8BAGpBAXQiCDsBACAFQQJqIgVBHkcNAAsgAgRAQQAhBwNAAkACQCABIAdHBEAgACAHai0AACIJRQ0CIAlBD0sNASAGQSBqIAlBAXRqIgUgBS8BACIFQQFqOwEAIAVBD3FBAnRBkJbSAGooAgAhCCAJQQVPBEBBBCEKA0AgBUECdkE8cUGQltIAaigCACAIQQR0ciEIIAVBBHZB/x9xIQUgCkEEaiIKIAlJDQALCyAEIAdLBEAgAyAHQQF0aiAIQQAgCWtBA3F2OwEADAMLIAcgBEHwltIAEMMhAAsgASABQdCW0gAQwyEACyAJQRBB4JbSABDDIQALIAdBAWoiByACRw0ACwsgBkFAayQADwsgB0EQQZCX0gAQwyEACyABIAFBgJfSABDDIQALmwQBBH8jAEHQAGsiAyQAIABBBCAAKAI0IgQgBEEETRs2AjQgAEEwaiEEAkAgAkF/cyAAKAIwIgZrQQNxIgUgACgCCCAGa00NACAAKAIIIAAoAjBrIAVPDQADQCAAEPsWIAAoAgggACgCMGsgBUkNAAsLIAQgBRCNNyAAQQEgACgCNCIFIAVBAU0bNgI0IAAoAggaIARBABCNNyAAKAIIIAAoAjBHIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIARBARCNNyADQTBqIAAQ3DsgAygCNCEFIAMoAjAhBiADQShqIAAoAjAQjDcgA0EgaiAGIAUgAygCKCADKAIsQbC3/gAQ1yYCQAJAIAMoAiQEQCADKAIgQQA6AAACQCAAKAIIIAAoAjBrIAJPIgUNACACQYCAgIB4Sw0CIAUNAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAjAhBCADQRhqIAAQ3DsgA0EQaiADKAIYIAMoAhwgBCAEIAJrQZC3/gAQ1yYgAygCFCIEIAJHDQIgAgRAIAMoAhAgASAC/AoAAAsgA0EIaiAAENw7IAAgAhCpERogACgCMCADQdAAaiQADwsgA0EANgJIIANBATYCPCADQey3/gA2AjggA0IENwJAIANBOGpBwLf+ABDvLAALQdi2/gBBJUGAt/4AEJ8pAAsgBCACQaC3/gAQszsAC4EEAgh+BH8jAEEwayILJABCgICAgICAgICAfyEFAkACQAJ+AkACQCAAKAIEKAIQIAFBBHRqIgopAwAiByAKKQMIIghCgICAgICAgICAf4WEQgBSIAAoAgAiDSgCACIKKAIAIgwpAwgiAiAMKQMAIgODQn9SckUEQEIAIQIMAQsgAiADhFANAyALQSBqIAcgCCADIAIQgxkgC0EQaiALKQMgIgQgCykDKCIFIAMgAhCoHkIAIAcgCykDECIJfSACIAODQn9RIgwbIQZCACAIIAspAxh9IAcgCVStfSAMGyECIAhCAFkNAQsgBCAGIAooAggiCikDAFggAiAKKQMIIgNXIAIgA1EbrSIDfSECIAUgAyAEVq19DAELIAUgBCAGIAooAgQiCikDAFogAiAKKQMIIgNZIAIgA1EbrXwiAiAEVK18CyEEAkACQCACQoCAgIAIfCIDQv////8PViAEIAIgA1atfCIEQgBSIARQGw0AIAKnIgogDSgCBC0AABDEKUUNACAAKAIIIAFBAnRqIAo2AgAMAQsgACgCECIKIAooAgBBAWo2AgAgC0EIaiAAKAIUEIY9IAFBA3YiACALKAIMIgpPDQIgCygCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAtBMGokAA8LQcyP/wAQ4isACyAAIApBiIv/ABDDIQALnAQBAn8jAEHgAGsiBSQAIAUgBDoADwJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgIsIAVBoIzNADYCKCAFQgE3AjQgBUGuAzYCTCAFIAVByABqNgIwIAUgBUEPajYCSCAAQQRqIAVBKGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMAQsgBUEwaiIEQQA2AgAgBUKAgICAwAA3AiggBUEoaiIGQQEQhi0gBUEYaiIHIAQoAgA2AgAgBUEANgIkIAVCgICAgBA3AhwgBSAFKQIoNwMQIAQgAkEIaikCADcDACAFQQA2AjggBSADNgI8IAUgAikCADcDKCAFIAEtAGg6AEAgBUHIAGogBiAFQRBqIgNBfxDpCCAFKAJIIgJBCEcEQCAAIAUpA1A3AwggAEEQaiAFQdgAaikDADcDACAAIAUoAkw2AgQgACACNgIAIAVBNGogBSgCLCAFKAIwIAUoAigoAhARAQAgAxDaLwwBCyAFQdgAaiIDIAVBIGopAwA3AwAgBUHQAGogBykDADcDACAFIAUpAxA3A0ggAUHQAGohAiABKAJQQYCAgIB4RwRAIAIQ2i8LIAIgBSkDSDcCACACQRBqIAMpAwA3AgAgAkEIaiAFQdAAaikDADcCACAAQQg2AgAgBUE0aiAFKAIsIAUoAjAgBSgCKCgCEBEBAAsgBUHgAGokAAucBAECfyMAQeAAayIFJAAgBSAEOgAPAkAgBEH/AXEiBEEHTUEAQQEgBHRBgwFxG0UEQCAFQQE2AiwgBUGgjM0ANgIoIAVCATcCNCAFQa4DNgJMIAUgBUHIAGo2AjAgBSAFQQ9qNgJIIABBBGogBUEoahCZDiAAQQE2AgAgAkEMaiACKAIEIAIoAgggAigCACgCEBEBAAwBCyAFQTBqIgRBADYCACAFQoCAgICAATcCKCAFQShqIgZBARCHLSAFQRhqIgcgBCgCADYCACAFQQA2AiQgBUKAgICAEDcCHCAFIAUpAig3AxAgBCACQQhqKQIANwMAIAVBADYCOCAFIAM2AjwgBSACKQIANwMoIAUgAS0AaDoAQCAFQcgAaiAGIAVBEGoiA0F/EOoIIAUoAkgiAkEIRwRAIAAgBSkDUDcDCCAAQRBqIAVB2ABqKQMANwMAIAAgBSgCTDYCBCAAIAI2AgAgBUE0aiAFKAIsIAUoAjAgBSgCKCgCEBEBACADENsvDAELIAVB2ABqIgMgBUEgaikDADcDACAFQdAAaiAHKQMANwMAIAUgBSkDEDcDSCABQdAAaiECIAEoAlBBgICAgHhHBEAgAhDbLwsgAiAFKQNINwIAIAJBEGogAykDADcCACACQQhqIAVB0ABqKQMANwIAIABBCDYCACAFQTRqIAUoAiwgBSgCMCAFKAIoKAIQEQEACyAFQeAAaiQAC9AEAgR/CH4jAEGAAmsiAiQAIAAoAgAhBCACQYABaiIFIAAoAgQoAhAgAWotAAAQtC4gAikDgAEhCSACKQOIASEKIAIpA5ABIQsgAikDmAEhDCAEKAIAIgMpAwAhBiADKQMIIQcgAykDECEIIAIgAykDGCINNwN4IAIgCDcDcCACIAc3A2ggAiAGNwNgIAIgDDcDWCACIAs3A1AgAiAKNwNIIAIgCTcDQAJAAkACQAJAAkAgBiAIhCAHIA2EhFBFBEAgBSAJIAogCyAMIAYgByAIIA0QmgggAi0AgAFBAUcNAiACQQI2AoQBIAJBmJD/ADYCgAEgAkICNwKMASACQYMMNgL8ASACQYMMNgL0ASACIAJB8AFqNgKIASACIAJB4ABqNgL4ASACIAJBQGs2AvABIAJB4AFqIAUQmQ4gAkEkaiACQewBaigCADYCACACQYiAgIB4NgLcASACIAJB5AFqKQIANwIcIAIgAikC3AE3AhQMAQsgAkGHgICAeDYCFAsgAkEBNgIQIAJBEGpBBHIQiBEMAQsgAikDkAEiBiACKQOYASIHIAIpA6ABIgggAikDqAEiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQYACaiQADwsgACADQYiL/wAQwyEAC9AEAgR/CH4jAEGAAmsiAiQAIAAoAgAhBCACQYABaiIFIAAoAgQoAhAgAWotAAAQki0gAikDgAEhCSACKQOIASEKIAIpA5ABIQsgAikDmAEhDCAEKAIAIgMpAwAhBiADKQMIIQcgAykDECEIIAIgAykDGCINNwN4IAIgCDcDcCACIAc3A2ggAiAGNwNgIAIgDDcDWCACIAs3A1AgAiAKNwNIIAIgCTcDQAJAAkACQAJAAkAgBiAIhCAHIA2EhFBFBEAgBSAJIAogCyAMIAYgByAIIA0QmgggAi0AgAFBAUcNAiACQQI2AoQBIAJBmJD/ADYCgAEgAkICNwKMASACQYMMNgL8ASACQYMMNgL0ASACIAJB8AFqNgKIASACIAJB4ABqNgL4ASACIAJBQGs2AvABIAJB4AFqIAUQmQ4gAkEkaiACQewBaigCADYCACACQYiAgIB4NgLcASACIAJB5AFqKQIANwIcIAIgAikC3AE3AhQMAQsgAkGHgICAeDYCFAsgAkEBNgIQIAJBEGpBBHIQiBEMAQsgAikDkAEiBiACKQOYASIHIAIpA6ABIgggAikDqAEiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQYACaiQADwsgACADQYiL/wAQwyEAC4sEAQJ/IwBB0ABrIgUkACAFIAQ6AAcCQCAEQf8BcSIEQQdNQQBBASAEdEGDAXEbRQRAIAVBATYCPCAFQaCMzQA2AjggBUIBNwJEIAVBrgM2AiQgBSAFQSBqNgJAIAUgBUEHajYCICAAQQRqIAVBOGoQmQ4gAEEBNgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAMAQsgBUIENwIYIAVCADcCECAFQoCAgICAAjcCCCAFQUBrIgQgAkEIaikCADcDACAFIAIpAgA3AzggAS0AaCECIAVBIGoiBiAFQThqIgcQ/BsgBSACOgA0IAVBADYCLCAFIAM2AjAgByAGIAVBCGpBfxDmByAFKAI4IgJBCEcEQCAAIAUpA0A3AwggAEEQaiAFQcgAaikDADcDACAAIAUoAjw2AgQgACACNgIAIAUoAiAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAYQ+x4LIAVBCGoQ2S8MAQsgBUHIAGoiAyAFQRhqKQIANwMAIAQgBUEQaikCADcDACAFIAUpAgg3AzggAUHQAGohAiABKAJQQYCAgIB4RwRAIAIQ2S8LIAIgBSkDODcCACACQRBqIAMpAwA3AgAgAkEIaiAFQUBrKQMANwIAIABBCDYCACAFKAIgIgAgACgCACIAQQFrNgIAIABBAUcNACAFQSBqEPseCyAFQdAAaiQAC7cEAgd/AX4jAEEgayIIJAACQCADRQ0AIAFBEGohCgNAIAMgBWshByACIAVBAnRqIQkCQAJAIAEoAjQiBA0AIAEoAjghBgJAAkACQAJAA0AgBkUEQCAKKAIARQ0CIAggChClGCAIKAIAQQFHDQkgCCkDCCILUA0JIAtCAYNQRQRAIAEgC6dBAnRBeHE2AjgMCAsgASALQgGIPgI0IAhBEGogCiABLQA8IglBA3YgCUEHcUEAR2oQwRwgCCkDECELIAEgCCkDGDcDCCABIAs3AwAgC6cNB0HA+swAQS5B8PrMABCfKQALIAooAgBFDQIgBiAHIAYgB0kbIgQgBWoiBiAESQ0DIAMgBkkNBCAKIAkgBCABLQA8ELkGIgRFBEBBACEGIAFBADYCOCABKAI0IgRFDQEMBgsLIAEgASgCOCAEazYCOCAEIAVqIQUMBQtBnPjMAEEYQbD6zAAQyyQAC0Gc+MwAQRhBtPjMABDLJAALIAUgBkHE+MwAELE7AAsgBiADQcT4zAAQsDsACyABKAIARQRAQdT4zAAQsjsACwJAIAQgByAEIAdJGyIHIAVqIgQgB08EQCADIARJDQEgASgCCCEFIAcEQCAHQQJ0IQYDQCAJIAU2AgAgCUEEaiEJIAZBBGsiBg0ACwsgASABKAI0IAdrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAIQSBqJAALtwQCB38BfiMAQSBrIggkAAJAIANFDQAgAUEQaiEKA0AgAyAFayEHIAIgBUEBdGohCQJAAkAgASgCNCIEDQAgASgCOCEGAkACQAJAAkADQCAGRQRAIAooAgBFDQIgCCAKEKUYIAgoAgBBAUcNCSAIKQMIIgtQDQkgC0IBg1BFBEAgASALp0ECdEF4cTYCOAwICyABIAtCAYg+AjQgCEEQaiAKIAEtADwiCUEDdiAJQQdxQQBHahDBHCAIKQMQIQsgASAIKQMYNwMIIAEgCzcDACALpw0HQcD6zABBLkHw+swAEJ8pAAsgCigCAEUNAiAGIAcgBiAHSRsiBCAFaiIGIARJDQMgAyAGSQ0EIAogCSAEIAEtADwQpggiBEUEQEEAIQYgAUEANgI4IAEoAjQiBEUNAQwGCwsgASABKAI4IARrNgI4IAQgBWohBQwFC0Gc+MwAQRhBsPrMABDLJAALQZz4zABBGEG0+MwAEMskAAsgBSAGQcT4zAAQsTsACyAGIANBxPjMABCwOwALIAEoAgBFBEBB1PjMABCyOwALAkAgBCAHIAQgB0kbIgcgBWoiBCAHTwRAIAMgBEkNASABLwEIIQUgBwRAIAdBAXQhBgNAIAkgBTsBACAJQQJqIQkgBkECayIGDQALCyABIAEoAjQgB2s2AjQgBCEFDAILIAUgBEHk+MwAELE7AAsgBCADQeT4zAAQsDsACyADIAVLDQALCyAAQQg2AgAgACAFNgIEIAhBIGokAAufBAEGfyMAQeACayIFJAAgASgC7AIiBigCFCIEQQhqIAQoAghBAkZBAnRqIgctACEhCEEAIQQCQAJAAkACQCAGLwEYIgkOAgABAgsgBUIFNwMIDAILIAYvARoNACAHLQAgIgRBA0cgBEEAR3EhBAsgBUEIaiAJIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDWAwBCyAFQdgAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBOBEAgBUG4AWpBADoAACAFQgA3A7ABQQAiBEUEQCAFQZACaiAFQQhqQdAA/AoAAAsgBEUEQCAFQcABaiAFQdgAakHQAPwKAAALIAEpAwBCBVIEQCABKAKQAiIEIAQoAgAiBEEBazYCACAEQQFGBEAgAUGQAmoQ2SELIAFBiAJqELwqIAFB0ABqEJMqIAEQ/S4CQCABKALwASIERQ0AIAQgBCgCACIEQQFrNgIAIARBAUcNACABQfABahC7IwsgAUGgAWoQmywgAUH4AWoQlAwLIAEgBUHAAWpBoAH8CgAAIAEgBjYCkAIgASADNgKMAiABIAI2AogCIAFBADYC8AEgAUIHNwOgASABIAhBAUYiAjoAhAIgASAFKQOwATcClAIgAUGcAmogBUG4AWotAAA6AAAgASAFLwCtATsAnQIgAUGfAmogBUGvAWotAAA6AAAgAUEZQRYgAhs6APgBIABBCDYCACAFQeACaiQADwsAC58EAQZ/IwBB4AJrIgUkACABKALsAiIGKAIUIgRBCGogBCgCCEECRkECdGoiBy0AISEIQQAhBAJAAkACQAJAIAYvARgiCQ4CAAECCyAFQgU3AwgMAgsgBi8BGg0AIActACAiBEEDRyAEQQBHcSEECyAFQQhqIAkgBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNYDAELIAVB2ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQCAFQbgBakEAOgAAIAVCADcDsAFBACIERQRAIAVBkAJqIAVBCGpB0AD8CgAACyAERQRAIAVBwAFqIAVB2ABqQdAA/AoAAAsgASkDAEIFUgRAIAEoApACIgQgBCgCACIEQQFrNgIAIARBAUYEQCABQZACahDZIQsgAUGIAmoQvCogAUHQAGoQkyogARD9LgJAIAEoAvABIgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAFB8AFqELsjCyABQaABahCbLCABQfgBahCUDAsgASAFQcABakGgAfwKAAAgASAGNgKQAiABIAM2AowCIAEgAjYCiAIgAUEANgLwASABQgc3A6ABIAEgCEEBRiICOgCEAiABIAUpA7ABNwKUAiABQZwCaiAFQbgBai0AADoAACABIAUvAK0BOwCdAiABQZ8CaiAFQa8Bai0AADoAACABQRhBFCACGzoA+AEgAEEINgIAIAVB4AJqJAAPCwAL6QMBCX8gBAR9AkACQAJAA0ACQAJAAn8CQAJAIAIgCGogA3EiBSABTQRAIAEgBUYNAUEBIAAgBWoiBi0AACIKwCIHQQBKDQMaQQEhCyAEIAhrIgxBAU0NBCABIAVrIQUgB0FgcUFARw0CIAVBAUcEQCAHQR5xRQ0DIAYsAAFBQE4NA0ECDAQLQQFBAUH8ndYAEMMhAAsgBSABQdye1gAQrzsAC0EAQQBB7J3WABDDIQALIAxBAkYNAQJAIAdBcHFBYEcNAAJAIAVBAUcEQCAGLAABIg1BQE4NAiAFQQNJDQEgDUH/AXFBBnRBgBBxIApBDHRBgOADcXJFIAYsAAJBQE5yDQJBAwwDC0EBQQFBjJ7WABDDIQALQQJBAkGcntYAEMMhAAsgB0H4AXFB8AFHIAxBBElyDQEgBUEBRg0CIAYsAAEiB0FATg0BIAVBA0kNBCAGLAACQUBODQEgBUEDRg0FIApBEnRBgIDwAHEgB0H/AXFBDHRBgIAMcXJBgIAEa0H//z9LIAYsAANBQE5yDQFBBAsiCyAJaiEJCyAEIAggC2oiCEsNAQwECwtBAUEBQaye1gAQwyEAC0ECQQJBvJ7WABDDIQALQQNBA0HMntYAEMMhAAsgCbMFQwAAAAALIASzQwAAQD+UXgvYAwIDfgV/IwBBIGsiByQAAkAgAlAgAUK/f1NyDQBB/wEhCCABQiZVDQAgB0EQaiABpyIGQQR0IglB0MOBAWopAwBCACACIAJ5IgOGIgVCABCoHiAHKQMQIQQgBykDGCICQv//////B4NC//////8HUQRAIAcgCUHYw4EBaikDAEIAIAVCABCoHiACIAcpAwgiAiAEfCIEIAJUrXwhAgsgA6chCSACQj+IIgOnIQogBEJ/USABQht8QtIAVnFFBEAgAiADQiaEIgWIIQMCQAJAIAZB6qQNbEEQdSAJayAKakE/aiIGQYJ/TgRAQYABQf8AIANC/P//H4MgAyADIAWGIAJRGyADIANCA4NCAVEbIAMgAUIRfEIcVBsgAyAEQgJUGyIBQgGDIAF8IgFC////D1YiCRsgBmoiBkH+AU0NAUIAIQQMBAsgBkHDfk8NAUIAIQRBACEIDAMLQgAgAUIBiEL///8bgyAJGyEEIAYhCAwCCyADQQIgBmtBP3GtiCIBQgGDIgIgAXxC////B1YhCCACpyABp2pBAXatIQQMAQsgBkHqpA1sQRB1IApFIgYgCWprQen+AWshCCACIAathiEECyAAIAg2AgggACAENwMAIAdBIGokAAu+AgEBfyMAQTBrIgQkAAJAAkACQAJAAkACQCAAKAIAKAIALQAAQQ1rDgUBAgIDAwALIAEoAhQhACAEIAI2AgAgAiAAQQF2IgBJDQMMBAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NA0HYm4QBELI7AAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NAkGsnIQBELI7AAsgACgCBCgCFCEAIAQgAjYCACACIABBAXYiAE8NAUH8nIQBELI7AAsgBCABKAIQIAJBAXRqLwEAOwEEIARBBGogAxDiFCAEQTBqJAAPCyAEIAA2AhwgBEECNgIIIARBuJeEATYCBCAEQgI3AhAgBEE7NgIsIARBOzYCJCAEIARBIGo2AgwgBCAEQRxqNgIoIAQgBDYCICAEQQRqQciXhAEQ7ywAC74CAQF/IwBBMGsiBCQAAkACQAJAAkACQAJAIAAoAgAoAgAtAABBDWsOBQECAgMDAAsgASgCFCEAIAQgAjYCACACIABBAnYiAEkNAwwECyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0DQdibhAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0CQaychAEQsjsACyAAKAIEKAIUIQAgBCACNgIAIAIgAEECdiIATw0BQfychAEQsjsACyAEIAEoAhAgAkECdGoqAgA4AgQgBEEEaiADEI8gIARBMGokAA8LIAQgADYCHCAEQQI2AgggBEG4l4QBNgIEIARCAjcCECAEQTs2AiwgBEE7NgIkIAQgBEEgajYCDCAEIARBHGo2AiggBCAENgIgIARBBGpByJeEARDvLAALjAQBCH8jAEEgayIFJAAgBUEYaiAAKAIcIgNB2ABqEOQlIAUoAhwhCAJAAkACQAJ/AkAgAygCXCIEIAMoAmAiCSADKAJkIgpqIgZrIgcgAk8NAAJAAkACQANAIAQgCSAKaiIGSQ0BIAcgBCAGayIESw0CIAcEQCADKAJYIAZqIAEgB/wKAAALIAMgAygCZCAHajYCZCAAKAIwIQYgBUEQaiADQdgAahDkJSAFKAIUIgQgCEkNAyAAIAYgBSgCECAIaiAEIAhrEN0HNgIwIAMgAygCjAEgB2o2AowBIAAQ4hggBUEIaiAAKAIcIgNB2ABqEOQlIAUoAgxFBEAgASAHaiEBQQAhCCACIAdrIgIgAygCXCIEIAMoAmAiCSADKAJkIgpqIgZrIgdNDQUMAQsLIANB/wE6AAFBAAwECyAGIARBkPr7ABCvOwALIAcgBEGQ+vsAELA7AAsgCCAEQaD6+wAQrzsACyAEIAZJDQEgAiAEIAZrIgdLDQIgAgRAIAMoAlggBmogASAC/AoAAAsgAyADKAJkIAJqNgJkIAAoAjAgBSADQdgAahDkJSAFKAIEIgEgCEkNAyAFKAIAIAhqIAEgCGsQ3QchASADQQA2AowBIAAgATYCMEEDCyAFQSBqJAAPCyAGIARB8Pn7ABCvOwALIAIgB0Hw+fsAELA7AAsgCCABQYD6+wAQrzsAC6wFAgd/AX4jAEEwayIDJAACQAJAIAEoAhQiBiABKAIQIgdJBEAgASAGQQFqIgQ2AhQgAUEMaiEFIAEoAgwiCCAGai0AACIJQTBGBEACQCAEIAdJBEAgBCAIai0AAEEwa0H/AXFBCkkNAQsgACABIAJCABDIFAwECyADQQ02AiAgA0EIaiAFIAZBAmoiASAHIAEgB0kbEOoMIANBIGogAygCCCADKAIMEPsoIQEgAEIDNwMAIAAgATYCCAwDCyAJQTFrQf8BcUEJTwRAIANBDTYCICADQRBqIAUgBBDqDCADQSBqIAMoAhAgAygCFBD7KCEBIABCAzcDACAAIAE2AggMAwsgCUEwa61C/wGDIQoCQCAEIAdPDQADQCAEIAhqLQAAQTBrIgZB/wFxIgVBCk8NASAFQQVLIApCmbPmzJmz5swZUnIgCkKZs+bMmbPmzBlacQ0DIAEgBEEBaiIENgIUIApCCn4gBq1C/wGDfCEKIAQgB0cNAAsLIAAgASACIAoQyBQMAgsgA0EFNgIgIANBGGogAUEMaiAGEOoMIANBIGogAygCGCADKAIcEPsoIQEgAEIDNwMAIAAgATYCCAwBCyADQSBqIQYgAiEEQQAhAgJAAkACQCABKAIQIgcgASgCFCIFTQ0AIAVBAWohCCAHIAVrIQcgASgCDCAFaiEJA0AgAiAJai0AACIFQTBrQf8BcUEKTwRAIAVBLkYNAyAFQcUARyAFQeUAR3ENAiAGIAEgBCAKIAIQ6QwMBAsgASACIAhqNgIUIAcgAkEBaiICRw0ACyAHIQILIAYgASAEIAogAhCwEgwBCyAGIAEgBCAKIAIQ1A0LIAACfiADKAIgQQFGBEAgACADKAIkNgIIQgMMAQsgACADKwMoOQMIQgALNwMACyADQTBqJAALuwYCCH8BfiMAQTBrIgMkACABAn8CQAJAAkACQAJAAkACQAJAAkAgAS0ACEEBaw4EBAEDAAILIAEoAhghBAwFCwALIAFCATcDECABIAEoAgA2AiAgAUIAIAE1AgR9NwMYCyADQQhqIQUjAEEQayIGJAACQCABQRBqIgQpAwBCA1IEQCAGIAQoAhAoAgAQ3R4gBigCACIHQQJGBEAgBUECNgIADAILIAdBAXEEQCAFIAYpAgQ3AgQgBUEBNgIADAILIAQpAwAhCyAEKAIQKAIAIgcgBCkDCDcDCCAHIAs3AwAgBEIDNwMAIAUgBCgCECgCABDdHgwBCyAFIAQoAhAoAgAQ3R4LIAZBEGokACADKAIIIgRBAkcNASAAQQk2AgBBAwwFC0HM/8IAEOgrAAsgBEEBcQRAIAMgAykCDDcDCCADQRhqIANBCGoQgSsMAwsgA0EIaiABKAIEQQBBAUEBEKAYIAMoAgwhBCADKAIIQQFGDQEgAygCECEFIAFBADYCFCABIAU2AhAgASAENgIMIAFBADYCKCABIAQ2AiQgAUEANgIgIAEgAUEMajYCHCABIAFBMGoiBDYCGCABIAEoAgA2AjggASABNQIENwMwCyADQQhqIQYjAEEQayIFJAAgAUEoaiIJKAIAIQcgBUEIaiABQRxqIgogBCACEIAJAkAgBS0ACCIIQQVHBEADQCAIQQRHBEAgBiAFKQMINwIADAMLIAUoAgwiCEUEQCAGIAc2AgQgBkEEOgAAIAlBADYCAAwDCyAJIAcgCGoiBzYCACAFQQhqIAogBCACEIAJIAUtAAgiCEEFRw0ACwsgBkEFOgAACyAFQRBqJAAgAy0ACEEFRgRAIABBCTYCAEEEDAMLIAMpAwgiC0L/AYNCBFIEQCADIAs3AwggA0EYaiADQQhqEIErIAFBDGoQ3jsMAgsgA0EQaiABQRRqKAIANgIAIAMgASkCDDcDCCADQRhqQQRyIANBCGoQ5xUgA0EINgIYDAELIAQgAygCEEHc/8IAEP0vAAsgACADKQMYNwMAIABBEGogA0EoaikDADcDACAAQQhqIANBIGopAwA3AwBBAQs6AAggA0EwaiQAC/YGAQd/IwBBEGsiCyQAQf3/AyENQQEhBwJAIANFDQAgAiADaiIIIANJIAYgCElyDQAgBSACQQNsaiIFLwAAIAVBAmotAABBEHRyIgJBgIDEAEYNACAFQQNqIQcgA0EBayEJIAIhDQsgByAJQQNsaiEIAkAgBEUEQCALIAg2AgwgCyAHNgIIQQAhBiALQQhqENclIgdBgIDEAEYNASABQQRqIQUgAUHIAGohCEEBIQkDQCAHAn9B/x9B//8DIAEoAlwiAi0ALBsgB08EQCAHQQZ2IgMgAigCCEkEQCACKAIEIANBAXRqLwAAIAdBP3FqDAILIAIoAhRBAWsMAQsgAiAHEMAuCyIDIAIoAhQiB0kEfyACKAIQIANBAnRqKAAABSAECyACKAIAIAMgB0kbIgoQoy8hDAJ/IAgoAgAiAkESSQRAIAIhAyAIIQdBESECIAUMAQsgASgCBCEDIAUhByABKAIICyEEIAIgA0YEfyABEPwfIAEoAgghBCAFIQcgASgCBAUgAwtBAnQgBGogDDYCACAHIAcoAgBBAWo2AgAgBiAJIAoQ+zobIQYgCUEBaiEJIAtBCGoQ1yUiB0GAgMQARw0ACwwBCyMAQRBrIgokACAKQQhqIAEiAyAIIAdrQQNuEJ8YIAooAgggCigCDBCALSADQcgAaiEJQREhAgJ/IAMoAkgiBEERTQRAIANBBGohBiAJIQEgBAwBCyADQQRqIQEgAygCCCEGIAQhAiADKAIECyEEAkACQCABIAIgBEsEfyAGIARBAnRqIQUDQCAHIAhGDQIgBy8AACAHQQJqLQAAQRB0ciIGQYCAxABGDQIgBSAGQYCAgHhyNgIAIAVBBGohBSAHQQNqIQcgAiAEQQFqIgRHDQALIAIFIAQLNgIAIAcgCEYNASADQQRqIQIDQCAHLwAAIAdBAmotAABBEHRyIgxBgIDEAEYNAgJ/IAkoAgAiBkESSQRAIAYhBSACIQFBESEGIAkMAQsgAygCBCEFIAMoAgghASACCyEEIAUgBkYEQCADEPwfIAMoAgQhBSACIQQgAygCCCEBCyABIAVBAnRqIAxBgICAeHI2AgAgBCAEKAIAQQFqNgIAIAdBA2oiByAIRw0ACwwBCyABIAQ2AgALIApBEGokAEEAIQYLIAAgBjYCBCAAIA02AgAgC0EQaiQAC5YEAgd/AX4jAEEgayIHJAACQCADRQRADAELIAFBEGohCANAIAIgBWohCiADIAVrIQkCQAJAIAEoAjQiBA0AIAEoAjghBgJAAkACQAJAA0AgBkUEQCAIKAIARQ0CIAcgCBClGCAHKAIAQQFHDQkgBykDCCILUA0JIAtCAYNQRQRAIAEgC6dBAnRBeHE2AjgMCAsgASALQgGIPgI0IAdBEGogCCABLQA8IgRBA3YgBEEHcUEAR2oQwRwgBykDECELIAEgBykDGDcDCCABIAs3AwAgC6cNB0HA+swAQS5B8PrMABCfKQALIAgoAgBFDQIgBiAJIAYgCUkbIgQgBWoiBiAESQ0DIAMgBkkNBCAIIAogBCABLQA8EJwLIgRFBEBBACEGIAFBADYCOCABKAI0IgRFDQEMBgsLIAEgASgCOCAEazYCOCAEIAVqIQUMBQtBnPjMAEEYQbD6zAAQyyQAC0Gc+MwAQRhBtPjMABDLJAALIAUgBkHE+MwAELE7AAsgBiADQcT4zAAQsDsACyABKAIARQRAQdT4zAAQsjsACwJAIAQgCSAEIAlJGyIGIAVqIgQgBk8EQCADIARJDQEgCiAGIAEtAAgQ7S8gASABKAI0IAZrNgI0IAQhBQwCCyAFIARB5PjMABCxOwALIAQgA0Hk+MwAELA7AAsgAyAFSw0ACwsgAEEINgIAIAAgBTYCBCAHQSBqJAALlAkCCX8CfiMAQUBqIgQkAAJAAkACQCAAKAJYRQRAIAAoAkwhAgwBCyAAKQJQIQsgAEKAgICAEDcDUCAEQRBqIABB2ABqIgIoAgA2AgAgAkEANgIAIAQgCzcDCCAEQRhqIARBCGoQ8i8gBCAEKQIYNwI0IARBADYCMCAEIAQoAiQiAzYCLCAEIAQoAiA2AiggBCAEQShqENc7IAQoAgAhBkEcQQQQrTYiAkUNASACQoGAgIAQNwIAIAIgBCkCKDcCCCACQRBqIARBMGopAgA3AgAgAkEYaiAEQThqKAIANgIAIANBf0YNAiAAKAJMIgUgACgCREYEQCAAQcQAakGAhYQBEJAoCyAAKAJIIAVBDGxqIgcgAzYCCCAHIAY2AgQgByACNgIAIAAgBUEBaiICNgJMCyABKAIIIQcgBCACNgIYIAEoAgQhBSMAQRBrIgMkACAAQcQAaiIGIAUgB0EMbGoiCCAFa0EMbhD9LSADIAYpAgRCIIk3AgggAyAGQQhqNgIEIAUgCCADQQRqEN4ZIANBEGokACAAQThqIQMgASgCHCIFIAEoAiBBcHFqIQYCQCACRSAHRXJFBEAgBCAGNgIsIAQgBTYCKCAEIARBGGo2AjAjAEEQayICJAAgBEEoaiIFKAIEIAUoAgBrQQR2IgYgAygCACADKAIIIgdrSwRAIAMgByAGQRBBEBDeKCADKAIIIQcLIAIgAygCBDYCDCACIAc2AgggAiADQQhqNgIEIAJBBGoiBigCBCEHIAYoAgAgBSgCACIDIAUoAgQiCEcEQCAFKAIIIQogBigCCCAHQQR0aiEFIAcgCCADa0EEdiIIaiEHA0AgAykDCCILpyEGIAMpAwAiDKdBDU8EQCAKKAIAIAZqIQYLIAUgDDcDACAFIAatIAtCgICAgHCDhDcDCCADQRBqIQMgBUEQaiEFIAhBAWsiCA0ACwsgBzYCACACQRBqJAAMAQsgAyAFIAYQ6yMLIABB3ABqIQACQCABEJM2IgIEQCAAIAIQ4SYMAQsgARDSPCECIwBBEGsiASQAAkACQAJAIAAoAgAEQCAAKAIQIgVBB3EiB0UNAiABQQhqIAAQhj0gASgCDCIDRQ0BIAEoAgggA2pBAWsiA0UNASADIAMtAABBfyAHdHI6AAAMAgsgACAAKAIUIAJqNgIUDAILQZCGhAEQsjsACwJAIAIgBWoiBUEDdiAFQQdxIgdBAEdqIgMgACgCDCICTQ0AIAMgAmshBiAAKAIEIgggA0kEQCAAIAhBAXQiAiADQcD///8DcUFAayADIANBP3EbIgggAiAISxsQ6BkgACgCDCECCyAGRQ0AIAAoAgggAmpB/wEgBvwLAAsgACADNgIMIAcEQCABIAAQhj0CQCABKAIEIgIEQCABKAIAIAJqQQFrIgINAQtBoIaEARCyOwALIAIgAi0AAEF/IAd0QX9zcToAAAsgACAFNgIQCyABQRBqJAALIARBQGskAA8LQQRBHBCjPQALIARBADYCOCAEQQE2AiwgBEHohIQBNgIoIARCBDcCMCAEQShqQfCEhAEQ7ywAC+gEAgV/AX4jAEHwA2siBCQAIAQgAkHAA/wKAAAgASgCACIDIAMpAwAgBCkD2AJ8NwMAIAEoAgQiAyADKQMAIAQpA/ABfDcDACABKAIIIgMoAggiBSADKAIARgRAIANBhMLDABChKAsgAygCBCAFQcACbGogAkHAAvwKAAAgAyAFQQFqNgIIIAEoAgwiAygCCCIFIAMoAgBGBEAgA0GUwsMAEJAoCyADKAIEIAVBDGxqIgYgAikC6AI3AgAgBkEIaiACQfACaigCADYCACADIAVBAWo2AgggASgCECIDKAIIIgYgAygCAEYEQCMAQRBrIgUkACAFQQhqIAMgAygCAEEBQQRBzAAQtxEgBSgCCCIHQYGAgIB4RwRAIAcgBSgCDEGkwsMAEP0vAAsgBUEQaiQACyADKAIEIAZBzABsaiACQfQCakHMAPwKAAAgAyAGQQFqNgIIIAEoAhQiAygCCCIFIAMoAgBGBEAgA0G0wsMAEJEoCyADKAIEIAVBGGxqIgYgAikCwAI3AgAgBkEQaiACQdACaikCADcCAEEIIQcgBkEIaiACQcgCaikCADcCACADIAVBAWo2AggCQCABKAIYIgEoAgBBAUYEQCAEIAEpAwgiCDcDwAMgCCAEKQPgAlENASAEQQM2AswDIARB8MLDADYCyAMgBEICNwLUAyAEQTw2AuwDIAQgBEHgAmo2AugDIARBPDYC5AMgBCAEQeADajYC0AMgBCAEQcADajYC4AMgAEEEaiAEQcgDahCZDkEAIQcMAQsgASAEKQPgAjcDCCABQgE3AwALIAAgBzYCACAEQfADaiQAC9gIAQp/IwBBkAFrIgYkAAJAAkACQAJAAkACQAJAAkACQCABKAIAIgJBH3UgAkH/////B2txIgJBAWsOBAEBAQIACyAGIAFByAD8CgAAQcgAQQQQrTYiAUUNBiABIAZByAD8CgAAIABBATYCCCAAIAE2AgQgAEEBNgIADAcLIAZByABqIgQgASgCBCIDQcgA/AoAACAAIAQQygsgA0HIAEEEEPg6IAJBAmsOAgIDAQsgASgCDCEEIAEoAgghAiABKAIEIQMgBkEANgJoIAZBADYCWCAGIAM2AlAgBiACNgJMIAYgAjYCSCAGIAIgBEHIAGxqNgJUQQAhAiMAQZABayIEJAAgBEEUaiAGQcgAaiIDEIINAkACQAJAIAQoAhRBgICAgHhHBEAgAygCEARAIAMoAhwgAygCFGtByABuIQILIAMoAiAEfyADKAIsIAMoAiRrQcgAbgVBAAsgAmohBQJ/AkAgAygCAEUNACADKAIMIAMoAgRGDQAgBEHgAGohAkEADAELIARB3ABqIQIgBQshByACIAc2AgAgBEHgAGoiAkEDIAUgBUEDTRtBAWpBAEEEQcgAEKAYIAQoAmQhBSAEKAJgQQFGDQIgBCgCaCIHIARBFGpByAD8CgAAIARBEGoiCkEBNgIAIAQgBzYCDCAEIAU2AgggAiADQTD8CgAAIARBCGohBSMAQdAAayIDJAAgAyACEIINIAMoAgBBgICAgHhHBEADQCAFKAIIIgcgBSgCAEYEQEEAIQggAigCEARAIAIoAhwgAigCFGtByABuIQgLIAIoAiAEfyACKAIsIAIoAiRrQcgAbgVBAAsgCGohCAJ/AkAgAigCAEUNACACKAIMIAIoAgRGDQAgA0HMAGohCUEADAELIANByABqIQkgCAshCyAJIAs2AgAgBSAHIAhBAWpBBEHIABDQKAsgBSgCBCAHQcgAbGogA0HIAPwKAAAgBSAHQQFqNgIIIAMgAhCCDSADKAIAQYCAgIB4Rw0ACwsgAhDDKiADQdAAaiQAIABBCGogCigCADYCACAAIAQpAgg3AgAMAQsgAEEANgIIIABCgICAgMAANwIAIAMQwyoLIARBkAFqJAAMAQsgBSAEKAJoQZCyzQAQ/S8ACyABKAIUIgANAwwFCyABKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCABQQhqEPseCyABKAIYIgBFDQQgACAAKAIAIgBBAWs2AgAgAEEBRw0EIAFBGGoQ+x4MBAsgASgCCCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEIahD7HgsgASgCGCIARQ0DIAAgACgCACIAQQFrNgIAIABBAUcNAyABQRhqEPseDAMLIAEoAhAiAEUNAiAAIAAoAgAiAEEBazYCACAAQQFHDQIgAUEQahD7HgwCCyAAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEUahD7HgwBC0EEQcgAEKM9AAsgBkGQAWokAAvuAwILfwF+IAAoArwBIQcgACgCZCEMIAAoAsgBIQ0gACgCwAEhBCAAKAJcIQgCQCADQQFGBEAgAUEIayEJIAdBCGohCiAAKAIcIgFBCHQhBiAAKAIEIgsgAWohAUE4IARrrSEPA0AgAUECaiAJSw0CIAFBA2ogASALa0EIdCEOQQAhACAGIQMDQCAAQQNHBEAgACABaiIFKQAAQuPIlb3Lm++NT34gD4inIQQCQAJAIABFBEAgDCAFIAogDRCjHSIFQQZ2Qfz//x9xaiAFQf8BcSAOcjYCACAEQQh2IQUMAQsgCCAEQQh2IgVBAnRqKAIADQELIAggBUECdGogAyAEQf8BcWo2AgALIANBgAJqIQMgAEEBaiEAIAINAQsLIAZBgAZqIQYhAQwACwALIAFBCGshBSAAKAIEIgYgACgCHCIBaiEAQcAAIARrrSEPA0AgAEECaiAFSw0BIABBA2ogASAGaiEJIAAgBmshCkEAIQADQCAAQQNHBEAgACAJaiILKQAAQuPIlb3Lm++NT34gD4inIQQCQAJAIABFBEAgDCALIAcgDRCjHUECdGogCjYCAAwBCyAIIARBAnRqKAIADQELIAggBEECdGogACABajYCAAsgAEEBaiEAIAINAQsLIAFBA2ohASEADAALAAsLwAQCA38DfiMAQZABayIDJAAgASgCCCEEAkACQAJ+AkAgASgCDCgCECACQQR0aiIFKQMIIgggBSkDACIHQoCAgICAgICAgH99IAdUrXxQBEAgAyAEKAIAKAIAKQMAIgY3AyAgAyAHNwMYIAMgByAHQj+HIAYgBkI/hxCoHiADKQMIIAMpAwAiBkI/h1ENASADQQI2AnQgA0GskP8ANgJwIANCAjcCfCADQYYMNgJMIANBhgw2AkQgAyADQUBrNgJ4IAMgA0EgajYCSCADIANBGGo2AkAgA0EwaiADQfAAahCZDiADQeQAaiADQTRqKQIANwIAIANB7ABqIANBPGooAgA2AgAgA0GIgICAeDYCLCADIAMpAiw3AlwgA0EBNgJYIANB2ABqQQRyEIgRCyAEKAIEIQEgAyAINwNIIAMgBzcDQCADQcyR/wA2AlggA0IENwJkIANBhAw2AowBIANB9As2AoQBIAMgAUEBajYCgAEgA0G7BzYCfCADIAE2AnggA0HMATYCdCADQaCS/wA2AnAgAyADQfAAajYCYCADIANBQGs2AogBIANBBDYCXCADQTBqIANB2ABqEJkOIAMpAjghBkGCgICAeCEEIAMpAjAMAQsgA0HwAGogBiAEKAIILQAAEI0QIAMoAnAiBEGTgICAeEYNASADKQJ8IQYgAykCdAshByAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBjcDAAsgA0GQAWokAAv8AwIHfwJ+IwBB4ABrIgMkACADQRhqIgUgAhDnOkEAQQRBDBCgGCADKAIcIQQgAygCGEEBRwRAIANBADYCFCADIAMoAiA2AhAgAyAENgIMIAUgAhDINCABKAIUQQN2IQQgA0E4aiEHIAEoAhAhCAJAA0ACQCADKQNAIgtQRQRAIAMpA0ghCgwBCwNAAn4CQCADKQMoIgpCA1IEQAJAAkACQCAKQgJRDQAgAyAKUK1CAYY3AyggCqdBAXFFDQAgAyADKQMwNwNYDAELIAMoAjhFDQEgA0HQAGogBxC2KiADKQNQIQoLIApCAFINAgsgA0IDNwMoCyADKQMYIgpCAlENBSADQgA3AxggAykDIAwBCyADKQNYCyELIAqnQQFxRQ0DIAMgAykDSEJAfSIKNwNIIAMgCzcDQCALUA0ACwsgAyALQgEgC3oiC4aFNwNAIAEgC6cgCqdqIgIQizshCSACIARJBEAgAygCFCIFIAMoAgxGBEAgA0EMakH4tIMBEJAoCyADKAIQIAVBDGxqIgZBCDYCCCAGIAggAkEDdGpBACAJGzYCBCAGIAI2AgAgAyAFQQFqNgIUDAELCyACIARB6LSDARDDIQALIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgA0HgAGokAA8LIAQgAygCIEHYtIMBEP0vAAv8AwIHfwJ+IwBB4ABrIgMkACADQRhqIgUgAhDnOkEAQQRBDBCgGCADKAIcIQQgAygCGEEBRwRAIANBADYCFCADIAMoAiA2AhAgAyAENgIMIAUgAhDINCABKAIUQQJ2IQQgA0E4aiEHIAEoAhAhCAJAA0ACQCADKQNAIgtQRQRAIAMpA0ghCgwBCwNAAn4CQCADKQMoIgpCA1IEQAJAAkACQCAKQgJRDQAgAyAKUK1CAYY3AyggCqdBAXFFDQAgAyADKQMwNwNYDAELIAMoAjhFDQEgA0HQAGogBxC2KiADKQNQIQoLIApCAFINAgsgA0IDNwMoCyADKQMYIgpCAlENBSADQgA3AxggAykDIAwBCyADKQNYCyELIAqnQQFxRQ0DIAMgAykDSEJAfSIKNwNIIAMgCzcDQCALUA0ACwsgAyALQgEgC3oiC4aFNwNAIAEgC6cgCqdqIgIQizshCSACIARJBEAgAygCFCIFIAMoAgxGBEAgA0EMakH4tIMBEJAoCyADKAIQIAVBDGxqIgZBBDYCCCAGIAggAkECdGpBACAJGzYCBCAGIAI2AgAgAyAFQQFqNgIUDAELCyACIARB6LSDARDDIQALIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAgA0HgAGokAA8LIAQgAygCIEHYtIMBEP0vAAupBAEOfyMAQRBrIgMkACABKAIEIQwgAyABKAIIIglBAEEEQRAQoBggAygCBCEHIAMoAgBBAUcEQCADKAIIIQoCQCAHRQ0AIAlBBHQhDUEAIQEgByELA0AgASANRg0BAkACQAJAAkACQAJAAkBBAiABIAxqIgIoAgAiBUH/////B2ogBUGAgICAeE0bQQFrDgQBAgMEAAsgAkEIaigCACEEIAJBBGooAgAhBiACQQxqKAIAIQhBgYCAgHghBQwFCyACQQRqKAIAIQZBgoCAgHghBSACQQhqKAIAIgJFDQMQzC8hBCADIAIQ1xAgBEEIaiADQQhqKQIANwIAIAQgAykCADcCAAwECyACQQxqKAIAIQggBUGAgICAeEYEQCAOIQQgDyEGQYCAgIB4IQUMBAsgAyACEM8LIAMoAgAhBSADKAIEIg8hBiADKAIIIgQhDgwDCyACQQRqKAIAIQZBhICAgHghBSACQQhqKAIAIgJFDQEQzC8hBCADIAIQ1xAgBEEIaiADQQhqKQIANwIAIAQgAykCADcCAAwCCyACQQxqKAIAIQggAkEIaigCACEEIAJBBGooAgAhBgwBC0EAIQQLIAEgCmoiAiAFNgIAIAJBDGogCDYCACACQQhqIAQ2AgAgAkEEaiAGNgIAIAFBEGohASALQQFrIgsNAAsLIAAgCTYCCCAAIAo2AgQgACAHNgIAIANBEGokAA8LIAcgAygCCEHIiocBEP0vAAvDBAEJfyMAQbABayICJAAgAkHYAGogASgCDEEIahD0FSACKAJcIQcCQAJAAkAgAigCWCIDQYGAgIB4RwRAIAAgAigCYDYCDCAAIAc2AgggACADNgIEIABBgICAgHg2AgAMAQsgAkHYAGogASgCCCIDQQBBCEHAABCgGCACKAJcIQUgAigCWEEBRg0BIAJBADYCFCACIAIoAmA2AhAgAiAFNgIMIAMEQCABKAIEIQEgA0EUbCEFIAJBhAFqIQkgAkHkAGohCCACQfAAaiEKA0AgAUEMaigCACIDIAMoAgAiBEEBajYCACAEQQBIDQQgAkGcAWoiBCABELwVIAIgAzYCqAEgAiABQRBqKAIANgKsASACQRhqIgMgBBCfDiACQdgAaiIEIAMQ+D0gAyAEEI0EIAIoAhQiBCACKAIMRgRAIwBBEGsiAyQAIANBCGogAkEMaiIGIAYoAgBBAUEIQcAAELESIAMoAggiBkGBgICAeEcEQCAGIAMoAgxB/MPMABD9LwALIANBEGokAAsgAigCECAEQQZ0aiACQRhqQcAA/AoAACACIARBAWo2AhQgChCSDCACQdgAaiIDEMUnIAMQ6DsgCBCkLCAIEPU8AkAgAigChAEiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgCRD7HgsgAUEUaiEBIAVBFGsiBQ0ACwsgACACKQIMNwIAIAAgBzYCDCAAQQhqIAJBFGooAgA2AgALIAJBsAFqJAAPCyAFIAIoAmBB7MPMABD9LwsAC6wFAgd/AX4jAEHwAGsiAyQAIANBgQE2AlACQAJAAkAgACADQdAAahCiNkUEQEECIAAoAgAlARBxIgRBAEcgBEH///8HRhtB/wFxIghBAkYNAQwCCyADQQc6AFAgA0HQAGogASACENciIQAMAgsjAEEQayIEJAAgBCAAKAIAJQEQcCADQShqIgUgBCgCAAR+IAUgBCsDCDkDCEIBBUIACzcDACAEQRBqJAAgAygCKEUEQCADQThqIAAQkh8CfyADKAI4QYCAgIB4RwRAIANBEGogA0FAaygCACIENgIAIAMgAykCODcDCEEFIQVBASEGIAMoAgwMAQsgA0HEAGohBSMAQRBrIgQkAAJAIAAoAgAlARBbBEAgBEEEaiAAEI8hIAVBCGogBEEMaigCADYCACAFIAQpAgQ3AgAMAQsgACgCACUBEEUEQCAEIAAQlD0iBjYCACAEQQRqIAQQjyEgBUEIaiAEQQxqKAIANgIAIAUgBCkCBDcCACAGQYQBSQ0BIAYQ8h8MAQsgBUGAgICAeDYCAAsgBEEQaiQAAn8gAygCRCIGQYCAgIB4RyIJRQRAIANBEGohBCADQQxqIQcgA0EBNgJUIANBiNLMADYCUCADQgE3AlwgA0HaADYCbCADIAA2AmggAyADQegAajYCWCADQQhqIANB0ABqEJkOQREMAQsgA0EgaiIAIQQgA0EcaiEHIAAgA0HMAGooAgA2AgAgAyADKQJENwMYQQYLIQUgBkGAgICAeEYhBiAEKAIAIQQgBygCAAshACAErSEKDAELQQMhBSADKQMwIQoLIAMgCjcDWCADIAA2AlQgAyAIOgBRIAMgBToAUCADQdAAaiABIAIQ1yIhACAJBEAgA0EYahDeOwsgBkUNACADQQhqEN47CyADQfAAaiQAIAAL3gMCA34FfyMAQSBrIgckAAJAIAJQIAFCqn1Tcg0AQf8PIQggAUK0AlUNACAHQRBqIAGnIgZBBHQiCUHQw4EBaikDAEIAIAIgAnkiA4YiBUIAEKgeIAcpAxAhBCAHKQMYIgJC/wODQv8DUQRAIAcgCUHYw4EBaikDAEIAIAVCABCoHiACIAcpAwgiAiAEfCIEIAJUrXwhAgsgA6chCSACQj+IIgOnIQogBEJ/USABQht8QtIAVnFFBEAgAiADQgl8IgWIIQMCQAJAIAZB6qQNbEEQdSAJayAKakE/aiIGQYJ4TgRAQYAIQf8HIANC/P////////8AgyADIAMgBYYgAlEbIAMgA0IDg0IBURsgAyABQgR8QhxUGyADIARCAlQbIgFCAYMgAXwiAUL/////////H1YiCRsgBmoiBkH+D00NAUIAIQQMBAsgBkHDd08NAUIAIQRBACEIDAMLQgAgAUIBiEL/////////9/8AgyAJGyEEIAYhCAwCCyADQQIgBmtBP3GtiCIBQgGDIAF8IgFC/////////w9WIQggAUIBiCEEDAELIAZB6qQNbEEQdSAKRSIGIAlqa0HM9wFrIQggAiAGrYYhBAsgACAINgIIIAAgBDcDACAHQSBqJAAL8AMBA34gACgCACgCACIAKQMIIgMgASgCACACQQJ0a0EEazUCAIUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAAKQMAIgRCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgAyAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoUgA4kL2AMCBX8BfiMAQfAOayIHJAAgAEEBayIKrSAEIAUgBhCVIwJAAkACQCAAQQFLBEAgB0EEakEAQbwI/AsAIAdBwAhqQQBBkAL8CwAgB0HQCmpBAEGgBPwLAEEBQgEgBCAFIAYQ5RJBBCABQQJrrSAEIAUgBhDlEiABQQFrIghBjwJLDQEgByAIQQJ0aiAANgIAIAdBATYCACAAIAhqIgsgAUsEQCABQZACayEJIAcgAUECdGohAQNAIAlFDQUgAUEBNgIAIAlBAWohCSABQQRqIQEgCkEBayIKDQALCyAHQZACIAsgCyACIAMgB0HACGoiAUGQAiAHQdAKaiICQZACIAQgBSAGEPIIIAhBAXQgAmohAkF/IAh0QX9zrSEMIAEgCGohA0EAIQkDQEEAIQEgCQRAIAggCWoiAUGQAk8NBAsgB0HACGogAWotAAAgB0HQCmogAUEBdGozAQAgBCAFIAYQ5RIgAy0AACACMwEAIAQgBSAGEOUSIAggDCAEIAUgBhDlEiAAIAlBAWoiCUcNAAtBAUIBIAQgBSAGEOUSCyAHQfAOaiQADwsgCEGQAkGc6tEAEMMhAAsgCCAJakGQAkGs6tEAEMMhAAtBkAJBkAJBvOrRABDDIQALuwQCBH8CfiMAQUBqIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AIEEBaw4DAwACAQsACyAAKQMAIgZCgICAgAhaDQQgACkDCCIHQoCAgIAIWg0FIAJBCGogAEEUaiAGpyAHpxCBJCACKAIMIQMgAigCCEEBcQ0GIAAgAzYCGCAAIABBGGoQkT0Q+w42AhwLIAIgAEEcaiIDIAEQxxggAigCACIBQQJHDQFBAyEDDAILQbz1wgAQ6CsACyACKAIEIQQgAygCACIFIAUoAgBBAWsiBTYCACAFRQRAIAMQshoLIAFBAXENBCACIAQ2AhQgAiACQRRqEKg7IgM2AjAgAkEYaiACQTBqEI8hIANBhAFPBEAgAxDyHwsgAkEkaiAAKAIQIAJBGGoQxSYgAigCJEGAgICAeEcNBSACKAIUIgNBhAFPBEAgAxDyHwsgACgCGCIDQYQBTwRAIAMQ8h8LQQEhAyAAKAIUIgRBhAFJDQAgBBDyHwsgACADOgAgIAJBQGskACABQQJGDwtBnODCAEErIAJBMGpB/N/CAEGM9cIAENUeAAtBnODCAEErIAJBMGpB/N/CAEGc9cIAENUeAAsgAiADNgIwQZzgwgBBKyACQTBqQdjgwgBBrPXCABDVHgALIAIgBDYCMEGc4MIAQSsgAkEwakHY4MIAQcz1wgAQ1R4ACyACQThqIAJBLGooAgA2AgAgAiACKQIkNwMwQZzgwgBBKyACQTBqQYjhwgBB3PXCABDVHgALuwQCBH8CfiMAQUBqIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AIEEBaw4DAwACAQsACyAAKQMAIgZCgICAgAhaDQQgACkDCCIHQoCAgIAIWg0FIAJBCGogAEEUaiAGpyAHpxCBJCACKAIMIQMgAigCCEEBcQ0GIAAgAzYCGCAAIABBGGoQkT0Q+w42AhwLIAIgAEEcaiIDIAEQxxggAigCACIBQQJHDQFBAyEDDAILQby5wwAQ6CsACyACKAIEIQQgAygCACIFIAUoAgBBAWsiBTYCACAFRQRAIAMQshoLIAFBAXENBCACIAQ2AhQgAiACQRRqEKg7IgM2AjAgAkEYaiACQTBqEI8hIANBhAFPBEAgAxDyHwsgAkEkaiAAKAIQIAJBGGoQxSYgAigCJEGAgICAeEcNBSACKAIUIgNBhAFPBEAgAxDyHwsgACgCGCIDQYQBTwRAIAMQ8h8LQQEhAyAAKAIUIgRBhAFJDQAgBBDyHwsgACADOgAgIAJBQGskACABQQJGDwtB4KbDAEErIAJBMGpBvKfDAEGMucMAENUeAAtB4KbDAEErIAJBMGpBvKfDAEGcucMAENUeAAsgAiADNgIwQeCmwwBBKyACQTBqQZynwwBBrLnDABDVHgALIAIgBDYCMEHgpsMAQSsgAkEwakGcp8MAQcy5wwAQ1R4ACyACQThqIAJBLGooAgA2AgAgAiACKQIkNwMwQeCmwwBBKyACQTBqQcynwwBB3LnDABDVHgAL8QMCCH4EfyMAQTBrIgskAEKAgICAgICAgIB/IQUCQAJAAn4CQAJAIAAoAgQoAhAgAUEEdGoiCikDACIHIAopAwgiCEKAgICAgICAgIB/hYRCAFIgACgCACINKAIAIgooAgAiDCkDCCICIAwpAwAiA4NCf1JyRQRAQgAhAgwBCyACIAOEUA0DIAtBIGogByAIIAMgAhCDGSALQRBqIAspAyAiBCALKQMoIgUgAyACEKgeQgAgByALKQMQIgl9IAIgA4NCf1EiDBshBkIAIAggCykDGH0gByAJVK19IAwbIQIgCEIAWQ0BCyAEIAYgCigCCCIKKQMAWCACIAopAwgiA1cgAiADURutIgN9IQIgBSADIARWrX0MAQsgBSAEIAYgCigCBCIKKQMAWiACIAopAwgiA1kgAiADURutfCICIARUrXwLIQQCQAJAIAQgAkKAgICAgICAgIB/fSACVK18UEUNACACIA0oAgQtAAAQxSlFDQAgACgCCCABQQN0aiACNwMADAELIAAoAhAiCiAKKAIAQQFqNgIAIAtBCGogACgCFBCGPSABQQN2IgAgCygCDCIKTw0CIAsoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyALQTBqJAAPC0HMj/8AEOIrAAsgACAKQYiL/wAQwyEAC+ebAQEGfyMAQTBrIggkACAIIAM2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAw4hAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gIQsgAkEAQYAB/AsADCELIAFBA00EQAwiCyACIAAoAAAiAEEfdjYCfCACIABBAXE2AgAgAiAAQR52QQFxNgJ4IAIgAEEddkEBcTYCdCACIABBHHZBAXE2AnAgAiAAQRt2QQFxNgJsIAIgAEEadkEBcTYCaCACIABBGXZBAXE2AmQgAiAAQRh2QQFxNgJgIAIgAEEXdkEBcTYCXCACIABBFnZBAXE2AlggAiAAQRV2QQFxNgJUIAIgAEEUdkEBcTYCUCACIABBE3ZBAXE2AkwgAiAAQRJ2QQFxNgJIIAIgAEERdkEBcTYCRCACIABBEHZBAXE2AkAgAiAAQQ92QQFxNgI8IAIgAEEOdkEBcTYCOCACIABBDXZBAXE2AjQgAiAAQQx2QQFxNgIwIAIgAEELdkEBcTYCLCACIABBCnZBAXE2AiggAiAAQQl2QQFxNgIkIAIgAEEIdkEBcTYCICACIABBB3ZBAXE2AhwgAiAAQQZ2QQFxNgIYIAIgAEEFdkEBcTYCFCACIABBBHZBAXE2AhAgAiAAQQN2QQFxNgIMIAIgAEECdkEBcTYCCCACIABBAXZBAXE2AgQMIAsgAUEHTQRADCELIAIgACgAACIBQR52NgI8IAIgAUEDcTYCACACIAAoAAQiAEEedjYCfCACIABBA3E2AkAgAiABQRx2QQNxNgI4IAIgAUEadkEDcTYCNCACIAFBGHZBA3E2AjAgAiABQRZ2QQNxNgIsIAIgAUEUdkEDcTYCKCACIAFBEnZBA3E2AiQgAiABQRB2QQNxNgIgIAIgAUEOdkEDcTYCHCACIAFBDHZBA3E2AhggAiABQQp2QQNxNgIUIAIgAUEIdkEDcTYCECACIAFBBnZBA3E2AgwgAiABQQR2QQNxNgIIIAIgAUECdkEDcTYCBCACIABBHHZBA3E2AnggAiAAQRp2QQNxNgJ0IAIgAEEYdkEDcTYCcCACIABBFnZBA3E2AmwgAiAAQRR2QQNxNgJoIAIgAEESdkEDcTYCZCACIABBEHZBA3E2AmAgAiAAQQ52QQNxNgJcIAIgAEEMdkEDcTYCWCACIABBCnZBA3E2AlQgAiAAQQh2QQNxNgJQIAIgAEEGdkEDcTYCTCACIABBBHZBA3E2AkggAiAAQQJ2QQNxNgJEDB8LIAFBC00EQAwgCyACIAAoAAAiA0EHcTYCACACIANBG3ZBB3E2AiQgAiADQRh2QQdxNgIgIAIgA0EVdkEHcTYCHCACIANBEnZBB3E2AhggAiADQQ92QQdxNgIUIAIgA0EMdkEHcTYCECACIANBCXZBB3E2AgwgAiADQQZ2QQdxNgIIIAIgA0EDdkEHcTYCBCACIAAoAAQiAUEcdkEHcTYCUCACIAFBGXZBB3E2AkwgAiABQRZ2QQdxNgJIIAIgAUETdkEHcTYCRCACIAFBEHZBB3E2AkAgAiABQQ12QQdxNgI8IAIgAUEKdkEHcTYCOCACIAFBB3ZBB3E2AjQgAiABQQR2QQdxNgIwIAIgAUEBdkEHcTYCLCACIAFBAnRBBHEgA0EednI2AiggAiAAKAAIIgBBHXY2AnwgAiAAQRp2QQdxNgJ4IAIgAEEXdkEHcTYCdCACIABBFHZBB3E2AnAgAiAAQRF2QQdxNgJsIAIgAEEOdkEHcTYCaCACIABBC3ZBB3E2AmQgAiAAQQh2QQdxNgJgIAIgAEEFdkEHcTYCXCACIABBAnZBB3E2AlggAiAAQQF0QQZxIAFBH3ZyNgJUDB4LIAFBD00EQAwfCyACIAAoAAAiAUEcdjYCHCACIAFBD3E2AgAgAiAAKAAEIgNBHHY2AjwgAiADQQ9xNgIgIAIgAUEYdkEPcTYCGCACIAFBFHZBD3E2AhQgAiABQRB2QQ9xNgIQIAIgAUEMdkEPcTYCDCACIAFBCHZBD3E2AgggAiABQQR2QQ9xNgIEIAIgA0EYdkEPcTYCOCACIANBFHZBD3E2AjQgAiADQRB2QQ9xNgIwIAIgA0EMdkEPcTYCLCACIANBCHZBD3E2AiggAiADQQR2QQ9xNgIkIAIgACgACCIBQRx2NgJcIAIgAUEYdkEPcTYCWCACIAFBFHZBD3E2AlQgAiABQRB2QQ9xNgJQIAIgAUEMdkEPcTYCTCACIAFBCHZBD3E2AkggAiABQQR2QQ9xNgJEIAIgAUEPcTYCQCACIAAoAAwiAEEcdjYCfCACIABBD3E2AmAgAiAAQRh2QQ9xNgJ4IAIgAEEUdkEPcTYCdCACIABBEHZBD3E2AnAgAiAAQQx2QQ9xNgJsIAIgAEEIdkEPcTYCaCACIABBBHZBD3E2AmQMHQsgAUETTQRADB4LIAIgACgAACIDQR9xNgIAIAIgA0EZdkEfcTYCFCACIANBFHZBH3E2AhAgAiADQQ92QR9xNgIMIAIgA0EKdkEfcTYCCCACIANBBXZBH3E2AgQgAiAAKAAEIgRBF3ZBH3E2AiwgAiAEQRJ2QR9xNgIoIAIgBEENdkEfcTYCJCACIARBCHZBH3E2AiAgAiAEQQN2QR9xNgIcIAIgACgACCIBQRp2QR9xNgJIIAIgAUEVdkEfcTYCRCACIAFBEHZBH3E2AkAgAiABQQt2QR9xNgI8IAIgAUEGdkEfcTYCOCACIAFBAXZBH3E2AjQgAiAEQQJ0QRxxIANBHnZyNgIYIAIgAUEEdEEQcSAEQRx2cjYCMCACIAAoABAiA0EbdjYCfCACIAAoAAwiAEEYdkEfcTYCYCACIABBE3ZBH3E2AlwgAiAAQQ52QR9xNgJYIAIgAEEJdkEfcTYCVCACIABBBHZBH3E2AlAgAiADQRZ2QR9xNgJ4IAIgA0ERdkEfcTYCdCACIANBDHZBH3E2AnAgAiADQQd2QR9xNgJsIAIgA0ECdkEfcTYCaCACIABBAXRBHnEgAUEfdnI2AkwgAiADQQN0QRhxIABBHXZyNgJkDBwLIAFBF00EQAwdCyACIAAoAAAiAUE/cTYCACACIAAoAAgiA0EadjYCPCACIAFBGHZBP3E2AhAgAiABQRJ2QT9xNgIMIAIgAUEMdkE/cTYCCCACIAFBBnZBP3E2AgQgAiAAKAAEIgRBFnZBP3E2AiQgAiAEQRB2QT9xNgIgIAIgBEEKdkE/cTYCHCACIARBBHZBP3E2AhggAiADQRR2QT9xNgI4IAIgA0EOdkE/cTYCNCACIANBCHZBP3E2AjAgAiADQQJ2QT9xNgIsIAIgBEECdEE8cSABQR52cjYCFCACIANBBHRBMHEgBEEcdnI2AiggAiAAKAAMIgFBP3E2AkAgAiAAKAAUIgNBGnY2AnwgAiABQRh2QT9xNgJQIAIgAUESdkE/cTYCTCACIAFBDHZBP3E2AkggAiABQQZ2QT9xNgJEIAIgACgAECIAQRZ2QT9xNgJkIAIgAEEQdkE/cTYCYCACIABBCnZBP3E2AlwgAiAAQQR2QT9xNgJYIAIgA0EUdkE/cTYCeCACIANBDnZBP3E2AnQgAiADQQh2QT9xNgJwIAIgA0ECdkE/cTYCbCACIABBAnRBPHEgAUEednI2AlQgAiADQQR0QTBxIABBHHZyNgJoDBsLIAFBG00EQAwcCyACIAAoAAAiBEH/AHE2AgAgAiAEQRV2Qf8AcTYCDCACIARBDnZB/wBxNgIIIAIgBEEHdkH/AHE2AgQgAiAAKAAEIgFBGHZB/wBxNgIgIAIgAUERdkH/AHE2AhwgAiABQQp2Qf8AcTYCGCACIAFBA3ZB/wBxNgIUIAIgACgACCIFQRR2Qf8AcTYCMCACIAVBDXZB/wBxNgIsIAIgBUEGdkH/AHE2AiggAiAAKAAMIgNBF3ZB/wBxNgJEIAIgA0EQdkH/AHE2AkAgAiADQQl2Qf8AcTYCPCACIANBAnZB/wBxNgI4IAIgAUEEdEHwAHEgBEEcdnI2AhAgAiAFQQF0Qf4AcSABQR92cjYCJCACIANBBXRB4ABxIAVBG3ZyNgI0IAIgACgAGCIBQRl2NgJ8IAIgACgAECIEQRN2Qf8AcTYCVCACIARBDHZB/wBxNgJQIAIgBEEFdkH/AHE2AkwgAiAAKAAUIgBBFnZB/wBxNgJoIAIgAEEPdkH/AHE2AmQgAiAAQQh2Qf8AcTYCYCACIABBAXZB/wBxNgJcIAIgAUESdkH/AHE2AnggAiABQQt2Qf8AcTYCdCACIAFBBHZB/wBxNgJwIAIgBEECdEH8AHEgA0EednI2AkggAiAAQQZ0QcAAcSAEQRp2cjYCWCACIAFBA3RB+ABxIABBHXZyNgJsDBoLIAFBH00EQAwbCyACIAAoAAAiAUEYdjYCDCACIAFB/wFxNgIAIAIgACgABCIDQRh2NgIcIAIgA0H/AXE2AhAgAiAAKAAIIgRBGHY2AiwgAiAEQf8BcTYCICACIAAoAAwiBUEYdjYCPCACIAVB/wFxNgIwIAIgAUEQdkH/AXE2AgggAiABQQh2Qf8BcTYCBCACIANBEHZB/wFxNgIYIAIgA0EIdkH/AXE2AhQgAiAEQRB2Qf8BcTYCKCACIARBCHZB/wFxNgIkIAIgBUEQdkH/AXE2AjggAiAFQQh2Qf8BcTYCNCACIAAoABAiAUEYdjYCTCACIAFB/wFxNgJAIAIgACgAFCIDQRh2NgJcIAIgA0H/AXE2AlAgAiAAKAAYIgRBGHY2AmwgAiAEQf8BcTYCYCACIAAoABwiAEEYdjYCfCACIABB/wFxNgJwIAIgAUEQdkH/AXE2AkggAiABQQh2Qf8BcTYCRCACIANBEHZB/wFxNgJYIAIgA0EIdkH/AXE2AlQgAiAEQRB2Qf8BcTYCaCACIARBCHZB/wFxNgJkIAIgAEEQdkH/AXE2AnggAiAAQQh2Qf8BcTYCdAwZCyABQSNNBEAMGgsgAiAAKAAAIgRB/wNxNgIAIAIgBEESdkH/A3E2AgggAiAEQQl2Qf8DcTYCBCACIAAoAAQiAUEWdkH/A3E2AhggAiABQQ12Qf8DcTYCFCACIAFBBHZB/wNxNgIQIAIgACgACCIFQRF2Qf8DcTYCJCACIAVBCHZB/wNxNgIgIAIgACgADCIDQRV2Qf8DcTYCNCACIANBDHZB/wNxNgIwIAIgA0EDdkH/A3E2AiwgAiABQQV0QeADcSAEQRt2cjYCDCACIAVBAXRB/gNxIAFBH3ZyNgIcIAIgA0EGdEHAA3EgBUEadnI2AiggAiAAKAAQIgRBEHZB/wNxNgJAIAIgBEEHdkH/A3E2AjwgAiAEQQJ0QfwDcSADQR52cjYCOCACIAAoABQiAUEUdkH/A3E2AlAgAiABQQt2Qf8DcTYCTCACIAFBAnZB/wNxNgJIIAIgACgAGCIFQQ92Qf8DcTYCXCACIAVBBnZB/wNxNgJYIAIgACgAHCIDQRN2Qf8DcTYCbCACIANBCnZB/wNxNgJoIAIgA0EBdkH/A3E2AmQgAiABQQd0QYADcSAEQRl2cjYCRCACIAVBA3RB+ANxIAFBHXZyNgJUIAIgA0EIdEGAAnEgBUEYdnI2AmAgAiAAKAAgIgBBF3Y2AnwgAiAAQQ52Qf8DcTYCeCACIABBBXZB/wNxNgJ0IAIgAEEEdEHwA3EgA0EcdnI2AnAMGAsgAUEnTQRADBkLIAIgACgAACIBQf8HcTYCACACIAAoABAiA0EWdjYCPCACIAFBFHZB/wdxNgIIIAIgAUEKdkH/B3E2AgQgAiAAKAAEIgRBEnZB/wdxNgIUIAIgBEEIdkH/B3E2AhAgAiAAKAAIIgVBEHZB/wdxNgIgIAIgBUEGdkH/B3E2AhwgAiAAKAAMIgZBDnZB/wdxNgIsIAIgBkEEdkH/B3E2AiggAiADQQx2Qf8HcTYCOCACIANBAnZB/wdxNgI0IAIgBEECdEH8B3EgAUEednI2AgwgAiAFQQR0QfAHcSAEQRx2cjYCGCACIAZBBnRBwAdxIAVBGnZyNgIkIAIgA0EIdEGABnEgBkEYdnI2AjAgAiAAKAAUIgFB/wdxNgJAIAIgACgAJCIDQRZ2NgJ8IAIgAUEUdkH/B3E2AkggAiABQQp2Qf8HcTYCRCACIAAoABgiBEESdkH/B3E2AlQgAiAEQQh2Qf8HcTYCUCACIAAoABwiBUEQdkH/B3E2AmAgAiAFQQZ2Qf8HcTYCXCACIAAoACAiAEEOdkH/B3E2AmwgAiAAQQR2Qf8HcTYCaCACIANBDHZB/wdxNgJ4IAIgA0ECdkH/B3E2AnQgAiAEQQJ0QfwHcSABQR52cjYCTCACIAVBBHRB8AdxIARBHHZyNgJYIAIgAEEGdEHAB3EgBUEadnI2AmQgAiADQQh0QYAGcSAAQRh2cjYCcAwXCyABQStNBEAMGAsgAiAAKAAAIgZB/w9xNgIAIAIgBkELdkH/D3E2AgQgAiAAKAAEIgFBDHZB/w9xNgIQIAIgAUEBdkH/D3E2AgwgAiAAKAAIIgNBDXZB/w9xNgIcIAIgA0ECdkH/D3E2AhggAiAAKAAMIgRBDnZB/w9xNgIoIAIgBEEDdkH/D3E2AiQgAiAAKAAQIgVBD3ZB/w9xNgI0IAIgBUEEdkH/D3E2AjAgAiABQQp0QYAIcSAGQRZ2cjYCCCACIANBCXRBgAxxIAFBF3ZyNgIUIAIgBEEIdEGADnEgA0EYdnI2AiAgAiAFQQd0QYAPcSAEQRl2cjYCLCACIAAoABQiAUEQdkH/D3E2AkAgAiABQQV2Qf8PcTYCPCACIAAoABgiA0ERdkH/D3E2AkwgAiADQQZ2Qf8PcTYCSCACIAAoABwiBEESdkH/D3E2AlggAiAEQQd2Qf8PcTYCVCACIAAoACAiBkETdkH/D3E2AmQgAiAGQQh2Qf8PcTYCYCACIAAoACQiB0EUdkH/D3E2AnAgAiAHQQl2Qf8PcTYCbCACIAFBBnRBwA9xIAVBGnZyNgI4IAIgA0EFdEHgD3EgAUEbdnI2AkQgAiAEQQR0QfAPcSADQRx2cjYCUCACIAZBA3RB+A9xIARBHXZyNgJcIAIgB0ECdEH8D3EgBkEednI2AmggAiAAKAAoIgBBFXY2AnwgAiAAQQp2Qf8PcTYCeCACIABBAXRB/g9xIAdBH3ZyNgJ0DBYLIAFBL00EQAwXCyACIAAoAAAiBEH/H3E2AgAgAiAAKAAIIgVBFHY2AhwgAiAAKAAMIgZB/x9xNgIgIAIgBEEMdkH/H3E2AgQgAiAAKAAEIgFBEHZB/x9xNgIQIAIgAUEEdkH/H3E2AgwgAiAFQQh2Qf8fcTYCGCACIAZBDHZB/x9xNgIkIAIgACgAECIDQRB2Qf8fcTYCMCACIANBBHZB/x9xNgIsIAIgAUEIdEGAHnEgBEEYdnI2AgggAiAFQQR0QfAfcSABQRx2cjYCFCACIANBCHRBgB5xIAZBGHZyNgIoIAIgACgAFCIBQRR2NgI8IAIgAUEIdkH/H3E2AjggAiABQQR0QfAfcSADQRx2cjYCNCACIAAoABgiA0H/H3E2AkAgAiAAKAAgIgRBFHY2AlwgAiAAKAAkIgVB/x9xNgJgIAIgA0EMdkH/H3E2AkQgAiAAKAAcIgFBEHZB/x9xNgJQIAIgAUEEdkH/H3E2AkwgAiAEQQh2Qf8fcTYCWCACIAVBDHZB/x9xNgJkIAIgAUEIdEGAHnEgA0EYdnI2AkggAiAEQQR0QfAfcSABQRx2cjYCVCACIAAoACgiAUEQdkH/H3E2AnAgAiABQQR2Qf8fcTYCbCACIAFBCHRBgB5xIAVBGHZyNgJoIAIgACgALCIAQRR2NgJ8IAIgAEEIdkH/H3E2AnggAiAAQQR0QfAfcSABQRx2cjYCdAwVCyABQTNNBEAMFgsgAiAAKAAAIgRB/z9xNgIAIAIgBEENdkH/P3E2AgQgAiAAKAAEIgVBB3ZB/z9xNgIMIAIgACgACCIBQQ52Qf8/cTYCGCACIAFBAXZB/z9xNgIUIAIgACgADCIGQQh2Qf8/cTYCICACIAAoABAiA0EPdkH/P3E2AiwgAiADQQJ2Qf8/cTYCKCACIAAoABQiB0EJdkH/P3E2AjQgAiAFQQZ0QcA/cSAEQRp2cjYCCCACIAFBDHRBgCBxIAVBFHZyNgIQIAIgBkEFdEHgP3EgAUEbdnI2AhwgAiADQQt0QYAwcSAGQRV2cjYCJCACIAdBBHRB8D9xIANBHHZyNgIwIAIgACgAGCIBQRB2Qf8/cTYCQCACIAFBA3ZB/z9xNgI8IAIgACgAHCIFQQp2Qf8/cTYCSCACIAAoACAiA0ERdkH/P3E2AlQgAiADQQR2Qf8/cTYCUCACIAAoACQiBkELdkH/P3E2AlwgAiAAKAAoIgRBEnZB/z9xNgJoIAIgBEEFdkH/P3E2AmQgAiABQQp0QYA4cSAHQRZ2cjYCOCACIAVBA3RB+D9xIAFBHXZyNgJEIAIgA0EJdEGAPHEgBUEXdnI2AkwgAiAGQQJ0Qfw/cSADQR52cjYCWCACIARBCHRBgD5xIAZBGHZyNgJgIAIgACgALCIBQQx2Qf8/cTYCcCACIAFBAXRB/j9xIARBH3ZyNgJsIAIgACgAMCIAQRN2NgJ8IAIgAEEGdkH/P3E2AnggAiAAQQd0QYA/cSABQRl2cjYCdAwUCyABQTdNBEAMFQsgAiAAKAAAIgNB//8AcTYCACACIANBDnZB//8AcTYCBCACIAAoAAQiBEEKdkH//wBxNgIMIAIgACgACCIFQQZ2Qf//AHE2AhQgAiAAKAAMIgFBEHZB//8AcTYCICACIAFBAnZB//8AcTYCHCACIAAoABAiBkEMdkH//wBxNgIoIAIgACgAFCIHQQh2Qf//AHE2AjAgAiAEQQR0QfD/AHEgA0EcdnI2AgggAiAFQQh0QYD+AHEgBEEYdnI2AhAgAiABQQx0QYDgAHEgBUEUdnI2AhggAiAGQQJ0Qfz/AHEgAUEednI2AiQgAiAHQQZ0QcD/AHEgBkEadnI2AiwgAiAAKAAYIgNBEnY2AjwgAiAAKAAcIgRB//8AcTYCQCACIANBBHZB//8AcTYCOCACIARBDnZB//8AcTYCRCACIAAoACAiBUEKdkH//wBxNgJMIAIgACgAJCIGQQZ2Qf//AHE2AlQgAiAAKAAoIgFBEHZB//8AcTYCYCACIAFBAnZB//8AcTYCXCACIANBCnRBgPgAcSAHQRZ2cjYCNCACIAVBBHRB8P8AcSAEQRx2cjYCSCACIAZBCHRBgP4AcSAFQRh2cjYCUCACIAFBDHRBgOAAcSAGQRR2cjYCWCACIAAoACwiA0EMdkH//wBxNgJoIAIgA0ECdEH8/wBxIAFBHnZyNgJkIAIgACgAMCIBQQh2Qf//AHE2AnAgAiABQQZ0QcD/AHEgA0EadnI2AmwgAiAAKAA0IgBBEnY2AnwgAiAAQQR2Qf//AHE2AnggAiAAQQp0QYD4AHEgAUEWdnI2AnQMEwsgAUE7TQRADBQLIAIgACgAACIBQf//AXE2AgAgAiABQQ92Qf//AXE2AgQgAiAAKAAEIgNBDXZB//8BcTYCDCACIAAoAAgiBEELdkH//wFxNgIUIAIgACgADCIFQQl2Qf//AXE2AhwgAiAAKAAQIgZBB3ZB//8BcTYCJCACIAAoABQiB0EFdkH//wFxNgIsIAIgA0ECdEH8/wFxIAFBHnZyNgIIIAIgBEEEdEHw/wFxIANBHHZyNgIQIAIgBUEGdEHA/wFxIARBGnZyNgIYIAIgBkEIdEGA/gFxIAVBGHZyNgIgIAIgB0EKdEGA+AFxIAZBFnZyNgIoIAIgACgAGCIDQQN2Qf//AXE2AjQgAiADQQx0QYDgAXEgB0EUdnI2AjAgAiAAKAAcIgFBEHZB//8BcTYCQCACIAFBAXZB//8BcTYCPCACIAAoACAiBEEOdkH//wFxNgJIIAIgACgAJCIFQQx2Qf//AXE2AlAgAiAAKAAoIgZBCnZB//8BcTYCWCACIAAoACwiB0EIdkH//wFxNgJgIAIgAUEOdEGAgAFxIANBEnZyNgI4IAIgBEEBdEH+/wFxIAFBH3ZyNgJEIAIgBUEDdEH4/wFxIARBHXZyNgJMIAIgBkEFdEHg/wFxIAVBG3ZyNgJUIAIgB0EHdEGA/wFxIAZBGXZyNgJcIAIgACgAMCIBQQZ2Qf//AXE2AmggAiABQQl0QYD8AXEgB0EXdnI2AmQgAiAAKAA0IgNBBHZB//8BcTYCcCACIANBC3RBgPABcSABQRV2cjYCbCACIAAoADgiAEERdjYCfCACIABBAnZB//8BcTYCeCACIABBDXRBgMABcSADQRN2cjYCdAwSCyABQT9NBEAMEwsgAiAAKAAAIgFBEHY2AgQgAiABQf//A3E2AgAgAiAAKAAEIgFBEHY2AgwgAiABQf//A3E2AgggAiAAKAAIIgFBEHY2AhQgAiABQf//A3E2AhAgAiAAKAAMIgFBEHY2AhwgAiABQf//A3E2AhggAiAAKAAQIgFBEHY2AiQgAiABQf//A3E2AiAgAiAAKAAUIgFBEHY2AiwgAiABQf//A3E2AiggAiAAKAAYIgFBEHY2AjQgAiABQf//A3E2AjAgAiAAKAAcIgFBEHY2AjwgAiABQf//A3E2AjggAiAAKAAgIgFBEHY2AkQgAiABQf//A3E2AkAgAiAAKAAkIgFBEHY2AkwgAiABQf//A3E2AkggAiAAKAAoIgFBEHY2AlQgAiABQf//A3E2AlAgAiAAKAAsIgFB//8DcTYCWCACIAFBEHY2AlwgAiAAKAAwIgFBEHY2AmQgAiABQf//A3E2AmAgAiAAKAA0IgFBEHY2AmwgAiABQf//A3E2AmggAiAAKAA4IgFBEHY2AnQgAiABQf//A3E2AnAgAiAAKAA8IgBBEHY2AnwgAiAAQf//A3E2AngMEQsgAUHDAE0EQAwSCyACIAAoAAAiCUH//wdxNgIAIAIgACgABCIBQQJ2Qf//B3E2AgggAiAAKAAIIgNBBHZB//8HcTYCECACIAAoAAwiBEEGdkH//wdxNgIYIAIgACgAECIFQQh2Qf//B3E2AiAgAiAAKAAUIgZBCnZB//8HcTYCKCACIAAoABgiB0EMdkH//wdxNgIwIAIgAUEPdEGAgAZxIAlBEXZyNgIEIAIgA0ENdEGAwAdxIAFBE3ZyNgIMIAIgBEELdEGA8AdxIANBFXZyNgIUIAIgBUEJdEGA/AdxIARBF3ZyNgIcIAIgBkEHdEGA/wdxIAVBGXZyNgIkIAIgB0EFdEHg/wdxIAZBG3ZyNgIsIAIgACgAHCIBQQ52Qf//B3E2AjggAiAAKAAkIgNBAXZB//8HcTYCRCACIAAoACgiBEEDdkH//wdxNgJMIAIgACgALCIFQQV2Qf//B3E2AlQgAiAAKAAwIgZBB3ZB//8HcTYCXCACIAFBA3RB+P8HcSAHQR12cjYCNCACIAAoACAiB0EBdEH+/wdxIAFBH3ZyNgI8IAIgA0EQdEGAgARxIAdBEHZyNgJAIAIgBEEOdEGAgAdxIANBEnZyNgJIIAIgBUEMdEGA4AdxIARBFHZyNgJQIAIgBkEKdEGA+AdxIAVBFnZyNgJYIAIgACgANCIBQQl2Qf//B3E2AmQgAiABQQh0QYD+B3EgBkEYdnI2AmAgAiAAKAA4IgNBC3ZB//8HcTYCbCACIANBBnRBwP8HcSABQRp2cjYCaCACIAAoADwiAUENdkH//wdxNgJ0IAIgAUEEdEHw/wdxIANBHHZyNgJwIAIgACgAQCIAQQ92NgJ8IAIgAEECdEH8/wdxIAFBHnZyNgJ4DBALIAFBxwBNBEAMEQsgAiAAKAAAIgdB//8PcTYCACACIAAoAAQiAUEEdkH//w9xNgIIIAIgACgACCIDQQh2Qf//D3E2AhAgAiAAKAAMIgRBDHZB//8PcTYCGCACIAAoABQiBUECdkH//w9xNgIkIAIgACgAGCIGQQZ2Qf//D3E2AiwgAiABQQ50QYCAD3EgB0ESdnI2AgQgAiADQQp0QYD4D3EgAUEWdnI2AgwgAiAEQQZ0QcD/D3EgA0EadnI2AhQgAiAAKAAQIgFBAnRB/P8PcSAEQR52cjYCHCACIAVBEHRBgIAMcSABQRB2cjYCICACIAZBDHRBgOAPcSAFQRR2cjYCKCACIAAoACAiB0EOdjYCPCACIAAoACQiCUH//w9xNgJAIAIgACgAHCIBQQp2Qf//D3E2AjQgAiAAKAAoIgNBBHZB//8PcTYCSCACIAAoACwiBEEIdkH//w9xNgJQIAIgACgAMCIFQQx2Qf//D3E2AlggAiABQQh0QYD+D3EgBkEYdnI2AjAgAiAHQQR0QfD/D3EgAUEcdnI2AjggAiADQQ50QYCAD3EgCUESdnI2AkQgAiAEQQp0QYD4D3EgA0EWdnI2AkwgAiAFQQZ0QcD/D3EgBEEadnI2AlQgAiAAKAA0IgNBAnRB/P8PcSAFQR52cjYCXCACIAAoADgiAUECdkH//w9xNgJkIAIgAUEQdEGAgAxxIANBEHZyNgJgIAIgACgAPCIDQQZ2Qf//D3E2AmwgAiADQQx0QYDgD3EgAUEUdnI2AmggAiAAKABAIgFBCnZB//8PcTYCdCACIAFBCHRBgP4PcSADQRh2cjYCcCACIAAoAEQiAEEOdjYCfCACIABBBHRB8P8PcSABQRx2cjYCeAwPCyABQcsATQRADBALIAIgACgAACIGQf//H3E2AgAgAiAAKAAEIgFBBnZB//8fcTYCCCACIAAoAAgiA0EMdkH//x9xNgIQIAIgACgAECIEQQV2Qf//H3E2AhwgAiAAKAAUIgVBC3ZB//8fcTYCJCACIAFBDXRBgMAfcSAGQRN2cjYCBCACIANBB3RBgP8fcSABQRl2cjYCDCACIAAoAAwiAUEBdEH+/x9xIANBH3ZyNgIUIAIgBEEOdEGAgB9xIAFBEnZyNgIYIAIgBUEIdEGA/h9xIARBGHZyNgIgIAIgACgAGCIDQQJ0Qfz/H3EgBUEednI2AiggAiAAKAAcIgFBBHZB//8fcTYCMCACIAFBD3RBgIAecSADQRF2cjYCLCACIAAoACAiA0EKdkH//x9xNgI4IAIgACgAKCIEQQN2Qf//H3E2AkQgAiAAKAAsIgVBCXZB//8fcTYCTCACIAAoADQiBkECdkH//x9xNgJYIAIgA0EJdEGA/B9xIAFBF3ZyNgI0IAIgACgAJCIBQQN0Qfj/H3EgA0EddnI2AjwgAiAEQRB0QYCAHHEgAUEQdnI2AkAgAiAFQQp0QYD4H3EgBEEWdnI2AkggAiAAKAAwIgFBBHRB8P8fcSAFQRx2cjYCUCACIAZBEXRBgIAYcSABQQ92cjYCVCACIAAoADgiAUEIdkH//x9xNgJgIAIgAUELdEGA8B9xIAZBFXZyNgJcIAIgACgAPCIDQQV0QeD/H3EgAUEbdnI2AmQgAiAAKABAIgFBAXZB//8fcTYCbCACIAFBEnRBgIAQcSADQQ52cjYCaCACIAAoAEQiA0EHdkH//x9xNgJ0IAIgA0EMdEGA4B9xIAFBFHZyNgJwIAIgACgASCIAQQ12NgJ8IAIgAEEGdEHA/x9xIANBGnZyNgJ4DA4LIAFBzwBNBEAMDwsgAiAAKAAAIgVB//8/cTYCACACIAAoABAiBkEMdjYCHCACIAAoABQiB0H//z9xNgIgIAIgACgABCIBQQh2Qf//P3E2AgggAiAAKAAMIgNBBHZB//8/cTYCFCACIAAoABgiBEEIdkH//z9xNgIoIAIgAUEMdEGA4D9xIAVBFHZyNgIEIAIgACgACCIFQQR0QfD/P3EgAUEcdnI2AgwgAiADQRB0QYCAPHEgBUEQdnI2AhAgAiAGQQh0QYD+P3EgA0EYdnI2AhggAiAEQQx0QYDgP3EgB0EUdnI2AiQgAiAAKAAcIgVBBHRB8P8/cSAEQRx2cjYCLCACIAAoACQiBkEMdjYCPCACIAAoACgiB0H//z9xNgJAIAIgACgAOCIJQQx2NgJcIAIgACgAICIBQQR2Qf//P3E2AjQgAiAAKAAsIgNBCHZB//8/cTYCSCACIAAoADQiBEEEdkH//z9xNgJUIAIgAUEQdEGAgDxxIAVBEHZyNgIwIAIgBkEIdEGA/j9xIAFBGHZyNgI4IAIgA0EMdEGA4D9xIAdBFHZyNgJEIAIgACgAMCIBQQR0QfD/P3EgA0EcdnI2AkwgAiAEQRB0QYCAPHEgAUEQdnI2AlAgAiAJQQh0QYD+P3EgBEEYdnI2AlggAiAAKAA8IgNB//8/cTYCYCACIAAoAEAiAUEIdkH//z9xNgJoIAIgAUEMdEGA4D9xIANBFHZyNgJkIAIgACgARCIDQQR0QfD/P3EgAUEcdnI2AmwgAiAAKABIIgFBBHZB//8/cTYCdCACIAFBEHRBgIA8cSADQRB2cjYCcCACIAAoAEwiAEEMdjYCfCACIABBCHRBgP4/cSABQRh2cjYCeAwNCyABQdMATQRADA4LIAIgACgAACIGQf///wBxNgIAIAIgACgABCIBQQp2Qf///wBxNgIIIAIgACgADCIDQQl2Qf///wBxNgIUIAIgACgAFCIEQQh2Qf///wBxNgIgIAIgACgAHCIFQQd2Qf///wBxNgIsIAIgAUELdEGA8P8AcSAGQRV2cjYCBCACIAAoAAgiBkEBdEH+//8AcSABQR92cjYCDCACIANBDHRBgOD/AHEgBkEUdnI2AhAgAiAAKAAQIgFBAnRB/P//AHEgA0EednI2AhggAiAEQQ10QYDA/wBxIAFBE3ZyNgIcIAIgACgAGCIBQQN0Qfj//wBxIARBHXZyNgIkIAIgBUEOdEGAgP8AcSABQRJ2cjYCKCACIAAoACQiAUEGdkH///8AcTYCOCACIAAoACwiA0EFdkH///8AcTYCRCACIAAoADQiBEEEdkH///8AcTYCUCACIAAoADwiBkEDdkH///8AcTYCXCACIAAoACAiB0EEdEHw//8AcSAFQRx2cjYCMCACIAFBD3RBgID+AHEgB0ERdnI2AjQgAiAAKAAoIgVBBXRB4P//AHEgAUEbdnI2AjwgAiADQRB0QYCA/ABxIAVBEHZyNgJAIAIgACgAMCIBQQZ0QcD//wBxIANBGnZyNgJIIAIgBEERdEGAgPgAcSABQQ92cjYCTCACIAAoADgiAUEHdEGA//8AcSAEQRl2cjYCVCACIAZBEnRBgIDwAHEgAUEOdnI2AlggAiAAKABAIgNBCHRBgP7/AHEgBkEYdnI2AmAgAiAAKABEIgFBAnZB////AHE2AmggAiABQRN0QYCA4ABxIANBDXZyNgJkIAIgACgASCIDQQl0QYD8/wBxIAFBF3ZyNgJsIAIgACgATCIBQQF2Qf///wBxNgJ0IAIgAUEUdEGAgMAAcSADQQx2cjYCcCACIAAoAFAiAEELdjYCfCACIABBCnRBgPj/AHEgAUEWdnI2AngMDAsgAUHXAE0EQAwNCyACIAAoAAAiBUH///8BcTYCACACIAAoAAgiAUECdkH///8BcTYCDCACIAAoABAiA0EEdkH///8BcTYCGCACIAAoABgiBEEGdkH///8BcTYCJCACIAAoAAQiBkEKdEGA+P8BcSAFQRZ2cjYCBCACIAFBFHRBgIDAAXEgBkEMdnI2AgggAiAAKAAMIgVBCHRBgP7/AXEgAUEYdnI2AhAgAiADQRJ0QYCA8AFxIAVBDnZyNgIUIAIgACgAFCIBQQZ0QcD//wFxIANBGnZyNgIcIAIgBEEQdEGAgPwBcSABQRB2cjYCICACIAAoABwiBUEEdEHw//8BcSAEQRx2cjYCKCACIAAoACgiBEEKdjYCPCACIAAoACwiBkH///8BcTYCQCACIAAoACAiAUEIdkH///8BcTYCMCACIAAoADQiA0ECdkH///8BcTYCTCACIAFBDnRBgID/AXEgBUESdnI2AiwgAiAAKAAkIgVBAnRB/P//AXEgAUEednI2AjQgAiAEQQx0QYDg/wFxIAVBFHZyNgI4IAIgACgAMCIBQQp0QYD4/wFxIAZBFnZyNgJEIAIgA0EUdEGAgMABcSABQQx2cjYCSCACIAAoADgiBEEIdEGA/v8BcSADQRh2cjYCUCACIAAoADwiAUEEdkH///8BcTYCWCACIAFBEnRBgIDwAXEgBEEOdnI2AlQgAiAAKABAIgNBBnRBwP//AXEgAUEadnI2AlwgAiAAKABEIgFBBnZB////AXE2AmQgAiABQRB0QYCA/AFxIANBEHZyNgJgIAIgACgASCIDQQR0QfD//wFxIAFBHHZyNgJoIAIgACgATCIBQQh2Qf///wFxNgJwIAIgAUEOdEGAgP8BcSADQRJ2cjYCbCACIAAoAFAiA0ECdEH8//8BcSABQR52cjYCdCACIAAoAFQiAEEKdjYCfCACIABBDHRBgOD/AXEgA0EUdnI2AngMCwsgAUHbAE0EQAwMCyACIAAoAAAiBUH///8DcTYCACACIAAoAAgiAUEFdkH///8DcTYCDCACIAAoABQiA0EBdkH///8DcTYCHCACIAAoABwiBEEGdkH///8DcTYCKCACIAAoAAQiBkEJdEGA/P8DcSAFQRd2cjYCBCACIAFBEnRBgIDwA3EgBkEOdnI2AgggAiAAKAAMIgVBBHRB8P//A3EgAUEcdnI2AhAgAiAAKAAQIgFBDXRBgMD/A3EgBUETdnI2AhQgAiADQRZ0QYCAgAJxIAFBCnZyNgIYIAIgACgAGCIBQQh0QYD+/wNxIANBGHZyNgIgIAIgBEERdEGAgPgDcSABQQ92cjYCJCACIAAoACgiAUECdkH///8DcTYCOCACIAAoADAiA0EHdkH///8DcTYCRCACIAAoADwiBUEDdkH///8DcTYCVCACIAAoACAiBkEDdEH4//8DcSAEQR12cjYCLCACIAAoACQiBEEMdEGA4P8DcSAGQRR2cjYCMCACIAFBFXRBgICAA3EgBEELdnI2AjQgAiAAKAAsIgRBB3RBgP//A3EgAUEZdnI2AjwgAiADQRB0QYCA/ANxIARBEHZyNgJAIAIgACgANCIBQQJ0Qfz//wNxIANBHnZyNgJIIAIgACgAOCIDQQt0QYDw/wNxIAFBFXZyNgJMIAIgBUEUdEGAgMADcSADQQx2cjYCUCACIAAoAEAiA0EGdEHA//8DcSAFQRp2cjYCWCACIAAoAEQiAUEIdkH///8DcTYCYCACIAFBD3RBgID+A3EgA0ERdnI2AlwgAiAAKABIIgNBAXRB/v//A3EgAUEfdnI2AmQgAiAAKABMIgRBCnRBgPj/A3EgA0EWdnI2AmggAiAAKABQIgFBBHZB////A3E2AnAgAiABQRN0QYCA4ANxIARBDXZyNgJsIAIgACgAVCIDQQV0QeD//wNxIAFBG3ZyNgJ0IAIgACgAWCIAQQl2NgJ8IAIgAEEOdEGAgP8DcSADQRJ2cjYCeAwKCyABQd8ATQRADAsLIAIgACgAACIBQf///wdxNgIAIAIgACgACCIDQQh2NgIMIAIgACgADCIEQf///wdxNgIQIAIgACgAFCIFQQh2NgIcIAIgACgAGCIGQf///wdxNgIgIAIgACgABCIHQQh0QYD+/wdxIAFBGHZyNgIEIAIgA0EQdEGAgPwHcSAHQRB2cjYCCCACIAAoABAiAUEIdEGA/v8HcSAEQRh2cjYCFCACIAVBEHRBgID8B3EgAUEQdnI2AhggAiAAKAAcIgFBCHRBgP7/B3EgBkEYdnI2AiQgAiAAKAAgIgNBCHY2AiwgAiADQRB0QYCA/AdxIAFBEHZyNgIoIAIgACgAJCIBQf///wdxNgIwIAIgACgALCIDQQh2NgI8IAIgACgAMCIEQf///wdxNgJAIAIgACgAOCIFQQh2NgJMIAIgACgAPCIGQf///wdxNgJQIAIgACgAKCIHQQh0QYD+/wdxIAFBGHZyNgI0IAIgA0EQdEGAgPwHcSAHQRB2cjYCOCACIAAoADQiAUEIdEGA/v8HcSAEQRh2cjYCRCACIAVBEHRBgID8B3EgAUEQdnI2AkggAiAAKABAIgFBCHRBgP7/B3EgBkEYdnI2AlQgAiAAKABEIgNBCHY2AlwgAiADQRB0QYCA/AdxIAFBEHZyNgJYIAIgACgASCIBQf///wdxNgJgIAIgACgATCIDQQh0QYD+/wdxIAFBGHZyNgJkIAIgACgAUCIBQQh2NgJsIAIgAUEQdEGAgPwHcSADQRB2cjYCaCACIAAoAFQiAUH///8HcTYCcCACIAAoAFgiA0EIdEGA/v8HcSABQRh2cjYCdCACIAAoAFwiAEEIdjYCfCACIABBEHRBgID8B3EgA0EQdnI2AngMCQsgAUHjAE0EQAwKCyACIAAoAAAiBEH///8PcTYCACACIAAoAAwiAUEEdkH///8PcTYCECACIAAoABwiA0EBdkH///8PcTYCJCACIAAoAAQiBUEHdEGA//8PcSAEQRl2cjYCBCACIAAoAAgiBEEOdEGAgP8PcSAFQRJ2cjYCCCACIAFBFXRBgICAD3EgBEELdnI2AgwgAiAAKAAQIgRBA3RB+P//D3EgAUEddnI2AhQgAiAAKAAUIgFBCnRBgPj/D3EgBEEWdnI2AhggAiAAKAAYIgRBEXRBgID4D3EgAUEPdnI2AhwgAiADQRh0QYCAgAhxIARBCHZyNgIgIAIgACgAICIEQQZ0QcD//w9xIANBGnZyNgIoIAIgACgAKCIBQQV2Qf///w9xNgI0IAIgACgAOCIDQQJ2Qf///w9xNgJIIAIgACgAJCIFQQ10QYDA/w9xIARBE3ZyNgIsIAIgAUEUdEGAgMAPcSAFQQx2cjYCMCACIAAoACwiBEECdEH8//8PcSABQR52cjYCOCACIAAoADAiAUEJdEGA/P8PcSAEQRd2cjYCPCACIAAoADQiBEEQdEGAgPwPcSABQRB2cjYCQCACIANBF3RBgICADHEgBEEJdnI2AkQgAiAAKAA8IgFBBXRB4P//D3EgA0EbdnI2AkwgAiAAKABAIgNBDHRBgOD/D3EgAUEUdnI2AlAgAiAAKABEIgFBBnZB////D3E2AlggAiABQRN0QYCA4A9xIANBDXZyNgJUIAIgACgASCIDQQF0Qf7//w9xIAFBH3ZyNgJcIAIgACgATCIBQQh0QYD+/w9xIANBGHZyNgJgIAIgACgAUCIDQQ90QYCA/g9xIAFBEXZyNgJkIAIgACgAVCIBQQN2Qf///w9xNgJsIAIgAUEWdEGAgIAOcSADQQp2cjYCaCACIAAoAFgiA0EEdEHw//8PcSABQRx2cjYCcCACIAAoAFwiAUELdEGA8P8PcSADQRV2cjYCdCACIAAoAGAiAEEHdjYCfCACIABBEnRBgIDwD3EgAUEOdnI2AngMCAsgAUHnAE0EQAwJCyACIAAoAAAiBEH///8fcTYCACACIAAoABAiAUECdkH///8fcTYCFCACIAAoACAiA0EEdkH///8fcTYCKCACIAAoAAQiBUEGdEHA//8fcSAEQRp2cjYCBCACIAAoAAgiBEEMdEGA4P8fcSAFQRR2cjYCCCACIAAoAAwiBUESdEGAgPAfcSAEQQ52cjYCDCACIAFBGHRBgICAGHEgBUEIdnI2AhAgAiAAKAAUIgRBBHRB8P//H3EgAUEcdnI2AhggAiAAKAAYIgFBCnRBgPj/H3EgBEEWdnI2AhwgAiAAKAAcIgRBEHRBgID8H3EgAUEQdnI2AiAgAiADQRZ0QYCAgB5xIARBCnZyNgIkIAIgACgAMCIEQQZ2NgI8IAIgACgANCIFQf///x9xNgJAIAIgACgARCIBQQJ2Qf///x9xNgJUIAIgACgAJCIGQQJ0Qfz//x9xIANBHnZyNgIsIAIgACgAKCIDQQh0QYD+/x9xIAZBGHZyNgIwIAIgACgALCIGQQ50QYCA/x9xIANBEnZyNgI0IAIgBEEUdEGAgMAfcSAGQQx2cjYCOCACIAAoADgiA0EGdEHA//8fcSAFQRp2cjYCRCACIAAoADwiBEEMdEGA4P8fcSADQRR2cjYCSCACIAAoAEAiA0ESdEGAgPAfcSAEQQ52cjYCTCACIAFBGHRBgICAGHEgA0EIdnI2AlAgAiAAKABIIgNBBHRB8P//H3EgAUEcdnI2AlggAiAAKABMIgFBCnRBgPj/H3EgA0EWdnI2AlwgAiAAKABQIgNBEHRBgID8H3EgAUEQdnI2AmAgAiAAKABUIgFBBHZB////H3E2AmggAiABQRZ0QYCAgB5xIANBCnZyNgJkIAIgACgAWCIDQQJ0Qfz//x9xIAFBHnZyNgJsIAIgACgAXCIBQQh0QYD+/x9xIANBGHZyNgJwIAIgACgAYCIDQQ50QYCA/x9xIAFBEnZyNgJ0IAIgACgAZCIAQQZ2NgJ8IAIgAEEUdEGAgMAfcSADQQx2cjYCeAwHCyABQesATQRADAgLIAIgACgAACIDQf///z9xNgIAIAIgACgAFCIBQQJ2Qf///z9xNgIYIAIgACgABCIEQQV0QeD//z9xIANBG3ZyNgIEIAIgACgACCIDQQp0QYD4/z9xIARBFnZyNgIIIAIgACgADCIEQQ90QYCA/j9xIANBEXZyNgIMIAIgACgAECIDQRR0QYCAwD9xIARBDHZyNgIQIAIgAUEZdEGAgIAwcSADQQd2cjYCFCACIAAoABgiA0EDdEH4//8/cSABQR12cjYCHCACIAAoABwiAUEIdEGA/v8/cSADQRh2cjYCICACIAAoACAiBEENdEGAwP8/cSABQRN2cjYCJCACIAAoACgiAUEEdkH///8/cTYCMCACIAAoAEAiA0EBdkH///8/cTYCTCACIAAoACQiBUESdEGAgPA/cSAEQQ52cjYCKCACIAFBF3RBgICAPHEgBUEJdnI2AiwgAiAAKAAsIgRBAXRB/v//P3EgAUEfdnI2AjQgAiAAKAAwIgFBBnRBwP//P3EgBEEadnI2AjggAiAAKAA0IgRBC3RBgPD/P3EgAUEVdnI2AjwgAiAAKAA4IgFBEHRBgID8P3EgBEEQdnI2AkAgAiAAKAA8IgRBFXRBgICAP3EgAUELdnI2AkQgAiADQRp0QYCAgCBxIARBBnZyNgJIIAIgACgARCIBQQR0QfD//z9xIANBHHZyNgJQIAIgACgASCIDQQl0QYD8/z9xIAFBF3ZyNgJUIAIgACgATCIBQQ50QYCA/z9xIANBEnZyNgJYIAIgACgAUCIDQRN0QYCA4D9xIAFBDXZyNgJcIAIgACgAVCIBQQN2Qf///z9xNgJkIAIgAUEYdEGAgIA4cSADQQh2cjYCYCACIAAoAFgiA0ECdEH8//8/cSABQR52cjYCaCACIAAoAFwiAUEHdEGA//8/cSADQRl2cjYCbCACIAAoAGAiA0EMdEGA4P8/cSABQRR2cjYCcCACIAAoAGQiAUERdEGAgPg/cSADQQ92cjYCdCACIAAoAGgiAEEFdjYCfCACIABBFnRBgICAPnEgAUEKdnI2AngMBgsgAUHvAE0EQAwHCyACIAAoAAAiAUH/////AHE2AgAgAiAAKAAYIgNBBHY2AhwgAiAAKAAcIgRB/////wBxNgIgIAIgACgABCIFQQR0QfD///8AcSABQRx2cjYCBCACIAAoAAgiAUEIdEGA/v//AHEgBUEYdnI2AgggAiAAKAAMIgVBDHRBgOD//wBxIAFBFHZyNgIMIAIgACgAECIBQRB0QYCA/P8AcSAFQRB2cjYCECACIAAoABQiBUEUdEGAgMD/AHEgAUEMdnI2AhQgAiADQRh0QYCAgPgAcSAFQQh2cjYCGCACIAAoACAiAUEEdEHw////AHEgBEEcdnI2AiQgAiAAKAA0IgNBBHY2AjwgAiAAKAA4IgRB/////wBxNgJAIAIgACgAJCIFQQh0QYD+//8AcSABQRh2cjYCKCACIAAoACgiAUEMdEGA4P//AHEgBUEUdnI2AiwgAiAAKAAsIgVBEHRBgID8/wBxIAFBEHZyNgIwIAIgACgAMCIBQRR0QYCAwP8AcSAFQQx2cjYCNCACIANBGHRBgICA+ABxIAFBCHZyNgI4IAIgACgAPCIBQQR0QfD///8AcSAEQRx2cjYCRCACIAAoAEAiA0EIdEGA/v//AHEgAUEYdnI2AkggAiAAKABEIgFBDHRBgOD//wBxIANBFHZyNgJMIAIgACgASCIDQRB0QYCA/P8AcSABQRB2cjYCUCACIAAoAEwiAUEUdEGAgMD/AHEgA0EMdnI2AlQgAiAAKABQIgNBBHY2AlwgAiADQRh0QYCAgPgAcSABQQh2cjYCWCACIAAoAFQiAUH/////AHE2AmAgAiAAKABYIgNBBHRB8P///wBxIAFBHHZyNgJkIAIgACgAXCIBQQh0QYD+//8AcSADQRh2cjYCaCACIAAoAGAiA0EMdEGA4P//AHEgAUEUdnI2AmwgAiAAKABkIgFBEHRBgID8/wBxIANBEHZyNgJwIAIgACgAaCIDQRR0QYCAwP8AcSABQQx2cjYCdCACIAAoAGwiAEEEdjYCfCACIABBGHRBgICA+ABxIANBCHZyNgJ4DAULIAFB8wBNBEAMBgsgAiAAKAAAIgFB/////wFxNgIAIAIgACgABCIDQQN0Qfj///8BcSABQR12cjYCBCACIAAoAAgiAUEGdEHA////AXEgA0EadnI2AgggAiAAKAAMIgNBCXRBgPz//wFxIAFBF3ZyNgIMIAIgACgAECIBQQx0QYDg//8BcSADQRR2cjYCECACIAAoABQiA0EPdEGAgP7/AXEgAUERdnI2AhQgAiAAKAAYIgFBEnRBgIDw/wFxIANBDnZyNgIYIAIgACgAHCIDQRV0QYCAgP8BcSABQQt2cjYCHCACIAAoACAiBEEYdEGAgID4AXEgA0EIdnI2AiAgAiAAKAAkIgFBAnZB/////wFxNgIoIAIgAUEbdEGAgIDAAXEgBEEFdnI2AiQgAiAAKAAoIgNBAXRB/v///wFxIAFBH3ZyNgIsIAIgACgALCIBQQR0QfD///8BcSADQRx2cjYCMCACIAAoADAiA0EHdEGA////AXEgAUEZdnI2AjQgAiAAKAA0IgFBCnRBgPj//wFxIANBFnZyNgI4IAIgACgAOCIDQQ10QYDA//8BcSABQRN2cjYCPCACIAAoADwiAUEQdEGAgPz/AXEgA0EQdnI2AkAgAiAAKABAIgNBE3RBgIDg/wFxIAFBDXZyNgJEIAIgACgARCIBQRZ0QYCAgP4BcSADQQp2cjYCSCACIAAoAEgiA0EZdEGAgIDwAXEgAUEHdnI2AkwgAiAAKABMIgFBAXZB/////wFxNgJUIAIgAUEcdEGAgICAAXEgA0EEdnI2AlAgAiAAKABQIgNBAnRB/P///wFxIAFBHnZyNgJYIAIgACgAVCIBQQV0QeD///8BcSADQRt2cjYCXCACIAAoAFgiA0EIdEGA/v//AXEgAUEYdnI2AmAgAiAAKABcIgFBC3RBgPD//wFxIANBFXZyNgJkIAIgACgAYCIDQQ50QYCA//8BcSABQRJ2cjYCaCACIAAoAGQiAUERdEGAgPj/AXEgA0EPdnI2AmwgAiAAKABoIgNBFHRBgIDA/wFxIAFBDHZyNgJwIAIgACgAbCIBQRd0QYCAgPwBcSADQQl2cjYCdCACIAAoAHAiAEEDdjYCfCACIABBGnRBgICA4AFxIAFBBnZyNgJ4DAQLIAFB9wBNBEAMBQsgAiAAKAAAIgFB/////wNxNgIAIAIgACgABCIDQQJ0Qfz///8DcSABQR52cjYCBCACIAAoAAgiAUEEdEHw////A3EgA0EcdnI2AgggAiAAKAAMIgNBBnRBwP///wNxIAFBGnZyNgIMIAIgACgAECIBQQh0QYD+//8DcSADQRh2cjYCECACIAAoABQiA0EKdEGA+P//A3EgAUEWdnI2AhQgAiAAKAAYIgFBDHRBgOD//wNxIANBFHZyNgIYIAIgACgAHCIDQQ50QYCA//8DcSABQRJ2cjYCHCACIAAoACAiAUEQdEGAgPz/A3EgA0EQdnI2AiAgAiAAKAAkIgNBEnRBgIDw/wNxIAFBDnZyNgIkIAIgACgAOCIBQQJ2NgI8IAIgACgAPCIEQf////8DcTYCQCACIAAoACgiBUEUdEGAgMD/A3EgA0EMdnI2AiggAiAAKAAsIgNBFnRBgICA/gNxIAVBCnZyNgIsIAIgACgAMCIFQRh0QYCAgPgDcSADQQh2cjYCMCACIAAoADQiA0EadEGAgIDgA3EgBUEGdnI2AjQgAiABQRx0QYCAgIADcSADQQR2cjYCOCACIAAoAEAiAUECdEH8////A3EgBEEednI2AkQgAiAAKABEIgNBBHRB8P///wNxIAFBHHZyNgJIIAIgACgASCIBQQZ0QcD///8DcSADQRp2cjYCTCACIAAoAEwiA0EIdEGA/v//A3EgAUEYdnI2AlAgAiAAKABQIgFBCnRBgPj//wNxIANBFnZyNgJUIAIgACgAVCIDQQx0QYDg//8DcSABQRR2cjYCWCACIAAoAFgiAUEOdEGAgP//A3EgA0ESdnI2AlwgAiAAKABcIgNBEHRBgID8/wNxIAFBEHZyNgJgIAIgACgAYCIBQRJ0QYCA8P8DcSADQQ52cjYCZCACIAAoAGQiA0EUdEGAgMD/A3EgAUEMdnI2AmggAiAAKABoIgFBFnRBgICA/gNxIANBCnZyNgJsIAIgACgAbCIDQRh0QYCAgPgDcSABQQh2cjYCcCACIAAoAHAiAUEadEGAgIDgA3EgA0EGdnI2AnQgAiAAKAB0IgBBAnY2AnwgAiAAQRx0QYCAgIADcSABQQR2cjYCeAwDCyABQfsATQRADAQLIAIgACgAACIBQf////8HcTYCACACIAAoAAQiA0EBdEH+////B3EgAUEfdnI2AgQgAiAAKAAIIgFBAnRB/P///wdxIANBHnZyNgIIIAIgACgADCIDQQN0Qfj///8HcSABQR12cjYCDCACIAAoABAiAUEEdEHw////B3EgA0EcdnI2AhAgAiAAKAAUIgNBBXRB4P///wdxIAFBG3ZyNgIUIAIgACgAGCIBQQZ0QcD///8HcSADQRp2cjYCGCACIAAoABwiA0EHdEGA////B3EgAUEZdnI2AhwgAiAAKAAgIgFBCHRBgP7//wdxIANBGHZyNgIgIAIgACgAJCIDQQl0QYD8//8HcSABQRd2cjYCJCACIAAoACgiAUEKdEGA+P//B3EgA0EWdnI2AiggAiAAKAAsIgNBC3RBgPD//wdxIAFBFXZyNgIsIAIgACgAMCIBQQx0QYDg//8HcSADQRR2cjYCMCACIAAoADQiA0ENdEGAwP//B3EgAUETdnI2AjQgAiAAKAA4IgFBDnRBgID//wdxIANBEnZyNgI4IAIgACgAPCIDQQ90QYCA/v8HcSABQRF2cjYCPCACIAAoAEAiAUEQdEGAgPz/B3EgA0EQdnI2AkAgAiAAKABEIgNBEXRBgID4/wdxIAFBD3ZyNgJEIAIgACgASCIBQRJ0QYCA8P8HcSADQQ52cjYCSCACIAAoAEwiA0ETdEGAgOD/B3EgAUENdnI2AkwgAiAAKABQIgFBFHRBgIDA/wdxIANBDHZyNgJQIAIgACgAVCIDQRV0QYCAgP8HcSABQQt2cjYCVCACIAAoAFgiAUEWdEGAgID+B3EgA0EKdnI2AlggAiAAKABcIgNBF3RBgICA/AdxIAFBCXZyNgJcIAIgACgAYCIBQRh0QYCAgPgHcSADQQh2cjYCYCACIAAoAGQiA0EZdEGAgIDwB3EgAUEHdnI2AmQgAiAAKABoIgFBGnRBgICA4AdxIANBBnZyNgJoIAIgACgAbCIDQRt0QYCAgMAHcSABQQV2cjYCbCACIAAoAHAiAUEcdEGAgICAB3EgA0EEdnI2AnAgAiAAKAB0IgNBHXRBgICAgAZxIAFBA3ZyNgJ0IAIgACgAeCIAQQF2NgJ8IAIgAEEedEGAgICABHEgA0ECdnI2AngMAgsgAUH/AE0EQAwDCyACIAAoAAA2AgAgAiAAKQAENwIEIAIgACkADDcCDCACIAApABQ3AhQgAiAAKQAcNwIcIAIgACkAJDcCJCACIAApACw3AiwgAiAAKQA0NwI0IAIgACgAPDYCPCACIAAoAEA2AkAgAiAAKQBENwJEIAIgACkATDcCTCACIAApAFQ3AlQgAiAAKQBcNwJcIAIgACkAZDcCZCACIAApAGw3AmwgAiAAKQB0NwJ0IAIgACgAfDYCfAwBCyAIQQE2AhQgCEH8ic8ANgIQIAhCATcCHCAIQTs2AiwgCCAIQShqNgIYIAggCEEMajYCKCAIQRBqQaSKzwAQ7ywACyAIQTBqJAAPC0GU7s4AQS1BhO7OABCfKQAL7gMBBH8jAEEgayIGJAACQCAEIAFB/wFxIgRJDQACQAJAAkACQAJAAkACQAJAAkAgBEEYTQRAIAAoAgQgBEECdGooAgAgBCABQRB2bGoiB0GhvwdPDQRBoL8HIAdrIQggACgCCCAHaiEAIAFBCHZB/wFxIgFFDQMgAUEKRg0BIAQNAgwJCyAEQRlBjNTRABDDIQALIAdBoL8HRg0DIAAtAAAiAUHhAGtB/wFxQRpPDQggA0UNBCACLQAAIAFzQSBHDQggAEEBakGfvwcgB2sgAkEBaiADQQFrIARBAWsiABCyICAARiEFDAgLQQAhAQNAIAEgCEYNBQJAAkAgACABai0AACIFQeEAa0H/AXFBGk8EQCABIANJBEAgBSABIAJqLQAARg0CDAoLIAEgA0Hc1NEAEMMhAAsgASADTw0BIAEgAmotAAAgBXNBIEcNCAsgBCABQQFqIgFGDQgMAQsLIAEgA0Hs1NEAEMMhAAsgACAIIAIgAyAEELIgIARGIQUMBgsgBkEANgIYIAZBATYCDCAGQbjQ0QA2AgggBkIENwIQIAZBCGpBnNTRABDvLAALQQBBAEGs1NEAEMMhAAtBAEEAQbzU0QAQwyEACyAIIAhBzNTRABDDIQALQQAhBQwBC0EBIQULIAZBIGokACAFC9kDAQd/IABBDGohBQJAIAGnQQFxBEACQCAFKAIABEAgACgCHCIGQQFqIgdBA3YgB0EHcUEAR2oiAyAAKAIYIgRLBEAgAyAEayEIIAAoAhAiCSADSQRAIAUgCUEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSAAKAIYIQQLIAgEQCAAKAIUIARqQQAgCPwLAAsgACADNgIYCyAAIAc2AhwgACgCFCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgMgACgCAEYEQCAAQYSTgAEQsygLIAAoAgQgA0EDdGogAjcDAAwBCyAFEOY6IAUoAgAEQCAAKAIcQQFqIgZBA3YgBkEHcUEAR2oiAyAAKAIYIgRLBEAgAyAEayEHIAAoAhAiCCADSQRAIAUgCEEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACADNgIYCyAAIAY2AhwgACgCCCIDIAAoAgBGBEAgAEH0koABELMoCyAAKAIEIANBA3RqQgA3AwAMAQtBoJWAARCyOwALIAAgA0EBajYCCAuTBAIFfwF+IwBBQGoiAiQAAkACfyABKAJYQYCAgIB4RwRAIAJBGGogAUEQahC8CiACQRBqIgMgAkEkaikCADcDACACIAIpAhw3AwggAigCGCIEQQhHBEAgAigCLCEBIAAgAikDCDcCDCAAIAE2AhwgACAENgIIIABCAjcDACAAQRRqIAMpAwA3AgAMAwsgAkE4aiADKQMANwMAIAIgAikDCDcDMEEHDAELIAJBGGogASgCaCIEIAEoAmwiBSgCHBEAACACQRBqIgMgAkEkaikCADcDACACIAIpAhw3AwggAigCGCIGQQhHBEAgAigCLCEBIAAgAikDCDcCDCAAIAE2AhwgACAGNgIIIABCAjcDACAAQRRqIAMpAwA3AgAMAgsgAkE4aiADKQMANwMAIAIgAikDCDcDMCAEIAUoAhARBAALIQMgASgCqAEhBCABQQA2AqgBIAEpA3AhByABQQA2AnAgACAHNwMgIAEpAoQBIQcgAUEANgKEASAAIAc3AjQgASkDACEHIAFCADcDACAAQShqIAFB+ABqKQMANwMAIABBMGogAUGAAWooAgA2AgAgAEE8aiABQYwBaikCADcCACAAQcQAaiABQZQBaigCADYCACAAIAEpAwg3AwggACAHNwMAIABBGGogAkE4aikDADcDACAAIAIpAzA3AxAgACADOgBMIAAgBDYCSAsgAkFAayQAC80DAgZ/Cn4gASgCYEGAgICAeEYEQCAAQgA3AwAPCyABKAJkIgMgASgCaEEGdGohBCABLQBwIQUgAS0AcSEGQQAhAQNAIAkhCiANIQsgCCEMA0ACQAJAAkACQCABRSABIAdGckUEQCABIQIMAQsDQCADIARGDQIgA0EoaiADQUBrIQMoAgAiAUUNAAsgA0EcaygCACICIAFBwAJsaiEHCyAFRQ0CQgAhCAJAIAIoAkBBAUcNACACKQNIIglCAFMNACACKALIAUEBRw0AIAIoAswBIgFBAEgNACAJIAGtfCEOQgEhCCAJIQ8LIAynQQFxDQEgDiEKIA8hCyAIIQwMAgsgACAKNwMQIAAgCzcDCCAAIAw3AwAPCyAIUA0AIA4gCiAKIA5UGyEKIA8gCyALIA9WGyELQgEhDAsgAkHAAmohASAGRQ0AC0IAIQgCQCACKAIwQQFHDQAgAikDOCIJQgBTDQAgAigCwAFBAUcNACACKALEASICQQBIDQAgCSACrXwhEEIBIQggCSERCyAQIQkgESENIAynQQFxRQ0AIAhQIAohCSALIQ0gDCEIDQAgECAKIAogEFQbIQkgESALIAsgEVYbIQ1CASEIDAALAAv+AwEGfyAAQRxqIQgCQAJAIAAoAixFBEAgAiEDDAELIAAoAiwiA0ERTw0BIAJBECADayIEIAIgBEkbIgQEQCADIAhqIAEgBPwKAAALIAAgACgCLCAEaiIDQQAgA0EQRyIFGzYCLCACIARrIQMgASAEaiEBIAUNACAAIAAoAgAgACgCHEH3lK+veGxqQQ13QbHz3fF5bDYCACAAIAAoAgQgACgCIEH3lK+veGxqQQ13QbHz3fF5bDYCBCAAIAAoAgggACgCJEH3lK+veGxqQQ13QbHz3fF5bDYCCCAAIAAoAgwgACgCKEH3lK+veGxqQQ13QbHz3fF5bDYCDAsgA0EQTwRAIAAoAgwhBCAAKAIIIQUgACgCBCEGIAAoAgAhBwNAIAEoAABB95Svr3hsIAdqQQ13QbHz3fF5bCEHIAFBDGooAABB95Svr3hsIARqQQ13QbHz3fF5bCEEIAFBCGooAABB95Svr3hsIAVqQQ13QbHz3fF5bCEFIAFBBGooAABB95Svr3hsIAZqQQ13QbHz3fF5bCEGIAFBEGohASADQRBrIgNBD0sNAAsgACAENgIMIAAgBTYCCCAAIAY2AgQgACAHNgIACyADBEAgAwRAIAggASAD/AoAAAsgACADNgIsCyAAIAApAxAgAq18NwMQDwsgA0EQQZTJ0AAQrzsAC9gDAQZ/IABBDGohAwJAIAFBAXEEQAJAIAMoAgAEQCAAKAIcIgVBAWoiBkEDdiAGQQdxQQBHaiIBIAAoAhgiBEsEQCABIARrIQcgACgCECIIIAFJBEAgAyAIQQF0IgMgAUHA////A3FBQGsgASABQT9xGyIEIAMgBEsbEOgZIAAoAhghBAsgBwRAIAAoAhQgBGpBACAH/AsACyAAIAE2AhgLIAAgBjYCHCAAKAIUIAVBA3ZqIgEgAS0AAEEBIAVBB3F0cjoAAAwBCyAAIAAoAiBBAWo2AiALIAAoAggiASAAKAIARgRAIABBhJOAARCtKAsgACgCBCABQQF0aiACOwEADAELIAMQ5jogAygCAARAIAAoAhxBAWoiBEEDdiAEQQdxQQBHaiIBIAAoAhgiAksEQCABIAJrIQUgACgCECIGIAFJBEAgAyAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAhghAgsgBQRAIAAoAhQgAmpBACAF/AsACyAAIAE2AhgLIAAgBDYCHCAAKAIIIgEgACgCAEYEQCAAQfSSgAEQrSgLIAAoAgQgAUEBdGpBADsBAAwBC0GglYABELI7AAsgACABQQFqNgIIC9gDAQZ/IABBDGohAwJAIAFBAXEEQAJAIAMoAgAEQCAAKAIcIgVBAWoiBkEDdiAGQQdxQQBHaiIBIAAoAhgiBEsEQCABIARrIQcgACgCECIIIAFJBEAgAyAIQQF0IgMgAUHA////A3FBQGsgASABQT9xGyIEIAMgBEsbEOgZIAAoAhghBAsgBwRAIAAoAhQgBGpBACAH/AsACyAAIAE2AhgLIAAgBjYCHCAAKAIUIAVBA3ZqIgEgAS0AAEEBIAVBB3F0cjoAAAwBCyAAIAAoAiBBAWo2AiALIAAoAggiASAAKAIARgRAIABBhJOAARCdKAsgACgCBCABQQJ0aiACNgIADAELIAMQ5jogAygCAARAIAAoAhxBAWoiBEEDdiAEQQdxQQBHaiIBIAAoAhgiAksEQCABIAJrIQUgACgCECIGIAFJBEAgAyAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAhghAgsgBQRAIAAoAhQgAmpBACAF/AsACyAAIAE2AhgLIAAgBDYCHCAAKAIIIgEgACgCAEYEQCAAQfSSgAEQnSgLIAAoAgQgAUECdGpBADYCAAwBC0GglYABELI7AAsgACABQQFqNgIIC9wDAgt/AX4CfyADIAEoAhgiCiAFayIISwRAIAEoAgwiCSAFIAUgCUkbIQ8gASgCICEMIAEoAhAhECABKQMAIRIDQAJAAkAgEiACIAhqIhExAACIQgGDUARAIAEgCDYCGCAFIQcgCCEKIAYNAgwBCyAJIAwgCSAJIAxLGyAGG0EBayINIQcCQAJAAkACQANAIAdBf0YEQCAFIAwgBhsiByAJIAcgCUsbIQ0gCSEHA0AgByANRgRAIAEgCDYCGCAGRQRAIAEgBTYCIAsgACAKNgIIIAAgCDYCBEEBDAwLIAcgD0YNAyAHIAhqIANPDQQgByARaiELIAQgB2ogB0EBaiEHLQAAIAstAABGDQALIAogEGshCiAQIQcgBkUNBgwHCyAFIA1NDQQgByAIaiILIANPDQMgByARaiELIAQgB2ogB0EBayEHLQAAIAstAABGDQALIAogCWsgB2pBAWohCiAFIQcgBkUNBAwFCyAPIAVBmK+IARDDIQALIAMgCCAJaiIAIAAgA0kbIANBqK+IARDDIQALIAsgA0HIr4gBEMMhAAsgByAFQbiviAEQwyEACyABIAc2AiAgByEMCyAKIAVrIgggA0kNAAsLIAFBADYCGEEACyEHIAAgBzYCAAvhFwEVfyMAIgEhGSABQYABa0FAcSIHJAAgBCAEKAIIIhAgA0HuAGxB5ABuakEUahCOLQJAAkAgECAEKAIIIgVNBEAgBCgCBCEBIAdBADYCPCAHIAUgEGs2AjggByABIBBqNgI0AkAgA0H//wNPBEAgB0FAayIFQYAgQdTG0AAQvxUgB0EoaiAFQeTG0AAQmCEgBygCLCINQYAgRiIBQQEgBygCKCIIG0UNAyAHIAggDSABGzYCQCAHQSBqIREgAiEKQQAhASADIg1B7gBsQeQAbkEUaiAHQTRqIgYoAgQgBigCCCIVa0sEf0EBBQJAIA1BDUkNACAFKAIAIAooAABBsfPd8XlsQRJ2Qfz/AHFqQQA2AgBBASICIA1BDGsiEksNACAKQQRqIRYgCkEBayETIApBAmshFyAFKAIAIRQDQCABIQMgAkEBaiEBQSEhBQNAIAIhCSAFIQggASECIBQgCSAKaigAACILQbHz3fF5bEESdkH8/wBxaiIBKAIAIQUgASAJNgIAAkAgCSAFayIYQYCABE8NACALIAUgCmooAABHDQACfyAFRSADIAlPckUEQCAJIBNqIQ8gBSEBIAUgE2ohC0EAIQIDQCABIAJqIQUgAiAJaiIIIAIgD2otAAAgAiALai0AAEcNAhogAkEBayECIAVBAUcgCEEBayADS3ENAAsgASACaiEFIAIgCWoMAQsgCQsiDiADayEMIAogBUEEaiIBaiEFAkACfyAOQQRqIgsgDSABayICIA0gDmtBCmsiAUEAIAEgDU0bIgEgASACSxtqIg8gDkEIakkEQCALDAELIA4gFmohCUEAIQICQANAIAIgCWooAAAiCCACIAVqKAAAIgFGBEAgDyAOIAJBBGoiAmoiAUEIak8NAQwCCwsgDiABIAhzaEEDdmogAmpBBGohAQwCCyACIAVqIQUgAUEEagshAQJAIA8gAWtBAU0NACABIApqLwAAIAUvAABHDQAgBUECaiEFIAFBAmohAQsgASAPTw0AIAEgASAKai0AACAFLQAARmohAQsgFCABIBdqKAAAQbHz3fF5bEESdkH8/wBxaiABQQJrNgIAIAYoAgAgBigCCGpBcCAMQQR0IAxBD08bQQ8gASALayILIAtBD08bcjoAACAGIAYoAghBAWo2AggCQAJAIAxBDk0EQCADIApqIQUgDEEJTw0BIAYoAgAgBigCCGogBSkAADcAAAwCCyAMQQ9rIgVB/AdPBEAgBigCACEIIAVB/AduIgJBAnQiCQRAIAggBigCCGpB/wEgCfwLAAsgBiAGKAIIIAlqNgIIIAUgAkH8B2xrIQULIAYoAgAgBigCCGpBfzYAACAGIAVB//8DcUH/AW4iAiAGKAIIakEBajYCCCAGKAIAIAYoAghqQQFrIAIgBWo6AAAgAyAKaiEFIAxBEUkNACAGKAIAIAYoAghqIQIgDEEZTwRAIAxFDQIgAiAFIAz8CgAADAILIAIgBSkAADcAACACQRBqIAVBEGopAAA3AAAgAkEIaiAFQQhqKQAANwAADAELIAYoAgAgBigCCGoiAiAFKQAANwAAIAJBCGogBUEIaikAADcAAAsgBiAGKAIIIAxqNgIIIAYoAgAgBigCCGogGDsAACAGIAYoAghBAmo2AgggC0EOSwRAIAtBD2siAkH8B08EQCAGKAIAIQUgAkH8B24iA0ECdCIIBEAgBSAGKAIIakH/ASAI/AsACyAGIAYoAgggCGo2AgggAiADQfwHbGshAgsgBigCACAGKAIIakF/NgAAIAYgAkH//wNxQf8BbiIDIAYoAghqQQFqNgIIIAYoAgAgBigCCGpBAWsgAiADajoAAAsgASICIBJNDQIMAwsgCEEBaiEFIAhBBXYgAmohASACIBJNDQALCyADIQELIAYgCiANIAEQ4AogBigCCCAVayEBQQALIQIgESABNgIEIBEgAjYCACAHKAIkIQIgBygCICEDIAcoAkBBgIABQQQQ+DoMAQsgB0FAayIFQYAgQYTH0AAQmRUgB0EYaiAFQZTH0AAQqiEgBygCHCINQYAgRiIBQQEgBygCGCIIG0UNAyAHIAggDSABGzYCQCAHQRBqIREgAiEKQQAhASADIg1B7gBsQeQAbkEUaiAHQTRqIgYoAgQgBigCCCIVa0sEf0EBBQJAIA1BDUkNACAFKAIAIAooAABBsfPd8XlsQRN2Qf4/cWpBADsBAEEBIgIgDUEMayISSw0AIApBBGohFiAKQQFrIRMgCkECayEXIAUoAgAhFANAIAEhAyACQQFqIQFBISEFA0AgAiEJIAUhCCABIQIgFCAJIApqKAAAIgtBsfPd8XlsQRN2Qf4/cWoiAS8BACEFIAEgCTsBAAJAIAkgBWsiGEGAgARPDQAgCyAFIApqKAAARw0AAn8gBUUgAyAJT3JFBEAgCSATaiEPIAUhASAFIBNqIQtBACECA0AgASACaiEFIAIgCWoiCCACIA9qLQAAIAIgC2otAABHDQIaIAJBAWshAiAFQQFHIAhBAWsgA0txDQALIAEgAmohBSACIAlqDAELIAkLIg4gA2shDCAKIAVBBGoiAWohBQJAAn8gDkEEaiILIA0gAWsiAiANIA5rQQprIgFBACABIA1NGyIBIAEgAksbaiIPIA5BCGpJBEAgCwwBCyAOIBZqIQlBACECAkADQCACIAlqKAAAIgggAiAFaigAACIBRgRAIA8gDiACQQRqIgJqIgFBCGpPDQEMAgsLIA4gASAIc2hBA3ZqIAJqQQRqIQEMAgsgAiAFaiEFIAFBBGoLIQECQCAPIAFrQQFNDQAgASAKai8AACAFLwAARw0AIAVBAmohBSABQQJqIQELIAEgD08NACABIAEgCmotAAAgBS0AAEZqIQELIBQgASAXaigAAEGx893xeWxBE3ZB/j9xaiABQf7/A2o7AQAgBigCACAGKAIIakFwIAxBBHQgDEEPTxtBDyABIAtrIgsgC0EPTxtyOgAAIAYgBigCCEEBajYCCAJAAkAgDEEOTQRAIAMgCmohBSAMQQlPDQEgBigCACAGKAIIaiAFKQAANwAADAILIAxBD2siBUH8B08EQCAGKAIAIQggBUH8B24iAkECdCIJBEAgCCAGKAIIakH/ASAJ/AsACyAGIAYoAgggCWo2AgggBSACQfwHbGshBQsgBigCACAGKAIIakF/NgAAIAYgBUH//wNxQf8BbiICIAYoAghqQQFqNgIIIAYoAgAgBigCCGpBAWsgAiAFajoAACADIApqIQUgDEERSQ0AIAYoAgAgBigCCGohAiAMQRlPBEAgDEUNAiACIAUgDPwKAAAMAgsgAiAFKQAANwAAIAJBEGogBUEQaikAADcAACACQQhqIAVBCGopAAA3AAAMAQsgBigCACAGKAIIaiICIAUpAAA3AAAgAkEIaiAFQQhqKQAANwAACyAGIAYoAgggDGo2AgggBigCACAGKAIIaiAYOwAAIAYgBigCCEECajYCCCALQQ5LBEAgC0EPayICQfwHTwRAIAYoAgAhBSACQfwHbiIDQQJ0IggEQCAFIAYoAghqQf8BIAj8CwALIAYgBigCCCAIajYCCCACIANB/AdsayECCyAGKAIAIAYoAghqQX82AAAgBiACQf//A3FB/wFuIgMgBigCCGpBAWo2AgggBigCACAGKAIIakEBayACIANqOgAACyABIgIgEk0NAgwDCyAIQQFqIQUgCEEFdiACaiEBIAIgEk0NAAsLIAMhAQsgBiAKIA0gARDgCiAGKAIIIBVrIQFBAAshAiARIAE2AgQgESACNgIAIAcoAhQhAiAHKAIQIQMgBygCQEGAwABBAhD4OgsgAAJ/IANBAXEEQCAAQeja0AA2AgggAEEBNgIEQQUMAQsgBCACIBBqEPQ0QQgLNgIAIBkkAA8LIBAgBUHI2tAAEK87AAsgByANNgJEIAcgCDYCQEH0otAAQSsgB0FAa0Ggo9AAQfTG0AAQ1R4ACyAHIA02AkQgByAINgJAQfSi0ABBKyAHQUBrQeSi0ABBpMfQABDVHgAL7wMBAn8CQAJ/AkACQAJAAkACQCAAKAIAIgFBH3UgAUH/////B2txDgQBAgMEAAsgACgCDCICBEAgACgCCCEBA0AgARDiCyABQcgAaiEBIAJBAWsiAg0ACwsgAEEEakEEQcgAEOAeIAAoAhQiAUUNBSABIAEoAgAiAUEBazYCACABQQFHDQUgAEEUagwECyAAQQxqELQwIABBGGoQtDAgABDpOyAAKAIkIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSRqELsjCyAAKAIsIgFFDQQgASABKAIAIgFBAWs2AgAgAUEBRw0EIABBLGoMAwsgACgCBBDiCyAAKAIEQcgAQQQQ+DogACgCCCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEIahD7HgsgACgCGCIBRQ0DIAEgASgCACIBQQFrNgIAIAFBAUcNAyAAQRhqDAILIAAoAgQQ4gsgACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNAiABIAEoAgAiAUEBazYCACABQQFHDQIgAEEYagwBCyAAKAIEEOILIAAoAgRByABBBBD4OiAAKAIQIgFFDQEgASABKAIAIgFBAWs2AgAgAUEBRw0BIABBEGoLEPseCwuWBAIEfwF+IwBB4ABrIgIkACAAKAIIIQNBASEEIAApAwAiBkIAWQR/QQEFQn9CACADGyAGfSEGQYCU69wDIANrQQAgAxshA0EBIQVBgMWGAQshACACIAM2AgggAiAGNwMAIAIgBTYCGCACIAA2AhQgAkECNgJMIAJBhMWGATYCSCACQgE3AlQgAkHHAjYCJCACIAJBIGo2AlAgAiACQRRqNgIgAkAgASgCACIAIAEoAgQiBSACQcgAahDLCg0AIAMgBkIAUnJFBEAgAUGUxYYBQQIQ+zUhBAwBCyACQQE2AkwgAkGYxYYBNgJIIAJCATcCVCACQe4GNgIkIAIgAkEgajYCUCACIAI2AiAgACAFIAJByABqEMsKDQAgAigCCCIDQQBKBEACQCADQQpwRQRAQQkhAANAIABBAWshACADQQpuIgNBCnBFDQALIAIgAzYCHCAAQYCABEkNASACQQA2AlggAkEBNgJMIAJB+MSGATYCSCACQgQ3AlAgAkHIAGpBoMWGARDvLAALIAIgAzYCHEEJIQALIAIgADsBRCACQQA2AkAgAkGcAzYCPCACQQE2AjQgAkG8xYYBNgIwIAJBATYCJCACQbTFhgE2AiAgAkECNgIsIAIgAkEcajYCOCACIAJBOGo2AiggASgCACABKAIEIAJBIGoQywoNAQsgAUHUxYYBQQEQ+zUhBAsgAkHgAGokACAEC+EDAQ1/IwBBEGsiByQAAkAgAS0AJQ0AAkAgASgCECIEIAEoAgwiAkkNACAEIAEoAggiCEsNACABKAIEIQwgAUETaiENIAFBFGohDgNAIAEoAgQgAmohCiANIAEtABgiBmotAAAhBQJAAkACQCAEIAJrIgtBB00EQCACIARGDQFBACEDA0AgAyAKai0AACAFRg0EIAsgA0EBaiIDRw0ACwwBCyAHQQhqIAUgCiALEJ0SIAcoAghBAXENASABKAIQIQQLIAEgBDYCDAwDCyAHKAIMIQMgAS0AGCEGIAEoAgghCCABKAIMIQILIAEgAiADakEBaiICNgIMAkAgAiAGSSACIAhLcg0AIAZBBUkEQCACIAZrIgQgASgCBGogBiAOIAYQwS4hAyABKAIMIQIgA0UEQCABKAIIIQgMAgsgASgCHCEFIAEgAjYCHCAFIAxqIQkgBCAFayEDDAQLIAZBBEG4nMQAELA7AAsgASgCECIEIAJJDQEgBCAITQ0ACwsgAS0AJQ0AIAFBAToAJQJAIAEtACRBAUYEQCABKAIgIQIgASgCHCEFDAELIAEoAiAiAiABKAIcIgVGDQELIAIgBWshAyABKAIEIAVqIQkLIAAgAzYCBCAAIAk2AgAgB0EQaiQAC+EDAQ1/IwBBEGsiByQAAkAgAS0AJQ0AAkAgASgCECIEIAEoAgwiAkkNACAEIAEoAggiCEsNACABKAIEIQwgAUETaiENIAFBFGohDgNAIAEoAgQgAmohCiANIAEtABgiBmotAAAhBQJAAkACQCAEIAJrIgtBB00EQCACIARGDQFBACEDA0AgAyAKai0AACAFRg0EIAsgA0EBaiIDRw0ACwwBCyAHQQhqIAUgCiALEJ0SIAcoAghBAXENASABKAIQIQQLIAEgBDYCDAwDCyAHKAIMIQMgAS0AGCEGIAEoAgghCCABKAIMIQILIAEgAiADakEBaiICNgIMAkAgAiAGSSACIAhLcg0AIAZBBUkEQCACIAZrIgQgASgCBGogBiAOIAYQwS4hAyABKAIMIQIgA0UEQCABKAIIIQgMAgsgASgCHCEFIAEgAjYCHCAFIAxqIQkgBCAFayEDDAQLIAZBBEHstIABELA7AAsgASgCECIEIAJJDQEgBCAITQ0ACwsgAS0AJQ0AIAFBAToAJQJAIAEtACRBAUYEQCABKAIgIQIgASgCHCEFDAELIAEoAiAiAiABKAIcIgVGDQELIAIgBWshAyABKAIEIAVqIQkLIAAgAzYCBCAAIAk2AgAgB0EQaiQAC+oKAQJ/IwBBEGsiAyQAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkADQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDigBAgMTDgIDEw4DEw4OEw4TDg4EBwUIBgcIBhMJCg4LDBYNEw4QERMSAAsgAEEAOwEMIABBADYCCCAAQoCAgIDAADcCAAwZC0EMQQQQrTYiAUUNGSAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAgAUECNgIADBgLQQxBBBCtNiIBRQ0YIAFBATYCCCABQoCAgIAQNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwXC0EMQQQQrTYiAUUNFyABQQI2AgggAUKAgICAIDcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMFgsgAS0AAUEBaw4CDxAOCyABKAIEIgJBAEgNEUEMQQQQrTYiAUUNFSABQQE2AgggASACNgIEIAFBADYCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMFAtBDEEEEK02IgFFDRQgAUEQNgIIIAFCgICAgIACNwIAIABBgQI7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMEwtBGEEEEK02IgFFDRQgAUKEgICAEDcCCCABQoCAgIDAADcCACAAQQE7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEgtBGEEEEK02IgFFDRMgAUKIgICAEDcCCCABQoCAgICAATcCACAAQQE7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEQtBGEEEEK02IgFFDRIgAUKEgICAwAA3AhAgAUIENwIIIAFCgICAgMAANwIAIABBgQI7AQwgAEECNgIIIAAgATYCBCAAQQI2AgAMEAsgAEEBOwEMIABBADYCCCAAQoCAgIDAADcCAAwPC0EYQQQQrTYiAUUNECABQoiAgICAATcCECABQgg3AgggAUKAgICAgAE3AgAgAEGBAjsBDCAAQQI2AgggACABNgIEIABBAjYCAAwOCyAAQQE7AQwgAEEANgIIIABCgICAgMAANwIADA0LIAEoAgQhAQwBCwtBDEEEEK02IgFFDQsgAUEINgIIIAFCgICAgIABNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwKC0EMQQQQrTYiAUUNCiABQRA2AgggAUKAgICAgAI3AgAgAEEBOwEMIABBATYCCCAAIAE2AgQgAEEBNgIADAkLQQxBBBCtNiIBRQ0JIAFBEDYCCCABQoCAgICABDcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMCAsgAEEAOwEMIABBADYCCCAAQoCAgIDAADcCAAwHC0EMQQQQrTYiAUUNByABQQQ2AgggAUKAgICAwAA3AgAgAEEBOwEMIABBATYCCCAAIAE2AgQgAEEBNgIADAYLQQxBBBCtNiIBRQ0GIAFBBDYCCCABQoCAgICAATcCACAAQQE7AQwgAEEBNgIIIAAgATYCBCAAQQE2AgAMBQtBDEEEEK02IgFFDQUgAUEINgIIIAFCgICAgIACNwIAIABBATsBDCAAQQE2AgggACABNgIEIABBATYCAAwECyABLQABDQFBDBDLLyIBQQE2AgggAUKAgICAEDcCAEEBDAILQejahgFBKyADQQ9qQdjahgFBjISHARDVHgALQRgQyy8iAUKEgICAwAA3AhAgAUIBNwIIIAFCgICAgBA3AgBBAgshAiAAQQA7AQwgACACNgIIIAAgATYCBCAAIAI2AgALIANBEGokAA8LQQRBDBCjPQALQQRBGBCjPQAL1wMCBn4DfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIIAEoAgA2AkwgCEEIaiIAIAhBzABqIgpBBBC7CSAIIAEoAgQ2AkwgACAKQQQQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvgAwIIfgR/IwBBMGsiCyQAQoCAgICAgICAgH8hBQJAAkACfgJAAkAgACgCBCgCECABQQR0aiIKKQMAIgcgCikDCCIIQoCAgICAgICAgH+FhEIAUiAAKAIAIg0oAgAiCigCACIMKQMIIgIgDCkDACIDg0J/UnJFBEBCACECDAELIAIgA4RQDQMgC0EgaiAHIAggAyACEIMZIAtBEGogCykDICIEIAspAygiBSADIAIQqB5CACAHIAspAxAiCX0gAiADg0J/USIMGyEGQgAgCCALKQMYfSAHIAlUrX0gDBshAiAIQgBZDQELIAQgBiAKKAIIIgopAwBYIAIgCikDCCIDVyACIANRG60iA30hAiAFIAMgBFatfQwBCyAFIAQgBiAKKAIEIgopAwBaIAIgCikDCCIDWSACIANRG618IgIgBFStfAshBAJAIAIgBCANKAIELQAAEP8gBEAgACgCCCABQQR0aiIAIAQ3AwggACACNwMADAELIAAoAhAiCiAKKAIAQQFqNgIAIAtBCGogACgCFBCGPSABQQN2IgAgCygCDCIKTw0CIAsoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyALQTBqJAAPC0HMj/8AEOIrAAsgACAKQYiL/wAQwyEAC9gJAQx/IwBB0ABrIgIkAEEBIQMCQCABKAIAIgpBjPqFAUEMIAEoAgQoAgwiCxEGAA0AIApBmPqFAUENIAsRBgANACAKQaX6hQFBAiALEQYADQAjAEEwayIGJAACQAJAIAAoAhgiB0UNAEEKIAcgB0EKTxshDCABKAIEIQ0gASgCACEEAkADQCAAIAgQlCUhCSANKAIMIQUCQCAJRQRAQQEhCSAEQfDDhAFBAiAFEQYADQUgBEGcnYQBQQUgBREGAA0FIARB8sOEAUECIAURBgANBQwBCyAEQfTDhAFBCCAFEQYADQILIAwgCEEBaiIIRw0ACyAHQQtJDQEgB0EVTwRAIAZBAjYCECAGQeDDhAE2AgwgBkIBNwIYIAZBOzYCKCAGIAdBFGs2AiwgBiAGQSRqNgIUIAYgBkEsajYCJCAEIA0gBkEMahDLCg0BCyAHQQprIgggDCAIIAxLGyIIIAdPDQEDQAJAIAAgCBCUJUUEQEEBIQkgBEHww4QBQQIgBREGAA0FIARBnJ2EAUEFIAURBgANBSAEQfLDhAFBAiAFEQYADQUMAQsgBEH0w4QBQQggBREGAA0CCyAIQQFqIgggB0cNAAsMAQtBASEJDAELQQAhCQsgBkEwaiQAIAkNACAKQaf6hQFBBCALEQYADQAgAkEIaiEGIwBBIGsiBCQAAkAgAC0ADEEgRgRAIAQgAEEQahDDNCAEKAIAIgMhByADIAQoAgRBAnRqIQUjAEEgayIDJAAgA0EUaiAFIAdrQQJ2QQBBBEEIEKAYIAMoAhghCCADKAIUQQFGBEAgCCADKAIcQdDqhQEQ/S8ACyADQRBqIgtBADYCACADIAMoAhw2AgwgAyAINgIIIANBCGoiCCAFIAdrQQJ2IgkQ/y0gCCgCCCEKIAggBSAHRwR/IAkgCmogCCgCBCAKQQN0aiEFA0AgBSAHKAIAKQJANwIAIAdBBGohByAFQQhqIQUgCUEBayIJDQALBSAKCzYCCCAGQQhqIAsoAgA2AgAgBiADKQIINwIAIANBIGokACAEQSBqJAAMAQsgBEEANgIYIARBATYCDCAEQZT4hQE2AgggBEIENwIQIARBCGpBnPiFARDvLAALAkACQCACKAIQIgMEQCACKAIMIQYgA0EDdCEHIAAoAgQhAyAAKAIIIQRBACEAA0AgAiAANgIUIAIgBjYCGCAAIARGDQMgAiADKAIAIANBBGoiBSgCACIIKAIIQQFrQXhxakEIaiAIKAIcEQQANgI0IAJBBDYCICACQbz6hQE2AhwgAkIDNwIoIAJBrwM2AkwgAkGDETYCRCACQTs2AjwgAiACQThqNgIkIAIgAkE0ajYCSCACIAJBGGo2AkAgAiACQRRqNgI4IAEoAgAgASgCBCACQRxqEMsKDQIgAygCACAFKAIAIgUoAghBAWtBeHFqQQhqIAEgBSgCDBECAA0CIAEoAgBB3PqFAUEBIAEoAgQoAgwRBgANAiAGQQhqIQYgAEEBaiEAIANBCGohAyAHQQhrIgcNAAsLIAJBCGoQ6jsgAkEANgJIIAJBATYCPCACQcTuhQE2AjggAkIENwJAIAEgAkE4ahDROSEDDAILIAJBCGoQ6jtBASEDDAELIAQgBEGw94UBEMMhAAsgAkHQAGokACADC8wDAgN/An4CQAJAAkAgBEEBaw4CAQACC0KBBCACIAMbIAIgAkJ/URshAgwBC0EAIQMLAkACQCADQYCAgIACSyACQoCAgIACVnJFBEAgASgCACIGQQZBICADIAKnaiIHQQFrZ2sgB0HAAEkbIgcgBiAHSRshBgwBCyABKAIAIQYgAkJ/UQ0BCyABIAEoAggiCAJ/IAYgA0UNABogBkIBIAathiIJIAIgA60iCnxaDQAaQR4gCSAKfCICQv////8DVg0AGkEgIAKnQQFrZ2sLIgdBAWoiAyADIAhLGzYCCCABKAIEIAEoAhhBBUsiA2sgB00NACABIAdBf0EAIAMbazYCBAsgAUEKIAYgBkEKTRs2AgAgBEECRyABKAIYIgRBA2tBfklyRQRAIAFBGCABKAIIIgMgA0EYTxs2AgggAUEYIAEoAgQiAyADQRhPGzYCBAsgBEEGa0F9SSAFQQFLckUEQCABIAEoAggiBEEEQQYgASgCDCIDIANBBk8bIgMgA0EETRtBGHIiAyADIARLGzYCCAsgACABKQIANwIAIABBGGogAUEYaigCADYCACAAQRBqIAFBEGopAgA3AgAgAEEIaiABQQhqKQIANwIAC/UDAQN/IwBBgAJrIgMkACADQRBqIgQgASACKAIUEQAAIANB1ABqIgEgBBDRDSABENI8IQVBACEBIAMoAnQiBEEQTwRAIAMoAnAhAiAEQQR2IQQDQCABIAIoAgBqIQEgAkEQaiECIARBAWsiBA0ACwsgA0GQAWogBSABEKYUIANBxAFqIANB1ABqENgqAkACQAJAIAMoAuABIgIgAygC5AEiAUYEQCADKALIASEEDAELIAMoAsgBIQQDQAJAAkAgBARAIAIgAygC2AFPDQUgAygCzAEgAiADKALUAWoiBUEDdmotAABB/wFzIAVBB3F2QQFxDQELIAMgAkEBajYC4AEgA0EIaiADKALEASACEKwfIANBkAFqIAMoAgggAygCDBD9EgwBCyADIAJBAWo2AuABIANBkAFqEKYVCyABIAJBAWoiAkcNAAsLAkAgBEUNACAEIAQoAgAiAUEBazYCACABQQFHDQAgA0HIAWoQ+x4LIANBxAFqIgIgA0GQAWoiBBDrDkHEAEEEEK02IgFFDQEgAUKBgICAEDcCACABQQhqIAJBPPwKAAAgAEGg4f8ANgIIIAAgATYCBCAAQZOAgIB4NgIAIAQQuiwgA0HUAGoQ3iIgA0GAAmokAA8LQfzA/wBBIEGcwf8AEJ8pAAtBBEHEABCjPQAL9QMBA38jAEGAAmsiAyQAIANBEGoiBCABIAIoAhQRAAAgA0HUAGoiASAEENENIAEQ0jwhBUEAIQEgAygCdCIEQRBPBEAgAygCcCECIARBBHYhBANAIAEgAigCAGohASACQRBqIQIgBEEBayIEDQALCyADQZABaiAFIAEQpRQgA0HEAWogA0HUAGoQ2CoCQAJAAkAgAygC4AEiAiADKALkASIBRgRAIAMoAsgBIQQMAQsgAygCyAEhBANAAkACQCAEBEAgAiADKALYAU8NBSADKALMASACIAMoAtQBaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXENAQsgAyACQQFqNgLgASADQQhqIAMoAsQBIAIQrB8gA0GQAWogAygCCCADKAIMEP4SDAELIAMgAkEBajYC4AEgA0GQAWoQpxULIAEgAkEBaiICRw0ACwsCQCAERQ0AIAQgBCgCACIBQQFrNgIAIAFBAUcNACADQcgBahD7HgsgA0HEAWoiAiADQZABaiIEEOwOQcQAQQQQrTYiAUUNASABQoGAgIAQNwIAIAFBCGogAkE8/AoAACAAQfjh/wA2AgggACABNgIEIABBk4CAgHg2AgAgBBC7LCADQdQAahDeIiADQYACaiQADwtB/MD/AEEgQZzB/wAQnykAC0EEQcQAEKM9AAvRAwEIfyMAQaABayICJAAgAkEQaiABQcQA/AoAACACQoCAgICQAjcCCEERIQUgAiAAQREQnxggAigCACACKAIEEIAtIABByABqIQgCfyAAKAJIIgFBEU0EQCABIQQgCCEGIABBBGoMAQsgAEEEaiEGIAAoAgQhBCABIQUgACgCCAshAwJAAkAgBCAFTwRAIAQhBQwBCyAEIAVrQQFqIQkgAyAEQQJ0aiEHQQAhA0EIIQECQANAIAEgB2pBCGsgAkEIaiABaigCADYCACADIAlqRQ0BIAFBBGohASADQQFqIgNBEUcNAAsgBiADIARqNgIADAILIAIgA0EBajYCCAsgBiAFNgIAIAJB1ABqIAJBCGpBzAD8CgAAIAIoAlQiASACKAJYRg0AIABBBGohBCACQdwAaiEJA0AgAiABQQFqNgJUIAkgAUECdGoCfyAIKAIAIgVBEkkEQCAFIQEgBCEGQREhBSAIDAELIAAoAgQhASAAKAIIIQYgBAshAygCACEHIAEgBUYEfyAAEPwfIAAoAgghBiAEIQMgACgCBAUgAQtBAnQgBmogBzYCACADIAMoAgBBAWo2AgAgAigCVCIBIAIoAlhHDQALCyACQaABaiQAC6cEAgZ+BX8jAEHQAGsiCCQAIAhBQGsiC0IANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggASgCBCEMIAggASgCCCIBNgJMIAhBCGoiACAIQcwAakEEELsJIwBBEGsiCSQAIAEEQCABQQxsIQogDEEIaiEBA0AgACABQQRrKAIAIAEoAgAQuwkgCUH/AToADyAAIAlBD2pBARC7CSABQQxqIQEgCkEMayIKDQALCyAJQRBqJAAgCCkDCCEDIAgpAxghAiALNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvDAwEMfwJAIAIgA0EBaiIESwRAIAEvAQIhBSABIARBAnRqQf//AzsBAkEEQQMgBRshCkEHQYoBIAUbIQQgAEEEaiELQX8hBgwBCyAEIAJBjPj7ABDDIQALA0AgBiEJIAUhCCAEQf//A3EhBkEAIQQCQAJAAkACQANAIAQhDSAMIAMgB0lyDQEgB0EBaiIFIAJPDQIgAyAHTSEMIAcgAyAHS2ohByABIAVBAnRqLwECIgUgCEH//wNxIg9GIAYgBEEBaiIEQf//A3EiDktxDQALIA8hBiAKQf//A3EgDk0EQAJAIAYiBEUEQCANQf//A3FBCkkNASAAIAAvAUxBAWo7AUwMBgsCQCAGIAlHBEAgBEEnTw0BIAsgBkECdGoiBCAELwEAQQFqOwEACyAAIAAvAURBAWo7AUQMBgsgBkEnQaz4+wAQwyEACyAAIAAvAUhBAWo7AUgMBAsgCEH//wNxQSdJDQIgBkEnQbz4+wAQwyEACw8LIAUgAkGc+PsAEMMhAAsgCyAGQQJ0aiIJIAkvAQAgBGo7AQALQQZBByAIQf//A3EgBUYiCBtBigEgBRshBEEDQQQgCBtBAyAFGyEKDAALAAvPAwEGfyAAQQxqIQMCQCABBEACQCADKAIABEAgACgCHCIFQQFqIgZBA3YgBkEHcUEAR2oiASAAKAIYIgRLBEAgASAEayEHIAAoAhAiCCABSQRAIAMgCEEBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACABNgIYCyAAIAY2AhwgACgCFCAFQQN2aiIBIAEtAABBASAFQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgEgACgCAEYEQCAAQYSTgAEQqRkLIAAoAgQgAWogAjoAAAwBCyADEOY6IAMoAgAEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIYIgJLBEAgASACayEFIAAoAhAiBiABSQRAIAMgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIYIQILIAUEQCAAKAIUIAJqQQAgBfwLAAsgACABNgIYCyAAIAQ2AhwgACgCCCIBIAAoAgBGBEAgAEH0koABEKkZCyAAKAIEIAFqQQA6AAAMAQtBoJWAARCyOwALIAAgAUEBajYCCAvPAwEGfyAAQQxqIQMCQCABBEACQCADKAIABEAgACgCHCIFQQFqIgZBA3YgBkEHcUEAR2oiASAAKAIYIgRLBEAgASAEayEHIAAoAhAiCCABSQRAIAMgCEEBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSAAKAIYIQQLIAcEQCAAKAIUIARqQQAgB/wLAAsgACABNgIYCyAAIAY2AhwgACgCFCAFQQN2aiIBIAEtAABBASAFQQdxdHI6AAAMAQsgACAAKAIgQQFqNgIgCyAAKAIIIgEgACgCAEYEQCAAQYSTgAEQoygLIAAoAgQgAWogAjoAAAwBCyADEOY6IAMoAgAEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIYIgJLBEAgASACayEFIAAoAhAiBiABSQRAIAMgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIYIQILIAUEQCAAKAIUIAJqQQAgBfwLAAsgACABNgIYCyAAIAQ2AhwgACgCCCIBIAAoAgBGBEAgAEH0koABEKMoCyAAKAIEIAFqQQA6AAAMAQtBoJWAARCyOwALIAAgAUEBajYCCAuhBAEDfyMAQRBrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0ASEEBaw4DBwIBAAsgACAAKQIANwIoIABBQGsgAEEYaikCADcCACAAQThqIABBEGopAgA3AgAgAEEwaiAAQQhqKQIANwIACyAAQShqIQMgAC0AREEBaw4DBAACAQsACyADKAIAIgIoAggNBCACQX82AgggACACQQhqNgI0IAAgAkEMaiICNgIwIABBADoAQCAAIAI2AjggACAAKAIsIgQ2AjwMAQsgAC0AQEEBcQ0EIAAoAjwhBCAAKAI4IQILIAIoAgAEQCACELwqCyACQQA2AgAgBEGEAU8EQCAEEPIfCyAAQQE6AEAgACgCNCICIAIoAgBBAWo2AgAgACgCKCICIAIoAgBBAWsiAjYCACACRQRAIAMQ1CILIABBAToARCADENocIAFBgAE2AgggAUGAATYCDCABIABBIGoiAiABQQxqIAFBCGoQwiMgASgCAEEBcQ0EAkAgASgCBCIDQYQBSQ0AIAMQ8h8gASgCDCIDQYQBSQ0AIAMQ8h8LIAEoAggiA0GEAU8EQCADEPIfCyACKAIAIgJBhAFPBEAgAhDyHwsgACgCJCICQYQBTwRAIAIQ8h8LIABBAToASCABQRBqJABBAA8LQcjewwAQ6CsAC0Ho3cMAEOgrAAtB1NvDAEExEJc9AAtBmN7DABDoKwALQdTbwwBBMRCXPQAL3AYBCX8jAEEwayIDJAACQAJAAkACQAJAAkAgAigCAEGAgICAeEcEQCADQRBqIAJBCGooAgAiBDYCACADIAIpAgA3AwggASgCACIFKAIAIgFFDQIgA0EkaiABQQBBBEEMEKAYIAQgAW4hAiADKAIoIQEgAygCJEEBRg0BIANBADYCICADIAMoAiw2AhwgAyABNgIYIAUoAgAiBwRAIAJBA3QhCCADKAIMIQtBACEBA0AgASACbCIFIAJqIgYgBUkNBSAEIAZJDQYgA0EkaiACQQBBCEEIEKAYIAMoAighBiADKAIkQQFGDQcgAygCLCEJIAgEQCAJIAsgBUEDdGogCPwKAAALIAMoAiAiBSADKAIYRgRAIANBGGpB7MrNABCQKAsgAygCHCAFQQxsaiIKIAI2AgggCiAJNgIEIAogBjYCACADIAVBAWo2AiAgAUEBaiEBIAdBAWsiBw0ACwsgACADKQIYNwIAIABBCGogA0EgaigCADYCACADQQhqEOM8DAYLIANBgICAgHg2AiQgASgCACgCACEBIwBBIGsiAiQAIAJBFGogAUEAQQRBDBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEH8ys0AEP0vAAsgAkEQaiIKQQA2AgAgAiACKAIcNgIMIAIgBDYCCCADQSRqIQcjAEEQayIIJAAgAkEIaiIFKAIAIAUoAggiBGsgAUkEQCAFIAQgAUEEQQwQ0CggBSgCCCEECyAFKAIEIARBDGxqIQYCQAJAIAFBAk8EQCABQQFrIQkDQAJAIAcoAgBBgICAgHhHBEAgCEEEaiAHEKUdDAELIAhBgICAgHg2AgQLIAYgCCkCBDcCACAGQQhqIAhBDGooAgA2AgAgBkEMaiEGIAlBAWsiCQ0ACyABIARqQQFrIQQMAQsgAQ0AIAUgBDYCCCAHEIUwDAELIAYgBykCADcCACAGQQhqIAdBCGooAgA2AgAgBSAEQQFqNgIICyAIQRBqJAAgAEEIaiAKKAIANgIAIAAgAikCCDcCACACQSBqJAAMBQsgASADKAIsQczKzQAQ/S8AC0G8ys0AEOIrAAsgBSAGQdzKzQAQsTsACyAGIARB3MrNABCwOwALIAYgAygCLEH8u80AEP0vAAsgA0EwaiQAC8EGAgV/A34jAEHgAWsiByQAAkACQAJAIAJB/wFxIghBAUYgCEEHRnJFBEAgB0HYAWogA0EIaikCADcDACAHIAMpAgA3A9ABIAdBgAFqIAIgB0HQAWogBCAFIAYgAS0AZBD8AiAHQYgBaiECIAcpA4ABIgxCBlINASAHQdAAaiACQRBqKQMAIgw3AwAgB0HIAGogAkEIaikDACINNwMAIAcgAikDACIONwNAIABBEGogDDcDACAAQQhqIA03AwAgACAONwMADAMLIAMoAghFDQEgAygCBC0AACECIAdBADYCuAEgB0IANwOwASAHQQA2ApABIAcgAjoAvAEgB0IANwOAASAHQUBrIgIgA0EBEOoUIwBBQGoiCCQAIAdBgAFqIglBEGohCgJAIAkoAhAiCwRAIAlBHGogCSgCFCAJKAIYIAsoAhARAQAgCUIANwMgIAlBKGpCADcDACAKQQhqIAJBCGopAgA3AgAgCiACKQIANwIADAELIAhBEGpCADcDACAIQRhqQgA3AwAgCiACKQIAIgw3AwAgCkEQakIANwMAIApBGGpCADcDACAIQQhqIAJBCGopAgAiDTcDACAKQQhqIA03AwAgCCAMNwMACwJAAkAgCigCAARAIAhBIGogChClGAJAIAgoAiBBAUcNACAIKQMoIgxQDQAgDEIBg1BFBEAgCSAMp0ECdEF4cTYCOAwBCyAJIAxCAYg+AjQgCEEwaiAKIAktADwiAkEDdiACQQdxQQBHahDBHCAIKQMwIQwgCSAIKQM4NwMIIAkgDDcDACAMp0UNAgsgCEFAayQADAILQdrtzQBBGEH07c0AEMskAAtBhO7NAEEuQbTuzQAQnykACyAHIAlBwAD8CgAAIAEQ2RUgAUIGNwMAIAFBCGogB0HAAPwKAAAgAEEINgIAIAEgBiAEIAVBAXEbNgJIIANBDGogAygCBCADKAIIIAMoAgAoAhARAQAMAgsgB0FAayACQcAA/AoAACAHKQPIASENIAcgB0FAa0HAAPwKAAAgARDZFSABIAw3AwAgAUEIaiAHQcAA/AoAACAAQQg2AgAgASANNwNIDAELQQBBAEHE1M0AEMMhAAsgB0HgAWokAAvEAwEDfyMAQYAIayIJJAAgCUEAQYAI/AsAAkAgAkGAgAJPBEADQCABIAhNBEAgCCABQaTezgAQwyEACyAJIAAgCGotAABBAnRqIgogCigCAEEBajYCACAIQR1qIgggAkkNAAsgAkEcakEdbiECQQAhCANAIAggCWoiAEELIAAoAgAiACAAQQtPG0EBdEEBciIBIABqNgIAIAEgAmohAiAIQQRqIghBgAhHDQALDAELIAIEQANAIAEgCEYEQCABIAFB1N7OABDDIQALIAkgACAIai0AAEECdGoiCiAKKAIAQQFqNgIAIAIgCEEBaiIIRw0ACwtBACEIA0AgCCAJaiIAQQsgACgCACIAIABBC08bQQF0IgEgAGo2AgAgASACaiECIAhBBGoiCEGACEcNAAsLIAlBgAIgAkEIIANBgAIgBEGAAiAFIAYgBxCjAkEAIQAgCSEBQQAhCAJAAkADQCABKAIAIgQEQCAIQYACTw0CIAQgAyAIai0AAGwgAGohAAsgAUEEaiEBIAhBAWoiCEGAAkcNAAsgAkUNASAJQYAIaiQAIABB/QBsIAJuDwsgCEGAAkHE3s4AEMMhAAtBtN7OABDiKwAL1wMCBX8BfiMAQeAAayICJAAgAkEANgIUIAJCgICAgBA3AgwgAkHIAGogARCNDSACQUBrIgMgAkHUAGoiBCkCADcDACACIAIpAkw3AzgCQAJAIAIoAkgiBUEIRwRAIAIoAlwhASAAIAIpAzg3AgQgACABNgIUIAAgBTYCACAAQQxqIAMpAwA3AgAMAQsgAkEgaiADKQMAIgc3AwAgAiACKQM4NwMYIAJBDGogAigCHCIFIAenIgYQoTYgAkHIAGogAUHgAGoQ/wwgAyAEKQIANwMAIAIgAikCTDcDOCACKAJIIgNBCEcEQCACKAJcIQEgACACKQM4NwIEIAAgATYCFCAAIAM2AgAgAEEMaiACQUBrKQMANwIAIAJBJGogBSAGIAIoAhgoAhARAQAMAQsgAkEwaiACQUBrKQMAIgc3AwAgAiACKQM4NwMoIAJBDGogAigCLCIDIAenIgQQoTYgAUEANgLYASACQdAAaiACQRRqKAIANgIAIAIgAikCDDcDSCAAQQRqIAJByABqEOcVIABBCDYCACACQTRqIAMgBCACKAIoKAIQEQEAIAJBJGogAigCHCACKAIgIAIoAhgoAhARAQAMAQsgAkEMahDeOwsgAkHgAGokAAvLAwEKfyMAQYABayIDJABBYiEKAkAgAkEJSQ0AIABBmNAAaiABQQhqIgUgAkEIayAAQZjQABCFBCILQYh/Sw0AIANBHzYCfCADIANB/ABqIgcgA0H4AGoiCCAFIAtqIgUgASACaiICIAVrEII3IgxBiH9LDQAgAygCfCIBQR9LDQAgAygCeCIGQQlPDQAgAEGIIGogAyABQcCw0QBBwLHRACAGIABBqNABaiIGEOYIIANBNDYCfCADIAcgCCAFIAxqIgEgAiABaxCCNyIFQYh/Sw0AIAMoAnwiBEE0Sw0AIAMoAngiCUEKTw0AIABBkDBqIAMgBEHgsdEAQcCz0QAgCSAGEOYIIANBIzYCfCADIAcgCCABIAVqIgQgAiAEaxCCNyIJQYh/Sw0AIAMoAnwiB0EjSw0AIAMoAngiCEEKTw0AQQAhASAAIAMgB0GAtNEAQZC10QAgCCAGEOYIIAQgCWoiBkEMaiIEIAJLDQAgAEGc0AFqIQAgAiAEayECA0AgAUEMRwRAIAEgBmooAAAiBEEBayACTw0CIAAgAWogBDYCACABQQRqIQEMAQsLIAsgDGogBWogCWogAWpBCGohCgsgA0GAAWokACAKC88DAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEEIaiIAIAEoAgQgASgCCBC7CSAIQf8BOgBPIAAgCEHPAGpBARC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8oDAgx/AX4CfyADIAEoAhQiCCAFQQFrIg1qIgdLBEAgBSABKAIQIg5rIQ8gASgCHCELIAEoAgghCiABKQMAIRMDQAJAAkAgEyACIAdqMQAAiEIBg1AEQCABIAUgCGoiCDYCFEEAIQcgBg0CDAELIAogCyAKIAogC0kbIAYbIgkgBSAFIAlJGyEMIAIgCGohECAJIQcCQAJAAkADQCAHIAxGBEBBACALIAYbIQwgCiEHA0AgByAMTQRAIAEgBSAIaiICNgIUIAZFBEAgAUEANgIcCyAAIAI2AgggACAINgIEQQEMCwsgB0EBayIHIAVPDQUgByAIaiIJIANPDQMgBCAHai0AACACIAlqLQAARg0ACyABIAggDmoiCDYCFCAPIQcgBkUNBQwGCyAHIAhqIANPDQIgByAQaiERIAQgB2ogB0EBaiEHLQAAIBEtAABGDQALIAggCmsgB2ohCCAGDQRBACEHDAMLIAkgA0HQxsMAEMMhAAsgAyAIIAlqIgAgACADSRsgA0HgxsMAEMMhAAsgByAFQcDGwwAQwyEACyABIAc2AhwgByELCyAIIA1qIgcgA0kNAAsLIAEgAzYCFEEACyEHIAAgBzYCAAvSAwIHfwJ+IwBBEGsiBCQAAkACQAJAAkAgACkDYEIAUwRAIAAtABQhAiAEIAApAwA3AwggAkEDdiACQQdxQQBHaiICQQlPDQEgAEEIaiIDIARBCGogAhChNiAAQQA6ABQgAEIANwMAIAA1AhAhCSAEQQEQ+jcgAyAEKAIAIAQtAAQQjykgACAJNwNgCyAAKAJoIgJBCU8NASACBEAgAkEDdCEGIABBCGohByAAKQMAIQkgAC0AFCECA0AgACAALQB0IgggAmoiAzoAFCAAIAAgBWpBGGopAwAiCiACrYYgCYQiCTcDAAJAIANB/wFxQcAASQRAIAMhAgwBCyAEIAk3AwggByAEQQhqQQgQoTYgACADQUBqIgI6ABQgACAKIAggAmsiA62IQgAgA0H/AXFBwABJGyIJNwMACyAGIAVBCGoiBUcNAAsLIABBADYCaCABBEAgACgCYCICQQFqIgFFDQMgASAAKAIQIgNLDQQgACgCDCACaiAAKAJwQQJ2QQFyOgAAIABBADYCcCAAQn83A2ALIARBEGokAA8LIAJBCEG49cwAELA7AAsgAkEIQYz4zAAQsDsAC0F/IAFBiPbMABCxOwALIAEgA0GI9swAELA7AAv4DQIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0hCyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBigCACALSXEhCSAGQQRqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDpOyAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDgLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNAyAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCiCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALiQ4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgICAATcCOCAFQThqIgNBARCHLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0EASA0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGKAIAIAtJcSEJIAZBBGohBiAIQQFrIggNAAsgCQ0AIAJBMGoiBBD0LSEGIAJBOzYCmAEgAiAGNgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAEELsjCyACQSBqEOk7IAcoAgAiA0UNByADIAMoAgAiA0EBazYCACADQQFHDQcgBxD7HgwHCwJAIAooAggiBi0AACILQRVGBEAgBigCBCEGIAJBFToA3AIgAiAGNgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBSACKAKcASEIIAIoApgBIQYgCRCVDAwBCyACKAI0IQggAigCMCEGCyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAEQQRqEOAsIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIERQ0EIARCgYCAgBA3AgAgBCACKQKUATcCCCAEQRBqIAJBnAFqKQIANwIAIARBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBDYC0AIgCSACQfABaiIEIAJB0AJqEPojIAogBiAIENMjIAQgCSAKEO8lIAJBOGoiBiAEIAcQrhYgAkGgA2oiByAGEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0GIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0GIAJBMGoQuyMMBgsgAkHkA2oiBiAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBCACQfABaiAGEKMLIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhBCACKAKYASEGIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAQ2AgggAyAGNgIEIANBCDYCAAwFC0HIyc0AQcIAQYzKzQAQnykAC0Hsx80AELI7AAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALkA4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgICAATcCOCAFQThqIgNBARCHLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0GAgARPDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYvAQAgC0H//wNxSXEhCSAGQQJqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahCdPCAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDfLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5AOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAwAA3AjggBUE4aiIDQQEQhi0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgIAETw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLwEAIAtB//8DcUlxIQkgBkECaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQnTwgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ3ywgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuUDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYABTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLQAAwCIMQQBOcSAMIAvASHEhCSAGQQFqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDeOyAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDyLyACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5UOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAgAE3AjggBUE4aiIDQQEQhy0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgIACTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLwEAwSIMQQBOcSAMIAvBSHEhCSAGQQJqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahCdPCAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDfLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC/kNAgx/An4jAEHgAGsiBiQAAkAgASgC8AJFBEAgBkEIaiABQZgDahCUKSAGKAIIIQEgACAGKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBkFAayIHQQA2AgAgBkKAgICAgAE3AjggBkE4aiIDQQEQhy0gBkHYAGogBygCACIHNgIAIAYgBikCOCIONwNQIAZBGGogAUGoAmoiAikCADcDACAGQSBqIAFBsAJqIgUpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAFQgE3AwAgAUEANgKsAiAGIA83AxAgBkEsaiIHIAEQ1xggBkEQaiEFIwBB8ANrIgIkAAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAFKAIAQYCAgIB4RgRAIAJBKGogBUEMaigCADYCACACIAUpAgQ3AyAgAiAFKQIQNwIwAkAgAkEwaiIEEPUtDQAgBBD0LSACKAIoIghFDQCtIQ8gAigCJCEEQQEhCQNAIAkgBCkDACAPVHEhCSAEQQhqIQQgCEEBayIIDQALIAkNACACQTBqIgUQ9C0hBCACQTs2ApgBIAIgBDYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBRC7IwsgAkEgahDjPCAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgQtAAAiC0EVRgRAIAQoAgQhBCACQRU6ANwCIAIgBDYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEEIAkQlQwMAQsgAigCNCEIIAIoAjAhBAsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBUEEahDeLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBUUNAyAFQoGAgIAQNwIAIAUgAikClAE3AgggBUEQaiACQZwBaikCADcCACAFQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAU2AtACIAkgAkHwAWoiBSACQdACahD6IyAKIAQgCBDTIyAFIAkgChDvJSACQThqIgQgBSAHEK4WIAJBoANqIgcgBBDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgQgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAUgAkHwAWogBBCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQUgAigCmAEhBCACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAFNgIIIAMgBDYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBigCQCEDIAYoAjwhByAGKAI4IgJBCEcEQCAAIAYpAkQ3AgwgAEEUaiAGQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAZB4ABqJAAL+Q0CDH8CfiMAQeAAayIGJAACQCABKALwAkUEQCAGQQhqIAFBmANqEJQpIAYoAgghASAAIAYoAgw2AgggACABNgIEIABBCDYCAAwBCyAGQUBrIgdBADYCACAGQoCAgIDAADcCOCAGQThqIgNBARCGLSAGQdgAaiAHKAIAIgc2AgAgBiAGKQI4Ig43A1AgBkEYaiABQagCaiICKQIANwMAIAZBIGogAUGwAmoiBSkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIAVCATcDACABQQA2AqwCIAYgDzcDECAGQSxqIgcgARDXGCAGQRBqIQUjAEHwA2siAiQAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAUoAgBBgICAgHhGBEAgAkEoaiAFQQxqKAIANgIAIAIgBSkCBDcDICACIAUpAhA3AjACQCACQTBqIgQQ9S0NACAEEPQtIAIoAigiCEUNAK0hDyACKAIkIQRBASEJA0AgCSAEKQMAIA9UcSEJIARBCGohBCAIQQFrIggNAAsgCQ0AIAJBMGoiBRD0LSEEIAJBOzYCmAEgAiAENgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAFELsjCyACQSBqEOM8IAcoAgAiA0UNBiADIAMoAgAiA0EBazYCACADQQFHDQYgBxD7HgwGCwJAIAooAggiBC0AACILQRVGBEAgBCgCBCEEIAJBFToA3AIgAiAENgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBCACKAKcASEIIAIoApgBIQQgCRCVDAwBCyACKAI0IQggAigCMCEECyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAFQQRqEN4sIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIFRQ0DIAVCgYCAgBA3AgAgBSACKQKUATcCCCAFQRBqIAJBnAFqKQIANwIAIAVBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBTYC0AIgCSACQfABaiIFIAJB0AJqEPojIAogBCAIENMjIAUgCSAKEO8lIAJBOGoiBCAFIAcQrhYgAkGgA2oiByAEEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0FIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0FIAJBMGoQuyMMBQsgAkHkA2oiBCAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBSACQfABaiAEEKILIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQMgAigCnAEhBSACKAKYASEEIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAU2AgggAyAENgIEIANBCDYCAAwEC0HIyc0AQcIAQYzKzQAQnykACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAGKAJAIQMgBigCPCEHIAYoAjgiAkEIRwRAIAAgBikCRDcCDCAAQRRqIAZBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBkHgAGokAAuVDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYCAAk8NAyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBi8BAMEiDEEATnEgDCALwUhxIQkgBkECaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQnTwgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ3ywgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuJDgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgMAANwI4IAVBOGoiA0EBEIYtIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQQBIDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYoAgAgC0lxIQkgBkEEaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQ6TsgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ4CwgAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAv4DQIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0hCyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBigCACALSXEhCSAGQQRqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDpOyAHKAIAIgNFDQYgAyADKAIAIgNBAWs2AgAgA0EBRw0GIAcQ+x4MBgsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDgLCACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNAyAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBSACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBSACQTBqELsjDAULIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0DIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBAtByMnNAEHCAEGMys0AEJ8pAAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALjg4CDH8CfiMAQeAAayIFJAACQCABKALwAkUEQCAFQQhqIAFBmANqEJQpIAUoAgghASAAIAUoAgw2AgggACABNgIEIABBCDYCAAwBCyAFQUBrIgdBADYCACAFQoCAgIDAADcCOCAFQThqIgNBARCGLSAFQdgAaiAHKAIAIgc2AgAgBSAFKQI4Ig43A1AgBUEYaiABQagCaiICKQIANwMAIAVBIGogAUGwAmoiBCkCADcDACABKQKgAiEPIAEgDjcCoAIgAiAHNgIAIARCATcDACABQQA2AqwCIAUgDzcDECAFQSxqIgcgARDXGCAFQRBqIQQjAEHwA2siAiQAAkACQAJAAkACQCABQZgDaiIKLQAAQSJGBEAgBCgCAEGAgICAeEYEQCACQShqIARBDGooAgA2AgAgAiAEKQIENwMgIAIgBCkCEDcCMAJAIAJBMGoiBhD1LQ0AIAYQ9C0iC0GAAk8NAyACKAIoIghFDQAgAigCJCEGQQEhCQNAIAkgBi0AACALQf8BcUlxIQkgBkEBaiEGIAhBAWsiCA0ACyAJDQAgAkEwaiIEEPQtIQYgAkE7NgKYASACIAY2AtwCIAJBrMjNADYC8AEgAkIBNwL8ASACIAJB3AJqNgKUASACIAJBlAFqNgL4ASACQQE2AvQBIANBBGogAkHwAWoQmQ4gA0EANgIAIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAQQuyMLIAJBIGoQ3jsgBygCACIDRQ0HIAMgAygCACIDQQFrNgIAIANBAUcNByAHEPseDAcLAkAgCigCCCIGLQAAIgtBFUYEQCAGKAIEIQYgAkEVOgDcAiACIAY2AuACIAJBlAFqIAJBMGpBtMjNACACQdwCaiIJEOkjIAIoApQBQZOAgIB4Rw0FIAIoApwBIQggAigCmAEhBiAJEJUMDAELIAIoAjQhCCACKAIwIQYLIAJBkAJqIAoQwgYgAkEAOwHIAiACQQA2AsQCIAJBADYCrAIgAkEANgKgAiACQgQ3AogCIAJCADcCgAIgAkKAgICAwAA3AvgBIAJBADYC8AEgAiACKAIoNgKcAiACQdwCaiIKIARBBGoQ8i8gAiACKQLcAjcCoAEgAkEANgKcASACIAIoAugCIgw2ApgBIAIgAigC5AI2ApQBIAJBEGogAkGUAWoiCRDXOyACKAIQIQ1BHEEEEK02IgRFDQQgBEKBgICAEDcCACAEIAIpApQBNwIIIARBEGogAkGcAWopAgA3AgAgBEEYaiACQaQBaigCADYCACACIAw2AtgCIAIgDTYC1AIgAiAENgLQAiAJIAJB8AFqIgQgAkHQAmoQ+iMgCiAGIAgQ0yMgBCAJIAoQ7yUgAkE4aiIGIAQgBxCuFiACQaADaiIHIAYQzRwgAkEIaiAHEKABIAIoAgghByADIAIoAgw2AgggAyAHNgIEIANBCDYCACALQRVHDQYgAigCMCIDIAMoAgAiA0EBazYCACADQQFHDQYgAkEwahC7IwwGCyACQeQDaiIGIAooAggQwgYgAkH4AWoiCCAHQQhqKAIANgIAIAIgBykCADcD8AEgAkEYaiAEIAJB8AFqIAYQogsgAiACKQMYNwLcAiACQZQBaiACQdwCaiIHQbTIzQAgChDpIyACKAKUAUGTgICAeEcNBCACKAKcASEEIAIoApgBIQYgAigC3AIiCCAIKAIAIghBAWs2AgAgCEEBRgRAIAcQuyMLIAMgBDYCCCADIAY2AgQgA0EINgIADAULQcjJzQBBwgBBjMrNABCfKQALQezHzQAQsjsACyACQYACaiACQaQBaigCADYCACACQfgBaiACQZwBaikCADcDACACIAIpApQBNwPwAUGos80AQSsgAkHwAWpBiLPNAEGMyc0AENUeAAtBBEEcEKM9AAsgAkGAAmogAkGkAWooAgA2AgAgCCACQZwBaikCADcDACACIAIpApQBNwPwAUGcyc0AQRkgAkHwAWpBiLPNAEG4yc0AENUeAAsgAkHwA2okACAFKAJAIQMgBSgCPCEHIAUoAjgiAkEIRwRAIAAgBSkCRDcCDCAAQRRqIAVBzABqKAIANgIAIAAgAzYCCCAAIAc2AgQgACACNgIADAELAn9BgICAgHggASgCuAIiAkGBgICAeEYNABpBgICAgHggAkGAgICAeEYNABogASkCvAIhDiABQQA2AsACIAFCgICAgCA3A7gCIAILIQIgAUGAA2oQtDAgASAONwKEAyABIAI2AoADIAEoAuACIgJBgICAgHhHBEAgASkC5AIhDiABQQA2AugCIAFCgICAgCA3A+ACCyABQYwDahC0MCABIA43A5ADIAEgAjYCjAMgAUIANwPwAiAAIAM2AgggACAHNgIEIABBCDYCAAsgBUHgAGokAAuODgIMfwJ+IwBB4ABrIgUkAAJAIAEoAvACRQRAIAVBCGogAUGYA2oQlCkgBSgCCCEBIAAgBSgCDDYCCCAAIAE2AgQgAEEINgIADAELIAVBQGsiB0EANgIAIAVCgICAgIABNwI4IAVBOGoiA0EBEIctIAVB2ABqIAcoAgAiBzYCACAFIAUpAjgiDjcDUCAFQRhqIAFBqAJqIgIpAgA3AwAgBUEgaiABQbACaiIEKQIANwMAIAEpAqACIQ8gASAONwKgAiACIAc2AgAgBEIBNwMAIAFBADYCrAIgBSAPNwMQIAVBLGoiByABENcYIAVBEGohBCMAQfADayICJAACQAJAAkACQAJAIAFBmANqIgotAABBIkYEQCAEKAIAQYCAgIB4RgRAIAJBKGogBEEMaigCADYCACACIAQpAgQ3AyAgAiAEKQIQNwIwAkAgAkEwaiIGEPUtDQAgBhD0LSILQYACTw0DIAIoAigiCEUNACACKAIkIQZBASEJA0AgCSAGLQAAIAtB/wFxSXEhCSAGQQFqIQYgCEEBayIIDQALIAkNACACQTBqIgQQ9C0hBiACQTs2ApgBIAIgBjYC3AIgAkGsyM0ANgLwASACQgE3AvwBIAIgAkHcAmo2ApQBIAIgAkGUAWo2AvgBIAJBATYC9AEgA0EEaiACQfABahCZDiADQQA2AgAgAigCMCIDIAMoAgAiA0EBazYCACADQQFGBEAgBBC7IwsgAkEgahDeOyAHKAIAIgNFDQcgAyADKAIAIgNBAWs2AgAgA0EBRw0HIAcQ+x4MBwsCQCAKKAIIIgYtAAAiC0EVRgRAIAYoAgQhBiACQRU6ANwCIAIgBjYC4AIgAkGUAWogAkEwakG0yM0AIAJB3AJqIgkQ6SMgAigClAFBk4CAgHhHDQUgAigCnAEhCCACKAKYASEGIAkQlQwMAQsgAigCNCEIIAIoAjAhBgsgAkGQAmogChDCBiACQQA7AcgCIAJBADYCxAIgAkEANgKsAiACQQA2AqACIAJCBDcCiAIgAkIANwKAAiACQoCAgIDAADcC+AEgAkEANgLwASACIAIoAig2ApwCIAJB3AJqIgogBEEEahDyLyACIAIpAtwCNwKgASACQQA2ApwBIAIgAigC6AIiDDYCmAEgAiACKALkAjYClAEgAkEQaiACQZQBaiIJENc7IAIoAhAhDUEcQQQQrTYiBEUNBCAEQoGAgIAQNwIAIAQgAikClAE3AgggBEEQaiACQZwBaikCADcCACAEQRhqIAJBpAFqKAIANgIAIAIgDDYC2AIgAiANNgLUAiACIAQ2AtACIAkgAkHwAWoiBCACQdACahD6IyAKIAYgCBDTIyAEIAkgChDvJSACQThqIgYgBCAHEK4WIAJBoANqIgcgBhDNHCACQQhqIAcQoAEgAigCCCEHIAMgAigCDDYCCCADIAc2AgQgA0EINgIAIAtBFUcNBiACKAIwIgMgAygCACIDQQFrNgIAIANBAUcNBiACQTBqELsjDAYLIAJB5ANqIgYgCigCCBDCBiACQfgBaiIIIAdBCGooAgA2AgAgAiAHKQIANwPwASACQRhqIAQgAkHwAWogBhCjCyACIAIpAxg3AtwCIAJBlAFqIAJB3AJqIgdBtMjNACAKEOkjIAIoApQBQZOAgIB4Rw0EIAIoApwBIQQgAigCmAEhBiACKALcAiIIIAgoAgAiCEEBazYCACAIQQFGBEAgBxC7IwsgAyAENgIIIAMgBjYCBCADQQg2AgAMBQtByMnNAEHCAEGMys0AEJ8pAAtB7MfNABCyOwALIAJBgAJqIAJBpAFqKAIANgIAIAJB+AFqIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQaizzQBBKyACQfABakGIs80AQYzJzQAQ1R4AC0EEQRwQoz0ACyACQYACaiACQaQBaigCADYCACAIIAJBnAFqKQIANwMAIAIgAikClAE3A/ABQZzJzQBBGSACQfABakGIs80AQbjJzQAQ1R4ACyACQfADaiQAIAUoAkAhAyAFKAI8IQcgBSgCOCICQQhHBEAgACAFKQJENwIMIABBFGogBUHMAGooAgA2AgAgACADNgIIIAAgBzYCBCAAIAI2AgAMAQsCf0GAgICAeCABKAK4AiICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQK8AiEOIAFBADYCwAIgAUKAgICAIDcDuAIgAgshAiABQYADahC0MCABIA43AoQDIAEgAjYCgAMgASgC4AIiAkGAgICAeEcEQCABKQLkAiEOIAFBADYC6AIgAUKAgICAIDcD4AILIAFBjANqELQwIAEgDjcDkAMgASACNgKMAyABQgA3A/ACIAAgAzYCCCAAIAc2AgQgAEEINgIACyAFQeAAaiQAC5QOAgx/An4jAEHgAGsiBSQAAkAgASgC8AJFBEAgBUEIaiABQZgDahCUKSAFKAIIIQEgACAFKAIMNgIIIAAgATYCBCAAQQg2AgAMAQsgBUFAayIHQQA2AgAgBUKAgICAwAA3AjggBUE4aiIDQQEQhi0gBUHYAGogBygCACIHNgIAIAUgBSkCOCIONwNQIAVBGGogAUGoAmoiAikCADcDACAFQSBqIAFBsAJqIgQpAgA3AwAgASkCoAIhDyABIA43AqACIAIgBzYCACAEQgE3AwAgAUEANgKsAiAFIA83AxAgBUEsaiIHIAEQ1xggBUEQaiEEIwBB8ANrIgIkAAJAAkACQAJAAkAgAUGYA2oiCi0AAEEiRgRAIAQoAgBBgICAgHhGBEAgAkEoaiAEQQxqKAIANgIAIAIgBCkCBDcDICACIAQpAhA3AjACQCACQTBqIgYQ9S0NACAGEPQtIgtBgAFPDQMgAigCKCIIRQ0AIAIoAiQhBkEBIQkDQCAJIAYtAADAIgxBAE5xIAwgC8BIcSEJIAZBAWohBiAIQQFrIggNAAsgCQ0AIAJBMGoiBBD0LSEGIAJBOzYCmAEgAiAGNgLcAiACQazIzQA2AvABIAJCATcC/AEgAiACQdwCajYClAEgAiACQZQBajYC+AEgAkEBNgL0ASADQQRqIAJB8AFqEJkOIANBADYCACACKAIwIgMgAygCACIDQQFrNgIAIANBAUYEQCAEELsjCyACQSBqEN47IAcoAgAiA0UNByADIAMoAgAiA0EBazYCACADQQFHDQcgBxD7HgwHCwJAIAooAggiBi0AACILQRVGBEAgBigCBCEGIAJBFToA3AIgAiAGNgLgAiACQZQBaiACQTBqQbTIzQAgAkHcAmoiCRDpIyACKAKUAUGTgICAeEcNBSACKAKcASEIIAIoApgBIQYgCRCVDAwBCyACKAI0IQggAigCMCEGCyACQZACaiAKEMIGIAJBADsByAIgAkEANgLEAiACQQA2AqwCIAJBADYCoAIgAkIENwKIAiACQgA3AoACIAJCgICAgMAANwL4ASACQQA2AvABIAIgAigCKDYCnAIgAkHcAmoiCiAEQQRqEPIvIAIgAikC3AI3AqABIAJBADYCnAEgAiACKALoAiIMNgKYASACIAIoAuQCNgKUASACQRBqIAJBlAFqIgkQ1zsgAigCECENQRxBBBCtNiIERQ0EIARCgYCAgBA3AgAgBCACKQKUATcCCCAEQRBqIAJBnAFqKQIANwIAIARBGGogAkGkAWooAgA2AgAgAiAMNgLYAiACIA02AtQCIAIgBDYC0AIgCSACQfABaiIEIAJB0AJqEPojIAogBiAIENMjIAQgCSAKEO8lIAJBOGoiBiAEIAcQrhYgAkGgA2oiByAGEM0cIAJBCGogBxCgASACKAIIIQcgAyACKAIMNgIIIAMgBzYCBCADQQg2AgAgC0EVRw0GIAIoAjAiAyADKAIAIgNBAWs2AgAgA0EBRw0GIAJBMGoQuyMMBgsgAkHkA2oiBiAKKAIIEMIGIAJB+AFqIgggB0EIaigCADYCACACIAcpAgA3A/ABIAJBGGogBCACQfABaiAGEKILIAIgAikDGDcC3AIgAkGUAWogAkHcAmoiB0G0yM0AIAoQ6SMgAigClAFBk4CAgHhHDQQgAigCnAEhBCACKAKYASEGIAIoAtwCIgggCCgCACIIQQFrNgIAIAhBAUYEQCAHELsjCyADIAQ2AgggAyAGNgIEIANBCDYCAAwFC0HIyc0AQcIAQYzKzQAQnykAC0Hsx80AELI7AAsgAkGAAmogAkGkAWooAgA2AgAgAkH4AWogAkGcAWopAgA3AwAgAiACKQKUATcD8AFBqLPNAEErIAJB8AFqQYizzQBBjMnNABDVHgALQQRBHBCjPQALIAJBgAJqIAJBpAFqKAIANgIAIAggAkGcAWopAgA3AwAgAiACKQKUATcD8AFBnMnNAEEZIAJB8AFqQYizzQBBuMnNABDVHgALIAJB8ANqJAAgBSgCQCEDIAUoAjwhByAFKAI4IgJBCEcEQCAAIAUpAkQ3AgwgAEEUaiAFQcwAaigCADYCACAAIAM2AgggACAHNgIEIAAgAjYCAAwBCwJ/QYCAgIB4IAEoArgCIgJBgYCAgHhGDQAaQYCAgIB4IAJBgICAgHhGDQAaIAEpArwCIQ4gAUEANgLAAiABQoCAgIAgNwO4AiACCyECIAFBgANqELQwIAEgDjcChAMgASACNgKAAyABKALgAiICQYCAgIB4RwRAIAEpAuQCIQ4gAUEANgLoAiABQoCAgIAgNwPgAgsgAUGMA2oQtDAgASAONwOQAyABIAI2AowDIAFCADcD8AIgACADNgIIIAAgBzYCBCAAQQg2AgALIAVB4ABqJAALxQQCAn8EfgJAIAFFDQAgACAAKQMAIAKtfDcDAAJAIAAoAkgiAyACakEfTQRAIAIEQCAAIANqQShqIAEgAvwKAAALIAAoAkggAmohAgwBCyABIAJqIQIgAwRAQSAgA2siBARAIABBKGogA2ogASAE/AoAAAsgACgCSCEDIABBADYCSCAAIAApAwggACkAKELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDCCAAIAApAxAgACkAMELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDECAAIAApAxggACkAOELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDGCAAIAApAyAgACkAQELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDICABIANrQSBqIQELIAIgAUEgak8EQCACQSBrIQMgACkDICEFIAApAxghBiAAKQMQIQcgACkDCCEIA0AgACABKQAAQs/W077Sx6vZQn4gCHxCH4lCh5Wvr5i23puef34iCDcDCCAAIAFBCGopAABCz9bTvtLHq9lCfiAHfEIfiUKHla+vmLbem55/fiIHNwMQIAAgAUEQaikAAELP1tO+0ser2UJ+IAZ8Qh+JQoeVr6+Ytt6bnn9+IgY3AxggACABQRhqKQAAQs/W077Sx6vZQn4gBXxCH4lCh5Wvr5i23puef34iBTcDICABQSBqIgEgA00NAAsLIAEgAk8NASACIAFrIgJFDQAgAEEoaiABIAL8CgAACyAAIAI2AkgLC44EAgN/A34jAEHgAGsiAyQAQoCAgICAgICAgH8hCAJAAkACQCAAAn8CfgJAAkAgASgCDCgCECACQQN0aikDACIHQoCAgICAgICAgH9SIAEoAggiBCgCACIFKAIAKQMAIgZCf1JyRQRAQgAhBgwBCyAGUA0GIAcgByAGfyIIIAZ+fUIAIAZCf1IbIQYgB0IAWQ0BCyAIIAYgBSgCCCkDAFetfQwBCyAIIAYgBSgCBCkDAFmtfAsiBkKAgICACHxCgICAgBBaBEAgBCgCBCEBIAMgBzcDICADQcyR/wA2AiggA0IENwI0IANBhgw2AlwgA0H0CzYCVCADIAFBAWo2AlAgA0G7BzYCTCADIAE2AkggA0HMATYCRCADQfiR/wA2AkAgAyADQUBrNgIwIAMgA0EgajYCWCADQQQ2AiwgA0EQaiADQShqEJkOIANBCGogA0EcaigCADYCACADIAMpAhQ3AwBBgoCAgHghBCADKAIQDAELIANBQGsgBqciBSAEKAIILQAAEOoPIAMoAkAiBEGTgICAeEYNASADQQhqIANB0ABqKAIANgIAIAMgAykCSDcDACADKAJECzYCBCAAIAQ2AgAgACADKQMANwIIIABBEGogA0EIaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkECdGogBTYCAAsgA0HgAGokAA8LQbyP/wAQ4isAC6gEAgR/AX4jAEGAAWsiAiQAIAIgAUEYaiIDNgIYIAJBKGpBlqzYsAE2AgAgAkKWrNiw4cKFixY3AyAgAiACQSBqIgQ2AhwCQAJAIAMgBBDHCARAIAQQxwwgAkEQaiABENw7IAIgAigCFCIDNgJYIANBAkcNASACQfQAaiABELEYIAJBCGogARDcOyACKAIMIgNBAUsEQCACKAIIIgQoAgwiAyADKAIAIgVBAWo2AgAgBUEASA0DIAQpAhAhBiAAQSRqIAFBLGpBACABKAIsGxDuJSAAQQhqQZas2LABNgIAIABClqzYsOHChYsWNwIAIAAgBjcCHCAAIAM2AhggACACKQJ0NwIMIABBFGogAkH8AGooAgA2AgAgARCLJyACQYABaiQADwtBASADQfyThgEQwyEACyACQdAAakGWrNiwATYCACACQpas2LDhwoWLFjcDSCACQgM3AjwgAkEDNgI0IAJB0JOGATYCMCACQa0DNgJwIAJBxwI2AmggAkHsj4YBNgJkIAJBxwI2AmAgAkHcj4YBNgJcIAIgAkHcAGo2AjggAiACQcgAajYCbCACQRhqIAJBHGogAkEwakHok4YBEKMrAAsgAkICNwJoIAJBAzYCYCACQcyUhgE2AlwgAkHHAjYCPCACQeyPhgE2AjggAkHHAjYCNCACQdyPhgE2AjAgAiACQTBqNgJkQQAgAkHYAGpB+JOGASACQdwAakHklIYBEK8rCwALqAQCBH8BfiMAQYABayICJAAgAiABQRhqIgM2AhggAkEoakGZsuTIATYCACACQpmy5MiRo8aMGTcDICACIAJBIGoiBDYCHAJAAkAgAyAEEMcIBEAgBBDHDCACQRBqIAEQ3DsgAiACKAIUIgM2AlggA0ECRw0BIAJB9ABqIAEQsRggAkEIaiABENw7IAIoAgwiA0EBSwRAIAIoAggiBCgCDCIDIAMoAgAiBUEBajYCACAFQQBIDQMgBCkCECEGIABBJGogAUEsakEAIAEoAiwbEO4lIABBCGpBmbLkyAE2AgAgAEKZsuTIkaPGjBk3AgAgACAGNwIcIAAgAzYCGCAAIAIpAnQ3AgwgAEEUaiACQfwAaigCADYCACABEIsnIAJBgAFqJAAPC0EBIANB/JOGARDDIQALIAJB0ABqQZmy5MgBNgIAIAJCmbLkyJGjxowZNwNIIAJCAzcCPCACQQM2AjQgAkHQk4YBNgIwIAJBrQM2AnAgAkHHAjYCaCACQdyOhgE2AmQgAkHHAjYCYCACQdyPhgE2AlwgAiACQdwAajYCOCACIAJByABqNgJsIAJBGGogAkEcaiACQTBqQeiThgEQoysACyACQgI3AmggAkEDNgJgIAJBzJSGATYCXCACQccCNgI8IAJB3I6GATYCOCACQccCNgI0IAJB3I+GATYCMCACIAJBMGo2AmRBACACQdgAakH4k4YBIAJB3ABqQeSUhgEQrysLAAuoBAIEfwF+IwBBgAFrIgIkACACIAFBGGoiAzYCGCACQShqQZSo0KABNgIAIAJClKjQoMGChYoUNwMgIAIgAkEgaiIENgIcAkACQCADIAQQxwgEQCAEEMcMIAJBEGogARDcOyACIAIoAhQiAzYCWCADQQJHDQEgAkH0AGogARCyGCACQQhqIAEQ3DsgAigCDCIDQQFLBEAgAigCCCIEKAIMIgMgAygCACIFQQFqNgIAIAVBAEgNAyAEKQIQIQYgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEIakGUqNCgATYCACAAQpSo0KDBgoWKFDcCACAAIAY3AhwgACADNgIYIAAgAikCdDcCDCAAQRRqIAJB/ABqKAIANgIAIAEQiycgAkGAAWokAA8LQQEgA0H8k4YBEMMhAAsgAkHQAGpBlKjQoAE2AgAgAkKUqNCgwYKFihQ3A0ggAkIDNwI8IAJBAzYCNCACQdCThgE2AjAgAkGtAzYCcCACQccCNgJoIAJB7I+GATYCZCACQccCNgJgIAJBzI6GATYCXCACIAJB3ABqNgI4IAIgAkHIAGo2AmwgAkEYaiACQRxqIAJBMGpB6JOGARCjKwALIAJCAjcCaCACQQM2AmAgAkHMlIYBNgJcIAJBxwI2AjwgAkHsj4YBNgI4IAJBxwI2AjQgAkHMjoYBNgIwIAIgAkEwajYCZEEAIAJB2ABqQfiThgEgAkHcAGpB5JSGARCvKwsAC6gEAgR/AX4jAEGAAWsiAiQAIAIgAUEYaiIDNgIYIAJBKGpBmLDgwAE2AgAgAkKYsODAgYOGjBg3AyAgAiACQSBqIgQ2AhwCQAJAIAMgBBDHCARAIAQQxwwgAkEQaiABENw7IAIgAigCFCIDNgJYIANBAkcNASACQfQAaiABELIYIAJBCGogARDcOyACKAIMIgNBAUsEQCACKAIIIgQoAgwiAyADKAIAIgVBAWo2AgAgBUEASA0DIAQpAhAhBiAAQSRqIAFBLGpBACABKAIsGxDuJSAAQQhqQZiw4MABNgIAIABCmLDgwIGDhowYNwIAIAAgBjcCHCAAIAM2AhggACACKQJ0NwIMIABBFGogAkH8AGooAgA2AgAgARCLJyACQYABaiQADwtBASADQfyThgEQwyEACyACQdAAakGYsODAATYCACACQpiw4MCBg4aMGDcDSCACQgM3AjwgAkEDNgI0IAJB0JOGATYCMCACQa0DNgJwIAJBxwI2AmggAkHcjoYBNgJkIAJBxwI2AmAgAkHMjoYBNgJcIAIgAkHcAGo2AjggAiACQcgAajYCbCACQRhqIAJBHGogAkEwakHok4YBEKMrAAsgAkICNwJoIAJBAzYCYCACQcyUhgE2AlwgAkHHAjYCPCACQdyOhgE2AjggAkHHAjYCNCACQcyOhgE2AjAgAiACQTBqNgJkQQAgAkHYAGpB+JOGASACQdwAakHklIYBEK8rCwALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEI8MIAAoAgRBDEEEEPg6IAAoAggQjwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iUL6wMBAX8jAEEQayIEJAACQAJAAkACQAJAIAJBJUYEQCAEIAMpAgA3AgggBEEIahDuEiECIARBCGoQ7hIhAyACQYCAxABGDQQgA0GAgMQARw0BDAQLIAJB3///AHFBwQBrQRpJIAJBMGtBCklyDQQgAkEhayIDQR9NDQEMAgsgAkHf//8AcUHBAGtBBUsgAkEwa0EKT3ENAiADQTBrQQpJDQMgA0Hf//8AcUHBAGtBBUsNAgwDC0EBIAN0Qen/gbB9cQ0CCyACQd8ARiACQf4ARnIgAkGgAWtB4K4DSSACQYDAA2tB0DtJcnIgAkHw+wNrQY4ESSACQYCABGtB/v8DSXIgAkGAgAhrQf7/A0kgAkGAgAxrQf7/A0lycnINASACQYCAEGtB/v8DSSACQYCAFGtB/v8DSXIgAkGAgBhrQf7/A0kgAkGAgBxrQf7/A0lyciACQYCAIGtB/v8DSSACQYCAJGtB/v8DSXIgAkGAgChrQf7/A0kgAkGAgCxrQf7/A0lycnINASACQYCAMGtB/v8DSSACQYCANGtB/v8DSXIgAkGAoDhrQf7fA0kgAkGAgDxrQf7/A0lyciACQYCAQGpB/v8DSXINASAAQQYgASgCFBEAAAwBCyAAQQggASgCFBEAAAsgBEEQaiQAC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCRDCAAKAIEQQxBBBD4OiAAKAIIEJEMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCSDCAAKAIEQQxBBBD4OiAAKAIIEJIMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCTDCAAKAIEQQxBBBD4OiAAKAIIEJMMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCUDCAAKAIEQQxBBBD4OiAAKAIIEJQMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCVDCAAKAIEQQxBBBD4OiAAKAIIEJUMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN8kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOAkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN0kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN4kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABENwkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC88DAQF/IwBBMGsiBiQAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOEkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNBiAGKAIsIQIgAwRAIAIgBCAD/AoAAAsgBiADNgIsIAYgAjYCKCAGIAE2AiQgBkEMaiAGQSRqEP8fDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQYgBigCLCECIAMEQCACIAQgA/wKAAALIAYgAzYCLCAGIAI2AiggBiABNgIkIAZBDGogBkEkahD/HwwBCyAGQQxqIAYoAhwgBigCICADEPIHCyAGKAIMIgFBgICAgHhGDQAgACAGKQIQNwIEIAAgATYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVByIHPABCwOwALIAMgBUHYgc8AELA7AAsgASAGKAIsQcD1zgAQ/S8AC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCcDCAAKAIEQQxBBBD4OiAAKAIIEJwMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCdDCAAKAIEQQxBBBD4OiAAKAIIEJ0MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCeDCAAKAIEQQxBBBD4OiAAKAIIEJ4MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBCfDCAAKAIEQQxBBBD4OiAAKAIIEJ8MIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC/kDAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUGWAWsOFgECAwQFBgcICQoLDA0WDg8QFRESFhMACwJAAkACQAJAAkACQCABDgcAAQIDGQQFGwsgACACQQAgAkEBa0EGSRs2AgAMGgsgACACNgIUDBkLIAAgAjYCGAwYCyAAIAI2AhwMFwsgACACNgIgDBYLIAAgAkEARzoAUgwVCyAAIAJBAEc6AFAMFAsgACACQQBHOgBRDBMLIAAgAjoAWQwSCyAAIAI6AFoMEQsgACACNgI8DBALIAAgAjoAWwwPCyAAIAI6AFwMDgsgACACOwFEIAAvAUAgAC8BQnINDSAAIAI7AUAPCyAAIAI7AUYgAC8BQg0MIAAgAjsBQg8LIAAgAjsBTCAALwFIIAAvAUpyDQsgACACOwFIDwsgACACOwFOIAAvAUoNCiAAIAI7AUoPCyAAIAI7AUAMCQsgACACOwFCDAgLIAAgAjsBSAwHCyAAIAI7AUoMBgsgACACQQBHOgBTDAULIAAgAkEARzoAVgwECyAAIAJBAEc6AFcMAwsgACACQQBHOgBYDAILIAJBAk8NASAAIAI2AiQMAQsgACACQQBHIgE6AFQgAC0AVkUEQCAAIAE6AFYLIAAgAkU6AFULC74OAQ1/IwBBQGoiBSQAIAUgAToAGwJAAkACQAJAAkACQCACLQCKEUEVaw4CAQIAC0HMo/MAQShB9KPzABCfKQALIAENAUH8DiEBQfgOIQZB5BAhCQwDCyABRQ0BQeQOIQFB4A4hBkGYECEJDAILIAVBADYCHCAFQRtqQcy0wgAgBUEcakGoo/MAEK0rAAsgBUEANgIcIAVBG2pBuKPzACAFQRxqQbyj8wAQrSsACyACIAlqKAIAIQkgBUEANgIkIAVCgICAgBA3AhwgBUEQaiAFQRxqIhBB9Kj7ABCQISAFKAIUIQcgAiAGaiIGKAIAIQggASACaiIBKAIAIQogBiAFKAIQNgIAIAEgBzYCACAFIAk2AjQgBSAKNgI8IAUgCDYCOCAFQTRqIQ4gBUE4aiEJIwBBMGsiBiQAIAJBjhFqIREgAkHwDWohCwJAA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQCNEUEBaw4EAQIDBAALIBEgCyAOIAMgBBDuE0EBRg0EDAsLA0AgAigC+A0iAUHBAGtBe0kNBSALIAMgBBDLIA0ACwwKCyAGQQA2AiwgBkKAgICAIDcCJCAGQRhqIAZBJGoiB0H0qPsAEJYhIAIoAuwOIQggAigC6A4hCiACIAYpAxg3A+gOIAIoAtAQIA4oAgBqIgEgASAKIAhBAEEAIAIgAyAEEPcIIQEgBkEANgIsIAZCgICAgCA3AiQgBkEQaiAHQfSo+wAQliEgBigCFCEHIAYoAhAhDCACKALsDiENIAIgCDYC7A4gAigC6A4hCCACIAo2AugOIA0EQCAIIA1BAnRBAhD4OgsgAUEBRw0EIAJBAzoAjREgAkH//wM2AtQQIAdFDQogDCAHQQJ0QQIQ+DoMCgsgCSgCBCEIIAkoAgAhDCACKALQECENIAIoAswQIQEgBiACKALUECIKNgIgIApB//8DRyIHIAAgAUtyDQQMBwtBACEHIAZBADYCJEEBIQEgC0EBIAZBJGogAyAEEO0fDQRBAiEBQQQhBwwFCyACQQA2AswQIA4gDigCAEEBaiIBNgIAIAZBJGoiByAAQcSo+wAQzhggBkEIaiAHQdSo+wAQkCEgBigCDCEHIAYoAgghCCAJKAIEIgoEQCAJKAIAIApBARD4OgsgCSAHNgIEIAkgCDYCACAAIAdLBEBBZyEBDAkLIAFBAk8EQCACQQE6AI0RDAgLQQEhASAHRQ0IIAhBACAH/AsADAgLIAJBAjoAjREgAiABQQVBASACKQPwDSABQT9xrYinIgdBAXEiCBtqNgL4DSACIAdBAXZBD3FBAWpBACAIa3E2AtAQDAYLIAdFDQYgDCAHQQJ0QQIQ+DoMBgsDQAJAAkACQAJAAkACQCAHQQFxRQRAAkAgAigC6A4gAigC7A4gCyAGQSBqIAMgBBCfEwRAIAYoAiAiCg0BIAEgCE8NAyABIAxqQQA6AAAMBQsgAiABNgLMECACQf//AzYC1BAMDAsgCiANSw0CCyAGQQA2AiQgCyAKIAZBJGogAyAEEO0fDQQgAiABNgLMECACIAo2AtQQDAoLIAEgCEH4ovMAEMMhAAsgASAITw0BIAEgDGogCiANazoAAAsgAUEBaiEBDAILIAEgCEGIo/MAEMMhAAsgACAGKAIkQQEgCnRqIgcgAWpJBEBBeCEBDAgLIAEgCCABIAhLGyEPA0AgASAPRwRAIAEgDGpBADoAACABQQFqIQEgB0EBayIHDQEMAgsLIA8gCEGYo/MAEMMhAAtBACEHIAAgAUsNAAsMAgsgBigCJEUNAEFhIQEgAi0AjxENBCAJKAIAIQQgCSgCBCEIIAJBkBFqIQNBACEBAkACQCACQdgQaiIKKAIAQQFqIglBgQJJBEAgCQRAA0AgASADaiABOgAAIAkgAUEBaiIBRw0ACwsgACAISw0BIABFBEBBACEBDAMLIANBAWohCEEAIQEDQCAEIAMgBC0AACIJai0AACILOgAAIAkEQCAIIAMgCfwKAAALIARBAWohBCABIAlyIQEgAyALOgAAIABBAWsiAA0ACwwCCyAJQYACQcii8wAQsDsACyAAIAhB2KLzABCwOwALIAogATYCAEEBIQELIAIgBzoAjREMAwsgAkEEOgCNEQwBCwtBAiEBCyAGQTBqJAAgASAFKAI0IQACQCAFLQAbRQRAIAIgADYC5BAgBUEANgIkIAVCgICAgBA3AhwgBUEIaiAQQfSo+wAQkCEgBSgCDCEBIAUoAgghAyACKAL8DiEAIAIoAvgOIAIgBSkCODcD+A4gAEUNASAAQQEQ+DoMAQsgAiAANgKYECAFQQA2AiQgBUKAgICAEDcCHCAFIAVBHGpB9Kj7ABCQISAFKAIEIQEgBSgCACEDIAIoAuQOIQAgAigC4A4gAiAFKQI4NwPgDiAARQ0AIABBARD4OgsgAQRAIAMgAUEBEPg6CyAFQUBrJAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKIMIAAoAgRBDEEEEPg6IAAoAggQogwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKMMIAAoAgRBDEEEEPg6IAAoAggQowwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULtAMBBH8jAEEwayIDJAAgAEEANgIgAkACQAJAIAAoAjRBAWtBfCAAKAIwIgRrcSICIAAoAgggBGtNDQAgAkGAgICAeEsNASAAKAIIIAAoAjBrIAJPDQADQCAAEPsWIAAoAgggACgCMGsgAkkNAAsLIABBMGoiBCACEI03IABBBCAAKAI0IgIgAkEETRs2AjQCQEEAIAAoAjAiBWtBA3EiAiAAKAIIIAVrTQ0AIAAoAgggACgCMGsgAk8NAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAgggACgCMGtBA0siAiACckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IANBEGogABDcOyADKAIUIQIgAygCECEEIANBCGogACgCMBCMNyADIAQgAiADKAIIIAMoAgxB4P3+ABDXJiADKAIEIgJBA00NASADKAIAIAIgAWs2AAAgAEEBOgA5IANBMGokAA8LQYj9/gBBJUGw/f4AEJ8pAAsgA0EANgIoIANBATYCHCADQcj+/gA2AhggA0IENwIgIANBGGpB8P3+ABDvLAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKUMIAAoAgRBDEEEEPg6IAAoAggQpQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKYMIAAoAgRBDEEEEPg6IAAoAggQpgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKcMIAAoAgRBDEEEEPg6IAAoAggQpwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKgMIAAoAgRBDEEEEPg6IAAoAggQqAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEKkMIAAoAgRBDEEEEPg6IAAoAggQqQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQqgwgAUEMQQQQ+DogACgCCCIAEKoMIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC8gDAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEEENgJMIAhBCGoiACAIQcwAakEEELsJIAAgAUEEELsJIAgpAwghAyAIKQMYIQIgCTUCACEGIAgpAzghBCAIKQMgIAgpAxAhByAIQdAAaiQAIAQgBkI4hoQiBoUiBEIQiSAEIAd8IgSFIgVCFYkgBSACIAN8IgNCIIl8IgWFIgdCEIkgByAEIAJCDYkgA4UiAnwiA0IgiUL/AYV8IgSFIgdCFYkgByADIAJCEYmFIgIgBSAGhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULyAMCBn4CfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIQQg2AkwgCEEIaiIAIAhBzABqQQQQuwkgACABQQgQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvIAwIGfgJ/IwBB0ABrIggkACAIQUBrIglCADcDACAIQgA3AzggCCAAKQMIIgI3AzAgCCAAKQMAIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAhBIDYCTCAIQQhqIgAgCEHMAGpBBBC7CSAAIAFBIBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8gDAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCEECNgJMIAhBCGoiACAIQcwAakEEELsJIAAgAUECELsJIAgpAwghAyAIKQMYIQIgCTUCACEGIAgpAzghBCAIKQMgIAgpAxAhByAIQdAAaiQAIAQgBkI4hoQiBoUiBEIQiSAEIAd8IgSFIgVCFYkgBSACIAN8IgNCIIl8IgWFIgdCEIkgByAEIAJCDYkgA4UiAnwiA0IgiUL/AYV8IgSFIgdCFYkgByADIAJCEYmFIgIgBSAGhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULyAMCBn4CfyMAQdAAayIIJAAgCEFAayIJQgA3AwAgCEIANwM4IAggACkDCCICNwMwIAggACkDACIDNwMoIAggAkLzytHLp4zZsvQAhTcDICAIIAJC7d6R85bM3LfkAIU3AxggCCADQuHklfPW7Nm87ACFNwMQIAggA0L1ys2D16zbt/MAhTcDCCAIQQE2AkwgCEEIaiIAIAhBzABqQQQQuwkgACABQQEQuwkgCCkDCCEDIAgpAxghAiAJNQIAIQYgCCkDOCEEIAgpAyAgCCkDECEHIAhB0ABqJAAgBCAGQjiGhCIGhSIEQhCJIAQgB3wiBIUiBUIViSAFIAIgA3wiA0IgiXwiBYUiB0IQiSAHIAQgAkINiSADhSICfCIDQiCJQv8BhXwiBIUiB0IViSAHIAMgAkIRiYUiAiAFIAaFfCIDQiCJfCIGhSIFQhCJIAUgAyACQg2JhSICIAR8IgNCIIl8IgSFIgVCFYkgBSADIAJCEYmFIgIgBnwiA0IgiXwiBoUiBUIQiSAFIAJCDYkgA4UiAiAEfCIDQiCJfCIEhUIViSACQhGJIAOFIgJCDYkgAiAGfIUiAkIRiYUgAiAEfCICQiCJhSAChQvIAwIGfgJ/IwBB0ABrIggkACAIQUBrIglCADcDACAIQgA3AzggCCAAKQMIIgI3AzAgCCAAKQMAIgM3AyggCCACQvPK0cunjNmy9ACFNwMgIAggAkLt3pHzlszct+QAhTcDGCAIIANC4eSV89bs2bzsAIU3AxAgCCADQvXKzYPXrNu38wCFNwMIIAhBEDYCTCAIQQhqIgAgCEHMAGpBBBC7CSAAIAFBEBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC+ADAgF/An4jAEGAAWsiAyQAIAMgAjYCCCADIAE2AgQgA0EEOwEOIANB4ABqIAEgAiADQQ5qEJUDAkAgAygCYEEBRgRAIANB2ABqIANB9ABqKAIAIgE2AgAgA0HQAGogA0HsAGopAgAiBDcDACADIAMpAmQiBTcDSCAAQRBqIAE2AgAgAEEIaiAENwIAIAAgBTcCAAwBCyADQRhqIANB8ABqKQMANwMAIAMgAykDaCIENwMQIAMgA0EQajYCNCADKAIcRSAEUHFFBEAgA0EBNgJkIANBpMuAATYCYCADQgE3AmwgA0HEEDYCTCADIANByABqIgE2AmggAyADQTRqNgJIIANBJGogA0HgAGoiAhCZDiADQY2AgIB4NgIgIANB2ABqIANBMGooAgA2AgAgA0HQAGogA0EoaikCADcDACADIAMpAiA3A0ggA0ECNgJkIANByMaAATYCYCADQgE3AmwgA0HMATYCfCADIANB+ABqNgJoIAMgA0EEajYCeCADQThqIAIQmQ4gARCIESAAIAMpAjw3AgggAEEQaiADQcQAaigCADYCACAAIAMoAjg2AgQgAEGCgICAeDYCAAwBCyADKAIYIQEgAEGTgICAeDYCACAAIAE2AgQLIANBgAFqJAALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELIMIAAoAgRBDEEEEPg6IAAoAggQsgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELMMIAAoAgRBDEEEEPg6IAAoAggQswwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELQMIAAoAgRBDEEEEPg6IAAoAggQtAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELUMIAAoAgRBDEEEEPg6IAAoAggQtQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELYMIAAoAgRBDEEEEPg6IAAoAggQtgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELcMIAAoAgRBDEEEEPg6IAAoAggQtwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELgMIAAoAgRBDEEEEPg6IAAoAggQuAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELkMIAAoAgRBDEEEEPg6IAAoAggQuQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULkg4CFX8EfiMAQRBrIgkkACAJIAE2AgwgAEEQaiIMIAlBDGoQzQUhGCAAKAIIRQRAIwBBQGoiBSQAAkACQCAAKAIMIg1BAWoiASANTwRAAkAgACgCBCIHIAdBAWoiCEEDdiIDQQdsIAdBCEkbIg9BAXYgAUkEQAJ/IA9BAWoiAiABIAEgAkkbIgFBD08EQCABQf////8BSw0FQX8gAUEDdEEHbkEBa2d2QQFqDAELQQRBCEEQIAFBCEkbIAFBBEkbCyEBIAVBMGogAEEQaiIEQQRBCCABEJ0UIAUoAjQhAyAFKAIwIgJFBEAgBSgCOCEBDAULIAUpAjghFyADQQlqIgEEQCACQf8BIAH8CwALIAUgF0IgiD4CLCAFIBenIgg2AiggBSADNgIkIAUgAjYCICAFQoSAgICAATcCGCAFIAQ2AhQgBUEgaiEOIAUgDQR/IAJBCGohCiAAKAIAIgYpAwBCf4VCgIGChIiQoMCAf4MhF0EAIQEDQCAXUARAA0AgAUEIaiEBIAZBCGoiBikDAEKAgYKEiJCgwIB/gyIXQoCBgoSIkKDAgH9RDQALIBdCgIGChIiQoMCAf4UhFwsgAiADIAwgACgCACAXeqdBA3YgAWpBAnQiD2tBBGsQzQWnIhBxIgRqKQAAQoCBgoSIkKDAgH+DIhlQBEBBCCEHA0AgBCAHaiEEIAdBCGohByACIAMgBHEiBGopAABCgIGChIiQoMCAf4MiGVANAAsLIBdCAX0gF4MhFyACIBl6p0EDdiAEaiADcSIEaiwAAEEATgRAIAIpAwBCgIGChIiQoMCAf4N6p0EDdiEECyACIARqIBBBGXYiBzoAACAKIARBCGsgA3FqIAc6AAAgAiAEQQJ0a0EEayAAKAIAIA9rQQRrKAAANgAAIA1BAWsiDQ0ACyAAKAIMBUEACyIBNgIsIAUgCCABazYCKCAAIA5BBBD6KiAFKAIkIgFFDQEgASAFKAIcIgIgBSgCGCABQQFqbGpBAWtBACACa3EiA2pBCWoiAUUNASAFKAIgIANrIAEgAhD4OgwBCyAAKAIAIQIgAyAIQQdxQQBHaiIGBEAgAiEBA0AgASABKQMAIhdCf4VCB4hCgYKEiJCgwIABgyAXQv/+/fv379+//wCEfDcDACABQQhqIQEgBkEBayIGDQALCwJAAkAgCEEITwRAIAIgCGogAikAADcAAAwBCyAIBEAgAkEIaiACIAj8CgAACyAIRQ0BCyACQQhqIQ4gAkEEayETQQEhA0EAIQEDQCABIQQgAyEBAkAgAiAEaiIQLQAAQYABRw0AIBMgBEECdCIDayEUIAIgA2tBBGshEQNAIAcgDCAUEM0FpyIScSIDIQYgAiADaikAAEKAgYKEiJCgwIB/gyIXUARAQQghCgNAIAYgCmohBiAKQQhqIQogAiAGIAdxIgZqKQAAQoCBgoSIkKDAgH+DIhdQDQALCyACIBd6p0EDdiAGaiAHcSIGaiwAAEEATgRAIAIpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIANrIAQgA2tzIAdxQQhPBEAgAiAGaiIDLQAAIAMgEkEZdiIDOgAAIA4gBkEIayAHcWogAzoAACACIAZBAnRrQQRrIQNB/wFGBEAgEEH/AToAACAOIARBCGsgB3FqQf8BOgAAIAMgESgAADYAAAwDCyARIANBARD6KgwBCwsgECASQRl2IgM6AAAgDiAEQQhrIAdxaiADOgAACyABIAEgCEkiBGohAyAEDQALCyAAIA8gDWs2AggLQYGAgIB4IQMMAgsQ4ycgBSgCBCEBIAUoAgAhAwwBCxDjJyAFKAIMIQEgBSgCCCEDCyAJIAM2AgAgCSABNgIEIAVBQGskACAJKAIMIQELIAAoAgQiAyAYp3EhAiAYQhmIIhlC/wCDQoGChIiQoMCAAX4hGiAAKAIAIQQDQAJ/AkACQCACIARqKQAAIhggGoUiF0J/hSAXQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhdQRQRAA0BBASEMIAEgACgCACAXeqdBA3YgAmogA3FBAnRrQQRrKAIAEMEIDQIgF0IBfSAXgyIXUEUNAAsLIBhCgIGChIiQoMCAf4MhFyAVRQRAIBdQDQIgF3qnQQN2IAJqIANxIQsLQQEgFyAYQgGGg1ANAhpBACEMIAQgC2osAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhCwsgACgCACIBIAtqIgItAAAhAyAJKAIMIQQgAiAZp0H/AHEiAjoAACABIAAoAgQgC0EIa3FqQQhqIAI6AAAgACAAKAIMQQFqNgIMIAAgACgCCCADQQFxazYCCCABIAtBAnRrQQRrIAQ2AgALIAlBEGokACAMDwtBAAshFSACIBZBCGoiFmogA3EhAgwACwALggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELsMIAAoAgRBDEEEEPg6IAAoAggQuwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEELwMIAAoAgRBDEEEEPg6IAAoAggQvAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL0MIAAoAgRBDEEEEPg6IAAoAggQvQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL4MIAAoAgRBDEEEEPg6IAAoAggQvgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEL8MIAAoAgRBDEEEEPg6IAAoAggQvwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMAMIAAoAgRBDEEEEPg6IAAoAggQwAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMEMIAAoAgRBDEEEEPg6IAAoAggQwQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMIMIAAoAgRBDEEEEPg6IAAoAggQwgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMMMIAAoAgRBDEEEEPg6IAAoAggQwwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMQMIAAoAgRBDEEEEPg6IAAoAggQxAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMUMIAAoAgRBDEEEEPg6IAAoAggQxQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMYMIAAoAgRBDEEEEPg6IAAoAggQxgwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMcMIAAoAgRBDEEEEPg6IAAoAggQxwwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMgMIAAoAgRBDEEEEPg6IAAoAggQyAwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULggQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEEMkMIAAoAgRBDEEEEPg6IAAoAggQyQwgACgCCEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQygwgAUEMQQQQ+DogACgCCCIAEMoMIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBDLDCAAKAIEQQxBBBD4OiAAKAIIEMsMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4AEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBCIBEMwMIAFBDEEEEPg6IAAoAggiABDMDCAAQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuCBAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQQzQwgACgCBEEMQQQQ+DogACgCCBDNDCAAKAIIQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuABAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQiARDODCABQQxBBBD4OiAAKAIIIgAQzgwgAEEMQQQQ+DoPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCw8LIABBBGoQ8iULgAQBAX8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAADigLCwsLCwsLCwsLCwsLAQsLCwsLCwsLCwsLCwsCAwQFBgcICQsLCwsKAAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEEahDyJQsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQogAEEIahDyJQwKCyAAKAIEIgFFDQkgASABKAIAIgFBAWs2AgAgAUEBRw0JIABBBGoQkiwPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNCAwJCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBwwICyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQUMBgsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQMgAEEEahCFHQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0PCyAAKAIEIgEQzwwgAUEMQQQQ+DogACgCCCIAEM8MIABBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC4IEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBBDQDCAAKAIEQQxBBBD4OiAAKAIIENAMIAAoAghBDEEEEPg6DwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEEahDyJQsPCyAAQQRqEPIlC8kDAgZ+An8jAEHQAGsiCSQAIAlBQGsiCkIANwMAIAlCADcDOCAJIAApAwgiAzcDMCAJIAApAwAiBDcDKCAJIANC88rRy6eM2bL0AIU3AyAgCSADQu3ekfOWzNy35ACFNwMYIAkgBELh5JXz1uzZvOwAhTcDECAJIARC9crNg9es27fzAIU3AwggCUEIaiIAIAEgAhC7CSAJQf8BOgBPIAAgCUHPAGpBARC7CSAJKQMIIQQgCSkDGCEDIAo1AgAhByAJKQM4IQUgCSkDICAJKQMQIQggCUHQAGokACAFIAdCOIaEIgeFIgVCEIkgBSAIfCIFhSIGQhWJIAYgAyAEfCIEQiCJfCIGhSIIQhCJIAggBSADQg2JIASFIgN8IgRCIIlC/wGFfCIFhSIIQhWJIAggBCADQhGJhSIDIAYgB4V8IgRCIIl8IgeFIgZCEIkgBiAEIANCDYmFIgMgBXwiBEIgiXwiBYUiBkIViSAGIAQgA0IRiYUiAyAHfCIEQiCJfCIHhSIGQhCJIAYgA0INiSAEhSIDIAV8IgRCIIl8IgWFQhWJIANCEYkgBIUiA0INiSADIAd8hSIDQhGJhSADIAV8IgNCIImFIAOFC4AEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQgMCQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcMCAsgACgCCCIBIAEoAgAiAUEBazYCACABQQFHDQYgAEEIahDyJQ8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0EDAULIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0DIABBBGoQhR0PCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAiAAQQRqEIYdDwsgACgCBCIBENIMIAFBDEEEEPg6IAAoAggiABDSDCAAQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQuCBAEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAAAOKAsLCwsLCwsLCwsLCwsBCwsLCwsLCwsLCwsLCwIDBAUGBwgJCwsLCwoACyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPIlCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNCiAAQQhqEPIlDAoLIAAoAgQiAUUNCSABIAEoAgAiAUEBazYCACABQQFHDQkgAEEEahCSLA8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0HDAgLIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0GIABBCGoQ8iUPCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBQwGCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNBAwFCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDwsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQIgAEEEahCGHQ8LIAAoAgQQ0wwgACgCBEEMQQQQ+DogACgCCBDTDCAAKAIIQQxBBBD4Og8LIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULDwsgAEEEahDyJQvpAwEBfyAAQShqIgEQ0ykgARDeOyAAQThqEN47IAAoAoQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQYQBahCDIAsgACgCiAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBiAFqEIYfCyAAKAKMASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGMAWoQriALIABByABqIgEQ3BggARDsOyAAQdQAaiIBELErIAFBBEEMEOAeIABB4ABqIgEQuiogAUEEQQwQ4B4gAEHsAGoiARC7KiABQQRBDBDgHiAAQfgAaiIBEOApIAEQ8jsCQCAAKAK8AUGAgICAeEYNACAAQbwBaiIBEKsBIAEQ9DsgACgCyAEiASABKAIAIgFBAWs2AgAgAUEBRw0AIABByAFqEPgjCyAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ+CMLIAAoArABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbABahCDIAsgAEGYAWoiARCjJyABEOk7IABBpAFqEOk7IAAoArQBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQbQBahD4IwsgACgCuAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBuAFqEK4gCyAAQRBqEIcaC6AEAgZ/An4jAEHQAGsiAiQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAIAAtAERBAWsOAwUBAAILIABBOGohBQJAAkAgAC0AOEEBaw4DCwIAAQsgACgCNCEEDAQLIAApAyghCCAAKQMgIQkgACgCMAwCCwALIABBADoAOCAAIAApAxgiCDcDKCAAIAApAxAiCTcDICAAIAA2AjAgAEE4aiEFIAALIAJBCGoQzyIgAigCDCEEIAIoAgghBigCCBD0OiEHQShBCBCtNiIDRQ0FIANBADoAICADIAc2AhQgAyAGNgIQIAMgCDcDCCADIAk3AwAgA0HM3sIAENQaIAAgBDYCNAsgAkFAayIDIARBCGogARDeFCACKAJAIgFBgYCAgHhGDQEgAikCRCEIIABBNGoQsCwgAUGAgICAeEcNAkGc4MIAQSsgA0H44MIAQfz0wgAQ1R4AC0GM9sIAEOgrAAtBAyEEIAVBAzoAAAwBC0EBIQQgAEEBOgA4IAIgCDcCKCACIAE2AiQgAkEUaiIDIAJBJGoQ5xUgAkEwaiAAKAJAIAMQxiYgAigCMA0DIAAoAggiA0GEAUkNACADEPIfCyAAIAQ6AEQgAkHQAGokACABQYGAgIB4Rg8LQQhBKBCjPQALQez0wgAQ6CsACyACQcgAaiACQThqKQIANwMAIAIgAikCMDcDQEGc4MIAQSsgAkFAa0GM4MIAQZz2wgAQ1R4AC6AEAgZ/An4jAEHQAGsiAiQAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAIAAtAERBAWsOAwUBAAILIABBOGohBQJAAkAgAC0AOEEBaw4DCwIAAQsgACgCNCEEDAQLIAApAyghCCAAKQMgIQkgACgCMAwCCwALIABBADoAOCAAIAApAxgiCDcDKCAAIAApAxAiCTcDICAAIAA2AjAgAEE4aiEFIAALIAJBCGoQzyIgAigCDCEEIAIoAgghBigCCBD0OiEHQShBCBCtNiIDRQ0FIANBADoAICADIAc2AhQgAyAGNgIQIAMgCDcDCCADIAk3AwAgA0HopMMAENQaIAAgBDYCNAsgAkFAayIDIARBCGogARDeFCACKAJAIgFBgYCAgHhGDQEgAikCRCEIIABBNGoQsCwgAUGAgICAeEcNAkHgpsMAQSsgA0Gsp8MAQfy4wwAQ1R4AC0GMusMAEOgrAAtBAyEEIAVBAzoAAAwBC0EBIQQgAEEBOgA4IAIgCDcCKCACIAE2AiQgAkEUaiIDIAJBJGoQ5xUgAkEwaiAAKAJAIAMQxiYgAigCMA0DIAAoAggiA0GEAUkNACADEPIfCyAAIAQ6AEQgAkHQAGokACABQYGAgIB4Rg8LQQhBKBCjPQALQey4wwAQ6CsACyACQcgAaiACQThqKQIANwMAIAIgAikCMDcDQEHgpsMAQSsgAkFAa0HQpsMAQZy6wwAQ1R4AC9kEAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQEEBIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOCQECAwQFBgcICQALIAIgAEEEajYCDCABQZjKzABBFEGsyswAQQggAEEQakH4ycwAQbTKzABBCyACQQxqQYjKzAAQjhgMCQsgAiAANgIMIAFBv8rMAEERQdDKzABBBSAAQQxqQfjJzABB1crMAEEKIABBGGpB+MnMAEG0yswAQQsgAkEMakGIyswAEIkXDAgLIAIgAEEEajYCDCABQdjJzABBCUGAy8wAQQUgAEEQakHgyswAQYXLzABBBSAAQRhqQfDKzABBtMrMAEELIAJBDGpBiMrMABCJFwwHCyACIABBBGo2AgwgAUGKy8wAQRVBhcvMAEEFIABBEGpB8MrMAEG0yswAQQsgAkEMakGIyswAEI4YDAYLIAIgAEEEajYCDCABQZ/LzABBCUGoy8wAQQggAEEcakG4ycwAQbDLzABBDiAAQRBqQfjJzABBtMrMAEELIAJBDGpBiMrMABCJFwwFCyACIABBBGo2AgwgAUG+y8wAQRBBhcvMAEEFIABBEGpB8MrMAEG0yswAQQsgAkEMakGIyswAEI4YDAQLIAIgAEEEajYCDCABQeDLzABBF0H3y8wAQQcgAEEQakHQy8wAQajLzABBCCAAQRRqQbjJzABBtMrMAEELIAJBDGpBiMrMABCJFwwDCyABQf7LzABBDRD7NQwCCyABQYvMzABBFBD7NQwBCyABQZ/MzABBERD7NQsgAkEQaiQAC9kEAQJ/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQEEBIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOCQECAwQFBgcICQALIAIgAEEEajYCDCABQbyhzwBBFEHQoc8AQQggAEEQakGcoc8AQdihzwBBCyACQQxqQayhzwAQjhgMCQsgAiAANgIMIAFB46HPAEERQfShzwBBBSAAQQxqQZyhzwBB+aHPAEEKIABBGGpBnKHPAEHYoc8AQQsgAkEMakGsoc8AEIkXDAgLIAIgAEEEajYCDCABQdCgzwBBCUGkos8AQQUgAEEQakGEos8AQamizwBBBSAAQRhqQZSizwBB2KHPAEELIAJBDGpBrKHPABCJFwwHCyACIABBBGo2AgwgAUGuos8AQRVBqaLPAEEFIABBEGpBlKLPAEHYoc8AQQsgAkEMakGsoc8AEI4YDAYLIAIgAEEEajYCDCABQcOizwBBCUHMos8AQQggAEEcakHYn88AQdSizwBBDiAAQRBqQZyhzwBB2KHPAEELIAJBDGpBrKHPABCJFwwFCyACIABBBGo2AgwgAUHios8AQRBBqaLPAEEFIABBEGpBlKLPAEHYoc8AQQsgAkEMakGsoc8AEI4YDAQLIAIgAEEEajYCDCABQYSjzwBBF0Gbo88AQQcgAEEQakH0os8AQcyizwBBCCAAQRRqQdifzwBB2KHPAEELIAJBDGpBrKHPABCJFwwDCyABQaKjzwBBDRD7NQwCCyABQa+jzwBBFBD7NQwBCyABQcOjzwBBERD7NQsgAkEQaiQAC4QMAhF/AX4gAygCVCEMIAAgBCAFaiIJQYKAgHhBgoCAgAYgB0EARyADKAIcQQFrQQJJcSIIG2ogBCAFQf7//wdB/v///3kgCBsiCEsbIgQgBSAIIAUgCEkbIgVBABCDFxogAUUgDEEBR3JFBEAgASAEIAVBABCDFxogASADKAIwBH9BAAUgCSABKAIEaws2AhwjAEEgayIKJAAgASIMKAIEIREgA0HUAGoiCygCCCEIIAsoAgQhDSALKAIMIQ8gCkEQaiALEPwnIAFBJGohDkEAIA9rIRAgDyAEIgFqIRJBfyANIAhrdEF/cyETA0AgASAJSQRAIApBADYCDCAKQRBqIAEgCSABayAOIApBDGoQ/AohFiAKKAIMIQ0gDiEIA0AgDQRAIBIgASAIKAIAaiIUTQRAIAwoAhggECAUaiIUIA8Q0z0iGacgE3EiFSALKAAIIhd0QQN0aiAMKAIgIBVqIhUtAAAiGEEDdGogFCARa60gGUKAgICAcIOENwIAIBUgGEEBakF/IBd0QX9zcToAAAsgCEEEaiEIIA1BAWshDQwBCwsgASAWaiEBDAELCyAKQSBqJAALAkAgAygCHEEHSwRAIAUhAQwBCyAFQQhBHCADKAIMIgEgAygCCCIIIAEgCEsbIgEgAUEcTxt0IgggBSAISRshASAJIAhrIAQgBSAISxshBAsgACADKAKIATYCaCAAIAQgACgCBCIFazYCHCAAQQAgCSAFayADKAIwGzYCGCABQQlPBEAgACACIAMgBCAJEJsOAkACQAJAAkACQCADKAIcQQFrDgkAAQICAgMDAwMECyAAIAkgBiAHEPENDAMLIAAgCSAGIAcQywsMAgsgACgCbARAIAAoAlwiB0EBIAAoAsABQQJrIg90IgxBAnQiAyAAKAIcIgFBAnRqIAlBCGsgACgCBCINayIIQQMgD3QiAmsgASACIAhJGyIOQQJ0a2ohBiABIAggASAISxshBSAIQQEgACgCvAF0IgprIQtBASAAKALEAXRBA2shAiAIIAFrIRAgAyAHaiERIAAoAmQhEiABIQMDQCADIAVGBEBB/wEgAiACQf8BTxshBSALIAEgCiAQSRshEEEAIQFBACEKA38gCiAMRgR/IAcgDEEEdGoFQQAhBkEAIQsgByAKQQJ0aiITIQMDQCADKAIAIgMgDkkgBkECS3JFBEAgBkEBaiEGIAsgAyAQSWohCyARIAMgDmtBAnRqIQMMAQsLQQAhBAJAIAZBA0cNACASIAFBAnRqIQYgASECAkADQCAEIAVGBEAgBSEEIAIhAQwDCyADIBBJBEAgA0UNAiALQQFqIgtBA0sNAgsgBiADNgIAIAJBAWohAiADIA5PBEAgBEEBaiEEIAZBBGohBiARIAMgDmtBAnRqKAIAIQMMAQsLIARBAWohBCACIQEMAQsgASAEaiEBCyATIAEgBGtBCHQgBGpBACAEGzYCACAKQQFqIQoMAQsLIQYDQAJAIAwEQCAHIAxBAWsiDEECdCIBaigCACECQXAhAwNAIANBfEYNAiADIAZqQQA2AgAgA0EEaiEDDAALAAsgACgCHCIDIAggAyAISxshAgNAIAIgA0cEQCAHIAMgDWogDyAAKALIARCjHUEEdGoiASkCACEZIAEgAzYCACABQQRqIBk3AgAgA0EBaiEDDAELCyAAIAg2AhwMBgsgByABQQJ0akEMaiACNgIAIAZBEGshBgwACwALIAMgDWogDyAAKALIARCjHSEEIAMgDk8EQCAGIAcgBEECdGooAgA2AgALIAcgBEECdGogAzYCACAGQQRqIQYgA0EBaiEDDAALAAsgAygChAFBAUYEQEEBIAMoAgx0IgEEQCAAKAIoQQAgAfwLAAsgACAJQQhrQQYgACgCyAEiASABQQZPG0EEQQYgACgCxAEiASABQQZPGyIBIAFBBE0bIgFBfyABdEF/c0EAELAgDAILIAAgAEG4AWogCUEIayAAKALIAUEAELwZGgwBCyAAIAlBCGsgCSAAKALIAUEAEKUJCyAAIAkgACgCBGs2AhwLC4oEAgV/BH4jAEGQAWsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBBHRqIgcpAwAiCCAHKQMIIgkQsi4gBiADKQMQIAMpAxggAykDICADKQMoIAQoAgAiBCkDACAEKQMIIAQpAxAgBCkDGBCcBgJAAkACfiADKAIQIgRBAUYEQCAEBEAgBkEEchCIEQsgBSgCBCEBIAMgCTcDaCADIAg3A2AgA0HMkf8ANgJ4IANCBDcChAEgA0GEDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AoABIAMgA0HgAGo2AiggA0EENgJ8IANB0ABqIANB+ABqEJkOIANBCGogA0HUAGooAgA2AgAgA0GCgICAeDYCTCADIAMpAkw3AwAgAykCWAwBCyADQRBqIAMpAyAiCCADKQMoIgkgAykDMCIKIAMpAzgiCyAFKAIILQAAENAOIAMoAhBBk4CAgHhGDQEgA0EIaiADQRhqKAIANgIAIAMgAykCEDcDACADKQIcCyEIIAAgAykDADcCACAAIAg3AgwgAEEIaiADQQhqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAs3AxggACAKNwMQIAAgCTcDCCAAIAg3AwALIANBkAFqJAALhwQCBn8BfiMAQdAAayICJAACQCABKAJYIgQEQCABQQA2AlggASgCVCEDIAEoAlAhBSABQoCAgIAQNwNQIAIgBTYCTCACQoCAgIAQNwJEIAIgBDYCQCACIAM2AjwgAiACQTxqENc7IAIoAgAhB0EcQQQQrTYiA0UNASADQoGAgIAQNwIAIAMgAikCPDcCCCADQRBqIAJBxABqKQIANwIAIANBGGogAkHMAGooAgA2AgAgASgCTCIFIAEoAkRGBEAgAUHEAGpBlMaFARCQKAsgASgCSCAFQQxsaiIGIAQ2AgggBiAHNgIEIAYgAzYCACABIAVBAWo2AkwLIAEpAkQhCCABQoCAgIDAADcCRCACQRBqIgMgAUHMAGoiBCgCADYCACAEQQA2AgAgAiAINwMIIAJBGGogAUHcAGoQ9BICQCABKAIIRQ0AIAEoAhRFDQAgAUEIahCJIAsgASkCOCEIIAFCgICAgIACNwM4IAJBOGogAUFAayIBKAIANgIAIAFBADYCACACIAg3AzAgAEEYaiACQTBqELoYIABBFGpBmrTo0AE2AgAgAEKatOjQocOGjRo3AgwgACACKQMINwIAIABBCGogAygCADYCACAAIAIpAhg3AiQgAEEsaiACQSBqKQIANwIAIABBNGogAkEoaikCADcCACACQdAAaiQADwtBBEEcEKM9AAuHBAIGfwF+IwBB0ABrIgIkAAJAIAEoAlgiBARAIAFBADYCWCABKAJUIQMgASgCUCEFIAFCgICAgBA3A1AgAiAFNgJMIAJCgICAgBA3AkQgAiAENgJAIAIgAzYCPCACIAJBPGoQ1zsgAigCACEHQRxBBBCtNiIDRQ0BIANCgYCAgBA3AgAgAyACKQI8NwIIIANBEGogAkHEAGopAgA3AgAgA0EYaiACQcwAaigCADYCACABKAJMIgUgASgCREYEQCABQcQAakGUxoUBEJAoCyABKAJIIAVBDGxqIgYgBDYCCCAGIAc2AgQgBiADNgIAIAEgBUEBajYCTAsgASkCRCEIIAFCgICAgMAANwJEIAJBEGoiAyABQcwAaiIEKAIANgIAIARBADYCACACIAg3AwggAkEYaiABQdwAahD0EgJAIAEoAghFDQAgASgCFEUNACABQQhqEIkgCyABKQI4IQggAUKAgICAgAI3AzggAkE4aiABQUBrIgEoAgA2AgAgAUEANgIAIAIgCDcDMCAAQRhqIAJBMGoQuhggAEEUakGXrty4ATYCACAAQpeu3Ljx4sWLFzcCDCAAIAIpAwg3AgAgAEEIaiADKAIANgIAIAAgAikCGDcCJCAAQSxqIAJBIGopAgA3AgAgAEE0aiACQShqKQIANwIAIAJB0ABqJAAPC0EEQRwQoz0AC+QDAgR/AX4jAEEwayIHJAACQAJAIAMgBE8EQCAERQRAIAEoAgQgASgCCCIEIAIgASgCECABKAIUIgJrIgUgAyADIAVLGyIDQQN0IARBA3YgAhCBFiAAIAM2AgQgASACIANqNgIUIABBCDYCAAwDCyAHIAMgBGsiCTYCACABKAIEIAEoAggiCiACIAEoAhAgASgCFCIIayIEIAMgAyAESxsiBEEDdCAKQQN2IAgQgRYgASAEIAhqNgIUIAcgBDYCBCAEIAlHDQEgA0EBayEBIANBA3QgAmpBCGshBANAAkACQCAGIAFBA3YiCEsEQCABQQdxQfzEzgBqLQAAIAUgCGotAABxRQ0CIAlBAWsiCSADTw0BIAQpAwAhCyAEIAIgCUEDdGoiCCkDADcDACAIIAs3AwAMAgsgCCAGQaj1zAAQwyEACyAJIANBhPfMABDDIQALIARBCGshBCABQQFrIgFBf0cNAAsgAEEINgIAIAAgAzYCBAwCC0HI9swAQSxB9PbMABCfKQALIAdBAjYCDCAHQcj3zAA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAsgB0EwaiQAC+IDAQR/IwBBMGsiByQAAkACQCADIARPBEAgBEUEQCABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0ECdCAEQQJ2IAIQghYgACADNgIEIAEgAiADajYCFCAAQQg2AgAMAwsgByADIARrIgk2AgAgASgCBCABKAIIIgogAiABKAIQIAEoAhQiCGsiBCADIAMgBEsbIgRBAnQgCkECdiAIEIIWIAEgBCAIajYCFCAHIAQ2AgQgBCAJRw0BIANBAWshASADQQJ0IAJqQQRrIQQDQAJAAkAgBiABQQN2IghLBEAgAUEHcUH8xM4Aai0AACAFIAhqLQAAcUUNAiAJQQFrIgkgA08NASAEKAIAIQggBCACIAlBAnRqIgooAgA2AgAgCiAINgIADAILIAggBkGo9cwAEMMhAAsgCSADQYT3zAAQwyEACyAEQQRrIQQgAUEBayIBQX9HDQALIABBCDYCACAAIAM2AgQMAgtByPbMAEEsQfT2zAAQnykACyAHQQI2AgwgB0HI98wANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgALIAdBMGokAAviAwIFfwJ+IwBB8ABrIgIkACAAKAIAIgQoAgAhBSACQdAAaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAJQQQFxRQ0AIAIpA2AiB0KAgICACHwiCEL/////D1YgAikDaCAHIAhWrXwiCEIAUiAIUBsNACACIAUoAgAoAgAiAzYCKCACIAc+AiQCQCADrCAHxH4iB0IgiKcgB6ciA0EfdUcEQCACQQI2AlQgAkGskP8ANgJQIAJCAjcCXCACQYIMNgJMIAJBggw2AkQgAiACQUBrNgJYIAIgAkEoajYCSCACIAJBJGo2AkAgAkEwaiAGEJkOIAJBGGogAkE0aikCADcDACACQSBqIAJBPGooAgA2AgAgAkGIgICAeDYCLCACIAIpAiwiBzcDECAHp0GTgICAeEcNASACKAIUIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEQahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB8ABqJAAPCyAAIANBiIv/ABDDIQALrgMBAX8gAEEEaiEBAkACQAJAAkACQAJAIAAoAgAOBQECBAMEAAsgASgCACIAQYQBSQ0EIAAQ8h8PCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgASgCACIAKAIAIgFBgICAgHhzIAFBAE4bDhAAAQIDBAUGDwcICQoLDA0ODwsgAEEEahDeOwwOCyAAQQRqELwqDA0LIABBBGoQ3jsMDAsgAEEEahDeOwwLCyAAQQRqEN47DAoLIABBBGoQ3jsMCQsgAEEEahDeOwwICyAAQQRqEN47DAcLIABBBGoQ3jsMBgsgAEEEahDeOwwFCyAAEN47IAAtAAxBA0cNBCAAKAIQIgEQvCogAUEMQQQQ+DoMBAsgAEEEahDeOwwDCyAAQQRqEN47DAILIABBBGoQ3jsMAQsgAEEEahDeOwsgAEEUQQQQ+DoPCyABKAIAIgAQySMgAEEYQQgQ+DoPCyABKAIAIgEoAgAiACgCTARAIABBzABqELwqCyAAKAIAQQJHBEAgAEEQahDeOwsgAEHUAEEEEPg6IAFBBEEEEPg6DwsgARDeOwsL0xUBBn8gCygCACETAkACQAJAAkACQAJAAkACQAJAAkACQAJAIApnQSBqQT9zQQhrDgoAAQIDBAUGBwgJCgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEIQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQ0CQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMCQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEJQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQwCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMCAsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEKQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQsCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBwsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUELQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQoCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEMQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQkCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUENQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQgCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMBAsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEOQQQgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQcCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAwsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEPQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQYCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAgsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUEQQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQUCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsMAQsjAEEgayIOJAACQCACIgoEQANAIA5BADYCCCAOQQA2AgwgDiAHNgIUIA4gBjYCECAOIAU2AhwgDiAENgIYIA9BgIAIIAogCkGAgAhPGyIQIAogACABIAggCUERQQYgDkEQaiAOQQhqIA5BGGogDkEMahCtASABIA9JDQQCQCAAIA9qIhEgASAPayISIBAgDigCCBDdFUUEQCARIBIgECALIAwgDRCpIQwBCyAQQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAYgByAOKAIIIAQgBSAOKAIMIAsgDCANENoICyAPIBBqIQ8gCiAQayIKDQALCyAOQSBqJAAMAAsLIAJBA3RBH2ogCygCACATa0kEQAJAIA0gE0EDdiIESwRAIAsgEzYCACAEIAxqIgQgBC0AAEF/IBNBB3F0QX9zcToAAAwBCyAEIA1BiI7SABDDIQALIAAgASACIAsgDCANEKkhCyADBEBBAUIBIAsgDCANEN8TQQFCASALIAwgDRDfEyALIAsoAgBBB2pBeHE2AgALDwsgDyABQZjmzgAQrzsAC4AEAgV/BH4jAEHwAGsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBAnRqKAIAIgesIgggCEI/hxCyLiAGIAMpAxAgAykDGCADKQMgIAMpAyggBCgCACIEKQMAIAQpAwggBCkDECAEKQMYEJwGAkACQAJ+IAMoAhAiBEEBRgRAIAQEQCAGQQRyEIgRCyAFKAIEIQEgAyAHNgJUIANBzJH/ADYCWCADQgQ3AmQgA0GCDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AmAgAyADQdQAajYCKCADQQQ2AlwgA0HEAGogA0HYAGoQmQ4gA0EIaiADQcgAaigCADYCACADQYKAgIB4NgJAIAMgAykCQDcDACADKQJMDAELIANBEGogAykDICIIIAMpAygiCSADKQMwIgogAykDOCILIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQggACADKQMANwIAIAAgCDcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCzcDGCAAIAo3AxAgACAJNwMIIAAgCDcDAAsgA0HwAGokAAuRBAIGfwJ+IwBBgAFrIgMkACABKAIMKAIQIAJBAnRqKAIAIQQgAyABKAIIIgUoAgAoAgApAwAiCTcDGCADIASsIgo3AxAgAyAKIApCP4cgCSAJQj+HEKgeAkACQAJ+IAMpAwggAykDACIJQj+HUgRAIANBAjYCZCADQayQ/wA2AmAgA0ICNwJsIANBhgw2AjAgA0GGDDYCKCADIANBJGoiBjYCaCADIANBGGo2AiwgAyADQRBqNgIkIANBOGoiAiADQeAAaiIHEJkOIANB1ABqIANBPGopAgA3AgAgA0HcAGogA0HEAGooAgA2AgAgA0GIgICAeDYCNCADIAMpAjQ3AkwgA0EBNgJIIANByABqIghBBHIQiBEgBSgCBCEBIAMgBDYCJCADQQQ2AkwgA0HMkf8ANgJIIANCBDcCVCADQYIMNgJ8IANB9As2AnQgAyABQQFqNgJwIANBuwc2AmwgAyABNgJoIANBzAE2AmQgA0Ggkv8ANgJgIAMgBzYCUCADIAY2AnggAiAIEJkOIAMpAkAhCkGCgICAeCEEIAMpAjgMAQsgA0HgAGogCSAFKAIILQAAEI0QIAMoAmAiBEGTgICAeEYNASADKQJsIQogAykCZAshCSAAIAo3AgwgACAJNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEDdGogCTcDAAsgA0GAAWokAAuLBAIEfwR+IwBBoAFrIgMkACADQRBqIgYgASgCDCgCECACQQV0aiIEKQMAIgcgBCkDCCIIIAQpAxAiCSAEKQMYIgogASgCCCIFKAIAKAIAIgQpAwAgBCkDCCAEKQMQIAQpAxgQnAYCQAJAAn4gAygCECIEQQFGBEAgBARAIAZBBHIQiBELIAUoAgQhASADIAo3A3ggAyAJNwNwIAMgCDcDaCADIAc3A2AgA0HMkf8ANgKIASADQgQ3ApQBIANBgww2AiwgA0H0CzYCJCADIAFBAWo2AiAgA0G7BzYCHCADIAE2AhggA0HMATYCFCADQYyS/wA2AhAgAyADQRBqNgKQASADIANB4ABqNgIoIANBBDYCjAEgA0HQAGogA0GIAWoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIHIAMpAygiCCADKQMwIgkgAykDOCIKIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQcgACADKQMANwIAIAAgBzcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCjcDGCAAIAk3AxAgACAINwMIIAAgBzcDAAsgA0GgAWokAAvdAwIEfg9/AkAgACgCDCIGIAEoAgxHDQAgAUEQaiENIAEoAgAiC0EYayEOIAAoAgAiB0EIaiEAIAcpAwBCf4VCgIGChIiQoMCAf4MhAiABKAIEIQoDQAJAIAZFIQ8gBkUNACAGQQFrIQYgAlAEQANAIAdBwAFrIQcgACkDACAAQQhqIQBCgIGChIiQoMCAf4MiA0KAgYKEiJCgwIB/UQ0ACyADQoCBgoSIkKDAgH+FIQILIAJCAX0gAoNBACEMIAcgAnqnQQN2QWhsaiIIQRBrIRAgCEEUayERIAogDSAIQRhrEPgLIgKncSEJIAJCGYhC/wCDQoGChIiQoMCAAX4hBQNAAkAgCSALaikAACIEIAWFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQCAQKAIAIRIgESgCACETA0AgEyASIA4gAnqnQQN2IAlqIApxQWhsIhRqIgEoAgQgASgCCBDBLg0CIAJCAX0gAoMiAlBFDQALCyAEIARCAYaDQoCBgoSIkKDAgH+DUEUNBCAJIAxBCGoiDGogCnEhCQwBCwshAiAIQQhrKAIAIAhBBGsoAgAgCyAUaiIBQQhrKAIAIAFBBGsoAgAQwS4NAQsLIA8PC0EAC5EEAQF/AkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiAC0AAA4oCwsLCwsLCwsLCwsLCwELCwsLCwsLCwsLCwsLAgMEBQYHCAkLCwsLCgALIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBBGoQ8iULIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0KIABBCGoQ8iUMCgsgACgCBCIBRQ0JIAEgASgCACIBQQFrNgIAIAFBAUcNCSAAQQRqEJIsDAkLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0IIABBBGoQ8iUMCAsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQcgAEEEahDyJQwHCyAAKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNBiAAQQhqEPIlDAYLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0FIABBBGoQ8iUMBQsgACgCBCIBIAEoAgAiAUEBazYCACABQQFHDQQgAEEEahDyJQwECyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNAyAAQQRqEIUdDAMLIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBBGoQhh0MAgsgAEEEahDmDCAAQQhqEOYMDAELIAAoAgQiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ8iULIABBDEEEEPg6C9UDAQt/IwBBIGsiAiQAIAEoAgghCSABKAIAIQogAkEUaiABKAIMIgcgASgCBCIBa0EDdkEAQQRBCBCgGCACKAIYIQMCQAJAAkAgAigCFEEBRwRAIAJBADYCECACIAIoAhwiBDYCDCACIAM2AggCQANAIAEgB0YNASABKAIAIQUgAUEIaiEBIAVFDQALIAFBBGstAAAhBiADRQRAIAJBCGpBzIPNABCbKCACKAIMIQQLIAQgBjoABCAEIAU2AgAgAkEBNgIQCwNAIAEiAyAHRg0CIAFBCGohASADKAIAIgVFDQAgAigCECIERQ0DIAIoAgwiBiAEQQN0IgtqIgxBCGsiCEUNAyADQQRqLQAAIgMgDEEEay0AAEcEQCACKAIIIARGBH8gAkEIakHsg80AEJsoIAIoAgwFIAYLIAtqIgYgAzoABCAGIAU2AgAgAiAEQQFqNgIQDAELIAgoAgAiAyAFaiIEIANJDQQgCCAENgIADAALAAsgAyACKAIcQbyDzQAQ/S8ACyACIAo2AhggAiAJNgIUIAJBFGpBBEEIEOAeIABBCGogAkEQaigCADYCACAAIAIpAgg3AgAgAkEgaiQADwtB3IPNABCyOwALQfyDzQAQsjsAC8MEAgl/An4jAEGQAmsiAiQAIAEtAEEhBiABLQAoIQcgAS0AQCEIIAJB+ABqIAFBKGoQsQECQCACKAJ4QQFGBEAgAkHQAGogAkGMAWooAgAiATYCACACQcgAaiACQYQBaikCACILNwMAIAIgAikCfCIMNwNAIABBFGogATYCACAAQQxqIAs3AgAgACAMNwIEIABBATYCAAwBCyACQcQAaiIDIAJBgAFqQTD8CgAAIAJBsAFqIgQgA0Ew/AoAACACQQhqIQUgASgCOCEJIAEoAjwhCiMAQSBrIgMkACADIAkgChC/DwJAIAMoAgBBgICAgHhGBEAgBCADKAIENgIEIAVBCGogBEEw/AoAACAFQQA2AgAgA0EgaiQADAELIANBGGogA0EIaikCADcDACADIAMpAgA3AxBBzNWHAUErIANBEGpB+NWHAUHQ1ocBENUeAAsgAigCCEEBRgRAIAJBiAFqIAJBHGooAgAiATYCACACQYABaiACQRRqKQIAIgs3AwAgAiACKQIMIgw3A3ggAEEUaiABNgIAIABBDGogCzcCACAAIAw3AgQgAEEBNgIADAELIAJBhAFqIAJBGGopAwAiCzcCACACQYACaiACQTBqKQMANwMAIAJBiAJqIAJBOGopAwA3AwAgAkHoAWogCzcDACACIAIpAxAiCzcCfCACIAIpAyg3A/gBIAIgCzcD4AEgAiAGQQAgB0EiRhutQv8Bg0ICQgAgCBuENwPwASAAIAJB4AFqIAEQ6AgLIAJBkAJqJAAL9QQBB38jAEEgayIGJABBASEIIAEgASgCFCIHQQFqIgU2AhQCQCAFIAEoAhAiCU8NAAJAAkAgASgCDCAFai0AAEEraw4DAQIAAgtBACEICyABIAdBAmoiBTYCFAsCQAJAIAUgCUkEQCABIAVBAWoiBzYCFCABKAIMIgsgBWotAABBMGtB/wFxIgVBCk8EQCAGQQ02AhQgBiABQQxqIAcQ6gwgBkEUaiAGKAIAIAYoAgQQ+yghASAAQQE2AgAgACABNgIEDAMLIAcgCU8NAQNAIAcgC2otAABBMGtB/wFxIgpBCk8NAiABIAdBAWoiBzYCFCAFQcyZs+YARyAKQQdLciAFQcuZs+YASnFFBEAgBUEKbCAKaiEFIAcgCUcNAQwDCwsjAEEgayIEJAAgAAJ/AkAgA0IAIAgbUARAIAEoAhQiBSABKAIQIgdPDQEgASgCDCEIA0AgBSAIai0AAEEwa0H/AXFBCk8NAiABIAVBAWoiBTYCFCAFIAdHDQALDAELIARBDjYCFCAEQQhqIAFBDGogASgCFBDqDCAAIARBFGogBCgCCCAEKAIMEPsoNgIEQQEMAQsgAEQAAAAAAAAAAEQAAAAAAAAAgCACGzkDCEEACzYCACAEQSBqJAAMAgsgBkEFNgIUIAZBCGogAUEMaiAFEOoMIAZBFGogBigCCCAGKAIMEPsoIQEgAEEBNgIAIAAgATYCBAwBCyAAIAEgAiADAn8gCEUEQCAEIAVrIgBBH3VBgICAgHhzIAAgACAESCAFQQBKcxsMAQsgBCAFaiIAQR91QYCAgIB4cyAAIAVBAEggACAESHMbCxCwEgsgBkEgaiQAC94DAQV/AkACQAJAAkACQCABKAIEIgcgAk8EQCABKAIAIQEgAkUNBCABIAJqIgMgARCWPiIGQQNNBEADQCABIANPDQYgA0EBayIDLQAAQQpHDQAMBQsAC0GAgoQIIANBBGsoAAAiBEGKlKjQAHNrIARyQYCBgoR4cUGAgYKEeEcEQANAIAEgA08NBiADQQFrIgMtAABBCkcNAAwFCwALIAIgA0EDcWshBCAGQQlJDQEDQCAEIgNBCEgNA0GAgoQIIAEgA2oiBkEIaygCACIEQYqUqNAAc2sgBHJBgIGChHhxQYCBgoR4Rw0DIANBCGshBEGAgoQIIAZBBGsoAgAiBkGKlKjQAHNrIAZyQYCBgoR4cUGAgYKEeEYNAAsMAgsgAiAHQejFiAEQsDsACyABIARqIQMDQCABIANPDQMgA0EBayIDLQAAQQpHDQALDAELIAEgA2ohAwNAIAEgA08NAiADQQFrIgMtAABBCkcNAAsLIAMgARCWPkEBaiIFIAdLDQELQQEhAyAAIAEgBWogAUsEf0EAIQMgBSEEA0AgAyABLQAAQQpGaiEDIAFBAWohASAEQQFrIgQNAAsgA0EBagUgAws2AgAgACACIAVrNgIEDwsgBSAHQfjFiAEQsDsAC8ADAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCCABKAIANgJMIAhBCGogCEHMAGpBBBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC8ADAgZ+An8jAEHQAGsiCCQAIAhBQGsiCUIANwMAIAhCADcDOCAIIAApAwgiAjcDMCAIIAApAwAiAzcDKCAIIAJC88rRy6eM2bL0AIU3AyAgCCACQu3ekfOWzNy35ACFNwMYIAggA0Lh5JXz1uzZvOwAhTcDECAIIANC9crNg9es27fzAIU3AwggCCABLQAANgJMIAhBCGogCEHMAGpBBBC7CSAIKQMIIQMgCCkDGCECIAk1AgAhBiAIKQM4IQQgCCkDICAIKQMQIQcgCEHQAGokACAEIAZCOIaEIgaFIgRCEIkgBCAHfCIEhSIFQhWJIAUgAiADfCIDQiCJfCIFhSIHQhCJIAcgBCACQg2JIAOFIgJ8IgNCIIlC/wGFfCIEhSIHQhWJIAcgAyACQhGJhSICIAUgBoV8IgNCIIl8IgaFIgVCEIkgBSADIAJCDYmFIgIgBHwiA0IgiXwiBIUiBUIViSAFIAMgAkIRiYUiAiAGfCIDQiCJfCIGhSIFQhCJIAUgAkINiSADhSICIAR8IgNCIIl8IgSFQhWJIAJCEYkgA4UiAkINiSACIAZ8hSICQhGJhSACIAR8IgJCIImFIAKFC44EAgV/An4jAEGAAWsiAyQAIAEoAgwoAhAgAkEDdGopAwAhCSADIAEoAggiBCgCACgCACkDACIINwMYIAMgCTcDECADIAkgCUI/hyAIIAhCP4cQqB4CQAJAAn4gAykDCCADKQMAIghCP4dSBEAgA0ECNgJkIANBrJD/ADYCYCADQgI3AmwgA0GGDDYCLCADQYYMNgIkIAMgA0EgaiIFNgJoIAMgA0EYajYCKCADIANBEGo2AiAgA0E4aiICIANB4ABqIgYQmQ4gA0HUAGogA0E8aikCADcCACADQdwAaiADQcQAaigCADYCACADQYiAgIB4NgI0IAMgAykCNDcCTCADQQE2AkggA0HIAGoiB0EEchCIESAEKAIEIQEgAyAJNwMgIANBBDYCTCADQcyR/wA2AkggA0IENwJUIANBhgw2AnwgA0H0CzYCdCADIAFBAWo2AnAgA0G7BzYCbCADIAE2AmggA0HMATYCZCADQaCS/wA2AmAgAyAGNgJQIAMgBTYCeCACIAcQmQ4gAykCQCEIQYKAgIB4IQQgAykCOAwBCyADQeAAaiAIIAQoAggtAAAQjRAgAygCYCIEQZOAgIB4Rg0BIAMpAmwhCCADKQJkCyEJIAAgCDcCDCAAIAk3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQN0aiAINwMACyADQYABaiQAC/0DAgR/BH4jAEGAAWsiAyQAIAEoAggiBSgCACEEIANBEGoiBiABKAIMKAIQIAJBA3RqKQMAIgcgB0I/hxCyLiAGIAMpAxAgAykDGCADKQMgIAMpAyggBCgCACIEKQMAIAQpAwggBCkDECAEKQMYEJwGAkACQAJ+IAMoAhAiBEEBRgRAIAQEQCAGQQRyEIgRCyAFKAIEIQEgAyAHNwNgIANBzJH/ADYCaCADQgQ3AnQgA0GGDDYCLCADQfQLNgIkIAMgAUEBajYCICADQbsHNgIcIAMgATYCGCADQcwBNgIUIANBjJL/ADYCECADIANBEGo2AnAgAyADQeAAajYCKCADQQQ2AmwgA0HQAGogA0HoAGoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIHIAMpAygiCCADKQMwIgkgAykDOCIKIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQcgACADKQMANwIAIAAgBzcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCjcDGCAAIAk3AxAgACAINwMIIAAgBzcDAAsgA0GAAWokAAv0AwIEfwJ+IwBBkAFrIgIkAAJAIAEtAHxFBEAgAkHgAGoiBCABENQBIAItAGAiA0EERwRAIARBAXIhBANAQQBFBEAgAiAEQS/8CgAACyAFRQRAIAJBMWogAkEv/AoAAAsCQAJAAkACQCADQQNHBEAgAiADOgBgIAVFBEAgBCACQTFqQS/8CgAACyADQQJGDQQgA0EBaw0BDAILIAFBAToAfCAAQoCAgICAgICAgH83AgAMBwsgAkErQQBBAUEBEKAYIAIoAgQhASACKAIAQQFHDQEgASACKAIIQbDMzAAQ/S8ACyAAIAIpADQ3AAQgAEEANgIAIABBFGogAkHEAGooAAA2AAAgAEEMaiACQTxqKQAANwAADAULIAIoAggiA0HgzMwAQSv8CgAAIABBKzYCECAAIAM2AgwgACABNgIIIABCgYCAgMCBgICAfzcCACACLQBgQQFGDQQgAkHgAGoQmx8MBAsgAkHgAGoiAxCbHyADIAEQ1AEgAi0AYCIDQQRHDQALCyACQRNqIAJB9ABqKAIAIgE2AAAgAkELaiACQewAaikCACIGNwAAIAIgAikCZCIHNwADIABBFGogATYAACAAQQxqIAY3AAAgACAHNwAEIABBATYCAAwBCyAAQoCAgICAgICAgH83AgALIAJBkAFqJAAL7wMBB38gAyACIAIgA0kbIQggAEH8EWohCSABIANBAnRqIQcgACgC9BEhBAJAAkACQAJAAkACQAJAA0AgBEG9BE8NASAAIARBAnRqKAIAIQUgACAEQQFrNgL0ESAAKAIEIQQgACAFNgIEIAAgASACQQEQ/w0gACAAKAL4EUEBayIGNgL4ESAGQbwESw0CIAAoAgQhBSAAIAZBAnRqIAQ2AgAgACAAKAL4EUEBayIGNgL4ESAGQb0ETw0DIAAgBkECdGogBTYCACACIARNDQQgAiAFTQ0FIAMgCEYNBiAHIAEgBUECdGoiBi8BACABIARBAnRqIgovAQBqOwEAIAogAzsBAiAAIANqQfwRaiAFIAlqLQAAIgUgBCAJai0AACIEIAQgBUkbQQFqOgAAIAYgAzsBAiAAIAM2AgQgACABIAJBARD/DSAHQQRqIQcgA0EBaiEDIAAoAvQRIgRBAk8NAAsgACAAKAL4EUEBayIBNgL4ESABQbwETQ0GIAFBvQRBqP/7ABDDIQALIARBvQRByP77ABDDIQALIAZBvQRB2P77ABDDIQALIAZBvQRB6P77ABDDIQALIAQgAkH4/vsAEMMhAAsgBSACQYj/+wAQwyEACyAIIAJBmP/7ABDDIQALIAAgAUECdGogACgCBDYCAAuLEAISfwJ+Qbh/IQgCQAJAIAVFDQAgBCwAACILQf8BcSENAkAgC0EASARAIA1B/gBrQQF2IgYgBU8NAiANQf8AayILQYACTw0DIARBAWohCEEAIQUDQCAFIAtPBEAgBiENDAMFIAAgBWoiBCAILQAAQQR2OgAAIARBAWogCC0AAEEPcToAACAIQQFqIQggBUECaiEFDAELAAsACyAFIA1NDQEjAEEwayIHJAAgB0H/ATYCBAJAIAYgB0EEaiAHQQhqIARBAWoiFiANEP0HIgVBiH9LBEAgBSEEDAELQVQhBCAHKAIIIg9BBksNACAHKAIEIhNBAXRBAmqtQgEgD62GIhpBASAPdCIOrEIChnx8QhN8QnyDQoQEfELsBlYNAAJ/IAZBgARqIREgBkEEIA90IgRqQYgEaiELQeQCIARrIQRBUiEJAkAgE0H/AUsNACAErSAaIBNBAWoiF0EBdK18Qgh8VA0AQVQgD0EMSw0BGiARQQRqIRggCyATQQF0akECaiEUQYCAAiAPdEEQdiEQIAYhCCALIQRBACEJQQEhEiAOQQFrIhUhDANAIAkgF0cEQAJAIAgvAQAiCkH//wNGBEAgGCAMQQJ0akECaiAJOgAAIAxBAWshDEEBIQoMAQsgEkEAIBAgCsFKGyESCyAEIAo7AQAgCEECaiEIIARBAmohBCAJQQFqIQkMAQsLIBEgEjsBAiARIA87AQACQCAMIBVGBEAgCyATQQF0aiEQIA5BA3ZBA2ohDEEAIQRBACEKA0AgBCAXRgRAIAwgDkEBdmoiEEEBdCEIQQAhCkEAIQQDQCAEIA5PDQRBACEJIAohDANAIAlBAkcEQCAYIAwgFXFBAnRqQQJqIAkgFGotAAA6AAAgDCAQaiEMIAlBAWohCQwBCwsgFEECaiEUIARBAmohBCAIIApqIBVxIQoMAAsABSAKIBRqIBk3AAAgCiAQaiEIIAYgBEEBdGouAQAhEkEIIQkDQCAJIBJIBEAgCCAJakECaiAZNwAAIAlBCGohCQwBCwsgGUKBgoSIkKDAgAF8IRkgBEEBaiEEIAogEmohCgwBCwALAAsgDkEDdiAOQQF2akEDaiEQQQAhBEEAIQkDQCAEIBdHBEBBACEIIAYgBEEBdGouAQAiCkEAIApBAEobIQoDQCAIIApHBEAgGCAJQQJ0akECaiAEOgAAA0AgCSAQaiAVcSIJIAxLDQALIAhBAWohCAwBCwsgBEEBaiEEDAELCyAJRQ0AQX8MAgsgEUEHaiEJIA9BH2shDCAOIQQDfyAEBH8gCyAJQQFrLQAAQQF0aiIIIAgvAQAiCkEBajsBACAJIAwgCmdqIgg6AAAgCUEDayAKIAh0IA5rOwEAIAlBBGohCSAEQQFrIQQMAQVBAAsLIQkLIAkLIgRBiH9LDQAgDSAFayIERQRAQbh/IQQMAQsgBi8BggQhCCAHIAUgFmoiBjYCKCAHIAZBBGo2AiwCQAJAIARBBE8EQCAHIA0gFmpBBGsiBTYCJCAHIAUoAAAiBTYCHCAFQYCAgAhPDQFBfyEEDAMLIAcgBjYCJCAHIAYtAAAiBTYCHAJAAkACQCAEQQJrDgIBAAILIAYtAAJBEHQgBXIhBQsgByAGLQABQQh0IAVqNgIcCyANIBZqQQFrLQAAIgVFBEBBbCEEDAMLIAcgBWcgBEEDdGtBCWo2AiAMAQsgB0EIIAVBGHZnQR9zazYCICAEQYh/Sw0BCyAAQf8BaiILQQNrIQYgB0EUaiAHQRxqIgQgERDYLiAHQQxqIAQgERDYLiAAIQUCQANAIAdBHGoiBBD9GCAFIAZPcg0BIAVBAWoCfyAIBEAgBSAHQRRqIAQQ+ic6AAAgB0EMaiAEEPonDAELIAUgB0EUaiAHQRxqIgQQtCw6AAAgB0EMaiAEELQsCzoAACAHQRxqIgQQ/RhFBEAgBUEDagJ/IAgEQCAFQQJqIAdBFGogBBD6JzoAACAHQQxqIAQQ+icMAQsgBUECaiAHQRRqIAdBHGoiBBC0LDoAACAHQQxqIAQQtCwLOgAAIAVBBGohBQwBCwsgBUECaiEFCyALQQJrIQsCfwNAQbp/IQQgBSALSw0CIAUCfyAIBEAgB0EUaiAHQRxqEPonDAELIAdBFGogB0EcahC0LAs6AAAgB0EcaiIGEP0YQQNGBEAgBUEBagJ/IAgEQCAHQQxqIAYQ+icMAQsgB0EMaiAHQRxqELQsCzoAACAFQQJqDAILIAVBAWoiBiALSw0CIAYCfyAIBEAgB0EMaiAHQRxqEPonDAELIAdBDGogB0EcahC0LAs6AAAgBUECaiEFIAdBHGoiBBD9GEEDRw0ACyAFAn8gCARAIAdBFGogBBD6JwwBCyAHQRRqIAdBHGoQtCwLOgAAIAVBAWoLIABrIQQLIAdBMGokACAEIgshCCAEQYh/Sw0BC0EAIQQgAUEAQTT8CwAgCyEIIAAhBQNAIAgEQCAFLQAAIgZBDEsNAyABIAZBAnRqIgYgBigCAEEBajYCACAIQQFrIQhBASAFLQAAdEEBdSAEaiEEIAVBAWohBQwBCwtBbCEIIARFDQAgBGciBUEcc0ELSw0AIANBICAFayIDNgIAQYCAgIB4QQEgA3QgBGsiBGciA3YgBEcNACAAIAtqQSAgA2siADoAACABIABBAnRqIgAgACgCAEEBajYCACABKAIEIgBBAkkgAEEBcXINACACIAtBAWo2AgAgDUEBaiEICyAIDwtBbAu0AwEHfyACIARvIgdBAEoEQCABQQFrIQgDQCAHQQBMRQRAIAAgAiAIai0AACADQQBBABD7MCAHQQFrIQcgAkEBayECDAELCyAAIAUQrSULIAIgBEEBdCIKbwRAIARBAWshByABIAJqQQFrIQgDQCAHBEAgACAILQAAIANBAEEBEPswIAhBAWshCCAHQQFrIQcMAQsLIAAgASACIARrIgJqLQAAIANBACAGEPswIAAgBRCtJQtBACAEayEJIAEgAmohCEEAIARBAXRrIQsDQCACQQBMRQRAQX8hBwNAIAQgB2oEQCAAIAcgCGotAAAgA0EAQQEQ+zAgB0EBayEHDAELCyAAIAEgAiAEayIMai0AACADQQAgBhD7MCAAIAUQrSUgAEEANgIMIABBADYCBCAIIAlqIQ1BfyEHA0AgByAJRkUEQCAAIAcgDWotAAAgA0EBQQEQ+zAgB0EBayEHDAELCyAAIAEgDCAEa2otAAAgA0EBIAYQ+zAgACAAKAIMIgcgACgCCGo2AgggACAAKAIEIAAoAgAgB3ZyNgIAIAAgBRCtJSAIIAtqIQggAiAKayECDAELCwvXAwIHfwF+IwBBQGoiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCRHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJEdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0EMbCACakEMayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgAiAIQQxsaiIJQQhqIgooAgAhCyABKQIAIQ4gASAJKQIANwIAIAFBCGoiDCgCACENIAwgCzYCACAKIA02AgAgCSAONwIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQxrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0FAayQAC9cDAgd/AX4jAEFAaiIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADENUKDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ1QogBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQxsIAJqQQxrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASACIAhBDGxqIglBCGoiCigCACELIAEpAgAhDiABIAkpAgA3AgAgAUEIaiIMKAIAIQ0gDCALNgIAIAogDTYCACAJIA43AgAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBDGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQUBrJAALsAMCBH4JfyMAQRBrIgkkACAJIAE6AA8gAEEQaiIGIAlBD2oQwxAhAiAAKAIIRQRAIAkgAEEBIAYQlgQLIAAoAgAiB0EBayELIAAoAgQiCiACp3EhBiACQhmIIgRC/wCDQoGChIiQoMCAAX4hBSABQf8BcSEMA0ACfwJAAkAgBiAHaikAACIDIAWFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAwgCyACeqdBA3YgBmogCnFrLQAARg0CIAJCAX0gAoMiAlBFDQALCyADQoCBgoSIkKDAgH+DIQIgDUUEQCACUA0CIAJ6p0EDdiAGaiAKcSEIC0EBIAIgA0IBhoNQDQIaIAcgCGosAAAiBkEATgRAIAcgBykDAEKAgYKEiJCgwIB/g3qnQQN2IghqLQAAIQYLIAcgCGogBKdB/wBxIgs6AAAgByAIQQhrIApxakEIaiALOgAAIAAgACgCCCAGQQFxazYCCCAAIAAoAgxBAWo2AgwgCEF/cyAHaiABOgAACyAJQRBqJAAPC0EACyENIAYgDkEIaiIOaiAKcSEGDAALAAucAwIDfwJ+IwBB4ABrIgYkAAJAIAEgAoRQIAMgBIRQcg0AQgAgA30gAyAEQgBTIgcbIQlCACABfSABIAJCAFMiCBshCkIAIAQgA0IAUq18fSAEIAcbIQMgAiAEhSEEQgACfkIAIAIgAUIAUq18fSACIAgbIgFQRQRAIANQRQRAIAZB0ABqIAkgAyAKIAEQqB5BASEHIAYpA1ghASAGKQNQDAILIAZBQGsgCSADIApCABCoHiAGQTBqIAkgAyABQgAQqB4gBikDOEIAUiAGKQNIIgIgBikDMHwiASACVHIhByAGKQNADAELIANQRQRAIAZBIGogCUIAIAogARCoHiAGQRBqIANCACAKIAEQqB4gBikDGEIAUiAGKQMoIgIgBikDEHwiASACVHIhByAGKQMgDAELIAYgCSADIAogARCoHkEAIQcgBikDCCEBIAYpAwALIgJ9IAIgBEIAUyIIGyEKQgAgASACQgBSrXx9IAEgCBsiCSAEhUIAWQ0AQQEhBwsgACAKNwMAIAUgBzYCACAAIAk3AwggBkHgAGokAAuKBAIHfwJ+IwBBMGsiAyQAAkACQCABAn8CQAJAAkACQAJAAkACQAJAIAEtADhBAWsOAwUBAAILIAFBHGohBgJAAkAgAS0AHEEBaw4DCwIAAQsgASgCGCEFDAQLIAEoAhQhByABKQMAIQoMAgsACyADQRBqIAFBLGoQ3SAgAUEAOgAcIAEgASkDICIKNwMAIAEgAykDEDcDCCABQRBqIANBGGooAgA2AgAgASABKAIoIgc2AhQgAUEcaiEGCyADQShqIgggAUEQaigCADYCACADIAEpAwg3AyAgA0EIahDPIiADKAIMIQUgAygCCCEJQcgHQQgQrTYiBEUNBSAEIAk2ArQHIAQgBzYCsAcgBCAKNwMAIAQgAykDIDcDuAcgBEEAOgDEByAEQcAHaiAIKAIANgIAIARBoIbDABDUGiABIAU2AhgLIANBIGoiBCAFQQhqIAIQ3hQgAygCICICQYGAgIB4Rg0BIAMpAiQhCiABQRhqELAsIAJBgICAgHhHDQJBoIjDAEErIARBkIjDAEHIl8MAENUeAAtB0JjDABDoKwALIAZBAzoAACAAQYGAgIB4NgIIQQMMAQsgAUEBOgAcIAEQ+ywgASkDICELIAFBLGoQ3jsgACAKNwIMIAAgAjYCCCAAIAs3AwBBAQs6ADggA0EwaiQADwtBCEHIBxCjPQALQbiXwwAQ6CsAC+YDAQd/IwBBIGsiBCQAIABB2ABqIgZBACADEIwmIAYQ8BUCQAJAAkACQAJAAkACQAJAIAEgAk0EQCACIAAoAhgiA0sNASAAKAJcIgMgACgCYCIJIAAoAmQiB2oiBWsiCEEBTQ0CIAMgBUkNAyAAKAIUIQogBigCACIGIAVqIAIgAWsiAjsAACAIQX5xQQJGDQQgAyAFQQJqIgVJDQUgAyAFayIIQQFNDQYgACAHQQRqIgc2AmQgBSAGaiACQX9zOwAAIAJB//8DcQRAIAMgByAJaiIFayACSQ0IIAMgBUkNCSACBEAgBSAGaiABIApqIAL8CgAACyAAIAIgB2o2AmQLIARBIGokAA8LIAEgAkHs9PsAELE7AAsgAiADQez0+wAQsDsACyAEQQA2AhggBEEBNgIMIARBrML7ADYCCCAEQgQ3AhAgBEEIakH89PsAEO8sAAsgBSADQfz0+wAQrzsACyAEQQA2AhggBEEBNgIMIARBrML7ADYCCCAEQgQ3AhAgBEEIakGM9fsAEO8sAAsgBSADQYz1+wAQrzsAC0ECIAhBjPX7ABCwOwALIARBADYCGCAEQQE2AgwgBEGswvsANgIIIARCBDcCECAEQQhqQZz1+wAQ7ywACyAFIANBnPX7ABCvOwAL+QMCBX8EfiMAQbABayICJAAgACgCACIEKAIAIQUgAkEwaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAIwQQFxRQ0AIAIpA0ghByACKQNAIQggBSgCACIDKQMAIQkgAiADKQMIIgo3A2ggAiAJNwNgIAIgBzcDWCACIAg3A1AgAkEANgIsIAJBEGogCCAHIAkgCiACQSxqEPYMIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCAGQQRyEIgRDAELIAIpAxAiByACKQMYIgggBCgCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgCDcDCCAAIAc3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALhAQBCH8jAEHwAmsiAiQAIAEoAhwhBCABKAIYIQUgAkGwAmoiBkGFipQoNgIAIAJChYqUqNCgwYIFNwKoAiACQgQ3AqACIAJCADcCmAIgAkKAgICAwAA3ApACIAJBADYCiAIgAkEAOwHgAiACQQA2AtwCIAJBADYCxAIgAkEANgK4AiACIAEoAhRBA3Y2ArQCAkBBDEEEEK02IgMEQCADIAEpAgw3AgAgA0EIaiABQRRqKAIANgIAIAJBATYC7AIgAiADNgLoAiACQQE2AuQCIAJBDGoiAyACQYgCaiIHIAJB5AJqIggQlikgAkHoAGoiCSADEM0cIAYgAUEIaigCADYCACACQQA2AuACIAIgBDYC3AIgAkEANgLEAiACQQA2ArgCIAIgBTYCtAIgAkIENwKgAiACQgA3ApgCIAJCgICAgMAANwKQAiACQQA2AogCIAIgASkCADcCqAJBiAFBBBCtNiIDRQ0BIANBxABqIAEoAiAiBCABKAIkIgUoAghBAWtBeHFqQQhqIAUoAhQRAAAgAyAJQcQA/AoAACACQQI2AuwCIAIgAzYC6AIgAkECNgLkAiACQawBaiIDIAcgCBD8IiAAIAMQzRwgBCAEKAIAIgBBAWs2AgAgAEEBRgRAIAFBIGoQuyMLIAJB8AJqJAAPC0EEQQwQoz0AC0EEQYgBEKM9AAuEBAEIfyMAQfACayICJAAgASgCHCEEIAEoAhghBSACQbACaiIGQYOGjBg2AgAgAkKDhoyYsODAgQM3AqgCIAJCBDcCoAIgAkIANwKYAiACQoCAgIDAADcCkAIgAkEANgKIAiACQQA7AeACIAJBADYC3AIgAkEANgLEAiACQQA2ArgCIAIgASgCFEEBdjYCtAICQEEMQQQQrTYiAwRAIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLsAiACIAM2AugCIAJBATYC5AIgAkEMaiIDIAJBiAJqIgcgAkHkAmoiCBCWKSACQegAaiIJIAMQzRwgBiABQQhqKAIANgIAIAJBADYC4AIgAiAENgLcAiACQQA2AsQCIAJBADYCuAIgAiAFNgK0AiACQgQ3AqACIAJCADcCmAIgAkKAgICAwAA3ApACIAJBADYCiAIgAiABKQIANwKoAkGIAUEEEK02IgNFDQEgA0HEAGogASgCICIEIAEoAiQiBSgCCEEBa0F4cWpBCGogBSgCFBEAACADIAlBxAD8CgAAIAJBAjYC7AIgAiADNgLoAiACQQI2AuQCIAJBrAFqIgMgByAIEPwiIAAgAxDNHCAEIAQoAgAiAEEBazYCACAAQQFGBEAgAUEgahC7IwsgAkHwAmokAA8LQQRBDBCjPQALQQRBiAEQoz0AC4QEAQh/IwBB8AJrIgIkACABKAIcIQQgASgCGCEFIAJBsAJqIgZBhIiQIDYCACACQoSIkKDAgIGCBDcCqAIgAkIENwKgAiACQgA3ApgCIAJCgICAgMAANwKQAiACQQA2AogCIAJBADsB4AIgAkEANgLcAiACQQA2AsQCIAJBADYCuAIgAiABKAIUQQJ2NgK0AgJAQQxBBBCtNiIDBEAgAyABKQIMNwIAIANBCGogAUEUaigCADYCACACQQE2AuwCIAIgAzYC6AIgAkEBNgLkAiACQQxqIgMgAkGIAmoiByACQeQCaiIIEJYpIAJB6ABqIgkgAxDNHCAGIAFBCGooAgA2AgAgAkEANgLgAiACIAQ2AtwCIAJBADYCxAIgAkEANgK4AiACIAU2ArQCIAJCBDcCoAIgAkIANwKYAiACQoCAgIDAADcCkAIgAkEANgKIAiACIAEpAgA3AqgCQYgBQQQQrTYiA0UNASADQcQAaiABKAIgIgQgASgCJCIFKAIIQQFrQXhxakEIaiAFKAIUEQAAIAMgCUHEAPwKAAAgAkECNgLsAiACIAM2AugCIAJBAjYC5AIgAkGsAWoiAyAHIAgQ/CIgACADEM0cIAQgBCgCACIAQQFrNgIAIABBAUYEQCABQSBqELsjCyACQfACaiQADwtBBEEMEKM9AAtBBEGIARCjPQALxAMBAn8CfyABQYABTwRAQQBBzQVBACABQdI9TxsiAiACQeYCaiICIAJBA3RBsJSKAWooAgAgAUsbIgIgAkGzAWoiAiACQQN0QbCUigFqKAIAIAFLGyICIAJB2gBqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQS1qIgIgAkEDdEGwlIoBaigCACABSxsiAiACQRZqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQtqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQZqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQNqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQFqIgIgAkEDdEGwlIoBaigCACABSxsiAiACQQFqIgIgAkEDdEGwlIoBaigCACABSxsiAkEDdEGwlIoBaigCACIDIAFHDQEaIAIgASADS2oiAUGZC00EQEHpACABQQN0QbSUigFqKAIAIgEgAUGAsANzQYCAxABrQYCQvH9JIgIbIQFBhwZBACACGwwCC0GaC0GaC0GglIoBEMMhAAsgAUHBAGtBGklBBXQgAXIhAUEACyECIABBADYCCCAAIAI2AgQgACABNgIAC8sDAgR/AX4jAEHgAGsiBCQAAkAgASgCCEGAgICAeEYEQCAEQQRqIgdBgAhBAEEBQQEQoBggBCgCCCEFIAQoAgRBAUYNASAEQdwAaiIGQQA2AgAgBCAEKAIMNgJYIAQgBTYCVCAEQdQAakHIhs4AQQQQoTYgBEHQAGoiBSAGKAIANgIAIAQgBCkCVDcDSCAEQQdqQQBBwAD8CwAgARCBLyABQgA3AwAgAUEAOgAUIAFBCGoiBiAEKQNINwMAIAZBCGogBSgCADYCACABQRVqIAdBwwD8CgAAIAFBAToAdCABQQA2AnAgAUIANwNoIAFCfzcDYCABQgA3A1gLAkAgAwRAIAFBGGohBgNAIAEoAmwhBQJAAkAgAjEAACIIIAEpA1hSBEAgBUEHSwRAIAEQvQ0LIAEgCDcDWCABQQE2AmwMAQsgASAFQQFqIgU2AmwgBUEISw0BCyABKAJoIgVBB0sNAyAGIAVBA3RqIAg3AwAgASABKAJoQQFqIgU2AmggBUEIRw0AIAEQyicLIAJBAWohAiADQQFrIgMNAAsLIABBCDYCACAEQeAAaiQADwsgBUEIQeiizgAQwyEACyAFIAQoAgxB6JzOABD9LwALwAMCBn8BfiMAQdAAayICJAAgAkEANgIUIAJCgICAgBA3AgwgAkE4aiABEI0NIAJBMGoiAyACQcQAaikCADcDACACIAIpAjw3AygCQAJAIAIoAjgiBEEIRwRAIAIoAkwhASAAIAIpAyg3AgQgACABNgIUIAAgBDYCACAAQQxqIAMpAwA3AgAgAkEMahDeOwwBCyACQSBqIAMpAwAiCDcDACACIAIpAyg3AxggAkEMaiACKAIcIgUgCKciBhChNgJAIAEoAmgiBEUNACABKAJkIgMgBEEEdGohBANAIAMoAgBFDQMgAkEMaiADQQRqKAIAIANBCGooAgAQoTYgA0EQaiIDIARHDQALIAEoAmghBCABQQA2AmggBEUNACABKAJkIQMDQCADKAIAIgcEQCADQQxqIANBBGooAgAgA0EIaigCACAHKAIQEQEACyADQRBqIQMgBEEBayIEDQALCyABQQA2AmwgAkFAayACQRRqKAIANgIAIAIgAikCDDcDOCAAQQRqIAJBOGoQ5xUgAEEINgIAIAJBJGogBSAGIAIoAhgoAhARAQALIAJB0ABqJAAPC0Hkh84AQSBBhIjOABDLJAALhAMAIAAgAjYCACAAIAQgA2tBGXQgA3I2AgQgBSABKAIEIAE1AgAgAEEOaiAAQQhqEJYYIAAvAQ4CfwJAAkAgAkEGTwRAIAJBggFJDQEgAkHCEEkNAkEVIAJBwjBJDQMaQRZBFyACQcKwAUkbDAMLIAIMAgsgAkECayICZ0EgakE/c0EBayIDQQF0IAIgA3ZqQQJqDAELIAJBwgBrZ0EgakE/c0EKagshA0H/B3EhBQJ/AkAgBEEKTwRAIARBhgFJDQFBFyAEQcYQTw0CGiAEQcYAa2dBIGpBP3NBDGoMAgsgBEECawwBCyAEQQZrIgFnQSBqQT9zQQFrIgJBAXQgASACdmpBBGoLIgJBB3EgA0EDdEE4cXIhASAAAn8gBSADQf//A3FBB0tyRSACQf//A3FBEElxRQRAIAEgA0H4/wNxQQN2QQNsIAJB+P8DcUEDdmoiAUEGdEHAmsgCIAFBAXR2QcABcWpyQUBrDAELIAEgAUHAAHIgAkH//wNxQQhJGws7AQwLkgQCCH8BfiMAQeAAayICJAAgAiAAKQMYIgo3A0ggAiAAKQMQNwNAIAIgACkDCDcDOCACIAApAwA3AzACQCAKQgBZBEAgAkEIaiACQTBqQSAQgg8gAkEoaiACQRBqKAIAIgA2AgAgAiACKQIINwMgIAJBAkEBIAAbOgAsDAELIAJB1ABqIQMgAkEwaiEEIwBBEGsiACQAIABBBGpBIEEAQQFBARCgGCAAKAIIIQUCQCAAKAIEQQFHBEAgACgCDCIGIARBIPwKAAAgA0EgNgIIIAMgBjYCBCADIAU2AgAgAEEQaiQADAELIAUgACgCDEGwoogBEP0vAAsCQAJAIAIoAlwiBARAIApCAFlBAXQhBiACKAJYIQdBACEAQQEhAwNAIAAgB2oiCCAILQAAIglBf3M6AAAgA0EAIQMEQCAIQQAgCWs6AAAgCUUhAwsgBCAAQQFqIgBHDQALIAJBCGogByAEEIIPIAIoAhANAgwBCyACQRBqQfjyhwEoAgA2AgAgAkHw8ocBKQIANwMIC0EBIQYLIAJBKGogAkEQaigCADYCACACIAIpAwg3AyAgAiAGOgAsIAJB1ABqEN47CyACQaEdNgJYIAJBATYCDCACQcjzhwE2AgggAkIBNwIUIAIgAkEgaiIANgJUIAIgAkHUAGo2AhAgASgCACABKAIEIAJBCGoQywogABDpOyACQeAAaiQAC8sDAQZ/IwBB4ABrIgQkACABQRBqIQUgBEEcaiEHAn8gASgCEARAIAEoAhQhAiABKAIcIQZBAAwBC0EBCyEDA0ACQAJAAkACQCADRQRAIAIgBkcEQCABIAJByABqNgIUIAIoAgAiA0GAgICAeEcNAgsgBRDnICAFQQA2AgBBASEDDAULIAEoAgBFDQEgASgCBCICIAEoAgxGDQEgASACQcgAajYCBCACKAIAIgNBhICAgHhGDQEgByACQQRqQcQA/AoAACAEIAM2AhggBEEMaiAEQRhqEMoLIAQoAgwiAkGAgICAeEYNASABIAI2AhggASAEKAIQIgI2AhQgASACNgIQIAEgAiAEKAIUQcgAbGoiBjYCHAwCCyAAQQRqIAJBBGpBxAD8CgAAIAAgAzYCAAwCCyABKAIgBEACQCABKAIkIgMgASgCLEcEQCABIANByABqNgIkIAMoAgAhAiAEQRhqIANBBGpBxAD8CgAAIAJBgICAgHhHDQELIAFBIGoiARDnICABQQA2AgBBgICAgHghAgsgACACNgIAIABBBGogBEEYakHEAPwKAAAMAgsgAEGAgICAeDYCAAwBC0EAIQMMAQsLIARB4ABqJAALixECEH8BfiMAQTBrIhAkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQgAoMBQsgACABQQN2IghB1ABsaiEHIAAgCEEwbGohCiAQQRBqAn8gAUHAAE8EQCAAIAogByAIIAYQoRoMAQsgACAHIAogACgCACIIIAooAgAiCkkiCyAKIAcoAgAiB0lzGyALIAcgCEtzGwsiB0EIaigCADYCACAQIAcpAgA3AwggByAAa0EMbiEKAkACQCAFBEAgBSgCACAHKAIATw0BCwJ/QQAhCSABIANLIAoiByABT3JFBEAgAiABQQxsaiELIAAgB0EMbGohDCAAIQgDQCAAIAdBA2siDkEAIAcgDk8bQQxsaiIOIAhLBEADQCAJQQxsIAIgC0EMayAIKAIAIAwoAgBJIg0baiIPIAgpAgA3AgAgD0EIaiAIQQhqKAIANgIAIAkgDWoiCUEMbCACIAtBGGsgCEEMaiINKAIAIAwoAgBJIg8baiIRIA0pAgA3AgAgEUEIaiAIQRRqKAIANgIAIAkgD2oiCUEMbCACIAtBJGsgCEEYaiINKAIAIAwoAgBJIg8baiIRIA0pAgA3AgAgEUEIaiAIQSBqKAIANgIAIAkgD2oiCUEMbCACIAtBMGsiCyAIQSRqIg0oAgAgDCgCAEkiDxtqIhEgDSkCADcCACARQQhqIAhBLGooAgA2AgAgCSAPaiEJIAhBMGoiCCAOSQ0ACwsgACAHQQxsaiIOIAhLBEADQCAJQQxsIAIgC0EMayILIAgoAgAgDCgCAEkiDRtqIg8gCCkCADcCACAPQQhqIAhBCGooAgA2AgAgCSANaiEJIAhBDGoiCCAOSQ0ACwsgASAHRwRAIAtBDGsiCyAJQQxsaiIHIAgpAgA3AgAgB0EIaiAIQQhqKAIANgIAIAhBDGohCCABIQcMAQsLIAlBDGwiBwRAIAAgAiAH/AoAAAsgASAJRwRAIAEgCWshByAAIAlBDGxqIQggAUEMbCACakEMayELA0AgCCALKQIANwIAIAhBCGogC0EIaigCADYCACALQQxrIQsgCEEMaiEIIAdBAWsiBw0ACwsgCQwBCwALIgdFDQAgASAHTw0BIBBBADYCKCAQQQE2AhwgEEHs8/4ANgIYIBBCBDcCICAQQRhqQfTz/gAQ7ywACyABAn9BACEIIAEgA0sgCiIFIAFPckUEQCACIAFBDGxqIQogACAFQQxsaiELIAAhBwNAIAAgBUEDayIJQQAgBSAJTxtBDGxqIgkgB0sEQANAIAhBDGwgAiAKQQxrIAsoAgAgBygCAE8iDBtqIg4gBykCADcCACAOQQhqIAdBCGooAgA2AgAgCCAMaiIIQQxsIAIgCkEYayALKAIAIAdBDGoiDCgCAE8iDhtqIg0gDCkCADcCACANQQhqIAdBFGooAgA2AgAgCCAOaiIIQQxsIAIgCkEkayALKAIAIAdBGGoiDCgCAE8iDhtqIg0gDCkCADcCACANQQhqIAdBIGooAgA2AgAgCCAOaiIIQQxsIAIgCkEwayIKIAsoAgAgB0EkaiIMKAIATyIOG2oiDSAMKQIANwIAIA1BCGogB0EsaigCADYCACAIIA5qIQggB0EwaiIHIAlJDQALCyAAIAVBDGxqIgkgB0sEQANAIAhBDGwgAiAKQQxrIgogCygCACAHKAIATyIMG2oiDiAHKQIANwIAIA5BCGogB0EIaigCADYCACAIIAxqIQggB0EMaiIHIAlJDQALCyABIAVHBEAgCEEMbCACIApBDGsiCkEBG2oiBSAHKQIANwIAIAVBCGogB0EIaigCADYCACAHQQxqIQcgCEEBaiEIIAEhBQwBCwsgCEEMbCIFBEAgACACIAX8CgAACyABIAhHBEAgASAIayEFIAAgCEEMbGohByABQQxsIAJqQQxrIQoDQCAHIAopAgA3AgAgB0EIaiAKQQhqKAIANgIAIApBDGshCiAHQQxqIQcgBUEBayIFDQALCyAIDAELAAsiB0kNAyAAIAdBDGxqIQBBACEFIAEgB2siAUEhTw0CDAQLIAAgB0EMbGogASAHayACIAMgBCAQQQhqIAYQgw0gBEEBayEEIAciAUEhTw0ACwsMAQsgByABQYT0/gAQrzsACyAAIQUgAiEEIwBBEGsiCSQAIAEiBkECTwRAAn8CQCABQRBqIANNBEAgAUEBdiEMIAFBD0sNASACIAxBDGwiB2ohAyAAIAdqIQcgAUEHSwRAIAAgAhDxEiAHIAMQ8RJBBAwDCyAEIAUpAgA3AgAgBEEIaiAFQQhqKAIANgIAIAMgBykCADcCACADQQhqIAdBCGooAgA2AgBBAQwCCwALIAUgBCAEIAZBDGxqIgAQsC0gBSAMQQxsIgFqIAEgBGogAEHgAGoQsC1BCAshAyAJQgI3AgQgA0EMbCEOIANBAWohCCAJIAw2AgwgBiAMayESIAlBCGohE0EAIQADQCAAIBIgDCATIABBAnRqKAIAIgAbIhQgA0sEQCAFIABBDGwiAGohFUEMIQcgACAEaiIPIQogCCEAIAMhAQNAIAAhAiAPIAFBDGwiAWoiACABIBVqIgEpAgAiFzcCACAAQQhqIAFBCGooAgA2AgAgF6ciESAAQQxrKAIASQRAIAApAgQhFyAHIQAgCiEBAn8DQCABIA5qIg0gDUEMayIWKQIANwIAIA1BCGogFkEIaigCADYCACAPIAAgDkYNARogAEEMaiEAIAFBDGshASARIA1BGGsoAgBJDQALIAEgDmoLIgAgFzcCBCAAIBE2AgALIAdBDGshByAKQQxqIQogAiACIBRJIg1qIQAgAiEBIA0NAAsLQQEhAEEBcUUNAAsgCUECNgIAIAQgBiAFEIgQCyAJQRBqJAALIBBBMGokAAu4AwEHfyMAQSBrIgIkAAJAAkACQCAAKAIARQRAQcAAIQQgACgCGCIBIAAoAhQiBSABIAVLGyIBQQN2IAFBB3FBAEdqIgFBwP///wNxQUBrIAEgAUE/cRsiA0HAABDRNEUNASADBEAgA0HAABCtNiIERQ0DCyACQgA3AhQgAiAENgIQIAIgAzYCDCACQcAANgIIAkAgBUEDdiAFQQdxIgZBAEdqIgFFDQAgASADSwRAIAJBCGogA0EBdCIDIAFBwP///wNxQUBrIAEgAUE/cRsiBCADIARLGxDoGSACKAIUIQcgAigCECEECyABRQ0AIAQgB2pB/wEgAfwLAAsgAiABNgIUIAYEQCABRQ0EIAEgBGpBAWsiAUUNBCABIAEtAABBfyAGdEF/c3E6AAALIAIgBTYCGAJAIAAoAgAiAUUNACAAKAIEIgNFDQAgACgCCCADIAEQ+DoLIAAgAikCCDcCACAAQRBqIAJBGGooAgA2AgAgAEEIaiACQRBqKQIANwIACyACQSBqJAAPC0HY/ocBQSkgAkEfakHM/IcBQYT/hwEQ1R4AC0HAACADEKM9AAtBlP+HARCyOwALmg4BDn8jAEEgayIQJAACQAJAIAFBIUkNAAJAA0AgBEEBayEEA0AgBEF/RgRAIAAgASACIANBASAGEPoJDAULIAAgAUEDdiIHQRxsaiEIIAAgB0EEdGohCyAQAn8gAUHAAE8EQCAAIAsgCCAHIAYQuRkMAQsgACAAKAIAQRh2IgcgCygCAEEYdiIKSSIJIAcgCCgCAEEYdiIMSXMNABogCCALIAkgCiAMSXMbCyIIKAIAIgc2AgQgCCAAa0ECdiELAkACQCAFBEAgBS0AAyAHQRh2Tw0BCwJ/QQAhCSABIANLIAsiCCABT3JFBEAgAiABQQJ0aiEKIAAgCEECdGohDCAAIQcDQCAAIAhBA2siDUEAIAggDU8bQQJ0aiINIAdLBEADQCAJQQJ0IAIgCkEEayAMLQADIAcoAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEIayAMLQADIAdBBGooAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEMayAMLQADIAdBCGooAgAiDkEYdksiDxtqIA42AgAgCSAPaiIJQQJ0IAIgCkEQayIKIAwtAAMgB0EMaigCACIOQRh2SyIPG2ogDjYCACAJIA9qIQkgB0EQaiIHIA1JDQALCyAAIAhBAnRqIg0gB0sEQANAIAlBAnQgAiAKQQRrIgogDC0AAyAHKAIAIg5BGHZLIg8baiAONgIAIAkgD2ohCSAHQQRqIgcgDUkNAAsLIAEgCEcEQCAKQQRrIgogCUECdGogBygCADYCACAHQQRqIQcgASEIDAELCyAJQQJ0IggEQCAAIAIgCPwKAAALIAEgCUcEQCABIAlrIQggACAJQQJ0aiEHIAFBAnQgAmpBBGshCgNAIAcgCigCADYCACAKQQRrIQogB0EEaiEHIAhBAWsiCA0ACwsgCQwBCwALIghFDQAgASAITw0BIBBBADYCGCAQQQE2AgwgEEGorMwANgIIIBBCBDcCECAQQQhqQbCszAAQ7ywACyABAn9BACEHIAEgA0sgCyIFIAFPckUEQCACIAFBAnRqIQsgACAFQQJ0aiEKIAAhCANAIAAgBUEDayIJQQAgBSAJTxtBAnRqIgkgCEsEQANAIAdBAnQgAiALQQRrIAotAAMgCCgCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQQhrIAotAAMgCEEEaigCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQQxrIAotAAMgCEEIaigCACIMQRh2TyING2ogDDYCACAHIA1qIgdBAnQgAiALQRBrIgsgCi0AAyAIQQxqKAIAIgxBGHZPIg0baiAMNgIAIAcgDWohByAIQRBqIgggCUkNAAsLIAAgBUECdGoiCSAISwRAA0AgB0ECdCACIAtBBGsiCyAKLQADIAgoAgAiDEEYdk8iDRtqIAw2AgAgByANaiEHIAhBBGoiCCAJSQ0ACwsgASAFRwRAIAdBAnQgAiALQQRrIgtBARtqIAgoAgA2AgAgCEEEaiEIIAdBAWohByABIQUMAQsLIAdBAnQiBQRAIAAgAiAF/AoAAAsgASAHRwRAIAEgB2shBSAAIAdBAnRqIQggAUECdCACakEEayELA0AgCCALKAIANgIAIAtBBGshCyAIQQRqIQggBUEBayIFDQALCyAHDAELAAsiCEkNAyAAIAhBAnRqIQBBACEFIAEgCGsiAUEhTw0CDAQLIAAgCEECdGogASAIayACIAMgBCAQQQRqIAYQhQ0gBEEBayEEIAgiAUEhTw0ACwsMAQsgCCABQcCszAAQrzsACyAAIQQjAEEQayIKJAAgASIFQQJPBEACfwJAIAFBEGogA00EQCABQQF2IQcgAUEPSw0BIAFBB0sEQCAAIAIQwRUgACAHQQJ0IgFqIAEgAmoQwRVBBAwDCyACIAQoAgA2AgAgAiAHQQJ0IgBqIAAgBGooAgA2AgBBAQwCCwALIAQgAiACIAVBAnRqIgAQqS0gBCAHQQJ0IgFqIAEgAmogAEEgahCpLUEICyEDIApCAjcCBCADQQJ0IQggCiAHNgIMIAUgB2shDiAKQQhqIQ9BACEAA0AgACAOIAcgDyAAQQJ0aigCACIAGyIRIANLBEAgAiAAQQJ0IgBqIQkgACAEaiESIAghASADIQYDQCAJIAZBAnQiAGoiDSAAIBJqKAIAIgw2AgAgDEEYdiITIA1BBGsoAgAiDUEYdkkEQCABIQACfwNAIAAgCWoiFCANNgIAIAkgAEEERg0BGiAAQQRrIQAgEyAUQQhrKAIAIg1BGHZJDQALIAAgCWoLIAw2AgALIAFBBGohASAGQQFqIgYgEUcNAAsLQQEhAEEBcUUNAAsgCkECNgIAIAIgBSAEEPcQCyAKQRBqJAALIBBBIGokAAv4BAIJfwF+IwBBIGsiCiQAIAMoAgAhDiACKAIEIQggCiAAIAIoAgAiDGoiCSACKAIIIgtrIg82AhgCQAJAAkAgDCAOaiIQIARLDQAgACAIIAxqIg1qIAFBIGtLDQAgDUEgaiABIABrTQ0BCyAKQRBqIAJBCGooAgA2AgAgCiACKQIANwMIQbp/IQICQCAKQQhqIgsoAgQiCSALKAIAIgxqIg8gASAAa0sNAEFsIQIgDCAEIAMoAgAiDWtLDQAgACAMaiIIIAsoAggiC2shBCAAIAFBIGsiDiANIAxBABCxFCADIAwgDWo2AgACQAJAIAggBWsgC08EQCAEIQUMAQsgCyAIIAZrSw0CIAcgByAEIAVrIgBqIgEgCWpPBEAgCUUNAiAIIAEgCfwKAAAMAgtBACAAayICBEAgCCABIAL8CgAACyAAIAlqIQkgCCAAayEICyAIIA4gBSAJQQEQsRQLIA8hAgsgAiENDAELIA4pAAAhESAAQQhqIA5BCGopAAA3AAAgACARNwAAIAxBEU8EQCAAQRBqIAMoAgBBEGogDEEQa0EAENEVCyADIBA2AgAgCiAJNgIcAkAgCSAFayALTwRAIA8hBQwBCyAJIAZrIAtJBEBBbCENDAILIAcgByAPIAVrIgBqIgEgCGpPBEAgCEUNAiAJIAEgCPwKAAAMAgtBACAAayICBEAgCSABIAL8CgAACyAKIAU2AhggCiAJIABrIgk2AhwgACAIaiEICyALQRBPBEAgCSAFIAhBABDRFQwBCyAKQRxqIApBGGogCxDFGSAIQQlJDQAgCigCHCAKKAIYIAhBCGtBARDRFQsgCkEgaiQAIA0LoAQBBX8gACAAKAIIIgMgAmoiBDYCCCAAKAIEIgcgBEEIaiIEIAQgB0sbIQUgACgCACEGAkACQAJAAkACQAJAIAEgAk8EQCABIANLDQEgAyABayEAIAQgB08EQCMAQSBrIgQkACAEIAAgACACaiAFQeDy/AAQhyogBSAEKAIEIAQoAgAiAGsiAWsgA08EQCABBEAgAyAGaiAAIAZqIAH8CgAACyAEQSBqJAAMCAsgBEEANgIYIARBATYCDCAEQbCA/QA2AgggBEIENwIQIARBCGpB4PL8ABDvLAALIAMgBmoiBCAAIAZqIgApAAA3AAAgAkEJSQ0GIAAgAmohAEEAIAFrIQEgBEEIaiEDA0AgAyABIANqKQAANwAAIANBCGoiAyABaiAASQ0ACwwGCyABQQFHBEAgBSADayIAQQAgACAFTRshACAGIAFrIQdBACABayEEA0AgAyAEaiAFTw0FIABFDQYgAyAGaiADIAdqLQAAOgAAIANBAWohAyAAQQFrIQAgAkEBayICDQALDAYLIAUgA0EBayIBSwRAIAMgBUsNAiACIAUgA2siAEsNAyACRQ0GIAMgBmogASAGai0AACAC/AsADwsgASAFQfTx/AAQwyEAC0HE8vwAQQlB0PL8ABDLJAALIAMgBUGE8vwAEK87AAsgAiAAQZTy/AAQsDsACyADIAFrIAVBpPL8ABDDIQALIAMgBUG08vwAEMMhAAsLuAMBCX8gASgCBCIIIAEoAgAiBGshBQJAAkAgBCAIRg0AIAFBCGohCSAEIQIDQCABIAJBAWoiBzYCAAJAIAItAAAiA8BBAE4NACABIAJBAmoiBzYCACACLQABQT9xIQYgA0EfcSEKIANB3wFNBEAgCkEGdCAGciEDDAELIAEgAkEDaiIHNgIAIAItAAJBP3EgBkEGdHIhBiADQfABSQRAIAYgCkEMdHIhAwwBCyABIAJBBGoiBzYCACAKQRJ0QYCA8ABxIAItAANBP3EgBkEGdHJyIQMLAkACQAJAAkAgA0EITARAIANFDQEMAwsgA0ENRiADQQlrQQJJckUEQCADQYCAxABHDQMMBgsgByAIQX9zaiICIAVqIgFFBEBBACEFDAcLAkAgASAFTwRAIAINAQwDCyABIARqLAAAQb9/Sg0CCyAEIAVBACABQdSUxAAQozYACyAJKAIAIgJFDQIgAkEHIAEoAgwoAhQRAAAMAgsgASEFDAQLIAkoAgBFDQAgCUHsk8QAIAMgARCQDAsgASgCACICIAEoAgQiCEcNAAsLIARBACAFGyEECyAAIAU2AgQgACAENgIAC+4DAQJ/IwBBEGsiAyQAIAMgACgCDCIAQQhqIAAoAghBAkZBAnRqIgAQiRkCQAJAAkACfwJAIAMtAABBBEcEQCAALQAhQQZHDQEgASgCAEUNBSACKAIARQ0FIAEoAgQgASgCCCACKAIEIAIoAggQlBIMAgsgASgCAEUNBCACKAIARQ0EIAEoAgQgASgCCCACKAIEIAIoAggQlBIMAQsgAyAAEIkZIAMtAABBDUcEQCACKAIAIQACfwJAIAEoAgAEQCAADQFBAQwCC0F/QQAgABsMAQsgASACEMYpCyIAQf8BcUECRyAAwEEASnEMAQsgASgCAEUNAyACKAIARQ0DIAEoAghBAkcNASACKAIIIAIoAgQhAiADIAEoAgQvAAA7AQxBAkcNAiADIAIvAAA7AQ4CfyADQQ5qIQFBACECAkACQCADQQxqLwEAIgBB//8BcUGA+AFLDQAgAS8BACIBQf//AXEiBEGA+AFLDQAgAMFBAEgNASAAIAFLIAHBQQBODQIaIAAgBHJBAEchAgsgAgwBCyABwUEASCAAIAFJcQsLIANBEGokAA8LQcTvzgBBKyADQQ5qQfDvzgBB8ITPABDVHgALQcTvzgBBKyADQQ5qQfDvzgBBgIXPABDVHgALQeSHzgBBIEGEiM4AEMskAAurAwERfyMAQRBrIgMkACAAKALsBSELIAAoAvAFIQwgACgC6AUgACgC5AUhBCAAKALQBSEGIAAoAtQFIQogA0EIaiAAKALQECIBQfAjaigCADYCACADIAEpAugjNwMAIARrQQN1IQggBiAKQQR0aiINIQUDQCAHIAhGRQRAIAVBDGoiDkEANgIAIAVBBGoiDyAEQQRqLwEAIgI2AgAgBUEIaiIQIARBBmovAQAiEUEDajYCACAEKAIAIQEgAiEGAkAgByAAKAKMBkcNAAJAAkAgACgCiAZBAWsOAgABAgsgDyACQYCABHIiBjYCAAwBCyAQIBFBg4AEajYCAAsgBQJ/IAFBA2sgAUEDSw0AGiAOIAE2AgAgBgRAIAFBAnQgA2pBBGsoAgAMAQsgAUEDRgRAIAMoAgBBAWsMAQsgAyABQQJ0aigCAAs2AgAgAyABIAJFEOUcIAVBEGohBSAEQQhqIQQgB0EBaiEHIAYgCWohCQwBCwsgDSAIQQR0aiICIAwgCSALams2AgQgAkIANwIIIAJBADYCACAAIAggCmpBAWo2AtQFIANBEGokAAvgAwIFfwJ+IwBBkAFrIgIkACAAKAIAIgQoAgAhBSACQfAAaiIGIAAoAgQoAhAgAUEFdGoiAykDACADKQMIIAMpAxAgAykDGBDWIwJAAkACQCACKAJwQQFxRQ0AIAIpA4gBIAIpA4ABIgdCgICAgICAgICAf30gB1StfEIAUg0AIAIgBSgCACkDACIINwNAIAIgBzcDOCACQRBqIAcgB0I/hyAIIAhCP4cQqB4gAikDGCACKQMQIgdCP4dSBEAgAkECNgJ0IAJBrJD/ADYCcCACQgI3AnwgAkGGDDYCbCACQYYMNgJkIAIgAkHgAGo2AnggAiACQUBrNgJoIAIgAkE4ajYCYCACQdAAaiAGEJkOIAJBLGogAkHUAGopAgA3AgAgAkE0aiACQdwAaigCADYCACACQYiAgIB4NgJMIAIgAikCTDcCJCACQQE2AiAgAkEgakEEchCIEQwBCyAHIAQoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAHNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC7UDAQR/IwBBMGsiAiQAIAJBCGogARCSBwJAAkACQCACKAIIIgNBCEcEQCAAIAIpAgw3AgQgAEEUaiACQRxqKAIANgIAIABBDGogAkEUaikCADcCACAAIAM2AgAMAQsgARDAKyACQoCAgIAQNwIkIAJBADYCLCABLQAUIQMgAiABKQMANwMIIANBA3YgA0EHcUEAR2oiA0EJTw0BIAFBCGogAkEIaiIEIAMQoTYgAUEAOgAUIAFCADcDACACQSRqIgUgASgCDCABKAIQEKE2IAEtACwhAyACIAEpAxg3AwggA0EDdiADQQdxQQBHaiIDQQlPDQIgAUEgaiAEIAMQoTYgAUEAOgAsIAFCADcDGCAFIAEoAiQgASgCKBChNiABQQA2AiggAUEAOgAUIAFCADcDACABQQA2AhAgAUEANgJcIAFBADYCTCABQQA6ACwgAUIANwMYIAFCADcDMCABQThqQgA3AwAgAkEQaiACQSxqKAIANgIAIAIgAikCJDcDCCAAQQRqIAQQ5xUgAEEINgIACyACQTBqJAAPCyADQQhB6I7OABCwOwALIANBCEHojs4AELA7AAu1AwEEfyMAQTBrIgIkACACQQhqIAEQiwcCQAJAAkAgAigCCCIDQQhHBEAgACACKQIMNwIEIABBFGogAkEcaigCADYCACAAQQxqIAJBFGopAgA3AgAgACADNgIADAELIAEQwCsgAkKAgICAEDcCJCACQQA2AiwgAS0AFCEDIAIgASkDADcDCCADQQN2IANBB3FBAEdqIgNBCU8NASABQQhqIAJBCGoiBCADEKE2IAFBADoAFCABQgA3AwAgAkEkaiIFIAEoAgwgASgCEBChNiABLQAsIQMgAiABKQMYNwMIIANBA3YgA0EHcUEAR2oiA0EJTw0CIAFBIGogBCADEKE2IAFBADoALCABQgA3AxggBSABKAIkIAEoAigQoTYgAUEANgIoIAFBADoAFCABQgA3AwAgAUEANgIQIAFBADYCXCABQQA2AkwgAUEAOgAsIAFCADcDGCABQgA3AzAgAUE4akIANwMAIAJBEGogAkEsaigCADYCACACIAIpAiQ3AwggAEEEaiAEEOcVIABBCDYCAAsgAkEwaiQADwsgA0EIQeiOzgAQsDsACyADQQhB6I7OABCwOwALpQMBBH8jAEFAaiIEJAAgBEEeakIANwEAIARBGGpCADcDACAEQRBqQgA3AwAgBEIANwMIA0AgBCAGakEKaiADIAZqLwEAIAVqQQF0IgU7AQAgBkECaiIGQRxHDQALIAQgAy8BHCAFakEBdCIGOwEmAkACQCADLwEeIAZqQf//A3FBgIACRgRAQQAhBgNAIAEgBk0NAiAAIAZBAnRqIgcvAQIiAwRAIANBEE8NBCAEQQhqIANBAXRqIgUgBS8BACIFQQFqOwEAIAcgBUEIdCAFQQh2ciIFQQR2QY8ecSAFQY8ecUEEdHIiBUECdkGz5gBxIAVBs+YAcUECdHIiBUEBdkHVqgFxIAVB1aoBcUEBdHJBACADa0EPcXY7AQALIAIgBksiAwRAIAMgBmoiBiACTQ0BCwsgBEFAayQADwsgBEEANgI4IARBATYCLCAEQfT3+wA2AiggBEIENwIwIARBKGpB/Pf7ABDvLAALIAYgAUGc9/sAEMMhAAsgBEEANgI4IARBATYCLCAEQcT3+wA2AiggBEIENwIwIARBKGpBzPf7ABDvLAALrQMCBX8CfiMAQSBrIgUkAAJAAkACQAJAAkAgAkHBAEkEQCACQSFPDQEgASgCHCIGIAJqIgIgASgCGCIDQQN0aiABKAIIIgRBA3RLBEBBACEBDAYLAkAgBgRAIAEpAxAhCAwBCyADIARLDQMgAUEIIAQgA2siByAHQQhPGyABKAIEIANqIAcQ2SIiCDcDEAsgASACNgIcIAUgCEJ/Qn8gAq2GQn+FIAJBP0sbgyAGQT9xrYgiCDcDACACQcAASQ0EIAEgAkFAaiICNgIcIAEgA0EIaiIDNgIYIAJFDQQgAyAESw0DIAFBCCAEIANrIgQgBEEITxsgASgCBCADaiAEENkiIgk3AxAgBSAJQn9CfyACrYZCf4UgAkE/SxuDQQAgBmtBP3GthiAIhDcDAAwEC0GYts4AQSBBuLbOABCfKQALQci2zgBBMEH4ts4AEJ8pAAsgAyAEQcS7zgAQrzsACyADIARBxLvOABCvOwALIAVBCGogBUEIEKQYIAUoAghBCEYiAQRAIAUoAgwhAgwBCyAFQQhqEMkjCyAAIAI2AgQgACABNgIAIAVBIGokAAvJAwIFfwJ+IwBBIGsiBSQAAkACQAJAAkACQCACQcEASQRAIAJBCU8NASABKAIcIgYgAmoiAiABKAIYIgRBA3RqIAEoAggiA0EDdEsEQEEAIQEMBgsCQCAGBEAgASkDECEIDAELIAMgBEkNAyABQQggAyAEayIHIAdBCE8bIAEoAgQgBGogBxDZIiIINwMQCyABIAI2AhwgBSAIQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIINwMAIAJBwABJDQQgASACQUBqIgI2AhwgASAEQQhqIgQ2AhggAkUNBCADIARJDQMgAUEIIAMgBGsiAyADQQhPGyABKAIEIARqIAMQ2SIiCTcDECAFIAlCf0J/IAKthkJ/hSACQT9LG4NBACAGa0E/ca2GIAiENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAEIANBxLvOABCvOwALIAQgA0HEu84AEK87AAsjAEHQAGsiASQAIAVBCGoiAyAFLQAAOgAEIANBCDYCACABQdAAaiQAIAUoAghBCEYiAQRAIAUtAAwhAgwBCyAFQQhqEMkjCyAAIAI6AAEgACABOgAAIAVBIGokAAvJAwIFfwJ+IwBBIGsiBSQAAkACQAJAAkACQCACQcEASQRAIAJBEU8NASABKAIcIgYgAmoiAiABKAIYIgRBA3RqIAEoAggiA0EDdEsEQEEAIQEMBgsCQCAGBEAgASkDECEIDAELIAMgBEkNAyABQQggAyAEayIHIAdBCE8bIAEoAgQgBGogBxDZIiIINwMQCyABIAI2AhwgBSAIQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIINwMAIAJBwABJDQQgASACQUBqIgI2AhwgASAEQQhqIgQ2AhggAkUNBCADIARJDQMgAUEIIAMgBGsiAyADQQhPGyABKAIEIARqIAMQ2SIiCTcDECAFIAlCf0J/IAKthkJ/hSACQT9LG4NBACAGa0E/ca2GIAiENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAEIANBxLvOABCvOwALIAQgA0HEu84AEK87AAsjAEHQAGsiASQAIAVBCGoiAyAFLwAAOwEEIANBCDYCACABQdAAaiQAIAUoAghBCEYiAQRAIAUvAQwhAgwBCyAFQQhqEMkjCyAAIAI7AQIgACABOwEAIAVBIGokAAuQAwEEfyAAKAIEIgVBGHZBgAFxIAVBGXZywCAFQf///w9xaiEGAn8CQAJAIAAoAgAiBUEGTwRAIAVBggFJDQEgBUHCEEkNAkEVIAVBwjBJDQMaQRZBFyAFQcKwAUkbDAMLIAUMAgsgBUECayIAZ0EgakE/c0EBayIEQQF0IAAgBHZqQQJqDAELIAVBwgBrZ0EgakE/c0EKagshAAJAAkACfwJAIAZBCk8EQCAGQYYBSQ0BIAZBxgBrZ0EgakE/c0EMaiAGQcYQSQ0CGkEXIQQgAEH//wNxIgBBGE8NBAwDCyAGQQJrDAELIAZBBmsiBCAEZ0EgakE/c0EBayIEdiAEQQF0akEEagsgAEH//wNxIgBBGE8NAUH//wNxIgRBGEkNACAEQRhBvOzRABDDIQALIABBAnQiAEGIn+IAaigCACIHIARBAnQiBEHIoOIAaigCAGogBSAAQaie4gBqKAIAa60gBiAEQeif4gBqKAIAa60gB0E/ca2GhCABIAIgAxDlEg8LIABBGEGs7NEAEMMhAAu3AwMCfwF+A30CfQJAIAJFBEAMAQsgAkEBayABSQRAIAIhByAAIQYDQCAIIAY1AgB8IQggBkEEaiEGIAdBAWsiBw0ACyAIQoACVA0BIAi1EOoSDAILIAEgAUHwoNYAEMMhAAsgCKdBAnRBwIfzAGoqAgALIQoCQCACRSADckUEQCABIAJBAWtNDQEgAiEHIAAhBgNAIAggBigCAEWtfCEIIAZBBGohBiAHQQFrIgcNAAsLAn0gCEKAAloEQCAItRDqEgwBCyAIp0ECdEHAh/MAaioCAAshCSACBEAgCUMAAABAkiELQQAhBgNAAkACQAJAIAEgBkcEQCAAKAIAIgNFBEAgBSAGTQ0CIAQgCzgCAAwECwJ9IANBgAJPBEAgA7MQ6hIMAQsgA0ECdEHAh/MAaioCAAshCSAFIAZNDQIgBCAKIAmTIgk4AgAgCUMAAIA/XUUNAyAEQYCAgPwDNgIADAMLIAEgAUHAoNYAEMMhAAsgBiAFQdCg1gAQwyEACyAGIAVB4KDWABDDIQALIABBBGohACAEQQRqIQQgAiAGQQFqIgZHDQALCw8LIAEgAUGwoNYAEMMhAAu9AwEFfyMAQUBqIgAkAAJAAkBB3O6KAS0AAEECRgRAQeDuigEoAgAhAUHg7ooBQQA2AgAgAUUNASAAQShqIAERAwAgAEEgaiICIABBOGooAgA2AgAgAEEYaiIDIABBMGopAgA3AwAgAEEOaiIEIABBP2otAAA6AAAgACAAKQIoNwMQIAAgAC8APTsBDCAALQA8IQECQEHc7ooBLQAAQQJGBEBByO6KASAAKQMQNwIAQdzuigEgAToAAEHd7ooBIAAvAQw7AABB2O6KASACKAIANgIAQdDuigEgAykDADcCAEHf7ooBIAQtAAA6AAAMAQsgAUECRw0DCyAAQQI6ADwgAEEoahD1JQsgAEFAayQADwsgAEEANgI4IABBATYCLCAAQYiqiAE2AiggAEIENwIwIABBKGpBkKqIARDvLAALIABBP2ogAEEOai0AADoAACAAQTBqIABBGGopAwA3AwAgAEE4aiAAQSBqKAIANgIAIAAgAC8BDDsAPSAAIAApAxA3AyggACABOgA8IABBKGoiARD1JSAAQQA2AjggAEEBNgIsIABBsKqIATYCKCAAQgQ3AjAgAUG4qogBEO8sAAv7AgELfwJAIAQEQAJAIAMoAgBBAUcNACADKAIEIg1Bf0cNACAGKAIAIQ4MAgsgB0EEaiESIAYoAgAhDiAKKAIAIRBBACEHA0ACQAJAIAQgDSAPaiILSwRAQQAhDSADIAtBFGxqIgsoAgBBAUYEQCALKAIEIQ0LIAcgCUYNASAIIBIgCygCECIMQf///z9xIhNBACAOIAcbaiIUIAsoAggiFUH///8PcSIRIBEgFUEZdmtBCWogCygCDCILQQ9qIAxBG3ZBAWsgDEGAgIDAAEkbIgwQgA0gDEUgCyACIA8gE2oiDyABaiIMIAIgDEkbS3INAiAFIAUoAgg2AgwgBSAFKQIANwIEIAUgCzYCAAwCCyALIARBkJ/WABDDIQALIAkgCUGgn9YAEMMhAAsgDkEAIAcbIQ4gCiAQIBRqIhA2AgAgCEEQaiEIIAdBAWohByAPIBFqIQ8gDUF/Rw0ACwwBC0EAQQBBgJ/WABDDIQALIAYgACAOaiAPazYCAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+QkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCcGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEGkn8QANgIIIAhCBDcCECAIQQhqQayfxAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCWDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFBvJ/EABCvOwALIAAgASACIAMQyQoLIAhBIGokAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+AkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCcGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEGkn8QANgIIIAhCBDcCECAIQQhqQayfxAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCXDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFBvJ/EABCvOwALIAAgASACIAMQyQoLIAhBIGokAAuZAwEFfyMAQSBrIggkAAJAAkAgAUEhSQ0AAkADQCAEQQFrIQQDQCAEQX9GBEAgACABIAIgA0EBIAYQ+wkMBQsgACABQQN2IgpBOGxqIQcgACAKQQV0aiEJIAgCfyABQcAATwRAIAAgCSAHIAogBhCdGgwBCyAAIAcgCSAAKAIAIgogCSgCACIJSSILIAkgBygCACIHSXMbIAsgByAKS3MbCyIHKAIENgIEIAggBygCACIKNgIAIAcgAGtBA3YhCQJAAkAgBQRAIAUoAgAgCk8NAQsgACABIAIgAyAJENcKIgdFDQAgASAHTw0BIAhBADYCGCAIQQE2AgwgCEHg0swANgIIIAhCBDcCECAIQQhqQejSzAAQ7ywACyABIAAgASACIAMgCRDYCiIHSQ0DIAAgB0EDdGohAEEAIQUgASAHayIBQSFPDQIMBAsgACAHQQN0aiABIAdrIAIgAyAEIAggBhCYDSAEQQFrIQQgByIBQSFPDQALCwwBCyAHIAFB+NLMABCvOwALIAAgASACIAMQyQoLIAhBIGokAAu5AwICfwF+IwBBgAFrIgUkAAJAAkACQCABKAIIBEAgBUEANgI4IAVCADcDMCAFQgA3AwAgBSABKAIELQAAOgA8IAVBQGsgAUEBEOoUIAVB2ABqQgA3AwAgBUHQAGpCADcDACAFQSBqQgA3AwAgBUEoakIANwMAIAVBGGogBUHIAGopAwA3AwAgBSAFKQNAIgc3AxAgB6dFDQEgBUHgAGogBUEQaiIGEKUYAkAgBSgCYEEBRw0AIAUpA2giB1ANACAHQgGDUEUEQCAFIAenQQJ0QXhxNgI4DAELIAUgB0IBiD4CNCAFQfAAaiAGIAUtADwiBkEDdiAGQQdxQQBHahDBHCAFIAUpA3g3AwggBSAFKQNwIgc3AwAgB6dFDQMLQYAgQQQQrTYiBkUNAyAGQQBBgCD8CwAgACAFQcAA/AoAACAAIAQgAiADQQFxGzYCTCAAQgA3AkQgACAGNgJAIAFBDGogASgCBCABKAIIIAEoAgAoAhARAQAgBUGAAWokAA8LQQBBAEG8iM4AEMMhAAtB+KLOAEEYQZCjzgAQyyQAC0Ggo84AQS5B0KPOABCfKQALQQRBgCAQoz0AC7wDAQF/IwBBMGsiBiQAAkACQAJAAkAgAAJ/AkAgAkEBcUUgAyAFT3INAAJAIAEQ3yRFBEAgAyAFSw0EIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEMaiAGKAIcIAYoAiAgAxCSFCAGKAIMIQILIAJBgICAgHhGDQAgACAGKQIQNwIEIAAgAjYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVBqIHPABCwOwALIAMgBUG4gc8AELA7AAsgASAGKAIsQcD1zgAQ/S8ACyACIAYoAixBwPXOABD9LwALvAMBAX8jAEEwayIGJAACQAJAAkACQCAAAn8CQCACQQFxRSADIAVPcg0AAkAgARDgJEUEQCADIAVLDQQgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEYaiAEIAUQnQkgBigCGEEBRgRAIAMgBUsNBSAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQQxqIAYoAhwgBigCICADEJIUIAYoAgwhAgsgAkGAgICAeEYNACAAIAYpAhA3AgQgACACNgIAQQEMAQsgBkEkaiAFQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQMgBigCLCECIAUEQCACIAQgBfwKAAALIAAgBTYCCCAAIAI2AgQgACABNgIAQQALOgAMIAZBMGokAA8LIAMgBUGogc8AELA7AAsgAyAFQbiBzwAQsDsACyABIAYoAixBwPXOABD9LwALIAIgBigCLEHA9c4AEP0vAAu8AwEBfyMAQTBrIgYkAAJAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEN0kRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQRhqIAQgBRCdCSAGKAIYQQFGBEAgAyAFSw0FIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBDGogBigCHCAGKAIgIAMQkhQgBigCDCECCyACQYCAgIB4Rg0AIAAgBikCEDcCBCAAIAI2AgBBAQwBCyAGQSRqIAVBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNAyAGKAIsIQIgBQRAIAIgBCAF/AoAAAsgACAFNgIIIAAgAjYCBCAAIAE2AgBBAAs6AAwgBkEwaiQADwsgAyAFQaiBzwAQsDsACyADIAVBuIHPABCwOwALIAEgBigCLEHA9c4AEP0vAAsgAiAGKAIsQcD1zgAQ/S8AC7wDAQF/IwBBMGsiBiQAAkACQAJAAkAgAAJ/AkAgAkEBcUUgAyAFT3INAAJAIAEQ3iRFBEAgAyAFSw0EIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBGGogBCAFEJ0JIAYoAhhBAUYEQCADIAVLDQUgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEMaiAGKAIcIAYoAiAgAxCSFCAGKAIMIQILIAJBgICAgHhGDQAgACAGKQIQNwIEIAAgAjYCAEEBDAELIAZBJGogBUEAQQFBARCgGCAGKAIoIQEgBigCJEEBRg0DIAYoAiwhAiAFBEAgAiAEIAX8CgAACyAAIAU2AgggACACNgIEIAAgATYCAEEACzoADCAGQTBqJAAPCyADIAVBqIHPABCwOwALIAMgBUG4gc8AELA7AAsgASAGKAIsQcD1zgAQ/S8ACyACIAYoAixBwPXOABD9LwALvAMBAX8jAEEwayIGJAACQAJAAkACQCAAAn8CQCACQQFxRSADIAVPcg0AAkAgARDcJEUEQCADIAVLDQQgBkEkaiADQQBBAUEBEKAYIAYoAighAiAGKAIkQQFGDQcgBigCLCEBIAMEQCABIAQgA/wKAAALIAYgAzYCFCAGIAE2AhAMAQsgBkEYaiAEIAUQnQkgBigCGEEBRgRAIAMgBUsNBSAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQQxqIAYoAhwgBigCICADEJIUIAYoAgwhAgsgAkGAgICAeEYNACAAIAYpAhA3AgQgACACNgIAQQEMAQsgBkEkaiAFQQBBAUEBEKAYIAYoAighASAGKAIkQQFGDQMgBigCLCECIAUEQCACIAQgBfwKAAALIAAgBTYCCCAAIAI2AgQgACABNgIAQQALOgAMIAZBMGokAA8LIAMgBUGogc8AELA7AAsgAyAFQbiBzwAQsDsACyABIAYoAixBwPXOABD9LwALIAIgBigCLEHA9c4AEP0vAAu8AwEBfyMAQTBrIgYkAAJAAkACQAJAIAACfwJAIAJBAXFFIAMgBU9yDQACQCABEOEkRQRAIAMgBUsNBCAGQSRqIANBAEEBQQEQoBggBigCKCECIAYoAiRBAUYNByAGKAIsIQEgAwRAIAEgBCAD/AoAAAsgBiADNgIUIAYgATYCEAwBCyAGQRhqIAQgBRCdCSAGKAIYQQFGBEAgAyAFSw0FIAZBJGogA0EAQQFBARCgGCAGKAIoIQIgBigCJEEBRg0HIAYoAiwhASADBEAgASAEIAP8CgAACyAGIAM2AhQgBiABNgIQDAELIAZBDGogBigCHCAGKAIgIAMQkhQgBigCDCECCyACQYCAgIB4Rg0AIAAgBikCEDcCBCAAIAI2AgBBAQwBCyAGQSRqIAVBAEEBQQEQoBggBigCKCEBIAYoAiRBAUYNAyAGKAIsIQIgBQRAIAIgBCAF/AoAAAsgACAFNgIIIAAgAjYCBCAAIAE2AgBBAAs6AAwgBkEwaiQADwsgAyAFQaiBzwAQsDsACyADIAVBuIHPABCwOwALIAEgBigCLEHA9c4AEP0vAAsgAiAGKAIsQcD1zgAQ/S8AC5oDAQh/IAMoAlwgCUECdGohCiADKAIAIgsgCCADKAIEIgxqayEIQQAhCQNAIAlBDEZFBEAgCUEEaiEJDAELC0EDIAIgAkEDTxshCSAEQQRqIQ0gByAIakEDaiEOIAMoAmQiDyAKQQxqKAIAIhBBCHYiEUECdGohCAJAAkADQCAJBEAgCigCACIDRQ0CAkAgAyAMaiIHKAAAIAQoAABHDQAgDSAHQQRqIAUgCyAGEM0oQQRqIgcgAU0NACAAIA4gA2s2AgAgByEBIAQgB2ogBUYNBAsgCkEEaiEKIAlBAWshCSACQQFrIQIMAQsLIAIgEEH/AXEiAyACIANJIgcbIQkDQCAJBEAgCEEEaiEIIAlBAWshCQwBBSACIAMgBxshCSAPIBFBAnRqIQoDQCAJRQ0DAkAgDCAKKAIAIgJqIgMoAAAgBCgAAEcNACANIANBBGogBSALIAYQzShBBGoiByABTQ0AIAAgDiACazYCACAHIQEgBCAHaiAFRg0FCyAJQQFrIQkgCkEEaiEKDAALAAsACwALIAEhBwsgBwvyAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJBAnRqKAIAEJQvIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC/IDAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAkEDdGopAwAQsy4gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAAL8gMCA38IfiMAQcABayIDJAAgASgCCCEFIANBQGsgASgCDCgCECACQQJ0aigCABDJLSADKQNAIQkgAykDSCEKIAMpA1AhCyADKQNYIQwgBSgCACIEKQMAIQYgBCkDCCEHIAQpAxAhCCADIAQpAxgiDTcDOCADIAg3AzAgAyAHNwMoIAMgBjcDICADIAw3AxggAyALNwMQIAMgCjcDCCADIAk3AwACQAJAAkAgBiAIhCAHIA2EhFAEQEGHgICAeCEEDAELIANBQGsiBCAJIAogCyAMIAYgByAIIA0QmgggAy0AQEEBRgRAIANBAjYCRCADQZiQ/wA2AkAgA0ICNwJMIANBgww2ArwBIANBgww2ArQBIAMgA0GwAWo2AkggAyADQSBqNgK4ASADIAM2ArABIANBoAFqIAQQmQ4gAykCoAEhByADKQKoASEGQYiAgIB4IQQMAQsgA0FAayADKQNQIgYgAykDWCIHIAMpA2AiCCADKQNoIgkgBSgCBC0AABDQDiADKAJAIgRBk4CAgHhGDQEgAykCTCEGIAMpAkQhBwsgACAGNwIMIAAgBzcCBCAAIAQ2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvyAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJBAXRqLwEAELUuIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC/IDAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAkEBdGovAQAQky0gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAAL8gMCA38IfiMAQcABayIDJAAgASgCCCEFIANBQGsgASgCDCgCECACQQN0aikDABDOLyADKQNAIQkgAykDSCEKIAMpA1AhCyADKQNYIQwgBSgCACIEKQMAIQYgBCkDCCEHIAQpAxAhCCADIAQpAxgiDTcDOCADIAg3AzAgAyAHNwMoIAMgBjcDICADIAw3AxggAyALNwMQIAMgCjcDCCADIAk3AwACQAJAAkAgBiAIhCAHIA2EhFAEQEGHgICAeCEEDAELIANBQGsiBCAJIAogCyAMIAYgByAIIA0QmgggAy0AQEEBRgRAIANBAjYCRCADQZiQ/wA2AkAgA0ICNwJMIANBgww2ArwBIANBgww2ArQBIAMgA0GwAWo2AkggAyADQSBqNgK4ASADIAM2ArABIANBoAFqIAQQmQ4gAykCoAEhByADKQKoASEGQYiAgIB4IQQMAQsgA0FAayADKQNQIgYgAykDWCIHIAMpA2AiCCADKQNoIgkgBSgCBC0AABDQDiADKAJAIgRBk4CAgHhGDQEgAykCTCEGIAMpAkQhBwsgACAGNwIMIAAgBzcCBCAAIAQ2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEI8cIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQZSvgAEoAgA2AgAgAkGMr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvSAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEI8cIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQZSvgAEoAgA2AgAgAkGMr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvmAQEEfyMAQTBrIgMkACADQQI6ABcgA0EYaiIEIAJBA3YgAkEHcUEAR2oiAkHAACABrcN5p2siAUH/AXEiBUEDdiABQQdxQQBHakEBamwiBiAFQQFqIAJsIgIgAiAGSRtBAEEBQQEQoBggAygCHCECIAMoAhhBAUcEQCADQQA2AhAgAyADKAIgNgIMIAMgAjYCCCADQQhqQai3zgBBBBChNiADQSBqIANBEGooAgA2AgAgAyADKQIINwMYIABBCGogASAEEJwfIABBADoAACADQTBqJAAPCyACIAMoAiBB5MPOABD9LwAL0wMCAn8BfSMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfQJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQwAAAAAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAkE4aiABIAQQwQEgAigCOEExRw0BIAIqAjwLIQZBAQwBCyACQdgAakGLlqzYADYCACACQouWrNiw4cKFCzcDUCACQQM2AjwgAkHEroABNgI4IAJCAjcCRCACQa4QNgJsIAJBzAE2AmQgAiACQeAAajYCQCACIAJB0ABqIgE2AmggAiACQRxqNgJgIAJBKGogAkE4ahCZDiABEKoMIAJBGGoiASACQTRqKAIANgIAIAIgAikCLDcDECACKgIoIQYgAygCAEGTgICAeEcEQCADEIgRCyADIAY4AgQgA0GCgICAeDYCACADIAIpAxA3AgggA0EQaiABKAIANgIAQQALIQEgACAGOAIEIAAgATYCACACQfAAaiQADwtB9KeAAUEgQZSogAEQnykAC88DAQJ/IwBB8ABrIgIkAAJAAkAgASgCHCIEIAEoAiBGBEBBAiEBDAELAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQjxwgAigCAEEBcUUNASACKAIECyEEQQEhAQwBC0EAIQEgAkHYAGpBlK+AASgCADYCACACQYyvgAEpAgA3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIENgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gBBCqDCACQRhqIgQgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEFIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAFNgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogBCgCADYCAAsgACAENgIEIAAgATYCACACQfAAaiQADwtB9KeAAUEgQZSogAEQnykAC9MDAgJ/AX0jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn0CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEMAAAAADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAJBOGogASAEEMEBIAIoAjhBMUcNASACKgI8CyEGQQEMAQsgAkHYAGpBi5as2AA2AgAgAkKLlqzYsOHChQs3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAioCKCEGIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAGOAIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBjgCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvPAwECfyMAQfAAayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQIhAQwBCwJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEJAcIAIoAgBBAXFFDQEgAigCBAshBEEBIQEMAQtBACEBIAJB2ABqQaCvgAEoAgA2AgAgAkGYr4ABKQIANwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiBDYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAQQqgwgAkEYaiIEIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBSADKAIAQZOAgIB4RwRAIAMQiBELIAMgBTYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAQoAgA2AgALIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAuFBAIHfwJ+IwBBwAFrIgQkAEIDIQsgAS0ACSEGIAEtAAghBQJAIAEpAwAiDEIDUQ0AIAQgBjoASSAEIAU6AEggBCAMNwNAIARBygBqIgggAUEKakE+/AoAACAEIAIoAgQgAigCCBDICgJAIAQoAgBBAUYEQEEEIQUMAQsgBEGQAWoiCSAEQQxqKQIANwMAIAQgBCkCBDcDiAEgAygCBCECIAMoAgghA0EAIQECQANAIAEgA0cEQCABIAJqLQAAIgVBH0sgBUH/AEdxIQogAUEBaiEBQQIhByAFQQlGIApyDQEMAgsLIAQgAiADEPweQQAhBwsgBCAHOgAQIAQtABAiAUECRgRAQQUhBSAEKAKIASIBRQ0BIARBlAFqIAQoAowBIAQoApABIAEoAhARAQAMAQsgBEG0AWogBEEIaiIGKQEANwEAIARBvwFqIARBE2otAAA6AAAgBCAEKQECNwGuASAEIAQvABE7AL0BIAQgAToAvAEgBCAELwEAOwGsASAGIAkpAwA3AwAgBCAEKQOIATcDAEEGIQUgBEFAayAEIARBrAFqEJIDQf8BcUECRg0AIAQtAEkhBiAELQBIIQUgBCkDQCELIAQgCEE+/AoAAAwBCyAEQUBrELwuCyAAIAY6AAkgACAFOgAIIAAgCzcDACAAQQpqIARBPvwKAAAgBEHAAWokAAuRAwIGfwF+IAYEQANAAkACQAJAAkAgBSAURwRAIAQgFEEEdGoiEi8BDCITQcAFTw0BIBNBwAVPDQIgEi8BDiEWIBI1AgghGCASKAIEIRcgEigCACEVIAkgE2otAAAgCiATQQF0ajMBACAPIBAgERDlEiASIA8gECAREJINIBVFDQQDQCACIANxIhIgAU8NBCAAIBJqLQAAIRIgByASai0AACAIIBJBAXRqMwEAIA8gECAREOUSIAJBAWohAiAVQQFrIhUNAAsMBAsgBSAFQfzs0QAQwyEACyATQcAFQYzt0QAQwyEACyATQcAFQZzt0QAQwyEACyASIAFBzO3RABDDIQALAkAgF0H///8PcSISRSATQf8ATXINACAWQf8HcSITIAxJBEAgDiATSwRAIAsgE2otAAAgDSATQQF0ajMBACAPIBAgERDlEiAWQYD4A3FBCnYgGCAPIBAgERDlEgwCCyATIA5BvO3RABDDIQALIBMgDEGs7dEAEMMhAAsgAiASaiECIBRBAWoiFCAGRw0ACwsLtAQBB38jAEHQAGsiBSQAIABBCCAAKAI0IgMgA0EITRs2AjQgAEEwaiEGIAJBA3QhAwJAQQAgACgCMCIHa0EHcSIEIAAoAgggB2tNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAGIAQQjTcgA0EEciIEIAAoAgggACgCMGsiB00gBCAHTXJFBEADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAYgAxCNNyAFQRBqIAAQ3DsgBUEIaiAFKAIQIAUoAhQgACgCMCIEIAQgA2tB1Mb+ABDXJiAFKAIMIQMgBSgCCCEEIAVBCDYCTCAFIAQ2AkQgBSADQQdxNgJAIAUgA0F4cSIDNgJIIAUgAyAEajYCPCAFQRhqIQMjAEEQayIEJAAgBCABIAJBA3RqIgg2AgwgBCABNgIIIARBCGoQmDYhByAFQTxqIgYoAhAiCUUEQEHk9P4AEOIrAAsgA0EANgIcIAMgCDYCBCADIAE2AgAgAyAGKQIANwIIIANBEGogBkEIaikCADcCACADQRhqIAZBEGooAgA2AgAgAyAGKAIMIAluIgEgByABIAdJGzYCICAEQRBqJAAgBSgCOCIBIAUoAjQiA0sEQCABIANrIQEgBSgCGCADQQN0aiEEIAUoAiggAyAFKAIwIgZsaiEDA0AgAyAEKQMANwAAIARBCGohBCADIAZqIQMgAUEBayIBDQALCyAAIAIQqhEgBUHQAGokAAvvAwIDfwh+IwBBwAFrIgMkACABKAIIIQUgA0FAayABKAIMKAIQIAJqLQAAELQuIAMpA0AhCSADKQNIIQogAykDUCELIAMpA1ghDCAFKAIAIgQpAwAhBiAEKQMIIQcgBCkDECEIIAMgBCkDGCINNwM4IAMgCDcDMCADIAc3AyggAyAGNwMgIAMgDDcDGCADIAs3AxAgAyAKNwMIIAMgCTcDAAJAAkACQCAGIAiEIAcgDYSEUARAQYeAgIB4IQQMAQsgA0FAayIEIAkgCiALIAwgBiAHIAggDRCaCCADLQBAQQFGBEAgA0ECNgJEIANBmJD/ADYCQCADQgI3AkwgA0GDDDYCvAEgA0GDDDYCtAEgAyADQbABajYCSCADIANBIGo2ArgBIAMgAzYCsAEgA0GgAWogBBCZDiADKQKgASEHIAMpAqgBIQZBiICAgHghBAwBCyADQUBrIAMpA1AiBiADKQNYIgcgAykDYCIIIAMpA2giCSAFKAIELQAAENAOIAMoAkAiBEGTgICAeEYNASADKQJMIQYgAykCRCEHCyAAIAY3AgwgACAHNwIEIAAgBDYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQcABaiQAC+8DAgN/CH4jAEHAAWsiAyQAIAEoAgghBSADQUBrIAEoAgwoAhAgAmotAAAQki0gAykDQCEJIAMpA0ghCiADKQNQIQsgAykDWCEMIAUoAgAiBCkDACEGIAQpAwghByAEKQMQIQggAyAEKQMYIg03AzggAyAINwMwIAMgBzcDKCADIAY3AyAgAyAMNwMYIAMgCzcDECADIAo3AwggAyAJNwMAAkACQAJAIAYgCIQgByANhIRQBEBBh4CAgHghBAwBCyADQUBrIgQgCSAKIAsgDCAGIAcgCCANEJoIIAMtAEBBAUYEQCADQQI2AkQgA0GYkP8ANgJAIANCAjcCTCADQYMMNgK8ASADQYMMNgK0ASADIANBsAFqNgJIIAMgA0EgajYCuAEgAyADNgKwASADQaABaiAEEJkOIAMpAqABIQcgAykCqAEhBkGIgICAeCEEDAELIANBQGsgAykDUCIGIAMpA1giByADKQNgIgggAykDaCIJIAUoAgQtAAAQ0A4gAygCQCIEQZOAgIB4Rg0BIAMpAkwhBiADKQJEIQcLIAAgBjcCDCAAIAc3AgQgACAENgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBwAFqJAALywMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBCPLCACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEENorIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvQAwICfwF9IwBB8ABrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ9AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxDAAAAAAwBCyABIARBAWo2AhwgAkEIaiABIAQQrSogAigCCCEBIAIgAigCDCIENgIgIAIgATYCHCACQThqIAEgBBDBASACKAI4QTFHDQEgAioCPAshBkEBDAELIAJB2ABqQYuWrNgANgIAIAJCi5as2LDhwoULNwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiATYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAEQqgwgAkEYaiIBIAJBNGooAgA2AgAgAiACKQIsNwMQIAIqAighBiADKAIAQZOAgIB4RwRAIAMQiBELIAMgBjgCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAEoAgA2AgBBAAshASAAIAY4AgQgACABNgIAIAJB8ABqJAAPC0H0p4ABQSBBlKiAARCfKQALzAMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEENgmIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQY6cuPAANgIAIAJCjpy48ODBg4cONwNQIAJBAzYCPCACQcSugAE2AjggAkICNwJEIAJBrhA2AmwgAkHMATYCZCACIAJB4ABqNgJAIAIgAkHQAGoiATYCaCACIAJBHGo2AmAgAkEoaiACQThqEJkOIAEQqgwgAkEYaiIBIAJBNGooAgA2AgAgAiACKQIsNwMQIAIoAighBCADKAIAQZOAgIB4RwRAIAMQiBELIAMgBDYCBCADQYKAgIB4NgIAIAMgAikDEDcCCCADQRBqIAEoAgA2AgBBAAshASAAIAQ2AgQgACABNgIAIAJB8ABqJAAPC0H0p4ABQSBBlKiAARCfKQALywMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEoAgAgBBDaKyACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvMAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASgCACAEEI8sIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ2CYgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBjpy48AA2AgAgAkKOnLjw4MGDhw43A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvXAwIFfwF+IwBBIGsiBiQAAkACQAJAAkACQAJAAn8gASgCCEGAgICAeEYEQCABKAIAIQUgASgCBAwBCyABKAIwIQUgASkDICIKpyIHIAEoAgAiCE8EQCAEIAdqIAEoAhAiCSAIak0NAgsgBiABKAIYIApC/////w+DIAQgBSAEIAVLGyABKAIcKAIUESUAIAYoAgQhByAGKAIAIQhBCEEEEK02IgVFDQMgBSAINgIAIAUgBzYCBCABELcuIAFBgICAgHg2AgggAUH4qogBNgIEIAEgBTYCAEH4qogBCyEHIAZBCGogBSACIAcoAgwRAQAgBigCECIFQYGAgIB4Rw0BIABBBToAAAwFCyAHIAhrIgIgBGoiBSACSQ0CIAUgCUsNAyAEBEAgAyABKAIMIAJqIAT8CgAACyAAIAQ2AgQgAEEEOgAAIAEgCiAErXw3AyAMBAsgBikDCCEKIAVBgICAgHhGBEAgACAKNwIADAQLIAEQty4gASAFNgIIIAEgCjcDACABIAYpAhQ3AgwgAUEUaiAGQRxqKAIANgIAIAAgASACIAMgBBC8DQwDC0EEQQgQoz0ACyACIAVBiKuIARCxOwALIAUgCUGIq4gBELA7AAsgBkEgaiQAC5gDAgV/AX4jAEEQayIDJAAgACgCbEEBdCIBrSEGAkAgAUGAAUkNACAAQQhqIQEDQAJAIAMgBqdBgAFyOgAAIAAtABQhAiADIAApAwA3AwggAkEDdiACQQdxQQBHaiICQQlPDQAgASADQQhqIAIQoTYgAEEAOgAUIABCADcDACABIANBARChNiAGQoCAAVQgBkIHiCEGRQ0BDAILCyACQQhBuPXMABCwOwALIAMgBjwAACAALQAUIQEgAyAAKQMANwMIIAFBA3YgAUEHcUEAR2oiAkEJTwRAIAJBCEG49cwAELA7AAsgAEEIaiIBIANBCGoiBSACEKE2IABBADoAFCAAQgA3AwAgASADQQEQoTYgAC0AdCECIAMgACkDWDcDACAALQAUIQQgAyAAKQMANwMIIARBA3YgBEEHcUEAR2oiBEEJSQRAIAEgBSAEEKE2IABBADoAFCAAQgA3AwAgASADQQggAkEDdiACQQdxQQBHaiIBIAFBCE8bEKE2IABCADcDaCADQRBqJAAPCyAEQQhBuPXMABCwOwALxQMBA38jAEEwayIHJAACQAJAIAMgBE8EQAJAIARFBEAgASgCAEUNASAAIAEgAiABKAIwIgIgAyACIANJG0EBEKELIgI2AgQgAEEINgIAIAEgASgCMCACazYCMAwECyAHIAMgBGsiBDYCACABKAIABEAgASACIAEoAjAiCCADIAMgCEsbQQEQoQshCCABIAEoAjAgCGs2AjAgByAINgIEIAQgCEcNAyADQQFrIQEDQAJAAkAgBiABQQN2IghLBEAgAUEHcUH8xM4Aai0AACAFIAhqLQAAcUUNAiAEQQFrIgQgA08NASABIAJqIggtAAAhCSAIIAIgBGoiCC0AADoAACAIIAk6AAAMAgsgCCAGQcSIzQAQwyEACyAEIANBpKDNABDDIQALIAFBAWsiAUF/Rw0ACyAAQQg2AgAgACADNgIEDAQLQYT+zAAQsjsAC0GE/swAELI7AAtB6J/NAEEsQZSgzQAQnykACyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgALIAdBMGokAAumAwEBfyMAQSBrIgEkAAJAAkACQAJAAkAgBUEBcQRAIAQgBCgCCCIFIAZqEI4tIAQoAggiByAFSQ0CIAQoAgQhBCABQQA2AhwgASAHIAVrNgIYIAEgBCAFajYCFCABQQhqIAIgAyABQRRqEIQEIAEoAghBBEYNAUEMQQQQrTYiAkUNAyACIAEpAgg3AgAgAEGM2tAANgIIIAAgAjYCBCAAQQU2AgAgAkEIaiABQRBqKAIANgIADAQLIAFBFGpBL0EAQQFBARCgGCABKAIYIQIgASgCFEEBRg0EIAEoAhwiA0H42NAAQS/8CgAAIABBLzYCDCAAIAM2AgggACACNgIEIABBADYCAAwDCyAGIAEoAgxGBEAgAEEINgIAIAAgBjYCBAwDCyABQRRqQTNBAEEBQQEQoBggASgCGCECIAEoAhRBAUYNAyABKAIcIgNByNnQAEEz/AoAACAAQTM2AgwgACADNgIIIAAgAjYCBCAAQQA2AgAMAgsgBSAHQbjZ0AAQrzsAC0EEQQwQoz0ACyABQSBqJAAPCyACIAEoAhxBpMbQABD9LwALtQMCBH8BfSMAQdAAayIDJAAgAyABKAIMKAIQIAJBAXRqLwEAIgQ7AQIgAAJ/An8gBEEQdCAEQf//AXFFDQAaIARB/wdxIQUgBEGAgAJxIQYgBEGA+AFxIgRBgPgBRgRAIAZBEHQhBCAEQYCAgPwHciAFRQ0BGiAEIAVBDXRyQYCAgP4HcgwBCyAGQRB0IQYgBEENdEGAgID8AHEgBUENdHJBgICAwANqIAZyIAQNABogBSAFZ0EQayIEQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIARBF3Rrcgu+IgdDAACAv14gB0MAAIBPXXFFBEAgA0E4akGIkKDAADYCACADQoiQoMCAgYKECDcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAgw3AgggAEEQaiADQRRqKAIANgIAIAAgAygCCDYCBEGCgICAeAwBCyABKAIAIAJBAnRqIAepNgIAQZOAgIB4CzYCACADQdAAaiQAC7UDAgR/AX0jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwABAMdeIAdDAAAAR11xRQRAIANBOGpBg4aMGDYCACADQoOGjJiw4MCBAzcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAQo3AQYgAEEMaiADQRBqKQEANwEAIAAgAy8BCDsBBEGCgICAeAwBCyABKAIAIAJBAXRqIAf8ADsBAEGTgICAeAs2AgAgA0HQAGokAAu0AwIEfwF9IwBB0ABrIgMkACADIAEoAgwoAhAgAkEBdGovAQAiBDsBAiAAAn8CfyAEQRB0IARB//8BcUUNABogBEH/B3EhBSAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCEEIARBgICA/AdyIAVFDQEaIAQgBUENdHJBgICA/gdyDAELIAZBEHQhBiAEQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogBnIgBA0AGiAFIAVnQRBrIgRB//8DcUEIanRB////A3EgBkGAgIDYA3IgBEEXdGtyC74iB0MAAADPYCAHQwAAAE9dcUUEQCADQThqQYSIkCA2AgAgA0KEiJCgwICBggQ3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgACADKQIMNwIIIABBEGogA0EUaigCADYCACAAIAMoAgg2AgRBgoCAgHgMAQsgASgCACACQQJ0aiAHqDYCAEGTgICAeAs2AgAgA0HQAGokAAu1AwIEfwF9IwBB0ABrIgMkACADIAEoAgwoAhAgAkEBdGovAQAiBDsBAiAAAn8CfyAEQRB0IARB//8BcUUNABogBEH/B3EhBSAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCEEIARBgICA/AdyIAVFDQEaIAQgBUENdHJBgICA/gdyDAELIAZBEHQhBiAEQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogBnIgBA0AGiAFIAVnQRBrIgRB//8DcUEIanRB////A3EgBkGAgIDYA3IgBEEXdGtyC74iB0MAAIC/XiAHQwAAgEddcUUEQCADQThqQYeOnDg2AgAgA0KHjpy48ODBgwc3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgACADKQEKNwEGIABBDGogA0EQaikBADcBACAAIAMvAQg7AQRBgoCAgHgMAQsgASgCACACQQF0aiAH/AE7AQBBk4CAgHgLNgIAIANB0ABqJAALyAMBAn8jAEHwAGsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQQhqIAEgBBCtKiACKAIIIQEgAiACKAIMIgQ2AiAgAiABNgIcIAIgASAEEO0cIAIoAgBBAXFFDQEgAigCBAshBEEBDAELIAJB2ABqQYSIkCA2AgAgAkKEiJCgwICBggQ3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvJAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ2CYgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBjpy48AA2AgAgAkKOnLjw4MGDhw43A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvJAwECfyMAQfAAayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBCGogASAEEK0qIAIoAgghASACIAIoAgwiBDYCICACIAE2AhwgAiABIAQQ6xwgAigCAEEBcUUNASACKAIECyEEQQEMAQsgAkHYAGpBiJCgwAA2AgAgAkKIkKDAgIGChAg3A1AgAkEDNgI8IAJBxK6AATYCOCACQgI3AkQgAkGuEDYCbCACQcwBNgJkIAIgAkHgAGo2AkAgAiACQdAAaiIBNgJoIAIgAkEcajYCYCACQShqIAJBOGoQmQ4gARCqDCACQRhqIgEgAkE0aigCADYCACACIAIpAiw3AxAgAigCKCEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAENgIEIANBgoCAgHg2AgAgAyACKQMQNwIIIANBEGogASgCADYCAEEACyEBIAAgBDYCBCAAIAE2AgAgAkHwAGokAA8LQfSngAFBIEGUqIABEJ8pAAvWAwEBfyMAQaAQayIEJAAgBCACNgIIIAQgATYCBAJAAkACQCAAAn8CQAJAAkACQAJAAkACQAJAIAFBAWsOBwECBwMEBQYACyAAQQA2AgRBCAwHCyAEQQxqIgIiAUEMakEAQYAQ/AsAIAFBADYCCCABQoCAgIAgNwIAQYwQQQQQrTYiAUUNByABIAJBjBD8CgAAIABBoOjQADYCCCAAIAE2AgRBCAwGC0EEQQQQrTYiAUUNCCAAQbTo0AA2AgggACABNgIEIAEgAjYCAEEIDAULQQRBBBCtNiIBRQ0HIABByOjQADYCCCAAIAE2AgQgASACNgIAQQgMBAsgAy0AACECQQFBARCtNiIBRQ0FIABB3OjQADYCCCAAIAE2AgQgASACOgAAQQgMAwtBBEEEEK02IgFFDQUgAEHw6NAANgIIIAAgATYCBCABIAI2AgBBCAwCCyAAQYTp0AA2AgggAEEBNgIEQQgMAQsgBEECNgIQIARBvOnQADYCDCAEQgE3AhggBEGQCjYCnBAgBCAEQZgQajYCFCAEIARBBGo2ApgQIABBBGogBEEMahCZDkEBCzYCACAEQaAQaiQADwtBBEGMEBCjPQALQQFBARCjPQALQQRBBBCjPQALlQMCBn8BfgJAIAIgAWsiA0EISARAIANBACADQQBKG0EBaiEGIAAgAUEDdGoiASEAQQEhAwNAIAMgBkYNAiABIANBA3RqIgIoAgQhByACKAIAIQIgACEFIAMhBANAAkAgBEEATARAQQAhBAwBCyAFKAIAIAJPDQAgBUEIaiAFKQIANwIAIARBAWshBCAFQQhrIQUMAQsLIAEgBEEDdGoiBCAHNgIEIAQgAjYCACAAQQhqIQAgA0EBaiEDDAALAAsDQCAAIAJBA3RqIQYDQCABIAJODQIgAUEBayEDIAAgAUEDdGohBSAGKAIAIQcgAiEEA0AgASAERwRAIAcgBSgCAEkEQCAAIANBAWoiA0EDdGoiCCkCACEJIAggBSkCADcCACAFIAk3AgALIARBAWshBCAFQQhqIQUMAQsLIAAgA0EBaiIEQQN0aiIFKQIAIQkgBSAGKQIANwIAIAYgCTcCACAEIAFrIAIgBGtIBEAgACABIAMQyA0gA0ECaiEBDAELCyAAIANBAmogAhDIDSADIQIMAAsACwvtAwIDfwR+IwBBwAFrIgMkACADQRBqIAEoAggiBSgCACABKAIMKAIQIAJBBXRqIgQpAwAiBiAEKQMIIgcgBCkDECIIIAQpAxgiCRDtCQJAAkACfiADKAIQQQFxRQRAIAUoAgQhASADIAk3A3ggAyAINwNwIAMgBzcDaCADIAY3A2AgA0HMkf8ANgKIASADQgQ3ApQBIANBgww2ArwBIANB9As2ArQBIANBuwc2AqwBIANBzAE2AqQBIANBjJL/ADYCoAEgAyABNgKoASADIAFBAWo2ArABIAMgA0GgAWo2ApABIAMgA0HgAGo2ArgBIANBBDYCjAEgA0HQAGogA0GIAWoQmQ4gA0EIaiADQdQAaigCADYCACADQYKAgIB4NgJMIAMgAykCTDcDACADKQJYDAELIANBEGogAykDICIGIAMpAygiByADKQMwIgggAykDOCIJIAUoAggtAAAQ0A4gAygCEEGTgICAeEYNASADQQhqIANBGGooAgA2AgAgAyADKQIQNwMAIAMpAhwLIQYgACADKQMANwIAIAAgBjcCDCAAQQhqIANBCGooAgA2AgAMAQsgAEGTgICAeDYCACABKAIAIAJBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAsgA0HAAWokAAvZAwIHfwF+IwBBoANrIgIkACABKAIQIQMgAkEUaiIFIAFBFGoQ9BIgAkEAOwG8AiACQQA2ArgCIAJBADYCoAIgAkEANgKUAiACIAM2ApACIAJBAToAhAIgAkIENwL8ASACQgA3AvQBIAJCgICAgMAANwLsASACQQA2AuQBAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhCSABQsAANwIAIAEoAhAhBiABKAIMIQQgAUIANwIMIAIgCTcClAEgAkEANgKQASACIAQ2AowBIAIgAzYCiAEgAkEIaiACQYgBaiIDENc7IAIoAgghB0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCiAE3AgggAUEQaiACQZABaiIIKQIANwIAIAFBGGogAkGYAWooAgA2AgAgAiAENgKcAyACIAc2ApgDIAIgATYClAMgAyACQZQDakEAIAYQ8hUgAkHIAmogCCgCADYCACACIAIpAogBNwPAAiADIAJB5AFqIAJBwAJqEPojIAJBLGoiASADIAUQwhkgAkHQAmoiAyABEM0cIAAgAxDRECACQaADaiQADwtB9OmFAUEpIAJBiAFqQeDqhQFBoOqFARDVHgALQQRBHBCjPQALzQUBCn8jAEEwayICJAACfyAAKAIAIgEEQCAAKAIEIQMgACgCDCEGQQAMAQtBAQshBANAAkACQAJAIARFBEAgAyAGRw0BIAIgATYCICACIAAoAgg2AhwgAkEcakEEQQQQ4B4gAEEANgIAQQEhBAwECwJAIAAoAiAiAUUNACABIAAoAiRGDQAgACABQQRqNgIgIAEoAgAhAyACIAAoAigpAwA3AxAgAkEcaiIBIANBCGoQgxUgAigCHCEEIAIgAigCICIDIAIoAiRBAnRqNgIoIAIgBDYCJCACIAM2AiAgAiADNgIcIAIgAkEQajYCLCMAQRBrIgMkACABKAIIIQkgASgCACIGIQQgAUEQaiEHIAEoAgwaIAEoAgQiBSABKAIMIghHBEAgBygCACEKA0AgBSgCACEHIAEgBUEEaiIFNgIEAkAgBykDICAKKQMAUg0AIActAChBIkcNACAEIAc2AgAgBEEEaiEEIAEoAgQhBSABKAIMIQgLIAUgCEcNAAsLIAMgBDYCBCADIAY2AgAgAygCBCEEIAFBADYCCCABQQQ2AgAgA0KAgICAwAA3AgggA0EIaiIFQQRBBBDgHiABQQQ2AgwgAUEENgIEIAJBBGoiASAEIAZrQQJ2NgIIIAEgBjYCBCABIAk2AgAgA0KAgICAwAA3AgggBUEEQQQQ4B4gA0EQaiQAIAIoAgQiAUGAgICAeEYNACAAIAE2AgggACACKAIIIgE2AgQgACABNgIAIAAgASACKAIMQQJ0aiIGNgIMIAEhAwwCCyAAKAIQIgNFBEBBACEBDAMLIAAoAhQiASAAKAIcRwRAIAAgAUEEajYCFCABKAIAIQEMAwsgAiADNgIgIAIgACgCGDYCHCACQRxqQQRBBBDgHkEAIQEgAEEANgIQDAILIAAgA0EEajYCBCADKAIAIQEMAQtBACEEDAELCyACQTBqJAAgAQuVAwEDfwJAAkACQAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9IAhCAYZacUUEQCAGIAhWDQEMCAsgAiADSQ0DDAYLIAcgBiAIfSIGfSAGVg0GIAIgA0kNAyABIANqIQsCQAJAA0AgAyAJakUNASAJQQFrIgkgC2oiCi0AAEE5Rg0ACyAKIAotAABBAWo6AAAgAyAJakEBaiIFIANNDQEgBSADQcDqiQEQrzsACwJAIANFBEBBMSEJDAELIAFBMToAAEEwIQkgA0EBayIKRSAKRXINACABQQFqQTAgCvwLAAsgBEEBasEiBCAFwUwgAiADTXINBSALIAk6AAAgA0EBaiEDDAULIAlBf0YNBCAJQX9zIgVFDQQgCkEBakEwIAX8CwAMBAsgAEEANgIADwsgAEEANgIADwsgAyACQbDqiQEQsDsACyADIAJBkOqJARCwOwALIAIgA08NACADIAJBoOqJARCwOwALIAAgBDsBCCAAIAM2AgQgACABNgIADwsgAEEANgIAC7ADAQd/IwBBIGsiBiQAIAEoAgghCCAGIAU2AhwgBiAENgIYIAZBGGoQ7hIhBwJAAkACQCACQf8BcUECRgRAIAdBPkwEQCAHQSNGDQQgB0EvRg0DDAILIAdBP0YNAyAHQYCAxABHDQEMAgsgBigCHCELIAYoAhghDAJ/IAggB0HcAEcNABogCCABKAIYIgpFDQAaIApBACABKAIcKAIUEQAAIAEoAggLIQkgASgCBCEKIAZBLzYCGAJAAkAgCQR/IAZBGGpBASAJIApqQQFrQQEQwS4NASABKAIIBUEACyEJIAFBARDYLSABKAIEIAEoAghqQS86AAAgASAJQQFqNgIIIAdBL0YgB0HcAEZyDQELIAZBCGogASACIAMgCCAEIAUQvwEgBigCDCEFIAYoAgghBAwDCyAGQRBqIAEgAiADIAggDCALEL8BIAYoAhQhBSAGKAIQIQQMAgsgAUEBENgtIAEoAgQgASgCCGpBLzoAACABIAhBAWo2AggLIAYgAUECIAMgCCAEIAUQvwEgBigCBCEFIAYoAgAhBAsgACAENgIAIAAgBTYCBCAGQSBqJAALsgMCBH8BfSMAQdAAayIDJAAgAyABKAIMKAIQIAJBAXRqLwEAIgQ7AQIgAAJ/An8gBEEQdCAEQf//AXFFDQAaIARB/wdxIQUgBEGAgAJxIQYgBEGA+AFxIgRBgPgBRgRAIAZBEHQhBCAEQYCAgPwHciAFRQ0BGiAEIAVBDXRyQYCAgP4HcgwBCyAGQRB0IQYgBEENdEGAgID8AHEgBUENdHJBgICAwANqIAZyIAQNABogBSAFZ0EQayIEQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIARBF3Rrcgu+IgdDAACAv14gB0MAAIBDXXFFBEAgA0E4akGGjJgwNgIAIANChoyYsODAgYMGNwMwIANBAjYCHCADQfiS/wA2AhggA0ICNwIkIANBrQM2AkwgA0GHDDYCRCADIANBQGs2AiAgAyADQTBqIgE2AkggAyADQQJqNgJAIANBCGogA0EYahCZDiABEKUMIAAgAykACTcABSAAQQxqIANBEGopAAA3AAAgACADLQAIOgAEQYKAgIB4DAELIAEoAgAgAmogB/wBOgAAQZOAgIB4CzYCACADQdAAaiQAC7IDAgR/AX0jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAAcNeIAdDAAAAQ11xRQRAIANBOGpBgoSIEDYCACADQoKEiJCgwICBAjcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCAAIAMpAAk3AAUgAEEMaiADQRBqKQAANwAAIAAgAy0ACDoABEGCgICAeAwBCyABKAIAIAJqIAf8ADoAAEGTgICAeAs2AgAgA0HQAGokAAu1AwIDfwJ+IwBB4ABrIgIkAAJAAkACQCAAKAIEKAIQIAFBBHRqIgMpAwAiBUKAgICACHwiBkL/////D1YgAykDCCAFIAZWrXwiBkIAUiAGUBsNACACIAAoAgAiBCgCACgCACgCACIDNgIgIAIgBT4CHAJAIAOsIAXEfiIFQiCIpyAFpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBTcDCCAFp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwwMBC38jAEFAaiICJAAgAkEQaiABENw7AkACQAJAIAIoAhQEQCACKAIQIgMoAgAiBCAEKAIAIgVBAWo2AgAgBUEASA0BIAIgBDYCHCACIAMpAgQ3AiAgAkEoaiACQRxqIAEoAiggASgCJBD9HCACQQhqIAEQ3DsgAigCDCIDRQ0CIAIoAgghCSACQTRqIANBAWsiCkEAQQRBDBCgGCACKAI4IQQgAigCNEEBRg0DIAIoAjwhBwJAIARFDQAgA0EMbEEMayELQQAhBSAEIQMDQCAFIAtGDQEgBSAJaiIMQQxqKAIAIgggCCgCACIGQQFqNgIAIAZBAEgNAyAFIAdqIgZBBGogDEEQaikCADcCACAGIAg2AgAgBUEMaiEFIANBAWsiAw0ACwsgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEUakGXrty4ATYCACAAQpeu3Ljx4sWLFzcCDCAAIAo2AgggACAHNgIEIAAgBDYCACAAIAIpAig3AhggAEEgaiACQTBqKAIANgIAIAEQiCcgAkFAayQADwtBAEEAQYzNhQEQwyELAAtBAUEAQZzNhQEQrzsACyAEIAIoAjxB0MmFARD9LwALwwMBC38jAEFAaiICJAAgAkEQaiABENw7AkACQAJAIAIoAhQEQCACKAIQIgMoAgAiBCAEKAIAIgVBAWo2AgAgBUEASA0BIAIgBDYCHCACIAMpAgQ3AiAgAkEoaiACQRxqIAEoAiggASgCJBD9HCACQQhqIAEQ3DsgAigCDCIDRQ0CIAIoAgghCSACQTRqIANBAWsiCkEAQQRBDBCgGCACKAI4IQQgAigCNEEBRg0DIAIoAjwhBwJAIARFDQAgA0EMbEEMayELQQAhBSAEIQMDQCAFIAtGDQEgBSAJaiIMQQxqKAIAIgggCCgCACIGQQFqNgIAIAZBAEgNAyAFIAdqIgZBBGogDEEQaikCADcCACAGIAg2AgAgBUEMaiEFIANBAWsiAw0ACwsgAEEkaiABQSxqQQAgASgCLBsQ7iUgAEEUakGatOjQATYCACAAQpq06NChw4aNGjcCDCAAIAo2AgggACAHNgIEIAAgBDYCACAAIAIpAig3AhggAEEgaiACQTBqKAIANgIAIAEQiCcgAkFAayQADwtBAEEAQYzNhQEQwyELAAtBAUEAQZzNhQEQrzsACyAEIAIoAjxB0MmFARD9LwALmQMCBX8CfiMAQSBrIgMkAAJ/AkACQAJAAkAgAUHBAEkEQCABQQlPDQFBAiAAKAIcIgYgAWoiAiAAKAIYIgVBA3RqIAAoAggiAUEDdEsNBRoCQCAGBEAgACkDECEHDAELIAEgBUkNAyAAQQggASAFayIEIARBCE8bIAAoAgQgBWogBBDZIiIHNwMQCyAAIAI2AhwgAyAHQn9CfyACrYZCf4UgAkE/SxuDIAZBP3GtiCIHNwMAIAJBwABJDQQgACACQUBqIgQ2AhwgACAFQQhqIgI2AhggBEUNBCABIAJJDQMgAEEIIAEgAmsiASABQQhPGyAAKAIEIAJqIAEQ2SIiCDcDECADIAhCf0J/IASthkJ/hSAEQT9LG4NBACAGa0E/ca2GIAeENwMADAQLQZi2zgBBIEG4ts4AEJ8pAAtByLbOAEEwQfi2zgAQnykACyAFIAFBxLvOABCvOwALIAIgAUHEu84AEK87AAsgA0EIaiADQQgQ2BYgAygCCEEIRgRAIAMtAAwMAQsgA0EIahDJI0ECCyADQSBqJAALjgQBDH8jAEEgayIGJAAgASABKAIUIghBAWoiCTYCFAJAIAEoAhAiByAJSwRAIAhBAmohCiABQQxqIQsgASgCDCAJaiEMIAhBf3MgB2ohDQJAAkADQCAFIAxqLQAAIg5BMGsiD0H/AXEiEEEKTwRAIAVFBEAgBkENNgIUIAYgCyAFIAhqQQJqIgEgByABIAdJGxDqDCAGQRRqIAYoAgAgBigCBBD7KCEBIABBATYCACAAIAE2AgQMBgsgBCAFayEFIA5BIHJB5QBHDQMgACABIAIgAyAFEOkMDAULIBBBBUsgA0KZs+bMmbPmzBlSciADQpiz5syZs+bMGVZxDQEgASAFIApqNgIUIANCCn4gD61C/wGDfCEDIA0gBUEBaiIFRw0ACyAEIAlqIAdrIQUMAQsgBCAFayEFAkACQAJAIAEoAhQiBCABKAIQIgdPDQAgASgCDCEIA0AgBCAIai0AACIJQTBrQf8BcUEJTQRAIAEgBEEBaiIENgIUIAQgB0cNAQwCCwsgCUEgckHlAEYNAQsgACABIAIgAyAFELASDAELIAAgASACIAMgBRDpDAsMAgsgACABIAIgAyAFELASDAELIAZBBTYCFCAGQQhqIAFBDGogCEECaiIBIAcgASAHSRsQ6gwgBkEUaiAGKAIIIAYoAgwQ+yghASAAQQE2AgAgACABNgIECyAGQSBqJAALrwMBBH8jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEOgJDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ6AkgBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQJ0IAJqQQRrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKAIAIQkgASACIAhBAnRqIgooAgA2AgAgCiAJNgIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQRrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC7EDAgN/AX4jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEP8PDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQ/w8gBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQN0IAJqQQhrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKQMAIQogASACIAhBA3RqIgkpAwA3AwAgCSAKNwMADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQhrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC68DAQR/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCQHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJAdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0ECdCACakEEayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASgCACEJIAEgAiAIQQJ0aiIKKAIANgIAIAogCTYCAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEEayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuvAwEEfyMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQkh0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCSHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBAnQgAmpBBGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEoAgAhCSABIAIgCEECdGoiCigCADYCACAKIAk2AgAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBBGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQkx0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCTHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQgBAMAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCAECAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALsQMCA38BfiMAQTBrIgckAAJAIAMgBE8EQCAERQRAIAAgASACIAMQlR0MAgsgByADIARrIgg2AgAgB0EIaiABIAIgAxCVHSAHKAIMIQEgBygCCCIEQQhHBEAgACAHKQMQNwMIIABBEGogB0EYaikDADcDACAAIAE2AgQgACAENgIADAILIAcgATYCBCABIAhGBEAgA0EBayEEIANBA3QgAmpBCGshAQNAAkACQCAGIARBA3YiCUsEQCAEQQdxQfzEzgBqLQAAIAUgCWotAABxRQ0CIAhBAWsiCCADTw0BIAEpAwAhCiABIAIgCEEDdGoiCSkDADcDACAJIAo3AwAMAgsgCSAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIAFBCGshASAEQQFrIgRBf0cNAAsgAEEINgIAIAAgAzYCBAwCCyAHQQI2AgwgB0HooM0ANgIIIAdCAjcCFCAHQTs2AiwgB0E7NgIkIAcgB0EgajYCECAHIAc2AiggByAHQQRqNgIgIABBBGogB0EIahCZDiAAQQA2AgAMAQtB6J/NAEEsQZSgzQAQnykACyAHQTBqJAALrwMBBH8jAEEwayIHJAACQCADIARPBEAgBEUEQCAAIAEgAiADEIEQDAILIAcgAyAEayIINgIAIAdBCGogASACIAMQgRAgBygCDCEBIAcoAggiBEEIRwRAIAAgBykDEDcDCCAAQRBqIAdBGGopAwA3AwAgACABNgIEIAAgBDYCAAwCCyAHIAE2AgQgASAIRgRAIANBAWshBCADQQJ0IAJqQQRrIQEDQAJAAkAgBiAEQQN2IglLBEAgBEEHcUH8xM4Aai0AACAFIAlqLQAAcUUNAiAIQQFrIgggA08NASABKAIAIQkgASACIAhBAnRqIgooAgA2AgAgCiAJNgIADAILIAkgBkHEiM0AEMMhAAsgCCADQaSgzQAQwyEACyABQQRrIQEgBEEBayIEQX9HDQALIABBCDYCACAAIAM2AgQMAgsgB0ECNgIMIAdB6KDNADYCCCAHQgI3AhQgB0E7NgIsIAdBOzYCJCAHIAdBIGo2AhAgByAHNgIoIAcgB0EEajYCICAAQQRqIAdBCGoQmQ4gAEEANgIADAELQeifzQBBLEGUoM0AEJ8pAAsgB0EwaiQAC68DAQR/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCCEAwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEIIQIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0ECdCACakEEayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASgCACEJIAEgAiAIQQJ0aiIKKAIANgIAIAogCTYCAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEEayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuxAwIDfwF+IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxDpCQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEOkJIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQgA0EDdCACakEIayEBA0ACQAJAIAYgBEEDdiIJSwRAIARBB3FB/MTOAGotAAAgBSAJai0AAHFFDQIgCEEBayIIIANPDQEgASkDACEKIAEgAiAIQQN0aiIJKQMANwMAIAkgCjcDAAwCCyAJIAZBxIjNABDDIQALIAggA0GkoM0AEMMhAAsgAUEIayEBIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuVAwIFfwJ+IwBBIGsiBCQAAkACQAJAAkAgAkHBAEkEQCABKAIcIgcgAmoiAyABKAIYIgZBA3RqIAEoAggiAkEDdE0EQAJAIAcEQCABKQMQIQgMAQsgAiAGSQ0DIAFBCCACIAZrIgUgBUEITxsgASgCBCAGaiAFENkiIgg3AxALIAEgAzYCHCAEIAhCf0J/IAOthkJ/hSADQT9LG4MgB0E/ca2IIgg3AwAgA0HAAEkNBCABIANBQGoiBTYCHCABIAZBCGoiAzYCGCAFRQ0EIAIgA0kNAyABQQggAiADayICIAJBCE8bIAEoAgQgA2ogAhDZIiIJNwMQIAQgCUJ/Qn8gBa2GQn+FIAVBP0sbg0EAIAdrQT9xrYYgCIQ3AwAMBAsgAEIANwMADAQLQZi2zgBBIEG4ts4AEJ8pAAsgBiACQcS7zgAQrzsACyADIAJBxLvOABCvOwALIARBCGogBEEIEMQYIAACfiAEKAIIQQhGBEAgACAEKQMQNwMIQgEMAQsgBEEIahDJI0IACzcDAAsgBEEgaiQAC8oDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQ2isgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDsHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGHjpw4NgIAIAJCh46cuPDgwYMHNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvKAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEEI8sIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQ7BwgAi8BCEEBcUUNASACLwEKCyEEQQEMAQsgAkHoAGpBh46cODYCACACQoeOnLjw4MGDBzcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpATo3AxggAiACQUBrKQEANwEeIAIvATghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgATsBBCADQYKAgIB4NgIAIAMgAikDGDcBBiADQQxqIAIpAR43AQBBAAshASAAIAQ7AQIgACABOwEAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQALygMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEoAgAgBBDaKyACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEEO4cIAIvAQhBAXFFDQEgAi8BCgshBEEBDAELIAJB6ABqQYOGjBg2AgAgAkKDhoyYsODAgQM3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQE6NwMYIAIgAkFAaykBADcBHiACLwE4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE7AQQgA0GCgICAeDYCACADIAIpAxg3AQYgA0EMaiACKQEeNwEAQQALIQEgACAEOwECIAAgATsBACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8oDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQjywgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDuHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGDhowYNgIAIAJCg4aMmLDgwIEDNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAuyAwIPfwF+IwBBsAFrIgIkACACQfAAaiABQTRqENQGAkAgASgCTCIFBEAgBSAFKAIAIgNBAWo2AgAgA0EASA0BIAEoAlwhCCABKAJYIQkgASgCVCEKIAEoAlAhCyABKAJgIQcLIAEoAhghBiACQQxqIAFBDGoQ1AYgASgCHCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiwhDCABKAIoIQ0gASgCJCEOIAEoAiAhDyABKAIwIQQLIAJB/ABqIhAgARC8FSACQZABaiACQRRqKAIANgIAIAIgBjYClAEgAiAENgKsASACIAw2AqgBIAIgDTYCpAEgAiAONgKgASACIA82ApwBIAIgAzYCmAEgAiACKQIMNwKIASABKAJAIgMgAygCACIGQQFqNgIAIAZBAEgNACACQcgAaiACQfgAaigCADYCACACIAIpAnA3AkAgAiAHNgJsIAIgCDYCaCACIAk2AmQgAiAKNgJgIAIgCzYCXCACIAU2AlggASkCRCERIAJBDGoiASAQQTT8CgAAIAIgETcCUCACIAM2AkwgACABEPYRIAJBsAFqJAAPCwALoAMBCn8gACgCBCIFKAIEIAAoAgAiBCgCBCAFKAIIIgcgBCgCCCIEIAQgB0sbEJknIQIgAEEMQQggACgCDCIFKAIEIAAoAggiBigCBCAFKAIIIgUgBigCCCIGIAUgBkkbEJknIgMgBSAGayADG0EASCIGG2ohBSAAQQhBDCAGG2oiBiAAIAIgByAEayACGyIEQX9zQR12QQRxaiIHIAUgBSgCACICKAIEIAAgBEEddkEEcWoiACgCACIDKAIEIAIoAggiBCADKAIIIgIgAiAESxsQmSciAyAEIAJrIAMbQQBIIgQbIAYoAgAiAigCBCAHKAIAIgMoAgQgAigCCCICIAMoAggiAyACIANJGxCZJyIIIAIgA2sgCBtBAEgiAhsiAygCACIJKAIEIAAgBSAHIAIbIAQbIggoAgAiCigCBCAJKAIIIgkgCigCCCIKIAkgCkkbEJknIQsgASAFIAAgBBsoAgA2AgAgASADIAggCyAJIAprIAsbQQBIIgAbKAIANgIEIAEgCCADIAAbKAIANgIIIAEgByAGIAIbKAIANgIMC8UJAg5+A38jAEGAAWsiESQAQQEhEgJAIAEoAgBBAUYEQCAAIAEpAgQ3AgQgAEEUaiABQRRqKAIANgIAIABBDGogAUEMaikCADcCAAwBCyABKQMoIQ4gASkDICEPIAEpAxghCiABKQMQIQsgEUHgAGoiAUIKQgAQsi4gESkDYCEDIBEpA2ghBSARKQNwIQggESkDeCEJIAIoAgAhEiMAQaACayICJAACQCASRQRAIAFCAUIAELIuDAELIAJBgAJqQgFCABCyLiACKQOYAiEMIAIpA5ACIQ0gAikDiAIhBiACKQOAAiEEIBJBAUcEQANAIBJBAXEEQCACQfABaiAEQgAgA0IAEKgeIAJB4AFqIAZCACADQgAQqB4gAkHQAWogBEIAIAVCABCoHiACQcABaiAGQgAgBUIAEKgeIAJBsAFqIAMgBSANIAwQqB4gAkGgAWogBCAGIAggCRCoHiACKQPIASACKQOgASIEIAIpA7ABfCIGIARUrSACKQOoASACKQO4AXx8fCAGIAYgAikDwAF8IgRWrXwgBCAEIAIpA+gBIAIpA/gBIgcgAikD4AF8IgYgB1StfHwiBFatfCAEIAIpA9gBIAYgBiACKQPQAXwiBlatfHwiDSAEVK18IQwgAikD8AEhBAsgAkGQAWogA0IAIgcgAyAHEKgeIAJBgAFqIAMgByAFIAcQqB4gAkHwAGogBSAHIAUgBxCoHiACQeAAaiADIAUgCCAJEKgeIAIpA3ggAikDaEIBhiACKQNgIgNCP4iEfCACKQNwIgUgA0IBhnwiAyAFVK18IAMgAyACKQOIASIJIAIpA5gBIgUgAikDgAEiEHwiByAFVK18fCIIVq18IAggCCAJIAcgByAQfCIFVq18fCIIVq18IQkgAikDkAFCfYMhAyASQQNLIBJBAXYhEg0ACwsgAkHQAGogA0IAIARCABCoHiACQUBrIANCACAGQgAQqB4gAkEwaiAFQgAgBEIAEKgeIAJBIGogBUIAIAZCABCoHiACQRBqIAMgBSANIAwQqB4gAiAIIAkgBCAGEKgeIAEgAikDUDcDACABIAIpA1giBCACKQNAfCIDIAIpAzB8Igc3AwggASACKQMQIgggAikDAHwiBSACKQMgfCIGIAIpA0ggAyAEVK18fCIEIAIpAzggAyAHVq18fCIDNwMQIAEgAyAEVK0gBCAGVK0gBSAGVq0gAikDKCAFIAhUrSACKQMYIAIpAwh8fHx8fHw3AxgLIAJBoAJqJAAgEUHQAGogESkDYCIDQgAgC0IAEKgeIBFBQGsgA0IAIApCABCoHiARQTBqIBEpA2giBUIAIAtCABCoHiARQSBqIAVCACAKQgAQqB4gEUEQaiADIAUgDyAOEKgeIBEgESkDcCARKQN4IAsgChCoHiAAIBEpA1A3AxAgACARKQNYIgQgESkDQHwiAyARKQMwfCIHNwMYIAAgESkDICIIIBEpAxB8IgUgESkDAHwiBiARKQNIIAMgBFStfHwiBCARKQM4IAMgB1atfHwiAzcDICAAIAMgBFStIAQgBlStIAUgBlatIBEpAwggBSAIVK0gESkDKCARKQMYfHx8fHx8NwMoQQAhEgsgACASNgIAIBFBgAFqJAALxwMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEgBBCtKiACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEEOwcIAIvAQhBAXFFDQEgAi8BCgshBEEBDAELIAJB6ABqQYeOnDg2AgAgAkKHjpy48ODBgwc3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQE6NwMYIAIgAkFAaykBADcBHiACLwE4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE7AQQgA0GCgICAeDYCACADIAIpAxg3AQYgA0EMaiACKQEeNwEAQQALIQEgACAEOwECIAAgATsBACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8cDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABIAQQrSogAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBDuHCACLwEIQQFxRQ0BIAIvAQoLIQRBAQwBCyACQegAakGDhowYNgIAIAJCg4aMmLDgwIEDNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikBOjcDGCACIAJBQGspAQA3AR4gAi8BOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOwEEIANBgoCAgHg2AgAgAyACKQMYNwEGIANBDGogAikBHjcBAEEACyEBIAAgBDsBAiAAIAE7AQAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvHAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEENorIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQuh0gAi0ACEUNASACLQAJCyEEQQEMAQsgAkHoAGpBhoyYMDYCACACQoaMmLDgwIGDBjcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpADk3AxggAiACQUBrKQAANwAfIAItADghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgAToABCADQYKAgIB4NgIAIAMgAikDGDcABSADQQxqIAIpAB83AABBAAshASAAIAQ6AAEgACABOgAAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQALxwMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEoAgAgBBCPLCACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEELsdIAItAAhFDQEgAi0ACQshBEEBDAELIAJB6ABqQYKEiBA2AgAgAkKChIiQoMCAgQI3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQA5NwMYIAIgAkFAaykAADcAHyACLQA4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE6AAQgA0GCgICAeDYCACADIAIpAxg3AAUgA0EMaiACKQAfNwAAQQALIQEgACAEOgABIAAgAToAACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8cDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABKAIAIAQQjywgAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBC6HSACLQAIRQ0BIAItAAkLIQRBAQwBCyACQegAakGGjJgwNgIAIAJChoyYsODAgYMGNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikAOTcDGCACIAJBQGspAAA3AB8gAi0AOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOgAEIANBgoCAgHg2AgAgAyACKQMYNwAFIANBDGogAikAHzcAAEEACyEBIAAgBDoAASAAIAE6AAAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAvHAwECfyMAQYABayICJAACQAJ/QQIgASgCHCIEIAEoAiBGDQAaAkACfwJAIAEoAgRFDQAgBCABKAIUTw0EIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAMAQsgASAEQQFqNgIcIAJBEGogASgCACAEENorIAIoAhAhASACIAIoAhQiBDYCMCACIAE2AiwgAkEIaiABIAQQux0gAi0ACEUNASACLQAJCyEEQQEMAQsgAkHoAGpBgoSIEDYCACACQoKEiJCgwICBAjcDYCACQQM2AkwgAkHEroABNgJIIAJCAjcCVCACQa4QNgJ8IAJBzAE2AnQgAiACQfAAajYCUCACIAJB4ABqIgE2AnggAiACQSxqNgJwIAJBOGogAkHIAGoQmQ4gARCqDCACIAIpADk3AxggAiACQUBrKQAANwAfIAItADghASADKAIAQZOAgIB4RwRAIAMQiBELIAMgAToABCADQYKAgIB4NgIAIAMgAikDGDcABSADQQxqIAIpAB83AABBAAshASAAIAQ6AAEgACABOgAAIAJBgAFqJAAPC0H0p4ABQSBBlKiAARCfKQAL8wYCE38BfiMAQcACayICJAACQAJAIAEtAAxBIUYEQCABKAIgIRECfyABKAIkBEBBGEEEEK02IgVFDQMgBSABKQIYNwIAIAUgAUEkaiIDKQIANwIMIAVBCGogAUEgaigCADYCACAFQRRqIANBCGooAgA2AgBBAgwBC0EMQQQQrTYiBUUNAyAFIAEpAhg3AgAgBUEIaiABQSBqKAIANgIAQQELIQ4gAkEIaiABQRBqELAuIAIpAwghFSACIAE2AuABIAIgFTcC2AEjAEEgayIDJAAgA0EUaiACQdgBaiIIKAIEIAgoAgBrQQN2QQBBBEHEABCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEGMz4UBEP0vAAsgAkEUaiELIANBEGoiEkEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEQayIEJAAgA0EIaiIGIAgoAgQiCSAIKAIAIgprQQN2EP4tIAQgBikCBEIgiTcCBCAEIAZBCGo2AgAgBCAIKAIINgIMIwBB0ABrIg8kACAEKAIEIQYgBCgCACETAkACQAJAIAkgCkcEQCAEKAIMIRAgBCgCCCAGQcQAbGohDCAJIAprQQN2IQkDQCAQKAIIIg0gCiwAACIHTQ0CIBAoAgQgB0EDdGoiBygCACINRQ0DIA9BDGoiFCANIAcoAgQiBygCCEEBa0F4cWpBCGogBygCFBEAACAMIBRBxAD8CgAAIApBCGohCiAMQcQAaiEMIAZBAWohBiAJQQFrIgkNAAsLIBMgBjYCACAPQdAAaiQADAILIAcgDUGU5oQBEMMhAAtBpOaEARCyOwALIARBEGokACALQQhqIBIoAgA2AgAgCyADKQIINwIAIANBIGokACACQYACaiABQQxqIgNBCGooAgA2AgAgAkEAOwGwAiACQQA2AqwCIAJBADYClAIgAkEANgKIAiACIBE2AoQCIAJCBDcC8AEgAkIANwLoASACQoCAgIDAADcC4AEgAkEANgLYASACIAMpAgA3AvgBIAIgDjYCvAIgAiAFNgK4AiACIA42ArQCIAJB/ABqIgMgCCACQbQCahCWKSACQSBqIgUgAyALEPwiIAAgBRDNHCABELMmIAFBBEEIEOAeIAJBwAJqJAAPC0GU3YUBQShB9OKFARCfKQALQQRBGBCjPQALQQRBDBCjPQALgAMBAX8gAEEEaiEBAkACQAJAAkACQAJAIAAoAgAOBQECBAMEAAsgASgCACIAQYQBSQ0EIAAQ8h8PCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgASgCACIAKAIAIgFBgICAgHhzIAFBAE4bDhAAAQIDBAUGDwcICQoLDA0ODwsgAEEEahDeOwwOCyAAQQRqELwqDA0LIABBBGoQ3jsMDAsgAEEEahDeOwwLCyAAQQRqEN47DAoLIABBBGoQ3jsMCQsgAEEEahDeOwwICyAAQQRqEN47DAcLIABBBGoQ3jsMBgsgAEEEahDeOwwFCyAAEN47IAAtAAxBA0cNBCAAKAIQIgEQvCogAUEMQQQQ+DoMBAsgAEEEahDeOwwDCyAAQQRqEN47DAILIABBBGoQ3jsMAQsgAEEEahDeOwsgAEEUQQQQ+DoPCyABKAIAIgAQySMgAEEYQQgQ+DoPCyABKAIAIgAQoSkgAEEEQQQQ+DoPCyABEN47CwvwBAIDfwN+IwBB8AFrIgUkACAFIAI2AhAgBSABNgIMIAUgAzYCFAJAAkAgBC0AAEEpRwRAIAVBIGogBEEIaigCADYCACAFIAQpAgA3AxgMAQsgBUGoAWogA0EIahCLBSAFKALcASIEQYCAgIB4RgRAIAVBgAFqIAVBuAFqKQMAIgg3AwAgBUH4AGogBUGwAWopAwAiCTcDACAFIAUpA6gBIgo3A3AgAEEYaiAINwMAIABBEGogCTcDACAAIAo3AwggAEIGNwMAIAMgAygCACIAQQFrNgIAIABBAUYEQCAFQRRqENkhCyAFQQxqELwqDAILIAVB8ABqIgYgBUGoAWpBNPwKAAAgBUHoAGogBUHoAWopAwA3AwAgBSAFKQPgATcDYCAFQShqIgcgBkE0/AoAACAFIAQ2AlwgBUEYaiAFQdAAahDCBiAHEIAvC0EAIQYjAEEwayIEJAAgBCADNgIEAkAgAy4BGCIHQQBMBEAgBEGBgICAeDYCCAwBCwJAIAdBAUcNACADLwEaDQAgAygCFCIGQQhqIAYoAghBAkZBAnRqLQAgIgZBA0cgBkEAR3EhBgsgBEEIaiAEQQRqIAYQlRILIAAgAzYCoAIgAEEANgKQAiAAQoCAgICAATcDiAIgAy4BGiEDIABB4AFqIARBCGpBKPwKAAAgAEICNwOYAiAAQgA3AqQCIABCBTcDACAAIANBAExBH3Q2ApQCIARBMGokACAAQYCAgIB4NgLEAiAAQYCAgIB4NgK4AiAAIAI2ArQCIAAgATYCsAIgACAFKQMYNwPQAiAAQdgCaiAFQSBqKAIANgIACyAFQfABaiQAC64DAgJ/A34jAEHwAWsiBSQAIAUgAjYCECAFIAE2AgwgBSADNgIUAkACQCAELQAAQSlHBEAgBUEgaiAEQQhqKAIANgIAIAUgBCkCADcDGAwBCyAFQagBaiADQQhqEIsFIAUoAtwBIgRBgICAgHhGBEAgBUGAAWogBUG4AWopAwAiBzcDACAFQfgAaiAFQbABaikDACIINwMAIAUgBSkDqAEiCTcDcCAAQRhqIAc3AwAgAEEQaiAINwMAIAAgCTcDCCAAQgY3AwAgAyADKAIAIgBBAWs2AgAgAEEBRgRAIAVBFGoQ2SELIAVBDGoQvCoMAgtBAEUEQCAFQfAAaiAFQagBakE0/AoAAAsgBUHoAGogBUHoAWopAwA3AwAgBSAFKQPgATcDYCAGRQRAIAVBKGogBUHwAGpBNPwKAAALIAUgBDYCXCAFQRhqIAVB0ABqEMIGIAVBKGoQgC8LIAAgAxDKFSAAQYCAgIB4NgLEAiAAQYCAgIB4NgK4AiAAIAI2ArQCIAAgATYCsAIgACAFKQMYNwPQAiAAQdgCaiAFQSBqKAIANgIACyAFQfABaiQAC5sDAQl/IAAoAsABIQUgACgCXCEHAkAgA0EBRgRAIAFBBmshCSAFQQhqIQYgACgCBCIKIAAoAhwiA2ohASADQQh0QYACaiEEIAAoAsgBIQgDQCABQQNqIgUgCU8NAiAHIAEgBiAIEKMdIgBBBnZB/P//H3FqIABB/wFxIAEgCmtBCHRyNgIAAkAgAkUNAEEBIQMgBCEAA0AgA0EDRg0BIAcgASADaiAGIAgQox0iC0EGdkH8//8fcWoiDCgCAEUEQCAMIAAgC0H/AXFqNgIACyAAQYACaiEAIANBAWohAwwACwALIARBgAZqIQQgBSEBDAALAAsgAUEGayEIIAAoAhwiA0EBaiEBIAAoAgQiBCADaiEDIAAoAsgBIQYDQCADQQNqIgAgCE8NASAHIAMgBSAGEKMdQQJ0aiADIARrNgIAAkAgAkUNACABIARqIQlBACEDA0AgA0ECRg0BIAcgAyAJaiAFIAYQox1BAnRqIgooAgBFBEAgCiABIANqNgIACyADQQFqIQMMAAsACyABQQNqIQEgACEDDAALAAsLzwMCA38EfiMAQbABayICJAAgACgCBCgCECABQQR0aiIDKQMAIQUgAykDCCEGIAAoAgAiAygCACgCACIEKQMAIQcgAiAEKQMIIgg3A2ggAiAHNwNgIAIgBjcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAGIAcgCCACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALxAMBAn8jAEGAAWsiAiQAAkACf0ECIAEoAhwiBCABKAIgRg0AGgJAAn8CQCABKAIERQ0AIAQgASgCFE8NBCABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEADAELIAEgBEEBajYCHCACQRBqIAEgBBCtKiACKAIQIQEgAiACKAIUIgQ2AjAgAiABNgIsIAJBCGogASAEELodIAItAAhFDQEgAi0ACQshBEEBDAELIAJB6ABqQYaMmDA2AgAgAkKGjJiw4MCBgwY3A2AgAkEDNgJMIAJBxK6AATYCSCACQgI3AlQgAkGuEDYCfCACQcwBNgJ0IAIgAkHwAGo2AlAgAiACQeAAaiIBNgJ4IAIgAkEsajYCcCACQThqIAJByABqEJkOIAEQqgwgAiACKQA5NwMYIAIgAkFAaykAADcAHyACLQA4IQEgAygCAEGTgICAeEcEQCADEIgRCyADIAE6AAQgA0GCgICAeDYCACADIAIpAxg3AAUgA0EMaiACKQAfNwAAQQALIQEgACAEOgABIAAgAToAACACQYABaiQADwtB9KeAAUEgQZSogAEQnykAC8QDAQJ/IwBBgAFrIgIkAAJAAn9BAiABKAIcIgQgASgCIEYNABoCQAJ/AkAgASgCBEUNACAEIAEoAhRPDQQgASgCCCABKAIQIARqIgVBA3ZqLQAAQf8BcyAFQQdxdkEBcUUNACABIARBAWo2AhxBAAwBCyABIARBAWo2AhwgAkEQaiABIAQQrSogAigCECEBIAIgAigCFCIENgIwIAIgATYCLCACQQhqIAEgBBC7HSACLQAIRQ0BIAItAAkLIQRBAQwBCyACQegAakGChIgQNgIAIAJCgoSIkKDAgIECNwNgIAJBAzYCTCACQcSugAE2AkggAkICNwJUIAJBrhA2AnwgAkHMATYCdCACIAJB8ABqNgJQIAIgAkHgAGoiATYCeCACIAJBLGo2AnAgAkE4aiACQcgAahCZDiABEKoMIAIgAikAOTcDGCACIAJBQGspAAA3AB8gAi0AOCEBIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyABOgAEIANBgoCAgHg2AgAgAyACKQMYNwAFIANBDGogAikAHzcAAEEACyEBIAAgBDoAASAAIAE6AAAgAkGAAWokAA8LQfSngAFBIEGUqIABEJ8pAAuXAQEBfwJAIAFBBEwNACAAIAAoAgAiAkEBazYCECAAIAJBAWo2AhQgACACQQJrNgIYIAAgAkECajYCHCAAIAJBA2s2AiAgACACQQNqNgIkIAFBCk0NACAAIAAoAgQiAUEBazYCKCAAIAFBAWo2AiwgACABQQJrNgIwIAAgAUECajYCNCAAIAFBA2s2AjggACABQQNqNgI8CwurAwMEfwF9AX4jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAgL9eIAdDAACAX11xRQRAIANBOGpBiZKkyAA2AgAgA0KJkqTIkKHChAk3AzAgA0ECNgIcIANB+JL/ADYCGCADQgI3AiQgA0GtAzYCTCADQYcMNgJEIAMgA0FAazYCICADIANBMGoiATYCSCADIANBAmo2AkAgA0EIaiADQRhqEJkOIAEQpQwgAykCCCEIIAAgAykCEDcCDCAAIAg3AgRBgoCAgHgMAQsgASgCACACQQN0aiAHrzcDAEGTgICAeAs2AgAgA0HQAGokAAuqAwMEfwF9AX4jAEHQAGsiAyQAIAMgASgCDCgCECACQQF0ai8BACIEOwECIAACfwJ/IARBEHQgBEH//wFxRQ0AGiAEQf8HcSEFIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IQQgBEGAgID8B3IgBUUNARogBCAFQQ10ckGAgID+B3IMAQsgBkEQdCEGIARBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAGciAEDQAaIAUgBWdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILviIHQwAAAN9gIAdDAAAAX11xRQRAIANBOGpBhYqUKDYCACADQoWKlKjQoMGCBTcDMCADQQI2AhwgA0H4kv8ANgIYIANCAjcCJCADQa0DNgJMIANBhww2AkQgAyADQUBrNgIgIAMgA0EwaiIBNgJIIAMgA0ECajYCQCADQQhqIANBGGoQmQ4gARClDCADKQIIIQggACADKQIQNwIMIAAgCDcCBEGCgICAeAwBCyABKAIAIAJBA3RqIAeuNwMAQZOAgIB4CzYCACADQdAAaiQAC8sDAgN/BH4jAEGwAWsiAiQAIAAoAgQoAhAgAUECdGo0AgAhBSAAKAIAIgMoAgAoAgAiBCkDACEGIAIgBCkDCCIHNwNoIAIgBjcDYCACIAVCP4ciCDcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAIIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALywMCA38EfiMAQbABayICJAAgACgCBCgCECABQQN0aikDACEFIAAoAgAiAygCACgCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAvDDQIRfwR+IwBBEGsiCiQAIAEoAghFBEAgCkEIaiEOIwBB4ABrIgYkACAGIAU2AhwgASgCDCEHIAYgBkEcajYCIAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgggBSAFIAhJGyIHQQ9PBEAgB0H/////AUsNAUF/IAdBA3RBB25BAWtndkEBaiEIDAILQQRBCEEQIAdBCEkbIAdBBEkbIQgMAQsQ3ScgBigCFCEIIAYoAhAiBUGBgICAeEcNBAsgBkHQAGogB0EEIAgQ+xQgBigCWCEIIAYoAlQhBSAGKAJQIgdFDQMgBiAGKAJcNgJMIAYgCDYCSCAGIAU2AkQgBiAHNgJAIAZBCGogBkFAaxDBNCAGKAIMIgUEQCAGKAIIQf8BIAX8CwALIAYoAkghCCAGKAJEIQUgBigCQCIHRQ0DIAYgBigCTDYCPCAGIAg2AjggBiAFNgI0IAYgBzYCMCAGQoSAgICAATcCKCAGIAFBEGo2AiQgBkEwaiERIAYgASgCDCIPBH8gB0EIaiESIAEoAgAiECkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIAxBCGohDCAQQQhqIhApAwBCgIGChIiQoMCAf4MiF0KAgYKEiJCgwIB/UQ0ACyAXQoCBgoSIkKDAgH+FIRoLIAcgBSAGKAIgKAIAIgkpAwgiFyABKAIAIBp6p0EDdiAMakECdCITa0EEazUCAIUiGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhELSgaqbq/qC16d/fiIXQjiGIBdCgP4Dg0IohoQgF0KAgPwHg0IYhiAXQoCAgPgPg0IIhoSEIBdCCIhCgICA+A+DIBdCGIhCgID8B4OEIBdCKIhCgP4DgyAXQjiIhISEIBhC2KLR78Kp5b8tfoUiF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAJKQMAIhhCf4V+IhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIQgFyAYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEfoUgF4mnIhRxIglqKQAAQoCBgoSIkKDAgH+DIhdQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiF1ANAAsLIBpCAX0gGoMhGiAHIBd6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBRBGXYiCzoAACASIAlBCGsgBXFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBNrQQRrKAAANgAAIA9BAWsiDw0ACyABKAIMBUEACyIFNgI8IAYgCCAFazYCOCABIBFBBBD6KiAGQSRqEPUnDAELIAEgBkEgakHYyIUBEO4JC0GBgICAeCEFDAELEN0nIAYoAgQhCCAGKAIAIQULIA4gCDYCBCAOIAU2AgAgBkHgAGokAAsgASgCBCIGIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hGSAEKAIEIQggBCgCACEHIAEoAgAhBANAIAQgBWopAAAiGCAZhSIXQn+FIBdCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhFwJ/AkAgAAJ+AkADQCAXUA0BIAogAyABKAIAIBd6p0EDdiAFaiAGcSIJQQJ0a0EEaygCABD4EiAXQgF9IBeDIRcgByAIIAooAgAgCigCBBCfO0UNAAsgACACNwMIIAAgASgCAEEAIAlrQQJ0ajYCEEIADAELIBhCgIGChIiQoMCAf4MhFyAVRQRAIBdQDQIgF3qnQQN2IAVqIAZxIQ0LQQEgFyAYQgGGg1ANAhogACAEIA1qLAAAQQBOBH8gBCkDAEKAgYKEiJCgwIB/g3qnQQN2BSANCzYCECAAIAI3AwhCAQs3AwAgACABNgIUIApBEGokAA8LQQALIRUgBSAWQQhqIhZqIAZxIQUMAAsAC/MPAhB/BH4jAEHQEGsiBiQAIAZBARDlOiAGQRhqIQMjAEEgayIHJAACQAJAAkACQAJAQcAAQcAAENE0BEBBwABBwAAQrTYiBEUNASAHQgA3AgwgByAENgIIIAdBwAA2AgQgB0HAADYCACAEQf8BOgAAIAdBATYCDCAERQ0CIAQgBC0AAEEBcToAAEEAQcAAENE0RQ0DIAcoAgAhCCAHKAIEIQQgBygCCCESIAcoAgwhDEEcQQQQrTYiDUUNBSANIAQ2AhggDSAINgIUIA1BADYCECANIAw2AgwgDSASNgIIIA1CgYCAgBA3AgAgByAMNgIcIAcgEjYCGCAHIA02AhQgAyAHQRRqQQBBARDyFSAHQSBqJAAMBAsMAgtBwABBwAAQoz0AC0GQgogBELI7AAtB8/+HAUEpIAdBFGpB2P+HAUGcgIgBENUeAAsgA0EANgIUA0AgBkEwaiAJaiIEIAZBGGo2AgAgBEEEakEANgIAIAlBCGoiCUGAEEcNAAsgAigCCCIEBEAgAigCBCEJIARBHGwhAwNAIAZBMGogCS0AAEEDdGoiCEF/QQAgCUEYaigCACAJQRRqKAIARyIEGzYCBCAIIAlBBGogBiAEGzYCACAJQRxqIQkgA0EcayIDDQALCyABKAIgIQQCQAJAIAEoAiQEQCAGIAEoAixBAnYiCDYCtBAgBiAENgKwECAEIAhGDQEgBkEANgK4EEEAIAZBsBBqIAZBtBBqIAZBuBBqQcCGhgEQrysACyAGQTBqIQcjAEEwayIFJABBwAAhDgJAAkAgBCIIQQZ2IgwgBEE/cSIJQQBHaiIDQQN0IgRBwP///wNxQUBrIAQgA0EHcRsiD0HAABDRNARAIA8EQCAPQcAAEK02Ig5FDQILIAhBwABPBEAgDK0hFSABKAIcIQ1BACEEA0AgBCEDQgAhE0IAIRQDQCAHIAMgDWotAABBA3RqIhIoAgAiDCgCBCAMKAIMIBIoAgQgA3FqIgxBA3ZqLQAAIAxBB3F2QQFxrSAThiAUhCEUIANBAWohAyATQgF8IhNCwABSDQALIAogDmogFDcDACAEQUBrIQQgCkEIaiEKIBZCAXwiFiAVUg0ACwsgCQRAIAhBQHEhAyAJrSEVIAEoAhwhDEIAIRNCACEUA0AgByADIAxqLQAAQQN0aiIEKAIAIgEoAgQgASgCDCAEKAIEIANxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCADQQFqIQMgFSATQgF8IhNSDQALIAogDmogFDcAACAKQQhqIQoLIAUgDzYCLCAFQoCAgICACDcCJCAFIA42AhwgBSAIQQN2IAhBB3FBAEdqIgEgCiABIApJGyIENgIgIAVBCGogBUEcahDXOyAFKAIIIQFBHEEEEK02IgNFDQUgA0KBgICAEDcCACADIAUpAhw3AgggA0EQaiAFQSRqKQIANwIAIANBGGogBUEsaigCADYCACAFIAQ2AhggBSABNgIUIAUgAzYCECAAIAVBEGpBACAIEPIVIAVBMGokAAwCC0H09IQBQSkgBUEcakHQ9oQBQaD1hAEQ1R4AC0HAACAPEKM9AAsMAQsgBiABQSRqNgK8ECAGIAE2ArgQIAYgBkEwajYCwBAgBkG4EGohCkEAIQdBACEJIwBBMGsiCyQAQcAAIQ4CQAJAIARBBnYiAyAEQT9xIg1BAEdqIghBA3QiAUHA////A3FBQGsgASAIQQdxGyIPQcAAENE0BEAgDwRAIA9BwAAQrTYiDkUNAgsgBEHAAE8EQCADrSEVIAooAgghEiAKKAIEIQwgCigCACEDA0AgAygCHCAHaiERIAwoAgQgCWohBUIAIRNCACEUA0AgEiARLQAAQQN0aiIIKAIAIgEoAgQgASgCDCAIKAIEIAUoAgBxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCARQQFqIREgBUEEaiEFIBNCAXwiE0LAAFINAAsgDiAQaiAUNwMAIAdBQGshByAJQYACaiEJIBBBCGohECAWQgF8IhYgFVINAAsLIA0EQCAKKAIAKAIcIAStQgaIpyIBQQZ0aiERIAooAgQoAgQgAUEIdGohBSANrSEVIAooAgghA0IAIRNCACEUA0AgAyARLQAAQQN0aiIIKAIAIgEoAgQgASgCDCAIKAIEIAUoAgBxaiIBQQN2ai0AACABQQdxdkEBca0gE4YgFIQhFCARQQFqIREgBUEEaiEFIBUgE0IBfCITUg0ACyAOIBBqIBQ3AAAgEEEIaiEQCyALIA82AiwgC0KAgICAgAg3AiQgCyAONgIcIAsgBEEDdiAEQQdxQQBHaiIBIBAgASAQSRsiCDYCICALQQhqIAtBHGoQ1zsgCygCCCEBQRxBBBCtNiIDRQ0EIANCgYCAgBA3AgAgAyALKQIcNwIIIANBEGogC0EkaikCADcCACADQRhqIAtBLGooAgA2AgAgCyAINgIYIAsgATYCFCALIAM2AhAgACALQRBqQQAgBBDyFSALQTBqJAAMAgtB9PSEAUEpIAtBHGpB0PaEAUGg9YQBENUeAAtBwAAgDxCjPQALCyAGKAIYIgAgACgCACIAQQFrNgIAIABBAUYEQCAGQRhqEPseCyAGKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCAGEPseCyACENsmIAJBBEEcEOAeIAZB0BBqJAAPC0EEQRwQoz0AC48DAQp/IwBBEGsiBCQAAkAgAS0AJQ0AIAEtACRFBEAgAUEBOgAkIARBCGogARD8DSAEKAIIIgIEQCAEKAIMIgMNAgtBACECIAEtACVBAUYNAQsgASgCBCEHAn8CQCABKAIQIgIgASgCDCIDSQ0AIAIgASgCCCIISw0AIAFBE2ohCSABQRRqIQoDQCAEIAkgAS0AGGotAAAgAyAHaiACIANrEKMKAkACQCAEKAIAQQFxBEAgASgCDCIDIAQoAgRqIgIgAS0AGCIGQQFrIgVJDQIgAiAFayIFIAZqIgsgBUkgCCALSXINAiAGQQVPDQEgBSAHaiAGIAogBhDBLkUEQCABKAIMIQMMAwsgASAFNgIQIAEoAiAgASAFNgIgIAUgAS0AGGoiAWsMBQsgASABKAIMNgIQDAMLIAZBBEGAmMQAELA7AAsgASACNgIQIAIgCEsNASACIANPDQALCyABQQE6ACUgASgCICABKAIcIgFrCyEDIAEgB2ohAgsgACADNgIEIAAgAjYCACAEQRBqJAALhgQBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIALQAAQQFrDhABAgMEBQYHCAkKCwwNDg8QAAsgAUHdhs8AQQYQ+zUMEAsgAUHjhs8AQQMQ+zUMDwsgAUHmhs8AQQQQ+zUMDgsgAUHqhs8AQQQQ+zUMDQsgAiAAQQhqNgIMIAFBkIfPAEEHQZeHzwBBBSAAQQRqQfCGzwBBnIfPAEEJIAJBDGpBgIfPABCOGAwMCyABQaWHzwBBBBD7NQwLCyACIABBAWo2AgwgAUHMh88AQQRB0IfPAEEUIABBAmpBrIfPAEHkh88AQQQgAkEMakG8h88AEI4YDAoLIAIgAEEBajYCDCABQeiHzwBBCUHQh88AQRQgAEECakGsh88AQeSHzwBBBCACQQxqQbyHzwAQjhgMCQsgAiAAQQJqNgIMIAFBlIjPAEEHQZuIzwBBCSAAQQFqQfSHzwBBpIjPAEEJIAJBDGpBhIjPABCOGAwICyABQa2IzwBBBxD7NQwHCyABQbSIzwBBBBD7NQwGCyABQbiIzwBBBBD7NQwFCyABQbyIzwBBBBD7NQwECyABQcCIzwBBBxD7NQwDCyABQceIzwBBBxD7NQwCCyABQc6IzwBBCBD7NQwBCyABQdaIzwBBCRD7NQsgAkEQaiQAC9sRBBB/AXwEfQN+AkAgACgCDCIRBEAgACgCBCESIAAoAgAhEyABIQwgACgCmBYhCyAAKAIIIhRBBGoiASEPIBFBAWshECMAQZAYayIJJAACQAJAAkACQAJAAkACQAJAAkACQCACIgogAyAMIAQgCxC/C0UEQCAJQQBBgAj8CwAgC0UNASAMIQVB0A8gCyALQdAPTxsiAiEHA0AgAyAEIAVxIgZNBEAgBiADQbyd1gAQwyEACyAJIAYgCmotAABBAnRqIgYgBigCAEEBajYCACAFQQFqIQUgB0EBayIHDQALQQAhBQJAAkACQANAIAVBzw9LBEAgBSAMakHQD2sgBHEiByADTw0CIAkgByAKai0AAEECdGoiByAHKAIAQQFrNgIAIAJBAWshAgsgCyAFQdAPaiIGSwRAIAUgDGpB0A9qIARxIgcgA08NAyAJIAcgCmotAABBAnRqIgcgBygCAEEBajYCACACQQFqIQILIAUgDGogBHEiBSADTw0DIAkgBSAKai0AAEECdGooAgAiBUEBSyEHAn0gAkGAAk8EQCACsxDqEgwBCyACQQJ0QcCH8wBqKgIACyEWIAVBASAHGyEHAn0gBUGAAk8EQCAHsxDqEgwBCyAHQQJ0QcCH8wBqKgIACyEYIBAgBkHQD2siBUcEQCAPIBa7IBi7oUQZBFYOLbKdP6AiFUQAAAAAAADgP6JEAAAAAAAA4D+gIBUgFUQAAAAAAADwP2MbtjgCACAPQQRqIQ8gBUEBaiIFIAtGDQYMAQsLIBAgEEGsndYAEMMhAAsgByADQfyc1gAQwyEACyAHIANBjJ3WABDDIQALIAUgA0GcndYAEMMhAAsgCUEIakEANgIAIAlCADcDACALRQ0AA0ACfwJAIAMgBSAMaiAEcSICSwRAQQAgAiAKaiwAACICQQBODQIaIAJBv39NDQFBAQwCCyACIANBvJvWABDDIQALIAdB3wFLQQF0CyEGIAJB/wFxIQcgCSAGQQJ0aiICIAIoAgBBAWo2AgAgCyAFQQFqIgVHDQALIAkoAgQgCSgCCCAJQQBBgBj8CwAgCUGIGGpBADYCACAJQgA3A4AYQe8DIAsgC0HvA08bIQhqQRhLIQ4gDCECQQAhB0EAIQUDQCADIAIgBHEiDU0EQCANIANB7JzWABDDIQALIAchBiAJQYAYaiAFQQJ0aiIHIAcoAgBBAWo2AgAgCSAFQQp0aiAKIA1qLAAAIgVB/wFxIgdBAnRqIg0gDSgCAEEBajYCAAJ/QQAgBUEATg0AGiAOIAVBv39LDQAaIA4gBkHgAU9xCyEFIAJBAWohAiAIQQFrIggNAAtB0A8hB0EAIQUDQCAFQe8DTwRAQQAhAgJAIAVB7wNGDQAgBSAMaiINQfADayAEcSICIANPDQUgAiAKai0AACEGQQAhAkEAIQggBUHxA08EQCANQfEDayAEcSIIIANPDQcgDiAIIApqLQAAQeABT3EhCAsgBsBBAE4NACAOIAggBkG/AUsbIQILIAUgDGpB7wNrIARxIgYgA08NBiAJQYAYaiACQQJ0ciIIIAgoAgBBAWs2AgAgCSACQQp0aiAGIApqLQAAQQJ0aiICIAIoAgBBAWs2AgALAkACQAJAAkAgCyAFQe8DaksEQCAFIAxqIgJB7gNqIARxIgYgA08NASACQe0DaiAEcSIIIANPDQIgAkHvA2ohDQJ/QQAgBiAKaiwAACICQQBODQAaIA4gAkG/f0sNABogDiAIIApqLQAAQeABT3ELIQIgBCANcSIGIANPDQsgCUGAGGogAkECdHIiCCAIKAIAQQFqNgIAIAkgAkEKdGogBiAKai0AAEECdGoiAiACKAIAQQFqNgIACyAFDQJBACECDAMLIAYgA0H8m9YAEMMhAAsgCCADQYyc1gAQwyEACyAFIAxqIg1BAWsgBHEiAiADTw0IIAIgCmotAAAhBkEAIQJBACEIIAVBAUcEQCANQQJrIARxIgggA08NCiAOIAggCmotAABB4AFPcSEICyAGwEEATg0AIA4gCCAGQb8BSxshAgsgBSAMaiAEcSIGIANPDQkgCSACQQp0aiAGIApqLQAAQQJ0aigCACIGQQFLIQggBkEBIAgbIQgCfSAJQYAYaiACQQJ0cigCACICQYACTwRAIAKzEOoSDAELIAJBAnRBwIfzAGoqAgALuwJ9IAZBgAJPBEAgCLMQ6hIMAQsgCEECdEHAh/MAaioCAAu7oUQ6kst/SL+dP6AiFUQAAAAAAADgP6JEAAAAAAAA4D+gIBUgFUQAAAAAAADwP2MbIRUgBUHPD00EQCAHuEQAAAAAAECfwKNEZmZmZmZm1j+iRGZmZmZmZuY/oCAVoCEVCyAFIBBGDQIgDyAVtjgCACAHQQFrIQcgD0EEaiEPIAsgBUEBaiIFRw0ACwsgCUGQGGokAAwICyAQIBBB3JzWABDDIQALIAIgA0HMm9YAEMMhAAsgCCADQdyb1gAQwyEACyAGIANB7JvWABDDIQALIAYgA0GcnNYAEMMhAAsgAiADQayc1gAQwyEACyAIIANBvJzWABDDIQALIAYgA0HMnNYAEMMhAAtBACEEIBRBADYCAAJAIAsEQEEAIAtrIQNBASECA0AgAiARRg0CIAEgFyAZIAEqAgCSIhiSIhY4AgAgGCAWIBeTkyEZIAFBBGohASAWIRcgAyACQQFqIgJqQQFHDQALC0EsIQEDQCAAIAFqQRxrAn0gBEH1AU8EQCAEQQtqsxDqEgwBCyABQcCH8wBqKgIACzgCACABQQRqIQEgBEEBaiIEQcAFRw0ACwwCCyACIBFB/LbQABDDIQALQQFBAEHcttAAEK87AAsCQCAAKAKQFiIBBEAgAa0hGyASrSEcQQAhBANAAn0gGkLsAVoEQCAaQhR8tRDqEgwBCyAEQZCI8wBqKgIACyEXIBogHFENAiAEIBNqIBc4AgAgBEEEaiEEIBsgGkIBfCIaUg0ACwsgAEHsh/MAKgIAOAKUFg8LIBIgEkHsttAAEMMhAAuXAwEIfwJAAkAgA0G8BE0EQAJAIAIgACADQQJ0aigCACIHSwRAIANBAXQiBiAAKAL0ESIFTQ0BDAMLIAcgAkH4/fsAEMMhAAsgAEH8EWoiCCAHai0AACABIAdBAnRqLwEAQQh0ciELA0ACQAJAAkACQCADQZ4CTQRAIAAgBkECdGooAgAiBCACTw0BIAQgCGotAAAgASAEQQJ0ai8BAEEIdHIhBCAFIAZNBEAgBCEFIAYhBAwFCyAGQQFyIglBvQRPDQIgACAJQQJ0aigCACIFIAJPDQMgBSAIai0AACABIAVBAnRqLwEAQQh0ciIKIAQgBCAKSxshBSAGIAkgBCAKSRshBAwECyAGQb0EQYj++wAQwyEACyAEIAJBmP77ABDDIQALQb0EQb0EQaj++wAQwyEACyAFIAJBuP77ABDDIQALIAUgC08NAiAAIANBAnRqIAAgBEECdGooAgA2AgAgBCIDQQF0IgYgACgC9BEiBU0NAAsMAgsgA0G9BEHo/fsAEMMhAAsgAyEECyAAIARBAnRqIAc2AgALyAMCA38EfiMAQbABayICJAAgACgCBCgCECABQQF0ajIBACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAvIAwIDfwR+IwBBsAFrIgIkACAAKAIEKAIQIAFBAnRqNAIAIQUgACgCACIDKAIAIgQpAwAhBiACIAQpAwgiBzcDaCACIAY3A2AgAiAFQj+HIgg3A1ggAiAFNwNQIAJBADYCLCACQRBqIAUgCCAGIAcgAkEsahD2DAJAAkACQCACKAIsBEAgAkECNgKMASACQayQ/wA2AogBIAJCAjcClAEgAkGEDDYCrAEgAkGEDDYCpAEgAiACQaABajYCkAEgAiACQeAAajYCqAEgAiACQdAAajYCoAEgAkH4AGogAkGIAWoQmQ4gAkHEAGogAkGEAWooAgA2AgAgAkGIgICAeDYCdCACIAJB/ABqKQIANwI8IAIgAikCdDcCNCACQQE2AjAgAkEwakEEchCIEQwBCyACKQMQIgUgAikDGCIGIAMoAgQtAAAQ/yBFDQAgACgCCCABQQR0aiIAIAY3AwggACAFNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQbABaiQADwsgACADQYiL/wAQwyEAC8gDAgN/BH4jAEGwAWsiAiQAIAAoAgQoAhAgAUEDdGopAwAhBSAAKAIAIgMoAgAiBCkDACEGIAIgBCkDCCIHNwNoIAIgBjcDYCACIAVCP4ciCDcDWCACIAU3A1AgAkEANgIsIAJBEGogBSAIIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALtQMCA38BfiMAQdAAayIDJAACQAJAIAECfwJAAkACQAJAIAEtACxBAWsOAwIFAQALIAMgASgCBDYCLCADQZiXwwA2AjAgA0IBNwI8IANBOzYCTCADIANByABqNgI4IAMgA0EsajYCSCADQQE2AjQgA0EEaiADQTBqIgQQmQ4gBCABKAIAKAIAQQhqEN0gIAEoAgAoAgAoAhQiBCAEKAIAIgVBAWo2AgAgBUEASA0EIANBGGoiBSADQThqKAIANgIAIANBJGogA0EMaigCADYCACADIAMpAjAiBjcDECADIAMpAgQ3AhwgAUEYaiADQSBqKQMANwIAIAFBEGogBSkDADcCACABIAY3AgggAUEAOgAoIAEgBDYCIAsgA0EwaiABQQhqIgUgAhCxDiADKAIwRQ0BIABBCTYCAEEDDAILQezzwgAQ6CsACyADKQI8IQYgAygCOCECIAMoAjQhBCAFEKAlIARFDQIgACAGNwIMIAAgAjYCCCAAIAQ2AgQgAEEINgIAQQELOgAsIANB0ABqJAAPCwALIAMgAjYCMEGc4MIAQSsgA0EwakHY4MIAQfzzwgAQ1R4AC7YWAhZ/BH4jAEHQAGsiCyQAAkACQCABLQCsAUUNACABKAKkASIFKAIUIgdBCGogBygCCEECRkECdGotACFBFkYNACALQQxqIQogAiIHIANBBHRqIQ4jAEEwayIGJAAgBUEIaiIJKAIMQQhqIQwCQANAIA4gByIFRgRAIApBADYCAAwCCyAGQRBqIAwgDCgCAEECRkECdGoQiRkgBi0AEEENRgRAIAUoAgBFDQQCQAJAAkAgBUEIaigCAA4CAAECC0EAQQBB7InOABDDIQALQQFBAUH8ic4AEMMhAAsgBUEQaiEHIAVBBGooAgAiBC0AAUEIdEGA/gFxIAQtAAByQYD4AUsNAQsLIAVBEGohCCAFIQQDQAJAAkAgDiAIIgdHBEAgBkEQaiAMIAwoAgBBAkZBAnRqEIkZIAYtABBBDUcNAiAHKAIARQ0GAkACQCAHQQhqKAIADgIAAQMLQQBBAEHsic4AEMMhAAtBAUEBQfyJzgAQwyEACyAGIAUgCUMAAACAEJkKIAZBIGoiBSAEIAlDAAAAABCZCiAKQQE2AgAgCiAGKQIANwIEIApBDGogBkEIaikCADcCACAKQRRqIAUpAwA3AgAgCkEcaiAGQShqKQMANwIADAMLIAdBEGohCCAHQQRqKAIAIg8tAAFBCHRBgP4BcSAPLQAAckGA+AFLDQELIAcgBSAJIAUgBxCJDRshBSAHIAQgCSAHIAQQiQ0bIQQgB0EQaiEIDAALAAsgBkEwaiQAIAsoAgxBAUcNACALQThqIAtBGGopAgA3AwAgCyALKQIQNwMwIAtByABqIAtBKGopAgA3AwAgCyALKQIgNwNAIAEoAqQBQQhqIgUgC0EwaiIHIAFB8ABqIAUgBxCmESABKAKkAUEIaiIFIAtBQGsiByABQYQBaiAFIAcQpxEgCygCQCIFBEAgC0HMAGogCygCRCALKAJIIAUoAhARAQALIAsoAjAiBUUNACALQTxqIAsoAjQgCygCOCAFKAIQEQEACyADRSABKAKYAUGAgICAeEZyRQRAIAFBmAFqIQcgA0EEdCEEIAIhBQNAIAUoAgBFDQIgByAFKAIEIAUoAggQhgoQohUgBUEQaiEFIARBEGsiBA0ACwsCQCABKAJYQYCAgIB4RwRAIAFBEGoiBUHIAGogAxDsLSADBEAgA0EEdCEBA0AjAEEwayIMJAAgAigCAEUEQAwFCyAMQRhqIQcgBUEQaiIGIAIoAgQgAigCCBDNAiEbIAVBMGohA0EAIQhBACEOQQAhD0EAIRFBACESIwBBEGsiEyQAAkAgBSgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCADNgIcIAQgBjYCGCAFKAIMIQogBCAEQRhqNgIgAkACQAJAAkACQAJAIAogCkEBaiIGTQRAIAUoAgQiCiAKQQFqQQN2QQdsIApBCEkbIgpBAXYgBkkEQCAKQQFqIgggBiAGIAhJGyIIQQ9JDQIgCEH/////AU0EQEF/IAhBA3RBB25BAWtndkEBaiEIDAQLEN0nIAQoAhQhCCAEKAIQIgZBgYCAgHhHDQUMAwsgBSAEQSBqQcSkzwAQ6wkMAwsQ3ScgBCgCBCEIIAQoAgAhBgwDC0EEQQhBECAIQQhJGyAIQQRJGyEICyAEQdAAaiAFQRBqIglBCCAIEPsUIAQoAlghCCAEKAJUIQYgBCgCUCIKRQ0BIAQgBCgCXDYCTCAEIAg2AkggBCAGNgJEIAQgCjYCQCAEQQhqIARBQGsQwTQgBCgCDCIIBEAgBCgCCEH/ASAI/AsACyAEKAJIIQggBCgCRCEGIAQoAkAiCkUNASAEIAQoAkw2AjwgBCAINgI4IAQgBjYCNCAEIAo2AjAgBEKIgICAgAE3AiggBCAJNgIkIAQgBSgCDCIVBH8gCkEIaiEXIAUoAgAiFikDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA5BCGohDiAWQQhqIhYpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAiAiDSgCBCIQKAIIIhggBSgCACAaeqdBA3YgDmpBA3QiGWtBCGsoAgAiCU0NBCAQKAIEIAlBBHRqIgkoAgBFDQUgCiAGIA0oAgAgCSgCBCAJKAIIEM0CpyIQcSIJaikAAEKAgYKEiJCgwIB/gyIcUARAQQghDQNAIAkgDWohCSANQQhqIQ0gCiAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhxQDQALCyAaQgF9IBqDIRogCiAceqdBA3YgCWogBnEiCWosAABBAE4EQCAKKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgCSAKaiAQQRl2Ig06AAAgFyAJQQhrIAZxaiANOgAAIAogCUEDdGtBCGsgBSgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgBSgCDAVBAAsiBjYCPCAEIAggBms2AjggBSAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBgsgFCAINgIEIBQgBjYCACAEQeAAaiQADAILIAkgGEGUkM4AEMMhAAsMBwsLIAUoAgQiCCAbp3EhBCAbQhmIQv8Ag0KBgoSIkKDAgAF+IR0gAygCBCEOIAMoAgghCiAFKAIAIQYDQCAEIAZqKQAAIhwgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAAkAgBwJ+AkADQCAaUA0BIAIoAgBFDQwgCiAFKAIAQQAgGnqnQQN2IARqIAhxayINQQN0akEIaygCACIJTQ0DIA4gCUEEdGoiCSgCAEUNDCAaQgF9IBqDIRogAigCBCACKAIIIAkoAgQgCSgCCBCfO0UNAAsgByAbNwMIIAcgBSgCACANQQN0ajYCEEIADAELIBxCgIGChIiQoMCAf4MhGiARRQRAIBpQDQMgGnqnQQN2IARqIAhxIQ8LQQEgGiAcQgGGg1ANAxogByAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAHIBs3AwhCAQs3AwAgByAFNgIUIBNBEGokAAwECyAJIApBlJDOABDDIQALQQALIREgBCASQQhqIhJqIAhxIQQMAAsACyAMQQhqIQQCQCAHKAIAQQFGBEAgBykDCCEaIAcoAhAhCiAHKAIUIQcCfiMAQRBrIggkACACKAIAIgkEQCADIAMoAgwgAygCEGo2AgwgAygCCCEGIAggAkEMaiACKAIEIAIoAgggCSgCABEFACADKAIAIAZGBEAgA0GkkM4AEJ4oCyADKAIEIAZBBHRqIgkgCCkCADcCACAJQQhqIAhBCGopAgA3AgAgAyAGQQFqNgIIIAhBEGokACAGrQwBC0Gsh84AQSVB1IfOABCfKQALIRsgCiAHKAIAIgNqIggtAAAhBiAIIBqnQRl2Igg6AAAgAyAHKAIEIApBCGtxakEIaiAIOgAAIAQgBzYCDCAEIBo3AwAgByAHKAIMQQFqNgIMIAQgAyAKQQN0ayIDNgIIIAcgBygCCCAGQQFxazYCCCADQQhrIBs3AwAMAQsgBCAHQQhqIgMpAwA3AwAgBEEIaiADQQhqKQMANwMACyAMKAIQQQhrKQMAIRogDEEwaiQAIAUoAlAiAyAFKAJIRgRAIAVByABqQdSQzgAQsygLIAUoAkwgA0EDdGogGjcDACAFIANBAWo2AlAgAkEQaiECIAFBEGsiAQ0ACwsgAEEINgIADAELIAAgASgCaCACIAMgASgCbCgCDBEFAAsgC0HQAGokAA8LQeSHzgBBIEGEiM4AEMskAAuKHAILfwZ+IwBBkCtrIgYkACABKAIAIQwgBkEIaiAGQYgraiILQYAgELgpIAYoAgghDSAGKAIMIQ4jAEEQayIKJAAgCkEVQefzzQBBDBDNGiAKQQhqIg9BF0Hz880AQRIQzRogBkEQaiEHIwBB8CprIggkACMAQUBqIgUkACAIQQhqIgFBCGoiCUIANwJAIAlCgICAgIAINwIIIAlBADoAUCAJQvz//5+wATcCECAJQgA3AgAgCUEANgBZIAlCEDcCOCAJQoiAgIDQADcCMCAJQoaAgIDwATcCKCAJQgA3AiAgCUIWNwIYIAlCgICAgBA3AFEgCUHIAGpCADcCACAFQShqEP0nIAUpAyghECAFQQA2AjwgBUKAgICAwAA3AjQgBUEgaiAFQTRqIglBjIfOABCYISAFKQMgIREgBUEYahD+JyAFKQMYIRIgBUEQahD9JyAFKQMQIRMgBUEIahD9JyAFKQMIIRQgBUEANgI8IAVCgICAgMAANwI0IAUgCUGMh84AEJ0hIAUpAwAhFSABQgA3AvQpIAEgFDcC7CkgAUIANwPoASABQQA2AmggAUH8KWpCADcCACABQYQqakIANwIAIAFBjCpqQgA3AgAgAUEANgKcKiABQgA3ApQqIAEgFTcDwAEgAUIANwPwASABQfgBakIANwMAIAFCj4CAgIACNwOIAiABQoSAgICwATcDgAIgAUGQAmpBAEEw/AsAIAFBADoAwCogAUEAOwG+KiABQQA7AbgqIAFCj4CAgIACNwPIAiABQoSAgICwATcDwAIgAUEANgKgKiABIBA3A8gBIAFB0AJqQQBBgCD8CwAgAUEANgKkKiABIBE3A9ABIAFB0CJqQQBBgAf8CwAgASATNwPgASABIBI3A9gBIAFCADcDqCogAUECNgIAIAFCADcD0CkgAUHYKWpCADcDACABQeApakIANwMAIAFB6ClqQQA2AgAgAUEANgG6KiABQQA2ArQqIAFBADYCsCogBUFAayQAIAggDjYC5CogCCANNgLgKiAIIAQ2AugqIAhCATcDACAIIA8pAgA3A9gqIAggCikCADcD0CoCQAJAIAgtAMMqIgFFBEAgCEEQakEBIAwQoAwgCC0AwypBAXFFDQEMAgsgAQ0BCyAIQRBqQQJBFhCgDAsgByAIQfAq/AoAACAIQfAqaiQAIApBEGokACMAQRBrIgQkAAJAAkAgAwRAA0AgBEEIaiEFIwBBIGsiASQAIAEgAzYCDCABQQA2AhACQAJAAkACQAJAIAMEQCAHQQhqIQkDQCABQQA2AhQgASAHKALkKiIINgIYIAlBACABQQxqIAIgAyABQRBqIAFBGGogBygC4CogCCABQRRqIAcQzwkgASgCFCIIBEAgBygC6CoiDEUNBSAIIAcoAuQqIg1LDQYgDCAHKALgKiIMIAggDGoQvSYLRQRAIAcpA9AqIRAgB0EEOgDQKiAQQv8Bg0IEUg0DQfTuzQAQsjsACyABKAIMDQALCyAFQQQ6AAAgBSADNgIEDAELIAUgEDcCAAsgAUEgaiQADAILQdTuzQAQsjsACyAIIA1B5O7NABCwOwALAkACQAJAAkACQCAELQAIIgFBBEcEQAJAIAFBAWsOAwAEAgkLIAQtAAlBI0cNCAwECyAEKAIMIgFFBEBByPDNACEFDAgLIAEgA00NASABIANB0PDNABCvOwALIAQoAgwtAAhBI0YNAgwGCyABIAJqIQIgAyABayEDDAILIAQoAgwtAAhBI0cNBAsgBEEIahC5LgsgAw0ACwsgC0EEOgAADAELIAsgBSkCADcCAAsgBEEQaiQAAkACQCAGLQCIK0EERg0AIAYpA4grIhBC/wGDQgRRDQAgBiAQNwOIKyAAIAsQgSsMAQsgBkGAK2ohAiMAQRBrIgEkACABQQhqIAZBEGoiA0EBEJESAkACQAJAIAEtAAhBBEcEQCACIAEpAwg3AgAMAQsgAygC6CpFDQEgAkEEOgAACyABQRBqJAAMAQtBxO7NABCyOwALIAYtAIArQQRHBEAgBiAGKQOAKzcDiCsgACAGQYgrahCBKwwBCyAAQQg2AgALIwBBEGsiCCQAAkAgBkEQaiIAKALoKkUNACAIQQhqIgEgAEECEJESIAgtAAhBBEYNACABELkuCyMAQUBqIgIkACACQShqEP0nIABBCGoiAygCyAEhACADIAIoAig2AsgBIAMoAswBIQEgAyACKAIsNgLMASADQb4qaiIJIAAgARDgNSACQQA2AjwgAkKAgICAwAA3AjQgAkEgaiACQTRqQYyHzgAQnSEgAygCxAEhACADKALAASEBIAMgAikDIDcDwAEgAARAIAEgAEEEdEEEEPg6CyACQRhqEP0nIAMoAvApIQAgAigCGCEBIAMgAigCHDYC8CkgAygC7CkhBCADIAE2AuwpIAkgBCAAEOA1IwBB0AFrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADQegAaiIAKAIAQQFrDgoAAQIDBAUGBwgJCwsgAUEIahD+JyAAKAIIIQQgASgCCCEFIAAgASgCDDYCCCAAKAIEIAAgBTYCBCAEEIAxDAkLIAFBEGoQ/icgACgCCCEEIAEoAhAhBSAAIAEoAhQ2AgggACgCBCAAIAU2AgQgBBCAMQwICyABQRhqEP4nIAAoAgghBCABKAIYIQUgACABKAIcNgIIIAAoAgQgACAFNgIEIAQQgDEMBwsgAUEgahD+JyAAKAIIIQQgASgCICEFIAAgASgCJDYCCCAAKAIEIAAgBTYCBCAEEIAxDAYLIAFBADYChAEgAUKAgICAIDcCfCABQTBqIAFB/ABqQYyHzgAQqiEgACgCCCEEIAAoAgQhBSAAIAEpAzA3AgQgBARAIAUgBEEBdEECEPg6CyABQShqEP4nIAAoAhAhBCABKAIoIQUgACABKAIsNgIQIAAoAgwgACAFNgIMIAQQgDEMBQsgAUEANgKEASABQoCAgIAgNwJ8IAFBQGsgAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDQDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFBOGoQ/icgACgCECEEIAEoAjghBSAAIAEoAjw2AhAgACgCDCAAIAU2AgwgBBCAMQwECyABQQA2AoQBIAFCgICAgCA3AnwgAUHQAGogAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDUDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFByABqEP4nIAAoAhAhBCABKAJIIQUgACABKAJMNgIQIAAoAgwgACAFNgIMIAQQgDEMAwsgAUEANgKEASABQoCAgIAgNwJ8IAFB4ABqIAFB/ABqQYyHzgAQqiEgACgCDCEEIAAoAgghBSAAIAEpA2A3AwggBARAIAUgBEEBdEECEPg6CyABQdgAahD+JyAAKAIQIAAgASgCWDYCECAAKAIUIAAgASgCXDYCFBCAMQwCCyABQQA2AoQBIAFCgICAgCA3AnwgAUHwAGogAUH8AGpBjIfOABCqISAAKAIIIQQgACgCBCEFIAAgASkDcDcCBCAEBEAgBSAEQQF0QQIQ+DoLIAFB6ABqEP4nIAAoAhAhBCABKAJoIQUgACABKAJsNgIQIAAoAgwgACAFNgIMIAQQgDEMAQsjAEEQayIEJAAgBEEIahD+JyAAQQRqIgUoAgwhByAEKAIIIQogBSAEKAIMNgIMIAUoAgggBSAKNgIIIAcQgDEgBBD+JyAFKAIEIQcgBCgCACEKIAUgBCgCBDYCBCAFKAIAIAUgCjYCACAHEIAxIARBEGokAAsCfwJAAkACQAJAAkACQAJAAkAgACgCAA4KCQUFBQUEAwIBAAYLIAAoAggiBEUNBiAAKAIEIARBAXRBAhD4OgwGCyAAKAIMIgQEQCAAKAIIIARBAXRBAhD4OgsgACgCFCIERQ0HQRAMBgsgACgCCCIERQ0EIAAoAgQgBEEBdEECEPg6DAQLIAAoAggiBEUNAyAAKAIEIARBAXRBAhD4OgwDCyAAKAIIIgRFDQIgACgCBCAEQQF0QQIQ+DoMAgsgACgCCCIERQ0DQQQMAgsgACgCCCIERQ0AIAAoAgQgBEECdEEEEPg6CyAAKAIQIgRFDQFBDAsgAGooAgAgBEECdEEEEPg6CyAAQQA2AgAgAEEEaiABQfwAakHUAPwKAAAgAUHQAWokACACQQA2AjwgAkKAgICAwAA3AjQgAkEQaiACQTRqQYyHzgAQmCEgAygC1AEhACADKALQASEBIAMgAikDEDcD0AEgAARAIAEgAEECdEEEEPg6CyACQQhqEP4nIAMoAtgBIAMgAigCCDYC2AEgAygC3AEgAyACKAIMNgLcARCAMSACEP0nIAMoAuABIQAgAyACKAIANgLgASADKALkASEBIAMgAigCBDYC5AEgCSAAIAEQ4DUgAkFAayQAIAhBEGokACAGKAL0KiIABEAgBigC8CogAEEBEPg6CyAGLQDgKkEERwRAIAZB4CpqELkuCyAGQYABahDzEyAGKAKIKiIABEAgBigChCogAEEBEPg6CyAGKALcASIABEAgBigC2AEgAEEEdEEEEPg6CyAGKALkASIABEAgBigC4AEgAEEBEPg6CyAGKALsASIABEAgBigC6AEgAEECdEEEEPg6CyAGKAL0ASIABEAgBigC8AEgAEECdEEEEPg6CyAGKAL8ASIABEAgBigC+AEgAEEBEPg6CyAGLQDoKkEERwRAIAZB6CpqELkuCyAGQZAraiQAC6IDAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBC0F/IAJBBGoiBSACIAVLGyICQQdxBEAgACACNgIcIABBAzYCGCAAQbDk/gA2AhQgAEGAgICAeDYCECAAQgQ3AgggAEKEgICACDcCAAwBCwJAAkBBfyACQX8gBEEDdCAEQf////8BSxsiBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC6MDAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBC0F/IAJBBGoiBSACIAVLGyICQQNxBEAgACACNgIcIABBygA2AhggAEHm4/4ANgIUIABBgICAgHg2AhAgAEIENwIIIABChICAgAg3AgAMAQsCQAJAQX8gAkF/IARBAnQgBEH/////A0sbIgVqIgQgAiAESxsiBCABKAIETQRAIAEgASgCFCAFaiIGNgIUQYiAgIB4IQUgBiABKAIIKAIISw0BDAILIANBDGogAiAEEL8vIAMoAgwiBUGKgICAeEYNAQsgACADKQIQNwIEIABBHGogA0EoaikCADcCACAAQRRqIANBIGopAgA3AgAgAEEMaiADQRhqKQIANwIAIAAgBTYCAAwBCyAAIAQ2AgggACACNgIEIABBioCAgHg2AgALIANBMGokAAuiAwEEfyMAQTBrIgMkACADQQxqIAEgAhCTDiADKAIQIQQCQCADKAIMIgVBioCAgHhHBEAgACADKQIUNwIIIABBIGogA0EsaigCADYCACAAQRhqIANBJGopAgA3AgAgAEEQaiADQRxqKQIANwIAIAAgBDYCBCAAIAU2AgAMAQtBfyACQQRqIgUgAiAFSxsiAkEDcQRAIAAgAjYCHCAAQQM2AhggAEG85P4ANgIUIABBgICAgHg2AhAgAEIENwIIIABChICAgAg3AgAMAQsCQAJAQX8gAkF/IARBAnQgBEH/////A0sbIgVqIgQgAiAESxsiBCABKAIETQRAIAEgASgCFCAFaiIGNgIUQYiAgIB4IQUgBiABKAIIKAIISw0BDAILIANBDGogAiAEEL8vIAMoAgwiBUGKgICAeEYNAQsgACADKQIQNwIEIABBHGogA0EoaikCADcCACAAQRRqIANBIGopAgA3AgAgAEEMaiADQRhqKQIANwIAIAAgBTYCAAwBCyAAIAQ2AgggACACNgIEIABBioCAgHg2AgALIANBMGokAAvIAwMDfwR+AXwjAEGgAWsiAyQAIAEoAgghBCADIAEoAgwoAhAgAkEDdGorAwAiCjkDGCADQSBqIAogBCgCACsDAKIQoSQQowYgBCgCBCEFAkACQAJ+IAMoAiBBAXFFBEAgBCgCCCEBIANBzJH/ADYCaCADQgQ3AnQgA0GJDDYCnAEgA0H0CzYClAEgAyABNgKQASADQbsHNgKMASADIAU2AogBIANBzAE2AoQBIANBjJL/ADYCgAEgAyADQYABajYCcCADIANBGGo2ApgBIANBBDYCbCADQdgAaiADQegAahCZDiADQRBqIANB3ABqKAIANgIAIANBgoCAgHg2AlQgAyADKQJUNwMIIAMpAmAMAQsgA0EgaiADKQMwIgYgAykDOCIHIAMpA0AiCCADKQNIIgkgBS0AABDQDiADKAIgQZOAgIB4Rg0BIANBEGogA0EoaigCADYCACADIAMpAiA3AwggAykCLAshBiAAIAMpAwg3AgAgACAGNwIMIABBCGogA0EQaigCADYCAAwBCyAAQZOAgIB4NgIAIAEoAgAgAkEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMACyADQaABaiQAC4wDAgx/AX4jAEEgayIDJAAgASgCECIKrSACrX4iD0IgiFAEQCADQQRqIA+nIgtBA3YgC0EHcUEAR2oQ0h8CQCAKRQRAIAMoAhAhBiADKAIMIQcMAQsgASgCDCENIAEoAgQhDiADKAIQIQYgAygCDCEHA0ACQCACRQ0AIAghBCACIQkgDiAMIA1qIgVBA3ZqLQAAQQEgBUEHcXRxRQ0AA0AgBiAEQQN2IgVLBEAgBSAHaiIFIAUtAABBASAEQQdxdHI6AAAgBEEBaiEEIAlBAWsiCQ0BDAILCyAFIAZByPqHARDDIQALIAIgCGohCCAMQQFqIgwgCkcNAAsLIAMoAgQhCCADKAIIIQlBHEEEEK02IgQEQCAEIAk2AhggBCAINgIUIARBADYCECAEIAY2AgwgBCAHNgIIIARCgYCAgBA3AgAgAyAGNgIcIAMgBzYCGCADIAQ2AhQgACADQRRqQQAgCxDyFSAAIAEoAhQgAmw2AhQgA0EgaiQADwtBBEEcEKM9AAtBuPqHARCyOwALtAQBBn8jAEGAAWsiBCQAAkACQCABKQMAQgNRDQAgBEEMaiACQQUQyAogBCgCDEEBRgRAQQQgBBD5OiECIAEQ+C4gASACNgIIIAFCAzcDAAwBCyAEQShqIARBGGopAgA3AwAgBCAEKQIQNwMgIARB0ABqIANBCGooAgA2AgAgBCADKQIANwNIIARB8ABqIgIgBEHIAGoQ5xUgBEE0aiEDIAIoAgghBiACKAIEIQcCQAJAA0AgBSAGRg0BIAUgB2otAAAiCEEfSyAIQf8AR3EhCSAFQQFqIQUgCEEJRiAJcg0ACyADQQI6ABAgAkEMaiAHIAYgAigCACgCEBEBAAwBCyADQQA6ABAgAyACKQIANwIAIANBCGogAkEIaikCADcCAAsCQCAELQBEQQJGBEBBBSAEEPk6IQIgBCgCICIDRQ0BIARBLGogBCgCJCAEKAIoIAMoAhARAQAMAQsgBEHoAGogBEHEAGooAgA2AgAgBEHgAGogBEE8aikCADcDACAEIAQpAjQ3A1ggBEH4AGogBEEQaiICQQhqKQIANwMAIAQgAikCADcDcCMAQRBrIgIkACABIARB8ABqIARB2ABqEJIDQf8BcUECRgRAQdyowwBBFyACQQ9qQcCmwwBB9KjDABDVHgALIAJBEGokACAAIAFB2AH8CgAADAILIAEQ+C4gASACNgIIIAFCAzcDACAAIAFB2AH8CgAADAELIAAgAUHYAfwKAAAgAxDeOwsgBEGAAWokAAv2AgECfyMAQfAEayILJAACQCADIARGBEAgAEEANgIAIAlFIANBAktyIQEMAQsCQAJAIApBA00EQCAJRQ0BIARB5wdNBEBBAyEBIAAoAgBBAkYNBAsgBEEKIAprIAh0QQN2SQ0CIAMgBCAIQQFrdk8NAQwCC0F/IQpBfyEMIAkEQCAHIAggASACEIQgIQwLIAAoAgAEQCAGIAEgAhDuFSEKCyALIAUgBCACEIE7IgMgASAEIAIgBEH/D0sQ9AYiBUGIf00EQCALQfAAakGABCALIAIgAxD7JiEFCyACQQFqIQNBACEJA0AgAwRAQQEgASgCACICQQh0IgYgBG4iByAEIAZLGyAHIAIbQQJ0QfCO0QBqKAIAIAJsIAlqIQkgA0EBayEDIAFBBGohAQwBCwtBAyEBIAogDE8gBUEDdCAJQQh2aiICIAxPcQ0BIAIgCk8NAgsgAEEBNgIAQQIhAQwBC0EAIQEgAEEANgIACyALQfAEaiQAIAEL/gIBBn4gACkDCCICIAEpAwAiA4VC88rRy6eM2bL0AIUiBCAAKQMAIgZC4eSV89bs2bzsAIV8IgUgBEIQiYUiBCACQu3ekfOWzNy35ACFIgIgBkL1ys2D16zbt/MAhXwiBkIgiXwiByAEQhWJhUKAgICAgICAgAiFIgRCEIkgBCAFIAYgAkINiYUiAnwiBkIgiXwiBIUiBUIViSAFIAYgAkIRiYUiAiADIAeFfCIDQiCJfCIGhSIFQhCJIAUgBCADIAJCDYmFIgJ8IgNCIIlC/wGFfCIEhSIFQhWJIAUgAyACQhGJhSICIAZCgICAgICAgIAIhXwiA0IgiXwiBoUiBUIQiSAFIAMgAkINiYUiAiAEfCIDQiCJfCIEhSIFQhWJIAUgAyACQhGJhSICIAZ8IgNCIIl8IgaFIgVCEIkgBSACQg2JIAOFIgIgBHwiA0IgiXwiBIVCFYkgAkIRiSADhSICQg2JIAIgBnyFIgJCEYmFIAIgBHwiAkIgiYUgAoULxQMCA38EfiMAQbABayICJAAgACgCBCgCECABajAAACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAIgBUI/hyIINwNYIAIgBTcDUCACQQA2AiwgAkEQaiAFIAggBiAHIAJBLGoQ9gwCQAJAAkAgAigCLARAIAJBAjYCjAEgAkGskP8ANgKIASACQgI3ApQBIAJBhAw2AqwBIAJBhAw2AqQBIAIgAkGgAWo2ApABIAIgAkHgAGo2AqgBIAIgAkHQAGo2AqABIAJB+ABqIAJBiAFqEJkOIAJBxABqIAJBhAFqKAIANgIAIAJBiICAgHg2AnQgAiACQfwAaikCADcCPCACIAIpAnQ3AjQgAkEBNgIwIAJBMGpBBHIQiBEMAQsgAikDECIFIAIpAxgiBiADKAIELQAAEP8gRQ0AIAAoAgggAUEEdGoiACAGNwMIIAAgBTcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGwAWokAA8LIAAgA0GIi/8AEMMhAAubAwIPfwF+IwBB0ABrIgIkACACQQRqIAFBNGoQygYCQCABKAJMIgUEQCAFIAUoAgAiA0EBajYCACADQQBIDQEgASgCXCEIIAEoAlghCSABKAJUIQogASgCUCELIAEoAmAhBwsgASgCGCEGIAJBxABqIAFBDGoQygYgASgCHCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiwhDCABKAIoIQ0gASgCJCEOIAEoAiAhDyABKAIwIQQLIAJBEGoiECABELwVIAJBJGogAkHMAGooAgA2AgAgAiAGNgIoIAIgBDYCQCACIAw2AjwgAiANNgI4IAIgDjYCNCACIA82AjAgAiADNgIsIAIgAikCRDcCHCABKAJAIgMgAygCACIGQQFqNgIAIAZBAEgNACAAIAIpAgQ3AjQgACAHNgJgIAAgCDYCXCAAIAk2AlggACAKNgJUIAAgCzYCUCAAIAU2AkwgAEE8aiACQQxqKAIANgIAIAEpAkQhESAAIBBBNPwKAAAgACARNwJEIAAgAzYCQCACQdAAaiQADwsAC78DAQZ/IwBBMGsiAiQAIAIgACgCBCIDQYCU69wDayADIANB/5Pr3ANLIgUbIgM2AgggACgCACIEQTxuIgZBPHAhB0EBIQACQCABIARBkBxuELUoDQAgAUE6EIM2DQAgASAHELUoDQAgAUE6EIM2DQAgASAEIAZBPGxrIAVqELUoDQAgA0UEQEEAIQAMAQsgAyADQcCEPW4iAEHAhD1sRgRAIAJBATYCJCACQdjFhgE2AiAgAkEBNgIUIAJBtMWGATYCECACQQE2AhwgAkE7NgIsIAIgADYCDCACIAJBKGo2AhggAiACQQxqNgIoIAEgAkEQahDROSEADAELIAMgA0HoB24iAEHoB2xGBEAgAkEBNgIkIAJB8MWGATYCICACQQE2AhQgAkG0xYYBNgIQIAJBATYCHCACQTs2AiwgAiAANgIMIAIgAkEoajYCGCACIAJBDGo2AiggASACQRBqENE5IQAMAQsgAkEBNgIkIAJBiMaGATYCICACQQE2AhQgAkG0xYYBNgIQIAJBATYCHCACQTs2AiwgAiACQShqNgIYIAIgAkEIajYCKCABIAJBEGoQ0TkhAAsgAkEwaiQAIAALsgMCBX8CfiMAQTBrIgQkAAJAAkACQAJAAkACQCABKQMAIglQBEAgAEEEOgAADAELIAMoAgQiBSADKAIIIgZJDQEgBEIANwIIIAQgAygCACAGaiIINgIAIAQgCDYCECAEQv////8PIAkgCUL/////D1obpyIHIAUgBmsiBSAFIAdLGzYCBCAEQRhqIAEoAggoAgAgAiAEEM0SIAQtABhBBUYEQCAAQQU6AAAMAQsgBCkDGCIKQv8Bg0IEUgRAIAAgCjcCAAwBCyAEKAIIIgcgBCgCBCICSw0CIAQgBCgCACICNgIUIAIgCEcNAyAGIAdqIgIgAygCDCIFSwRAIAMgAjYCDCACIQULIAIgBkkNBCACIAVLDQUgAyACNgIIIABBBDoAACABIAkgB619NwMACyAEQTBqJAAPCyAGIAVBpKHDABCvOwALIAcgAkG0ocMAELA7AAsgBEEANgIYIARBFGogBEEQaiAEQRhqQYijwwAQ9SoAC0HEocMAQQ9BmKPDABDLJAALIARBADYCKCAEQQE2AhwgBEGcocMANgIYIARCBDcCICAEQRhqQZijwwAQ7ywAC7kDAQt/AkACQAJAAkACQAJAIAcoAogQQQBOBEAgBygCsBAiDiAHKALsD3EiCCABKAIAIg8gBygCrBAiECAHKALoDyILbCAHKALYDyINIAsgCyANSiIRG2ogDmsiCSAJIA9LIhIbIglqIgogCEkNAiAKIAcoAtwOIgxLDQMgBygC2A4gCGohCiAEKAIAIgwgCWohCAJAIAJFDQAgCCAMSQ0FIAMgCEkNBiAJRQ0AIAIgDGogCiAJ/AoAAAsgBCAINgIAIAEgDyAJazYCACAHIAkgDmoiATYCsBAgBSABNgIAQQEgBygC4BB0IQECQCASRQRAIBENCCABIAtGDQEMCAsgBiABIAtGcg0CIAAgCTYCCCAAIAo2AgQgAEEBNgIADwsgByALIA1HOgCREyAHIBBBAWo2AqwQIAcgDSALazYC2A8MBgsgAEEANgIIIABC9////x83AgAPCyAAQQA2AgggAEKDgICAEDcCAA8LIAggCkH0pfMAELE7AAsgCiAMQfSl8wAQsDsACyAMIAhBhKbzABCxOwALIAggA0GEpvMAELA7AAsgACAJNgIIIAAgCjYCBCAAQQE2AgALrgMBBX8jAEEwayIDJAACQAJAAkACQAJAAkACQCACQQNxBEAgAyACNgIoIANBAzYCJCADQbbk/gA2AiAgA0KAgICAgICAgIB/NwIYIANCgICAgMAANwIQQYSAgIB4IQUMAQtBfyACQQRqIgQgAiAESxsiBSABKAIEIgRNBEAgASABKAIUQQRqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAUQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAMAQsgAiAETw0BIAJBAXIiBSAETw0CIAJBAnIiBiAETw0DIAJBA3IiByAETw0EIAAgASgCACIBIAVqLQAAQQh0IAEgAmotAAByIAEgBmotAABBEHRyIAEgB2otAABBGHRyNgIEQYqAgIB4IQULIAAgBTYCACADQTBqJAAPCyACIARB8OH+ABDDIQALIAUgBEGA4v4AEMMhAAsgBiAEQZDi/gAQwyEACyAHIARBoOL+ABDDIQALrgMBBX8jAEEwayIDJAACQAJAAkACQAJAAkACQCACQQNxBEAgAyACNgIoIANBAzYCJCADQcb2/gA2AiAgA0KAgICAgICAgIB/NwIYIANCgICAgMAANwIQQYSAgIB4IQUMAQtBfyACQQRqIgQgAiAESxsiBSABKAIEIgRNBEAgASABKAIUQQRqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAUQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAMAQsgAiAETw0BIAJBAXIiBSAETw0CIAJBAnIiBiAETw0DIAJBA3IiByAETw0EIAAgASgCACIBIAVqLQAAQQh0IAEgAmotAAByIAEgBmotAABBEHRyIAEgB2otAABBGHRyNgIEQYqAgIB4IQULIAAgBTYCACADQTBqJAAPCyACIARBhPX+ABDDIQALIAUgBEGU9f4AEMMhAAsgBiAEQaT1/gAQwyEACyAHIARBtPX+ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQJ0ajUCACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQN0aikDACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALwwMCA38DfiMAQbABayICJAAgACgCBCgCECABQQF0ajMBACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALmwMBBX8jAEEgayIDJAAgA0EUaiACQQBBBEEEEKAYIAMoAhghBgJAIAMoAhRBAUcEQCADKAIcIQQgAkECdCIFBEAgBCABIAX8CgAACyADIAI2AhwgAyAENgIYIAMgBjYCFCACRQ0BIAQgBWpBBGsiAUUNASABKAIADQEgAkECdCEBIARBBGshBSACQf////8DcSEEAkADQCABRQRAQQAhAQwCCyAEQQFrIQQgASAFaiABQQRrIQEoAgBFDQALIARBAWoiASACSw0CCyADIAE2AhwgASECDAELIAYgAygCHEH8iYgBEP0vAAsCQCACIAZBAnZPDQAgAyADQRRqIAJBBEEEEPQUIAMoAgAiAUGBgICAeEYNACABIAMoAgRBzI2IARD9LwALIANBEGoiASADQRxqKAIAIgI2AgAgAyADKQIUNwMIAkAgAgRAIAAgAykDCDcCACAAQQI6AAwgAEEIaiABKAIANgIADAELIABBCGpBlIqIASkCADcCACAAQYyKiAEpAgA3AgAgA0EIakEEQQQQ4B4LIANBIGokAAuIAwEHfyMAQRBrIgQkAAJAAkACQAJAIAEoAgQiAgRAIAEoAgAhBiACQQNxIQUCQCACQQRJBEBBACECDAELIAZBHGohAyACQXxxIQhBACECA0AgAygCACADQQhrKAIAIANBEGsoAgAgA0EYaygCACACampqaiECIANBIGohAyAIIAdBBGoiB0cNAAsLIAUEQCAHQQN0IAZqQQRqIQMDQCADKAIAIAJqIQIgA0EIaiEDIAVBAWsiBQ0ACwsgASgCDEUNAiACQQ9LDQEgBigCBA0BDAMLQQAhAiABKAIMRQ0CCyACQQAgAkEAShtBAXQhAgtBACEDIAJBAE4EQCACRQ0BQQEhAyACQQEQrTYiBQ0CCyADIAJBuMGJARD9LwALQQEhBUEAIQILIARBADYCCCAEIAU2AgQgBCACNgIAIARB9MCJASABEMsKRQRAIAAgBCkCADcCACAAQQhqIARBCGooAgA2AgAgBEEQaiQADwtBmMKJAUHWACAEQQ9qQYjCiQFB8MKJARDVHgALrwMCBX8CfiMAQTBrIgQkAAJAAkACQAJAAkACQCABKQMAIglQBEAgAEEEOgAADAELIAMoAgQiBSADKAIIIgZJDQEgBEIANwIIIAQgAygCACAGaiIINgIAIAQgCDYCECAEQv////8PIAkgCUL/////D1obpyIHIAUgBmsiBSAFIAdLGzYCBCAEQRhqIAEoAgggAiAEEM0SIAQtABhBBUYEQCAAQQU6AAAMAQsgBCkDGCIKQv8Bg0IEUgRAIAAgCjcCAAwBCyAEKAIIIgcgBCgCBCICSw0CIAQgBCgCACICNgIUIAIgCEcNAyAGIAdqIgIgAygCDCIFSwRAIAMgAjYCDCACIQULIAIgBkkNBCACIAVLDQUgAyACNgIIIABBBDoAACABIAkgB619NwMACyAEQTBqJAAPCyAGIAVBpKHDABCvOwALIAcgAkG0ocMAELA7AAsgBEEANgIYIARBFGogBEEQaiAEQRhqQYijwwAQ9SoAC0HEocMAQQ9BmKPDABDLJAALIARBADYCKCAEQQE2AhwgBEGcocMANgIYIARCBDcCICAEQRhqQZijwwAQ7ywAC40DAQJ/IAQgACgABCIFa0GBgICAek8EQCABIAEoAgg2AhAgACAAKAIUQQFqNgIUIAAgA0EBIAIoAgR0IgZBASACKAIIIAIoAhxBBUtrdCIEIAQgBkkbIAMgBWsiAyAEQQFrcSIFakECIAQgBEECTRtBACAFQQJJG2oiBGs2AgQgACADIARrIgMgACgCCGo2AgggAEECIAAoAhAiBCADayAEIANBAmoiBUkbNgIQIABBAiAAKAIMIgQgA2sgBCAFSRs2AgwgACgCXEEBIAIoAgx0IAMQgjsgAigCHCEEAkACQCAAKAJsDQAgBEEBRg0BIARBA2tBAksNACACKAKEAUEBRg0BC0EBIAIoAgh0IQIgACgCZCEFIARBBkYEQCAFIAIgA0EBELQbDAELIAUgAiADEII7CyAAKAIgIgIEQCAAKAJgQQEgAnQgAxCCOwsgASgCDCICIAEoAhBLBEAgASACNgIQCyAAQQA2ArQBIABBADYCGCAAIAAoAhwiACADayIBQQAgACABTxs2AhwLC7gDAgJ/An4jAEGQAWsiAiQAAkACQAJAIAAoAgQoAhAgAUEEdGoiAykDCCADKQMAIgRCgICAgICAgICAf30gBFStfFBFDQAgAiAAKAIAIgMoAgAoAgApAwAiBTcDSCACIAQ3A0AgAkEQaiAEIARCP4cgBSAFQj+HEKgeIAIpAxggAikDECIEQj+HUgRAIAJBAjYCbCACQayQ/wA2AmggAkICNwJ0IAJBhgw2AowBIAJBhgw2AoQBIAIgAkGAAWo2AnAgAiACQcgAajYCiAEgAiACQUBrNgKAASACQdgAaiACQegAahCZDiACQTRqIAJB3ABqKQIANwIAIAJBPGogAkHkAGooAgA2AgAgAkGIgICAeDYCVCACIAIpAlQ3AiwgAkEBNgIoIAJBKGpBBHIQiBEMAQsgBCADKAIELQAAEMUpRQ0AIAAoAgggAUEDdGogBDcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGQAWokAA8LIAAgA0GIi/8AEMMhAAvlCQIVfwF9IwBBIGsiByQAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAmggAS0ACmo2AmgMAwsgACAAKAJoIAEoAghqNgJoDAILIAEtAAEhBCABLQACIQEjAEEgayIFJAAgACABOgB5IAAgBDoAeCAAIAAoAmxBAWoiATYCbAJAAkACQCAAKAJkIgQgAUEDdEEHcksNACAAKAJgIQYgBUEIaiIBIARBAXQQoxUgBSABQcyCzgAQmCEgBCAFKAIEIgJLDQEgBSgCACEIIAQEQEEAIQEDQCABIAhqIAEgBmoqAgA4AgAgAUEEaiEBIARBAWsiBA0ACyAAKAJkIQEgACACNgJkIAAoAmAgACAINgJgIAFFDQEgAUECdEEEEPg6DAELIAAgAjYCZCAAIAg2AmALIAVBIGokAAwBCyAFQQA2AhggBUEBNgIMIAVB4NLMADYCCCAFQgQ3AhAgBUEIakGk0swAEO8sAAsMAQsgB0IANwMQQQchCQNAIAwgACgCaCIFSQRAIAdBEGogCWogACAFIAlqQQhrQbTSzAAQqSgtAAA6AAALIAxBAWohDCAJQQFrIglBf0cNAAsgASgCCCIFBEAgASgCBCEJQQAhDCAFIQEDQCAHQRBqIgggDEEGakEHcXItAAAhBiAAKAIcIgQoAgQhAyAHQQhqIAggDEEBa0EHcSICci0AACAGIAQoAgAgAyAEKAIQBH8gBCgCDC0AAAVBAAsgAC0AeBC1GyAHLQAMGiAHKAIIIQQgByAHKQMQNwMYIAktAAAhCCMAQRBrIgYkACAGIAdBGGoiAyACai0AADoACCAGIAMgAkEBakEHcWotAAA6AA8gBiADIAJBAmpBB3FqLQAAOgAOIAYgAyACQQNqQQdxai0AADoADSAGIAMgAkEEc2otAAA6AAwgBiADIAJBBWpBB3FqLQAAOgALIAYgAyACQQZqQQdxai0AADoACiAGIAMgAkEBa0EHcWotAAA6AAkgBkEIaiESIwBBIGsiAyQAIAAoAmQiDiAAKAJsIg1BA3QiE2siAkEAIAIgDk0bIRQgAEEkaiEKIAhB8AFxQQR2IQ8gACgCYCIQIA1BBXRqIQsgAC8BdiERIAAvAXQhFUEAIQICQAJAA0AgA0EQaiAKQQRrKAIAIAooAgAgAiASai0AACAEQQAgAxDvFSADIAMpAxA3AhggA0EYaiIWIA8Q+hYhFyACIBRGDQEgCyAXIAsqAgCSOAIAIBYgDyAVIBEQuBYgCkEIaiEKIAtBBGohCyACQQFqIgJBCEcNAAsgAEEkaiEKIAhBD3EhCCAQIA1BBXRqIQsgAC8BciENIAAvAXAhEEEAIQICQANAIANBCGogCkEEaygCACAKKAIAIAIgEmotAAAgBEEBIA8Q7xUgAyADKQMINwIYIANBGGoiESAIEPoWIRcgAiAURg0BIAsgFyALKgIAkjgCACARIAggECANELgWIApBCGohCiALQQRqIQsgAkEBaiICQQhHDQALIANBIGokAAwCCyACIBNqIA5B/NTMABDDIQALIAIgE2ogDkGM1cwAEMMhAAsgBkEQaiQAIAdBEGogDGogCS0AADoAACAMQQFqQQdxIQwgCUEBaiEJIAFBAWsiAQ0ACwsgACAAKAJoIAVqNgJoCyAHQSBqJAALwAMCA38DfiMAQbABayICJAAgACgCBCgCECABajEAACEFIAAoAgAiAygCACIEKQMAIQYgAiAEKQMIIgc3A2ggAiAGNwNgIAJCADcDWCACIAU3A1AgAkEANgIsIAJBEGogBUIAIAYgByACQSxqEPYMAkACQAJAIAIoAiwEQCACQQI2AowBIAJBrJD/ADYCiAEgAkICNwKUASACQYQMNgKsASACQYQMNgKkASACIAJBoAFqNgKQASACIAJB4ABqNgKoASACIAJB0ABqNgKgASACQfgAaiACQYgBahCZDiACQcQAaiACQYQBaigCADYCACACQYiAgIB4NgJ0IAIgAkH8AGopAgA3AjwgAiACKQJ0NwI0IAJBATYCMCACQTBqQQRyEIgRDAELIAIpAxAiBSACKQMYIgYgAygCBC0AABD/IEUNACAAKAIIIAFBBHRqIgAgBjcDCCAAIAU3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBsAFqJAAPCyAAIANBiIv/ABDDIQALnwMBDn8jAEEQayIDJAAgASgCECENIAEoAgwiBCAEKAIAIgJBAWo2AgACQAJAIAJBAEgNACADIAQ2AgAgBCgCCCIIIAgoAgAiAkEBajYCACACQQBIDQAgASgCBCEFIAQoAgwhDiADQQRqIAEoAggiCUEAQQRBCBCgGCADKAIIIQIgAygCBEEBRg0BIAMoAgwhCgJAIAJFDQAgCUEDdCEHIAohBiACIQsDQCAHRQ0BIAUoAgAiDCAMKAIAIg9BAWo2AgAgD0EASA0CIAZBBGogBSgCBDYCACAGIAw2AgAgBkEIaiEGIAdBCGshByAFQQhqIQUgC0EBayILDQALCyAAQQA2AhwgACAONgIUIAAgCDYCECAAQSA6AAwgACANNgIYIAAgCTYCCCAAIAo2AgQgACACNgIAIAQgBCgCACIAQQFrNgIAIABBAUYEQCADEPgjCyABQQxqIgAoAgAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAAQ+CMLIAEQwycgAUEEQQgQ4B4gA0EQaiQADwsACyACIAMoAgxBlO6FARD9LwALhQMBCn8jAEEQayIDJAACQAJAAkAgASgCCCIEBEAgASgCBCEJIARBA3QhBQNAIAYgCWoiCygCACAIaiIIIAJLDQIgB0EBaiEHIAUgBkEIaiIGRw0ACwsgACABKQIANwIAIAFCgICAgMAANwIAIABBCGogAUEIaiIAKAIANgIAIABBADYCAAwBCyADQQRqIAQgB2siDEEAQQRBCBCgGCADKAIIIQogAygCBEEBRg0BIAMoAgwhBSABIAc2AgggBEEDdCAGayIEBEAgBSALIAT8CgAACyADIAw2AgwgAyAFNgIIIAMgCjYCBCAFKAIAIgQgCCACayICRwRAIAUtAAQhCCAHIAEoAgBGBH8gAUGMgc0AEJsoIAEoAgQFIAkLIAZqIgYgBCACazYCACAGQQRqIAg6AAAgASAHQQFqNgIICyAFIAI2AgAgA0EEaiABQQMQ+iogAEEIaiADQQxqKAIANgIAIAAgAykCBDcCAAsgA0EQaiQADwsgCiADKAIMQfyAzQAQ/S8AC50DAQN/IwBBMGsiByQAAkAgAyAETwRAIARFBEAgACABIAIgAxCUHQwCCyAHIAMgBGsiCDYCACAHQQhqIAEgAiADEJQdIAcoAgwhASAHKAIIIgRBCEcEQCAAIAcpAxA3AwggAEEQaiAHQRhqKQMANwMAIAAgATYCBCAAIAQ2AgAMAgsgByABNgIEIAEgCEYEQCADQQFrIQQDQAJAAkAgBiAEQQN2IgFLBEAgBEEHcUH8xM4Aai0AACABIAVqLQAAcUUNAiAIQQFrIgggA08NASACIARqIgEtAAAhCSABIAIgCGoiAS0AADoAACABIAk6AAAMAgsgASAGQcSIzQAQwyEACyAIIANBpKDNABDDIQALIARBAWsiBEF/Rw0ACyAAQQg2AgAgACADNgIEDAILIAdBAjYCDCAHQeigzQA2AgggB0ICNwIUIAdBOzYCLCAHQTs2AiQgByAHQSBqNgIQIAcgBzYCKCAHIAdBBGo2AiAgAEEEaiAHQQhqEJkOIABBADYCAAwBC0Hon80AQSxBlKDNABCfKQALIAdBMGokAAuBAwEFfyACKAIgIgcEQCADQv8BViADQv+BBFZqIANC/v///w9WaiEGC0G6fyEFAkAgAUESSQ0AQQAgBEEARyAEQf8BS2ogBEH//wNLaiACKAIoGyIIIAIoAiRBAEpBAnRqQSBBACAHQQBHIANBASACKAIEIgl0rVhxIgcbciAGQQZ0ciEFQQAhASACKAIARQRAIABBqOq+aTYAAEEEIQELIAAgAWogBToAACABQQFyIQUgB0UEQCAAIAVqIAlBA3RB0ABrOgAAIAFBAnIhBQsCQAJAAkACQCAIQQFrDgMAAQIDCyAAIAVqIAQ6AAAgBUEBaiEFDAILIAAgBWogBDsAACAFQQJqIQUMAQsgACAFaiAENgAAIAVBBGohBQsCQAJAAkACQCAGQQFrDgMBAgMACyAHRQ0DIAAgBWogAzwAACAFQQFqDwsgACAFaiADp0GAAms7AAAgBUECag8LIAAgBWogAz4AACAFQQRqDwsgACAFaiADNwAAIAVBCGohBQsgBQupAwELfyMAQRBrIgUkACAAIAEoAtAQIAEoAtQQIAFBuAFqIAFBkBtqIAEoArgSEKwJIgJBiH9NBEAgASgCuBIhAiABKALUECEGIAAoAhQhCCAAKAIQIQkgACgCGCEKIAAoAgAhAyAAKAIEIAEoApAbIQcgACgCDCAAKAIIIQQgBUH/ATYCDCAEayEAIANrQQN1IQMCQAJAAkACQCAHDgQDAAEBAgtBASEADAILIAIgBUEMaiAEIAAgAkHYxQAQ4CVBiH9LDQEgBiACIAUoAgwQ5SMhBCAHQQJGBEAgASgClBwgBGohBAsgAEH//wBLQQRBAyAAQf8HSxtqIAQgBEEGaiAAQYACSRtqIQAMAQtBACEACyABKAKcHCAKIANBHyAGQYgIakEAQZD40ABBBSACELcWQQRBAyADQf/9AUsbQQNBAiADQf8ASxtqIABqaiABKAKYHCAJIANBIyAGQbgZakHA+dAAQcD30ABBBiACELcWaiABKAKgHCAIIANBNCAGQYwOakHw+dAAQdD40ABBBiACELcWaiABKAKsHWohAgsgBUEQaiQAIAILiQMBA38CQAJAIABBBk8EQCAAQYIBTwRAIABBwhBPBEAgAEHCME8EQCABKAIEIQIgAEHCsAFPBEAgAgRAIAEoAgAiAyAAQQh0QemD4QJrNgIADAcLQQBBAEHI/9EAEMMhAAsgAgRAIAEoAgAiAyAAQQh0QeqD4QBrNgIADAYLQQBBAEHY/9EAEMMhAAsgASgCBCICBEAgASgCACIDIABBCHRB64MhazYCAAwFC0EAQQBB6P/RABDDIQALIAEoAgQiAgRAIAEoAgAiAyAAQcIAayIAZ0EgakE/cyIEQX8gBHQgAGpBCHRyQQpqNgIADAQLQQBBAEH4/9EAEMMhAAsgASgCBCICRQ0BIAEoAgAiAyAAQQJrIgAgACAAZ0EgakE/c0EBayIAdiIEIAB0a0EIdCAEIABBAXRqQQJqcjYCAAwCCyABKAIEIgIEQCABKAIAIgMgADYCAAwCC0EAQQBBmIDSABDDIQALQQBBAEGIgNIAEMMhAAsgASACQQFrNgIEIAEgA0EEajYCAAuwAwEEfyMAQUBqIgIkAAJAAkACQAJAAkACQCABKAIkBEAgAkEYaiABENw7IAIoAhxFDQEgAkEsaiACKAIYIAEQrxIgAkEoaiIDIAJBNGooAgA2AgAgAiACKQIsNwMgIAIoAjghBCACKAI8IQUgAkEQaiABEO88IAIoAhRFDQIgAEEMaiACKAIQIAQgBRDWCCAAQQhqIAMoAgA2AgAgACACKQMgNwIADAYLQQBBwAAQ0TRFDQMgAkEANgI8IAJCgICAgIAINwI0IAJCwAA3AiwgAkEIaiACQSxqENc7IAIoAgghBEEcQQQQrTYiA0UNBCADQoGAgIAQNwIAIAMgAikCLDcCCCADQRBqIAJBNGopAgA3AgAgA0EYaiACQTxqKAIANgIAIAIgARDvPCACKAIERQ0CIABBDGogAigCAEEAQQAQ1gggAEEANgIIIAAgBDYCBCAAIAM2AgAMBQtBAEEAQeDR/gAQwyEAC0EAQQBB8NH+ABDDIQALQQBBAEGA0v4AEMMhAAtBgMj+AEEpIAJBLGpB/Mj+AEGsyP4AENUeAAtBBEEcEKM9AAsgAkFAayQAC8UDAwN/BH4BfSMAQZABayIDJAAgASgCCCEEIAMgASgCDCgCECACQQJ0aioCACIKOAIMIANBEGogBCgCACsDACAKu6IQoSQQowYgBCgCBCEFAkACQAJ+IAMoAhBBAXFFBEAgBCgCCCEBIANBzJH/ADYCWCADQgQ3AmQgA0GFDDYCjAEgA0H0CzYChAEgAyABNgKAASADQbsHNgJ8IAMgBTYCeCADQcwBNgJ0IANBjJL/ADYCcCADIANB8ABqNgJgIAMgA0EMajYCiAEgA0EENgJcIANByABqIANB2ABqEJkOIANBCGogA0HMAGooAgA2AgAgA0GCgICAeDYCRCADIAMpAkQ3AwAgAykCUAwBCyADQRBqIAMpAyAiBiADKQMoIgcgAykDMCIIIAMpAzgiCSAFLQAAENAOIAMoAhBBk4CAgHhGDQEgA0EIaiADQRhqKAIANgIAIAMgAykCEDcDACADKQIcCyEGIAAgAykDADcCACAAIAY3AgwgAEEIaiADQQhqKAIANgIADAELIABBk4CAgHg2AgAgASgCACACQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwALIANBkAFqJAALowMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQJ0aigCACEDIAIgACgCACIFKAIAKAIAIgQ2AiAgAiADNgIcAkACQAJAAkACQCAEBEAgA0GAgICAeEYgBEF/RnFFBEAgAyAEbSEDDAMLIAJBAjYCPCACQZiQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMMAgsgAkGHgICAeDYCCAsgAkEIahCIEQwBCyADIAUoAgQtAAAQxClFDQAgACgCCCABQQJ0aiADNgIADAELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC6MDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAUEDdGooAgAhAyACIAAoAgAiBSgCACgCACIENgIgIAIgAzYCHAJAAkACQAJAAkAgBARAIANBgICAgHhGIARBf0ZxRQRAIAMgBG0hAwwDCyACQQI2AjwgAkGYkP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDDAILIAJBh4CAgHg2AggLIAJBCGoQiBEMAQsgAyAFKAIELQAAEMQpRQ0AIAAoAgggAUECdGogAzYCAAwBCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAv3AgEIfwJAAkACQAJAIAFBAXYgAWoiBQRAIAIoAgAhCANAAkACfyABIAVBAWsiBU0EQCAFIAFrDAELIAAoAgAhAiAAIAAgBUECdGoiBigCADYCACAGIAI2AgBBAAsiBkEBdCIEQQFyIgIgASAFIAEgBUkbIgpPDQADQCAIKAIEIQMgBEECaiIHIApJBEAgACACQQJ0aigCACIEIANPDQUgACAHQQJ0aigCACIHIANPDQYgAiAIKAIAIgkgBEECdGooAgAgCSAHQQJ0aigCAEhqIQILIAAgBkECdGoiBygCACIGIANPDQYgACACQQJ0aiIJKAIAIgQgA08NByAIKAIAIgMgBkECdGooAgAgAyAEQQJ0aigCAE4NASAHIAlBARD6KiACIQYgAkEBdCIEQQFyIgIgCkkNAAsLIAUNAAsLDwsgBCADQfD2gwEQwyEACyAHIANBgPeDARDDIQALIAYgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEAC/cCAQh/AkACQAJAAkAgAUEBdiABaiIFBEAgAigCACEIA0ACQAJ/IAEgBUEBayIFTQRAIAUgAWsMAQsgACgCACECIAAgACAFQQJ0aiIGKAIANgIAIAYgAjYCAEEACyIGQQF0IgRBAXIiAiABIAUgASAFSRsiCk8NAANAIAgoAgQhAyAEQQJqIgcgCkkEQCAAIAJBAnRqKAIAIgQgA08NBSAAIAdBAnRqKAIAIgcgA08NBiACIAgoAgAiCSAEQQJ0aigCACAJIAdBAnRqKAIASWohAgsgACAGQQJ0aiIHKAIAIgYgA08NBiAAIAJBAnRqIgkoAgAiBCADTw0HIAgoAgAiAyAGQQJ0aigCACADIARBAnRqKAIATw0BIAcgCUEBEPoqIAIhBiACQQF0IgRBAXIiAiAKSQ0ACwsgBQ0ACwsPCyAEIANB8PaDARDDIQALIAcgA0GA94MBEMMhAAsgBiADQfD2gwEQwyEACyAEIANBgPeDARDDIQAL9wIBCH8CQAJAAkACQCABQQF2IAFqIgUEQCACKAIAIQgDQAJAAn8gASAFQQFrIgVNBEAgBSABawwBCyAAKAIAIQIgACAAIAVBAnRqIgYoAgA2AgAgBiACNgIAQQALIgZBAXQiBEEBciICIAEgBSABIAVJGyIKTw0AA0AgCCgCBCEDIARBAmoiByAKSQRAIAAgAkECdGooAgAiBCADTw0FIAAgB0ECdGooAgAiByADTw0GIAIgCCgCACIJIARBA3RqKQMAIAkgB0EDdGopAwBUaiECCyAAIAZBAnRqIgcoAgAiBiADTw0GIAAgAkECdGoiCSgCACIEIANPDQcgCCgCACIDIAZBA3RqKQMAIAMgBEEDdGopAwBaDQEgByAJQQEQ+iogAiEGIAJBAXQiBEEBciICIApJDQALCyAFDQALCw8LIAQgA0Hw9oMBEMMhAAsgByADQYD3gwEQwyEACyAGIANB8PaDARDDIQALIAQgA0GA94MBEMMhAAv3AgEIfwJAAkACQAJAIAFBAXYgAWoiBQRAIAIoAgAhCANAAkACfyABIAVBAWsiBU0EQCAFIAFrDAELIAAoAgAhAiAAIAAgBUECdGoiBigCADYCACAGIAI2AgBBAAsiBkEBdCIEQQFyIgIgASAFIAEgBUkbIgpPDQADQCAIKAIEIQMgBEECaiIHIApJBEAgACACQQJ0aigCACIEIANPDQUgACAHQQJ0aigCACIHIANPDQYgAiAIKAIAIgkgBEEDdGopAwAgCSAHQQN0aikDAFNqIQILIAAgBkECdGoiBygCACIGIANPDQYgACACQQJ0aiIJKAIAIgQgA08NByAIKAIAIgMgBkEDdGopAwAgAyAEQQN0aikDAFkNASAHIAlBARD6KiACIQYgAkEBdCIEQQFyIgIgCkkNAAsLIAUNAAsLDwsgBCADQfD2gwEQwyEACyAHIANBgPeDARDDIQALIAYgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEAC78DAgJ/AX4jAEHQAGsiBCQAIAQgAzoAHyAEIAI3AwggBCABNwMAIAACfwJAIANB/wFxIgNBJ08EQCAEQQI2AjwgBEHsjYUBNgI4IARCAjcCRCAEQbsHNgIsIARBuwc2AiQgBEHAjYUBNgIgIAQgBEEgajYCQCAEIARBH2o2AiggAEEEaiAEQThqEJkODAELIAEgA0EEdCIFQbCChQFqIgMpAwBYIAIgBUG4goUBaikDACIGVyACIAZRG0UEQCAEQQM2AiQgBEGojYUBNgIgIARCAzcCLCAEQfoaNgJMIAQgAzYCSCAEQbsHNgJEIARB+ho2AjwgBCAEQThqNgIoIAQgBEEfajYCQCAEIAQ2AjggAEEEaiAEQSBqEJkODAELQZOAgIB4IAEgBUGgh4UBaiIDKQMAWiACIAVBqIeFAWopAwAiAVkgASACURsNARogBEEDNgIkIARB0IyFATYCICAEQgM3AiwgBEH6GjYCTCAEIAM2AkggBEG7BzYCRCAEQfoaNgI8IAQgBEE4ajYCKCAEIARBH2o2AkAgBCAENgI4IABBBGogBEEgahCZDgtBjYCAgHgLNgIAIARB0ABqJAAL0AMBAn8gACABEJg+IQICQAJAIAAoAgQiA0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQEgACADEJY+IgBB0POKASgCAEYEQCACKAIEQQNxQQNHDQFByPOKASABNgIAIAAgASACEIkuDAILIAAgAxCFDwsCQAJAAkAgAigCBCIDQQJxRQRAIAJB1POKASgCAEYNAiACQdDzigEoAgBGDQMgAiADQXhxIgIQhQ8gACABIAJqIgEQ0DQgAEHQ84oBKAIARw0BQcjzigEgATYCAA8LIAAgASACEIkuCyABQYACTwRAIAAgARDsEA8LAn9BwPOKASgCACICQQEgAUEDdnQiA3FFBEBBwPOKASACIANyNgIAIAFB+AFxQbjxigFqIgEMAQsgAUH4AXEiAkG48YoBaiEBIAJBwPGKAWooAgALIQIgASAANgIIIAIgADYCDCAAIAE2AgwgACACNgIIDwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBCAAQdDzigEoAgBHDQFByPOKAUEANgIAQdDzigFBADYCAA8LQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLC+MCAQZ/AkAgAkUEQAwBCyABIAJqIQggASEEA0ACfyAEIgUsAAAiA0EATgRAIANB/wFxIQMgBUEBagwBCyAFLQABQT9xIQQgA0EfcSEGIANBX00EQCAGQQZ0IARyIQMgBUECagwBCyAFLQACQT9xIARBBnRyIQQgA0FwSQRAIAQgBkEMdHIhAyAFQQNqDAELIAZBEnRBgIDwAHEgBS0AA0E/cSAEQQZ0cnIhAyAFQQRqCyEEAkAgA0EgRiADQQlrQQVJcg0AIANBgAFJDQICQCADQQh2IgZBH00EQCAGRQ0BIAZBFkcNBCADQYAtRg0CDAQLIAZBIEcEQCAGQTBHDQQgA0GA4ABGDQIMBAsgA0H/AXFB+9SJAWotAABBAnENAQwDCyADQf8BcUH71IkBai0AAEEBcUUNAgsgByAFayAEaiEHIAQgCEcNAAsgAiEHCyAAIAIgB2s2AgQgACABIAdqNgIAC7kCAQZ/QR8gAGdrIQAgAigCOEEBRgRAIAFBAmsiAmchAQJ/IAMEQEEfIAFrIgFBCHQgAkEIdCABdmoMAQtBgD4gAUEIdGsLIABBCHRqQYAgag8LIAFBA2shASACKAIMIABBAnRqKAIAQQFqIgVnIQQgAwR/IARBCHQgBUEIdEEfIARrdmtBgD5rBSAEQQh0QYA+awshBCACKAI0IQYgA0ECSSAAQRNLcSEFIABBCXQhByABQYABTwR/QcMAIAFnawUgAUHAr9EAai0AAAsiAUGAr9EAai0AACEIIAIoAgggAUECdGooAgBBAWoiCWchASACKAIwIQIgAwR/IAFBCHQgCUEIdEEfIAFrdmtBgD5rBSABQQh0QYA+awsgB0HNywBrQTMgBRsgBmogBGogAmogACAIakEIdGpqC50DAQZ/IwBBMGsiAyQAAkACQCABAn8CQAJAAkACQAJAAkAgAS0AIEEBaw4DBAEAAgsgASgCHCEFDAILAAsgA0EQaiIGIAFBCGooAgA2AgAgA0EcaiABQRRqKAIANgIAIAMgASkCADcDCCADIAEpAgw3AhQgASgCGCEHIAMQziIgAygCBCEFIAMoAgAhCEGwB0EIEK02IgRFDQQgBCADKQMINwMAIARBADoAICAEIAg2AhwgBCAHNgIYIARBEGogA0EYaikDADcDACAEQQhqIAYpAwA3AwAgBEG83sIAENQaIAEgBTYCHAsgA0EIaiAFQQhqIAIQqBQgAygCCEUNAUEBIQVBAwwCC0HM9sIAEOgrAAsgA0EoaiIEIANBGGooAgA2AgAgAyADKQIQNwMgIAMoAgwhAiABQRxqEK4sIAJFDQIgACADKQMgNwIIIABBEGogBCgCADYCACAAIAI2AgRBACEFQQELOgAgIAAgBTYCACADQTBqJAAPC0EIQbAHEKM9AAtBnODCAEErIANBCGpB+ODCAEHc9sIAENUeAAuLAwEEfyMAQSBrIgIkACACQQxqIAEQmxMgAi0AECEEIAACfyACKAIMIgNBBEcEQCAAIAIpABE3AAkgAEEQaiACQRhqKQAANwAAIAAgBDoACCAAIAM2AgRBAQwBCwJAAkACQAJAIARBD3EiA0EBaw4CAQACC0EAIQMLIAEgAzoAEkECIQMMAQsgAkEMaiADEKgSIAItABAhAyACKAIMIgVBBEcEQCAAIAIpABE3AAkgAEEQaiACQRhqKQAANwAAIAAgAzoACCAAIAU2AgRBAQwCCyADDQAgAkGAgICAeDYCDCAAQQRqIAJBDGogAhCvLUEADAELIAECfyAEQQ9NBEAgAkEMaiABEIYmIAIvARAiBCACKAIMIgVBBEYNARogACACKQESNwEKIABBEGogAkEYaikBADcBACAAIAQ7AQggACAFNgIEQQEMAgsgAS8BECAEQfABcUEEdmoLIgQ7ARAgACADOgAUIAAgBDsBEiAAQQE7ARAgAEGAgICAeDYCBEEACzYCACACQSBqJAALiwMBBH8jAEEgayICJAAgAkEMaiABEMQZIAItABAhBCAAAn8gAigCDCIDQQRHBEAgACACKQARNwAJIABBEGogAkEYaikAADcAACAAIAQ6AAggACADNgIEQQEMAQsCQAJAAkACQCAEQQ9xIgNBAWsOAgEAAgtBACEDCyABIAM6ABJBAiEDDAELIAJBDGogAxCoEiACLQAQIQMgAigCDCIFQQRHBEAgACACKQARNwAJIABBEGogAkEYaikAADcAACAAIAM6AAggACAFNgIEQQEMAgsgAw0AIAJBgICAgHg2AgwgAEEEaiACQQxqIAIQry1BAAwBCyABAn8gBEEPTQRAIAJBDGogARCHJiACLwEQIgQgAigCDCIFQQRGDQEaIAAgAikBEjcBCiAAQRBqIAJBGGopAQA3AQAgACAEOwEIIAAgBTYCBEEBDAILIAEvARAgBEHwAXFBBHZqCyIEOwEQIAAgAzoAFCAAIAQ7ARIgAEEBOwEQIABBgICAgHg2AgRBAAs2AgAgAkEgaiQAC9QIARB/IwBBIGsiBSQAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAkAgAS0ACmo2AkAMAwsgACAAKAJAIAEoAghqNgJADAILIAAgAS8AATsBzAYMAQsgBUIANwMQQQchBgNAIAggACgCQCINSQRAIAVBEGogBmogACAGIA1qQQhrQaDOzgAQqSgtAAA6AAALIAhBAWohCCAGQQFrIgZBf0cNAAsgASgCCCINBEAgASgCBCEGQQAhCCANIQEDQCAFQRBqIgMgCEEGakEHcXItAAAhAiAFQQhqIAMgCEEHaiIHQQdxci0AACACIAAoAhggACgCHCAAKAIoBH8gACgCJC0AAAVBAAsgAC0AzAYQtRsgBSgCCCELIAUgBSkDEDcDGCAFQRhqIAcgAC0AzQZrQQdxci0AACEJIAYtAAAhAiMAQfAAayIDJAAgA0EoaiAAKAIwIAAoAjQgCxCvGiAAQYwEaiADKAIoIgwgAygCLCIEIAJB8AFxQQR2IgcQuAogA0EwaiIPIAwgBBCnEiADQSBqIAAoAjAgACgCNCALIAcQrxkgAEHMA2ogAygCICIEIAMoAiQiCiACQQ9xIgwQuAogA0HQAGoiECAEIAoQpxIgA0EYaiEEIAAoAjghESAAKAI8IQojAEEgayICJAACQAJAIAlB/wFxQRF0IAtBCXRyIg4gCk0EQCAKIA5rQf8BTQ0BIARBgAI2AgQgBCARIA5BAXRqNgIAIAJBIGokAAwCCyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGo8NEAEO8sAAsgAkEANgIYIAJBATYCDCACQYDw0QA2AgggAkIENwIQIAJBCGpBuPDRABDvLAALIABBjAZqIAMoAhgiAiADKAIcIgQgDyAHEKgJIABBjAVqIAIgBCAHELgKIAIgBCAHEPgIIANBEGohBCAAKAI4IQ4gACgCPCEKIwBBIGsiAiQAAkACQCALQQl0IAlBD3FBEXRyIAdB/wFxQRV0ckGAAnIiCSAKTQRAIAogCWtB/wFNDQEgBEGAAjYCBCAEIA4gCUEBdGo2AgAgAkEgaiQADAILIAJBADYCGCACQQE2AgwgAkGA8NEANgIIIAJCBDcCECACQQhqQYjw0QAQ7ywACyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGY8NEAEO8sAAsgAEHMBWogAygCECICIAMoAhQiCSAQIAwQqAkgAEHMBGogAiAJIAwQuAogAiAJIAwQ+AggA0EIaiAAKAIwIAAoAjQgCxCvGiADKAIIIAMoAgwgBxD4CCADIAAoAjAgACgCNCALIAcQrxkgAygCACADKAIEIAwQ+AggA0HwAGokACAFQRBqIAhqIAYtAAA6AAAgCEEBakEHcSEIIAZBAWohBiABQQFrIgENAAsLIAAgACgCQCANajYCQAsgBUEgaiQAC+UEAQR/IwBB4ABrIg0kACANQRRqIAIgAyAEIAcgBRDvFiANKAIgIQMgDSgCHCEOIA0oAhQhDyANKAIYIQQjAEEQayICJAAgAkIANwMAIAJBADYCCCACQQA2AgxBAUIAIAkgCiALEOUSIAcgAiACQQhqIAJBDGoQvRlBAiACNQIMIAkgCiALEOUSIAIoAgggAikDACAJIAogCxDlEkEBQgEgCSAKIAsQ5RIgAkEQaiQAIAkgCiALELQpAkACQAJAAkACQCAEIAkoAgBBA3YiAmoiBSACTwRAIAUgC0sNASACIApqIAQgDyAEQbSt0AAQ1SwgCSAJKAIAIARBA3RqIgI2AgAgAkEDdiICIANqIgUgAkkNAiAFIAtLDQMgAiAKaiADIA4gA0HUrdAAENUsIAkgCSgCACADQQN0aiIFNgIAIwBBIGsiAiQAIAIgBUEHcSIQNgIEAkAgEEUEQCAFQQN2IgUgC0kNASAFIAtBnObRABDDIQALIAJBADYCCEEAIAJBBGpBmObRACACQQhqQazm0QAQrysACyAFIApqQQA6AAAgAkEgaiQAIAwNBSAGLQBRQQFxDQQMBQsgAiAFQaSt0AAQsTsACyAFIAtBpK3QABCwOwALIAIgBUHErdAAELE7AAsgBSALQcSt0AAQsDsACyANQRBqQQA2AgAgDUIANwIIIA0gBzYCBCANQRRqIgIQ8yggACANQQRqQQEgDyAEIA4gA0HkrdAAIAggAiAGQQQQpQELIAEEQEEBQgEgCSAKIAsQ5RJBAUIBIAkgCiALEOUSIAkgCiALELQpCyANQeAAaiQAC+IwARR/IwBBEGsiFyQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCABIgIgAkEBdmoiBgRAIAQoAgAhBwNAAkACfyACIAZBAWsiBk0EQCAGIAJrDAELIAAvAAAhASAAIAAgBkEBdGoiAy8AADsAACADIAE7AABBAAsiA0EBdCIEQQFyIgEgAiAGIAIgBkkbIg5PDQADQCAEQQJqIgQgDkkEQCAAIAFBAXRqIAAgBEEBdGogBygCACgCABECAEEfdiABaiEBCyAAIANBAXRqIgMgACABQQF0IgRqIgUgBygCACgCABECAEEATg0BIAMvAAAhCSADIAUvAAA7AAAgBSAJOwAAIAEhAyAEQQFyIgEgDkkNAAsLIAYNAAsLDAMLIAAgAUF4cWohBiAAIAFBA3YiDkEObGohBwJ/IAFBwABPBEAgACAGIAcgDiAEEMkYDAELIAAgACAGIAQoAgAiDigCACgCABECACIFIAAgByAOKAIAKAIAEQIAc0EASA0AGiAHIAYgBiAHIA4oAgAoAgARAgAgBXNBAEgbCyAAayIHQQF2IQYCQAJAIAJFDQAgAiAAIAdqIAQoAgAoAgAoAgARAgBBAEgNACAXIAQ2AgwCf0EAIAFFDQAaIBdBDGohAgJAIAEgBk0NACAALwAAIQcgACAAIAZBAXRqIgYvAAA7AAAgBiAHOwAAIABBAmohByMAQRBrIgUkACABQQFrIgwEfyAFIAcvAAA7AQ4gAigCACEJQQAhDiAHIgZBAmoiAiAGIAxBAXRqIgxBAmsiEEkEQCAGIQIDQCAAIAJBAmoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIA5BAXRqIgYvAAA7AAAgBiAKLwAAOwAAIAAgAkEEaiIGIAkoAgAoAgAoAgARAgAhFSAKIAcgDiASQX9zQR92aiIOQQF0aiIKLwAAOwAAIAogBi8AADsAACAOIBVBf3NBH3ZqIQ4gAkEGaiAGIQIgEEkNAAsgBkECaiECCyACIAxHBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAOQQF0aiIGLwAAOwAAIAYgAi8AADsAACAOIApBf3NBH3ZqIQ4gAiIGQQJqIgIgDEcNAAsgAkECayEGCyAAIAVBDmogCSgCACgCACgCABECACECIAYgByAOQQF0aiIGLwAAOwAAIAYgBS8BDjsAACAOIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgAC8AACEGIAAgACACQQF0aiIHLwAAOwAAIAcgBjsAACACDAELAAsiBkEBaiECIAEgBksEQCABIAJrIQEgACACQQF0aiEAQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAvAAAhByAAIAAgBkEBdGoiBi8AADsAACAGIAc7AAAgAEECaiEOIwBBEGsiCSQAIAFBAWsiCgR/IAkgDi8AADsBDiAEKAIAIQxBACEFIA4iB0ECaiIGIAcgCkEBdGoiCkECayISSQRAIAchBgNAIAZBAmoiECAAIAwoAgAoAgARAgAhFSAGIA4gBUEBdGoiBy8AADsAACAHIBAvAAA7AAAgBkEEaiIHIAAgDCgCACgCABECACAQIA4gFUEfdiAFaiIFQQF0aiIQLwAAOwAAIBAgBy8AADsAAEEfdiAFaiEFIAZBBmogByEGIBJJDQALIAZBAmohBgsgBiAKRwRAA0AgBiAAIAwoAgAoAgARAgAgByAOIAVBAXRqIgcvAAA7AAAgByAGLwAAOwAAQR92IAVqIQUgBiEHIAZBAmoiBiAKRw0ACyAGQQJrIQcLIAlBDmogACAMKAIAKAIAEQIAIAcgDiAFQQF0aiIHLwAAOwAAIAcgCS8BDjsAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAvAAAhByAAIAAgBkEBdGoiDi8AADsAACAOIAc7AAAgBgwBCwALIgYgAiADIAQQtg4gASAGQX9zaiEBIAAgBkEBdGoiAkECaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBQGoiBiQAAkACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgcgAUESSSIYGyECIAEgB2shByAAIAFBfnFqIQ4DQAJ/IAJBDE0EQEEBIAJBCE0NARoCQCACQQlPBEAgACAAQQZqIgkgACAEKAIAIgUoAgAoAgARAgAiDEEfdUEGcWovAAAhCiAAIABBBkEAIAxBAE4bai8AADsABiAAIAo7AAAgAEEOQQIgAEEOaiISIABBAmoiFSAFKAIAKAIAEQIAQQBIIgwbai8AACEKIAAgAEECQQ4gDBtqLwAAOwAOIAAgCjsAAiAAQQpBBCAAQQpqIgwgAEEEaiIQIAUoAgAoAgARAgBBAEgiChtqLwAAIQ0gACAAQQRBCiAKG2ovAAA7AAogACANOwAEIABBEEEIIABBEGoiEyAAQQhqIgogBSgCACgCABECAEEASCING2ovAAAhCyAAIABBCEEQIA0bai8AADsAECAAIAs7AAggACASIAAgBSgCACgCABECACINQR91QQ5xai8AACELIAAgAEEOQQAgDUEAThtqLwAAOwAOIAAgCzsAACAAQQhBBCAKIBAgBSgCACgCABECAEEASCING2ovAAAhCyAAIABBBEEIIA0bai8AADsACCAAIAs7AAQgAEEQQQYgEyAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIQsgACAAQQZBECANG2ovAAA7ABAgACALOwAGIABBDEEKIABBDGoiDSAMIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQpBDCALG2ovAAA7AAwgACAPOwAKIAAgECAAIAUoAgAoAgARAgAiC0EddkEEcWovAAAhDyAAIAAgC0F/c0EddkEEcWovAAA7AAQgACAPOwAAIABBBkECIAkgFSAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEECQQYgCxtqLwAAOwAGIAAgDzsAAiAAQQpBCCAMIAogBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBCEEKIAsbai8AADsACiAAIA87AAggAEEQQQ4gEyASIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQ5BECALG2ovAAA7ABAgACAPOwAOIABBCEECIAogFSAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEECQQggCxtqLwAAOwAIIAAgDzsAAiAAQQxBBiANIAkgBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBBkEMIAsbai8AADsADCAAIA87AAYgAEEOQQogEiAMIAUoAgAoAgARAgBBAEgiCxtqLwAAIQ8gACAAQQpBDiALG2ovAAA7AA4gACAPOwAKIAAgFSAAIAUoAgAoAgARAgAiC0EedkECcWovAAAhDyAAIAAgC0F/c0EedkECcWovAAA7AAIgACAPOwAAIABBCEEEIAogECAFKAIAKAIAEQIAQQBIIgsbai8AACEPIAAgAEEEQQggCxtqLwAAOwAIIAAgDzsABCAAQQpBBiAMIAkgBSgCACgCABECAEEASCILG2ovAAAhDyAAIABBBkEKIAsbai8AADsACiAAIA87AAYgAEEQQQwgEyANIAUoAgAoAgARAgBBAEgiExtqLwAAIQsgACAAQQxBECATG2ovAAA7ABAgACALOwAMIABBBkEEIAkgECAFKAIAKAIAEQIAQQBIIhMbai8AACELIAAgAEEEQQYgExtqLwAAOwAGIAAgCzsABCAAQQpBCCAMIAogBSgCACgCABECAEEASCITG2ovAAAhCyAAIABBCEEKIBMbai8AADsACiAAIAs7AAggAEEOQQwgEiANIAUoAgAoAgARAgBBAEgiEhtqLwAAIRMgACAAQQxBDiASG2ovAAA7AA4gACATOwAMIABBBEECIBAgFSAFKAIAKAIAEQIAQQBIIhAbai8AACESIAAgAEECQQQgEBtqLwAAOwAEIAAgEjsAAiAAQQhBBiAKIAkgBSgCACgCABECAEEASCIJG2ovAAAhCiAAIABBBkEIIAkbai8AADsACCAAIAo7AAYgAEEMQQogDSAMIAUoAgAoAgARAgBBAEgiBRtqLwAAIQkgACAAQQpBDCAFG2ovAAA7AAwgACAJOwAKDAELAAtBCQwBCwJAIAJBDU8EQCAAIABBGGoiESAAIAQoAgAiBSgCACgCABECACIJQR91QRhxai8AACEMIAAgAEEYQQAgCUEAThtqLwAAOwAYIAAgDDsAACAAQRRBAiAAQRRqIg0gAEECaiIPIAUoAgAoAgARAgBBAEgiCRtqLwAAIQwgACAAQQJBFCAJG2ovAAA7ABQgACAMOwACIABBEkEEIABBEmoiDCAAQQRqIhMgBSgCACgCABECAEEASCIJG2ovAAAhCiAAIABBBEESIAkbai8AADsAEiAAIAo7AAQgAEEOQQYgAEEOaiILIABBBmoiCiAFKAIAKAIAEQIAQQBIIgkbai8AACEQIAAgAEEGQQ4gCRtqLwAAOwAOIAAgEDsABiAAQRZBCiAAQRZqIhYgAEEKaiIQIAUoAgAoAgARAgBBAEgiCRtqLwAAIRIgACAAQQpBFiAJG2ovAAA7ABYgACASOwAKIABBEEEMIABBEGoiEiAAQQxqIgkgBSgCACgCABECAEEASCIVG2ovAAAhCCAAIABBDEEQIBUbai8AADsAECAAIAg7AAwgAEEMQQIgCSAPIAUoAgAoAgARAgBBAEgiFRtqLwAAIQggACAAQQJBDCAVG2ovAAA7AAwgACAIOwACIABBBkEEIAogEyAFKAIAKAIAEQIAQQBIIhUbai8AACEIIAAgAEEEQQYgFRtqLwAAOwAGIAAgCDsABCAAQRZBCCAWIABBCGoiFSAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEEIQRYgCBtqLwAAOwAWIAAgFDsACCAAQRJBDiAMIAsgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBDkESIAgbai8AADsAEiAAIBQ7AA4gAEEUQRAgDSASIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQRBBFCAIG2ovAAA7ABQgACAUOwAQIAAgFSAAIAUoAgAoAgARAgAiCEEcdkEIcWovAAAhFCAAIAAgCEF/c0EcdkEIcWovAAA7AAggACAUOwAAIABBBEECIBMgDyAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEECQQQgCBtqLwAAOwAEIAAgFDsAAiAAQQxBBiAJIAogBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBBkEMIAgbai8AADsADCAAIBQ7AAYgAEEQQQ4gEiALIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQQ5BECAIG2ovAAA7ABAgACAUOwAOIABBFEESIA0gDCAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEESQRQgCBtqLwAAOwAUIAAgFDsAEiAAQRhBFiARIBYgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBFkEYIAgbai8AADsAGCAAIBQ7ABYgAEEMQQggCSAVIAUoAgAoAgARAgBBAEgiCBtqLwAAIRQgACAAQQhBDCAIG2ovAAA7AAwgACAUOwAIIABBEkEKIAwgECAFKAIAKAIAEQIAQQBIIggbai8AACEUIAAgAEEKQRIgCBtqLwAAOwASIAAgFDsACiAAQRZBECAWIBIgBSgCACgCABECAEEASCIIG2ovAAAhFCAAIABBEEEWIAgbai8AADsAFiAAIBQ7ABAgAEEYQRQgESANIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQRRBGCARG2ovAAA7ABggACAIOwAUIAAgECAAIAUoAgAoAgARAgAiEUEfdUEKcWovAAAhCCAAIABBCkEAIBFBAE4bai8AADsACiAAIAg7AAAgAEEQQQYgEiAKIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQQZBECARG2ovAAA7ABAgACAIOwAGIABBDkEIIAsgFSAFKAIAKAIAEQIAQQBIIhEbai8AACEIIAAgAEEIQQ4gERtqLwAAOwAOIAAgCDsACCAAQRZBDCAWIAkgBSgCACgCABECAEEASCIRG2ovAAAhCCAAIABBDEEWIBEbai8AADsAFiAAIAg7AAwgAEEUQRIgDSAMIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQRJBFCARG2ovAAA7ABQgACAIOwASIAAgDyAAIAUoAgAoAgARAgAiEUEedkECcWovAAAhCCAAIAAgEUF/c0EedkECcWovAAA7AAIgACAIOwAAIABBCkEEIBAgEyAFKAIAKAIAEQIAQQBIIhEbai8AACEIIAAgAEEEQQogERtqLwAAOwAKIAAgCDsABCAAQRJBDCAMIAkgBSgCACgCABECAEEASCIRG2ovAAAhCCAAIABBDEESIBEbai8AADsAEiAAIAg7AAwgAEEQQQ4gEiALIAUoAgAoAgARAgBBAEgiERtqLwAAIQggACAAQQ5BECARG2ovAAA7ABAgACAIOwAOIABBFkEUIBYgDSAFKAIAKAIAEQIAQQBIIhYbai8AACERIAAgAEEUQRYgFhtqLwAAOwAWIAAgETsAFCAAQQZBAiAKIA8gBSgCACgCABECAEEASCIWG2ovAAAhESAAIABBAkEGIBYbai8AADsABiAAIBE7AAIgAEEIQQQgFSATIAUoAgAoAgARAgBBAEgiFhtqLwAAIREgACAAQQRBCCAWG2ovAAA7AAggACAROwAEIABBDEEKIAkgECAFKAIAKAIAEQIAQQBIIhYbai8AACERIAAgAEEKQQwgFhtqLwAAOwAMIAAgETsACiAAQRRBEiANIAwgBSgCACgCABECAEEASCING2ovAAAhFiAAIABBEkEUIA0bai8AADsAFCAAIBY7ABIgAEEEQQIgEyAPIAUoAgAoAgARAgBBAEgiDRtqLwAAIQ8gACAAQQJBBCANG2ovAAA7AAQgACAPOwACIABBCEEGIBUgCiAFKAIAKAIAEQIAQQBIIg0bai8AACEPIAAgAEEGQQggDRtqLwAAOwAIIAAgDzsABiAAQQ5BCiALIBAgBSgCACgCABECAEEASCING2ovAAAhDyAAIABBCkEOIA0bai8AADsADiAAIA87AAogAEEQQQwgEiAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIQ8gACAAQQxBECANG2ovAAA7ABAgACAPOwAMIABBBkEEIAogEyAFKAIAKAIAEQIAQQBIIg0bai8AACETIAAgAEEEQQYgDRtqLwAAOwAGIAAgEzsABCAAQQpBCCAQIBUgBSgCACgCABECAEEASCING2ovAAAhEyAAIABBCEEKIA0bai8AADsACiAAIBM7AAggAEEOQQwgCyAJIAUoAgAoAgARAgBBAEgiDRtqLwAAIRMgACAAQQxBDiANG2ovAAA7AA4gACATOwAMIABBEkEQIAwgEiAFKAIAKAIAEQIAQQBIIgwbai8AACESIAAgAEEQQRIgDBtqLwAAOwASIAAgEjsAECAAQQhBBiAVIAogBSgCACgCABECAEEASCIMG2ovAAAhCiAAIABBBkEIIAwbai8AADsACCAAIAo7AAYgAEEMQQogCSAQIAUoAgAoAgARAgBBAEgiBRtqLwAAIQkgACAAQQpBDCAFG2ovAAA7AAwgACAJOwAKDAELAAtBDQsiBUEBayACTw0CIAIgBUcEQCAFQQF0IQUgAkEBdCECA0AgACAAIAVqIAQQvx4gAiAFQQJqIgVHDQALCyAYDQEgACADRiAHIQIgDiEADQALIAFBAXYhDCABQQF0QQJrIgcgBiICaiEJIAcgAyIAaiEOIAAgAUF+cWoiB0ECayEFIAQoAgAhBANAIAIgACAHIAcgACAEKAIAKAIAEQIAIgpBAE4iEBsvAAA7AAAgCSAOIAUgDiAFIAQoAgAoAgARAgAiEkEAThsvAAA7AAAgACAQQQF0aiEAIAcgCkEedkECcWohByAFIBJBH3UiCkEBdGohBSAOIApBf3NBAXRqIQ4gCUECayEJIAJBAmohAiAMQQFrIgwNAAsgBUECaiEEIAFBAXEEfyACIAAgByAAIARJIgIbLwAAOwAAIAcgACAET0EBdGohByAAIAJBAXRqBSAACyAERyAHIA5BAmpHcgRAEOQrAAsgAUEBdCIARQ0AIAMgBiAA/AoAAAsgBkFAayQADAELAAsLIBdBEGokAAvjEwIPfwN+IwBBgAZrIgwkAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAjAEEQayIIJAAgASIDIAFBAXZqIgUEQCAAIQIgBCgCACEEA0ACQAJ/IAMgBUEBayIFTQRAIAUgA2sMAQsgAiAFQQR0aiIAQQhqIgEpAAAhFCACKQAAIRUgAiAAKQAANwAAIAJBCGoiBikAACEWIAYgFDcAACABIBY3AAAgACAVNwAAQQALIgBBAXQiBkEBciIBIAMgBSADIAVJGyIHTw0AA0AgAiAAQQR0aiIJIAIgByAGQQJqIgBNBH8gAQUgAiABQQR0aiACIABBBHRqIAQoAgAoAgARAgBBH3YgAWoLIgBBBHRqIgYgBCgCACgCABECAEEATg0BQQAhAQNAIAEgCWoiCigAACENIAogASAGaiIKKAAANgAAIAogDTYAACABQQRqIgFBEEcNAAsgAEEBdCIGQQFyIgEgB0kNAAsLIAUNAAsLIAhBEGokAAwDCyAAIAFBA3YiB0HwAGxqIQUgACAHQQZ0aiEGAn8gAUHAAE8EQCAAIAYgBSAHIAQQzRgMAQsgACAAIAYgBCgCACIHKAIAKAIAEQIAIgggACAFIAcoAgAoAgARAgBzQQBIDQAaIAUgBiAGIAUgBygCACgCABECACAIc0EASBsLIABrIgZBBHYhBQJ/AkAgAkUNACACIAAgBmogBCgCACgCACgCABECAEEASA0AIAwgBDYCACMAQSBrIg4kAAJAIAFFBEBBACECDAELAkAgASAFTQ0AIAAgBUEEdGoiAkEIaiIFKQAAIRQgACkAACEVIAAgAikAADcAACAAQQhqIgopAAAhFiAKIBQ3AAAgBSAWNwAAIAIgFTcAACAAQRBqIQZBACEHIwBBEGsiCCQAIAFBAWsiDQR/IAhBCGogBkEIaikAADcDACAIIAYpAAA3AwAgDCgCACEJIAYiBUEQaiICIAUgDUEEdGoiDUEQayIRSQRAIAUhAgNAIAAgAkEQaiILIAkoAgAoAgAoAgARAgAhDyAGIAdBBHRqIgUpAAAhFCACQQhqIAVBCGoiECkAADcAACACIBQ3AAAgECACQRhqIhApAAA3AAAgBSALKQAANwAAIAAgAkEgaiIFIAkoAgAoAgAoAgARAgAhEiAGIAcgD0F/c0EfdmoiD0EEdGoiBykAACEUIBAgB0EIaiIQKQAANwAAIAsgFDcAACAQIAJBKGopAAA3AAAgByAFKQAANwAAIA8gEkF/c0EfdmohByACQTBqIAUhAiARSQ0ACyAFQRBqIQILIAIgDUcEQANAIAAgAiAJKAIAKAIAKAIAEQIAIREgBiAHQQR0aiILKQAAIRQgBUEIaiALQQhqIg8pAAA3AAAgBSAUNwAAIA8gAkEIaikAADcAACALIAIpAAA3AAAgByARQX9zQR92aiEHIAIiBUEQaiICIA1HDQALIAJBEGshBQsgACAIIAkoAgAoAgAoAgARAgAhCSAGIAdBBHRqIgIpAAAhFCAFQQhqIAJBCGoiBikAADcAACAFIBQ3AAAgBiAIQQhqKQMANwAAIAIgCCkDADcAACAHIAlBf3NBH3ZqBUEACyECIAhBEGokACABIAJNDQAgACACQQR0aiIFQQhqIgYpAAAhFCAAKQAAIRUgACAFKQAANwAAIAopAAAhFiAKIBQ3AAAgBiAWNwAAIAUgFTcAAAwBCwALIA5BIGokACACQQFqIQUgASACSwRAIAEgBWshAUEAIQIgACAFQQR0agwCCyAFIAFB0PHQABCvOwALIwBBIGsiESQAAkAgAUUEQEEAIQUMAQsCQCABIAVNDQAgACAFQQR0aiIFQQhqIgYpAAAhFCAAKQAAIRUgACAFKQAANwAAIABBCGoiDSkAACEWIA0gFDcAACAGIBY3AAAgBSAVNwAAIABBEGohB0EAIQgjAEEQayIJJAAgAUEBayILBH8gCUEIaiAHQQhqKQAANwMAIAkgBykAADcDACAEKAIAIQogByIGQRBqIgUgBiALQQR0aiILQRBrIg9JBEAgBiEFA0AgBUEQaiIOIAAgCigCACgCABECACEQIAcgCEEEdGoiBikAACEUIAVBCGogBkEIaiISKQAANwAAIAUgFDcAACASIAVBGGoiEikAADcAACAGIA4pAAA3AAAgBUEgaiIGIAAgCigCACgCABECACAHIBBBH3YgCGoiEEEEdGoiCCkAACEUIBIgCEEIaiISKQAANwAAIA4gFDcAACASIAVBKGopAAA3AAAgCCAGKQAANwAAQR92IBBqIQggBUEwaiAGIQUgD0kNAAsgBUEQaiEFCyAFIAtHBEADQCAFIAAgCigCACgCABECACAHIAhBBHRqIg4pAAAhFCAGQQhqIA5BCGoiECkAADcAACAGIBQ3AAAgECAFQQhqKQAANwAAIA4gBSkAADcAAEEfdiAIaiEIIAUhBiAFQRBqIgUgC0cNAAsgBUEQayEGCyAJIAAgCigCACgCABECACAHIAhBBHRqIgUpAAAhFCAGQQhqIAVBCGoiBykAADcAACAGIBQ3AAAgByAJQQhqKQMANwAAIAUgCSkDADcAAEEfdiAIagVBAAshBSAJQRBqJAAgASAFTQ0AIAAgBUEEdGoiBkEIaiIHKQAAIRQgACkAACEVIAAgBikAADcAACANKQAAIRYgDSAUNwAAIAcgFjcAACAGIBU3AAAMAQsACyARQSBqJAAgACAFIAIgAyAEELcOIAEgBUF/c2ohASAAIAVBBHRqIgJBEGoLIQAgA0EBayEDIAFBIU8NAAsLIwBBEGsiByQAIAFBAk8EQCAAIQICQAJAIAFBEGpBME0EQCABQQF2IQUgAUEPSw0BQQQhBiAMIAVBBHQiCGohAyAAIAhqIQggAUEHSwRAIAAgDCAEENwQIAggAyAEENwQDAMLIAwgAikAADcAACAMQQhqIAJBCGopAAA3AAAgAyAIKQAANwAAIANBCGogCEEIaikAADcAAEEBIQYMAgsACyACIAwgDCABQQR0aiIAIAQQrC0gAiAFQQR0IgNqIAMgDGogAEGAAWogBBCsLUEIIQYLQQAhACAHQQA2AghBACAGayEKIAIgBkEEdCIDaiENIAMgDGohCyAHIAU2AgwgASAFayEOIAdBCGohEQNAIAAgDiAFIBEgAEECdGooAgAiABsiCCAGSwRAIAwgAEEEdCIAaiEPIAggCmohCSAAIA1qIQggACALaiEAA0AgACAIKQAANwAAIABBCGogCEEIaikAADcAACAPIAAgBBCMGSAIQRBqIQggAEEQaiEAIAlBAWsiCQ0ACwtBASEAQQFxRQ0ACyAMIAEgAiAEEKwPCyAHQRBqJAALIAxBgAZqJAAL0TECAX4TfyMAQRBrIhckAAJAIAFBIU8EQCADQQFrIQMDQCADQX9GBEAgASIDIAFBAXZqIgcEQCAAIQIgBCgCACEEA0ACQAJ/IAMgB0EBayIHTQRAIAcgA2sMAQsgAikAACEFIAIgAiAHQQN0aiIAKQAANwAAIAAgBTcAAEEACyIAQQF0IghBAXIiASADIAcgAyAHSRsiCk8NAANAIAIgAEEDdGoiBiACIAogCEECaiIATQR/IAEFIAIgAUEDdGogAiAAQQN0aiAEKAIAKAIAEQIAQR92IAFqCyIAQQN0aiIIIAQoAgAoAgARAgBBAE4NAUEAIQEDQCABIAZqIgkoAAAhCyAJIAEgCGoiCSgAADYAACAJIAs2AAAgAUEEaiIBQQhHDQALIABBAXQiCEEBciIBIApJDQALCyAHDQALCwwDCyAAIAFBA3YiCkE4bGohByAAIApBBXRqIQgCfyABQcAATwRAIAAgCCAHIAogBBDMGAwBCyAAIAAgCCAEKAIAIgooAgAoAgARAgAiBiAAIAcgCigCACgCABECAHNBAEgNABogByAIIAggByAKKAIAKAIAEQIAIAZzQQBIGwsgAGsiCEEDdiEHAkACQCACRQ0AIAIgACAIaiAEKAIAKAIAKAIAEQIAQQBIDQAgFyAENgIMAn9BACABRQ0AGiAXQQxqIQICQCABIAdNDQAgACkAACEFIAAgACAHQQN0aiIHKQAANwAAIAcgBTcAACAAQQhqIQgjAEEQayIGJAAgAUEBayILBH8gBiAIKQAANwMIIAIoAgAhCUEAIQogCCIHQQhqIgIgByALQQN0aiILQQhrIg5JBEAgByECA0AgACACQQhqIg0gCSgCACgCACgCABECACETIAIgCCAKQQN0aiIHKQAANwAAIAcgDSkAADcAACAAIAJBEGoiByAJKAIAKAIAKAIAEQIAIREgDSAIIAogE0F/c0EfdmoiCkEDdGoiDSkAADcAACANIAcpAAA3AAAgCiARQX9zQR92aiEKIAJBGGogByECIA5JDQALIAdBCGohAgsgAiALRwRAA0AgACACIAkoAgAoAgAoAgARAgAhDSAHIAggCkEDdGoiBykAADcAACAHIAIpAAA3AAAgCiANQX9zQR92aiEKIAIiB0EIaiICIAtHDQALIAJBCGshBwsgACAGQQhqIAkoAgAoAgAoAgARAgAhAiAHIAggCkEDdGoiBykAADcAACAHIAYpAwg3AAAgCiACQX9zQR92agVBAAshAiAGQRBqJAAgASACTQ0AIAApAAAhBSAAIAAgAkEDdGoiBykAADcAACAHIAU3AAAgAgwBCwALIgdBAWohAiABIAdLBEAgASACayEBIAAgAkEDdGohAEEAIQIMAgsgAiABQdDx0AAQrzsACyAAAn9BACABRQ0AGgJAIAEgB00NACAAKQAAIQUgACAAIAdBA3RqIgcpAAA3AAAgByAFNwAAIABBCGohCiMAQRBrIgkkACABQQFrIg0EfyAJIAopAAA3AwggBCgCACELQQAhBiAKIghBCGoiByAIIA1BA3RqIg1BCGsiE0kEQCAIIQcDQCAHQQhqIg4gACALKAIAKAIAEQIAIREgByAKIAZBA3RqIggpAAA3AAAgCCAOKQAANwAAIAdBEGoiCCAAIAsoAgAoAgARAgAgDiAKIBFBH3YgBmoiBkEDdGoiDikAADcAACAOIAgpAAA3AABBH3YgBmohBiAHQRhqIAghByATSQ0ACyAHQQhqIQcLIAcgDUcEQANAIAcgACALKAIAKAIAEQIAIAggCiAGQQN0aiIIKQAANwAAIAggBykAADcAAEEfdiAGaiEGIAchCCAHQQhqIgcgDUcNAAsgB0EIayEICyAJQQhqIAAgCygCACgCABECACAIIAogBkEDdGoiCCkAADcAACAIIAkpAwg3AABBH3YgBmoFQQALIQcgCUEQaiQAIAEgB00NACAAKQAAIQUgACAAIAdBA3RqIggpAAA3AAAgCCAFNwAAIAcMAQsACyIHIAIgAyAEELgOIAEgB0F/c2ohASAAIAdBA3RqIgJBCGohAAsgA0EBayEDIAFBIU8NAAsLIAAhAyMAQYACayIHJAACQAJAAkAgAUECSQ0AIAFBIEsNASABIAFBAXYiCiABQRJJIhgbIQIgASAKayEIIAAgCkEDdGohCgNAAn8gAkEMTQRAQQEgAkEITQ0BGgJAIAJBCU8EQCAAIABBGGoiCSAAIAQoAgAiBigCACgCABECACILQR91QRhxaikAACEFIAAgAEEYQQAgC0EAThtqKQAANwAYIAAgBTcAACAAQThBCCAAQThqIhMgAEEIaiIRIAYoAgAoAgARAgBBAEgiCxtqKQAAIQUgACAAQQhBOCALG2opAAA3ADggACAFNwAIIABBKEEQIABBKGoiCyAAQRBqIg4gBigCACgCABECAEEASCING2opAAAhBSAAIABBEEEoIA0baikAADcAKCAAIAU3ABAgAEHAAEEgIABBQGsiFCAAQSBqIg0gBigCACgCABECAEEASCIMG2opAAAhBSAAIABBIEHAACAMG2opAAA3AEAgACAFNwAgIAAgEyAAIAYoAgAoAgARAgAiDEEfdUE4cWopAAAhBSAAIABBOEEAIAxBAE4baikAADcAOCAAIAU3AAAgAEEgQRAgDSAOIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQRBBICAMG2opAAA3ACAgACAFNwAQIABBwABBGCAUIAkgBigCACgCABECAEEASCIMG2opAAAhBSAAIABBGEHAACAMG2opAAA3AEAgACAFNwAYIABBMEEoIABBMGoiDCALIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQShBMCAPG2opAAA3ADAgACAFNwAoIAAgDiAAIAYoAgAoAgARAgAiD0EbdkEQcWopAAAhBSAAIAAgD0F/c0EbdkEQcWopAAA3ABAgACAFNwAAIABBGEEIIAkgESAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEIQRggDxtqKQAANwAYIAAgBTcACCAAQShBICALIA0gBigCACgCABECAEEASCIPG2opAAAhBSAAIABBIEEoIA8baikAADcAKCAAIAU3ACAgAEHAAEE4IBQgEyAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEE4QcAAIA8baikAADcAQCAAIAU3ADggAEEgQQggDSARIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQQhBICAPG2opAAA3ACAgACAFNwAIIABBMEEYIAwgCSAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEYQTAgDxtqKQAANwAwIAAgBTcAGCAAQThBKCATIAsgBigCACgCABECAEEASCIPG2opAAAhBSAAIABBKEE4IA8baikAADcAOCAAIAU3ACggACARIAAgBigCACgCABECACIPQRx2QQhxaikAACEFIAAgACAPQX9zQRx2QQhxaikAADcACCAAIAU3AAAgAEEgQRAgDSAOIAYoAgAoAgARAgBBAEgiDxtqKQAAIQUgACAAQRBBICAPG2opAAA3ACAgACAFNwAQIABBKEEYIAsgCSAGKAIAKAIAEQIAQQBIIg8baikAACEFIAAgAEEYQSggDxtqKQAANwAoIAAgBTcAGCAAQcAAQTAgFCAMIAYoAgAoAgARAgBBAEgiFBtqKQAAIQUgACAAQTBBwAAgFBtqKQAANwBAIAAgBTcAMCAAQRhBECAJIA4gBigCACgCABECAEEASCIUG2opAAAhBSAAIABBEEEYIBQbaikAADcAGCAAIAU3ABAgAEEoQSAgCyANIAYoAgAoAgARAgBBAEgiFBtqKQAAIQUgACAAQSBBKCAUG2opAAA3ACggACAFNwAgIABBOEEwIBMgDCAGKAIAKAIAEQIAQQBIIhMbaikAACEFIAAgAEEwQTggExtqKQAANwA4IAAgBTcAMCAAQRBBCCAOIBEgBigCACgCABECAEEASCIOG2opAAAhBSAAIABBCEEQIA4baikAADcAECAAIAU3AAggAEEgQRggDSAJIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQRhBICAJG2opAAA3ACAgACAFNwAYIABBMEEoIAwgCyAGKAIAKAIAEQIAQQBIIgYbaikAACEFIAAgAEEoQTAgBhtqKQAANwAwIAAgBTcAKAwBCwALQQkMAQsCQCACQQ1PBEAgACAAQeAAaiISIAAgBCgCACIGKAIAKAIAEQIAIglBH3VB4ABxaikAACEFIAAgAEHgAEEAIAlBAE4baikAADcAYCAAIAU3AAAgAEHQAEEIIABB0ABqIgwgAEEIaiIWIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQQhB0AAgCRtqKQAANwBQIAAgBTcACCAAQcgAQRAgAEHIAGoiCyAAQRBqIhQgBigCACgCABECAEEASCIJG2opAAAhBSAAIABBEEHIACAJG2opAAA3AEggACAFNwAQIABBOEEYIABBOGoiDyAAQRhqIg0gBigCACgCABECAEEASCIJG2opAAAhBSAAIABBGEE4IAkbaikAADcAOCAAIAU3ABggAEHYAEEoIABB2ABqIhUgAEEoaiIOIAYoAgAoAgARAgBBAEgiCRtqKQAAIQUgACAAQShB2AAgCRtqKQAANwBYIAAgBTcAKCAAQcAAQTAgAEFAayITIABBMGoiCSAGKAIAKAIAEQIAQQBIIhEbaikAACEFIAAgAEEwQcAAIBEbaikAADcAQCAAIAU3ADAgAEEwQQggCSAWIAYoAgAoAgARAgBBAEgiERtqKQAAIQUgACAAQQhBMCARG2opAAA3ADAgACAFNwAIIABBGEEQIA0gFCAGKAIAKAIAEQIAQQBIIhEbaikAACEFIAAgAEEQQRggERtqKQAANwAYIAAgBTcAECAAQdgAQSAgFSAAQSBqIhEgBigCACgCABECAEEASCIQG2opAAAhBSAAIABBIEHYACAQG2opAAA3AFggACAFNwAgIABByABBOCALIA8gBigCACgCABECAEEASCIQG2opAAAhBSAAIABBOEHIACAQG2opAAA3AEggACAFNwA4IABB0ABBwAAgDCATIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQcAAQdAAIBAbaikAADcAUCAAIAU3AEAgACARIAAgBigCACgCABECACIQQRp2QSBxaikAACEFIAAgACAQQX9zQRp2QSBxaikAADcAICAAIAU3AAAgAEEQQQggFCAWIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQQhBECAQG2opAAA3ABAgACAFNwAIIABBMEEYIAkgDSAGKAIAKAIAEQIAQQBIIhAbaikAACEFIAAgAEEYQTAgEBtqKQAANwAwIAAgBTcAGCAAQcAAQTggEyAPIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQThBwAAgEBtqKQAANwBAIAAgBTcAOCAAQdAAQcgAIAwgCyAGKAIAKAIAEQIAQQBIIhAbaikAACEFIAAgAEHIAEHQACAQG2opAAA3AFAgACAFNwBIIABB4ABB2AAgEiAVIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQdgAQeAAIBAbaikAADcAYCAAIAU3AFggAEEwQSAgCSARIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQSBBMCAQG2opAAA3ADAgACAFNwAgIABByABBKCALIA4gBigCACgCABECAEEASCIQG2opAAAhBSAAIABBKEHIACAQG2opAAA3AEggACAFNwAoIABB2ABBwAAgFSATIAYoAgAoAgARAgBBAEgiEBtqKQAAIQUgACAAQcAAQdgAIBAbaikAADcAWCAAIAU3AEAgAEHgAEHQACASIAwgBigCACgCABECAEEASCISG2opAAAhBSAAIABB0ABB4AAgEhtqKQAANwBgIAAgBTcAUCAAIA4gACAGKAIAKAIAEQIAIhJBH3VBKHFqKQAAIQUgACAAQShBACASQQBOG2opAAA3ACggACAFNwAAIABBwABBGCATIA0gBigCACgCABECAEEASCISG2opAAAhBSAAIABBGEHAACASG2opAAA3AEAgACAFNwAYIABBOEEgIA8gESAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEEgQTggEhtqKQAANwA4IAAgBTcAICAAQdgAQTAgFSAJIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQTBB2AAgEhtqKQAANwBYIAAgBTcAMCAAQdAAQcgAIAwgCyAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEHIAEHQACASG2opAAA3AFAgACAFNwBIIAAgFiAAIAYoAgAoAgARAgAiEkEcdkEIcWopAAAhBSAAIAAgEkF/c0EcdkEIcWopAAA3AAggACAFNwAAIABBKEEQIA4gFCAGKAIAKAIAEQIAQQBIIhIbaikAACEFIAAgAEEQQSggEhtqKQAANwAoIAAgBTcAECAAQcgAQTAgCyAJIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQTBByAAgEhtqKQAANwBIIAAgBTcAMCAAQcAAQTggEyAPIAYoAgAoAgARAgBBAEgiEhtqKQAAIQUgACAAQThBwAAgEhtqKQAANwBAIAAgBTcAOCAAQdgAQdAAIBUgDCAGKAIAKAIAEQIAQQBIIhUbaikAACEFIAAgAEHQAEHYACAVG2opAAA3AFggACAFNwBQIABBGEEIIA0gFiAGKAIAKAIAEQIAQQBIIhUbaikAACEFIAAgAEEIQRggFRtqKQAANwAYIAAgBTcACCAAQSBBECARIBQgBigCACgCABECAEEASCIVG2opAAAhBSAAIABBEEEgIBUbaikAADcAICAAIAU3ABAgAEEwQSggCSAOIAYoAgAoAgARAgBBAEgiFRtqKQAAIQUgACAAQShBMCAVG2opAAA3ADAgACAFNwAoIABB0ABByAAgDCALIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQcgAQdAAIAwbaikAADcAUCAAIAU3AEggAEEQQQggFCAWIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQQhBECAMG2opAAA3ABAgACAFNwAIIABBIEEYIBEgDSAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEYQSAgDBtqKQAANwAgIAAgBTcAGCAAQThBKCAPIA4gBigCACgCABECAEEASCIMG2opAAAhBSAAIABBKEE4IAwbaikAADcAOCAAIAU3ACggAEHAAEEwIBMgCSAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEwQcAAIAwbaikAADcAQCAAIAU3ADAgAEEYQRAgDSAUIAYoAgAoAgARAgBBAEgiDBtqKQAAIQUgACAAQRBBGCAMG2opAAA3ABggACAFNwAQIABBKEEgIA4gESAGKAIAKAIAEQIAQQBIIgwbaikAACEFIAAgAEEgQSggDBtqKQAANwAoIAAgBTcAICAAQThBMCAPIAkgBigCACgCABECAEEASCIMG2opAAAhBSAAIABBMEE4IAwbaikAADcAOCAAIAU3ADAgAEHIAEHAACALIBMgBigCACgCABECAEEASCILG2opAAAhBSAAIABBwABByAAgCxtqKQAANwBIIAAgBTcAQCAAQSBBGCARIA0gBigCACgCABECAEEASCILG2opAAAhBSAAIABBGEEgIAsbaikAADcAICAAIAU3ABggAEEwQSggCSAOIAYoAgAoAgARAgBBAEgiBhtqKQAAIQUgACAAQShBMCAGG2opAAA3ADAgACAFNwAoDAELAAtBDQsiBkEBayACTw0CIAIgBkcEQCAGQQN0IQYgAkEDdCECA0AgACAAIAZqIAQQwR4gAiAGQQhqIgZHDQALCyAYDQEgACADRiAIIQIgCiEADQALIAFBA3RBCGsiCCAHIgJqIQkgCCADIgBqIQogACABQQF2IgtBA3RqIghBCGshBiAEKAIAIQQDQCACIAAgCCAIIAAgBCgCACgCABECACINQQBOIg4bKQAANwAAIAkgCiAGIAogBiAEKAIAKAIAEQIAIhNBAE4bKQAANwAAIAAgDkEDdGohACAIIA1BHHZBCHFqIQggBiATQR91Ig1BA3RqIQYgCiANQX9zQQN0aiEKIAlBCGshCSACQQhqIQIgC0EBayILDQALIAZBCGohBCABQQFxBH8gAiAAIAggACAESSICGykAADcAACAIIAAgBE9BA3RqIQggACACQQN0agUgAAsgBEcgCCAKQQhqR3IEQBDkKwALIAFBA3QiAEUNACADIAcgAPwKAAALIAdBgAJqJAAMAQsACwsgF0EQaiQAC+UwARR/IwBBEGsiFyQAAkAgAUEhTwRAIANBAWshAwNAIANBf0YEQCABIgIgAkEBdmoiBgRAIAQoAgAhBANAAkACfyACIAZBAWsiBk0EQCAGIAJrDAELIAAoAAAhASAAIAAgBkECdGoiAygAADYAACADIAE2AABBAAsiA0EBdCIHQQFyIgEgAiAGIAIgBkkbIgxPDQADQCAHQQJqIgcgDEkEQCAAIAFBAnRqIAAgB0ECdGogBCgCACgCABECAEEfdiABaiEBCyAAIANBAnRqIgMgACABQQJ0aiIHIAQoAgAoAgARAgBBAE4NASADKAAAIQUgAyAHKAAANgAAIAcgBTYAACABIQMgAUEBdCIHQQFyIgEgDEkNAAsLIAYNAAsLDAMLIAAgAUEDdiIMQRxsaiEGIAAgDEEEdGohBwJ/IAFBwABPBEAgACAHIAYgDCAEEMoYDAELIAAgACAHIAQoAgAiDCgCACgCABECACIFIAAgBiAMKAIAKAIAEQIAc0EASA0AGiAGIAcgByAGIAwoAgAoAgARAgAgBXNBAEgbCyAAayIHQQJ2IQYCQAJAIAJFDQAgAiAAIAdqIAQoAgAoAgAoAgARAgBBAEgNACAXIAQ2AgwCf0EAIAFFDQAaIBdBDGohAgJAIAEgBk0NACAAKAAAIQcgACAAIAZBAnRqIgYoAAA2AAAgBiAHNgAAIABBBGohByMAQRBrIgUkACABQQFrIg0EfyAFIAcoAAA2AgwgAigCACEJQQAhDCAHIgZBBGoiAiAGIA1BAnRqIg1BBGsiEEkEQCAGIQIDQCAAIAJBBGoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIAxBAnRqIgYoAAA2AAAgBiAKKAAANgAAIAAgAkEIaiIGIAkoAgAoAgAoAgARAgAhFSAKIAcgDCASQX9zQR92aiIMQQJ0aiIKKAAANgAAIAogBigAADYAACAMIBVBf3NBH3ZqIQwgAkEMaiAGIQIgEEkNAAsgBkEEaiECCyACIA1HBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAMQQJ0aiIGKAAANgAAIAYgAigAADYAACAMIApBf3NBH3ZqIQwgAiIGQQRqIgIgDUcNAAsgAkEEayEGCyAAIAVBDGogCSgCACgCACgCABECACECIAYgByAMQQJ0aiIGKAAANgAAIAYgBSgCDDYAACAMIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgACgAACEGIAAgACACQQJ0aiIHKAAANgAAIAcgBjYAACACDAELAAsiBkEBaiECIAEgBksEQCABIAJrIQEgACACQQJ0aiEAQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAoAAAhByAAIAAgBkECdGoiBigAADYAACAGIAc2AAAgAEEEaiEMIwBBEGsiCSQAIAFBAWsiCgR/IAkgDCgAADYCDCAEKAIAIQ1BACEFIAwiB0EEaiIGIAcgCkECdGoiCkEEayISSQRAIAchBgNAIAZBBGoiECAAIA0oAgAoAgARAgAhFSAGIAwgBUECdGoiBygAADYAACAHIBAoAAA2AAAgBkEIaiIHIAAgDSgCACgCABECACAQIAwgFUEfdiAFaiIFQQJ0aiIQKAAANgAAIBAgBygAADYAAEEfdiAFaiEFIAZBDGogByEGIBJJDQALIAZBBGohBgsgBiAKRwRAA0AgBiAAIA0oAgAoAgARAgAgByAMIAVBAnRqIgcoAAA2AAAgByAGKAAANgAAQR92IAVqIQUgBiEHIAZBBGoiBiAKRw0ACyAGQQRrIQcLIAlBDGogACANKAIAKAIAEQIAIAcgDCAFQQJ0aiIHKAAANgAAIAcgCSgCDDYAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAoAAAhByAAIAAgBkECdGoiDCgAADYAACAMIAc2AAAgBgwBCwALIgYgAiADIAQQuQ4gASAGQX9zaiEBIAAgBkECdGoiAkEEaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBgAFrIgYkAAJAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIMIAFBEkkiGBshAiABIAxrIQcgACAMQQJ0aiEMA0ACfyACQQxNBEBBASACQQhNDQEaAkAgAkEJTwRAIAAgAEEMaiIJIAAgBCgCACIFKAIAKAIAEQIAIg1BH3VBDHFqKAAAIQogACAAQQxBACANQQBOG2ooAAA2AAwgACAKNgAAIABBHEEEIABBHGoiEiAAQQRqIhUgBSgCACgCABECAEEASCING2ooAAAhCiAAIABBBEEcIA0baigAADYAHCAAIAo2AAQgAEEUQQggAEEUaiINIABBCGoiECAFKAIAKAIAEQIAQQBIIgobaigAACEOIAAgAEEIQRQgChtqKAAANgAUIAAgDjYACCAAQSBBECAAQSBqIhMgAEEQaiIKIAUoAgAoAgARAgBBAEgiDhtqKAAAIQsgACAAQRBBICAOG2ooAAA2ACAgACALNgAQIAAgEiAAIAUoAgAoAgARAgAiDkEfdUEccWooAAAhCyAAIABBHEEAIA5BAE4baigAADYAHCAAIAs2AAAgAEEQQQggCiAQIAUoAgAoAgARAgBBAEgiDhtqKAAAIQsgACAAQQhBECAOG2ooAAA2ABAgACALNgAIIABBIEEMIBMgCSAFKAIAKAIAEQIAQQBIIg4baigAACELIAAgAEEMQSAgDhtqKAAANgAgIAAgCzYADCAAQRhBFCAAQRhqIg4gDSAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEUQRggCxtqKAAANgAYIAAgDzYAFCAAIBAgACAFKAIAKAIAEQIAIgtBHHZBCHFqKAAAIQ8gACAAIAtBf3NBHHZBCHFqKAAANgAIIAAgDzYAACAAQQxBBCAJIBUgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBBEEMIAsbaigAADYADCAAIA82AAQgAEEUQRAgDSAKIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQRBBFCALG2ooAAA2ABQgACAPNgAQIABBIEEcIBMgEiAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEcQSAgCxtqKAAANgAgIAAgDzYAHCAAQRBBBCAKIBUgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBBEEQIAsbaigAADYAECAAIA82AAQgAEEYQQwgDiAJIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQQxBGCALG2ooAAA2ABggACAPNgAMIABBHEEUIBIgDSAFKAIAKAIAEQIAQQBIIgsbaigAACEPIAAgAEEUQRwgCxtqKAAANgAcIAAgDzYAFCAAIBUgACAFKAIAKAIAEQIAIgtBHXZBBHFqKAAAIQ8gACAAIAtBf3NBHXZBBHFqKAAANgAEIAAgDzYAACAAQRBBCCAKIBAgBSgCACgCABECAEEASCILG2ooAAAhDyAAIABBCEEQIAsbaigAADYAECAAIA82AAggAEEUQQwgDSAJIAUoAgAoAgARAgBBAEgiCxtqKAAAIQ8gACAAQQxBFCALG2ooAAA2ABQgACAPNgAMIABBIEEYIBMgDiAFKAIAKAIAEQIAQQBIIhMbaigAACELIAAgAEEYQSAgExtqKAAANgAgIAAgCzYAGCAAQQxBCCAJIBAgBSgCACgCABECAEEASCITG2ooAAAhCyAAIABBCEEMIBMbaigAADYADCAAIAs2AAggAEEUQRAgDSAKIAUoAgAoAgARAgBBAEgiExtqKAAAIQsgACAAQRBBFCATG2ooAAA2ABQgACALNgAQIABBHEEYIBIgDiAFKAIAKAIAEQIAQQBIIhIbaigAACETIAAgAEEYQRwgEhtqKAAANgAcIAAgEzYAGCAAQQhBBCAQIBUgBSgCACgCABECAEEASCIQG2ooAAAhEiAAIABBBEEIIBAbaigAADYACCAAIBI2AAQgAEEQQQwgCiAJIAUoAgAoAgARAgBBAEgiCRtqKAAAIQogACAAQQxBECAJG2ooAAA2ABAgACAKNgAMIABBGEEUIA4gDSAFKAIAKAIAEQIAQQBIIgUbaigAACEJIAAgAEEUQRggBRtqKAAANgAYIAAgCTYAFAwBCwALQQkMAQsCQCACQQ1PBEAgACAAQTBqIhEgACAEKAIAIgUoAgAoAgARAgAiCUEfdUEwcWooAAAhDSAAIABBMEEAIAlBAE4baigAADYAMCAAIA02AAAgAEEoQQQgAEEoaiIOIABBBGoiDyAFKAIAKAIAEQIAQQBIIgkbaigAACENIAAgAEEEQSggCRtqKAAANgAoIAAgDTYABCAAQSRBCCAAQSRqIg0gAEEIaiITIAUoAgAoAgARAgBBAEgiCRtqKAAAIQogACAAQQhBJCAJG2ooAAA2ACQgACAKNgAIIABBHEEMIABBHGoiCyAAQQxqIgogBSgCACgCABECAEEASCIJG2ooAAAhECAAIABBDEEcIAkbaigAADYAHCAAIBA2AAwgAEEsQRQgAEEsaiIWIABBFGoiECAFKAIAKAIAEQIAQQBIIgkbaigAACESIAAgAEEUQSwgCRtqKAAANgAsIAAgEjYAFCAAQSBBGCAAQSBqIhIgAEEYaiIJIAUoAgAoAgARAgBBAEgiFRtqKAAAIQggACAAQRhBICAVG2ooAAA2ACAgACAINgAYIABBGEEEIAkgDyAFKAIAKAIAEQIAQQBIIhUbaigAACEIIAAgAEEEQRggFRtqKAAANgAYIAAgCDYABCAAQQxBCCAKIBMgBSgCACgCABECAEEASCIVG2ooAAAhCCAAIABBCEEMIBUbaigAADYADCAAIAg2AAggAEEsQRAgFiAAQRBqIhUgBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBEEEsIAgbaigAADYALCAAIBQ2ABAgAEEkQRwgDSALIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQRxBJCAIG2ooAAA2ACQgACAUNgAcIABBKEEgIA4gEiAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEgQSggCBtqKAAANgAoIAAgFDYAICAAIBUgACAFKAIAKAIAEQIAIghBG3ZBEHFqKAAAIRQgACAAIAhBf3NBG3ZBEHFqKAAANgAQIAAgFDYAACAAQQhBBCATIA8gBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBBEEIIAgbaigAADYACCAAIBQ2AAQgAEEYQQwgCSAKIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQQxBGCAIG2ooAAA2ABggACAUNgAMIABBIEEcIBIgCyAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEcQSAgCBtqKAAANgAgIAAgFDYAHCAAQShBJCAOIA0gBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBJEEoIAgbaigAADYAKCAAIBQ2ACQgAEEwQSwgESAWIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQSxBMCAIG2ooAAA2ADAgACAUNgAsIABBGEEQIAkgFSAFKAIAKAIAEQIAQQBIIggbaigAACEUIAAgAEEQQRggCBtqKAAANgAYIAAgFDYAECAAQSRBFCANIBAgBSgCACgCABECAEEASCIIG2ooAAAhFCAAIABBFEEkIAgbaigAADYAJCAAIBQ2ABQgAEEsQSAgFiASIAUoAgAoAgARAgBBAEgiCBtqKAAAIRQgACAAQSBBLCAIG2ooAAA2ACwgACAUNgAgIABBMEEoIBEgDiAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEoQTAgERtqKAAANgAwIAAgCDYAKCAAIBAgACAFKAIAKAIAEQIAIhFBH3VBFHFqKAAAIQggACAAQRRBACARQQBOG2ooAAA2ABQgACAINgAAIABBIEEMIBIgCiAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEMQSAgERtqKAAANgAgIAAgCDYADCAAQRxBECALIBUgBSgCACgCABECAEEASCIRG2ooAAAhCCAAIABBEEEcIBEbaigAADYAHCAAIAg2ABAgAEEsQRggFiAJIAUoAgAoAgARAgBBAEgiERtqKAAAIQggACAAQRhBLCARG2ooAAA2ACwgACAINgAYIABBKEEkIA4gDSAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEkQSggERtqKAAANgAoIAAgCDYAJCAAIA8gACAFKAIAKAIAEQIAIhFBHXZBBHFqKAAAIQggACAAIBFBf3NBHXZBBHFqKAAANgAEIAAgCDYAACAAQRRBCCAQIBMgBSgCACgCABECAEEASCIRG2ooAAAhCCAAIABBCEEUIBEbaigAADYAFCAAIAg2AAggAEEkQRggDSAJIAUoAgAoAgARAgBBAEgiERtqKAAAIQggACAAQRhBJCARG2ooAAA2ACQgACAINgAYIABBIEEcIBIgCyAFKAIAKAIAEQIAQQBIIhEbaigAACEIIAAgAEEcQSAgERtqKAAANgAgIAAgCDYAHCAAQSxBKCAWIA4gBSgCACgCABECAEEASCIWG2ooAAAhESAAIABBKEEsIBYbaigAADYALCAAIBE2ACggAEEMQQQgCiAPIAUoAgAoAgARAgBBAEgiFhtqKAAAIREgACAAQQRBDCAWG2ooAAA2AAwgACARNgAEIABBEEEIIBUgEyAFKAIAKAIAEQIAQQBIIhYbaigAACERIAAgAEEIQRAgFhtqKAAANgAQIAAgETYACCAAQRhBFCAJIBAgBSgCACgCABECAEEASCIWG2ooAAAhESAAIABBFEEYIBYbaigAADYAGCAAIBE2ABQgAEEoQSQgDiANIAUoAgAoAgARAgBBAEgiDhtqKAAAIRYgACAAQSRBKCAOG2ooAAA2ACggACAWNgAkIABBCEEEIBMgDyAFKAIAKAIAEQIAQQBIIg4baigAACEPIAAgAEEEQQggDhtqKAAANgAIIAAgDzYABCAAQRBBDCAVIAogBSgCACgCABECAEEASCIOG2ooAAAhDyAAIABBDEEQIA4baigAADYAECAAIA82AAwgAEEcQRQgCyAQIAUoAgAoAgARAgBBAEgiDhtqKAAAIQ8gACAAQRRBHCAOG2ooAAA2ABwgACAPNgAUIABBIEEYIBIgCSAFKAIAKAIAEQIAQQBIIg4baigAACEPIAAgAEEYQSAgDhtqKAAANgAgIAAgDzYAGCAAQQxBCCAKIBMgBSgCACgCABECAEEASCIOG2ooAAAhEyAAIABBCEEMIA4baigAADYADCAAIBM2AAggAEEUQRAgECAVIAUoAgAoAgARAgBBAEgiDhtqKAAAIRMgACAAQRBBFCAOG2ooAAA2ABQgACATNgAQIABBHEEYIAsgCSAFKAIAKAIAEQIAQQBIIg4baigAACETIAAgAEEYQRwgDhtqKAAANgAcIAAgEzYAGCAAQSRBICANIBIgBSgCACgCABECAEEASCING2ooAAAhEiAAIABBIEEkIA0baigAADYAJCAAIBI2ACAgAEEQQQwgFSAKIAUoAgAoAgARAgBBAEgiDRtqKAAAIQogACAAQQxBECANG2ooAAA2ABAgACAKNgAMIABBGEEUIAkgECAFKAIAKAIAEQIAQQBIIgUbaigAACEJIAAgAEEUQRggBRtqKAAANgAYIAAgCTYAFAwBCwALQQ0LIgVBAWsgAk8NAiACIAVHBEAgBUECdCEFIAJBAnQhAgNAIAAgACAFaiAEEL4eIAIgBUEEaiIFRw0ACwsgGA0BIAAgA0YgByECIAwhAA0ACyABQQJ0QQRrIgcgBiICaiEJIAcgAyIAaiEMIAAgAUEBdiINQQJ0aiIHQQRrIQUgBCgCACEEA0AgAiAAIAcgByAAIAQoAgAoAgARAgAiCkEATiIQGygAADYAACAJIAwgBSAMIAUgBCgCACgCABECACISQQBOGygAADYAACAAIBBBAnRqIQAgByAKQR12QQRxaiEHIAUgEkEfdSIKQQJ0aiEFIAwgCkF/c0ECdGohDCAJQQRrIQkgAkEEaiECIA1BAWsiDQ0ACyAFQQRqIQQgAUEBcQR/IAIgACAHIAAgBEkiAhsoAAA2AAAgByAAIARPQQJ0aiEHIAAgAkECdGoFIAALIARHIAcgDEEEakdyBEAQ5CsACyABQQJ0IgBFDQAgAyAGIAD8CgAACyAGQYABaiQADAELAAsLIBdBEGokAAviAgEJf0EBIQcCQCABQQFGDQAgAC0AACEIAkAgAUEPcSIEBEAgACAEaiEFIAAiAkEBaiIJIQMCfwJAIARBBU8EQCACKAAAIgIgACgAASIDRw0BIAVBA2shCkEAIQMCQANAIAAgA2oiAkEFaiIGIApPDQEgA0EEaiEDIAJBBGooAAAiAiAGKAAAIgZGDQALIAIgBnNoQQN2IANqDAMLIAJBBWohAyACQQRqIQILAkAgAyAFQQFrTw0AIAIvAAAgAy8AAEcNACACQQJqIQIgA0ECaiEDCyADIAVJBH8gAyACLQAAIAMtAABGagUgAwsgCWsMAQsgAiADc2hBA3YLIARBAWtHDQELIAhBgYKECGwhAyAAIARqIQIDQCABIARGDQJBACEAA0AgAEEPTQRAIAAgAmohBSAAQQRqIQAgAyAFKAAARg0BDAMLCyACQRBqIQIgBEEQaiEEDAALAAtBACEHCyAHC5YDAQN/IwBBMGsiAyQAAkACQCABQf//A3EgAkH//wNxRgRAIAAtADpBAUcNAQsgAEECIAAoAjQiAiACQQJNGzYCNCAAQTBqIQQCQCAAKAIwIgVBAXEiAiAAKAIIIAVrTQ0AIAAoAgggACgCMGsgAk8NAANAIAAQ+xYgACgCCCAAKAIwayACSQ0ACwsgBCACEI03IAAoAgggACgCMGtBAUsiAiACckUEQANAIAAQ+xYgACgCCCAAKAIwa0ECSQ0ACwsgBEECEI03IANBEGogABDcOyADKAIUIQIgAygCECEEIANBCGogACgCMBCMNyADIAQgAiADKAIIIAMoAgxBsLf+ABDXJiADKAIEQQFNDQEgAygCACABOwAAIAAoAjAhAiAAKAIUIgEgACgCDEYEQCAAQQxqQbi2/gAQmygLIAAoAhAgAUEDdGoiBEEEOwEEIAQgAjYCACAAIAFBAWo2AhQLIANBMGokAA8LIANBADYCKCADQQE2AhwgA0Hst/4ANgIYIANCBDcCICADQRhqQcC3/gAQ7ywAC5UDAQR/IwBBMGsiAiQAIAAoAgAhAAJAAkAgAUH//wNxBEAgAC0AOkEBRw0BCyAAQQIgACgCNCIDIANBAk0bNgI0IABBMGohBAJAIAAoAjAiBUEBcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EBSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQJJDQALCyAEQQIQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGwt/4AENcmIAIoAgRBAU0NASACKAIAIAE7AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQey3/gA2AhggAkIENwIgIAJBGGpBwLf+ABDvLAALmwMCA38BfiMAQeAAayICJAACQAJAAkAgACgCBCgCECABQQN0aikDACIFQoCAgIAIfEL/////D1YNACACIAAoAgAiBCgCACgCACgCACIDNgIgIAIgBT4CHAJAIAUgA6x+IgVCIIinIAWnIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIFNwMIIAWnQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuBBgELfyMAQSBrIgckAAJAAkACQAJAAkACQAJAAkAgAy0AAEEUaw4KAQACAAMEAAAABQALIAIEQANAIAEoAgAgAUEEaigCACgCJBEEACAEaiEEIAFBCGohASACQQFrIgINAAsLIABBhYCAgHg2AgAgACAENgIEDAULIAAgASACEK8YDAQLIAAgASACEK4YDAMLIAAgASACELAYDAILIAAgASACEK0YDAELIAIEQCABIQQgAiEGA0AgBCgCACAEQQRqKAIAKAIkEQQAIAhqIQggBEEIaiEEIAZBAWsiBg0ACwsgAygCCCIMLQAwIgNBHU1BAEEBIAN0QYCAwJoCcRtFBEAgAEGFgICAeDYCACAAIAg2AgQMAQsjAEEgayIDJAAgA0EUaiABIAJBA3RqIgIgAWtBA3ZBAEEEQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxB0MiCARD9LwALIAdBBGohCSADQRBqIg1BADYCACADIAMoAhw2AgwgAyAENgIIIwBBEGsiBiQAIAIgAWtBA3YiCiADQQhqIgUoAgAgBSgCCCIEa0sEQCAFIAQgCkEEQQgQ3iggBSgCCCEECyAGIAUoAgQ2AgwgBiAENgIIIAYgBUEIajYCBCAGQQRqIgQoAgQhBSAEKAIAIAEgAkcEQCAEKAIIIAVBA3RqIQQgBSACIAFrQQN2IgJqIQUDQCABKAIAIAFBBGooAgAQxi8iCygCDCEOIARBBGogCygCECILNgIAIAQgDiALKAIIQQFrQXhxakEIajYCACABQQhqIQEgBEEIaiEEIAJBAWsiAg0ACwsgBTYCACAGQRBqJAAgCUEIaiANKAIANgIAIAkgAykCCDcCACADQSBqJAAgB0EQaiAHKAIIIAcoAgwgDEEwahC+DkEQQQQQrTYiAUUNASABIAcpAhA3AgAgAUEIaiAHQRhqKQIANwIAIAAgATYCCCAAIAg2AgQgAEGCgICAeDYCACAJQQRBCBDgHgsgB0EgaiQADwtBBEEQEKM9AAuKAwEFfyMAQRBrIgckACAHQQhqIAEQhj0gBygCDCEIIAcoAggiCUEIEPgvIQUCQAJAAkACQAJAIAMgAyAEaiIGQQFqIgRNBEAgBCAAKAIEIgJLDQEgAUEIIAUgCWogBSAISyIJG0EAIAggBWtBA3YgCRtBA3RqQQhrKQMAIAAoAgAiBSADQQN0aiIIIAQgA2sQ+BMgAiADTQ0CIAIgBk0NBSAFIAZBA3RqKAIAIgIgCCgCACIDSQ0DIAAoAgwiBCACSQ0EIAAoAgghBCABKAIcIgAgAiADayICaiIFIAEoAhQiBksEQCABQRBqIAZBAXQiACAFEN4qIgUgACAFSxsQ6BkgASgCHCEACyACBEAgASgCGCAAaiADIARqIAL8CgAACyABIAEoAhwgAmo2AhwgB0EQaiQADwsgAyAEQfSjhwEQsTsACyAEIAJB9KOHARCwOwALIAMgAkGEo4cBEMMhAAsgAyACQaSjhwEQsTsACyACIARBpKOHARCwOwALIAYgAkGUo4cBEMMhAAuKAwEFfyMAQRBrIgckACAHQQhqIAEQhj0gBygCDCEIIAcoAggiCUEEEPgvIQUCQAJAAkACQAJAIAMgAyAEaiIGQQFqIgRNBEAgBCAAKAIEIgJLDQEgAUEEIAUgCWogBSAISyIJG0EAIAggBWtBAnYgCRtBAnRqQQRrKAIAIAAoAgAiBSADQQJ0aiIIIAQgA2sQ+RMgAiADTQ0CIAIgBk0NBSAFIAZBAnRqKAIAIgIgCCgCACIDSQ0DIAIgACgCDCIESw0EIAAoAgghBCABKAIcIgAgAiADayICaiIFIAEoAhQiBksEQCABQRBqIAZBAXQiACAFEN4qIgUgACAFSxsQ6BkgASgCHCEACyACBEAgASgCGCAAaiADIARqIAL8CgAACyABIAEoAhwgAmo2AhwgB0EQaiQADwsgAyAEQfSjhwEQsTsACyAEIAJB9KOHARCwOwALIAMgAkGEo4cBEMMhAAsgAyACQaSjhwEQsTsACyACIARBpKOHARCwOwALIAYgAkGUo4cBEMMhAAu8BAEKfyMAQRBrIgMkAAJ/AkACQANAAkAgAC0AACICQSJHBEACQAJAAkACQAJAAkACQAJAAkAgAkEbaw4NBAAGAQIHCA0NDQ0NAw0LIAEtAABBHEcNDAwECyABLQAAQR5HDQsMAwsgAS0AAEEfRw0KDAILIAEtAABBJ0YNBgwJCyABLQAAQRtHDQgLIAAoAgRBCGogASgCBEEIahDxCgwICyABLQAAQR1HDQYgACgCBCABKAIERw0FIAAoAghBCGogASgCCEEIahDxCgwHCyABLQAAQSBHDQUgAEEEaiABQQRqEM8cDAYLIAEtAABBIUcNBCAALQABIAEtAAFHDQMgACgCCCECIAMgACgCBEEIaiIANgIIIAMgACACQQN0ajYCDAJ/IAFBBGohAUEAIANBCGoiBCgCACIAIAQoAgQiB0YNABogASgCAEEMaiECIAEoAgQiBUEDdCEIIAVFIQYDQAJAIAQgAEEIaiIJNgIAIAVFDQAgACgCBEEIaiEKIAAtAAAhCyAIIQEgAiEAAkADQCAAQQRrLQAAIAtGBEAgCiAAKAIAQQhqEPEKDQILIABBCGohACABQQhrIgENAAtBASEGDAELIAkiACAHRw0BCwsgBgtBAXMMBQsgAS0AAEEiRw0DIAAoAgQgASgCBBDBDkUNAiABKAIIIQEgACgCCCEADAELCyAALQABIAEtAAFHDQAgACgCBEEIaiABKAIEQQhqEPEKDAILQQAMAQsgACABEMwICyADQRBqJAALjAMBC38jAEEgayICJAAgASgCICEDIAJBBGogASgCJCIEQQBBAUEBEKAYIAIoAgghBQJAAkACQCACKAIEQQFHBEAgAigCDCEGIAQEQCAGIAMgBPwKAAALIAEtACkhAyABLQAoIQwCQCABLQAUIgdBEUcEQCAHQQRrDgUDBAEBAwQLIAEoAgQhCCABKAIAIQkMBAsgAS0AFSEKIAEtABYhCwwCCyAFIAIoAgxB5KPPABD9LwALIAJBGGogAUEfai0AADoAACACIAEpABc3AxAgAS0AFiELIAEtABUhCgsgASgCBCEIIAEoAgAhCSADDQAgAUEUahCaEEH/AXEhAwsgACALOgAeIAAgCjoAHSAAIAc6ABwgACAENgIYIAAgBjYCFCAAIAU2AhAgACAINgIMIAAgCTYCCCAAQQI2AgQgACACKQMQNwAfIAAgASkCCDcCLCAAQTRqIAFBEGooAgA2AgAgAEEnaiACQRhqLQAAOgAAIAAgAzoAKSAAIAw6ACggAEEANgIAIAJBIGokAAvCBAEKfyMAQTBrIgckAAJAIAEpAwBCBFIEQCMAQTBrIgMkACADQQA2AhQgA0KAgICAIDcCDAJAAkAgAkUNAANAIANBDGoiBEGACCACIAhrIgUgBUGACE8bIgUQhS0gA0EYaiABIAQgBRCZECADKAIgIQQgAygCHCEFIAMoAhgiCUEIRwRAIAAgAykCJDcCDCAAQRRqIANBLGooAgA2AgAgACAENgIIIAAgBTYCBCAAIAk2AgAMAwsgBEUNASAFIAZqIQYgBCAIaiIIIAJJDQALCyAAIAg2AgggACAGNgIEIABBCDYCAAsgA0EMahCdPCADQTBqJAAMAQtBCCEIAkACQCACRQ0AIAFBCGohCwNAAkAgASgCHCIERQRAIAEoAiAiBCABKAIkIgZGBEAgASgCGCABKAIQRg0EIAcgCxD7CiAHKAIAIgRBCEYNAiAAIAcpAgQ3AgQgAEEUaiAHQRRqKAIANgIAIABBDGogB0EMaikCADcCACAEIQgMBQsgByABKAIMIAEoAhAgASgCGCIMQQN0IAZqIAIgA2siCSAEIAZrIgogCSAKSRsiCRDQCCAHENcjIQogASAGIAlqIgY2AiQgBCAGRgRAIAEgDCAEQQN2ajYCGAsgAyAJaiEDIAUgCmohBQwBCyABIAQgAiADayIGIAQgBCAGSxsiBGs2AhwgAyAEaiEDIARBACABLQAoGyAFaiEFCyACIANHDQALIAIhAwsgACADNgIIIAAgBTYCBAsgACAINgIACyAHQTBqJAALlgMBBH8jAEEwayICJAAgACgCACEAAkACQCABQf//A3FFBEAgAC0AOkEBRw0BCyAAQQIgACgCNCIDIANBAk0bNgI0IABBMGohBAJAIAAoAjAiBUEBcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EBSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQJJDQALCyAEQQIQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGsx/4AENcmIAIoAgRBAU0NASACKAIAIAE7AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALrwMBAn8jAEHQAGsiBCQAIAQgAzYCAAJAIAEoAhQiBSACTQRAIAQgAkEBajYCMCAEIAU2AjQgBEEDNgIcIARBuPmGATYCGCAEQgM3AiQgBEE7NgJMIARBOzYCRCAEQa0DNgI8IAQgAUEYajYCOCAEIARBOGo2AiAgBCAEQTRqNgJIIAQgBEEwajYCQCAEQQhqIARBGGoQmQ4gACAEKQIMNwIIIABBEGogBEEUaigCADYCACAAIAQoAgg2AgQgAEGNgICAeDYCAAwBCyADIAEoAhAgAkHEAGxqIgJBGGoiAxDJCARAIARBOGogAhC5ASAEKAI4IgFBk4CAgHhHBEAgAEEEaiICIAQpAjw3AgAgAkEIaiAEQcQAaikCADcCACAAIAE2AgAMAgsgAEGTgICAeDYCACAAIAI2AgQMAQsgBEEDNgIcIARB3PiGATYCGCAEQgM3AiQgBEGtAzYCTCAEIAM2AkggBEGnBDYCRCAEQa0DNgI8IAQgAUEYajYCOCAEIARBOGo2AiAgBCAENgJAIABBBGogBEEYahCZDiAAQY2AgIB4NgIACyAEQdAAaiQAC9UDAgV/AX4jAEHgAGsiAyQAAkAgAQJ/AkACQAJAAkACQAJAIAEtAAxBAWsOAwQBAAILIAEoAgghBSABKAIEIQQMAgsACyABKAIAIgQpAjghCCAEQoCAgIAQNwM4IANBGGogBEFAayIFKAIANgIAIAVBADYCACADIAg3AxAgA0E8aiADQRBqEOcVIANBADoAWCADIAQ2AjggA0EIaiEEIANBOGohBgJAQSRBBBCtNiIFBEAgBSAGQST8CgAAIARBjKTDADYCBCAEIAU2AgAMAQtBBEEkEKM9AAsgAygCCCEEIAEgAygCDCIFNgIIIAEgBDYCBAsgA0E4aiAEIAIgBSgCDBEBACADKAI4IgJBCUcNASAAQQk2AgBBAwwCC0G018IAEOgrAAsgA0EwaiIGIANBzABqKAIANgIAQQghBSADQShqIgcgA0HEAGopAgA3AwAgAyADKQI8NwMgIAFBBGoQvCogAkEIRwRAQRhBCBCtNiIERQ0CIAQgAjYCACAEIAMpAyA3AgQgBEEMaiAHKQMANwIAIARBFGogBigCADYCAEEFIQULIABB1NfCADYCCCAAIAQ2AgQgACAFNgIAQQELOgAMIANB4ABqJAAPC0EIQRgQoz0AC+gUAg5/AW8jAEEgayIIJAACQAJAAkACQAJAIAAtAJABQQFrDgMDAAIBCwALIABBzABqIABBxAD8CgAACyAIQRBqIQ4jAEEQayIKJAACQAJAIABBzABqIgMoAgAEQCABIQtBACEBIwBB4ABrIgQkAAJAAkACQCADKAIALQAUBEBBAiEHDAELIANBBGohDwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMtAEBBAWsOAwYCAQALIA8oAgAiASgCCA0WIAFBfzYCCCADIAFBCGo2AhAgAyABQQxqIgE2AgwgA0EAOgA8IAMgATYCFCADIAMoAggiBzYCGCADQTxqIQYMAwsgA0E8aiEGAkAgAy0APEEBaw4DCAEAAgsgAygCMCEBIAMoAjghByADKAI0IQIMAwsACyADKAIYIQcgAygCFCEBCyADIAc2AiAgAyABNgIcIAEoAgxFDQwgBEEgaiICIANBIGooAgAlARA3IgU2AgQgAiAFQQBHNgIAIAQoAiBBAXFFDQwgAyAEKAIkNgIkIARBGGoiAiADQSRqKAIAJQEQFSIFNgIEIAIgBUEARzYCACAEKAIYQQFxRQ0MIAMgBCgCHDYCKCADIANBKGooAgAlARBgIgc2AiwgAygCHCIMKAIIIgIgB0kEQCAMIAcgAmsiAhCILiAMKAIEIgUgDCgCCCIHaiEJAkACQCACQQJPBEAgAkEBayICBEAgCUEAIAL8CwALIAUgAiAHaiIHaiEJDAELIAJFDQELIAlBADoAACAHQQFqIQcLIAwgBzYCCCADKAIsIQcgAygCHCIMKAIIIQILIAIgB0kNAyAMKAIEIQIgAyAHNgI4IAMgAjYCNCADIAFBDGoiATYCMAsgBEHQAGogASgCACALIAIgByABKAIEKAIMEQcAIAQtAFAiBUEFRg0BIARBLmoiASAELQBTOgAAIAQgBC8AUTsBLCAEKAJUIQkCQAJAIAVBBEcEQCAEIAU6ADAgBCAELwEsOwAxIAQgCTYCNCAEIAEtAAA6ADMCQCADKAIcIgYoAgwiAkUNACAGKAIQIgUoAgAiAQRAIAIgAREDAAsgBSgCBCIBRQ0AIAIgASAFKAIIEPg6CyAGQQA2AgwgBhDeOyAGQQA2AgggBkKAgICAEDcCACAEQQA2AkwgBEKAgICAEDcCRCAEQdjewwA2AlQgBEKggICADjcCWCAEIARBxABqNgJQIARBMGogBEHQAGoQ1A4NByAEQUBrIARBzABqKAIAIgE2AgAgBCAEKQJENwM4IAQoAjwgARBGIRAQ3xIiASAQJgEgBEE4ahDeOyAELQAwQQNHDQEgBCgCNCIJKAIAIQYgCSgCBCICKAIAIgUEQCAGIAURAwALIAIoAgQiBQRAIAYgBSACKAIIEPg6CyAJQQxBBBD4OgwBCwJAIAlFBEACQCADKAIcIgYoAgwiAkUNACAGKAIQIgUoAgAiAQRAIAIgAREDAAsgBSgCBCIBRQ0AIAIgASAFKAIIEPg6CyAGQQA2AgwgBhDeOyAGQQA2AgggBkKAgICAEDcCACMAQRBrIgIkACADQSBqKAIAJQEQOCACQQhqEM4tIAIoAgwhBSAEQQhqIgEgAigCCEEBcTYCACABIAU2AgQgAkEQaiQAIAQoAghBAXFFDQEgBCgCDCEBDAILIANBKGoiASgCACUBEF8hEBDfEiIFIBAmASAEIAU2AlAgASgCACUBEGEhASAEQdAAaigCACUBIAEgCRBeIRAQ3xIiASAQJgEgBCABNgJEIAVBhAFPBEAgBRDyHwsgCSADKAIcIgUoAggiAUsNCCAFKAIEIQUjAEEgayIGJAAgBEHEAGooAgAiARCcPiECIAYgCTYCBCAGIAI2AgAgAiAJRwRAIAZBADYCCEEAIAYgBkEEaiAGQQhqQeSriAEQrysACyABJQEgBSAJEFkgBkEgaiQAIARBEGogA0EkaiAJEJopIAQoAhBBAXFFDQIgBCgCFCEBIAQoAkQiBUGEAUkNASAFEPIfDAELIAQgA0EkakEAEJopIAQoAgBBAXFFDQggBCgCBCEBCyADKAIoIgVBhAFPBEAgBRDyHwsgAygCJCIFQYQBTwRAIAUQ8h8LQQEhByADKAIgIgJBgwFLDQgMCQsgBCgCRCIBQYQBSQ0GIAEQ8h8MBgtBwODDABDoKwALQQMhAiAGQQM6AABBAiEHDAcLIAcgAkGA4MMAELA7AAtBkODDABDoKwALQYDfwwBBNyAEQThqQfDewwBBuN/DABDVHgALIAkgAUGg4MMAELA7AAsgAygCKCIBQYQBTwRAIAEQ8h8LIAMoAiQiAUGEAU8EQCABEPIfC0GAASEBQQAhByADKAIgIgJBgwFNDQELIAIQ8h8LQQEhAiADQQE6ADwgAygCECIFIAUoAgBBAWo2AgAgAygCBCIFIAUoAgBBAWsiBTYCACAFDQAgDxDfHwsgAyACOgBAIAdBAkcNACADKAIAQQhqIAsoAgAQixRBAkEDIAMoAgAtABQbIQcLIAogATYCBCAKIAc2AgAgBEHgAGokAAwBC0Hm2cMAQTEQlz0ACyAKKAIAIgVBA0YEf0ECBSADKAIARQ0CIAooAgQhCyAKIAM2AgwgCkEMaigCACICQQRqIQ0CQAJAAkAgAi0AQA4EAAICAQILIA0oAgAiASABKAIAQQFrIgE2AgAgAUUEQCANEN8fCyACKAIIIgFBhAFJDQEgARDyHwwBCwJAAkACQAJAIAItADwOBAADAwEDCyACKAIYIgFBgwFNDQIMAQsgAigCKCIBQYQBTwRAIAEQ8h8LIAIoAiQiAUGEAU8EQCABEPIfCyACKAIgIgFBgwFNDQELIAEQ8h8LIAIoAhAiASABKAIAQQFqNgIAIAIoAgQiASABKAIAQQFrIgE2AgAgAQ0AIA0Q3x8LIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAIQ6ScLIANBADYCAEGAASALIAVBAkYiARshDUEAIAUgARsLIQEgDiANNgIEIA4gATYCACAKQRBqJAAMAgtBqNjDAEE2QeDYwwAQnykAC0Hw18MAQShBmNjDABCfKQALQQMhAQJAAkAgCCgCECILQQJGIgoNACAIKAIUIQEgAxDfFAJAIAtBAXEEQCAIIAE2AhggCEGAATYCHCAIIABByABqIAhBHGogCEEYahDCIyAIKAIAQQFxDQUCQCAIKAIEIgFBhAFJDQAgARDyHyAIKAIcIgFBhAFJDQAgARDyHwsgCCgCGCIBQYQBSQ0BIAEQ8h8MAQsgCCABNgIYIAhBgAE2AhwgCEEIaiAAQcQAaiAIQRxqIAhBGGoQwiMgCCgCCEEBcQ0CAkAgCCgCDCIBQYQBSQ0AIAEQ8h8gCCgCHCIBQYQBSQ0AIAEQ8h8LIAgoAhgiAUGEAUkNACABEPIfCyAAKAJEIgFBhAFPBEAgARDyHwtBASEBIAAoAkgiC0GEAUkNACALEPIfCyAAIAE6AJABIAhBIGokACAKDwsMAQtB6N3DABDoKwALQdTbwwBBMRCXPQALlwwBC38jAEEgayIFJAACQAJAAkACQAJAIAAtAGhBAWsOAwMAAgELAAsgAEE4aiAAQTD8CgAACyAFQRBqIQsjAEEQayIJJAACQAJAIABBOGoiAigCAARAIwBBIGsiCCQAAkAgAigCAC0AFARAQQIhBwwBCyACQQRqIQwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAsQQFrDgMNAgEACyAMKAIAIgQoAggNFyAEQX82AgggAiAEQQhqNgIQIAIgBEEMaiIHNgIMIAJBADoAKCACIAc2AhQgAiACKAIIIgY2AhggAkEoaiEEDAMLIAJBKGohBAJAIAItAChBAWsOAwUBAAILIAIoAiQhBwwDCwALIAIoAhghBiACKAIUIQcLIAIgBjYCICACIAc2AhwgBygCAEUNCiACIAc2AiQLIAhBEGogBygCACABIAcoAgQoAgwRAQAgCCgCECIDQQJrDgICCAELQbDgwwAQ6CsACyAIKAIUIQQgA0EBcQ0DIAggBDYCHCMAQRBrIgMkACACQSBqKAIAJQEgCEEcaigCACUBEDogA0EIahDOLSADKAIMIQYgCCADKAIIQQFxNgIAIAggBjYCBCADQRBqJAAgCCgCAEEBcUUNASAIKAIEIQYgBEGEAUkNBCAEEPIfDAQLIAIoAhwQ1ykgAigCHEEANgIAIwBBEGsiAyQAIAJBIGooAgAlARA5IANBCGoQzi0gAygCDCEGIAhBCGoiBCADKAIIQQFxNgIAIAQgBjYCBCADQRBqJAAgCCgCCEEBcUUNASAIKAIMIQYMAwsgBEGEAUkNACAEEPIfC0GAASEGQQAhByACKAIgIgNBhAFJDQYMBQsgAigCHBDXKSACKAIcQQA2AgAgBCEGC0EBIQcgAigCICIDQYMBSw0DDAQLQdDgwwAQ6CsAC0EDIQMgBEEDOgAAQQIhBwwDC0Hm2cMAQTEQlz0ACyADEPIfC0EBIQMgAkEBOgAoIAIoAhAiBCAEKAIAQQFqNgIAIAIoAgQiBCAEKAIAQQFrIgQ2AgAgBA0AIAwQ1CILIAIgAzoALCAHQQJHDQAgAigCAEEIaiABKAIAEIsUQQJBAyACKAIALQAUGyEHCyAJIAY2AgQgCSAHNgIAIAhBIGokACAJKAIAIgZBA0YEf0ECBSACKAIARQ0CIAkoAgQhBCAJIAI2AgwgCUEMaigCACIDQQRqIQoCQAJAAkAgAy0ALA4EAAICAQILIAooAgAiASABKAIAQQFrIgE2AgAgAUUEQCAKENQiCyADKAIIIgFBhAFJDQEgARDyHwwBCwJAAkACQAJAIAMtACgOBAADAwEDCyADKAIYIgFBgwFNDQIMAQsgAygCICIBQYMBTQ0BCyABEPIfCyADKAIQIgEgASgCAEEBajYCACADKAIEIgEgASgCAEEBayIBNgIAIAENACAKENQiCyADKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCADEOknCyACQQA2AgBBgAEgBCAGQQJGIgEbIQpBACAGIAEbCyEBIAsgCjYCBCALIAE2AgAgCUEQaiQADAILQajYwwBBNkHg2MMAEJ8pAAtB8NfDAEEoQZjYwwAQnykAC0EDIQECQAJAIAUoAhAiCUECRiIEDQAgBSgCFCEBIAIQ0xYCQCAJQQFxBEAgBSABNgIYIAVBgAE2AhwgBSAAQTRqIAVBHGogBUEYahDCIyAFKAIAQQFxDQUCQCAFKAIEIgFBhAFJDQAgARDyHyAFKAIcIgFBhAFJDQAgARDyHwsgBSgCGCIBQYQBSQ0BIAEQ8h8MAQsgBSABNgIYIAVBgAE2AhwgBUEIaiAAQTBqIAVBHGogBUEYahDCIyAFKAIIQQFxDQICQCAFKAIMIgFBhAFJDQAgARDyHyAFKAIcIgFBhAFJDQAgARDyHwsgBSgCGCIBQYQBSQ0AIAEQ8h8LIAAoAjAiAUGEAU8EQCABEPIfC0EBIQEgACgCNCIJQYQBSQ0AIAkQ8h8LIAAgAToAaCAFQSBqJAAgBA8LDAELQejdwwAQ6CsAC0HU28MAQTEQlz0AC5gDAQJ/AkACQAJAAkACQAJAIAAoAgAiAUEfdSABQf////8Ha3EOBAECAwQACyAAKAIMIgIEQCAAKAIIIQEDQCABEOILIAFByABqIQEgAkEBayICDQALCyAAQQRqQQRByAAQ4B4gACgCFCIBRQ0EIAEgASgCACIBQQFrNgIAIAFBAUcNBCAAQRRqEPseDwsgABDCIA8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNAiABIAEoAgAiAUEBazYCACABQQFHDQIgAEEYahD7Hg8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAggiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBCGoQ+x4LIAAoAhgiAUUNASABIAEoAgAiAUEBazYCACABQQFHDQEgAEEYahD7Hg8LIAAoAgQQyQ4gACgCBEHIAEEEEPg6IAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahD7HgsLjwMBA38jAEEwayIEJAACQAJAIAIgA0YEQCAALQA6QQFHDQELIABBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEFAkBBACAAKAIwIgZrQQNxIgMgACgCCCAGa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAUgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIAVBBBCNNyAEQRBqIAAQ3DsgBCgCFCEDIAQoAhAhBSAEQQhqIAAoAjAQjDcgBCAFIAMgBCgCCCAEKAIMQbC3/gAQ1yYgBCgCBEEDTQ0BIAQoAgAgAjYAACAAKAIwIQMgACgCFCICIAAoAgxGBEAgAEEMakG4tv4AEJsoCyAAKAIQIAJBA3RqIgUgATsBBCAFIAM2AgAgACACQQFqNgIUCyAEQTBqJAAPCyAEQQA2AiggBEEBNgIcIARB7Lf+ADYCGCAEQgQ3AiAgBEEYakHAt/4AEO8sAAuNAwEEfyMAQTBrIgMkAAJAAkAgAlAEQCAALQA6QQFHDQELIABBCCAAKAI0IgQgBEEITRs2AjQgAEEwaiEFAkBBACAAKAIwIgZrQQdxIgQgACgCCCAGa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAUgBBCNNyAAKAIIIAAoAjBrQQdLIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMGtBCEkNAAsLIAVBCBCNNyADQRBqIAAQ3DsgAygCFCEEIAMoAhAhBSADQQhqIAAoAjAQjDcgAyAFIAQgAygCCCADKAIMQazH/gAQ1yYgAygCBEEHTQ0BIAMoAgAgAjcAACAAKAIwIQUgACgCFCIEIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIARBA3RqIgYgATsBBCAGIAU2AgAgACAEQQFqNgIUCyADQTBqJAAPCyADQQA2AiggA0EBNgIcIANB9Mj+ADYCGCADQgQ3AiAgA0EYakG8x/4AEO8sAAuJAwECfyMAQTBrIgMkACADIAI6AAcgAyABOgAGIAACfwJAIAFB/wFxIgRFBEAgA0ECNgIMIANBwNKAATYCCCADQgE3AhQgA0G7BzYCJCADQZDSgAE2AiAgAyADQSBqNgIQDAELAkAgBEEmTQRAIALAIgRBJkoNAUGTgICAeCAEQQBMIAJB/wFxIAFB/wFxTXINAxogA0ECNgIMIANB9NKAATYCCCADQgI3AhQgA0G7BzYCLCADQfQLNgIkIAMgA0EgajYCECADIANBBmo2AiggAyADQQdqNgIgDAILIANBAjYCDCADQbjTgAE2AgggA0ICNwIUIANBuwc2AiwgA0GQ0oABNgIoIANBuwc2AiQgAyADQSBqNgIQIAMgA0EGajYCIAwBCyADQQI2AgwgA0Gc04ABNgIIIANCAjcCFCADQfQLNgIsIANBkNKAATYCKCADQfQLNgIkIAMgA0EgajYCECADIANBB2o2AiALIABBBGogA0EIahCZDkGNgICAeAs2AgAgA0EwaiQAC4kDAQJ/IwBBMGsiAyQAIAMgAjoAByADIAE6AAYgAAJ/AkAgAUH/AXEiBEUEQCADQQI2AgwgA0HA0oABNgIIIANCATcCFCADQbsHNgIkIANByNOAATYCICADIANBIGo2AhAMAQsCQCAEQRJNBEAgAsAiBEESSg0BQZOAgIB4IARBAEwgAkH/AXEgAUH/AXFNcg0DGiADQQI2AgwgA0H00oABNgIIIANCAjcCFCADQbsHNgIsIANB9As2AiQgAyADQSBqNgIQIAMgA0EGajYCKCADIANBB2o2AiAMAgsgA0ECNgIMIANBuNOAATYCCCADQgI3AhQgA0G7BzYCLCADQcjTgAE2AiggA0G7BzYCJCADIANBIGo2AhAgAyADQQZqNgIgDAELIANBAjYCDCADQZzTgAE2AgggA0ICNwIUIANB9As2AiwgA0HI04ABNgIoIANB9As2AiQgAyADQSBqNgIQIAMgA0EHajYCIAsgAEEEaiADQQhqEJkOQY2AgIB4CzYCACADQTBqJAALiQMBAn8jAEEwayIDJAAgAyACOgAHIAMgAToABiAAAn8CQCABQf8BcSIERQRAIANBAjYCDCADQcDSgAE2AgggA0IBNwIUIANBuwc2AiQgA0HJ04ABNgIgIAMgA0EgajYCEAwBCwJAIARBCU0EQCACwCIEQQlKDQFBk4CAgHggBEEATCACQf8BcSABQf8BcU1yDQMaIANBAjYCDCADQfTSgAE2AgggA0ICNwIUIANBuwc2AiwgA0H0CzYCJCADIANBIGo2AhAgAyADQQZqNgIoIAMgA0EHajYCIAwCCyADQQI2AgwgA0G404ABNgIIIANCAjcCFCADQbsHNgIsIANBydOAATYCKCADQbsHNgIkIAMgA0EgajYCECADIANBBmo2AiAMAQsgA0ECNgIMIANBnNOAATYCCCADQgI3AhQgA0H0CzYCLCADQcnTgAE2AiggA0H0CzYCJCADIANBIGo2AhAgAyADQQdqNgIgCyAAQQRqIANBCGoQmQ5BjYCAgHgLNgIAIANBMGokAAuLAwECfyMAQTBrIgMkACADIAI6AAcgAyABOgAGIAACfwJAIAFB/wFxIgRFBEAgA0ECNgIMIANBwNKAATYCCCADQgE3AhQgA0G7BzYCJCADQcrTgAE2AiAgAyADQSBqNgIQDAELAkAgBEHMAE0EQCACwCIEQcwASg0BQZOAgIB4IARBAEwgAkH/AXEgAUH/AXFNcg0DGiADQQI2AgwgA0H00oABNgIIIANCAjcCFCADQbsHNgIsIANB9As2AiQgAyADQSBqNgIQIAMgA0EGajYCKCADIANBB2o2AiAMAgsgA0ECNgIMIANBuNOAATYCCCADQgI3AhQgA0G7BzYCLCADQcrTgAE2AiggA0G7BzYCJCADIANBIGo2AhAgAyADQQZqNgIgDAELIANBAjYCDCADQZzTgAE2AgggA0ICNwIUIANB9As2AiwgA0HK04ABNgIoIANB9As2AiQgAyADQSBqNgIQIAMgA0EHajYCIAsgAEEEaiADQQhqEJkOQY2AgIB4CzYCACADQTBqJAALtQMBA38jAEHgAGsiBiQAIAYgBToALyAGIAQ3AxggBiADNwMQIAYgAjcDCCAGIAE3AwAgAAJ/AkAgBUH/AXEiBUHMAE0EQCAGIAVBBXQiB0GglIUBaiIFEPsbIghB/wFxQQJGIAjAQQBMckUEQCAGQQM2AjQgBkHgu4UBNgIwIAZCAzcCPCAGQYMMNgJcIAYgBTYCWCAGQbsHNgJUIAZBgww2AkwgBiAGQcgAajYCOCAGIAZBL2o2AlAgBiAGNgJIIABBBGogBkEwahCZDgwCC0GTgICAeCAGIAdBwKeFAWoiBxD7G8BBAE4NAhogBkEDNgI0IAZBlLuFATYCMCAGQgM3AjwgBkGDDDYCXCAGIAc2AlggBkG7BzYCVCAGQYMMNgJMIAYgBkHIAGo2AjggBiAGQS9qNgJQIAYgBjYCSCAAQQRqIAZBMGoQmQ4MAQsgBkECNgJMIAZBnLyFATYCSCAGQgI3AlQgBkG7BzYCPCAGQbsHNgI0IAZB+LuFATYCMCAGIAZBMGo2AlAgBiAGQS9qNgI4IABBBGogBkHIAGoQmQ4LQY2AgIB4CzYCACAGQeAAaiQAC9UVAg1/BX4jAEGgA2siBiQAIAZB+ABqIgoQuy8gBiAKIAItAAQQliojAEEgayILJAAgATUCCCEQIwBBoAFrIggkACAIIBA3AwggCEEQaiEDIwBB0ABrIgQkAAJAIAE1AggiEUIIWgRAIARCADcDCCAEQThqIAEgEUIIfRDhMCAEQTBqIgUgBEHEAGopAgA3AwAgBCAEKQI8NwMoIAQoAjgiCUEIRwRAIAQoAkwhByADIAQpAyg3AgQgA0GAgICAeDYCUCADIAc2AhQgAyAJNgIAIANBDGogBSkDADcCAAwCCyAEQSBqIAUpAwA3AwAgBCAEKQMoNwMYIARBEGohDCAEQRhqIQ4gBEEIaiENQQghCSMAQRBrIgUkAAJAAkADQCAOIA0gCSAOKAIIIgcgByAJSxsiBxCXGiAFQQhqIg9BBDoAACAPIAc2AgQCQAJAAkACQCAFLQAIIgdBBEcEQAJAIAdBAWsOAwADAgcLIAUtAAlBI0cNBgwDCwJAIAUoAgwiBwRAIAcgCU0NASAHIAlBiM3DABCvOwALIAxBgM3DACkDADcCAAwHCyAHIA1qIQ0gCSAHayEJDAMLIAUoAgwtAAhBI0YNAQwECyAFKAIMLQAIQSNHDQMLIAVBCGoQuS4LIAkNAAsgDEEEOgAADAELIAwgBSkDCDcCAAsgBUEQaiQAAkAgBC0AEEEERg0AIAQpAxAiEkL/AYNCBFENACAEIBI3AzggAyAEQThqEIErIANBgICAgHg2AlAgBEEkaiAEKAIcIAQoAiAgBCgCGCgCEBEBAAwCCyAEQSRqIAQoAhwgBCgCICAEKAIYKAIQEQEAIARBOGogBEEIahCKGSAELQBAIQkgBCgCPCEFAkAgBCgCOCIHQQhHBEAgAyAEKQBBNwAJIANBEGogBEHIAGopAAA3AAAgAyAJOgAIIAMgBTYCBCADIAc2AgAMAQsgBkEBNgIIIAQgBTYCECAGIAVBCGoiBzYCDCAEIAk6ABQgB60iEiARWARAIARBOGogASARIBJ9IAUQzy4gBEEwaiIFIARBxABqKQIANwMAIAQgBCkCPDcDKCAEKAI4IglBCEcEQCAEKAJMIQcgAyAEKQMoNwIEIANBgICAgHg2AlAgAyAHNgIUIAMgCTYCACADQQxqIAUpAwA3AgAMBAsgBEEgaiAFKQMAIhE3AwAgBCAEKQMoNwMYIAMgBiAEKAIcIgMgEaciBSAEQRBqEP8ZIARBJGogAyAFIAQoAhgoAhARAQAMAwsgAyAHNgIEIANBBjYCAAsgA0GAgICAeDYCUAwBCyADQYCAgIB4NgJQIANChoCAgIABNwMACyAEQdAAaiQAAkAgC0EIaiIEAn8CQAJAIAgoAmBBgICAgHhGBEAgCCgCEEEGRw0BIAggCCgCFCIDNgJ0IBAgATUCCFEgECADrVRyDQIgBCADNgIEQQYMAwsgBkEQaiIDENIWIAMgCEEQakHgAPwKAAAgBi0AcCAGLQBxcgRAIwBB0ABrIgMkACADIBA3AwACQAJAAkACQAJAAkACQAJAIAYoAmBBgICAgHhHBEAgA0E4aiAGENwLIAMoAjhFDQEgAyADKQNIIhI3AxAgAyADKQNAIhE3AwggATUCCCETAkAgECARWA0AIBEgECATfSITQgAgECATWhsiE1QgECASWHINACASIBNaDQULIBAgElQNAiAQIBF9IhBC/////w9YDQMMBwsgA0E4akE7QQBBAUEBEKAYIAMoAjwhASADKAI4QQFGDQQgAygCQCIFQcTVwwBBO/wKAAAgBEE7NgIMIAQgBTYCCCAEIAE2AgQgBEEANgIADAcLIARBCDYCAAwGCyADQQI2AjwgA0Hc1MMANgI4IANCAjcCRCADQTw2AjQgA0HbATYCLCADIANBKGo2AkAgAyADNgIwIAMgA0EIajYCKCAEQQRqIANBOGoQmQ4gBEECNgIADAULIAQgED4CBCAEQQY2AgAMBAsgBigCCEUNASAGNQIMIRQgAyAQNwMgIAMgECAUfSIUQgAgECAUWhsiEDcDGCAQIBJaDQEgA0ECNgI8IANBtNXDADYCOCADQgI3AkQgA0HbATYCNCADQdsBNgIsIAMgA0EoajYCQCADIANBGGo2AjAgAyADQQhqNgIoIARBBGohCSMAQRBrIgUkACADQThqIgEoAgwhBwJAAkACQAJAAkACQAJAIAEoAgQOAgABAgsgBw0BQQEhB0EAIQEMAgsgBw0AIAEoAgAiBygCBCEBIAcoAgAhBwwBCyAJIAEQmQ4MAQsgBUEEaiABQQBBAUEBEKAYIAUoAgghDCAFKAIEQQFGDQEgBSgCDCENIAEEQCANIAcgAfwKAAALIAkgATYCCCAJIA02AgQgCSAMNgIACyAFQRBqJAAMAQsgDCAFKAIMQdDXwwAQ/S8ACyAEQQI2AgAMAwsgASADKAJAQdDXwwAQ/S8ACyASIBF9IhBC/////w9WDQAgA0E4aiABIBEgE30gEKcQzy4gA0EwaiIBIANBxABqKQIANwMAIAMgAykCPDcDKCADKAI4IgVBCEcEQCADKAJMIQkgBCADKQMoNwIEIAQgCTYCFCAEIAU2AgAgBEEMaiABKQMANwIADAILIANBIGogASkDADcDACADIAMpAyg3AxggA0E4aiIFIAYgA0EYaiIJIBEQphICQCADKAI4IgFBCEcNACAFIAYgCSAREJ8GIAMoAjgiAUEIRw0AIARBCDYCACADQSRqIAMoAhwgAygCICADKAIYKAIQEQEADAILIAQgAykCPDcCBCAEQRRqIANBzABqKAIANgIAIARBDGogA0HEAGopAgA3AgAgBCABNgIAIANBJGogAygCHCADKAIgIAMoAhgoAhARAQAMAQsgBBDbJAsgA0HQAGokAAwECyAEQQg2AgAMAwsgBCAIKQMQNwMAIARBEGogCEEgaikDADcDACAEQQhqIAhBGGopAwA3AwAMAgsgCEECNgJ8IAhBlNTDADYCeCAIQgI3AoQBIAhBOzYCnAEgCEE8NgKUASAIIAhBkAFqNgKAASAIIAhB9ABqNgKYASAIIAhBCGo2ApABIARBBGogCEH4AGoQmQ5BAgs2AgAgCEEQahDJIwsgCEGgAWokAAJAIAsoAggiAUEIRwRAIAogCykCDDcCBCAKQRRqIAtBHGooAgA2AgAgCkEMaiALQRRqKQIANwIAIApBgICAgHg2AlAgCiABNgIADAELIAogBhD+FAsgBkEQahDSFiALQSBqJAACQAJAIAYoAsgBIgRBgICAgHhGBEAgBkGAAmogBkGIAWopAwAiEDcDACAGQfgBaiAGQYABaikDACIRNwMAIAYgBikDeCISNwPwASAAQRBqIBA3AwAgAEEIaiARNwMAIAAgEjcDACACKAIAIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAIQ+CMMAQsgBkHwAWoiASAGQfgAaiIDQdAA/AoAACAGQcgCaiIIIAZB1AFqKAIANgIAIAYgBikCzAE3A8ACIAZB0AJqIgUgAUHQAPwKAABB6ABBCBCtNiIBRQ0BIAFCgYCAgBA3AwAgAUEIaiAFQdAA/AoAACABIAQ2AlggASAGKQPAAjcCXCABQeQAaiAIKAIANgIAIAYgAikCADcDeCAAIAEgAxDtAQsgBkGgA2okAA8LQQhB6AAQoz0AC/YcAhB/B34jAEGAAWsiAiQAIAEoAgghDiABKAIAIQ8gAiABKAIMIgwgASgCBCIBa0EDdhDEGwJAIAEgDEcEQCACQThqIRAgAkHcAGohDQNAAkAgASgCACIFBEAgAUEEaigCACEGIwBB0AFrIgQkACAEIAY2AgwgBCAFNgIIAkACQAJAAkAgBkENTwRAIAIoAgghAyACQQA2AgggAw0BDAILIARBADYCGCAEQgA3AxAgBgRAIARBEGogBSAG/AoAAAsgBDUCGCESIAQpAxAhFCACKAJAIgMgAigCOEYEQCACQThqQYzOhQEQsSgLIAIoAjwgA0EEdGoiBSASPgIMIAUgFDcCBCAFIAY2AgAgAiADQQFqNgJAIAIoAlwEQCACKAJsIgZBAWoiB0EDdiAHQQdxQQBHaiIFIAIoAmgiA0sEQCAFIANrIQkgAigCYCIIIAVJBEAgAkHcAGogCEEBdCIDIAVBwP///wNxQUBrIAUgBUE/cRsiCCADIAhLGxDoGSACKAJoIQMLIAkEQCACKAJkIANqQQAgCfwLAAsgAiAFNgJoCyACIAc2AmwgAigCZCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAwsgAiACKAJwQQFqNgJwDAILIARBNGogAkEUaigCADYCACAEQUBrIAJBIGopAwAiEjcDACAEQcgAaiACQShqKQMAIhc3AwAgBEHQAGogAkEwaikDACIWNwMAIAQgAzYCKCAEIAIpAgw3AiwgBCACKQMYIhQ3AzggEiAGrSIVhSITQjiGIBNCgP4Dg0IohoQgE0KAgPwHg0IYhiATQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEQtKBqpur+oLXp39+IhJCOIYgEkKA/gODQiiGhCASQoCA/AeDQhiGIBJCgICA+A+DQgiGhIQgEkIIiEKAgID4D4MgEkIYiEKAgPwHg4QgEkIoiEKA/gODIBJCOIiEhIQgE0LYotHvwqnlvy1+hSAVfEKt/tXk1IX9qNgAfiESAkAgBkEQTQRAIBIgFHwgBSkAACAXhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIAUgBmpBCGspAAAgFoUiE0J/hX4iFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhIUgE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhCASfoVCF4khEgwBCyASIBR8IBcgBSAGakEQayIDKQAAhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIBYgAykACIUiE0J/hX4iFUI4hiAVQoD+A4NCKIaEIBVCgID8B4NCGIYgFUKAgID4D4NCCIaEhCAVQgiIQoCAgPgPgyAVQhiIQoCA/AeDhCAVQiiIQoD+A4MgFUI4iISEhIUgE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhCASfoVCF4khEiAWQn+FIRUgBSEDIAYhBwNAIBIgFHwgFyADKQAAhSISQjiGIBJCgP4Dg0IohoQgEkKAgPwHg0IYhiASQoCAgPgPg0IIhoSEIBJCCIhCgICA+A+DIBJCGIhCgID8B4OEIBJCKIhCgP4DgyASQjiIhISEIAMpAAgiGCAVhX4iE0I4hiATQoD+A4NCKIaEIBNCgID8B4NCGIYgE0KAgID4D4NCCIaEhCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEhIUgEiAWIBiFIhNCOIYgE0KA/gODQiiGhCATQoCA/AeDQhiGIBNCgICA+A+DQgiGhIQgE0IIiEKAgID4D4MgE0IYiEKAgPwHg4QgE0IoiEKA/gODIBNCOIiEhIR+hUIXiSESIANBEGohAyAHQRBrIgdBEEsNAAsLIAJBCGohByAEQdgAaiAEQShqIBIgFEI4hiAUQoD+A4NCKIaEIBRCgID8B4NCGIYgFEKAgID4D4NCCIaEhCAUQgiIQoCAgPgPgyAUQhiIQoCA/AeDhCAUQiiIQoD+A4MgFEI4iISEhH4gEkI4hiASQoD+A4NCKIaEIBJCgID8B4NCGIYgEkKAgID4D4NCCIaEhCASQgiIQoCAgPgPgyASQhiIQoCA/AeDhCASQiiIQoD+A4MgEkI4iISEhCAUQn+FfiIUQjiGIBRCgP4Dg0IohoQgFEKAgPwHg0IYhiAUQoCAgPgPg0IIhoSEIBRCCIhCgICA+A+DIBRCGIhCgID8B4OEIBRCKIhCgP4DgyAUQjiIhISEhSASiSACIARBCGogBEE4ahD6DSAEKAJYQQFGBEAgBCgCbCIDKAIAIgkgBCgCaCIIaiIKLQAAIQsgAigCQCERIAogBCgCYEEZdiIKOgAAIAkgAygCBCAIQQhrcWpBCGogCjoAACADIAMoAgxBAWo2AgwgAyADKAIIIAtBAXFrNgIIIAkgCEECdGtBBGsgETYCACAEQagBaiAEQTBqKQIANwMAIAQgBCkCKDcDoAEgBEHIAWogBEHQAGopAwA3AwAgBEHAAWogBEHIAGopAwA3AwAgBEG4AWogBEFAaykDADcDACAEIAQpAzg3A7ABIAIoAggEQCAHQQQQ7igLIAcgBEGgAWpBMPwKAAAMAQsgBCgCaEEEaygCACIFIAIoAkAiA0kEQCACKAI8IgYgBUEEdGoiBSkDCCESIAUpAwAhFCACKAI4IANGBH8gAkE4akHMzYUBELEoIAIoAjwFIAYLIANBBHRqIgUgEjcDCCAFIBQ3AwAgAiADQQFqNgJAAkAgAigCXARAIAIoAmwiBkEBaiIJQQN2IAlBB3FBAEdqIgMgAigCaCIFSwRAIAMgBWshCCACKAJgIgogA0kEQCACQdwAaiAKQQF0IgUgA0HA////A3FBQGsgAyADQT9xGyIKIAUgCksbEOgZIAIoAmghBQsgCARAIAIoAmQgBWpBACAI/AsACyACIAM2AmgLIAIgCTYCbCACKAJkIAZBA3ZqIgMgAy0AAEEBIAZBB3F0cjoAAAwBCyACIAIoAnBBAWo2AnALIARB+ABqIARBMGopAgA3AwAgBEGIAWogBEFAaykDADcDACAEQZABaiAEQcgAaikDADcDACAEQZgBaiAEQdAAaikDADcDACAEIAQpAig3A3AgBCAEKQM4NwOAASAHKAIABEAgB0EEEO4oCyAHIARB8ABqQTD8CgAADAILIAUgA0G8zYUBEMMhAAsgAkHQAGohCSACKAJQIgcgAigCWCIDIAZqSQRAIAMEQCACQQA2AlggAigCVCEIIAJCgICAgBA3A1AgBCAHNgJoIARCgICAgBA3AmAgBCADNgJcIAQgCDYCWCAEIARB2ABqENc7IAQoAgAhC0EcQQQQrTYiB0UNAyAHQoGAgIAQNwIAIAcgBCkCWDcCCCAHQRBqIARB4ABqKQIANwIAIAdBGGogBEHoAGooAgA2AgAgAigCTCIIIAIoAkRGBEAgAkHEAGpBrM2FARCQKAsgAigCSCAIQQxsaiIKIAM2AgggCiALNgIEIAogBzYCACACIAhBAWo2AkwLIAIoAgQhBwJAIAIoAgBBAUcEQCAHIQMMAQtBgICAASEDIAdB////AEsNACACIAdBAXQiAzYCBAsgCSADIAYgAyAGSxsQhC4gAigCWCEDCyAJIAUgBhChNiACNQJMIAOtQiCGhCESIAatIAU1AABCIIaEIRQgAigCQCIDIAIoAjhGBEAgAkE4akH8zYUBELEoCyACKAI8IANBBHRqIgUgEjcDCCAFIBQ3AwAgAiADQQFqNgJAIAIoAlwEQCACKAJsIgZBAWoiB0EDdiAHQQdxQQBHaiIFIAIoAmgiA0sEQCAFIANrIQkgAigCYCIIIAVJBEAgAkHcAGogCEEBdCIDIAVBwP///wNxQUBrIAUgBUE/cRsiCCADIAhLGxDoGSACKAJoIQMLIAkEQCACKAJkIANqQQAgCfwLAAsgAiAFNgJoCyACIAc2AmwgAigCZCAGQQN2aiIDIAMtAABBASAGQQdxdHI6AAAMAQsgAiACKAJwQQFqNgJwCyAEQdABaiQADAILQQRBHBCjPQALIA0Q5jogAigCXEUNAyACKAJsQQFqIgZBA3YgBkEHcUEAR2oiAyACKAJoIgVLBEAgAyAFayEHIAIoAmAiBCADSQRAIA0gBEEBdCIFIANBwP///wNxQUBrIAMgA0E/cRsiBCAEIAVJGxDoGSACKAJoIQULIAcEQCACKAJkIAVqQQAgB/wLAAsgAiADNgJoCyACIAY2AmwgAigCQCIDIAIoAjhGBEAgEEGczoUBELEoCyACKAI8IANBBHRqIgVCADcDCCAFQgA3AwAgAiADQQFqNgJACyABQQhqIgEgDEcNAAsLIAIgDzYCfCACIA42AnggAkH4AGpBBEEIEOAeIAAgAhDcDCACQThqQRBBEBDgHiACKAJcBEAgAkHcAGoQzy8LIAJBxABqIgAQxScgABDoOyACQdAAahDeOyACKAIIBEAgAkEIakEEEO4oCyACQYABaiQADwtBoMmFARCyOwALjAMCBn4DfyMAQTBrIggkACABKQMYIQIgASkDECEDAkACQCABKQMAIgVCAVYgASkDCCIGQgBSIAZQGw0AAkACQCAFp0EBRgRAIAIgA4RQDQEMAwsgAyACQoCAgICAgICAgH+FhFANASACIAOEUEUNAiAAQgA3AwggAEIBNwMADAMLIABCgICAgICAgPg/NwMIIABCATcDAAwCCyAAQgE3AwAgAEKAgICAgICA8E83AwgMAQsgAkI/hyIEIAaFIgd5IAQgBYV5QkB9IAdCAFIbp0GAf3MgAiAEhSIHeSADIASFIgR5QkB9IAdCAFIbpyAEIAeEUBsiCUEBayIKwCEBAkAgCkH/AXFFDQAgAUEASARAIAhBIGogBSAGIAFB/wBxEMYjIAgpAyghAgwBCyAIQRBqIAMgAiABQf8BcRDGIyAIIAUgBkEBIAlrQf8AcRDHIyAIKQMIIAgpAxiEIQILIABCATcDACAARAAAAAAAAABAQcABIAFB/wFxaxDeICACuaI5AwgLIAhBMGokAAu6AwEBfyMAQUBqIgIkAAJAAkACQAJAAkACQCAALQAAQQFrDgMBAgMACyACIAAoAgQ2AgRBFEEBEK02IgBFDQQgAEEQakH0uokBKAAANgAAIABBCGpB7LqJASkAADcAACAAQeS6iQEpAAA3AAAgAkEUNgIQIAIgADYCDCACQRQ2AgggAkEDNgIsIAJByLKJATYCKCACQgI3AjQgAiACQQRqrUKAgICAwDOENwMgIAIgAkEIaq1CgICAgJDeA4Q3AxggAiACQRhqNgIwIAEoAgAgASgCBCACQShqEMsKIQAgAigCCCIBRQ0DIAIoAgwgAUEBEPg6DAMLIAAtAAEhACACQQE2AiwgAkHQq4kBNgIoIAJCATcCNCACIAJBGGqtQoCAgICg3gOENwMIIAIgAEECdCIAQfy6iQFqKAIANgIcIAIgAEGkvIkBaigCADYCGCACIAJBCGo2AjAgASgCACABKAIEIAJBKGoQywohAAwCCyAAKAIEIgAoAgAgACgCBCABEKk9IQAMAQsgACgCBCIAKAIAIAEgACgCBCgCEBECACEACyACQUBrJAAgAA8LQQFBFEH4qIkBEP0vAAvYhAECOX8gfSMAQSBrIjEkAAJAAkACQAJAAkACQCABLQAAQQFrDgYAAwQCBAQBCyAAIAAoAoABIAEtAApqNgKAAQwDCyAAIAAoAoABIAEoAghqNgKAAQwCCyAAIAEvAAE7AZwBDAELIDFCADcDEEEHITIDQCAzIAAoAoABIhVJBEAgMUEQaiAyaiAAIBUgMmpBCGtBhMbOABCpKC0AADoAAAsgM0EBaiEzIDJBAWsiMkF/Rw0ACyABKAIIIjoEQCABKAIEITJBACEzIDohAQNAIDFBEGoiFSAzQQZqQQdxci0AACECIDFBCGogFSAzQQFrQQdxIghyLQAAIAIgACgCGCAAKAIcIAAoAigEfyAAKAIkLQAABUEACyAALQCcARC1GyAxLQAMGiAxKAIIIRUgMSAxKQMQNwMYIDFBGGohGSAyLQAAIS4jAEEgayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgFUERbCIXIAAoAjwiFEkEQCAZIAggAC0AnQFrQQdxai0AACE0IAAoAjgiJyAXQQV0aiIEIC5B8AFxQQR2IhpBAXRqLwEAIQcgLkEQTwRAIBpBAWsiA0EQTw0CIAcgBCADQQF0ai8BAGshBwsgFSAaQQh0akGAIGohNiA0QQR0QYAecSAVaiE3IAdB//8DcUECdEHMhuMAaioCACE7IAQvAR4iEEECdEHMhuMAaioCACE8IAQvARwhAyAELwEaIQYgBC8BGCEJIAQvARYhCyAELwEUIQwgBC8BEiENIAQvARAhDyAELwEOIQogBC8BDCERIAQvAQohEiAELwEIIS8gBC8BBiEqIAQvAQQhKyAELwECIRggBC8BACEpIAAuAZIBIAAvAZABIQ5BACEHA0AgAiAHaiAOOwEAIAdBAmoiB0EgRw0ACyACLwEeIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRYgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQcDQCACIAdqIBo7AQAgB0ECaiIHQSBHDQALQQAgAi4BHEEPSBsgA2ohByAFQQAgAi4BGkEOSBsgBmohBSATQQAgAi4BGEENSBsgCWohAyAWQQAgAi4BFkEMSBsgC2ohFiAdQQAgAi4BFEELSBsgDGohDiAeQQAgAi4BEkEKSBsgDWohEyAfQQAgAi4BEEEJSBsgD2ohDyAgQQAgAi4BDkEISBsgCmohBiAhQQAgAi4BDEEHSBsgEWohCyAiQQAgAi4BCkEGSBsgEmohDCAjQQAgAi4BCEEFSBsgL2ohCiAkQQAgAi4BBkEESBsgKmohCSAlQQAgAi4BBEEDSBsgK2ohDSAmQQAgAi4BAkECSBsgGGohESAoQQAgAi4BAEEATBsgKWohEkEAIAIuAR5BEEgbIBBqwSIQTARAIBBBEGoiECAQwUECdWshECAHQQ9qIgcgB8FBAnVrIQcgBUEOaiIFIAXBQQJ1ayEFIBZBDGoiFiAWwUECdWshFiAOQQtqIg4gDsFBAnVrIQ4gE0EKaiITIBPBQQJ1ayETIA9BCWoiDyAPwUECdWshDyAGQQhqIgYgBsFBAnVrIQYgC0EHaiILIAvBQQJ1ayELIAxBBmoiDCAMwUECdWshDCAKQQVqIgogCsFBAnVrIQogCUEEaiIJIAnBQQJ1ayEJIA1BA2oiDSANwUECdWshDSARQQJqIhEgEcFBAnVrIREgEkEBaiISIBLBQQJ1ayESIANBDWoiAyADwUECdWshAwsgBCAQOwEeIAQgBzsBHCAEIAU7ARogBCADOwEYIAQgFjsBFiAEIA47ARQgBCATOwESIAQgDzsBECAEIAY7AQ4gBCALOwEMIAQgDDsBCiAEIAo7AQggBCAJOwEGIAQgDTsBBCAEIBE7AQIgBCASOwEAIBcgGmpBAWoiFiAUTw0CICcgFkEFdGoiAyAuQQ9xIidBAXRqIgcvAQAhBiAnBH8gBiAHQQJrLwEAawUgBgtB//8DcUECdEHMhuMAaioCACE9IAMvAR4iBUECdEHMhuMAaioCACE+IAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhDiADLwEOIREgAy8BDCESIAMvAQohECADLwEIIRQgAy8BBiErIAMvAQQhGCADLwECISkgAy8BACEbIAAuAY4BIS8gAC8BjAEhKkEAIQQDQCACIARqICo7AQAgBEECaiIEQSBHDQALIAIvAR4hHCACLwEcIAIvARohCiACLwEYIR0gAi8BFiEeIAIvARQhHyACLwESISAgAi8BECEhIAIvAQ4hIiACLwEMISMgAi8BCiEkIAIvAQghJSACLwEGISYgAi8BBCEoIAIvAQIhLCACLwEAIS1BACEEA0AgAiAEaiAnOwEAIARBAmoiBEEgRw0AC0EAIAIuARxBD0gbIAZqIQQgCkEAIAIuARpBDkgbIAdqIRMgHUEAIAIuARhBDUgbIAlqIQ8gHkEAIAIuARZBDEgbIAtqIQYgH0EAIAIuARRBC0gbIAxqIQsgIEEAIAIuARJBCkgbIA1qIQwgIUEAIAIuARBBCUgbIA5qIQogIkEAIAIuAQ5BCEgbIBFqIQkgI0EAIAIuAQxBB0gbIBJqIQ0gJEEAIAIuAQpBBkgbIBBqIREgJUEAIAIuAQhBBUgbIBRqIRIgJkEAIAIuAQZBBEgbICtqIRAgKEEAIAIuAQRBA0gbIBhqIQcgLEEAIAIuAQJBAkgbIClqIQ4gLUEAIAIuAQBBAEwbIBtqIRQgLyAcQQAgAi4BHkEQSBsgBWrBIgVMBEAgBUEQaiIFIAXBQQJ1ayEFIARBD2oiBCAEwUECdWshBCATQQ5qIhMgE8FBAnVrIRMgD0ENaiIPIA/BQQJ1ayEPIAtBC2oiCyALwUECdWshCyAMQQpqIgwgDMFBAnVrIQwgCkEJaiIKIArBQQJ1ayEKIAlBCGoiCSAJwUECdWshCSANQQdqIg0gDcFBAnVrIQ0gEUEGaiIRIBHBQQJ1ayERIBJBBWoiEiASwUECdWshEiAQQQRqIhAgEMFBAnVrIRAgB0EDaiIHIAfBQQJ1ayEHIA5BAmoiDiAOwUECdWshDiAUQQFqIhQgFMFBAnVrIRQgBkEMaiIGIAbBQQJ1ayEGCyADIAU7AR4gAyAEOwEcIAMgEzsBGiADIA87ARggAyAGOwEWIAMgCzsBFCADIAw7ARIgAyAKOwEQIAMgCTsBDiADIA07AQwgAyAROwEKIAMgEjsBCCADIBA7AQYgAyAHOwEEIAMgDjsBAiADIBQ7AQAgFyAAKAJEIgRPDQMgACgCQCIrIBdBBXRqIgUgGkEBdGovAQAhAyAuQRBPBH8gGkEBayIGQRBPDRQgAyAFIAZBAXRqLwEAawUgAwtB//8DcUECdEHMhuMAaiAFLwEeIhRBAnRBzIbjAGohKSAFLwEcIQMgBS8BGiEXIAUvARghEyAFLwEWIQ8gBS8BFCEGIAUvARIhCyAFLwEQIQwgBS8BDiEKIAUvAQwhCSAFLwEKIQ0gBS8BCCERIAUvAQYhEiAFLwEEIRAgBS8BAiEHIAUvAQAhDiAUwSIUQYAITgRAIBRBEGoiFCAUwUECdWshFCAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyAGQQtqIgYgBsFBAnVrIQYgC0EKaiILIAvBQQJ1ayELIAxBCWoiDCAMwUECdWshDCAKQQhqIgogCsFBAnVrIQogCUEHaiIJIAnBQQJ1ayEJIA1BBmoiDSANwUECdWshDSARQQVqIhEgEcFBAnVrIREgEkEEaiISIBLBQQJ1ayESIBBBA2oiECAQwUECdWshECAHQQJqIgcgB8FBAnVrIQcgDkEBaiIOIA7BQQJ1ayEOIANBD2oiAyADwUECdWshAwsqAgAhPyApKgIAIUAgBSAUOwEeIAUgAzsBHCAFIBc7ARogBSATOwEYIAUgDzsBFiAFIAY7ARQgBSALOwESIAUgDDsBECAFIAo7AQ4gBSAJOwEMIAUgDTsBCiAFIBE7AQggBSASOwEGIAUgEDsBBCAFIAc7AQIgBSAOOwEAIAQgFk0NBCArIBZBBXRqIgUgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqIAUvAR4iDkECdEHMhuMAaiEUIAUvARwhAyAFLwEaIRcgBS8BGCEWIAUvARYhEyAFLwEUIQ8gBS8BEiEGIAUvARAhCyAFLwEOIQwgBS8BDCEKIAUvAQohCSAFLwEIIQ0gBS8BBiERIAUvAQQhEiAFLwECIRAgBS8BACEHIA7BIg5BgAhOBEAgDkEQaiIOIA7BQQJ1ayEOIBdBDmoiFyAXwUECdWshFyAWQQ1qIhYgFsFBAnVrIRYgE0EMaiITIBPBQQJ1ayETIA9BC2oiDyAPwUECdWshDyAGQQpqIgYgBsFBAnVrIQYgC0EJaiILIAvBQQJ1ayELIAxBCGoiDCAMwUECdWshDCAKQQdqIgogCsFBAnVrIQogCUEGaiIJIAnBQQJ1ayEJIA1BBWoiDSANwUECdWshDSARQQRqIhEgEcFBAnVrIREgEkEDaiISIBLBQQJ1ayESIBBBAmoiECAQwUECdWshECAHQQFqIgcgB8FBAnVrIQcgA0EPaiIDIAPBQQJ1ayEDCyoCACFBIBQqAgAhQiAFIA47AR4gBSADOwEcIAUgFzsBGiAFIBY7ARggBSATOwEWIAUgDzsBFCAFIAY7ARIgBSALOwEQIAUgDDsBDiAFIAo7AQwgBSAJOwEKIAUgDTsBCCAFIBE7AQYgBSASOwEEIAUgEDsBAiAFIAc7AQAgFUEBdCIWQQFyIgMgACgCTCIGTw0FIAAoAkgiBSADQQV0aiIDIBpBAXRqLwEAIQcgLkEQTwR/IBpBAWsiBkEQTw0UIAcgAyAGQQF0ai8BAGsFIAcLQf//A3FBAnRBzIbjAGoqAgAhQyADLwEeIhRBAnRBzIbjAGoqAgAhRCADLwEcIQYgAy8BGiEHIAMvARghCSADLwEWIQsgAy8BFCEMIAMvARIhDSADLwEQIQ4gAy8BDiEKIAMvAQwhESADLwEKIRIgAy8BCCEQIAMvAQYhKyADLwEEIRggAy8BAiEpIAMvAQAhG0EAIQQDQCACIARqICo7AQAgBEECaiIEQSBHDQALIAIvAR4hHCACLwEcIAIvARohEyACLwEYIR0gAi8BFiEeIAIvARQhHyACLwESISAgAi8BECEhIAIvAQ4hIiACLwEMISMgAi8BCiEkIAIvAQghJSACLwEGISYgAi8BBCEoIAIvAQIhLCACLwEAIS1BACEEA0AgAiAEaiAaOwEAIARBAmoiBEEgRw0AC0EAIAIuARxBD0gbIAZqIQQgE0EAIAIuARpBDkgbIAdqIRcgHUEAIAIuARhBDUgbIAlqIRMgHkEAIAIuARZBDEgbIAtqIQ8gH0EAIAIuARRBC0gbIAxqIQYgIEEAIAIuARJBCkgbIA1qIQsgIUEAIAIuARBBCUgbIA5qIQwgIkEAIAIuAQ5BCEgbIApqIQogI0EAIAIuAQxBB0gbIBFqIQkgJEEAIAIuAQpBBkgbIBJqIQ0gJUEAIAIuAQhBBUgbIBBqIREgJkEAIAIuAQZBBEgbICtqIRIgKEEAIAIuAQRBA0gbIBhqIRAgLEEAIAIuAQJBAkgbIClqIQcgLUEAIAIuAQBBAEwbIBtqIQ4gLyAcQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIARBD2oiBCAEwUECdWshBCAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyALQQpqIgsgC8FBAnVrIQsgDEEJaiIMIAzBQQJ1ayEMIApBCGoiCiAKwUECdWshCiAJQQdqIgkgCcFBAnVrIQkgDUEGaiINIA3BQQJ1ayENIBFBBWoiESARwUECdWshESASQQRqIhIgEsFBAnVrIRIgEEEDaiIQIBDBQQJ1ayEQIAdBAmoiByAHwUECdWshByAOQQFqIg4gDsFBAnVrIQ4gBkELaiIGIAbBQQJ1ayEGCyADIBQ7AR4gAyAEOwEcIAMgFzsBGiADIBM7ARggAyAPOwEWIAMgBjsBFCADIAs7ARIgAyAMOwEQIAMgCjsBDiADIAk7AQwgAyANOwEKIAMgETsBCCADIBI7AQYgAyAQOwEEIAMgBzsBAiADIA47AQAgBSAWQQV0aiIDICdBAXRqIgcvAQAhBiAnBH8gBiAHQQJrLwEAawUgBgtB//8DcUECdEHMhuMAaioCACFFIAMvAR4iDkECdEHMhuMAaioCACFGIAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhCiADLwEOIREgAy8BDCESIAMvAQohECADLwEIIRQgAy8BBiErIAMvAQQhGCADLwECISkgAy8BACEbQQAhBANAIAIgBGogKjsBACAEQQJqIgRBIEcNAAsgAi8BHiEqIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRwgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQQDQCACIARqICc7AQAgBEECaiIEQSBHDQALQQAgAi4BHEEPSBsgBmohBCAFQQAgAi4BGkEOSBsgB2ohBSATQQAgAi4BGEENSBsgCWohFyAcQQAgAi4BFkEMSBsgC2ohEyAdQQAgAi4BFEELSBsgDGohDyAeQQAgAi4BEkEKSBsgDWohBiAfQQAgAi4BEEEJSBsgCmohCyAgQQAgAi4BDkEISBsgEWohDCAhQQAgAi4BDEEHSBsgEmohCiAiQQAgAi4BCkEGSBsgEGohCSAjQQAgAi4BCEEFSBsgFGohDSAkQQAgAi4BBkEESBsgK2ohESAlQQAgAi4BBEEDSBsgGGohEiAmQQAgAi4BAkECSBsgKWohECAoQQAgAi4BAEEATBsgG2ohByAvICpBACACLgEeQRBIGyAOasEiDkwEQCAOQRBqIg4gDsFBAnVrIQ4gBEEPaiIEIATBQQJ1ayEEIAVBDmoiBSAFwUECdWshBSAXQQ1qIhQgFMFBAnVrIRcgE0EMaiITIBPBQQJ1ayETIA9BC2oiDyAPwUECdWshDyALQQlqIgsgC8FBAnVrIQsgDEEIaiIMIAzBQQJ1ayEMIApBB2oiCiAKwUECdWshCiAJQQZqIgkgCcFBAnVrIQkgDUEFaiINIA3BQQJ1ayENIBFBBGoiESARwUECdWshESASQQNqIhIgEsFBAnVrIRIgEEECaiIQIBDBQQJ1ayEQIAdBAWoiByAHwUECdWshByAGQQpqIgYgBsFBAnVrIQYLIAMgDjsBHiADIAQ7ARwgAyAFOwEaIAMgFzsBGCADIBM7ARYgAyAPOwEUIAMgBjsBEiADIAs7ARAgAyAMOwEOIAMgCjsBDCADIAk7AQogAyANOwEIIAMgETsBBiADIBI7AQQgAyAQOwECIAMgBzsBACAZIAhBB3FqLQAAIitBCXQgFnIiAyAAKAJUIgRPDQYgACgCUCIYIANBBXRqIgMgGkEBdGovAQAhByAuQRBPBH8gGkEBayIGQRBPDRQgByADIAZBAXRqLwEAawUgBwtB//8DcUECdEHMhuMAaioCACFHIAMvAR4iFEECdEHMhuMAaioCACFIIAMvARwhBiADLwEaIQcgAy8BGCEJIAMvARYhCyADLwEUIQwgAy8BEiENIAMvARAhDiADLwEOIQogAy8BDCERIAMvAQohEiADLwEIIRAgAy8BBiEpIAMvAQQhGyADLwECIRwgAy8BACEdIAAuAZoBIS8gAC8BmAEhKkEAIQUDQCACIAVqICo7AQAgBUECaiIFQSBHDQALIAIvAR4hHiACLwEcIAIvARohEyACLwEYIR8gAi8BFiEgIAIvARQhISACLwESISIgAi8BECEjIAIvAQ4hJCACLwEMISUgAi8BCiEmIAIvAQghKCACLwEGISwgAi8BBCEtIAIvAQIhMCACLwEAITVBACEFA0AgAiAFaiAaOwEAIAVBAmoiBUEgRw0AC0EAIAIuARxBD0gbIAZqIQUgE0EAIAIuARpBDkgbIAdqIRcgH0EAIAIuARhBDUgbIAlqIRMgIEEAIAIuARZBDEgbIAtqIQ8gIUEAIAIuARRBC0gbIAxqIQYgIkEAIAIuARJBCkgbIA1qIQsgI0EAIAIuARBBCUgbIA5qIQwgJEEAIAIuAQ5BCEgbIApqIQogJUEAIAIuAQxBB0gbIBFqIQkgJkEAIAIuAQpBBkgbIBJqIQ0gKEEAIAIuAQhBBUgbIBBqIREgLEEAIAIuAQZBBEgbIClqIRIgLUEAIAIuAQRBA0gbIBtqIRAgMEEAIAIuAQJBAkgbIBxqIQcgNUEAIAIuAQBBAEwbIB1qIQ4gLyAeQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIAVBD2oiBSAFwUECdWshBSAXQQ5qIhcgF8FBAnVrIRcgE0ENaiITIBPBQQJ1ayETIA9BDGoiDyAPwUECdWshDyALQQpqIgsgC8FBAnVrIQsgDEEJaiIMIAzBQQJ1ayEMIApBCGoiCiAKwUECdWshCiAJQQdqIgkgCcFBAnVrIQkgDUEGaiINIA3BQQJ1ayENIBFBBWoiESARwUECdWshESASQQRqIhIgEsFBAnVrIRIgEEEDaiIQIBDBQQJ1ayEQIAdBAmoiByAHwUECdWshByAOQQFqIg4gDsFBAnVrIQ4gBkELaiIGIAbBQQJ1ayEGCyADIBQ7AR4gAyAFOwEcIAMgFzsBGiADIBM7ARggAyAPOwEWIAMgBjsBFCADIAs7ARIgAyAMOwEQIAMgCjsBDiADIAk7AQwgAyANOwEKIAMgETsBCCADIBI7AQYgAyAQOwEEIAMgBzsBAiADIA47AQAgGkEMdCIpICtBD3FBCHRyIBVyQQF0QQFyIgMgBE8NByAYIANBBXRqIgQgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIUkgBC8BHiITQQJ0QcyG4wBqKgIAIUogBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEYIAQvAQIhGyAELwEAIRwgAC4BlgEhKyAALwGUASEXQQAhAwNAIAIgA2ogFzsBACADQQJqIgNBIEcNAAsgAi8BHiEdIAIvARwgAi8BGiEKIAIvARghHiACLwEWIR8gAi8BFCEgIAIvARIhISACLwEQISIgAi8BDiEjIAIvAQwhJCACLwEKISUgAi8BCCEmIAIvAQYhKCACLwEEISwgAi8BAiEtIAIvAQAhMEEAIQMDQCACIANqICc7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyAKQQAgAi4BGkEOSBsgB2ohBiAeQQAgAi4BGEENSBsgCWohCyAfQQAgAi4BFkEMSBsgDGohDCAgQQAgAi4BFEELSBsgDWohCiAhQQAgAi4BEkEKSBsgDmohCSAiQQAgAi4BEEEJSBsgD2ohDSAjQQAgAi4BDkEISBsgEWohESAkQQAgAi4BDEEHSBsgEmohEiAlQQAgAi4BCkEGSBsgEGohECAmQQAgAi4BCEEFSBsgBWohByAoQQAgAi4BBkEESBsgFGohDiAsQQAgAi4BBEEDSBsgGGohFCAtQQAgAi4BAkECSBsgG2ohBSAwQQAgAi4BAEEATBsgHGohDyArIB1BACACLgEeQRBIGyATasEiE0wEQCATQRBqIhMgE8FBAnVrIRMgBkEOaiIGIAbBQQJ1ayEGIAtBDWoiCyALwUECdWshCyAMQQxqIgwgDMFBAnVrIQwgCkELaiIKIArBQQJ1ayEKIAlBCmoiCSAJwUECdWshCSANQQlqIg0gDcFBAnVrIQ0gEUEIaiIRIBHBQQJ1ayERIBJBB2oiEiASwUECdWshEiAQQQZqIhAgEMFBAnVrIRAgB0EFaiIHIAfBQQJ1ayEHIA5BBGoiDiAOwUECdWshDiAUQQNqIhQgFMFBAnVrIRQgBUECaiIFIAXBQQJ1ayEFIA9BAWoiDyAPwUECdWshDyADQQ9qIgMgA8FBAnVrIQMLIAQgEzsBHiAEIAM7ARwgBCAGOwEaIAQgCzsBGCAEIAw7ARYgBCAKOwEUIAQgCTsBEiAEIA07ARAgBCAROwEOIAQgEjsBDCAEIBA7AQogBCAHOwEIIAQgDjsBBiAEIBQ7AQQgBCAFOwECIAQgDzsBACAZIAhBAWtBB3FqLQAAIhtBCXQgFnIiAyAAKAJcIhhPDQ4gACgCWCIcIANBBXRqIgQgGkEBdGovAQAhAyAuQRBPBH8gGkEBayIGQRBPDRQgAyAEIAZBAXRqLwEAawUgAwtB//8DcUECdEHMhuMAaioCACFLIAQvAR4iE0ECdEHMhuMAaioCACFMIAQvARwhBiAELwEaIQcgBC8BGCEJIAQvARYhDCAELwEUIQ0gBC8BEiEOIAQvARAhDyAELwEOIREgBC8BDCESIAQvAQohECAELwEIIQUgBC8BBiEUIAQvAQQhHSAELwECIR4gBC8BACEfQQAhAwNAIAIgA2ogKjsBACADQQJqIgNBIEcNAAsgAi8BHiEgIAIvARwgAi8BGiEKIAIvARghISACLwEWISIgAi8BFCEjIAIvARIhJCACLwEQISUgAi8BDiEmIAIvAQwhKCACLwEKISwgAi8BCCEtIAIvAQYhMCACLwEEITUgAi8BAiE4IAIvAQAhOUEAIQMDQCACIANqIBo7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyAKQQAgAi4BGkEOSBsgB2ohBiAhQQAgAi4BGEENSBsgCWohCyAiQQAgAi4BFkEMSBsgDGohDCAjQQAgAi4BFEELSBsgDWohCiAkQQAgAi4BEkEKSBsgDmohCSAlQQAgAi4BEEEJSBsgD2ohDSAmQQAgAi4BDkEISBsgEWohESAoQQAgAi4BDEEHSBsgEmohEiAsQQAgAi4BCkEGSBsgEGohECAtQQAgAi4BCEEFSBsgBWohByAwQQAgAi4BBkEESBsgFGohDiA1QQAgAi4BBEEDSBsgHWohFCA4QQAgAi4BAkECSBsgHmohBSA5QQAgAi4BAEEATBsgH2ohDyAvICBBACACLgEeQRBIGyATasEiE0wEQCATQRBqIhMgE8FBAnVrIRMgBkEOaiIGIAbBQQJ1ayEGIAtBDWoiCyALwUECdWshCyAMQQxqIgwgDMFBAnVrIQwgCkELaiIKIArBQQJ1ayEKIAlBCmoiCSAJwUECdWshCSANQQlqIg0gDcFBAnVrIQ0gEUEIaiIRIBHBQQJ1ayERIBJBB2oiEiASwUECdWshEiAQQQZqIhAgEMFBAnVrIRAgB0EFaiIHIAfBQQJ1ayEHIA5BBGoiDiAOwUECdWshDiAUQQNqIhQgFMFBAnVrIRQgBUECaiIFIAXBQQJ1ayEFIA9BAWoiDyAPwUECdWshDyADQQ9qIgMgA8FBAnVrIQMLIAQgEzsBHiAEIAM7ARwgBCAGOwEaIAQgCzsBGCAEIAw7ARYgBCAKOwEUIAQgCTsBEiAEIA07ARAgBCAROwEOIAQgEjsBDCAEIBA7AQogBCAHOwEIIAQgDjsBBiAEIBQ7AQQgBCAFOwECIAQgDzsBACAbQQ9xQQh0IClyIBVyQQF0QQFyIgMgGE8NDiAcIANBBXRqIgQgJ0EBdGoiBi8BACEDICcEfyADIAZBAmsvAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIU0gBC8BHiITQQJ0QcyG4wBqKgIAIU4gBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEYIAQvAQIhGyAELwEAIRxBACEDA0AgAiADaiAXOwEAIANBAmoiA0EgRw0ACyACLwEeIR0gAi8BHCACLwEaIQogAi8BGCEeIAIvARYhHyACLwEUISAgAi8BEiEhIAIvARAhIiACLwEOISMgAi8BDCEkIAIvAQohJSACLwEIISYgAi8BBiEoIAIvAQQhLCACLwECIS0gAi8BACEwQQAhAwNAIAIgA2ogJzsBACADQQJqIgNBIEcNAAtBACACLgEcQQ9IGyAGaiEDIApBACACLgEaQQ5IGyAHaiEGIB5BACACLgEYQQ1IGyAJaiELIB9BACACLgEWQQxIGyAMaiEMICBBACACLgEUQQtIGyANaiEKICFBACACLgESQQpIGyAOaiEJICJBACACLgEQQQlIGyAPaiENICNBACACLgEOQQhIGyARaiERICRBACACLgEMQQdIGyASaiESICVBACACLgEKQQZIGyAQaiEQICZBACACLgEIQQVIGyAFaiEHIChBACACLgEGQQRIGyAUaiEOICxBACACLgEEQQNIGyAYaiEUIC1BACACLgECQQJIGyAbaiEFIDBBACACLgEAQQBMGyAcaiEPICsgHUEAIAIuAR5BEEgbIBNqwSITTARAIBNBEGoiEyATwUECdWshEyAGQQ5qIgYgBsFBAnVrIQYgC0ENaiILIAvBQQJ1ayELIAxBDGoiDCAMwUECdWshDCAKQQtqIgogCsFBAnVrIQogCUEKaiIJIAnBQQJ1ayEJIA1BCWoiDSANwUECdWshDSARQQhqIhEgEcFBAnVrIREgEkEHaiISIBLBQQJ1ayESIBBBBmoiECAQwUECdWshECAHQQVqIgcgB8FBAnVrIQcgDkEEaiIOIA7BQQJ1ayEOIBRBA2oiFCAUwUECdWshFCAFQQJqIgUgBcFBAnVrIQUgD0EBaiIPIA/BQQJ1ayEPIANBD2oiAyADwUECdWshAwsgBCATOwEeIAQgAzsBHCAEIAY7ARogBCALOwEYIAQgDDsBFiAEIAo7ARQgBCAJOwESIAQgDTsBECAEIBE7AQ4gBCASOwEMIAQgEDsBCiAEIAc7AQggBCAOOwEGIAQgFDsBBCAEIAU7AQIgBCAPOwEAIBkgCEEGakEHcWotAAAiG0EJdCAWciIDIAAoAmQiGE8NDiAAKAJgIhwgA0EFdGoiBCAaQQF0ai8BACEDIC5BEE8EfyAaQQFrIgZBEE8NFCADIAQgBkEBdGovAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIU8gBC8BHiITQQJ0QcyG4wBqKgIAIVAgBC8BHCEGIAQvARohByAELwEYIQkgBC8BFiEMIAQvARQhDSAELwESIQ4gBC8BECEPIAQvAQ4hESAELwEMIRIgBC8BCiEQIAQvAQghBSAELwEGIRQgBC8BBCEdIAQvAQIhHiAELwEAIR9BACEDA0AgAiADaiAqOwEAIANBAmoiA0EgRw0ACyACLwEeISAgAi8BHCACLwEaIQogAi8BGCEhIAIvARYhIiACLwEUISMgAi8BEiEkIAIvARAhJSACLwEOISYgAi8BDCEoIAIvAQohLCACLwEIIS0gAi8BBiEwIAIvAQQhNSACLwECITggAi8BACE5QQAhAwNAIAIgA2ogGjsBACADQQJqIgNBIEcNAAtBACACLgEcQQ9IGyAGaiEDIApBACACLgEaQQ5IGyAHaiEGICFBACACLgEYQQ1IGyAJaiELICJBACACLgEWQQxIGyAMaiEMICNBACACLgEUQQtIGyANaiEKICRBACACLgESQQpIGyAOaiEJICVBACACLgEQQQlIGyAPaiENICZBACACLgEOQQhIGyARaiERIChBACACLgEMQQdIGyASaiESICxBACACLgEKQQZIGyAQaiEQIC1BACACLgEIQQVIGyAFaiEHIDBBACACLgEGQQRIGyAUaiEOIDVBACACLgEEQQNIGyAdaiEUIDhBACACLgECQQJIGyAeaiEFIDlBACACLgEAQQBMGyAfaiEPIC8gIEEAIAIuAR5BEEgbIBNqwSITTARAIBNBEGoiEyATwUECdWshEyAGQQ5qIgYgBsFBAnVrIQYgC0ENaiILIAvBQQJ1ayELIAxBDGoiDCAMwUECdWshDCAKQQtqIgogCsFBAnVrIQogCUEKaiIJIAnBQQJ1ayEJIA1BCWoiDSANwUECdWshDSARQQhqIhEgEcFBAnVrIREgEkEHaiISIBLBQQJ1ayESIBBBBmoiECAQwUECdWshECAHQQVqIgcgB8FBAnVrIQcgDkEEaiIOIA7BQQJ1ayEOIBRBA2oiFCAUwUECdWshFCAFQQJqIgUgBcFBAnVrIQUgD0EBaiIPIA/BQQJ1ayEPIANBD2oiAyADwUECdWshAwsgBCATOwEeIAQgAzsBHCAEIAY7ARogBCALOwEYIAQgDDsBFiAEIAo7ARQgBCAJOwESIAQgDTsBECAEIBE7AQ4gBCASOwEMIAQgEDsBCiAEIAc7AQggBCAOOwEGIAQgFDsBBCAEIAU7AQIgBCAPOwEAIBtBD3FBCHQgKXIgFXJBAXRBAXIiAyAYTw0OIBwgA0EFdGoiBCAnQQF0aiIGLwEAIQMgJwR/IAMgBkECay8BAGsFIAMLQf//A3FBAnRBzIbjAGoqAgAhUSAELwEeIhNBAnRBzIbjAGoqAgAhUiAELwEcIQYgBC8BGiEHIAQvARghCSAELwEWIQwgBC8BFCENIAQvARIhDiAELwEQIQ8gBC8BDiERIAQvAQwhEiAELwEKIRAgBC8BCCEFIAQvAQYhFCAELwEEIRggBC8BAiEbIAQvAQAhHEEAIQMDQCACIANqIBc7AQAgA0ECaiIDQSBHDQALIAIvAR4hHSACLwEcIAIvARohCiACLwEYIR4gAi8BFiEfIAIvARQhICACLwESISEgAi8BECEiIAIvAQ4hIyACLwEMISQgAi8BCiElIAIvAQghJiACLwEGISggAi8BBCEsIAIvAQIhLSACLwEAITBBACEDA0AgAiADaiAnOwEAIANBAmoiA0EgRw0AC0EAIAIuARxBD0gbIAZqIQMgCkEAIAIuARpBDkgbIAdqIQYgHkEAIAIuARhBDUgbIAlqIQsgH0EAIAIuARZBDEgbIAxqIQwgIEEAIAIuARRBC0gbIA1qIQogIUEAIAIuARJBCkgbIA5qIQkgIkEAIAIuARBBCUgbIA9qIQ0gI0EAIAIuAQ5BCEgbIBFqIREgJEEAIAIuAQxBB0gbIBJqIRIgJUEAIAIuAQpBBkgbIBBqIRAgJkEAIAIuAQhBBUgbIAVqIQcgKEEAIAIuAQZBBEgbIBRqIQ4gLEEAIAIuAQRBA0gbIBhqIRQgLUEAIAIuAQJBAkgbIBtqIQUgMEEAIAIuAQBBAEwbIBxqIQ8gKyAdQQAgAi4BHkEQSBsgE2rBIhNMBEAgE0EQaiITIBPBQQJ1ayETIAZBDmoiBiAGwUECdWshBiALQQ1qIgsgC8FBAnVrIQsgDEEMaiIMIAzBQQJ1ayEMIApBC2oiCiAKwUECdWshCiAJQQpqIgkgCcFBAnVrIQkgDUEJaiINIA3BQQJ1ayENIBFBCGoiESARwUECdWshESASQQdqIhIgEsFBAnVrIRIgEEEGaiIQIBDBQQJ1ayEQIAdBBWoiByAHwUECdWshByAOQQRqIg4gDsFBAnVrIQ4gFEEDaiIUIBTBQQJ1ayEUIAVBAmoiBSAFwUECdWshBSAPQQFqIg8gD8FBAnVrIQ8gA0EPaiIDIAPBQQJ1ayEDCyAEIBM7AR4gBCADOwEcIAQgBjsBGiAEIAs7ARggBCAMOwEWIAQgCjsBFCAEIAk7ARIgBCANOwEQIAQgETsBDiAEIBI7AQwgBCAQOwEKIAQgBzsBCCAEIA47AQYgBCAUOwEEIAQgBTsBAiAEIA87AQAgGSAIQQVqQQdxai0AACIFQQl0IBZyIgggACgCbCIPTw0IIAAoAmgiBCAIQQV0aiIIIBpBAXRqLwEAIQMgLkEQTwR/IBpBAWsiBkEQTw0UIAMgCCAGQQF0ai8BAGsFIAMLQf//A3FBAnRBzIbjAGoqAgAhUyAILwEeIhRBAnRBzIbjAGoqAgAhVCAILwEcIQYgCC8BGiEHIAgvARghCSAILwEWIQsgCC8BFCEMIAgvARIhDSAILwEQIQ4gCC8BDiEKIAgvAQwhESAILwEKIRIgCC8BCCEQIAgvAQYhGCAILwEEIRsgCC8BAiEcIAgvAQAhHUEAIQMDQCACIANqICo7AQAgA0ECaiIDQSBHDQALIAIvAR4hHiACLwEcIAIvARohFiACLwEYIRkgAi8BFiEfIAIvARQhICACLwESISEgAi8BECEiIAIvAQ4hIyACLwEMISQgAi8BCiElIAIvAQghJiACLwEGISggAi8BBCEsIAIvAQIhLSACLwEAITBBACEDA0AgAiADaiAaOwEAIANBAmoiA0EgRw0AC0EAIAIuARxBD0gbIAZqIQMgFkEAIAIuARpBDkgbIAdqIRMgGUEAIAIuARhBDUgbIAlqIRkgH0EAIAIuARZBDEgbIAtqIRYgIEEAIAIuARRBC0gbIAxqIQYgIUEAIAIuARJBCkgbIA1qIQsgIkEAIAIuARBBCUgbIA5qIQwgI0EAIAIuAQ5BCEgbIApqIQogJEEAIAIuAQxBB0gbIBFqIQkgJUEAIAIuAQpBBkgbIBJqIQ0gJkEAIAIuAQhBBUgbIBBqIREgKEEAIAIuAQZBBEgbIBhqIRIgLEEAIAIuAQRBA0gbIBtqIRAgLUEAIAIuAQJBAkgbIBxqIQcgMEEAIAIuAQBBAEwbIB1qIQ4gLyAeQQAgAi4BHkEQSBsgFGrBIhRMBEAgFEEQaiIUIBTBQQJ1ayEUIBNBDmoiEyATwUECdWshEyAWQQxqIhYgFsFBAnVrIRYgBkELaiIGIAbBQQJ1ayEGIAtBCmoiCyALwUECdWshCyAMQQlqIgwgDMFBAnVrIQwgCkEIaiIKIArBQQJ1ayEKIAlBB2oiCSAJwUECdWshCSANQQZqIg0gDcFBAnVrIQ0gEUEFaiIRIBHBQQJ1ayERIBJBBGoiEiASwUECdWshEiAQQQNqIhAgEMFBAnVrIRAgB0ECaiIHIAfBQQJ1ayEHIA5BAWoiDiAOwUECdWshDiAZQQ1qIhkgGcFBAnVrIRkgA0EPaiIDIAPBQQJ1ayEDCyAIIBQ7AR4gCCADOwEcIAggEzsBGiAIIBk7ARggCCAWOwEWIAggBjsBFCAIIAs7ARIgCCAMOwEQIAggCjsBDiAIIAk7AQwgCCANOwEKIAggETsBCCAIIBI7AQYgCCAQOwEEIAggBzsBAiAIIA47AQAgBUEPcUEIdCApciAVckEBdEEBciIIIA9PDQkgBCAIQQV0aiIIICdBAXRqIgYvAQAhAyAnBH8gAyAGQQJrLwEAawUgAwtB//8DcUECdEHMhuMAaioCACFVIAgvAR4iDkECdEHMhuMAaioCACFWIAgvARwhBiAILwEaIQcgCC8BGCEJIAgvARYhCyAILwEUIQwgCC8BEiENIAgvARAhCiAILwEOIREgCC8BDCESIAgvAQohECAILwEIIQUgCC8BBiEEIAgvAQQhFCAILwECIRggCC8BACEpQQAhAwNAIAIgA2ogFzsBACADQQJqIgNBIEcNAAsgAi8BHiEbIAIvARwgAi8BGiETIAIvARghFiACLwEWIRwgAi8BFCEdIAIvARIhHiACLwEQIR8gAi8BDiEgIAIvAQwhISACLwEKISIgAi8BCCEjIAIvAQYhJCACLwEEISUgAi8BAiEmIAIvAQAhKEEAIQMDQCACIANqICc7AQAgA0ECaiIDQSBHDQALQQAgAi4BHEEPSBsgBmohAyATQQAgAi4BGkEOSBsgB2ohEyAWQQAgAi4BGEENSBsgCWohGSAcQQAgAi4BFkEMSBsgC2ohFiAdQQAgAi4BFEELSBsgDGohDyAeQQAgAi4BEkEKSBsgDWohBiAfQQAgAi4BEEEJSBsgCmohCyAgQQAgAi4BDkEISBsgEWohDCAhQQAgAi4BDEEHSBsgEmohCiAiQQAgAi4BCkEGSBsgEGohCSAjQQAgAi4BCEEFSBsgBWohDSAkQQAgAi4BBkEESBsgBGohESAlQQAgAi4BBEEDSBsgFGohEiAmQQAgAi4BAkECSBsgGGohECAoQQAgAi4BAEEATBsgKWohByArIBtBACACLgEeQRBIGyAOasEiDkwEQCAOQRBqIg4gDsFBAnVrIQ4gE0EOaiIFIAXBQQJ1ayETIBZBDGoiBSAFwUECdWshFiAPQQtqIg8gD8FBAnVrIQ8gBkEKaiIGIAbBQQJ1ayEGIAtBCWoiCyALwUECdWshCyAMQQhqIgwgDMFBAnVrIQwgCkEHaiIKIArBQQJ1ayEKIAlBBmoiCSAJwUECdWshCSANQQVqIg0gDcFBAnVrIQ0gEUEEaiIRIBHBQQJ1ayERIBJBA2oiEiASwUECdWshEiAQQQJqIhAgEMFBAnVrIRAgB0EBaiIHIAfBQQJ1ayEHIBlBDWoiBSAFwUECdWshGSADQQ9qIgMgA8FBAnVrIQMLIAggDjsBHiAIIAM7ARwgCCATOwEaIAggGTsBGCAIIBY7ARYgCCAPOwEUIAggBjsBEiAIIAs7ARAgCCAMOwEOIAggCjsBDCAIIAk7AQogCCANOwEIIAggETsBBiAIIBI7AQQgCCAQOwECIAggBzsBACA0QfABcUEIdCAVciIIIAAoAnQiB08NCiAAKAJwIg4gCEEFdGoiCCAaQQF0ai8BACEDIC5BEE8EfyAaQQFrIgZBEE8NFCADIAggBkEBdGovAQBrBSADC0H//wNxQQJ0QcyG4wBqKgIAIVcgCC8BHiIQQQJ0QcyG4wBqKgIAIVggCC8BHCEGIAgvARohCSAILwEYIQsgCC8BFiEMIAgvARQhDSAILwESIQ8gCC8BECEKIAgvAQ4hESAILwEMIRIgCC8BCiEFIAgvAQghLiAILwEGIRggCC8BBCEpIAgvAQIhGyAILwEAIRxBACEDA0AgAiADaiAqOwEAIANBAmoiA0EgRw0ACyACLwEeISogAi8BHCACLwEaIRMgAi8BGCEUIAIvARYhFiACLwEUIRkgAi8BEiEdIAIvARAhHiACLwEOIR8gAi8BDCEgIAIvAQohISACLwEIISIgAi8BBiEjIAIvAQQhJCACLwECISUgAi8BACEmQQAhBANAIAIgBGogGjsBACAEQQJqIgRBIEcNAAtBACACLgEcQQ9IGyAGaiEEIBNBACACLgEaQQ5IGyAJaiEDIBRBACACLgEYQQ1IGyALaiEUIBZBACACLgEWQQxIGyAMaiETIBlBACACLgEUQQtIGyANaiEZIB1BACACLgESQQpIGyAPaiEWIB5BACACLgEQQQlIGyAKaiEPIB9BACACLgEOQQhIGyARaiEGICBBACACLgEMQQdIGyASaiELICFBACACLgEKQQZIGyAFaiEMICJBACACLgEIQQVIGyAuaiEKICNBACACLgEGQQRIGyAYaiEJICRBACACLgEEQQNIGyApaiENICVBACACLgECQQJIGyAbaiERICZBACACLgEAQQBMGyAcaiESIC8gKkEAIAIuAR5BEEgbIBBqwSIQTARAIBBBEGoiECAQwUECdWshECAEQQ9qIgUgBcFBAnVrIQQgFEENaiIFIAXBQQJ1ayEUIBNBDGoiBSAFwUECdWshEyAWQQpqIgUgBcFBAnVrIRYgD0EJaiIPIA/BQQJ1ayEPIAZBCGoiBiAGwUECdWshBiALQQdqIgsgC8FBAnVrIQsgDEEGaiIMIAzBQQJ1ayEMIApBBWoiCiAKwUECdWshCiAJQQRqIgkgCcFBAnVrIQkgDUEDaiINIA3BQQJ1ayENIBFBAmoiESARwUECdWshESASQQFqIhIgEsFBAnVrIRIgGUELaiIFIAXBQQJ1ayEZIANBDmoiAyADwUECdWshAwsgCCAQOwEeIAggBDsBHCAIIAM7ARogCCAUOwEYIAggEzsBFiAIIBk7ARQgCCAWOwESIAggDzsBECAIIAY7AQ4gCCALOwEMIAggDDsBCiAIIAo7AQggCCAJOwEGIAggDTsBBCAIIBE7AQIgCCASOwEAIDRBCHQgGkEQdHIgFXJBgIAEaiIVIAdPDQsgDiAVQQV0aiIVICdBAXRqIgMvAQAhCCAnBH8gCCADQQJrLwEAawUgCAtB//8DcUECdEHMhuMAaioCACFZIBUvAR4iDEECdEHMhuMAaioCACFaIBUvARwhCCAVLwEaIQMgFS8BGCEGIBUvARYhCyAVLwEUIQ0gFS8BEiEOIBUvARAhDyAVLwEOIQogFS8BDCERIBUvAQohEiAVLwEIIRAgFS8BBiEEIBUvAQQhGiAVLwECIS4gFS8BACEvQQAhCQNAIAIgCWogFzsBACAJQQJqIglBIEcNAAsgAi8BHiEqIAIvARwgAi8BGiEFIAIvARghEyACLwEWIRQgAi8BFCEWIAIvARIhGSACLwEQIRggAi8BDiE0IAIvAQwhKSACLwEKIRsgAi8BCCEcIAIvAQYhHSACLwEEIR4gAi8BAiEfIAIvAQAhIEEAIQkDQCACIAlqICc7AQAgCUECaiIJQSBHDQALQQAgAi4BHEEPSBsgCGohCSAFQQAgAi4BGkEOSBsgA2ohByATQQAgAi4BGEENSBsgBmohBSAUQQAgAi4BFkEMSBsgC2ohAyAWQQAgAi4BFEELSBsgDWohFyAZQQAgAi4BEkEKSBsgDmohFCAYQQAgAi4BEEEJSBsgD2ohCCA0QQAgAi4BDkEISBsgCmohEyApQQAgAi4BDEEHSBsgEWohGSAbQQAgAi4BCkEGSBsgEmohFiAcQQAgAi4BCEEFSBsgEGohDiAdQQAgAi4BBkEESBsgBGohDSAeQQAgAi4BBEEDSBsgGmohDyAfQQAgAi4BAkECSBsgLmohBiAgQQAgAi4BAEEATBsgL2ohCyArICpBACACLgEeQRBIGyAMasEiDEwEQCAMQRBqIgwgDMFBAnVrIQwgCUEPaiIJIAnBQQJ1ayEJIAdBDmoiByAHwUECdWshByAFQQ1qIgogCsFBAnVrIQUgA0EMaiIDIAPBQQJ1ayEDIBdBC2oiCiAKwUECdWshFyAUQQpqIgogCsFBAnVrIRQgE0EIaiIKIArBQQJ1ayETIBZBBmoiCiAKwUECdWshFiAOQQVqIg4gDsFBAnVrIQ4gDUEEaiINIA3BQQJ1ayENIA9BA2oiDyAPwUECdWshDyAGQQJqIgYgBsFBAnVrIQYgC0EBaiILIAvBQQJ1ayELIBlBB2oiCiAKwUECdWshGSAIQQlqIgggCMFBAnVrIQgLIBUgDDsBHiAVIAk7ARwgFSAHOwEaIBUgBTsBGCAVIAM7ARYgFSAXOwEUIBUgFDsBEiAVIAg7ARAgFSATOwEOIBUgGTsBDCAVIBY7AQogFSAOOwEIIBUgDTsBBiAVIA87AQQgFSAGOwECIBUgCzsBACA2IAAoAnwiCE8NDCAAKAJ4IgMgNkEFdGoiFSA+ID2TIBUqAgCSOAIAIBUgWiBZkyAVKgIEkjgCBCAVIEIgQZMgFSoCCJI4AgggFSBGIEWTIBUqAgySOAIMIBUgSiBJkyAVKgIQkjgCECAVIE4gTZMgFSoCFJI4AhQgFSBSIFGTIBUqAhiSOAIYIBUgViBVkyAVKgIckjgCHCAIIDdLDQ0gNyAIQbiGzgAQwyEACyAXIBRB3IbOABDDIQALIANBEEHMhs4AEMMhAAsgFiAUQdyGzgAQwyEACyAXIARB3IbOABDDIQALIBYgBEHchs4AEMMhAAsgAyAGQdyGzgAQwyEACyADIARB3IbOABDDIQALIAMgBEHchs4AEMMhAAsgCCAPQdyGzgAQwyEACyAIIA9B3IbOABDDIQALIAggB0Hchs4AEMMhAAsgFSAHQdyGzgAQwyEACyA2IAhBqIbOABDDIQALIAMgN0EFdGoiFSA8IDuTIBUqAgCSOAIAIBUgWCBXkyAVKgIEkjgCBCAVIEAgP5MgFSoCCJI4AgggFSBEIEOTIBUqAgySOAIMIBUgSCBHkyAVKgIQkjgCECAVIEwgS5MgFSoCFJI4AhQgFSBQIE+TIBUqAhiSOAIYIBUgVCBTkyAVKgIckjgCHCACQSBqJAAMAQsgAyAYQdyGzgAQwyEACyAxQRBqIDNqIDItAAA6AAAgM0EBakEHcSEzIDJBAWohMiABQQFrIgENAAsLIAAgACgCgAEgOmo2AoABCyAxQSBqJAAPCyAGQRBBzIbOABDDIQAL0QMBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDg4BAgMEBQYHCAkKCwwNDgALIAIgAEEBajYCDCABQcTN0QBBECACQQxqQbTN0QAQ0BMMDgsgAiAAQQRqNgIMIAFB5M3RAEESIAJBDGpB1M3RABDQEwwNCyACIABBBGo2AgwgAUGIztEAQQcgAkEMakH4zdEAENATDAwLIAIgAEEBajYCDCABQaDO0QBBFCACQQxqQZDO0QAQ0BMMCwsgAiAAQQFqNgIMIAFBtM7RAEESIAJBDGpBkM7RABDQEwwKCyABQcbO0QBBEBD7NQwJCyABQdbO0QBBDxD7NQwICyABQeXO0QBBEBD7NQwHCyABQfXO0QBBCxD7NQwGCyABQYDP0QBBExD7NQwFCyABQZPP0QBBEhD7NQwECyABQaXP0QBBFBD7NQwDCyACIABBBGo2AgwgAUHMz9EAQQ4gAkEMakG8z9EAENATDAILIAFB2s/RAEEWEPs1DAELIAIgAEEQajYCDCABQZDQ0QBBEkHuzNEAQQggAEEIakHwz9EAQfbM0QBBBiACQQxqQYDQ0QAQjhgLIAJBEGokAAuMAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFBAnRqKAIAIQMgAiAAKAIAIgQoAgAoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC+gCAQV/AkACQAJAIAEoAhAiAkGFwABPBEAgAkGFwABGDQEgAkGGwABNDQIgAkGHwABGDQMgASgCDCIBLQCGQCECIAEtAIRAIgNBCE8EQCADQQdxIANBA3ZBAWtBD3EiA3RB+P8DcUEDdkEBIAN0ciEFCyABLQCFQCEDIAJBCE8EQCACQQdxIAJBA3ZBAWtBD3EiAnRB+P8DcUEDdkEBIAJ0ciEECyABLQCHQCECQQAhASADQQhPBEAgA0EHcSADQQN2QQFrQQ9xIgN0Qfj/A3FBA3ZBASADdHIhBgsgACACQQhPBH8gAkEHcSACQQN2QQFrQQ9xIgF0Qfj/A3FBA3ZBASABdHIFIAELOwEGIAAgBjsBBCAAIAQ7AQIgACAFOwEADwtBhMAAIAJB/PTOABDDIQALQYXAAEGFwABBjPXOABDDIQALQYbAAEGGwABBnPXOABDDIQALQYfAAEGHwABBrPXOABDDIQALiQMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQF0ai8BACEDIAIgACgCACIEKAIAKAIAIgU2AiAgAiADNgIcAkACQAJAAkAgBawgA61+IgZCIIinIAanIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIGNwMIIAanQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuJAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFBA3RqKAIAIQMgAiAAKAIAIgQoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC4kDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAUEBdGouAQAhAyACIAAoAgAiBCgCACgCACIFNgIgIAIgAzYCHAJAAkACQAJAIAOsIAWsfiIGQiCIpyAGpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALiQMCBH8BfiMAQeAAayICJAAgACgCBCgCECABQQJ0aigCACEDIAIgACgCACIEKAIAKAIAIgU2AiAgAiADNgIcAkACQAJAAkAgA6wgBax+IgZCIIinIAanIgNBH3VHBEAgAkECNgI8IAJBrJD/ADYCOCACQgI3AkQgAkGCDDYCXCACQYIMNgJUIAIgAkHQAGo2AkAgAiACQSBqNgJYIAIgAkEcajYCUCACQShqIAJBOGoQmQ4gAkEQaiACQSxqKQIANwMAIAJBGGogAkE0aigCADYCACACQYiAgIB4NgIkIAIgAikCJCIGNwMIIAanQZOAgIB4Rw0BIAIoAgwhAwsgAyAEKAIELQAAEMQpRQ0BIAAoAgggAUECdGogAzYCAAwCCyACQQhqEIgRCyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAuGAwIGfwF+IwBBIGsiBSQAAkACQAJAIAJFBEAMAQsgAUEQaiEHA0AgAiADayEEAkACQCABKAI0IgZFBEAgASgCOCEIA0AgCEUEQCAHKAIARQ0HIAUgBxClGCAFKAIAQQFHDQYgBSkDCCIJUA0GIAlCAYNQRQRAIAEgCadBAnRBeHE2AjgMBQsgASAJQgGIPgI0IAVBEGogByABLQA8IgRBA3YgBEEHcUEAR2oQwRwgBSkDECEJIAEgBSkDGDcDCCABIAk3AwAgCacNBEHA+swAQS5B8PrMABCfKQALIAcoAgBFDQcgByAIIAQgBCAISxsgAS0APBCzFiIGDQJBACEIIAFBADYCOCABKAI0IgZFDQALCyABIAYgBiAEIAQgBksbIgRrNgI0IAMgBGohAwwBCyABIAEoAjggBms2AjggAyAGaiEDCyACIANLDQALCyAAQQg2AgAgACADNgIEIAVBIGokAA8LQZz4zABBGEGw+swAEMskAAtBnPjMAEEYQfT4zAAQyyQAC9EdAhF/A34jAEEwayIKJAAgCkEMaiEPIwBBgAFrIgMkACADQRBqIgIQvS8gA0EYaiIGQQEQlSQgA0HMAGogACAGIAIQnBAgA0HwAGoiAiADKAJUIgBBCGpBAEEBQQEQoBggAygCdCEGAkACQAJAIAMoAnBBAUcEQCADQQA2AmwgAyADKAJ4NgJoIAMgBjYCZEEEQQEQrTYiBkUNASAGQX82AAAgAyAGNgJ0IANBBDYCcCADQeQAaiIEQQQQ5S0gAygCaCADKAJsaiAGKAAANgAAIANBADYCeCADIAMoAmxBBGo2AmwgAhDeOyACQQRBAEEBQQEQoBggAygCdCEGIAMoAnBBAUYNAiADKAJ4IgUgADYAACADIAU2AnQgAyAGNgJwIARBBBDlLSADKAJoIAMoAmxqIAUoAAA2AAAgA0EANgJ4IAMgAygCbEEEajYCbCACEN47IAMoAlAhAiAEIAAQ5S0gAARAIAMoAmggAygCbGogAiAA/AoAAAsgA0EANgJUIAMgAygCbCAAajYCbCADQQhqIANB5ABqIhAQ3DsgAygCCCEOIAMoAgwhCCMAQTBrIgkkACAJQQhqIQJB+NnPAC0AACEEQQAhACAIQQNuIQYCQCAIQf////97SwRAQQAhBAwBCyAGQQJ0IQAgCCAGQQNsayIGRQRAQQEhBAwBCyAERQRAQQEhBEECQQMgBkEBRhsgAHIhAAwBCyAAQXxHIQQgAEEEaiEACyACIAA2AgQgAiAENgIAAkACQCAJKAIIQQFxBEAgCUEQaiAJKAIMQZD0zgAQzhggCSgCFCEGIAkoAhghBEEAIQUCQAJAAkACf0EAIQACQCAIQRtJDQAgCEEaayIAQQAgACAITRshDQJAA0AgCCAFQRpqTwRAIAdBYEYNAiAEIAdBIGoiAEkEQCAAIARBzJiBARCwOwALIAYgB2oiAiAFIA5qIgcpAAAiE0I4hiIUQjqIp0H72c8Aai0AADoAACACQQRqIBNCgICA+A+DQgiGIhVCIoinQfvZzwBqLQAAOgAAIAJBAWogFCATQoD+A4NCKIaEIhRCNIinQT9xQfvZzwBqLQAAOgAAIAJBAmogFCATQoCA/AeDQhiGIBWEhCIUQi6Ip0E/cUH72c8Aai0AADoAACACQQNqIBRCKIinQT9xQfvZzwBqLQAAOgAAIAJBBmogE0IIiEKAgID4D4MgE0IYiEKAgPwHg4QgE0IoiEKA/gODIBNCOIiEhCITpyIMQRZ2QT9xQfvZzwBqLQAAOgAAIAJBB2ogDEEQdkE/cUH72c8Aai0AADoAACACQQVqIBMgFIRCHIinQT9xQfvZzwBqLQAAOgAAIAJBCGogB0EGaikAACITQjiGIhRCOoinQfvZzwBqLQAAOgAAIAJBCWogFCATQoD+A4NCKIaEIhRCNIinQT9xQfvZzwBqLQAAOgAAIAJBCmogFCATQoCAgPgPg0IIhiIVIBNCgID8B4NCGIaEhCIUQi6Ip0E/cUH72c8Aai0AADoAACACQQtqIBRCKIinQT9xQfvZzwBqLQAAOgAAIAJBDGogFUIiiKdB+9nPAGotAAA6AAAgAkENaiAUIBNCCIhCgICA+A+DIBNCGIhCgID8B4OEIBNCKIhCgP4DgyATQjiIhIQiE4RCHIinQT9xQfvZzwBqLQAAOgAAIAJBDmogE6ciDEEWdkE/cUH72c8Aai0AADoAACACQQ9qIAxBEHZBP3FB+9nPAGotAAA6AAAgAkEQaiAHQQxqKQAAIhNCOIYiFEI6iKdB+9nPAGotAAA6AAAgAkERaiAUIBNCgP4Dg0IohoQiFEI0iKdBP3FB+9nPAGotAAA6AAAgAkESaiAUIBNCgICA+A+DQgiGIhUgE0KAgPwHg0IYhoSEIhRCLoinQT9xQfvZzwBqLQAAOgAAIAJBE2ogFEIoiKdBP3FB+9nPAGotAAA6AAAgAkEUaiAVQiKIp0H72c8Aai0AADoAACACQRZqIBNCCIhCgICA+A+DIBNCGIhCgID8B4OEIBNCKIhCgP4DgyATQjiIhIQiE6ciDEEWdkE/cUH72c8Aai0AADoAACACQRdqIAxBEHZBP3FB+9nPAGotAAA6AAAgAkEVaiATIBSEQhyIp0E/cUH72c8Aai0AADoAACACQRhqIAdBEmopAAAiE0I4hiIUQjqIp0H72c8Aai0AADoAACACQRlqIBQgE0KA/gODQiiGhCIUQjSIp0E/cUH72c8Aai0AADoAACACQRpqIBQgE0KAgID4D4NCCIYiFSATQoCA/AeDQhiGhIQiFEIuiKdBP3FB+9nPAGotAAA6AAAgAkEbaiAUQiiIp0E/cUH72c8Aai0AADoAACACQRxqIBVCIoinQfvZzwBqLQAAOgAAIAJBHWogFCATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOEQhyIp0E/cUH72c8Aai0AADoAACACQR5qIBOnIgdBFnZBP3FB+9nPAGotAAA6AAAgAkEfaiAHQRB2QT9xQfvZzwBqLQAAOgAAIAAhByANIAVBGGoiBU8NAQwDCwsgBUEaaiAIQbyYgQEQsDsAC0FgQQBBzJiBARCxOwALAkACQAJAAkACQAJ/AkACQAJAAkACQAJAIAggCEEDcCIMayINIAVNBEAgACECDAELA0AgBUF8Sw0CIAVBA2oiByAISw0DIABBe0sNBCAEIABBBGoiAkkEQCACIARBrJiBARCwOwALIAAgBmoiACAFIA5qIgUtAAAiEUECdkH72c8Aai0AADoAACAAQQNqIAVBAmotAAAiEkE/cUH72c8Aai0AADoAACAAQQJqIAVBAWotAAAiBUECdCASQQZ2ckE/cUH72c8Aai0AADoAACAAQQFqIBFBBHQgBUEEdnJBP3FB+9nPAGotAAA6AAAgAiEAIAciBSANSQ0ACwsgDEEBaw4CAwQGCyAFIAVBA2pBnJiBARCxOwALIAVBA2ogCEGcmIEBELA7AAsgACAAQQRqQayYgQEQsTsACyACIARJBEBBAiEHIAIgBmogDSAOai0AACIAQQJ2QfjZzwBqLQADOgAAIABBBHRBMHEgBCACQQFqIgBLDQIaIAAgBEGMmIEBEMMhAAsgAiAEQfyXgQEQwyEACyACIARPDQIgAiAGaiANIA5qLQAAIgdBAnZB+9nPAGotAAA6AAAgDUEBaiIAIAhPDQMgAkEBaiIFIARPDQQgBSAGaiAHQQR0IAAgDmotAAAiBUEEdnJBP3FB+9nPAGotAAA6AAAgAkECaiIAIARPDQVBAyEHIAVBAnRBPHELIQUgACAGaiAFQfjZzwBqLQADOgAAIAIgB2ohAgsgAgwECyACIARBvJeBARDDIQALIAAgCEHMl4EBEMMhAAsgBSAEQdyXgQEQwyEACyAAIARB7JeBARDDIQALIgBB+NnPAC0AAEEBRgR/IAAgBEsNAQJ/IAAgBmohByAEIABrIQVBACECAkBBACAAa0EDcSIIBEADQCACIAVGDQIgAiAHakE9OgAAIAggAkEBaiICRw0ACwsgCAwBCyAFIAVB3JaBARDDIQALBUEACyAAaksNAQwCCyAAIARBwPLOABCvOwALQdDyzgBBKkH88s4AEMskAAsgCSgCECEAIAlBHGogBiAEEJ0JAkAgCSgCHEUEQCAErSETIAYhBAwBCyAJKQIgIRMgAEGAgICAeEcNAiAGIQALIA8gEz4CCCAPIACtIAStQiCGhDcCACAJQTBqJAAMAgtB0PPOAEEtQYD0zgAQyyQACyAJIBM3AiggCSAANgIcIAkgBq0gBK1CIIaENwIgQaD0zgBBDCAJQRxqQaTvzgBBrPTOABDVHgALIBAQ3jsgA0HMAGoQ3jsgA0HYAGoQ3jsCQCADQRhqIgYoAgQiBEUNACAGKAIMIgUEQCAGKAIAIgBBCGohAiAAKQMAQn+FQoCBgoSIkKDAgH+DIRMDQCATUARAA0AgAEGABWshACACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyITQoCBgoSIkKDAgH9RDQALIBNCgIGChIiQoMCAf4UhEwsgACATeqdBA3ZBsH9sakHIAGsQ9yYgE0IBfSATgyETIAVBAWsiBQ0ACwsgBCAEQdAAbEHXAGpBeHEiAGpBCWoiAkUNACAGKAIAIABrIAJBCBD4OgsgA0E4ahDjPCADQYABaiQADAMLIAYgAygCeEHk3c8AEP0vAAtBAUEEEKM9AAsgBiADKAJ4QeSjzwAQ/S8ACyAKQRhqQQxBAEEBQQEQoBggCigCHCEIIAooAhhBAUcEQCAKKAIgIgdBCGpBxNnPACgAADYAACAHQbzZzwApAAA3AAACfyABKAJsQYCAgIB4RwRAIAEoAnQhCyABKAJwDAELIAFBADYCdCABQoCAgIDAADcCbEEECyEAIAFB7ABqIQYgC0EYbCELQX8hAgJAAkADQCALRQ0BIAtBGGshCyACQQFqIQIgACgCCCEEIAAoAgQgAEEYaiEAIARBvNnPAEEMEMEuRQ0ACyAKQRhqIQACQCAGKAIIIgUgAksEQCAAIAYoAgQgAkEYbGoiBCkCADcCACAAQQhqIARBCGopAgA3AgAgAEEQaiAEQRBqKQIANwIAIAUgAkF/c2pBGGwiAgRAIAQgBEEYaiAC/AoAAAsgBiAFQQFrNgIIDAELIwBBMGsiACQAIAAgBTYCBCAAIAI2AgAgAEEDNgIMIABB/MSJATYCCCAAQgI3AhQgACAAQQRqrUKAgICAsAeENwMoIAAgAK1CgICAgLAHhDcDICAAIABBIGo2AhAgAEEIakG03s8AEO8sAAsgABDeOyAKQSRqEIYwIAEoAnQiCyABKAJsRw0BIAZBxN7PABCRKAwBCyABKAJ0IgsgASgCbEcNACAGQaTezwAQkSgLIAEoAnAgC0EYbGoiAEEMNgIIIAAgBzYCBCAAIAg2AgAgACAKKQIMNwIMIABBFGogCkEUaigCADYCACABIAtBAWo2AnQgCkEwaiQADwsgCCAKKAIgQeSjzwAQ/S8AC/kCAgV/BH4jAEHwAGsiAiQAAkACQAJAIAEoAgwiBgR/IAEoAggiAyABKAIEIgRLDQIgASgCACEEIAEgBkEBazYCDCABIANBBGo2AgggAiADIARqKAAAIgQ6AB8gAkIBQgAgBEH/AHEQxiMgASgCECIDKQMAIgcgAikDACIIgyADKQMIIgkgAikDCCIKg4RQRQ0DIAMgByAIhDcDACADIAkgCoQ3AwhBAQVBAAtFDQAgASgCGCIDIAEoAiBGDQAgASADQcgAajYCGCADKAI0IgFBgICAgHhGDQAgAkEoaiIFIANBNPwKAAAgAkHoAGogA0FAaykDADcDACACIAE2AlwgAiADKQM4NwNgIAUQ0CkhBQsgACAFNgIEIAAgBDoAACACQfAAaiQADwsgAyAEQdDt/gAQrzsACyACQQE2AiwgAkH07f4ANgIoIAJCATcCNCACQfQLNgIkIAIgAkEgajYCMCACIAJBH2o2AiAgAkEoakH87f4AEO8sAAuRAwEGfyMAQaACayICJAAgASgCKCEDIAJB4AFqIAFBCGooAgA2AgAgAkEAOwGQAiACQQA2AowCIAJBADYC9AEgAkEANgLoASACIANBAnY2AuQBIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACIAEpAgA3AtgBIAJB3ABqIgQgAkG4AWoiBSABQSxqEMIZAkBBGEEEEK02IgMEQCADIAEpAhQ3AgAgAyABKQIgNwIMIANBCGogAUEcaigCADYCACADQRRqIAFBKGooAgA2AgAgAkECNgKcAiACIAM2ApgCIAJBAjYClAIgBSAEIAJBlAJqEJYpQcQAQQQQrTYiA0UNASADIAEoAgwiBiABKAIQIgcoAghBAWtBeHFqQQhqIAcoAhQRAAAgAkEBNgJkIAIgAzYCYCACQQE2AlwgAiAFIAQQ/CIgACACEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQQxqELsjCyACQaACaiQADwtBBEEYEKM9AAtBBEHEABCjPQALkQMBBn8jAEGgAmsiAiQAIAEoAighAyACQeABaiABQQhqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQN2NgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQIANwLYASACQdwAaiIEIAJBuAFqIgUgAUEsahDCGQJAQRhBBBCtNiIDBEAgAyABKQIUNwIAIAMgASkCIDcCDCADQQhqIAFBHGooAgA2AgAgA0EUaiABQShqKAIANgIAIAJBAjYCnAIgAiADNgKYAiACQQI2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABKAIMIgYgASgCECIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCAGIAYoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBGBCjPQALQQRBxAAQoz0AC9sCAQp/IAAgAUECdEEEayIEaiEHIAIgBGohCCAAIAFBAXYiCkECdGoiBEEEayEFA0AgAiAAIAQgBCgCACIDKAIEIAAoAgAiBigCBCADKAIIIgMgBigCCCIGIAMgBkkbEJknIgkgAyAGayAJGyIJQQBOIgsbKAIANgIAIAggByAFIAcoAgAiAygCBCAFKAIAIgYoAgQgAygCCCIDIAYoAggiBiADIAZJGxCZJyIMIAMgBmsgDBsiA0EAThsoAgA2AgAgACALQQJ0aiEAIAQgCUEddkEEcWohBCAFIANBH3UiA0ECdGohBSAHIANBf3NBAnRqIQcgCEEEayEIIAJBBGohAiAKQQFrIgoNAAsgBUEEaiEFIAFBAXEEfyACIAAgBCAAIAVJIgEbKAIANgIAIAQgACAFT0ECdGohBCAAIAFBAnRqBSAACyAFRyAEIAdBBGpHckUEQA8LEOQrAAuHAwIFfwN+IwBBIGsiAiQAAkACQAJAIAEOAgACAQsgAEEANgIIDAELIAFpQQFHBEAgACgCCCIDRQ0BIAAoAgQhBCADQQJ0IQUgAa0hCUEAIQEDQCABIARqIgYgBjUCACAJfiAHfCIIPgIAIAhCIIghByAFIAFBBGoiAUcNAAsgCEKAgICAEFQNASAAKAIAIANGBH8gAEGAjYgBEJ0oIAAoAgQFIAQLIANBAnRqIAc+AgAgACADQQFqNgIIDAELIAAoAgQhAyAAKAIAIQQgAEGwjYgBKQIANwIAIABBCGoiBigCACEFIAZBuI2IASgCADYCAAJAAkACQCAEQYCAgIB4RgRAIAMoAggNASACQQhqIAMQ6R0MAwsgBUUNAQsgAiAFNgIcIAIgAzYCGCACIAQ2AhQgAkEIaiACQRRqQQAgAWgQqAUMAQsgAkEANgIQIAIgAzYCDCACIAQ2AggLIABBBEEEEOAeIABBCGogAkEQaigCADYCACAAIAIpAgg3AgALIAJBIGokAAuOAwIFfwFvIwBBMGsiACQAIABBIGpBzKuIARD9KSAAKAIkIQICQCAAKAIgIgRBAXEEQCAEIQEgAiEDDAELIABBGGpB0KuIARD9KSAAKAIcIQMgACgCGCEBIARFIAJBhAFJcg0AIAIQ8h8LAkAgAUEBcQRAIAEhAiADIQQMAQsgAEEQakHIq4gBEP0pIAAoAhQhBCAAKAIQIQIgAUUgA0GEAUlyDQAgAxDyHwsCQCACQQFxBEAgAiEDIAQhAQwBCyAAQQhqQdSriAEQ/SkgACgCDCEBIAAoAgghAyACRSAEQYQBSXINACAEEPIfCwJAAkAgA0EBcUUNACAAIAE2AiwgAEEsahCpO0UNASABQYQBSQ0AIAEQ8h8LQdiriAFBCxA9IQUQ3xIiASAFJgEgACABNgIoIABBgAE2AiwgACAAQShqIABBLGoQgiQgACgCACICQQFxRSAAKAIEIgNBhAFJckUEQCADEPIfCyABQYQBTwRAIAEQ8h8LQYABIAMgAkEBcRshAQsgAEEwaiQAIAEL3y8BFH8jAEEQayIXJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIAEiAiACQQF2aiIGBEAgBCgCACEEA0ACQAJ/IAIgBkEBayIGTQRAIAYgAmsMAQsgAC0AACEBIAAgACAGaiIDLQAAOgAAIAMgAToAAEEACyIDQQF0IgdBAXIiASACIAYgAiAGSRsiDE8NAANAIAdBAmoiByAMSQRAIAAgAWogACAHaiAEKAIAKAIAEQIAQR92IAFqIQELIAAgA2oiAyAAIAFqIgcgBCgCACgCABECAEEATg0BIAMtAAAhBSADIActAAA6AAAgByAFOgAAIAEhAyABQQF0IgdBAXIiASAMSQ0ACwsgBg0ACwsMAwsgACABQQN2IgxBB2xqIQYgACAMQQJ0aiEHAn8gAUHAAE8EQCAAIAcgBiAMIAQQyxgMAQsgACAAIAcgBCgCACIMKAIAKAIAEQIAIgUgACAGIAwoAgAoAgARAgBzQQBIDQAaIAYgByAHIAYgDCgCACgCABECACAFc0EASBsLIABrIQYCQAJAIAJFDQAgAiAAIAZqIgcgBCgCACgCACgCABECAEEASA0AIBcgBDYCDAJ/QQAgAUUNABogF0EMaiECAkAgASAGTQ0AIAAtAAAhBiAAIActAAA6AAAgByAGOgAAIABBAWohByMAQRBrIgUkACABQQFrIg0EfyAFIActAAA6AA8gAigCACEJQQAhDCAHIgZBAWoiAiAGIA1qIg1BAWsiEEkEQCAGIQIDQCAAIAJBAWoiCiAJKAIAKAIAKAIAEQIAIRIgAiAHIAxqIgYtAAA6AAAgBiAKLQAAOgAAIAAgAkECaiIGIAkoAgAoAgAoAgARAgAhEyAKIAcgDCASQX9zQR92aiIMaiIKLQAAOgAAIAogBi0AADoAACAMIBNBf3NBH3ZqIQwgAkEDaiAGIQIgEEkNAAsgBkEBaiECCyACIA1HBEADQCAAIAIgCSgCACgCACgCABECACEKIAYgByAMaiIGLQAAOgAAIAYgAi0AADoAACAMIApBf3NBH3ZqIQwgAiIGQQFqIgIgDUcNAAsgAkEBayEGCyAAIAVBD2ogCSgCACgCACgCABECACECIAYgByAMaiIGLQAAOgAAIAYgBS0ADzoAACAMIAJBf3NBH3ZqBUEACyECIAVBEGokACABIAJNDQAgAC0AACEGIAAgACACaiIHLQAAOgAAIAcgBjoAACACDAELAAsiBkEBaiECIAEgBksEQCAAIAJqIQAgASACayEBQQAhAgwCCyACIAFB0PHQABCvOwALIAACf0EAIAFFDQAaAkAgASAGTQ0AIAAtAAAhByAAIAAgBmoiBi0AADoAACAGIAc6AAAgAEEBaiEMIwBBEGsiCSQAIAFBAWsiCgR/IAkgDC0AADoADyAEKAIAIQ1BACEFIAwiB0EBaiIGIAcgCmoiCkEBayISSQRAIAchBgNAIAZBAWoiECAAIA0oAgAoAgARAgAhEyAGIAUgDGoiBy0AADoAACAHIBAtAAA6AAAgBkECaiIHIAAgDSgCACgCABECACAQIAwgE0EfdiAFaiIFaiIQLQAAOgAAIBAgBy0AADoAAEEfdiAFaiEFIAZBA2ogByEGIBJJDQALIAZBAWohBgsgBiAKRwRAA0AgBiAAIA0oAgAoAgARAgAgByAFIAxqIgctAAA6AAAgByAGLQAAOgAAQR92IAVqIQUgBiEHIAZBAWoiBiAKRw0ACyAGQQFrIQcLIAlBD2ogACANKAIAKAIAEQIAIAcgBSAMaiIHLQAAOgAAIAcgCS0ADzoAAEEfdiAFagVBAAshBiAJQRBqJAAgASAGTQ0AIAAtAAAhByAAIAAgBmoiDC0AADoAACAMIAc6AAAgBgwBCwALIgYgAiADIAQQ5Q4gASAGQX9zaiEBIAAgBmoiAkEBaiEACyADQQFrIQMgAUEhTw0ACwsgACEDIwBBIGsiBiQAAkACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgwgAUESSSIYGyECIAEgDGshByAAIAxqIQwDQAJ/IAJBDE0EQEEBIAJBCE0NARoCQCACQQlPBEAgACAAQQNqIgkgACAEKAIAIgUoAgAoAgARAgAiDUEfdUEDcWotAAAhCiAAIABBA0EAIA1BAE4bai0AADoAAyAAIAo6AAAgAEEHQQEgAEEHaiISIABBAWoiEyAFKAIAKAIAEQIAQQBIIg0bai0AACEKIAAgAEEBQQcgDRtqLQAAOgAHIAAgCjoAASAAQQVBAiAAQQVqIg0gAEECaiIQIAUoAgAoAgARAgBBAEgiChtqLQAAIQ4gACAAQQJBBSAKG2otAAA6AAUgACAOOgACIABBCEEEIABBCGoiFCAAQQRqIgogBSgCACgCABECAEEASCIOG2otAAAhCyAAIABBBEEIIA4bai0AADoACCAAIAs6AAQgACASIAAgBSgCACgCABECACIOQR91QQdxai0AACELIAAgAEEHQQAgDkEAThtqLQAAOgAHIAAgCzoAACAAQQRBAiAKIBAgBSgCACgCABECAEEASCIOG2otAAAhCyAAIABBAkEEIA4bai0AADoABCAAIAs6AAIgAEEIQQMgFCAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIQsgACAAQQNBCCAOG2otAAA6AAggACALOgADIABBBkEFIABBBmoiDiANIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQVBBiALG2otAAA6AAYgACAPOgAFIAAgECAAIAUoAgAoAgARAgAiC0EedkECcWotAAAhDyAAIAAgC0F/c0EedkECcWotAAA6AAIgACAPOgAAIABBA0EBIAkgEyAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEEBQQMgCxtqLQAAOgADIAAgDzoAASAAQQVBBCANIAogBSgCACgCABECAEEASCILG2otAAAhDyAAIABBBEEFIAsbai0AADoABSAAIA86AAQgAEEIQQcgFCASIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQdBCCALG2otAAA6AAggACAPOgAHIABBBEEBIAogEyAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEEBQQQgCxtqLQAAOgAEIAAgDzoAASAAQQZBAyAOIAkgBSgCACgCABECAEEASCILG2otAAAhDyAAIABBA0EGIAsbai0AADoABiAAIA86AAMgAEEHQQUgEiANIAUoAgAoAgARAgBBAEgiCxtqLQAAIQ8gACAAQQVBByALG2otAAA6AAcgACAPOgAFIAAgEyAAIAUoAgAoAgARAgAiC0EfdmotAAAhDyAAIAAgC0F/c0EfdmotAAA6AAEgACAPOgAAIABBBEECIAogECAFKAIAKAIAEQIAQQBIIgsbai0AACEPIAAgAEECQQQgCxtqLQAAOgAEIAAgDzoAAiAAQQVBAyANIAkgBSgCACgCABECAEEASCILG2otAAAhDyAAIABBA0EFIAsbai0AADoABSAAIA86AAMgAEEIQQYgFCAOIAUoAgAoAgARAgBBAEgiFBtqLQAAIQsgACAAQQZBCCAUG2otAAA6AAggACALOgAGIABBA0ECIAkgECAFKAIAKAIAEQIAQQBIIhQbai0AACELIAAgAEECQQMgFBtqLQAAOgADIAAgCzoAAiAAQQVBBCANIAogBSgCACgCABECAEEASCIUG2otAAAhCyAAIABBBEEFIBQbai0AADoABSAAIAs6AAQgAEEHQQYgEiAOIAUoAgAoAgARAgBBAEgiEhtqLQAAIRQgACAAQQZBByASG2otAAA6AAcgACAUOgAGIABBAkEBIBAgEyAFKAIAKAIAEQIAQQBIIhAbai0AACESIAAgAEEBQQIgEBtqLQAAOgACIAAgEjoAASAAQQRBAyAKIAkgBSgCACgCABECAEEASCIJG2otAAAhCiAAIABBA0EEIAkbai0AADoABCAAIAo6AAMgAEEGQQUgDiANIAUoAgAoAgARAgBBAEgiBRtqLQAAIQkgACAAQQVBBiAFG2otAAA6AAYgACAJOgAFDAELAAtBCQwBCwJAIAJBDU8EQCAAIABBDGoiESAAIAQoAgAiBSgCACgCABECACIJQR91QQxxai0AACENIAAgAEEMQQAgCUEAThtqLQAAOgAMIAAgDToAACAAQQpBASAAQQpqIg4gAEEBaiIPIAUoAgAoAgARAgBBAEgiCRtqLQAAIQ0gACAAQQFBCiAJG2otAAA6AAogACANOgABIABBCUECIABBCWoiDSAAQQJqIhQgBSgCACgCABECAEEASCIJG2otAAAhCiAAIABBAkEJIAkbai0AADoACSAAIAo6AAIgAEEHQQMgAEEHaiILIABBA2oiCiAFKAIAKAIAEQIAQQBIIgkbai0AACEQIAAgAEEDQQcgCRtqLQAAOgAHIAAgEDoAAyAAQQtBBSAAQQtqIhYgAEEFaiIQIAUoAgAoAgARAgBBAEgiCRtqLQAAIRIgACAAQQVBCyAJG2otAAA6AAsgACASOgAFIABBCEEGIABBCGoiEiAAQQZqIgkgBSgCACgCABECAEEASCITG2otAAAhCCAAIABBBkEIIBMbai0AADoACCAAIAg6AAYgAEEGQQEgCSAPIAUoAgAoAgARAgBBAEgiExtqLQAAIQggACAAQQFBBiATG2otAAA6AAYgACAIOgABIABBA0ECIAogFCAFKAIAKAIAEQIAQQBIIhMbai0AACEIIAAgAEECQQMgExtqLQAAOgADIAAgCDoAAiAAQQtBBCAWIABBBGoiEyAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEEQQsgCBtqLQAAOgALIAAgFToABCAAQQlBByANIAsgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBB0EJIAgbai0AADoACSAAIBU6AAcgAEEKQQggDiASIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQhBCiAIG2otAAA6AAogACAVOgAIIAAgEyAAIAUoAgAoAgARAgAiCEEddkEEcWotAAAhFSAAIAAgCEF/c0EddkEEcWotAAA6AAQgACAVOgAAIABBAkEBIBQgDyAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEBQQIgCBtqLQAAOgACIAAgFToAASAAQQZBAyAJIAogBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBA0EGIAgbai0AADoABiAAIBU6AAMgAEEIQQcgEiALIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQdBCCAIG2otAAA6AAggACAVOgAHIABBCkEJIA4gDSAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEJQQogCBtqLQAAOgAKIAAgFToACSAAQQxBCyARIBYgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBC0EMIAgbai0AADoADCAAIBU6AAsgAEEGQQQgCSATIAUoAgAoAgARAgBBAEgiCBtqLQAAIRUgACAAQQRBBiAIG2otAAA6AAYgACAVOgAEIABBCUEFIA0gECAFKAIAKAIAEQIAQQBIIggbai0AACEVIAAgAEEFQQkgCBtqLQAAOgAJIAAgFToABSAAQQtBCCAWIBIgBSgCACgCABECAEEASCIIG2otAAAhFSAAIABBCEELIAgbai0AADoACyAAIBU6AAggAEEMQQogESAOIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQpBDCARG2otAAA6AAwgACAIOgAKIAAgECAAIAUoAgAoAgARAgAiEUEfdUEFcWotAAAhCCAAIABBBUEAIBFBAE4bai0AADoABSAAIAg6AAAgAEEIQQMgEiAKIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQNBCCARG2otAAA6AAggACAIOgADIABBB0EEIAsgEyAFKAIAKAIAEQIAQQBIIhEbai0AACEIIAAgAEEEQQcgERtqLQAAOgAHIAAgCDoABCAAQQtBBiAWIAkgBSgCACgCABECAEEASCIRG2otAAAhCCAAIABBBkELIBEbai0AADoACyAAIAg6AAYgAEEKQQkgDiANIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQlBCiARG2otAAA6AAogACAIOgAJIAAgDyAAIAUoAgAoAgARAgAiEUEfdmotAAAhCCAAIAAgEUF/c0EfdmotAAA6AAEgACAIOgAAIABBBUECIBAgFCAFKAIAKAIAEQIAQQBIIhEbai0AACEIIAAgAEECQQUgERtqLQAAOgAFIAAgCDoAAiAAQQlBBiANIAkgBSgCACgCABECAEEASCIRG2otAAAhCCAAIABBBkEJIBEbai0AADoACSAAIAg6AAYgAEEIQQcgEiALIAUoAgAoAgARAgBBAEgiERtqLQAAIQggACAAQQdBCCARG2otAAA6AAggACAIOgAHIABBC0EKIBYgDiAFKAIAKAIAEQIAQQBIIhYbai0AACERIAAgAEEKQQsgFhtqLQAAOgALIAAgEToACiAAQQNBASAKIA8gBSgCACgCABECAEEASCIWG2otAAAhESAAIABBAUEDIBYbai0AADoAAyAAIBE6AAEgAEEEQQIgEyAUIAUoAgAoAgARAgBBAEgiFhtqLQAAIREgACAAQQJBBCAWG2otAAA6AAQgACAROgACIABBBkEFIAkgECAFKAIAKAIAEQIAQQBIIhYbai0AACERIAAgAEEFQQYgFhtqLQAAOgAGIAAgEToABSAAQQpBCSAOIA0gBSgCACgCABECAEEASCIOG2otAAAhFiAAIABBCUEKIA4bai0AADoACiAAIBY6AAkgAEECQQEgFCAPIAUoAgAoAgARAgBBAEgiDhtqLQAAIQ8gACAAQQFBAiAOG2otAAA6AAIgACAPOgABIABBBEEDIBMgCiAFKAIAKAIAEQIAQQBIIg4bai0AACEPIAAgAEEDQQQgDhtqLQAAOgAEIAAgDzoAAyAAQQdBBSALIBAgBSgCACgCABECAEEASCIOG2otAAAhDyAAIABBBUEHIA4bai0AADoAByAAIA86AAUgAEEIQQYgEiAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIQ8gACAAQQZBCCAOG2otAAA6AAggACAPOgAGIABBA0ECIAogFCAFKAIAKAIAEQIAQQBIIg4bai0AACEUIAAgAEECQQMgDhtqLQAAOgADIAAgFDoAAiAAQQVBBCAQIBMgBSgCACgCABECAEEASCIOG2otAAAhFCAAIABBBEEFIA4bai0AADoABSAAIBQ6AAQgAEEHQQYgCyAJIAUoAgAoAgARAgBBAEgiDhtqLQAAIRQgACAAQQZBByAOG2otAAA6AAcgACAUOgAGIABBCUEIIA0gEiAFKAIAKAIAEQIAQQBIIg0bai0AACESIAAgAEEIQQkgDRtqLQAAOgAJIAAgEjoACCAAQQRBAyATIAogBSgCACgCABECAEEASCING2otAAAhCiAAIABBA0EEIA0bai0AADoABCAAIAo6AAMgAEEGQQUgCSAQIAUoAgAoAgARAgBBAEgiBRtqLQAAIQkgACAAQQVBBiAFG2otAAA6AAYgACAJOgAFDAELAAtBDQsiBUEBayACTw0CIAIgBUcEQANAIAAgACAFaiAEEMAeIAIgBUEBaiIFRw0ACwsgGA0BIAAgA0YgByECIAwhAA0ACyABQQFrIgcgBiICaiEJIAcgAyIAaiEMIAAgAUEBdiINaiIHQQFrIQUgBCgCACEEA0AgAiAAIAcgByAAIAQoAgAoAgARAgAiCkEATiIQGy0AADoAACAJIAwgBSAMIAUgBCgCACgCABECACISQQBOIhMbLQAAOgAAIAAgEGohACAHIApBH3ZqIQcgBSASQR91aiEFIAwgE2shDCAJQQFrIQkgAkEBaiECIA1BAWsiDQ0ACyAFQQFqIQQgAUEBcQR/IAIgACAHIAAgBEkiAhstAAA6AAAgByAAIARPaiEHIAAgAmoFIAALIARHIAcgDEEBakdyBEAQ5CsACyABRQ0AIAMgBiAB/AoAAAsgBkEgaiQADAELAAsLIBdBEGokAAucAwICfwJ+IwBBkAFrIgIkACAAKAIEKAIQIAFBA3RqKQMAIQQgAiAAKAIAIgMoAgAoAgApAwAiBTcDSCACIAQ3A0AgAkEQaiAEIARCP4cgBSAFQj+HEKgeAkACQAJAIAIpAxggAikDECIEQj+HUgRAIAJBAjYCbCACQayQ/wA2AmggAkICNwJ0IAJBhgw2AowBIAJBhgw2AoQBIAIgAkGAAWo2AnAgAiACQcgAajYCiAEgAiACQUBrNgKAASACQdgAaiACQegAahCZDiACQTRqIAJB3ABqKQIANwIAIAJBPGogAkHkAGooAgA2AgAgAkGIgICAeDYCVCACIAIpAlQ3AiwgAkEBNgIoIAJBKGpBBHIQiBEMAQsgBCADKAIELQAAEMUpRQ0AIAAoAgggAUEDdGogBDcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkGQAWokAA8LIAAgA0GIi/8AEMMhAAuGAwIEfwF+IwBB4ABrIgIkACAAKAIEKAIQIAFqLAAAIQMgAiAAKAIAIgQoAgAoAgAiBTYCICACIAM2AhwCQAJAAkACQCADrCAFrH4iBkIgiKcgBqciA0EfdUcEQCACQQI2AjwgAkGskP8ANgI4IAJCAjcCRCACQYIMNgJcIAJBggw2AlQgAiACQdAAajYCQCACIAJBIGo2AlggAiACQRxqNgJQIAJBKGogAkE4ahCZDiACQRBqIAJBLGopAgA3AwAgAkEYaiACQTRqKAIANgIAIAJBiICAgHg2AiQgAiACKQIkIgY3AwggBqdBk4CAgHhHDQEgAigCDCEDCyADIAQoAgQtAAAQxClFDQEgACgCCCABQQJ0aiADNgIADAILIAJBCGoQiBELIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC4YDAgR/AX4jAEHgAGsiAiQAIAAoAgQoAhAgAWotAAAhAyACIAAoAgAiBCgCACgCACIFNgIgIAIgAzYCHAJAAkACQAJAIAWsIAOtfiIGQiCIpyAGpyIDQR91RwRAIAJBAjYCPCACQayQ/wA2AjggAkICNwJEIAJBggw2AlwgAkGCDDYCVCACIAJB0ABqNgJAIAIgAkEgajYCWCACIAJBHGo2AlAgAkEoaiACQThqEJkOIAJBEGogAkEsaikCADcDACACQRhqIAJBNGooAgA2AgAgAkGIgICAeDYCJCACIAIpAiQiBjcDCCAGp0GTgICAeEcNASACKAIMIQMLIAMgBCgCBC0AABDEKUUNASAAKAIIIAFBAnRqIAM2AgAMAgsgAkEIahCIEQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALnAMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQJ0ajQCACEEIAIgACgCACIDKAIAKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQAL7QIBDH8jAEEQayIGJAACQCABKAIQIgMgASgCDCICSQ0AIAMgASgCCCIHSw0AIAFBE2ohDCABQRRqIQ0DQCABKAIEIAJqIQogDCABLQAYIgRqLQAAIQgCQAJAAkAgAyACayILQQdNBEAgAiADRg0BQQAhBQNAIAUgCmotAAAgCEYNBCALIAVBAWoiBUcNAAsMAQsgBkEIaiAIIAogCxCdEiAGKAIIQQFxDQEgASgCECEDCyABIAM2AgwMAwsgBigCDCEFIAEtABghBCABKAIIIQcgASgCDCECCyABIAIgBWpBAWoiAjYCDAJAIAIgBEkgAiAHS3INACAEQQVJBEAgAiAEayIIIAEoAgRqIAQgDSAEEMEuIAEoAgwhAkUEQCABKAIIIQcMAgsgACACNgIIIAAgCDYCBEEBIQkMAwsgBEEEQaDDgAEQsDsACyABKAIQIgMgAkkNASADIAdNDQALCyAAIAk2AgAgBkEQaiQAC5IDAgd/AX4jAEHwAmsiAiQAIAFBGGoiCBD0NSEDIAJB6AFqQZSo0KABNgIAIAJClKjQoMGChYoUNwLgASACQgQ3AtgBIAJCADcC0AEgAkKAgICAwAA3AsgBIAJBADYCwAEgAkEAOwGYAiACQQA2ApQCIAJBADYC/AEgAkEANgLwASACIAM2AuwBIAJB6ABqIAFBFGoiAygCADYCACADQQA2AgAgASkCDCEJIAFCgICAgMAANwIMIAIgCTcDYCACQaACaiIGIAJB4ABqIgQQ8RggBCACQcABaiIHIAYQ+iMgAkHIAWogAUEIaiIFKAIANgIAIAVBADYCACABKQIAIQkgAUKAgICAEDcCACACIAk3A8ABIAYgBxCTGSAHIAQgBhD6IyAEIAgQ9BIgAkEEaiAHIAQQwhkgBSgCACEFIAMoAgAiAyABKAIMRgRAIAFBDGpB3OaFARCdKAsgASgCECADQQJ0aiAFNgIAIAEgA0EBajYCFCACQawCaiIBIAJBBGoQzRwgACABEI0MIAJB8AJqJAALkgMCB38BfiMAQfACayICJAAgAUEYaiIIEPQ1IQMgAkHoAWpBlqzYsAE2AgAgAkKWrNiw4cKFixY3AuABIAJCBDcC2AEgAkIANwLQASACQoCAgIDAADcCyAEgAkEANgLAASACQQA7AZgCIAJBADYClAIgAkEANgL8ASACQQA2AvABIAIgAzYC7AEgAkHoAGogAUEUaiIDKAIANgIAIANBADYCACABKQIMIQkgAUKAgICAgAE3AgwgAiAJNwNgIAJBoAJqIgUgAkHgAGoiBBDzGCAEIAJBwAFqIgYgBRD6IyACQcgBaiABQQhqIgcoAgA2AgAgB0EANgIAIAEpAgAhCSABQoCAgIAQNwIAIAIgCTcDwAEgBSAGEJMZIAYgBCAFEPojIAQgCBD0EiACQQRqIAYgBBDCGSAHNQIAIQkgAygCACIDIAEoAgxGBEAgAUEMakHc5oUBELMoCyABKAIQIANBA3RqIAk3AwAgASADQQFqNgIUIAJBrAJqIgEgAkEEahDNHCAAIAEQiwwgAkHwAmokAAuSAwIHfwF+IwBB8AJrIgIkACABQRhqIggQ9DUhAyACQegBakGYsODAATYCACACQpiw4MCBg4aMGDcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiADNgLsASACQegAaiABQRRqIgMoAgA2AgAgA0EANgIAIAEpAgwhCSABQoCAgIDAADcCDCACIAk3A2AgAkGgAmoiBiACQeAAaiIEEPEYIAQgAkHAAWoiByAGEPojIAJByAFqIAFBCGoiBSgCADYCACAFQQA2AgAgASkCACEJIAFCgICAgBA3AgAgAiAJNwPAASAGIAcQkxkgByAEIAYQ+iMgBCAIEPQSIAJBBGogByAEEMIZIAUoAgAhBSADKAIAIgMgASgCDEYEQCABQQxqQdzmhQEQnSgLIAEoAhAgA0ECdGogBTYCACABIANBAWo2AhQgAkGsAmoiASACQQRqEM0cIAAgARCODCACQfACaiQAC5IDAgd/AX4jAEHwAmsiAiQAIAFBGGoiCBD0NSEDIAJB6AFqQZmy5MgBNgIAIAJCmbLkyJGjxowZNwLgASACQgQ3AtgBIAJCADcC0AEgAkKAgICAwAA3AsgBIAJBADYCwAEgAkEAOwGYAiACQQA2ApQCIAJBADYC/AEgAkEANgLwASACIAM2AuwBIAJB6ABqIAFBFGoiAygCADYCACADQQA2AgAgASkCDCEJIAFCgICAgIABNwIMIAIgCTcDYCACQaACaiIFIAJB4ABqIgQQ8xggBCACQcABaiIGIAUQ+iMgAkHIAWogAUEIaiIHKAIANgIAIAdBADYCACABKQIAIQkgAUKAgICAEDcCACACIAk3A8ABIAUgBhCTGSAGIAQgBRD6IyAEIAgQ9BIgAkEEaiAGIAQQwhkgBzUCACEJIAMoAgAiAyABKAIMRgRAIAFBDGpB3OaFARCzKAsgASgCECADQQN0aiAJNwMAIAEgA0EBajYCFCACQawCaiIBIAJBBGoQzRwgACABEIwMIAJB8AJqJAAL/QICB38BfiMAQSBrIgQkAEGAgICAeCECAkAgASgCACIFQYCAgIB4RgRAIAEoAgwhBwwBCyABKAIIQQN0IQMgASgCBCIIIQICQANAIAMEQCADQQhrIQMgAi0ABCACQQhqIQINAQwCCwsgBEKEgICAwAA3AhAgBEKAgICAwAA3AhggBEEEaiAEQRBqEOcMIAFBBEEIEOAeIAFBCGogBEEMaigCADYCACABIAQpAgQ3AgAgASgCBCEIIAEoAgAhBQtBgICAgHghAiABKAIMIQcgBUGAgICAeEYNACABKQIEIglCIIinIQMCQCAJQoCAgIAQVA0AIAmnIgEgA0EDdCICakEIRg0AIAEgAmoiAkEEay0AAEEBRw0AIANBAWshASACQRBrIQIDQCABIgNFIAJFcg0BIAFBAWshASACQQRqIAJBCGshAi0AAEEBRg0ACwsgBSECCyAAIAM2AgwgAEEANgIIIAAgCDYCBCAAIAI2AgAgACAHNgIQIARBIGokAAuCAwEEfyMAQTBrIgIkACAAKAIAIgBBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEEAkBBACAAKAIwIgVrQQNxIgMgACgCCCAFa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAQgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIARBBBCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBCIDQQNLBEAgAigCACADIAFrNgAAIAAoAjAhAyAAKAIUIgEgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAUEDdGoiBEEIOwEEIAQgAzYCACAAIAFBAWo2AhQgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALggMBBH8jAEEwayICJAAgACgCACIAQQQgACgCNCIDIANBBE0bNgI0IABBMGohBAJAQQAgACgCMCIFa0EDcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EDSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAEQQQQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQQgAkEIaiAAKAIwEIw3IAIgBCADIAIoAgggAigCDEGsx/4AENcmIAIoAgQiA0EDSwRAIAIoAgAgAyABazYAACAAKAIwIQMgACgCFCIBIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIAFBA3RqIgRBBjsBBCAEIAM2AgAgACABQQFqNgIUIAJBMGokAA8LIAJBADYCKCACQQE2AhwgAkH0yP4ANgIYIAJCBDcCICACQRhqQbzH/gAQ7ywAC4IDAQR/IwBBMGsiAiQAIAAoAgAiAEEEIAAoAjQiAyADQQRNGzYCNCAAQTBqIQQCQEEAIAAoAjAiBWtBA3EiAyAAKAIIIAVrTQ0AIAAoAgggACgCMGsgA08NAANAIAAQ+xYgACgCCCAAKAIwayADSQ0ACwsgBCADEI03IAAoAgggACgCMGtBA0siAyADckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IAJBEGogABDcOyACKAIUIQMgAigCECEEIAJBCGogACgCMBCMNyACIAQgAyACKAIIIAIoAgxBrMf+ABDXJiACKAIEIgNBA0sEQCACKAIAIAMgAWs2AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQo7AQQgBCADNgIAIAAgAUEBajYCFCACQTBqJAAPCyACQQA2AiggAkEBNgIcIAJB9Mj+ADYCGCACQgQ3AiAgAkEYakG8x/4AEO8sAAuCAwEEfyMAQTBrIgIkACAAKAIAIgBBBCAAKAI0IgMgA0EETRs2AjQgAEEwaiEEAkBBACAAKAIwIgVrQQNxIgMgACgCCCAFa00NACAAKAIIIAAoAjBrIANPDQADQCAAEPsWIAAoAgggACgCMGsgA0kNAAsLIAQgAxCNNyAAKAIIIAAoAjBrQQNLIgMgA3JFBEADQCAAEPsWIAAoAgggACgCMGtBBEkNAAsLIARBBBCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBCIDQQNLBEAgAigCACADIAFrNgAAIAAoAjAhAyAAKAIUIgEgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAUEDdGoiBEEMOwEEIAQgAzYCACAAIAFBAWo2AhQgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQF0ajIBACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQN0aikDACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALmQMCAn8CfiMAQZABayICJAAgACgCBCgCECABQQJ0ajQCACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBCAEQj+HIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALkgYCDH8CfiMAQSBrIgMkACAAKAIoIQECfwJAAkAgACkDAEIBUgRAQQAgASAAKAIcIgIgAkECdmtHDQMaIAFFBEAgAEEHOwE4IANBFGoiAUEIQYDhwwAQsTYgA0EIaiABQZDhwwAQliEgAygCDCEBIAMoAgghAiAAKAIcIgQEQCAAKAIYIARBAnRBAhD4OgsgACABNgIcIAAgAjYCGCADQRRqQQZBAEEEQTQQoBggAygCGCEBIAMoAhRBAUYNAiADKAIcIQIgAEEgaiIEEN8eIAQQ1TsgAEEANgIoIAAgAjYCJCAAIAE2AiBBAAwECyAAIAJBAXQQtgoMAwsgAbMgACgCHCIBs5VDzcxMPmBFDQEgAEIANwMAIAAgAUEBdBC2CgwCCyABIAMoAhxBoOHDABD9LwALIwBBEGsiASQAAn5B+POKASgCAEEBRgRAQYj0igEpAwAhDUGA9IoBKQMADAELIAEQ4yZB+POKAUIBNwMAQYj0igEgASkDCCINNwMAIAEpAwALIQ4gACANNwMQIAAgDjcDCCAAQgI3AwBBgPSKASAOQgF8NwMAIAFBEGokACAAKAIcIgIEQCAAKAIYIgEgAkECdGohAgNAIAFB//8DNgEAIAFBBGoiASACRw0ACwsgACILKAIoIgEEQCAAKAIkIgUgAUE0bGohDCAALwE4IQcgACgCGCEIIAAoAhwhCgNAIAUgCyAFQSBqEKEJQf//A3EiBDsBMCAJIgJBAWohCSAFQTRqIQUgBCAHcSEAQQAhBgJAAkADQCAAIQFBACEAIAEgCk8NACAIIAFBAnRqIgAvAQBB//8DRg0BIAYgASAALwECIAdxayAHcU0EQCABQQFqIQAgBkEBaiEGDAELCwNAIAEhAEEAIQEgACAKTw0AIAggAEECdGoiAS8BACIGQf//A0cEQCABIAI7AQAgAS8BAiABIAQ7AQIgAEEBaiEBIQQgBiECDAELCyABIAI7AQAMAQsgACACOwEAIAEhAAsgCCAAQQJ0aiAEOwECIAUgDEcNAAsLQQALIANBIGokAAvmBQEEfyAALQC7KkUEQCAAQQhqIgFBCyABKAIUIgJBACACQQBKGyICIAJBC04bNgIUAkAgAQJ/QQogASgCGCICQQpIDQAaIAJBGUkNAUEYIAEtAFJBAUcNABogAkEfSQ0BQR4LNgIYCyABLQBUBEAgAUEBOgBWCyAAAn8gASgCFCICQQFNBEAgASgCGAwBC0EOIAJBA0wNABoCQCABKAIcIgNFBEAgAkEISw0BQRAMAgtBGEEQIAMgA0EQTBsiAiACQRhOGwwBC0EQQRIgASgCGCICIAJBEk8bIAJBEEwbCzYCJEEAIQICQCABKAIUQQROBEACQEEBIAEoAgQgASgCAEECRiIDGyICQQNLDQBBDCABKAIIIAMbIgNB+ABLDQAgAyACdkEPcSACdCADRg0CC0EAIQILQQAhAwsgASACIAMQxBUgAEF/NgKsKkEBIQIgAEEBIAEoAhwiAyABKAIYIgEgASADSBtBAWp0IgE2AvQpIABBASAAKAIkdCIDNgL8KSAAIAFBAWs2AvgpIAAgASADajYCgCpBEiAAKAIgIgEgAUESTBsgASAAKAIcIgRBAkkbIQMCQAJAAkAgAC0AWkUEQEEAIQEgA0EQaw4CAwECCyADQQh0QYD+AHFBEXIhAUEOIQIMAgtBByECQQEhAQwBCyADQRFMBEAgA0EEdEH/AGshAUEHIQIMAQsgA0EBdEEhayEBQQQhAgsgACACOgC+KiAAIAE7AbgqIARFBEAgAEHQImpBgAFBvO7RAEGAAUHU9dEAENUsIABB0CNqQZT20QBBgAL8CgAAIABB0CVqQTlBvO/RAEE5QYT20QAQ1SwgAEGkKmpBwAM2AgALIAAtAFxBAUYEQCAAQYACaiECQQAhAQNAIAEgAmpB8P///wc2AgAgAUEEaiIBQcAARw0ACyAAQcACaiECQQAhAQNAIAEgAmpB8P///wc2AgAgAUEEaiIBQRBHDQALCyAAQQE6ALsqCwufFgISfwN+IwBB0BNrIgEkACMAQSBrIgkkACAJQRBqEP0nIAkoAhQgCSgCECEKIAlBCGogCUEfaiAGQYAgIAVBAXEbIgVBgCAgBRsQuCkgCSgCCCELIAkoAgwhDCMAQdATayIHJAAgB0HIE2pBFUGAoNAAQQwQzRogB0EgaiENIQVBACEIIwBBoBVrIgYkACAGQThqEP0nIAYoAjwhDiAGKAI4IQ8gBkHYE2oQhSAgBkHwE2oQhSAgBkGIFGoQhSAgBkEwahD/JyAGKAI0IRAgBigCMCERIAZBKGoQ/ycgBigCLCESIAYoAighEyAGQSBqEP0nIAYoAiQhFCAGKAIgIRUDQCAGQaAUaiIWIAhqIhdBADsBACAXQQJqQQA6AAAgCEEEaiIIQYABRw0ACyAGQcIRakEAOwEAIAZBuhFqQgA3AQAgBkIANwGyESAGQcABakEAQcAM/AsAIAZBGGoQ/ycgBikDGCEZIAZB0BFqQQBBgAL8CwAgBkEQahD9JyAGKQMQIRogBkEIahD9JyAGQYgOakIANwMAIAZBkA5qQgA3AwAgBkGYDmpCADcDACAGQbgOakIANwMAIAZBwA5qQQA2AgAgBkIANwOADiAGQQA6AMoRIAZCADcDsA4gBkIANwPIDiAGKQMIIRsgBkGQEGpBAEEk/AsAIAZB2A5qIAZB4BNqKQIANwMAIAZB4A5qIAZB6BNqKQIANwMAIAZB8A5qIAZB+BNqKQIANwMAIAZB+A5qIAZBgBRqKQIANwMAIAZBADsBsBEgBiAONgKcDyAGIA82ApgPIAZCi4CAgMAANwOoDiAGQpCAgIDwATcDoA4gBkHEq/sANgKoESAGQQA2ArwQIAZCADcCtBAgBiAGKQLYEzcD0A4gBiAGKQLwEzcD6A4gBkHUEGpCADcCACAGQZAPaiAGQZgUaikCADcDACAGQYgPaiAGQZAUaikCADcDACAGQQA2AsgQIAZCADcDwBAgBiAQNgLMDyAGIBI2AtQPIAYgEzYC0A8gBiARNgLIDyAGQgA3AswQIAYgBikCiBQ3A4APIAZB2A9qQQBBNfwLACAGQQA7AdATIAZBADsBxBEgBiAUNgKkDyAGIBU2AqAPIAZBATYCrBEgBkHcEGpBAEEk/AsAIAZBQGsgFkGAAfwKAAAgBkGMEWpCADcCACAGQZQRakKAgICA8B83AgAgBkIANwKEESAGQRA2AoARIAZBADoAzxEgBiAZNwOoDyAGQQA7ANMTIAYgBUEARzoA0hMgBiAFNgKcESAGIAU2ArQPIAYgCjYCsA8gBkEANgDLESAGQQA2AcYRIAZCADcDoBEgBiAbNwPADyAGIBo3A7gPIwBBIGsiBSQAIAVBFGoiCEG4CBD3GyAFQQhqIAhB1Kj7ABCWISAGIAUpAwg3AwAgBUEgaiQAIAYoAgQhBSAGKAIAIQggBigCrA8iCgRAIAYoAqgPIApBAnRBAhD4OgsgBkEBOgDQEyAGIAg2AqgPIAYgBTYCrA8gBkGwDmoiBUHAADYCCCAFQgA3AwAgDSAGQUBrQZgT/AoAACAGQaAVaiQAIAdBADYCwBMgB0IANwO4EyAHIAw2AgwgByALNgIIIAdBADoAxBMgByADNgIUIAcgAjYCECAHIAcpA8gTNwMYIAFBCGoiCiAHQQhqQcAT/AoAACAHQdATaiQAIAlBIGokAEEAIQcjAEEwayIFJABBgMAAIQgCQAJAIAQoAgAiDCAEKAIIIgJrQSBPBEAgAiEDDAELIAVBEGogCiAEEJQTAkAgBS0AEEEERgRAIAUoAhQhAwwBCyAFKQMQIhlCIIinIQMgGaciBkH/AXFBBEYNACABIAM2AgQgASAGOgAAIAFBA2ogBkEYdjoAACABIAZBCHY7AAEMAgsgAwRAIAQoAgghAwwBCyABQQQ6AAAgAUEANgIEDAELA0ACQCADIAQoAgAiBkcgBiAMR3INACAFQRBqIAogBBCUEwJAIAUtABBBBEYEQCAFKAIUIQYMAQsgBSkDECIZQiCIpyEGIBmnIgNB/wFxQQRGDQAgASAGNgIEIAEgAzoAACABQQNqIANBGHY6AAAgASADQQh2OwABDAMLIAQoAgghAyAGBEAgBCgCACEGDAELIAFBBDoAACABIAMgAms2AgQMAgsCQAJAAkACQCADIAZGBEAgBUEIaiAEIAYQtCAgBSgCCEGBgICAeEcNASAEKAIAIQYgBCgCCCEDCyAEKAIEIQkgBSAHNgIcIAVBADYCGCAFIAMgCWo2AhAgBSAIIAYgA2siAyADIAhLGyIHNgIUIAVBIGogCiAFQRBqEIQWIAUtACAiA0EERw0BDAILIAFCgcwANwIADAQLA0BBACEGAkACQAJAAkAgA0H/AXFBAWsOAwECAAYLIAUoAiQtAAhBI0cNBQwCCyAFLQAhQSNGDQEMBAsgBSgCJC0ACEEjRw0DCyAFIAUpAyA3AyggBUEoahC5LiAFQSBqIAogBUEQahCEFiAFLQAgIgNBBEcNAAsLQQEhBgsgBCAFKAIYIgkgBCgCCGoiAzYCCCAFKAIcIQsCQCAGDQAgBSkDICIZpyIGQf8BcUEERg0AIAEgBjoAACABQQdqIBlCOIg8AAAgAUEFaiAZQiiIPQAAIAEgGUIIiD4AAQwCCyAJBEAgByAJRyAHQX8gCCAYQQFqQQAgByAJSxsiGEEBShsgCCAHIAtHGyIISXJFBEBBfyAIQQF0IAhBAEgbIQgLIAsgCWshBwwBBSABQQQ6AAAgASADIAJrNgIECwsLIAVBMGokAAJAIAEtAABBBEcEQCABIAEpAwA3A8gTIAAgAUHIE2oQgSsMAQsgACABKAIENgIEIABBCDYCAAsgASgCDCIABEAgASgCCCAAQQEQ+DoLIAEtABhBBEcEQCABQRhqELkuCyMAQUBqIgAkACABQSBqIgIQyhMgAEEANgI8IABCgICAgBA3AjQgAEEoaiAAQTRqQfSo+wAQkCEgAigC3A4hAyACKALYDiEEIAIgACkDKDcD2A4gAwRAIAQgA0EBEPg6CyAAQQA2AjwgAEKAgICAIDcCNCAAQSBqIABBNGpB9Kj7ABCWISACKAKMDyEDIAIoAogPIQQgAiAAKQMgNwOIDyADBEAgBCADQQJ0QQIQ+DoLIABBADYCPCAAQoCAgIAgNwI0IABBGGogAEE0akH0qPsAEJYhIAIoApQPIQMgAigCkA8hBCACIAApAxg3A5APIAMEQCAEIANBAnRBAhD4OgsgAEEANgI8IABCgICAgCA3AjQgAEEQaiAAQTRqQfSo+wAQliEgAigC7A4hAyACKALoDiEEIAIgACkDEDcD6A4gAwRAIAQgA0ECdEECEPg6CyAAQQA2AjwgAEKAgICAEDcCNCAAQQhqIABBNGpB9Kj7ABCQISACKAL0DiEDIAIoAvAOIQQgAiAAKQMINwPwDiADBEAgBCADQQEQ+DoLIABBQGskACABKAL8DiIABEAgASgC+A4gAEEBEPg6CyABQbAOahCZKiABQcgOahCZKiABQeAOahCZKiABKAKsDyIABEAgASgCqA8gAEECdEECEPg6CyABKAK0DyIABEAgASgCsA8gAEECdEECEPg6CyABKAKEDyIABEAgASgCgA8gAEEBEPg6CyABKAKMDyIABEAgASgCiA8gAEECdEECEPg6CyABKAKUDyIABEAgASgCkA8gAEEBEPg6CyABKAKcDyIABEAgASgCmA8gAEEBEPg6CyABKAKkDyIABEAgASgCoA8gAEEBEPg6CyABQdATaiQAC+wCAQV/IwBBMGsiAiQAIAEtAAwhAyACQShqIgQgAUEIaigCADYCACACIAEpAgA3AyAgAkEgakECEOMOIAJBGGogBCgCADYCACACIAIpAyA3AxACQCADQQFHBEAgA0EBIAIoAhgbIQEMAQsgAkEANgIYIAJBEGpBBEEEEJ4kAkAgAigCGCIDRQ0AIAIoAhQiBCADQQJ0IgVqQQRrIgFFDQAgASgCAA0AIAUhASAEQQRrIQUgA0H/////A3EhBAJAA0AgAUUEQEEAIQEMAgsgBEEBayEEIAEgBWogAUEEayEBKAIARQ0ACyAEQQFqIgEgA0sNAQsgAiABNgIYIAEhAwtBASEBIAMgAigCEEECdk8NACACQQhqIAJBEGogA0EEQQQQ9BQgAigCCCIDQYGAgIB4Rg0AIAMgAigCDEHMjYgBEP0vAAsgACACKQMQNwIAIAAgAToADCAAQQhqIAJBGGooAgA2AgAgAkEwaiQAC/4DAgR/AW8jAEHwAGsiASQAIAEgADYCECABQQA2AiggAUEANgIgIAFCgICAgCA3AhQgAUEUahD2KSIAIAAoAgBBAWoiAjYCAAJAAkAgAkUNAEEEQQQQrTYiAkUEQEEEQQQQoz0ACyACIAA2AgAgAUEIaiIDQfiniAE2AgQgAyACNgIAIAEoAggiAkH4p4gBEJM1IQMgACAAKAIAQQFqIgQ2AgAgAUH4p4gBNgJEIAEgAjYCQCABIAM2AkggBEUNAEEEQQQQrTYiAkUEQEEEQQQQoz0ACyACIAA2AgAgAUHkp4gBNgIEIAEgAjYCACABKAIAIgJB5KeIARCTNSEDIAFB5KeIATYCUCABIAI2AkwgASADNgJUIAFBEGooAgAlASABQUBrKAIIJQEgAUHMAGooAgglARBSIQUQ3xIiAiAFJgEgAkGEAU8EQCACEPIfCyABQeAAaiICIAFByABqKAIANgIAIAFB7ABqIAFB1ABqKAIANgIAIAEgASkCQDcDWCABIAEpAkw3AmQgACgCCA0BIABBfzYCCCAAQRxqEKkrIABBLGogAUHoAGopAwA3AgAgAEEkaiACKQMANwIAIAAgASkDWDcCHCAAIAAoAghBAWo2AgggASgCECICQYQBTwRAIAIQ8h8LIAFB8ABqJAAgAA8LAAtB/KiIARCbPgAL/QIBBH8jAEEwayIDJAAgAEEEIAAoAjQiBCAEQQRNGzYCNCAAQTBqIQUCQEEAIAAoAjAiBmtBA3EiBCAAKAIIIAZrTQ0AIAAoAgggACgCMGsgBE8NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBSAEEI03IAAoAgggACgCMGtBA0siBCAEckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBUEEEI03IANBEGogABDcOyADKAIUIQQgAygCECEFIANBCGogACgCMBCMNyADIAUgBCADKAIIIAMoAgxBsLf+ABDXJiADKAIEIgRBA0sEQCADKAIAIAQgAms2AAAgACgCMCEEIAAoAhQiAiAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECACQQN0aiIFIAE7AQQgBSAENgIAIAAgAkEBajYCFCADQTBqJAAPCyADQQA2AiggA0EBNgIcIANB7Lf+ADYCGCADQgQ3AiAgA0EYakHAt/4AEO8sAAv9AgEEfyMAQTBrIgMkACAAQQQgACgCNCIEIARBBE0bNgI0IABBMGohBQJAQQAgACgCMCIGa0EDcSIEIAAoAgggBmtNDQAgACgCCCAAKAIwayAETw0AA0AgABD7FiAAKAIIIAAoAjBrIARJDQALCyAFIAQQjTcgACgCCCAAKAIwa0EDSyIEIARyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAFQQQQjTcgA0EQaiAAENw7IAMoAhQhBCADKAIQIQUgA0EIaiAAKAIwEIw3IAMgBSAEIAMoAgggAygCDEGEgf8AENcmIAMoAgQiBEEDSwRAIAMoAgAgBCACazYAACAAKAIwIQQgACgCFCICIAAoAgxGBEAgAEEMakGcgP8AEJsoCyAAKAIQIAJBA3RqIgUgATsBBCAFIAQ2AgAgACACQQFqNgIUIANBMGokAA8LIANBADYCKCADQQE2AhwgA0Gwgf8ANgIYIANCBDcCICADQRhqQZSB/wAQ7ywAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAUECdGo1AgAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIARCACAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAUEBdGozAQAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIARCACAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC5YDAgJ/An4jAEGQAWsiAiQAIAAoAgQoAhAgAWowAAAhBCACIAAoAgAiAygCACkDACIFNwNIIAIgBDcDQCACQRBqIAQgBEI/hyAFIAVCP4cQqB4CQAJAAkAgAikDGCACKQMQIgRCP4dSBEAgAkECNgJsIAJBrJD/ADYCaCACQgI3AnQgAkGGDDYCjAEgAkGGDDYChAEgAiACQYABajYCcCACIAJByABqNgKIASACIAJBQGs2AoABIAJB2ABqIAJB6ABqEJkOIAJBNGogAkHcAGopAgA3AgAgAkE8aiACQeQAaigCADYCACACQYiAgIB4NgJUIAIgAikCVDcCLCACQQE2AiggAkEoakEEchCIEQwBCyAEIAMoAgQtAAAQxSlFDQAgACgCCCABQQN0aiAENwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQZABaiQADwsgACADQYiL/wAQwyEAC7sDAQJ/IwBBEGsiAyQAAkACQAJAAkACQAJAAkACQCABLQAAQQFrDgYBAgMEBQYACyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIADAYLIAMgAUEEahDMIiAAIAMpAwA3AgQgAEEBOgAADAULIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAMBAsgA0EIaiABQQRqEMwiIAAgAykDCDcCBCAAQQM6AAAMAwsgAEEEOgAAIAAgAS8AATsAAQwCC0EEIQICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRMgAS0AASIBQQRrIAFBA00bQf8BcUEBaw4TAAECAwQFBgcICQoLDA0ODxAREhMLQQUhAgwSC0EGIQIMEQtBByECDBALQQghAgwPC0EJIQIMDgtBCiECDA0LQQshAgwMC0EMIQIMCwtBDSECDAoLQQ4hAgwJC0EPIQIMCAtBECECDAcLQREhAgwGC0ESIQIMBQtBEyECDAQLQRQhAgwDC0EVIQIMAgtBFiECDAELIAEhAgsgAEEFOgAAIAAgAjoAAQwBCyAAQQY6AAALIANBEGokAAuPBgEPfyMAQTBrIgQkACAEQQg6AAsgBCACNgIQIAQgATYCDCAEQQQ2AhQgBCAEQQtqNgIYIARBJGohCyMAQSBrIgMkAAJAAkACQCADQRRqIARBDGoiASgCBCICBH8gASgCCCIFRQ0BIAIgBW4iBiACIAUgBmxHagVBAAtBAEEEQQQQoBggAygCGCECIAMoAhRBAUYNASADQRBqIgxBADYCACADIAMoAhw2AgwgAyACNgIIIANBCGohAiMAQRBrIgkkAAJAAkACQCABKAIEIgZFBEAgAkEIaiEFDAELIAEoAggiB0UNASACQQhqIQUgBiAHbiIIIAYgByAIbEdqIgYgAigCACACKAIIIgdrTQ0AIAIgByAGEN8oCyAJIAIpAgRCIIk3AgggCSAFNgIEIAlBBGoiAigCBCEFIAIoAgAgASgCBCIGBEAgAigCCCEOIAEoAgwhDyABKAIIIQggASgCACEKA0AgBiAIIAYgBiAISxsiAmshBgJAIAhFBEBBACEHDAELIApBAWshECAPLQAAQR9xIRFBACEHIAIhAQNAIAEgEGotAAAgByARdHIhByABQQFrIgENAAsLIAIgCmohCiAOIAVBAnRqIAc2AgAgBUEBaiEFIAYNAAsLIAU2AgAgCUEQaiQADAELQcCiiAEQ4isACyALQQhqIAwoAgA2AgAgCyADKQIINwIAIANBIGokAAwCC0HAoogBEOIrAAsgAiADKAIcQdyNiAEQ/S8ACwJAIAQoAiwiAUUNACAEKAIoIgIgAUECdCIDakEEayIFRQ0AIAUoAgANACACQQRrIQUgAUH/////A3EhAgJAA0AgA0UEQEEAIQMMAgsgAkEBayECIAMgBWogA0EEayEDKAIARQ0ACyACQQFqIgMgAUsNAQsgBCADNgIsIAMhAQsCQCABIAQoAiRBAnZPDQAgBCAEQSRqIAFBBEEEEPQUIAQoAgAiAUGBgICAeEYNACABIAQoAgRBgKKIARD9LwALIAAgBCkCJDcCACAAQQhqIARBLGooAgA2AgAgBEEwaiQAC6ADAQJ/IwBBIGsiByQAAkAgACgCACIIIAEgAiAAKAIEKAIMIgERBgAEQEEBIQIMAQsCQCAALQAKQYABcUUEQEEBIQIgCEHZ8YkBQQEgAREGAA0CIAMgACAEKAIMEQIARQ0BDAILIAhB2vGJAUECIAERBgAEQEEBIQIMAgtBASECIAdBAToADyAHQbDxiQE2AhQgByAAKQIANwIAIAcgACkCCDcCGCAHIAdBD2o2AgggByAHNgIQIAMgB0EQaiAEKAIMEQIADQEgBygCEEHU8YkBQQIgBygCFCgCDBEGAA0BCwJAIAAtAApBgAFxRQRAIAAoAgBBz/GJAUECIAAoAgQoAgwRBgAEQAwDCyAFIAAgBigCDBECAEUNAQwCCyAHQQE6AA8gB0Gw8YkBNgIUIAcgACkCADcCACAHIAApAgg3AhggByAHQQ9qNgIIIAcgBzYCECAFIAdBEGogBigCDBECAA0BIAcoAhBB1PGJAUECIAcoAhQoAgwRBgANAQsgACgCAEGT7YkBQQEgACgCBCgCDBEGACECCyAHQSBqJAAgAguJAwEFfyMAQRBrIgUkACAFQQhqIAAgAUEJahC4KSAFKAIMIQQgBSgCCCEGAkACQAJAAkACQCACKAIEIgdFBEAgAiAENgIEIAIgBjYCAAwBCyACKAIYQQlqIgMgBEsNASADIAdLDQIgBiADIAIoAgAgA0Gsu9AAENUsIAUQ/ScgBSgCBCEDIAUoAgAgACACKAIAIAIoAgQQ4DUgAiAENgIEIAIgBjYCACADRQ0AIANBARD4OgsgAkECNgIgIAIgATYCGCAERQ0CIAZBADoAACACKAIgIgRBAWsiASACKAIEIgBPDQMgAigCACIDIAFqQQA6AAAgACACKAIYIARqIgFrIgJBACAAIAJPGyEEIAEgA2ohA0EAIQICQANAIAIgBEYNASACIANqQQA6AAAgAkEBaiICQQdHDQALIAVBEGokAA8LIAEgAmogAEHcu9AAEMMhAAsgAyAEQYy70AAQsDsACyADIAdBnLvQABCwOwALQQBBAEG8u9AAEMMhAAsgASAAQcy70AAQwyEAC4IDAQR/IAAoAgwhAgJAAkACQCABQYACTwRAIAAoAhghAwJAAkAgACACRgRAIABBFEEQIAAoAhQiAhtqKAIAIgENAUEAIQIMAgsgACgCCCIBIAI2AgwgAiABNgIIDAELIABBFGogAEEQaiACGyEEA0AgBCEFIAEiAkEUaiACQRBqIAIoAhQiARshBCACQRRBECABG2ooAgAiAQ0ACyAFQQA2AgALIANFDQICQCAAKAIcQQJ0QajwigFqIgEoAgAgAEcEQCADKAIQIABGDQEgAyACNgIUIAINAwwECyABIAI2AgAgAkUNBAwCCyADIAI2AhAgAg0BDAILIAAoAggiACACRwRAIAAgAjYCDCACIAA2AggPC0HA84oBQcDzigEoAgBBfiABQQN2d3E2AgAPCyACIAM2AhggACgCECIBBEAgAiABNgIQIAEgAjYCGAsgACgCFCIARQ0AIAIgADYCFCAAIAI2AhgPCw8LQcTzigFBxPOKASgCAEF+IAAoAhx3cTYCAAuxCAMFfwJ9BH4jAEEgayIJJAACQAJAAn8CQAJAIAEgB0kEQCAGIAFBFGxqIggoAgBFBEAgCCoCBCENC0EAIAFFDQMaIAgoAhAhCiAIKAIIQf///w9xIQsgAiAIKAIMIgxJDQIgCyAMaiAAIAFqTQ0BDAILIAEgB0GUstAAEMMhAAsgASAMQQ9qIApBG3ZBAWsgCkGAgIDAAEkbDQEaCyABIAsgCkH///8/cWprIgAgB08NAUEAIAYgAEEUbGoiACgCAEECRw0AGiAAKAIECyEAIAggADYCBCAIQQI2AgAgASAEKAIMIgBPDQEgBCgCCCIAIAFBAnRqKgIAIAAqAgCTIg4gDWAEQCAJQQhqQgA3AwAgCUIANwMAIAkgATYCECAJIA04AhggCSANIA6TOAIUQQAhAEEAIQJBECEKIwBBIGsiCCQAAkACQAJAAkACQAJAIAEgB0kEQCAGIAFBFGxqIgEoAgBBAkcNAiABKAIEIgRFDQIgCSEBA0AgAiEAAkACQAJAIAQgB0kEQCAAQQRGDQEgASAGIARBFGxqIgIoAgw2AgAgBCACKAIIQf///w9xIAIoAhBB////P3FqayICIAdPDQIgBiACQRRsaiIEKAIAQQJGDQMMBgsgBCAHQYCg1gAQwyEAC0EEQQRBkKDWABDDIQALIAIgB0GgoNYAEMMhAAsgAEECSw0CIABBAWohAiABQQRqIQEgBCgCBCIEDQALDAELIAEgB0HQn9YAEMMhAAsgAEECSw0BIABBAWohAAtBBCAAIABBBE0bIQEgCSAAQQJ0aiEEA0AgCkUNAyAAIAFGDQIgBCADKAIANgIAIARBBGohBCADQQRqIQMgCkEBayEKIABBAWoiAEEERw0ACwsgCEEgaiQADAILIAFBBEHwn9YAEMMhAAsgCEEANgIYIAhBATYCDCAIQfie1gA2AgggCEIENwIQIAhBCGpB4J/WABDvLAALIAUgBSgC4AEiAUEBaiIANgLgASAFIAFBf3NBB3EiAkEcbGoiASAJKQIANwIAIAFBCGogCUEIaikCADcCACABQRBqIAlBEGopAgA3AgAgAUEYaiAJQRhqKAIANgIAIABBAk8EQEEIIAAgAEEITxtBAWshAwNAIAUgAkEHcUEcbGoiACoCFCAFIAJBAWoiAkEHcUEcbGoiASoCFF4EQCAAKQIAIRAgAUEIaiIEKQIAIREgAUEQaiIGKQIAIQ8gAUEYaiIHKAIAIQggACABKQIANwIAIABBGGoiCigCACELIAogCDYCACAAQRBqIggpAgAhEiAIIA83AgAgAEEIaiIAKQIAIQ8gACARNwIAIAcgCzYCACAGIBI3AgAgBCAPNwIAIAEgEDcCAAsgA0EBayIDDQALCwsgCUEgaiQADwsgACAHQdy00AAQwyEACyABIABBzLXQABDDIQALkwMCAn8CfiMAQZABayICJAAgACgCBCgCECABajEAACEEIAIgACgCACIDKAIAKQMAIgU3A0ggAiAENwNAIAJBEGogBEIAIAUgBUI/hxCoHgJAAkACQCACKQMYIAIpAxAiBEI/h1IEQCACQQI2AmwgAkGskP8ANgJoIAJCAjcCdCACQYYMNgKMASACQYYMNgKEASACIAJBgAFqNgJwIAIgAkHIAGo2AogBIAIgAkFAazYCgAEgAkHYAGogAkHoAGoQmQ4gAkE0aiACQdwAaikCADcCACACQTxqIAJB5ABqKAIANgIAIAJBiICAgHg2AlQgAiACKQJUNwIsIAJBATYCKCACQShqQQRyEIgRDAELIAQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBkAFqJAAPCyAAIANBiIv/ABDDIQALuQMBCH8jAEEQayIFJAAgAiABayIDQQAgAiADTxshAwJAAkACQCAAKAIMBEAgAEEMaiEGIAAoAhwiB0EHcSIIRQ0CIAVBCGogBhCGPSAFKAIMIgRFDQEgBSgCCCAEakEBayIERQ0BIAQgBC0AAEF/IAh0cjoAAAwCCyAAIAAoAiAgA2o2AiAMAgtBjPWBARCyOwALAkAgAyAHaiIHQQN2IAdBB3EiCEEAR2oiAyAAKAIYIgRNDQAgAyAEayEJIAAoAhAgA0kEQCADENIqIQQgBiAAKAIQQQF0IgogBCAEIApJGxDoGSAAKAIYIQQLIAlFDQAgACgCFCAEakH/ASAJ/AsACyAAIAM2AhggCARAIAUgBhCGPQJAIAUoAgQiAwRAIAUoAgAgA2pBAWsiAw0BC0Gc9YEBELI7AAsgAyADLQAAQX8gCHRBf3NxOgAACyAAIAc2AhwLIAAgAiABayIDQQAgAiADTxsQhS4gACgCCCEDIAAgASACSQR/IAIgA2ogAWsgACgCBCADQQJ0aiEAA0AgACABNgIAIABBBGohACACIAFBAWoiAUcNAAsFIAMLNgIIIAVBEGokAAvRAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QYi2gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACADQQBIIAIgA01yDwtBAAvTAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QbC4gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACACIANNIANB//8BS3IPC0EAC9ICAQp/AkACQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBxLmDAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB08NAQsgACABQQJ0aiEIIAYgBSgCJBEEACEDQQEhAUEBIQQDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIANqIQNBASEJIARBAXFBACEBQQAhBEUNASAGIAUgCyAKIAcRCgAhBAwBCwsgBEEBcQ0AIAIgA00gA0H/AEtyDwtBAAvTAgEKfwJAAkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0QYC9gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdPDQELIAAgAUECdGohCCAGIAUoAiQRBAAhA0EBIQFBASEEA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACADaiEDQQEhCSAEQQFxQQAhAUEAIQRFDQEgBiAFIAsgCiAHEQoAIQQMAQsLIARBAXENACACIANNIANB//8DS3IPC0EAC9ICAQp/AkACQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBlL6DAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB08NAQsgACABQQJ0aiEIIAYgBSgCJBEEACEDQQEhAUEBIQQDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIANqIQNBASEJIARBAXFBACEBQQAhBEUNASAGIAUgCyAKIAcRCgAhBAwBCwsgBEEBcQ0AIAIgA00gA0H/AUtyDwtBAAuFGAIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDgAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8CQAJAIAkQ9C1BgIACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDOJyAKIA82AhQgCiAINgIQIApCAjcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEIUtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAXRqIA0gCWsQvAsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQmgsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABCZFSADQTBqIBMgAygCJCADKAIoELwLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ8w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahCdPAwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJoLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEJ08CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQhS0gBiADIAcgAiAEIAUQ/AkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALwRACGH8DfiMAQSBrIggkAAJAAkACQAJAAkAgASkDAEIFUgRAIAhBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQsjAEEwayIDJAACQAJAAkAgAiIMRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ3wIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgDCAPayEGIAEpAwBCBFINASACIAYgAiAGSRsiCiECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQogAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCAKNgIEIAQgBzYCAAwGCyAFIApyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiAKTQ0CIAEtAEwgAUEAOgBMIApqIQoLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgBzYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIRBBACEJIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACINQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIA1qKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAJQQhqIglqIBdxIQcMAAsACyAGQQdqEIUpAAsgCyALKAIIIgcgBWoQhi0gCygCCCIJIAdJDQEgBkEIaiANIBpBDGxqIg1BCGsoAgAgCygCBCAHQQJ0aiAJIAdrIA1BBGsoAgAoAhARBQAgBigCDCEJAkAgBigCCCINQQhHBEAgECAGKQMQNwMIIBBBEGogBkEYaikDADcDAAwBCyALIAcgCWoQ9DQLIBAgDTYCACAQIAk2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAJQaSuzgAQrzsACyADKAIcIQYgAygCGCIHQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAHNgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBFqIREgAiASaiESIAogD2oiDyAMSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCARNgIIIAQgDzYCBCAEQQg2AgALIANBMGokAAwACyAIKAIQIQUgCCgCFCECIAgoAgwhDCAIKAIIIgNBCEcEQCAAIAgpAxg3AxAgACACNgIMIAAgBTYCCCAAIAw2AgQgACADNgIADAULIAIgBU0NAyATKAIAIgNBgYCAgHhHDQIgCEEIakE9QQBBAUEBEKAYIAgoAgwhASAIKAIIQQFGDQEgCCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAgoAhBB1P3MABD9LwALIAEoAqQCIQQgCCATQQRBDCADQYCAgIB4RhtqEIY9IAsgBCAFIAIgCCgCACAIKAIEEP0JCyAAIAw2AgQgAEEINgIAIAEgASgCqAIgDGo2AqgCIAEgASgCpAIgAmo2AqQCCyAIQSBqJAAPCyACIAMoAiBB9I7PABD9LwALqzUCI38IfiMAQSBrIhokAAJAAkACQAJAAkAgASkDAEIFUgRAIBpBCGohDSABQcACaiIiQQAgASgCwAJBgYCAgHhHGyEjIAFB6AJqQQAgASgC6AJBgICAgHhHGyEkIAFBqAJqIREjAEEwayIIJAACQAJAIAIiHkUNACABQaABaiELIAFB0ABqISUgASgCoAIhBAJAAkADQAJAAkACQCABKAKcAiICQQAgAiAERxtFBEAgCEEYaiABENACIAgtABwhBSAIKAIYIgJBCEcNASAFQQFxRQ0HIAEoApwCIgJFDQcgASgCoAIhBAsgAiAEayECIB4gIWshCiABKQMAQgRSDQEgAiAKIAIgCkkbIhghAgwCCyANIAgpAB03AAUgDUEUaiAIQSxqKAAANgAAIA1BDWogCEElaikAADcAACANIAU6AAQgDSACNgIADAYLICRFBEAgCEEYakEeQQBBAUEBEKAYIAgoAhwhAiAIKAIYQQFGDQwgCCgCICIFQRZqQeiSzwApAAA3AAAgBUEQakHiks8AKQAANwAAIAVBCGpB2pLPACkAADcAACAFQdKSzwApAAA3AAAgDUEeNgIMIA0gBTYCCCANIAI2AgQgDUEANgIADAYLIAhBGGogASAkIAogAhCMECAIKAIgIQUgCCgCHCEYIAgoAhgiBEEIRwRAIA0gCCkCJDcCDCANQRRqIAhBLGooAgA2AgAgDSAFNgIIIA0gGDYCBCANIAQ2AgAMBgsgBSAYckUEQCAIQRhqQS9BAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNDCAIKAIgIgVBuJDPAEEv/AoAACANQS82AgwgDSAFNgIIIA0gAjYCBCANQQA2AgAMBgsgAiAFRwRAIAUhAgwBCyABLQCkAkEBRw0AIAogGE0NAiABLQBMIAFBADoATCAYaiEYCyACIQUCQCAlKQMAQgVRDQAgI0UEQCAIQRhqQR5BAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNBCAIKAIgIgVBFmpBhpPPACkAADcAACAFQRBqQYCTzwApAAA3AAAgBUEIakH4ks8AKQAANwAAIAVB8JLPACkAADcAACANQR42AgwgDSAFNgIIIA0gAjYCBCANQQA2AgAMBgsgCEEYaiAlICMgAhDFAyAIKAIgIQogCCgCHCEFIAgoAhgiBEEIRwRAIA0gCCkCJDcCDCANQRRqIAhBLGooAgA2AgAgDSAKNgIIIA0gBTYCBCANIAQ2AgAMBgsgAiAKRg0AIAhBGGpB3gBBAEEBQQEQoBggCCgCHCECIAgoAhhBAUYNCyAIKAIgIgVB9JHPAEHeAPwKAAAgDUHeADYCDCANIAU2AgggDSACNgIEIA1BADYCAAwFCyAIIAU2AgAjAEHwAGsiAyQAAkACQAJAIAhBGGoiCgJ/IAspAwAiJkIGUQRAIANB2ABqQQ5BAEEBQQEQoBggAygCXCEbIAMoAlhBAUYNAyADKAJgIgRBBmpBrozNACkAADcAACAEQaiMzQApAAA3AAAgCkEONgIMIAogBDYCCCAKIBs2AgQgCkEANgIADAILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEBICanQQJrICZCAVgbQQFrDgMAAQIFCyALKAJQIg5BgICAgHhHDQMgA0HYAGpBK0EAQQFBARCgGCADKAJcIRsgAygCWEEBRw0CDBILIBEgCygCECIGIAsoAiQiCWsiBCAFIAQgBUkbIg8Q6y0gCSAPaiIEIA9JDQQgBCAGSw0FIAsoAgwhBiADQdgAaiIEIAtBIGogCygCGCALKAIcIAsoAhQoAgARBQAgA0EoaiAEEPwbIBEoAhQiByARKAIMRgRAIBFBDGpBjITNABCQKAsgESgCECAHQQxsaiIEIAMpAig3AgAgBEEIaiADQTBqKAIANgIAIBEgB0EBajYCFCALKAIoIg4hGSAPBEAgBiAJQQJ0aiEXIA9BAnQhFANAIBEgByAZIBcoAgAQjRogFygCACAZaiEZIBdBBGohFyAUQQRrIhQNAAsLIAstACxFDQ4gDiAZSw0GIBkgCygCHCIESw0HIANByABqIAsoAhggDmogGSAOaxCdCSADKAJIQQFHDQ4gAyADKQJMNwNAIANBATYCXCADQfCIzQA2AlggA0IBNwJkIANBsAM2AhggAyADQRRqNgJgIAMgA0FAazYCFCAKQQRqIANB2ABqEJkOQQAMDwsgESALKAIQIAsoAjxrIgQgBSAEIAVJGxDrLSADQdgAaiIdQYAgQQBBAUEBEKAYIAMoAlwhBCADKAJYQQFGDQcgC0EIaiESIANBADYCHCADIAMoAmA2AhggAyAENgIUIAMgESgCFDYCICALLQBERQRAIAMgETYCUCADIANBIGo2AkwgAyADQRRqNgJIIANByABqIQkjAEEwayIWJAACQAJAAkACQAJAAkAgEigCCCIGIBIoAjQiB2siBCAFIAQgBUkbIhUgB2oiDCAVTwRAIAYgDEkNASAMIBIoAhQiBEsNAiAWQQhqIAdBAnQiByASKAIEaiIEIAQgFUECdCIGaiASKAIQIAdqIgQgBCAGahCLKAJAIBYoAhwiBCAWKAIYIgZLBEAgEigCLCEMIBIoAighByAEIAZrIRwgEkEYaiEPIAZBAnQiBCAWKAIQaiEXIBYoAgggBGohFCASKAI4IRsgCSgCCCETIAkoAgQhBiAJKAIAIQ4DQCASKAIsIBsgFygCACIQakkNAiAPIBQoAgAQ9DQgEigCOCIJIBBqIgQgCUkNBiAEIAxLDQcgDyAHIAlqIBAQoTYgFkEgaiASKAIcIgQgEigCICIJIAYoAgAgDigCCBDwCiAJQQ1PBEAgDiAEIAkQoTYLIBYpAyghJyAWKQMgISYgEygCCCIJIBMoAgBGBEAgE0GshM0AELEoCyATKAIEIAlBBHRqIgQgJzcDCCAEICY3AwAgEyAJQQFqNgIIIBIgEigCOCAQaiIbNgI4IBdBBGohFyAUQQRqIRQgHEEBayIcDQALIBIoAjQgFWohDAsgHSAVNgIEIBIgDDYCNCAdQQg2AgAMBwsgFkEgakEXQQBBAUEBEKAYIBYoAiQhBCAWKAIgQQFGDQUgFigCKCIGQQ9qQduGzQApAAA3AAAgBkEIakHUhs0AKQAANwAAIAZBzIbNACkAADcAACAdQRc2AgwgHSAGNgIIIB0gBDYCBCAdQQI2AgAMBgsgByAMQYyGzQAQsTsACyAMIAZBjIbNABCwOwALIAwgBEGchs0AELA7AAsgCSAEQayGzQAQsTsACyAEIAxBrIbNABCwOwALIAQgFigCKEHU/cwAEP0vAAsgFkEwaiQAIAMoAlwhGSADKAJYIgRBCEYNDCAKIAMpA2A3AwggCkEQaiADQegAaikDADcDACAKIBk2AgQgCiAENgIADA0LIANB2ABqIhtBgCBBAEEBQQEQoBggAygCXCEEIAMoAlhBAUYNCCADQQA2AjAgAyADKAJgNgIsIAMgBDYCKCADIBE2AlQgAyADQShqNgJQIAMgA0EgajYCTCADIANBFGo2AkggA0HIAGohDiMAQTBrIhQkAAJAAkACQAJAAkACQAJAAkAgEigCCCIGIBIoAjQiB2siBCAFIAQgBUkbIh0gB2oiDCAdTwRAIAYgDEkNASAMIBIoAhQiBEsNAiAUQQhqIAdBAnQiByASKAIEaiIEIAQgHUECdCIGaiASKAIQIAdqIgQgBCAGahCLKCAUKAIcIgQgFCgCGCIGTQ0HIBIoAiwhECASKAIoIQkgBCAGayEWIBJBGGohDCAGQQJ0IgQgFCgCEGohEyAUKAIIIARqIRcgEigCOCEZIA4oAgwhHCAOKAIIIQcgDigCBCEGIA4oAgAhDwNAIBIoAiwgGSATKAIAIhVqTwRAIAwgFygCABD0NCASKAI4Ig4gFWoiBCAOSQ0FIAQgEEsNBiAMIAkgDmogFRChNiAUQSBqIBIoAhwiBCASKAIgIg4gBigCACAPKAIIEPAKAkAgDkEMTQRAIAcgBCAOEKE2DAELIA8gBCAOEKE2CyAUKQMoIScgFCkDICEmIBwoAggiDiAcKAIARgRAIBxBrITNABCxKAsgHCgCBCAOQQR0aiIEICc3AwggBCAmNwMAIBwgDkEBajYCCCASIBIoAjggFWoiGTYCOCATQQRqIRMgF0EEaiEXIBZBAWsiFg0BDAgLCyAUQSBqQRdBAEEBQQEQoBggFCgCJCEEIBQoAiBBAUYNBSAUKAIoIgZBD2pB24bNACkAADcAACAGQQhqQdSGzQApAAA3AAAgBkHMhs0AKQAANwAAIBtBFzYCDCAbIAY2AgggGyAENgIEIBtBAjYCAAwICyAHIAxBjIbNABCxOwALIAwgBkGMhs0AELA7AAsgDCAEQZyGzQAQsDsACyAOIARBrIbNABCxOwALIAQgEEGshs0AELA7AAsgBCAUKAIoQdT9zAAQ/S8ACyASKAI0IB1qIQwLIBsgHTYCBCASIAw2AjQgG0EINgIACyAUQTBqJAAgAygCXCEZAkAgAygCWCIEQQhHBEAgCiADKQNgNwMIIApBEGogA0HoAGopAwA3AwAgCiAZNgIEIAogBDYCAAwBCyADQcgAaiADKAIYIAMoAhwQnQkgAygCSEEBRgRAIAMgAykCTDcDOCADQQE2AlwgA0HwiM0ANgJYIANCATcCZCADQbADNgJEIAMgA0FAazYCYCADIANBOGo2AkAgCkEEaiADQdgAahCZDiAKQQA2AgAMAQsgA0HIAGogAygCLCADKAIwEJ0JIAMoAkhBAUcNCyADIAMpAkw3AzggA0EBNgJcIANB8IjNADYCWCADQgE3AmQgA0GwAzYCRCADIANBQGs2AmAgAyADQThqNgJAIApBBGogA0HYAGoQmQ4gCkEANgIACyADQShqEN47DAwLIAMoAmAiBEGokM0AQSv8CgAAIApBKzYCDCAKIAQ2AgggCiAbNgIEIApBADYCAAwOCwJAIAUEQCALKAJYDQELIApCCDcDAAwOCwJAAkAgESgCFCIJIAsoAmQiFUkEQCALKAJgIRcMAQsgESgCECIEIAkgFWtBDGxqIQcgCygCYCEXIANB2ABqIg9BADYCECAPIBcgFUEMbGoiBjYCDCAPIBc2AgggDyAEIAlBDGxqIgQ2AgQgDyAHNgIAIA8gBiAXa0EMbiIGIAQgB2tBDG4iBCAEIAZLGzYCFCADKAJoIhYgAygCbCIPTw0BIBYgDyAPIBZJGyEHIAMoAmAhFCADKAJYIQwgFkEMbCEJA0ACQCAJIAxqIgZBBGooAgAgCSAUaiIEQQRqKAIARw0AIAZBCGooAgAgBEEIaigCAEcNACAMQQxqIQwgFEEMaiEUIBZBAWoiFiAHRw0BDAMLCyAVRSAPIBZNcg0BCyARQQxqIQkgFyAVQQxsaiEHA0AgFygCACIQIBAoAgAiBEEBajYCACAEQQBIDQkgF0EIaigCACEGIBdBBGooAgAhBCARKAIUIgwgESgCDEYEQCAJQfSQzQAQkCgLIBEoAhAgDEEMbGoiDyAGNgIIIA8gBDYCBCAPIBA2AgAgESAMQQFqNgIUIBdBDGoiFyAHRw0ACwsgAyARKAIUIBVrNgJIIAMgETYCXCADIAtB0ABqQQAgDkGAgICAeEcbNgJYIAMgA0HIAGo2AmAgA0HYAGohB0EAIRwjAEFAaiITJAACQAJAAkACQAJAIAVFDQAgCygCTCIGRQ0AIAsoAkghBCAHKAIEIRUgBygCCCEOIAcoAgAhDANAIAsoAkQiByAERgRAIBNBIGogCyALKAJAQYAIENwKIBMoAiQhByATKAIgIgRBCEcEQCAKIBMpAyg3AwggCkEQaiATQTBqKQMANwMAIAogBzYCBCAKIAQ2AgAMBwsgB0UNAiALQQA2AkggCyAHNgJEIAsoAkwhBkEAIQQLIAYgByAEayIJIAUgHGsiByAHIAlLGyIHIAYgB0kbIhAgBGoiByAQSQ0DIAdBgAhLDQQgEARAIAsoAkAiCSAEQQJ0IgRqIQYgEEECdCEHIAQgCWohBANAIAYoAgAiCSAMKAIITw0EAkAgDCgCBCAJQQR0aiIJKQMAIienQQ1PBEAgDigCACAJKQMIIianaq0gJkKAgICAcIOEISYgFSgCCCIPIBUoAgBGBEAgFUGshM0AELEoCyAVKAIEIA9BBHRqIgkgJjcDCCAJICc3AwAMAQsgCSkDCCEnIAkpAwAhJiAVKAIIIg8gFSgCAEYEQCAVQayEzQAQsSgLIBUoAgQgD0EEdGoiCSAnNwMIIAkgJjcDAAsgFSAPQQFqNgIIIAZBBGohBiAEQQRqIQQgB0EEayIHDQALIAsoAkggEGohByALKAJMIQYLIAsgBzYCSCALIAYgEGsiBDYCTCAQIBxqIhwgBUYNASAGIBBGIAQhBiAHIQRFDQALCyAKQQg2AgAgCiAcNgIEDAMLIBNBAjYCJCATQdSPzgA2AiAgE0IBNwIsIBNBnAM2AjwgEyAENgI4IBMgE0E4ajYCKCATQQhqQQRyIBNBIGoQmQ4gCiATKQMQNwMIIApBEGogE0EYaikDADcDACAKIBMoAgw2AgQgCkEANgIADAILIAQgB0HMiM4AELE7AAsgB0GACEHMiM4AELA7AAsgE0FAayQADA0LIAogC0EIaiARIAUQ5gcMDAsgCSAEQaSRzQAQsTsACyAEIAZBpJHNABCwOwALIA4gGUG0kc0AELE7AAsgGSAEQbSRzQAQsDsACyAEIAMoAmBB5JHNABD9LwALIAQgAygCYEH0kc0AEP0vAAsACyADQShqEN47CyADQTBqIANBHGooAgA2AgAgAyADKQIUNwMoIANByABqIANBKGoQ8i8gAyADKQJINwJkIANBADYCYCADIAMoAlQiBjYCXCADIAMoAlA2AlggA0EIaiADQdgAahDXOyADKAIIIQQCQEEcQQQQrTYiDgRAIA5CgYCAgBA3AgAgDiADKQJYNwIIIA5BEGogA0HgAGopAgA3AgAgDkEYaiADQegAaigCADYCACARKAIUIgkgESgCDEYEQCARQQxqQYyEzQAQkCgLIBEoAhAgCUEMbGoiByAGNgIIIAcgBDYCBCAHIA42AgAgESAJQQFqNgIUIAMgCTYCJCAJIAMoAiBGDQEgA0EANgJYIANBJGogA0EgaiADQdgAakGEks0AEKgrAAtBBEEcEKM9AAsgCkEINgIAIAogGTYCBAwDCyADQRRqEN47DAILIAsgGTYCKCAKIA82AgQgCyALKAIkIA9qNgIkQQgLNgIACyADQfAAaiQADAELIBsgAygCYEHU/cwAEP0vAAsgCCgCHCEKIAgoAhgiBEEIRwRAIA0gCCkDIDcDCCANQRBqIAhBKGopAwA3AwAgDSAKNgIEIA0gBDYCAAwFCyAIIAo2AgQgBSAKRgRAIAEgASgCoAIgAmoiBDYCoAIgBSAfaiEfIAIgIGohICAYICFqIiEgHkkNAQwECwsgCEECNgIcIAhB5JHPADYCGCAIQgI3AiQgCEE7NgIUIAhBOzYCDCAIIAhBCGo2AiAgCCAIQQRqNgIQIAggCDYCCCANQQRqIAhBGGoQmQ4gDUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMBwsgDSAgNgIMIA0gHzYCCCANICE2AgQgDUEINgIACyAIQTBqJAAgGigCECEeIBooAhQhDiAaKAIMIQkgGigCCCICQQhHBEAgACAaKQMYNwMQIAAgDjYCDCAAIB42AgggACAJNgIEIAAgAjYCAAwFCyAOIB5NDQMgIigCACICQYGAgIB4Rw0CIBpBCGpBPUEAQQFBARCgGCAaKAIMIQIgGigCCEEBRg0BIBooAhAiAUHEh80AQT38CgAAIABBPTYCDCAAIAE2AgggACACNgIEIABBADYCAAwEC0G0h80AELI7AAsgAiAaKAIQQdT9zAAQ/S8ACyABKAL4AiEPIBogIkEEQQwgAkGAgICAeEYbahCGPSAaKAIAIQsgGigCBCEEIwBB8ABrIhAkAAJAIA4gD2oiBSARKAIIIgJNBEAgESAFNgIIDAELIBEgBSACayICEOstIBEoAgQgESgCCCIYQQR0aiEFAkACQCACQQJPBEAgAkEBayEgA0AgBUIANwMAIAVCADcDCCAFQRBqIQUgIEEBayIgDQALIAIgGGpBAWshGAwBCyACRQ0BCyAFQgA3AwAgBUIANwMIIBhBAWohGAsgESAYNgIICyAQIAsgBBDgHCAQQgA3A2ggECAPNgJgIBAgDyAeaiICIgU2AmQCQAJAAkACQCAFIA9NDQAgAkEEdEEQayEHIBAoAlghCiAQKQMgISogECgCVCEYIBAoAlAhBiAQKQNAISggECkDMCErIBAoAhAhHyAQKQMIISkgECgCKCEeIBAoAhghCyAQKQNIIS0gECkDOCEnIBApAwAhLANAICynQQFxRSEMAkADQAJAAkACQCAMRQRAIClQRQ0BQgAhKUIAISxBASEMDAQLAn4CQCArQgJ9IiZCAVgEQCAmp0EBaw0BDAULICunICtQrUIBhiErQQFxRQ0AICcMAQsgKEIDUQRAQgMhKAwECyAGRSAGIBhGckUEQCAYQQhrIhgpAwAMAQtBACEGIChCAlEEQEICISgMBAsgKKdCACEoQQFxRQ0DIC0LISlCASEsIApBQGoiCiEfDAELIB8gKXmnQT9zIgJqIQxCASACrYYgKYUhKQwDC0EAIQwMAQsLIAsgKkIAUnFFDQIgHiAqeadBP3MiAmohDEIBIAKthiAqhSEqCyAMIAVBAWsiAk0NASACIBEoAggiBE8NAiAEIAxNDQMgESgCBCIFIAxBBHRqIgQgBSAHaiIFKQMANwMAIAQgBSkDCDcDCCAHQRBrIQcgAiIFIA9LDQALCyAQQfAAaiQADAILIAVBAWsgBEGwms8AEMMhAAsgDCAEQcCazwAQwyEACwsgACAJNgIEIABBCDYCACABIAEoAvwCIAlqNgL8AiABIAEoAvgCIA5qNgL4AgsgGkEgaiQADwsgAiAIKAIgQfSOzwAQ/S8AC6MOARN/IwBBIGsiByQAAkACQAJAAkACQCABKQMAQgVSBEAgB0EIaiEEIAFBwAJqIg9BACABKALAAkGBgICAeEcbIRAgAUHoAmpBACABKALoAkGAgICAeEcbIREgAUGoAmohEiMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDCABQdAAaiETIAEoAqACIQYCQAJAA0ACQAJAAkAgASgCnAIiAkEAIAIgBkcbRQRAIANBGGogARDZAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKAKcAiICRQ0HIAEoAqACIQYLIAIgBmshAiAKIAtrIQYgASkDAEIEUg0BIAIgBiACIAZJGyIJIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyARRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgESAGIAIQjBAgAygCICEFIAMoAhwhCSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAk2AgQgBCAINgIADAYLIAUgCXJFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0ApAJBAUcNACAGIAlNDQIgAS0ATCABQQA6AEwgCWohCQsgAiEFAkAgEykDAEIFUQ0AIBBFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogEyAQIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohCCMAQRBrIgYkAAJAAkACQCAMKQMAQgZRBEAgBkEEakEOQQBBAUEBEKAYIAYoAgghFCAGKAIEQQFGDQIgBigCDCIVQQZqQa6MzQApAAA3AAAgFUGojM0AKQAANwAAIAhBDjYCDCAIIBU2AgggCCAUNgIEIAhBADYCAAwBCyAIIAwgEiAFIAxB0ABqQQAgDCgCUEGAgICAeEcbEMEUCyAGQRBqJAAMAQsgFCAGKAIMQdT9zAAQ/S8ACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKAKgAiACaiIGNgKgAiAFIA1qIQ0gAiAOaiEOIAkgC2oiCyAKSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIA42AgwgBCANNgIIIAQgCzYCBCAEQQg2AgALIANBMGokAAwACyAHKAIQIQUgBygCFCECIAcoAgwhCiAHKAIIIgNBCEcEQCAAIAcpAxg3AxAgACACNgIMIAAgBTYCCCAAIAo2AgQgACADNgIADAULIAIgBU0NAyAPKAIAIgNBgYCAgHhHDQIgB0EIakE9QQBBAUEBEKAYIAcoAgwhASAHKAIIQQFGDQEgBygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAcoAhBB1P3MABD9LwALIAEoAvgCIQQgByAPQQRBDCADQYCAgIB4RhtqEIY9IBIgBCAFIAIgBygCACAHKAIEEMwHCyAAIAo2AgQgAEEINgIAIAEgASgC/AIgCmo2AvwCIAEgASgC+AIgAmo2AvgCCyAHQSBqJAAPCyACIAMoAiBB9I7PABD9LwALjScCIH8IfiMAQSBrIhEkAAJAAkACQAJAAkAgASkDAEIFUgRAIBFBCGohByABQaACaiIbQQAgASgCoAJBgYCAgHhHGyEdIAFB3AJqQQAgASgC3AJBgICAgHhHGyEfIAFByAJqIQwjAEEwayIGJAACQAJAAkAgAiITRQ0AIAFBoAFqIQkgAUHQAGohICABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAGQRhqIAEQ1QIgBi0AHCECIAYoAhgiA0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgEyAVayEKIAEpAwBCBFINASACIAogAiAKSRsiEiECDAILIAcgBikAHTcABSAHQRRqIAZBLGooAAA2AAAgB0ENaiAGQSVqKQAANwAAIAcgAjoABCAHIAM2AgAMBgsgH0UEQCAGQRhqQR5BAEEBQQEQoBggBigCHCECIAYoAhhBAUYNDSAGKAIgIgNBFmpB6JLPACkAADcAACADQRBqQeKSzwApAAA3AAAgA0EIakHaks8AKQAANwAAIANB0pLPACkAADcAACAHQR42AgwgByADNgIIIAcgAjYCBCAHQQA2AgAMBgsgBkEYaiABIB8gCiACEIwQIAYoAiAhAyAGKAIcIRIgBigCGCIEQQhHBEAgByAGKQIkNwIMIAdBFGogBkEsaigCADYCACAHIAM2AgggByASNgIEIAcgBDYCAAwGCyADIBJyRQRAIAZBGGpBL0EAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0NIAYoAiAiA0G4kM8AQS/8CgAAIAdBLzYCDCAHIAM2AgggByACNgIEIAdBADYCAAwGCyACIANHBEAgAyECDAELIAEtAJwCQQFHDQAgCiASTQ0CIAEtAEwgAUEAOgBMIBJqIRILIAIhCgJAICApAwBCBVENACAdRQRAIAZBGGpBHkEAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0EIAYoAiAiA0EWakGGk88AKQAANwAAIANBEGpBgJPPACkAADcAACADQQhqQfiSzwApAAA3AAAgA0Hwks8AKQAANwAAIAdBHjYCDCAHIAM2AgggByACNgIEIAdBADYCAAwGCyAGQRhqICAgHSACEMUDIAYoAiAhAyAGKAIcIQogBigCGCIEQQhHBEAgByAGKQIkNwIMIAdBFGogBkEsaigCADYCACAHIAM2AgggByAKNgIEIAcgBDYCAAwGCyACIANGDQAgBkEYakHeAEEAQQFBARCgGCAGKAIcIQIgBigCGEEBRg0MIAYoAiAiA0H0kc8AQd4A/AoAACAHQd4ANgIMIAcgAzYCCCAHIAI2AgQgB0EANgIADAULIAYgCjYCACAGQRhqIQ4jAEEgayIQJAACQCAMKAIAQQFGBEAgECAMKAIEIgg2AgQgCCAJKAJgRg0BIBBBADYCCEEAIBBBBGogCUHgAGogEEEIakGQnc0AEK8rAAsgDEEBNgIAIAwgCSgCYCIINgIECwJAAkAgCSkDACIjQgZSBEACQAJAAkACQAJAAkACQAJAQQEgI6dBAmsgI0IBWBtBAWsOAwACBAELIAkoAlBFDQYgCSgCWEUNAiAQIAlB0ABqNgIQIBAgCUHgAGo2AgwgECAMQQhqNgIIIBBBCGohBEEAIQMjAEEgayILJAACQAJAAkACQAJAAkAgCkUNACAJKAJMIghFDQAgCSgCSCEFIAQoAgghDyAEKAIEIRQgBCgCACEYA0AgCSgCRCIEIAVGBEAgC0EIaiAJIAkoAkBBgAgQ3AogCygCDCEEIAsoAggiBUEIRwRAIA4gCykDEDcDCCAOQRBqIAtBGGopAwA3AwAgDiAENgIEIA4gBTYCAAwICyAERQ0CIAlBADYCSCAJIAQ2AkQgCSgCTCEIQQAhBQsgCCAEIAVrIgQgCiADayINIAQgDUkbIgQgBCAISxsiBCAFaiIIIARJDQIgCEGACEsNAyAJKAJAIQggGCAUKAIAIARsEOUtIAQEQCAIIAVBAnRqIQUgBEECdCEZA0AgFCgCACIaIAUoAgBsIgggGmoiDSAISQ0GIA0gDygCCCIcSw0HIAVBBGohBSAYIA8oAgQgCGogGhChNiAZQQRrIhkNAAsLIAkgCSgCSCAEaiIFNgJIIAkgCSgCTCINIARrIgg2AkwgAyAEaiIDIApGDQEgBCANRw0ACwsgDkEINgIAIA4gAzYCBAwECyAFIAhBzIjOABCxOwALIAhBgAhBzIjOABCwOwALIAggDUH0j84AELE7AAsgDSAcQfSPzgAQsDsACyALQSBqJAAMCQsgCARAIAggCSgCECIFIAkoAhgiBGsiAyAIIApsIgsgAyALSRsgCG4iDWwiCyAEaiIDIAtJDQUgAyAFSw0EIAxBCGogCSgCDCAEaiALEKE2IA4gDTYCBCAJIAM2AhggDkEINgIADAkLQbCdzQAQ4isACyAMQQhqIiEgCSgCECAJKAI8ayIDIAogAyAKSRsiAyAIbBDlLSAJQeAAaiEYIwBB4ABrIgQkAAJAAkACQAJAAkACQCAJQQhqIgUoAggiDSAFKAI0IghrIgsgAyADIAtLGyILIAhqIgMgC08EQCADIA1LDQEgAyAFKAIUIg1LDQIgBCAIQQJ0IgggBSgCBGoiDSANIAtBAnQiD2ogBSgCECAIaiIIIAggD2oQiygCQAJAIAQoAhQiDSAEKAIQIghLBEAgBSgCLCEZIAUoAighIiANIAhrIRogBUEYaiEcIAhBAnQiCCAEKAIIaiEDIAQoAgAgCGohDSAFKAI4IQ8gGCgCACEeA0AgBSgCLCAPIAMoAgAiCGpJDQMgHCANKAIAEPQ0IAUoAjgiDyAIaiIUIA9JDQcgFCAZSw0IIBwgDyAiaiAIEKE2IAUoAiAiDyAeRw0CICEgBSgCHCAeEKE2IAUgBSgCOCAIaiIPNgI4IANBBGohAyANQQRqIQ0gGkEBayIaDQALIAUoAjQgC2ohAwsgDiALNgIEIAUgAzYCNCAOQQg2AgAMCAsgBCAPNgJMIARBAjYCOCAEQdiezQA2AjQgBEICNwJAIARBOzYCXCAEIBg2AlggBEE7NgJUIAQgBEHQAGo2AjwgBCAEQcwAajYCUCAEQRhqQQRyIARBNGoQmQ4gDkEUaiAEQSxqKAIANgIAIA5BDGogBEEkaikCADcCACAOIAQpAhw3AgQgDkEANgIADAcLIARBNGpBF0EAQQFBARCgGCAEKAI4IQUgBCgCNEEBRg0FIAQoAjwiA0EPakHbhs0AKQAANwAAIANBCGpB1IbNACkAADcAACADQcyGzQApAAA3AAAgDkEXNgIMIA4gAzYCCCAOIAU2AgQgDkECNgIADAYLIAggA0GMhs0AELE7AAsgAyANQYyGzQAQsDsACyADIA1BnIbNABCwOwALIA8gFEGshs0AELE7AAsgFCAZQayGzQAQsDsACyAFIAQoAjxB1P3MABD9LwALIARB4ABqJAAMBwsgDkIINwMADAYLIAhFDQQgDEEIaiAMKAIQIgQgCSgCECIPIAhuIhggCSgCGCIZayIDIAogAyAKSRsiBSAIbCIUaiIDEI4tIAMgBE8EQCAMKAIQIgsgA08EQCAMKAIMIARqIRogCSgCDCEcQQAhCwNAAkACQCALIBhsIBlqIgMgBWoiBCADTwRAIAQgD0sNASAFRQ0CIAMgHGohHkEAIQ0gCyEEIAUhAwNAIAQgFEkEQCAEIBpqIA0gHmotAAA6AAAgBCAIaiEEIA1BAWohDSADQQFrIgMNAQwECwsgBCAUQcifzQAQwyEACyADIARBuJ/NABCxOwALIAQgD0G4n80AELA7AAsgC0EBaiILIAhHDQALIA4gBTYCBCAOQQg2AgAgCSAJKAIYIAVqNgIYDAcLIAMgC0Gon80AELA7AAsgBCADQaifzQAQsTsACyADIAVBwJ3NABCwOwALIAQgA0HAnc0AELE7AAtB4J3NABCyOwALQaCdzQAQsjsAC0GAns0AEOIrAAsgEEEgaiQAIAYoAhwhAyAGKAIYIgRBCEcEQCAHIAYpAyA3AwggB0EQaiAGQShqKQMANwMAIAcgAzYCBCAHIAQ2AgAMBQsgBiADNgIEIAMgCkYEQCABIAEoApgCIAJqIgM2ApgCIAogFmohFiACIBdqIRcgEiAVaiIVIBNJDQEMBAsLIAZBAjYCHCAGQeSRzwA2AhggBkICNwIkIAZBOzYCFCAGQTs2AgwgBiAGQQhqNgIgIAYgBkEEajYCECAGIAY2AgggB0EEaiAGQRhqEJkOIAdBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAcgFzYCDCAHIBY2AgggByAVNgIEIAdBCDYCAAsgBkEwaiQADAALIBEoAhAhAyARKAIUIQ4gESgCDCEIIBEoAggiAkEIRwRAIAAgESkDGDcDECAAIA42AgwgACADNgIIIAAgCDYCBCAAIAI2AgAMBQsgAyAOTw0DIBsoAgAiAkGBgICAeEcNAiARQQhqQT1BAEEBQQEQoBggESgCDCEBIBEoAghBAUYNASARKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgESgCEEHU/cwAEP0vAAsgASgC7AIhCyARIBtBBEEMIAJBgICAgHhGG2oQhj0gESgCACEFIBEoAgQhEyMAQZABayICJAAgAiAMKAIQIgY2AgAgAiAMKAIEQQAgDCgCABsiCiADIAtqIgRsIhA2AgQCQAJAAkACQAJAAkACQCAGIBBGBEAgDEEIaiAKIAsgDmpsEI4tIApBBEsNASACQQhqIAUgExDgHCACQgA3A3AgAiALNgJoIAIgBDYCbCAEIAtNDQIgDCgCECEHQQAgCmshFSAMKAIMIhYgCiAEQQFrbCITaiEMQQAgE2shECACKAJgIQkgAikDKCElIAIoAlwhEiACKAJYIQYgAikDSCEjIAIpAzghJiACKAIYIQ0gAikDECEkIAIoAjAhFyACKAIgIQ8gAikDUCEoIAIpA0AhKSACKQMIIScCQANAICenQQFxRSEDAkADQAJAAkACQCADRQRAICRQRQ0BQgAhJEIAISdBASEDDAQLAn4CQCAmQgJ9IipCAVgEQCAqp0EBaw0BDAULICanICZQrUIBhiEmQQFxRQ0AICkMAQsgI0IDUQRAQgMhIwwECyAGRSAGIBJGckUEQCASQQhrIhIpAwAMAQtBACEGICNCAlEEQEICISMMBAsgI6dCACEjQQFxRQ0DICgLISRCASEnIAlBQGoiCSENDAELIA0gJHmnQT9zIgNqIQVCASADrYYgJIUhJAwDC0EAIQMMAQsLIA8gJUIAUnFFDQUgFyAleadBP3MiA2ohBUIBIAOthiAlhSElCyAFIARBAWsiBE0NBAJAIAoEQCAHIBNrIgNBACADIAdNGyEUQQAhAyAHIAUgCmwiBWsiG0EAIAcgG08bIRsgBSAWaiEdA0AgAyAURg0CIAMgG0YNBCADIB1qIAMgDGotAAA6AAAgA0EBaiIDIApHDQALCyAMIBVqIQwgCiAQaiEQIBMgCmshEyAEIAtLDQEMBQsLIAMgEGsgB0H0m80AEMMhAAsgAyAFaiAHQYSczQAQwyEACyACQQA2AghBACACIAJBBGogAkEIakGkm80AEK8rAAsgAkEIaiAFIBMQ4BwgAkIANwNwIAIgCzYCaCACIAQ2AmwgBCALTQ0AIAwoAhAhEiAMKAIMIg0gCiADIAtqIhVBAWtsIhZqIRdBACEDIAIoAmAhCSACKQMoISUgAigCXCEGIAIoAlghByACKQNIISMgAikDOCEmIAIoAhghEyACKQMQISQgAigCMCEPIAIoAiAhFCACKQNQISggAikDQCEpIAIpAwghJwNAICenQQFxRSEFAkADQAJAAkACQCAFRQRAICRQRQ0BQgAhJEIAISdBASEFDAQLAn4CQCAmQgJ9IipCAVgEQCAqp0EBaw0BDAULICanICZQrUIBhiEmQQFxRQ0AICkMAQsgI0IDUQRAQgMhIwwECyAHRSAGIAdGckUEQCAGQQhrIgYpAwAMAQtBACEHICNCAlEEQEICISMMBAsgI6dCACEjQQFxRQ0DICgLISRCASEnIAlBQGoiCSETDAELIBMgJHmnQT9zIgxqIQVCASAMrYYgJIUhJAwDC0EAIQUMAQsLIBQgJUIAUnFFDQIgDyAleadBP3MiDGohBUIBIAythiAlhSElCyAFIARBAWsiBE0NASASIAUgCmwiBUkNAiAKIBIgBWsiDEsNAyADIBBqIgwgAyAWakkNBCAFIAxJDQUgCgRAIAUgDWogAyAXaiAK/AoAAAsgAyAKayEDIAQgC0sNAAsLIAJBkAFqJAAMBAsgAkEANgKIASACQQE2AnwgAkHM/cwANgJ4IAJCBDcCgAEgAkH4AGpBxJvNABDvLAALIAogDEHUm80AELA7AAsgCiAVQQFrbCADaiAMQeSbzQAQsTsACyAMIAVB5JvNABCwOwALCyAAIAg2AgQgAEEINgIAIAEgASgC8AIgCGo2AvACIAEgASgC7AIgDmo2AuwCCyARQSBqJAAPCyACIAYoAiBB9I7PABD9LwAL8BUCF38BfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBSABQbgCaiIVQQAgASgCuAJBgYCAgHhHGyEWIAFB4AJqQQAgASgC4AJBgICAgHhHGyEXIAFBoAJqIQ8jAEEwayIEJAACQAJAAkAgAiIQRQ0AIAFBoAFqIQ0gAUHQAGohGCABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ0gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgECARayEDIAEpAwBCBFINASACIAMgAiADSRsiDiECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgF0UEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBcgAyACEIwQIAQoAiAhByAEKAIcIQ4gBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAONgIEIAUgBjYCAAwGCyAHIA5yRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAOTQ0CIAEtAEwgAUEAOgBMIA5qIQ4LIAIhBwJAIBgpAwBCBVENACAWRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBggFiACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDSkDAEIGfSIaQgFYBEAgGqdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA0oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA0oAkghCCADIA1B0ABqIgkQ8y0iCzYCICADIA1B2ABqIgw2AnggCyAMELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshCyANQQhqIRICQCAPIAkQ1BMiCARAIAggCCgCCCIJIAtqEIctIAgoAggiDCAJSQ0GIANBMGogEiAIKAIEIAlBA3RqIAwgCWsQ2wogAygCNCEMIAMoAjAiC0EIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAMNgIEIAYgCzYCAAwMCyADQTBqIA8QkwsgAygCNCEZIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAZNgIEIAYgCDYCAAwMCyADQSBqIAtBgNXNABC2FSADQTBqIBIgAygCJCADKAIoENsKIAMoAjQhCAJAIAMoAjAiC0EIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCzYCAAwBCyADIAkQ8y0iCzYCLCADIAw2AnggCyAMELgIRQ0HIANBMGoiDCAJEMMtIANBGGogDBDcOyADKAIcIglFDQggA0EQaiADKAIYIgsQxxsgCUEBRg0KIAMoAhQhCSADKAIQIRIgA0EIaiALQQxqENw7IAggAygCKCILSw0JIANB+ABqIBkgAygCJCAIIBIgCSADKAIIIAMoAgwQ8A8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDBDvJgsgA0EgahDjPAwLCyAIIAkgDGoQ9DQgBiAMNgIEIAZBCDYCACANIA0oAkggDGs2AkgMCgsgA0EwaiAPEJMLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMIUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDEHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAtBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAooAhAhByAKKAIUIQIgCigCDCEQIAooAggiA0EIRwRAIAAgCikDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgC8AIhAyAKIBVBBEEMIARBgICAgHhGG2oQhj0gCigCACEEIAooAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzQcMAQsgD0EEaiIGIAIgA2oQhy0gBiADIAcgAiAEIAUQ/gkLCyAAIBA2AgQgAEEINgIAIAEgASgC9AIgEGo2AvQCIAEgASgC8AIgAmo2AvACCyAKQSBqJAAPCyACIAQoAiBB9I7PABD9LwAL7xcCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3AIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/IAkQ9C0aAkACQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAMLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0DIAggCCgCACIWQQFqNgIAIBZBAEgNAiAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMAwsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQAgCSgCBCEPIAoQ0CcgCiAPNgIUIAogCDYCECAKQgQ3AgggCkKAgICACDcCACAKQQRqDAILAAtBAAsiCARAIAggCCgCCCIJIAxqEJUtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAnRqIA0gCWsQuwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQkQsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABC/FSADQTBqIBMgAygCJCADKAIoELsLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ7w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDpOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJELIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEOk7CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQlS0gBiADIAcgAiAEIAUQ/wkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALyhgCGX8BfiMAQSBrIgwkAAJAAkACQAJAAkAgASkDAEIFUgRAIAxBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ1wIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA4oAkghCSADIA5B0ABqIggQ8y0iDTYCICADIA5B2ABqIgs2AnggDSALELgIRQ0CIAgQ9S0NAyAJIAcgByAJSxshDSAOQQhqIRMCQAJ/AkACQCAIEPQtQYCABEkEQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCCgCACIJIAgoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAkgCSgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAk2AhALIApBBGoMBAsgCCgCACIJIAkoAgAiD0EBajYCACAPQQBIDQEgCCgCBCEPIAoQzScgCiAPNgIUIAogCTYCECAKQgI3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIgkEQAJAIAkoAggiCCANaiILIAhNBEAgCSALNgIIDAELIAkgDRDMGiAJKAIIIQsLIAggC0sNBiADQTBqIBMgCSgCBCAIQQF0aiALIAhrELwLIAMoAjQhCyADKAIwIg1BCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCzYCBCAGIA02AgAMDAsgA0EwaiAKEJkLIAMoAjQhDyADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAk2AgAMDAsgA0EgaiANQYDVzQAQmRUgA0EwaiATIAMoAiQgAygCKBC8CyADKAI0IQkCQCADKAIwIg1BCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIA02AgAMAQsgAyAIEPMtIg02AiwgAyALNgJ4IA0gCxC4CEUNByADQTBqIgsgCBDDLSADQRhqIAsQ3DsgAygCHCIIRQ0IIANBEGogAygCGCINEMcbIAhBAUYNCiADKAIUIQggAygCECETIANBCGogDUEMahDcOyAJIAMoAigiDUsNCSADQfgAaiAPIAMoAiQgCSATIAggAygCCCADKAIMELcQIAMoAngiCEEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAINgIAIAsQ7yYLIANBIGoQnTwMCwsgCCALaiIIIAkoAghNBEAgCSAINgIICyAGIAs2AgQgBkEINgIAIA4gDigCSCALazYCSAwKCyADQTBqIAoQmQsgAygCNCEIIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCTYCAAwKCyAGIA4gCCAHQQAQwhQMCQsgCCADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCCALQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAkgDUHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAk2AgQgBkEINgIAIA4gDigCSCAJazYCSCADQTBqEO8mIANBIGoQnTwLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgDCgCECEHIAwoAhQhAiAMKAIMIREgDCgCCCIDQQhHBEAgACAMKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAxBCGpBPUEAQQFBARCgGCAMKAIMIQEgDCgCCEEBRg0BIAwoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASAMKAIQQdT9zAAQ/S8ACyABKALwAiEDIAwgGEEEQQwgBEGAgICAeEYbahCGPSAMKAIAIQQgDCgCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIQYCQCACIANqIg4gCigCDCIITQRAIAogDjYCDAwBCyAGIA4gCGsQzBoLIAYgAyAHIAIgBCAFEMkJCwsgACARNgIEIABBCDYCACABIAEoAvQCIBFqNgL0AiABIAEoAvACIAJqNgLwAgsgDEEgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC58VAhh/CH4jAEEgayIKJAACQAJAAkACQAJAIAEpAwBCBVIEQCAKQQhqIQQgAUHgAWoiE0EAIAEoAuABQYGAgIB4RxshFCABQZQCakEAIAEoApQCQYCAgIB4RxshFSABQYgCaiEMIwBBMGsiAyQAAkACQAJAIAIiCUUNACABQaABaiENIAFB0ABqIRYgASgC2AEhBgJAAkADQAJAAkACQCABKALUASICQQAgAiAGRxtFBEAgA0EYaiABENoCIAMtABwhAiADKAIYIgVBCEcNASACQQFxRQ0HIAEoAtQBIgJFDQcgASgC2AEhBgsgAiAGayECIAkgDmshBiABKQMAQgRSDQEgAiAGIAIgBkkbIgshAgwCCyAEIAMpAB03AAUgBEEUaiADQSxqKAAANgAAIARBDWogA0ElaikAADcAACAEIAI6AAQgBCAFNgIADAYLIBVFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQRZqQeiSzwApAAA3AAAgBUEQakHiks8AKQAANwAAIAVBCGpB2pLPACkAADcAACAFQdKSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogASAVIAYgAhCMECADKAIgIQUgAygCHCELIAMoAhgiB0EIRwRAIAQgAykCJDcCDCAEQRRqIANBLGooAgA2AgAgBCAFNgIIIAQgCzYCBCAEIAc2AgAMBgsgBSALckUEQCADQRhqQS9BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBuJDPAEEv/AoAACAEQS82AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgAiAFRwRAIAUhAgwBCyABLQDcAUEBRw0AIAYgC00NAiABLQBMIAFBADoATCALaiELCyACIQUCQCAWKQMAQgVRDQAgFEUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNBCADKAIgIgVBFmpBhpPPACkAADcAACAFQRBqQYCTzwApAAA3AAAgBUEIakH4ks8AKQAANwAAIAVB8JLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiAWIBQgAhDFAyADKAIgIQYgAygCHCEFIAMoAhgiB0EIRwRAIAQgAykCJDcCDCAEQRRqIANBLGooAgA2AgAgBCAGNgIIIAQgBTYCBCAEIAc2AgAMBgsgAiAGRg0AIANBGGpB3gBBAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDCADKAIgIgVB9JHPAEHeAPwKAAAgBEHeADYCDCAEIAU2AgggBCACNgIEIARBADYCAAwFCyADIAU2AgAgA0EYaiEPQQAhByMAQSBrIgYkAAJAAkAgDS0AJCIIQQlHBEAgBiAIOgAHAkACQCANKAIMRQ0AIA1BEGogBkEHahDsDCEbIA0oAgAiEUEMayEYIA0oAgQiFyAbp3EhCCAbQhmIQv8Ag0KBgoSIkKDAgAF+IR0gBi0AByEZA0AgCCARaikAACIcIB2FIhtCf4UgG0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIbUEUEQANAIBkgGEEAIBt6p0EDdiAIaiAXcWsiGkEMbGotAABGDQQgG0IBfSAbgyIbUEUNAAsLIBwgHEIBhoNCgIGChIiQoMCAf4NQRQ0BIAggB0EIaiIHaiAXcSEIDAALAAsgBkEHahCFKQALAkAgDCgCCCIIIAVqIgcgCE0EQCAMIAc2AggMAQsgDCAFEIMfIAwoAgghBwsgByAISQ0BIAZBCGogESAaQQxsaiIRQQhrKAIAIAwoAgQgCEEDdGogByAIayARQQRrKAIAKAIQEQUAIAYoAgwhBwJAIAYoAggiEUEIRwRAIA8gBikDEDcDCCAPQRBqIAZBGGopAwA3AwAMAQsgByAIaiIIIAwoAghLDQAgDCAINgIICyAPIBE2AgAgDyAHNgIEIAZBIGokAAwCC0Hkrc4AQR5BhK7OABDLJAALIAggB0Gkrs4AEK87AAsgAygCHCEGIAMoAhgiB0EIRwRAIAQgAykDIDcDCCAEQRBqIANBKGopAwA3AwAgBCAGNgIEIAQgBzYCAAwFCyADIAY2AgQgBSAGRgRAIAEgASgC2AEgAmoiBjYC2AEgBSAQaiEQIAIgEmohEiALIA5qIg4gCUkNAQwECwsgA0ECNgIcIANB5JHPADYCGCADQgI3AiQgA0E7NgIUIANBOzYCDCADIANBCGo2AiAgAyADQQRqNgIQIAMgAzYCCCAEQQRqIANBGGoQmQ4gBEEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBCASNgIMIAQgEDYCCCAEIA42AgQgBEEINgIACyADQTBqJAAMAAsgCigCECEFIAooAhQhBiAKKAIMIQcgCigCCCICQQhHBEAgACAKKQMYNwMQIAAgBjYCDCAAIAU2AgggACAHNgIEIAAgAjYCAAwFCyAFIAZPDQMgEygCACIJQYGAgIB4Rw0CIApBCGpBPUEAQQFBARCgGCAKKAIMIQEgCigCCEEBRg0BIAooAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASAKKAIQQdT9zAAQ/S8ACyABKAKkAiECIAogE0EEQQwgCUGAgICAeEYbahCGPSAKKAIAIQQgCigCBCELIwBB8ABrIgMkAAJAIAIgBmoiCSAMKAIIIghNBEAgDCAJNgIIDAELIAwgCSAIaxCDHwsgAyAEIAsQ4BwgA0IANwNoIAMgAjYCYCADIAIgBWoiBTYCZAJAAkACQAJAIAIgBU8NACAFQQN0QQhrIQsgAygCWCEPIAMpAyAhHSADKAJUIQggAygCUCENIAMpA0AhGyADKQMwIR4gAygCECEQIAMpAwghHCADKAIoIRIgAygCGCETIAMpA0ghICADKQM4ISEgAykDACEfA0AgH6dBAXFFIQQCQANAAkACQAJAIARFBEAgHFBFDQFCACEcQgAhH0EBIQQMBAsCfgJAIB5CAn0iIkIBWARAICKnQQFrDQEMBQsgHqcgHlCtQgGGIR5BAXFFDQAgIQwBCyAbQgNRBEBCAyEbDAQLIA1FIAggDUZyRQRAIAhBCGsiCCkDAAwBC0EAIQ0gG0ICUQRAQgIhGwwECyAbp0IAIRtBAXFFDQMgIAshHEIBIR8gD0FAaiIPIRAMAQsgECAceadBP3MiCWohBEIBIAmthiAchSEcDAMLQQAhBAwBCwsgEyAdQgBScUUNAiASIB15p0E/cyIJaiEEQgEgCa2GIB2FIR0LIAQgBUEBayIJTQ0BIAkgDCgCCCIOTw0CIAQgDk8NAyAMKAIEIgUgBEEDdGogBSALaisDADkDACALQQhrIQsgCSIFIAJLDQALCyADQfAAaiQADAILIAVBAWsgDkGwms8AEMMhAAsgBCAOQcCazwAQwyEACwsgACAHNgIEIABBCDYCACABIAEoAqgCIAdqNgKoAiABIAEoAqQCIAZqNgKkAgsgCkEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC6MOARN/IwBBIGsiByQAAkACQAJAAkACQCABKQMAQgVSBEAgB0EIaiEEIAFBwAJqIg9BACABKALAAkGBgICAeEcbIRAgAUHoAmpBACABKALoAkGAgICAeEcbIREgAUGoAmohEiMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDCABQdAAaiETIAEoAqACIQYCQAJAA0ACQAJAAkAgASgCnAIiAkEAIAIgBkcbRQRAIANBGGogARDTAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKAKcAiICRQ0HIAEoAqACIQYLIAIgBmshAiAKIAtrIQYgASkDAEIEUg0BIAIgBiACIAZJGyIJIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyARRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgESAGIAIQjBAgAygCICEFIAMoAhwhCSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAk2AgQgBCAINgIADAYLIAUgCXJFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0ApAJBAUcNACAGIAlNDQIgAS0ATCABQQA6AEwgCWohCQsgAiEFAkAgEykDAEIFUQ0AIBBFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogEyAQIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIghBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohCCMAQRBrIgYkAAJAAkACQCAMKQMAQgZRBEAgBkEEakEOQQBBAUEBEKAYIAYoAgghFCAGKAIEQQFGDQIgBigCDCIVQQZqQa6MzQApAAA3AAAgFUGojM0AKQAANwAAIAhBDjYCDCAIIBU2AgggCCAUNgIEIAhBADYCAAwBCyAIIAwgEiAFIAxB0ABqQQAgDCgCUEGAgICAeEcbEMIUCyAGQRBqJAAMAQsgFCAGKAIMQdT9zAAQ/S8ACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKAKgAiACaiIGNgKgAiAFIA1qIQ0gAiAOaiEOIAkgC2oiCyAKSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIA42AgwgBCANNgIIIAQgCzYCBCAEQQg2AgALIANBMGokAAwACyAHKAIQIQUgBygCFCECIAcoAgwhCiAHKAIIIgNBCEcEQCAAIAcpAxg3AxAgACACNgIMIAAgBTYCCCAAIAo2AgQgACADNgIADAULIAIgBU0NAyAPKAIAIgNBgYCAgHhHDQIgB0EIakE9QQBBAUEBEKAYIAcoAgwhASAHKAIIQQFGDQEgBygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAcoAhBB1P3MABD9LwALIAEoAvgCIQQgByAPQQRBDCADQYCAgIB4RhtqEIY9IBIgBCAFIAIgBygCACAHKAIEEM0HCyAAIAo2AgQgAEEINgIAIAEgASgC/AIgCmo2AvwCIAEgASgC+AIgAmo2AvgCCyAHQSBqJAAPCyACIAMoAiBB9I7PABD9LwALxhgCGX8BfiMAQSBrIgwkAAJAAkACQAJAAkAgASkDAEIFUgRAIAxBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ1gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA4oAkghCSADIA5B0ABqIggQ8y0iDTYCICADIA5B2ABqIgs2AnggDSALELgIRQ0CIAgQ9S0NAyAJIAcgByAJSxshDSAOQQhqIRMCQAJ/AkACQCAIEPQtQYABSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAIKAIAIgkgCCgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCSAJKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCTYCEAsgCkEEagwECyAIKAIAIgkgCSgCACIPQQFqNgIAIA9BAEgNASAIKAIEIQ8gChDMJyAKIA82AhQgCiAJNgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCQRAAkAgCSgCCCIIIA1qIgsgCE0EQCAJIAs2AggMAQsgCSANEMggIAkoAgghCwsgCCALSw0GIANBMGogEyAJKAIEIAhqIAsgCGsQqAsgAygCNCELIAMoAjAiDUEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiALNgIEIAYgDTYCAAwMCyADQTBqIAoQlwsgAygCNCEPIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCTYCAAwMCyADQSBqIA1BgNXNABDOGCADQTBqIBMgAygCJCADKAIoEKgLIAMoAjQhCQJAIAMoAjAiDUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgDTYCAAwBCyADIAgQ8y0iDTYCLCADIAs2AnggDSALELgIRQ0HIANBMGoiCyAIEMMtIANBGGogCxDcOyADKAIcIghFDQggA0EQaiADKAIYIg0QxRsgCEEBRg0KIAMoAhQhCCADKAIQIRMgA0EIaiANQQxqENw7IAkgAygCKCINSw0JIANB+ABqIA8gAygCJCAJIBMgCCADKAIIIAMoAgwQkhAgAygCeCIIQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAg2AgAgCxDvJgsgA0EgahDeOwwLCyAIIAtqIgggCSgCCE0EQCAJIAg2AggLIAYgCzYCBCAGQQg2AgAgDiAOKAJIIAtrNgJIDAoLIANBMGogChCXCyADKAI0IQggAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAJNgIADAoLIAYgDiAIIAdBABDBFAwJCyAIIAMoAjhB/LvNABD9LwALIANBADYCMCADQSBqIANB+ABqIANBMGpB8NTNABCjKwALIAZCCDcDAAwGCyAIIAtB4NXNABCvOwALIANBADYCMCADQSxqIANB+ABqIANBMGpBkNXNABCjKwALQQBBAEGg1c0AEMMhAAsgCSANQcDVzQAQsDsAC0EBQQFBsNXNABDDIQALIAYgCTYCBCAGQQg2AgAgDiAOKAJIIAlrNgJIIANBMGoQ7yYgA0EgahDeOwsgA0GQAWokACAEKAIcIQMgBCgCGCIGQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAGNgIADAULIAQgAzYCBCADIAdGBEAgASABKAKYAiACaiIDNgKYAiAHIBRqIRQgAiAVaiEVIBAgEmoiEiARSQ0BDAQLCyAEQQI2AhwgBEHkkc8ANgIYIARCAjcCJCAEQTs2AhQgBEE7NgIMIAQgBEEIajYCICAEIARBBGo2AhAgBCAENgIIIAVBBGogBEEYahCZDiAFQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAFIBU2AgwgBSAUNgIIIAUgEjYCBCAFQQg2AgALIARBMGokAAwACyAMKAIQIQcgDCgCFCECIAwoAgwhESAMKAIIIgNBCEcEQCAAIAwpAxg3AxAgACACNgIMIAAgBzYCCCAAIBE2AgQgACADNgIADAULIAIgB00NAyAYKAIAIgRBgYCAgHhHDQIgDEEIakE9QQBBAUEBEKAYIAwoAgwhASAMKAIIQQFGDQEgDCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAwoAhBB1P3MABD9LwALIAEoAvACIQMgDCAYQQRBDCAEQYCAgIB4RhtqEIY9IAwoAgAhBCAMKAIEIQUCQCAKKAIAQYCAgIB4RwRAIAogAyAHIAIgBCAFEMwHDAELIApBBGohBgJAIAIgA2oiDiAKKAIMIghNBEAgCiAONgIMDAELIAYgDiAIaxDIIAsgBiADIAcgAiAEIAUQ6gkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyAMQSBqJAAPCyACIAQoAiBB9I7PABD9LwALgRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDMJyAKIA82AhQgCiAINgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEI4tIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlqIA0gCWsQxwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQlgsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABDOGCADQTBqIBMgAygCJCADKAIoEMcLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQyhAgAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDeOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJYLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQji0gBiADIAcgAiAEIAUQqgoLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwAL8BUCF38BfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBSABQbgCaiIVQQAgASgCuAJBgYCAgHhHGyEWIAFB4AJqQQAgASgC4AJBgICAgHhHGyEXIAFBoAJqIQ8jAEEwayIEJAACQAJAAkAgAiIQRQ0AIAFBoAFqIQ0gAUHQAGohGCABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ3AIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgECARayEDIAEpAwBCBFINASACIAMgAiADSRsiDiECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgF0UEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBcgAyACEIwQIAQoAiAhByAEKAIcIQ4gBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAONgIEIAUgBjYCAAwGCyAHIA5yRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAOTQ0CIAEtAEwgAUEAOgBMIA5qIQ4LIAIhBwJAIBgpAwBCBVENACAWRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBggFiACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDSkDAEIGfSIaQgFYBEAgGqdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA0oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCCADKAIwQQFGDQIgAygCOCIJQfDVzQBBIvwKAAAgBkEiNgIMIAYgCTYCCCAGIAg2AgQgBkEANgIADAsLIA0oAkghCCADIA1B0ABqIgkQ8y0iCzYCICADIA1B2ABqIgw2AnggCyAMELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshCyANQQhqIRICQCAPIAkQ0xMiCARAIAggCCgCCCIJIAtqEIctIAgoAggiDCAJSQ0GIANBMGogEiAIKAIEIAlBA3RqIAwgCWsQ2wogAygCNCEMIAMoAjAiC0EIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAMNgIEIAYgCzYCAAwMCyADQTBqIA8QmAsgAygCNCEZIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAZNgIEIAYgCDYCAAwMCyADQSBqIAtBgNXNABC2FSADQTBqIBIgAygCJCADKAIoENsKIAMoAjQhCAJAIAMoAjAiC0EIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCzYCAAwBCyADIAkQ8y0iCzYCLCADIAw2AnggCyAMELgIRQ0HIANBMGoiDCAJEMMtIANBGGogDBDcOyADKAIcIglFDQggA0EQaiADKAIYIgsQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRIgA0EIaiALQQxqENw7IAggAygCKCILSw0JIANB+ABqIBkgAygCJCAIIBIgCSADKAIIIAMoAgwQ8g8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDBDvJgsgA0EgahDjPAwLCyAIIAkgDGoQ9DQgBiAMNgIEIAZBCDYCACANIA0oAkggDGs2AkgMCgsgA0EwaiAPEJgLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDEHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAtBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAooAhAhByAKKAIUIQIgCigCDCEQIAooAggiA0EIRwRAIAAgCikDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgC8AIhAyAKIBVBBEEMIARBgICAgHhGG2oQhj0gCigCACEEIAooAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzAcMAQsgD0EEaiIGIAIgA2oQhy0gBiADIAcgAiAEIAUQ/gkLCyAAIBA2AgQgAEEINgIAIAEgASgC9AIgEGo2AvQCIAEgASgC8AIgAmo2AvACCyAKQSBqJAAPCyACIAQoAiBB9I7PABD9LwALwRACGH8DfiMAQSBrIggkAAJAAkACQAJAAkAgASkDAEIFUgRAIAhBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQsjAEEwayIDJAACQAJAAkAgAiIMRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ1AIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgDCAPayEGIAEpAwBCBFINASACIAYgAiAGSRsiCiECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQogAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCAKNgIEIAQgBzYCAAwGCyAFIApyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiAKTQ0CIAEtAEwgAUEAOgBMIApqIQoLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIHQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgBzYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIRBBACEJIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACINQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIA1qKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAJQQhqIglqIBdxIQcMAAsACyAGQQdqEIUpAAsgCyALKAIIIgcgBWoQhy0gCygCCCIJIAdJDQEgBkEIaiANIBpBDGxqIg1BCGsoAgAgCygCBCAHQQN0aiAJIAdrIA1BBGsoAgAoAhARBQAgBigCDCEJAkAgBigCCCINQQhHBEAgECAGKQMQNwMIIBBBEGogBkEYaikDADcDAAwBCyALIAcgCWoQ9DQLIBAgDTYCACAQIAk2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAJQaSuzgAQrzsACyADKAIcIQYgAygCGCIHQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAHNgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBFqIREgAiASaiESIAogD2oiDyAMSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCARNgIIIAQgDzYCBCAEQQg2AgALIANBMGokAAwACyAIKAIQIQUgCCgCFCECIAgoAgwhDCAIKAIIIgNBCEcEQCAAIAgpAxg3AxAgACACNgIMIAAgBTYCCCAAIAw2AgQgACADNgIADAULIAIgBU0NAyATKAIAIgNBgYCAgHhHDQIgCEEIakE9QQBBAUEBEKAYIAgoAgwhASAIKAIIQQFGDQEgCCgCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAgoAhBB1P3MABD9LwALIAEoAqQCIQQgCCATQQRBDCADQYCAgIB4RhtqEIY9IAsgBCAFIAIgCCgCACAIKAIEEP4JCyAAIAw2AgQgAEEINgIAIAEgASgCqAIgDGo2AqgCIAEgASgCpAIgAmo2AqQCCyAIQSBqJAAPCyACIAMoAiBB9I7PABD9LwAL3BUCGH8IfiMAQSBrIgokAAJAAkACQAJAAkAgASkDAEIFUgRAIApBCGohBCABQeABaiITQQAgASgC4AFBgYCAgHhHGyEUIAFBlAJqQQAgASgClAJBgICAgHhHGyEVIAFBiAJqIQwjAEEwayIDJAACQAJAAkAgAiIJRQ0AIAFBoAFqIQ4gAUHQAGohFiABKALYASEGAkACQANAAkACQAJAIAEoAtQBIgJBACACIAZHG0UEQCADQRhqIAEQ0QIgAy0AHCECIAMoAhgiBUEIRw0BIAJBAXFFDQcgASgC1AEiAkUNByABKALYASEGCyACIAZrIQIgCSANayEGIAEpAwBCBFINASACIAYgAiAGSRsiCyECDAILIAQgAykAHTcABSAEQRRqIANBLGooAAA2AAAgBEENaiADQSVqKQAANwAAIAQgAjoABCAEIAU2AgAMBgsgFUUEQCADQRhqQR5BAEEBQQEQoBggAygCHCECIAMoAhhBAUYNDSADKAIgIgVBFmpB6JLPACkAADcAACAFQRBqQeKSzwApAAA3AAAgBUEIakHaks8AKQAANwAAIAVB0pLPACkAADcAACAEQR42AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBgsgA0EYaiABIBUgBiACEIwQIAMoAiAhBSADKAIcIQsgAygCGCIIQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAU2AgggBCALNgIEIAQgCDYCAAwGCyAFIAtyRQRAIANBGGpBL0EAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUG4kM8AQS/8CgAAIARBLzYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyACIAVHBEAgBSECDAELIAEtANwBQQFHDQAgBiALTQ0CIAEtAEwgAUEAOgBMIAtqIQsLIAIhBQJAIBYpAwBCBVENACAURQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0EIAMoAiAiBUEWakGGk88AKQAANwAAIAVBEGpBgJPPACkAADcAACAFQQhqQfiSzwApAAA3AAAgBUHwks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIBYgFCACEMUDIAMoAiAhBiADKAIcIQUgAygCGCIIQQhHBEAgBCADKQIkNwIMIARBFGogA0EsaigCADYCACAEIAY2AgggBCAFNgIEIAQgCDYCAAwGCyACIAZGDQAgA0EYakHeAEEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0MIAMoAiAiBUH0kc8AQd4A/AoAACAEQd4ANgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAULIAMgBTYCACADQRhqIQ9BACEIIwBBIGsiBiQAAkACQCAOLQAkIgdBCUcEQCAGIAc6AAcCQAJAIA4oAgxFDQAgDkEQaiAGQQdqEOwMIRsgDigCACIRQQxrIRggDigCBCIXIBuncSEHIBtCGYhC/wCDQoGChIiQoMCAAX4hHSAGLQAHIRkDQCAHIBFqKQAAIhwgHYUiG0J/hSAbQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhtQRQRAA0AgGSAYQQAgG3qnQQN2IAdqIBdxayIaQQxsai0AAEYNBCAbQgF9IBuDIhtQRQ0ACwsgHCAcQgGGg0KAgYKEiJCgwIB/g1BFDQEgByAIQQhqIghqIBdxIQcMAAsACyAGQQdqEIUpAAsgDCgCCCEHIAZBADYCECAGQgA3AggCQCAHIAUgB2oiCE8EQCAMIAg2AggMAQsgDCAFIAZBCGoQhBggDCgCCCEICyAHIAhLDQEgBkEIaiARIBpBDGxqIhFBCGsoAgAgDCgCBCAHQQxsaiAIIAdrIBFBBGsoAgAoAhARBQAgBigCDCEIAkAgBigCCCIRQQhHBEAgDyAGKQMQNwMIIA9BEGogBkEYaikDADcDAAwBCyAHIAhqIgcgDCgCCEsNACAMIAc2AggLIA8gETYCACAPIAg2AgQgBkEgaiQADAILQeStzgBBHkGErs4AEMskAAsgByAIQaSuzgAQrzsACyADKAIcIQYgAygCGCIIQQhHBEAgBCADKQMgNwMIIARBEGogA0EoaikDADcDACAEIAY2AgQgBCAINgIADAULIAMgBjYCBCAFIAZGBEAgASABKALYASACaiIGNgLYASAFIBBqIRAgAiASaiESIAsgDWoiDSAJSQ0BDAQLCyADQQI2AhwgA0Hkkc8ANgIYIANCAjcCJCADQTs2AhQgA0E7NgIMIAMgA0EIajYCICADIANBBGo2AhAgAyADNgIIIARBBGogA0EYahCZDiAEQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAEIBI2AgwgBCAQNgIIIAQgDTYCBCAEQQg2AgALIANBMGokAAwACyAKKAIQIQUgCigCFCEGIAooAgwhCCAKKAIIIgJBCEcEQCAAIAopAxg3AxAgACAGNgIMIAAgBTYCCCAAIAg2AgQgACACNgIADAULIAUgBk8NAyATKAIAIglBgYCAgHhHDQIgCkEIakE9QQBBAUEBEKAYIAooAgwhASAKKAIIQQFGDQEgCigCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAooAhBB1P3MABD9LwALIAEoAqQCIQIgCiATQQRBDCAJQYCAgIB4RhtqEIY9IAooAgAhBCAKKAIEIQsjAEHwAGsiAyQAIANBADYCCCADQgA3AgACQCACIAZqIgkgDCgCCCIHTQRAIAwgCTYCCAwBCyAMIAkgB2sgAxCEGAsgAyAEIAsQ4BwgA0IANwNoIAMgAjYCYCADIAIgBWoiBTYCZAJAAkACQAJAIAIgBU8NACAFQQxsQQxrIQsgAygCWCEPIAMpAyAhHSADKAJUIQcgAygCUCEOIAMpA0AhGyADKQMwIR4gAygCECEQIAMpAwghHCADKAIoIRIgAygCGCETIAMpA0ghISADKQM4ISIgAykDACEfA0AgH6dBAXFFIQQCQANAAkACQAJAIARFBEAgHFBFDQFCACEcQgAhH0EBIQQMBAsCfgJAIB5CAn0iIEIBWARAICCnQQFrDQEMBQsgHqcgHlCtQgGGIR5BAXFFDQAgIgwBCyAbQgNRBEBCAyEbDAQLIA5FIAcgDkZyRQRAIAdBCGsiBykDAAwBC0EAIQ4gG0ICUQRAQgIhGwwECyAbp0IAIRtBAXFFDQMgIQshHEIBIR8gD0FAaiIPIRAMAQsgECAceadBP3MiCWohBEIBIAmthiAchSEcDAMLQQAhBAwBCwsgEyAdQgBScUUNAiASIB15p0E/cyIJaiEEQgEgCa2GIB2FIR0LIAQgBUEBayIJTQ0BIAkgDCgCCCINTw0CIAQgDU8NAyAMKAIEIgUgC2oiDSkCACEgIAUgBEEMbGoiBUEIaiANQQhqKAIANgIAIAUgIDcCACALQQxrIQsgCSIFIAJLDQALCyADQfAAaiQADAILIAVBAWsgDUGwms8AEMMhAAsgBCANQcCazwAQwyEACwsgACAINgIEIABBCDYCACABIAEoAqgCIAhqNgKoAiABIAEoAqQCIAZqNgKkAgsgCkEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC8oYAhl/AX4jAEEgayIMJAACQAJAAkACQAJAIAEpAwBCBVIEQCAMQQhqIQUgAUG4AmoiGEEAIAEoArgCQYGAgIB4RxshGSABQeACakEAIAEoAuACQYCAgIB4RxshGiABQaACaiEKIwBBMGsiBCQAAkACQAJAIAIiEUUNACABQaABaiEOIAFB0ABqIRsgASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABEOMCIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBEgEmshAyABKQMAQgRSDQEgAiADIAIgA0kbIhAhAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBpFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAaIAMgAhCMECAEKAIgIQcgBCgCHCEQIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgEDYCBCAFIAY2AgAMBgsgByAQckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgEE0NAiABLQBMIAFBADoATCAQaiEQCyACIQcCQCAbKQMAQgVRDQAgGUUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAbIBkgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA4pAwBCBn0iHEIBWARAIBynQQFGBEBB1NTNAEELQeDUzQAQyyQACyAOKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQggAygCMEEBRg0CIAMoAjgiCUHw1c0AQSL8CgAAIAZBIjYCDCAGIAk2AgggBiAINgIEIAZBADYCAAwLCyAOKAJIIQkgAyAOQdAAaiIIEPMtIg02AiAgAyAOQdgAaiILNgJ4IA0gCxC4CEUNAiAIEPUtDQMgCSAHIAcgCUsbIQ0gDkEIaiETAkACfwJAAkAgCBD0LUGAgARJBEACQCAKKAIAQYCAgIB4RwRAIAooAghBAUYNAQwECyAKKAIQIAooAhQoAghBAWtBeHFqIAgoAgAiCSAIKAIEIg8oAghBAWtBeHFqRwRAIAooAgwNBCAJIAkoAgAiFkEBajYCACAWQQBIDQMgCkEQaiIWKAIAIhcgFygCACIXQQFrNgIAIBdBAUYEQCAWELsjCyAKIA82AhQgCiAJNgIQCyAKQQRqDAQLIAgoAgAiCSAJKAIAIg9BAWo2AgAgD0EASA0BIAgoAgQhDyAKEM4nIAogDzYCFCAKIAk2AhAgCkICNwIIIApCgICAgAg3AgAgCkEEagwDC0Hgxs0AQTtBnMfNABCfKQsAC0EACyIJBEACQCAJKAIIIgggDWoiCyAITQRAIAkgCzYCCAwBCyAJIA0QzBogCSgCCCELCyAIIAtLDQYgA0EwaiATIAkoAgQgCEEBdGogCyAIaxC8CyADKAI0IQsgAygCMCINQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAs2AgQgBiANNgIADAwLIANBMGogChCSCyADKAI0IQ8gAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAJNgIADAwLIANBIGogDUGA1c0AEJkVIANBMGogEyADKAIkIAMoAigQvAsgAygCNCEJAkAgAygCMCINQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiANNgIADAELIAMgCBDzLSINNgIsIAMgCzYCeCANIAsQuAhFDQcgA0EwaiILIAgQwy0gA0EYaiALENw7IAMoAhwiCEUNCCADQRBqIAMoAhgiDRDFGyAIQQFGDQogAygCFCEIIAMoAhAhEyADQQhqIA1BDGoQ3DsgCSADKAIoIg1LDQkgA0H4AGogDyADKAIkIAkgEyAIIAMoAgggAygCDBC2ECADKAJ4IghBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCDYCACALEO8mCyADQSBqEJ08DAsLIAggC2oiCCAJKAIITQRAIAkgCDYCCAsgBiALNgIEIAZBCDYCACAOIA4oAkggC2s2AkgMCgsgA0EwaiAKEJILIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiAOIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAggC0Hg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAJIA1BwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAJNgIEIAZBCDYCACAOIA4oAkggCWs2AkggA0EwahDvJiADQSBqEJ08CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAwoAhAhByAMKAIUIQIgDCgCDCERIAwoAggiA0EIRwRAIAAgDCkDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiAMQQhqQT1BAEEBQQEQoBggDCgCDCEBIAwoAghBAUYNASAMKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgDCgCEEHU/cwAEP0vAAsgASgC8AIhAyAMIBhBBEEMIARBgICAgHhGG2oQhj0gDCgCACEEIAwoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiEGAkAgAiADaiIOIAooAgwiCE0EQCAKIA42AgwMAQsgBiAOIAhrEMwaCyAGIAMgByACIAQgBRDJCQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAxBIGokAA8LIAIgBCgCIEH0js8AEP0vAAuMFQIYfwh+IwBBIGsiCSQAAkACQAJAAkACQCABKQMAQgVSBEAgCUEIaiEFIAFB4AFqIhNBACABKALgAUGBgICAeEcbIRQgAUGUAmpBACABKAKUAkGAgICAeEcbIRUgAUGIAmohDCMAQTBrIgMkAAJAAkACQCACIgpFDQAgAUGgAWohDSABQdAAaiEWIAEoAtgBIQYCQAJAA0ACQAJAAkAgASgC1AEiAkEAIAIgBkcbRQRAIANBGGogARDhAiADLQAcIQIgAygCGCIEQQhHDQEgAkEBcUUNByABKALUASICRQ0HIAEoAtgBIQYLIAIgBmshAiAKIA5rIQYgASkDAEIEUg0BIAIgBiACIAZJGyILIQIMAgsgBSADKQAdNwAFIAVBFGogA0EsaigAADYAACAFQQ1qIANBJWopAAA3AAAgBSACOgAEIAUgBDYCAAwGCyAVRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBEEWakHoks8AKQAANwAAIARBEGpB4pLPACkAADcAACAEQQhqQdqSzwApAAA3AAAgBEHSks8AKQAANwAAIAVBHjYCDCAFIAQ2AgggBSACNgIEIAVBADYCAAwGCyADQRhqIAEgFSAGIAIQjBAgAygCICEEIAMoAhwhCyADKAIYIghBCEcEQCAFIAMpAiQ3AgwgBUEUaiADQSxqKAIANgIAIAUgBDYCCCAFIAs2AgQgBSAINgIADAYLIAQgC3JFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIEQbiQzwBBL/wKAAAgBUEvNgIMIAUgBDYCCCAFIAI2AgQgBUEANgIADAYLIAIgBEcEQCAEIQIMAQsgAS0A3AFBAUcNACAGIAtNDQIgAS0ATCABQQA6AEwgC2ohCwsgAiEEAkAgFikDAEIFUQ0AIBRFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIEQRZqQYaTzwApAAA3AAAgBEEQakGAk88AKQAANwAAIARBCGpB+JLPACkAADcAACAEQfCSzwApAAA3AAAgBUEeNgIMIAUgBDYCCCAFIAI2AgQgBUEANgIADAYLIANBGGogFiAUIAIQxQMgAygCICEGIAMoAhwhBCADKAIYIghBCEcEQCAFIAMpAiQ3AgwgBUEUaiADQSxqKAIANgIAIAUgBjYCCCAFIAQ2AgQgBSAINgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIEQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAENgIIIAUgAjYCBCAFQQA2AgAMBQsgAyAENgIAIANBGGohD0EAIQgjAEEgayIGJAACQAJAIA0tACQiB0EJRwRAIAYgBzoABwJAAkAgDSgCDEUNACANQRBqIAZBB2oQ7AwhGyANKAIAIhBBDGshGCANKAIEIhcgG6dxIQcgG0IZiEL/AINCgYKEiJCgwIABfiEdIAYtAAchGQNAIAcgEGopAAAiHCAdhSIbQn+FIBtCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiG1BFBEADQCAZIBhBACAbeqdBA3YgB2ogF3FrIhpBDGxqLQAARg0EIBtCAX0gG4MiG1BFDQALCyAcIBxCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAhBCGoiCGogF3EhBwwACwALIAZBB2oQhSkACwJAIAwoAggiByAEaiIIIAdNBEAgDCAINgIIDAELIAwgBBCGHCAMKAIIIQgLIAcgCEsNASAGQQhqIBAgGkEMbGoiEEEIaygCACAMKAIEIAdqIAggB2sgEEEEaygCACgCEBEFACAGKAIMIQgCQCAGKAIIIhBBCEcEQCAPIAYpAxA3AwggD0EQaiAGQRhqKQMANwMADAELIAcgCGoiByAMKAIISw0AIAwgBzYCCAsgDyAQNgIAIA8gCDYCBCAGQSBqJAAMAgtB5K3OAEEeQYSuzgAQyyQACyAHIAhBpK7OABCvOwALIAMoAhwhBiADKAIYIghBCEcEQCAFIAMpAyA3AwggBUEQaiADQShqKQMANwMAIAUgBjYCBCAFIAg2AgAMBQsgAyAGNgIEIAQgBkYEQCABIAEoAtgBIAJqIgY2AtgBIAQgEWohESACIBJqIRIgCyAOaiIOIApJDQEMBAsLIANBAjYCHCADQeSRzwA2AhggA0ICNwIkIANBOzYCFCADQTs2AgwgAyADQQhqNgIgIAMgA0EEajYCECADIAM2AgggBUEEaiADQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgEjYCDCAFIBE2AgggBSAONgIEIAVBCDYCAAsgA0EwaiQADAALIAkoAhAhBCAJKAIUIQUgCSgCDCEGIAkoAggiAkEIRwRAIAAgCSkDGDcDECAAIAU2AgwgACAENgIIIAAgBjYCBCAAIAI2AgAMBQsgBCAFTw0DIBMoAgAiAkGBgICAeEcNAiAJQQhqQT1BAEEBQQEQoBggCSgCDCEBIAkoAghBAUYNASAJKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCSgCEEHU/cwAEP0vAAsgASgCpAIhAyAJIBNBBEEMIAJBgICAgHhGG2oQhj0gCSgCACEIIAkoAgQhCyMAQfAAayICJAACQCADIAVqIgogDCgCCCIHTQRAIAwgCjYCCAwBCyAMIAogB2sQhhwLIAIgCCALEOAcIAJCADcDaCACIAM2AmAgAiADIARqIgQ2AmQCQAJAAkACQCADIARPDQAgBEEBayEKIAIoAlghDSACKQMgIR0gAigCVCEIIAIoAlAhCyACKQNAIRsgAikDMCEeIAIoAhAhDiACKQMIIRwgAigCKCEPIAIoAhghESACKQNIISAgAikDOCEhIAIpAwAhHwNAIB+nQQFxRSEEAkADQAJAAkACQCAERQRAIBxQRQ0BQgAhHEIAIR9BASEEDAQLAn4CQCAeQgJ9IiJCAVgEQCAip0EBaw0BDAULIB6nIB5QrUIBhiEeQQFxRQ0AICEMAQsgG0IDUQRAQgMhGwwECyALRSAIIAtGckUEQCAIQQhrIggpAwAMAQtBACELIBtCAlEEQEICIRsMBAsgG6dCACEbQQFxRQ0DICALIRxCASEfIA1BQGoiDSEODAELIA4gHHmnQT9zIgdqIQRCASAHrYYgHIUhHAwDC0EAIQQMAQsLIBEgHUIAUnFFDQIgDyAdeadBP3MiB2ohBEIBIAethiAdhSEdCyAEIApNDQEgCiAMKAIIIgdPDQIgBCAHTw0DIAQgDCgCBCIHaiAHIApqLQAAOgAAIAMgCkkgCkEBayEKDQALCyACQfAAaiQADAILIAogB0Gwms8AEMMhAAsgBCAHQcCazwAQwyEACwsgACAGNgIEIABBCDYCACABIAEoAqgCIAZqNgKoAiABIAEoAqQCIAVqNgKkAgsgCUEgaiQADwsgAiADKAIgQfSOzwAQ/S8AC4UYAhl/AX4jAEEgayILJAACQAJAAkACQAJAIAEpAwBCBVIEQCALQQhqIQUgAUG4AmoiGEEAIAEoArgCQYGAgIB4RxshGSABQeACakEAIAEoAuACQYCAgIB4RxshGiABQaACaiEKIwBBMGsiBCQAAkACQAJAIAIiEUUNACABQaABaiEOIAFB0ABqIRsgASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABENsCIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBEgEmshAyABKQMAQgRSDQEgAiADIAIgA0kbIhAhAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBpFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAaIAMgAhCMECAEKAIgIQcgBCgCHCEQIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgEDYCBCAFIAY2AgAMBgsgByAQckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgEE0NAiABLQBMIAFBADoATCAQaiEQCyACIQcCQCAbKQMAQgVRDQAgGUUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAbIBkgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA4pAwBCBn0iHEIBWARAIBynQQFGBEBB1NTNAEELQeDUzQAQyyQACyAOKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQkgAygCMEEBRg0CIAMoAjgiCEHw1c0AQSL8CgAAIAZBIjYCDCAGIAg2AgggBiAJNgIEIAZBADYCAAwLCyAOKAJIIQggAyAOQdAAaiIJEPMtIgw2AiAgAyAOQdgAaiINNgJ4IAwgDRC4CEUNAiAJEPUtDQMgCCAHIAcgCEsbIQwgDkEIaiETAkACfwJAAkAgCRD0LUEATgRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDPJyAKIA82AhQgCiAINgIQIApCBDcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEIYtIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlBAnRqIA0gCWsQ3AogAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQlQsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqQQAgDEGA1c0AELMVIANBMGogEyADKAIkIAMoAigQ3AogAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgDTYCeCAMIA0QuAhFDQcgA0EwaiINIAkQwy0gA0EYaiANENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDHGyAJQQFGDQogAygCFCEJIAMoAhAhEyADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogDyADKAIkIAggEyAJIAMoAgggAygCDBDuDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACANEO8mCyADQSBqEOk7DAsLIAggCSANahD0NCAGIA02AgQgBkEINgIAIA4gDigCSCANazYCSAwKCyADQTBqIAoQlQsgAygCNCEJIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgCDYCAAwKCyAGIA4gCSAHQQAQwhQMCQsgCSADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSANQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA4gDigCSCAIazYCSCADQTBqEO8mIANBIGoQ6TsLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIREgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgGEEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIgYgAiADahCGLSAGIAMgByACIAQgBRD9CQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAu1FgIXfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhVBACABKAK4AkGBgICAeEcbIRYgAUHgAmpBACABKALgAkGAgICAeEcbIRcgAUGgAmohDyMAQTBrIgQkAAJAAkACQCACIhBFDQAgAUGgAWohDSABQdAAaiEYIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDcAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiAQIBFrIQMgASkDAEIEUg0BIAIgAyACIANJGyIOIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAXRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgFyADIAIQjBAgBCgCICEHIAQoAhwhDiAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIA42AgQgBSAGNgIADAYLIAcgDnJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIA5NDQIgAS0ATCABQQA6AEwgDmohDgsgAiEHAkAgGCkDAEIFUQ0AIBZFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGCAWIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCANKQMAQgZ9IhpCAVgEQCAap0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDSgCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEIIAMoAjBBAUYNAiADKAI4IglB8NXNAEEi/AoAACAGQSI2AgwgBiAJNgIIIAYgCDYCBCAGQQA2AgAMCwsgDSgCSCEIIAMgDUHQAGoiCRDzLSIMNgIgIAMgDUHYAGoiCjYCeCAMIAoQuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA1BCGohEgJAIA8gCRDTEyIIBEACQCAIKAIIIgkgDGoiCiAJTQRAIAggCjYCCAwBCyAIIAwQix8gCCgCCCEKCyAJIApLDQYgA0EwaiASIAgoAgQgCUEDdGogCiAJaxDbCiADKAI0IQogAygCMCIMQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAo2AgQgBiAMNgIADAwLIANBMGogDxCYCyADKAI0IRkgAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIBk2AgQgBiAINgIADAwLIANBIGogDEGA1c0AELYVIANBMGogEiADKAIkIAMoAigQ2wogAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgCjYCeCAMIAoQuAhFDQcgA0EwaiIKIAkQwy0gA0EYaiAKENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDFGyAJQQFGDQogAygCFCEJIAMoAhAhEiADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogGSADKAIkIAggEiAJIAMoAgggAygCDBDyDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACAKEO8mCyADQSBqEOM8DAsLIAkgCmoiCSAIKAIITQRAIAggCTYCCAsgBiAKNgIEIAZBCDYCACANIA0oAkggCms2AkgMCgsgA0EwaiAPEJgLIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiANIAggB0EAEMEUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgCkHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACANIA0oAkggCGs2AkggA0EwahDvJiADQSBqEOM8CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgE2ohEyACIBRqIRQgDiARaiIRIBBJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFDYCDCAFIBM2AgggBSARNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCEQIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgEDYCBCAAIAM2AgAMBQsgAiAHTQ0DIBUoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBVBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIA8oAgBBgICAgHhHBEAgDyADIAcgAiAEIAUQzAcMAQsgD0EEaiEGAkAgAiADaiINIA8oAgwiDk0EQCAPIA02AgwMAQsgBiANIA5rEIsfCyAGIAMgByACIAQgBRDICQsLIAAgEDYCBCAAQQg2AgAgASABKAL0AiAQajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAvGGAIZfwF+IwBBIGsiDCQAAkACQAJAAkACQCABKQMAQgVSBEAgDEEIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDkAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEIIAMoAjBBAUYNAiADKAI4IglB8NXNAEEi/AoAACAGQSI2AgwgBiAJNgIIIAYgCDYCBCAGQQA2AgAMCwsgDigCSCEJIAMgDkHQAGoiCBDzLSINNgIgIAMgDkHYAGoiCzYCeCANIAsQuAhFDQIgCBD1LQ0DIAkgByAHIAlLGyENIA5BCGohEwJAAn8CQAJAIAgQ9C1BgAFJBEACQCAKKAIAQYCAgIB4RwRAIAooAghBAUYNAQwECyAKKAIQIAooAhQoAghBAWtBeHFqIAgoAgAiCSAIKAIEIg8oAghBAWtBeHFqRwRAIAooAgwNBCAJIAkoAgAiFkEBajYCACAWQQBIDQMgCkEQaiIWKAIAIhcgFygCACIXQQFrNgIAIBdBAUYEQCAWELsjCyAKIA82AhQgCiAJNgIQCyAKQQRqDAQLIAgoAgAiCSAJKAIAIg9BAWo2AgAgD0EASA0BIAgoAgQhDyAKEMsnIAogDzYCFCAKIAk2AhAgCkIBNwIIIApCgICAgAg3AgAgCkEEagwDC0Hgxs0AQTtBnMfNABCfKQsAC0EACyIJBEACQCAJKAIIIgggDWoiCyAITQRAIAkgCzYCCAwBCyAJIA0QyCAgCSgCCCELCyAIIAtLDQYgA0EwaiATIAkoAgQgCGogCyAIaxCoCyADKAI0IQsgAygCMCINQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAs2AgQgBiANNgIADAwLIANBMGogChCQCyADKAI0IQ8gAygCMCIJQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAJNgIADAwLIANBIGogDUGA1c0AEM4YIANBMGogEyADKAIkIAMoAigQqAsgAygCNCEJAkAgAygCMCINQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiANNgIADAELIAMgCBDzLSINNgIsIAMgCzYCeCANIAsQuAhFDQcgA0EwaiILIAgQwy0gA0EYaiALENw7IAMoAhwiCEUNCCADQRBqIAMoAhgiDRDHGyAIQQFGDQogAygCFCEIIAMoAhAhEyADQQhqIA1BDGoQ3DsgCSADKAIoIg1LDQkgA0H4AGogDyADKAIkIAkgEyAIIAMoAgggAygCDBCRECADKAJ4IghBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCDYCACALEO8mCyADQSBqEN47DAsLIAggC2oiCCAJKAIITQRAIAkgCDYCCAsgBiALNgIEIAZBCDYCACAOIA4oAkggC2s2AkgMCgsgA0EwaiAKEJALIAMoAjQhCCADKAIwIglBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAk2AgAMCgsgBiAOIAggB0EAEMIUDAkLIAggAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAggC0Hg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAJIA1BwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAJNgIEIAZBCDYCACAOIA4oAkggCWs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAwoAhAhByAMKAIUIQIgDCgCDCERIAwoAggiA0EIRwRAIAAgDCkDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiAMQQhqQT1BAEEBQQEQoBggDCgCDCEBIAwoAghBAUYNASAMKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgDCgCEEHU/cwAEP0vAAsgASgC8AIhAyAMIBhBBEEMIARBgICAgHhGG2oQhj0gDCgCACEEIAwoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzQcMAQsgCkEEaiEGAkAgAiADaiIOIAooAgwiCE0EQCAKIA42AgwMAQsgBiAOIAhrEMggCyAGIAMgByACIAQgBRDqCQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAxBIGokAA8LIAIgBCgCIEH0js8AEP0vAAufFQIYfwh+IwBBIGsiCiQAAkACQAJAAkACQCABKQMAQgVSBEAgCkEIaiEEIAFB4AFqIhNBACABKALgAUGBgICAeEcbIRQgAUGUAmpBACABKAKUAkGAgICAeEcbIRUgAUGIAmohDCMAQTBrIgMkAAJAAkACQCACIglFDQAgAUGgAWohDSABQdAAaiEWIAEoAtgBIQYCQAJAA0ACQAJAAkAgASgC1AEiAkEAIAIgBkcbRQRAIANBGGogARDdAiADLQAcIQIgAygCGCIFQQhHDQEgAkEBcUUNByABKALUASICRQ0HIAEoAtgBIQYLIAIgBmshAiAJIA5rIQYgASkDAEIEUg0BIAIgBiACIAZJGyILIQIMAgsgBCADKQAdNwAFIARBFGogA0EsaigAADYAACAEQQ1qIANBJWopAAA3AAAgBCACOgAEIAQgBTYCAAwGCyAVRQRAIANBGGpBHkEAQQFBARCgGCADKAIcIQIgAygCGEEBRg0NIAMoAiAiBUEWakHoks8AKQAANwAAIAVBEGpB4pLPACkAADcAACAFQQhqQdqSzwApAAA3AAAgBUHSks8AKQAANwAAIARBHjYCDCAEIAU2AgggBCACNgIEIARBADYCAAwGCyADQRhqIAEgFSAGIAIQjBAgAygCICEFIAMoAhwhCyADKAIYIgdBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBTYCCCAEIAs2AgQgBCAHNgIADAYLIAUgC3JFBEAgA0EYakEvQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQ0gAygCICIFQbiQzwBBL/wKAAAgBEEvNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIAIgBUcEQCAFIQIMAQsgAS0A3AFBAUcNACAGIAtNDQIgAS0ATCABQQA6AEwgC2ohCwsgAiEFAkAgFikDAEIFUQ0AIBRFBEAgA0EYakEeQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQQgAygCICIFQRZqQYaTzwApAAA3AAAgBUEQakGAk88AKQAANwAAIAVBCGpB+JLPACkAADcAACAFQfCSzwApAAA3AAAgBEEeNgIMIAQgBTYCCCAEIAI2AgQgBEEANgIADAYLIANBGGogFiAUIAIQxQMgAygCICEGIAMoAhwhBSADKAIYIgdBCEcEQCAEIAMpAiQ3AgwgBEEUaiADQSxqKAIANgIAIAQgBjYCCCAEIAU2AgQgBCAHNgIADAYLIAIgBkYNACADQRhqQd4AQQBBAUEBEKAYIAMoAhwhAiADKAIYQQFGDQwgAygCICIFQfSRzwBB3gD8CgAAIARB3gA2AgwgBCAFNgIIIAQgAjYCBCAEQQA2AgAMBQsgAyAFNgIAIANBGGohD0EAIQcjAEEgayIGJAACQAJAIA0tACQiCEEJRwRAIAYgCDoABwJAAkAgDSgCDEUNACANQRBqIAZBB2oQ7AwhGyANKAIAIhFBDGshGCANKAIEIhcgG6dxIQggG0IZiEL/AINCgYKEiJCgwIABfiEdIAYtAAchGQNAIAggEWopAAAiHCAdhSIbQn+FIBtCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiG1BFBEADQCAZIBhBACAbeqdBA3YgCGogF3FrIhpBDGxqLQAARg0EIBtCAX0gG4MiG1BFDQALCyAcIBxCAYaDQoCBgoSIkKDAgH+DUEUNASAIIAdBCGoiB2ogF3EhCAwACwALIAZBB2oQhSkACwJAIAwoAggiCCAFaiIHIAhNBEAgDCAHNgIIDAELIAwgBRCEHyAMKAIIIQcLIAcgCEkNASAGQQhqIBEgGkEMbGoiEUEIaygCACAMKAIEIAhBAnRqIAcgCGsgEUEEaygCACgCEBEFACAGKAIMIQcCQCAGKAIIIhFBCEcEQCAPIAYpAxA3AwggD0EQaiAGQRhqKQMANwMADAELIAcgCGoiCCAMKAIISw0AIAwgCDYCCAsgDyARNgIAIA8gBzYCBCAGQSBqJAAMAgtB5K3OAEEeQYSuzgAQyyQACyAIIAdBpK7OABCvOwALIAMoAhwhBiADKAIYIgdBCEcEQCAEIAMpAyA3AwggBEEQaiADQShqKQMANwMAIAQgBjYCBCAEIAc2AgAMBQsgAyAGNgIEIAUgBkYEQCABIAEoAtgBIAJqIgY2AtgBIAUgEGohECACIBJqIRIgCyAOaiIOIAlJDQEMBAsLIANBAjYCHCADQeSRzwA2AhggA0ICNwIkIANBOzYCFCADQTs2AgwgAyADQQhqNgIgIAMgA0EEajYCECADIAM2AgggBEEEaiADQRhqEJkOIARBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAQgEjYCDCAEIBA2AgggBCAONgIEIARBCDYCAAsgA0EwaiQADAALIAooAhAhBSAKKAIUIQYgCigCDCEHIAooAggiAkEIRwRAIAAgCikDGDcDECAAIAY2AgwgACAFNgIIIAAgBzYCBCAAIAI2AgAMBQsgBSAGTw0DIBMoAgAiCUGBgICAeEcNAiAKQQhqQT1BAEEBQQEQoBggCigCDCEBIAooAghBAUYNASAKKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCigCEEHU/cwAEP0vAAsgASgCpAIhAiAKIBNBBEEMIAlBgICAgHhGG2oQhj0gCigCACEEIAooAgQhCyMAQfAAayIDJAACQCACIAZqIgkgDCgCCCIITQRAIAwgCTYCCAwBCyAMIAkgCGsQhB8LIAMgBCALEOAcIANCADcDaCADIAI2AmAgAyACIAVqIgU2AmQCQAJAAkACQCACIAVPDQAgBUECdEEEayELIAMoAlghDyADKQMgIR0gAygCVCEIIAMoAlAhDSADKQNAIRsgAykDMCEeIAMoAhAhECADKQMIIRwgAygCKCESIAMoAhghEyADKQNIISAgAykDOCEhIAMpAwAhHwNAIB+nQQFxRSEEAkADQAJAAkACQCAERQRAIBxQRQ0BQgAhHEIAIR9BASEEDAQLAn4CQCAeQgJ9IiJCAVgEQCAip0EBaw0BDAULIB6nIB5QrUIBhiEeQQFxRQ0AICEMAQsgG0IDUQRAQgMhGwwECyANRSAIIA1GckUEQCAIQQhrIggpAwAMAQtBACENIBtCAlEEQEICIRsMBAsgG6dCACEbQQFxRQ0DICALIRxCASEfIA9BQGoiDyEQDAELIBAgHHmnQT9zIglqIQRCASAJrYYgHIUhHAwDC0EAIQQMAQsLIBMgHUIAUnFFDQIgEiAdeadBP3MiCWohBEIBIAmthiAdhSEdCyAEIAVBAWsiCU0NASAJIAwoAggiDk8NAiAEIA5PDQMgDCgCBCIFIARBAnRqIAUgC2oqAgA4AgAgC0EEayELIAkiBSACSw0ACwsgA0HwAGokAAwCCyAFQQFrIA5BsJrPABDDIQALIAQgDkHAms8AEMMhAAsLIAAgBzYCBCAAQQg2AgAgASABKAKoAiAHajYCqAIgASABKAKkAiAGajYCpAILIApBIGokAA8LIAIgAygCIEH0js8AEP0vAAvvFwIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDSAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8gCRD0LRoCQAJAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMAwsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQMgCCAIKAIAIhZBAWo2AgAgFkEASA0CIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwDCyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNACAJKAIEIQ8gChDPJyAKIA82AhQgCiAINgIQIApCBDcCCCAKQoCAgIAINwIAIApBBGoMAgsAC0EACyIIBEAgCCAIKAIIIgkgDGoQlS0gCCgCCCINIAlJDQYgA0EwaiATIAgoAgQgCUECdGogDSAJaxC7CyADKAI0IQ0gAygCMCIMQQhGDQEgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA02AgQgBiAMNgIADAwLIANBMGogChCVCyADKAI0IQ8gAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIA82AgQgBiAINgIADAwLIANBIGogDEGA1c0AEL8VIANBMGogEyADKAIkIAMoAigQuwsgAygCNCEIAkAgAygCMCIMQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAg2AgQgBiAMNgIADAELIAMgCRDzLSIMNgIsIAMgDTYCeCAMIA0QuAhFDQcgA0EwaiINIAkQwy0gA0EYaiANENw7IAMoAhwiCUUNCCADQRBqIAMoAhgiDBDHGyAJQQFGDQogAygCFCEJIAMoAhAhEyADQQhqIAxBDGoQ3DsgCCADKAIoIgxLDQkgA0H4AGogDyADKAIkIAggEyAJIAMoAgggAygCDBDuDyADKAJ4IglBCEYNCyAGIAMpAnw3AgQgBkEUaiADQYwBaigCADYCACAGQQxqIANBhAFqKQIANwIAIAYgCTYCACANEO8mCyADQSBqEOk7DAsLIAggCSANahD0NCAGIA02AgQgBkEINgIAIA4gDigCSCANazYCSAwKCyADQTBqIAoQlQsgAygCNCEJIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAJNgIEIAYgCDYCAAwKCyAGIA4gCSAHQQAQwhQMCQsgCSADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSANQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA4gDigCSCAIazYCSCADQTBqEO8mIANBIGoQ6TsLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByAUaiEUIAIgFWohFSAQIBJqIhIgEUkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAVNgIMIAUgFDYCCCAFIBI2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIREgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACARNgIEIAAgAzYCAAwFCyACIAdNDQMgGCgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgGEEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgCigCAEGAgICAeEcEQCAKIAMgByACIAQgBRDNBwwBCyAKQQRqIgYgAiADahCVLSAGIAMgByACIAQgBRD/CQsLIAAgETYCBCAAQQg2AgAgASABKAL0AiARajYC9AIgASABKALwAiACajYC8AILIAtBIGokAA8LIAIgBCgCIEH0js8AEP0vAAuFGAIZfwF+IwBBIGsiCyQAAkACQAJAAkACQCABKQMAQgVSBEAgC0EIaiEFIAFBuAJqIhhBACABKAK4AkGBgICAeEcbIRkgAUHgAmpBACABKALgAkGAgICAeEcbIRogAUGgAmohCiMAQTBrIgQkAAJAAkACQCACIhFFDQAgAUGgAWohDiABQdAAaiEbIAEoApgCIQMCQAJAA0ACQAJAAkAgASgClAIiAkEAIAIgA0cbRQRAIARBGGogARDYAiAELQAcIQIgBCgCGCIHQQhHDQEgAkEBcUUNByABKAKUAiICRQ0HIAEoApgCIQMLIAIgA2shAiARIBJrIQMgASkDAEIEUg0BIAIgAyACIANJGyIQIQIMAgsgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSACOgAEIAUgBzYCAAwGCyAaRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0EWakHoks8AKQAANwAAIAdBEGpB4pLPACkAADcAACAHQQhqQdqSzwApAAA3AAAgB0HSks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIAEgGiADIAIQjBAgBCgCICEHIAQoAhwhECAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIBA2AgQgBSAGNgIADAYLIAcgEHJFBEAgBEEYakEvQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQbiQzwBBL/wKAAAgBUEvNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIAIgB0cEQCAHIQIMAQsgAS0AnAJBAUcNACADIBBNDQIgAS0ATCABQQA6AEwgEGohEAsgAiEHAkAgGykDAEIFUQ0AIBlFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQQgBCgCICIHQRZqQYaTzwApAAA3AAAgB0EQakGAk88AKQAANwAAIAdBCGpB+JLPACkAADcAACAHQfCSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogGyAZIAIQxQMgBCgCICEDIAQoAhwhByAEKAIYIgZBCEcEQCAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgAzYCCCAFIAc2AgQgBSAGNgIADAYLIAIgA0YNACAEQRhqQd4AQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQwgBCgCICIHQfSRzwBB3gD8CgAAIAVB3gA2AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBQsgBCAHNgIAIARBGGohBiMAQZABayIDJAACQAJAAkACQAJAAkACQAJAAkACQCAOKQMAQgZ9IhxCAVgEQCAcp0EBRgRAQdTUzQBBC0Hg1M0AEMskAAsgDigCUEUEQCADQTBqQSJBAEEBQQEQoBggAygCNCEJIAMoAjBBAUYNAiADKAI4IghB8NXNAEEi/AoAACAGQSI2AgwgBiAINgIIIAYgCTYCBCAGQQA2AgAMCwsgDigCSCEIIAMgDkHQAGoiCRDzLSIMNgIgIAMgDkHYAGoiDTYCeCAMIA0QuAhFDQIgCRD1LQ0DIAggByAHIAhLGyEMIA5BCGohEwJAAn8CQAJAIAkQ9C1BAE4EQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAggCCgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMBAsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQEgCSgCBCEPIAoQ0CcgCiAPNgIUIAogCDYCECAKQgQ3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIggEQCAIIAgoAggiCSAMahCGLSAIKAIIIg0gCUkNBiADQTBqIBMgCCgCBCAJQQJ0aiANIAlrENwKIAMoAjQhDSADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDTYCBCAGIAw2AgAMDAsgA0EwaiAKEJELIAMoAjQhDyADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAg2AgAMDAsgA0EgakEAIAxBgNXNABCzFSADQTBqIBMgAygCJCADKAIoENwKIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxRsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQ7w8gAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDpOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJELIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMEUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEOk7CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzAcMAQsgCkEEaiIGIAIgA2oQhi0gBiADIAcgAiAEIAUQ/QkLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALgRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ4gIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYACSQRAAkAgCigCAEGAgICAeEcEQCAKKAIIQQFGDQEMBAsgCigCECAKKAIUKAIIQQFrQXhxaiAJKAIAIgggCSgCBCIPKAIIQQFrQXhxakcEQCAKKAIMDQQgCCAIKAIAIhZBAWo2AgAgFkEASA0DIApBEGoiFigCACIXIBcoAgAiF0EBazYCACAXQQFGBEAgFhC7IwsgCiAPNgIUIAogCDYCEAsgCkEEagwECyAJKAIAIgggCCgCACIPQQFqNgIAIA9BAEgNASAJKAIEIQ8gChDLJyAKIA82AhQgCiAINgIQIApCATcCCCAKQoCAgIAINwIAIApBBGoMAwtB4MbNAEE7QZzHzQAQnykLAAtBAAsiCARAIAggCCgCCCIJIAxqEI4tIAgoAggiDSAJSQ0GIANBMGogEyAIKAIEIAlqIA0gCWsQxwsgAygCNCENIAMoAjAiDEEIRg0BIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiANNgIEIAYgDDYCAAwMCyADQTBqIAoQmwsgAygCNCEPIAMoAjAiCEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAPNgIEIAYgCDYCAAwMCyADQSBqIAxBgNXNABDOGCADQTBqIBMgAygCJCADKAIoEMcLIAMoAjQhCAJAIAMoAjAiDEEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgDDYCAAwBCyADIAkQ8y0iDDYCLCADIA02AnggDCANELgIRQ0HIANBMGoiDSAJEMMtIANBGGogDRDcOyADKAIcIglFDQggA0EQaiADKAIYIgwQxxsgCUEBRg0KIAMoAhQhCSADKAIQIRMgA0EIaiAMQQxqENw7IAggAygCKCIMSw0JIANB+ABqIA8gAygCJCAIIBMgCSADKAIIIAMoAgwQyRAgAygCeCIJQQhGDQsgBiADKQJ8NwIEIAZBFGogA0GMAWooAgA2AgAgBkEMaiADQYQBaikCADcCACAGIAk2AgAgDRDvJgsgA0EgahDeOwwLCyAIIAkgDWoQ9DQgBiANNgIEIAZBCDYCACAOIA4oAkggDWs2AkgMCgsgA0EwaiAKEJsLIAMoAjQhCSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCTYCBCAGIAg2AgAMCgsgBiAOIAkgB0EAEMIUDAkLIAkgAygCOEH8u80AEP0vAAsgA0EANgIwIANBIGogA0H4AGogA0EwakHw1M0AEKMrAAsgBkIINwMADAYLIAkgDUHg1c0AEK87AAsgA0EANgIwIANBLGogA0H4AGogA0EwakGQ1c0AEKMrAAtBAEEAQaDVzQAQwyEACyAIIAxBwNXNABCwOwALQQFBAUGw1c0AEMMhAAsgBiAINgIEIAZBCDYCACAOIA4oAkggCGs2AkggA0EwahDvJiADQSBqEN47CyADQZABaiQAIAQoAhwhAyAEKAIYIgZBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAY2AgAMBQsgBCADNgIEIAMgB0YEQCABIAEoApgCIAJqIgM2ApgCIAcgFGohFCACIBVqIRUgECASaiISIBFJDQEMBAsLIARBAjYCHCAEQeSRzwA2AhggBEICNwIkIARBOzYCFCAEQTs2AgwgBCAEQQhqNgIgIAQgBEEEajYCECAEIAQ2AgggBUEEaiAEQRhqEJkOIAVBADYCAAwDC0HnkM8AQTJBnJHPABCfKQALDAgLIAUgFTYCDCAFIBQ2AgggBSASNgIEIAVBCDYCAAsgBEEwaiQADAALIAsoAhAhByALKAIUIQIgCygCDCERIAsoAggiA0EIRwRAIAAgCykDGDcDECAAIAI2AgwgACAHNgIIIAAgETYCBCAAIAM2AgAMBQsgAiAHTQ0DIBgoAgAiBEGBgICAeEcNAiALQQhqQT1BAEEBQQEQoBggCygCDCEBIAsoAghBAUYNASALKAIQIgJBxIfNAEE9/AoAACAAQT02AgwgACACNgIIIAAgATYCBCAAQQA2AgAMBAtBtIfNABCyOwALIAEgCygCEEHU/cwAEP0vAAsgASgC8AIhAyALIBhBBEEMIARBgICAgHhGG2oQhj0gCygCACEEIAsoAgQhBQJAIAooAgBBgICAgHhHBEAgCiADIAcgAiAEIAUQzQcMAQsgCkEEaiIGIAIgA2oQji0gBiADIAcgAiAEIAUQqgoLCyAAIBE2AgQgAEEINgIAIAEgASgC9AIgEWo2AvQCIAEgASgC8AIgAmo2AvACCyALQSBqJAAPCyACIAQoAiBB9I7PABD9LwALhRgCGX8BfiMAQSBrIgskAAJAAkACQAJAAkAgASkDAEIFUgRAIAtBCGohBSABQbgCaiIYQQAgASgCuAJBgYCAgHhHGyEZIAFB4AJqQQAgASgC4AJBgICAgHhHGyEaIAFBoAJqIQojAEEwayIEJAACQAJAAkAgAiIRRQ0AIAFBoAFqIQ4gAUHQAGohGyABKAKYAiEDAkACQANAAkACQAJAIAEoApQCIgJBACACIANHG0UEQCAEQRhqIAEQ5QIgBC0AHCECIAQoAhgiB0EIRw0BIAJBAXFFDQcgASgClAIiAkUNByABKAKYAiEDCyACIANrIQIgESASayEDIAEpAwBCBFINASACIAMgAiADSRsiECECDAILIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAjoABCAFIAc2AgAMBgsgGkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBFmpB6JLPACkAADcAACAHQRBqQeKSzwApAAA3AAAgB0EIakHaks8AKQAANwAAIAdB0pLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiABIBogAyACEIwQIAQoAiAhByAEKAIcIRAgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAQNgIEIAUgBjYCAAwGCyAHIBByRQRAIARBGGpBL0EAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0NIAQoAiAiB0G4kM8AQS/8CgAAIAVBLzYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyACIAdHBEAgByECDAELIAEtAJwCQQFHDQAgAyAQTQ0CIAEtAEwgAUEAOgBMIBBqIRALIAIhBwJAIBspAwBCBVENACAZRQRAIARBGGpBHkEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0EIAQoAiAiB0EWakGGk88AKQAANwAAIAdBEGpBgJPPACkAADcAACAHQQhqQfiSzwApAAA3AAAgB0Hwks8AKQAANwAAIAVBHjYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwGCyAEQRhqIBsgGSACEMUDIAQoAiAhAyAEKAIcIQcgBCgCGCIGQQhHBEAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAM2AgggBSAHNgIEIAUgBjYCAAwGCyACIANGDQAgBEEYakHeAEEAQQFBARCgGCAEKAIcIQIgBCgCGEEBRg0MIAQoAiAiB0H0kc8AQd4A/AoAACAFQd4ANgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAULIAQgBzYCACAEQRhqIQYjAEGQAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkAgDikDAEIGfSIcQgFYBEAgHKdBAUYEQEHU1M0AQQtB4NTNABDLJAALIA4oAlBFBEAgA0EwakEiQQBBAUEBEKAYIAMoAjQhCSADKAIwQQFGDQIgAygCOCIIQfDVzQBBIvwKAAAgBkEiNgIMIAYgCDYCCCAGIAk2AgQgBkEANgIADAsLIA4oAkghCCADIA5B0ABqIgkQ8y0iDDYCICADIA5B2ABqIg02AnggDCANELgIRQ0CIAkQ9S0NAyAIIAcgByAISxshDCAOQQhqIRMCQAJ/AkACQCAJEPQtQYCAAkkEQAJAIAooAgBBgICAgHhHBEAgCigCCEEBRg0BDAQLIAooAhAgCigCFCgCCEEBa0F4cWogCSgCACIIIAkoAgQiDygCCEEBa0F4cWpHBEAgCigCDA0EIAggCCgCACIWQQFqNgIAIBZBAEgNAyAKQRBqIhYoAgAiFyAXKAIAIhdBAWs2AgAgF0EBRgRAIBYQuyMLIAogDzYCFCAKIAg2AhALIApBBGoMBAsgCSgCACIIIAgoAgAiD0EBajYCACAPQQBIDQEgCSgCBCEPIAoQzScgCiAPNgIUIAogCDYCECAKQgI3AgggCkKAgICACDcCACAKQQRqDAMLQeDGzQBBO0Gcx80AEJ8pCwALQQALIggEQCAIIAgoAggiCSAMahCFLSAIKAIIIg0gCUkNBiADQTBqIBMgCCgCBCAJQQF0aiANIAlrELwLIAMoAjQhDSADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDTYCBCAGIAw2AgAMDAsgA0EwaiAKEJQLIAMoAjQhDyADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgDzYCBCAGIAg2AgAMDAsgA0EgaiAMQYDVzQAQmRUgA0EwaiATIAMoAiQgAygCKBC8CyADKAI0IQgCQCADKAIwIgxBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAw2AgAMAQsgAyAJEPMtIgw2AiwgAyANNgJ4IAwgDRC4CEUNByADQTBqIg0gCRDDLSADQRhqIA0Q3DsgAygCHCIJRQ0IIANBEGogAygCGCIMEMcbIAlBAUYNCiADKAIUIQkgAygCECETIANBCGogDEEMahDcOyAIIAMoAigiDEsNCSADQfgAaiAPIAMoAiQgCCATIAkgAygCCCADKAIMEPEPIAMoAngiCUEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAJNgIAIA0Q7yYLIANBIGoQnTwMCwsgCCAJIA1qEPQ0IAYgDTYCBCAGQQg2AgAgDiAOKAJIIA1rNgJIDAoLIANBMGogChCUCyADKAI0IQkgAygCMCIIQQhHBEAgBiADKQM4NwMIIAZBEGogA0FAaykDADcDACAGIAk2AgQgBiAINgIADAoLIAYgDiAJIAdBABDCFAwJCyAJIAMoAjhB/LvNABD9LwALIANBADYCMCADQSBqIANB+ABqIANBMGpB8NTNABCjKwALIAZCCDcDAAwGCyAJIA1B4NXNABCvOwALIANBADYCMCADQSxqIANB+ABqIANBMGpBkNXNABCjKwALQQBBAEGg1c0AEMMhAAsgCCAMQcDVzQAQsDsAC0EBQQFBsNXNABDDIQALIAYgCDYCBCAGQQg2AgAgDiAOKAJIIAhrNgJIIANBMGoQ7yYgA0EgahCdPAsgA0GQAWokACAEKAIcIQMgBCgCGCIGQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAGNgIADAULIAQgAzYCBCADIAdGBEAgASABKAKYAiACaiIDNgKYAiAHIBRqIRQgAiAVaiEVIBAgEmoiEiARSQ0BDAQLCyAEQQI2AhwgBEHkkc8ANgIYIARCAjcCJCAEQTs2AhQgBEE7NgIMIAQgBEEIajYCICAEIARBBGo2AhAgBCAENgIIIAVBBGogBEEYahCZDiAFQQA2AgAMAwtB55DPAEEyQZyRzwAQnykACwwICyAFIBU2AgwgBSAUNgIIIAUgEjYCBCAFQQg2AgALIARBMGokAAwACyALKAIQIQcgCygCFCECIAsoAgwhESALKAIIIgNBCEcEQCAAIAspAxg3AxAgACACNgIMIAAgBzYCCCAAIBE2AgQgACADNgIADAULIAIgB00NAyAYKAIAIgRBgYCAgHhHDQIgC0EIakE9QQBBAUEBEKAYIAsoAgwhASALKAIIQQFGDQEgCygCECICQcSHzQBBPfwKAAAgAEE9NgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAQLQbSHzQAQsjsACyABIAsoAhBB1P3MABD9LwALIAEoAvACIQMgCyAYQQRBDCAEQYCAgIB4RhtqEIY9IAsoAgAhBCALKAIEIQUCQCAKKAIAQYCAgIB4RwRAIAogAyAHIAIgBCAFEM0HDAELIApBBGoiBiACIANqEIUtIAYgAyAHIAIgBCAFEPwJCwsgACARNgIEIABBCDYCACABIAEoAvQCIBFqNgL0AiABIAEoAvACIAJqNgLwAgsgC0EgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC7UWAhd/AX4jAEEgayILJAACQAJAAkACQAJAIAEpAwBCBVIEQCALQQhqIQUgAUG4AmoiFUEAIAEoArgCQYGAgIB4RxshFiABQeACakEAIAEoAuACQYCAgIB4RxshFyABQaACaiEPIwBBMGsiBCQAAkACQAJAIAIiEEUNACABQaABaiENIAFB0ABqIRggASgCmAIhAwJAAkADQAJAAkACQCABKAKUAiICQQAgAiADRxtFBEAgBEEYaiABENICIAQtABwhAiAEKAIYIgdBCEcNASACQQFxRQ0HIAEoApQCIgJFDQcgASgCmAIhAwsgAiADayECIBAgEWshAyABKQMAQgRSDQEgAiADIAIgA0kbIg4hAgwCCyAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAI6AAQgBSAHNgIADAYLIBdFBEAgBEEYakEeQQBBAUEBEKAYIAQoAhwhAiAEKAIYQQFGDQ0gBCgCICIHQRZqQeiSzwApAAA3AAAgB0EQakHiks8AKQAANwAAIAdBCGpB2pLPACkAADcAACAHQdKSzwApAAA3AAAgBUEeNgIMIAUgBzYCCCAFIAI2AgQgBUEANgIADAYLIARBGGogASAXIAMgAhCMECAEKAIgIQcgBCgCHCEOIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgDjYCBCAFIAY2AgAMBgsgByAOckUEQCAEQRhqQS9BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDSAEKAIgIgdBuJDPAEEv/AoAACAFQS82AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgAiAHRwRAIAchAgwBCyABLQCcAkEBRw0AIAMgDk0NAiABLQBMIAFBADoATCAOaiEOCyACIQcCQCAYKQMAQgVRDQAgFkUEQCAEQRhqQR5BAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNBCAEKAIgIgdBFmpBhpPPACkAADcAACAHQRBqQYCTzwApAAA3AAAgB0EIakH4ks8AKQAANwAAIAdB8JLPACkAADcAACAFQR42AgwgBSAHNgIIIAUgAjYCBCAFQQA2AgAMBgsgBEEYaiAYIBYgAhDFAyAEKAIgIQMgBCgCHCEHIAQoAhgiBkEIRwRAIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSADNgIIIAUgBzYCBCAFIAY2AgAMBgsgAiADRg0AIARBGGpB3gBBAEEBQQEQoBggBCgCHCECIAQoAhhBAUYNDCAEKAIgIgdB9JHPAEHeAPwKAAAgBUHeADYCDCAFIAc2AgggBSACNgIEIAVBADYCAAwFCyAEIAc2AgAgBEEYaiEGIwBBkAFrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAIA0pAwBCBn0iGkIBWARAIBqnQQFGBEBB1NTNAEELQeDUzQAQyyQACyANKAJQRQRAIANBMGpBIkEAQQFBARCgGCADKAI0IQggAygCMEEBRg0CIAMoAjgiCUHw1c0AQSL8CgAAIAZBIjYCDCAGIAk2AgggBiAINgIEIAZBADYCAAwLCyANKAJIIQggAyANQdAAaiIJEPMtIgw2AiAgAyANQdgAaiIKNgJ4IAwgChC4CEUNAiAJEPUtDQMgCCAHIAcgCEsbIQwgDUEIaiESAkAgDyAJENQTIggEQAJAIAgoAggiCSAMaiIKIAlNBEAgCCAKNgIIDAELIAggDBCLHyAIKAIIIQoLIAkgCksNBiADQTBqIBIgCCgCBCAJQQN0aiAKIAlrENsKIAMoAjQhCiADKAIwIgxBCEYNASAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCjYCBCAGIAw2AgAMDAsgA0EwaiAPEJMLIAMoAjQhGSADKAIwIghBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgGTYCBCAGIAg2AgAMDAsgA0EgaiAMQYDVzQAQthUgA0EwaiASIAMoAiQgAygCKBDbCiADKAI0IQgCQCADKAIwIgxBCEcEQCAGIAMpAzg3AwggBkEQaiADQUBrKQMANwMAIAYgCDYCBCAGIAw2AgAMAQsgAyAJEPMtIgw2AiwgAyAKNgJ4IAwgChC4CEUNByADQTBqIgogCRDDLSADQRhqIAoQ3DsgAygCHCIJRQ0IIANBEGogAygCGCIMEMcbIAlBAUYNCiADKAIUIQkgAygCECESIANBCGogDEEMahDcOyAIIAMoAigiDEsNCSADQfgAaiAZIAMoAiQgCCASIAkgAygCCCADKAIMEPAPIAMoAngiCUEIRg0LIAYgAykCfDcCBCAGQRRqIANBjAFqKAIANgIAIAZBDGogA0GEAWopAgA3AgAgBiAJNgIAIAoQ7yYLIANBIGoQ4zwMCwsgCSAKaiIJIAgoAghNBEAgCCAJNgIICyAGIAo2AgQgBkEINgIAIA0gDSgCSCAKazYCSAwKCyADQTBqIA8QkwsgAygCNCEIIAMoAjAiCUEIRwRAIAYgAykDODcDCCAGQRBqIANBQGspAwA3AwAgBiAINgIEIAYgCTYCAAwKCyAGIA0gCCAHQQAQwhQMCQsgCCADKAI4Qfy7zQAQ/S8ACyADQQA2AjAgA0EgaiADQfgAaiADQTBqQfDUzQAQoysACyAGQgg3AwAMBgsgCSAKQeDVzQAQrzsACyADQQA2AjAgA0EsaiADQfgAaiADQTBqQZDVzQAQoysAC0EAQQBBoNXNABDDIQALIAggDEHA1c0AELA7AAtBAUEBQbDVzQAQwyEACyAGIAg2AgQgBkEINgIAIA0gDSgCSCAIazYCSCADQTBqEO8mIANBIGoQ4zwLIANBkAFqJAAgBCgCHCEDIAQoAhgiBkEIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBjYCAAwFCyAEIAM2AgQgAyAHRgRAIAEgASgCmAIgAmoiAzYCmAIgByATaiETIAIgFGohFCAOIBFqIhEgEEkNAQwECwsgBEECNgIcIARB5JHPADYCGCAEQgI3AiQgBEE7NgIUIARBOzYCDCAEIARBCGo2AiAgBCAEQQRqNgIQIAQgBDYCCCAFQQRqIARBGGoQmQ4gBUEANgIADAMLQeeQzwBBMkGckc8AEJ8pAAsMCAsgBSAUNgIMIAUgEzYCCCAFIBE2AgQgBUEINgIACyAEQTBqJAAMAAsgCygCECEHIAsoAhQhAiALKAIMIRAgCygCCCIDQQhHBEAgACALKQMYNwMQIAAgAjYCDCAAIAc2AgggACAQNgIEIAAgAzYCAAwFCyACIAdNDQMgFSgCACIEQYGAgIB4Rw0CIAtBCGpBPUEAQQFBARCgGCALKAIMIQEgCygCCEEBRg0BIAsoAhAiAkHEh80AQT38CgAAIABBPTYCDCAAIAI2AgggACABNgIEIABBADYCAAwEC0G0h80AELI7AAsgASALKAIQQdT9zAAQ/S8ACyABKALwAiEDIAsgFUEEQQwgBEGAgICAeEYbahCGPSALKAIAIQQgCygCBCEFAkAgDygCAEGAgICAeEcEQCAPIAMgByACIAQgBRDNBwwBCyAPQQRqIQYCQCACIANqIg0gDygCDCIOTQRAIA8gDTYCDAwBCyAGIA0gDmsQix8LIAYgAyAHIAIgBCAFEMgJCwsgACAQNgIEIABBCDYCACABIAEoAvQCIBBqNgL0AiABIAEoAvACIAJqNgLwAgsgC0EgaiQADwsgAiAEKAIgQfSOzwAQ/S8AC5sDAgJ/An4jAEHwAGsiAiQAIAAoAgQoAhAgAUEDdGopAwAhBCACIAAoAgAiAygCACkDACIFNwMoIAIgBDcDIAJAAkACQAJAAkAgBVBFBEAgBEKAgICAgICAgIB/UiAFQn9Scg0CIAJBAjYCTCACQZiQ/wA2AkggAkICNwJUIAJBhgw2AmwgAkGGDDYCZCACIAJB4ABqNgJQIAIgAkEoajYCaCACIAJBIGo2AmAgAkE4aiACQcgAahCZDiACQRRqIAJBPGopAgA3AgAgAkEcaiACQcQAaigCADYCACACQYiAgIB4NgI0IAIgAikCNDcCDAwBCyACQYeAgIB4NgIMCyACQQE2AgggAkEIakEEchCIEQwBCyAEIAV/IgQgAygCBC0AABDFKUUNACAAKAIIIAFBA3RqIAQ3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB8ABqJAAPCyAAIANBiIv/ABDDIQAL1AIBBn8gACgCECIFQQFqIgZBA3YgBkEHcUEAR2oiAiAAKAIMIgNLBEAgAiADayEEIAAoAgQiByACSQRAIAAgB0EBdCIDIAIQzSoiByADIAdLGxDoGSAAKAIMIQMLIAQEQCAAKAIIIANqQQAgBPwLAAsgACACNgIMCyAAIAY2AhAgAQRAIAAoAgggBUEDdmoiASABLQAAQQEgBUEHcXRyOgAACyAAKAIUBEAgACgCJCIDQQFqIgVBA3YgBUEHcUEAR2oiASAAKAIgIgJLBEAgASACayEGIAAoAhgiBCABSQRAIABBFGogBEEBdCICIAEQzSoiBCACIARLGxDoGSAAKAIgIQILIAYEQCAAKAIcIAJqQQAgBvwLAAsgACABNgIgCyAAIAU2AiQgACgCHCADQQN2aiIAIAAtAABBASADQQdxdHI6AAAPCyAAIAAoAihBAWo2AigL1wIBBX9BEkEAIABBsLgETxsiAiACQQlyIgEgAEELdCICIAFBAnRBrJGKAWooAgBBC3RJGyIBIAFBBWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAmoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBIAFBAWoiASABQQJ0QayRigFqKAIAQQt0IAJLGyIBQQJ0QayRigFqKAIAQQt0IgQgAkYgAiAES2ogAWoiBEECdEGskYoBaiIFKAIAQRV2IQJBiQchAQJAIARBI00EQCAFKAIEQRV2IQEgBEUNAQsgBUEEaygCAEH///8AcSEDCwJAIAEgAkF/c2pFDQAgACADayEDIAFBAWshAUEAIQADQCAAIAJBxMWJAWotAABqIgAgA0sNASABIAJBAWoiAkcNAAsLIAJBAXELiwMBA38jAEEQayIDJAAgACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqEJcVCyAAKALEASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHEAWoQ+CMLIAMgAEH4AGoiASAAKAKEARD4GCABEOk7IABBqAFqEIYwIABBtAFqEI4wAkAgACkDAEIEUQ0AIAAoAmQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB5ABqEJcVCwJAIAAoAmgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHoAGoQ2x4LIAAQ/RsgAEHYAGoQni8gACgCbCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQewAahCBLAsCQAJAAkBBASAAKAKIASIBQf////8HaiABQYCAgIB4TRtBAWsOAgABAgsgAEGIAWoQ9x8MAQsgACgCjAEhASAAKAKQASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAkUNACABIAIgACgCCBD4OgsgA0EQaiQAC8wCAQl/IAIgAUEEdEEQayIEaiEHIAAgBGohBiAAIAFBAXYiCkEEdGoiBEEQayEFIAMoAgAhAwNAIAIgACAEIAQgACADKAIAKAIAEQIAIghBAE4iCxsiCSkAADcAACACQQhqIAlBCGopAAA3AAAgByAGIAUgBiAFIAMoAgAoAgARAgAiCUEAThsiDCkAADcAACAHQQhqIAxBCGopAAA3AAAgACALQQR0aiEAIAQgCEEbdkEQcWohBCAFIAlBH3UiCEEEdGohBSAGIAhBf3NBBHRqIQYgB0EQayEHIAJBEGohAiAKQQFrIgoNAAsgBUEQaiEDIAFBAXEEfyACIAAgBCAAIANJIgEbIgUpAAA3AAAgAkEIaiAFQQhqKQAANwAAIAQgACADT0EEdGohBCAAIAFBBHRqBSAACyADRyAEIAZBEGpHckUEQA8LEOQrAAuVBAIHfwJ+IwBBEGsiByQAAkACQAJAIAQgAyAEaiICTQRAIAIgACgCBCIFSw0BIAAoAgAgA0EEdGohAyABKAIMIgIgBEEEdCIFaiIIIAEoAgQiBksEQCABIAZBAXQiAiAIENwqIgYgAiAGSxsQ6BkgASgCBCEGIAEoAgwhAgsgAyAFaiEJIABBCGohCCAERSACQRBqIAZLcg0CIAVBEGshBCAIKAIAIQogASgCCCELA0AgCiADKQMIIgynaq0gDEKAgICAcIOEIAwgAykDACIMp0ENTxshDSADQRBqIQMgAiALaiIAIAw3AAAgACANNwAIIAJBEGohACACQSBqIAZLDQQgBCAEQRBrIQQgACECDQALDAMLIAMgAkGUkYcBELE7AAsgAiAFQZSRhwEQsDsACyACIQALIAEgADYCDCAHIAg2AgwgByAJNgIIIAcgAzYCBCAHQQRqIgIoAgAiACACKAIEIgNHBEAgAyAAa0EEdiEDIAIoAggoAgAhAgNAIAIgACkDCCIMp2qtIAxCgICAgHCDhCAMIAApAwAiDKdBDU8bIQ0gASgCDCIEQRBqIgUgASgCBCIGSwR/IAEgBkEBdCIEIAUQ2yoiBSAEIAVLGxDoGSABKAIMBSAECyABKAIIaiIEIA03AAggBCAMNwAAIAEgASgCDEEQajYCDCAAQRBqIQAgA0EBayIDDQALCyAHQRBqJAAL0QIBBH8CQAJAIAIgASgCFCIFTw0AIAJBAWohAwJAIAEoAhAiBiACQQF0ai4AACIBQQBOBEAgAUHAgAFJDQEgAUHA/wFPBEAgAyAFTw0EIAJBAmoiAiAFTw0EIAYgAkEBdGovAAAgBiADQQF0ai8AAEEQdHIhAUEDIQQMBAsgAyAFTw0CIAYgA0EBdGovAAAgAUHA/wFxQcCAAWtBwP8DcUEKdHIhAUEDIQQMAwsCQCABQf//AXEiAUGAgAFJDQACQCABQf//AUYEQCADIAVJDQEMBQsgAyAFTw0DIAYgA0EBdGovAAAgAUEQdHJBgICAgARrIQEMAQsgAkECaiICIAVPDQMgBiACQQF0ai8AACAGIANBAXRqLwAAQRB0ciEBC0ECIQQMAgsgAUHA/wNxQQZ2QQFrQf//A3EhAUEDIQQMAQsLIAAgATYCBCAAIAQ2AgAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAAAz2BFIAZDAAAAT11FckUEQCAAKAIIIAFBAnRqIAaoNgIADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAAA32BFIAZDAAAAX11FckUEQCAAKAIIIAFBA3RqIAauNwMADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4AICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAX11FckUEQCAAKAIIIAFBA3RqIAavNwMADAELIAAoAhAiAiACKAIAQQFqNgIAIAVBCGogACgCFBCGPSABQQN2IgAgBSgCDCICTw0BIAUoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAFQRBqJAAPCyAAIAJBiIv/ABDDIQAL4QICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAR11FckUEQCAAKAIIIAFBAXRqIAb8ATsBAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC+ACAgR/AX0jAEEQayIFJAACQAJAAn8gACgCBCgCECABQQF0ai8BACIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSECIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IQMgA0GAgID8B3IgAkUNARogAyACQQ10ckGAgID+B3IMAQsgBEEQdCEEIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAEciADDQAaIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAEQYCAgNgDciACQRd0a3ILviIGQwAAgL9eRSAGQwAAgE9dRXJFBEAgACgCCCABQQJ0aiAGqTYCAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC/0CAgR+A38jAEEwayIGJABCgICAgICAgICAfyEDAkACQCAGQRBqAn4CQAJAIAAoAgQoAhAgAUEDdGopAwAiBEKAgICAgICAgIB/UiAAKAIAIggoAgAiBygCACkDACICQn9SckUEQEIAIQIMAQsgAlANAyAEIAQgAn8iAyACfn1CACACQn9SGyECIARCAFkNAQsgAyACIAcoAggpAwBXrX0MAQsgAyACIAcoAgQpAwBZrXwLIgIgAkI/hxCyLgJAIAYpAxAiAiAGKQMYIgMgBikDICIEIAYpAygiBSAIKAIELQAAENwdBEAgACgCCCABQQV0aiIAIAU3AxggACAENwMQIAAgAzcDCCAAIAI3AwAMAQsgACgCECIHIAcoAgBBAWo2AgAgBkEIaiAAKAIUEIY9IAFBA3YiACAGKAIMIgdPDQIgBigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAZBMGokAA8LQbyP/wAQ4isACyAAIAdBiIv/ABDDIQAL4QICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAAEAx15FIAZDAAAAR11FckUEQCAAKAIIIAFBAXRqIAb8ADsBAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakG43YABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQbDbgAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAv8DQIWfwR+IwBBIGsiCyQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBSACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAFNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBU0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBUkEQAJAAkAgB0EBaiIGIAUgBSAGSRsiBkEPTwRAIAZB/////wFLDQFBfyAGQQN0QQduQQFrZ3ZBAWohBgwCC0EEQQhBECAGQQhJGyAGQQRJGyEGDAELEN0nIAQoAiQhBiAEKAIgIgVBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAYQ+xQgBCgCaCEGIAQoAmQhBSAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBjYCWCAEIAU2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIGBEAgBCgCGEH/ASAG/AsACyAEKAJYIQYgBCgCVCEFIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAGNgJIIAQgBTYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhDCAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAFIAwgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAkgDGohCSAMQQhqIQwgByAFIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBXEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igw6AAAgFyAJQQhrIAVxaiAMOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBTYCTCAEIAYgBWs2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpBsN6AARDuCQtBgYCAgHghBQwBCxDdJyAEKAIMIQYgBCgCCCEFCyATIAY2AgQgEyAFNgIAIARB8ABqJAALIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQUDQAJAIAQgBWopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAGcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAZxIQ8LQQEgGiAbQgGGg1ANAhogCiAFIA9qLAAAQQBOBH8gBSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrNQIAIRogCEGQgICAeDYCGCAKEIgRIAtBCGoiAkEANgIAIAIgGjcDCCAIQUBrJABBASEDAn8gCygCCEEBRgRAIAspAxghGiALKAIMIQEgACALKQMQNwMIIAAgATYCBEEQDAELIAspAxAhGgJAIAEoAjwEQCABKAJMIghBAWoiBEEDdiAEQQdxQQBHaiICIAEoAkgiA0sEQCACIANrIQYgASgCQCIFIAJJBEAgAUE8aiAFQQF0IgMgAhDPKiIFIAMgBUsbEOgZIAEoAkghAwsgBgRAIAEoAkQgA2pBACAG/AsACyABIAI2AkgLIAEgBDYCTCABKAJEIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCzKAsgASgCNCACQQN0aiAaNwMAIAEgAkEBajYCOEEAIQNBCAsgAGogGjcDACAAIAM2AgAgC0EgaiQAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHw2YABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejggAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAv8DQIWfwR+IwBBIGsiCyQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBSACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAFNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBU0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBUkEQAJAAkAgB0EBaiIGIAUgBSAGSRsiBkEPTwRAIAZB/////wFLDQFBfyAGQQN0QQduQQFrZ3ZBAWohBgwCC0EEQQhBECAGQQhJGyAGQQRJGyEGDAELEN0nIAQoAiQhBiAEKAIgIgVBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAYQ+xQgBCgCaCEGIAQoAmQhBSAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBjYCWCAEIAU2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIGBEAgBCgCGEH/ASAG/AsACyAEKAJYIQYgBCgCVCEFIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAGNgJIIAQgBTYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhDCAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAFIAwgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAkgDGohCSAMQQhqIQwgByAFIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBXEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igw6AAAgFyAJQQhrIAVxaiAMOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBTYCTCAEIAYgBWs2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB+NiAARDuCQtBgYCAgHghBQwBCxDdJyAEKAIMIQYgBCgCCCEFCyATIAY2AgQgEyAFNgIAIARB8ABqJAALIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQUDQAJAIAQgBWopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAGcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAZxIQ8LQQEgGiAbQgGGg1ANAhogCiAFIA9qLAAAQQBOBH8gBSkDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrNQIAIRogCEGQgICAeDYCGCAKEIgRIAtBCGoiAkEANgIAIAIgGjcDCCAIQUBrJABBASEDAn8gCygCCEEBRgRAIAspAxghGiALKAIMIQEgACALKQMQNwMIIAAgATYCBEEQDAELIAspAxAhGgJAIAEoAjwEQCABKAJMIghBAWoiBEEDdiAEQQdxQQBHaiICIAEoAkgiA0sEQCACIANrIQYgASgCQCIFIAJJBEAgAUE8aiAFQQF0IgMgAhDPKiIFIAMgBUsbEOgZIAEoAkghAwsgBgRAIAEoAkQgA2pBACAG/AsACyABIAI2AkgLIAEgBDYCTCABKAJEIAhBA3ZqIgIgAi0AAEEBIAhBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCzKAsgASgCNCACQQN0aiAaNwMAIAEgAkEBajYCOEEAIQNBCAsgAGogGjcDACAAIAM2AgAgC0EgaiQAC/wNAhZ/BH4jAEEgayILJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIFIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAU2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIFTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAFSQRAAkACQCAHQQFqIgYgBSAFIAZJGyIGQQ9PBEAgBkH/////AUsNAUF/IAZBA3RBB25BAWtndkEBaiEGDAILQQRBCEEQIAZBCEkbIAZBBEkbIQYMAQsQ3ScgBCgCJCEGIAQoAiAiBUGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBhD7FCAEKAJoIQYgBCgCZCEFIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAGNgJYIAQgBTYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgYEQCAEKAIYQf8BIAb8CwALIAQoAlghBiAEKAJUIQUgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAY2AkggBCAFNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACEMIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAUgDCAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCEMA0AgCSAMaiEJIAxBCGohDCAHIAUgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAFcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiDDoAACAXIAlBCGsgBXFqIAw6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIFNgJMIAQgBiAFazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGA2IABEO4JC0GBgICAeCEFDAELEN0nIAQoAgwhBiAEKAIIIQULIBMgBjYCBCATIAU2AgAgBEHwAGokAAsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBQNAAkAgBCAFaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAZxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0CGiAKIAUgD2osAABBAE4EfyAFKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAZxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGs1AgAhGiAIQZCAgIB4NgIYIAoQiBEgC0EIaiICQQA2AgAgAiAaNwMIIAhBQGskAEEBIQMCfyALKAIIQQFGBEAgCykDGCEaIAsoAgwhASAAIAspAxA3AwggACABNgIEQRAMAQsgCykDECEaAkAgASgCPARAIAEoAkwiCEEBaiIEQQN2IARBB3FBAEdqIgIgASgCSCIDSwRAIAIgA2shBiABKAJAIgUgAkkEQCABQTxqIAVBAXQiAyACEM8qIgUgAyAFSxsQ6BkgASgCSCEDCyAGBEAgASgCRCADakEAIAb8CwALIAEgAjYCSAsgASAENgJMIAEoAkQgCEEDdmoiAiACLQAAQQEgCEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABELMoCyABKAI0IAJBA3RqIBo3AwAgASACQQFqNgI4QQAhA0EICyAAaiAaNwMAIAAgAzYCACALQSBqJAAL/A0CFn8EfiMAQSBrIgskACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgUgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBTYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgVNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAVJBEACQAJAIAdBAWoiBiAFIAUgBkkbIgZBD08EQCAGQf////8BSw0BQX8gBkEDdEEHbkEBa2d2QQFqIQYMAgtBBEEIQRAgBkEISRsgBkEESRshBgwBCxDdJyAEKAIkIQYgBCgCICIFQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAGEPsUIAQoAmghBiAEKAJkIQUgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAY2AlggBCAFNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBgRAIAQoAhhB/wEgBvwLAAsgBCgCWCEGIAQoAlQhBSAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBjYCSCAEIAU2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQwgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBSAMIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQwDQCAJIAxqIQkgDEEIaiEMIAcgBSAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAVxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiIMOgAAIBcgCUEIayAFcWogDDoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgU2AkwgBCAGIAVrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQcjbgAEQ7gkLQYGAgIB4IQUMAQsQ3ScgBCgCDCEGIAQoAgghBQsgEyAGNgIEIBMgBTYCACAEQfAAaiQACyABKAIEIgYgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEFA0ACQCAEIAVqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBnEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQIaIAogBSAPaiwAAEEATgR/IAUpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEazUCACEaIAhBkICAgHg2AhggChCIESALQQhqIgJBADYCACACIBo3AwggCEFAayQAQQEhAwJ/IAsoAghBAUYEQCALKQMYIRogCygCDCEBIAAgCykDEDcDCCAAIAE2AgRBEAwBCyALKQMQIRoCQCABKAI8BEAgASgCTCIIQQFqIgRBA3YgBEEHcUEAR2oiAiABKAJIIgNLBEAgAiADayEGIAEoAkAiBSACSQRAIAFBPGogBUEBdCIDIAIQzyoiBSADIAVLGxDoGSABKAJIIQMLIAYEQCABKAJEIANqQQAgBvwLAAsgASACNgJICyABIAQ2AkwgASgCRCAIQQN2aiICIAItAABBASAIQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQsygLIAEoAjQgAkEDdGogGjcDACABIAJBAWo2AjhBACEDQQgLIABqIBo3AwAgACADNgIAIAtBIGokAAvEBQIIfwF+IwBBEGsiCCQAAkACQAJAAkACQAJAAkADQCABKAIIIQUCQCABKAIIIgMgASgCBCIERg0AAkAgAyAESQRAIAEoAgAiByADai0AACIGQSJGIAZB3ABGciAGQSBJcg0CIAEgA0EBaiIGNgIIIAdBAWohB0EAIAQgBmtBeHEiCWshBANAIARFDQIgAyAHaiAEQQhqIQQgA0EIaiEDKQAAIgtCf4UgC0LcuPHixYuXrtwAhUKBgoSIkKDAgAF9IAtCosSIkaLEiJEihUKBgoSIkKDAgAF9IAtCoMCAgYKEiJAgfYSEg0KAgYKEiJCgwIB/gyILUA0ACyABIAt6p0EDdiADakEHazYCCAwCCyADIARBiMaIARDDIQALIAEgBiAJajYCCAJAIAEoAggiAyABKAIEIgZPDQAgASgCACEHA0AgAyAHai0AACIEQSJGIARB3ABGciAEQSBJcg0BIAEgA0EBaiIDNgIIIAMgBkcNAAsLCyABKAIIIgMgASgCBCIERg0DIAMgBE8NBCABKAIAIgQgA2oiBi0AACIHQdwARwRAIAdBIkYNAyABIANBAWo2AgggCEEQNgIEIAAgASAIQQRqEJspDAgLIAMgBUkNASACIAQgBWogBhC/JiABIANBAWo2AgggAUEBIAIQwQoiA0UNAAsgAEECNgIAIAAgAzYCBAwGCyAFIANByMaIARCxOwALIAIoAggEQCADIAVJDQMgAiAEIAVqIAYQvyYgASADQQFqNgIIIABBATYCACAAIAIpAgQ3AgQMBQsgAyAFSQ0DIABBADYCACAAIAMgBWs2AgggASADQQFqNgIIIAAgBCAFajYCBAwECyAIQQQ2AgQgACABIAhBBGoQmykMAwsgAyAEQZjGiAEQwyEACyAFIANBqMaIARCxOwALIAUgA0G4xogBELE7AAsgCEEQaiQAC+YEAQR/IwBBIGsiBSQAAkACQCACQX9HBEACQCACQQFqIgZBAEgNAEEBIQMgBkEBEK02IgRFDQAgAgRAIAQgASAC/AoAAAsCQCACQQdNBEAgAkUNBCABLQAARQRAQQAhAwwCCyACQQFGDQQgAS0AAUUNAUECIQMgAkECRg0EIAEtAAJFDQFBAyEDIAJBA0YNBCABLQADRQ0BQQQhAyACQQRGDQQgAS0ABEUNAUEFIQMgAkEFRg0EIAEtAAVFDQFBBiEDIAJBBkYNBCABLQAGRQ0BDAQLIAVBCGpBACABIAIQnRIgBSgCCEEBcUUNAyAFKAIMIQMLIAAgAzYCDCAAIAI2AgggACAENgIEIAAgBjYCAAwDCyADIAZB2MGJARD9LwALQejBiQEQsjsACyAFIAI2AhwgBSAENgIYIAUgBjYCFEEAIQQjAEEgayIDJAAgBUEUaiIBKAIAIgYgASgCCCICRgRAAkAgAkEBaiIGQQBOBH8gAyACBH8gAyACNgIcIAMgASgCBDYCFEEBBUEACzYCGCADQQhqIAYgA0EUahCiGyADKAIIQQFHDQEgAygCECEEIAMoAgwFQQALIARB+MGJARD9LwALIAMoAgwhBCABIAY2AgAgASAENgIECyABIAJBAWoiBDYCCCABKAIEIgEgAmpBADoAAAJAIAQgBk8EQCABIQIMAQsgBEUEQEEBIQIgASAGQQEQ+DoMAQsgASAGQQEgBBCXNSICDQBBASAEEKM9AAsgBSAENgIEIAUgAjYCACADQSBqJAAgACAFKQMANwIEIABBgICAgHg2AgALIAVBIGokAAuaAgEFfwJAIAFBD3ECfwJAAkAgAC0AKAR/IAEgACgCGCICTyACQYAgTXINAUHAAAVB/AcLIAFBDnZqIgMgACgCBCICTw0DIAAoAgAiBCADQQF0ai8AACABQQl2QR9xaiIFIAJPDQMgAUEEdiIDQR9xIQEgBCAFQQF0ai4AACIGQf//A3EhBSAGQQBOBEAgAiABIAVqIgJNDQQgBCACQQF0ai8AAAwDCyACIAVB//8BcSADQRhxIAFBA3ZyaiIBTQ0DIAIgA0EHcSICIAFqQQFqIgNLDQEMAwtB7P3FAEHdAEHM/sUAEJ8pAAsgBCADQQF0ai8AACAEIAFBAXRqLwAAIAJBAXRBAmp0QYCADHFyC2oPCyAAKAIQQQFrC5oCAQV/AkAgAUEPcQJ/AkACQCAALQAsBH8gASAAKAIcIgJPIAJBgCBNcg0BQcAABUH8BwsgAUEOdmoiAyAAKAIIIgJPDQMgACgCBCIEIANBAXRqLwAAIAFBCXZBH3FqIgUgAk8NAyABQQR2IgNBH3EhASAEIAVBAXRqLgAAIgZB//8DcSEFIAZBAE4EQCACIAEgBWoiAk0NBCAEIAJBAXRqLwAADAMLIAIgBUH//wFxIANBGHEgAUEDdnJqIgFNDQMgAiADQQdxIgIgAWpBAWoiA0sNAQwDC0HgrMwAQd0AQcCtzAAQnykACyAEIANBAXRqLwAAIAQgAUEBdGovAAAgAkEBdEECanRBgIAMcXILag8LIAAoAhRBAWsL5QIBBX8jAEEQayIFJAAgAEEEIAAoAjQiAyADQQRNGzYCNCAAQTBqIQYgAkECdCEDAkBBACAAKAIwIgdrQQNxIgQgACgCCCAHa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAYgBBCNNwJAAkAgA0EEaiIEIAAoAgggACgCMGsiB00NACAEQYCAgIB4Sw0BIAQgB00NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgBiADEI03IAAoAjAhBCAFQQhqIAAQ3DsgBSAFKAIIIAUoAgwgACgCMCIGIAYgA2tByLb+ABDXJiAFKAIEQQJ2IgMgAiACIANLGyIGBEAgBSgCACEDA0AgAyAEIAEoAgBrNgAAIAFBBGohASADQQRqIQMgBEEEayEEIAZBAWsiBg0ACwsgACACEKkRIAVBEGokAA8LQdi2/gBBJUGAt/4AEJ8pAAvyAgIHfwJ+IAEpAggiCUIgiKciBEEEaiEHIAEoAgQhAyABKAIcIQUgASgCECECIAmnIQYgASgCAEEBcSEIAkACQAJAA0AgAgRAIAUEQCABKAIYIgMgASgCFCIESw0FIABCATcDACABIAVBAWs2AhwgASADQQhqNgIYIAAgAiADaikAADcDCA8LIAFBADYCEAsgAyECAkAgCEUNACABQQA2AgQgAkUNACAEIAZLDQIgASAHNgIYIAEgBjYCFCABIAI2AhAgASACIARqKAAAIgU2AhxBACEDDAELCwJ+AkAgASgCICIDBEAgASgCLCIERQ0BIAEoAigiAiABKAIkIgVLDQQgASAEQQFrNgIsIAEgAkEIajYCKCACIANqKQAAIQlCAQwCCyAAQgA3AwAPCyABQQA2AiBCAAshCiAAIAk3AwggACAKNwMADwsgBCAGQdDt/gAQrzsACyACIAVB0O3+ABCvOwALIAMgBEHQ7f4AEK87AAvyAgIGfwR+IwBBMGsiAyQAQYCAgIB4IQQCQAJAIANBEGoCfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNAyAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qC6wiCCAIQj+HELIuAkAgAykDECIIIAMpAxgiCSADKQMgIgogAykDKCILIAcoAgQtAAAQ3B0EQCAAKAIIIAFBBXRqIgAgCzcDGCAAIAo3AxAgACAJNwMIIAAgCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EwaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAvuAgEGfyMAQbABayICJAAgASgCACEEIAJBoAFqIAFBFGopAgA3AgAgAkGYAWogAUEMaikCADcCACACIAEpAgQ3ApABIAEoAiAhBSABKAIcIQEgBBDTOiEDIAQQ0zoaIAJBEGogAyABaxDEGyACIAU2AqwBIAIgATYCqAEgAiAENgKMASACKAKQASEDAkAgASAFRwRAA0AgAkEQagJ/AkAgAwRAIAEgAigCoAFPDQUgAigClAEgASACKAKcAWoiBkEDdmotAABB/wFzIAZBB3F2QQFxDQELIAIgAUEBajYCqAEgAkEIaiAEIAEQjywgAigCDCEHIAIoAggMAQsgAiABQQFqNgKoAUEACyAHELoBIAUgAUEBaiIBRw0ACwsCQCADRQ0AIAMgAygCACIBQQFrNgIAIAFBAUcNACACQZABahD7HgsgACACQRBqIgAQ3AwgABDpJSACQbABaiQADwtBrOyAAUEgQczsgAEQnykAC+4CAQZ/IwBBsAFrIgIkACABKAIAIQQgAkGgAWogAUEUaikCADcCACACQZgBaiABQQxqKQIANwIAIAIgASkCBDcCkAEgASgCICEFIAEoAhwhASAEENQ6IQMgBBDUOhogAkEQaiADIAFrEMQbIAIgBTYCrAEgAiABNgKoASACIAQ2AowBIAIoApABIQMCQCABIAVHBEADQCACQRBqAn8CQCADBEAgASACKAKgAU8NBSACKAKUASABIAIoApwBaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENAQsgAiABQQFqNgKoASACQQhqIAQgARDaKyACKAIMIQcgAigCCAwBCyACIAFBAWo2AqgBQQALIAcQugEgBSABQQFqIgFHDQALCwJAIANFDQAgAyADKAIAIgFBAWs2AgAgAUEBRw0AIAJBkAFqEPseCyAAIAJBEGoiABDcDCAAEOklIAJBsAFqJAAPC0Gs7IABQSBBzOyAARCfKQAL4gQCDH8CfiMAQTBrIgMkAAJAIAEoAgAiAiABKAIEIgdHBEAgASgCDCEGIAEoAgghBANAIAEgAkEEaiIFNgIAAkACQCACKAIARQRAIAYgBBDyJiABIARBAWo2AggNAQwCCyABIARBAWo2AggMAQsgA0EYaiICIAEoAhAgBBCJLRDsICADKQMgIQ8gAykDGCEOIAJBBEEAQQhBEBCgGCADKAIcIQUgAygCGEEBRwRAIAMoAiAiBCAOIA98NwMIIAQgDjcDACADQRRqIgpBATYCACADIAQ2AhAgAyAFNgIMIANBKGogAUEQaigCADYCACADQSBqIAFBCGopAgA3AwAgAyABKQIANwMYIANBDGohBiMAQRBrIggkAAJAIAIiASgCACIFIAEoAgQiCUYNACABKAIQIQsgASgCDCEMIAEoAgghBANAIAQhAgNAIAEgBUEEaiIHNgIAAkACQCAFKAIARQRAIAwgAhDyJiABIAJBAWoiBDYCCA0BDAILIAEgAkEBajYCCAwBCyAIIAsgAhCJLRDsICAIKQMAIg4gCCkDCHwhDyAGKAIIIgIgBigCAEYEQCAGIAJBAUEIQRAQ0CgLIAYoAgQgAkEEdGoiByAPNwMIIAcgDjcDACAGIAJBAWo2AgggBUEEaiIFIAlHDQIMAwsgAkEBaiECIAciBSAJRw0ACwsLIAhBEGokACAAQQhqIAooAgA2AgAgACADKQIMNwIADAQLIAUgAygCIEGI+sIAEP0vAAsgBEEBaiEEIAUiAiAHRw0ACwsgAEEANgIIIABCgICAgIABNwIACyADQTBqJAALvRICEX8EfiMAQYAGayIRJAACQCABQSFPBEAgA0EBayEDA0AgA0F/RgRAIwBBEGsiByQAIAEiAiABQQF2aiIEBEADQAJAAn8gAiAEQQFrIgRNBEAgBCACawwBCyAAIARBBHRqIgFBCGoiAykDACEXIAApAwAhGCAAIAEpAwA3AwAgAEEIaiIFKQMAIRYgBSAXNwMAIAMgFjcDACABIBg3AwBBAAsiA0EBdCIFQQFyIgEgAiAEIAIgBEkbIgZPDQADQCAFQQJqIgUgBkkEQCABIAAgAUEEdGopAwAgACAFQQR0aikDAFRqIQELIAAgA0EEdGoiAykDACAAIAFBBHRqIgUpAwBaDQEgAyAFQQQQ+iogASEDIAFBAXQiBUEBciIBIAZJDQALCyAEDQALCyAHQRBqJAAMAwsgACABQQN2IgdB8ABsaiEFIAAgB0EGdGohBgJ/IAFBwABPBEAgACAGIAUgByAEEJsaDAELIAAgBSAGIAApAwAiFyAGKQMAIhhUIgYgGCAFKQMAIhZUcxsgBiAWIBdWcxsLIABrIgZBBHYhBQJ/AkAgAkUNACACKQMAIAAgBmopAwBUDQAjAEEgayILJAACQCABRQRAQQAhAgwBCwJAIAEgBU0NACAAIAVBBHRqIgJBCGoiBSkDACEXIAApAwAhGCAAIAIpAwA3AwAgAEEIaiIIKQMAIRYgCCAXNwMAIAUgFjcDACACIBg3AwACfyAAQRBqIQZBACEHQQAgAUEBayINRQ0AGiAAKQMAIRcgBikDCCEZIAYpAwAhGCAGIgVBEGoiAiAFIA1BBHRqIg1BEGsiDEkEQCAFIQIDQCAGIAdBBHRqIgVBCGoiCSkDACEWIAIgBSkDADcDACACQQhqIBY3AwAgAkEQaiIKKQMAIRYgCSACQRhqIgkpAwA3AwAgBSAWNwMAIAYgByAWIBdYaiIOQQR0aiIHQQhqIg8pAwAhFiAKIAcpAwA3AwAgCSAWNwMAIAJBIGoiBSkDACEWIA8gAkEoaikDADcDACAHIBY3AwAgDiAWIBdYaiEHIAJBMGogBSECIAxJDQALIAVBEGohAgsgAiANRwRAA0AgBiAHQQR0aiIMQQhqIgkpAwAhFiAFIAwpAwA3AwAgBUEIaiAWNwMAIAIpAwAhFiAJIAJBCGopAwA3AwAgDCAWNwMAIAcgFiAXWGohByACIgVBEGoiAiANRw0ACyACQRBrIQULIAYgB0EEdGoiAikDACEWIAVBCGogAkEIaiIGKQMANwMAIAUgFjcDACAGIBk3AwAgAiAYNwMAIAcgFyAYWmoLIgIgAU8NACAAIAJBBHRqIgVBCGoiBikDACEXIAApAwAhGCAAIAUpAwA3AwAgCCkDACEWIAggFzcDACAGIBY3AwAgBSAYNwMADAELAAsgC0EgaiQAIAJBAWohBSABIAJLBEAgASAFayEBQQAhAiAAIAVBBHRqDAILIAUgAUHU7sMAEK87AAsjAEEgayIJJAACQCABRQRAQQAhBQwBCwJAIAEgBU0NACAAIAVBBHRqIgVBCGoiBikDACEXIAApAwAhGCAAIAUpAwA3AwAgAEEIaiINKQMAIRYgDSAXNwMAIAYgFjcDACAFIBg3AwACfyAAQRBqIQdBACEIQQAgAUEBayIMRQ0AGiAAKQMAIRcgBykDCCEZIAcpAwAhGCAHIgZBEGoiBSAGIAxBBHRqIgxBEGsiC0kEQCAGIQUDQCAHIAhBBHRqIgZBCGoiCikDACEWIAUgBikDADcDACAFQQhqIBY3AwAgBUEQaiIOKQMAIRYgCiAFQRhqIgopAwA3AwAgBiAWNwMAIAcgCCAWIBdUaiIPQQR0aiIIQQhqIhApAwAhFiAOIAgpAwA3AwAgCiAWNwMAIAVBIGoiBikDACEWIBAgBUEoaikDADcDACAIIBY3AwAgDyAWIBdUaiEIIAVBMGogBiEFIAtJDQALIAVBEGohBQsgBSAMRwRAA0AgByAIQQR0aiILQQhqIgopAwAhFiAGIAspAwA3AwAgBkEIaiAWNwMAIAUpAwAhFiAKIAVBCGopAwA3AwAgCyAWNwMAIAggFiAXVGohCCAFIQYgBUEQaiIFIAxHDQALIAVBEGshBgsgByAIQQR0aiIFKQMAIRYgBkEIaiAFQQhqIgcpAwA3AwAgBiAWNwMAIAcgGTcDACAFIBg3AwAgCCAXIBhWagsiBSABTw0AIAAgBUEEdGoiBkEIaiIHKQMAIRcgACkDACEYIAAgBikDADcDACANKQMAIRYgDSAXNwMAIAcgFjcDACAGIBg3AwAMAQsACyAJQSBqJAAgACAFIAIgAyAEEMgPIAEgBUF/c2ohASAAIAVBBHRqIgJBEGoLIQAgA0EBayEDIAFBIU8NAAsLIAAhBCARIQMjAEEQayILJAAgASIGQQJPBEACQAJAIAFBEGpBME0EQCABQQF2IQkgAUEPSw0BQQQhBSADIAlBBHQiB2ohAiAAIAdqIQcgAUEHSwRAIAAgAxDsEiAHIAIQ7BIMAwsgAyAEKQMANwMAIANBCGogBEEIaikDADcDACACIAcpAwA3AwAgAkEIaiAHQQhqKQMANwMAQQEhBQwCCwALIAQgAyADIAZBBHRqIgAQpy0gBCAJQQR0IgFqIAEgA2ogAEGAAWoQpy1BCCEFCyALQgI3AgQgBUEEdCEKIAVBAWohDSALIAk2AgwgBiAJayEQIAtBCGohEkEAIQADQCAAIBAgCSASIABBAnRqKAIAIgAbIhMgBUsEQCAEIABBBHQiAGohFEEQIQcgACADaiIPIQggDSEAIAUhAQNAIAAhAiAPIAFBBHQiAWoiACABIBRqIgEpAwAiFzcDACAAQQhqIAFBCGopAwA3AwAgAEEQaykDACAXVgRAIAApAwghGCAHIQAgCCEBAn8DQCABIApqIg4gDkEQayIVKQMANwMAIA5BCGogFUEIaikDADcDACAPIAAgCkYNARogAEEQaiEAIAFBEGshASAXIA5BIGspAwBUDQALIAEgCmoLIgAgGDcDCCAAIBc3AwALIAdBEGshByAIQRBqIQggAiACIBNJIg5qIQAgAiEBIA4NAAsLQQEhAEEBcUUNAAsgC0ECNgIAIAMgBiAEEP4PCyALQRBqJAALIBFBgAZqJAAL8QICBH8BfiMAQSBrIgIkAAJAAn4CQAJAAkAgASgCECIERQRAIAJBCGoQtB4gAigCCCIFQQRGDQEgAigCDCIEQQh2IQEMAwsgASgCDCEDIAEgBEEBazYCECABIANBAWo2AgxBAiEEAkAgAy0AACIDQQ9xIgVBAWtBAkkNACACQQhqIAUQoxIgAi0ADCEEIAIoAggiBUEERg0AIAIvAA0gAkEPai0AAEEQdHIhAQwDCyADQQR2IgNBD0cNASACQQhqIAEQyxMgAigCCEUEQCACKAIQIQMMAgsgAikDECIGQiCIpyEDIAanIQQgAigCDCIFQQRGDQEgBkIIiKchASACKQMYDAMLQQFBAEHUs84AEK87AAsgACAEOgAIIAAgAzYCBCAAQQQ2AgAMAgsgAigCECEDIAIpAhQLIQYgACABOwAFIAAgBjcCDCAAIAM2AgggACAEOgAEIAAgBTYCACAAQQdqIAFBEHY6AAALIAJBIGokAAvxAgIDfwJ+IwBBQGoiAiQAIABBEGohAwJAIAAoAhAiBARAIABBHGogACgCFCAAKAIYIAQoAhARAQAgAEIANwMgIABBKGpCADcDACADQQhqIAFBCGopAgA3AgAgAyABKQIANwIADAELIAJBEGpCADcDACACQRhqQgA3AwAgAyABKQIAIgU3AwAgA0EQakIANwMAIANBGGpCADcDACACQQhqIAFBCGopAgAiBjcDACADQQhqIAY3AwAgAiAFNwMACwJAIAMoAgAEQCACQSBqIAMQpRgCQCACKAIgQQFHDQAgAikDKCIFUA0AIAVCAYNQRQRAIAAgBadBAnRBeHE2AjgMAQsgACAFQgGIPgI0IAJBMGogAyAALQA8IgFBA3YgAUEHcUEAR2oQwRwgAikDMCEFIAAgAikDODcDCCAAIAU3AwAgBadFDQILIAJBQGskAA8LQZTEzgBBGEGsxM4AEMskAAtBvMTOAEEuQezEzgAQnykAC+MCAQR/IwBBMGsiAyQAIANBDGogASACEJMOIAMoAhAhBAJAIAMoAgwiBUGKgICAeEcEQCAAIAMpAhQ3AgggAEEgaiADQSxqKAIANgIAIABBGGogA0EkaikCADcCACAAQRBqIANBHGopAgA3AgAgACAENgIEIAAgBTYCAAwBCwJAAkBBf0F/IAJBBGoiBSACIAVLGyICQX8gBEEEdCAEQf////8ASxsiBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC+sCAgR/AX4jAEFAaiIDJAAgASgCCCgCACEFIANBNGoiBCABKAIMKAIQIAJBA3RqKQMAEP0VAkACQAJAAkACQCADKAI0IgZFDQAgAyADKQI4NwIgIANBGGogA0EkaigCADYCACADIAY2AhwgAyADKQIcNwMQIAQgBSgCABCWNiADKAI0DQAgBCADQRxqIAMoAjgQ+BEgAygCNEUNBCADQTBqIANBPGooAgA2AgAgAyADKQI0NwMoIAMgA0EoahCZGiADKAIAQQFxDQELIANBKkEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkGIk/8AQSr8CgAAIABCKjcCDCAAQYKAgIB4NgIAIAAgAa0gAq1CIIaENwIEDAELIAMpAwghByAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0FAayQADwsgASADKAIIQYSR/wAQ/S8AC0GIiv8AQSpBtIr/ABDLJAAL6wICBH8BfiMAQUBqIgMkACABKAIIKAIAIQUgA0E0aiIEIAEoAgwoAhAgAkEDdGopAwAQ/RcCQAJAAkACQAJAIAMoAjQiBkUNACADIAMpAjg3AiAgA0EYaiADQSRqKAIANgIAIAMgBjYCHCADIAMpAhw3AxAgBCAFKAIAEJY2IAMoAjQNACAEIANBHGogAygCOBD4ESADKAI0RQ0EIANBMGogA0E8aigCADYCACADIAMpAjQ3AyggAyADQShqEMQnIAMoAgBBAXENAQsgA0EqQQBBAUEBEKAYIAMoAgQhASADKAIAQQFGDQIgAygCCCICQYiT/wBBKvwKAAAgAEIqNwIMIABBgoCAgHg2AgAgACABrSACrUIghoQ3AgQMAQsgAykDCCEHIABBk4CAgHg2AgAgASgCACACQQN0aiAHNwMACyADQUBrJAAPCyABIAMoAghBhJH/ABD9LwALQYiK/wBBKkG0iv8AEMskAAvrAgIEfwF+IwBBQGoiAyQAIAEoAggoAgAhBSADQTRqIgQgASgCDCgCECACQQN0aikDABDWFQJAAkACQAJAAkAgAygCNCIGRQ0AIAMgAykCODcCICADQRhqIANBJGooAgA2AgAgAyAGNgIcIAMgAykCHDcDECAEIAUoAgAQljYgAygCNA0AIAQgA0EcaiADKAI4EPgRIAMoAjRFDQQgA0EwaiADQTxqKAIANgIAIAMgAykCNDcDKCADIANBKGoQ4BkgAygCAEEBcQ0BCyADQSpBAEEBQQEQoBggAygCBCEBIAMoAgBBAUYNAiADKAIIIgJBiJP/AEEq/AoAACAAQio3AgwgAEGCgICAeDYCACAAIAGtIAKtQiCGhDcCBAwBCyADKQMIIQcgAEGTgICAeDYCACABKAIAIAJBA3RqIAc3AwALIANBQGskAA8LIAEgAygCCEGEkf8AEP0vAAtBiIr/AEEqQbSK/wAQyyQAC+sCAgR/AX4jAEFAaiIDJAAgASgCCCgCACEFIANBNGoiBCABKAIMKAIQIAJBA3RqKQMAEIEVAkACQAJAAkACQCADKAI0IgZFDQAgAyADKQI4NwIgIANBGGogA0EkaigCADYCACADIAY2AhwgAyADKQIcNwMQIAQgBSgCABCWNiADKAI0DQAgBCADQRxqIAMoAjgQ+BEgAygCNEUNBCADQTBqIANBPGooAgA2AgAgAyADKQI0NwMoIAMgA0EoahCZJCADKAIAQQFxDQELIANBKkEAQQFBARCgGCADKAIEIQEgAygCAEEBRg0CIAMoAggiAkGIk/8AQSr8CgAAIABCKjcCDCAAQYKAgIB4NgIAIAAgAa0gAq1CIIaENwIEDAELIAMpAwghByAAQZOAgIB4NgIAIAEoAgAgAkEDdGogBzcDAAsgA0FAayQADwsgASADKAIIQYSR/wAQ/S8AC0GIiv8AQSpBtIr/ABDLJAAL3gICBH8BfSMAQRBrIgUkAAJAAkACfyAAKAIEKAIQIAFBAXRqLwEAIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0BGiADIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyIAMNABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3Rrcgu+IgZDAACAv15FIAZDAACAQ11FckUEQCAAKAIIIAFqIAb8AToAAAwBCyAAKAIQIgIgAigCAEEBajYCACAFQQhqIAAoAhQQhj0gAUEDdiIAIAUoAgwiAk8NASAFKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgBUEQaiQADwsgACACQYiL/wAQwyEAC94CAgR/AX0jAEEQayIFJAACQAJAAn8gACgCBCgCECABQQF0ai8BACIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSECIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IQMgA0GAgID8B3IgAkUNARogAyACQQ10ckGAgID+B3IMAQsgBEEQdCEEIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAEciADDQAaIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAEQYCAgNgDciACQRd0a3ILviIGQwAAAcNeRSAGQwAAAENdRXJFBEAgACgCCCABaiAG/AA6AAAMAQsgACgCECICIAIoAgBBAWo2AgAgBUEIaiAAKAIUEIY9IAFBA3YiACAFKAIMIgJPDQEgBSgCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAVBEGokAA8LIAAgAkGIi/8AEMMhAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpByN6AARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC4YOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHA2YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAoQiBEgDEEMaiIDQZOAgIB4NgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5UOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHY2YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQQBOBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakH424ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQbjXgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB//8BTQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI7AQQgCEFAayQAIAwvARAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpARI3AQYgAEEMaiAMQRhqKQEANwEAIAAgAzsBBCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQrSgLIAEoAjQgAkEBdGogAzsBACAAIAM7AQQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB6NqAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wNNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGI3YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlQ4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQcDfgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJBAE4EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQZjYgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB//8DTQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI7AQQgCEFAayQAIAwvARAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpARI3AQYgAEEMaiAMQRhqKQEANwEAIAAgAzsBBCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQrSgLIAEoAjQgAkEBdGogAzsBACAAIAM7AQQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuXDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB+N6AARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH//wNNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjsBBCAIQUBrJAAgDC8BECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkBEjcBBiAAQQxqIAxBGGopAQA3AQAgACADOwEEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCtKAsgASgCNCACQQF0aiADOwEAIAAgAzsBBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC4YOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHg2IABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAoQiBEgDEEMaiIDQZOAgIB4NgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5UOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGQ34ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQQBOBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjYCBCAIQUBrJAAgDCgCECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkCFDcCCCAAQRBqIAxBHGooAgA2AgAgACADNgIEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCdKAsgASgCNCACQQJ0aiADNgIAIAAgAzYCBCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5cOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGA4YABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf//A00EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOwEEIAhBQGskACAMLwEQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQESNwEGIABBDGogDEEYaikBADcBACAAIAM7AQQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEK0oCyABKAI0IAJBAXRqIAM7AQAgACADOwEEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALlQ4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQajcgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJBAE4EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALhg4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejdgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggChCIESAMQQxqIgNBk4CAgHg2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALhg4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQZDZgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggChCIESAMQQxqIgNBk4CAgHg2AgAgAyACNgIEIAhBQGskACAMKAIQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQIUNwIIIABBEGogDEEcaigCADYCACAAIAM2AgQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEJ0oCyABKAI0IAJBAnRqIAM2AgAgACADNgIEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALxwIBCn8CQAJAIAEEQCAAKAIAIgMoAjwgAygCQCIFKAIIQQFrQXhxakEIaiIGIAUoAhwRBAAtAAAiBEECayIDQf8BcUElT0L/j9CG4AMgA62Ip0EBcUVyDQEgA0H/AXFBAnRBnLeDAWooAgAhBwwCC0EAQQBB2LODARDDIQALQc4WIQcgBEENa0H/AXFBB0kNAEEADwsgACABQQJ0aiEIIAYgBSgCJBEEACEEQQEhAUEBIQMDQAJAAn8gCQRAIAAiASABIAhHDQEaDAILIAEgCCAAa0ECdk8NASAAIAFBAnRqCyIBQQRqIQAgASgCACIBKAI8IAEoAkAiCigCCEEBa0F4cWpBCGoiCyAKKAIkEQQAIARqIQRBASEJIANBAXFBACEBQQAhA0UNASAGIAUgCyAKIAcRCgAhAwwBCwsgA0F/cyACIARNcQvHAgEKfwJAAkAgAQRAIAAoAgAiAygCPCADKAJAIgUoAghBAWtBeHFqQQhqIgYgBSgCHBEEAC0AACIEQQJrIgNB/wFxQSVPQv+P0IbgAyADrYinQQFxRXINASADQf8BcUECdEHYuoMBaigCACEHDAILQQBBAEHYs4MBEMMhAAtBzhYhByAEQQ1rQf8BcUEHSQ0AQQAPCyAAIAFBAnRqIQggBiAFKAIkEQQAIQRBASEBQQEhAwNAAkACfyAJBEAgACIBIAEgCEcNARoMAgsgASAIIABrQQJ2Tw0BIAAgAUECdGoLIgFBBGohACABKAIAIgEoAjwgASgCQCIKKAIIQQFrQXhxakEIaiILIAooAiQRBAAgBGohBEEBIQkgA0EBcUEAIQFBACEDRQ0BIAYgBSALIAogBxEKACEDDAELCyADQX9zIAIgBE1xC8cCAQp/AkACQCABBEAgACgCACIDKAI8IAMoAkAiBSgCCEEBa0F4cWpBCGoiBiAFKAIcEQQALQAAIgRBAmsiA0H/AXFBJU9C/4/QhuADIAOtiKdBAXFFcg0BIANB/wFxQQJ0Qey7gwFqKAIAIQcMAgtBAEEAQdizgwEQwyEAC0HOFiEHIARBDWtB/wFxQQdJDQBBAA8LIAAgAUECdGohCCAGIAUoAiQRBAAhBEEBIQFBASEDA0ACQAJ/IAkEQCAAIgEgASAIRw0BGgwCCyABIAggAGtBAnZPDQEgACABQQJ0agsiAUEEaiEAIAEoAgAiASgCPCABKAJAIgooAghBAWtBeHFqQQhqIgsgCigCJBEEACAEaiEEQQEhCSADQQFxQQAhAUEAIQNFDQEgBiAFIAsgCiAHEQoAIQMMAQsLIANBf3MgAiAETXEL9gIBAn8jAEEwayIFJAAgBSACNgIEIAUgATYCAAJAAkAgAygCCEUEQCAFQRhqQZUBQQBBAUEBEKAYIAUoAhwhASAFKAIYQQFGDQIgBSgCICICQYzyhQFBlQH8CgAAIABBlQE2AhAgACACNgIMIAAgATYCCCAAQoCAgIDYgYCAgH83AgACQCAEKAIAIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAQQ+x4LIAMQwycgA0EEQQgQ4B4gBSgCACIAIAAoAgAiAEEBazYCACAAQQFHDQEgBRCFHQwBCyADKAIEIgYoAgAgBigCBCIGKAIIQQFrQXhxakEIaiAGKAIkEQQAIQYgBUEQaiADQQhqKAIANgIAIAUgAykCADcDCCAFQShqIARBEGopAgA3AwAgBUEgaiAEQQhqKQIANwMAIAUgBCkCADcDGCAAIAEgAiAFQQhqIAVBGGogBhDPAwsgBUEwaiQADwsgASAFKAIgQaTuhQEQ/S8AC8ICAgF/AX4jAEHwAGsiByQAIAcgAjYCDCAHIAE2AgggByAENgIUIAcgAzYCECAHIABB/wFxQQJ0IgBBjO6KAWooAgA2AhwgByAAQYDuigFqKAIANgIYAkAgBSgCAARAIAdBMGogBUEQaikCADcDACAHQShqIAVBCGopAgA3AwAgByAFKQIANwMgIAdBBDYCXCAHQfzwiQE2AlggB0IENwJkIAdCgICAgNDjAyIIIAdBEGqthDcDUCAHIAggB0EIaq2ENwNIIAcgB0Egaq1CgICAgPDjA4Q3A0AMAQsgB0EDNgJcIAdByPCJATYCWCAHQgM3AmQgB0KAgICA0OMDIgggB0EQaq2ENwNIIAcgCCAHQQhqrYQ3A0ALIAcgB0EYaq1CgICAgODjA4Q3AzggByAHQThqNgJgIAdB2ABqIAYQ7ywAC8cDAwJ+BXwCfwJAAkACfyAAvSIBQoCAgICAgIAIWQRAIAFC//////////f/AFYNA0GBeCEJIAFCIIgiAkKAgMD/A1IEQCACpwwCC0GAgMD/AyABpw0BGkQAAAAAAAAAAA8LIABEAAAAAAAAAABhBEBEAAAAAAAA8L8gACAAoqMPCyABQgBTDQFBy3chCSAARAAAAAAAAFBDor0iAUIgiKcLIQggAUL/////D4MgCEHiviVqIghB//8/cUGewZr/A2qtQiCGhL9EAAAAAAAA8L+gIgAgACAARAAAAAAAAOA/oqIiA6G9QoCAgIBwg78iBEQAACBlRxX3P6IiBSAIQRR2IAlqtyIGoCIHIAUgBiAHoaAgACAEoSADoSAAIABEAAAAAAAAAECgoyIAIAMgACAAoiIDIAOiIgAgACAARJ/GeNAJmsM/okSveI4dxXHMP6CiRAT6l5mZmdk/oKIgAyAAIAAgAEREUj7fEvHCP6JE3gPLlmRGxz+gokRZkyKUJEnSP6CiRJNVVVVVVeU/oKKgoKKgIgBEAAAgZUcV9z+iIAAgBKBEAKLvLvwF5z2ioKCgDwsgACAAoUQAAAAAAAAAAKMhAAsgAAvGAgICfwF+IwBBQGoiAiQAIAJBEGogAUEMaiIBEI0UAkACQAJAIAJBBGoCfyACLQAQQQRGBEAgAigCFAwBCyACKQMQIgRC/wGDQgRSDQEgBEIgiKcLQZTGzgAQzhggAkEoaiABKAIAIAIoAgggAigCDBCbISACLQAoQQRGBEAgAkE4aiACQQxqKAIANgIAIAIgAikCBDcDMAwCCyACIAIpAyg3AzAgAkEQaiACQTBqIgEQ0AkgAigCECACQThqIAJBDGooAgA2AgAgAiACKQIENwMwQQRGDQEgACACKQIQNwIAIABBEGogAkEgaigCADYCACAAQQhqIAJBGGopAgA3AgAgARDeOwwCCyACIAQ3AxAgACACQRBqENAJDAELIAAgAikDMDcCBCAAQQQ2AgAgAEEMaiACQThqKAIANgIACyACQUBrJAAL7QMCBn8DfiMAQUBqIgIkACACQRBqIAFBDGoiARD/EwJAAkACQCACQQRqAn8gAi0AEEEERgRAIAIoAhQMAQsgAikDECIIQv8Bg0IEUg0BIAhCIIinC0GUxs4AEM4YIAJBKGohBSACKAIIIQYgASgCACIDKAIEIgStIQgCQAJAIAIoAgwiASAEQv////8PIAMpAwgiCSAJQv////8PWhunayIHQQAgBCAHTxtNBEAgAygCACAJIAggCCAJVhunaiEEAkAgAUEBRwRAIAFFDQEgBiAEIAH8CgAADAELIAYgBC0AADoAAAsgBUEEOgAADAELIAVBqKHQACkDACIKNwIAIApC/wGDQgRSDQELIAkgAa18IQgLIAMgCDcDCCACLQAoQQRGBEAgAkE4aiACQQxqKAIANgIAIAIgAikCBDcDMAwCCyACIAIpAyg3AzAgAkEQaiACQTBqIgEQ0AkgAigCECACQThqIAJBDGooAgA2AgAgAiACKQIENwMwQQRGDQEgACACKQIQNwIAIABBEGogAkEgaigCADYCACAAQQhqIAJBGGopAgA3AgAgARDeOwwCCyACIAg3AxAgACACQRBqENAJDAELIAAgAikDMDcCBCAAQQQ2AgAgAEEMaiACQThqKAIANgIACyACQUBrJAALjQMBAn8jAEFAaiIDJAAgAyACOgAPIAMgATYCCCAAAn8CQCACQf8BcSICQQpPBEAgA0ECNgIsIANBiJCFATYCKCADQgI3AjQgA0G7BzYCHCADQbsHNgIUIANB5I+FATYCECADIANBEGo2AjAgAyADQQ9qNgIYIABBBGogA0EoahCZDgwBCyACQQJ0IgRB/I2FAWoiAigCACABSARAIANBAzYCFCADQcyPhQE2AhAgA0IDNwIcIANBnAM2AjwgAyACNgI4IANBuwc2AjQgA0GcAzYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgA0EIajYCKCAAQQRqIANBEGoQmQ4MAQtBk4CAgHggASAEQaSOhQFqIgQoAgBODQEaIANBAzYCFCADQYCPhQE2AhAgA0IDNwIcIANBnAM2AjwgAyAENgI4IANBuwc2AjQgA0GcAzYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgA0EIajYCKCAAQQRqIANBEGoQmQ4LQY2AgIB4CzYCACADQUBrJAAL+gIBBn8jAEGgAmsiAiQAIAEoAhwhAyACQeABaiABQQhqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQN2QQFrNgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQIANwLYASACQdwAaiIEIAJBuAFqIgUgAUEgahDCGQJAQQxBBBCtNiIDBEAgAyABKQIUNwIAIANBCGogAUEcaigCADYCACACQQE2ApwCIAIgAzYCmAIgAkEBNgKUAiAFIAQgAkGUAmoQlilBxABBBBCtNiIDRQ0BIAMgASgCDCIGIAEoAhAiBygCCEEBa0F4cWpBCGogBygCFBEAACACQQE2AmQgAiADNgJgIAJBATYCXCACIAUgBBD8IiAAIAIQzRwgBiAGKAIAIgBBAWs2AgAgAEEBRgRAIAFBDGoQuyMLIAJBoAJqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAv6AgEGfyMAQaACayICJAAgASgCHCEDIAJB4AFqIAFBCGooAgA2AgAgAkEAOwGQAiACQQA2AowCIAJBADYC9AEgAkEANgLoASACIANBAnZBAWs2AuQBIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACIAEpAgA3AtgBIAJB3ABqIgQgAkG4AWoiBSABQSBqEMIZAkBBDEEEEK02IgMEQCADIAEpAhQ3AgAgA0EIaiABQRxqKAIANgIAIAJBATYCnAIgAiADNgKYAiACQQE2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABKAIMIgYgASgCECIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCAGIAYoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBDBCjPQALQQRBxAAQoz0AC/ICAQF/AkAgAgRAIAEtAABBME0NASAFQQI7AQACQAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf//A3EiA0sNASAFQQA7AQwgBSACNgIIIAUgAyACazYCECAEDQJBAiEBDAULIAUgAjYCICAFIAE2AhwgBUECOwEYIAVBADsBDCAFQQI2AgggBUHF64kBNgIEIAVBACAGayIDNgIQQQMhASACIARPDQQgBCACayICIANNDQQgAiAGaiEEDAMLIAVBAjsBGCAFQQE2AhQgBUHE64kBNgIQIAVBAjsBDCAFIAM2AgggBSACIANrIgI2AiAgBSABIANqNgIcIAIgBEkNAUEDIQEMAwsgBUEBNgIgIAVBxOuJATYCHCAFQQI7ARgMAQsgBCACayEECyAFIAQ2AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQcDoiQFBIUHQ6okBEJ8pAAtB4OqJAUEfQYDriQEQnykAC9sCAQN/IwBBMGsiCCQAAkACQCADRQ0AIANBAnQhCgJAA0ACQCAFIAIoAgAiCUEBaiIDSwRAIAUgCUsNASAJIAVBgMrQABDDIQALIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBAnRqKAIAIgMgBCAJQQJ0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQnxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkEEaiECIApBBGsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvbAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQJ0IQoCQANAAkAgBSACKAIAIglBAWoiA0sEQCAFIAlLDQEgCSAFQYDK0AAQwyEACyAIQQE2AhwgCEHQytAANgIYIAhCATcCJCAIQTs2AhBBACEDIAggBUEBayIBQQAgASAFTRs2AhQgCCAIQQxqNgIgIAggCEEUajYCDCAAQQRqIAhBGGoQmQ4MBAsgBCADQQN0aigCACIDIAQgCUEDdGooAgAiCU8EQCADIAdLDQIgCEEYaiABIAYgCWogAyAJa0EAEJcUIAgoAhgiA0EIRwRAIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIADAULIAJBBGohAiAKQQRrIgpFDQMMAQsLIAkgA0GQytAAELE7AAsgAyAHQZDK0AAQsDsAC0EIIQMLIAAgAzYCACAIQTBqJAAL2wIBA38jAEEwayIIJAACQAJAIANFDQAgA0EDdCEKAkADQAJAIAUgAigCACIJQQFqIgNLBEAgBSAJSw0BIAkgBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0ECdGooAgAiAyAEIAlBAnRqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCfFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQhqIQIgCkEIayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC9sCAQN/IwBBMGsiCCQAAkACQCADRQ0AIANBAXQhCgJAA0ACQCAFIAIuAQAiCUEBaiIDSwRAIAUgCUsNASAJIAVBgMrQABDDIQALIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBAnRqKAIAIgMgBCAJQQJ0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQnxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkECaiECIApBAmsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvbAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQN0IQoCQANAAkAgBSACKAIAIglBAWoiA0sEQCAFIAlLDQEgCSAFQYDK0AAQwyEACyAIQQE2AhwgCEHQytAANgIYIAhCATcCJCAIQTs2AhBBACEDIAggBUEBayIBQQAgASAFTRs2AhQgCCAIQQxqNgIgIAggCEEUajYCDCAAQQRqIAhBGGoQmQ4MBAsgBCADQQN0aigCACIDIAQgCUEDdGooAgAiCU8EQCADIAdLDQIgCEEYaiABIAYgCWogAyAJa0EAEJcUIAgoAhgiA0EIRwRAIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIADAULIAJBCGohAiAKQQhrIgpFDQMMAQsLIAkgA0GQytAAELE7AAsgAyAHQZDK0AAQsDsAC0EIIQMLIAAgAzYCACAIQTBqJAAL2wIBA38jAEEwayIIJAACQAJAIANFDQAgA0EBdCEKAkADQAJAIAUgAi4BACIJQQFqIgNLBEAgBSAJSw0BIAkgBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0EDdGooAgAiAyAEIAlBA3RqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCXFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQJqIQIgCkECayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC94CAQR/IwBB0ABrIgMkACADIAI3AwACQCABKAIABEAgAEEEaiABIAKnIAEoAhBrEOoUIABBCDYCAAwBCyABKAIIIQUCQAJAAkACQCABKAIMIgEOAgIBAAsDQCAEIAFBAXYiBiAEaiIEIAIgBSAEQRRsajUCAFQbIQQgASAGayIBQQFLDQALCyACIAUgBEEUbGoiATUCAFINACADQQhqIAFBEGogASgCCCABKAIMIAEoAgQoAgARBQAgAygCCA0BCyADQQE2AjQgA0HU5dAANgIwIANCATcCPCADQTw2AkwgAyADQcgAajYCOCADIAM2AkggA0EYakEEciADQTBqEJkOIANBADYCGCAAIAMpAxg3AwAgAEEIaiADQSBqKQMANwMAIABBEGogA0EoaikDADcDAAwBCyAAIAMpAgg3AgQgAEEINgIAIABBDGogA0EQaikCADcCAAsgA0HQAGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB4NuAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AU0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKkZCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQfDcgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5MOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCDGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakGI4IABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIMaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELQVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf8ATQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI6AAQgCEFAayQAIAwtABAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpABE3AAUgAEEMaiAMQRhqKQAANwAAIAAgAzoABCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQoygLIAEoAjQgAmogAzoAACAAIAM6AAQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQghogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpB0NqAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCCGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC1FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AE0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKMoCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIMaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQejXgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQgxogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtBUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC5MOAhZ/BH4jAEEgayIMJAAjAEFAaiIIJAAgCCADNgIEIAggAjYCACAIQRhqIQogAUEQaiIGIAIgAxDNAiEcIAFB5ABqIRAjAEEQayIOJAAgASgCCEUEQCAOQQhqIRMjAEHwAGsiBCQAIAQgEDYCLCAEIAY2AiggASgCDCEHIAQgBEEoajYCMAJAIAcgB0EBaiIGTQRAAkAgASgCBCIHIAdBAWpBA3ZBB2wgB0EISRsiB0EBdiAGSQRAAkACQCAHQQFqIgUgBiAFIAZLGyIFQQ9PBEAgBUH/////AUsNAUF/IAVBA3RBB25BAWtndkEBaiEFDAILQQRBCEEQIAVBCEkbIAVBBEkbIQUMAQsQ3ScgBCgCJCEFIAQoAiAiBkGBgICAeEcNBAsgBEHgAGogAUEQaiIJQQQgBRD7FCAEKAJoIQUgBCgCZCEGIAQoAmAiB0UNAyAEIAQoAmw2AlwgBCAFNgJYIAQgBjYCVCAEIAc2AlAgBEEYaiAEQdAAahDBNCAEKAIcIgUEQCAEKAIYQf8BIAX8CwALIAQoAlghBSAEKAJUIQYgBCgCUCIHRQ0DIAQgBCgCXDYCTCAEIAU2AkggBCAGNgJEIAQgBzYCQCAEQoSAgICAATcCOCAEIAk2AjQgBEFAayEWIAQgASgCDCIUBH8gB0EIaiEXIAEoAgAiFSkDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAVQQhqIhUpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAjAiCSgCACELIARBEGogCSgCBCABKAIAIBp6p0EDdiANakECdCIYa0EEaygCABCCGiAHIAYgCyAEKAIQIAQoAhQQzQKnIhlxIglqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCSALaiEJIAtBCGohCyAHIAYgCXEiCWopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAHIBt6p0EDdiAJaiAGcSIJaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEJCyAHIAlqIBlBGXYiCzoAACAXIAlBCGsgBnFqIAs6AAAgByAJQQJ0a0EEayABKAIAIBhrQQRrKAAANgAAIBRBAWsiFA0ACyABKAIMBUEACyIGNgJMIAQgBSAGazYCSCABIBZBBBD6KiAEQTRqEPUnDAELIAEgBEEwakHY34ABEO4JC0GBgICAeCEGDAELEN0nIAQoAgwhBSAEKAIIIQYLIBMgBTYCBCATIAY2AgAgBEHwAGokAAsgASgCBCIFIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAIKAIEIQcgCCgCACEJIAEoAgAhBgNAAkAgBCAGaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAKAn4CQANAIBpQDQEgDiAQIAEoAgAgGnqnQQN2IARqIAVxIg1BAnRrQQRrKAIAEIIaIBpCAX0gGoMhGiAJIAcgDigCACAOKAIEEJ87RQ0ACyAKIBw3AwggCiABKAIAQQAgDWtBAnRqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAiAaeqdBA3YgBGogBXEhDwtBASAaIBtCAYaDUA0CGiAKIAYgD2osAABBAE4EfyAGKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAogHDcDCEIBCzcDACAKIAE2AhQgDkEQaiQADAILQQALIREgBCASQQhqIhJqIAVxIQQMAQsLIAggAzYCPCAIIAI2AjggCCAQNgI0IAhBCGogCiAIQTRqELUVIAgoAhBBBGsoAgAhAiAIQZCAgIB4NgIYIAxBDGoiAyACQf8ATQR/IAoQiBFBk4CAgHgFQZCAgIB4CzYCACADIAI6AAQgCEFAayQAIAwtABAhAwJAIAwoAgwiAkGTgICAeEcEQCAAIAwpABE3AAUgAEEMaiAMQRhqKQAANwAAIAAgAzoABCAAIAI2AgAMAQsCQCABKAI8BEAgASgCTCIEQQFqIgVBA3YgBUEHcUEAR2oiAiABKAJIIghLBEAgAiAIayEGIAEoAkAiByACSQRAIAFBPGogB0EBdCIIIAIQzyoiByAHIAhJGxDoGSABKAJIIQgLIAYEQCABKAJEIAhqQQAgBvwLAAsgASACNgJICyABIAU2AkwgASgCRCAEQQN2aiICIAItAABBASAEQQdxdHI6AAAMAQsgASABKAJQQQFqNgJQCyABKAI4IgIgASgCMEYEQCABQTBqQZzigAEQoygLIAEoAjQgAmogAzoAACAAIAM6AAQgAEGTgICAeDYCACABIAJBAWo2AjgLIAxBIGokAAuTDgIWfwR+IwBBIGsiDCQAIwBBQGoiCCQAIAggAzYCBCAIIAI2AgAgCEEYaiEKIAFBEGoiBiACIAMQzQIhHCABQeQAaiEQIwBBEGsiDiQAIAEoAghFBEAgDkEIaiETIwBB8ABrIgQkACAEIBA2AiwgBCAGNgIoIAEoAgwhByAEIARBKGo2AjACQCAHIAdBAWoiBk0EQAJAIAEoAgQiByAHQQFqQQN2QQdsIAdBCEkbIgdBAXYgBkkEQAJAAkAgB0EBaiIFIAYgBSAGSxsiBUEPTwRAIAVB/////wFLDQFBfyAFQQN0QQduQQFrZ3ZBAWohBQwCC0EEQQhBECAFQQhJGyAFQQRJGyEFDAELEN0nIAQoAiQhBSAEKAIgIgZBgYCAgHhHDQQLIARB4ABqIAFBEGoiCUEEIAUQ+xQgBCgCaCEFIAQoAmQhBiAEKAJgIgdFDQMgBCAEKAJsNgJcIAQgBTYCWCAEIAY2AlQgBCAHNgJQIARBGGogBEHQAGoQwTQgBCgCHCIFBEAgBCgCGEH/ASAF/AsACyAEKAJYIQUgBCgCVCEGIAQoAlAiB0UNAyAEIAQoAlw2AkwgBCAFNgJIIAQgBjYCRCAEIAc2AkAgBEKEgICAgAE3AjggBCAJNgI0IARBQGshFiAEIAEoAgwiFAR/IAdBCGohFyABKAIAIhUpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFUEIaiIVKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIwIgkoAgAhCyAEQRBqIAkoAgQgASgCACAaeqdBA3YgDWpBAnQiGGtBBGsoAgAQgxogByAGIAsgBCgCECAEKAIUEM0CpyIZcSIJaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAkgC2ohCSALQQhqIQsgByAGIAlxIglqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogByAbeqdBA3YgCWogBnEiCWosAABBAE4EQCAHKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgByAJaiAZQRl2Igs6AAAgFyAJQQhrIAZxaiALOgAAIAcgCUECdGtBBGsgASgCACAYa0EEaygAADYAACAUQQFrIhQNAAsgASgCDAVBAAsiBjYCTCAEIAUgBms2AkggASAWQQQQ+iogBEE0ahD1JwwBCyABIARBMGpBuOCAARDuCQtBgYCAgHghBgwBCxDdJyAEKAIMIQUgBCgCCCEGCyATIAU2AgQgEyAGNgIAIARB8ABqJAALIAEoAgQiBSAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gCCgCBCEHIAgoAgAhCSABKAIAIQYDQAJAIAQgBmopAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkAgCgJ+AkADQCAaUA0BIA4gECABKAIAIBp6p0EDdiAEaiAFcSINQQJ0a0EEaygCABCDGiAaQgF9IBqDIRogCSAHIA4oAgAgDigCBBCfO0UNAAsgCiAcNwMIIAogASgCAEEAIA1rQQJ0ajYCEEIADAELIBtCgIGChIiQoMCAf4MhGiARRQRAIBpQDQIgGnqnQQN2IARqIAVxIQ8LQQEgGiAbQgGGg1ANAhogCiAGIA9qLAAAQQBOBH8gBikDAEKAgYKEiJCgwIB/g3qnQQN2BSAPCzYCECAKIBw3AwhCAQs3AwAgCiABNgIUIA5BEGokAAwCC0EACyERIAQgEkEIaiISaiAFcSEEDAELCyAIIAM2AjwgCCACNgI4IAggEDYCNCAIQQhqIAogCEE0ahC0FSAIKAIQQQRrKAIAIQIgCEGQgICAeDYCGCAMQQxqIgMgAkH/AE0EfyAKEIgRQZOAgIB4BUGQgICAeAs2AgAgAyACOgAEIAhBQGskACAMLQAQIQMCQCAMKAIMIgJBk4CAgHhHBEAgACAMKQARNwAFIABBDGogDEEYaikAADcAACAAIAM6AAQgACACNgIADAELAkAgASgCPARAIAEoAkwiBEEBaiIFQQN2IAVBB3FBAEdqIgIgASgCSCIISwRAIAIgCGshBiABKAJAIgcgAkkEQCABQTxqIAdBAXQiCCACEM8qIgcgByAISRsQ6BkgASgCSCEICyAGBEAgASgCRCAIakEAIAb8CwALIAEgAjYCSAsgASAFNgJMIAEoAkQgBEEDdmoiAiACLQAAQQEgBEEHcXRyOgAADAELIAEgASgCUEEBajYCUAsgASgCOCICIAEoAjBGBEAgAUEwakGc4oABEKMoCyABKAI0IAJqIAM6AAAgACADOgAEIABBk4CAgHg2AgAgASACQQFqNgI4CyAMQSBqJAALkw4CFn8EfiMAQSBrIgwkACMAQUBqIggkACAIIAM2AgQgCCACNgIAIAhBGGohCiABQRBqIgYgAiADEM0CIRwgAUHkAGohECMAQRBrIg4kACABKAIIRQRAIA5BCGohEyMAQfAAayIEJAAgBCAQNgIsIAQgBjYCKCABKAIMIQcgBCAEQShqNgIwAkAgByAHQQFqIgZNBEACQCABKAIEIgcgB0EBakEDdkEHbCAHQQhJGyIHQQF2IAZJBEACQAJAIAdBAWoiBSAGIAUgBksbIgVBD08EQCAFQf////8BSw0BQX8gBUEDdEEHbkEBa2d2QQFqIQUMAgtBBEEIQRAgBUEISRsgBUEESRshBQwBCxDdJyAEKAIkIQUgBCgCICIGQYGAgIB4Rw0ECyAEQeAAaiABQRBqIglBBCAFEPsUIAQoAmghBSAEKAJkIQYgBCgCYCIHRQ0DIAQgBCgCbDYCXCAEIAU2AlggBCAGNgJUIAQgBzYCUCAEQRhqIARB0ABqEME0IAQoAhwiBQRAIAQoAhhB/wEgBfwLAAsgBCgCWCEFIAQoAlQhBiAEKAJQIgdFDQMgBCAEKAJcNgJMIAQgBTYCSCAEIAY2AkQgBCAHNgJAIARChICAgIABNwI4IAQgCTYCNCAEQUBrIRYgBCABKAIMIhQEfyAHQQhqIRcgASgCACIVKQMAQn+FQoCBgoSIkKDAgH+DIRoDQCAaUARAA0AgDUEIaiENIBVBCGoiFSkDAEKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBCgCMCIJKAIAIQsgBEEQaiAJKAIEIAEoAgAgGnqnQQN2IA1qQQJ0IhhrQQRrKAIAEIIaIAcgBiALIAQoAhAgBCgCFBDNAqciGXEiCWopAABCgIGChIiQoMCAf4MiG1AEQEEIIQsDQCAJIAtqIQkgC0EIaiELIAcgBiAJcSIJaikAAEKAgYKEiJCgwIB/gyIbUA0ACwsgGkIBfSAagyEaIAcgG3qnQQN2IAlqIAZxIglqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQkLIAcgCWogGUEZdiILOgAAIBcgCUEIayAGcWogCzoAACAHIAlBAnRrQQRrIAEoAgAgGGtBBGsoAAA2AAAgFEEBayIUDQALIAEoAgwFQQALIgY2AkwgBCAFIAZrNgJIIAEgFkEEEPoqIARBNGoQ9ScMAQsgASAEQTBqQYDbgAEQ7gkLQYGAgIB4IQYMAQsQ3ScgBCgCDCEFIAQoAgghBgsgEyAFNgIEIBMgBjYCACAEQfAAaiQACyABKAIEIgUgHKdxIQQgHEIZiEL/AINCgYKEiJCgwIABfiEdIAgoAgQhByAIKAIAIQkgASgCACEGA0ACQCAEIAZqKQAAIhsgHYUiGkJ/hSAaQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIRoCfwJAIAoCfgJAA0AgGlANASAOIBAgASgCACAaeqdBA3YgBGogBXEiDUECdGtBBGsoAgAQghogGkIBfSAagyEaIAkgByAOKAIAIA4oAgQQnztFDQALIAogHDcDCCAKIAEoAgBBACANa0ECdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0CIBp6p0EDdiAEaiAFcSEPC0EBIBogG0IBhoNQDQIaIAogBiAPaiwAAEEATgR/IAYpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCiAcNwMIQgELNwMAIAogATYCFCAOQRBqJAAMAgtBAAshESAEIBJBCGoiEmogBXEhBAwBCwsgCCADNgI8IAggAjYCOCAIIBA2AjQgCEEIaiAKIAhBNGoQtRUgCCgCEEEEaygCACECIAhBkICAgHg2AhggDEEMaiIDIAJB/wFNBH8gChCIEUGTgICAeAVBkICAgHgLNgIAIAMgAjoABCAIQUBrJAAgDC0AECEDAkAgDCgCDCICQZOAgIB4RwRAIAAgDCkAETcABSAAQQxqIAxBGGopAAA3AAAgACADOgAEIAAgAjYCAAwBCwJAIAEoAjwEQCABKAJMIgRBAWoiBUEDdiAFQQdxQQBHaiICIAEoAkgiCEsEQCACIAhrIQYgASgCQCIHIAJJBEAgAUE8aiAHQQF0IgggAhDPKiIHIAcgCEkbEOgZIAEoAkghCAsgBgRAIAEoAkQgCGpBACAG/AsACyABIAI2AkgLIAEgBTYCTCABKAJEIARBA3ZqIgIgAi0AAEEBIARBB3F0cjoAAAwBCyABIAEoAlBBAWo2AlALIAEoAjgiAiABKAIwRgRAIAFBMGpBnOKAARCpGQsgASgCNCACaiADOgAAIAAgAzoABCAAQZOAgIB4NgIAIAEgAkEBajYCOAsgDEEgaiQAC9cCAQZ/IwBBgARrIgUkACAFQQxqIAEgASACQQN0akHIy4MBEMEbIAVBGGoiAiAFKAIQIgEgASAFKAIUQcQAbGpByMuDARDAGyAFQSRqIAJBACAEEMAsIAMgBEEDdGohCCADKAIAIQZBASEEIAMoAgQiByEBA0ACQAJAIARFBEAgAyAIRw0BDAILIAQgCCADa0EDdk8NASADIARBA3RqIQMLIAFBAWohASADQQhqIQkgAygCBCECQQAhBCAGIAMoAgAiCkYEQCAJIQMgASACRg0CCyAFQSRqIAYgByABENgbIAohBiACIQcgCSEDIAIhAQwBCwsgBUEkaiIDIAYgByABQQFqENgbIAVBtAJqIgIgA0HMAfwKAAAgBUHwAWoiASACEOosIAUgARCgASAAIAUpAwA3AgQgAEGTgICAeDYCACAFQQxqIgAQpCwgABD1PCAFQYAEaiQAC74CAgh/BH4gACABQQR0QRBrIgNqIQYgAiADaiEFIAAgAUEBdiIIQQR0aiIDQRBrIQQDQCACIAMgACADKQMAIgsgACkDACIMVCIJGyIHKQMANwMAIAJBCGogB0EIaikDADcDACAFIAQgBiAGKQMAIg0gBCkDACIOVCIHGyIKKQMANwMAIAVBCGogCkEIaikDADcDACAFQRBrIQUgAkEQaiECIARBcEEAIAcbaiEEIAZBcEEAIA0gDlobaiEGIAAgCyAMWkEEdGohACADIAlBBHRqIQMgCEEBayIIDQALIARBEGohBCABQQFxBH8gAiAAIAMgACAESSIBGyIFKQMANwMAIAJBCGogBUEIaikDADcDACADIAAgBE9BBHRqIQMgACABQQR0agUgAAsgBEcgAyAGQRBqR3JFBEAPCxDkKwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkEDdCIFIAEoAiggASgCNCIHa00EQCAFIANBA3QiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGUiM0AEMskAAsgBSADQZSIzQAQsDsACyAFIANBlIjNABCzOwALIAIgBCgCCEHU/cwAEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQN0IgUgASgCKCABKAI0IgdrTQRAIAUgA0EDdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHs/swALwAAOwAAIAFBEGpB5P7MACkAADcAACABQQhqQdz+zAApAAA3AAAgAUHU/swAKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB5P3MAEEgQbSIzQAQyyQACyAFIANBtIjNABCwOwALIAUgA0G0iM0AELM7AAsgAiAEKAIIQdT9zAAQ/S8AC4MDAQR/IwBBEGsiBCQAAkACQAJAIAEoAiAEQAJAIAEoAjAiBSADIAMgBUsbIgZBAnQiBSABKAIoIAEoAjQiB2tNBEAgBSADQQJ0IgNLDQMgBCABQSBqIAcgBSAHahDSECAFIAQoAggiA0cNBCAEKAIEIQMgBQRAIAIgAyAF/AoAAAsgBEEMaiADIAUgBCgCACgCEBEBACAAIAY2AgQgAEEINgIAIAEgASgCNCAFajYCNCABIAEoAjAgBms2AjAMAQsgBEEaQQBBAUEBEKAYIAQoAgQhAiAEKAIAQQFGDQQgBCgCCCIBQRhqQez+zAAvAAA7AAAgAUEQakHk/swAKQAANwAAIAFBCGpB3P7MACkAADcAACABQdT+zAApAAA3AAAgAEEaNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyAEQRBqJAAPC0Hk/cwAQSBBhIjNABDLJAALIAUgA0GEiM0AELA7AAsgBSADQYSIzQAQszsACyACIAQoAghB1P3MABD9LwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkECdCIFIAEoAiggASgCNCIHa00EQCAFIANBAnQiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB7P7MAC8AADsAACABQRBqQeT+zAApAAA3AAAgAUEIakHc/swAKQAANwAAIAFB1P7MACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQeT9zABBIEGkiM0AEMskAAsgBSADQaSIzQAQsDsACyAFIANBpIjNABCzOwALIAIgBCgCCEHU/cwAEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQJ0IgUgASgCKCABKAI0IgdrTQRAIAUgA0ECdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHwqM4ALwAAOwAAIAFBEGpB6KjOACkAADcAACABQQhqQeCozgApAAA3AAAgAUHYqM4AKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB+KfOAEEgQZC0zgAQyyQACyAFIANBkLTOABCwOwALIAUgA0GQtM4AELM7AAsgAiAEKAIIQdinzgAQ/S8AC4MDAQR/IwBBEGsiBCQAAkACQAJAIAEoAiAEQAJAIAEoAjAiBSADIAMgBUsbIgZBAnQiBSABKAIoIAEoAjQiB2tNBEAgBSADQQJ0IgNLDQMgBCABQSBqIAcgBSAHahDSECAFIAQoAggiA0cNBCAEKAIEIQMgBQRAIAIgAyAF/AoAAAsgBEEMaiADIAUgBCgCACgCEBEBACAAIAY2AgQgAEEINgIAIAEgASgCNCAFajYCNCABIAEoAjAgBms2AjAMAQsgBEEaQQBBAUEBEKAYIAQoAgQhAiAEKAIAQQFGDQQgBCgCCCIBQRhqQfCozgAvAAA7AAAgAUEQakHoqM4AKQAANwAAIAFBCGpB4KjOACkAADcAACABQdiozgApAAA3AAAgAEEaNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyAEQRBqJAAPC0H4p84AQSBByLTOABDLJAALIAUgA0HItM4AELA7AAsgBSADQci0zgAQszsACyACIAQoAghB2KfOABD9LwALgwMBBH8jAEEQayIEJAACQAJAAkAgASgCIARAAkAgASgCMCIFIAMgAyAFSxsiBkEDdCIFIAEoAiggASgCNCIHa00EQCAFIANBA3QiA0sNAyAEIAFBIGogByAFIAdqENIQIAUgBCgCCCIDRw0EIAQoAgQhAyAFBEAgAiADIAX8CgAACyAEQQxqIAMgBSAEKAIAKAIQEQEAIAAgBjYCBCAAQQg2AgAgASABKAI0IAVqNgI0IAEgASgCMCAGazYCMAwBCyAEQRpBAEEBQQEQoBggBCgCBCECIAQoAgBBAUYNBCAEKAIIIgFBGGpB8KjOAC8AADsAACABQRBqQeiozgApAAA3AAAgAUEIakHgqM4AKQAANwAAIAFB2KjOACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQI2AgALIARBEGokAA8LQfinzgBBIEHYtM4AEMskAAsgBSADQdi0zgAQsDsACyAFIANB2LTOABCzOwALIAIgBCgCCEHYp84AEP0vAAuDAwEEfyMAQRBrIgQkAAJAAkACQCABKAIgBEACQCABKAIwIgUgAyADIAVLGyIGQQN0IgUgASgCKCABKAI0IgdrTQRAIAUgA0EDdCIDSw0DIAQgAUEgaiAHIAUgB2oQ0hAgBSAEKAIIIgNHDQQgBCgCBCEDIAUEQCACIAMgBfwKAAALIARBDGogAyAFIAQoAgAoAhARAQAgACAGNgIEIABBCDYCACABIAEoAjQgBWo2AjQgASABKAIwIAZrNgIwDAELIARBGkEAQQFBARCgGCAEKAIEIQIgBCgCAEEBRg0EIAQoAggiAUEYakHwqM4ALwAAOwAAIAFBEGpB6KjOACkAADcAACABQQhqQeCozgApAAA3AAAgAUHYqM4AKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgBEEQaiQADwtB+KfOAEEgQbi0zgAQyyQACyAFIANBuLTOABCwOwALIAUgA0G4tM4AELM7AAsgAiAEKAIIQdinzgAQ/S8AC9oCAwN/AXwBfiMAQbARayIGJAAgBkEQakEAQYQR/AsAIAZBo+D/+wc2ApQRAn8CQCABIAJPBEAgAkUNASAEKAIAIgEgAygCAEYgBCgCBCIHIAMoAgRGcSEIIAJBBHQhAiABrSEKIAQoAgwhAQNAAkAgAEEEaigCAEH///8PcUUNACAAQQxqLwEAQf8ATQ0AAkACQCAIRQRAIAAgAxCzICIEIAFNDQFBAAwHCyAGIABBDmovAQAiBDsBDgwBCyAEIAcgCiAGQQ5qIAZBmBFqEJYYIAYvAQ4hBAsgBkEQaiAEQf8HcRC1KSAJIARBgPgDcUEKdrigIQkLIABBEGohACACQRBrIgINAAsMAQsgBkEANgKoESAGQQE2ApwRIAZBrJfSADYCmBEgBkIENwKgESAGQZgRakG0mNIAEO8sAAsgBSAJIAZBEGoQoge7oDkDAEEBCyAGQbARaiQAC7wCAQx/IAAgAUEMbEEMayIDaiEGIAIgA2ohBSAAIAFBAXYiCEEMbGoiA0EMayEEA0AgAiADIAAgAygCACIJIAAoAgAiCkkiCxsiBykCADcCACACQQhqIAdBCGooAgA2AgAgBSAEIAYgBigCACIHIAQoAgAiDEkiDRsiDikCADcCACAFQQhqIA5BCGooAgA2AgAgBUEMayEFIAJBDGohAiAEQXRBACANG2ohBCAGQXRBACAHIAxPG2ohBiAAIAkgCk9BDGxqIQAgAyALQQxsaiEDIAhBAWsiCA0ACyAEQQxqIQQgAUEBcQR/IAIgACADIAAgBEkiARsiBSkCADcCACACQQhqIAVBCGooAgA2AgAgAyAAIARPQQxsaiEDIAAgAUEMbGoFIAALIARHIAMgBkEMakdyRQRADwsQ5CsAC9QCAgR/An4jAEEgayIEJAAgBEEIaiAAKAJIIAFBDGxqENw7IARBEGogBCgCCCACakF/IAIgA2oiAyACIANLGyACayABIAIQ8AogBCkDGCEIIAQpAxAhCSAAKAJAIgEgACgCOEYEQCAAQThqQejrgAEQsSgLIAAoAjwgAUEEdGoiAiAINwMIIAIgCTcDACAAIAFBAWo2AkACQCAAKAJcBEAgACgCbCIDQQFqIgZBA3YgBkEHcUEAR2oiASAAKAJoIgJLBEAgASACayEHIAAoAmAiBSABSQRAIABB3ABqIAVBAXQiAiABENAqIgUgAiAFSxsQ6BkgACgCaCECCyAHBEAgACgCZCACakEAIAf8CwALIAAgATYCaAsgACAGNgJsIAAoAmQgA0EDdmoiACAALQAAQQEgA0EHcXRyOgAADAELIAAgACgCcEEBajYCcAsgBEEgaiQAC/wCAgR/AX4gASACIAMQrAIhCQJ/AkACQCABKAIsIgYgCSABNQIgiKciBUsEQAJAIAEoAiggBUEEdGoiASgCAEEBRgRAIAJFIAEoAgQiBUVyDQEgBSABKAIIIAIgAxCfOw0EDAMLIAQoAggoAgAhBiAEKAIEKAIAIQcgBCgCACIEKAIIIgUgBCgCAEYEQCAEQbi0gwEQmygLIAQoAgQgBUEDdGoiCCAGNgIEIAggBzYCACAEIAVBAWo2AgggASAFNgIMIAEgAzYCCCABIAI2AgQgAUEBNgIAIAFBDGoMBAsgAiAFcg0BDAILIAUgBkHIs4MBEMMhAAsgBCgCCCgCACEGIAQoAgQoAgAhByAEKAIAIgQoAggiBSAEKAIARgRAIARBuLSDARCbKAsgBCgCBCAFQQN0aiIIIAY2AgQgCCAHNgIAIAQgBUEBajYCCCABIAM2AgggASACNgIEIAEgBTYCDAsgAUEMagshASAAQZOAgIB4NgIAIAAgATYCBAvKAgEGfyABIAJBAXRqIQkgAEGA/gNxQQh2IQogAEH/AXEhDAJAAkACQAJAA0AgAUECaiELIAcgAS0AASICaiEIIAogAS0AACIBRwRAIAEgCksNBCAIIQcgCyIBIAlHDQEMBAsgByAISw0BIAQgCEkNAiADIAdqIQEDQCACRQRAIAghByALIgEgCUcNAgwFCyACQQFrIQIgAS0AACABQQFqIQEgDEcNAAsLQQAhAgwDCyAHIAhB1P6JARCxOwALIAggBEHU/okBELA7AAsgAEH//wNxIQcgBSAGaiEDQQEhAgNAIAVBAWohAAJAIAUsAAAiAUEATgRAIAAhBQwBCyAAIANHBEAgBS0AASABQf8AcUEIdHIhASAFQQJqIQUMAQtBxP6JARCyOwALIAcgAWsiB0EASA0BIAJBAXMhAiADIAVHDQALCyACQQFxC8cCAQd/IwBBIGsiBSQAAkACQAJAAkAgA0UEQAwBCyAERQ0AIAEoAkghBgNAIAYgASgCREYEQCAFQQhqIAEQ8hsgBSgCCCIGQQhHBEAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAMBgsgASgCREUNAiABKAJIIQYLIAVBCGogASADIAhrIAQgB2sQ6hMgBSgCECIKIAZqIgkgCkkNAiAJQYAISw0DIAUoAgghCSAFLQAMIQsgAiABKAJAIAZBAXRqIAoQ+CkgASALOgBMIAEgASgCSCAKaiIGNgJIIAcgCmohByAIIAlqIgggA08NASAEIAdLDQALCyAAIAc2AgggACAINgIEQQghBgwCCyAGIAlBxLDOABCxOwALIAlBgAhBxLDOABCwOwALIAAgBjYCACAFQSBqJAALhwMBAn8jAEFAaiIDJAAgAyACOgAPIAMgATcDACAAAn8CQCACQf8BcSICQRNPBEAgA0ECNgIsIANBhJSFATYCKCADQgI3AjQgA0G7BzYCHCADQbsHNgIUIANB4JOFATYCECADIANBEGo2AjAgAyADQQ9qNgIYIABBBGogA0EoahCZDgwBCyACQQN0IgRBmJCFAWoiAikDACABUwRAIANBAzYCFCADQciThQE2AhAgA0IDNwIcIANB7gY2AjwgAyACNgI4IANBuwc2AjQgA0HuBjYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgAzYCKCAAQQRqIANBEGoQmQ4MAQtBk4CAgHggASAEQbCRhQFqIgQpAwBZDQEaIANBAzYCFCADQfyShQE2AhAgA0IDNwIcIANB7gY2AjwgAyAENgI4IANBuwc2AjQgA0HuBjYCLCADIANBKGo2AhggAyADQQ9qNgIwIAMgAzYCKCAAQQRqIANBEGoQmQ4LQY2AgIB4CzYCACADQUBrJAAL7AUCDX8BfiMAQfACayIGJAAgA0EIaiIHKAIAIQ8gBCgCACEMIAYgAjYCvAIgBiABNgK4AiAGIAxBAEc6ALUCIAZBIToAtAIgBkEANgLoAiAGQQA2AtACIAZCADcCwAIgBkEANgKUAiAGQQA7AewCIAZCBDcCrAIgBkIANwKkAiAGQoCAgIDAADcCnAIgBkHIAWogBygCADYCACAGIAMpAgA3A8ABIAZB4ABqIg0gBkGUAmoiByAGQcABaiIKEPojIAUoAgghAiAFKAIEIQEgBiAFKAIANgKcAiAGIAE2ApgCIAYgATYClAIgBiABIAJBA3RqNgKgAiMAQSBrIgMkACADQRRqIAcoAgwgBygCBGtBA3ZBAEEEQcQAEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQbTmhAEQ/S8ACyADQRBqIhBBADYCACADIAMoAhw2AgwgAyABNgIIIwBBIGsiBSQAIANBCGoiASAHKAIMIAcoAgRrQQN2EP4tIAEpAgQhEyAFQQhqIAdBCGopAgA3AwAgBSAHKQIANwMAIAUgE0IgiTcCGCAFIAFBCGo2AhQgBUEUaiEIIwBB0ABrIg4kAAJAIAUoAgQiASAFKAIMIhFGBEAgCCgCBCEJDAELIAgoAgggCCgCBCIJQcQAbGohCwNAIAUgAUEIaiICNgIEIA5BDGoiEiABKAIAIAFBBGooAgAQ0yMgCyASQcQA/AoAACAIIAlBAWoiCTYCBCALQcQAaiELIAIiASARRw0ACwsgCCgCACAJNgIAIAUQshwgDkHQAGokACAFQSBqJAAgCkEIaiAQKAIANgIAIAogAykCCDcCACADQSBqJAAgBkEEaiIBIA0gChD8IiAGIA82AjACQCAMBEAgBkHoAGogBEEIaigCADYCACAGIAQpAgA3A2AgByABIA0Q+iMgBkHQAWogBxDNHAwBCyAGQdABaiAGQQRqEM0cCyAAIAZB0AFqELcEIAZB8AJqJAAL7wIBBH8jAEEQayIGJAAgBiAENgIMIAYgAzYCCAJAIAIoAghBAUYEQCACKAIUIQcgAigCDCIFRQRAQQAhBQwCCwJAIAIoAhgiCCAFTQRAIAUgCEcNAQwDCyAFIAdqLAAAQb9/Sg0CCyAHIAhBACAFQZSVxAAQozYACyACKAIYIQUgAigCFCEHCyABIAQgA2sgBWoQ2C0gASAHIAUgB2oQgSYgAUEIaiIDKAIAIQQgAUEBENgtIAEoAgQgAygCAGpBIzoAACADIARBAWo2AgAgBkEIahDuEhogASAGKAIIIAYoAgwQ3BwgAEEBNgIIIAAgBTYCDCAAQRhqIAMoAgA2AgAgACABKQIANwIQIAAgAikCNDcCNCAAQTxqIAJBPGopAgA3AgAgAEHEAGogAkHEAGotAAA6AAAgACACKAIwNgIwIAAgAikCADcCACAAIAIpAiA3AiAgACACKQIoNwIoIAAgAigCHDYCHCAGQRBqJAAL2yACDH8BfiMAQdAAayIJJAAgASgCACEMIwBBEGsiCyQAIwBBMGsiByQAIwBBEGsiBiQAIAZBCGoiCiIBQQA2AgAgBkIANwMAIwBBEGsiCCQAAkAgBigCAEUgBigCBEVzDQAgCEEIaiABKAIANgIAIAggBikCADcDAEHIHSAIENkuIgFFDQAgAUEAQcgd/AsAIAFBwAVqIAooAgA2AgAgASAGKQIANwK4BSABQQIQoB8aIAEhBQsgCEEQaiQAIAZBEGokACAFRQRAQZTw0ABBNEHI8NAAEMskAAsgCUEoaiEIIAtBCGohCiAHIAU2AhwgB0EAOgAoIAcgDDYCLCAHQRBqIQ0gB0EcaiEFAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQShqIgEtAABBAWsOEgECAwQFBgcICQoLDA0ODxAREgALQeQAIQYgASgCBAwSC0HlACEGIAEoAgQMEQtB5gAhBiABKAIEDBALQecAIQYgASgCBAwPC0HoACEGIAEoAgQMDgtB6QAhBiABKAIEDA0LQeoAIQYgASgCBAwMC0HrACEGIAEoAgQMCwtBoAEhBiABLQABDAoLQaEBIQYgASgCBAwJC0GiASEGIAEoAgQMCAtBowEhBiABKAIEDAcLQaQBIQYgASgCBAwGC0HIASEGIAEtAAEMBQtByQEhBiABLQABDAQLQcoBIQYgAS0AAQwDC0GQAyEGIAEoAgQMAgtBkQMhBiABKAIEDAELQZIDIQYgASgCBAshAQJAIAUoAgAiDCgC5BIEQEFEIQUgBkHkAGsiDkEHSyAOQQFGcg0BIAxBATYCBAsCQCAGQegHa0ERSSAGQeQAa0EISXIgBkGgAWtBBUkgBkHIAWtBA0lycg0AQVghBQJAAkAgBkGQA2sOAwECAgALIAZBCkYgBkH0A0ZyDQEMAgsgAUUNACAMKALIBQ0BCwJ/IAxBDGohBQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkHoB2sOEQECAwoLBAwNDg8QERITFBUWAAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkHkAGsOCAECAwQFBgcIAAsCQCAGQaABaw4FEBESExQACwJAIAZByAFrDgMJCgsACwJAIAZBkANrDgMkJCQACyAGQfQDRg0jQVggBkEKRw0kGkEKIAEQ2CdFDSEgBSABNgIADCILIAUCf0GAgHggAUGAgHhIDQAaQRYgAUEWSg0AGiABQQMgARsLIgE2AiwgAUEAIAFBAEobDCMLIAEEQEHlACABENgnRQ0gCyAFIAE2AgQMIAsgAQRAQeYAIAEQ2CdFDR8LIAUgATYCDAwfCyABBEBB5wAgARDYJ0UNHgsgBSABNgIIDB4LIAEEQEHoACABENgnRQ0dCyAFIAE2AhAMHQsgAQRAQekAIAEQ2CdFDRwLIAUgATYCFAwcC0HqACABENgnRQ0aIAUgATYCGAwbCyABBEBB6wAgARDYJ0UNGgsgBSABNgIcDBoLIAUgAUEARyIBNgIgIAEMGwsgBSABQQBHIgE2AiQgAQwaCyAFIAFFNgIoIAFBAEcMGQsgBSABQQBHIgE2AjAgAQwYC0HpByABENgnRQ0UIAUgATYCPAwVC0HqByABENgnRQ0TIAUgATYCQAwUCyAFIAFBAEciATYCbCABDBULQaABIAEQ2CdFDREgBSABNgJUDBILIAEEQEGhASABENgnRQ0RCyAFIAE2AlgMEQsgAQRAQaIBIAEQ2CdFDRALIAUgATYCYAwQCyABBEBBowEgARDYJ0UNDwsgBSABNgJcDA8LIAEEQEGkASABENgnRQ0OCyAFIAE2AmQMDgsgAQRAQesHIAEQ2CdFDQ0LIAUgATYCNAwNCyABBEBB7AcgARDYJ0UNDAsgBSABNgI4DAwLQe4HIAEQ2CdFDQogBSABNgJwDAsLQe8HIAEQ2CdFDQkgBSABNgJ0DAoLQfAHIAEQ2CdFDQggBSABNgJ4DAkLQfEHIAEQ2CdFDQcgBSABNgJ8DAgLQfIHIAEQ2CdFDQYgBSABNgKAAQwHC0HzByABENgnRQ0FIAUgATYChAEMBgtB9AcgARDYJ0UNBCAFIAFBAEciATYCiAEgAQwHC0H1ByABENgnRQ0DIAUgATYCmAEMBAtB9gcgARDYJ0UNAiAFIAE2ApwBDAMLIAEEQEH3ByABENgnRQ0CCyAFIAE2AqQBDAILQfgHIAEQ2CdFDQAgBSABNgKoAQwBC0FWDAILIAEMAQtBWEEAIAEbCyEFCyAFENI9IQEgDSAFNgIEIA0gAUEARzYCAAJAAkACQCAHKAIQQQFxRQ0AIAdBIGogBygCFBDiGiAHLQAgQQRGDQAgBykDICIRQv8Bg0IEUg0BCyAHQRxqKAIAIQUjAEEQayIGJABBRCEBIAUoAuQSRQRAIAUQ5SRBACEBCyAGQRBqJAAgARDSPSEFIAdBCGoiBiABNgIEIAYgBUEARzYCAAJAIAcoAghBAXFFDQAgB0EoaiAHKAIMEOIaIActAChBBEYNACAHKQMoIhFC/wGDQgRSDQELIAogBygCHDYCBCAKQQQ6AAAMAQsgCiARNwIAIAdBHGoQjjwLIAdBMGokAAJAAkAgCy0ACEEERgRAIAsoAgwhAQwBCyALKAIMIQEgCygCCCIFQf8BcUEERg0AIAhBgICAgHg2AgAgCCAFrSABrUIghoQ3AgQMAQsjAEEQayIFJAAgBUEEakGAgAJBAEEBQQEQoBggBSgCCCEGIAUoAgRBAUYEQCAGIAUoAgxB9PHNABD9LwALIAUoAgwhByAIQQA2AhQgCCABNgIQIAggBDYCDCAIQQA7ARggCEEANgIIIAggBzYCBCAIIAY2AgAgBUEQaiQACyALQRBqJAAgCSkCLCERAkAgCSgCKCIBQYCAgIB4RgRAIAkgETcDKCAAIAgQgSsMAQsgCUEYaiAJQTxqKQIANwIAIAkgCSkCNDcCECAJIBE3AgggCSABNgIEIAlBKGohCyAJQQRqIQYjAEEQayIHJAACQAJAIAMEQANAIAdBCGohBCMAQSBrIgEkACAGQRBqIQwCQANAIAEgBhDeKQJAIAEtAABBBEYNACABKQMAIhFC/wGDQgRRDQAgBCARNwIADAILIAYtABkEQCMAQRBrIgUkACAMKAIAQQEQoB8iCBDSPSEKIAUgCDYCBCAFIApBAEc2AgACQAJAIAUoAgBBAXFFDQAgBUEIaiAFKAIEEOIaIAUtAAhBBEYNACAFKQMIIhFC/wGDQgRRDQAgASARNwIADAELIAFBBDoAAAsgBUEQaiQAAkAgAS0AAEEERg0AIAEpAwAiEUL/AYNCBFENACAEIBE3AgAMAwsgBkEAOgAZCyAGQQA2AgggAUEANgIIIAEgAzYCBCABIAI2AgAgAUEANgIcIAEgBjYCGCABQRBqIQojAEEQayIIJAAgCEEIaiMAQTBrIgUkACABQRhqIg0oAgAiDygCBCEQIAUgDygCADYCGCAFIBA2AhQgBSANNgIQIAUgDSgCBDYCHCAFQSBqIg0gARDfLyAFQQhqIAwoAgAiDyAFQRRqIAVBJGpBABCSBCIQQYh/TQR/IA8QjCsFIBALEN4vIAUpAwggDRCKLSAFKAIQIAUoAhwQsyw3AwAgBUEwaiQAIAgoAgwhBQJAIAgoAghBAXEEQCAKIAUQ4hoMAQsgCkEEOgAAIAogBTYCBAsgCEEQaiQAIAZBADYCFCABKAIIIQUCQCABLQAQQQRGBEAgASgCFCEIDAELIAEpAxAiEUL/AYNCBFEEQCARQiCIpyEIDAELIAQgETcCAAwCCyAIRQRAIAZBAToAGQtBACADIAUbDQALIARBBDoAACAEIAU2AgQLIAFBIGokAAJAAkACQAJAAkAgBy0ACCIBQQRHBEACQCABQQFrDgMABAIJCyAHLQAJQSNHDQgMBAsgBygCDCIBRQRAQeDf0AAhBAwICyABIANNDQEgASADQejf0AAQrzsACyAHKAIMLQAIQSNGDQIMBgsgASACaiECIAMgAWshAwwCCyAHKAIMLQAIQSNHDQQLIAdBCGoQuS4LIAMNAAsLIAtBBDoAAAwBCyALIAQpAgA3AgALIAdBEGokAAJAIAktAChBBEYNACAJKQMoIhFC/wGDQgRRDQAgCSARNwMoIAAgCxCBKyAJQRRqEI48IAYQ3jsMAQsgCUFAayAJQRxqKAIANgIAIAlBOGogCUEUaikCADcDACAJQTBqIAlBDGopAgA3AwAgCSAJKQIENwMoIAlBIGohCyMAQdAAayIGJAAgBkEIaiEFIwBBMGsiASQAIwBBIGsiAiQAIAlBKGoiBEEQaiEMA0ACQCACQRhqIAQQ3ikCQAJAAkAgAi0AGEEERg0AIAIpAxgiEUL/AYNCBFENACABIBE3AgAMAQsCQAJAIAQtABhFBEAgBEEANgIIIAJBADYCHCACIAQ2AhgjAEEgayIDJAAgAkEYaiIHKAIAIggoAgQhCiADIAgoAgA2AhggAyAKNgIUIAMgBzYCECADIAcoAgQ2AhwgDCgCACEHIANBFGohCiMAQRBrIggkAAJAIAcoAqgCQQFGBEAgCEEIaiAHQfQSaigCADYCACAIIAcpAuwSNwMADAELIAhBCGpBADYCACAIQgA3AwALAkAgByAKIAhBAhCSBCIKQYh/Sw0AIAcoAvwBQQBKDQBBAEEDIAcoAugSIg0bIQ4gDQR/QQAFIAcoAtwBQQJ0CyAKIA5qaiEKCyAIQRBqJAAgA0EIaiAKEN4vIAMpAwghESADKAIQIAMoAhwQsywgAkEIaiARNwMAIANBIGokACACKAIMIQMgAigCCEEBcUUEQCACQQQ6ABAgAiADNgIUIARBADYCFAwDCyACQRBqIAMQ4hogAi0AECAEQQA2AhRBBEYEQCACKAIUIQMMAwsgAikDECIRQv8Bg0IEUg0BIBFCIIinIQMMAgsgAUEEOgAADAILIAEgETcCAAwBCyADRQ0BIAQoAggNASABQSVBhPLNAEEQEM0aCyACQSBqJAAMAQsgBCADRToAGAwBCwsCQCABLQAAQQRHBEAgBSABKQMANwIcIAUgBCkCADcCACAFQQhqIARBCGopAgA3AgAgBUEQaiAEQRBqKQIANwIAIAVBGGogBEEYaigCADYCAAwBCyABQRhqIARBCGopAgA3AwAgAUEoaiAEQRhqKAIANgIAIAFBIGogBEEQaikCACIRNwMAIAEgBCkCADcDECABKAIcIQIgAUEQahDeOyABIBE+AgwgASACNgIIIAVBgICAgHg2AgAgBSACNgIEIAFBDGoQjjwLIAFBMGokAAJAIAYoAghBgICAgHhHBEAgBkEsaiIBIAVBJPwKAAAgBikCSCERIAZBPGoQjjwgARDeOyALIBE3AgAMAQsgCyAGKAIMNgIEIAtBBDoAAAsgBkHQAGokACAJLQAgQQRHBEAgCSAJKQMgNwNIIAAgCUHIAGoQgSsMAQsgAEEINgIACyAJQdAAaiQAC9QCAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQAJAIAUgAiwAACIKQQFqIglLBEAgBSAKSw0BIAogBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUECdGooAgAiCSAEIApBAnRqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCfFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC9QCAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQAJAIAUgAiwAACIKQQFqIglLBEAgBSAKSw0BIAogBUGAytAAEMMhAAsgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUEDdGooAgAiCSAEIApBA3RqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCXFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC9ICAQV/IwBBQGoiAiQAIAAoAgAhAyACQQhqIgQgAUEDdCIFIAAoAgQoAhBqKQMAENYVAkACQAJAAkACQCACKAIIIgZFDQAgAiACKQIMNwIoIAJBIGogAkEsaigCADYCACACIAY2AiQgAiACKQIkNwMYIAQgAygCABCWNiACKAIIDQAgBCACQSRqIAIoAgwQ+BEgAigCCEUNBCACQThqIAJBEGooAgA2AgAgAiACKQIINwMwIAQgAkEwahDgGSACKAIIQQFxRQ0BIAUgACgCCGogAikDEDcDAAwCCyACQgA3AwgLIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALQYiK/wBBKkG0iv8AEMskAAvSAgEFfyMAQUBqIgIkACAAKAIAIQMgAkEIaiIEIAFBA3QiBSAAKAIEKAIQaikDABCBFQJAAkACQAJAAkAgAigCCCIGRQ0AIAIgAikCDDcCKCACQSBqIAJBLGooAgA2AgAgAiAGNgIkIAIgAikCJDcDGCAEIAMoAgAQljYgAigCCA0AIAQgAkEkaiACKAIMEPgRIAIoAghFDQQgAkE4aiACQRBqKAIANgIAIAIgAikCCDcDMCAEIAJBMGoQmSQgAigCCEEBcUUNASAFIAAoAghqIAIpAxA3AwAMAgsgAkIANwMICyAAKAIQIgMgAygCAEEBajYCACACIAAoAhQQhj0gAUEDdiIAIAIoAgQiA08NASACKAIAIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkFAayQADwsgACADQYiL/wAQwyEAC0GIiv8AQSpBtIr/ABDLJAAL0gIBBX8jAEFAaiICJAAgACgCACEDIAJBCGoiBCABQQN0IgUgACgCBCgCEGopAwAQ/RcCQAJAAkACQAJAIAIoAggiBkUNACACIAIpAgw3AiggAkEgaiACQSxqKAIANgIAIAIgBjYCJCACIAIpAiQ3AxggBCADKAIAEJY2IAIoAggNACAEIAJBJGogAigCDBD4ESACKAIIRQ0EIAJBOGogAkEQaigCADYCACACIAIpAgg3AzAgBCACQTBqEMQnIAIoAghBAXFFDQEgBSAAKAIIaiACKQMQNwMADAILIAJCADcDCAsgACgCECIDIAMoAgBBAWo2AgAgAiAAKAIUEIY9IAFBA3YiACACKAIEIgNPDQEgAigCACAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBQGskAA8LIAAgA0GIi/8AEMMhAAtBiIr/AEEqQbSK/wAQyyQAC9ICAQV/IwBBQGoiAiQAIAAoAgAhAyACQQhqIgQgAUEDdCIFIAAoAgQoAhBqKQMAEP0VAkACQAJAAkACQCACKAIIIgZFDQAgAiACKQIMNwIoIAJBIGogAkEsaigCADYCACACIAY2AiQgAiACKQIkNwMYIAQgAygCABCWNiACKAIIDQAgBCACQSRqIAIoAgwQ+BEgAigCCEUNBCACQThqIAJBEGooAgA2AgAgAiACKQIINwMwIAQgAkEwahCZGiACKAIIQQFxRQ0BIAUgACgCCGogAikDEDcDAAwCCyACQgA3AwgLIAAoAhAiAyADKAIAQQFqNgIAIAIgACgCFBCGPSABQQN2IgAgAigCBCIDTw0BIAIoAgAgAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALQYiK/wBBKkG0iv8AEMskAAvZAgEKfyMAQRBrIgUkAAJAIAEoAhwiAiABKAIgIghGBEAgASgCBCEDDAELIAJBf3MhByABKAIEIQMDQAJAAn8CQCADBEAgAiABKAIUTw0DIAEoAgggAiABKAIQaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENAQsgASACQQFqNgIcIAVBCGogASgCACACENorIAUoAgwhCSAFKAIIDAELIAEgAkEBajYCHEEACyEKIAAoAggiBiAAKAIARgRAIAEoAgAiBBDUOiELIAQQ1DoaIAAgByALakEBaiIEQX8gBBsQ6i0LIAAoAgQgBkEDdGoiBCAJNgIEIAQgCjYCACAAIAZBAWo2AgggB0EBayEHIAJBAWoiAiAIRw0BDAILC0G8tIABQSBB3LSAARCfKQALAkAgA0UNACADIAMoAgAiAEEBazYCACAAQQFHDQAgAUEEahD7HgsgBUEQaiQAC7gCAQR/AkAgBEUgASAETXINACADIAEgBGsiBiAEIAQgBksiCBsiB0kNACAAIARBA3RqIQMgB0EDdCIFBEAgAiADIAAgCBsgBfwKAAALIAIgBWohBQJAAkAgBCAGSwRAIAFBA3QgAGpBCGshBANAIAQgA0EIayIBIAVBCGsiAyADKAIAIgYgASgCACIHSSIFGykCADcCACADIAVBA3RqIQUgASAGIAdPQQN0aiIDIABGDQIgBEEIayEEIAIgBUcNAAsMAQsgB0UNASAAIAFBA3RqIQEDQCAAIAMgAiADKAIAIgQgAigCACIGSSIHGykCADcCACAAQQhqIQAgAiAEIAZPQQN0aiICIAVGDQIgAyAHQQN0aiIDIAFHDQALDAELIAMhAAsgBSACayIBRQ0AIAAgAiAB/AoAAAsLywIBBH8jAEEgayIFJAAgAiADIAIoAggiA2oQhS0CQAJAAkACQCABKQMAQgNSBEAgAigCCCIEIANJDQEgBUEIaiABIAIoAgQgA0EBdGogBCADaxDVGSAFKAIMIQYgBSgCCCIEQQhHBEAgACAFKQMQNwMIIABBEGogBUEYaikDADcDACAAIAY2AgQgACAENgIADAULIAIgAyAGahD0NCACKAIIIQQgAigCBCIHIQIgAwRAIANBAWsiAiAETw0DIAcgAkEBdGpBAmohAgsgAiAHIARBAXRqIgNGDQIgAyACa0EBdiEDQQAhBCABLwFAIQEDQCAEIAIvAQAgAUZqIQQgAkECaiECIANBAWsiAw0ACwwDC0GEsM4AELI7AAsgAyAEQZSwzgAQrzsAC0EAIQQLIAAgBjYCCCAAIAQ2AgQgAEEINgIACyAFQSBqJAAL9QIBBH8jAEEwayICJAACQCAALQAAIgRBEUYNACAALQABIQNBASEBAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBEEBaw4QAgMEBQYAAQcICQoICAgICBALQYgSIANBA3R2IQEMDwtBihYgA0EDdHYhAQwOC0ECIQEMDQtBBCEBDAwLQQUhAQwLC0EGIQEMCgtBByEBDAkLIAAtAAIhACADQQhrIgFBBXQgAUH4AXFBA3ZyQf8BcQ4IBAUDBgMDAwcDC0EAIQEMBwtBFCEBDAYLQRUhAQwFCyACIAM6AA4gAiAAQQFxOgAPIAJBAjYCFCACQfT4zgA2AhAgAkIBNwIcIAJBkAg2AiwgAiACQShqNgIYIAIgAkEOajYCKCACQRBqQYT5zgAQ7ywAC0EQQQwgAEEBcRshAQwDC0ERQQ0gAEEBcRshAQwCC0ESQQ4gAEEBcRshAQwBC0ETQQ8gAEEBcRshAQsgAkEwaiQAIAELygIBAn8CfyAGKAIAQQAgAEEQRiINGyIGIAcoAgBHBEAgByAGNgIAQQAMAQtBACAEKAIAIgBFDQAaIABBAmtBAkEDIA0bdCEMIAALIQAgBCABIAxqQQNqIgE2AgACQAJAAkAgAiADKAIAIgQgASAAayIAaiIBTwRAIAZFBEAgAyABNgIADwsgBkEgTw0BIAsgBkECdGoiBygCACECIAAhDANAIAIgCWoiAUHQBU8NAyADIAQiAkEBaiIENgIAIAggAUEBdGogAjsBACAMQQFrIgwNAAsgByAEQQFrNgIAIAUgBSgCACAAQQ8gBmt0azYCACAGQRBPDQMgCiAGQQF0aiIBIAEvAQAgAGo7AQAPCyAFQf//PzYCACADIAI2AgAPCyAGQSBB/J/zABDDIQALIAFB0AVBjKDzABDDIQALIAZBEEGcoPMAEMMhAAuPBwEPfyMAQfAAayIEJAAgBEEgaiIFEIYgIAQgAjYCZCMAQTBrIgckACAHQQhqIAEQwzQgBygCDCEGIAcoAgghAiAHIARB5ABqIg02AiwgByAFNgIoIAcgAjYCICAHIAIgBkECdGo2AiQjAEEgayICJAAgAkEUaiAHQSBqIgYoAgQgBigCAGtBAnZBAEEEQQQQoBggAigCGCEKIAIoAhRBAUYEQCAKIAIoAhxB0Lf+ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAo2AggjAEEQayIKJAAgBigCBCAGKAIAa0ECdiIMIAJBCGoiCCgCACAIKAIIIglrSwRAIAggCSAMQQRBBBDeKCAIKAIIIQkLIAdBFGohDCAKIAgoAgQ2AgwgCiAJNgIIIAogCEEIajYCBCAKQQRqIgsoAgQhCCALKAIAIAYoAgAiCSAGKAIEIhBHBEAgBigCDCERIAYoAgghEiALKAIIIAhBAnRqIQYgCCAQIAlrQQJ2IgtqIQgDQCAGIBIgESAJKAIAQQhqEKsCNgIAIAlBBGohCSAGQQRqIQYgC0EBayILDQALCyAINgIAIApBEGokACAMQQhqIA4oAgA2AgAgDCACKQIINwIAIAJBIGokACAFIAcoAhggBygCHBDCDyEGAkAgASgCFEUEQCAFQQE6ADggBSgCMCECIAVBBiAGEPwODAELIAUgAUEIahD9CiEBIAVBAToAOCAFKAIwIQIgBUEGIAYQ/A4gBUEIIAEQ/A4LIAUgAhDYByECIAVBADYCFCAFQQA6ADggB0EUakEEQQQQ4B4gB0EwaiQAIARBAToAWCAEIAQoAlAiBzYCYCAEIAU2AlwgBEHcAGoiASADLwECEMQOIAFBARCfEiAFQQpCABDLDiABIAIQ8A4gBSAHENgHIQEgBEEANgI0IARBADoAWCAFIAEQpAwgBEEYaiAFENw7IAQoAhwhASAEKAIYIQIgBEEQaiAEKAJQEIw3IARBCGogAiABIAQoAhAgBCgCFEHkxv4AENcmIAQoAgghBSANIAQoAgwiAUEAQQFBARCgGCAEKAJoIQIgBCgCZEEBRwRAIAQoAmwhAyABBEAgAyAFIAH8CgAACyAAQQA2AhQgAEKAgICAEDcCDCAAIAE2AgggACADNgIEIAAgAjYCACAEQSBqEMwqIARB8ABqJAAPCyACIAQoAmxBqMn+ABD9LwALwAQCCH8CfiMAQYABayICJAAgAkEYaiABEPEHAkACQCACKAIYQQFGBEAgASgCHCABKAIUa0EEdkEAIAEoAhAbIAEoAgwgASgCBGtBBHZBACABKAIAG2ohBSACKQMoIQogAikDICELAn8gASgCIARAIAJB9ABqIAEoAjQgASgCMEcNARoLIAUhAyACQRRqCyADNgIAIAJB9ABqQQMgBSAFQQNNG0EBakEAQQhBEBCgGCACKAJ4IQYgAigCdEEBRg0CIAIoAnwiAyAKNwMIIAMgCzcDACACQRBqIgVBATYCACACIAM2AgwgAiAGNgIIIAJBGGoiAyABQdgA/AoAACACQQhqIQcjAEEgayIEJAAgBCADEPEHIAQoAgBBAUYEQANAIAQpAxAhCiAEKQMIIQsgBygCCCIIIAcoAgBGBEAgAygCHCADKAIUa0EEdkEAIAMoAhAbIAMoAgwgAygCBGtBBHZBACADKAIAG2ohCQJ/AkAgAygCIEUNACADKAI0IAMoAjBGDQAgBEEcaiEGQQAMAQsgBEEYaiEGIAkLIQEgBiABNgIAIAcgCCAJQQFqQQhBEBDQKAsgBygCBCAIQQR0aiIBIAo3AwggASALNwMAIAcgCEEBajYCCCAEIAMQ8QcgBCgCAA0ACwsgAxDQLSAEQSBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCAAwBCyAAQQA2AgggAEKAgICAgAE3AgAgARDQLQsgAkGAAWokAA8LIAYgAigCfEGI+sIAEP0vAAuVAwEBfyMAQUBqIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAIAAoAgAiAC8BSEEBaw4GAQIDBAUGAAsgAUG26cMAQQ0Q+zVFDQYMBwsgAUHD6cMAQRUQ+zUNBgwFCyABQdjpwwBBGBD7NQ0FDAQLIAIgAEHKAGo2AgwgAkEYNgIUIAJBiOrDAEHw6cMAIAAvAUpBkANrQf//A3FB5ABJGzYCECACQQM2AiwgAkGk6sMANgIoIAJCAjcCNCACQbECNgIkIAJBsgI2AhwgAiACQRhqNgIwIAIgAkEMajYCICACIAJBEGo2AhggASgCACABKAIEIAJBKGoQywoNBAwDCyABQbzqwwBBHhD7NQ0DDAILIAFB2urDAEEcEPs1DQIMAQsgAUH26sMAQRoQ+zUNAQtBACAAKAIAQQJGDQEaIAIgADYCECACQQI2AiwgAkGc68MANgIoIAJCATcCNCACQbMCNgIcIAIgAkEYajYCMCACIAJBEGo2AhggASgCACABKAIEIAJBKGoQywoMAQtBAQsgAkFAayQAC+gCACMAQUBqIgUkACAFIAQ6AA8CQAJAIARB/wFxIgRBB01BAEEBIAR0QYMBcRtFBEAgBUEBNgIYIAVBoIzNADYCFCAFQgE3AiAgBUGuAzYCNCAFIAVBMGo2AhwgBSAFQQ9qNgIwIABBBGogBUEUahCZDiAAQQE2AgAgAigCCCEEDAELIAUgASgCYCADbCIDNgIQIAIoAggiBCADTwRAIAEoAlAiAwRAIAFB3ABqIAEoAlQgASgCWCADKAIQEQEACyAAQQg2AgAgAUHQAGoiACACKQIANwIAIABBCGogAkEIaikCADcCAAwCCyAFIAQ2AiwgBUECNgIYIAVBxJzNADYCFCAFQgI3AiAgBUE7NgI8IAVBOzYCNCAFIAVBMGo2AhwgBSAFQSxqNgI4IAUgBUEQajYCMCAAQQRqIAVBFGoQmQ4gAEEANgIACyACQQxqIAIoAgQgBCACKAIAKAIQEQEACyAFQUBrJAAL+gQBC38jAEEwayIEJAAjAEEgayIFJAAgBUEUaiACIANBBHRqIgsgAmtBBHZBAEEEQQQQoBggBSgCGCEGIAUoAhRBAUYEQCAGIAUoAhxBoIPOABD9LwALIARBDGohDCAFQRBqIg1BADYCACAFIAUoAhw2AgwgBSAGNgIIIwBBEGsiCiQAIAVBCGoiCCALIAIiBmtBBHYiBxDuLSAKIAgpAgRCIIk3AgggCiAIQQhqNgIEIApBBGoiCSgCBCEIIAkoAgAhDgJAAkAgAiALRwRAIAkoAgggCEECdGohCQNAIAYoAgBFDQIgCSAGQQhqKAIANgIAIAZBEGohBiAJQQRqIQkgCEEBaiEIIAdBAWsiBw0ACwsgDiAINgIADAELQbjj0ABBJUHg49AAEJ8pAAsgCkEQaiQAIAxBCGogDSgCADYCACAMIAUpAgg3AgAgBUEgaiQAIARBGGogASAEKAIQIAQoAhQQzxFBCCEGAkACQCAEKAIYIgdBCEcEQCAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAHIQYMAQsgA0UNACABQeAAaiEDA0AgAigCACIGRQ0CIAEgAkEIaigCACIHIAEoAmxqNgJsIARBGGogAkEMaiIFIAJBBGooAgAgByAGKAIAEQUAIAEoAmgiAiABKAJgRgRAIANBhKDOABCeKAsgASgCZCACQQR0aiIHIAQpAhg3AgBBCCEGIAdBCGogBEEgaikCADcCACABIAJBAWo2AmggBUEEaiICIAtHDQALCyAAIAY2AgAgBEEMahDpOyAEQTBqJAAPC0Gsh84AQSVB1IfOABCfKQAL0gIBBH8jAEEwayIDJAAgA0EMaiABIAIQkw4gAygCECEFAkAgAygCDCIEQYqAgIB4RwRAIAAgAykCFDcCCCAAQSBqIANBLGooAgA2AgAgAEEYaiADQSRqKQIANwIAIABBEGogA0EcaikCADcCACAAIAU2AgQgACAENgIADAELAkACQEF/QX8gAkEEaiIEIAIgBEsbIgIgBWoiBCACIARLGyIEIAEoAgRNBEAgASABKAIUIAVqIgY2AhRBiICAgHghBSAGIAEoAggoAghLDQEMAgsgA0EMaiACIAQQvy8gAygCDCIFQYqAgIB4Rg0BCyAAIAMpAhA3AgQgAEEcaiADQShqKQIANwIAIABBFGogA0EgaikCADcCACAAQQxqIANBGGopAgA3AgAgACAFNgIADAELIAAgBDYCCCAAIAI2AgQgAEGKgICAeDYCAAsgA0EwaiQAC9gCAQV/IwBBEGsiBCQAAkACQCADIAEoAihGBEAgASACIAMQoTYCQCABKAIMBEAgASgCHCIGQQFqIgdBA3YgB0EHcUEAR2oiAiABKAIYIgNLBEAgAiADayEIIAEoAhAiBSACSQRAIAFBDGogBUEBdCIDIAIQzSoiBSADIAVLGxDoGSABKAIYIQMLIAgEQCABKAIUIANqQQAgCPwLAAsgASACNgIYCyABIAc2AhwgASgCFCAGQQN2aiIBIAEtAABBASAGQQdxdHI6AAAMAQsgASABKAIgQQFqNgIgCyAAQZOAgIB4NgIADAELIARBBGpB0ABBAEEBQQEQoBggBCgCCCEBIAQoAgRBAUYNASAEKAIMIgJB0L7/AEHQAPwKAAAgAEHQADYCDCAAIAI2AgggACABNgIEIABBjYCAgHg2AgALIARBEGokAA8LIAEgBCgCDEGMyf8AEP0vAAviAgIEfgF/AkACQAJAAkACQAJAAkACQAJAIAUgCEsEQCAHIAlNDQEgCCAKaiIPIAVPDQIgBCAPQQN0aikDACAEIAhBA3RqKQMAIg19IgtCgICAgBBaDQMgCSAKaiIEIAdPDQQgBiAEQQN0aikDACAGIAlBA3RqKQMAIg59IgxCgICAgBBaDQUgCyAMhFAEQEEBDwsgCyAMUgRAQQAPCyALpyIEIA2nIgZqIgUgBEkNBiABIAVJDQcgBCAOpyIFaiIBIARJDQggASADSw0JIAAgBmogBCACIAVqIAQQnzsPCyAIIAVB1K2HARDDIQALIAkgB0HkrYcBEMMhAAsgDyAFQfSthwEQwyEAC0GErocBELI7AAsgBCAHQZSuhwEQwyEAC0GkrocBELI7AAsgBiAFQbSthwEQsTsACyAFIAFBtK2HARCwOwALIAUgAUHErYcBELE7AAsgASADQcSthwEQsDsAC/MCAgV/A34jAEEwayIDJAACQAJAIAECfwJAAkACQAJAAkACQCABLQAYQQFrDgMEAQACCyABKAIUIQUMAgsACyADEM4iIAMoAgQhBSADKAIAIQYgASgCECIEKAIIEPQ6IQcgASkDCCEIIAEpAwAhCSAEKQMAIQpByABBCBCtNiIERQ0EIARBADoARCAEIAY2AkAgBCAINwMYIAQgCTcDECAEIAc2AgggBCAKNwMAIARB3N7CABDUGiABIAU2AhQLIANBDGogBUEIaiACEKgUIAMoAgxFDQEgAEEJNgIAQQMMAgtB7PXCABDoKwALIANBKGoiBCADQRxqKAIANgIAIAMgAykCFDcDICADKAIQIQIgAUEUahCuLCACRQ0CIAAgAykDIDcCCCAAQRBqIAQoAgA2AgAgACACNgIEIABBCDYCAEEBCzoAGCADQTBqJAAPC0EIQcgAEKM9AAtBnODCAEErIANBDGpB+ODCAEH89cIAENUeAAvqAgEGf0H9ASEEAkACQAJ/IAEoAvgHIgNB/QFNBEAgAUEEaiEGIAMMAQsgASgCCCEGIAMhBCABKAIECyIIIAJNBEACQAJAIAJB/gFPBEBBgYCAgHghBSACIARGDQUgAkECdCEHQQAhBSACQf////8DSw0FIAdBBBDRNEUNBSADQf4BSQ0CIARBAnQhAyAEQf////8DTQ0BIAMhBwwFC0GBgICAeCEFIANB/QFNDQQgAUEANgIAIAhBAnQiAgRAIAFBBGogBiAC/AoAAAsgASAINgL4ByAGIAQQoiQMBAsgA0EEENE0RQ0DQQQhBSAGIANBBCAHEJc1IgRFDQMMAgtBBCEFIAdBBBCtNiIERQ0CIAhBAnQiA0UNASAEIAYgA/wKAAAMAQtB6J3EAEEgQYiexAAQnykACyABIAI2AvgHIAEgBDYCCCABIAg2AgQgAUEBNgIAQYGAgIB4IQULIAAgBzYCBCAAIAU2AgAL5QIBBn9BOyEEAkACQAJ/IAEoAvABIgNBO00EQCABQQRqIQYgAwwBCyABKAIIIQYgAyEEIAEoAgQLIgggAk0EQAJAAkAgAkE8TwRAQYGAgIB4IQUgAiAERg0FIAJBAnQhB0EAIQUgAkH/////A0sNBSAHQQQQ0TRFDQUgA0E8SQ0CIARBAnQhAyAEQf////8DTQ0BIAMhBwwFC0GBgICAeCEFIANBO00NBCABQQA2AgAgCEECdCICBEAgAUEEaiAGIAL8CgAACyABIAg2AvABIAYgBBCiJAwECyADQQQQ0TRFDQNBBCEFIAYgA0EEIAcQlzUiBEUNAwwCC0EEIQUgB0EEEK02IgRFDQIgCEECdCIDRQ0BIAQgBiAD/AoAAAwBC0HoncQAQSBBiJ7EABCfKQALIAEgAjYC8AEgASAENgIIIAEgCDYCBCABQQE2AgBBgYCAgHghBQsgACAHNgIEIAAgBTYCAAu7AwEGf0ERIQMCQAJAAn8gASgCSCIEQRFNBEAgAUEEaiEGIAQMAQsgASgCCCEGIAQhAyABKAIECyIIIAJNBEACQAJAIAJBEk8EQEGBgICAeCEFIAIgA0YNBSACQQJ0IQdBACEFIAJB/////wNLDQUgB0EEENE0RQ0FIARBEkkNAiADQQJ0IQQgA0H/////A00NASAEIQcMBQtBgYCAgHghBSAEQRFNDQQgAUEANgIAIAhBAnQiAgRAIAFBBGogBiAC/AoAAAsgASAINgJIIwBBEGsiASQAIANBAnQhAgJAIANB/////wNNBEAgAkEEENE0DQELIAEgAjYCDCABQQA2AghBgK7MAEErIAFBCGpB8K3MAEHcrswAENUeAAsgBiACQQQQ+DogAUEQaiQADAQLIARBBBDRNEUNA0EEIQUgBiAEQQQgBxCXNSIDRQ0DDAILQQQhBSAHQQQQrTYiA0UNAiAIQQJ0IgRFDQEgAyAGIAT8CgAADAELQaywzABBIEHMsMwAEJ8pAAsgASACNgJIIAEgAzYCCCABIAg2AgQgAUEBNgIAQYGAgIB4IQULIAAgBzYCBCAAIAU2AgALxQIBA38jAEHQAGsiBSQAIAVBLGogASAEEJMOIAUoAjAhBgJAIAUoAiwiB0GKgICAeEcEQCAFQShqIAVBzABqKAIANgIAIAVBIGogBUHEAGopAgA3AgAgBUEYaiAFQTxqKQIANwIAIAUgBSkCNDcCECAFIAY2AgwgBSAHNgIIDAELIAVBLGogAUF/IAQgBmoiASABIAZJGxC0BiAFKAIwIQECQCAFKAIsIgZBioCAgHhHBEAgBUEYaiAFQTxqKAIANgIAIAVBJGogBUHIAGopAgA3AgAgBSAFKQI0NwIQIAUgBSkCQDcCHCAFIAE2AgwMAQsgASABKAIMQQFrNgIMCyAFIAY2AggLIAUgAzYCPCAFIAI2AjggBUGAgICAeDYCNCAFIAQ2AjAgBUECNgIsIAAgBUEIaiAFQSxqEIEUIAVB0ABqJAAL4QICCX8CfiMAQTBrIgIkACABKAIEIQUgASgCACEIAkACQCAAKAIAIgQgACgCBCIDRwRAIAAoAhQhByAAKAIQIQkgACgCDCEKIAAoAgghBiABKAIIIAVBBHRqIQAgAyAEa0EDdiEBA0AgAiAENgIMAkAgBCgCACIDIAlJBEAgCiADQQR0aiIDKQMIIQsgAykDACEMDAELIAYgBygCEE8NA0IAIQxCACELIAcoAgQgBiAHKAIMaiIDQQN2ai0AACADQQdxdkEBcQ0ECyAAIAw3AwAgACALNwMIIARBCGohBCAAQRBqIQAgBkEBaiEGIAVBAWohBSABQQFrIgENAAsLIAggBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC+ECAgl/An4jAEEwayICJAAgASgCBCEFIAEoAgAhCAJAAkAgACgCACIEIAAoAgQiA0cEQCAAKAIUIQcgACgCECEJIAAoAgwhCiAAKAIIIQYgASgCCCAFQQR0aiEAIAMgBGtBAnYhAQNAIAIgBDYCDAJAIAkgBCgCACIDSwRAIAogA0EEdGoiAykDCCELIAMpAwAhDAwBCyAGIAcoAhBPDQNCACEMQgAhCyAHKAIEIAYgBygCDGoiA0EDdmotAAAgA0EHcXZBAXENBAsgACAMNwMAIAAgCzcDCCAEQQRqIQQgAEEQaiEAIAZBAWohBiAFQQFqIQUgAUEBayIBDQALCyAIIAU2AgAgAkEwaiQADwtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQe0GNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAvhAgIJfwJ+IwBBMGsiAiQAIAEoAgQhBSABKAIAIQgCQAJAIAAoAgAiBCAAKAIEIgNHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEGIAEoAgggBUEEdGohACADIARrQQJ2IQEDQCACIAQ2AgwCQCAJIAQoAgAiA0sEQCAKIANBBHRqIgMpAwghCyADKQMAIQwMAQsgBiAHKAIQTw0DQgAhDEIAIQsgBygCBCAGIAcoAgxqIgNBA3ZqLQAAIANBB3F2QQFxDQQLIAAgDDcDACAAIAs3AwggBEEEaiEEIABBEGohACAGQQFqIQYgBUEBaiEFIAFBAWsiAQ0ACwsgCCAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG7EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAAL4QICCX8CfiMAQTBrIgIkACABKAIEIQUgASgCACEIAkACQCAAKAIAIgQgACgCBCIDRwRAIAAoAhQhByAAKAIQIQkgACgCDCEKIAAoAgghBiABKAIIIAVBBHRqIQAgAyAEa0EDdiEBA0AgAiAENgIMAkAgBCgCACIDIAlJBEAgCiADQQR0aiIDKQMIIQsgAykDACEMDAELIAYgBygCEE8NA0IAIQxCACELIAcoAgQgBiAHKAIMaiIDQQN2ai0AACADQQdxdkEBcQ0ECyAAIAw3AwAgACALNwMIIARBCGohBCAAQRBqIQAgBkEBaiEGIAVBAWohBSABQQFrIgENAAsLIAggBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJByBA2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC78CAgV/AX4jAEHwAGsiAiQAIAEoAgQhAyABKAIIIgUEQCADKAIEIAMoAggiBCgCCEEBa0F4cWpBCGogBCgCJBEEACEECyACIAM2AkggAiADNgJMIAIgASgCADYCUCACIAMgBUEMbGo2AlQgAkHoAGoiA0IENwIAIAJB4ABqIgVCADcCACACQoCAgIDAADcCWCACQcgAaiACQdgAaiIGIAJB5ABqEPoeIAJBQGsgAykCADcDACACQThqIAUpAgAiBzcDACACQRhqIAc+AgAgAkEoaiACQcQAaigCADYCACACIAIpAlgiBzcDMCACIAc3AxAgAiACKQI8NwMgIAJBMGoiAyABQQxqQQAgBBDyFSAGIAMQ4ScgAkEIaiACQRBqELYZIAAgAigCCCACKAIMIAJBIGogBhDLHCACQfAAaiQAC6MGAQ1/IwBBMGsiAyQAIAMgADYCAAJ/IAAtAABBIEYEQEEBIAEoAgAiCEHsyIcBQQcgASgCBCIKKAIMIgsRBgANARogACgCCCIBBEAgACgCBEEIaiEAIwBBIGsiBCQAIARBFGogACABQQJ0aiIBIABrQQJ2QQBBBEEMEKAYIAQoAhghAiAEKAIUQQFGBEAgAiAEKAIcQdzIhwEQ/S8ACyADQRhqIQkgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgAjYCCCMAQRBrIgckACABIABrQQJ2IgUgBEEIaiICKAIAIAIoAggiBmtLBEAgAiAGIAVBBEEMENwoIAIoAgghBgsgByACKAIENgIMIAcgBjYCCCAHIAJBCGo2AgQjAEFAaiICJAAgB0EEaiIFKAIEIQYgBSgCACAAIAFHBEAgBSgCCCAGQQxsaiEFIAYgASAAa0ECdiIBaiEGA0AgAiAAKAIAIg5BPGo2AiggAiAOQTBqNgIsIAJBAjYCFCACQZjchwE2AhAgAkICNwIcIAJBpwQ2AjwgAkH0GzYCNCACIAJBMGo2AhggAiACQSxqNgI4IAIgAkEoajYCMCACQQRqIAJBEGoQmQ4gBUEIaiACQQxqKAIANgIAIAUgAikCBDcCACAAQQRqIQAgBUEMaiEFIAFBAWsiAQ0ACwsgBjYCACACQUBrJAAgB0EQaiQAIAlBCGogDCgCADYCACAJIAQpAgg3AgAgBEEgaiQAIANBBGogAygCHCIAIAMoAiAiAUHzyIcBQQIQ8QMgAQRAA0AgAEEBQQEQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsgA0EYaiIAQQRBDBDgHiADQQE2AhwgA0H4yIcBNgIYIANCATcCJCADQeMcNgIUIAMgA0EQajYCICADIANBBGoiATYCECAIIAogABDLCiEAIAFBAUEBEOAeQQEgAA0CGgsgCEGAyYcBQQEgCxEGAAwBCyADQQE2AhwgA0H4yIcBNgIYIANCATcCJCADQa8DNgIIIAMgA0EEajYCICADIAM2AgQgASgCACABKAIEIANBGGoQywoLIANBMGokAAv8CAIPfwR+IwBBEGsiCyQAIAFBEGoiBiACEO4LIRQgASgCBCIEIBSncSEDIBRCGYhC/wCDQoGChIiQoMCAAX4hFSACKAIIIQggAigCBCEJIAEoAgAhBQJAAkADQAJAIAMgBWopAAAiEyAVhSISQn+FIBJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiElBFBEADQCAFIBJ6p0EDdiADaiAEcUEGdGsiB0E8aygCACAHQThrKAIAIAkgCBDkHA0CIBJCAX0gEoMiElBFDQALCyATIBNCAYaDQoCBgoSIkKDAgH+DUEUNAiADIApBCGoiCmogBHEhAwwBCwsgAEGAgICAeDYCCCAAIAE2AgQgACAHNgIAIAIQ0SsgAhDoOwwBCyABKAIIRQRAIAtBCGohCiMAQdAAayIDJAAgAyAGNgIcIAEoAgwhCCADIANBHGo2AiACQAJAIAggCEEBaiIETQRAAkAgASgCBCIFIAVBAWpBA3ZBB2wgBUEISRsiBUEBdiAESQRAAn8gBUEBaiIFIAQgBCAFSRsiBEEPTwRAIARB/////wFLDQVBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgBEEISRsgBEEESRsLIQQgA0FAayABQRBqIgZBwABBCCAEEJ0UIAMoAkQhBSADKAJAIgdFBEAgAygCSCEEDAULIAMpAkghEiAFQQlqIgQEQCAHQf8BIAT8CwALIAMgEkIgiD4CPCADIBKnIg02AjggAyAFNgI0IAMgBzYCMCADQsCAgICAATcCKCADIAY2AiQgA0EwaiEOIAMgCAR/IAdBCGohDyABKAIAIgwpAwBCf4VCgIGChIiQoMCAf4MhEkEAIQQDQCASUARAA0AgBEEIaiEEIAxBCGoiDCkDAEKAgYKEiJCgwIB/gyISQoCBgoSIkKDAgH9RDQALIBJCgIGChIiQoMCAf4UhEgsgByAFIAMoAhwgASgCACASeqdBA3YgBGoiEEEGdGtBQGoQ7gunIhFxIgZqKQAAQoCBgoSIkKDAgH+DIhNQBEBBCCEJA0AgBiAJaiEGIAlBCGohCSAHIAUgBnEiBmopAABCgIGChIiQoMCAf4MiE1ANAAsLIAcgE3qnQQN2IAZqIAVxIgZqLAAAQQBOBEAgBykDAEKAgYKEiJCgwIB/g3qnQQN2IQYLIAYgB2ogEUEZdiIJOgAAIA8gBkEIayAFcWogCToAACAHIAZBf3NBBnRqIAEoAgAgEEF/c0EGdGpBwAD8CgAAIBJCAX0gEoMhEiAIQQFrIggNAAsgASgCDAVBAAsiBDYCPCADIA0gBGs2AjggASAOQQQQ+iogA0EkahDQJgwBCyABIANBIGpB3KTPAEHAABDFCQtBgYCAgHghBQwCCxDjJyADKAIMIQQgAygCCCEFDAELEOMnIAMoAhQhBCADKAIQIQULIAogBDYCBCAKIAU2AgAgA0HQAGokAAsgACABNgIUIAAgFDcDACAAIAIpAgA3AgggAEEQaiACQQhqKAIANgIACyALQRBqJAALzgIBCH9BCiEDIAEiBEHoB08EQCACQQRrIQggBCEFA0AgAyAIaiIGQQFqIAUgBUGQzgBuIgRBkM4AbGsiB0H//wNxQeQAbiIJQQF0IgpB4/OJAWotAAA6AAAgBiAKQeLziQFqLQAAOgAAIAZBA2ogByAJQeQAbGtB//8DcUEBdCIHQePziQFqLQAAOgAAIAZBAmogB0Hi84kBai0AADoAACADQQRrIQMgBUH/rOIESyAEIQUNAAsLAkAgBEEJTQRAIAQhBQwBCyACIANqQQFrIAQgBEH//wNxQeQAbiIFQeQAbGtB//8DcUEBdCIEQePziQFqLQAAOgAAIAIgA0ECayIDaiAEQeLziQFqLQAAOgAAC0EAIAEgBRtFBEAgAiADQQFrIgNqIAVBAXRBHnFB4/OJAWotAAA6AAALIABBCiADazYCBCAAIAIgA2o2AgAL1gIBAX8jAEFAaiIDJAAgAyACNgIEIAMgATYCAAJAIAFBgAFrQf99TQRAIANBATYCJCADQbjqzQA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgAzYCOCADQQhqQQRyIANBIGoQmQ4gACADKQANNwAFIABBDWogA0EVaikAADcAACAAQRRqIANBHGooAAA2AAAgACADLQAMOgAEIABBAzYCAAwBCyACQYACTwRAIANBATYCJCADQeDqzQA2AiAgA0IBNwIsIANBnAM2AjwgAyADQThqNgIoIAMgA0EEajYCOCADQQhqQQRyIANBIGoQmQ4gACADKQANNwAFIABBDWogA0EVaikAADcAACAAQRRqIANBHGooAAA2AAAgACADLQAMOgAEIABBAzYCAAwBCyAAIAE6AAYgACACOgAFIABBJToABCAAQQg2AgALIANBQGskAAvWAgEBfyMAQUBqIgMkACADIAI2AgQgAyABNgIAAkAgAUGAAWtB/31NBEAgA0EBNgIkIANBuOrNADYCICADQgE3AiwgA0GcAzYCPCADIANBOGo2AiggAyADNgI4IANBCGpBBHIgA0EgahCZDiAAIAMpAA03AAUgAEENaiADQRVqKQAANwAAIABBFGogA0EcaigAADYAACAAIAMtAAw6AAQgAEEDNgIADAELIAJBgAJPBEAgA0EBNgIkIANB4OrNADYCICADQgE3AiwgA0GcAzYCPCADIANBOGo2AiggAyADQQRqNgI4IANBCGpBBHIgA0EgahCZDiAAIAMpAA03AAUgAEENaiADQRVqKQAANwAAIABBFGogA0EcaigAADYAACAAIAMtAAw6AAQgAEEDNgIADAELIAAgAToABiAAIAI6AAUgAEEmOgAEIABBCDYCAAsgA0FAayQAC7oRAhZ/BX4jAEEgayIPJAACQCABLQCUAUUNACABKAKMASIGKAIUIgdBCGogBygCCEECRkECdGotACFBFkYNACAGQQhqIQsgD0EMaiIJIAIiByAHIANBAnRqIgRGBH9BAAUCQCAEIAdBBGoiCEYEQCAHIQYMAQsgByEGA0AgCCAGIAsgBiAIEOwVGyEGIAggByALIAggBxDsFRshByAIQQRqIgggBEcNAAsLIAkgBygCADYCCCAJIAYoAgA2AgRBAQs2AgAgDygCDEEBRw0AIA8gDygCECIGNgIYIA8gDygCFCIHNgIcAkAgASgCEEEBRgRAIAsgAUEUaiAPQRhqEOwVRQ0BCyABIAY2AhQgAUEBNgIQCyABKAIYQQFGBEAgCyAPQRxqIAFBHGoQ7BVFDQELIAEgBzYCHCABQQE2AhgLIANFIAEoAoABQYCAgIB4RnJFBEAgAUGAAWohBCADQQJ0IQYgAiEHA0AgBCAHQQQQhgoQohUgB0EEaiEHIAZBBGsiBg0ACwsCQCABKAJoQYCAgIB4RwRAIAFBIGoiBkHIAGogAxDsLSADBEAgA0ECdCEBA0AjAEEwayISJAAgEkEYaiEDIAZBEGoiBCACQQQQzQIhHCAGQTBqIQdBACENQQAhFEEAIRNBACEVQQAhFiMAQRBrIhckACAGKAIIRQRAAkAgF0EIaiEYIwBB4ABrIgUkACAFIAc2AhwgBSAENgIYIAYoAgwhBCAFIAVBGGo2AiACQAJAAkACQAJAIAQgBEEBaiIJTQRAIAYoAgQiBCAEQQFqQQN2QQdsIARBCEkbIgRBAXYgCUkEQCAEQQFqIgQgCSAEIAlLGyIEQQ9JDQIgBEH/////AU0EQEF/IARBA3RBB25BAWtndkEBaiENDAQLEN0nIAUoAhQhDSAFKAIQIg5BgYCAgHhHDQUMAwsgBiAFQSBqQaykzwAQ6wkMAwsQ3ScgBSgCBCENIAUoAgAhDgwDC0EEQQhBECAEQQhJGyAEQQRJGyENCyAFQdAAaiAGQRBqIglBCCANEPsUIAUoAlghDSAFKAJUIQ4gBSgCUCIERQ0BIAUgBSgCXDYCTCAFIA02AkggBSAONgJEIAUgBDYCQCAFQQhqIAVBQGsQwTQgBSgCDCIEBEAgBSgCCEH/ASAE/AsACyAFKAJIIQ0gBSgCRCEOIAUoAkAiEEUNASAFIAUoAkw2AjwgBSANNgI4IAUgDjYCNCAFIBA2AjAgBUKIgICAgAE3AiggBSAJNgIkIAUgBigCDCIZBH8gEEEIaiEMIAYoAgAiESkDAEJ/hUKAgYKEiJCgwIB/gyEbA0AgG1AEQANAIBRBCGohFCARQQhqIhEpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRsLIAUoAiAiCCgCBCIJKAIIIgQgBigCACAbeqdBA3YgFGpBA3QiC2tBCGsoAgAiCk0NBCAQIA4gCCgCACAJKAIEIApBAnRqQQQQzQKnIglxIgpqKQAAQoCBgoSIkKDAgH+DIhpQBEBBCCEIA0AgCCAKaiEEIAhBCGohCCAQIAQgDnEiCmopAABCgIGChIiQoMCAf4MiGlANAAsLIBtCAX0gG4MhGyAQIBp6p0EDdiAKaiAOcSIKaiwAAEEATgRAIBApAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAKIBBqIAlBGXYiBDoAACAMIApBCGsgDnFqIAQ6AAAgECAKQQN0a0EIayAGKAIAIAtrQQhrKQAANwAAIBlBAWsiGQ0ACyAGKAIMBUEACyIENgI8IAUgDSAEazYCOCAGIAVBMGpBBBD6KiAFQSRqEPUnC0GBgICAeCEOCyAYIA02AgQgGCAONgIAIAVB4ABqJAAMAQsgCiAEQZSQzgAQwyEACwsgBigCBCIKIByncSERIBxCGYhC/wCDQoGChIiQoMCAAX4hHiAHKAIEIQkgBygCCCEIIAYoAgAhDANAAkAgDCARaikAACIdIB6FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEbAn8CQAJAIAMCfgJAA0AgG1ANASAIIAYoAgAgG3qnQQN2IBFqIApxIgRBA3RrQQhrKAIAIgtNDQMgG0IBfSAbgyEbIAJBBCAJIAtBAnRqQQQQnztFDQALIAMgHDcDCCADIAYoAgBBACAEa0EDdGo2AhBCAAwBCyAdQoCBgoSIkKDAgH+DIRogFUUEQCAaUA0DIBp6p0EDdiARaiAKcSETC0EBIBogHUIBhoNQDQMaIAMgDCATaiwAAEEATgR/IAwpAwBCgIGChIiQoMCAf4N6p0EDdgUgEws2AhAgAyAcNwMIQgELNwMAIAMgBjYCFCAXQRBqJAAMAwsgCyAIQZSQzgAQwyEAC0EACyEVIBEgFkEIaiIWaiAKcSERDAELCyASQQhqIQgCQCADKAIAQQFGBEAgAykDCCEaIAMoAhAhCyADKAIUIQwgByAHKAIMQQRqNgIMIAIoAgAhAyAHKAIIIgkgBygCAEYEQCAHQaSQzgAQnSgLIAcoAgQgCUECdGogAzYCACAHIAlBAWo2AgggCyAMKAIAIgRqIgMtAAAhByADIBqnQRl2IgM6AAAgBCAMKAIEIAtBCGtxakEIaiADOgAAIAggDDYCDCAIIBo3AwAgDCAMKAIMQQFqNgIMIAggBCALQQN0ayIDNgIIIAwgDCgCCCAHQQFxazYCCCADQQhrIAmtNwMADAELIAggA0EIaiIDKQMANwMAIAhBCGogA0EIaikDADcDAAsgEigCEEEIaykDACEaIBJBMGokACAGKAJQIgMgBigCSEYEQCAGQcgAakHUkM4AELMoCyAGKAJMIANBA3RqIBo3AwAgBiADQQFqNgJQIAJBBGohAiABQQRrIgENAAsLIABBCDYCAAwBCyAAIAEoAnggAiADIAEoAnwoAgwRBQALIA9BIGokAAu8EQIWfwV+IwBBMGsiDyQAAkAgAS0ApAFFDQAgASgCnAEiBigCFCIHQQhqIAcoAghBAkZBAnRqLQAhQRZGDQAgBkEIaiELIA9BCGoiCSACIgcgByADQQN0aiIERgR+QgAFAkAgBCAHQQhqIghGBEAgByEGDAELIAchBgNAIAggBiALIAYgCBDzGxshBiAIIAcgCyAIIAcQ8xsbIQcgCEEIaiIIIARHDQALCyAJIAcpAwA3AxAgCSAGKQMANwMIQgELNwMAIA8oAghBAUcNACAPIA8pAxAiHDcDICAPIA8pAxgiGjcDKAJAIAEoAgBBAUYEQCALIAFBCGogD0EgahDzG0UNAQsgASAcNwMIIAFCATcDAAsgASgCEEEBRgRAIAsgD0EoaiABQRhqEPMbRQ0BCyABIBo3AxggAUIBNwMQCyADRSABKAKQAUGAgICAeEZyRQRAIAFBkAFqIQQgA0EDdCEGIAIhBwNAIAQgB0EIEIYKEKIVIAdBCGohByAGQQhrIgYNAAsLAkAgASgCeEGAgICAeEcEQCABQTBqIgZByABqIAMQ7C0gAwRAIANBA3QhAQNAIwBBMGsiEiQAIBJBGGohAyAGQRBqIgQgAkEIEM0CIR0gBkEwaiEHQQAhDUEAIRRBACETQQAhFUEAIRYjAEEQayIXJAAgBigCCEUEQAJAIBdBCGohGCMAQeAAayIFJAAgBSAHNgIcIAUgBDYCGCAGKAIMIQQgBSAFQRhqNgIgAkACQAJAAkACQCAEIARBAWoiCU0EQCAGKAIEIgQgBEEBakEDdkEHbCAEQQhJGyIEQQF2IAlJBEAgBEEBaiIEIAkgBCAJSxsiBEEPSQ0CIARB/////wFNBEBBfyAEQQN0QQduQQFrZ3ZBAWohDQwECxDdJyAFKAIUIQ0gBSgCECIOQYGAgIB4Rw0FDAMLIAYgBUEgakGkpc8AEOsJDAMLEN0nIAUoAgQhDSAFKAIAIQ4MAwtBBEEIQRAgBEEISRsgBEEESRshDQsgBUHQAGogBkEQaiIJQQggDRD7FCAFKAJYIQ0gBSgCVCEOIAUoAlAiBEUNASAFIAUoAlw2AkwgBSANNgJIIAUgDjYCRCAFIAQ2AkAgBUEIaiAFQUBrEME0IAUoAgwiBARAIAUoAghB/wEgBPwLAAsgBSgCSCENIAUoAkQhDiAFKAJAIhBFDQEgBSAFKAJMNgI8IAUgDTYCOCAFIA42AjQgBSAQNgIwIAVCiICAgIABNwIoIAUgCTYCJCAFIAYoAgwiGQR/IBBBCGohDCAGKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhGwNAIBtQBEADQCAUQQhqIRQgEUEIaiIRKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEbCyAFKAIgIggoAgQiCSgCCCIEIAYoAgAgG3qnQQN2IBRqQQN0IgtrQQhrKAIAIgpNDQQgECAOIAgoAgAgCSgCBCAKQQN0akEIEM0CpyIJcSIKaikAAEKAgYKEiJCgwIB/gyIaUARAQQghCANAIAggCmohBCAIQQhqIQggECAEIA5xIgpqKQAAQoCBgoSIkKDAgH+DIhpQDQALCyAbQgF9IBuDIRsgECAaeqdBA3YgCmogDnEiCmosAABBAE4EQCAQKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCiAQaiAJQRl2IgQ6AAAgDCAKQQhrIA5xaiAEOgAAIBAgCkEDdGtBCGsgBigCACALa0EIaykAADcAACAZQQFrIhkNAAsgBigCDAVBAAsiBDYCPCAFIA0gBGs2AjggBiAFQTBqQQQQ+iogBUEkahD1JwtBgYCAgHghDgsgGCANNgIEIBggDjYCACAFQeAAaiQADAELIAogBEGUkM4AEMMhAAsLIAYoAgQiCiAdp3EhESAdQhmIQv8Ag0KBgoSIkKDAgAF+IRwgBygCBCEJIAcoAgghCCAGKAIAIQwDQAJAIAwgEWopAAAiHiAchSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGwJ/AkACQCADAn4CQANAIBtQDQEgCCAGKAIAIBt6p0EDdiARaiAKcSIEQQN0a0EIaygCACILTQ0DIBtCAX0gG4MhGyACQQggCSALQQN0akEIEJ87RQ0ACyADIB03AwggAyAGKAIAQQAgBGtBA3RqNgIQQgAMAQsgHkKAgYKEiJCgwIB/gyEaIBVFBEAgGlANAyAaeqdBA3YgEWogCnEhEwtBASAaIB5CAYaDUA0DGiADIAwgE2osAABBAE4EfyAMKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBMLNgIQIAMgHTcDCEIBCzcDACADIAY2AhQgF0EQaiQADAMLIAsgCEGUkM4AEMMhAAtBAAshFSARIBZBCGoiFmogCnEhEQwBCwsgEkEIaiEIAkAgAygCAEEBRgRAIAMpAwghHCADKAIQIQsgAygCFCEMIAcgBygCDEEIajYCDCACKQMAIRogBygCCCIJIAcoAgBGBEAgB0GkkM4AELMoCyAHKAIEIAlBA3RqIBo3AwAgByAJQQFqNgIIIAsgDCgCACIEaiIDLQAAIQcgAyAcp0EZdiIDOgAAIAQgDCgCBCALQQhrcWpBCGogAzoAACAIIAw2AgwgCCAcNwMAIAwgDCgCDEEBajYCDCAIIAQgC0EDdGsiAzYCCCAMIAwoAgggB0EBcWs2AgggA0EIayAJrTcDAAwBCyAIIANBCGoiAykDADcDACAIQQhqIANBCGopAwA3AwALIBIoAhBBCGspAwAhGiASQTBqJAAgBigCUCIDIAYoAkhGBEAgBkHIAGpB1JDOABCzKAsgBigCTCADQQN0aiAaNwMAIAYgA0EBajYCUCACQQhqIQIgAUEIayIBDQALCyAAQQg2AgAMAQsgACABKAKIASACIAMgASgCjAEoAgwRBQALIA9BMGokAAvbAgIGfwF9IwBBEGsiBCQAIAQgAUECIAJBAXMgAxtBB3RqIgEoAswDNgIEIAQgASgCjAQ2AgAgBEEANgIMIARBADYCCCABQcwDaiEHQQEhBQNAIAcgBUECdGohCCAEQQxqIQYgBEEEaiECQQEhA0EAIQEDQCAIIAFBBnRqKgIAIgogAioCAF0EQCACIAo4AgAgBiAFNgIAC0EBIQEgA0EBcSAEQQhqIQYgBCECQQAhAw0ACyAFQQFqIgVBEEcNAAsCQCAEKAIMIgFBEEkEQCAEKAIIIgJBEE8NASAAIAQoAgA2AgwgACAEKAIENgIIIAAgAkEBdCICQYjlzgBqLwEAOwEGIAAgAkHY5M4Aai8BADsBBCAAIAFBAXQiAUGI5c4Aai8BADsBAiAAIAFB2OTOAGovAQA7AQAgBEEQaiQADwsgAUEQQfjkzgAQwyEACyACQRBBqOXOABDDIQALxAIBA38jAEEwayIIJAACQAJAIANFDQAgA0EBdCEKAkADQCAFIAIvAQAiCUEBaiIDTQRAIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQMgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIANBA3RqKAIAIgMgBCAJQQN0aigCACIJTwRAIAMgB0sNAiAIQRhqIAEgBiAJaiADIAlrQQAQlxQgCCgCGCIDQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkECaiECIApBAmsiCkUNAwwBCwsgCSADQZDK0AAQsTsACyADIAdBkMrQABCwOwALQQghAwsgACADNgIAIAhBMGokAAvEAgEDfyMAQTBrIggkAAJAAkAgA0UNACADQQF0IQoCQANAIAUgAi8BACIJQQFqIgNNBEAgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhAyAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgA0ECdGooAgAiAyAEIAlBAnRqKAIAIglPBEAgAyAHSw0CIAhBGGogASAGIAlqIAMgCWtBABCfFCAIKAIYIgNBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQJqIQIgCkECayIKRQ0DDAELCyAJIANBkMrQABCxOwALIAMgB0GQytAAELA7AAtBCCEDCyAAIAM2AgAgCEEwaiQAC+8NAgh/AX4jAEGgAWsiASQAIwBBwAFrIgUkACAFQSxqIgZBgIACQeTF0AAQzhggBUEIaiAGQfTF0AAQkCEgBUIANwIkIAUgAzYCGCAFIAI2AhQgBSAFKQMINwIcIAVBOGohAyMAQfABayICJAAgAkEMaiIGEM0rIAJB+ABqIAYgBUEUaiIGEPYDAn8CQAJAIAItAHgiB0EERwRAAn8CQAJAAkAgB0EBaw4DAAECBgsgAi0AeQwCCyACKAJ8LQAIDAELIAIoAnwtAAgLQf8BcUENRw0CIAIpAhAhDyACKAIMIQcgAkHUAGogAkEYakEk/AoAACACQdAAaiACQcQAaigCADYCACACIAIpAjw3A0ggAkH4AGoQuS4MAQsgAkGwAWoiByACQQxqQTz8CgAAIAJBgAFqIAcQkCsgAikDgAEhDyACQdQAaiACQYgBakEk/AoAAEGBgICAeCEHC0EADAELQYOAgIB4IQcgAikDeCEPQQELIAJBkAFqIgogBkEQaikCADcDACACQYgBaiIJIAZBCGopAgA3AwAgAiAGKQIANwOAASACQcgBahDAHyACQcABaiAKKQMANwMAIAJBuAFqIAkpAwA3AwAgAiACKQOAATcDsAEgA0EwahCPKyADIAJBsAFqQTD8CgAAIAMgDzcCTCADIAc2AkggA0HUAGogAkHUAGpBJPwKAAAgA0EAOgCEASADQYABaiACQdAAaigCADYCACADIAIpA0g3AngEQCACQQxqENUuCyACQfABaiQAIAVBAToAvAEgAUEIaiIKIANBiAH8CgAAIAVBwAFqJAAgAUGQAWohBiMAQTBrIgUkAEGAwAAhCAJAAkAgBCgCACINIAQoAggiA2tBIE8EQCADIQIMAQsgBUEQaiAKIAQQlRMCQCAFLQAQQQRGBEAgBSgCFCECDAELIAUpAxAiD0IgiKchAiAPpyIHQf8BcUEERg0AIAYgAjYCBCAGIAc6AAAgBkEDaiAHQRh2OgAAIAYgB0EIdjsAAQwCCyACBEAgBCgCCCECDAELIAZBBDoAACAGQQA2AgQMAQsDQAJAIAIgBCgCACIHRyAHIA1Hcg0AIAVBEGogCiAEEJUTAkAgBS0AEEEERgRAIAUoAhQhBwwBCyAFKQMQIg9CIIinIQcgD6ciAkH/AXFBBEYNACAGIAc2AgQgBiACOgAAIAZBA2ogAkEYdjoAACAGIAJBCHY7AAEMAwsgBCgCCCECIAcEQCAEKAIAIQcMAQsgBkEEOgAAIAYgAiADazYCBAwCCwJAAkACQAJAIAIgB0YEQCAFQQhqIAQgBxC0ICAFKAIIQYGAgIB4Rw0BIAQoAgAhByAEKAIIIQILIAQoAgQhCSAFIAs2AhwgBUEANgIYIAUgAiAJajYCECAFIAggByACayICIAIgCEsbIgk2AhQgBUEgaiAKIAVBEGoQgxYgBS0AICICQQRHDQEMAgsgBkKBzAA3AgAMBAsDQEEAIQcCQAJAAkACQCACQf8BcUEBaw4DAQIABgsgBSgCJC0ACEEjRw0FDAILIAUtACFBI0YNAQwECyAFKAIkLQAIQSNHDQMLIAUgBSkDIDcDKCAFQShqELkuIAVBIGogCiAFQRBqEIMWIAUtACAiAkEERw0ACwtBASEHCyAEIAUoAhgiCyAEKAIIaiICNgIIIAUoAhwhDAJAIAcNACAFKQMgIg+nIgdB/wFxQQRGDQAgBiAHOgAAIAZBB2ogD0I4iDwAACAGQQVqIA9CKIg9AAAgBiAPQgiIPgABDAILIAsEQCAJIAtHIAlBfyAIIA5BAWpBACAJIAtLGyIOQQFKGyAIIAkgDEcbIghJckUEQEF/IAhBAXQgCEEASBshCAsgDCALayELDAEFIAZBBDoAACAGIAIgA2s2AgQLCwsgBUEwaiQAAkAgAS0AkAFBBEcEQCABIAEpA5ABNwOYASAAIAFBmAFqEIErDAELIAAgASgClAE2AgQgAEEINgIACwJAAkACQAJAAkACQEGAgICAeCABKAJQIgAgAEGAgICAeE0bQf////8HcQ4EAQIDBAALIAEoAlRBgYCAgHhGDQQgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMBAsgAUHQAGoCQAJAIAEtAHxBAWsOBQAAAAAAAQsgASgCgAEiAkUNACACQRhBCBD4OgsQhjAgAUHcAGoQhjAgAUHoAGoQhjAMAwsgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMAgsgAUHUAGoQhjAgAUHgAGoQhjAgAUHsAGoQhjAMAQsgAUHUAGoQuS4LIAEoAhQiAARAIAEoAhAgAEEBEPg6CyABKAIwEJIrIAFBMGoQhjsgAUGgAWokAAviAgIGfwF+IwBBQGoiASQAAkACQCAAKAJYBEAgACkCUCEHIABCgICAgBA3A1AgAUEQaiAAQdgAaiICKAIANgIAIAJBADYCACABIAc3AwggAUEYaiABQQhqEPIvIAEgASkCGDcCNCABQQA2AjAgASABKAIkIgM2AiwgASABKAIgNgIoIAEgAUEoahDXOyABKAIAIQZBHEEEEK02IgJFDQEgAkKBgICAEDcCACACIAEpAig3AgggAkEQaiABQTBqKQIANwIAIAJBGGogAUE4aigCADYCACADQX9GDQIgACgCTCIEIAAoAkRGBEAgAEHEAGpB2OuAARCQKAsgACgCSCAEQQxsaiIFIAM2AgggBSAGNgIEIAUgAjYCACAAIARBAWo2AkwLIAFBQGskAA8LQQRBHBCjPQALIAFBADYCOCABQQE2AiwgAUHA64ABNgIoIAFCBDcCMCABQShqQcjrgAEQ7ywAC7kCAQV/QQtBACAAQYCPBE8bIgIgAkEFaiIBIABBC3QiAiABQQJ0QcCSigFqKAIAQQt0SRsiASABQQNqIgEgAUECdEHAkooBaigCAEELdCACSxsiASABQQFqIgEgAUECdEHAkooBaigCAEELdCACSxsiASABQQFqIgEgAUECdEHAkooBaigCAEELdCACSxsiAUECdEHAkooBaigCAEELdCIEIAJGIAIgBEtqIAFqIgRBAnRBwJKKAWoiBSgCAEEVdiECQb8CIQECQCAEQRRNBEAgBSgCBEEVdiEBIARFDQELIAVBBGsoAgBB////AHEhAwsCQCABIAJBf3NqRQ0AIAAgA2shAyABQQFrIQFBACEAA0AgACACQc3MiQFqLQAAaiIAIANLDQEgASACQQFqIgJHDQALCyACQQFxC8cCAQJ/IwBBMGsiAyQAAkAgAkEhSQRAIAJFDQECQCABLAAAQQBIBEAgA0EgakJ/NwMAIANBGGpCfzcDACADQRBqQn83AwAgA0J/NwMIDAELIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCAsgAyABNgIoIAMgASACajYCLAJAIANBKGoQgzsiBEUNACAEIAIgAiAESxsiBEUNACADIAJrQShqIAEgBPwKAAALIAAgAykDCDcAACAAQRhqIANBIGopAwA3AAAgAEEQaiADQRhqKQMANwAAIABBCGogA0EQaikDADcAACADQTBqJAAPCyADQQE2AgwgA0H0/M4ANgIIIANCATcCFCADQTs2AiwgA0HM/M4ANgIoIAMgA0EoajYCECADQQhqQfz8zgAQ7ywAC0EAQQBBjP3OABDDIQAL3gIBA38jAEEgayIGJABBgIAIQYCAAiADGyIHIAQgBCAHSxshCEGAAiEEA0AgBCIHQQF0IQQgByAISQ0ACwJAAkAgByAEIAdBgNQqcSADchsiBEGBCE8EQCACKAIAIQEgAigCBCIDIARJBEAgBkEANgIcIAZCgICAgMAANwIUIAZBCGogBkEUakGMh84AEJghIAYoAgghByACIAYoAgwiCDYCBCACIAc2AgAgAwRAIAEgA0ECdEEEEPg6CyAGQRRqIgFBACAEQcSe0AAQsxUgBiABQcyCzgAQmCEgBigCBCEDIAYoAgAhASAIBEAgByAIQQJ0QQQQ+DoLIAIgAzYCBCACIAE2AgALIAUgBDYCACADIARPDQEgBCADQfy60AAQsDsACyAFIAQ2AgBBgAghAyAERQ0BCyAEQQJ0IgJFDQAgAUEAIAL8CwALIAAgAzYCBCAAIAE2AgAgBkEgaiQAC80CAQF/IwBBQGoiBCQAIAQgAjYCCCAEIAM2AgwgASgCGEF/IAIgA2oiAyACIANLG08EQCABKAIIIQIgBCABKAIEIgM2AiggBCADIAJBA3RqNgIsIAQgBEEMajYCNCAEIARBCGo2AjAgBEEQaiAEQShqIgJB0OqFARCfGyAEQRxqIAFBDGoQ1gYCQCABKAIcBEAgAiABQRxqIAQoAgggBCgCDBCxHwwBCyAEQQA2AigLIAAgBCgCDDYCGCAAIAQpAhw3AgwgACAEKQIoNwIcIAAgBCkCEDcCACAAQRRqIARBJGooAgA2AgAgAEEkaiAEQTBqKQIANwIAIABBLGogBEE4aikCADcCACAAQQhqIARBGGooAgA2AgAgBEFAayQADwsgBEEANgI4IARBATYCLCAEQYz5hQE2AiggBEIENwIwIARBKGpBlPmFARDvLAALzwIBBX8jAEEwayIBJAAgAUEIaiAAQRhqEOYLIAEoAhAiAiAAKAIIIgMgAiADSRsiBQRAIAAoAgQhAiABKAIMIQMDQAJAIAMoAgANACADQQhqKAIAIgRpQQFGBEAgAkEEaigCACAEEPgvRQ0BIAEgAhDcOyABQRhqIAEoAgAgASgCBBD9FCACKAIAIgQgBCgCACIEQQFrNgIAIARBAUYEQCACEPseCyACIAEpAhg3AgAgAkEIaiABQSBqKAIANgIADAELIAFBADYCKCABQQE2AhwgAUGw2oYBNgIYIAFCBDcCICABQRhqQbjahgEQ7ywACyACQQxqIQIgA0EMaiEDIAVBAWsiBQ0ACwsgACgCFCIDBEAgACgCECECIANBxABsIQMDQCACEL4QIAJBxABqIQIgA0HEAGsiAw0ACwsgAUEIakEEQQwQ4B4gAUEwaiQAC8kCAQZ/IwBBEGsiAiQAAkAgAC4BACIFIAXBQQ91IgBzIABrIgNB//8DcSIEQegHTwRAQQEhACACIAMgBEGQzgBuIgNBkM4AbGsiBEH//wNxQeQAbiIGQQF0IgdB4/OJAWotAAA6AA0gAiAHQeLziQFqLQAAOgAMIAIgBCAGQeQAbGtB//8DcUEBdCIEQePziQFqLQAAOgAPIAIgBEHi84kBai0AADoADgwBC0EFIQAgBEEKSQ0AIAIgAyADQf//A3FB5ABuIgNB5ABsa0H//wNxQQF0IgBB4/OJAWotAAA6AA8gAiAAQeLziQFqLQAAOgAOQQMhAAtBACAFIANB//8DcRtFBEAgAEEBayIAIAJBC2pqIANBAXRBHnFB4/OJAWotAAA6AAALIAEgBUEATkEBQQAgAkELaiAAakEFIABrEIEJIAJBEGokAAvVAgEDfyMAQRBrIgQkAAJAAkACQAJAIAIoAggiBUEETwRAIAIoAgQoAAAiBiAFQQRrSw0BIAEQkSogAUEBOgA8IAFBADYCOCABQgA3AzAgAUEANgIQIAFCADcDACAEIAJBBCAGQQRqENIQIAEgBBDKDyABIAM2AkAgAEEINgIADAMLIARBGkEAQQFBARCgGCAEKAIEIQEgBCgCAEEBRg0DDAELIARBGkEAQQFBARCgGCAEKAIEIQEgBCgCAEEBRw0ADAILIAQoAggiA0EYakHwqM4ALwAAOwAAIANBEGpB6KjOACkAADcAACADQQhqQeCozgApAAA3AAAgA0HYqM4AKQAANwAAIABBGjYCDCAAIAM2AgggACABNgIEIABBAjYCAAsgAkEMaiACKAIEIAIoAgggAigCACgCEBEBACAEQRBqJAAPCyABIAQoAghB2KfOABD9LwALywMAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4PAQIDBAUGBwgJCgsMDQ4PAAsgASgCAEHEpf4AQQQgASgCBCgCDBEGAA8LIAEoAgBByKX+AEEEIAEoAgQoAgwRBgAPCyABKAIAQcyl/gBBBCABKAIEKAIMEQYADwsgASgCAEHQpf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB06X+AEEGIAEoAgQoAgwRBgAPCyABKAIAQdml/gBBAyABKAIEKAIMEQYADwsgASgCAEHcpf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB36X+AEEDIAEoAgQoAgwRBgAPCyABKAIAQeKl/gBBBiABKAIEKAIMEQYADwsgASgCAEHopf4AQQQgASgCBCgCDBEGAA8LIAEoAgBB7KX+AEEGIAEoAgQoAgwRBgAPCyABKAIAQfKl/gBBAyABKAIEKAIMEQYADwsgASgCAEH1pf4AQQMgASgCBCgCDBEGAA8LIAEoAgBB+KX+AEEEIAEoAgQoAgwRBgAPCyABKAIAQfyl/gBBBCABKAIEKAIMEQYADwsgASgCAEGApv4AQQUgASgCBCgCDBEGAAv6CwENfyMAQaABayIHJAAgB0EgaiEIIwBBMGsiBCQAAkACQAJAIAMQyzpFBEAgAygCACIMIAwoAgAiBkEBajYCACAGQQBIDQIgAygCECEPIAMoAgwhDSADKAIIIQ4gAygCBCEQIAMoAhQiBgRAIAYgBigCACIFQQFqNgIAIAVBAEgNAyADKAIoIQUgAygCJCEKIAMoAiAhCyADKAIcIQkgAygCGCEDCyAEIAU2AiwgBCAKNgIoIAQgCzYCJCAEIAk2AiAgBCADNgIcIAQgBjYCGCAEIA82AhQgBCANNgIQIAQgDjYCDCAEIBA2AgggBCAMNgIEDAELIARBBGogAxDaJwsCf0EFIARBBGoiBhDnOiIDRSAGKAIQIgZFcg0AGkEEIAMgBkYNABogA7ggBrijRJqZmZmZmek/ZEULIQYgCEEQaiAEQQRqQSz8CgAAIAggBjYCACAIIAM2AjwgBEEwaiQADAELAAsgASACKAIcEQQAIQMCQANAAkACQCADLQAAIgRBIEcEQCAEQSFHDQQgAy0AAQ0EIANBBGoQjj5FDQEMBAsgB0EYaiADQQRqIgMQwzQgBygCHEEBTQ0BCyAHQeAAaiIIIAdBIGoiD0HAAPwKAAAjAEHQAGsiBiQAAkACQAJAIAgoAgAOAgABAgsgBkEQaiIEIAhBEGoQyTQgBkEEaiEKIwBB4ABrIgMkACADQRRqIAQQ1QkCQAJAAkAgAygCFEEBRgRAIAMoAhwhDCADKAIYIQ0gA0EgaiILQQRBAEEEQQgQoBggAygCJCEFIAMoAiBBAUYNAiADKAIoIgkgDDYCBCAJIA02AgAgA0EQaiIMQQE2AgAgAyAJNgIMIAMgBTYCCCALIARBwAD8CgAAIwBBEGsiBCQAIARBBGogCxDVCSAEKAIEQQFGBEAgA0EIaiEFA0AgBCgCDCENIAQoAgghDiAFKAIIIgkgBSgCAEYEQCAFIAlBAUEEQQgQ3igLIAUoAgQgCUEDdGoiECANNgIEIBAgDjYCACAFIAlBAWo2AgggBEEEaiALENUJIAQoAgQNAAsLIARBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgA0HgAGokAAwBCyAFIAMoAihBoIKDARD9LwALIAgQiywgCEEDNgIAIAggBikCBDcCBCAIQQxqIAZBDGooAgA2AgAMAQsgBkEQaiIDIAhBEGogCCgCPBCxJiAGQQRqIQojAEHgAGsiBCQAIARBCGogAxDWEAJAAkACQCAEKAIIQQFxBEAgBCgCDCEJIARBIGoiC0EEIAMoAjhBAWoiBUF/IAUbIgUgBUEETRtBAEEEQQQQoBggBCgCJCEFIAQoAiBBAUYNAiAEKAIoIgwgCTYCACAEQRxqIg1BATYCACAEIAw2AhggBCAFNgIUIAsgA0HAAPwKAAAjAEEQayIDJAAgA0EIaiALENYQIAMoAghBAXEEQCAEQRRqIQUgAygCDCEJA0AgBSgCCCIMIAUoAgBGBEAgBSALKAI4QQFqIg5BfyAOGxDuLQsgBSgCBCAMQQJ0aiAJNgIAIAUgDEEBajYCCCADIAsQ1hAgAygCBCEJIAMoAgBBAXENAAsLIANBEGokACAKQQhqIA0oAgA2AgAgCiAEKQIUNwIADAELIApBADYCCCAKQoCAgIDAADcCAAsgBEHgAGokAAwBCyAFIAQoAihBoIKDARD9LwALIAgQiywgCEECNgIAIAggBikCBDcCBCAIQQxqIAZBDGooAgA2AgALIA8gCEHAAPwKAAAgBkHQAGokAAwCCyAHQRBqIAMQwzQgBygCFEEBRw0BIAdBCGogAxDDNCAHKAIMBEAgBygCCCgCAEEwaiEDDAELC0EAQQBBnISDARDDIQALIAcoAlwhAyAHQfAAaiIEIAdBMGpBLPwKAAAgB0HoAGogB0EoaikCADcDACAHIAM2ApwBIAcgBykCIDcDYCAAIAEgAiAHQeAAaiIAEKIBIAQQzSYgABCLLCAHQaABaiQAC7kCAQZ+IAApAwgiAiABMQAAQoCAgICAgICAAYQiA4VC88rRy6eM2bL0AIUiBEIQiSAEIAApAwAiBULh5JXz1uzZvOwAhXwiBIUiBkIViSAGIAJC7d6R85bM3LfkAIUiAiAFQvXKzYPXrNu38wCFfCIFQiCJfCIGhSIHQhCJIAcgBCACQg2JIAWFIgJ8IgRCIIlC/wGFfCIFhSIHQhWJIAcgBCACQhGJhSICIAMgBoV8IgNCIIl8IgSFIgZCEIkgBiADIAJCDYmFIgIgBXwiA0IgiXwiBYUiBkIViSAGIAMgAkIRiYUiAiAEfCIDQiCJfCIEhSIGQhCJIAYgAkINiSADhSICIAV8IgNCIIl8IgWFQhWJIAJCEYkgA4UiAkINiSACIAR8hSICQhGJhSACIAV8IgJCIImFIAKFC8sCAgl/AX4jAEEwayICJAAgASgCBCEEIAIgASgCCCIHQQBBBEEYEKAYIAIoAgQhBSACKAIAQQFHBEAgAigCCCEIAkAgBUUNACAHQRhsIQYgBEEMaiEDIAJBDGohCSAIIQEgBSEEA0AgBkUNASACQRhqIANBDGsQ3SACQCADKAIAQYCAgIB4RwRAIAJBJGogAxDdIAwBCyACQYCAgIB4NgIkCyAJIAIpAiQ3AgAgAkEIaiIKIAJBIGooAgA2AgAgCUEIaiACQSxqKAIANgIAIAIgAikCGCILNwMAIAFBEGogAkEQaikDADcCACABQQhqIAopAwA3AgAgASALNwIAIAFBGGohASAGQRhrIQYgA0EYaiEDIARBAWsiBA0ACwsgACAHNgIIIAAgCDYCBCAAIAU2AgAgAkEwaiQADwsgBSACKAIIQdC1wgAQ/S8AC7YCAQV/IwBB4AJrIgIkACACQZgCaiIDIAFBDGoQ3AECQCACKAKYAkEIRgRAIAIgAikCnAI3AgggAkEQaiIFIAJBCGoiBhDDLSACQbABaiIEIAUQoRsgAyABEMMGIAJB1ABqIgEgBCADEIwYIAMgARDNHCAEIAMQuAZB7ABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAEQeQA/AoAACAAQdDPzwA2AgggACABNgIEIABBCDYCACACKAIIIgAgACgCACIAQQFrNgIAIABBAUYEQCAGELsjCyACQeACaiQADwsgAkHAAWogAkGoAmopAwA3AwAgAkG4AWogAkGgAmopAwA3AwAgAiACKQOYAjcDsAFBzJ7PAEErIAJBsAFqQbyezwBBwM/PABDVHgALQQRB7AAQoz0AC4oDAQN/IwBBEGsiAiQAAkACQAJAAkACQAJAQQIgASgCACIDQf////8HaiADQYCAgIB4TRtBAWsOBAECAwQACyAAQYGAgIB4NgIAIAAgASgCDDYCDCAAIAEpAgQ3AgQMBAsgASgCBCEDAkAgASgCCCIERQRAQQAhAQwBCxDMLyEBIAIgBBDGECABQQhqIAJBCGopAgA3AgAgASACKQIANwIACyAAIAE2AgggACADNgIEIABBgoCAgHg2AgAMAwsgASgCDCEEAkAgA0GAgICAeEcEQCACIAEQzwsMAQsgAkGAgICAeDYCAAsgACAENgIMIAAgAikCADcCACAAQQhqIAJBCGooAgA2AgAMAgsgASgCBCEDAkAgASgCCCIERQRAQQAhAQwBCxDMLyEBIAIgBBDGECABQQhqIAJBCGopAgA3AgAgASACKQIANwIACyAAIAE2AgggACADNgIEIABBhICAgHg2AgAMAQsgACABKQIANwIAIABBCGogAUEIaikCADcCAAsgAkEQaiQAC4kDAgN+B38jAEEQayIGJAAgAS0AJCIHQQlHBEAgBiAHOgAPAkACQCABKAIMRQ0AIAFBEGogBkEPahDsDCEDIAEoAgAiB0EMayEJIAEoAgQiCCADp3EhASADQhmIQv8Ag0KBgoSIkKDAgAF+IQUgBi0ADyEKA0AgASAHaikAACIEIAWFIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIDUEUEQANAIAogCUEAIAN6p0EDdiABaiAIcWsiC0EMbGotAABGDQQgA0IBfSADgyIDUEUNAAsLIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0BIAEgDEEIaiIMaiAIcSEBDAALAAsjAEEgayIAJAAgAEECNgIEIABB2K7OADYCACAAQgE3AgwgAEGuAzYCHCAAIAZBD2o2AhggACAAQRhqNgIIIABBiK/OABDvLAALIAAgByALQQxsaiIAQQhrKAIAIAIgAEEEaygCACgCIBEBACAGQRBqJAAPC0Hkrc4AQR5B+K7OABDLJAAL0iQBBX8jAEEwayIHJAAgByADNgIMAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDhEAAQIDBAUGBwgJCgsMDQ4PEBELIAJCADcBACACQRhqQgA3AQAgAkEQakIANwEAIAJBCGpCADcBAAwRCyABQQFNBEAMEgsgAiAALwAAIgBBD3Y7AR4gAiAAQQFxOwEAIAIgAEEOdkEBcTsBHCACIABBDXZBAXE7ARogAiAAQQx2QQFxOwEYIAIgAEELdkEBcTsBFiACIABBCnZBAXE7ARQgAiAAQQl2QQFxOwESIAIgAEEIdkEBcTsBECACIABBB3ZBAXE7AQ4gAiAAQQZ2QQFxOwEMIAIgAEEFdkEBcTsBCiACIABBBHZBAXE7AQggAiAAQQN2QQFxOwEGIAIgAEECdkEBcTsBBCACIABBAXZBAXE7AQIMEAsgAUEDTQRADBELIAIgAC8AACIBQQ52OwEOIAIgAUEDcTsBACACIAAvAAIiAEEOdjsBHiACIABBA3E7ARAgAiABQQx2QQNxOwEMIAIgAUEKdkEDcTsBCiACIAFBCHZBA3E7AQggAiABQQZ2QQNxOwEGIAIgAUEEdkEDcTsBBCACIAFBAnZBA3E7AQIgAiAAQQx2QQNxOwEcIAIgAEEKdkEDcTsBGiACIABBCHZBA3E7ARggAiAAQQZ2QQNxOwEWIAIgAEEEdkEDcTsBFCACIABBAnZBA3E7ARIMDwsgAUEFTQRADBALIAIgAC8AACIBQQdxOwEAIAIgAC8ABCIDQQ12OwEeIAIgAUEMdkEHcTsBCCACIAFBCXZBB3E7AQYgAiABQQZ2QQdxOwEEIAIgAUEDdkEHcTsBAiACIAAvAAIiAEELdkEHcTsBEiACIABBCHZBB3E7ARAgAiAAQQV2QQdxOwEOIAIgAEECdkEHcTsBDCACIANBCnZBB3E7ARwgAiADQQd2QQdxOwEaIAIgA0EEdkEHcTsBGCACIANBAXZBB3E7ARYgAiAAQQF0QQZxIAFBD3ZyOwEKIAIgA0ECdEEEcSAAQQ52cjsBFAwOCyABQQdNBEAMDwsgAiAALwAAIgFBDHY7AQYgAiABQQ9xOwEAIAIgAC8AAiIDQQx2OwEOIAIgA0EPcTsBCCACIAAvAAQiBEEMdjsBFiACIARBD3E7ARAgAiAALwAGIgBBDHY7AR4gAiAAQQ9xOwEYIAIgAUEIdkEPcTsBBCACIAFBBHZBD3E7AQIgAiADQQh2QQ9xOwEMIAIgA0EEdkEPcTsBCiACIARBCHZBD3E7ARQgAiAEQQR2QQ9xOwESIAIgAEEIdkEPcTsBHCACIABBBHZBD3E7ARoMDQsgAUEJTQRADA4LIAIgAC8AACIBQR9xOwEAIAIgAC8ACCIDQQt2OwEeIAIgAUEKdkEfcTsBBCACIAFBBXZBH3E7AQIgAiAALwACIgRBCXZBH3E7AQogAiAEQQR2QR9xOwEIIAIgAC8ABCIFQQh2QR9xOwEQIAIgBUEDdkEfcTsBDiACIAAvAAYiAEEHdkEfcTsBFiACIABBAnZBH3E7ARQgAiADQQZ2QR9xOwEcIAIgA0EBdkEfcTsBGiACIARBAXRBHnEgAUEPdnI7AQYgAiAFQQJ0QRxxIARBDnZyOwEMIAIgAEEDdEEYcSAFQQ12cjsBEiACIANBBHRBEHEgAEEMdnI7ARgMDAsgAUELTQRADA0LIAIgAC8AACIEQT9xOwEAIAIgAC8ABCIFQQp2OwEOIAIgAC8ABiIGQT9xOwEQIAIgBEEGdkE/cTsBAiACIAAvAAIiAUEIdkE/cTsBCCACIAFBAnZBP3E7AQYgAiAFQQR2QT9xOwEMIAIgBkEGdkE/cTsBEiACIAAvAAgiA0EIdkE/cTsBGCACIANBAnZBP3E7ARYgAiABQQR0QTBxIARBDHZyOwEEIAIgBUECdEE8cSABQQ52cjsBCiACIANBBHRBMHEgBkEMdnI7ARQgAiAALwAKIgBBCnY7AR4gAiAAQQR2QT9xOwEcIAIgAEECdEE8cSADQQ52cjsBGgwLCyABQQ1NBEAMDAsgAiAALwAAIgNB/wBxOwEAIAIgA0EHdkH/AHE7AQIgAiAALwACIgRBBXZB/wBxOwEGIAIgAC8ABCIFQQN2Qf8AcTsBCiACIAAvAAYiAUEIdkH/AHE7ARAgAiABQQF2Qf8AcTsBDiACIAAvAAgiBkEGdkH/AHE7ARQgAiAALwAKIghBBHZB/wBxOwEYIAIgBEECdEH8AHEgA0EOdnI7AQQgAiAFQQR0QfAAcSAEQQx2cjsBCCACIAFBBnRBwABxIAVBCnZyOwEMIAIgBkEBdEH+AHEgAUEPdnI7ARIgAiAIQQN0QfgAcSAGQQ12cjsBFiACIAAvAAwiAEEJdjsBHiACIABBAnZB/wBxOwEcIAIgAEEFdEHgAHEgCEELdnI7ARoMCgsgAUEPTQRADAsLIAIgAC8AACIBQQh2OwECIAIgAUH/AXE7AQAgAiAALwACIgFBCHY7AQYgAiABQf8BcTsBBCACIAAvAAQiAUEIdjsBCiACIAFB/wFxOwEIIAIgAC8ABiIBQQh2OwEOIAIgAUH/AXE7AQwgAiAALwAIIgFBCHY7ARIgAiABQf8BcTsBECACIAAvAAoiAUEIdjsBFiACIAFB/wFxOwEUIAIgAC8ADCIBQQh2OwEaIAIgAUH/AXE7ARggAiAALwAOIgBBCHY7AR4gAiAAQf8BcTsBHAwJCyABQRFNBEAMCgsgAiAALwAAIghB/wNxOwEAIAIgAC8AAiIBQQJ2Qf8DcTsBBCACIAAvAAQiA0EEdkH/A3E7AQggAiAALwAGIgRBBnZB/wNxOwEMIAIgAC8ACiIFQQF2Qf8DcTsBEiACIAAvAAwiBkEDdkH/A3E7ARYgAiABQQd0QYADcSAIQQl2cjsBAiACIANBBXRB4ANxIAFBC3ZyOwEGIAIgBEEDdEH4A3EgA0ENdnI7AQogAiAALwAIIgFBAXRB/gNxIARBD3ZyOwEOIAIgBUEIdEGAAnEgAUEIdnI7ARAgAiAGQQZ0QcADcSAFQQp2cjsBFCACIAAvABAiAUEHdjsBHiACIAAvAA4iAEEFdkH/A3E7ARogAiAAQQR0QfADcSAGQQx2cjsBGCACIAFBAnRB/ANxIABBDnZyOwEcDAgLIAFBE00EQAwJCyACIAAvAAAiBUH/B3E7AQAgAiAALwAIIgZBBnY7AQ4gAiAALwAKIghB/wdxOwEQIAIgAC8AAiIBQQR2Qf8HcTsBBCACIAAvAAYiA0ECdkH/B3E7AQogAiAALwAMIgRBBHZB/wdxOwEUIAIgAUEGdEHAB3EgBUEKdnI7AQIgAiAALwAEIgVBAnRB/AdxIAFBDnZyOwEGIAIgA0EIdEGABnEgBUEIdnI7AQggAiAGQQR0QfAHcSADQQx2cjsBDCACIARBBnRBwAdxIAhBCnZyOwESIAIgAC8ADiIBQQJ0QfwHcSAEQQ52cjsBFiACIAAvABIiA0EGdjsBHiACIAAvABAiAEECdkH/B3E7ARogAiAAQQh0QYAGcSABQQh2cjsBGCACIANBBHRB8AdxIABBDHZyOwEcDAcLIAFBFU0EQAwICyACIAAvAAAiBUH/D3E7AQAgAiAALwAEIgFBAXZB/w9xOwEGIAIgAC8ACCIDQQJ2Qf8PcTsBDCACIAAvAAwiBEEDdkH/D3E7ARIgAiAALwACIgZBBXRB4A9xIAVBC3ZyOwECIAIgAUEKdEGACHEgBkEGdnI7AQQgAiAALwAGIgVBBHRB8A9xIAFBDHZyOwEIIAIgA0EJdEGADHEgBUEHdnI7AQogAiAALwAKIgFBA3RB+A9xIANBDXZyOwEOIAIgBEEIdEGADnEgAUEIdnI7ARAgAiAALwAOIgNBAnRB/A9xIARBDnZyOwEUIAIgAC8AFCIEQQV2OwEeIAIgAC8AECIBQQR2Qf8PcTsBGCACIAFBB3RBgA9xIANBCXZyOwEWIAIgAC8AEiIAQQF0Qf4PcSABQQ92cjsBGiACIARBBnRBwA9xIABBCnZyOwEcDAYLIAFBF00EQAwHCyACIAAvAAAiAUH/H3E7AQAgAiAALwAEIgNBBHY7AQYgAiAALwAGIgRB/x9xOwEIIAIgAC8ACiIFQQR2OwEOIAIgAC8ADCIGQf8fcTsBECACIAAvAAIiCEEEdEHwH3EgAUEMdnI7AQIgAiADQQh0QYAecSAIQQh2cjsBBCACIAAvAAgiAUEEdEHwH3EgBEEMdnI7AQogAiAFQQh0QYAecSABQQh2cjsBDCACIAAvAA4iAUEEdEHwH3EgBkEMdnI7ARIgAiAALwAQIgNBBHY7ARYgAiADQQh0QYAecSABQQh2cjsBFCACIAAvABIiAUH/H3E7ARggAiAALwAWIgNBBHY7AR4gAiAALwAUIgBBBHRB8B9xIAFBDHZyOwEaIAIgA0EIdEGAHnEgAEEIdnI7ARwMBQsgAUEZTQRADAYLIAIgAC8AACIEQf8/cTsBACACIAAvAAgiAUEBdkH/P3E7AQogAiAALwAQIgNBAnZB/z9xOwEUIAIgAC8AAiIFQQN0Qfg/cSAEQQ12cjsBAiACIAAvAAQiBEEGdEHAP3EgBUEKdnI7AQQgAiAALwAGIgVBCXRBgDxxIARBB3ZyOwEGIAIgAUEMdEGAIHEgBUEEdnI7AQggAiAALwAKIgRBAnRB/D9xIAFBDnZyOwEMIAIgAC8ADCIBQQV0QeA/cSAEQQt2cjsBDiACIAAvAA4iBEEIdEGAPnEgAUEIdnI7ARAgAiADQQt0QYAwcSAEQQV2cjsBEiACIAAvABgiAUEDdjsBHiACIAAvABIiBEEBdEH+P3EgA0EPdnI7ARYgAiAALwAUIgNBBHRB8D9xIARBDHZyOwEYIAIgAC8AFiIAQQd0QYA/cSADQQl2cjsBGiACIAFBCnRBgDhxIABBBnZyOwEcDAQLIAFBG00EQAwFCyACIAAvAAAiAUH//wBxOwEAIAIgAC8ADCIDQQJ2OwEOIAIgAC8ADiIEQf//AHE7ARAgAiAALwACIgVBAnRB/P8AcSABQQ52cjsBAiACIAAvAAQiAUEEdEHw/wBxIAVBDHZyOwEEIAIgAC8ABiIFQQZ0QcD/AHEgAUEKdnI7AQYgAiAALwAIIgFBCHRBgP4AcSAFQQh2cjsBCCACIAAvAAoiBUEKdEGA+ABxIAFBBnZyOwEKIAIgA0EMdEGA4ABxIAVBBHZyOwEMIAIgAC8AECIBQQJ0Qfz/AHEgBEEOdnI7ARIgAiAALwAaIgNBAnY7AR4gAiAALwASIgRBBHRB8P8AcSABQQx2cjsBFCACIAAvABQiAUEGdEHA/wBxIARBCnZyOwEWIAIgAC8AFiIEQQh0QYD+AHEgAUEIdnI7ARggAiAALwAYIgBBCnRBgPgAcSAEQQZ2cjsBGiACIANBDHRBgOAAcSAAQQR2cjsBHAwDCyABQR1NBEAMBAsgAiAALwAAIgFB//8BcTsBACACIAAvAAIiA0EBdEH+/wFxIAFBD3ZyOwECIAIgAC8ABCIBQQJ0Qfz/AXEgA0EOdnI7AQQgAiAALwAGIgNBA3RB+P8BcSABQQ12cjsBBiACIAAvAAgiAUEEdEHw/wFxIANBDHZyOwEIIAIgAC8ACiIDQQV0QeD/AXEgAUELdnI7AQogAiAALwAMIgFBBnRBwP8BcSADQQp2cjsBDCACIAAvAA4iA0EHdEGA/wFxIAFBCXZyOwEOIAIgAC8AECIBQQh0QYD+AXEgA0EIdnI7ARAgAiAALwASIgNBCXRBgPwBcSABQQd2cjsBEiACIAAvABwiAUEBdjsBHiACIAAvABQiBEEKdEGA+AFxIANBBnZyOwEUIAIgAC8AFiIDQQt0QYDwAXEgBEEFdnI7ARYgAiAALwAYIgRBDHRBgOABcSADQQR2cjsBGCACIAAvABoiAEENdEGAwAFxIARBA3ZyOwEaIAIgAUEOdEGAgAFxIABBAnZyOwEcDAILIAFBH00EQAwDCyACIAAvAAA7AQAgAiAAKQACNwECIAIgACkACjcBCiACIAApABI3ARIgAiAAKAAaNgEaIAIgAC8AHjsBHgwBCyAHQQE2AhQgB0H8ic8ANgIQIAdCATcCHCAHQTs2AiwgByAHQShqNgIYIAcgB0EMajYCKCAHQRBqQZSKzwAQ7ywACyAHQTBqJAAPC0GkvM4AQS1BlLzOABCfKQALvQIBA38jAEEwayIIJAACQAJAIANFDQACQANAIAUgAi0AACIKQQFqIglNBEAgCEEBNgIcIAhB0MrQADYCGCAIQgE3AiQgCEE7NgIQQQAhCSAIIAVBAWsiAUEAIAEgBU0bNgIUIAggCEEMajYCICAIIAhBFGo2AgwgAEEEaiAIQRhqEJkODAQLIAQgCUECdGooAgAiCSAEIApBAnRqKAIAIgpPBEAgByAJSQ0CIAhBGGogASAGIApqIAkgCmtBABCfFCAIKAIYIglBCEcEQCAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCAAwFCyACQQFqIQIgA0EBayIDRQ0DDAELCyAKIAlBkMrQABCxOwALIAkgB0GQytAAELA7AAtBCCEJCyAAIAk2AgAgCEEwaiQAC70CAQN/IwBBMGsiCCQAAkACQCADRQ0AAkADQCAFIAItAAAiCkEBaiIJTQRAIAhBATYCHCAIQdDK0AA2AhggCEIBNwIkIAhBOzYCEEEAIQkgCCAFQQFrIgFBACABIAVNGzYCFCAIIAhBDGo2AiAgCCAIQRRqNgIMIABBBGogCEEYahCZDgwECyAEIAlBA3RqKAIAIgkgBCAKQQN0aigCACIKTwRAIAcgCUkNAiAIQRhqIAEgBiAKaiAJIAprQQAQlxQgCCgCGCIJQQhHBEAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAMBQsgAkEBaiECIANBAWsiA0UNAwwBCwsgCiAJQZDK0AAQsTsACyAJIAdBkMrQABCwOwALQQghCQsgACAJNgIAIAhBMGokAAvKAgECfyMAQaACayIDJAAgAiABLQBDQQFzOgBYIANBEGoiBCACQdwA/AoAACABLQBEQQFGBEAgA0HsAGoiASACQdwA/AoAACABQQE6AFkgBCABQdwA/AoAAAsgA0HsAGogA0EQahDfByADQdABaiIBIANB+ABqKQIANwMAIANB2AFqIgIgA0GAAWooAgA2AgAgAyADKQJwNwPIAQJAIAMoAmwiBEGAgICAeEYEQCAAIAMpA8gBNwIAIABBEGogAigCADYCACAAQQhqIAEpAwA3AgAMAQsgA0H0AWogA0GEAWpBLPwKAAAgA0HoAWogA0HQAWopAwA3AgAgA0HwAWogA0HYAWooAgA2AgAgAyAENgLcASADIAMpA8gBNwLgASADQQhqIANB3AFqEKABIAAgAykDCDcCBCAAQZOAgIB4NgIACyADQaACaiQAC9QCAgJ/A34jAEEwayIDJAACQAJAAkACQCACQSZNBEAgA0EQaiABIAIQ+gggAy0AEEUNASAAQgA3AwggAEIBNwMADAQLAkACQAJAIAEtAABBK2sOAwECAAILQQEhBCABLAABQb9/TA0DIAFBAWohASACQQFrIQIMAQsgASwAAUG/f0wNAyABQQFqIQEgAkEBayECCyADQQhqIAEgAkEwEMkTIAMoAgwiAUUEQCAAQQBBMPwLAAwECyADKAIIIgItAABBMGtB/wFxQQpPBEAgAEIANwMIIABCATcDAAwECyAAIAIgASAEEIIGDAMLIAMpAyAhBSAAIAMpAygiBkI/hyIHNwMoIAAgBzcDICAAIAY3AxggACAFNwMQIABCADcDCCAAQgA3AwAMAgsgASACQQEgAkHQ84cBEKM2AAsgASACQQEgAkHg84cBEKM2AAsgA0EwaiQAC7ICAQp/IwBBIGsiBCQAIAQgADYCCCAEIAAgAyABIAEgA0sbIghBAnQiCWoiBzYCDAJAAkACQCAIIARBCGoQnjYiBiAGIAhLGyIKRQ0AIAIhBgNAIAAgACgCACILIAYoAgAiDGsiDSAFazYCACALIAxJIAUgDUtyIQUgAEEEaiEAIAZBBGohBiAKQQFrIgoNAAsgBUUNACABQQJ0IAhBAnRrIQADQCAARQ0CIAcgBygCACIBQQFrNgIAIABBBGshACAHQQRqIQcgAUUNAAsLIAIgCWohBSADQQJ0IAlrIQADQCAARQ0CIABBBGshACAFKAIAIAVBBGohBUUNAAsLIARBADYCGCAEQQE2AgwgBEH4pogBNgIIIARCBDcCECAEQQhqQYCniAEQ7ywACyAEQSBqJAALygICBH8BfiMAQRBrIgIkACACQQhqIAEQgRgCQAJAIAItAAhBBEYNACACKQMIIgZC/wGDQgRRDQAgACAGNwIADAELIAJBCGogAUEYahCCGAJAIAItAAhBBEYNACACKQMIIgZC/wGDQgRRDQAgACAGNwIADAELAkACQCABKAJAQQdNBEAgAkEQaiEFA0AgARCFOyEDIAIgASgCECIEQRh2OgAPIAIgBEEQdjoADiACIARBCHY6AA0gAiAEOgAMIAIgA0EYdjoACyACIANBEHY6AAogAiADQQh2OgAJIAIgAzoACCABKAIwIgRFDQIgASgCQCIDQQlPDQMgBCACQQhqIANqIAUQvSYgASABKAJAIANrIgNBCGo2AkAgA0F3Sw0ACwsgAEEEOgAADAILQYD1zQAQsjsACyADQQhBuPTNABCvOwALIAJBEGokAAvIAgIDfgh/An9BCCABKAJMRQ0AGiABQdAAaiACEO4LIQMgASgCQCIIQUBqIQsgASgCRCIJIAOncSEGIANCGYhC/wCDQoGChIiQoMCAAX4hBSACKAIIIQwgAigCBCENA0ACQCAGIAhqKQAAIgQgBYUiA0J/hSADQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgNQRQRAA0AgDSAMIAsgA3qnQQN2IAZqIAlxIgdBBnRrIgIoAgQgAigCCBDkHA0CIANCAX0gA4MiA1BFDQALC0EIIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0CGiAGIApBCGoiCmogCXEhBgwBCwsgCEEAIAdrQQZ0aiICQQxrKAIAIQcgAkEQaygCAAshAiAAIAEoAiQgByACQQhGIgYbNgIEIAAgASgCICACIAYbIgBBACAAQQhHGzYCAAvEAgIDfwF+IwBBoAJrIgIkACABQQhqIQMCQAJAAkACQAJAAkAgAS0AAEEBaw4CAQIACyACQQhqIgEgA0H4APwKAAAgAkGAAWogARD/ECACKAKIASIBQQNNDQMgACACKQKAATcCACACKAKEASABQQRrNgAAIABBCGogAkGIAWooAgA2AgAMAgsgAkGQAWoiASADQfgA/AoAACAAIAEQ/xAMAQsgAkGYAmoiASADQRBqKQMANwMAIAJBkAJqIgQgA0EIaikDADcDACACIAMpAwAiBTcDiAIgAi0AnAIhAyACIAU3A4ABIANBA3YgA0EHcUEAR2oiA0EJTw0CIAQgAkGAAWogAxChNiAAQQhqIAEoAgA2AgAgACACKQOQAjcCAAsgAkGgAmokAA8LQQQgAUGEi88AELA7AAsgA0EIQZCJzwAQsDsAC+0CAQR/IwBB0ABrIgIkACACIAFBGGoiAzYCHAJAAkAgA0HQ74UBEMYIBEAgAkEQaiABENw7IAIgAigCFCIDNgI0IANBAUcNASACQQhqIAEQ3DsgAigCDARAIAIoAggiBCgCACIDIAMoAgAiBUEBajYCACAFQQBIDQMgAiADNgI4IAIgBCkCBDcCPCAAIAJBOGogASgCKCABKAIkEPIVIABBFGogAUEsakEAIAEoAiwbEO4lIAEQiicgAkHQAGokAA8LQQBBAEGM8YUBEMMhAAsgAiADNgIgIAJCAjcCRCACQQI2AjwgAkHo8IUBNgI4IAJBpwQ2AjAgAkGtAzYCKCACQdDvhQE2AiQgAiACQSRqNgJAIAIgAkEgajYCLCACQRxqQbTwhQEgAkE4akH48IUBEKMrAAsgAkIANwJEIAJCgYCAgMAANwI8IAJB5PGFATYCOEEAIAJBNGpBiPGFASACQThqQezxhQEQrysLAAvgAgECfyMAQUBqIgQkACAEIAEoAggiBTYCDCAEIAI2AhAgBCADNgIUAkAgAiADTQRAIAMgBUsNAQJAIAIgA0cEQCAEQRhqIAFBDGogASgCBCAFIAEoAgAoAgARBQAgBEEgaiIBIAQoAhQgAms2AgAgBCAEKAIcIAJqNgIcIAAgBCkCGDcCACAAQQhqIAEpAgA3AgAMAQsgAEEANgIMIABCATcCBCAAQdCFiAE2AgALIARBQGskAA8LIARBAjYCHCAEQZSGiAE2AhggBEICNwIkIARBqx02AjwgBEGrHTYCNCAEIARBMGo2AiAgBCAEQRRqNgI4IAQgBEEQajYCMCAEQRhqQaSGiAEQ7ywACyAEQQI2AhwgBEHQhogBNgIYIARCAjcCJCAEQasdNgI8IARBqx02AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBEEYakHghogBEO8sAAujAgEDfyMAQZABayIDJAACfwJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxDQEgA0EIaiAAKAIAIANBEGoQsBAgAUEBQQFBACADKAIIIAMoAgwQgQkMAgsgACgCACEAQQAhAgNAIAIgA2pBjwFqIABBD3EiBEEwciAEQdcAaiAEQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIANqQZABakEAIAJrEIEJDAELIAAoAgAhAEEAIQIDQCACIANqQY8BaiAAQQ9xIgRBMHIgBEE3aiAEQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIANqQZABakEAIAJrEIEJCyADQZABaiQAC+UCAgN/AX4jAEHgA2siBCQAIARByAFqIAMoAgQgAygCCBC4GSADEN47IAIoAgghAyACKAIEIQUgAi0AACEGAkAgBCgCyAFBAkYEQEIDIQcgBCgCzAEhAiADRSAGQQpJcg0BIAUgA0EBEPg6DAELIAIpAgwhByAEQZACahD+LCAEQccDaiACQQNqLQAAOgAAIAQgBjoAxAMgBCAHNwPQAyAEIAM2AswDIAQgBTYCyAMgBCACLwABOwDFAyAEQdACaiAEQcgBakHIAPwKAAAgBEEBOgDYAyAEQYCU69wDNgKgAyAEQQA2AqgDIARChICAgPAANwK8AyAEKQOQAiEHIAQoApgCIQIgBEEEaiAEQZwCakHEAfwKAAALIAEoAgAiASABKAIAIgNBAWo2AgAgA0EATgRAIAAgAjYCCCAAIAc3AwAgACABNgLQASAAQQxqIARBBGpBxAH8CgAAIARB4ANqJAAPCwALwwIBBX8jAEEQayIFJAAgAEEIIAAoAjQiAyADQQhNGzYCNCAAQTBqIQcgAkEEdCEDAkBBACAAKAIwIgZrQQdxIgQgACgCCCAGa00NACAAKAIIIAAoAjBrIARPDQADQCAAEPsWIAAoAgggACgCMGsgBEkNAAsLIAcgBBCNNwJAAkAgA0EEciIEIAAoAgggACgCMGsiBk0NACAEQYCAgIB4Sw0BIAQgBk0NAANAIAAQ+xYgACgCCCAAKAIwayAESQ0ACwsgByADEI03IAVBCGogABDcOyAFIAUoAgggBSgCDCAAKAIwIgQgBCADa0HUxv4AENcmAkAgBSgCBEEEdiIDIAIgAiADSxsiA0UNACADQQR0IgNFDQAgBSgCACABIAP8CgAACyAAIAIQqhEgBUEQaiQADwtB9Mb+AEElQZzH/gAQnykAC8ICAgJ+An8jAEEQayIFJAACQCABKAI4IgQEfwJAIAEpAygiA1BFBEAgASkDMCECDAELIAFBIGohBANAAn4CQCABKQMQIgJCA1IEQAJAAkACQCACQgJRDQAgASACUK1CAYY3AxAgAqdBAXFFDQAgBSABKQMYNwMIDAELIAQoAgBFDQEgBSAEELYqIAUpAwAhAgsgAkIAUg0CCyABQgM3AxALIAEpAwAiAkICUQ0FIAFCADcDACABKQMIDAELIAUpAwgLIQMgAqdBAXFFDQMgASADNwMoIAEgASkDMEJAfSICNwMwIANQDQALIAEoAjghBAsgASAEQQFrNgI4IAEgA0IBIAN6IgOGhTcDKCADpyACp2ohBEEBBUEACyEBIAAgBDYCBCAAIAE2AgAgBUEQaiQADwtB3IODAUEdQfyDgwEQyyQAC4YDAgR/AX4jAEEQayICJABBgICAgHghAwJAAkACQAJAAkACQEECIAEoAgAiBEH/////B2ogBEGAgICAeE0bQQFrDgQBAgMEAAsgAEGBgICAeDYCACAAIAEoAgw2AgwgACABKQIENwIEDAQLIAEoAgQhAwJAIAEoAggiBEUEQEEAIQEMAQsQzC8hASACIAQQ1xAgAUEIaiACQQhqKQIANwIAIAEgAikCADcCAAsgACABNgIIIAAgAzYCBCAAQYKAgIB4NgIADAMLIAEoAgwhBSAEQYCAgIB4RwRAIAIgARDPCyACKQIEIQYgAigCACEDCyAAIAY3AgQgACADNgIAIAAgBTYCDAwCCyABKAIEIQMCQCABKAIIIgRFBEBBACEBDAELEMwvIQEgAiAEENcQIAFBCGogAkEIaikCADcCACABIAIpAgA3AgALIAAgATYCCCAAIAM2AgQgAEGEgICAeDYCAAwBCyAAIAEpAgA3AgAgAEEIaiABQQhqKQIANwIACyACQRBqJAALzAIBAX8CQAJAAkACQAJAAkACQAJAAkAgBSAISwRAIAcgCU0NASAIIApqIgsgBU8NAiAEIAtBAnRqKAIAIgUgBCAIQQJ0aigCACIIayIEQQBIDQMgCSAKaiIKIAdPDQQgBiAKQQJ0aigCACAGIAlBAnRqKAIAIgZrIgdBAEgNBSAEIAdyRQRAQQEPCyAEIAdHBEBBAA8LIAUgCEkNBiABIAVJDQcgBCAGaiIBIARJDQggASADSw0JIAAgCGogBCACIAZqIAQQnzsPCyAIIAVB1K2HARDDIQALIAkgB0HkrYcBEMMhAAsgCyAFQfSthwEQwyEAC0GErocBELI7AAsgCiAHQZSuhwEQwyEAC0GkrocBELI7AAsgCCAFQbSthwEQsTsACyAFIAFBtK2HARCwOwALIAYgAUHErYcBELE7AAsgASADQcSthwEQsDsAC7wCAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtB8KzNABCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEHIAAoAgQiBiABSQRAIAAgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiBiACIAZLGxDoGSAAKAIMIQILIAdFDQAgACgCCCACakH/ASAH/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQYCtzQAQsjsACyAAIAQ2AhAgA0EQaiQAC9oCAQN/IwBBMGsiAiQAIAEtABYhAyABQQI6ABYCQAJAIANBAkcEQCAAQQQ2AgAgACADOgAEDAELIAEoAhAiBEUEQCACQRBqELQeIAIoAhAiA0EERg0CIAAgAikCGDcCCCAAQRBqIAJBIGooAgA2AgAgAEEHaiACKAIUIgFBGHY6AAAgACABQQh2OwAFIAAgAToABCAAIAM2AgAMAQsgASgCDCEDIAEgBEEBazYCECABIANBAWo2AgwCQAJAAkAgAy0AACIBDgMCAQIACyACIAE6AA8gAkECNgIUIAJBpLPOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAILIABBBDYCACAAQQE6AAQMAQsgAEEENgIAIABBADoABAsgAkEwaiQADwtBAUEAQdSzzgAQrzsAC6UFAgV/AX4jAEEQayIIJAACQAJAAkACQAJAAkACQAJAIAAoAugpQQFGBEAgAC0AvioNAQsgACgCqCoiBkUNByABKAIAIglFDQcgBCgCACIKIAkgBiAGIAlLGyIGaiIHIApJDQQgAyAHSQ0FIAhBCGogACAAKALIASAAKALMASAAQdgpahDqHiAGIAgoAgwiA0sNBiACIApqIAYgCCgCCCAGQcjD0AAQ1SwgASAJIAZrNgIAIAQgBzYCACAAKAIAQQFrDgICAwELIwBBEGsiAiQAIAAtAL4qIQEgAEEAOgC+KiAALwG4KiAAQQA7AbgqQQYgAXQiB3IhAwJAAkACQAJAAkACQCAAKAIAQQFNBEAgAkEIaiAAIAAoAsgBIAAoAswBIABB2ClqEOoeIAIoAgwiBSAAKAKoKiIESQ0CIAQgBUYNAyACKAIIIARqIgYgAzoAACABQQJNDQYgBSAEayIEQQFHBEAgBiADQQh2OgABIAFBCk0NByAEQQJNDQIMBgtBAUEBQYjD0AAQwyEACyAAIAM6ANgpIABCATcDACABQQJLDQMMBQtBAiAEQZjD0AAQwyEACyAEIAVB6MLQABCvOwALQQBBAEH4wtAAEMMhAAsgACADQQh2OgDZKSABQQpNDQEgAEHYKWohBgsgBiAHQRB2OgACCyAAIAAoAqgqIAFBDWpBA3ZqNgKoKiACQRBqJABBASEHDAYLIAAoAgQgBmohAQwBCyAAKAIEIAZqIQELIAAgATYCBCAAIAAoAqgqIAZrNgKoKiAAIAApA9ApIAatfCILNwPQKUEBIQcgBSgCAEEBRw0DIAUgCz4CBAwDCyAKIAdBqMPQABCxOwALIAcgA0Gow9AAELA7AAsgBiADQbjD0AAQsDsACyAIQRBqJAAgBwu6AgEHfyAAQRBqIAAgAigCACICKAIAKAIAEQIAIQMgAEEwQSAgAEEwaiAAQSBqIAIoAgAoAgARAgBBAEgiBBtqIQUgAEEgQTAgBBtqIgYgACADQX9zQRt2QRBxaiIEIAUgBSAAIANBG3ZBEHFqIgAgAigCACgCABECAEEASCIDGyAGIAQgAigCACgCABECAEEASCIHGyIIIAAgBSAEIAcbIAMbIgkgAigCACgCABECACECIAFBCGogBSAAIAMbIgBBCGopAAA3AAAgASAAKQAANwAAIAEgCCAJIAJBAEgiABsiAikAADcAECABQRhqIAJBCGopAAA3AAAgAUEoaiAJIAggABsiAEEIaikAADcAACABIAApAAA3ACAgASAEIAYgBxsiACkAADcAMCABQThqIABBCGopAAA3AAAL1QIBA38CQAJAIAJB//8DcSICIAEoAgxPDQBBfyACIAEoAggiAmoiAyACIANLGyICQQFxBEBBhICAgHghAUGAgICAeCEDQciB/wAhBAwCC0F/IAJBAmoiAyACIANLGyIEIAEoAgAiAygCBCIFSwRAQYWAgIB4IQEgAiEDDAILIAMgAygCFEECaiIENgIUIAMoAggoAgggBEkEQEGIgICAeCEBDAILIAIgBUkEQCAFIAJBAXIiBE0EQCAEIAVBzIL/ABDDIQALIAMoAgAiAyAEai0AAEEIdCACIANqLQAAciICRQ0BIABCioCAgBg3AgAgAEF/IAEoAgQiACACaiIBIAAgAUsbNgIIDwsgAiAFQbyC/wAQwyEACyAAQoqAgIAINwIADwsgACACNgIcIABBAzYCGCAAIAQ2AhQgACADNgIQIABCBDcCCCAAQQA2AgQgACABNgIAC7wCAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtBmIz/ABCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEHIAAoAgQiBiABSQRAIAAgBkEBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiBiACIAZLGxDoGSAAKAIMIQILIAdFDQAgACgCCCACakH/ASAH/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQaiM/wAQsjsACyAAIAQ2AhAgA0EQaiQAC80CAgN+A38jAEEQayIGJABCgICAgICAgICAfyEDAkACQAJAAn4CQAJAIAAoAgQoAhAgAUEDdGopAwAiBEKAgICAgICAgIB/UiAAKAIAIgcoAgAiBSgCACkDACICQn9SckUEQEIAIQIMAQsgAlANBCAEIAQgAn8iAyACfn1CACACQn9SGyECIARCAFkNAQsgAyACIAUoAggpAwBXrX0MAQsgAyACIAUoAgQpAwBZrXwLIgIgAkI/hyIDIAcoAgQtAAAQ/yAEQCAAKAIIIAFBBHRqIgAgAzcDCCAAIAI3AwAMAQsgACgCECIFIAUoAgBBAWo2AgAgBkEIaiAAKAIUEIY9IAFBA3YiACAGKAIMIgVPDQIgBigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAZBEGokAA8LQbyP/wAQ4isACyAAIAVBiIv/ABDDIQAL1QICA34DfyMAQRBrIgYkAEKAgICAgICAgIB/IQMCQAJAAkACQAJ+AkACQCAAKAIEKAIQIAFBA3RqKQMAIgRCgICAgICAgICAf1IgACgCACIHKAIAIgUoAgApAwAiAkJ/UnJFBEBCACECDAELIAJQDQUgBCAEIAJ/IgMgAn59QgAgAkJ/UhshAiAEQgBZDQELIAMgAiAFKAIIKQMAV619DAELIAMgAiAFKAIEKQMAWa18CyICQoCAgIAIfEL/////D1YNACACpyIFIAcoAgQtAAAQxClFDQAgACgCCCABQQJ0aiAFNgIADAELIAAoAhAiBSAFKAIAQQFqNgIAIAZBCGogACgCFBCGPSABQQN2IgAgBigCDCIFTw0CIAYoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAGQRBqJAAPC0G8j/8AEOIrAAsgACAFQYiL/wAQwyEAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQN2IQUDQCACIAM2AgwCQCADKAIAIgYgCUkEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBCGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQJ2IQUDQCACIAM2AgwCQCAJIAMoAgAiBksEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBBGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQJ2IQUDQCACIAM2AgwCQCAJIAMoAgAiBksEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBBGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC8sCAQp/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQgCQAJAIAAoAgAiAyAAKAIEIgVHBEAgACgCFCEHIAAoAhAhCSAAKAIMIQogACgCCCEAIAEoAgggBEECdGohASAFIANrQQN2IQUDQCACIAM2AgwCQCADKAIAIgYgCUkEQCAKIAZBAnRqKAIAIQYMAQsgACAHKAIQTw0DQQAhBiAHKAIEIAAgBygCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgASAGNgIAIANBCGohAyABQQRqIQEgAEEBaiEAIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJByBA2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC4QBAQF/AkACQCAAKAIAIgFBk4CAgHhGDQACQAJAAkBBCyABQYCAgIB4cyABQQBOGw4QBAAEBAQEBAMEBAQBBAQEAgMLIABBBGoQvCoPCyAAEN47IAAtAAxBA0cNASAAKAIQIgAQvCogAEEMQQQQ+DoPCyAAQQRqEN47Cw8LIABBBGoQ3jsLvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0HswIIBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtB/MCCARCyOwALIAAgBDYCECADQRBqJAALvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0HQ54QBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtB4OeEARCyOwALIAAgBDYCECADQRBqJAALvAIBBn8jAEEQayIDJAACQCAAKAIQIgRBB3EiBUUNACADQQhqIAAQhj0CQCADKAIMIgJFDQAgAygCCCACakEBayICRQ0AIAIgAi0AAEF/IAV0cjoAAAwBC0Gw9YQBELI7AAsCQCABIARqIgRBA3YgBEEHcSIFQQBHaiIBIAAoAgwiAk0NACABIAJrIQcgACgCBCIGIAFJBEAgACAGQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIGIAIgBksbEOgZIAAoAgwhAgsgB0UNACAAKAIIIAJqQf8BIAf8CwALIAAgATYCDAJAIAVFDQAgAyAAEIY9AkAgAygCBCIBRQ0AIAMoAgAgAWpBAWsiAUUNACABIAEtAABBfyAFdEF/c3E6AAAMAQtBwPWEARCyOwALIAAgBDYCECADQRBqJAALzQMCBn8CfiMAQRBrIgckAAJAAkACQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIANBA3RqIQUgASgCDCIDIARBA3QiAmoiCCABKAIEIgZLBEAgASAGQQF0IgMgCBDdKiIGIAMgBksbEOgZIAEoAgQhBiABKAIMIQMLIAIgBWohCSAAQQhqIQggBEUgA0EIaiAGS3INAiACQQhrIQQgCCkDACELIAEoAgghCgNAIAMgCmogBSkDACALfDcAACADQQhqIQAgBUEIaiEFIANBEGogBksNBCAEIgJBCGshBCAAIQMgAg0ACwwDCyADIAJBxJyHARCxOwALIAIgBUHEnIcBELA7AAsgAyEACyABIAA2AgwgByAINgIMIAcgCTYCCCAHIAU2AgQgB0EEaiIDKAIAIgAgAygCBCICRwRAIAIgAGtBA3YhBCABKAIMIQIgAygCCCkDACELA0AgACkDACEMIAJBCGoiAyABKAIEIgVLBH8gASAFQQF0IgIgAxDbKiIDIAIgA0sbEOgZIAEoAgwFIAILIAEoAghqIAsgDHw3AAAgASABKAIMQQhqIgI2AgwgAEEIaiEAIARBAWsiBA0ACwsgB0EQaiQAC8sDAQd/IwBBEGsiCCQAAkACQAJAIAQgAyAEaiICTQRAIAIgACgCBCIGSw0BIAAoAgAgA0ECdGohBiABKAIMIgMgBEECdCICaiIHIAEoAgQiBUsEQCABIAVBAXQiAyAHEN0qIgUgAyAFSxsQ6BkgASgCBCEFIAEoAgwhAwsgAiAGaiEJIABBCGohByAERSADQQRqIAVLcg0CIAJBBGshBCAHKAIAIQogASgCCCELA0AgAyALaiAGKAIAIApqNgAAIANBBGohACAGQQRqIQYgA0EIaiAFSw0EIAQiAkEEayEEIAAhAyACDQALDAMLIAMgAkHEnIcBELE7AAsgAiAGQcSchwEQsDsACyADIQALIAEgADYCDCAIIAc2AgwgCCAJNgIIIAggBjYCBCAIQQRqIgMoAgAiACADKAIEIgJHBEAgAiAAa0ECdiEEIAEoAgwhAiADKAIIKAIAIQMDQCAAKAIAIQYgAkEEaiIFIAEoAgQiB0sEfyABIAdBAXQiAiAFENsqIgUgAiAFSxsQ6BkgASgCDAUgAgsgASgCCGogAyAGajYAACABIAEoAgxBBGoiAjYCDCAAQQRqIQAgBEEBayIEDQALCyAIQRBqJAALywMBB38jAEEQayIIJAACQAJAAkAgBCADIARqIgJNBEAgAiAAKAIEIgZLDQEgACgCACADQQF0aiEGIAEoAgwiAyAEQQF0IgJqIgcgASgCBCIFSwRAIAEgBUEBdCIDIAcQ3SoiBSADIAVLGxDoGSABKAIEIQUgASgCDCEDCyACIAZqIQkgAEEIaiEHIARFIANBAmogBUtyDQIgAkECayEEIAcvAQAhCiABKAIIIQsDQCADIAtqIAYvAQAgCmo7AAAgA0ECaiEAIAZBAmohBiADQQRqIAVLDQQgBCICQQJrIQQgACEDIAINAAsMAwsgAyACQcSchwEQsTsACyACIAZBxJyHARCwOwALIAMhAAsgASAANgIMIAggBzYCDCAIIAk2AgggCCAGNgIEIAhBBGoiAygCACIAIAMoAgQiAkcEQCACIABrQQF2IQQgASgCDCECIAMoAggvAQAhAwNAIAAvAQAhBiACQQJqIgUgASgCBCIHSwR/IAEgB0EBdCICIAUQ2yoiBSACIAVLGxDoGSABKAIMBSACCyABKAIIaiADIAZqOwAAIAEgASgCDEECaiICNgIMIABBAmohACAEQQFrIgQNAAsLIAhBEGokAAvEAgEEfyAAQgA3AhAgAAJ/QQAgAUGAAkkNABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEgA0EBdGtBPmoLIgI2AhwgAkECdEGo8IoBaiEEQQEgAnQiA0HE84oBKAIAcUUEQCAEIAA2AgAgACAENgIYIAAgADYCDCAAIAA2AghBxPOKAUHE84oBKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgAkEBdmtBACACQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGCAAIAA2AgwgACAANgIIC8MCAgV/An4CQCAAQugHVARAIAAhCAwBCyABQQRrIQYgACEJA0AgAiAGaiIEQQFqIAkgCUKQzgCAIghCkM4Afn2nIgdB//8DcUHkAG4iBUEBdCIDQePziQFqLQAAOgAAIAQgA0Hi84kBai0AADoAACAEQQNqIAcgBUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAACAEQQJqIANB4vOJAWotAAA6AAAgAkEEayECIAlC/6ziBFYgCCEJDQALCyAIQglWBEAgASACakEBayAIpyIDIANB//8DcUHkAG4iBUHkAGxrQf//A3FBAXQiA0Hj84kBai0AADoAACABIAJBAmsiAmogA0Hi84kBai0AADoAACAFrSEICyAAUEUgCFBxRQRAIAEgAkEBayICaiAIp0EBdEEecUHj84kBai0AADoAAAsgAgu4AgEGfyMAQTBrIgMkAAJAIAEoAggiBAR/IAEoAgQiASAEQQN0aiEHAkADQCADQQhqIAEoAgAgAiABQQRqKAIAKAIUEQEAIAMoAgwhBCADKAIIIghBCEcEQCAAIAMpAxA3AwggAEEQaiADQRhqKQMANwMAIAAgBDYCBCAAIAg2AgAMBAsgAyAENgIAAkACQCAFRQRAIAQhBkEBIQUMAQsgAyAGNgIEIAQgBkcNAQsgAUEIaiIBIAdGDQIMAQsLIANBAjYCDCADQeTV0AA2AgggA0ICNwIUIANBOzYCLCADQTs2AiQgAyADQSBqNgIQIAMgAzYCKCADIANBBGo2AiAgAEEEaiADQQhqEJkOIABBADYCAAwCCyAGQQAgBRsFQQALIQEgAEEINgIAIAAgATYCBAsgA0EwaiQAC7gCAQZ/IwBBMGsiAyQAAkAgASgCCCIEBH8gASgCBCIBIARBA3RqIQcCQANAIANBCGogASgCACACIAFBBGooAgAoAhwRAQAgAygCDCEEIAMoAggiCEEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwAgACAENgIEIAAgCDYCAAwECyADIAQ2AgACQAJAIAVFBEAgBCEGQQEhBQwBCyADIAY2AgQgBCAGRw0BCyABQQhqIgEgB0YNAgwBCwsgA0ECNgIMIANB6NjQADYCCCADQgI3AhQgA0E7NgIsIANBOzYCJCADIANBIGo2AhAgAyADNgIoIAMgA0EEajYCICAAQQRqIANBCGoQmQ4gAEEANgIADAILIAZBACAFGwVBAAshASAAQQg2AgAgACABNgIECyADQTBqJAAL1QICBX8BfiMAQSBrIgMkAAJAAkACQAJAAkAgAC0AGCIFQcAARwRAIAAoAgQiBiAAKAIMIgcgACgCCGoiBGtBB00NAiAEIAZLDQMgACkDECEIIAAgB0EIajYCDCAAKAIAIARqIAggASAFrYaENwAAIAAgAUEAIAVrQT9xrYg3AxAMAQsgACgCBCIFIAAoAgwiBiAAKAIIaiIEa0EHTQ0DIAQgBUsNBCAAKQMQIQggACABNwMQIAAgBkEIajYCDCAAKAIAIARqIAg3AAALIAAgAkFAajoAGCADQSBqJAAPCyADQQA2AhggA0EBNgIMIANBrML7ADYCCCADQgQ3AhAgA0EIakHM3PsAEO8sAAsgBCAGQczc+wAQrzsACyADQQA2AhggA0EBNgIMIANBrML7ADYCCCADQgQ3AhAgA0EIakHc3PsAEO8sAAsgBCAFQdzc+wAQrzsAC7oCAQR/IABCADcCECAAAn9BACABQYACSQ0AGkEfIAFB////B0sNABogAUEGIAFBCHZnIgNrdkEBcSADQQF0a0E+agsiBDYCHCAEQQJ0QajwigFqIQICQEEBIAR0IgNBxPOKASgCAHFFBEAgAiAANgIAIAAgAjYCGEHE84oBQcTzigEoAgAgA3I2AgAMAQsCQAJAIAEgAigCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgBEEBdmtBACAEQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGAsgACAANgIMIAAgADYCCAvCAgIGfwJ+IwBBEGsiAyQAQYCAgIB4IQQCQAJAAkACfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNBCAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qC6wiCCAIQj+HIgkgBygCBC0AABD/IARAIAAoAgggAUEEdGoiACAJNwMIIAAgCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EQaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAu7BAEIfyMAQYABayIDJAAgA0H0AGogASACEMYvIgEQyQYgASgCDCIEIAQoAgAiAkEBajYCAAJAAkAgAkEASA0AIAEoAhAhBiABKAIUIgIEQCACIAIoAgAiBUEBajYCACAFQQBIDQEgASgCICEHIAEoAhwhCCABKAIYIQkgASgCKCEKIAEoAiQhBQsgA0HIAGogA0H8AGooAgA2AgAgAyADKQJ0NwNAIAMgCjYCaCADIAU2AmQgAyAHNgJgIAMgCDYCXCADIAk2AlggAyACNgJUIAMgBjYCUCADIAQ2AkwgAyABKQIsNwJsIANBCGoiByEBIwBBMGsiAiQAAkACQCADQUBrIgQtAABBHUYEQCACQQxqIAQoAjAgBCgCBBCKESAEKAIIIgYgBigCACIFQQFqNgIAIAVBAEgNASACQRhqIAQQmzYQ7iUgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIDQEgASAGNgIEIAFBHjoAACABIAIpAhg3AiAgASAFNgIMIAEgAikCDDcCFCABIAQoAhA2AhAgAUEoaiACQSBqKQIANwIAIAFBMGogAkEoaikCADcCACABQRxqIAJBFGooAgA2AgAgBBD7JCACQTBqJAAMAgtB/OOAAUEoQaTkgAEQnykLAAtBwABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABB5OWAATYCCCAAIAE2AgQgAEGTgICAeDYCACADQYABaiQADwsAC0EEQcAAEKM9AAu7BAEIfyMAQYABayIDJAAgA0H0AGogASACEMYvIgEQyQYgASgCDCIEIAQoAgAiAkEBajYCAAJAAkAgAkEASA0AIAEoAhAhBiABKAIUIgIEQCACIAIoAgAiBUEBajYCACAFQQBIDQEgASgCICEHIAEoAhwhCCABKAIYIQkgASgCKCEKIAEoAiQhBQsgA0HIAGogA0H8AGooAgA2AgAgAyADKQJ0NwNAIAMgCjYCaCADIAU2AmQgAyAHNgJgIAMgCDYCXCADIAk2AlggAyACNgJUIAMgBjYCUCADIAQ2AkwgAyABKQIsNwJsIANBCGoiByEBIwBBMGsiAiQAAkACQCADQUBrIgQtAABBHUYEQCACQQxqIAQoAjAgBCgCBBCCESAEKAIIIgYgBigCACIFQQFqNgIAIAVBAEgNASACQRhqIAQQmzYQ7iUgBCgCDCIFIAUoAgAiCEEBajYCACAIQQBIDQEgASAGNgIEIAFBGzoAACABIAIpAhg3AiAgASAFNgIMIAEgAikCDDcCFCABIAQoAhA2AhAgAUEoaiACQSBqKQIANwIAIAFBMGogAkEoaikCADcCACABQRxqIAJBFGooAgA2AgAgBBD7JCACQTBqJAAMAgtB/OOAAUEoQaTkgAEQnykLAAtBwABBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiAHQTj8CgAAIABBvOaAATYCCCAAIAE2AgQgAEGTgICAeDYCACADQYABaiQADwsAC0EEQcAAEKM9AAvOAgECfyAAQQRBBBDgHiAAQcgAahDNDCAAKAI4BEAgAEE4ahDPLwsgAEEMahDPLyAAQRxqEM8vIABBLGoiARCKFCABQQRBzAEQ4B4CQCAAKAKAAUGAgICAeEYNACAAQZgBahDNDCAAQYABaiIBEMUnIAFBBEEMEOAeIAAoApQBIgIEQCAAKAKQASEBA0AgARClHiABQcQAaiEBIAJBAWsiAg0ACwsgAEGMAWpBBEHEABDgHiAAKAKsASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQawBahD7HgsgAEHcAGoiARDFJyABQQRBDBDgHiAAQegAaiIBEIEjIAFBBEEIEOAeIABB9ABqIgEQgSMgAUEEQQgQ4B4gACgCxAEhASAAKALIASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAgRAIAEgAiAAKAIIEPg6Cwv5EwMdfwR+AW8jAEEgayIJJAACQAJAIAEoAggiESABKAIMRg0AIAFBEGohHAJAA0ACQCABIBFBCGo2AgggESgCACECIBEoAgQhAyMAQRBrIhYkACAWIAM2AgwgFiACNgIIAn8gFkEIaiECIwBBIGsiDyQAAkACfwJAQQBBkNLMACgCABEEACITBEAgEygCAA0DIBNBfzYCACAPQQhqIRAgAigCACEUIAIoAgQhF0EAIQIjAEEQayIdJAAgE0EEaiIMKAIEIgQgFCAXIBQbIgVxIQMgBa0iIUIZiEKBgoSIkKDAgAF+ISIgDCgCACEFAkACQANAAkAgAyAFaikAACIfICKFIiBCf4UgIEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIgUEUEQANAIBQgBSAgeqdBA3YgA2ogBHFBdGxqIg5BDGsoAgBGBEAgDkEIaygCACAXRg0DCyAgQgF9ICCDIiBQRQ0ACwsgHyAfQgGGg0KAgYKEiJCgwIB/g1BFDQIgAyACQQhqIgJqIARxIQMMAQsLIBAgDDYCBCAQIA42AgBBACEMDAELIAwoAghFBEAgHUEIaiEeIwBBQGoiByQAAkAgDCgCDCIOQQFqIgIgDk8EQAJAAkAgDCgCBCIGIAZBAWoiCEEDdiIEQQdsIAZBCEkbIhhBAXYgAkkEQCAHQTBqAn8gGEEBaiIDIAIgAiADSRsiAkEPTwRAIAJB/////wFLDQRBfyACQQN0QQduQQFrZ3ZBAWoMAQtBBEEIQRAgAkEISRsgAkEESRsLIgJBDEEIIAIQnRQgBygCNCEKIAcoAjAiC0UEQCAHKAI4IQIMBQsgBykCOCEfIApBCWoiAgRAIAtB/wEgAvwLAAsgByAfQiCIPgIsIAcgH6ciEjYCKCAHIAo2AiQgByALNgIgIAdBCDYCHCAOBEAgC0EMayEVIAtBCGohDSAMKAIAIgNBDGshGCADKQMAQn+FQoCBgoSIkKDAgH+DIR9BACECIA4hBCADIQUDQCAfUARAA0AgAkEIaiECIAVBCGoiBSkDAEKAgYKEiJCgwIB/gyIfQoCBgoSIkKDAgH9RDQALIB9CgIGChIiQoMCAf4UhHwsgCyADIB96p0EDdiACaiIZQXRsaiIGQQxrKAIAIgggBkEIaygCACAIGyIaIApxIgZqKQAAQoCBgoSIkKDAgH+DIiBQBEBBCCEIA0AgBiAIaiEGIAhBCGohCCALIAYgCnEiBmopAABCgIGChIiQoMCAf4MiIFANAAsLIB9CAX0gH4MhHyALICB6p0EDdiAGaiAKcSIGaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAtqIBpBGXYiCDoAACANIAZBCGsgCnFqIAg6AAAgFSAGQXRsaiIGQQhqIBggGUF0bGoiCEEIaigAADYAACAGIAgpAAA3AAAgBEEBayIEDQALCyAHIA42AiwgByASIA5rNgIoQQAhAgNAIAIgDGoiAygCACEEIAMgAiAHakEgaiIDKAIANgIAIAMgBDYCACACQQRqIgJBEEcNAAsgBygCJCICRQ0BIAIgAkEMbEETakF4cSIDakEJaiICRQ0BIAcoAiAgA2sgAkEIEPg6DAELIAwoAgAhAyAEIAhBB3FBAEdqIgUEQCADIQIDQCACIAIpAwAiH0J/hUIHiEKBgoSIkKDAgAGDIB9C//79+/fv37//AIR8NwMAIAJBCGohAiAFQQFrIgUNAAsLAkACQCAIQQhPBEAgAyAIaiADKQAANwAADAELIAgEQCADQQhqIAMgCPwKAAALIAhFDQELIANBCGohFSADQQxrIRlBASEEIAMhC0EAIQIDQCACIQogBCECAkAgAyAKaiIaLQAAQYABRw0AIBkgCkF0bGohEgJAA0AgEigCACIEIBIoAgQgBBsiGyAGcSIEIQUgAyAEaikAAEKAgYKEiJCgwIB/gyIfUARAQQghDQNAIAUgDWohBSANQQhqIQ0gAyAFIAZxIgVqKQAAQoCBgoSIkKDAgH+DIh9QDQALCyADIB96p0EDdiAFaiAGcSIFaiwAAEEATgRAIAMpAwBCgIGChIiQoMCAf4N6p0EDdiEFCyAFIARrIAogBGtzIAZxQQhPBEAgAyAFaiIELQAAIAQgG0EZdiIEOgAAIBUgBUEIayAGcWogBDoAACAFQXRsIQRB/wFGDQIgAyAEaiEFQXQhBANAIAQgC2oiDSgAACEbIA0gBCAFaiINKAAANgAAIA0gGzYAACAEQQRqIgQNAAsMAQsLIBogG0EZdiIEOgAAIBUgCkEIayAGcWogBDoAAAwBCyAaQf8BOgAAIBUgCkEIayAGcWpB/wE6AAAgBCAZaiIEQQhqIBJBCGooAAA2AAAgBCASKQAANwAACyALQQxrIQsgAiACIAhJIgVqIQQgBQ0ACwsgDCAYIA5rNgIIC0GBgICAeCEKDAILEOMnIAcoAgwhAiAHKAIIIQoMAQsQ4ycgBygCBCECIAcoAgAhCgsgHiAKNgIAIB4gAjYCBCAHQUBrJAALIBAgFzYCDCAQIBQ2AgggECAhNwMACyAQIAw2AhAgHUEQaiQAIA8oAhgiAkUNASAPKQMIIR8gDykDECEgIA8gFCAXEJM+NgIQIA8gIDcCCCACIB8gEBD6EgwCC0HQ0cwAEJgnAAsgDygCCAtBBGsoAgAQ9DogEyATKAIAQQFqNgIAIA9BIGokAAwBC0GU0swAEJs+AAshAiAWQRBqJAAgCSACNgIQIBwoAgAlASAJQRBqIgIoAgAlARAMISMQ3xIiAyAjJgEgCSADNgIUAkAgCUEUahCpOwRAIAIoAgAlASAcKAIAJQEQb0UNAQsgCSgCFCECAkAgASgCAEUNACABKAIEIgNBhAFJDQAgAxDyHwsgASACNgIEQQEhBCABQQE2AgAgCUEIaiARKAIAIBEoAgQQtTYgCUEYaiEBAkACQAJAAkACQCAJKAIIIgIgCSgCDCIDQbzKwwBBCRDBLkUEQCACIANBxcrDAEEJEMEuDQEgAiADQc7KwwBBBRDBLg0CIAIgA0HTysMAQQYQwS4NAyACIANB2crDAEEHEMEuDQQgAiADQeDKwwBBCxDBLkUEQCABQQY6AAEMBgsgAUEFOgABDAULIAFBADoAAQwECyABQQE6AAEMAwsgAUECOgABDAILIAFBAzoAAQwBCyABQQQ6AAELIAFBADoAACAJLQAYRQ0BIAAgCSgCHDYCBAwDCyAJKAIUIgJBhAFPBEAgAhDyHwsgCSgCECICQYQBTwRAIAIQ8h8LIAEoAggiESABKAIMRw0BDAMLCyAAIAktABk6AAFBACEECyAAIAQ6AAAgCSgCECIAQYQBSQ0BIAAQ8h8MAQsgAEGADjsBAAsgCUEgaiQAC5QCAQt/IAAgAUECdEEEayIDaiEFIAIgA2ohBiAAIAFBAXYiC0ECdGoiA0EEayEEA0AgAiADKAIAIgcgACgCACIIIAdBGHYiByAIQRh2IghJIgwbNgIAIAYgBCgCACIJIAUoAgAiCiAKQRh2IgogCUEYdiIJSSINGzYCACAEQXxBACANG2ohBCAFQXxBACAJIApNG2ohBSAAIAcgCE9BAnRqIQAgAyAMQQJ0aiEDIAZBBGshBiACQQRqIQIgC0EBayILDQALIARBBGohBCABQQFxBH8gAiAAIAMgACAESSIBGygCADYCACADIAAgBE9BAnRqIQMgACABQQJ0agUgAAsgBEcgAyAFQQRqR3JFBEAPCxDkKwAL0AIBBn8jAEHAAmsiBSQAIAEoAvQCIgYoAhQiBEEIaiAEKAIIQQJGQQJ0aiIHLQAhIQhBACEEAkACQAJAAkAgBi8BGCIJDgIAAQILIAVCBTcDAAwCCyAGLwEaDQAgBy0AICIEQQNHIARBAEdxIQQLIAUgCSAEEJ8aCwJAIAYvARoiBEUEQCAFQgQ3A1AMAQsgBUHQAGogBBDgIwsgBiAGKAIAIgRBAWo2AgAgBEEATgRAQQAiBEUEQCAFQfABaiAFQdAA/AoAAAsgBEUEQCAFQaABaiAFQdAAakHQAPwKAAALIAEQvB8gASAFQaABakGgAfwKAAAgAUIANwKcAiABIAY2ApgCIAEgAzYClAIgASACNgKQAiABIAhBAUY6AIgCIAFBgICAgHg2AvABIAFCBjcDoAEgAUGkAmpBADoAACAAQQg2AgAgBUHAAmokAA8LAAvQAgEGfyMAQcACayIFJAAgASgC9AIiBigCFCIEQQhqIAQoAghBAkZBAnRqIgctACEhCEEAIQQCQAJAAkACQCAGLwEYIgkOAgABAgsgBUIFNwMADAILIAYvARoNACAHLQAgIgRBA0cgBEEAR3EhBAsgBSAJIAQQnxoLAkAgBi8BGiIERQRAIAVCBDcDUAwBCyAFQdAAaiAEEOAjCyAGIAYoAgAiBEEBajYCACAEQQBOBEBBACIERQRAIAVB8AFqIAVB0AD8CgAACyAERQRAIAVBoAFqIAVB0ABqQdAA/AoAAAsgARDNISABIAVBoAFqQaAB/AoAACABQgA3ApwCIAEgBjYCmAIgASADNgKUAiABIAI2ApACIAEgCEEBRjoAiAIgAUGAgICAeDYC8AEgAUIGNwOgASABQaQCakEAOgAAIABBCDYCACAFQcACaiQADwsAC9ACAQZ/IwBBwAJrIgUkACABKAL0AiIGKAIUIgRBCGogBCgCCEECRkECdGoiBy0AISEIQQAhBAJAAkACQAJAIAYvARgiCQ4CAAECCyAFQgU3AwAMAgsgBi8BGg0AIActACAiBEEDRyAEQQBHcSEECyAFIAkgBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNQDAELIAVB0ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQEEAIgRFBEAgBUHwAWogBUHQAPwKAAALIARFBEAgBUGgAWogBUHQAGpB0AD8CgAACyABELsfIAEgBUGgAWpBoAH8CgAAIAFCADcCnAIgASAGNgKYAiABIAM2ApQCIAEgAjYCkAIgASAIQQFGOgCIAiABQYCAgIB4NgLwASABQgY3A6ABIAFBpAJqQQA6AAAgAEEINgIAIAVBwAJqJAAPCwALgBIDFn8EfgN9IwBBEGsiDCQAAkAgAS0AlAFFDQAgASgCjAEoAhQiBUEIaiAFKAIIQQJGQQJ0ai0AIUEWRg0AIAIiBSADQQJ0aiEGIAxBBGoiBwJ/A0BBACAFIAZGDQEaIAUqAgAhHiAFQQRqIgghBSAeIB5cDQALIB4hHyAIQQRrIgUhBANAIAYgCEcEQCAIKgIAISAgCEEEaiEIICAgIFwNASAIQQRrIgkgBCAeICBdIgobIQQgCSAFIB8gIF4iCRshBSAgIB4gChshHiAgIB8gCRshHwwBCwsgBSoAACEeIAdDAAAAACAEKgAAIh8gH0MAAAAAWxs4AgggB0MAAACAIB4gHkMAAAAAWxs4AgRBAQs2AgAgDCgCBEEBRw0AIAwqAgwhHgJAIAwqAggiHyAfXA0AIAEoAhBBAUYEQCABKgIUIB9eRQ0BCyABIB84AhQgAUEBNgIQCyAeIB5cDQAgASgCGEEBRgRAIB4gASoCHF5FDQELIAEgHjgCHCABQQE2AhgLIANFIAEoAoABQYCAgIB4RnJFBEAgAUGAAWohBCADQQJ0IQggAiEFA0AgBCAFQQQQhgoQohUgBUEEaiEFIAhBBGsiCA0ACwsCQCABKAJoQYCAgIB4RwRAIAFBIGoiAUHIAGogAxDsLSADBEAgA0ECdCEDA0AjAEEwayIOJAAgDkEYaiEIIAFBEGoiByACQQQQzQIhHCABQTBqIQVBACEGQQAhDUEAIQ9BACERQQAhEiMAQRBrIhMkACABKAIIRQRAAkAgE0EIaiEUIwBB4ABrIgQkACAEIAU2AhwgBCAHNgIYIAEoAgwhCSAEIARBGGo2AiACQAJAAkACQAJAIAkgCUEBaiIHTQRAIAEoAgQiCSAJQQFqQQN2QQdsIAlBCEkbIglBAXYgB0kEQCAJQQFqIgYgByAGIAdLGyIGQQ9JDQIgBkH/////AU0EQEF/IAZBA3RBB25BAWtndkEBaiEGDAQLEN0nIAQoAhQhBiAEKAIQIgdBgYCAgHhHDQUMAwsgASAEQSBqQeSmzwAQ6wkMAwsQ3ScgBCgCBCEGIAQoAgAhBwwDC0EEQQhBECAGQQhJGyAGQQRJGyEGCyAEQdAAaiABQRBqIgpBCCAGEPsUIAQoAlghBiAEKAJUIQcgBCgCUCIJRQ0BIAQgBCgCXDYCTCAEIAY2AkggBCAHNgJEIAQgCTYCQCAEQQhqIARBQGsQwTQgBCgCDCIGBEAgBCgCCEH/ASAG/AsACyAEKAJIIQYgBCgCRCEHIAQoAkAiCUUNASAEIAQoAkw2AjwgBCAGNgI4IAQgBzYCNCAEIAk2AjAgBEKIgICAgAE3AiggBCAKNgIkIAQgASgCDCIVBH8gCUEIaiEXIAEoAgAiFikDAEJ/hUKAgYKEiJCgwIB/gyEaA0AgGlAEQANAIA1BCGohDSAWQQhqIhYpAwBCgIGChIiQoMCAf4MiGkKAgYKEiJCgwIB/UQ0ACyAaQoCBgoSIkKDAgH+FIRoLIAQoAiAiCygCBCIQKAIIIhggASgCACAaeqdBA3YgDWpBA3QiGWtBCGsoAgAiCk0NBCAJIAcgCygCACAQKAIEIApBAnRqQQQQzQKnIhBxIgpqKQAAQoCBgoSIkKDAgH+DIhtQBEBBCCELA0AgCiALaiEKIAtBCGohCyAJIAcgCnEiCmopAABCgIGChIiQoMCAf4MiG1ANAAsLIBpCAX0gGoMhGiAJIBt6p0EDdiAKaiAHcSIKaiwAAEEATgRAIAkpAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAJIApqIBBBGXYiCzoAACAXIApBCGsgB3FqIAs6AAAgCSAKQQN0a0EIayABKAIAIBlrQQhrKQAANwAAIBVBAWsiFQ0ACyABKAIMBUEACyIHNgI8IAQgBiAHazYCOCABIARBMGpBBBD6KiAEQSRqEPUnC0GBgICAeCEHCyAUIAY2AgQgFCAHNgIAIARB4ABqJAAMAQsgCiAYQZSQzgAQwyEACwsgASgCBCIGIByncSEEIBxCGYhC/wCDQoGChIiQoMCAAX4hHSAFKAIEIQ0gBSgCCCEJIAEoAgAhBwNAAkAgBCAHaikAACIbIB2FIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQAJAIAgCfgJAA0AgGlANASAJIAEoAgAgGnqnQQN2IARqIAZxIgtBA3RrQQhrKAIAIgpNDQMgGkIBfSAagyEaIAJBBCANIApBAnRqQQQQnztFDQALIAggHDcDCCAIIAEoAgBBACALa0EDdGo2AhBCAAwBCyAbQoCBgoSIkKDAgH+DIRogEUUEQCAaUA0DIBp6p0EDdiAEaiAGcSEPC0EBIBogG0IBhoNQDQMaIAggByAPaiwAAEEATgR/IAcpAwBCgIGChIiQoMCAf4N6p0EDdgUgDws2AhAgCCAcNwMIQgELNwMAIAggATYCFCATQRBqJAAMAwsgCiAJQZSQzgAQwyEAC0EACyERIAQgEkEIaiISaiAGcSEEDAELCyAOQQhqIQQCQCAIKAIAQQFGBEAgCCkDCCEaIAgoAhAhBiAIKAIUIQggBSAFKAIMQQRqNgIMIAIqAgAhHiAFKAIIIgcgBSgCAEYEQCAFQaSQzgAQnSgLIAUoAgQgB0ECdGogHjgCACAFIAdBAWo2AgggBiAIKAIAIgVqIgktAAAhCiAJIBqnQRl2Igk6AAAgBSAIKAIEIAZBCGtxakEIaiAJOgAAIAQgCDYCDCAEIBo3AwAgCCAIKAIMQQFqNgIMIAQgBSAGQQN0ayIFNgIIIAggCCgCCCAKQQFxazYCCCAFQQhrIAetNwMADAELIAQgCEEIaiIFKQMANwMAIARBCGogBUEIaikDADcDAAsgDigCEEEIaykDACEaIA5BMGokACABKAJQIgUgASgCSEYEQCABQcgAakHUkM4AELMoCyABKAJMIAVBA3RqIBo3AwAgASAFQQFqNgJQIAJBBGohAiADQQRrIgMNAAsLIABBCDYCAAwBCyAAIAEoAnggAiADIAEoAnwoAgwRBQALIAxBEGokAAuQEgMWfwR+A3wjAEEgayIMJAACQCABLQCkAUUNACABKAKcASgCFCIFQQhqIAUoAghBAkZBAnRqLQAhQRZGDQAgAiIFIANBA3RqIQYgDEEIaiIHAn4DQEIAIAUgBkYNARogBSsDACEeIAVBCGohBSAeIB5iDQALIB4hHyAFQQhrIgkhBANAIAUgBkcEQCAFKwMAISAgBUEIaiEFICAgIGINASAFQQhrIgggBCAeICBjIgobIQQgCCAJIB8gIGQiCBshCSAgIB4gChshHiAgIB8gCBshHwwBCwsgCSsAACEeIAdEAAAAAAAAAAAgBCsAACIfIB9EAAAAAAAAAABhGzkDECAHRAAAAAAAAACAIB4gHkQAAAAAAAAAAGEbOQMIQgELNwMAIAwoAghBAUcNACAMKwMYIR4CQCAMKwMQIh8gH2INACABKAIAQQFGBEAgASsDCCAfZEUNAQsgASAfOQMIIAFCATcDAAsgHiAeYg0AIAEoAhBBAUYEQCAeIAErAxhkRQ0BCyABIB45AxggAUIBNwMQCyADRSABKAKQAUGAgICAeEZyRQRAIAFBkAFqIQQgA0EDdCEJIAIhBQNAIAQgBUEIEIYKEKIVIAVBCGohBSAJQQhrIgkNAAsLAkAgASgCeEGAgICAeEcEQCABQTBqIgVByABqIAMQ7C0gAwRAIANBA3QhAQNAIwBBMGsiDiQAIA5BGGohCSAFQRBqIgcgAkEIEM0CIRwgBUEwaiEDQQAhBkEAIQ1BACEPQQAhEUEAIRIjAEEQayITJAAgBSgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCADNgIcIAQgBzYCGCAFKAIMIQggBCAEQRhqNgIgAkACQAJAAkACQCAIIAhBAWoiB00EQCAFKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAdJBEAgCEEBaiIGIAcgBiAHSxsiBkEPSQ0CIAZB/////wFNBEBBfyAGQQN0QQduQQFrZ3ZBAWohBgwECxDdJyAEKAIUIQYgBCgCECIHQYGAgIB4Rw0FDAMLIAUgBEEgakH0pM8AEOsJDAMLEN0nIAQoAgQhBiAEKAIAIQcMAwtBBEEIQRAgBkEISRsgBkEESRshBgsgBEHQAGogBUEQaiIKQQggBhD7FCAEKAJYIQYgBCgCVCEHIAQoAlAiCEUNASAEIAQoAlw2AkwgBCAGNgJIIAQgBzYCRCAEIAg2AkAgBEEIaiAEQUBrEME0IAQoAgwiBgRAIAQoAghB/wEgBvwLAAsgBCgCSCEGIAQoAkQhByAEKAJAIghFDQEgBCAEKAJMNgI8IAQgBjYCOCAEIAc2AjQgBCAINgIwIARCiICAgIABNwIoIAQgCjYCJCAEIAUoAgwiFQR/IAhBCGohFyAFKAIAIhYpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCANQQhqIQ0gFkEIaiIWKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIgIgsoAgQiECgCCCIYIAUoAgAgGnqnQQN2IA1qQQN0IhlrQQhrKAIAIgpNDQQgCCAHIAsoAgAgECgCBCAKQQN0akEIEM0CpyIQcSIKaikAAEKAgYKEiJCgwIB/gyIbUARAQQghCwNAIAogC2ohCiALQQhqIQsgCCAHIApxIgpqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogCCAbeqdBA3YgCmogB3EiCmosAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCCAKaiAQQRl2Igs6AAAgFyAKQQhrIAdxaiALOgAAIAggCkEDdGtBCGsgBSgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgBSgCDAVBAAsiBzYCPCAEIAYgB2s2AjggBSAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBwsgFCAGNgIEIBQgBzYCACAEQeAAaiQADAELIAogGEGUkM4AEMMhAAsLIAUoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gAygCBCENIAMoAgghCCAFKAIAIQcDQAJAIAQgB2opAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkACQCAJAn4CQANAIBpQDQEgCCAFKAIAIBp6p0EDdiAEaiAGcSILQQN0a0EIaygCACIKTQ0DIBpCAX0gGoMhGiACQQggDSAKQQN0akEIEJ87RQ0ACyAJIBw3AwggCSAFKAIAQQAgC2tBA3RqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAyAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0DGiAJIAcgD2osAABBAE4EfyAHKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAkgHDcDCEIBCzcDACAJIAU2AhQgE0EQaiQADAMLIAogCEGUkM4AEMMhAAtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgDkEIaiEEAkAgCSgCAEEBRgRAIAkpAwghGiAJKAIQIQYgCSgCFCEJIAMgAygCDEEIajYCDCACKwMAIR4gAygCCCIHIAMoAgBGBEAgA0GkkM4AELMoCyADKAIEIAdBA3RqIB45AwAgAyAHQQFqNgIIIAYgCSgCACIDaiIILQAAIQogCCAap0EZdiIIOgAAIAMgCSgCBCAGQQhrcWpBCGogCDoAACAEIAk2AgwgBCAaNwMAIAkgCSgCDEEBajYCDCAEIAMgBkEDdGsiAzYCCCAJIAkoAgggCkEBcWs2AgggA0EIayAHrTcDAAwBCyAEIAlBCGoiAykDADcDACAEQQhqIANBCGopAwA3AwALIA4oAhBBCGspAwAhGiAOQTBqJAAgBSgCUCIDIAUoAkhGBEAgBUHIAGpB1JDOABCzKAsgBSgCTCADQQN0aiAaNwMAIAUgA0EBajYCUCACQQhqIQIgAUEIayIBDQALCyAAQQg2AgAMAQsgACABKAKIASACIAMgASgCjAEoAgwRBQALIAxBIGokAAu1AgIEfwF+IwBBIGsiAyQAAkAgASgCbCIEIAEoAnAiBXIgASgCaCICckUNAAJAAkAgBQ0AIAIgBEcEQCAERSACcg0BDAILIAQNAQsgAkEBa0EHSQRAIAFBGGohBANAIAQgAkEDdGpCADcDACABIAEoAmhBAWoiAjYCaCACQQhJDQALIAEoAnAhBQsgASACIAVqNgJwIAFBARD6CyABQQA2AmwMAQsgARC9DQsgA0EQaiICIAFBEGopAwA3AwAgA0EIaiIEIAFBCGopAwA3AwAgAyABKQMAIgY3AwAgAy0AFCEBIAMgBjcDGCABQQN2IAFBB3FBAEdqIgFBCU8EQCABQQhB6I7OABCwOwALIAQgA0EYaiABEKE2IABBCGogAigCADYCACAAIAMpAwg3AgAgA0EgaiQAC4YOAgZ/An4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgoBAgMEBQYHCAkKAAtB5M3OAEEMQZDOzgAQ7SwACwJ/AkACQCAAQQRqIgUoAiAiCkUEQAJAIAFFIAJBgBBLckUEQCACRQ0BIAUoAgAhASAFKAIEIQcgBCEAA0AgBCAGSQ0EIAMgBmogABC3HiIIIAdPDQUgASAIQQJ0akEANgIAIABBAWshACACIAZBAWoiBkcNAAsMAQsgBSgCBCIARQ0AIABBAnQiAEUNACAFKAIAQQAgAPwLAAsgBUEBNgIgCyAKRQwCCyAGIARBxM3OABCvOwALIAhBAWogB0HUzc4AELA7AAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAEEtyRQRAIAJFDQEgCSgCACEIIAkoAgQhBiAEIQADQCAEIAVJDQ4gAyAFaiAAELceIgpBAmoiASAGSw0PIAggCkECdGpCADcCACAAQQFrIQAgAiAFQQFqIgVHDQALDAELIAkoAgQiAEUNACAAQQJ0IgBFDQAgCSgCAEEAIAD8CwALIAlBATYCIAsgB0UMAAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAIEtyRQRAIAJFDQEgCSgCACEIIAkoAgQhBiAEIQADQCAEIAVJDQ0gAyAFaiAAELYeIgpBBGoiASAGSw0OIAggCkECdGoiAUIANwIAIAFBCGpCADcCACAAQQFrIQAgAiAFQQFqIgVHDQALDAELIAkoAgQiAEUNACAAQQJ0IgBFDQAgCSgCAEEAIAD8CwALIAlBATYCIAsgB0UMAAsPCwJ/IABBBGoiCSgCICIHRQRAAkAgAUUgAkGAgAJLckUEQCACRQ0BIAkoAgAhCCAJKAIEIQYgBCEAA0AgBCAFSQ0MIAMgBWogABCWGiIKQQRqIgEgBksNDSAIIApBAnRqIgFCADcCACABQQhqQgA3AgAgAEEBayEAIAIgBUEBaiIFRw0ACwwBCyAJKAIEIgBFDQAgAEECdCIARQ0AIAkoAgBBACAA/AsACyAJQQE2AiALIAdFDAALDwsCfwJAAkACQCAAQQRqIgYoAigiCkUEQAJAIAFFIAIgBigCOCIBQQZ2S3JFBEAgAkUNASAEIQADQCAEIAdJDQYgBjUCNCELIAMgB2ogABDvICEMIAYoAgQiASAMIAuIpyIITQ0EIAYoAgAgCEEBdGpBADsBACAAQQFrIQAgAiAHQQFqIgdHDQALDAELIAEgBigCBCIASw0DIAFFDQAgAUEBdCIARQ0AIAYoAgBBACAA/AsACyAGQQE2AigLIApFDAMLIAggAUHc1s4AEMMhAAsgASAAQbzWzgAQsDsACyAHIARBzNbOABCvOwALDwsCfwJAIABBBGoiBSgCKCIKRQRAAkAgAUUgAkGABEtyRQRAIAJFDQEgBSgCACEBIAUoAgQhByAEIQADQCAEIAZJDQ4gAyAGaiAAEMYgIgggB08NDSABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyAFKAIEIgBB//8BTQ0CIAUoAgBBAEGAgAT8CwALIAVBATYCKAsgCkUMAQtBgIACIABBvNbOABCwOwALDwsCfwJAIABBBGoiBSgCKCIKRQRAAkAgAUUgAkGAAktyRQRAIAJFDQEgBSgCACEBIAUoAgQhByAEIQADQCAEIAZJDQ0gAyAGaiAAEMcgIgggB08NDCABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyAFKAIEIgBB//8ATQ0CIAUoAgBBAEGAgAL8CwALIAVBATYCKAsgCkUMAQtBgIABIABBvNbOABCwOwALDwsCfwJAIABBCGoiBSgCQCIKRQRAAkAgAUUgAiAFKAIcIgFBBnZLckUEQCACRQ0BIAUoAgAhASAFKAIEIQcgBCEAA0AgBCAGSQ0MIAUgAyAGaiAAEJcdIgggB08NCyABIAhBAXRqQQA7AQAgAEEBayEAIAIgBkEBaiIGRw0ACwwBCyABIAUoAgQiAEsNAiABRQ0AIAFBAXQiAEUNACAFKAIAQQAgAPwLAAsgBUEBNgJACyAKRQwBCyABIABBvNbOABCwOwALDwsgACgCLA0BAkAgACgCCCIBRQ0AIAFBAXQiAUUNACAAKAIEQQAgAfwLAAsgAEEBNgIsQQEPCyAAKAI0DQAgACgCCCICBEAgACgCBCEEIAAoAkAhASACQQJ0IQMDQCAEIAE2AgAgBEEEaiEEIANBBGsiAw0ACwsgAEEBNgI0QQEPC0EADwsgBSAEQcTNzgAQrzsACyABIAZB1M3OABCwOwALIAggB0Hc1s4AEMMhAAsgBiAEQczWzgAQrzsAC7UCAgR/AX4jAEEgayIDJAACQCABKAJsIgQgASgCcCIFciABKAJoIgJyRQ0AAkACQCAFDQAgAiAERwRAIARFIAJyDQEMAgsgBA0BCyACQQFrQQdJBEAgAUEYaiEEA0AgBCACQQN0akIANwMAIAEgASgCaEEBaiICNgJoIAJBCEkNAAsgASgCcCEFCyABIAIgBWo2AnAgAUEBEPoLIAFBADYCbAwBCyABEL0NCyADQRBqIgIgAUEQaikDADcDACADQQhqIgQgAUEIaikDADcDACADIAEpAwAiBjcDACADLQAUIQEgAyAGNwMYIAFBA3YgAUEHcUEAR2oiAUEJTwRAIAFBCEGQic8AELA7AAsgBCADQRhqIAEQoTYgAEEIaiACKAIANgIAIAAgAykDCDcCACADQSBqJAALrAICBX8BfiMAQUBqIgUkAEJ/IQogAkJ/USIHIANBACAEQQFHGyIGRXFFBEAgAiAGrXxC9ANCACAGG0IAIAcbfCEKCyAFQThqIgggCkKBgBBUIApCgYAIVGogCkKBgAFUakGEBWxBFiABIAFBFk8bQQAgAUEAThtBAyABG0EcbGoiBkH4+tAAaigCADYCACAFQTBqIgcgBkHw+tAAaikCADcDACAFQShqIgkgBkHo+tAAaikCADcDACAFIAZB4PrQAGopAgA3AyAgAUEASARAIAVBAEGAgHggASABQYCAeE0bazYCNAsgBUEYaiAIKAIANgIAIAVBEGogBykDADcDACAFQQhqIAkpAwA3AwAgBSAFKQMgNwMAIAAgBSACIAMgBEEAEOoLIAVBQGskAAuoAgIDfwJ9IwBBIGsiBSQAAkAgA0EBcUUEQAwBCyACRQRAQQAhAgwBCyACQQFrIQJDAAAAACABKAIAIgRB//8DcUECdEHMhuMAaioCACAEs5STIQcgAUEEaiEBCyACIANBfnEiBk8EQCAGBEAgA0ECdEF4cSECA0AgASgCACIDIARqIQQgByADQf//A3FBAnRBzIbjAGoqAgAgA7OUkyEHIAFBBGohASACQQRrIgINAAsLIAQEQCAEsyEIIAcCfSAEQYACTwRAIAgQ6hIMAQsgBEECdEHAh/MAaioCAAsgCJSSIQcLIAAgBDYCBCAAIAc4AgAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQayX0gA2AgggBUIENwIQIAVBCGpBtJfSABDvLAALuwIBBX8jAEEgayIDJAAgA0EQaiABQQFqQQBBBEEEEKAYIAMoAhQhBQJAAkAgAygCEEEBRwRAIANBADYCDCADIAMoAhgiBDYCCCADIAU2AgQgBQR/IAQFIANBBGpBwLeAARCdKCADKAIIC0EANgIAIANBATYCDCABBEBBBCEHQQAhBANAIAQgAiAEaiIESw0DIAZBAWoiBSADKAIERgRAIANBBGpBkLiAARCdKAsgAygCCCAHaiAENgIAIAMgBkECajYCDCAHQQRqIQcgBSIGIAFHDQALIARBAEgNAwsgA0EYaiADQQxqKAIANgIAIAMgAykCBDcDECAAIANBEGoQ6BggA0EgaiQADwsgBSADKAIYQbC3gAEQ/S8AC0Hwt4ABQQ5BgLiAARDLJAALQdC3gAFBD0Hgt4ABEMskAAvPAgENfyMAQdAAayICJAAgAkHEAGogARDYBgJAIAEoAiwiBgRAIAYgBigCACIDQQFqNgIAIANBAEgNASABKAI8IQkgASgCOCEKIAEoAjQhCyABKAIwIQwgASgCQCEICyABKAIMIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIUIgQgBCgCACIFQQFqNgIAIAVBAEgNACABKAIQIQ0gASgCICIFIAUoAgAiB0EBajYCACAHQQBIDQAgASgCHCEHIAEoAhghDiACQQhqIAJBzABqKAIANgIAIAIgAikCRDcDACACIAg2AkAgAiAJNgI8IAIgCjYCOCACIAs2AjQgAiAMNgIwIAIgBjYCLCACIAU2AiAgAiAHNgIcIAIgDjYCGCACIAQ2AhQgAiANNgIQIAIgAzYCDCACIAEpAiQ3AiQgACACEOAOIAJB0ABqJAAPCwALzwIBDX8jAEHQAGsiAiQAIAJBxABqIAEQ2AYCQCABKAIsIgYEQCAGIAYoAgAiA0EBajYCACADQQBIDQEgASgCPCEJIAEoAjghCiABKAI0IQsgASgCMCEMIAEoAkAhCAsgASgCDCIDIAMoAgAiBEEBajYCACAEQQBIDQAgASgCFCIEIAQoAgAiBUEBajYCACAFQQBIDQAgASgCECENIAEoAiAiBSAFKAIAIgdBAWo2AgAgB0EASA0AIAEoAhwhByABKAIYIQ4gAkEIaiACQcwAaigCADYCACACIAIpAkQ3AwAgAiAINgJAIAIgCTYCPCACIAo2AjggAiALNgI0IAIgDDYCMCACIAY2AiwgAiAFNgIgIAIgBzYCHCACIA42AhggAiAENgIUIAIgDTYCECACIAM2AgwgAiABKQIkNwIkIAAgAhDhDiACQdAAaiQADwsAC7wDAQd/IwBBEGsiCCQAAkAgBCADIARqIgJNBEAgAiAAKAIEIgZLDQEgACgCACADaiICIARqIQYgASgCDCIDIARqIgcgASgCBCIFSwRAIAEgBUEBdCIDIAcQ3SoiBSADIAVLGxDoGSABKAIEIQUgASgCDCEDCyAAQQhqIQcCQCAFIANBAWpJDQAgAyAEaiEAIActAAAhCSABKAIIIQoDQCAERQRAIAYhAiAAIQMMAgsgAyAKaiACLQAAIAlqOgAAIARBAWshBCACQQFqIQIgA0ECaiELIANBAWohAyAFIAtPDQALCyABIAM2AgwgCCAHNgIMIAggBjYCCCAIIAI2AgQgCEEEaiIDKAIAIgAgAygCBCICRwRAIAIgAGshBCABKAIMIQIgAygCCC0AACEDA0AgAC0AACEGIAJBAWoiBSABKAIEIgdLBH8gASAHQQF0IgIgBRDbKiIFIAIgBUsbEOgZIAEoAgwFIAILIAEoAghqIAMgBmo6AAAgASABKAIMQQFqIgI2AgwgAEEBaiEAIARBAWsiBA0ACwsgCEEQaiQADwsgAyACQcSchwEQsTsACyACIAZBxJyHARCwOwALzQICBH8EfiMAQcACayIBJAAgAUEIaiICIAAQlRogASkCjAEhBSABKQKUASEGIAEvAZwBIQAgAUGQAmogAUHwAGooAgA2AgAgAUGcAmogAUH8AGooAgA2AgAgAUHwAWogAUHQAGopAwA3AwAgAUH4AWogAUHYAGopAwA3AwAgAUGAAmogAUHgAGopAwA3AwAgASABKQNoNwOIAiABIAEpAnQ3ApQCIAEgASkDSDcD6AEgAS0AngEhAyABQagCaiABQYgBaigCADYCACABIAEpA4ABNwOgAiABKQM4IQcgASkDQCEIIAEtAJ8BIQQgAUGoAWogAkEw/AoAACABIAQ6AL8CIAEgAzoAvgIgASAAOwG8AiABIAY3ArQCIAEgBTcCrAIgASAINwPgASABIAc3A9gBIAFBADYCoAEgAUGgAWoQ0SlBCGogAUHAAmokAAvPAgEDfyMAQTBrIgIkACAAKAIAIQACQAJAIAFB/wFxRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiAyADQQFNGzYCNCAAKAIIGiAAQTBqIgNBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIANBARCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBEUNASACKAIAIAE6AAAgACgCMCEDIAAoAhQiASAAKAIMRgRAIABBDGpBxMb+ABCbKAsgACgCECABQQN0aiIEQQQ7AQQgBCADNgIAIAAgAUEBajYCFAsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQfTI/gA2AhggAkIENwIgIAJBGGpBvMf+ABDvLAALeQEBfwJAAkACQAJAAkBBCyAAKAIAIgFBgICAgHhzIAFBAE4bDhAEAAQEBAQEAwQEBAEEBAQCAwsgAEEEahC8Kg8LIAAQ3jsgAC0ADEEDRw0BIAAoAhAiABC8KiAAQQxBBBD4Og8LIABBBGoQ3jsLDwsgAEEEahDeOwuqAgEEfyMAQUBqIgckACAHQQRqQQBBPPwLACAHQX82AgACQCAAIAJJBEADQAJAAkACQAJAIAEgAEEDdGoiAC4BBCIJQQBOBEAgBkEBaiIGIAVMDQEMBwsgBCAALgEGIgBNDQEgACADaiAGOgAAIAZBD0sNAkEAIAZrIQggByAGQQJ0aiEGA0AgBigCACIAQX9GBEAgBkEEayEGIAhBAWoiCEEBRw0BDAgLCyAGQX82AgBBACAIayEGDAMLIAZBD00EQCAHIAZBAnRqIAAuAQY2AgAgCSEADAMLIAZBEEGoj9IAEMMhAAsgACAEQYiP0gAQwyEACyAGQRBBmI/SABDDIQALIAAgAkkNAAsLIAAgAkH4jtIAEMMhAAsgB0FAayQAIAlBgIACcUEPdgu1AgIFfwJ+IwBBIGsiAyQAIANBEGogAUEBakEAQQhBCBCgGCADKAIUIQQCQCADKAIQQQFHBEAgA0EANgIMIAMgAygCGCIFNgIIIAMgBDYCBCAEBH8gBQUgA0EEakHAt4ABELMoIAMoAggLQgA3AwAgA0EBNgIMIAEEQEEAIQVBCCEGIAKtIgkhCEEAIQQDQCAEIAIgBGoiBEsNAyAFQQFqIgcgAygCBEYEQCADQQRqQZC4gAEQsygLIAMoAgggBmogCDcDACADIAVBAmo2AgwgBkEIaiEGIAggCXwhCCAHIgUgAUcNAAsLIANBGGogA0EMaigCADYCACADIAMpAgQ3AxAgACADQRBqEL0YIANBIGokAA8LIAQgAygCGEGwt4ABEP0vAAtB8LeAAUEOQYC4gAEQyyQAC8YCAQV/IwBBwAJrIgUkACABKALoAiIGQQhqEN4lIQcCQAJAAkACQCAGLwEYIggOAgABAgsgBUIFNwMADAILIAYvARoNACAGKAIUIgRBCGogBCgCCEECRkECdGotACAiBEEDRyAEQQBHcSEECyAFIAggBBCfGgsCQCAGLwEaIgRFBEAgBUIENwNQDAELIAVB0ABqIAQQ4CMLIAYgBigCACIEQQFqNgIAIARBAE4EQEEAIgRFBEAgBUHwAWogBUHQAPwKAAALIARFBEAgBUGgAWogBUHQAGpB0AD8CgAACyABEOEfIAEgBUGgAWpBoAH8CgAAIAFCADcClAIgASAGNgKQAiABIAM2AowCIAEgAjYCiAIgASAHNgKAAiABQQA2AvABIAFCBjcDoAEgAUGcAmpBADoAACAAQQg2AgAgBUHAAmokAA8LAAvHAgIEfwR+IwBBQGoiAiQAIAAoAgAiBSgCACEDIAJBEGoiBCAAKAIEKAIQIAFBAnRqNAIAIgYgBkI/hxCyLiAEIAIpAxAgAikDGCACKQMgIAIpAyggAygCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBEEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBSgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkFAayQADwsgACADQYiL/wAQwyEAC8cCAgR/BH4jAEFAaiICJAAgACgCACIFKAIAIQMgAkEQaiIEIAAoAgQoAhAgAUEDdGopAwAiBiAGQj+HELIuIAQgAikDECACKQMYIAIpAyAgAikDKCADKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAEQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAFKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQUBrJAAPCyAAIANBiIv/ABDDIQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDsDiACQUBrIgQgAUEwahDWFAJAAkBBDEEEEK02IgEEQCABQoKEiJCgwICBAjcCACABQQhqQYKEiBA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQvRUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJgUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQngggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO4OIAJBQGsiBCABQTBqENAUAkACQEEMQQQQrTYiAQRAIAFChIiQoMCAgYIENwIAIAFBCGpBhIiQIDYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCbFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCiCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDsDiACQUBrIgQgAUEwahDQFAJAAkBBDEEEEK02IgEEQCABQoSIkKDAgIGCBDcCACABQQhqQYSIkCA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQmxUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJgUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQogggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO4OIAJBQGsiBCABQTBqENYUAkACQEEMQQQQrTYiAQRAIAFCgoSIkKDAgIECNwIAIAFBCGpBgoSIEDYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBC9FSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCeCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ2xQCQAJAQQxBBBCtNiIBBEAgAUKFipSo0KDBggU3AgAgAUEIakGFipQoNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJoVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCYFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKAIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDtDiACQUBrIgQgAUEwahDOFAJAAkBBDEEEEK02IgEEQCABQoOGjJiw4MCBAzcCACABQQhqQYOGjBg2AgBBDEEEEK02IgNFDQEgA0KYsODAgYOGjBg3AgAgA0EIakGYsODAATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQnBUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQpAggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqENsUAkACQEEMQQQQrTYiAQRAIAFChYqUqNCgwYIFNwIAIAFBCGpBhYqUKDYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCaFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCgCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQzhQCQAJAQQxBBBCtNiIBBEAgAUKDhoyYsODAgQM3AgAgAUEIakGDhowYNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJwVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCYFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKQIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDQFAJAAkBBDEEEEK02IgEEQCABQoSIkKDAgIGCBDcCACABQQhqQYSIkCA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQmxUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQogggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqEM4UAkACQEEMQQQQrTYiAQRAIAFCg4aMmLDgwIEDNwIAIAFBCGpBg4aMGDYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBCcFSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmBQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCkCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQzhQCQAJAQQxBBBCtNiIBBEAgAUKDhoyYsODAgQM3AgAgAUEIakGDhowYNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJwVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKQIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAu4AgEEfyMAQZADayICJAAgASgCDARAIAEQiSALIAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDWFAJAAkBBDEEEEK02IgEEQCABQoKEiJCgwICBAjcCACABQQhqQYKEiBA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQvRUgAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEJkUIAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQngggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7gCAQR/IwBBkANrIgIkACABKAIMBEAgARCJIAsgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqENYUAkACQEEMQQQQrTYiAQRAIAFCgoSIkKDAgIECNwIAIAFBCGpBgoSIEDYCAEEMQQQQrTYiA0UNASADQpiw4MCBg4aMGDcCACADQQhqQZiw4MABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBC9FSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQmRQgAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCeCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALuAIBBH8jAEGQA2siAiQAIAEoAgwEQCABEIkgCyACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ0BQCQAJAQQxBBBCtNiIBBEAgAUKEiJCgwICBggQ3AgAgAUEIakGEiJAgNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEJsVIAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRCZFCACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKIIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAvMAgEFfyMAQdAAayIEJAAgBCACNgIMAkACQCABKAIIIgUgAksEQCAEIAEoAigiBiADaiIFQQN0Igc2AhAgAAJ/IAcgASgCBCACQQxsaiICKAIIIghNBEAgBCACEMUbIAUgBkkNAyAFIAQoAgQiAUsNBCAEKAIAIQEgACADNgIIIAAgASAGQQN0ajYCBEGTgICAeAwBCyAEIAg2AiwgBEGk7YYBNgIUIARCBDcCICAEQTs2AkwgBEE7NgJEIARBrQM2AjwgBCABQRhqNgI4IARBOzYCNCAEQQQ2AhggBCAEQTBqNgIcIAQgBEEsajYCSCAEIARBEGo2AkAgBCAEQQxqNgIwIABBBGogBEEUahCZDkGNgICAeAs2AgAgBEHQAGokAA8LIAIgBUHQ7IYBEMMhAAsgBiAFQeDshgEQsTsACyAFIAFB4OyGARCwOwALzAIBBX8jAEHQAGsiBCQAIAQgAjYCDAJAAkAgASgCCCIFIAJLBEAgBCABKAIoIgYgA2oiBUECdCIHNgIQIAACfyAHIAEoAgQgAkEMbGoiAigCCCIITQRAIAQgAhDHGyAFIAZJDQMgBSAEKAIEIgFLDQQgBCgCACEBIAAgAzYCCCAAIAEgBkECdGo2AgRBk4CAgHgMAQsgBCAINgIsIARBpO2GATYCFCAEQgQ3AiAgBEE7NgJMIARBOzYCRCAEQa0DNgI8IAQgAUEYajYCOCAEQTs2AjQgBEEENgIYIAQgBEEwajYCHCAEIARBLGo2AkggBCAEQRBqNgJAIAQgBEEMajYCMCAAQQRqIARBFGoQmQ5BjYCAgHgLNgIAIARB0ABqJAAPCyACIAVB0OyGARDDIQALIAYgBUHg7IYBELE7AAsgBSABQeDshgEQsDsAC7UCAQZ/IwBBEGsiAyQAIAAEQCADQQhqIAAoAgAQkTUgAygCDCEBIAMoAggiAkEAOgAAIAEEQCACIAFBARD4OgsCQCAAKAIEIgFFDQAgAyABEJE1IAMoAgQhASADKAIAIgJBADoAACABRQ0AIAIgAUEBEPg6CyAAKAIsIgEEQCABKAIQIgQEQCABKAIMIQIgBEECdCEEA0AgAigCACIFKAIoIgYEQCAFIAYRAwALIAJBBGohAiAFQTBBCBD4OiAEQQRrIgQNAAsLIAEoAhQiAgRAIAIoAigiBARAIAIgBBEDAAsgAkEwQQgQ+DoLIAEoAhAiAgRAIAEoAgwgAkECdEEEEPg6CyABKAIAQYCAgIB4RwRAIAFBAUEBEOAeCyABQRhBBBD4OgsgAEEANgIoCyADQRBqJAALxwICBX8EfiMAQUBqIgIkACAAKAIAIgUoAgAhAyACQRBqIgQgACgCBCgCECABQQR0aiIGKQMAIAYpAwgQsi4gBCACKQMQIAIpAxggAikDICACKQMoIAMoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIARBBHIQiBEMAQsgAikDICIHIAIpAygiCCACKQMwIgkgAikDOCIKIAUoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAo3AxggACAJNwMQIAAgCDcDCCAAIAc3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJBQGskAA8LIAAgA0GIi/8AEMMhAAuWAwEGfyMAQSBrIgQkAAJAIAAoAiggASgCKEcNACAAKAIkIAEoAiRHDQAgAEEYaiABQRhqEMkIRQ0AIAAoAggiBSABKAIIRw0AIAAoAhQiBiABKAIURw0AIAEoAiwhAgJAIAAoAiwEQCACRQ0CIABBLGogAUEsahCTLA0BDAILIAINAQsCQCAFRQ0AIAAoAgRBBGohAyABKAIEQQRqIQIDQCADKAIAIAIoAgBGBEAgA0EMaiEDIAJBDGohAiAHQQFqIgcgBUcNAQwCCwtBACEDIAUgB0sNAQsgBEEANgIYIAQgASgCECIBNgIQIAQgACgCECIANgIIIAQgBjYCHCAEIAEgBkHEAGwiA2o2AhQgBCAAIANqNgIMIARBCGoiASgCECIAIAEoAhQiBiAAIAZLGyEDIABBxABsIgIgASgCCGohBSABKAIAIAJqIQICQANAIAAgA0YNASABIABBAWoiADYCECACIAUQohEgBUHEAGohBSACQcQAaiECDQALIABBAWshAwsgAyAGTyEDCyAEQSBqJAAgAwutAgEEfyMAQSBrIgUkACAFQRRqIAIgBGpBAWpB8IyIARC/FSAFKAIUIQggBSgCGCIHIAUoAhwiBiABIAIgAyAEEIsBIAUgBjYCHCAFIAc2AhggBSAINgIUAkAgBkUNACAHIAZBAnQiBGpBBGsiAUUNACABKAIADQAgB0EEayEBIAZB/////wNxIQICQANAIARFBEBBACEEDAILIAJBAWshAiABIARqIARBBGshBCgCAEUNAAsgAkEBaiIEIAZLDQELIAUgBDYCHCAEIQYLAkAgBiAIQQJ2Tw0AIAVBCGogBUEUaiAGQQRBBBD0FCAFKAIIIgFBgYCAgHhGDQAgASAFKAIMQcyNiAEQ/S8ACyAAIAUpAhQ3AgAgAEEIaiAFQRxqKAIANgIAIAVBIGokAAukAgECfyMAQRBrIgIkACACQQA2AgwCfwJAIAFBgAFPBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAwsgAiABQT9xQYABcjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwCCyACIAE6AAxBAQwBCyACIAFBP3FBgAFyOgANIAIgAUEGdkHAAXI6AAxBAgsiASAAKAIIIgAoAgAgACgCCCIDa0sEQCAAIAMgARCFEyAAKAIIIQMLIAEEQCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYCCCACQRBqJABBAAvMAgIJfwF+IwBBIGsiAiQAIAJBCGogARDLEwJAAkACQCACKAIIQQFGBEAgAigCDCEBIAIpAxAhCyAAIAIpAxg3AgwgACALNwIEIAAgATYCAAwBCyACKAIQIgQhAyABKAIMIgkhBgJAIAEoAhAiByAETyIKDQAgAkEIahC0HiACKAIQIQMgAigCDCEGIAIoAggiBUEERg0AIAAgAikCFDcCDCAAIAM2AgggACAGNgIEIAAgBTYCAAwBCyACQQhqIANBAEEBQQEQoBggAigCDCEFIAIoAghBAUYNASACKAIQIQggAwRAIAggBiAD/AoAAAsgCkUNAiAAIAM2AgwgACAINgIIIAAgBTYCBCAAQQQ2AgAgASAHIARrNgIQIAEgBCAJajYCDAsgAkEgaiQADwsgBSACKAIQQdinzgAQ/S8ACyAEIAdBtLPOABCvOwALxQIBAX8jAEEgayIFJAAgBUEEaiAAKAIMIgBBCGogACgCCEECRkECdGoQiRkCQAJAIAUtAARBDUYEQCABKAIARQ0CAkACQAJAIAEoAggOAgABAgtBAEEAQdCEzwAQwyEAC0EBQQFB4ITPABDDIQALIAEoAgQiAC0AAUEIdEGA/gFxIAAtAAByQYD4AUsNAQsgAkEEaiEAIAIoAgBBAUYEQCADIAAgBBCJDUUNAQsCQCABKAIAIgMEQCAFQRBqIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgBUEANgIQCwJAIAIoAgBFDQAgACgCACIBRQ0AIAJBEGogAigCCCACKAIMIAEoAhARAQALIAJBATYCACAAIAUpAhA3AgAgAEEIaiAFQRhqKQIANwIACyAFQSBqJAAPC0Hkh84AQSBBhIjOABDLJAALxQIBAX8jAEEgayIFJAAgBUEEaiAAKAIMIgBBCGogACgCCEECRkECdGoQiRkCQAJAIAUtAARBDUYEQCABKAIARQ0CAkACQAJAIAEoAggOAgABAgtBAEEAQdCEzwAQwyEAC0EBQQFB4ITPABDDIQALIAEoAgQiAC0AAUEIdEGA/gFxIAAtAAByQYD4AUsNAQsgAkEEaiEAIAIoAgBBAUYEQCADIAQgABCJDUUNAQsCQCABKAIAIgMEQCAFQRBqIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgBUEANgIQCwJAIAIoAgBFDQAgACgCACIBRQ0AIAJBEGogAigCCCACKAIMIAEoAhARAQALIAJBATYCACAAIAUpAhA3AgAgAEEIaiAFQRhqKQIANwIACyAFQSBqJAAPC0Hkh84AQSBBhIjOABDLJAALoQIBA38jAEEgayIFJAAgBUEANgIEAkACQAJAAkAgAUEDSwRAIAVBBGoiBkEEIABBBEGojtIAENUsIAUoAgQhByAFQQA2AgQgA0EDTQ0EIAZBBCACQQRBqI7SABDVLAJAAn9BACAHIAUoAgRHDQAaQQEgBEEERg0AGiABQQRGDQMgA0EERg0EQQAgAC0ABCACLQAERw0AGiABQQVGDQUgA0EFRg0BIAAtAAUgAi0ABUYLIAVBIGokAA8LQQVBBUGogtIAEMMhAAsMAwtBBEEEQfiB0gAQwyEAC0EEQQRBiILSABDDIQALQQVBBUGYgtIAEMMhAAsgBUEANgIYIAVBATYCDCAFQcD/0QA2AgggBUIENwIQIAVBCGpBmI7SABDvLAALtQIBBH8jAEEwayICJAAgAEEEIAAoAjQiBCAEQQRNGzYCNCAAQTBqIQQCQEEAIAAoAjAiBWtBA3EiAyAAKAIIIAVrTQ0AIAAoAgggACgCMGsgA08NAANAIAAQ+xYgACgCCCAAKAIwayADSQ0ACwsgBCADEI03IAAoAgggACgCMGtBA0siAyADckUEQANAIAAQ+xYgACgCCCAAKAIwa0EESQ0ACwsgBEEEEI03IAJBEGogABDcOyACKAIUIQMgAigCECEFIAJBCGogACgCMBCMNyACIAUgAyACKAIIIAIoAgxBsLf+ABDXJiACKAIEQQNNBEAgAkEANgIoIAJBATYCHCACQey3/gA2AhggAkIENwIgIAJBGGpBwLf+ABDvLAALIAIoAgAgATYAACAEKAIAIAJBMGokAAu1AgEEfyMAQTBrIgIkACAAQQQgACgCNCIEIARBBE0bNgI0IABBMGohBAJAQQAgACgCMCIFa0EDcSIDIAAoAgggBWtNDQAgACgCCCAAKAIwayADTw0AA0AgABD7FiAAKAIIIAAoAjBrIANJDQALCyAEIAMQjTcgACgCCCAAKAIwa0EDSyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBrQQRJDQALCyAEQQQQjTcgAkEQaiAAENw7IAIoAhQhAyACKAIQIQUgAkEIaiAAKAIwEIw3IAIgBSADIAIoAgggAigCDEGsx/4AENcmIAIoAgRBA00EQCACQQA2AiggAkEBNgIcIAJB9Mj+ADYCGCACQgQ3AiAgAkEYakG8x/4AEO8sAAsgAigCACABNgAAIAQoAgAgAkEwaiQAC7ACAQZ/IwBBEGsiAyQAAkAgACgCECIEQQdxIgVFDQAgA0EIaiAAEIY9AkAgAygCDCICRQ0AIAMoAgggAmpBAWsiAkUNACACIAItAABBfyAFdHI6AAAMAQtB3OOAARCyOwALAkAgASAEaiIEQQN2IARBB3EiBUEAR2oiASAAKAIMIgJNDQAgASACayEGIAAoAgQgAUkEQCABEM8qIQIgACAAKAIEQQF0IgcgAiACIAdJGxDoGSAAKAIMIQILIAZFDQAgACgCCCACakH/ASAG/AsACyAAIAE2AgwCQCAFRQ0AIAMgABCGPQJAIAMoAgQiAUUNACADKAIAIAFqQQFrIgFFDQAgASABLQAAQX8gBXRBf3NxOgAADAELQezjgAEQsjsACyAAIAQ2AhAgA0EQaiQAC9YCAQF/IwBBMGsiAiQAAn8CQAJAAkACQAJAAkAgACgCAEEBaw4FAQIDBAUACyAAQQRqKAIAIAEQnwQMBQsgACgCBCABELkJDAQLIAIgAEEEajYCDCACQQI2AhQgAkGkmcMANgIQIAJCATcCHCACQYQBNgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywoMAwsgAiAAQQRqNgIMIAJBAjYCFCACQcSZwwA2AhAgAkIBNwIcIAJBhQE2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCgwCCyACIABBBGo2AgwgAkECNgIUIAJB6JnDADYCECACQgE3AhwgAkGEATYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKDAELIAFB+JnDAEEREPs1CyACQTBqJAALugIBBX8gACgCGCEDAkACQCAAIAAoAgwiAUYEQCAAQRRBECAAKAIUIgEbaigCACICDQFBACEBDAILIAAoAggiAiABNgIMIAEgAjYCCAwBCyAAQRRqIABBEGogARshBANAIAQhBSACIgFBFGogAUEQaiABKAIUIgIbIQQgAUEUQRAgAhtqKAIAIgINAAsgBUEANgIACwJAIANFDQACQAJAIAAoAhwiAkECdEGo8IoBaiIEKAIAIABHBEACQCAAIAMoAhBHBEAgAyABNgIUDAELIAMgATYCEAsgAQ0BDAMLIAQgATYCACABRQ0BCyABIAM2AhggACgCECICBEAgASACNgIQIAIgATYCGAsgACgCFCIARQ0BIAEgADYCFCAAIAE2AhgPC0HE84oBQcTzigEoAgBBfiACd3E2AgALC8QCAQN/IwBBMGsiAyQAAkACQCACRQRAIAAtADpBAUcNAQsgAEEBIAAoAjQiBCAEQQFNGzYCNCAAKAIIGiAAQTBqIgRBABCNNyAAKAIIIAAoAjBHIgUgBXJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIARBARCNNyADQRBqIAAQ3DsgAygCFCEEIAMoAhAhBSADQQhqIAAoAjAQjDcgAyAFIAQgAygCCCADKAIMQbC3/gAQ1yYgAygCBEUNASADKAIAIAI6AAAgACgCMCEEIAAoAhQiAiAAKAIMRgRAIABBDGpBuLb+ABCbKAsgACgCECACQQN0aiIFIAE7AQQgBSAENgIAIAAgAkEBajYCFAsgA0EwaiQADwsgA0EANgIoIANBATYCHCADQey3/gA2AhggA0IENwIgIANBGGpBwLf+ABDvLAALvQICA34DfyMAQRBrIgYkAEKAgICAgICAgIB/IQMCQAJAAkACfgJAAkAgACgCBCgCECABQQN0aikDACIEQoCAgICAgICAgH9SIAAoAgAiBygCACIFKAIAKQMAIgJCf1JyRQRAQgAhAgwBCyACUA0EIAQgBCACfyIDIAJ+fUIAIAJCf1IbIQIgBEIAWQ0BCyADIAIgBSgCCCkDAFetfQwBCyADIAIgBSgCBCkDAFmtfAsiAiAHKAIELQAAEMUpBEAgACgCCCABQQN0aiACNwMADAELIAAoAhAiBSAFKAIAQQFqNgIAIAZBCGogACgCFBCGPSABQQN2IgAgBigCDCIFTw0CIAYoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyAGQRBqJAAPC0G8j/8AEOIrAAsgACAFQYiL/wAQwyEAC74CAQp/IwBBMGsiAiQAIAEoAgQhBSABKAIAIQcCQAJAIAAoAgAiBCAAKAIEIgNHBEAgASgCCCEIIAAoAhQhBiAAKAIQIQkgACgCDCEKIAAoAgghACADIARrQQN2IQEDQCACIAQ2AgwCQCAEKAIAIgMgCUkEQCADIApqLQAAIQMMAQsgACAGKAIQTw0DQQAhAyAGKAIEIAAgBigCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgBSAIaiADOgAAIARBCGohBCAAQQFqIQAgBUEBaiEFIAFBAWsiAQ0ACwsgByAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG6EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALvgIBCn8jAEEwayICJAAgASgCBCEFIAEoAgAhBwJAAkAgACgCACIEIAAoAgQiA0cEQCABKAIIIQggACgCFCEGIAAoAhAhCSAAKAIMIQogACgCCCEAIAMgBGtBA3YhAQNAIAIgBDYCDAJAIAQoAgAiAyAJSQRAIAMgCmotAAAhAwwBCyAAIAYoAhBPDQNBACEDIAYoAgQgACAGKAIMaiILQQN2ai0AACALQQdxdkEBcQ0ECyAFIAhqIAM6AAAgBEEIaiEEIABBAWohACAFQQFqIQUgAUEBayIBDQALCyAHIAU2AgAgAkEwaiQADwtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAu+AgEKfyMAQTBrIgIkACABKAIEIQUgASgCACEHAkACQCAAKAIAIgQgACgCBCIDRwRAIAEoAgghCCAAKAIUIQYgACgCECEJIAAoAgwhCiAAKAIIIQAgAyAEa0ECdiEBA0AgAiAENgIMAkAgCSAEKAIAIgNLBEAgAyAKai0AACEDDAELIAAgBigCEE8NA0EAIQMgBigCBCAAIAYoAgxqIgtBA3ZqLQAAIAtBB3F2QQFxDQQLIAUgCGogAzoAACAEQQRqIQQgAEEBaiEAIAVBAWohBSABQQFrIgENAAsLIAcgBTYCACACQTBqJAAPC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuxM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywAC74CAQp/IwBBMGsiAiQAIAEoAgQhBSABKAIAIQcCQAJAIAAoAgAiBCAAKAIEIgNHBEAgASgCCCEIIAAoAhQhBiAAKAIQIQkgACgCDCEKIAAoAgghACADIARrQQJ2IQEDQCACIAQ2AgwCQCAJIAQoAgAiA0sEQCADIApqLQAAIQMMAQsgACAGKAIQTw0DQQAhAyAGKAIEIAAgBigCDGoiC0EDdmotAAAgC0EHcXZBAXENBAsgBSAIaiADOgAAIARBBGohBCAAQQFqIQAgBUEBaiEFIAFBAWsiAQ0ACwsgByAFNgIAIAJBMGokAA8LQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkHtBjYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALvAIBBH8jAEHQAGsiAyQAIAAgACgCCCACQQRBBEGwsYMBEMMoIAMgAUHAAPwKAAAgA0HEAGogAxDVCQJAAkACQCADKAJEQQFGBEADQCADKAJIIgIgAygCTCIFSQRAIAJBAnQhAQNAIAIgACgCHCIETw0EIAJBAWoiBiAETw0FIAAoAhggAWoiAkEEaigCACACKAIAayICQQBIDQYgACAAKAIoIAJqIgQ2AiggACgCCCICIAAoAgBGBEAgAEHAsYMBEJ0oCyAAKAIEIAJBAnRqIAQ2AgAgACACQQFqNgIIIAFBBGohASAGIgIgBUcNAAsLIANBxABqIAMQ1QkgAygCRA0ACwsgA0HQAGokAA8LIAIgBEGcsIMBEMMhAAsgAkEBaiAEQZywgwEQwyEAC0GssIMBQRRBwLCDARDLJAALrgIBAn8gASgCCCEEAn8CQAJAAkAgASgCBCACaiICIAJBgKMFbSIDQYCjBWxrIgJBH3UgA2pBAWoOAwEAAgALIAEoAgAMAgsCfyABKAIAIgFB8D9xIgNBEE0EQCABQQ11QQFrIgEgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAABB8DNyEMYkDAELIANBEGsgAUGPQHFyCyIBQeetgIB4IAEbDAELIAEoAgAiA0H4P3EiAUHRLU8EQEGfwP//ByADQQ11IgNB/v8Pa0GCgGBJDQEaIANBAWoiAUENdCABQZADbyIBQR91QZADcSABakH0yYYBai0AAHJBEHIMAQsgAUEQaiADQYdAcXILIQEgACAENgIIIAAgATYCACAAIAJBgKMFaiACIAJBAEgbNgIEC6UCAQN/AkACQCABKAIAQQFGBEAgAUEEaiECDAELIAEoAggEQCABQQxqIQIMAQsgASgCGCECIAEoAhQhAwJAAkAgASgCMCIBRQ0AIAEgAk8EQCABIAJGDQEMAgsgASADaiwAAEG/f0wNAQsgASADaiEDDAILIAMgAiABIAJB4JfEABCjNgALIAEoAhghAyABKAIUIQQCQCACKAIAIgIgASgCMCIBSQ0AAkAgAUUNACABIANPBEAgASADRw0CDAELIAEgBGosAABBv39MDQELAkAgAkUNACACIANPBEAgAiADRw0CDAELIAIgBGosAABBv39MDQELIAEgBGohAwwBCyAEIAMgASACQdCXxAAQozYACyACIAFrIQEgACABNgIEIAAgAzYCAAuYAgIEfwF+IwBBIGsiBiQAAkAgBUUNACACIANqIgMgAkkNACAEIAVqQQFrQQAgBGtxrSADIAEoAgAiCEEBdCICIAIgA0kbIgJBCEEEQQEgBUGBCEkbIAVBAUYbIgMgAiADSxsiA61+IgpCIIinDQAgCqciCUGAgICAeCAEa0sNAAJ/IAhFBEAgBkEYaiEHQQAMAQsgBkEcaiEHIAYgBDYCGCAGIAEoAgQ2AhQgBSAIbAshBSAHIAU2AgAgBkEIaiAEIAkgBkEUahC+GiAGKAIIQQFGBEAgBigCECECIAYoAgwhBwwBCyAGKAIMIQQgASADNgIAIAEgBDYCBEGBgICAeCEHCyAAIAI2AgQgACAHNgIAIAZBIGokAAuoEQIWfwR+IwBBEGsiDiQAAkAgAS0AhAFFDQAgASgCfCgCFCIFQQhqIAUoAghBAkZBAnRqLQAhQRZGDQAgDkEIaiEKIAIiBSADIAVqIg1GBH9BAgUCQCANIAVBAWoiBEYEQCAFIQkMAQsgBS0AACIGIQcgBSEJA0AgBCAFIAQtAAAiCCAGQX9zcUEBcSILGyEFIAggBiALGyEGIAQgCSAHIAhBf3NxQQFxIgsbIQkgCCAHIAsbIQcgBEEBaiIEIA1HDQALCyAFLQAAIQYgCS0AAAshBSAKIAY6AAEgCiAFOgAAIA4tAAgiBUECRg0AIA4tAAkhCSABLQCFASIEQQJHIAVBAXMgBHFBAXFFcUUEQCABIAVBAXE6AIUBCyABLQCGASIFQQJHIAkgBUEBc3FBAXFFcQ0AIAEgCUEBcToAhgELIANFIAEoAnBBgICAgHhGckUEQCABQfAAaiEEIAMhCSACIQUDQCAEIAVBARCGChCiFSAFQQFqIQUgCUEBayIJDQALCwJAIAEoAlhBgICAgHhHBEAgAUEQaiIBQcgAaiADEOwtIAMEQANAIwBBMGsiDSQAIA1BGGohCSABQRBqIgcgAkEBEM0CIRwgAUEwaiEFQQAhBkEAIQtBACEPQQAhEUEAIRIjAEEQayITJAAgASgCCEUEQAJAIBNBCGohFCMAQeAAayIEJAAgBCAFNgIcIAQgBzYCGCABKAIMIQggBCAEQRhqNgIgAkACQAJAAkACQCAIIAhBAWoiB00EQCABKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAdJBEAgCEEBaiIGIAcgBiAHSxsiBkEPSQ0CIAZB/////wFNBEBBfyAGQQN0QQduQQFrZ3ZBAWohBgwECxDdJyAEKAIUIQYgBCgCECIHQYGAgIB4Rw0FDAMLIAEgBEEgakG8pc8AEOsJDAMLEN0nIAQoAgQhBiAEKAIAIQcMAwtBBEEIQRAgBkEISRsgBkEESRshBgsgBEHQAGogAUEQaiIKQQggBhD7FCAEKAJYIQYgBCgCVCEHIAQoAlAiCEUNASAEIAQoAlw2AkwgBCAGNgJIIAQgBzYCRCAEIAg2AkAgBEEIaiAEQUBrEME0IAQoAgwiBgRAIAQoAghB/wEgBvwLAAsgBCgCSCEGIAQoAkQhByAEKAJAIghFDQEgBCAEKAJMNgI8IAQgBjYCOCAEIAc2AjQgBCAINgIwIARCiICAgIABNwIoIAQgCjYCJCAEIAEoAgwiFQR/IAhBCGohFyABKAIAIhYpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCALQQhqIQsgFkEIaiIWKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsgGkKAgYKEiJCgwIB/hSEaCyAEKAIgIgwoAgQiECgCCCIYIAEoAgAgGnqnQQN2IAtqQQN0IhlrQQhrKAIAIgpNDQQgCCAHIAwoAgAgECgCBCAKakEBEM0CpyIQcSIKaikAAEKAgYKEiJCgwIB/gyIbUARAQQghDANAIAogDGohCiAMQQhqIQwgCCAHIApxIgpqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogCCAbeqdBA3YgCmogB3EiCmosAABBAE4EQCAIKQMAQoCBgoSIkKDAgH+DeqdBA3YhCgsgCCAKaiAQQRl2Igw6AAAgFyAKQQhrIAdxaiAMOgAAIAggCkEDdGtBCGsgASgCACAZa0EIaykAADcAACAVQQFrIhUNAAsgASgCDAVBAAsiBzYCPCAEIAYgB2s2AjggASAEQTBqQQQQ+iogBEEkahD1JwtBgYCAgHghBwsgFCAGNgIEIBQgBzYCACAEQeAAaiQADAELIAogGEGUkM4AEMMhAAsLIAEoAgQiBiAcp3EhBCAcQhmIQv8Ag0KBgoSIkKDAgAF+IR0gBSgCBCELIAUoAgghCCABKAIAIQcDQAJAIAQgB2opAAAiGyAdhSIaQn+FIBpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhGgJ/AkACQCAJAn4CQANAIBpQDQEgCCABKAIAIBp6p0EDdiAEaiAGcSIMQQN0a0EIaygCACIKTQ0DIBpCAX0gGoMhGiACQQEgCiALakEBEJ87RQ0ACyAJIBw3AwggCSABKAIAQQAgDGtBA3RqNgIQQgAMAQsgG0KAgYKEiJCgwIB/gyEaIBFFBEAgGlANAyAaeqdBA3YgBGogBnEhDwtBASAaIBtCAYaDUA0DGiAJIAcgD2osAABBAE4EfyAHKQMAQoCBgoSIkKDAgH+DeqdBA3YFIA8LNgIQIAkgHDcDCEIBCzcDACAJIAE2AhQgE0EQaiQADAMLIAogCEGUkM4AEMMhAAtBAAshESAEIBJBCGoiEmogBnEhBAwBCwsgDUEIaiEEAkAgCSgCAEEBRgRAIAkpAwghGiAJKAIQIQYgCSgCFCEJIAUgBSgCDEEBajYCDCACLQAAIQggBSgCCCIHIAUoAgBGBEAgBUGkkM4AEKMoCyAFKAIEIAdqIAg6AAAgBSAHQQFqNgIIIAYgCSgCACIFaiIILQAAIQogCCAap0EZdiIIOgAAIAUgCSgCBCAGQQhrcWpBCGogCDoAACAEIAk2AgwgBCAaNwMAIAkgCSgCDEEBajYCDCAEIAUgBkEDdGsiBTYCCCAJIAkoAgggCkEBcWs2AgggBUEIayAHrTcDAAwBCyAEIAlBCGoiBSkDADcDACAEQQhqIAVBCGopAwA3AwALIA0oAhBBCGspAwAhGiANQTBqJAAgASgCUCIFIAEoAkhGBEAgAUHIAGpB1JDOABCzKAsgASgCTCAFQQN0aiAaNwMAIAEgBUEBajYCUCACQQFqIQIgA0EBayIDDQALCyAAQQg2AgAMAQsgACABKAJoIAIgAyABKAJsKAIMEQUACyAOQRBqJAAL5AMBBX8jAEEgayIDJAACQAJAIAAoApQKIgIgACgChAoiBUcNACADIAJBAXQQ+SYgAiADKAIEIgVLDQEgAygCACEEIAJBFGwiAgRAIAQgACgCgAogAvwKAAALIAAoAoQKIQIgACAFNgKECiAAKAKACiAAIAQ2AoAKIAJFDQAgAkEUbEEEEPg6CwJAIAUgACgClAoiBEcEQCADQQhqIQICQAJAAkACQAJAAkACQAJAIAEtAAAiBkEBaw4GAQIDBAUGAAsgAiABKQIENwIEDAYLIAIgASkCBDcCBAwFCyACIAEtABA6AAwgAiABKQIIQiCJNwIEDAQLIAIgAS0AAToAAQwDCyACIAEvAAE7AAEMAgsgAiABLQABOgABDAELIAIgASgCFDYCECACIAEoAhg2AgwgAiABKAIINgIIIAIgASgCDDYCBAsgAiAGOgAAIAQgBUkEQCAAKAKACiAEQRRsaiIBIAMpAgg3AgAgAUEIaiADQRBqKQIANwIAIAFBEGogA0EYaigCADYCACAAIARBAWo2ApQKDAILIAQgBUGEn9AAEMMhAAsgAEEBOgCjCgsgA0EgaiQADwsgA0EANgIYIANBATYCDCADQfig0AA2AgggA0IENwIQIANBCGpB9J7QABDvLAALmgIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBBDRKCAAKAIIBSACCyAAKAIEaiECAkACQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoAAyACIAFBEnZB8AFyOgAAIAIgAUEGdkE/cUGAAXI6AAIgAiABQQx2QT9xQYABcjoAAQwDCyACIAFBP3FBgAFyOgACIAIgAUEMdkHgAXI6AAAgAiABQQZ2QT9xQYABcjoAAQwCCyACIAE6AAAMAQsgAiABQT9xQYABcjoAASACIAFBBnZBwAFyOgAACyAAIAMgBGo2AghBAAvBAgEEfyMAQTBrIgEkAAJAIAAoAgAiAC0AOkEBRgRAIABBASAAKAI0IgIgAkEBTRs2AjQgACgCCBogAEEwaiICQQAQjTcgACgCCCAAKAIwRyIDIANyRQRAA0AgABD7FiAAKAIIIAAoAjBGDQALCyACQQEQjTcgAUEQaiAAENw7IAEoAhQhAiABKAIQIQMgAUEIaiAAKAIwEIw3IAEgAyACIAEoAgggASgCDEGsx/4AENcmIAEoAgRFDQEgASgCAEEAOgAAIAAoAjAhAyAAKAIUIgIgACgCDEYEQCAAQQxqQcTG/gAQmygLIAAoAhAgAkEDdGoiBEEGOwEEIAQgAzYCACAAIAJBAWo2AhQLIAFBMGokAA8LIAFBADYCKCABQQE2AhwgAUH0yP4ANgIYIAFCBDcCICABQRhqQbzH/gAQ7ywAC9wCAgJ/AX4jAEHgAGsiAyQAIANBBGogASgCDCgCECACQQN0aikDACIFIAEoAggoAgAoAgAQzyUCQAJAIAMoAgQEQCADQSBqIANBDGopAgA3AgAgAyADKQIENwIYIANBk4CAgHg2AhQgA0EwaiADQRhqIAMoAiQQ9xEgAygCMCIEDQFBx5D/AEErQfSQ/wAQyyQACyADIAU3AyggA0EnNgJMIANBg4//ADYCSCADQQM2AjQgA0HEkv8ANgIwIANCAjcCPCADQe4GNgJcIANBzAE2AlQgAyADQdAAajYCOCADIANBKGo2AlggAyADQcgAajYCUCADQRhqIANBMGoQmQ4gACADKQIcNwIIIABBEGogA0EkaigCADYCACAAIAMoAhg2AgQgAEGCgICAeDYCAAwBCyAEEMUkIQQgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANB4ABqJAAL3AICAn8BfiMAQeAAayIDJAAgA0EEaiABKAIMKAIQIAJBA3RqKQMAIgUgASgCCCgCACgCABDOJQJAAkAgAygCBARAIANBIGogA0EMaikCADcCACADIAMpAgQ3AhggA0GTgICAeDYCFCADQTBqIANBGGogAygCJBD3ESADKAIwIgQNAUHHkP8AQStB9JD/ABDLJAALIAMgBTcDKCADQSw2AkwgA0Gsjv8ANgJIIANBAzYCNCADQcSS/wA2AjAgA0ICNwI8IANB7gY2AlwgA0HMATYCVCADIANB0ABqNgI4IAMgA0EoajYCWCADIANByABqNgJQIANBGGogA0EwahCZDiAAIAMpAhw3AgggAEEQaiADQSRqKAIANgIAIAAgAygCGDYCBCAAQYKAgIB4NgIADAELIAQQxSQhBCAAQZOAgIB4NgIAIAEoAgAgAkECdGogBDYCAAsgA0HgAGokAAvcAgICfwF+IwBB4ABrIgMkACADQQRqIAEoAgwoAhAgAkEDdGopAwAiBSABKAIIKAIAKAIAEMwlAkACQCADKAIEBEAgA0EgaiADQQxqKQIANwIAIAMgAykCBDcCGCADQZOAgIB4NgIUIANBMGogA0EYaiADKAIkEPcRIAMoAjAiBA0BQceQ/wBBK0H0kP8AEMskAAsgAyAFNwMoIANBLDYCTCADQYCO/wA2AkggA0EDNgI0IANBxJL/ADYCMCADQgI3AjwgA0HuBjYCXCADQcwBNgJUIAMgA0HQAGo2AjggAyADQShqNgJYIAMgA0HIAGo2AlAgA0EYaiADQTBqEJkOIAAgAykCHDcCCCAAQRBqIANBJGooAgA2AgAgACADKAIYNgIEIABBgoCAgHg2AgAMAQsgBBDFJCEEIABBk4CAgHg2AgAgASgCACACQQJ0aiAENgIACyADQeAAaiQAC9wCAgJ/AX4jAEHgAGsiAyQAIANBBGogASgCDCgCECACQQN0aikDACIFIAEoAggoAgAoAgAQzSUCQAJAIAMoAgQEQCADQSBqIANBDGopAgA3AgAgAyADKQIENwIYIANBk4CAgHg2AhQgA0EwaiADQRhqIAMoAiQQ9xEgAygCMCIEDQFBx5D/AEErQfSQ/wAQyyQACyADIAU3AyggA0ErNgJMIANB2I7/ADYCSCADQQM2AjQgA0HEkv8ANgIwIANCAjcCPCADQe4GNgJcIANBzAE2AlQgAyADQdAAajYCOCADIANBKGo2AlggAyADQcgAajYCUCADQRhqIANBMGoQmQ4gACADKQIcNwIIIABBEGogA0EkaigCADYCACAAIAMoAhg2AgQgAEGCgICAeDYCAAwBCyAEEMUkIQQgAEGTgICAeDYCACABKAIAIAJBAnRqIAQ2AgALIANB4ABqJAALsgICBn8BfiMAQRBrIgMkAEGAgICAeCEEAkACQAJAAn8CQAJAIAAoAgQoAhAgAUECdGooAgAiBUGAgICAeEcgACgCACIHKAIAIgYoAgAoAgAiAkF/R3JFBEBBACECDAELIAJFDQQgBSAFIAJtIgQgAmxrQQAgAkF/RxshAiAFQQBODQELIAQgAiAGKAIIKAIATGsMAQsgBCACIAYoAgQoAgBOagusIgggBygCBC0AABDFKQRAIAAoAgggAUEDdGogCDcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NAiADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0EQaiQADwtBrI//ABDiKwALIAAgAkGIi/8AEMMhAAugBAECfyMAQTBrIgQkAAJAIAACfwJAAkACQAJAIAJB/wFxQQFrDgMBAgMACyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUHAg/8AEIwYIAEgAxDNHCAEIAEQvBMgAkGAAmokAEE4QQQQrTYiAkUNBCACQoGAgIAQNwIAIAJBCGogBEEw/AoAAEGgz/8ADAMLIwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQaiD/wAQjBggASADEM0cIAQgARC1EyACQYACaiQAQThBBBCtNiICRQ0DIAJCgYCAgBA3AgAgAkEIaiAEQTD8CgAAQdDQ/wAMAgsjAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBkIP/ABCMGCABIAMQzRwgBCABELoTIAJBgAJqJABBOEEEEK02IgJFDQIgAkKBgICAEDcCACACQQhqIARBMPwKAABBoM7/AAwBCyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUH8g/8AEIwYIAEgAxDNHCAEIAEQwRMgAkGAAmokAEE4QQQQrTYiAkUNASACQoGAgIAQNwIAIAJBCGogBEEw/AoAAEH4z/8ACzYCBCAAIAI2AgAgBEEwaiQADwtBBEE4EKM9AAvMAgICfwJ+IwBBIGsiBCQAIARBCGogACABKAIQEQAAIARBEGoiACAEKAIIIgEgBCgCDCgCDBEAACAEKQMQIQYgBCkDGCEHIAQgAiADKAIQEQAAIAAgBCgCACICIAQoAgQoAgwRAABBACEAAkAgAUEAIAZCx9n0597Etpx3hSAHQo2yzpSMypLmp3+FhFAbIgFFDQAgAkEAIAQpAxBCx9n0597Etpx3hSAEKQMYQo2yzpSMypLmp3+FhFAbIgNFDQACQAJ/AkAgASgCHCADKAIcRgRAIAEoAiAgAygCIEYNAQsgARCTNiECIAMQkzYhAUEAIAJFDQEaDAMLIAEoAhAgAygCEEYgASgCFCADKAIURnEhAiABEJM2IQUgAxCTNiEBIAUNASACCyABRXEhAAwBCyACRSABRXINACAFIAEQkywhAAsgBEEgaiQAIAALzgICAn8CfiMAQSBrIgQkACAEQQhqIAAgASgCEBEAACAEQRBqIgAgBCgCCCIBIAQoAgwoAgwRAAAgBCkDECEGIAQpAxghByAEIAIgAygCEBEAACAAIAQoAgAiAiAEKAIEKAIMEQAAQQAhAAJAIAFBACAGQpCes+7ZtI2S6QCFIAdCiPSrgeCxxeTCAIWEUBsiAUUNACACQQAgBCkDEEKQnrPu2bSNkukAhSAEKQMYQoj0q4HgscXkwgCFhFAbIgNFDQACQAJ/AkAgASgCHCADKAIcRgRAIAEoAiAgAygCIEYNAQsgARCTNiECIAMQkzYhAUEAIAJFDQEaDAMLIAEoAhAgAygCEEYgASgCFCADKAIURnEhAiABEJM2IQUgAxCTNiEBIAUNASACCyABRXEhAAwBCyACRSABRXINACAFIAEQkywhAAsgBEEgaiQAIAALzAICAn8CfiMAQSBrIgQkACAEQQhqIAAgASgCEBEAACAEQRBqIgAgBCgCCCIBIAQoAgwoAgwRAAAgBCkDECEGIAQpAxghByAEIAIgAygCEBEAACAAIAQoAgAiAiAEKAIEKAIMEQAAQQAhAAJAIAFBACAGQtPY0/j95vaSSIUgB0Ki2J6I4aDq6cwAhYRQGyIBRQ0AIAJBACAEKQMQQtPY0/j95vaSSIUgBCkDGEKi2J6I4aDq6cwAhYRQGyIDRQ0AAkACfwJAIAEoAhwgAygCHEYEQCABKAIgIAMoAiBGDQELIAEQkzYhAiADEJM2IQFBACACRQ0BGgwDCyABKAIQIAMoAhBGIAEoAhQgAygCFEZxIQIgARCTNiEFIAMQkzYhASAFDQEgAgsgAUVxIQAMAQsgAkUgAUVyDQAgBSABEJMsIQALIARBIGokACAAC84CAgJ/An4jAEEgayIEJAAgBEEIaiAAIAEoAhARAAAgBEEQaiIAIAQoAggiASAEKAIMKAIMEQAAIAQpAxAhBiAEKQMYIQcgBCACIAMoAhARAAAgACAEKAIAIgIgBCgCBCgCDBEAAEEAIQACQCABQQAgBkLCjPf26svc0YR/hSAHQuWT9Jj5r/joqH+FhFAbIgFFDQAgAkEAIAQpAxBCwoz39urL3NGEf4UgBCkDGELlk/SY+a/46Kh/hYRQGyIDRQ0AAkACfwJAIAEoAhwgAygCHEYEQCABKAIgIAMoAiBGDQELIAEQkzYhAiADEJM2IQFBACACRQ0BGgwDCyABKAIQIAMoAhBGIAEoAhQgAygCFEZxIQIgARCTNiEFIAMQkzYhASAFDQEgAgsgAUVxIQAMAQsgAkUgAUVyDQAgBSABEJMsIQALIARBIGokACAAC5oCAQN/IAAoAggiAyECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIEIAAoAgAgA2tLBH8gACADIAQQ2yggACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALuQIBAn8jAEHQAGsiAiQAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACIAQ2AgwCQCAEKAIAIgQgASgCCCIBKAIEIgVJBEAgASgCACAEQQJ0aigCCCIBIAEoAgAiA0EBajYCACADQQBODQEACyACIAU2AjwgAkECNgIoIAJB0NyHATYCJCACQgI3AjAgAkE7NgJMIAJB/Rw2AkQgAiACQUBrNgIsIAIgAkE8ajYCSCACIAJBDGo2AkAgAkEUaiACQSRqEJkOIAJBCGoiASACQSBqKAIANgIAIAIgAikCGDcDACACKAIUIQQgAxCOEiADIAQ2AgQgA0GFgICAeDYCACADIAIpAwA3AgggA0EQaiABKAIANgIAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAALngIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBEEBQQEQ3CggACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALlAIBBX8gA0H4////AXEEQCAAIAAgA0EDdiIDQQR0IgVqIAAgA0EcbCIHaiADIAQQyREhACABIAEgBWogASAHaiADIAQQyREhASACIAIgBWogAiAHaiADIAQQyREhAgsgACgCACIDKAIEIgUgASgCACIEKAIEIgcgAygCCCIDIAQoAggiBCADIARJGxCZJyIGIAMgBGsgBhsiBkEASiAGQQBIayIGIAUgAigCACIFKAIEIgggAyAFKAIIIgUgAyAFSRsQmSciCSADIAVrIAkbIgNBAEogA0EASGtzQQBOBH8gAiABIAcgCCAEIAUgBCAFSRsQmSciACAEIAVrIAAbIgBBAEogAEEASGsgBnNBAEgbBSAACwuaAgEDfyAAKAIIIgMhAgJ/QQEgAUGAAUkNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiBCAAKAIAIANrSwR/IAAgAyAEEOAoIAAoAggFIAILIAAoAgRqIQICQAJAIAFBgAFPBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgADIAIgAUESdkHwAXI6AAAgAiABQQZ2QT9xQYABcjoAAiACIAFBDHZBP3FBgAFyOgABDAMLIAIgAUE/cUGAAXI6AAIgAiABQQx2QeABcjoAACACIAFBBnZBP3FBgAFyOgABDAILIAIgAToAAAwBCyACIAFBP3FBgAFyOgABIAIgAUEGdkHAAXI6AAALIAAgAyAEajYCCEEAC5oCAQN/IAAoAggiAyECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIEIAAoAgAgA2tLBH8gACADIAQQhRMgACgCCAUgAgsgACgCBGohAgJAAkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIARqNgIIQQALggcDCn8BfgFvIwBBIGsiBCQAIAECfwJAAkACQAJAAkACQAJAAkACQCABLQAEQQFrDgQFAgEAAwsgASgCCCEFDAYLIAEoAgghBQwCCwALIAEgASgCACIFNgIICyAEQRhqIQkjAEEQayIHJAAgB0EIaiELIAIhBiMAQRBrIggkAAJAIAVBEGoiBSgCDEUNACAIQQhqIAVBDGoiCiAGEMcYQQIhAyAIKAIIIgxBAkYNACAIKAIMIQYCQCAKKAIAIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAoQshoLIApBADYCAEEBIQMgDEEBcQRAIAUQpS0gBUEANgIADAELIAZBhAFPBEAgBhDyHwtBACEDCyALIAY2AgQgCyADNgIAIAhBEGokAAJAIAcoAggiBkECRgRAIAlBBToAAAwBCyAGQQFxBEAgCSAHKAIMEI8SDAELIAlBBDoAAAsgB0EQaiQAIAQtABhBBUcNASAAQQk2AgBBAwwEC0HAtcMAEOgrAAsgBCkDGCINQv8Bg0IEUgRAIAQgDTcDGCAEIARBGGoQgSsMAgsgASABKAIAIgU2AggLIARBGGohCSMAQRBrIgckACAHQQhqIQpBACEDIwBBEGsiCCQAIAVBEGoiAUEQaiEGAkAgASgCEEUEQCABKAIAQQFHDQEgAUEEaigCACUBECshDhDfEiIDIA4mASADEPsOIQUCQCABKAIQIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAYQshoLIAYgBTYCAAsgCEEIaiAGIAIQxxhBAiEDIAgoAggiBUECRg0AIAgoAgwhAgJAIAYoAgAiA0UNACADIAMoAgBBAWsiAzYCACADDQAgBhCyGgtBACEDIAFBADYCECABEKUtIAFBADYCACAFQQFxBEBBASEDDAELIAJBhAFJDQAgAhDyHwsgCiACNgIEIAogAzYCACAIQRBqJAACQCAHKAIIIgFBAkYEQCAJQQU6AAAMAQsgAUEBcQRAIAkgBygCDBCPEgwBCyAJQQQ6AAALIAdBEGokACAELQAYQQVGBEAgAEEJNgIAQQQMAgsgBCkDGCINQv8Bg0IEUgRAIAQgDTcDGCAEIARBGGoQgSsMAQsgBEEINgIACyAAIAQpAwA3AwAgAEEQaiAEQRBqKQMANwMAIABBCGogBEEIaikDADcDAEEBCzoABCAEQSBqJAAL7gIDA38BfgFvIwBBQGoiAyQAIAAoAhAQ9DohBUEIQQQQrTYiBEUEQEEEQQgQoz0ACyAEIAU2AgQgBEEBNgIAIANBGGoiBUG47MMANgIEIAUgBDYCACADKAIYIgRBuOzDABB5IQcQ3xIiBSAHJgEgA0G47MMANgIoIAMgBDYCJCADIAU2AiwgAyABQgBC6AdCABCoHiADKQMAIgYgAkHAhD1urXwiAUKAgICACFQgAykDCCABIAZUrXxQcQRAIANBLGoiAigCACUBIAGnEAYhBxDfEiIEIAcmASADQThqIABBCGopAgA3AwAgACkCACEBIAAgBDYCACAAIAMpAiQ3AgQgAEEMaiACKAIANgIAIAMgATcDMAJAIAMoAjRFDQAgAygCMBD/LyIAQYQBTwRAIAAQ8h8LIANBPGoQrDtFDQAgA0EwakEEchC8KgsgA0FAayQADwtBl+3DAEEHIANBMGpB6OzDAEGg7cMAENUeAAuIBgEIfyMAQRBrIgYkACAGIAU2AgwgBiAENgIIAn8CQAJ/AkACQCAGQQhqEO4SIgVBgIDEAEcEQCAFQT9GDQIgBUEjRw0BIAYoAgghAyAGKAIMDAMLQQAhBSAAQQA2AgBBCAwEC0HYksQAQcMAQZyTxAAQnykACyABKAIIIQRBASENIAFBARDYLSABKAIEIAEoAghqQT86AAAgASAEQQFqNgIIIAYoAgghByAGKAIMIQgjAEFAaiIFJAAgBSAINgIMIAUgBzYCCCAFIAEpAhg3AhAgBSABLQAgRToAGAJAAkACf0EAIAEoAhAiCUUNABogASgCFCEKIAEoAgQhBwJAIANFDQAgASgCCCIIIANNBEAgAyAIRg0BDAMLIAMgB2osAABBv39MDQILAkAgByADQbSGxABBBBDBLg0AIAcgA0G4hsQAQQUQwS4NACAHIANBxYbEAEEEEMEuDQBBACAHIANBwobEAEEDEMEuRQ0BGgsgCQshByAFQRxqIAVBCGoQnwsCQCAFLQAkIgNBAkYNAEGsk8QAQbyTxAAgAkH/AXFBAkYbIQIDQCAFKAIgIQggBSgCHCEJAkAgBwRAIAVBNGoiDCAHIAkgCCAKKAIUEQUAIAUgDBDcOyAFIAI2AjAgBSAFKQMANwIoIAEgBUEoahCvHiAFKAI0QYCAgIB4Rg0BIAwQ3jsMAQsgBSACNgI8IAUgCDYCOCAFIAk2AjQgASAFQTRqEK8eCyADQQFxRQRAIAVBHGogBUEIahCfCyAFLQAkIgNBAkYNAgwBCwsgBSgCDCEDIAUoAgghCwsgBiADNgIEIAYgCzYCACAFQUBrJAAMAQsgByAIQQAgA0GElMQAEKM2AAsgBigCACIDRQ0BIAYoAgQLIQIgASgCCCEFIAFBARDYLSABKAIEIAEoAghqQSM6AAAgASAFQQFqNgIIIAEgAyACENwcIABBATYCCCAAIAQ2AgQgACANNgIAQQwMAQsgACAENgIEIABBATYCAEEAIQVBCAsgAGogBTYCACAGQRBqJAALpwICBH8BfiMAQSBrIgUkAEEIIQcCQAJAIANFDQAgASgCTCIGRQRAIAEgAjQCACIINwM4IAEgCDcDMEEBIQQLIAEgAyAGajYCTCADIARNDQAgAyAEayEGIAIgBEECdGohAwNAIAEoAlwiAiABKAJIIgRPDQIgASgCRCACQQN0aiADNAIAIgggASkDOH3ENwMAIAEgCDcDOCABIAEoAlxBAWoiAjYCXAJAIAIgASgCUEcNACAFQQhqIAEQiwcgBSgCCCIHQQhGDQAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAMAgsgA0EEaiEDIAZBAWsiBg0AC0EIIQcLIAAgBzYCACAFQSBqJAAPCyACIARBgJ/OABDDIQALvgICA34IfwJAAkAgACgCTEUNACAAQdAAaiABEO4LIQIgACgCQCIGQUBqIQggACgCRCIHIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQkgASgCBCEKQQAhAQNAIAUgBmopAAAiAyAEhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAKIAkgCCACeqdBA3YgBWogB3EiC0EGdGsiDCgCBCAMKAIIEOQcDQQgAkIBfSACgyICUEUNAAsLIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0BIAUgAUEIaiIBaiAHcSEFDAALAAsgACgCHEGAgMAAIAAoAhhBAXEbDwsgBkEAIAtrQQZ0aiIBQRRrKAIAIAAoAhxBgIDAACAAKAIYQQFxGyABQRhrKAIAGwuwAgIDfgh/An9BACAAKAJMRQ0AGiAAQdAAaiABEO4LIQIgACgCQCIHQUBqIQkgACgCRCIIIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQogASgCBCELQQAhAQNAAkAgBSAHaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAsgCiAJIAJ6p0EDdiAFaiAIcSIGQQZ0ayIMKAIEIAwoAggQ5BwNAiACQgF9IAKDIgJQRQ0ACwtBACADIANCAYaDQoCBgoSIkKDAgH+DUEUNAhogBSABQQhqIgFqIAhxIQUMAQsLIAdBACAGa0EGdGoiAUEoa0EAIAFBMGsoAgAbCyIGIABBCGpBACAAKAIAQQFxGyAGGwvyEQMGfwR8AX4jAEEwayIFJAAgBSACOQMAAkAgAAJ/IAJEAAAAAAAA8D9jIAJEAAAAAAAAAABmcUUEQCAFQQE2AhQgBUHI6c4ANgIQIAVCATcCHCAFQYoINgIMIAUgBUEIajYCGCAFIAU2AgggAEEEaiAFQRBqEJkOQQAMAQsgBUF/QSBBgICAwAAgAbpEAAAAAAAAIMCiAnwCQAJAAn9EAAAAAAAA8D8CfEQAAAAAAADwPyEJAkACQAJAIAK9IgGnIgdFIAFCIIgiDUKAgMD/A1FxDQAgAkQAAAAAAADAP6AgDaciBEH/////B3EiBkGAgMD/B0sgBkGAgMD/B0ZBACAHG3INAxoCQCABQgBZDQALIAKZIQkCQAJAIAcNACAEQQBIBEAgBEGAgICAeEYgBEGAgMD/e0ZyDQIgBEGAgEBHDQEMAgsgBEUgBEGAgMD/A0ZyIARBgIDA/wdGcg0BCyABQgBTBEAgAiACoSICIAKjDAULIAlEAAAAAAAAQEOiIgIgCSAGQYCAwABJIgcbIQkgAr1CIIinIAYgBxsiCEH//z9xIgRBgIDA/wNyIQYgCEEUdUHMd0GBeCAHG2ohBwJAIARBj7EOSQ0AIARB+uwuSQRAQQEhAwwBCyAEQYCAgP8DciEGIAdBAWohBwsgA0EDdCIEQajuigFqKwMARAAAAAAAAPA/IARBmO6KAWorAwAiAiAJvUL/////D4MgBq1CIIaEvyILoKMiCSALIAKhIgogA0ESdCAGQQF2akGAgKCAAmqtQiCGvyIMIAogCaIiCr1CgICAgHCDvyIJoqEgAiAMoSALoCAJoqGiIgIgCSAJoiILRAAAAAAAAAhAoCACIAogCaCiIAogCqIiAiACoiACIAIgAiACIAJE705FSih+yj+iRGXbyZNKhs0/oKJEAUEdqWB00T+gokRNJo9RVVXVP6CiRP+rb9u2bds/oKJEAzMzMzMz4z+goqAiDKC9QoCAgIBwg78iAqIgCiAMIAJEAAAAAAAACMCgIAuhoaKgIgogCiAJIAKiIgmgvUKAgICAcIO/IgIgCaGhRP0DOtwJx+4/oiACRPUBWxTgLz6+oqCgIgkgBEG47ooBaisDACIKIAkgAkQAAADgCcfuP6IiCaCgIAe3IgugvUKAgICAcIO/IgIgC6EgCqEgCaGhIQogAkQAAAAAAADAP6IiCSAKRAAAAAAAAMA/oiACRAAAAAAAAAAAoqAiAqAiCr0iAachAwJAIAFCIIinIgRB//+/hARMBEAgBEGA+P//B3FB/5fDhARNDQEgBEGA6Lz7A2ogA3INBCACIAogCaFlRQ0BDAQLIARBgIDAhARrIANyDQQgAkT+gitlRxWXPKAgCiAJoWRFDQAMBAtBACEDAnwgBEH/////B3FBgICA/wNLBH5BAEGAgMAAIARBFHZBAmp2IARqIgRB//8/cUGAgMAAckETIARBFHYiBmt2IgNrIAMgAUIAUxshAyACIAlBgIBAIAZBAWp1IARxrUIghr+hIgmgvQUgAQtCgICAgHCDvyIKRAAAAABDLuY/oiILIAIgCiAJoaFE7zn6/kIu5j+iIApEOWyoDGFcIL6ioCIKoCICIAIgAiACIAKiIgkgCSAJIAkgCUTQpL5yaTdmPqJE8WvSxUG9u76gokQs3iWvalYRP6CiRJO9vhZswWa/oKJEPlVVVVVVxT+goqEiCaIgCUQAAAAAAAAAwKCjIAogAiALoaEiCSACIAmioKGhRAAAAAAAAPA/oCICvSIBQiCIpyADQRR0aiIEQYCAwABOBEAgAUL/////D4MgBK1CIIaEvwwBCwJAAkACQCADQf8HTARAIANBgnhODQMgAkQAAAAAAABgA6IhAiADQbhwTQ0BIANByQdqIQMMAwsgAkQAAAAAAADgf6IhAiADQf4PSw0BIANB/wdrIQMMAgsgAkQAAAAAAABgA6IhAkHwaCADIANB8GhNG0GSD2ohAwwBCyACRAAAAAAAAOB/oiECQf0XIAMgA0H9F08bQf4PayEDCyACIANB/wdqrUI0hr+iC0QAAAAAAADwP6IhCQwBCyABQgBZDQAgBkGAgMD/A0YEQCAJIAmhIgIgAqMMBAsgCQwDCyAJDAILRAAAAAAAAAAADAELRAAAAAAAAPB/C6EiAr0iAUKAgICAgICACFkEQCABQv/////////3/wBWDQNBgXghAyABQiCIIg1CgIDA/wNSBEAgDacMAgtBgIDA/wMgAacNARpEAAAAAAAAAAAMBAtEAAAAAAAA8L8gAiACoqMgAkQAAAAAAAAAAGENAxogAUIAUw0BQct3IQMgAkQAAAAAAABQQ6K9IgFCIIinCyEEIAMgBEHiviVqIgNBFHZqtyIJRAAA4P5CLuY/oiABQv////8PgyADQf//P3FBnsGa/wNqrUIghoS/RAAAAAAAAPC/oCICIAlEdjx5Ne856j2iIAIgAkQAAAAAAAAAQKCjIgkgAiACRAAAAAAAAOA/oqIiCiAJIAmiIgkgCaIiAiACIAJEn8Z40Amawz+iRK94jh3Fccw/oKJEBPqXmZmZ2T+goiAJIAIgAiACRERSPt8S8cI/okTeA8uWZEbHP6CiRFmTIpQkSdI/oKJEk1VVVVVV5T+goqCgoqAgCqGgoAwCCyACIAKhRAAAAAAAAAAAoyECCyACC6P8A0EDdiIDIANBgICAwABPGyIDIANBIE0bQQFrZ3ZBAWoiBEEecSIDNgIIIAMNASAFQShqQgA3AwAgBUEgakIANwMAIAVBGGpCADcDACAFQgA3AxAjAEEgayIDJAAgA0EUaiAEQQV2IgZBAEEEQSAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxB1OnOABD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AgggA0EIaiAGIAVBEGoQlBQgAEEEaiIAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAEEICzYCACAFQTBqJAAPCyAFQQA2AhBBACAFQQhqQdDpzgAgBUEQakHk6c4AEK8rAAufAgECfyMAQSBrIgEkACAEIAQoAggiBUEIahCOLSABQQhqIAEgAiADIAQQ4QsCQAJAAkACQCABKAIIIgZBCEcEQCAAIAEpAgw3AgQgAEEUaiABQRxqKAIANgIAIABBDGogAUEUaikCADcCAAwBCyAEKAIIIgIgBUkNASACIAVrIgJBA00NAiAEKAIEIAVqIgQgA0EYdCADQYD+A3FBCHRyIANBCHZBgP4DcSADQRh2cnI2AAAgAkEHTQ0DIAQgAkEIayICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycjYABAsgACAGNgIAIAFBIGokAA8LIAUgAkH03dAAEK87AAtBBCACQYTe0AAQsDsAC0EIIAJBlN7QABCwOwALsAIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqEM8UAkACQEEMQQQQrTYiAQRAIAFCh46cuPDgwYMHNwIAIAFBCGpBh46cODYCAEEMQQQQrTYiA0UNASADQpiw4MCBg4aMGDcCACADQQhqQZiw4MABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBD5PSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ7j0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCfCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEOsOIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KUqNCgwYKFihQ3AgAgA0EIakGUqNCgATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEO49IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDtDiACQUBrIgQgAUEwahDUFAJAAkBBDEEEEK02IgEEQCABQoiQoMCAgYKECDcCACABQQhqQYiQoMAANgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPE9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKMIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuxAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQ1BQCQAJAQQxBBBCtNiIBBEAgAUKIkKDAgIGChAg3AgAgAUEIakGIkKDAADYCAEEMQQQQrTYiA0UNASADQpmy5MiRo8aMGTcCACADQQhqQZmy5MgBNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBDxPSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ9D0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCjCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEOwOIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KWrNiw4cKFixY3AgAgA0EIakGWrNiwATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEPQ9IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDrDiACQUBrIgQgAUEwahDUFAJAAkBBDEEEEK02IgEEQCABQoiQoMCAgYKECDcCACABQQhqQYiQoMAANgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPE9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKMIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANClqzYsOHChYsWNwIAIANBCGpBlqzYsAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7g4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuxAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQ1BQCQAJAQQxBBBCtNiIBBEAgAUKIkKDAgIGChAg3AgAgAUEIakGIkKDAADYCAEEMQQQQrTYiA0UNASADQpas2LDhwoWLFjcCACADQQhqQZas2LABNgIAIAIgAzYCeCACIAE2AnQgAkEiOgBwIAJB2AFqIgMgBBDxPSACQbQCaiIBIAMQoRsgAyABIAJB8ABqEIwYQcQAQQQQrTYiBEUNAiAEIAUQ9D0gAkEBNgK8AiACIAQ2ArgCIAJBATYCtAIgAkH8AGoiBCADIAEQ/CIgASAEEM0cIAAgARCjCCACQZADaiQADwtBBEEMEKM9AAtBBEEMEKM9AAtBBEHEABCjPQALsQIBBH8jAEGQA2siAiQAIAEQlzYgAkEEaiIFIAFB5ABqEO0OIAJBQGsiBCABQTBqENkUAkACQEEMQQQQrTYiAQRAIAFCiZKkyJChwoQJNwIAIAFBCGpBiZKkyAA2AgBBDEEEEK02IgNFDQEgA0KYsODAgYOGjBg3AgAgA0EIakGYsODAATYCACACIAM2AnggAiABNgJ0IAJBIjoAcCACQdgBaiIDIAQQ8D0gAkG0AmoiASADEKEbIAMgASACQfAAahCMGEHEAEEEEK02IgRFDQIgBCAFEO49IAJBATYCvAIgAiAENgK4AiACQQE2ArQCIAJB/ABqIgQgAyABEPwiIAEgBBDNHCAAIAEQoQggAkGQA2okAA8LQQRBDBCjPQALQQRBDBCjPQALQQRBxAAQoz0AC7ECAQR/IwBBkANrIgIkACABEJc2IAJBBGoiBSABQeQAahDuDiACQUBrIgQgAUEwahDZFAJAAkBBDEEEEK02IgEEQCABQomSpMiQocKECTcCACABQQhqQYmSpMgANgIAQQxBBBCtNiIDRQ0BIANCmbLkyJGjxowZNwIAIANBCGpBmbLkyAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPA9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEKEIIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7Q4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANCmLDgwIGDhowYNwIAIANBCGpBmLDgwAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ7A4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANClqzYsOHChYsWNwIAIANBCGpBlqzYsAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRD0PSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQzxQCQAJAQQxBBBCtNiIBBEAgAUKHjpy48ODBgwc3AgAgAUEIakGHjpw4NgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPk9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ8IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAuwAgEEfyMAQZADayICJAAgARCXNiACQQRqIgUgAUHkAGoQ6w4gAkFAayIEIAFBMGoQ0RQCQAJAQQxBBBCtNiIBBEAgAUKGjJiw4MCBgwY3AgAgAUEIakGGjJgwNgIAQQxBBBCtNiIDRQ0BIANClKjQoMGChYoUNwIAIANBCGpBlKjQoAE2AgAgAiADNgJ4IAIgATYCdCACQSI6AHAgAkHYAWoiAyAEEPc9IAJBtAJqIgEgAxChGyADIAEgAkHwAGoQjBhBxABBBBCtNiIERQ0CIAQgBRDuPSACQQE2ArwCIAIgBDYCuAIgAkEBNgK0AiACQfwAaiIEIAMgARD8IiABIAQQzRwgACABEJ0IIAJBkANqJAAPC0EEQQwQoz0AC0EEQQwQoz0AC0EEQcQAEKM9AAvfDAIVfwJ+IwBBMGsiBiQAIAFBqAFqIQggBkEcaiEPIAZBIGohCwJAA0ACQCAGQRhqIQUjAEGwBGsiAyQAIAFBgAFqIRAgAUGMAWohEyABQdAAaiEUIAFBIGohFSABQQhqIQwgAUHkAGohDSABQeAAaiEHIAEoAmAhBCADQewCaiERIANB4AJqIRIgA0GQAWohCSADQdwBaiEOIANBqAFqIRYCQANAAkACQAJAAkACQAJAAkACQAJAAkBBASAEQf////8HaiAEQYCAgIB4TRtBAWsOAwIDAAELIAVBCTYCAAwHCyADQRBqIBQQ0yIgAygCEEEBcQ0HIAVBCTYCAAwGCyADQYgBaiAHEIcGIAMoAogBIgRBAkYNASAEQQFxBEAgA0EoaiADQZwBaigCADYCACADQSBqIANBlAFqKQIANwMAIAMgAykCjAE3AxggBxCGJCAHQYSAgIB4NgIAIANBADYCmAQgA0KAgICAEDcCkAQgA0GY+cIANgKgBCADQqCAgIAONwKkBCADIANBkARqNgKcBCADQRhqIgcgA0GcBGoQnwQNAyAFIAMpApAENwIEIAVBDGogA0GYBGooAgA2AgAgBUEDNgIAIAcQiBEMBgsgBSADKQKMATcCBCAFQQg2AgAgBUEUaiADQZwBaigCADYCACAFQQxqIANBlAFqKQIANwIADAULIANBiAFqIAEoAmQgAiABKAJoKAIMEQEAIAMpA4gBIhhCA1ENAyAYQgJRBEAgBSAJKQMANwMAIAVBEGogCUEQaikDADcDACAFQQhqIAlBCGopAwA3AwAgBxCGJCAHQYSAgIB4NgIADAULIAMoAtgBIQQgASkDAEICUgRAIAEQ2BULIAEgGDcDACAMIAkpAwA3AwAgDEEIaiAJQQhqKQMANwMAIAxBEGogCUEQaikDADcDACAVIBZBMPwKAAAgBxCGJCAEQYGAgIB4Rg0CIA0gDikCADcCACANQRhqIA5BGGooAgA2AgAgDUEQaiAOQRBqKQIANwIAIA1BCGogDkEIaikCADcCAAwCCyAHEIYkQYGAgIB4IQQMAQtBwPnCAEE3IANBrwRqQbD5wgBB+PnCABDVHgALIAcgBDYCAAwDCyAFQQo2AgALIANBsARqJAAMAgsgAygCFCEEIAEpAwAhGCABQgI3AwAgGEICUgRAIANBMGogDEHIAPwKAAAgASgCmAFBCGogBBCILSEKAkAgASgCjAFBgICAgHhHBEAgA0H8AGogEyAKKAIQEKAODAELIANBgICAgHg2AnwLAkAgECgCAEGAgICAeEcEQCADQRhqIBAQ5x4MAQsgA0GAgICAeDYCGAsgESADKQIYNwIAIBFBCGogA0EgaigCADYCACADIBg3A4gBIAEoAqABIQogCSADQTBqQcgA/AoAACASIAMpAnw3AgAgEkEIaiADQYQBaigCADYCACADIAQ2AvgCIANBADoApAMgAyAKNgL8AiADQQhqIQQgA0GIAWohFwJAQYgDQQgQrTYiCgRAIAogF0GIA/wKAAAgBEHY+MIANgIEIAQgCjYCAAwBC0EIQYgDEKM9AAsgAygCCCEEIAcQhiQgAUHY+MIANgJoIAEgBDYCZEGDgICAeCEEIAFBg4CAgHg2AmAMAQsLQZT4wgBBE0Go+MIAEMskAAsCQAJAIAYoAhgiA0EIRwRAAkAgA0EJaw4CBAIACyAGQRBqIAtBCGopAwAiGDcDACAGIAspAwAiGTcDCCAGKAIcIQEgAEEQaiAYNwMAIAAgGTcDCCAAIAE2AgQgACADNgIADAULIAZBEGoiAyALQQhqKQMANwMAIAYgCykDADcDCCAGKAIcIgVBgICAgHhrDgICAAELIABBCTYCAAwDCyAPIAYpAwg3AgAgD0EIaiADKQMANwIAIAYgBTYCGCAGQRhqIgUoAgAiB0GAgICAeEciBCAIKAIAIAgoAggiA2tLBEAgCCADIARBBEEUENAoIAgoAgghAwsgCCAHQYCAgIB4RwR/IAgoAgQgA0EUbGoiBCAHNgIAIAQgBSkCBDcCBCAEQQxqIAVBDGopAgA3AgAgA0EBagUgAws2AggMAQsLIAAgCCkCADcCBCAAQQxqIAhBCGooAgA2AgAgAUEANgKwASABQoCAgIDAADcDqAEgAEEINgIACyAGQTBqJAALrgIBCH8jAEEgayIEJAACQCABKAIEIgNFBEAMAQsgASgCACIFLAAAIgZB/wFxIQICQAJAAkAgBkEASA0AIAEoAggiCCACQQN2QRxxaigCACACdkEBcQ0AQQEhBgNAIAMgBiICRg0CIAIgBWoiCSwAACIHQQBOBEAgAkEBaiEGIAggB0EDdkH8////AXFqKAIAIAd2QQFxRQ0BCwsgAiADSw0CIAEgAyACazYCBCABIAk2AgAgAiEDDAMLIAEgA0EBazYCBCABIAVBAWo2AgBBAyEDIAJBA2xBsLHMAGohBQwCCyABQgE3AgAMAQsgBEEANgIYIARBATYCDCAEQYixzAA2AgggBEIENwIQIARBCGpBsLfMABDvLAALIAAgAzYCBCAAIAU2AgAgBEEgaiQAC6UCAgR/AX4jAEEgayIFJABBCCEHAkAgA0UNACABKAJMIgZFBEAgASACKQMAIgg3AzggASAINwMwQQEhBAsgASADIAZqNgJMIAMgBE0NACADIARrIQYgAiAEQQN0aiEDA0AgASgCXCICIAEoAkgiBEkEQCABKAJEIAJBA3RqIAMpAwAiCCABKQM4fTcDACABIAg3AzggASABKAJcQQFqIgI2AlwCQCACIAEoAlBHDQAgBUEIaiABEJIHIAUoAggiB0EIRg0AIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIADAMLQQghByADQQhqIQMgBkEBayIGDQEMAgsLIAIgBEGAn84AEMMhAAsgACAHNgIAIAVBIGokAAuyAgIDfgh/An8CQAJAIAAoAkxFDQAgAEHQAGogARDuCyECIAAoAkAiBkFAaiEIIAAoAkQiByACp3EhBSACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgASgCCCEJIAEoAgQhCkEAIQEDQCAFIAZqKQAAIgMgBIUiAkJ/hSACQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgJQRQRAA0AgCiAJIAggAnqnQQN2IAVqIAdxIgtBBnRrIgwoAgQgDCgCCBDkHA0EIAJCAX0gAoMiAlBFDQALCyADIANCAYaDQoCBgoSIkKDAgH+DUEUNASAFIAFBCGoiAWogB3EhBQwACwALIAAtACgMAQsgAC0AKCAGQQAgC2tBBnRqQQhrLQAAIgAgAEECRhsLIgAgAEH/AXFBAkZyQQFxC8YFAgp/An4jAEEwayICJAAgASgCHCEGIAEoAgwhCSABKAIQIQMgAiABKAIYIgQ2AgAgAiAJIANBA3RqNgIsIAIgCTYCKCACIAQgBkECdGoiBjYCBCACQShqEJg2IQUgAhCeNiEIIAIpAighDCACIAEoAiQiCiABKAIoQQN0aiIDNgIsIAIgCjYCKCACQShqEJg2IQkgAkEANgIgIAIgAzYCHCACIAo2AhggAkEANgIQIAIgBjYCDCACIAQ2AgggAiAMNwIAIAIgCCAFIAUgCEsbIgM2AhQgAiAJIAMgAyAJSxs2AiQjAEEgayIHJAAgB0EUaiACKAIkIAIoAiBrQQBBCEEYEKAYIAcoAhghAyAHKAIUQQFGBEAgAyAHKAIcQbjmzwAQ/S8ACyAHQRBqIglBADYCACAHIAcoAhw2AgwgByADNgIIIwBBEGsiCyQAIAIoAiQgAigCIGsiAyAHQQhqIgYoAgAgBigCCCIEa0sEQCAGIAQgA0EIQRgQ0CggBigCCCEECyALIAYoAgQ2AgwgCyAENgIIIAsgBkEIajYCBCALQQRqIggoAgQhBSAIKAIAIAIoAiQiAyACKAIgIgRHBH8gAyAEayEKIAMgBWogBGsgCCgCCCAFQRhsaiEFIAIoAhggBEEDdGohCCACKAIAIAIoAhAgBGoiA0EDdGohBCACKAIIIANBAnRqIQMDQCAEKQMAIQ0gCCkDACEMIAVBEGogAygCADYCACAFQQhqIAw3AwAgBSANNwMAIARBCGohBCADQQRqIQMgCEEIaiEIIAVBGGohBSAKQQFrIgoNAAsFIAULNgIAIAtBEGokACAAQQhqIAkoAgA2AgAgACAHKQIINwIAIAdBIGokACAAQRRqIAFBNGooAgA2AgAgACABKQIsNwIMIAFBCGoQ4zwgAUEUahDpOyABQSBqEOM8IAJBMGokAAugFgIMfwF+AkAgAEGN/3tPDQACfwJAAkACQEEQIABBC2pBeHEgAEELSRsiCUHMAGoiAEH1AU8EQCAAQcz/e0sNAiAAQQtqQXhxIQRBxPOKASgCAEUNAUEAIARrIQMCQAJAAkACf0EAIARBgAJJDQAaQR8gBEH///8HSw0AGiAEQQYgBEEIdmciAGt2QQFxIABBAXRrQT5qCyIHQQJ0QajwigFqKAIAIgAEQCAEQRkgB0EBdmtBACAHQR9HG3QhBgNAAkAgACgCBEF4cSIFIARJDQAgBSAEayIFIANPDQAgACECIAUiAw0AQQAhAyAAIQEMAwsgACgCFCIFIAEgBSAAIAZBHXZBBHFqKAIQIgBHGyABIAUbIQEgBkEBdCEGIAANAAsLIAEgAnJFBEBBACEBQcTzigEoAgBBAiAHdCIAQQAgAGtycSIARQ0DQQAhAiAAaEECdEGo8IoBaigCACEBCyABRQ0BCwNAIAEgAiABKAIEQXhxIgUgBGsiBiADSSIHGyEIIAEoAhAiAEUEQCABKAIUIQALIAIgCCAEIAVLIgEbIQIgAyAGIAMgBxsgARshAyAAIgENAAsLQQAhASACRQ0AIARByPOKASgCACIATSADIAAgBGtPcQ0AIAIgBBCYPiEAIAIQrRECQCADQRBPBEAgAiAEQQNyNgIEIAAgAxDQNCAAIAMQihwMAQsgAiADIARqEPMuCyACEJk+IQELIAENAgwBCwJAAkACQEHA84oBKAIAIgNBECAAQQtqQfgDcSAAQQtJGyIEQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgVBA3QiBEGo8IoBaiIBQZABaiIAIAFBmAFqKAIAIgEoAggiAkYNASACIAA2AgwgACACNgIIDAILIARByPOKASgCAE0NAyABRQRAQcTzigEoAgBFDQRBxPOKASgCAGhBAnRBqPCKAWooAgAiASgCBEF4cSAEayEDIAEhAAJAA0ACQAJAIAEoAhAiAg0AIAEoAhQiAg0AIAAgBBCYPiEFIAAQrREgA0EQTwRAIAAgBEEDcjYCBCAFIAMQ0DRByPOKASgCACICRQ0CQdDzigEoAgAhAQJ/QcDzigEoAgAiBkEBIAJBA3Z0IgdxRQRAQcDzigEgBiAHcjYCACACQXhxQbjxigFqIgIMAQsgAkF4cUGo8IoBaiIGQZABaiECIAZBmAFqKAIACyEGIAIgATYCCCAGIAE2AgwgASACNgIMIAEgBjYCCAwCCyAAIAMgBGoQ8y4MAwsgAigCBEF4cSAEayIBIAMgASADSSIBGyEDIAIgACABGyEAIAIhAQwBCwtB0POKASAFNgIAQcjzigEgAzYCAAsgABCZPiIBRQ0EDAULAkBBAiAAdCICQQAgAmtyIAEgAHRxaCIFQQN0IgZBuPGKAWoiACAAKAIIIgIoAggiAUcEQCABIAA2AgwgACABNgIIDAELQcDzigEgA0F+IAV3cTYCAAsgAiAEQQNyNgIEIAIgBBCYPiIFIAYgBGsiBBDQNEHI84oBKAIAIgFFDQJB0POKASgCACEAAn9BwPOKASgCACIDQQEgAUEDdnQiBnFFBEBBwPOKASADIAZyNgIAIAFBeHFBuPGKAWoiAQwBCyABQXhxQbjxigFqIgEoAggLIQMgASAANgIIIAMgADYCDCAAIAE2AgwgACADNgIIDAILQcDzigEgA0F+IAV3cTYCAAsgASAEEPMuIAEQmT4MBAtB0POKASAFNgIAQcjzigEgBDYCACACEJk+DAMLQcjzigEoAgAiASAETw0BIARBzPOKASgCACIATwRAQQAhBiMAQRBrIgckACAHQQRqIARBr4AEakGAgHxxEMsiAkAgBygCBCIARQ0AIAcoAgwhCEHY84oBIAcoAggiBUHY84oBKAIAaiIBNgIAQdzzigEgAUHc84oBKAIAIgIgASACSxs2AgACQEHU84oBKAIARQRAQeTzigEoAgAiAUEAIAAgAU8bRQRAQeTzigEgADYCAAtB6POKAUH/HzYCAEG08YoBIAg2AgBBrPGKASAFNgIAQajxigEgADYCAEEAIQIDQCACQajwigFqIgFBmAFqIAFBkAFqIgM2AgAgAUGcAWogAzYCACACQQhqIgJBgAJHDQALIAAgBUEoaxDRJgwBC0Go8YoBIgMhAgJAA0AgAhCuOyAARwRAIAIoAggiAg0BDAILCyACKAIMIgFBAXEgAUEBdiAIR3INACACQdTzigEoAgAQzy1FDQAgAiACKAIEIAVqNgIEQdTzigEoAgBBzPOKASgCACAFahDRJgwBC0Hk84oBQeTzigEoAgAiASAAIAAgAUsbNgIAIAAgBWohAgJAAkADQCACIAMoAgAiAUcEQCADKAIIIgMNAQwCCwsgAygCDCICQQFxDQAgAkEBdiAIRg0BC0HU84oBKAIAIQJBqPGKASEBAkADQCACIAEoAgBPBEAgARCuOyACSw0CCyABKAIIIgENAAtBACEBCyACIAEQrjsiC0EvayIBEJk+IgNBB2pBeHEgA2sgAWoiASABIAJBEGpJGyIDEJk+IQogA0EYEJg+IQEgACAFQShrENEmIANBGzYCBEGo8YoBKQIAIQ0gCkEIakGw8YoBKQIANwIAIAogDTcCAEG08YoBIAg2AgBBrPGKASAFNgIAQajxigEgADYCAEGw8YoBIAo2AgADQCABQQQQmD4gAUEHNgIEIgFBBGogC0kNAAsgAiADRwRAIAIgAyACayIAIAIgABCYPhCJLiACIAAQihwLDAELIAMgADYCACADIAMoAgQgBWo2AgQgABCZPiECIAEQmT4hAyAAIAJBB2pBeHEgAmtqIgIgBBCYPiEAIAIgBEEDcjYCBCABIANBB2pBeHEgA2tqIgEgAiAEamshBAJAAkBB1POKASgCACABRwRAIAFB0POKASgCAEYNASABKAIEIgNBA3FBAUYEQCABIANBeHEiAxCpJyADIARqIQQgASADEJg+IQELIAAgBCABEIkuIAAgBBCKHAwCC0HU84oBIAA2AgBBzPOKAUHM84oBKAIAIARqIgE2AgAgACABQQFyNgIEDAELQdDzigEgADYCAEHI84oBQcjzigEoAgAgBGoiATYCACAAIAEQ0DQLIAIQmT4hBgwBC0HM84oBKAIAIgAgBE0NAEHM84oBIAAgBGsiATYCAEHU84oBQdTzigEoAgAiACAEEJg+IgI2AgAgAiABQQFyNgIEIAAgBEEDcjYCBCAAEJk+IQYLIAdBEGokACAGDAMLQczzigEgACAEayIBNgIAQdTzigFB1POKASgCACIAIAQQmD4iAjYCACACIAFBAXI2AgQgACAEQQNyNgIEIAAQmT4hAQsgAQwBC0HQ84oBKAIAIQACQCABIARrIgJBD00EQEHQ84oBQQA2AgBByPOKAUEANgIAIAAgARDzLgwBCyAAIAQQmD4hAUHI84oBIAI2AgBB0POKASABNgIAIAEgAhDQNCAAIARBA3I2AgQLIAAQmT4LIgBFDQAgABCaPiEBAkAgAEE/cUUEQCABIQAMAQsgAEE/akFAcRCaPiEAIAEoAgQiBUF4cSAAQcAAQQAgACABa0EQTRtqIgAgAWsiAmshAyAFQQNxBEAgACADEO4sIAEgAhDuLCABIAIQlxIMAQsgASgCACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAJQRBqTQ0AIAAgCRCYPiEBIAAgCRDuLCABIAIgCWsiAhDuLCABIAIQlxILIAAQmT4hDAsgDAvAAgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFBA3RqKQMAEM4vIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQF0ai8BABC1LiACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC8ACAgR/BH4jAEHgAGsiAiQAIAAoAgAhBCACQUBrIAAoAgQoAhAgAUECdGooAgAQlC8gAkEQaiIFIAIpA0AgAikDSCACKQNQIAIpA1ggBCgCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBUEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBCgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAvAAgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFBAXRqLwEAEJMtIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQJ0aigCABDJLSACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC68CAQZ/IwBBEGsiAyQAQYCAgIB4IQQCQAJAAkACfwJAAkAgACgCBCgCECABQQJ0aigCACIFQYCAgIB4RyAAKAIAIgcoAgAiBigCACgCACICQX9HckUEQEEAIQIMAQsgAkUNBCAFIAUgAm0iBCACbGtBACACQX9HGyECIAVBAE4NAQsgBCACIAYoAggoAgBMawwBCyAEIAIgBigCBCgCAE5qCyICIAcoAgQtAAAQxCkEQCAAKAIIIAFBAnRqIAI2AgAMAQsgACgCECICIAIoAgBBAWo2AgAgA0EIaiAAKAIUEIY9IAFBA3YiACADKAIMIgJPDQIgAygCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIANBEGokAA8LQayP/wAQ4isACyAAIAJBiIv/ABDDIQALwAICBH8EfiMAQeAAayICJAAgACgCACEEIAJBQGsgACgCBCgCECABQQN0aikDABCzLiACQRBqIgUgAikDQCACKQNIIAIpA1AgAikDWCAEKAIAIgMpAwAgAykDCCADKQMQIAMpAxgQnAYCQAJAAkAgAigCECIDQQFGBEAgA0UNASAFQQRyEIgRDAELIAIpAyAiBiACKQMoIgcgAikDMCIIIAIpAzgiCSAEKAIELQAAENwdRQ0AIAAoAgggAUEFdGoiACAJNwMYIAAgCDcDECAAIAc3AwggACAGNwMADAELIAAoAhAiAyADKAIAQQFqNgIAIAJBCGogACgCFBCGPSABQQN2IgAgAigCDCIDTw0BIAIoAgggAGoiACAALQAAQX4gAUEHcXdxOgAACyACQeAAaiQADwsgACADQYiL/wAQwyEAC70CAQF/IwBB0ABrIgQkACAEIAE3AwACQAJAIAACfyACQQFxBEAgBEEgaiABIAMQzyUgBCgCIEUNAiAEKAIsIQIgBCAEKQIkNwJAIARBDGogBEFAayACEIooIAQoAgwhAyAEKAIQDAELIARBIGogARD9FyAEKAIgRQ0BIAQoAiQhAyAEKAIoCzYCCCAAIAM2AgQgAEGTgICAeDYCAAwBCyAEQSc2AjwgBEGLyP8ANgI4IARBAjYCJCAEQazb/wA2AiAgBEICNwIsIARB7gY2AkwgBEHMATYCRCAEIARBQGs2AiggBCAENgJIIAQgBEE4ajYCQCAEQRBqIARBIGoQmQ4gBEGCgICAeDYCDCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIAIABBEGogBEEcaigCADYCAAsgBEHQAGokAAu9AgEBfyMAQdAAayIEJAAgBCABNwMAAkACQCAAAn8gAkEBcQRAIARBIGogASADEM0lIAQoAiBFDQIgBCgCLCECIAQgBCkCJDcCQCAEQQxqIARBQGsgAhCKKCAEKAIMIQMgBCgCEAwBCyAEQSBqIAEQ/RUgBCgCIEUNASAEKAIkIQMgBCgCKAs2AgggACADNgIEIABBk4CAgHg2AgAMAQsgBEErNgI8IARB4Mf/ADYCOCAEQQI2AiQgBEGs2/8ANgIgIARCAjcCLCAEQe4GNgJMIARBzAE2AkQgBCAEQUBrNgIoIAQgBDYCSCAEIARBOGo2AkAgBEEQaiAEQSBqEJkOIARBgoCAgHg2AgwgACAEKQIMNwIAIABBCGogBEEUaikCADcCACAAQRBqIARBHGooAgA2AgALIARB0ABqJAALvQIBAX8jAEHQAGsiBCQAIAQgATcDAAJAAkAgAAJ/IAJBAXEEQCAEQSBqIAEgAxDMJSAEKAIgRQ0CIAQoAiwhAiAEIAQpAiQ3AkAgBEEMaiAEQUBrIAIQiiggBCgCDCEDIAQoAhAMAQsgBEEgaiABEIEVIAQoAiBFDQEgBCgCJCEDIAQoAigLNgIIIAAgAzYCBCAAQZOAgIB4NgIADAELIARBLDYCPCAEQYjH/wA2AjggBEECNgIkIARBrNv/ADYCICAEQgI3AiwgBEHuBjYCTCAEQcwBNgJEIAQgBEFAazYCKCAEIAQ2AkggBCAEQThqNgJAIARBEGogBEEgahCZDiAEQYKAgIB4NgIMIAAgBCkCDDcCACAAQQhqIARBFGopAgA3AgAgAEEQaiAEQRxqKAIANgIACyAEQdAAaiQAC70CAQF/IwBB0ABrIgQkACAEIAE3AwACQAJAIAACfyACQQFxBEAgBEEgaiABIAMQziUgBCgCIEUNAiAEKAIsIQIgBCAEKQIkNwJAIARBDGogBEFAayACEIooIAQoAgwhAyAEKAIQDAELIARBIGogARDWFSAEKAIgRQ0BIAQoAiQhAyAEKAIoCzYCCCAAIAM2AgQgAEGTgICAeDYCAAwBCyAEQSw2AjwgBEG0x/8ANgI4IARBAjYCJCAEQazb/wA2AiAgBEICNwIsIARB7gY2AkwgBEHMATYCRCAEIARBQGs2AiggBCAENgJIIAQgBEE4ajYCQCAEQRBqIARBIGoQmQ4gBEGCgICAeDYCDCAAIAQpAgw3AgAgAEEIaiAEQRRqKQIANwIAIABBEGogBEEcaigCADYCAAsgBEHQAGokAAu3AgEHfyMAQTBrIgIkACABKAIEIQQgASgCACEIAkACQCAAKAIAIgMgACgCBCIFRwRAIAEoAgggBEECdGohASAFIANrQQN2IQUgACgCCCEHA0AgAygCACIAIAcoAggiBk8NAiAHKAIEIABBAnRqKAIAIQAgAiADQQRqKAIAIgY2AgAgAEEMahDbPCAGTQ0DIAEgACgCECAGQQJ0aigCADYCACADQQhqIQMgAUEEaiEBIARBAWohBCAFQQFrIgUNAAsLIAggBDYCACACQTBqJAAPCyAAIAZB/LSCARDDIQALIAIgABD8OzYCHCACQQI2AgggAkGosYIBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBuLGCARDvLAALxAIBBH8jAEGgAmsiAiQAIAEoAkghAyACQeABaiABQTxqKAIANgIAIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQJ2QQFrNgLkASACQgQ3AtABIAJCADcCyAEgAkKAgICAwAA3AsABIAJBADYCuAEgAiABKQI0NwLYASACQdwAaiIEIAJBuAFqIgUgAUHMAGoQwhkCQEEMQQQQrTYiAwRAIAMgASkCQDcCACADQQhqIAFByABqKAIANgIAIAJBATYCnAIgAiADNgKYAiACQQE2ApQCIAUgBCACQZQCahCWKUHEAEEEEK02IgNFDQEgAyABEPAWIAJBATYCZCACIAM2AmAgAkEBNgJcIAIgBSAEEPwiIAAgAhDNHCABENYoIAJBoAJqJAAPC0EEQQwQoz0AC0EEQcQAEKM9AAuuAgECfyABKAIIIQQCQAJAAkACQAJAAkAgASgCBCACaiICIAJBgKMFbSIDQYCjBWxrIgJBH3UgA2pBAWoOAwAEAQQLIAEoAgAiAUHwP3EiA0ERSQ0BIANBEGsgAUGPQHFyIQEMBAsgASgCACIBQfg/cSIDQdAtTQRAIANBEGogAUGHQHFyIQEMBAsgAUENdSIBQf7/D2tBgoBgSQ0BIAFBAWoiAUENdCABQZADbyIBQR91QZADcSABakH0yYYBai0AAHJBEHIhAQwDCyABQQ11QQFrIgEgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAABB8DNyEMYkIgENAgsgAEEANgIADwsgASgCACEBCyAAIAQ2AgggACACQYCjBWogAiACQQBIGzYCBCAAIAE2AgALrgIBAn8gASgCCCEEAkACQAJAAkACQAJAIAEoAgQgAmsiAiACQYCjBW0iA0GAowVsayICQR91IANqQQFqDgMABAEECyABKAIAIgFB8D9xIgNBEUkNASADQRBrIAFBj0BxciEBDAQLIAEoAgAiAUH4P3EiA0HQLU0EQCADQRBqIAFBh0BxciEBDAQLIAFBDXUiAUH+/w9rQYKAYEkNASABQQFqIgFBDXQgAUGQA28iAUEfdUGQA3EgAWpB9MmGAWotAAByQRByIQEMAwsgAUENdUEBayIBIAFBkANvIgFBH3VBkANxIAFqQfTJhgFqLQAAQfAzchDGJCIBDQILIABBADYCAA8LIAEoAgAhAQsgACAENgIIIAAgAkGAowVqIAIgAkEASBs2AgQgACABNgIAC8ECAQZ/IwBB0ABrIgMkACADQQA2AgwCQAJAIAEoAggEQCADIAEoAigiBSACaiIEQQR0IgY2AhAgAAJ/IAYgASgCBCIHKAIIIghNBEAgAyAHEMgbIAQgBUkNAyAEIAMoAgQiAUsNBCADKAIAIQEgACACNgIIIAAgASAFQQR0ajYCBEGTgICAeAwBCyADIAg2AiwgA0Gk7YYBNgIUIANCBDcCICADQTs2AkwgA0E7NgJEIANBrQM2AjwgAyABQRhqNgI4IANBOzYCNCADQQQ2AhggAyADQTBqNgIcIAMgA0EsajYCSCADIANBEGo2AkAgAyADQQxqNgIwIABBBGogA0EUahCZDkGNgICAeAs2AgAgA0HQAGokAA8LQQBBAEHQ7IYBEMMhAAsgBSAEQeDshgEQsTsACyAEIAFB4OyGARCwOwALmgIBA38gACgCCCIDIQICf0EBIAFBgAFJDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgQgACgCACADa0sEfyAAIAMgBBDPFiAAKAIIBSACCyAAKAIEaiECAkACQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoAAyACIAFBEnZB8AFyOgAAIAIgAUEGdkE/cUGAAXI6AAIgAiABQQx2QT9xQYABcjoAAQwDCyACIAFBP3FBgAFyOgACIAIgAUEMdkHgAXI6AAAgAiABQQZ2QT9xQYABcjoAAQwCCyACIAE6AAAMAQsgAiABQT9xQYABcjoAASACIAFBBnZBwAFyOgAACyAAIAMgBGo2AghBAAvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFBvNXCAEEHIAJBDGpBrNXCABDQEwwHCyACIABBBGo2AgwgAUHD1cIAQQMgAkEMakGs1cIAENATDAYLIAIgAEEEajYCDCABQcbVwgBBAyACQQxqQazVwgAQ0BMMBQsgAiAAQQRqNgIMIAFBydXCAEEKIAJBDGpBrNXCABDQEwwECyACIABBCGo2AgwgAUHk1cIAQQ8gAEEEakHwysIAIAJBDGpB1NXCABCDDwwDCyACIABBBGo2AgwgAUGE1sIAQQggAkEMakH01cIAENATDAILIAIgAEEEajYCDCABQYzWwgBBDCACQQxqQdTVwgAQ0BMMAQsgAiAAQQhqNgIMIAFBqNbCAEERIAJBDGpBmNbCABDQEwsgAkEQaiQAC9kCAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAIAAoAgBBAWsOBwECAwQFBgcACyACIABBBGo2AgwgAUGk68IAQQcgAkEMakGU68IAENATDAcLIAIgAEEEajYCDCABQavrwgBBAyACQQxqQZTrwgAQ0BMMBgsgAiAAQQRqNgIMIAFBruvCAEEDIAJBDGpBlOvCABDQEwwFCyACIABBBGo2AgwgAUGx68IAQQogAkEMakGU68IAENATDAQLIAIgAEEIajYCDCABQdzrwgBBDyAAQQRqQbzrwgAgAkEMakHM68IAEIMPDAMLIAIgAEEEajYCDCABQfzrwgBBCCACQQxqQezrwgAQ0BMMAgsgAiAAQQRqNgIMIAFBhOzCAEEMIAJBDGpBzOvCABDQEwwBCyACIABBCGo2AgwgAUGg7MIAQREgAkEMakGQ7MIAENATCyACQRBqJAALrAIBA38CQAJAIAAoAgAiACgCDCAAKAIQIAEoAgAiASgCDCABKAIQEMEuRQ0AIAEtACAgAC0AIEcNACAALQAhIAEtACFHDQACQCAALQAUIgNBEUYgAS0AFCICQRFGckUEQCACIANHDQICQAJAAkACQCADQQRrDgUABQECAwULIAAoAhggASgCGEcNBSAAKAIcIAEoAhxGDQQMBQsgAC0AFiABLQAWRw0EIAAtABUgAS0AFUYNAwwECyAALQAWIAEtABZHDQMgAC0AFSABLQAVRg0CDAMLIAAtABUgAS0AFUcNAiAALQAWIAEtABZGDQEMAgsgA0ERRyACQRFHcg0BCyABKAIAIQIgACgCAEEBRw0BIAJFDQAgACgCBCABKAIERiEECyAEDwsgAkEBcwvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFBxJvDAEEHIAJBDGpBtJvDABDQEwwHCyACIABBBGo2AgwgAUHLm8MAQQMgAkEMakG0m8MAENATDAYLIAIgAEEEajYCDCABQc6bwwBBAyACQQxqQbSbwwAQ0BMMBQsgAiAAQQRqNgIMIAFB0ZvDAEEKIAJBDGpBtJvDABDQEwwECyACIABBCGo2AgwgAUH8m8MAQQ8gAEEEakHcm8MAIAJBDGpB7JvDABCDDwwDCyACIABBBGo2AgwgAUGcnMMAQQggAkEMakGMnMMAENATDAILIAIgAEEEajYCDCABQaScwwBBDCACQQxqQeybwwAQ0BMMAQsgAiAAQQhqNgIMIAFBwJzDAEERIAJBDGpBsJzDABDQEwsgAkEQaiQAC4YCAQt/IAAgAUEDdEEIayIDaiEFIAIgA2ohBiAAIAFBAXYiB0EDdGoiA0EIayEEA0AgAiADIAAgAygCACIIIAAoAgAiCUkiChspAgA3AgAgBiAEIAUgBSgCACILIAQoAgAiDEkiDRspAgA3AgAgBkEIayEGIAJBCGohAiAEQXhBACANG2ohBCAFQXhBACALIAxPG2ohBSAAIAggCU9BA3RqIQAgAyAKQQN0aiEDIAdBAWsiBw0ACyAEQQhqIQQgAUEBcQR/IAIgACADIAAgBEkiARspAgA3AgAgAyAAIARPQQN0aiEDIAAgAUEDdGoFIAALIARHIAMgBUEIakdyRQRADwsQ5CsAC9kCAQF/IwBBEGsiAiQAAn8CQAJAAkACQAJAAkACQAJAIAAoAgBBAWsOBwECAwQFBgcACyACIABBBGo2AgwgAUHkgM4AQQcgAkEMakHUgM4AENATDAcLIAIgAEEEajYCDCABQeuAzgBBAyACQQxqQdSAzgAQ0BMMBgsgAiAAQQRqNgIMIAFB7oDOAEEDIAJBDGpB1IDOABDQEwwFCyACIABBBGo2AgwgAUHxgM4AQQogAkEMakHUgM4AENATDAQLIAIgAEEIajYCDCABQZyBzgBBDyAAQQRqQfyAzgAgAkEMakGMgc4AEIMPDAMLIAIgAEEEajYCDCABQbyBzgBBCCACQQxqQayBzgAQ0BMMAgsgAiAAQQRqNgIMIAFBxIHOAEEMIAJBDGpBjIHOABDQEwwBCyACIABBCGo2AgwgAUHggc4AQREgAkEMakHQgc4AENATCyACQRBqJAAL2QIBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkAgACgCAEEBaw4HAQIDBAUGBwALIAIgAEEEajYCDCABQeCMzgBBByACQQxqQdCMzgAQ0BMMBwsgAiAAQQRqNgIMIAFB54zOAEEDIAJBDGpB0IzOABDQEwwGCyACIABBBGo2AgwgAUHqjM4AQQMgAkEMakHQjM4AENATDAULIAIgAEEEajYCDCABQe2MzgBBCiACQQxqQdCMzgAQ0BMMBAsgAiAAQQhqNgIMIAFBmI3OAEEPIABBBGpB+IzOACACQQxqQYiNzgAQgw8MAwsgAiAAQQRqNgIMIAFBuI3OAEEIIAJBDGpBqI3OABDQEwwCCyACIABBBGo2AgwgAUHAjc4AQQwgAkEMakGIjc4AENATDAELIAIgAEEIajYCDCABQdyNzgBBESACQQxqQcyNzgAQ0BMLIAJBEGokAAuxAgIDfgh/QQICfwJAAkAgACgCTEUNACAAQdAAaiABEO4LIQIgACgCQCIGQUBqIQggACgCRCIHIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCABKAIIIQkgASgCBCEKQQAhAQNAIAUgBmopAAAiAyAEhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAKIAkgCCACeqdBA3YgBWogB3EiC0EGdGsiDCgCBCAMKAIIEOQcDQQgAkIBfSACgyICUEUNAAsLIAMgA0IBhoNCgIGChIiQoMCAf4NQRQ0BIAUgAUEIaiIBaiAHcSEFDAALAAsgAC0AKgwBCyAALQAqIAZBACALa0EGdGpBBmstAAAiACAAQQNGGwsiACAAQf8BcUEDRhsL2QIBAX8jAEEQayICJAACfwJAAkACQAJAAkACQAJAAkAgACgCAEEBaw4HAQIDBAUGBwALIAIgAEEEajYCDCABQdCFzwBBByACQQxqQcCFzwAQ0BMMBwsgAiAAQQRqNgIMIAFB14XPAEEDIAJBDGpBwIXPABDQEwwGCyACIABBBGo2AgwgAUHahc8AQQMgAkEMakHAhc8AENATDAULIAIgAEEEajYCDCABQd2FzwBBCiACQQxqQcCFzwAQ0BMMBAsgAiAAQQhqNgIMIAFBiIbPAEEPIABBBGpB6IXPACACQQxqQfiFzwAQgw8MAwsgAiAAQQRqNgIMIAFBqIbPAEEIIAJBDGpBmIbPABDQEwwCCyACIABBBGo2AgwgAUGwhs8AQQwgAkEMakH4hc8AENATDAELIAIgAEEIajYCDCABQcyGzwBBESACQQxqQbyGzwAQ0BMLIAJBEGokAAvZAgEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkACQCAAKAIAQQFrDgcBAgMEBQYHAAsgAiAAQQRqNgIMIAFB0MHPAEEHIAJBDGpBwMHPABDQEwwHCyACIABBBGo2AgwgAUHXwc8AQQMgAkEMakHAwc8AENATDAYLIAIgAEEEajYCDCABQdrBzwBBAyACQQxqQcDBzwAQ0BMMBQsgAiAAQQRqNgIMIAFB3cHPAEEKIAJBDGpBwMHPABDQEwwECyACIABBCGo2AgwgAUHnwc8AQQ8gAEEEakHYn88AIAJBDGpBhKDPABCDDwwDCyACIABBBGo2AgwgAUGIws8AQQggAkEMakH4wc8AENATDAILIAIgAEEEajYCDCABQZDCzwBBDCACQQxqQYSgzwAQ0BMMAQsgAiAAQQhqNgIMIAFBrMLPAEERIAJBDGpBnMLPABDQEwsgAkEQaiQAC60CAgJ/AX4gACgCDCEGAkAgASACaiIHIANBIGsiA00EQCACKQAAIQggBkEIaiACQQhqKQAANwAAIAYgCDcAACABQRFJDQEgACgCDEEQaiACQRBqIAFBEGsQ2BkMAQsCQCACIANLBEAgAiEDDAELIAYgAiADIAJrIgIQ2BkgAiAGaiEGCwNAIAMgB08NASAGIAMtAAA6AAAgBkEBaiEGIANBAWohAwwACwALIAAgACgCDCABajYCDAJAIAFB//8DTQRAIAAoAgQhAwwBCyAAQQE2AiQgACAAKAIEIgMgACgCAGtBA3U2AigLIAMgBDYCACADIAE7AQQgBUEDayIBQYCABE8EQCAAQQI2AiQgACADIAAoAgBrQQN1NgIoCyADIAE7AQYgACADQQhqNgIEC7ECAQF/IwBBgAFrIg4kACAOIAM2AnwCQAJAAkACQAJAAkAgAkEBaw4DAAMCAQsgBkUEQEG4fyEKDAULIAMgBS0AACICSQ0DIAIgCGotAAAhAyAAQQA6AAsgACADOgAKIABBADsBCCABIAA2AgAgByACQQJ0aigCACEBIABCADcCACAAIAE2AgxBASEKDAQLIAEgCTYCAEEAIQoMAwsgCkUNAUEAIQogC0UgDEEZSXINAkEIIAR0QQhyIQBBACEDA0AgACADTQ0DIANBQGshAwwACwALQWwhCiAOIA5B/ABqIA5B+ABqIAUgBhCCNyICQYh/Sw0BIA4oAngiAyAESw0BIAAgDiAOKAJ8IAcgCCADIA0Q5gggASAANgIAIAIhCgwBC0FsIQoLIA5BgAFqJAAgCguqAgIBfwR+IwBBkAFrIgYkACAGQRBqIAEpAwAiCEIAIABCAoYiAEIChCIHQgAQqB4gBkHgAGogASkDCCIKQgAgB0IAEKgeIAYgBikDGCIHIAYpA2B8IgkgBikDaCAHIAlWrXwgAkH/AHFBwABzIgEQxyMgAyAGKQMANwMAIAZBMGogCEIAIAAgBUF/c6x8IgdCABCoHiAGQfAAaiAKQgAgB0IAEKgeIAZBIGogBikDOCIHIAYpA3B8IgkgBikDeCAHIAlWrXwgARDHIyAEIAYpAyA3AwAgBkHQAGogCEIAIABCABCoHiAGQYABaiAKQgAgAEIAEKgeIAZBQGsgBikDWCIAIAYpA4ABfCIIIAYpA4gBIAAgCFatfCABEMcjIAYpA0AgBkGQAWokAAvQAgEEfyMAQSBrIgUkAEEBIQcCQCAALQAEDQAgAC0ABSEIIAAoAgAiBi0ACkGAAXFFBEAgBigCAEHP8YkBQczxiQEgCEEBcSIIG0ECQQMgCBsgBigCBCgCDBEGAA0BIAYoAgAgASACIAYoAgQoAgwRBgANASAGKAIAQZzxiQFBAiAGKAIEKAIMEQYADQEgAyAGIAQoAgwRAgAhBwwBCyAIQQFxRQRAIAYoAgBB0fGJAUEDIAYoAgQoAgwRBgANAQsgBUEBOgAPIAVBsPGJATYCFCAFIAYpAgA3AgAgBSAGKQIINwIYIAUgBUEPajYCCCAFIAU2AhAgBSABIAIQzAoNACAFQZzxiQFBAhDMCg0AIAMgBUEQaiAEKAIMEQIADQAgBSgCEEHU8YkBQQIgBSgCFCgCDBEGACEHCyAAQQE6AAUgACAHOgAEIAVBIGokACAAC2QBAX8CQAJAAkACQAJAQQsgACgCACIBQYCAgIB4cyABQQBOGw4QBAAEBAQEBAMEBAQBBAQEAgMLIABBBGoQvCoPCyAAEN47IABBDGoQuS4PCyAAQQRqEN47Cw8LIABBBGoQ3jsLkwIBBX8CQCABQRFJIANBDElyDQAgAEEGaiIHIAFBBmsgAiADQQNqQQJ2IgYgBBCtEiIFQYh/SwRAIAUPCyAFQYCABGtBgYB8SQ0AIAAgBTsAACAFIAdqIgUgACABaiIHIAVrIAIgBmoiCCAGIAQQrRIiAUGIf0sEQCABDwsgAUGAgARrQYGAfEkNACAAIAE7AAIgASAFaiIFIAcgBWsgBiAIaiIIIAYgBBCtEiIBQYh/SwRAIAEPCyABQYCABGtBgYB8SQ0AIAAgATsABCABIAVqIgUgByAFayAGIAhqIgEgAiADaiABayAEEK0SIgFBiH9LBEAgAQ8LIAFBgIAEa0GBgHxJDQAgASAFaiAAayEJCyAJC70CAgR/BH4jAEHgAGsiAiQAIAAoAgAhBCACQUBrIAAoAgQoAhAgAWotAAAQki0gAkEQaiIFIAIpA0AgAikDSCACKQNQIAIpA1ggBCgCACIDKQMAIAMpAwggAykDECADKQMYEJwGAkACQAJAIAIoAhAiA0EBRgRAIANFDQEgBUEEchCIEQwBCyACKQMgIgYgAikDKCIHIAIpAzAiCCACKQM4IgkgBCgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgMgAygCAEEBajYCACACQQhqIAAoAhQQhj0gAUEDdiIAIAIoAgwiA08NASACKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgAkHgAGokAA8LIAAgA0GIi/8AEMMhAAu9AgIEfwR+IwBB4ABrIgIkACAAKAIAIQQgAkFAayAAKAIEKAIQIAFqLQAAELQuIAJBEGoiBSACKQNAIAIpA0ggAikDUCACKQNYIAQoAgAiAykDACADKQMIIAMpAxAgAykDGBCcBgJAAkACQCACKAIQIgNBAUYEQCADRQ0BIAVBBHIQiBEMAQsgAikDICIGIAIpAygiByACKQMwIgggAikDOCIJIAQoAgQtAAAQ3B1FDQAgACgCCCABQQV0aiIAIAk3AxggACAINwMQIAAgBzcDCCAAIAY3AwAMAQsgACgCECIDIAMoAgBBAWo2AgAgAkEIaiAAKAIUEIY9IAFBA3YiACACKAIMIgNPDQEgAigCCCAAaiIAIAAtAABBfiABQQdxd3E6AAALIAJB4ABqJAAPCyAAIANBiIv/ABDDIQALtgMCCH8DfgJ/IAEoAhgEQANAAkAgASkDACIKUEUEQCABKAIQIQIMAQsgASgCECECIAEoAgghAwNAIAJBCGshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIKQoCBgoSIkKDAgH9RDQALIAEgAjYCECABIAM2AgggCkKAgYKEiJCgwIB/hSEKCyABIApCAX0gCoM3AwAgAiAKeqdBA3ZrIAEgASgCGEEBayIGNgIYQQFrIQMCQAJAIAEoAiAiAigCDEUNACACKAIAIgdBAWshCCACKAIEIgQgAkEQaiADEMMQIgqncSECIApCGYhC/wCDQoGChIiQoMCAAX4hDEEAIQUDQCACIAdqKQAAIgsgDIUiCkJ/hSAKQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgpQRQRAIAMtAAAhCQNAIAkgCCAKeqdBA3YgAmogBHFrLQAARg0EIApCAX0gCoMiClBFDQALCyALIAtCAYaDQoCBgoSIkKDAgH+DUEUNASACIAVBCGoiBWogBHEhAgwACwALIAMtAAAhAkEBDAMLIAYNAAsLQQALIQEgACACOgABIAAgAToAAAuQAQEBfwJAAkAgACgCACIBQZOAgIB4Rg0AAkACQAJAQQsgAUGAgICAeHMgAUEAThsOEAQABAQEBAQDBAQEAQQEBAIDCyAAQQRqELwqDwsgAEEBQQEQ4B4gAC0ADEEDRw0BIAAoAhAiABC8KiAAQQxBBBD4Og8LIABBBGpBAUEBEOAeCw8LIABBBGpBAUEBEOAeC7kDAgJ/AW8jAEFAaiICJAAgAiABNgIIIAJBGGogAkEIahCSHwJAAkACQCACAn4gAigCGCIBQYCAgIB4RwRAIAIpAhwMAQsgAkEIaiIBQQAgARCqOxsiAUUNASABKAIAJQEQTSEEEN8SIgEgBCYBIAIgATYCMCACQTRqIgEgAkEwahCSHyACQSRqIQMCQCABKAIAQYCAgIB4RwRAIAMgASkCADcCACADQQhqIAFBCGooAgA2AgAMAQtBoq2IAUExEJc9AAsgAigCMCIBQYQBTwRAIAEQ8h8LIAIoAiQiAUGAgICAeEYNASACKQIoCzcCEAwBCyACQTRqQQ1BAEEBQQEQoBggAigCOCEBIAIoAjRBAUYNASACKAI8IgNBBWpBhdnDACkAADcAACADQYDZwwApAAA3AAAgAkENNgIUIAIgAzYCEAsgAiABNgIMQQxBBBCtNiIBRQRAQQRBDBCjPQALIAEgAkEMaiIDKQIANwIAIAFBCGogA0EIaigCADYCACAAQSggAUGo28MAEMkpIAIoAggiAEGEAU8EQCAAEPIfCyACQUBrJAAPCyABIAIoAjxB8NjDABD9LwALwwIBBH8jAEHwAWsiAiQAIAJBsAFqIAEQwgYgAkEAOwHoASACQQA2AuQBIAJBADYCzAEgAkEANgLAASACQgQ3AqgBIAJCADcCoAEgAkKAgICAwAA3ApgBIAJBADYCkAEgAiABKAIQNgK8ASACQcwAaiIEIAJBkAFqIgMQ3wcCQCACKAJMQYCAgIB4RwRAIAJBCGoiBSAEQcQA/AoAACABQQA2AhAgAyAFEIYXQTxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgAUEIaiADQTT8CgAAIABB9MDNADYCCCAAIAE2AgQgAEEINgIAIAJB8AFqJAAPCyACQaABaiACQeAAaigCADYCACACQZgBaiACQdgAaikCADcDACACIAIpAlA3A5ABQaizzQBBKyACQZABakGIs80AQfDXzQAQ1R4AC0EEQTwQoz0AC7QCAgd/AX4jAEEgayIDJAAgAUEIaiEHIAJB/wFxQQFGIQgCQAJAAkACQANAIANBADYCDCADQQA2AhAgAyABKALkKiIENgIUIAEoAuAqIQUgA0EANgIYIAcgAiADQQxqQQFBACADQRBqIANBFGogBSAEIANBGGogARDPCSADKAIYIgQEQCABKALoKiIGRQ0CIAQgASgC5CoiCUsNBCAGIAEoAuAqIgYgBCAGahC9JgtFBEAgASkD0CohCiABQQQ6ANAqIApC/wGDQgRRDQMgACAKNwIADAULIAhFBEAgASgC8ClBAkcNASABKAKwKg0BIABBBDoAAAwFCyABKAKwKg0ACyAAQQQ6AAAMAwtBiPTNABCyOwALQaj0zQAQsjsACyAEIAlBmPTNABCwOwALIANBIGokAAufAgIEfwF+IwBBIGsiAiQAIAJBCGogARDEGSACLQAMIQMCQCACKAIIIgRBBEcEQCAAIAIpAA03AAUgAEEMaiACQRRqKQAANwAAIAAgAzoABCAAIAQ2AgAMAQsgAkEIaiADQQ9xEK4tIAItAAwhBCACKAIIIgVBBEcEQCAAIAIpAA03AAUgAEEMaiACQRRqKQAANwAAIAAgBDoABCAAIAU2AgAMAQsCQAJAIANBBHYiA0EPRw0AIAJBCGogAUEMahCNFCACLQAIQQRGBEAgAigCDCEDDAELIAIpAwgiBkL/AYNCBFINASAGQiCIpyEDCyAAIAM2AgggACAEOgAEIABBBDYCAAwBCyACIAY3AwggACACQQhqENAJCyACQSBqJAALnwICBH8BfiMAQSBrIgIkACACQQhqIAEQmxMgAi0ADCEDAkAgAigCCCIEQQRHBEAgACACKQANNwAFIABBDGogAkEUaikAADcAACAAIAM6AAQgACAENgIADAELIAJBCGogA0EPcRCuLSACLQAMIQQgAigCCCIFQQRHBEAgACACKQANNwAFIABBDGogAkEUaikAADcAACAAIAQ6AAQgACAFNgIADAELAkACQCADQQR2IgNBD0cNACACQQhqIAFBDGoQ/xMgAi0ACEEERgRAIAIoAgwhAwwBCyACKQMIIgZC/wGDQgRSDQEgBkIgiKchAwsgACADNgIIIAAgBDoABCAAQQQ2AgAMAQsgAiAGNwMIIAAgAkEIahDQCQsgAkEgaiQAC4ICAQZ/IAFBACADG0UEQCABQQBHDwsCQCACLAAAIgQgACwAACIGc0EASCABIANGIgUgBCAGR3FyRQRAIAUNASAGQQd1IQQCQCABIANLIglFBEAgAyABayEFIARB/wFxIQcgAiEEA0AgBUUNBCAFQQFrIQUgBC0AACEIIARBAWohBCAHIAhGDQALDAELIAEgA2shBSAEQf8BcSEHIAAhBANAIAVFDQMgBUEBayEFIAQtAAAhCCAEQQFqIQQgByAIRg0ACwsgCSAGQQBIcw8LIAQgBkgPCyAAQQFqIAJBAWogAUEBayIAIANBAWsiAiAAIAJJGxCZJyIAIAEgA2sgABtBAEoLxgICAn8BfiMAQSBrIgMkAAJAAkACQCACRQRAQcAAIQJBAEHAABDRNEUNAyABKAIALwEYIQFCAiEFDAILIAMgASgCACIBLwEYIgI7AQQgAkEBRwRAIANCADcCFCADQoGAgIDAADcCDCADQczN0AA2AgggA0EEakG4zNAAIANBCGpB1M3QABCHKwALIAMgAS8BGiICOwEGIAJFDQAgA0IANwIUIANCgYCAgMAANwIMIANB+MzQADYCCCADQQZqQbrM0AAgA0EIakGAzdAAEIcrAAtBACECQQBBwAAQ0TQEQEGAgICAeCEEQsAAIQUMAQsMAQsgAEEANgIkIAAgATsBICAAQgA3AhggACACNgIUIABCwAA3AgwgACAFNwIEIAAgBDYCACADQSBqJAAPC0GUn9AAQSkgA0EIakHUotAAQcCf0AAQ1R4AC6QCAQN/AkACQAJAAkAgBQRAIAMhBwNAIAQgBkYNAiAHQYACOwEAIAdBAmohByAFIAZBAWoiBkcNAAsLIAJFBEBBACEFDAQLQQAhBUEAIQYDQCABIAZGDQMgBCAAIAZqLQAAIgdNDQIgAyAHQQF0aiIHLwEAQYACRgRAIAcgBTsBACAFQQFqIQULIAIgBkEBaiIGRw0ACyAFQf//A3EhBUEAIQYDQCABIAZGBEAgASABQYCi1gAQwyEACyAAIAZqIggtAAAiByAETwRAIAcgBEGQotYAEMMhAAsgCCADIAdBAXRqLQAAOgAAIAZBAWoiBiACRw0ACwwDCyAEIARBwKLWABDDIQALIAcgBEGwotYAEMMhAAsgASABQaCi1gAQwyEACyAFC9QCAQJ/IAAgARCYPiECAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAgAxCWPiIAQdDzigEoAgBGBEAgAigCBEEDcUEDRw0BQcjzigEgATYCACAAIAEgAhCJLgwCCyAAIAMQqScLAkACQAJAIAIoAgQiA0ECcUUEQCACQdTzigEoAgBGDQIgAkHQ84oBKAIARg0DIAIgA0F4cSICEKknIAAgASACaiIBENA0IABB0POKASgCAEcNAUHI84oBIAE2AgAPCyAAIAEgAhCJLgsgACABEIocDwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBCAAQdDzigEoAgBHDQFByPOKAUEANgIAQdDzigFBADYCAA8LQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLC64CAgV/AX4jAEHQAGsiAyQAIABBGGoiBSAAKAIgIAJBCEEIQbCxgwEQwyggAyABQcAA/AoAACADQcQAaiADENUJAkACQCADKAJEQQFGBEADQCADKAJIIgIgAygCTCIGSQRAIAJBA3QhAQNAIAIgACgCDCIETw0EIAJBAWoiByAETw0FIAAgACkDACAAKAIIIAFqIgJBCGopAwAgAikDAH1C/////w+DfCIINwMAIAAoAiAiAiAAKAIYRgRAIAVBwLGDARCzKAsgACgCHCACQQN0aiAINwMAIAAgAkEBajYCICABQQhqIQEgByICIAZHDQALCyADQcQAaiADENUJIAMoAkQNAAsLIANB0ABqJAAPCyACIARBnLCDARDDIQALIAJBAWogBEGcsIMBEMMhAAvfAgEDfyMAQcACayICJAAgAkGYAWpBhIiQIDYCACACQoSIkKDAgIGCBDcCkAEgAkIENwKIASACQgA3AoABIAJCgICAgMAANwJ4IAJBADYCcCACQQA7AcgBIAJBADYCxAEgAkEANgKsASACQQA2AqABIAIgASgCCDYCnAEgAkGcAmogARDgLCACIAIpApwCNwK4AiACQQA2ArQCIAIgAigCqAIiAzYCsAIgAiACKAKkAjYCrAIgAkEIaiACQawCahDXOyACKAIIIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAqwCNwIIIAFBEGogAkG0AmopAgA3AgAgAUEYaiACQbwCaigCADYCACACIAM2AtQBIAIgBDYC0AEgAiABNgLMASACQRRqIgEgAkHwAGogAkHMAWoQ+iMgAkHYAWoiAyABEM0cIAAgAxCtEyACQcACaiQAC98CAQN/IwBBwAJrIgIkACACQZgBakGFipQoNgIAIAJChYqUqNCgwYIFNwKQASACQgQ3AogBIAJCADcCgAEgAkKAgICAwAA3AnggAkEANgJwIAJBADsByAEgAkEANgLEASACQQA2AqwBIAJBADYCoAEgAiABKAIINgKcASACQZwCaiABEN4sIAIgAikCnAI3ArgCIAJBADYCtAIgAiACKAKoAiIDNgKwAiACIAIoAqQCNgKsAiACQQhqIAJBrAJqENc7IAIoAgghBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCrAI3AgggAUEQaiACQbQCaikCADcCACABQRhqIAJBvAJqKAIANgIAIAIgAzYC1AEgAiAENgLQASACIAE2AswBIAJBFGoiASACQfAAaiACQcwBahD6IyACQdgBaiIDIAEQzRwgACADELETIAJBwAJqJAALkQIBBH8CQCABQc3/e0EQIAAgAEEQTRsiAGtPDQAgAEEQIAFBC2pBeHEgAUELSRsiBGpBDGoQrAEiAkUNACACEJo+IQECQCAAQQFrIgMgAnFFBEAgASEADAELIAIgA2pBACAAa3EQmj4hAiABKAIEIgVBeHEgAiAAQQAgAiABa0EQTRtqIgAgAWsiAmshAyAFQQNxBEAgACADEO4sIAEgAhDuLCABIAIQrg4MAQsgASgCACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAEQRBqTQ0AIAAgBBCYPiEBIAAgBBDuLCABIAIgBGsiBBDuLCABIAQQrg4LIAAQmT4hAwsgAwuoAgEFfyMAQRBrIgMkAAJ/IAAvAQAiAEHoB08EQCADIAAgAEGQzgBuIgRBkM4AbGsiAkH//wNxQeQAbiIFQQF0IgZB4/OJAWotAAA6AA0gAyAGQeLziQFqLQAAOgAMIAMgAiAFQeQAbGtB//8DcUEBdCICQePziQFqLQAAOgAPIAMgAkHi84kBai0AADoADkEBDAELIAAhBEEFIABBCkkNABogAyAAIABB5ABuIgRB5ABsa0H//wNxQQF0IgJB4/OJAWotAAA6AA8gAyACQeLziQFqLQAAOgAOQQMLIQJBACAAIAQbRQRAIAJBAWsiAiADQQtqaiAEQQF0QR5xQePziQFqLQAAOgAACyABQQFBAUEAIANBC2ogAmpBBSACaxCBCSADQRBqJAALnQIBBX8CQAJAAkACQCACQQNqQXxxIgQgAkYNACADIAQgAmsiBCADIARJGyIFRQ0AQQAhBCABQf8BcSEGQQEhBwNAIAIgBGotAAAgBkYNBCAFIARBAWoiBEcNAAsgBSADQQhrIghLDQIMAQsgA0EIayEIQQAhBQsgAUH/AXFBgYKECGwhBANAQYCChAggAiAFaiIHKAIAIARzIgZrIAZyQYCChAggB0EEaigCACAEcyIGayAGcnFBgIGChHhxQYCBgoR4Rw0BIAVBCGoiBSAITQ0ACwsgAyAFRwRAIAFB/wFxIQRBASEHA0AgBCACIAVqLQAARgRAIAUhBAwDCyADIAVBAWoiBUcNAAsLQQAhBwsgACAENgIEIAAgBzYCAAudAgEEfyAAKAIEIQcgACAAKAIAIgg2AgQgACACQf8BcSICNgIAIANFBEAgAEEBIAJBAmpBACACIAdHGyAIQQFqIAJGGyICai0AwAQgACACQQF0ajMBCCAEIAUgBhDlEgtBFEEOIAFB8AVLG0EHQQAgAUEoSxsgAUGwAUsbIgJBwgZqIQMgAkEDdEHc49EAaiEKIAJBAXQgAGpBjARqIQcCQANAIAchCCAKIQkgAyICQdsGRg0BIAJBAWohAyAIQQJqIQcgASAJQQhqIgooAgBPDQALIANBwwZrIgNBGkkNACADQRpBvOnRABDDIQALIAAgAmotAAAgCDMBACAEIAUgBhDlEiAJQQRqKAIAIAEgCSgCAGutIAQgBSAGEOUSC7MCAQN/IwBBMGsiAiQAIAAoAgAiAEEBIAAoAjQiAyADQQFNGzYCNCAAKAIIGiAAQTBqIgNBABCNNyAAKAIIIAAoAjBHIgQgBHJFBEADQCAAEPsWIAAoAgggACgCMEYNAAsLIANBARCNNyACQRBqIAAQ3DsgAigCFCEDIAIoAhAhBCACQQhqIAAoAjAQjDcgAiAEIAMgAigCCCACKAIMQazH/gAQ1yYgAigCBARAIAIoAgAgAToAACAAKAIwIQMgACgCFCIBIAAoAgxGBEAgAEEMakHExv4AEJsoCyAAKAIQIAFBA3RqIgRBBjsBBCAEIAM2AgAgACABQQFqNgIUIAJBMGokAA8LIAJBADYCKCACQQE2AhwgAkH0yP4ANgIYIAJCBDcCICACQRhqQbzH/gAQ7ywAC5ICAQZ/IABBFGoiAxDmOiAAKAIUBEAgACgCJEEBaiIEQQN2IARBB3FBAEdqIgIgACgCICIBSwRAIAIgAWshBSAAKAIYIgYgAkkEQCADIAZBAXQiASACEM0qIgMgASADSxsQ6BkgACgCICEBCyAFBEAgACgCHCABakEAIAX8CwALIAAgAjYCIAsgACAENgIkIAAoAhBBAWoiBEEDdiAEQQdxQQBHaiICIAAoAgwiAUsEQCACIAFrIQUgACgCBCIDIAJJBEAgACADQQF0IgEgAhDNKiIDIAEgA0sbEOgZIAAoAgwhAQsgBQRAIAAoAgggAWpBACAF/AsACyAAIAI2AgwLIAAgBDYCEA8LQejB/wAQsjsAC7YCAQR/IwBBIGsiByQAAkACQCABQdsAIAIoAhAiCRECAA0AIAMgBEkEQCAHQQhqIAUgAyABIAIgBigCDBEHACAHKAIIIghBlICAgHhHBEAgACAHKQIMNwIEIABBDGogB0EUaikCADcCAAwDCyADQQFqIQMLIAMgBEkEQCAGKAIMIQYgAigCFCEKA0AgB0EANgIYIAdBjJaBATYCCCAHQgQ3AhAgB0EBNgIMIAEgB0EIaiIIIAoRAgANAiAIIAUgAyABIAIgBhEHACAHKAIIIghBlICAgHhHBEAgACAHKQIMNwIEIABBDGogB0EUaikCADcCAAwECyAEIANBAWoiA0cNAAsLQZOAgIB4QZSAgIB4IAFB3QAgCRECABshCAwBC0GTgICAeCEICyAAIAg2AgAgB0EgaiQAC60CAgV/BH4jAEGgAWsiASQAIAFBCGoiAhDVEyAAIAEpA2g3A2AgAEHoAGogAUHwAGooAgA2AgAgACABKQJ0NwJsIABB9ABqIAFB/ABqKAIANgIAIAAgASkDSDcDQCAAQcgAaiABQdAAaikDADcDACAAQdAAaiABQdgAaikDADcDACAAQdgAaiABQeAAaikDADcDACABKQKMASEGIAEpApQBIQcgAS8BnAEhAyABLQCeASEEIABBgAFqIAFBiAFqKAIANgIAIAAgASkDgAE3A3ggASkDOCEIIAEpA0AhCSABLQCfASEFIAAgAkEw/AoAACAAIAU6AJcBIAAgBDoAlgEgACADOwGUASAAIAc3AowBIAAgBjcChAEgACAJNwM4IAAgCDcDMCABQaABaiQAC9cCAQF/IwBBMGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUH/AXEODQEAAAIDBAUGBwgJCgsACyACIAE6AA8gAkECNgIUIAJB8LPOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAsLIABBBDYCACAAQQA6AAQMCgsgAEEENgIAIABBAzoABAwJCyAAQQQ2AgAgAEEFOgAEDAgLIABBBDYCACAAQQY6AAQMBwsgAEEENgIAIABBBzoABAwGCyAAQQQ2AgAgAEEEOgAEDAULIABBBDYCACAAQQg6AAQMBAsgAEEENgIAIABBDToABAwDCyAAQQQ2AgAgAEEMOgAEDAILIABBBDYCACAAQQs6AAQMAQsgAEEENgIAIABBCjoABAsgAkEwaiQAC5UCAQJ/IwBBIGsiAiQAAkACQCABKAIAIgFBAE4EQCACQRRqQQpBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYNAiACQQA2AhAgAiACKAIcNgIMIAIgAzYCCAwBCyACQRRqQQtBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYNASACQQA2AhAgAiACKAIcNgIMIAIgAzYCCCACQQhqQQEQ5S0gAigCDCACKAIQakEtOgAAIAJBATYCEAsgAiABIAFBH3UiA3MgA2sgAkEUahCwECACQQhqIAIoAgAiASABIAIoAgRqEL0mIABBCGogAkEQaigCADYCACAAIAIpAgg3AgAgAkEgaiQADwsgAyACKAIcQfiezwAQ/S8AC6UCAQV/IwBBQGoiAiQAIAEoAghBAkYEQCACQQA2AjAgAkKAgICAwAA3AiggAkEANgI8IAJCgICAgMAANwI0IAJBCGogAUEIahCKJiACKAIMIgMEQCACKAIIIQQgA0ECdCEFQQAhAwNAIAJBADYCGCACQoCAgIDAADcCECAEIANBAEEAIAJBKGogAkE0aiACQRBqIgYQ0wogA0EBaiEDIARBBGohBCAGEOo7IAVBBGsiBQ0ACwsgACACKQIoNwIAIAAgAikCNDcCDCAAIAE2AhggAEEIaiACQTBqKAIANgIAIABBFGogAkE8aigCADYCACACQUBrJAAPCyACQQA2AiAgAkEBNgIUIAJB/LvPADYCECACQgQ3AhggAkEQakGEvM8AEO8sAAuIBwEKfyMAQdAAayIEJAAgBCADNwMIIAEoAmBBgICAgHhHBEACQCABLQBwBEAgASgCaCEGIAEoAmQhBSAEIAFBEGo2AkwgBCACNgJIIARBADYCQCAEIAU2AjggBCAFIAZBBnRqNgI8IAQgBEEIajYCRCAEQSBqIQgjAEHQAGsiBSQAIAVBCDYCCCAFQUBrIARBOGoiAkEQaikCADcDACAFQThqIAJBCGopAgA3AwAgBSACKQIANwMwIAUgBUEIajYCSCAFQSRqIQkjAEFAaiICJAAgAkEUaiAFQTBqIgYQqCUCQAJAAkAgAigCFEGAgICAeEcEQCACQSBqIgtBBEEAQQRBDBCgGCACKAIkIQcgAigCIEEBRg0CIAIoAigiCiACKQIUNwIAIApBCGogAkEcaigCADYCACACQRBqIgxBATYCACACIAo2AgwgAiAHNgIIIAJBOGogBkEYaigCADYCACACQTBqIAZBEGopAgA3AwAgAkEoaiAGQQhqKQIANwMAIAIgBikCADcDICMAQRBrIgYkACAGQQRqIAsQqCUgBigCBEGAgICAeEcEQCACQQhqIQcDQCAHKAIIIgogBygCAEYEQCAHIApBAUEEQQwQ0CgLIAcoAgQgCkEMbGoiDSAGKQIENwIAIA1BCGogBkEMaigCADYCACAHIApBAWo2AgggBkEEaiALEKglIAYoAgRBgICAgHhHDQALCyAGQRBqJAAgCUEIaiAMKAIANgIAIAkgAikCCDcCAAwBCyAJQQA2AgggCUKAgICAwAA3AgALIAJBQGskAAwBCyAHIAIoAihByJfPABD9LwALAkAgBSgCCEEIRwRAIAggBSkDCDcDACAIQRBqIAVBGGopAwA3AwAgCEEIaiAFQRBqKQMANwMAIAkQxiogCUEEQQwQ4B4MAQsgCCAFKQIkNwIEIAhBCDYCACAIQQxqIAVBLGooAgA2AgALIAVB0ABqJAAgBEEYaiICIARBLGooAgA2AgAgBCAEKQIkNwMQIAQoAiAiBUEIRwRAIAQpAzAhAyAAIAQpAxA3AgQgACADNwMQIAAgBTYCACAAQQxqIAIoAgA2AgAMAgsgBEFAayIFIAIoAgA2AgAgBCAEKQMQNwM4IAFByABqELgvIAFB0ABqIAUoAgA2AgAgASAEKQM4NwJICyAAQQg2AgALIARB0ABqJAAPC0H49M8AELI7AAulAgEBfyMAQSBrIgMkACADIAI2AgQgAkGAAkYEQCAAIAFBEGoiAS8BADsBACAAIAFB4ANqLwEAOwEeIAAgAUHAA2ovAQA7ARwgACABQaADai8BADsBGiAAIAFBgANqLwEAOwEYIAAgAUHgAmovAQA7ARYgACABQcACai8BADsBFCAAIAFBoAJqLwEAOwESIAAgAUGAAmovAQA7ARAgACABQeABai8BADsBDiAAIAFBwAFqLwEAOwEMIAAgAUGgAWovAQA7AQogACABQYABai8BADsBCCAAIAFB4ABqLwEAOwEGIAAgAUFAay8BADsBBCAAIAFBIGovAQA7AQIgA0EgaiQADwsgA0EANgIIQQAgA0EEakG88dEAIANBCGpB8PTRABCvKwAL1wIBAX8jAEEwayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcQ4NAQAAAgMEBQYHCAkKCwALIAIgAToADyACQQI2AhQgAkHspP4ANgIQIAJCATcCHCACQbsHNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBAToAECAAQQE2AgAMCwsgAEEENgIAIABBADoABAwKCyAAQQQ2AgAgAEEDOgAEDAkLIABBBDYCACAAQQU6AAQMCAsgAEEENgIAIABBBjoABAwHCyAAQQQ2AgAgAEEHOgAEDAYLIABBBDYCACAAQQQ6AAQMBQsgAEEENgIAIABBCDoABAwECyAAQQQ2AgAgAEENOgAEDAMLIABBBDYCACAAQQw6AAQMAgsgAEEENgIAIABBCzoABAwBCyAAQQQ2AgAgAEEKOgAECyACQTBqJAALtAICBH8EfiMAQUBqIgMkACADQRBqIgQgACgCBCgCECABQQV0aiICKQMAIAIpAwggAikDECACKQMYIAAoAgAiBSgCACgCACICKQMAIAIpAwggAikDECACKQMYEJwGAkACQAJAIAMoAhAiAkEBRgRAIAJFDQEgBEEEchCIEQwBCyADKQMgIgYgAykDKCIHIAMpAzAiCCADKQM4IgkgBSgCBC0AABDcHUUNACAAKAIIIAFBBXRqIgAgCTcDGCAAIAg3AxAgACAHNwMIIAAgBjcDAAwBCyAAKAIQIgIgAigCAEEBajYCACADQQhqIAAoAhQQhj0gAUEDdiIAIAMoAgwiAk8NASADKAIIIABqIgAgAC0AAEF+IAFBB3F3cToAAAsgA0FAayQADwsgACACQYiL/wAQwyEAC4sCAQN/IwBBEGsiAiQAAkAgAUKAAVQNACAAQQhqIQQDQAJAIAIgAadBgAFyOgAHIAAtABQhAyACIAApAwA3AwggA0EDdiADQQdxQQBHaiIDQQlPDQAgBCACQQhqIAMQoTYgAEEAOgAUIABCADcDACAEIAJBB2pBARChNiABQoCAAVQgAUIHiCEBRQ0BDAILCyADQQhB6I7OABCwOwALIAIgATwAByAALQAUIQQgAiAAKQMANwMIIARBA3YgBEEHcUEAR2oiBEEJSQRAIABBCGoiAyACQQhqIAQQoTYgAEEAOgAUIABCADcDACADIAJBB2pBARChNiACQRBqJAAPCyAEQQhB6I7OABCwOwALpgICA34IfwJ/AkACQCAAKAJMRQ0AIABB0ABqIAEQ7gshAiAAKAJAIgZBQGohCCAAKAJEIgcgAqdxIQUgAkIZiEL/AINCgYKEiJCgwIABfiEEIAEoAgghCSABKAIEIQpBACEBA0AgBSAGaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAogCSAIIAJ6p0EDdiAFaiAHcSILQQZ0ayIMKAIEIAwoAggQ5BwNBCACQgF9IAKDIgJQRQ0ACwsgAyADQgGGg0KAgYKEiJCgwIB/g1BFDQEgBSABQQhqIgFqIAdxIQUMAAsACyAALQApDAELIAAtACkgBkEAIAtrQQZ0akEHay0AACIAIABBAkYbC0EBcQu6AgECfwJAAkACQAJAAkAgACAAKAKMByIJBH8gCQUgACAAKAKIB0EBaiIJNgKIByAJIAAoAgwiCk8NASAJIAAoAgQiCk8NAiAAKAIAIAlqLQAAIQogACAAKAIIIAlBAnRqKAIAIgk2AowHIAAgCiAIdDYCkAcgAEEsaiAJIApBACAFIAYgBxCeEiAAKAKMBwtBAWs2AowHIAAoApAHIAJqIgIgBE8NAiAAKAIgIAMgAkECdGooAgBsIAFqIgEgACgCFCICTw0DIAEgACgCHCICSQ0EIAEgAkHUrNAAEMMhAAsgCSAKQZSs0AAQwyEACyAJIApBpKzQABDDIQALIAIgBEG0rNAAEMMhAAsgASACQcSs0AAQwyEACyAAKAIQIAFqLQAAIAAoAhggAUEBdGozAQAgBSAGIAcQ5RILpAIBAn8jAEEgayIFJAACf0EAIAFBCEkNABogBEEEaiEGIAQoAgAhBCAFQQhqQgA3AwAgBUIANwMAIAUgADYCFCAFIAA2AhAgBSAAIAFqQQRrNgIYAkAgBEEMSSADIARsQQN2QQhqIAFNcUUEQCAFIAIgAyAGQQJBAEEAEPIMDAELAkACQAJAIARBCGsOBAEBAQACCyAFIAIgAyAGQQJBAUEAEPIMDAILIAUgAiADIAZBAkEBQQEQ8gwMAQsgBSACIAMgBkEDQQFBARDyDAsgBSAFKAIIQf////8HazYCCCAFIAUoAgBBAXZBgICAgHhyNgIAIAVBABCtJUEAIAUoAhQiACAFKAIYTw0AGiAAIAUoAhBrIAUtAAhBAEdqCyAFQSBqJAALjwYBDX8jAEEgayIFJAAgBSABEMUbAkACQAJAIAIoAigiAyACKAIkIgZqQQFqIgIgA08EQCACIAUoAgQiBEsNASACIANGDQIgBSgCACIERQ0CIAQgAkEDdGoiAkEIayILRQ0DAkAgBCADQQN0IgNqIgkoAgBFBEAgBUEIaiABIAMgBkEDdEEIahDmFQwBCyAFIAk2AhwgBSACNgIYIAUgCTYCFCMAQUBqIgEkACMAQSBrIgIkACACQRRqIAVBFGoiAygCBCADKAIAa0EDdkEAQQhBCBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEG4+/4AEP0vAAsgAUEQaiEKIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIGIAMoAgQgAygCAGtBA3YQ7C0gBCAGKQIEQiCJNwIIIAQgBkEIajYCBCAEQQRqIgcoAgQhBiAHKAIAIAMoAgAiCCADKAIEIg5HBEAgAygCCCEPIAcoAgggBkEDdGohAyAGIA4gCGtBA3YiB2ohBgNAIAMgCCkDACAPKQMAfTcDACAIQQhqIQggA0EIaiEDIAdBAWsiBw0ACwsgBjYCACAEQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgAUEcaiAKEN4sIAEgASkCHDcCOCABQQA2AjQgASABKAIoIgQ2AjAgASABKAIkNgIsIAFBCGogAUEsahDXOyABKAIIIQZBHEEEEK02IgJFBEBBBEEcEKM9AAsgAkKBgICAEDcCACACIAEpAiw3AgggBUEIaiIDIAQ2AgggAyAGNgIEIAMgAjYCACACQRBqIAFBNGopAgA3AgAgAkEYaiABQTxqKAIANgIAIAFBQGskAAsgCygCACECIAkoAgAhASAAIAUpAgg3AgAgACABNgIMIABBCGogBUEQaigCADYCACAAIAIgAWs2AhAgBUEgaiQADwsgAyACQZDR/gAQsTsACyACIARBkNH+ABCwOwALQaDR/gAQsjsAC0Gw0f4AELI7AAuPBgENfyMAQSBrIgUkACAFIAEQxxsCQAJAAkAgAigCKCIDIAIoAiQiBmpBAWoiAiADTwRAIAIgBSgCBCIESw0BIAIgA0YNAiAFKAIAIgRFDQIgBCACQQJ0aiICQQRrIgtFDQMCQCAEIANBAnQiA2oiCSgCAEUEQCAFQQhqIAEgAyAGQQJ0QQRqEOYVDAELIAUgCTYCHCAFIAI2AhggBSAJNgIUIwBBQGoiASQAIwBBIGsiAiQAIAJBFGogBUEUaiIDKAIEIAMoAgBrQQJ2QQBBBEEEEKAYIAIoAhghBCACKAIUQQFGBEAgBCACKAIcQbj7/gAQ/S8ACyABQRBqIQogAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgYgAygCBCADKAIAa0ECdhDuLSAEIAYpAgRCIIk3AgggBCAGQQhqNgIEIARBBGoiBygCBCEGIAcoAgAgAygCACIIIAMoAgQiDkcEQCADKAIIIQ8gBygCCCAGQQJ0aiEDIAYgDiAIa0ECdiIHaiEGA0AgAyAIKAIAIA8oAgBrNgIAIAhBBGohCCADQQRqIQMgB0EBayIHDQALCyAGNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACABQRxqIAoQ4CwgASABKQIcNwI4IAFBADYCNCABIAEoAigiBDYCMCABIAEoAiQ2AiwgAUEIaiABQSxqENc7IAEoAgghBkEcQQQQrTYiAkUEQEEEQRwQoz0ACyACQoGAgIAQNwIAIAIgASkCLDcCCCAFQQhqIgMgBDYCCCADIAY2AgQgAyACNgIAIAJBEGogAUE0aikCADcCACACQRhqIAFBPGooAgA2AgAgAUFAayQACyALKAIAIQIgCSgCACEBIAAgBSkCCDcCACAAIAE2AgwgAEEIaiAFQRBqKAIANgIAIAAgAiABazYCECAFQSBqJAAPCyADIAJBkNH+ABCxOwALIAIgBEGQ0f4AELA7AAtBoNH+ABCyOwALQbDR/gAQsjsAC6wCAgJ/AnwjAEEgayIFJAAgA7ohByAAAn8CQAJAAkACQCAEIARBH3UiBnMgBmsiBkG1Ak8EQANAIAdEAAAAAAAAAABhDQUgBEEATg0CIAdEoMjrhfPM4X+jIQcgBEG0AmoiBCAEQR91IgZzIAZrIgZBtAJLDQALCyAGQQN0QYiyiAFqKwMAIQggBEEATg0BIAcgCKMhBwwDCyAFQQ42AhQgBSABQQxqIAEoAhQQ6gwgACAFQRRqIAUoAgAgBSgCBBD7KDYCBAwBCyAHIAiiIgeZRAAAAAAAAPB/Yg0BIAVBDjYCFCAFQQhqIAFBDGogASgCFBDqDCAAIAVBFGogBSgCCCAFKAIMEPsoNgIEC0EBDAELIAAgByAHmiACGzkDCEEACzYCACAFQSBqJAALgQICBH8BfiMAQSBrIgYkAAJAIAVFDQAgAiADaiIDIAJJDQAgBCAFakEBa0EAIARrca0gAyABKAIAIghBAXQiAiACIANJGyICQQhBBEEBIAVBgQhJGyAFQQFGGyIDIAIgA0sbIgOtfiIKQiCIpw0AIAqnIglBgICAgHggBGtLDQAgBiAIBH8gBiAFIAhsNgIcIAYgASgCBDYCFCAEBSAHCzYCGCAGQQhqIAQgCSAGQRRqEL4aIAYoAghBAUYEQCAGKAIQIQIgBigCDCEHDAELIAYoAgwhBCABIAM2AgAgASAENgIEQYGAgIB4IQcLIAAgAjYCBCAAIAc2AgAgBkEgaiQAC6kCAgN/An4jAEGgAWsiASQAIAFBCGoiAxDVEyAAIAEpA2g3A2AgAEHoAGogAUHwAGooAgA2AgAgACABKQJ0NwJsIABB9ABqIAFB/ABqKAIANgIAIAAgASkDSDcDQCAAQcgAaiABQdAAaikDADcDACAAQdAAaiABQdgAaikDADcDACAAQdgAaiABQeAAaikDADcDACABLQCeASECIAEpAowBIQQgASkClAEhBSAAIAEvAZwBOwGUASAAIAU3AowBIAAgBDcChAEgACACOgCWASAAQYABaiABQYgBaigCADYCACAAIAEpA4ABNwN4IAEpAzghBCABKQNAIQUgAS0AnwEhAiAAIANBMPwKAAAgACACOgCXASAAIAU3AzggACAENwMwIAFBoAFqJAALoAIBAX8CQAJAAkACQEECIAAoAmAiAUGAgICAeHMgAUEAThsOAgECAAsgAEHgAGoQ3jsgAEHsAGoQ3jsgAEH4AGoQ3SkgAEH8AGoQ3SkMAgsgAEHkAGoQ3jsMAQsgAEHkAGoQ3jsgAEHwAGoQ3SkLIAAoAgBBgICAgHhHBEAgAEEYakEIEO4oIAAQ3jsgAEEMakEEQQgQ4B4gAEHQAGoQ4zwLAkAgACgCnAFFDQAgACgCoAEiAUUNACAAQawBaiAAKAKkASAAKAKoASABKAIQEQEACwJAIAAoArABRQ0AIAAoArQBIgFFDQAgAEHAAWogACgCuAEgACgCvAEgASgCEBEBAAsgACgCkAFBgICAgHhHBEAgAEGQAWpBBEEgEOAeCwuWAgIDfwF+IAApAxAhBCAAKAIYIQEgAEEcaiEDIAAoAiwiAkERSQRAAn8gBEIQWgRAIAAoAgRBB3cgACgCAEEBd2ogACgCCEEMd2ogACgCDEESd2oMAQsgAUGxz9myAWoLIASnaiEBAkAgAkEESQRAIAMhAAwBCwNAIAMoAABBvdzKlXxsIAFqQRF3Qa/W074CbCEBIANBBGoiACEDIAJBBGsiAkEDSw0ACwsgAgRAA0AgAC0AABDUPUGxz9myAWwgAWpBC3dBsfPd8XlsIQEgAEEBaiEAIAJBAWsiAg0ACwsgAUEPdiABc0H3lK+veGwiAEENdiAAc0G93MqVfGwiAEEQdiAAc60PCyACQRBBpMnQABCwOwALkgQCA38BfiMAQSBrIggkAAJAAkACQCAGQf8BcUECRwRAIAggBjoACyAIQQxqIQYgCEELaiEJIwBBEGsiASQAAkACQAJAIAIEQCABIAI2AgQgBCABQQRqIgJBBBChNgJAAkAgCS0AAEEBRgRAQS4hCSACQS5BAEEBQQEQoBggASgCCCECIAEoAgRBAUYNBSABKAIMIgpByvr+AEEu/AoAAAwBC0EsIQkgAUEEakEsQQBBAUEBEKAYIAEoAgghAiABKAIEQQFGDQEgASgCDCIKQfD5/gBBLPwKAAALIAYgCTYCDCAGIAo2AgggBiACNgIEIAZBjYCAgHg2AgAMAgsMAgsgBkKTgICACDcCAAsgAUEQaiQADAELIAIgASgCDEHo+P4AEP0vAAsgCCgCECECIAgoAgwiAUGTgICAeEYNASAAIAgpAhQ3AgwgAEEUaiAIQRxqKAIANgIAIAAgAjYCCCAAIAE2AgQgAEEBNgIADAILIAQgASACEKE2CyADKAIIIgEgAygCAEYEQCADQZzU/gAQrigLIAMoAgQgAUEEdGoiBiACrSILNwAIIAYgBTcAACADIAFBAWo2AgggAiAHQQFrQf8BcSIBaiABQX9zcSACayIBQcEATw0BIARB/Mz+ACABEKE2IABBADYCACAAIAGtIAUgC3x8NwMICyAIQSBqJAAPCyABQcAAQazU/gAQsDsAC7cCAgJ/AX4jAEEgayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQMhAQwBCwJAIAEoAgRFDQAgBCABKAIUTw0CIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAhAQwBCyABIARBAWo2AhwgAiABKAIAIAQQjywgAkEMaiACKAIAIAIoAgQQsQxBACEBAkACQCACKAIMIgVB7f///wdqDgIAAgELIAIoAhAhBEEBIQEMAQsgAikCGCEGIAIoAhQhASACKAIQIQQgAygCAEGTgICAeEcEQCADEIgRCyADIAY3AgwgAyABNgIIIAMgBDYCBCADIAU2AgBBAiEBCyAAIAQ2AgQgACABNgIAIAJBIGokAA8LQfSngAFBIEGUqIABEJ8pAAu3AgICfwF+IwBBIGsiAiQAAkACQCABKAIcIgQgASgCIEYEQEEDIQEMAQsCQCABKAIERQ0AIAQgASgCFE8NAiABKAIIIAEoAhAgBGoiBUEDdmotAABB/wFzIAVBB3F2QQFxRQ0AIAEgBEEBajYCHEEAIQEMAQsgASAEQQFqNgIcIAIgASgCACAEENorIAJBDGogAigCACACKAIEELEMQQAhAQJAAkAgAigCDCIFQe3///8Hag4CAAIBCyACKAIQIQRBASEBDAELIAIpAhghBiACKAIUIQEgAigCECEEIAMoAgBBk4CAgHhHBEAgAxCIEQsgAyAGNwIMIAMgATYCCCADIAQ2AgQgAyAFNgIAQQIhAQsgACAENgIEIAAgATYCACACQSBqJAAPC0H0p4ABQSBBlKiAARCfKQALjgQDBH8BfgFvIwBBIGsiAiQAIAIgATYCCAJAIAJBCGooAgAlARBuBEAgAiABNgIMIwBBEGsiAyQAIAMgAkEMaiIFKAIAJQEQcyACQRBqIgQgAygCAAR+IAQgAykDCDcDCEIBBUIACzcDACADQRBqJABBASEDAkACQCACKAIQQQFHDQAgAikDGCIGEHwhBxDfEiIBIAcmASACIAE2AhAgBSgCACUBIAQoAgAlARB2QQBHIAFBhAFPBEAgARDyHwsgAigCDCEBRQ0AIAFBhAFPBEAgARDyHwsgBkKAgICAEFoNASAGpyEEQQAhAwwDC0G0ycMAQcgAENwbIQQgAUGEAUkNAiABEPIfDAILIAJBAToAECACIAY3AxggAkEQaiACQQxqENEiIQQMAQsjAEEwayIDJAAgA0EIaiIBIAJBCGoiBSgCACUBEEsEfiABIAUoAgAlARBp/AY3AwhCAQVCAAs3AwBBASEEIAICfwJAIAMoAghBAUYEQCADKQMQIgZCAFkNAQsgBSADQS9qQYDGwwAQ0QsMAQsgBkKAgICAEFQEQEEAIQQgBqcMAQsgA0EBOgAYIAMgBjcDICADQRhqIANBL2oQ0SILNgIEIAIgBDYCACADQTBqJAAgAigCBCEEIAIoAgAhAyACKAIIIgFBhAFJDQAgARDyHwsgACAENgIEIAAgAzYCACACQSBqJAAL/wEBB38jAEEgayIEJAACQAJAIAJFBEAMAQsgA0UNACABKAJIIQUgASgCRCEIA0AgBSAIRgRAIARBCGogARDyGyAEKAIIIgVBCEcEQCAAIAQpAgw3AgQgAEEUaiAEQRxqKAIANgIAIABBDGogBEEUaikCADcCAAwECyABKAJEIghFDQIgASgCSCEFCyAEQQhqIAEgAiAHayADIAZrEOoTIAQoAgghCiAEKAIQIQkgASAELQAMOgBMIAEgBSAJaiIFNgJIIAYgCWohBiAHIApqIgcgAk8NASADIAZLDQALCyAAIAY2AgggACAHNgIEQQghBQsgACAFNgIAIARBIGokAAvxAQEDfyAAKAJAQQJHBEAgACgCGEEBaiIDZyECIAACfyABBEBBHyACayICQQh0IANBCHQgAnZqDAELQYA+IAJBCHRrCzYCKAsgACgCHEEBaiIDZyECAn8gAQRAQR8gAmsiAUEIdCADQQh0IAF2aiEBQR8gACgCJEEBaiICZ2siA0EIdCACQQh0IAN2aiECQR8gACgCIEEBaiIDZ2siBEEIdCADQQh0IAR2agwBC0GAPiACQQh0ayEBQYA+IAAoAiRBAWpnQQh0ayECQYA+IAAoAiBBAWpnQQh0awshAyAAIAI2AjQgACADNgIwIAAgATYCLAuZAgIDfwJ+IwBBIGsiAyQAIAJBAWsiBEH//wNxEMoqQf8BcSICQR5JBEAgAUH/AXFBAnQiBUGO5vsAai8BACEBIAVBjOb7AGozAQAhByACQQJ0QYzu+wBqMwEAIQYgAkGw2/sAai0AACIFBH8gBCACQQF0Qc7b+wBqLwEAa61C//8Dg0IFhiAGhCEGIAVBBWoFQQULIQIgBiABQT9xrYYgB4QhBgJAIAAtABgiBCABIAJqaiIBQf8BcUHAAE8EQCAAIAYgARDwEAwBCyAAIAE6ABggACAAKQMQIAYgBK2GhDcDEAsgA0EgaiQADwsgA0EANgIYIANBATYCDCADQZjb+wA2AgggA0IENwIQIANBCGpBoNv7ABDvLAALkgICBH8BfiAAIAEgAhChNgJAIAAoAhgEQCAAKAIoIgRBAWoiBUEDdiAFQQdxQQBHaiIBIAAoAiQiAksEQCABIAJrIQYgACgCHCIDIAFJBEAgAEEYaiADQQF0IgIgAUHA////A3FBQGsgASABQT9xGyIDIAIgA0sbEOgZIAAoAiQhAgsgBgRAIAAoAiAgAmpBACAG/AsACyAAIAE2AiQLIAAgBTYCKCAAKAIgIARBA3ZqIgEgAS0AAEEBIARBB3F0cjoAAAwBCyAAIAAoAixBAWo2AiwLIAA1AgghByAAKAIUIgEgACgCDEYEQCAAQQxqQeD0/wAQsygLIAAoAhAgAUEDdGogBzcDACAAIAFBAWo2AhQLkAIBBH8gACABIAIQoTYCQCAAKAIYBEAgACgCKCIEQQFqIgVBA3YgBUEHcUEAR2oiASAAKAIkIgJLBEAgASACayEGIAAoAhwiAyABSQRAIABBGGogA0EBdCICIAFBwP///wNxQUBrIAEgAUE/cRsiAyACIANLGxDoGSAAKAIkIQILIAYEQCAAKAIgIAJqQQAgBvwLAAsgACABNgIkCyAAIAU2AiggACgCICAEQQN2aiIBIAEtAABBASAEQQdxdHI6AAAMAQsgACAAKAIsQQFqNgIsCyAAKAIIIQIgACgCFCIBIAAoAgxGBEAgAEEMakHg9P8AEJ0oCyAAKAIQIAFBAnRqIAI2AgAgACABQQFqNgIUC7QCAgJ/AX4jAEEgayICJAACQAJAIAEoAhwiBCABKAIgRgRAQQMhAQwBCwJAIAEoAgRFDQAgBCABKAIUTw0CIAEoAgggASgCECAEaiIFQQN2ai0AAEH/AXMgBUEHcXZBAXFFDQAgASAEQQFqNgIcQQAhAQwBCyABIARBAWo2AhwgAiABIAQQrSogAkEMaiACKAIAIAIoAgQQsQxBACEBAkACQCACKAIMIgVB7f///wdqDgIAAgELIAIoAhAhBEEBIQEMAQsgAikCGCEGIAIoAhQhASACKAIQIQQgAygCAEGTgICAeEcEQCADEIgRCyADIAY3AgwgAyABNgIIIAMgBDYCBCADIAU2AgBBAiEBCyAAIAQ2AgQgACABNgIAIAJBIGokAA8LQfSngAFBIEGUqIABEJ8pAAuyAgICfwF+IwBBMGsiAyQAAkAgAkELTwRAIANBGGoiBEEBIAEgAhCCAwJAAkAgAygCGEGTgICAeEcEQCAEEIgRDAELIAMoAhwiAQ0BCyAAQgA3AwAMAgsgAykCICEFIAMgATYCGCADQRhqENEfIQEgAEIBNwMAIAAgBUIgiKdBwIQ9bq0gAaxCgKMFfiAFQv////8Pg3xC6Ad+fEKA6My6sZAOfTcDCAwBCyABIAIQxQIiAQRAIANCADcDACADIAE2AgwgAyADKQMANwIQIANBGGogA0EMahDKLyADIAMoAhg2AiwgA0EsahDRHyEBIABCATcDACAAIAMoAiBBwIQ9bq0gAzUCHCABrEKAowV+fELoB358QoDozLqxkA59NwMIDAELIABCADcDAAsgA0EwaiQAC6oCAQd/IwBBMGsiAiQAIAEoAgQhBCABKAIAIQcCQAJAIAAoAgAiAyAAKAIEIgVHBEAgASgCCCEIIAUgA2tBA3YhASAAKAIIIQUDQCADKAIAIgAgBSgCCCIGTw0CIAUoAgQgAEECdGooAgAhACACIANBBGooAgAiBjYCACAGIABBDGooAghPDQMgBCAIaiAAKAIQIAZqLQAAOgAAIANBCGohAyAEQQFqIQQgAUEBayIBDQALCyAHIAQ2AgAgAkEwaiQADwsgACAGQfy0ggEQwyEACyACIAAQozw2AhwgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywAC4wCAQF/IwBBEGsiAiQAIAAoAgAhAAJ/IAEtAAtBGHFFBEAgASgCACAAIAEoAgQoAhARAgAMAQsgAkEANgIMIAEgAkEMagJ/AkAgAEGAAU8EQCAAQYAQSQ0BIABBgIAETwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfABcjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAOIAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoADUEDDAILIAIgADoADEEBDAELIAIgAEE/cUGAAXI6AA0gAiAAQQZ2QcABcjoADEECCxDWCQsgAkEQaiQAC4kCAQR/IwBBEGsiAkEANgIMAn8CQCABQYABTwRAIAFBgBBJDQEgAUGAgARPBEAgAiABQT9xQYABcjoADyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAMLIAIgAUE/cUGAAXI6AA4gAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANQQMMAgsgAiABOgAMQQEMAQsgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQILIgEgACgCACIDaiIEIANJIARBD0tyIgVFBEAgAQRAIAAgA2pBBGogAkEMaiAB/AoAAAsgACAENgIACyAFC7oCAgN/AX4jAEEwayIDJAACQCABAn8CQAJAAkACQAJAIAEtAERBAWsOAwMAAgELAAsgA0EIaiIEIAFBQGsoAgA2AgAgAyABKQI4NwMAIAEoAjQhBSADQQxqIAEpAwAiBiABKQMIIAZ9ENgfIAFBADoAMCABIAU2AiggAUEgaiADQRBqKQMANwIAIAFBGGogBCkDADcCACABIAMpAwA3AhALIANBHGogAUEQaiIFIAIQsQ4gAygCHEUNASAAQQk2AgBBAwwCC0GM9MIAEOgrAAsgAykCKCEGIAMoAiQhAiADKAIgIQQgBRCgJSAERQ0BIAAgBjcCDCAAIAI2AgggACAENgIEIABBCDYCAEEBCzoARCADQTBqJAAPCyADIAI2AhxBnODCAEErIANBHGpB2ODCAEGc9MIAENUeAAuLAgICfwF+AkAgAUEfcSIJQRhNBEACQCAEIAlJDQAgACgCBCAJQQJ0aigCACAJIAFBBXYiBGxqIgFBob8HTw0CIAIgAyAAKAIIIAFqQaC/ByABayAJELIgIgFFIAFBCmogCU1yDQAgBCAFakKA5LTRrcHUjQcgCSABa60iC0IGfohCP4MgC0IChnynIAAoAgAgCWotAAB0akEBaiIAIAZLDQAgASAHQQJ2bK0gAGdBIGpBP3NBHmytfUKAD3wiCyAIKQMAVA0AIAggADYCECAIIAE2AgggCCALNwMAIAggASAJczYCDEEBIQoLIAoPCyAJQRlB+JrSABDDIQALIAFBoL8HQYib0gAQrzsAC4wCAQV/IwBBEGsiACQAAkAgASgCLARAIAFBLGohByABKAJMIgIgA2oiBEEDdiAEQQdxQQBHaiIEIAEoAjgiBUsEQCAEIAVrIQggASgCMCIGIARJBEAgByAGQQF0IgUgBBDcKiIGIAUgBksbEOgZIAEoAjghBQsgCARAIAEoAjQgBWpBACAI/AsACyABIAQ2AjgLIABBCGogBxCGPSADBEAgACgCDCEBIAAoAgghBQNAIAJBA3YiBCABTw0DIAQgBWoiBCAELQAAQQEgAkEHcXRyOgAAIAJBAWohAiADQQFrIgMNAAsLIABBEGokAA8LQcyPhwFBHUHsj4cBEMskAAsgBCABQYyLhwEQwyEAC5kCAQN/IwBBEGsiBCQAAkACQCABKAIIQQFGBEAgASgCACEFIAEoAgQhBiABQQxBBBD4OiAEQQhqIgEgBjYCACAEIAIgBWsiAiADajYCBCAEIAU2AgAgBEEHQSAgBkEKdmdrIgMgA0EHTxtBAnRBAXI2AgwgBCACEKceIABBCGogASkCADcCACAAIAQpAgA3AgAMAQsgBCADQQBBAUEBEKAYIAQoAgQhBSAEKAIAQQFGDQEgBCgCCCEGIAMEQCAGIAIgA/wKAAALIAEQlC0gACAFNgIIIAAgAzYCBCAAIAY2AgAgAEEHQSAgBUEKdmdrIgAgAEEHTxtBAnRBAXI2AgwLIARBEGokAA8LIAUgBCgCCEHAhYgBEP0vAAvVAwIGfwFvIwBBIGsiAiQAEEIhCBDfEiIHIAgmASACIAc2AhQjAEEQayIDJAAgASgCACUBIAJBFGooAgAlARBiIQgQ3xIiBCAIJgEgBCEFIANBCGoQzi1BASEEIAJBCGoiBgJ/IAMoAghBAXEEQCADKAIMDAELQQAhBCAFCzYCBCAGIAQ2AgAgA0EQaiQAIAIoAgwhAwJAAkACQCACKAIIQQFxBEAgAEEDOgAEIAAgAzYCAAwBCyACIAM2AhwCQCACQRxqEKs7BEAgAiADNgIYIAIgAkEYaiABEIIkIAIoAgQhAQJAIAIoAgBBAXEEQCAAQQM6AAQgACABNgIADAELIAIgATYCHEEAIQUjAEEQayIEJAACQCACQRxqIgYQqjtFDQAgBigCACUBED8hCBDfEiIFIAgmASAEIAUiBjYCDCAEQQxqEKs7IQUgBkGEAUkNACAGEPIfCyAEQRBqJAAgBQRAIABBADoABCAAIAE2AgAgA0GEAU8EQCADEPIfCyAHQYQBSQ0GDAULIABBAjoABCABQYQBSQ0AIAEQ8h8LIANBhAFJDQIMAQsgAEECOgAEIANBgwFNDQELIAMQ8h8LIAdBgwFNDQELIAcQ8h8LIAJBIGokAAu6EAIJfwF+IwBB4ABrIgEkACMAQTBrIgckACMAQSBrIgUkACAFQRRqQYOACEEAQQFBARCgGCAFKAIYIQYgBSgCFEEBRgRAIAYgBSgCHEGQ880AEP0vAAsgBSgCHCEGIAVBCGoiCEGDgAg2AgQgCCAGNgIAIAUoAgwhBiAHQQhqIgggBSgCCDYCACAIIAY2AgQgBUEgaiQAIAcgAzYCLCAHIAI2AiggB0EANgIkIAdCADcCHCAHIAcpAwg3AhQgAUEwaiEGIAdBFGohCiMAQRBrIgkkACAJQQhqIQwjAEEgayICJABBACEDIwBBEGsiCCQAIAhBCGoiDUEANgIAIAhCADcDACMAQRBrIgskAAJAIAgoAgBFIAgoAgRFcw0AIAtBCGogDSgCADYCACALIAgpAgA3AwBBuOwFIAsQ2S4iBUUNACAFIAgpAgA3AvzqASAFQYTrAWogDSgCADYCACAFIgNBADYCmOsBIAVCADcDkOsBIAVBADYCzOsBIAVBADYCvOsBIAVCADcDoOsBIAVBADYCuOkBIAVBADYCtOwFIAVCADcCtOsBIAVBADYCqOsBIAVCADcD4OsBIAVBgYCAwAA2AsTrASAFQgA3AqzrASAFQgA3AuzqAQsgC0EQaiQAIAhBEGokACADRQRAQZTw0ABBNEGE8dAAEMskAAsgAiADNgIUIAJBCGohCCACQRRqKAIAIgVBADYC4OsBIAVBADYCtOsBIwBBQGoiCyQAQUQhAyAFKAK06wFFBEAgBRD8MEEAIQMLIAtBQGskACADQYh/TQRAQQFBBSAFKALs6gEbIQMLIAMQ0j0hBSAIIAM2AgQgCCAFQQBHNgIAAkACQAJAIAIoAghBAXFFDQAgAkEYaiACKAIMEOIaIAItABhBBEYNACACKQMYIhBC/wGDQgRSDQELIAJBFGooAgAhBUEAIQMjAEEQayIIJAACQCAFKAK06wEEQEFEIQMMAQsgBRD8MAsgCEEQaiQAIAMQ0j0hBSACIAM2AgQgAiAFQQBHNgIAAkAgAigCAEEBcUUNACACQRhqIAIoAgQQ4hogAi0AGEEERg0AIAIpAxgiEEL/AYNCBFINAQsgDCACKAIUNgIEIAxBBDoAAAwBCyAMIBA3AgAgAkEUahCPPAsgAkEgaiQAAkACQCAJLQAIQQRGBEAgCSgCDCECDAELIAkoAgwhAiAJKAIIIgNB/wFxQQRGDQAgBkECOgAiIAYgA60gAq1CIIaENwIAIAooAgQiAkUNASAKKAIAIAJBARD4OgwBCyAGQQA6ACIgBkEAOwEgIAYgAjYCHCAGIAopAgA3AgAgBkEYaiAKQRhqKAIANgIAIAZBEGogCkEQaikCADcCACAGQQhqIApBCGopAgA3AgALIAlBEGokACAHQTBqJAAgASkDMCEQAkAgAS0AUiICQQJGBEAgASAQNwMwIAAgBhCBKwwBCyABQShqIAFB0ABqLwEAOwEAIAFBIGogAUHIAGopAwA3AwAgAUEYaiABQUBrKQMANwMAIAEgASkDODcDECABIAEtAFM6ACsgASACOgAqIAEgEDcDCCABQTBqIQYgAUEIaiEKIwBBMGsiBSQAQYDAACEIAkACQCAEKAIAIg0gBCgCCCIDa0EgTwRAIAMhAgwBCyAFQRBqIAogBBCSEwJAIAUtABBBBEYEQCAFKAIUIQIMAQsgBSkDECIQQiCIpyECIBCnIgdB/wFxQQRGDQAgBiACNgIEIAYgBzoAACAGQQNqIAdBGHY6AAAgBiAHQQh2OwABDAILIAIEQCAEKAIIIQIMAQsgBkEEOgAAIAZBADYCBAwBCwNAAkAgAiAEKAIAIgdHIAcgDUdyDQAgBUEQaiAKIAQQkhMCQCAFLQAQQQRGBEAgBSgCFCEHDAELIAUpAxAiEEIgiKchByAQpyICQf8BcUEERg0AIAYgBzYCBCAGIAI6AAAgBkEDaiACQRh2OgAAIAYgAkEIdjsAAQwDCyAEKAIIIQIgBwRAIAQoAgAhBwwBCyAGQQQ6AAAgBiACIANrNgIEDAILAkACQAJAAkAgAiAHRgRAIAVBCGogBCAHELQgIAUoAghBgYCAgHhHDQEgBCgCACEHIAQoAgghAgsgBCgCBCEJIAUgDjYCHCAFQQA2AhggBSACIAlqNgIQIAUgCCAHIAJrIgIgAiAISxsiCTYCFCAFQSBqIAogBUEQahCFFiAFLQAgIgJBBEcNAQwCCyAGQoHMADcCAAwECwNAQQAhBwJAAkACQAJAIAJB/wFxQQFrDgMBAgAGCyAFKAIkLQAIQSNHDQUMAgsgBS0AIUEjRg0BDAQLIAUoAiQtAAhBI0cNAwsgBSAFKQMgNwMoIAVBKGoQuS4gBUEgaiAKIAVBEGoQhRYgBS0AICICQQRHDQALC0EBIQcLIAQgBSgCGCILIAQoAghqIgI2AgggBSgCHCEMAkAgBw0AIAUpAyAiEKciB0H/AXFBBEYNACAGIAc6AAAgBkEHaiAQQjiIPAAAIAZBBWogEEIoiD0AACAGIBBCCIg+AAEMAgsgCwRAIAkgC0cgCUF/IAggD0EBakEAIAkgC0sbIg9BAUobIAggCSAMRxsiCElyRQRAQX8gCEEBdCAIQQBIGyEICyAMIAtrIQ4MAQUgBkEEOgAAIAYgAiADazYCBAsLCyAFQTBqJAACQCABLQAwQQRHBEAgASABKQMwNwNYIAAgAUHYAGoQgSsMAQsgASgCNCECIABBCDYCACAAIAI2AgQLIAEoAgwiAARAIAEoAgggAEEBEPg6CyABQSRqEI88CyABQeAAaiQAC8QCAQN/IwBBgAFrIQMCQCABLwEOIgVB/wdxIgRBEE8EQAJ/IAQgAigCBCIDQRBqTwRAIAMgBCADa0EQayIEQX8gAigCACICdEF/c3FqIAEoAgggBCACdkEBcUECciAFQQp2dGpBBGsgAnRqQQFqDAELIARBD2sLIQFBACECDAELIANCgoCAgDA3AnggA0KCgICAUDcCcCADQoKAgIAgNwJoIANCgoCAgGA3AmAgA0KCgICAEDcCWCADQoKAgIBwNwJQIANCgYCAgDA3AkggA0KBgICAUDcCQCADQoGAgIAgNwI4IANCgYCAgGA3AjAgA0KBgICAEDcCKCADQoGAgIBwNwIgIANCBDcCGCADQgM3AhAgA0ICNwIIIANCATcCACADIARBA3RqIgEoAgAhAiABKAIEIQELIAAgATYCBCAAIAI2AgAL/gIBBn8jAEFAaiIDJAAgA0EIaiABEN0oAkACQCADKAIIIgcEQCADQSBqIghBBCABKAIYQQFqIgRBfyAEGyIEIARBBE0bQQBBBEEEEKAYIAMoAiQhBSADKAIgQQFGDQIgAygCKCIEIAc2AgAgA0EcaiICQQE2AgAgAyAENgIYIAMgBTYCFCADQThqIAFBGGopAwA3AwAgA0EwaiABQRBqKQMANwMAIANBKGogAUEIaikDADcDACADIAEpAwA3AyAgA0EUaiEGIwBBEGsiBSQAIAVBCGogCBDdKCAFKAIIIgcEQANAIAYoAggiBCAGKAIARgRAIAYgCCgCGEEBaiIBQX8gARsQgC4LIAYoAgQgBEECdGogBzYCACAGIARBAWo2AgggBSAIEN0oIAUoAgAiBw0ACwsgBUEQaiQAIABBCGogAigCADYCACAAIAMpAhQ3AgAMAQsgAEEANgIIIABCgICAgMAANwIACyADQUBrJAAPCyAFIAMoAiggAhD9LwALtwIBAn8jAEFAaiICJAAgAkEQaiABENw7IAIgAigCFCIDNgIYAkACQCADQQFGBEAgAS0AGEEVRw0BIAEoAhwhAyACQQhqIAEQ3DsgAigCDA0CQQBBAEGIoYYBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJBmKKGATYCHEEAIAJBGGpBhKGGASACQRxqQaCihgEQrysACyACQQA2AiwgAkEBNgIgIAJBwKGGATYCHCACQgQ3AiQgAkEcakHIoYYBEO8sAAsgAkE0aiACKAIIIAEoAiggA2wgASgCJCADbBDmFSAAIAFBGGoQ2QYgAEEYaiABQSxqQQAgASgCLBsQ7iUgACADNgI0IAAgAikCNDcCDCAAQRRqIAJBPGooAgA2AgAgACABKAIkNgIwIAEQjCcgAkFAayQAC54CAQV/IwBBEGsiAiQAQQEhBQJAIAAoAgAiAy8BECABKAIAIgQvARBHDQAgAy8BEiAELwESRw0AIAMoAgwiACgCCCIGQQJGIAQoAgwiASgCCEECRnMNAAJAIAZBAkYEQCACIABBDGo2AgggAiABQQxqNgIMIAJBCGogAkEMahD9EUUNAiAAKAI0IAAoAjggASgCNCABKAI4EOsSDQEMAgsgAiAAQQhqNgIIIAIgAUEIajYCDCAAKAIsIAEoAixHDQEgACgCMCABKAIwRw0BIAAoAjQgASgCNEcNASACQQhqIAJBDGoQ/RFFDQEgAC0AOCABLQA4Rw0BCyADKAIEIAMoAgggBCgCBCAEKAIIEOQcQQFzIQULIAJBEGokACAFC6oCAgZ/AX4jAEEgayIEJAAgAygCACEIIAMoAgghBSADKAIEIgYgAygCDCIHSwRAIAYgB2siCQRAIAcgCGpBACAJ/AsACyADIAY2AgwgBiEHCwJAAkACQCAFIAZNBEAgBCABQRBqIAIgBSAIaiAGIAVrELwNIAQtAABBBEcNAyAEKAIEIAVqIgEgBUkNASABIAdLDQIgAyABNgIIDAMLIAUgBkHgzcMAELE7AAtBgM7DAEEPQeDOwwAQyyQACyAEQQA2AhggBEEBNgIMIARB2M3DADYCCCAEQgQ3AhAgBEEIakHgzsMAEO8sAAsCQAJAAkACQCAEKQMAIgqnQf8BcUEEaw4CAgABCyAAQQU6AAAMAgsgACAKNwIADAELIABBBDoAAAsgBEEgaiQAC7MQAg1/Bn4jAEHwAGsiCCQAIAhBFGoiBCABKAIAQQhqEPsuIAhBCGogBBDtEiAIKAIIIgoEQCAIKAIMIQEDQCMAQSBrIgUkAEEAIQRBACEJIwBBIGsiCyQAIAsgCjYCDCAFAn9BAyACEPcODQAaIAtBDGohBiMAQdAAayIDJAACQCACKQMAQgJRBEAgA0FAa0IANwMAIANCADcDOCADIAIpAxAiEDcDMCADIAIpAwgiETcDKCADIBBC88rRy6eM2bL0AIU3AyAgAyAQQu3ekfOWzNy35ACFNwMYIAMgEULh5JXz1uzZvOwAhTcDECADIBFC9crNg9es27fzAIU3AwggAyAGKAIAIgQoAgAiBkEARzYCTCADQQhqIgcgA0HMAGpBBBC7CQJAIAYEQCAHIAQoAgQgBCgCCBC7CQwBCyADIAQtAAQ2AkwgA0EIaiADQcwAakEEELsJCyADKQM4IAM1AkBCOIaEIhAgAykDIIUiEUIQiSARIAMpAxB8IhGFIhJCFYkgEiADKQMYIhMgAykDCHwiFEIgiXwiEoUiFUIQiSAVIBEgE0INiSAUhSITfCIRQiCJQv8BhXwiFIUiFUIViSAVIBEgE0IRiYUiESAQIBKFfCIQQiCJfCIShSITQhCJIBMgECARQg2JhSIQIBR8IhFCIIl8IhOFIhRCFYkgFCARIBBCEYmFIhAgEnwiEUIgiXwiEoUiFEIQhiAUIBBCDYkgEYUiECATfCIRQiCJfCIThUIriCAQQhGJIBGFIhBCDYkgECASfIUiEEIviIUgECATfCIQQiCIhSAQhSEQDAELIAMgBigCACIGKAIAIgdBAEc2AghCpcaIocicp/lLIRADQCAQIANBCGogBGoxAACFQrODgICAIH4hECAEQQFqIgRBBEcNAAsgBwRAIAYoAggiB0UNASAGKAIEIQQDQCAQIAQxAACFQrODgICAIH4hECAEQQFqIQQgB0EBayIHDQALDAELIAMgBi0ABDYCCEEAIQQDQCAQIANBCGogBGoxAACFQrODgICAIH4hECAEQQFqIgRBBEcNAAsLIANB0ABqJAAgEKdB//8BcSIGIAIvAThxIQQCQAJAAkADQCACKAIcIQcDQCAEIQNBACEEIAMgB08NAAsgAigCGCADQQJ0aiIHLwEAIgRB//8DRwRAIAMgAi8BOCIMIAcvAQIiB3FrIAxxIAlJDQICQCAGIAdHDQAgAigCKCIHIARNDQQgCigCAEUgAigCJCAEQTRsaiIHKAIgIgxBAEdGDQAgB0EgaiEHIAwEQCAHIAoQjDVFDQEMBgsgBy0ABCAKLQAERg0FCyADQQFqIQQgCUEBaiEJDAELCyACKQMAIRAgC0EQaiAKENUiIAspAhAhESALKQIYIRIgBSAGOwEYIAUgAzYCFCAFIBI3AgwgBSARNwIEIAUgAjYCACAJQf8DSyAQQgJScQwDCyACKQMAIRAgC0EQaiAKENUiIAspAhAhESALKQIYIRIgBSAGOwEYIAUgAzYCFCAFIBI3AgwgBSARNwIEIAUgAjYCACAJQf8DSyAQQgJScQwCCyAEIAdB8ODDABDDIQALIAUgBDYCCCAFIAM2AgQgBSACNgIAQQILOgAaIAtBIGokACAFLQAaQQNGBEBB0OHDAEEXIAVBH2pB4ODDAEHo4cMAENUeAAsgCEEkaiIEIAUpAgA3AgAgBEEYaiAFQRhqKAIANgIAIARBEGogBUEQaikCADcCACAEQQhqIAVBCGopAgA3AgAgBUEgaiQAIAgtAD5BAkcEQCAIQdgAaiAIQTxqKAIANgIAIAhB0ABqIAhBNGopAgA3AwAgCEHIAGogCEEsaikCADcDACAIIAgpAiQ3A0AgCEHcAGoiBCABQQxqIAEoAgQgASgCCCABKAIAKAIAEQUAIAggAS0AEDoAbCMAQRBrIgwkAAJ/IAQhAUEAIQcjAEEwayIJJAAgCEFAayIFKAIAIQYgCUEIaiAFQQxqKQIANwMAIAkgBSkCBDcDAAJAAn8CQCAGKAIoIgNB//8BTQRAIAUtABohDiAFKAIUIQogBS8BGCEEIAlBLGoiCyABQRBqKAIANgIAIAlBJGoiDSABQQhqKQIANwIAIAkgASkCADcCHCAGQSBqIgEoAgAgA0YEQCABQbDhwwAQkygLIAYoAiQgA0E0bGoiASAJKQIUNwIEIAFBADYCACABIAVBBGoiBSkCADcCICABIAQ7ATAgAUEMaiAJQRxqKQIANwIAIAFBFGogDSkCADcCACABQRxqIAsoAgA2AgAgAUEoaiAFQQhqKQIANwIAIAYgA0EBajYCKCAGKAIcIQ0gBigCGCEPIAMhAQNAIAohC0EAIQogCyANTw0AIA8gC0ECdGoiCi8BACIFQf//A0YNAiAKIAE7AQAgCi8BAiAKIAQ7AQIgC0EBaiEKIAdBAWohByEEIAUhAQwACwALIAFBDGogASgCBCABKAIIIAEoAgAoAhARAQAgCSgCACIBBEAgCUEMaiAJKAIEIAkoAgggASgCEBEBAAtBAAwBCyAKIAQ7AQIgCiABOwEAAkAgDkEBcyAHQYABSXENACAGKQMAQgBSDQAgBkIBNwMACyADIAYoAigiAU8NASAGKAIkIANBNGxqQQxqCyAJQTBqJAAMAQsgAyABQbjiwwAQwyEAC0UEQEHQ4cMAQRcgDEEPakHg4MMAQcjiwwAQ1R4ACyAMQRBqJAALIAggCEEUahDtEiAIKAIEIQEgCCgCACIKDQALCyAAIAJB0AH8CgAAIABBADoAzAMgCEHwAGokAAuBAgIBfwF+IwBBoAFrIgckACAHQdAAaiACIAMgBCAFIAYgAS0AaBD8AiAHQUBrIgIgB0HgAGopAwA3AwAgB0HIAGoiAyAHQegAaikDADcDACAHIAcpA1g3AzgCQCAHKQNQIghCBlEEQCAAIAcpAzg3AwAgAEEQaiADKQMANwMAIABBCGogAikDADcDAAwBCyAHQQhqIAdB8ABqQTD8CgAAIAEpAwBCBlIEQCABELEeCyABIAg3AwAgASAHKQM4NwMIIAFBEGogB0FAaykDADcDACABQRhqIAdByABqKQMANwMAIAFBIGogB0EIakEw/AoAACAAQQg2AgALIAdBoAFqJAALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQbTDzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQdTDzQAQrSgLIAAoAhAgAUEBdGogA0ECazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDQEiAAQcgAaiEAIAJByABrIgINAAsLDwtBpMPNABCyOwALQcTDzQAQsjsABSAAKAIEIQAMAQsACwALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQfTCzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQZTDzQAQrSgLIAAoAhAgAUEBdGogA0EBazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDREiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MLNABCyOwALQYTDzQAQsjsABSAAKAIEIQAMAQsACwALswIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGCIDQYCAgIB4Rg0BIAEvAQBBAWshBCADIAAoAiAiAkYEQCAAQRhqQfTEzQAQrSgLIAAoAhwgAkEBdGogBDsBACAAIAJBAWo2AiAgACgCDCICQYCAgIB4Rg0CIAEvAQIhAyACIAAoAhQiAUYEQCAAQQxqQZTFzQAQrSgLIAAoAhAgAUEBdGogA0ECazsBACAAIAFBAWo2AhQPCyAAKAIMIgIEQCAAKAIIIQAgAkHIAGwhAgNAIAAgARDSEiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MTNABCyOwALQYTFzQAQsjsABSAAKAIEIQAMAQsACwALmAIAIwBBMGsiAiQAIAJBADYCCCACQoCAgIDAADcCACACQQA2AhQgAkKAgICAwAA3AgwgA0UEQCACQRhqIAFB4ABqQQRBABCgECACKAIYIgFBCEcEQCAAIAIpAhw3AgQgAEEUaiACQSxqKAIANgIAIABBDGogAkEkaikCADcCAAsgACABNgIAIAIoAhQiAwRAIAIoAhAhAANAIAAoAgAiAQRAIABBDGogAEEEaigCACAAQQhqKAIAIAEoAhARAQALIABBEGohACADQQFrIgMNAAsLIAJBDGpBBEEQEOAeIAIQ6TsgAkEwaiQADwsgAkEANgIoIAJBATYCHCACQaCizgA2AhggAkIENwIgIAJBGGpBqKLOABDvLAALngIBBn8gASgCACEEAkACQAJAAkACQAJAIAAoAgQiCCAAKAIIIgVrIgkgAyACayIGQQhqSQRAIAEoAggiByABKAIEIgFLDQIgAiADSw0DIAMgB0sNBCAFIAhLDQUgBiAJSw0GIAZFDQEgACgCACAFaiACIARqIAb8CgAADAELIAAoAgAgBWoiASACIARqIgIpAAA3AAAgAkEIaiICIAMgBGoiBE8NACABQQhqIQMDQCADIAIpAAA3AAAgA0EIaiEDIAJBCGoiAiAESQ0ACwsgACAFIAZqNgIIDwsgByABQdTw/AAQsDsACyACIANBxPH8ABCxOwALIAMgB0HE8fwAELA7AAsgBSAIQdTx/AAQrzsACyAGIAlB5PH8ABCwOwALhwICAn8CfiMAQSBrIQMgAAJ+IAJFBEAgACABKQMANwMAIABBGGogAUEYaikDADcDACAAQRBqIAFBEGopAwA3AwAgAEEIaiABQQhqKQMANwMAQgAMAQsgA0EYakIANwMAIANBEGpCADcDACADQgA3AwggAyABKQMAIAJBP3GtIgaGNwMAQQAgAmtBP3GtIQUDQCADIARqQQhqIAEgBGoiAkEIaikDACAGhiACKQMAIAWIhDcDACAEQQhqIgRBGEcNAAsgACADKQMANwMAIABBCGogA0EIaikDADcDACAAQRBqIANBEGopAwA3AwAgAEEYaiADQRhqKQMANwMAIAEpAxggBYgLNwMgC6ICAgN/AX4jAEFAaiICJAAgASgCAEGAgICAeEYEQCABKAIMIQMgAkEkaiIEQQA2AgAgAkKAgICAEDcCHCACQTBqIAMoAgAiA0EIaikCADcDACACQThqIANBEGopAgA3AwAgAiADKQIANwMoIAJBHGpB4KiJASACQShqEMsKGiACQRhqIAQoAgAiAzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIACyABKQIAIQUgAUKAgICAEDcCACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCACACIAU3AwBBDEEEEK02IgFFBEBBBEEMEKM9AAsgASACKQMANwIAIAFBCGogAygCADYCACAAQdy1iQE2AgQgACABNgIAIAJBQGskAAuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEOUtIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQAL3gECAX8BfiAAKAK8AiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEG8AmoQ2SELIABBgAJqEN47IABBjAJqEIYwAkAgACkDYCICQghRIAKnQQZJcg0AAkAgACgCiAFFDQAgACgCjAEiAUUNACAAQZgBaiAAKAKQASAAKAKUASABKAIQEQEACyAAKAKcAUUNACAAKAKgASIBRQ0AIABBrAFqIAAoAqQBIAAoAqgBIAEoAhARAQALIAAoApgCQYCAgIB4RwRAIABBmAJqEOo7CyAAQaQCahCFMCAAQbACahCFMAuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEIguIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQALhAIBBH8gACgCCCEDIAACf0EBIAFBgAFJIgQNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiBRDYLSAAKAIEIAAoAghqIQICQAJAIARFBEAgAUGAEEkNASABQYCABE8EQCACIAFBP3FBgAFyOgADIAIgAUESdkHwAXI6AAAgAiABQQZ2QT9xQYABcjoAAiACIAFBDHZBP3FBgAFyOgABDAMLIAIgAUE/cUGAAXI6AAIgAiABQQx2QeABcjoAACACIAFBBnZBP3FBgAFyOgABDAILIAIgAToAAAwBCyACIAFBP3FBgAFyOgABIAIgAUEGdkHAAXI6AAALIAAgAyAFajYCCEEAC58CAgN+CH8CQAJAIAAoAkxFDQAgAEHQAGogARDuCyECIAAoAkAiBkFAaiEIIAAoAkQiByACp3EhBSACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgASgCCCEJIAEoAgQhCkEAIQEDQCAFIAZqKQAAIgMgBIUiAkJ/hSACQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgJQRQRAA0AgCiAJIAggAnqnQQN2IAVqIAdxIgtBBnRrIgwoAgQgDCgCCBDkHA0EIAJCAX0gAoMiAlBFDQALCyADIANCAYaDQoCBgoSIkKDAgH+DUEUNASAFIAFBCGoiAWogB3EhBQwACwALIAAtACsPCyAALQArIAZBACALa0EGdGpBBWstAAAiACAAQQlGGwuEAgEEfyAAKAIIIQMgAAJ/QQEgAUGAAUkiBA0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIFEIQuIAAoAgQgACgCCGohAgJAAkAgBEUEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACADIAVqNgIIQQALlgIBBH8jAEHQAGsiAyQAIABBDGoiBSAAKAIUIAAoAihBAUEBQeCwgwEQwyggA0EQaiICIAFBwAD8CgAAIANBCGogAhDWEAJAAkACQAJAIAMoAghBAXEEQCADKAIMIQEDQCABIAAoAhwiAk8NAyABQQFqIgQgAk8NAiAAKAIYIgIgBEECdGooAgAiBCACIAFBAnRqKAIAIgJJDQQgBCAAKAIkIgFLDQUgBSAAKAIgIAJqIAQgAmsQoTYgAyADQRBqENYQIAMoAgQhASADKAIAQQFxDQALCyADQdAAaiQADwsgBCACQYCxgwEQwyEACyABIAJB8LCDARDDIQALIAIgBEGQsYMBELE7AAsgBCABQZCxgwEQsDsAC5YCAQR/IwBB0ABrIgMkACAAQSRqIgUgACgCLCAAKAIAQQFBAUHgsIMBEMMoIANBEGoiAiABQcAA/AoAACADQQhqIAIQ1hACQAJAAkACQCADKAIIQQFxBEAgAygCDCEBA0AgASAAKAIMIgJPDQMgAUEBaiIEIAJPDQIgACgCCCICIARBA3RqKAIAIgQgAiABQQN0aigCACICSQ0EIAAoAhQiASAESQ0FIAUgACgCECACaiAEIAJrEKE2IAMgA0EQahDWECADKAIEIQEgAygCAEEBcQ0ACwsgA0HQAGokAA8LIAQgAkGAsYMBEMMhAAsgASACQfCwgwEQwyEACyACIARBkLGDARCxOwALIAQgAUGQsYMBELA7AAuvAwEGfyMAQRBrIgUkAAJAQaDvigEoAgBFBEBBoO+KAUF/NgIAQbDvigEoAgAiAkGs74oBKAIAIgBGBEAgAiEAQaTvigEoAgAiASACRgRA0G9BgAEgAiACQYABTRsiAPwPASIDQX9GDQMCQEG074oBKAIAIgFFBEBBtO+KASADNgIADAELIAEgAmogA0cNBAsgBUEIaiEDIwBBEGsiBCQAAn9BgYCAgHhBpO+KASgCAEGs74oBKAIAIgFrIABPDQAaIARBCGpBpO+KASABIABBBEEEEMwUQYGAgIB4IAQoAggiAUGBgICAeEYNABogBCgCDCEAIAELIQEgAyAANgIEIAMgATYCACAEQRBqJAAgBSgCCEGBgICAeEcNA0Gk74oBKAIAIQFBrO+KASgCACEACyAAIAFPDQJBqO+KASgCACAAQQJ0aiACQQFqNgIAQazvigEgAEEBaiIANgIACyAAIAJNDQFBsO+KAUGo74oBKAIAIAJBAnRqKAIANgIAQaDvigFBoO+KASgCAEEBajYCAEG074oBKAIAIAVBEGokACACag8LQeiuiAEQmz4ACwAL/QECBH8BfiMAQZABayIDJAAgAS0ACSEEIAEtAAghBQJAIAEpAwAiB0IDUQRAQgMhBwwBCyADIAQ6AFEgAyAFOgBQIAMgBzcDSCADQdIAaiIGIAFBCmpBPvwKAABBACACQQAgAkHkAGtB//8DcUGEB0kbIgFBEHRBASABQf//A3EbIgFBgICAGHEgAUEBcSICGyABQYCA/AdxckEQdiEBIAIEQCADQcgAahC8LkIDIQcgASEEQQAhBQwBCyADIAE7AYwBIANBCmogBkE+/AoAAAsgACAEOgAJIAAgBToACCAAIAc3AwAgAEEKaiADQQpqQT78CgAAIANBkAFqJAALmQIBA38jAEEQayIEJAACQAJAAkAgASgCECABKAIURgRAIAMgASgCDE8NAQsgBEEEaiABENsWIAQoAgRFDQEgACAEKQIINwIADAILIAEoAgAhBQJAIAEoAgQiBiADIAMgBksbIgNBAUcEQCADRQ0BIAIgBSAD/AoAAAwBCyACIAUtAAA6AAALIAAgAzYCBCAAQQQ6AAAgASAGIANrNgIEIAEgAyAFajYCAAwBCyAEKAIIIQUCQCAEKAIMIgYgAyADIAZLGyIDQQFHBEAgA0UNASACIAUgA/wKAAAMAQsgAiAFLQAAOgAACyAAIAM2AgQgAEEEOgAAIAEgASgCFCIAIAEoAhAgA2oiASAAIAFJGzYCEAsgBEEQaiQAC4kCAQJ/IwBB0ABrIgIkAAJAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACQRhqIgUgBCgCAEEIaiABKAIILQAAEJUBAkAgAigCGEUEQEE8QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEEckE0/AoAAAwBCyACQRBqIAJBMGopAwA3AwAgAiACKQMoNwMIIAIoAiQhASACKAIgIgRBCEYNACADKAIAQQhHBEAgAxDJIwsgAyABNgIEIAMgBDYCACADIAIpAwg3AwggA0EQaiACQRBqKQMANwMAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAAPC0EEQTwQoz0AC4kCAQJ/IwBB0ABrIgIkAAJAIAEoAgAiBCABKAIERgR/QQAFIAEgBEEEajYCACACQRhqIgUgBCgCAEEIaiABKAIILQAIEJUBAkAgAigCGEUEQEE8QQQQrTYiAUUNAyABQoGAgIAQNwIAIAFBCGogBUEEckE0/AoAAAwBCyACQRBqIAJBMGopAwA3AwAgAiACKQMoNwMIIAIoAiQhASACKAIgIgRBCEYNACADKAIAQQhHBEAgAxDJIwsgAyABNgIEIAMgBDYCACADIAIpAwg3AwggA0EQaiACQRBqKQMANwMAQQAhAQtBAQshAyAAIAE2AgQgACADNgIAIAJB0ABqJAAPC0EEQTwQoz0AC+ABAQN/IAEoAjhBAUchBSAAIQMCfwNAIAVFBEAgAEEBaiIBZyEAIAIEQEEAIQRBHyAAayIAQQh0IAFBCHQgAHZqDAMLQQAhBEGAPiAAQQh0awwCCyADQYCACEYEQCAEQYACaiEEQf//ByEDDAELCyABKAIsIANBwABPBH9BMiADZ2sFIANBwK7RAGotAAALIgNBkK7RAGotAABBCHRqIQUgASgCBCADQQJ0aigCAEEBaiIBZyEAIAIEfyAAQQh0IAFBCHRBHyAAa3ZrQYA+awUgAEEIdEGAPmsLIAVqCyAEaguTAgIEfwF+IwBBIGsiBSQAIAUgASAArYgiCTcDAAJAAkACQCAJUARAIABB/wFxQTlPDQEgAigCACIHQQN2IgYgBE8NAiAGQQdqIgggBEkNAyAIIARB+OXRABDDIQALIAVBADYCCCAFQbDl0QAgBUEIakGI5tEAEK4rAAtBuOXRAEEeQdjl0QAQnykACyAGIARB6OXRABDDIQALIAIgByAAQf8BcWo2AgAgAyAIaiABIAdBB3GthiIBQjiIPAAAIAMgBmoiACABQjCIPAAGIAAgAUIoiDwABSAAIAFCIIg8AAQgACABQhiIPAADIAAgAUIQiDwAAiAAIAFCCIg8AAEgACAALQAAIAGncjoAACAFQSBqJAALmQIBBX8jAEEgayICJAAgAiABQf8BcSIDNgIEAkACQAJAIANFBEBBACEDA0AgASAESQ0CIAEgBGtBD00NAyADQQFqIQUgA0ECdEEEaiEGQQAhAwNAIAAgA2ogBjsBACADQQJqIgNBIEcNAAsgBEEQaiEEIAVBEEYEQEEAIQUgASAERg0FCyAAQSBqIQAgBSEDDAALAAsgAkEANgIIQQAgAkEEakGI8dEAIAJBCGpBrPHRABCvKwALIAJBADYCGCACQQE2AgwgAkGA8NEANgIIIAJCBDcCECACQQhqQYzx0QAQ7ywACyACQQA2AhggAkEBNgIMIAJBgPDRADYCCCACQgQ3AhAgAkEIakGc8dEAEO8sAAsgAkEgaiQAC7MCAQR/IwBBsAJrIgIkACABQSBqIgMoAgAhBCACQcgBaiIFIAMoAgA2AgAgAiABKQIYNwPAASABIAJBwAFqIgNBhOOFARD5GyACQegBakGatOjQATYCACACQpq06NChw4aNGjcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiAEQQR2NgLsASACQagCaiABQQhqKAIANgIAIAIgASkCADcDoAIgAkHkAGoiBCADIAJBoAJqEJYpIAJB0AFqIAFBNGopAgA3AwAgBSABQSxqKQIANwMAIAIgASkCJDcDwAEgAkEIaiIFIAQgAxDCGSAAIAUQzRwgAUEMahDDDCACQbACaiQAC7MCAQR/IwBBsAJrIgIkACABQSBqIgMoAgAhBCACQcgBaiIFIAMoAgA2AgAgAiABKQIYNwPAASABIAJBwAFqIgNBhOOFARD5GyACQegBakGXrty4ATYCACACQpeu3Ljx4sWLFzcC4AEgAkIENwLYASACQgA3AtABIAJCgICAgMAANwLIASACQQA2AsABIAJBADsBmAIgAkEANgKUAiACQQA2AvwBIAJBADYC8AEgAiAEQQR2NgLsASACQagCaiABQQhqKAIANgIAIAIgASkCADcDoAIgAkHkAGoiBCADIAJBoAJqEJYpIAJB0AFqIAFBNGopAgA3AwAgBSABQSxqKQIANwMAIAIgASkCJDcDwAEgAkEIaiIFIAQgAxDCGSAAIAUQzRwgAUEMahDDDCACQbACaiQAC6ACAQV/IwBBMGsiAiQAIAIgACgCACIAQQ11IgM2AgwCQAJAIABBA3ZB/wdxIgRB3QVJBEAgBEGUzYYBai0AACEFIANBkM4ATwRAQQEhACACQQE2AiQgAkGoxoYBNgIgIAJBATYCFCACQaDGhgE2AhAgAkEBNgIcIAJBnAM2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCg0DDAILQQEhACABIANB//8DcUHkAG4iBhC1KA0CIAEgAyAGQeQAbGsQtShFDQEMAgsgBEHdBUH00oYBEMMhAAsgAUEtEIM2DQAgASAEIAVqIgNBBnYQtSgNACABQS0QgzYNACABIANBAXZBH3EQtSghAAsgAkEwaiQAIAALoQICAn8CfQJAAkAgALwiAUGAgIAETgRAIAFB////+wdLDQFBgX8hAkMAAAAAIQAgAUGAgID8A0YNAQwCCyAAQwAAAABbBEBDAACAvyAAIACUlQ8LIAFBAE4EQCAAQwAAAEyUvCEBQeh+IQIMAgsgACAAk0MAAAAAlSEACyAADwsgAUGN9qsCaiIBQf///wNxQfOJ1PkDar5DAACAv5IiACAAIABDAAAAP5SUIgOTvEGAYHG+IgRDALC4P5QgACAEkyADkyAAIABDAAAAQJKVIgAgAyAAIACUIgAgACAAlCIAQ+7pkT6UQ6qqKj+SlCAAIABDJp54PpRDE87MPpKUkpKUkiIAQwCwuD+UIAAgBJJD1Jo4uZSSkiABQRd2IAJqspILhQIBBH8jAEEQayIEJAACQCABIANHDQAgAQRAA0AgACgCACIDKAIIIgdBAkYgAigCACIFKAIIQQJGcw0CAkAgB0ECRgRAIAQgA0EMajYCCCAEIAVBDGo2AgwgBEEIaiAEQQxqEP0RRQ0EIAMoAjQgAygCOCAFKAI0IAUoAjgQ6xJFDQQMAQsgBCADQQhqNgIIIAQgBUEIajYCDCADKAIsIAUoAixHDQMgAygCMCAFKAIwRw0DIAMoAjQgBSgCNEcNAyAEQQhqIARBDGoQ/RFFDQMgAy0AOCAFLQA4Rw0DCyAAQQRqIQAgAkEEaiECIAFBAWsiAQ0ACwtBASEGCyAEQRBqJAAgBguKAgIHfwJ+IAAgACkDECIJIAApAwAiClRBBHRqIgMgAEEwQSAgACkDMCAAKQMgVCIEG2oiAiAAIAkgClpBBHRqIgUgAEEgQTAgBBtqIgApAwAgBSkDAFQiBBsgAikDACADKQMAVCIGGyIHKQMAIQkgACAFIAIgBhsgBBsiCCkDACEKIAFBCGogAiADIAYbIgJBCGopAwA3AwAgASACKQMANwMAIAEgCCAHIAkgClYiAhsiAykDADcDECABQRhqIANBCGopAwA3AwAgAUEoaiAHIAggAhsiAkEIaikDADcDACABIAIpAwA3AyAgAUE4aiAFIAAgBBsiAEEIaikDADcDACABIAApAwA3AzALkgIBBH8CQAJAAn8CfyABAn8CQCABKAIAIgVBAkYEQCABKAIMQQFqIgMgASgCCCICKAIoSQ0BQQAMBAsgASgCDCICIAEoAggiBCgCKCIDTw0EIAQoAiQgAkE0bGoiAyAFQQFxRQ0BGiABKAIEIgUgBCgCNCICTw0FQQIhAiABIAQoAjAgBUEkbGoiBCgCCAR/IAEgBCgCDDYCBEEBBSACCzYCACAEQRBqDAILIAEgAzYCDCACKAIkIANBNGxqCyIDKAIENgIEIAFBAUECIAMoAgBBAXEbNgIAIANBDGoLIQIgA0EgagshASAAIAI2AgQgACABNgIADwsgAiADQaz2wwAQwyEACyAFIAJBvPbDABDDIQALiwIBB38gACgCACEBIAAoAgQhBwNAIAEgB0YEQEGAgMQADwsgACABQQFqIgQ2AgACQAJAIAEtAAAiAsBBAE4NACAAIAFBAmoiBDYCACABLQABQT9xIQMgAkEfcSEFIAJB3wFNBEAgBUEGdCADciECDAELIAAgAUEDaiIENgIAIAEtAAJBP3EgA0EGdHIhBiACQfABSQRAIAYgBUEMdHIhAgwBCyAAIAFBBGoiBDYCAEGAgMQAIQMgBUESdEGAgPAAcSABLQADQT9xIAZBBnRyciICQYCAxABGDQELIAQhAQJ/IAJBDU0EQEGAgMQAQQEgAnRBgMwAcQ0BGgsgAgsiA0GAgMQARg0BCwsgAwuOAgEBfyMAQRBrIgQkAAJAAkACQAJAIAEoAgBBgICAgHhHBEAgASgCCCADSQ0BCyACKAIAQYCAgIB4RwRAIAIoAgggA0kNAgsgAEEINgIADAILIARBBGpBKUEAQQFBARCgGCAEKAIIIQEgBCgCBEEBRg0CIAQoAgwiAkHcis4AQSn8CgAAIABBKTYCDCAAIAI2AgggACABNgIEIABBADYCAAwBCyAEQQRqQSlBAEEBQQEQoBggBCgCCCEBIAQoAgRBAUYNASAEKAIMIgJBhYvOAEEp/AoAACAAQSk2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMAAsgBEEQaiQADwsgASAEKAIMQZyHzgAQ/S8AC+8BAgF/AX4gACgCvAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBvAJqENkhCyAAQYACakEBQQEQ4B4gAEGMAmoQhjACQCAAKQNgIgJCCFENACACpyIBQQZJDQAgAUEHRhoCQCAAKAKIAUUNACAAKAKMASIBRQ0AIABBmAFqIAAoApABIAAoApQBIAEoAhARAQALIAAoApwBRQ0AIAAoAqABIgFFDQAgAEGsAWogACgCpAEgACgCqAEgASgCEBEBAAsgACgCmAJBgICAgHhHBEAgAEGYAmpBBEEIEOAeCyAAQaQCahCFMCAAQbACahCFMAuIAgEJfyAAIAAoAgwiAyAAKAIAIgRJQQxsaiIFIABBJEEYIAAoAiQgACgCGEkiBhtqIgIgACADIARPQQxsaiIDIABBGEEkIAYbaiIAKAIAIAMoAgBJIgQbIAIoAgAgBSgCAEkiBhsiBygCACEJIAAgAyACIAYbIAQbIggoAgAhCiABQQhqIAIgBSAGGyICQQhqKAIANgIAIAEgAikCADcCACABIAggByAJIApLIgIbIgUpAgA3AgwgAUEUaiAFQQhqKAIANgIAIAFBIGogByAIIAIbIgJBCGooAgA2AgAgASACKQIANwIYIAFBLGogAyAAIAQbIgBBCGooAgA2AgAgASAAKQIANwIkC5wCAQV/IwBB0ABrIgMkAAJAAkACQCABRQ0AIAEoAhRFDQAgA0EMaiIEIAEgAhDlCCADQThqIgUgBBDhJyADQShqIgIgA0HEAGoiBCkCADcDACADQTBqIgYgA0HMAGoiBygCADYCACADIAMpAjw3AyAgAygCOCIBRQ0BIAQgAikDADcCACAHIAYoAgAiAjYCACADIAE2AjggAyADKQMgNwI8IAJFBEAgASABKAIAIgFBAWs2AgAgAUEBRgRAIAUQ+x4LIABBADYCAAwDCyAAIAE2AgAgACADKQMgNwIEIABBDGogA0EoaikDADcCACAAQRRqIANBMGooAgA2AgAMAgsgACACEJI2EO4lDAELIABBADYCAAsgA0HQAGokAAucAgEFfyMAQdAAayIDJAACQAJAAkAgAUUNACABKAIURQ0AIANBDGoiBCABIAIQ5AggA0E4aiIFIAQQ4ScgA0EoaiICIANBxABqIgQpAgA3AwAgA0EwaiIGIANBzABqIgcoAgA2AgAgAyADKQI8NwMgIAMoAjgiAUUNASAEIAIpAwA3AgAgByAGKAIAIgI2AgAgAyABNgI4IAMgAykDIDcCPCACRQRAIAEgASgCACIBQQFrNgIAIAFBAUYEQCAFEPseCyAAQQA2AgAMAwsgACABNgIAIAAgAykDIDcCBCAAQQxqIANBKGopAwA3AgAgAEEUaiADQTBqKAIANgIADAILIAAgAhCSNhDuJQwBCyAAQQA2AgALIANB0ABqJAALrgIBBn8jAEEgayICJAAgAUEANgIUIAEoAgAhAyABQQA2AgACQAJAAkAgA0UEQCAAQQA2AgAMAQsgASgCECEGIAEoAgwhBCABKAIIIQUgASgCBCEHQQBBwAAQ0TRFDQFBHEEEEK02IgFFDQIgASAHNgIYIAEgAzYCFCABQQA2AhAgASAENgIMIAEgBTYCCCABQoGAgIAQNwIAIAIgBDYCHCACIAU2AhggAiABNgIUIAIgAkEUakEAIAYQ8hUgAiACKAIMIAJBEGoiASgCACIDENMfIQQgAEEQaiABKAIANgIAIABBCGogAkEIaikCADcCACAAIAIpAgA3AgAgACADIARrNgIUCyACQSBqJAAPC0HY/ocBQSkgAkHM/IcBQYT/hwEQ1R4AC0EEQRwQoz0AC00BA38jAEEQayIDJAAgA0EANgIMIANBLToADCABIAIgA0EMakEBIgQQ9C4hBSAAIAIgBGs2AgQgACABIARqQQAgBRs2AgAgA0EQaiQAC5UCAQp/IAEoAlwhAyABKAKEASEFIAEoAlQhAiABKAJYIQYgAS0AiAEiB0EBRiEIAkADQCACIAZGBEBBgIDEACEEDAILIAEgAkEEaiIJNgJUIAUgAigCACIESwRAQQAhAgwCCwJ/Qf8fQf//AyADLQAsGyAETwRAIARBBnYiAiADKAIISQRAIAMoAgQgAkEBdGovAAAgBEE/cWoMAgsgAygCFEEBawwBCyADIAQQwC4LIgIgAygCFCIKSQRAIAMoAhAgAkECdGooAAAhCwsgCyADKAIAIAIgCkkbIgJBf0cNASAJIQIgCA0AC0F/IQICQAJAIAdBAWsOAgABAgsAC0H9/4OABCECCyAAIAI2AgQgACAENgIAC6wOAgt/BH4jAEHgAGsiByQAAkACQCAEIAVBAXEEfyAGBUEAIQECQAJAIAMEQANAAkAgASACaiwAACIFrSEUAkAgBUEASARAQQMhBiABQQpHDQEMBQsgEkLAAFoEQEEDIQYMBQsgFEL/AYMgEoYgE4QiEqchBSASQoCAgIAQVA0BIAFBAWohCSASQiCIpyEKQQAhBgwECyAUQv8AgyAShiAThCETIBJCB3whEiADIAFBAWoiAUcNAQwDCwsgB0EOOgAAIAcgBTYCBAwCCyAHQQ46AAAgB0EANgIEDAELIAdC/////w83AxAgByAKNgIMIAcgBTYCCCAHIAk2AgQgByAGOgAACyAHLQAAIgFBDkcEQCAHQdAAaiAHQRBqKQMANwMAIAdB2ABqIAdBGGopAwA3AwAgByAHLQADOgBDIAcgBy8AATsAQSAHIAcpAwg3A0ggByAHKAIENgJEIAcgAToAQCAAIAdBQGsQ0SEMAgsgBygCBAsgBCgCCCIFahCOLSAEKAIIIgYgBUkNASAHQSBqIQsgAiEBIAQoAgQgBWohDSAGIAVrIQVBACEGQQAhCUIAIRJCACETQQAhAgJAAkAgAwRAA0ACQCABIAlqIg8sAAAiCq0hFAJAIApBAEgEQEEDIQQgCUEKRw0BDAULIBJCwABaBEBBAyEEDAULIAlBAWohBiAUQv8BgyAShiAThCITpyEKIBNCgICAgBBUDQEgE0IgiKchCEEAIQQMBAsgFEL/AIMgEoYgE4QhEyASQgd8IRIgAyAJQQFqIglHDQEMAwsLAkAgBSAKTwRAIAMgCU0NAUEAIQECQAJAIAkgA0EBa0cEQCADIAlrIRAgCUF/cyADaiIOrSEVA0AgDEEBaiEGAkACfgJAAkACQAJAAn8CQAJAAkAgDCAPaiIEQQFqLQAAIgVBA3FFBEAgBUECdkEBaiIIrSESAkAgBUE/TQRAIAxBEWogDksgAUEQaiAKS3INASABIA1qIgVBCGogBEEKaikAADcAACAFIARBAmopAAA3AAAgBiAIaiEMIAEgCGohAQwMCyAFQewBTQ0AIAytQgV8IBVWDQIgCEE8ayIFQQJ0Qdyd/gBqKAIAIARBAmooAABxrUIBfCESIAUgBmohBgsgEiAGQX9zIBBqrSIUViASIAogAWsiCK1Wcg0IIBKnIgQEQCABIA1qIAYgD2pBAWogBPwKAAALIAEgBGohASAEIAZqIQwMCgsgBUEBdEHwnf4Aai8BACIIQQt2IQUCQAJ+AkAgDiAMQQVqSQRAAkACQCAFQQFrDgIAAQMLIAYgDkkNBEIBDAMLQgIgDiAMQQJqTQ0CGiAQIAxrQQJrQQFNDQUgBEECai8AAAwHCyAIQYDQAEkNBSAFQQVBkKL+ABDDIQALIAWtCyETIAMgDGsgCWtBAmshAUEGIQkMBQsgBEECai0AAAwDCyAKIAFrIQggAyAMayAJa0ECa60hFEIEDAcLQQIgAyAMayAJa0ECa0HonP4AELA7AAsgBUECdEHcnf4AaigCACAEQQJqKAAAcQshAgJAAkACQAJAIAIgCEGADnFyIgJBAWsgAUkEQCAFIAZqIQwgCEH/AXEiBiABaiEEIAJBCEkgBkEQS3JFIAFBEGogCk1xDQEgCiAEQRhqSQRAIAQgCksNAyAGRQ0IIAEgCiABIApLGyEFIA0gAmshCEEAIAJrIREDQCABIBFqIApPDQUgASAFRwRAIAEgDWogASAIai0AADoAACABQQFqIQEgBkEBayIGDQEMCgsLIAUgCkGAov4AEMMhAAsgASANaiIGIAJrIQggAiIFQQ9LDQYDQCAIKQAAIRIgBkEIaiAIQQhqKQAANwAAIAYgEjcAACABIAVqIQEgBSAGaiIGIAhrIgVBD00NAAsMBgsgAq0hE0EIIQkMAwsgASANaiIBIAEgAmsiBSkAADcAACABIAUpAAg3AAgMBQsgCiABayEBIAatIRNBByEJDAELIAEgAmsgCkHwof4AEMMhAAsLIAGtIRQMBwsgASAETw0AA0AgBiAIKQAANwAAIAZBCGogCEEIaikAADcAACAGQRBqIQYgCEEQaiEIIAFBEGoiASAESQ0ACwsgBCEBDAILIBILIRMgCK0hEkEFIQkMAwsgDCAOSQ0ACwsgASAKRg0BIAGtIRRBBCEJCyALIBI3AxggCyAUNwMQIAsgEzcDCCALIAI2AgQgCyAJOgAADAULIAtBDjoAACALIAo2AgQMBAsgCyATNwMQIAtBAToAACALIAWtNwMIDAMLIAYgA0HMnf4AEK87AAsgC0ECOgAADAELIAtC/////w83AxAgCyAINgIMIAsgCjYCCCALIAY2AgQgCyAEOgAACyAHLQAgQQ5HBEAgACALENEhDAELIAAgBygCJDYCBCAAQQg2AgALIAdB4ABqJAAPCyAFIAZB1IrPABCvOwALlQICBH8BfiMAQRBrIgQkAAJAAkACQAJAAkACQCABKAJAIAJLBEAgASgCPCACQQR0aiICKQMApyIFQQ1JDQEgAikDCCIHQiCIpyECIAenIgMgASgCTE8EQCACIAVqIgMgAkkNAyADIAEoAlgiBksNBCABKAJUIAJqIQEMBwsgBEEIaiABKAJIIANBDGxqENw7IAIgBWoiASACSQ0EIAEgBCgCDCIDSw0FIAQoAgggAmohAQwGC0GkxoUBELI7AAsgAkEEaiEBDAQLIAIgA0G0xoUBELE7AAsgAyAGQbTGhQEQsDsACyACIAFBxMaFARCxOwALIAEgA0HExoUBELA7AAsgACAFNgIEIAAgATYCACAEQRBqJAAL9gEBAn9BBiEFIwBBIGsiBCQAIARBBjYCACAEQQY2AgQgACgCACABQQUgACgCBCgCDBEGACEBIARBADoADSAEIAE6AAwgBCAANgIIA0AgBEEIaiACKAIAIAJBBGooAgAgA0H09okBEIgSIQEgA0EIaiEDIAJBCGohAiAFQQFrIgUNAAsgBC0ADSICIAQtAAwiA3IhAAJAIAJBAXFFIANBAXFyDQAgASgCACIALQAKQYABcUUEQCAAKAIAQdfxiQFBAiAAKAIEKAIMEQYAIQAMAQsgACgCAEHW8YkBQQEgACgCBCgCDBEGACEACyAEQSBqJAAgAEEBcQuIAgEFfyAAKAIAIgQgACgCBCIGIAGnIgdxIgNqKQAAQoCBgoSIkKDAgH+DIgFQBEBBCCEFA0AgAyAFaiEDIAVBCGohBSAEIAMgBnEiA2opAABCgIGChIiQoMCAf4MiAVANAAsLIAQgAXqnQQN2IANqIAZxIgNqLAAAIgVBAE4EQCAEIAQpAwBCgIGChIiQoMCAf4N6p0EDdiIDai0AACEFCyADIARqIAdBGXYiBzoAACAEIANBCGsgBnFqQQhqIAc6AAAgACAAKAIIIAVBAXFrNgIIIAAgACgCDEEBajYCDCAEIANBdGxqIgBBDGsiAyACKQIANwIAIANBCGogAkEIaigCADYCACAAC6ICAQV/A0AgACgCACICQR91IAJB/////wdrcSICQQFrQQNPBEACQAJAAkACQAJAIAJBAWsOBAAAAAIBCwALIAAoAhhBgICAgHhGDQIgASgCDCIELwEAQQFrIQUgACgCHCIGIAAoAiBBAXRqIQAgASgCBCgCACABKAIIKAIAayECIAEoAgAoAgAiAyEBA0AgACAGRg0CIABBAmsiAC8BACAELwEARw0AIAJFIAEgA3JFcg0CIAJBAWshAiABIAMgARtBAWsiAQ0AIAAgBTsBAAwACwALIAAoAgwiAkUNACAAKAIIIQAgAkHIAGwhAgNAIAAgARD7EiAAQcgAaiEAIAJByABrIgINAAsLDwtBlMTNABCyOwAFIAAoAgQhAAwBCwALAAv/AQQCfwR8AX0BfiMAQSBrIgMkACADIAE2AgQgAUGAgARGBEBBACEBA0ACfQJAIAFBgIAQRwRAIAAgAWogAUEEaiEBKAIAIgJFDQMgArghByACQYACSQ0BIAKzEOoSDAILAn0gBPwHIglCgAJaBEAgCbUQ6hIMAQsgCadBAnRBwIfzAGoqAgALIQggA0EgaiQAIAZEAAAAAAAAMECiIAWgIAQgCLuioA8LIAJBAnRBwIfzAGoqAgALIQggBkQAAAAAAADwP6AhBiAEIAegIQQgBSAHIAi7oqEhBQwACwALIANBADYCCEEAIANBBGpBmJvWACADQQhqQZyb1gAQrysAC4ECAQR/IAAgASACEKE2AkAgACgCGARAIAAoAigiBEEBaiIFQQN2IAVBB3FBAEdqIgEgACgCJCICSwRAIAEgAmshBiAAKAIcIgMgAUkEQCAAQRhqIANBAXQiAiABEM0qIgMgAiADSxsQ6BkgACgCJCECCyAGBEAgACgCICACakEAIAb8CwALIAAgATYCJAsgACAFNgIoIAAoAiAgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAAgACgCLEEBajYCLAsgACgCCCECIAAoAhQiASAAKAIMRgRAIABBDGpBoL7/ABCdKAsgACgCECABQQJ0aiACNgIAIAAgAUEBajYCFAuDAgIEfwF+IAAgASACEKE2AkAgACgCGARAIAAoAigiBEEBaiIFQQN2IAVBB3FBAEdqIgEgACgCJCICSwRAIAEgAmshBiAAKAIcIgMgAUkEQCAAQRhqIANBAXQiAiABEM0qIgMgAiADSxsQ6BkgACgCJCECCyAGBEAgACgCICACakEAIAb8CwALIAAgATYCJAsgACAFNgIoIAAoAiAgBEEDdmoiASABLQAAQQEgBEEHcXRyOgAADAELIAAgACgCLEEBajYCLAsgADUCCCEHIAAoAhQiASAAKAIMRgRAIABBDGpBoL7/ABCzKAsgACgCECABQQN0aiAHNwMAIAAgAUEBajYCFAuVCwEOfyMAQYABayIMJAACQAJAIAFBAkkNACABQSBLDQEgASABQQF2IgMgAUESSSILGyEEIAEgA2shByAAIANBAnRqIQogACEDA0ACfyAEQQxNBEBBASAEQQhNDQEaAkAgBEEJTwRAIANBAEEDIAIQ5xsgA0EBQQcgAhDnGyADQQJBBSACEOcbIANBBEEIIAIQ5xsgA0EAQQcgAhDnGyADQQJBBCACEOcbIANBA0EIIAIQ5xsgA0EFQQYgAhDnGyADQQBBAiACEOcbIANBAUEDIAIQ5xsgA0EEQQUgAhDnGyADQQdBCCACEOcbIANBAUEEIAIQ5xsgA0EDQQYgAhDnGyADQQVBByACEOcbIANBAEEBIAIQ5xsgA0ECQQQgAhDnGyADQQNBBSACEOcbIANBBkEIIAIQ5xsgA0ECQQMgAhDnGyADQQRBBSACEOcbIANBBkEHIAIQ5xsgA0EBQQIgAhDnGyADQQNBBCACEOcbIANBBUEGIAIQ5xsMAQsAC0EJDAELAkAgBEENTwRAIANBAEEMIAIQ5xsgA0EBQQogAhDnGyADQQJBCSACEOcbIANBA0EHIAIQ5xsgA0EFQQsgAhDnGyADQQZBCCACEOcbIANBAUEGIAIQ5xsgA0ECQQMgAhDnGyADQQRBCyACEOcbIANBB0EJIAIQ5xsgA0EIQQogAhDnGyADQQBBBCACEOcbIANBAUECIAIQ5xsgA0EDQQYgAhDnGyADQQdBCCACEOcbIANBCUEKIAIQ5xsgA0ELQQwgAhDnGyADQQRBBiACEOcbIANBBUEJIAIQ5xsgA0EIQQsgAhDnGyADQQpBDCACEOcbIANBAEEFIAIQ5xsgA0EDQQggAhDnGyADQQRBByACEOcbIANBBkELIAIQ5xsgA0EJQQogAhDnGyADQQBBASACEOcbIANBAkEFIAIQ5xsgA0EGQQkgAhDnGyADQQdBCCACEOcbIANBCkELIAIQ5xsgA0EBQQMgAhDnGyADQQJBBCACEOcbIANBBUEGIAIQ5xsgA0EJQQogAhDnGyADQQFBAiACEOcbIANBA0EEIAIQ5xsgA0EFQQcgAhDnGyADQQZBCCACEOcbIANBAkEDIAIQ5xsgA0EEQQUgAhDnGyADQQZBByACEOcbIANBCEEJIAIQ5xsgA0EDQQQgAhDnGyADQQVBBiACEOcbDAELAAtBDQsiBUEBayAETw0CIAQgBUcEQCAFQQJ0IQUgBEECdCEEA0AgAyADIAVqIAIQuBUgBCAFQQRqIgVHDQALCyALDQEgACADRiAHIQQgCiEDDQALIAFBAnRBBGsiByAMIgRqIQsgByAAIgNqIQogAyABQQF2Ig1BAnRqIgdBBGshBSACKAIAIQICQAJAAkACQAJAA0AgBygCACIIIAIoAgQiBk8NASADKAIAIgkgBk8NAiAEIAggCSACKAIAIgYgCEECdGooAgAiDiAGIAlBAnRqKAIAIg9IIhAbNgIAIAooAgAiCCACKAIEIgZPDQMgBSgCACIJIAZPDQQgAyAOIA9OQQJ0aiEDIAcgEEECdGohByAEQQRqIQQgCyAJIAggAigCACIGIAhBAnRqKAIAIgggBiAJQQJ0aigCACIGSCIJGzYCACAFQXxBACAJG2ohBSAKQXxBACAGIAhMG2ohCiALQQRrIQsgDUEBayINDQALIAVBBGohAiABQQFxBH8gBCADIAcgAiADSyIEGygCADYCACAHIAIgA01BAnRqIQcgAyAEQQJ0agUgAwsgAkYgByAKQQRqRnENBBDkKwALIAggBkGov4MBEMMhAAsgCSAGQbi/gwEQwyEACyAIIAZBqL+DARDDIQALIAkgBkG4v4MBEMMhAAsgAUECdCIBRQ0AIAAgDCAB/AoAAAsgDEGAAWokAA8LAAuXCwIMfwJ+IwBBgAFrIgwkAAJAAkAgAUECSQ0AIAFBIEsNASABIAFBAXYiAyABQRJJIgsbIQQgASADayEGIAAgA0ECdGohCiAAIQMDQAJ/IARBDE0EQEEBIARBCE0NARoCQCAEQQlPBEAgA0EAQQMgAhDpGyADQQFBByACEOkbIANBAkEFIAIQ6RsgA0EEQQggAhDpGyADQQBBByACEOkbIANBAkEEIAIQ6RsgA0EDQQggAhDpGyADQQVBBiACEOkbIANBAEECIAIQ6RsgA0EBQQMgAhDpGyADQQRBBSACEOkbIANBB0EIIAIQ6RsgA0EBQQQgAhDpGyADQQNBBiACEOkbIANBBUEHIAIQ6RsgA0EAQQEgAhDpGyADQQJBBCACEOkbIANBA0EFIAIQ6RsgA0EGQQggAhDpGyADQQJBAyACEOkbIANBBEEFIAIQ6RsgA0EGQQcgAhDpGyADQQFBAiACEOkbIANBA0EEIAIQ6RsgA0EFQQYgAhDpGwwBCwALQQkMAQsCQCAEQQ1PBEAgA0EAQQwgAhDpGyADQQFBCiACEOkbIANBAkEJIAIQ6RsgA0EDQQcgAhDpGyADQQVBCyACEOkbIANBBkEIIAIQ6RsgA0EBQQYgAhDpGyADQQJBAyACEOkbIANBBEELIAIQ6RsgA0EHQQkgAhDpGyADQQhBCiACEOkbIANBAEEEIAIQ6RsgA0EBQQIgAhDpGyADQQNBBiACEOkbIANBB0EIIAIQ6RsgA0EJQQogAhDpGyADQQtBDCACEOkbIANBBEEGIAIQ6RsgA0EFQQkgAhDpGyADQQhBCyACEOkbIANBCkEMIAIQ6RsgA0EAQQUgAhDpGyADQQNBCCACEOkbIANBBEEHIAIQ6RsgA0EGQQsgAhDpGyADQQlBCiACEOkbIANBAEEBIAIQ6RsgA0ECQQUgAhDpGyADQQZBCSACEOkbIANBB0EIIAIQ6RsgA0EKQQsgAhDpGyADQQFBAyACEOkbIANBAkEEIAIQ6RsgA0EFQQYgAhDpGyADQQlBCiACEOkbIANBAUECIAIQ6RsgA0EDQQQgAhDpGyADQQVBByACEOkbIANBBkEIIAIQ6RsgA0ECQQMgAhDpGyADQQRBBSACEOkbIANBBkEHIAIQ6RsgA0EIQQkgAhDpGyADQQNBBCACEOkbIANBBUEGIAIQ6RsMAQsAC0ENCyIFQQFrIARPDQIgBCAFRwRAIAVBAnQhBSAEQQJ0IQQDQCADIAMgBWogAhC3FSAEIAVBBGoiBUcNAAsLIAsNASAAIANGIAYhBCAKIQMNAAsgAUECdEEEayIGIAwiBGohCyAGIAAiA2ohCiADIAFBAXYiDUECdGoiBkEEayEFIAIoAgAhAgJAAkACQAJAAkADQCAGKAIAIgggAigCBCIHTw0BIAMoAgAiCSAHTw0CIAQgCCAJIAIoAgAiByAIQQN0aikDACIPIAcgCUEDdGopAwAiEFMiDhs2AgAgCigCACIIIAIoAgQiB08NAyAFKAIAIgkgB08NBCADIA8gEFlBAnRqIQMgBiAOQQJ0aiEGIARBBGohBCALIAkgCCACKAIAIgcgCEEDdGopAwAiDyAHIAlBA3RqKQMAIhBTIggbNgIAIAVBfEEAIAgbaiEFIApBfEEAIA8gEFkbaiEKIAtBBGshCyANQQFrIg0NAAsgBUEEaiECIAFBAXEEfyAEIAMgBiACIANLIgQbKAIANgIAIAYgAiADTUECdGohBiADIARBAnRqBSADCyACRiAGIApBBGpGcQ0EEOQrAAsgCCAHQai/gwEQwyEACyAJIAdBuL+DARDDIQALIAggB0Gov4MBEMMhAAsgCSAHQbi/gwEQwyEACyABQQJ0IgFFDQAgACAMIAH8CgAACyAMQYABaiQADwsAC5cLAgx/An4jAEGAAWsiDCQAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIDIAFBEkkiCxshBCABIANrIQYgACADQQJ0aiEKIAAhAwNAAn8gBEEMTQRAQQEgBEEITQ0BGgJAIARBCU8EQCADQQBBAyACEOobIANBAUEHIAIQ6hsgA0ECQQUgAhDqGyADQQRBCCACEOobIANBAEEHIAIQ6hsgA0ECQQQgAhDqGyADQQNBCCACEOobIANBBUEGIAIQ6hsgA0EAQQIgAhDqGyADQQFBAyACEOobIANBBEEFIAIQ6hsgA0EHQQggAhDqGyADQQFBBCACEOobIANBA0EGIAIQ6hsgA0EFQQcgAhDqGyADQQBBASACEOobIANBAkEEIAIQ6hsgA0EDQQUgAhDqGyADQQZBCCACEOobIANBAkEDIAIQ6hsgA0EEQQUgAhDqGyADQQZBByACEOobIANBAUECIAIQ6hsgA0EDQQQgAhDqGyADQQVBBiACEOobDAELAAtBCQwBCwJAIARBDU8EQCADQQBBDCACEOobIANBAUEKIAIQ6hsgA0ECQQkgAhDqGyADQQNBByACEOobIANBBUELIAIQ6hsgA0EGQQggAhDqGyADQQFBBiACEOobIANBAkEDIAIQ6hsgA0EEQQsgAhDqGyADQQdBCSACEOobIANBCEEKIAIQ6hsgA0EAQQQgAhDqGyADQQFBAiACEOobIANBA0EGIAIQ6hsgA0EHQQggAhDqGyADQQlBCiACEOobIANBC0EMIAIQ6hsgA0EEQQYgAhDqGyADQQVBCSACEOobIANBCEELIAIQ6hsgA0EKQQwgAhDqGyADQQBBBSACEOobIANBA0EIIAIQ6hsgA0EEQQcgAhDqGyADQQZBCyACEOobIANBCUEKIAIQ6hsgA0EAQQEgAhDqGyADQQJBBSACEOobIANBBkEJIAIQ6hsgA0EHQQggAhDqGyADQQpBCyACEOobIANBAUEDIAIQ6hsgA0ECQQQgAhDqGyADQQVBBiACEOobIANBCUEKIAIQ6hsgA0EBQQIgAhDqGyADQQNBBCACEOobIANBBUEHIAIQ6hsgA0EGQQggAhDqGyADQQJBAyACEOobIANBBEEFIAIQ6hsgA0EGQQcgAhDqGyADQQhBCSACEOobIANBA0EEIAIQ6hsgA0EFQQYgAhDqGwwBCwALQQ0LIgVBAWsgBE8NAiAEIAVHBEAgBUECdCEFIARBAnQhBANAIAMgAyAFaiACELoVIAQgBUEEaiIFRw0ACwsgCw0BIAAgA0YgBiEEIAohAw0ACyABQQJ0QQRrIgYgDCIEaiELIAYgACIDaiEKIAMgAUEBdiINQQJ0aiIGQQRrIQUgAigCACECAkACQAJAAkACQANAIAYoAgAiCCACKAIEIgdPDQEgAygCACIJIAdPDQIgBCAIIAkgAigCACIHIAhBA3RqKQMAIg8gByAJQQN0aikDACIQVCIOGzYCACAKKAIAIgggAigCBCIHTw0DIAUoAgAiCSAHTw0EIAMgDyAQWkECdGohAyAGIA5BAnRqIQYgBEEEaiEEIAsgCSAIIAIoAgAiByAIQQN0aikDACIPIAcgCUEDdGopAwAiEFQiCBs2AgAgBUF8QQAgCBtqIQUgCkF8QQAgDyAQWhtqIQogC0EEayELIA1BAWsiDQ0ACyAFQQRqIQIgAUEBcQR/IAQgAyAGIAIgA0siBBsoAgA2AgAgBiACIANNQQJ0aiEGIAMgBEECdGoFIAMLIAJGIAYgCkEEakZxDQQQ5CsACyAIIAdBqL+DARDDIQALIAkgB0G4v4MBEMMhAAsgCCAHQai/gwEQwyEACyAJIAdBuL+DARDDIQALIAFBAnQiAUUNACAAIAwgAfwKAAALIAxBgAFqJAAPCwALlQsBDn8jAEGAAWsiDCQAAkACQCABQQJJDQAgAUEgSw0BIAEgAUEBdiIDIAFBEkkiCxshBCABIANrIQcgACADQQJ0aiEKIAAhAwNAAn8gBEEMTQRAQQEgBEEITQ0BGgJAIARBCU8EQCADQQBBAyACEOgbIANBAUEHIAIQ6BsgA0ECQQUgAhDoGyADQQRBCCACEOgbIANBAEEHIAIQ6BsgA0ECQQQgAhDoGyADQQNBCCACEOgbIANBBUEGIAIQ6BsgA0EAQQIgAhDoGyADQQFBAyACEOgbIANBBEEFIAIQ6BsgA0EHQQggAhDoGyADQQFBBCACEOgbIANBA0EGIAIQ6BsgA0EFQQcgAhDoGyADQQBBASACEOgbIANBAkEEIAIQ6BsgA0EDQQUgAhDoGyADQQZBCCACEOgbIANBAkEDIAIQ6BsgA0EEQQUgAhDoGyADQQZBByACEOgbIANBAUECIAIQ6BsgA0EDQQQgAhDoGyADQQVBBiACEOgbDAELAAtBCQwBCwJAIARBDU8EQCADQQBBDCACEOgbIANBAUEKIAIQ6BsgA0ECQQkgAhDoGyADQQNBByACEOgbIANBBUELIAIQ6BsgA0EGQQggAhDoGyADQQFBBiACEOgbIANBAkEDIAIQ6BsgA0EEQQsgAhDoGyADQQdBCSACEOgbIANBCEEKIAIQ6BsgA0EAQQQgAhDoGyADQQFBAiACEOgbIANBA0EGIAIQ6BsgA0EHQQggAhDoGyADQQlBCiACEOgbIANBC0EMIAIQ6BsgA0EEQQYgAhDoGyADQQVBCSACEOgbIANBCEELIAIQ6BsgA0EKQQwgAhDoGyADQQBBBSACEOgbIANBA0EIIAIQ6BsgA0EEQQcgAhDoGyADQQZBCyACEOgbIANBCUEKIAIQ6BsgA0EAQQEgAhDoGyADQQJBBSACEOgbIANBBkEJIAIQ6BsgA0EHQQggAhDoGyADQQpBCyACEOgbIANBAUEDIAIQ6BsgA0ECQQQgAhDoGyADQQVBBiACEOgbIANBCUEKIAIQ6BsgA0EBQQIgAhDoGyADQQNBBCACEOgbIANBBUEHIAIQ6BsgA0EGQQggAhDoGyADQQJBAyACEOgbIANBBEEFIAIQ6BsgA0EGQQcgAhDoGyADQQhBCSACEOgbIANBA0EEIAIQ6BsgA0EFQQYgAhDoGwwBCwALQQ0LIgVBAWsgBE8NAiAEIAVHBEAgBUECdCEFIARBAnQhBANAIAMgAyAFaiACELkVIAQgBUEEaiIFRw0ACwsgCw0BIAAgA0YgByEEIAohAw0ACyABQQJ0QQRrIgcgDCIEaiELIAcgACIDaiEKIAMgAUEBdiINQQJ0aiIHQQRrIQUgAigCACECAkACQAJAAkACQANAIAcoAgAiCCACKAIEIgZPDQEgAygCACIJIAZPDQIgBCAIIAkgAigCACIGIAhBAnRqKAIAIg4gBiAJQQJ0aigCACIPSSIQGzYCACAKKAIAIgggAigCBCIGTw0DIAUoAgAiCSAGTw0EIAMgDiAPT0ECdGohAyAHIBBBAnRqIQcgBEEEaiEEIAsgCSAIIAIoAgAiBiAIQQJ0aigCACIIIAYgCUECdGooAgAiBkkiCRs2AgAgBUF8QQAgCRtqIQUgCkF8QQAgBiAITRtqIQogC0EEayELIA1BAWsiDQ0ACyAFQQRqIQIgAUEBcQR/IAQgAyAHIAIgA0siBBsoAgA2AgAgByACIANNQQJ0aiEHIAMgBEECdGoFIAMLIAJGIAcgCkEEakZxDQQQ5CsACyAIIAZBqL+DARDDIQALIAkgBkG4v4MBEMMhAAsgCCAGQai/gwEQwyEACyAJIAZBuL+DARDDIQALIAFBAnQiAUUNACAAIAwgAfwKAAALIAxBgAFqJAAPCwALogIBBn8jAEGgAmsiAiQAIAJB7AFqIAFBCGooAgA2AgAgAkEAOwGcAiACQQA2ApgCIAJBADYCgAIgAkEANgL0ASACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAiABKQIANwLkASACIAEoAjA2AvABIAJB6ABqIgUgAkHEAWoiBiABQRRqEMIZQcQAQQQQrTYiAwRAIAMgASgCDCIEIAEoAhAiBygCCEEBa0F4cWpBCGogBygCFBEAACACQQE2AswBIAIgAzYCyAEgAkEBNgLEASACQQxqIgMgBSAGEPwiIAAgAxDNHCAEIAQoAgAiAEEBazYCACAAQQFGBEAgAUEMahC7IwsgAkGgAmokAA8LQQRBxAAQoz0AC/YBAQZ/IwBBIGsiBCQAIAEgA08EQCAEIAA2AgggBCAAIANBAnRqIgY2AgwCQCADIARBCGoQnjYiByADIAdJGyIHRQ0AA0AgACAFIAAoAgAiCCACKAIAaiIFaiIJNgIAIAUgCEkgBSAJS3IhBSAAQQRqIQAgAkEEaiECIAdBAWsiBw0ACyAFRQ0AIAFBAnQgA0ECdGshAANAIABFDQEgBiAGKAIAQQFqIgE2AgAgAEEEayEAIAZBBGohBiABRQ0ACwsgBEEgaiQADwsgBEEANgIYIARBATYCDCAEQfCliAE2AgggBEIENwIQIARBCGpBpKaIARDvLAAL1AECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgRLBEBBACECDAELQQAhAkEIIAQgACgCACIFQQF0IgEgASAESRsiASABQQhNGyIErSIHQiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMgBTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIaiAGIANBFGoQohsgAygCCEEBRw0BIAMoAhAhASADKAIMIQILIAIgAUGgqIkBEP0vAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC5ICAQN/IwBBQGoiAiQAIAIgATYCCAJAIAEuARgiBEEATARAIAJBgYCAgHg2AgwMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBDGogAkEIaiADEJUSCyABLgEaIQMgAkE8aiIEQQA2AgAgAkKAgICAgAE3AjQgAkE0akEBEIctIABBADYCtAIgAEKAgICAEDcCrAIgAEGoAmogBCgCADYCACAAIAIpAjQ3AqACIAAgATYC7AIgAEG4AmogAkEMakEo/AoAACAAQgI3AuQCIAAgA0EATEEfdDYC4AIgAEIANwPwAiAAQgU3AwAgAkFAayQAC5ICAQN/IwBBQGoiAiQAIAIgATYCCAJAIAEuARgiBEEATARAIAJBgYCAgHg2AgwMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBDGogAkEIaiADEJUSCyABLgEaIQMgAkE8aiIEQQA2AgAgAkKAgICAwAA3AjQgAkE0akEBEIYtIABBADYCtAIgAEKAgICAEDcCrAIgAEGoAmogBCgCADYCACAAIAIpAjQ3AqACIAAgATYC7AIgAEG4AmogAkEMakEo/AoAACAAQgI3AuQCIAAgA0EATEEfdDYC4AIgAEIANwPwAiAAQgU3AwAgAkFAayQAC8YCAgR/AX4jAEEQayIDJAACf0GAgICAeCABKALgASICQYGAgIB4Rg0AGkGAgICAeCACQYCAgIB4Rg0AGiABKQLkASEGIAFBADYC6AEgAUKAgICAIDcD4AEgAgshAiABKAKkAiEEIAFBuAJqELQwIAEgBjcCvAIgASACNgK4AiABKAKUAiICQYCAgIB4RwRAIAEpA5gCIQYgAUEANgKcAiABQoCAgIAgNwKUAgsgAUHEAmoQtDAgASAGNwPIAiABIAI2AsQCIANBBGoiBSABENYYAkAgAygCBCICRQ0AIAIgAigCACICQQFrNgIAIAJBAUcNACAFEPseCyABQgA3AqQCQQxBBBCtNiIBRQRAQQRBDBCjPQALIAEgBDYCCCABQoGAgIAQNwIAIABBgNjNADYCCCAAIAE2AgQgAEEINgIAIANBEGokAAufAgEBfyMAQSBrIgUkAAJAAkACQCADIARxIgMgAk0EQCAFQQA2AgQgAiADa0EDTQ0BIAVBBGpBBCABIANqQQRBtNnOABDVLCAFKAIEQb3P1vEBbEERdiIBIAAoAgQiAk8NAiAAKAIAIAFBAXRqIgItAAAgAUEIdHIiASAAKAIMIgNJDQMgASADQZTLzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakH0ys4AEO8sAAsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpBpNnOABDvLAALIAEgAkGEy84AEMMhAAsgACgCCCABQQJ0aiAENgIAIAIgAi8BAEEBajsBACAFQSBqJAALggMBCH8jAEFAaiICJAAgAkEIaiABEIIoAkACQCACKAIIIgUEQCACKAIMIQYgAkEgaiIHQQRBAEEEQQgQoBggAigCJCEDIAIoAiBBAUYNAiACKAIoIgQgBjYCBCAEIAU2AgAgAkEcaiIIQQE2AgAgAiAENgIYIAIgAzYCFCACQThqIAFBGGopAgA3AwAgAkEwaiABQRBqKQIANwMAIAJBKGogAUEIaikCADcDACACIAEpAgA3AyAgAkEUaiEDIwBBEGsiASQAIAFBCGogBxCCKCABKAIIIgQEQCABKAIMIQUDQCADKAIIIgYgAygCAEYEQCADQQEQ6i0LIAMoAgQgBkEDdGoiCSAFNgIEIAkgBDYCACADIAZBAWo2AgggASAHEIIoIAEoAgQhBSABKAIAIgQNAAsLIAFBEGokACAAQQhqIAgoAgA2AgAgACACKQIUNwIADAELIABBADYCCCAAQoCAgIDAADcCAAsgAkFAayQADwsgAyACKAIoQbi1gAEQ/S8AC/EEAgt/AX4jAEEgayIHJAACQCABKAIAQQFGBEAgASgCFCEFIAEoAhAhCCABKQMIIQ4gAigCCCEDIAIoAgQhBCACKAIAIgFBDGoQ9DUhDSAHQQxqIQYjAEEQayICJAACQAJAAkAgAyABKAIoRgRAIAEgBCADEKE2AkAgASgCDARAIAEoAhwiCkEBaiILQQN2IAtBB3FBAEdqIgMgASgCGCIESwRAIAMgBGshDCABKAIQIgkgA0kEQCABQQxqIAlBAXQiBCADQcD///8DcUFAayADIANBP3EbIgkgBCAJSxsQ6BkgASgCGCEECyAMBEAgASgCFCAEakEAIAz8CwALIAEgAzYCGAsgASALNgIcIAEoAhQgCkEDdmoiASABLQAAQQEgCkEHcXRyOgAADAELIAEgASgCIEEBajYCIAsgBkGTgICAeDYCAAwBCyACQQRqQdAAQQBBAUEBEKAYIAIoAgghASACKAIEQQFGDQEgAigCDCIDQYi2gAFB0AD8CgAAIAZB0AA2AgwgBiADNgIIIAYgATYCBCAGQY2AgIB4NgIACyACQRBqJAAMAQsgASACKAIMQfTBgAEQ/S8ACyAHKAIMQZOAgIB4RwRAIAYQiBELIAUoAgAiASAIaiICLQAAIQMgAiAOp0EZdiICOgAAIAEgBSgCBCAIQQhrcWpBCGogAjoAACAAIAU2AgwgACAONwMAIAUgBSgCDEEBajYCDCAAIAEgCEECdGsiADYCCCAFIAUoAgggA0EBcWs2AgggAEEEayANNgIADAELIAAgAUEIaiIBKQMANwMAIABBCGogAUEIaikDADcDAAsgB0EgaiQAC6ECAQJ/IwBBsAFrIgckACAHQfgAaiABQQhqKAIANgIAIAdBiAFqIARBCGooAgA2AgAgB0HgAGoiCCAFQQhqKAIANgIAIAdB7ABqIAZBCGooAgA2AgAgByACNgJ8IAcgAzYCVCAHQQA2AlAgB0EANgKkASAHQQA2AowBIAcgASkCADcCcCAHIAQpAgA3AoABIAcgBSkCADcCWCAHIAYpAgA3AmQgB0GAAjsBqAEgB0EMaiIBIAdB0ABqEN8HIAcoAgxBgICAgHhHBEAgACABQcQA/AoAACAHQbABaiQADwsgCCAHQSBqKAIANgIAIAdB2ABqIAdBGGopAgA3AwAgByAHKQIQNwNQQejahgFBKyAHQdAAakGU24YBQZDjhgEQ1R4AC40CAQZ/IwBBEGsiBiQAIAZBCGogARCGPSAGKAIMIQogBigCCCIIQQgQ+C8hBQJAAkACQAJAIAMgAyAEaiIJQQFqIgdNBEAgByAAKAIEIgRLDQEgAUEIIAUgCGogBSAKSyIIG0EAIAogBWtBA3YgCBtBA3RqQQhrKQMAIAAoAgAiACADQQN0aiIFIAcgA2sQ+BMgASgCKEUNAiADIARPDQMgBCAJSw0EIAkgBEHUoocBEMMhAAsgAyAHQaSihwEQsTsACyAHIARBpKKHARCwOwALQQBBAEG0oocBEMMhAAsgAyAEQcSihwEQwyEACyABKAIkIAIgBSgCACAAIAlBA3RqKAIAENgbIAZBEGokAAuNAgEGfyMAQRBrIgYkACAGQQhqIAEQhj0gBigCDCEKIAYoAggiCEEEEPgvIQUCQAJAAkACQCADIAMgBGoiCUEBaiIHTQRAIAcgACgCBCIESw0BIAFBBCAFIAhqIAUgCksiCBtBACAKIAVrQQJ2IAgbQQJ0akEEaygCACAAKAIAIgAgA0ECdGoiBSAHIANrEPkTIAEoAihFDQIgAyAETw0DIAQgCUsNBCAJIARB1KKHARDDIQALIAMgB0GkoocBELE7AAsgByAEQaSihwEQsDsAC0EAQQBBtKKHARDDIQALIAMgBEHEoocBEMMhAAsgASgCJCACIAUoAgAgACAJQQJ0aigCABDYGyAGQRBqJAALjAIBA38gACgCZCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHkAGoQlxULAkAgACgCaCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQegAahDbHgsCQCAAKAIYQYCAgIB4RwRAIABBGGoQ3jsMAQsgACgCECEBIAAoAhQiAygCACICBEAgASACEQMACyADKAIEIgJFDQAgASACIAMoAggQ+DoLIAAoAighASAAKAIsIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIABB2ABqEJ4vAkAgACgCbCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQewAahCBLAsL9gECBX8BfiMAQSBrIgNBEGoiBSAAKAIEIgQgAUEFdGoiAEEIaikDADcDACADQRhqIgYgAEEQaikDADcDACADIAApAwA3AwggACkDGCEHAkACQCABRQ0AA0AgBCABQQFrQQF2IgBBBXRqIgIpAxggB1cNASAEIAFBBXRqIgEgAikDADcDACABQRhqIAJBGGopAwA3AwAgAUEQaiACQRBqKQMANwMAIAFBCGogAkEIaikDADcDACAAIgENAAsMAQsgASEACyAEIABBBXRqIgAgAykDCDcDACAAIAc3AxggAEEQaiAGKQMANwMAIABBCGogBSkDADcDAAvHAgEEfyMAQdAAayIDJAACQCABLwFEIgRBkANrQf//A3FByAFPBEAgACABQegA/AoAAAwBCyADQQhqIAEoAlBByAD8CgAAIwBBEGsiBSQAQdQAQQQQrTYiAkUEQEEEQdQAEKM9AAsgAkEANgJQIAJBADYCTCACIAQ7AUogAkEDOwFIIAJBAjYCACAFQRBqJAAgAhD5LiACIANBCGpByAD8CgAAIABCAzcDACAAIAI2AgggARDLKSABKAJAIgAEQCAAEOkmIABBEEEEEPg6CyABKAJIIgBBhAFPBEAgABDyHwsgAUHUAGoiABCaHyABKAJkIgJBhAFPBEAgAhDyHwsCQCABKAJYRQ0AIAAoAgAiAEGEAU8EQCAAEPIfCyABQeAAahCsO0UNACABQdgAahC8KgsgASgCUEHIAEEEEPg6CyADQdAAaiQAC48CAQJ/IwBBMGsiAyQAIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCCADQShqIAEgA0EIakEgENIKAkACQAJAIAMtACgiBEEERg0AA0ACQAJAAkACQAJAIARBAWsOAwACAQQLIAMtAClBI0cNAwwCCyADKAIsLQAIQSNGDQEMAgsgAygCLC0ACEEjRw0BCyADQShqIgQQuS4gBCABIANBCGpBIBDSCiADLQAoIgRBBEcNAQwCCwsgACADKQMoNwIADAELIAMoAiwiAUEhTw0BIAIgA0EIaiICIAEgAmoQvSYgAEEEOgAAIAAgATYCBAsgA0EwaiQADwsgAUEgQYDwzQAQsDsAC4sCAQJ/IwBBMGsiAyQAIANBIGpCADcDACADQRhqQgA3AwAgA0EQakIANwMAIANCADcDCCADQShqIAEgA0EIahCrGQJAAkACQCADLQAoIgRBBEYNAANAAkACQAJAAkACQCAEQQFrDgMAAgEECyADLQApQSNHDQMMAgsgAygCLC0ACEEjRg0BDAILIAMoAiwtAAhBI0cNAQsgA0EoaiIEELkuIAQgASADQQhqEKsZIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALjwIBAn8jAEEwayIDJAAgA0EgakIANwMAIANBGGpCADcDACADQRBqQgA3AwAgA0IANwMIIANBKGogASADQQhqQSAQnQsCQAJAAkAgAy0AKCIEQQRGDQADQAJAAkACQAJAAkAgBEEBaw4DAAIBBAsgAy0AKUEjRw0DDAILIAMoAiwtAAhBI0YNAQwCCyADKAIsLQAIQSNHDQELIANBKGoiBBC5LiAEIAEgA0EIakEgEJ0LIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALjwIBAn8jAEEwayIDJAAgA0EgakIANwMAIANBGGpCADcDACADQRBqQgA3AwAgA0IANwMIIANBKGogASADQQhqQSAQpwcCQAJAAkAgAy0AKCIEQQRGDQADQAJAAkACQAJAAkAgBEEBaw4DAAIBBAsgAy0AKUEjRw0DDAILIAMoAiwtAAhBI0YNAQwCCyADKAIsLQAIQSNHDQELIANBKGoiBBC5LiAEIAEgA0EIakEgEKcHIAMtACgiBEEERw0BDAILCyAAIAMpAyg3AgAMAQsgAygCLCIBQSFPDQEgAiADQQhqIgIgASACahC9JiAAQQQ6AAAgACABNgIECyADQTBqJAAPCyABQSBBgPDNABCwOwALmgIBA38jAEEQayIDJAACQCAALQBMQQFHDQAgASgCAEGAgICAeEcEQCADQQA2AgwgA0KAgICAgAE3AgQgAEEwaiEEAkAgACgCMEGAgICAeEYEQCAEEIUwIABBADYCOCAAQoCAgICAATcCMAwBCyADQQRqEOM8CyAEIAEoAggiBRDsLSAEIAEoAgQiASABIAVBA3RqEPcoCyACKAIAQYCAgIB4Rg0AIANBADYCDCADQoCAgICAATcCBCAAQTxqIQECQCAAKAI8QYCAgIB4RgRAIAEQhTAgAEEANgJEIABCgICAgIABNwI8DAELIANBBGoQ4zwLIAEgAigCCCIAEOwtIAEgAigCBCIBIAEgAEEDdGoQ9ygLIANBEGokAAv1AQEIfyMAQTBrIgEkAAJAIABFDQAgAEEQaiEFIAAoApwmIQMgACgCmCYhAiAAKAKUJiEGAkAgACAAKAIQIgdPBEAgACgCFCEEIAFBKGoiCCADNgIAIAEgAjYCJCABIAY2AiAgBUEAQSz8CwAgAUEYaiAIKAIANgIAIAEgASkDIDcDECAHIAFBEGoQiy0gACAETw0BDAILIAFBKGoiBCADNgIAIAEgAjYCJCABIAY2AiAgBUEAQSz8CwAgAUEIaiAEKAIANgIAIAEgASkDIDcDACAHIAEQiy0LIAIEQCADIAAgAhEAAAwBCyAAENI1CyABQTBqJAALhgIBCH8CfyABKAIEIgMgAksEQCAAIAEpAgw3AiQgACABKAIAIgU2AgAgAEEsaiABQRRqKAIANgIAIAMgAmshBCACIAVqIQVBACEDQQEhB0EIIQhBBCEJIAEoAggiASACagwBCyAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIAIAAgASgCDCIHIAEoAhAiBCACIANrIgYgBCAGSRsiA2o2AiQgBCADayECIAYgASgCFCIKaiEBQQAhBEEBIQVBLCEIQSghCUEACyEGIAAgCWogAjYCACAAIAhqIAE2AgAgACAGNgIgIAAgBDYCHCAAIAU2AhggACAKNgIUIAAgAzYCECAAIAc2AgwLigIBBH8jAEEQayIEJAAgBEEIaiABENYQAkAgBCgCCEEBcQRAIAQoAgwhAgNAIAIgASgCRCIDTw0CAkAgAyACQQFqIgVLBEAgASgCQCIDIAVBAnRqKAIAIAMgAkECdGooAgBrIgJBAE4NAUHMuIIBQRRB4LiCARDLJAALIAUgA0G8uIIBEMMhAAsgASgCSCIDIAMoAgAgAmoiAzYCACAAKAIIIgIgACgCAEYEQCAAIAEoAjhBAWoiBUF/IAUbEO4tCyAAKAIEIAJBAnRqIAM2AgAgACACQQFqNgIIIAQgARDWECAEKAIEIQIgBCgCAEEBcQ0ACwsgBEEQaiQADwsgAiADQay4ggEQwyEAC48CAQR/IwBBEGsiAyQAIAAoAgwiAiAAKAIEIgFrQdADbiEEIAEgAkcEQCABQcACaiEBA0AgAUGAAWoiAhDUJyACEO47IAFBwAJrENgSIAFBKGoiAigCAEGAgICAeEcEQCACEPA7CyABQTRqIgIoAgBBgICAgHhHBEAgAhDeOyABQUBrIgIQ0SsgAhDoOyABQcwAaiICENErIAIQ6DsgAUHYAGoQhTAgAUHkAGoQhTAgAUHwAGoQhTALIAEoAgBBgICAgHhHBEAgARD1OyABQQxqEIUwCyABQdADaiEBIARBAWsiBA0ACwsgAyAAKAIANgIMIAMgACgCCDYCCCADQQhqQQhB0AMQ4B4gA0EQaiQAC/UBAgN/BH4jAEEgayICJAACQAJAIAEoAgwiASgCBCIDIAEpAwgiBiADrSIFIAUgBlYbpyIDRwRAIAEoAgAgA2otAAAhBEEEIQMMAQtBqKHQACkCACIIQgiIIQcgCKchAyAIQv8Bg0IEUg0BCyAGQgF8IQULIAEgBTcDCAJAAkAgA0H/AXFBBEYNACACIAOtQv8BgyAHQgiGhDcDGCACQQRqIAJBGGoQ0AkgAigCBEEERg0AIAAgAikCBDcCACAAQRBqIAJBFGooAgA2AgAgAEEIaiACQQxqKQIANwIADAELIABBBDYCACAAIAQ6AAQLIAJBIGokAAuLAgEBfyMAQTBrIgUkACAFIAM6AA8CQCAAAn8CQAJAAkAgA0H/AXFBAmsOAgECAAsgBUEBNgIUIAVB+JXPADYCECAFQgE3AhwgBUGuAzYCLCAFIAVBKGo2AhggBSAFQQ9qNgIoIABBBGogBUEQahCZDkEADAILIAQoAghBA00NAiAAQQhqIARBBCAEKAIEKAAAQQRqIgEQ0hAgACABNgIEQQgMAQsgAEEIaiAEQcAAIAGtw3mnayACbCIBQQN2IAFBB3FBAEdqIgEQzRUgACABNgIEQQgLNgIAIARBDGogBCgCBCAEKAIIIAQoAgAoAhARAQAgBUEwaiQADwtBtLXOAEEjQdi1zgAQnykAC4YDAQZ/IwBB4AFrIgIkACACQRBqIgUgARCaHQJAAkAgAikDEEICUgRAIAJB5ABqIgQgARCtGiAEQQQgAigCZEEBaiIDQX8gAxsiAyADQQRNG0EAQQhB0AAQoBggAigCaCEDIAIoAmRBAUYNAiACKAJsIgYgBUHQAPwKAAAgAkEMaiIHQQE2AgAgAiAGNgIIIAIgAzYCBCAEIAFB/AD8CgAAIAJBBGohAyMAQeAAayIBJAAgASAEEJodIAEpAwBCAlIEQANAIAMoAggiBSADKAIARgRAIAFB1ABqIAQQrRogAyAFIAEoAlRBAWoiBkF/IAYbQQhB0AAQ0CgLIAMoAgQgBUHQAGxqIAFB0AD8CgAAIAMgBUEBajYCCCABIAQQmh0gASkDAEICUg0ACwsgBBDiJCABQeAAaiQAIABBCGogBygCADYCACAAIAIpAgQ3AgAMAQsgAEEANgIIIABCgICAgIABNwIAIAEQ4iQLIAJB4AFqJAAPCyADIAIoAmxByJfPABD9LwAL0gYCBX4FfyAAIAEgAiADIARBARDMAiIKQYh/SwRAIAoPCyACIAprIQNBRCECIAEgCmoiCyEBAkACQAJAAkACQCAAKAIADgQDAAECAQsgCyADIABBuAFqQgBBABCiDiICQYh/Sw0CIABBAjYCACACIAtqIQEgAyACayEDCyADQQRJDQIgAUEBNgAAIANBA2shAyABQQNqIQELIAAoAtwBBEACfiAAQeAEaiICKQMAIgZCIFoEQCACKQMQIgVCB4kgAikDCCIHQgGJfCACKQMYIghCDIl8IAIpAyAiCUISiXwgB0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAFQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAhCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCULP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfQwBCyACKQMYQsXP2bLx5brqJ3wLIAZ8IQUgBqciDEEYcSAMQR9xIQQgAkEoaiIOIQIDQCAEQQhPBEAgBEEIayEEIAIpAwBCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAFhUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSEFIAJBCGohAgwBCwsgDmohAiAMQQdxIgRBBE8EQCAEQQRrIQQgAjUCAEKHla+vmLbem55/fiAFhUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhBSACQQRqIQILA0AgBARAIARBAWshBCACMQAAQsXP2bLx5brqJ34gBYVCC4lCh5Wvr5i23puef34hBSACQQFqIQIMAQsLIAVCIYggBYVCz9bTvtLHq9lCfiIFQh2IIAWFQvnz3fGZ9pmrFn4iBUIgiCAFhSEFIANBBEkNAiABIAU+AAAgAUEEaiEBCyAAQQA2AgAgASALayICQYh/Sw0AAkAgACkDyAQiBVANACAFIAApA9AEQgF8UQ0AQbh/DwsgAiAKaiECCyACDwtBun8LpgQBBX8CQANAIAIoAggiBkHBAGtBcUkNASACIAQgBRDLIA0ACwJ/AkACQAJAAkACQAJAIAIoAggiBEHAAEYEQAJAIAEEQCAALQACRQ0BDAgLQQBBAEHMnvMAEMMhAAsgAC8BACEGDAELIAIpAwAgBEE/ca2IpyIKQf8BcSIHIAFPDQJBwAAgBGshCSAAIAdBAnRqIgUvAQAhBiAFLQACIgVBCU8EQCAJQQlJDQIgBUEhTw0EIAYgB2ogBUECdEH4nPMAaigCACAKcUEIdmoiBSABTw0FIAAgBUECdGoiAC0AAiIBQTggBGtLDQIgAiABIARqQQhqNgIIIAAvAQAhBgwBCyAFIAlLDQUgAiAEIAVqNgIICyADIAY2AgBBASEICyAIDAQLIAcgAUHcnvMAEMMhAAsgBUEhQfyd8wAQwyEACyAFIAFB7J7zABDDIQALQQALDwsCQAJAIAEgAikDACAGQT9xrYinIghB/wFxIgRLBEAgACAEQQJ0aiIFLwEAIQcgAyAFLQACIgVBCEsEfyAFQQhrQf8BcSIDQSFPDQIgBCAHaiADQQJ0Qfic8wBqKAIAIAhBCHZxQf8AcWoiAyABTw0DIAZBCGohBiAAIANBAnRqIgAtAAIhBSAALwEABSAHC0H//wNxNgIAIAIgBiAFQf8BcWo2AghBAQ8LIAQgAUGsnvMAEMMhAAsgA0EhQfyd8wAQwyEACyADIAFBvJ7zABDDIQALjQIBAn8jAEEgayIEJAAgBEEMaiACIAMQzg4CQCAEKAIMIgVBk4CAgHhHBEAgACAEKQIQNwIIIABBEGogBEEYaikCADcCACAAQSk6AAAgACAFNgIEIAEQpQwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD7HgsgASgCGCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAgAzoAAiAAIAI6AAEgAEEjOgAAIAAgASkCDDcCDCAAIAEpAhg3AhggAEEUaiABQRRqKAIANgIAIABBIGogAUEgaikCADcCACAAQShqIAFBKGopAgA3AgAgARClDAsgBEEgaiQAC40CAQJ/IwBBIGsiBCQAIARBDGogAiADEMwOAkAgBCgCDCIFQZOAgIB4RwRAIAAgBCkCEDcCCCAAQRBqIARBGGopAgA3AgAgAEEpOgAAIAAgBTYCBCABEKUMIAEoAgwiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAFBDGoQ+x4LIAEoAhgiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAUEYahD7HgwBCyAAIAM6AAIgACACOgABIABBJToAACAAIAEpAgw3AgwgACABKQIYNwIYIABBFGogAUEUaigCADYCACAAQSBqIAFBIGopAgA3AgAgAEEoaiABQShqKQIANwIAIAEQpQwLIARBIGokAAuNAgECfyMAQSBrIgQkACAEQQxqIAIgAxDNDgJAIAQoAgwiBUGTgICAeEcEQCAAIAQpAhA3AgggAEEQaiAEQRhqKQIANwIAIABBKToAACAAIAU2AgQgARClDCABKAIMIgAgACgCACIAQQFrNgIAIABBAUYEQCABQQxqEPseCyABKAIYIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAFBGGoQ+x4MAQsgACADOgACIAAgAjoAASAAQSQ6AAAgACABKQIMNwIMIAAgASkCGDcCGCAAQRRqIAFBFGooAgA2AgAgAEEgaiABQSBqKQIANwIAIABBKGogAUEoaikCADcCACABEKUMCyAEQSBqJAALjQIBAn8jAEEgayIEJAAgBEEMaiACIAMQzw4CQCAEKAIMIgVBk4CAgHhHBEAgACAEKQIQNwIIIABBEGogBEEYaikCADcCACAAQSk6AAAgACAFNgIEIAEQpQwgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD7HgsgASgCGCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASABQRhqEPseDAELIAAgAzoAAiAAIAI6AAEgAEEmOgAAIAAgASkCDDcCDCAAIAEpAhg3AhggAEEUaiABQRRqKAIANgIAIABBIGogAUEgaikCADcCACAAQShqIAFBKGopAgA3AgAgARClDAsgBEEgaiQAC4ACAgN/A34gA0H4////AXEEQCAAIAAgA0EDdiIDQQR0IgVqIAAgA0EcbCIGaiADIAQQpBMhACABIAEgBWogASAGaiADIAQQpBMhASACIAIgBWogAiAGaiADIAQQpBMhAgsCQAJAIAAoAgAiBSAEKAIAIgcoAgQiA0kEQCABKAIAIgQgA08NASACKAIAIgYgA08NAiAAIAIgASAHKAIAIgAgBUEDdGopAwAiCCAAIARBA3RqKQMAIglTIgEgCSAAIAZBA3RqKQMAIgpTcxsgASAIIApTcxsPCyAFIANB8PaDARDDIQALIAQgA0GA94MBEMMhAAsgBiADQYD3gwEQwyEAC/4BAQN/IANB+P///wFxBEAgACAAIANBA3YiA0EEdCIFaiAAIANBHGwiBmogAyAEEKUTIQAgASABIAVqIAEgBmogAyAEEKUTIQEgAiACIAVqIAIgBmogAyAEEKUTIQILAkACQCAAKAIAIgUgBCgCACIHKAIEIgNJBEAgASgCACIEIANPDQEgAigCACIGIANPDQIgACACIAEgBygCACIAIAVBAnRqKAIAIgEgACAEQQJ0aigCACICSCIDIAIgACAGQQJ0aigCACIASHMbIAMgACABSnMbDwsgBSADQfD2gwEQwyEACyAEIANBgPeDARDDIQALIAYgA0GA94MBEMMhAAv+AQEDfyADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBCmEyEAIAEgASAFaiABIAZqIAMgBBCmEyEBIAIgAiAFaiACIAZqIAMgBBCmEyECCwJAAkAgACgCACIFIAQoAgAiBygCBCIDSQRAIAEoAgAiBCADTw0BIAIoAgAiBiADTw0CIAAgAiABIAcoAgAiACAFQQJ0aigCACIBIAAgBEECdGooAgAiAkkiAyACIAAgBkECdGooAgAiAElzGyADIAAgAUtzGw8LIAUgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEACyAGIANBgPeDARDDIQALgAICA38DfiADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBCnEyEAIAEgASAFaiABIAZqIAMgBBCnEyEBIAIgAiAFaiACIAZqIAMgBBCnEyECCwJAAkAgACgCACIFIAQoAgAiBygCBCIDSQRAIAEoAgAiBCADTw0BIAIoAgAiBiADTw0CIAAgAiABIAcoAgAiACAFQQN0aikDACIIIAAgBEEDdGopAwAiCVQiASAJIAAgBkEDdGopAwAiClRzGyABIAggClRzGw8LIAUgA0Hw9oMBEMMhAAsgBCADQYD3gwEQwyEACyAGIANBgPeDARDDIQALmQIBBX8jAEFAaiICJAAgAUEYaiIEEP0WIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD2HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQlh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/BwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJgeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEPwcIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD3HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCCHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQkh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJEeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD0HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ0xggAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/RwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJUeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBDzHCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQkx4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEPwWIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD1HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQmh4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ3SYgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEENIYIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCbHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBDdJiAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQjx4gAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQgB0gACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEPocIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD4HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ8hwgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJkeIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEPwcIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBDxHCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCBHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQhRcgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEJceIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBD5HCACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ+xwgAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/hwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEENAYIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEIAdIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCUHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBCAHSAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAuZAgEFfyMAQUBqIgIkACABQRhqIgQQ0RggAkEQaiABENw7IAIgAigCFCIDNgIYAkAgA0EBRgRAIAJBCGogARDcOyACKAIMBEAgAigCCCIFKAIAIgMgAygCACIGQQFqNgIAIAZBAEgNAiACIAM2AhwgAiAFKQIENwIgIAJBNGogAkEcaiABKAIoIAEoAiQQ/xwgACAEENAGIABBGGogAUEsakEAIAEoAiwbEO4lIABBFGogAkE8aigCADYCACAAIAIpAjQ3AgwgARCGJyACQUBrJAAPC0EAQQBBhOWEARDDIQALIAJCADcCKCACQoGAgIDAADcCICACQdzlhAE2AhxBACACQRhqQYDlhAEgAkEcakHk5YQBEK8rCwALmQIBBX8jAEFAaiICJAAgAUEYaiIEEP4WIAJBEGogARDcOyACIAIoAhQiAzYCGAJAIANBAUYEQCACQQhqIAEQ3DsgAigCDARAIAIoAggiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIcIAIgBSkCBDcCICACQTRqIAJBHGogASgCKCABKAIkEP4cIAAgBBDQBiAAQRhqIAFBLGpBACABKAIsGxDuJSAAQRRqIAJBPGooAgA2AgAgACACKQI0NwIMIAEQhicgAkFAayQADwtBAEEAQYTlhAEQwyEACyACQgA3AiggAkKBgICAwAA3AiAgAkHc5YQBNgIcQQAgAkEYakGA5YQBIAJBHGpB5OWEARCvKwsAC5kCAQV/IwBBQGoiAiQAIAFBGGoiBBCQHiACQRBqIAEQ3DsgAiACKAIUIgM2AhgCQCADQQFGBEAgAkEIaiABENw7IAIoAgwEQCACKAIIIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCHCACIAUpAgQ3AiAgAkE0aiACQRxqIAEoAiggASgCJBD+HCAAIAQQ0AYgAEEYaiABQSxqQQAgASgCLBsQ7iUgAEEUaiACQTxqKAIANgIAIAAgAikCNDcCDCABEIYnIAJBQGskAA8LQQBBAEGE5YQBEMMhAAsgAkIANwIoIAJCgYCAgMAANwIgIAJB3OWEATYCHEEAIAJBGGpBgOWEASACQRxqQeTlhAEQrysLAAvIDQIPfwJ+IwBB0ABrIgYkACAGQQRqIgNBgAE6ABggA0EANgIIIANCgICAgBA3AgAgAyABKQIANwIMIANBFGogAUEIaigCADYCACAGQThqIQgjAEFAaiICJAAgAkEwaiADEP4eAkACQAJAAkACQAJ/IAItADBBAUYEQCACKAI0DAELIAItADFBAUYEQCACLQAyQdsARw0DIAMgAy0AGEEBayIBOgAYIAFB/wFxDQIgAkEYNgIAIAMgAhCWJyEBIAhBgICAgHg2AgAgCCABNgIEDAYLIAJBBTYCACADIAIQlicLIQEgCEGAgICAeDYCACAIIAE2AgQMBAsgAxDvOiACIAM2AhwgAkEBOgAgIAJBMGogAkEcahCqGkGAgICAeCEKAkACfwJAAkACQAJAAkACQCACKAIwIgFBgICAgHhrDgICAAELIAIoAjQhCQwGCyACIAIpAjQiETcCKCACIAE2AiQgAiACQRxqEKoaIAIoAgAiDkGAgICAeGsOAgMBAgtBACACQT9qEN0fIQkMBAsgAigCBAwCCyARQiCIpyEPIAIpAgQhEiARpyEJIAEhCgwCC0EBIAJBP2oQ3R8LIQkgAkEkahDeOwsgAyADLQAYQQFqOgAYQgAhESMAQUBqIgUkAAJAIAMoAhQiASADKAIQIgRJBEAgA0EMaiELIAMoAgwhDANAAkACQAJAAkAgASAMai0AACIHQQxNBEAgB0EJa0ECSQ0EDAELIAdBH00EQCAHQQ1HDQEMBAsgB0EgRg0DIAdB3QBGDQEgB0EsRg0CCyAFQRY2AjQgBUEIaiALIAFBAWoiASAEIAEgBEkbEOoMIAVBNGogBSgCCCAFKAIMEPsoIQEMBQsgAyABQQFqNgIUQQAhAQwECyADIAFBAWoiATYCFAJAIAEgBEkEQAJ+AkADQCABIAxqLQAAIgdBCWsiDUEXS0EBIA10QZOAgARxRXINASADIAFBAWoiATYCFCABIARHDQALIAQhAUIADAELQoACCyERIAUgESAHrUIQhoQiETcDKCARQoCC9AJSDQEgBUEVNgI0IAVBGGogCyABQQFqIgEgBCABIARJGxDqDCAFQTRqIAUoAhggBSgCHBD7KCEBDAULIAVCADcDKAsgBUEWNgI0IAVBIGogCyABQQFqIgEgBCABIARJGxDqDCAFQTRqIAUoAiAgBSgCJBD7KCEBIBFC/wGDUA0DAkACQAJAIAVBKGpBBHIoAgAiBCgCAA4CAAECCyAEKAIIIgdFDQEgBCgCBCAHQQEQ+DoMAQsgBC0ABEEDRw0AIAQoAggiBygCACELIAcoAgQiDCgCACINBEAgCyANEQMACyAMKAIEIg0EQCALIA0gDCgCCBD4OgsgB0EMQQQQ+DoLIARBFEEEEPg6DAMLIAMgAUEBaiIBNgIUIAEgBEcNAAsgBCEBCyAFQQI2AjQgBUEQaiADQQxqIAFBAWoiASAEIAEgBEkbEOoMIAVBNGogBSgCECAFKAIUEPsoIQELIAVBQGskACACIAE2AhggAiASNwIQIAIgDjYCDCACIA82AgggAiAJNgIEIAIgCjYCACAKQYCAgIB4RwRAIAFFDQMgAhCkLSABIQkMAgsgAUUNAQJAAkACQCABKAIADgIAAQILIAEoAggiBEUNASABKAIEIARBARD4OgwBCyABQQRqELkuCyABQRRBBBD4OgwBCyADIAJBP2pBtMvDABCeCiEJCyADIAkQlT4hASAIQYCAgIB4NgIAIAggATYCBAwBCyAIIAJBCGoiASkCADcCCCAIQRBqIAFBCGopAgA3AgAgCCAJNgIEIAggCjYCAAsgAkFAayQAAkAgBigCOEGAgICAeEYEQCAAIAYpAjg3AgAgAEEQaiAGQcgAaikCADcCACAAQQhqIAZBQGspAgA3AgAMAQsgBkEwaiAGQcgAaiIKKQIANwMAIAZBKGogBkFAayICKQIANwMAIAYgBikCODcDICMAQSBrIgEkAAJAIAZBBGoiAygCFCIEIAMoAhAiCU8NACADQQxqIQUgAygCDCEIA0AgBCAIai0AAEEJayIHQRdLQQEgB3RBk4CABHFFckUEQCADIARBAWoiBDYCFCAEIAlHDQEMAgsLIAFBFjYCFCABQQhqIAUgBEEBaiIEIAkgBCAJSRsQ6gwgAUEUaiABKAIIIAEoAgwQ+yghEAsgAUEgaiQAIBAEQCAAQYCAgIB4NgIAIAAgEDYCBCAGQSBqEKQtDAELIAAgBikCODcCACAAQRBqIAopAgA3AgAgAEEIaiACKQIANwIACyAGQQRqEN47IAZB0ABqJAAL3AEBBn8gAiABIAJqayEJA0ACQCACIAQiB0YEQCACIQcMAQsCfyABIAdqIgQsAAAiBUEATgRAIAVB/wFxIQUgBEEBagwBCyAELQABQT9xIQYgBUEfcSEIIAVBX00EQCAIQQZ0IAZyIQUgBEECagwBCyAELQACQT9xIAZBBnRyIQYgBUFwSQRAIAYgCEEMdHIhBSAEQQNqDAELIAhBEnRBgIDwAHEgBC0AA0E/cSAGQQZ0cnIhBSAEQQRqCyAJaiEEIAMgBUYNAQsLIAAgAiAHazYCBCAAIAEgB2o2AgALogIBA38jAEEwayIBJAAgAUEANgIsIAFCgICAgBA3AiQgAUEYaiABQSRqQfSo+wAQkCEgACgC/A4hAiAAKAL4DiEDIAAgASkDGDcD+A4gAgRAIAMgAkEBEPg6CyABQQA2AiwgAUKAgICAEDcCJCABQRBqIAFBJGpB9Kj7ABCQISAAKAKEDyECIAAoAoAPIQMgACABKQMQNwOADyACBEAgAyACQQEQ+DoLIAFBADYCLCABQoCAgIAQNwIkIAFBCGogAUEkakH0qPsAEJAhIAAoAuQOIQIgACgC4A4hAyAAIAEpAwg3A+AOIAIEQCADIAJBARD4OgsgAEGQDmogAEGEEWoiAhCAGiAAQagOaiACEIAaIABBwA5qIAIQgBogAUEwaiQAC/QBAgZ/AX4jAEEgayICJAAgASgCEEEBayEEIAEoAgwhAwJAIAACfwNAIARBf0YEQCACQQxqELQeIAIoAgwiA0EERg0DIAAgAikCFDcCDCAAQRRqIAJBHGooAgA2AgAgAEELaiACKAIQIgFBGHY6AAAgACABQQh2OwAJIAAgAToACCAAIAM2AgRBAQwCCyABIAQ2AhAgASADQQFqIgY2AgwgAywAACIHQf8Aca0gBUE/ca2GIAiEIQggBEEBayEEIAVBB2ohBSAGIQMgB0EASA0ACyAAIAg3AwhBAAs2AgAgAkEgaiQADwtBAUEAQdSzzgAQrzsAC5YCAQR/IAIgACgCBCIDIAIgA0kbIgIEQCAAIAMgAms2AgQgACgCHCIDLQACIQQgA0EUaiIFIAEgASACaiAAKAIAIgYQ0iYCQAJAAkACQAJAAkACQCAEQQFrDgIBAAYLIAMoAhgiBCABSQ0BIAIgBCABayIESw0CIAMgAygCoAEgAygCFCABaiACEN0HNgKgAQwFCyADKAIYIgMgAUkNAiACIAMgAWsiA0sNAyAAIAAoAjAgBSgCACABaiACEOgHNgIwDAQLIAEgBEGs9PsAEK87AAsgAiAEQbz0+wAQsDsACyABIANBzPT7ABCvOwALIAIgA0Hc9PsAELA7AAsgACACIAZqNgIAIAAgACgCCCACajYCCAsgAguLAgEEfyAAIAAoAgggA0EEQQRBsLGDARDDKAJAAkACQCABIAJHBEADQCABKAIAIgMgASgCBCIGSQRAIANBAnQhBQNAIAMgACgCHCIETw0EIANBAWoiByAETw0FIAAoAhggBWoiA0EEaigCACADKAIAayIDQQBIDQYgACAAKAIoIANqIgQ2AiggACgCCCIDIAAoAgBGBEAgAEHAsYMBEJ0oCyAAKAIEIANBAnRqIAQ2AgAgACADQQFqNgIIIAVBBGohBSAHIgMgBkcNAAsLIAFBCGoiASACRw0ACwsPCyADIARBnLCDARDDIQALIANBAWogBEGcsIMBEMMhAAtBrLCDAUEUQcCwgwEQyyQAC/kBAQJ/IAFB/wFxIgNBCm4hBAJAAkACQCADQQlLDQACQCACQf8BcUEBaw4CAQIACyAAKAIIIQMMAgsgACgCCCIDIQIgAyAAKAIARgRAIAAgA0EBENsoIAAoAgghAgsgACADQQFqIgM2AgggACgCBCACaiAEQTBqOgAADAELIAAoAggiAyECIAMgACgCAEYEQCAAIANBARDbKCAAKAIIIQILIAAgA0EBaiIDNgIIIAAoAgQgAmpBIDoAAAsgAyICIAAoAgBGBEAgACADQQEQ2yggACgCCCECCyAAIANBAWo2AgggACgCBCACaiABIARBCmxrQTByOgAAQQALmAIBBX8jAEEQayIDJAACQAJAAkACQCABKAIIIgQEQCACKAIIIgUNAQsgAEEIakG4jYgBKAIANgIAIABBsI2IASkCADcCAAwBCyACKAIEIQYgBUEBRgRAIAYoAgAhBCADQQhqIgUgAUEIaigCADYCACADIAEpAgA3AwAgAyAEEOMOIABBCGogBSgCADYCACAAIAMpAwA3AgAgAiEBDAMLIAEoAgQhByAEQQFGDQEgACAHIAQgBiAFEKMRCyACQQRBBBDgHgwBCyAHKAIAIQQgA0EIaiIFIAJBCGooAgA2AgAgAyACKQIANwMAIAMgBBDjDiAAQQhqIAUoAgA2AgAgACADKQMANwIACyABQQRBBBDgHiADQRBqJAALogIBBH8jAEEgayIFJABBASEGAkAgACgCACIHIAEgAiAAKAIEIggoAgwiAREGAA0AAkAgAC0ACkGAAXFFBEAgB0HZ8YkBQQEgAREGAA0CIAMgACAEKAIMEQIARQ0BDAILIAdB2vGJAUECIAERBgANASAFQQE6AA8gBSAINgIEIAUgBzYCACAFQbDxiQE2AhQgBSAAKQIINwIYIAUgBUEPajYCCCAFIAU2AhAgAyAFQRBqIAQoAgwRAgANASAFKAIQQdTxiQFBAiAFKAIUKAIMEQYADQELAkAgAg0AIAAtAApBgAFxDQAgACgCAEHc8YkBQQEgACgCBCgCDBEGAA0BCyAAKAIAQZPtiQFBASAAKAIEKAIMEQYAIQYLIAVBIGokACAGC4cCAQV/IwBBMGsiAyQAIAFBFGohBAJAIAEoAhRBgYCAgHhHDQAgA0EMaiABIAIQqRogAygCDCIHQYKAgIB4RgRAQQEhBgwBCyADQShqIANBGGopAgA3AwAgAyADKQIQNwMgIAdBgYCAgHhGBEBBACEEDAELIAFBGGohAgJAIAQoAgAiBUGBgICAeEYNACAFQYCAgIB4RwRAIAFBIGoiASgCACIFIAUoAgAiBUEBazYCACAFQQFGBEAgARD4IwsgBBDDJyAEEOo7DAELIAIQ0CILIAQgBzYCACACIAMpAyA3AgAgAkEIaiADQShqKQMANwIACyAAIAQ2AgQgACAGNgIAIANBMGokAAuqEAIMfwF+IwBB4ABrIggkACAIIAMQ3DsgCCgCACIEIAgoAgRBAnRqIQkjAEEgayIFJAAgBUEUaiAJIARrQQJ2QQBBBEEMEKAYIAUoAhghByAFKAIUQQFGBEAgByAFKAIcQfDGwwAQ/S8ACyAFQRBqIgxBADYCACAFIAUoAhw2AgwgBSAHNgIIIwBBEGsiByQAIAVBCGoiBiAJIARrQQJ2Ig0Qgi4gByAGKQIEQiCJNwIIIAcgBkEIajYCBCMAQRBrIgYkACAHQQRqIgooAgQhCyAKKAIAIAQgCUcEQCAKKAIIIAtBDGxqIQogCyANIglqIQsDQCAGQQRqIAQoAgBBCGoiDSgCBCANKAIIQZC7zwBBARDkOiAKQQhqIAZBDGooAgA2AgAgCiAGKQIENwIAIARBBGohBCAKQQxqIQogCUEBayIJDQALCyALNgIAIAZBEGokACAHQRBqJAAgCEEMaiIEQQhqIAwoAgA2AgAgBCAFKQIINwIAIAVBIGokACAIIAE2AiQgCCABIAJBDGxqNgIoIAggBDYCLCAIQTBqIQkjAEEwayICJAAgAkEGNgIEIAJBKGogCEEkaiIBQQhqKAIANgIAIAIgASkCADcDICACIAJBBGo2AiwgAkEUaiEFIwBBMGsiASQAIAFBFGogAkEgaiIEEKIlAkACQAJAIAEoAhRBgICAgHhHBEAgAUEgaiILQQRBAEEEQQwQoBggASgCJCEHIAEoAiBBAUYNAiABKAIoIgYgASkCFDcCACAGQQhqIAFBHGooAgA2AgAgAUEQaiIKQQE2AgAgASAGNgIMIAEgBzYCCCABQShqIARBCGopAgA3AwAgASAEKQIANwMgIwBBEGsiBCQAIARBBGogCxCiJSAEKAIEQYCAgIB4RwRAIAFBCGohBwNAIAcoAggiBiAHKAIARgRAIAcgBkEBQQRBDBDQKAsgBygCBCAGQQxsaiIMIAQpAgQ3AgAgDEEIaiAEQQxqKAIANgIAIAcgBkEBajYCCCAEQQRqIAsQoiUgBCgCBEGAgICAeEcNAAsLIARBEGokACAFQQhqIAooAgA2AgAgBSABKQIINwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAUEwaiQADAELIAcgASgCKEG4gcMAEP0vAAsCQCACKAIEQQZHBEAgCSACKQIENwIAIAlBCGogAkEMaikCADcCACAFELArIAVBBEEMEOAeDAELIAkgAikCFDcCBCAJQQY2AgAgCUEMaiACQRxqKAIANgIACyACQTBqJAAgCCgCNCECIAgoAjghASAIKAI8IQQCQCAIKAIwIgxBBkcEQCAAIAQ2AgwgACABNgIIIAAgAjYCBAwBCyAIQQA2AlAgCEEANgJAIAggAjYCOCAIIAE2AjQgCCABNgIwIAggASAEQQxsajYCPCAIQRhqIQkjAEFAaiIFJAAgCEEwaiIEQRBqIQYgBCgCECECAkACQAJAAn8CQANAIAIEQCAEKAIUIgEgBCgCHCIKRw0CIAYQoSwgBkEANgIACwJAIAQoAgAiB0UNACAEKAIEIgEgBCgCDEYNACAEIAFBDGo2AgQgASgCACICQYCAgIB4Rg0AIAEpAgQhECAEIAI2AhggBCAQpyICNgIUIAQgAjYCECAEIAIgEEIgiKdBAnRqNgIcDAELCwJAIAQoAiAEQCAEKAIkIgEgBCgCLCICRw0BIARBIGoiARChLCABQQA2AgALIAlBADYCCCAJQoCAgIDAADcCACAEELkqDAMLIAQgAUEEaiIGNgIkIAIgBmtBAnYhAiABKAIAIQtBAAwBCyAEIAFBBGoiBjYCFCAEKAIsIAQoAiRrQQJ2QQAgBCgCIBshAiAEKAIAIQcgASgCACELIAogBmtBAnYLIAJqIQYCfwJAIAdFDQAgBCgCDCAEKAIERg0AIAVBEGohAkEADAELIAVBDGohAiAGCyEBIAIgATYCACAFQRBqIgFBAyAGIAZBA00bQQFqQQBBBEEEEKAYIAUoAhQhAiAFKAIQQQFGDQEgBSgCGCIHIAs2AgAgBUEIaiIOQQE2AgAgBSAHNgIEIAUgAjYCACABIARBMPwKAAAjAEEQayIEJAAgAUEgaiEGIAFBEGohCwNAAkAgCygCACECAkACfwJAAkACQAJ/AkADQCACBEAgASgCFCICIAEoAhxHDQIgCxChLCALQQA2AgALAkAgASgCAEUNACABKAIEIgIgASgCDEYNACABIAJBDGo2AgQgAigCACIHQYCAgIB4Rg0AIAIpAgQhECABIAc2AhggASAQpyICNgIUIAEgAjYCECABIAIgEEIgiKdBAnRqNgIcDAELCyAGKAIARQ0DIAEoAiQiAiABKAIsRg0CIAEgAkEEajYCJEEBDAELIAEgAkEEajYCFEEACyEHIAIoAgAhDSAFKAIIIgIgBSgCAEcNBCABKAIsIAEoAiRrQQJ2QQAgASgCIBtBACABKAIcIAEoAhRrQQJ2IAcbaiEKIAEoAgBFDQIgASgCDCABKAIERg0CIARBDGohB0EADAMLIAYQoSwgBkEANgIACyABELkqIARBEGokAAwDCyAEQQhqIQcgCgshDyAHIA82AgAgBSAKQQFqEO4tCyAFKAIEIAJBAnRqIA02AgAgBSACQQFqNgIIDAELCyAJQQhqIA4oAgA2AgAgCSAFKQIANwIACyAFQUBrJAAMAQsgAiAFKAIYQfDGwwAQ/S8ACyAAQQRqIAMgCRDoFQsgCEEMaiIBENErIAEQ6DsgACAMNgIAIAhB4ABqJAALhQIBA38gARD0LRoCQAJAAkAgACgCAEGAgICAeEcEQCAAKAIIQQFGDQEMAwsgACgCECAAKAIUKAIIQQFrQXhxaiABKAIAIgIgASgCBCIBKAIIQQFrQXhxakcEQCAAKAIMDQMgAiACKAIAIgNBAWo2AgAgA0EASA0CIABBEGoiAygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgAxC7IwsgACABNgIUIAAgAjYCEAsgAEEEag8LIAEoAgAiAiACKAIAIgNBAWo2AgAgA0EASA0AIAEoAgQhASAAENInIAAgATYCFCAAIAI2AhAgAEIINwIIIABCgICAgAg3AgAgAEEEag8LAAtBAAuFAgEDfyABEPQtGgJAAkACQCAAKAIAQYCAgIB4RwRAIAAoAghBAUYNAQwDCyAAKAIQIAAoAhQoAghBAWtBeHFqIAEoAgAiAiABKAIEIgEoAghBAWtBeHFqRwRAIAAoAgwNAyACIAIoAgAiA0EBajYCACADQQBIDQIgAEEQaiIDKAIAIgQgBCgCACIEQQFrNgIAIARBAUYEQCADELsjCyAAIAE2AhQgACACNgIQCyAAQQRqDwsgASgCACICIAIoAgAiA0EBajYCACADQQBIDQAgASgCBCEBIAAQ0ScgACABNgIUIAAgAjYCECAAQgg3AgggAEKAgICACDcCACAAQQRqDwsAC0EAC+ECAgN/An4jAEEQayIBJAAgAUEZQQBBAUEBEKAYIAEoAgQhAyABKAIAQQFGBEAgAyABKAIIQdinzgAQ/S8ACyABKAIIIgJBGGpB/LDOAC0AADoAACACQRBqQfSwzgApAAA3AAAgAkEIakHssM4AKQAANwAAIAJB5LDOACkAADcAACABQaClzgAQpSsgASkDACEEIAEpAwghBSAAQQA7AZQBIABCgIiAgICAgAg3AowBIABCgIDAgIDEEzcChAEgAEEAOgCWASAAIAI2AmQgACADNgJgIABCmYCAgICAgICAfzcDaCAAQYKEjMgANgIoIABBCDYCICAAQQA2AhggAEIANwMAIABBsKXOACkDADcDQCAAQcgAakG4pc4AKQMANwMAIABBgICAgHg2AnggACAFNwNYIAAgBDcDUCAAQQA6AJcBIABCgYCAgIAINwM4IABCgYCAgIAINwMwIAFBEGokAAuFAgIBfwJ+IwBBIGsiBSQAAkACQAJAIAMgBHEiAyACTQRAIAA1AjQhBiABIANqIAIgA2sQ7yAhByAAKAIEIgIgByAGiKciAU0NASAAKAI8IAAoAgAgAUEBdGovAQBxIAEgACgCQHRqIgIgACgCDCIDTw0CIAAoAgggAkECdGogBDYCACAAKAIEIgIgAUsNAyABIAJBrNbOABDDIQALIAVBADYCGCAFQQE2AgwgBUGY184ANgIIIAVCBDcCECAFQQhqQfzVzgAQ7ywACyABIAJBjNbOABDDIQALIAIgA0Gc1s4AEMMhAAsgACgCACABQQF0aiIAIAAvAQBBAWo7AQAgBUEgaiQAC40CAQN/IAAoAmghASAAKAJsIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAlhBgICAgHhHBEAgAEEQakEIEO4oIABBQGsiARDcJSABQQRBEBDgHiAAQdgAahDjPAsgACgCpAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBpAFqENkhCwJAIAAoAnBFDQAgACgCdCIBRQ0AIABBgAFqIAAoAnggACgCfCABKAIQEQEACwJAIAAoAoQBRQ0AIAAoAogBIgFFDQAgAEGUAWogACgCjAEgACgCkAEgASgCEBEBAAsgACgCmAFBgICAgHhHBEAgAEGYAWpBBEEgEOAeCwuaAgEBfyAAQdADahCGMAJAIAApAyBCAlENACAAQegCakEEQQQQ4B4gAEH0AmoiARDRKyABEOg7IAAoAoADQYCAgIB4RwRAIABBgANqIgEQ4CkgAUEEQRgQ4B4LIAApA1BCAlIEQCAAQfAAahCGMCAAQfwAahCGMCAAQYgBahCGMCAAQZQBahCGMAsgACgCjANBgICAgHhHBEAgAEGMA2pBBEEMEOAeCyAAKQOoAUICUgRAIABBuAFqEIUwIABBxAFqEIUwCyAAKQPQAUIDUQ0AIAAoArACQYCAgIB4Rg0AIABBsAJqEOk7CyAAKAKwA0GCgICAeE4EQCAAQbADaiIBENErIAEQ6DsgAEG8A2oQhjALIABB3ANqEIYwC/cBAQV/IAAoAgAiBCAAKAIEIgYgAaciB3EiA2opAABCgIGChIiQoMCAf4MiAVAEQEEIIQUDQCADIAVqIQMgBUEIaiEFIAQgAyAGcSIDaikAAEKAgYKEiJCgwIB/gyIBUA0ACwsgBCABeqdBA3YgA2ogBnEiA2osAAAiBUEATgRAIAQgBCkDAEKAgYKEiJCgwIB/g3qnQQN2IgNqLQAAIQULIAMgBGogB0EZdiIHOgAAIAAgACgCCCAFQQFxazYCCCAEIANBCGsgBnFqQQhqIAc6AAAgBCADQQZ0ayIDQUBqIAJBwAD8CgAAIAAgACgCDEEBajYCDCADC/8BAQV/IwBB4ABrIgQkACABLwEaIQUgAS8BGCEGIARB1ABqIgcgAUEMahDDBiAEQQhqIgggAiADIAdBABCbFAJAQdAAQQgQrTYiAwRAIANCgYCAgBA3AwAgA0EIaiAIQcgA/AoAAEEgQQQQrTYiAkUNASAAQQA6ABwgACAFOwEaIAAgBjsBGCAAIAM2AhAgAEEbOgAMIABBATYCCCAAIAI2AgQgAEEBNgIAIAIgASkCADcCACACQRhqIAFBGGopAgA3AgAgAkEQaiABQRBqKQIANwIAIAJBCGogAUEIaikCADcCACAEQeAAaiQADwtBCEHQABCjPQALQQRBIBCjPQALjwIBAn8jAEHQAGsiAyQAAkAgACkDAEIEUgRAIANBEGoiBCABIAIgAC0AQhCTFSAAEJIqIAAgBEHAAPwKAAAMAQsgAEEAOgAoIABBADYCHCAAQQA2AiQgAyABOgAHAkACQAJAIAFB/wFxQQJrDgICAQALIANBATYCFCADQczQ0AA2AhAgA0IBNwIcIANBrgM2AgwgAyADQQhqNgIYIAMgA0EHajYCCCADQRBqQdTQ0AAQ7ywACyACKAIIQQN0IQQLIAAgBDYCICAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEAIABBADYCGCAAQQhqIgBBCGogAkEIaikCADcCACAAIAIpAgA3AgALIANB0ABqJAALoQIBAX9BfyEPAkACQAJAAkACQCAEDgQCAAMBBAsgAkEANgEEIAIgBkH/AXEiAzsBAiACQQA7AQAgAiADQQN0akIANwIIQQAhD0EADQMgAUUEQEG6fw8LIAAgBy0AADoAAEEBDwsgDQRAIAIgDCAN/AoAAAtBAA8LIAIgCSALIAogDkGExAAQyAciAEEAIABBiX9PGw8LIA4gAyAIIAYQgTsiAyAFIAUgByAIakEBay0AAEECdGoiBCgCACIFQQJPBEAgBCAFQQFrNgIAIAhBAWshCAsgCCAGIAhB/w9LEPQGIg9BiH9LDQAgACABIA4gBiADEPsmIg9BiH9LDQAgDyACIA4gBiADIA5B7ABqQfQIEMgHIgAgAEGJf0kbIQ8LIA8L+wEBAX8gAkUEQCAAQgA3AgAgAEEQakEANgIAIABBCGpCADcCAEG4fw8LIAAgATYCDCAAIAFBBGo2AhAgAkEETwRAIAAgASACaiIBQQRrIgM2AgggACADKAAANgIAIAFBAWstAAAiAQRAIABBCCABZ0Efc2s2AgQgAg8LIABBADYCBEF/DwsgACABNgIIIAAgAS0AACIDNgIAAkACQAJAIAJBAmsOAgEAAgsgACABLQACQRB0IANyIgM2AgALIAAgAS0AAUEIdCADajYCAAsgASACakEBay0AACIBRQRAIABBADYCBEFsDwsgACABZyACQQN0a0EJajYCBCACC7ECAQN/IAJBB3EhAyACQRhxIQUgAkEfcSECIAEhBANAIAJBCElFBEAgAkEIayECIAQpAABCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAAhUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSEAIARBCGohBAwBCwsgASAFaiEBIANBBEkEfyABBSADQQRrIQMgATUAAEKHla+vmLbem55/fiAAhUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhACABQQRqCyECA0AgAwRAIANBAWshAyACMQAAQsXP2bLx5brqJ34gAIVCC4lCh5Wvr5i23puef34hACACQQFqIQIMAQsLIABCIYggAIVCz9bTvtLHq9lCfiIAQh2IIACFQvnz3fGZ9pmrFn4iAEIgiCAAhQuDAgEEfyMAQSBrIgUkAAJAIAIoAgAiB0EDdiIGIARNBEAgBCAGRwRAIAMgBmoiAy0AACEIIAUgASAHQQdxrYYiAUI4iDwAByAFIAFCMIg8AAYgBSABQiiIPAAFIAUgAUIgiDwABCAFIAFCGIg8AAMgBSABQhCIPAACIAUgAUIIiDwAASAFIAggAadyOgAAIAQgBmtBB00NAiADQQggBUEIQeiO0gAQ1SwgAiAAIAdqNgIAIAVBIGokAA8LQQBBAEG4iNIAEMMhAAsgBiAEQaiI0gAQrzsACyAFQQA2AhggBUEBNgIMIAVBwP/RADYCCCAFQgQ3AhAgBUEIakHYjtIAEO8sAAuCAgELfyAAKAIYIgMgAUECaiIETwRAIAMgBGsiAyACTwRAIAIEQCAAKAIgQf//A2ohCCAAKAIUIARqIQkgACgCKCEKIAAoAiwhBSAAKAIwIQsgACgChAEhBEEAIQMDQAJAIAsgAyAJai0AACAEQQV0QeD/AXFzIgRBAXRqIgwvAQAiDSABIANqIgZB//8DcUYNACAFIAYgCHFB//8DcSIHSwRAIAogB0EBdGogDTsBACAMIAY7AQAMAQsgACAENgKEASAHIAVBhOD8ABDDIQALIAIgA0EBaiIDRw0ACyAAIAQ2AoQBCw8LIAIgA0H03/wAELA7AAsgBCADQeTf/AAQrzsAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQF2IAIQiQUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARC9EyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQJ2IAIQigUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCtEyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQN2IAIQpwUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCxEyADQaACaiQAC4MCAQR/IwBBoAJrIgMkACADQQhqIgQgASgCECABKAIUQQF2IAIQiQUgA0GgAWogARDMBiADQQA7AdgBIANBADYC1AEgA0EANgK8ASADQQA2ArABIANCBDcCmAEgA0IANwKQASADQoCAgIDAADcCiAEgA0EANgKAASADIAIoAjw2AqwBIANBFGoiBSADQYABaiIGIAQQ+iMgA0HwAGogARCSNiACEOYYIAMoAnQEQCADKAJwIQEgA0GIAWogA0EcakHUAPwKAAAgAyABNgKEASADQQE2AoABIAUgBiADQfQAahCuFgsgA0HcAWoiASADQRRqEM0cIAAgARCqEyADQaACaiQAC8QNAQt/IwBBoAJrIgYkACAGQQhqIQogASgCECELIAEoAhRBAnYhCCMAQcABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAIIAJBEGoiBCgCEE8EQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMFBQALIANB+ABqIgUgAigCPEEAQQRBBBCgGCADKAJ8IQcgAygCeEEBRg0GIANBADYCLCADIAMoAoABNgIoIAMgBzYCJCAFIAQQyTQgA0HsAGogBRDVCSADKAJsQQFGBEADQCADKAJ0IgQgAygCcCIFSQ0QIAQgCEsNESADQSRqIAsgBUECdGogBCAFaxCNNSADQewAaiADQfgAahDVCSADKAJsDQALCyADQYABaiADQSxqKAIANgIAIAMgAykCJDcDeCAKIANB+ABqELgYDAMLIANB+ABqIgUgBCACKAI8ELEmIANBMGogBUE4/AoAACADKAK0ASEFIAMgAygCsAEiDEECdCIENgIkIAQhByAEQTxxIgkEQCAEIAlrQUBrIgcgBEkNBwtBwAAhCSAHQcAAENE0RQ0HIAcEQCAHQcAAEK02IglFDQkLIANB+ABqIg0gA0EwakE4/AoAACADIAg2ArwBIAMgCzYCuAEgAyAFNgK0ASADIAw2ArABIANBGGogDRDWECAJIQUgAygCGEEBcQRAIAMoAhwhBANAIAQgAygCvAEiCE8NCyAFIAMoArgBIARBAnRqKAIANgAAIAVBBGohBSADQRBqIANB+ABqENYQIAMoAhQhBCADKAIQQQFxDQALIAMoAiQhBAsgAyAFIAlrIgU2AmwgBCAFRw0KIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgBDYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQdBHEEEEK02IgVFDQsgBUKBgICAEDcCACAFIAMpAng3AgggCiAENgIIIAogBzYCBCAKIAU2AgAgBUEQaiADQYABaikCADcCACAFQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AngjAEEgayIEJAAgBEEUaiADQfgAaiIFKAIEIAUoAgBrQQJ2QQBBBEEEEKAYIAQoAhghByAEKAIUQQFGBEAgByAEKAIcQaCCgwEQ/S8ACyAEQRBqIghBADYCACAEIAQoAhw2AgwgBCAHNgIIIwBBEGsiByQAIARBCGoiCSAFKAIEIAUoAgBrQQJ2EIUuIAcgCSkCBEIgiTcCCCAHIAlBCGo2AgQgBSAHQQRqENsZIAdBEGokACADQewAaiIFQQhqIAgoAgA2AgAgBSAEKQIINwIAIARBIGokACAKIAUQuBgMAQsgA0H4AGogAigCPEEAQQRBBBCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgQEQCACKAIIIgUgBEEDdGohCQNAIAVBBGooAgAiBCAFKAIAIgdJDQ8gBCAISw0QIANB7ABqIAsgB0ECdGogBCAHaxCNNSAFQQhqIgUgCUcNAAsLIANBgAFqIANB9ABqKAIANgIAIAMgAykCbDcDeCAKIANB+ABqELgYCyADQcABaiQADA4LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyAHIAMoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSADQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAHEKM9AAsgBCAIQeyvgwEQwyEACyADQgA3AoQBIANCgYCAgMAANwJ8IANBqPuCATYCeEEAIANB7ABqIANBJGogA0H4AGpBsPuCARCvKwALQQRBHBCjPQALIAQgAygCgAFBrK+DARD9LwALIAUgBEGMr4MBELE7AAsgBCAIQYyvgwEQsDsACyAHIARBvK+DARCxOwALIAQgCEG8r4MBELA7AAsgBkGgAWogARDMBiAGQQA7AdgBIAZBADYC1AEgBkEANgK8ASAGQQA2ArABIAZCBDcCmAEgBkIANwKQASAGQoCAgIDAADcCiAEgBkEANgKAASAGIAIoAjw2AqwBIAZBFGoiBCAGQYABaiIFIAoQ+iMgBkHwAGogARCSNiACEOYYIAYoAnQEQCAGKAJwIQEgBkGIAWogBkEcakHUAPwKAAAgBiABNgKEASAGQQE2AoABIAQgBSAGQfQAahCuFgsgBkHcAWoiASAGQRRqEM0cIAAgARC5EyAGQaACaiQAC88MAQt/IwBBoAJrIgYkACAGQQhqIQogASgCECELIAEoAhRBA3YhCCMAQcABayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAIIAJBEGoiBCgCEE8EQAJAAkACQAJAAkACQCACKAIAQQFrDgUBAgMFBQALIANB+ABqIgUgAigCPEEAQQhBCBCgGCADKAJ8IQcgAygCeEEBRg0GIANBADYCLCADIAMoAoABNgIoIAMgBzYCJCAFIAQQyTQgA0HsAGogBRDVCSADKAJsQQFGBEADQCADKAJ0IgQgAygCcCIFSQ0QIAQgCEsNESADQSRqIAQgBWsiBBDsLSAEQQN0IgcEQCADKAIoIAMoAixBA3RqIAsgBUEDdGogB/wKAAALIAMgAygCLCAEajYCLCADQewAaiADQfgAahDVCSADKAJsDQALCyADQYABaiADQSxqKAIANgIAIAMgAykCJDcDeCAKIANB+ABqELMYDAMLIANB+ABqIgUgBCACKAI8ELEmIANBMGogBUE4/AoAACADKAK0ASEEIAMgAygCsAEiDEEDdCIHNgIkIAciBUE4cSIJBEAgBSAFIAlrQUBrIgVLDQcLQcAAIQkgBUHAABDRNEUNByAFBEAgBUHAABCtNiIJRQ0JCyADQfgAaiINIANBMGpBOPwKAAAgAyAINgK8ASADIAs2ArgBIAMgBDYCtAEgAyAMNgKwASADQRhqIA0Q1hAgCSEEIAMoAhhBAXEEQCADKAIcIQgDQCAIIAMoArwBIgtPDQsgBCADKAK4ASAIQQN0aikDADcAACAEQQhqIQQgA0EQaiADQfgAahDWECADKAIUIQggAygCEEEBcQ0ACwsgAyAEIAlrIgQ2AmwgBCAHRw0KIAMgBTYCiAEgA0KAgICAgAg3AoABIAMgBzYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQVBHEEEEK02IgRFDQsgBEKBgICAEDcCACAEIAMpAng3AgggCiAHNgIIIAogBTYCBCAKIAQ2AgAgBEEQaiADQYABaikCADcCACAEQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AnggA0HsAGoiBCADQfgAahD9GiAKIAQQsxgMAQsgA0H4AGogAigCPEEAQQhBCBCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgUEQCACKAIIIgQgBUEDdGohCQNAIARBBGooAgAiBSAEKAIAIgdJDQ8gBSAISw0QIANB7ABqIAUgB2siBRDsLSAFQQN0IgwEQCADKAJwIAMoAnRBA3RqIAsgB0EDdGogDPwKAAALIAMgAygCdCAFajYCdCAEQQhqIgQgCUcNAAsLIANBgAFqIANB9ABqKAIANgIAIAMgAykCbDcDeCAKIANB+ABqELMYCyADQcABaiQADA4LQfytgwFBKEHcr4MBEJ8pAAtBtK6DAUE4QeyugwEQnykACyAHIAMoAoABQfyugwEQ/S8AC0H0+YIBQSNBmPqCARDLJAALQbj6ggFBKSADQfgAakGwgoMBQeT6ggEQ1R4AC0HAACAFEKM9AAsgCCALQeyvgwEQwyEACyADQgA3AoQBIANCgYCAgMAANwJ8IANBqPuCATYCeEEAIANB7ABqIANBJGogA0H4AGpBsPuCARCvKwALQQRBHBCjPQALIAQgAygCgAFBrK+DARD9LwALIAUgBEGMr4MBELE7AAsgBCAIQYyvgwEQsDsACyAHIAVBvK+DARCxOwALIAUgCEG8r4MBELA7AAsgBkGgAWogARDMBiAGQQA7AdgBIAZBADYC1AEgBkEANgK8ASAGQQA2ArABIAZCBDcCmAEgBkIANwKQASAGQoCAgIDAADcCiAEgBkEANgKAASAGIAIoAjw2AqwBIAZBFGoiBCAGQYABaiIFIAoQ+iMgBkHwAGogARCSNiACEOYYIAYoAnQEQCAGKAJwIQEgBkGIAWogBkEcakHUAPwKAAAgBiABNgKEASAGQQE2AoABIAQgBSAGQfQAahCuFgsgBkHcAWoiASAGQRRqEM0cIAAgARCuEyAGQaACaiQAC4YCAQp/IwBBEGsiAiQAIAJBBGogARDUBgJAIAEoAiAiBQRAIAUgBSgCACIDQQFqNgIAIANBAEgNASABKAIwIQggASgCLCEJIAEoAighCiABKAIkIQsgASgCNCEHCyABKAIMIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIUIgQgBCgCACIGQQFqNgIAIAZBAEgNACABKAIQIQYgACACKQIENwIAIAAgBzYCNCAAIAg2AjAgACAJNgIsIAAgCjYCKCAAIAs2AiQgACAFNgIgIAAgBDYCFCAAIAY2AhAgACADNgIMIAAgASkCGDcCGCAAQQhqIAJBDGooAgA2AgAgAkEQaiQADwsAC5MCAgd/AX4jAEGQAmsiAiQAAkAgAQRAIAJBpAFqIQUgAkGYAWohAyACQfwBaiEGIAJB9AFqIQcgAkGQAWohBANAIAJBCGoiCCAAENkcIAIpAwhCDVENAiAEIAhBgAH8CgAAIAIgATYCiAECQCACKQOQASIJQgxSBEACQAJAAkBBASAJp0EJayAJQghYGw4CAQIACyAFIAIoApwBIAIoAqABIAIoApgBKAIQEQEADAMLIAYgAigC9AEgAigC+AEgAigC8AEoAhARAQAgAxDCGAwCCyAHIAIoAuwBIAIoAvABIAIoAugBKAIQEQEAIAQQwhgMAQsgAxDJIwsgAUEBayIBDQALC0EAIQELIAJBkAJqJAAgAQvrAQEHfyAAKAIAIgRBCGohBQJAIAAoAggiAEEBaiIGIAQvAQYiA0sNACADIABrIgdFDQAgBSAGaiAAIAVqIAf8CgAACyADQQFqIQcgACAFaiABOgAAIARBFGohAQJAIANBAmoiBSAAQQJqIghNDQAgAyAAa0ECdCIJRQ0AIAEgCEECdGogASAGQQJ0aiAJ/AoAAAsgASAGQQJ0aiACNgIAIAQgBzsBBiAFIAZLBEAgA0EBaiECIABBAnQgBGpBGGohAQNAIAEoAgAiAyAAQQFqIgA7AQQgAyAENgIAIAFBBGohASAAIAJHDQALCwvuAQEHfwJ/IAEoAkQgASgCSCIFayIEIAMgAyAESxsiBkUEQEEAIQRBACEGQQEMAQsgASgCQCIHQYAQaiEJIAEtAEwhCiAHIQhBACEEQQAhA0EAIQEDQAJAAkAgBUUEQCABQYAQRw0BDAILQQEgBSAJIAhrQQF2Tw0DGiAFQQF0IAFqIQELAkAgASAHai8BACADQQBHIApyQQFxRXINACAEQQFqIgQgAkcNACACIQQgAyEGQQAMAwsgByABQQJqIgFqIQhBACEFIAYgA0EBaiIDRw0BCwtBAQshASAAIAY2AgggACAENgIAIAAgAToABAuOAgECfyMAQTBrIgIkACABLQASIQMgAUECOgASAkAgA0ECRwRAIABBBDYCACAAIAM6AAQMAQsgAkEQaiABEJsTIAItABQhASACKAIQIgNBBEcEQCAAIAIpABU3AAUgAEEMaiACQRxqKQAANwAAIAAgAToABCAAIAM2AgAMAQsCQAJAAkAgAUEBaw4CAQIACyACIAE6AA8gAkECNgIUIAJBgMfOADYCECACQgE3AhwgAkG7BzYCLCACIAJBKGo2AhggAiACQQ9qNgIoIABBBGogAkEQahCZDiAAQQE6ABAgAEEBNgIADAILIABBBDYCACAAQQE6AAQMAQsgAEEENgIAIABBADoABAsgAkEwaiQAC44CAQJ/IwBBMGsiAiQAIAEtABIhAyABQQI6ABICQCADQQJHBEAgAEEENgIAIAAgAzoABAwBCyACQRBqIAEQxBkgAi0AFCEBIAIoAhAiA0EERwRAIAAgAikAFTcABSAAQQxqIAJBHGopAAA3AAAgACABOgAEIAAgAzYCAAwBCwJAAkACQCABQQFrDgIBAgALIAIgAToADyACQQI2AhQgAkGAx84ANgIQIAJCATcCHCACQbsHNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBAToAECAAQQE2AgAMAgsgAEEENgIAIABBAToABAwBCyAAQQQ2AgAgAEEAOgAECyACQTBqJAAL+Q0BBX8gASgCCCEHIAEgASgCDCADbCIGEOUtIAFBfyABKAIIIgQgBmoiBSAEIAVLGxCOLQJAAkACQAJAIAYgBiAHaiIETQRAIAQgASgCCCIFSw0BIAEoAgQgB2ohBwJAAkACQAJAAkACQAJAAkACQCABKAIMIgFBAmsOBwECAwQFBgcACyAHIQQgBiEHIwBBMGsiBSQAIAUgATYCAAJAAkAgAwRAIAIgA0EEdGohCEEAIQMDQCACKAIARQ0OAkAgASACQQhqKAIAIgZGBEAgASADaiIGIAFJDQQgBiAHTQ0BIAYgB0G07M4AELA7AAsgBSAGNgIcIAVBAjYCCCAFQfzrzgA2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBTYCKCAFIAVBHGo2AiAgBUEEakHE7M4AEO8sAAsgAQRAIAMgBGogAkEEaigCACAB/AoAAAsgBiEDIAJBEGoiAiAIRw0ACwsgBUEwaiQADAELIAMgBkG07M4AELE7AAsMBwsjAEEwayIEJAACQCADBEAgAiADQQR0aiEFQQAhAQNAIAIoAgBFDQwCQCACQQhqKAIAIgNBAkYEQCABQQJqIgMgBk0NAQwPCyAEIAM2AhwgBEECNgIIIARB/OvOADYCBCAEQgI3AhAgBEE7NgIsIARBoOzOADYCKAwPCyABIAdqIAJBBGooAgAvAAA7AAAgAyEBIAJBEGoiAiAFRw0ACwsgBEEwaiQADAALDAYLIwBBMGsiBCQAAkAgAwRAIAIgA0EEdGohBUEAIQEDQCACKAIARQ0LAkAgAkEIaigCACIDQQNGBEAgAUEDaiIDIAZNDQEMDgsgBCADNgIcIARBAjYCCCAEQfzrzgA2AgQgBEICNwIQIARBOzYCLCAEQajszgA2AigMDgsgASAHaiIBIAJBBGooAgAiCC8AADsAACABQQJqIAhBAmotAAA6AAAgAyEBIAJBEGoiAiAFRw0ACwsgBEEwaiQADAALDAULIwBBMGsiBCQAAkAgAwRAIAIgA0EEdGohBUEAIQEDQCACKAIARQ0KAkAgAkEIaigCACIDQQRGBEAgAUEEaiIDIAZNDQEMDQsgBCADNgIcIARBAjYCCCAEQfzrzgA2AgQgBEICNwIQIARBOzYCLCAEQdDrzgA2AigMDQsgASAHaiACQQRqKAIAKAAANgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwECyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNCQJAIAJBCGooAgAiA0EFRgRAIAFBBWoiAyAGTQ0BDAwLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGw7M4ANgIoDAwLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEEaiAIQQRqLQAAOgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwDCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNCAJAIAJBCGooAgAiA0EGRgRAIAFBBmoiAyAGTQ0BDAsLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGs7M4ANgIoDAsLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEEaiAIQQRqLwAAOwAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwCCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNBwJAIAJBCGooAgAiA0EHRgRAIAFBB2oiAyAGTQ0BDAoLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGc7M4ANgIoDAoLIAEgB2oiASACQQRqKAIAIggoAAA2AAAgAUEDaiAIQQNqKAAANgAAIAMhASACQRBqIgIgBUcNAAsLIARBMGokAAwACwwBCyMAQTBrIgQkAAJAIAMEQCACIANBBHRqIQVBACEBA0AgAigCAEUNBgJAIAJBCGooAgAiA0EIRgRAIAFBCGoiAyAGTQ0BDAkLIAQgAzYCHCAEQQI2AgggBEH8684ANgIEIARCAjcCECAEQTs2AiwgBEGk7M4ANgIoDAkLIAEgB2ogAkEEaigCACkAADcAACADIQEgAkEQaiICIAVHDQALCyAEQTBqJAAMAAsLIABBCDYCAA8LIAcgBEHk7M4AELE7AAsgBCAFQeTszgAQsDsAC0Hkh84AQSBBhIjOABDLJAALIAMgBkHA684AELA7AAsgBEE7NgIkIAQgBEEgajYCDCAEIARBHGo2AiAgBEEEakGM7M4AEO8sAAuBAgECfyMAQRBrIgUkACAFQQA2AgwgAC0AACEGAn8CQANAAkACQAJAAkACQCAGQQFrDgIBAgALIAFBASAFQQxqIAMgBBDtH0UNBUEBIQYgBSgCDEUNAwwCCyABQQMgBUEMaiADIAQQ7R9FBEAgAEEBOgAADAULIAUoAgwiBkUEQCAAQQA6AAAgAkEBNgIAQQEMBgsgAiAGNgIAQQIhBgwBCyABIAIoAgAiASAFQQxqIAMgBBDtH0UEQCAAQQI6AABBAgwFCyAAQQA6AAAgAiAFKAIMQQEgAXRqNgIAQQEMBAsgACAGOgAADAELCyACQQA2AgBBAQwBC0ECCyAFQRBqJAAL4QMBBn8jAEEQayIFJAAgACgCACIAQQA6ABwCQCAAKAIIIgJB/////wdJBEACQCAAKAIYIgZFDQAgAg0CA0ACQCAAQX82AgggACgCGCICRQ0AIAAgAkEBazYCGCAAKAIQIAAoAhQiA0ECdGooAgAhAiAAQQA2AgggACADQQFqIgMgACgCDCIEQQAgAyAETxtrNgIUIAUgAjYCDCMAQRBrIgMkAAJAIAJBCGoiAigCAEUEQCACQX82AgAgAigCBCIERQRAQQAhBAwCCyACQQA6ABQgA0EANgIIIAMgAkEMaiIHNgIEIAMgBzYCACAEIAMgAigCCCgCDBECAEUEQCACQQRqIgQQ4icgBEEANgIACyACKAIAQQFqIQQMAQtB6KqIARCbPgALIAIgBDYCACADQRBqJAAgBSgCDCICIAIoAgBBAWsiAjYCACACRQRAIAVBDGoQqisLIAZBAWsiBkUNAiAAKAIIRQ0BDAQLCyAAQQA2AggLIAFBhAFPBEAgARDyHwsgBUEQaiQADwsjAEEwayIAJAAgAEEBNgIMIABBwO2JATYCCCAAQgE3AhQgACAAQS9qrUKAgICAwOMDhDcDICAAIABBIGo2AhAgAEEIakG8qIgBEO8sAAtBzKiIARCbPgAL9gwCDn8FfiMAQZABayIEJAAgBEEIaiACEMUKIAQoAhQhAiAEKAIQIQUgBCgCDCEGAkAgBCgCCCIHQQZHBEAgACACNgIUIAAgBTYCECAAIAY2AgwgACAHNgIIIABCAjcDACABEPslDAELIARBMGogAUEYaikDADcDACAEQShqIAFBEGopAwA3AwAgBEEgaiABQQhqKQMANwMAIARBgAg2AoQBIAQgAjYCgAEgBCAFNgJ8IAQgBjYCeCAEQYCAgIB4NgJsIARBgICAgHg2AmAgBEGAgICAeDYCVCAEQYCAgIB4NgJIIARCgICAgICAgKAGNwOIASAEQQA2AkAgBEEANgI4IAQgASkDADcDGCAEQRhqIQIjAEHgAWsiASQAIAMoAgBBAUYEQCACIAIoAmAoAggiBSADKAIEIgYgBSAGSRs2AmwLIAMoAghBAUYEQCACQQE2AiAgAiADKAIMNgIkCyADKAIQQQFGBEAgAkEBNgIoIAIgAygCFDYCLAsCQCADKAIsQYCAgIB4RwRAIAIoAmBBCGoQhTwhBSABQegAaiADKAIwIAMoAjQgBRDSEyABQdAAaiIFIAFB9ABqKAIANgIAIAEgASkCbDcDSCABKAJoIgZBBkcEQCACQeAAaiEDIAAgASkDSDcCDCAAIAY2AgggAEICNwMAIABBFGogBSgCADYCAAJAIAIoAgBFBEAgAigCECIAQYQBSQ0BIAAQ8h8MAQsgAkEQahDeOyACKAIcIgAgACgCACIAQQFrNgIAIABBAUcNACACQRxqEJ0nCyADKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCADEJcVCyACKAJkIgAgACgCACIAQQFrNgIAIABBAUYEQCACQeQAahD4IwsCQCACKAJoIgBFDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJB6ABqENseCyACQTBqEJcwIAJBPGoQhjAgAkHIAGoQni8gAkHUAGoQjjAgAigCcCIARQ0CIAAgACgCACIAQQFrNgIAIABBAUcNAiACQfAAahCBLAwCCyABQTBqIgYgBSgCADYCACABIAEpA0g3AyggAUHoAGogAkH4APwKAAAgAUHgAGoiByACQRhqIggpAwA3AwAgAUHYAGoiCSACQRBqIgopAwA3AwAgBSACQQhqIgspAwA3AwAgAUFAayIMIAJBOGoiDSgCADYCACABQSBqIg4gAkHQAGoiDygCADYCACABIAIpAwA3A0ggASACKQMwNwM4IAEgAikDSDcDGCABKQPQASESIAEpA8gBIRMgAUEQaiIQIAJB3ABqIhEoAgA2AgAgASACKQJUNwMIIAEpA9gBIRQgASkDiAEhFSABKQOQASEWIAFBpAFqEIYwIAggBykDADcDACAKIAkpAwA3AwAgCyAFKQMANwMAIAIgASkDSDcDACACIBY3AyggAiAVNwMgIAIgASkDODcDMCANIAwoAgA2AgAgAiABKQMoNwI8IAJBxABqIAYoAgA2AgAgAiATNwNgIAIgEjcDaCACIBQ3A3AgDyAOKAIANgIAIAIgASkDGDcDSCACIAEpAwg3AlQgESAQKAIANgIACyADKAIgQYCAgIB4RwRAIAFB6ABqIAJB+AD8CgAAIAFBOGogA0EgahCJHSABQeAAaiIDIAFBgAFqKQMANwMAIAFB2ABqIgUgAUH4AGopAwA3AwAgAUHQAGoiBiABQfAAaikDADcDACABQTBqIgcgAUGsAWooAgA2AgAgAUEgaiIIIAFBuAFqKAIANgIAIAEgASkDaDcDSCABIAEpAqQBNwMoIAEgASkDsAE3AxggASkDyAEhEiABKQPQASETIAFBEGoiCSABQcQBaigCADYCACABIAEpArwBNwMIIAEpA9gBIRQgASkDiAEhFSABKQOQASEWIAFBmAFqEJcwIAJBGGogAykDADcDACACQRBqIAUpAwA3AwAgAkEIaiAGKQMANwMAIAIgASkDSDcDACACIBY3AyggAiAVNwMgIAIgASkDODcDMCACQThqIAFBQGsoAgA2AgAgAiABKQMoNwI8IAJBxABqIAcoAgA2AgAgAiAUNwNwIAIgEzcDaCACIBI3A2AgAkHQAGogCCgCADYCACACIAEpAxg3A0ggAkHcAGogCSgCADYCACACIAEpAwg3AlQLIAAgAkH4APwKAAALIAFB4AFqJAALIARBkAFqJAAL6QEBAX4jAEGwAmsiAiQAIAJBADYCDCACIAE2AgggAkEoaiACQQhqEI4UIAJBGGoiASACQThqKQMANwMAIAJBIGoiAyACQUBrKQMANwMAIAIgAikDMDcDEAJAIAIpAygiBEIEUQRAIAAgAikDEDcDECAAQgQ3AwggAEEgaiADKQMANwMAIABBGGogASkDADcDAAwBCyAAQShqIAJByABqQegB/AoAACAAQSBqIAJBIGopAwA3AwAgAEEYaiACQRhqKQMANwMAIAAgAikDEDcDECAAIAQ3AwggACACKAIMNgIACyACQbACaiQAC+sBAgJ/AX4jAEGwAmsiAiQAIAJBADYCDCACIAE2AgggAkEoaiACQQhqEI4UIAJBGGoiASACQThqKQMANwMAIAJBIGoiAyACQUBrKQMANwMAIAIgAikDMDcDEAJAIAIpAygiBEIEUQRAIAAgAikDEDcDECAAQgQ3AwggAEEgaiADKQMANwMAIABBGGogASkDADcDAAwBCyAAQShqIAJByABqQegB/AoAACAAQSBqIAJBIGopAwA3AwAgAEEYaiACQRhqKQMANwMAIAAgAikDEDcDECAAIAQ3AwggACACKAIMNgIACyACQbACaiQAC4oCAQF/AkACfwJAAkACQAJAAkACQAJAAkAgACgCAA4KCQEBAQECAwQFBgALIAAoAggiAUUNBiAAKAIEIAFBAnRBBBD4OgwGCyAAKAIIIgFFDQdBBAwGCyAAKAIIIgFFDQQgACgCBCABQQF0QQIQ+DoMBAsgACgCCCIBRQ0DIAAoAgQgAUEBdEECEPg6DAMLIAAoAggiAUUNAiAAKAIEIAFBAXRBAhD4OgwCCyAAKAIMIgEEQCAAKAIIIAFBAXRBAhD4OgsgACgCFCIBRQ0DQRAMAgsgACgCCCIBRQ0AIAAoAgQgAUEBdEECEPg6CyAAKAIQIgFFDQFBDAsgAGooAgAgAUECdEEEEPg6Cwv9DQEKfyMAQaACayIGJAAgBkEIaiEKIAEoAhAhCyABKAIUIQgjAEHAAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCCACQRBqIgQoAhBPBEACQAJAAkACQAJAAkAgAigCAEEBaw4FAQIDBQUACyADQfgAaiIFIAIoAjxBAEEBQQEQoBggAygCfCEHIAMoAnhBAUYNBiADQQA2AiwgAyADKAKAATYCKCADIAc2AiQgBSAEEMk0IANB7ABqIAUQ1QkgAygCbEEBRgRAA0AgAygCdCIEIAMoAnAiBUkNECAEIAhLDREgA0EkaiAEIAVrIgQQgS4gBARAIAMoAiggAygCLGogBSALaiAE/AoAAAsgAyADKAIsIARqNgIsIANB7ABqIANB+ABqENUJIAMoAmwNAAsLIANBgAFqIANBLGooAgA2AgAgAyADKQIkNwN4IAogA0H4AGoQ8hgMAwsgA0H4AGoiBSAEIAIoAjwQsSYgA0EwaiAFQTj8CgAAIAMoArQBIQUgAyADKAKwASIENgIkIAQhByAEQT9xIgkEQCAEIAlrQUBrIgcgBEkNBwtBwAAhCSAHQcAAENE0RQ0HIAcEQCAHQcAAEK02IglFDQkLIANB+ABqIgwgA0EwakE4/AoAACADIAg2ArwBIAMgCzYCuAEgAyAFNgK0ASADIAQ2ArABIANBGGogDBDWECAJIQUgAygCGEEBcQRAIAMoAhwhBANAIAQgAygCvAEiCE8NCyAFIAMoArgBIARqLQAAOgAAIAVBAWohBSADQRBqIANB+ABqENYQIAMoAhQhBCADKAIQQQFxDQALIAMoAiQhBAsgAyAFIAlrIgU2AmwgBCAFRw0KIAMgBzYCiAEgA0KAgICAgAg3AoABIAMgBDYCfCADIAk2AnggA0EIaiADQfgAahDXOyADKAIIIQdBHEEEEK02IgVFDQsgBUKBgICAEDcCACAFIAMpAng3AgggCiAENgIIIAogBzYCBCAKIAU2AgAgBUEQaiADQYABaikCADcCACAFQRhqIANBiAFqKAIANgIADAILIAIoAgghBCACKAIMIQUgAyAINgKEASADIAs2AoABIAMgBCAFQQJ0ajYCfCADIAQ2AngjAEEgayIEJAAgBEEUaiADQfgAaiIFKAIEIAUoAgBrQQJ2QQBBAUEBEKAYIAQoAhghByAEKAIUQQFGBEAgByAEKAIcQaCCgwEQ/S8ACyAEQRBqIghBADYCACAEIAQoAhw2AgwgBCAHNgIIIwBBEGsiByQAIARBCGoiCSAFKAIEIAUoAgBrQQJ2EIEuIAcgCSkCBEIgiTcCCCAHIAlBCGo2AgQgBSAHQQRqELwbIAdBEGokACADQewAaiIFQQhqIAgoAgA2AgAgBSAEKQIINwIAIARBIGokACAKIAUQ8hgMAQsgA0H4AGogAigCPEEAQQFBARCgGCADKAJ8IQQgAygCeEEBRg0KIANBADYCdCADIAMoAoABNgJwIAMgBDYCbCACKAIMIgQEQCACKAIIIgUgBEEDdGohCQNAIAVBBGooAgAiBCAFKAIAIgdJDQ8gBCAISw0QIANB7ABqIAQgB2siBBCBLiAEBEAgAygCcCADKAJ0aiAHIAtqIAT8CgAACyADIAMoAnQgBGo2AnQgBUEIaiIFIAlHDQALCyADQYABaiADQfQAaigCADYCACADIAMpAmw3A3ggCiADQfgAahDyGAsgA0HAAWokAAwOC0H8rYMBQShB3K+DARCfKQALQbSugwFBOEHsroMBEJ8pAAsgByADKAKAAUH8roMBEP0vAAtB9PmCAUEjQZj6ggEQyyQAC0G4+oIBQSkgA0H4AGpBsIKDAUHk+oIBENUeAAtBwAAgBxCjPQALIAQgCEHsr4MBEMMhAAsgA0IANwKEASADQoGAgIDAADcCfCADQaj7ggE2AnhBACADQewAaiADQSRqIANB+ABqQbD7ggEQrysAC0EEQRwQoz0ACyAEIAMoAoABQayvgwEQ/S8ACyAFIARBjK+DARCxOwALIAQgCEGMr4MBELA7AAsgByAEQbyvgwEQsTsACyAEIAhBvK+DARCwOwALIAZBoAFqIAEQzAYgBkEAOwHYASAGQQA2AtQBIAZBADYCvAEgBkEANgKwASAGQgQ3ApgBIAZCADcCkAEgBkKAgICAwAA3AogBIAZBADYCgAEgBiACKAI8NgKsASAGQRRqIgQgBkGAAWoiBSAKEPojIAZB8ABqIAEQkjYgAhDmGCAGKAJ0BEAgBigCcCEBIAZBiAFqIAZBHGpB1AD8CgAAIAYgATYChAEgBkEBNgKAASAEIAUgBkH0AGoQrhYLIAZB3AFqIgEgBkEUahDNHCAAIAEQthMgBkGgAmokAAuzDQEKfyMAQaACayIGJAAgBkEIaiEKIAEoAhAhCyABKAIUIQgjAEHAAWsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCCACQRBqIgQoAhBPBEACQAJAAkACQAJAAkAgAigCAEEBaw4FAQIDBQUACyADQfgAaiIFIAIoAjxBAEEBQQEQoBggAygCfCEHIAMoAnhBAUYNBiADQQA2AiwgAyADKAKAATYCKCADIAc2AiQgBSAEEMk0IANB7ABqIAUQ1QkgAygCbEEBRgRAA0AgAygCdCIEIAMoAnAiBUkNECAEIAhLDREgA0EkaiAFIAtqIAQgBWsQoTYgA0HsAGogA0H4AGoQ1QkgAygCbA0ACwsgA0GAAWogA0EsaigCADYCACADIAMpAiQ3A3ggCiADQfgAahCTGQwDCyADQfgAaiIFIAQgAigCPBCxJiADQTBqIAVBOPwKAAAgAygCtAEhBSADIAMoArABIgQ2AiQgBCEHIARBP3EiCQRAIAQgCWtBQGsiByAESQ0HC0HAACEJIAdBwAAQ0TRFDQcgBwRAIAdBwAAQrTYiCUUNCQsgA0H4AGoiDCADQTBqQTj8CgAAIAMgCDYCvAEgAyALNgK4ASADIAU2ArQBIAMgBDYCsAEgA0EYaiAMENYQIAkhBSADKAIYQQFxBEAgAygCHCEEA0AgBCADKAK8ASIITw0LIAUgAygCuAEgBGotAAA6AAAgBUEBaiEFIANBEGogA0H4AGoQ1hAgAygCFCEEIAMoAhBBAXENAAsgAygCJCEECyADIAUgCWsiBTYCbCAEIAVHDQogAyAHNgKIASADQoCAgICACDcCgAEgAyAENgJ8IAMgCTYCeCADQQhqIANB+ABqENc7IAMoAgghB0EcQQQQrTYiBUUNCyAFQoGAgIAQNwIAIAUgAykCeDcCCCAKIAQ2AgggCiAHNgIEIAogBTYCACAFQRBqIANBgAFqKQIANwIAIAVBGGogA0GIAWooAgA2AgAMAgsgAigCCCEEIAIoAgwhBSADIAg2AoQBIAMgCzYCgAEgAyAEIAVBAnRqNgJ8IAMgBDYCeCMAQSBrIgQkACAEQRRqIANB+ABqIgUoAgQgBSgCAGtBAnZBAEEBQQEQoBggBCgCGCEHIAQoAhRBAUYEQCAHIAQoAhxBoIKDARD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAc2AggjAEEQayIHJAAgBEEIaiIJIAUoAgQgBSgCAGtBAnYQhC4gByAJKQIEQiCJNwIIIAcgCUEIajYCBCAFIAdBBGoQvBsgB0EQaiQAIANB7ABqIgVBCGogCCgCADYCACAFIAQpAgg3AgAgBEEgaiQAIAogBRCTGQwBCyADQfgAaiACKAI8QQBBAUEBEKAYIAMoAnwhBCADKAJ4QQFGDQogA0EANgJ0IAMgAygCgAE2AnAgAyAENgJsIAIoAgwiBARAIAIoAggiBSAEQQN0aiEJA0AgBUEEaigCACIEIAUoAgAiB0kNDyAEIAhLDRAgA0HsAGogByALaiAEIAdrEKE2IAVBCGoiBSAJRw0ACwsgA0GAAWogA0H0AGooAgA2AgAgAyADKQJsNwN4IAogA0H4AGoQkxkLIANBwAFqJAAMDgtB/K2DAUEoQdyvgwEQnykAC0G0roMBQThB7K6DARCfKQALIAcgAygCgAFB/K6DARD9LwALQfT5ggFBI0GY+oIBEMskAAtBuPqCAUEpIANB+ABqQbCCgwFB5PqCARDVHgALQcAAIAcQoz0ACyAEIAhB7K+DARDDIQALIANCADcChAEgA0KBgICAwAA3AnwgA0Go+4IBNgJ4QQAgA0HsAGogA0EkaiADQfgAakGw+4IBEK8rAAtBBEEcEKM9AAsgBCADKAKAAUGsr4MBEP0vAAsgBSAEQYyvgwEQsTsACyAEIAhBjK+DARCwOwALIAcgBEG8r4MBELE7AAsgBCAIQbyvgwEQsDsACyAGQaABaiABEMwGIAZBADsB2AEgBkEANgLUASAGQQA2ArwBIAZBADYCsAEgBkIENwKYASAGQgA3ApABIAZCgICAgMAANwKIASAGQQA2AoABIAYgAigCPDYCrAEgBkEUaiIEIAZBgAFqIgUgChD6IyAGQfAAaiABEJI2IAIQ5hggBigCdARAIAYoAnAhASAGQYgBaiAGQRxqQdQA/AoAACAGIAE2AoQBIAZBATYCgAEgBCAFIAZB9ABqEK4WCyAGQdwBaiIBIAZBFGoQzRwgACABELgTIAZBoAJqJAALhwIBBX8jAEHQAGsiAiQAIABBDGoiBSAAKAIUIAAoAihBAUEBQdCxgwEQwyggAiABQcAA/AoAACACQcQAaiACENUJAkACQAJAAkAgAigCREEBRgRAA0AgAigCSCIDIAAoAhwiAU8NAiACKAJMIgQgAU8NAyAAKAIYIgYgBEECdGooAgAiASAGIANBAnRqKAIAIgNJDQQgASAAKAIkIgRLDQUgBSAAKAIgIANqIAEgA2sQoTYgAkHEAGogAhDVCSACKAJEDQALCyACQdAAaiQADwsgAyABQZywgwEQwyEACyAEIAFBnLCDARDDIQALIAMgAUHgsYMBELE7AAsgASAEQeCxgwEQsDsAC4cCAQV/IwBB0ABrIgIkACAAQSRqIgUgACgCLCAAKAIAQQFBAUHQsYMBEMMoIAIgAUHAAPwKAAAgAkHEAGogAhDVCQJAAkACQAJAIAIoAkRBAUYEQANAIAIoAkgiAyAAKAIMIgFPDQIgAigCTCIEIAFPDQMgACgCCCIGIARBA3RqKAIAIgEgBiADQQN0aigCACIDSQ0EIAAoAhQiBCABSQ0FIAUgACgCECADaiABIANrEKE2IAJBxABqIAIQ1QkgAigCRA0ACwsgAkHQAGokAA8LIAMgAUGcsIMBEMMhAAsgBCABQZywgwEQwyEACyADIAFB4LGDARCxOwALIAEgBEHgsYMBELA7AAvxAQIDfwJ+IAAoAgwgA0EDdGoiBCAAKAIESwRAIAQQ3iohBCAAIAAoAgRBAXQiBSAEIAQgBUkbEOgZCwJAIANBAk8EQCACQQhqIQQgA0EBaiEDIAIpAwAhBwNAIAQpAwAiCCAHfSIHQgBTIAEgASAHfCIBVUcNAiAAKAIMIgJBCGoiBSAAKAIEIgZLBH8gACAGQQF0IgIgBRDeKiIFIAIgBUsbEOgZIAAoAgwFIAILIAAoAghqIAE3AAAgACAAKAIMQQhqNgIMIARBCGohBCAIIQcgA0EBayIDQQJLDQALCw8LQeSihwFBD0H0oocBEMskAAvzAQEEfyAAKAIMIANBAnRqIgQgACgCBEsEQCAEEN4qIQQgACAAKAIEQQF0IgUgBCAEIAVJGxDoGQsCQCADQQJPBEAgAkEEaiEFIANBAWohBiACKAIAIQIDQCAFKAIAIgQgAmsiAkEASCABIAJqIgMgAUhHDQIgACgCDCIBQQRqIgIgACgCBCIHSwR/IAAgB0EBdCIBIAIQ3ioiAiABIAJLGxDoGSAAKAIMBSABCyAAKAIIaiADNgAAIAAgACgCDEEEajYCDCAFQQRqIQUgBCECIAMhASAGQQFrIgZBAksNAAsLDwtB5KKHAUEPQfSihwEQyyQAC/QBAgF/B34jAEEwayIFJAAgBSABIAIgAyAEENAIIAU1AighDCAFKQMYIQogBSkDECEGIAUoAiQhAyAFKAIgIQIgBSkDCCELAn8CQCAFKQMAIgenIgFFBEAgA0UNASAHUK1CAYYhCCACKQMAIQcgBiEJQgEhBiACQQhqDAILIAFFDQAgBiEJIAshB0IBIQYgAgwBC0IDIQggCiEHIAILIQEgACAENgI4IAAgATYCICAAIAs3AxggACAINwMQIAAgCjcDCCAAIAk3AwAgAEIAIAx9NwMoIAAgAiADQQN0ajYCJCAAIAdCACAGpxs3AzAgBUEwaiQAC6ACAQF/AkACQAJAAkACQAJAAkAgAC0AsAUOBwAGBgQDAQIGCyAAQZgBahD5JSAAQYAFahCHGiAAKQMAQgJRDQQgABCgKQwECwJAIAAtAPgFQQNHDQAgAC0A9AVBA0cNACAAQewFahC8KgsgAEHMBWoQ6SsgACgCuAVBgICAgHhHDQEgAEG4BWoQ9S4MAQsgAEG4BWoQ0S0LIAAtALMFBEAgAEGoA2oQ1AwLIABBADoAswULIABBqAFqEJ0vIAAtALIFBEAgAEGABWoQhxoLAkAgAC0AsQVFDQAgACkDAEICUQ0AIAAQoCkLIAAtALQFRQ0BCyAAKAKUBSIBQQhqEJMfIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQZQFahCWHwsLjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBtKzNAEEpIAJBHGpBmLPNAEHgrM0AENUeAAtBBEEcEKM9AAuXAgACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEBaw4QAQIDBAUGBwgJCgsMDQ4PEAALIABBAjYCAA8LIABBAzYCAA8LIABBBDYCAA8LIABBBTYCAA8LIABBBjYCACAAIAEpAgQ3AgQPCyAAQQc2AgAPCyAAQQg2AgAMCgsgAEEJNgIADAkLIABBCjYCAAwICyAAQQs2AgAPCyAAQQw2AgAPCyAAQQ02AgAPCyAAQQ42AgAPCyAAQQ82AgAPCyAAQRA2AgAgAEEAOgAEDwsgAEKRgICAgICAgIB/NwIADwsgAEGAgICAeDYCCCAAQQA2AgAPCyAAIAEtAAE6AAUgACABLQACOgAEC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQZSf0ABBKSACQRxqQdSi0ABBwJ/QABDVHgALQQRBHBCjPQAL/gECAn8CfiMAQTBrIgIkACACQRRqIgMQ7i8gASgCACEBAkACQCADEOkpDQADQCABKAIEIgMgASkDCCIEIAOtIgUgBCAFVBunIgNGBEAgAigCGA0CIABBJUHAo9AAQQsQzRoMAwsgASAEQgF8NwMIIAJBKGogAkEUaiABKAIAIANqLQAAENQmAkAgAi0AKEEERg0AIAIpAygiBEL/AYNCBFENACAAIAQ3AgAMAwsgAkEUahDpKUUNAAsLIAJBCGogAkEUahCBKCACKAIIQQFxBEAgAigCDCEBIABBBDoAACAAIAE2AgQMAQsgAEElQcCj0ABBCxDNGgsgAkEwaiQAC9QBAQZ/AkACQCACQQNrIgMgAE0EfyAABSABKAAAIgQgACgAACIFRw0CIABBBGohBSABQQRqIQhBACEEAkADQCAEIAVqIgYgA08NASAEIAhqIARBBGohBCgAACIHIAYoAAAiBkYNAAsgBiAHc2hBA3YgBGoPCyABIARqQQRqIQEgACAEakEEagsiAyACQQFrTw0AIAEvAAAgAy8AAEcNACABQQJqIQEgA0ECaiEDCyACIANLBH8gAyABLQAAIAMtAABGagUgAwsgAGsPCyAEIAVzaEEDdguAAgEDfwJAAkACQAJAAkACQAJAAkACQCABKAIAIgRBioCAgHhGDQAgASEDQQEgBEGAgICAeHMgBEEAThsOBwEHAgMEBQYACyAAIAFBJPwKAAAgAigCAEUNByACQQhqEIYwDwsgAUEEaiEDDAULIAFBBGohAwwECyABQQRqIQMMAwsgAUEEaiEDDAILIAFBBGohAwwBCyABQQRqIQMLIAMoAggiBCADKAIARgRAIANB4OH+ABCvKAsgAygCBCAEQRRsaiIFIAIpAgA3AgAgBUEQaiACQRBqKAIANgIAIAVBCGogAkEIaikCADcCACADIARBAWo2AgggACABQST8CgAACwuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0Hci/8AQSkgAkEcakHsj/8AQYiM/wAQ1R4AC0EEQRwQoz0AC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQaDjgAFBKSACQRxqQfTkgAFBzOOAARDVHgALQQRBHBCjPQALjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBvLKCAUEpIAJBHGpBmLOCAUHosoIBENUeAAtBBEEcEKM9AAuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0GwwIIBQSkgAkEcakHgyIIBQdzAggEQ1R4AC0EEQRwQoz0AC44CAgR/AX4jAEEwayICJAACQEEAQcAAENE0BEAgASgCCCEDIAFBwAA2AgggASkCACEGIAFCwAA3AgAgASgCECEFIAEoAgwhBCABQgA3AgwgAiAGNwIoIAJBADYCJCACIAQ2AiAgAiADNgIcIAJBCGogAkEcahDXOyACKAIIIQNBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACIAQ2AhggAiADNgIUIAIgATYCECAAIAJBEGpBACAFEPIVIAJBMGokAA8LQeCygwFBKSACQRxqQayzgwFBjLODARDVHgALQQRBHBCjPQALjgICBH8BfiMAQTBrIgIkAAJAQQBBwAAQ0TQEQCABKAIIIQMgAUHAADYCCCABKQIAIQYgAULAADcCACABKAIQIQUgASgCDCEEIAFCADcCDCACIAY3AiggAkEANgIkIAIgBDYCICACIAM2AhwgAkEIaiACQRxqENc7IAIoAgghA0EcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAIgBDYCGCACIAM2AhQgAiABNgIQIAAgAkEQakEAIAUQ8hUgAkEwaiQADwtBlOeEAUEpIAJBHGpB8OiEAUHA54QBENUeAAtBBEEcEKM9AAuOAgIEfwF+IwBBMGsiAiQAAkBBAEHAABDRNARAIAEoAgghAyABQcAANgIIIAEpAgAhBiABQsAANwIAIAEoAhAhBSABKAIMIQQgAUIANwIMIAIgBjcCKCACQQA2AiQgAiAENgIgIAIgAzYCHCACQQhqIAJBHGoQ1zsgAigCCCEDQRxBBBCtNiIBRQ0BIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAiAENgIYIAIgAzYCFCACIAE2AhAgACACQRBqQQAgBRDyFSACQTBqJAAPC0H09IQBQSkgAkEcakHQ9oQBQaD1hAEQ1R4AC0EEQRwQoz0AC4ACAQp/IwBB0ABrIgIkACACQcQAaiABENkGIAEoAgwiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgASgCFCEGIAEoAhAhByABKAIYIgMEQCADIAMoAgAiBEEBajYCACAEQQBIDQEgASgCKCEIIAEoAiQhCSABKAIgIQogASgCHCELIAEoAiwhBAsgAkEQaiACQcwAaigCADYCACACIAIpAkQ3AwggAiAENgI0IAIgCDYCMCACIAk2AiwgAiAKNgIoIAIgCzYCJCACIAM2AiAgAiAGNgIcIAIgBzYCGCACIAU2AhQgAiABKQIwNwM4IAAgAkEIahDkFSACQdAAaiQADwsAC4ICAQR/IAAoAggiAwRAIAAoAgQhAANAIABBBEEEEOAeIABByABqEMsMIABBOGoiASgCAARAIAEQzy8LIABBDGoQzy8gAEEcahDPLyAAQSxqIgEQihQgAUEEQcwBEOAeIABBgAFqIgEoAgBBgICAgHhHBEAgARClHgsgAEHcAGoiARDFJyABQQRBDBDgHiAAQegAaiIBEIEjIAFBBEEIEOAeIABB9ABqIgEQgSMgAUEEQQgQ4B4gAEHEAWooAgAhASAAQcgBaigCACIEKAIAIgIEQCABIAIRAwALIAQoAgQiAgRAIAEgAiAEKAIIEPg6CyAAQcwBaiEAIANBAWsiAw0ACwsLkAIBA38jAEEQayIDJAAgACAAKAIIIgJBASACGzYCCAJAAkACQAJAAkACQAJAIAIOAwAFAQULIAEoAgAhAiAAKAIAIgQNASABKAIEIQEMAgsgASgCBCABKAIAKAIIEQMADAMLIAEoAgQiASAAKAIERw0AIAIgBEYNAQsgA0EIaiABIAIoAgARAAAgAygCDCEBIAMoAgghAiAAKAIAIgQEQCAAKAIEIAQoAgwRAwALIAAgATYCBCAAIAI2AgALIABBACAAKAIIIgEgAUEBRiIBGzYCCCABDQAgACgCACEBIABBADYCACABRQ0BIAAoAgQgAEEANgIIIAEoAgQRAwALIANBEGokAA8LQbiriAEQsjsAC/8BAQd/IAEoAgAiCC8BBiECEKgvIgNBADsBBiADQQA2AgAgASADEIUcIQcgAy8BBiIGQQFqIQQCQCAGQQxJBEAgAiABKAIIIgJrIgUgBEcNASADQRRqIQQgBUECdCIFBEAgBCAIIAJBAnRqQRhqIAX8CgAACyAHQf8BcSEHIAEoAgQhAkEAIQEDQAJAIAQgAUECdGooAgAiBSABOwEEIAUgAzYCACABIAZPDQAgASABIAZJaiIBIAZNDQELCyAAIAc6ABAgACACNgIEIAAgCDYCACAAIAI2AgwgACADNgIIDwsgBEEMQYS4zQAQsDsAC0G8t80AQShB5LfNABCfKQALgwICA38BfiMAQTBrIgIkACACQQA6ABMgAkEUaiIDEO4vIAEoAgAhAQJAAkAgAxDpKQ0AA0AgASgCACIDIAJBE2ogAygCCCIDQQBHIgQQlxogASABKAIEIARqNgIEIANFBEAgAigCGA0CIABBJUHc880AQQsQzRoMAwsgAkEoaiACQRRqIAItABMQ1CYCQCACLQAoQQRGDQAgAikDKCIFQv8Bg0IEUQ0AIAAgBTcCAAwDCyACQRRqEOkpRQ0ACwsgAkEIaiACQRRqEIEoIAIoAghBAXEEQCACKAIMIQEgAEEEOgAAIAAgATYCBAwBCyAAQSVB3PPNAEELEM0aCyACQTBqJAALlkQCMX8CfiMAQcACayIKJAAgCkECOgAeIApBADYCFCAKQoCAgIAgNwIMIApBADsBHCAKIAE2AhggCkE4aiEEIwBB8AVrIgEkACABQbgCaiAKQQxqIgUQ8ScgAUGYAWoiGSABQcQCaiICKAIANgIAIAEgASkCvAI3A5ABAkAgASgCuAIiA0EERwRAIAEoAsgCIQIgBCABKQOQATcCDCAEIAI2AhggBCADNgIIIARCBDcDACAEQRRqIBkoAgA2AgAMAQsgAUEoaiIkIBkoAgA2AgAgASABKQOQATcDICABQSBqEIYwIAFBADYCCCABQgM3AyAgAUIDNwOQASABQbgCaiAFELMOIAFBuANqIAIpAgA3AwAgAUHAA2oiJSABQcwCaigCADYCACABIAEpArwCNwOwAwJAAkACQCABKAK4AkUEQCABQTxqISwgAUHUAmohKiABQcACaiEYIAFBxQJqISsgAUGsAWohLSABQbwCaiEmQQMhGgNAIAFBmAJqICUoAgAiAjYCACABQZACaiABQbgDaiIuKQMANwMAIAEgASkDsAM3A4gCAkACQAJAAkACQAJAIAJB/wFxBEAgAUG4AmogAUGIAmoQ/BcgAS8BvAIhAiABKAK4AiIDQQRHBEAgBCABKQG+AjcBDiAEQRRqIAFBxAJqKQEANwEAIAQgAjsBDCAEIAM2AgggBEIENwMADAsLAkACQAJAAkACQAJAAkACQAJAIAJBAWsOCAABAgMEBQYHCAsgAUG4AmogBRCIJiABKAK8AiEdIAEoArgCIgJBBEYNCSAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAdNgIMIAQgAjYCCCAEQgQ3AwAMEgsgAUG4AmogBRCIJiABKAK8AiEeIAEoArgCIgJBBEcEQCAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAeNgIMIAQgAjYCCCAEQgQ3AwAMEgtBASEgDA0LIAFBuAJqIAUQiCYgASgCvAIhHyABKAK4AiICQQRHBEAgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHzYCDCAEIAI2AgggBEIENwMADBELQQEhIQwMCyABQbgCaiAFEIgmIAEoArwCISIgASgCuAIiAkEERwRAIAQgASkCwAI3AhAgBEEYaiABQcgCaigCADYCACAEICI2AgwgBCACNgIIIARCBDcDAAwQC0EBISgMCwsgAUG4AmohA0EAIQhBACENQQAhEEEAIQxBACEHQQAhCUEAIQ5BACELIwBBwAJrIgIkACACQagBaiAFEPEnIAJBKGoiBiACQbQBaiITKAIANgIAIAIgAikCrAE3AyACQCACKAKoASIRQQRHBEAgAigCuAEhByADIAIpAyA3AgwgAyAHNgIYIAMgETYCCCADQgM3AwAgA0EUaiAGKAIANgIADAELIAJBiAJqIhEgBigCADYCACACIAIpAyA3A4ACIAJBgAJqEIYwIAJCAjcDICACQagBaiAFELMOIBEgEykCADcDACACQZACaiITIAJBvAFqKAIANgIAIAIgAikCrAE3A4ACAkACQCACKAKoAUUEQCACQTxqIRYgAkHEAWohFyACQbABaiERIAJBrAFqIRQDQCACQYgBaiATKAIAIg82AgAgAkGAAWogAkGIAmoiGykDADcDACACIAIpA4ACNwN4AkACQAJAAkACQAJAAkAgD0H/AXEEQCACQagBaiACQfgAahD8FyACLwGsASEPIAIoAqgBIhVBBEcEQCADIAIpAa4BNwEOIANBFGogAkG0AWopAQA3AQAgAyAPOwEMIAMgFTYCCCADQgM3AwAMCwsCQAJAAkACQAJAAkAgD0EBaw4FAAECAwQFCyACQagBaiAFEIgmIAIoAqwBIQcgAigCqAEiDEEERg0GIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAc2AgwgAyAMNgIIIANCAzcDAAwPCyACQagBaiAFEIgmIAIoAqwBIQkgAigCqAEiEEEERwRAIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAk2AgwgAyAQNgIIIANCAzcDAAwPC0EBIRAMCwsgAkGoAWogBRCIJiACKAKsASEOIAIoAqgBIg1BBEcEQCADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAONgIMIAMgDTYCCCADQgM3AwAMDgtBASENDAoLIAJBqAFqIAUQiCYgAigCrAEhCyACKAKoASIIQQRHBEAgAyACKQKwATcCECADQRhqIAJBuAFqKAIANgIAIAMgCzYCDCADIAg2AgggA0IDNwMADA0LQQEhCAwJCyACQagBaiAFEO0CIAJBmAFqIg8gEUEIaikDADcDACACQaABaiIVIBFBEGooAgA2AgAgAiARKQMANwOQASACKQOoASIzQgJRDQcgAkGAAmoiEiAXQTz8CgAAIAJBuAFqIicgFSgCADYCACACQbABaiIVIA8pAwA3AwAgAiACKQOQATcDqAEgAkEgahDxKyAGIAIpA6gBNwMAIAZBCGogFSkDADcDACAGQRBqICcoAgA2AgAgAiAzNwMgIBYgEkE8/AoAAAwICyACQagBaiAFIAItAIgBQcAAELQCIAIoAqgBIg9BBEYNByADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgDzYCCAwKCyACIAs2AhwgAiAINgIYIAIgDjYCFCACIA02AhAgAiAJNgIMIAIgEDYCCCACIAc2AgQgAiAMNgIAIAJB+ABqEIYwIAJBqAFqIAUQqikgAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQbyD0ABBGSACEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakHVg9AAQRcgAkEIahDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgAkGoAWpB7IPQAEEoIAJBEGoQ5h4gAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQZSE0ABBKCACQRhqEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyAMRQ0BIBBFDQIgDUUNAyAIRQ0EIAMgAkEgakHYAPwKAAAgAyALNgJkIAMgDjYCYCADIAk2AlwgAyAHNgJYDAsLQQEhDAwFC0H4/M8AQccAQbyE0AAQyyQAC0H4/M8AQccAQcyE0AAQyyQAC0H4/M8AQccAQdyE0AAQyyQAC0H4/M8AQccAQeyE0AAQyyQACyADIAIpA5ABNwMIIANCAzcDACADQRhqIAJBoAFqKAIANgIAIANBEGogAkGYAWopAwA3AwAMAwsgAkH4AGoQhjAgAkGoAWogBRCzDiAbIBRBCGopAgA3AwAgEyAUQRBqKAIANgIAIAIgFCkCADcDgAIgAigCqAFFDQALCyADIAIpA4ACNwIIIANCAzcDACADQRhqIBMoAgA2AgAgA0EQaiACQYgCaikDADcCAAwBCyACQfgAahCGMAsgAkEgahDxKwsgAkHAAmokACABQagCaiICIBhBCGopAwA3AwAgAUGwAmoiAyAYQRBqKAIANgIAIAEgGCkDADcDoAIgASkDuAIiM0IDUQ0NIAFBsANqICpBzAD8CgAAIAFByAJqIgcgAygCADYCACABQcACaiIDIAIpAwA3AwAgASABKQOgAjcDuAIgASkDIEIDUgRAIAFBIGoQ8SsLICQgASkDuAI3AwAgJEEIaiADKQMANwMAICRBEGogBygCADYCACABIDM3AyAgLCABQbADakHMAPwKAAAMCgsgAUG4AmohAyMAQdAAayICJAAgAkE4aiAFEPEnIAJBKGoiByACQcQAaiIJKAIANgIAIAIgAikCPDcDIAJAIAIoAjgiCEEERwRAIAIoAkghCSADIAIpAyA3AgQgAyAJNgIQIAMgCDYCACADQQxqIAcoAgA2AgAMAQsgAkEQaiAHKAIANgIAIAIgAikDIDcDCCACQQhqEIYwIAJBOGogBRCzDiAHIAkpAgA3AwAgAkEwaiIHIAJBzABqKAIANgIAIAIgAikCPDcDIAJAAkAgAigCOEUEQCACQTxqIQkDQCACQRhqIAcoAgAiCDYCACACQRBqIAJBKGoiDSkDADcDACACIAIpAyA3AwggCEH/AXFFDQMgAkE4aiIOIAUgCEHAABC0AiACKAI4IghBBEcNAiACQQhqEIYwIA4gBRCzDiANIAlBCGopAgA3AwAgByAJQRBqKAIANgIAIAIgCSkCADcDICACKAI4RQ0ACwsgAyACKQMgNwIAIANBEGogBygCADYCACADQQhqIAJBKGopAwA3AgAMAgsgAyACKQI8NwIEIANBDGogAkHEAGopAgA3AgAgAyAINgIAIAJBCGoQhjAMAQsgAkEIahCGMCACQThqIAUQqikgAigCOCIHQQRHBEAgAyACKQI8NwIEIANBDGogAkHEAGopAgA3AgAgAyAHNgIADAELIANBBDYCAAsgAkHQAGokACABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMDgtBASEpDAkLIAFBuAJqIQNBACEJQQAhDkEAIQcjAEHgAGsiAiQAIAJByABqIAUQ8ScgAkE4aiIIIAJB1ABqIg0oAgA2AgAgAiACKQJMNwMwAkAgAigCSCILQQRHBEAgAigCWCEHIAMgAikDMDcCBCADIAc2AhAgAyALNgIAIANBDGogCCgCADYCAAwBCyACQSBqIAgoAgA2AgAgAiACKQMwNwMYIAJBGGoQhjAgAkHIAGogBRCzDiAIIA0pAgA3AwAgAkFAayILIAJB3ABqKAIANgIAIAIgAikCTDcDMAJAIAIoAkhFBEAgAkHMAGohEEEAIQhBAiENA0AgAkEoaiALKAIAIgw2AgAgAkEgaiACQThqIgYpAwA3AwAgAiACKQMwNwMYAkACQAJAAkAgDEH/AXEEQCACQcgAaiACQRhqEPwXIAIvAUwhDCACKAJIIhpBBEcEQCADIAIpAU43AQYgA0EMaiACQdQAaikBADcBACADIAw7AQQgAyAaNgIADAgLAkACQAJAAkAgDEEBaw4DAAECAwsgAkHIAGogBRCIJiACKAJMIQ4gAigCSCIJQQRGDQQgAyACKQJQNwIIIANBEGogAkHYAGooAgA2AgAgAyAONgIEIAMgCTYCAAwKCyACQcgAaiAFEIgmIAIoAkwhByACKAJIIghBBEcEQCADIAIpAlA3AgggA0EQaiACQdgAaigCADYCACADIAc2AgQgAyAINgIADAoLQQEhCAwGCyACQcgAaiAFEOwTIAItAEwhDSACKAJIIgxBBEYNBSADIAIpAE03AAUgA0EMaiACQdQAaikAADcAACADIA06AAQgAyAMNgIADAgLIAJByABqIAUgAi0AKEHAABC0AiACKAJIIgxBBEYNBCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAw2AgAMBwsgAiAHNgIUIAIgCDYCECACIA42AgwgAiAJNgIIIAJBGGoQhjAgAkHIAGogBRCqKSACKAJIIgtBBEcEQCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAs2AgAMCAsgAkHIAGpB54XQAEEfIAJBCGoQ5h4gAigCSCILQQRHBEAgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyALNgIADAgLIAJByABqQYaG0ABBHSACQRBqEOYeIAIoAkgiC0EERwRAIAMgAikCTDcCBCADQQxqIAJB1ABqKQIANwIAIAMgCzYCAAwICyAJRQ0BIAhFDQIgAyANOgAMIAMgBzYCCCADIA42AgQgA0EENgIADAcLQQEhCQwCC0H4/M8AQccAQaSG0AAQyyQAC0H4/M8AQccAQbSG0AAQyyQACyACQRhqEIYwIAJByABqIAUQsw4gBiAQQQhqKQIANwMAIAsgEEEQaigCADYCACACIBApAgA3AzAgAigCSEUNAAsLIAMgAikDMDcCACADQRBqIAsoAgA2AgAgA0EIaiACQThqKQMANwIADAELIAJBGGoQhjALIAJB4ABqJAAgAUGyA2oiAiArQQJqLQAAOgAAIAEgKy8AADsBsAMgAS0AxAIhGiABKQK8AiE0IAEoArgCIgNBBEcEQCABKALIAiEFIAQgAS8BsAM7ABUgBCAFNgIYIAQgGjoAFCAEIDQ3AgwgBCADNgIIIARCBDcDACAEQRdqIAItAAA6AAAMDQsgAUGOAWogAi0AADoAACABIAEvAbADOwGMAQwICyABQbgCaiEDQQAhEEEAIQxBACETQQAhEUEAIRRBACEHQQAhCUEAIQ5BACELQQAhCEEAIQ0jAEHQAmsiAiQAIAJBuAFqIAUQ8ScgAkE4aiIGIAJBxAFqIhYoAgA2AgAgAiACKQK8ATcDMAJAIAIoArgBIg9BBEcEQCACKALIASEHIAMgAikDMDcCDCADIAc2AhggAyAPNgIIIANCAzcDACADQRRqIAYoAgA2AgAMAQsgAkGYAmoiFyAGKAIANgIAIAIgAikDMDcDkAIgAkGQAmoQhjBBACEPIAJBADYCACACQQA2AgggAkEANgIQIAJCAjcDMCACQbgBaiAFELMOIBcgFikCADcDACACQaACaiIWIAJBzAFqKAIANgIAIAIgAikCvAE3A5ACAkACQCACKAK4AUUEQCACQcwAaiEnIAJB1AFqIS8gAkHAAWohFyACQbwBaiEbQQIhFQNAIAJBmAFqIBYoAgAiEjYCACACQZABaiACQZgCaiIwKQMANwMAIAIgAikDkAI3A4gBAkACQAJAAkACQAJAAkACQAJAIBJB/wFxBEAgAkG4AWogAkGIAWoQ/BcgAi8BvAEhEiACKAK4ASIcQQRHBEAgAyACKQG+ATcBDiADQRRqIAJBxAFqKQEANwEAIAMgEjsBDCADIBw2AgggA0IDNwMADA0LAkACQAJAAkACQAJAAkACQAJAIBJBAWsOCAABAgMEBQYHCAsgAkG4AWogBRCIJiACKAK8ASEHIAIoArgBIhRBBEYNCSADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAHNgIMIAMgFDYCCCADQgM3AwAMFAsgAkG4AWogBRCIJiACKAK8ASEJIAIoArgBIhFBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAJNgIMIAMgETYCCCADQgM3AwAMFAtBASERDBALIAJBuAFqIAUQiCYgAigCvAEhDiACKAK4ASITQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgDjYCDCADIBM2AgggA0IDNwMADBMLQQEhEwwPCyACQbgBaiAFEIgmIAIoArwBIQsgAigCuAEiDEEERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIAs2AgwgAyAMNgIIIANCAzcDAAwSC0EBIQwMDgsgAkG4AWogBRCIJiACKAK8ASEIIAIoArgBIhBBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyAINgIMIAMgEDYCCCADQgM3AwAMEQtBASEQDA0LIAJBuAFqIAUQiCYgAigCvAEhDSACKAK4ASIPQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgDTYCDCADIA82AgggA0IDNwMADBALQQEhDwwMCyACQbgBaiAFEOwTIAItALwBIRUgAigCuAEiEkEERg0LIAMgAikAvQE3AA0gA0EUaiACQcQBaikAADcAACADIBU6AAwgAyASNgIIIANCAzcDAAwOCyACQbgBaiAFEO0CIAJBqAFqIhIgF0EIaikDADcDACACQbABaiIcIBdBEGooAgA2AgAgAiAXKQMANwOgASACKQO4ASIzQgJRDQkgAkGQAmoiMSAvQTz8CgAAIAJByAFqIjIgHCgCADYCACACQcABaiIcIBIpAwA3AwAgAiACKQOgATcDuAEgAkEwahDxKyAGIAIpA7gBNwMAIAZBCGogHCkDADcDACAGQRBqIDIoAgA2AgAgAiAzNwMwICcgMUE8/AoAAAwKCyACQbgBaiAFIAItAJgBQcAAELQCIAIoArgBIhJBBEYNCSADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgEjYCCAwMCyACIA02AiwgAiAPNgIoIAIgCDYCJCACIBA2AiAgAiALNgIcIAIgDDYCGCACIA42AhQgAiATNgIQIAIgCTYCDCACIBE2AgggAiAHNgIEIAIgFDYCACACQYgBahCGMCACQbgBaiAFEKopIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakHhhtAAQRsgAhDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpB/IbQAEEaIAJBCGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQZaH0ABBGSACQRBqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakGvh9AAQRkgAkEYahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpByIfQAEEuIAJBIGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQfaH0ABBLiACQShqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyAURQ0BIBFFDQIgE0UNAyAMRQ0EIBBFDQUgD0UNBiADIAJBMGpB2AD8CgAAIAMgFToAcCADIA02AmwgAyAINgJoIAMgCzYCZCADIA42AmAgAyAJNgJcIAMgBzYCWAwNC0EBIRQMBwtB+PzPAEHHAEGkiNAAEMskAAtB+PzPAEHHAEG0iNAAEMskAAtB+PzPAEHHAEHEiNAAEMskAAtB+PzPAEHHAEHUiNAAEMskAAtB+PzPAEHHAEHkiNAAEMskAAtB+PzPAEHHAEH0iNAAEMskAAsgAyACKQOgATcDCCADQgM3AwAgA0EYaiACQbABaigCADYCACADQRBqIAJBqAFqKQMANwMADAMLIAJBiAFqEIYwIAJBuAFqIAUQsw4gMCAbQQhqKQIANwMAIBYgG0EQaigCADYCACACIBspAgA3A5ACIAIoArgBRQ0ACwsgAyACKQOQAjcCCCADQgM3AwAgA0EYaiAWKAIANgIAIANBEGogAkGYAmopAwA3AgAMAQsgAkGIAWoQhjALIAJBMGoQ8SsLIAJB0AJqJAAgAUGoAmoiAiAYQQhqKQMANwMAIAFBsAJqIgMgGEEQaigCADYCACABIBgpAwA3A6ACIAEpA7gCIjNCA1ENBiABQbADaiAqQdwA/AoAACABQcgCaiIHIAMoAgA2AgAgAUHAAmoiAyACKQMANwMAIAEgASkDoAI3A7gCIAEpA5ABQgNSBEAgAUGQAWoQ8SsLIBkgASkDuAI3AwAgGUEIaiADKQMANwMAIBlBEGogBygCADYCACABIDM3A5ABIC0gAUGwA2pB3AD8CgAADAcLIAFBuAJqIAUgAS0AmAJBwAAQtAIgASgCuAIiAkEERg0GIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAoLIAEgHzYCHCABICE2AhggASAeNgIUIAEgIDYCECABIB02AgwgASAjNgIIIAFBiAJqEIYwIAFBuAJqIAUQqikgASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLIAFBuAJqQeyJ0ABBECABQQhqEOYeIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyABQbgCakH8idAAQSEgAUEQahDmHiABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMCwsgAUG4AmpBnYrQAEEfIAFBGGoQ5h4gASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLICNFDQEgIEUNAiAhRQ0DIAFBkARqIgIgAUEgakHoAPwKAAAgBEHzAWogAUGOAWotAAA6AAAgBCABLwGMATsA8QEgAUH4BGogAUGQAWpB+AD8CgAAIAQgAkHgAfwKAAAgBCApOgCAAiAEIB82AvwBIAQgHjYC+AEgBCAdNgL0ASAEIBo6APABIAQgNDcD6AEgBCAiNgLkASAEICg2AuABDAsLQQEhIwwEC0H4/M8AQccAQbyK0AAQyyQAC0H4/M8AQccAQcyK0AAQyyQAC0H4/M8AQccAQdyK0AAQyyQACyAEIAEpA6ACNwMIIARCBDcDACAEQRhqIAFBsAJqKAIANgIAIARBEGogAUGoAmopAwA3AwAMBAsgAUGIAmoQhjAgAUG4AmogBRCzDiAuICZBCGopAgA3AwAgJSAmQRBqKAIANgIAIAEgJikCADcDsAMgASgCuAJFDQALCyAEIAEpA7ADNwIIIARCBDcDACAEQRhqICUoAgA2AgAgBEEQaiABQbgDaikDADcCAAwCCyAEIAEpA6ACNwMIIARCBDcDACAEQRhqIAFBsAJqKAIANgIAIARBEGogAUGoAmopAwA3AwALIAFBiAJqEIYwCyABKQOQAUIDUgRAIAFBkAFqEPErCyABKQMgQgNRDQAgAUEgahDxKwsgAUHwBWokACAKQShqIApByABqKQMANwMAIApBMGogCkHQAGooAgA2AgAgCiAKKQNANwMgAkAgCikDOCI0QgRRBEAgAEEIaiAKQSBqEKUlDAELIABBHGogCkHUAGpB7AH8CgAAIABBGGogCkEwaigCADYCACAAQRBqIApBKGopAwA3AwAgACAKKQMgNwMICyAKQQxqEJ08IAAgNDcDACAKQcACaiQAC5ZEAjF/An4jAEHAAmsiCiQAIApBAjoAHiAKQQA2AhQgCkKAgICAIDcCDCAKQQA7ARwgCiABNgIYIApBOGohBCMAQfAFayIBJAAgAUG4AmogCkEMaiIFEPEnIAFBmAFqIhkgAUHEAmoiAigCADYCACABIAEpArwCNwOQAQJAIAEoArgCIgNBBEcEQCABKALIAiECIAQgASkDkAE3AgwgBCACNgIYIAQgAzYCCCAEQgQ3AwAgBEEUaiAZKAIANgIADAELIAFBKGoiJCAZKAIANgIAIAEgASkDkAE3AyAgAUEgahCGMCABQQA2AgggAUIDNwMgIAFCAzcDkAEgAUG4AmogBRCyDiABQbgDaiACKQIANwMAIAFBwANqIiUgAUHMAmooAgA2AgAgASABKQK8AjcDsAMCQAJAAkAgASgCuAJFBEAgAUE8aiEsIAFB1AJqISogAUHAAmohGCABQcUCaiErIAFBrAFqIS0gAUG8AmohJkEDIRoDQCABQZgCaiAlKAIAIgI2AgAgAUGQAmogAUG4A2oiLikDADcDACABIAEpA7ADNwOIAgJAAkACQAJAAkACQCACQf8BcQRAIAFBuAJqIAFBiAJqEPwXIAEvAbwCIQIgASgCuAIiA0EERwRAIAQgASkBvgI3AQ4gBEEUaiABQcQCaikBADcBACAEIAI7AQwgBCADNgIIIARCBDcDAAwLCwJAAkACQAJAAkACQAJAAkACQCACQQFrDggAAQIDBAUGBwgLIAFBuAJqIAUQiSYgASgCvAIhHSABKAK4AiICQQRGDQkgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHTYCDCAEIAI2AgggBEIENwMADBILIAFBuAJqIAUQiSYgASgCvAIhHiABKAK4AiICQQRHBEAgBCABKQLAAjcCECAEQRhqIAFByAJqKAIANgIAIAQgHjYCDCAEIAI2AgggBEIENwMADBILQQEhIAwNCyABQbgCaiAFEIkmIAEoArwCIR8gASgCuAIiAkEERwRAIAQgASkCwAI3AhAgBEEYaiABQcgCaigCADYCACAEIB82AgwgBCACNgIIIARCBDcDAAwRC0EBISEMDAsgAUG4AmogBRCJJiABKAK8AiEiIAEoArgCIgJBBEcEQCAEIAEpAsACNwIQIARBGGogAUHIAmooAgA2AgAgBCAiNgIMIAQgAjYCCCAEQgQ3AwAMEAtBASEoDAsLIAFBuAJqIQNBACEIQQAhDUEAIRBBACEMQQAhB0EAIQlBACEOQQAhCyMAQcACayICJAAgAkGoAWogBRDxJyACQShqIgYgAkG0AWoiEygCADYCACACIAIpAqwBNwMgAkAgAigCqAEiEUEERwRAIAIoArgBIQcgAyACKQMgNwIMIAMgBzYCGCADIBE2AgggA0IDNwMAIANBFGogBigCADYCAAwBCyACQYgCaiIRIAYoAgA2AgAgAiACKQMgNwOAAiACQYACahCGMCACQgI3AyAgAkGoAWogBRCyDiARIBMpAgA3AwAgAkGQAmoiEyACQbwBaigCADYCACACIAIpAqwBNwOAAgJAAkAgAigCqAFFBEAgAkE8aiEWIAJBxAFqIRcgAkGwAWohESACQawBaiEUA0AgAkGIAWogEygCACIPNgIAIAJBgAFqIAJBiAJqIhspAwA3AwAgAiACKQOAAjcDeAJAAkACQAJAAkACQAJAIA9B/wFxBEAgAkGoAWogAkH4AGoQ/BcgAi8BrAEhDyACKAKoASIVQQRHBEAgAyACKQGuATcBDiADQRRqIAJBtAFqKQEANwEAIAMgDzsBDCADIBU2AgggA0IDNwMADAsLAkACQAJAAkACQAJAIA9BAWsOBQABAgMEBQsgAkGoAWogBRCJJiACKAKsASEHIAIoAqgBIgxBBEYNBiADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAHNgIMIAMgDDYCCCADQgM3AwAMDwsgAkGoAWogBRCJJiACKAKsASEJIAIoAqgBIhBBBEcEQCADIAIpArABNwIQIANBGGogAkG4AWooAgA2AgAgAyAJNgIMIAMgEDYCCCADQgM3AwAMDwtBASEQDAsLIAJBqAFqIAUQiSYgAigCrAEhDiACKAKoASINQQRHBEAgAyACKQKwATcCECADQRhqIAJBuAFqKAIANgIAIAMgDjYCDCADIA02AgggA0IDNwMADA4LQQEhDQwKCyACQagBaiAFEIkmIAIoAqwBIQsgAigCqAEiCEEERwRAIAMgAikCsAE3AhAgA0EYaiACQbgBaigCADYCACADIAs2AgwgAyAINgIIIANCAzcDAAwNC0EBIQgMCQsgAkGoAWogBRDuAiACQZgBaiIPIBFBCGopAwA3AwAgAkGgAWoiFSARQRBqKAIANgIAIAIgESkDADcDkAEgAikDqAEiM0ICUQ0HIAJBgAJqIhIgF0E8/AoAACACQbgBaiInIBUoAgA2AgAgAkGwAWoiFSAPKQMANwMAIAIgAikDkAE3A6gBIAJBIGoQ8SsgBiACKQOoATcDACAGQQhqIBUpAwA3AwAgBkEQaiAnKAIANgIAIAIgMzcDICAWIBJBPPwKAAAMCAsgAkGoAWogBSACLQCIAUHAABCzAiACKAKoASIPQQRGDQcgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIA82AggMCgsgAiALNgIcIAIgCDYCGCACIA42AhQgAiANNgIQIAIgCTYCDCACIBA2AgggAiAHNgIEIAIgDDYCACACQfgAahCGMCACQagBaiAFEKopIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakG8g9AAQRkgAhDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgAkGoAWpB1YPQAEEXIAJBCGoQ5h4gAigCqAEiBkEERwRAIAMgAikCrAE3AgwgA0EUaiACQbQBaikCADcCACADQgM3AwAgAyAGNgIIDAsLIAJBqAFqQeyD0ABBKCACQRBqEOYeIAIoAqgBIgZBBEcEQCADIAIpAqwBNwIMIANBFGogAkG0AWopAgA3AgAgA0IDNwMAIAMgBjYCCAwLCyACQagBakGUhNAAQSggAkEYahDmHiACKAKoASIGQQRHBEAgAyACKQKsATcCDCADQRRqIAJBtAFqKQIANwIAIANCAzcDACADIAY2AggMCwsgDEUNASAQRQ0CIA1FDQMgCEUNBCADIAJBIGpB2AD8CgAAIAMgCzYCZCADIA42AmAgAyAJNgJcIAMgBzYCWAwLC0EBIQwMBQtB+PzPAEHHAEG8hNAAEMskAAtB+PzPAEHHAEHMhNAAEMskAAtB+PzPAEHHAEHchNAAEMskAAtB+PzPAEHHAEHshNAAEMskAAsgAyACKQOQATcDCCADQgM3AwAgA0EYaiACQaABaigCADYCACADQRBqIAJBmAFqKQMANwMADAMLIAJB+ABqEIYwIAJBqAFqIAUQsg4gGyAUQQhqKQIANwMAIBMgFEEQaigCADYCACACIBQpAgA3A4ACIAIoAqgBRQ0ACwsgAyACKQOAAjcCCCADQgM3AwAgA0EYaiATKAIANgIAIANBEGogAkGIAmopAwA3AgAMAQsgAkH4AGoQhjALIAJBIGoQ8SsLIAJBwAJqJAAgAUGoAmoiAiAYQQhqKQMANwMAIAFBsAJqIgMgGEEQaigCADYCACABIBgpAwA3A6ACIAEpA7gCIjNCA1ENDSABQbADaiAqQcwA/AoAACABQcgCaiIHIAMoAgA2AgAgAUHAAmoiAyACKQMANwMAIAEgASkDoAI3A7gCIAEpAyBCA1IEQCABQSBqEPErCyAkIAEpA7gCNwMAICRBCGogAykDADcDACAkQRBqIAcoAgA2AgAgASAzNwMgICwgAUGwA2pBzAD8CgAADAoLIAFBuAJqIQMjAEHQAGsiAiQAIAJBOGogBRDxJyACQShqIgcgAkHEAGoiCSgCADYCACACIAIpAjw3AyACQCACKAI4IghBBEcEQCACKAJIIQkgAyACKQMgNwIEIAMgCTYCECADIAg2AgAgA0EMaiAHKAIANgIADAELIAJBEGogBygCADYCACACIAIpAyA3AwggAkEIahCGMCACQThqIAUQsg4gByAJKQIANwMAIAJBMGoiByACQcwAaigCADYCACACIAIpAjw3AyACQAJAIAIoAjhFBEAgAkE8aiEJA0AgAkEYaiAHKAIAIgg2AgAgAkEQaiACQShqIg0pAwA3AwAgAiACKQMgNwMIIAhB/wFxRQ0DIAJBOGoiDiAFIAhBwAAQswIgAigCOCIIQQRHDQIgAkEIahCGMCAOIAUQsg4gDSAJQQhqKQIANwMAIAcgCUEQaigCADYCACACIAkpAgA3AyAgAigCOEUNAAsLIAMgAikDIDcCACADQRBqIAcoAgA2AgAgA0EIaiACQShqKQMANwIADAILIAMgAikCPDcCBCADQQxqIAJBxABqKQIANwIAIAMgCDYCACACQQhqEIYwDAELIAJBCGoQhjAgAkE4aiAFEKopIAIoAjgiB0EERwRAIAMgAikCPDcCBCADQQxqIAJBxABqKQIANwIAIAMgBzYCAAwBCyADQQQ2AgALIAJB0ABqJAAgASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDA4LQQEhKQwJCyABQbgCaiEDQQAhCUEAIQ5BACEHIwBB4ABrIgIkACACQcgAaiAFEPEnIAJBOGoiCCACQdQAaiINKAIANgIAIAIgAikCTDcDMAJAIAIoAkgiC0EERwRAIAIoAlghByADIAIpAzA3AgQgAyAHNgIQIAMgCzYCACADQQxqIAgoAgA2AgAMAQsgAkEgaiAIKAIANgIAIAIgAikDMDcDGCACQRhqEIYwIAJByABqIAUQsg4gCCANKQIANwMAIAJBQGsiCyACQdwAaigCADYCACACIAIpAkw3AzACQCACKAJIRQRAIAJBzABqIRBBACEIQQIhDQNAIAJBKGogCygCACIMNgIAIAJBIGogAkE4aiIGKQMANwMAIAIgAikDMDcDGAJAAkACQAJAIAxB/wFxBEAgAkHIAGogAkEYahD8FyACLwFMIQwgAigCSCIaQQRHBEAgAyACKQFONwEGIANBDGogAkHUAGopAQA3AQAgAyAMOwEEIAMgGjYCAAwICwJAAkACQAJAIAxBAWsOAwABAgMLIAJByABqIAUQiSYgAigCTCEOIAIoAkgiCUEERg0EIAMgAikCUDcCCCADQRBqIAJB2ABqKAIANgIAIAMgDjYCBCADIAk2AgAMCgsgAkHIAGogBRCJJiACKAJMIQcgAigCSCIIQQRHBEAgAyACKQJQNwIIIANBEGogAkHYAGooAgA2AgAgAyAHNgIEIAMgCDYCAAwKC0EBIQgMBgsgAkHIAGogBRDrEyACLQBMIQ0gAigCSCIMQQRGDQUgAyACKQBNNwAFIANBDGogAkHUAGopAAA3AAAgAyANOgAEIAMgDDYCAAwICyACQcgAaiAFIAItAChBwAAQswIgAigCSCIMQQRGDQQgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyAMNgIADAcLIAIgBzYCFCACIAg2AhAgAiAONgIMIAIgCTYCCCACQRhqEIYwIAJByABqIAUQqikgAigCSCILQQRHBEAgAyACKQJMNwIEIANBDGogAkHUAGopAgA3AgAgAyALNgIADAgLIAJByABqQeeF0ABBHyACQQhqEOYeIAIoAkgiC0EERwRAIAMgAikCTDcCBCADQQxqIAJB1ABqKQIANwIAIAMgCzYCAAwICyACQcgAakGGhtAAQR0gAkEQahDmHiACKAJIIgtBBEcEQCADIAIpAkw3AgQgA0EMaiACQdQAaikCADcCACADIAs2AgAMCAsgCUUNASAIRQ0CIAMgDToADCADIAc2AgggAyAONgIEIANBBDYCAAwHC0EBIQkMAgtB+PzPAEHHAEGkhtAAEMskAAtB+PzPAEHHAEG0htAAEMskAAsgAkEYahCGMCACQcgAaiAFELIOIAYgEEEIaikCADcDACALIBBBEGooAgA2AgAgAiAQKQIANwMwIAIoAkhFDQALCyADIAIpAzA3AgAgA0EQaiALKAIANgIAIANBCGogAkE4aikDADcCAAwBCyACQRhqEIYwCyACQeAAaiQAIAFBsgNqIgIgK0ECai0AADoAACABICsvAAA7AbADIAEtAMQCIRogASkCvAIhNCABKAK4AiIDQQRHBEAgASgCyAIhBSAEIAEvAbADOwAVIAQgBTYCGCAEIBo6ABQgBCA0NwIMIAQgAzYCCCAEQgQ3AwAgBEEXaiACLQAAOgAADA0LIAFBjgFqIAItAAA6AAAgASABLwGwAzsBjAEMCAsgAUG4AmohA0EAIRBBACEMQQAhE0EAIRFBACEUQQAhB0EAIQlBACEOQQAhC0EAIQhBACENIwBB0AJrIgIkACACQbgBaiAFEPEnIAJBOGoiBiACQcQBaiIWKAIANgIAIAIgAikCvAE3AzACQCACKAK4ASIPQQRHBEAgAigCyAEhByADIAIpAzA3AgwgAyAHNgIYIAMgDzYCCCADQgM3AwAgA0EUaiAGKAIANgIADAELIAJBmAJqIhcgBigCADYCACACIAIpAzA3A5ACIAJBkAJqEIYwQQAhDyACQQA2AgAgAkEANgIIIAJBADYCECACQgI3AzAgAkG4AWogBRCyDiAXIBYpAgA3AwAgAkGgAmoiFiACQcwBaigCADYCACACIAIpArwBNwOQAgJAAkAgAigCuAFFBEAgAkHMAGohJyACQdQBaiEvIAJBwAFqIRcgAkG8AWohG0ECIRUDQCACQZgBaiAWKAIAIhI2AgAgAkGQAWogAkGYAmoiMCkDADcDACACIAIpA5ACNwOIAQJAAkACQAJAAkACQAJAAkACQCASQf8BcQRAIAJBuAFqIAJBiAFqEPwXIAIvAbwBIRIgAigCuAEiHEEERwRAIAMgAikBvgE3AQ4gA0EUaiACQcQBaikBADcBACADIBI7AQwgAyAcNgIIIANCAzcDAAwNCwJAAkACQAJAAkACQAJAAkACQCASQQFrDggAAQIDBAUGBwgLIAJBuAFqIAUQiSYgAigCvAEhByACKAK4ASIUQQRGDQkgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgBzYCDCADIBQ2AgggA0IDNwMADBQLIAJBuAFqIAUQiSYgAigCvAEhCSACKAK4ASIRQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgCTYCDCADIBE2AgggA0IDNwMADBQLQQEhEQwQCyACQbgBaiAFEIkmIAIoArwBIQ4gAigCuAEiE0EERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIA42AgwgAyATNgIIIANCAzcDAAwTC0EBIRMMDwsgAkG4AWogBRCJJiACKAK8ASELIAIoArgBIgxBBEcEQCADIAIpAsABNwIQIANBGGogAkHIAWooAgA2AgAgAyALNgIMIAMgDDYCCCADQgM3AwAMEgtBASEMDA4LIAJBuAFqIAUQiSYgAigCvAEhCCACKAK4ASIQQQRHBEAgAyACKQLAATcCECADQRhqIAJByAFqKAIANgIAIAMgCDYCDCADIBA2AgggA0IDNwMADBELQQEhEAwNCyACQbgBaiAFEIkmIAIoArwBIQ0gAigCuAEiD0EERwRAIAMgAikCwAE3AhAgA0EYaiACQcgBaigCADYCACADIA02AgwgAyAPNgIIIANCAzcDAAwQC0EBIQ8MDAsgAkG4AWogBRDrEyACLQC8ASEVIAIoArgBIhJBBEYNCyADIAIpAL0BNwANIANBFGogAkHEAWopAAA3AAAgAyAVOgAMIAMgEjYCCCADQgM3AwAMDgsgAkG4AWogBRDuAiACQagBaiISIBdBCGopAwA3AwAgAkGwAWoiHCAXQRBqKAIANgIAIAIgFykDADcDoAEgAikDuAEiM0ICUQ0JIAJBkAJqIjEgL0E8/AoAACACQcgBaiIyIBwoAgA2AgAgAkHAAWoiHCASKQMANwMAIAIgAikDoAE3A7gBIAJBMGoQ8SsgBiACKQO4ATcDACAGQQhqIBwpAwA3AwAgBkEQaiAyKAIANgIAIAIgMzcDMCAnIDFBPPwKAAAMCgsgAkG4AWogBSACLQCYAUHAABCzAiACKAK4ASISQQRGDQkgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIBI2AggMDAsgAiANNgIsIAIgDzYCKCACIAg2AiQgAiAQNgIgIAIgCzYCHCACIAw2AhggAiAONgIUIAIgEzYCECACIAk2AgwgAiARNgIIIAIgBzYCBCACIBQ2AgAgAkGIAWoQhjAgAkG4AWogBRCqKSACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpB4YbQAEEbIAIQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQfyG0ABBGiACQQhqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakGWh9AAQRkgAkEQahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgAkG4AWpBr4fQAEEZIAJBGGoQ5h4gAigCuAEiBkEERwRAIAMgAikCvAE3AgwgA0EUaiACQcQBaikCADcCACADQgM3AwAgAyAGNgIIDA0LIAJBuAFqQciH0ABBLiACQSBqEOYeIAIoArgBIgZBBEcEQCADIAIpArwBNwIMIANBFGogAkHEAWopAgA3AgAgA0IDNwMAIAMgBjYCCAwNCyACQbgBakH2h9AAQS4gAkEoahDmHiACKAK4ASIGQQRHBEAgAyACKQK8ATcCDCADQRRqIAJBxAFqKQIANwIAIANCAzcDACADIAY2AggMDQsgFEUNASARRQ0CIBNFDQMgDEUNBCAQRQ0FIA9FDQYgAyACQTBqQdgA/AoAACADIBU6AHAgAyANNgJsIAMgCDYCaCADIAs2AmQgAyAONgJgIAMgCTYCXCADIAc2AlgMDQtBASEUDAcLQfj8zwBBxwBBpIjQABDLJAALQfj8zwBBxwBBtIjQABDLJAALQfj8zwBBxwBBxIjQABDLJAALQfj8zwBBxwBB1IjQABDLJAALQfj8zwBBxwBB5IjQABDLJAALQfj8zwBBxwBB9IjQABDLJAALIAMgAikDoAE3AwggA0IDNwMAIANBGGogAkGwAWooAgA2AgAgA0EQaiACQagBaikDADcDAAwDCyACQYgBahCGMCACQbgBaiAFELIOIDAgG0EIaikCADcDACAWIBtBEGooAgA2AgAgAiAbKQIANwOQAiACKAK4AUUNAAsLIAMgAikDkAI3AgggA0IDNwMAIANBGGogFigCADYCACADQRBqIAJBmAJqKQMANwIADAELIAJBiAFqEIYwCyACQTBqEPErCyACQdACaiQAIAFBqAJqIgIgGEEIaikDADcDACABQbACaiIDIBhBEGooAgA2AgAgASAYKQMANwOgAiABKQO4AiIzQgNRDQYgAUGwA2ogKkHcAPwKAAAgAUHIAmoiByADKAIANgIAIAFBwAJqIgMgAikDADcDACABIAEpA6ACNwO4AiABKQOQAUIDUgRAIAFBkAFqEPErCyAZIAEpA7gCNwMAIBlBCGogAykDADcDACAZQRBqIAcoAgA2AgAgASAzNwOQASAtIAFBsANqQdwA/AoAAAwHCyABQbgCaiAFIAEtAJgCQcAAELMCIAEoArgCIgJBBEYNBiAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwKCyABIB82AhwgASAhNgIYIAEgHjYCFCABICA2AhAgASAdNgIMIAEgIzYCCCABQYgCahCGMCABQbgCaiAFEKopIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyABQbgCakHsidAAQRAgAUEIahDmHiABKAK4AiICQQRHBEAgBCABKQK8AjcCDCAEQRRqIAFBxAJqKQIANwIAIARCBDcDACAEIAI2AggMCwsgAUG4AmpB/InQAEEhIAFBEGoQ5h4gASgCuAIiAkEERwRAIAQgASkCvAI3AgwgBEEUaiABQcQCaikCADcCACAEQgQ3AwAgBCACNgIIDAsLIAFBuAJqQZ2K0ABBHyABQRhqEOYeIAEoArgCIgJBBEcEQCAEIAEpArwCNwIMIARBFGogAUHEAmopAgA3AgAgBEIENwMAIAQgAjYCCAwLCyAjRQ0BICBFDQIgIUUNAyABQZAEaiICIAFBIGpB6AD8CgAAIARB8wFqIAFBjgFqLQAAOgAAIAQgAS8BjAE7APEBIAFB+ARqIAFBkAFqQfgA/AoAACAEIAJB4AH8CgAAIAQgKToAgAIgBCAfNgL8ASAEIB42AvgBIAQgHTYC9AEgBCAaOgDwASAEIDQ3A+gBIAQgIjYC5AEgBCAoNgLgAQwLC0EBISMMBAtB+PzPAEHHAEG8itAAEMskAAtB+PzPAEHHAEHMitAAEMskAAtB+PzPAEHHAEHcitAAEMskAAsgBCABKQOgAjcDCCAEQgQ3AwAgBEEYaiABQbACaigCADYCACAEQRBqIAFBqAJqKQMANwMADAQLIAFBiAJqEIYwIAFBuAJqIAUQsg4gLiAmQQhqKQIANwMAICUgJkEQaigCADYCACABICYpAgA3A7ADIAEoArgCRQ0ACwsgBCABKQOwAzcCCCAEQgQ3AwAgBEEYaiAlKAIANgIAIARBEGogAUG4A2opAwA3AgAMAgsgBCABKQOgAjcDCCAEQgQ3AwAgBEEYaiABQbACaigCADYCACAEQRBqIAFBqAJqKQMANwMACyABQYgCahCGMAsgASkDkAFCA1IEQCABQZABahDxKwsgASkDIEIDUQ0AIAFBIGoQ8SsLIAFB8AVqJAAgCkEoaiAKQcgAaikDADcDACAKQTBqIApB0ABqKAIANgIAIAogCikDQDcDIAJAIAopAzgiNEIEUQRAIABBCGogCkEgahClJQwBCyAAQRxqIApB1ABqQewB/AoAACAAQRhqIApBMGooAgA2AgAgAEEQaiAKQShqKQMANwMAIAAgCikDIDcDCAsgCkEMahCdPCAAIDQ3AwAgCkHAAmokAAvmAQEFfyMAQSBrIgMkAAJAAkAgASgCTCIFIAIgAiAFSxsiBkUNAANAIAECfyABKAJEIgcgASgCSCICRwRAIAEgAiAHIAJrIgIgBiAEayIHIAIgB0kbIgJqNgJIIAUgAmsMAQsgA0EIaiABIAYgBGsQ3Q4gAygCDCECIAMoAggiBUEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwAgACACNgIEIAAgBTYCAAwECyACRQ0CIAEoAkwgAmsLIgU2AkwgAiAEaiIEIAZJDQALCyAAQQg2AgAgACAENgIECyADQSBqJAAL3wQBDH8jAEEwayIDJAAgASgCACECAkAgACgCAEGAgICAeEcEQCACQYCAgIB4Rg0BIABBCGoiCigCACECIAAoAgQhBCABKAIIIQUgASgCBCEBIANBADYCKCADIAEgBWo2AiQgAyABNgIgIAMgAiAEajYCHCADIAQ2AhggAyAFIAIgAiAFSxs2AiwjAEEgayICJAAgAkEUaiADQRhqIgEoAhQgASgCEGtBAEEBQQEQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBwKXOABD9LwALIANBDGohCSACQRBqIgtBADYCACACIAIoAhw2AgwgAiAFNgIIIwBBEGsiBSQAIAEoAhQgASgCEGsiBiACQQhqIgQoAgAgBCgCCCIHa0sEQCAEIAcgBkEBQQEQ0CggBCgCCCEHCyAFIAQoAgQ2AgwgBSAHNgIIIAUgBEEIajYCBCAFQQRqIgYoAgQhBCAGKAIAIAEoAhQiCCABKAIQIgdHBEAgCCAHayEIIAYoAgghDSABKAIAIAdqIQYgASgCCCAHaiEBA0AgBCANaiAGLQAAIAEtAABxOgAAIAZBAWohBiABQQFqIQEgBEEBaiEEIAhBAWsiCA0ACwsgBDYCACAFQRBqJAAgCUEIaiALKAIANgIAIAkgAikCCDcCACACQSBqJAAgABCGMCAKIANBFGooAgA2AgAgACADKQIMNwIADAELAkAgAkGAgICAeEcEQCADQRhqIAEQ5x4MAQsgA0GAgICAeDYCGAsgABCGMCAAQQhqIANBIGooAgA2AgAgACADKQIYNwIACyADQTBqJAALhgIBAn8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAIAMOAgIBAAsDQAJAIAIgA00EQCACIANHDQEMBgsgASADaiwAAEG/f0oNBAsgA0EBayIDQQFLDQALC0EBIQMgAkEBTQRAIAJBAUcNAQwCCyABLAABQb9/Sg0BCyAAQYCAgIB4NgIADAILIAIgA0kNAiADIQILIARBBGogAkEAQQFBARCgGCAEKAIIIQMgBCgCBEEBRg0CIAQoAgwhBSACBEAgBSABIAL8CgAACyAAIAI2AgggACAFNgIEIAAgAzYCAAsgBEEQaiQADwsgAyACQZCFzwAQsDsACyADIAQoAgxBwPXOABD9LwALtxQCFX8CfiMAQUBqIgskACAEIAQoAggiEiADQQZurSIbIAOtfEIgfCIap0EAIBpC/////w9YG2oQji0gEiAEKAIIIglNBEAgASEQIAIhFCAEKAIEIBJqIQogCSASayEIQQAhASMAQRBrIhMkAAJAAkACQAJAAkACQAJAIBsgA60iGnxCIHwiG0KAgICAEFoEQCALQv////8PNwMQIAsgGjcDCCALQQA6AAAMAQsCQCAbpyAITQRAIANFDQEgCEEBayERIBBBDGohFgJ/AkAgGkKAAVQNAANAIAEgCEcEQCABIApqIBqnQYABcjoAACABQQFqIQEgGkL//wBWIBpCB4ghGg0BDAILCyAIIAhBvJ3+ABDDIQALIAEgCEkEQCABIApqIBo8AAAgAUEBagwBCyABIAhBrJ3+ABDDIQALIQUDQAJAIBQhDAJAAkACQAJAAkACfyADQYCABEsEQCAMQYCABGohFCADQYCABGshAUGAgAEhBkGAgAQMAQsgA0ERSQ0BIAMgDGohFEEAIQEgA0GBAkkNAkGAgAEgAyADQYCAAU8bIQYgAwshCUGAAiEHQRghDgNAIA5BAWshDiAHIgJBAXQiByAGSQ0ACyACQYEESQRAIAEhAyAWIQ0MBQsgECgCCCIGRQRAIBNBBGpBgIABQaCT/gAQmRUgEEECQQIQ4B4gEEEIaiICIBNBDGooAgA2AgAgECATKQIENwIAIAIoAgAhBgsgBiAHSQ0CIBAoAgQhDSABIQMMBAsgBSAITw0JIAUgCmogA0ECdEEEazoAACAKIAVBAWoiAmohASADQRBHDQIgASAMKQAANwAAIAFBCGogDEEIaikAADcAACAFQRFqIQUMBAtBgAIhB0EYIQ4gAyEJQQAhAyAWIQ0MAgsgByAGQbCT/gAQsDsACyADBEAgASAMIAP8CgAACyACIANqIQUMAQtBASEGQQAhAiAHQQF0IgEEQCANQQAgAfwLAAsgDEEBayEYIA5BH3EhFSAJQQ9rIRcgDCgAASEPAkACQAJAAkACQAJAAkACQAJAAkADQEEgIQcCfwJAAkACQAJ/AkACQAJAAkADQCAHQQV2IhkgBiIBaiIGIBdLDQEgDSAPQb3P1vEBbCAVdkEBdGoiDy8BACEOIA8gATsBACAHIBlqIQcgBiAMaigAACEPIAEgDGooAAAgDCAOaigAAEcNAAsgASACRg0GIAEgAmsiB0EBayIGQTxJDQIgBkGAAkkNASAFIAhPDRogBSAKakH0AToAACAFQQFqIg8gEU8NGyAKIA9qIAY7AAAgBUEDagwECyACIAlPDRIgCSACayIBQQFrIg1BPE8EQCANQYACTwRAIAUgCEkEQCAFIApqQfQBOgAAIAVBAWoiCSARTw0dIAkgCmogDTsAACAFQQNqIQUMFAsMGwsgBSAITw0cIAUgCmpB8AE6AAAgBUEBaiIJIAhPDQUgCSAKaiANOgAAIAVBAmohBQwSCyAFIAhJDRAMGAsgBSAITw0aIAUgCmpB8AE6AAAgBUEBaiIPIAhJDQEgDyAIQYCT/gAQwyEACyAFIAhJDQQMFgsgCiAPaiAGOgAAIAVBAmoLIQUgBwwDCyAJIAhBgJP+ABDDIQALQdCS/gAQsjsACyAFIApqIAZBAnQ6AAAgBUEBaiEFIAdBECAHIAdBEE0bIAJBEGogCUsbCyIGBEAgBSAKaiACIAxqIAb8CgAACyAFIAdqIQUCQANAIA5BBGohBgJAIAkgAUEMaiIHSQR/IAFBBGoFAkADQCAHIAxqQQhrKQAAIhogBiAMaikAACIbUQRAIAZBCGohBiAJIAdBCGoiB08NAQwCCwsgGiAbhXqnQQN2IAdqQQhrIQIMAgsgB0EIawsiAiAJTw0AIAYgCSAGIAlLGyEHA0AgBiAHRg0FIAIgDGotAAAgBiAMai0AAEcNASAGQQFqIQYgCSACQQFqIgJHDQALIAkhAgsgASAOayEGIAIgAWsiB0HEAE8EQCAGQQh2IQ4DQCAFIAhPDRggBSAKaiIBQf4BOgAAIAVBAWogEU8NFiABQQJqIA46AAAgAUEBaiAGOgAAIAVBA2ohBSAHQUBqIgdBwwBLDQALCwJ/IAdBwABLBEAgBSAITw0YIAUgCmpB7gE6AAAgBUEBaiIBIBFPDRYgASAKaiAGOwAAIAVBA2ohBSAHQTxrIQcLIAdBDEkgBkH/D01xRQRAIAUgCE8NGCAFIApqIAdBAnRBAms6AAAgBUEBaiIBIBFPDRYgASAKaiAGOwAAQQMMAQsgBSAITw0FIAUgCmogB0ECdEEQayAGQQN2QeABcXJBAXI6AAAgBUEBaiIBIAhPDQYgASAKaiAGOgAAQQILIAVqIQUgAiAXTw0BIA0gAiAYaikAACIap0G9z9bxAWwgFXZBAXRqIAJBAWs7AQAgDSAaQgiIpyIHQb3P1vEBbCAVdkEBdGoiAS8BACEOIAEgAjsBACACIQEgDCAOaigAACAHRg0ACyABQQFqIQYgGkIQiKchDwwBCwsgAiAJTw0JIAkgAmsiAUEBayINQTxPBEAgDUGAAk8EQCAFIAhJBEAgBSAKakH0AToAACAFQQFqIgkgEU8NFCAJIApqIA07AAAgBUEDaiEFDAgLDBILIAUgCE8NEyAFIApqQfABOgAAIAVBAWoiCSAITw0EIAkgCmogDToAACAFQQJqIQUMBgsgBSAISQ0EDA8LIAcgCUHAkv4AEMMhAAsgBSAIQZCS/gAQwyEACyABIAhBoJL+ABDDIQALIAkgCEGAk/4AEMMhAAsgBSAKaiANQQJ0OgAAIAVBAWohBSACQRBqIAlLIAFBEEtyDQAgBSAKaiIJIAIgDGoiAikAADcAACAJQQhqIAJBCGopAAA3AAAMAQsgAUUNACAFIApqIAIgDGogAfwKAAALIAEgBWohBQwCCyAFIApqIA1BAnQ6AAAgBUEBaiEFIAJBEGogCUsgAUEQS3INACAFIApqIgkgAiAMaiICKQAANwAAIAlBCGogAkEIaikAADcAACABIAVqIQUMAQsgAQRAIAUgCmogAiAMaiAB/AoAAAsgASAFaiEFCyADDQELCyALQQ46AAAgCyAFNgIEDAILIAsgGzcDECALQQE6AAAgCyAIrTcDCAwBCyALQQE2AgQgCkEAOgAAIAtBDjoAAAsgE0EQaiQADAULIAUgCEGQk/4AEMMhAAsgBSAIQeCS/gAQwyEAC0H4nP4AQSJBnJ3+ABCfKQALIAUgCEHwkv4AEMMhAAsgBSAIQbCS/gAQwyEACwJAIAstAAAiAUEORwRAIAtBMGogC0EQaikDADcDACALQThqIAtBGGopAwA3AwAgCyALLQADOgAjIAsgCy8AATsAISALIAspAwg3AyggCyALKAIENgIkIAsgAToAICAAIAtBIGoQ0SEMAQsgBCALKAIEIBJqEPQ0IABBCDYCAAsgC0FAayQADwsgEiAJQfSKzwAQrzsAC/MBAQN/IAAoAgAgACgCCCIEayABSQRAIAAgBCABQQRBIBDQKCAAKAIIIQQLIAAoAgQgBEEFdGohAwJAAkAgAUECTwRAIAFBAWshBQNAIAMgAikCADcCACADQRhqIAJBGGopAgA3AgAgA0EQaiACQRBqKQIANwIAIANBCGogAkEIaikCADcCACADQSBqIQMgBUEBayIFDQALIAEgBGpBAWshBAwBCyABRQ0BCyADIAIpAgA3AgAgA0EYaiACQRhqKQIANwIAIANBEGogAkEQaikCADcCACADQQhqIAJBCGopAgA3AgAgBEEBaiEECyAAIAQ2AggLhAIBAX8gACgCCCIFIAAoAgBGBEAgAEG4+s8AEKMoCyAAKAIEIAVqIAE6AAAgACAFQQFqNgIIIAAoAhQiASAAKAIMRgRAIABBDGpByPrPABCQKAsgACgCECABQQxsaiIFIAIpAgA3AgAgBUEIaiACQQhqKAIANgIAIAAgAUEBajYCFCAAKAIgIgEgACgCGEYEQCAAQRhqQdj6zwAQkCgLIAAoAhwgAUEMbGoiAiADKQIANwIAIAJBCGogA0EIaigCADYCACAAIAFBAWo2AiAgACgCLCIBIAAoAiRGBEAgAEEkakHo+s8AELMoCyAAKAIoIAFBA3RqIAQ3AwAgACABQQFqNgIsC5ICAQJ/AkACQAJAAkAgACAAKAKMByIFBH8gBQUgACAAKAKIB0EBaiIFNgKIByAFIAAoAgwiBk8NASAFIAAoAgQiBk8NAiAAKAIAIAVqLQAAIQYgACAAKAIIIAVBAnRqKAIAIgU2AowHIAAgBiAAKAIgbDYCkAcgAEEsaiAFIAZBACACIAMgBBCeEiAAKAKMBwtBAWs2AowHIAAoApAHIAFqIgEgACgCFCIFTw0CIAEgACgCHCIFSQ0DIAEgBUGErNAAEMMhAAsgBSAGQdSr0AAQwyEACyAFIAZB5KvQABDDIQALIAEgBUH0q9AAEMMhAAsgACgCECABai0AACAAKAIYIAFBAXRqMwEAIAIgAyAEEOUSC5QCAgF/AX4jAEEQayIFJAACQAJAAkAgA0UgBEVyDQAgAiwAAEG/f0oNACAFQQRqQRpBAEEBQQEQoBggBSgCCCECIAUoAgRBAUYNASAFKAIMIgFBGGpB3MnQAC8AADsAACABQRBqQdTJ0AApAAA3AAAgAUEIakHMydAAKQAANwAAIAFBxMnQACkAADcAACAAQRo2AgwgACABNgIIIAAgAjYCBCAAQQA2AgAMAgsgAUEMaiACIAMQoTYgATUCFCEGIAEoAggiAiABKAIARgRAIAFB8MnQABCzKAsgASgCBCACQQN0aiAGNwMAIABBCDYCACABIAJBAWo2AggMAQsgAiAFKAIMQaTG0AAQ/S8ACyAFQRBqJAALlwIBAn8jAEGgAmsiAiQAIAEoAhQhAyACQeABaiABQQhqKAIANgIAIAJCBDcC0AEgAkIANwLIASACQoCAgIDAADcCwAEgAkEANgK4ASACQQA7AZACIAJBADYCjAIgAkEANgL0ASACQQA2AugBIAIgA0EDdkEBazYC5AEgAiABKQIANwLYAUEYQQQQrTYiA0UEQEEEQRgQoz0ACyADIAEpAhg3AgwgAyABKQIMNwIAIANBFGogAUEgaigCADYCACADQQhqIAFBFGooAgA2AgAgAkECNgKcAiACIAM2ApgCIAJBAjYClAIgAkHcAGoiAyACQbgBaiACQZQCahCWKSACIAMgAUEkahDCGSAAIAIQzRwgAkGgAmokAAuXAgECfyMAQaACayICJAAgASgCFCEDIAJB4AFqIAFBCGooAgA2AgAgAkIENwLQASACQgA3AsgBIAJCgICAgMAANwLAASACQQA2ArgBIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiADQQJ2QQFrNgLkASACIAEpAgA3AtgBQRhBBBCtNiIDRQRAQQRBGBCjPQALIAMgASkCGDcCDCADIAEpAgw3AgAgA0EUaiABQSBqKAIANgIAIANBCGogAUEUaigCADYCACACQQI2ApwCIAIgAzYCmAIgAkECNgKUAiACQdwAaiIDIAJBuAFqIAJBlAJqEJYpIAIgAyABQSRqEMIZIAAgAhDNHCACQaACaiQAC6oCAQd/IwBBEGsiAyQAAkAgACgCACIBRQRAQQAhAAwBCxDMLyEAQYCAgIB4IQICQAJAAkACQAJAAkBBAiABKAIAIgZB/////wdqIAZBgICAgHhNG0EBaw4EAQIDBAALIAEoAgghBCABKAIEIQUgASgCDCEHQYGAgIB4IQIMBAsgASgCBCEFQYKAgIB4IQIgAUEIahCaFCEEDAMLIAEoAgwhByAGQYCAgIB4Rg0CIANBBGogARDPCyADKAIMIQQgAygCCCEFIAMoAgQhAgwCCyABKAIEIQVBhICAgHghAiABQQhqEJoUIQQMAQsgASgCDCEHIAEoAgghBCABKAIEIQUgBiECCyAAIAc2AgwgACAENgIIIAAgBTYCBCAAIAI2AgALIANBEGokACAAC6ICAgN/An4jAEEQayIFJAAgBSACQQBBAUEBEKAYIAUoAgQhBiAFKAIAQQFHBEAgBSgCCCEHIAIEQCAHIAEgAvwKAAALAn5B+POKASgCAEEBRgRAQYj0igEpAwAhCEGA9IoBKQMADAELIAUQ4yZB+POKAUIBNwMAQYj0igEgBSkDCCIINwMAIAUpAwALIQkgACACNgI8IAAgBzYCOCAAIAY2AjQgACAEOgBAIABBADoAQSAAQgA3AyAgACAINwMYIAAgCTcDEEGA9IoBIAlCAXw3AwAgACADKQIANwIoIABB6M6HASkDADcDACAAQQhqQfDOhwEpAwA3AwAgAEEwaiADQQhqKAIANgIAIAVBEGokAA8LIAYgBSgCCEHQzocBEP0vAAvkAQEBfyMAQRBrIgMkACADQQA2AgwgACABIANBDGoCfwJAIAJBgAFPBEAgAkGAEEkNASACQYCABE8EQCADIAJBP3FBgAFyOgAPIAMgAkESdkHwAXI6AAwgAyACQQZ2QT9xQYABcjoADiADIAJBDHZBP3FBgAFyOgANQQQMAwsgAyACQT9xQYABcjoADiADIAJBDHZB4AFyOgAMIAMgAkEGdkE/cUGAAXI6AA1BAwwCCyADIAI6AAxBAQwBCyADIAJBP3FBgAFyOgANIAMgAkEGdkHAAXI6AAxBAgsQ9C4gA0EQaiQAC9kBAgJ/AX4jAEEQayIFJAACQAJAAkAgAq0gBK1+IgdCIIinDQAgB6ciASADQQFraiICIAFJDQAgAkEAIANrcSIGIARBCGpqIgIgBkkgAkGAgICAeCADa0tyDQAgAgR/IAIgAxCtNgUgAwsiAQ0BIAMgAhDlLiAAIAUpAwg3AgQgAEEANgIADAILEOMnIAAgBSkDADcCBCAAQQA2AgAMAQsgAEEANgIMIAAgBEEBayICNgIEIAAgASAGajYCACAAIAIgBEEDdkEHbCACQQhJGzYCCAsgBUEQaiQAC+IBAQh/IAIEQCABQUBrIQogASgCTCEDIAEoAlAhBgNAIAEoAjQiBSACIAdrIgQgBCAFSxsiCCAHaiEHIAMgBiAIaiIGQQN2IAZBB3FBAEdqIgRJBEAgBCADayEJIAEoAkQiBSAESQRAIAogBUEBdCIFIARBwP///wNxQUBrIAQgBEE/cRsiAyADIAVJGxDoGSABKAJMIQMLIAkEQCABKAJIIANqQQAgCfwLAAsgASAENgJMIAQhAwsgASAGNgJQIAEgASgCLCAIajYCLCACIAdLDQALCyAAQQg2AgAgACACNgIEC44CAQF/IwBBEGsiBSQAAkACQCADRSAERXINACACLAAAQb9/Sg0AIAVBBGpBGkEAQQFBARCgGCAFKAIIIQIgBSgCBEEBRwRAIAUoAgwiAUEYakHcydAALwAAOwAAIAFBEGpB1MnQACkAADcAACABQQhqQczJ0AApAAA3AAAgAUHEydAAKQAANwAAIABBGjYCDCAAIAE2AgggACACNgIEIABBADYCAAwCCyACIAUoAgxBpMbQABD9LwALIAFBDGogAiADEKE2IAEoAhQhAyABKAIIIgIgASgCAEYEQCABQfDJ0AAQnSgLIAEoAgQgAkECdGogAzYCACAAQQg2AgAgASACQQFqNgIICyAFQRBqJAAL5AEBAX8jAEEQayICJAAgAkEANgIMIAAgAkEMagJ/AkAgAUGAAU8EQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA1BBAwDCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAILIAIgAToADEEBDAELIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECCxChNiACQRBqJABBAAv5AQIEfwF+IwBBEGsiBCQAIARBCGogARDWEAJAAkAgBCgCCEEBcQRAIAQoAgwhAwNAIAMgASgCRCICTw0CIANBAWoiBSACTw0DIAEoAkgiAiACKQMAIAEoAkAiAiAFQQN0aikDACACIANBA3RqKQMAfUL/////D4N8IgY3AwAgACgCCCIDIAAoAgBGBEAgACABKAI4QQFqIgJBfyACGxDsLQsgACgCBCADQQN0aiAGNwMAIAAgA0EBajYCCCAEIAEQ1hAgBCgCBCEDIAQoAgBBAXENAAsLIARBEGokAA8LIAMgAkGsuIIBEMMhAAsgBSACQby4ggEQwyEAC/0BAgV/AX4gAEEYaiIGIAAoAiAgA0EIQQhBsLGDARDDKAJAAkAgASACRwRAA0AgASgCACIDIAEoAgQiB0kEQCADQQN0IQQDQCADIAAoAgwiBU8NBCADQQFqIgggBU8NBSAAIAApAwAgACgCCCAEaiIDQQhqKQMAIAMpAwB9Qv////8Pg3wiCTcDACAAKAIgIgMgACgCGEYEQCAGQcCxgwEQsygLIAAoAhwgA0EDdGogCTcDACAAIANBAWo2AiAgBEEIaiEEIAgiAyAHRw0ACwsgAUEIaiIBIAJHDQALCw8LIAMgBUGcsIMBEMMhAAsgA0EBaiAFQZywgwEQwyEAC4UCAQl/IwBBEGsiAyQAIAEoAhgiBSAFKAIAIgJBAWo2AgACQCACQQBIDQAgASgCICEGIAEoAhwhByADQQRqIAEQvhUgASgCJCICBEAgAiACKAIAIgRBAWo2AgAgBEEASA0BIAEoAjghBCABKAI0IQggASgCMCEJIAEoAiwhCiABKAIoIQELIABCmrTo0KHDho0aNwIMIAAgBjYCICAAIAc2AhwgACAFNgIYIAAgAykCBDcCACAAIAQ2AjggACAINgI0IAAgCTYCMCAAIAo2AiwgACABNgIoIAAgAjYCJCAAQRRqQZq06NABNgIAIABBCGogA0EMaigCADYCACADQRBqJAAPCwALhQIBCX8jAEEQayIDJAAgASgCGCIFIAUoAgAiAkEBajYCAAJAIAJBAEgNACABKAIgIQYgASgCHCEHIANBBGogARC+FSABKAIkIgIEQCACIAIoAgAiBEEBajYCACAEQQBIDQEgASgCOCEEIAEoAjQhCCABKAIwIQkgASgCLCEKIAEoAighAQsgAEKXrty48eLFixc3AgwgACAGNgIgIAAgBzYCHCAAIAU2AhggACADKQIENwIAIAAgBDYCOCAAIAg2AjQgACAJNgIwIAAgCjYCLCAAIAE2AiggACACNgIkIABBFGpBl67cuAE2AgAgAEEIaiADQQxqKAIANgIAIANBEGokAA8LAAuJAgEDfyMAQSBrIgMkACADQRRqIAFBAWpBAEEIQQgQoBggAygCGCEEAkAgAygCFEEBRwRAIANBADYCECADIAMoAhwiBTYCDCADIAQ2AgggBAR/IAUFIANBCGpBvOaFARCzKCADKAIMC0IANwMAIANBATYCECADQRRqIAJBAEEBQQEQoBggAygCGCECIAMoAhRBAUYNASADKAIcIQQgACADKQIINwIMIAAgATYCMCAAQQA2AiwgAEEANgIYIABBADYCCCAAIAQ2AgQgACACNgIAIABBFGogA0EQaigCADYCACADQSBqJAAPCyAEIAMoAhxBrOaFARD9LwALIAIgAygCHEHM5oUBEP0vAAuJAgEDfyMAQSBrIgMkACADQRRqIAFBAWpBAEEEQQQQoBggAygCGCEEAkAgAygCFEEBRwRAIANBADYCECADIAMoAhwiBTYCDCADIAQ2AgggBAR/IAUFIANBCGpBvOaFARCdKCADKAIMC0EANgIAIANBATYCECADQRRqIAJBAEEBQQEQoBggAygCGCECIAMoAhRBAUYNASADKAIcIQQgACADKQIINwIMIAAgATYCMCAAQQA2AiwgAEEANgIYIABBADYCCCAAIAQ2AgQgACACNgIAIABBFGogA0EQaigCADYCACADQSBqJAAPCyAEIAMoAhxBrOaFARD9LwALIAIgAygCHEHM5oUBEP0vAAvKBgIKfwJ+IwBBQGoiBCQAIAQgATYCPCAEIAI2AjQgBCACIANBAnRqNgI4IARBFGohByMAQTBrIgMkACADQZOAgIB4NgIAIANBKGogBEE0aiICQQhqKAIANgIAIAMgAikCADcDICADIAM2AiwgA0EUaiEIIwBBMGsiAiQAIAJBCGogA0EgaiIFIAJBIGoiCiAFKAIMEMcRAkACQAJAAkAgAigCCEEBcUUNACACKAIMIglFDQAgCkEEQQBBBEEEEKAYIAIoAiQhBiACKAIgQQFGDQIgAkEcaiINQQE2AgAgAigCKCILIAk2AgAgAiALNgIYIAIgBjYCFCACQShqIAVBCGopAgA3AwAgAiAFKQIANwMgIAJBFGohBiMAQSBrIgUkACAFQRBqIAogBUEfaiAKKAIMEMcRAkAgBSgCEEEBcUUNACAFKAIUIgxFDQAgBigCCCIJQQJ0IQsDQCAGKAIAIAlGBEAgBiAJQQFBBEEEENwoCyAGIAlBAWoiCTYCCCAGKAIEIAtqIAw2AgAgBUEIaiAKIAVBH2ogCigCDBDHESAFKAIIQQFxRQ0BIAtBBGohCyAFKAIMIgwNAAsLIAVBIGokACAIQQhqIA0oAgA2AgAgCCACKQIUNwIADAELIAhBADYCCCAIQoCAgIDAADcCAAsgAkEwaiQADAELIAYgAigCKEHc7IcBEP0vAAsCQCADKAIAQZOAgIB4RwRAIAcgAykCADcCACAHQRBqIANBEGooAgA2AgAgB0EIaiADQQhqKQIANwIAIAgQxycgCEEEQQQQ4B4MAQsgByADKQIUNwIEIAdBk4CAgHg2AgAgB0EMaiADQRxqKAIANgIACyADQTBqJAAgBEEQaiIDIARBIGooAgA2AgAgBCAEKQIYNwMIAn8gBCgCFCICQZOAgIB4RwRAIAQoAiQhASAAIAQpAwg3AgggACABNgIUIABBEGogAygCADYCAEEADAELIARBMGogAygCADYCACAEIAQpAwg3AyggASkDGCEOIAEpAyAhDyAAQQhqIAFBCGoQ/iIgACAPNwMgIAAgDjcDGCAEIARBKGoQthkgBCgCBCECIAQoAgALIQEgACACNgIEIAAgATYCACAEQUBrJAALgQIBA38jAEEQayIDJAACQAJAIAEtACwNACADQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAEtABwgAygCDCECIAMoAgghBSABQQE6ABxFBEAgASgCFCIEBEAgASgCGCAEKAIMEQMACyABQQA6ABwgASACNgIYIAEgBTYCFCABLQAsDQEgAEEBNgIADAILIAIgBSgCDBEDAAsgAS0AECABQQE6ABBFBEAgASgCACECIAFBADYCACACBEAgACACNgIEIABBADYCACABQQA6ABAgACABKQIENwIIIABBEGogAUEMaigCADYCAAwCCyABQQA6ABALIABCADcCAAsgA0EQaiQAC+cBAQJ/IwBBIGsiBCQAAkACQCADIAEvASRrIgVBAWtB//8DcUEOTwRAIARBDGogASACEIgaIAQoAgwiAkEERwRAIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAMAwsgBEEMaiABIAMQqRsgBCgCDCICQQRGDQEgACAEKQIQNwIEIABBDGogBEEYaikCADcCAAwCCyAEQQxqIAEgBUEEdCACchCIGiAEKAIMIgJBBEYNACAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAELIAEgAzsBJEEEIQILIAAgAjYCACAEQSBqJAAL5wEBAn8jAEEgayIEJAACQAJAIAMgAS8BJGsiBUEBa0H//wNxQQ5PBEAgBEEMaiABIAIQiRogBCgCDCICQQRHBEAgACAEKQIQNwIEIABBDGogBEEYaikCADcCAAwDCyAEQQxqIAEgAxCoGyAEKAIMIgJBBEYNASAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAILIARBDGogASAFQQR0IAJyEIkaIAQoAgwiAkEERg0AIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAMAQsgASADOwEkQQQhAgsgACACNgIAIARBIGokAAvmAQEBfyMAQTBrIgQkACACEKMuIQICQCADQQ9OBEAgBEEMaiABIAJBcHIQiBogBCgCDCICQQRHBEAgACAEKQIQNwIEIABBDGogBEEYaikCADcCACAAIAI2AgAMAgsgBEEgaiABQSBqIAMQuBoCQCAELQAgQQRGDQAgBCAEKQMgNwMoIARBDGogBEEoahDQCSAEKAIMQQRGDQAgACAEKQIMNwIAIABBEGogBEEcaigCADYCACAAQQhqIARBFGopAgA3AgAMAgsgAEEENgIADAELIAAgASACIANBBHRyEIgaCyAEQTBqJAAL5gEBAX8jAEEwayIEJAAgAhCjLiECAkAgA0EPTgRAIARBDGogASACQXByEIkaIAQoAgwiAkEERwRAIAAgBCkCEDcCBCAAQQxqIARBGGopAgA3AgAgACACNgIADAILIARBIGogAUEgaiADELkaAkAgBC0AIEEERg0AIAQgBCkDIDcDKCAEQQxqIARBKGoQ0AkgBCgCDEEERg0AIAAgBCkCDDcCACAAQRBqIARBHGooAgA2AgAgAEEIaiAEQRRqKQIANwIADAILIABBBDYCAAwBCyAAIAEgAiADQQR0chCJGgsgBEEwaiQAC5ACAQJ/IwBBMGsiAyQAIAMgAjYCAAJAAkACQCACLQAQIgRBAkYEQCABKAIMQYGAgIB4Rg0BIANBATYCCCADQcSFwwA2AgQgA0IBNwIQIANBgwE2AiAgAyADQRxqNgIMIAMgAzYCHCADQQRqQcyFwwAQ7ywACyAEEIscIQQgAi8BDEUNAiAAIAEgBCACLwEOEKoUDAELIAFBDGohBAJAIAIoAgBBgICAgHhGBEAgA0GAgICAeDYCJAwBCyADQSRqIAIQ3SALIAQgAykCJDcCACABQQI6ABwgAEEENgIAIAEgAigCDDYCGCAEQQhqIANBLGooAgA2AgALIANBMGokAA8LQdyFwwBBI0GAhsMAEMskAAuQAgECfyMAQTBrIgMkACADIAI2AgACQAJAAkAgAi0AECIEQQJGBEAgASgCDEGBgICAeEYNASADQQE2AgggA0HEhcMANgIEIANCATcCECADQYMBNgIgIAMgA0EcajYCDCADIAM2AhwgA0EEakHMhcMAEO8sAAsgBBCLHCEEIAIvAQxFDQIgACABIAQgAi8BDhCpFAwBCyABQQxqIQQCQCACKAIAQYCAgIB4RgRAIANBgICAgHg2AiQMAQsgA0EkaiACEN0gCyAEIAMpAiQ3AgAgAUECOgAcIABBBDYCACABIAIoAgw2AhggBEEIaiADQSxqKAIANgIACyADQTBqJAAPC0HchcMAQSNBgIbDABDLJAAL7AECBX8BfiMAQRBrIgMkAAJAIAEpAwgiCFAEQCAAQQQ6AAAMAQsgAigCBCACKAIIIgVrrSAIWARAIAAgAUEQaiACEP8VIAEgASkDCCACKAIIIAVrrX03AwgMAQsgAigCDCEGIAIoAgAhBCADQQA2AgggAyAEIAVqNgIAIAMgCKciBDYCBCADIAYgBWsiByAEIAQgB0sbNgIMIAAgAUEQaiADEP8VIAIgAygCCCIEIAVqIgA2AgggASABKQMIIAStfTcDCCACIAMoAgwgBWoiASAAIAYgACAGSxsiACAAIAFJGzYCDAsgA0EQaiQAC5ACAQJ/IwBBMGsiAyQAIAMgAjYCAAJAAkACQCACLQAQIgRBAkYEQCABKAIMQYGAgIB4Rg0BIANBATYCCCADQZjIzgA2AgQgA0IBNwIQIANBgwE2AiAgAyADQRxqNgIMIAMgAzYCHCADQQRqQaDIzgAQ7ywACyAEEIscIQQgAi8BDEUNAiAAIAEgBCACLwEOEPoXDAELIAFBDGohBAJAIAIoAgBBgICAgHhGBEAgA0GAgICAeDYCJAwBCyADQSRqIAIQ3SALIAQgAykCJDcCACABQQI6ABwgAEEENgIAIAEgAigCDDYCGCAEQQhqIANBLGooAgA2AgALIANBMGokAA8LQbDIzgBBI0HUyM4AEMskAAvqAQECfyMAQRBrIgUkACAFIAI2AgggBSAANgIMIAAgA2ohBgJAIANBB0wEQANAIAAgBk8NAiAAIAItAAA6AAAgAEEBaiEAIAJBAWohAgwACwALIAQEQCAFQQxqIAVBCGogACACaxDFGSADQQhrIQMLIAUoAgwhAiABIAZPBEAgAiAFKAIIIAMgBBDRFQwBCyAFKAIIIQACQCABIAJJBEAgAiEBDAELIAIgACABIAJrIgIgBBDRFSAAIAJqIQALA0AgASAGTw0BIAEgAC0AADoAACABQQFqIQEgAEEBaiEADAALAAsgBUEQaiQAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpas2LDhwoWLFjcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZas2LABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpiw4MCBg4aMGDcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZiw4MABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpSo0KDBgoWKFDcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZSo0KABNgIADwsAC48CAQt/IAEoAgwiBCAEKAIAIgJBAWo2AgACQCACQQBIDQAgASgCGCIFIAUoAgAiAkEBajYCACACQQBIDQAgASgCFCEGIAEoAhAhByABKAIgIQggASgCHCEJIAEoAiQiAgRAIAIgAigCACIDQQFqNgIAIANBAEgNASABKAI4IQMgASgCNCEKIAEoAjAhCyABKAIsIQwgASgCKCEBCyAAQpmy5MiRo8aMGTcCACAAIAM2AjggACAKNgI0IAAgCzYCMCAAIAw2AiwgACABNgIoIAAgAjYCJCAAIAg2AiAgACAJNgIcIAAgBTYCGCAAIAY2AhQgACAHNgIQIAAgBDYCDCAAQQhqQZmy5MgBNgIADwsAC8YCAgJ/A34jAEEgayIBJAAgACgCACEAAkBBmPCKASkDACIDUARAQaDwigEpAwAhBANAIARCf1ENAkGg8IoBIARCAXwiA0Gg8IoBKQMAIgUgBCAFUSICGzcDACAFIQQgAkUNAAtBmPCKASADNwMACwJAAkAgACkDACADUgRAIAAtAAwhAiAAQQE6AAwgASACOgAHIAJFDQEgAUIANwIUIAFCgYCAgMAANwIMIAFByLSJATYCCCABQQdqQfi6iQEgAUEIakHQtIkBEK0rAAsgACgCCCICQX9HBEAgACACQQFqNgIIDAILQeC0iQFBJkGItYkBEMskAAsgAEEBNgIIIAAgAzcDAAsgAUEgaiQAIAAPCyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBnKuJATYCCCAAQgQ3AhAgAEEIakGkq4kBEO8sAAuEAgEDfyMAQSBrIgEkAAJAIAAoAgQiAyAAKAIARg0AQQEhAiAAQQE2AgACQAJAAkACQAJAIAAoAggoAgAiAC0AMEEXaw4KBQQEBQAEAQIEAwQLIAFCgICAgBA3AhQgASAAQTRqNgIcIAFBFGoQtxQgA0EBR3IhAgwECyABQoCAgIAQNwIUIAEgAEE4ajYCHCABQRRqELcUIANBAUdyIQIMAwsgAUKAgICAEDcCFCABIABBNGo2AhwgAUEUahC3FCADQQFHciECDAILIAFBCGogAEE0ahDDNCABKAIIIgAgACABKAIMQQJ0ahC6CiADQQFHciECDAELQQAhAgsgAUEgaiQAIAIL7gEBBX8jAEEQayIDJAAgASgCCCICQQRqIQQCQAJAIAJBe00EQCAEIAEoAgQiBUsNASADQQRqIgYgASgCACIEIAUgAiACIARqKAAAaxD2NAJAAkAgBkEGEMwgQf//A3EiBgRAIAIgBmoiAiAFSw0FIAIgBGotAABBAUYNAQsgAEEANgIADAELIANBBGogARCSFSADKAIEBEAgACADKQIENwIAIABBCGogA0EMaigCADYCAAwBCyAAQQA2AgALIANBEGokAA8LIAIgBEHQzMwAELE7AAsgBCAFQdDMzAAQsDsACyACIAVBjMnMABCvOwAL/AEBAn8jAEEgayIDJAACQCACQRFJBEAgAkUNAQJAIAEsAABBAEgEQCADQQhqQn83AwAgA0J/NwMADAELIANBCGpCADcDACADQgA3AwALIAMgATYCGCADIAEgAmo2AhwCQCADQRhqEIM7IgRFDQAgBCACIAIgBEsbIgRFDQAgAyACa0EQaiABIAT8CgAACyAAIAMpAwA3AAAgAEEIaiADQQhqKQMANwAAIANBIGokAA8LIANBATYCBCADQfT8zgA2AgAgA0IBNwIMIANBOzYCHCADQZz9zgA2AhggAyADQRhqNgIIIANB/PzOABDvLAALQQBBAEGM/c4AEMMhAAu+BAIHfwF+IwBBQGoiAiQAIAJBGGohBCABQSBqIQcjAEHQAGsiAyQAIANBEGogAUEcaiIIKAIAQQhqIgYQwzQgA0EwaiADKAIUQQBBCEG4BRCgGCADKAI0IQUCQCADKAIwQQFHBEAgA0EANgIkIAMgAygCODYCICADIAU2AhwgAyABKAIEIgU2AiggAyAFIAEoAghBAnRqNgIsIANBCGogBhCvLgJAIAMoAggiASADKAIMIgZHBEADQCADQTBqIANBzwBqIAEoAgBBMGogByADQShqIANBHGoiBRC8ASADKAIwIglBCEcEQCAEIAMpAjQ3AgQgBEEUaiADQcQAaigCADYCACAEQQxqIANBPGopAgA3AgAgBCAJNgIAIAUQqwEgBUEIQbgFEOAeDAMLIAFBBGoiASAGRw0ACwsgBCADKQIcNwIEIARBCDYCACAEQQxqIANBJGooAgA2AgALIANB0ABqJAAMAQsgBSADKAI4QfjpzwAQ/S8ACyACQRBqIgEgAkEkaigCADYCACACIAIpAhw3AwgCQAJAIAIoAhgiA0EIRwRAIAIpAyghCiAAIAIpAwg3AgQgACAKNwMQIAAgAzYCACAAQQxqIAEoAgA2AgAMAQsgAkE4aiIDIAEoAgA2AgAgAiACKQMINwMwIAgoAgAiASABKAIAIgRBAWo2AgAgBEEASA0BIAAgAikDMDcCBCAAQQA2AhQgACABNgIQIABBCDYCACAAQQxqIAMoAgA2AgALIAJBQGskAA8LAAvUAQIBfwN+QQEhAiAArcMiA0IBhiIEIANCP4ciBVIEQCAEIAWFIQNBACECA0AgAkEBaiECIANC/wBWIANCB4ghAw0ACwsCQCACQQpNBEBBACECIAQgBYUiA0KAAVQNAQNAIAJBCkcEQCABIAJqIAOnQYABcjoAACACQQFqIQIgA0L//wBWIANCB4ghAw0BDAMLC0EKQQpBsLX+ABDDIQALQay0/gBBNEGQtf4AEJ8pAAsgAkEKTwRAIAJBCkGgtf4AEMMhAAsgASACaiADPAAAIAJBAWoL+QEBBX8jAEEQayIHJAAgASgCCCIFQQRqIQQCQAJAAkAgBUF7TQRAIAQgASgCBCIGSw0BIAdBBGoiCCABKAIAIgQgBiAFIAQgBWooAABrEPY0AkAgCCACEMwgQf//A3EiAUUEQCAAIAMpAgA3AgAgAEEIaiADQQhqKAIANgIADAELIAEgBWoiAUEEaiECIAFBe0sNAyACIAZLDQQgACAGNgIEIAAgBDYCACAAIAEgBGooAAAgAWo2AggLIAdBEGokAA8LIAUgBEGQuf4AELE7AAsgBCAGQZC5/gAQsDsACyABIAJBgLn+ABCxOwALIAIgBkGAuf4AELA7AAvxAQEEfyMAQSBrIgQkACABKAIIIgNBBGohBQJAAkACQCADQXtNBEAgBSABKAIEIgZLDQEgBEEUaiIFIAEoAgAiASAGIAMgASADaigAAGsQ9jQgBSACEMwgQf//A3EiAgR/IAIgA2oiAkEEaiEDIAJBe0sNAyADIAZLDQQgBEEIaiABIAYgASACaigAACACahCsISAEKAIMIQEgBCgCCAVBAAshAiAAIAE2AgQgACACNgIAIARBIGokAA8LIAMgBUGQuf4AELE7AAsgBSAGQZC5/gAQsDsACyACIANBgLn+ABCxOwALIAMgBkGAuf4AELA7AAvxAQEEfyMAQSBrIgQkACABKAIIIgNBBGohBQJAAkACQCADQXtNBEAgBSABKAIEIgZLDQEgBEEUaiIFIAEoAgAiASAGIAMgASADaigAAGsQ9jQgBSACEMwgQf//A3EiAgR/IAIgA2oiAkEEaiEDIAJBe0sNAyADIAZLDQQgBEEIaiABIAYgASACaigAACACahCsISAEKAIMIQEgBCgCCAVBAAshAiAAIAE2AgQgACACNgIAIARBIGokAA8LIAMgBUGA9/4AELE7AAsgBSAGQYD3/gAQsDsACyACIANB8Pb+ABCxOwALIAMgBkHw9v4AELA7AAvlAQIBfwZ+IwBBMGsiBSQAIAUgASACIAMgBBDQCCAFKQMYIQogBSkDECEGIAUoAiQhAyAFKAIgIQEgBSkDCCELIAACfwJAIAUpAwAiB6ciAkUEQCADRQ0BIAdQrUIBhiEIIAEpAwAhByAGIQlCASEGIAFBCGoMAgsgAkUNACAGIQkgCyEHQgEhBiABDAELQgMhCCAKIQcgAQs2AiAgACALNwMYIAAgCDcDECAAIAo3AwggACAJNwMAIABCACAFNQIofTcDMCAAIAdCACAGpxs3AyggACABIANBA3RqNgIkIAVBMGokAAvxAQEDfwJAIABBkM4ASQRAIAAhAgwBCyABQQRrIQEDQCABIABBkM4AbiICQfCxf2wgAGoiA0HkAG4iBEEBdEGI0IgBai8AADsAACABQQJqIAMgBEHkAGxrQQF0QYjQiAFqLwAAOwAAIAFBBGshASAAQf/B1y9LIAIhAA0ACyABQQRqIQELAkAgAkHjAE0EQCACIQAMAQsgAUECayIBIAIgAkH//wNxQeQAbiIAQeQAbGtB//8DcUEBdEGI0IgBai8AADsAAAsgAEEJTQRAIAFBAWsgAEEwcjoAAA8LIAFBAmsgAEEBdEGI0IgBai8AADsAAAuHEAIPfwF+IwBBEGsiDSQAAkACQAJAAkACQAJAAkBBASABKQMAIhSnQQJrIBRCAVgbQQFrDgMBAgMACyAAIAFBCGogAiADEOoIDAULIAQNAyANQQRqQSJBAEEBQQEQoBggDSgCCCEBIA0oAgRBAUcNAiABIA0oAgxB1P3MABD9LwALIAAhBCMAQSBrIgUkACACKAIUIQ4gAiABQQhqIgYoAggiCiAGKAIcIgBrIgEgAyABIANJGyIBEOwtAkACQAJAAkACQCABIAAgAWoiB00EQCAHIApLDQEgAkEMaiEJAkAgAQRAIAYoAgQgAEECdGoiCiEDIAEhAANAIAMoAgAgCGohCCADQQRqIQMgAEEBayIADQALIAkgCBDlLSABQQJ0IQggBigCFCEJIAYoAhAhDCAGKAIgIQMgBi0AJCIPQQFxIRADQCAKKAIAIgsgA2oiACALSQ0FIAAgCUsNBiAFQQhqIAIgAyAMaiALIBAQlxQgBSgCCCIDQQhHBEAgBCAFKQIMNwIEIARBFGogBUEcaigCADYCACAEQQxqIAVBFGopAgA3AgAMCQsgCkEEaiEKIAAhAyAIQQRrIggNAAsgBiAHNgIcIAYgADYCICAPQQFxDQEMBgsgCUEAEOUtIAYgBzYCHCAGLQAkQQFxRQ0FCyAFQQhqIAIgDhCuGSAFKAIIIgNBCEYNBCAEIAUpAgw3AgQgBEEUaiAFQRxqKAIANgIAIARBDGogBUEUaikCADcCAAwFCyAAIAdB3I7NABCxOwALIAcgCkHcjs0AELA7AAsgAyAAQfyOzQAQsTsACyAAIAlB/I7NABCwOwALIAQgATYCBEEIIQMLIAQgAzYCACAFQSBqJAAMAwsjAEEgayIFJAAgAigCFCEQIAIgAUEIaiIBKAIIIAEoAjRrIgQgAyADIARLGxDsLSAFQQhqIQYgAUE8aiIRIQsjAEEwayIEJAACQAJAAkACQAJAAkAgASgCCCIIIAEoAjQiB2siCiADIAMgCksbIgogB2oiAyAKTwRAIAMgCEsNASADIAEoAhQiCEsNAiAEIAdBAnQiByABKAIEaiIIIAggCkECdCIJaiABKAIQIAdqIgcgByAJahCLKAJAAkAgBCgCFCIIIAQoAhAiB0sEQCABKAIsIQ4gASgCKCESIAggB2shDCABQRhqIQ8gB0ECdCIHIAQoAghqIQMgBCgCACAHaiEHIAEoAjghCSALLQAAQQFxIRMDQCABKAIsIAkgAygCACIIakkNAyAPIAcoAgAQ9DQgASgCOCIJIAhqIgsgCUkNByALIA5LDQggDyAJIBJqIAgQoTYgBEEYaiACIAEoAhwgASgCICATEJcUIAQoAhgiCUEIRw0CIAEgASgCOCAIaiIJNgI4IANBBGohAyAHQQRqIQcgDEEBayIMDQALIAEoAjQgCmohAwsgBiAKNgIEIAEgAzYCNCAGQQg2AgAMCAsgBiAEKQIcNwIEIAZBFGogBEEsaigCADYCACAGQQxqIARBJGopAgA3AgAgBiAJNgIADAcLIARBGGpBF0EAQQFBARCgGCAEKAIcIQMgBCgCGEEBRg0FIAQoAiAiAUEPakHbhs0AKQAANwAAIAFBCGpB1IbNACkAADcAACABQcyGzQApAAA3AAAgBkEXNgIMIAYgATYCCCAGIAM2AgQgBkECNgIADAYLIAcgA0GMhs0AELE7AAsgAyAIQYyGzQAQsDsACyADIAhBnIbNABCwOwALIAkgC0Gshs0AELE7AAsgCyAOQayGzQAQsDsACyADIAQoAiBB1P3MABD9LwALIARBMGokACAFKAIMIQECQCAFKAIIIgNBCEcEQCAAIAUpAxA3AwggAEEQaiAFQRhqKQMANwMAIAAgATYCBCAAIAM2AgAMAQsCQCARLQAARQ0AIAVBCGogAiAQEK4ZIAUoAggiAkEIRg0AIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIAIAAgAjYCAAwBCyAAQQg2AgAgACABNgIECyAFQSBqJAAMAgsgDSgCDCICQeSMzQBBIvwKAAAgAEEiNgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAQoAghBAUcEQCMAQSBrIgUkAAJAAkACQAJAIANFDQAgASgCTCIHRQ0AIAEoAkghBiAEKAIUIQggBCgCECEJIAQoAgghCyAEKAIEIQ4DQCABKAJEIgQgBkYEQCAFQQhqIAEgASgCQEGACBDcCiAFKAIMIQQgBSgCCCIGQQhHBEAgACAFKQMQNwMIIABBEGogBUEYaikDADcDACAAIAQ2AgQgACAGNgIADAYLIARFDQIgAUEANgJIIAEgBDYCRCABKAJMIQdBACEGCyAHIAQgBmsiBCADIAprIgwgBCAMSRsiBCAEIAdLGyIEIAZqIgcgBEkNAiAHQYAISw0DIAVBCGogAiABKAJAIAZBAnRqIAQgDiALIAkgCBDvDyAFKAIIIgZBCEcEQCAAIAUpAgw3AgQgAEEUaiAFQRxqKAIANgIAIABBDGogBUEUaikCADcCACAAIAY2AgAMBQsgASABKAJIIARqIgY2AkggASABKAJMIgwgBGsiBzYCTCAEIApqIgogA0YNASAEIAxHDQALCyAAQQg2AgAgACAKNgIEDAILIAYgB0HMiM4AELE7AAsgB0GACEHMiM4AELA7AAsgBUEgaiQADAELIABCCDcDAAsgDUEQaiQAC4cQAg9/AX4jAEEQayINJAACQAJAAkACQAJAAkACQEEBIAEpAwAiFKdBAmsgFEIBWBtBAWsOAwECAwALIAAgAUEIaiACIAMQ6QgMBQsgBA0DIA1BBGpBIkEAQQFBARCgGCANKAIIIQEgDSgCBEEBRw0CIAEgDSgCDEHU/cwAEP0vAAsgACEEIwBBIGsiBSQAIAIoAhQhDiACIAFBCGoiBigCCCIKIAYoAhwiAGsiASADIAEgA0kbIgEQ7i0CQAJAAkACQAJAIAEgACABaiIHTQRAIAcgCksNASACQQxqIQkCQCABBEAgBigCBCAAQQJ0aiIKIQMgASEAA0AgAygCACAIaiEIIANBBGohAyAAQQFrIgANAAsgCSAIEOUtIAFBAnQhCCAGKAIUIQkgBigCECEMIAYoAiAhAyAGLQAkIg9BAXEhEANAIAooAgAiCyADaiIAIAtJDQUgACAJSw0GIAVBCGogAiADIAxqIAsgEBCfFCAFKAIIIgNBCEcEQCAEIAUpAgw3AgQgBEEUaiAFQRxqKAIANgIAIARBDGogBUEUaikCADcCAAwJCyAKQQRqIQogACEDIAhBBGsiCA0ACyAGIAc2AhwgBiAANgIgIA9BAXENAQwGCyAJQQAQ5S0gBiAHNgIcIAYtACRBAXFFDQULIAVBCGogAiAOEK4ZIAUoAggiA0EIRg0EIAQgBSkCDDcCBCAEQRRqIAVBHGooAgA2AgAgBEEMaiAFQRRqKQIANwIADAULIAAgB0Hcjs0AELE7AAsgByAKQdyOzQAQsDsACyADIABB/I7NABCxOwALIAAgCUH8js0AELA7AAsgBCABNgIEQQghAwsgBCADNgIAIAVBIGokAAwDCyMAQSBrIgUkACACKAIUIRAgAiABQQhqIgEoAgggASgCNGsiBCADIAMgBEsbEO4tIAVBCGohBiABQTxqIhEhCyMAQTBrIgQkAAJAAkACQAJAAkACQCABKAIIIgggASgCNCIHayIKIAMgAyAKSxsiCiAHaiIDIApPBEAgAyAISw0BIAMgASgCFCIISw0CIAQgB0ECdCIHIAEoAgRqIgggCCAKQQJ0IglqIAEoAhAgB2oiByAHIAlqEIsoAkACQCAEKAIUIgggBCgCECIHSwRAIAEoAiwhDiABKAIoIRIgCCAHayEMIAFBGGohDyAHQQJ0IgcgBCgCCGohAyAEKAIAIAdqIQcgASgCOCEJIAstAABBAXEhEwNAIAEoAiwgCSADKAIAIghqSQ0DIA8gBygCABD0NCABKAI4IgkgCGoiCyAJSQ0HIAsgDksNCCAPIAkgEmogCBChNiAEQRhqIAIgASgCHCABKAIgIBMQnxQgBCgCGCIJQQhHDQIgASABKAI4IAhqIgk2AjggA0EEaiEDIAdBBGohByAMQQFrIgwNAAsgASgCNCAKaiEDCyAGIAo2AgQgASADNgI0IAZBCDYCAAwICyAGIAQpAhw3AgQgBkEUaiAEQSxqKAIANgIAIAZBDGogBEEkaikCADcCACAGIAk2AgAMBwsgBEEYakEXQQBBAUEBEKAYIAQoAhwhAyAEKAIYQQFGDQUgBCgCICIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAGQRc2AgwgBiABNgIIIAYgAzYCBCAGQQI2AgAMBgsgByADQYyGzQAQsTsACyADIAhBjIbNABCwOwALIAMgCEGchs0AELA7AAsgCSALQayGzQAQsTsACyALIA5BrIbNABCwOwALIAMgBCgCIEHU/cwAEP0vAAsgBEEwaiQAIAUoAgwhAQJAIAUoAggiA0EIRwRAIAAgBSkDEDcDCCAAQRBqIAVBGGopAwA3AwAgACABNgIEIAAgAzYCAAwBCwJAIBEtAABFDQAgBUEIaiACIBAQrhkgBSgCCCICQQhGDQAgACAFKQIMNwIEIABBFGogBUEcaigCADYCACAAQQxqIAVBFGopAgA3AgAgACACNgIADAELIABBCDYCACAAIAE2AgQLIAVBIGokAAwCCyANKAIMIgJB5IzNAEEi/AoAACAAQSI2AgwgACACNgIIIAAgATYCBCAAQQA2AgAMAQsgBCgCCEEBRwRAIwBBIGsiBSQAAkACQAJAAkAgA0UNACABKAJMIgdFDQAgASgCSCEGIAQoAhQhCCAEKAIQIQkgBCgCCCELIAQoAgQhDgNAIAEoAkQiBCAGRgRAIAVBCGogASABKAJAQYAIENwKIAUoAgwhBCAFKAIIIgZBCEcEQCAAIAUpAxA3AwggAEEQaiAFQRhqKQMANwMAIAAgBDYCBCAAIAY2AgAMBgsgBEUNAiABQQA2AkggASAENgJEIAEoAkwhB0EAIQYLIAcgBCAGayIEIAMgCmsiDCAEIAxJGyIEIAQgB0sbIgQgBmoiByAESQ0CIAdBgAhLDQMgBUEIaiACIAEoAkAgBkECdGogBCAOIAsgCSAIEO4PIAUoAggiBkEIRwRAIAAgBSkCDDcCBCAAQRRqIAVBHGooAgA2AgAgAEEMaiAFQRRqKQIANwIAIAAgBjYCAAwFCyABIAEoAkggBGoiBjYCSCABIAEoAkwiDCAEayIHNgJMIAQgCmoiCiADRg0BIAQgDEcNAAsLIABBCDYCACAAIAo2AgQMAgsgBiAHQcyIzgAQsTsACyAHQYAIQcyIzgAQsDsACyAFQSBqJAAMAQsgAEIINwMACyANQRBqJAAL9wEBBX8gACgCBCECIAAoAgAhASAAQoiAgICAATcCACACIAFrQegDbiEDIAAoAgghBAJAAkAgASACRgRAIAAoAhAiAUUNASAAKAIMIgIgBCgCCCIARg0CIAFB6ANsIgNFDQIgBCgCBCIFIABB6ANsaiAFIAJB6ANsaiAD/AoAAAwCCwNAIAEQ2BMgAUHoA2ohASADQQFrIgMNAAsgACgCECIBRQ0AAkAgACgCDCICIAQoAggiAEYNACABQegDbCIDRQ0AIAQoAgQiBSAAQegDbGogBSACQegDbGogA/wKAAALIAQgACABajYCCAsPCyAEIAAgAWo2AggL1QEBC38CQCAAKAIQIgUgACgCBCIGaiABKAIQIgQgASgCBCICakYEQCABKAIMIgcgBGohCCABKAIAIgMgAmohCSAAKAIMIgIgBWohCiAAKAIAIgEgBmohCwNAAn8gAUUgASALRnJFBEAgAiEEIAFBAWoMAQsgAiAKRg0DIAJBAWohBCACIQFBAAsgA0UgAyAJRnIEfyAHIAhGDQMgByIDQQFqIQdBAAUgA0EBagshBiADLQAAIQwgAS0AACEFIQEgBCECIAYhAyAFIAxGDQALC0EADwtBAQvcAQEDfyMAQSBrIgQkACAEQQA2AgQCQAJAIAFBA0sEQCAEQQRqIgVBBCAAQQRBtJzzABDVLCAEKAIEIQYgBEEANgIEIANBA00NAiAFQQQgAkEEQbSc8wAQ1SxBACEFAkAgBCgCBCAGRgRAIAFBBEYNAyADQQRGDQEgAC0ABCACLQAERiEFCyAEQSBqJAAgBQ8LQQRBBEHkk/MAEMMhAAsMAQtBBEEEQdST8wAQwyEACyAEQQA2AhggBEEBNgIMIARBzI/zADYCCCAEQgQ3AhAgBEEIakGknPMAEO8sAAvTAQIBfwN+QQEhAiAArCIDQgGGIgQgA0I/hyIFUgRAIAQgBYUhA0EAIQIDQCACQQFqIQIgA0L/AFYgA0IHiCEDDQALCwJAIAJBCk0EQEEAIQIgBCAFhSIDQoABVA0BA0AgAkEKRwRAIAEgAmogA6dBgAFyOgAAIAJBAWohAiADQv//AFYgA0IHiCEDDQEMAwsLQQpBCkGwtf4AEMMhAAtBrLT+AEE0QZC1/gAQnykACyACQQpPBEAgAkEKQaC1/gAQwyEACyABIAJqIAM8AAAgAkEBaguBAgIFfwF+IwBB8AJrIgIkACABQQxqIgQQ9DUhBSACQRU6AOQBIAJBADYCmAIgAkEANgKAAiACQgA3AvABIAJBADYCxAEgAkEAOwGcAiACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAIgASgCKDYC6AEgAkHwAGogAUEIaiIDKAIANgIAIANBADYCACABKQIAIQcgAUKAgICAEDcCACACIAc3A2ggAkGgAmoiBiACQegAaiIBEJMZIAEgAkHEAWoiAyAGEPojIAMgBBD0EiACQQxqIgQgASADEMIZIAIgBTYCOCACQawCaiIBIAQQzRwgACABEMsSIAJB8AJqJAAL+AECAn8CfiMAQRBrIgQkAAJAAkACQAJAAkACQAJAIAEoAhQiBSABKAIQSQRAIAEoAgwgBWotAAAiBUEuRg0BIAVBxQBGIAVB5QBGcg0CCyACRQ0CQgEhBgwFCyAEIAEgAiADQQAQ1A0gBCgCAA0CDAMLIAQgASACIANBABDpDCAEKAIARQ0CIAAgBCgCBDYCCCAAQgM3AwAMBAtCACADfSIHQgBTBEBCAiEGIAchAwwDCyADur1CgICAgICAgICAf4QhAwwCCyAAIAQoAgQ2AgggAEIDNwMADAILIAQpAwghAwsgACADNwMIIAAgBjcDAAsgBEEQaiQAC4ICAQR/IwBBIGsiAyQAQQEhBQJAIAAtAAQNACAALQAFIQYCQCAAKAIAIgQtAApBgAFxRQRAIAZBAXFFDQEgBCgCAEHP8YkBQQIgBCgCBCgCDBEGAEUNAQwCCyAGQQFxRQRAIAQoAgBB3fGJAUEBIAQoAgQoAgwRBgANAgsgA0EBOgAPIANBsPGJATYCFCADIAQpAgA3AgAgAyAEKQIINwIYIAMgA0EPajYCCCADIAM2AhAgASADQRBqIAIoAgwRAgANASADKAIQQdTxiQFBAiADKAIUKAIMEQYAIQUMAQsgASAEIAIoAgwRAgAhBQsgAEEBOgAFIAAgBToABCADQSBqJAAL7gEBAX8CQCAAKAIAIgAoAhBFBEAgACgCICIBQYQBSQ0BIAEQ8h8MAQsgAEEgahDeOyAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEJ0nCyAAKAIwIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTBqEJcVCyAAKAI0IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTRqEPgjCwJAIAAoAjgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEE4ahDbHgsCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBwABBCBD4OgsLcgACfyAAQcKwAU8EQCABLQA/IAIzAX4gBCAFIAYQ3xNBGCAArULCsAF9IAQgBSAGEN8TQfwBDAELIAEtAD4gAjMBfCAEIAUgBhDfE0EOIACtQsIwfSAEIAUgBhDfE0H4AQsgA2oiACAAKAIAQQFqNgIAC9UBAgN/AX4jAEEgayIGJAACQCAFRQ0AIAIgA2oiAyACSQ0AIAQgBWpBAWtBACAEa3GtIAOtfiIJQiCIpw0AIAmnIghBgICAgHggBGtLDQAgBiABKAIAIgIEfyAGIAIgBWw2AhwgBiABKAIENgIUIAQFIAcLNgIYIAZBCGogBCAIIAZBFGoQvhogBigCCEEBRgRAIAYoAhAhAiAGKAIMIQcMAQsgBigCDCEEIAEgAzYCACABIAQ2AgRBgYCAgHghBwsgACACNgIEIAAgBzYCACAGQSBqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIDAADcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELgYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQsxMgAkGAA2okAAv+AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgCA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARC2GCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEL0TIAJBgANqJAAL/gECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIAgNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQthggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARCqEyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAwAA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDxGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEK0TIAJBgANqJAAL/gECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIAQNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQkxkgASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARC4EyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAgAE3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDzGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABELcTIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgICAAjcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELUYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQsBMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgMAANwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQuBggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARC5EyACQYADaiQAC/4BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAIDcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELYYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQqxMgAkGAA2okAAv+AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgBA3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARDyGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABELYTIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgIDAADcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBEPEYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQwxMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgIABNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQsxggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARDHEyACQYADaiQAC/8BAgR/AX4jAEGAA2siAiQAIAFBCGoiAygCACEEIAJBBGoiBSABQQxqEPQSIAJB9AFqIAFBKGoQ1QYgAkEAOwGsAiACQQA2AqgCIAJBADYCkAIgAkEANgKEAiACIAQ2AoACIAJCBDcC7AEgAkIANwLkASACQoCAgIDAADcC3AEgAkEANgLUASACQYABaiADKAIANgIAIANBADYCACABKQIAIQYgAUKAgICAgAE3AgAgAiAGNwN4IAJBsAJqIgMgAkH4AGoiARCzGCABIAJB1AFqIAMQ+iMgAkEcaiIDIAEgBRDCGSACQbwCaiIBIAMQzRwgACABEK4TIAJBgANqJAAL/wECBH8BfiMAQYADayICJAAgAUEIaiIDKAIAIQQgAkEEaiIFIAFBDGoQ9BIgAkH0AWogAUEoahDVBiACQQA7AawCIAJBADYCqAIgAkEANgKQAiACQQA2AoQCIAIgBDYCgAIgAkIENwLsASACQgA3AuQBIAJCgICAgMAANwLcASACQQA2AtQBIAJBgAFqIAMoAgA2AgAgA0EANgIAIAEpAgAhBiABQoCAgICAAjcCACACIAY3A3ggAkGwAmoiAyACQfgAaiIBELkYIAEgAkHUAWogAxD6IyACQRxqIgMgASAFEMIZIAJBvAJqIgEgAxDNHCAAIAEQxRMgAkGAA2okAAv/AQIEfwF+IwBBgANrIgIkACABQQhqIgMoAgAhBCACQQRqIgUgAUEMahD0EiACQfQBaiABQShqENUGIAJBADsBrAIgAkEANgKoAiACQQA2ApACIAJBADYChAIgAiAENgKAAiACQgQ3AuwBIAJCADcC5AEgAkKAgICAwAA3AtwBIAJBADYC1AEgAkGAAWogAygCADYCACADQQA2AgAgASkCACEGIAFCgICAgIABNwIAIAIgBjcDeCACQbACaiIDIAJB+ABqIgEQ8xggASACQdQBaiADEPojIAJBHGoiAyABIAUQwhkgAkG8AmoiASADEM0cIAAgARCxEyACQYADaiQAC4ECAgR/AX4jAEHgAGsiAiQAIAFBGGohBAJAIAEtABhBHUYEQCABKAIcIQMgAkEIaiABEO88IAIoAgwNAUEAQQBBrKaGARDDIQALIAIgBDYCECACQQE2AiAgAkGEp4YBNgIcIAJCATcCKCACQa8DNgIYIAIgAkEUajYCJCACIAJBEGo2AhQgAkEcakGMp4YBEO8sAAsgAkEcaiIFIAIoAgggASgCKCADbCABKAIkIANsENYIIAIgBRCgASACKQMAIQYgACAEENkGIABBFGogAUEsakEAIAEoAiwbEO4lIAAgAzYCLCAAIAY3AgwgACABKAIkNgIwIAEQjCcgAkHgAGokAAuXAgECfyMAQRBrIgIkAAJ/AkACQAJAAkACQEECIAAoAgAiA0H/////B2ogA0GAgICAeE0bQQFrDgQBAgMEAAsgAiAAQQRqNgIMIAFB9I6HAUEGIABBDGpBnI+HASACQQxqQZiXhwEQgw8MBAsgAiAAQQhqNgIMIAFB+o6HAUEEIABBBGpBnI+HASACQQxqQaiXhwEQgw8MAwsgAiAANgIMIAFB/o6HAUEGIABBDGpBnI+HASACQQxqQbiXhwEQgw8MAgsgAiAAQQhqNgIMIAFBhI+HAUEKIABBBGpBnI+HASACQQxqQaiXhwEQgw8MAQsgAiAAQQRqNgIMIAFByJeHAUEFIAJBDGpBwI6HARDQEwsgAkEQaiQAC4oCAQN/IwBBEGsiBCQAAkACQAJAIAEtACgNACAEQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAEtABggBCgCDCECIAQoAgghAyABQQE6ABhFBEAgASgCECIFBEAgASgCFCAFKAIMEQMACyABQQA6ABggASACNgIUIAEgAzYCECABLQAoDQFBgYCAgHghAgwCCyACIAMoAgwRAwALIAEtAAwgAUEBOgAMBEBBgICAgHghAgwBCyABKAIAIQNBgICAgHghAiABQYCAgIB4NgIAIANBgICAgHhHBEAgACABKQIENwIEIAAgAzYCACABQQA6AAwMAgsgAUEAOgAMCyAAIAI2AgALIARBEGokAAuMAgECfwJAIAAoAgBFDQAgAEEEaiECAkACQAJAIAAtAEAOBAACAgECCyACKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgAhDfHwsgACgCCCICQYQBSQ0BIAIQ8h8MAQsCQAJAAkACQCAALQA8DgQAAwMBAwsgACgCGCIBQYMBTQ0CDAELIAAoAigiAUGEAU8EQCABEPIfCyAAKAIkIgFBhAFPBEAgARDyHwsgACgCICIBQYMBTQ0BCyABEPIfCyAAKAIQIgEgASgCAEEBajYCACAAKAIEIgEgASgCAEEBayIBNgIAIAENACACEN8fCyAAKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACAAEOknCwuXAgECfyMAQTBrIgIkAAJAAkACQAJAAkACQAJAIAEoAvQBIgMOBAEAAgMACyACIAM2AgwgAkECNgIUIAJBqJDPADYCECACQgE3AhwgAkGhCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIABBBGogAkEQahCZDiAAQQA2AgAMAwsgASkDAEIDUQ0DIABBADoAFCAAQQE2AgwgAEIINwMAIAAgASgCWDYCEAwCCyAAQQE6ABQgAEEANgIMIABCCDcDAAwBCyABKQNoQgNRDQIgAEEAOgAUIABBATYCDCAAQoiAgIAQNwMAIAAgASgCwAE2AhAgACABKALIATYCCAsgAkEwaiQADwtB2I/PABCyOwALQeiPzwAQsjsAC+oBAQl/IwBBEGsiAiQAIAEoAgQhAyACQQRqIAEoAggiCEEAQQRBCBCgGCACKAIIIQQCQCACKAIEQQFHBEAgAigCDCEJAkAgBEUNACAIQQN0IQYgCSEBIAQhCgNAIAZFDQEgAygCACIHBEAgByAHKAIAIgVBAWo2AgAgBUEASA0EIANBBGooAgAhBQsgA0EIaiEDIAEgBzYCACABQQRqIAU2AgAgAUEIaiEBIAZBCGshBiAKQQFrIgoNAAsLIAAgCDYCCCAAIAk2AgQgACAENgIAIAJBEGokAA8LIAQgAigCDEHE5oQBEP0vCwAL1wEBA38jAEEQayIEJAAgBAJ/IAAvAQAiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhACACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCECIAJBgICA/AdyIABFDQEaIAIgAEENdHJBgICA/gdyDAELIANBEHQhAyACQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogA3IgAg0AGiAAIABnQRBrIgBB//8DcUEIanRB////A3EgA0GAgIDYA3IgAEEXdGtyCzYCDCAEQQxqIAEQjyAgBEEQaiQAC5UCAgN/AX0jAEEQayIEJAAgBAJ/IAAvAQAiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhACACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCICQYCAgPwHciAARQ0BGiACIABBDXRyQYCAgP4HcgwBCyADQRB0IgMgAkENdEGAgID8AHEgAEENdHJBgICAwANqciACDQAaIAAgAGdBEGsiAEH//wNxQQhqdEH///8DcSADQYCAgNgDciAAQRd0a3ILNgIMAn8gASgCCCICQYCAgAFxIQAgBEEMaioCACEFIAJBgICAgAFxRQRAIAEgBSAAQQBHQQAQkAkMAQsgASAFIABBAEcgAS8BDhDpBwsgBEEQaiQAC4UCAQN/IwBBIGsiAyQAIAAoAgAhBSAAAn9BASAALQAIDQAaIAAoAgQiBC0ACkGAAXFFBEBBASAEKAIAQc/xiQFB2fGJASAFG0ECQQEgBRsgBCgCBCgCDBEGAA0BGiABIAQgAigCDBECAAwBCyAFRQRAQQEgBCgCAEHa8YkBQQIgBCgCBCgCDBEGAA0BGgsgA0EBOgAPIANBsPGJATYCFCADIAQpAgA3AgAgAyAEKQIINwIYIAMgA0EPajYCCCADIAM2AhBBASABIANBEGogAigCDBECAA0AGiADKAIQQdTxiQFBAiADKAIUKAIMEQYACzoACCAAIAVBAWo2AgAgA0EgaiQAIAAL2QEBBn8gACgCACIBIAAoAgQiAkcEQCAAIAEgAiABa0EEa0F8cWpBBGo2AgALIAAoAhAiAwRAIAAoAggiAkHIAGohBAJAAkACfwJAIAIoAkgiAUESTwRAIAAoAgwiACACKAIEIgFHDQEgASADaiEADAMLIAEgACgCDCIARgRAIAEgA2ohAAwECyACQQRqDAELIAIoAggLIQUgA0ECdCIGBEAgBSABQQJ0aiAFIABBAnRqIAb8CgAACyABIANqIQAgBCgCAEESSQ0BCyACQQRqIQQLIAQgADYCAAsLggIBA38DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCGEGAgICAeEYNASABKAIAKAIAIAEoAgQoAgBrIQIgACgCHCIDIAAoAiBBAXRqIQAgASgCCCEBA0AgACADRg0DIAEuAQAiBCAAQQJrIgAuAQBIDQAgAkEBayICDQALIAAgBEEBazsBAA8LIAAoAgwiAgRAIAAoAgghACACQcgAbCECA0AgACABEOYUIABByABqIQAgAkHIAGsiAg0ACwsPC0HEws0AELI7AAtB1MLNABCyOwAFIAAoAgQhAAwBCwALAAu0AgIGfwF+IAEpAxgiCVAEQCAAQQQ6AAAPCyACKAIEIAIoAggiB2utIAlYBEAgAigCACEDIAIoAgQiBCACKAIMIgZrIgUEQCADIAZqQQAgBfwLAAsgAiAENgIMIAEgAyACKAIIIgZqIAQgBmsiAyABKAIIIgQgAyAESRsiAxCXGiAAQQQ6AAAgAiADIAZqNgIIIAEgASkDGCACKAIIIAdrrX03AxgPCyACKAIAIAdqIQQgCaciAyACKAIMIgYgB2siBSADIAMgBUsbIgVrIggEQCAEIAVqQQAgCPwLAAsgASAEIAMgASgCCCIEIAMgBEkbIgQQlxogAiAEIAdqIgU2AgggAEEEOgAAIAEgASkDGCAErX03AxggAiADIAdqIgAgBSAGIAUgBksbIgEgACABSxs2AgwL0AEBCX8gASgCMCINIAEoAiwiC0EHdk8EQCABKAI0IQ9BgIACIAIgAxDKICIIQQF0IgxrIglBACAJQYCAAk0bIRAgC0EBaiEJIAhBAnRBmJvSAGohCANAIAoCQCAKIBBHBEAgASAJNgIsIAgvAQAiCkUNASAAIAogAiADIAQgBSAGIA8gBxDEEkUNAUEBIQ4gASANQQFqIg02AjAMAQsgDEGAgAJBhOLOABDDIQALQQEhCiAJQQFqIQkgCEECaiEIIAxBAWohDEEBcUUNAAsLIA4L0wEBCX8gASgCKCINIAEoAiQiC0EHdk8EQCABKAIsIQ9BgIACIAIgAxDKICIIQQF0IgxrIglBACAJQYCAAk0bIRAgC0EBaiEJIAhBAnRBmJvSAGohCANAIAoCQCAKIBBHBEAgASAJNgIkIAgvAQAiCkUNASAAIAogAiADIAQgBSAGIA8gBxDEEkUNAUEBIQ4gASANQQFqIg02AigMAQsgDEGAgAJBhOLOABDDIQALQQEhCiAJQQFqIQkgCEECaiEIIAxBAWohDEEBckEBcUUNAAsLIA4L9wEBAn8jAEEwayIDJAAgASgCCCEEIAMgAjYCACADIAQ2AgQgAiAETQRAAkAgAiAERwRAIANBCGogAUEMaiABKAIEIAQgASgCACgCABEFACADQRBqIgEgBCACazYCACAAQQhqIAEpAgA3AgAgAyADKAIMIAJqNgIMIAAgAykCCDcCAAwBCyAAQQA2AgwgAEIBNwIEIABBtPDOADYCAAsgA0EwaiQADwsgA0ECNgIMIANB+PDOADYCCCADQgI3AhQgA0GLCDYCLCADQYsINgIkIAMgA0EgajYCECADIANBBGo2AiggAyADNgIgIANBCGpBiPHOABDvLAAL6AEBCX8gASAAKAIYIgNNBEAgAkEDaiICIAMgAWsiAyACIANJGyICQQRPBEAgACgCIEH//wNqIQUgAkEDayEGIAAoAhQgAWohByAAKAIoIQggACgCLCECIAAoAjAhCUEAIQADQAJAIAkgACAHaigAAEGx893xeWxBD3ZB/v8HcWoiCi8BACILIAAgAWoiA0H//wNxRg0AIAIgAyAFcUH//wNxIgRLBEAgCCAEQQF0aiALOwEAIAogAzsBAAwBCyAEIAJBtN/8ABDDIQALIAYgAEEBaiIARw0ACwsPCyABIANBpN/8ABCvOwAL8gcCB38FfiMAQeAAayIDJAAgA0EgaiEEIAEoAiwhBiMAQfABayICJAACQCABKAIcIgUgASgCIEcEQAJAAkACfgJAIAEoAgRFDQAgBSABKAIUTw0DIAEoAgggASgCECAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASAFQQFqNgIcQgAMAQsgASAFQQFqNgIcIAJBCGogASAFEK0qIAIoAgghBSABKAIoIQcgASgCJCEBIAIgAigCDCIINgJMIAIgBTYCSCACQdAAaiAFIAggASwAABDWAQJAAn4gAigCUEEBRgRAIAJBqAFqIAIpAlw3AwAgAkGwAWogAkHkAGooAgA2AgAgAiACKQJUNwOgASACQdgBakGYroABKAIANgIAIAJBkK6AASkCADcD0AEgAkEDNgK8ASACQcSugAE2ArgBIAJCAjcCxAEgAkGuEDYC7AEgAkHMATYC5AEgAiACQeABajYCwAEgAiACQdABaiIBNgLoASACIAJByABqNgLgASACQZABaiACQbgBahCZDiABEKoMIAJBgoCAgHg2AowBIAJBoAFqEIgRIAJBQGsgAkGUAWooAgA2AgAgAiACKQKMATcDOCACKQKYAQwBCyACQdAAaiACKQNgIgkgAikDaCIKIAIpA3AiCyACKQN4IgwgBy0AABDQDiACKAJQQZOAgIB4Rg0BIAJBQGsgAkHYAGooAgA2AgAgAiACKQJQNwM4IAIpAlwLIQkgAiACKQM4NwMQIAIgCTcCHCACIAJBQGsoAgA2AhhCAiEJIAYoAgBBk4CAgHhGDQIgBhCIEQwCCyACIAs3AyAgAiAJNwMQIAIgDDcDKCACIAo3AxhCAQshCSACQewAaiACQSxqKAIANgIAIAIgAikCJDcCZCACQdAAaiEGCyAGIAIpAxA3AgAgBkEIaiACKQMYNwIAIAZBEGogAkEgaigCADYCACAEQgA3AwggBCAJNwMAIAQgAikDUDcDECAEQRhqIAIpA1g3AwAgBEEgaiACQeAAaikDADcDACAEQShqIAJB6ABqKQMANwMADAILQfSngAFBIEGUqIABEJ8pAAsgBEIANwMIIARCAzcDAAsgAkHwAWokACAAAn5CAiADKQMoIgkgAykDICIKQgOFhFANABogA0EYaiIBIANByABqKQMANwMAIANBEGoiAiADQUBrKQMANwMAIAMgAykDMDcDACADIANBOGopAwA3AwhCAiAKQgKFIAmEUA0AGiAAIAMpAwA3AxAgAEEYaiADKQMINwMAIABBKGogASkDADcDACAAQSBqIAIpAwA3AwAgCSENIAoLNwMAIAAgDTcDCCADQeAAaiQAC/UHAgd/BX4jAEHgAGsiAyQAIANBIGohBCABKAIsIQYjAEHwAWsiAiQAAkAgASgCHCIFIAEoAiBHBEACQAJAAn4CQCABKAIERQ0AIAUgASgCFE8NAyABKAIIIAEoAhAgBWoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBUEBajYCHEIADAELIAEgBUEBajYCHCACQQhqIAEoAgAgBRCPLCACKAIIIQUgASgCKCEHIAEoAiQhASACIAIoAgwiCDYCTCACIAU2AkggAkHQAGogBSAIIAEsAAAQ1gECQAJ+IAIoAlBBAUYEQCACQagBaiACKQJcNwMAIAJBsAFqIAJB5ABqKAIANgIAIAIgAikCVDcDoAEgAkHYAWpBmK6AASgCADYCACACQZCugAEpAgA3A9ABIAJBAzYCvAEgAkHEroABNgK4ASACQgI3AsQBIAJBrhA2AuwBIAJBzAE2AuQBIAIgAkHgAWo2AsABIAIgAkHQAWoiATYC6AEgAiACQcgAajYC4AEgAkGQAWogAkG4AWoQmQ4gARCqDCACQYKAgIB4NgKMASACQaABahCIESACQUBrIAJBlAFqKAIANgIAIAIgAikCjAE3AzggAikCmAEMAQsgAkHQAGogAikDYCIJIAIpA2giCiACKQNwIgsgAikDeCIMIActAAAQ0A4gAigCUEGTgICAeEYNASACQUBrIAJB2ABqKAIANgIAIAIgAikCUDcDOCACKQJcCyEJIAIgAikDODcDECACIAk3AhwgAiACQUBrKAIANgIYQgIhCSAGKAIAQZOAgIB4Rg0CIAYQiBEMAgsgAiALNwMgIAIgCTcDECACIAw3AyggAiAKNwMYQgELIQkgAkHsAGogAkEsaigCADYCACACIAIpAiQ3AmQgAkHQAGohBgsgBiACKQMQNwIAIAZBCGogAikDGDcCACAGQRBqIAJBIGooAgA2AgAgBEIANwMIIAQgCTcDACAEIAIpA1A3AxAgBEEYaiACKQNYNwMAIARBIGogAkHgAGopAwA3AwAgBEEoaiACQegAaikDADcDAAwCC0H0p4ABQSBBlKiAARCfKQALIARCADcDCCAEQgM3AwALIAJB8AFqJAAgAAJ+QgIgAykDKCIJIAMpAyAiCkIDhYRQDQAaIANBGGoiASADQcgAaikDADcDACADQRBqIgIgA0FAaykDADcDACADIAMpAzA3AwAgAyADQThqKQMANwMIQgIgCkIChSAJhFANABogACADKQMANwMQIABBGGogAykDCDcDACAAQShqIAEpAwA3AwAgAEEgaiACKQMANwMAIAkhDSAKCzcDACAAIA03AwggA0HgAGokAAv1BwIHfwV+IwBB4ABrIgMkACADQSBqIQQgASgCLCEGIwBB8AFrIgIkAAJAIAEoAhwiBSABKAIgRwRAAkACQAJ+AkAgASgCBEUNACAFIAEoAhRPDQMgASgCCCABKAIQIAVqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAVBAWo2AhxCAAwBCyABIAVBAWo2AhwgAkEIaiABKAIAIAUQ2isgAigCCCEFIAEoAighByABKAIkIQEgAiACKAIMIgg2AkwgAiAFNgJIIAJB0ABqIAUgCCABLAAAENYBAkACfiACKAJQQQFGBEAgAkGoAWogAikCXDcDACACQbABaiACQeQAaigCADYCACACIAIpAlQ3A6ABIAJB2AFqQZiugAEoAgA2AgAgAkGQroABKQIANwPQASACQQM2ArwBIAJBxK6AATYCuAEgAkICNwLEASACQa4QNgLsASACQcwBNgLkASACIAJB4AFqNgLAASACIAJB0AFqIgE2AugBIAIgAkHIAGo2AuABIAJBkAFqIAJBuAFqEJkOIAEQqgwgAkGCgICAeDYCjAEgAkGgAWoQiBEgAkFAayACQZQBaigCADYCACACIAIpAowBNwM4IAIpApgBDAELIAJB0ABqIAIpA2AiCSACKQNoIgogAikDcCILIAIpA3giDCAHLQAAENAOIAIoAlBBk4CAgHhGDQEgAkFAayACQdgAaigCADYCACACIAIpAlA3AzggAikCXAshCSACIAIpAzg3AxAgAiAJNwIcIAIgAkFAaygCADYCGEICIQkgBigCAEGTgICAeEYNAiAGEIgRDAILIAIgCzcDICACIAk3AxAgAiAMNwMoIAIgCjcDGEIBCyEJIAJB7ABqIAJBLGooAgA2AgAgAiACKQIkNwJkIAJB0ABqIQYLIAYgAikDEDcCACAGQQhqIAIpAxg3AgAgBkEQaiACQSBqKAIANgIAIARCADcDCCAEIAk3AwAgBCACKQNQNwMQIARBGGogAikDWDcDACAEQSBqIAJB4ABqKQMANwMAIARBKGogAkHoAGopAwA3AwAMAgtB9KeAAUEgQZSogAEQnykACyAEQgA3AwggBEIDNwMACyACQfABaiQAIAACfkICIAMpAygiCSADKQMgIgpCA4WEUA0AGiADQRhqIgEgA0HIAGopAwA3AwAgA0EQaiICIANBQGspAwA3AwAgAyADKQMwNwMAIAMgA0E4aikDADcDCEICIApCAoUgCYRQDQAaIAAgAykDADcDECAAQRhqIAMpAwg3AwAgAEEoaiABKQMANwMAIABBIGogAikDADcDACAJIQ0gCgs3AwAgACANNwMIIANB4ABqJAAL6AEBBX8jAEEQayIEJAAgACgCBCIDIAAoAggiAiABKAIEIAEoAggQzRACQCACRQ0AIAMgAkECdCIFakEEayIBRQ0AIAEoAgANACAFIQEgA0EEayEFIAJB/////wNxIQMCQANAIAFFBEBBACEBDAILIANBAWshAyABIAVqIAFBBGshASgCAEUNAAsgA0EBaiIBIAJLDQELIAAgATYCCCABIQILAkAgAiAAKAIAQQJ2Tw0AIARBCGogACACQQRBBBD0FCAEKAIIIgBBgYCAgHhGDQAgACAEKAIMQdiJiAEQ/S8ACyAEQRBqJAAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQN0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQbi0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQJ0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQZC0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQJ0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQci0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL/QEBBH8jAEEQayIDJAACQCABKAIgBEACQCABKAIwIgQgAiACIARLGyICQQN0IgUgASgCKCABKAI0IgZrTQRAIAAgAjYCBCAAQQg2AgAgASAEIAJrNgIwIAEgBSAGajYCNAwBCyADQQRqQRhBAEEBQQEQoBggAygCCCECIAMoAgRBAUYNAiADKAIMIgFBEGpBsLTOACkAADcAACABQQhqQai0zgApAAA3AAAgAUGgtM4AKQAANwAAIABBGDYCDCAAIAE2AgggACACNgIEIABBAjYCAAsgA0EQaiQADwtB+KfOAEEgQdi0zgAQyyQACyACIAMoAgxB2KfOABD9LwAL3wEBBX8jAEEQayIHJAAgB0EMaiEIAkAgBEUNACABKAIAIgZFDQAgByADNgIMIAQgBmwhBSABKAIEIQkgB0EIaiEICyAIIAU2AgACQCAHKAIMIgUEQCAHKAIIIQYCQCACRQRAIAYEQCAJIAYgBRD4OgsgASADNgIEDAELIAIgBGwhCAJ/AkAgBEUEQCAGRQ0BIAkgBiAFEPg6DAELIAkgBiAFIAgQlzUMAQsgBQsiBEUNAiABIAQ2AgQLIAEgAjYCAAtBgYCAgHghBQsgACAINgIEIAAgBTYCACAHQRBqJAAL4wEBB38jAEEQayIGJAAgASgCLARAIAFBLGohCCABKAJMIgogA2oiBEEDdiAEQQdxQQBHaiIEIAEoAjgiBUsEQCAEIAVrIQkgASgCMCIHIARJBEAgCCAHQQF0IgUgBBDcKiIHIAUgB0sbEOgZIAEoAjghBQsgCQRAIAEoAjQgBWpBACAJ/AsACyABIAQ2AjgLIAZBCGogCBCGPSABIAYoAgggBigCDCAAKAIAIAAoAgQgCiAAKAIIKAIMIAJqIAMQhAkgASgCSGo2AkggBkEQaiQADwtBzI+HAUEdQeyPhwEQyyQAC5wIAw9/AX4BbyMAQSBrIgYkACABAn8CQAJAAkACQAJAIAEtACBBAWsOAwMAAgELAAsgASABKAIMNgIcIAEgASgCCDYCGCABIAEoAgA2AhQLIAZBGGohCyMAQSBrIgkkACABQRRqIgooAgghDAJAAkACQANAIAxFDQEgCUEIaiENIAooAgBBEGohBCAKKAIEIREjAEEgayIHJAAgB0EQaiEQIAIhBUEAIQMjAEEQayIOJAAgBEEIaiEIAkAgBCgCCEUEQCAEKAIAQQFHDQEgBEEEaigCACUBECohExDfEiIDIBMmASADEPsOIQ8CQCAEKAIIIgNFDQAgAyADKAIAQQFrIgM2AgAgAw0AIAgQshoLIAggDzYCAAsgDkEIaiAIIAUQxxhBAiEDIA4oAggiD0ECRg0AIA4oAgwhBQJAIAgoAgAiA0UNACADIAMoAgBBAWsiAzYCACADDQAgCBCyGgsgCEEANgIAQQEhAyAPQQFxBEAgBBClLSAEQQA2AgAMAQsgBUGEAU8EQCAFEPIfC0EAIQMLIBAgBTYCBCAQIAM2AgAgDkEQaiQAAkACQCAHKAIQIgVBAkcEQCAFQQFxRQRAIAdBBDoAGAwCCyAHQRhqIAcoAhQQjxIgBy0AGEEFRw0BCyANQQU6AAAMAQsgBykDGCISQv8Bg0IEUgRAIA0gEjcCAAwBCyARIAwQlT0hBSMAQRBrIggkACAIIAU2AgwgBCgCAEEBRgRAIARBDGohBSAEQQRqKAIAJQEgCEEMaigCACUBEC0hExDfEiIDIBMmASADEPsOIQMCQCAEKAIMIgRFDQAgBCAEKAIAQQFrIgQ2AgAgBA0AIAUQshoLIAUgAzYCACAIKAIMIQULIAVBhAFPBEAgBRDyHwsgB0EIakEANgIAIAhBEGokACANIAw2AgQgDUEEOgAACyAHQSBqJAAgCS0ACEEFRgRAIAtBBToAAAwECyAJKQMIIhJC/wGDQgRSBEAgCyASNwIADAQLIAooAgQhByAKKAIIIQUgCkIBNwIEIAUgEkIgiKciBEkNAiAKIAUgBGsiDDYCCCAKIAQgB2o2AgQgEkL/////D1YNAAsgC0KBLjcCAAwCCyALQQQ6AAAMAQsgCUEANgIYIAlBATYCDCAJQYzHwwA2AgggCUIENwIQIAlBCGpB/MnDABDvLAALIAlBIGokACAGLQAYQQVHDQEgAEEJNgIAQQMMAgtBsLXDABDoKwALAkAgBikDGCISQv8Bg0IEUgRAIAYgEjcDGCAGIAZBGGoQgSsMAQsgBkEINgIACyABQRBqIAEoAgggASgCDCABKAIEKAIQEQEAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAgACAGKQMANwMAQQELOgAgIAZBIGokAAvCCQIPfwN+IwBB4ABrIgUkAAJAAkAgASgCCCICIAEoAhBGBEAgAEEJNgIADAELIAEgAkEEajYCCCAFQRhqIQogAigCACECIwBB8ABrIgQkACABKAIUQQhqIgMgAhCILSIGIAEoAhgiBxCJLSEJAkACQAJAAkACQAJAIAMQ1zQiA0UNACACIAMoAggiCE8NAiADKAIEIgMgAkEMbCIIaigCCCICRQ0AIAIgB00NAyAEQQRqIAMgCGooAgQgB0EYbGoQzhUMAQsgBEGAgICAeDYCBAsgBikDECABKAIAIgsgCygCACIBQQFqNgIAIAFBAEgNAiMAQRBrIgckACAHQQhqQYEEOwEAIActAAghASAHIActAAlBAXE6AAEgByABOgAAIActAAEhASAHLQAAIQJBDEEEEK02IgZFBEBBBEEMEKM9AAsgBkKBgICAEDcCACAGIAJBAXE6AAggBiABQQFxOgAJIARBKGohAachECAEQQRqIQMjAEEgayICJAAgAiAGNgIEIAIgCzYCACACQQhqIAkoAtABIAkoAtQBIAZBCGoQxw0gAigCECEOIAIoAgwhDwJAIAIoAggiCEEIRwRAIAEgAikCFDcCFCABQRxqIAJBHGooAgA2AgAgASAONgIQIAEgDzYCDCABIAg2AgggAUIDNwMAIAYgBigCACIBQQFrNgIAIAFBAUYEQCACQQRqEIIsCyADKAIAQYCAgIB4RwRAIAMQ9TsLIAIoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAIQ6CcMAQsgAkEIaiAJEOwgIAIpAwghEQJAAn4CQCADKAIAIgZBgICAgHhHBEAgAygCBCEIIAMoAggiDA0BQgAMAgsgAikDECETIAktABAhBkICIRIMAgtCACAIKQMAIhIgEVENABogEiARfachDUIBCyESIAZBCHYhAwsgCSgCvAJBCGoQ3SVB/wFxIQkgAUEjaiADQRB2OgAAIAEgAzsAISABIAs2AkAgASAONgI8IAEgDzYCOCABQQA2AjQgASAQNgIwIAEgDDYCLCABQQA2AiggASAINgIkIAEgBjoAICABQQA2AhwgASANNgIYIAEgEzcDECABIBE3AwggASASNwMAIAEgCToARCACKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNACACQQRqEIIsCyACQSBqJAAgB0EQaiQAIARBGGoiASAEQThqKQMANwMAIARBIGoiAiAEQUBrKQMANwMAIAQgBCkDMDcDECAEKQMoIhFCA1IEQCAKQSBqIARByABqQSj8CgAACyAKIAQpAxA3AwggCkEYaiACKQMANwMAIApBEGogASkDADcDACAKIBE3AwAgBEHwAGokAAwDCyACIAhBgNbDABDDIQALIAcgAkGQ1sMAEMMhCwALIAACfyAFKQMYQgNRBEAgBUEQaiAFQTRqKAIANgIAIAUgBSkCLDcDCCAFKAIkIQEgBSgCICECIAUoAigMAQtByABBCBCtNiIBRQ0CIAEgBUEYakHIAPwKAABBCCECQazPwwALNgIIIAAgATYCBCAAIAI2AgAgACAFKQMINwIMIABBFGogBUEQaigCADYCAAsgBUHgAGokAA8LQQhByAAQoz0AC94FAgh/AX4jAEEQayIGJAACQAJAAkACQAJAAkACQEEBIAEpAwAiDKdBAmsgDEIBWBtBAWsOAwECAwALQQAhAyMAQRBrIgUkAAJAAkACQAJAAkAgAUEIaiIEKAIUIgcgAiACIAdLGyIBRQ0AIAQoAhAiAiAEKAIIIghPDQAgBCgCBCEJIAFBAWshCkEAIQEDQCACQQRqIgMgCEsNAiACQXxPDQMgBCACIAlqKAAAIANqIgI2AhAgAUEBaiEDIAIgCE8NASABIApHIAMhAQ0ACwsgACADNgIEIABBCDYCACAEIAcgA2s2AhQMAwsgBUEEakEXQQBBAUEBEKAYIAUoAgghAiAFKAIEQQFGDQEgBSgCDCIBQQ9qQduGzQApAAA3AAAgAUEIakHUhs0AKQAANwAAIAFBzIbNACkAADcAACAAQRc2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMAgsgAiADQdiNzQAQsTsACyACIAUoAgxB1P3MABD9LwALIAVBEGokAAwFCyADDQMgBkEEakEiQQBBAUEBEKAYIAYoAgghASAGKAIEQQFHDQIgASAGKAIMQdT9zAAQ/S8ACyAAIQMCQAJAIAIgAUEIaiIFKAIIIgQgBSgCHCIBayIAIAAgAksbIgAgAWoiAiAATwRAIAIgBEsNAQJAIABFBEBBACEEDAELIAUoAgQgAUECdGohB0EAIQQgACEBA0AgBygCACAEaiEEIAdBBGohByABQQFrIgENAAsLIAUgAjYCHCADIAA2AgQgA0EINgIAIAUgBSgCICAEajYCIAwCCyABIAJBjI/NABCxOwALIAIgBEGMj80AELA7AAsMAwsgACABQQhqIAIQpAsMAgsgBigCDCICQeSMzQBBIvwKAAAgAEEiNgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAMoAghBAUcEQCAAIAEgAhCQFAwBCyAAQgg3AwALIAZBEGokAAvvAQEEfyMAQUBqIgQkAAJAAkAgASACKAIQEQQAIgUtAABBIEYEQCAFKAIEIgYgBigCACIHQQFqNgIAIAdBAEgNASAEIAYgBSgCCBDOHEEwQQgQrTYiBUUNAiAFQoGAgIAQNwMAIAVBCGogBEEo/AoAACAAIAU2AhwgACACNgIYIAAgATYCFCAAIAMpAgA3AgAgAEEIaiADQQhqKQIANwIAIABBEGogA0EQaigCADYCACAEQUBrJAAPCyAEQQA2AjggBEEBNgIsIARB5KvPADYCKCAEQgQ3AjAgBEEoakHsq88AEO8sCwALQQhBMBCjPQAL4wEBA38jAEGABGsiBCQAIARBDGogASABIAJBA3RqIgVB0MiCARDBGyAEQRhqIgYgBCgCECICIAIgBCgCFEHEAGxqQdDIggEQwBsgBEEkaiAGQQAgAxCjAUEAIQIDQCAEQSRqIgMgAkEAIAEoAgAgAUEEaigCACgCJBEEABDYGyACQQFqIQIgAUEIaiIBIAVHDQALIARBtAJqIgEgA0HMAfwKAAAgBEHwAWoiAiABEOosIAQgAhCgASAAIAQpAwA3AgQgAEGTgICAeDYCACAEQQxqIgAQpCwgABD1PCAEQYAEaiQAC8gBAgJ/AX4jAEEQayIBJAACQAJAAkAgAq0gA61+IgZCIIinDQAgBqciAkEHaiIEIAJJDQAgAyAEQXhxIgRqQQhqIgIgBEkgAkH4////B0tyDQAgAkEIEK02IgUNAUEIIAIQ5S4gACABKQMINwIEIABBADYCAAwCCxDdJyAAIAEpAwA3AgQgAEEANgIADAELIABBADYCDCAAIANBAWsiAjYCBCAAIAQgBWo2AgAgACACIANBA3ZBB2wgAkEISRs2AggLIAFBEGokAAvrAQEJfyMAQUBqIgIkACACQTRqIAEQ2QYgASgCDCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIQIQYgASgCFCIDBEAgAyADKAIAIgRBAWo2AgAgBEEASA0BIAEoAiQhByABKAIgIQggASgCHCEJIAEoAhghCiABKAIoIQQLIAJBCGogAkE8aigCADYCACACIAIpAjQ3AwAgAiAENgIoIAIgBzYCJCACIAg2AiAgAiAJNgIcIAIgCjYCGCACIAM2AhQgAiAGNgIQIAIgBTYCDCACIAEpAiw3AiwgACACEIMTIAJBQGskAA8LAAv3AQEDfyMAQRBrIgUkACACIQMCQAJAAkACQCACQT9xIgQEQCACIARrQUBrIgMgAkkNAQtBwAAhBCADQcAAENE0RQ0BIAMEQCADQcAAEK02IgRFDQMLIAIEQCAEIAEgAvwKAAALQRxBBBCtNiIBRQ0DIAEgAzYCGCABQoCAgICACDcCECABIAI2AgwgASAENgIIIAFCgYCAgBA3AgAgACACNgIIIAAgBDYCBCAAIAE2AgAgBUEQaiQADwtBpP+HAUEjQcj/hwEQyyQAC0HY/ocBQSkgBUEPakHM/IcBQYT/hwEQ1R4AC0HAACADEKM9AAtBBEEcEKM9AAuGAgECfyMAQRBrIgIkACABKAJgIQMgAUGAgICAeDYCYAJAAkAgA0GAgICAeEcEQCAAIAFBEGpB0AD8CgAAIAAgAzYCUCAAIAEpAmQ3AlQgAEHcAGogAUHsAGooAgA2AgAMAQsgAkEEakEgQQBBAUEBEKAYIAIoAgghAyACKAIEQQFGDQEgAigCDCIBQRhqQfD0zwApAAA3AAAgAUEQakHo9M8AKQAANwAAIAFBCGpB4PTPACkAADcAACABQdj0zwApAAA3AAAgAEGAgICAeDYCUCAAQSA2AgwgACABNgIIIAAgAzYCBCAAQQA2AgALIAJBEGokAA8LIAMgAigCDEGw6M8AEP0vAAvrAQEHfyMAQeAAayIBJAACQAJAAkACQCAAKAIMIgdFDQAgACgCCCICQQRqIQMgAkF7Sw0BIAMgACgCBCIFSw0CIAAoAgAhBiAAIAM2AgggACAHQQFrNgIMIAEgAiAGaigAACACajYCXCABIAU2AlggASAGNgJUIAFBCGoiACABQdQAahDwAyABKAI8QYCAgIB4Rg0AQdAAQQgQrTYiBEUNAyAEQoGAgIAQNwMAIARBCGogAEHIAPwKAAALIAFB4ABqJAAgBA8LIAIgA0G87v4AELE7AAsgAyAFQbzu/gAQsDsAC0EIQdAAEKM9AAvoAQEJfyMAQRBrIgMkACADQQRqIAEQ0AYgASgCDCIFIAUoAgAiAkEBajYCAAJAIAJBAEgNACABKAIUIQYgASgCECEHIAEoAhgiAgRAIAIgAigCACIEQQFqNgIAIARBAEgNASABKAIsIQQgASgCKCEIIAEoAiQhCSABKAIgIQogASgCHCEBCyAAIAMpAgQ3AgAgACAENgIsIAAgCDYCKCAAIAk2AiQgACAKNgIgIAAgATYCHCAAIAI2AhggACAGNgIUIAAgBzYCECAAIAU2AgwgAEEIaiADQQxqKAIANgIAIANBEGokAA8LAAv0AQICfwR+IwBBMGsiAiQAIAJBEGpBuKyGASgCADYCACACQbCshgEpAgA3AwgCQAJAAkAgASABQugHfyIBQugHfn0iBEI/hyIFIAF8IgEgAUKAowV/IgFCgKMFfn0iBkI/hyIHIAF8IgFCxY3U/wd9QoCAgIBwVA0AIAGnQbvyK2oQ8xYiA0UNACACIAVC6AeDIAR8p0HAhD1sNgIsIAIgB0KAowWDIAZ8PgIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAvQAQEDfyMAQTBrIgQkACADKAIsIQYCQAJAIAIEQEGTgICAeCEFIAZFDQIgAiADQSxqEOIIDQIgBEECNgIcIARByPuGATYCGCAEQgE3AiQMAQtBk4CAgHghBSAGRQ0BIAMoAkBFDQEgBEECNgIcIARBkPuGATYCGCAEQgI3AiQgBEGtAzYCFCAEIAFBGGo2AhALIARBrQM2AgwgBCADQRhqNgIIIAQgBEEIajYCICAAQQRqIARBGGoQmQ5BjYCAgHghBQsgACAFNgIAIARBMGokAAuqFAEUfyMAQSBrIgkkAAJAQQRBBBCtNiIQBEAgECABNgIAQQEhEyAJQQE2AhAgCSAQNgIMIAlBATYCCCAJQRRqIQIgAUEoaiEBIwBBMGsiCiQAAkACfwJAAkADQCABLQAAIgNBIkcEQAJAAkACQAJAIANBG2sODgYABwYAAQIAAAAAAAYDAAsgAkEANgIIIAJCgICAgMAANwIADAgLIAEoAgQhAyABKAIIIQEgCkEANgIYIApBADYCCCAKIANBCGoiAzYCKCAKIAMgAUECdGo2AiwgAiENQQAhAyMAQUBqIgQkAAJ/IApBCGoiASgCACICBEAgASgCBCEDIAEoAgwhB0EADAELQQELIQYDQAJAAkACQAJ/AkAgBkUEQCADIAdHDQEgBCACNgIUIAQgASgCCDYCECAEQRBqQQRBBBDgHiABQQA2AgBBASEGDAYLAkAgASgCICICRQ0AIAIgASgCJEYNACABIAJBBGo2AiAgBEEQaiACKAIAQQhqEIMVIAQoAhAiAkGAgICAeEYNACABIAI2AgggASAEKAIUIgI2AgQgASACNgIAIAEgAiAEKAIYQQJ0aiIHNgIMIAIhAwwECwJAIAEoAhAiAgRAIAEoAhQiAyABKAIcIgdHDQEgBCACNgI8IAQgASgCGDYCOCAEQThqQQRBBBDgHiABQQA2AhALIA1BADYCCCANQoCAgIDAADcCACABEP0iDAMLIAEgA0EEaiICNgIUIAcgAmtBAnYhAkEAIQYgAygCAAwBCyABIANBBGoiDjYCBCABKAIcIAEoAhRrQQJ2QQAgASgCEBshAiAHIA5rQQJ2IQYgAygCAAshAyAEQRBqIgVBAyACIAZqIgIgAkEDTRtBAWpBAEEEQQQQoBggBCgCFCECIAQoAhBBAUYNDSAEQQxqIhRBATYCACAEKAIYIgcgAzYCACAEIAc2AgggBCACNgIEIAUgAUEo/AoAACAEQQRqIQsjAEEgayIIJAAgBSgCHCERIAUoAhAhDyAFKAIkIRUgBSgCFCEMIAUoAgghDiAFKAIgIQIgBSgCBCEBIAUoAgwhByAFKAIAIQMDQAJAIANFIQYDQAJAAkACQCAGRQRAIAEgB0cNASAIIAM2AhAgCCAONgIMIAhBDGpBBEEEEOAeIAVBADYCACABIQdBASEGDAQLAkAgAkUEQEEAIQIMAQsgAiAVRg0AIAUgAkEEaiIDNgIgIAhBDGogAigCAEEIahCDFSAIKAIMIgJBgICAgHhHDQIgAyECCwJAIA8EQCAMIBFHDQEgCCAPNgIcIAggBSgCGDYCGCAIQRhqQQRBBBDgHiAFQQA2AhALIAUQ/SIgCEEgaiQADAULIAUgDEEEaiIGNgIUIAwoAgAhEkEAIQMgBiEMDAILIAUgAUEEaiIGNgIEIAEoAgAhEiAGIQEMAQsgBSACNgIIIAUgCCgCECIBNgIEIAUgATYCACAFIAEgCCgCFEECdGoiBzYCDCACIQ4gAyECIAEhA0EAIQYMAQsLIAsoAggiBiALKAIARgRAIAsgBiAHIAFrQQJ2QQAgAxsgESAMa0ECdkEBakEBIA8bakEEQQQQ3CgLIAsgBkEBajYCCCALKAIEIAZBAnRqIBI2AgAMAQsLIA1BCGogFCgCADYCACANIAQpAgQ3AgALIARBQGskAAwBC0EAIQYMAQsLDAcLIAEoAgQhAyABKAIIIQEgCkEANgIYIApBADYCCCAKIANBCGoiAzYCKCAKIAMgAUEDdGo2AiwgAiENQQAhAyMAQUBqIgQkAAJ/IApBCGoiASgCACICBEAgASgCBCEDIAEoAgwhB0EADAELQQELIQYDQAJAAkACQAJ/AkAgBkUEQCADIAdHDQEgBCACNgIUIAQgASgCCDYCECAEQRBqQQRBBBDgHiABQQA2AgBBASEGDAYLAkAgASgCICICRQ0AIAIgASgCJEYNACABIAJBCGo2AiAgBEEQaiACKAIEQQhqEIMVIAQoAhAiAkGAgICAeEYNACABIAI2AgggASAEKAIUIgI2AgQgASACNgIAIAEgAiAEKAIYQQJ0aiIHNgIMIAIhAwwECwJAIAEoAhAiAgRAIAEoAhQiAyABKAIcIgdHDQEgBCACNgI8IAQgASgCGDYCOCAEQThqQQRBBBDgHiABQQA2AhALIA1BADYCCCANQoCAgIDAADcCACABEP0iDAMLIAEgA0EEaiICNgIUIAcgAmtBAnYhAkEAIQYgAygCAAwBCyABIANBBGoiDjYCBCABKAIcIAEoAhRrQQJ2QQAgASgCEBshAiAHIA5rQQJ2IQYgAygCAAshAyAEQRBqIgVBAyACIAZqIgIgAkEDTRtBAWpBAEEEQQQQoBggBCgCFCECIAQoAhBBAUYNDCAEQQxqIhRBATYCACAEKAIYIgcgAzYCACAEIAc2AgggBCACNgIEIAUgAUEo/AoAACAEQQRqIQsjAEEgayIIJAAgBSgCHCERIAUoAhAhDyAFKAIkIRUgBSgCFCEMIAUoAgghDiAFKAIgIQIgBSgCBCEBIAUoAgwhByAFKAIAIQMDQAJAIANFIQYDQAJAAkACQCAGRQRAIAEgB0cNASAIIAM2AhAgCCAONgIMIAhBDGpBBEEEEOAeIAVBADYCACABIQdBASEGDAQLAkAgAkUEQEEAIQIMAQsgAiAVRg0AIAUgAkEIaiIDNgIgIAhBDGogAigCBEEIahCDFSAIKAIMIgJBgICAgHhHDQIgAyECCwJAIA8EQCAMIBFHDQEgCCAPNgIcIAggBSgCGDYCGCAIQRhqQQRBBBDgHiAFQQA2AhALIAUQ/SIgCEEgaiQADAULIAUgDEEEaiIGNgIUIAwoAgAhEkEAIQMgBiEMDAILIAUgAUEEaiIGNgIEIAEoAgAhEiAGIQEMAQsgBSACNgIIIAUgCCgCECIBNgIEIAUgATYCACAFIAEgCCgCFEECdGoiBzYCDCACIQ4gAyECIAEhA0EAIQYMAQsLIAsoAggiBiALKAIARgRAIAsgBiAHIAFrQQJ2QQAgAxsgESAMa0ECdkEBakEBIA8bakEEQQQQ3CgLIAsgBkEBajYCCCALKAIEIAZBAnRqIBI2AgAMAQsLIA1BCGogFCgCADYCACANIAQpAgQ3AgALIARBQGskAAwBC0EAIQYMAQsLDAYLBSABKAIIIQEMAQsLIAIgASgCCEEIahCDFQwDC0EEDAELQQgLIQMgAiABIANqKAIAQQhqEIMVCyAKQTBqJAAgCSgCGCECIAkoAhwiAQRAIAlBCGpBASABQQRBBBDcKCAJKAIQIRMgCSgCDCEQCyABQQJ0IgMEQCAQIBNBAnRqIAIgA/wKAAALIAlBEGoiAiABIBNqNgIAIAlBADYCHCAJQRRqQQRBBBDgHiAAQQhqIAIoAgA2AgAgACAJKQIINwIAIAlBIGokAA8LQQRBBBCjPQALIAIgBCgCGEHAzocBEP0vAAv5BAEJfyMAQSBrIgQkAAJAAkAgASgCCCICRQ0AIAEgAkEBayIGNgIIIAEoAgQiAyAGQQV0aiIHKAIAIgJBCUYNACAEQRxqIAdBHGooAgA2AgAgBEEUaiAHQRRqKQIANwIAIARBDGogB0EMaikCADcCACAEIAcpAgQ3AgQgBCACNgIAIAYEQCAEIANBCBD6KiMAQSBrIgUkACAFQQhqIAEoAgQiCCICQQhqKQMANwMAIAVBEGogAkEQaikDADcDACAFQRhqIAJBGGopAwA3AwAgBSACKQMANwMAQQEhAwJAIAEoAggiAkECayIHQQAgAiAHTxsiBkUEQEEAIQIMAQtBACECA0AgCCACQQV0aiIKIAggAyAJQQV0IAhqQdgAaikDACAIIANBBXRqKQMYV2oiAkEFdGoiAykDADcDACAKQQhqIANBCGopAwA3AwAgCkEQaiADQRBqKQMANwMAIApBGGogA0EYaikDADcDACACQQF0IglBAXIhAyAGIAlLDQALCwJAIAcgCUcEQCACIQMMAQsgCCACQQV0aiIGIAggA0EFdGoiAikDADcDACAGQRhqIAJBGGopAwA3AwAgBkEQaiACQRBqKQMANwMAIAZBCGogAkEIaikDADcDAAsgCCADQQV0aiICIAUpAwA3AwAgAkEYaiAFQRhqKQMANwMAIAJBEGogBUEQaikDADcDACACQQhqIAVBCGopAwA3AwAgASADEJATIAVBIGokAAsgACAEKQMANwMAIABBGGogBEEYaikDADcDACAAQRBqIARBEGopAwA3AwAgAEEIaiAEQQhqKQMANwMADAELIABBCTYCAAsgBEEgaiQAC8kBAQR/IAAgAWohBkEBIQUCQANAIAAgBkYNAQJ/IAAsAAAiAUEATgRAIAFB/wFxIQEgAEEBagwBCyAALQABQT9xIQMgAUEfcSEEIAFBX00EQCAEQQZ0IANyIQEgAEECagwBCyAALQACQT9xIANBBnRyIQMgAUFwSQRAIAMgBEEMdHIhASAAQQNqDAELIARBEnRBgIDwAHEgAC0AA0E/cSADQQZ0cnIiAUGAgMQARg0CIABBBGoLIQAgAhDuEiABRg0AC0EAIQULIAUL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDLJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqEMwnIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/ABAQF/IABBmANqEJUMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAuwCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQewCahDZIQsgAEGgAmoQzScgAEG4AmoQsiwgAEHgAmoQtDAgACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LgJAIAAoAvABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABB8AFqELsjCyAAQaABahDZFSAAQfgBahCVDAsL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDOJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqEM8nIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/ABAQF/IABBmANqEJUMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAuwCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQewCahDZIQsgAEGgAmoQ0CcgAEG4AmoQsiwgAEHgAmoQtDAgACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LgJAIAAoAvABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABB8AFqELsjCyAAQaABahDZFSAAQfgBahCVDAsL8AEBAX8gAEGYA2oQlQwgAEH4AmoQvCogAEGAA2oQtDAgAEGMA2oQtDAgACgC7AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB7AJqENkhCyAAQaACahDRJyAAQbgCahCyLCAAQeACahC0MCAAKQMAQgVSBEAgACgCkAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBkAJqENkhCyAAQYgCahC8KiAAQdAAahCTKiAAEP0uAkAgACgC8AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHwAWoQuyMLIABBoAFqENkVIABB+AFqEJUMCwvwAQEBfyAAQZgDahCVDCAAQfgCahC8KiAAQYADahC0MCAAQYwDahC0MCAAKALsAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAmoQ2SELIABBoAJqENInIABBuAJqELIsIABB4AJqELQwIAApAwBCBVIEQCAAKAKQAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGQAmoQ2SELIABBiAJqELwqIABB0ABqEJMqIAAQ/S4CQCAAKALwASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfABahC7IwsgAEGgAWoQ2RUgAEH4AWoQlQwLC/oBAgJ/AX4jAEGgAWsiAiQAIAEoAgghAyABQYCAgIB4NgIIAkAgA0GAgICAeEcEQCABKQMAIQQgAiADNgIIIAIgBDcDACACQQxqIAFBDGpB7AD8CgAAIAJB/ABqIAIQ/RAgAigChAEiAUEDTQ0BIAIoAoABIAFBBGs2AAAgAkGQAWogAkGEAWooAgA2AgAgAiACKQJ8NwOIASAAQQRqIAJBiAFqEOcVIABBCDYCACACQaABaiQADwtBiJ3OAEEkQaydzgAQyyQACyACQQA2ApgBIAJBATYCjAEgAkHcnc4ANgKIASACQgQ3ApABIAJBiAFqQeSdzgAQ7ywAC+QBAQV/IAAoAiAiAkUEQEEADwsgACACQQFrNgIgAkACQCAAEM0jIgMEQCADKAIEIQACQAJAIAMoAggiBCADKAIAIgEvAQZJBEAgASECDAELA0AgASgCACICRQ0CIABBAWohACABLwEEIQQgBCACIgEvAQZPDQALCyAEQQFqIQEgAA0CIAIhBQwDC0HI4NAAELI7AAtB2ODQABCyOwALIAIgAUECdGpBFGohAQNAIAEoAgAiBUEUaiEBIABBAWsiAA0AC0EAIQELIAMgATYCCCADQQA2AgQgAyAFNgIAIAIgBGpBCGoL6wECBn8BfiMAQSBrIgEkACAALQAYIQIgASAAKQMQIgc3AwAgAkEDdiEDAkACQCACQcgASQRAIAAoAgQiBSAAKAIMIgYgACgCCGoiBGsgA0kNASAEIAVLDQIgAwRAIAAoAgAgBGogASAD/AoAAAsgACACQQdxOgAYIAAgAyAGajYCDCAAIAcgAq1C+ACDiEIAIAJBwABJGzcDECABQSBqJAAPCyADQQhBjNz7ABCwOwALIAFBADYCGCABQQE2AgwgAUGswvsANgIIIAFCBDcCECABQQhqQZzc+wAQ7ywACyAEIAVBnNz7ABCvOwAL0gEBBn8gACAAKAIoIgIQhC4gACgCCCEBIAAgAgR/IAIEQCAAKAIEIAFqQQAgAvwLAAsgASACagUgAQs2AgggAEEMaiIDEOY6IAAoAgwEQCAAKAIcQQFqIgRBA3YgBEEHcUEAR2oiAiAAKAIYIgFLBEAgAiABayEFIAAoAhAiBiACSQRAIAMgBkEBdCIBIAIQzSoiAyABIANLGxDoGSAAKAIYIQELIAUEQCAAKAIUIAFqQQAgBfwLAAsgACACNgIYCyAAIAQ2AhwPC0Howf8AELI7AAvmAQEFfyMAQRBrIgUkACABKAIIIgJBBGohAwJAAkACQCACQXtNBEAgAyABKAIEIgRLDQEgBUEEaiIGIAEoAgAiAyAEIAIgAiADaigAAGsQ9jQCQCAGQQgQzCBB//8DcSIBRQRAIABBADYCAAwBCyABIAJqIgFBBGohAiABQXtLDQMgAiAESw0EIAAgBDYCBCAAIAM2AgAgACABIANqKAAAIAFqNgIICyAFQRBqJAAPCyACIANB0MzMABCxOwALIAMgBEHQzMwAELA7AAsgASACQcDMzAAQsTsACyACIARBwMzMABCwOwAL8gEBAX8jAEHwAGsiBCQAIAQgAToABwJAAkACQAJAIAFB/wFxQQJrDgIBAgALIARBATYCDCAEQdyvzgA2AgggBEIBNwIUIARBrgM2AmwgBCAEQegAajYCECAEIARBB2o2AmggBEEIakHkr84AEO8sAAsgBEEANgJAIARCADcDOCAEQQA2AhggBCADOgBEIARCADcDCCAEQQhqIgEgAhDKDyAAIAFBwAD8CgAADAELIAAgAzoAKCAAQgI3AwAgACACKQIANwMIIABBGGpCADcDACAAQSBqQgA3AwAgAEEQaiACQQhqKQIANwMACyAEQfAAaiQAC+ABAQF/IABB0AJqEJ0MIABBsAJqELwqIABBuAJqELQwIABBxAJqELQwIAAoAqACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaACahDZIQsgAEGIAmoQ3jsgAEHgAWoQsiwgAEGUAmoQtDAgACkDAEIFUgRAIAAoAtABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQdABahDZIQsgAEHIAWoQvCogAEHQAGoQlSogABCCLyAAKALAASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHAAWoQ2SELIABBoAFqEPYmCwvgAQEBfyAAQdACahCdDCAAQbACahC8KiAAQbgCahC0MCAAQcQCahC0MCAAKAKgAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGgAmoQ2SELIABBiAJqEOk7IABB4AFqELIsIABBlAJqELQwIAApAwBCBVIEQCAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ2SELIABByAFqELwqIABB0ABqEJUqIAAQgi8gACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqENkhCyAAQaABahD2JgsL4AEBAX8gAEHQAmoQnQwgAEGwAmoQvCogAEG4AmoQtDAgAEHEAmoQtDAgACgCoAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBoAJqENkhCyAAQYgCahDjPCAAQeABahCyLCAAQZQCahC0MCAAKQMAQgVSBEAgACgC0AEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB0AFqENkhCyAAQcgBahC8KiAAQdAAahCVKiAAEIIvIAAoAsABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQcABahDZIQsgAEGgAWoQ9iYLC+sBAQF/IAAoAgAiACgCEEGAgICAeEcEQCAAQRBqEN47CyAAQRxqEK4vIAAoAjQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBNGoQhh8LIAAoAihBgICAgHhHBEAgAEEoakEBQQEQ4B4LIABB2ABqIgEQ3BggAUEIQcAAEOAeIAAoAkBBgICAgHhHBEAgAEFAayIBEMYqIAFBBEEMEOAeCyAAKAJMQYCAgIB4RwRAIABBzABqIgEQxyogAUEEQQwQ4B4LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQegAQQgQ+DoLC88BAQJ/IAEoAgAiBEECdEEEaiIFBEAgAEEAIAX8CwALAkAgAwRAIAIgA2ohAwNAIAIgA08EQCAEQQFqIQIgACAEQQJ0aiEDA0AgAkEBayECIAMoAgAgA0EEayEDRQ0ACyABIAI2AgBBACEDQX8hAQNAIAEgAkYNBCAAKAIAIgQgAyADIARJGyEDIABBBGohACABQQFqIQEMAAsABSAAIAItAABBAnRqIgUgBSgCAEEBajYCACACQQFqIQIMAQsACwALQQAhAyABQQA2AgALIAMLYAECfyMAQSBrIgMkACADQRRqIAFBAUECQQIQoBggAygCGCEEIAMoAhRBAUcEQCADKAIcIQIgACABNgIIIAAgAjYCBCAAIAQ2AgAgA0EgaiQADwsgBCADKAIcIAIQ/S8AC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQN2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQJ2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQF2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQR2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC/0BAQJ/IwBBoAJrIgIkACACQewBaiABQQhqKAIANgIAIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAIgASkCADcC5AEgAiABKAIUQQV2NgLwASACQegAaiACQcQBaiABQRhqEMIZQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgLMASACIAM2AsgBIAJBATYCxAEgAkEMaiIBIAJB6ABqIAJBxAFqEJYpIAAgARDNHCACQaACaiQAC+oBAQt/IwBBMGsiAiQAIAEoAgAiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgASgCECEGIAEoAgwhByABKAIIIQggASgCBCEJIAEoAhQiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNASABKAIoIQQgASgCJCEKIAEoAiAhCyABKAIcIQwgASgCGCEBCyACIAQ2AiwgAiAKNgIoIAIgCzYCJCACIAw2AiAgAiABNgIcIAIgAzYCGCACIAY2AhQgAiAHNgIQIAIgCDYCDCACIAk2AgggAiAFNgIEIAAgAkEEahCtFiACQTBqJAAPCwAL9AECAn8EfiMAQTBrIgIkACACQRBqQY+evPgANgIAIAJCj568+PDhw4cPNwMIAkACQAJAIAEgAULoB38iAULoB359IgRCP4ciBSABfCIBIAFCgKMFfyIBQoCjBX59IgZCP4ciByABfCIBQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAiAFQugHgyAEfKdBwIQ9bDYCLCACIAdCgKMFgyAGfD4CKCACIAM2AiQgAkEYaiACQSRqEMovIAIoAhgiAw0BCyAAQQA2AgAMAQsgACACKQIcNwIEIAAgAzYCAAsgAkEIahDJDCACQTBqJAAL5AEBBH8jAEEQayIBJAAgACgCDCECAkACQAJAAkACQAJAIAAoAgQOAgABAgsgAg0BQQEhA0EAIQAMAgsgAg0AIAAoAgAiAigCBCEAIAIoAgAhAwwBCyABQQRqIAAQmQ4gASgCDCEAIAEoAgghAgwBCyABQQRqIABBAEEBQQEQoBggASgCCCEEIAEoAgRBAUYNASABKAIMIQIgAARAIAIgAyAA/AoAAAsgASAANgIMIAEgAjYCCCABIAQ2AgQLIAIgABCUPiABQQRqEN47IAFBEGokAA8LIAQgASgCDEHg0cwAEP0vAAvNAQEEfyMAQSBrIgIkACAAKAIIIgMgA60gAUIgiH5CIIinIgRLBEAgACgCBCACQRhqQgA3AwAgAkEQakIANwMAIAJBCGpCADcDACACQgA3AwAgAachBUEAIQADQCAAIAJqQQEgAEHs6M4AaigCACAFbEEbdnQ2AgAgAEEEaiIAQSBHDQALIARBBXRqIQNBACEAA0AgACADaiIEIAQoAgAgACACaigCAHI2AgAgAEEEaiIAQSBHDQALIAJBIGokAA8LIAQgA0H06c4AEMMhAAtjAQN/IwBBIGsiAiQAIAJBFGogAUEBQQRBBBCgGCACKAIYIQMgAigCFEEBRwRAIAIoAhwhBCAAIAE2AgggACAENgIEIAAgAzYCACACQSBqJAAPCyADIAIoAhxBxJ7QABD9LwALYwEDfyMAQSBrIgIkACACQRRqIAFBAUEIQRAQoBggAigCGCEDIAIoAhRBAUcEQCACKAIcIQQgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEgaiQADwsgAyACKAIcQazKzQAQ/S8AC+QBAQF/IABB0AJqEJ0MIABBsAJqELwqIABBuAJqELQwIABBxAJqELQwIAAoAqACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQaACahDZIQsgAEGIAmpBBEEMEOAeIABB4AFqELIsIABBlAJqELQwIAApAwBCBVIEQCAAKALQASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHQAWoQ2SELIABByAFqELwqIABB0ABqEJUqIAAQgi8gACgCwAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBwAFqENkhCyAAQaABahD2JgsL1wEBBn8gAEEYaiIDEOY6IAAoAhgEQCAAKAIoQQFqIgRBA3YgBEEHcUEAR2oiAiAAKAIkIgFLBEAgAiABayEFIAAoAhwiBiACSQRAIAMgBkEBdCIBIAIQzSoiAyABIANLGxDoGSAAKAIkIQELIAUEQCAAKAIgIAFqQQAgBfwLAAsgACACNgIkCyAAIAQ2AiggACgCCCEBIAAoAhQiAiAAKAIMRgRAIABBDGpBgL7/ABCdKAsgACgCECACQQJ0aiABNgIAIAAgAkEBajYCFA8LQejB/wAQsjsAC9kBAgZ/AX4gAEEYaiIDEOY6IAAoAhgEQCAAKAIoQQFqIgRBA3YgBEEHcUEAR2oiASAAKAIkIgJLBEAgASACayEFIAAoAhwiBiABSQRAIAMgBkEBdCICIAEQzSoiAyACIANLGxDoGSAAKAIkIQILIAUEQCAAKAIgIAJqQQAgBfwLAAsgACABNgIkCyAAIAQ2AiggADUCCCEHIAAoAhQiASAAKAIMRgRAIABBDGpBgL7/ABCzKAsgACgCECABQQN0aiAHNwMAIAAgAUEBajYCFA8LQejB/wAQsjsAC2MBA38jAEEgayICJAAgAkEUaiABQQFBBEEIEKAYIAIoAhghAyACKAIUQQFHBEAgAigCHCEEIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBIGokAA8LIAMgAigCHEGQ7oMBEP0vAAuiBwILfwF+IwBBIGsiBiQAIAEoAgghAiAGQRRqAn8gASgCACIEBEAgASgCBCAEa0EYbiIEIAJFDQEaIAEoAgwgAmtBGG4gBGoMAQtBACACRQ0AGiABKAIMIAJrQRhuC0EAQQRBGBCgGCAGKAIYIQIgBigCFEEBRgRAIAIgBigCHEGUvMMAEP0vAAsgBkEQaiILQQA2AgAgBiAGKAIcNgIMIAYgAjYCCCAGQQhqIQIjAEEQayIJJAAgASgCCCEEAkACQAJ/IAEoAgAiAwRAIAEoAgQgA2tBGG4iAyAERQ0BGiABKAIMIARrQRhuIANqDAELIARFBEAgAkEIaiEDDAILIAEoAgwgBGtBGG4LIQcgAkEIaiEDIAcgAigCACACKAIIIgRrTQ0BIAIgBCAHQQRBGBDQKAsgAigCCCEECyAJIAIoAgQ2AgwgCSAENgIIIAkgAzYCBCAJQQRqIQgjAEEwayICJAACQCABKAIAIgRFDQAgASgCBCEDIAIgCDYCACADIARGDQAgAyAEa0EYbiEHA0AjAEEwayIDJAAgAigCACEFIANBGGogBBDdIAJAIAQoAgxBgICAgHhHBEAgA0EkaiAEQQxqEN0gDAELIANBgICAgHg2AiQLIANBCGoiCiADQSBqKAIANgIAIANBFGogA0EsaigCADYCACADIAMpAhgiDTcDACADIAMpAiQ3AgwgBSAFKAIEIgxBAWo2AgQgBSgCCCAMQRhsaiIFIA03AgAgBUEIaiAKKQMANwIAIAVBEGogA0EQaikDADcCACADQTBqJAAgBEEYaiEEIAdBAWsiBw0ACwsCQCABKAIIIgUEQCAIKAIEIQMgCCgCACABKAIMIgEgBUcEQCAFQQxqIQcgCCgCCCADQRhsaiEEIAMgASAFa0EYbiIBaiEDIAJBDGohCANAIAJBGGogB0EMaxDdIAJAIAcoAgBBgICAgHhHBEAgAkEkaiAHEN0gDAELIAJBgICAgHg2AiQLIAggAikCJDcCACACQQhqIgUgAkEgaigCADYCACAIQQhqIAJBLGooAgA2AgAgAiACKQIYIg03AwAgBEEQaiACQRBqKQMANwIAIARBCGogBSkDADcCACAEIA03AgAgB0EYaiEHIARBGGohBCABQQFrIgENAAsLIAM2AgAMAQsgCCgCACAIKAIENgIACyACQTBqJAAgCUEQaiQAIABBCGogCygCADYCACAAIAYpAgg3AgAgBkEgaiQAC80BAgJ/An4jAEHwAGsiBCQAIAQgATYCDCAEQRBqIgFBABCVJCAEQUBrIgUgAiABIAMQnBAgBEHYAGogBEEMaiAFIAMQ2goCQCAEKAJYIgJBk4CAgHhHBEAgBCkCXCEGIAQpAmQhByAAQYCAgIB4NgIoIAAgBzcCDCAAIAY3AgQgACACNgIAIAEQ7SYgBEEwahDjPAwBCyAEKAIMIQEgAEEIaiAEQRBqQTD8CgAAIABBADoAPCAAIAE2AjggACADKQEANwMACyAEQfAAaiQAC4AEAQV/IwBBIGsiAyQAAkACQAJAIAEtADxFBEAgA0EMaiEGIAFBOGohBCMAQTBrIgIkAAJAAkACQAJAAkAgAS8BAiIFDgUBAQECAwALIAIgBTsBDiACQQE2AhQgAkGkvswANgIQIAJCATcCHCACQfgCNgIsIAIgAkEoajYCGCACIAJBDmo2AiggAkEQakGsvswAEO8sAAsgAkEANgIgIAJBATYCFCACQeS9zAA2AhAgAkIENwIYIAJBEGpB7L3MABDvLAALIAQoAgAhBUEIIQQgAS0ABEUEQCAFQfy9zABBBBChNkEEIQQLIAJBADYCECAFIAJBEGpBBBChNgwBCyAEKAIAIgRB/L3MAEEEEKE2IAJBADYCECAEIAJBEGpBBBChNkEIIQQLIAZBk4CAgHg2AgAgBiAENgIEIAJBMGokACADKAIMIgJBk4CAgHhGDQEgACADKQIUNwIIIABBEGogA0EcaigCADYCACAAIAMoAhA2AgQgACACNgIADAILIANBDGpBNEEAQQFBARCgGCADKAIQIQEgAygCDEEBRg0CIAMoAhQiAkHKv8wAQTT8CgAAIABBNDYCDCAAIAI2AgggACABNgIEIABBjICAgHg2AgAMAQsgAEGTgICAeDYCACABQQE6ADwLIANBIGokAA8LIAEgAygCFEHsu8wAEP0vAAuvAgEFfyMAQTBrIgIkAAJAAkAgARCPFSIEBEAgBC0AACEFIAJBDGoiBEEIIAEoAiBBAWoiA0F/IAMbIgMgA0EITRtBAEEBQQEQoBggAigCECEDIAIoAgxBAUYNAiACKAIUIgYgBToAACACQQhqIgVBATYCACACIAY2AgQgAiADNgIAIAQgAUEk/AoAACAEEI8VIgEEQANAIAEtAAAhAyACKAIIIgEgAigCAEYEQCACIAEgBCgCIEEBaiIGQX8gBhtBAUEBENAoCyACKAIEIAFqIAM6AAAgAiABQQFqNgIIIAQQjxUiAQ0ACwsgAEEIaiAFKAIANgIAIAAgAikCADcCAAwBCyAAQQA2AgggAEKAgICAEDcCAAsgAkEwaiQADwsgAyACKAIUQZTvzgAQ/S8AC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBAUEBEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAv3AQECfyMAQRBrIgIkAAJAAkAgASgCAEECRwRAIAJBBGpBHkEAQQFBARCgGCACKAIIIQMgAigCBEEBRg0CIAIoAgwiAUEWakGWwc8AKQAANwAAIAFBEGpBkMHPACkAADcAACABQQhqQYjBzwApAAA3AAAgAUGAwc8AKQAANwAAIABBHjYCDCAAIAE2AgggACADNgIEIABBADYCAAwBCyACQQxqIgNBADYCACACQoCAgIDAADcCBCABIAJBBGoQywcgAEEINgIAIABBDGogAygCADYCACAAIAIpAgQ3AgQLIAJBEGokAA8LIAMgAigCDEHko88AEP0vAAvSAQEBfyAAIAFBLPwKAAAgAgRAIAAgASgCACACQQN0ajYCBCAAIAAoAgggABDsH2o2AggLAkAgASgCJEUNACACIAEoAigiBE0gAyAET3FFBEAgAEEANgIkDAELIAAgACgCKCACazYCKAsgACABKAIAIAJBA3RqNgIAIAAgASgCACIEIANBA3RqNgIEIAEoAgQgBGtBA3UgA0cEQCAAIAAoAgggABDsH2o2AgwLIAAgACgCECACajYCECAAIAAoAhQgAmo2AhQgACAAKAIYIAJqNgIYC2MBA38jAEEgayICJAAgAkEUaiABQQFBBEEEEKAYIAIoAhghAyACKAIUQQFHBEAgAigCHCEEIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBIGokAA8LIAMgAigCHEHEqPsAEP0vAAvTAQEHfyMAQYAQayIDJAADQCACIANqQgI3AgAgAkEIaiICQYAQRw0ACwJAAkAgASgCBCICBEAgASgCACEGIAJBAnQhByABKAIIIQggASgCDCEEIAMhAUEAIQIDQCAEIAIgBmooAgAiBUkNAyACQQRqIgJBhAhGDQIgAUEEaiAEIAVrNgIAIAEgCCAFQQJ0ajYCACABQQhqIQEgAiAHRw0ACwsgACADQYAQ/AoAACADQYAQaiQADwtBgAJBgAJB8N/zABDDIQALIAUgBEHg3/MAEK87AAvOAQICfwJ+AkACQAJAAkAgAARAAkBBfyECIACtIgUhBANAIAJBAWohAiAEQv8AViAEQgeIIQQNAAsgAkEKTw0FIABBgAFJDQBBACECIAUhBANAIAJBCkYNBCABIAJqIASnQYABcjoAACACQQFqIQIgBEL//wBWIARCB4giBSEEDQALDAILC0EAIQILIAJBCkkNASACQQpB8LT+ABDDIQALQQpBCkGAtf4AEMMhAAsgASACaiAFPAAAIAJBAWoPC0GstP4AQTRB4LT+ABCfKQAL3QEBA38jAEEgayIEJAACQAJAAkAgAQRAIARBFGogAkEAQQRBBBCgGCAEKAIYIQUgBCgCFEEBRg0CIARBEGoiBkEANgIAIAQgBCgCHDYCDCAEIAU2AgggBEEIaiACIAEQih8gAEEIaiAGKAIANgIAIAAgBCkCCDcCAAwBCyAEQRRqIAJBAUEEQQQQoBggBCgCGCEBIAQoAhRBAUYNAiAEKAIcIQMgACACNgIIIAAgAzYCBCAAIAE2AgALIARBIGokAA8LIAUgBCgCHCADEP0vAAsgASAEKAIcIAMQ/S8AC+QDAgh/An4gASgCAEEBRgRAIAEpAwghCyABKAIQIQYgASgCFCEEIAIoAgghAyACKAIEIQUgAigCACIBEN48IQogASAFIAMQoTYCQCABKAIYBEAgASgCKCIFQQFqIghBA3YgCEEHcUEAR2oiAiABKAIkIgNLBEAgAiADayEJIAEoAhwiByACSQRAIAFBGGogB0EBdCIDIAJBwP///wNxQUBrIAIgAkE/cRsiByADIAdLGxDoGSABKAIkIQMLIAkEQCABKAIgIANqQQAgCfwLAAsgASACNgIkCyABIAg2AiggASgCICAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAQsgASABKAIsQQFqNgIsCyABNQIIIQwgASgCFCICIAEoAgxGBEAgAUEMakHotYABELMoCyABKAIQIAJBA3RqIAw3AwAgASACQQFqNgIUIAYgBCgCACIBaiICLQAAIQMgAiALp0EZdiICOgAAIAEgBCgCBCAGQQhrcWpBCGogAjoAACAAIAQ2AgwgACALNwMAIAQgBCgCDEEBajYCDCAAIAEgBkECdGsiADYCCCAEIAQoAgggA0EBcWs2AgggAEEEayAKNgIADwsgACABQQhqIgEpAwA3AwAgAEEIaiABQQhqKQMANwMAC+QDAgh/AX4gASgCAEEBRgRAIAEpAwghCyABKAIQIQYgASgCFCEEIAIoAgghAyACKAIEIQUgAigCACIBEN48IQogASAFIAMQoTYCQCABKAIYBEAgASgCKCIFQQFqIghBA3YgCEEHcUEAR2oiAiABKAIkIgNLBEAgAiADayEJIAEoAhwiByACSQRAIAFBGGogB0EBdCIDIAJBwP///wNxQUBrIAIgAkE/cRsiByADIAdLGxDoGSABKAIkIQMLIAkEQCABKAIgIANqQQAgCfwLAAsgASACNgIkCyABIAg2AiggASgCICAFQQN2aiICIAItAABBASAFQQdxdHI6AAAMAQsgASABKAIsQQFqNgIsCyABKAIIIQMgASgCFCICIAEoAgxGBEAgAUEMakHotYABEJ0oCyABKAIQIAJBAnRqIAM2AgAgASACQQFqNgIUIAYgBCgCACIBaiICLQAAIQMgAiALp0EZdiICOgAAIAEgBCgCBCAGQQhrcWpBCGogAjoAACAAIAQ2AgwgACALNwMAIAQgBCgCDEEBajYCDCAAIAEgBkECdGsiADYCCCAEIAQoAgggA0EBcWs2AgggAEEEayAKNgIADwsgACABQQhqIgEpAwA3AwAgAEEIaiABQQhqKQMANwMAC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBCEEIEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAvjAQEFfwJAAkACQCABKAIAIgMgAigCACIFKAIEIgJJBEAgAUEEayIGKAIAIgEgAk8NASAFKAIAIgIgA0EDdCIHaikDACACIAFBA3RqKQMAUwRAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgAyAFKAIEIgRPDQUgAkEEayIGKAIAIgEgBE8NBiAFKAIAIgQgB2opAwAgBCABQQN0aikDAFMNAQsLIAIgAzYCAAsPCyADIAJBqL+DARDDIQALIAEgAkG4v4MBEMMhAAsgAyAEQai/gwEQwyEACyABIARBuL+DARDDIQAL4wEBBX8CQAJAAkAgASgCACIDIAIoAgAiBSgCBCICSQRAIAFBBGsiBigCACIBIAJPDQEgBSgCACICIANBAnQiB2ooAgAgAiABQQJ0aigCAEgEQANAAkAgBiICQQRqIAE2AgAgACACRg0AIAMgBSgCBCIETw0FIAJBBGsiBigCACIBIARPDQYgBSgCACIEIAdqKAIAIAQgAUECdGooAgBIDQELCyACIAM2AgALDwsgAyACQai/gwEQwyEACyABIAJBuL+DARDDIQALIAMgBEGov4MBEMMhAAsgASAEQbi/gwEQwyEAC+MBAQV/AkACQAJAIAEoAgAiAyACKAIAIgUoAgQiAkkEQCABQQRrIgYoAgAiASACTw0BIAUoAgAiAiADQQJ0IgdqKAIAIAIgAUECdGooAgBJBEADQAJAIAYiAkEEaiABNgIAIAAgAkYNACADIAUoAgQiBE8NBSACQQRrIgYoAgAiASAETw0GIAUoAgAiBCAHaigCACAEIAFBAnRqKAIASQ0BCwsgAiADNgIACw8LIAMgAkGov4MBEMMhAAsgASACQbi/gwEQwyEACyADIARBqL+DARDDIQALIAEgBEG4v4MBEMMhAAvjAQEFfwJAAkACQCABKAIAIgMgAigCACIFKAIEIgJJBEAgAUEEayIGKAIAIgEgAk8NASAFKAIAIgIgA0EDdCIHaikDACACIAFBA3RqKQMAVARAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgAyAFKAIEIgRPDQUgAkEEayIGKAIAIgEgBE8NBiAFKAIAIgQgB2opAwAgBCABQQN0aikDAFQNAQsLIAIgAzYCAAsPCyADIAJBqL+DARDDIQALIAEgAkG4v4MBEMMhAAsgAyAEQai/gwEQwyEACyABIARBuL+DARDDIQALuwQBCn8jAEFAaiICJAAgAkGTgICAeDYCCCACQThqIAFBEGooAgA2AgAgAkEwaiABQQhqKQIANwMAIAIgASkCADcDKCACIAJBCGo2AjwgAkEcaiEFIwBBMGsiASQAIAEgAkEoaiIDEK4hAkACQAJAIAEoAgAiBwRAIAEoAgQhCCABQRhqIglBBEEAQQRBCBCgGCABKAIcIQQgASgCGEEBRg0CIAEoAiAiBiAINgIEIAYgBzYCACABQRRqIgpBATYCACABIAY2AhAgASAENgIMIAFBKGogA0EQaikCADcDACABQSBqIANBCGopAgA3AwAgASADKQIANwMYIwBBEGsiAyQAIANBCGogCRCuISADKAIIIgYEQCABQQxqIQQgAygCDCEHA0AgBCgCCCIIIAQoAgBGBEAgBEEBEOotCyAEKAIEIAhBA3RqIgsgBzYCBCALIAY2AgAgBCAIQQFqNgIIIAMgCRCuISADKAIEIQcgAygCACIGDQALCyADQRBqJAAgBUEIaiAKKAIANgIAIAUgASkCDDcCAAwBCyAFQQA2AgggBUKAgICAwAA3AgALIAFBMGokAAwBCyAEIAEoAiBBiPmDARD9LwALAkAgAigCCEGTgICAeEcEQCAAIAIpAgg3AgAgAEEQaiACQRhqKAIANgIAIABBCGogAkEQaikCADcCACAFEMMnIAUQ6jsMAQsgACACKQIcNwIEIABBk4CAgHg2AgAgAEEMaiACQSRqKAIANgIACyACQUBrJAAL3gEBCX8jAEEQayICJAAgASgCBCEDIAJBBGogASgCCCIGQQBBBEEIEKAYIAIoAgghBAJAIAIoAgRBAUcEQCACKAIMIQcCQCAERQ0AIAZBA3QhBSAHIQEgBCEIA0AgBUUNASADKAIAIgkgCSgCACIKQQFqNgIAIApBAEgNAyABQQRqIAMoAgQ2AgAgASAJNgIAIAFBCGohASAFQQhrIQUgA0EIaiEDIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAQ2AgAgAkEQaiQADwsgBCACKAIMQcTmhAEQ/S8LAAv6AQECfyMAQaACayICJAAgAkHsAWogAUEIaigCADYCACACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAkEAOwGcAiACQQA2ApgCIAJBADYCgAIgAkEANgL0ASACIAEpAgA3AuQBIAIgASgCFDYC8AEgAkHoAGogAkHEAWogAUEYahDCGUEMQQQQrTYiA0UEQEEEQQwQoz0ACyADIAEpAgw3AgAgA0EIaiABQRRqKAIANgIAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiASACQegAaiACQcQBahCWKSAAIAEQzRwgAkGgAmokAAveAQEJfyMAQRBrIgIkACABKAIEIQMgAkEEaiABKAIIIgZBAEEEQQwQoBggAigCCCEEAkAgAigCBEEBRwRAIAIoAgwhBwJAIARFDQAgBkEMbCEFIAchASAEIQgDQCAFRQ0BIAMoAgAiCSAJKAIAIgpBAWo2AgAgCkEASA0DIAFBBGogAykCBDcCACABIAk2AgAgAUEMaiEBIAVBDGshBSADQQxqIQMgCEEBayIIDQALCyAAIAY2AgggACAHNgIEIAAgBDYCACACQRBqJAAPCyAEIAIoAgxByIqHARD9LwsAC2ABAn8jAEEgayIDJAAgA0EUaiABQQFBBEEEEKAYIAMoAhghBCADKAIUQQFHBEAgAygCHCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBIGokAA8LIAQgAygCHCACEP0vAAvkAQEEfyMAQSBrIgMkACAAKAIAIgAoAgAhBCAAQQA2AgACQCAEQQFxBEAgA0EYaiIEIABBHGopAgA3AwAgA0EQaiIFIABBFGopAgA3AwAgA0EIaiIGIABBDGopAgA3AwAgAyAAKQIENwMAQcwAQQQQrTYiAEUNASAAIAMpAwA3AgAgAEEAOgBIIAAgAjYCJCAAIAE2AiAgAEEYaiAEKQMANwIAIABBEGogBSkDADcCACAAQQhqIAYpAwA3AgAgAEHk3MMAENQaIANBIGokAA8LQebZwwBBMRCXPQALQQRBzAAQoz0AC80BAQl/IAAgACgCBEEYdiIDIAAoAgBBGHYiBUlBAnRqIgIgAEEMQQggAC0ADyAALQALSSIGG2oiBCAAIAMgBU9BAnRqIgMgAEEIQQwgBhtqIgAtAAMgAy0AA0kiBRsgBCgCACIHQRh2IAIoAgAiCEEYdkkiAhsiBi0AAyEJIAAgAyAEIAIbIAUbIgQtAAMhCiABIAcgCCACGzYCACABIAQgBiAJIApLIgIbKAIANgIEIAEgBiAEIAIbKAIANgIIIAEgAyAAIAUbKAIANgIMC+0BAgR/AX4jAEEgayICJAAgAkEMaiABEKURIAIoAhghASACKAIUIQMgAigCECEEAkAgAigCDCIFQQRHBEAgACACKAIcNgIQIAAgATYCDCAAIAM2AgggACAENgIEIAAgBTYCAAwBCyACQQxqIAMgARCdCQJAAkAgAigCDEUEQCABrSEGIAMhAQwBCyACKQIQIQYgBEGAgICAeEcNASADIQQLIAAgBj4CDCAAIAE2AgggACAENgIEIABBBDYCAAwBCyACIAY3AhggAiABNgIUIAIgAzYCECACIAQ2AgwgACACQQxqEMgcCyACQSBqJAAL8gEBAn8gACgCCCICBEAgACgCBCEAA0ACQAJAAkACQAJAAkACQAJAAkAgACgCAA4ICAECAwQFBgcACyAAQQRqEMUqDAcLIABBBGoiARDiKSABQQhBMBDgHgwGCyAAQQRqIgEQ4ykgAUEIQTgQ4B4MBQsgAEEEaiIBEOEpIAFBCEHIABDgHgwECyAAQQRqIgEQ4SkgAUEIQcgAEOAeDAMLIABBBGoiARDjKSABQQhBOBDgHgwCCyAAQQRqIgEQ4SkgAUEIQcgAEOAeDAELIABBBGoiARDbGCABQQhB0AAQ4B4LIABBFGohACACQQFrIgINAAsLC9wBAQN/IwBBEGsiBCQAIAAgAjYCCCAAIAE2AgQCfyAALQBSRQRAQQEgAUEaanQgAmpBfyABQQJqdGohBUEYDAELIARCjICAgMADNwIIIARCgICAgMAANwIAAkAgAUEDTQRAIAQgAUECdGooAgAiAyACTQRAQfz//z8hBSACIANBASABdGpJDQIgAiADa0H8////BWohBQwCCyACIANrQfz//z9qIQUMAQsgAUEEQZSY0gAQwyEAC0E+CyEDIAAgBTYCECAAIAIgAyABQQFqdGpBEGo2AgwgBEEQaiQAC8gBAQR/IwBBEGsiAiQAQQMhAyAALAAAIgQgBMBBB3UiAHMgAGsiAEH/AXEiBUEKTwRAQQEhAyACIABBAXQiACAAQThqIAVB5ABJG0H+AXEiAEHj84kBai0AADoADyACIABB4vOJAWotAAA6AA4gBUHjAEshAAtBACAEIABB/wFxG0UEQCADQQFrIgMgAkENamogAEEBdEH+AXFB4/OJAWotAAA6AAALIAEgBEEATkEBQQAgAkENaiADakEDIANrEIEJIAJBEGokAAvcAQICfwF+IwBBIGsiAyQAIAEoAgwhBCABQYGAgIB4NgIMAkACQCAEQYGAgIB4RwRAIANBGGogAUEYaikCACIFNwIAIAMgBDYCDCADIAEpAhA3AhAgBadBAXFFDQIgACABQQFBAiACGyADLwEaEPoXIANBDGoQhjAMAQsgAkUEQCADQQI6AAwgASgCICADQQxqIANBDWoQvSYgAEEENgIADAELIAEoAiAgA0EBOgAMIANBDGogA0ENahC9JiAAQQQ2AgALIANBIGokAA8LQZDHzgBBIUG0x84AEMskAAvNAQECfyMAQSBrIgQkACAEIAM2AhAgBCACNgIMIARBFGoiAyABEM4GAkBBDEEEEK02IgIEQCACIAQpAhQ3AgAgAkEIaiAEQRxqIgUoAgA2AgAgAyAEQQxqEPMtEM4GQQxBBBCtNiIDRQ0BIAMgBCkCFDcCACADQQhqIAUoAgA2AgAgACADNgIIIAAgAjYCBCAAQSI6AAAgAEEMaiABQTD8CgAAIABBADoARCAAIAQpAgw3AjwgBEEgaiQADwtBBEEMEKM9AAtBBEEMEKM9AAvXAQEEfwJAIAQgAyAEaiIFTQRAIAUgACgCBCIGSw0BIAAoAgAhBiABKAIMIgAgBGoiByABKAIEIghLBEAgASAIQQF0IgAgBxDfKiIHIAAgB0sbEOgZIAEoAgwhAAsgBARAIAEoAgggAGogAyAGaiAE/AoAAAsgASABKAIMIARqNgIMIAEoAigiAARAIAEoAiQhASAAQcwBbCEEA0AgASACIAMgBRDYGyABQcwBaiEBIARBzAFrIgQNAAsLDwsgAyAFQYCohwEQsTsACyAFIAZBgKiHARCwOwALywEBCH8jAEEgayIDJAAgACgCFCIEIAAoAhAiBSAEIAVLGyEGIABBDGohByAAKAIMIQgCfwJAA0BBACACRQ0CGiAEIAZGDQEgACAEQQFqIgU2AhQgAkEBayECIAQgCGohCSABLQAAIAUhBCABQQFqIQEgCS0AAEYNAAsgA0EJNgIUIANBCGogByAEEOoMIANBFGogAygCCCADKAIMEPsoDAELIANBBTYCFCADIAcgBhDqDCADQRRqIAMoAgAgAygCBBD7KAsgA0EgaiQAC9gBAQN/IwBBMGsiAiQAIAIgATYCBAJAIAEuARgiBEEATARAIAJBgYCAgHg2AggMAQsCQCAEQQFHDQAgAS8BGg0AIAEoAhQiA0EIaiADKAIIQQJGQQJ0ai0AICIDQQNHIANBAEdxIQMLIAJBCGogAkEEaiADEJUSCyAAIAE2AqACIABBADYCkAIgAEKAgICAwAA3A4gCIAEuARohASAAQeABaiACQQhqQSj8CgAAIABCAjcDmAIgAEIANwKkAiAAQgU3AwAgACABQQBMQR90NgKUAiACQTBqJAALyQEBBH8jAEEQayIHJAAgBCAFQT9rIARBP2ogBUsbIgYgBEGABGpJIAQgBk9yRQRAIAAoAhBBD2shCCAAKAIUIQkDQCAHQQA2AgggACABIAIgBCADIAlBgAEgCCAHQQhqQQhBABCDBxogBEEIaiIEIAZJDQALCyAFIAZLBEAgACgCEEEPayEEIAAoAhQhCANAIAdBADYCDCAAIAEgAiAGIAMgCEGAASAEIAdBDGpBCEEAEIMHGiAGQQFqIgYgBUkNAAsLIAdBEGokAAvlCAERfyMAQRBrIg0kACANQQRqIAEoAggiAkH07M4AEM4YIAEoAgQhCCANKAIMIQcgDSgCCCEKAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIMIgRBAmsOBwECAwQFBgcACyAIIQYgAiEJIAohCyAHIQVBACEHAkACQCAEIggEQCACIAhuIRAgCEECdiAIQQNxQQBHaiIRRQ0CDAELQaTqzgAQ4isACwNAIAggCU0EQEEBQQQgBCAEQQRPGyICIAJBAU0bIQxBACEOIAchAgNAAkAgByAIRg0AQQAhDyAMIQMgAiEKAkADQCAJIApNDQEgBSAHIA9qIBBsIA5qIhJLBEAgCyASaiAGIApqLQAAOgAAIA9BAWohDyAKQQFqIQogA0EBayIDRQ0DDAELCyASIAVBxOrOABDDIQALIAogCUG06s4AEMMhAAsgAiAIaiECIA5BAWoiDiAQSQ0ACwsgB0EEaiEHIARBBGshBCARQQFrIhENAAsLDAcLQQAhBCACQQJPBEAgCCEJIAJBAXYhCwNAQQEhCCAEIgVBAXQhDCAFQQFqIQRBACEGAkACQANAIAYgDHIiAyACTw0BIAcgBiALbCAFaiIGSwRAIAYgCmogAyAJai0AADoAAEEBIQYgCEEAIQhFDQMMAQsLIAYgB0GU6s4AEMMhAAsgAyACQYTqzgAQwyEACyAEIAtHDQALCwwGC0EAIQQgAiIJQQNPBEAgAkEDbiEGA0AgBSAIaiELIAQiAkEBaiEEQQAhAwJAA0AgAyAFaiIMIAlPDQsgAiAHSQRAIAIgCmogAyALai0AADoAACACIAZqIQIgA0EBaiIDQQNGDQIMAQsLDAkLIAVBA2ohBSAEIAZHDQALCwwFCyAIIAIgCiAHEKAZDAQLQQAhBCACIglBBU8EQCACQQVuIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NCSACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBBUYNAgwBCwsMBwsgBUEFaiEFIAQgBkcNAAsLDAMLQQAhBCACIglBBk8EQCACQQZuIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NCCACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBBkYNAgwBCwsMBgsgBUEGaiEFIAQgBkcNAAsLDAILQQAhBCACIglBB08EQCACQQduIQYDQCAFIAhqIQsgBCICQQFqIQRBACEDAkADQCADIAVqIgwgCU8NByACIAdJBEAgAiAKaiADIAtqLQAAOgAAIAIgBmohAiADQQFqIgNBB0YNAgwBCwsMBQsgBUEHaiEFIAQgBkcNAAsLDAELIAggAiAKIAcQoRkLIAFBADYCCCAAQQRqIA1BBGoQ5xUgAEEINgIAIA1BEGokAA8LIAIgB0GU6s4AEMMhAAsgDCAJQYTqzgAQwyEAC+IBAQJ/IwBBMGsiAyQAIAMgASgCCCIENgIAIAMgAjYCBCACIARNBEACQCACBEAgA0EIaiABQQxqIAEoAgQgBCABKAIAKAIAEQUAIANBEGoiASACNgIAIAAgAykCCDcCACAAQQhqIAEpAgA3AgAMAQsgAEEANgIMIABCATcCBCAAQbTwzgA2AgALIANBMGokAA8LIANBAjYCDCADQbTxzgA2AgggA0ICNwIUIANBiwg2AiwgA0GLCDYCJCADIANBIGo2AhAgAyADNgIoIAMgA0EEajYCICADQQhqQcTxzgAQ7ywAC9YBAQd/IwBBEGsiAiQAIAEoAgQhAyACQQRqIAEoAggiBkEAQQhBGBCgGCACKAIIIQQgAigCBEEBRwRAIAIoAgwhBwJAIARFDQAgBkEYbCEFIAchASAEIQgDQCAFRQ0BIAEgAykDADcDACABQRBqIANBEGopAwA3AwAgAUEIaiADQQhqKQMANwMAIAFBGGohASAFQRhrIQUgA0EYaiEDIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAQ2AgAgAkEQaiQADwsgBCACKAIMQeiZzwAQ/S8AC7kDAgR/AX4jAEEQayIDJAAgAyABNgIEAkADQCADQQhqIQQjAEEQayIBJAAgAUEAOgAHIAFBCGogA0EEaigCACIGIAFBB2pBARDhEgJAAkAgAS0ACCIFQQRGDQADQAJAAkACQAJAAkAgBUEBaw4DAAIBBAsgAS0ACUEjRw0DDAILIAEoAgwtAAhBI0YNAQwCCyABKAIMLQAIQSNHDQELIAFBCGoiBRC5LiAFIAYgAUEHakEBEOESIAEtAAgiBUEERw0BDAILCyAEIAEpAwg3AgAMAQsgASgCDEUEQCAEQQU6AAAMAQsgBCABLQAHOgABIARBBDoAAAsgAUEQaiQAAkACQAJ/AkACQCADLQAIQQRrDgIAAwELIAMtAAkMAQsgAykDCCIHQv8Bg0IEUgRAIAAgBzcCAAwFCyAHQoACg1ANASAHQhCIpwsiBEH/AXENASAAQQQ6AAAMAwsgAEKBygA3AgAMAgsgAigCCCIBQf//A0cEQCACKAIAIAFGBEAgAkGYxdAAEKkZCyACKAIEIAFqIAQ6AAAgAiABQQFqNgIIDAELCyAAQRRBqMXQAEEaEM0aCyADQRBqJAALwAEBCn8gAiABIAEgAkkbIQwgAEEsaiENIAAoAiQiDkEIaiEPIAAoAgQhCCAAKAIoIQkgACgCXCEKA0AgASAMRkUEQCAJAn8gBgRAIA0gCCABIA4gAyAAKQNQEKcoDAELIAEgCGogDyADIAApA1AQ5iMLIgJBCHYgBHQiEGoiC0EAIAUgCy0AAEE/aiAFcSIHGyAHaiIHOgAAIAcgC2ogAjoAACAKIBBBAnRqIAdBAnRqIAE2AgAgAUEBaiEBDAELCwvQAQIBfgF/IAAgAmohBQJAIANFIAAgAWtBD0pyRQRAA0AgACABKQAANwAAIAFBCGohASAAQQhqIgAgBUkNAAwCCwALIAEpAAAhBCAAQQhqIAFBCGopAAA3AAAgACAENwAAIAJBEUgNACABQSBqIQEgAEEQaiEAA0AgAUEQayICKQAAIQQgAEEIaiACQQhqKQAANwAAIAAgBDcAACABKQAAIQQgAEEYaiABQQhqKQAANwAAIABBEGogBDcAACABQSBqIQEgAEEgaiIAIAVJDQALCwvPAgEIfyMAQUBqIgIkACACIAEQ5QsCQAJAIAIoAgAiBQRAIAIoAgQhBiACQRhqIgdBBEEAQQRBCBCgGCACKAIcIQMgAigCGEEBRg0CIAIoAiAiBCAGNgIEIAQgBTYCACACQRRqIghBATYCACACIAQ2AhAgAiADNgIMIAcgAUEo/AoAACACQQxqIQMjAEEQayIBJAAgAUEIaiAHEOULIAEoAggiBARAIAEoAgwhBQNAIAMoAggiBiADKAIARgRAIANBARD/LQsgAygCBCAGQQN0aiIJIAU2AgQgCSAENgIAIAMgBkEBajYCCCABIAcQ5QsgASgCBCEFIAEoAgAiBA0ACwsgAUEQaiQAIABBCGogCCgCADYCACAAIAIpAgw3AgAMAQsgAEEANgIIIABCgICAgMAANwIACyACQUBrJAAPCyADIAIoAiBBuJeAARD9LwAL/gEBAn8jAEEgayIEJAAgBCABKAIAIgUoAgAgASgCBCACIAMgBSgCBCgCDBEHAAJAAkACQAJAIAQoAgBB7f///wdqDgICAAELIABBk4CAgHg2AgAMAgsgACAEKQIANwIAIABBEGogBEEQaigCADYCACAAQQhqIARBCGopAgA3AgAMAQsgBEEUakEMQQBBAUEBEKAYIAQoAhghASAEKAIUQQFGBEAgASAEKAIcQbiHgQEQ/S8ACyAEKAIcIgJBCGpB44mBASgAADYAACACQduJgQEpAAA3AAAgAEEMNgIMIAAgAjYCCCAAIAE2AgQgAEGCgICAeDYCAAsgBEEgaiQAC5EGAQp/IwBBQGoiBCQAIAQgARCSNjYCCCACKAIUIQUgAigCECECIAQgATYCPCAEIAI2AjAgBCACIAVBeHFqNgI0IAQgBEEIajYCOCAEQRxqIQYjAEFAaiICJAAgAkGTgICAeDYCCCACQTBqIARBMGoiAUEIaikCADcDACACIAEpAgA3AyggAiACQQhqNgI4IAJBHGohCCMAQTBrIgEkACABQQxqIAJBKGoiBRDzIAJAAkACQCABKAIMQQFGBEAgASgCFCEKIAEoAhAhCyABQRhqIgxBBEEAQQRBCBCgGCABKAIcIQcgASgCGEEBRg0CIAEoAiAiCSAKNgIEIAkgCzYCACABQQhqIgpBATYCACABIAk2AgQgASAHNgIAIAFBKGogBUEQaigCADYCACABQSBqIAVBCGopAgA3AwAgASAFKQIANwMYIwBBEGsiBSQAIAVBBGogDBDzICAFKAIEQQFGBEADQCAFKAIMIQkgBSgCCCELIAEoAggiByABKAIARgRAIAEgB0EBQQRBCBDeKAsgASgCBCAHQQN0aiINIAk2AgQgDSALNgIAIAEgB0EBajYCCCAFQQRqIAwQ8yAgBSgCBA0ACwsgBUEQaiQAIAhBCGogCigCADYCACAIIAEpAgA3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyABQTBqJAAMAQsgByABKAIgQYj5gwEQ/S8ACwJAIAIoAghBk4CAgHhHBEAgBiACKQIINwIAIAZBEGogAkEYaigCADYCACAGQQhqIAJBEGopAgA3AgAgCBDqOwwBCyAGIAIpAhw3AgQgBkGTgICAeDYCACAGQQxqIAJBJGooAgA2AgALIAJBQGskACAEKAIoIQIgBCgCJCEBIAQoAiAhBQJAIAQoAhwiBkGTgICAeEcEQCAAIAQoAiw2AhQgACACNgIQIAAgATYCDCAAIAU2AgggACAGNgIEIABBKToAAAwBCyAEIAU2AhQgBCABNgIMIAQgATYCECAEIAEgAkEDdGo2AhggACAEQQxqIAMQugYLIARBQGskAAvUAQEIfyMAQUBqIgIkACACQTRqIAFBDGoQ1wYgASgCGCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIgIQYgASgCHCEHIAEoAiQiAwRAIAMgAygCACIEQQFqNgIAIARBAEgNASABKAIoIQggASgCLCEECyACQQRqIgkgARDhFCACQRhqIAJBPGooAgA2AgAgAiAENgIwIAIgCDYCLCACIAM2AiggAiAGNgIkIAIgBzYCICACIAU2AhwgAiACKQI0NwIQIAAgCRDtDSACQUBrJAAPCwAL3wECAn8EfiMAQTBrIgIkACACQRBqQdSthgEoAgA2AgAgAkHMrYYBKQIANwMIAkACQCABIAFCwIQ9fyIBQsCEPX59IgRCP4ciBSABfCIBIAFCgKMFfyIBQoCjBX59IgZCP4ciByABfKdBu/IrahDzFiIDBEAgAiADNgIkIAIgB0KAowWDIAZ8PgIoIAIgBULAhD2DIAR8p0HoB2w2AiwgAkEYaiACQSRqEMovIAIoAhgiAw0BCyAAQQA2AgAMAQsgACACKQIcNwIEIAAgAzYCAAsgAkEIahDJDCACQTBqJAAL6QEBAX8jAEEQayIWJAAgACgCACABQQ0gACgCBCgCDBEGACEBIBZBADoADSAWIAE6AAwgFiAANgIIIBZBCGogAiADIAQgBRCIEiAGIAcgCCAJEIgSIAogCyAMIA0QiBIgDiAPIBAgERCIEiASIBMgFCAVEIgSIQEgFi0ADSICIBYtAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIBZBEGokACAAQQFxC9IBAQF/IAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQlxULAkAgACgCQCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQUBrENseCwJAIAAoAgBFBEAgACgCECIBQYQBSQ0BIAEQ8h8MAQsgAEEQahDeOyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEJ0nCyAAQTBqEJ4vAkAgACgCRCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQcQAahCBLAsLxQEBAX4gACkDACIBQgdSBEAgAUIGUQRAIABBCGoQkSoPCwJAAkACQAJAQQEgAadBAmsgAUIBWBsOAwECAwALIABBCGoQ6TsgAEEUahDpOyAAQThqIAAoAjAgACgCNCAAKAIsKAIQEQEAIABBIGoQ3jsPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKiAAKAJAQYAgQQQQ+DoPCyAAQQhqEOk7IABBIGogACgCGCAAKAIcIAAoAhQoAhARAQALC/QBAQZ/AkAgB0ECcUUEQCAAIAEgAkEBEO0gIQEMAQsgBEHsBWshCyADQewFaiEMQX4hCiAAIQEgBiEHIAJBAWohCQNAIAkEQCAJQQFrIQkgCCAHKAIAQQBHaiEIIAdBBGohBwwBCwtBICAIZ2siCSEHA0AgACAHSQ0BAkAgBSAGIAIgByADIAQQ+AEiCEGIf0sNACAHIAhLIAcgCUtxDQIgDCALIAUgAiAIIAMgBBCkCSIIQYh/Sw0AIAUgBiACEOUjIAhqIgggCkEBaksNAiAHIAEgCCAKSSINGyEBIAggCiANGyEKCyAHQQFqIQcMAAsACyABC/MKAQ1/IAVBACAGQQdLG0UEQEFgQQAgB0ECRhsPCyAAQoSAgICAATcC7CMgAEKAgICAEDcC5CMgAEIANwLcIyAAQQA2AoQIAkAgB0EBRg0AAkACQCAFKAAAQbfIwuF+Rg0AQWAhEwJAIAcOAwABAgELDAILQQAhEyAEKAIoRQRAIAUoAAQhEwsjAEHAAWsiDSQAIABBATYChAggDUEfNgJ8IA1B/wE2AhAgDUEBNgKAASANQRBqIRUgDUGAAWohByMAQZADayIMJAAgDEEANgJMIAxBADYCSCMAQfAGayICJAAgDEGQAWogDEHQAGogDEHIAGogDEHMAGogBUEIaiIWIAZBCGsgAhDxDCERIAJB8AZqJAACQCARQYh/Sw0AIAcgDCgCUEEARzYCACAMKAJMIg5BDEsEQEFUIREMAQsgDCgCSCIHIBUoAgBBAWpLBEBBUCERDAELIABBBGohECAAIA42AgAgDkEBaiEXIAxB0ABqQQRyIQIgDiELQQEhEgNAIAsEQCACKAIAIAIgDzYCACACQQRqIQIgC0EBayELIBJBAWt0IA9qIQ8gEkEBaiESDAEFIA5BAWohEiAMQZABaiELIBAhDyAHIQIDQCACBEAgDyASIAstAAAiFGtBACAUG0H/AXE2AgAgD0EEaiEPIAtBAWohCyACQQFrIQIMAQsLIAxBOGpBADYCACAMQTBqQgA3AwAgDEIANwMoIAxCADcDICAMQRhqQQA2AgAgDEEQakIANwMAIAxCADcDCCAMQgA3AwAgECELIAchAgNAIAIEQCAMQSBqIAstAABBAXRqIg8gDy8BAEEBajsBACALQQRqIQsgAkEBayECDAELC0EAIQsgDCAXQQF0akEAOwEAIA5BAXQhAgNAIA4EQCACIAxqIAs7AQAgDkEBayEOIAxBIGogAmovAQAgC2pB/v8DcUEBdiELIAJBAmshAgwBBSAHIQIDQCACBEAgDCAQKAIAIg5B/wFxIgtBAXRqIg8gDy8BACIPQQFqOwEAIAsEQCAQIA9BICALa3QgDnI2AgALIBBBBGohECACQQFrIQIMAQsLIBUgB0EBazYCAAsLCwsLIAxBkANqJAAgESELIA0oAoABRQRAIABBAjYChAgLQWIhAgJAIAtBiX9JIA0oAhBB/gFLcSIORQ0AIA1BgAFqIhAgDUH8AGogDUEQaiIHIBYgC0EAIA4baiIOIAUgBmoiCyAOaxCCNyIPQYh/Sw0AIA0oAhAiEUEJTw0AIABBiAhqIBBBHyARIApBgMQAEMgHQYh/Sw0AIA1BNDYCDCAHIA1BDGoiESANQQhqIgwgDiAPaiIOIAsgDmsQgjciD0GIf0sNACANKAIIIhJBCUsNACAAQYwOaiAHIA0oAgwgEiAKQYDEABDIB0GJf08NACAAIAcgDSgCDEE0EPEoNgLgIyANQSM2AgwgByARIAwgDiAPaiIOIAsgDmsQgjciD0GIf0sNACANKAIIIhFBCUsNACAAQbgZaiAHIA0oAgwgESAKQYDEABDIB0GJf08NACAAIAcgDSgCDEEjEPEoNgLkIyAOIA9qIgdBDGoiCiALSw0AIAAgBygAADYC6CMgACAHKAAENgLsIyAAIAcoAAg2AvAjIAAgECANKAJ8QR8gCyAKayILQYCACGpnQR9zIAtBgIB4TxsQ8Sg2AtwjIABB6CNqIRBBACEAA0AgAEEEaiIHQRBHBEAgACAQaiAHIQAoAgBBAWsgC0kNAQwCCwsgCiAFayECCyANQcABaiQAIAIiAEGIf0sEQCAADwsgAUEAIAMgBCAAIAVqIAYgAGsgCCAJENkMCyATDwsgASACIAMgBCAFIAYgCCAJENkMQQALyQEBAX8jAEEQayIKJAAgCiACNgIMIAkgCkEMaiABIAMgCUHYxQAQ+ScaQQAhAgJ/AkACQAJ/AkACQCAADgIAAwELIAooAgwiACAISw0DIAYgByAJIAAQhCAMAQsgAEF+cUECRw0BIAQgCSAKKAIMEO4VCyICQYh/Sw0BCyABIANqIQADQCAAIAFNRQRAIAEhCSAFBEAgBSABLQAAaiEJCyABQQFqIQEgAiAJLQAAaiECDAELCyACQQN2DAELIANBCmwLIApBEGokAAvLAQICfwJ9IwBBkAhrIgUkAEEBIQQCQCADsyACsyIGQ0jhej+UXUUEQCAFQRBqQQBBgAj8CwAgAgRAQQAhBANAIAEgBE0NAyAFQRBqIAAgBGotAABBAnRqIgMgAygCAEEBajYCACAEQStqIgQgAkkNAAsLIAVBCGogBUEQakGAAkGAAhCBESAGQwAAAEGUQ0jhej+UQwAALEKVIAUoAgyzIgYgBSoCCCIHIAYgB14bXiEECyAFQZAIaiQAIAQPCyAEIAFBmIjSABDDIQAL5QEBAX8jAEHQAGsiAyQAAkAgASgCAARAIABBk4CAgHg2AgAgACABKQIANwIEIABBDGogAUEIaikCADcCAAwBCyADQR82AiQgA0HuxIABNgIgIANBAjYCLCADQczEgAE2AiggA0ICNwI0IAIoAgAhASADQcwBNgJMIANBzAE2AkQgAyABNgJAIAMgA0FAazYCMCADIANBIGo2AkggA0EQaiADQShqEJkOIANBhICAgHg2AgwgAEEQaiADQRxqKAIANgIAIABBCGogA0EUaikCADcCACAAIAMpAgw3AgALIANB0ABqJAAL1gEBBH8gACgCACICIAAoAgRGBEBBAA8LIAAgAkEIajYCACACKAIAIAIoAgQQkSIiAhC/OiEBIAAoAggiAyABIAMoAgBqNgIAIAIQwTohASAAKAIMIgMgAy0AACABQQBHcjoAAAJAIAIoAhwiA0EITwRAQQEhASACKAIYIgQpAwBCAFcEQCAEIANBeHFqQQhrIgFFDQIgASgCACEBIAJBDGoQ9C0gAUshAQsgACgCECIAIAEgAC0AAHI6AAAgAg8LQQBBAEHst4IBEMMhAAtB/LeCARCyOwALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCaFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahC9FSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCbFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQALxAEBBn8jAEGgAmsiAiQAIAJB6ABqIgQgAUEMahCcFSACQcQBaiIFIAQQoRsgBCAFIAEQjBhBxABBBBCtNiIDBEAgAyABKAI8IgYgASgCQCIHKAIIQQFrQXhxakEIaiAHKAIUEQAAIAJBATYCzAEgAiADNgLIASACQQE2AsQBIAJBDGoiAyAEIAUQ/CIgACADEM0cIAYgBigCACIAQQFrNgIAIABBAUYEQCABQTxqELsjCyACQaACaiQADwtBBEHEABCjPQAL8wEBAn8jAEGgAmsiAiQAIAJB4AFqIAFBCGooAgA2AgAgAkIENwLQASACQgA3AsgBIAJCgICAgMAANwLAASACQQA2ArgBIAJBADsBkAIgAkEANgKMAiACQQA2AvQBIAJBADYC6AEgAiABKQIANwLYASACIAEoAjA2AuQBQQxBBBCtNiIDRQRAQQRBDBCjPQALIAMgASkCDDcCACADQQhqIAFBFGooAgA2AgAgAkEBNgKcAiACIAM2ApgCIAJBATYClAIgAkHcAGoiAyACQbgBaiACQZQCahCWKSACIAMgAUEYahDCGSAAIAIQzRwgAkGgAmokAAuVAgEFfyAABEAgACgCOCICKAIYIgEEQCACKAIUIQMgAUECdCEBA0AgAygCACIEKAI0IgUEQCAEIAURAwALIANBBGohAyAEQcAAQQgQ+DogAUEEayIBDQALCyACKAIcIgMEQCADKAI0IgEEQCADIAERAwALIANBwABBCBD4OgsgAEEANgI0IAIoAggiAwRAIAIoAgQhAANAAkAgACgCACIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAEPseCyAAQQxqIQAgA0EBayIDDQALCyACQQRBDBDgHiACKAIQIgAEQCACKAIMIABBAnRBBBD4OgsgAigCGCIABEAgAigCFCAAQQJ0QQQQ+DoLIAJBIEEEEPg6CwvbAQEDfyMAQUBqIgQkACAEIAM2AgwgBCACNgIIAkAgASgCCEF/IAIgA2oiBSACIAVLG08EQCABKAIEIQUgASgCACIBIAEoAgAiBkEBajYCACAGQQBIDQEgACADNgIIIAAgATYCACAAIAIgBWo2AgQgBEFAayQADwsgBEEDNgIUIARBsP6HATYCECAEQgM3AhwgBEE7NgI8IAQgAUEIajYCOCAEQTs2AjQgBEE7NgIsIAQgBEEoajYCGCAEIARBDGo2AjAgBCAEQQhqNgIoIARBEGpByP6HARDvLAsAC+ABAQR/IwBBIGsiAiQAIAEoAgQhBAJAAn8gASgCCCIFIAEoAgAiA0cEQEEMQQQQrTYiAUUNAiABQQE2AgggASADNgIEIAEgBDYCAEGAiIgBDAELIAIgAzYCHCACIAQ2AhggAiADNgIUIAJBCGogAkEUakGoh4gBEJAhIAIoAggiA0EBIAIoAgwiBRshBCADQQFyQQAgBRshAUHMh4gBQbiHiAEgA0EBcRtB0IWIASAFGwshAyAAIAE2AgwgACAFNgIIIAAgBDYCBCAAIAM2AgAgAkEgaiQADwtBBEEMEKM9AAvTAQEEfyMAQSBrIgMkACADQQRqIAEoAghBkJ7DABCtFSACKAIIIQQgAigCBCEBIAMgAigCADYCGCADIAE2AhQgAyABNgIQIAMgASAEQQJ0IgJqNgIcAkAgBARAIAMoAgghBiADKAIMIQUDQCADIAFBBGoiBDYCFCABKAIAIgEgBU8NAiABIAZqQQE6AAAgBCEBIAJBBGsiAg0ACwsgA0EQahChLCAAIAMpAgQ3AgAgAEEIaiADQQxqKAIANgIAIANBIGokAA8LIAEgBUGgnsMAEMMhAAv4AQECfyMAQRBrIgIkACAAQQRqIQMCfwJAAkACQAJAAkACQCAAKAIAQQFrDgUBAgMEBQALIAIgAzYCDCABQdGbwwBBCiACQQxqQbCewwAQ0BMMBQsgAiADNgIMIAFB0J7DAEEMIAJBDGpBwJ7DABDQEwwECyACIAM2AgwgAUHcnsMAQQ0gAkEMakG0m8MAENATDAMLIAIgAzYCDCABQfyewwBBCSACQQxqQeyewwAQ0BMMAgsgAiADNgIMIAFBhZ/DAEEUIAJBDGpBtJvDABDQEwwBCyACIAM2AgwgAUGsn8MAQQ8gAkEMakGcn8MAENATCyACQRBqJAAL2gEBAn8jAEEQayIGJAACQAJAIAIgA0YNAAJAIAIgAiADayIHTQRAIANFDQEMAwsgASAHaiwAAEG/f0wNAgsgBEH/AXFBAkcEQCAGQYyPxAA2AgwgBiAHNgIIIAYgATYCBCAAIAZBBGoQrx4MAQsgBUH/AXFBAkYEQCAGQZyPxAA2AgwgBiAHNgIIIAYgATYCBCAAIAZBBGoQrx4MAQsgBkGsj8QANgIMIAYgBzYCCCAGIAE2AgQgACAGQQRqEK8eCyAGQRBqJAAPCyABIAJBACAHQfyOxAAQozYAC74BAgR/An4jAEEQayIGJAAgAwRAIAFBCGohByABKQMAIQggAS0AFCEEA0AgASAEQQFqIgU6ABQgASACMQAAIgkgBK2GIAiEIgg3AwAgBUH/AXFBwABJBH8gBQUgBiAINwMIIAcgBkEIakEIEKE2IAEgBEE/ayIFOgAUIAEgCUHAACAEayIErYhCACAEQf8BcUHAAEkbIgg3AwAgBQshBCACQQFqIQIgA0EBayIDDQALCyAAQQg2AgAgBkEQaiQAC7IBAQF/IwBBEGsiAyQAIANBBGogACgCDCIAQQhqIAAoAghBAkZBAnRqIgAQiRkCfwJAIAMtAARBCEcNACADLQAGDQAgASgCACIAQR91rUIghiAArYQgAigCACIAQR91rUIghiAArYRWDAELIAAtACFBHHFBDEYEQCABKAIAIgBBH3WtQiCGIACthCACKAIAIgBBH3WtQiCGIACthFYMAQsgASgCACACKAIASgsgA0EQaiQAC9MBAQR/IwBBEGsiAyQAIAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ3xgLAkAgACgCOCIBRQ0AIAAoAjwiBCgCACICBEAgASACEQMACyAEKAIEIgJFDQAgASACIAQoAggQ+DoLAkAgACkDAEICUQRAIAAoAhgiAEUNASAAKQMAQgNSBEAgABDxKwsgACkDaEIDUgRAIABB6ABqEPErCyAAQYgCQQgQ+DoMAQsgAyAAQSBqIgEgACgCLBD4GCABQQhBGBDgHgsgA0EQaiQAC7IBAQl/QX8hBwJAIAIgAC8AAksNAEEBIAAvAAAiA3QhCCADQQh0QYACaiEJQQEgA0EBa3RBASADG0ECdCAAakEIaiEFQQAhAANAIAAgAk0EQCABKAIAIgoEQCAFKAIAIgZBEHZBAWoiC0EIdCALQRh0IAYgCGpBCHRrIAN2ayIGIAlPDQMgBiAKbCAEaiEECyABQQRqIQEgBUEIaiEFIABBAWohAAwBCwsgBEEIdiEHCyAHC8oBAQF/IwBBIGsiByQAAkACfyAFBEAgBkH/AXFBDHQgA0EPcUEIdHIgBHIhBEEQDAELIANB/wFxQQ10CyAEQQV0ciIDIAJNBEAgAiADa0EPTQ0BIABBEDYCBCAAIAEgA0EBdGo2AgAgB0EgaiQADwsgB0EANgIYIAdBATYCDCAHQdSd4gA2AgggB0IENwIQIAdBCGpBzIbzABDvLAALIAdBADYCGCAHQQE2AgwgB0HUneIANgIIIAdCBDcCECAHQQhqQdyG8wAQ7ywAC9kBAQV/IwBBIGsiASQAIAAtABghAiABIAApAxA3AwACQAJAIAJBA3YgAkEHcUEAR2oiAkEJSQRAIAAoAgQiBCAAKAIMIgUgACgCCGoiA2sgAkkNASADIARLDQIgAgRAIAAoAgAgA2ogASAC/AoAAAsgAEEAOgAYIAAgAiAFajYCDCAAQgA3AxAgAUEgaiQADwsgAkEIQazc+wAQsDsACyABQQA2AhggAUEBNgIMIAFBrML7ADYCCCABQgQ3AhAgAUEIakG83PsAEO8sAAsgAyAEQbzc+wAQrzsAC9wBAQN/IwBBQGoiAyQAIAMgAjYCCAJAIAEoAgwiAgRAIAEoAgAgASgCBCABKAIIIgQQuikhBSABIAJBAWs2AgwgASAEQRBqNgIIIAAgBTYCBCAAQZOAgIB4NgIADAELIANBAjYCJCADQbDf/gA2AiAgA0IBNwIsIANB0gs2AjwgAyADQThqNgIoIAMgA0EIajYCOCADQRBqIANBIGoQmQ4gA0GFgICAeDYCDCAAIAMpAgw3AgAgAEEIaiADQRRqKQIANwIAIABBEGogA0EcaigCADYCAAsgA0FAayQAC94BAQJ/IwBBQGoiBCQAIAQgAzYCCCAEIAI2AgQgBCABKAIIIgU2AgwCQCAFQf////8BSw0AIAVBA3RBfyACIANqIgUgAiAFSxtPDQAgBEEENgIUIARB5ICIATYCECAEQgM3AhwgBEE7NgI8IARBOzYCNCAEQTs2AiwgBCAEQShqNgIYIAQgBEEMajYCOCAEIARBCGo2AjAgBCAEQQRqNgIoIARBEGpBhIGIARDvLAALIAAgAzYCECAAIAI2AgwgACABKQIANwIAIABBCGogAUEIaigCADYCACAEQUBrJAALwgEBBX8jAEFAaiICJAACQCABBEAgAkEoaiEDA0AgAkEIaiAAEPcUIAIoAghBCUYNAiADIAIpAwg3AwAgA0EQaiACQRhqKQMANwMAIANBCGogAkEQaikDADcDACACIAE2AiACQCACKAIoQQhGBEAgAigCLCEFIAIoAjAiBigCACIEBEAgBSAEEQMACyAGKAIEIgRFDQEgBSAEIAYoAggQ+DoMAQsgAxDJIwsgAUEBayIBDQALC0EAIQELIAJBQGskACABC8MEAgV/An4jAEGgAWsiAyQAIANBOGohBCMAQaACayICJAAgASgCACIFIAUoAgAiBkEBajYCAAJAIAZBAE4EQCACIAU2AgggAkEgOgAEIAIgASgCBDYCDCACQbgBaiACQQRqELEBAkAgAigCuAFBAUYEQCACQZABaiACQcwBaigCACIBNgIAIAJBiAFqIAJBxAFqKQIAIgc3AwAgAiACKQK8ASIINwOAASAEQRRqIAE2AgAgBEEMaiAHNwIAIAQgCDcCBCAEQQE2AgAMAQsgAkGEAWohBSAFIAJBwAFqQTD8CgAAIAJB8AFqIgYgBUEw/AoAACACQcgAaiAGIAFBCGoQ6AggAigCSEEBRgRAIAJBIGogAkHcAGooAgAiATYCACACQRhqIAJB1ABqKQIAIgc3AwAgAiACKQJMIgg3AxAgBEEUaiABNgIAIARBDGogBzcCACAEIAg3AgQgBEEBNgIADAELIAJBFGohASABIAJB0ABqQTD8CgAAIARBCGogAUEw/AoAACAEQQA2AgALIAJBBGoQ0AwgAkGgAmokAAwBCwALAkACQCADKAI4QQFGBEAgA0EQaiADQcwAaigCADYCACADQQhqIANBxABqKQIANwMAIAMgAykCPDcDACAAIAMQyiYMAQsgA0EEaiIBIANBQGtBMPwKAAAgA0HwAGoiAiABQTD8CgAAQTBBCBCtNiIBRQ0BIAEgAkEw/AoAACAAQYGAgIB4NgIAIAAgATYCBAsgA0GgAWokAA8LQQhBMBCjPQALzwECAn4EfyAAKAJAIgNBCGohBCADKQMAQn+FQoCBgoSIkKDAgH+DIQIgACgCTCEFIAAtACohBgJ/AkADQCAFBEAgBUEBayEFIAIiAVAEQANAIANBgARrIQMgBCkDACAEQQhqIQRCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAFCAX0gAYMhAiADIAF6p0EDdEHAB3FrQQZrLQAAQQJHDQEMAgsLIAZBAkYNACAALQCWAQwBC0EAC0EBcQvRAQEFfyAAKAIEIQEgACgCACEDIABChICAgMAANwIAIAAoAhAhAgJAAkACQCABIANHBEAgAg0BDAMLIAJFDQIgACgCDCIDIAAoAggiACgCCCIBRg0BIAJBAnQiBEUNASAAKAIEIgUgAUECdGogBSADQQJ0aiAE/AoAAAwBCwJAIAAoAgwiAyAAKAIIIgAoAggiAUYNACACQQJ0IgRFDQAgACgCBCIFIAFBAnRqIAUgA0ECdGogBPwKAAALIAAgASACajYCCA8LIAAgASACajYCCAsLswEBAX8jAEFAaiIFJAAgAkJ/UQRAQn8gATQCOCICIAJCAFcbIQILIAVBJGogASgCLCACIAMgBBCAESABKAJUQQFGBEAgBUEbNgIkCyAFQSRqIAFBBGoQxBwgASgChAEhASAFQSBqIAVBPGooAgA2AgAgBUEYaiAFQTRqKQIANwMAIAVBEGogBUEsaikCADcDACAFIAUpAiQ3AwggACAFQQhqIAIgAyAEIAEQ6gsgBUFAayQAC7IBAQF/IAAoAhghBAJAAkBBACACIAMbDQBBACECIARBAUYNASABQQFHDQAgBEEDa0EDSQ0BC0EEIAAoAgR0IQILQcCOCUGAASAEQQZLG0GAASADGyACakEEIAAoAggiAnRqQQEgAnRBP2pBQHFBACAEQQZrQX1PG0EAIAFBAUYbakEEAn9BACADRQ0AGkEAIAAoAhBBA0cNABpBESAAKAIAIgAgAEERTxsLIgJ0QQAgAhtqC9IBAQR/IAAoAgAiASAAKAIERgRAQQAPCyAAIAFBCGo2AgAgASgCACABKAIEEJAiIgEQwDohAiAAKAIIIgMgAiADKAIAajYCACABEME6IQIgACgCDCIDIAMtAAAgAkEAR3I6AAACQCABKAIcIgNBBE8EQEEBIQIgASgCGCIEKAIAQQBMBEAgBCADQXxxakEEayICRQ0CIAIoAgAgAUEMahD0LUkhAgsgACgCECIAIAIgAC0AAHI6AAAgAQ8LQQBBAEHst4IBEMMhAAtB/LeCARCyOwAL2QEBBX8gAEEMaiIGIAAoAhQgACgCKEEBQQFB0LGDARDDKAJAAkACQAJAIAEgAkcEQANAIAEoAgAiBCAAKAIcIgNPDQIgAUEEaigCACIFIANPDQMgACgCGCIHIAVBAnRqKAIAIgMgByAEQQJ0aigCACIESQ0EIAMgACgCJCIFSw0FIAYgACgCICAEaiADIARrEKE2IAFBCGoiASACRw0ACwsPCyAEIANBnLCDARDDIQALIAUgA0GcsIMBEMMhAAsgBCADQeCxgwEQsTsACyADIAVB4LGDARCwOwAL2QEBBX8gAEEkaiIGIAAoAiwgACgCAEEBQQFB0LGDARDDKAJAAkACQAJAIAEgAkcEQANAIAEoAgAiBCAAKAIMIgNPDQIgAUEEaigCACIFIANPDQMgACgCCCIHIAVBA3RqKAIAIgMgByAEQQN0aigCACIESQ0EIAAoAhQiBSADSQ0FIAYgACgCECAEaiADIARrEKE2IAFBCGoiASACRw0ACwsPCyAEIANBnLCDARDDIQALIAUgA0GcsIMBEMMhAAsgBCADQeCxgwEQsTsACyADIAVB4LGDARCwOwALygEBA38jAEHgAmsiAiQAAkAgAS0ANEEnRgRAIAEoAjgiAyADKAIAIgRBAWo2AgAgBEEASA0BIAJBGzoADCACIAM2AhAgAkH8AWoiAyABQeQA/AoAACACQfQAaiIBIAMQ9hEgAyABEKEbIAJBGGoiASADIAJBDGoQjBggAkG4AWoiAyABEM0cIAAgAxCvHyACQeACaiQADwsgAkEANgKMAiACQQE2AoACIAJB3OKFATYC/AEgAkIENwKEAiACQfwBakHk4oUBEO8sCwAL4AECAn8EfiMAQTBrIgIkACACQRBqQYythgEoAgA2AgAgAkGErYYBKQIANwMIAkACQCABIAFCgJTr3AN/IgFCgJTr3AN+fSIEQj+HIgUgAXwiASABQoCjBX8iAUKAowV+fSIGQj+HIgcgAXynQbvyK2oQ8xYiAwRAIAIgAzYCJCACIAVCgJTr3AODIAR8PgIsIAIgB0KAowWDIAZ8PgIoIAJBGGogAkEkahDKLyACKAIYIgMNAQsgAEEANgIADAELIAAgAikCHDcCBCAAIAM2AgALIAJBCGoQyQwgAkEwaiQAC80CAQJ/IwBBMGsiAiQAAkACQCABRQRAIwBBQGoiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQTj8CgAAIANBADYCAAJAIANBf0YNACAAQQRrIgAgACgCAEEBayIANgIAIAANACADQcAAQQgQ+DoLIAIgAUEQakEw/AoAACABQUBrJAAMAgsQmD0AC0HE98IAQT8Qlz0ACyACEPslIAIoAiAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAJBIGoQlxULIAIoAiQiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAJBJGoQ+CMLIAIoAigiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEoahDbHgwBCyAARQ0BIAIgAEEIayIANgIAIAAgACgCAEEBayIANgIAIAANACACEMoUCyACQTBqJAAPCxCYPQALsgcCDH8BfiMAQRBrIggkACACKAIAIQkgAigCBCIEIAIoAgwiA2siBgRAIAMgCWpBACAG/AsACyACIAQ2AgwgCEEIaiEKIAkgAigCCCIMaiEOIAQgDGshCyMAQRBrIgUkACABIgZBCGohDSABQRBqIQkgAUEEaiEBIAVBDGohBAJAAkADQAJAIAYoAgAiA0EBRgRAIAEoAgAhBwwBCyAGKAIYIgcgBigCIEYEf0EABSAGIAdBEGo2AhggBUEIaiAHQQxqKAIANgIAIAUgBykCBDcDACAHKAIACyEHAkAgA0UNACABKAIAIgNFDQAgCSAGKAIIIAYoAgwgAygCEBEBAAsgBiAHNgIEIAZBATYCACANIAUpAwA3AgAgDUEIaiAFQQhqKAIANgIACyAHBEAgBigCDCIDDQIgBkEANgIAIAVBCGogAUEIaikCADcDACAFIAEpAgAiDzcDACAPpyIDRQ0BIAQgBSgCBCAFKAIIIAMoAhARAQAMAQsLIApBBDoAACAKQQA2AgQMAQsjAEEwayIEJAAgBCALIAMgAyALSxsiAzYCAAJAAkAgASgCCCIGIANHBEAgAw0BIAVCADcCCCAFQdCFiAE2AgAgBSABKAIENgIEDAILIAEpAgAhDyABQdCFiAE2AgAgBSAPNwIAIAFBCGoiBikCACEPIAZCADcCACAFQQhqIA83AgAgASABKAIEIANqNgIEDAELIAMgBk0EQCAEQQRqIAFBDGogASgCBCAGIAEoAgAoAgARBQAgBEEMaiIGIAM2AgAgBSAEKQIENwIAIAEgASgCCCADazYCCCABIAEoAgQgA2o2AgQgBUEIaiAGKQIANwIADAELIAQgBjYCHCAEQQI2AgggBEGIh4gBNgIEIARCAjcCECAEQasdNgIsIARBqx02AiQgBCAEQSBqNgIMIAQgBEEcajYCKCAEIAQ2AiAgBEEEakGYh4gBEO8sAAsgBEEwaiQAIAUoAggiASADRgRAIAUoAgQhASADBEAgDiABIAP8CgAACyAKQQQ6AAAgCiADNgIEIAVBDGogASADIAUoAgAoAhARAQAMAQsgAyABQYjpzwAQszsACyAFQRBqJAACQAJAIAgtAAhBBEcEQCAAIAgpAwgiD0IgiD4CBCAAIA88AAAgAEEDaiAPpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyALIAgoAgwiAUkNASAAQQQ6AAAgAiABIAxqNgIICyAIQRBqJAAPC0GQzMMAQTZByMzDABCfKQAL1AEBBn8jAEEQayIEJAAgASgCDCIFIAUoAgAiA0EBajYCAAJAAkAgA0EASA0AIAEoAhAiBiAGKAIAIgNBAWo2AgAgA0EASA0AIARBBGogARCJHSAEKAIMIQcgBCgCCCEDIAQoAgQhCEEcQQQQrTYiAUUNASABIAI2AhggASAGNgIUIAEgCDYCDCABIAM2AgggASADNgIEIAEgBTYCACAAQZDPwwA2AgggACABNgIEIABBCDYCACABIAMgB0ECdGo2AhAgBEEQaiQADwsAC0EEQRwQoz0AC7wBAQZ/IAEgBU8EQCADQQhPBEAgA0EDdiEIIAAgBWohCSABIAVrIQdBACEAA0AgAiAGaiEKIAAiBUEBaiEAQQAhAQJAAkADQCAFIAdPDQEgAyABIAZqIgtLBEAgASAKaiAFIAlqLQAAOgAAIAQgBWohBSABQQFqIgFBCEYNAwwBCwsgCyADQbj2zAAQwyEACyAFIAdBqPbMABDDIQALIAZBCGohBiAAIAhHDQALCw8LIAUgAUGY9swAEK87AAu8AQEGfyABIAVPBEAgA0EETwRAIANBAnYhCCAAIAVqIQkgASAFayEHQQAhAANAIAIgBmohCiAAIgVBAWohAEEAIQECQAJAA0AgBSAHTw0BIAMgASAGaiILSwRAIAEgCmogBSAJai0AADoAACAEIAVqIQUgAUEBaiIBQQRGDQMMAQsLIAsgA0G49swAEMMhAAsgBSAHQaj2zAAQwyEACyAGQQRqIQYgACAIRw0ACwsPCyAFIAFBmPbMABCvOwAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQpwcCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQnQsCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQAL0AECBX8BfiMAQRBrIgQkACACKAIAIQMgAigCBCIFIAIoAgwiBmsiBwRAIAMgBmpBACAH/AsACyACIAU2AgwgBEEIaiABIAMgAigCCCIBaiAFIAFrIgMQ0goCQAJAIAQtAAhBBEcEQCAAIAQpAwgiCEIgiD4CBCAAIAg8AAAgAEEDaiAIpyIBQRh2OgAAIAAgAUEIdjsAAQwBCyADIAQoAgwiA0kNASAAQQQ6AAAgAiABIANqNgIICyAEQRBqJAAPC0GE780AQTZBvO/NABCfKQALxwEBBn8gA0H8E2ohByADQdATaiEIIANBpBNqIQkDQAJAIAIgAWtBrAJJDQAgACgCBEHDAUsNACAJIAQgASACEK8VIAggBCABIAEgAmpBAXYiBRCvFSAHIAQgBSACEK8VIAkgAxCjDiIGQYh/SyAIIAMQow4iCkGIf0tyIAYgByADEKMOIgYgCmpNIAZBiH9LcnINACAAIAEgBSADIAQQhhYgACAAKAIEIgFBAWo2AgQgACgCACABQQJ0aiAFNgIAIAUhAQwBCwsL8QEBA38jAEEQayICJAACQAJAIAEtAABBA0YEQCACIAEoAgQiAygCACADKAIEKAIcEQAAIAMoAgAhASADKAIEIQQgA0EMQQQQ+DogAiABIAQoAhwRAAAgAikDAEKJrPzB6qf/qRKFIAIpAwhCqZ7qidv+mNeMf4WEUEUNAiAAIAEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDACABQRhBCBD4OgwBCyAAQQI6AAAgACABKQIANwIECyACQRBqJAAPCyACIAQ2AgQgAiABNgIAQejH0QBBKyACQdjH0QBBqMzRABDVHgAL1QgCBn8CfiMAQRBrIgUkACABKAIcIgMEQCABKAIQIAEoAhQgASgCGCIEELopIQIgASADQQFrNgIcIAEgBEEQajYCGCABLQBCIQMgBSABKAI8IAIoAAAgAigACBDmFQJAAkAgA0ECRwRAIAUoAggNAQsgACAFKQIANwIEIABBk4CAgHg2AgAgAEEMaiAFQQhqKAIANgIADAELIAUgAzoADyAFQQ9qIQIjAEHQAGsiASQAIAFBEGogBRDcOwJAAkACQAJAAkACQCABKAIUIgNBB0sEQCABIAEoAhApAAAiCDcDGCAIQgF8IglCAVgEQCAJp0EBRgRAIAFBJGohBCMAQSBrIgIkAAJAQQBBwAAQ0TQEQCACQQA2AhwgAkKAgICAgAg3AhQgAkLAADcCDCACIAJBDGoQ1zsgAigCACEGQRxBBBCtNiIDRQ0BIANCgYCAgBA3AgAgAyACKQIMNwIIIARBADYCCCAEIAY2AgQgBCADNgIAIANBEGogAkEUaikCADcCACADQRhqIAJBHGooAgA2AgAgAkEgaiQADAcLQYD+/gBBKSACQQxqQdD+/gBBrP7+ABDVHgALQQRBHBCjPQALIAFBJGohAyMAQUBqIgIkACAFKAIAIgQgBCgCACIGQQFqNgIAAkACQCAGQQBOBEAgAiAENgIIIAIgBSgCCCIENgIQIAIgBSgCBCIHNgIMIAJBCDYCFCACQRBqIQYgBEEISQ0BIAYgBEEIayIENgIAIAIgB0EIajYCDCADQQhqIAQ2AgAgAyACKQIINwIAIAJBQGskAAwCCwALIAJBAjYCHCACQbj9hwE2AhggAkICNwIkIAJBOzYCPCACIAY2AjggAkE7NgI0IAIgAkEwajYCICACIAJBFGo2AjAgAkEYakHI/YcBEO8sAAsMBAsgCEL/////D1YNAiABQQhqIAUQ3DsgASgCDCIDQQdNDQECQAJAIAItAABBAUYEQEEwIQMgAUEwakEwQQBBAUEBEKAYIAEoAjQhAiABKAIwQQFHDQEMCAtBLiEDIAFBMGpBLkEAQQFBARCgGCABKAI0IQIgASgCMEEBRg0HIAEoAjgiBEGc+v4AQS78CgAADAELIAEoAjgiBEH4+v4AQTD8CgAACyAAIAM2AgwgACAENgIIIAAgAjYCBCAAQY2AgIB4NgIADAQLQQggA0Go+/4AELA7AAtBCCADQbj5/gAQrzsACyABQQE2AjQgAUHo+f4ANgIwIAFCATcCPCABQe4GNgJMIAEgAUHIAGo2AjggASABQRhqNgJIIABBBGogAUEwahCZDiAAQYyAgIB4NgIADAELIAAgASkCJDcCBCAAQZOAgIB4NgIAIABBDGogAUEsaigCADYCAAsgAUHQAGokAAwBCyACIAEoAjhB6Pj+ABD9LwALIAUoAgAiACAAKAIAIgBBAWs2AgAgAEEBRw0AIAUQ+x4LIAVBEGokAA8LQdTe/gAQsjsAC9YBAQV/IABBJGoiBiAAKAIsIAAoAgBBAUEBQeCwgwEQwygCQAJAAkACQCABIAJHBEADQCABKAIAIgQgACgCDCIDTw0DIARBAWoiBSADTw0CIAAoAggiByAFQQN0aigCACIDIAcgBEEDdGooAgAiBEkNBCAAKAIUIgUgA0kNBSAGIAAoAhAgBGogAyAEaxChNiABQQRqIgEgAkcNAAsLDwsgBSADQYCxgwEQwyEACyAEIANB8LCDARDDIQALIAQgA0GQsYMBELE7AAsgAyAFQZCxgwEQsDsAC9YBAQV/IABBDGoiBiAAKAIUIAAoAihBAUEBQeCwgwEQwygCQAJAAkACQCABIAJHBEADQCABKAIAIgQgACgCHCIDTw0DIARBAWoiBSADTw0CIAAoAhgiByAFQQJ0aigCACIDIAcgBEECdGooAgAiBEkNBCADIAAoAiQiBUsNBSAGIAAoAiAgBGogAyAEaxChNiABQQRqIgEgAkcNAAsLDwsgBSADQYCxgwEQwyEACyAEIANB8LCDARDDIQALIAQgA0GQsYMBELE7AAsgAyAFQZCxgwEQsDsAC8ABAQV/IwBBEGsiBCQAIARBCGogABCGPSAEKAIMIQUgBCgCCCIDQQQQ+C8hAiABBEBBBCACIANqIAIgBUsiAxtBACAFIAJrQQJ2IAMbQQJ0akEEaygCACEFIAAoAgwhAgNAIAJBBGoiAyAAKAIEIgZLBH8gACAGQQF0IgIgAxDeKiIDIAIgA0sbEOgZIAAoAgwFIAILIAAoAghqIAU2AAAgACAAKAIMQQRqIgI2AgwgAUEBayIBDQALCyAEQRBqJAALwgECBH8BfiMAQRBrIgUkACAFQQhqIAAQhj0gBSgCDCEDIAUoAggiBEEIEPgvIQIgAQRAQQggAiAEaiACIANLIgQbQQAgAyACa0EDdiAEG0EDdGpBCGspAwAhBiAAKAIMIQIDQCACQQhqIgMgACgCBCIESwR/IAAgBEEBdCICIAMQ3ioiAyACIANLGxDoGSAAKAIMBSACCyAAKAIIaiAGNwAAIAAgACgCDEEIaiICNgIMIAFBAWsiAQ0ACwsgBUEQaiQAC+wCAgZ/AX4jAEGAAWsiAiQAIAEoAgghAyACIAFBCGo2AhAgAiADNgIMIAIgAkH/AGo2AgggAkFAayEFIAJBCGoiByEEIwBB8ABrIgMkAAJAIAEoAgAiBiABKAIERwRAIAQoAgQhBCABIAZBCGo2AgAgA0E4aiAGKAIEQQhqEOgMIAUCfiADKAI4QQFxBEAgBBCOEiAEQRBqIANBzABqKAIANgIAIARBCGogA0HEAGopAgA3AgAgBCADKQI8NwIAQgAMAQsgA0EIaiADQUBrQTD8CgAAQgELNwMAIAVBCGogA0EIakEw/AoAAAwBCyAFQgI3AwALIANB8ABqJAACQCACKQNAQgJSBEAgByAFQTj8CgAAIAIpAwgiCKdBAXEEQCAAQQhqIAJBEGpBMPwKAAAgAEIBNwMADAILIABCADcDACAIUA0BIAIoAjgiAEUNASACQRBqIAARAwAMAQsgAEIANwMACyACQYABaiQAC70BAgN+A38jAEGAAWsiBiQAIAApAwghAiAAKQMAIQNBACEAAkADQCAAQf8AakH/AEsNASAAIAZqQf8AaiADp0EPcSIFQTByIAVB1wBqIAVBCkkbOgAAIAJCPIYgA0IQVCEFIAJQIQcgAEEBayEAIAJCBIghAiADQgSIhCEDIAUgB3FFDQALIAFBAUHg84kBQQIgACAGakGAAWpBACAAaxCBCSAGQYABaiQADwsgAEH/AGpBgAFB0POJARDDIQALvAECA34DfyMAQYABayIGJAAgACkDCCECIAApAwAhA0EAIQACQANAIABB/wBqQf8ASw0BIAAgBmpB/wBqIAOnQQ9xIgVBMHIgBUE3aiAFQQpJGzoAACACQjyGIANCEFQhBSACUCEHIABBAWshACACQgSIIQIgA0IEiIQhAyAFIAdxRQ0ACyABQQFB4POJAUECIAAgBmpBgAFqQQAgAGsQgQkgBkGAAWokAA8LIABB/wBqQYABQdDziQEQwyEAC9IBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCAAIAEgA2ogAiADaxCXHSIBIAAoAgQiAk8NASAAKAIgIAAoAgAgAUEBdGoiAi8BAHEgASAAKAIkdGoiASAAKAIMIgNPDQIgACgCCCABQQJ0aiAENgIAIAIgAi8BAEEBajsBACAFQSBqJAAPCyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakH81c4AEO8sAAsgASACQYzWzgAQwyEACyABIANBnNbOABDDIQALwQEBBX8CQCAAKAIMIgMEQCADIAAoAgQiA0sNAQsgAEJ/NwIUDwsgAiAAKAIAIANBDGxqIgMoAgQiBCAAKAIIIgZrIgVBACAEIAVPGyIFTQRAIABCfzcCFCAAIAIQiB8PCyADKAIIIQcgACADKAIANgIcIAAgASAFaiIDNgIUIAAgAyAHIAYgBGsiBEEAIAQgBk0bayIEaiIDNgIYIAEgAmoiASADSQRAIAAgATYCGCAAIAIQiB8PCyAAIAQgBWoQiB8LwgEBBn8gBgRAA0ACQCAFIAtHBEAgBCALQQR0aiIKLwEOIQ0gCigCBCEOIAooAgAhDCAIIAovAQwiDxC3KSAMRQ0BA0AgASACIANxIgpLBEAgByAAIApqLQAAELYpIAJBAWohAiAMQQFrIgwNAQwDCwsgCiABQezs0QAQwyEACyAFIAVB3OzRABDDIQALIA5B////D3EiCkUgD0H/AE1yRQRAIAkgDUH/B3EQtSkLIAIgCmohAiALQQFqIgsgBkcNAAsLC8cBAgF/A34CQAJAIABBA2oiAGdBIGpBP3MiB0EBdCAArSIIIAdBAWsiB0E/ca0iCYhCAYMiCqdyQcwAaiIAQYABSQRAIABBgAFPDQEgACABai0AACACIABBAXRqMwEAIAQgBSAGEN8TIAcgCCAKQgKEIAmGfSAEIAUgBhDfEyAAQYABSQ0CIABBgAFBhJfzABDDIQALIABBgAFB5JbzABDDIQALIABBgAFB9JbzABDDIQALIAMgAEECdGoiACAAKAIAQQFqNgIAC8YBAQd/IAAoAjAhAUGAgAQhAyAAKAIgIgRB//8DcSEFA0BBACECA0AgASACaiIGIAYvAQAiBiAFayIHQQAgBiAHTxs7AQAgAkECaiICQcAARw0ACyABQUBrIQEgA0EgayIDDQALIAAoAixBYHEiAwRAIAAoAighASAEQf//A3EhAANAQQAhAgNAIAEgAmoiBCAELwEAIgQgAGsiBUEAIAQgBU8bOwEAIAJBAmoiAkHAAEcNAAsgAUFAayEBIANBIGsiAw0ACwsLwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQuhYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENodIANB1ABqIgQgARDKBiAEEJkeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQJ2IAIQuxYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEEL8dIANB1ABqIgQgARDKBiAEEJIeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQN2IAIQvBYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENYdIANB1ABqIgQgARDKBiAEEJUeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQuhYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEEM0dIANB1ABqIgQgARDKBiAEEJYeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwwQBCH8jAEHgAGsiBSQAIAEoAhAhBCABKAIUQQJ2IQgjAEEwayIDJAACQAJAIAIQkjYiBkUNACAGKAIURQ0AIAIoAhAhByACKAIUIQkgAyAGNgIgIAMgCDYCHCADIAQ2AhggA0EANgIUIAMgByAJQXxxajYCECADIAc2AgwgA0EkaiEHIwBBIGsiBCQAIARBFGogA0EMaiIIKAIEIAgoAgBrQQJ2QQBBBEEEEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIARBCGoiCSAIKAIEIAgoAgBrQQJ2EIUuIAYgCSkCBEIgiTcCCCAGIAlBCGo2AgQgCCAGQQRqEOIQIAZBEGokACAHQQhqIAooAgA2AgAgByAEKQIINwIAIARBIGokAAwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAQ2AhQgAyAGIAdBfHFqNgIQIAMgBjYCDCADQSRqIgcgA0EMahD8GgsgBSAHEOgYIANBMGokACAFQQxqIgMgARCSNiACEPISIAVBJGoiAiAFIAMQxx0gBUHUAGoiAyABEMoGIAMQjx4gAEEIaiAFQdwAaigCADYCACAAIAUpAlQ3AgAgACAFKQIwNwIMIABBFGogBUE4aigCADYCACAAIAUpAjw3AhggAEEgaiAFQcQAaikCADcCACAAQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokAAv7AgEHfyMAQeAAayIEJAAgASgCECEFIAEoAhRBA3YhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBTYCGCADQQA2AhQgAyAHIAlBfHFqNgIQIAMgBzYCDCADQSRqIgUgA0EMahCMGwwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAU2AhQgAyAGIAdBfHFqNgIQIAMgBjYCDCADQSRqIgUgA0EMahCBGwsgBCAFEOcYIANBMGokACAEQQxqIgMgARCSNiACEPISIARBJGoiAiAEIAMQ2R0gBEHUAGoiAyABEMoGIAMQkR4gAEEIaiAEQdwAaigCADYCACAAIAQpAlQ3AgAgACAEKQIwNwIMIABBFGogBEE4aigCADYCACAAIAQpAjw3AhggAEEgaiAEQcQAaikCADcCACAAQShqIARBzABqKQIANwIAIAIQuwwgBEHgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAXYgAhC+FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQ2h0gA0HUAGoiBCABEMoGIAQQmR4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAnYgAhC/FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQvx0gA0HUAGoiBCABEMoGIAQQkh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBA3YgAhDAFiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQ1h0gA0HUAGoiBCABEMoGIAQQlR4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvBAQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhRBAXYgAhC+FiADQQxqIgQgARCSNiACEPISIANBJGoiAiADIAQQzR0gA0HUAGoiBCABEMoGIAQQlh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvDBAEIfyMAQeAAayIFJAAgASgCECEEIAEoAhRBAnYhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBDYCGCADQQA2AhQgAyAHIAlBfHFqNgIQIAMgBzYCDCADQSRqIQcjAEEgayIEJAAgBEEUaiADQQxqIggoAgQgCCgCAGtBAnZBAEEEQQQQoBggBCgCGCEGIAQoAhRBAUYEQCAGIAQoAhxBvPyBARD9LwALIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAY2AggjAEEQayIGJAAgBEEIaiIJIAgoAgQgCCgCAGtBAnYQhS4gBiAJKQIEQiCJNwIIIAYgCUEIajYCBCAIIAZBBGoQ4xAgBkEQaiQAIAdBCGogCigCADYCACAHIAQpAgg3AgAgBEEgaiQADAELIAIoAhAhBiACKAIUIQcgAyAINgIYIAMgBDYCFCADIAYgB0F8cWo2AhAgAyAGNgIMIANBJGoiByADQQxqEPwaCyAFIAcQ6BggA0EwaiQAIAVBDGoiAyABEJI2IAIQ8hIgBUEkaiICIAUgAxDHHSAFQdQAaiIDIAEQygYgAxCPHiAAQQhqIAVB3ABqKAIANgIAIAAgBSkCVDcCACAAIAUpAjA3AgwgAEEUaiAFQThqKAIANgIAIAAgBSkCPDcCGCAAQSBqIAVBxABqKQIANwIAIABBKGogBUHMAGopAgA3AgAgAhC7DCAFQeAAaiQAC/sCAQd/IwBB4ABrIgQkACABKAIQIQUgASgCFEEDdiEIIwBBMGsiAyQAAkACQCACEJI2IgZFDQAgBigCFEUNACACKAIQIQcgAigCFCEJIAMgBjYCICADIAg2AhwgAyAFNgIYIANBADYCFCADIAcgCUF8cWo2AhAgAyAHNgIMIANBJGoiBSADQQxqEIYbDAELIAIoAhAhBiACKAIUIQcgAyAINgIYIAMgBTYCFCADIAYgB0F8cWo2AhAgAyAGNgIMIANBJGoiBSADQQxqEIEbCyAEIAUQ5xggA0EwaiQAIARBDGoiAyABEJI2IAIQ8hIgBEEkaiICIAQgAxDZHSAEQdQAaiIDIAEQygYgAxCRHiAAQQhqIARB3ABqKAIANgIAIAAgBCkCVDcCACAAIAQpAjA3AgwgAEEUaiAEQThqKAIANgIAIAAgBCkCPDcCGCAAQSBqIARBxABqKQIANwIAIABBKGogBEHMAGopAgA3AgAgAhC7DCAEQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEBdiACEMIWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDaHSADQdQAaiIEIAEQygYgBBCZHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEECdiACEMMWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBC/HSADQdQAaiIEIAEQygYgBBCSHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEDdiACEMQWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDWHSADQdQAaiIEIAEQygYgBBCVHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8EBAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFEEBdiACEMIWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDNHSADQdQAaiIEIAEQygYgBBCWHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC/YEAgh/AX4jAEHgAGsiBiQAIAEoAhAhBCABKAIUQQJ2IQUjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhCCACKAIUIQkgAyAHNgIgIAMgBTYCHCADIAQ2AhggA0EANgIUIAMgCCAJQXhxajYCECADIAg2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQN2QQBBBEEEEKAYIAQoAhghBSAEKAIUQQFGBEAgBSAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAFNgIIIwBBMGsiBSQAIARBCGoiCSAHKAIEIAcoAgBrQQN2EIUuIAkpAgQhCyAFQRhqIAdBEGopAgA3AwAgBUEQaiAHQQhqKQIANwMAIAUgBykCADcDCCAFIAtCIIk3AiggBSAJQQhqNgIkIAVBCGogBUEkahDhECAFQTBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhCCADIAU2AhggAyAENgIUIAMgByAIQXhxajYCECADIAc2AgwgA0EkaiIIIANBDGoQmxsLIAYgCBDoGCADQTBqJAAgBkEMaiIDIAEQkjYgAhDzEiAGQSRqIgIgBiADEMcdIAZB1ABqIgMgARDKBiADEI8eIABBCGogBkHcAGooAgA2AgAgACAGKQJUNwIAIAAgBikCMDcCDCAAQRRqIAZBOGooAgA2AgAgACAGKQI8NwIYIABBIGogBkHEAGopAgA3AgAgAEEoaiAGQcwAaikCADcCACACELsMIAZB4ABqJAAL+wIBB38jAEHgAGsiBCQAIAEoAhAhBSABKAIUQQN2IQgjAEEwayIDJAACQAJAIAIQkjYiBkUNACAGKAIURQ0AIAIoAhAhByACKAIUIQkgAyAGNgIgIAMgCDYCHCADIAU2AhggA0EANgIUIAMgByAJQXhxajYCECADIAc2AgwgA0EkaiIFIANBDGoQ9xoMAQsgAigCECEGIAIoAhQhByADIAg2AhggAyAFNgIUIAMgBiAHQXhxajYCECADIAY2AgwgA0EkaiIFIANBDGoQghsLIAQgBRDnGCADQTBqJAAgBEEMaiIDIAEQkjYgAhDzEiAEQSRqIgIgBCADENkdIARB1ABqIgMgARDKBiADEJEeIABBCGogBEHcAGooAgA2AgAgACAEKQJUNwIAIAAgBCkCMDcCDCAAQRRqIARBOGooAgA2AgAgACAEKQI8NwIYIABBIGogBEHEAGopAgA3AgAgAEEoaiAEQcwAaikCADcCACACELsMIARB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQxhYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEENodIANB1ABqIgQgARDKBiAEEJkeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQJ2IAIQxxYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEEL8dIANB1ABqIgQgARDKBiAEEJIeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQN2IAIQyBYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEENYdIANB1ABqIgQgARDKBiAEEJUeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwQEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUQQF2IAIQxhYgA0EMaiIEIAEQkjYgAhDzEiADQSRqIgIgAyAEEM0dIANB1ABqIgQgARDKBiAEEJYeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAAL9gQCCH8BfiMAQeAAayIGJAAgASgCECEEIAEoAhRBAnYhBSMAQTBrIgMkAAJAAkAgAhCSNiIHRQ0AIAcoAhRFDQAgAigCECEIIAIoAhQhCSADIAc2AiAgAyAFNgIcIAMgBDYCGCADQQA2AhQgAyAIIAlBeHFqNgIQIAMgCDYCDCADQSRqIQgjAEEgayIEJAAgBEEUaiADQQxqIgcoAgQgBygCAGtBA3ZBAEEEQQQQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhxBvPyBARD9LwALIARBEGoiCkEANgIAIAQgBCgCHDYCDCAEIAU2AggjAEEwayIFJAAgBEEIaiIJIAcoAgQgBygCAGtBA3YQhS4gCSkCBCELIAVBGGogB0EQaikCADcDACAFQRBqIAdBCGopAgA3AwAgBSAHKQIANwMIIAUgC0IgiTcCKCAFIAlBCGo2AiQgBUEIaiAFQSRqEOQQIAVBMGokACAIQQhqIAooAgA2AgAgCCAEKQIINwIAIARBIGokAAwBCyACKAIQIQcgAigCFCEIIAMgBTYCGCADIAQ2AhQgAyAHIAhBeHFqNgIQIAMgBzYCDCADQSRqIgggA0EMahCbGwsgBiAIEOgYIANBMGokACAGQQxqIgMgARCSNiACEPMSIAZBJGoiAiAGIAMQxx0gBkHUAGoiAyABEMoGIAMQjx4gAEEIaiAGQdwAaigCADYCACAAIAYpAlQ3AgAgACAGKQIwNwIMIABBFGogBkE4aigCADYCACAAIAYpAjw3AhggAEEgaiAGQcQAaikCADcCACAAQShqIAZBzABqKQIANwIAIAIQuwwgBkHgAGokAAv7AgEHfyMAQeAAayIEJAAgASgCECEFIAEoAhRBA3YhCCMAQTBrIgMkAAJAAkAgAhCSNiIGRQ0AIAYoAhRFDQAgAigCECEHIAIoAhQhCSADIAY2AiAgAyAINgIcIAMgBTYCGCADQQA2AhQgAyAHIAlBeHFqNgIQIAMgBzYCDCADQSRqIgUgA0EMahD4GgwBCyACKAIQIQYgAigCFCEHIAMgCDYCGCADIAU2AhQgAyAGIAdBeHFqNgIQIAMgBjYCDCADQSRqIgUgA0EMahCCGwsgBCAFEOcYIANBMGokACAEQQxqIgMgARCSNiACEPMSIARBJGoiAiAEIAMQ2R0gBEHUAGoiAyABEMoGIAMQkR4gAEEIaiAEQdwAaigCADYCACAAIAQpAlQ3AgAgACAEKQIwNwIMIABBFGogBEE4aigCADYCACAAIAQpAjw3AhggAEEgaiAEQcQAaikCADcCACAAQShqIARBzABqKQIANwIAIAIQuwwgBEHgAGokAAvpAQECfyMAQaACayICJAAgAkEANgKcAiACQQA2AoACIAJBADYC9AEgAkEBOgDkASACQgQ3AtwBIAJCADcC1AEgAkKAgICAwAA3AswBIAJBADYCxAEgAiABKAIMNgKYAiACIAEoAhA2AvABIAJB6ABqIAJBxAFqIAFBFGoQwhlBDEEEEK02IgNFBEBBBEEMEKM9AAsgAyABKQIANwIAIANBCGogAUEIaigCADYCACACQQE2AswBIAIgAzYCyAEgAkEBNgLEASACQQxqIgEgAkHoAGogAkHEAWoQlikgACABEM0cIAJBoAJqJAALxgEBA38jAEEgayIEJAACQCABKAI8IgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAFBPGoQ+x4LIAFBADYCPCABIAQpAgw3AkAgAUHIAGogBEEUaikCADcCACABQdAAaiAEQRxqKAIANgIAIAFBMGohAwJAIAEoAjAiBUUNACAFIAUoAgAiBUEBazYCACAFQQFHDQAgAxD7HgsgAyACKQIANwIAIANBCGogAkEIaigCADYCACAAIAFB3AD8CgAAIARBIGokAAulAgIHfwFvIwBBIGsiAiQAIAJBHGpBADoAACACQgA3AhQgAkEENgIQIAJCADcCCCACQQhqIgUQnychBBCmOyIDJQEQDyEIEN8SIgEgCCYBIAIgATYCCCAFEKs7IQUgAUGEAU8EQCABEPIfCyADQYQBTwRAIAMQ8h8LIAJBgAE2AgggAkEIaigCACUBEE8hCBDfEiIBIAgmASABIQYgBCAEKAIAQQFqIgE2AgAgAQRAQQRBBBCtNiIBRQRAQQRBBBCjPQALIAEgBDYCACABQaioiAEQkzUhByAAQQRqIgNBqKiIATYCBCADIAE2AgAgAyAHNgIIIAAgBToAFCAAIAY2AhAgACAENgIAIAIoAggiAEGEAU8EQCAAEPIfCyACQSBqJAAPCwAL0QEBBX8CQCAAQoCAgIAQVARAIAEhBAwBCyABQQhrIgQgACAAQoDC1y+AIgBCgL6o0A9+fKciAkGQzgBuIgNBkM4AcCIFQeQAbiIGQQF0QYjQiAFqLwAAOwAAIAFBBGsgAiADQZDOAGxrIgJB//8DcUHkAG4iA0EBdEGI0IgBai8AADsAACABQQZrIAUgBkHkAGxrQf//A3FBAXRBiNCIAWovAAA7AAAgAUECayACIANB5ABsa0H//wNxQQF0QYjQiAFqLwAAOwAACyAApyAEEMAUC94BAQF/IwBBEGsiDiQAIAAoAgAgAUEQIAAoAgQoAgwRBgAhASAOQQA6AA0gDiABOgAMIA4gADYCCCAOQQhqIAJBDiADIAQQiBIgBUENIAYgBxCIEiAIQQ0gCSAKEIgSIAtBBCAMIA0QiBIhASAOLQANIgIgDi0ADCIDciEAAkAgA0EBcSACQQFHcg0AIAEoAgAiAC0ACkGAAXFFBEAgACgCAEHX8YkBQQIgACgCBCgCDBEGACEADAELIAAoAgBB1vGJAUEBIAAoAgQoAgwRBgAhAAsgDkEQaiQAIABBAXELxwECAn8BfiMAQSBrIgIkAAJAIAEEQCABQQhrIgMoAgBBAUcNASACQRhqIAFBEGopAgA3AgAgAkEQaiABQQhqKQIANwIAIAEpAgAhBCADQQA2AgAgAiAENwIIAkAgA0F/Rg0AIAFBBGsiASABKAIAQQFrIgE2AgAgAQ0AIANBIEEEEPg6CyAAIAIpAgw3AgAgAEEQaiACQRxqKAIANgIAIABBCGogAkEUaikCADcCACACQSBqJAAPCxCYPQALQf6/zABBPxCXPQALwwEBBX8CQAJAIAJBwQBJBEAgACAAKAIIIgMgACgCGCIFa0EDdCAAKAIcIgZrIgcgASACbCIESQR/IAJFDQIgByACbiIBIAJsBSAECyAGIAVBA3RqaiICQQdxIgQ2AhwgACACQQN2IgI2AhggBARAIAIgA0sNAyAAQQggAyACayIDIANBCE8bIAAoAgQgAmogAxDZIjcDEAsgAQ8LQZi2zgBBIEGous4AEJ8pAAtBuLrOABDiKwALIAIgA0HEu84AEK87AAuTCQEEfyMAQTBrIgQkACAEIAM2AgwCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAw4JAAECAwQFBgcICQsgAkIANwAADAkLIAFFBEAMCgsgAiAALQAAIgBBB3Y6AAcgAiAAQQFxOgAAIAIgAEEGdkEBcToABiACIABBBXZBAXE6AAUgAiAAQQR2QQFxOgAEIAIgAEEDdkEBcToAAyACIABBAnZBAXE6AAIgAiAAQQF2QQFxOgABDAgLIAFBAU0EQAwJCyACIAAtAAAiAUEGdjoAAyACIAFBA3E6AAAgAiAALQABIgBBBnY6AAcgAiAAQQNxOgAEIAIgAUEEdkEDcToAAiACIAFBAnZBA3E6AAEgAiAAQQR2QQNxOgAGIAIgAEECdkEDcToABQwHCyABQQJNBEAMCAsgAiAALQAAIgFBB3E6AAAgAiAALQACIgNBBXY6AAcgAiABQQN2QQdxOgABIAIgAC0AASIAQQR2QQdxOgAEIAIgAEEBdkEHcToAAyACIANBAnZBB3E6AAYgAiAAQQJ0QQRxIAFBBnZyOgACIAIgA0EBdEEGcSAAQQd2cjoABQwGCyABQQNNBEAMBwsgAiAALQAAIgFBBHY6AAEgAiABQQ9xOgAAIAIgAC0AASIBQQR2OgADIAIgAUEPcToAAiACIAAtAAIiAUEEdjoABSACIAFBD3E6AAQgAiAALQADIgBBBHY6AAcgAiAAQQ9xOgAGDAULIAFBBE0EQAwGCyACIAAtAAAiBUEfcToAACACIAAtAAQiBkEDdjoAByACIAAtAAEiAUECdkEfcToAAiACIAAtAAMiA0EBdkEfcToABSACIAFBA3RBGHEgBUEFdnI6AAEgAiAALQACIgBBAXRBHnEgAUEHdnI6AAMgAiADQQR0QRBxIABBBHZyOgAEIAIgBkECdEEccSADQQZ2cjoABgwECyABQQVNBEAMBQsgAiAALQAAIgFBP3E6AAAgAiAALQACIgNBAnY6AAMgAiAALQADIgVBP3E6AAQgAiAALQAFIgZBAnY6AAcgAiAALQABIgdBAnRBPHEgAUEGdnI6AAEgAiADQQR0QTBxIAdBBHZyOgACIAIgAC0ABCIAQQJ0QTxxIAVBBnZyOgAFIAIgBkEEdEEwcSAAQQR2cjoABgwDCyABQQZNBEAMBAsgAiAALQAAIgFB/wBxOgAAIAIgAC0ABiIDQQF2OgAHIAIgAC0AASIFQQF0Qf4AcSABQQd2cjoAASACIAAtAAIiAUECdEH8AHEgBUEGdnI6AAIgAiAALQADIgVBA3RB+ABxIAFBBXZyOgADIAIgAC0ABCIBQQR0QfAAcSAFQQR2cjoABCACIAAtAAUiAEEFdEHgAHEgAUEDdnI6AAUgAiADQQZ0QcAAcSAAQQJ2cjoABgwCCyABQQdNBEAMAwsgAiAAKQAANwAADAELIARBATYCFCAEQfyJzwA2AhAgBEIBNwIcIARBOzYCLCAEIARBKGo2AhggBCAEQQxqNgIoIARBEGpBhIrPABDvLAALIARBMGokAA8LQeS7zgBBLUHUu84AEJ8pAAvIAQEHfyMAQRBrIgIkACABKAIEIQMgAkEEaiABKAIIIgZBAEEEQQgQoBggAigCCCEEIAIoAgRBAUcEQCACKAIMIQcCQCAERQ0AIAZBA3QhASAHIQUgBCEIA0AgAUUNASAFIAM1AgAgAzEABEIghiADMQAFQiiGhIQ3AgAgBUEIaiEFIAFBCGshASADQQhqIQMgCEEBayIIDQALCyAAIAY2AgggACAHNgIEIAAgBDYCACACQRBqJAAPCyAEIAIoAgxB6JnPABD9LwALlx0CG38DfiMAQeAAayIJJAAgASgCACEPIwBBMGsiByQAIAdBADoAICAHQQA2AhQgB0EANgIMIAdBgICAgHg2AgAgB0EANgIcIwBBIGsiASQAIAcoAhwhCiAHLQAhIRQgBy0AICEVIAcoAhghECAHKAIUIQ0gBygCECERIAcoAgwhDiAHKQIEISAgBygCACESIAFBBGoiBUEKQei++wAQzhggEkGAgICAeEcEQCABQoCAgIAgNwIQIAEgIEIgiCIhPQEYIwBBEGsiDCQAIAUgAUEQaiIIKAIEIAgoAgBrEOQtIAUoAgghCyAFKAIEIRYgDEEIaiAIQQhqKAIANgIAIAwgCCkCACIiNwMAICKnIgYgDCgCBCITRwRAA0AgCyAWaiAGIAxqQQhqLQAAOgAAIAtBAWohCyATIAZBAWoiBkcNAAsgDCATNgIACyAFIAs2AgggDEEQaiQAIAEgEjYCGCABICCnIgY2AhAgASAGICGnajYCHCABIAY2AhQjAEEQayIGJAAgBSAIKAIMIAgoAgQiC2siDBDkLSAMBEAgBSgCBCAFKAIIaiALIAz8CgAACyAIIAs2AgwgBSAFKAIIIAxqNgIIIAYgCCgCADYCDCAGIAgoAgg2AgggBkEIakEBQQEQ4B4gBkEQaiQAQQQhBgsgB0EkaiESAkAgDkUNACABQQRqIA4gDiARahDoJCAOQQA6AAAgBkEIciEGIBFFDQAgDiARQQEQ+DoLAkAgDUUNACABQQRqIA0gDSAQahDoJCANQQA6AAAgBkEQciEGIBBFDQAgDSAQQQEQ+DoLAkACQAJAAkACQAJAAkACQAJAAkAgASgCDARAIAEoAghBHzoAACABKAIMIgVBAU0NASABKAIIQYsBOgABIAEoAgwiBUECTQ0CIAEoAghBCDoAAiABKAIMIgVBA00NAyABKAIIIAY6AAMgASgCDCIFQQRNDQQgASgCCCAKOgAEIAEoAgwiBUEFTQ0FIAEoAgggCkEIdjoABSABKAIMIgVBBk0NBiABKAIIIApBEHY6AAYgASgCDCIFQQdNDQcgASgCCCAKQRh2OgAHIAEoAgwiBUEITQ0IIAEoAggiBUECIA9BAklBAnQgD0EISxs6AAggASgCDCIGQQlNDQkgBSAUQX8gFUEBcRs6AAkgEiABKQIENwIAIBJBCGogAUEMaigCADYCACABQSBqJAAMCgtBAEEAQbi/+wAQwyEAC0EBIAVByL/7ABDDIQALQQIgBUHYv/sAEMMhAAtBAyAFQei/+wAQwyEAC0EEIAVB+L/7ABDDIQALQQUgBUGIwPsAEMMhAAtBBiAFQZjA+wAQwyEAC0EHIAVBqMD7ABDDIQALQQggBUG4wPsAEMMhAAtBCSAGQcjA+wAQwyEACyMAQSBrIhgkACAYQQhqIQ0jAEEgayIOJAAQiCwhASMAQSBrIgwkAAJ/QXpBt7TCAC0AAEExRw0AGkF+IAFFDQAaIAxBADoAHCAMQQg2AhggDEFxNgIUIAxBCDYCDCAMIA82AhBBACEFIwBBEGsiCCQAIAFBADYCGCAMQQxqIgooAgghBgJAIAEoAiAiFQRAIAEoAiQiFg0BCyABQQA2AihBnAshFiABQZwLNgIkQZ0LIRUgAUGdCzYCIAsgCigCBCELIAotABAhHCAKKAIMIRECQAJ/IAZBAE4EQEEBIQVBASAGQQ9NDQEaIAZBEGshBkEAIQVBAgwBC0F+IQogBkFxSQ0BQQAgBmshBkEACyEdQX4hCiAGQXhxQQhHIBFBAWtBCEtyDQAgBkEIRyAFckVBBiALIAtBf0YbIh5BCUtyDQAgCCAWNgIIIAggFTYCBCAIIAEoAig2AgxBfCEKIAhBBGoiHyILQcAAQcAWELYbIgVFDQBBAUEJIAYgBkEIRhsiGXQhFyALQQIgGXQiBhCBGiETIAtBAiAGELYbIQ8gC0ECQYCACBC2GyEQIAtBAUGAAiARdCIaELYbIRQgC0HAASARdCIbEIEaIQsCQAJAIA9FIBBFIBNFcnJBASAUGwRAIAsEQCAfIAsgGxCNGQsgFEUNAgwBCyALRQ0AIAYEQCAPQQAgBvwLAAsgEEEAQYCACPwLACAFQgA3AAUgBSAeOgAEIAUgHDoAAyAFIB06AAIgBUEBOwEAIAVBDGpCADcAACAFQQA2AjwgBSAQNgIwIAUgFzYCLCAFIA82AiggBUEANgIkIAUgFzYCICAFIBk2AhwgBSAGNgIYIAUgEzYCFCAFQQA2AjQgBUE3akEANgAAIAUgCzYCQCAFIBs2AkQgBUEANgJIIAVBwAAgEXQ2AkwgBUEANgJQIAUgFDYCWCAFIBo2AlwgBUHwAGpBADoAACAFQegAakIANwIAIAVCADcCYCAFQfgAakEAQSz8CwAgBUGkAWpB8ML7AEH8EfwKAAAgBUGgE2pBgNX7AEH8AfwKAAAgBUGcFWpB/Nb7AEGkAfwKAAAgASAFNgIcQX4hCiAVRSAWRXINAiABQQI2AiwgAUIANwIUIAFBADYCCCABKAIcIgVBADYCZCAFIAUtAAIiBiAGwEEHdSIGcyAGayIGOgACIAVBBEEBIAZB/wFxIgpBAkYbOgAAQQEhBiAKQQJGBEAgBUEANgKgAUEAIQYLIAVBkPT7ADYCnBUgBUHg8/sANgKgEyAFQcTz+wA2AqQBIAVB/gE6AAEgASAGNgIwIAVBADoAcCAFQgA3A2ggBRCxGiAFIAUoAiBBAXQ2AlAgBSgCMEEAQYCACPwLACAFLQAEIgbAIQoCQCAGQQlNBEAgBSAGOgAEIAUgCkEMbCIGQeKA/QBqLwEAIgo7ATYgBSAGQeCA/QBqLwEAOwEKIAUgBkHcgP0Aai8BADsBCCAFIAZB3oD9AGovAQA7ATggBSAKQYAISzoABgwBCyAKQQpBoNj7ABDDIQALIAVBADYCPCAFQQA2AhAgBUEANgIkIAVBADsBNCAFQgA3A4ABIAVBADsBDCAFQQA6AAdBACEKDAILIAhBBGogFCAaEI4ZCyAQBEAgCEEEaiAQEOMYCyAPBEAgCEEEaiAPIBcQ5BgLIBMEQCAIQQRqIBMgBhCNGQsgCEEEaiAFEOUYCyAIQRBqJAAgCgshBSAMQSBqJAAgDiAFNgIEAkAgBUUEQCANQgA3AwAgDSABNgIQIA1BCGpCADcDACAOQSBqJAAMAQsgDkEANgIIIA5BBGogDkEIakGAvvsAEI4rAAsjAEEQayIBJAAgAUEEakGAgAJBAEEBQQEQoBggASgCCCEGIAEoAgRBAUYEQCAGIAEoAgxB4PTNABD9LwALIAEoAgwhCCAJQRhqIgUgBDYCGCAFQQA2AiQgBSAINgIgIAUgBjYCHCAFIA0pAwA3AwAgBUEIaiANQQhqKQMANwMAIAVBEGogDUEQaikDADcDACABQRBqJAAgCRCPKyAJQQA2AkAgCSASKQIANwJEIAlBzABqIBJBCGooAgA2AgAgGEEgaiQAIAdBMGokACAJQdgAaiEMIwBBEGsiBSQAAkACQCADBEADQCAFQQhqIQQjAEEgayIBJAACQAJAAkAgCSgCQEUEQCABQQhqIAkQgRgCQCABLQAIQQRGDQAgASkDCCIgQv8Bg0IEUQ0AIAQgIDcCAAwECyABQQhqIQYjAEEQayIHJAAgCUEYaiIIQRxqIQ0CQANAIAcgCBCDGAJAIActAABBBEYNACAHKQMAIiBC/wGDQgRRDQAgBkEBNgIAIAYgIDcCBAwCCyAIKQMAISAgByAIIAIgAyANQQAQkDYgBy0AACIOIAgpAwAgIH2nIgogA0VyckUgBy0AASILQQJHcQ0AC0EBIQgCQCAOQQFxBEAgBkEEakEUQcj0zQBBFhDNGgwBCyAGIAs6AAggBiAKNgIEQQAhCAsgBiAINgIACyAHQRBqJAACfyABKAIIRQRAIAEoAgwMAQsgASkCDCIgQv8Bg0IEUg0CICBCIIinCyIHIANLDQIgCSACIAcQgzEgBEEEOgAAIAQgBzYCBAwDCyABQQA2AghBACAJQUBrQZD1zQAgAUEIakGk9c0AEK8rAAsgBCAgNwIADAELIAcgA0GU9c0AELA7AAsgAUEgaiQAAkACQAJAAkACQCAFLQAIIgFBBEcEQAJAIAFBAWsOAwAEAgkLIAUtAAlBI0cNCAwECyAFKAIMIgFFBEBByPDNACEEDAgLIAEgA00NASABIANB0PDNABCvOwALIAUoAgwtAAhBI0YNAgwGCyABIAJqIQIgAyABayEDDAILIAUoAgwtAAhBI0cNBAsgBUEIahC5LgsgAw0ACwsgDEEEOgAADAELIAwgBCkCADcCAAsgBUEQaiQAAkACQCAJLQBYQQRGDQAgCSkDWCIgQv8Bg0IEUQ0AIAkgIDcDWCAAIAwQgSsMAQsgCUHQAGogCRDOECAJLQBQQQRHBEAgCSAJKQNQNwNYIAAgCUHYAGoQgSsMAQsgAEEINgIACyMAQRBrIgAkAAJAIAkoAjBFDQAgAEEIaiIBIAkQzhAgAC0ACEEERg0AIAEQuS4LIABBEGokACMAQRBrIgAkAAJAIAlBGGoiASgCGEUNACAAQQhqIgIgARCCGCAALQAIQQRGDQAgAhC5LgsgAEEQaiQAIAkoAighASMAQRBrIgMkAAJAIAFFDQAgASgCIEUNACABKAIkRQ0AIAEoAhxFDQAgAUEgaiECIAEoAhwiAC0AACEEIAAoAkQiBQRAIAAoAkAhByAAQgE3A0AgAiAHIAUQjRkLIAIgACgCWCAAKAJcEI4ZIAIgACgCMBDjGCAAKAIsIgUEQCACIAAoAiggBRDkGAsgACgCGCIFBEAgACgCFCEHIABCATcCFCACIAcgBRCNGQsgAUEANgIcIAIgABDlGCADQQhqIgAgATYCBCAAIARBAkY2AgAgAygCCBoLIANBEGokACAJQShqEIY7IAlBNGoQ3jsgCUHEAGoQ3jsgCUHgAGokAAvAAQEBfyMAQRBrIgkkACAJIAM2AgwgCCAJQQxqIAEgAiAIQdjFABD5JxpBACEDAn8CQAJAAn8CQAJAIAAOAgADAQsgBiAHIAggCSgCDBCEIAwBCyAAQX5xQQJHDQEgBCAIIAkoAgwQ7hULIgNBiH9LDQELIAEgAmohAANAIAAgAU1FBEAgASEIIAUEQCAFIAEtAABqIQgLIAFBAWohASADIAgtAABqIQMMAQsLIANBA3YMAQsgAkEKbAsgCUEQaiQAC8cBAQJ/IwBBIGsiBCQAIAQgACgCBCIFNgIEIAVBEEYEQCABQQ9xQQF0IQEgACgCACEAA0AgACABaiIFIAUvAQAgAmo7AQAgAUECaiIBQSBHDQALIAAvAR4gA0H//wNxTwRAQQAhAQNAIAAgAWoiAiABQZCH8wBqLwEAIAIvAQBqIgIgAkH8/wNxQQJ2azsBACABQQJqIgFBIEcNAAsLIARBIGokAA8LIARBADYCCEEAIARBBGpB7IbzACAEQQhqQbCH8wAQrysAC+MBAgN/An4jAEEQayIHJAAgByACQQBBAUEBEKAYIAcoAgQhCCAHKAIAQQFHBEAgBygCCCEJIAIEQCAJIAEgAvwKAAALIAdBpPb+ABClKyAHKQMAIQogBykDCCELIAAgAjYCPCAAIAk2AjggACAINgI0IAAgBDoAQCAAIAY6AEEgACAFNwMgIABBsPb+ACkDADcDACAAQQhqQbj2/gApAwA3AwAgACALNwMYIAAgCjcDECAAIAMpAgA3AiggAEEwaiADQQhqKAIANgIAIAdBEGokAA8LIAggBygCCEHg9v4AEP0vAAvPBQEOfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBfHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBAnZBAEECQQIQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEQayIIJAAgA0EIaiIEIAIoAgQgAigCAGtBAnYQ7S0gCCAEKQIEQiCJNwIIIAggBEEIajYCBCMAQTBrIgQkACAIQQRqIgcoAgQhCSAHKAIAIQ4CQAJAAkAgAigCACIGIAIoAgQiCkcEQCACKAIUIQwgAigCECEPIAIoAgwhECACKAIIIQIgBygCCCAJQQF0aiEHIAogBmtBAnYhCgNAIAQgBjYCDAJAIA8gBigCACILSwRAIBAgC0EBdGovAQAhCwwBCyACIAwoAhBPDQNBACELIAwoAgQgAiAMKAIMaiIRQQN2ai0AACARQQdxdkEBcQ0ECyAHIAs7AQAgBkEEaiEGIAdBAmohByACQQFqIQIgCUEBaiEJIApBAWsiCg0ACwsgDiAJNgIAIARBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIARBATYCFCAEQdy2ggE2AhAgBEIBNwIcIARB7QY2AiwgBCAEQShqNgIYIAQgBEEMajYCKCAEQRBqQeS2ggEQ7ywACyAIQRBqJAAgAUEIaiANKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAFIAI2AhggBSABNgIUIAUgBCADQXxxajYCECAFIAQ2AgwgBUEkaiIBIAVBDGoQihsLIAAgARDpGCAFQTBqJAALiQMBBH8jAEEwayIEJAACQAJAIAMQkjYiBUUNACAFKAIURQ0AIAMoAhAhBiADKAIUIQMgBCAFNgIgIAQgAjYCHCAEIAE2AhggBEEANgIUIAQgBiADQXxxajYCECAEIAY2AgwgBEEkaiEBIwBBIGsiAiQAIAJBFGogBEEMaiIDKAIEIAMoAgBrQQJ2QQBBBEEEEKAYIAIoAhghBSACKAIUQQFGBEAgBSACKAIcQbz8gQEQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiAFNgIIIwBBEGsiBSQAIAJBCGoiBiADKAIEIAMoAgBrQQJ2EO4tIAUgBikCBEIgiTcCCCAFIAZBCGo2AgQgAyAFQQRqEOIQIAVBEGokACABQQhqIAcoAgA2AgAgASACKQIINwIAIAJBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCdGwsgACABEOgYIARBMGokAAvBAQEDfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIgEgBEEMahCMGwwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCBGwsgACABEL0YIARBMGokAAuJAwEEfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIQEjAEEgayICJAAgAkEUaiAEQQxqIgMoAgQgAygCAGtBAnZBAEEBQQEQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBvPyBARD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAU2AggjAEEQayIFJAAgAkEIaiIGIAMoAgQgAygCAGtBAnYQgS4gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCADIAVBBGoQsxEgBUEQaiQAIAFBCGogBygCADYCACABIAIpAgg3AgAgAkEgaiQADAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEJQbCyAAIAEQ7hggBEEwaiQAC88FAQ5/IwBBMGsiBSQAAkACQCADEJI2IgRFDQAgBCgCFEUNACADKAIQIQYgAygCFCEDIAUgBDYCICAFIAI2AhwgBSABNgIYIAVBADYCFCAFIAYgA0F8cWo2AhAgBSAGNgIMIAVBJGohASMAQSBrIgMkACADQRRqIAVBDGoiAigCBCACKAIAa0ECdkEAQQJBAhCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEG8/IEBEP0vAAsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgBDYCCCMAQRBrIggkACADQQhqIgQgAigCBCACKAIAa0ECdhDtLSAIIAQpAgRCIIk3AgggCCAEQQhqNgIEIwBBMGsiBCQAIAhBBGoiBygCBCEJIAcoAgAhDgJAAkACQCACKAIAIgYgAigCBCIKRwRAIAIoAhQhDCACKAIQIQ8gAigCDCEQIAIoAgghAiAHKAIIIAlBAXRqIQcgCiAGa0ECdiEKA0AgBCAGNgIMAkAgDyAGKAIAIgtLBEAgECALQQF0ai8BACELDAELIAIgDCgCEE8NA0EAIQsgDCgCBCACIAwoAgxqIhFBA3ZqLQAAIBFBB3F2QQFxDQQLIAcgCzsBACAGQQRqIQYgB0ECaiEHIAJBAWohAiAJQQFqIQkgCkEBayIKDQALCyAOIAk2AgAgBEEwaiQADAILQYyyggFBIEGssoIBEJ8pAAsgBEEBNgIUIARB3LaCATYCECAEQgE3AhwgBEG7EzYCLCAEIARBKGo2AhggBCAEQQxqNgIoIARBEGpB5LaCARDvLAALIAhBEGokACABQQhqIA0oAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBfHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCKGwsgACABEOkYIAVBMGokAAuJAwEEfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBfHFqNgIQIAQgBjYCDCAEQSRqIQEjAEEgayICJAAgAkEUaiAEQQxqIgMoAgQgAygCAGtBAnZBAEEEQQQQoBggAigCGCEFIAIoAhRBAUYEQCAFIAIoAhxBvPyBARD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAU2AggjAEEQayIFJAAgAkEIaiIGIAMoAgQgAygCAGtBAnYQ7i0gBSAGKQIEQiCJNwIIIAUgBkEIajYCBCADIAVBBGoQ4xAgBUEQaiQAIAFBCGogBygCADYCACABIAIpAgg3AgAgAkEgaiQADAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEJ0bCyAAIAEQ6BggBEEwaiQAC8EBAQN/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGoiASAEQQxqEIYbDAELIAMoAhAhBSADKAIUIQMgBCACNgIYIAQgATYCFCAEIAUgA0F8cWo2AhAgBCAFNgIMIARBJGoiASAEQQxqEIEbCyAAIAEQvRggBEEwaiQAC4kDAQR/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgIkACACQRRqIARBDGoiAygCBCADKAIAa0ECdkEAQQFBARCgGCACKAIYIQUgAigCFEEBRgRAIAUgAigCHEG8/IEBEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgBTYCCCMAQRBrIgUkACACQQhqIgYgAygCBCADKAIAa0ECdhCBLiAFIAYpAgRCIIk3AgggBSAGQQhqNgIEIAMgBUEEahCyESAFQRBqJAAgAUEIaiAHKAIANgIAIAEgAikCCDcCACACQSBqJAAMAQsgAygCECEFIAMoAhQhAyAEIAI2AhggBCABNgIUIAQgBSADQXxxajYCECAEIAU2AgwgBEEkaiIBIARBDGoQlBsLIAAgARDuGCAEQTBqJAALhAYCDn8BfiMAQTBrIgYkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEFIAMoAhQhAyAGIAQ2AiAgBiACNgIcIAYgATYCGCAGQQA2AhQgBiAFIANBeHFqNgIQIAYgBTYCDCAGQSRqIQEjAEEgayIDJAAgA0EUaiAGQQxqIgIoAgQgAigCAGtBA3ZBAEECQQIQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIFIAIoAgQgAigCAGtBA3YQ7S0gBSkCBCESIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgEkIgiTcCKCAEIAVBCGo2AiQjAEEwayICJAAgBEEkaiIHKAIEIQkgBygCACEOAkACQAJAIARBCGoiBSgCACIIIAUoAgQiCkcEQCAFKAIUIQwgBSgCECEPIAUoAgwhECAFKAIIIQUgBygCCCAJQQF0aiEHIAogCGtBA3YhCgNAIAIgCDYCDAJAIAgoAgAiCyAPSQRAIBAgC0EBdGovAQAhCwwBCyAFIAwoAhBPDQNBACELIAwoAgQgBSAMKAIMaiIRQQN2ai0AACARQQdxdkEBcQ0ECyAHIAs7AQAgCEEIaiEIIAdBAmohByAFQQFqIQUgCUEBaiEJIApBAWsiCg0ACwsgDiAJNgIAIAJBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJBuhM2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyAEQTBqJAAgAUEIaiANKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAGIAI2AhggBiABNgIUIAYgBCADQXhxajYCECAGIAQ2AgwgBkEkaiIBIAZBDGoQixsLIAAgARDpGCAGQTBqJAALvAMCBH8BfiMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEEQQQQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIGIAIoAgQgAigCAGtBA3YQ7i0gBikCBCEIIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgCEIgiTcCKCAEIAZBCGo2AiQgBEEIaiAEQSRqEOEQIARBMGokACABQQhqIAcoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBeHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCDGwsgACABEOgYIAVBMGokAAvBAQEDfyMAQTBrIgQkAAJAAkAgAxCSNiIFRQ0AIAUoAhRFDQAgAygCECEGIAMoAhQhAyAEIAU2AiAgBCACNgIcIAQgATYCGCAEQQA2AhQgBCAGIANBeHFqNgIQIAQgBjYCDCAEQSRqIgEgBEEMahD3GgwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBeHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCCGwsgACABEL0YIARBMGokAAu8AwIEfwF+IwBBMGsiBSQAAkACQCADEJI2IgRFDQAgBCgCFEUNACADKAIQIQYgAygCFCEDIAUgBDYCICAFIAI2AhwgBSABNgIYIAVBADYCFCAFIAYgA0F4cWo2AhAgBSAGNgIMIAVBJGohASMAQSBrIgMkACADQRRqIAVBDGoiAigCBCACKAIAa0EDdkEAQQFBARCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEG8/IEBEP0vAAsgA0EQaiIHQQA2AgAgAyADKAIcNgIMIAMgBDYCCCMAQTBrIgQkACADQQhqIgYgAigCBCACKAIAa0EDdhCBLiAGKQIEIQggBEEYaiACQRBqKQIANwMAIARBEGogAkEIaikCADcDACAEIAIpAgA3AwggBCAIQiCJNwIoIAQgBkEIajYCJCAEQQhqIARBJGoQsBEgBEEwaiQAIAFBCGogBygCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJobCyAAIAEQ7hggBUEwaiQAC4QGAg5/AX4jAEEwayIGJAACQAJAIAMQkjYiBEUNACAEKAIURQ0AIAMoAhAhBSADKAIUIQMgBiAENgIgIAYgAjYCHCAGIAE2AhggBkEANgIUIAYgBSADQXhxajYCECAGIAU2AgwgBkEkaiEBIwBBIGsiAyQAIANBFGogBkEMaiICKAIEIAIoAgBrQQN2QQBBAkECEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQbz8gQEQ/S8ACyADQRBqIg1BADYCACADIAMoAhw2AgwgAyAENgIIIwBBMGsiBCQAIANBCGoiBSACKAIEIAIoAgBrQQN2EO0tIAUpAgQhEiAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIBJCIIk3AiggBCAFQQhqNgIkIwBBMGsiAiQAIARBJGoiBygCBCEJIAcoAgAhDgJAAkACQCAEQQhqIgUoAgAiCCAFKAIEIgpHBEAgBSgCFCEMIAUoAhAhDyAFKAIMIRAgBSgCCCEFIAcoAgggCUEBdGohByAKIAhrQQN2IQoDQCACIAg2AgwCQCAIKAIAIgsgD0kEQCAQIAtBAXRqLwEAIQsMAQsgBSAMKAIQTw0DQQAhCyAMKAIEIAUgDCgCDGoiEUEDdmotAAAgEUEHcXZBAXENBAsgByALOwEAIAhBCGohCCAHQQJqIQcgBUEBaiEFIAlBAWohCSAKQQFrIgoNAAsLIA4gCTYCACACQTBqJAAMAgtBjLKCAUEgQayyggEQnykACyACQQE2AhQgAkHctoIBNgIQIAJCATcCHCACQcgQNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAkEQakHktoIBEO8sAAsgBEEwaiQAIAFBCGogDSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBiACNgIYIAYgATYCFCAGIAQgA0F4cWo2AhAgBiAENgIMIAZBJGoiASAGQQxqEIsbCyAAIAEQ6RggBkEwaiQAC7wDAgR/AX4jAEEwayIFJAACQAJAIAMQkjYiBEUNACAEKAIURQ0AIAMoAhAhBiADKAIUIQMgBSAENgIgIAUgAjYCHCAFIAE2AhggBUEANgIUIAUgBiADQXhxajYCECAFIAY2AgwgBUEkaiEBIwBBIGsiAyQAIANBFGogBUEMaiICKAIEIAIoAgBrQQN2QQBBBEEEEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQbz8gQEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIwBBMGsiBCQAIANBCGoiBiACKAIEIAIoAgBrQQN2EO4tIAYpAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAhCIIk3AiggBCAGQQhqNgIkIARBCGogBEEkahDkECAEQTBqJAAgAUEIaiAHKAIANgIAIAEgAykCCDcCACADQSBqJAAMAQsgAygCECEEIAMoAhQhAyAFIAI2AhggBSABNgIUIAUgBCADQXhxajYCECAFIAQ2AgwgBUEkaiIBIAVBDGoQgxsLIAAgARDoGCAFQTBqJAALwQEBA38jAEEwayIEJAACQAJAIAMQkjYiBUUNACAFKAIURQ0AIAMoAhAhBiADKAIUIQMgBCAFNgIgIAQgAjYCHCAEIAE2AhggBEEANgIUIAQgBiADQXhxajYCECAEIAY2AgwgBEEkaiIBIARBDGoQ+BoMAQsgAygCECEFIAMoAhQhAyAEIAI2AhggBCABNgIUIAQgBSADQXhxajYCECAEIAU2AgwgBEEkaiIBIARBDGoQghsLIAAgARC9GCAEQTBqJAALvAMCBH8BfiMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEBQQEQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiIGIAIoAgQgAigCAGtBA3YQgS4gBikCBCEIIARBGGogAkEQaikCADcDACAEQRBqIAJBCGopAgA3AwAgBCACKQIANwMIIAQgCEIgiTcCKCAEIAZBCGo2AiQgBEEIaiAEQSRqELERIARBMGokACABQQhqIAcoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQQgAygCFCEDIAUgAjYCGCAFIAE2AhQgBSAEIANBeHFqNgIQIAUgBDYCDCAFQSRqIgEgBUEMahCaGwsgACABEO4YIAVBMGokAAvgAwEGfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgAigCBCACKAIAa0EDdiIIIANBCGoiBigCACAGKAIIIgdrSwRAIAYgByAIQRBBEBDeKCAGKAIIIQcLIAYoAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAg2AiwgBCAHNgIoIAQgBkEIajYCJCAEQQhqIARBJGoQqRAgBEEwaiQAIAFBCGogCSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJYbCyAAIAEQuhggBUEwaiQAC68DAQZ/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgMkACADQRRqIARBDGoiAigCBCACKAIAa0ECdkEAQRBBEBCgGCADKAIYIQUgAygCFEEBRgRAIAUgAygCHEG8/IEBEP0vAAsgA0EQaiIIQQA2AgAgAyADKAIcNgIMIAMgBTYCCCMAQRBrIgUkACACKAIEIAIoAgBrQQJ2IgkgA0EIaiIGKAIAIAYoAggiB2tLBEAgBiAHIAlBEEEQEN4oIAYoAgghBwsgBSAGKAIENgIMIAUgBzYCCCAFIAZBCGo2AgQgAiAFQQRqEKsQIAVBEGokACABQQhqIAgoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCQGwsgACABELoYIARBMGokAAvgAwEGfyMAQTBrIgUkAAJAAkAgAxCSNiIERQ0AIAQoAhRFDQAgAygCECEGIAMoAhQhAyAFIAQ2AiAgBSACNgIcIAUgATYCGCAFQQA2AhQgBSAGIANBeHFqNgIQIAUgBjYCDCAFQSRqIQEjAEEgayIDJAAgA0EUaiAFQQxqIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgAigCBCACKAIAa0EDdiIIIANBCGoiBigCACAGKAIIIgdrSwRAIAYgByAIQRBBEBDeKCAGKAIIIQcLIAYoAgQhCCAEQRhqIAJBEGopAgA3AwAgBEEQaiACQQhqKQIANwMAIAQgAikCADcDCCAEIAg2AiwgBCAHNgIoIAQgBkEIajYCJCAEQQhqIARBJGoQrBAgBEEwaiQAIAFBCGogCSgCADYCACABIAMpAgg3AgAgA0EgaiQADAELIAMoAhAhBCADKAIUIQMgBSACNgIYIAUgATYCFCAFIAQgA0F4cWo2AhAgBSAENgIMIAVBJGoiASAFQQxqEJYbCyAAIAEQuhggBUEwaiQAC68DAQZ/IwBBMGsiBCQAAkACQCADEJI2IgVFDQAgBSgCFEUNACADKAIQIQYgAygCFCEDIAQgBTYCICAEIAI2AhwgBCABNgIYIARBADYCFCAEIAYgA0F8cWo2AhAgBCAGNgIMIARBJGohASMAQSBrIgMkACADQRRqIARBDGoiAigCBCACKAIAa0ECdkEAQRBBEBCgGCADKAIYIQUgAygCFEEBRgRAIAUgAygCHEG8/IEBEP0vAAsgA0EQaiIIQQA2AgAgAyADKAIcNgIMIAMgBTYCCCMAQRBrIgUkACACKAIEIAIoAgBrQQJ2IgkgA0EIaiIGKAIAIAYoAggiB2tLBEAgBiAHIAlBEEEQEN4oIAYoAgghBwsgBSAGKAIENgIMIAUgBzYCCCAFIAZBCGo2AgQgAiAFQQRqEKoQIAVBEGokACABQQhqIAgoAgA2AgAgASADKQIINwIAIANBIGokAAwBCyADKAIQIQUgAygCFCEDIAQgAjYCGCAEIAE2AhQgBCAFIANBfHFqNgIQIAQgBTYCDCAEQSRqIgEgBEEMahCQGwsgACABELoYIARBMGokAAvQAQEBfyMAQTBrIgQkACAEIAI2AgwgBCADNgIQAkAgASgCECACIANqTwRAIAEoAgghAiAEIAEoAgQiAzYCICAEIAMgAkEDdGo2AiQgBCAEQRBqNgIsIAQgBEEMajYCKCAEQRRqIARBIGpBwPaEARCfGyABKAIMIgEgASgCACICQQFqNgIAIAJBAEgNASAAIAE2AgwgACAEKQIUNwIAIAAgBCgCEDYCECAAQQhqIARBHGooAgA2AgAgBEEwaiQADwtB6P+EAUE2QaCAhQEQnykLAAu6AQEDfyMAQSBrIgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIEQQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFIAILNgIYIANBCGogBCADQRRqEKIbIAMoAghBAUcNASADKAIQIQUgAygCDAsgBUGowYkBEP0vAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC8oBAQF/IwBBMGsiAiQAAn8gAC0ABEEBRgRAIAIgAC0ABToAByACQQI2AhwgAkHQ+YkBNgIYIAJCAjcCJCACIACtQoCAgICwB4Q3AxAgAiACQQdqrUKAgICAsPcAhDcDCCACIAJBCGo2AiAgASgCACABKAIEIAJBGGoQywoMAQsgAkEBNgIcIAJBjPqJATYCGCACQgE3AiQgAiAArUKAgICAsAeENwMIIAIgAkEIajYCICABKAIAIAEoAgQgAkEYahDLCgsgAkEwaiQAC7wBAgR+An8jAEEQayIGJAAgBkIAIAB9IAAgAUIAUyIHGyIDQgAgASAAQgBSrXx9IAEgBxsiAiACeSADeUJAfSACQgBSGyIEp0H/AHEQxiMgBikDCCECIAYpAwAhAyAGQRBqJAAgAkILiCIFIAFCgICAgICAgICAf4OEQgBCgICAgICAgOjHACAEQjSGfSAAIAGEUBt8IANC/////w+DIAJCNYYiACADQguIhIQgBUJ/hSAAQj+Ig31CP4h8vwvRAQEBfwJAIAAoAlBBgICAgHhGDQAgACgCCEGAgICAeEcEQCAAQQhqEN47CyAAKAIUQYCAgIB4RwRAIABBFGoiARDgKSABEPI7CyAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSxqEIYfCyAAKAIgQYCAgIB4RwRAIABBIGoQ3jsLIABB0ABqIgEQ3BggARDsOyAAKAI4QYCAgIB4RwRAIABBOGoiARDGKiABEOg7CyAAKAJEQYCAgIB4Rg0AIABBxABqIgAQxyogABDoOwsL5gEBAn8CQCAAKAIARQ0AIABBBGohAgJAAkACQCAALQAsDgQAAgIBAgsgAigCACIBIAEoAgBBAWsiATYCACABRQRAIAIQ1CILIAAoAggiAkGEAUkNASACEPIfDAELAkACQAJAAkAgAC0AKA4EAAMDAQMLIAAoAhgiAUGDAU0NAgwBCyAAKAIgIgFBgwFNDQELIAEQ8h8LIAAoAhAiASABKAIAQQFqNgIAIAAoAgQiASABKAIAQQFrIgE2AgAgAQ0AIAIQ1CILIAAoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAAQ6ScLC8ABAQl/IAAgACgCCCICIAAoAgAiBElBA3RqIgYgAEEYQRAgACgCGCAAKAIQSSIFG2oiAyAAIAIgBE9BA3RqIgIgAEEQQRggBRtqIgAoAgAgAigCAEkiBBsgAygCACAGKAIASSIFGyIHKAIAIQkgACACIAMgBRsgBBsiCCgCACEKIAEgAyAGIAUbKQIANwIAIAEgCCAHIAkgCksiAxspAgA3AgggASAHIAggAxspAgA3AhAgASACIAAgBBspAgA3AhgLowECBX8BfiABBEAgAUEBRwRAIAAgAUEDdGohBiAAQQgiAWohAgNAIAIoAgAiBCACQQhrKAIASQRAIAI1AgQhByABIQMCfwNAIAAgA2oiBSAFQQhrKQIANwIAIAAgA0EIRg0BGiADQQhrIQMgBCAFQRBrKAIASQ0ACyAAIANqCyAErSAHQiCGhDcCAAsgAUEIaiEBIAJBCGoiAiAGRw0ACwsPCwAL4QEBAX8DQCAAKAIAIgJBH3UgAkH/////B2txIgJBAWtBA08EQAJAAkACQAJAAkAgAkEBaw4EAAAAAgELAAsgACgCDEGAgICAeEYNAiAAQQxqIAEoAgQoAgAgASgCACgCAGsiAiABKAIIIgEvAQJBAWsQqSUgACgCGEGAgICAeEYNASAAQRhqIAIgAS8BABCpJQ8LIAAoAgwiAkUNACAAKAIIIQAgAkHIAGwhAgNAIAAgARDWFiAAQcgAaiEAIAJByABrIgINAAsLDwtB5MPNABCyOwAFIAAoAgQhAAwBCwALAAveAQEBfwNAIAAoAgAiA0EfdSADQf////8Ha3EiA0EBa0EDTwRAAkACQAJAAkACQCADQQFrDgQAAAACAQsACyAAKAIYQYCAgIB4Rg0BIABBGGogAigCACICIAEvAQBBAWsQqSUgACgCDEGAgICAeEYNAiAAQQxqIAIgAS8BAkEBaxCpJQ8LIAAoAgwiAwRAIAAoAgghACADQcgAbCEDA0AgACABIAIQ1xYgAEHIAGohACADQcgAayIDDQALCw8LQaTEzQAQsjsAC0HExM0AELI7AAUgACgCBCEADAELAAsAC8cBAQF/IwBB0ABrIgMkACAAAn8gAkUEQEEAIQIgA0EANgI8IANBAjYCKCADQZi1zgA2AiQgA0ICNwIwIANBOzYCTCADQTs2AkQgA0Gstc4ANgJAIAMgA0FAazYCLCADIANBPGo2AkggA0EIakEEciADQSRqEJkOIAAgAykADTcABSAAQQ1qIANBFWopAAA3AAAgAEEUaiADQRxqKAAANgAAIAMtAAwMAQtBCCECIAEtAABBAEcLOgAEIAAgAjYCACADQdAAaiQAC8oBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCABIANqIAIgA2sQxiAiASAAKAIEIgJPDQEgACgCACABQQF0aiICLwEAQT9xIAFBBnRyIgEgACgCDCIDTw0CIAAoAgggAUECdGogBDYCACACIAIvAQBBAWo7AQAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpB/NXOABDvLAALIAEgAkGM1s4AEMMhAAsgASADQZzWzgAQwyEAC8oBAQF/IwBBIGsiBSQAAkACQCADIARxIgMgAk0EQCABIANqIAIgA2sQxyAiASAAKAIEIgJPDQEgACgCACABQQF0aiICLwEAQQ9xIAFBBHRyIgEgACgCDCIDTw0CIAAoAgggAUECdGogBDYCACACIAIvAQBBAWo7AQAgBUEgaiQADwsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpB/NXOABDvLAALIAEgAkGM1s4AEMMhAAsgASADQZzWzgAQwyEAC9IBAQZ/IAEoAgwhBCABKAIIIQUCQAJAAkACQCABKAIQIgMgASgCFCICRgRAIAEoAgAhBiABKAIEIgcgBCAEIAdLGyICQQFGDQEgAkUNAiAFIAYgAvwKAAAMAgsgAiADSQ0DIAIgBE0NAiACIARBhMbQABCwOwALIAUgBi0AADoAAAsgASACNgIUQQAhAyABQQA2AhAgASAHIAJrNgIEIAEgAiAGajYCAAsgAEEANgIAIAAgAiADazYCCCAAIAMgBWo2AgQPCyADIAJBhMbQABCxOwAL1QEBAX8gACgCyAEhBSAAKALMAUECTwRAAkACQAJAAkAgBUEFaw4DAQIDAAsgACABIAIgAyAEQQRBARCzBg8LIAAgASACIAMgBEEFQQEQswYPCyAAIAEgAiADIARBBkEBELMGDwsgACABIAIgAyAEQQdBARCzBg8LAkACQAJAAkAgBUEFaw4DAQIDAAsgACABIAIgAyAEQQRBABCzBg8LIAAgASACIAMgBEEFQQAQswYPCyAAIAEgAiADIARBBkEAELMGDwsgACABIAIgAyAEQQdBABCzBgu7AQEBfwJAIAAoAgwiBUUNACAAKAIEIAVPDQAgACgCGCIFIANNBEAgAyAFSwRAIAAgAyAFaxCIHwsgACADIAQQkRYgACgCGCEFCyADIAAoAhRJIAMgBU9yDQAgBSADayIEQQNJDQAgAigCACIDBEAgA0H/H0sNASAEIAEgA0EDdGpBBGsoAgBNDQELIAEgA0EDdGogBDYCBCABIAIoAgBBA3RqIAAoAhxBA2o2AgAgAiACKAIAQQFqNgIACwvAAQEBfyMAQSBrIgQkACAAIAAQgBogACADOwEUIAAgAjsBEiAAIAE7ARAgBEEUaiIBIANB//8DcSICELAVIARBCGogAUHUqPsAEJghIAAoAgQhASAAKAIAIQMgACAEKQMINwIAIAEEQCADIAFBAnRBBBD4OgsgBEEUaiIBIAJBuAhsEPcbIAQgAUHUqPsAEJYhIAAoAgwhASAAKAIIIQIgACAEKQMANwIIIAEEQCACIAFBAnRBAhD4OgsgBEEgaiQAC74BAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFCACEL0WIANBDGoiBCABEJI2IAIQ8hIgA0EkaiICIAMgBBDYHSADQdQAaiIEIAEQygYgBBCaHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC8AEAQh/IwBB4ABrIgUkACABKAIQIQQgASgCFCEIIwBBMGsiAyQAAkACQCACEJI2IgdFDQAgBygCFEUNACACKAIQIQYgAigCFCEJIAMgBzYCICADIAg2AhwgAyAENgIYIANBADYCFCADIAYgCUF8cWo2AhAgAyAGNgIMIANBJGohCCMAQSBrIgQkACAEQRRqIANBDGoiBygCBCAHKAIAa0ECdkEAQQFBARCgGCAEKAIYIQYgBCgCFEEBRgRAIAYgBCgCHEG8/IEBEP0vAAsgBEEQaiIKQQA2AgAgBCAEKAIcNgIMIAQgBjYCCCMAQRBrIgYkACAEQQhqIgkgBygCBCAHKAIAa0ECdhCELiAGIAkpAgRCIIk3AgggBiAJQQhqNgIEIAcgBkEEahCzESAGQRBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhBiADIAg2AhggAyAENgIUIAMgByAGQXxxajYCECADIAc2AgwgA0EkaiIIIANBDGoQnhsLIAUgCBDuGCADQTBqJAAgBUEMaiIDIAEQkjYgAhDyEiAFQSRqIgIgBSADEMEdIAVB1ABqIgMgARDKBiADEJseIABBCGogBUHcAGooAgA2AgAgACAFKQJUNwIAIAAgBSkCMDcCDCAAQRRqIAVBOGooAgA2AgAgACAFKQI8NwIYIABBIGogBUHEAGopAgA3AgAgAEEoaiAFQcwAaikCADcCACACELsMIAVB4ABqJAALvgEBAn8jAEHgAGsiAyQAIAMgASgCECABKAIUIAIQwRYgA0EMaiIEIAEQkjYgAhDyEiADQSRqIgIgAyAEENgdIANB1ABqIgQgARDKBiAEEJoeIABBCGogA0HcAGooAgA2AgAgACADKQJUNwIAIAAgAykCMDcCDCAAQRRqIANBOGooAgA2AgAgACADKQI8NwIYIABBIGogA0HEAGopAgA3AgAgAEEoaiADQcwAaikCADcCACACELsMIANB4ABqJAALwAQBCH8jAEHgAGsiBSQAIAEoAhAhBCABKAIUIQgjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhBiACKAIUIQkgAyAHNgIgIAMgCDYCHCADIAQ2AhggA0EANgIUIAMgBiAJQXxxajYCECADIAY2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQJ2QQBBAUEBEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIARBCGoiCSAHKAIEIAcoAgBrQQJ2EIQuIAYgCSkCBEIgiTcCCCAGIAlBCGo2AgQgByAGQQRqELIRIAZBEGokACAIQQhqIAooAgA2AgAgCCAEKQIINwIAIARBIGokAAwBCyACKAIQIQcgAigCFCEGIAMgCDYCGCADIAQ2AhQgAyAHIAZBfHFqNgIQIAMgBzYCDCADQSRqIgggA0EMahCeGwsgBSAIEO4YIANBMGokACAFQQxqIgMgARCSNiACEPISIAVBJGoiAiAFIAMQwR0gBUHUAGoiAyABEMoGIAMQmx4gAEEIaiAFQdwAaigCADYCACAAIAUpAlQ3AgAgACAFKQIwNwIMIABBFGogBUE4aigCADYCACAAIAUpAjw3AhggAEEgaiAFQcQAaikCADcCACAAQShqIAVBzABqKQIANwIAIAIQuwwgBUHgAGokAAu+AQECfyMAQeAAayIDJAAgAyABKAIQIAEoAhQgAhDFFiADQQxqIgQgARCSNiACEPMSIANBJGoiAiADIAQQ2B0gA0HUAGoiBCABEMoGIAQQmh4gAEEIaiADQdwAaigCADYCACAAIAMpAlQ3AgAgACADKQIwNwIMIABBFGogA0E4aigCADYCACAAIAMpAjw3AhggAEEgaiADQcQAaikCADcCACAAQShqIANBzABqKQIANwIAIAIQuwwgA0HgAGokAAvzBAIIfwF+IwBB4ABrIgYkACABKAIQIQQgASgCFCEFIwBBMGsiAyQAAkACQCACEJI2IgdFDQAgBygCFEUNACACKAIQIQggAigCFCEJIAMgBzYCICADIAU2AhwgAyAENgIYIANBADYCFCADIAggCUF4cWo2AhAgAyAINgIMIANBJGohCCMAQSBrIgQkACAEQRRqIANBDGoiBygCBCAHKAIAa0EDdkEAQQFBARCgGCAEKAIYIQUgBCgCFEEBRgRAIAUgBCgCHEG8/IEBEP0vAAsgBEEQaiIKQQA2AgAgBCAEKAIcNgIMIAQgBTYCCCMAQTBrIgUkACAEQQhqIgkgBygCBCAHKAIAa0EDdhCELiAJKQIEIQsgBUEYaiAHQRBqKQIANwMAIAVBEGogB0EIaikCADcDACAFIAcpAgA3AwggBSALQiCJNwIoIAUgCUEIajYCJCAFQQhqIAVBJGoQsBEgBUEwaiQAIAhBCGogCigCADYCACAIIAQpAgg3AgAgBEEgaiQADAELIAIoAhAhByACKAIUIQggAyAFNgIYIAMgBDYCFCADIAcgCEF4cWo2AhAgAyAHNgIMIANBJGoiCCADQQxqEJEbCyAGIAgQ7hggA0EwaiQAIAZBDGoiAyABEJI2IAIQ8xIgBkEkaiICIAYgAxDBHSAGQdQAaiIDIAEQygYgAxCbHiAAQQhqIAZB3ABqKAIANgIAIAAgBikCVDcCACAAIAYpAjA3AgwgAEEUaiAGQThqKAIANgIAIAAgBikCPDcCGCAAQSBqIAZBxABqKQIANwIAIABBKGogBkHMAGopAgA3AgAgAhC7DCAGQeAAaiQAC74BAQJ/IwBB4ABrIgMkACADIAEoAhAgASgCFCACEMkWIANBDGoiBCABEJI2IAIQ8xIgA0EkaiICIAMgBBDYHSADQdQAaiIEIAEQygYgBBCaHiAAQQhqIANB3ABqKAIANgIAIAAgAykCVDcCACAAIAMpAjA3AgwgAEEUaiADQThqKAIANgIAIAAgAykCPDcCGCAAQSBqIANBxABqKQIANwIAIABBKGogA0HMAGopAgA3AgAgAhC7DCADQeAAaiQAC/MEAgh/AX4jAEHgAGsiBiQAIAEoAhAhBCABKAIUIQUjAEEwayIDJAACQAJAIAIQkjYiB0UNACAHKAIURQ0AIAIoAhAhCCACKAIUIQkgAyAHNgIgIAMgBTYCHCADIAQ2AhggA0EANgIUIAMgCCAJQXhxajYCECADIAg2AgwgA0EkaiEIIwBBIGsiBCQAIARBFGogA0EMaiIHKAIEIAcoAgBrQQN2QQBBAUEBEKAYIAQoAhghBSAEKAIUQQFGBEAgBSAEKAIcQbz8gQEQ/S8ACyAEQRBqIgpBADYCACAEIAQoAhw2AgwgBCAFNgIIIwBBMGsiBSQAIARBCGoiCSAHKAIEIAcoAgBrQQN2EIQuIAkpAgQhCyAFQRhqIAdBEGopAgA3AwAgBUEQaiAHQQhqKQIANwMAIAUgBykCADcDCCAFIAtCIIk3AiggBSAJQQhqNgIkIAVBCGogBUEkahCxESAFQTBqJAAgCEEIaiAKKAIANgIAIAggBCkCCDcCACAEQSBqJAAMAQsgAigCECEHIAIoAhQhCCADIAU2AhggAyAENgIUIAMgByAIQXhxajYCECADIAc2AgwgA0EkaiIIIANBDGoQkRsLIAYgCBDuGCADQTBqJAAgBkEMaiIDIAEQkjYgAhDzEiAGQSRqIgIgBiADEMEdIAZB1ABqIgMgARDKBiADEJseIABBCGogBkHcAGooAgA2AgAgACAGKQJUNwIAIAAgBikCMDcCDCAAQRRqIAZBOGooAgA2AgAgACAGKQI8NwIYIABBIGogBkHEAGopAgA3AgAgAEEoaiAGQcwAaikCADcCACACELsMIAZB4ABqJAAL2nICEX8CfiMAQSBrIg4kACAOQQxqIAEQuQECQCAOKAIMIgNBk4CAgHhHBEAgACAOKQIQNwIEIABBDGogDkEYaikCADcCAAwBCyAOQQxqIQIjAEFAaiIDJAAgAUEsaiEEAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIsIgcEQCADIAEoAjwgBBDnOmsiBjYCDCAGIAEoAkAiBUcNAQsgAS0AGCIGQRtrDgYHCAEHCAIGCyADIAU2AhAgA0EDNgIYIANBlPqGATYCFCADQgI3AiAgA0E7NgI4IANBOzYCMCADIANBLGo2AhwgAyADQQxqNgI0IAMgA0EQajYCLCACQQRqIANBFGoQmQ4gAkGNgICAeDYCAAwJCyABKAIURQ0BIAEoAiAtAEgNBiABKAIQIQYgB0UNAyADQRRqIgUgBCABKAIcEIoOIANBLGogASAFIAYQghUgAygCLCIGQZOAgIB4Rg0CIAIgAykCMDcCBCACQQxqIANBOGopAgA3AgAgAiAGNgIAIAMoAhQiAiACKAIAIgJBAWs2AgAgAkEBRw0IIAUQ+x4MCAsgAyABQRxqEMM0IAEoAhAhBSABKAIUIQggAygCBCEJIAMgAygCACIGNgIUIAMgBiAJQQJ0ajYCGCAIIANBFGoQnjYiCSAIIAlJGyIIRQ0FIARBACAHGyEEA0ACQCAGKAIALQBIDQAgA0EUaiABIAQgBRCCFSADKAIUIgdBk4CAgHhGDQAgAiADKQIYNwIEIAJBDGogA0EgaikCADcCACACIAc2AgAMCQsgBkEEaiEGIAVBxABqIQUgCEEBayIIDQALDAULQQBBAEGs+oYBEMMhAAsgAygCFCIGIAYoAgAiBkEBazYCACAGQQFHDQMgA0EUahD7HgwDCyADQRRqIAFBACAGEIIVIAMoAhQiBkGTgICAeEYNAiACIAMpAhg3AgQgAkEMaiADQSBqKQIANwIAIAIgBjYCAAwECyAGQSdHDQELIAEoAhwtAEgNACABKAIURQ0BIANBFGogAUEAIAEoAhAQghUgAygCFCIGQZOAgIB4Rg0AIAIgAykCGDcCBCACQQxqIANBIGopAgA3AgAgAiAGNgIADAILIAJBk4CAgHg2AgAMAQtBAEEAQbz6hgEQwyEACyADQUBrJAAgDigCDCIDQZOAgIB4RwRAIAAgDikCEDcCBCAAQQxqIA5BGGopAgA3AgAMAQsgDkEMaiEGQQAhCEEAIQdBACEFQQAhCSMAQYACayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AGEEUaw4VAAgBCQIDCgQICAUICAYHCAgICAQUCAsgASgCCCIDQQFNDRQgBiABIAEoAgQoAhQQsQoMKAsgASgCCCIDQQFNDRQgBiABIAEoAgQoAhQQsgoMJwsgASgCCCIDQQFNDRQgAkEIaiABKAIEQQxqENw7IAJB6ABqIAIoAggiBCACKAIMIgMQnQkgAigCaEEBRgRAIAIgAzYCfCACIAQ2AnggAiADNgJ0IAJBIGogARCPJyACKAIoIQQgAigCJCEBIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgATYCBCAGIAU2AgAMKAsgAkIANwL4ASACIAEgBEECdGo2AuwBIAIgAkH0AGo2AvQBIAQEQCACQfwBaiEEIAJB+AFqIQUgAkEBNgLwASACIAFBBGo2AugBIAJBADYCmAEgAiABNgKcAQJ/IAEoAgAiAUEASARAIAJBAjYCJCACQcT+hgE2AiAgAkICNwIsIAJBOzYCrAEgAkGpCDYCpAEgAiACQaABajYCKCACIAJBmAFqNgKoASACIAJBnAFqNgKgASACQbgBaiACQSBqEJkOIAJB5AFqIAJBxAFqKAIANgIAIAIgAikCvAE3AtwBIAIoArgBDAELIAEgA00NJyACQQM2ArgBIAJB4P2GATYCtAEgAkIDNwLAASACQTs2AjQgAkGpCDYCLCACQTs2AiQgAiACQSBqNgK8ASACIAJB9ABqNgIwIAIgAkGcAWo2AiggAiACQZgBajYCICACQdgBaiACQbQBahCZDiACKALYAQshASACIAIpAuABNwKMASACIAIoAtwBNgKIASACIAE2AoQBIAJBjYCAgHg2AoABIAJBgAFqEIgRDCcLIAZBk4CAgHg2AgAMJwsgAiACKQJsNwJ4IAIgAzYCdCACQSBqIAEQjycgAigCKCEEIAIoAiQhASACKAIgIgVBk4CAgHhHBEAgBiACKQIsNwIMIAYgBDYCCCAGIAE2AgQgBiAFNgIADCcLIAJCADcC+AEgAiABIARBAnRqNgLsASACIAJB9ABqNgL0ASAEBEAgAkH8AWohBCACQfgBaiEFIAJBATYC8AEgAiABQQRqNgLoASACQQA2ApgBIAIgATYCnAECfyABKAIAIgFBAEgEQCACQQI2AiQgAkHE/oYBNgIgIAJCAjcCLCACQTs2AqwBIAJBqQg2AqQBIAIgAkGgAWo2AiggAiACQZgBajYCqAEgAiACQZwBajYCoAEgAkG4AWogAkEgahCZDiACQeQBaiACQcQBaigCADYCACACIAIpArwBNwLcASACKAK4AQwBCyABIANNDSQgAkEDNgK4ASACQeD9hgE2ArQBIAJCAzcCwAEgAkE7NgI0IAJBqQg2AiwgAkE7NgIkIAIgAkEgajYCvAEgAiACQfQAajYCMCACIAJBnAFqNgIoIAIgAkGYAWo2AiAgAkHYAWogAkG0AWoQmQ4gAigC2AELIQEgAiACKQLgATcCjAEgAiACKALcATYCiAEgAiABNgKEASACQY2AgIB4NgKAASACQYABahCIEQwkCyAGQZOAgIB4NgIADCYLIAEoAggiA0EBTQ0UIAJBEGogASgCBEEMahDcOyACQegAaiACKAIQIgQgAigCFCIDEJ0JIAIoAmhBAUYEQCACIAM2AnwgAiAENgJ4IAIgAzYCdCACQSBqIAEQkCcgAigCKCEEIAIoAiQhASACKAIgIgVBk4CAgHhHBEAgBiACKQIsNwIMIAYgBDYCCCAGIAE2AgQgBiAFNgIADCcLIAJCADcC+AEgAiABIARBA3RqNgLsASACIAJB9ABqNgL0ASAEBEAgAkH8AWohBCACQfgBaiEFIAJBATYC8AEgAiABQQhqNgLoASACQQA2ApgBIAIgATYCnAECfyABKQMAIhNCgICAgBBaBEAgAkECNgIkIAJBxP6GATYCICACQgI3AiwgAkE7NgKsASACQccQNgKkASACIAJBoAFqNgIoIAIgAkGYAWo2AqgBIAIgAkGcAWo2AqABIAJBuAFqIAJBIGoQmQ4gAkHkAWogAkHEAWooAgA2AgAgAiACKQK8ATcC3AEgAigCuAEMAQsgAyATpyIBTw0iIAJBAzYCuAEgAkHg/YYBNgK0ASACQgM3AsABIAJBOzYCNCACQccQNgIsIAJBOzYCJCACIAJBIGo2ArwBIAIgAkH0AGo2AjAgAiACQZwBajYCKCACIAJBmAFqNgIgIAJB2AFqIAJBtAFqEJkOIAIoAtgBCyEBIAIgAikC4AE3AowBIAIgAigC3AE2AogBIAIgATYChAEgAkGNgICAeDYCgAEgAkGAAWoQiBEMIgsgBkGTgICAeDYCAAwmCyACIAIpAmw3AnggAiADNgJ0IAJBIGogARCQJyACKAIoIQQgAigCJCEBIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgATYCBCAGIAU2AgAMJgsgAkIANwL4ASACIAEgBEEDdGo2AuwBIAIgAkH0AGo2AvQBIAQEQCACQfwBaiEEIAJB+AFqIQUgAkEBNgLwASACIAFBCGo2AugBIAJBADYCmAEgAiABNgKcAQJ/IAEpAwAiE0KAgICAEFoEQCACQQI2AiQgAkHE/oYBNgIgIAJCAjcCLCACQTs2AqwBIAJBxxA2AqQBIAIgAkGgAWo2AiggAiACQZgBajYCqAEgAiACQZwBajYCoAEgAkG4AWogAkEgahCZDiACQeQBaiACQcQBaigCADYCACACIAIpArwBNwLcASACKAK4AQwBCyADIBOnIgFPDR8gAkEDNgK4ASACQeD9hgE2ArQBIAJCAzcCwAEgAkE7NgI0IAJBxxA2AiwgAkE7NgIkIAIgAkEgajYCvAEgAiACQfQAajYCMCACIAJBnAFqNgIoIAIgAkGYAWo2AiAgAkHYAWogAkG0AWoQmQ4gAigC2AELIQEgAiACKQLgATcCjAEgAiACKALcATYCiAEgAiABNgKEASACQY2AgIB4NgKAASACQYABahCIEQwfCyAGQZOAgIB4NgIADCULIAEoAhRFDRQgBiABIAEoAhAoAiQQsQoMJAsgASgCFEUNFCAGIAEgASgCECgCJBCyCgwjCyAGQZOAgIB4NgIADCILIAEoAhRFDRMgASgCEDUCJEIBfSETIAEoAhwtAABBAmsOCAQFBgcICQoLAwsgBkGTgICAeDYCAAwgCyACQSBqIAEgASgCJBD5ESACKAIoIQQgAigCJCEDIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiAENgIIIAYgAzYCBCAGIAU2AgAMIAsgASgCCCIFRQ0SIAEoAgRBDGohDSAFQQFrIQkjAEGQAWsiASQAAkAgBARAIARBBHQhBSABQShqIQoDQCABIAc2AhggASADKQMAIhSnIgQ2AhwgAykDCCETAkACQCAEQQ1PBEAgASAENgIgIAEgFEIgiD4CJCABIBOnIgs2AiggASATQiCIpyIINgIsIAkgC00EQCABIAk2AmQgAUGsx4cBNgJMIAFCAzcCWCABQTs2AnwgAUE7NgJ0IAEgCjYCcCABQTs2AmwgASABQegAajYCVCABIAFB5ABqNgJ4IAEgAUEYajYCaCABQQQ2AlAgAUE8aiABQcwAahCZDiAGIAEpAkA3AgggBkEQaiABQcgAaigCADYCACAGIAEoAjw2AgQgBkGNgICAeDYCAAwGCyABIAg2AjAgASAEIAhqIgw2AjQgAUEQaiANIAtBDGxqIgsQ3DsCQAJAIAggDEsNACAMIAEoAhRLDQAgASgCECIMDQELIAEgCygCCDYCZCABQQU2AlAgAUGEyIcBNgJMIAFCBTcCWCABQTs2AowBIAFBOzYChAEgASAKNgKAASABQTs2AnwgAUE7NgJ0IAFBOzYCbCABIAFB6ABqNgJUIAEgAUHkAGo2AogBIAEgAUE0ajYCeCABIAFBMGo2AnAgASABQRhqNgJoIAFBPGogAUHMAGoQmQ4gASkCPCETIAYgASkCRDcCDCAGIBM3AgQgBkGNgICAeDYCAAwGCyABIAEoAiQ2AmggCCAMaiAEIAFB6ABqIgRBBBD0Lg0CIARBKUEAQQFBARCgGCABKAJsIQMgASgCaEEBRg0BIAEoAnAiBEH4xYcBQSn8CgAAIAZBKTYCDCAGIAQ2AgggBiADNgIEIAZBjYCAgHg2AgAMBQsgBEEMRg0BIAEgFCATIARBA3RBIGoQxyMgASkDACABKQMIhFANASABQQI2AmwgAUHgxocBNgJoIAFCAjcCdCABQTs2AlggAUE7NgJQIAEgAUHMAGo2AnAgASABQRxqNgJUIAEgAUEYajYCTCAGQQRqIAFB6ABqEJkOIAZBjYCAgHg2AgAMBAsgAyABKAJwQaDEhwEQ/S8ACyADQRBqIQMgB0EBaiEHIAVBEGsiBQ0ACwsgBkGTgICAeDYCAAsgAUGQAWokAAwfCyACQSBqIAEgASgCJBD5ESACKAIoIQMgAigCJCEEIAIoAiAiBUGTgICAeEcEQCAGIAIpAiw3AgwgBiADNgIIIAYgBDYCBCAGIAU2AgAMHwsgASgCCCIFRQ0SIAYgBCADIAEoAgRBDGogBUEBaxDiBgweC0G4/IYBQShB4PyGARCfKQALIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghLDSAgAyAIEI8fIAQgBUkNISAEIAMoAgQiCEsNIkGTgICAeCEEAkAgB0UNACADKAIAIAVqIQggASgCOCEJIAEoAjAhCiABKAI8IQsgASgCLCEMQQAhAQNAIAMgATYCJCABIAhqLAAAIQUCQCAMBEAgASALTw0nIAogASAJaiINQQN2ai0AACANQQdxdkEBcUUNAQsgAyAFrCIUNwMoIAVBAE4gEyAUWXENACADQYCAhwE2AjAgA0IDNwI8IANB7gY2AlwgA0HuBjYCVCADQTs2AkwgAyADQcgAajYCOCADIANBCGo2AlggAyADQShqNgJQIAMgA0EkajYCSCADQQQ2AjQgA0EUaiADQTBqEJkOIAZBDGogA0EcaikCADcCACAGIAMpAhQ3AgRBjYCAgHghBAwCCyAHIAFBAWoiAUcNAAsLIAYgBDYCACADQeAAaiQADAELDB4LDBwLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAXZLDR8gAyAIEMYbIAQgBUkNICAEIAMoAgQiCEsNIUGTgICAeCEIAkAgB0UNACADKAIAIAVBAXRqIQQgB0EBdCEFIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDEEAIQEDQCADIAE2AiQgBC4BACEHAkAgDARAIAEgC08NJiAKIAEgCWoiDUEDdmotAAAgDUEHcXZBAXFFDQELIAMgB6wiFDcDKCAHQQBOIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEECaiEEIAFBAWohASAFQQJrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDB0LDBsLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAnZLDR4gAyAIEMcbIAQgBUkNHyAEIAMoAgQiCEsNIEGTgICAeCEIAkAgB0UNACADKAIAIAVBAnRqIQQgB0ECdCEFIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDEEAIQEDQCADIAE2AiQgBCgCACEHAkAgDARAIAEgC08NJSAKIAEgCWoiDUEDdmotAAAgDUEHcXZBAXFFDQELIAMgB6wiFDcDKCAHQQBOIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEEaiEEIAFBAWohASAFQQRrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBwLDBoLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBA3ZLDR0gAyAIEMUbIAQgBUkNHiAEIAMoAgQiCEsNH0GTgICAeCEIAkAgB0UNACADKAIAIAVBA3RqIQQgB0EDdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBCkDACEUAkAgCwRAIAEgCk8NJCAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCAUQgBZIBMgFFlxDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEIaiEEIAFBAWohASAFQQhrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBsLDBkLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghLDRwgAyAIEI8fIAQgBUkNHSAEIAMoAgQiCEsNHkGTgICAeCEEAkAgB0UNACADKAIAIAVqIQUgASgCOCEIIAEoAjAhCSABKAI8IQogASgCLCELQQAhAQNAIAMgATYCJCABIAVqMQAAIRQCQCALBEAgASAKTw0jIAkgASAIaiIMQQN2ai0AACAMQQdxdkEBcUUNAQsgAyAUNwMoIBMgFFkNACADQYCAhwE2AjAgA0IDNwI8IANB7gY2AlwgA0HuBjYCVCADQTs2AkwgAyADQcgAajYCOCADIANBCGo2AlggAyADQShqNgJQIAMgA0EkajYCSCADQQQ2AjQgA0EUaiADQTBqEJkOIAZBDGogA0EcaikCADcCACAGIAMpAhQ3AgRBjYCAgHghBAwCCyAHIAFBAWoiAUcNAAsLIAYgBDYCACADQeAAaiQADAELDBoLDBgLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAXZLDRsgAyAIEMYbIAQgBUkNHCAEIAMoAgQiCEsNHUGTgICAeCEIAkAgB0UNACADKAIAIAVBAXRqIQQgB0EBdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBDMBACEUAkAgCwRAIAEgCk8NIiAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCATIBRZDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEECaiEEIAFBAWohASAFQQJrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBkLDBcLIwBB4ABrIgMkACADIBM3AwgCQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBAnZLDRogAyAIEMcbIAQgBUkNGyAEIAMoAgQiCEsNHEGTgICAeCEIAkAgB0UNACADKAIAIAVBAnRqIQQgB0ECdCEFIAEoAjghByABKAIwIQkgASgCPCEKIAEoAiwhC0EAIQEDQCADIAE2AiQgBDUCACEUAkAgCwRAIAEgCk8NISAJIAEgB2oiDEEDdmotAAAgDEEHcXZBAXFFDQELIAMgFDcDKCATIBRZDQAgA0GAgIcBNgIwIANCAzcCPCADQe4GNgJcIANB7gY2AlQgA0E7NgJMIAMgA0HIAGo2AjggAyADQQhqNgJYIAMgA0EoajYCUCADIANBJGo2AkggA0EENgI0IANBFGogA0EwahCZDiAGQQxqIANBHGopAgA3AgAgBiADKQIUNwIEQY2AgIB4IQgMAgsgBEEEaiEEIAFBAWohASAFQQRrIgUNAAsLIAYgCDYCACADQeAAaiQADAELDBgLDBYLIwBBgAFrIgMkACADIBM3AxACQCABKAIIBEAgASgCKCIFIAEoAiQiB2oiBCABKAIEIggoAghBA3ZLDRkgA0EIaiAIEJskIAQgBUkNGiAEIAMoAgwiCEsNG0GTgICAeCEIAkAgB0UNACADKAIIIAVBA3RqIQQgB0EDdCEHIAEoAjghCSABKAIwIQogASgCPCELIAEoAiwhDCADQcQAaiENIANBHGohBUEAIQEDQCADIAE2AiwgAyAEKQMAIhQ3AzACQCAMBEAgASALTw0gIAogASAJaiIPQQN2ai0AACAPQQdxdkEBcUUNAQsCQCAUQgBTBEAgA0EDNgJcIANBvICHATYCWCADQgI3AmQgA0E8NgJ8IANBOzYCdCADIANB8ABqNgJgIAMgA0EwajYCeCADIANBLGo2AnAgDSADQdgAahCZDiADIAMpAkw3AiQgAyADKQJENwIcDAELIAMgFDcDOCATIBRZDQEgA0EENgJEIANBgICHATYCQCADQgM3AkwgA0HuBjYCbCADQe4GNgJkIANBOzYCXCADIANB2ABqNgJIIAMgA0EQajYCaCADIANBOGo2AmAgAyADQSxqNgJYIAUgA0FAaxCZDgsgBkEMaiAFQQhqKQIANwIAIAYgBSkCADcCBEGNgICAeCEIDAILIARBCGohBCABQQFqIQEgB0EIayIHDQALCyAGIAg2AgAgA0GAAWokAAwBCwwXCwwVCwJAAkACQAJAAkAgASgCFARAIAJB1AFqIAEoAhAiA0EYahDaBiADKAIoIQQgAygCJCEKIAJB6AFqIAMQvhUgAkG0AWogA0EMahCACyADKAIsIgcEQCAHIAcoAgAiBUEBajYCACAFQQBIDRAgAygCQCEIIAMoAjwhBSADKAI4IQkgAygCNCELIAMoAjAhAwsgAkFAayACQdwBaigCADYCACACQShqIAJB8AFqKAIANgIAIAJBNGogAkG8AWooAgA2AgAgAiACKQLUATcDOCACIAQ2AkggAiAKNgJEIAIgAikC6AE3AyAgAiACKQK0ATcCLCACIAg2AmAgAiAFNgJcIAIgCTYCWCACIAs2AlQgAiADNgJQIAIgBzYCTCABKAIcLQAwQQNrDgMCAwQBC0EAQQBBgP2GARDDIQALQbj8hgFBKEGQ/YYBEJ8pAAsgAkEANgJoIAIoAihFDQ0gAiAEIApqIgdBAXQiATYCoAECQCABIAIoAiQiAygCCCIFTQRAIAJBGGogAxDGGyAEIAdLDRAgByACKAIcIgFNDQEgByABQeDshgEQsDsACyACIAU2AoABIAJBpO2GATYC6AEgAkIENwL0ASACQTs2AtABIAJBOzYCyAEgAkGtAzYCwAEgAiACQThqNgK8ASACQTs2ArgBIAIgAkG0AWo2AvABIAIgAkGAAWo2AswBIAIgAkGgAWo2AsQBIAIgAkHoAGo2ArQBIAJBBDYC7AEgAkHYAWogAkHoAWoQmQ4gAikC2AEhEyAGIAIpAuABNwIMIAYgEzcCBCAGQY2AgIB4NgIADAMLIAIoAhghASACQgA3A6ABAkACQCAKRQRAQQAhBQwBCyABIARBAXRqIQMgCkEBdCEEQQAhAQNAIAIgATYCaCACIAMvAQAiBa3DIhQ3A4ABAkACQCAFwUEASgRAIAFFIBMgFFNyDQIgAiATNwOgASACQYyDhwE2AugBIAJCAzcC9AEgAkHuBjYCyAEgAkE7NgLAASACQe4GNgK4ASACIAJBtAFqNgLwASACIAJBoAFqNgLEASACIAJB6ABqNgK8ASACIAJBgAFqNgK0ASACQQQ2AuwBIAJB2AFqIAJB6AFqEJkODAELIAIgEzcDoAEgAkEDNgK4ASACQfSDhwE2ArQBIAJCAjcCwAEgAkE7NgL0ASACQe4GNgLsASACIAJB6AFqNgK8ASACIAJB6ABqNgLwASACIAJBgAFqNgLoASACQdgBaiACQbQBahCZDgsgBiACKQLYATcCBCAGQQxqIAJB4AFqKQIANwIADAMLIANBAmohAyABQQFqIQEgFCETIARBAmsiBA0ACyACIBM3A6ABCyAFIAdPBEAgBkGTgICAeDYCAAwECyACIAc2AtQBIAJBAzYCuAEgAkH0gYcBNgK0ASACQgI3AsABIAJBOzYC9AEgAkHuBjYC7AEgAiACQegBajYCvAEgAiACQdQBajYC8AEgAiACQaABajYC6AEgBkEEaiACQbQBahCZDgsgBkGNgICAeDYCAAwCC0EAIQQgAkG0AWogAkEgakEAIAoQnxEgAigCvAEhASACKAK4ASEDIAIoArQBIgVBk4CAgHhHBEAgBiACKQLAATcCDCAGIAE2AgggBiADNgIEIAYgBTYCAAwCCyACQgA3A6ABAkAgAQRAIAFBAnQhB0EAIQEDQCACIAE2AmggAiADKAIAIgSsIhQ3A4ABAkACQCAEQQBKBEAgAUUgEyAUU3INAiACIBM3A6ABIAJBjIOHATYC6AEgAkIDNwL0ASACQe4GNgLIASACQTs2AsABIAJB7gY2ArgBIAIgAkG0AWo2AvABIAIgAkGgAWo2AsQBIAIgAkHoAGo2ArwBIAIgAkGAAWo2ArQBIAJBBDYC7AEgAkHYAWogAkHoAWoQmQ4MAQsgAiATNwOgASACQQM2ArgBIAJB9IOHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHoAGo2AvABIAIgAkGAAWo2AugBIAJB2AFqIAJBtAFqEJkOCyAGIAIpAtgBNwIEIAZBDGogAkHgAWopAgA3AgAMAwsgA0EEaiEDIAFBAWohASAUIRMgB0EEayIHDQALIAIgEzcDoAELIAQgAigCSCAKaiIBTwRAIAZBk4CAgHg2AgAMAwsgAiABNgLUASACQQM2ArgBIAJB9IGHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHUAWo2AvABIAIgAkGgAWo2AugBIAZBBGogAkG0AWoQmQ4LIAZBjYCAgHg2AgAMAQtBACEHIAJBtAFqIAJBIGpBACAKEJ4RIAIoArwBIQEgAigCuAEhAyACKAK0ASIEQZOAgIB4RwRAIAYgAikCwAE3AgwgBiABNgIIIAYgAzYCBCAGIAQ2AgAMAQsgAkIANwOgAQJAIAEEQCABQQN0IQRBACEBA0AgAiABNgJoIAIgAykDACIUNwOAAQJAAkAgFEIAVQRAIAFFIBMgFFNyDQIgAiATNwOgASACQYyDhwE2AugBIAJCAzcC9AEgAkHuBjYCyAEgAkE7NgLAASACQe4GNgK4ASACIAJBtAFqNgLwASACIAJBoAFqNgLEASACIAJB6ABqNgK8ASACIAJBgAFqNgK0ASACQQQ2AuwBIAJB2AFqIAJB6AFqEJkODAELIAIgEzcDoAEgAkEDNgK4ASACQfSDhwE2ArQBIAJCAjcCwAEgAkE7NgL0ASACQe4GNgLsASACIAJB6AFqNgK8ASACIAJB6ABqNgLwASACIAJBgAFqNgLoASACQdgBaiACQbQBahCZDgsgBiACKQLYATcCBCAGQQxqIAJB4AFqKQIANwIADAMLIANBCGohAyABQQFqIQEgFCETIARBCGsiBA0ACyACIBM3A6ABIBOnIQcLIAcgAigCSCAKaiIBTwRAIAZBk4CAgHg2AgAMAgsgAiABNgLUASACQQM2ArgBIAJB9IGHATYCtAEgAkICNwLAASACQTs2AvQBIAJB7gY2AuwBIAIgAkHoAWo2ArwBIAIgAkHUAWo2AvABIAIgAkGgAWo2AugBIAZBBGogAkG0AWoQmQ4LIAZBjYCAgHg2AgALIAJBIGoQpB4MFAtBASADQdj7hgEQwyEAC0EBIANB6PuGARDDIQALQQEgA0HU/oYBEMMhAAtBASADQdT+hgEQwyEAC0EAQQBB8PyGARDDIQALQQBBAEGY/IYBEMMhAAtBAEEAQaj8hgEQwyEAC0EBQQBB+PuGARCvOwALQQFBAEGI/IYBEK87CwALQQBBAEHQ7IYBEMMhAAsgBCAHQeDshgEQsTsACyACIAE2AvgBCyACIAU2ArgBIAIgBDYCtAEgAiACQfgAajYCvAEgAkEgaiELIAJBtAFqIQUjAEHwAGsiASQAQZSAgIB4IQgCQCACQegBaiIEKAIAIgMgBCgCBCIRRg0AIAUoAgghDSAFKAIEIQwgBCgCDCEPIAQoAgghBwJAAn8CQANAIAEgBzYCTCABIAM2AmggAykDACITQoCAgIAQWgRAIAQgA0EIajYCACABQQI2AlQgAUGAh4cBNgJQIAFCAjcCXCABQTs2AiggAUHHEDYCICABIAFBHGo2AlggASABQcwAajYCJCABIAFB6ABqNgIcIAFBOGogAUHQAGoQmQ4gAUEYaiABQcQAaigCADYCACABIAEpAjw3AhAgASgCOCEDDAILIBOnIgUgDygCAEsEQCAEIANBCGo2AgAgAUEDNgI4IAFBnIaHATYCNCABQgM3AkAgAUE7NgJkIAEgDzYCYCABQccQNgJcIAFBOzYCVCABIAFB0ABqNgI8IAEgAUHoAGo2AlggASABQcwAajYCUCABQQxqIAFBNGoQmQ4gASgCDCEDDAILIAEgDDYCMCAFIAwoAgAiCUkEQCAEIANBCGo2AgAgASAFNgJMIAEgB0EBazYCaCABQQM2AjggAUHMh4cBNgI0IAFCAzcCQCABQTs2AmQgAUH/GzYCXCABQTs2AlQgASABQdAAajYCPCABIAFBzABqNgJgIAEgAUEwajYCWCABIAFB6ABqNgJQIAFBIGogAUE0ahCZDiABKAIgIQMgASgCKCEFIAEoAiwhCCABKAIkDAMLIAwgBTYCACABIAdBAWsiEjYCTCANKAIEIQogDSgCACEQAkACQAJAIAlFDQAgCSAKTwRAIAkgCkYNAQwCCyAJIBBqLAAAQUBIDQELIBNQDQEgBSAKTwRAIAUgCkcNAQwCCyAFIBBqLAAAQb9/Sg0BCyAEIANBCGo2AgAgAUEBNgJUIAFBkIiHATYCUCABQgE3AlwgAUE7NgJsIAEgAUHoAGo2AlggASABQcwAajYCaCABQThqIAFB0ABqEJkODAQLIAQgEkECaiIHNgIIIANBCGoiAyARRw0ACyAEIAM2AgAMAwsgASkCFCITQiCIpyEIIBOnIQUgASgCEAshCSABIAg2AkQgASAFNgJAIAEgCTYCPCABIAM2AjgLIAsgASkCODcCBCALQQxqIAFBQGspAgA3AgAgBCAHQQFqNgIIQY2AgIB4IQgLIAsgCDYCACABQfAAaiQAIAIoAiBBlICAgHhHBEAgBiACKQIgNwIAIAZBEGogAkEwaigCADYCACAGQQhqIAJBKGopAgA3AgAMBwsgBkGTgICAeDYCAAwGCyACIAE2AvgBCyACIAU2ArgBIAIgBDYCtAEgAiACQfgAajYCvAEgAkG0AWohAyMAQZABayIEJAACQCACQSBqIgoCfgJ/AkACQCACQegBaiIIKAIAIgEgCCgCBCINRwRAIAMoAgghCyADKAIEIQUgCCgCDCEMIAgoAgghBwNAIAggAUEIaiIDNgIAIAQgBzYCOCAEIAE2AhggASkDACITQoCAgIAQWgRAIARBAjYCfCAEQYCHhwE2AnggBEICNwKEASAEQTs2AlAgBEHHEDYCSCAEIARBxABqNgKAASAEIARBOGo2AkwgBCAEQRhqNgJEIARB5ABqIARB+ABqEJkOIARBFGogBEHwAGooAgA2AgAgBCAEKQJoNwIMIAQoAmQhAQwECyATpyIBIAwoAgBLBEAgBEEDNgJkIARBnIaHATYCYCAEQgM3AmwgBEE7NgKMASAEIAw2AogBIARBxxA2AoQBIARBOzYCfCAEIARB+ABqNgJoIAQgBEEYajYCgAEgBCAEQThqNgJ4IARBCGogBEHgAGoQmQ4gBCgCCCEBDAQLIAQgBTYCWCAFKAIAIgkgAUsEQCAEIAE2AjggBCAHQQFrNgJEIARBAzYCZCAEQcyHhwE2AmAgBEIDNwJsIARBOzYCjAEgBEH/GzYChAEgBEE7NgJ8IAQgBEH4AGo2AmggBCAEQThqNgKIASAEIARB2ABqNgKAASAEIARBxABqNgJ4IARBHGogBEHgAGoQmQ4gBCgCKCEDIAQoAiQhBSAEKAIcIQEgBCgCIAwFCyAFIAE2AgAgBCABNgI0IAQgCTYCMCAEIAdBAWs2AiwgCygCBCIPIAFJDQIgBEE4aiALKAIAIAlqIAEgCWsQnQkgBCgCOEEBRgRAIAQgBCkCPDcDWCAEQQM2AmQgBEHUiIcBNgJgIARCAzcCbCAEQbADNgKMASAEQaQDNgKEASAEQTs2AnwgBCAEQfgAajYCaCAEIARB2ABqNgKIASAEIARBMGo2AoABIAQgBEEsajYCeCAEQcgAaiAEQeAAahCZDiAEKAJIIQEgBCgCTCEJIAQpAlAMBgsgCCAHQQFqIgc2AgggAyIBIA1HDQALCyAKQZSAgIB4NgIADAQLIAEgD0GYiIcBELA7AAsgBCkCECITQiCIpyEDIBOnIQUgBCgCDAshCSAFrSADrUIghoQLNwIMIAogCTYCCCAKIAE2AgQgCkGNgICAeDYCACAIIAdBAWo2AggLIARBkAFqJAAgAigCIEGUgICAeEcEQCAGIAIpAiA3AgAgBkEQaiACQTBqKAIANgIAIAZBCGogAkEoaikCADcCAAwFCyAGQZOAgIB4NgIADAQLIAIgATYC+AELIAIgBTYCuAEgAiAENgK0ASACIAJB+ABqNgK8ASACQSBqIQsgAkG0AWohBSMAQfAAayIBJABBlICAgHghCAJAIAJB6AFqIgQoAgAiAyAEKAIEIhFGDQAgBSgCCCENIAUoAgQhDCAEKAIMIQ8gBCgCCCEHAkACfwJAA0AgASAHNgJMIAEgAzYCaCADKAIAIgVBAEgEQCAEIANBBGo2AgAgAUECNgJUIAFBgIeHATYCUCABQgI3AlwgAUE7NgIoIAFBqQg2AiAgASABQRxqNgJYIAEgAUHMAGo2AiQgASABQegAajYCHCABQThqIAFB0ABqEJkOIAFBGGogAUHEAGooAgA2AgAgASABKQI8NwIQIAEoAjghBQwCCyAPKAIAIAVJBEAgBCADQQRqNgIAIAFBAzYCOCABQZyGhwE2AjQgAUIDNwJAIAFBOzYCZCABIA82AmAgAUGpCDYCXCABQTs2AlQgASABQdAAajYCPCABIAFB6ABqNgJYIAEgAUHMAGo2AlAgAUEMaiABQTRqEJkOIAEoAgwhBQwCCyABIAw2AjAgBSAMKAIAIglJBEAgBCADQQRqNgIAIAEgBTYCTCABIAdBAWs2AmggAUEDNgI4IAFBzIeHATYCNCABQgM3AkAgAUE7NgJkIAFB/xs2AlwgAUE7NgJUIAEgAUHQAGo2AjwgASABQcwAajYCYCABIAFBMGo2AlggASABQegAajYCUCABQSBqIAFBNGoQmQ4gASgCICEFIAEoAighCCABKAIsIQMgASgCJAwDCyAMIAU2AgAgASAHQQFrIhI2AkwgDSgCBCEKIA0oAgAhEAJAAkACQCAJRQ0AIAkgCk8EQCAJIApGDQEMAgsgCSAQaiwAAEFASA0BCyAFRQ0BIAUgCk8EQCAFIApHDQEMAgsgBSAQaiwAAEG/f0oNAQsgBCADQQRqNgIAIAFBATYCVCABQZCIhwE2AlAgAUIBNwJcIAFBOzYCbCABIAFB6ABqNgJYIAEgAUHMAGo2AmggAUE4aiABQdAAahCZDgwECyAEIBJBAmoiBzYCCCADQQRqIgMgEUcNAAsgBCADNgIADAMLIAEpAhQiE0IgiKchAyATpyEIIAEoAhALIQkgASADNgJEIAEgCDYCQCABIAk2AjwgASAFNgI4CyALIAEpAjg3AgQgC0EMaiABQUBrKQIANwIAIAQgB0EBajYCCEGNgICAeCEICyALIAg2AgAgAUHwAGokACACKAIgQZSAgIB4RwRAIAYgAikCIDcCACAGQRBqIAJBMGooAgA2AgAgBkEIaiACQShqKQIANwIADAMLIAZBk4CAgHg2AgAMAgsgAiABNgL4AQsgAiAFNgK4ASACIAQ2ArQBIAIgAkH4AGo2ArwBIAJBtAFqIQMjAEGQAWsiBCQAAkAgAkEgaiIKAn4CfwJAAkAgAkHoAWoiCCgCACIBIAgoAgQiDUcEQCADKAIIIQsgAygCBCEFIAgoAgwhDCAIKAIIIQcDQCAIIAFBBGoiAzYCACAEIAc2AjggBCABNgIYIAEoAgAiAUEASARAIARBAjYCfCAEQYCHhwE2AnggBEICNwKEASAEQTs2AlAgBEGpCDYCSCAEIARBxABqNgKAASAEIARBOGo2AkwgBCAEQRhqNgJEIARB5ABqIARB+ABqEJkOIARBFGogBEHwAGooAgA2AgAgBCAEKQJoNwIMIAQoAmQhAQwECyAMKAIAIAFJBEAgBEEDNgJkIARBnIaHATYCYCAEQgM3AmwgBEE7NgKMASAEIAw2AogBIARBqQg2AoQBIARBOzYCfCAEIARB+ABqNgJoIAQgBEEYajYCgAEgBCAEQThqNgJ4IARBCGogBEHgAGoQmQ4gBCgCCCEBDAQLIAQgBTYCWCAFKAIAIgkgAUsEQCAEIAE2AjggBCAHQQFrNgJEIARBAzYCZCAEQcyHhwE2AmAgBEIDNwJsIARBOzYCjAEgBEH/GzYChAEgBEE7NgJ8IAQgBEH4AGo2AmggBCAEQThqNgKIASAEIARB2ABqNgKAASAEIARBxABqNgJ4IARBHGogBEHgAGoQmQ4gBCgCKCEDIAQoAiQhBSAEKAIcIQEgBCgCIAwFCyAFIAE2AgAgBCABNgI0IAQgCTYCMCAEIAdBAWs2AiwgASALKAIEIg9LDQIgBEE4aiALKAIAIAlqIAEgCWsQnQkgBCgCOEEBRgRAIAQgBCkCPDcDWCAEQQM2AmQgBEHUiIcBNgJgIARCAzcCbCAEQbADNgKMASAEQaQDNgKEASAEQTs2AnwgBCAEQfgAajYCaCAEIARB2ABqNgKIASAEIARBMGo2AoABIAQgBEEsajYCeCAEQcgAaiAEQeAAahCZDiAEKAJIIQEgBCgCTCEJIAQpAlAMBgsgCCAHQQFqIgc2AgggAyIBIA1HDQALCyAKQZSAgIB4NgIADAQLIAEgD0GYiIcBELA7AAsgBCkCECITQiCIpyEDIBOnIQUgBCgCDAshCSAFrSADrUIghoQLNwIMIAogCTYCCCAKIAE2AgQgCkGNgICAeDYCACAIIAdBAWo2AggLIARBkAFqJAAgAigCIEGUgICAeEcEQCAGIAIpAiA3AgAgBkEQaiACQTBqKAIANgIAIAZBCGogAkEoaikCADcCAAwBCyAGQZOAgIB4NgIACyACQYACaiQADAULQQBBAEHk/oYBEMMhAAtB9P6GAUHEAEG4/4YBEJ8pAAsgBSAEQcj/hgEQsTsACyAEIAhByP+GARCwOwALQdTZhgFBIEH02YYBEJ8pAAsgDigCDCIDQZOAgIB4RwRAIAAgDikCEDcCBCAAQQxqIA5BGGopAgA3AgAMAQtBk4CAgHghAwsgACADNgIAIA5BIGokAAvtAQECfyMAQTBrIgIkAAJAIAApAwBC////////////AINCgICAgICAgPj/AFoEQCACQQE2AhQgAkG8p4kBNgIQIAJCATcCHCACQYoINgIsIAIgADYCKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQywohAwwBCyACQQA6AAwgAiABNgIIQQEhAyACQQE2AhQgAkG8p4kBNgIQIAJCATcCHCACQYoINgIsIAIgADYCKCACIAJBKGo2AhggAkEIaiACQRBqEJs9DQAgAi0ADEUEQCABQcSniQFBAhD7NQ0BC0EAIQMLIAJBMGokACADC9oBAgR+An8jAEEQayIGJAACQCABvSIFQv///////////wCDIgRCgICAgICAgPg/VA0AIARCgICAgICAgPDHAFoEQCAEQoGAgICAgID4/wBaDQEgBUI/hyIDQv///////////wCFIQIgA0J/hSEDDAELIAZCACAEQguGQoCAgICAgICAgH+EQf4AIARCNIina0H/AHEQxyNCACAGKQMAIgJ9IAIgBUIAUyIHGyEDQgAgBikDCCIEIAJCAFKtfH0gBCAHGyECCyAAIAM3AwAgACACNwMIIAZBEGokAAuQDAIRfwF+IwBBQGoiBSQAIAVBKGohBiMAQaAFayIDJAAgAUGoAWohDSABQbQBaiEQIAFB+ABqIREgAUEgaiESIAFBCGohCiABQYwBaiELIAFBiAFqIQcgASgCiAEhBCADQdwDaiEOIANB0ANqIQ8gA0GwAWohCCADQaQCaiEMIANByAFqIRMCQANAAkACQAJAAkACQAJAAkACQAJAAkBBASAEQf////8HaiAEQYCAgIB4TRtBAWsOAwIDAAELIAZBCTYCAAwHCyADQQhqIBEQ0yIgAygCCEEBcQ0HIAZBCTYCAAwGCyADQagBaiAHEIcGIAMoAqgBIgRBAkYNASAEQQFxBEAgA0EgaiADQbwBaigCADYCACADQRhqIANBtAFqKQIANwMAIAMgAykCrAE3AxAgBxCGJCAHQYSAgIB4NgIAIANBADYCiAUgA0KAgICAEDcCgAUgA0GY+cIANgKQBSADQqCAgIAONwKUBSADIANBgAVqNgKMBSADQRBqIgEgA0GMBWoQnwQNAyAGIAMpAoAFNwIEIAZBDGogA0GIBWooAgA2AgAgBkEDNgIAIAEQiBEMBgsgBiADKQKsATcCBCAGQQg2AgAgBkEUaiADQbwBaigCADYCACAGQQxqIANBtAFqKQIANwIADAULIANBqAFqIAEoAowBIAIgASgCkAEoAgwRAQAgAykDqAEiFEIFUQ0DIBRCBFEEQCAGIAgpAwA3AwAgBkEQaiAIQRBqKQMANwMAIAZBCGogCEEIaikDADcDACAHEIYkIAdBhICAgHg2AgAMBQsgAygCoAIhBCABKQMAQgRSBEAgARCPEwsgASAUNwMAIAogCCkDADcDACAKQQhqIAhBCGopAwA3AwAgCkEQaiAIQRBqKQMANwMAIBIgE0HYAPwKAAAgBxCGJCAEQYGAgIB4Rg0CIAsgDCkCADcCACALQRhqIAxBGGooAgA2AgAgC0EQaiAMQRBqKQIANwIAIAtBCGogDEEIaikCADcCAAwCCyAHEIYkQYGAgIB4IQQMAQtBwPnCAEE3IANBnwVqQbD5wgBB+PnCABDVHgALIAcgBDYCAAwDCyAGQQo2AgALIANBoAVqJAAMAgsgAygCDCEEIAEpAwAhFCABQgQ3AwAgFEIEUgRAIANBKGogCkHwAPwKAAAgASgCwAFBCGogBBCILSEJAkAgASgCtAFBgICAgHhHBEAgA0GcAWogECAJKAIQEKAODAELIANBgICAgHg2ApwBCwJAIA0oAgBBgICAgHhHBEAgA0EQaiANEOceDAELIANBgICAgHg2AhALIA4gAykCEDcCACAOQQhqIANBGGooAgA2AgAgAyAUNwOoASABKALIASEJIAggA0EoakHwAPwKAAAgDyADKQKcATcCACAPQQhqIANBpAFqKAIANgIAIAMgBDYC6AMgA0EAOgCUBCADIAk2AuwDIANBqAFqIQkCQEHYA0EIEK02IgQEQCAEIAlB2AP8CgAAIANBiPnCADYCBCADIAQ2AgAMAQtBCEHYAxCjPQALIAMoAgAhBCAHEIYkIAFBiPnCADYCkAEgASAENgKMAUGDgICAeCEEIAFBg4CAgHg2AogBDAELC0GU+MIAQRNBqPjCABDLJAALAn9BAyAFKAIoIgJBCkYNABogBUEgaiIBIAVBPGoiAygCADYCACAFQRhqIgcgBUE0aiIEKQIANwMAIAUgBSkCLDcDEEECIAJBCUYNABogBCAHKQMANwIAIAMgASgCADYCACAFIAI2AiggBSAFKQMQNwIsIwBBIGsiASQAIAZBBGohAiAGKAIAIgNBCEcEQCABQRRqIAJBCGopAgA3AgAgAUEcaiACQRBqKAIANgIAIAEgAzYCCCABIAIpAgA3AgxBvJrDAEErIAFBCGpBrJrDAEHsn8MAENUeAAsgAUEYaiACQRBqKAIANgIAIAFBEGogAkEIaikCADcDACABIAIpAgA3AwggBUEIaiICIAFBCGoQ2CQ2AgQgAkEANgIAIAFBIGokACAFKAIMIQIgBSgCCAshASAAIAI2AgQgACABNgIAIAVBQGskAAupBAIFfwJ+IwBBgAFrIgQkACACKAIIBEAgAigCBC0AACEHIARBADYCOCAEQgA3AzAgBEEANgIQIAQgBzoAPCAEQgA3AwAgBEFAayIHIAJBARDqFCMAQUBqIgUkACAEQRBqIQYCQCAEKAIQIggEQCAEQRxqIAQoAhQgBCgCGCAIKAIQEQEAIARCADcDICAEQShqQgA3AwAgBkEIaiAHQQhqKQIANwIAIAYgBykCADcCAAwBCyAFQRBqQgA3AwAgBUEYakIANwMAIAYgBykCACIKNwMAIAZBEGpCADcDACAGQRhqQgA3AwAgBUEIaiAHQQhqKQIAIgk3AwAgBkEIaiAJNwMAIAUgCjcDAAsCQAJAIAYoAgAEQCAFQSBqIAYQpRgCQCAFKAIgQQFHDQAgBSkDKCIJUA0AIAlCAYNQRQRAIAQgCadBAnRBeHE2AjgMAQsgBCAJQgGIPgI0IAVBMGogBiAELQA8IghBA3YgCEEHcUEAR2oQwRwgBSkDMCEJIAQgBSkDODcDCCAEIAk3AwAgCadFDQILIAVBQGskAAwCC0H8qM0AQRhBlKnNABDLJAALQaSpzQBBLkHUqc0AEJ8pAAsgASADNgJMIAcgBEHAAPwKAAAgASkDAEICUgRAIAEQkSoLIAEgBEFAa0HAAPwKAAAgAEEINgIAIAJBDGogAigCBCACKAIIIAIoAgAoAhARAQAgBEGAAWokAA8LQQBBAEGIoc0AEMMhAAvOAQICfwF+IwBBEGsiAyQAIAEtABQhAiADIAEpAwA3AwAgAkEDdiACQQdxQQBHaiICQQlPBEAgAkEIQeiOzgAQsDsACyABQQhqIAMgAhChNiABQQA6ABQgAUIANwMAIAFBGGogASgCDCABKAIQEKE2IAFBADoAFCABQgA3AwAgAUEANgIQIANBCGogAUEgaiICKAIANgIAIAJBADYCACABKQIYIQQgAUKAgICAEDcDGCADIAQ3AwAgAEEEaiADEOcVIABBCDYCACADQRBqJAALtgEBA38jAEEgayIDJAAgA0EUaiACQQN2IAJBB3FBAEdqIgJBwAAgAa3DeadrIgFB/wFxIgRBA3YgAUEHcUEAR2pBAWpsIgUgBEEBaiACbCICIAIgBUkbQQBBAUEBEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQYTEzgAQ/S8ACyADQQA2AhAgAyADKAIcNgIMIAMgAjYCCCAAQQhqIAEgA0EIahCcHyAAQQE6AAAgA0EgaiQAC7MCAQV+An4gACkDACICQiBaBEAgACkDECIBQgeJIAApAwgiA0IBiXwgACkDGCIEQgyJfCAAKQMgIgVCEol8IANCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gAULP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0MAQsgACkDGELFz9my8eW66id8CyACfCAAQShqIAKnEN4TC8UBAQF/AkACQAJAAn8gAyAFcSIDIARqIgYgBUEBaiIFTQRAAkAgAyAGTQRAIAIgBkkNAUEAIQVBAQwDCyADIAZB/O3RABCxOwALIAYgAkH87dEAELA7AAsgAyAFSw0BIAIgBUkNAiAEIAUgA2siBGsiBSACSw0DIAELIQIgACAFNgIMIAAgAjYCCCAAIAQ2AgQgACABIANqNgIADwsgAyAFQYzu0QAQsTsACyAFIAJBjO7RABCwOwALIAUgAkGc7tEAELA7AAvJAQEIfyMAQUBqIgIkACABKAIYIQUgAkE0aiABQQxqENYGAkAgASgCHCIEBEAgBCAEKAIAIgNBAWo2AgAgA0EASA0BIAEoAiwhBiABKAIoIQcgASgCJCEIIAEoAiAhCSABKAIwIQMLIAIgARC8FSACQRRqIAJBPGooAgA2AgAgAiAFNgIYIAIgAzYCMCACIAY2AiwgAiAHNgIoIAIgCDYCJCACIAk2AiAgAiAENgIcIAIgAikCNDcCDCAAIAIQ7xcgAkFAayQADwsAC9gBAgJ/AX4jAEFAaiIDJAAgAyACNgIAIAEoAhRBA3ZBAWsiBCACTQRAIAMgBDYCHCADQQQ2AgggA0Gkj4YBNgIEIANCBDcCECADQTs2AjwgA0HHAjYCNCADQdyOhgE2AjAgA0HHAjYCLCADQdyPhgE2AiggA0E7NgIkIAMgA0EgajYCDCADIANBHGo2AjggAyADNgIgIANBBGpBxI+GARDvLAALIAAgASgCECACQQN0aiICQQhqKQMAIAIpAwAiBX0+AgQgACABKAIcIAWnajYCACADQUBrJAAL2AECAn8BfiMAQUBqIgMkACADIAI2AgAgASgCFEEDdkEBayIEIAJNBEAgAyAENgIcIANBBDYCCCADQaSPhgE2AgQgA0IENwIQIANBOzYCPCADQccCNgI0IANB7I+GATYCMCADQccCNgIsIANB3I+GATYCKCADQTs2AiQgAyADQSBqNgIMIAMgA0EcajYCOCADIAM2AiAgA0EEakHEj4YBEO8sAAsgACABKAIQIAJBA3RqIgJBCGopAwAgAikDACIFfT4CBCAAIAEoAhwgBadqNgIAIANBQGskAAvIAgEHfyMAQRBrIgIkAAJAAkAgACAAQe0CaiIBSg0AIAJBCGohAyABIAFBsfUIbSIEQbH1CGxrIgBBH3UiBUGx9QhxIABqIgFB7QJuIQACfwJAIAFBvPcITQRAIAEgAEHtAmxrIgEgAEHAxoYBai0AACIGTwRAIAEgBmsMAwsgAEEBayIAQZEDSQ0BQX9BkQNB5MmGARDDIQALIABBkQNB1MmGARDDIQALIAEgAEHAxoYBai0AAGtB7QJqCyEBIAMgADYCACADIAFBAWo2AgQgAigCCCIAQZADTw0BIAIoAgwiAUHvAmtBkn1JDQAgACAEIAVqQZADbGoiA0H//w9rQYKAYEkNACAAQfTJhgFqLQAAIANBDXQgAUEEdHJyIgBBACAAQfg/cUHhLUkbIQcLIAJBEGokACAHDwsgAEGQA0GEzYYBEMMhAAvEAQEDfyMAQRBrIgQkAAJAAkAgASgCACIBKAIQQQFHBEAgBEEEaiADQQBBAUEBEKAYIAQoAgghBSAEKAIEQQFGDQIgBCgCDCEGIAMEQCAGIAIgA/wKAAALIAEQwyxBB0EgIAVBCnZnayIBIAFBB08bQQJ0QQFyIQEMAQsgASgCBCABKAIAIAJraiEFIAIhBgsgACABNgIMIAAgBTYCCCAAIAM2AgQgACAGNgIAIARBEGokAA8LIAUgBCgCDEGUiIgBEP0vAAuyAQEEfyAAKAIAIgEgACgCBEYEQEGAgMQADwsgACABQQFqNgIAIAEtAAAiA8BBAEgEfyAAIAFBAmo2AgAgAS0AAUE/cSECIANBH3EhBCADQd8BTQRAIARBBnQgAnIPCyAAIAFBA2o2AgAgAS0AAkE/cSACQQZ0ciECIANB8AFJBEAgAiAEQQx0cg8LIAAgAUEEajYCACAEQRJ0QYCA8ABxIAEtAANBP3EgAkEGdHJyBSADCwucAQEHfyABBEAgAUEBRwRAIAAgAUECdGohBSAAQQQiBGohAwNAIAMoAgAiBkEYdiIHIANBBGsoAgAiAUEYdkkEQCAEIQICfwNAIAAgAmoiCCABNgIAIAAgAkEERg0BGiACQQRrIQIgByAIQQhrKAIAIgFBGHZJDQALIAAgAmoLIAY2AgALIARBBGohBCADQQRqIgMgBUcNAAsLDwsAC8ACAQN/IwBBMGsiASQAIAFBADYCHCABQoCAgIAQNwIUIAFBqMXMADYCJCABQqCAgIAONwIoIAEgAUEUajYCICABQSBqIQMjAEEwayICJAACfyAAKAIAQYCAgIB4RwRAIAIgADYCDCACQQI2AhQgAkGgxMwANgIQIAJCATcCHCACQYQBNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAygCACADKAIEIAJBEGoQywoMAQsgACgCBCADEJ8ECyACQTBqJABFBEAgAUEQaiABQRxqKAIAIgI2AgAgASABKQIUNwMIIAEoAgwgAhCUPiABQQhqEN47AkAgACgCAEGAgICAeEYEQCAAKAIEIgAQiBEgAEEUQQQQ+DoMAQsgABDeOwsgAUEwaiQADwtB0MXMAEE3IAFBCGpBwMXMAEGIxswAENUeAAu8AQEIfyMAQRBrIgIkACAAKAIMIgEgACgCBCIFa0HQAG4hByABIAVHBEADQCAFIANB0ABsaiIBQTBqIAEoAjgiBgRAIAEoAjQhBANAIAQQ2BMgBEHoA2ohBCAGQQFrIgYNAAsLQQhB6AMQ4B4gASgCPEGAgICAeEcEQCABQTxqQQRBCBDgHgsgA0EBaiIDIAdHDQALCyACIAAoAgA2AgwgAiAAKAIINgIIIAJBCGpBCEHQABDgHiACQRBqJAAL3KsBAhN/EX4gAEEIaiEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAAJ+AkACQAJAAkACQAJAAkACQCABQQhqEN0lQf8BcUEBaw4HAQIDBAUGBwALIwBBgARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABB4AFqIAwgDSAAQQ9qEMcNAkACQCAAKALgAUEIRgRAIAAoAugBIRAgACgC5AEhESAAQfACaiEGIwBB4ABrIgckACAIIABBCGooAgAiCkEIaiIJEOcRGiAIIAkQ2xIhAUECQQAgCC0AlQFBAXEbIAFB/wFxIgEgAUEJRhshBSMAQfABayIBJAACQAJAIAdBEGoiCwJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcUAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDRQgBSABQSj8CgAAQfSQzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDRQgASgCCCIOQfSRzgBBNfwKAAAgC0E1NgIMIAsgDjYCCCALIAU2AgQgC0EANgIADAYLQfgAQQgQrTYiBUUNFCAFQYCAgIB4NgIIQZSRzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0UIAUgAUHwAPwKAABBtJHOAAwCCyABEKEnQeABQQgQrTYiBUUNFCAFIAFB4AH8CgAAQdSRzgAMAQtBDEEEEK02IgVFDRQgBUEANgIIIAVCgICAgBA3AgBBrJLOAAs2AgggCyAFNgIEIAtBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgC0EEaiABEJkOIAtBATYCAAsgAUHwAWokACAHKAIYIQEgBygCFCELAkACQAJAIAcoAhAiBUEIRwRAIAYgBykCHDcCFCAGQRxqIAdBJGooAgA2AgAgBiABNgIQIAYgCzYCDCAGIAU2AgggBkICNwMADAELIAcgATYCXCAHIAs2AlggCCAJEIISIQ5BgICAgHghBQJAIAggCRDRESIJRQ0AIAdBEGogCSkDCCAJKwMAENIRAkACQCAHKAIQIglBCGsOAgECAAsgBygCFCEBIAcpAxghFyAGIAcpAyA3AxggBiAXNwMQIAYgATYCDCAGIAk2AgggBkICNwMAIAdB2ABqELwqDAILIAcpAxghFyAHKAIUIQULIAogCigCACIJQQFqNgIAIAlBAEgNASAGQRBqIAdBEGpByAD8CgAAIAZBgICAgHg2AlggBkGCBDsAhQEgBiAOOgCEASAGQQA2AoABIAYgCjYCfCAGIBc3AnQgBiAFNgJwIAYgATYCbCAGIAs2AmggBkIANwMAIAYgBykCBDcCXCAGQeQAaiAHQQxqKAIANgIACyAHQeAAaiQADAELAAsgACkD8AJCAlENASAAQRBqIAZBiAH8CgAAIAggDxCCEiEFQQAhASAAQQA2AqQBIABBADYCnAFBAiEGIABBnAFqQQIQ6R4gAEG4AWpBAEEo/AsAAn8gBUH/AXEiC0UEQEGAgICAeCEFQYCAgIB4IQdBgICAgHghCkGAgICAeCEJQQIMAQsgAEIANwOQAyAAQYCAgIB4NgKEAyAAQYCAgIB4NgL4AiAAQgA3A/ACIABB+AJqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgLgAQwBCyAAQeABaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABB6AFqKAIANgIAIAEgACkC4AE3AgAgAEHgAWogAEHwAmpBKPwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgLwAgwBCyAAQfACaiABQQFqQf//A3FBoPnPABC2FQsgAEH0AWoQhTAgAEH8AWogAEH4AmooAgA2AgAgACAAKQLwAiIXNwL0ASAAKQPgASEYIAAoAugBIQUgACkC7AEhGSAAKAKAAiETIAAoAoQCIRQgACkD+AEhGiAAQgA3A6ADIABCADcDkAMgAEIANwOAAyAAQgA3A/ACIABBqANqIABBsAFqQTD8CgAAIABBggQ7AfgDIABBgICAgHg2AuwDIABBgICAgHg2AuADIABCADcD2AMgAEHgA2ohAQJAIAAoAgguARoiBkEATARAIABBgICAgHg2AuABDAELIABB4AFqIAZBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEHoAWooAgA2AgAgASAAKQLgATcCACAAQeABaiAAQfACakGQAfwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgLwAgwBCyAAQfACaiABQQFqQf//A3FBoPnPABC2FQsgAEHcAmoQhTAgAEHkAmogAEH4AmooAgA2AgAgACAAKQLwAjcC3AIgACkD4AEhGyAAKQPoASEcIAApA/ABIR0gACkD+AEhHiAAKQOAAiEfIAApA4gCISAgACkDkAIhISAAQbABaiAAQZgCakEw/AoAACAXpyEHIABBrAFqIABB7gJqLwEAOwEAIAAgACgB6gI2AqgBIAtBAkYhASAALQDpAiEGIAApA+ACISIgACgC3AIhCSAAKQLUAiEjIAAoAtACIQogACkDyAIhJCAALQDoAgshDyAIEPUVIQggBCALOgCsBCAEIAI2ApgEIARBuO3PADYC5AMgBCADNgLgAyAEIBA2AuwDIAQgETYC6AMgBCANNgKcAiAEIAw2ApgCIARBpARqIABBpAFqKAIANgIAIAQgACkCnAE3ApwEIAQgACgCCDYClAQgBCAAQRBqQYgB/AoAACAEIBQ2AqQDIAQgEzYCoAMgBCAaNwOYAyAEIAc2ApQDIAQgGTcCjAMgBCAFNgKIAyAEIBg3A4ADIAQgITcDuAEgBCAgNwOwASAEIB83A6gBIAQgHjcDoAEgBCAdNwOYASAEIBw3A5ABIAQgGzcDiAEgBEHAAWogAEGwAWpBMPwKAAAgBCAGOgCRAiAEIA86AJACIAQgIjcDiAIgBCAJNgKEAiAEICM3AvwBIAQgCjYC+AEgBCAkNwPwASAEQQA2ApAEIARCgICAgCA3A4gEIARCAjcDgAQgBEIANwP4AyAEQoCAgIDAADcD8AMgBEGAgICAeDYC4AIgBEGAgICAeDYC7AIgBEEANgL4AiAEQgA3A6gDIARBgICAgHhBACAIGzYCsAMgBEGAgICAeDYC1AMgBEGBAjsBqgQgBEKAgICAgAE3A6ACIARCADcDqAIgBEKAgICAEDcDsAIgBEIANwO4AiAEQgQ3A8ACIARCgICAgMAANwPIAiAEQgA3A9ACIARCCDcD2AIgBEIINwK0AyAEQoCAgIDAADcCvAMgBEIANwLEAyAEQgg3AswDIAQgAToA/AIgBCAAKAKoATYBkgIgBEGWAmogAEGsAWovAQA7AQAgBEECOgCoBCAAQYAEaiQADAILIABBgANqIABB8AFqKQMANwMAIABB+AJqIABB6AFqKQMANwMAIAAgACkD4AE3A/ACQcTvzgBBKyAAQfACakG0784AQaj9zgAQ1R4ACyAAQfABaiAAQYgDaikDADcDACAAQegBaiAAQYADaikDADcDACAAIAApA/gCNwPgAUHE784AQSsgAEHgAWpBtO/OAEG4/c4AENUeAAtCAAwHCyMAQaAEayIAJAAgACABNgIQIABBCGogAkEIaiIKIAFBCGoiDhDPECAAKAIMIRAgACgCCCERIABBAToAFyAAQfABaiARIBAgAEEXahDHDQJAIAAoAvABQQhGBEAgACgC+AEhEiAAKAL0ASEVIABBiANqIQYjAEGAAWsiByQAAkACQAJAIAogAEEQaigCACIJQQhqIgwQ5xFFBEAgB0GAgICAeDYCUAwBCyAJIAkoAgAiAUEBajYCACABQQBIDQEgB0EIaiAJEMMgCyAKIAwQ2xIhAUEEQQAgCi0AlQFBAXEbIAFB/wFxIgEgAUEJRhshBSMAQfABayIBJAACQAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAAkAgBUH/AXFBAWsOCAECCQMEBQEGAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNFiAFIAFBKPwKAABB2JrOAAwGCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNFiABKAIIIhZB9JHOAEE1/AoAACAIQTU2AgwgCCAWNgIIIAggBTYCBCAIQQA2AgAMCAtB+ABBCBCtNiIFRQ0WIAVBgICAgHg2AghB+JrOAAwECyABEJkoQeAAQQgQrTYiBUUNBCAFIAFB4AD8CgAAQZibzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0VIAUgAUHwAPwKAABBuJvOAAwCCyABEKEnQeABQQgQrTYiBUUNFSAFIAFB4AH8CgAAQdibzgAMAQtBDEEEEK02IgVFDRUgBUEANgIIIAVCgICAgBA3AgBB+JvOAAs2AgggCCAFNgIEIAhBCDYCAAwCC0EIQeAAEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAhBBGogARCZDiAIQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCAJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAg2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByAINgJgIAogDBCCEiEWQYCAgIB4IQECQAJAIAogDBDRESIMRQ0AIAdB6ABqIAwpAwggDCsDABDSEQJAIAcoAmgiDEEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAJIAkoAgAiDEEBajYCACAMQQBIDQIgBkEgaiAHQQhqQdgA/AoAACAGIBY6AJQBIAZBADYCkAEgBiAJNgKMASAGIBc3AoQBIAYgATYCgAEgBiAFNgJ8IAYgCDYCeCAGQQA2AhggBkEANgIQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDDYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDSLAwBCwALIAdBgAFqJAAgACkDiANCAlENESAAQRhqIAZBmAH8CgAAIAogDhCCEiEBQQAhBiAAQQA2ArgBIABBADYCsAEgAEGwAWpBAhDpHiAAQcABakEAQTD8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDqAMgAEGAgICAeDYCnAMgAEGAgICAeDYCkAMgAEIANwOIAyAAQZADaiEBAkAgACgCEC4BGiIFQQBMBEAgAEGAgICAeDYC8AEMAQsgAEHwAWogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQfgBaigCADYCACABIAApAvABNwIAIABB8AFqIABBiANqQSj8CgAAAkAgACgCEC4BGCIBQQBMBEAgAEGAgICAeDYCiAMMAQsgAEGIA2ogAUEBakH//wNxQaD5zwAQthULIABBhAJqEIUwIABBjAJqIABBkANqKAIANgIAIAAgACkCiAMiFzcChAIgACkD8AEhGCAAKAL4ASEHIAApAvwBIRkgACgCkAIhEyAAKAKUAiEUIAApA4gCIRogAEEANgLQAyAAQQA2AsgDIABCADcDuAMgAEIANwOoAyAAQgA3A5gDIABCADcDiAMgAEHUA2ogAEG8AWpBNPwKAAAgAEGAgICAeDYClAQgAEGAgICAeDYCiAQgAEGIBGohAQJAIAAoAhAuARoiBUEATARAIABBgICAgHg2AvABDAELIABB8AFqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEH4AWooAgA2AgAgASAAKQLwATcCACAAQfABaiAAQYgDakGYAfwKAAACQCAAKAIQLgEYIgFBAEwEQCAAQYCAgIB4NgKIAwwBCyAAQYgDaiABQQFqQf//A3FBoPnPABC2FQsgAEH8AmoQhTAgAEGEA2ogAEGQA2ooAgA2AgAgACAAKQKIAzcC/AIgACkD8AEhGyAAKQP4ASEcIAApA4ACIR0gACkDiAIhHiAAKQOQAiEfIAApA5gCISAgACkDoAIhISAAKQOoAiEiIAAoArACIQsgACgCtAIhDSAAKAK4AiEPIABBvAFqIABBvAJqQTT8CgAAIBenIQUgCEECRiEGIAApA4ADISMgACkC9AIhJCAAKALwAiEBIAAoAvwCCyEJIAoQ9RUhCiAEIAg6AM4EIAQgAjYCvAQgBEG47c8ANgL8AyAEIAM2AvgDIAQgEjYChAQgBCAVNgKABCAEIBA2ArQCIAQgETYCsAIgBEHIBGogAEG4AWooAgA2AgAgBCAAKQKwATcCwAQgBCAAKAIQNgK4BCAEIABBGGpBmAH8CgAAIAQgFDYCvAMgBCATNgK4AyAEIBo3A7ADIAQgBTYCrAMgBCAZNwKkAyAEIAc2AqADIAQgGDcDmAMgBCAPNgLgASAEIA02AtwBIAQgCzYC2AEgBCAiNwPQASAEICE3A8gBIAQgIDcDwAEgBCAfNwO4ASAEIB43A7ABIAQgHTcDqAEgBCAcNwOgASAEIBs3A5gBIARB5AFqIABBvAFqQTT8CgAAIARBADYCtAQgBEKAgICAIDcCrAQgBEICNwKkBCAEQgA3ApwEIARCgICAgMAANwKUBCAEICM3A6gCIAQgCTYCpAIgBCAkNwKcAiAEIAE2ApgCIARBgQI7AcwEIARBgICAgHg2AuwDIARCCDcC5AMgBEIANwLcAyAEQoCAgIDAADcC1AMgBEIINwLMAyAEQYCAgIB4QQAgChs2AsgDIARCADcDwAMgBCAGOgCUAyAEQQA2ApADIARBgICAgHg2AoQDIARBgICAgHg2AvgCIARCCDcD8AIgBEIANwPoAiAEQoCAgIDAADcD4AIgBEIENwPYAiAEQgA3A9ACIARCgICAgBA3A8gCIARCADcDwAIgBEKAgICAgAE3A7gCIARBADYCiAQgAEGgBGokAAwBCwwPC0IBDAYLIwBB0ARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABBgAJqIAwgDSAAQQ9qEMcNAkAgACgCgAJBCEYEQCAAKAKIAiEQIAAoAoQCIREgAEGoA2ohBiMAQYABayIHJAACQAJAAkAgCCAAQQhqKAIAIgpBCGoiCRDnEUUEQCAHQYCAgIB4NgJQDAELIAogCigCACIBQQFqNgIAIAFBAEgNASAHQQhqIAoQxCALIAggCRDbEiEBQQRBACAILQCVAUEBcRsgAUH/AXEiASABQQlGGyEFIwBB8AFrIgEkAAJAAkACQCAHQegAaiILAn8CQAJAAkACQAJAAkACQCAFQf8BcUEBaw4IAQIJAwQFAQYACyABQYACEOggIAFBADYCICABQoCAgIAQNwMYQShBCBCtNiIFRQ0VIAUgAUEo/AoAAEH4ks4ADAYLIAFBNUEAQQFBARCgGCABKAIEIQUgASgCAEEBRg0VIAEoAggiDkH0kc4AQTX8CgAAIAtBNTYCDCALIA42AgggCyAFNgIEIAtBADYCAAwIC0H4AEEIEK02IgVFDRUgBUGAgICAeDYCCEGYk84ADAQLIAFBIBDoICABQRhqQYCAwAAQ6CAgAUFAa0GAAkGEns4AELYVIAFCADcDMCABQoCAgICAIDcCTCABQThqQgA3AwAgAUEANgJcIAFCwICAgMAANwJUQeAAQQgQrTYiBUUNBCAFIAFB4AD8CgAAQbiTzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0UIAUgAUHwAPwKAABB2JPOAAwCCyABEKEnQeABQQgQrTYiBUUNFCAFIAFB4AH8CgAAQfiTzgAMAQtBDEEEEK02IgVFDRQgBUEANgIIIAVCgICAgBA3AgBBmJTOAAs2AgggCyAFNgIEIAtBCDYCAAwCC0EIQeAAEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAtBBGogARCZDiALQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCwJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAs2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByALNgJgIAggCRCCEiEOQYCAgIB4IQECQAJAIAggCRDRESIJRQ0AIAdB6ABqIAkpAwggCSsDABDSEQJAIAcoAmgiCUEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAKIAooAgAiCUEBajYCACAJQQBIDQIgBkEwaiAHQQhqQdgA/AoAACAGIA46AKQBIAZBADYCoAEgBiAKNgKcASAGIBc3ApQBIAYgATYCkAEgBiAFNgKMASAGIAs2AogBIAZCADcDICAGQgA3AxAgBkIANwMADAMLIAcoAmwhASAHKQNwIRcgBiAHKQN4NwMYIAYgFzcDECAGIAE2AgwgBiAJNgIIIAZCAjcDACAHQeAAahC8KgsgBygCUEGAgICAeEYNASAHQQhqENMsDAELAAsgB0GAAWokACAAKQOoA0ICUQ0SIABBEGogBkGoAfwKAAAgCCAPEIISIQFBACEGIABBADYCxAEgAEEANgK8ASAAQbwBakECEOkeIABB0AFqQQBBMPwLAAJ/IAFB/wFxIgtFBEBBgICAgHghB0GAgICAeCEFQYCAgIB4IQFBgICAgHgMAQsgAEIANwPIAyAAQYCAgIB4NgK8AyAAQYCAgIB4NgKwAyAAQgA3A6gDIABBsANqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKAAgwBCyAAQYACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBiAJqKAIANgIAIAEgACkCgAI3AgAgAEGAAmogAEGoA2pBKPwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgKoAwwBCyAAQagDaiABQQFqQf//A3FBoPnPABC2FQsgAEGUAmoQhTAgAEGcAmogAEGwA2ooAgA2AgAgACAAKQKoAyIXNwKUAiAAKQOAAiEYIAAoAogCIQcgACkCjAIhGSAAKAKgAiETIAAoAqQCIRQgACkDmAIhGiAAQgA3A/gDIABCADcD6AMgAEIANwPYAyAAQgA3A8gDIABCADcDuAMgAEIANwOoAyAAQYAEaiAAQcgBakE4/AoAACAAQYCAgIB4NgLEBCAAQYCAgIB4NgK4BCAAQbgEaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCgAIMAQsgAEGAAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQYgCaigCADYCACABIAApAoACNwIAIABBgAJqIABBqANqQagB/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AqgDDAELIABBqANqIAFBAWpB//8DcUGg+c8AELYVCyAAQZwDahCFMCAAQaQDaiAAQbADaigCADYCACAAIAApAqgDNwKcAyAAKQOAAiEbIAApA4gCIRwgACkDkAIhHSAAKQOYAiEeIAApA6ACIR8gACkDqAIhICAAKQOwAiEhIAApA7gCISIgACkDwAIhIyAAKQPIAiEkIAApA9ACISUgAEHIAWogAEHYAmpBOPwKAAAgF6chBSALQQJGIQYgACkDoAMhJiAAKQKUAyEnIAAoApADIQEgACgCnAMLIQogCBD1FSEIIAQgCzoA+gQgBCACNgLoBCAEQbjtzwA2ArQEIAQgAzYCsAQgBCAQNgK8BCAEIBE2ArgEIAQgDTYC7AIgBCAMNgLoAiAEQfQEaiAAQcQBaigCADYCACAEIAApArwBNwLsBCAEIAAoAgg2AuQEIAQgAEEQakGoAfwKAAAgBCAUNgL0AyAEIBM2AvADIAQgGjcD6AMgBCAFNgLkAyAEIBk3AtwDIAQgBzYC2AMgBCAYNwPQAyAEICU3A/gBIAQgJDcD8AEgBCAjNwPoASAEICI3A+ABIAQgITcD2AEgBCAgNwPQASAEIB83A8gBIAQgHjcDwAEgBCAdNwO4ASAEIBw3A7ABIAQgGzcDqAEgBEGAAmogAEHIAWpBOPwKAAAgBEEANgLgBCAEQoCAgIAgNwPYBCAEQgI3A9AEIARCADcDyAQgBEKAgICAwAA3A8AEIAQgJjcDyAIgBCAKNgLEAiAEICc3ArwCIAQgATYCuAIgBEGBAjsB+AQgBEGAgICAeDYCpAQgBEIINwKcBCAEQgA3ApQEIARCgICAgMAANwKMBCAEQgg3AoQEIARBgICAgHhBACAIGzYCgAQgBEIANwP4AyAEIAY6AMwDIARBADYCyAMgBEGAgICAeDYCvAMgBEGAgICAeDYCsAMgBEIINwOoAyAEQgA3A6ADIARCgICAgMAANwOYAyAEQgQ3A5ADIARCADcDiAMgBEKAgICAEDcDgAMgBEIANwP4AiAEQoCAgICAATcD8AIgBEIANwPQAiAAQdAEaiQADAELDBALQgIMBQsjAEHgBGsiACQAIAAgATYCCCAAIAJBCGoiCiABQQhqIhEQzxAgACgCBCEPIAAoAgAhECAAQQE6AA8gAEGQAmogECAPIABBD2oQxw0CQAJAIAAoApACQQhGBEAgACgCmAIhDiAAKAKUAiESIABBuANqIQYjAEGAAWsiByQAAkACQAJAIAogAEEIaigCACIJQQhqIgwQ5xFFBEAgB0GAgICAeDYCUAwBCyAJIAkoAgAiAUEBajYCACABQQBIDQEgB0EIaiAJEMMgCyAKIAwQ2xJB/wFxIgFBACABQQlHGyEFIwBB8AFrIgEkAAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcTAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDRMgBSABQSj8CgAAQbiZzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDRMgASgCCCIVQfSRzgBBNfwKAAAgCEE1NgIMIAggFTYCCCAIIAU2AgQgCEEANgIADAYLQfgAQQgQrTYiBUUNEyAFQYCAgIB4NgIIQdiZzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0TIAUgAUHwAPwKAABB+JnOAAwCCyABEKEnQeABQQgQrTYiBUUNEyAFIAFB4AH8CgAAQZiazgAMAQtBDEEEEK02IgVFDRMgBUEANgIIIAVCgICAgBA3AgBBuJrOAAs2AgggCCAFNgIEIAhBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgCEEEaiABEJkOIAhBATYCAAsgAUHwAWokACAHKAJwIQUgBygCbCEIAkAgBygCaCIBQQhHBEAgBiAHKQJ0NwIUIAZBHGogB0H8AGooAgA2AgAgBiAFNgIQIAYgCDYCDCAGIAE2AgggBkICNwMADAELIAcgBTYCZCAHIAg2AmAgCiAMEIISIRVBgICAgHghAQJAAkAgCiAMENERIgxFDQAgB0HoAGogDCkDCCAMKwMAENIRAkAgBygCaCIMQQhrDgIAAQILIAcpA3AhFyAHKAJsIQELIAkgCSgCACIMQQFqNgIAIAxBAEgNAiAGQTBqIAdBCGpB2AD8CgAAIAYgFToApAEgBkEANgKgASAGIAk2ApwBIAYgFzcClAEgBiABNgKQASAGIAU2AowBIAYgCDYCiAEgBkEANgIgIAZBADYCECAGQgA3AwAMAwsgBygCbCEBIAcpA3AhFyAGIAcpA3g3AxggBiAXNwMQIAYgATYCDCAGIAw2AgggBkICNwMAIAdB4ABqELwqCyAHKAJQQYCAgIB4Rg0BIAdBCGoQgy0MAQsACyAHQYABaiQAIAApA7gDQgJRDQEgAEEQaiAGQagB/AoAACAKIBEQghIhAUEAIQYgAEEANgLAASAAQQA2ArgBIABBuAFqQQIQ6R4gAEHQAWpBAEEw/AsAAn8gAUH/AXEiCEUEQEGAgICAeCEHQYCAgIB4IQVBgICAgHghAUGAgICAeAwBCyAAQgA3A9gDIABBgICAgHg2AswDIABBgICAgHg2AsADIABCADcDuAMgAEHAA2ohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2ApACDAELIABBkAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEGYAmooAgA2AgAgASAAKQKQAjcCACAAQZACaiAAQbgDakEo/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2ArgDDAELIABBuANqIAFBAWpB//8DcUGg+c8AELYVCyAAQaQCahCFMCAAQawCaiAAQcADaigCADYCACAAIAApArgDIhc3AqQCIAApA5ACIRggACgCmAIhByAAKQKcAiEZIAAoArACIRMgACgCtAIhFCAAKQOoAiEaIABBADYCiAQgAEEANgL4AyAAQgA3A+gDIABCADcD2AMgAEIANwPIAyAAQgA3A7gDIABBjARqIABBxAFqQTz8CgAAIABBgICAgHg2AtQEIABBgICAgHg2AsgEIABByARqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKQAgwBCyAAQZACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBmAJqKAIANgIAIAEgACkCkAI3AgAgAEGQAmogAEG4A2pBqAH8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYCuAMMAQsgAEG4A2ogAUEBakH//wNxQaD5zwAQthULIABBrANqEIUwIABBtANqIABBwANqKAIANgIAIABBiAJqIABB3AJqKAIANgIAIAAgACkCuAM3AqwDIAAgACkC1AI3A4ACIAApA5ACIRsgACkDmAIhHCAAKQOgAiEdIAApA6gCIR4gACkDsAIhHyAAKQO4AiEgIAApA8ACISEgACkDyAIhIiAAKALQAiELIAAoAuACIQ0gAEHEAWogAEHkAmpBPPwKAAAgF6chBSAIQQJGIQYgACkDsAMhIyAAKQKkAyEkIAAoAqADIQEgACgCrAMLIQkgChD1FSEKIAQgCDoA/gQgBCACNgLsBCAEQbjtzwA2ApwEIAQgAzYCmAQgBCAONgKkBCAEIBI2AqAEIAQgDzYC1AIgBCAQNgLQAiAEQfgEaiAAQcABaigCADYCACAEIAApArgBNwLwBCAEIAAoAgg2AugEIAQgAEEQakGoAfwKAAAgBCAUNgLcAyAEIBM2AtgDIAQgGjcD0AMgBCAFNgLMAyAEIBk3AsQDIAQgBzYCwAMgBCAYNwO4AyAEIAs2AugBIAQgIjcD4AEgBCAhNwPYASAEICA3A9ABIAQgHzcDyAEgBCAeNwPAASAEIB03A7gBIAQgHDcDsAEgBCAbNwOoASAEIAApA4ACNwLsASAEQfQBaiAAQYgCaigCADYCACAEIA02AvgBIARB/AFqIABBxAFqQTz8CgAAIARBADYC5AQgBEKAgICAIDcC3AQgBEICNwLUBCAEQgA3AswEIARCgICAgMAANwLEBCAEICM3A8gCIAQgCTYCxAIgBCAkNwK8AiAEIAE2ArgCIARBgQI7AfwEIARBgICAgHg2AowEIARCCDcChAQgBEIANwL8AyAEQoCAgIDAADcC9AMgBEIINwLsAyAEQYCAgIB4QQAgChs2AugDIARCADcD4AMgBCAGOgC0AyAEQQA2ArADIARBgICAgHg2AqQDIARBgICAgHg2ApgDIARCCDcDkAMgBEIANwOIAyAEQoCAgIDAADcDgAMgBEIENwP4AiAEQgA3A/ACIARCgICAgBA3A+gCIARCADcD4AIgBEKAgICAgAE3A9gCIARBADYCqAQgAEHgBGokAAwCCyAAQcgDaiAAQaACaikDADcDACAAQcADaiAAQZgCaikDADcDACAAIAApA5ACNwO4A0HE784AQSsgAEG4A2pBtO/OAEGo/c4AENUeAAsgAEGgAmogAEHQA2opAwA3AwAgAEGYAmogAEHIA2opAwA3AwAgACAAKQPAAzcDkAJBxO/OAEErIABBkAJqQbTvzgBBuP3OABDVHgALQgMMBAsjAEGgBGsiACQAIAAgATYCECAAQQhqIAJBCGoiCiABQQhqIg4QzxAgACgCDCEQIAAoAgghESAAQQE6ABcgAEHwAWogESAQIABBF2oQxw0CQCAAKALwAUEIRgRAIAAoAvgBIRIgACgC9AEhFSAAQYgDaiEGIwBBgAFrIgckAAJAAkACQCAKIABBEGooAgAiCUEIaiIMEOcRRQRAIAdBgICAgHg2AlAMAQsgCSAJKAIAIgFBAWo2AgAgAUEASA0BIAdBCGogCRDDIAsgCiAMENsSQf8BcSIBQQAgAUEJRxshBSMAQfABayIBJAACQAJAIAdB6ABqIggCfwJAAkACQAJAAkACQCAFQf8BcUEBaw4IAQIHEQMEAQUACyABQYACEOggIAFBADYCICABQoCAgIAQNwMYQShBCBCtNiIFRQ0RIAUgAUEo/AoAAEG4lM4ADAULIAFBNUEAQQFBARCgGCABKAIEIQUgASgCAEEBRg0RIAEoAggiFkH0kc4AQTX8CgAAIAhBNTYCDCAIIBY2AgggCCAFNgIEIAhBADYCAAwGC0H4AEEIEK02IgVFDREgBUGAgICAeDYCCEHYlM4ADAMLIAEQmSggAUIANwNoIAFCgICAgMAANwNgQfAAQQgQrTYiBUUNESAFIAFB8AD8CgAAQfiUzgAMAgsgARChJ0HgAUEIEK02IgVFDREgBSABQeAB/AoAAEGYlc4ADAELQQxBBBCtNiIFRQ0RIAVBADYCCCAFQoCAgIAQNwIAQbiVzgALNgIIIAggBTYCBCAIQQg2AgAMAQsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIAhBBGogARCZDiAIQQE2AgALIAFB8AFqJAAgBygCcCEFIAcoAmwhCAJAIAcoAmgiAUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgBTYCECAGIAg2AgwgBiABNgIIIAZCAjcDAAwBCyAHIAU2AmQgByAINgJgIAogDBCCEiEWQYCAgIB4IQECQAJAIAogDBDRESIMRQ0AIAdB6ABqIAwpAwggDCsDABDSEQJAIAcoAmgiDEEIaw4CAAECCyAHKQNwIRcgBygCbCEBCyAJIAkoAgAiDEEBajYCACAMQQBIDQIgBkEgaiAHQQhqQdgA/AoAACAGIBY6AJQBIAZBADYCkAEgBiAJNgKMASAGIBc3AoQBIAYgATYCgAEgBiAFNgJ8IAYgCDYCeCAGQQA2AhggBkEANgIQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDDYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDSLAwBCwALIAdBgAFqJAAgACkDiANCAlENDiAAQRhqIAZBmAH8CgAAIAogDhCCEiEBQQAhBiAAQQA2ArgBIABBADYCsAEgAEGwAWpBAhDpHiAAQcABakEAQTD8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDqAMgAEGAgICAeDYCnAMgAEGAgICAeDYCkAMgAEIANwOIAyAAQZADaiEBAkAgACgCEC4BGiIFQQBMBEAgAEGAgICAeDYC8AEMAQsgAEHwAWogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQfgBaigCADYCACABIAApAvABNwIAIABB8AFqIABBiANqQSj8CgAAAkAgACgCEC4BGCIBQQBMBEAgAEGAgICAeDYCiAMMAQsgAEGIA2ogAUEBakH//wNxQaD5zwAQthULIABBhAJqEIUwIABBjAJqIABBkANqKAIANgIAIAAgACkCiAMiFzcChAIgACkD8AEhGCAAKAL4ASEHIAApAvwBIRkgACgCkAIhEyAAKAKUAiEUIAApA4gCIRogAEEANgLQAyAAQQA2AsgDIABCADcDuAMgAEIANwOoAyAAQgA3A5gDIABCADcDiAMgAEHUA2ogAEG8AWpBNPwKAAAgAEGAgICAeDYClAQgAEGAgICAeDYCiAQgAEGIBGohAQJAIAAoAhAuARoiBUEATARAIABBgICAgHg2AvABDAELIABB8AFqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEH4AWooAgA2AgAgASAAKQLwATcCACAAQfABaiAAQYgDakGYAfwKAAACQCAAKAIQLgEYIgFBAEwEQCAAQYCAgIB4NgKIAwwBCyAAQYgDaiABQQFqQf//A3FBoPnPABC2FQsgAEH8AmoQhTAgAEGEA2ogAEGQA2ooAgA2AgAgACAAKQKIAzcC/AIgACkD8AEhGyAAKQP4ASEcIAApA4ACIR0gACkDiAIhHiAAKQOQAiEfIAApA5gCISAgACkDoAIhISAAKQOoAiEiIAAoArACIQsgACgCtAIhDSAAKAK4AiEPIABBvAFqIABBvAJqQTT8CgAAIBenIQUgCEECRiEGIAApA4ADISMgACkC9AIhJCAAKALwAiEBIAAoAvwCCyEJIAoQ9RUhCiAEIAg6AM4EIAQgAjYCvAQgBEG47c8ANgL8AyAEIAM2AvgDIAQgEjYChAQgBCAVNgKABCAEIBA2ArQCIAQgETYCsAIgBEHIBGogAEG4AWooAgA2AgAgBCAAKQKwATcCwAQgBCAAKAIQNgK4BCAEIABBGGpBmAH8CgAAIAQgFDYCvAMgBCATNgK4AyAEIBo3A7ADIAQgBTYCrAMgBCAZNwKkAyAEIAc2AqADIAQgGDcDmAMgBCAPNgLgASAEIA02AtwBIAQgCzYC2AEgBCAiNwPQASAEICE3A8gBIAQgIDcDwAEgBCAfNwO4ASAEIB43A7ABIAQgHTcDqAEgBCAcNwOgASAEIBs3A5gBIARB5AFqIABBvAFqQTT8CgAAIARBADYCtAQgBEKAgICAIDcCrAQgBEICNwKkBCAEQgA3ApwEIARCgICAgMAANwKUBCAEICM3A6gCIAQgCTYCpAIgBCAkNwKcAiAEIAE2ApgCIARBgQI7AcwEIARBgICAgHg2AuwDIARCCDcC5AMgBEIANwLcAyAEQoCAgIDAADcC1AMgBEIINwLMAyAEQYCAgIB4QQAgChs2AsgDIARCADcDwAMgBCAGOgCUAyAEQQA2ApADIARBgICAgHg2AoQDIARBgICAgHg2AvgCIARCCDcD8AIgBEIANwPoAiAEQoCAgIDAADcD4AIgBEIENwPYAiAEQgA3A9ACIARCgICAgBA3A8gCIARCADcDwAIgBEKAgICAgAE3A7gCIARBADYCiAQgAEGgBGokAAwBCwwMC0IEDAMLIwBB0ARrIgAkACAAIAE2AgggACACQQhqIgggAUEIaiIPEM8QIAAoAgQhDSAAKAIAIQwgAEEBOgAPIABBgAJqIAwgDSAAQQ9qEMcNAkAgACgCgAJBCEYEQCAAKAKIAiEQIAAoAoQCIREgAEGoA2ohBiMAQYABayIHJAACQAJAAkAgCCAAQQhqKAIAIgpBCGoiCRDnEUUEQCAHQYCAgIB4NgJQDAELIAogCigCACIBQQFqNgIAIAFBAEgNASAHQQhqIAoQxCALIAggCRDbEkH/AXEiAUEAIAFBCUcbIQUjAEHwAWsiASQAAkACQCAHQegAaiILAn8CQAJAAkACQAJAAkAgBUH/AXFBAWsOCAECBxADBAEFAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNECAFIAFBKPwKAABBmJjOAAwFCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNECABKAIIIg5B9JHOAEE1/AoAACALQTU2AgwgCyAONgIIIAsgBTYCBCALQQA2AgAMBgtB+ABBCBCtNiIFRQ0QIAVBgICAgHg2AghBuJjOAAwDCyABEJkoIAFCADcDaCABQoCAgIDAADcDYEHwAEEIEK02IgVFDRAgBSABQfAA/AoAAEHYmM4ADAILIAEQoSdB4AFBCBCtNiIFRQ0QIAUgAUHgAfwKAABB+JjOAAwBC0EMQQQQrTYiBUUNECAFQQA2AgggBUKAgICAEDcCAEGYmc4ACzYCCCALIAU2AgQgC0EINgIADAELIAFBAzoA5wEgAUECNgIEIAFB6JLOADYCACABQgE3AgwgAUGuAzYC7AEgASABQegBajYCCCABIAFB5wFqNgLoASALQQRqIAEQmQ4gC0EBNgIACyABQfABaiQAIAcoAnAhBSAHKAJsIQsCQCAHKAJoIgFBCEcEQCAGIAcpAnQ3AhQgBkEcaiAHQfwAaigCADYCACAGIAU2AhAgBiALNgIMIAYgATYCCCAGQgI3AwAMAQsgByAFNgJkIAcgCzYCYCAIIAkQghIhDkGAgICAeCEBAkACQCAIIAkQ0REiCUUNACAHQegAaiAJKQMIIAkrAwAQ0hECQCAHKAJoIglBCGsOAgABAgsgBykDcCEXIAcoAmwhAQsgCiAKKAIAIglBAWo2AgAgCUEASA0CIAZBMGogB0EIakHYAPwKAAAgBiAOOgCkASAGQQA2AqABIAYgCjYCnAEgBiAXNwKUASAGIAE2ApABIAYgBTYCjAEgBiALNgKIASAGQgA3AyAgBkIANwMQIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgCTYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahDTLAwBCwALIAdBgAFqJAAgACkDqANCAlENDyAAQRBqIAZBqAH8CgAAIAggDxCCEiEBQQAhBiAAQQA2AsQBIABBADYCvAEgAEG8AWpBAhDpHiAAQdABakEAQTD8CwACfyABQf8BcSILRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDyAMgAEGAgICAeDYCvAMgAEGAgICAeDYCsAMgAEIANwOoAyAAQbADaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCgAIMAQsgAEGAAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQYgCaigCADYCACABIAApAoACNwIAIABBgAJqIABBqANqQSj8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYCqAMMAQsgAEGoA2ogAUEBakH//wNxQaD5zwAQthULIABBlAJqEIUwIABBnAJqIABBsANqKAIANgIAIAAgACkCqAMiFzcClAIgACkDgAIhGCAAKAKIAiEHIAApAowCIRkgACgCoAIhEyAAKAKkAiEUIAApA5gCIRogAEIANwP4AyAAQgA3A+gDIABCADcD2AMgAEIANwPIAyAAQgA3A7gDIABCADcDqAMgAEGABGogAEHIAWpBOPwKAAAgAEGAgICAeDYCxAQgAEGAgICAeDYCuAQgAEG4BGohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2AoACDAELIABBgAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEGIAmooAgA2AgAgASAAKQKAAjcCACAAQYACaiAAQagDakGoAfwKAAACQCAAKAIILgEYIgFBAEwEQCAAQYCAgIB4NgKoAwwBCyAAQagDaiABQQFqQf//A3FBoPnPABC2FQsgAEGcA2oQhTAgAEGkA2ogAEGwA2ooAgA2AgAgACAAKQKoAzcCnAMgACkDgAIhGyAAKQOIAiEcIAApA5ACIR0gACkDmAIhHiAAKQOgAiEfIAApA6gCISAgACkDsAIhISAAKQO4AiEiIAApA8ACISMgACkDyAIhJCAAKQPQAiElIABByAFqIABB2AJqQTj8CgAAIBenIQUgC0ECRiEGIAApA6ADISYgACkClAMhJyAAKAKQAyEBIAAoApwDCyEKIAgQ9RUhCCAEIAs6APoEIAQgAjYC6AQgBEG47c8ANgK0BCAEIAM2ArAEIAQgEDYCvAQgBCARNgK4BCAEIA02AuwCIAQgDDYC6AIgBEH0BGogAEHEAWooAgA2AgAgBCAAKQK8ATcC7AQgBCAAKAIINgLkBCAEIABBEGpBqAH8CgAAIAQgFDYC9AMgBCATNgLwAyAEIBo3A+gDIAQgBTYC5AMgBCAZNwLcAyAEIAc2AtgDIAQgGDcD0AMgBCAlNwP4ASAEICQ3A/ABIAQgIzcD6AEgBCAiNwPgASAEICE3A9gBIAQgIDcD0AEgBCAfNwPIASAEIB43A8ABIAQgHTcDuAEgBCAcNwOwASAEIBs3A6gBIARBgAJqIABByAFqQTj8CgAAIARBADYC4AQgBEKAgICAIDcD2AQgBEICNwPQBCAEQgA3A8gEIARCgICAgMAANwPABCAEICY3A8gCIAQgCjYCxAIgBCAnNwK8AiAEIAE2ArgCIARBgQI7AfgEIARBgICAgHg2AqQEIARCCDcCnAQgBEIANwKUBCAEQoCAgIDAADcCjAQgBEIINwKEBCAEQYCAgIB4QQAgCBs2AoAEIARCADcD+AMgBCAGOgDMAyAEQQA2AsgDIARBgICAgHg2ArwDIARBgICAgHg2ArADIARCCDcDqAMgBEIANwOgAyAEQoCAgIDAADcDmAMgBEIENwOQAyAEQgA3A4gDIARCgICAgBA3A4ADIARCADcD+AIgBEKAgICAgAE3A/ACIARCADcD0AIgAEHQBGokAAwBCwwNC0IFDAILIwBBkAVrIgAkACAAIAE2AgggACACQQhqIgogAUEIaiIQEM8QIAAoAgQhDCAAKAIAIQ8gAEEBOgAPIABBsAJqIA8gDCAAQQ9qEMcNAkAgACgCsAJBCEYEQCAAKAK4AiERIAAoArQCIQ4gAEHgA2ohBiMAQYABayIHJAACQAJAAkAgCiAAQQhqKAIAIglBCGoiDRDnEUUEQCAHQYCAgIB4NgJQDAELIAkgCSgCACIBQQFqNgIAIAFBAEgNASAHQQhqIAkQwyALIAogDRDbEiEBQQZBACAKLQCVAUEBcRsgAUH/AXEiASABQQlGGyEFIwBB8AFrIgEkAAJAAkAgB0HoAGoiCAJ/AkACQAJAAkACQAJAIAVB/wFxQQFrDggBAgcPAwQBBQALIAFBgAIQ6CAgAUEANgIgIAFCgICAgBA3AxhBKEEIEK02IgVFDQ8gBSABQSj8CgAAQdiVzgAMBQsgAUE1QQBBAUEBEKAYIAEoAgQhBSABKAIAQQFGDQ8gASgCCCISQfSRzgBBNfwKAAAgCEE1NgIMIAggEjYCCCAIIAU2AgQgCEEANgIADAYLQfgAQQgQrTYiBUUNDyAFQYCAgIB4NgIIQfiVzgAMAwsgARCZKCABQgA3A2ggAUKAgICAwAA3A2BB8ABBCBCtNiIFRQ0PIAUgAUHwAPwKAABBmJbOAAwCCyABEKEnQeABQQgQrTYiBUUNDyAFIAFB4AH8CgAAQbiWzgAMAQtBDEEEEK02IgVFDQ8gBUEANgIIIAVCgICAgBA3AgBB2JbOAAs2AgggCCAFNgIEIAhBCDYCAAwBCyABQQM6AOcBIAFBAjYCBCABQeiSzgA2AgAgAUIBNwIMIAFBrgM2AuwBIAEgAUHoAWo2AgggASABQecBajYC6AEgCEEEaiABEJkOIAhBATYCAAsgAUHwAWokACAHKAJwIQUgBygCbCEIAkAgBygCaCIBQQhHBEAgBiAHKQJ0NwIUIAZBHGogB0H8AGooAgA2AgAgBiAFNgIQIAYgCDYCDCAGIAE2AgggBkICNwMADAELIAcgBTYCZCAHIAg2AmAgCiANEIISIRJBgICAgHghAQJAAkAgCiANENERIg1FDQAgB0HoAGogDSkDCCANKwMAENIRAkAgBygCaCINQQhrDgIAAQILIAcpA3AhFyAHKAJsIQELIAkgCSgCACINQQFqNgIAIA1BAEgNAiAGQRBqIAdBCGpB2AD8CgAAIAYgEjoArAEgBkEANgKoASAGIAk2AqQBIAYgFzcCnAEgBiABNgKYASAGQQA2AoQBIAZBADYCcCAGIAU2AmwgBiAINgJoIAZCADcDAAwDCyAHKAJsIQEgBykDcCEXIAYgBykDeDcDGCAGIBc3AxAgBiABNgIMIAYgDTYCCCAGQgI3AwAgB0HgAGoQvCoLIAcoAlBBgICAgHhGDQEgB0EIahCeLAwBCwALIAdBgAFqJAAgACkD4ANCAlENECAAQRBqIAZBsAH8CgAAIAogEBCCEiEBQQAhBiAAQQA2AswBIABBADYCxAEgAEHEAWpBAhDpHiAAQfgBakEAQTT8CwACfyABQf8BcSIIRQRAQYCAgIB4IQdBgICAgHghBUGAgICAeCEBQYCAgIB4DAELIABCADcDgAQgAEGAgICAeDYC9AMgAEGAgICAeDYC6AMgAEIANwPgAyAAQegDaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCsAIMAQsgAEGwAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQbgCaigCADYCACABIAApArACNwIAIABBsAJqIABB4ANqQSj8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYC4AMMAQsgAEHgA2ogAUEBakH//wNxQaD5zwAQthULIABBxAJqEIUwIABBzAJqIABB6ANqKAIANgIAIAAgACkC4AMiFzcCxAIgACkDsAIhGCAAKAK4AiEHIAApArwCIRkgACgC0AIhEyAAKALUAiEUIAApA8gCIRogAEIANwOQBCAAQgA3A4AEIABCADcD8AMgAEIANwPgAyAAQZgEaiAAQfABakE8/AoAACAAQYCAgIB4NgKEBSAAQYCAgIB4NgL4BCAAQQA2AuQEIABB+ARqIQECQCAAKAIILgEaIgVBAEwEQCAAQYCAgIB4NgKwAgwBCyAAQbACaiAFQQFqQf//A3FBoPnPABC2FQsgARCFMCABQQhqIABBuAJqKAIANgIAIAEgACkCsAI3AgAgAEGwAmogAEHgA2pBsAH8CgAAAkAgACgCCC4BGCIBQQBMBEAgAEGAgICAeDYC4AMMAQsgAEHgA2ogAUEBakH//wNxQaD5zwAQthULIABB1ANqEIUwIABB3ANqIABB6ANqKAIANgIAIAAgACkC4AM3AtQDIAApA7ACIRsgACkDuAIhHCAAKQPAAiEdIAApA8gCIR4gACkD0AIhHyAAKQPYAiEgIAApA+ACISEgAEHwAWogAEHoAmpBPPwKAAAgF6chBSAAQegBaiAAQawDaikCADcDACAAQdgBaiAAQcADaikDADcDACAAIAApAqQDNwPgASAAIAApA7gDNwPQASAIQQJGIQYgACgCtAMhCyAAKALIAyEBIAApAswDISIgACkD2AMhIyAAKALUAwshCSAKEPUVIQogBCAIOgCWBSAEIAI2AoQFIARBuO3PADYCrAQgBCADNgKoBCAEIBE2ArQEIAQgDjYCsAQgBCAMNgLkAiAEIA82AuACIARBkAVqIABBzAFqKAIANgIAIAQgACkCxAE3AogFIAQgACgCCDYCgAUgBCAAQRBqQbAB/AoAACAEIBQ2AuwDIAQgEzYC6AMgBCAaNwPgAyAEIAU2AtwDIAQgGTcC1AMgBCAHNgLQAyAEIBg3A8gDIAQgITcD4AEgBCAgNwPYASAEIB83A9ABIAQgHjcDyAEgBCAdNwPAASAEIBw3A7gBIAQgGzcDsAEgBEHoAWogAEHwAWpBPPwKAAAgBCALNgK0AiAEQQA2AvwEIARCgICAgCA3AvQEIARCAjcC7AQgBEIANwLkBCAEQoCAgIDAADcC3AQgBCAjNwPYAiAEIAk2AtQCIAQgIjcCzAIgBCABNgLIAiAEQawCaiAAQegBaikDADcCACAEIAApA+ABNwKkAiAEIAApA9ABNwO4AiAEQcACaiAAQdgBaikDADcDACAEQYECOwGUBSAEQYCAgIB4NgKcBCAEQgg3ApQEIARCADcCjAQgBEKAgICAwAA3AoQEIARCCDcC/AMgBEGAgICAeEEAIAobNgL4AyAEQgA3A/ADIAQgBjoAxAMgBEEANgLAAyAEQYCAgIB4NgK0AyAEQYCAgIB4NgKoAyAEQgg3A6ADIARCADcDmAMgBEKAgICAwAA3A5ADIARCBDcDiAMgBEIANwOAAyAEQoCAgIAQNwP4AiAEQgA3A/ACIARCgICAgIABNwPoAiAEQQA2ArgEIABBkAVqJAAMAQsMDgtCBgwBCyMAQZAFayIAJAAgACABNgIIIAAgAkEIaiIIIAFBCGoiEBDPECAAKAIEIQwgACgCACEPIABBAToADyAAQbACaiAPIAwgAEEPahDHDQJAIAAoArACQQhGBEAgACgCuAIhESAAKAK0AiEOIABB4ANqIQZBACEBIwBBgAFrIgckAAJAAkACQAJAAkAgCCAAQQhqIgUoAgAiCUEIaiINEOcRRQRAQQZBACAILQCVAUEBcRshAQwBCyAILQCVAQ0BCyAHQYCAgIB4NgJQDAELIAkgCSgCACIBQQFqNgIAIAFBAEgNASAHQQhqIAkQwyBBBiEBCyABIAggDRDbEkH/AXEiASABQQlGGyESIwBB8AFrIgEkAAJAAkACQCAHQegAaiIKAn8CQAJAAkACQAJAAkAgEkH/AXFBAWsOCAECCA8DBAEFAAsgAUGAAhDoICABQQA2AiAgAUKAgICAEDcDGEEoQQgQrTYiBUUNDyAFIAFBKPwKAABB+JbOAAwFCyABQTVBAEEBQQEQoBggASgCBCEFIAEoAgBBAUYNDyABKAIIIhJB9JHOAEE1/AoAACAKQTU2AgwgCiASNgIIIAogBTYCBCAKQQA2AgAMBwtB+ABBCBCtNiIFRQ0PIAVBgICAgHg2AghBmJfOAAwDCyABEJkoIAFCADcDaCABQoCAgIDAADcDYEHwAEEIEK02IgVFDQ8gBSABQfAA/AoAAEG4l84ADAILIAEQoSdB4AFBCBCtNiIFRQ0PIAUgAUHgAfwKAABB2JfOAAwBCyAFKAIAQQhqEN4lIRJBEEEEEK02IgVFDQEgBSASNgIMIAVBADYCCCAFQoCAgIAQNwIAQfiXzgALNgIIIAogBTYCBCAKQQg2AgAMAgtBBEEQEKM9AAsgAUEDOgDnASABQQI2AgQgAUHoks4ANgIAIAFCATcCDCABQa4DNgLsASABIAFB6AFqNgIIIAEgAUHnAWo2AugBIApBBGogARCZDiAKQQE2AgALIAFB8AFqJAAgBygCcCEBIAcoAmwhCgJAIAcoAmgiBUEIRwRAIAYgBykCdDcCFCAGQRxqIAdB/ABqKAIANgIAIAYgATYCECAGIAo2AgwgBiAFNgIIIAZCAjcDAAwBCyAHIAE2AmQgByAKNgJgIAggDRCCEiESQYCAgIB4IQUCQAJAIAggDRDRESINRQ0AIAdB6ABqIA0pAwggDSsDABDSEQJAIAcoAmgiDUEIaw4CAAECCyAHKQNwIRcgBygCbCEFCyAJIAkoAgAiDUEBajYCACANQQBIDQIgBkEQaiAHQQhqQdgA/AoAACAGIBI6AKwBIAZBADYCqAEgBiAJNgKkASAGIBc3ApwBIAYgBTYCmAEgBkEANgKEASAGQQA2AnAgBiABNgJsIAYgCjYCaCAGQgA3AwAMAwsgBygCbCEBIAcpA3AhFyAGIAcpA3g3AxggBiAXNwMQIAYgATYCDCAGIA02AgggBkICNwMAIAdB4ABqELwqCyAHKAJQQYCAgIB4Rg0BIAdBCGoQniwMAQsACyAHQYABaiQAIAApA+ADQgJRDQ8gAEEQaiAGQbAB/AoAACAIIBAQghIhBUEAIQEgAEEANgLMASAAQQA2AsQBIABBxAFqQQIQ6R4gAEH4AWpBAEE0/AsAAn8gBUH/AXEiBkUEQEGAgICAeCEHQYCAgIB4IQpBgICAgHghBUGAgICAeAwBCyAAQgA3A4AEIABBgICAgHg2AvQDIABBgICAgHg2AugDIABCADcD4AMgAEHoA2ohAQJAIAAoAgguARoiBUEATARAIABBgICAgHg2ArACDAELIABBsAJqIAVBAWpB//8DcUGg+c8AELYVCyABEIUwIAFBCGogAEG4AmooAgA2AgAgASAAKQKwAjcCACAAQbACaiAAQeADakEo/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AuADDAELIABB4ANqIAFBAWpB//8DcUGg+c8AELYVCyAAQcQCahCFMCAAQcwCaiAAQegDaigCADYCACAAIAApAuADIhc3AsQCIAApA7ACIRggACgCuAIhByAAKQK8AiEZIAAoAtACIRMgACgC1AIhFCAAKQPIAiEaIABCADcDkAQgAEIANwOABCAAQgA3A/ADIABCADcD4AMgAEGYBGogAEHwAWpBPPwKAAAgAEGAgICAeDYChAUgAEGAgICAeDYC+AQgAEEANgLkBCAAQfgEaiEBAkAgACgCCC4BGiIFQQBMBEAgAEGAgICAeDYCsAIMAQsgAEGwAmogBUEBakH//wNxQaD5zwAQthULIAEQhTAgAUEIaiAAQbgCaigCADYCACABIAApArACNwIAIABBsAJqIABB4ANqQbAB/AoAAAJAIAAoAgguARgiAUEATARAIABBgICAgHg2AuADDAELIABB4ANqIAFBAWpB//8DcUGg+c8AELYVCyAAQdQDahCFMCAAQdwDaiAAQegDaigCADYCACAAIAApAuADNwLUAyAAKQOwAiEbIAApA7gCIRwgACkDwAIhHSAAKQPIAiEeIAApA9ACIR8gACkD2AIhICAAKQPgAiEhIABB8AFqIABB6AJqQTz8CgAAIBenIQogAEHoAWogAEGsA2opAgA3AwAgAEHYAWogAEHAA2opAwA3AwAgACAAKQKkAzcD4AEgACAAKQO4AzcD0AEgBkECRiEBIAAoArQDIQsgACgCyAMhBSAAKQLMAyEiIAApA9gDISMgACgC1AMLIQkgCBD1FSEIIAQgBjoAlgUgBCACNgKEBSAEQbjtzwA2AqwEIAQgAzYCqAQgBCARNgK0BCAEIA42ArAEIAQgDDYC5AIgBCAPNgLgAiAEQZAFaiAAQcwBaigCADYCACAEIAApAsQBNwKIBSAEIAAoAgg2AoAFIAQgAEEQakGwAfwKAAAgBCAUNgLsAyAEIBM2AugDIAQgGjcD4AMgBCAKNgLcAyAEIBk3AtQDIAQgBzYC0AMgBCAYNwPIAyAEICE3A+ABIAQgIDcD2AEgBCAfNwPQASAEIB43A8gBIAQgHTcDwAEgBCAcNwO4ASAEIBs3A7ABIARB6AFqIABB8AFqQTz8CgAAIAQgCzYCtAIgBEEANgL8BCAEQoCAgIAgNwL0BCAEQgI3AuwEIARCADcC5AQgBEKAgICAwAA3AtwEIAQgIzcD2AIgBCAJNgLUAiAEICI3AswCIAQgBTYCyAIgBEGsAmogAEHoAWopAwA3AgAgBCAAKQPgATcCpAIgBCAAKQPQATcDuAIgBEHAAmogAEHYAWopAwA3AwAgBEGBAjsBlAUgBEGAgICAeDYCnAQgBEIINwKUBCAEQgA3AowEIARCgICAgMAANwKEBCAEQgg3AvwDIARBgICAgHhBACAIGzYC+AMgBEIANwPwAyAEIAE6AMQDIARBADYCwAMgBEGAgICAeDYCtAMgBEGAgICAeDYCqAMgBEIINwOgAyAEQgA3A5gDIARCgICAgMAANwOQAyAEQgQ3A4gDIARCADcDgAMgBEKAgICAEDcD+AIgBEIANwPwAiAEQoCAgICAATcD6AIgBEEANgK4BCAAQZAFaiQADAELDA0LQgcLNwMADwsjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyfzgA2AgggAEIENwIQIABBCGpB9J/OABDvLAALQQhBKBCjPQALIAUgASgCCEGch84AEP0vAAtBCEH4ABCjPQALQQhB8AAQoz0AC0EIQeABEKM9AAtBBEEMEKM9AAsgAEGYA2ogAEGAAmopAwA3AwAgAEGQA2ogAEH4AWopAwA3AwAgACAAKQPwATcDiANBxO/OAEErIABBiANqQbTvzgBBqP3OABDVHgALIABBgAJqIABBoANqKQMANwMAIABB+AFqIABBmANqKQMANwMAIAAgACkDkAM3A/ABQcTvzgBBKyAAQfABakG0784AQbj9zgAQ1R4ACyAAQbgDaiAAQZACaikDADcDACAAQbADaiAAQYgCaikDADcDACAAIAApA4ACNwOoA0HE784AQSsgAEGoA2pBtO/OAEGo/c4AENUeAAsgAEGQAmogAEHAA2opAwA3AwAgAEGIAmogAEG4A2opAwA3AwAgACAAKQOwAzcDgAJBxO/OAEErIABBgAJqQbTvzgBBuP3OABDVHgALIABB8ANqIABBwAJqKQMANwMAIABB6ANqIABBuAJqKQMANwMAIAAgACkDsAI3A+ADQcTvzgBBKyAAQeADakG0784AQaj9zgAQ1R4ACyAAQcACaiAAQfgDaikDADcDACAAQbgCaiAAQfADaikDADcDACAAIAApA+gDNwOwAkHE784AQSsgAEGwAmpBtO/OAEG4/c4AENUeAAvAAQIDfwJ9IwBBIGsiAiQAIAIgACgCBCIDNgIEAkAgA0EQRgRAIAAoAgAiAyABQQ9xIgRBAXRqLwEAIQAgAUH/AXEEfyAEQQFrIgFBD0sNAiAAIAMgAUEBdGovAQBrBSAAC0H//wNxQQJ0QcyG4wBqKgIAIQUgAy8BHkECdEHMhuMAaioCACACQSBqJAAgBZMPCyACQQA2AghBACACQQRqQeyG8wAgAkEIakGAh/MAEK8rAAtBf0EQQfCG8wAQwyEAC8QBAQN/IwBBIGsiAyQAIABBASAAKAIIIgJBAXQiASABQQFNGyIBIAJrEIwcAkACQAJAIAFBAUYNACAAKAIIIgIgAUEBdiIBSQ0BIAIgAWsiAiABRw0CIAAoAgQhACABRSICRQRAIAAgAWogACAB/AoAAAsgAg0AIABBACAB/AsACyADQSBqJAAPCyADQQA2AhggA0EBNgIMIANB1IH/ADYCCCADQgQ3AhAgA0EIakHsgf8AEO8sAAsgAiABQfyB/wAQszsAC8MBAgR/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpB3MmEASgCACICNgIAIAFB1MmEASkCACIFNwMIIAAtAAAgAC0AASEAIAFBCGoiBBC/DEENRiAAQQNGcUUEQCABQShqIAI2AgAgASAFNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCAEQfDIhAEQ7ywACyABQUBrJAALwwECBH8BfiMAQUBqIgEkACABIAA2AgQgAUEQakGAyoQBKAIAIgI2AgAgAUH4yYQBKQIAIgU3AwggAC0AACAALQABIQAgAUEIaiIEEL8MQQ1GIABBAkZxRQRAIAFBKGogAjYCACABIAU3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIARB8MiEARDvLAALIAFBQGskAAvDAQIEfwF+IwBBQGoiASQAIAEgADYCBCABQRBqQaTKhAEoAgAiAjYCACABQZzKhAEpAgAiBTcDCCAALQAAIAAtAAEhACABQQhqIgQQvwxBDUYgAEEBRnFFBEAgAUEoaiACNgIAIAEgBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgBEHwyIQBEO8sAAsgAUFAayQAC9UBAQJ/IwBBQGoiAyQAIAMgAjYCACABKAIUQQJ2QQFrIgQgAk0EQCADIAQ2AhwgA0EENgIIIANBpI+GATYCBCADQgQ3AhAgA0E7NgI8IANBxwI2AjQgA0HcjoYBNgIwIANBxwI2AiwgA0HMjoYBNgIoIANBOzYCJCADIANBIGo2AgwgAyADQRxqNgI4IAMgAzYCICADQQRqQcSPhgEQ7ywACyAAIAEoAhAgAkECdGoiAigCACIEIAEoAhxqNgIAIAAgAkEEaigCACAEazYCBCADQUBrJAAL1QEBAn8jAEFAaiIDJAAgAyACNgIAIAEoAhRBAnZBAWsiBCACTQRAIAMgBDYCHCADQQQ2AgggA0Gkj4YBNgIEIANCBDcCECADQTs2AjwgA0HHAjYCNCADQeyPhgE2AjAgA0HHAjYCLCADQcyOhgE2AiggA0E7NgIkIAMgA0EgajYCDCADIANBHGo2AjggAyADNgIgIANBBGpBxI+GARDvLAALIAAgASgCECACQQJ0aiICKAIAIgQgASgCHGo2AgAgACACQQRqKAIAIARrNgIEIANBQGskAAu6DgIPfwF+IwBBEGsiCiQAIAAoAgwhAwJAAkACQAJAAkACQCAAKAIEDgIAAQILIAMNAUEBIQNBACEADAILIAMNACAAKAIAIgMoAgQhACADKAIAIQMMAQsgCkEEaiAAEJkODAELIApBBGogAEEAQQFBARCgGCAKKAIIIQIgCigCBEEBRg0BIAooAgwhBiAABEAgBiADIAD8CgAACyAKIAA2AgwgCiAGNgIIIAogAjYCBAsCf0EAIQYjAEHgAGsiBSQAIAVBIGogCkEEaiINKAIEIgkgDSgCCCICQaiwiAFBCRCpAwJAAkAgBQJ/AkACQAJAIAUoAiBBAUYEQCAFQShqIQAgBSgCXCEDIAUoAlghBiAFKAJUIQQgBSgCUCEIIAUoAkRBf0YNASAFQRRqIAAgCCAEIAYgA0EAEOALDAULQQAgBS0ALg0DGiAFLQAtIQYgBSgCKCIBRQ0BIAUoAlQhCCAFKAJQIQMDQAJAIAEgCE8EQCABIAhGDQEMCAsgASADaiwAAEFASA0HCyABIANqIgRBAWssAAAiAEEASARAIABBP3ECfyAEQQJrLQAAIgDAIgdBQE4EQCAAQR9xDAELIAdBP3ECfyAEQQNrLQAAIgDAIgdBQE4EQCAAQQ9xDAELIAdBP3EgBEEEay0AAEEHcUEGdHILQQZ0cgtBBnRyIQALIAZBAXENA0EBIQYCf0F/IABBgAFJDQAaQX4gAEGAEEkNABpBfUF8IABBgIAESRsLIAFqIgENAAtBACEBDAILIAVBFGogACAIIAQgBiADQQEQ4AsMAwtBACIBIAZBAXFFDQEaCyAFIAE2AhhBAQs2AhQLAkAgBSgCFEEBRw0AIAIgCWohACAFKAIYIgxBCWoiByEBAkACQAJAAkACQAJAA0ACQCABRQ0AIAEgAk8EQCABIAJGDQEMCAsgASAJaiwAAEG/f0wNBwsCQAJAAn8gASACRgRAIAAhBiACDAELIAEgCWoiBi0AAEEwa0H/AXFBCkkNASABCyEEAkAgAUUNACACIARNBEAgAiAERg0BDAkLIAYsAABBv39MDQgLIAYgAiAEa0GxsIgBQQgQ9C5FDQkgBEEIaiILIQADQAJAIABFDQAgACACTwRAIAAgAkYNAQwJCyAAIAlqLAAAQb9/TA0ICwJAAkACQCAAIAJGBEAgAiEDDAELIAAgCWotAABBMGtB/wFxQQpJDQEgACEDIAAgAkkNDQsgBCAHSQ0GIAdFDQQgAiAHSw0BIAIgB0cNBgwECyAAQQFqIQAMAQsLIAcgCWosAABBv39KDQEMAwsgAUEBaiEBDAELCwJAIAFFDQAgAiAETQRAIAIgBEYNAQwCCyAGLAAAQb9/TA0BCyAHIAlqIQECQAJAAkAgBCAHayIHDgIJAAELQQEhBCABLQAAQStrDgMIAQgBCyABLQAAQStGBEAgB0EBayEEIAFBAWohASAHQQpJDQEMAwsgByIEQQlPDQILQQAhBgNAIAEtAABBMGsiCEEJSw0HIAFBAWohASAIIAZBCmxqIQYgBEEBayIEDQALDAILIAkgAiAHIARBzLGIARCjNgALQQAhBgNAIARFDQEgAS0AAEEwayIHQQlLDQUgBq1CCn4iEEIgiKcNBSABQQFqIQEgBEEBayEEIAcgEKciD2oiBiAPTw0ACwwECwJAAkACQAJAAkACQCADIAtJDQACQCALRQ0AIAIgC00EQCACIAtHDQIMAQsgCSALaiwAAEG/f0wNAQsgAEEAIAIgA0cbDQAgCSALaiEBIAMgC2siAw4CCQECCyAJIAIgCyADQdyxiAEQozYAC0EBIQAgAS0AAEEraw4DBwEHAQsgAS0AAEErRgRAIANBAWshACABQQFqIQEgA0EKSQ0BDAILIAMiAEEJTw0BC0EAIQgDQCABLQAAQTBrIgNBCUsNBiABQQFqIQEgAyAIQQpsaiEIIABBAWsiAA0ACwwBC0EAIQgDQCAARQ0BIAEtAABBMGsiA0EJSw0FIAitQgp+IhBCIIinDQUgAUEBaiEBIABBAWshACADIBCnIgRqIgggBE8NAAsMBAtBASEOIAIgDEkNAwJAIAxFIAIgDE1yRQRAIAkgDGosAABBv39MDQELIA0gDDYCCAwEC0HYr4gBQTBB7LGIARCfKQALIAkgAiAAIAJBvLGIARCjNgALIAkgAiAEIAJBrLGIARCjNgALIAkgAiABIAJBnLGIARCjNgALIAVBKGogDUEIaigCADYCACAFIA0pAgA3AyAgBUEIaiAFQSBqQYyxiAEQkCEgBSgCDCEDIAUoAgghAkEUQQQQrTYiAARAIAAgAjYCBCAAQQA2AgAgACAIQQAgDhs2AhAgACAGQQAgDhs2AgwgACADNgIIIAVB4ABqJAAgAAwCC0EEQRQQoz0ACyADIAhBACABQZiwiAEQozYACyAKQRBqJAAPCyACIAooAgxBiLCIARD9LwALnCMDF38BfgN9AkAgAgRAIAJBA3RBH2oCfyALKAIAIh0gBmdBIGpBP3MiBkEPSw0AGiAdQQEgBnRBgNQCcUUNABogBCEXIAUhEyAGIQQgByERIAghEiAKIRpBACEKIwBBoAprIg8kACAPQQBBgAT8CwAgCygCACEOIA9BgARqIgVBAEGAAvwLACAPQYAGaiIGQQBBgAT8CwBBgIAGIAIiFCAUQYCABk8bIghBACALIAwgDRDoI0ENQgAgCyAMIA0Q3xMgACABIAggBSAGIAsgDCANEPULIR8CQAJAIAkiISgCACIFQQhPBEBBByEGA0AgBkEHa0EDdiIHQYAETw0CQQggByAaajEAACALIAwgDRDfEyAGQQhqIgYgBUkNAAsLIAVBA3YiBkGABE8EQCAGQYAEQeTZzgAQwyEAC0HAACAEayEVIA5BA2ohGyAFQQdxIAYgGmoxAAAgCyAMIA0Q3xNBASEZIAghB0EAIQQMAQsgB0GABEGU3s4AEMMhAAsCQAJAAkADQAJAIAQhCQJAAkACQAJAIBlBAWsOAgACAQsgD0HUj/MAQYAE/AoAACAHIApqIR5BACEZIAdBD00NBCAKQQFqIgYgAU0EQCAAIAZqIAEgBmsgFRDnHCEFIApBAmoiECAUQRBrIg4gB0EFayIWIA4gFkkbIApqIhxLDQUgHkEFayEiQX8hBANAQSEhIANAAkACQAJAAkACQAJAIBAiDiABTQRAIAAgDmogASAOayAVEOccIRYgASAGSQ0BIAEgBiAEayIQSQ0CIAYgEEtBACAAIAZqIiMgASAGayIkIAAgEGogASAQaxDFFBtFBEAgBSATSQRAIBcgBUECdGoiBSgCACEQIAUgBjYCACABIBBJDQUgIyAkIAAgEGogASAQaxDFFA0HDAgLIAUgE0H02s4AEMMhAAsgBSATSQ0EIAUgE0GU284AEMMhAAsgDiABQcTazgAQrzsACyAGIAFB1NrOABCvOwALIBAgAUHk2s4AEK87AAsgECABQYTbzgAQrzsACyAXIAVBAnRqIAY2AgALIAYgEGsiBUHw/w9LDQACQAJAAkACQCAQQQVqIg4gAU0EQCABIAZBBWoiEEkNASAAIA5qIAEgDmsgACAQaiABIBBrICIgBmsQsiAhEAJAIAYgCWsiDkHCME8EQCAJIBhrIA4gHxDzNEUEQCAOIBEgEiAPIAsgDCANEMsUDAILIAAgGGogASAYayAGIBhrIBtBA2sgCyAMIA0QsBkgCiAUaiAGayEUQQIhGSAGIQogBiEEDA8LIA4gESASIA8gCyAMIA0QmgoLIAEgCUkNAiAAIAlqIAEgCWsgDiAPQYAEaiAPQYAGaiALIAwgDRDHHCAEIAVHBEAgBSARIBIgDyALIAwgDRCTFgwFCwwDCyAOIAFBpNvOABCvOwALIBAgAUG0284AEK87AAsgCSABQcTbzgAQrzsACyARLQBAIBIzAYABIAsgDCANEN8TIA8gDygCgAJBAWo2AoACIAQhBQsCQAJAAkACQAJAAkACQAJAAkACQCAQQQVqIhAiBEEMTwRAIARByABPBEAgBEGIAU8EQCAEQcgQTwRAIBEtACcgEjMBTiALIAwgDRDfE0EYIARByBBrrSALIAwgDRDfEyARLQBAIBIzAYABIAsgDCANEN8TIA8gDygCnAFBAWo2ApwBDAwLIARByABrIg5nQSBqQT9zIglBHGoiBEGAAU8NAyAEQYABTyIWDQQgBCARai0AACASIARBAXRqMwEAIAsgDCANEN8TIAkgDq1CfyAJrYZ8IAsgDCANEN8TIBEtAEAgEjMBgAEgCyAMIA0Q3xMgFg0FIA8gBEECdGoiBCAEKAIAQQFqNgIADAsLIARBCGsiCUEFdkEeaiIEQYABTw0FIARBgAFPIg4NBiAEIBFqLQAAIBIgBEEBdGozAQAgCyAMIA0Q3xNBBSAJQR9xrSALIAwgDRDfEyARLQBAIBIzAYABIAsgDCANEN8TIA4EQCAEQYABQZSZ8wAQwyEACyAPIARBAnRqIgQgBCgCAEEBajYCAAwKCyAEQQhrIg4gDmdBIGpBP3NBAWsiCXYiFiAJQQF0akEEaiIEQYABTw0GIARBgAFPBEAgBEGAAUHEmfMAEMMhAAsgBCARai0AACASIARBAXRqMwEAIAsgDCANEN8TIAkgDiAWIAl0a60gCyAMIA0Q3xMgBEGAAUkNCCAEQYABQdSZ8wAQwyEACyAEQQRrIgRBgAFPDQYgBEGAAU8EQCAEQYABQfSZ8wAQwyEACyAEIBFqLQAAIBIgBEEBdGozAQAgCyAMIA0Q3xMgBEGAAUkNByAEQYABQYSa8wAQwyEACyAEQYABQfSX8wAQwyEACyAEQYABQYSY8wAQwyEACyAEQYABQbSY8wAQwyEACyAEQYABQdSY8wAQwyEACyAEQYABQeSY8wAQwyEACyAEQYABQbSZ8wAQwyEACyAEQYABQeSZ8wAQwyEACyAPIARBAnRqIgQgBCgCAEEBajYCAAwBCyAPIA8oAoACQQFqNgKAAgsgBiAQaiIJIBxPDQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCUECSwRAIAEgCUEDayIESQ0BIA9CADcDgAogASAEa0EHTQ0XIA9BgApqQQggACAEakEIQdTZzgAQ1SwgDykDgAoiJUEAIBUQ4y0hBiAlQQMgFRDjLSEOIAYgE08NAiAXIAZBAnRqIAQ2AgAgJUEBIBUQ4y0iBCATTw0DIBcgBEECdGogCUECazYCACAlQQIgFRDjLSIEIBNPDQQgFyAEQQJ0aiAJQQFrNgIAAkACQAJAIA4gE0kEQCAXIA5BAnRqIgQoAgAhBiAEIAk2AgAgASAGSQ0CIAUhBCAAIAlqIAEgCWsgACAGaiABIAZrEMUUDQEMEAsgDiATQeTczgAQwyEACwNAIAEgBkEFaiIESQ0IIAEgCUEFaiIOSQ0JIAAgBGogASAEayAAIA5qIAEgDmsgIiAJaxCyICEOIAkgBmsiBEHw/w9LBEAgBSEEDBALAkACQAJAAkACQAJAAkAgDkEFaiIQIgVBCk8EQCAFQYYBTwRAIAVBxhBPBEAgES0AJyASMwFOIAsgDCANEN8TQRggBa1CxhB9IAsgDCANEN8TIA8gDygCnAFBAWo2ApwBDAkLIAVBxgBrIg5nQSBqQT9zIgZBHGoiBUGAAU8NAiAFQYABTw0DIAUgEWotAAAgEiAFQQF0ajMBACALIAwgDRDfEyAGIA6tQn8gBq2GfCALIAwgDRDfEyAFQYABSQ0HIAVBgAFB5JrzABDDIQALIAVBBmsiDiAOZ0EgakE/c0EBayIGdiIWIAZBAXRqQRRqIgVBgAFPDQMgBUGAAU8EQCAFQYABQYSb8wAQwyEACyAFIBFqLQAAIBIgBUEBdGozAQAgCyAMIA0Q3xMgBiAOrSAWrSAGrYZ9IAsgDCANEN8TIAVBgAFJDQUgBUGAAUGUm/MAEMMhAAsgBUEOaiIFQYABTw0DIAVBgAFPBEAgBUGAAUG0m/MAEMMhAAsgBSARai0AACASIAVBAXRqMwEAIAsgDCANEN8TIAVBgAFJDQUgBUGAAUHEm/MAEMMhAAsgBUGAAUHEmvMAEMMhAAsgBUGAAUHUmvMAEMMhAAsgBUGAAUH0mvMAEMMhAAsgBUGAAUGkm/MAEMMhAAsgDyAFQQJ0aiIFIAUoAgBBAWo2AgAMAQsgDyAFQQJ0aiIFIAUoAgBBAWo2AgALIAQgESASIA8gCyAMIA0QkxYgCSAQaiIJIBxPDRYgCUECTQ0KIAEgCUEDayIFSQ0LIA9CADcDgAogASAFa0EHTQ0aIA9BgApqQQggACAFakEIQdTZzgAQ1SwgDykDgAoiJUEAIBUQ4y0hBiAlQQMgFRDjLSEOIAYgE08NDCAXIAZBAnRqIAU2AgAgJUEBIBUQ4y0iBSATTw0NIBcgBUECdGogCUECazYCACAlQQIgFRDjLSIFIBNPDQ4gFyAFQQJ0aiAJQQFrNgIAIA4gE08NAiAXIA5BAnRqIgUoAgAhBiAFIAk2AgAgASAGSQ0BIAQhBSAAIAlqIAEgCWsgACAGaiABIAZrEMUUDQALDA4LIAYgAUH03M4AEK87AAsgDiATQfTdzgAQwyEAC0H0284AQR9BlNzOABCfKQALIAQgAUGk3M4AEK87AAsgBiATQbTczgAQwyEACyAEIBNBxNzOABDDIQALIAQgE0HU3M4AEMMhAAsgBCABQYTdzgAQrzsACyAOIAFBlN3OABCvOwALQfTbzgBBH0Gk3c4AEJ8pAAsgBSABQbTdzgAQrzsACyAGIBNBxN3OABDDIQALIAUgE0HU3c4AEMMhAAsgBSATQeTdzgAQwyEACyAJQQFqIQYgASAJSwRAIAAgBmogASAGayAVEOccIQUgCUECaiIQIBxNDQMMBwsgBiABQYTezgAQrzsACyAgQQV2ICBBAWohICAWIQUgDiIGaiIQIBxNDQALCwwDCyAGIAFBtNrOABCvOwALQYCABCAUIAdrIhQgFEGAgARPGyEFIAcgCmohCgJAAkACQAJAAkACQAJAIBRFDQAgBSAIaiIGQYGAwABPDQAgASAKSQ0EAn8gACAKaiEWIAEgCmshECAPQYAEaiEOQQAhBCMAQYAIayIHJAAgB0EAQYAI/AsAAkACfQJAIAVFDQADQCAEIBBPDQMgByAEIBZqLQAAQQJ0aiIZIBkoAgBBAWo2AgAgBEEraiIEIAVJDQALIAVBKmoiEEErbiEEIBBBgNYASQ0AIASzIiYQ6hIMAQsgBLMhJiAEQQJ0QcCH8wBqKgIACyEnICYgJ0MAAAA/kpRDAABIQ5IhJkEAIQQDQCAOLQAAsyEoIAQgB2ooAgAiELMhJyAOQQFqIQ4gJgJ9IBBBgAJPBEAgJxDqEgwBCyAQQQJ0QcCH8wBqKgIACyAokiAnlJMhJiAEQQRqIgRBgAhHDQALIAdBgAhqJAAgJkMAAAAAYAwBCyAEIBBB5JvzABDDIQALDQELQQIhGSAFIQcgCSAeIgRPDQkgBCAJayIFQcIwSQ0BIAkgGGsgBSAfEPM0RQ0CIAAgGGogASAYayAEIBhrIBtBA2sgCyAMIA0QsBkMCQsgBkEBayEOIBshBEEUIQcCQAJAA0AgBEEDdiIIIA1PDQEgCCAMaiIIIAgtAABBf0EIIARBB3EiEGsiCCAHIAcgCEsbIgggEGp0QX8gEHRBf3NycSAOQX8gCHRBf3NxIBB0cjoAACAEIAhqIQQgDiAIdiEOIAcgCGsiBw0ACwwBCyAIIA1B9JvzABDDIQALQQEhGSAGIQggBSEHDAYLIAUgESASIA8gCyAMIA0QmgogASAJSQ0CIAAgCWogASAJayAFIA9BgARqIA9BgAZqIAsgDCANEMccDAcLIAUgESASIA8gCyAMIA0QyxQgASAJSQ0CIAAgCWogASAJayAFIA9BgARqIA9BgAZqIAsgDCANEMccDAYLIAogAUGE2s4AEK87AAsgCSABQaTazgAQrzsACyAJIAFBlNrOABCvOwALAkAgFEUEQCADRQ0BDAULIAsoAgBBgIAGIBQgFEGAgAZPGyIIQQAgCyAMIA0Q6CNBDUIAIAsgDCANEN8TIAEgCkkNAiAAIApqIAEgCmsgCCAPQYAEaiAPQYAGaiALIAwgDRD1CyEfIA8gESASIAsgDCANEOIHQQNqIRtBASEZIAghByAKIRgMAQsgIUEANgIAIBpBADoAACAPIBEgEiAhIBpBgAQQ4gcMAwsgCSEEDAELCyAKIAFB9NnOABCvOwALIA9BoApqJAAMAQsgD0EANgKYCiAPQQE2AowKIA9BmNfOADYCiAogD0IENwKQCiAPQYgKakHE2c4AEO8sAAsgCygCAAsgHWtJBEAgACABIAIgHSALIAwgDRCwGQsgA0UNAQtBAUIBIAsgDCANEN8TQQFCASALIAwgDRDfEyALIAsoAgBBB2pBeHE2AgALC7oBAQN/IAJFBEBBAQ8LAkAgAyAAKAIAIgUgAUdyRQRAIAAoAgwhAyAAKAIQIQYgACgCCCEEQQEhBQwBCyAAIAAoAgwiBjYCECAAIAAoAgQiBDYCCCAAIAUgBGsiAzYCDCAAIAEgA2s2AgRBACEFIAMgBmtBB0sNACAAIAM2AhAgAyEGCyAAIAEgAmoiAjYCACACIAQgBmpNIAEgAyAEak9yRQRAIAAgAiAEayIAIAMgACADSBs2AhALIAUL7wEBAn8jAEEQayICJAAgAEEEaiEDAn8CQAJAAkACQCAAKAIAQQFrDgMBAgMACyACIAM2AgQgAUH0rf4AQQ5Bgq7+AEEEIABBEGpB1K3+AEGQqv4AQQcgAkEEakHkrf4AEI4YDAMLIAIgAzYCCCABQdiu/gBBDUGCrv4AQQQgAEEQakHIrv4AQZCq/gBBByACQQhqQeSt/gAQjhgMAgsgAiADNgIMIAFBpK/+AEEQQYKu/gBBBCAAQRBqQZSv/gBBkKr+AEEHIAJBDGpB5K3+ABCOGAwBCyAAKAIEIAEgACgCCCgCDBECAAsgAkEQaiQAC8EBAgR/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBuMmEASgCACICNgIAIAFBsMmEASkCACIFNwMIIAAtAAAhAyAALQABIAFBCGoiBBC/DEUgA0ENRnFFBEAgAUEoaiACNgIAIAEgBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgBEHwyIQBEO8sAAsgAUFAayQAC+kHARd/IwBBMGsiBCQAIAQgASgCKDYCDCAEIAEoAiQ2AhAgBCABEO88IAQoAgQhAiAEIAQoAgAiAzYCICAEIAMgAkHEAGxqNgIkIAQgBEEQajYCLCAEIARBDGo2AigjAEEgayIFJAAgBUEUaiAEQSBqIgIoAgQgAigCAGtBxABuQQBBBEEIEKAYIAUoAhghAyAFKAIUQQFGBEAgAyAFKAIcQdDqhQEQ/S8ACyAEQRRqIQ0gBUEQaiIVQQA2AgAgBSAFKAIcNgIMIAUgAzYCCCMAQSBrIgYkACACKAIEIAIoAgBrQcQAbiIHIAVBCGoiAygCACADKAIIIghrSwRAIAMgCCAHQQRBCBDeKCADKAIIIQgLIAMoAgQhByAGQQhqIAJBCGopAgA3AwAgBiACKQIANwMAIAYgBzYCHCAGIAg2AhggBiADQQhqNgIUIwBBgAFrIgIkACAGQRRqIgcoAgQhCCAHKAIAIRYCQAJAIAYoAgAiAyAGKAIEIglHBEAgBigCDCEXIAYoAgghGCAHKAIIIAhBA3RqIQcgCSADa0HEAG4hEiACQSRqIRMgAkEwaiEUA0AgFygCACEJAn8CQCAYKAIAIgoNACAJIANBJGooAgBHDQAgAkHcAGogA0EYahDRBiADQShqKAIAIQwgAkHoAGogAxC+FSACQfQAaiADQQxqEIALIANBLGooAgAiCgRAIAogCigCACILQQFqNgIAIAtBAEgNBSADQTxqKAIAIQ4gA0E4aigCACEPIANBNGooAgAhECADQTBqKAIAIREgA0FAaygCACELCyAUIAIpAlw3AgAgEyACKQJ0NwIAIBRBCGogAkHkAGooAgA2AgAgAkEgaiACQfAAaigCADYCACATQQhqIAJB/ABqKAIANgIAIAIgDDYCQCACIAk2AjwgAiACKQJoNwMYIAIgCzYCWCACIA42AlQgAiAPNgJQIAIgEDYCTCACIBE2AkggAiAKNgJEIAJBCGogAkEYahCgASACKAIIIQkgAigCDAwBCyACQRhqIgwgAyAKIAkQ1gggAkEQaiAMEKABIAIoAhAhCSACKAIUCyEKIAcgCTYCACAHQQRqIAo2AgAgA0HEAGohAyAHQQhqIQcgCEEBaiEIIBJBAWsiEg0ACwsgFiAINgIAIAJBgAFqJAAMAQsACyAGQSBqJAAgDUEIaiAVKAIANgIAIA0gBSkCCDcCACAFQSBqJAAgASgCJCECIABBDGogAUEYahDWBiAAQRxqIAFBLGpBACABKAIsGxDuJSAAIAI2AhggACAEKQIUNwIAIABBCGogBEEcaigCADYCACABEIonIARBMGokAAvEAQEEfyAAIAAoAlggAWoiAjYCWCAAKAI4BEACQCACQQN2IAJBB3FBAEdqIgIgACgCRCIDTQ0AIAIgA2shBCAAKAI8IAJJBEAgAhDcKiEDIABBOGogACgCPEEBdCIFIAMgAyAFSRsQ6BkgACgCRCEDCyAERQ0AIAAoAkAgA2pBACAE/AsACyAAIAI2AkQgACAAKAJUIAFqNgJUIAAoAsQBIABBDGogASAAKALIASgCFBEBAA8LQcyPhwFBHUHsj4cBEMskAAu6AQEEfyMAQRBrIgIkACABKAJMIARqIgVBA3YgBUEHcUEAR2oiBSABKAIMIgZLBEAgBSAGayEIIAEoAgQiByAFSQRAIAEgB0EBdCIGIAUQ3ioiByAGIAdLGxDoGSABKAIMIQYLIAgEQCABKAIIIAZqQQAgCPwLAAsgASAFNgIMCyACQQhqIAEQhj0gAigCCCACKAIMIAAoAgAgACgCBCABKAJMIAAoAggoAiggA2ogBBCECRogAkEQaiQAC9MBAQF/IwBBEGsiDyQAIAAoAgAgASACIAAoAgQoAgwRBgAhASAPQQA6AA0gDyABOgAMIA8gADYCCCAPQQhqIAMgBCAFIAYQiBIgByAIIAkgChCIEiALIAwgDSAOEIgSIQEgDy0ADSICIA8tAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIA9BEGokACAAQQFxC5gEAQh/IwBBMGsiAiQAIAJBk4CAgHg2AgAgAkEoaiABQQhqKAIANgIAIAIgASkCADcDICACIAI2AiwgAkEUaiEFIwBBMGsiASQAIAFBCGogAkEgaiIDEL4gAkACQAJAIAEoAghBAXEEQCABKAIMIQYgAUEgaiIIQQRBAEEEQQQQoBggASgCJCEEIAEoAiBBAUYNAiABKAIoIgcgBjYCACABQRxqIglBATYCACABIAc2AhggASAENgIUIAFBKGogA0EIaikCADcDACABIAMpAgA3AyAjAEEQayIDJAAgA0EIaiAIEL4gIAMoAghBAXEEQCABQRRqIQQgAygCDCEHA0AgBCgCCCIGIAQoAgBGBEAgBCAGQQFBBEEEENAoCyAEKAIEIAZBAnRqIAc2AgAgBCAGQQFqNgIIIAMgCBC+ICADKAIEIQcgAygCAEEBcQ0ACwsgA0EQaiQAIAVBCGogCSgCADYCACAFIAEpAhQ3AgAMAQsgBUEANgIIIAVCgICAgMAANwIACyABQTBqJAAMAQsgBCABKAIoQbiBwwAQ/S8ACwJAIAIoAgBBk4CAgHhHBEAgACACKQIANwIAIABBEGogAkEQaigCADYCACAAQQhqIAJBCGopAgA3AgAgBRD4JSAFQQRBBBDgHgwBCyAAIAIpAhQ3AgQgAEGTgICAeDYCACAAQQxqIAJBHGooAgA2AgALIAJBMGokAAuYBAEIfyMAQTBrIgIkACACQZOAgIB4NgIAIAJBKGogAUEIaigCADYCACACIAEpAgA3AyAgAiACNgIsIAJBFGohBSMAQTBrIgEkACABQQhqIAJBIGoiAxC/IAJAAkACQCABKAIIQQFxBEAgASgCDCEGIAFBIGoiCEEEQQBBBEEEEKAYIAEoAiQhBCABKAIgQQFGDQIgASgCKCIHIAY2AgAgAUEcaiIJQQE2AgAgASAHNgIYIAEgBDYCFCABQShqIANBCGopAgA3AwAgASADKQIANwMgIwBBEGsiAyQAIANBCGogCBC/ICADKAIIQQFxBEAgAUEUaiEEIAMoAgwhBwNAIAQoAggiBiAEKAIARgRAIAQgBkEBQQRBBBDQKAsgBCgCBCAGQQJ0aiAHNgIAIAQgBkEBajYCCCADIAgQvyAgAygCBCEHIAMoAgBBAXENAAsLIANBEGokACAFQQhqIAkoAgA2AgAgBSABKQIUNwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAUEwaiQADAELIAQgASgCKEG4gcMAEP0vAAsCQCACKAIAQZOAgIB4RwRAIAAgAikCADcCACAAQRBqIAJBEGooAgA2AgAgAEEIaiACQQhqKQIANwIAIAUQ+CUgBUEEQQQQ4B4MAQsgACACKQIUNwIEIABBk4CAgHg2AgAgAEEMaiACQRxqKAIANgIACyACQTBqJAALvgICBn8BbyMAQSBrIgEkACABEKY7IgM2AgwgAUGg7MMAQRgQkz42AhggAUEQaiEEIwBBEGsiAiQAIAFBDGooAgAlASABQRhqKAIAJQEQYyEGIAJBCGoQzi1BASEFAkAgAigCCEEBcQRAIAQgAigCDDYCBAwBC0EAIQUgBCAGQQBHOgABCyAEIAU6AAAgAkEQaiQAAkACQCABLQAQIgJBAUYNACABLQARQQFHDQAgASADNgIcIAFBHGooAgAlASAAKAIAJQEQECEHEN8SIgAgByYBIANBhAFJDQEgAxDyHwwBCyAAKAIAJQEQBSEHEN8SIgAgByYBIAEoAgwiA0GEAUkNACADEPIfCwJAIAJFDQAgASgCFCICQYQBSQ0AIAIQ8h8LIAEoAhgiAkGEAU8EQCACEPIfCyABQSBqJAAgAAu4AQEEfyMAQRBrIgEkACABIAApAgA3AgggAUEIahDuEiECIAFBCGoQ7hIhACABQQhqEO4SIQQCQCACQYCAxABGIABBgIDEAEZyDQAgAkHf//8AcUHBAGshAiAEQYCAxABHBEAgAEH8AEcgAEE6R3EgAkEaT3INASAEQSNrIgBBOk8NAUKBoICAgYCAgAIgAK2IpyEDDAELIAJBGUsNACAAQTpGIABB/ABGciEDCyABQRBqJAAgA0EBcQusBAEMfyMAQTBrIgUkAAJAAkAgACgCAEGAgICAeEcEQCABKAIAQYCAgIB4Rw0BCyAAEIYwIABBgICAgHg2AgAMAQsgAEEIaiIKKAIAIQIgACgCBCEDIAEoAgghBCABKAIEIQEgBUEANgIoIAUgASAEajYCJCAFIAE2AiAgBSACIANqNgIcIAUgAzYCGCAFIAQgAiACIARLGzYCLCMAQSBrIgIkACACQRRqIAVBGGoiASgCFCABKAIQa0EAQQFBARCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHApc4AEP0vAAsgBUEMaiEJIAJBEGoiC0EANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgASgCFCABKAIQayIGIAJBCGoiAygCACADKAIIIgdrSwRAIAMgByAGQQFBARDQKCADKAIIIQcLIAQgAygCBDYCDCAEIAc2AgggBCADQQhqNgIEIARBBGoiBigCBCEDIAYoAgAgASgCFCIIIAEoAhAiB0cEQCAIIAdrIQggBigCCCENIAEoAgAgB2ohBiABKAIIIAdqIQEDQCADIA1qIAYtAAAgAS0AAHJBAXE6AAAgBkEBaiEGIAFBAWohASADQQFqIQMgCEEBayIIDQALCyADNgIAIARBEGokACAJQQhqIAsoAgA2AgAgCSACKQIINwIAIAJBIGokACAAEIYwIAogBUEUaigCADYCACAAIAUpAgw3AgALIAVBMGokAAvOAQEDfyMAQTBrIgMkACADIAI2AgwCQCACQQBOBEAgA0EQaiABIAJsQQBBAUEBEKAYIAMoAhQhBCADKAIQQQFGDQEgAygCGCEFIAAgAjYCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAU2AgQgACAENgIAIANBMGokAA8LIANBAjYCFCADQdTFhQE2AhAgA0IBNwIcIANBnAM2AiwgAyADQShqNgIYIAMgA0EMajYCKCADQRBqQeTFhQEQ7ywACyAEIAMoAhhB9MWFARD9LwAL7QEAIABBwOkBaiABIAIgACgC7OoBEOcJIgFBiH9NBH8gAQRAQbh/DwsCQCAAKAKs6wFBAUcNACAAKAKo6wFFDQAgABDFHAsCQCAAKALc6QEiAUUNACAAKAKc6wEgAUYNAEFgDwsCQCAAKALg6QEEQCAAIAAoAvDqASIBRTYC9OoBIAENASAAQZDqAWpBAEHYAPwLACAAQvnq0NDnyaHk4QA3A7DqASAAQs/W077Sx6vZQjcDoOoBIABC1uuC7ur9ifXgADcDmOoBDAELIABBADYC9OoBCyAAIAApA/DpASACrXw3A/DpAUEABSABCwvDAQEBfyMAQRBrIgUkACAFQgA3AwAgBUEANgIIIAVBADYCDEEBIACtIAIgAyAEEOUSAkAgAARAQQFCACACIAMgBBDlEiABIAUgBUEIaiAFQQxqEL0ZQQIgBTUCDCACIAMgBBDlEiAFKAIIIAUpAwAgAiADIAQQ5RIMAQsgASAFIAVBCGogBUEMahC9GUECIAU1AgwgAiADIAQQ5RIgBSgCCCAFKQMAIAIgAyAEEOUSQQFCACACIAMgBBDlEgsgBUEQaiQAC84BAQJ/IwBBQGoiAyQAQQEhBAJAIAEoAgBBAXEEQCAAIAEpAyg3AyggACABKQMgNwMgIAAgASkDGDcDGCAAIAEpAxA3AxBBACEEDAELIANBATYCJCADQdScgAE2AiAgA0IBNwIsIANBzAE2AjwgAyACNgI4IAMgA0E4ajYCKCADQRBqIANBIGoQmQ4gA0GNgICAeDYCDCAAIAMpAgw3AgQgAEEMaiADQRRqKQIANwIAIABBFGogA0EcaigCADYCAAsgACAENgIAIANBQGskAAvDAQEHfyMAQRBrIgIkACACQQRqIAEQ0wYgASgCDCIFIAUoAgAiA0EBajYCAAJAIANBAEgNACABKAIgIgMgAygCACIEQQFqNgIAIARBAEgNACABKAIcIQQgASgCGCEGIAEoAhQhByABKAIQIQggACACKQIENwIAIAAgAzYCICAAIAQ2AhwgACAGNgIYIAAgBzYCFCAAIAg2AhAgACAFNgIMIAAgASgCJDYCJCAAQQhqIAJBDGooAgA2AgAgAkEQaiQADwsAC+QBAgJ/An4jAEEQayICJAAgAiABQQBBBEEEEKAYIAIoAgQhASACKAIAQQFHBEAgAigCCCEDAn5B+POKASgCAEEBRgRAQYj0igEpAwAhBEGA9IoBKQMADAELIAIQ4yZB+POKAUIBNwMAQYj0igEgAikDCCIENwMAIAIpAwALIQUgAEEANgIoIAAgAzYCJCAAIAE2AiAgACAENwMYIAAgBTcDEEGA9IoBIAVCAXw3AwAgAEHo3IcBKQMANwMAIABBCGpB8NyHASkDADcDACACQRBqJAAPCyABIAIoAghBiN2HARD9LwALkAEBBH8gASgCSCIDIQQgA0ESTwRAIAEoAgQhBAsgAiAETQRAIAFBBGoiBSABQcgAaiIGIANBEk8bQQA2AgAgBigCAEERTQR/IAUFIAEoAggLIQMgACACNgIMIAAgATYCCCAAIAQgAms2AhAgACADIAJBAnRqNgIEIAAgAzYCAA8LQdCvzABBHEHsr8wAEJ8pAAu/AQECfyAAEOk7IABByABqEJ0MIAAoAjgEQCAAQThqEM8vCyAAQQxqEM8vIABBHGoQzy8gAEEsaiIBEIoUIAEQ9DwgACgCgAFBgICAgHhHBEAgAEGAAWoQ9yYLIABB3ABqIgEQxScgARDoOyAAQegAaiIBEIEjIAEQ6jsgAEH0AGoiARCBIyABEOo7IAAoAsQBIQEgACgCyAEiACgCACICBEAgASACEQMACyAAKAIEIgIEQCABIAIgACgCCBD4OgsLvwEBAn8gABDpOyAAQcgAahCfDCAAKAI4BEAgAEE4ahDPLwsgAEEMahDPLyAAQRxqEM8vIABBLGoiARCKFCABEPQ8IAAoAoABQYCAgIB4RwRAIABBgAFqEPomCyAAQdwAaiIBEMUnIAEQ6DsgAEHoAGoiARCBIyABEOo7IABB9ABqIgEQgSMgARDqOyAAKALEASEBIAAoAsgBIgAoAgAiAgRAIAEgAhEDAAsgACgCBCICBEAgASACIAAoAggQ+DoLC6kBAgF+An8gA0EEaiEFIAFBgYKECGwhAQNAIAAgBWpBCGsoAAAgAXMiBkGAgYKEeHJBgYKECGsgBnJBgIGChHhxQYGBgQFsQRx2rSAEQgSGhCEEIAVBBGsiBUEHSw0ACyAEQn+FIQQCQCADQSBHBEAgA0EQRw0BIASnIgBB//8DcSACQQ9xdiAAQQAgAmtBD3F0cq1C//8Dgw8LIASnIAJ4rQ8LIAQgAq2KC8kBAQJ/IAAoAoTqASIFQQdGIQYCQCAAAn8CQCAAKALk6wFFBEACfyAFQQdGBEAgACgC0OsBIQFBAAwBCyAAKALM6wEgACgC0OsBIgFrCyECIAAgACgCyOsBIAFqIAIgAyAEENsHIgRBiH9LDQMgBCAGckUNASAAIAAoAtDrASAEajYC1OsBQQQMAgsgACABKAIAIgVBACACIAVrIAYbIAMgBBDbByIEQYh/Sw0CIAEgASgCACAEajYCAAtBAgs2ArTrAUEAIQQLIAQLkAUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ9A0CQAJAAkAgAi0ACEEBcQRAIAItAAkhCiAFIAYQoSogBUEIIAIoAhhBAWoiAUF/IAEbIgEgAUEITRtBAEEBQQEQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjoAACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEPQNIAQtABBBAXEEQCACQQxqIQkgBC0AESEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQgS4LIAkoAgQgBmogCDoAACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBD0DSAELQAJIQggBC0ACEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAQNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ3jsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQviQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQviQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQviQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBCtDQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQrQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkEK0NIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQsyQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQsyQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQsyQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDnDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ5w0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOcNIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDtIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDtIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDtIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDqDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC9KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6g0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxCBLgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOoNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQtg0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkELYNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQhS4LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBC2DSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOoiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL4pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOoiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL4pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOoiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQvCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC/KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQvCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEL8pIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQvCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuQBQIIfwF9IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEKwNAkACQAJAIAIoAgBBAXEEQCACKgIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhByACKAIYQQFGDQIgAigCICIBIAo4AgAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBzYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBCsDSAEKAIIQQFxBEAgAkEMaiEHIAQqAgwhCgNAIAcoAggiBiAHKAIARgRAIARBFGogBRC9KSAHIAQoAhRBAWoiAUF/IAEbEO4tCyAHKAIEIAZBAnRqIAo4AgAgByAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQrA0gBCoCBCEKIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgByACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgCBDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC9JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFEL8pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC9JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC9JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEKgNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL4pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBCoDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQqA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQrw0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQoSogBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEK8NIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCvDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDiDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhC+KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ4g0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOINIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQqg0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvSkgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEKoNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL0pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCqDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELskAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELskIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELskIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQpw0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEKcNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBCnDSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEKkkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEKkkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEKkkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC3JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC3JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC3JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC8oFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQkjAEHgAGsiAiQAIAJBGGogBRDjGwJAAkACQCACKQMYQgJSBEAgAkE0aiIGIAUQwSkgBkEEIAIoAjRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRgQoBggAigCOCEBIAIoAjRBAUYNAiACKAI8IgggAikDGDcDACAIQRBqIAJBKGopAwA3AwAgCEEIaiACQSBqKQMANwMAIAJBFGoiCkEBNgIAIAIgCDYCECACIAE2AgwgBiAFQSz8CgAAIwBBMGsiBCQAIARBCGogBhDjGyAEKQMIQgJSBEAgAkEMaiEHA0ACQCAHKAIIIgggBygCAEcNACAEQSRqIAYQwSkgBCgCJEEBaiIBQX8gARsiBSAHKAIAIAcoAggiAWtNDQAgByABIAVBCEEYEN4oCyAHKAIEIAhBGGxqIgEgBCkDCDcDACABQRBqIARBGGopAwA3AwAgAUEIaiAEQRBqKQMANwMAIAcgCEEBajYCCCAEQQhqIAYQ4xsgBCkDCEICUg0ACwsCQCAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIARBMGokACAJQQhqIAooAgA2AgAgCSACKQIMNwIADAELIAlBADYCCCAJQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB4ABqJAAMAQsgASACKAI8Qbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCRD1OwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfCMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDoIgJAAkACQCACKAIYQQFGBEAgAisDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKOQMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDoIiAGKAIAQQFGBEAgAkEMaiEFA0AgBisDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo5AwAgBSAEQQFqNgIIIAYgBxDoIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBC1DQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhC9KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQtQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkELUNIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMQNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDEDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRCoJAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELwpIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxCoJCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvCkgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxCoJCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC5MFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAkEIaiAGIAJBGGoiBSAGKAIkEOENAkACQAJAIAIvAQhBAXEEQCACLwEKIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBAkECEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo7AQAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEQaiAFIARBFGogBSgCJBDhDSAELwEQQQFxBEAgAkEMaiEJIAQvARIhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEO0tCyAJKAIEIAZBAXRqIAg7AQAgCSAGQQFqNgIIIARBCGogBSAEQRRqIAUoAiQQ4Q0gBC8BCiEIIAQvAQhBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAIDcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEJ08DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOQiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOQiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOQiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELsNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC7DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQuw0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDhIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDhIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDhIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEO8iAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEO8iIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEO8iIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC8kFAQt/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBiABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEFAaiICJAAgAiAGIAJBFGoiBSAGKAIoELYSAkACQAJAIAIoAgAiCkF+cUECRwRAIAIoAgQhCyAFIAYQvykgBUEEIAIoAhRBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQgQoBggAigCGCEJIAIoAhRBAUYNAiACKAIcIgEgCzYCBCABIAo2AgAgAkEQaiILQQE2AgAgAiABNgIMIAIgCTYCCCAFIAZBLPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCKBC2EiAEKAIIIgxBfnFBAkcEQCACQQhqIQcgBCgCDCEJA0ACQCAHKAIIIgogBygCAEcNACAEQRRqIAUQvykgBCgCFEEBaiIBQX8gARsiBiAHKAIAIAcoAggiAWtNDQAgByABIAZBBEEIEN4oCyAHKAIEIApBA3RqIgEgCTYCBCABIAw2AgAgByAKQQFqNgIIIAQgBSAEQRRqIAUoAigQthIgBCgCBCEJIAQoAgAiDEF+cUECRw0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAIQQhqIAsoAgA2AgAgCCACKQIINwIADAELIAhBADYCCCAIQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAJIAIoAhxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEOo7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvJBQELfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgYgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBBQGoiAiQAIAIgBiACQRRqIgUgBigCKBC3EgJAAkACQCACKAIAIgpBfnFBAkcEQCACKAIEIQsgBSAGELspIAVBBCACKAIUQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEIEKAYIAIoAhghCSACKAIUQQFGDQIgAigCHCIBIAs2AgQgASAKNgIAIAJBEGoiC0EBNgIAIAIgATYCDCACIAk2AgggBSAGQSz8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAigQtxIgBCgCCCIMQX5xQQJHBEAgAkEIaiEHIAQoAgwhCQNAAkAgBygCCCIKIAcoAgBHDQAgBEEUaiAFELspIAQoAhRBAWoiAUF/IAEbIgYgBygCACAHKAIIIgFrTQ0AIAcgASAGQQRBCBDeKAsgBygCBCAKQQN0aiIBIAk2AgQgASAMNgIAIAcgCkEBajYCCCAEIAUgBEEUaiAFKAIoELcSIAQoAgQhCSAEKAIAIgxBfnFBAkcNAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiALKAIANgIAIAggAikCCDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCSACKAIcQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDqOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC5JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC5JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC5JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQryQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQryQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQryQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELgkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELgkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELgkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRC6JAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFELspIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxC6JCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQuykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxC6JCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQwCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQwCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQwCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEL8kAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEL8kIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEL8kIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALkwUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ6A0CQAJAAkAgAi8BCEEBcQRAIAIvAQohCiAFIAYQoSogBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEECQQIQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjsBACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEOgNIAQvARBBAXEEQCACQQxqIQkgBC8BEiEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEKEqIAkgBCgCFEEBaiIBQX8gARsQ7S0LIAkoAgQgBkEBdGogCDsBACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBDoDSAELwEKIQggBC8BCEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAgNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQnTwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC5AFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAkEIaiAGIAJBGGoiBSAGKAIkEOwNAkACQAJAIAItAAhBAXEEQCACLQAJIQogBSAGEL4pIAVBCCACKAIYQQFqIgFBfyABGyIBIAFBCE0bQQBBAUEBEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo6AAAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEQaiAFIARBFGogBSgCJBDsDSAELQAQQQFxBEAgAkEMaiEJIAQtABEhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEIEuCyAJKAIEIAZqIAg6AAAgCSAGQQFqNgIIIARBCGogBSAEQRRqIAUoAiQQ7A0gBC0ACSEIIAQtAAhBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAEDcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEN47DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOUiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOUiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOUiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQwSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC/KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQwSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEL8pIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQwSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELEkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELEkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELEkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDjIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDjIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDjIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDzDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhChKiAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ8w0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQoSogCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEPMNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDmIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDmIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDmIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEPEiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEPEiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEPEiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMUNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDFDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxQ0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALkwUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACQQhqIAYgAkEYaiIFIAYoAiQQ4w0CQAJAAkAgAi8BCEEBcQRAIAIvAQohCiAFIAYQvSkgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEECQQIQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjsBACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQRBqIAUgBEEUaiAFKAIkEOMNIAQvARBBAXEEQCACQQxqIQkgBC8BEiEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL0pIAkgBCgCFEEBaiIBQX8gARsQ7S0LIAkoAgQgBkEBdGogCDsBACAJIAZBAWo2AgggBEEIaiAFIARBFGogBSgCJBDjDSAELwEKIQggBC8BCEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIAgNwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQnTwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkEMYNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEKEqIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBDGDSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRChKiAJIAQoAhRBAWoiAUF/IAEbEIUuCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQxg0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDgIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDgIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDgIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFELQkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHELQkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHELQkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALjgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohByMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQuQ0CQAJAAkAgAigCAEEBcQRAIAIoAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEIIAIoAhhBAUYNAiACKAIgIgEgCjYCACACQRRqIgpBATYCACACIAE2AhAgAiAINgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkELkNIAQoAghBAXEEQCACQQxqIQkgBCgCDCEIA0AgCSgCCCIGIAkoAgBGBEAgBEEUaiAFEL4pIAkgBCgCFEEBaiIBQX8gARsQ7i0LIAkoAgQgBkECdGogCDYCACAJIAZBAWo2AgggBCAFIARBFGogBSgCJBC5DSAEKAIEIQggBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAHQQhqIAooAgA2AgAgByACKQIMNwIADAELIAdBADYCCCAHQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAIIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAHEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDrDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC9KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6w0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOsNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALpQUCCX8CfiMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIgcgBRCuJAJAAkACQCACKQMYIgtCAlIEQCACKQMgIQwgAkHEAGoiASAFEL8pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEQEKAYIAIoAkghCSACKAJEQQFGDQIgAigCTCIBIAw3AwggASALNwMAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgByAFQSz8CgAAIwBBIGsiBCQAIAQgBxCuJCAEKQMAIgtCAlIEQCACQQxqIQYDQCAEKQMIIQwCQCAGKAIIIgkgBigCAEcNACAEQRRqIAcQvykgBCgCFEEBaiIBQX8gARsiBSAGKAIAIAYoAggiAWtNDQAgBiABIAVBCEEQEN4oCyAGKAIEIAlBBHRqIgEgDDcDCCABIAs3AwAgBiAJQQFqNgIIIAQgBxCuJCAEKQMAIgtCAlINAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCTEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ7TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQtSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQtSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQtSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuTBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDgDQJAAkACQCACLwEIQQFxBEAgAi8BCiEKIAUgBhC+KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQJBAhCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOwEAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ4A0gBC8BEEEBcQRAIAJBDGohCSAELwESIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxDtLQsgCSgCBCAGQQF0aiAIOwEAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOANIAQvAQohCCAELwEIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgCA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxCdPAwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDpIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDpIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDpIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEMMkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQvykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEMMkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC/KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEMMkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALygUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCSMAQeAAayICJAAgAkEYaiAFEOUbAkACQAJAIAIpAxhCAlIEQCACQTRqIgYgBRCiKiAGQQQgAigCNEEBaiIBQX8gARsiASABQQRNG0EAQQhBGBCgGCACKAI4IQEgAigCNEEBRg0CIAIoAjwiCCACKQMYNwMAIAhBEGogAkEoaikDADcDACAIQQhqIAJBIGopAwA3AwAgAkEUaiIKQQE2AgAgAiAINgIQIAIgATYCDCAGIAVBLPwKAAAjAEEwayIEJAAgBEEIaiAGEOUbIAQpAwhCAlIEQCACQQxqIQcDQAJAIAcoAggiCCAHKAIARw0AIARBJGogBhCiKiAEKAIkQQFqIgFBfyABGyIFIAcoAgAgBygCCCIBa00NACAHIAEgBUEIQRgQ3igLIAcoAgQgCEEYbGoiASAEKQMINwMAIAFBEGogBEEYaikDADcDACABQQhqIARBEGopAwA3AwAgByAIQQFqNgIIIARBCGogBhDlGyAEKQMIQgJSDQALCwJAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgBEEwaiQAIAlBCGogCigCADYCACAJIAIpAgw3AgAMAQsgCUEANgIIIAlCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHgAGokAAwBCyABIAIoAjxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAJEPU7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvJBQELfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgYgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBBQGoiAiQAIAIgBiACQRRqIgUgBigCKBC+EgJAAkACQCACKAIAIgpBfnFBAkcEQCACKAIEIQsgBSAGEKIqIAVBBCACKAIUQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEIEKAYIAIoAhghCSACKAIUQQFGDQIgAigCHCIBIAs2AgQgASAKNgIAIAJBEGoiC0EBNgIAIAIgATYCDCACIAk2AgggBSAGQSz8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAigQvhIgBCgCCCIMQX5xQQJHBEAgAkEIaiEHIAQoAgwhCQNAAkAgBygCCCIKIAcoAgBHDQAgBEEUaiAFEKIqIAQoAhRBAWoiAUF/IAEbIgYgBygCACAHKAIIIgFrTQ0AIAcgASAGQQRBCBDeKAsgBygCBCAKQQN0aiIBIAk2AgQgASAMNgIAIAcgCkEBajYCCCAEIAUgBEEUaiAFKAIoEL4SIAQoAgQhCSAEKAIAIgxBfnFBAkcNAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgCEEIaiALKAIANgIAIAggAikCCDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCSACKAIcQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDqOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAALqgUBCX8jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiAFELElAkACQAJAIAIoAhhBAkcEQCACQSRqIgYgBRC/KSAGQQQgAigCJEEBaiIBQX8gARsiASABQQRNG0EAQQRBDBCgGCACKAIoIQkgAigCJEEBRg0CIAIoAiwiASACKQIYNwIAIAFBCGogAkEgaigCADYCACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAYgBUEs/AoAACMAQSBrIgQkACAEQQhqIAYQsSUgBCgCCEECRwRAIAJBDGohBwNAAkAgBygCCCIJIAcoAgBHDQAgBEEUaiAGEL8pIAQoAhRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQRBDBDeKAsgBygCBCAJQQxsaiIBIAQpAgg3AgAgAUEIaiAEQRBqKAIANgIAIAcgCUEBajYCCCAEQQhqIAYQsSUgBCgCCEECRw0ACwsCQCAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgIDAADcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAIsQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDoOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDrIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC9KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDrIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC9KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDrIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvwBAIIfwF8IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOwiAkACQAJAIAIoAhhBAUYEQCACKwMgIQogAkHEAGoiASAEEL0pIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo5AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOwiIAYoAgBBAUYEQCACQQxqIQUDQCAGKwMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEL0pIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjkDACAFIARBAWo2AgggBiAHEOwiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELoNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL0pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC6DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC9KSAJIAQoAhRBAWoiAUF/IAEbEIUuCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQug0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALkAUCCH8BfSMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBC3DQJAAkACQCACKAIAQQFxBEAgAioCBCEKIAUgBhChKiAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQcgAigCGEEBRg0CIAIoAiAiASAKOAIAIAJBFGoiCUEBNgIAIAIgATYCECACIAc2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQtw0gBCgCCEEBcQRAIAJBDGohByAEKgIMIQoDQCAHKAIIIgYgBygCAEYEQCAEQRRqIAUQoSogByAEKAIUQQFqIgFBfyABGxDuLQsgBygCBCAGQQJ0aiAKOAIAIAcgBkEBajYCCCAEIAUgBEEUaiAFKAIkELcNIAQqAgQhCiAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAcgAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC5AFAgh/AX0jAEHQAGsiAyQAIANBk4CAgHg2AgggA0EoaiIGIAFBJPwKAAAgAyADQQhqNgJMIANBHGohCCMAQUBqIgIkACACIAYgAkEYaiIFIAYoAiQQrg0CQAJAAkAgAigCAEEBcQRAIAIqAgQhCiAFIAYQvikgBUEEIAIoAhhBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQQQoBggAigCHCEHIAIoAhhBAUYNAiACKAIgIgEgCjgCACACQRRqIglBATYCACACIAE2AhAgAiAHNgIMIAUgBkEo/AoAACMAQSBrIgQkACAEQQhqIAUgBEEUaiAFKAIkEK4NIAQoAghBAXEEQCACQQxqIQcgBCoCDCEKA0AgBygCCCIGIAcoAgBGBEAgBEEUaiAFEL4pIAcgBCgCFEEBaiIBQX8gARsQ7i0LIAcoAgQgBkECdGogCjgCACAHIAZBAWo2AgggBCAFIARBFGogBSgCJBCuDSAEKgIEIQogBCgCAEEBcQ0ACwsCQCAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIARBIGokACAIQQhqIAkoAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgIDAADcCACAGKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAZBBGoQ+x4LIAJBQGskAAwBCyAHIAIoAiBBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOk7DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuqBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEIIwBB0ABrIgIkACACQRhqIAUQsCUCQAJAAkAgAigCGEECRwRAIAJBJGoiBiAFELspIAZBBCACKAIkQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEMEKAYIAIoAighCSACKAIkQQFGDQIgAigCLCIBIAIpAhg3AgAgAUEIaiACQSBqKAIANgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAk2AgwgBiAFQSz8CgAAIwBBIGsiBCQAIARBCGogBhCwJSAEKAIIQQJHBEAgAkEMaiEHA0ACQCAHKAIIIgkgBygCAEcNACAEQRRqIAYQuykgBCgCFEEBaiIBQX8gARsiBSAHKAIAIAcoAggiAWtNDQAgByABIAVBBEEMEN4oCyAHKAIEIAlBDGxqIgEgBCkCCDcCACABQQhqIARBEGooAgA2AgAgByAJQQFqNgIIIARBCGogBhCwJSAEKAIIQQJHDQALCwJAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgMAANwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAixBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEOg7DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvwBAIIfwF+IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBCABQST8CgAAIAMgA0EIajYCTCADQRxqIQgjAEHQAGsiAiQAIAJBGGoiByAEEOIiAkACQAJAIAIoAhhBAUYEQCACKQMgIQogAkHEAGoiASAEEKEqIAFBBCACKAJEQQFqIgFBfyABGyIBIAFBBE0bQQBBCEEIEKAYIAIoAkghBSACKAJEQQFGDQIgAigCTCIBIAo3AwAgAkEUaiIJQQE2AgAgAiABNgIQIAIgBTYCDCAHIARBKPwKAAAjAEEgayIGJAAgBiAHEOIiIAYoAgBBAUYEQCACQQxqIQUDQCAGKQMIIQogBSgCCCIEIAUoAgBGBEAgBkEUaiAHEKEqIAUgBigCFEEBaiIBQX8gARsQ7C0LIAUoAgQgBEEDdGogCjcDACAFIARBAWo2AgggBiAHEOIiIAYoAgANAAsLAkAgBygCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAHQQRqEPseCyAGQSBqJAAgCEEIaiAJKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAgAE3AgAgBCgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAEQQRqEPseCyACQdAAaiQADAELIAUgAigCTEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAgQ4zwMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6oFAQl/IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGogBRCvJQJAAkACQCACKAIYQQJHBEAgAkEkaiIGIAUQoiogBkEEIAIoAiRBAWoiAUF/IAEbIgEgAUEETRtBAEEEQQwQoBggAigCKCEJIAIoAiRBAUYNAiACKAIsIgEgAikCGDcCACABQQhqIAJBIGooAgA2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAGIAVBLPwKAAAjAEEgayIEJAAgBEEIaiAGEK8lIAQoAghBAkcEQCACQQxqIQcDQAJAIAcoAggiCSAHKAIARw0AIARBFGogBhCiKiAEKAIUQQFqIgFBfyABGyIFIAcoAgAgBygCCCIBa00NACAHIAEgBUEEQQwQ3igLIAcoAgQgCUEMbGoiASAEKQIINwIAIAFBCGogBEEQaigCADYCACAHIAlBAWo2AgggBEEIaiAGEK8lIAQoAghBAkcNAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQSBqJAAgCEEIaiAKKAIANgIAIAggAikCDDcCAAwBCyAIQQA2AgggCEKAgICAwAA3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQdAAaiQADAELIAkgAigCLEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAgQ6DsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQrSQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQrSQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQrSQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAvKBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEJIwBB4ABrIgIkACACQRhqIAUQ5hsCQAJAAkAgAikDGEICUgRAIAJBNGoiBiAFEL8pIAZBBCACKAI0QQFqIgFBfyABGyIBIAFBBE0bQQBBCEEYEKAYIAIoAjghASACKAI0QQFGDQIgAigCPCIIIAIpAxg3AwAgCEEQaiACQShqKQMANwMAIAhBCGogAkEgaikDADcDACACQRRqIgpBATYCACACIAg2AhAgAiABNgIMIAYgBUEs/AoAACMAQTBrIgQkACAEQQhqIAYQ5hsgBCkDCEICUgRAIAJBDGohBwNAAkAgBygCCCIIIAcoAgBHDQAgBEEkaiAGEL8pIAQoAiRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQhBGBDeKAsgBygCBCAIQRhsaiIBIAQpAwg3AwAgAUEQaiAEQRhqKQMANwMAIAFBCGogBEEQaikDADcDACAHIAhBAWo2AgggBEEIaiAGEOYbIAQpAwhCAlINAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQTBqJAAgCUEIaiAKKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQeAAaiQADAELIAEgAigCPEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAkQ9TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC44FAQl/IwBB0ABrIgMkACADQZOAgIB4NgIIIANBKGoiBiABQST8CgAAIAMgA0EIajYCTCADQRxqIQcjAEFAaiICJAAgAiAGIAJBGGoiBSAGKAIkELgNAkACQAJAIAIoAgBBAXEEQCACKAIEIQogBSAGEL4pIAVBBCACKAIYQQFqIgFBfyABGyIBIAFBBE0bQQBBBEEEEKAYIAIoAhwhCCACKAIYQQFGDQIgAigCICIBIAo2AgAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCDYCDCAFIAZBKPwKAAAjAEEgayIEJAAgBEEIaiAFIARBFGogBSgCJBC4DSAEKAIIQQFxBEAgAkEMaiEJIAQoAgwhCANAIAkoAggiBiAJKAIARgRAIARBFGogBRC+KSAJIAQoAhRBAWoiAUF/IAEbEO4tCyAJKAIEIAZBAnRqIAg2AgAgCSAGQQFqNgIIIAQgBSAEQRRqIAUoAiQQuA0gBCgCBCEIIAQoAgBBAXENAAsLAkAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyAEQSBqJAAgB0EIaiAKKAIANgIAIAcgAikCDDcCAAwBCyAHQQA2AgggB0KAgICAwAA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDpOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAAL8AQCCH8BfCMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDwIgJAAkACQCACKAIYQQFGBEAgAisDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKOQMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDwIiAGKAIAQQFGBEAgAkEMaiEFA0AgBisDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo5AwAgBSAEQQFqNgIIIAYgBxDwIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEKskAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQoiogAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEKskIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxCiKiAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEKskIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDuIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBC+KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDuIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxC+KSAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDuIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAvKBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCBCADQSRqIgUgAUEo/AoAACADIANBBGo2AkwgA0EYaiEJIwBB4ABrIgIkACACQRhqIAUQ5BsCQAJAAkAgAikDGEICUgRAIAJBNGoiBiAFELspIAZBBCACKAI0QQFqIgFBfyABGyIBIAFBBE0bQQBBCEEYEKAYIAIoAjghASACKAI0QQFGDQIgAigCPCIIIAIpAxg3AwAgCEEQaiACQShqKQMANwMAIAhBCGogAkEgaikDADcDACACQRRqIgpBATYCACACIAg2AhAgAiABNgIMIAYgBUEs/AoAACMAQTBrIgQkACAEQQhqIAYQ5BsgBCkDCEICUgRAIAJBDGohBwNAAkAgBygCCCIIIAcoAgBHDQAgBEEkaiAGELspIAQoAiRBAWoiAUF/IAEbIgUgBygCACAHKAIIIgFrTQ0AIAcgASAFQQhBGBDeKAsgBygCBCAIQRhsaiIBIAQpAwg3AwAgAUEQaiAEQRhqKQMANwMAIAFBCGogBEEQaikDADcDACAHIAhBAWo2AgggBEEIaiAGEOQbIAQpAwhCAlINAAsLAkAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyAEQTBqJAAgCUEIaiAKKAIANgIAIAkgAikCDDcCAAwBCyAJQQA2AgggCUKAgICAgAE3AgAgBSgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAFQQRqEPseCyACQeAAaiQADAELIAEgAigCPEG4tYABEP0vAAsCQCADKAIEQZOAgIB4RwRAIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIAIAkQ9TsMAQsgACADKQIYNwIEIABBk4CAgHg2AgAgAEEMaiADQSBqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQrCQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRCiKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQrCQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHEKIqIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQrCQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAulBQIJfwJ+IwBB0ABrIgMkACADQZOAgIB4NgIEIANBJGoiBSABQSj8CgAAIAMgA0EEajYCTCADQRhqIQgjAEHQAGsiAiQAIAJBGGoiByAFEMIkAkACQAJAIAIpAxgiC0ICUgRAIAIpAyAhDCACQcQAaiIBIAUQuykgAUEEIAIoAkRBAWoiAUF/IAEbIgEgAUEETRtBAEEIQRAQoBggAigCSCEJIAIoAkRBAUYNAiACKAJMIgEgDDcDCCABIAs3AwAgAkEUaiIKQQE2AgAgAiABNgIQIAIgCTYCDCAHIAVBLPwKAAAjAEEgayIEJAAgBCAHEMIkIAQpAwAiC0ICUgRAIAJBDGohBgNAIAQpAwghDAJAIAYoAggiCSAGKAIARw0AIARBFGogBxC7KSAEKAIUQQFqIgFBfyABGyIFIAYoAgAgBigCCCIBa00NACAGIAEgBUEIQRAQ3igLIAYoAgQgCUEEdGoiASAMNwMIIAEgCzcDACAGIAlBAWo2AgggBCAHEMIkIAQpAwAiC0ICUg0ACwsCQCAHKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAdBBGoQ+x4LIARBIGokACAIQQhqIAooAgA2AgAgCCACKQIMNwIADAELIAhBADYCCCAIQoCAgICAATcCACAFKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAVBBGoQ+x4LIAJB0ABqJAAMAQsgCSACKAJMQbi1gAEQ/S8ACwJAIAMoAgRBk4CAgHhHBEAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAgCBDtOwwBCyAAIAMpAhg3AgQgAEGTgICAeDYCACAAQQxqIANBIGooAgA2AgALIANB0ABqJAAL8AQCCH8BfiMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgQgAUEk/AoAACADIANBCGo2AkwgA0EcaiEIIwBB0ABrIgIkACACQRhqIgcgBBDnIgJAAkACQCACKAIYQQFGBEAgAikDICEKIAJBxABqIgEgBBChKiABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBCBCgGCACKAJIIQUgAigCREEBRg0CIAIoAkwiASAKNwMAIAJBFGoiCUEBNgIAIAIgATYCECACIAU2AgwgByAEQSj8CgAAIwBBIGsiBiQAIAYgBxDnIiAGKAIAQQFGBEAgAkEMaiEFA0AgBikDCCEKIAUoAggiBCAFKAIARgRAIAZBFGogBxChKiAFIAYoAhRBAWoiAUF/IAEbEOwtCyAFKAIEIARBA3RqIAo3AwAgBSAEQQFqNgIIIAYgBxDnIiAGKAIADQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBkEgaiQAIAhBCGogCSgCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAQoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBEEEahD7HgsgAkHQAGokAAwBCyAFIAIoAkxBuLWAARD9LwALAkAgAygCCEGTgICAeEcEQCAAIAMpAgg3AgAgAEEQaiADQRhqKAIANgIAIABBCGogA0EQaikCADcCACAIEOM8DAELIAAgAykCHDcCBCAAQZOAgIB4NgIAIABBDGogA0EkaigCADYCAAsgA0HQAGokAAuOBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAIgBiACQRhqIgUgBigCJBCpDQJAAkACQCACKAIAQQFxBEAgAigCBCEKIAUgBhC9KSAFQQQgAigCGEEBaiIBQX8gARsiASABQQRNG0EAQQRBBBCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKNgIAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBCGogBSAEQRRqIAUoAiQQqQ0gBCgCCEEBcQRAIAJBDGohCSAEKAIMIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvSkgCSAEKAIUQQFqIgFBfyABGxDuLQsgCSgCBCAGQQJ0aiAINgIAIAkgBkEBajYCCCAEIAUgBEEUaiAFKAIkEKkNIAQoAgQhCCAEKAIAQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgMAANwIAIAYoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBkEEahD7HgsgAkFAayQADAELIAggAigCIEG4tYABEP0vAAsCQCADKAIIQZOAgIB4RwRAIAAgAykCCDcCACAAQRBqIANBGGooAgA2AgAgAEEIaiADQRBqKQIANwIAIAcQ6TsMAQsgACADKQIcNwIEIABBk4CAgHg2AgAgAEEMaiADQSRqKAIANgIACyADQdAAaiQAC6UFAgl/An4jAEHQAGsiAyQAIANBk4CAgHg2AgQgA0EkaiIFIAFBKPwKAAAgAyADQQRqNgJMIANBGGohCCMAQdAAayICJAAgAkEYaiIHIAUQqiQCQAJAAkAgAikDGCILQgJSBEAgAikDICEMIAJBxABqIgEgBRC7KSABQQQgAigCREEBaiIBQX8gARsiASABQQRNG0EAQQhBEBCgGCACKAJIIQkgAigCREEBRg0CIAIoAkwiASAMNwMIIAEgCzcDACACQRRqIgpBATYCACACIAE2AhAgAiAJNgIMIAcgBUEs/AoAACMAQSBrIgQkACAEIAcQqiQgBCkDACILQgJSBEAgAkEMaiEGA0AgBCkDCCEMAkAgBigCCCIJIAYoAgBHDQAgBEEUaiAHELspIAQoAhRBAWoiAUF/IAEbIgUgBigCACAGKAIIIgFrTQ0AIAYgASAFQQhBEBDeKAsgBigCBCAJQQR0aiIBIAw3AwggASALNwMAIAYgCUEBajYCCCAEIAcQqiQgBCkDACILQgJSDQALCwJAIAcoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgB0EEahD7HgsgBEEgaiQAIAhBCGogCigCADYCACAIIAIpAgw3AgAMAQsgCEEANgIIIAhCgICAgIABNwIAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgAkHQAGokAAwBCyAJIAIoAkxBuLWAARD9LwALAkAgAygCBEGTgICAeEcEQCAAIAMpAgQ3AgAgAEEQaiADQRRqKAIANgIAIABBCGogA0EMaikCADcCACAIEO07DAELIAAgAykCGDcCBCAAQZOAgIB4NgIAIABBDGogA0EgaigCADYCAAsgA0HQAGokAAuQBQEJfyMAQdAAayIDJAAgA0GTgICAeDYCCCADQShqIgYgAUEk/AoAACADIANBCGo2AkwgA0EcaiEHIwBBQGoiAiQAIAJBCGogBiACQRhqIgUgBigCJBDpDQJAAkACQCACLQAIQQFxBEAgAi0ACSEKIAUgBhC+KSAFQQggAigCGEEBaiIBQX8gARsiASABQQhNG0EAQQFBARCgGCACKAIcIQggAigCGEEBRg0CIAIoAiAiASAKOgAAIAJBFGoiCkEBNgIAIAIgATYCECACIAg2AgwgBSAGQSj8CgAAIwBBIGsiBCQAIARBEGogBSAEQRRqIAUoAiQQ6Q0gBC0AEEEBcQRAIAJBDGohCSAELQARIQgDQCAJKAIIIgYgCSgCAEYEQCAEQRRqIAUQvikgCSAEKAIUQQFqIgFBfyABGxCELgsgCSgCBCAGaiAIOgAAIAkgBkEBajYCCCAEQQhqIAUgBEEUaiAFKAIkEOkNIAQtAAkhCCAELQAIQQFxDQALCwJAIAUoAgQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgBUEEahD7HgsgBEEgaiQAIAdBCGogCigCADYCACAHIAIpAgw3AgAMAQsgB0EANgIIIAdCgICAgBA3AgAgBigCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAGQQRqEPseCyACQUBrJAAMAQsgCCACKAIgQbi1gAEQ/S8ACwJAIAMoAghBk4CAgHhHBEAgACADKQIINwIAIABBEGogA0EYaigCADYCACAAQQhqIANBEGopAgA3AgAgBxDeOwwBCyAAIAMpAhw3AgQgAEGTgICAeDYCACAAQQxqIANBJGooAgA2AgALIANB0ABqJAALTgECfyMAQRBrIgIkACACIAFBABD4EQJAAkAgAigCACIBRQRADAELIAAgAikCBDcCCCAAIAE2AgQMAQtBAiEDCyAAIAM2AgAgAkEQaiQAC78BAQJ/IAAQ6TsgAEHIAGoQsgwgACgCOARAIABBOGoQzy8LIABBDGoQzy8gAEEcahDPLyAAQSxqIgEQihQgARD0PCAAKAKAAUGAgICAeEcEQCAAQYABahCBJwsgAEHcAGoiARDFJyABEOg7IABB6ABqIgEQgSMgARDqOyAAQfQAaiIBEIEjIAEQ6jsgACgCxAEhASAAKALIASIAKAIAIgIEQCABIAIRAwALIAAoAgQiAgRAIAEgAiAAKAIIEPg6CwuSBAEOfyMAQaACayICJAAgAkHsAWogAUEUaikCADcCACACQQA7AZwCIAJBADYCmAIgAkEANgKAAiACQQA2AvQBIAJCBDcC3AEgAkIANwLUASACQoCAgIDAADcCzAEgAkEANgLEASACIAEpAgw3AuQBIAJB6ABqIgwgAkHEAWoiCiABQRxqEMIZIAEoAgQiBCABKAIIQQN0aiEFIwBBIGsiAyQAIANBFGogBSAEa0EDdkEAQQRBxAAQoBggAygCGCEHIAMoAhRBAUYEQCAHIAMoAhxBjM+FARD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAc2AggjAEEQayIIJAAgA0EIaiIGIAUgBGtBA3YiBxD+LSAIIAYpAgRCIIk3AgggCCAGQQhqNgIEIwBB0ABrIgskACAIQQRqIgkoAgQhBiAJKAIAIAQgBUcEQCAJKAIIIAZBxABsaiEFIAYgB2ohBgNAIAtBDGoiCSAEKAIAIARBBGooAgAiDygCCEEBa0F4cWpBCGogDygCFBEAACAFIAlBxAD8CgAAIARBCGohBCAFQcQAaiEFIAdBAWsiBw0ACwsgBjYCACALQdAAaiQAIAhBEGokACAKQQhqIA0oAgA2AgAgCiADKQIINwIAIANBIGokACACQQxqIgQgDCAKEPwiIAAgBBDNHCABEMMnIAFBBEEIEOAeIAJBoAJqJAALxwECAn8BfiMAQSBrIgMkACAAKAIARQRAIABBfzYCACADQRhqIABBJGopAgA3AwAgA0EQaiAAQRxqKQIANwMAIAApAhQhBSAAQQA2AhQgAyAFNwMIIANBCGoQqSsCQCAAKAIEQQJGDQAgACgCCCIEQYQBSQ0AIAQQ8h8LIAAgAjYCCCAAIAE2AgQgACgCDCEBIABBADYCDCAAIAAoAgBBAWo2AgAgAQRAIAAoAhAgASgCBBEDAAsgA0EgaiQADwtBjKmIARCbPgALyAEBAX8jAEHQAGsiAiQAAn8CQAJAAkAgAC0AAEEDaw4FAQAAAAIACyACQUBrIABBCGopAwA3AwAgAiAAKQMANwM4IAJBOGogARDDCQwCCyACQQhqIAJBOGogACsDCBCuJSACQccCNgIsIAJBAjYCFCACQfiwiAE2AhAgAkIBNwIcIAIgAikDCDcCMCACIAJBMGo2AiggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEMsKDAELIAFBiLGIAUEEEPs1CyACQdAAaiQAC8IBAgN/AX4jAEEwayICJAAgASgCAEGAgICAeEYEQCABKAIMIQMgAkEUaiIEQQA2AgAgAkKAgICAEDcCDCACQSBqIAMoAgAiA0EIaikCADcDACACQShqIANBEGopAgA3AwAgAiADKQIANwMYIAJBDGpB4KiJASACQRhqEMsKGiACQQhqIAQoAgAiAzYCACACIAIpAgwiBTcDACABQQhqIAM2AgAgASAFNwIACyAAQdy1iQE2AgQgACABNgIAIAJBMGokAAuXAgECfyMAQSBrIgUkAEGQ8IoBQZDwigEoAgAiBkEBajYCAAJAAn9BACAGQQBIDQAaQQFB8POKAS0AAA0AGkHw84oBQQE6AABB7POKAUHs84oBKAIAQQFqNgIAQQILQf8BcSIGQQJHBEAgBkEBcUUNASAFQQhqIAAgASgCGBEAAAwBC0GE8IoBKAIAIgZBAEgNAEGE8IoBIAZBAWo2AgBBhPCKAUGI8IoBKAIABH8gBSAAIAEoAhQRAAAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQYjwigEoAgAgBUEQakGM8IoBKAIAKAIUEQAAQYTwigEoAgBBAWsFIAYLNgIAQfDzigFBADoAACADRQ0AAAsAC7cCAQJ/IwBBsAFrIgMkACABQQhqIQQCfyABKAIAQQFGBEAgA0GkAWogAkEIaigCADYCACADQQA6AKgBIAMgBDYCmAEgAyACKQIANwKcASADQQhqIQEgA0EYaiEEAkBBmAFBCBCtNiICBEAgAiAEQZgB/AoAACABQezdwgA2AgQgASACNgIADAELQQhBmAEQoz0ACyADKAIIIQIgAygCDAwBCyADQaQBaiACQQhqKAIANgIAIANBADoAqAEgAyAENgKYASADIAIpAgA3ApwBIANBEGohASADQRhqIQQCQEGYAUEIEK02IgIEQCACIARBmAH8CgAAIAFBvN3CADYCBCABIAI2AgAMAQtBCEGYARCjPQALIAMoAhAhAiADKAIUCyEBIAAgAjYCACAAIAE2AgQgA0GwAWokAAvVAQEBfwJAAkACQAJAAkAgAC0AnAIOBQAEBAECBAsgABDYFSAAQdgBahCOMCAAQeQBahCGMA8LIABBsAJqEL4oDAELIABBoAJqEL4oIABB7AJqEI4wIABBADoAnQILIAAtAJ4CBEAgAEHIAWoQjjALIABBADoAngIgAEGgAWoiARD3JSABQQRBBBDgHiAAKAKYAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGYAmoQiSkLIABBjAJqEIYwIABB/AFqEIYwIABB0ABqENgVIABBADoAnwILC9UBAQF/AkACQAJAAkACQCAALQDsAg4FAAQEAQIECyAAEI8TIABBqAJqEI4wIABBtAJqEIYwDwsgAEGAA2oQvigMAQsgAEHwAmoQviggAEG8A2oQjjAgAEEAOgDtAgsgAC0A7gIEQCAAQZgCahCOMAsgAEEAOgDuAiAAQfABaiIBEPclIAFBBEEEEOAeIAAoAugCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegCahCJKQsgAEHcAmoQhjAgAEHMAmoQhjAgAEH4AGoQjxMgAEEAOgDvAgsLtwECAn8BfiMAQSBrIgIkAAJAIAEEQCABQQhrIgMoAgBBAUcNASACQRxqIAFBEGooAgA2AgAgAkEUaiABQQhqKQIANwIAIAEpAgAhBCADQQA2AgAgAiAENwIMAkAgA0F/Rg0AIAFBBGsiASABKAIAQQFrIgE2AgAgAQ0AIANBHEEEEPg6CyAAIAIpAhA3AgAgAEEIaiACQRhqKQIANwIAIAJBIGokAA8LEJg9AAtBsMTMAEE/EJc9AAu3AQICfwF+IwBBIGsiAiQAAkAgAQRAIAFBCGsiAygCAEEBRw0BIAJBHGogAUEQaigCADYCACACQRRqIAFBCGopAgA3AgAgASkCACEEIANBADYCACACIAQ3AgwCQCADQX9GDQAgAUEEayIBIAEoAgBBAWsiATYCACABDQAgA0EcQQQQ+DoLIAAgAikCEDcCACAAQQhqIAJBGGopAgA3AgAgAkEgaiQADwsQmD0AC0HU0MwAQT8Qlz0AC78BAQF/IwBB0ABrIgMkACAAAn8gAkELTQRAIAMgAjYCPCADQQI2AiggA0HYjs4ANgIkIANCAjcCMCADQTs2AkwgA0E7NgJEIANBjIrOADYCQCADIANBQGs2AiwgAyADQTxqNgJIIANBCGpBBHIgA0EkahCZDiAAQQxqIANBFGooAgA2AgAgACADKQIMNwIEIAAgAykDGDcDEEEADAELIAAgASgACDYCDCAAIAEpAAA3AgRBCAs2AgAgA0HQAGokAAv7AgEGfyMAQSBrIgQkAAJAAkAgAyABLwEkayIFQQFrQf//A3FBDk8EQCAEIAI6AAwgASgCICAEQQxqIgYgBEENahC9JiMAQTBrIgIkACACQSBqIQggAUEgaiMAQRBrIgUkACAFQQhqQQA7AQAgBUIANwMAIAMgBRC7FCIHQQtPBEAgB0EKQayZzwAQsDsACygCACAFIAcQoTYgCEEEOgAAIAggBzYCBCAFQRBqJAACQAJAIAItACBBBEYNACACIAIpAyA3AyggAkEMaiACQShqENAJIAIoAgxBBEYNACAGIAIpAgw3AgAgBkEQaiACQRxqKAIANgIAIAZBCGogAkEUaikCADcCAAwBCyAGQQQ2AgALIAJBMGokACAEKAIMIgJBBEYNASAAIAQpAhA3AgQgAEEMaiAEQRhqKQIANwIADAILIAQgBUEEdCACcjoADCABKAIgIARBDGogBEENahC9JgsgASADOwEkQQQhAgsgACACNgIAIARBIGokAAu0AQEDfyMAQSBrIgIkACACIAAoAggiAzYCACACIAEoAggiBDYCBCADIARGBEAgACgCBCEAIAIgASgCBCIBIANBA3RqNgIMIAIgATYCCCACQQhqEJg2IgQgAyADIARLGyIDBEADQCAAIAApAwAgASkDAHw3AwAgAEEIaiEAIAFBCGohASADQQFrIgMNAAsLIAJBIGokAA8LIAJBADYCCEEAIAIgAkEEaiACQQhqQbD5zwAQrysAC7sBAQF/IwBBQGoiAiQAIAIgATYCCAJAIAEvAQxBAUYEQCABLwEOIQEgAEEENgIAIAAgATsBBAwBCyACQQE2AiQgAkGcpv4ANgIgIAJCATcCLCACQYMBNgI8IAIgAkE4ajYCKCACIAJBCGo2AjggAkEQaiACQSBqEJkOIAJBHGoiAUEAOgAAIAJBATYCDCAAIAIpAgw3AgAgAEEIaiACQRRqKQIANwIAIABBEGogASgCADYCAAsgAkFAayQAC84BAgJ/An4jAEEwayICJAAgAkEQakGwrYYBKAIANgIAIAJBqK2GASkCADcDCAJAAkACQCABIAFCgKMFfyIBQoCjBX59IgRCP4ciBSABfCIBQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAkEANgIsIAIgBUKAowWDIAR8PgIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAvEAwIHfwF+IwBBIGsiAiQAIAEoAgwhAyACIAFBCGo2AhggAiADNgIUIAIgAkEfajYCECACQQRqIQYgAkEQaiEEIwBBIGsiAyQAAkACfwJAIAEoAgAiBSABKAIERwRAIAQoAgghByAEKAIEIQQgASAFQQhqNgIAIAUxAAAhCSADQQxqIAVBBGogBygCABCTAyADKAIMIgFBk4CAgHhGDQEgA0EKaiIFIANBE2otAAA6AAAgAyADLwAROwEIIAMtABAhByADKAIUIQggAykCGCEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAHOgAEIAQgATYCACAEIAMvAQg7AAUgBCAJNwIMIAQgCDYCCCAEQQdqIAUtAAA6AABCACEJQQAMAgsgBkECNgIADAILIAM1AhBCIIYgCYQhCUEBCyEBIAYgCTcCBCAGIAE2AgALIANBIGokAAJAAkAgAigCBEECRgRAIAJBADYCEAwBCyACQRhqIAJBDGooAgA2AgAgAiACKQIEIgk3AxBBASEBIAmnQQFxRQ0AIAAgAigCGDYCCCAAIAItABQ6AAQMAQsgAkEQahC+KkEAIQELIAAgATYCACACQSBqJAALxAMCB38BfiMAQSBrIgIkACABKAIMIQMgAiABQQhqNgIYIAIgAzYCFCACIAJBH2o2AhAgAkEEaiEGIAJBEGohBCMAQSBrIgMkAAJAAn8CQCABKAIAIgUgASgCBEcEQCAEKAIIIQcgBCgCBCEEIAEgBUEIajYCACAFMQAAIQkgA0EMaiAFQQRqIAcoAgAQlAMgAygCDCIBQZOAgIB4Rg0BIANBCmoiBSADQRNqLQAAOgAAIAMgAy8AETsBCCADLQAQIQcgAygCFCEIIAMpAhghCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgBzoABCAEIAE2AgAgBCADLwEIOwAFIAQgCTcCDCAEIAg2AgggBEEHaiAFLQAAOgAAQgAhCUEADAILIAZBAjYCAAwCCyADNQIQQiCGIAmEIQlBAQshASAGIAk3AgQgBiABNgIACyADQSBqJAACQAJAIAIoAgRBAkYEQCACQQA2AhAMAQsgAkEYaiACQQxqKAIANgIAIAIgAikCBCIJNwMQQQEhASAJp0EBcUUNACAAIAIoAhg2AgggACACLQAUOgAEDAELIAJBEGoQvipBACEBCyAAIAE2AgAgAkEgaiQAC5YCAQN/IwBBMGsiASQAIAEgADYCBCABQQA2AhwgAUKAgICAEDcCFCABQajFzAA2AiQgAUKggICADjcCKCABIAFBFGo2AiAjAEEgayIAJAAgAEEUaiICIAFBBGooAgAlARALIABBCGogACgCFCAAKAIYELU2IAAgACgCCCAAKAIMEPooIAIgACgCACAAKAIEEI81IAAoAhggACgCHCABQSBqEKk9IAIQ3jsgAEEgaiQARQRAIAFBEGogAUEcaigCACIANgIAIAEgASkCFDcDCCABKAIMIAAQlD4gAUEIahDeOyABKAIEIgJBhAFPBEAgAhDyHwsgAUEwaiQADwtB0MXMAEE3IAFBCGpBwMXMAEGIxswAENUeAAu7AQEFfyMAQSBrIgIkAAJAIAEoAkwiAwRAIAFBxABqIQUDQCABKAIwIgRFDQIgBCABKAJIIgQgAyAEahC9JiACIAMgASgCTCIEEMotIAIoAgQhAyABIAIoAgAiBjYCTCACIAU2AhQgAiADNgIYIAIgBCADazYCHCACIAMgASgCSCIEajYCECACIAQgBmo2AgwgAkEMahCdGCABKAJMIgMNAAsLIABBBDoAACACQSBqJAAPC0GA9c0AELI7AAuUAgIHfwJ+IwBBIGsiAiQAIAFBHGohBgJAA0AgAkEQaiABEIMYAkAgAi0AEEEERg0AIAIpAxAiCUL/AYNCBFENACAAIAk3AgAMAgsgASkDCCACQRBqIAFBAUEAIAZBBBCQNgJAIAItABBFDQAgAigCFCEHIAIoAhghCCMAQRBrIgMkACADQQhqIQVBCEEEEK02IgRFBEBBBEEIEKM9AAsgBCAINgIEIAQgBzYCACAFQay8+wA2AgQgBSAENgIAIAJBCGpBKCADKAIIQay8+wAQySkgA0EQaiQAIAItAAhBBEYNACACKQMIIgpC/wGDQgRRDQAgACAKNwIADAILIAEpAwhSDQALIABBBDoAAAsgAkEgaiQAC7oBAQV/IwBBIGsiAiQAAkAgASgCJCIDBEAgAUEcaiEFA0AgASgCGCIERQ0CIAQgASgCICIEIAMgBGoQvSYgAiADIAEoAiQiBBDKLSACKAIEIQMgASACKAIAIgY2AiQgAiAFNgIUIAIgAzYCGCACIAQgA2s2AhwgAiADIAEoAiAiBGo2AhAgAiAEIAZqNgIMIAJBDGoQnRggASgCJCIDDQALCyAAQQQ6AAAgAkEgaiQADwtB8PTNABCyOwALswEBA38gACgCACAAKAIIIgNrIAFJBEAgACADIAFBBEEMENAoIAAoAgghAwsgACgCBCADQQxsaiEEAkACQCABQQJPBEAgAUEBayEFA0AgBCACKQIANwIAIARBCGogAkEIaigCADYCACAEQQxqIQQgBUEBayIFDQALIAEgA2pBAWshAwwBCyABRQ0BCyAEIAIpAgA3AgAgBEEIaiACQQhqKAIANgIAIANBAWohAwsgACADNgIIC581AiN/Bn4jAEFAaiIRJAAgEUEgaiEcIAEoAgwhFiMAQSBrIg8kAAJAAkAgASgCACIDIAEoAgQiIkYNACABKAIIISMCQANAIAEgA0EQaiIkNgIAIA9BCGohBCADKAIAIQcgA0EEaigCACEGQgAhJiMAQeAAayICJAAgAiAGNgIMIAIgBzYCCCACIAY2AjAgAkEANgIsIAIgBjYCKCACIAc2AiQgAkEBOgA4IAJBLjYCICACQS42AjQgAkFAayACQSBqEOoOAkACQAJAAkACQCACKAJARQ0AIAcgAigCSCIJaiELAkACQAJAAkAgBiAJayIMQRBPDQAgAigCRCEFIAsgDEEtEJwUIQogBiAJRgRAIApFDQUMAgsgCg0AIAcgBUEtEJwUIQoCQCAFRQ0AIAcgBUHkyYABQQEQwS4NACACQUBrIgkgByAFEJsKIAJBIGohBiACQQhqIRMjAEFAaiIHJABBASEFAkAgCS0AAEEBRgRAIAdBAjYCJCAHQdDKgAE2AiAgB0IBNwIsIAdBzAE2AjwgByATNgI4IAcgB0E4ajYCKCAHQRBqIAdBIGoQmQ4gB0GEgICAeDYCDCAGIAcpAgw3AgQgBkEMaiAHQRRqKQIANwIAIAZBFGogB0EcaigCADYCAAwBCyAGIAkpAwg3AwhBACEFCyAGIAU2AgAgB0FAayQAIAIoAiBBAXENAyACKQMoISYLIAJBEGogCyAMEJsKQQEhByACLQAQQQFGBEAgAkECNgIkIAJB0MqAATYCICACQgE3AiwgAkHMATYCXCACIAJB2ABqNgIoIAIgAkEIajYCWCACQcQAaiACQSBqEJkOIAIpAkQhJSAEIAIpAkw3AxAgBCAlNwMIIARBhICAgHg2AgQMCQsgAikDGCEqQgEhJwJAIAxBD0YNAEEPIAxrIQdCCiElA0AgB0EBcQRAICUgJ34hJyAHQQFGDQILIAdBAXYhByAlICV+ISUMAAsACyAEICY3AwggBEIAICcgKn4iJX0iJyAnICUgJkIAUxsgChs3AxAMBwsgCyAMQS0QnBRFDQILIAJBAjYCJCACQdDKgAE2AiAgAkIBNwIsIAJBzAE2AkQgAiACQUBrNgIoIAIgAkEIajYCQCAEQQhqIAJBIGoQmQ4gBEGEgICAeDYCBEEBIQcMBgsgAigCJCEHIAIpAyghJSAEIAIpAzA3AxAgBCAlNwMIIAQgBzYCBEEBIQcMBQsgDEEPSw0BCyACQRBqIAIoAgggAigCDBCbCiACLQAQRQ0BIAJBAjYCJCACQdDKgAE2AiAgAkIBNwIsIAJBzAE2AlwgAiACQdgAajYCKCACIAJBCGo2AlggAkHEAGogAkEgahCZDiACKQJEISUgBCACKQJMNwMQIAQgJTcDCCAEQYSAgIB4NgIEQQEhBwwDCyACQQI2AiQgAkGcyoABNgIgIAJCATcCLCACQcwBNgJEIAIgAkFAazYCKCACIAJBCGo2AkAgBEEIaiACQSBqEJkOIARBhICAgHg2AgRBASEHDAILIAIpAxghJSAEQgA3AxAgBCAlNwMIC0EAIQcLIAQgBzYCACACQeAAaiQAAkACfiAPKAIIQQFGBEAgDykDECImQhCIISUgDygCDCECICanIQMgDykDGAwBCyAPKQMYISUgDykDECEmIANBCGooAgAiDEUEQCAjLwEAIQMMAgsgD0EIaiEQIANBDGooAgAhC0EAIQRBACECIwBBQGoiDSQAIA0gCzYCECANIAw2AgwgDUEUaiEdQQAhAyMAQSBrIggkAAJAAkACQAJAIAtBAEgNAAJAAkACQCALRQRAQQEhCQwBC0EBIQQgC0EBEK02IglFDQMgDCEFIAkhBAJAIAsiCkEQSQ0AIAtB8P///wdxIQMDQCACIAlqIQQgAiAMaiIFQQFqLAAAIgdBf3NBgAFxQQd2IAUsAAAiBkF/c0GAAXFBB3ZqIAVBAmosAAAiE0F/c0GAAXFBB3ZqIAVBA2osAAAiEkF/c0GAAXFBB3ZqIAVBBGosAAAiDkF/c0GAAXFBB3ZqIAVBBWosAAAiFEF/c0GAAXFBB3ZqIAVBBmosAAAiF0F/c0GAAXFBB3ZqIAVBB2osAAAiGEF/c0GAAXFBB3ZqIAVBCGosAAAiGUF/c0GAAXFBB3ZqIAVBCWosAAAiGkF/c0GAAXFBB3ZqIAVBCmosAAAiG0F/c0GAAXFBB3ZqIAVBC2osAAAiFUF/c0GAAXFBB3ZqIAVBDGosAAAiHkF/c0GAAXFBB3ZqIAVBDWosAAAiH0F/c0GAAXFBB3ZqIAVBDmosAAAiIEF/c0GAAXFBB3ZqIAVBD2osAAAiIUF/c0GAAXFBB3ZqQf8BcUEQRwRAIAIhAwwCCyAEQQ9qICFBwQBrQf8BcUEaSUEFdCAhcjoAACAEQQ5qICBBwQBrQf8BcUEaSUEFdCAgcjoAACAEQQ1qIB9BwQBrQf8BcUEaSUEFdCAfcjoAACAEQQxqIB5BwQBrQf8BcUEaSUEFdCAecjoAACAEQQtqIBVBwQBrQf8BcUEaSUEFdCAVcjoAACAEQQpqIBtBwQBrQf8BcUEaSUEFdCAbcjoAACAEQQlqIBpBwQBrQf8BcUEaSUEFdCAacjoAACAEQQhqIBlBwQBrQf8BcUEaSUEFdCAZcjoAACAEQQdqIBhBwQBrQf8BcUEaSUEFdCAYcjoAACAEQQZqIBdBwQBrQf8BcUEaSUEFdCAXcjoAACAEQQVqIBRBwQBrQf8BcUEaSUEFdCAUcjoAACAEQQRqIA5BwQBrQf8BcUEaSUEFdCAOcjoAACAEQQNqIBJBwQBrQf8BcUEaSUEFdCAScjoAACAEQQJqIBNBwQBrQf8BcUEaSUEFdCATcjoAACAEQQFqIAdBwQBrQf8BcUEaSUEFdCAHcjoAACAEIAZBwQBrQf8BcUEaSUEFdCAGcjoAACACQRBqIQIgCkEQayIKQQ9LDQALIAIgC0YNASACIAlqIQQgAiAMaiEFCyADIApqQQAhDgNAIAUgDmoiAiwAACIGQQBIDQIgBCAOaiAGQcEAa0H/AXFBGklBBXQgBnI6AAAgCiAOQQFqIg5HDQALIQMLIAggAzYCECAIIAk2AgwgCCALNgIIDAELIAggCTYCDCAIIAMgDmoiEzYCECACIAogDmtqIRcgDCATaiEUIANBAmoiBCAOaiEYIAggCzYCCCALIAxqIRkgAyALayAOaiEaIAQgC2sgDmohG0EAIQcgEyEDA0ACQAJ/IAIsAAAiBEEASARAIAItAAFBP3EhBSAEQR9xIQYCfyAEQV9NBEAgBkEGdCAFciEEIAJBAmoMAQsgAi0AAkE/cSAFQQZ0ciEFIARBcEkEQCAFIAZBDHRyIQQgAkEDagwBCyAGQRJ0QYCA8ABxIAItAANBP3EgBUEGdHJyIQQgAkEEagsiEiAHIAJraiEGIARBowdHBEAgBiEHIBIMAgsCQCAHIBNqIglFDQAgCSALTwRAIAcgGmpFDQEMCQsgByAUaiwAAEFASA0ICyAHIBRqIQRBACEOAkADQEGDASEKIAQgDEYNASAEQQFrIgIsAAAiBUEASARAIAVBP3ECfyAEQQJrIgItAAAiBcAiFUFATgRAIAVBH3EMAQsgFUE/cQJ/IARBA2siAi0AACIFwCIVQb9/SgRAIAVBD3EMAQsgFUE/cSAEQQRrIgItAABBB3FBBnRyC0EGdHILQQZ0ciIFQYCAxABGDQILAn8CQCAOQQFxDQAgBRCqD0UNAEGAgMQAIQVBAAwBC0EBCyEOIAIhBCAFQYCAxABGDQALIAUQuhBFDQACQCAHIBhqRQ0AIAsgCUECak0EQCAHIBtqRQ0BDAkLIAcgFGpBAmosAABBQEgNCAsgByAUakECaiEEQQAhAgNAQYIBIQogBCAZRg0BAn8gBCwAACIHQQBOBEAgB0H/AXEhBSAEQQFqDAELIAQtAAFBP3EhCSAHQR9xIQUgB0FfTQRAIAVBBnQgCXIhBSAEQQJqDAELIAQtAAJBP3EgCUEGdHIhCSAHQXBJBEAgCSAFQQx0ciEFIARBA2oMAQsgBUESdEGAgPAAcSAELQADQT9xIAlBBnRyciIFQYCAxABGDQIgBEEEagshBAJ/AkAgAkEBcQ0AIAUQqg9FDQBBgIDEACEFQQAMAQtBAQshAiAFQYCAxABGDQALQYN/QYJ/IAUQuhAbIQoLIAgoAgggA2tBAU0EfyAIQQhqIANBAhDPFiAIKAIQBSADCyAIKAIMIglqIgIgCjoAASACQc8BOgAAIAggA0ECaiIDNgIQIAYhByASIQIMAgsgBEH/AXEhBCACQQFqIgYgByACa2ohByAGCyECIAhBFGogBBD9DAJAIAgoAhgiBEUEQAJ/QQEgCCgCFCIEQYABSSIKDQAaQQIgBEGAEEkNABpBA0EEIARBgIAESRsLIgUgCCgCCCADa0sEfyAIQQhqIAMgBRDPFiAIKAIMIQkgCCgCEAUgAwsgCWohBgJAAkAgCkUEQCAEQYAQSQ0BIARBgIAESQ0CIAYgBEE/cUGAAXI6AAMgBiAEQRJ2QfABcjoAACAGIARBBnZBP3FBgAFyOgACIAYgBEEMdkE/cUGAAXI6AAEMBAsgBiAEOgAADAMLIAYgBEE/cUGAAXI6AAEgBiAEQQZ2QcABcjoAAAwCCyAGIARBP3FBgAFyOgACIAYgBEEMdkHgAXI6AAAgBiAEQQZ2QT9xQYABcjoAAQwBCyAIKAIUIQYCQAJAAkACQAJAAkAgCCgCHCIFRQRAAn9BASAGQYABSSISDQAaQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIgogCCgCCCADa0sEfyAIQQhqIAMgChDPFiAIKAIMIQkgCCgCEAUgAwsgCWohBSASDQEgBkGAEEkNAiAGQYCABE8EQCAFIAZBP3FBgAFyOgADIAUgBkESdkHwAXI6AAAgBSAGQQZ2QT9xQYABcjoAAiAFIAZBDHZBP3FBgAFyOgABDAcLIAUgBkE/cUGAAXI6AAIgBSAGQQx2QeABcjoAACAFIAZBBnZBP3FBgAFyOgABDAYLAn9BASAGQYABSSISDQAaQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIgogCCgCCCADa0sEfyAIQQhqIAMgChDPFiAIKAIMIQkgCCgCEAUgAwsgCWohCSASDQIgBkGAEEkNAyAGQYCABE8EQCAJIAZBP3FBgAFyOgADIAkgBkESdkHwAXI6AAAgCSAGQQZ2QT9xQYABcjoAAiAJIAZBDHZBP3FBgAFyOgABDAULIAkgBkE/cUGAAXI6AAIgCSAGQQx2QeABcjoAACAJIAZBBnZBP3FBgAFyOgABDAQLIAUgBjoAAAwECyAFIAZBP3FBgAFyOgABIAUgBkEGdkHAAXI6AAAMAwsgCSAGOgAADAELIAkgBkE/cUGAAXI6AAEgCSAGQQZ2QcABcjoAAAsgCCADIApqIgY2AhACf0EBIARBgAFJIhINABpBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiCiAIKAIIIAZrSwR/IAhBCGogBiAKEM8WIAgoAhAFIAYLIAgoAgwiCWohAwJAAkAgEkUEQCAEQYAQSQ0BIARBgIAETwRAIAMgBEE/cUGAAXI6AAMgAyAEQRJ2QfABcjoAACADIARBBnZBP3FBgAFyOgACIAMgBEEMdkE/cUGAAXI6AAEMAwsgAyAEQT9xQYABcjoAAiADIARBDHZB4AFyOgAAIAMgBEEGdkE/cUGAAXI6AAEMAgsgAyAEOgAADAELIAMgBEE/cUGAAXI6AAEgAyAEQQZ2QcABcjoAAAsgCCAGIApqIgQ2AhACf0EBIAVBgAFJIgoNABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiBiAIKAIIIARrSwR/IAhBCGogBCAGEM8WIAgoAgwhCSAIKAIQBSAECyAJaiEDAkACQCAKRQRAIAVBgBBJDQEgBUGAgARPBEAgAyAFQT9xQYABcjoAAyADIAVBEnZB8AFyOgAAIAMgBUEGdkE/cUGAAXI6AAIgAyAFQQx2QT9xQYABcjoAAQwDCyADIAVBP3FBgAFyOgACIAMgBUEMdkHgAXI6AAAgAyAFQQZ2QT9xQYABcjoAAQwCCyADIAU6AAAMAQsgAyAFQT9xQYABcjoAASADIAVBBnZBwAFyOgAACyAIIAQgBmoiAzYCEAwCCyAIIAMgCmoiBjYCEAJ/QQEgBEGAAUkiCg0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyIFIAgoAgggBmtLBH8gCEEIaiAGIAUQzxYgCCgCEAUgBgsgCCgCDCIJaiEDAkACQCAKRQRAIARBgBBJDQEgBEGAgARPBEAgAyAEQT9xQYABcjoAAyADIARBEnZB8AFyOgAAIAMgBEEGdkE/cUGAAXI6AAIgAyAEQQx2QT9xQYABcjoAAQwDCyADIARBP3FBgAFyOgACIAMgBEEMdkHgAXI6AAAgAyAEQQZ2QT9xQYABcjoAAQwCCyADIAQ6AAAMAQsgAyAEQT9xQYABcjoAASADIARBBnZBwAFyOgAACyAIIAUgBmoiAzYCEAwBCyAIIAMgBWoiAzYCEAsgAiAXRw0ACwsgHSAIKQIINwIAIB1BCGogCEEQaigCADYCACAIQSBqJAAMAwsgBCALQezDiQEQ/S8ACyAMIAsgCUECaiALQdzDiQEQozYACyAMIAtBACAJQczDiQEQozYACyAQAn8CQCANKAIYIgMgDSgCHCICQbTHgAFBARDBLg0AIAMgAkG1x4ABQQQQwS4NACADIAJBuceAAUEFEMEuDQAgAyACQb7HgAFBBxDBLg0AIAMgAkHFx4ABQQkQwS4NAAJAIAMgAkHOx4ABQQMQwS4NACADIAJB0ceAAUEEEMEuDQAgAyACQdXHgAFBBhDBLg0AIAMgAkHbx4ABQQcQwS4NAAJAIAMgAkHix4ABQQEQwS4NACADIAJB48eAAUECEMEuDQAgAyACQeXHgAFBAxDBLg0AIAMgAkHox4ABQQQQwS4NACADIAJB7MeAAUEFEMEuDQACQCADIAJB8ceAAUEDEMEuDQAgAyACQfTHgAFBBBDBLg0AIAMgAkH4x4ABQQUQwS4NACADIAJB/ceAAUEGEMEuDQACQCADIAJBg8iAAUEBEMEuDQAgAyACQYTIgAFBBBDBLg0AIAMgAkGIyIABQQUQwS4NAAJAIAMgAkGNyIABQQEQwS4NACADIAJBjsiAAUEDEMEuDQAgAyACQZHIgAFBBBDBLg0AAkAgAyACQZXIgAFBARDBLg0AIAMgAkGWyIABQQIQwS4NACADIAJBmMiAAUEDEMEuDQAgAyACQZvIgAFBBBDBLg0AIAMgAkGfyIABQQUQwS4NAAJAIAMgAkGkyIABQQEQwS4NACADIAJBpciAAUEDEMEuDQAgAyACQajIgAFBBBDBLg0AIAMgAkGsyIABQQYQwS4NACADIAJBssiAAUEHEMEuDQACQCADIAJBuciAAUEBEMEuDQAgAyACQbrIgAFBAxDBLg0AIAMgAkG9yIABQQQQwS4NACADIAJBwciAAUEGEMEuDQAgAyACQcfIgAFBBxDBLg0AAkAgAyACQc7IgAFBAhDBLg0AIAMgAkHQyIABQQQQwS4NACADIAJB1MiAAUEFEMEuDQAgAyACQdnIgAFBBxDBLg0AIAMgAkHgyIABQQgQwS4NACADIAJB6MiAAUELEMEuDQAgAyACQfPIgAFBDBDBLg0AAkAgAyACQf/IgAFBAhDBLg0AIAMgAkGByYABQQQQwS4NACADIAJBhcmAAUEFEMEuDQAgAyACQYrJgAFBBxDBLg0AIAMgAkGRyYABQQgQwS4NACADIAJBmcmAAUELEMEuDQAgAyACQaTJgAFBDBDBLg0AAkAgAyACQbDJgAFBChDBLkUEQCADIAJBusmAAUELEMEuRQ0BCyAQQYAQOwEEQZOAgIB4DAwLIA1BATYCJCANQdzJgAE2AiAgDUIBNwIsIA1BzAE2AjwgDSANQThqNgIoIA0gDUEMajYCOCAQQQRqIQcjAEEQayIEJAAgDUEgaiIDKAIMIQICQAJAAkACQAJAAkACQCADKAIEDgIAAQILIAINAUEBIQJBACEDDAILIAINACADKAIAIgIoAgQhAyACKAIAIQIMAQsgByADEJkODAELIARBBGogA0EAQQFBARCgGCAEKAIIIQwgBCgCBEEBRg0BIAQoAgwhBiADBEAgBiACIAP8CgAACyAHIAM2AgggByAGNgIEIAcgDDYCAAsgBEEQaiQADAELIAwgBCgCDEGww4ABEP0vAAtBjYCAgHgMCwsgEEGACDsBBEGTgICAeAwKCyAQQYAEOwEEQZOAgIB4DAkLIBBBgAI7AQRBk4CAgHgMCAsgEEGAATsBBEGTgICAeAwHCyAQQcAAOwEEQZOAgIB4DAYLIBBBIDsBBEGTgICAeAwFCyAQQRA7AQRBk4CAgHgMBAsgEEEIOwEEQZOAgIB4DAMLIBBBBDsBBEGTgICAeAwCCyAQQQI7AQRBk4CAgHgMAQsgEEEBOwEEQZOAgIB4CzYCACANQRRqEN47IA1BQGskACAPLwEMIQMgDygCCCICQZOAgIB4Rg0BIA81AQ4gD0ESajMBAEIghoQhJSAPKQIUCyEmIBYoAgBBk4CAgHhHBEAgFhCIEQsgFiAmNwIMIBYgA61C//8DgyAlQhCGhDcCBCAWIAI2AgBBACEDDAILAkAgA0H//wNxIgIEQCACQYEQRw0BICYhKSAlISgLICQiAyAiRg0DDAELCyAlISggJiEpCyAcICg3AwggHCApNwMADAELQYEQIQMLIBwgAzsBECAPQSBqJAACQAJAIBEvATAiAUGBEEYNACARQRhqIgMgEUEoaikDADcDACARQQxqIgIgEUE2ai8BADsBACARIBEpAyA3AxAgESARKAEyNgIIIAFFDQAgACARKQMQNwMAIAAgESgCCDYBEiAAQQhqIAMpAwA3AwAgAEEWaiACLwEAOwEADAELQQAhAQsgACABOwEQIBFBQGskAAuvAQEBfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC3JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgACAEKQIANwIAIAAgBCkCDDcCDCAAIAQpAhg3AhggAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaigCADYCACAAQSBqIARBIGopAgA3AgAgAEEoaiAEQShqKQIANwIAIARBMGokAAuvAQEBfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC4JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgACAEKQIANwIAIAAgBCkCDDcCDCAAIAQpAhg3AhggAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaigCADYCACAAQSBqIARBIGopAgA3AgAgAEEoaiAEQShqKQIANwIAIARBMGokAAvyAQEGfyMAQTBrIgQkACAEIAEQ0AYgBEEMaiMAQRBrIgUkACABQQxqIggoAgAiBiAGKAIAIglBAWo2AgAgCUEASARAAAsgBSAGNgIEIAUgCCkCBDcCCCAFQQRqIAIgAxD8HCAFQRBqJAACQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAAgBCkCADcCACAAIAQpAgw3AgwgACAEKQIYNwIYIABBCGogBEEIaigCADYCACAAQRRqIARBFGooAgA2AgAgAEEgaiAEQSBqKQIANwIAIABBKGogBEEoaikCADcCACAEQTBqJAALrwEBAX8jAEEwayIEJAAgBCABENAGIARBDGogAUEMaiACIAMQtSYCQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAAgBCkCADcCACAAIAQpAgw3AgwgACAEKQIYNwIYIABBCGogBEEIaigCADYCACAAQRRqIARBFGooAgA2AgAgAEEgaiAEQSBqKQIANwIAIABBKGogBEEoaikCADcCACAEQTBqJAALhwQBCX8jAEHQAGsiAyQAIAMgAjYCGCADIAE2AhQgA0EIaiEHIwBBEGsiBSQAQQMhCEEwIQlBBCEKQTAhCwJAAkACQAJAIAJBA2sOBAIDAQADCyABLQADQTpHDQJBBSEKQQQhCAsgASAKai0AACELIAEgCGotAAAhCQsgBSALOgAPIAUgCToADiAFIAEvAAE7AAwDQCAFQQxqIARqIgYgBi0AAEEwazoAACAEQQFqIgRBBEcNAAtBACEEAkADQCAEQQRGDQEgBUEMaiAEaiAEQQFqIQQtAABBCU0NAAtBACEGDAELAkACQCACBEAgBS0ADyAFLQAOQQpsakH/AXFBPGwgBS0ADSAFLQAMQQpsakH/AXFBkBxsaiEEQQAhBiABLQAAQStrDgMBAwIDC0EAQQBBtOmFARDDIQALIARBgKMFSSEGDAELIARBgKMFSSEGQQAgBGshBAsgByAENgIEIAcgBjYCACAFQRBqJAAgAAJ/IAMoAghBAXFFBEAgA0ECNgI0IANBhIKFATYCMCADQgE3AjwgA0HHAjYCTCADIANByABqNgI4IAMgA0EUajYCSCADQSBqIANBMGoQmQ4gACADKQIkNwIIIABBEGogA0EsaigCADYCACADKAIgIQJBhICAgHgMAQsgAygCDCECQZOAgIB4CzYCACAAIAI2AgQgA0HQAGokAAuoAQEHfyABQf8BcSICQeMASyIGRQRAIAJBCm4iB0EwciEIIAAoAggiAiEDIAIgACgCACIERgRAIAAgAkEBENsoIAAoAgghAyAAKAIAIQQLIAAgAkEBaiIFNgIIIAMgACgCBCIDaiAIOgAAIAQgBUYEQCAAIARBARDbKCAAKAIEIQMgACgCCCEFCyAAIAJBAmo2AgggAyAFaiABIAdBCmxrQTByOgAACyAGC8gBACAAIAIpAgA3AiAgACABKAIsNgIsIAAgASkCADcCACAAIAEpAjA3AjAgACABKQI8NwI8IABBKGogAkEIaigCADYCACAAQThqIAFBOGooAgA2AgAgAEHEAGogAUHEAGopAgA3AgAgAEHMAGogAUHMAGopAgA3AgAgACABKAJUNgJUIAAgASkCCDcCCCAAQRBqIAFBEGooAgA2AgAgACABKQIUNwIUIABBHGogAUEcaigCADYCACAAIAEvAVg7AVggAUEgahDKDAvAAQEDfyMAQRBrIgUkACABQQAgASgCCCIEIARBAUYiBBs2AggCQAJAIARFBEAgBUEEaiADQQBBAUEBEKAYIAUoAgghBiAFKAIEQQFGDQIgBSgCDCEEIAMEQCAEIAIgA/wKAAALIAEQlC0MAQsgASgCBCEGIAEoAgAhBCABQQxBBBD4OiADRQ0AIAQgAiAD/AoAAAsgACADNgIIIAAgBDYCBCAAIAY2AgAgBUEQaiQADwsgBiAFKAIMQcCFiAEQ/S8AC8gBAQF/IwBBEGsiCyQAIAAoAgAgASACIAAoAgQoAgwRBgAhASALQQA6AA0gCyABOgAMIAsgADYCCCALQQhqIAMgBCAFIAYQiBIgByAIIAkgChCIEiEBIAstAA0iAiALLQAMIgNyIQACQCADQQFxIAJBAUdyDQAgASgCACIALQAKQYABcUUEQCAAKAIAQdfxiQFBAiAAKAIEKAIMEQYAIQAMAQsgACgCAEHW8YkBQQEgACgCBCgCDBEGACEACyALQRBqJAAgAEEBcQu3AQEDfyAAKAJAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQUBrEOgnCwJAIAAoAjgiAUUNACAAKAI8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CwJAIAApAwBCAlEEQCAAKAIYIgBFDQEgACkDAEIDUgRAIAAQ8SsLIAApA2hCA1IEQCAAQegAahDxKwsgAEGIAkEIEPg6DwsgAEEgaiIAENAuIAAQ9TsLC5YEAQZ/IwBBkAFrIgQkACABKAIMIgIoAggiBSAFKAIAIgNBAWo2AgACQCADQQBIDQAgBCACKAIMNgJQIAQgBTYCTCAEQSA6AEggBEEBQQAgBEHIAGoiBUEAEJsUIAIgAigCACIDQQFqNgIAIANBAEgNACAEQfwAaiIDIAEQvBUgBCACNgKIASAEIAEoAhA2AowBIAUgAxCfDiMAQfABayIBJAAgAUGoAWogBBDoDCAEQTRqQQFBARDgHiAEQShqENAMIAQQkycCQAJAAkACQCABKAKoAUEBRgRAIAFBEGogAUG8AWooAgA2AgAgAUEIaiABQbQBaikCADcDACABIAEpAqwBNwMAIAAgARDKJgwBCyABQQRqIgIgAUGwAWpBMPwKAAAgAUE4aiIGIAJBMPwKAAAgAUGoAWoiAiAFQYjIzAAoAgARAAAgAUHoAGoiByACEI0EIAJBGGoQkwwgAhDFJyACEOg7IAJBDGoiAxCkLCADEPU8AkAgAigCLCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACACQSxqEPseC0HAAEEIEK02IgJFDQEgAiAHQcAA/AoAAEEwQQgQrTYiA0UNAiADIAZBMPwKAAAgACADNgIIIAAgAjYCBCAAQYGAgIB4NgIACyABQfABaiQADAILQQhBwAAQoz0AC0EIQTAQoz0ACyAFEIIpIARBkAFqJAAPCwALqwEBBH8jAEEQayIEJAAgACgCCCIBQQRqIQICQAJAIAFBe00EQCACIAAoAgQiA0sNASAEQQRqIgIgACgCACIAIAMgASAAIAFqKAAAaxD2NCACQQgQzCBB//8DcSICBH8gASACaiIBIANLDQMgACABai0AAEEARwVBAAsgBEEQaiQADwsgASACQdDMzAAQsTsACyACIANB0MzMABCwOwALIAEgA0GMycwAEK87AAu5AQEDfyMAQSBrIgIkAAJAAkAgASgCECIERQRAIAJBDGoQtB4gAigCDCIDQQRGDQIgACACKQIUNwIIIABBEGogAkEcaigCADYCACAAQQdqIAIoAhAiAUEYdjoAACAAIAFBCHY7AAUgACABOgAEIAAgAzYCAAwBCyABKAIMIQMgASAEQQFrNgIQIAEgA0EBajYCDCAAQQQ2AgAgACADLQAAOgAECyACQSBqJAAPC0EBQQBB1LPOABCvOwALtgEBB38jAEEQayICJAAgASgCBCEEIAJBBGogASgCCCIGQQBBBEEIEKAYIAIoAgghAyACKAIEQQFHBEAgAigCDCEHAkAgA0UNACAGQQN0IQEgByEFIAMhCANAIAFFDQEgBSAEKQIANwIAIAVBCGohBSABQQhrIQEgBEEIaiEEIAhBAWsiCA0ACwsgACAGNgIIIAAgBzYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQeiZzwAQ/S8AC6gCAQN/IwBBIGsiBCQAAkACfwJAIAJFDQAgBEEIaiABIAIgAxCeASAEKAIMIQIgBCgCCCIDQQhGBEAgAkUNASAEKAIQDAILIAAgBCkCFDcCDCAAQRRqIARBHGooAgA2AgAgACAEKAIQNgIIIAAgAjYCBCAAIAM2AgAMAgsgASgCACABKAIEKAIMEQQAIQMjAEEQayICJAAgAkEIahDBLCACKAIMIQUgAigCCCEGQRRBBBCtNiIBRQRAQQRBFBCjPQALIAFBADYCECABIAM2AgwgASAGNgIEIAFBIDoAACABIAU2AgggBEG4180ANgIEIAQgATYCACACQRBqJAAgBCgCACECIAQoAgQLIQEgACACNgIEIABBCDYCACAAIAE2AggLIARBIGokAAvMAQECfyMAQRBrIgUkAAJAIAAoAowBDQAgASgCBCABKAIARw0AIAAoAgwiBiAAKAIQRyAEQQlJcg0AIAMgACgCBGsgBkcNACAFQQhqIAJBCGooAgA2AgAgBSACKQIANwMAIAAgASAFIAMgBEEAEN81GiABQQA2AiQgASABKAIINgIMIAEgASgCADYCBCAAIAAoAgQgBGs2AgQgACAAKAIMIARqIgY2AgwgACAGNgIcIAAgBjYCEAsgACABIAIgAyAEQQAQ3zUgBUEQaiQAC5oBAQR+AkAgAUEQaiAATQRAIACtIAGtIgd9QgEgAkICfIZ8QhB9IgUgBSAFeUI/hUL/////D3wiBohCAYMiCEIChCAGhn0gAoinIQEgByAFQX8gAqd0QX9zrYN8IAZC/////w+DIAJ9IgVCAYYgCIRC/v8DfCAChnxCEHwgBUIKhoSnIQAMAQtBACEBCyAEIAE2AgAgAyAAOwEAC7kBACACQQA2AgAgASgCACECAkACQAJAIAAEQCAAQSBPDQEgCCAAQQJ0aiIIKAIAIAZqIgZB0AVPDQIgCCACNgIAIAQgADYCACAFIAZBAXRqIAI7AQAgAyADKAIAQYCAAiAAdms2AgAgAEEQTw0DIAcgAEEBdGoiACAALwEAQQFqOwEACyABIAJBAWo2AgAPCyAAQSBBzJ/zABDDIQALIAZB0AVB3J/zABDDIQALIABBEEHsn/MAEMMhAAveAQEBfyMAQRBrIgIkAAJ/AkACQAJAIAAoAgAiACgCAEEBaw4CAQIACyACIABBCGo2AgQgAUHY5f4AQQ1B5eX+AEEFIABBBGpBuOX+AEHq5f4AQQggAkEEakHI5f4AEI4YDAILIAIgAEEEajYCCCABQYTm/gBBCkGO5v4AQQogAEEIakH05f4AQerl/gBBCCACQQhqQcjl/gAQjhgMAQsgAiAAQQRqNgIMIAFBmOb+AEEMQaTm/gBBByAAQQhqQfTl/gBB6uX+AEEIIAJBDGpByOX+ABCOGAsgAkEQaiQAC8sBAQJ/IwBBIGsiAyQAAkACQCABKAIAIgEtAABBDUYEQCABKAIEIgRFDQEgA0EMaiAEQQhqIAEoAggQihggAygCECEBIAMoAgwiBEGTgICAeEcEQCAAIAMpAhQ3AgggAEEQaiADQRxqKAIANgIAIAAgATYCBCAAIAQ2AgAMAwsgACABNgIIIABCk4CAgBg3AgAgACACKQIYNwIMDAILQZCJ/wBBKEGolP8AEJ8pAAsgAEKTgICACDcCACAAIAIpAhA3AgwLIANBIGokAAu7AQEDfyMAQUBqIgIkACACQQhqIgMgACgCACUBEGUgAigCCCEAIAIgAigCDCIENgI8IAIgADYCOCACIAQ2AjQgAiACQTRqQYiviAEQkCEgAkHnHTYCJCACQQI2AgwgAkHIrogBNgIIIAJCATcCFCACIAIoAgQiADYCMCACIAIoAgA2AiwgAiAANgIoIAIgAkEoaiIANgIgIAIgAkEgajYCECABKAIAIAEoAgQgAxDLCiAAEN47IAJBQGskAAvgAwEHfyMAQTBrIgMkACADQRBqIQcjAEEQayIEJAACQAJAAkACQCABIAJGDQADQCABQQAgASgCABsQkSwiCEUEQCACIAFBBGoiAUcNAQwCCwsgBEEEaiIFQQRBAEEEQQQQoBggBCgCCCEGIAQoAgRBAUYNAiAEKAIMIgkgCDYCACAEQQxqIghBATYCACAEIAk2AgggBCAGNgIEAkAgAiABQQRqIgFGDQADQCABQQAgASgCABsgAUEEaiEBEJEsIglFBEAgASACRg0CDAELIAUoAggiBiAFKAIARgRAIAVBARCALgsgBSgCBCAGQQJ0aiAJNgIAIAUgBkEBajYCCCABIAJHDQALCyAHQQhqIAgoAgA2AgAgByAEKQIENwIADAELIAdBADYCCCAHQoCAgIDAADcCAAsgBEEQaiQADAELIAYgBCgCDEGQ0MMAEP0vAAsgAygCECEFIAMoAhQhASADIAMoAhgiAjYCHCADQQhqIAJBAnQiAiADQRxqEL8hIAMoAgghBCADKAIMIQcgAgRAIARBCGogASAC/AoAAAsgA0EANgIoIAMgATYCICADIAU2AhwgAyADQS9qNgIkIANBHGoiARDGJyABEOk7IAAgBzYCBCAAIAQ2AgAgA0EwaiQAC7AEAQl/IwBBMGsiAyQAIANBEGohCCMAQRBrIgQkAAJAAkACQAJAAkAgASACRg0AA0AgAUEEaigCACIFRQRAIAIgAUEIaiIBRw0BDAILCyABLQAAIQogBSAFKAIAIgZBAWo2AgAgBkEASA0CIARBBGoiBkEEQQBBBEEIEKAYIAQoAgghByAEKAIEQQFGDQMgBCgCDCIJIAU2AgQgCSAKOgAAIARBDGoiCkEBNgIAIAQgCTYCCCAEIAc2AgQCQCABQQhqIgEgAiIFRg0AAkADQCABQQhqIQIgAUEEaigCACIHRQRAIAIiASAFRg0DDAELIAEtAAAhCSAHIAcoAgAiAUEBajYCACABQQBIDQEgBigCCCIBIAYoAgBGBEAgBkEBEP8tCyAGKAIEIAFBA3RqIgsgBzYCBCALIAk6AAAgBiABQQFqNgIIIAIiASAFRw0ACwwBCwALIAhBCGogCigCADYCACAIIAQpAgQ3AgAMAQsgCEEANgIIIAhCgICAgMAANwIACyAEQRBqJAAMAgsACyAHIAQoAgxBkNDDABD9LwALIAMoAhAhBCADKAIUIQEgAyADKAIYIgI2AhwgA0EIaiACQQN0IgIgA0EcahC/ISADKAIIIQUgAygCDCEGIAIEQCAFQQhqIAEgAvwKAAALIANBADYCKCADIAE2AiAgAyAENgIcIAMgA0EvajYCJCADQRxqIgEQ3yYgARDqOyAAIAY2AgQgACAFNgIAIANBMGokAAu3AQEEfyAAKAIEIQIgACgCACEDIABCgYCAgBA3AgAgACgCECEBAkACQAJAIAIgA0cEQCABDQEMAwsgAUUNAiABRSAAKAIMIgMgACgCCCIAKAIIIgJGcg0BIAAoAgQiBCACaiADIARqIAH8CgAADAELIAFFIAAoAgwiAyAAKAIIIgAoAggiAkZyRQRAIAAoAgQiBCACaiADIARqIAH8CgAACyAAIAEgAmo2AggPCyAAIAEgAmo2AggLC58BAQN/IwBBEGsiBSQAAkAgASgC8AEiBEE8SQRAIAQhA0E7IQQMAQsgASgCBCEDCwJ/QYGAgIB4IAIgBCADa00NABpBACADIAIgA2oiAksNABpBAEF/IAJBAWtndkEAIAJBAk8bIgNBf0YNABogBUEIaiABIANBAWoQphAgBSgCDCEDIAUoAggLIQQgACADNgIEIAAgBDYCACAFQRBqJAALngEBA38jAEEQayIFJAACQCABKAJIIgRBEkkEQCAEIQNBESEEDAELIAEoAgQhAwsCf0GBgICAeCACIAQgA2tNDQAaQQAgAyACIANqIgJLDQAaQQBBfyACQQFrZ3ZBACACQQJPGyIDQX9GDQAaIAVBCGogASADQQFqEKcQIAUoAgwhAyAFKAIICyEEIAAgAzYCBCAAIAQ2AgAgBUEQaiQAC54BAQF+IAACfwJAIAMgBGpBAWtBACADa3GtIAGtfiIFQiCIUARAIAWnIgRBgICAgHggA2tNDQELIABBADYCBEEBDAELIARFBEAgACADNgIIIABBADYCBEEADAELAn8gAgRAIAQgAxCuNgwBCyAEIAMQrTYLIgIEQCAAIAI2AgggACABNgIEQQAMAQsgACAENgIIIAAgAzYCBEEBCzYCAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHU/cwAEP0vAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEH8u80AEP0vAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHYp84AEP0vAAu2AQEBfyMAQdAAayIDJAAgAAJ/IAJBA00EQCADIAI2AjwgA0ECNgIoIANBmLXOADYCJCADQgI3AjAgA0E7NgJMIANBOzYCRCADQai1zgA2AkAgAyADQUBrNgIsIAMgA0E8ajYCSCADQQhqQQRyIANBJGoQmQ4gACADKQMQNwMIIABBEGogA0EYaikDADcDAEEAIQIgAygCDAwBC0EIIQIgASgAAAs2AgQgACACNgIAIANB0ABqJAAL8QICB38DfiMAQTBrIgIkAAJAAkADQCACQQhqIQZBACEEIAEoAhwhAyABQQA2AhwgASABKAIYIANBA3ZqIANBB3FBAEdqIgM2AhgCQAJAIANBAWoiByABKAIIIgVNBEAgAyAFSw0BAn8gASgCBCADaiEIIwBBEGsiBCQAIAUgA2sEQCAEQQA6AA8gBEEPaiAILQAAOgAAIAQtAA8gBEEQaiQADAELQbS1zgBBI0HYtc4AEJ8pAAshBCABIAc2AhgLIAYgBDoAASAGIAUgB086AAAMAQsgAyAFQei6zgAQrzsACyACLQAIRQ0BIAlCwABaDQIgAiwACSIDrUL/AIMgCYYgCoQhCiAJQgd8IQkgA0EASA0ACyAAIAo3AwhCASELCyAAIAs3AwAgAkEwaiQADwsgAkECNgIUIAJBpLvOADYCECACQgE3AhwgAkE7NgIsIAJB+LrOADYCKCACIAJBKGo2AhggAkEQakG0u84AEO8sAAu4AQICfwJ+IwBBQGoiBCQAIAEpAwAhByABIAIpAgA3AwAgAUEIaiIFKQMAIQYgBSACQQhqKQIANwMAIARBCGogBjcDACABQRBqIgIpAwAhBiACQgA3AwAgBEEQaiAGNwMAIAFBGGoiAikDACEGIAJCADcDACAEQRhqIAY3AwAgBCAHNwMAIAenIgIEQCAEQQxqIAQoAgQgBCgCCCACKAIQEQEACyAAQQg2AgAgASADNgIwIARBQGskAAvEAQEEfyMAQRBrIgMkACABKAIMIQICQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASECQQAhAQwCCyACDQAgASgCACICKAIEIQEgAigCACECDAELIAAgARCZDgwBCyADQQRqIAFBAEEBQQEQoBggAygCCCEEIAMoAgRBAUYNASADKAIMIQUgAQRAIAUgAiAB/AoAAAsgACABNgIIIAAgBTYCBCAAIAQ2AgALIANBEGokAA8LIAQgAygCDEHko88AEP0vAAuuAQEEfwNAAkACQCABRQ0AIAAoAgQiBSAAKAIMIgZPDQAgACgCACAFQQxsaiIDKAIEIgQgAU8EQCADIAQgAWs2AgQPCyADQQA2AgQgASAEayIBIAMoAggiBE8NASADIAQgAWsiATYCCCABIAJPDQAgBiAFQQFqIgJLBEAgAyADKAIQIAFqNgIQCyAAIAI2AgQLDwsgA0EANgIIIAAgBUEBajYCBCABIARrIQEMAAsAC8ABAgJ/AX4jAEEQayICJAACQAJAAkACQCABLQAYIgNBF2sOBAIBAQIACyADQSJGDQILIAIgARDvPCACKAIEIgNFDQEgAigCACEBIANBxABsIQMDQCAAIAEQqRggAUHEAGohASADQcQAayIDDQALDAELIAJBCGogARDcOyACNQIMQgF9IQQgACgCCCIBIAAoAgBGBEAgAEH8zf4AELMoCyAAKAIEIAFBA3RqIAQ3AwAgACABQQFqNgIICyACQRBqJAALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxB0KD/ABD9LwALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxBjMn/ABD9LwALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxB4K2AARD9LwALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQkyIiBigCFCIDQQN2IghBAWshBSADQQhJDQIgBigCECIDIAVBA3RqKAIAIQUgAygCACEDIAYQ1DogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQlSIiBigCFCIDQQN2IghBAWshBSADQQhJDQIgBigCECIDIAVBA3RqKAIAIQUgAygCACEDIAYQ1DogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQlCIiBigCFCIDQQJ2IghBAWshBSADQQRJDQIgBigCECIDIAVBAnRqKAIAIQUgAygCACEDIAYQ0zogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQALrwEBBn8CQAJAIAJFBEBBACECDAELIAEgAkEDdGohB0EAIQIDQCABKAIAIAFBBGooAgAQkiIiBigCFCIDQQJ2IghBAWshBSADQQRJDQIgBigCECIDIAVBAnRqKAIAIQUgAygCACEDIAYQ0zogBGohBCACIAVqIANrIQIgAUEIaiIBIAdHDQALCyAAIAI2AgggACAENgIMIABCgYCAgBg3AgAPCyAFIAhBkMqCARDDIQAL+gIBBX8jAEEgayICJAACQAJAAkACQAJAIAEoAiQiBEUEQCACQQhqIAEQ3DsgAigCDEUNASACKAIIKAIIRQ0DCyACIAEQ3DsgAigCBA0BQQBBAEG8w4QBEMMhAAtBAEEAQazDhAEQwyEACyACKAIAIgUoAgAiAyADKAIAIgZBAWo2AgAgBkEASA0CIAIgAzYCFCACIAUpAgQ3AhggACACQRRqIAEoAiggBEEBahD+HAwBCyMAQUBqIgEkACABQRBqQQgQ0h8gASABKQIQNwI4IAFBADYCNCABIAEoAhwiBDYCMCABIAEoAhg2AiwgAUEIaiABQSxqENc7IAEoAgghBUEcQQQQrTYiA0UEQEEEQRwQoz0ACyADQoGAgIAQNwIAIAMgASkCLDcCCCADQRBqIAFBNGopAgA3AgAgA0EYaiABQTxqKAIANgIAIAEgBDYCKCABIAU2AiQgASADNgIgIAAgAUEgahDkGSABQUBrJAALIAJBIGokAA8LAAv6AgEFfyMAQSBrIgIkAAJAAkACQAJAAkAgASgCJCIERQRAIAJBCGogARDcOyACKAIMRQ0BIAIoAggoAghFDQMLIAIgARDcOyACKAIEDQFBAEEAQbzDhAEQwyEAC0EAQQBBrMOEARDDIQALIAIoAgAiBSgCACIDIAMoAgAiBkEBajYCACAGQQBIDQIgAiADNgIUIAIgBSkCBDcCGCAAIAJBFGogASgCKCAEQQFqEIAdDAELIwBBQGoiASQAIAFBEGpBBBDSHyABIAEpAhA3AjggAUEANgI0IAEgASgCHCIENgIwIAEgASgCGDYCLCABQQhqIAFBLGoQ1zsgASgCCCEFQRxBBBCtNiIDRQRAQQRBHBCjPQALIANCgYCAgBA3AgAgAyABKQIsNwIIIANBEGogAUE0aikCADcCACADQRhqIAFBPGooAgA2AgAgASAENgIoIAEgBTYCJCABIAM2AiAgACABQSBqEOUZIAFBQGskAAsgAkEgaiQADwsAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgIABNwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgMAANwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQR0NgIcIAJCgICAgIACNwIUIAIgBEEEdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC70BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQF0NgIcIAJCgICAgCA3AhQgAiAEQQF0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBHQ2AhwgAkKAgICAgAE3AhQgAiAEQQR0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBAnQ2AhwgAkKAgICAwAA3AhQgAiAEQQJ0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBXQ2AhwgAkKAgICAgAI3AhQgAiAEQQV0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALvgEBA38jAEEgayICJAAgASgCBCEDIAEoAgghBCACIAEoAgBBBHQ2AhwgAkKAgICAgAI3AhQgAiAEQQR0IgQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACAAIAQ2AgggACADNgIEIAAgATYCACACQSBqJAALxAEBBH8jAEEQayIDJAAgASgCDCECAkACQAJAAkACQAJAIAEoAgQOAgABAgsgAg0BQQEhAkEAIQEMAgsgAg0AIAEoAgAiAigCBCEBIAIoAgAhAgwBCyAAIAEQmQ4MAQsgA0EEaiABQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCEFIAEEQCAFIAIgAfwKAAALIAAgATYCCCAAIAU2AgQgACAENgIACyADQRBqJAAPCyAEIAMoAgxBgOOGARD9LwALsAEBAn8CQCAAKAIIIgUgAyAEamwiAiADIAVsIgNPBEAgAiAAKAIEIgZLDQEgACgCACEGIAEoAgwiAiAEIAVsIgBqIgQgASgCBCIFSwRAIAEgBUEBdCICIAQQ3ioiBCACIARLGxDoGSABKAIMIQILIAAEQCABKAIIIAJqIAMgBmogAPwKAAALIAEgASgCDCAAajYCDA8LIAMgAkHUoYcBELE7AAsgAiAGQdShhwEQsDsAC74BAQN/IwBBIGsiAiQAIAEoAgQhAyABKAIIIQQgAiABKAIAQQN0NgIcIAJCgICAgIABNwIUIAIgBEEDdCIENgIQIAIgAzYCDCACIAJBDGoQ1zsgAigCACEDQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgACAENgIIIAAgAzYCBCAAIAE2AgAgAkEgaiQAC8QBAQR/IwBBEGsiAyQAIAEoAgwhAgJAAkACQAJAAkACQCABKAIEDgIAAQILIAINAUEBIQJBACEBDAILIAINACABKAIAIgIoAgQhASACKAIAIQIMAQsgACABEJkODAELIANBBGogAUEAQQFBARCgGCADKAIIIQQgAygCBEEBRg0BIAMoAgwhBSABBEAgBSACIAH8CgAACyAAIAE2AgggACAFNgIEIAAgBDYCAAsgA0EQaiQADwsgBCADKAIMQbDWhwEQ/S8AC9MBAQd/AkAgACgCECIJIAIgAWsiCmoiB0EDdiAHQQdxQQBHaiICIAAoAgwiBU0EQCAAKAIIIQYgBSECDAELIAIgBWshCCAAKAIEIgYgAkkEQAJAIAIiBUE/cSILRQ0AIAIgC2tBQGsiBSACTw0AQaCDiAFBI0HEg4gBEMskAAsgACAGQQF0IgYgBSAFIAZJGxDoGSAAKAIMIQULIAAoAgghBiAIBEAgBSAGakEAIAj8CwALIAAgAjYCDAsgACAHNgIQIAYgAiADIAQgCSABIAoQhAkaC8IBAQN/IwBBEGsiBCQAAkACQCABKAIAIgEoAhBBAUcEQCAEQQRqIANBAEEBQQEQoBggBCgCCCEGIAQoAgRBAUYNAiAEKAIMIQUgAwRAIAUgAiAD/AoAAAsgARDDLAwBCyABQQA2AgggASgCACEGIAEoAgQhBSABQoCAgIAQNwIAIAEQwywgA0UNACAFIAIgA/wKAAALIAAgAzYCCCAAIAU2AgQgACAGNgIAIARBEGokAA8LIAYgBCgCDEGUiIgBEP0vAAuoAQEDfyMAQRBrIgMkAEEDIQIgAC0AACIAIQQgAEEKTwRAIAMgACAAQeQAbiIEQeQAbGtB/wFxQQF0IgJB4/OJAWotAAA6AA8gAyACQeLziQFqLQAAOgAOQQEhAgtBACAAIAQbRQRAIAJBAWsiAiADQQ1qaiAEQQF0Qf4BcUHj84kBai0AADoAAAsgAUEBQQFBACADQQ1qIAJqQQMgAmsQgQkgA0EQaiQAC3sCAX8BfgJAIAApAwAiAkIIUQ0AIAKnIgFBBkkNACABQQdGGgJAIAAoAihFDQAgACgCLCIBRQ0AIABBOGogACgCMCAAKAI0IAEoAhARAQALIAAoAjxFDQAgACgCQCIBRQ0AIABBzABqIAAoAkQgACgCSCABKAIQEQEACwuqAQIEfwF+IwBBEGsiBCQAIAAoAggiAUEEaiECAkACQCABQXtNBEAgAiAAKAIEIgNLDQEgBEEEaiICIAAoAgAiACADIAEgACABaigAAGsQ9jQgAkEEEMwgQf//A3EiAgR+IAEgAmoiASADSw0DIAAgAWopAAAFQgALIARBEGokAA8LIAEgAkHQzMwAELE7AAsgAiADQdDMzAAQsDsACyABIANBjMnMABCvOwALtQEBAX8jAEHQAGsiAyQAIAACfyACQQdNBEAgAyACNgI8IANBAjYCKCADQZi1zgA2AiQgA0ICNwIwIANBOzYCTCADQTs2AkQgA0Gwtc4ANgJAIAMgA0FAazYCLCADIANBPGo2AkggA0EIakEEciADQSRqEJkOIAAgAykCFDcCDCAAQRRqIANBHGooAgA2AgAgACADKQIMNwIEQQAMAQsgACABKQAANwMIQQgLNgIAIANB0ABqJAALmwEAAkAgASACQQdxIgFBB2ogASABQQNJG2oiAUEHTwRAQQEgAUEHbiIBIAFBhgggAnZBAXFBNHJLIgEbIQIgACABaiIBQZADbyEADAELQYYIIABBAWsiAUGQA28iAEEfdUGQA3EgAGpB5L+GAWotAAB2QQFxQTRyIQILIABBH3VBkANxIABqQeS/hgFqLQAAIAFBCnQgAkEEdHJyC8MCAgV/AX4jAEGAAWsiAyQAIANBQGshBCABKAIIIQUjAEHwAGsiAiQAAkAgASgCACIGIAEoAgRHBEAgASAGQQRqNgIAIAJBOGogBigCAEEIahDoDCAEAn4gAigCOEEBcQRAIAUQjhIgBUEQaiACQcwAaigCADYCACAFQQhqIAJBxABqKQIANwIAIAUgAikCPDcCAEIADAELIAJBCGogAkFAa0Ew/AoAAEIBCzcDACAEQQhqIAJBCGpBMPwKAAAMAQsgBEICNwMACyACQfAAaiQAAkAgAykDQEICUgRAIANBCGogBEE4/AoAACADKQMIIgenQQFxBEAgAEEIaiADQRBqQTD8CgAAIABCATcDAAwCCyAAQgA3AwAgB1ANASADKAI4IgBFDQEgA0EQaiAAEQMADAELIABCADcDAAsgA0GAAWokAAu8AQEEfyMAQRBrIgMkACABKAIAIgEoAghFBEAgASgCDCEEIAFC/////y83AgggAQJ/IARBAkcEQCABKAIQIQJBAAwBCyADQQhqIAIoAgAiAigCBCACKAIAKAIAEQAAIAMoAgwhAiADKAIIIQUgASgCFCIGBEAgASgCGCAGKAIMEQMACyABIAI2AhggASAFNgIUIAEoAghBAWoLNgIIIAAgAjYCBCAAIAQ2AgAgA0EQaiQADwtBnKmIARCbPgALpgEBAX8jAEEgayIBJAACf0EKIAAoAgAiAyAAKAIERg0AGiAAIANBBGo2AgAgAUEIaiADKAIAEMYaIAEtAAwiACABKAIIIgNBCEYNABogAigCAEEIRwRAIAIQySMLIAIgADoABCACIAM2AgAgAiABQQhqQQVyIgApAAA3AAUgAkENaiAAQQhqKQAANwAAIAJBFGogAEEPaigAADYAAEEJCyABQSBqJAALqwEBAn8gA0H4////AXEEQCAAIAAgA0F4cSIFaiAAIANBA3YiA0EObCIGaiADIAQQyRghACABIAEgBWogASAGaiADIAQQyRghASACIAIgBWogAiAGaiADIAQQyRghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwurAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIgZqIAMgBBDKGCEAIAEgASAFaiABIAZqIAMgBBDKGCEBIAIgAiAFaiACIAZqIAMgBBDKGCECCyAAIAEgBCgCACgCACgCABECACIDIAAgAiAEKAIAKAIAKAIAEQIAc0EATgR/IAIgASABIAIgBCgCACgCACgCABECACADc0EASBsFIAALC6sBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0ECdCIFaiAAIANBB2wiBmogAyAEEMsYIQAgASABIAVqIAEgBmogAyAEEMsYIQEgAiACIAVqIAIgBmogAyAEEMsYIQILIAAgASAEKAIAKAIAKAIAEQIAIgMgACACIAQoAgAoAgAoAgARAgBzQQBOBH8gAiABIAEgAiAEKAIAKAIAKAIAEQIAIANzQQBIGwUgAAsLqwEBAn8gA0H4////AXEEQCAAIAAgA0EDdiIDQQV0IgVqIAAgA0E4bCIGaiADIAQQzBghACABIAEgBWogASAGaiADIAQQzBghASACIAIgBWogAiAGaiADIAQQzBghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwusAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBnQiBWogACADQfAAbCIGaiADIAQQzRghACABIAEgBWogASAGaiADIAQQzRghASACIAIgBWogAiAGaiADIAQQzRghAgsgACABIAQoAgAoAgAoAgARAgAiAyAAIAIgBCgCACgCACgCABECAHNBAE4EfyACIAEgASACIAQoAgAoAgAoAgARAgAgA3NBAEgbBSAACwtiAQJ/IwBBEGsiAyQAIANBBGogAUEBQQFBARCgGCADKAIIIQQCQCADKAIEBEAMAQsgAygCDCECIAAgATYCCCAAIAI2AgQgACAENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAuTAQIDfwN+IAEoAgQiAkELSQRAIAFBCGohAQJAA0AgAkUNASABLQAAIgNB/wBxrSAFhiAGhCEGIAPAIgNBAEgEQCACQQFrIQIgAUEBaiEBIAVCOVQgBUIHfCEFDQELCyADQQBIDQBCASEHIABCACAGQgGDfSAGQgGIhTcDCAsgACAHNwMADwsgAkEKQdCo/gAQsDsAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBoMmEASgCACICNgIAIAFBmMmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSNHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpBxMmEASgCACICNgIAIAFBvMmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSZHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpB6MmEASgCACICNgIAIAFB4MmEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSRHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7UBAgN/AX4jAEFAaiIBJAAgASAANgIEIAFBEGpByMqEASgCACICNgIAIAFBwMqEASkCACIENwMIIAAtAAAgAUEIaiIDEL8MQSVHBEAgAUEoaiACNgIAIAEgBDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgA0HwyIQBEO8sAAsgAUFAayQAC7EBAQN/IwBBIGsiAyQAAkAgAigCAARAIAMgASgCECIENgIAIAMgAigCECIFNgIEIAQgBUcNAQsgACABKQIANwIAIAAgAikCADcCFCAAQRBqIAFBEGooAgA2AgAgAEEIaiABQQhqKQIANwIAIABBHGogAkEIaikCADcCACAAQSRqIAJBEGopAgA3AgAgA0EgaiQADwsgA0EANgIIQQAgAyADQQRqIANBCGpBzO6FARCvKwALuAEBAn8jAEEwayIDJAAgAyABNgIQAkAgAigCAARAIAMgAigCECIENgIUIAEgBEcNAQsgA0EIahDBLCAAIAMpAwg3AhAgAEEgOgAMIAAgATYCGCAAIAIpAgA3AhwgAEEANgIIIABCgICAgMAANwIAIABBJGogAkEIaikCADcCACAAQSxqIAJBEGopAgA3AgAgA0EwaiQADwsgA0EANgIYQQAgA0EQaiADQRRqIANBGGpB6PaFARCvKwALtgEBAX8jAEEQayICJAACQCABKALgAUGBgICAeEcEQCACQQRqIAFB4AFqEOMcDAELIAJBADYCBAsCQAJAAkAgASgCoAIoAhQiAUEIaiABKAIIQQJGQQJ0ai0AIA4EAAEBAAELIABBADYCACACKAIEIgBFDQEgACAAKAIAIgBBAWs2AgAgAEEBRw0BIAJBBGoQ+x4MAQsgACACKQIENwIAIABBCGogAkEMaigCADYCAAsgAkEQaiQAC7YBAQF/IwBBEGsiAiQAAkAgASgCuAJBgYCAgHhHBEAgAkEEaiABQbgCahDjHAwBCyACQQA2AgQLAkACQAJAIAEoAuwCKAIUIgFBCGogASgCCEECRkECdGotACAOBAABAQABCyAAQQA2AgAgAigCBCIARQ0BIAAgACgCACIAQQFrNgIAIABBAUcNASACQQRqEPseDAELIAAgAikCBDcCACAAQQhqIAJBDGooAgA2AgALIAJBEGokAAu2AQEBfyMAQRBrIgIkAAJAIAEoAsACQYGAgIB4RwRAIAJBBGogAUHAAmoQ4xwMAQsgAkEANgIECwJAAkACQCABKAL0AigCFCIBQQhqIAEoAghBAkZBAnRqLQAgDgQAAQEAAQsgAEEANgIAIAIoAgQiAEUNASAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEEahD7HgwBCyAAIAIpAgQ3AgAgAEEIaiACQQxqKAIANgIACyACQRBqJAALsQEBAn8jAEEQayIEJAAgAUEEaiEFAkAgASgCAEEBRgRAIAIgBSADEIkNRQ0BCwJAIAAoAgAiAgRAIAQgAEEMaiAAKAIEIAAoAgggAigCABEFAAwBCyAEQQA2AgALAkAgASgCAEUNACAFKAIAIgBFDQAgAUEQaiABKAIIIAEoAgwgACgCEBEBAAsgAUEBNgIAIAUgBCkCADcCACAFQQhqIARBCGopAgA3AgALIARBEGokAAuxAQECfyMAQRBrIgQkACABQQRqIQUCQCABKAIAQQFGBEAgAiADIAUQiQ1FDQELAkAgACgCACICBEAgBCAAQQxqIAAoAgQgACgCCCACKAIAEQUADAELIARBADYCAAsCQCABKAIARQ0AIAUoAgAiAEUNACABQRBqIAEoAgggASgCDCAAKAIQEQEACyABQQE2AgAgBSAEKQIANwIAIAVBCGogBEEIaikCADcCAAsgBEEQaiQAC6oBAQJ/IAAoAggiAgRAIAAoAgRBxABqIQADQAJAIABBNGsoAgBFDQAgAEEwaygCACIBRQ0AIABBJGsgAEEsaygCACAAQShrKAIAIAEoAhARAQALAkAgAEEgaygCAEUNACAAQRxrKAIAIgFFDQAgAEEQayAAQRhrKAIAIABBFGsoAgAgASgCEBEBAAsgAEEMaxCFMCAAEIUwIABB0ABqIQAgAkEBayICDQALCwuiAQEGfyAAKAIIIgQEQCAAKAIEIQUDQCAFIAJBBnRqIgFBIGogASgCKCIDBEAgASgCJCEAA0AgABDwEiAAQcACaiEAIANBAWsiAw0ACwtBCEHAAhDgHiABKAIsQYCAgIB4RwRAIAFBLGpBBEEIEOAeCyABKAI8IgAgACgCACIAQQFrNgIAIABBAUYEQCABQTxqEIYfCyACQQFqIgIgBEcNAAsLC7UBAQJ/IwBBMGsiAiQAIAJBDGogARDgLCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAAgAzYCCCAAIAQ2AgQgACABNgIAIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAkEwaiQAC7UBAQJ/IwBBMGsiAiQAIAJBDGogARDeLCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAAgAzYCCCAAIAQ2AgQgACABNgIAIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgAkEwaiQAC6wBAQJ/AkAgACgCACIBKAIIIgBFBEAgASgCFCICBEAgASgCEEEQaiEAA0AgACAAQQhrKAIAIABBBGsoAgAgAEEMaygCACgCEBEBACAAQRRqIQAgAkEBayICDQALCyABQQxqQQRBFBDgHgwBCyABQRRqIAEoAgwgASgCECAAKAIQEQEACwJAIAFBf0YNACABIAEoAgQiAEEBazYCBCAAQQFHDQAgAUEcQQQQ+DoLC6QBAQF/AkAgAiAAa0EETgRAIAJBA2shBQNAIAEQ4BsgACAFT3INAiAAIAEgAyAEEIcsOgAAIABBAWogASADIAQQhyw6AAAgAEECaiEADAALAAsgARDgGxoLA0AgARDgGyAAIAJPckUEQCAAIAEgAyAEEIcsOgAAIABBAWohAAwBCwsDQCAAIAJPRQRAIAAgASADIAQQhyw6AAAgAEEBaiEADAELCwvEAQEBfyMAQTBrIgIkAAJ/AkACQAJAAkAgACgCAEEBaw4DAQIDAAsgAiAAQQRqNgIAIAIgAEEIajYCBCACQQI2AgwgAkHMydEANgIIIAJCAjcCFCACQfoKNgIsIAJB+go2AiQgAiACQSBqNgIQIAIgAjYCKCACIAJBBGo2AiAgASgCACABKAIEIAJBCGoQywoMAwsgAUHcydEAQSUQ+zUMAgsgAUGBytEAQSEQ+zUMAQsgAUGiytEAQT4Q+zULIAJBMGokAAuuAQEFfyMAQRBrIgMkACAAKAIcIgJB2ABqIgEQkBUgA0EIaiABEOQlAkAgACgCECIEIAMoAgwiASABIARLGyIBRQ0AIAAoAgwhBSABBEAgBSADKAIIIAH8CgAACyAAIAEgBWo2AgwgACAEIAFrNgIQIAAgACgCFCABajYCFCACIAIoAmAgAWo2AmAgAiACKAJkIgAgAWs2AmQgACABRw0AIAJBADYCYAsgA0EQaiQAC18BAn8jAEEwayICJAAgAkEBNgIMIAIgATYCCAJAIAFFDQAgACgCBCIDQZwLRwRAIAAoAgggAUEEaygAACADEQAADAELIAJBgIAINgIQIAJBEGogARDpJAsgAkEwaiQAC7cBAQJ/IwBBMGsiAyQAIAMgAjYCDCADIAE2AggCQAJAIAFFDQAgACgCBCIEQZwLRwRAIAAoAgggAUEEaygAACAEEQAADAELIAJFDQEgAyACQQF0NgIQIANBEGogARDpJAsgA0EwaiQADwsgA0IBNwIcIANBATYCFCADQdD1/AA2AhAgA0GeCzYCLCADIANBKGo2AhggAyADQQhqNgIoQQEgA0EMakG49fwAIANBEGpB2PX8ABCvKwALXgECfyMAQTBrIgIkACACQQE2AgwgAiABNgIIAkAgAUUNACAAKAIEIgNBnAtHBEAgACgCCCABQQRrKAAAIAMRAAAMAQsgAkHAFjYCECACQRBqIAEQ6SQLIAJBMGokAAusAQECfyMAQRBrIgMkAAJAIAFFBEAgAEEANgIEDAELIAEoAhRFBEAgAEEANgIEDAELIANBBGoiBCABIAIQlQIgAigCPCIBIARBACABENMfIgJHBEAgACADKQIENwIEIAAgASACazYCACAAQQxqIANBDGooAgA2AgAMAQsgAEEANgIEIAMoAgQiACAAKAIAIgBBAWs2AgAgAEEBRw0AIANBBGoQ+x4LIANBEGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3iwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ4CwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3ywgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAvbAQEDfyMAQTBrIgIkACACQQxqIgNBCDYCACADIAEoAgQ2AgggAyABKAIIQQR0NgIMIAMgASgCAEEEdDYCBCACIAIpAgw3AiggAkEANgIkIAIgAigCGCIDNgIgIAIgAigCFDYCHCACIAJBHGoQ1zsgAigCACEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIcNwIIIAFBEGogAkEkaikCADcCACABQRhqIAJBLGooAgA2AgAgACADNgIIIAAgBDYCBCAAIAE2AgAgAkEwaiQAC9sBAQN/IwBBMGsiAiQAIAJBDGoiA0EENgIAIAMgASgCBDYCCCADIAEoAghBA3Q2AgwgAyABKAIAQQN0NgIEIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACAAIAM2AgggACAENgIEIAAgATYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEN0sIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACAAIAM2AgggACAENgIEIAAgATYCACACQTBqJAAL2wEBA38jAEEwayICJAAgAkEMaiIDQRA2AgAgAyABKAIENgIIIAMgASgCCEEFdDYCDCADIAEoAgBBBXQ2AgQgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ8i8gAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAAgAzYCCCAAIAQ2AgQgACABNgIAIAJBMGokAAu1AQEDfyMAQTBrIgIkACACQQxqIAEQ3SwgAiACKQIMNwIoIAJBADYCJCACIAIoAhgiAzYCICACIAIoAhQ2AhwgAiACQRxqENc7IAIoAgAhBEEcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCHDcCCCAAIAM2AgggACAENgIEIAAgATYCACABQRBqIAJBJGopAgA3AgAgAUEYaiACQSxqKAIANgIAIAJBMGokAAvTBgIQfwF+IwBBMGsiBSQAIAVBDGohCiMAQUBqIgIkACACQQhqIAFBKPwKAAAgAigCCCIIEMA8IQQgAigCJCEBIAgQwDwaQcAAIQcCQEF/IAQgAWsiBEEHaiIDIAMgBEkbIgRBA3YiA0HA////AXFBQGsgAyAEQfgDcRsiBEHAABDRNARAAkAgBARAIARBwAAQrTYiB0UNAQsgAkEANgI8IAIgBzYCOCACIAQ2AjQgAkHAADYCMCACQQxqIQsgAigCLCEMIAIoAhghDSACKAIQIQ4gAigCHCEPIAIoAgwhCSACKAIoIQRBACEHQQEhAwNAAkACQAJAAkAgASAERiIQRQRAAn8gCQRAIAEgD08NA0EAIA4gASANaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXENARoLIAgoAhAgAUEDdGopAwAiEkKAgICAEFoNAyADQQAgDCASpxCTOxsLIAdyIQcgAUEBaiEBIANBAXQiA0H+AXENBSACIAE2AiQMAwsgAiAENgIkIAQhASADQf8BcUEBRw0CDAMLQZz4gwFBIEG8+IMBEJ8pAAtBtPmDARCyOwALAkAgAigCPCIGIAIoAjRHDQAgCBDAPCEDIAgQwDwaIAIoAjwiBkF/IAMgAWsiA0EHaiIRIAMgEUsbQQN2akEBaiIDIAIoAjRNDQAgAxDVKiEDIAJBMGogAigCNEEBdCIGIAMgAyAGSRsQ6BkgAigCPCEGCyACKAI4IAZqIAc6AABBASEDIAIgBkEBajYCPEEAIQcgEEUNAQsLIAogAikCMDcCACAKQQhqIAJBOGopAgA3AgACQCAJRQ0AIAkgCSgCACIBQQFrNgIAIAFBAUcNACALEPseCyACQUBrJAAMAgtBwAAgBBCjPQALQcz4gwFBKSACQTBqQZj5gwFB+PiDARDVHgALIAUgBSkCDDcCKCAFQQA2AiQgBSAFKAIYIgQ2AiAgBSAFKAIUNgIcIAUgBUEcahDXOyAFKAIAIQJBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAUpAhw3AgggACAENgIIIAAgAjYCBCAAIAE2AgAgAUEQaiAFQSRqKQIANwIAIAFBGGogBUEsaigCADYCACAFQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEOAsIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEPIvIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALtQEBA38jAEEwayICJAAgAkEMaiABEN4sIAIgAikCDDcCKCACQQA2AiQgAiACKAIYIgM2AiAgAiACKAIUNgIcIAIgAkEcahDXOyACKAIAIQRBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAhw3AgggACADNgIIIAAgBDYCBCAAIAE2AgAgAUEQaiACQSRqKQIANwIAIAFBGGogAkEsaigCADYCACACQTBqJAALsQEBA38jAEEQayIDJABBwAAhBAJAIAFBA3YgAUEHcUEAR2oiAkHA////A3FBQGsgAiACQT9xGyICQcAAENE0BEAgAgRAIAJBwAAQrTYiBEUNAgsgACABNgIsIABBADYCKCAAQQA2AhQgAEIANwIMIAAgBDYCCCAAIAI2AgQgAEHAADYCACADQRBqJAAPC0H06YUBQSkgA0EPakHg6oUBQaDqhQEQ1R4AC0HAACACEKM9AAuyAQEBfwJAQQxBBBCtNiIGBEAgBkECNgIIIAYgAzYCACAGIAQgA2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAgASABKAIIIgJBAWo2AgggAkEASA0CIAAgATYCDCAAIAU2AgggACAENgIEIABBgIiIATYCACAGQQxBBBD4Og8LIAAgBjYCDCAAIAU2AgggACAENgIEIABBgIiIATYCAA8LQQRBDBCjPQALAAu9AQEBfyMAQRBrIgckACAAKAIAIAEgAiAAKAIEKAIMEQYAIQEgB0EAOgANIAcgAToADCAHIAA2AgggB0EIaiADIAQgBSAGEIgSIQEgBy0ADSICIActAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB1/GJAUECIAAoAgQoAgwRBgAhAAwBCyAAKAIAQdbxiQFBASAAKAIEKAIMEQYAIQALIAdBEGokACAAQQFxC7sEAg1/AX4jAEEgayIEJAAgBEEUaiABKAIcIAEoAhRrQQR2IgIgASgCDCABKAIEa0EDdiIFIAIgBUkbQQBBBEEUEKAYIAQoAhghAiAEKAIUQQFGBEAgAiAEKAIcQdC0wgAQ/S8ACyAEQRBqIgtBADYCACAEIAQoAhw2AgwgBCACNgIIIwBB0ABrIgIkACABKAIcIAEoAhRrQQR2IgUgASgCDCABKAIEa0EDdiIDIAMgBUsbIgMgBEEIaiIHKAIAIAcoAggiBWtLBEAgByAFIANBBEEUENAoIAcoAgghBQsgBygCBCEJIAJBCGogAUEo/AoAACACKAIkIgwgAigCHCIBa0EEdiIDIAIoAhQiDSACKAIMIgZrQQN2IgggAyAISRsiCARAIAkgBUEUbGohAwNAIAYgDUcEQCAGKAIAIQkgBkEIaiEGCwJAIAEgDEYEQEEAIQoMAQsgASgCACEKIAJBOGogAUEMaigCADYCACACIAEpAgQ3AzAgAUEQaiEBCyACQcgAaiACQThqKAIAIg42AgAgAiACKQMwIg83A0AgA0EEaiAKNgIAIAMgCTYCACADQQhqIA83AgAgA0EQaiAONgIAIANBFGohAyAFQQFqIQUgCEEBayIIDQALIAIgATYCHCACIAY2AgwLIAcgBTYCCCACIAIoAgg2AkQgAiACKAIQNgJAIAJBQGsQ4zwgAkEYahC7HCACQdAAaiQAIABBCGogCygCADYCACAAIAQpAgg3AgAgBEEgaiQAC6QBAQN/IwBBEGsiAyQAIANBCGogAhDqOgJAIAMoAgwiBSADKAIIIgJGBEAgAEIANwIAIABBCGpCADcCAAwBCyAAIAEoAgggAmoiBCABKAIAIgFBACABIARNG2siBDYCACAFIAJrIgIgASAEayIFTQRAIABCADcCCCAAIAIgBGo2AgQMAQsgAEEANgIIIAAgATYCBCAAIAIgBWs2AgwLIANBEGokAAuiAQEDfyAAKAJoIQEgACgCbCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJYQYCAgIB4RwRAIABBEGpBCBDuKCAAQUBrEN47IABB2ABqEOM8CyAAKAJ8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfwAahDZIQsgACgCcEGAgICAeEcEQCAAQfAAakEEQSAQ4B4LC6UBAQN/IAAoAnghASAAKAJ8IgMoAgAiAgRAIAEgAhEDAAsgAygCBCICBEAgASACIAMoAggQ+DoLIAAoAmhBgICAgHhHBEAgAEEgakEIEO4oIABB0ABqEOk7IABB6ABqEOM8CyAAKAKMASIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGMAWoQ2SELIAAoAoABQYCAgIB4RwRAIABBgAFqQQRBIBDgHgsLpwEBA38gACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAahDjPCAAQfgAahDjPAsgACgCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBnAFqENkhCyAAKAKQAUGAgICAeEcEQCAAQZABakEEQSAQ4B4LC8sBAQJ/IwBBEGsiAiQAIAAoAgAiAEEwaiEDAn8gACgCCEECRgRAIAIgAzYCDCABQZzr0ABBCUHZ6tAAQQogAEEMakGc6tAAQaXr0ABBBiACQQxqQYzr0AAQjhgMAQsgAiAAQTRqNgIIIAFBzOrQAEHZ6tAAQQogAEEIakGc6tAAQePq0ABBDSAAQThqQazq0ABB8OrQAEELIABBLGpBvOrQAEH76tAAQQUgA0G86tAAQYDr0ABBCSACQQhqQfDp0AAQ1xULIAJBEGokAAufAQEDf0EDIQIgACgCBCIBQSBNBEAgACgCCCIDIAAoAhBPBEAgACABQQdxNgIEIAAgAyABQQN2ayIBNgIIIAAgASgAADYCAEEADwsgACgCDCICIANGBEBBAkEBIAFBIEYbDwsgACABIAMgAmsgAUEDdiIBIAMgAWsgAkkiAhsiAUEDdGs2AgQgACADIAFrIgE2AgggACABKAAANgIACyACC6UBAQF/IAAgAmohAwJAAkAgAkEITgRAIAAgAWsiAkF5SA0BCwNAIAAgA08NAiAAIAEtAAA6AAAgAEEBaiEAIAFBAWohAQwACwALAkACQCACQW9LDQAgACADQSBrIgJLDQAgACABIAIgAGsiAEEAENEVIAAgAWohAQwBCyAAIQILA0AgAiADTw0BIAIgAS0AADoAACACQQFqIQIgAUEBaiEBDAALAAsLpAQCCX8BfiMAQSBrIgUkACAFQRRqIAEoAhQgASgCDGtBA3YiAiABKAIEIAEoAgBrQQJ2IgMgAiADSRtBAEEEQQwQoBggBSgCGCECIAUoAhRBAUYEQCACIAUoAhxBvPyBARD9LwALIAVBEGoiCEEANgIAIAUgBSgCHDYCDCAFIAI2AggjAEEgayICJAAgASgCFCABKAIMa0EDdiIDIAEoAgQgASgCAGtBAnYiBCADIARJGyIGIAVBCGoiBCgCACAEKAIIIgNrSwRAIAQgAyAGQQRBDBDeKCAEKAIIIQMLIAQoAgQhBiACQQhqIgkgAUEIaikCADcDACACQRBqIAFBEGopAgA3AwAgAkEYaiABQRhqKQIANwMAIAIgASkCACILNwMAIAQgAigCFCACKAIMa0EDdiIBIAIoAgQgC6drQQJ2IgQgASAESRsiBAR/IAMgBGogBiADQQxsaiEBA0ACQCACKAIAIgMgAigCBEYEQEEAIQMMAQsgAiADQQRqNgIAIAMoAgAiAyADKAIAIgZBAWo2AgAgBkEATg0AAAsgAigCDCIGIAIoAhRGBH9BAAUgAiAGQQhqNgIMIAYoAgQhByAGKAIACyEGIAEgAzYCACABQQhqIAc2AgAgAUEEaiAGNgIAIAFBDGohASAEQQFrIgQNAAsFIAMLNgIIIAkQshwgAkEgaiQAIABBCGogCCgCADYCACAAIAUpAgg3AgAgBUEgaiQAC6sBAQN/IwBBEGsiBCQAAkAgAkEBaiIFIAEoAhxBAnYiA0kEQCACIANJDQEgAiADQcDVhQEQwyEACyAFIANBsNWFARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAEoAhgiASACQQJ0aigCACICIAEgBUECdGooAgAgAmsgAygCIBEFACAEKAIMIQEgACAEKAIINgIAIAAgATYCBCAEQRBqJAALqwEBA38jAEEQayIEJAACQCACQQFqIgUgASgCHEEDdiIDSQRAIAIgA0kNASACIANBwNWFARDDIQALIAUgA0Gw1YUBEMMhAAsgBEEIaiABKAIMIAEoAhAiAygCCEEBa0F4cWpBCGogASgCGCIBIAJBA3RqKAIAIgIgASAFQQN0aigCACACayADKAIgEQUAIAQoAgwhASAAIAQoAgg2AgAgACABNgIEIARBEGokAAuZHwMUfwN+AXwjAEEQayINJAAgAC0ADCEVIA1BBGohDyMAQSBrIg4kAAJAAkACQCAAKAIIBEAgDkEIaiEQIwBBgAFrIgIkAAJAAkACQAJAAkACQAJAAkACQCAAKAIIIgMEQCAAKAIEIANBAnRqQQRrIghFDQQgAkHYAGoiBAJ/QQAgA61CBYYgCCgCAGetfbpEcaN5CU+TCkCjmyIZRAAAAAAAAPC/ZEUNABpBACAZRAAAAAAAAPBBY0UNABogGasLQQBBAUEBEKAYIAIoAlwhAyACKAJYQQFGDQMgAkEANgIkIAIgAigCYDYCICACIAM2AhwgAkEoaiAAEOkdIAIoAjAiCEHAAEkNBiACQeAAaiISQeyOiAEoAgA2AgAgAkHkjogBKQIANwNYIARB8I6IARCdKCACKAJcQZDOADYCACACQUBrIgVBATYCACACIAIpA1g3AzgCfwJAAkACQAJAAkAgAigCMCIEQQRPBEAgBLif/AMiCEUNASAIIAQgCG4gCGpBAXYiA0kNAiADIQAMAwsgBEEARyEIDAMLQdSniAEQ4isACwNAIAMgBCADbiADakEBdiIASSADIQggACEDDQALCyAAIAhPDQADQCAAIghFDQIgCCAEIABuIABqQQF2IgBLDQALCyAIDAELQdSniAEQ4isACyIEIAUoAgAiA0sNAUEBIQgMAgtBAUEBEK02IgBFDQQgEEEBNgIIIBAgADYCBCAQQQE2AgAgAEEAOgAADAYLQQEhCANAIAIoAjwhAAJAAkACQAJAIAMOAgABAgsgAkH4AGpB7I6IASgCADYCACACQeSOiAEpAgA3A3AMAgsgACgCACEAIAJB2ABqIgMgAkE4ahDpHSADIAAQ4w4gAkH4AGogEigCADYCACACIAIpAlg3A3AMAQsgAkHwAGogACADIAAgAxCjEQsgAkE4akEEQQQQ4B4gBSACQfgAaigCACIDNgIAIAIgAikDcDcDOCAIQQF0IQggAyAESQ0ACwsgAkHkAGohFANAAkACQCADIAIoAjAiAEYEQCACKAIsQQRrIQAgA0ECdCEDIAIoAjxBBGshBANAIANFDQIgAyAEaiEFIAAgA2ogA0EEayEDKAIAIgYgBSgCACIFRg0ACyAFIAZPDQEMAgsgACADSw0BCyACQThqQQRBBBDgHiACKAIwIQgMBQsgAkHYAGohBSACQShqIhEhACMAQeAAayIEJAACQAJAAkACQCACQThqIgcoAggiAwRAIAAoAggiBkUNAQJAAkACQAJAIANBAUYEQCAHKAIEIgYoAABBAUYNASAEQdQAaiIDIAAQ6R0gBEEwaiELIAYoAgAhAEEAIQlCACEWIwBBIGsiBiQAAkAgAARAIAMoAgghByADKAIEIQoCQCAAQYCABE8EQCAHDQEMAwsgB0UNAiAKQQRrIQogB0ECdCEHA0AgByAKaiIMIAwoAgAiDEEQdiITIBMgCUEQdHIgAG4iCSAAbGtBEHQgDEH//wNxciIMIABuIhMgCUEQdHI2AgAgDCAAIBNsayEJIAdBBGsiBw0ACwwCCyAKQQRrIQkgB0ECdCEHIACtIRcDQCAHIAlqIgAgADUCACAWQiCGhCIWIBeAIhg+AgAgFiAXIBh+fSEWIAdBBGsiBw0ACyAWpyEJDAELIAZBADYCGCAGQQE2AgwgBkGQo4gBNgIIIAZCBDcCECAGQQhqQZijiAEQ7ywACyAGQRBqIANBCGooAgAiADYCACAGIAMpAgA3AwgCQCAARQ0AIAYoAgwiByAAQQJ0IgNqQQRrIgpFDQAgCigCAA0AIAdBBGshCiAAQf////8DcSEHAkADQCADRQRAQQAhAwwCCyAHQQFrIQcgAyAKaiADQQRrIQMoAgBFDQALIAdBAWoiAyAASw0BCyAGIAM2AhAgAyEACwJAIAAgBigCCEECdk8NACAGIAZBCGogAEEEQQQQ9BQgBigCACIAQYGAgIB4Rg0AIAAgBigCBEH0pIgBEP0vAAsgCyAGKQMINwIAIAtBCGogBkEQaigCADYCACALIAk2AgwgBkEgaiQAIARBCGoiBiAEQThqIgAoAgA2AgAgBCAEKQIwNwMAIAQoAjwhAyAAQbCjiAEoAgA2AgAgBEGoo4gBKQIANwMwIAMEQCALQdSkiAEQnSggBCgCNCADNgIAIARBATYCOAsgBSAEKQMwNwIMIAVBFGogACgCADYCACAFQQhqIAYoAgA2AgAgBSAEKQMANwIADAkLIAMgBkcEfyADIAZJIAMgBktrBSADQQJ0IQYgACgCBEEEayEKIAcoAgRBBGshDANAIAZFDQQgBiAMaiEJIAYgCmogBkEEayEGKAIAIgsgCSgCACIJRg0ACyAJIAtJIAkgC0trC0H/AXEOAgIDAQsgBSAAEOkdIAVBFGpBsKOIASgCADYCACAFQaijiAEpAgA3AgwMBwsgBUEMaiAAEOkdIAVBCGpBsKOIASgCADYCACAFQaijiAEpAgA3AgAMBgtBBEEEEK02IgBFDQMgBUEBNgIIIAUgADYCBCAFQQE2AgAgAEEBNgIAIAVBqKOIASkCADcCDCAFQRRqQbCjiAEoAgA2AgAMBQsgBygCBCIGIANBAnRqQQRrIgtFDQMgCygCACILZyIJRQRAIARBMGoiByAAEOkdIAUgByAGIAMQjwQMBQsgBCAANgI0IARBgICAgHg2AjAgBEHIAGoiCiAEQTBqIgAgC0UiAyAJQR9xIgYQqAUgBCAHNgI0IARBgICAgHg2AjAgBEHUAGoiByAAIAMgBhCoBSAAIAogBCgCWCAEKAJcEI8EIARBGGogBEE4aigCADYCACAEQShqIARBxABqKAIANgIAIAQgBCkCMDcDECAEIAQpAjw3AyAgB0EEQQQQ4B4CQCAEKAIkIgcgBEEgaiILIAQoAiAiCUGAgICAeEYiChsoAggEQCAAIAsgAyAGEJUJDAELIApFBEAgBCAEKAIoNgI4IAQgBzYCNCAEIAk2AjAMAQsgBEEwaiAHEOkdCyAFIAQpAxA3AgAgBSAEKQIwNwIMIAVBCGogBEEYaigCADYCACAFQRRqIARBOGooAgA2AgAMBAsgBEEANgJAIARBATYCNCAEQZCjiAE2AjAgBEIENwI4IARBMGpBxKOIARDvLAALIAVBCGpBsKOIASgCACIANgIAIAVBqKOIASkCACIWNwIAIAUgFjcCDCAFQRRqIAA2AgAMAgtBBEEEEKM9AAtBtKOIARCyOwALIARB4ABqJAAgAkHQAGoiACASKAIANgIAIAIgAikCWDcDSCACQfgAaiILIBRBCGooAgA2AgAgAiAUKQIANwNwIBFBBEEEEOAeIAJBMGogACgCADYCACACIAIpA0g3AyggCARAQQAhBgNAIAIoAnQhBSACKAJwIQdBACEDIAIoAngiBARAIAVBBGshCSAEQQJ0IQADQCAAIAlqIgogCigCACIKQRB2IhEgESADQRB0ckGQzgBuIgNBkM4AbGtBEHQgCkH//wNxciIKQZDOAG4iESADQRB0cjYCACAKIBFBkM4AbGshAyAAQQRrIgANAAsLIAIgBDYCYCACIAc2AlggAiAFNgJcAkAgBEUNACAFIARBAnQiAGpBBGsiCUUNACAJKAIADQAgBUEEayEJIARB/////wNxIQUCQANAIABFBEBBACEADAILIAVBAWshBSAAIAlqIABBBGshACgCAEUNAAsgBUEBaiIAIARLDQELIAIgADYCYCAAIQQLAkAgBCAHQQJ2Tw0AIAJBCGogAkHYAGogBEEEQQQQ9BQgAigCCCIAQYGAgIB4Rg0AIAAgAigCDEGAoogBEP0vAAsgCyASKAIANgIAIAIgAikCWDcDcEEAIQAgAigCJCEFA0AgAyADQQpuIgNBCmxrIQcgACAFaiIEIAIoAhxGBEAgAkEcakHwkIgBEKkZCyAEIAIoAiBqIAc6AAAgAiAEQQFqNgIkIABBAWoiAEEERw0ACyAGQQFqIgYgCEcNAAsLIAJB8ABqQQRBBBDgHiACKAJAIQMMAAsACyADIAIoAmBBgJCIARD9LwALQfChiAEQsjsAC0EBQQEQoz0ACyAIQQJPBEADQEEAIQMgAigCLCEFIAIoAighBiAIQQJ0IgQhAANAIABBBGsiACAFaiIHIAcoAgAiB0EQdiILIAsgA0EQdHJBkM4AbiIDQZDOAGxrQRB0IAdB//8DcXIiB0GQzgBuIgsgA0EQdHI2AgAgByALQZDOAGxrIQMgAA0ACyACIAY2AlggAiAINgJgIAIgBTYCXAJAIAUgCEECdGpBBGsiAEUNACAAKAIADQAgBUEEayEFIAghAAJAA0AgBEUEQEEAIQAMAgsgAEEBayEAIAQgBWogBEEEayEEKAIARQ0ACyAAQQFqIgAgCEsNAQsgAiAANgJgIAAhCAsCQCAIIAZBAnZPDQAgAiACQdgAaiAIQQRBBBD0FCACKAIAIgBBgYCAgHhGDQAgACACKAIEQYCiiAEQ/S8ACyACQfgAaiIEIAJB4ABqKAIANgIAIAIgAikCWDcDcEEAIQAgAigCJCEFA0AgAyADQQpuIgNBCmxrIQYgACAFaiIIIAIoAhxGBEAgAkEcakHQkIgBEKkZCyAIIAIoAiBqIAY6AAAgAiAIQQFqNgIkIABBAWoiAEEERw0ACyACQTBqIAQoAgAiCDYCACACIAIpA3A3AyggCEEBSw0ACwsgCEUNASACKAIsKAIAIgMEQCACKAIkIQADQCADIANBCm4iCEEKbGshBCACKAIcIABGBEAgAkEcakGwkIgBEKkZCyACKAIgIABqIAQ6AAAgAiAAQQFqIgA2AiQgA0EKSSAIIQNFDQALCyAQIAIpAhw3AgAgEEEIaiACQSRqKAIANgIAIAJBKGpBBEEEEOAeCyACQYABaiQADAELQQBBAEGQkIgBEMMhAAsgDigCECIDBEAgDigCDCEAA0AgACAALQAAIghBMHIgCEHXAGogCEEKSRs6AAAgAEEBaiEAIANBAWsiAw0ACwsgDyAOKQIINwIAIA9BCGogDkEQaigCADYCAAwBC0EBQQEQrTYiAEUNASAPQQE2AgggDyAANgIEIA9BATYCACAAQTA6AAALIA5BIGokAAwBC0EBQQEQoz0ACyANKAIMIgNBAk8EQCADQQF2IQggAyANKAIIIgBqQQFrIQMDQCAALQAAIQQgACADLQAAOgAAIAMgBDoAACADQQFrIQMgAEEBaiEAIAhBAWsiCA0ACwsgASAVQQBHQQFBACANKAIIIA0oAgwQgQkgDUEEakEBQQEQ4B4gDUEQaiQAC5IBAQJ/IwBBIGsiBiQAIAZCACABfSABIAJCAFMiBRtCACACIAFCAFKtfH0gAiAFG0IAIAN9IAMgBEIAUyIFG0IAIAQgA0IAUq18fSAEIAUbEKcGIAYpAwghASAAQgAgBikDACIDfSADIAIgBIVCAFMiBRs3AwAgAEIAIAEgA0IAUq18fSABIAUbNwMIIAZBIGokAAusAQECfyMAQTBrIgIkACACIAE2AgAgAkEBNgIUIAJBmOzDADYCECACQgE3AhwgAkHaADYCLCACIAJBKGo2AhggAiACNgIoIAJBBGogAkEQahCZDkEMQQQQrTYiAQRAIAEgAikCBDcCACABQQhqIAJBDGooAgA2AgAgAigCACIDQYQBTwRAIAMQ8h8LIABBvOjDADYCBCAAIAE2AgAgAkEwaiQADwtBBEEMEKM9AAu2AQEBfyMAQRBrIgQkAAJAAkAgASACckEATiADIAGsWnFFBEAgBEEEakETQQBBAUEBEKAYIAQoAgghAiAEKAIEQQFGDQIgBCgCDCIBQQ9qQYOAzgAoAAA2AAAgAUEIakH8/80AKQAANwAAIAFB9P/NACkAADcAACAAQRM2AgwgACABNgIIIAAgAjYCBCAAQQI2AgAMAQsgAEEINgIACyAEQRBqJAAPCyACIAQoAgxBtPXNABD9LwALqwEBA38gACgCiAEhASAAKAKMASIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAJ4QYCAgIB4RwRAIABBMGpBCBDuKCAAQeAAakEEQQwQ4B4gAEH4AGoQ4zwLIAAoApwBIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZwBahDZIQsgACgCkAFBgICAgHhHBEAgAEGQAWpBBEEgEOAeCwulAQEFfyMAQRBrIgIkACACIAAgACgCDBD4GCACKAIIIQMgAigCDCEEIAAoAgQhBSACKAIEIgEgAigCACIARwRAIAEgAGshASAFIABBiAFsaiEAA0AgABCfHyAAQYgBaiEAIAFBAWsiAQ0ACwsgAyAERwRAIAQgA2shASAFIANBiAFsaiEAA0AgABCfHyAAQYgBaiEAIAFBAWsiAQ0ACwsgAkEQaiQAC7EBAQN/IwBBIGsiAiQAIAEoAgghAyABKAIMIQQgAiABKQIANwIYIAJBADYCFCACIAQ2AhAgAiADNgIMIAIgAkEMahDXOyACKAIAIQNBHEEEEK02IgFFBEBBBEEcEKM9AAsgAUKBgICAEDcCACABIAIpAgw3AgggACAENgIIIAAgAzYCBCAAIAE2AgAgAUEQaiACQRRqKQIANwIAIAFBGGogAkEcaigCADYCACACQSBqJAALnQEBBH8gAS0AFCIDQRFHBEAjAEEQayECAkACQAJAIANBBGsOBQECAAABAgsgAS0AFSEEIAEtABYhBQwBCyACQQhqIAFBH2otAAA6AAAgAiABKQAXNwMAIAEtABYhBSABLQAVIQQLIAAgBToAAiAAIAQ6AAEgACADOgAAIAAgAikDADcAAyAAQQtqIAJBCGotAAA6AAAPCyAAQRE6AAALtwEBA38jAEEQayICJAACQAJAAkAgAUEEaiIDQfz1zwAQiDsiBA0AIANBgPbPABCIOw0AIAJBBGpBJEEAQQFBARCgGCACKAIIIQEgAigCBEEBRg0BIAIoAgwiA0GE9s8AQST8CgAAIABBJDYCDCAAIAM2AgggACABNgIEIABBADYCAAwCCyAAIAQ6AAggAEEINgIAIAAgASgAADYCBAwBCyABIAIoAgxBsOjPABD9LwALIAJBEGokAAu2AQEBfyMAQRBrIgQkACAEQQhqIAEgAiADEOESAkACQCAELQAIIgFBBEcEQAJ/AkACQAJAIAFBAWsOAwABAgULIAQtAAkMAgsgBCgCDC0ACAwBCyAEKAIMLQAIC0H/AXFBI0cNASAAQQQ6AAAgAEEANgIEIARBCGoQuS4MAgsgBCgCDCIBRQRAIABCgcoANwIADAILIABBBDoAACAAIAE2AgQMAQsgACAEKQMINwIACyAEQRBqJAALrAEBAn8jAEEQayIDJAAgASABQRBrIgQgAigCACICKAIAKAIAEQIAQQBIBEAgA0EIaiABQQhqKQAANwMAIAMgASkAADcDAANAAkAgBCIBQRBqIAEpAAA3AAAgAUEYaiABQQhqKQAANwAAIAAgAUYNACADIAFBEGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMpAwA3AAAgAUEIaiADQQhqKQMANwAACyADQRBqJAALtAEBAn8jAEEwayIDJAAgAyACNgIMIAMgATYCCAJAAkAgAUUNACAAKAIEIgRBnAtHBEAgACgCCCABQQRrKAAAIAQRAAAMAQsgAkUNASADIAI2AhAgA0EQaiABEOkkCyADQTBqJAAPCyADQgE3AhwgA0EBNgIUIANB0PX8ADYCECADQZ4LNgIsIAMgA0EoajYCGCADIANBCGo2AihBASADQQxqQbj1/AAgA0EQakHY9fwAEK8rAAu0AQECfyMAQTBrIgMkACADIAI2AgwgAyABNgIIAkACQCABRQ0AIAAoAgQiBEGcC0cEQCAAKAIIIAFBBGsoAAAgBBEAAAwBCyACRQ0BIAMgAjYCECADQRBqIAEQ6SQLIANBMGokAA8LIANCATcCHCADQQE2AhQgA0HQ9fwANgIQIANBoAs2AiwgAyADQShqNgIYIAMgA0EIajYCKEEBIANBDGpBuPX8ACADQRBqQdj1/AAQrysAC6oBAQZ/IAEoAgQhAyABKAIAIQYCQCAAKAIAIgQgACgCBCICRwRAIAAoAgwhBSAAKAIIIQcgASgCCCADQQR0aiEAIAIgBGtBAnYhAQNAIAQoAgAiAiAFTw0CIAAgByACQQR0aiICKQMANwMAIAAgAikDCDcDCCAEQQRqIQQgAEEQaiEAIANBAWohAyABQQFrIgENAAsLIAYgAzYCAA8LIAIgBUH0toIBEMMhAAuqAQEGfyABKAIEIQMgASgCACEGAkAgACgCACIEIAAoAgQiAkcEQCAAKAIMIQUgACgCCCEHIAEoAgggA0EEdGohACACIARrQQN2IQEDQCAFIAQoAgAiAk0NAiAAIAcgAkEEdGoiAikDADcDACAAIAIpAwg3AwggBEEIaiEEIABBEGohACADQQFqIQMgAUEBayIBDQALCyAGIAM2AgAPCyACIAVB9LaCARDDIQALqgEBBn8gASgCBCEDIAEoAgAhBgJAIAAoAgAiBCAAKAIEIgJHBEAgACgCDCEFIAAoAgghByABKAIIIANBBHRqIQAgAiAEa0ECdiEBA0AgBCgCACICIAVPDQIgACAHIAJBBHRqIgIpAwA3AwAgACACKQMINwMIIARBBGohBCAAQRBqIQAgA0EBaiEDIAFBAWsiAQ0ACwsgBiADNgIADwsgAiAFQby0ggEQwyEAC5sBAQN/IAAoAhAgAWohAyAAKAIEIQRBACEBIAAoAghBAXYiACECAkACQAJAIAAOAgIBAAsDQCABIABBAXYiAiABaiIBIAQgAUEBdGouAQAgA8FKGyEBIAAgAmsiAEEBSw0ACwsgBCABQQF0ai8BACIAIANB//8DcUYEQCABIQBBASECDAELIAEgAMEgA8FIaiEAQQAhAgsgACACagu1AQEDfyMAQSBrIgIkACABKAIEIQMgASgCCCEEIAIgASgCADYCHCACQoCAgIAQNwIUIAIgBDYCECACIAM2AgwgAiACQQxqENc7IAIoAgAhA0EcQQQQrTYiAUUEQEEEQRwQoz0ACyABQoGAgIAQNwIAIAEgAikCDDcCCCAAIAQ2AgggACADNgIEIAAgATYCACABQRBqIAJBFGopAgA3AgAgAUEYaiACQRxqKAIANgIAIAJBIGokAAulAQEDfyMAQRBrIgIkACAAQRhqENQeIAAoAggiAwR/IAAoAgQhASADQQxsIQMDQCABENQeIAFBDGohASADQQxrIgMNAAsgACgCCAVBAAshAQJAIAEgACgCAEkEQCACQQhqIAAgAUEEQQwQ9BQgAigCCCIBQYGAgIB4Rw0BCyAAKAIkBEAgAEEkahDUHgsgAkEQaiQADwsgASACKAIMQfzMhQEQ/S8AC6sBAQN/IwBBEGsiAiQAIABBGGoQ1B4gACgCJARAIABBJGoQ1B4LIAAoAghBA3QhAyAAKAIEIQEDQAJAIAMEQCABKAIARQ0BIAEQ+SMMAQsCQCAAKAIIIgEgACgCAE8NACACQQhqIAAgAUEEQQgQ9BQgAigCCCIAQYGAgIB4Rg0AIAAgAigCDEHUiIYBEP0vAAsgAkEQaiQADwsgAUEIaiEBIANBCGshAwwACwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBAXQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQF0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBBXQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQV0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBA3QiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQN0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBAnQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQJ0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALpgEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQUgASgCDCIAIARBBHQiAmoiBCABKAIEIgZLBEAgASAGQQF0IgAgBBDdKiIEIAAgBEsbEOgZIAEoAgwhAAsgAgRAIAEoAgggAGogBSADQQR0aiAC/AoAAAsgASABKAIMIAJqNgIMDwsgAyACQfSahwEQsTsACyACIAVB9JqHARCwOwALmgICA38CfiMAQfADayIEJAAgBEEIaiIFIAAQlRogBCABIAIQ+iggBEGgAWoiACAEKAIAIAQoAgQQjzUgA0EJSQRAIARBrAFqIgIgABCkKCAEQbgBaiIAIAVBmAH8CgAAIARB2AJqIwBBQGoiASQAIAEgAEFAayACEK8QAn8gASgCCCICQYCAgIB4RwRAIAEoAhQgASkDACABKQIMIQggAUGChIzIADYCOCABQQg2AjAgAUEANgIoIAFCADcDECABIAg3AgQgASACNgIAIAEQ2RMMAQsgASgCAAtBMGsgAxCUJCAAQZgB/AoAACABQUBrJAAgBEEANgLQAiAEQdACahDRKUEIaiAEQfADaiQADwtB5ILDAEEZEJc9AAuaAgIDfwJ+IwBB8ANrIgQkACAEQQhqIgUgABCVGiAEIAEgAhD6KCAEQaABaiIAIAQoAgAgBCgCBBCPNSADQQNJBEAgBEGsAWoiAiAAEKQoIARBuAFqIgAgBUGYAfwKAAAgBEHYAmojAEFAaiIBJAAgASAAQUBrIAIQrxACfyABKAIIIgJBgICAgHhHBEAgASgCFCABKQMAIAEpAgwhCCABQYKEjMgANgI4IAFBCDYCMCABQQA2AiggAUIANwMQIAEgCDcCBCABIAI2AgAgARDZEwwBCyABKAIAC0EGayADOgAAIABBmAH8CgAAIAFBQGskACAEQQA2AtACIARB0AJqENEpQQhqIARB8ANqJAAPC0HkgsMAQRkQlz0AC6YBAQR/IwBBEGsiAiQAIAJBADYCDCACIAE2AggCQCABKAIIBEAgAUEQaiEEA0AgAUEBOgAMIAIgAkEIahD+KSAEIAIoAgAiBSAFIAIoAgQiA2oQwCYgAUEAOgAMIANFBEAgAEKCgICAwPCwCDcCAAwDCyACIAIoAgwgA2oiAzYCDCADIAIoAggoAghJDQALCyAAQQQ6AAALIAJBCGoQxCMgAkEQaiQAC6QBAQV/IAAoAgQhAyAAKAIAIQEgACgCFCECAkACQCAAKAIQIgQgACgCDEkEQCAAKAIIIARBA3RqIgUoAgAgAkYNASABIANHDQIDQAwACwALIAEgA0cNAUGAgMQADwsgACACQQFqNgIUIAAgBEEBajYCECAFKAIEDwsgACACQQFqNgIUIAAgAUEBajYCACABLQAAIgBBwQBrQf8BcUEaSUEFdCAAcgusAQICfwN+IAEoAgQiBK0hBgJAAkAgBEL/////DyABKQMIIgcgB0L/////D1obp2siBUEAIAQgBU8bIANPBEAgASgCACAHIAYgBiAHVhunaiEEAkAgA0EBRwRAIANFDQEgAiAEIAP8CgAADAELIAIgBC0AADoAAAsgAEEEOgAADAELIABBuLjMACkDACIINwIAIAhC/wGDQgRSDQELIAcgA618IQYLIAEgBjcDCAuYAQEHfyABQQRPBEAgAUECdiEJA0AgACAFaiEKIAciBEEBaiEHQQAhBgJAAkADQCAFIAZqIgggAU8NASADIARLBEAgAiAEaiAGIApqLQAAOgAAIAQgCWohBCAGQQFqIgghBiAIQQRGDQMMAQsLIAQgA0GU6s4AEMMhAAsgCCABQYTqzgAQwyEACyAFQQRqIQUgByAJRw0ACwsLmAEBB38gAUEITwRAIAFBA3YhCQNAIAAgBWohCiAHIgRBAWohB0EAIQYCQAJAA0AgBSAGaiIIIAFPDQEgAyAESwRAIAIgBGogBiAKai0AADoAACAEIAlqIQQgBkEBaiIIIQYgCEEIRg0DDAELCyAEIANBlOrOABDDIQALIAggAUGE6s4AEMMhAAsgBUEIaiEFIAcgCUcNAAsLC5kBAQJ/IwBBQGoiBCQAIARBBGogARDSBiAEQRBqIgUgAUEMaiACIAMQhxggASgCPCICIAIoAgAiA0EBajYCACADQQBOBEAgACAEKQIENwIAIABBCGogBEEMaigCADYCACABKAJAIQMgAS0ARCEBIABBDGogBUEw/AoAACAAIAE6AEQgACADNgJAIAAgAjYCPCAEQUBrJAAPCwALmQEBAn8jAEFAaiIEJAAgBEEEaiABENIGIARBEGoiBSABQQxqIAIgAxCGGCABKAI8IgIgAigCACIDQQFqNgIAIANBAE4EQCAAIAQpAgQ3AgAgAEEIaiAEQQxqKAIANgIAIAEoAkAhAyABLQBEIQEgAEEMaiAFQTD8CgAAIAAgAToARCAAIAM2AkAgACACNgI8IARBQGskAA8LAAuZAQECfyMAQUBqIgQkACAEQQRqIAEQ0gYgBEEQaiIFIAFBDGogAiADEIkYIAEoAjwiAiACKAIAIgNBAWo2AgAgA0EATgRAIAAgBCkCBDcCACAAQQhqIARBDGooAgA2AgAgASgCQCEDIAEtAEQhASAAQQxqIAVBMPwKAAAgACABOgBEIAAgAzYCQCAAIAI2AjwgBEFAayQADwsAC5kBAQJ/IwBBQGoiBCQAIARBBGogARDSBiAEQRBqIgUgAUEMaiACIAMQiBggASgCPCICIAIoAgAiA0EBajYCACADQQBOBEAgACAEKQIENwIAIABBCGogBEEMaigCADYCACABKAJAIQMgAS0ARCEBIABBDGogBUEw/AoAACAAIAE6AEQgACADNgJAIAAgAjYCPCAEQUBrJAAPCwALtwEBAn8jAEFAaiIDJAAgAyACNgIIIAEoAiBBBHYiBCACTQRAIAMgBDYCJCADQQM2AhAgA0HEyoUBNgIMIANCAzcCGCADQTs2AjwgA0HHAjYCNCADQfjJhQE2AjAgA0E7NgIsIAMgA0EoajYCFCADIANBJGo2AjggAyADQQhqNgIoIANBDGpB3MqFARDvLAALIAMgASACEKwfIAMoAgQhASAAIAMoAgA2AgAgACABNgIEIANBQGskAAu3AQECfyMAQUBqIgMkACADIAI2AgggASgCIEEEdiIEIAJNBEAgAyAENgIkIANBAzYCECADQcTKhQE2AgwgA0IDNwIYIANBOzYCPCADQccCNgI0IANB9MqFATYCMCADQTs2AiwgAyADQShqNgIUIAMgA0EkajYCOCADIANBCGo2AiggA0EMakHcyoUBEO8sAAsgAyABIAIQrB8gAygCBCEBIAAgAygCADYCACAAIAE2AgQgA0FAayQAC5QBAQJ/IABBAE4EfyAABSABQS06AAAgAUEBaiEBQQAgAGsLIgJB4wBMBEAgAkEJTARAIAEgAkEwajoAACAAQR92QQFqDwsgASACQQF0QYjQiAFqLwAAOwAAIABBH3ZBAnIPCyABIAJB5ABuIgNBMGo6AAAgASACIANB5ABsa0EBdEGI0IgBai8AADsAASAAQR92QQNqC5gBAQR/IwBBIGsiAiQAAkBBCCAAKAIAIgVBAXQiBCAEQQhNGyIEQQBOBH8gAiAFBH8gAiAFNgIcIAIgACgCBDYCFEEBBSADCzYCGCACQQhqIAQgAkEUahCiGyACKAIIQQFHDQEgAigCECEDIAIoAgwFIAMLIAMgARD9LwALIAIoAgwhASAAIAQ2AgAgACABNgIEIAJBIGokAAuQAQEFfwJAIAEoAgAiBCABKAIEIgJGDQAgBC0AACIDQcEAa0FfcUEKaiADQTBrIANBOUsbIgZBD0sNACACIARBAWoiAkYNACACLQAAIgJBwQBrQV9xQQpqIAJBMGsgAkE5SxsiAkEPSw0AIAEgBEECajYCACAGQQR0IAJyIQNBASEFCyAAIAM6AAEgACAFOgAAC6IBAgJ/An4jAEEgayIDJAACQCABKQMYIgVQBEBBACECDAELIAEgAkIgIAUgBUIgWhunIgIgASgCCCIEIAIgBEkbIgIQlxogASkDGCIFIAKtIgZUBEAgA0EANgIYIANBATYCDCADQbjyzQA2AgggA0IENwIQIANBCGpBwPLNABDvLAALIAEgBSAGfTcDGAsgAEEEOgAAIAAgAjYCBCADQSBqJAALrQIBBn8jAEEwayIFJAAjAEEgayIEJAAgBEEUaiACIANBBHRqIgYgAmtBBHZBAEEEQQQQoBggBCgCGCEHIAQoAhRBAUYEQCAHIAQoAhxBoIPOABD9LwALIAVBDGohCCAEQRBqIglBADYCACAEIAQoAhw2AgwgBCAHNgIIIARBCGogBiACa0EEdhDuLSACIAZHBEBBjOrQABCyOwALIAhBCGogCSgCADYCACAIIAQpAgg3AgAgBEEgaiQAIAVBGGogASAFKAIQIAUoAhQQzxECQCAFKAIYIgFBCEcEQCAAIAUpAhw3AgQgAEEUaiAFQSxqKAIANgIAIABBDGogBUEkaikCADcCAAwBCyADRQ0AQeSgzgAQsjsACyAAIAE2AgAgBUEMahDpOyAFQTBqJAALlAQBCH8jAEFAaiIDJAACfyABRQRAIANBADYCKCADQoCAgIAgNwIgIANBCGogA0EgakGMh84AEKEhIAMoAgghAiADKAIMDAELIANBOGpCADcDACADQTBqQgA3AwAgA0EoakIANwMAIANCADcDICMAQSBrIgEkACABQRRqIAJBAEECQSAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxBxJ7QABD9LwALIANBFGohCCABQRBqIgpBADYCACABIAEoAhw2AgwgASAENgIIIANBIGohBiABQQhqIgcoAgAgBygCCCIFayACSQRAIAcgBSACQQJBIBDQKCAHKAIIIQULIAcoAgQgBUEFdGohBAJAAkAgAkECTwRAIAJBAWshCQNAIAQgBikBADcBACAEQRhqIAZBGGopAQA3AQAgBEEQaiAGQRBqKQEANwEAIARBCGogBkEIaikBADcBACAEQSBqIQQgCUEBayIJDQALIAIgBWpBAWshBQwBCyACRQ0BCyAEIAYpAQA3AQAgBEEYaiAGQRhqKQEANwEAIARBEGogBkEQaikBADcBACAEQQhqIAZBCGopAQA3AQAgBUEBaiEFCyAHIAU2AgggCEEIaiAKKAIANgIAIAggASkCCDcCACABQSBqJAAgAyAIQcyCzgAQoSEgAygCACECIAMoAgQLIQEgACACNgIAIAAgATYCBCADQUBrJAALqAEBAn8jAEFAaiIDJAAgAiABKAIUIgRNBEAgA0EMaiABKAIQIAJqIAQgAmsQnQlBCCECIAAgAygCDEEBRgR/IAMgAykCEDcDGCADQQE2AiQgA0GA0dAANgIgIANCATcCLCADQbADNgI8IAMgA0E4ajYCKCADIANBGGo2AjggAEEEaiADQSBqEJkOQQAFIAILNgIAIANBQGskAA8LIAIgBEHYytAAEK87AAutAQEBfyMAQSBrIgUkAAJAIANBEWwgBEH/AXFqQQh0QYACaiIDIAJNBEAgAiADa0H/AU0NASAAQYACNgIEIAAgASADQQF0ajYCACAFQSBqJAAPCyAFQQA2AhggBUEBNgIMIAVBgPDRADYCCCAFQgQ3AhAgBUEIakHI8NEAEO8sAAsgBUEANgIYIAVBATYCDCAFQYDw0QA2AgggBUIENwIQIAVBCGpB2PDRABDvLAALnwEBAX8CQCAGIANBA3YiB0sEQCAEIAM2AgAgBSAHaiIHIActAABBfyADQQdxdEF/c3E6AAAgAkEBIAQgBSAGEOgjIAUgBiAEKAIAQQdqIgNBA3YgACABIAIQiR8gBCADQXhxIAJBA3RqIgA2AgAgAEEDdiIAIAZJDQEgACAGQcSV8wAQwyEACyAHIAZBtJXzABDDIQALIAAgBWpBADoAAAu3AQEDfyAAIAAoArgPIgFBBnQiAjYC9A8gAUEFdiEDAkACQCABQf8BTQRAIAAgACADQQJ0aigCwA0gAXZBAXE2AoAQIAIgACgC/A4iA08NASAAIAAoAvgOIAJqLQAAOgCEESABIAAoAoQPIgJPDQIgACAAKAKADyABai0AAEEDcUEJdEHEq/sAajYC6BAPCyADQQhBtKXzABDDIQALIAIgA0HEpfMAEMMhAAsgASACQdSl8wAQwyEAC7sBAQF/IwBBMGsiBSQAIAACfyABKAIAIAIQhyVFBEAgASACEM4aIQEgBUGEETYCKCAFIAE7AS4gBUEBNgIQIAVBtJP/ADYCDCAFQgE3AhggBSAFQS5qNgIkIAUgBUEkajYCFEGTgICAeEGUgICAeCADIAVBDGogBCgCFBECABsMAQtBlICAgHggASgCCCICRQ0AGkGTgICAeEGUgICAeCADIAEoAgQgAiAEKAIMEQYAGws2AgAgBUEwaiQAC6kBAQJ/IwBBEGsiBCQAAkAgASgCHEEDdiIDIAJLBEAgAiABKAIoQQN2IgNJDQEgAiADQYSVhgEQwyEACyACIANB9JSGARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAJBA3QiAiABKAIYaigCACABKAIkIAJqKAIAIAMoAiARBQAgBCgCDCEBIAAgBCgCCDYCACAAIAE2AgQgBEEQaiQAC6kBAQJ/IwBBEGsiBCQAAkAgASgCHEECdiIDIAJLBEAgAiABKAIoQQJ2IgNJDQEgAiADQYSVhgEQwyEACyACIANB9JSGARDDIQALIARBCGogASgCDCABKAIQIgMoAghBAWtBeHFqQQhqIAJBAnQiAiABKAIYaigCACABKAIkIAJqKAIAIAMoAiARBQAgBCgCDCEBIAAgBCgCCDYCACAAIAE2AgQgBEEQaiQAC6kBAQV/AkBBBEEEEK02IgEEQCABQeithgE2AgBBCEEEEK02IgBFDQEgAEGIrIYBNgIEIAAgATYCAEHQ74oBQdDvigEoAgAiASAAIAEbNgIAIAFFBEAgAA8LIAAoAgAhAyAAKAIEIgQoAgAiAgRAIAMgAhEDAAsgBCgCBCICBEAgAyACIAQoAggQ+DoLIABBCEEEEPg6IAEPC0EEQQQQoz0AC0EEQQgQoz0AC58BAQV/IwBBIGsiAiQAIAEoAgAhBSABKAIEIQMgAiABKAIIIgE2AgwgAiABQQJ0IgEgAkEMahC/ISACKAIAIQQgAigCBCEGIAEEQCAEQQhqIAMgAfwKAAALIAJBADYCGCACIAM2AhAgAiAFNgIMIAIgAkEfajYCFCACQQxqIgEQxicgAUEEQQQQ4B4gACAGNgIEIAAgBDYCACACQSBqJAALowECA38BfgJAIAEoAgwiA0EDdCACTwRAIAJBA3YgAkEHcSIFQQBHaiIEIAMgAyAESxshAyABKAIIIQQgASkCACEGIAUEQCADRQ0CIAMgBGpBAWsiAUUNAiABIAEtAABBfyAFdEF/c3E6AAALIAAgAjYCECAAIAM2AgwgACAENgIIIAAgBjcCAA8LQdSCiAFBKUGAg4gBEJ8pAAtBkIOIARCyOwALhQYBBn8jAEGwAWsiAyQAIANBADYCpAEgA0EANgKcASADQQA2AqwBIANBDGogA0GcAWogASACELwaAkAgAygCDCIBQQJGBEAgAy0AECEBIwBBEGsiAiQAIAFBCkYEf0EABUEBQQEQrTYiBUUEQEEBQQEQoz0ACyAFIAE6AAAgAkEIaiIBQfzkwwA2AgQgASAFNgIAIAIoAgwhBSACKAIICyEGQdQAQQQQrTYiAUUEQEEEQdQAEKM9AAsgASAFNgJQIAEgBjYCTCABIAM7AUogAUEAOwFIIAFBAjYCACACQRBqJAAgAEECNgIAIAAgATYCBAwBCyADKAIQIQIgA0HcAGogA0EUakHAAPwKAAAgAyACNgJYIAMgATYCVCMAQdAAayIFJAAgA0HUAGoiASgCGCECIAEoAhQhBgJAAkACQCABKAIgIgRFDQAgAiAETQRAIAIgBEYNAQwCCyAEIAZqLAAAQb9/TA0BCwJAAkAgBiAEQdztwwBBBBDBLkUNACAFIAEQthEgBSgCACAFKAIEQeDtwwBBBBCtO0UNAAJAAkAgAkEFTQRAIAJBBUYNAQwCCyAGLAAFQb9/TA0BCyAFQQhqIgQgBkEFaiACQQVrELgZIAUoAggCQCAEKAIAQQJHBEAgBEEQahDeOwwBCwJAIAQoAgQiAigCTCIGRQ0AIAIoAlAiBCgCACIHBEAgBiAHEQMACyAEKAIEIgdFDQAgBiAHIAQoAggQ+DoLIAIoAgBBAkcEQCACQRBqEN47CyACQdQAQQQQ+DoLQQJGDQEgACABQcgA/AoAAAwCCyAGIAJBBSACQeTtwwAQozYACyABLQA0RQRAQdQAQQQQrTYiAkUEQEEEQdQAEKM9AAsgAkG45cMANgJQIAJBATYCTCACIAE7AUogAkEAOwFIIAJBAjYCACACEPkuIAIgAUHIAPwKAAAgAEECNgIAIAAgAjYCBAwBCyAAIAFByAD8CgAACyAFQdAAaiQADAELIAYgAkEAIARBzO3DABCjNgALCyADQbABaiQAC5MBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0EEdCIFaiAAIANBHGwiBmogAyAEELkZIQAgASABIAVqIAEgBmogAyAEELkZIQEgAiACIAVqIAIgBmogAyAEELkZIQILIAAgAiABIAAoAgBBGHYiACABKAIAQRh2IgFJIgMgASACKAIAQRh2IgJJcxsgAyAAIAJJcxsLtQEBAX8jAEEQayIDJAACQAJAIAEpAwBCBlEEQCADQQRqQQ5BAEEBQQEQoBggAygCCCEBIAMoAgRBAUYNAiADKAIMIgJBBmpBrozNACkAADcAACACQaiMzQApAAA3AAAgAEEONgIMIAAgAjYCCCAAIAE2AgQgAEEANgIADAELIAAgASACIAFB0ABqQQAgASgCUEGAgICAeEcbEPgUCyADQRBqJAAPCyABIAMoAgxB1P3MABD9LwALpAEBAn8jAEEQayIEJAACQAJAIAMEQCABQRhqIQEgAiADQQR0aiEDA0AgAigCAEUNAiAEIAJBCGoiBSgCADYCDCABIARBDGpBBBChNiACKAIARQ0DIAEgAkEEaigCACAFKAIAEKE2IAJBEGoiAiADRw0ACwsgAEEINgIAIARBEGokAA8LQayHzgBBJUHUh84AEJ8pAAtB5IfOAEEgQYSIzgAQyyQAC50BAQh/IAAoAhwiBSACIAAoAgQiCGsiBiAFIAZLGyEJQX8gASgCBHRBf3MhCiAAKAJkIQsgASgCCCEBIAAoAlwhBwNAIAUgCUcEQCALIAUgCnFBAnRqIAcgBSAIaiABIAMQox1BAnRqIgwoAgA2AgAgDCAFNgIAIAVBAWohBSAERQ0BCwsgACAGNgIcIAcgAiABIAMQox1BAnRqKAIAC6QBAAJAAkACQCACAn8gAEEBRgRAQQAhAkEEDAELIABFDQEgAEGBgIAITw0CQQFBICAAQQFrIgJnayACQQJJGyIAQRlPDQNBBCAAQQNqQQJ2IABBEEkbCyIAQQJ0NgIAIAMgAEEEazYCACABIAKtNwMADwtBvOfRAEEcQdjn0QAQnykAC0Ho59EAQSVBkOjRABCfKQALQaDo0QBBGkG86NEAEJ8pAAv3DgISfwJ+IwBB8ABrIgckACAHQZOAgIB4NgIEIAdBxABqIgMgAUEo/AoAACAHIAdBBGo2AmwgB0EYaiENIwBBkAJrIgIkACACQShqIgEgA0Es/AoAACACQdABaiIIIAEQuykCQAJAAkACQCACKALUAQRAIAJB1ABqIgMgAigC2AEiDkEDdiAOQQdxQQBHaiIGENIfIAJB5ABqIgQgBhDSHyACQSBqIAQQhj0gAikDICEUIAJBGGogAxCGPSACKQMYIRUgCCABQSz8CgAAIAJBADYCjAIgAiAUNwKEAiACIBU3AvwBIAIoAvgBIQkjAEHgAGsiBSQAIAgoAhwiASAIKAIgIhBHBEACQCAIKAIEIREgAkH8AWoiCigCECELIAVBHGohEgNAAkACQAJAAkACQAJAAkAgEQRAIAEgCCgCFE8NAiAIKAIIIAgoAhAgAWoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAggAUEBaiIMNgIcIAVBEGogCCgCACABENorIAUoAhAhASAFQUBrIAUoAhQiA0EAQQFBARCgGCAFKAJEIQ8gBSgCQEEBRg0CIAUoAkghBCADBEAgBCABIAP8CgAACyADBEAgBCEBIAMhBgNAIAEgAS0AACITQcEAa0H/AXFBGklBBXQgE3I6AAAgAUEBaiEBIAZBAWsiBg0ACwsgBSADNgI0IAUgBDYCMCAFIA82AiwgBUEIaiAEIAMQ9AhBk4CAgHghBkEBIQECQCAFKAIIIgMgBSgCDCIEQfmwgAFBARDBLg0AIAMgBEH6sIABQQIQwS4NACADIARB/LCAAUEDEMEuDQAgAyAEQf+wgAFBBBDBLg0AIAMgBEGDsYABQQEQwS4NACADIARBhLGAAUECEMEuDQAgAyAEQYaxgAFBAxDBLg0AIAMgBEGJsYABQQIQwS4NACADIARBi7GAAUEBEMEuDQBBACEBIAMgBEGMsYABQQEQwS4NACADIARBjbGAAUECEMEuDQAgAyAEQY+xgAFBAxDBLg0AIAMgBEGSsYABQQQQwS4NACADIARBlrGAAUEFEMEuDQAgAyAEQZuxgAFBARDBLg0AIAMgBEGcsYABQQIQwS4NACADIARBnrGAAUECEMEuDQAgAyAEQaCxgAFBAxDBLg0AIAMgBEGjsYABQQEQwS4NACAFIAQ2AjwgBSADNgI4IAgoAiQtADQEQEECIQEMAQsgBUECNgJEIAVB1LGAATYCQCAFQgE3AkwgBUHMATYCXCAFIAVB2ABqNgJIIAUgBUE4ajYCWCASIAVBQGsQrBhBgoCAgHghBiAFLQAcIQELIAVBLGoQ3jsgBkGTgICAeEcEQCAJKAIAQZOAgIB4RwRAIAkQiBELIAkgAToABCAJIAY2AgAgCSAFQR1qIgEpAAA3AAUgCUEMaiABQQdqKQAANwAADAkLIAFB/wFxQQJGDQUgC0EDdiIDIAooAgQiBk8NAyAKKAIAIANqIgZBASALQQdxdCIEIAYtAAByOgAAIAFBAXFFDQUgAyAKKAIMIgFPDQQgCigCCCADaiIBIAEtAAAgBHI6AAAMBQsgCCABQQFqIgE2AhwMBQtB9KeAAUEgQZSogAEQnykACyAPIAUoAkhB4K2AARD9LwALIAMgBkGgp4ABEMMhAAsgAyABQaCngAEQwyEACyAMIQELIAogC0EBaiILNgIQIAEgEEcNAAsLCyAFQeAAaiQAAkAgAigC1AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAkHUAWoQ+x4LIAJBAToAuAEgAigCXCEBIAIoAmAhAyACIAIpAlQ3AtwBIAJBADYC2AEgAiADNgLUASACIAE2AtABIAJBEGogAkHQAWoiBhDXOyACKAIQIQRBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAtABNwIIIAFBEGogAkHYAWopAgA3AgAgAUEYaiACQeABaigCADYCACACIAM2AswBIAIgBDYCyAEgAiABNgLEAUEMQQQQrTYiA0UNAiACKAJsIQEgAigCcCEEIAIgAikCZDcC3AEgAkEANgLYASACIAQ2AtQBIAIgATYC0AEgAkEIaiAGENc7IAIoAgghDEEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAMgBDYCCCADIAw2AgQgAyABNgIAIAJBATYChAIgAiADNgKAAiACQQE2AvwBIAJBADYC2AEgAkKAgICAwAA3AtABIAJB9ABqIgEgAkG4AWogDiACIAJBxAFqIAJB/AFqIAYQjBMgDSABENEQIAJBkAJqJAAMBAtB/LSAAUEWQZS1gAEQyyQAC0EEQRwQoz0AC0EEQQwQoz0AC0EEQRwQoz0ACwJAIAcoAgRBk4CAgHhHBEAgACAHKQIENwIEIABBADYCACAAQRRqIAdBFGooAgA2AgAgAEEMaiAHQQxqKQIANwIAIA0QzSYMAQsgACAHQRhqQSz8CgAACyAHQfAAaiQAC/cOAhJ/An4jAEHwAGsiByQAIAdBk4CAgHg2AgQgB0HEAGoiAyABQSj8CgAAIAcgB0EEajYCbCAHQRhqIQ0jAEGQAmsiAiQAIAJBKGoiASADQSz8CgAAIAJB0AFqIgggARC/KQJAAkACQAJAIAIoAtQBBEAgAkHUAGoiAyACKALYASIOQQN2IA5BB3FBAEdqIgYQ0h8gAkHkAGoiBCAGENIfIAJBIGogBBCGPSACKQMgIRQgAkEYaiADEIY9IAIpAxghFSAIIAFBLPwKAAAgAkEANgKMAiACIBQ3AoQCIAIgFTcC/AEgAigC+AEhCSMAQeAAayIFJAAgCCgCHCIBIAgoAiAiEEcEQAJAIAgoAgQhESACQfwBaiIKKAIQIQsgBUEcaiESA0ACQAJAAkACQAJAAkACQCARBEAgASAIKAIUTw0CIAgoAgggCCgCECABaiIDQQN2ai0AAEH/AXMgA0EHcXZBAXENAQsgCCABQQFqIgw2AhwgBUEQaiAIKAIAIAEQjywgBSgCECEBIAVBQGsgBSgCFCIDQQBBAUEBEKAYIAUoAkQhDyAFKAJAQQFGDQIgBSgCSCEEIAMEQCAEIAEgA/wKAAALIAMEQCAEIQEgAyEGA0AgASABLQAAIhNBwQBrQf8BcUEaSUEFdCATcjoAACABQQFqIQEgBkEBayIGDQALCyAFIAM2AjQgBSAENgIwIAUgDzYCLCAFQQhqIAQgAxD0CEGTgICAeCEGQQEhAQJAIAUoAggiAyAFKAIMIgRB+bCAAUEBEMEuDQAgAyAEQfqwgAFBAhDBLg0AIAMgBEH8sIABQQMQwS4NACADIARB/7CAAUEEEMEuDQAgAyAEQYOxgAFBARDBLg0AIAMgBEGEsYABQQIQwS4NACADIARBhrGAAUEDEMEuDQAgAyAEQYmxgAFBAhDBLg0AIAMgBEGLsYABQQEQwS4NAEEAIQEgAyAEQYyxgAFBARDBLg0AIAMgBEGNsYABQQIQwS4NACADIARBj7GAAUEDEMEuDQAgAyAEQZKxgAFBBBDBLg0AIAMgBEGWsYABQQUQwS4NACADIARBm7GAAUEBEMEuDQAgAyAEQZyxgAFBAhDBLg0AIAMgBEGesYABQQIQwS4NACADIARBoLGAAUEDEMEuDQAgAyAEQaOxgAFBARDBLg0AIAUgBDYCPCAFIAM2AjggCCgCJC0ANARAQQIhAQwBCyAFQQI2AkQgBUHUsYABNgJAIAVCATcCTCAFQcwBNgJcIAUgBUHYAGo2AkggBSAFQThqNgJYIBIgBUFAaxCsGEGCgICAeCEGIAUtABwhAQsgBUEsahDeOyAGQZOAgIB4RwRAIAkoAgBBk4CAgHhHBEAgCRCIEQsgCSABOgAEIAkgBjYCACAJIAVBHWoiASkAADcABSAJQQxqIAFBB2opAAA3AAAMCQsgAUH/AXFBAkYNBSALQQN2IgMgCigCBCIGTw0DIAooAgAgA2oiBkEBIAtBB3F0IgQgBi0AAHI6AAAgAUEBcUUNBSADIAooAgwiAU8NBCAKKAIIIANqIgEgAS0AACAEcjoAAAwFCyAIIAFBAWoiATYCHAwFC0H0p4ABQSBBlKiAARCfKQALIA8gBSgCSEHgrYABEP0vAAsgAyAGQaCngAEQwyEACyADIAFBoKeAARDDIQALIAwhAQsgCiALQQFqIgs2AhAgASAQRw0ACwsLIAVB4ABqJAACQCACKALUASIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACACQdQBahD7HgsgAkEBOgC4ASACKAJcIQEgAigCYCEDIAIgAikCVDcC3AEgAkEANgLYASACIAM2AtQBIAIgATYC0AEgAkEQaiACQdABaiIGENc7IAIoAhAhBEEcQQQQrTYiAUUNASABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAIgAzYCzAEgAiAENgLIASACIAE2AsQBQQxBBBCtNiIDRQ0CIAIoAmwhASACKAJwIQQgAiACKQJkNwLcASACQQA2AtgBIAIgBDYC1AEgAiABNgLQASACQQhqIAYQ1zsgAigCCCEMQRxBBBCtNiIBRQ0DIAFCgYCAgBA3AgAgASACKQLQATcCCCABQRBqIAJB2AFqKQIANwIAIAFBGGogAkHgAWooAgA2AgAgAyAENgIIIAMgDDYCBCADIAE2AgAgAkEBNgKEAiACIAM2AoACIAJBATYC/AEgAkEANgLYASACQoCAgIDAADcC0AEgAkH0AGoiASACQbgBaiAOIAIgAkHEAWogAkH8AWogBhCMEyANIAEQ0RAgAkGQAmokAAwEC0H8tIABQRZBlLWAARDLJAALQQRBHBCjPQALQQRBDBCjPQALQQRBHBCjPQALAkAgBygCBEGTgICAeEcEQCAAIAcpAgQ3AgQgAEEANgIAIABBFGogB0EUaigCADYCACAAQQxqIAdBDGopAgA3AgAgDRDNJgwBCyAAIAdBGGpBLPwKAAALIAdB8ABqJAAL8A4CD38CfiMAQfAAayIIJAAgCEGTgICAeDYCBCAIQcQAaiIDIAFBKPwKAAAgCCAIQQRqNgJsIAhBGGohDCMAQZACayICJAAgAkEoaiIBIANBLPwKAAAgAkHQAWoiByABEKIqAkACQAJAAkAgAigC1AEEQCACQdQAaiIDIAIoAtgBIg1BA3YgDUEHcUEAR2oiBhDSHyACQeQAaiIEIAYQ0h8gAkEgaiAEEIY9IAIpAyAhESACQRhqIAMQhj0gAikDGCESIAcgAUEs/AoAACACQQA2AowCIAIgETcChAIgAiASNwL8ASACQfwBaiEJIAIoAvgBIQojAEHgAGsiBSQAAkACQAJAAkACQCAHKAIcIgEgBygCIEcEQAJAIAkoAhAhCyAFQRxqIQ8DQAJAAkAgBygCBARAIAEgBygCFE8NBiAHKAIIIAcoAhAgAWoiA0EDdmotAABB/wFzIANBB3F2QQFxDQELIAcgAUEBajYCHCAFQRBqIAcgARCtKiAFKAIQIQEgBUFAayAFKAIUIgNBAEEBQQEQoBggBSgCRCEOIAUoAkBBAUYNBiAFKAJIIQQgAwRAIAQgASAD/AoAAAsgAwRAIAQhASADIQYDQCABIAEtAAAiEEHBAGtB/wFxQRpJQQV0IBByOgAAIAFBAWohASAGQQFrIgYNAAsLIAUgAzYCNCAFIAQ2AjAgBSAONgIsIAVBCGogBCADEPQIQZOAgIB4IQZBASEBAkAgBSgCCCIDIAUoAgwiBEH5sIABQQEQwS4NACADIARB+rCAAUECEMEuDQAgAyAEQfywgAFBAxDBLg0AIAMgBEH/sIABQQQQwS4NACADIARBg7GAAUEBEMEuDQAgAyAEQYSxgAFBAhDBLg0AIAMgBEGGsYABQQMQwS4NACADIARBibGAAUECEMEuDQAgAyAEQYuxgAFBARDBLg0AQQAhASADIARBjLGAAUEBEMEuDQAgAyAEQY2xgAFBAhDBLg0AIAMgBEGPsYABQQMQwS4NACADIARBkrGAAUEEEMEuDQAgAyAEQZaxgAFBBRDBLg0AIAMgBEGbsYABQQEQwS4NACADIARBnLGAAUECEMEuDQAgAyAEQZ6xgAFBAhDBLg0AIAMgBEGgsYABQQMQwS4NACADIARBo7GAAUEBEMEuDQAgBSAENgI8IAUgAzYCOCAHKAIkLQA0BEBBAiEBDAELIAVBAjYCRCAFQdSxgAE2AkAgBUIBNwJMIAVBzAE2AlwgBSAFQdgAajYCSCAFIAVBOGo2AlggDyAFQUBrEKwYQYKAgIB4IQYgBS0AHCEBCyAFQSxqEN47IAZBk4CAgHhHBEAgCigCAEGTgICAeEcEQCAKEIgRCyAKIAE6AAQgCiAGNgIAIAogBUEdaiIBKQAANwAFIApBDGogAUEHaikAADcAAAwECyABQf8BcUECRg0BIAtBA3YiAyAJKAIEIgZPDQcgCSgCACADaiIGQQEgC0EHcXQiBCAGLQAAcjoAACABQQFxRQ0BIAMgCSgCDCIBTw0IIAkoAgggA2oiASABLQAAIARyOgAADAELIAcgAUEBajYCHAsgCSALQQFqIgs2AhAgBygCHCIBIAcoAiBHDQALCwsgBUHgAGokAAwEC0H0p4ABQSBBlKiAARCfKQALIA4gBSgCSEHgrYABEP0vAAsgAyAGQaCngAEQwyEACyADIAFBoKeAARDDIQALAkAgAigC1AEiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAkHUAWoQ+x4LIAJBAToAuAEgAigCXCEBIAIoAmAhAyACIAIpAlQ3AtwBIAJBADYC2AEgAiADNgLUASACIAE2AtABIAJBEGogAkHQAWoiBhDXOyACKAIQIQRBHEEEEK02IgFFDQEgAUKBgICAEDcCACABIAIpAtABNwIIIAFBEGogAkHYAWopAgA3AgAgAUEYaiACQeABaigCADYCACACIAM2AswBIAIgBDYCyAEgAiABNgLEAUEMQQQQrTYiA0UNAiACKAJsIQEgAigCcCEEIAIgAikCZDcC3AEgAkEANgLYASACIAQ2AtQBIAIgATYC0AEgAkEIaiAGENc7IAIoAgghBUEcQQQQrTYiAUUNAyABQoGAgIAQNwIAIAEgAikC0AE3AgggAUEQaiACQdgBaikCADcCACABQRhqIAJB4AFqKAIANgIAIAMgBDYCCCADIAU2AgQgAyABNgIAIAJBATYChAIgAiADNgKAAiACQQE2AvwBIAJBADYC2AEgAkKAgICAwAA3AtABIAJB9ABqIgEgAkG4AWogDSACIAJBxAFqIAJB/AFqIAYQjBMgDCABENEQIAJBkAJqJAAMBAtB/LSAAUEWQZS1gAEQyyQAC0EEQRwQoz0AC0EEQQwQoz0AC0EEQRwQoz0ACwJAIAgoAgRBk4CAgHhHBEAgACAIKQIENwIEIABBADYCACAAQRRqIAhBFGooAgA2AgAgAEEMaiAIQQxqKQIANwIAIAwQzSYMAQsgACAIQRhqQSz8CgAACyAIQfAAaiQAC5UBAQR/IwBBQGoiAiQAIAJBBGogARDSBiACQRBqIgUgAUEMahCAFSABKAI8IgQgBCgCACIDQQFqNgIAIANBAE4EQCAAIAIpAgQ3AgAgAEEIaiACQQxqKAIANgIAIAEoAkAhAyABLQBEIQEgAEEMaiAFQTD8CgAAIAAgAToARCAAIAM2AkAgACAENgI8IAJBQGskAA8LAAuhAQECfyABQTxqIQMCQCABKAI8IgRFDQAgBCAEKAIAIgRBAWs2AgAgBEEBRw0AIAMQ+x4LIAFBADYCACADIAIpAgA3AgAgA0EQaiACQRBqKQIANwIAIANBCGogAkEIaikCADcCAAJAIAEoAjAiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgAUEwahD7HgsgAUEANgIwIAAgAUHcAPwKAAALogEBA38jAEEQayICJAAgAkEANgIMIAIgATYCCAJAIAEoAggEQANAIAFBAToADCACIAJBCGoQ/ikgASgCECACKAIAIgQgBCACKAIEIgNqEMAmIAFBADoADCADRQRAIABCgoCAgMDwsAg3AgAMAwsgAiACKAIMIANqIgM2AgwgAyACKAIIKAIISQ0ACwsgAEEEOgAACyACQQhqEMQjIAJBEGokAAudAQEBfyMAQTBrIgIkACACQQA6AAsgAkEgaiABKAIMIAJBC2pBARCbIQJAAkAgAi0AIEEERg0AIAIgAikDIDcDKCACQQxqIAJBKGoQ0AkgAigCDEEERg0AIAAgAikCDDcCACAAQRBqIAJBHGooAgA2AgAgAEEIaiACQRRqKQIANwIADAELIAAgAi0ACzoABCAAQQQ2AgALIAJBMGokAAu2AQEBfyABAn8gAkEHTQRAIAAoAgAgASgCAC0AADoAACAAKAIAIAEoAgAtAAE6AAEgACgCACABKAIALQACOgACIAAoAgAgASgCAC0AAzoAAyABIAEoAgAgAkECdCICQbDG0QBqKAIAaiIDNgIAIAAoAgAgAygAADYABCABKAIAIAJB0MbRAGooAgBrDAELIAAoAgAgASgCACkAADcAACABKAIAC0EIajYCACAAIAAoAgBBCGo2AgALogEBAX8CQAJAIAEEQCAALQAAIgJBwAFPBEAgAkHgAU8EQCABQQJNDQMgACAALQACQQVzOgACQQMhAQwECyABQQFHBEAgACAALQABQSBzOgABQQIPC0EBQQFB1NnzABDDIQALQQEhASACQeEAa0H/AXFBGUsNAiAAIAJB3wBxOgAAQQEPC0EAQQBBtNnzABDDIQALQQIgAUHE2fMAEMMhAAsgAQupAQEDfyAAQoCAgIDQxwA3AvQRIAJFBEBBfw8LIAJBAnQhBCAAQfwRaiEFQX8hA0EAIQIDQAJAIAEvAQBFBEAgAUECakEAOwEADAELIAAgACgC9BFBAWoiAzYC9BEgA0G9BE8EQCADQb0EQdj9+wAQwyEACyAAIANBAnRqIAI2AgAgAiAFakEAOgAAIAIhAwsgAUEEaiEBIAJBAWohAiAEQQRrIgQNAAsgAwuWAQICfwJ+IAAoAhAgAWqtIQQgACgCBCEDQQAhASAAKAIIQQN2IgAhAgJAAkACQCAADgICAQALA0AgASAAQQF2IgIgAWoiASADIAFBA3RqKQMAIARVGyEBIAAgAmsiAEEBSw0ACwtBASECIAQgAyABQQN0aikDACIFUQRAIAEhAAwBCyABIAQgBVVqIQBBACECCyAAIAJqC6ABAQF/IAAQvgwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQ+x4LC7YCAQZ/IwBBIGsiBCQAIAQgARDTBiAEQQxqIQYjAEEgayIFJAACQAJAIAFBDGoiCCgCDEF/IAIgA2oiByACIAdLG08EQCAIKAIAIgcgBygCACIJQQFqNgIAIAlBAEgNASAGIAM2AgwgBiAHNgIAIAYgCCkCBDcCBCAGIAgoAhAgAmo2AhAgBUEgaiQADAILIAVBADYCGCAFQQE2AgwgBUGs9IQBNgIIIAVCBDcCECAFQQhqQbT0hAEQ7ywLAAsgASgCICICIAIoAgAiA0EBajYCACADQQBIBEAACyAAIAQpAgA3AgAgACAEKQIMNwIMIAAgAjYCICAAIAEoAiQ2AiQgAEEIaiAEQQhqKAIANgIAIABBFGogBEEUaikCADcCACAAQRxqIARBHGooAgA2AgAgBEEgaiQAC6ABAQF/IAAQxwwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQ+x4LC7MBAQF/IwBBQGoiAiQAIAAoAgAhACACQaDmhwE2AjggAkGA5ocBNgIwIAIgAEHJAGo2AiwgAkGQ5ocBNgIoIAIgAEEoajYCJCACQYDmhwE2AiAgAiAAQcgAajYCHCACQfDlhwE2AhggAiAAQTBqNgIUIAJB4OWHATYCECACIABBPGo2AgwgAiAAQQhqNgI8IAIgAkE8ajYCNCABQZTnhwFB5OaHASACQQxqEPkSIAJBQGskAAukAQEEfyABKAIUIgQoAmQhAgJAAkAgASgCAEEIaiAERwRAIAIhAyAEIQIMAQsgAkUEQEEBIQQMAgsgASACNgIUIAIoAmQhAwsCQCADDQBBAiEEIAIgASgCEEYEQCABKAIAIgNBADYCbCABKAIQIAEgA0EIaiIDNgIQIAM2AmQgAigCZCIDDQELDAELIAEgAzYCFEEAIQQLIAAgAjYCBCAAIAQ2AgALpAEBBH8gASgCFCIEKAJEIQICQAJAIAEoAgBBCGogBEcEQCACIQMgBCECDAELIAJFBEBBASEEDAILIAEgAjYCFCACKAJEIQMLAkAgAw0AQQIhBCACIAEoAhBGBEAgASgCACIDQQA2AkwgASgCECABIANBCGoiAzYCECADNgJEIAIoAkQiAw0BCwwBCyABIAM2AhRBACEECyAAIAI2AgQgACAENgIAC6kBAQR/IAEoAhQiBCgCzAEhAgJAAkAgASgCAEEIaiAERwRAIAIhAyAEIQIMAQsgAkUEQEEBIQQMAgsgASACNgIUIAIoAswBIQMLAkAgAw0AQQIhBCACIAEoAhBGBEAgASgCACIDQQA2AtQBIAEoAhAgASADQQhqIgM2AhAgAzYCzAEgAigCzAEiAw0BCwwBCyABIAM2AhRBACEECyAAIAI2AgQgACAENgIAC64BAgJ/AX4jAEEgayIDJAAgASgCDCEEIAFBgYCAgHg2AgwCQAJAIARBgYCAgHhHBEAgA0EYaiABQRhqKQIAIgU3AgAgAyAENgIMIAMgASkCEDcCECAFp0EBcUUNAiAAIAFBAUECIAIbIAMvARoQqRQgA0EMahCGMAwBCyACRQRAIAAgAUECEIgaDAELIAAgAUEBEIgaCyADQSBqJAAPC0GchMMAQSFBwITDABDLJAALrgECAn8BfiMAQSBrIgMkACABKAIMIQQgAUGBgICAeDYCDAJAAkAgBEGBgICAeEcEQCADQRhqIAFBGGopAgAiBTcCACADIAQ2AgwgAyABKQIQNwIQIAWnQQFxRQ0CIAAgAUEBQQIgAhsgAy8BGhCqFCADQQxqEIYwDAELIAJFBEAgACABQQIQiRoMAQsgACABQQEQiRoLIANBIGokAA8LQZyEwwBBIUHAhMMAEMskAAufAQECfyMAQTBrIgEkACABQQA2AhwgAUKAgICAEDcCFCABQZCHwwA2AiQgAUKggICADjcCKCABIAFBFGo2AiAgACABQSBqELkJBEBBuIfDAEE3IAFBCGpBqIfDAEHwh8MAENUeAAsgAUEQaiABQRxqKAIAIgI2AgAgASABKQIUNwMIIAEoAgwgAhCUPiABQQhqEN47IAAQySMgAUEwaiQAC58BAQJ/IwBBMGsiASQAIAFBADYCHCABQoCAgIAQNwIUIAFBkIfDADYCJCABQqCAgIAONwIoIAEgAUEUajYCICAAIAFBIGoQrBEEQEG4h8MAQTcgAUEIakGoh8MAQfCHwwAQ1R4ACyABQRBqIAFBHGooAgAiAjYCACABIAEpAhQ3AwggASgCDCACEJQ+IAFBCGoQ3jsgABDQIiABQTBqJAALnwEBAn8jAEEwayIBJAAgAUEANgIcIAFCgICAgBA3AhQgAUGoxcwANgIkIAFCoICAgA43AiggASABQRRqNgIgIAAgAUEgahCfBARAQdDFzABBNyABQQhqQcDFzABBiMbMABDVHgALIAFBEGogAUEcaigCACICNgIAIAEgASkCFDcDCCABKAIMIAIQlD4gAUEIahDeOyAAEIgRIAFBMGokAAuhAQEBfyMAQSBrIgQkAAJAAkAgASkDAEICUgRAIARBCGogASACIAMQvAsgBCgCDCEBIAQoAggiAkEIRg0BIAAgBCkDEDcDCCAAQRBqIARBGGopAwA3AwAgACABNgIEIAAgAjYCAAwCCyABQQhqIAIgAyABLQAoEKYIIQEgAEEINgIAIAAgATYCBAwBCyAAQQg2AgAgACABNgIECyAEQSBqJAALtwEBAX8jAEEQayICJAACfwJAAkACQAJAIAAtAABBAWsOAwECAwALIAIgAEEBajYCBCABQfifzwBBCyAAQQRqQdifzwAgAkEEakHon88AEIMPDAMLIAIgAEEEajYCCCABQZSgzwBBDSACQQhqQYSgzwAQ0BMMAgsgAiAAQQFqNgIMIAFBoaDPAEERIABBBGpB2J/PACACQQxqQeifzwAQgw8MAQsgAUGyoM8AQQ4Q+zULIAJBEGokAAuhAQEDfyMAQRBrIgMkACABp0EBcQRAIANBADYCDCADQoCAgICAATcCBCAAQSxqIQQCQAJAIAAoAixBgICAgHhGBEAgBBCFMCAAQQA2AjQgAEKAgICAgAE3AiwMAQsgA0EEahDjPCAAKAI0IgUgACgCLEcNAQsgBEHo+88AELMoCyAAKAIwIAVBA3RqIAI3AwAgACAFQQFqNgI0CyADQRBqJAALmwECAX4BfyABKQAAIQMgAEEIaiABQQhqKQAANwAAIAAgAzcAACACQRFOBEAgACACaiECIAFBIGohASAAQRBqIQADQCABQRBrIgQpAAAhAyAAQQhqIARBCGopAAA3AAAgACADNwAAIAEpAAAhAyAAQRhqIAFBCGopAAA3AAAgAEEQaiADNwAAIAFBIGohASAAQSBqIgAgAkkNAAsLC6MBAQR/IAFBAmoiAiAAKAIYIgNJBEAgACAAKAIUIAJqLQAAIAAoAoQBQQV0QeD/AXFzIgI2AoQBAkAgACgCMCACQQF0aiIELwEAIgIgAUH//wNxRwRAIAAoAiBBAWsgAXEiAyAAKAIsIgVPDQEgACgCKCADQQF0aiACOwEAIAQgATsBAAsgAg8LIAMgBUHU3/wAEMMhAAsgAiADQcTf/AAQwyEAC5cBAgN/An5BASECIAEoAhgoAgBBk4CAgHhGBEAjAEEQayEDQQAhAgJ/IAEpAwAiBSABKQMIIgZTBEAgA0EMaiAFQgBVIAYgBX0iBSAGU3MgBUL/////D1ZyDQEaIAWnIQILIANBATYCDCADQQhqCyACNgIAIAMoAgghBCADKAIMIQILIAAgBDYCCCAAIAI2AgQgAEEANgIAC54BAQZ/IAEoAgQhAiABKAIAIQYCQCAAKAIAIgMgACgCBCIERwRAIAAoAgwhBSAAKAIIIQcgASgCCCACQQJ0aiEAIAQgA2tBAnYhAQNAIAMoAgAiBCAFTw0CIAAgByAEQQJ0aigCADYCACADQQRqIQMgAEEEaiEAIAJBAWohAiABQQFrIgENAAsLIAYgAjYCAA8LIAQgBUG8tIIBEMMhAAueAQEGfyABKAIEIQIgASgCACEGAkAgACgCACIDIAAoAgQiBEcEQCAAKAIMIQUgACgCCCEHIAEoAgggAkECdGohACAEIANrQQN2IQEDQCAFIAMoAgAiBE0NAiAAIAcgBEECdGooAgA2AgAgA0EIaiEDIABBBGohACACQQFqIQIgAUEBayIBDQALCyAGIAI2AgAPCyAEIAVB9LaCARDDIQALngEBBn8gASgCBCECIAEoAgAhBgJAIAAoAgAiAyAAKAIEIgRHBEAgACgCDCEFIAAoAgghByABKAIIIAJBAnRqIQAgBCADa0ECdiEBA0AgAygCACIEIAVPDQIgACAHIARBAnRqKAIANgIAIANBBGohAyAAQQRqIQAgAkEBaiECIAFBAWsiAQ0ACwsgBiACNgIADwsgBCAFQfS2ggEQwyEAC5cBAQZ/IAIoAgQhAyACKAIAIQYCQCAAIAFHBEAgAigCCCADQQxsaiEHIAEgAGtBDG4hAUEAIQIDQCAAIAJqIggoAgAiBSAFKAIAIgRBAWo2AgAgBEEASA0CIAIgB2oiBCAFNgIAIARBBGogCEEEaikCADcCACACQQxqIQIgA0EBaiEDIAFBAWsiAQ0ACwsgBiADNgIADwsAC5MBAQN/IAAoAhAgAWohAyAAKAIEIQRBACEBIAAoAghBAnYiACECAkACQAJAIAAOAgIBAAsDQCABIABBAXYiAiABaiIBIAQgAUECdGooAgAgA0obIQEgACACayIAQQFLDQALC0EBIQIgAyAEIAFBAnRqKAIAIgBGBEAgASEADAELIAEgACADSGohAEEAIQILIAAgAmoLnQECAX8CfiMAQSBrIgIkACACQRBqIAEQyi8gAiACKAIQNgIcIAIgAkEcahDRH6xCgKMFfiACNQIUfEKAkc285wF9IgMgA0I/h0LAhD1CABCoHiAAAn5CACACKQMIIAIpAwAiA0I/h1INABpCACACKAIYQegHbq0iBEIAVCADIAMgBHwiA1VzDQAaIAAgAzcDCEIBCzcDACACQSBqJAALrwEBAn8jAEEgayICJAAgASgCBEECEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEQEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEBEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEIEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALrwEBAn8jAEEgayICJAAgASgCBEEEEPgvIQMCQAJAIAEQij0oAgAEQCADRQ0BIAJBADYCGCACQQE2AgwgAkHo5YUBNgIIIAJCBDcCECACQQhqQfDlhQEQ7ywACyADDQELIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAgAkEgaiQADwsgAkEANgIYIAJBATYCDCACQaDkhQE2AgggAkIENwIQIAJBCGpBqOSFARDvLAALngEBAn8CQCAEIAMgBGoiAk0EQCACIAAoAgQiBUsNASAAKAIAIQIgASgCDCIAIARqIgUgASgCBCIGSwRAIAEgBkEBdCIAIAUQ3SoiBSAAIAVLGxDoGSABKAIMIQALIAQEQCABKAIIIABqIAIgA2ogBPwKAAALIAEgASgCDCAEajYCDA8LIAMgAkH0mocBELE7AAsgAiAFQfSahwEQsDsAC54BAQZ/IAEoAgAiBCgCBCABQQRrIgYoAgAiASgCBCAEKAIIIgIgASgCCCIDIAIgA0kbEJknIgUgAiADayAFG0EASARAA0ACQCAGIgJBBGogATYCACAAIAJGDQAgBCgCBCACQQRrIgYoAgAiASgCBCAEKAIIIgMgASgCCCIFIAMgBUkbEJknIgcgAyAFayAHG0EASA0BCwsgAiAENgIACwuiAQEDfyMAQRBrIgQkAAJAAkACfwJAIAEgACgCACIDENE0BEAgACgCBCECIAFFBEAgAkUNBSAAKAIIIAIgAxD4OgwECyACRQ0BIAAoAgggAiADIAEQlzUMAgtBsPSHAUErIARBD2pBoPSHAUHs9YcBENUeAAsgASADEK02CyICBEAgACACNgIIDAELIAMgARCjPQALIAAgATYCBAsgBEEQaiQAC5YBAQJ/IwBBEGsiBCQAAkAgASgCACIBQQFxBEAgBCABQX5xIgE2AgAgBEEIaiIFIAIgAWsiAiADaiIBNgIAIAQgATYCBCAEQQdBICABQQp2Z2siASABQQdPG0ECdEEBcjYCDCAEIAIQpx4gAEEIaiAFKQIANwIAIAAgBCkCADcCAAwBCyAAIAEgAiADEMYSCyAEQRBqJAALowEBAn8gACgCACIAQQxqIgEQ0yQgACgCFCICIAIoAgBBAWsiAjYCACACRQRAIABBFGoQ3x8LAkAgASgCAEUNACAAKAIQIgFBhAFJDQAgARDyHwsCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ6ScLAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLjAEBAn8Cf0H/H0H//wMgAC0AKBsgAU8EQCABQQZ2IgIgACgCBEkEQCAAKAIAIAJBAXRqLwAAIAFBP3FqDAILIAAoAhBBAWsMAQsgACgCGCABSwRAIAAgARDADwwBCyAAKAIQQQJrCyIBIAAoAhAiA0kEfyAAKAIMIAFqLQAABSACCyAALQAsIAEgA0kbC94BAQJ/IwBBMGsiAiQAIAIgATYCAAJAIAAoAggiAyABSwRAIAEgACgCFE8NASAAKAIQIAFBAnRqKAIAIAJBMGokAA8LIAIgAzYCHCACQQM2AgggAkG0vM8ANgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBzLzPABDvLAALIwBBIGsiACQAIABBAjYCBCAAQYi9zwA2AgAgAEIBNwIMIABBOzYCHCAAIAI2AhggACAAQRhqNgIIIABBmL3PABDvLAALhwIBA38jAEFAaiIDJAAgAyACNgIQIAIgASgCACgCIE8EQCADIAEQzD02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAAgASgCACgCHCACaiwAACECAn8gAUEEaiIBEN49IAJNBEBBACEBQQEMAQsgBEEIaiABIAIQpyogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4cCAQN/IwBBQGoiAyQAIAMgAjYCECACIAEoAgAoAiBPBEAgAyABEMw9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAmosAAAhAgJ/IAFBBGoiARDfPSACTQRAQQAhAUEBDAELIARBCGogASACEKYqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuIAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDJPCACTQRAIAMgARDLPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkAAJ/IAEoAgAoAhwgAkECdGooAgAiAiABQQRqIgEQ3z1PBEBBACEBQQEMAQsgBEEIaiABIAIQpiogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4oCAQN/IwBBQGoiAyQAIAMgAjYCECABKAIAEMo8IAJNBEAgAyABEMk9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAkEDdGooAgAhAgJ/IAFBBGoiARDfPSACTQRAQQAhAUEBDAELIARBCGogASACEKYqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLgEAIQIgA0EIaiIHIAFBBGoiARDfPSACSwR/IARBCGogASACEKYqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLwEAIQIgA0EIaiIHIAFBBGoiARDfPSACSwR/IARBCGogASACEKYqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLgEAIQIgA0EIaiIHIAFBBGoiARCMPiACSwR/IARBCGogASACEKwuIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuAAgEFfyMAQUBqIgMkACADIAI2AhAgASgCABDLPCACTQRAIAMgARDKPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIwBBEGsiBCQAQQEhBSABKAIAKAIcIAJBAXRqLwEAIQIgA0EIaiIHIAFBBGoiARDePSACSwR/IARBCGogASACEKcqIAQoAgghBSAEKAIMBSAGCzYCBCAHIAU2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuKAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDKPCACTQRAIAMgARDJPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJBA3RqKAIAIQICfyABQQRqIgEQ3j0gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCnKiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALiAIBA38jAEFAaiIDJAAgAyACNgIQIAEoAgAQyTwgAk0EQCADIAEQyz02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAACfyABKAIAKAIcIAJBAnRqKAIAIgIgAUEEaiIBEN49TwRAQQAhAUEBDAELIARBCGogASACEKcqIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuHAgEDfyMAQUBqIgMkACADIAI2AhAgAiABKAIAKAIgTwRAIAMgARDMPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJqLQAAIQICfyABQQRqIgEQ3z0gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCmKiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALiAIBA38jAEFAaiIDJAAgAyACNgIQIAEoAgAQyTwgAk0EQCADIAEQyz02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAACfyABKAIAKAIcIAJBAnRqKAIAIgIgAUEEaiIBEIw+TwRAQQAhAUEBDAELIARBCGogASACEKwuIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuKAgEDfyMAQUBqIgMkACADIAI2AhAgASgCABDKPCACTQRAIAMgARDJPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJBA3RqKAIAIQICfyABQQRqIgEQjD4gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCsLiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALgAIBBX8jAEFAaiIDJAAgAyACNgIQIAEoAgAQyzwgAk0EQCADIAEQyj02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyMAQRBrIgQkAEEBIQUgASgCACgCHCACQQF0ai8BACECIANBCGoiByABQQRqIgEQjD4gAksEfyAEQQhqIAEgAhCsLiAEKAIIIQUgBCgCDAUgBgs2AgQgByAFNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAALhwIBA38jAEFAaiIDJAAgAyACNgIQIAIgASgCACgCIE8EQCADIAEQzD02AiwgA0ECNgIYIANBmObPADYCFCADQgI3AiAgA0E7NgI8IANBOzYCNCADIANBMGo2AhwgAyADQSxqNgI4IAMgA0EQajYCMCADQRRqQajmzwAQ7ywACyADQQhqIQUjAEEQayIEJAAgASgCACgCHCACai0AACECAn8gAUEEaiIBEN49IAJNBEBBACEBQQEMAQsgBEEIaiABIAIQpyogBCgCDCEBIAQoAggLIQIgBSABNgIEIAUgAjYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4ACAQV/IwBBQGoiAyQAIAMgAjYCECABKAIAEMs8IAJNBEAgAyABEMo9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsjAEEQayIEJABBASEFIAEoAgAoAhwgAkEBdGouAQAhAiADQQhqIgcgAUEEaiIBEN49IAJLBH8gBEEIaiABIAIQpyogBCgCCCEFIAQoAgwFIAYLNgIEIAcgBTYCACAEQRBqJAAgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0FAayQAC4cCAQN/IwBBQGoiAyQAIAMgAjYCECACIAEoAgAoAiBPBEAgAyABEMw9NgIsIANBAjYCGCADQZjmzwA2AhQgA0ICNwIgIANBOzYCPCADQTs2AjQgAyADQTBqNgIcIAMgA0EsajYCOCADIANBEGo2AjAgA0EUakGo5s8AEO8sAAsgA0EIaiEFIwBBEGsiBCQAIAEoAgAoAhwgAmotAAAhAgJ/IAFBBGoiARCMPiACTQRAQQAhAUEBDAELIARBCGogASACEKwuIAQoAgwhASAEKAIICyECIAUgATYCBCAFIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBQGskAAuHAgEDfyMAQUBqIgMkACADIAI2AhAgAiABKAIAKAIgTwRAIAMgARDMPTYCLCADQQI2AhggA0GY5s8ANgIUIANCAjcCICADQTs2AjwgA0E7NgI0IAMgA0EwajYCHCADIANBLGo2AjggAyADQRBqNgIwIANBFGpBqObPABDvLAALIANBCGohBSMAQRBrIgQkACABKAIAKAIcIAJqLAAAIQICfyABQQRqIgEQjD4gAk0EQEEAIQFBAQwBCyAEQQhqIAEgAhCsLiAEKAIMIQEgBCgCCAshAiAFIAE2AgQgBSACNgIAIARBEGokACADKAIMIQEgACADKAIINgIAIAAgATYCBCADQUBrJAAL+YUDA0l/JX4IfCMAQeAAayIBJAACQAJAIAQtAARFBEAjAEGQBGsiECQAIBBBCGoiBCACIAMQnR8gEEHYAWohDiMAQfADayIDJAAgA0GwAWogBBDwJyADQfAAaiICIANBvAFqIgcoAgA2AgAgAyADKQK0ATcDaAJAIAMoArABIgZBBEcEQCADKALAASEEIA4gAykDaDcCCCAOIAQ2AhQgDiAGNgIEIA5BAzYCACAOQRBqIAIoAgA2AgAMAQsgA0HgA2oiBiACKAIANgIAIAMgAykDaDcD2AMgA0HYA2oQhjAgA0EANgIAIANBgICAgHg2AgggA0IANwMYIANBgICAgHg2AiggA0GAgICAeDYCOCADQYCAgIB4NgJIIANBgICAgHg2AlggA0ECNgJoIANBgICAgHg2AogBIANBsAFqIAQQ0wkgBiAHKQIANwMAIANB6ANqIiIgA0HEAWooAgA2AgAgAyADKQK0ATcD2AMCQAJAAkAgAygCsAFFBEAgA0HIAWohRyADQbQBaiEeIANBzAFqIUggA0G4AWohOyADQewAaiE8A0AgA0GoAWogIigCACICNgIAIANBoAFqIANB4ANqIh8pAwA3AwAgAyADKQPYAzcDmAECQAJAAkACQAJAAkACQAJAAkACQAJAIAJB/wFxBEAgA0GwAWogA0GYAWoQ/BcgAy8BtAEhAiADKAKwASIHQQRHBEAgDiADKQG2ATcBCiAOQRBqIANBvAFqKQEANwEAIA4gAjsBCCAOIAc2AgQgDkEDNgIADBALAkACQAJAAkACQAJAAkACQAJAAkAgAkEBaw4JAAECAwQFBgcICQsgA0GwAWogBBDAHCADKAKwAUUEQCADKAK4ASE1QQEhOAwVCyADKQO4ASJOpyE1QQEhOCADKAK0ASICQQRGDRQgDiADKQPAATcDECAOIDU2AgggDiACNgIEIA5BAzYCACAOIE5CIIg+AgwMGAsgA0GwAWogBBDJDyADKAK0ASEVIAMoArABIgJBBEcEQCAOIAMpALkBNwANIA5BFGogA0HAAWooAAA2AAAgDiADLQC4AToADCAOIBU2AgggDiACNgIEIA5BAzYCAAwYCyADQbABaiAVQQBBBEHgABCgGCADKAK0ASECIAMoArABQQFGDQkgA0EANgK8AyADIAMoArgBNgK4AyADIAI2ArQDIBVBAEoEQANAIANBsAFqIQpBACE2QQAhN0EAIRNBACEsQQAhGEEAIS1BACEuQQAhJkEAIQlBACEWQQAhJUEAIRJBACEnQQAhL0EAIShBACEpIwBB8ABrIgckACAHQdgAaiAEEPAnIAdByABqIgIgB0HkAGoiBigCADYCACAHIAcpAlw3A0ACQCAHKAJYIgVBBEcEQCAHKAJoIQYgCiAHKQNANwIIIAogBjYCFCAKIAU2AgQgCkECNgIAIApBEGogAigCADYCAAwBCyAHQTBqIAIoAgA2AgAgByAHKQNANwMoIAdBKGoQhjAgB0GAgICAeDYCACAHQRI2AhAgB0HYAGogBBDTCSACIAYpAgA3AwAgB0HQAGoiFCAHQewAaigCADYCACAHIAcpAlw3A0ACQAJAAkAgBygCWEUEQCAHQdwAaiEaA0AgB0E4aiAUKAIAIgI2AgAgB0EwaiAHQcgAaiIZKQMANwMAIAcgBykDQDcDKAJAIAJB/wFxBEAgB0HYAGogB0EoahD8FyAHLwFcIQIgBygCWCIGQQRHBEAgCiAHKQFeNwEKIApBEGogB0HkAGopAQA3AQAgCiACOwEIIAogBjYCBCAKQQI2AgAMBgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACQQFrDgoAAQILAwQFBgcREgsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCEJDAELIAcpA2AiTqchCSAHKAJcIgJBBEcNCAtBASE2DBMLIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhFgwBCyAHKQNgIk6nIRYgBygCXCICQQRHDQgLQQEhNwwSCyAHQdgAaiAEEMAcAkAgBygCWEUEQCAHKAJgISUMAQsgBykDYCJOpyElIAcoAlwiAkEERw0IC0EBIRMMEQsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCESDAELIAcpA2AiTqchEiAHKAJcIgJBBEcNCQtBASEsDBALIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhJwwBCyAHKQNgIk6nIScgBygCXCICQQRHDQkLQQEhGAwPCyAHQdgAaiAEEMAcAkAgBygCWEUEQCAHKAJgIS8MAQsgBykDYCJOpyEvIAcoAlwiAkEERw0JC0EBIS0MDgsgB0HYAGogBBDAHAJAIAcoAlhFBEAgBygCYCEoDAELIAcpA2AiTqchKCAHKAJcIgJBBEcNCQtBASEuDA0LIAdB2ABqIAQQwBwCQCAHKAJYRQRAIAcoAmAhKQwBCyAHKQNgIk6nISkgBygCXCICQQRHDQkLQQEhJgwMCyAKIAcpA2g3AhAgCiAJNgIIIAogAjYCBCAKQQI2AgAgCiBOQiCIPgIMDA8LIAogBykDaDcCECAKIBY2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMDgsgCiAHKQNoNwIQIAogJTYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwNCyAHQdgAaiAEEMIVIBkgGkEIaigCADYCACAHIBopAgA3A0AgBygCWCICQQRHBEAgBygCaCEGIAogBykDQDcCCCAKIAY2AhQgCiACNgIEIApBAjYCACAKQRBqIAdByABqKAIANgIADA0LIAdB4ABqIgIgGSgCADYCACAHIAcpA0A3A1ggBxCGMCAHQQhqIAIoAgA2AgAgByAHKQNYNwMADAgLIAogBykDaDcCECAKIBI2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMCwsgCiAHKQNoNwIQIAogJzYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwKCyAKIAcpA2g3AhAgCiAvNgIIIAogAjYCBCAKQQI2AgAgCiBOQiCIPgIMDAkLIAogBykDaDcCECAKICg2AgggCiACNgIEIApBAjYCACAKIE5CIIg+AgwMCAsgCiAHKQNoNwIQIAogKTYCCCAKIAI2AgQgCkECNgIAIAogTkIgiD4CDAwHCyAHQdgAaiEGQQAhICMAQYABayICJAAgAkESNgIIIAJB6ABqIAQQ8CcgAkHYAGoiBSACQfQAaiIIKAIANgIAIAIgAikCbDcDUAJAAkAgAigCaCINQQRHBEAgAigCeCEIIAYgAikDUDcCCCAGIAg2AhQgBiANNgIEIAZBATYCACAGQRBqIAUoAgA2AgAMAQsgAkFAayIzIAUoAgA2AgAgAiACKQNQNwM4IAJBOGoQhjAgAkHoAGogBBDTCSAFIAgpAgA3AwAgAkHgAGoiIyACQfwAaigCADYCACACIAIpAmw3A1ACQCACKAJoRQRAIAJBDGohMiACQewAaiEdA0AgAkEwaiAjKAIAIgU2AgAgAkEoaiACQdgAaiIkKQMANwMAIAIgAikDUDcDIAJAAkAgBUH/AXEEQCACQegAaiACQSBqEPwXIAIvAWwhBSACKAJoIghBBEcEQCAGIAIpAW43AQogBkEQaiACQfQAaikBADcBACAGIAU7AQggBiAINgIEIAZBATYCAAwGCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFQQFrDhIAAQIDBAUGBxEICQoLDA0ODxARCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMFwsgAigCCEESRw0TIAJBCGoQpiggAkECNgIIDBMLIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwWCyACKAIIQRJHDRIgAkEIahCmKCACQQM2AggMEgsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDBULIAIoAghBEkcNESACQQhqEKYoIAJBBDYCCAwRCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMFAsgAigCCEESRw0QIAJBCGoQpiggAkEFNgIIDBALIAJB6ABqIQhBACERQQAhDSMAQeAAayIFJAAgBUHIAGogBBDwJyAFQThqIgsgBUHUAGoiDCgCADYCACAFIAUpAkw3AzACQCAFKAJIIg9BBEcEQCAFKAJYIQ0gCCAFKQMwNwIEIAggDTYCECAIIA82AgAgCEEMaiALKAIANgIADAELIAVBIGogCygCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQcgAaiAEENMJIAsgDCkCADcDACAFQUBrIgwgBUHcAGooAgA2AgAgBSAFKQJMNwMwAkAgBSgCSEUEQCAFQcwAaiEXQQAhD0EAIQsDQCAFQShqIAwoAgAiGzYCACAFQSBqIAVBOGoiMCkDADcDACAFIAUpAzA3AxgCQCAbQf8BcQRAIAVByABqIAVBGGoQ/BcgBS8BTCEbIAUoAkgiNEEERwRAIAggBSkBTjcBBiAIQQxqIAVB1ABqKQEANwEAIAggGzsBBCAIIDQ2AgAMBQsCQAJAAkAgG0EBaw4CAAECCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCERQQEhCwwECyAFKQNQIk6nIRFBASELIAUoAkwiG0EERg0DIAggBSkDWDcCDCAIIBE2AgQgCCAbNgIAIAggTkIgiD4CCAwGCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCENQQEhDwwDCyAFKQNQIk6nIQ1BASEPIAUoAkwiG0EERg0CIAggBSkDWDcCDCAIIA02AgQgCCAbNgIAIAggTkIgiD4CCAwFCyAFQcgAaiAEIAUtAChBwAAQyQIgBSgCSCIbQQRGDQEgCCAFKQJMNwIEIAhBDGogBUHUAGopAgA3AgAgCCAbNgIADAQLIAUgDTYCFCAFIA82AhAgBSARNgIMIAUgCzYCCCAFQRhqEIYwIAVByABqIAQQqCkgBSgCSCIMQQRHBEAgCCAFKQJMNwIEIAhBDGogBUHUAGopAgA3AgAgCCAMNgIADAULIAVByABqQf7+zwBBESAFQQhqEOYeIAUoAkgiDEEERwRAIAggBSkCTDcCBCAIQQxqIAVB1ABqKQIANwIAIAggDDYCAAwFCyAFQcgAakGP/88AQRUgBUEQahDmHiAFKAJIIgxBBEcEQCAIIAUpAkw3AgQgCEEMaiAFQdQAaikCADcCACAIIAw2AgAMBQsCQCALBEAgD0UNASAIIA02AgggCCARNgIEIAhBBDYCAAwGC0H4/M8AQccAQaT/zwAQyyQAC0H4/M8AQccAQbT/zwAQyyQACyAFQRhqEIYwIAVByABqIAQQ0wkgMCAXQQhqKQIANwMAIAwgF0EQaigCADYCACAFIBcpAgA3AzAgBSgCSEUNAAsLIAggBSkDMDcCACAIQRBqIAwoAgA2AgAgCEEIaiAFQThqKQMANwIADAELIAVBGGoQhjALIAVB4ABqJAAgAigCcCEFIAIoAmwhCCACKAJoIg1BBEcEQCAGIAIpAnQ3AhAgBiAFNgIMIAYgCDYCCCAGIA02AgQgBkEBNgIADBMLIAIoAghBEkcNDyACQQhqEKYoIAIgBTYCECACIAg2AgwgAkEGNgIIDA8LIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwSCyACKAIIQRJHDQ4gAkEIahCmKCACQQc2AggMDgsgAkHoAGohCCMAQdAAayIFJAAgBUE4aiAEEPAnIAVBKGoiDSAFQcQAaiILKAIANgIAIAUgBSkCPDcDIAJAIAUoAjgiEUEERwRAIAUoAkghCyAIIAUpAyA3AgQgCCALNgIQIAggETYCACAIQQxqIA0oAgA2AgAMAQsgBUEQaiANKAIANgIAIAUgBSkDIDcDCCAFQQhqEIYwIAVBOGogBBDTCSANIAspAgA3AwAgBUEwaiILIAVBzABqKAIANgIAIAUgBSkCPDcDIAJAAkAgBSgCOEUEQCAFQTxqIQ9BAiERQQMhDQNAIAVBGGogCygCACIMNgIAIAVBEGogBUEoaiIbKQMANwMAIAUgBSkDIDcDCCAMQf8BcUUNAiAFQThqIAVBCGoQ/BcgBS8BPCEXIAUoAjgiDEEERwRAIAggBSkBPjcBBiAIQQxqIAVBxABqKQEANwEAIAggFzsBBAwECwJAAkACQAJAIBdBAWsOAgABAgsgBUE4aiAEENoQIAUtADwhESAFKAI4IgxBBEYNAiAIIAUpAD03AAUgCEEMaiAFQcQAaikAADcAACAIIBE6AAQMBgsgBUE4aiAEEM4HIAUtADwhDSAFKAI4IgxBBEYNASAIIAUpAD03AAUgCEEMaiAFQcQAaikAADcAACAIIA06AAQMBQsgBUE4aiAEIAUtABhBwAAQyQIgBSgCOCIMQQRGDQAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAMBAsgBUEIahCGMCAFQThqIAQQ0wkgGyAPQQhqKQIANwMAIAsgD0EQaigCADYCACAFIA8pAgA3AyAgBSgCOEUNAAsLIAggBSkDIDcCACAIQRBqIAsoAgA2AgAgCEEIaiAFQShqKQMANwIADAILIAUgEToABiAFIA06AAcgBUEIahCGMCAFQThqIAQQqCkgBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILIAVBOGpBpIHQAEEdIAVBBmoQ9B0gBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILIAVBOGpBwYHQAEENIAVBB2oQ9h0gBSgCOCILQQRHBEAgCCAFKQI8NwIEIAhBDGogBUHEAGopAgA3AgAgCCALNgIADAILAkAgEUECRwRAIA1BA0YNASAIIA06AAUgCCAROgAEIAhBBDYCAAwDC0H4/M8AQccAQdCB0AAQyyQAC0H4/M8AQccAQeCB0AAQyyQACyAIIAw2AgAgBUEIahCGMAsgBUHQAGokACACLQBtIQUgAi0AbCEIIAIoAmgiDUEERwRAIAYgAikBbjcBCiAGQRBqIAJB9ABqKQEANwEAIAYgBToACSAGIAg6AAggBiANNgIEIAZBATYCAAwRCyACKAIIQRJHDQ0gAkEIahCmKCACIAU6AA0gAiAIOgAMIAJBCDYCCAwNCyACQegAaiEIIwBB0ABrIgUkACAFQThqIAQQ8CcgBUEoaiINIAVBxABqIgsoAgA2AgAgBSAFKQI8NwMgAkAgBSgCOCIRQQRHBEAgBSgCSCELIAggBSkDIDcCBCAIIAs2AhAgCCARNgIAIAhBDGogDSgCADYCAAwBCyAFQRBqIA0oAgA2AgAgBSAFKQMgNwMIIAVBCGoQhjAgBUE4aiAEENMJIA0gCykCADcDACAFQTBqIgsgBUHMAGooAgA2AgAgBSAFKQI8NwMgAkACQCAFKAI4RQRAIAVBPGohD0ECIRFBAyENA0AgBUEYaiALKAIAIgw2AgAgBUEQaiAFQShqIhspAwA3AwAgBSAFKQMgNwMIIAxB/wFxRQ0CIAVBOGogBUEIahD8FyAFLwE8IRcgBSgCOCIMQQRHBEAgCCAFKQE+NwEGIAhBDGogBUHEAGopAQA3AQAgCCAXOwEEDAQLAkACQAJAAkAgF0EBaw4CAAECCyAFQThqIAQQ2hAgBS0APCERIAUoAjgiDEEERg0CIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwGCyAFQThqIAQQzgcgBS0APCENIAUoAjgiDEEERg0BIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggDToABAwFCyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNACAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwECyAFQQhqEIYwIAVBOGogBBDTCSAbIA9BCGopAgA3AwAgCyAPQRBqKAIANgIAIAUgDykCADcDICAFKAI4RQ0ACwsgCCAFKQMgNwIAIAhBEGogCygCADYCACAIQQhqIAVBKGopAwA3AgAMAgsgBSAROgAGIAUgDToAByAFQQhqEIYwIAVBOGogBBCoKSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsgBUE4akHNgNAAQSIgBUEGahD0HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsgBUE4akHvgNAAQRIgBUEHahD2HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMAgsCQCARQQJHBEAgDUEDRg0BIAggDToABSAIIBE6AAQgCEEENgIADAMLQfj8zwBBxwBBhIHQABDLJAALQfj8zwBBxwBBlIHQABDLJAALIAggDDYCACAFQQhqEIYwCyAFQdAAaiQAIAItAG0hBSACLQBsIQggAigCaCINQQRHBEAgBiACKQFuNwEKIAZBEGogAkH0AGopAQA3AQAgBiAFOgAJIAYgCDoACCAGIA02AgQgBkEBNgIADBALIAIoAghBEkcNDCACQQhqEKYoIAIgBToADSACIAg6AAwgAkEJNgIIDAwLIAJB6ABqIQhBACEPQQAhDSMAQdAAayIFJAAgBUE4aiAEEPAnIAVBKGoiCyAFQcQAaiIRKAIANgIAIAUgBSkCPDcDIAJAIAUoAjgiDEEERwRAIAUoAkghDSAIIAUpAyA3AgQgCCANNgIQIAggDDYCACAIQQxqIAsoAgA2AgAMAQsgBUEQaiALKAIANgIAIAUgBSkDIDcDCCAFQQhqEIYwIAVBOGogBBDTCSALIBEpAgA3AwAgBUEwaiILIAVBzABqKAIANgIAIAUgBSkCPDcDIAJAAkACQCAFKAI4RQRAIAVBPGohF0ECIREDQCAFQRhqIAsoAgAiDDYCACAFQRBqIAVBKGoiMCkDADcDACAFIAUpAyA3AwgCQAJAIAxB/wFxBEAgBUE4aiAFQQhqEPwXIAUvATwhGyAFKAI4IgxBBEcEQCAIIAUpAT43AQYgCEEMaiAFQcQAaikBADcBACAIIBs7AQQMCAsCQAJAAkAgG0EBaw4CAAECCyAFQThqIAQQkhggBS0APCENIAUoAjgiDEEERg0DIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggDToABAwJCyAFQThqIAQQ2hAgBS0APCERIAUoAjgiDEEERg0DIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwICyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNAiAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwHCyAFIA06AAYgBSAPOgAFIAUgEToAByAFQQhqEIYwIAVBOGogBBCoKSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsjAEEwayILJAAgC0ERNgIMIAtB8IHQADYCCCAFQThqIgwgBUEFai0AAAR/QQQFIAtBATYCFCALQeyOzwA2AhAgC0IBNwIcIAtBzAE2AiwgCyALQShqNgIYIAsgC0EIajYCKCAMQQRqIAtBEGoQmQ4gDEEAOgAQQQELNgIAIAtBMGokACAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsgBUE4akGBgtAAQREgBUEHahD0HSAFKAI4IgtBBEcEQCAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCACAIIAs2AgAMCAsgD0UNBCARQQJGDQUgCCANOgAFIAhBBDYCACAIIBFBAXE6AAQMBwtBASEPCyAFQQhqEIYwIAVBOGogBBDTCSAwIBdBCGopAgA3AwAgCyAXQRBqKAIANgIAIAUgFykCADcDICAFKAI4RQ0ACwsgCCAFKQMgNwIAIAhBEGogCygCADYCACAIQQhqIAVBKGopAwA3AgAMAwtB+PzPAEHHAEGUgtAAEMskAAtB+PzPAEHHAEGkgtAAEMskAAsgCCAMNgIAIAVBCGoQhjALIAVB0ABqJAAgAi0AbSEFIAItAGwhCCACKAJoIg1BBEcEQCAGIAIpAW43AQogBkEQaiACQfQAaikBADcBACAGIAU6AAkgBiAIOgAIIAYgDTYCBCAGQQE2AgAMDwsgAigCCEESRw0LIAJBCGoQpiggAiAFOgANIAIgCDoADCACQQo2AggMCwsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDA4LIAIoAghBEkcNCiACQQhqEKYoIAJBCzYCCAwKCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMDQsgAigCCEESRw0JIAJBCGoQpiggAkEMNgIIDAkLIAJB6ABqIAQQ+gogAigCaCIFQQRHBEAgBiACKQJsNwIIIAZBEGogAkH0AGopAgA3AgAgBkEBNgIAIAYgBTYCBAwMCyACKAIIQRJHDQggAkEIahCmKCACQQ02AggMCAsgAkHoAGogBBD6CiACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAsLIAIoAghBEkcNByACQQhqEKYoIAJBDjYCCAwHCyACQegAaiAEEPoKIAIoAmgiBUEERwRAIAYgAikCbDcCCCAGQRBqIAJB9ABqKQIANwIAIAZBATYCACAGIAU2AgQMCgsgAigCCEESRw0GIAJBCGoQpiggAkEPNgIIDAYLIAJB6ABqIQhBACERIwBB0ABrIgUkACAFQThqIAQQ8CcgBUEoaiINIAVBxABqIgsoAgA2AgAgBSAFKQI8NwMgAkAgBSgCOCIMQQRHBEAgBSgCSCELIAggBSkDIDcCBCAIIAs2AhAgCCAMNgIAIAhBDGogDSgCADYCAAwBCyAFQRBqIA0oAgA2AgAgBSAFKQMgNwMIIAVBCGoQhjAgBUE4aiAEENMJIA0gCykCADcDACAFQTBqIg0gBUHMAGooAgA2AgAgBSAFKQI8NwMgAkAgBSgCOEUEQCAFQTxqIQ9BACELA0AgBUEYaiANKAIAIgw2AgAgBUEQaiAFQShqIhspAwA3AwAgBSAFKQMgNwMIAkACQCAMQf8BcQRAIAVBOGogBUEIahD8FyAFLwE8IRcgBSgCOCIMQQRHBEAgCCAFKQE+NwEGIAhBDGogBUHEAGopAQA3AQAgCCAXOwEEDAYLIBdBAUYEQCAFQThqIAQQkhggBS0APCERIAUoAjgiDEEERg0CIAggBSkAPTcABSAIQQxqIAVBxABqKQAANwAAIAggEToABAwGCyAFQThqIAQgBS0AGEHAABDJAiAFKAI4IgxBBEYNAiAIIAUpAjw3AgQgCEEMaiAFQcQAaikCADcCAAwFCyAFQQhqEIYwIAVBOGogBBCoKSAFKAI4Ig1BBEcEQCAIQQRqIgsgBSkCPDcCACALQQhqIAVBxABqKQIANwIAIAggDTYCAAwGCyAIIBE6AAUgCEEENgIAIAggCzoABAwFC0EBIQsLIAVBCGoQhjAgBUE4aiAEENMJIBsgD0EIaikCADcDACANIA9BEGooAgA2AgAgBSAPKQIANwMgIAUoAjhFDQALCyAIIAUpAyA3AgAgCEEQaiANKAIANgIAIAhBCGogBUEoaikDADcCAAwBCyAIIAw2AgAgBUEIahCGMAsgBUHQAGokACACLQBtIQUgAi0AbCEIIAIoAmgiDUEERwRAIAYgAikBbjcBCiAGQRBqIAJB9ABqKQEANwEAIAYgBToACSAGIAg6AAggBiANNgIEIAZBATYCAAwJCyACKAIIQRJHDQUgAkEIahCmKCACIAU6AA0gAiAIOgAMIAJBEDYCCAwFCyACQegAaiEIIwBB4ABrIgUkACAFQcgAaiAEEPAnIAVBOGoiDSAFQdQAaiILKAIANgIAIAUgBSkCTDcDMAJAIAUoAkgiEUEERwRAIAUoAlghCyAIIAUpAzA3AgQgCCALNgIQIAggETYCACAIQQxqIA0oAgA2AgAMAQsgBUEgaiANKAIANgIAIAUgBSkDMDcDGCAFQRhqEIYwIAVBgICAgHg2AgggBUHIAGogBBDTCSANIAspAgA3AwAgBUFAayILIAVB3ABqKAIANgIAIAUgBSkCTDcDMAJAAkAgBSgCSEUEQCAFQcwAaiENA0AgBUEoaiALKAIAIgw2AgAgBUEgaiAFQThqIhEpAwA3AwAgBSAFKQMwNwMYAkACQCAMQf8BcQRAIAVByABqIAVBGGoQ/BcgBS8BTCEMIAUoAkgiD0EERwRAIAggBSkBTjcBBiAIQQxqIAVB1ABqKQEANwEAIAggDDsBBCAIIA82AgAMBgsgDEEBRgRAIAVByABqIAQQwhUgESANQQhqKAIANgIAIAUgDSkCADcDMCAFKAJIIgxBBEYNAiAFKAJYIQ0gCCAFKQMwNwIEIAggDTYCECAIIAw2AgAgCEEMaiAFQThqKAIANgIADAYLIAVByABqIAQgBS0AKEHAABDJAiAFKAJIIgxBBEYNAiAIIAUpAkw3AgQgCEEMaiAFQdQAaikCADcCACAIIAw2AgAMBQsgBUEYahCGMCAFQcgAaiAEEKgpIAhBBGohDSAFKAJIIgtBBEcEQCANIAUpAkw3AgAgDUEIaiAFQdQAaikCADcCACAIIAs2AgAMBgsgDSAFKQMINwIAIAhBBDYCACANQQhqIAVBEGooAgA2AgAMBgsgBUHQAGoiDCARKAIANgIAIAUgBSkDMDcDSCAFQQhqEIYwIAVBEGogDCgCADYCACAFIAUpA0g3AwgLIAVBGGoQhjAgBUHIAGogBBDTCSARIA1BCGopAgA3AwAgCyANQRBqKAIANgIAIAUgDSkCADcDMCAFKAJIRQ0ACwsgCCAFKQMwNwIAIAhBEGogCygCADYCACAIQQhqIAVBOGopAwA3AgAMAQsgBUEYahCGMAsgBUEIahCGMAsgBUHgAGokACAkIB1BCGooAgA2AgAgAiAdKQIANwNQIAIoAmgiBUEERwRAIAIoAnghCCAGIAIpA1A3AgggBiAINgIUIAYgBTYCBCAGQQE2AgAgBkEQaiACQdgAaigCADYCAAwICyACQUBrIgUgJCgCADYCACACIAIpA1A3AzggAigCCEESRwRAIAJBOGoQhjAMBQsgAkHwAGoiCCAFKAIANgIAIAIgAikDODcDaCACQQhqEKYoIDIgAikDaDcCACAyQQhqIAgoAgA2AgAgAkERNgIIDAQLIAJB6ABqIQhBACENIwBB4ABrIgUkACAFQcgAaiAEEPAnIAVBOGoiCyAFQdQAaiIRKAIANgIAIAUgBSkCTDcDMAJAIAUoAkgiDEEERwRAIAUoAlghDSAIIAUpAzA3AgggCCANNgIUIAggDDYCBCAIQQE2AgAgCEEQaiALKAIANgIADAELIAVBIGogCygCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQYCAgIB4NgIIIAVByABqIAQQ0wkgCyARKQIANwMAIAVBQGsiDCAFQdwAaigCADYCACAFIAUpAkw3AzACQCAFKAJIRQRAIAVBzABqIRFBACELA0AgBUEoaiAMKAIAIhc2AgAgBUEgaiAFQThqIg8pAwA3AwAgBSAFKQMwNwMYAkACQAJAIBdB/wFxBEAgBUHIAGogBUEYahD8FyAFLwFMIRcgBSgCSCIbQQRHBEAgCCAFKQFONwEKIAhBEGogBUHUAGopAQA3AQAgCCAXOwEIIAggGzYCBCAIQQE2AgAMAwsCQAJAAkAgF0EBaw4CAQACCyAFQcgAaiAEEMAcIAUoAkhFBEAgBSgCUCENQQEhCwwGCyAFKQNQIk6nIQ1BASELIAUoAkwiF0EERg0FIAggBSkDWDcCECAIIA02AgggCCAXNgIEIAhBATYCACAIIE5CIIg+AgwMBAsgBUHIAGogBBDCFSAPIBFBCGooAgA2AgAgBSARKQIANwMwIAUoAkgiF0EERg0CIAUoAlghDSAIIAUpAzA3AgggCCANNgIUIAggFzYCBCAIQQE2AgAgCEEQaiAFQThqKAIANgIADAMLIAVByABqIAQgBS0AKEHAABDJAiAFKAJIIhdBBEYNAyAIIAUpAkw3AgggCEEQaiAFQdQAaikCADcCACAIQQE2AgAgCCAXNgIEDAILIAVBGGoQhjAgBUHIAGogBBCoKSAFKAJIIhFBBEcEQCAIIAUpAkw3AgggCEEQaiAFQdQAaikCADcCACAIQQE2AgAgCCARNgIEDAYLIAggBSkDCDcCDCAIIA02AgggCCALNgIEIAhBADYCACAIQRRqIAVBEGooAgA2AgAMBgsgBUHQAGoiFyAPKAIANgIAIAUgBSkDMDcDSCAFQQhqEIYwIAVBEGogFygCADYCACAFIAUpA0g3AwgMAQsgBUEYahCGMAwDCyAFQRhqEIYwIAVByABqIAQQ0wkgDyARQQhqKQIANwMAIAwgEUEQaigCADYCACAFIBEpAgA3AzAgBSgCSEUNAAsLIAggBSkDMDcCBCAIQQE2AgAgCEEUaiAMKAIANgIAIAhBDGogBUE4aikDADcCAAsgBUEIahCGMAsgBUHgAGokACAkIB1BCGopAgA3AwAgIyAdQRBqKAIANgIAIAIgHSkCADcDUCACKAJoDQIgAkHIAGoiBSAjKAIANgIAIAJBQGsiCCAkKQMANwMAIAIgAikDUDcDOCACKAIIQRJHBEAgMxCGMAwECyACQfgAaiINIAUoAgA2AgAgAkHwAGoiBSAIKQMANwMAIAIgAikDODcDaCACQQhqEKYoIAJBGGogDSgCADYCACACQRBqIAUpAwA3AwAgAiACKQNoNwMIDAMLIAJB6ABqIAQgAi0AMEHAABDJAiACKAJoIgVBBEYNAiAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAULIAJBIGoQhjAgAkHoAGogBBCoKSACKAJoIgVBBEcEQCAGIAIpAmw3AgggBkEQaiACQfQAaikCADcCACAGQQE2AgAgBiAFNgIEDAYLAkAgIEUEQCACQegAakG0gtAAQSwQoh8MAQsgIEEBTARAIAJB+ABqIAJBGGooAgA2AgAgAkHwAGogAkEQaikDADcDACACIAIpAwg3A2gjAEEgayIFJAAgBgJ/IAJB6ABqIggoAgBBEkcEQCAGIAgpAgA3AgQgBkEUaiAIQRBqKAIANgIAIAZBDGogCEEIaikCADcCAEEADAELIAVBEGpBpIDQAEEpEKIfIAZBDGogBUEUaikCADcCACAGQRRqIAVBHGooAgA2AgAgBUEBNgIMIAYgBSkCDDcCBEEBCzYCACAFQSBqJAAMCAsgAkHoAGpB4ILQAEE6EKIfCyAGQoGAgIAQNwIAIAYgAikCaDcCCCAGQRBqIAJB8ABqKQIANwIAIAJBCGoQpigMBgsgBiACKQNQNwIEIAZBATYCACAGQRRqIAJB4ABqKAIANgIAIAZBDGogAkHYAGopAwA3AgAMAwsgAkEgahCGMCACQegAaiAEENMJICQgHUEIaikCADcDACAjIB1BEGooAgA2AgAgAiAdKQIANwNQICBBAWohICACKAJoRQ0ACwsgBiACKQNQNwIEIAZBATYCACAGQRRqICMoAgA2AgAgBkEMaiACQdgAaikDADcCAAwBCyACQSBqEIYwCyACQQhqEKYoCyACQYABaiQAIBkgGkEIaikCADcDACAUIBpBEGooAgA2AgAgByAaKQIANwNAIAcoAlgNBSAHQegAaiICIBQoAgA2AgAgB0HgAGoiBiAZKQMANwMAIAcgBykDQDcDWCAHQRBqEKYoIAdBIGogAigCADYCACAHQRhqIAYpAwA3AwAgByAHKQNYNwMQDAILIAdB2ABqIAQgBy0AOEHAABDJAiAHKAJYIgJBBEYNASAKIAcpAlw3AgggCkEQaiAHQeQAaikCADcCACAKQQI2AgAgCiACNgIEDAULIAdBKGoQhjAgB0HYAGogBBCoKSAHKAJYIgJBBEcEQCAKIAcpAlw3AgggCkEQaiAHQeQAaikCADcCACAKQQI2AgAgCiACNgIEDAYLIAdB2ABqQZqD0ABBEiAHEPUdIAcoAlgiAkEERwRAIAogBykCXDcCCCAKQRBqIAdB5ABqKQIANwIAIApBAjYCACAKIAI2AgQMBgsgBygCACICQYCAgIB4RwRAIAogBykDEDcCQCAKIAcpAgQ3AlggCiACNgJUIAogKTYCPCAKICY2AjggCiAoNgI0IAogLjYCMCAKIC82AiwgCiAtNgIoIAogJzYCJCAKIBg2AiAgCiASNgIcIAogLDYCGCAKICU2AhQgCiATNgIQIAogFjYCDCAKIDc2AgggCiAJNgIEIAogNjYCACAKQcgAaiAHQRhqKQMANwIAIApB0ABqIAdBIGooAgA2AgAMBwtB+PzPAEHHAEGsg9AAEMskAAsgB0EoahCGMCAHQdgAaiAEENMJIBkgGkEIaikCADcDACAUIBpBEGooAgA2AgAgByAaKQIANwNAIAcoAlhFDQALCyAKIAcpA0A3AgQgCkECNgIAIApBFGogFCgCADYCACAKQQxqIAdByABqKQMANwIADAILIAogBykDQDcCBCAKQQI2AgAgCkEUaiAHQdAAaigCADYCACAKQQxqIAdByABqKQMANwIACyAHQShqEIYwCyAHQRBqEKYoIAcQhjALIAdB8ABqJAAgHyAeQQhqKQIANwMAICIgHkEQaigCADYCACADIB4pAgA3A9gDIAMoArABIgZBAkYEQCAOIAMpA9gDNwIEIA5BAzYCACAOQRRqIANB6ANqKAIANgIAIA5BDGogA0HgA2opAwA3AgAgA0G0A2oiAhD3HSACQQRB4AAQ4B4MGgsgA0GQAmogR0HIAPwKAAAgA0HgAmoiCiAfKQMANwMAIANB6AJqIgUgIigCADYCACADIAMpA9gDNwPYAiADKAK8AyIHIAMoArQDRgRAIANBtANqQcSb0AAQnygLIAMoArgDIAdB4ABsaiICIAY2AgAgAiADKQPYAjcCBCACQQxqIAopAwA3AgAgAkEUaiAFKAIANgIAIAJBGGogA0GQAmpByAD8CgAAIAMgB0EBajYCvAMgFUEBayIVDQALCyADQbgBaiICIANBvANqKAIANgIAIAMgAykCtAM3A7ABIANBCGoQty8gA0EQaiACKAIANgIAIAMgAykDsAE3AwgMEwsgA0GwAWogBBDAHCADKAKwAQ0VIAMpA7gBIVRCASFVDBILIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMFgsgA0GwAWogFUEAQQhB0AAQoBggAygCtAEhAiADKAKwAUEBRg0IIANBADYCvAMgAyADKAK4ATYCuAMgAyACNgK0AyAVQQBKBEADQCADQbABaiEIQgAhVkEAISVBACEsQgAhXUIAIV5BACEvQgAhX0IAIVdCACFYQgAhYEIAIWEjAEHQCGsiByQAIAdBgAFqIAQQ8CcgB0HwAGoiAiAHQYwBaiIGKAIANgIAIAcgBykChAE3A2gCQCAHKAKAASIKQQRHBEAgBygCkAEhBiAIIAcpA2g3AgwgCCAGNgIYIAggCjYCCCAIQgI3AwAgCEEUaiACKAIANgIADAELIAdB0ABqIAIoAgA2AgAgByAHKQNoNwNIIAdByABqEIYwIAdBgICAgHg2AgggB0IANwMYIAdCADcDKCAHQYCAgIB4NgI4IAdBgAFqIAQQ0wkgAiAGKQIANwMAIAdB+ABqIhcgB0GUAWooAgA2AgAgByAHKQKEATcDaAJAAkAgBygCgAFFBEAgB0GcAWohSSAHQYgBaiE9IAdBhAFqIT4DQCAHQdgAaiAXKAIAIgI2AgAgB0HQAGogB0HwAGoiNCkDADcDACAHIAcpA2g3A0gCQAJAAkACQAJAAkACQAJAAkACQAJAIAJB/wFxBEAgB0GAAWogB0HIAGoQ/BcgBy8BhAEhAiAHKAKAASIGQQRHBEAgCCAHKQGGATcBDiAIQRRqIAdBjAFqKQEANwEAIAggAjsBDCAIIAY2AgggCEICNwMADA8LAkACQAJAAkACQAJAAkACQCACQQFrDgcBAgMEBQYABwsgB0GAAWogBBDAHCAHKAKAAUUEQCAHLwGIASEsQQEhJQwTCyAHKQOIASJOpyEsQQEhJSAHKAKEASICQQRGDRIgCCAHKQOQATcCFCAIICw7AQwgCCACNgIIIAhCAjcDACAIQRJqIE5CMIg9AQAgCCBOQhCIPgEODBULIAdBgAFqIAQQyQ8gBygChAEhESAHKAKAASICQQRHBEAgCCAHKQCJATcAESAIQRhqIAdBkAFqKAAANgAAIAggBy0AiAE6ABAgCCARNgIMIAggAjYCCCAIQgI3AwAMFQsgB0GAAWogEUEAQQhB6AMQoBggBygChAEhAiAHKAKAAUEBRg0HIAdBADYCZCAHIAcoAogBNgJgIAcgAjYCXCARQQBKBEADQCAHQYABaiENQgAhWUEAIS1BACEuQQAhREEAITZBACE3QgAhUkIAIVpCACFbQgAhXEIAIVEjAEHgCWsiCiQAIApB+ANqIAQQ8CcgCkEoaiIyIApBhARqIgIoAgA2AgAgCiAKKQL8AzcDIAJAIAooAvgDIgZBBEcEQCAKKAKIBCECIA0gCikDIDcCDCANIAI2AhggDSAGNgIIIA1CAjcDACANQRRqIDIoAgA2AgAMAQsgCkGAB2oiBiAyKAIANgIAIAogCikDIDcD+AYgCkH4BmoQhjAgCkGAgICAeDYCACAKQgI3AyAgCkGBgICAeDYCoAMgCkGAgICAeDYCuAMgCkH4A2ogBBDTCSAGIAIpAgA3AwAgCkGIB2oiGyAKQYwEaigCADYCACAKIAopAvwDNwP4BgJAAkACQAJAAkACQAJAIAooAvgDRQRAIApB/ANqIRggCkE8aiFKIApBlARqIUsgCkGABGohPyAKQaQDaiFAA0AgCkHYA2ogGygCACICNgIAIApB0ANqIApBgAdqIiMpAwA3AwAgCiAKKQP4BjcDyAMCQAJAAkAgAkH/AXEEQCAKQfgDaiAKQcgDahD8FyAKLwH8AyECIAooAvgDIgZBBEcEQCANIAopAf4DNwEOIA1BFGogCkGEBGopAQA3AQAgDSACOwEMIA0gBjYCCCANQgI3AwAMDAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkEBaw4JAgMEBQAHAQkKCwsgCkH4A2ogBBDAHAJAIAooAvgDRQRAIAooAoAEIS0MAQsgCikDgAQiTqchLSAKKAL8AyICQQRHDQYLQQEhRAwOCyAKQfgDaiAEEMAcAkAgCigC+ANFBEAgCigCgAQhLgwBCyAKKQOABCJOpyEuIAooAvwDIgJBBEcNBwtBASE2DA0LIApB+ANqIAQQwhUgIyAYQQhqKAIANgIAIAogGCkCADcD+AYgCigC+AMiAkEERg0KIAooAogEIQYgDSAKKQP4BjcCDCANIAY2AhggDSACNgIIIA1CAjcDACANQRRqIApBgAdqKAIANgIADBQLIApB+ANqIAQQwBwgCigC+AMNEiAKKQOABCFZQQEhN0IBIVIMCwsgCkH4A2ohBkEAISBBACEzQQAhJkEAIRZBACEnQQAhKEIAIWJCACFjQgAhZEEAISlCACFlQgAhZkIAIWdCACFoQgAhaUIAIWpCACFrQgAhbEIAIW1CACFuIwBBsAVrIgIkACACQegDaiAEEPAnIAJBmAJqIjAgAkH0A2oiBSgCADYCACACIAIpAuwDNwOQAgJAIAIoAugDIglBBEcEQCACKAL4AyEFIAYgAikDkAI3AgwgBiAFNgIYIAYgCTYCCCAGQgI3AwAgBkEUaiAwKAIANgIADAELIAJBiAFqIkEgMCgCADYCACACIAIpA5ACNwOAASACQYABahCGMCACQQA2AgAgAkGAgICAeDYCCCACQYCAgIB4NgIYIAJBADYCKCACQgA3AzAgAkIANwNAIAJCADcDUCACQYCAgIB4NgJgIAJCADcDcCACQgI3A4ABIAJBgICAgHg2AtgBIAJCAjcD6AEgAkIDNwOQAiACQegDaiAEENMJIAJB4ARqIAUpAgA3AwAgAkHoBGoiJCACQfwDaigCADYCACACIAIpAuwDNwPYBCACQfACaiFFAkACQCACKALoA0UEQCACQewDaiEaIAJBnAFqIUwgAkGEBGohOSACQfADaiEZIAJBhAJqIUYgAkHwAWohQiACQawCaiFNA0AgAkGQA2ogJCgCACIFNgIAIAJBiANqIAJB4ARqIh0pAwA3AwAgAiACKQPYBDcDgAMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAVB/wFxBEAgAkHoA2ogAkGAA2oQ/BcgAi8B7AMhBSACKALoAyIJQQRHBEAgBiACKQHuAzcBDiAGQRRqIAJB9ANqKQEANwEAIAYgBTsBDCAGIAk2AgggBkICNwMADBULAkACQAJAAkAgBUEBaw4RAAMSAREQDw4NDAsKCQgCBwYFCyACQegDaiAEEMAcIAIoAugDRQRAIAIoAvADISAMFAsgAikD8AMiTqchICACKALsAyIFQQRGDRMgBiACKQP4AzcCFCAGICA2AgwgBiAFNgIIIAZCAjcDACAGIE5CIIg+AhAMFwsgAkHoA2ogBBDAHCACKALoA0UEQCACKALwAyEzDBILIAIpA/ADIk6nITMgAigC7AMiBUEERg0RIAYgAikD+AM3AhQgBiAzNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQDBYLIAJB6ANqIAQQwBwgAigC6ANFBEAgAigC8AMhJkEBIRYMEwsgAikD8AMiTqchJkEBIRYgAigC7AMiBUEERg0SIAYgAikD+AM3AhQgBiAmNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQDBULIAJB6ANqIAQQyQ8gAigC7AMhCyACKALoAyIFQQRHBEAgBiACKQDxAzcAESAGQRhqIAJB+ANqKAAANgAAIAYgAi0A8AM6ABAgBiALNgIMIAYgBTYCCCAGQgI3AwAMFQsgAkHoA2ogC0EAQQRBBBCgGCACKALsAyEFIAIoAugDQQFHBEAgAkEANgLgBCACIAIoAvADNgLcBCACIAU2AtgEIAtBAEoEQANAIAJB6ANqIAQQwBwCQCACKALoA0UEQCACKALwAyEPDAELIAIpA/ADIk6nIQ8gAigC7AMiBUEERg0AIAYgAikD+AM3AhQgBiAPNgIMIAYgBTYCCCAGQgI3AwAgBiBOQiCIPgIQIAJB2ARqQQRBBBDgHgwYCyACKALgBCIFIAIoAtgERgRAIAJB2ARqQZiO0AAQnSgLIAIoAtwEIAVBAnRqIA82AgAgAiAFQQFqNgLgBCALQQFrIgsNAAsLIAJB8ANqIgUgHSgCADYCACACIAIpAtgENwPoAyACKAIIQYCAgIB4RwRAIAJBCGpBBEEEEOAeCyACQRBqIAUoAgA2AgAgAiACKQPoAzcDCAwSCyAFIAIoAvADQYiO0AAQ/S8ACyACQYADahCGMCACQegDaiAEEKgpIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakGIj9AAQRQgAhDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsgAkHoA2pBnI/QAEEYIAJBCGoQ9R0gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQbSP0ABBHSACQRhqEPUdIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakHRj9AAQRQgAkEoahDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsgAkHoA2pB5Y/QAEEZIAJBMGoQ5h4gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQf6P0ABBJiACQUBrEOYeIAIoAugDIgVBBEcEQCAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwVCyACQegDakGkkNAAQSQgAkHQAGoQ5h4gAigC6AMiBUEERwRAIAYgAikC7AM3AgwgBkEUaiACQfQDaikCADcCACAGQgI3AwAgBiAFNgIIDBULIAJB6ANqQciQ0ABBHyACQfAAahDmHiACKALoAyIFQQRHBEAgBiACKQLsAzcCDCAGQRRqIAJB9ANqKQIANwIAIAZCAjcDACAGIAU2AggMFQsCQAJAAkACQAJAAkACQCAnBEAgAigCCCIFQYCAgIB4Rg0BIAIoAhgiCUGAgICAeEYNAiAoRQ0DIGJQDQQgY1ANBSBkUA0GIClFDQcgAikCDCFOIAIpAhwhTyAGQTBqIAJBgAFqQdgA/AoAACAGQfQCaiACQeABaigCADYCACAGIAIpA9gBNwLsAiAGQYgBaiACQegBakEo/AoAACAGQbABaiACQZACakHwAPwKAAAgBiAzNgL8AiAGICA2AvgCIAYgTzcD2AIgBiAJNgLUAiAGIE43AswCIAYgBTYCyAIgBiBlNwPAAiAGIGY3A7gCIAYgZzcDsAIgBiBoNwOoAiAGICY2AqQCIAYgFjYCoAIgBiBpNwMoIAYgajcDICAGIGs3AxggBiBsNwMQIAYgbTcDCCAGIG43AwAgBkHoAmogAkHoAGooAgA2AgAgBiACKQNgNwLgAgwdC0H4/M8AQccAQeiQ0AAQyyQAC0H4/M8AQccAQfiQ0AAQyyQAC0H4/M8AQccAQYiR0AAQyyQAC0H4/M8AQccAQZiR0AAQyyQAC0H4/M8AQccAQaiR0AAQyyQAC0H4/M8AQccAQbiR0AAQyyQAC0H4/M8AQccAQciR0AAQyyQAC0H4/M8AQccAQdiR0AAQyyQACyACQegDaiAEIAItAJADQcAAEMkCIAIoAugDIgVBBEYNDyAGIAIpAuwDNwIMIAZBFGogAkH0A2opAgA3AgAgBkICNwMAIAYgBTYCCAwSCyACQegDaiEPIwBBwAJrIgUkACAFQeABaiAEEPAnIAVBkAFqIgkgBUHsAWoiCygCADYCACAFIAUpAuQBNwOIAQJAIAUoAuABIgxBBEcEQCAFKALwASELIA8gBSkDiAE3AgwgDyALNgIYIA8gDDYCCCAPQgM3AwAgD0EUaiAJKAIANgIADAELIAVBEGogCSgCADYCACAFIAUpA4gBNwMIIAVBCGoQhjAgBUGAgICAeDYCYCAFQeABaiAEENMJIAkgCykCADcDACAFQZgBaiITIAVB9AFqKAIANgIAIAUgBSkC5AE3A4gBAkACQCAFKALgAUUEQCAFQegBaiEUIAVB5AFqISpCAiFOA0AgBUGAAWogEygCACIJNgIAIAVB+ABqIAVBkAFqIispAwA3AwAgBSAFKQOIATcDcAJAAkAgCUH/AXEEQCAFQeABaiAFQfAAahD8FyAFLwHkASEJIAUoAuABIgtBBEcEQCAPIAUpAeYBNwEOIA9BFGogBUHsAWopAQA3AQAgDyAJOwEMIA8gCzYCCCAPQgM3AwAMBgsCQAJAIAlBAWsOAgABAwsgBUHgAWohC0IAIU5CACFPQgAhUEIAIVNCACFvQgAhcEIAIXFCACFyRAAAAAAAAAAAIXNEAAAAAAAAAAAhdEQAAAAAAAAAACF1RAAAAAAAAAAAIXZEAAAAAAAAAAAhd0QAAAAAAAAAACF4RAAAAAAAAAAAIXlEAAAAAAAAAAAheiMAQZABayIJJAAgCUH4AGogBBDwJyAJQegAaiIMIAlBhAFqIhIoAgA2AgAgCSAJKQJ8NwNgAkACQAJAIAkoAngiIUEERwRAIAkoAogBIRIgCyAJKQNgNwIMIAsgEjYCGCALICE2AgggC0ICNwMAIAtBFGogDCgCADYCAAwBCyAJQdAAaiAMKAIANgIAIAkgCSkDYDcDSCAJQcgAahCGMCAJQgA3AwggCUH4AGogBBDTCSAMIBIpAgA3AwAgCUHwAGoiISAJQYwBaigCADYCACAJIAkpAnw3A2ACQCAJKAJ4RQRAIAlB/ABqITFBACESA0AgCUHYAGogISgCACIMNgIAIAlB0ABqIAlB6ABqIkMpAwA3AwAgCSAJKQNgNwNIAkAgDEH/AXEEQCAJQfgAaiAJQcgAahD8FyAJLwF8ITogCSgCeCIMQQRHBEAgCyAJKQF+NwEOIAtBFGogCUGEAWopAQA3AQAgCyA6OwEMDAULAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCA6QQFrDggAAQIDBAUGBxALIAQoAhAiDEEHSw0HDBYLIAQoAhAiDEEHSw0HDBULIAQoAhAiDEEHSw0HDBQLIAQoAhAiDEEHSw0HQQggDEHEs84AELA7AAsgBCgCECIMQQdLDQcMEgsgBCgCECIMQQdLDQcMEQsgBCgCECIMQQdLDQcMEAsgBCgCECIMQQdLDQcMDwsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhc0IBIVAMCQsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdEIBIU8MCAsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdUIBIU4MBwsgBCAMQQhrNgIQIAQgBCgCDCIMQQhqNgIMIAwrAAAhdkEBIRJCASFyDAYLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXdCASFTDAULIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXhCASFvDAQLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXlCASFwDAMLIAQgDEEIazYCECAEIAQoAgwiDEEIajYCDCAMKwAAIXpCASFxDAILIAlB+ABqIAQgCS0AWEHAABDJAiAJKAJ4IgxBBEYNASALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCAAwECyAJIHY5A0AgCSByNwM4IAkgdTkDMCAJIE43AyggCSB0OQMgIAkgTzcDGCAJIHM5AxAgCSBQNwMIIAlByABqEIYwIAlB+ABqIAQQqCkgCSgCeCIMQQRHBEAgCyAJKQJ8NwIMIAtBFGogCUGEAWopAgA3AgAgC0ICNwMAIAsgDDYCCAwFCyAJQfgAakG4/M8AQRAgCUEIahDmHiAJKAJ4IgxBBEcEQCALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCACALQgI3AwAgCyAMNgIIDAULIAlB+ABqQcj8zwBBECAJQRhqEOYeIAkoAngiDEEERwRAIAsgCSkCfDcCDCALQRRqIAlBhAFqKQIANwIAIAtCAjcDACALIAw2AggMBQsgCUH4AGpB2PzPAEEQIAlBKGoQ5h4gCSgCeCIMQQRHBEAgCyAJKQJ8NwIMIAtBFGogCUGEAWopAgA3AgAgC0ICNwMAIAsgDDYCCAwFCyAJQfgAakHo/M8AQRAgCUE4ahDmHiAJKAJ4IgxBBEcEQCALIAkpAnw3AgwgC0EUaiAJQYQBaikCADcCACALQgI3AwAgCyAMNgIIDAULAkACQAJAIFBQRQRAIE9QDQEgTlANAiASRQ0DIAsgdjkDWCALIHU5A1AgCyB0OQNIIAsgczkDQCALIHo5AzggCyBxNwMwIAsgeTkDKCALIHA3AyAgCyB4OQMYIAsgbzcDECALIHc5AwggCyBTNwMADAgLQfj8zwBBxwBBwP3PABDLJAALQfj8zwBBxwBB0P3PABDLJAALQfj8zwBBxwBB4P3PABDLJAALQfj8zwBBxwBB8P3PABDLJAALIAlByABqEIYwIAlB+ABqIAQQ0wkgQyAxQQhqKQIANwMAICEgMUEQaigCADYCACAJIDEpAgA3A2AgCSgCeEUNAAsLIAsgCSkDYDcCCCALQgI3AwAgC0EYaiAhKAIANgIAIAtBEGogCUHoAGopAwA3AgAMAQsgCyAMNgIIIAtCAjcDACAJQcgAahCGMAsgCUGQAWokAAwBC0EIIAxBxLPOABCwOwALIAUpA+ABIk5CAlIEQCAFQYgBaiIJIBRB2AD8CgAAIAVBCGogCUHYAPwKAAAMBAsgBUGYAWogFEEQaigCACIJNgIAIAVBkAFqIBRBCGopAwAiTjcDACAFIBQpAwAiTzcDiAEgD0EYaiAJNgIAIA9BEGogTjcDACAPIE83AwggD0IDNwMADAYLIAVB4AFqIAQQyQ8gBSgC5AEhCyAFKALgASIJQQRHBEAgDyAFKQDpATcAESAPQRhqIAVB8AFqKAAANgAAIA8gBS0A6AE6ABAgDyALNgIMIA8gCTYCCCAPQgM3AwAMBgsgBUHgAWogC0EAQQRBBBCgGCAFKALkASEJIAUoAuABQQFHBEAgBUEANgKQASAFIAUoAugBNgKMASAFIAk2AogBIAtBAEoEQANAIAVB4AFqIAQQwBwCQCAFKALgAUUEQCAFKALoASEMDAELIAUpA+gBIk+nIQwgBSgC5AEiCUEERg0AIA8gBSkD8AE3AhQgDyAMNgIMIA8gCTYCCCAPQgM3AwAgDyBPQiCIPgIQIAVBiAFqEOk7DAkLIAUoApABIgkgBSgCiAFGBEAgBUGIAWpBkP7PABCdKAsgBSgCjAEgCUECdGogDDYCACAFIAlBAWo2ApABIAtBAWsiCw0ACwsgBUHoAWoiCSArKAIANgIAIAUgBSkCiAE3A+ABIAVB4ABqEJcwIAVB6ABqIAkoAgA2AgAgBSAFKQPgATcDYAwDCyAJIAUoAugBQYD+zwAQ/S8ACyAFQfAAahCGMCAFQeABaiAEEKgpIAUoAuABIglBBEcEQCAPIAUpAuQBNwIMIA9BFGogBUHsAWopAgA3AgAgD0IDNwMAIA8gCTYCCAwGCyAPQQhqIAVBCGpB2AD8CgAAIA8gTjcDACAPQegAaiAFQegAaigCADYCACAPIAUpA2A3AmAMBgsgBUHgAWogBCAFLQCAAUHAABDJAiAFKALgASIJQQRGDQAgDyAFKQLkATcCDCAPQRRqIAVB7AFqKQIANwIAIA9CAzcDACAPIAk2AggMAwsgBUHwAGoQhjAgBUHgAWogBBDTCSArICpBCGopAgA3AwAgEyAqQRBqKAIANgIAIAUgKikCADcDiAEgBSgC4AFFDQALCyAPIAUpA4gBNwIIIA9CAzcDACAPQRhqIBMoAgA2AgAgD0EQaiAFQZABaikDADcCAAwBCyAFQfAAahCGMAsgBUHgAGoQlzALIAVBwAJqJAAgAkHYA2oiBSAZQQhqKQMANwMAIAJB4ANqIgkgGUEQaigCADYCACACIBkpAwA3A9ADIAIpA+gDIk5CA1IEQCACQdgEaiA5QdQA/AoAACACQfgDaiILIAkoAgA2AgAgAkHwA2oiCSAFKQMANwMAIAIgAikD0AM3A+gDIAIpA5ACQgNSBEAgRRCXMAsgMCACKQPoAzcDACAwQQhqIAkpAwA3AwAgMEEQaiALKAIANgIAIAIgTjcDkAIgTSACQdgEakHUAPwKAAAMDwsgBiACKQPQAzcDCCAGQgI3AwAgBkEYaiACQeADaigCADYCACAGQRBqIAJB2ANqKQMANwMADBELIAJB6ANqIQlCACFOQgAhTyMAQfAAayIFJAAgBUHYAGogBBDwJyAFQcgAaiILIAVB5ABqIgwoAgA2AgAgBSAFKQJcNwNAAkAgBSgCWCIPQQRHBEAgBSgCaCEMIAkgBSkDQDcCDCAJIAw2AhggCSAPNgIIIAlCAjcDACAJQRRqIAsoAgA2AgAMAQsgBUEwaiALKAIANgIAIAUgBSkDQDcDKCAFQShqEIYwIAVBgICAgHg2AgggBUGAgICAeDYCGCAFQdgAaiAEENMJIAsgDCkCADcDACAFQdAAaiIMIAVB7ABqKAIANgIAIAUgBSkCXDcDQAJAAkAgBSgCWEUEQCAFQdwAaiEPA0AgBUE4aiAMKAIAIgs2AgAgBUEwaiAFQcgAaiISKQMANwMAIAUgBSkDQDcDKAJAAkACQCALQf8BcQRAIAVB2ABqIAVBKGoQ/BcgBS8BXCELIAUoAlgiFEEERwRAIAkgBSkBXjcBDiAJQRRqIAVB5ABqKQEANwEAIAkgCzsBDCAJIBQ2AgggCUICNwMADAcLAkACQAJAAkAgC0EBaw4DAAECAwsgBUHYAGogBBDAHCAFKAJYRQRAIAUpA2AhT0IBIU4MBwsgBSgCXCELIAUpA2AhTiAJIAUpA2g3AhQgCSBONwIMIAkgCzYCCCAJQgI3AwAMCQsgBUHYAGogBBDJDyAFKAJcIQsgBSgCWCIUQQRHBEAgCSAFKQBhNwARIAlBGGogBUHoAGooAAA2AAAgCSAFLQBgOgAQIAkgCzYCDCAJIBQ2AgggCUICNwMADAkLIAVB2ABqIAtBAEEIQQgQoBggBSgCXCEUIAUoAlhBAUYNAyAFQQA2AkggBSAFKAJgNgJEIAUgFDYCQCALQQBKBEADQCAFQdgAaiAEEMAcIAUoAlgEQCAFKAJcIQsgBSkDYCFOIAkgBSkDaDcCFCAJIE43AgwgCSALNgIIIAlCAjcDACAFQUBrEOM8DAsLIAUpA2AhUCAFKAJIIhQgBSgCQEYEQCAFQUBrQYj8zwAQsygLIAUoAkQgFEEDdGogUDcDACAFIBRBAWo2AkggC0EBayILDQALCyAFQeAAaiILIBIoAgA2AgAgBSAFKQJANwNYIAVBCGoQhTAgBUEQaiALKAIANgIAIAUgBSkDWDcDCAwFCyAFQdgAaiAEEMkPIAUoAlwhCyAFKAJYIhRBBEcEQCAJIAUpAGE3ABEgCUEYaiAFQegAaigAADYAACAJIAUtAGA6ABAgCSALNgIMIAkgFDYCCCAJQgI3AwAMCAsgBUHYAGogC0EAQQhBCBCgGCAFKAJcIRQgBSgCWEEBRg0DIAVBADYCSCAFIAUoAmA2AkQgBSAUNgJAIAtBAEoEQANAIAVB2ABqIAQQwBwgBSgCWARAIAUoAlwhCyAFKQNgIU4gCSAFKQNoNwIUIAkgTjcCDCAJIAs2AgggCUICNwMAIAVBQGsQ4zwMCgsgBSkDYCFQIAUoAkgiFCAFKAJARgRAIAVBQGtBqPzPABCzKAsgBSgCRCAUQQN0aiBQNwMAIAUgFEEBajYCSCALQQFrIgsNAAsLIAVB4ABqIgsgEigCADYCACAFIAUpAkA3A1ggBUEYahCFMCAFQSBqIAsoAgA2AgAgBSAFKQNYNwMYDAQLIAVB2ABqIAQgBS0AOEHAABDJAiAFKAJYIgtBBEYNAyAJIAUpAlw3AgwgCUEUaiAFQeQAaikCADcCACAJQgI3AwAgCSALNgIIDAYLIAVBKGoQhjAgBUHYAGogBBCoKSAFKAJYIgtBBEcEQCAJIAUpAlw3AgwgCUEUaiAFQeQAaikCADcCACAJQgI3AwAgCSALNgIIDAcLIAkgBSkDCDcCECAJIAUpAxg3AhwgCSBPNwMIIAkgTjcDACAJQRhqIAVBEGooAgA2AgAgCUEkaiAFQSBqKAIANgIADAcLIBQgBSgCYEH4+88AEP0vAAsgFCAFKAJgQZj8zwAQ/S8ACyAFQShqEIYwIAVB2ABqIAQQ0wkgEiAPQQhqKQIANwMAIAwgD0EQaigCADYCACAFIA8pAgA3A0AgBSgCWEUNAAsLIAkgBSkDQDcCCCAJQgI3AwAgCUEYaiAMKAIANgIAIAlBEGogBUHIAGopAwA3AgAMAQsgBUEoahCGMAsgBUEYahCFMCAFQQhqEIUwCyAFQfAAaiQAIB0gGUEIaikDADcDACAkIBlBEGooAgA2AgAgAiAZKQMANwPYBCACKQPoAyJOQgJSBEAgAkHYA2oiBSA5QQhqKAIANgIAIAIgOSkCADcD0AMgAkH4A2oiCSAkKAIANgIAIAJB8ANqIgsgHSkDADcDACACIAIpA9gENwPoAyACQegBahDTLiBCIAIpA+gDNwMAIEJBCGogCykDADcDACBCQRBqIAkoAgA2AgAgRiACKQPQAzcCACBGQQhqIAUoAgA2AgAgAiBONwPoAQwOCyAGIAIpA9gENwMIIAZCAjcDACAGQRhqIAJB6ARqKAIANgIAIAZBEGogAkHgBGopAwA3AwAMEAsgAkHoA2ogBBDAHCACKALoA0UEQCACKQPwAyFpQgEhagwNCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwPCyACQegDaiAEEMkPIAIoAuwDIQsgAigC6AMiBUEERwRAIAYgAikA8QM3ABEgBkEYaiACQfgDaigAADYAACAGIAItAPADOgAQIAYgCzYCDCAGIAU2AgggBkICNwMADA8LIAJB6ANqIAtBAEEEQQwQoBggAigC7AMhBQJAIAIoAugDQQFHBEAgAkEANgLYAyACIAIoAvADNgLUAyACIAU2AtADIAtBAEwNAQNAIAJB6ANqIQlBACEqQQAhD0EAIRRBACETQQAhEiMAQeAAayIFJAAgBUHIAGogBBDwJyAFQThqIgwgBUHUAGoiISgCADYCACAFIAUpAkw3AzACQCAFKAJIIjFBBEcEQCAFKAJYIQ8gCSAFKQMwNwIEIAkgDzYCECAJIDE2AgAgCUEMaiAMKAIANgIADAELIAVBIGogDCgCADYCACAFIAUpAzA3AxggBUEYahCGMCAFQcgAaiAEENMJIAwgISkCADcDACAFQUBrIiEgBUHcAGooAgA2AgAgBSAFKQJMNwMwIAUoAkhFBEAgBUHMAGohMUEAIQwDQCAFQShqICEoAgAiKzYCACAFQSBqIAVBOGoiOikDADcDACAFIAUpAzA3AxgCQAJAICtB/wFxBEAgBUHIAGogBUEYahD8FyAFLwFMISsgBSgCSCJDQQRHBEAgCSAFKQFONwEGIAlBDGogBUHUAGopAQA3AQAgCSArOwEEIAkgQzYCAAwCCwJAAkACQAJAAkACQCArQQFrDgMAAQIFCyAFQcgAaiAEEMAcAkAgBSgCSEUEQCAFKAJQIRQMAQsgBSkDUCJOpyEUIAUoAkwiD0EERw0DC0EBIQ8MBwsgBUHIAGogBBDAHAJAIAUoAkhFBEAgBSgCUCETDAELIAUpA1AiTqchEyAFKAJMIipBBEcNAwtBASEqDAYLIAVByABqIAQQwBwgBSgCSEUEQCAFKAJQIRJBASEMDAYLIAUpA1AiTqchEkEBIQwgBSgCTCIrQQRGDQUgCSAFKQNYNwIMIAkgEjYCBCAJICs2AgAgCSBOQiCIPgIIDAQLIAkgBSkDWDcCDCAJIBQ2AgQgCSAPNgIAIAkgTkIgiD4CCAwDCyAJIAUpA1g3AgwgCSATNgIEIAkgKjYCACAJIE5CIIg+AggMAgsgBUHIAGogBCAFLQAoQcAAEMkCIAUoAkgiK0EERg0CIAkgBSkCTDcCBCAJQQxqIAVB1ABqKQIANwIAIAkgKzYCAAwBCyAFIBI2AhQgBSAMNgIQIAUgEzYCDCAFICo2AgggBSAUNgIEIAUgDzYCACAFQRhqEIYwIAVByABqIAQQqCkgBSgCSCIhQQRHBEAgCSAFKQJMNwIEIAlBDGogBUHUAGopAgA3AgAgCSAhNgIADAULIAVByABqQYyN0ABBGyAFEOYeIAUoAkgiIUEERwRAIAkgBSkCTDcCBCAJQQxqIAVB1ABqKQIANwIAIAkgITYCAAwFCyAFQcgAakGnjdAAQRogBUEIahDmHiAFKAJIIiFBBEcEQCAJIAUpAkw3AgQgCUEMaiAFQdQAaikCADcCACAJICE2AgAMBQsgBUHIAGpBwY3QAEEXIAVBEGoQ5h4gBSgCSCIhQQRHBEAgCSAFKQJMNwIEIAlBDGogBUHUAGopAgA3AgAgCSAhNgIADAULAkACQCAPBEAgKkUNASAMRQ0CIAkgEjYCDCAJIBM2AgggCSAUNgIEIAlBBDYCAAwHC0H4/M8AQccAQdiN0AAQyyQAC0H4/M8AQccAQeiN0AAQyyQAC0H4/M8AQccAQfiN0AAQyyQACyAFQRhqEIYwDAMLIAVBGGoQhjAgBUHIAGogBBDTCSA6IDFBCGopAgA3AwAgISAxQRBqKAIANgIAIAUgMSkCADcDMCAFKAJIRQ0ACwsgCSAFKQMwNwIAIAlBEGogISgCADYCACAJQQhqIAVBOGopAwA3AgALIAVB4ABqJAAgHSAaQQhqKAIANgIAIAIgGikCADcD2AQgAigC6AMiBUEERwRAIAIoAvgDIQkgBiACKQPYBDcCDCAGIAk2AhggBiAFNgIIIAZCAjcDACAGQRRqIAJB4ARqKAIANgIAIAJB0ANqQQRBDBDgHgwSCyACQcgDaiIJIB0oAgA2AgAgAiACKQPYBDcDwAMgAigC2AMiBSACKALQA0YEQCACQdADakH4jtAAEJAoCyACKALUAyAFQQxsaiIMIAIpA8ADNwIAIAxBCGogCSgCADYCACACIAVBAWo2AtgDIAtBAWsiCw0ACwwBCyAFIAIoAvADQeiO0AAQ/S8ACyACQfADaiIFIAJB2ANqKAIANgIAIAIgAikC0AM3A+gDIAIoAtgBQYCAgIB4RwRAIAJB2AFqQQRBDBDgHgsgAkHgAWogBSgCADYCACACIAIpA+gDNwPYAQwLCyACQegDaiEJQgAhTkIAIU9CACFQQgAhUyMAQZABayIFJAAgBUH4AGogBBDwJyAFQegAaiILIAVBhAFqIgwoAgA2AgAgBSAFKQJ8NwNgAkAgBSgCeCIPQQRHBEAgBSgCiAEhDCAJIAUpA2A3AgwgCSAMNgIYIAkgDzYCCCAJQgI3AwAgCUEUaiALKAIANgIADAELIAVB0ABqIAsoAgA2AgAgBSAFKQNgNwNIIAVByABqEIYwIAVBgICAgHg2AgggBUGAgICAeDYCGCAFQYCAgIB4NgIoIAVBgICAgHg2AjggBUH4AGogBBDTCSALIAwpAgA3AwAgBUHwAGoiFCAFQYwBaigCADYCACAFIAUpAnw3A2ACQAJAAkACQCAFKAJ4RQRAIAVB/ABqIQtBAiESQQIhDANAIAVB2ABqIBQoAgAiEzYCACAFQdAAaiAFQegAaiIPKQMANwMAIAUgBSkDYDcDSAJAAkAgE0H/AXEEQCAFQfgAaiAFQcgAahD8FyAFLwF8IRMgBSgCeCIqQQRHBEAgCSAFKQF+NwEOIAlBFGogBUGEAWopAQA3AQAgCSATOwEMIAkgKjYCCCAJQgI3AwAMCAsCQAJAAkACQAJAAkACQAJAAkAgE0EBaw4IAAECAwQFBgcICyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRGDQkgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwPCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwPCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBGGoQhjAgBUEgaiATKAIANgIAIAUgBSkDeDcDGAwJCyAFQfgAaiAEEMAcIAUoAngNDCAFKQOAASFQQgEhTgwICyAFQfgAaiAEEMAcIAUoAngNCiAFKQOAASFTQgEhTwwHCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwMCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBKGoQhjAgBUEwaiATKAIANgIAIAUgBSkDeDcDKAwGCyAFQfgAaiAEEKURIA8gC0EIaigCADYCACAFIAspAgA3A2AgBSgCeCITQQRHBEAgBSgCiAEhCyAJIAUpA2A3AgwgCSALNgIYIAkgEzYCCCAJQgI3AwAgCUEUaiAFQegAaigCADYCAAwLCyAFQYABaiITIA8oAgA2AgAgBSAFKQNgNwN4IAVBOGoQhjAgBUFAayATKAIANgIAIAUgBSkDeDcDOAwFCyAFQfgAaiAEENoQIAUtAHwhEiAFKAJ4IhNBBEYNBCAJIAUpAH03AA0gCUEUaiAFQYQBaikAADcAACAJIBI6AAwgCSATNgIIIAlCAjcDAAwJCyAFQfgAaiAEENoQIAUtAHwhDCAFKAJ4IhNBBEYNAyAJIAUpAH03AA0gCUEUaiAFQYQBaikAADcAACAJIAw6AAwgCSATNgIIIAlCAjcDAAwICyAFQfgAaiAEIAUtAFhBwAAQyQIgBSgCeCITQQRGDQIgCSAFKQJ8NwIMIAlBFGogBUGEAWopAgA3AgAgCUICNwMAIAkgEzYCCAwHCyAFQcgAahCGMCAFQfgAaiAEEKgpIAUoAngiC0EERwRAIAkgBSkCfDcCDCAJQRRqIAVBhAFqKQIANwIAIAlCAjcDACAJIAs2AggMCAsgCSAFKQMINwIgIAkgBSkDGDcCLCAJIAUpAyg3AjggCSAFKQM4NwJEIAkgEjoAUCAJIAw6AFEgCSBTNwMYIAkgTzcDECAJIFA3AwggCSBONwMAIAlBKGogBUEQaigCADYCACAJQTRqIAVBIGooAgA2AgAgCUFAayAFQTBqKAIANgIAIAlBzABqIAVBQGsoAgA2AgAMCAsgBUGAAWoiEyAPKAIANgIAIAUgBSkDYDcDeCAFQQhqEIYwIAVBEGogEygCADYCACAFIAUpA3g3AwgLIAVByABqEIYwIAVB+ABqIAQQ0wkgDyALQQhqKQIANwMAIBQgC0EQaigCADYCACAFIAspAgA3A2AgBSgCeEUNAAsLIAkgBSkDYDcCCCAJQgI3AwAgCUEYaiAUKAIANgIAIAlBEGogBUHoAGopAwA3AgAMAwsgBSgCfCELIAUpA4ABIU4gCSAFKQOIATcCFCAJIE43AgwgCSALNgIIIAlCAjcDAAwBCyAFKAJ8IQsgBSkDgAEhTiAJIAUpA4gBNwIUIAkgTjcCDCAJIAs2AgggCUICNwMACyAFQcgAahCGMAsgBUE4ahCGMCAFQShqEIYwIAVBGGoQhjAgBUEIahCGMAsgBUGQAWokACACQdgDaiIFIBlBCGopAwA3AwAgAkHgA2oiCSAZQRBqKAIANgIAIAIgGSkDADcD0AMgAikD6AMiTkICUgRAIAJB2ARqIgsgOUE8/AoAACACQfgDaiIMIAkoAgA2AgAgAkHwA2oiCSAFKQMANwMAIAIgAikD0AM3A+gDIAJBgAFqEPErIEEgAikD6AM3AwAgQUEIaiAJKQMANwMAIEFBEGogDCgCADYCACACIE43A4ABIEwgC0E8/AoAAAwLCyAGIAIpA9ADNwMIIAZCAjcDACAGQRhqIAJB4ANqKAIANgIAIAZBEGogAkHYA2opAwA3AwAMDQsgAkHoA2ogBBDAHCACKALoA0UEQCACKQPwAyFrQgEhbAwKCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwMCyACQegDaiAEEMAcIAIoAugDRQRAIAIpA/ADIW1CASFuDAkLIAIoAuwDIQUgAikD8AMhTiAGIAIpA/gDNwIUIAYgTjcCDCAGIAU2AgggBkICNwMADAsLIAJB6ANqIAQQwBwgAigC6ANFBEAgAiACKQPwAyJlNwN4IAJCATcDcEEBISkMCAsgAigC7AMhBSACKQPwAyFOIAYgAikD+AM3AhQgBiBONwIMIAYgBTYCCCAGQgI3AwAMCgsgAkHoA2ogBBDJDyACKALsAyEPIAIoAugDIgVBBEcEQCAGIAIpAPEDNwARIAZBGGogAkH4A2ooAAA2AAAgBiACLQDwAzoAECAGIA82AgwgBiAFNgIIIAZCAjcDAAwKCyACQegDaiAPQQBBBEEYEKAYIAIoAuwDIQUgAigC6ANBAUcEQCACQQA2AtgDIAIgAigC8AM2AtQDIAIgBTYC0AMgD0EASgRAA0AgAkHoA2ogBBCyBiAdIBpBCGopAgA3AwAgJCAaQRBqKAIANgIAIAIgGikCADcD2AQgAigC6AMiC0GAgICAeEYEQCAGIAIpA9gENwIIIAZCAjcDACAGQRhqIAJB6ARqKAIANgIAIAZBEGogAkHgBGopAwA3AgAgAkHQA2oiBhDgKSAGQQRBGBDgHgwNCyACQbgDaiIMICQoAgA2AgAgAkGwA2oiEiAdKQMANwMAIAIgAikD2AQ3A6gDIAIoAtgDIgkgAigC0ANGBEAgAkHQA2pB2I7QABCRKAsgAigC1AMgCUEYbGoiBSACKQOoAzcCBCAFIAs2AgAgBUEMaiASKQMANwIAIAVBFGogDCgCADYCACACIAlBAWo2AtgDIA9BAWsiDw0ACwsgAkHwA2oiBSACQdgDaigCADYCACACIAIpAtADNwPoAyACQeAAahCuLyACQegAaiAFKAIANgIAIAIgAikD6AM3A2AMBwsgBSACKALwA0HIjtAAEP0vAAsgAkHoA2ogBBDAHCACKALoA0UEQCACIAIpA/ADImY3A1hCASFkIAJCATcDUAwGCyACKALsAyEFIAIpA/ADIU4gBiACKQP4AzcCFCAGIE43AgwgBiAFNgIIIAZCAjcDAAwICyACQegDaiAEEMAcIAIoAugDRQRAIAIgAikD8AMiZzcDSEIBIWMgAkIBNwNADAULIAIoAuwDIQUgAikD8AMhTiAGIAIpA/gDNwIUIAYgTjcCDCAGIAU2AgggBkICNwMADAcLIAJB6ANqIAQQwBwgAigC6ANFBEAgAiACKQPwAyJoNwM4QgEhYiACQgE3AzAMBAsgAigC7AMhBSACKQPwAyFOIAYgAikD+AM3AhQgBiBONwIMIAYgBTYCCCAGQgI3AwAMBgsgAkHoA2ogBBDJDyACKALsAyELIAIoAugDIgVBBEcEQCAGIAIpAPEDNwARIAZBGGogAkH4A2ooAAA2AAAgBiACLQDwAzoAECAGIAs2AgwgBiAFNgIIIAZCAjcDAAwGCyACQegDaiALQQBBBEEMEKAYIAIoAuwDIQUgAigC6ANBAUcEQCACQQA2AtgDIAIgAigC8AM2AtQDIAIgBTYC0AMgC0EASgRAA0AgAkHoA2ogBBDCFSAdIBpBCGooAgA2AgAgAiAaKQIANwPYBCACKALoAyIFQQRHBEAgAigC+AMhCSAGIAIpA9gENwIMIAYgCTYCGCAGIAU2AgggBkICNwMAIAZBFGogAkHgBGooAgA2AgAgAkHQA2oiBhDRKyAGEOg7DAkLIAJBoANqIgkgHSgCADYCACACIAIpA9gENwOYAyACKALYAyIFIAIoAtADRgRAIAJB0ANqQbiO0AAQkCgLIAIoAtQDIAVBDGxqIgwgAikDmAM3AgAgDEEIaiAJKAIANgIAIAIgBUEBajYC2AMgC0EBayILDQALCyACQfADaiIFIAJB2ANqKAIANgIAIAIgAikC0AM3A+gDIAJBGGoQmDAgAkEgaiAFKAIANgIAIAIgAikD6AM3AxgMAwsgBSACKALwA0GojtAAEP0vAAsgAiAzNgIsQQEhKCACQQE2AigMAQsgAiAgNgIEQQEhJyACQQE2AgALIAJBgANqEIYwIAJB6ANqIAQQ0wkgHSAaQQhqKQIANwMAICQgGkEQaigCADYCACACIBopAgA3A9gEIAIoAugDRQ0ACwsgBiACKQPYBDcCCCAGQgI3AwAgBkEYaiAkKAIANgIAIAZBEGogAkHgBGopAwA3AgAMAQsgAkGAA2oQhjALIAIpA5ACQgNSBEAgRRCXMAsgAkHoAWoQ0y4gAigC2AFBgICAgHhHBEAgAkHYAWpBBEEMEOAeCyACQYABahDxKyACQeAAahCuLyACQRhqEJgwIAIoAghBgICAgHhGDQAgAkEIakEEQQQQ4B4LIAJBsAVqJAAgCkHoA2oiAiA/QQhqKQMANwMAIApB8ANqIgYgP0EQaigCADYCACAKID8pAwA3A+ADIAopA/gDIk5CAlENECAKQfgGaiIFIEtB5AL8CgAAIApBiARqIgkgBigCADYCACAKQYAEaiIGIAIpAwA3AwAgCiAKKQPgAzcD+AMgCkEgahCsICAyIAopA/gDNwMAIDJBCGogBikDADcDACAyQRBqIAkoAgA2AgAgCiBONwMgIEogBUHkAvwKAAAMCgsgCkH4A2ogBBDAHCAKKAL4Aw0OIAopA4AEIVpCASFbDAkLIA0gCikDiAQ3AhQgDSAtNgIMIA0gAjYCCCANQgI3AwAgDSBOQiCIPgIQDBALIApB+ANqIAQQwBwgCigC+AMNCyAKKQOABCFcQgEhUQwHCyANIAopA4gENwIUIA0gLjYCDCANIAI2AgggDUICNwMAIA0gTkIgiD4CEAwOCyAKQfgDaiEJIwBBgAFrIgYkACAGQYGAgIB4NgIIIAZB6ABqIAQQ8CcgBkFAayICIAZB9ABqIgUoAgA2AgAgBiAGKQJsNwM4AkACQCAGKAJoIgtBBEcEQCAGKAJ4IQUgCSAGKQM4NwIIIAkgBTYCFCAJIAs2AgQgCUGBgICAeDYCACAJQRBqIAIoAgA2AgAMAQsgBkHYAGogAigCADYCACAGIAYpAzg3A1AgBkHQAGoQhjAgBkHoAGogBBDTCSACIAUpAgA3AwAgBkHIAGoiICAGQfwAaigCADYCACAGIAYpAmw3AzgCQCAGKAJoRQRAIAZBxABqIRMgBkE8aiEaIAZB7ABqIQxBACESA0AgBkEwaiAgKAIAIgI2AgAgBkEoaiAGQUBrIhQpAwA3AwAgBiAGKQM4NwMgAkACQCACQf8BcQRAIAZB6ABqIAZBIGoQ/BcgBi8BbCECIAYoAmgiBUEERwRAIAkgBikBbjcBCiAJQRBqIAZB9ABqKQEANwEAIAkgAjsBCCAJIAU2AgQgCUGBgICAeDYCAAwGCwJAAkACQCACQQFrDgIAAQILIAZB6ABqIAQQ+gogBigCaCICQQRHBEAgCSAGKQJsNwIIIAlBEGogBkH0AGopAgA3AgAgCUGBgICAeDYCACAJIAI2AgQMCAsgBigCCEGBgICAeEcNBCAGQQhqENQuIAZBgICAgHg2AggMBAsgBkHoAGohBSMAQZABayICJAAgAkHYAGogBBDwJyACQcgAaiILIAJB5ABqIg8oAgA2AgAgAiACKQJcNwNAAkAgAigCWCIWQQRHBEAgAigCaCEPIAUgAikDQDcCCCAFIA82AhQgBSAWNgIEIAVBgICAgHg2AgAgBUEQaiALKAIANgIADAELIAJBMGogCygCADYCACACIAIpA0A3AyggAkEoahCGMCACQYCAgIB4NgIIIAJBgICAgHg2AhggAkHYAGogBBDTCSALIA8pAgA3AwAgAkHQAGoiHSACQewAaigCADYCACACIAIpAlw3A0ACQAJAIAIoAlhFBEAgAkHcAGohCwNAIAJBOGogHSgCACIWNgIAIAJBMGogAkHIAGoiDykDADcDACACIAIpA0A3AygCQAJAAkAgFkH/AXEEQCACQdgAaiACQShqEPwXIAIvAVwhFiACKAJYIhlBBEcEQCAFIAIpAV43AQogBUEQaiACQeQAaikBADcBACAFIBY7AQggBSAZNgIEIAVBgICAgHg2AgAMBwsCQAJAAkAgFkEBaw4CAAECCyACQdgAaiAEEMkPIAIoAlwhFiACKAJYIhlBBEcEQCAFIAIpAGE3AA0gBUEUaiACQegAaigAADYAACAFIAItAGA6AAwgBSAWNgIIIAUgGTYCBCAFQYCAgIB4NgIADAkLIAJB2ABqIBZBAEEEQQwQoBggAigCXCEZIAIoAlhBAUYNAyACQQA2AnwgAiACKAJgNgJ4IAIgGTYCdCAWQQBKBEADQCACQdgAaiAEEMIVIA8gC0EIaigCADYCACACIAspAgA3A0AgAigCWCIZQQRHBEAgAigCaCELIAUgAikDQDcCCCAFIAs2AhQgBSAZNgIEIAVBgICAgHg2AgAgBUEQaiACQcgAaigCADYCACACQfQAaiIFENErIAUQ6DsMCwsgAkGIAWoiJiAPKAIANgIAIAIgAikDQDcDgAEgAigCfCIZIAIoAnRGBEAgAkH0AGpB+JHQABCQKAsgAigCeCAZQQxsaiIkIAIpA4ABNwIAICRBCGogJigCADYCACACIBlBAWo2AnwgFkEBayIWDQALCyACQeAAaiIWIAJB/ABqKAIANgIAIAIgAikCdDcDWCACQQhqEJgwIAJBEGogFigCADYCACACIAIpA1g3AwgMBQsgAkHYAGogBBClESAPIAtBCGooAgA2AgAgAiALKQIANwNAIAIoAlgiFkEERwRAIAIoAmghCyAFIAIpA0A3AgggBSALNgIUIAUgFjYCBCAFQYCAgIB4NgIAIAVBEGogAkHIAGooAgA2AgAMCAsgAkHgAGoiFiAPKAIANgIAIAIgAikDQDcDWCACQRhqEIYwIAJBIGogFigCADYCACACIAIpA1g3AxgMBAsgAkHYAGogBCACLQA4QcAAEMkCIAIoAlgiFkEERg0DIAUgAikCXDcCCCAFQRBqIAJB5ABqKQIANwIAIAVBgICAgHg2AgAgBSAWNgIEDAYLIAJBKGoQhjAgAkHYAGogBBCoKSACKAJYIgtBBEcEQCAFIAIpAlw3AgggBUEQaiACQeQAaikCADcCACAFQYCAgIB4NgIAIAUgCzYCBAwHCyACQdgAakGIktAAQSYgAkEIahD1HSACKAJYIgtBBEcEQCAFIAIpAlw3AgggBUEQaiACQeQAaikCADcCACAFQYCAgIB4NgIAIAUgCzYCBAwHCyACKAIIIgtBgICAgHhGDQEgBSACKQMYNwIMIAUgAikCDDcCBCAFIAs2AgAgBUEUaiACQSBqKAIANgIADAcLIBkgAigCYEHokdAAEP0vAAtB+PzPAEHHAEGwktAAEMskAAsgAkEoahCGMCACQdgAaiAEENMJIA8gC0EIaikCADcDACAdIAtBEGooAgA2AgAgAiALKQIANwNAIAIoAlhFDQALCyAFIAIpA0A3AgQgBUGAgICAeDYCACAFQRRqIB0oAgA2AgAgBUEMaiACQcgAaikDADcCAAwBCyACQShqEIYwCyACQRhqEIYwIAJBCGoQmDALIAJBkAFqJAAgBkHYAGoiAiAMQQhqKQIANwMAIAZB4ABqIgUgDEEQaigCADYCACAGIAwpAgA3A1AgBigCaCILQYCAgIB4Rg0CIBogBikDUDcCACAaQRBqIAUoAgA2AgAgGkEIaiACKQMANwIAIAYgCzYCOCAGKAIIQYGAgIB4RwRAIAZBOGoiAhDRKyACEOg7IBMQhjAMBAsgBkH4AGoiAiAgKQIANwMAIAZB8ABqIgUgFCkCADcDACAGIAYpAjg3A2ggBkEIahDULiAGQRhqIAIpAwA3AwAgBkEQaiAFKQMANwMAIAYgBikDaDcDCAwDCyAGQegAaiAEIAYtADBBwAAQyQIgBigCaCICQQRGDQIgCSAGKQJsNwIIIAlBEGogBkH0AGopAgA3AgAgCUGBgICAeDYCACAJIAI2AgQMBQsgBkEgahCGMCAGQegAaiAEEKgpIAYoAmgiAkEERwRAIAkgBikCbDcCCCAJQRBqIAZB9ABqKQIANwIAIAlBgYCAgHg2AgAgCSACNgIEDAYLAkAgEkUEQCAJQQhqQcCS0ABBNRCiHwwBCyASQQFMBEAgBkH4AGogBkEYaikDADcDACAGQfAAaiAGQRBqKQMANwMAIAYgBikDCDcDaCMAQSBrIgIkAAJAIAZB6ABqIgUoAgBBgYCAgHhHBEAgCSAFKQIANwIAIAlBEGogBUEQaikCADcCACAJQQhqIAVBCGopAgA3AgAMAQsgAkEQakGkgNAAQSkQoh8gCUGBgICAeDYCACAJQQxqIAJBFGopAgA3AgAgCUEUaiACQRxqKAIANgIAIAJBATYCDCAJIAIpAgw3AgQLIAJBIGokAAwICyAJQQhqQfWS0ABBwwAQoh8LIAlCgYCAgBg3AgAgBkEIahDULgwGCyAJIAYpA1A3AgQgCUGBgICAeDYCACAJQRRqIAZB4ABqKAIANgIAIAlBDGogBkHYAGopAwA3AgAMAwsgBkEgahCGMCAGQegAaiAEENMJIBQgDEEIaikCADcDACAgIAxBEGooAgA2AgAgBiAMKQIANwM4IBJBAWohEiAGKAJoRQ0ACwsgCSAGKQM4NwIEIAlBgYCAgHg2AgAgCUEUaiAgKAIANgIAIAlBDGogBkFAaykDADcCAAwBCyAGQSBqEIYwCyAGQQhqENQuCyAGQYABaiQAICMgGEEIaikCADcDACAbIBhBEGooAgA2AgAgCiAYKQIANwP4BiAKKAL4AyICQYGAgIB4Rg0IIApBiARqIgYgGygCADYCACAKQYAEaiIFICMpAwA3AwAgCiAKKQP4BjcD+AMgCkGgA2oQ1C4gQCAKKQP4AzcCACBAQQhqIAUpAwA3AgAgQEEQaiAGKAIANgIAIAogAjYCoAMMBQsgCkH4A2ogBBClESAjIBhBCGooAgA2AgAgCiAYKQIANwP4BiAKKAL4AyICQQRHBEAgCigCiAQhBiANIAopA/gGNwIMIA0gBjYCGCANIAI2AgggDUICNwMAIA1BFGogCkGAB2ooAgA2AgAMDQsgCkGABGoiAiAjKAIANgIAIAogCikD+AY3A/gDIApBuANqEIYwIApBwANqIAIoAgA2AgAgCiAKKQP4AzcDuAMMBAsgCkH4A2ogBCAKLQDYA0HAABDJAiAKKAL4AyICQQRGDQMgDSAKKQL8AzcCDCANQRRqIApBhARqKQIANwIAIA1CAjcDACANIAI2AggMCwsgCiBZNwMYIAogUjcDECAKQcgDahCGMCAKQfgDaiAEEKgpIAooAvgDIgJBBEcEQCANIAopAvwDNwIMIA1BFGogCkGEBGopAgA3AgAgDUICNwMAIA0gAjYCCAwMCyAKQfgDakG4k9AAQRcgCkEQahDmHiAKKAL4AyICQQRHBEAgDSAKKQL8AzcCDCANQRRqIApBhARqKQIANwIAIA1CAjcDACANIAI2AggMDAsgN0UNASANQSBqIApBIGpBgAP8CgAAIA0gWTcDyAMgDSAuNgKsAyANIDY2AqgDIA0gLTYCpAMgDSBENgKgAyANIFw3AxggDSBRNwMQIA0gWjcDCCANIFs3AwAgDUHAA2ogCkGwA2opAgA3AgAgDUG4A2ogCkGoA2opAgA3AgAgDSAKKQKgAzcCsAMgDSAKKQO4AzcC3AMgDUHkA2ogCkHAA2ooAgA2AgAgDSAKKQMANwLQAyANQdgDaiAKQQhqKAIANgIADAwLIApBgARqIgIgIygCADYCACAKIAopA/gGNwP4AyAKEIYwIApBCGogAigCADYCACAKIAopA/gDNwMADAELQfj8zwBBxwBB0JPQABDLJAALIApByANqEIYwIApB+ANqIAQQ0wkgIyAYQQhqKQIANwMAIBsgGEEQaigCADYCACAKIBgpAgA3A/gGIAooAvgDRQ0ACwsgDSAKKQP4BjcCCCANQgI3AwAgDUEYaiAbKAIANgIAIA1BEGogCkGAB2opAwA3AgAMBgsgDSAKKQP4BjcCCCANQgI3AwAgDUEYaiAKQYgHaigCADYCACANQRBqIApBgAdqKQMANwIADAQLIAooAvwDIQIgCikDgAQhTiANIAopA4gENwIUIA0gTjcCDCANIAI2AgggDUICNwMADAMLIAooAvwDIQIgCikDgAQhTiANIAopA4gENwIUIA0gTjcCDCANIAI2AgggDUICNwMADAILIA0gCikD4AM3AwggDUICNwMAIA1BGGogCkHwA2ooAgA2AgAgDUEQaiAKQegDaikDADcDAAwBCyAKKAL8AyECIAopA4AEIU4gDSAKKQOIBDcCFCANIE43AgwgDSACNgIIIA1CAjcDAAsgCkHIA2oQhjALIApBuANqEIYwIApBoANqENQuIApBIGoQrCAgChCGMAsgCkHgCWokACA0ID1BCGopAwA3AwAgFyA9QRBqKAIANgIAIAcgPSkDADcDaCAHKQOAASJOQgJRBEAgCCAHKQNoNwMIIAhCAjcDACAIQRhqIAdB+ABqKAIANgIAIAhBEGogB0HwAGopAwA3AwAgBygCZCIRBEAgBygCYCEMA0AgDBDYEyAMQegDaiEMIBFBAWsiEQ0ACwsgB0HcAGpBCEHoAxDgHgwXCyAHQewEaiBJQcwD/AoAACAHQcAIaiIKIDQpAwA3AwAgB0HICGoiBSAXKAIANgIAIAcgBykDaDcDuAggBygCZCIGIAcoAlxGBEAjAEEQayICJAAgAkEIaiAHQdwAaiINIA0oAgBBAUEIQegDELcRIAIoAggiDUGBgICAeEcEQCANIAIoAgxB8JPQABD9LwALIAJBEGokAAsgBygCYCAGQegDbGoiAiBONwMAIAIgBykDuAg3AwggAkEQaiAKKQMANwMAIAJBGGogBSgCADYCACACQRxqIAdB7ARqQcwD/AoAACAHIAZBAWo2AmQgEUEBayIRDQALCyAHQYgBaiICIAdB5ABqKAIANgIAIAcgBykCXDcDgAEgB0EIahDKKCAHQRBqIAIoAgA2AgAgByAHKQOAATcDCAwRCyAHQYABaiAEEMAcIAcoAoABDQ8gBykDiAEhV0IBIVYMEAsgB0GAAWogBBDAHCAHKAKAAQ0NIAcpA4gBIVhBASEvQgEhXwwPCyAHQYABaiAEEMkPIAcoAoQBIREgBygCgAEiAkEERwRAIAggBykAiQE3ABEgCEEYaiAHQZABaigAADYAACAIIActAIgBOgAQIAggETYCDCAIIAI2AgggCEICNwMADBILIAdBgAFqIBFBAEEEQQgQoBggBygChAEhAiAHKAKAAUEBRg0FIAdBADYCcCAHIAcoAogBNgJsIAcgAjYCaCARQQBMDQsDQCAHQYABaiEGQQAhGCMAQeAAayICJAAgAkHIAGogBBDwJyACQThqIgogAkHUAGoiBSgCADYCACACIAIpAkw3AzACQCACKAJIIg1BBEcEQCACKAJYIQUgBiACKQMwNwIEIAYgBTYCECAGIA02AgAgBkEMaiAKKAIANgIADAELIAJBIGogCigCADYCACACIAIpAzA3AxggAkEYahCGMCACQcgAaiAEENMJIAogBSkCADcDACACQUBrIgogAkHcAGooAgA2AgAgAiACKQJMNwMwIAIoAkhFBEAgAkHMAGohBUEAIQlBAiEPQQIhDQNAIAJBKGogCigCACILNgIAIAJBIGogAkE4aiIMKQMANwMAIAIgAikDMDcDGAJAAkAgC0H/AXEEQCACQcgAaiACQRhqEPwXIAIvAUwhCyACKAJIIhJBBEcEQCAGIAIpAU43AQYgBkEMaiACQdQAaikBADcBACAGIAs7AQQgBiASNgIADAILAkACQAJAAkAgC0EBaw4DAAECAwsgAkHIAGogBBDAHCACKAJIRQRAIAIoAlAhGEEBIQkMBgsgAikDUCJOpyEYQQEhCSACKAJMIgtBBEYNBSAGIAIpA1g3AgwgBiAYNgIEIAYgCzYCACAGIE5CIIg+AggMBAsgAkHIAGogBBDaECACLQBMIQ0gAigCSCILQQRGDQQgBiACKQBNNwAFIAZBDGogAkHUAGopAAA3AAAgBiANOgAEIAYgCzYCAAwDCyACQcgAaiAEENoQIAItAEwhDyACKAJIIgtBBEYNAyAGIAIpAE03AAUgBkEMaiACQdQAaikAADcAACAGIA86AAQgBiALNgIADAILIAJByABqIAQgAi0AKEHAABDJAiACKAJIIgtBBEYNAiAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAs2AgAMAQsgAiANOgAWIAIgDzoAFyACIBg2AhAgAiAJNgIMIAJBGGoQhjAgAkHIAGogBBCoKSACKAJIIgpBBEcEQCAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAo2AgAMBQsgAkHIAGpBkIzQAEEYIAJBDGoQ5h4gAigCSCIKQQRHBEAgBiACKQJMNwIEIAZBDGogAkHUAGopAgA3AgAgBiAKNgIADAULIAJByABqQaiM0ABBGCACQRZqEPQdIAIoAkgiCkEERwRAIAYgAikCTDcCBCAGQQxqIAJB1ABqKQIANwIAIAYgCjYCAAwFCyACQcgAakHAjNAAQRkgAkEXahD0HSACKAJIIgpBBEcEQCAGIAIpAkw3AgQgBkEMaiACQdQAaikCADcCACAGIAo2AgAMBQsCQAJAIAkEQCANQQJGDQEgD0ECRg0CIAYgDToACCAGIBg2AgQgBkEENgIAIAYgD0EBcToACQwHC0H4/M8AQccAQdyM0AAQyyQAC0H4/M8AQccAQeyM0AAQyyQAC0H4/M8AQccAQfyM0AAQyyQACyACQRhqEIYwDAMLIAJBGGoQhjAgAkHIAGogBBDTCSAMIAVBCGopAgA3AwAgCiAFQRBqKAIANgIAIAIgBSkCADcDMCACKAJIRQ0ACwsgBiACKQMwNwIAIAZBEGogCigCADYCACAGQQhqIAJBOGopAwA3AgALIAJB4ABqJAAgBykChAEhTiAHKAKAASICQQRHBEAgCCAHKQKMATcCFCAIIE43AgwgCCACNgIIIAhCAjcDACAHQegAakEEQQgQ4B4MEwsgBygCcCICIAcoAmhGBEAgB0HoAGpBkJTQABCbKAsgBygCbCACQQN0aiBONwIAIAcgAkEBajYCcCARQQFrIhENAAsMCwsgB0GAAWogBBDAHCAHKAKAAQ0JIAcpA4gBIWBCASFdDA0LIAdBgAFqIAQQwBwgBygCgAENByAHKQOIASFhQgEhXgwMCyAHQYABaiAEIActAFhBwAAQyQIgBygCgAEiAkEERg0LIAggBykChAE3AgwgCEEUaiAHQYwBaikCADcCACAIQgI3AwAgCCACNgIIDA4LIAcgWDcDMCAHIF83AyggByBXNwMgIAcgVjcDGCAHQcgAahCGMCAHQYABaiAEEKgpIAcoAoABIgJBBEcEQCAIIAcpAoQBNwIMIAhBFGogB0GMAWopAgA3AgAgCEICNwMAIAggAjYCCAwPCyAHQYABakGglNAAQRAgB0EIahD1HSAHKAKAASICQQRHBEAgCCAHKQKEATcCDCAIQRRqIAdBjAFqKQIANwIAIAhCAjcDACAIIAI2AggMDwsgB0GAAWpBsJTQAEEYIAdBGGoQ5h4gBygCgAEiAkEERwRAIAggBykChAE3AgwgCEEUaiAHQYwBaikCADcCACAIQgI3AwAgCCACNgIIDA8LIAdBgAFqQciU0ABBESAHQShqEOYeIAcoAoABIgJBBEcEQCAIIAcpAoQBNwIMIAhBFGogB0GMAWopAgA3AgAgCEICNwMAIAggAjYCCAwPCyAHKAIIIgJBgICAgHhGDQIgVlANAyAvRQ0EIAcpAgwhTiAIIAcpAzg3AjwgCCAsOwFKIAggJTsBSCAIIE43AjQgCCACNgIwIAggWDcDKCAIIFc3AyAgCCBhNwMYIAggXjcDECAIIGA3AwggCCBdNwMAIAhBxABqIAdBQGsoAgA2AgAMDwsgAiAHKAKIAUHgk9AAEP0vAAsgAiAHKAKIAUGAlNAAEP0vAAtB+PzPAEHHAEHclNAAEMskAAtB+PzPAEHHAEHslNAAEMskAAtB+PzPAEHHAEH8lNAAEMskAAsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBwsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBgsgB0GIAWoiAiA0KAIANgIAIAcgBykCaDcDgAEgBygCOEGAgICAeEcEQCAHQThqQQRBCBDgHgsgB0FAayACKAIANgIAIAcgBykDgAE3AzgMAgsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMBAsgBygChAEhAiAHKQOIASFOIAggBykDkAE3AhQgCCBONwIMIAggAjYCCCAIQgI3AwAMAwsgB0HIAGoQhjAgB0GAAWogBBDTCSA0ID5BCGopAgA3AwAgFyA+QRBqKAIANgIAIAcgPikCADcDaCAHKAKAAUUNAAsLIAggBykDaDcCCCAIQgI3AwAgCEEYaiAXKAIANgIAIAhBEGogB0HwAGopAwA3AgAMAQsgB0HIAGoQhjALIAcoAjhBgICAgHhHBEAgB0E4akEEQQgQ4B4LIAdBCGoQyigLIAdB0AhqJAAgHyA7QQhqKQMANwMAICIgO0EQaigCADYCACADIDspAwA3A9gDIAMpA7ABIk5CAlEEQCAOIAMpA9gDNwIEIA5BAzYCACAOQRRqIANB6ANqKAIANgIAIA5BDGogA0HgA2opAwA3AgAgA0G0A2oiAhD0GyACQQhB0AAQ4B4MGAsgA0HsAmogSEE0/AoAACADQagDaiIGIB8pAwA3AwAgA0GwA2oiCiAiKAIANgIAIAMgAykD2AM3A6ADIAMoArwDIgcgAygCtANGBEAjAEEQayICJAAgAkEIaiADQbQDaiIFIAUoAgBBAUEIQdAAELcRIAIoAggiBUGBgICAeEcEQCAFIAIoAgxB5JvQABD9LwALIAJBEGokAAsgAygCuAMgB0HQAGxqIgIgTjcDACACIAMpA6ADNwMIIAJBEGogBikDADcDACACQRhqIAooAgA2AgAgAkEcaiADQewCakE0/AoAACADIAdBAWo2ArwDIBVBAWsiFQ0ACwsgA0G4AWoiAiADQbwDaigCADYCACADIAMpArQDNwOwASADQShqELovIANBMGogAigCADYCACADIAMpA7ABNwMoDBELIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMFQsgA0GwAWogFUEAQQRBGBCgGCADKAK0ASECIAMoArABQQFGDQggA0EANgK8AyADIAMoArgBNgK4AyADIAI2ArQDIBVBAEoEQANAIANBsAFqIAQQsgYgHyAeQQhqKQIANwMAICIgHkEQaigCADYCACADIB4pAgA3A9gDIAMoArABIgZBgICAgHhGBEAgDiADKQPYAzcCBCAOQQM2AgAgDkEUaiADQegDaigCADYCACAOQQxqIANB4ANqKQMANwIAIANBtANqIgIQ4CkgAkEEQRgQ4B4MFwsgA0HQA2oiCiAiKAIANgIAIANByANqIgUgHykDADcDACADIAMpA9gDNwPAAyADKAK8AyIHIAMoArQDRgRAIANBtANqQYSc0AAQkSgLIAMoArgDIAdBGGxqIgIgAykDwAM3AgQgAiAGNgIAIAJBDGogBSkDADcCACACQRRqIAooAgA2AgAgAyAHQQFqNgK8AyAVQQFrIhUNAAsLIANBuAFqIgIgA0G8A2ooAgA2AgAgAyADKQK0AzcDsAEgA0E4ahCuLyADQUBrIAIoAgA2AgAgAyADKQOwATcDOAwQCyADQbABaiAEEMIVIB8gHkEIaigCADYCACADIB4pAgA3A9gDIAMoArABIgJBBEcEQCADKALAASEEIA4gAykD2AM3AgggDiAENgIUIA4gAjYCBCAOQQM2AgAgDkEQaiADQeADaigCADYCAAwUCyADQbgBaiICIB8oAgA2AgAgAyADKQPYAzcDsAEgA0HIAGoQhjAgA0HQAGogAigCADYCACADIAMpA7ABNwNIDA8LIANBsAFqIAQQyQ8gAygCtAEhFSADKAKwASICQQRHBEAgDiADKQC5ATcADSAOQRRqIANBwAFqKAAANgAAIA4gAy0AuAE6AAwgDiAVNgIIIA4gAjYCBCAOQQM2AgAMEwsgA0GwAWogFUEAQQFBABCgGCADKAK0ASECIAMoArABQQFGDQcgA0EANgLgAyADIAMoArgBNgLcAyADIAI2AtgDIBVBAEwNDQNAIANBsAFqIQdBACEJIwBB0ABrIgIkACACQThqIAQQ8CcgAkEoaiIGIAJBxABqIgooAgA2AgAgAiACKQI8NwMgAkAgAigCOCIFQQRHBEAgAigCSCEKIAcgAikDIDcCBCAHIAo2AhAgByAFNgIAIAdBDGogBigCADYCAAwBCyACQRBqIAYoAgA2AgAgAiACKQMgNwMIIAJBCGoQhjAgAkE4aiAEENMJIAYgCikCADcDACACQTBqIgYgAkHMAGooAgA2AgAgAiACKQI8NwMgAkAgAigCOEUEQCACQTxqIQpBACERA0AgAkEYaiAGKAIAIgU2AgAgAkEQaiACQShqIggpAwA3AwAgAiACKQMgNwMIAkACQCAFQf8BcQRAIAJBOGogAkEIahD8FyACLwE8IQUgAigCOCIMQQRHBEAgByACKQE+NwEGIAdBDGogAkHEAGopAQA3AQAgByAFOwEEDAYLIAVBAUYEQCACQThqIAQQ+gogAigCOCIMQQRGDQIgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAMBgsgAkE4aiAEIAItABhBwAAQyQIgAigCOCIMQQRGDQIgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAMBQsgAkEIahCGMCACQThqIAQQqCkgAigCOCIGQQRHBEAgByACKQI8NwIEIAdBDGogAkHEAGopAgA3AgAgByAGNgIADAYLIBFFBEAgB0EEakGMldAAQSwQoh8gB0EBNgIADAYLIBFBAUwEQCAJBEAgB0EENgIADAcLIAJBPGpBpIDQAEEpEKIfIAdBCGogAkFAaykCADcCACAHQRBqIAJByABqKAIANgIAIAJBATYCOCAHIAIpAjg3AgAMBgsgB0EEakG4ldAAQToQoh8gB0EBNgIADAULQQEhCQsgAkEIahCGMCACQThqIAQQ0wkgCCAKQQhqKQIANwMAIAYgCkEQaigCADYCACACIAopAgA3AyAgEUEBaiERIAIoAjhFDQALCyAHIAIpAyA3AgAgB0EQaiAGKAIANgIAIAdBCGogAkEoaikDADcCAAwBCyAHIAw2AgAgAkEIahCGMAsgAkHQAGokACADKAKwASICQQRHBEAgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQgA0HYA2pBAUEAEOAeDBQLIAMoAuADIgdBf0YEQCMAQRBrIgIkACACQQhqIANB2ANqIgYgBigCAEEBQQFBABC3ESACKAIIIgZBgYCAgHhHBEAgBiACKAIMQaSc0AAQ/S8ACyACQRBqJAALIAMgB0EBajYC4AMgFUEBayIVDQALDA0LIANBsAFqIQdBACEJIwBBkAFrIgIkACACQQI2AgAgAkHwAGogBBDwJyACQUBrIgYgAkH8AGoiCigCADYCACACIAIpAnQ3AzgCQAJAIAIoAnAiBUEERwRAIAIoAoABIQogByACKQM4NwIIIAcgCjYCFCAHIAU2AgQgB0ECNgIAIAdBEGogBigCADYCAAwBCyACQeAAaiAGKAIANgIAIAIgAikDODcDWCACQdgAahCGMCACQfAAaiAEENMJIAYgCikCADcDACACQcgAaiIIIAJBhAFqKAIANgIAIAIgAikCdDcDOCACKAJwRQRAIAJBxABqIREgAkE8aiEFIAJB9ABqIQYgAkEEaiEKA0AgAkEwaiAIKAIAIgs2AgAgAkEoaiACQUBrIg0pAwA3AwAgAiACKQM4NwMgAkACQAJAAkAgC0H/AXEEQCACQfAAaiACQSBqEPwXIAIvAXQhCyACKAJwIgxBBEcEQCAHIAIpAXY3AQogB0EQaiACQfwAaikBADcBACAHIAs7AQggByAMNgIEIAdBAjYCAAwDCwJAAkACQCALQQFrDgIAAQILIAJB8ABqIAQQpQYgAkHgAGoiCyAGQQhqKQIANwMAIAJB6ABqIgwgBkEQaigCADYCACACIAYpAgA3A1ggAigCcCIPQYGAgIB4RwRAIAIoAogBIRUgBSACKQNYNwIAIAVBEGogDCgCADYCACAFQQhqIAspAwA3AgAgAiAVNgJQIAIgDzYCOCACKAIAQQJHDQYgAkGIAWoiCyACQdAAaigCADYCACACQYABaiIMIAgpAgA3AwAgAkH4AGoiDyANKQIANwMAIAIgAikCODcDcCACELsuIAogAikDcDcCACAKQQhqIA8pAwA3AgAgCkEQaiAMKQMANwIAIApBGGogCygCADYCACACQQA2AgAMBwsgByACKQNYNwIEIAdBAjYCACAHQRRqIAJB6ABqKAIANgIAIAdBDGogAkHgAGopAwA3AgAMBAsgAkHwAGogBBClBiACQeAAaiILIAZBCGopAgA3AwAgAkHoAGoiDCAGQRBqKAIANgIAIAIgBikCADcDWCACKAJwIg9BgYCAgHhGDQIgAigCiAEhFSAFIAIpA1g3AgAgBUEQaiAMKAIANgIAIAVBCGogCykDADcCACACIBU2AlAgAiAPNgI4IAIoAgBBAkcNBCACQYgBaiILIAJB0ABqKAIANgIAIAJBgAFqIgwgCCkCADcDACACQfgAaiIPIA0pAgA3AwAgAiACKQI4NwNwIAIQuy4gCiACKQNwNwIAIApBCGogDykDADcCACAKQRBqIAwpAwA3AgAgCkEYaiALKAIANgIAIAJBATYCAAwFCyACQfAAaiAEIAItADBBwAAQyQIgAigCcCILQQRGDQQgByACKQJ0NwIIIAdBEGogAkH8AGopAgA3AgAgB0ECNgIAIAcgCzYCBAwCCyACQSBqEIYwIAJB8ABqIAQQqCkgAigCcCIGQQRHBEAgByACKQJ0NwIIIAdBEGogAkH8AGopAgA3AgAgB0ECNgIAIAcgBjYCBAwHCwJAIAlFBEAgB0EIakG8mtAAQTQQoh8MAQsgCUEBTARAIAJBiAFqIAJBGGopAgA3AwAgAkGAAWogAkEQaikCADcDACACQfgAaiACQQhqKQIANwMAIAIgAikCADcDcCMAQSBrIgYkAAJAIAJB8ABqIgooAgBBAkcEQCAHIAopAgA3AgAgB0EYaiAKQRhqKQIANwIAIAdBEGogCkEQaikCADcCACAHQQhqIApBCGopAgA3AgAMAQsgBkEQakGkgNAAQSkQoh8gB0ECNgIAIAdBDGogBkEUaikCADcCACAHQRRqIAZBHGooAgA2AgAgBkEBNgIMIAcgBikCDDcCBAsgBkEgaiQADAkLIAdBCGpB8JrQAEHCABCiHwsgB0KCgICAEDcCAAwGCyAHIAIpA1g3AgQgB0ECNgIAIAdBFGogAkHoAGooAgA2AgAgB0EMaiACQeAAaikDADcCAAsgAkEgahCGMAwECyACQThqEIYwIBEQhjALIAJBIGoQhjAgAkHwAGogBBDTCSANIAZBCGopAgA3AwAgCCAGQRBqKAIANgIAIAIgBikCADcDOCAJQQFqIQkgAigCcEUNAAsLIAcgAikDODcCBCAHQQI2AgAgB0EUaiAIKAIANgIAIAdBDGogAkFAaykDADcCAAsgAhC7LgsgAkGQAWokACAfIB5BCGopAgA3AwAgIiAeQRBqKAIANgIAIAMgHikCADcD2AMgAygCsAEiAkECRg0LIAMpAsgBIU4gA0HAAWoiByAiKAIANgIAIANBuAFqIgYgHykDADcDACADIAMpA9gDNwOwASADQegAahC7LiA8IAMpA7ABNwIAIDxBCGogBikDADcCACA8QRBqIAcoAgA2AgAgAyACNgJoIAMgTjcCgAEMDQsgA0GwAWogBBClESAfIB5BCGooAgA2AgAgAyAeKQIANwPYAyADKAKwASICQQRHBEAgAygCwAEhBCAOIAMpA9gDNwIIIA4gBDYCFCAOIAI2AgQgDkEDNgIAIA5BEGogA0HgA2ooAgA2AgAMEQsgA0G4AWoiAiAfKAIANgIAIAMgAykD2AM3A7ABIANBiAFqEIYwIANBkAFqIAIoAgA2AgAgAyADKQOwATcDiAEMDAsgA0GwAWogBCADLQCoAUHAABDJAiADKAKwASICQQRGDQsgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQMDwsgAyBUNwMgIAMgVTcDGCADIDU2AgQgAyA4NgIAIANBmAFqEIYwIANBsAFqIAQQqCkgAygCsAEiAkEERwRAIA4gAykCtAE3AgggDkEQaiADQbwBaikCADcCACAOQQM2AgAgDiACNgIEDBALIANBsAFqQbSc0ABBFCADEOYeIAMoArABIgJBBEcEQCAOIAMpArQBNwIIIA5BEGogA0G8AWopAgA3AgAgDkEDNgIAIA4gAjYCBAwQCyADQbABakHInNAAQRMgA0EIahD1HSADKAKwASICQQRHBEAgDiADKQK0ATcCCCAOQRBqIANBvAFqKQIANwIAIA5BAzYCACAOIAI2AgQMEAsgA0GwAWpB25zQAEEVIANBGGoQ5h4gAygCsAEiAkEERwRAIA4gAykCtAE3AgggDkEQaiADQbwBaikCADcCACAOQQM2AgAgDiACNgIEDBALIANBsAFqQfCc0ABBFyADQShqEPUdIAMoArABIgJBBEcEQCAOIAMpArQBNwIIIA5BEGogA0G8AWopAgA3AgAgDkEDNgIAIA4gAjYCBAwQCyA4RQ0EIAMoAggiAkGAgICAeEYNBSBVUA0GIAMoAigiBEGAgICAeEYNByADKQIMIU4gDiADKQM4NwJAIA4gAykDSDcCTCAOIAMpA1g3AlggDiADKQJoNwIAIA5ByABqIANBQGsoAgA2AgAgDkHUAGogA0HQAGooAgA2AgAgDkHgAGogA0HgAGooAgA2AgAgDkEIaiADQfAAaikCADcCACAOQRBqIANB+ABqKQIANwIAIA5BGGogA0GAAWopAgA3AgAgAykCLCFPIA4gNTYCcCAOIE83AzggDiAENgI0IA4gTjcCLCAOIAI2AiggDiBUNwMgIA5B7ABqIANBkAFqKAIANgIAIA4gAykDiAE3AmQMEAsgAiADKAK4AUG0m9AAEP0vAAsgAiADKAK4AUHUm9AAEP0vAAsgAiADKAK4AUH0m9AAEP0vAAsgAiADKAK4AUGUnNAAEP0vAAtB+PzPAEHHAEGIndAAEMskAAtB+PzPAEHHAEGYndAAEMskAAtB+PzPAEHHAEGondAAEMskAAtB+PzPAEHHAEG4ndAAEMskAAsgDiADKQPYAzcCBCAOQQM2AgAgDkEUaiADQegDaigCADYCACAOQQxqIANB4ANqKQMANwIADAULIANBuAFqIgIgHygCADYCACADIAMpAtgDNwOwASADKAJYQYCAgIB4RwRAIANB2ABqQQFBABDgHgsgA0HgAGogAigCADYCACADIAMpA7ABNwNYCyADQZgBahCGMCADQbABaiAEENMJIB8gHkEIaikCADcDACAiIB5BEGooAgA2AgAgAyAeKQIANwPYAyADKAKwAUUNAAsLIA4gAykD2AM3AgQgDkEDNgIAIA5BFGogIigCADYCACAOQQxqIANB4ANqKQMANwIADAILIAMoArQBIQIgAykDuAEhTiAOIAMpA8ABNwMQIA4gTjcDCCAOIAI2AgQgDkEDNgIACyADQZgBahCGMAsgA0GIAWoQhjAgA0HoAGoQuy4gAygCWEGAgICAeEcEQCADQdgAakEBQQAQ4B4LIANByABqEIYwIANBOGoQri8gA0EoahC6LyADQQhqELcvCyADQfADaiQAIA5BBHIhAgJAIBAoAtgBIgNBA0YEQCAQQYAEaiACQRBqKAIANgIAIBBB+ANqIAJBCGopAgA3AwAgECACKQIANwPwAyAQQQE2AiQgEEGg988ANgIgIBBCATcCLCAQQYcBNgKMBCAQIBBBiARqNgIoIBAgEEHwA2oiAjYCiAQgEEHYA2pBBHIgEEEgahCZDiAQQQA2AtgDIAJBBHIhAgJAIBAoAvADQQNGBEAgAhC8KgwBCyACEN47CyAQQaQBaiAQQeADaikDACJONwIAIBBBrAFqIBBB6ANqKQMAIk83AgAgECAQKQPYAyJSNwKcASABQRBqIE83AgAgAUEIaiBONwIAIAEgUjcCACABQYCAgIB4NgJQDAELIBBB0AFqIgQgAkEYaigCADYCACAQQcgBaiIHIAJBEGopAgA3AwAgEEHAAWoiBiACQQhqKQIANwMAIBAgAikCADcDuAEgEEFAayAQQfgBakHYAPwKAAAgEEGwAWogBCgCACICNgIAIBBBqAFqIAcpAwAiTjcDACAQQSxqIAYpAwA3AgAgEEE0aiBONwIAIBBBPGogAjYCACAQIAM2AiAgECAQKQO4ATcCJCAQQdgBaiEDIBAoAkwhCiAQKAJQIQRBACESIwBBQGoiAiQAIAJBADYCFCACQoCAgIDAADcCDAJAAkAgBEUNAANAIAJBGGogCiAEIBIQwwEgAigCICEGIAIoAhwhEiACKAIYIgdBCEcEQCADIAIpAiQ3AgwgA0EUaiACQSxqKAIANgIAIAMgBjYCCCADIBI2AgQgAyAHNgIADAMLIAIoAhQiByACKAIMRgRAIAJBDGpBiL/PABCdKAsgAigCECAHQQJ0aiAGNgIAIAIgB0EBaiIcNgIUIAQgEksNAAsgBw0AIAIoAhAoAgAiBCgCCEECRgRAIAMgBDYCBCADQQg2AgAgAkEANgIUDAILIAJBGGpBJUEAQQFBARCgGCACKAIcIQQgAigCGEEBRwRAIAIoAiAiB0Gwvs8AQSX8CgAAIANBJTYCDCADIAc2AgggAyAENgIEIANBADYCAAwCCyAEIAIoAiBB5KPPABD9LwALIAJBATYCHCACQYC/zwA2AhggAkIBNwIkIAJBOzYCOCACIBw2AjwgAiACQTRqNgIgIAIgAkE8ajYCNCADQQRqIAJBGGoQmQ4gA0EANgIACyACQQxqIgMQoicgA0EEQQQQ4B4gAkFAayQAIBBByABqIR4gECgC3AEhAgJAIBAoAtgBIh1BCEcEQCABIBApA+ABNwMIIAFBEGogEEHoAWopAwA3AwAgAUGAgICAeDYCUCABIAI2AgQgASAdNgIAQQEhBwwBCyAQQdgBaiACEKUSAkACQAJAAkACQAJAQSRBBBCtNiIGBEAgBkKBgICAEDcCACAGIBApAtgBNwIIIAZBEGogEEHgAWoiIikCADcCACAGQRhqIBBB6AFqKQIANwIAIAZBIGogEEHwAWooAgA2AgAgECAGNgLwAyAQQQA2AuADIBBCgICAgIABNwLYAyAQKAJUIQIgECAQKAJYIgwgECgCXCINQdAAbGoiDzYCxAEgECACNgLAASAQIAw2ArwBIBAgDDYCuAEgDUUNAyAQQfgBaiENIBBB2AJqIS0DQAJAIAwpAwAiTkICUgRAIBAgTjcD0AIgLSAMQQhqQcgA/AoAACAGIAYoAgAiAkEBajYCACACQQBIDQQgEEHYAWohBSMAQcAKayIEJAAgBCAGNgIAIBBB0AJqIg5BMGohIAJAAkACQAJAAkAgBigCECICIA4oAjgiA0YEQCAOKQMoIU8gDikDICFQIARBADYCECAEQoCAgICAATcCCCAOQQA2AjggBEEANgIkIAQgAjYCICAEICA2AhwgBEIANwIwIAQgDigCNCIcNgIUIAQgBigCDCIWNgIoIAQgHCACQegDbGoiJzYCGCAEIBYgAkECdCIoaiIuNgIsIAJFDQQgBEH4BmohJiAEQeAGaiEfIARBQGshLwNAAkAgHCkDACJOQgJSBEAgHyAcQQhqIgJB4AP8CgAAIAQgTjcD2AYgKEUEQCAEIC42AiggBCAcQegDajYCFCAEQagKahCGMCAEQfgGahCsICAEQYgKahDULiAEQbQKahCGMAwICyAvIAJB4AP8CgAAIAQgTjcDOCAWKAIAIhEgESgCACICQQFqNgIAIAJBAEgNBSAEQdgGaiEDQgAhWkIAIVtCACFcIwBB0AVrIgIkACACIBE2AgwCQAJAAkACQAJAAkAgBEE4aiIKKQMgIk5CAlIEQCACQRhqIApBKGpB+AL8CgAAIAIgTjcDECACQfgEaiACKAKIAxDkHiACLQD8BCEZIAIoAvgEIgdBCEYNASADIAIpAP0ENwANIANBHGogAkGMBWooAAA2AAAgA0EVaiACQYUFaikAADcAACADIBk6AAwgAyAHNgIIIANCAjcDACACQdgCaiEUDAMLIAJBEGpBIEEAQQFBARCgGCACKAIUIQggAigCEEEBRg0BIAIoAhgiB0EYakGw+s8AKQAANwAAIAdBEGpBqPrPACkAADcAACAHQQhqQaD6zwApAAA3AAAgB0GY+s8AKQAANwAAIANBIDYCFCADIAc2AhAgAyAINgIMIANBADYCCCADQgI3AwAgCkHQA2oQhjAgCkEgahCsIAwECyACKALgAiEHIAJBADYC4AIgAkEANgKwBCACIAc2AqwEIAIgAkHYAmoiFDYCqAQgAiACKALcAiIIIAdBAnRqNgKkBCACIAg2AqAEIAJB+ARqIQkjAEFAaiIHJAAgB0EINgIAIAdBOGogAkGgBGoiCEEQaigCADYCACAHQTBqIAhBCGopAgA3AwAgByAIKQIANwMoIAcgBzYCPCAHQRxqIRUjAEEwayIIJAACQAJAAkAgB0EoaiISIAhBGGoiCyASKAIUEMgYQf8BcSIaQQlrQQJPBEAgC0EIQQBBAUEBEKAYIAgoAhwhGCAIKAIYQQFGDQIgCCgCICITIBo6AAAgCEEUaiIlQQE2AgAgCCATNgIQIAggGDYCDCAIQShqIBJBEGopAgA3AwAgCEEgaiASQQhqKQIANwMAIAggEikCADcDGCMAQRBrIhgkACALIBhBD2ogCygCFBDIGEH/AXEiE0EJa0ECTwRAIAhBDGohEgNAIBIoAggiGiASKAIARgRAIBIgGkEBQQFBARDQKAsgEigCBCAaaiATOgAAIBIgGkEBajYCCCALIBhBD2ogCygCFBDIGEH/AXEiE0EJa0ECTw0ACwsgCxD2FSAYQRBqJAAgFUEIaiAlKAIANgIAIBUgCCkCDDcCAAwBCyAVQQA2AgggFUKAgICAEDcCACASEPYVCyAIQTBqJAAMAQsgGCAIKAIgQciXzwAQ/S8ACwJAIAcoAgBBCEcEQCAJIAcpAwA3AwAgCUEQaiAHQRBqKQMANwMAIAlBCGogB0EIaikDADcDACAVQQFBARDgHgwBCyAJIAcpAhw3AgQgCUEINgIAIAlBDGogB0EkaigCADYCAAsgB0FAayQAIAJBuANqIgcgAkGEBWooAgA2AgAgAiACKQL8BDcDsAMgAigC+AQiCEEIRwRAIAIpA4gFIU4gAyACKQOwAzcCDCADIE43AxggAyAINgIIIANCAjcDACADQRRqIAcoAgA2AgAMAgsgAkGYA2ogBygCADYCACACIAIpA7ADNwOQAyACQfgEaiEJIAIoAowDIQsjAEEwayIIJAAgCCALNgIMQQghBwJAIAtBCE8EQCAIQQE2AhQgCEGQ+s4ANgIQIAhCATcCHCAIQZwDNgIsIAggCEEoajYCGCAIIAhBDGo2AiggCUEEaiAIQRBqEJkOQQAhBwwBCyAJIAs2AgQgCSALQQJ0QfyNzwBqKAIANgIICyAJIAc2AgAgCEEwaiQAIAIoAoAFIRogAigC/AQhEwJAIAIoAvgEIiVBCEcEQCADIAIpAoQFNwIUIANBHGogAkGMBWooAgA2AgAgAyAaNgIQIAMgEzYCDCADICU2AgggA0ICNwMADAELIAJBqANqIApB2ANqKAIANgIAIAIgCikC0AM3A6ADIAopA8gDIU4gAikDuAIhUyACKQPIAiFUIAIpA8ACIVUgAikD0AIhViACKQMQIVcgAikDGCFYIAIpAyAhWSACKQMoIV0gAkH4BGoiByACQUBrQdgA/AoAACACQaAEaiAZIAcQqgIgAkGQBGoiByACQbAEaikDADcDACACQZgEaiIIIAJBuARqKQMANwMAIAIgAikDqAQ3A4gEAkAgAikDoAQiUkIJUQRAIAMgAikDiAQ3AwggA0ICNwMAIANBGGogCCkDADcDACADQRBqIAcpAwA3AwAMAQsgAkHQA2ogAkHABGpBOPwKAAAgAkHAA2ogAkGQBGopAwA3AwAgAkHIA2ogAkGYBGopAwA3AwAgAiBSNwOwAyACIAIpA4gENwO4A0GAgICAeCEZQYCAgIB4ISkCQAJAIAIoAvwCQYCAgIB4Rg0AIAJB+ARqIQkgAigCgAMiByACKAKEA0EMbGohCyMAQTBrIggkACAIQQg2AgAgCCALNgIoIAggBzYCJCAIIAg2AiwgCEEYaiEVIwBBMGsiByQAIAdBGGogCEEkaiILENslAkACQAJAIActAB1BBEcEQCAHKQMYIVEgB0EgaiIsQQRBAEEEQQgQoBggBygCJCESIAcoAiBBAUYNAiAHKAIoIhggUTcCACAHQRRqIiNBATYCACAHIBg2AhAgByASNgIMIAdBKGogC0EIaigCADYCACAHIAspAgA3AyAjAEEQayILJAAgC0EIaiAsENslIAstAA1BBEcEQCAHQQxqIRIDQCALKQMIIVEgEigCCCIYIBIoAgBGBEAgEiAYQQFBBEEIENAoCyASKAIEIBhBA3RqIFE3AgAgEiAYQQFqNgIIIAtBCGogLBDbJSALLQANQQRHDQALCyALQRBqJAAgFUEIaiAjKAIANgIAIBUgBykCDDcCAAwBCyAVQQA2AgggFUKAgICAwAA3AgALIAdBMGokAAwBCyASIAcoAihByJfPABD9LwALAkAgCCgCAEEIRwRAIAkgCCkDADcDACAJQRBqIAhBEGopAwA3AwAgCUEIaiAIQQhqKQMANwMAIBVBBEEIEOAeDAELIAkgCCkCGDcCBCAJQQg2AgAgCUEMaiAIQSBqKAIANgIACyAIQTBqJAACQCACKAL4BCIHQQhrDgIAAQILIAIpA4AFIVIgAigC/AQhKQsCfyACKQOYASJRQgJRBEBCACFRQYCAgIB4DAELIAIpA7gBIVogAikCrAEhWyACKAKoASEZIAIpA6ABIVwgAigCtAELIQcgCigCrAMhCCAKKAKoAyEJIAopAxghXiAKKQMQIV8gCigCpAMhCyAKKAKgAyEVIAopAwghYCAKKQMAIWEgAigCtAIhEiACKAKwAiEYIAIpAzghYiACKQMwIWMgAyACKQOQAzcCgAIgAyACKQOgAzcCjAIgA0GIAmogAkGYA2ooAgA2AgAgA0GUAmogAkGoA2ooAgA2AgAgA0HgAGogAkGwA2pB2AD8CgAAIAMgETYCvAIgAyBaNwK0AiADIAc2ArACIAMgWzcDqAIgAyAZNgKkAiADIFI3ApwCIAMgKTYCmAIgAyBWNwP4ASADIFU3A/ABIAMgVDcD6AEgAyBTNwPgASADIE43A9gBIAMgGjYC1AEgAyATNgLQASADIAg2AswBIAMgCTYCyAEgAyALNgLEASADIBU2AsABIAMgEjYCvAEgAyAYNgK4ASADIFw3A1ggAyBRNwNQIAMgXjcDSCADIF83A0AgAyBgNwM4IAMgYTcDMCADIGI3AyggAyBjNwMgIAMgXTcDGCADIFk3AxAgAyBYNwMIIAMgVzcDACAUQQRBBBDgHiACQeQCaiIDENErIAMQ6DsgAkHwAmoQri8gAigC/AJBgICAgHhHBEAgAkH8AmpBBEEMEOAeCyACKQPAAUIDUgRAIAJBoAJqEJcwCyAKQbADahDULiAKQdwDahCGMAwHCyACKAL8BCEIIAIpA4AFIU4gAyACKQOIBTcDGCADIE43AxAgAyAINgIMIAMgBzYCCCADQgI3AwAgAkGwA2oQwhgLIAJBoANqEIYwCyACQZADakEBQQEQ4B4gFEEEQQQQ4B4gAkHkAmoiAxDRKyADEOg7IAJB8AJqEK4vICVBCEcNAiACKAL8AkGAgICAeEcEQCACQfwCakEEQQwQ4B4LIAJBmAFqENMuIAIpA8ABQgNRDQMgAkGgAmoQlzAMAwsgCCACKAIYQbDozwAQ/S8ACyAUQQRBBBDgHiACQeQCaiIDENErIAMQ6DsgAkHwAmoQri8LIAJBQGsQ8SsgAigC/AJBgICAgHhHBEAgAkH8AmpBBEEMEOAeCyACQZgBahDTLiACKQPAAUIDUgRAIAJBoAJqEJcwCyAKQdADahCGMAsgCkGwA2oQ1C4gCkHcA2oQhjAgESARKAIAIgNBAWs2AgAgA0EBRw0AIAJBDGoQ2SELIAJB0AVqJAAgBEGoBGoiAyAfQQhqKQMANwMAIARBsARqIgcgH0EQaikDADcDACAEIB8pAwA3A6AEIAQpA9gGIk5CAlINASAEIBZBBGo2AiggBCAcQegDajYCFCAFQRhqIAcpAwA3AwAgBUEQaiADKQMANwMAIAUgBCkDoAQ3AwggBUICNwMAIARBFGoQwxQgBCgCECIHBEAgBCgCDCEcA0AgHBDwEiAcQcACaiEcIAdBAWsiBw0ACwsgBEEIakEIQcACEOAeDAQLIBxB6ANqIScMBQsgBEG4BGogJkGgAvwKAAAgBCgCECIKIAQoAghGBEAgBEEIakGE+M8AEKEoCyAEKAIMIApBwAJsaiICIE43AwAgAiAEKQOgBDcDCCACQRBqIAMpAwA3AwAgAkEYaiAHKQMANwMAIAJBIGogBEG4BGpBoAL8CgAAIBZBBGohFiAEIApBAWo2AhAgKEEEayEoIBxB6ANqIhwgJ0cNAAsMAwsgBCACNgIEIAQgAzYCCCAEQQI2AtwGIARB1PjPADYC2AYgBEICNwLkBiAEQTs2AiAgBEE7NgIYIAQgBEEUajYC4AYgBCAEQQhqNgIcIAQgBEEEajYCFCAFQQxqIARB2AZqEJkOIAVCAjcDACAFQQA2AggLIA4oAjgiBwRAIA4oAjQhHANAIBwQ2BMgHEHoA2ohHCAHQQFrIgcNAAsLICBBCEHoAxDgHiAOKAI8QYCAgIB4RwRAIA5BPGpBBEEIEOAeCyAGIAYoAgAiAkEBazYCACACQQFHDQMgBBCGHwwDCwALIAQgFjYCKCAEICc2AhQLIARBFGoQwxQgBSAEKQIINwIgIAVBKGogBEEQaigCADYCACAFIAY2AjwgBSBQNwMYIAUgTzcDECAFQTRqIA5BxABqKQIANwIAIAUgDikCPDcCLCAFIA4pAwg3AwggBSAOKQMANwMAIA4oAjgiBwRAIA4oAjQhHANAIBwQ2BMgHEHoA2ohHCAHQQFrIgcNAAsLICBBCEHoAxDgHgsgBEHACmokACAQQagDaiICIgQgIkEIaikDADcDACAQQbADaiIDIgcgIkEQaikDADcDACAQICIpAwA3A6ADIBApA9gBIk5CAlINASAQIAxB0ABqNgK8ASABQRBqIAMpAwA3AwAgAUEIaiACKQMANwMAIAEgECkDoAM3AwAgAUGAgICAeDYCUCAQQbgBahD4FkEBIQcMBwsgDEHQAGohDwwECyAQQdADaiIKIA1BGGopAwA3AwAgEEHIA2oiBSANQRBqKQMANwMAIBBBwANqIg4gDUEIaikDADcDACAQIA0pAwA3A7gDIBAoAuADIgMgECgC2ANGBEAgEEHYA2pB9PbPABCcKAsgECgC3AMgA0EGdGoiAiAQKQOgAzcDCCACIE43AwAgAiAQKQO4AzcDICACQRBqIAQpAwA3AwAgAkEYaiAHKQMANwMAIAJBKGogDikDADcDACACQTBqIAUpAwA3AwAgAkE4aiAKKQMANwMAIBAgA0EBajYC4AMgDEHQAGoiDCAPRw0ACwwCC0EEQSQQoz0LAAsgECAPNgK8AQsgEEG4AWoQ+BYCQAJAIBAoAngiAkGAgICAeEYEQEGAgICAeCEHDAELIBAgECkCfCJONwKcASAQIAI2ApgBIE5CIIinIgIgBigCEEcNASAQQQA2AsABIBBCgICAgBA3ArgBQQAhDUEBIQxBACEHIE5CgICAgBBaBEAgBigCDCEMIAJBAnQhHANAIAcgECgCoAEiAk8NBSAQQdgBaiICIAwoAgAiAygCFCIEQQhqIAQoAghBAkZBAnRqIgQQiRkgAiAELQAhIANBCGoQ3SVB/wFxEM4mQf8BcSEDIBAoAsABIgIgECgCuAFGBEAgEEG4AWpBuPfPABCjKAsgDEEEaiEMIBAoArwBIAJqIAM6AAAgECACQQFqIg02AsABIAdBAWohByAcQQRrIhwNAAsgECgCvAEhDCAQKAK4ASEHCyAQQZgBakEBQQAQ4B4LIAEgECkCbDcCCCABIBApA2A3AhQgAUEQaiAQQfQAaigCADYCACABQRxqIBBB6ABqKAIANgIAIBApA0AhTiAQKAKQASECIAFBgICAgHg2AkQgAUGAgICAeDYCOCABIAI2AjAgASAGNgIsIAEgDTYCKCABIAw2AiQgASAHNgIgIAEgTjcDACABQdAAaiAQKQLYAzcDACABQdgAaiAQQeADaigCADYCACABIBApA9gBNwNIIB4Q9x0gHkEEQeAAEOAeIBBBIGoQuy4gEEGEAWoQhjAMBQtBACEHIBBB2AFqQRxBAEEBQQEQoBggECgC3AEhAyAQKALYAUEBRg0CIBAoAuABIgJBGGpB4PfPACgAADYAACACQRBqQdj3zwApAAA3AAAgAkEIakHQ988AKQAANwAAIAJByPfPACkAADcAACAQQZgBakEBQQAQ4B4gAUGAgICAeDYCUCABQRw2AgwgASACNgIIIAEgAzYCBCABQQA2AgALIBBB2ANqIgIQ3BggAkEIQcAAEOAeIAYgBigCACICQQFrNgIAIAJBAUcNAiAQQfADahCGHwwCCyAHIAJBqPfPABDDIQALIAMgECgC4AFBsOjPABD9LwALIB4Q9x0gHkEEQeAAEOAeIB1BCEcEQCAQQdQAaiICEPQbIAJBCEHQABDgHgsgEEHgAGoQri8gEEHsAGoQhjACQCAHRQ0AIBAoAnhBgICAgHhGDQAgEEH4AGpBAUEAEOAeCyAQQSBqELsuIBBBhAFqEIYwCyAQQQhqEJ08IBBBkARqJAAMAQsgAUHLAEEAQQFBARCgGCABKAIEIQIgASgCAEEBRg0BIAEoAggiA0Go9s8AQcsA/AoAACABQYCAgIB4NgJQIAFBywA2AgwgASADNgIIIAEgAjYCBCABQQA2AgALIAAgAUHgAPwKAAAgAUHgAGokAA8LIAIgASgCCEGw6M8AEP0vAAusAQECfyMAQSBrIgEkACABQQA2AhwgAUKAgICAwAA3AhQgAUEIaiABQRRqQfSo+wAQmCEgACgCBCECIAAoAgAhAyAAIAEpAwg3AgAgAgRAIAMgAkECdEEEEPg6CyABQQA2AhwgAUKAgICAIDcCFCABIAFBFGpB9Kj7ABCWISAAKAIMIQIgACgCCCEDIAAgASkDADcCCCACBEAgAyACQQJ0QQIQ+DoLIAFBIGokAAuOAQEBfyMAQRBrIgIkAAJAAkACQAJAIAAoAgBBnQtHBEAgAEEBIAEQthsiAA0BDAMLIAFBwAAQ0TRFDQEgARDpESIARQ0CIAAQmj4tAARBA3FFDQMLIAFFDQIgAEEAIAH8CwAMAgtBgPT8AEErIAJBD2pB8PP8AEHI9PwAENUeAAtBACEACyACQRBqJAAgAAuiAQECfwJAAkAgAkEBaiIEIAEoAhQiA0kEQCACIANJBEAgASgCECIDIARBAnRqKAIAIgQgAyACQQJ0aigCACIDSQ0CIAQgASgCCCICSw0DIAEoAgQhASAAIAQgA2s2AgQgACABIANqNgIADwsgAiADQbzigAEQwyEACyAEIANBrOKAARDDIQALIAMgBEHM4oABELE7AAsgBCACQczigAEQsDsAC6IBAQJ/AkACQCACQQFqIgQgASgCFCIDSQRAIAIgA0kEQCABKAIQIgMgBEEDdGooAgAiBCADIAJBA3RqKAIAIgNJDQIgASgCCCICIARJDQMgASgCBCEBIAAgBCADazYCBCAAIAEgA2o2AgAPCyACIANBvOKAARDDIQALIAQgA0Gs4oABEMMhAAsgAyAEQczigAEQsTsACyAEIAJBzOKAARCwOwALnQEBAn8jAEEwayICJAAgAiABNgIAIAAoAhAiAyABTQRAIAIgAzYCHCACQQI2AgggAkGg74UBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBsO+FARDvLAALIAAoAgQgACgCDCABaiIAQQN2ai0AACACQTBqJAAgAEEHcXZBAXELrwEBAX8jAEFAaiICJAAgACgCACEAIAJBoNSHATYCOCACQYDUhwE2AjAgAiAAQcEAajYCLCACQZDUhwE2AiggAiAAQSBqNgIkIAJBgNSHATYCICACIABBQGs2AhwgAkHw04cBNgIYIAIgAEEoajYCFCACQeDThwE2AhAgAiAAQTRqNgIMIAIgADYCPCACIAJBPGo2AjQgAUGU1YcBQeTUhwEgAkEMahD5EiACQUBrJAALjwEBAn8jAEEwayIEJAAgACgCACIAKAIAIQMgAEEANgIAAkAgA0EBcQRAIARBCGoiAyAAQQRqQSj8CgAAQdwAQQQQrTYiAEUNASAAIANBKPwKAAAgAEEAOgBYIAAgAjYCLCAAIAE2AiggAEHUx8IAENQaIARBMGokAA8LQdSiwwBBMRCXPQALQQRB3AAQoz0AC6EBAQF/AkAgACgCAEUNACAAQQRqEJI+IAAoAgQiAUGEAUkNACABEPIfCwJAIAAoAggiAUUNACABIAEoAgBBAWsiATYCACABDQAgAEEIahCyGgsCQCAAKAIMIgFFDQAgASABKAIAQQFrIgE2AgAgAQ0AIABBDGoQshoLAkAgACgCECIBRQ0AIAEgASgCAEEBayIBNgIAIAENACAAQRBqELIaCwvlAwIGfwF+IwBBMGsiAyQAIAMgAjoAJyADQRhqIQcgASgCICgCACEBIANBJ2ohBkEBIQQjAEEQayICJAACQAJAAkAgASgCACABKAIIIgVrQQFLBEAgASgCBCAFaiAGLQAAOgAAIAEgBUEBajYCCAwBCyACQQhqIQQjAEEQayIFJAACQCABKAIAIgggASgCCEYEfyAFQQhqIAEQwxkgBS0ACEEERwRAIAQgBSkDCDcCAAwCCyABKAIABSAIC0EBSwRAIAEoAggiCCABKAIEaiAGLQAAOgAAIARBATYCBCABIAhBAWo2AgggBEEEOgAADAELIAFBAToADCABKAIQIAYgBkEBahDAJiABQQA6AAwgBEKEgICAEDcCAAsgBUEQaiQAIAItAAhBBEYEQCACKAIMIQQMAQsgAikDCCIJQv8Bg0IEUg0BIAlCIIinIQQLIAcgBDYCBCAHQQQ6AAAgASABKAIUIARqNgIUDAELIAcgCTcCAAsgAkEQaiQAAkACQCADLQAYQQRGDQAgAyADKQMYNwMoIANBBGogA0EoahDQCSADKAIEQQRGDQAgACADKQIENwIAIABBEGogA0EUaigCADYCACAAQQhqIANBDGopAgA3AgAMAQsgAEEENgIACyADQTBqJAAL5QMCBn8BfiMAQTBrIgMkACADIAI6ACcgA0EYaiEHIAEoAiAoAgAhASADQSdqIQZBASEEIwBBEGsiAiQAAkACQAJAIAEoAgAgASgCCCIFa0EBSwRAIAEoAgQgBWogBi0AADoAACABIAVBAWo2AggMAQsgAkEIaiEEIwBBEGsiBSQAAkAgASgCACIIIAEoAghGBH8gBUEIaiABEJ0ZIAUtAAhBBEcEQCAEIAUpAwg3AgAMAgsgASgCAAUgCAtBAUsEQCABKAIIIgggASgCBGogBi0AADoAACAEQQE2AgQgASAIQQFqNgIIIARBBDoAAAwBCyABQQE6AAwgAUEQaiAGIAZBAWoQwCYgAUEAOgAMIARChICAgBA3AgALIAVBEGokACACLQAIQQRGBEAgAigCDCEEDAELIAIpAwgiCUL/AYNCBFINASAJQiCIpyEECyAHIAQ2AgQgB0EEOgAAIAEgASgCHCAEajYCHAwBCyAHIAk3AgALIAJBEGokAAJAAkAgAy0AGEEERg0AIAMgAykDGDcDKCADQQRqIANBKGoQ0AkgAygCBEEERg0AIAAgAykCBDcCACAAQRBqIANBFGooAgA2AgAgAEEIaiADQQxqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC48BAQJ/IwBBMGsiBCQAIAAoAgAiACgCACEDIABBADYCAAJAIANBAXEEQCAEQQxqIgMgAEEEakEk/AoAAEHUAEEEEK02IgBFDQEgACADQST8CgAAIABBADoAUCAAIAI2AiggACABNgIkIABB9NzDABDUGiAEQTBqJAAPC0Hm2cMAQTEQlz0AC0EEQdQAEKM9AAuUAQECfyMAQdAAayIEJAAgACgCACIAKAIAIQMgAEEANgIAAkAgA0EBcQRAIARBDGoiAyAAQQRqQcQA/AoAAEGUAUEEEK02IgBFDQEgACADQcQA/AoAACAAQQA6AJABIAAgAjYCSCAAIAE2AkQgAEG03MMAENQaIARB0ABqJAAPC0Hm2cMAQTEQlz0AC0EEQZQBEKM9AAudAQEBfyMAQRBrIgIkAAJAAkAgAUUEQCACIAAQ9xcgAigCDCIAEIg1IABBMEEIEPg6IAIoAggiAQRAIAIoAgQhAANAIAAQhzUgAEFAayEAIAFBAWsiAQ0ACwsgAkEIQcAAEOAeDAELIABFDQEgAiAAQQhrIgA2AgAgACAAKAIAQQFrIgA2AgAgAA0AIAIQgR8LIAJBEGokAA8LEJg9AAuaAQIBfwJ+IwBBIGsiBCQAIARBCGogACgCECABQQxsahDcOyAEQRBqIAQoAgggAmpBfyACIANqIgMgAiADSxsgAmsgASACEPAKIAQpAxghBSAEKQMQIQYgACgCCCIBIAAoAgBGBEAgAEGchM0AELEoCyAAKAIEIAFBBHRqIgIgBTcDCCACIAY3AwAgACABQQFqNgIIIARBIGokAAusAQECfyMAQRBrIgMkAAJAAkAgAa0gAlgEQCAAQQg2AgAMAQsgA0EEakETQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCIBQQ9qQYOAzgAoAAA2AAAgAUEIakH8/80AKQAANwAAIAFB9P/NACkAADcAACAAQRM2AgwgACABNgIIIAAgBDYCBCAAQQI2AgALIANBEGokAA8LIAQgAygCDEG09c0AEP0vAAudAQAgACABKQIANwIAIABBCGogAUEIaigCADYCAAJAAkAgAkEETwRAIAAgACkCADcCBCACQQNrIQEMAQsCfwJAAkAgAiADakEBayICDgQEAQEAAQsgACgCACIDQQFrDAELIAAoAgAhAyAAIAJBAnRqKAIACyEBIAAgAEEIaiAAQQRqIAJBAUYbKAIANgIIIAAgAzYCBAsgACABNgIACwunAQECfwJAAkACQAJAAkACQAJAAkACQAJAAkAgAUH/AXFBMGsOCgABAgMEBQYHCAkKC0EBIQIMCQtBASEDQQEhAgwIC0EBIQJBAiEDDAcLQQEhAkEDIQMMBgtBASECQQQhAwwFC0EBIQJBBSEDDAQLQQEhAkEGIQMMAwtBASECQQchAwwCC0EBIQJBCCEDDAELQQEhAkEJIQMLIAAgAzoAASAAIAI6AAALqAEBA38jAEFAaiIDJAAgAyACNgIIQZOAgIB4IQQgACACIAEoAhQiBUcEfyADIAU2AiQgA0EDNgIQIANBjPiGATYCDCADQgM3AhggA0E7NgI8IANBOzYCNCADQa0DNgIsIAMgAUEYajYCKCADIANBKGo2AhQgAyADQSRqNgI4IAMgA0EIajYCMCAAQQRqIANBDGoQmQ5BjYCAgHgFIAQLNgIAIANBQGskAAuXAQECfyMAQSBrIgEkAAJAIAAoAlgiAkUEQEEAIQAMAQsgAUEIaiAAQQxqEIY9IAFBFGoiACABKAIIIAEoAgwQiz0gASAAEMcbQQAhACACIAEoAgRNBEAgASgCACACQQJ0akEEaygCACEACyABKAIUIgIgAigCACICQQFrNgIAIAJBAUcNACABQRRqEPseCyABQSBqJAAgAAuRAQICfwF+IwBBIGsiASQAAkAgACgCWCICRQRADAELIAFBCGogAEEMahCGPSABQRRqIgAgASgCCCABKAIMEIs9IAEgABDFGyACIAEoAgRNBEAgASgCACACQQN0akEIaykDACEDCyABKAIUIgAgACgCACIAQQFrNgIAIABBAUcNACABQRRqEPseCyABQSBqJAAgAwuXAQECfyMAQSBrIgEkAAJAIAAoAlgiAkUEQEEAIQAMAQsgAUEIaiAAQQxqEIY9IAFBFGoiACABKAIIIAEoAgwQiz0gASAAEMYbQQAhACACIAEoAgRNBEAgASgCACACQQF0akECay8BACEACyABKAIUIgIgAigCACICQQFrNgIAIAJBAUcNACABQRRqEPseCyABQSBqJAAgAAuMAQECfyMAQbABayICJAACQCABBEAgAUEIayIDKAIAQQFHDQEgAkEQaiABQaAB/AoAACADQQA2AgACQCADQX9GDQAgAUEEayIBIAEoAgBBAWsiATYCACABDQAgA0GoAUEIEPg6CyAAIAJBGGpBmAH8CgAAIAJBsAFqJAAPCxCYPQALQf2CwwBBPxCXPQALoAECAX8EfiMAQSBrIgIkACACQgA3AwAgAUEHTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQcTZzgAQ7ywACyACQQggAEEIQdTZzgAQ1SwgAjUCACEDIAIxAAQgAjEABSEFIAIxAAYhBiACQSBqJABCKIYgA0IIhoQgBUIwhoQgBkI4hoRCvc/W8dH36ZoefkIsiKcLjQEBBH8jAEEQayIFJAAgAiAAKAIIIgNNBEAgAgRAIAAoAgQhBgNAIAIgAyACIANJGyIEBEAgASAGIAT8CgAACyAEIAZqIQYgAyAEayEDIAEgBGohASACIARrIgINAAsgACADNgIIIAAgBjYCBAsgBUEQaiQADwsgBSADNgIMIAUgAjYCCCAFQQhqEPMlAAuYAQAgAAJ/IAQgAiADQcCACGpNckUEQCAAIAFBoIAIaiIBNgL06wEgASADaiEDQQEMAQsgA0GBgARPBEAgACABIAVqIgEgA2siAkHg/wNqIgQgAiAGGzYC9OsBIAMgBGpBgIAEayABIAYbIQNBAgwBCyAAIABBgOwBaiIBNgL06wEgASADaiEDQQALNgL86wEgACADNgL46wELmgECAX8CfiMAQSBrIgIkACACQRBqIAEQyi8gAiACKAIQNgIcIAIgAkEcahDRH6xCgKMFfiACNQIUfEKAkc285wF9IgMgA0I/h0KAlOvcA0IAEKgeIAACfkIAIAIpAwggAikDACIDQj+HUg0AGkIAIAI1AhgiBEIAVCADIAMgBHwiA1VzDQAaIAAgAzcDCEIBCzcDACACQSBqJAALkQEBAn8jAEEQayIEJAACQCABKAIAIgFBAXEEQCAEIAE2AgAgBEEIaiIFIAIgAWsiAiADaiIBNgIAIAQgATYCBCAEQQdBICABQQp2Z2siASABQQdPG0ECdEEBcjYCDCAEIAIQpx4gAEEIaiAFKQIANwIAIAAgBCkCADcCAAwBCyAAIAEgAiADEMYSCyAEQRBqJAALjQECAn8DfiADQfj///8BcQRAIAAgACADQQN2IgNBBnQiBWogACADQfAAbCIGaiADIAQQmxohACABIAEgBWogASAGaiADIAQQmxohASACIAIgBWogAiAGaiADIAQQmxohAgsgACACIAEgACkDACIHIAEpAwAiCFQiACAIIAIpAwAiCVRzGyAAIAcgCVRzGwuKAQECfyADQfj///8BcQRAIAAgACADQQN2IgNBBXQiBWogACADQThsIgZqIAMgBBCcGiEAIAEgASAFaiABIAZqIAMgBBCcGiEBIAIgAiAFaiACIAZqIAMgBBCcGiECCyAAIAIgASAAKAIAIgAgASgCACIBSSIDIAEgAigCACICSXMbIAMgACACSXMbC4oBAQJ/IANB+P///wFxBEAgACAAIANBA3YiA0EFdCIFaiAAIANBOGwiBmogAyAEEJ0aIQAgASABIAVqIAEgBmogAyAEEJ0aIQEgAiACIAVqIAIgBmogAyAEEJ0aIQILIAAgAiABIAAoAgAiACABKAIAIgFJIgMgASACKAIAIgJJcxsgAyAAIAJJcxsLmQEBAX8gAEE0ahCdDAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIABBDGoQnQwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgABDqOyAAKAJAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQUBrEPseCwuNAQEBfyMAQTBrIgMkACAAAn4gAkUEQEHAACABrcN5p2shAkIDDAELIANBADYCLCADQoCAgIAQNwIkIAMgA0EkahDnFSADQRhqQgA3AwAgA0EgakEAOgAAIANCADcDEEIECzcDACAAIAE7AUggAEEIaiADQST8CgAAIAAgAjoAQiAAIAE7AUAgA0EwaiQAC3YBAn8gA0EIIAQgASADaiIFa0EBaiIGIAZBCE8bQQAgBCAFTxsgA2oiBCADIARLGyEEIABBLGohBSAAKAIkQQhqIQYDQCADIARHBEAgBSADQQdxQQJ0aiABIANqIAYgAiAAKQNQEOYjNgIAIANBAWohAwwBCwsLiwEBAn8gA0H4////AXEEQCAAIAAgA0EDdiIDQTBsIgVqIAAgA0HUAGwiBmogAyAEEKEaIQAgASABIAVqIAEgBmogAyAEEKEaIQEgAiACIAVqIAIgBmogAyAEEKEaIQILIAAgAiABIAAoAgAiACABKAIAIgFJIgMgASACKAIAIgJJcxsgAyAAIAJJcxsL3gEBBH8jAEEgayIDJAAgA0EUaiABQQBBBEEQEKAYIAMoAhghBSADKAIUQQFGBEAgBSADKAIcIAIQ/S8ACyADQRBqIgJBADYCACADIAMoAhw2AgwgAyAFNgIIIAEiBSADQQhqIgYoAgAgBigCCCIEa0sEQCAGIAQgAUEEQRAQ3iggBigCCCEECyAGIAEEfyABIARqIAYoAgQgBEEEdGohBANAIARBADYCACAEQRBqIQQgBUEBayIFDQALBSAECzYCCCAAQQhqIAIoAgA2AgAgACADKQIINwIAIANBIGokAAuZAQEBfyAAQTRqELMMAkAgACgCTCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQcwAahD7HgsgAEEMahCzDAJAIAAoAhwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEcahD7HgsgABDDJyAAEOo7IAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ+x4LC4MBAQJ/IwBBIGsiAyQAIANBFGogAUEAQQRBBBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHCACEP0vAAsgA0EQaiICQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqQQAgARCIICAAQQhqIAIoAgA2AgAgACADKQIINwIAIANBIGokAAudAQEDfyMAQSBrIgQkAAJAIAEoAhBBfyACIANqIgUgAiAFSxtPBEAgASgCACIFIAUoAgAiBkEBajYCACAGQQBIDQEgACADNgIQIAAgBTYCACAAIAEpAgQ3AgQgACABKAIMIAJqNgIMIARBIGokAA8LIARBADYCGCAEQQE2AgwgBEHogYgBNgIIIARCBDcCECAEQQhqQfCBiAEQ7ywLAAuJAQEFfyMAQRBrIgMkAAJAAkAgAkEHTQRAIAINAQwCCyADQQhqQS4gASACEJ0SIAMoAghBAUYhBAwBCyACQQFrIQYgASEFA0AgBS0AAEEuRiIEDQEgBUEBaiEFIAYiB0EBayEGIAcNAAsLIAAgBCAALQAEcjoABCAAKAIAIAEgAhD7NSADQRBqJAALswICBH8BfiMAQRBrIgUkAAJAAkAgASgCACABKAIIIgRrIANLBEAgAwRAIAEoAgQgBGogAiAD/AoAAAsgASADIARqNgIIDAELIAVBCGohByMAQRBrIgQkAAJAIAEoAgAiBiABKAIIayADSQR/IARBCGogARCdGSAELQAIQQRHBEAgByAEKQMINwIADAILIAEoAgAFIAYLIANLBEAgASgCCCEGIAMEQCABKAIEIAZqIAIgA/wKAAALIAdBBDoAACABIAMgBmo2AggMAQsgAUEBOgAMIAFBEGogAiADEKE2IAdCBDcCACABQQA6AAwLIARBEGokACAFLQAIQQRGDQAgBSkDCCIIQv8Bg0IEUQ0AIAAgCDcCAAwBCyAAQQQ6AAAgASABKAIcIANqNgIcCyAFQRBqJAALswICBH8BfiMAQRBrIgUkAAJAAkAgASgCACABKAIIIgRrIANLBEAgAwRAIAEoAgQgBGogAiAD/AoAAAsgASADIARqNgIIDAELIAVBCGohByMAQRBrIgQkAAJAIAEoAgAiBiABKAIIayADSQR/IARBCGogARDDGSAELQAIQQRHBEAgByAEKQMINwIADAILIAEoAgAFIAYLIANLBEAgASgCCCEGIAMEQCABKAIEIAZqIAIgA/wKAAALIAdBBDoAACABIAMgBmo2AggMAQsgAUEBOgAMIAEoAhAgAiADEKE2IAdCBDcCACABQQA6AAwLIARBEGokACAFLQAIQQRGDQAgBSkDCCIIQv8Bg0IEUQ0AIAAgCDcCAAwBCyAAQQQ6AAAgASABKAIUIANqNgIUCyAFQRBqJAALzgYCCn8BbyMAQTBrIgckAAJAIAEtABBFBEAgB0EcaiEKIwBBIGsiCCQAIAhBDGohCyACIQNBACECIwBBIGsiBCQAIwBBEGsiBiQAIAFBCGohBQJAIAEoAghFBEAgASgCAEEBRwRAQQIhAwwCCyABQQRqKAIAJQEQJCENEN8SIgIgDSYBIAIQ+w4hCQJAIAEoAggiAkUNACACIAIoAgBBAWsiDDYCACAMDQAgBRCyGgsgBSAJNgIACyAGIAUgAxDHGCAGKAIAIgNBAkYEQEEDIQMMAQsgBigCBCECAkAgBSgCACIJRQ0AIAkgCSgCAEEBayIJNgIAIAkNACAFELIaCyAFQQA2AgAgA0EBcQRAIAEoAgAEQCABQQRqENUvCyABQQA2AgAMAQsgBiACNgIMAn9BAiAGQQxqIgMoAgAlARA1IgVBAEcgBUH///8HRhtB/QFxRQRAIAMoAgAlARA2IQ0Q3xIiAiANJgFBAAwBCyABKAIABEAgAUEEahDVLwsgAUEANgIAQQILIQMgBigCDCIFQYQBSQ0AIAUQ8h8LIAQgAjYCBCAEIAM2AgAgBkEQaiQAAkAgBCgCACIDQQNGBEAgC0GCgICAeDYCAAwBCwJAIANBAkcEQCAEKAIEIQIgA0EBcQRAIARBgICAgHg2AgwgBCACNgIQDAILIARBDGohAyACJQEhDSACEPIfAkAgDRAIIgZFBEAgA0GAgICAeDYCACADIAI2AgQMAQsgAyAGELIWCwwBCyAEQYGAgIB4NgIMCyALIAQpAgw3AgAgC0EQaiAEQRxqKAIANgIAIAtBCGogBEEUaikCADcCAAsgBEEgaiQAIAgoAgwiAkGCgICAeEcEQCAIKAIUIQQgCCgCECEDIAogCCkCGDcCDCAKIAMgBCACQYCAgIB4RiIEGzYCCCAKQQUgAyAEGzYCBAsgCiACNgIAIAhBIGokACAHKAIcIgJBgoCAgHhGBEAgAEGCgICAeDYCAAwCCyAHQRBqIgMgB0EoaikCADcDACAHIAcpAiA3AwggAkGBgICAeEYEQCABQQE6ABALIAAgAjYCACAAIAcpAwg3AgQgAEEMaiADKQMANwIADAELIABBgYCAgHg2AgALIAdBMGokAAuBCQELfyMAQRBrIggkACAIQQRqIQUjAEEwayIDJAACQAJAIAEoAgAiBygCFCICIAcoAhAiBEkEQCAHQQxqIQkgBygCDCEKA0AgAiAKai0AACIGQQlrIgtBF0tBASALdEGTgIAEcUVyDQIgByACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBAjYCJEEBIQYgA0EYaiAHQQxqIAJBAWoiAiAEIAIgBEkbEOoMIAUgA0EkaiADKAIYIAMoAhwQ+yg2AgQMAQsgBkHdAEYEQEEAIQYgBUEAOgABDAELAkACQCABLQAERQRAIAZBLEcNAUEBIQYgByACQQFqIgI2AhQgAiAESQRAA0AgAiAKai0AACILQQlrIgxBF0tBASAMdEGTgIAEcUVyDQQgByACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBBTYCJCADIAkgAkEBaiICIAQgAiAESRsQ6gwgBSADQSRqIAMoAgAgAygCBBD7KDYCBAwDCyAFQQE6AAFBACEGIAFBADoABAwCCyADQQc2AiRBASEGIANBEGogCSACQQFqIgIgBCACIARJGxDqDCAFIANBJGogAygCECADKAIUEPsoNgIEDAELIAtB3QBGBEAgA0EVNgIkIANBCGogCSACQQFqIgIgBCACIARJGxDqDCAFIANBJGogAygCCCADKAIMEPsoNgIEDAELIAVBAToAAUEAIQYLIAUgBjoAACADQTBqJAACQCAILQAEQQFGBEAgACAIKAIINgIEIABBgYCAgHg2AgAMAQsgCC0ABUUEQCAAQYCAgIB4NgIADAELIAhBBGohAiABKAIAIQQjAEEgayIBJAAgAUEEaiAEEP4eAkACQAJAAkACQAJ/IAEtAARBAUYEQCABKAIIDAELIAEtAAVBAUYEQCABLQAGQSJHDQIgBBDvOiAEQQA2AgggAUEQaiAEQQxqIAQQvg8gASgCFCEGIAEoAhAiC0ECRw0DIAJBgICAgHg2AgAgAiAGNgIEDAYLIAFBBTYCECAEIAFBEGoQlicLIQQgAkGAgICAeDYCACACIAQ2AgQMBAsgASAEIAFBH2pB8M7DABCeCjYCCAwBCyABQQRqIQcgASgCGCEFIwBBEGsiAyQAIANBBGogBUEAQQFBARCgGCADKAIIIQkCQCADKAIEQQFHBEAgAygCDCEKIAUEQCAKIAYgBfwKAAALIAcgBTYCCCAHIAo2AgQgByAJNgIAIANBEGokAAwBCyAJIAMoAgxB+M+IARD9LwALIAEoAgQhAyALQQFxBEAgA0GAgICAeEYNASACIAEpAgQ3AgAgAkEIaiABQQxqKAIANgIADAMLIANBgICAgHhHDQELIAQgASgCCBCVPiEEIAJBgICAgHg2AgAgAiAENgIEDAELIAIgASkCBDcCACACQQhqIAFBDGooAgA2AgALIAFBIGokACAIKAIEQYCAgIB4RwRAIAAgCCkCBDcCACAAQQhqIAhBDGooAgA2AgAMAQsgACAIKAIINgIEIABBgYCAgHg2AgALIAhBEGokAAuxAQEBfyMAQRBrIgIkAAJ/AkACQAJAAkACQAJAAkAgAC8BAEEBaw4GAQIDBAUGAAsgAUHY68MAQQcQ+zUMBgsgAUHf68MAQQcQ+zUMBQsgAUHm68MAQQgQ+zUMBAsgAiAAQQJqNgIMIAFBgOzDAEEGIAJBDGpB8OvDABDQEwwDCyABQYbswwBBBBD7NQwCCyABQYrswwBBBhD7NQwBCyABQZDswwBBBxD7NQsgAkEQaiQAC5MBAQN/IwBBEGsiAyQAAkACQCABp0EBcQRAIABBCDYCACAAIAI3AwgMAQsgA0EEakEnQQBBAUEBEKAYIAMoAgghBCADKAIEQQFGDQEgAygCDCIFQfbCzgBBJ/wKAAAgAEEnNgIMIAAgBTYCCCAAIAQ2AgQgAEECNgIACyADQRBqJAAPCyAEIAMoAgxB2KfOABD9LwALjQEBBH8gACABKAJ4KAIAQQhGBH8gASgCbCABKAJka0EMbiICIAEoAlQgASgCTGtBDG4iAyABKAI8IAEoAjRrQQR2IgQgASgCJCABKAIcayIFIAEoAhQgASgCEGsiASABIAVLGyIBIAEgBEsbIgEgASADSxsiASABIAJLGwUgAgs2AgggAEKAgICAEDcCAAuPAQEDfyMAQSBrIgIkAAJAIAFFDQAgACgCACEEIABBCTYCACAEQQlGBEAgASEDDAELIAJBHGogAEEUaigCADYCACACQRRqIABBDGopAgA3AgAgAiAENgIIIAIgACkCBDcCDCACIAE2AgAgAkEIahDWJyABQQFrIgFFDQAgAEEJNgIAIAEhAwsgAkEgaiQAIAMLoAEBAX8jAEEgayIEJAACQCADQYAibCIDIAJNBEAgAiADa0H/AU0NASAAQYACNgIEIAAgASADQQF0ajYCACAEQSBqJAAPCyAEQQA2AhggBEEBNgIMIARBgPDRADYCCCAEQgQ3AhAgBEEIakHo8NEAEO8sAAsgBEEANgIYIARBATYCDCAEQYDw0QA2AgggBEIENwIQIARBCGpB+PDRABDvLAALYwIEfwJ9IwBBIGsiAiQAIAJBEDYCBCAAQQRqIQEgACoCACEFQQEhAANAIAEqAgAiBiAFIAUgBl4iBBshBSAAIAMgBBshAyABQQRqIQEgAEEBaiIAQRBHDQALIAJBIGokACADC5sBAQJ/QagBIQEDQCAAIAFqQQA7AQAgAUEEaiIBQaAKRw0ACyAAQaQTaiECQQAhAQNAIAEgAmpBADsBACABQQRqIgFB+ABHDQALIABBoBVqIQJBACEBA0AgASACakEAOwEAIAFBBGoiAUHMAEcNAAsgAEIANwN4IABBATsBqAkgACgCQCAAKAJEQQAQ7S8gAEEAOgA6IABBADYCSAuWAQEBfwJAIAAoAgAiACgCDEECRg0AIAAoAhAiAUGEAUkNACABEPIfCyAAKAIUIgEEQCAAKAIYIAEoAgwRAwALAkAgACgCHEUNACAAQSRqEKw7BEAgAEEcahC8KgsgAEEwahCsO0UNACAAQShqELwqCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEE0QQQQ+DoLC5EBAQJ/IwBBsAFrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQdgA/AoAAEHAAUEIEK02IgBFDQEgACADQbAB/AoAACAAQQA6ALgBIAAgAjYCtAEgACABNgKwASAAQbTHwgAQ1BogA0GwAWokAA8LQdSiwwBBMRCXPQALQQhBwAEQoz0AC5EBAQJ/IwBBsAZrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQZgD/AoAAEHABkEIEK02IgBFDQEgACADQbAG/AoAACAAQQA6ALgGIAAgAjYCtAYgACABNgKwBiAAQfTGwgAQ1BogA0GwBmokAA8LQdSiwwBBMRCXPQALQQhBwAYQoz0AC5EBAQJ/IwBBkAFrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQcgA/AoAAEGgAUEIEK02IgBFDQEgACADQZAB/AoAACAAQQA6AJgBIAAgAjYClAEgACABNgKQASAAQaTHwgAQ1BogA0GQAWokAA8LQdSiwwBBMRCXPQALQQhBoAEQoz0AC5EBAQJ/IwBBgANrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQcAB/AoAAEGQA0EIEK02IgBFDQEgACADQYAD/AoAACAAQQA6AIgDIAAgAjYChAMgACABNgKAAyAAQYTHwgAQ1BogA0GAA2okAA8LQdSiwwBBMRCXPQALQQhBkAMQoz0AC5EBAQJ/IwBB4AVrIgMkACAAKAIAIgAoAgAhBCAAQgA3AwACQCAEQQFxBEAgAyAAQQhqQfAC/AoAAEHwBUEIEK02IgBFDQEgACADQeAF/AoAACAAQQA6AOgFIAAgAjYC5AUgACABNgLgBSAAQcTHwgAQ1BogA0HgBWokAA8LQdSiwwBBMRCXPQALQQhB8AUQoz0AC5QBAgJ/AX4jAEEgayIDJAAgA0EQakEAOwEAIANCADcDCCACIANBCGoiBBCyFSICQQtJBEAgA0EYaiABKAIAKAIAIAQgAhCoGgJAAkAgAy0AGEEERg0AIAMpAxgiBUL/AYNCBFENACAAIAU3AgAMAQsgAEEEOgAAIAAgAjYCBAsgA0EgaiQADwsgAkEKQYi9wwAQsDsAC5QBAgJ/AX4jAEEgayIDJAAgA0EQakEAOwEAIANCADcDCCACIANBCGoiBBCyFSICQQtJBEAgA0EYaiABKAIAKAIAIAQgAhCnGgJAAkAgAy0AGEEERg0AIAMpAxgiBUL/AYNCBFENACAAIAU3AgAMAQsgAEEEOgAAIAAgAjYCBAsgA0EgaiQADwsgAkEKQYi9wwAQsDsAC4oBAQJ/IwBBMGsiAyQAIAAoAgAiACgCACEEIABBADYCAAJAIARBAXEEQCADIABBBGpBMPwKAABB7ABBBBCtNiIARQ0BIAAgA0Ew/AoAACAAQQA6AGggACACNgI0IAAgATYCMCAAQdTcwwAQ1BogA0EwaiQADwtB5tnDAEExEJc9AAtBBEHsABCjPQALigEBAn8jAEEwayIDJAAgACgCACIAKAIAIQQgAEEANgIAAkAgBEEBcQRAIAMgAEEEakEw/AoAAEHsAEEEEK02IgBFDQEgACADQTD8CgAAIABBADoAaCAAIAI2AjQgACABNgIwIABBxNzDABDUGiADQTBqJAAPC0Hm2cMAQTEQlz0AC0EEQewAEKM9AAu2GQENfyMAQTBrIgokACAKQSRqIANBAEEBQQEQoBggCigCKCEFIAooAiRBAUYEQCAFIAooAixBwJfEABD9LwALIApBADoAICAKQQA2AgggCiAKKAIsNgIEIAogBTYCACAKIAEoAgw2AhwgCiABKAIINgIYIAogASgCBDYCFCAKIAEoAgA2AhAgCiABKAIQNgIMIAAhDCMAQaABayIEJAAgCiIAKAIcIQ0gACgCGCEJIARBGGohDiACIhAgAyIGaiEBA0ACQCAIIQUgASACIgNGBEAgASECQQAhC0EAIQUMAQsCfyADLAAAIgJBAE4EQCACQf8BcSEHIANBAWoMAQsgAy0AAUE/cSEHIAJBH3EhCCACQV9NBEAgCEEGdCAHciEHIANBAmoMAQsgAy0AAkE/cSAHQQZ0ciEHIAJBcEkEQCAHIAhBDHRyIQcgA0EDagwBCyAIQRJ0QYCA8ABxIAMtAANBP3EgB0EGdHJyIQcgA0EEagsiAiADayAFaiIIIQsgB0EhSQ0BCwsCQANAIAIgASIDRg0BIAFBAWsiASwAACIHQQBIBH8gB0E/cQJ/IANBAmsiAS0AACIHwCIPQUBOBEAgB0EfcQwBCyAPQT9xAn8gA0EDayIBLQAAIgfAIg9BQE4EQCAHQQ9xDAELIA9BP3EgA0EEayIBLQAAQQdxQQZ0cgtBBnRyC0EGdHIFIAcLQSFJDQALIAggAmsgA2ohCwsgDiALIAVrNgIEIA4gBSAQajYCACAEKAIcIQggBCgCGCEFAkAgCUUNACAGIAhLBEAgCUEBIA0oAhQRAAALIAUgCGohByAFIQEDQCABIAdGDQECfyABLAAAIgJBAE4EQCACQf8BcSECIAFBAWoMAQsgAS0AAUE/cSEGIAJBH3EhAyACQV9NBEAgA0EGdCAGciECIAFBAmoMAQsgAS0AAkE/cSAGQQZ0ciEGIAJBcEkEQCAGIANBDHRyIQIgAUEDagwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgJBgIDEAEYNAiABQQRqCyEBQQEgAnRBgMwAcUUgAkENS3INAAsgCUEJIA0oAhQRAAALIARBEGohBiAAIQIjAEEQayIDJAAgAyAFIAhqIggiATYCBCADIAU2AgAgAyABNgIMIAMgBTYCCAJ/QQAgA0EIahDuEkHf//8AcUHBAGtBGUsNABoCQAJAIAMQ7hIiAUGAgMQARwRAA0ACQCABQeEAa0EaSSABQTBrQQpJciABQStGIAFBLWtBAklyckUEQCABQTpGDQQgAUHBAGtBGk8NBSACKAIIIQcgAkEBENgtIAIoAgQgAigCCGogAUEgcjoAAAwBCyACKAIIIQcgAkEBENgtIAIoAgQgAigCCGogAToAAAsgAiAHQQFqNgIIIAMQ7hIiAUGAgMQARw0ACwsgAi0AIEEBRw0BCyADKAIEIQIgAygCAAwBCyACQQA2AghBAAshASAGIAI2AgQgBiABNgIAIANBEGokAAJAAkACQAJAAkACQAJAAkACQCAEKAIQIgNFBEAgACgCDCIBDQFBBiEBDAgLIAQoAhQhCCAEQSBqIgIgAEEk/AoAACAEKAIoIQdBASEFAkAgAigCBCIAIAIoAggiAUG0hsQAQQQQwS4NACAAIAFBuIbEAEEFEMEuDQAgACABQb2GxABBAhDBLg0AIAAgAUG/hsQAQQMQwS4NACAAIAFBwobEAEEDEMEuDQBBAEECIAAgAUHFhsQAQQQQwS4bIQULIAJBARDYLSAEKAIkIAQoAihqQTo6AAAgBCAHQQFqIgs2AigCQAJAAkACQCAFQf8BcUEBaw4CAQIACwJAIAQoAjgiAEUNACAEKAI8IQEgBCAINgKAASAEIAM2AnxBnIfEAEECIARB/ABqEIUVDQAgAEEEIAEoAhQRAAALQQAhAiAEKAIsIgEEQCABKAIUIQICQCABKAIgIgBFDQAgASgCGCIFIABNBEAgACAFRg0BDAwLIAAgAmosAABBv39MDQsLIAFBACACIABBxYbEAEEEEMEuGyECCyAEQQA2AiggBEH8AGoiACAEQSBqQST8CgAAIAwgACADIAggAhC1AQwLC0EAIQAgCCEBIAMhAgNAIAQgATYCgAEgBCACNgJ8IARB/ABqEO4SIgVB3ABHIAVBL0dxRQRAIABBAWohACAEKAKAASEBIAQoAnwhAgwBCwsgAEEBSw0HIAQoAiwiBQ0BDAcLIARBxABqIARBIGoiAUEk/AoAACAEIAg2AoABIAQgAzYCfEGch8QAQQIgBEH8AGoiABCFFQRAIAQoAoABIQIgBCgCfCEDIAAgAUEk/AoAACAMIAAgAyACQQIgBxCUAgwKCyAEQQA6AGggBCgCTCEJIAQgCDYCgAEgBCADNgJ8An8gBEH8AGoiABDuEkEvRgRAIAQoAoABIQEgBCgCfCECIARBxABqIgNBARDYLSAEKAJIIAQoAkxqQS86AAAgBCAJQQFqNgJMIARBADoAfCAEIANBAiAAIAkgAiABEL8BIAQoAgAhACAEKAIEDAELIARBCGohDiAEQcQAaiELIwBBIGsiBiQAIAYgCDYCECAGIAMiADYCDAJAAkACQAJAIAMgCEYNAANAIAAiAyEBA0ACQCABLAAAIgJBAE4EQCABQQFqIQAgAkH/AXEhBQwBCyABLQABQT9xIQAgAkEfcSEFIAJBX00EQCAFQQZ0IAByIQUgAUECaiEADAELIAEtAAJBP3EgAEEGdHIhDSACQXBJBEAgDSAFQQx0ciEFIAFBA2ohAAwBCyABQQRqIgAhAiAFQRJ0QYCA8ABxIAEtAANBP3EgDUEGdHJyIgVBgIDEAEYNBAtBASAFdEGAzABxRSAFQQ1LckUEQCAAIgEiAiAIRw0BDAQLCyAGIAA2AgwCQAJ/QQEgBUGAAUkNABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiDSAIIAFrIgJPBEAgAiANRg0BDAULIAEgDWosAABBv39MDQQLAkAgBUEjRwRAIAVBP0cEQCAFQYCAxABHDQIMBAsgAyECIAstACBFDQQMAQsgAyECIAstACBFDQMLIAsoAhgiAgRAIAIgCygCHCAFIAZBDGoQkAwLIAZBrJDEADYCHCAGIA02AhggBiABNgIUIAsgBkEUahCvHiAIIAAiAkcNAAsMAQsgACECCyAOIAg2AgQgDiACNgIAIAZBIGokAAwBCyABIAJBACANQcyGxAAQozYACyAEKAIIIQAgBCgCDAshASAEQfwAaiICIARBxABqQST8CgAAIAwgAkECIAcgCSAJIAkgBEHoAGpBACAEIAkgACABENEHDAkLIAUoAhQhBgJAIAUoAiAiAEUNACAFKAIYIgkgAE0EQCAAIAlGDQEMBgsgACAGaiwAAEG/f0wNBQsgBCgCJCEJIAcEQCAHIAlqLAAAQb9/TA0CCyAGIAAgCSAHEMEuRQ0FIARBADYCKCAEQfwAaiIAIARBIGpBJPwKAAAgDCAAIAMgCEEBIAUQxgIMCAsgBCAINgKAASAEIAU2AnwCQCAEQfwAahDuEkEjRwRAIAEoAhghAyABKAIUIQYCQCABKAIgQQFqIgJFDQAgAiADTwRAIAIgA0YNAQwGCyACIAZqLAAAQb9/TA0FCyAEQS82AnwgAiAGaiADIAJrIARB/ABqQQEQ9C4NAUEHIQEMCAsgBEH8AGoiAiAAQST8CgAAIAwgAiABIAUgCBCPEAwICyABKAIUIQMCQCABKAIgIgJFDQAgASgCGCIGIAJNBEAgAiAGRg0BDAMLIAIgA2osAABBv39MDQILIAMgAhCPJEH/AXEiAgRAIARB/ABqIgMgAEEk/AoAACAMIAMgBSAIIAIgARDGAgwICyAEQfwAaiICIABBJPwKAAAgDCACIAUgCCABELUBDAcLIAkgC0EAIAdBjIfEABCjNgALIAMgBkEAIAJBlJXEABCjNgALIAYgAyACIANBhJXEABCjNgALIAYgCUEAIABBlJXEABCjNgALAkAgBCgCOCIARQ0AIAQoAjwhBSAEQQA6AEwgBCAINgJIIAQgAzYCRCAEQYQBaiIDQQA2AgAgBEKAgICAEDcCfCAEQfwAaiAEQcQAahC6HCAEQfAAaiADKAIAIgM2AgAgBCAEKQJ8NwNoIAQoAmwgA0Gch8QAQQIQwS4gBEHoAGoQ3jsNACAAQQMgBSgCFBEAAAsgBEH8AGoiACAEQSBqQST8CgAAIAwgACACIAFBASAHEJQCDAILIAIgBUEAIABBlJXEABCjNgALIAxBAjYCACAMIAE6AAQgABDeOwsgBEGgAWokACAKQTBqJAALcgEDfyMAQfAAayICJAAgAkECaiIDIAFBIvwKAAAgAiACQSRqNgJsIAMhAUEAIQMDQCACQSRqIgQgA2ogAS8BADYCACABQQJqIQEgA0EEaiIDQcQARw0ACyACIAE2AmggACAEQcQA/AoAACACQfAAaiQAC4kBAQF/IAACfwJ/AkAgAkEATgRAAkAgAygCBARAIAMoAggiBEUEQCACDQIMBAsgAygCACAEIAEgAhCXNQwECyACRQ0CCyACIAEQrTYMAgsgAEEANgIEQQEMAgsgAQsiA0UEQCAAIAI2AgggACABNgIEQQEMAQsgACACNgIIIAAgAzYCBEEACzYCAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahCdDgsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahCdDgsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqEJ0OCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqEJ0OCyACQSBqJAALlwECAX8BfgJAIAApAwAiAkIGUQ0AAkACQAJAAkBBASACp0ECayACQgFYGw4DAQIDAAsgAEEIahCDKQ8LIAAoAggiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBCGoQ+x4PCyAAEJEqIAAoAkBBgCBBBBD4Og8LIABBCGoQ6TsgAEEgaiAAKAIYIAAoAhwgACgCFCgCEBEBAAsLjQEBAX8jAEEgayICJAAgASgCBARAIAJBEGogAUEIaigCADYCACACQQA6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQ1Q4LIAFBDGoiASgCBARAIAJBEGogAUEIaigCADYCACACQQA6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQ1Q4LIAJBIGokAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBAToAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahDVDgsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBAToAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahDVDgsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEAOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELQOCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEAOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELQOCyACQSBqJAALjQEBAX8jAEEgayICJAAgASgCBARAIAJBEGogAUEIaigCADYCACACQQE6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQtA4LIAFBDGoiASgCBARAIAJBEGogAUEIaigCADYCACACQQE6ABQgAkECOgAEIAIgASkCADcCCCAAIAJBBGoQtA4LIAJBIGokAAuOAQEBfyMAQTBrIgIkACACIAE2AgwgAAJ/Qf0HIAF2QQFxRSABQQpPckUEQCAAIAFB8I3PAGotAAA6AARBCAwBCyACQQE2AhQgAkHg+c4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQALNgIAIAJBMGokAAuNAQEBfyMAQSBrIgIkACABKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahC5EQsgAUEMaiIBKAIEBEAgAkEQaiABQQhqKAIANgIAIAJBADoAFCACQQI6AAQgAiABKQIANwIIIAAgAkEEahC5EQsgAkEgaiQAC40BAQF/IwBBIGsiAiQAIAEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELkRCyABQQxqIgEoAgQEQCACQRBqIAFBCGooAgA2AgAgAkEBOgAUIAJBAjoABCACIAEpAgA3AgggACACQQRqELkRCyACQSBqJAALpAEBBH8jAEEQayICJAAgASAAKAKgKksEQCACQQhqEP0nIAAoAsgBIQMgACACKAIINgLIASAAKALMASEEIAAgAigCDDYCzAEgAEG+KmoiBSADIAQQ4DUgAiAFIAEQuCkgAigCBCEDIAIoAgAhBCAAKALMASIFBEAgACgCyAEgBUEBEPg6CyAAIAE2AqAqIAAgAzYCzAEgACAENgLIAQsgAkEQaiQAC5cBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQCQCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALQQxBBBCtNiIBRQ0BIAEgAjYCCCABIAU2AgQgASAENgIAIABBKCABQfjg0AAQySkgA0EQaiQADwsgBCADKAIMQaji0AAQ/S8AC0EEQQwQoz0AC5cBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQCQCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALQQxBBBCtNiIBRQ0BIAEgAjYCCCABIAU2AgQgASAENgIAIABBFCABQei8+wAQySkgA0EQaiQADwsgBCADKAIMQay9+wAQ/S8AC0EEQQwQoz0AC40BAQN/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQJBAhDQKCAAKAIIIQILIAAoAgQgAkEBdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANBADsBACADQQJqIQMgBEEBayIEDQALIAEgAmpBAWshAgwBCyABRQ0BCyADQQA7AQAgAkEBaiECCyAAIAI2AggLlwEBA38jAEEQayIEJAAgBEEEaiADQQBBAUEBEKAYIAQoAgghBQJAIAQoAgRBAUcEQCAEKAIMIQYgAwRAIAYgAiAD/AoAAAtBDEEEEK02IgJFDQEgAiADNgIIIAIgBjYCBCACIAU2AgAgACABIAJB6KL+ABDJKSAEQRBqJAAPCyAFIAQoAgxB1KP+ABD9LwALQQRBDBCjPQALlwEBAX8jAEEwayICJAAgACgCACEAIAIgATYCACAAQQxqENk8IAFNBEAgAiAAEP47NgIcIAJBAjYCCCACQfCI/wA2AgQgAkICNwIQIAJBOzYCLCACQTs2AiQgAiACQSBqNgIMIAIgAkEcajYCKCACIAI2AiAgAkEEakGAif8AEO8sAAsgACgCECABQQF0ai8BACACQTBqJAALlwEBAX8jAEEwayICJAAgACgCACEAIAIgATYCACAAQQxqENs8IAFNBEAgAiAAEPw7NgIcIAJBAjYCCCACQfCI/wA2AgQgAkICNwIQIAJBOzYCLCACQTs2AiQgAiACQSBqNgIMIAIgAkEcajYCKCACIAI2AiAgAkEEakGAif8AEO8sAAsgACgCECABQQJ0aigCACACQTBqJAALmQECAX8BfiMAQTBrIgIkACAAKAIAIQAgAiABNgIAIABBDGoQ2DwgAU0EQCACIAAQ/Ts2AhwgAkECNgIIIAJB8Ij/ADYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQYCJ/wAQ7ywACyAAKAIQIAFBA3RqKQMAIAJBMGokAAuiAQECfwJAAkACQAJAQQIgACgCACIBQf////8HaiABQYCAgIB4TRtBAWsOAwABAgMLIAAoAggiAEUNAiAAENEaIABBEEEEEPg6DwsgAUGAgICAeEYNASAAKAIIIgIEQCAAKAIEIQEDQCABENEaIAFBEGohASACQQFrIgINAAsLIABBBEEQEOAeDwsgACgCCCIARQ0AIAAQ0RogAEEQQQQQ+DoLC6IBAQJ/AkACQAJAAkBBAiAAKAIAIgFB/////wdqIAFBgICAgHhNG0EBaw4DAAECAwsgACgCCCIARQ0CIAAQ0hogAEEQQQQQ+DoPCyABQYCAgIB4Rg0BIAAoAggiAgRAIAAoAgQhAQNAIAEQ0RogAUEQaiEBIAJBAWsiAg0ACwsgAEEEQRAQ4B4PCyAAKAIIIgBFDQAgABDSGiAAQRBBBBD4OgsLiQEBA38gACgCACAAKAIIIgJrIAFJBEAgACACIAEQ3yggACgCCCECCyAAKAIEIAJBAnRqIQMCQAJAIAFBAk8EQCABQQFrIQQDQCADQQA2AgAgA0EEaiEDIARBAWsiBA0ACyABIAJqQQFrIQIMAQsgAUUNAQsgA0EANgIAIAJBAWohAgsgACACNgIIC5MBAQN/IwBBIGsiAyQAIANCADcCCCADQQE6ABwgA0EIahCfJyICIAIoAgBBAWoiBDYCAAJAIAQEQCACKAIIDQEgAkF/NgIIIAJBDGoQ4icgAiACQQhqNgIYIAJB2KqIATYCFCACIAE2AhAgAiAANgIMIAJBADYCCBCUDSACEP0eIANBIGokAA8LAAtByKqIARCbPgALyQQCD38BfiMAQSBrIgQkACAEQRRqIAEoAgQgASgCAGtBBHZBAEEEQRAQoBggBCgCGCECIAQoAhRBAUYEQCACIAQoAhxB3N/CABD9LwALIARBEGoiDkEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEQayIGJAAgBEEIaiICIAEoAgQgASgCAGtBBHYQ1y0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQRBrIgckACAGQQRqIgUoAgQhCCAFKAIAIQ8CQAJAAkAgASgCACICIAEoAgQiA0cEQCAFKAIIIAhBBHRqIQUgAyACa0EEdiEKIAEoAgghCyABKAIMIQwDQAJ/IAsoAgQhCUEAIAsoAggiDSIDRQ0AGiACKQMAIRFBACEBIANBAUcEQANAIAEgA0EBdiIQIAFqIgEgCSABQQR0aikDACARVhshASADIBBrIgNBAUsNAAsLIAEgCSABQQR0aikDACARWGoLQQFrIgEgDU8NAiABIAwoAggiA08NAyAHIAFBBHQiASAMKAIEaiIDIAIpAwAgASAJaikDACIRfacgAygCCCIBIAJBCGopAwAgEX2nIgMgASADSRsQ0hAgBUEIaiAHQQhqKQIANwIAIAUgBykCADcCACACQRBqIQIgBUEQaiEFIAhBAWohCCAKQQFrIgoNAAsLIA8gCDYCACAHQRBqJAAMAgsgASANQYygwwAQwyEACyABIANBnKDDABDDIQALIAZBEGokACAAQQhqIA4oAgA2AgAgACAEKQIINwIAIARBIGokAAuMAQEBfwJAAkACQCAALQAgDgQBAgIAAgsgACgCHCIBIAEoAgBBAWsiATYCACABRQRAIABBHGoQshoLIAAoAhgiAUGEAU8EQCABEPIfCwsgACgCFCIBQYMBSwRAIAEQ8h8LIAAoAhAiAUEIahCVHyABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDHIQsLkwEBAX8CQAJAAkACQAJAAkAgAC0AIA4FAAUFAQIFCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEJ0nCyAAEN47IABBDGoQ3jsMAwsgAEEoahCqHgwBCyAAQShqENItCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEJ0nCyAAQRxqEK8sCwuTAQEBfwJAAkACQAJAAkACQCAALQAgDgUABQUBAgULIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQnScLIAAQ3jsgAEEMahDeOwwDCyAAQShqEMghDAELIABBKGoQ1S0LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQnScLIABBHGoQrywLC4YBAQJ/An8gACgCSCICQRFNBEAgAEHIAGohAyAAQQRqDAELIABBBGohAyAAKAIEIQIgACgCCAshACABIAJJBEAgAyACQQFrNgIAIAAgAUECdGoiACgCABogAiABQX9zakECdCIBBEAgACAAQQRqIAH8CgAACw8LQfyvzABBHUGcsMwAEJ8pAAucAgEFfyMAQTBrIgIkACACQRhqIgUgABCHIyACQQRqIQQgAigCGCEDIwBBIGsiACQAAkACQAJAIAMoAgggAU0EQCAEQYCAgIB4NgIADAELIAMoAgQgAUEUbGoiASgCDCIDIAMoAgAiBkEBajYCACAGQQBIDQEgAEEMaiABELwVIABBHGogASgCECIBNgIAIAQgACkCDDcCACAEQRBqIAE2AgAgACADNgIYIARBCGogAEEUaikCADcCAAsgAEEgaiQADAELAAsgBRCAKyACKAIEQYCAgIB4RwR/IAJBLGogAkEUaigCADYCACACQSRqIAJBDGopAgA3AgAgAiACKQIENwIcIAJBADYCGCAFEJ8nQQhqBUEACyACQTBqJAALkAEBAX8jAEEgayIFJAACQCADIARxIgMgAk0EQCABIANqIAIgA2sQtx4gBEEDdkEBcWoiASAAKAIEIgJJDQEgASACQbTNzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakGkzc4AEO8sAAsgACgCACABQQJ0aiAENgIAIAVBIGokAAuQAQEBfyMAQSBrIgUkAAJAIAMgBHEiAyACTQRAIAEgA2ogAiADaxCWGiAEQQN2QQNxaiIBIAAoAgQiAkkNASABIAJBtM3OABDDIQALIAVBADYCGCAFQQE2AgwgBUGY184ANgIIIAVCBDcCECAFQQhqQaTNzgAQ7ywACyAAKAIAIAFBAnRqIAQ2AgAgBUEgaiQAC5ABAQF/IwBBIGsiBSQAAkAgAyAEcSIDIAJNBEAgASADaiACIANrELYeIARBA3ZBA3FqIgEgACgCBCICSQ0BIAEgAkG0zc4AEMMhAAsgBUEANgIYIAVBATYCDCAFQZjXzgA2AgggBUIENwIQIAVBCGpBpM3OABDvLAALIAAoAgAgAUECdGogBDYCACAFQSBqJAAL8QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQcTSzAAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgASkDADcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL8QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQcTSzAAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASgCADYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAALlQMCB38BfiMAQSBrIgMkACADQRRqIAEoAgwgASgCBGtBA3ZBAEEIQRAQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxByJbPABD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAI2AggjAEEgayICJAAgA0EIaiIEIAEoAgwgASgCBGtBA3YQ6S0gBCkCBCEJIAJBCGogAUEIaikCADcDACACIAEpAgA3AwAgAiAJQiCJNwIYIAIgBEEIajYCFCACQRRqIQECQCACKAIEIgUgAigCDCIIRgRAIAEoAgQhBAwBCyABKAIIIAEoAgQiBEEEdGohBgNAIAUpAwAhCSACIAVBCGoiBTYCBCAGQQhqIAk3AwAgBkIBNwMAIAZBEGohBiAEQQFqIQQgBSAIRw0ACyABIAQ2AgQLIAEoAgAgBDYCACMAQRBrIgEkACABIAIoAgA2AgwgASACKAIINgIIIAFBCGoQ4zwgAUEQaiQAIAJBIGokACAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuaAQECfyMAQTBrIgIkAAJ/IAFFBEAgAkEANgIoIAJCgICAgMAANwIgIAIgAkEgakGMh84AEJ0hIAIoAgAhASACKAIEDAELIAJBKGpCADcDACACQgA3AyAgAkEUaiIDIAJBIGogARCDHCACQQhqIANBzILOABCdISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBMGokAAvOAgEEfyMAQSBrIgEkACMAQRBrIgMkACADQQhqIwBBIGsiAiQAIAJBDGpBoLTCAEGgtMIAELgqEJ0JIAIoAgxBAUYEQCACIAIpAhA3AxhB2PDQAEEbIAJBGGpBrO/QAEH08NAAENUeAAsgAikCEDcDACACQSBqJAAgAygCDCECIAFBCGoiBCADKAIINgIAIAQgAjYCBCADQRBqJAAgASgCCCEFIAFBFGogASgCDCICQQBBAUEBEKAYIAEoAhghAyABKAIUQQFHBEAgASgCHCEEIAIEQCAEIAUgAvwKAAALIAEgAjYCHCABIAQ2AhggASADNgIUQQxBBBCtNiICRQRAQQRBDBCjPQALIAIgAUEUaiIDKQIANwIAIAJBCGogA0EIaigCADYCACAAQSggAkHw7tAAEMkpIAFBIGokAA8LIAMgASgCHEGc79AAEP0vAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQN2IgUQ7C0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQN0aiEDA0AgAyABKQMAQugHfjcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL+AEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAEKAlOvcA343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC4EDAgh/An4jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIghBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiBSQAIAJBCGoiAyABKAIEIAEoAgBrQQN2EOwtIAUgAykCBEIgiTcCCCAFIANBCGo2AgQgBUEEaiIEKAIEIQYgBCgCACEJAkACQAJAIAEoAgAiByABKAIEIgNHBEAgASgCCCEBIAQoAgggBkEDdGohBCADIAdrQQN2IQMDQCABKAIAKQMAIgpQDQIgBykDACILQoCAgICAgICAgH9RIApCf1FxDQMgBCALIAp/NwMAIAdBCGohByAEQQhqIQQgBkEBaiEGIANBAWsiAw0ACwsgCSAGNgIADAILQfyzgAEQ4isAC0H8s4ABEOYrAAsgBUEQaiQAIABBCGogCCgCADYCACAAIAIpAgg3AgAgAkEgaiQAC/UBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAEpAwBC6Ad/NwMAIAFBCGohASADQQhqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv2AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQN2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKQMAQsCEPX8+AgAgAUEIaiEBIANBBGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCwIQ9fjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9wEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAEKAuJkpfjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9gEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgASkDAELAhD1+NwMAIAFBCGohASADQQhqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv5AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7C0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQN0aiEDA0AgAyABNAIAQoDA3e7BAn43AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC4EDAgh/An4jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIghBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiBSQAIAJBCGoiAyABKAIEIAEoAgBrQQN2EOwtIAUgAykCBEIgiTcCCCAFIANBCGo2AgQgBUEEaiIEKAIEIQYgBCgCACEJAkACQAJAIAEoAgAiByABKAIEIgNHBEAgASgCCCEBIAQoAgggBkEDdGohBCADIAdrQQN2IQMDQCABKAIAKQMAIgpQDQIgBykDACILQoCAgICAgICAgH9RIApCf1FxDQMgBCALIAp/NwMAIAdBCGohByAEQQhqIQQgBkEBaiEGIANBAWsiAw0ACwsgCSAGNgIADAILQYy0gAEQ4isAC0GMtIABEOYrAAsgBUEQaiQAIABBCGogCCgCADYCACAAIAIpAgg3AgAgAkEgaiQAC/oBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCgIC8isnSE343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/gBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDuLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBAnRqIQMDQCADIAEpAwBCgJTr3AN/PgIAIAFBCGohASADQQRqIQMgBUEBayIFDQALBSAGCzYCCCAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKAIAQegHbDYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASkDAELoB38+AgAgAUEIaiEBIANBBGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBAnYiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAE0AgBCgKMFfjcDACABQQRqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0ECdiIFEOwtIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkEDdGohAwNAIAMgATQCAELoB343AwAgAUEEaiEBIANBCGohAyAFQQFrIgUNAAsFIAYLNgIIIABBCGogBygCADYCACAAIAIpAgg3AgAgAkEgaiQAC/YBAQZ/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHcj/8AEP0vAAsgAkEQaiIHQQA2AgAgAiACKAIcNgIMIAIgAzYCCCACQQhqIgMgASgCBCIEIAEoAgAiAWtBA3YiBRDsLSADKAIIIQYgAyABIARHBH8gBSAGaiADKAIEIAZBA3RqIQMDQCADIAEpAwBCwIQ9fzcDACABQQhqIQEgA0EIaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL3gEBB38jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIGayIHQQJ2IggQ7C0gAygCCCEBIAMgBCAGRwR/IAdBAXQiBARAIAMoAgQgAUEDdGpBACAE/AsACyABIAhqBSABCzYCCCAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxB3I//ABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AgggAkEIaiIDIAEoAgQiBCABKAIAIgFrQQJ2IgUQ7i0gAygCCCEGIAMgASAERwR/IAUgBmogAygCBCAGQQJ0aiEDA0AgAyABKAIAQegHbTYCACABQQRqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAAL9wEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQdyP/wAQ/S8ACyACQRBqIgdBADYCACACIAIoAhw2AgwgAiADNgIIIAJBCGoiAyABKAIEIgQgASgCACIBa0EDdiIFEO4tIAMoAgghBiADIAEgBEcEfyAFIAZqIAMoAgQgBkECdGohAwNAIAMgASkDAEKAuJkpfz4CACABQQhqIQEgA0EEaiEDIAVBAWsiBQ0ACwUgBgs2AgggAEEIaiAHKAIANgIAIAAgAikCCDcCACACQSBqJAALygQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiICIAEoAgQgASgCAGtBA3YQ7C0gAikCBCEPIARBGGogAUEQaikCADcDACAEQRBqIAFBCGopAgA3AwAgBCABKQIANwMIIAQgD0IgiTcCKCAEIAJBCGo2AiQjAEEwayIBJAAgBEEkaiIFKAIEIQcgBSgCACEMAkACQAJAIARBCGoiAigCACIGIAIoAgQiCEcEQCACKAIUIQkgAigCECENIAIoAgwhDiACKAIIIQIgBSgCCCAHQQN0aiEFIAggBmtBA3YhCANAIAEgBjYCDAJAIAYoAgAiCiANSQRAIA4gCkEDdGopAwAhDwwBCyACIAkoAhBPDQNCACEPIAkoAgQgAiAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAFIA83AwAgBkEIaiEGIAVBCGohBSACQQFqIQIgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAFBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAFBATYCFCABQdy2ggE2AhAgAUIBNwIcIAFBuhM2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQeS2ggEQ7ywACyAEQTBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAALygQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAQ2AggjAEEwayIEJAAgA0EIaiICIAEoAgQgASgCAGtBA3YQ7C0gAikCBCEPIARBGGogAUEQaikCADcDACAEQRBqIAFBCGopAgA3AwAgBCABKQIANwMIIAQgD0IgiTcCKCAEIAJBCGo2AiQjAEEwayIBJAAgBEEkaiIFKAIEIQcgBSgCACEMAkACQAJAIARBCGoiAigCACIGIAIoAgQiCEcEQCACKAIUIQkgAigCECENIAIoAgwhDiACKAIIIQIgBSgCCCAHQQN0aiEFIAggBmtBA3YhCANAIAEgBjYCDAJAIAYoAgAiCiANSQRAIA4gCkEDdGopAwAhDwwBCyACIAkoAhBPDQNCACEPIAkoAgQgAiAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAFIA83AwAgBkEIaiEGIAVBCGohBSACQQFqIQIgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAFBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAFBATYCFCABQdy2ggE2AhAgAUIBNwIcIAFByBA2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQeS2ggEQ7ywACyAEQTBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyjwQ9y8gBEEcaiABIAIoAgAQyjwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyTwQ9y8gBEEcaiABIAIoAgAQyTwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOwtIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQN0aisDADkDACAGQQhqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQhS4gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQ3RkgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEGggoMBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhDsLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEDdGohASAHIAZrQQJ2IQUDQCAGKAIAIgcgCE8NAiABIAsgB0EDdGopAwA3AwAgBkEEaiEGIAFBCGohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQby0ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAALgAMCCn8BfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQ6S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgYoAgQhBCAGKAIAIQoCQAJAIAEoAgAiByABKAIEIgVHBEAgASgCDCEIIAEoAgghCyAGKAIIIARBBHRqIQEgBSAHa0EDdiEGA0AgCCAHKAIAIgVNDQIgCyAFQQR0aiIFKQMAIQwgAUEIaiAFQQhqKQMANwMAIAEgDDcDACAHQQhqIQcgAUEQaiEBIARBAWohBCAGQQFrIgYNAAsLIAogBDYCAAwBCyAFIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvLBgIRfwJ+IwBBIGsiBCQAIARBFGogASgCBCABKAIAa0EDdkEAQRBBEBCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHIy4MBEP0vAAsgBEEQaiIQQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCMAQTBrIgMkACABKAIEIAEoAgBrQQN2IgggBEEIaiIFKAIAIAUoAggiBmtLBEAgBSAGIAhBEEEQEN4oIAUoAgghBgsgBSgCBCEIIANBGGogAUEQaikCADcDACADQRBqIAFBCGopAgA3AwAgAyABKQIANwMIIAMgCDYCLCADIAY2AiggAyAFQQhqNgIkIANBJGoiCigCBCEIIAooAgAhEQJAAkACQAJAAkACQAJAIANBCGoiASgCACIFIAEoAgQiB0cEQCABKAIUIQYgASgCECEMIAEoAgwhDSABKAIIIQ4gCigCCCAIQQR0aiEKIAcgBWtBA3YhDwNAIAUoAgAiASAOKAIIIgdPDQIgAUECdCIJIA4oAgRqKAIAIgcoAhwiAkUNAyAFQQRqKAIAIgsgBygCIEEEdk8NAyACIAtBBHRqIgIpAwghEyACKQMAIhSnQQ1PBEAgASANKAIIIgJPDQUgE6ciASANKAIEIAlqKAIAaiIJIAwoAggiAk8NBgJAIAwoAgQgCUEDdGoiCSgCAEEBRgRAIAkoAgQhAQwBCyAHKAIIIgIgAU0NCSAHKAIEIAFBDGxqIgEoAgAiByAHKAIAIgJBAWo2AgAgAkEASA0IIAEoAgghCyABKAIEIRIgBigCCCIBIAYoAgBGBEAgBkGktoIBEJAoCyAGKAIEIAFBDGxqIgIgCzYCCCACIBI2AgQgAiAHNgIAIAkgATYCBCAJQQE2AgAgBiABQQFqNgIICyABrSATQoCAgIBwg4QhEwsgCiAUNwMAIAogEzcDCCAFQQhqIQUgCkEQaiEKIAhBAWohCCAPQQFrIg8NAAsLIBEgCDYCAAwGCyABIAdB1LWCARDDIQALQeS1ggEQsjsACyABIAJB9LWCARDDIQALIAkgAkGEtoIBEMMhCwALIAEgAkGUtoIBEMMhAAsgA0EwaiQAIABBCGogECgCADYCACAAIAQpAgg3AgAgBEEgaiQAC4EEAQt/IwBBIGsiAyQAIANBFGogASgCBCABKAIAa0EDdkEAQQhBCBCgGCADKAIYIQIgAygCFEEBRgRAIAIgAygCHEHIy4MBEP0vAAsgA0EQaiILQQA2AgAgAyADKAIcNgIMIAMgAjYCCCMAQRBrIgYkACADQQhqIgIgASgCBCABKAIAa0EDdhDsLSAGIAIpAgRCIIk3AgggBiACQQhqNgIEIwBBMGsiAiQAIAZBBGoiBCgCBCEHIAQoAgAhDAJAAkACQCABKAIAIgUgASgCBCIIRwRAIAQoAgggB0EDdGohBCAIIAVrQQN2IQggASgCCCEKA0AgBSgCACIBIAooAggiCU8NAiAKKAIEIAFBAnRqKAIAIQEgAiAFQQRqKAIAIgk2AgAgAUEMahDYPCAJTQ0DIAQgASgCECAJQQN0aikDADcDACAFQQhqIQUgBEEIaiEEIAdBAWohByAIQQFrIggNAAsLIAwgBzYCACACQTBqJAAMAgsgASAJQfy0ggEQwyEACyACIAEQ/Ts2AhwgAkECNgIIIAJBqLGCATYCBCACQgI3AhAgAkE7NgIsIAJBOzYCJCACIAJBIGo2AgwgAiACQRxqNgIoIAIgAjYCICACQQRqQbixggEQ7ywACyAGQRBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBCEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQJ2EOwtIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBAnYhBQNAIAYoAgAiByAITw0CIAEgCyAHQQN0aikDADcDACAGQQRqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQ7C0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBA3RqIQEgByAGa0EDdiEFA0AgCCAGKAIAIgdNDQIgASALIAdBA3RqKQMANwMAIAZBCGohBiABQQhqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDuLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahDcGSADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALqAMBCn8jAEEgayIEJAAgBEEUaiABKAIEIAEoAgBrQQJ2QQBBBEEIEKAYIAQoAhghAyAEKAIUQQFGBEAgAyAEKAIcIAIQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCADNgIIIwBBEGsiAiQAIAEoAgQgASgCAGtBAnYiByAEQQhqIgMoAgAgAygCCCIFa0sEQCADIAUgB0EEQQgQ3iggAygCCCEFCyACIAMoAgQ2AgwgAiAFNgIIIAIgA0EIajYCBCACQQRqIgcoAgQhAyAHKAIAIAEoAgAiBSABKAIEIgZHBEAgASgCCCELIAcoAgggA0EDdGohASADIAYgBWtBAnYiB2ohAwNAIAsoAgAiBiAFKAIAIggoAggiDE8EQCAGIAxBsPeFARDDIQALIAgoAgQgBkEDdGoiBigCACEIIAFBBGogBigCBCIGNgIAIAEgCCAGKAIIQQFrQXhxakEIajYCACAFQQRqIQUgAUEIaiEBIAdBAWsiBw0ACwsgAzYCACACQRBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAALmAMCCn8CfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEQQSAQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBA3YQ7y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyADKAIIIAVBBXRqIQEgByAGa0EDdiEHA0AgCCAGKAIAIgNNDQIgCyADQQV0aiIDKQMAIQwgAUEQaiADKQMQNwMAIAMpAwghDSABQRhqIAMpAxg3AwAgASAMNwMAIAEgDTcDCCAGQQhqIQYgAUEgaiEBIAVBAWohBSAHQQFrIgcNAAsLIAogBTYCAAwBCyADIAhB9LaCARDDIQALIARBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAuXBAINfwF+IwBBIGsiAyQAIANBFGogASgCBCABKAIAa0ECdkEAQQhBCBCgGCADKAIYIQIgAygCFEEBRgRAIAIgAygCHEG8/IEBEP0vAAsgA0EQaiILQQA2AgAgAyADKAIcNgIMIAMgAjYCCCMAQRBrIgYkACADQQhqIgIgASgCBCABKAIAa0ECdhDsLSAGIAIpAgRCIIk3AgggBiACQQhqNgIEIwBBMGsiAiQAIAZBBGoiBCgCBCEHIAQoAgAhDAJAAkACQCABKAIAIgUgASgCBCIIRwRAIAEoAhQhCSABKAIQIQ0gASgCDCEOIAEoAgghASAEKAIIIAdBA3RqIQQgCCAFa0ECdiEIA0AgAiAFNgIMAkAgDSAFKAIAIgpLBEAgDiAKQQN0aikDACEPDAELIAEgCSgCEE8NA0IAIQ8gCSgCBCABIAkoAgxqIgpBA3ZqLQAAIApBB3F2QQFxDQQLIAQgDzcDACAFQQRqIQUgBEEIaiEEIAFBAWohASAHQQFqIQcgCEEBayIIDQALCyAMIAc2AgAgAkEwaiQADAILQYyyggFBIEGssoIBEJ8pAAsgAkEBNgIUIAJB3LaCATYCECACQgE3AhwgAkG7EzYCLCACIAJBKGo2AhggAiACQQxqNgIoIAJBEGpB5LaCARDvLAALIAZBEGokACAAQQhqIAsoAgA2AgAgACADKQIINwIAIANBIGokAAuYAwIKfwJ+IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQRBBIBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgASgCBCABKAIAa0ECdhDvLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiAygCBCEFIAMoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAMoAgggBUEFdGohASAHIAZrQQJ2IQcDQCAGKAIAIgMgCE8NAiALIANBBXRqIgMpAwAhDCABQRBqIAMpAxA3AwAgAykDCCENIAFBGGogAykDGDcDACABIAw3AwAgASANNwMIIAZBBGohBiABQSBqIQEgBUEBaiEFIAdBAWsiBw0ACwsgCiAFNgIADAELIAMgCEH0toIBEMMhAAsgBEEQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEHIy4MBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDuLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahD1ESADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALzwEBBH8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOstIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgASADQQRqEJAZIANBEGokACAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEECQQIQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBAXRqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBAXRqLwEAOwEAIAZBBGohBiABQQJqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQJBAhCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhDtLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEBdGohASAHIAZrQQN2IQUDQCAIIAYoAgAiB00NAiABIAsgB0EBdGovAQA7AQAgBkEIaiEGIAFBAmohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQfS2ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAALlwQCDX8BfiMAQSBrIgMkACADQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxBvPyBARD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAI2AggjAEEQayIGJAAgA0EIaiICIAEoAgQgASgCAGtBAnYQ7C0gBiACKQIEQiCJNwIIIAYgAkEIajYCBCMAQTBrIgIkACAGQQRqIgQoAgQhByAEKAIAIQwCQAJAAkAgASgCACIFIAEoAgQiCEcEQCABKAIUIQkgASgCECENIAEoAgwhDiABKAIIIQEgBCgCCCAHQQN0aiEEIAggBWtBAnYhCANAIAIgBTYCDAJAIA0gBSgCACIKSwRAIA4gCkEDdGopAwAhDwwBCyABIAkoAhBPDQNCACEPIAkoAgQgASAJKAIMaiIKQQN2ai0AACAKQQdxdkEBcQ0ECyAEIA83AwAgBUEEaiEFIARBCGohBCABQQFqIQEgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAJBMGokAAwCC0GMsoIBQSBBrLKCARCfKQALIAJBATYCFCACQdy2ggE2AhAgAkIBNwIcIAJB7QY2AiwgAiACQShqNgIYIAIgAkEMajYCKCACQRBqQeS2ggEQ7ywACyAGQRBqJAAgAEEIaiALKAIANgIAIAAgAykCCDcCACADQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEEEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EO4tIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQJ0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQJ0aioCADgCACAGQQhqIQYgAUEEaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7i0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBAnRqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBAnRqKgIAOAIAIAZBBGohBiABQQRqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC+gCAQp/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQRBCBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIJQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhDqLSADIAQpAgRCIIk3AgggAyAEQQhqNgIEIANBBGoiBSgCBCEEIAUoAgAhCgJAAkAgASgCACIGIAEoAgQiB0cEQCABKAIMIQggASgCCCELIAUoAgggBEEDdGohASAHIAZrQQJ2IQUDQCAGKAIAIgcgCE8NAiABIAsgB0EDdGopAgA3AgAgBkEEaiEGIAFBCGohASAEQQFqIQQgBUEBayIFDQALCyAKIAQ2AgAMAQsgByAIQfS2ggEQwyEACyADQRBqJAAgAEEIaiAJKAIANgIAIAAgAikCCDcCACACQSBqJAAL9QEBBn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgZBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAEoAgQgASgCAGtBAnYiByACQQhqIgQoAgAgBCgCCCIFa0sEQCAEIAUgB0EQQRAQ3iggBCgCCCEFCyADIAQoAgQ2AgwgAyAFNgIIIAMgBEEIajYCBCABIANBBGoQjxkgA0EQaiQAIABBCGogBigCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC7GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALgAMCCn8BfiMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ6S0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgYoAgQhBCAGKAIAIQoCQAJAIAEoAgAiByABKAIEIgVHBEAgASgCDCEIIAEoAgghCyAGKAIIIARBBHRqIQEgBSAHa0ECdiEGA0AgBygCACIFIAhPDQIgCyAFQQR0aiIFKQMAIQwgAUEIaiAFQQhqKQMANwMAIAEgDDcDACAHQQRqIQcgAUEQaiEBIARBAWohBCAGQQFrIgYNAAsLIAogBDYCAAwBCyAFIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAvoAgEKfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEIQQgQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiCUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7C0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCADQQRqIgUoAgQhBCAFKAIAIQoCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCDCEIIAEoAgghCyAFKAIIIARBA3RqIQEgByAGa0ECdiEFA0AgBigCACIHIAhPDQIgASALIAdBA3RqKwMAOQMAIAZBBGohBiABQQhqIQEgBEEBaiEEIAVBAWsiBQ0ACwsgCiAENgIADAELIAcgCEH0toIBEMMhAAsgA0EQaiQAIABBCGogCSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhCBLiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC6GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAAL6AIBCn8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQN2QQBBBEEIEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIglBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQN2EOotIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgA0EEaiIFKAIEIQQgBSgCACEKAkACQCABKAIAIgYgASgCBCIHRwRAIAEoAgwhCCABKAIIIQsgBSgCCCAEQQN0aiEBIAcgBmtBA3YhBQNAIAggBigCACIHTQ0CIAEgCyAHQQN0aikCADcCACAGQQhqIQYgAUEIaiEBIARBAWohBCAFQQFrIgUNAAsLIAogBDYCAAwBCyAHIAhB9LaCARDDIQALIANBEGokACAAQQhqIAkoAgA2AgAgACACKQIINwIAIAJBIGokAAv1AQEGfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEQQRAQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBkEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgASgCBCABKAIAa0EDdiIHIAJBCGoiBCgCACAEKAIIIgVrSwRAIAQgBSAHQRBBEBDeKCAEKAIIIQULIAMgBCgCBDYCDCADIAU2AgggAyAEQQhqNgIEIAEgA0EEahCQGSADQRBqJAAgAEEIaiAGKAIANgIAIAAgAikCCDcCACACQSBqJAALmwUBEn8jAEEgayIFJAAgBUEUaiABKAIEIAEoAgBrQQJ2QQBBBEEUEKAYIAUoAhghAiAFKAIUQQFGBEAgAiAFKAIcQcjLgwEQ/S8ACyAFQRBqIg5BADYCACAFIAUoAhw2AgwgBSACNgIIIwBBIGsiAyQAIAEoAgQgASgCAGtBAnYiByAFQQhqIgIoAgAgAigCCCIGa0sEQCACIAYgB0EEQRQQ3iggAigCCCEGCyACKAIEIQcgA0EQaiABQRBqKAIANgIAIANBCGogAUEIaikCADcDACADIAEpAgA3AwAgAyAHNgIcIAMgBjYCGCADIAJBCGo2AhQjAEEwayIEJAAgA0EUaiIBKAIEIQggASgCACEPAkACQCADKAIAIgwgAygCBCICRwRAIAEoAgghECADKAIMIQYgAygCCCELIAMoAhAiEUEDdEEIayEHIAIgDGtBAnYhEgNAIARBCGoiASAMIApBAnRqIgIoAgAQyzwQ9y8gBEEcaiABIAIoAgAQyzwQtxkgByECIAYhAQJAIBFFDQADQCABKAIAIAtGBEAgAUEEaigCACENIAQgBEEcahCGPSANQQN2IgkgBCgCBCITTw0FIAQoAgAgCWoiCSAJLQAAQQEgDUEHcXRyOgAACyACRQ0BIAFBCGohASACQQhrIQIMAAsACyAEQQhqIARBHGoiARCEFCABEM8vIBAgCEEUbGoiASAEKQIINwIAIAFBEGogBEEYaigCADYCACABQQhqIARBEGopAgA3AgAgC0EBaiELIAhBAWohCCAKQQFqIgogEkcNAAsLIA8gCDYCACAEQTBqJAAMAQsgCSATQfyxggEQwyEACyADQSBqJAAgAEEIaiAOKAIANgIAIAAgBSkCCDcCACAFQSBqJAALzwEBBH8jAEEgayICJAAgAkEUaiABKAIEIAEoAgBrQQJ2QQBBEEEQEKAYIAIoAhghAyACKAIUQQFGBEAgAyACKAIcQbz8gQEQ/S8ACyACQRBqIgVBADYCACACIAIoAhw2AgwgAiADNgIIIwBBEGsiAyQAIAJBCGoiBCABKAIEIAEoAgBrQQJ2EOstIAMgBCkCBEIgiTcCCCADIARBCGo2AgQgASADQQRqEI8ZIANBEGokACAAQQhqIAUoAgA2AgAgACACKQIINwIAIAJBIGokAAubBQESfyMAQSBrIgUkACAFQRRqIAEoAgQgASgCAGtBAnZBAEEEQRQQoBggBSgCGCECIAUoAhRBAUYEQCACIAUoAhxByMuDARD9LwALIAVBEGoiDkEANgIAIAUgBSgCHDYCDCAFIAI2AggjAEEgayIDJAAgASgCBCABKAIAa0ECdiIHIAVBCGoiAigCACACKAIIIgZrSwRAIAIgBiAHQQRBFBDeKCACKAIIIQYLIAIoAgQhByADQRBqIAFBEGooAgA2AgAgA0EIaiABQQhqKQIANwMAIAMgASkCADcDACADIAc2AhwgAyAGNgIYIAMgAkEIajYCFCMAQTBrIgQkACADQRRqIgEoAgQhCCABKAIAIQ8CQAJAIAMoAgAiDCADKAIEIgJHBEAgASgCCCEQIAMoAgwhBiADKAIIIQogAygCECIRQQN0QQhrIQcgAiAMa0ECdiESA0AgBEEIaiIBIAwgC0ECdGoiAigCACgCIBD3LyAEQRxqIAEgAigCACgCIBC3GSAHIQIgBiEBAkAgEUUNAANAIAEoAgAgCkYEQCABQQRqKAIAIQ0gBCAEQRxqEIY9IA1BA3YiCSAEKAIEIhNPDQUgBCgCACAJaiIJIAktAABBASANQQdxdHI6AAALIAJFDQEgAUEIaiEBIAJBCGshAgwACwALIARBCGogBEEcaiIBEIQUIAEQzy8gECAIQRRsaiIBIAQpAgg3AgAgAUEQaiAEQRhqKAIANgIAIAFBCGogBEEQaikCADcCACAKQQFqIQogCEEBaiEIIAtBAWoiCyASRw0ACwsgDyAINgIAIARBMGokAAwBCyAJIBNB/LGCARDDIQALIANBIGokACAAQQhqIA4oAgA2AgAgACAFKQIINwIAIAVBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBA3ZBAEEBQQEQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBA3YQgS4gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQuxsgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0EDdkEAQQRBBBCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0EDdhCFLiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahDcGSADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALgQQBC38jAEEgayIDJAAgA0EUaiABKAIEIAEoAgBrQQN2QQBBAkECEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQcjLgwEQ/S8ACyADQRBqIgtBADYCACADIAMoAhw2AgwgAyACNgIIIwBBEGsiBiQAIANBCGoiAiABKAIEIAEoAgBrQQN2EO0tIAYgAikCBEIgiTcCCCAGIAJBCGo2AgQjAEEwayICJAAgBkEEaiIEKAIEIQcgBCgCACEMAkACQAJAIAEoAgAiBSABKAIEIghHBEAgBCgCCCAHQQF0aiEEIAggBWtBA3YhCCABKAIIIQoDQCAFKAIAIgEgCigCCCIJTw0CIAooAgQgAUECdGooAgAhASACIAVBBGooAgAiCTYCACABQQxqENk8IAlNDQMgBCABKAIQIAlBAXRqLwEAOwEAIAVBCGohBSAEQQJqIQQgB0EBaiEHIAhBAWsiCA0ACwsgDCAHNgIAIAJBMGokAAwCCyABIAlB/LSCARDDIQALIAIgARD+OzYCHCACQQI2AgggAkGosYIBNgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBuLGCARDvLAALIAZBEGokACAAQQhqIAsoAgA2AgAgACADKQIINwIAIANBIGokAAvPAQEEfyMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAnZBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxBvPyBARD9LwALIAJBEGoiBUEANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIDJAAgAkEIaiIEIAEoAgQgASgCAGtBAnYQ7i0gAyAEKQIEQiCJNwIIIAMgBEEIajYCBCABIANBBGoQ3RkgA0EQaiQAIABBCGogBSgCADYCACAAIAIpAgg3AgAgAkEgaiQAC88BAQR/IwBBIGsiAiQAIAJBFGogASgCBCABKAIAa0ECdkEAQQFBARCgGCACKAIYIQMgAigCFEEBRgRAIAMgAigCHEG8/IEBEP0vAAsgAkEQaiIFQQA2AgAgAiACKAIcNgIMIAIgAzYCCCMAQRBrIgMkACACQQhqIgQgASgCBCABKAIAa0ECdhCELiADIAQpAgRCIIk3AgggAyAEQQhqNgIEIAEgA0EEahC6GyADQRBqJAAgAEEIaiAFKAIANgIAIAAgAikCCDcCACACQSBqJAALoQMBCn8jAEEgayIEJAAgBEEUaiABKAIEIAEoAgBrQQN2QQBBBEEIEKAYIAQoAhghAyAEKAIUQQFGBEAgAyAEKAIcIAIQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCADNgIIIwBBEGsiAiQAIAEoAgQgASgCAGtBA3YiBiAEQQhqIgMoAgAgAygCCCIFa0sEQCADIAUgBkEEQQgQ3iggAygCCCEFCyACIAMoAgQ2AgwgAiAFNgIIIAIgA0EIajYCBCMAQRBrIgYkACACQQRqIgcoAgQhBSAHKAIAIAEoAgAiAyABKAIEIghHBEAgASgCDCELIAEoAgghDCAHKAIIIAVBA3RqIQEgBSAIIANrQQN2IgdqIQUDQCAGQQhqIAMoAgAgA0EEaigCACIIKAIIQQFrQXhxakEIaiAMKAIAIAsoAgAgCCgCIBEFACABIAYpAwg3AgAgA0EIaiEDIAFBCGohASAHQQFrIgcNAAsLIAU2AgAgBkEQaiQAIAJBEGokACAAQQhqIAkoAgA2AgAgACAEKQIINwIAIARBIGokAAuaAQECfyMAQTBrIgMkACADIAI2AgAgASgCMCIEIAJNBEAgAyAENgIcIANBAjYCCCADQfSfhgE2AgQgA0ICNwIQIANBOzYCLCADQTs2AiQgAyADQSBqNgIMIAMgA0EcajYCKCADIAM2AiAgA0EEakGEoIYBEO8sAAsgACABKAI0IgQ2AgQgACABKAIQIAIgBGxqNgIAIANBMGokAAubAQAgAEEANgIwIABBADYCACAAIAEpAhg3AiAgACABKQIMNwIUIAAgASkCLDcCPCAAIAEoAig2AlQgAEEcaiABQRRqKAIANgIAIABBxABqIAFBNGopAgA3AgAgAEHMAGogAUE8aikCADcCACAAQShqIAFBIGopAgA3AgAgAEEAOwFYIABBEGogAUEIaigCADYCACAAIAEpAgA3AggLjAEBAX8gAUEATgRAAn8CQCACKAIEBEAgAigCCCIDRQRAIAENAkEBDAMLIAIoAgAgA0EBIAEQlzUMAgsgAQ0AQQEMAQsgAUEBEK02CyICRQRAIAAgATYCCCAAQQE2AgQgAEEBNgIADwsgACABNgIIIAAgAjYCBCAAQQA2AgAPCyAAQQA2AgQgAEEBNgIAC44BAQR/IwBBEGsiAiQAAn9BASABKAIAIgNBJyABKAIEIgUoAhAiARECAA0AGiACIAAoAgBBgQIQjwkCQCACLQANIgBBgQFPBEAgAyACKAIAIAERAgBFDQFBAQwCCyADIAIgAi0ADCIEaiAAIARrIAUoAgwRBgBFDQBBAQwBCyADQScgARECAAsgAkEQaiQAC8YVAiZ/Dn4jAEEgayINJAAgDUEUaiACIAFrQQZ2QQBBCEHQABCgGCANKAIYIQMgDSgCFEEBRgRAIAMgDSgCHEGUvMMAEP0vAAsgDUEQaiIhQQA2AgAgDSANKAIcNgIMIA0gAzYCCCMAQRBrIhQkACACIAFrQQZ2IgwgDUEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAxBCEHQABDQKCADKAIIIQQLIBQgAygCBDYCDCAUIAQ2AgggFCADQQhqNgIEIwBB0ABrIgwkACAUQQRqIgMoAgQhFiADKAIAIAEgAkcEQCADKAIIIBZB0ABsaiEbIBYgAiABa0EGdiICaiEWA0BCACEqIAEoAiQiFyABKAIoIhxBwAJsaiEEIwBBIGsiDiQAIA5BFGogBCAXa0HAAm5BAEEIQegDEKAYIA4oAhghAyAOKAIUQQFGBEAgAyAOKAIcQbjmzwAQ/S8ACyAOQRBqIiNBADYCACAOIA4oAhw2AgwgDiADNgIIIwBBEGsiFSQAIAQgF2tBwAJuIgogDkEIaiIDKAIAIAMoAggiBWtLBEAgAyAFIApBCEHoAxDQKCADKAIIIQULIBUgAygCBDYCDCAVIAU2AgggFSADQQhqNgIEIwBB8ANrIh8kACAVQQRqIgUoAgQhGCAFKAIAIAQgFyIDRwRAIAUoAgggGEHoA2xqIR0gGCAEIANrQcACbiIgaiEYA0BBACEZQQAhHiMAQZADayIGJABCACEpIwBBkAFrIgckACADKAKkAiEEAn4CQAJAAkAgAygCUEUEQCAEQYCAgIB4Rw0BIAMoArACQYCAgIB4Rw0CQgIMBAsgBEGAgICAeEYNAQsgByADQaQCahClHQwBCyAHQYCAgIB4NgIACwJAIAMoArACQYCAgIB4RwRAIAdBEGogA0GwAmoQpR0MAQsgB0GAgICAeDYCEAsgAykDWCEpIAMpA1ALISsgAygCvAJBCGoQ3SUhESADKAKEAiIFIAMoAogCaiEEIwBBIGsiCiQAIApBFGogBCAFa0EAQQRBBBCgGCAKKAIYIQ8gCigCFEEBRgRAIA8gCigCHEG45s8AEP0vAAsgCkEQaiITQQA2AgAgCiAKKAIcNgIMIAogDzYCCCMAQRBrIg8kACAEIAVrIgsgCkEIaiIIKAIAIAgoAggiCWtLBEAgCCAJIAtBBEEEENAoIAgoAgghCQsgH0EIaiELIAdBHGohEiAPIAgoAgQ2AgwgDyAJNgIIIA8gCEEIajYCBCAPQQRqIhAoAgQhCCAQKAIAIAQgBUcEfyAEIAVrIQkgBCAIaiAFayAQKAIIIAhBAnRqIQQDQCAEIAUtAABBAnRBtOzQAGooAgA2AgAgBUEBaiEFIARBBGohBCAJQQFrIgkNAAsFIAgLNgIAIA9BEGokACASQQhqIBMoAgA2AgAgEiAKKQIINwIAIApBIGokACADKAK8AiIEKAIMIQggB0EoaiAEKAIQIhpBAEEEQQwQoBggBygCLCEKAkAgBygCKEEBRwRAIAcoAjAhDwJAIApFDQAgGkEMbCEJIA8hBCAKIQUDQCAJRQ0BIAdBKGogCBDdICAEQQhqIAdBMGooAgA2AgAgBCAHKQIoNwIAIARBDGohBCAJQQxrIQkgCEEMaiEIIAVBAWsiBQ0ACwsgEUH/AXEhJSADKQMYISwgAykDECEtIAMpAwghLiADKQMAIS8gAykD+AEhMCADKQPoASExIAMpA/ABITIgAykD4AEhMyADKALQASEmIAdBKGogA0HgAGpBACADKQNgQghSGxC3CAJAIAMoApgCQYCAgIB4RwRAIAMoApwCIgQgAygCoAJBA3RqIRAjAEEgayIIJAAgCEEUaiAQIARrQQN2QQBBBEEMEKAYIAgoAhghBSAIKAIUQQFGBEAgBSAIKAIcQbjmzwAQ/S8ACyAIQRBqIidBADYCACAIIAgoAhw2AgwgCCAFNgIIIwBBEGsiEiQAIBAgBGtBA3YiESAIQQhqIgUoAgAgBSgCCCIJa0sEQCAFIAkgEUEEQQwQ0CggBSgCCCEJCyASIAUoAgQ2AgwgEiAJNgIIIBIgBUEIajYCBCMAQRBrIhEkACASQQRqIgUoAgQhEyAFKAIAIAQgEEcEQCAFKAIIIBNBDGxqIQkgEyAQIARrQQN2IgVqIRMDQCARQQRqIhAgBCgCADYCCCAQIAQtAAU2AgAgECAELQAEQQJ0QbTs0ABqKAIANgIEIAlBCGogEUEMaigCADYCACAJIBEpAgQ3AgAgCUEMaiEJIARBCGohBCAFQQFrIgUNAAsLIBM2AgAgEUEQaiQAIBJBEGokACAHQYQBaiIEQQhqICcoAgA2AgAgBCAIKQIINwIAIAhBIGokAAwBCyAHQYCAgIB4NgKEAQsgBiAHKQMANwOYASAGIAcpAhA3AqQBIAYgJTYC+AIgBiAHKQIcNwLIAiAGIAo2AtQCIAYgDzYC2AIgBiAaNgLcAiAGICY2AvwCIAZBoAFqIAdBCGooAgA2AgAgBkGsAWogB0EYaigCADYCACAGQdACaiAHQSRqKAIANgIAIAMpAyAhNCADKQMoITUgAykDuAEhNiAGQYCAgIB4NgLgAiAGIDE3A7gCIAYgMjcDsAIgBiAzNwOoAiAGIDA3A8ACIAYgLDcDGCAGIC03AxAgBiAuNwMIIAYgLzcDACAGQTBqIAdBKGpB2AD8CgAAIAYgNjcDoAIgBiA1NwMoIAYgNDcDICAGQgM3A7ABIAYgKTcDkAEgBiArNwOIASAGQfQCaiAHQYwBaigCADYCACAGIAcpAoQBNwLsAiAHQZABaiQADAELIAogBygCMEHA6M8AEP0vAAtBgICAgHghBAJAAkACQCADKAKMAkGAgICAeEYNACADKAKQAiEFIAZBhANqIAMoApQCIhlBAEEBQQEQoBggBigCiAMhBCAGKAKEA0EBRg0BIAYoAowDIR4gGUUNACAeIAUgGfwKAAALIAMpA9gBISkgC0EgaiAGQYAD/AoAACALIBk2AtgDIAsgHjYC1AMgCyAENgLQAyALICk3A8gDIAtBgICAgHg2AtwDIAtBgYCAgHg2ArADIAsgAykDwAE3A6ADIAsgAykDODcDCCALIAMpAzA3AwAgCyADKQPIATcDqAMgCyADKQNINwMYIAsgAykDQDcDECAGQZADaiQADAELIAQgBigCjANBsOjPABD9LwALIB0gC0HoA/wKAAAgHUHoA2ohHSADQcACaiEDICBBAWsiIA0ACwsgGDYCACAfQfADaiQAIBVBEGokACAMQTBqIgNBCGogIygCADYCACADIA4pAgg3AgAgDkEgaiQAIAxBPGohAyABKQMQISkgASkDGCErAkAgASgCLEGAgICAeEcEQCADIAFBLGoQkxgMAQsgA0GAgICAeDYCAAsgASkDCCEsIAEpAwAhLSAcBEAgF0HoAWohAwNAIAMpAwAgKnwhKiADQcACaiEDIBxBAWsiHA0ACwsgDCApNwMoIAwgKzcDICAMICo3AxggDEIBNwMQIAwgLDcDCCAMIC03AwAgDCABKAI4NgJIIBsgDEHQAPwKAAAgG0HQAGohGyABQUBrIQEgAkEBayICDQALCyAWNgIAIAxB0ABqJAAgFEEQaiQAIABBCGogISgCADYCACAAIA0pAgg3AgAgDUEgaiQAC+MHAg1/AX4jAEEgayIFJAAgBUEUaiACIAFrQQJ2QQBBBEEEEKAYIAUoAhghAyAFKAIUQQFGBEAgAyAFKAIcQZDQwwAQ/S8ACyAFQRBqIgxBADYCACAFIAUoAhw2AgwgBSADNgIIIwBBEGsiCCQAIAVBCGoiAyACIAFrQQJ2IgsQgC4gCCADKQIEQiCJNwIIIAggA0EIajYCBCMAQbABayIDJAAgCEEEaiIHKAIEIQkgBygCACENAkACQAJAAkACQCABIAJHBEAgBygCCCAJQQJ0aiEHIANBkAFqIQ4gA0GcAWohDwNAIAEoAgAiAkEwaiEKAkACQAJAAkACQAJAAkACQCACLQAwQRdrDgoBAAACAwAEBQAGAAsgA0EUaiAKEL8GDAYLIANBFDoAFAwFCyADQRg6ABQMBAsgAyACQTRqNgIoIANCgICAgBA3AiAgA0EUaiADQSBqEMobIAMgAygCFDYCcCADIAMoAhgiBDYCaCADIAQgAygCHCIGQQJ0ajYCdCAGRQ0GIANBGzoAFCADIARBBGo2AmwgAyAEKAIANgIYIANB6ABqENUcDAMLIAMgAkE4ajYCKCADQoCAgIAQNwIgIANBFGogA0EgahDKGyADIAMoAhQ2AnAgAyADKAIYIgQ2AmggAyAEIAMoAhwiBkECdGo2AnQgBkUNBiADQR06ABQgAyAEQQRqNgJsIAMgBCgCADYCHCADIAIoAjQ2AhggA0HoAGoQ1RwMAgsgAyACQTRqNgIoIANCgICAgBA3AiAgA0EUaiADQSBqEMobIAMgAygCFDYCcCADIAMoAhgiBDYCaCADIAQgAygCHCIGQQJ0ajYCdCAGRQ0GIANBHjoAFCADIARBBGo2AmwgAyAEKAIANgIYIANB6ABqENUcDAELIANBCGogAkE0ahDDNCADQegAaiIEIAMoAggiBiAGIAMoAgxBAnRqEKUbIAMgBBC2GSADQSA6ABQgAyADKQMANwIYCyAPIAJBPGoQ3SAgDiAKEL8GIAIvAUghBCACKQMoIRAgA0HoAGoiCiACQQhqELEuIAMgEDcDiAEgAyAEOwGoASADQSBqIgQgCiADQRRqEKQrQdAAQQgQrTYiAkUNBSACQoGAgIAQNwMAIAJBCGogBEHIAPwKAAAgByACNgIAIAFBBGohASAHQQRqIQcgCUEBaiEJIAtBAWsiCw0ACwsgDSAJNgIAIANBsAFqJAAMBAtBqKPDABCyOwALQbijwwAQsjsAC0HIo8MAELI7AAtBCEHQABCjPQALIAhBEGokACAAQQhqIAwoAgA2AgAgACAFKQIINwIAIAVBIGokAAuSAQICfwF+IwBBEGsiBCQAIARBCGoiBSABQSBqIgEgAxC5GgJAAkAgBC0ACEEERg0AIAQpAwgiBkL/AYNCBFENACAEIAY3AwggACAFENAJDAELIAQgASgCACgCACACIAMQpxogBC0AAEEERwRAIAQgBCkDADcDCCAAIARBCGoQ0AkMAQsgAEEENgIACyAEQRBqJAALkgECAn8BfiMAQRBrIgQkACAEQQhqIgUgAUEgaiIBIAMQuBoCQAJAIAQtAAhBBEYNACAEKQMIIgZC/wGDQgRRDQAgBCAGNwMIIAAgBRDQCQwBCyAEIAEoAgAoAgAgAiADEKgaIAQtAABBBEcEQCAEIAQpAwA3AwggACAEQQhqENAJDAELIABBBDYCAAsgBEEQaiQAC5oCAgR/AX4jAEEwayIDJAAgA0EgaiEEIAFBIGohBSMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAkAgAiABQQhqIgYQuxQiAkELSQRAIAFBGGogBSgCACgCACAGIAIQpxoCQAJAIAEtABhBBEYNACABKQMYIgdC/wGDQgRRDQAgBCAHNwIADAELIARBBDoAACAEIAI2AgQLIAFBIGokAAwBCyACQQpBiL3DABCwOwALAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALmgICBH8BfiMAQTBrIgMkACADQSBqIQQgAUEgaiEFIwBBIGsiASQAIAFBEGpBADsBACABQgA3AwgCQCACIAFBCGoiBhC7FCICQQtJBEAgAUEYaiAFKAIAKAIAIAYgAhCoGgJAAkAgAS0AGEEERg0AIAEpAxgiB0L/AYNCBFENACAEIAc3AgAMAQsgBEEEOgAAIAQgAjYCBAsgAUEgaiQADAELIAJBCkGIvcMAELA7AAsCQAJAIAMtACBBBEYNACADIAMpAyA3AyggA0EMaiADQShqENAJIAMoAgxBBEYNACAAIAMpAgw3AgAgAEEQaiADQRxqKAIANgIAIABBCGogA0EUaikCADcCAAwBCyAAQQQ2AgALIANBMGokAAuaAgIEfwF+IwBBMGsiAyQAIANBIGohBCABQSBqIQUjAEEgayIBJAAgAUEQakEAOwEAIAFCADcDCAJAIAIgAUEIaiIGEMYUIgJBC0kEQCABQRhqIAUoAgAoAgAgBiACEKcaAkACQCABLQAYQQRGDQAgASkDGCIHQv8Bg0IEUQ0AIAQgBzcCAAwBCyAEQQQ6AAAgBCACNgIECyABQSBqJAAMAQsgAkEKQYi9wwAQsDsACwJAAkAgAy0AIEEERg0AIAMgAykDIDcDKCADQQxqIANBKGoQ0AkgAygCDEEERg0AIAAgAykCDDcCACAAQRBqIANBHGooAgA2AgAgAEEIaiADQRRqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC5oCAgR/AX4jAEEwayIDJAAgA0EgaiEEIAFBIGohBSMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAkAgAiABQQhqIgYQxhQiAkELSQRAIAFBGGogBSgCACgCACAGIAIQqBoCQAJAIAEtABhBBEYNACABKQMYIgdC/wGDQgRRDQAgBCAHNwIADAELIARBBDoAACAEIAI2AgQLIAFBIGokAAwBCyACQQpBiL3DABCwOwALAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALpQMBBX8jAEEwayIDJAAgA0EgaiEFIAFBIGohBiMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIARBCkYNASABQQhqIARqIAKnQYABcjoAACAEQQFqIQQgAkL//wBWIAJCB4ghAg0ACyAEQQFrQQlJDQEgBEEKQei8wwAQwyEAC0EKQQpB+LzDABDDIQALIAFBCGogBGogAjwAACAEQQFqDAILQaS8wwBBNEHYvMMAEJ8pAAsgASACPAAIQQELIQQgAUEYaiAGKAIAKAIAIAFBCGogBBCoGgJAAkAgAS0AGEEERg0AIAEpAxgiAkL/AYNCBFENACAFIAI3AgAMAQsgBUEEOgAAIAUgBDYCBAsgAUEgaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALpQMBBX8jAEEwayIDJAAgA0EgaiEFIAFBIGohBiMAQSBrIgEkACABQRBqQQA7AQAgAUIANwMIAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIARBCkYNASABQQhqIARqIAKnQYABcjoAACAEQQFqIQQgAkL//wBWIAJCB4ghAg0ACyAEQQFrQQlJDQEgBEEKQei8wwAQwyEAC0EKQQpB+LzDABDDIQALIAFBCGogBGogAjwAACAEQQFqDAILQaS8wwBBNEHYvMMAEJ8pAAsgASACPAAIQQELIQQgAUEYaiAGKAIAKAIAIAFBCGogBBCnGgJAAkAgAS0AGEEERg0AIAEpAxgiAkL/AYNCBFENACAFIAI3AgAMAQsgBUEEOgAAIAUgBDYCBAsgAUEgaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALjAEBAn8CQAJAIAAoAggiAyACRg0AAkAgAUH/AXENACAAKAIEIQQgAgRAIAIgA08NAyACIARqLAAAQb9/TA0DCyADIAJrQQJHDQAgAiAEaiIDLQAAQd8BcUHBAGtB/wFxQRlLDQAgAy0AAUE6Rg0BCyAAIAEgAhCPCwsPCyAEIAMgAiADQdyPxAAQozYAC+gBAQR/IwBBgCBrIgMkAAJAQYCJ+gAgASABQYCJ+gBPGyIGIAEgAUEBdmsiBSAFIAZJGyIFQYEITwRAIwBBEGsiBCQAIARBBGogBUEAQQRBBBCgGCAEKAIIIQYgBCgCBEEBRgRAIAYgBCgCDEHQrcwAEP0vAAsgBCgCDCEFIANBADYCCCADIAU2AgQgAyAGNgIAIARBEGokACAAIAEgAygCBCADKAIIIgBBAnRqIAMoAgAgAGsgAUHBAEkgAhD6CSADQQRBBBDgHgwBCyAAIAEgA0GACCABQcEASSACEPoJCyADQYAgaiQAC9kBAQN/IwBBMGsiAyQAIANBIGohBCABQSBqIwBBEGsiASQAIAFBCGpBADsBACABQgA3AwAgAiABEMYUIgJBC08EQCACQQpBrJnPABCwOwALKAIAIAEgAhChNiAEQQQ6AAAgBCACNgIEIAFBEGokAAJAAkAgAy0AIEEERg0AIAMgAykDIDcDKCADQQxqIANBKGoQ0AkgAygCDEEERg0AIAAgAykCDDcCACAAQRBqIANBHGooAgA2AgAgAEEIaiADQRRqKQIANwIADAELIABBBDYCAAsgA0EwaiQAC+sCAQV/IwBBMGsiAyQAIANBIGohBSABQSBqQQAhASMAQRBrIgQkACAEQQhqQQA7AQAgBEIANwMAAn8CQCACEKsnQQtJBEAgAkIBhiACQj+HhSICQoABVA0BAkACQANAIAFBCkYNASABIARqIAKnQYABcjoAACABQQFqIQEgAkL//wBWIAJCB4ghAg0ACyABQQFrQQlJDQEgAUEKQdyYzwAQwyEAC0EKQQpB7JjPABDDIQALIAEgBGogAjwAACABQQFqDAILQZiYzwBBNEHMmM8AEJ8pAAsgBCACPAAAQQELIQEoAgAgBCABEKE2IAVBBDoAACAFIAE2AgQgBEEQaiQAAkACQCADLQAgQQRGDQAgAyADKQMgNwMoIANBDGogA0EoahDQCSADKAIMQQRGDQAgACADKQIMNwIAIABBEGogA0EcaigCADYCACAAQQhqIANBFGopAgA3AgAMAQsgAEEENgIACyADQTBqJAALhQEBA38jAEEQayIEJAAgBEEEaiADQQBBAUEBEKAYIAQoAgghBSAEKAIEQQFHBEAgBCgCDCEGIAMEQCAGIAIgA/wKAAALIAFBNGoQ3jsgASADNgI8IAEgBjYCOCABIAU2AjQgACABQcgA/AoAACAEQRBqJAAPCyAFIAQoAgxB9I7PABD9LwALbwEBfwJAAkACQAJAAkBBgICAgHggACgCACIBIAFBgICAgHhNG0H/////B3EOBAEEBAIACyAAKAIEQYGAgIB4Rg0CDAMLIAAQ1S4PCyAAQQRqELkuCw8LIABBBGoQhjAgAEEQahCGMCAAQRxqEIYwC30BBX8gAUEQbSIBQQAgAUEAShshBiACQQJqIQcDQCAFIAZGRQRAQQAhAQNAIAFBwABGRQRAIAAgAWoiBEEBIAQoAgAiBCACa0EAIAQgB08bIgggBEEBRhsgCCADGzYCACABQQRqIQEMAQsLIABBQGshACAFQQFqIQUMAQsLC5UBAQF/IwBBEGsiByQAAkAgBUH/AXFBBEkEQCABIAIgBRDbIiIBQf8BcUHAAE8NASAEIAFB/wFxIgIgBkH/AXFBBnRyIgVLBEAgAyAFai0AACECCyAAIAE6AAQgACACNgIAIAdBEGokAA8LQeyd4gBBKyAHQQ9qQdyd4gBBkIbjABDVHgALQaCG4wBBHEG8huMAEJ8pAAuHAQEBfyABQcEASQRAAkAgACgCACIDQZ0LRwRAIAAoAgggASACakEEakEBIAMRBgAiAA0BQQAPCyABIAJBARCrKA8LIAAgASAAIAFwIgJrQQAgAhsiAmpBBCABIAFBBE0bQQAgAkEESRtqIgFBBGsgADYAACABDwtB6PT8AEEwQZj1/AAQnykAC5QBAQF/IwBBMGsiAiQAIAAoAgAhACACIAE2AgAgASAAQQxqKAIITwRAIAIgABCjPDYCHCACQQI2AgggAkHwiP8ANgIEIAJCAjcCECACQTs2AiwgAkE7NgIkIAIgAkEgajYCDCACIAJBHGo2AiggAiACNgIgIAJBBGpBgIn/ABDvLAALIAAoAhAgAWotAAAgAkEwaiQAC+EBAQV/IwBBIGsiAyQAIANBFGogAiABa0EDdkEAQQRBBBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEHk5IABEP0vAAsgA0EQaiIHQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqIgUgAiABa0EDdiIGEO4tIAUoAgghBCAFIAEgAkcEfyAEIAZqIAUoAgQgBEECdGohBANAIAQgASkDAD4CACABQQhqIQEgBEEEaiEEIAZBAWsiBg0ACwUgBAs2AgggAEEIaiAHKAIANgIAIAAgAykCCDcCACADQSBqJAAL4QEBBX8jAEEgayIDJAAgA0EUaiACIAFrQQJ2QQBBCEEIEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQeTkgAEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIANBCGoiBSACIAFrQQJ2IgYQ7C0gBSgCCCEEIAUgASACRwR/IAQgBmogBSgCBCAEQQN0aiEEA0AgBCABNQIANwMAIAFBBGohASAEQQhqIQQgBkEBayIGDQALBSAECzYCCCAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQJ2IQADQCADKAIAIgQgAU8NAiACIAZqIAQgB2otAAA6AAAgA0EEaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUH0toIBEMMhAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQN2IQADQCABIAMoAgAiBE0NAiACIAZqIAQgB2otAAA6AAAgA0EIaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUH0toIBEMMhAAuRAQEGfyABKAIEIQIgASgCACEFAkAgACgCACIDIAAoAgQiBEcEQCABKAIIIQYgACgCDCEBIAAoAgghByAEIANrQQJ2IQADQCADKAIAIgQgAU8NAiACIAZqIAQgB2otAAA6AAAgA0EEaiEDIAJBAWohAiAAQQFrIgANAAsLIAUgAjYCAA8LIAQgAUG8tIIBEMMhAAvkAgEIfyMAQSBrIgQkACAEQRRqIAIgAWtBAnZBAEEEQQgQoBggBCgCGCEGIAQoAhRBAUYEQCAGIAQoAhxB0MiCARD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAY2AggjAEEQayIGJAAgAiABa0ECdiIHIARBCGoiBSgCACAFKAIIIgNrSwRAIAUgAyAHQQRBCBDeKCAFKAIIIQMLIAYgBSgCBDYCDCAGIAM2AgggBiAFQQhqNgIEIAZBBGoiAygCBCEFIAMoAgAgASACRwRAIAMoAgggBUEDdGohAyAFIAIgAWtBAnYiAmohBQNAIAEoAgAiCCgCICEKIANBBGogCCgCJCIINgIAIAMgCiAIKAIIQQFrQXhxakEIajYCACABQQRqIQEgA0EIaiEDIAJBAWsiAg0ACwsgBTYCACAGQRBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAAL6wEBBn8jAEEgayIDJAAgA0EUaiACIAFrQQN2QQBBBEEIEKAYIAMoAhghBCADKAIUQQFGBEAgBCADKAIcQdDIggEQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyAENgIIIwBBEGsiBCQAIAIgAWtBA3YiCCADQQhqIgUoAgAgBSgCCCIGa0sEQCAFIAYgCEEEQQgQ3iggBSgCCCEGCyAEIAUoAgQ2AgwgBCAGNgIIIAQgBUEIajYCBCABIAIgBEEEahDfGyAEQRBqJAAgAEEIaiAHKAIANgIAIAAgAykCCDcCACADQSBqJAAL5AIBCH8jAEEgayIEJAAgBEEUaiACIAFrQQJ2QQBBBEEIEKAYIAQoAhghBiAEKAIUQQFGBEAgBiAEKAIcQdDIggEQ/S8ACyAEQRBqIglBADYCACAEIAQoAhw2AgwgBCAGNgIIIwBBEGsiBiQAIAIgAWtBAnYiByAEQQhqIgUoAgAgBSgCCCIDa0sEQCAFIAMgB0EEQQgQ3iggBSgCCCEDCyAGIAUoAgQ2AgwgBiADNgIIIAYgBUEIajYCBCAGQQRqIgMoAgQhBSADKAIAIAEgAkcEQCADKAIIIAVBA3RqIQMgBSACIAFrQQJ2IgJqIQUDQCABKAIAIggoAgwhCiADQQRqIAgoAhAiCDYCACADIAogCCgCCEEBa0F4cWpBCGo2AgAgAUEEaiEBIANBCGohAyACQQFrIgINAAsLIAU2AgAgBkEQaiQAIABBCGogCSgCADYCACAAIAQpAgg3AgAgBEEgaiQAC9kBAQR/IwBBIGsiBCQAIARBFGogAiABa0HEAG5BAEEEQQQQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhwgAxD9LwALIARBEGoiB0EANgIAIAQgBCgCHDYCDCAEIAU2AgggBEEIaiIFIAIgAWtBxABuEO4tIAUoAgghAyABIAJHBEAgBSgCBCADQQJ0aiEGA0AgBiABNgIAIAZBBGohBiADQQFqIQMgAUHEAGoiASACRw0ACwsgBSADNgIIIABBCGogBygCADYCACAAIAQpAgg3AgAgBEEgaiQAC8ACAQd/IwBBIGsiBCQAIARBFGogAiABa0EDdkEAQQRBxAAQoBggBCgCGCEFIAQoAhRBAUYEQCAFIAQoAhwgAxD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAU2AggjAEEQayIDJAAgBEEIaiIFIAIgAWtBA3YiBxD+LSADIAUpAgRCIIk3AgggAyAFQQhqNgIEIwBB0ABrIggkACADQQRqIgYoAgQhBSAGKAIAIAEgAkcEQCAGKAIIIAVBxABsaiEGIAUgByICaiEFA0AgCEEMaiIHIAEoAgAgAUEEaigCACgCFBEAACAGIAdBxAD8CgAAIAFBCGohASAGQcQAaiEGIAJBAWsiAg0ACwsgBTYCACAIQdAAaiQAIANBEGokACAAQQhqIAkoAgA2AgAgACAEKQIINwIAIARBIGokAAvuAgEJfyMAQSBrIgMkACADQRRqIAIgAWtBGG5BAEEEQRgQoBggAygCGCEGIAMoAhRBAUYEQCAGIAMoAhxByP+FARD9LwALIANBEGoiCUEANgIAIAMgAygCHDYCDCADIAY2AggjAEEQayIGJAAgAiABa0EYbiIHIANBCGoiBSgCACAFKAIIIgRrSwRAIAUgBCAHQQRBGBDeKCAFKAIIIQQLIAYgBSgCBDYCDCAGIAQ2AgggBiAFQQhqNgIEIAZBBGoiBCgCBCEFIAQoAgAgASACRwRAIAQoAgggBUEYbGohCyAFIAIgAWtBGG4iB2ohBUEAIQIDQCACIAtqIgRBFGpBADYCACAEIAEgAmoiCC0AADoAACAEQQxqIAhBDGopAgA3AgAgBEEEaiAIQQRqKQIANwIAIAJBGGohAiAHQQFrIgcNAAsLIAU2AgAgBkEQaiQAIABBCGogCSgCADYCACAAIAMpAgg3AgAgA0EgaiQAC6sDAQl/IwBBIGsiBSQAIAVBFGogAiABa0EcbkEAQQRBGBCgGCAFKAIYIQMgBSgCFEEBRgRAIAMgBSgCHEHI/4UBEP0vAAsgBUEQaiIIQQA2AgAgBSAFKAIcNgIMIAUgAzYCCCMAQRBrIgckACACIAFrQRxuIgYgBUEIaiIDKAIAIAMoAggiBGtLBEAgAyAEIAZBBEEYEN4oIAMoAgghBAsgByADKAIENgIMIAcgBDYCCCAHIANBCGo2AgQjAEEgayIDJAAgB0EEaiIEKAIEIQYgBCgCACABIAJHBEAgBCgCCCAGQRhsaiEEIAYgAiABa0EcbiICaiEGIANBDGohCgNAIAEtAAAhCyADIAFBBGoQ3DsgCiADKAIAIAMoAgQgAUEQaigCACABQRRqKAIAEIcdIARBCGogA0EQaikCADcCACAEQRBqIANBGGopAgA3AgAgAyALOgAIIAQgAykCCDcCACABQRxqIQEgBEEYaiEEIAJBAWsiAg0ACwsgBjYCACADQSBqJAAgB0EQaiQAIABBCGogCCgCADYCACAAIAUpAgg3AgAgBUEgaiQAC6UBAQN/IwBBEGsiAiQAIAJBBGogAUEAQRBBEBCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEGExoUBEP0vAAsgAigCDCEEIAAgATYCdCAAQQA2AnAgAEEANgJcIABBADYCQCAAIAQ2AjwgACADNgI4IABCATcCVCAAQgA3AkwgAEKAgICAwAA3AkQgAEEANgIIIABCgYCAgICACDcDACACQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQghBQJAIAMoAgwiAiADKAIIIgZBCBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEHcSECIARBA3YhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQIhBQJAIAMoAgwiAiADKAIIIgZBAhD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEBcSECIARBAXYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QQQhBQJAIAMoAgwiAiADKAIIIgZBBBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEDcSECIARBAnYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAALiAEBBX8jAEEQayIDJAAgA0EIaiABENw7QRAhBQJAIAMoAgwiAiADKAIIIgZBEBD4LyIBSQRAIAIhAUEAIQIMAQsgASAGaiEFIAIgAWsiBEEPcSECIARBBHYhBAsgASACcgRAQbSlhwFBOEHspYcBEJ8pAAsgACAENgIEIAAgBTYCACADQRBqJAAL6AEBBH8jAEGAIGsiAyQAAkBBgIn6ACABIAFBgIn6AE8bIgYgASABQQF2ayIFIAUgBkkbIgVBgQhPBEAjAEEQayIEJAAgBEEEaiAFQQBBBEEEEKAYIAQoAgghBiAEKAIEQQFGBEAgBiAEKAIMQczIhwEQ/S8ACyAEKAIMIQUgA0EANgIIIAMgBTYCBCADIAY2AgAgBEEQaiQAIAAgASADKAIEIAMoAggiAEECdGogAygCACAAayABQcEASSACEIEKIANBBEEEEOAeDAELIAAgASADQYAIIAFBwQBJIAIQgQoLIANBgCBqJAAL6AcCCX8BfiMAQSBrIgQkACAEQRRqIAEoAgQgASgCAGtBAEEEQQQQoBggBCgCGCECIAQoAhRBAUYEQCACIAQoAhxBkNDDABD9LwALIARBEGoiCUEANgIAIAQgBCgCHDYCDCAEIAI2AggjAEEgayIFJAAgBEEIaiICIAEoAgQgASgCAGsQgC4gAikCBCELIAVBEGogAUEIaigCADYCACAFIAEpAgA3AwggBSALQiCJNwIYIAUgAkEIajYCFCMAQbABayIBJAAgBUEUaiICKAIEIQgCQAJAAkACQAJAIAIoAgAgBUEIaiIDKAIAIAMoAgRHBH8gAigCCCADKAIIKAIAIgJBMGohBwJAAkACQAJAAkACQAJAAkAgAi0AMEEXaw4KAQAAAgMABAUABgALIAFBFGogBxC/BgwGCyABQRQ6ABQMBQsgAUEYOgAUDAQLIAEgAkE0ajYCKCABQoCAgIAQNwIgIAFBFGogAUEgahDKGyABIAEoAhQ2AnAgASABKAIYIgM2AmggASADIAEoAhwiBkECdGo2AnQgBkUNBSABQRs6ABQgASADQQRqNgJsIAEgAygCADYCGCABQegAahDVHAwDCyABIAJBOGo2AiggAUKAgICAEDcCICABQRRqIAFBIGoQyhsgASABKAIUNgJwIAEgASgCGCIDNgJoIAEgAyABKAIcIgZBAnRqNgJ0IAZFDQUgAUEdOgAUIAEgA0EEajYCbCABIAMoAgA2AhwgASACKAI0NgIYIAFB6ABqENUcDAILIAEgAkE0ajYCKCABQoCAgIAQNwIgIAFBFGogAUEgahDKGyABIAEoAhQ2AnAgASABKAIYIgM2AmggASADIAEoAhwiBkECdGo2AnQgBkUNBSABQR46ABQgASADQQRqNgJsIAEgAygCADYCGCABQegAahDVHAwBCyABQQhqIAJBNGoQwzQgAUHoAGoiAyABKAIIIgYgBiABKAIMQQJ0ahClGyABIAMQthkgAUEgOgAUIAEgASkDADcCGAsgAUGcAWogAkE8ahDdICABQZABaiAHEL8GIAIvAUghAyACKQMoIQsgAUHoAGoiByACQQhqELEuIAEgCzcDiAEgASADOwGoASABQSBqIgMgByABQRRqEKQrQdAAQQgQrTYiAkUNBCACQoGAgIAQNwMAIAJBCGogA0HIAPwKAAAgCEECdGogAjYCACAIQQFqBSAICzYCACABQbABaiQADAQLQaijwwAQsjsAC0G4o8MAELI7AAtByKPDABCyOwALQQhB0AAQoz0ACyAFQSBqJAAgAEEIaiAJKAIANgIAIAAgBCkCCDcCACAEQSBqJAALigEBA38jAEEQayIBJAACQCAAKAIAIgJB0ABqEJQhIgBFDQAgAi0AVCACQYECOwBUIAEgADYCDEUEQCACQQA2AkwgACgCGCAAIAJBCGoiADYCGCAANgJEIAEoAgwiAEEMahD5KAsgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAFBDGoQ2x8LIAFBEGokAAuKAQEDfyMAQRBrIgEkAAJAIAAoAgAiAkHwAGoQlCEiAEUNACACLQB0IAJBgQI7AHQgASAANgIMRQRAIAJBADYCbCAAKAIYIAAgAkEIaiIANgIYIAA2AmQgASgCDCIAQQxqEPkoCyAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEMahDaHwsgAUEQaiQAC44BAQN/IwBBEGsiASQAAkAgACgCACICQdgBahCUISIARQ0AIAItANwBIAJBgQI7ANwBIAEgADYCDEUEQCACQQA2AtQBIAAoAhggACACQQhqIgA2AhggADYCzAEgASgCDCIAQQxqEPkoCyAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUEMahDZHwsgAUEQaiQAC5EBAQJ/IwBBEGsiAiQAIAJBCGogARD8KQJAAkAgAigCCCIDQQJHBEAgAigCDCEBIANBAXFFDQEgAEECNgIAIAAgATYCBAwCCyAAQQA2AgAMAQsgAiABELgSIAIoAgQhASACKAIAQQFxRQRAIAAgATYCBCAAQQE2AgAMAQsgAEECNgIAIAAgATYCBAsgAkEQaiQAC4sBAQJ/IwBBIGsiAiQAAkAgASkDAEICUgRAIABBCDYCACAAQQE6AAQMAQsgAkEIaiABEJ0GIAIoAgwhASACKAIIIgNBCEcEQCAAIAIpAxA3AwggAEEQaiACQRhqKQMANwMAIAAgATYCBCAAIAM2AgAMAQsgAEEINgIAIAAgAUECRjoABAsgAkEgaiQAC30BAX8gAEEQahDeOyAAKAJ4IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfgAahD4IwsgAEHYAGoQ7CYgACgCIEGAgICAeEcEQCAAQSBqEOk7IAAoAjAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBMGoQhR0LIABBOGoQkycLC48BAQR/IwBBEGsiAyQAIAAoAhQhASAAKAIYIgQoAgAiAgRAIAEgAhEDAAsgBCgCBCICBEAgASACIAQoAggQ+DoLIAAoAhwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBHGoQ+CMLIAAoAgBBgICAgHhHBEAgAyAAIAAoAgwQ+BggAEEEQQgQ4B4LIANBEGokAAuLAQECfyMAQSBrIgIkAAJAIAEpAwBCAlIEQCAAQQg2AgAgAEEBOgAEDAELIAJBCGogARD8BSACKAIMIQEgAigCCCIDQQhHBEAgACACKQMQNwMIIABBEGogAkEYaikDADcDACAAIAE2AgQgACADNgIADAELIABBCDYCACAAIAFBAkY6AAQLIAJBIGokAAueAQEBfwJAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEOMoRQ0CDAMLIAAgARC5HA0CDAELIAAgARC4HA0BCyABKAIAQbz1zgBBAiABKAIEKAIMEQYADQAgAEEIaiEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDjKA8LIAAgARC5HA8LIAAgARC4HA8LQQELhwEBAn8jAEEQayIHJAAgAwRAIAdBADYCDCAAAn8CQCAEQRpJBEAgASAEQQJ0IgFB0qHzAGotAAAgB0EMaiAFIAYQ7R8iCA0BIAAgBDYCHEEBDAILIARBGkG4ovMAEMMhAAsgAiAHKAIMIAFB0KHzAGovAQBqNgIAQQALOgBECyAHQRBqJAAgCAvXBAIHfwN+IwBBIGsiBSQAAkACQAJAIAJFDQAgASACakEBayIDRQ0AIAMtAABBMGtB/wFxQQpJDQELIABCADcDAAwBCyAFQQhqIQkgASEHQQAhASMAQRBrIggkAAJAAkACQAJAAkACQCACIgNFDQAgBy0AACIBQStGIgQgAUEtRiIGciEBAkAgBkUEQCABIANGBEBBASEBDAMLQRRBEyAEGyIEIAMgAyAESxshBANAIAEgA0YNAiABIAdqLQAAQTBrIgZB/wFxQQpPDQMgC0IKfiAGrUL/AYN8IQsgBCABQQFqIgFHDQALIAQhAQwCCyABIANGBEBBASEDDAMLQgEhCgNAIAEgB2otAABBMGtB/wFxIgRBCUsNBSAEQQN0QdD1gAFqKQMAQgAgCqdBAXEbIQogAyABQQFqIgFHDQALDAYLIAMgA0Gw84ABEMMhAAsgASADRw0BC0IBIQoMAwsgASADIAEgA0sbIQRCASEKA0AgASAERg0CIAEgB2otAABBMGsiBkH/AXFBCk8NAQJ+QgAgCqdBAXFFDQAaIAggC0IAQgpCABCoHkIAIAgpAwhCAFINABogCyAIKQMAIgogBq1C/wGDfCIMIAogDFYbIQsgCiAMWK0LIQogAyABQQFqIgFHDQALDAILIAEhAwwBCyAEIANBwPOAARDDIQALIAkgAzYCECAJIAs3AwggCSAKNwMAIAhBEGokAAJAIAUpAwgiCqdBAUYEQCAFKAIYIAJGDQELIABCADcDAAwBCyAAIAUpAxA3AwggACAKNwMACyAFQSBqJAALpwYCB38DfiMAQSBrIgckAAJAAkACQCACRQ0AIAEgAmpBAWsiA0UNACADLQAAQTBrQf8BcUEKSQ0BCyAAQgA3AwAMAQsgB0EIaiEJIAEhCEEAIQEjAEEgayIGJAACQAJAAkACQAJAIAIiA0UNACAILQAAIgFBK0YgAUEtRiIEciEBAkACQAJAAkAgBARAIAEgA0cNAUEBIQEMBAsgASADRgRAQQEhAQwFCyABQRJyIgQgAyADIARLGyEEA0AgASADRg0CIAEgCGotAABBMGsiBUH/AXFBCk8NBSAKQgp+IAWtQv8Bg3whCiAEIAFBAWoiAUcNAAsgBCEBDAQLQRMgAyADQRNPGyEEA0AgASADRg0CIAEgCGotAABBMGsiBUH/AXFBCk8NAyAKQgp+IAWtQv8Bg30hCiAEIAFBAWoiAUcNAAsgBCEBDAILIAMgA0Gw84ABEMMhAAsgAyADQdDzgAEQwyEACyABIANGDQEgASADIAEgA0sbIQRCASELA0ACQCABIARHBEAgASAIai0AAEEwayIFQf8BcUEKSQ0BDAYLIAQgA0Hg84ABEMMhAAsCfkIAIAunQQFxRQ0AGiAGQRBqIAogCkI/h0IKQgAQqB5CACAGKQMYIAYpAxAiC0I/h1INABogCiALIAWtQv8BgyIKfSIMIApCAFIgCyAMVXMiBRshCiAFRa0LIQsgAyABQQFqIgFHDQALDAQLIAEgA0cNAQtCASELDAILIAEgAyABIANLGyEEQgEhCwNAIAEgBEcEQCABIAhqLQAAQTBrIgVB/wFxQQpPDQICfkIAIAunQQFxRQ0AGiAGIAogCkI/h0IKQgAQqB5CACAGKQMIIAYpAwAiC0I/h1INABogCiALIAWtQv8Bg3wiCiAKIAtTIgUbIQogBUWtCyELIAMgAUEBaiIBRw0BDAMLCyAEIANBwPOAARDDIQALIAEhAwsgCSADNgIQIAkgCjcDCCAJIAs3AwAgBkEgaiQAAkAgBykDCCIKp0EBRgRAIAcoAhggAkYNAQsgAEIANwMADAELIAAgBykDEDcDCCAAIAo3AwALIAdBIGokAAujAQECfyMAQTBrIgIkACACQRBqQY6cuPAANgIAIAJCjpy48ODBg4cONwMIAkACQAJAIAHEQsWN1P8HfUKAgICAcFQNACABp0G78itqEPMWIgNFDQAgAkIANwIoIAIgAzYCJCACQRhqIAJBJGoQyi8gAigCGCIDDQELIABBADYCAAwBCyAAIAIpAhw3AgQgACADNgIACyACQQhqEMkMIAJBMGokAAuVAQEDfwJAIAAoAnwiBCABSwRAIAFBA3QiBCAAKAJ4aiIFKAIAIABBDGoiBiACIAMgAmsiAyAFKAIEKAIUEQUAIAEgACgCcCIFTw0BIAAoAmwgBGoiBCgCACAGIAEgAiADIAQoAgQoAhQRBwAgACAAKAJYIANqNgJYDwsgASAEQciWhwEQwyEACyABIAVB2JaHARDDIQALngEBAX8CQAJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARD8KEUNAgwDCyAAIAEQ0xwNAgwBCyAAIAEQ0hwNAQsgASgCAEGMu4cBQQIgASgCBCgCDBEGAA0AIABBBGohACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ/CgPCyAAIAEQ0xwPCyAAIAEQ0hwPC0EBC6gBAQN/IwBBEGsiAiQAQbKxiQEhA0ETIQQCQAJAAkACQCABLQAAQQFrDgMCAAEDCyABKAIEIgEoAgQhBCABKAIAIQMMAgsgAkEIaiABKAIEIgEoAgAgASgCBCgCIBEAACACKAIMIQQgAigCCCEDDAELIAEtAAFBAnQiAUGkvIkBaigCACEDIAFB/LqJAWooAgAhBAsgACADNgIAIAAgBDYCBCACQRBqJAALmQEBA38gAC0ACCEBAkAgACgCACIDRQRAIAEhAgwBC0EBIQICQCABQQFxRQRAIANBAUcNASAALQAJRQ0BIAAoAgQiAS0ACkGAAXENASABKAIAQdzxiQFBASABKAIEKAIMEQYARQ0BCyAAIAI6AAgMAQsgACAAKAIEIgAoAgBBk+2JAUEBIAAoAgQoAgwRBgAiAjoACAsgAkEBcQuBAQEDfyMAQRBrIgIkACACQQRqIAFBAEEBQQEQoBggAigCCCEEIAIoAgRBAUcEQCACKAIMIQMgAQRAIAMgACAB/AoAAAsgAiABNgIMIAIgAzYCCCACIAQ2AgQgAyABEJQ+IAJBBGoQ3jsgAkEQaiQADwsgBCACKAIMQdzDzAAQ/S8AC5EBAQF/IwBBIGsiAiQAIAIgATYCDCACQRBqIAJBDGoQkh8CQCACKAIQQYCAgIB4RwRAIAAgAikCEDcCACAAQQhqIAJBGGooAgA2AgAMAQsgAkEMaiACQR9qQZDFzAAQ0QshASAAQYCAgIB4NgIAIAAgATYCBCACKAIMIQELIAFBhAFPBEAgARDyHwsgAkEgaiQAC8B4Aht/A34jAEEwayISJAAgEkEYaiEWIAEoAhwhEyMAQdAAayIPJAACQAJAAn8CQAJAIAEiESgCACIBIBEoAgQiGUcEQCARKAIIIhdBAWohFCARKAIQIRggESgCDCEaIA9BGGohFSAPQRBqQQRyIRsDQCARIAFBwAJqIhw2AgAgAUFAaygCAEEBRw0DIAFByABqKQMAIh1CAFMNAyABQcgBaigCAEEBRw0DIAFBzAFqKAIAIgZBAEgNAwJAAkACQAJAIB0gGikDACIffSIeQv////8PVg0AIB0gBq18IB99Ih1C/////w9WDQAgHqchAiAdpyEDIB0gHlQNBiAYKAIIIgYgA08NASADIAZB7OXQABCwOwALIA9BATYCMCAPQay+zQA2AiwgD0IBNwI4IA9BpgQ2AkggDyAPQcQAajYCNCAPIA9BzwBqNgJEIBsgD0EsahCZDkEAIQYgDygCFCEBDAELIA9BEGohDSAYKAIEIAJqIQQgAUG8AmooAgBBCGoQ3SVB/wFxIQ5BACEIQQAhCyMAQfABayIGJAAgBkEIaiIFIAQgAyACaxCdHyAGQThqIQMjAEHgAWsiASQAIAFByAFqIAUQ8CcgAUGQAWoiAiABQdQBaiIEKAIANgIAIAEgASkCzAE3A4gBAkAgASgCyAEiCUEERwRAIAEoAtgBIQUgAyABKQOIATcCCCADIAU2AhQgAyAJNgIEIANBgICAgHg2AgAgA0EQaiACKAIANgIADAELIAFB+ABqIAIoAgA2AgAgASABKQOIATcDcCABQfAAahCGMCABQYCAgIB4NgIIIAFBgICAgHg2AhggAUGAgICAeDYCKCABQQA2AjggAUGAgICAeDYCQCABQYCAgIB4NgJQIAFBgICAgHg2AmAgAUHIAWogBRDTCSACIAQpAgA3AwAgAUGYAWoiCiABQdwBaigCADYCACABIAEpAswBNwOIAQJAAkAgASgCyAFFBEAgAUHMAWohCQNAIAFBgAFqIAooAgAiAjYCACABQfgAaiABQZABaiIEKQMANwMAIAEgASkDiAE3A3ACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXEEQCABQcgBaiABQfAAahD8FyABLwHMASECIAEoAsgBIgdBBEcEQCADIAEpAc4BNwEKIANBEGogAUHUAWopAQA3AQAgAyACOwEIIAMgBzYCBCADQYCAgIB4NgIADBALAkACQAJAAkACQAJAAkACQCACQQFrDgcBAgMABAUGBwsgAUHIAWogBRDAHCABKALIAUUEQCABKALQASEIDBMLIAEpA9ABIh2nIQggASgCzAEiAkEERg0SIAMgASkD2AE3AhAgAyAINgIIIAMgAjYCBCADQYCAgIB4NgIAIAMgHUIgiD4CDAwWCyABQcgBaiAFEMkPIAEoAswBIQIgASgCyAEiB0EERwRAIAMgASkA0QE3AA0gA0EUaiABQdgBaigAADYAACADIAEtANABOgAMIAMgAjYCCCADIAc2AgQgA0GAgICAeDYCAAwWCyABQcgBaiACQQBBAUEBEKAYIAEoAswBIQcgASgCyAFBAUYNByABQQA2ApABIAEgASgC0AE2AowBIAEgBzYCiAEgAkEASgRAA0AgAUHIAWogBRDaECABLQDMASEHIAEoAsgBIgxBBEcEQCADIAEpAM0BNwAJIANBEGogAUHUAWopAAA3AAAgAyAHOgAIIAMgDDYCBCADQYCAgIB4NgIAIAFBiAFqEN47DBgLIAEoApABIgwgASgCiAFGBEAgAUGIAWpB8JfQABCjKAsgASgCjAEgDGogBzoAACABIAxBAWo2ApABIAJBAWsiAg0ACwsgAUHQAWoiAiAEKAIANgIAIAEgASkCiAE3A8gBIAFBCGoQhjAgAUEQaiACKAIANgIAIAEgASkDyAE3AwgMEgsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMFQsgAUHIAWogAkEAQQRBDBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgK0ASABIAEoAtABNgKwASABIAc2AqwBIAJBAEoEQANAIAFByAFqIAUQpREgBCAJQQhqKAIANgIAIAEgCSkCADcDiAEgASgCyAEiB0EERwRAIAEoAtgBIQIgAyABKQOIATcCCCADIAI2AhQgAyAHNgIEIANBgICAgHg2AgAgA0EQaiABQZABaigCADYCACABQawBaiIDENcrIAMQ6DsMFwsgAUGoAWoiDCAEKAIANgIAIAEgASkDiAE3A6ABIAEoArQBIgcgASgCrAFGBEAgAUGsAWpBkJjQABCQKAsgASgCsAEgB0EMbGoiECABKQOgATcCACAQQQhqIAwoAgA2AgAgASAHQQFqNgK0ASACQQFrIgINAAsLIAFB0AFqIgIgAUG0AWooAgA2AgAgASABKQKsATcDyAEgAUEYahDzMCABQSBqIAIoAgA2AgAgASABKQPIATcDGAwRCyABQcgBaiAFEMkPIAEoAswBIQIgASgCyAEiB0EERwRAIAMgASkA0QE3AA0gA0EUaiABQdgBaigAADYAACADIAEtANABOgAMIAMgAjYCCCADIAc2AgQgA0GAgICAeDYCAAwUCyABQcgBaiACQQBBBEEMEKAYIAEoAswBIQcgASgCyAFBAUYNByABQQA2ArQBIAEgASgC0AE2ArABIAEgBzYCrAEgAkEASgRAA0AgAUHIAWogBRClESAEIAlBCGooAgA2AgAgASAJKQIANwOIASABKALIASIHQQRHBEAgASgC2AEhAiADIAEpA4gBNwIIIAMgAjYCFCADIAc2AgQgA0GAgICAeDYCACADQRBqIAFBkAFqKAIANgIAIAFBrAFqIgMQ1ysgAxDoOwwWCyABQcABaiIMIAQoAgA2AgAgASABKQOIATcDuAEgASgCtAEiByABKAKsAUYEQCABQawBakGwmNAAEJAoCyABKAKwASAHQQxsaiIQIAEpA7gBNwIAIBBBCGogDCgCADYCACABIAdBAWo2ArQBIAJBAWsiAg0ACwsgAUHQAWoiAiABQbQBaigCADYCACABIAEpAqwBNwPIASABQShqEPMwIAFBMGogAigCADYCACABIAEpA8gBNwMoDBALIAFByAFqIAUQyQ8gASgCzAEhAiABKALIASIHQQRHBEAgAyABKQDRATcADSADQRRqIAFB2AFqKAAANgAAIAMgAS0A0AE6AAwgAyACNgIIIAMgBzYCBCADQYCAgIB4NgIADBMLIAFByAFqIAJBAEEIQQgQoBggASgCzAEhByABKALIAUEBRg0HIAFBADYCkAEgASABKALQATYCjAEgASAHNgKIASACQQBKBEADQCABQcgBaiAFEMAcIAEoAsgBBEAgASgCzAEhAiABKQPQASEdIAMgASkD2AE3AhAgAyAdNwIIIAMgAjYCBCADQYCAgIB4NgIAIAFBiAFqEOM8DBULIAEpA9ABIR0gASgCkAEiByABKAKIAUYEQCABQYgBakHQmNAAELMoCyABKAKMASAHQQN0aiAdNwMAIAEgB0EBajYCkAEgAkEBayICDQALCyABQdABaiICIAQoAgA2AgAgASABKQKIATcDyAEgAUFAaxCFMCABQcgAaiACKAIANgIAIAEgASkDyAE3A0AMDwsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMEgsgAUHIAWogAkEAQQhBCBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgKQASABIAEoAtABNgKMASABIAc2AogBIAJBAEoEQANAIAFByAFqIAUQwBwgASgCyAEEQCABKALMASECIAEpA9ABIR0gAyABKQPYATcCECADIB03AgggAyACNgIEIANBgICAgHg2AgAgAUGIAWoQ4zwMFAsgASkD0AEhHSABKAKQASIHIAEoAogBRgRAIAFBiAFqQfCY0AAQsygLIAEoAowBIAdBA3RqIB03AwAgASAHQQFqNgKQASACQQFrIgINAAsLIAFB0AFqIgIgBCgCADYCACABIAEpAogBNwPIASABQdAAahCFMCABQdgAaiACKAIANgIAIAEgASkDyAE3A1AMDgsgAUHIAWogBRDJDyABKALMASECIAEoAsgBIgdBBEcEQCADIAEpANEBNwANIANBFGogAUHYAWooAAA2AAAgAyABLQDQAToADCADIAI2AgggAyAHNgIEIANBgICAgHg2AgAMEQsgAUHIAWogAkEAQQhBCBCgGCABKALMASEHIAEoAsgBQQFGDQcgAUEANgKQASABIAEoAtABNgKMASABIAc2AogBIAJBAEoEQANAIAFByAFqIAUQwBwgASgCyAEEQCABKALMASECIAEpA9ABIR0gAyABKQPYATcCECADIB03AgggAyACNgIEIANBgICAgHg2AgAgAUGIAWoQ4zwMEwsgASkD0AEhHSABKAKQASIHIAEoAogBRgRAIAFBiAFqQZCZ0AAQsygLIAEoAowBIAdBA3RqIB03AwAgASAHQQFqNgKQASACQQFrIgINAAsLIAFB0AFqIgIgBCgCADYCACABIAEpAogBNwPIASABQeAAahCFMCABQegAaiACKAIANgIAIAEgASkDyAE3A2AMDQsgAUHIAWogBSABLQCAAUHAABDJAiABKALIASICQQRGDQwgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDA8LIAFB8ABqEIYwIAFByAFqIAUQqCkgASgCyAEiAkEERwRAIAMgASkCzAE3AgggA0EQaiABQdQBaikCADcCACADQYCAgIB4NgIAIAMgAjYCBAwQCyABQcgBakGgmdAAQRYgAUEIahD1HSABKALIASICQQRHBEAgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDBALIAFByAFqQbaZ0ABBFiABQRhqEPUdIAEoAsgBIgJBBEcEQCADIAEpAswBNwIIIANBEGogAUHUAWopAgA3AgAgA0GAgICAeDYCACADIAI2AgQMEAsgAUHIAWpBzJnQAEEWIAFBKGoQ9R0gASgCyAEiAkEERwRAIAMgASkCzAE3AgggA0EQaiABQdQBaikCADcCACADQYCAgIB4NgIAIAMgAjYCBAwQCyABQcgBakHimdAAQRogAUE4ahDmHiABKALIASICQQRHBEAgAyABKQLMATcCCCADQRBqIAFB1AFqKQIANwIAIANBgICAgHg2AgAgAyACNgIEDBALIAEoAggiAkGAgICAeEYNBiABKAIYIgVBgICAgHhGDQcgASgCKCIEQYCAgIB4Rg0IIAtFDQkgASkCDCEdIAEpAhwhHiABKQIsIR8gAyABKQNANwIkIAMgASkDUDcCMCADIAEpA2A3AjwgAyAINgJIIAMgHzcCHCADIAQ2AhggAyAeNwIQIAMgBTYCDCADIB03AgQgAyACNgIAIANBLGogAUHIAGooAgA2AgAgA0E4aiABQdgAaigCADYCACADQcQAaiABQegAaigCADYCAAwQCyAHIAEoAtABQeCX0AAQ/S8ACyAHIAEoAtABQYCY0AAQ/S8ACyAHIAEoAtABQaCY0AAQ/S8ACyAHIAEoAtABQcCY0AAQ/S8ACyAHIAEoAtABQeCY0AAQ/S8ACyAHIAEoAtABQYCZ0AAQ/S8AC0H4/M8AQccAQfyZ0AAQyyQAC0H4/M8AQccAQYya0AAQyyQAC0H4/M8AQccAQZya0AAQyyQAC0H4/M8AQccAQaya0AAQyyQACyABIAg2AjxBASELIAFBATYCOAsgAUHwAGoQhjAgAUHIAWogBRDTCSAEIAlBCGopAgA3AwAgCiAJQRBqKAIANgIAIAEgCSkCADcDiAEgASgCyAFFDQALCyADIAEpA4gBNwIEIANBgICAgHg2AgAgA0EUaiAKKAIANgIAIANBDGogAUGQAWopAwA3AgAMAQsgAUHwAGoQhjALIAFB4ABqEIUwIAFB0ABqEIUwIAFBQGsQhTAgAUEoahDzMCABQRhqEPMwIAFBCGoQhjALIAFB4AFqJAAgBkEoaiAGQcQAaikCADcDACAGQTBqIAZBzABqKAIANgIAIAYgBikCPDcDIAJAAkACQAJAIAYoAjgiAUGAgICAeEYEQCANIAZBIGoQpSUMAQsgBkGcAWogBkHQAGpBNPwKAAAgBkGQAWogBkEoaikDADcCACAGQZgBaiAGQTBqKAIANgIAIAYgATYChAEgBiAGKQMgNwKIASANAn8CQAJAAkACQAJAAkACQAJAIA5BAWsOBwECAwQFBgcACyAGQThqIQkjAEHQAWsiASQAIAEgBkGEAWoiAygCFCICNgIEAkACQCADKAIkIgRBgICAgHhGDQAgAygCLCEIIAMoAighBSABIAQ2AmAgASAFNgJcIAEgBTYCWCABIAUgCEEDdGo2AmQgAUFAayABQdgAahDgGiABKAJAQYCAgIB4Rg0AIAFBEGogAUHIAGooAgA2AgAgASABKQJANwMIDAELIAFBCGogAhCkFQsgASABQQRqNgIUIAFBGGogAUEUaiIFIANBMGoQ8wsgAUEkaiAFIANBPGoQ8wsgAygCICEFIAMoAhAhBCADKAIcIQggAUEANgJoIAEgCDYCYCABIAQgAkEMbGo2AlwgASAENgJYIAFCADcCyAEgASABKAIoIgQgASgCLEEMbGo2AsQBIAEgASgCJDYCwAEgASAENgK8ASABIAQ2ArgBIAFCADcCsAEgASABKAIcIgQgASgCIEEMbGo2AqwBIAEgASgCGDYCqAEgASAENgKkASABIAQ2AqABIAFCADcCmAEgASABKAIMIgQgASgCEEEEdGo2ApQBIAEgASgCCDYCkAEgASAENgKMASABIAQ2AogBIAFCADcCgAEgASAFIAIgAiAFSxs2AmwgASAIIAVBDGxqNgJkIAEgAygCADYCeCABIAMoAgQiAjYCdCABIAI2AnAgASACIAMoAghqNgJ8IAFBQGshCCMAQaABayIFJAAgBUEINgIAIAVBJGoiBCABQdgAakH4APwKAAAgBSAFNgKcASAFQRhqIQojAEHAAWsiAiQAIAJBEGoiDCAEEJkdAkACQAJAIAIpAxBCAlIEQCACQcQAaiILIAQQrRogC0EEIAIoAkRBAWoiB0F/IAcbIgcgB0EETRtBAEEIQTAQoBggAigCSCEHIAIoAkRBAUYNAiACKAJMIg4gDEEw/AoAACACQQxqIhBBATYCACACIA42AgggAiAHNgIEIAsgBEH8APwKAAAjAEFAaiIEJAAgBCALEJkdIAQpAwBCAlIEQCACQQRqIQcDQCAHKAIIIgwgBygCAEYEQCAEQTRqIAsQrRogByAMIAQoAjRBAWoiDkF/IA4bQQhBMBDQKAsgBygCBCAMQTBsaiAEQTD8CgAAIAcgDEEBajYCCCAEIAsQmR0gBCkDAEICUg0ACwsgCxDiJCAEQUBrJAAgCkEIaiAQKAIANgIAIAogAikCBDcCAAwBCyAKQQA2AgggCkKAgICAgAE3AgAgBBDiJAsgAkHAAWokAAwBCyAHIAIoAkxByJfPABD9LwALAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ikgCkEIQTAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAkLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQEMBwsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB0AFrIgIkACACQRhqIgwgBxCdHQJAIAIpAxhCAlIEQCACQdQAaiILIAcQrRogC0EEIAIoAlRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQTgQoBggAigCWCEEIAIoAlRBAUYNCiACKAJcIg4gDEE4/AoAACACQRRqIhBBATYCACACIA42AhAgAiAENgIMIAsgB0H8APwKAAAjAEHQAGsiBCQAIARBCGogCxCdHSAEKQMIQgJSBEAgAkEMaiEHA0AgBygCCCIMIAcoAgBGBEAgBEHEAGogCxCtGiAHIAwgBCgCREEBaiIOQX8gDhtBCEE4ENAoCyAHKAIEIAxBOGxqIARBCGoiDkE4/AoAACAHIAxBAWo2AgggDiALEJ0dIAQpAwhCAlINAAsLIAsQ4iQgBEHQAGokACAKQQhqIBAoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgICAATcCACAHEOIkCyACQdABaiQAAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ykgCkEIQTgQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAgLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQIMBgsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCYHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQogAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJgdIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQmB0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAcLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQMMBQsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCeHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQkgAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJ4dIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQnh0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAYLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQQMBAsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB0AFrIgIkACACQRhqIgwgBxCcHQJAIAIpAxhCAlIEQCACQdQAaiILIAcQrRogC0EEIAIoAlRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQTgQoBggAigCWCEEIAIoAlRBAUYNByACKAJcIg4gDEE4/AoAACACQRRqIhBBATYCACACIA42AhAgAiAENgIMIAsgB0H8APwKAAAjAEHQAGsiBCQAIARBCGogCxCcHSAEKQMIQgJSBEAgAkEMaiEHA0AgBygCCCIMIAcoAgBGBEAgBEHEAGogCxCtGiAHIAwgBCgCREEBaiIOQX8gDhtBCEE4ENAoCyAHKAIEIAxBOGxqIARBCGoiDkE4/AoAACAHIAxBAWo2AgggDiALEJwdIAQpAwhCAlINAAsLIAsQ4iQgBEHQAGokACAKQQhqIBAoAgA2AgAgCiACKQIMNwIADAELIApBADYCCCAKQoCAgICAATcCACAHEOIkCyACQdABaiQAAkAgBSgCAEEIRwRAIAggBSkDADcDACAIQRBqIAVBEGopAwA3AwAgCEEIaiAFQQhqKQMANwMAIAoQ4ykgCkEIQTgQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAULIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQUMAwsgBkE4aiEJIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIEQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQUgASAENgJgIAEgBTYCXCABIAU2AlggASAFIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBSADQTBqEPMLIAFBJGogBSADQTxqEPMLIAMoAiAhBSADKAIQIQQgAygCHCEIIAFBADYCaCABIAg2AmAgASAEIAJBDGxqNgJcIAEgBDYCWCABQgA3AsgBIAEgASgCKCIEIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgBDYCvAEgASAENgK4ASABQgA3ArABIAEgASgCHCIEIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgBDYCpAEgASAENgKgASABQgA3ApgBIAEgASgCDCIEIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgBDYCjAEgASAENgKIASABQgA3AoABIAEgBSACIAIgBUsbNgJsIAEgCCAFQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQgjAEGgAWsiBSQAIAVBCDYCACAFQSRqIgcgAUHYAGpB+AD8CgAAIAUgBTYCnAEgBUEYaiEKIwBB4AFrIgIkACACQRhqIgwgBxCbHQJAIAIpAxhCAlIEQCACQeQAaiILIAcQrRogC0EEIAIoAmRBAWoiBEF/IAQbIgQgBEEETRtBAEEIQcgAEKAYIAIoAmghBCACKAJkQQFGDQcgAigCbCIOIAxByAD8CgAAIAJBFGoiEEEBNgIAIAIgDjYCECACIAQ2AgwgCyAHQfwA/AoAACMAQeAAayIEJAAgBEEIaiALEJsdIAQpAwhCAlIEQCACQQxqIQcDQCAHKAIIIgwgBygCAEYEQCAEQdQAaiALEK0aIAcgDCAEKAJUQQFqIg5BfyAOG0EIQcgAENAoCyAHKAIEIAxByABsaiAEQQhqIg5ByAD8CgAAIAcgDEEBajYCCCAOIAsQmx0gBCkDCEICUg0ACwsgCxDiJCAEQeAAaiQAIApBCGogECgCADYCACAKIAIpAgw3AgAMAQsgCkEANgIIIApCgICAgIABNwIAIAcQ4iQLIAJB4AFqJAACQCAFKAIAQQhHBEAgCCAFKQMANwMAIAhBEGogBUEQaikDADcDACAIQQhqIAVBCGopAwA3AwAgChDhKSAKQQhByAAQ4B4MAQsgCCAFKQIYNwIEIAhBCDYCACAIQQxqIAVBIGooAgA2AgALIAVBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBUEIRwRAIAEpA1AhHSAJIAEpAzA3AgQgCSAdNwMQIAlBDGogAigCADYCAAwBCyAJIAEpAzA3AgQgCUEMaiACKAIANgIAIAkgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgCSAFNgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAQLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQYMAgsgBkE4aiEFIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIJQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQQgASAJNgJgIAEgBDYCXCABIAQ2AlggASAEIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBCADQTBqEPMLIAFBJGogBCADQTxqEPMLIAMoAiAhBCADKAIQIQkgAygCHCEIIAFBADYCaCABIAg2AmAgASAJIAJBDGxqNgJcIAEgCTYCWCABQgA3AsgBIAEgASgCKCIJIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgCTYCvAEgASAJNgK4ASABQgA3ArABIAEgASgCHCIJIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgCTYCpAEgASAJNgKgASABQgA3ApgBIAEgASgCDCIJIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgCTYCjAEgASAJNgKIASABQgA3AoABIAEgBCACIAIgBEsbNgJsIAEgCCAEQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQQjAEGgAWsiAiQAIAJBCDYCACACQSRqIgggAUHYAGpB+AD8CgAAIAIgAjYCnAEgAkEYaiIJIAgQnRMCQCACKAIAQQhHBEAgBCACKQMANwMAIARBEGogAkEQaikDADcDACAEQQhqIAJBCGopAwA3AwAgCRDbGCAJQQhB0AAQ4B4MAQsgBCACKQIYNwIEIARBCDYCACAEQQxqIAJBIGooAgA2AgALIAJBoAFqJAAgAUE4aiICIAFBzABqKAIANgIAIAEgASkCRDcDMAJAIAEoAkAiBEEIRwRAIAEpA1AhHSAFIAEpAzA3AgQgBSAdNwMQIAVBDGogAigCADYCAAwBCyAFIAEpAzA3AgQgBUEMaiACKAIANgIAIAUgAygCSDYCEAsgA0EMaiICENcrIAIQ6DsgA0EYaiIDENcrIAMQ6DsgBSAENgIAIAFB0AFqJAAgBkHoAWoiASAGQcQAaikCADcDACAGIAYpAjw3A+ABIAYoAjgiA0EIRwRAIAYoAkwhAiANIAYpA+ABNwIEIA0gAjYCFCANIAM2AgAgDUEMaiABKQMANwIADAMLIAZB2AFqIAZB6AFqKQMANwMAIAYgBikD4AE3A9ABQQcMAQsgBkE4aiEFIwBB0AFrIgEkACABIAZBhAFqIgMoAhQiAjYCBAJAAkAgAygCJCIJQYCAgIB4Rg0AIAMoAiwhCCADKAIoIQQgASAJNgJgIAEgBDYCXCABIAQ2AlggASAEIAhBA3RqNgJkIAFBQGsgAUHYAGoQ4BogASgCQEGAgICAeEYNACABQRBqIAFByABqKAIANgIAIAEgASkCQDcDCAwBCyABQQhqIAIQpBULIAEgAUEEajYCFCABQRhqIAFBFGoiBCADQTBqEPMLIAFBJGogBCADQTxqEPMLIAMoAiAhBCADKAIQIQkgAygCHCEIIAFBADYCaCABIAg2AmAgASAJIAJBDGxqNgJcIAEgCTYCWCABQgA3AsgBIAEgASgCKCIJIAEoAixBDGxqNgLEASABIAEoAiQ2AsABIAEgCTYCvAEgASAJNgK4ASABQgA3ArABIAEgASgCHCIJIAEoAiBBDGxqNgKsASABIAEoAhg2AqgBIAEgCTYCpAEgASAJNgKgASABQgA3ApgBIAEgASgCDCIJIAEoAhBBBHRqNgKUASABIAEoAgg2ApABIAEgCTYCjAEgASAJNgKIASABQgA3AoABIAEgBCACIAIgBEsbNgJsIAEgCCAEQQxsajYCZCABIAMoAgA2AnggASADKAIEIgI2AnQgASACNgJwIAEgAiADKAIIajYCfCABQUBrIQQjAEGgAWsiAiQAIAJBCDYCACACQSRqIgkgAUHYAGpB+AD8CgAAIAIgAjYCnAEgAkEYaiIIIAkQnRMCQCACKAIAQQhHBEAgBCACKQMANwMAIARBEGogAkEQaikDADcDACAEQQhqIAJBCGopAwA3AwAgCBDFKgwBCyAEIAIpAhg3AgQgBEEINgIAIARBDGogAkEgaigCADYCAAsgAkGgAWokACABQThqIgIgAUHMAGooAgA2AgAgASABKQJENwMwAkAgASgCQCIEQQhHBEAgASkDUCEdIAUgASkDMDcCBCAFIB03AxAgBUEMaiACKAIANgIADAELIAUgASkDMDcCBCAFQQxqIAIoAgA2AgAgBSADKAJINgIQCyADQQxqIgIQ1ysgAhDoOyADQRhqIgMQ1ysgAxDoOyAFIAQ2AgAgAUHQAWokACAGQegBaiIBIAZBxABqKQIANwMAIAYgBikCPDcD4AEgBigCOCIDQQhHBEAgBigCTCECIA0gBikD4AE3AgQgDSACNgIUIA0gAzYCACANQQxqIAEpAwA3AgAMAgsgBkHYAWogBkHoAWopAwA3AwAgBiAGKQPgATcD0AFBCAs2AgQgDSAGKQPQATcCCCANQQg2AgAgDUEQaiAGQdgBaikDADcCAAsgBkEIahCdPCAGQfABaiQADAILIAQgAigCXEHIl88AEP0vAAsgBCACKAJsQciXzwAQ/S8ACyAPKAIUIQEgDygCECIGQQhGDQELIBMoAgBBCEcEQCATEMkjCyATIAE2AgQgEyAGNgIAIBMgFSkDADcDCCATQRBqIBVBCGopAwA3AwBBCQwFCwJAIAFBCUYEQCARIBQ2AggMAQsgD0EIaiAVQQhqKQIANwMAIA8gFSkCADcDACARIBQ2AgggAUEKRw0GCyAXQQFqIRcgFEEBaiEUIBwiASAZRw0ACwtBCiEBDAQLIAIgA0Hs5dAAELE7AAtBAAshASARIBQ2AggLIBYgDykDADcCBCAWQQxqIA9BCGopAwA3AgALIBYgATYCACAPQdAAaiQAIAACf0EJIBIoAhgiAUEKRg0AGiASQRBqIhEgEkEkaikCADcDACASIBIpAhw3AwhBCSABQQlGDQAaIAAgEikDCDcCBCAAQQxqIBEpAwA3AgAgAQs2AgAgEkEwaiQAC34BA38gAigCBCEDIAIoAgAgACABRwRAIAIoAgggA0EDdGohAiADIAEgAGtBA3YiAWohAwNAIAJBBGogAEEEaigCACIFNgIAIAIgACgCACAFKAIIQQFrQXhxakEIajYCACAAQQhqIQAgAkEIaiECIAFBAWsiAQ0ACwsgAzYCAAu3AQEDf0EDIQMgACgCBCICQSBNBEAgACgCCCIBIAAoAhBPBEAgACgCCCIBIAAoAhBJBH9BAwUgACAAKAIEIgJBB3E2AgQgACABIAJBA3ZrIgE2AgggACABKAAANgIAQQALDwsgACgCDCIDIAFGBEBBAkEBIAJBIEYbDwsgACACIAEgA2sgAkEDdiICIAEgAmsgA0kiAxsiAkEDdGs2AgQgACABIAJrIgE2AgggACABKAAANgIACyADC7MBACAAQgA3AqzpASAAQgA3A/DpASAAQYyAgOAANgKoUCAAQQA2ApzrASAAQgA3A4jqASAAQgM3A4DqASAAQbTpAWpCADcCACAAQfjpAWpCADcDACAAQbS10QApAgA3AqzQASAAQbTQAWpBvLXRACgCADYCACAAIABBEGo2AgAgACAAQaAwajYCBCAAIABBmCBqNgIIIAAgAEGo0ABqNgIMIABBAUEFIAAoAuzqARs2ArzpAQumAQEBfyMAQTBrIgIkAAJAAkACQAJAIAFB/wFxDgICAQALIAIgAToADyACQQI2AhQgAkGY+f4ANgIQIAJCATcCHCACQf0LNgIsIAIgAkEoajYCGCACIAJBD2o2AiggAEEEaiACQRBqEJkOIABBgICAgHg2AgAMAgsgAEGTgICAeDYCACAAQQE6AAQMAQsgAEGTgICAeDYCACAAQQA6AAQLIAJBMGokAAvkBQIGfwN+IwBBMGsiAyQAIANBEGohBiABKAIoIQUjAEGgAWsiAiQAAkACQAJAIAEoAhwiBCABKAIgRwRAAkAgASgCBEUNACAEIAEoAhRPDQIgASgCCCABKAIQIARqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIARBAWo2AhwMAwsgASAEQQFqNgIcIAEoAiQhByACIAEoAgAoAhAgBEEDdGopAwAiCDcDMCACIAcpAwAiCTcDWCACIAg3A1AgAiAIIAhCP4cgCSAJQj+HEKgeIAIpAwggAikDACIIQj+HUQRAQgEhCQwDCyACQQI2AnwgAkHwqIABNgJ4QgIhCSACQgI3AoQBIAJBsRA2ApwBIAJBsRA2ApQBIAIgAkGQAWoiATYCgAEgAiACQdgAajYCmAEgAiACQdAAajYCkAEgAkHoAGogAkH4AGoiBBCZDiACQcQAaiACQewAaikCADcCACACQcwAaiACQfQAaigCADYCACACQYiAgIB4NgJkIAIgAikCZDcCPCACQQE2AjggAkGYAWpBxLKAASgCADYCACACQbyygAEpAgA3A5ABIAJBAjYCfCACQeiygAE2AnggAkICNwKEASACQbEQNgJwIAJBrhA2AmggAiACQeQAajYCgAEgAiACQTBqNgJsIAIgATYCZCACQSBqIAQQmQ4gARCqDCACQThqQQRyEIgRIAIpAyAhCCACKQMoIQogBSgCAEGTgICAeEcEQCAFEIgRCyAFIAo3AgwgBSAINwIEIAVBhoCAgHg2AgAMAgsgBkIDNwMADAILQfSngAFBIEGUqIABEJ8pAAsgBiAINwMQIAYgCjcDCCAGIAk3AwALIAJBoAFqJAAgAAJ+QgIgAykDECIIQgNRDQAaIANBCGoiASADQSBqKQMANwMAIAMgAykDGDcDAEICIAhCAlENABogACADKQMANwMIIABBEGogASkDADcDACAICzcDACADQTBqJAALswMCBn8DfiMAQTBrIgMkACADQRBqIQYgASgCKCEEIwBBIGsiAiQAAkAgASgCHCIFIAEoAiBHBEACQAJ+AkACQAJAIAEoAgRFDQAgBSABKAIUTw0EIAEoAgggASgCECAFaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASAFQQFqNgIcDAELIAEgBUEBajYCHCACIAEoAgAgBRDaKyACQQhqIAIoAgAgAigCBBDpHCACKAIIIgFBAkcNAQtCAAwBCyABQQFxRQRAIAIpAxghCiACKQMQIQhCAQwBCyACKQMYIQkgAikDECEIIAIoAgwhASAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgILIQkgBiAKNwMQIAYgCDcDCCAGIAk3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBIGokACAAAn5CAiADKQMQIghCA1ENABogA0EIaiIBIANBIGopAwA3AwAgAyADKQMYNwMAQgIgCEICUQ0AGiAAIAMpAwA3AwggAEEQaiABKQMANwMAIAgLNwMAIANBMGokAAuwAwIGfwN+IwBBMGsiAyQAIANBEGohBiABKAIoIQQjAEEgayICJAACQCABKAIcIgUgASgCIEcEQAJAAn4CQAJAAkAgASgCBEUNACAFIAEoAhRPDQQgASgCCCABKAIQIAVqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAVBAWo2AhwMAQsgASAFQQFqNgIcIAIgASAFEK0qIAJBCGogAigCACACKAIEEOkcIAIoAggiAUECRw0BC0IADAELIAFBAXFFBEAgAikDGCEKIAIpAxAhCEIBDAELIAIpAxghCSACKQMQIQggAigCDCEBIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgshCSAGIAo3AxAgBiAINwMIIAYgCTcDAAwCC0H0p4ABQSBBlKiAARCfKQALIAZCAzcDAAsgAkEgaiQAIAACfkICIAMpAxAiCEIDUQ0AGiADQQhqIgEgA0EgaikDADcDACADIAMpAxg3AwBCAiAIQgJRDQAaIAAgAykDADcDCCAAQRBqIAEpAwA3AwAgCAs3AwAgA0EwaiQAC7MDAgZ/A34jAEEwayIDJAAgA0EQaiEGIAEoAighBCMAQSBrIgIkAAJAIAEoAhwiBSABKAIgRwRAAkACfgJAAkACQCABKAIERQ0AIAUgASgCFE8NBCABKAIIIAEoAhAgBWoiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgBUEBajYCHAwBCyABIAVBAWo2AhwgAiABKAIAIAUQjywgAkEIaiACKAIAIAIoAgQQ6RwgAigCCCIBQQJHDQELQgAMAQsgAUEBcUUEQCACKQMYIQogAikDECEIQgEMAQsgAikDGCEJIAIpAxAhCCACKAIMIQEgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICCyEJIAYgCjcDECAGIAg3AwggBiAJNwMADAILQfSngAFBIEGUqIABEJ8pAAsgBkIDNwMACyACQSBqJAAgAAJ+QgIgAykDECIIQgNRDQAaIANBCGoiASADQSBqKQMANwMAIAMgAykDGDcDAEICIAhCAlENABogACADKQMANwMIIABBEGogASkDADcDACAICzcDACADQTBqJAALiQEBAn8CQCAAIAJBAnRqIgQoAgAiAiADKAIAIgUoAgQiA0kEQCAAIAFBAnRqIgEoAgAiACADTw0BIAEgAiAAIAUoAgAiASACQQJ0aigCACABIABBAnRqKAIASCIBGzYCACAEIAAgAiABGzYCAA8LIAIgA0Gov4MBEMMhAAsgACADQbi/gwEQwyEAC4kBAQJ/AkAgACACQQJ0aiIEKAIAIgIgAygCACIFKAIEIgNJBEAgACABQQJ0aiIBKAIAIgAgA08NASABIAIgACAFKAIAIgEgAkECdGooAgAgASAAQQJ0aigCAEkiARs2AgAgBCAAIAIgARs2AgAPCyACIANBqL+DARDDIQALIAAgA0G4v4MBEMMhAAuJAQECfwJAIAAgAkECdGoiBCgCACICIAMoAgAiBSgCBCIDSQRAIAAgAUECdGoiASgCACIAIANPDQEgASACIAAgBSgCACIBIAJBA3RqKQMAIAEgAEEDdGopAwBTIgEbNgIAIAQgACACIAEbNgIADwsgAiADQai/gwEQwyEACyAAIANBuL+DARDDIQALiQEBAn8CQCAAIAJBAnRqIgQoAgAiAiADKAIAIgUoAgQiA0kEQCAAIAFBAnRqIgEoAgAiACADTw0BIAEgAiAAIAUoAgAiASACQQN0aikDACABIABBA3RqKQMAVCIBGzYCACAEIAAgAiABGzYCAA8LIAIgA0Gov4MBEMMhAAsgACADQbi/gwEQwyEAC4UBAgJ/AX4jAEEwayIBJAAgASAAELMIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAELEIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAELIIAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC4UBAgJ/AX4jAEEwayIBJAAgASAAEJcDAkAgASgCAEUEQEEAIQAMAQsgAUEoaiABQRBqKQIANwMAIAFBIGogAUEIaikCADcDACABIAEpAgAiAzcDGCABKAIsIQAgA6ciAiACKAIAIgJBAWs2AgAgAkEBRw0AIAFBGGoQ+x4LIAFBMGokACAAC5QBAQF/IwBBIGsiBCQAAkAgASgCAEF/IAIgA2oiASABIAJJG08EQEEMQQQQrTYiAUUNASABIAM2AgggAUKBgICAEDcCACAAQbCphgE2AgQgACABNgIAIARBIGokAA8LIARBADYCGCAEQQE2AgwgBEH8qIYBNgIIIARCBDcCECAEQQhqQYSphgEQ7ywAC0EEQQwQoz0AC1cBAn8CQAJAAkAgACgCAA4GAgICAgEAAQsgACgCBCECIAAoAggiACgCACIBBEAgAiABEQMACyAAKAIEIgFFDQAgAiABIAAoAggQ+DoLDwsgAEEEahDeOwuRAQEBfyMAQRBrIgYkACAGIAU2AgwgBiAENgIIIABBLGogBkEIahDELSAAQgI3AhwgAEICNwIQIAAgATsBRiAAIAIgA2oiAjsBRCAAQQA2AgggAEKAgICAwAA3AgAgACAFNgIoIAAgBDYCJCAAIAFB//8DcUVBH3Q2AhggACACQf//A3FFQR90NgIMIAZBEGokAAuKAQEDfyMAQSBrIgIkACABKQMAQgNSBEAgAkEIaiABIAEoAkBBgAgQ1RkgAigCDCEDAkAgAigCCCIEQQhHBEAgACACKQMQNwMIIABBEGogAkEYaikDADcDACAAIAM2AgQMAQsgASADNgJEIAFBADYCSAsgACAENgIAIAJBIGokAA8LQbSwzgAQsjsAC34BAX8jAEEQayIDJAAgA0EEaiAAKAIMIgBBCGogACgCCEECRkECdGoiABCJGQJ/AkAgAy0ABEEIRw0AIAMtAAYNACABKQMAIAIpAwBWDAELIAAtACFBHHFBDEYEQCABKQMAIAIpAwBWDAELIAEpAwAgAikDAFULIANBEGokAAt/AQZ/IAAoAggiBARAIAAoAgQhBQNAIAUgAkHQAGxqIgFBMGogASgCOCIDBEAgASgCNCEAA0AgABDYEyAAQegDaiEAIANBAWsiAw0ACwtBCEHoAxDgHiABKAI8QYCAgIB4RwRAIAFBPGpBBEEIEOAeCyACQQFqIgIgBEcNAAsLC+8NAhd/BX4jAEFAaiIJJAAgAEEoaiIEIAEgAhDNAiEcIAkgADYCECAJIAI2AgwgCSABNgIIIAlBGGohCCAJQQhqIQ0jAEEQayISJAAgAEEYaiIFKAIIRQRAIBJBCGohGSMAQfAAayIDJAAgAyAANgIsIAMgBDYCKCAFKAIMIQQgAyADQShqNgIwAkACQAJAAkAgBCAEQQFqIgZNBEAgBSgCBCIEIARBAWpBA3ZBB2wgBEEISRsiBEEBdiAGSQRAIARBAWoiBCAGIAQgBksbIgRBD0kNAiAEQf////8BTQRAQX8gBEEDdEEHbkEBa2d2QQFqIQoMBAsQ3ScgAygCJCEKIAMoAiAiC0GBgICAeEcNBQwDCyAFIANBMGpBtKbPABDrCQwDCxDdJyADKAIMIQogAygCCCELDAMLQQRBCEEQIARBCEkbIARBBEkbIQoLIANB4ABqIAVBEGoiBkEIIAoQ+xQgAygCaCEKIAMoAmQhCyADKAJgIgRFDQEgAyADKAJsNgJcIAMgCjYCWCADIAs2AlQgAyAENgJQIANBGGogA0HQAGoQwTQgAygCHCIEBEAgAygCGEH/ASAE/AsACyADKAJYIQogAygCVCELIAMoAlAiDkUNASADIAMoAlw2AkwgAyAKNgJIIAMgCzYCRCADIA42AkAgA0KIgICAgAE3AjggAyAGNgI0IANBQGshEyADIAUoAgwiDwR/IA5BCGohByAFKAIAIhEpAwBCf4VCgIGChIiQoMCAf4MhGgNAIBpQBEADQCAVQQhqIRUgEUEIaiIRKQMAQoCBgoSIkKDAgH+DIhtCgIGChIiQoMCAf1ENAAsgG0KAgYKEiJCgwIB/hSEaCyADKAIwIgYoAgAhBCADQRBqIAYoAgQgBSgCACAaeqdBA3YgFWpBA3QiDGtBCGspAwAQ8h0gDiALIAQgAygCECADKAIUEM0CpyIGcSIQaikAAEKAgYKEiJCgwIB/gyIbUARAQQghFgNAIBAgFmohBCAWQQhqIRYgDiAEIAtxIhBqKQAAQoCBgoSIkKDAgH+DIhtQDQALCyAaQgF9IBqDIRogDiAbeqdBA3YgEGogC3EiEGosAABBAE4EQCAOKQMAQoCBgoSIkKDAgH+DeqdBA3YhEAsgDiAQaiAGQRl2IgQ6AAAgByAQQQhrIAtxaiAEOgAAIA4gEEEDdGtBCGsgBSgCACAMa0EIaykAADcAACAPQQFrIg8NAAsgBSgCDAVBAAsiBDYCTCADIAogBGs2AkggBSATQQQQ+iogA0E0ahD1JwtBgYCAgHghCwsgGSAKNgIEIBkgCzYCACADQfAAaiQACyAFKAIEIhEgHKdxIQ8gHEIZiEL/AINCgYKEiJCgwIABfiEeIA0oAgghByANKAIEIQwgDSgCACEGIAUoAgAhEwNAAkAgDyATaikAACIdIB6FIhtCf4UgG0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEaAn8CQCAIAn4CQANAIBpQDQEgEiAHIAUoAgAgGnqnQQN2IA9qIBFxIgRBA3RrQQhrKQMAEPIdIBpCAX0gGoMhGiAGIAwgEigCACASKAIEEJ87RQ0ACyAIIBw3AwggCCAFKAIAQQAgBGtBA3RqNgIQQgAMAQsgHUKAgYKEiJCgwIB/gyEbIBdFBEAgG1ANAiAbeqdBA3YgD2ogEXEhFAtBASAbIB1CAYaDUA0CGiAIIBMgFGosAABBAE4EfyATKQMAQoCBgoSIkKDAgH+DeqdBA3YFIBQLNgIQIAggHDcDCEIBCzcDACAIIAU2AhQgEkEQaiQADAILQQALIRcgDyAYQQhqIhhqIBFxIQ8MAQsLIAkgAjYCPCAJIAE2AjggCSAANgI0IAlBNGohAQJAIAgoAgBBAUYEQCAIKQMIIRsgCCgCECEGIAgoAhQhDCABKAIAIQcgASgCBCEAIAEoAgghASMAQRBrIgQkACAHNQIUIRwgByABQQRqEOUtIAQgATYCDCAHIARBDGpBBBChNiAHKAIIIQIgByAAIAEQoTYgBygCCCEBIAcoAhQiCCAHKAIMRgRAIAdBDGpB0PjNABCbKAsgBygCECAIQQN0aiIAIAE2AgQgACACNgIAIAcgCEEBajYCFCAEQRBqJAAgBiAMKAIAIgJqIgAtAAAhASAAIBunQRl2IgA6AAAgAiAMKAIEIAZBCGtxakEIaiAAOgAAIA0gDDYCDCANIBs3AwAgDCAMKAIMQQFqNgIMIA0gAiAGQQN0ayIANgIIIAwgDCgCCCABQQFxazYCCCAAQQhrIBw3AwAMAQsgDSAIQQhqIgApAwA3AwAgDUEIaiAAQQhqKQMANwMACyAJKAIQQQhrKQMAIAlBQGskAAuVAQEEfyMAQSBrIgIkACACQQhqEP0nIAAoAhQhAyACKAIIIQQgACACKAIMNgIUIAAoAhAhBSAAIAQ2AhAgASAFIAMQ4DUgAkEANgIcIAJCgICAgCA3AhQgAiACQRRqQYyHzgAQqiEgACgCHCEBIAAoAhghAyAAIAIpAwA3AhggAQRAIAMgAUEBdEECEPg6CyACQSBqJAALlwIBBn8jAEEgayIDJAAgA0EUaiABQQBBAkEEEKAYIAMoAhghAiADKAIUQQFGBEAgAiADKAIcQcSo+wAQ/S8ACyADQRBqIgdBADYCACADIAMoAhw2AgwgAyACNgIIIANBCGoiBSgCACAFKAIIIgJrIAFJBEAgBSACIAFBAhDOKCAFKAIIIQILIAUoAgQgAkECdGohBAJAAkAgAUECTwRAIAFBAWshBgNAIARBADsBACAEQQJqQQA6AAAgBEEEaiEEIAZBAWsiBg0ACyABIAJqQQFrIQIMAQsgAUUNAQsgBEEAOgACIARBADsBACACQQFqIQILIAUgAjYCCCAAQQhqIAcoAgA2AgAgACADKQIINwIAIANBIGokAAuRAQECfyMAQTBrIgIkAAJ/IAAoAgAiAwRAIAIgACgCBDYCDCACIAM2AgggAkEBNgIUIAJBjMH7ADYCECACQgE3AhwgAkHHAjYCLCACIAJBKGo2AhggAiACQQhqNgIoIAEoAgAgASgCBCACQRBqEMsKDAELIAEoAgBB2MD7AEEZIAEoAgQoAgwRBgALIAJBMGokAAt4AQJ/IAAoAggiA0EATwRAIAAoAgAgA0YEQCAAIAIQkCgLIAAoAgQhAgJAIANFDQAgA0EMbCIERQ0AIAJBDGogAiAE/AoAAAsgAiABKQIANwIAIAJBCGogAUEIaigCADYCACAAIANBAWo2AggPC0EAIAMgAhDCIQALlwECAX4CfwJAIAApAwAiAVBFBEAgACgCECECDAELIAAoAhAhAiAAKAIIIQMDQCACQcABayECIAMpAwAgA0EIaiEDQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgACACNgIQIAAgAzYCCCABQoCBgoSIkKDAgH+FIQELIAAgAUIBfSABgzcDACACIAF6p0EDdkFobGoLewIEfgF/IAApAwAiBCABKQMAIgVWIAApAwgiAiABKQMIIgNWIAIgA1EiBhsgBCAFVCACIANUIAYbayAAKQMQIgQgASkDECIFViAAKQMYIgIgASkDGCIDVSACIANRIgAbIAQgBVQgAiADUyAAG2sgBCAFhSACIAOFhFAbC4kCAQV/IwBBIGsiAiQAIAJBDGohAwJAAkAgASgCBCIGBEAgASgCCCEFQRhBBBCtNiIERQ0BIARCgYCAgBA3AgAgAyAFNgIQIANBsPmHATYCDCADIAQ2AgggAyAFNgIEIAMgBjYCACAEIAEpAgA3AgggBEEQaiABQQhqKQIANwIADAILQaD5hwEQsjsAC0EEQRgQoz0ACyACKAIMIQMgAigCECEEQRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASACKQIMNwIIIAAgBDYCCCAAIAM2AgQgACABNgIAIAFBEGogAkEUaikCADcCACABQRhqIAJBHGooAgA2AgAgAkEgaiQAC4YBAQN/AkAgACgCGEGAgICAeEcEQCAAQRhqEN47DAELIAAoAhAhAiAAKAIUIgEoAgAiAwRAIAIgAxEDAAsgASgCBCIDRQ0AIAIgAyABKAIIEPg6CyAAKAIoIQIgACgCLCIAKAIAIgEEQCACIAERAwALIAAoAgQiAQRAIAIgASAAKAIIEPg6CwuOAQECfyMAQdADayICJAAgAiAAEJUaIAFBCEkEQCACQZgBaiIAIAJBmAH8CgAAIAFBAnQiAUH8g8MAaigCACEDIAAgAUHcg8MAaigCADYCJCAAIAM2AiAgAkG4AmogAEGYAfwKAAAgAkEANgKwAiACQbACahDRKUEIaiACQdADaiQADwtB5ILDAEEZEJc9AAueAgEGfyMAQSBrIgIkACACQRRqIAFBAEEEQQQQoBggAigCGCEDIAIoAhRBAUYEQCADIAIoAhxByP7CABD9LwALIAJBEGoiB0EANgIAIAIgAigCHDYCDCACIAM2AggjAEEQayIGJAAgBkEANgIMIAJBCGoiBCgCACAEKAIIIgNrIAFJBEAgBCADIAFBBEEEENAoIAQoAgghAwsgBCgCBCADQQJ0aiEFAkACQCABQQJPBEAgAUEBayIBIANqIQMDQCAFQQA2AgAgBUEEaiEFIAFBAWsiAQ0ACwwBCyABDQAgBCADNgIIDAELIAVBADYCACAEIANBAWo2AggLIAZBEGokACAAQQhqIAcoAgA2AgAgACACKQIINwIAIAJBIGokAAuHAQEBfwJAIAEEQCABQQhrIgIoAgBBAUcNASAAIAEpAgQ3AgAgAEEQaiABQRRqKAIANgIAIABBCGogAUEMaikCADcCACACQQA2AgACQCACQX9GDQAgAUEEayIAIAAoAgBBAWsiADYCACAADQAgAkEgQQQQ+DoLDwsQmD0AC0GX2sMAQT8Qlz0AC5QCAQZ/IwBBIGsiBCQAIARBFGogAkEAQQRBiAgQoBggBCgCGCEDIAQoAhRBAUYEQCADIAQoAhxBxJ7QABD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAM2AgggBEEIaiIFKAIAIAUoAggiA2sgAkkEQCAFIAMgAkEEQYgIENAoIAUoAgghAwsgBSgCBCADQYgIbGohBgJAAkAgAkECTwRAIAJBAWshBwNAIAYgAUGICPwKAAAgBkGICGohBiAHQQFrIgcNAAsgAiADakEBayEDDAELIAJFDQELIAYgAUGICPwKAAAgA0EBaiEDCyAFIAM2AgggAEEIaiAIKAIANgIAIAAgBCkCCDcCACAEQSBqJAALlAIBBn8jAEEgayIEJAAgBEEUaiACQQBBBEGIERCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBiBEQ0CggBSgCCCEDCyAFKAIEIANBiBFsaiEGAkACQCACQQJPBEAgAkEBayEHA0AgBiABQYgR/AoAACAGQYgRaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNAQsgBiABQYgR/AoAACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuuAgEGfyMAQSBrIgQkACAEQRRqIAJBAEEEQRAQoBggBCgCGCEDIAQoAhRBAUYEQCADIAQoAhxBxJ7QABD9LwALIARBEGoiCEEANgIAIAQgBCgCHDYCDCAEIAM2AgggBEEIaiIGKAIAIAYoAggiA2sgAkkEQCAGIAMgAkEEQRAQ0CggBigCCCEDCyAGKAIEIANBBHRqIQUCQAJAIAJBAk8EQCACQQFrIQcDQCAFIAEpAgA3AgAgBUEIaiABQQhqKQIANwIAIAVBEGohBSAHQQFrIgcNAAsgAiADakEBayEDDAELIAJFDQELIAUgASkCADcCACAFQQhqIAFBCGopAgA3AgAgA0EBaiEDCyAGIAM2AgggAEEIaiAIKAIANgIAIAAgBCkCCDcCACAEQSBqJAALlAIBBn8jAEEgayIEJAAgBEEUaiACQQBBBEGIFhCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBiBYQ0CggBSgCCCEDCyAFKAIEIANBiBZsaiEGAkACQCACQQJPBEAgAkEBayEHA0AgBiABQYgW/AoAACAGQYgWaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNAQsgBiABQYgW/AoAACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuDAQEFfyABIAAoAgAiBC8BBiICIAAoAggiA0F/c2oiADsBBgJAIABBDEkEQCACIANBAWoiAmsgAEcNASAEQQhqIgUgA2otAAAgAARAIAFBCGogAiAFaiAA/AoAAAsgBCADOwEGDwsgAEELQfS3zQAQsDsAC0G8t80AQShB5LfNABCfKQALgAEBA38gACgCACAAKAIIIgJrIAFJBEAgACACIAFBAUEBENAoIAAoAgghAgsgACgCBCIEIAJqIQMCQAJAIAFBAk8EQCABQQFrIgEEQCADQQAgAfwLAAsgBCABIAJqIgJqIQMMAQsgAUUNAQsgA0EAOgAAIAJBAWohAgsgACACNgIIC4YBAQN/IwBBIGsiAyQAIANBFGogAkEAQQRBIBCgGCADKAIYIQQgAygCFEEBRgRAIAQgAygCHEHEntAAEP0vAAsgA0EQaiIFQQA2AgAgAyADKAIcNgIMIAMgBDYCCCADQQhqIAIgARCUFCAAQQhqIAUoAgA2AgAgACADKQIINwIAIANBIGokAAuCAQEDfyAAKAIAIgFBDGogASgCFCICBEAgASgCECEAA0AgAEEMaiAAQQRqKAIAIABBCGooAgAgACgCACgCEBEBACAAQRBqIQAgAkEBayICDQALC0EEQRAQ4B4CQCABQX9GDQAgASABKAIEIgBBAWs2AgQgAEEBRw0AIAFBHEEEEPg6CwuYAgIGfwF+IwBBIGsiBCQAIARBFGogAkEAQQRBCBCgGCAEKAIYIQMgBCgCFEEBRgRAIAMgBCgCHEHEntAAEP0vAAsgBEEQaiIIQQA2AgAgBCAEKAIcNgIMIAQgAzYCCCAEQQhqIgUoAgAgBSgCCCIDayACSQRAIAUgAyACQQRBCBDQKCAFKAIIIQMLIAUoAgQgA0EDdGohBgJAAkAgAkECTwRAIAJBAWshByABKQIAIQkDQCAGIAk3AgAgBkEIaiEGIAdBAWsiBw0ACyACIANqQQFrIQMMAQsgAkUNASABKQIAIQkLIAYgCTcCACADQQFqIQMLIAUgAzYCCCAAQQhqIAgoAgA2AgAgACAEKQIINwIAIARBIGokAAuJAQECfyABQYACTwRAIAAgARDxEA8LAn9BwPOKASgCACICQQEgAUEDdnQiA3FFBEBBwPOKASACIANyNgIAIAFB+AFxQbjxigFqIgEMAQsgAUH4AXFBqPCKAWoiAkGQAWohASACQZgBaigCAAshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggLhAEBAX8jAEEwayIBJAAgASAAOgAPIABB/wFxIgBBDk9B+fsAIAB2QQFxRXJFBEAgAEH8pP4Aai0AACABQTBqJAAPCyABQQI2AhQgAUHApP4ANgIQIAFCATcCHCABQbALNgIsIAEgAUEoajYCGCABIAFBD2o2AiggAUEQakHQpP4AEO8sAAu2AQEDfyAAKAIAIAAoAggiAmsgAUkEQCMAQRBrIgMkACADQQhqIAAgAiABQQFBARC3ESADKAIIIgJBgYCAgHhHBEAgAiADKAIMQdyB/wAQ/S8ACyADQRBqJAAgACgCCCECCyAAKAIEIgQgAmohAwJAAkAgAUECTwRAIAFBAWsiAQRAIANBACAB/AsACyAEIAEgAmoiAmohAwwBCyABRQ0BCyADQQA6AAAgAkEBaiECCyAAIAI2AggLfgEBfwJAIAAoAiBB/wdxQe8GRw0AIAAtAARB/QFHDQAgAC0AB0H9AUcNACAALQADIAAtAAFB5ABsIAAtAABB6AdsaiAALQACQQpsampB//8DcSAALQAGIAAtAAVBCmxqQf8BcSAALQAJIAAtAAhBCmxqQf8BcRCOJyEBCyABC4ABAgN/AX4jAEEgayIDJAAgA0EIaiIEIAEgAhCBBAJAIAMoAggiBUEBRgRAIAUEQCAEQQRyEIgRCyADQQhqIAEgAhCbCiAAIAMtAAgEfiAGBSAAIAMpAxA3AwhCAQs3AwAMAQsgACADKQMQQugHfzcDCCAAQgE3AwALIANBIGokAAt6AQR/IwBBIGsiAyQAIANBCGoiBSABIAIQgQRBASEEIAACfyADKAIIIgZBAUYEQCAGBEAgBUEEchCIEQsgA0EIaiABIAIQzwogAy0ACEF/c0EBcSEEIAMoAgwMAQsgAykDEELAhD1/pws2AgQgACAENgIAIANBIGokAAt8AQR/IwBBIGsiAyQAIANBCGoiBSABIAIQgQRBASEEIAACfyADKAIIIgZBAUYEQCAGBEAgBUEEchCIEQsgA0EIaiABIAIQzwogAy0ACEF/c0EBcSEEIAMoAgwMAQsgAykDEEKAlOvcA3+nCzYCBCAAIAQ2AgAgA0EgaiQAC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQqgYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCqBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDwBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDwBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkLygQBB38jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCAJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIFRQ0AQQogBSAFQQpPGyEHQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMQHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByADQQFqIgNHDQALIAVBC0kNASAFQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAHIAMgB0sbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDEBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCAsgBEEwaiQAIAgL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC9Bg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC9Bg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDxBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPEGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJ4LDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJ4LDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPMGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEPMGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO4GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO4GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvKBAEHfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEIAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgVFDQBBCiAFIAVBCk8bIQdBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQwwcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIANBAWoiA0cNAAsgBUELSQ0BIAVBFU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAcgAyAHSxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMMHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEICyAEQTBqJAAgCAvSBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBBEkNAEEKIAdBAnYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIkHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBLEkNASAHQdQATwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQiQcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EQSQ0AQQogB0EEdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQogoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0GwAUkNASAHQdACTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQogoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQwgsNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDCCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDtBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDtBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDyBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDyBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC2Aw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARC2Aw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0QQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQJJDQBBCiAHQQF2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCHBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQRZJDQEgB0EqTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQhwcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EISQ0AQQogB0EDdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7QoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0HYAEkNASAHQagBTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7QoNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9MEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EISQ0AQQogB0EDdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQkwYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0HYAEkNASAHQagBTwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQkwYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9EEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0ECSQ0AQQogB0EBdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQhQcNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EWSQ0BIAdBKk8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIUHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELUDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELUDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIsGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBsAFJDQEgB0HQAk8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIsGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvRBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBAkkNAEEKIAdBAXYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEMELDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBFkkNASAHQSpPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARDBCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCIBw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIgHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIYHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIYHDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELQDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELQDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELMDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABELMDDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvTBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBCEkNAEEKIAdBA3YiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIMEDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdB2ABJDQEgB0GoAU8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEIMEDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQvSBAEIfyMAQTBrIgQkACAEIAA2AgwgBEECNgIUIARB7OSEATYCECAEQgE3AhwgBEGvAzYCLCAEIARBKGo2AhggBCAEQQxqIgM2AihBASEJAkAgASgCACABKAIEIARBEGoQywoNACMAQTBrIgIkACACIAA2AgggAiADNgIEAkACQCAAKAIUIgdBBEkNAEEKIAdBAnYiBSAFQQpPGyEIQQAhAwJAA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEO8GDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBLEkNASAHQdQATwRAIAJBAjYCECACQeDDhAE2AgwgAkIBNwIYIAJBOzYCKCACIAVBFGs2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQ7wYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkEwaiQAIAYNACABKAIAQfzkhAFBASABKAIEKAIMEQYAIQkLIARBMGokACAJC9IEAQh/IwBBMGsiBCQAIAQgADYCDCAEQQI2AhQgBEHs5IQBNgIQIARCATcCHCAEQa8DNgIsIAQgBEEoajYCGCAEIARBDGoiAzYCKEEBIQkCQCABKAIAIAEoAgQgBEEQahDLCg0AIwBBMGsiAiQAIAIgADYCCCACIAM2AgQCQAJAIAAoAhQiB0EESQ0AQQogB0ECdiIFIAVBCk8bIQhBACEDAkADQAJAIAAgAxCHJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBBGogACADIAEQggQNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0EsSQ0BIAdB1ABPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCCBA0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQhJDQBBCiAHQQN2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCUBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQdgASQ0BIAdBqAFPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCUBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0wQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQSBJDQBBCiAHQQV2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCbBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQeACSQ0BIAdBoAVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBUEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIAVBCmsiAyAIIAMgCEsbIgMgBU8NAQNAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCbBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQTBqJAAgBg0AIAEoAgBB/OSEAUEBIAEoAgQoAgwRBgAhCQsgBEEwaiQAIAkL0gQBCH8jAEEwayIEJAAgBCAANgIMIARBAjYCFCAEQezkhAE2AhAgBEIBNwIcIARBrwM2AiwgBCAEQShqNgIYIAQgBEEMaiIDNgIoQQEhCQJAIAEoAgAgASgCBCAEQRBqEMsKDQAjAEEwayICJAAgAiAANgIIIAIgAzYCBAJAAkAgACgCFCIHQQRJDQBBCiAHQQJ2IgUgBUEKTxshCEEAIQMCQANAAkAgACADEIclRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEEaiAAIAMgARCWBg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggA0EBaiIDRw0ACyAHQSxJDQEgB0HUAE8EQCACQQI2AhAgAkHgw4QBNgIMIAJCATcCGCACQTs2AiggAiAFQRRrNgIsIAIgAkEkajYCFCACIAJBLGo2AiQgASgCACABKAIEIAJBDGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQhyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQRqIAAgAyABEJYGDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBMGokACAGDQAgASgCAEH85IQBQQEgASgCBCgCDBEGACEJCyAEQTBqJAAgCQuaCgEIfyMAQYABayIJJAAgCUEEaiEHIwBB0ABrIgYkACAGIAE2AgggBiACKAIIIgpBAnZBAWsiCzYCDAJAAkACQAJAAkACQAJAAkAgCkEESQ0AIAIoAgQgCkF8cWpBBGsiCEUNACADKAIYIQogBiAIKAIAIgg2AhACQCAIIApNBEACQCAEKAIAIgoEQCALIAQoAhAiCEcNAQsgAS0ASEUEQCADKAIcRQ0DIAMoAjBFDQMLIAZBNGpBJUEAQQFBARCgGCAGKAI4IQEgBigCNEEBRg0EIAYoAjwiBUG03IUBQSX8CgAAIAdBJTYCECAHIAU2AgwgByABNgIIIAdCgICAgNiBgICAfzcCAAwHCyAGIAg2AkwgBkECNgI4IAZBuNuFATYCNCAGQgI3AkAgBkE7NgIgIAZBOzYCGCAGIAZBFGo2AjwgBiAGQcwAajYCHCAGIAZBDGo2AhQgB0EIaiAGQTRqEJkOIAdCgICAgNiBgICAfzcCAAwHCyAGIAo2AkwgBkECNgI4IAZB9NyFATYCNCAGQgI3AkAgBkE7NgIgIAZBOzYCGCAGIAZBFGo2AjwgBiAGQcwAajYCHCAGIAZBEGo2AhQgB0EIaiAGQTRqEJkOIAdCgICAgNiBgICAfzcCACAEKAIAIQoMBQsgAUEwaiILIANBDGoiCBDFCEUNAiADKAIIIgtBAkcNAyAHIAQpAgA3AkwgB0HcAGogBEEQaikCADcCACAHQdQAaiAEQQhqKQIANwIAIAcgA0E0/AoAACAHIAE2AjggByAFOgA1IAdBJzoANCAHQcgAaiACQQhqKAIANgIAIAcgAikCADcCQAwHC0Hw2oUBELI7AAsgASAGKAI8QcTShQEQ/S8ACyAGIAs2AiwgBiAINgIwIAYgAUE8ajYCTCAGQQM2AhggBkGc3IUBNgIUIAZCAzcCICAGQcoENgJIIAZBpwQ2AkAgBkGnBDYCOCAGIAZBNGo2AhwgBiAGQcwAajYCRCAGIAZBMGo2AjwgBiAGQSxqNgI0IAdBCGogBkEUahCZDiAHQoCAgIDYgYCAgH83AgAMAQsgBkEBNgI4IAZB+NuFATYCNCAGQgE3AkAgBkE7NgIYIAYgCzYCTCAGIAZBFGo2AjwgBiAGQcwAajYCFCAHQQhqIQsjAEEQayIBJAAgBkE0aiIFKAIMIQgCQAJAAkACQAJAAkACQCAFKAIEDgIAAQILIAgNAUEBIQhBACEFDAILIAgNACAFKAIAIggoAgQhBSAIKAIAIQgMAQsgCyAFEJkODAELIAFBBGogBUEAQQFBARCgGCABKAIIIQwgASgCBEEBRg0BIAEoAgwhDSAFBEAgDSAIIAX8CgAACyALIAU2AgggCyANNgIEIAsgDDYCAAsgAUEQaiQADAELIAwgASgCDEHE0oUBEP0vAAsgB0KAgICA2IGAgIB/NwIACyAKRQ0BCyAKIAooAgAiAUEBazYCACABQQFHDQAgBBD7HgsgAxDWKCACKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCACEPseCyAGKAIIIgEgASgCACIBQQFrNgIAIAFBAUcNACAGQQhqEPIlCyAGQdAAaiQAIAkoAgRBgICAgHhHBEAgACAHQeQA/AoAACAJQYABaiQADwsgCUH4AGogCUEYaigCADYCACAJQfAAaiAJQRBqKQIANwMAIAkgCSkCCDcDaEGsz4UBQSsgCUHoAGpBnM+FAUGE3YUBENUeAAuEAQEEfyMAQRBrIgIkACAAKAIMIgMgACgCBCIBRwRAIAMgAWtBA3YhAwNAIAEoAgAiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAEQuyMLIAFBCGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEEQQgQ4B4gAkEQaiQAC4UBAQJ/IwBB0ABrIgYkACAGQQRqIgcgASACIAMgBCAFEOEGIAYtAARBKUcEQCAAIAdBNPwKAAAgBkHQAGokAA8LIAZByABqIAZBGGooAgA2AgAgBkFAayAGQRBqKQIANwMAIAYgBikCCDcDOEH0m4YBQSsgBkE4akHkm4YBQcyjhgEQ1R4AC3kBA38jAEGAAWsiAyQAIAAvAQAhBEEAIQADQCAAIANqQf8AaiAEQQ9xIgJBMHIgAkHXAGogAkEKSRs6AAAgAEEBayEAIAQiAkEEdiEEIAJBD0sNAAsgAUEBQeDziQFBAiAAIANqQYABakEAIABrEIEJIANBgAFqJAALeAEDfyMAQYABayIDJAAgAC0AACEEQQAhAANAIAAgA2pB/wBqIARBD3EiAkEwciACQTdqIAJBCkkbOgAAIABBAWshACAEIgJBBHYhBCACQQ9LDQALIAFBAUHg84kBQQIgACADakGAAWpBACAAaxCBCSADQYABaiQAC3kBA38jAEGAAWsiAyQAIAAtAAAhBEEAIQADQCAAIANqQf8AaiAEQQ9xIgJBMHIgAkHXAGogAkEKSRs6AAAgAEEBayEAIAQiAkEEdiEEIAJBD0sNAAsgAUEBQeDziQFBAiAAIANqQYABakEAIABrEIEJIANBgAFqJAALeAEDfyMAQYABayIDJAAgAC8BACEEQQAhAANAIAAgA2pB/wBqIARBD3EiAkEwciACQTdqIAJBCkkbOgAAIABBAWshACAEIgJBBHYhBCACQQ9LDQALIAFBAUHg84kBQQIgACADakGAAWpBACAAaxCBCSADQYABaiQAC3oCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUHg84kBQQIgACAEakGAAWpBACAAaxCBCSAEQYABaiQAC3kCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJIARBgAFqJAALggEBAn8jAEEQayICJAAgAEEAENgtIAJBCGogAUEIaigCACIDNgIAIAIgASkCADcDAAJAIANBAXENAANAIAIQ7hIiAUHcAEcgAUEvR3ENASAAKAIIIQMgAEEBENgtIAAoAgQgACgCCGogAToAACAAIANBAWo2AggMAAsACyACQRBqJAALgwEBA38jAEEQayICJAAgACgCDCIDIAAoAgQiAUcEQCADIAFrQQR2IQMDQCABQQxqIAFBBGooAgAgAUEIaigCACABKAIAKAIQEQEAIAFBEGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEEQRAQ4B4gAkEQaiQAC3cBAn8gACgCWEGAgICAeEcEQCAAKAJgIgJBA3YgAkEHcUEAR2oiAkEgIAAoAkgiAEEBayIBQQAgACABTxtnIgBrIgFBA3YgAUEHcUEAR2pBAWpsIgEgAkEhIABrbCIAIAAgAUkbDwsgACgCaCAAKAJsKAIUEQQAC3cBAn8gACgCaEGAgICAeEcEQCAAKAJwIgJBA3YgAkEHcUEAR2oiAkEgIAAoAlgiAEEBayIBQQAgACABTxtnIgBrIgFBA3YgAUEHcUEAR2pBAWpsIgEgAkEhIABrbCIAIAAgAUkbDwsgACgCeCAAKAJ8KAIUEQQAC3oBAn8gACgCeEGAgICAeEcEQCAAKAKAASICQQN2IAJBB3FBAEdqIgJBICAAKAJoIgBBAWsiAUEAIAAgAU8bZyIAayIBQQN2IAFBB3FBAEdqQQFqbCIBIAJBISAAa2wiACAAIAFJGw8LIAAoAogBIAAoAowBKAIUEQQAC4YBAQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQgAygCBEEBRwRAIAMoAgwhBSACBEAgBSABIAL8CgAACyADIAI2AgwgAyAFNgIIIAMgBDYCBCAAQQRqIANBBGoQ5xUgAEEINgIAIANBEGokAA8LIAQgAygCDEGch84AEP0vAAt/AgJ/AX4jAEEgayICJAAgAkEIaiABEMsTQQEhAQJ/IAIoAghBAUYEQCACKQMYIQQgAigCDCEDIAAgAikDEDcDCCAAIAM2AgRBEAwBCyACKQMQIgRCAYhCACAEQgGDfYUhBEEAIQFBCAsgAGogBDcDACAAIAE2AgAgAkEgaiQAC4EBAgN/AX4gASgCHCEDIAFBADYCHCABIAEoAhggA0EDdmogA0EHcUEAR2oiAzYCGAJAIAAgAiADaiIFIAEoAggiBE0EfiADIARLDQEgACACIAEoAgQgA2ogBCADaxDZIjcDCCABIAU2AhhCAQUgBgs3AwAPCyADIARB6LrOABCvOwALhwEBAX8jAEEgayIFJAACQCADIARxIgMgAk0EQCABIANqIAIgA2sQtx4iASAAKAIEIgJJDQEgASACQbTNzgAQwyEACyAFQQA2AhggBUEBNgIMIAVBmNfOADYCCCAFQgQ3AhAgBUEIakGkzc4AEO8sAAsgACgCACABQQJ0aiAENgIAIAVBIGokAAvNBQIMfwF+IwBBMGsiASQAAn8gACgCACICRQRAQQAhAEEADAELIAEgAjYCGCABQQA2AhQgASACNgIIIAFBADYCBCABIAAoAgQiAjYCHCABIAI2AgwgACgCCCEAQQELIQIgASAANgIgIAEgAjYCECABIAI2AgADQCABQSRqIQojAEEQayIFJAACQCABKAIgIgBFBEAgASgCACABQQA2AgBBAXEEQCABKAIMIQAgASgCCCECAkAgASgCBCIEBEAgBSACNgIIIAUgBDYCBAwBCyAABEADQCACKAIUIQIgAEEBayIADQALC0EAIQAgBUEANgIIIAUgAjYCBAsgBSAANgIMIwBBEGsiACQAIABBBGogBUEEaiICKAIAIAIoAgQQ8CYDQCAAKAIEIgIEQCAAQQRqIAIgACgCCBDwJgwBCwsgAEEQaiQACyAKQQA2AgAMAQsgASAAQQFrNgIgIAEQzSMiCARAIwBBMGsiAyQAIANBCGohBiMAQRBrIgkkACAIKAIEIQACQAJAIAgoAggiCyAIKAIAIgQvAQZPBEADQCAJQQRqIAQgABDwJiAJKAIEIgRFDQIgCSgCCCEAIAkoAgwiCyAELwEGTw0ACwsgC0EBaiEHAkAgAEUEQCAEIQIMAQsgBCAHQQJ0akEUaiEHIAAhDANAIAcoAgAiAkEUaiEHIAxBAWsiDA0AC0EAIQcLIAYgCzYCFCAGIAA2AhAgBiAENgIMIAYgBzYCCCAGQQA2AgQgBiACNgIADAELIAZBADYCAAsgCUEQaiQAIAMoAggEQCAKIAMpAhQ3AgAgA0EoaiADQRBqKAIAIgA2AgAgCkEIaiADQRxqKAIANgIAIAMgAykCCCINNwMgIAhBCGogADYCACAIIA03AgAgA0EwaiQADAILQdy4zQAQsjsAC0G44NAAELI7AAsgBUEQaiQAIAEoAiQNAAsgAUEwaiQAC3sBAX8gASgCACICBEAgACACNgIACyABKAIIIgIEQCAAIAI2AggLIAEoAgQiAgRAIAAgAjYCBAsgASgCDCICBEAgACACNgIMCyABKAIQIgIEQCAAIAI2AhALIAEoAhQiAgRAIAAgAjYCFAsgASgCGCIBBEAgACABNgIYCwuWAQEGfwJAIAAoApjrAUUNACAAKAKo6wEiAiAAKALc6QEiAxCzKSEBIAIoAgRBAWshBANAIAMgAigCACABIgVBAnRqKAIAEI42IgZHBEAgASAEcUEBaiEBIAYNAQsLIAIoAgAgBUECdGooAgAiAUUNACAAEPwwIABBfzYCpOsBIAAgATYCmOsBIAAgACgC3OkBNgKc6wELC4cBAQN/AkACQCACQQFrIgIgAUsEQEHABSABIAFBwAVNGyEEA0AgASAERg0CIAJBwAVPDQMgACABaiIDLQAAIQUgAyAAIAJqIgMtAAA6AAAgAyAFOgAAIAFBAWoiASACQQFrIgJJDQALCw8LIARBwAVB8JPSABDDIQALIAJBwAVB8JPSABDDIQALVgECfwJAIAIEQANAIAEgCEYNAiAAIAhqLQAAIQkgAyAJai0AACAEIAlBAXRqMwEAIAUgBiAHEN8TIAIgCEEBaiIIRw0ACwsPCyABIAFBtJbzABDDIQALmQEBAX8jAEEgayICJAAgAkEANgIIIAJCgICAgBA3AgAgAkH4qP4ANgIQIAJCoICAgA43AhQgAiACNgIMIAFBDGogAkEMahDQFgRAQaCp/gBBNyACQR9qQZCp/gBB2Kn+ABDVHgALIAAgAikCADcCBCAAQQxqIAJBCGooAgA2AgAgAEEBNgIAIABBAToAECABEN47IAJBIGokAAuEAQEBfyAAEMAMIABBDGoQwAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQuyMLC+gFAQp/IwBBMGsiAyQAIANBBTYCDCADQZDVhQE2AgggA0ECNgIUIANB3NqFATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCgJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAhxBA3YiC0EBayIHRQ0AQQogByAHQQpPGyEGAkADQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIEZIAIgAigCFCIJNgIgIAIgAigCECIFNgIcIAUgCSgCCEEBa0F4cWpBCGogASAJKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAHQQtJDQEgB0EVTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAtBFWs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyALQQtrIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEEIEZIAIgAigCDCIFNgIgIAIgAigCCCIGNgIcIAYgBSgCCEEBa0F4cWpBCGogASAFKAIMEQIAIAYgBigCACIGQQFrNgIAIAZBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQgMAQtBACEICyACQUBrJAAgCA0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCgsgA0EwaiQAIAoLhwEBAn8jAEHQAGsiBSQAIAVBBGoiBiABIAIgAyAEEOUPIAUoAgRBgICAgHhHBEAgACAGQTT8CgAAIAVB0ABqJAAPCyAFQcgAaiAFQRhqKAIANgIAIAVBQGsgBUEQaikCADcDACAFIAUpAgg3AzhBgOuFAUErIAVBOGpB8OqFAUH88YUBENUeAAvpBQEKfyMAQTBrIgMkACADQQU2AgwgA0HUj4YBNgIIIANBAjYCFCADQfSWhgE2AhAgA0IBNwIcIANBxwI2AiwgAyADQShqNgIYIAMgA0EIajYCKEEBIQsCQCABKAIAIAEoAgQgA0EQahDLCg0AIwBBQGoiAiQAAkACQCAAKAIoIgVBCEkNAEEKIAVBA3YiByAHQQpPGyEGAkADQAJAIAAgBBCXJUUEQEEBIQkgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEELMZIAIgAigCFCIKNgIgIAIgAigCECIINgIcIAggCigCCEEBa0F4cWpBCGogASAKKAIMEQIAIAggCCgCACIIQQFrNgIAIAhBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAFQdgASQ0BIAVBqAFPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgB0EUazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAdBCmsiBCAGIAQgBksbIgQgB08NAQNAAkAgACAEEJclRQRAQQEhCSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQsxkgAiACKAIMIgY2AiAgAiACKAIIIgU2AhwgBSAGKAIIQQFrQXhxakEIaiABIAYoAgwRAgAgBSAFKAIAIgVBAWs2AgAgBUEBRgRAIAJBHGoQuyMLDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBEEBaiIEIAdHDQALDAELQQEhCQwBC0EAIQkLIAJBQGskACAJDQAgASgCAEGUkIYBQQEgASgCBCgCDBEGACELCyADQTBqJAAgCwuLAQECfyMAQeAAayICJAAgAUEBOgBZIAJBBGoiAyABEN8HIAIoAgRBgICAgHhHBEAgACADQcQA/AoAACACQeAAaiQADwsgAkHYAGogAkEYaigCADYCACACQdAAaiACQRBqKQIANwMAIAIgAikCCDcDSEHo2oYBQSsgAkHIAGpBlNuGAUG8hIcBENUeAAumAQIBfwJ+IwBBEGsiAyQAAn5B+POKASgCAEEBRgRAQYj0igEpAwAhBEGA9IoBKQMADAELIAMQ4yZB+POKAUIBNwMAQYj0igEgAykDCCIENwMAIAMpAwALIQUgACACNgIEIAAgATYCACAAIAQ3AyAgACAFNwMYQYD0igEgBUIBfDcDACAAQejchwEpAwA3AwggAEEQakHw3IcBKQMANwMAIANBEGokAAt+AQN/AkACQCAAKAIAIgIgASgCACIDRg0AIAAoAgQiBCABKAIERw0BIARFDQAgAkEIaiEBIANBCGohAANAIAEoAgAiAiAAKAIAIgNHBEAgAkEIaiADQQhqEPEKRQ0DCyABQQRqIQEgAEEEaiEAIARBAWsiBA0ACwtBAQ8LQQALfwEEfyMAQRBrIgIkACAAKAIMIgQgACgCBCIBa0HIAG4hAyABIARHBEADQCABQTRqQQFBARDgHiABQShqENMMIAEQkycgAUHIAGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIakEIQcgAEOAeIAJBEGokAAuHAQEBfyMAQUBqIgMkACADIAI2AgQgAyABNgIAIANBKGogAEEIaikDADcDACADIAApAwA3AyAgA0ECNgIMIANB1LCIATYCCCADQgI3AhQgA0HKATYCPCADQegdNgI0IAMgA0EwajYCECADIAM2AjggAyADQSBqNgIwIANBCGoQgRcgA0FAayQAC3MBA38jAEGAAWsiBCQAIAAoAgAhAANAIAIgBGpB/wBqIABBD3EiA0EwciADQdcAaiADQQpJGzoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQeDziQFBAiACIARqQYABakEAIAJrEIEJIARBgAFqJAALcgEDfyMAQYABayIEJAAgACgCACEAA0AgAiAEakH/AGogAEEPcSIDQTByIANBN2ogA0EKSRs6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUHg84kBQQIgAiAEakGAAWpBACACaxCBCSAEQYABaiQAC34BAX8gAEEoaiIBEPcdIAEQ8TsgAEE0aiIBEPQbIAEQ7zsgAEFAaxCHMCAAKAJMQYCAgIB4RwRAIABBzABqEN47CyAAKAJYQYCAgIB4RwRAIABB2ABqEOs7CyAAKAIAQQJHBEAgAEEEahCGMCAAQRBqEIYwCyAAQeQAahCGMAuAAQEEfyMAQRBrIgIkACAAKAIMIgMgACgCBCIBRwRAIAMgAWtBAnYhAwNAIAEoAgAiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAEQ8iULIAFBBGohASADQQFrIgMNAAsLIAIgACgCADYCDCACIAAoAgg2AgggAkEIahDpOyACQRBqJAALgQEBAX8jAEHAAmsiAiQAIAJBCGogABCVGkEAIQACQAJAAkAgAQ4CAgEAC0HkgsMAQRkQlz0AC0EBIQALIAIvAZ4BIQEgAkGoAWogAkEIakGVAfwKAAAgAiABOwG+AiACIAA6AL0CIAJBADYCoAEgAkGgAWoQ0SlBCGogAkHAAmokAAv/AQIDfwJ+IwBB4AJrIgQkACAEQRBqIgUgABCVGiAEQQhqIAEgAhD6KCAEQagBaiIAIAQoAgggBCgCDBCPNSAEQbQBaiIBIAAQpCggBEHIAWogA0EARyEDIwBBQGoiACQAIAAgBUFAayABEK8QAn8gACgCCCIBQYCAgIB4RwRAIAAoAhQgACkDACAAKQIMIQggAEGChIzIADYCOCAAQQg2AjAgAEEANgIoIABCADcDECAAIAg3AgQgACABNgIAIAAQ2RMMAQsgACgCAAtBCGsgAzoAACAFQZgB/AoAACAAQUBrJAAgBEEANgLAASAEQcABahDRKUEIaiAEQeACaiQAC4UBAQF/IABBKGoiARD3HSABEPE7IABBNGoiARD0GyABEO87IAAoAkBBgICAgHhHBEAgAEFAayIBEOApIAEQ8jsLIABBzABqEIYwIAAoAlhBgICAgHhHBEAgAEHYAGoQ6zsLIAAoAgBBAkcEQCAAQQRqEIYwIABBEGoQhjALIABB5ABqEIYwC4QBAgF/AX4jAEGAAWsiAiQAIAIgARDdAQJAAkAgAikDAEIMfSIDQgFYBEAgA6dBAWsNASAAIAIpAwg3AwggAEIMNwMAIABBGGogAkEYaikDADcDACAAQRBqIAJBEGopAwA3AwAMAgsgACACQYAB/AoAAAwBCyAAQg03AwALIAJBgAFqJAALlgEBAX8CQAJAAkAgAC0AHA4EAAICAQILIAAoAgAiASABKAIAQQFrIgE2AgAgAUUEQCAAENQiCyAAKAIEIgBBhAFJDQEgABDyHw8LAkAgAC0AGA0AIAAoAhQiAUGEAUkNACABEPIfCyAAKAIMIgEgASgCAEEBajYCACAAKAIAIgEgASgCAEEBayIBNgIAIAENACAAENQiCwuQAQEBfyMAQRBrIgIkACACIAFB6OjDAEEOEJYtIAJBiOnDAEEEIAAoAgAiAEHIAGpB+OjDABCIEhogACgCAEECRwRAIAIgACkCFDcCCCACQZzpwwBBAyACQQhqQYzpwwAQiBIaCyAAKAJMBEAgAkGw6cMAQQYgAEHMAGpBoOnDABCIEhoLIAIQxCEgAkEQaiQAC4kBAQF/IwBBMGsiAyQAIAMgACkCGDcCHCADIAI2AhggAyABNgIUIANBCGogA0EUahCIDSADKAIIIgIEQCADKAIMIQEDQCADQcSUxAA2AiwgAyACNgIkIAMgATYCKCAAIANBJGoQrx4gAyADQRRqEIgNIAMoAgQhASADKAIAIgINAAsLIANBMGokAAu1AQACQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDgkBAgMEBQYHCAkACyABQaSVxABBChD7NQ8LIAFBrpXEAEEhEPs1DwsgAUHPlcQAQRMQ+zUPCyABQeKVxABBFBD7NQ8LIAFB9pXEAEEUEPs1DwsgAUGKlsQAQRgQ+zUPCyABQaKWxABBGxD7NQ8LIAFBvZbEAEEpEPs1DwsgAUHmlsQAQTMQ+zUPCyABQZmXxABBJRD7NQuBAQECfyMAQSBrIgIkACAALQBYBEAgACgCICAAKAIkIgFBA3ZqIAFBB3FBAEdqIQEgACgCOEUEQCAAKAJIIgAgASAAIAFLGyEBCyACQSBqJAAgAQ8LIAJBADYCGCACQQE2AgwgAkHIos0ANgIIIAJCBDcCECACQQhqQdCizQAQ7ywAC4QBAgF/AX4jAEGAAWsiAiQAIAIgARDTAQJAAkAgAikDAEIMfSIDQgFYBEAgA6dBAWsNASAAIAIpAwg3AwggAEIMNwMAIABBGGogAkEYaikDADcDACAAQRBqIAJBEGopAwA3AwAMAgsgACACQYAB/AoAAAwBCyAAQg03AwALIAJBgAFqJAALiwEBAX8jAEEwayIDJAAgAyABIAJBACACQQN0IgEQ0AggAEIANwMYIABCADcDACAAIAMoAiAiAjYCUCAAIAMpAwg3A0ggACADKQMANwNAIAAgAykDGDcDOCAAIAMpAxA3AzAgACADKAIsIAMoAiggAWpqNgJYIAAgAiADKAIkQQN0ajYCVCADQTBqJAALeAECfyAAIAEoAgwiAgR+IAEgAkEBazYCDCAAIAEoAgQgASgCCCIDQRhsaiICKQMANwMIIAEgA0EBaiIDIAEoAgAiAUEAIAEgA00bazYCCCAAQRBqIAJBCGopAwA3AwAgAEEYaiACQRBqKQMANwMAQgEFQgALNwMAC94CAQl/IwBBIGsiAyQAIAMgAjcDACACUARAIANBCGohByMAQRBrIgQkACABKAIEIQUgBCABKAIIIglBAEEEQRAQoBggBCgCBCEBAkAgBCgCAEEBRwRAIAQoAgghCgJAIAFFDQAgCUEEdCEIIAohBiABIQsDQCAIRQ0BIAQgBUEMaiAFKAIEIAUoAgggBSgCACgCABEFACAGQQhqIARBCGopAgA3AgAgBiAEKQIANwIAIAZBEGohBiAIQRBrIQggBUEQaiEFIAtBAWsiCw0ACwsgByAJNgIIIAcgCjYCBCAHIAE2AgAgBEEQaiQADAELIAEgBCgCCEHomc8AEP0vAAsgAygCECEGIAMoAgwhASAAIAMoAgg2AiAgACABNgIcIAAgATYCGCAAQgA3AwAgACABIAZBBHRqNgIkIANBIGokAA8LIANBADYCCCADQeDozwAgA0EIakH46M8AEK4rAAtjAQF/IwBBIGsiAiQAIAFBADYCJAJAIAEoAgBBgICAgHhGBEAgAkEMaiABQQRqEP4TDAELIAJBDGogAUEMahD+EwsgAEEIaiACQRRqKAIANgIAIAAgAikCDDcCACACQSBqJAALdgEBfyABIANHBEBBAA8LAkAgAUUEQEEBIQAMAQsgAEEIaiEDIAJBCGohAiABQQFrIQEDQCADQQRrKAIAIAMoAgAgAkEEaygCACACKAIAEMEuIgBFDQEgAUEARyADQQxqIQMgAkEMaiECIAFBAWshAQ0ACwsgAAuGAQEBfwJAAkAgAUEETwRAIAAgACkCADcCBCABQQNrIQEMAQsCfwJAAkAgASACakEBayICDgQEAQEAAQsgACgCACIDQQFrDAELIAAoAgAhAyAAIAJBAnRqKAIACyEBIABBCEEEIAJBAUYbaigCACECIAAgAzYCBCAAIAI2AggLIAAgATYCAAsLfAEDf0G6fyEFIAEgA0H/H0tBAkEBIANBH0sbaiIEIANqIgZPBH8CQAJAAkACQCAEQQJrDgIBAgALIAAgA0EDdDoAAAwCCyAAIANBBHRBBHI7AAAMAQsgACADQQR0QQxyNgAACyADBEAgACAEaiACIAP8CgAACyAGBSAFCwuGAQIBfwJ+IwBBIGsiAyQAIANCADcDACABQQdNBEAgA0EANgIYIANBATYCDCADQcyP8wA2AgggA0IENwIQIANBCGpBxJzzABDvLAALIANBCCAAQQhB1JzzABDVLCADNQIAIQQgAzEABCADQSBqJABCOIYgBEIYhoRCvc/W8QF+IAJBP3GtiKcLhwEBA38jAEEQayIFJAAgBUEEaiACQQBBAUEBEKAYIAUoAgghBiAFKAIEQQFHBEAgBSgCDCEHIAIEQCAHIAEgAvwKAAALIAAgAzoAECAAIAI2AgggACAHNgIEIAAgBjYCACAAIAQ7AQ4gAEEBOwEMIAVBEGokAA8LIAYgBSgCDEG0pf4AEP0vAAuLAQIBfwF+IwBBIGsiAyQAIANBCDsBBiADQQhqIAEgAiADQQZqEJUDQQEhAQJAIAMoAghBAUYEQCADKAIMIQIgAykDECEEIAAgAykDGDcDECAAIAQ3AwggACACNgIEDAELIAMpAxghBCAAIAMpAxA3AxAgACAENwMIQQAhAQsgACABNgIAIANBIGokAAt8AgN/AX4jAEEgayIDJAAgA0EIaiIEIAEgAhCBBAJAIAMoAggiBUEBRgRAIAUEQCAEQQRyEIgRCyADQQhqIAEgAhCbCiAAIAMtAAgEfiAGBSAAIAMpAxA3AwhCAQs3AwAMAQsgACADKQMQNwMIIABCATcDAAsgA0EgaiQAC50EAgp/AX4jAEEQayIIJAACQCACRQ0AIAEgAmpBAWsiA0UNACADLQAAQTBrQf8BcUEJSw0AIAhBBGohCiMAQSBrIgckAAJAAkAgAiIDRQ0AIAEtAAAiBEErRiIGIARBLUYiBXIhBCAFRQRAQQEhBSADIARGDQFBCkEJIAYbIgUgAyADIAVLGyEFA0ACQCADIARHBEAgB0EYaiABIARqLQAAEI0vIAcoAhhBAXENASAEIQUMBAsgAyADQbDzgAEQwyEACyAHKAIcIAlBCmxqIQkgBEEBaiIEIAVHDQALDAELIAMgBEYEQEEBIQZBASEDDAILQQEhBgNAIAdBEGogASAEai0AABCNLyAHKAIQQQFxRQRAIAQhAwwDCyAGIAcoAhRFcSEGIARBAWoiBCADRw0ACwwBCyADIAVGBEBBASEGDAELIAUgAyADIAVJGyELQQEhBgNAAkAgBSALRwRAIAdBCGogASAFai0AABCNLyAHKAIIQQFxDQEgBSEDDAMLIAsgA0HA84ABEMMhAAsgBiEEQQAhBgJAIARFDQAgCa1CCn4iDUIgiKcNACANpyIEIAcoAgxqIgkgBE8hBgsgAyAFQQFqIgVHDQALCyAKIAM2AgggCiAJNgIEIAogBjYCACAHQSBqJAAgCCgCBCIDQQFHDQAgCCgCDCACRw0AIAgoAgghASADIQwLIAAgATYCBCAAIAw2AgAgCEEQaiQAC6EEAQl/IwBBEGsiByQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAHQQhqIQlBACEDIwBBIGsiBSQAAkACQAJAAkACQCACRQ0AIAEtAAAiA0ErRiADQS1GIgRyIQMCQCAERQRAIAIgA0YEQEEBIQMMAwsgA0EEciIEIAIgAiAESxshBANAIAIgA0YNAiAFQRhqIAEgA2otAAAQji8gBS8BGEEBcUUNAyAFLwEaIAZBCmxqIQYgBCADQQFqIgNHDQALIAQhAwwCC0EBIQQgAiADRgRAQQEhAwwECwNAIAVBEGogASADai0AABCOLyAFLwEQQQFxRQ0EIAQgBS8BEkVxIQQgA0EBaiIDIAJHDQALDAILIAIgAkGw84ABEMMhAAtBASEEIAIgA0YNACADIAIgAiADSRshCgNAIAMgCkYNAyAFQQhqIAEgA2otAAAQji8gBS8BCEEBcUUNAiAEIQhBACEEAkAgCEUNACAGQf//A3FBCmwiCEEQdg0AIAUvAQoiBiAIQf//A3FqIgRB//8DcSAERiEEIAYgCGohBgsgAiADQQFqIgNHDQALCyACIQMLIAkgAzYCBCAJIAY7AQIgCSAEOwEAIAVBIGokAAwBCyAKIAJBwPOAARDDIQALIAcvAQgiA0EBRw0AIAcoAgwgAkcNACAHLwEKIQEgAyELCyAAIAE7AQIgACALOwEAIAdBEGokAAvcBQIJfwF+IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQRqIQpBACEDIwBBIGsiBiQAAkACQAJAAkACQCACRQ0AIAEtAAAiA0ErRiIFIANBLUYiA3IhBAJAIAMEQEEBIQVBASEDIAIgBEYNAUEKIAIgAkEKTxshAwNAAkAgAiAERwRAIAZBEGogASAEai0AABCNLyAGKAIQQQFxDQEgBCEDDAQLIAIgAkHQ84ABEMMhAAsgB0EKbCAGKAIUayEHIAMgBEEBaiIERw0ACwwBC0EBIQMgAiAERg0BQQpBCSAFGyIDIAIgAiADSxshAwNAAkAgAiAERwRAIAZBGGogASAEai0AABCNLyAGKAIYQQFxDQEgBCEDDAQLIAIgAkGw84ABEMMhAAsgBigCHCAHQQpsaiEHIARBAWoiBCADRw0ACwwBCyACIANGDQEgAyACIAIgA0kbIQkDQCADIAlHBEAgBkEIaiABIANqLQAAEI0vIAYoAghBAXFFDQQgBSEEQQAhBQJAIARFDQAgB6xCCn4iDEIgiKcgDKciBEEfdUcNACAGKAIMIgVBAEogBCAFayIHIARIc0UhBQsgAiADQQFqIgNHDQEMAwsLIAkgAkHg84ABEMMhAAtBASEFIAIgA0YNACADIAIgAiADSRshCQNAIAMgCUYNAyAGIAEgA2otAAAQjS8gBigCAEEBcUUNAiAFIQRBACEFAkAgBEUNACAHrEIKfiIMQiCIpyAMpyIEQR91Rw0AIAYoAgQiBUEASCAEIAVqIgcgBEhzRSEFCyACIANBAWoiA0cNAAsLIAIhAwsgCiADNgIIIAogBzYCBCAKIAU2AgAgBkEgaiQADAELIAkgAkHA84ABEMMhAAsgCCgCBCIDQQFHDQAgCCgCDCACRw0AIAgoAgghASADIQsLIAAgATYCBCAAIAs2AgAgCEEQaiQAC7gFAQp/IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQhqIQojAEEgayIFJAACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIDciEEAkAgAwRAQQEhB0EBIQMgAiAERg0BQQUgAiACQQVPGyEDA0ACQCACIARHBEAgBUEQaiABIARqLQAAEI4vIAUvARBBAXENASAEIQMMBAsgAiACQdDzgAEQwyEACyAGQQpsIAUvARJrIQYgAyAEQQFqIgRHDQALDAELIAIgBEYEQEEBIQQMAgsgBEEEciIDIAIgAiADSxshAwJAA0AgAiAERg0BIAVBGGogASAEai0AABCOLyAFLwEYQQFxRQ0DIAUvARogBkEKbGohBiADIARBAWoiBEcNAAsgAyEEDAILIAIgAkGw84ABEMMhAAsgAiADRg0BIAMgAiACIANJGyEJA0AgAyAJRwRAIAVBCGogASADai0AABCOLyAFLwEIQQFxRQ0EIAchBEEAIQcCQCAERQ0AIAbBQQpsIgvBIgQgC0cNACAEIAUvAQrBayIGwSAGRiEHCyACIANBAWoiA0cNAQwDCwsgCSACQeDzgAEQwyEAC0EBIQcgAiAERg0AIAQgAiACIARJGyEJA0ACQCAEIAlHBEAgBSABIARqLQAAEI4vIAUvAQBBAXENASAEIQMMBAsgCSACQcDzgAEQwyEACyAHIQNBACEHAkAgA0UNACAGwUEKbCILwSIDIAtHDQAgAyAFLwECwWoiBsEgBkYhBwsgAiAEQQFqIgRHDQALCyACIQMLIAogAzYCBCAKIAY7AQIgCiAHOwEAIAVBIGokACAILwEIIgNBAUcNACAIKAIMIAJHDQAgCC8BCiEBIAMhDAsgACABOwECIAAgDDsBACAIQRBqJAALwQYBCH8jAEHgAGsiBiQAIAZBDGohByMAQeAAayIEJAAgBCABKAIIQQJ2QQFrIgs2AgAgBEEgaiEIIwBBMGsiBSQAAkACQCABKAIIIglBBEkNACABKAIEIAlBfHFqQQRrIgpFDQAgAigCCCEJIAUgCigCACIKNgIAIAggCSAKSQR/IAUgCTYCHCAFQQI2AgggBUGA0YABNgIEIAVCAjcCECAFQTs2AiwgBUE7NgIkIAUgBUEgajYCDCAFIAVBHGo2AiggBSAFNgIgIAhBBGogBUEEahCZDkGNgICAeAVBk4CAgHgLNgIAIAVBMGokAAwBC0G80IABELI7AAsCQAJAAkAgBCgCICIFQZOAgIB4RgRAAkAgAygCACIFBEAgCyADKAIQIghHDQELIARBKGpBlKjQoAE2AgAgBEE0aiABQQhqKAIANgIAIARBQGsgAkEIaigCADYCACAEQcwAaiADQQhqKQIANwIAIARB1ABqIANBEGopAgA3AgAgBEKUqNCgwYKFihQ3AyAgBCABKQIANwIsIAQgAikCADcDOCAEIAMpAgA3AkQgByAEQSBqQTz8CgAADAQLIAQgCDYCHCAEQQQ2AgggBEGM94ABNgIEIARCBDcCECAEQTs2AjwgBEE7NgI0IARBzAE2AiwgBEG894ABNgIoIARBzAE2AiQgBEGs94ABNgIgIAQgBEEgajYCDCAEIARBHGo2AjggBCAENgIwIAdBCGogBEEEahCZDiAHQSk6AAAgB0GNgICAeDYCBAwBCyAHIAQpAiQ3AgggB0EQaiAEQSxqKQIANwIAIAdBKToAACAHIAU2AgQgAygCACIFRQ0BCyAFIAUoAgAiBUEBazYCACAFQQFHDQAgAxD7HgsgAigCACIDIAMoAgAiA0EBazYCACADQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgBEHgAGokACAGLQAMQSlHBEAgACAHQTz8CgAAIAZB4ABqJAAPCyAGQdgAaiAGQSBqKAIANgIAIAZB0ABqIAZBGGopAgA3AwAgBiAGKQIQNwNIQez4gAFBKyAGQcgAakHc+IABQaD2gAEQ1R4AC78GAQh/IwBB4ABrIgYkACAGQQxqIQcjAEHgAGsiBCQAIAQgASgCCEEDdkEBayIKNgIAIARBIGohCSMAQTBrIgUkAAJAAkAgASgCCCIIQQhJDQAgASgCBCAIQXhxakEIayIIRQ0AIAUgCCgCACIINgIAIAkgCCACKAIIIgtLBH8gBSALNgIcIAVBAjYCCCAFQYDRgAE2AgQgBUICNwIQIAVBOzYCLCAFQTs2AiQgBSAFQSBqNgIMIAUgBUEcajYCKCAFIAU2AiAgCUEEaiAFQQRqEJkOQY2AgIB4BUGTgICAeAs2AgAgBUEwaiQADAELQbzQgAEQsjsACwJAAkACQCAEKAIgIgVBk4CAgHhGBEACQCADKAIAIgUEQCAKIAMoAhAiCUcNAQsgBEEoakGWrNiwATYCACAEQTRqIAFBCGooAgA2AgAgBEFAayACQQhqKAIANgIAIARBzABqIANBCGopAgA3AgAgBEHUAGogA0EQaikCADcCACAEQpas2LDhwoWLFjcDICAEIAEpAgA3AiwgBCACKQIANwM4IAQgAykCADcCRCAHIARBIGpBPPwKAAAMBAsgBCAJNgIcIARBBDYCCCAEQYz3gAE2AgQgBEIENwIQIARBOzYCPCAEQTs2AjQgBEHMATYCLCAEQbz3gAE2AiggBEHMATYCJCAEQbj2gAE2AiAgBCAEQSBqNgIMIAQgBEEcajYCOCAEIAQ2AjAgB0EIaiAEQQRqEJkOIAdBKToAACAHQY2AgIB4NgIEDAELIAcgBCkCJDcCCCAHQRBqIARBLGopAgA3AgAgB0EpOgAAIAcgBTYCBCADKAIAIgVFDQELIAUgBSgCACIFQQFrNgIAIAVBAUcNACADEPseCyACKAIAIgMgAygCACIDQQFrNgIAIANBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyAEQeAAaiQAIAYtAAxBKUcEQCAAIAdBPPwKAAAgBkHgAGokAA8LIAZB2ABqIAZBIGooAgA2AgAgBkHQAGogBkEYaikCADcDACAGIAYpAhA3A0hB7PiAAUErIAZByABqQdz4gAFBoPaAARDVHgALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ7CNFBEAgAUEoakG0yIQBKAIANgIAIAFBrMiEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEO0jRQRAIAFBKGpBiMmEASgCADYCACABQYDJhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDuI0UEQCABQShqQZTJhAEoAgA2AgAgAUGMyYQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ7yNFBEAgAUEoakGsyYQBKAIANgIAIAFBpMmEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPAjRQRAIAFBKGpB0MmEASgCADYCACABQcjJhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDxI0UEQCABQShqQfTJhAEoAgA2AgAgAUHsyYQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ8iNFBEAgAUEoakGMyoQBKAIANgIAIAFBhMqEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPMjRQRAIAFBKGpBmMqEASgCADYCACABQZDKhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABD0I0UEQCABQShqQbDKhAEoAgA2AgAgAUGoyoQBKQIANwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQ9SNFBEAgAUEoakG8yoQBKAIANgIAIAFBtMqEASkCADcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEPYjRQRAIAFBKGpB1MqEASgCADYCACABQczKhAEpAgA3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuFAQECfyMAQRBrIgQkAAJAIAJBAE4EQCADQQBIDQEgBEEEaiIFIAEgAkEBdCADQQF0EOYVIAAgBRDhGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAuNAQECfyMAQRBrIgQkAAJAIAJBgICAgAFJBEAgA0GAgICAAU8NASAEQQRqIgUgASACQQR0IANBBHQQ5hUgACAFEOIZIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIARBEGokAA8LQaTjhQFBD0G044UBEMskAAtBxOOFAUEPQdTjhQEQyyQAC40BAQJ/IwBBEGsiBCQAAkAgAkGAgICAAkkEQCADQYCAgIACTw0BIARBBGoiBSABIAJBA3QgA0EDdBDmFSAAIAUQ5BkgASgCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgARD7HgsgBEEQaiQADwtBpOOFAUEPQbTjhQEQyyQAC0HE44UBQQ9B1OOFARDLJAALjQEBAn8jAEEQayIEJAACQCACQYCAgMAASQRAIANBgICAwABPDQEgBEEEaiIFIAEgAkEFdCADQQV0EOYVIAAgBRDiGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAuNAQECfyMAQRBrIgQkAAJAIAJBgICAgARJBEAgA0GAgICABE8NASAEQQRqIgUgASACQQJ0IANBAnQQ5hUgACAFEOUZIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIARBEGokAA8LQaTjhQFBD0G044UBEMskAAtBxOOFAUEPQdTjhQEQyyQAC40BAQJ/IwBBEGsiBCQAAkAgAkGAgICAAUkEQCADQYCAgIABTw0BIARBBGoiBSABIAJBBHQgA0EEdBDmFSAAIAUQ5BkgASgCACIAIAAoAgAiAEEBazYCACAAQQFGBEAgARD7HgsgBEEQaiQADwtBpOOFAUEPQbTjhQEQyyQAC0HE44UBQQ9B1OOFARDLJAALjQEBAn8jAEEQayIEJAACQCACQYCAgIACSQRAIANBgICAgAJPDQEgBEEEaiIFIAEgAkEDdCADQQN0EOYVIAAgBRDlGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAAPC0Gk44UBQQ9BtOOFARDLJAALQcTjhQFBD0HU44UBEMskAAt0AQR/IAAoAggiAiEDQQFBAiABQTBqwCIBQQBOIgUbIgQgACgCACACa0sEfyAAIAIgBBDbKCAAKAIIBSADCyAAKAIEaiIDIAUEfyABBSADIAFBvwFxOgABIAFBwAFxQQZ2QUByCzoAACAAIAIgBGo2AghBAAuEAQEDfyAALQA8QRVGBEACQCAAKAIMIgIgACgCQCABbCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDeKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMDwtBnKGHAUEoQeShhwEQnykAC7UBAQN/IwBBEGsiASQAIAEgAEEIajYCDCABIAAoAgQiAjYCCCABIAAoAgAiADYCBCACBEAgAEEIaiEAA0AgACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABDyJQsgAEEEaiEAIAJBAWsiAg0ACwsCQCABQQRqIgIoAgAiAEF/Rg0AIAAgACgCBCIDQQFrNgIEIANBAUcNACAAIAIoAgRBAnRBC2pBfHFBBBD4OgsgAUEQaiQAC7UBAQN/IwBBEGsiASQAIAEgAEEIajYCDCABIAAoAgQiAjYCCCABIAAoAgAiADYCBCACBEAgAEEMaiEAA0AgACgCACIDIAMoAgAiA0EBazYCACADQQFGBEAgABDyJQsgAEEIaiEAIAJBAWsiAg0ACwsCQCABQQRqIgIoAgAiAEF/Rg0AIAAgACgCBCIDQQFrNgIEIANBAUcNACAAIAIoAgRBA3RBC2pBeHFBBBD4OgsgAUEQaiQAC38BAX8CQCADIARqIgVBA3YgBUEHcUEAR2ogAkEDdE0EQCACIANBA3YiBUkNASAAIARBP3E2AhAgACAEQQZ2NgIMIAAgA0EHcTYCCCAAIAIgBWs2AgQgACABIAVqNgIADwtB3PmHAUE7QZj6hwEQnykACyAFIAJBqPqHARCvOwALhAEBA38jAEEQayICJAAgAkEEahDrOgJAQRhBBBCtNiIBBEAgAUKBgICAEDcCACABIAIpAgQ3AgggAUEAOgAUIAFBEGogAkEMaigCADYCACABIAEoAgAiA0EBajYCACADQQBIDQEgACABNgIEIAAgATYCACACQRBqJAAPC0EEQRgQoz0LAAuDAQEFfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEEQQQQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAUECdCIGBEAgBCAFIAb8CgAACyAAIAE2AgggACAENgIEIAAgAzYCACACQRBqJAAPCyADIAIoAgxB4LXCABD9LwALkAEBBX8gASgCxAEhAyAAKAIEIgQoAsgBIQUgACgCACgCCCEGIAFBADYCxAEgASgCwAEhAiABIAZBCGo2AsABAkACQAJAAkAgAgRAIAIgAzYCxAEgA0UNAQwCCyADDQEgAEEANgIEDAMLIAAgAjYCBCACIQQMAQsgAyACNgLAAQsgBCAFQQFrNgLIAQsgAUEIawuIAQEFfyABKAJcIQMgACgCBCIEKAJgIQUgACgCACgCCCEGIAFBADYCXCABKAJYIQIgASAGQQhqNgJYAkACQAJAAkAgAgRAIAIgAzYCXCADRQ0BDAILIAMNASAAQQA2AgQMAwsgACACNgIEIAIhBAwBCyADIAI2AlgLIAQgBUEBazYCYAsgAUEIawuIAQEFfyABKAI8IQMgACgCBCIEKAJAIQUgACgCACgCCCEGIAFBADYCPCABKAI4IQIgASAGQQhqNgI4AkACQAJAAkAgAgRAIAIgAzYCPCADRQ0BDAILIAMNASAAQQA2AgQMAwsgACACNgIEIAIhBAwBCyADIAI2AjgLIAQgBUEBazYCQAsgAUEIawuCAQEFf0EBIQQCQCAAKAIMIgIgACgCCCIDKAIIIgBGDQAgAiAAayEFIAMoAgQgAGohAiABKAIEIQYgASgCACEAA0AgACAGRyIERQ0BIAIgAC0AADoAACABIABBAWoiADYCACADIAMoAghBAWo2AgggAkEBaiECIAVBAWsiBQ0ACwsgBAv9BgIEfg5/IwBBQGoiCCQAIAggATYCBCAIQQhqIhAgCEEEaiIBEK08IAggARDfPTYCOCAIQQA2AjQgCCABNgIwIAggCEE/ajYCLCAIQSBqIQ0jAEEgayIBJAAgAUEUaiAIQSxqIg4iBygCDCIGIAcoAghrIgpBACAGIApPG0EAQRBBIBCgGCABKAIYIQYgASgCFEEBRgRAIAYgASgCHEHE0swAEP0vAAsgAUEQaiIRQQA2AgAgASABKAIcNgIMIAEgBjYCCCMAQRBrIgokACABQQhqIgYgBygCDCILIAcoAghrIglBACAJIAtNGxDvLSAKIAYpAgRCIIk3AgggCiAGQQhqNgIEIwBB0ABrIgYkACAKQQRqIgwoAgQhCSAMKAIAIAcoAggiCyAHKAIMIg9JBH8gBygCBCESIAkgD2ogC2sgDCgCCCAJQQV0aiEHA0AgBkEIaiASIAsQpioCfiAGKAIMIglFBEBCACEDQgAhBEIAIQVCAAwBCyAGQRBqIgwgBigCCCAJELsQIAZBMGogDBCmKyAGKQNAIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhBCAGKQNIIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhAyAGKQMwIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhBSAGKQM4IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQLIQIgByADNwMAIAdBGGogBTcDACAHQRBqIAI3AwAgByAENwMIIAdBIGohByAPIAtBAWoiC0cNAAsFIAkLNgIAIAZB0ABqJAAgCkEQaiQAIA1BCGogESgCADYCACANIAEpAgg3AgAgAUEgaiQAIA4gDRDtGCAAIA4gEBDOHSAIQUBrJAALmQUCDX8CfiMAQUBqIgIkACACIAE2AgQgAkEIaiINIAJBBGoiARCtPCACIAEQ3z02AjggAkEANgI0IAIgATYCMCACIAJBP2o2AiwgAkEgaiELIwBBIGsiAyQAIANBFGogAkEsaiIEKAIMIgcgBCgCCGsiAUEAIAEgB00bQQBBEEEQEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQcTSzAAQ/S8ACyADQRBqIg5BADYCACADIAMoAhw2AgwgAyABNgIIIwBBEGsiCCQAIANBCGoiCSAEKAIMIgcgBCgCCGsiAUEAIAEgB00bEOstIAggCSkCBEIgiTcCCCAIIAlBCGo2AgQjAEEgayIGJAAgCEEEaiIBKAIEIQUgASgCACAEKAIIIgogBCgCDCIMSQR/IAQoAgQhCSAFIAxqIAprIAEoAgggBUEEdGohBQNAIAZBCGogCSAKEKYqIAUCfiAGKAIMIgFFBEBCACEPQgAMAQsgBkEQaiAGKAIIIAEQuRQgBikDECIPQjiGIA9CgP4Dg0IohoQgD0KAgPwHg0IYhiAPQoCAgPgPg0IIhoSEIA9CCIhCgICA+A+DIA9CGIhCgID8B4OEIA9CKIhCgP4DgyAPQjiIhISEIQ8gBikDGCIQQjiGIBBCgP4Dg0IohoQgEEKAgPwHg0IYhiAQQoCAgPgPg0IIhoSEIBBCCIhCgICA+A+DIBBCGIhCgID8B4OEIBBCKIhCgP4DgyAQQjiIhISECzcDACAFIA83AwggBUEQaiEFIAwgCkEBaiIKRw0ACwUgBQs2AgAgBkEgaiQAIAhBEGokACALQQhqIA4oAgA2AgAgCyADKQIINwIAIANBIGokACAEIAsQ7BggACAEIA0Qyx0gAkFAayQAC/cHAw5/AX4BfSMAQSBrIggkAAJAIAEpAwBCAlIEQCABLQBQRQ0BIAAhDSABIgQoAkQhDiAEKAJIIQwgAiEPIAQoAkwiACADIAAgA0kbIQlBACEAIwBBIGsiBiQAAkACQCADIAlPBEAgCQ0BDAILQYT5zABBLEGw+cwAEJ8pAAsgBEEQaiELA0ACQAJAAkACQAJAAkACQAJAAkACQCAEKAIwRQRAQYAgQQQQrTYiAUUNASABQQBBgCD8CwAgBCABNgIwCyAEKAI0IgcNByAEKAI4IgVFDQYgCygCACIBRQ0FIAtBACABGyEQIAAhAQNAIAkgAWsiACAFIAAgBUkbIgBFDQkgECAEKAIwQYAIIAAgAEGACE8bIhEgBC0APBC5BiICRQRAIARBADYCOAwKCyABIAJqIgAgAkkNAiAAIANLDQMgAkGBCE8NBCAGIAQoAjAiBSACQQJ0ajYCFCAGIAU2AhAgBkEQahCeNiIHBEAgByACIAIgB0sbIQcgDyABQQJ0aiEBA0AgBSgCACIKIAxPDQcgASAOIApBAnRqKgIAOAIAIAFBBGohASAFQQRqIQUgB0EBayIHDQALCyAEIAQoAjggAmsiBTYCOCAAIQEgAiARTw0ACwwJC0EEQYAgEKM9AAsgASAAQdD5zAAQsTsACyAAIANB0PnMABCwOwALIAJBgAhB4PnMABCwOwALIAogDEGg+swAEMMhAAtBnPjMAEEYQcD5zAAQyyQACyALKAIABEAgBiALEKUYIAYoAgBBAUcNBSAGKQMIIhJQDQUgEkIBg1BFBEAgBCASp0ECdEF4cTYCOAwECyAEIBJCAYg+AjQgBkEQaiALIAQtADwiAUEDdiABQQdxQQBHahDBHCAGKQMQIRIgBCAGKQMYNwMIIAQgEjcDACASpw0DQcD6zABBLkHw+swAEJ8pAAtBnPjMAEEYQbD6zAAQyyQACwJAAkAgBCgCAARAIAQoAggiASAMTwRAIAEgDEGA+swAEMMhAAsgByAJIABrIgIgAiAHSxsiCiAAaiICIApJDQEgAiADSw0CIAAgCUcEQCAOIAFBAnRqKgIAIRMgDyAAQQJ0aiEFIApBAnQhAQNAIAUgEzgCACAFQQRqIQUgAUEEayIBDQALCyAEIAcgCms2AjQgAiEADAQLQfD5zAAQsjsACyAAIAJBkPrMABCxOwALIAIgA0GQ+swAELA7AAsgASEACyAAIAlJDQALCyANQQg2AgAgDSAANgIEIAZBIGokACAIQSBqJAAPC0GYoc0AQSxBxKHNABCfKQALIAhBADYCGCAIQQE2AgwgCEHwoc0ANgIIIAhCBDcCECAIQQhqQfihzQAQ7ywAC5cIAg5/AX4jAEEgayIJJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ4gASIEKAJEIQ8gBCgCSCEMIAIhECAEKAJMIgAgAyAAIANJGyEKQQAhACMAQSBrIgYkAAJAAkAgAyAKTwRAIAoNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIFDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshDSAAIQEDQCAKIAFrIgAgBSAAIAVJGyIARQ0JIA0gBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIBAgAUEMbGohAQNAIAUoAgAiCCAMTw0HIAEgDyAIQQxsaiIIKQIANwIAIAFBCGogCEEIaigCADYCACABQQxqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAIIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAUgCiAAayICIAIgBUsbIgggAGoiAiAISQ0BIAIgA0sNAiAAIApHBEAgDyABQQxsaiENIBAgAEEMbGohASAIQQxsIQcDQCABIA0pAgA3AgAgAUEIaiANQQhqKAIANgIAIAFBDGohASAHQQxrIgcNAAsLIAQgBSAIazYCNCACIQAMBAtB8PnMABCyOwALIAAgAkGQ+swAELE7AAsgAiADQZD6zAAQsDsACyABIQALIAAgCkkNAAsLIA5BCDYCACAOIAA2AgQgBkEgaiQAIAlBIGokAA8LQZihzQBBLEHEoc0AEJ8pAAsgCUEANgIYIAlBATYCDCAJQfChzQA2AgggCUIENwIQIAlBCGpB+KHNABDvLAAL9QcCDn8BfiMAQSBrIggkAAJAIAEpAwBCAlIEQCABLQBQRQ0BIAAhDiABIgQoAkQhDyAEKAJIIQwgAiEQIAQoAkwiACADIAAgA0kbIQlBACEAIwBBIGsiBiQAAkACQCADIAlPBEAgCQ0BDAILQYT5zABBLEGw+cwAEJ8pAAsgBEEQaiELA0ACQAJAAkACQAJAAkACQAJAAkACQCAEKAIwRQRAQYAgQQQQrTYiAUUNASABQQBBgCD8CwAgBCABNgIwCyAEKAI0IgcNByAEKAI4IgVFDQYgCygCACIBRQ0FIAtBACABGyENIAAhAQNAIAkgAWsiACAFIAAgBUkbIgBFDQkgDSAEKAIwQYAIIAAgAEGACE8bIhEgBC0APBC5BiICRQRAIARBADYCOAwKCyABIAJqIgAgAkkNAiAAIANLDQMgAkGBCE8NBCAGIAQoAjAiBSACQQJ0ajYCFCAGIAU2AhAgBkEQahCeNiIHBEAgByACIAIgB0sbIQcgECABQQJ0aiEBA0AgBSgCACIKIAxPDQcgASAPIApBAnRqKAIANgIAIAFBBGohASAFQQRqIQUgB0EBayIHDQALCyAEIAQoAjggAmsiBTYCOCAAIQEgAiARTw0ACwwJC0EEQYAgEKM9AAsgASAAQdD5zAAQsTsACyAAIANB0PnMABCwOwALIAJBgAhB4PnMABCwOwALIAogDEGg+swAEMMhAAtBnPjMAEEYQcD5zAAQyyQACyALKAIABEAgBiALEKUYIAYoAgBBAUcNBSAGKQMIIhJQDQUgEkIBg1BFBEAgBCASp0ECdEF4cTYCOAwECyAEIBJCAYg+AjQgBkEQaiALIAQtADwiAUEDdiABQQdxQQBHahDBHCAGKQMQIRIgBCAGKQMYNwMIIAQgEjcDACASpw0DQcD6zABBLkHw+swAEJ8pAAtBnPjMAEEYQbD6zAAQyyQACwJAAkAgBCgCAARAIAQoAggiASAMTwRAIAEgDEGA+swAEMMhAAsgByAJIABrIgIgAiAHSxsiCiAAaiICIApJDQEgAiADSw0CIAAgCUcEQCAPIAFBAnRqKAIAIQ0gECAAQQJ0aiEFIApBAnQhAQNAIAUgDTYCACAFQQRqIQUgAUEEayIBDQALCyAEIAcgCms2AjQgAiEADAQLQfD5zAAQsjsACyAAIAJBkPrMABCxOwALIAIgA0GQ+swAELA7AAsgASEACyAAIAlJDQALCyAOQQg2AgAgDiAANgIEIAZBIGokACAIQSBqJAAPC0GYoc0AQSxBxKHNABCfKQALIAhBADYCGCAIQQE2AgwgCEHwoc0ANgIIIAhCBDcCECAIQQhqQfihzQAQ7ywAC/UHAg5/AX4jAEEgayIIJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ0gASIEKAJEIQ4gBCgCSCEMIAIhDyAEKAJMIgAgAyAAIANJGyEJQQAhACMAQSBrIgYkAAJAAkAgAyAJTwRAIAkNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIHDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAJIAFrIgAgBSAAIAVJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIA8gAUEDdGohAQNAIAUoAgAiCiAMTw0HIAEgDiAKQQN0aikDADcDACABQQhqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAKIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAcgCSAAayICIAIgB0sbIgogAGoiAiAKSQ0BIAIgA0sNAiAAIAlHBEAgDiABQQN0aikDACESIA8gAEEDdGohBSAKQQN0IQEDQCAFIBI3AwAgBUEIaiEFIAFBCGsiAQ0ACwsgBCAHIAprNgI0IAIhAAwEC0Hw+cwAELI7AAsgACACQZD6zAAQsTsACyACIANBkPrMABCwOwALIAEhAAsgACAJSQ0ACwsgDUEINgIAIA0gADYCBCAGQSBqJAAgCEEgaiQADwtBmKHNAEEsQcShzQAQnykACyAIQQA2AhggCEEBNgIMIAhB8KHNADYCCCAIQgQ3AhAgCEEIakH4oc0AEO8sAAvKBwIOfwF+IwBBIGsiCSQAAkAgASkDAEICUgRAIAEtAFBFDQEgACENIAEiBCgCRCEOIAQoAkghDCAEKAJMIgAgAyAAIANJGyEKQQAhACMAQSBrIgckAAJAAkAgAyAKTwRAIAoNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIGDQcgBCgCOCIGRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAKIAFrIgAgBiAAIAZJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiBUUEQCAEQQA2AjgMCgsgASAFaiIAIAVJDQIgACADSw0DIAVBgQhPDQQgByAEKAIwIgYgBUECdGo2AhQgByAGNgIQIAdBEGoQnjYiCARAIAggBSAFIAhLGyEIIAEgAmohAQNAIAYoAgAiDyAMTw0HIAEgDiAPai0AADoAACABQQFqIQEgBkEEaiEGIAhBAWsiCA0ACwsgBCAEKAI4IAVrIgY2AjggACEBIAUgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyAFQYAIQeD5zAAQsDsACyAPIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAcgCxClGCAHKAIAQQFHDQUgBykDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAdBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBykDECESIAQgBykDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgggDE8EQCAIIAxBgPrMABDDIQALIAYgCiAAayIBIAEgBksbIgUgAGoiASAFSQ0BIAEgA0sNAiAFRSAAIApGckUEQCAAIAJqIAggDmotAAAgBfwLAAsgBCAGIAVrNgI0IAEhAAwEC0Hw+cwAELI7AAsgACABQZD6zAAQsTsACyABIANBkPrMABCwOwALIAEhAAsgACAKSQ0ACwsgDUEINgIAIA0gADYCBCAHQSBqJAAgCUEgaiQADwtBmKHNAEEsQcShzQAQnykACyAJQQA2AhggCUEBNgIMIAlB8KHNADYCCCAJQgQ3AhAgCUEIakH4oc0AEO8sAAv3BwMOfwF+AXwjAEEgayIIJAACQCABKQMAQgJSBEAgAS0AUEUNASAAIQ0gASIEKAJEIQ4gBCgCSCEMIAIhDyAEKAJMIgAgAyAAIANJGyEJQQAhACMAQSBrIgYkAAJAAkAgAyAJTwRAIAkNAQwCC0GE+cwAQSxBsPnMABCfKQALIARBEGohCwNAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCMEUEQEGAIEEEEK02IgFFDQEgAUEAQYAg/AsAIAQgATYCMAsgBCgCNCIHDQcgBCgCOCIFRQ0GIAsoAgAiAUUNBSALQQAgARshECAAIQEDQCAJIAFrIgAgBSAAIAVJGyIARQ0JIBAgBCgCMEGACCAAIABBgAhPGyIRIAQtADwQuQYiAkUEQCAEQQA2AjgMCgsgASACaiIAIAJJDQIgACADSw0DIAJBgQhPDQQgBiAEKAIwIgUgAkECdGo2AhQgBiAFNgIQIAZBEGoQnjYiBwRAIAcgAiACIAdLGyEHIA8gAUEDdGohAQNAIAUoAgAiCiAMTw0HIAEgDiAKQQN0aisDADkDACABQQhqIQEgBUEEaiEFIAdBAWsiBw0ACwsgBCAEKAI4IAJrIgU2AjggACEBIAIgEU8NAAsMCQtBBEGAIBCjPQALIAEgAEHQ+cwAELE7AAsgACADQdD5zAAQsDsACyACQYAIQeD5zAAQsDsACyAKIAxBoPrMABDDIQALQZz4zABBGEHA+cwAEMskAAsgCygCAARAIAYgCxClGCAGKAIAQQFHDQUgBikDCCISUA0FIBJCAYNQRQRAIAQgEqdBAnRBeHE2AjgMBAsgBCASQgGIPgI0IAZBEGogCyAELQA8IgFBA3YgAUEHcUEAR2oQwRwgBikDECESIAQgBikDGDcDCCAEIBI3AwAgEqcNA0HA+swAQS5B8PrMABCfKQALQZz4zABBGEGw+swAEMskAAsCQAJAIAQoAgAEQCAEKAIIIgEgDE8EQCABIAxBgPrMABDDIQALIAcgCSAAayICIAIgB0sbIgogAGoiAiAKSQ0BIAIgA0sNAiAAIAlHBEAgDiABQQN0aisDACETIA8gAEEDdGohBSAKQQN0IQEDQCAFIBM5AwAgBUEIaiEFIAFBCGsiAQ0ACwsgBCAHIAprNgI0IAIhAAwEC0Hw+cwAELI7AAsgACACQZD6zAAQsTsACyACIANBkPrMABCwOwALIAEhAAsgACAJSQ0ACwsgDUEINgIAIA0gADYCBCAGQSBqJAAgCEEgaiQADwtBmKHNAEEsQcShzQAQnykACyAIQQA2AhggCEEBNgIMIAhB8KHNADYCCCAIQgQ3AhAgCEEIakH4oc0AEO8sAAt9AQF/IwBBIGsiBCQAIARBCGogASACIAEoAkAiAiADIAIgA0kbEKALIAQoAgwhAgJAIAQoAggiA0EIRwRAIAAgBCkDEDcDCCAAQRBqIARBGGopAwA3AwAMAQsgASABKAJAIAJrNgJACyAAIAM2AgAgACACNgIEIARBIGokAAuHAQICfwJ+IwBBIGsiAyQAIAAoAhghBCADQgA3AwAgAkEHTQRAIANBADYCGCADQQE2AgwgA0GY184ANgIIIANCBDcCECADQQhqQcTZzgAQ7ywACyADQQggAUEIQdTZzgAQ1SwgAykDACAAKQMQIANBIGokAINC07femr3P1vEffiAEQT9xrYinC7oGAgp/Bn4jAEGQAWsiCCQAIAhBQGshBCABKAJ4IQojAEHgAGsiAiQAIAJB0ABqIQMCfgJAIAEoAhAiByABKAIUTw0AIAEgB0EBajYCECABKAIcIgYgASgCJEYNACABKAIIIQkgASgCACELIAEgBkEBajYCHCABKAI0IgUgASgCPEYNACAGLQAAIQYgASAFQRBqNgI0IAIgBSkDADcDUCAJIAdBDGwiB2ohCSAHIAtqIQcgAkFAayEDIAUpAwgMAQtCAgshDCADIAw3AwACQAJAAkAgAikDUCIRQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDQCEMIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAHNgIQIAIgAykCBDcCNCACIAU2AjAgAiAMNwMoIAIgETcDICACIAY6ABggAiAJNgIUIAJBMGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACIBQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCEOIAJBCGoiBSADQQhqKAIAIgs2AgAgAiADKQMAIg03AwAgAkHIAGogCzYCACACIA03A0AgAiAONwJUIAIgATYCUAJAAkAgBkEBcQR+QgAFIAJBEGoiBiAHKAIEIAcoAggQxBggAigCECIDQQhHDQEgAikDGCEPIAYgCSgCBCAJKAIIEMQYIAIoAhAiA0EIRw0BIAIpAxghEEIBCyENIAJBGGogBSgCADYCACACIAIpAwA3AxAMAQsgAikDICEMIAIpAxghDiADrSACNQIUQiCGhCENIAJB0ABqEIUwIAJBQGsQhTAgCigCAEEIRwRAIAoQySMLIAogDDcDECAKIA43AwggCiANNwMAQgIhDQsgBCAMNwMoIAQgETcDICAEIBA3AxggBCANNwMQIAQgDzcDCCAEIA03AwAgBCACKQMQNwMwIAQgDjcDQCAEIAE2AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAgpA0AiDEIDUQ0AGiAIIAhByABqQcAA/AoAAEICIAxCAlENABogAEEIaiAIQcAA/AoAACAMCzcDACAIQZABaiQAC+8HAgp/BH4jAEHgAGsiCiQAIApBKGohCCABKAJ4IQsjAEHwAGsiAiQAIAJB4ABqIQQCfgJAIAEiAygCECIBIAMoAhRPDQAgAyABQQFqNgIQIAMoAhwiBiADKAIkRg0AIAMoAgghByADKAIAIQkgAyAGQQFqNgIcIAMoAjQiBSADKAI8Rg0AIAYtAAAhBiADIAVBEGo2AjQgAiAFKQMANwNgIAcgAUEMbCIBaiEHIAEgCWohASACQdAAaiEEIAUpAwgMAQtCAgshDCAEIAw3AwACQAJAAkAgAikDYCIMQgJRDQAgAygCTCIEIAMoAlRGDQAgAikDUCENIAMgBEEMajYCTCAEKAIAIgVBgYCAgHhGDQAgAiABNgIQIAIgBCkCBDcCNCACIAU2AjAgAiANNwMoIAIgDDcDICACIAY6ABggAiAHNgIUIAJBMGohBCADKAJkIgkgAygCbEcEQCADIAlBDGo2AmQgCSgCACIFQYGAgIB4Rw0CCyAEEIUwCyAIQgM3AwAMAQsgCSkCBCEOIAJBCGoiCSAEQQhqKAIAIgM2AgAgAiAEKQMAIg83AwAgAkHYAGogAzYCACACIA83A1AgAiAONwJkIAIgBTYCYEECIQNBAiEEAkACQCAGQQFxRQRAIAJBEGogASgCBCABKAIIENgWIAItABQhASACKAIQIgZBCEcEQCACQcgAaiACQSBqKAIANgIAIAIgAikDGDcDQCACLwAVIAItABdBEHRyIQcgAigCJCEFDAILIAJBEGogBygCBCAHKAIIENgWIAItABQhBCACKAIQIgZBCEcEQCACQcgAaiACQSBqKAIANgIAIAIgAikDGDcDQCACLwAVIAItABdBEHRyIQcgAigCJCEFIAQhAQwCCyABIQMLIAJByABqIAkoAgA2AgAgAiACKQMANwNAIA1CKIinIQcgDUIgiKchASANpyEGDAELIAJB4ABqEIUwIAJB0ABqEIUwQgIhDAsgBq0gB61CKIYgAa1C/wGDQiCGhIQhDQJAIAxCAlEEQCALKAIAQQhHBEAgCxDJIwsgCyANNwMAIAsgAikDQDcDCCALIAU2AhQgC0EQaiACQcgAaigCADYCAAwBCyACQRhqIAJByABqKAIANgIAIAIgAikDQDcDEAsgCCANNwMIIAggDDcDACAIIAIpAxA3AxAgCCAEOgApIAggAzoAKCAIIA43AyAgCCAFNgIcIAhBGGogAkEYaigCADYCAAsgAkHwAGokACAAAn5CAiAKKQMoIgxCA1ENABogCiAKQTBqQSj8CgAAQgIgDEICUQ0AGiAAQQhqIApBKPwKAAAgDAs3AwAgCkHgAGokAAvfBwIMfwZ+IwBBoAFrIgokACAKQcgAaiEEIAEoAnghCCMAQYABayICJAAgAkHoAGohBQJ+AkAgASgCECIGIAEoAhRPDQAgASAGQQFqNgIQIAEoAhwiByABKAIkRg0AIAEoAgghCSABKAIAIQsgASAHQQFqNgIcIAEoAjQiAyABKAI8Rg0AIActAAAhByABIANBEGo2AjQgAiADKQMANwNoIAkgBkEMbCIGaiEJIAYgC2ohBiACQdgAaiEFIAMpAwgMAQtCAgshDiAFIA43AwACQAJAAkAgAikDaCIQQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDWCESIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAGNgIYIAIgAykCBDcCPCACIAU2AjggAiASNwMwIAIgEDcDKCACIAc6ACAgAiAJNgIcIAJBOGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACILQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCETIAJBEGoiDSADQQhqKAIAIgE2AgAgAiADKQMAIg43AwggAkHQAGogATYCACACIA43A0ggAiATNwJcIAIgCzYCWAJAAkACQAJAIAdBAXEEQEEAIQUMAQsgAkEYaiAGKAIEIAYoAggQvxwgAikCJCEOIAIoAiAhAyACKAIcIQEgAigCGCIMQQhHBEAgAigCLCEFDAMLIAIgAzYCcCACIAE2AmxBASEFIAJBATYCaCACIA43AnQgAkEYaiAJKAIEIAkoAggQvxwgAikCJCEPIAIoAiAhByACKAIcIQYgAigCGCIMQQhHBEAgAigCLCEFIAFFDQIgAkH4AGogAyAOpyABKAIQEQEADAILIAGtIAOtQiCGhCERCyACQSBqIA0oAgA2AgAgAiACKQMINwMYIA5CIIinIQkgDqchCAwCCyAGIQEgDyEOIAchAwsgAkHYAGoQhTAgAkHIAGoQhTAgCCgCAEEIRwRAIAgQySMLIAggBTYCFCAIIA43AgwgCCADNgIIIAggDK0gAa1CIIaENwMAQgIhEAsgBCAPNwMwIAQgBzYCLCAEIAY2AiggBCAFNgIkIAQgCTYCICAEIAg2AhwgBCARNwIUIAQgBTYCECAEIBI3AwggBCAQNwMAIAQgAikDGDcDOCAEIBM3A0ggBCALNgJEIARBQGsgAkEgaigCADYCAAsgAkGAAWokACAAAn5CAiAKKQNIIg5CA1ENABogCiAKQdAAakHIAPwKAABCAiAOQgJRDQAaIABBCGogCkHIAPwKAAAgDgs3AwAgCkGgAWokAAu8BgMKfwV+AXwjAEGQAWsiCCQAIAhBQGshBCABKAJ4IQojAEHgAGsiAiQAIAJB0ABqIQMCfgJAIAEoAhAiByABKAIUTw0AIAEgB0EBajYCECABKAIcIgYgASgCJEYNACABKAIIIQkgASgCACELIAEgBkEBajYCHCABKAI0IgUgASgCPEYNACAGLQAAIQYgASAFQRBqNgI0IAIgBSkDADcDUCAJIAdBDGwiB2ohCSAHIAtqIQcgAkFAayEDIAUpAwgMAQtCAgshDCADIAw3AwACQAJAAkAgAikDUCIQQgJRDQAgASgCTCIDIAEoAlRGDQAgAikDQCEMIAEgA0EMajYCTCADKAIAIgVBgYCAgHhGDQAgAiAHNgIQIAIgAykCBDcCNCACIAU2AjAgAiAMNwMoIAIgEDcDICACIAY6ABggAiAJNgIUIAJBMGohAyABKAJkIgUgASgCbEcEQCABIAVBDGo2AmQgBSgCACIBQYGAgIB4Rw0CCyADEIUwCyAEQgM3AwAMAQsgBSkCBCEOIAJBCGoiBSADQQhqKAIAIgs2AgAgAiADKQMAIg03AwAgAkHIAGogCzYCACACIA03A0AgAiAONwJUIAIgATYCUAJAAkAgBkEBcQR+QgAFIAJBEGoiBiAHKAIEIAcoAggQxBggAigCECIDQQhHDQEgAisDGCERIAYgCSgCBCAJKAIIEMQYIAIoAhAiA0EIRw0BIAIpAxghD0IBCyENIAJBGGogBSgCADYCACACIAIpAwA3AxAMAQsgAikDICEMIAIrAxghESADrSACNQIUQiCGhCEOIAJB0ABqEIUwIAJBQGsQhTAgCigCAEEIRwRAIAoQySMLIAogDDcDECAKIBE5AwggCiAONwMAQgIhDQsgBCAMNwMoIAQgEDcDICAEIA83AxggBCANNwMQIAQgETkDCCAEIA03AwAgBCACKQMQNwMwIAQgDjcDQCAEIAE2AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAgpA0AiDEIDUQ0AGiAIIAhByABqQcAA/AoAAEICIAxCAlENABogAEEIaiAIQcAA/AoAACAMCzcDACAIQZABaiQAC40HAwp/BH4EfSMAQfAAayIJJAAgCUEwaiEEIAEoAnghCCMAQeAAayICJAAgAkHQAGohAwJ+AkAgASgCECIFIAEoAhRPDQAgASAFQQFqNgIQIAEoAhwiBiABKAIkRg0AIAEoAgghCiABKAIAIQsgASAGQQFqNgIcIAEoAjQiByABKAI8Rg0AIAYtAAAhBiABIAdBEGo2AjQgAiAHKQMANwNQIAogBUEMbCIFaiEKIAUgC2ohBSACQUBrIQMgBykDCAwBC0ICCyEMIAMgDDcDAAJAAkACQCACKQNQIgxCAlENACABKAJMIgMgASgCVEYNACACKQNAIQ0gASADQQxqNgJMIAMoAgAiB0GBgICAeEYNACACIAU2AhAgAiADKQIENwI0IAIgBzYCMCACIAw3AyAgAiAGOgAYIAIgCjYCFCABKAJsIQsgASgCZCEDIAIgDTcDKCACQTBqIQcgAyALRwRAIAEgA0EMajYCZCADKAIAIgFBgYCAgHhHDQILIAcQhTALIARCAzcDAAwBCyADKQIEIQ4gAkEIaiILIAdBCGooAgAiAzYCACACIAcpAwAiDzcDACACQcgAaiADNgIAIAIgDzcDQCACIA43AlQgAiABNgJQAkAgBkEBcQR/QQAFIAJBEGogBSgCBCAFKAIIEKQYIAIqAhQhEAJAAn8gAigCECIDQQhHBEAgAioCJCESIAIqAhwhEyACKAIYIQYgAigCIAwBCyACQRBqIAooAgQgCigCCBCkGCACKgIUIREgAigCECIDQQhGDQEgAioCJCESIAIqAhwhEyACKAIYIQYgESEQIAIoAiALIQUgAkHQAGoQhTAgAkFAaxCFMCAIKAIAQQhHBEAgCBDJIwsgCCASOAIUIAggBTYCECAIIBM4AgwgCCAGNgIIIAggEDgCBCAIIAM2AgBCAiEMDAILQQELIQMgDUIgiKchBSANpyEGIAJBGGogCygCADYCACACIAIpAwA3AxALIAQgETgCHCAEIAM2AhggBCAQOAIUIAQgAzYCECAEIAU2AgwgBCAGNgIIIAQgDDcDACAEIAIpAxA3AyAgBCAONwMwIAQgATYCLCAEQShqIAJBGGooAgA2AgALIAJB4ABqJAAgAAJ+QgIgCSkDMCIMQgNRDQAaIAkgCUE4akEw/AoAAEICIAxCAlENABogAEEIaiAJQTD8CgAAIAwLNwMAIAlB8ABqJAAL8gYCC38EfiMAQfAAayIKJAAgCkEwaiEGIAEoAnghCSMAQeAAayICJAAgAkHQAGohAwJ+AkAgASgCECIFIAEoAhRPDQAgASAFQQFqNgIQIAEoAhwiByABKAIkRg0AIAEoAgghCCABKAIAIQsgASAHQQFqNgIcIAEoAjQiBCABKAI8Rg0AIActAAAhByABIARBEGo2AjQgAiAEKQMANwNQIAggBUEMbCIFaiEIIAUgC2ohBSACQUBrIQMgBCkDCAwBC0ICCyENIAMgDTcDAAJAAkACQCACKQNQIg1CAlENACABKAJMIgMgASgCVEYNACACKQNAIQ4gASADQQxqNgJMIAMoAgAiBEGBgICAeEYNACACIAU2AhAgAiADKQIENwI0IAIgBDYCMCACIA43AyggAiANNwMgIAIgBzoAGCACIAg2AhQgAkEwaiEDIAEoAmQiBCABKAJsRwRAIAEgBEEMajYCZCAEKAIAIgFBgYCAgHhHDQILIAMQhTALIAZCAzcDAAwBCyAEKQIEIQ8gAkEIaiIEIANBCGooAgAiCzYCACACIAMpAwAiEDcDACACQcgAaiALNgIAIAIgEDcDQCACIA83AlQgAiABNgJQAkAgB0EBcQR/QQAFIAJBEGogBSgCBCAFKAIIEKQYIAIoAhQhBQJAAn8gAigCECIDQQhHBEAgAigCICEIIAIoAhwhBCACKAIYIQsgAigCJAwBCyACQRBqIAgoAgQgCCgCCBCkGCACKAIUIQcgAigCECIDQQhGDQEgAigCICEIIAIoAhwhBCACKAIYIQsgByEFIAIoAiQLIQwgAkHQAGoQhTAgAkFAaxCFMCAJKAIAQQhHBEAgCRDJIwsgCSAMNgIUIAkgCDYCECAJIAQ2AgwgCSALNgIIIAkgA60gBa1CIIaENwMAQgIhDQwCC0EBCyEDIAJBGGogBCgCADYCACACIAIpAwA3AxALIAYgBzYCHCAGIAM2AhggBiAFNgIUIAYgAzYCECAGIA43AwggBiANNwMAIAYgAikDEDcDICAGIA83AzAgBiABNgIsIAZBKGogAkEYaigCADYCAAsgAkHgAGokACAAAn5CAiAKKQMwIg1CA1ENABogCiAKQThqQTD8CgAAQgIgDUICUQ0AGiAAQQhqIApBMPwKAAAgDQs3AwAgCkHwAGokAAuNBwIMfwR+IwBBkAFrIgkkACAJQUBrIQQgASgCeCEKIwBB4ABrIgIkACACQdAAaiEDAn4CQCABKAIQIgUgASgCFE8NACABIAVBAWo2AhAgASgCHCIHIAEoAiRGDQAgASgCCCEIIAEoAgAhDCABIAdBAWo2AhwgASgCNCILIAEoAjxGDQAgBy0AACEHIAEgC0EQajYCNCACIAspAwA3A1AgCCAFQQxsIgZqIQggBiAMaiEFIAJBQGshAyALKQMIDAELQgILIQ4gAyAONwMAAkACQAJAIAIpA1AiDkICUQ0AIAEoAkwiAyABKAJURg0AIAIpA0AhDyABIANBDGo2AkwgAygCACIGQYGAgIB4Rg0AIAIgBTYCECACIAMpAgQ3AjQgAiAGNgIwIAIgDzcDKCACIA43AyAgAiAHOgAYIAIgCDYCFCACQTBqIQYgASgCZCIDIAEoAmxHBEAgASADQQxqNgJkIAMoAgAiDUGBgICAeEcNAgsgBhCFMAsgBEIDNwMADAELIAMpAgQhESACQQhqIgwgBkEIaigCACIBNgIAIAIgBikDACIQNwMAIAJByABqIAE2AgAgAiAQNwNAIAIgETcCVCACIA02AlACQCAHQQFxBH9BAAUgAkEQaiAFKAIEIAUoAggQ+RcgAigCHCEDIAIoAhghASACKAIUIQUCQAJ+IAIoAhAiC0EIRwRAIAIpAyAMAQsgAkEQaiAIKAIEIAgoAggQ+RcgAigCHCEGIAIoAhghCCACKAIUIQcgAigCECILQQhGDQEgByEFIAYhAyAIIQEgAikDIAshDiALrSAFrUIghoQhDyACQdAAahCFMCACQUBrEIUwIAooAgBBCEcEQCAKEMkjCyAKIA43AxAgCiADNgIMIAogATYCCCAKIA83AwBCAiEODAILIAGtIAOtQiCGhCEQQQELIQMgAkEYaiAMKAIANgIAIAIgAikDADcDEAsgBCAGNgIsIAQgCDYCKCAEIAc2AiQgBCADNgIgIAQgEDcDGCAEIAU2AhQgBCADNgIQIAQgDzcDCCAEIA43AwAgBCACKQMQNwMwIAQgETcDQCAEIA02AjwgBEE4aiACQRhqKAIANgIACyACQeAAaiQAIAACfkICIAkpA0AiDkIDUQ0AGiAJIAlByABqQcAA/AoAAEICIA5CAlENABogAEEIaiAJQcAA/AoAACAOCzcDACAJQZABaiQAC9gDAQ1/IwBBkAFrIgMkACADQcQAaiEKIAEoAhwhBCMAQZABayICJAACQCABKAIQIgUgASgCFCIMSQRAIAEoAgAgBUECdGohByABKAIIIAVBA3RqIQggAkHkAGohDSACQSBqIQ4gAkEEciEGIAEoAhghCwNAIAEgBUEBaiIFNgIQIAIgBygCAEEIaiALLwEAIAsvAQIgCBC2AQJAAkAgAigCACIJQYSAgIB4RgRAIAQoAgBBCEcEQCAEEMkjCyAEIAIpAwg3AwAgBEEQaiACQRhqKQMANwMAIARBCGogAkEQaikDADcDAAwBCyACQeAAaiAGQRhqKAIANgIAIAJB2ABqIAZBEGopAgA3AwAgAkHQAGogBkEIaikCADcDACACIAYpAgA3A0ggDSAOQSj8CgAAIAlBhYCAgHhGDQELIApBBGogAkHIAGpBxAD8CgAADAMLIAdBBGohByAIQQhqIQggBSAMRw0ACwtBhYCAgHghCQsgCiAJNgIAIAJBkAFqJAAgAAJ/QYSAgIB4IAMoAkQiAUGFgICAeEYNABogAyADQcgAakHEAPwKAABBhICAgHggAUGEgICAeEYNABogAEEEaiADQcQA/AoAACABCzYCACADQZABaiQAC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQRBCBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQN0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEHYmc8AEP0vAAuUAQECfyMAQRBrIgIkACAAKAIAIgNBAWohAAJ/AkACQAJAIAMtAABBAWsOAgECAAsgAiAANgIEIAFB2J3QAEEGIAJBBGpByJ3QABDQEwwCCyACIAA2AgggAUHwndAAQQYgAkEIakHgndAAENATDAELIAIgADYCDCABQYie0ABBBSACQQxqQfid0AAQ0BMLIAJBEGokAAugAQAgAEEANgLQASAAQQA2AsgBIABBADYCwAEgAEEANgK4ASAAQgg3A2AgAEIANwNQIABCADcDQCAAQgA3AzAgAEIANwMgIABCADcDECAAQgA3AwAgAEHYAWpBAEEs/AsAIAAgATYCvAIgAEGAgICAeDYCsAIgAEGAgICAeDYCpAIgAEGAgICAeDYCmAIgAEGAgICAeDYCjAIgAEIBNwKEAguXAQACQAJAAkACQAJAIAJBBWsOBAECAwQACyAAKAAAQbHz3fF5bEEgIAFrdg8LIAApAABCgICA2Mub741PfkHAACABa62Ipw8LIAApAABCgIDs/Mub741PfkHAACABa62Ipw8LIAApAABCgMaV/cub741PfkHAACABa62Ipw8LIAApAABC48iVvcub741PfkHAACABa62Ipwt5AQR/IAAoAgAoAgAiACgCCCICIQNBAUECIAHAQQBOIgUbIgQgACgCACACa0sEfyAAIAIgBEEBQQEQ0CggACgCCAUgAwsgACgCBGoiAyAFBH8gAQUgAyABQb8BcToAASABQcABcUEGdkFAcgs6AAAgACACIARqNgIIC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQhBCBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQN0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEGs7v4AEP0vAAuNBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayIBJAAgAUEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQQhBCBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHcj/8AEP0vAAsgAUEQaiIVQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIg8kACABQQhqIgIgCigCBCAKKAIAa0EEdhDsLSAPIAIpAgRCIIk3AgggDyACQQhqNgIEIwBBIGsiAiQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBA3RqIQogDCAOa0EEdiENA0ACfgJAAkAgDikDACIGIA4pAwgiB0KAgICAgICAgIB/hYRCAFIgFygCACIMKAIAIhIpAwgiAyASKQMAIgSDQn9SckUEQEIAIQRCACEDQgAhBUKAgICAgICAgIB/IQgMAQsgAyAEhFANBSACQRBqIAYgByAEIAMQgxkgAiACKQMQIgUgAikDGCIIIAQgAxCoHkIAIAYgAikDACIJfSADIASDQn9RIhIbIQRCACAHIAIpAwh9IAYgCVStfSASGyEDIAdCAFkNAQsgBSAEIAwoAggiDCkDAFggAyAMKQMIIgRXIAMgBFEbrSIEfSEDIAggBCAFVq19DAELIAggBSAEIAwoAgQiDCkDAFogAyAMKQMIIgRZIAMgBFEbrXwiAyAFVK18CyADQoCAgICAgICAgH99IANUrXxQRQ0DIAogAzcDACAOQRBqIQ4gCkEIaiEKIBBBAWohECANQQFrIg0NAAsLIBYgEDYCACACQSBqJAAMAgtBxKiAARDiKwALQfCtgAEQsjsACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgASkCCDcCACABQSBqJAAgEyAREL0YIAAgEyAUEMYdIAtBQGskAAvgAwILfwF+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgsgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQojAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBBHZBAEEIQQgQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDEEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIIJAAgA0EIaiIBIAUoAgQgBSgCAGtBBHYQ7C0gCCABKQIEQiCJNwIIIAggAUEIajYCBCAIQQRqIgYoAgQhCSAGKAIAIQ0CQAJAIAUoAgAiByAFKAIEIgJHBEAgBSgCCCEBIAYoAgggCUEDdGohBiACIAdrQQR2IQIDQCAHKQMIIAcpAwAiDkKAgICAgICAgIB/fSAOVK18UEUNAiAGIAEoAgApAwAgDn43AwAgB0EQaiEHIAZBCGohBiAJQQFqIQkgAkEBayICDQALCyANIAk2AgAMAQtBgK6AARCyOwALIAhBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQvRggACAFIAsQxh0gBEFAayQAC/MFAgd+Dn8jAEFAaiILJAAgCyACNgIMIAtBEGoiFCABEJI2EO4lIAEoAhQhAiALIAEoAhAiATYCNCALIAEgAkFwcWo2AjggCyALQQxqNgI8IAtBKGohESMAQSBrIgEkACABQRRqIAtBNGoiEyIKKAIEIAooAgBrQQR2QQBBEEEQEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQdyP/wAQ/S8ACyABQRBqIhVBADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiDyQAIAFBCGoiAiAKKAIEIAooAgBrQQR2EOstIA8gAikCBEIgiTcCCCAPIAJBCGo2AgQjAEEgayICJAAgD0EEaiINKAIEIRAgDSgCACEWAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBBHRqIQogDCAOa0EEdiENA0BCgICAgICAgICAfyEGAn4CQAJAIA4pAwAiByAOKQMIIghCgICAgICAgICAf4WEQgBSIBcoAgAiDCgCACISKQMIIgQgEikDACIDg0J/UnJFBEBCACEDQgAhBEIAIQUMAQsgAyAEhFANBSACQRBqIAcgCCADIAQQgxkgAiACKQMQIgUgAikDGCIGIAMgBBCoHkIAIAcgAikDACIJfSADIASDQn9RIhIbIQNCACAIIAIpAwh9IAcgCVStfSASGyEEIAhCAFkNAQsgBSADIAwoAggiDCkDAFggBCAMKQMIIgNXIAMgBFEbrSIDfSEEIAYgAyAFVq19DAELIAYgBSADIAwoAgQiDCkDAFogBCAMKQMIIgNZIAMgBFEbrXwiBCAFVK18CyEFIAogBDcDACAKIAU3AwggDkEQaiEOIApBEGohCiAQQQFqIRAgDUEBayINDQALCyAWIBA2AgAgAkEgaiQADAELQcSogAEQ4isACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgASkCCDcCACABQSBqJAAgEyAREOwYIAAgEyAUEMsdIAtBQGskAAuiCQIOfwh+IwBBQGoiBiQAIAYgAjYCDCAGQRBqIg0gARCSNhDuJSABKAIUIQIgBiABKAIQIgE2AjQgBiABIAJBYHFqNgI4IAYgBkEMajYCPCAGQShqIQojAEEgayICJAAgAkEUaiAGQTRqIgsiASgCBCABKAIAa0EFdkEAQQRBBBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQSBrIgQkACACQQhqIgUgASgCBCABKAIAa0EFdhDuLSAFKQIEIREgBEEQaiABQQhqKAIANgIAIAQgASkCADcDCCAEIBFCIIk3AhggBCAFQQhqNgIUIwBBkAFrIgEkACAEQRRqIgMoAgQhCSADKAIAIQ8CQAJAIARBCGoiBygCACIFIAcoAgQiCEcEQCAHKAIIIRAgAygCCCAJQQJ0aiEHIAggBWtBBXYhDANAIAVBGGopAwAhEyAQKAIAIQggBSkDCCEUIAUpAwAhFSABIAVBEGopAwAiGDcDECABIBM3AxggASAVNwMAIAEgFDcDCCABQUBrIBUgFCAYIBMgCCgCACIDKQMAIAMpAwggAykDECADKQMYEJoIAn4gAS0AQEEBRgRAIAEtAEEEQEKAgICAgICAgIB/IRZCACESQgAhEUIADAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQdSngAEQ7ywACyABKQNoIRYgASkDYCERIAEpA1ghEiABKQNQCyEXIAFBQGsgFSAUIBggEyADKQMAIAMpAwggAykDECADKQMYEJoIAkAgAS0AQEEBRgRAIAEtAEEEQCABQThqQgA3AwAgAUEwakIANwMAIAFCADcDKCABQgA3AyAMAgsgAUEANgIwIAFBATYCJCABQcyngAE2AiAgAUIENwIoIAFBIGpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEyASIBNQrXwiFIRQrXwiFSARVK18IRYMAgsgF0IBfSETIBIgF1CtfSEUIBEgEiAXhFCtIhJ9IRUgFiARIBJUrX0hFgwBCyARIRUgFyETIBIhFAsgAUFAayATIBQgFSAWENYjIAEoAkBBAXFFDQIgASkDUCIRQoCAgIAIfCISQoCAgIAQVCABKQNYIBEgElatfFBxRQ0CIAcgET4CACAFQSBqIQUgB0EEaiEHIAlBAWohCSAMQQFrIgwNAAsLIA8gCTYCACABQZABaiQADAELQfCtgAEQsjsACyAEQSBqJAAgCkEIaiAOKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEOgYIAAgCyANEModIAZBQGskAAuYBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayIBJAAgAUEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHcj/8AEP0vAAsgAUEQaiIVQQA2AgAgASABKAIcNgIMIAEgAjYCCCMAQRBrIg8kACABQQhqIgIgCigCBCAKKAIAa0EEdhDuLSAPIAIpAgRCIIk3AgggDyACQQhqNgIEIwBBIGsiAiQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkACQCAKKAIAIg4gCigCBCIMRwRAIAooAgghFyANKAIIIBBBAnRqIQogDCAOa0EEdiENA0BCgICAgICAgICAfyEGAn4CQAJAIA4pAwAiByAOKQMIIghCgICAgICAgICAf4WEQgBSIBcoAgAiDCgCACISKQMIIgQgEikDACIDg0J/UnJFBEBCACEDQgAhBEIAIQUMAQsgAyAEhFANBSACQRBqIAcgCCADIAQQgxkgAiACKQMQIgUgAikDGCIGIAMgBBCoHkIAIAcgAikDACIJfSADIASDQn9RIhIbIQNCACAIIAIpAwh9IAcgCVStfSASGyEEIAhCAFkNAQsgBSADIAwoAggiDCkDAFggBCAMKQMIIgNXIAMgBFEbrSIDfSEEIAYgAyAFVq19DAELIAYgBSADIAwoAgQiDCkDAFogBCAMKQMIIgNZIAMgBFEbrXwiBCAFVK18CyEFIARCgICAgAh8IgNCgICAgBBUIAUgAyAEVK18UHFFDQMgCiAEPgIAIA5BEGohDiAKQQRqIQogEEEBaiEQIA1BAWsiDQ0ACwsgFiAQNgIAIAJBIGokAAwCC0HEqIABEOIrAAtB8K2AARCyOwALIA9BEGokACARQQhqIBUoAgA2AgAgESABKQIINwIAIAFBIGokACATIBEQ6BggACATIBQQyh0gC0FAayQAC+gDAgt/An4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFwcWo2AjggBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EEdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIggkACADQQhqIgEgBSgCBCAFKAIAa0EEdhDuLSAIIAEpAgRCIIk3AgggCCABQQhqNgIEIAhBBGoiBigCBCEJIAYoAgAhDQJAAkAgBSgCACIHIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAJQQJ0aiEGIAIgB2tBBHYhAgNAIAcpAwAiDkKAgICACHwiD0KAgICAEFQgBykDCCAOIA9WrXxQcUUNAiAGIAEoAgAoAgAgDqdsNgIAIAdBEGohByAGQQRqIQYgCUEBaiEJIAJBAWsiAg0ACwsgDSAJNgIADAELQYCugAEQsjsACyAIQRBqJAAgCkEIaiAMKAIANgIAIAogAykCCDcCACADQSBqJAAgBSAKEOgYIAAgBSALEModIARBQGskAAvkBQINfwZ+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQojAEEgayICJAAgAkEUaiAEQTRqIgsiAygCBCADKAIAa0EEdkEAQRBBIBCgGCACKAIYIQEgAigCFEEBRgRAIAEgAigCHEHcj/8AEP0vAAsgAkEQaiINQQA2AgAgAiACKAIcNgIMIAIgATYCCCMAQRBrIgckACACQQhqIgEgAygCBCADKAIAa0EEdhDvLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIwBBgAFrIgEkACAHQQRqIgUoAgQhCCAFKAIAIAMoAgAiBiADKAIEIglHBEAgAygCCCEPIAUoAgggCEEFdGohAyAIIAkgBmtBBHYiCWohCANAIAFB4ABqIAYpAwAgBikDCBCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAZBEGohBiADQSBqIQMgCUEBayIJDQALCyAINgIAIAFBgAFqJAAgB0EQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALngQBDX8jAEFAaiIEJAAgBCACNgIMIARBEGoiDCABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFgcWo2AjggBCAEQQxqNgI8IARBKGohCSMAQSBrIgEkACABQRRqIARBNGoiCyIDKAIEIAMoAgBrQQV2QQBBEEEQEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASACNgIIIwBBEGsiByQAIAFBCGoiAiADKAIEIAMoAgBrQQV2EOstIAcgAikCBEIgiTcCCCAHIAJBCGo2AgQjAEEwayICJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCADKAIAIgUgAygCBCIKRwRAIAMoAgghDyAGKAIIIAhBBHRqIQMgCiAFa0EFdiEGA0AgAkEQaiAFKQMAIAUpAwggBUEQaikDACAFQRhqKQMAENYjIAIoAhBBAXFFDQIgAiAPKAIAIgopAwAgCikDCCACKQMgIAIpAygQqB4gAyACKQMANwMAIAMgAikDCDcDCCAFQSBqIQUgA0EQaiEDIAhBAWohCCAGQQFrIgYNAAsLIA4gCDYCACACQTBqJAAMAQtBgK6AARCyOwALIAdBEGokACAJQQhqIA0oAgA2AgAgCSABKQIINwIAIAFBIGokACALIAkQ7BggACALIAwQyx0gBEFAayQAC8kDAgt/AX4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkF4cWo2AjggBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQhBEBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIggkACADQQhqIgEgBSgCBCAFKAIAa0EDdhDpLSAIIAEpAgRCIIk3AgggCCABQQhqNgIEIAhBBGoiBigCBCEJIAYoAgAgBSgCACIHIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAJQQR0aiEGIAkgAiAHa0EDdiICaiEJA0AgASgCACkDACEOIAZBBGogBygCADYCACAGQQA2AgAgBkEIaiAOIAdBBGo0AgB+NwMAIAdBCGohByAGQRBqIQYgAkEBayICDQALCyAJNgIAIAhBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQ6hggACAFIAsQxR0gBEFAayQAC6IEAgx/An4jAEFAaiIEJAAgBCACNgIMIARBEGoiDCABEJI2EO4lIAEoAhQhAiAEIAEoAhAiATYCNCAEIAEgAkFgcWo2AjggBCAEQQxqNgI8IARBKGohCyMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EFdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiINQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgkkACADQQhqIgEgBSgCBCAFKAIAa0EFdhDuLSAJIAEpAgRCIIk3AgggCSABQQhqNgIEIwBBIGsiCCQAIAlBBGoiBygCBCEKIAcoAgAhDgJAAkAgBSgCACIGIAUoAgQiAkcEQCAFKAIIIQEgBygCCCAKQQJ0aiEHIAIgBmtBBXYhAgNAIAggBikDACAGKQMIIAZBEGopAwAgBkEYaikDABDWIyAIKAIAQQFxRQ0CIAgpAxAiD0KAgICACHwiEEKAgICAEFQgCCkDGCAPIBBWrXxQcUUNAiAHIAEoAgAoAgAgD6dsNgIAIAZBIGohBiAHQQRqIQcgCkEBaiEKIAJBAWsiAg0ACwsgDiAKNgIAIAhBIGokAAwBC0GAroABELI7AAsgCUEQaiQAIAtBCGogDSgCADYCACALIAMpAgg3AgAgA0EgaiQAIAUgCxDoGCAAIAUgDBDKHSAEQUBrJAALoAkCDn8IfiMAQUBqIgYkACAGIAI2AgwgBkEQaiINIAEQkjYQ7iUgASgCFCECIAYgASgCECIBNgI0IAYgASACQWBxajYCOCAGIAZBDGo2AjwgBkEoaiEKIwBBIGsiAiQAIAJBFGogBkE0aiILIgEoAgQgASgCAGtBBXZBAEEIQQgQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEgayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBBXYQ7C0gBSkCBCERIARBEGogAUEIaigCADYCACAEIAEpAgA3AwggBCARQiCJNwIYIAQgBUEIajYCFCMAQbABayIBJAAgBEEUaiIDKAIEIQkgAygCACEPAkACQCAEQQhqIgcoAgAiBSAHKAIEIghHBEAgBygCCCEQIAMoAgggCUEDdGohByAIIAVrQQV2IQwDQCAFQRhqKQMAIRIgECgCACEIIAUpAwghEyAFKQMAIRQgASAFQRBqKQMAIhg3AxAgASASNwMYIAEgFDcDACABIBM3AwggAUFAayAUIBMgGCASIAgoAgAiAykDACADKQMIIAMpAxAgAykDGBCaCAJ+IAEtAEBBAUYEQCABLQBBBEBCgICAgICAgICAfyEWQgAhFUIAIRFCAAwCCyABQQA2AjAgAUEBNgIkIAFBzKeAATYCICABQgQ3AiggAUEgakHUp4ABEO8sAAsgASkDaCEWIAEpA2AhESABKQNYIRUgASkDUAshFyABQUBrIBQgEyAYIBIgAykDACADKQMIIAMpAxAgAykDGBCaCAJAIAEtAEBBAUYEQCABLQBBBEAgAUE4akIANwMAIAFBMGpCADcDACABQgA3AyggAUIANwMgDAILIAFBADYCqAEgAUEBNgKcASABQcyngAE2ApgBIAFCBDcCoAEgAUGYAWpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEiAVIBJQrXwiE4RQrXwiFCARVK18IRYMAgsgF0IBfSESIBUgF1CtfSETIBEgFSAXhFCtIhV9IRQgFiARIBVUrX0hFgwBCyARIRQgFyESIBUhEwsgAUFAayASIBMgFCAWENYjIAEoAkBBAXFFDQIgASkDWCABKQNQIhFCgICAgICAgICAf30gEVStfFBFDQIgByARNwMAIAVBIGohBSAHQQhqIQcgCUEBaiEJIAxBAWsiDA0ACwsgDyAJNgIAIAFBsAFqJAAMAQtB8K2AARCyOwALIARBIGokACAKQQhqIA4oAgA2AgAgCiACKQIINwIAIAJBIGokACALIAoQvRggACALIA0Qxh0gBkFAayQAC9oDAQ1/IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBcHFqNgI4IAQgBEEMajYCPCAEQShqIQkjAEEgayIBJAAgAUEUaiAEQTRqIgsiAigCBCACKAIAa0EEdkEAQRBBEBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEHcj/8AEP0vAAsgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgYkACABQQhqIgMgAigCBCACKAIAa0EEdhDrLSAGIAMpAgRCIIk3AgggBiADQQhqNgIEIwBBEGsiByQAIAZBBGoiBSgCBCEIIAUoAgAgAigCACIDIAIoAgQiCkcEQCACKAIIIQ8gBSgCCCAIQQR0aiECIAggCiADa0EEdiIFaiEIA0AgByAPKAIAIgopAwAgCikDCCADKQMAIAMpAwgQqB4gAiAHKQMANwMAIAIgBykDCDcDCCADQRBqIQMgAkEQaiECIAVBAWsiBQ0ACwsgCDYCACAHQRBqJAAgBkEQaiQAIAlBCGogDSgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAsgCRDsGCAAIAsgDBDLHSAEQUBrJAALzQUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgASgCFCECIAQgASgCECIBNgI0IAQgASACQWBxajYCOCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBBXZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAMoAgQgAygCAGtBBXYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQeAAayIBJAAgB0EEaiIGKAIEIQggBigCACADKAIAIgUgAygCBCIJRwRAIAMoAgghDyAGKAIIIAhBBXRqIQMgCCAJIAVrQQV2IglqIQgDQCABQdAAaiAPKAIAIgYpAwAiEEIAIAUpAwAiEkIAEKgeIAFBQGsgEEIAIAUpAwgiE0IAEKgeIAFBMGogBikDCCIRQgAgEkIAEKgeIAFBIGogEUIAIBNCABCoHiABQRBqIBAgESAFQRBqKQMAIAVBGGopAwAQqB4gASAGKQMQIAYpAxggEiATEKgeIAMgASkDUDcDACADIAEpA1giESABKQNAfCIQIAEpAzB8IhQ3AwggA0EQaiABKQMgIhUgASkDEHwiEiABKQMAfCITIAEpA0ggECARVK18fCIRIAEpAzggECAUVq18fCIQNwMAIANBGGogECARVK0gESATVK0gEiATVq0gASkDCCASIBVUrSABKQMoIAEpAxh8fHx8fHw3AwAgBUEgaiEFIANBIGohAyAJQQFrIgkNAAsLIAg2AgAgAUHgAGokACAHQRBqJAAgCkEIaiANKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEO0YIAAgCyAMEM4dIARBQGskAAuLCQIOfwh+IwBBQGoiBiQAIAYgAjYCDCAGQRBqIg0gARCSNhDuJSABKAIUIQIgBiABKAIQIgE2AjQgBiABIAJBYHFqNgI4IAYgBkEMajYCPCAGQShqIQojAEEgayICJAAgAkEUaiAGQTRqIgsiASgCBCABKAIAa0EFdkEAQRBBEBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIOQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQSBrIgQkACACQQhqIgUgASgCBCABKAIAa0EFdhDrLSAFKQIEIREgBEEQaiABQQhqKAIANgIAIAQgASkCADcDCCAEIBFCIIk3AhggBCAFQQhqNgIUIwBBkAFrIgEkACAEQRRqIgMoAgQhCSADKAIAIQ8CQAJAIARBCGoiBygCACIFIAcoAgQiCEcEQCAHKAIIIRAgAygCCCAJQQR0aiEHIAggBWtBBXYhDANAIAVBGGopAwAhEiAQKAIAIQggBSkDCCETIAUpAwAhFCABIAVBEGopAwAiGDcDECABIBI3AxggASAUNwMAIAEgEzcDCCABQUBrIBQgEyAYIBIgCCgCACIDKQMAIAMpAwggAykDECADKQMYEJoIAn4gAS0AQEEBRgRAIAEtAEEEQEKAgICAgICAgIB/IRZCACEVQgAhEUIADAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQdSngAEQ7ywACyABKQNoIRYgASkDYCERIAEpA1ghFSABKQNQCyEXIAFBQGsgFCATIBggEiADKQMAIAMpAwggAykDECADKQMYEJoIAkAgAS0AQEEBRgRAIAEtAEEEQCABQThqQgA3AwAgAUEwakIANwMAIAFCADcDKCABQgA3AyAMAgsgAUEANgIwIAFBATYCJCABQcyngAE2AiAgAUIENwIoIAFBIGpB5KeAARDvLAALIAEgASkDiAE3AzggASABKQOAATcDMCABIAEpA3g3AyggASABKQNwNwMgCyABQdgAakIANwMAIAFB0ABqQgA3AwAgAUIANwNIIAFCADcDQAJAAkACQCABIAFBQGsQ+xsiA0H/AXFBAkcgA8BBAE5xRQRAIAFBIGogCCgCCBD7G8BBAEwNAQwCCyABQSBqIAgoAgQQ+xsiA0H/AXFBAkYgA8BBAEhyDQEgFiARIBdCAXwiEiAVIBJQrXwiE4RQrXwiFCARVK18IRYMAgsgF0IBfSESIBUgF1CtfSETIBEgFSAXhFCtIhV9IRQgFiARIBVUrX0hFgwBCyARIRQgFyESIBUhEwsgAUFAayASIBMgFCAWENYjIAEoAkBBAXFFDQIgASkDWCERIAcgASkDUDcDACAHIBE3AwggBUEgaiEFIAdBEGohByAJQQFqIQkgDEEBayIMDQALCyAPIAk2AgAgAUGQAWokAAwBC0HwrYABELI7AAsgBEEgaiQAIApBCGogDigCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDsGCAAIAsgDRDLHSAGQUBrJAAL5QgCDn8IfiMAQUBqIgYkACAGIAI2AgwgBkEQaiINIAEQkjYQ7iUgASgCFCECIAYgASgCECIBNgI0IAYgASACQWBxajYCOCAGIAZBDGo2AjwgBkEoaiEKIwBBIGsiAiQAIAJBFGogBkE0aiILIgEoAgQgASgCAGtBBXZBAEEQQSAQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEgayIEJAAgAkEIaiIFIAEoAgQgASgCAGtBBXYQ7y0gBSkCBCERIARBEGogAUEIaigCADYCACAEIAEpAgA3AwggBCARQiCJNwIYIAQgBUEIajYCFCMAQZABayIBJAAgBEEUaiIDKAIEIQkgAygCACAEQQhqIgcoAgAiBSAHKAIEIghHBEAgBygCCCEQIAMoAgggCUEFdGohByAIIAVrQQV2IQwDQCAFQRhqKQMAIRIgECgCACEIIAUpAwghEyAFKQMAIRQgASAFQRBqKQMAIhg3AxAgASASNwMYIAEgFDcDACABIBM3AwggAUFAayAUIBMgGCASIAgoAgAiAykDACADKQMIIAMpAxAgAykDGBCaCAJ+IAEtAEBBAUYEQCABLQBBBEBCgICAgICAgICAfyEWQgAhFUIAIRFCAAwCCyABQQA2AjAgAUEBNgIkIAFBzKeAATYCICABQgQ3AiggAUEgakHUp4ABEO8sAAsgASkDaCEWIAEpA2AhESABKQNYIRUgASkDUAshFyABQUBrIBQgEyAYIBIgAykDACADKQMIIAMpAxAgAykDGBCaCAJAIAEtAEBBAUYEQCABLQBBBEAgAUE4akIANwMAIAFBMGpCADcDACABQgA3AyggAUIANwMgDAILIAFBADYCMCABQQE2AiQgAUHMp4ABNgIgIAFCBDcCKCABQSBqQeSngAEQ7ywACyABIAEpA4gBNwM4IAEgASkDgAE3AzAgASABKQN4NwMoIAEgASkDcDcDIAsgAUHYAGpCADcDACABQdAAakIANwMAIAFCADcDSCABQgA3A0ACQAJAAkAgASABQUBrEPsbIgNB/wFxQQJHIAPAQQBOcUUEQCABQSBqIAgoAggQ+xvAQQBMDQEMAgsgAUEgaiAIKAIEEPsbIgNB/wFxQQJGIAPAQQBIcg0BIBYgESAXQgF8IhIgFSASUK18IhOEUK18IhQgEVStfCEWDAILIBdCAX0hEiAVIBdQrX0hEyARIBUgF4RQrSIVfSEUIBYgESAVVK19IRYMAQsgESEUIBchEiAVIRMLIAdBGGogFjcDACAHQRBqIBQ3AwAgByATNwMIIAcgEjcDACAFQSBqIQUgB0EgaiEHIAlBAWohCSAMQQFrIgwNAAsLIAk2AgAgAUGQAWokACAEQSBqJAAgCkEIaiAOKAIANgIAIAogAikCCDcCACACQSBqJAAgCyAKEO0YIAAgCyANEM4dIAZBQGskAAuaBAIMfwF+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSABKAIUIQIgBCABKAIQIgE2AjQgBCABIAJBYHFqNgI4IAQgBEEMajYCPCAEQShqIQsjAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBBXZBAEEIQQgQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDUEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIJJAAgA0EIaiIBIAUoAgQgBSgCAGtBBXYQ7C0gCSABKQIEQiCJNwIIIAkgAUEIajYCBCMAQSBrIggkACAJQQRqIgcoAgQhCiAHKAIAIQ4CQAJAIAUoAgAiBiAFKAIEIgJHBEAgBSgCCCEBIAcoAgggCkEDdGohByACIAZrQQV2IQIDQCAIIAYpAwAgBikDCCAGQRBqKQMAIAZBGGopAwAQ1iMgCCgCAEEBcUUNAiAIKQMYIAgpAxAiD0KAgICAgICAgIB/fSAPVK18UEUNAiAHIAEoAgApAwAgD343AwAgBkEgaiEGIAdBCGohByAKQQFqIQogAkEBayICDQALCyAOIAo2AgAgCEEgaiQADAELQYCugAEQsjsACyAJQRBqJAAgC0EIaiANKAIANgIAIAsgAykCCDcCACADQSBqJAAgBSALEL0YIAAgBSAMEMYdIARBQGskAAurBgIHfg5/IwBBQGoiCyQAIAsgAjYCDCALQRBqIhQgARCSNhDuJSABKAIUIQIgCyABKAIQIgE2AjQgCyABIAJBcHFqNgI4IAsgC0EMajYCPCALQShqIREjAEEgayICJAAgAkEUaiALQTRqIhMiCigCBCAKKAIAa0EEdkEAQRBBIBCgGCACKAIYIQEgAigCFEEBRgRAIAEgAigCHEHcj/8AEP0vAAsgAkEQaiIVQQA2AgAgAiACKAIcNgIMIAIgATYCCCMAQRBrIg8kACACQQhqIgEgCigCBCAKKAIAa0EEdhDvLSAPIAEpAgRCIIk3AgggDyABQQhqNgIEIwBBQGoiASQAIA9BBGoiDSgCBCEQIA0oAgAhFgJAAkAgCigCACIOIAooAgQiDEcEQCAKKAIIIRcgDSgCCCAQQQV0aiEKIAwgDmtBBHYhDQNAQoCAgICAgICAgH8hBgJ+AkACQCAOKQMAIgcgDikDCCIIQoCAgICAgICAgH+FhEIAUiAXKAIAIgwoAgAiEikDCCIEIBIpAwAiA4NCf1JyRQRAQgAhA0IAIQRCACEFDAELIAMgBIRQDQUgAUEQaiAHIAggAyAEEIMZIAEgASkDECIFIAEpAxgiBiADIAQQqB5CACAHIAEpAwAiCX0gAyAEg0J/USISGyEDQgAgCCABKQMIfSAHIAlUrX0gEhshBCAIQgBZDQELIAUgAyAMKAIIIgwpAwBYIAQgDCkDCCIDVyADIARRG60iA30hBCAGIAMgBVatfQwBCyAGIAUgAyAMKAIEIgwpAwBaIAQgDCkDCCIDWSADIARRG618IgQgBVStfAshBSABQSBqIAQgBRCyLiABKQMgIQQgASkDKCEFIAEpAzAhAyAKQRhqIAEpAzg3AwAgCkEQaiADNwMAIAogBTcDCCAKIAQ3AwAgDkEQaiEOIApBIGohCiAQQQFqIRAgDUEBayINDQALCyAWIBA2AgAgAUFAayQADAELQcSogAEQ4isACyAPQRBqJAAgEUEIaiAVKAIANgIAIBEgAikCCDcCACACQSBqJAAgEyAREO0YIAAgEyAUEM4dIAtBQGskAAv7BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASgCACAEENorIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAv4BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASAEEK0qIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAv7BQIGfwR+IwBBMGsiAyQAIAEoAiwhBSMAQbABayICJAACQCABKAIcIgQgASgCIEcEQAJAAn4CfgJAIAEoAgRFDQAgBCABKAIUTw0DIAEoAgggASgCECAEaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASAEQQFqNgIcQgAMAQsgASAEQQFqNgIcIAIgASgCACAEEI8sIAIoAgAhBCABKAIoIQYgASgCJCEBIAIgAigCBCIHNgIcIAIgBDYCGCACQSBqIAQgByABLAAAEMYBAkACfiACKAIgQQFGBEAgAkHoAGogAikCLDcDACACQfAAaiACQTRqKAIANgIAIAIgAikCJDcDYCACQZgBakHwroABKAIANgIAIAJB6K6AASkCADcDkAEgAkEDNgJ8IAJBxK6AATYCeCACQgI3AoQBIAJBrhA2AqwBIAJBzAE2AqQBIAIgAkGgAWo2AoABIAIgAkGQAWoiATYCqAEgAiACQRhqNgKgASACQdAAaiACQfgAahCZDiABEKoMIAJBgoCAgHg2AkwgAkHgAGoQiBEgAkEQaiACQdQAaigCADYCACACIAIpAkw3AwggAikCWAwBCyACQSBqIAIpAzAiCCACKQM4IgkgBi0AABCtDiACKAIgQZOAgIB4Rg0BIAJBEGogAkEoaigCADYCACACIAIpAiA3AwggAikCLAshCCAFKAIAQZOAgIB4RwRAIAUQiBELIAUgAikDCDcCACAFIAg3AgwgBUEIaiACQRBqKAIANgIAQgIhCkIADAILQgELIQpCAAshCyADIAg3AxAgAyAKNwMAIAMgCTcDGCADIAs3AwgMAgtB9KeAAUEgQZSogAEQnykACyADQgA3AwggA0IDNwMACyACQbABaiQAAkAgAykDCCIIIAMpAwAiCUIDhYRQIAlCAoUgCIRQckUEQCADKQMYIQogACADKQMQNwMQIAAgCTcDACAAIAo3AxggACAINwMIDAELIABCADcDCCAAQgI3AwALIANBMGokAAuTBAEJfyMAQRBrIgckAAJAIAJFDQAgASACakEBayIDRQ0AIAMtAABBMGtB/wFxQQlLDQAgB0EIaiEJQQAhAyMAQSBrIgUkAAJAAkACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIEciEDAkAgBEUEQCACIANGBEBBASEDDAMLIANBAnIiBCACIAIgBEsbIQQDQCACIANGDQIgBUEYaiABIANqLQAAEJAaIAUtABhFDQMgBS0AGSAGQQpsaiEGIAQgA0EBaiIDRw0ACyAEIQMMAgtBASEEIAIgA0YEQEEBIQMMBAsDQCAFQRBqIAEgA2otAAAQkBogBS0AEEUNBCAEIAUtABFFcSEEIANBAWoiAyACRw0ACwwCCyACIAJBsPOAARDDIQALQQEhBCACIANGDQAgAyACIAIgA0kbIQoDQCADIApGDQMgBUEIaiABIANqLQAAEJAaIAUtAAhFDQIgBCEIQQAhBAJAIAhFDQAgBkH/AXFBCmwiCEEIdg0AIAUtAAkiBiAIQf8BcWoiBEH/AXEgBEYhBCAGIAhqIQYLIAIgA0EBaiIDRw0ACwsgAiEDCyAJIAM2AgQgCSAGOgABIAkgBDoAACAFQSBqJAAMAQsgCiACQcDzgAEQwyEACyAHLQAIQQFHDQAgBygCDCACRw0AQQEhCyAHLQAJIQELIAAgAToAASAAIAs6AAAgB0EQaiQAC6oFAQp/IwBBEGsiCCQAAkAgAkUNACABIAJqQQFrIgNFDQAgAy0AAEEwa0H/AXFBCUsNACAIQQhqIQojAEEgayIFJAACQAJAAkAgAkUNACABLQAAIgNBK0YgA0EtRiIDciEEAkAgAwRAQQEhB0EBIQMgAiAERg0BQQMgAiACQQNPGyEDA0ACQCACIARHBEAgBUEQaiABIARqLQAAEJAaIAUtABANASAEIQMMBAsgAiACQdDzgAEQwyEACyAGQQpsIAUtABFrIQYgAyAEQQFqIgRHDQALDAELIAIgBEYEQEEBIQQMAgsgBEECciIDIAIgAiADSxshAwJAA0AgAiAERg0BIAVBGGogASAEai0AABCQGiAFLQAYRQ0DIAUtABkgBkEKbGohBiADIARBAWoiBEcNAAsgAyEEDAILIAIgAkGw84ABEMMhAAsgAiADRg0BIAMgAiACIANJGyEJA0AgAyAJRwRAIAVBCGogASADai0AABCQGiAFLQAIRQ0EIAchBEEAIQcCQCAERQ0AIAbAQQpsIgvAIgQgC0cNACAEIAUtAAnAayIGwCAGRiEHCyACIANBAWoiA0cNAQwDCwsgCSACQeDzgAEQwyEAC0EBIQcgAiAERg0AIAQgAiACIARJGyEJA0ACQCAEIAlHBEAgBSABIARqLQAAEJAaIAUtAAANASAEIQMMBAsgCSACQcDzgAEQwyEACyAHIQNBACEHAkAgA0UNACAGwEEKbCILwCIDIAtHDQAgAyAFLQABwGoiBsAgBkYhBwsgAiAEQQFqIgRHDQALCyACIQMLIAogAzYCBCAKIAY6AAEgCiAHOgAAIAVBIGokACAILQAIQQFHDQAgCCgCDCACRw0AQQEhDCAILQAJIQELIAAgAToAASAAIAw6AAAgCEEQaiQAC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGE/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANB/PuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2zxHDQELIANBKGpBgPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQfj6gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDbPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQYuWrNgANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQouWrNiw4cKFCzcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakGEiJAgNgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoSIkKDAgIGCBDcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGQ/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBiPyDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvJAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEoAghHDQELIANBKGpBhoyYMDYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KGjJiw4MCBgwY3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABKAIINgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpBqPyDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQaD8gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQdT7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HM+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGPnrz4ADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KPnrz48OHDhw83AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2jxHDQELIANBKGpBvPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQbT7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDaPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQez7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Hk+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakGIkKDAADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KIkKDAgIGChAg3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENs8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpB+PuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQfD7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQZj7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0GQ+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDbPEcNAQsgA0EoakHg+4MBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANB2PuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENs8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2jxHDQELIANBKGpBjPuDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQYT7gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDaPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQcj7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HA+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDZPEcNAQsgA0EoakGHjpw4NgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoeOnLjw4MGDBzcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEQ2Tw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDcPEcNAQsgA0EoakGc/IMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBlPyDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENw8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2TxHDQELIANBKGpBipSo0AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCipSo0KDBgoUKNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDZPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQaT7gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Gc+4MBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGw+4MBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANBqPuDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2zxHDQELIANBKGpBjpy48AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCjpy48ODBg4cONwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDbPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQfT6gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0Hs+oMBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2Dw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakHQ+oMBKAIANgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADIAEpAgA3AiwgAyACKQIANwM4IANByPqDASkCADcDICAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpB6PqDASgCADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgAyABKQIANwIsIAMgAikCADcDOCADQeD6gwEpAgA3AyAgBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALyQMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENg8Rw0BCyADQShqQYWKlCg2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANChYqUqNCgwYIFNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALygMBBX8jAEHQAGsiBCQAIARBCGohBSMAQdAAayIDJAACQAJAIAIoAgAiBgRAIAIoAhAiByABENs8Rw0BCyADQShqQdz6gwEoAgA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIAMgASkCADcCLCADIAIpAgA3AzggA0HU+oMBKQIANwMgIAUgA0EgakEw/AoAAAwBCyADIAEQ2zw2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8kDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgASgCCEcNAQsgA0EoakGChIgQNgIAIANBNGogAUEIaigCADYCACADQUBrIAJBCGopAgA3AwAgA0HIAGogAkEQaikCADcDACADQoKEiJCgwICBAjcDICADIAEpAgA3AiwgAyACKQIANwM4IAUgA0EgakEw/AoAAAwBCyADIAEoAgg2AgggAyAHNgIMIANBAjYCJCADQbj6gwE2AiAgA0ICNwIsIANBOzYCHCADQTs2AhQgAyADQRBqNgIoIAMgA0EMajYCGCADIANBCGo2AhAgBUEIaiADQSBqEJkOIAVBKToAACAFQY2AgIB4NgIEIAYgBigCACIGQQFrNgIAIAZBAUYEQCACEPseCyABKAIAIgIgAigCACICQQFrNgIAIAJBAUcNACABEPseCyADQdAAaiQAIAQtAAhBKUcEQCAAIAVBMPwKAAAgBEHQAGokAA8LIARByABqIARBHGooAgA2AgAgBEFAayAEQRRqKQIANwMAIAQgBCkCDDcDOEGc/oMBQSsgBEE4akGM/oMBQeT5gwEQ1R4AC8oDAQV/IwBB0ABrIgQkACAEQQhqIQUjAEHQAGsiAyQAAkACQCACKAIAIgYEQCACKAIQIgcgARDYPEcNAQsgA0EoakGJkqTIADYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KJkqTIkKHChAk3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENg8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvJAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2TxHDQELIANBKGpBg4aMGDYCACADQTRqIAFBCGooAgA2AgAgA0FAayACQQhqKQIANwMAIANByABqIAJBEGopAgA3AwAgA0KDhoyYsODAgQM3AyAgAyABKQIANwIsIAMgAikCADcDOCAFIANBIGpBMPwKAAAMAQsgAyABENk8NgIIIAMgBzYCDCADQQI2AiQgA0G4+oMBNgIgIANCAjcCLCADQTs2AhwgA0E7NgIUIAMgA0EQajYCKCADIANBDGo2AhggAyADQQhqNgIQIAVBCGogA0EgahCZDiAFQSk6AAAgBUGNgICAeDYCBCAGIAYoAgAiBkEBazYCACAGQQFGBEAgAhD7HgsgASgCACICIAIoAgAiAkEBazYCACACQQFHDQAgARD7HgsgA0HQAGokACAELQAIQSlHBEAgACAFQTD8CgAAIARB0ABqJAAPCyAEQcgAaiAEQRxqKAIANgIAIARBQGsgBEEUaikCADcDACAEIAQpAgw3AzhBnP6DAUErIARBOGpBjP6DAUHk+YMBENUeAAvKAwEFfyMAQdAAayIEJAAgBEEIaiEFIwBB0ABrIgMkAAJAAkAgAigCACIGBEAgAigCECIHIAEQ2DxHDQELIANBKGpBjJiw4AA2AgAgA0E0aiABQQhqKAIANgIAIANBQGsgAkEIaikCADcDACADQcgAaiACQRBqKQIANwMAIANCjJiw4MCBg4YMNwMgIAMgASkCADcCLCADIAIpAgA3AzggBSADQSBqQTD8CgAADAELIAMgARDYPDYCCCADIAc2AgwgA0ECNgIkIANBuPqDATYCICADQgI3AiwgA0E7NgIcIANBOzYCFCADIANBEGo2AiggAyADQQxqNgIYIAMgA0EIajYCECAFQQhqIANBIGoQmQ4gBUEpOgAAIAVBjYCAgHg2AgQgBiAGKAIAIgZBAWs2AgAgBkEBRgRAIAIQ+x4LIAEoAgAiAiACKAIAIgJBAWs2AgAgAkEBRw0AIAEQ+x4LIANB0ABqJAAgBC0ACEEpRwRAIAAgBUEw/AoAACAEQdAAaiQADwsgBEHIAGogBEEcaigCADYCACAEQUBrIARBFGopAgA3AwAgBCAEKQIMNwM4QZz+gwFBKyAEQThqQYz+gwFB5PmDARDVHgALegEDfyMAQSBrIgUkACAFIAM3AxggBSACNwMQIAUgATcDCCAFIAA3AwACQCAEQf8BcSIEQcwASw0AIAUgBEEFdCIEQcCnhQFqEPsbIgdB/wFxQQJGIAfAQQBIcg0AIAUgBEGglIUBahD7G8BBAEwhBgsgBUEgaiQAIAYL4wQBCH8jAEEwayIDJAAgA0EDNgIMIANB/I+GATYCCCADQgI3AhQgA0HHAjYCLCADQeyPhgE2AiggA0HHAjYCJCADQcyOhgE2AiAgAyADQSBqNgIQQQEhCAJAIAEoAgAgASgCBCADQQhqEMsKDQAjAEFAaiICJAACQAJAIAAoAhRBAnYiCUEBayIFRQ0AQQogBSAFQQpPGyEHAkADQAJAIAAgBBCWJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIAXIAIoAhAgAigCFCABEMUjDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByAEQQFqIgRHDQALIAVBC0kNASAFQRVPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgCUEVazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAlBC2siBCAHIAQgB0sbIgQgBU8NAQNAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQgBcgAigCCCACKAIMIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAEQQFqIgQgBUcNAAsMAQtBASEGDAELQQAhBgsgAkFAayQAIAYNACABKAIAQZSQhgFBASABKAIEKAIMEQYAIQgLIANBMGokACAIC+0EAQh/IwBBMGsiAyQAIANBAzYCDCADQfyPhgE2AgggA0ICNwIUIANBxwI2AiwgA0HcjoYBNgIoIANBxwI2AiQgA0HMjoYBNgIgIAMgA0EgajYCEEEBIQgCQCABKAIAIAEoAgQgA0EIahDLCg0AIwBBQGoiAiQAAkACQCAAKAIUQQJ2IglBAWsiBUUNAEEKIAUgBUEKTxshBwJAA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQRBqIAAgBBD/FiACIAIpAxA3AhwgAkEcaiABELI2DQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgByAEQQFqIgRHDQALIAVBC0kNASAFQRVPBEAgAkECNgIgIAJB4MOEATYCHCACQgE3AiggAkE7NgI4IAIgCUEVazYCPCACIAJBNGo2AiQgAiACQTxqNgI0IAEoAgAgASgCBCACQRxqEMsKDQELIAlBC2siBCAHIAQgB0sbIgQgBU8NAQNAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEIaiAAIAQQ/xYgAiACKQMINwIcIAJBHGogARCyNg0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgL7QQBCH8jAEEwayIDJAAgA0EDNgIMIANB/I+GATYCCCADQgI3AhQgA0HHAjYCLCADQdyOhgE2AiggA0HHAjYCJCADQdyPhgE2AiAgAyADQSBqNgIQQQEhCAJAIAEoAgAgASgCBCADQQhqEMsKDQAjAEFAaiICJAACQAJAIAAoAhRBA3YiCUEBayIFRQ0AQQogBSAFQQpPGyEHAkADQAJAIAAgBBCWJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEPEWIAIgAikDEDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAJQRVrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgCUELayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBDxFiACIAIpAwg3AhwgAkEcaiABELI2DQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBEEBaiIEIAVHDQALDAELQQEhBgwBC0EAIQYLIAJBQGskACAGDQAgASgCAEGUkIYBQQEgASgCBCgCDBEGACEICyADQTBqJAAgCAvjBAEIfyMAQTBrIgMkACADQQM2AgwgA0H8j4YBNgIIIANCAjcCFCADQccCNgIsIANB7I+GATYCKCADQccCNgIkIANB3I+GATYCICADIANBIGo2AhBBASEIAkAgASgCACABKAIEIANBCGoQywoNACMAQUBqIgIkAAJAAkAgACgCFEEDdiIJQQFrIgVFDQBBCiAFIAVBCk8bIQcCQANAAkAgACAEEJYlRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQ8hYgAigCECACKAIUIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAJQRVrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgCUELayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQliVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBDyFiACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgL0wQBB38jAEEwayIDJAAgA0ECNgIQIANB0KKGATYCDCADQgE3AhggA0GcAzYCKCADIAAoAjQ2AiwgAyADQSRqNgIUIAMgA0EsajYCJEEBIQgCQCABKAIAIAEoAgQgA0EMahDLCg0AIwBBQGoiAiQAAkACQCAAKAIwIgVFDQBBCiAFIAVBCk8bIQcCQANAAkAgACAEEJslRQRAQQEhBiABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQoBsgAigCECACKAIUIAEQxSMNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIARBAWoiBEcNAAsgBUELSQ0BIAVBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAFQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBUEKayIEIAcgBCAHSxsiBCAFTw0BA0ACQCAAIAQQmyVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgBBCgGyACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBB4KKGAUEBIAEoAgQoAgwRBgAhCAsgA0EwaiQAIAgLwgYBDX8jAEEwayIDJAAgA0ECNgIQIANBmKiGATYCDCADQgE3AhggA0GcAzYCKCADIAAoAiw2AiwgAyADQSRqNgIUIAMgA0EsajYCJEEBIQ0CQCABKAIAIAEoAgQgA0EMahDLCg0AIwBBQGoiAiQAAkACQCAAKAIwIgZFDQBBCiAGIAZBCk8bIQUgACgCDEEIaiEOIAAoAhAhCyAAKAIsIQkCQANAAkAgACAEEJolRQRAQQEhDCABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAOIAsoAghBAWtBeHFqIAggCSALKAIgEQUAIAIgAigCFCIKNgIgIAIgAigCECIHNgIcIAcgCigCCEEBa0F4cWpBCGogASAKKAIMEQIAIAcgBygCACIHQQFrNgIAIAdBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAggCWohCCAFIARBAWoiBEcNAAsgBkELSQ0BIAZBFU8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAGQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBkEKayIEIAUgBCAFSxsiBCAGTw0BIAAoAiwiByAEbCEIIAAoAgxBCGohCiAAKAIQIQsDQAJAIAAgBBCaJUUEQEEBIQwgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogCiALKAIIQQFrQXhxaiAIIAcgCygCIBEFACACIAIoAgwiCTYCICACIAIoAggiBTYCHCAFIAkoAghBAWtBeHFqQQhqIAEgCSgCDBECACAFIAUoAgAiBUEBazYCACAFQQFGBEAgAkEcahC7IwsNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAHIAhqIQggBEEBaiIEIAZHDQALDAELQQEhDAwBC0EAIQwLIAJBQGskACAMDQAgASgCAEHgooYBQQEgASgCBCgCDBEGACENCyADQTBqJAAgDQt4AQN/IwBBEGsiAiQAAkAgASgCCCIDBEAgAkEIaiABKAIEEMUbIAIoAgwiAyABKAIoIgFJDQEgAigCCCEEIAAgAyABazYCBCAAIAQgAUEDdGo2AgAgAkEQaiQADwtBACADQbDkhgEQwyEACyABIANBwOSGARCvOwALeAEDfyMAQRBrIgIkAAJAIAEoAggiAwRAIAJBCGogASgCBBDGGyACKAIMIgMgASgCKCIBSQ0BIAIoAgghBCAAIAMgAWs2AgQgACAEIAFBAXRqNgIAIAJBEGokAA8LQQAgA0Gw5IYBEMMhAAsgASADQcDkhgEQrzsAC3gBA38jAEEQayICJAACQCABKAIIIgMEQCACQQhqIAEoAgQQmyQgAigCDCIDIAEoAigiAUkNASACKAIIIQQgACADIAFrNgIEIAAgBCABQQN0ajYCACACQRBqJAAPC0EAIANBsOSGARDDIQALIAEgA0HA5IYBEK87AAt4AQN/IwBBEGsiAiQAAkAgASgCCCIDBEAgAkEIaiABKAIEEMgbIAIoAgwiAyABKAIoIgFJDQEgAigCCCEEIAAgAyABazYCBCAAIAQgAUEEdGo2AgAgAkEQaiQADwtBACADQbDkhgEQwyEACyABIANBwOSGARCvOwALgQEBAn8jAEEQayIDJAACQCABKAIIIgQgAksEQCADQQhqIAEoAgQgAkEMbGoQxxsgAygCDCICIAEoAigiAUkNASADKAIIIQQgACACIAFrNgIEIAAgBCABQQJ0ajYCACADQRBqJAAPCyACIARBsOSGARDDIQALIAEgAkHA5IYBEK87AAt2AQN/IAAoAkwgAWoiAUEDdiABQQdxQQBHaiIBIAAoAgwiAksEQCABIAJrIQQgACgCBCIDIAFJBEAgACADQQF0IgIgARDeKiIDIAIgA0sbEOgZIAAoAgwhAgsgBARAIAAoAgggAmpBACAE/AsACyAAIAE2AgwLC4MBAQV/IwBBEGsiAiQAIAEoAgQhBSACQQRqIAEoAggiAUEAQQRBBBCgGCACKAIIIQMgAigCBEEBRwRAIAIoAgwhBCABQQJ0IgYEQCAEIAUgBvwKAAALIAAgATYCCCAAIAQ2AgQgACADNgIAIAJBEGokAA8LIAMgAigCDEGwoogBEP0vAAt7AQF/IwBBIGsiAiQAAn8gACgCAEGAgICAeEcEQCABIAAoAgQgACgCCBD7NQwBCyACQRBqIAAoAgwoAgAiAEEIaikCADcDACACQRhqIABBEGopAgA3AwAgAiAAKQIANwMIIAEoAgAgASgCBCACQQhqEMsKCyACQSBqJAALkQEBAX8CQAJAAkACQCAALQCIAw4EAAMDAQMLIAAtALgBQQNGBEAgAEEIahD1LAsgACgCgAMiAUGEAU8EQCABEPIfCyAAKAKEAyIAQYMBSw0BDAILIAAtAPgCQQNGBEAgAEHIAWoQ9SwLIAAoAoADIgFBhAFPBEAgARDyHwsgACgChAMiAEGDAU0NAQsgABDyHwsL2wICBX8CfiMAQdACayIEJAAgBEEIaiAAEJUaIAQgASACEPooIARBpAFqIAQoAgAgBCgCBBCPNSADQQhPBEBB5ILDAEEZEJc9AAsjAEGwAWsiAiQAIAJBDGoiBSAEQaQBahCkKCACQRhqIgAgBEEIakGYAfwKAAAgBEG4AWogA0H/AXFBAnQiAUH8g8MAaigCACEDIAFB3IPDAGooAgAhByMAQUBqIgEkACABIABBQGsgBRCvEAJ/IAEoAggiBUGAgICAeEcEQCABKAIUIAEpAwAgASkCDCEKIAFBgoSMyAA2AjggAUEINgIwIAFBADYCKCABQgA3AxAgASAKNwIEIAEgBTYCACABENkTDAELIAEoAgALIgVBDGsgBzYCACAFQRBrIAM2AgAgAEGYAfwKAAAgAUFAayQAIAJBsAFqJAAgBEEANgKwASAEQbABahDRKUEIaiAEQdACaiQAC4EBAQF/IAAoAgAiACgCCCIBBEAgAEEUaiAAKAIMIAAoAhAgASgCEBEBAAsgACgCHCIBBEAgACgCICABKAIMEQMACyAAKAIoIgEEQCAAKAIsIAEoAgwRAwALAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQThBBBD4OgsLfgEBfyAAKAIAIgBBKGoiARCfLCABEPM7IAAoAjRBgICAgHhHBEAgAEE0ahDqOwsgACgCRCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHEAGoQhh8LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQcgAQQgQ+DoLC4MBAQJ/IAAoAgAiAEEMaiIBENIkIAAoAgwiAiACKAIAQQFrIgI2AgAgAkUEQCABENQiCwJAIAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDpJwsCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBFEEEEPg6Cwv1AQEDfyMAQRBrIgIkAAJAAkAgAUUEQAJAAkAgAARAIABBCGsiASgCAEEBRw0BIAAoAgghAyAAKAIEIQQgAUEANgIAAkAgAUF/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIAFBFEEEEPg6CyACIAM2AgQgAiAENgIADAILEJg9AAtBzMjMAEE/EJc9AAsgAigCBCEAIAIoAgAiARCHNSABQcAAQQgQ+DogABCINSAAQTBBCBD4OgwBCyAARQ0BIAIgAEEIayIANgIMIAAgACgCAEEBayIANgIAIAANACACQQxqEO4mCyACQRBqJAAPCxCYPQALfQEBfyMAQRBrIgIkAAJAAkAgAUUEQCACIAAQzCEiADYCCCAAIAAoAgAiAEEBazYCACAAQQFHDQEgAkEIahD4IwwBCyAARQ0BIAIgAEEIayIANgIMIAAgACgCAEEBayIANgIAIAANACACQQxqEIQmCyACQRBqJAAPCxCYPQALhQEBA38CQAJAIAEoAhQiAyACpyIESwRAIAEoAhAgBEEDdGoiAygCBCIEIAMoAgAiA0kNASAEIAEoAggiBUsNAiABKAIEIQEgACAEIANrNgIEIAAgASADajYCAA8LIAQgA0GA+M0AEMMhAAsgAyAEQZD4zQAQsTsACyAEIAVBkPjNABCwOwALewECfyMAQSBrIgMkACADQQhqIAEgASgCQCIEIAIgAiAESxsQ3Q4gAygCDCECAkAgAygCCCIEQQhHBEAgACADKQMQNwMIIABBEGogA0EYaikDADcDAAwBCyABIAEoAkAgAms2AkALIAAgBDYCACAAIAI2AgQgA0EgaiQAC4MBAQF/IwBBMGsiBCQAIAQgAjYCDCAEIAE2AghBBCECIAAgAy0AAEECRgR/IARBATYCFCAEQeyOzwA2AhAgBEIBNwIcIARBzAE2AiwgBCAEQShqNgIYIAQgBEEIajYCKCAAQQRqIARBEGoQmQ4gAEEAOgAQQQEFIAILNgIAIARBMGokAAuHAQEBfyMAQTBrIgQkACAEIAI2AgwgBCABNgIIQQQhAiAAIAMoAgBBgICAgHhGBH8gBEEBNgIUIARB7I7PADYCECAEQgE3AhwgBEHMATYCLCAEIARBKGo2AhggBCAEQQhqNgIoIABBBGogBEEQahCZDiAAQQA6ABBBAQUgAgs2AgAgBEEwaiQAC4MBAQF/IwBBMGsiBCQAIAQgAjYCDCAEIAE2AghBBCECIAAgAy0AAEEDRgR/IARBATYCFCAEQeyOzwA2AhAgBEIBNwIcIARBzAE2AiwgBCAEQShqNgIYIAQgBEEIajYCKCAAQQRqIARBEGoQmQ4gAEEAOgAQQQEFIAILNgIAIARBMGokAAtnAQJ/IAAoAggiAgRAIAAoAgRBQGshAANAIABBFGoQ3jsCQCAAKAIAIgFBEkYNAEEQIAFBAmsgAUEBTRsiAUEPSQ0AQQhBBCABQQ9HGyAAahCGMAsgAEHgAGohACACQQFrIgINAAsLC4kBAQN/EKkvIQUQqi8iA0IANwIUIANCgICAgMAANwIMIANBADoACCADQoKAgIAQNwIAIAUgAzYCACACKAIAIgIgAigCACIEQQFqNgIAAkAgBEEASA0AIAEoAggoAgAiASABKAIAIgRBAWo2AgAgBEEASA0AIAAgAiABIAUQnAMgACADNgKwBQ8LAAuYAQEBfyMAQRBrIgIkAAJ/AkACQAJAAkAgACgCACIAKAIAQQFrDgMBAgMACyACIABBCGo2AgwgAUHgzNEAQQ5B7szRAEEIIABBBGpBwMzRAEH2zNEAQQYgAkEMakHQzNEAEI4YDAMLIAFB/MzRAEESEPs1DAILIAFBjs3RAEETEPs1DAELIAFBoc3RAEEREPs1CyACQRBqJAALgAECAX8BfiMAQSBrIgQkACAEQgA3AwAgAUEHTQRAIARBADYCGCAEQQE2AgwgBEHA/9EANgIIIARCBDcCECAEQQhqQbiO0gAQ7ywACyAEQQggAEEIQciO0gAQ1SwgBCkDACAEQSBqJAAgA0E4bEE4ca2GQr3P1vEBfiACQT9xrYinC4YBAQJ/IwBBIGsiAiQAAn8gAC8BACIDQQJNBEAgASADQQJ0IgBBxPH+AGooAgAgAEG48f4AaigCABD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfULNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAuGAQECfyMAQSBrIgIkAAJ/IAAvAQAiA0EDTQRAIAEgA0ECdCIAQeDx/gBqKAIAIABB0PH+AGooAgAQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALhgEBAn8jAEEgayICJAACfyAALwEAIgNBAk0EQCABIANBAnQiAEH88f4AaigCACAAQfDx/gBqKAIAEPs1DAELIAJBAjYCBCACQeDu/gA2AgAgAkIBNwIMIAJB9Qs2AhwgAiAANgIYIAIgAkEYajYCCCABKAIAIAEoAgQgAhDLCgsgAkEgaiQAC4YBAQJ/IwBBIGsiAiQAAn8gAC0AACIDQRpNBEAgASADQQJ0IgBB9PL+AGooAgAgAEGI8v4AaigCABD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfYLNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAuGAQECfyMAQSBrIgIkAAJ/IAAtAAAiA0EFTQRAIAEgA0ECdCIAQfT//gBqKAIAIABB3P/+AGooAgAQ+zUMAQsgAkECNgIEIAJBlP/+ADYCACACQgE3AgwgAkGADDYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALkQEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC47Di8bKTqs3WAIUgASkDGEKw3+Dy+LaU9Id/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC8vypnuWPoZ0rhSABKQMYQtmLjbqZvu3vr3+FhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEELut8rBy8Ln6Ll/hSABKQMYQvCO45ubiNaLEYWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC48BAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQqSv9PqoqZ2QLYUgASkDGELjrPqF49vQ9WyFhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEELMtKL9lYSLoWSFIAEpAxhC/oqN/Lqw25rcAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQofA7OjEzr/RyQCFIAEpAxhCvr+ev6/DpIL4AIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5ABAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQof529rX0fyYPIUgASkDGEK27+i19KWCvpZ/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBC3KeGzZSXyb2Wf4UgASkDGEKF8OaFkNqf4wyFhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuQAQEBfyMAQSBrIgEkACABQQhqIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIQEQAAIAFBEGogASgCCCIAIAEoAgwoAgwRAAACQCAABEAgASkDEEKfwr6izL/IoCGFIAEpAxhC1sWUxpj99dj4AIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQsmQrefTvtn4nH+FIAEpAxhC8fLKq+fn0cbCAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQo2j65PMtMaQ9wCFIAEpAxhC2avs9tngxfSMf4WEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5EBAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQvv22Orw4o2fxgCFIAEpAxhCmYalv/ivoY7SAIWEUA0BC0HE+YMBQQ9B1PmDARDLJAALIAFBIGokACAAC5ABAQF/IwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAAAJAIAAEQCABKQMQQtHx98ycuun+ToUgASkDGELWwo+ZmLzyo/EAhYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkQEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBCtcP+voycqqbDAIUgASkDGEKS+8eQvuyY/qN/hYRQDQELQcT5gwFBD0HU+YMBEMskAAsgAUEgaiQAIAALkAEBAX8jAEEgayIBJAAgAUEIaiAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogACgCEBEAACABQRBqIAEoAggiACABKAIMKAIMEQAAAkAgAARAIAEpAxBCmcTpt9SjhcVuhSABKQMYQpiWydPQ9J6WrX+FhFANAQtBxPmDAUEPQdT5gwEQyyQACyABQSBqJAAgAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABC9JUUEQCABQShqQYiQoMAANgIAIAFCiJCgwICBgoQINwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQviVFBEAgAUEoakGMmLDgADYCACABQoyYsODAgYOGDDcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEL8lRQRAIAFBKGpBiZKkyAA2AgAgAUKJkqTIkKHChAk3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuUAQEBfyMAQUBqIgEkACABIAA2AgQgABDAJUUEQCABQShqQYSIkCA2AgAgAUKEiJCgwICBggQ3AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDBJUUEQCABQShqQYuWrNgANgIAIAFCi5as2LDhwoULNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlQEBAX8jAEFAaiIBJAAgASAANgIEIAAQwiVFBEAgAUEoakGOnLjwADYCACABQo6cuPDgwYOHDjcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5QBAQF/IwBBQGoiASQAIAEgADYCBCAAEMMlRQRAIAFBKGpBhYqUKDYCACABQoWKlKjQoMGCBTcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5QBAQF/IwBBQGoiASQAIAEgADYCBCAAEMQlRQRAIAFBKGpBh46cODYCACABQoeOnLjw4MGDBzcDICABQQI2AgwgAUHgyIQBNgIIIAFCAjcCFCABQacENgI8IAFBrQM2AjQgASABQTBqNgIQIAEgAUEEajYCOCABIAFBIGo2AjAgAUEIakHwyIQBEO8sAAsgAUFAayQAC5UBAQF/IwBBQGoiASQAIAEgADYCBCAAEMUlRQRAIAFBKGpBj568+AA2AgAgAUKPnrz48OHDhw83AyAgAUECNgIMIAFB4MiEATYCCCABQgI3AhQgAUGnBDYCPCABQa0DNgI0IAEgAUEwajYCECABIAFBBGo2AjggASABQSBqNgIwIAFBCGpB8MiEARDvLAALIAFBQGskAAuVAQEBfyMAQUBqIgEkACABIAA2AgQgABDGJUUEQCABQShqQYqUqNAANgIAIAFCipSo0KDBgoUKNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQxyVFBEAgAUEoakGDhowYNgIAIAFCg4aMmLDgwIEDNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQyCVFBEAgAUEoakGChIgQNgIAIAFCgoSIkKDAgIECNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALlAEBAX8jAEFAaiIBJAAgASAANgIEIAAQySVFBEAgAUEoakGGjJgwNgIAIAFChoyYsODAgYMGNwMgIAFBAjYCDCABQeDIhAE2AgggAUICNwIUIAFBpwQ2AjwgAUGtAzYCNCABIAFBMGo2AhAgASABQQRqNgI4IAEgAUEgajYCMCABQQhqQfDIhAEQ7ywACyABQUBrJAALgAEBAX8jAEHQAGsiBiQAIAYgASACIAMgBCAFEOQHIAYtAABBKUcEQCAAIAZBOPwKAAAgBkHQAGokAA8LIAZByABqIAZBFGooAgA2AgAgBkFAayAGQQxqKQIANwMAIAYgBikCBDcDOEGsz4UBQSsgBkE4akGcz4UBQaDVhQEQ1R4AC4ABAQF/IwBB0ABrIgYkACAGIAEgAiADIAQgBRDlByAGLQAAQSlHBEAgACAGQTj8CgAAIAZB0ABqJAAPCyAGQcgAaiAGQRRqKAIANgIAIAZBQGsgBkEMaikCADcDACAGIAYpAgQ3AzhBrM+FAUErIAZBOGpBnM+FAUGg1YUBENUeAAveBQEKfyMAQTBrIgMkACADQgE3AgggA0ECNgIUIANB3NqFATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCgJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAhxBAnYiC0EBayIHRQ0AQQogByAHQQpPGyEGAkADQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACAEEIAZIAIgAigCFCIJNgIgIAIgAigCECIFNgIcIAUgCSgCCEEBa0F4cWpBCGogASAJKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIAYgBEEBaiIERw0ACyAHQQtJDQEgB0EVTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAtBFWs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyALQQtrIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCSJUUEQEEBIQggASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEEIAZIAIgAigCDCIFNgIgIAIgAigCCCIGNgIcIAYgBSgCCEEBa0F4cWpBCGogASAFKAIMEQIAIAYgBigCACIGQQFrNgIAIAZBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQgMAQtBACEICyACQUBrJAAgCA0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCgsgA0EwaiQAIAoLjQEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQcTnhQEpAgA3AiggAEEwakHM54UBKAIANgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEQQRAQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABB9OeFASkCADcCKCAAQTBqQfznhQEoAgA2AgAgAkEQaiQAC40BAQN/IwBBEGsiAiQAIAJBBGogAUEAQQhBCBCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEGA6IUBKQIANwIoIABBMGpBiOiFASgCADYCACACQRBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBEEEgEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQcjohQEpAgA3AiggAEEwakHQ6IUBKAIANgIAIAJBEGokAAveBQEKfyMAQTBrIgMkACADQgE3AgggA0ECNgIUIANB9JaGATYCECADQgE3AhwgA0HHAjYCLCADIANBKGo2AhggAyADQQhqNgIoQQEhCwJAIAEoAgAgASgCBCADQRBqEMsKDQAjAEFAaiICJAACQAJAIAAoAigiBUEESQ0AQQogBUECdiIHIAdBCk8bIQYCQANAAkAgACAEEJclRQRAQQEhCSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEQaiAAIAQQtBkgAiACKAIUIgo2AiAgAiACKAIQIgg2AhwgCCAKKAIIQQFrQXhxakEIaiABIAooAgwRAgAgCCAIKAIAIghBAWs2AgAgCEEBRgRAIAJBHGoQuyMLDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBiAEQQFqIgRHDQALIAVBLEkNASAFQdQATwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAdBFGs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyAHQQprIgQgBiAEIAZLGyIEIAdPDQEDQAJAIAAgBBCXJUUEQEEBIQkgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACAEELQZIAIgAigCDCIGNgIgIAIgAigCCCIFNgIcIAUgBigCCEEBa0F4cWpBCGogASAGKAIMEQIAIAUgBSgCACIFQQFrNgIAIAVBAUYEQCACQRxqELsjCw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIARBAWoiBCAHRw0ACwwBC0EBIQkMAQtBACEJCyACQUBrJAAgCQ0AIAEoAgBBlJCGAUEBIAEoAgQoAgwRBgAhCwsgA0EwaiQAIAsLfAECfyAAQRhqEMoMIAAQxScgAEEEQQwQ4B4gACgCFCICBEAgACgCECEBA0AgARClHiABQcQAaiEBIAJBAWsiAg0ACwsgAEEMakEEQcQAEOAeAkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwt8AQJ/IABBGGoQywwgABDFJyAAQQRBDBDgHiAAKAIUIgIEQCAAKAIQIQEDQCABEKUeIAFBxABqIQEgAkEBayICDQALCyAAQQxqQQRBxAAQ4B4CQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LC3gBBH8gASgCBCABKAIAayIDIAAoAgAgACgCCCICa0sEQCAAIAIgA0EBQQEQ3CggACgCCCECCyAAIAEoAgQiBCABKAIAIgNHBH8gBCADayIFBEAgACgCBCACaiABIANqQQhqIAX8CgAACyACIARqIANrBSACCzYCCAvhAQEFfyABBEACQCAAKAIMIgJBAXFFDQAgAkEFdiABaiIDQYCAgMAATwRAIAAoAgghBCAAKAIEIQUgACgCACEGIAAoAgwhA0EUQQQQrTYiAkUEQEEEQRQQoz0ACyACQQE2AhAgACACNgIMIAIgA0ECdkEHcTYCDCACIANBBXYiAyAFajYCCCACIAYgA2s2AgQgAiADIARqNgIADAELIAAgAkEfcSADQQV0cjYCDAsgACAAKAIAIAFqNgIAIAAgACgCCCABazYCCCAAIAAoAgQiACABayIBQQAgACABTxs2AgQLC24BBn4gACADQv////8PgyIFIAFC/////w+DIgZ+IgcgBiADQiCIIgZ+IgggBSABQiCIIgl+fCIFQiCGfCIKNwMAIAAgByAKVq0gBiAJfiAFIAhUrUIghiAFQiCIhHx8IAEgBH4gAiADfnx8NwMIC4IBAQF/AkAgAC0AtAFBCkkNACAAKAK8ASIBRQ0AIAAoArgBIAFBARD4OgsgAEHQAGoQ3jsgABDLKQJAIAAoApgBRQ0AIAAoApwBIgEEQCAAQagBaiAAKAKgASAAKAKkASABKAIQEQEADwsgACgCoAFBgICAgHhGDQAgAEGgAWoQ3jsLC4gBAQF/AkACQAJAIAAtAIAHDgQAAgIBAgsgACgC0AEiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB0AFqEJ0nCyAAKQMAQgNSBEAgABCpHg8LIABBCGoQoSkPCyAAQbADahDNJCAAKAKoAyIBIAEoAgAiAUEBazYCACABQQFHDQAgAEGoA2oQnScLC3oBAn8jAEEQayIFJAAgBUEEaiABEN0gQcAAQQgQrTYiBEUEQEEIQcAAEKM9AAsgBCADNgIoIAQgAjcDICAEIAUpAgQ3AiwgBEEAOgA4IARBNGogBUEMaigCADYCACABEN47IABBsJjDADYCBCAAIAQ2AgAgBUEQaiQAC6YBAQJ/IwBBEGsiBSQAIAJB/wFxQQdGBH9BAAVBAkEBEK02IgRFBEBBAUECEKM9AAsgBCADOgABIAQgAjoAACAFQQhqIgJBhOTDADYCBCACIAQ2AgAgBSgCDCEEIAUoAggLIQNB1ABBBBCtNiICRQRAQQRB1AAQoz0ACyACIAQ2AlAgAiADNgJMIAIgATsBSiACIAA7AUggAkECNgIAIAVBEGokACACC3wBAn8jAEEQayIBJAAgACgCACAAQQA2AgAEQCABIAAoAgQiADYCCCABQbDtwwBBGRCTPiICNgIMIAFBCGogAUEMahCiOyACQYQBTwRAIAIQ8h8gASgCCCEACyAAQYQBTwRAIAAQ8h8LIAFBEGokAA8LQczswwBBHBCXPQALiwEBAn8jAEEQayICJAACQAJAAkACQCABLQAAQQFrDgIAAQILIABBAjoAACAAIAEoAAE2AAEMAgsgAEEDOgAAIAAgASkAATcAASAAQQlqIAFBCWopAAA3AAAMAQsgAkEIaiABQQRqIgMQ3DsgACACKAIMQQBHOgAAIAEtAAANACADEIYwCyACQRBqJAALdQECfyMAQSBrIgIkACACQRhqIAFBCGooAgA2AgAgAiABKQIANwMQIAJBCGogAkEQahDlESACKAIIIgEEQCACKAIMIQMDQCAAIAEgASADahCCJiACIAJBEGoQ5REgAigCBCEDIAIoAgAiAQ0ACwsgAkEgaiQAC4QBAQN/AkACQCAAIAAoAgwiAQR/IAEFIAAgACgCBEEBaiIBNgIEIAEgACgCACICKAIEIgNPDQEgACACKAIAIAFqLQAANgIIIAEgAigCDCIDTw0CIAIoAgggAUECdGooAgALQQFrNgIMDwsgASADQfzqzAAQwyEACyABIANBjOvMABDDIQALggEBAX4CQAJAAkACQEEBIAApAwAiAadBAmsgAUIBWBsOAwECAwALIABBCGoQgykPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKiAAKAJAQYAgQQQQ+DoPCyAAQQhqEOk7IABBIGogACgCGCAAKAIcIAAoAhQoAhARAQALjwEBAn8jAEEQayICJAAgAEEBaiEDAn8CQAJAAkAgAC0AAEEBaw4CAQIACyACIAM2AgQgAUGcy80AQQYgAkEEakGMy80AENATDAILIAIgAzYCCCABQbTLzQBBBiACQQhqQaTLzQAQ0BMMAQsgAiADNgIMIAFBzMvNAEEFIAJBDGpBvMvNABDQEwsgAkEQaiQAC4sBAQN/IwBBEGsiASQAIAFBBGpBD0EAQQFBARCgGCABKAIIIQIgASgCBEEBRgRAIAIgASgCDEHYp84AEP0vAAsgASgCDCIDQQdqQZ+yzgApAAA3AAAgA0GYss4AKQAANwAAIABBBToAECAAQQ82AgwgACADNgIIIAAgAjYCBCAAQQE2AgAgAUEQaiQAC4sBAQN/IwBBEGsiASQAIAFBBGpBDkEAQQFBARCgGCABKAIIIQIgASgCBEEBRgRAIAIgASgCDEHYp84AEP0vAAsgASgCDCIDQQZqQYa0zgApAAA3AAAgA0GAtM4AKQAANwAAIABBBDoAECAAQQ42AgwgACADNgIIIAAgAjYCBCAAQQA2AgAgAUEQaiQAC4EBAgJ/AX4jAEEQayIEJAAgASkCICEGIAEgAikCADcCICAEQQhqIAFBKGoiBSkCADcDACAFIAJBCGopAgA3AgAgBCAGNwMAIAanIgIEQCAEQQxqIAQoAgQgBCgCCCACKAIQEQEACyABIAM2AjAgAUEANgI0IABBCDYCACAEQRBqJAALhgECAX8CfiMAQSBrIgIkACACQgA3AwAgAUEHTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQcTZzgAQ7ywACyACQQggAEEIQdTZzgAQ1SwgAjUCACEDIAIxAAQgAkEgaiQAQjiGIANCGIaEQr3P1vHR9+maHn5CL4inC4YBAgF/An4jAEEgayICJAAgAkIANwMAIAFBB00EQCACQQA2AhggAkEBNgIMIAJBmNfOADYCCCACQgQ3AhAgAkEIakHE2c4AEO8sAAsgAkEIIABBCEHU2c4AENUsIAI1AgAhAyACMQAEIAJBIGokAEI4hiADQhiGhEK9z9bx0ffpmh5+QjCIpwuJAQECfyMAQSBrIgIkAAJ/IAFFBEAgAkEANgIcIAJCgICAgIABNwIUIAIgAkEUakGMh84AEKMhIAIoAgAhASACKAIEDAELIAJBFGoiAyABQcSe0AAQthUgAkEIaiADQcyCzgAQoyEgAigCCCEBIAIoAgwLIQMgACABNgIAIAAgAzYCBCACQSBqJAALhAEBAn8jAEEgayICJAACfyABRQRAIAJBADYCHCACQoCAgIDAADcCFCACIAJBFGpBjIfOABCYISACKAIAIQEgAigCBAwBCyACQRRqIgMgARCjFSACQQhqIANBzILOABCYISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBIGokAAuIAQECfyMAQSBrIgIkAAJ/IAFFBEAgAkEANgIcIAJCgICAgCA3AhQgAiACQRRqQYyHzgAQqiEgAigCACEBIAIoAgQMAQsgAkEUaiIDIAFBxJ7QABCZFSACQQhqIANBzILOABCqISACKAIIIQEgAigCDAshAyAAIAE2AgAgACADNgIEIAJBIGokAAuIAQEBfyMAQSBrIgMkAAJ/IAFFBEAgA0EANgIcIANCgICAgCA3AhQgA0EIaiADQRRqQYyHzgAQqiEgAygCCCECIAMoAgwMAQsgA0EUaiIBIAJBxJ7QABCZFSADIAFBzILOABCqISADKAIAIQIgAygCBAshASAAIAI2AgAgACABNgIEIANBIGokAAuEAQEBfyMAQSBrIgMkAAJ/IAFFBEAgA0EANgIcIANCgICAgMAANwIUIANBCGogA0EUakGMh84AEJghIAMoAgghAiADKAIMDAELIANBFGoiASACEKMVIAMgAUHMgs4AEJghIAMoAgAhAiADKAIECyEBIAAgAjYCACAAIAE2AgQgA0EgaiQAC3wBAX8gABCfDAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfwECfyMAQRBrIgMkACABIAFBBGsiBCACKAIAIgIoAgAoAgARAgBBAEgEQCADIAEoAAA2AgwDQAJAIAQiAUEEaiABKAAANgAAIAAgAUYNACADQQxqIAFBBGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMoAgw2AAALIANBEGokAAt/AQJ/IwBBEGsiAyQAIAEgAUECayIEIAIoAgAiAigCACgCABECAEEASARAIAMgAS8AADsBDgNAAkAgBCIBQQJqIAEvAAA7AAAgACABRg0AIANBDmogAUECayIEIAIoAgAoAgARAgBBAEgNAQsLIAEgAy8BDjsAAAsgA0EQaiQAC38BAn8jAEEQayIDJAAgASABQQFrIgQgAigCACICKAIAKAIAEQIAQQBIBEAgAyABLQAAOgAPA0ACQCAEIgFBAWogAS0AADoAACAAIAFGDQAgA0EPaiABQQFrIgQgAigCACgCABECAEEASA0BCwsgASADLQAPOgAACyADQRBqJAALfwECfyMAQRBrIgMkACABIAFBCGsiBCACKAIAIgIoAgAoAgARAgBBAEgEQCADIAEpAAA3AwgDQAJAIAQiAUEIaiABKQAANwAAIAAgAUYNACADQQhqIAFBCGsiBCACKAIAKAIAEQIAQQBIDQELCyABIAMpAwg3AAALIANBEGokAAt2AQF/IwBBIGsiBSQAIAUgAiADIAEgBBCHKiABIAUoAgQgBSgCACICayIBa0EATwRAIAEEQCAAIAAgAmogAfwKAAALIAVBIGokAA8LIAVBADYCGCAFQQE2AgwgBUHk6PwANgIIIAVCBDcCECAFQQhqIAQQ7ywAC3wBAX8gABCnDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEPseCwJAIAAoAiQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEkahD7HgsLfAEBfyAAEKgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQsgwCQCAAKAIgIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBIGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LC58CAgF/AXwjAEEgayIFJAAgAAJ/IAEoAgAgAhCHJUUEQCMAQTBrIgAkACABKAIAIQEgACACNgIAIAFBDGoQ2DwgAk0EQCAAIAEQ/Ts2AhwgAEECNgIIIABB8Ij/ADYCBCAAQgI3AhAgAEE7NgIsIABBOzYCJCAAIABBIGo2AgwgACAAQRxqNgIoIAAgADYCICAAQQRqQYCJ/wAQ7ywACyABKAIQIAJBA3RqKwMAIQYgAEEwaiQAIAUgBUEIaiAGEK4lQZOAgIB4QZSAgIB4IAMgBSgCACAFKAIEIAQoAgwRBgAbDAELQZSAgIB4IAEoAggiAEUNABpBk4CAgHhBlICAgHggAyABKAIEIAAgBCgCDBEGABsLNgIAIAVBIGokAAuKEgMOfwR+AX0jAEEgayIPJAAgAAJ/IAEoAgAgAhCHJUUEQCAPQQhqIQgjAEEwayIAJAAgASgCACEBIAAgAjYCACABQQxqENs8IAJNBEAgACABEPw7NgIcIABBAjYCCCAAQfCI/wA2AgQgAEICNwIQIABBOzYCLCAAQTs2AiQgACAAQSBqNgIMIAAgAEEcajYCKCAAIAA2AiAgAEEEakGAif8AEO8sAAsgASgCECACQQJ0aioCACEXIABBMGokACMAQRBrIhAkAAJ/IBe8Qf////8HcUH////7B00EQAJ/IBe8IgJB////A3EhACACQQBIBEAgCEEtOgAAQQEhCQsCfwJAAn8CQAJAAkACQAJAAkACQCACQRd2Qf8BcSIBIAByBEAgAEGAgIAEciAAIAEbIgJBAnQiBSAAQQBHIAFBAklyIhFBf3NqIQcgAkEBcSESIAVBAnIhAiABQZgBa0HpfiABGyINQQBIBEBByPyIASANIA1BhaJTbCIKQRR2Ig5qIgxBBHRrKQMAIhNC/////w+DIhQgB60iFX5CIIggFSATQiCIIhZ+fCAOQTxqIgcgDEGx2bUPbEETdmtBP3FBIHOtIhWIpyEBIBQgAq0iE35CIIggEyAWfnwgFYinIQYgFCAFrSITfkIgiCATIBZ+fCAViKchACAKQYCAwABJDQggBkEBa0EKbiABQQpuTQ0CDAULIA1BwegEbEESdiIMQQR0QejRiAFqKQMAQgF8IhNC/////w+DIhQgB60iFX5CIIggFSATQiCIIhZ+fCAMIA1rIgogDEHPpsoAbEETdmpBPWpBP3FBIHOtIhWIpyEBIBQgAq0iE35CIIggEyAWfnwgFYinIQYgFCAFrSITfkIgiCATIBZ+fCAViKchACANQQRPDQIMAwsgCCAJaiIAQaCliQEvAAA7AAAgAEECakGipYkBLQAAOgAAIAJBH3ZBA2oMCgtBASAMayICQQR0Qcj8iAFqKQMAIhRC/////w+DIBN+QiCIIBRCIIggE358IAcgAkHPpsoAbEF/c0ETdmpBP3FBIHOtiKdBCnAhCwwCCyAGQQFrQQpuIAFBCm5NBEAgDEEBayILQQR0QejRiAFqKQMAQgF8IhRC/////w+DIBN+QiCIIBRCIIggE358IAogC0HPpsoAbEETdmpBPGpBP3FBIHOtiKdBCnAhCwsgDUEiTw0CCyAFQQVwRQRAQQAhBwNAIAdBAWohByAFQQVuIgVBBXBFDQALIAcgDEkNAgwDCyASBEBBACEFIAJBBXBFBEADQCAFQQFqIQUgAkEFbiICQQVwRQ0ACwsgBiAFIAxPayEGDAILQQAhCkEAIQUgB0EFcEUEQANAIAVBAWohBSAHQQVuIgdBBXBFDQALCyAFIAxJDQFBASEODAULIApBgICAAUkNAiAKQYCAwA9PDQAgBUF/IA5BAWt0QX9zcUUNAQtBACEFIAZBCm4iByABQQpuIgJLBEADQCAFQQFqIQUgACIGQQpuIQAgB0EKbiIHIAIiAUEKbiICSw0ACyAGIABBCmxrIQsLIAAgAUYgC0H/AXFBBEtyDAQLQQAMAQsgBiASayEGIBJFIBFxCyEOQQEhCgtBACEFAkAgBkEKbiIRIAFBCm4iDU0EQCALIQYgASEHIAAhAgwBCwNAIA5BACABayANIgdBdmxGcSEOIAVBAWohBSAAIABBCm4iAkEKbGshBiAKIAtB/wFxRXEhCiACIQAgBiELIBFBCm4iESAHIgFBCm4iDUsNAAsLAkAgDkUgB0EKcHJFBEADQCAFQQFqIQUgAiACQQpuIgBBCmxrIQEgCiAGQf8BcUVxIQogACECIAEhBiAHQQpuIgdBCnBFDQAMAgsACyAGIQEgAiEACyASRSAOcUUgACAHRnFBBUEEIABBAXEbIAEgAUH/AXFBBUYbIAEgChtB/wFxQQRLcgshAgJ/AkACQAJAAkACQCAFIAxqIgFBAE4gAQJ/QQkgACACaiIAQf/B1y9LDQAaQQggAEH/rOIESw0AGkEHIABBv4Q9Sw0AGkEGIABBn40GSw0AGkEFIABBj84ASw0AGkEEIABB5wdLDQAaQQMgAEHjAEsNABpBAkEBIABBCUsbCyIGaiICQQ5IcUUEQCACQQFrIgFBDUkNASACQQVqQQZJDQIgBkEBRw0EIAggCWoiBkHlADoAASAGIABBMGo6AAAgCCAJQQJyIgZqIQUgAUEASA0DIAEhAAwFCyAAIAggCWogBmoQwBQgAUUgAiAGTHJFBEAgBiAIaiAJakEwIAH8CwALIAggAiAJaiIAakGu4AA7AAAgAEECagwGCyAAIAggBiAJakEBaiIBahDAFCAIIAlqIQAgAgRAIAAgAEEBaiAC/AoAAAsgACACakEuOgAAIAEMBQsgCCAJaiIHQbDcADsAAEECIAJrIQECQCACQQBODQBBAyABIAFBA00bQQJrIgJFDQAgB0ECakEwIAL8CwALIAAgCCAGIAlqIAFqIgBqEMAUIAAMBAsgBUEtOgAAIAVBAWohBUEBIAJrIgBBCUoNASAFIABBMGo6AABBAgwCCyAAIAggBiAJaiIGaiIHQQFqEMAUIAggCWoiACAALQABOgAAIABBLjoAASAHQeUAOgABIAggBkECaiIGaiEFAn8CQCABQQBOBEAgASEADAELIAVBLToAACAFQQFqIQVBASACayIAQQlKDQAgBSAAQTBqOgAAQQIMAQsgBSAAQQF0QYjQiAFqLwAAOwAAIAFBH3ZBAnILIAZqDAILIAUgAEEBdEGI0IgBai8AADsAACABQR92QQJyCyAGagsMAQsgEEEIaiIAQQNBA0EEIBe8IgFBAE4iAhsgAUH///8DcSIBGzYCBCAAQdfRiAFB0NGIAUHT0YgBIAIbIAEbNgIAIBAoAgghCCAQKAIMCyEAIA8gCDYCACAPIAA2AgQgEEEQaiQAQZOAgIB4QZSAgIB4IAMgDygCACAPKAIEIAQoAgwRBgAbDAELQZSAgIB4IAEoAggiAEUNABpBk4CAgHhBlICAgHggAyABKAIEIAAgBCgCDBEGABsLNgIAIA9BIGokAAt8AQF/IAAQtAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3wBAX8gABC0DAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfAEBfyAAELYMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQtgwCQCAAKAIgIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBIGoQ+x4LIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLIAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQ+x4LC3wBAX8gABC3DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEPseCwJAIAAoAiQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEkahD7HgsLfAEBfyAAELkMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwt8AQF/IAAQvgwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3wBAX8gABC+DAJAIAAoAiAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEgahD7HgsgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahC7IwsgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahD7HgsLfAEBfyAAEMMMAkAgACgCICIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSBqEPseCyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCyAAKAIUIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRRqEPseCwt8AQF/IAAQxwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LC3UBA38jAEEQayICJAACQCABKAIIIgMEQCACQQhqIAEoAgQQjx8gAigCDCIDIAEoAigiAUkNASACKAIIIQQgACADIAFrNgIEIAAgASAEajYCACACQRBqJAAPC0EAIANBsOSGARDDIQALIAEgA0HA5IYBEK87AAtzAQZ+IAEpAxgiAyABKQMIIgaFIQQgASkDACEFAkACQCABKQMQIgcgA4NCf1EEQCAEQgBZDQEMAgsgAyAHhEIAUiAEQgBTcg0BCyAFIAaFQoCAgICAgICAgH+DQgBSDQAgACAFNwMIQgEhAgsgACACNwMAC/gBAQd/AkAgACgCBCAAKAIAIgEoAghrIgcgACgCCCIEakEAIAQbIgMgASgCGE8NACABQX8gASgCBCICIAJBAUYbNgIEIAJBAUcNACABQQE2AgQgASgCAEEBRw0AAn8CQCABQQhqIgEoAggNAAJ/QQAgASgCECICIANGDQAaIAMgASgCDCIFENE0RQ0BIAEoAgAhBgJAIANFBEAgBiACIAUQ+DpBwAAhAgwBC0EBIAYgAiAFIAMQlzUiAkUNARoLIAEgAzYCECABQQA2AgggASADNgIEIAEgAjYCAEEACwwBC0EBCw0AIAAgASgCACAHQQAgBBtqNgIECwt+AQF/IwBBQGoiBSQAIAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAFQQI2AhwgBUGg8YkBNgIYIAVCAjcCJCAFIAVBEGqtQoCAgIDQ4wOENwM4IAUgBUEIaq1CgICAgODjA4Q3AzAgBSAFQTBqNgIgIAVBGGogBBDvLAALfgEEfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAQRAIAQgBSAB/AoAAAsgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQeC1wgAQ/S8AC3gBAn8gACgCCCICBEAgACgCBEE8aiEAA0AgAEE8ayIBKAIAQYCAgIB4RwRAIAEQ3jsgAEEwayIBENErIAEQ6DsgAEEkayIBENErIAEQ6DsgAEEYaxCFMCAAQQxrEIUwIAAQhTALIABBzABqIQAgAkEBayICDQALCwuOAQEBfwJAAkACQAJAIAAtAOgFDgQAAwMBAwsgAC0A6AJBA0YEQCAAEMopCyAAKALgBSIBQYQBTwRAIAEQ8h8LIAAoAuQFIgBBgwFLDQEMAgsgAC0A2AVBA0YEQCAAQfACahDKKQsgACgC4AUiAUGEAU8EQCABEPIfCyAAKALkBSIAQYMBTQ0BCyAAEPIfCwuNAQEBfwJAAkACQAJAIAAtALgBDgQAAwMBAwsgAC0AUEEDRgRAIAAQqywLIAAoArABIgFBhAFPBEAgARDyHwsgACgCtAEiAEGDAUsNAQwCCyAALQCoAUEDRgRAIABB2ABqEKssCyAAKAKwASIBQYQBTwRAIAEQ8h8LIAAoArQBIgBBgwFNDQELIAAQ8h8LC40BAQF/AkACQAJAAkAgAC0AmAEOBAADAwEDCyAALQBEQQNGBEAgABCAKgsgACgCkAEiAUGEAU8EQCABEPIfCyAAKAKUASIAQYMBSw0BDAILIAAtAIwBQQNGBEAgAEHIAGoQgCoLIAAoApABIgFBhAFPBEAgARDyHwsgACgClAEiAEGDAU0NAQsgABDyHwsLgAEBAX8gACgCACIAQRRqEI8MAkAgACgCCEGAgICAeEYEQCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQQxqEIMgDAELIABBCGoiARC+HyABEPA7CwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEoQQQQ+DoLC3IBBH8jAEEQayIBJAAgAUEIaiAAKAJgQQhqENw7AkACQCAAKAJsIgQgASgCDE8NACABKAIIIgNFDQAgAyAEQQJ0aigCACICIAIoAgAiA0EBajYCACADQQBIDQEgACAEQQFqNgJsCyABQRBqJAAgAg8LAAu4AQICfwJ+IwBBEGsiAiQAAkAgASkDACIFQgNSBEAgAUEQaiEDIAEpAwghBAJAAkACQCAFp0EBaw4CAAECCyADKQMoIAR8IQQMAQsgAykDICAEfCEECyADIAQ3AyAgAiAENwMIIAJBADYCACACKAIAQQJGBEAgAEECNgIADAILIAFCAzcDACAAIAIpAwA3AwAgAEEIaiACQQhqKQMANwMADAELIABCADcDCCAAQQA2AgALIAJBEGokAAt6AQF/IwBBEGsiAiQAAkACQCABRQRAIAIgABDJISIANgIIIAAgACgCAEEBayIANgIAIAANASACQQhqENQiDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQ5yYLIAJBEGokAA8LEJg9AAt1AQJ/IAAoAggiAQRAIAAoAgQhAANAIABBIGooAgAiAgRAIABBLGogAEEkaigCACAAQShqKAIAIAIoAhARAQALIABBGGogAEEQaigCACAAQRRqKAIAIABBDGooAgAoAhARAQAgAEE0aiEAIAFBAWsiAQ0ACwsLcAEEfyMAQRBrIgMkACADQQxqIQUCQCACRQ0AIAAoAgAiBkUNACADIAE2AgwgAiAGbCEEIAAoAgQhAiADQQhqIQULIAUgBDYCAAJAIAMoAgwiAEUNACADKAIIIgFFDQAgAiABIAAQ+DoLIANBEGokAAuAAQEEfyMAQRBrIgIkACACQQhqEP0nIAAoAgQhAyACKAIIIQQgACACKAIMNgIEIAAoAgAhBSAAIAQ2AgAgASAFIAMQ4DUgAhD+JyAAKAIMIQMgAigCACEEIAAgAigCBDYCDCAAKAIIIAAgBDYCCCADEIAxIABCADcCECACQRBqJAALeQAgACAAKAKAESADajYCgBEgAiADTwRAAkAgAwRAIANBAXQhAwNAIAEvAQAiAkGgBE8NAiAAIAJBAnRqIgIgAigCAEEBajYCACABQQJqIQEgA0ECayIDDQALCw8LIAJBoARBzOrMABDDIQALIAMgAkG86swAELA7AAt5ACAAIAAoAoAWIANqNgKAFiACIANPBEACQCADBEAgA0EBdCEDA0AgAS8BACICQcAFTw0CIAAgAkECdGoiAiACKAIAQQFqNgIAIAFBAmohASADQQJrIgMNAAsLDwsgAkHABUHM6swAEMMhAAsgAyACQbzqzAAQsDsAC38BAn8jAEEwayICJAAgAiABNgIMQQghAwJAIAFBCE8EQCACQQE2AhQgAkGg+M4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQAhAwwBCyAAIAE6AAQLIAAgAzYCACACQTBqJAALeQEBfyMAQTBrIgIkACACIAE2AgwgAAJ/IAFBA08EQCACQQE2AhQgAkG4+c4ANgIQIAJCATcCHCACQZwDNgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOQQAMAQsgACABOgAEQQgLNgIAIAJBMGokAAuAAQEBfyMAQTBrIgQkACAEIAI2AgwgBCABNgIIQQQhAiAAIAMoAgAEfyACBSAEQQE2AhQgBEHsjs8ANgIQIARCATcCHCAEQcwBNgIsIAQgBEEoajYCGCAEIARBCGo2AiggAEEEaiAEQRBqEJkOIABBADoAEEEBCzYCACAEQTBqJAALfgEEfyMAQRBrIgIkACABKAIEIQUgAkEEaiABKAIIIgFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUcEQCACKAIMIQQgAQRAIAQgBSAB/AoAAAsgACABNgIIIAAgBDYCBCAAIAM2AgAgAkEQaiQADwsgAyACKAIMQdiZzwAQ/S8AC5MBAQF/IwBBEGsiAiQAAn8CQAJAAkACQCAAKAIAQQFrDgMBAgMACyACIABBCGo2AgwgAUHLo9AAQQ5BhKTQAEEIIABBBGpB5KPQAEGMpNAAQQYgAkEMakH0o9AAEI4YDAMLIAFBkqTQAEESEPs1DAILIAFBpKTQAEETEPs1DAELIAFBt6TQAEEREPs1CyACQRBqJAAL3Q4BEX8jAEFAaiILJAAgC0EEaiEIAkACQAJAAkAgACgCACICBEAgAUH/AXEhBiAAKAIEIQQDQCACLwEGIQNBACEFAkADQCADIAVGDQEgAiAFaiEKIAVBAWohBSAGIApBCGotAAAiCkogBiAKSGtB/wFxIgpBAUYNAAsgCkUNBCAFQQFrIQMLIARFDQIgBEEBayEEIAIgA0ECdGooAhQhAgwACwALIAhBADYCBAwCCyAIIAM2AgwgCEEANgIIIAggAjYCBAwBCyAIIAA2AgwgCCAENgIEIAggAjYCACAIIAVBAWs2AghBCSEBDAELIAggADYCAAsgCCABOgAQIAstABRBCUcEQCALQShqIAtBFGooAgA2AgAgC0EgaiALQQxqKQIANwMAIAsgCykCBDcDGCALQTBqIRFBACEEIwBBIGsiCiQAAn8gC0EYaiIIKAIEBEAgCkEYaiAIQQRqIgBBCGooAgA2AgAgCiAAKQIANwMQIApBBGohDiAILQAQIQ1BACECIwBBMGsiBSQAIAVBBGohAyMAQRBrIgYkAAJ/AkACQAJAIApBEGoiACIHKAIAIgEvAQYiCUELTwRAQQUhCUEEIQQgACgCCCIAQQVJDQEgACEEIABBBWsOAgEDAgsgAUEIaiECIAcoAgQhBAJAIAcoAggiAEEBaiIHIAlLDQAgCSAAayIMRQ0AIAIgB2ogACACaiAM/AoAAAsgASAJQQFqOwEGIAAgAmogDToAAEEJDAMLIAYgBDYCDCAGIAcoAgQiBDYCCCAGIAE2AgQQpy8iAkEAOwEGIAJBADYCACABQQhqIQcgBkEEaiACEIUcAkAgAS8BBiIJIABNDQAgCSAAayIPRQ0AIAAgB2oiEEEBaiAQIA/8CgAACyADQQA2AgwgAyACNgIIIAMgBDYCBCADIAE2AgAgASAJQQFqOwEGIAAgB2ogDToAAEH/AXEMAgsgAEEHayECQQYhCQsgBiAJNgIMIAYgATYCBCAGIAcoAgQiDDYCCBCnLyIAQQA7AQYgAEEANgIAIABBCGohByAGQQRqIAAQhRwCQCAALwEGIgkgAk0NACAJIAJrIgRFDQAgAiAHaiIQQQFqIBAgBPwKAAALQQAhBCADQQA2AgwgAyAANgIIIAMgDDYCBCADIAE2AgAgACAJQQFqOwEGIAIgB2ogDToAACAAIQEgAiEAQf8BcQshAiADIAA2AhwgAyAENgIYIAMgATYCFCADIAI6ABAgBkEQaiQAAkAgBS0AFCIBQQlHBEAgBSgCICEPIAUoAhghECAFKAIcIRIgBSgCDCEAIAUoAhAhBAJAAkAgBSgCBCIHKAIAIgIEQCAFKAIIIQMDQCAFIAI2AiQgBSAHLwEENgIsIAUgA0EBajYCKCAFQQRqIQYgACECQQAhDSMAQTBrIgMkAAJAAkAgBCAFQSRqIgQoAgQiCUEBa0YEQCAEKAIAIgwvAQZBC0kNAUEFIQdBBCEAAkACQAJAIAQoAggiBEEFSQ0AIAQiAEEFaw4CAAIBCyADIAA2AgwgAyAJNgIIIAMgDDYCBCADQRBqIANBBGoQjBQgAyAENgIsIAMgAykCEDcCJCADQSRqIAEgAhDpEyAGQRBqIANBIGooAgA2AgAgBkEIaiADQRhqKQIANwIAIAYgAykCEDcCAAwECyAEQQdrIQ1BBiEHCyADIAc2AgwgAyAJNgIIIAMgDDYCBCADQRBqIANBBGoQjBQgAyANNgIsIAMgA0EYaiIAKQIANwIkIANBJGogASACEOkTIAZBEGogA0EgaigCADYCACAGQQhqIAApAgA3AgAgBiADKQIQNwIADAILQZS4zQBBNUHMuM0AEJ8pAAsgBCABIAIQ6RMgBkEJOgAQCyADQTBqJAAgBS0AFCIBQQlGDQIgBSgCDCEAIAUoAhAhBCAFKAIIIQMgBSgCBCIHKAIAIgINAAsLIAgoAgAiAygCACIGRQ0BIAMoAgQhBxCoLyICIAY2AhQgAkEAOwEGIAJBADYCACAGQQA7AQQgBiACNgIAIAMgB0EBaiIGNgIEIAMgAjYCACAFIAY2AgggBSACNgIEAkACQCAFQQRqIgIoAgRBAWsgBEYEQCACKAIAIgIvAQYiBEELTw0BIAIgBGogAToACCACIARBAWoiATsBBiACIAFBAnRqIAA2AhQgACABOwEEIAAgAjYCAAwCC0Hsts0AQTBBnLfNABCfKQALQcy2zQBBIEGst80AEJ8pAAsLIA4gDzYCCCAOIBI2AgQgDiAQNgIADAILQby2zQAQsjsACyAOIAUoAiA2AgggDiAFKQIYNwIACyAFQTBqJAAgCCgCACEAIAooAgQhAiAKKAIIIQQgCigCDAwBCyAIKAIAIQAQpy8iAkEANgIAIABBADYCBCAAIAI2AgAgAkEBOwEGIAIgCC0AEDoACEEACyEBIAAgACgCCEEBajYCCCARIAE2AgggESAENgIEIBEgAjYCACARIAgoAgA2AgwgCkEgaiQACyALQUBrJAALgwEBAn9BASEFAkACQAJAAkACQCABKAIAQQFrDgIBAgALIAMgASgCBCIBSQ0CIAEgAmohBSADIAFrIQYMAQsgASgCBCIBQRFPDQIgASAEaiEFQRAgAWshBgsgACAGNgIEIAAgBTYCAA8LIAEgA0G09dEAEK87AAsgAUEQQcT10QAQrzsAC20BAX8gASgCBCICBEAgASACQQFrNgIEIAEgASgCACIBQQRqNgIAIAEgAEEDaiIAZyIBQQF0QT5zIAAgAEEeIAFrIgB2QQFxIgFBAnIgAHRrQQh0ciABckHMAGo2AgAPC0EAQQBBqIDSABDDIQALiwEBA38jAEEgayICJABB8O7+ACEDQQYhBAJ/AkACQAJAIAAvAQAOAgEAAgtB9u7+ACEDQQUhBAsgASADIAQQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALiwEBA38jAEEgayICJABBi+/+ACEDQQMhBAJ/AkACQAJAIAAvAQAOAgEAAgtBju/+ACEDQQshBAsgASADIAQQ+zUMAQsgAkECNgIEIAJB4O7+ADYCACACQgE3AgwgAkH1CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALiwEBA38jAEEgayICJABB/P7+ACEDQQkhBAJ/AkACQAJAIAAtAAAOAgEAAgtBhf/+ACEDQQQhBAsgASADIAQQ+zUMAQsgAkECNgIEIAJBlP/+ADYCACACQgE3AgwgAkH/CzYCHCACIAA2AhggAiACQRhqNgIIIAEoAgAgASgCBCACEMsKCyACQSBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBCEEIEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKJkqTIkKHChAk3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYmSpMgANgIAIAJBEGokAAuMAQEDfyMAQRBrIgIkACACQQRqIAFBAEEBQQEQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoKEiJCgwICBAjcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBgoSIEDYCACACQRBqJAALjQEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKLlqzYsOHChQs3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYuWrNgANgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEEQQQQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoiQoMCAgYKECDcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBiJCgwAA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQJBAhCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABCh46cuPDgwYMHNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGHjpw4NgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEECQQIQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoqUqNCgwYKFCjcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBipSo0AA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQJBAhCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABCg4aMmLDgwIEDNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGDhowYNgIAIAJBEGokAAuNAQEDfyMAQRBrIgIkACACQQRqIAFBAEEIQQgQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoyYsODAgYOGDDcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBjJiw4AA2AgAgAkEQaiQAC4wBAQN/IwBBEGsiAiQAIAJBBGogAUEAQQFBARCgGCACKAIIIQMgAigCBEEBRgRAIAMgAigCDEHs5oUBEP0vAAsgAigCDCEEIABChoyYsODAgYMGNwIoIAAgATYCJCAAQQA2AiAgAEIANwIIIAAgBDYCBCAAIAM2AgAgAEEwakGGjJgwNgIAIAJBEGokAAuMAQEDfyMAQRBrIgIkACACQQRqIAFBAEEIQQgQoBggAigCCCEDIAIoAgRBAUYEQCADIAIoAgxB7OaFARD9LwALIAIoAgwhBCAAQoWKlKjQoMGCBTcCKCAAIAE2AiQgAEEANgIgIABCADcCCCAAIAQ2AgQgACADNgIAIABBMGpBhYqUKDYCACACQRBqJAALjAEBA38jAEEQayICJAAgAkEEaiABQQBBBEEEEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQezmhQEQ/S8ACyACKAIMIQQgAEKEiJCgwICBggQ3AiggACABNgIkIABBADYCICAAQgA3AgggACAENgIEIAAgAzYCACAAQTBqQYSIkCA2AgAgAkEQaiQAC6kDAgZ/AX4jAEEQayIEJAACQCAAKAIMIgUgACgCBCIDRg0AIAEgBSADa0EMbiIFEIAuIAUgAigCACACKAIIIgNrTQ0AIAIgAyAFQQRBCBDeKAsgBEEIaiAAQQhqKQIANwMAIAQgACkCADcDACAEKAIEIgYgBCgCDCIARwRAIAEoAgQgASgCCCIHQQJ0aiEIIAIoAgQgAigCCCIFQQN0aiEDA0AgBkEEaikCACEJIAggBigCADYCACADIAk3AgAgCEEEaiEIIANBCGohAyAFQQFqIQUgB0EBaiEHIAZBDGoiBiAARw0ACyABIAc2AgggBCAGNgIEIAIgBTYCCAsjAEEQayICJAAgBCgCDCIAIAQoAgQiA2tBDG4hBiAAIANHBEADQCADKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCADEPIlCyADQQRqIgEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQuyMLIANBDGohAyAGQQFrIgYNAAsLIAIgBCgCADYCDCACIAQoAgg2AgggAkEIakEEQQwQ4B4gAkEQaiQAIARBEGokAAt/AQJ/AkACQCAAKAIAIgAoAhAiAQ0AIAAoAhgiAkUNACAAKAIIIAIgACgCFBD4OgwBCyABRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRBqELsjCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEcQQQQ+DoLC3wBA38jAEEQayIDJAAgA0EEaiACQQBBAUEBEKAYIAMoAgghBCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALIAMgAjYCDCADIAU2AgggAyAENgIEIAAgA0EEahDnFSADQRBqJAAPCyAEIAMoAgxBwIWIARD9LwALgAMCB38Bb0HI7ooBKAIAIgUoAghFBEAgBUF/NgIIIAVBDGoiASgCDCIDIAEoAgAiAkYEQCABKAIAIQQgAUHsqIgBEJcoAkAgASgCCCIHIAQgASgCDCICa00NACAEIAdrIgYgAiAGayIDSyABKAIAIgIgBGsgA09xRQRAIAIgBmshBCAGQQJ0IgMEQCABKAIEIgIgBEECdGogAiAHQQJ0aiAD/AoAAAsgASAENgIIDAELIANBAnQiA0UNACABKAIEIgIgBEECdGogAiAD/AoAAAsgASgCDCEDIAEoAgAhAgsgASADQQFqNgIMIAEoAgQgASgCCCADaiIBIAJBACABIAJPG2tBAnRqIAA2AgAgBS0AHCEAIAVBAToAHCAFIAUoAghBAWo2AggCQCAADQBB3O6KAS0AAEUEQEHY7ooBKAIAJQFB1O6KASgCACUBEFEhCBDfEiIAIAgmASAAQYQBSQ0BIAAQ8h8PC0HU7ooBKAIAJQEQDgsPC0HcqIgBEJs+AAtuAgF+BH8gACABKAIUIgAgASgCECIDSQR+IAEoAgwhBAJ+A0BCgAIgACAEai0AACIFQQlrIgZBF0tBASAGdEGTgIAEcUVyDQEaIAEgAEEBaiIANgIUIAAgA0cNAAtCAAsgBa1CEIaEBSACCzcCAAvaAQEEfyAAQegAahChLCAAEPslIABB2ABqELIfIABBQGsQlzAgAEHMAGoQmDAgAEGQAWohAQNAIAEoAgQiAgRAIAEgAhCKHRCHJAwBCwsgACgCkAEiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAEQ2R8LIABBnAFqIgMiASgCCCICBEAgASgCBCEBA0ACQCABKAIAQQhGBEAgAUEEaiIEEN4jIAQQ4DsMAQsgARDwGwsgAUEgaiEBIAJBAWsiAg0ACwsgA0EIQSAQ4B4gACgCsAEEQCAAQbABahDlIAsLbAEEfyMAQRBrIgIkACAAKAIMIgQgACgCBCIBa0EYbiEDIAEgBEcEQANAIAEQ3jsgAUEMahDeOyABQRhqIQEgA0EBayIDDQALCyACIAAoAgA2AgwgAiAAKAIINgIIIAJBCGoQ8jsgAkEQaiQAC3gBAn8gACgCACIBKAIYIgAQiDUgAEEwQQgQ+DogASgCFCICBEAgASgCECEAA0AgABCHNSAAQUBrIQAgAkEBayICDQALCyABQQxqQQhBwAAQ4B4CQCABQX9GDQAgASABKAIEQQFrIgA2AgQgAA0AIAFBHEEEEPg6CwtkAQF+AkAgACkDACIBQgZSBEACQAJAQQEgAadBAmsgAUIBWBsOAwMAAQMLIAAQkSogACgCQEGAIEEEEPg6DwsgAEEIahCDKQsPCyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEAC4ABAQN/IAAgARDsLSAAKAIEIAAoAggiAkEDdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANEAAAAAAAAAAA5AwAgA0EIaiEDIARBAWsiBA0ACyABIAJqQQFrIQIMAQsgAUUNAQsgA0QAAAAAAAAAADkDACACQQFqIQILIAAgAjYCCAt4AQN/IAAgARDuLSAAKAIEIAAoAggiAkECdGohAwJAAkAgAUECTwRAIAFBAWshBANAIANDAAAAADgCACADQQRqIQMgBEEBayIEDQALIAEgAmpBAWshAgwBCyABRQ0BCyADQwAAAAA4AgAgAkEBaiECCyAAIAI2AggLdgEDfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCwJAIABBFGoiAygCACIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACADEPseCyAAQSxqIQAgAkEBayICDQALCwtxAQF/IAAoAgAiACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahCDIAsgAEEIaiIBEKMnIAFBBEEEEOAeIABBFGoQ6TsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBJEEEEPg6CwtxAQF/IAAgAS8AACIDNgIMIAAgAUEEaiIBNgIEIAAgAUEBIANBAWt0QQEgAxtBAnRqIgM2AgggACABIAMgAkEDdGoiACgCBCICQYCAAmoiA0GAgHxxIAJrIANBEHZ1QQF0aiAAKAIAQQF0ai8BADYCAAt1AQN/IAAoAgggAWohAQNAAkACQCABBEAgACgCBCICIAAoAgwiBEkEQCABIAAoAgAgAkEMbGoiAygCCCADKAIEaiIDTw0DIAAgATYCCAsgAiAERw0BCyAAQQA2AggLDwsgACACQQFqNgIEIAEgA2shAQwACwALdAEBfwJAAkACQCAFIAIgBWoiBk0EQCABIAZJDQFBAA0CIAQgBUkNAyAAIAJqIAUgAyAFQeiI0gAQ1SwPCyACIAZByIjSABCxOwALIAYgAUHIiNIAELA7AAtBACAFQdiI0gAQsTsACyAFIARB2IjSABCwOwALcgEDfyAAIAEQ7i0gACgCBCAAKAIIIgNBAnRqIQQCQAJAIAFBAk8EQCABQQFrIQUDQCAEIAI2AgAgBEEEaiEEIAVBAWsiBQ0ACyABIANqQQFrIQMMAQsgAUUNAQsgBCACNgIAIANBAWohAwsgACADNgIIC3IBA38gACABEOwtIAAoAgQgACgCCCICQQN0aiEDAkACQCABQQJPBEAgAUEBayEEA0AgA0IANwMAIANBCGohAyAEQQFrIgQNAAsgASACakEBayECDAELIAFFDQELIANCADcDACACQQFqIQILIAAgAjYCCAuAAQEBfyMAQTBrIgIkACACIAAoAhA2AhggAiAAKAIUQQF2NgIcIAJBAzYCBCACQbz7hAE2AgAgAkICNwIMIAJB8gQ2AiwgAiAAQSBqNgIoIAJB5xo2AiQgAiACQSBqNgIIIAIgAkEYajYCICABKAIAIAEoAgQgAhDLCiACQTBqJAALgAEBAX8jAEEwayICJAAgAiAAKAIQNgIYIAIgACgCFEECdjYCHCACQQM2AgQgAkG8+4QBNgIAIAJCAjcCDCACQfIENgIsIAIgAEEgajYCKCACQegaNgIkIAIgAkEgajYCCCACIAJBGGo2AiAgASgCACABKAIEIAIQywogAkEwaiQAC4ABAQF/IwBBMGsiAiQAIAIgACgCEDYCGCACQQM2AgQgAiAAKAIUQQN2NgIcIAJBvPuEATYCACACQgI3AgwgAkHyBDYCLCACIABBIGo2AiggAkHpGjYCJCACIAJBIGo2AgggAiACQRhqNgIgIAEoAgAgASgCBCACEMsKIAJBMGokAAt0AQN/IwBBEGsiAiQAIAJBCGogARDcOyACKAIMIQEgAigCCCIEQQEQ+C8iAyABIAEgA0sbBEBBtKWHAUE4QeylhwEQnykACyAAQQEgAyAEaiABIANJGzYCACAAIAEgA2siAEEAIAAgAU0bNgIEIAJBEGokAAuNAQEBfyMAQSBrIgIkACACQQA2AgggAkKAgICAEDcCACACQfzshwE2AhAgAkKggICADjcCFCACIAI2AgwgASACQQxqENQOBEBBpO2HAUE3IAJBH2pBlO2HAUHc7YcBENUeAAsgACACKQIANwIAIABBCGogAkEIaigCADYCACAAIAEpAgA3AgwgAkEgaiQAC2cBBn4gASkDGCIDIAEpAwgiBIUhBSABKQMAIQYCQAJAIAEpAxAiByADg0J/UQRAIARCAFINAiAFQgBZDQEMAgsgAyAHhCAEhEIAUiAFQgBTcg0BCyAAIAY3AwhCASECCyAAIAI3AwALhwEBAn8jAEEgayICJAAgAkEUaiABKAIAJQEQcgJAIAIoAhQiAUUEQEGAgICAeCEBDAELIAIgAigCGCIDNgIcIAIgATYCGCACIAM2AhQgAkEIaiACQRRqQYiviAEQkCEgAigCCCEDIAAgAigCDCIBNgIIIAAgAzYCBAsgACABNgIAIAJBIGokAAt+AQF/IABBAToALCAALQAcIQEgAEEBOgAcAkAgAQ0AIABBADoAHCAAKAIUIQEgAEEANgIUIAFFDQAgACgCGCABKAIEEQMACyAALQAoIABBAToAKEUEQCAAKAIgIQEgAEEANgIgIAEEQCAAKAIkIAEoAgwRAwALIABBADoAKAsLfgEBfyAAQQE6ACQgAC0AFCEBIABBAToAFAJAIAENACAAQQA6ABQgACgCDCEBIABBADYCDCABRQ0AIAAoAhAgASgCBBEDAAsgAC0AICAAQQE6ACBFBEAgACgCGCEBIABBADYCGCABBEAgACgCHCABKAIMEQMACyAAQQA6ACALC34BAX8gAEEBOgAoIAAtABghASAAQQE6ABgCQCABDQAgAEEAOgAYIAAoAhAhASAAQQA2AhAgAUUNACAAKAIUIAEoAgQRAwALIAAtACQgAEEBOgAkRQRAIAAoAhwhASAAQQA2AhwgAQRAIAAoAiAgASgCDBEDAAsgAEEAOgAkCwt2AQF/IAAoAgAiACgCCEEGcUEGRwRAIABBCGoQ4AwLIAAoAhwiAQRAIAAoAiAgASgCDBEDAAsgACgCKCIBBEAgACgCLCABKAIMEQMACwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEE4QQQQ+DoLC3MBAn8jAEEQayICJAACQCABKAIARQ0AIAJBCGogARC7KCACKAIIQQFxRQ0AIAIoAgwhAyABIAEoAgxBAWo2AgwgAiADELgSIAIoAgAhASAAIAIoAgQ2AgRBAkEBIAFBAXEbIQMLIAAgAzYCACACQRBqJAALeQEDfwJAIAEEQCABQQhrIgIoAgBBAUcNASABKAIIIQMgASgCBCEEIAJBADYCAAJAIAJBf0YNACABQQRrIgEgASgCAEEBayIBNgIAIAENACACQRRBBBD4OgsgACADNgIEIAAgBDYCAA8LEJg9AAtBl9rDAEE/EJc9AAvIAQIFfwFvIwBBEGsiAiQAIwBBEGsiASQAEBIhBhDfEiIDIAYmASADIQQgAUEIahDOLUEBIQMgAkEIaiIFAn8gASgCCEEBcQRAIAEoAgwMAQtBACEDIAQLNgIEIAUgAzYCACABQRBqJAAgAigCDCEBIAACfwJAIAIoAghBAXFFDQAgAiABEIQZIAIoAgQhASACKAIAIgNFDQAgAEEAIAIgAyABENgpNgIEQQEMAQsgACABNgIUIABBADYCCEEACzYCACACQRBqJAALewIBfwF+IwBBEGsiASQAIABBEGooAgAlARATIAFBCGogAEEIaikCADcDACAAKQIAIQIgAEEANgIEIAEgAjcDAAJAIAEoAgRFDQAgASgCABD/LyIAQYQBTwRAIAAQ8h8LIAFBDGoQrDtFDQAgAUEEchC8KgsgAUEQaiQAC3oBAX8CQAJAAkACQCAALQAADgIBAgALIAAoAhAiASABKAIAIgFBAWs2AgAgAUEBRw0CIABBEGoQuyMPCyAAQQhqELEsDwsgACgCECIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEQahD4IwsgAEEEaiIAEMMnIAAQ6jsLC3gAIAFB/wFxQcEASQRAIAAgAikCADcCCCAAQRBqIAJBCGooAgA2AgAgAEEYakEAQcAA/AsAIABBADYCaCAAQQA6ABQgAEIANwMAIAAgAToAdCAAQgA3AmwgAEIANwNYIABCfzcDYA8LQdj3zABBIUH898wAEJ8pAAt+AQN/IwBBEGsiAyQAIANBBGpBEEEAQQJBAhCgGCADKAIIIQQgAygCBEEBRgRAIAQgAygCDEGIss4AEP0vAAsgAygCDCEFIABBADsBFCAAIAI2AhAgACABNgIMIABBAjoAFiAAQQA2AgggACAFNgIEIAAgBDYCACADQRBqJAALbAIBfwJ+IwBBEGsiBCQAIARBCGogAUECIAJBAXMgAxtBB3RqIgFBzANqEIwpIAQzAQghBSAEMwEKIQYgBCABQYwEahCMKSAAIAUgBDMBAkIwhiAEMwEAQiCGhCAGQhCGhIQ3AQAgBEEQaiQAC4QBAQF+AkACQAJAQQEgACkDACIBp0EJayABQghYGw4CAQIACyAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgAEHsAGogACgCZCAAKAJoIAAoAmAoAhARAQAgAEEIahDCGA8LIABB5ABqIAAoAlwgACgCYCAAKAJYKAIQEQEAIAAQwhgLbAAgAUF9cUEBRgRAIABCADcDyAQgAEEANgLkEgsgAUF+cUECRwRAQQAPCyAAKALkEgRAQUQPCyAAEOUkIABBvB1qQgA3AgAgAEIANwK0HSAAQQxqQQBBrAH8CwAgAEEBNgIsIABBAzYCOEEAC3IBAn8Cf0EAIAEgACgCJCICTQ0AGgJAIAINACAAIAAoAggiAjYCECAAIAAoAgQiA0FAcTYCGEFAIAMgAkEAIAJrQT9xIgNqIgJJDQEaIAAgAjYCDCAAIAI2AgggA0UNACAAIAI2AhALIAAgATYCJEEACwt5AQN/IwBBEGsiAyQAIANBBGogAkEAQQFBARCgGCADKAIIIQQgAygCBEEBRwRAIAMoAgwhBSACBEAgBSABIAL8CgAACyAAIAI2AgggACAFNgIEIAAgBDYCACAAQQE6AAwgA0EQaiQADwsgBCADKAIMQYCq/gAQ/S8AC3sBAn8jAEEgayICJAACfyAALwEAIgNBBE0EQCABIANBAnRBpPH+AGooAgBBAhD7NQwBCyACQQI2AgQgAkHg7v4ANgIAIAJCATcCDCACQfULNgIcIAIgADYCGCACIAJBGGo2AgggASgCACABKAIEIAIQywoLIAJBIGokAAvWBQIKfwR+IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhByAAIAAgAkECdGoiAigCADYCACACIAc2AgAgAQJ/IABBBGohB0EAIAFBAWsiBUUNABogAygCACEIIAcoAgAhCgJAAkACQAJAIAciAkEEaiIDIAIgBUECdGoiC0EEayIJSQRAIAAoAgAhAwNAIAJBBGoiDCgCACIFIAgoAgQiBE8NAiADIARPDQMgCCgCACIEIANBA3QiDWopAwAhDiAEIAVBA3RqKQMAIQ8gAiAHIAZBAnRqIgQoAgA2AgAgBCAFNgIAIAJBCGoiAigCACIFIAgoAgQiBE8NBCADIARPDQUgCCgCACIEIA1qKQMAIRAgBCAFQQN0aikDACERIAwgByAGIA4gD1VqIgZBAnRqIgQoAgA2AgAgBCAFNgIAIAYgECARVWohBiACQQRqIAlJDQALIAJBBGohAwsCQAJAAkACQCADIAtHBEAgACgCACEFA0AgAygCACIEIAgoAgQiCU8NAiAFIAlPDQMgCCgCACIJIAVBA3RqKQMAIQ4gCSAEQQN0aikDACEPIAIgByAGQQJ0aiICKAIANgIAIAIgBDYCACAGIA4gD1VqIQYgAyICQQRqIgMgC0cNAAsgA0EEayECCyAKIAgoAgQiA08NAiAAKAIAIgUgA08NAyAIKAIAIgMgBUEDdGopAwAhDiADIApBA3RqKQMAIQ8gAiAHIAZBAnRqIgIoAgA2AgAgAiAKNgIAIAYgDiAPVWoMCAsgBCAJQZCDhAEQwyEACyAFIAlBoIOEARDDIQALIAogA0GQg4QBEMMhAAsgBSADQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsgBSAEQZCDhAEQwyEACyADIARBoIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC6wFAQ1/IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhByAAIAAgAkECdGoiAigCADYCACACIAc2AgAgAQJ/IABBBGohB0EAIAFBAWsiBEUNABogAygCACEKIAAoAgAhCCAHKAIAIQsCQAJAAkAgByICQQRqIgMgAiAEQQJ0aiINQQRrIglJBEADQCAIIAooAgAiBigCBCIETw0EIAJBBGoiDigCACIDIARPDQIgBigCACIEIANBAnRqKAIAIQYgBCAIQQJ0Ig9qKAIAIRAgAiAHIAVBAnRqIgQoAgA2AgAgBCADNgIAIAggCigCACIMKAIEIgRPDQQgAkEIaiICKAIAIgMgBE8NAyAMKAIAIgQgA0ECdGooAgAhDCAEIA9qKAIAIQQgDiAHIAUgBiAQTWoiBUECdGoiBigCADYCACAGIAM2AgAgBSAEIAxPaiEFIAJBBGogCUkNAAsgAkEEaiEDCwJAAkAgAyANRwRAA0AgCCAKKAIAIgYoAgQiBE8NBiADKAIAIgkgBE8NAiAGKAIAIgQgCUECdGooAgAhBiAEIAhBAnRqKAIAIQQgAiAHIAVBAnRqIgIoAgA2AgAgAiAJNgIAIAUgBCAGT2ohBSADIgJBBGoiAyANRw0ACyADQQRrIQILIAggCigCACIDKAIEIgRPDQQgBCALTQ0BIAMoAgAiAyALQQJ0aigCACEEIAMgCEECdGooAgAhAyACIAcgBUECdGoiAigCADYCACACIAs2AgAgBSADIARPagwFCyAJIARBoIOEARDDIQALIAsgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyADIARBoIOEARDDIQALIAggBEGQg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwALrgUCC38EfiABRQRAQQAPCwJAIAEgAk0NACAAKAIAIQYgACAAIAJBAnRqIgIoAgA2AgAgAiAGNgIAIAECfyAAQQRqIQZBACABQQFrIgRFDQAaIAMoAgAhCiAAKAIAIQcgBigCACELAkACQAJAIAYiAkEEaiIDIAIgBEECdGoiDEEEayIISQRAA0AgByAKKAIAIgkoAgQiBE8NBCACQQRqIg0oAgAiAyAETw0CIAkoAgAiBCADQQN0aikDACEPIAQgB0EDdCIJaikDACEQIAIgBiAFQQJ0aiIEKAIANgIAIAQgAzYCACAHIAooAgAiDigCBCIETw0EIAJBCGoiAigCACIDIARPDQMgDigCACIEIANBA3RqKQMAIREgBCAJaikDACESIA0gBiAFIA8gEFhqIgRBAnRqIgUoAgA2AgAgBSADNgIAIAQgESASWGohBSACQQRqIAhJDQALIAJBBGohAwsCQAJAIAMgDEcEQANAIAcgCigCACIJKAIEIgRPDQYgAygCACIIIARPDQIgCSgCACIEIAhBA3RqKQMAIQ8gBCAHQQN0aikDACEQIAIgBiAFQQJ0aiICKAIANgIAIAIgCDYCACAFIA8gEFhqIQUgAyICQQRqIgMgDEcNAAsgA0EEayECCyAHIAooAgAiAygCBCIETw0EIAQgC00NASADKAIAIgMgC0EDdGopAwAhDyADIAdBA3RqKQMAIRAgAiAGIAVBAnRqIgIoAgA2AgAgAiALNgIAIAUgDyAQWGoMBQsgCCAEQaCDhAEQwyEACyALIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAHIARBkIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC9QFAQx/IAFFBEBBAA8LAkAgASACTQ0AIAAoAgAhCSAAIAAgAkECdGoiAigCADYCACACIAk2AgAgAQJ/IABBBGohCUEAIAFBAWsiBUUNABogAygCACEHIAkoAgAhCwJAAkACQAJAIAkiAkEEaiIDIAIgBUECdGoiDUEEayIISQRAIAAoAgAhAwNAIAJBBGoiCigCACIFIAcoAgQiBE8NAiADIARPDQMgBygCACIEIANBAnQiDGooAgAhDiAEIAVBAnRqKAIAIQ8gAiAJIAZBAnRqIgQoAgA2AgAgBCAFNgIAIAJBCGoiAigCACIFIAcoAgQiBE8NBCADIARPDQUgBygCACIEIAxqKAIAIQwgBCAFQQJ0aigCACEEIAogCSAGIA4gD0pqIgZBAnRqIgooAgA2AgAgCiAFNgIAIAYgBCAMSGohBiACQQRqIAhJDQALIAJBBGohAwsCQAJAAkACQCADIA1HBEAgACgCACEFA0AgAygCACIEIAcoAgQiCE8NAiAFIAhPDQMgBygCACIIIAVBAnRqKAIAIQogCCAEQQJ0aigCACEIIAIgCSAGQQJ0aiICKAIANgIAIAIgBDYCACAGIAggCkhqIQYgAyICQQRqIgMgDUcNAAsgA0EEayECCyALIAcoAgQiA08NAiAAKAIAIgUgA08NAyAHKAIAIgMgBUECdGooAgAhByADIAtBAnRqKAIAIQMgAiAJIAZBAnRqIgIoAgA2AgAgAiALNgIAIAYgAyAHSGoMCAsgBCAIQZCDhAEQwyEACyAFIAhBoIOEARDDIQALIAsgA0GQg4QBEMMhAAsgBSADQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsgBSAEQZCDhAEQwyEACyADIARBoIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC64FAgt/BH4gAUUEQEEADwsCQCABIAJNDQAgACgCACEGIAAgACACQQJ0aiICKAIANgIAIAIgBjYCACABAn8gAEEEaiEGQQAgAUEBayIERQ0AGiADKAIAIQogACgCACEHIAYoAgAhCwJAAkACQCAGIgJBBGoiAyACIARBAnRqIgxBBGsiCEkEQANAIAcgCigCACIJKAIEIgRPDQQgAkEEaiINKAIAIgMgBE8NAiAJKAIAIgQgA0EDdGopAwAhDyAEIAdBA3QiCWopAwAhECACIAYgBUECdGoiBCgCADYCACAEIAM2AgAgByAKKAIAIg4oAgQiBE8NBCACQQhqIgIoAgAiAyAETw0DIA4oAgAiBCADQQN0aikDACERIAQgCWopAwAhEiANIAYgBSAPIBBXaiIEQQJ0aiIFKAIANgIAIAUgAzYCACAEIBEgEldqIQUgAkEEaiAISQ0ACyACQQRqIQMLAkACQCADIAxHBEADQCAHIAooAgAiCSgCBCIETw0GIAMoAgAiCCAETw0CIAkoAgAiBCAIQQN0aikDACEPIAQgB0EDdGopAwAhECACIAYgBUECdGoiAigCADYCACACIAg2AgAgBSAPIBBXaiEFIAMiAkEEaiIDIAxHDQALIANBBGshAgsgByAKKAIAIgMoAgQiBE8NBCAEIAtNDQEgAygCACIDIAtBA3RqKQMAIQ8gAyAHQQN0aikDACEQIAIgBiAFQQJ0aiICKAIANgIAIAIgCzYCACAFIA8gEFdqDAULIAggBEGgg4QBEMMhAAsgCyAEQaCDhAEQwyEACyADIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgByAEQZCDhAEQwyEACyICTQ0AIAAoAgAhASAAIAAgAkECdGoiACgCADYCACAAIAE2AgAgAg8LAAusBQENfyABRQRAQQAPCwJAIAEgAk0NACAAKAIAIQcgACAAIAJBAnRqIgIoAgA2AgAgAiAHNgIAIAECfyAAQQRqIQdBACABQQFrIgRFDQAaIAMoAgAhCiAAKAIAIQggBygCACELAkACQAJAIAciAkEEaiIDIAIgBEECdGoiDUEEayIJSQRAA0AgCCAKKAIAIgYoAgQiBE8NBCACQQRqIg4oAgAiAyAETw0CIAYoAgAiBCADQQJ0aigCACEGIAQgCEECdCIPaigCACEQIAIgByAFQQJ0aiIEKAIANgIAIAQgAzYCACAIIAooAgAiDCgCBCIETw0EIAJBCGoiAigCACIDIARPDQMgDCgCACIEIANBAnRqKAIAIQwgBCAPaigCACEEIA4gByAFIAYgEExqIgVBAnRqIgYoAgA2AgAgBiADNgIAIAUgBCAMTmohBSACQQRqIAlJDQALIAJBBGohAwsCQAJAIAMgDUcEQANAIAggCigCACIGKAIEIgRPDQYgAygCACIJIARPDQIgBigCACIEIAlBAnRqKAIAIQYgBCAIQQJ0aigCACEEIAIgByAFQQJ0aiICKAIANgIAIAIgCTYCACAFIAQgBk5qIQUgAyICQQRqIgMgDUcNAAsgA0EEayECCyAIIAooAgAiAygCBCIETw0EIAQgC00NASADKAIAIgMgC0ECdGooAgAhBCADIAhBAnRqKAIAIQMgAiAHIAVBAnRqIgIoAgA2AgAgAiALNgIAIAUgAyAETmoMBQsgCSAEQaCDhAEQwyEACyALIARBoIOEARDDIQALIAMgBEGgg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAIIARBkIOEARDDIQALIgJNDQAgACgCACEBIAAgACACQQJ0aiIAKAIANgIAIAAgATYCACACDwsAC9YFAgp/BH4gAUUEQEEADwsCQCABIAJNDQAgACgCACEHIAAgACACQQJ0aiICKAIANgIAIAIgBzYCACABAn8gAEEEaiEHQQAgAUEBayIFRQ0AGiADKAIAIQggBygCACEKAkACQAJAAkAgByICQQRqIgMgAiAFQQJ0aiILQQRrIglJBEAgACgCACEDA0AgAkEEaiIMKAIAIgUgCCgCBCIETw0CIAMgBE8NAyAIKAIAIgQgA0EDdCINaikDACEOIAQgBUEDdGopAwAhDyACIAcgBkECdGoiBCgCADYCACAEIAU2AgAgAkEIaiICKAIAIgUgCCgCBCIETw0EIAMgBE8NBSAIKAIAIgQgDWopAwAhECAEIAVBA3RqKQMAIREgDCAHIAYgDiAPVmoiBkECdGoiBCgCADYCACAEIAU2AgAgBiAQIBFWaiEGIAJBBGogCUkNAAsgAkEEaiEDCwJAAkACQAJAIAMgC0cEQCAAKAIAIQUDQCADKAIAIgQgCCgCBCIJTw0CIAUgCU8NAyAIKAIAIgkgBUEDdGopAwAhDiAJIARBA3RqKQMAIQ8gAiAHIAZBAnRqIgIoAgA2AgAgAiAENgIAIAYgDiAPVmohBiADIgJBBGoiAyALRw0ACyADQQRrIQILIAogCCgCBCIDTw0CIAAoAgAiBSADTw0DIAgoAgAiAyAFQQN0aikDACEOIAMgCkEDdGopAwAhDyACIAcgBkECdGoiAigCADYCACACIAo2AgAgBiAOIA9WagwICyAEIAlBkIOEARDDIQALIAUgCUGgg4QBEMMhAAsgCiADQZCDhAEQwyEACyAFIANBoIOEARDDIQALIAUgBEGQg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwAL1AUBDH8gAUUEQEEADwsCQCABIAJNDQAgACgCACEJIAAgACACQQJ0aiICKAIANgIAIAIgCTYCACABAn8gAEEEaiEJQQAgAUEBayIFRQ0AGiADKAIAIQcgCSgCACELAkACQAJAAkAgCSICQQRqIgMgAiAFQQJ0aiINQQRrIghJBEAgACgCACEDA0AgAkEEaiIKKAIAIgUgBygCBCIETw0CIAMgBE8NAyAHKAIAIgQgA0ECdCIMaigCACEOIAQgBUECdGooAgAhDyACIAkgBkECdGoiBCgCADYCACAEIAU2AgAgAkEIaiICKAIAIgUgBygCBCIETw0EIAMgBE8NBSAHKAIAIgQgDGooAgAhDCAEIAVBAnRqKAIAIQQgCiAJIAYgDiAPS2oiBkECdGoiCigCADYCACAKIAU2AgAgBiAEIAxJaiEGIAJBBGogCEkNAAsgAkEEaiEDCwJAAkACQAJAIAMgDUcEQCAAKAIAIQUDQCADKAIAIgQgBygCBCIITw0CIAUgCE8NAyAHKAIAIgggBUECdGooAgAhCiAIIARBAnRqKAIAIQggAiAJIAZBAnRqIgIoAgA2AgAgAiAENgIAIAYgCCAKSWohBiADIgJBBGoiAyANRw0ACyADQQRrIQILIAsgBygCBCIDTw0CIAAoAgAiBSADTw0DIAcoAgAiAyAFQQJ0aigCACEHIAMgC0ECdGooAgAhAyACIAkgBkECdGoiAigCADYCACACIAs2AgAgBiADIAdJagwICyAEIAhBkIOEARDDIQALIAUgCEGgg4QBEMMhAAsgCyADQZCDhAEQwyEACyAFIANBoIOEARDDIQALIAUgBEGQg4QBEMMhAAsgAyAEQaCDhAEQwyEACyAFIARBkIOEARDDIQALIAMgBEGgg4QBEMMhAAsiAk0NACAAKAIAIQEgACAAIAJBAnRqIgAoAgA2AgAgACABNgIAIAIPCwALbgICfwF+IwBBEGsiAyQAAn8gASgCHCACQQR0aiICKQMApyIEQQ1PBEAgA0EIaiABKAIEIAIpAwgiBadBDGxqENw7IAMoAgggBUIgiKdqDAELIAJBBGoLIQEgACAENgIEIAAgATYCACADQRBqJAALhQEAIABCl67cuPHixYsXNwIMIAAgASkCGDcCGCAAIAEpAgA3AgAgACABKQIkNwIkIABBFGpBl67cuAE2AgAgAEEgaiABQSBqKAIANgIAIABBCGogAUEIaigCADYCACAAQSxqIAFBLGopAgA3AgAgAEE0aiABQTRqKQIANwIAIAFBDGoQwgwLqQgCCn8BfiMAQdAAayIDJAAjAEHgAWsiAiQAIAJBMGogARDcOwJAAkACQAJAAkACQCACKAI0QQFGBEAgAkEgaiABEO88IAIoAiRBAUcNAyACQRBqIAEQ7zwgAigCFEUNBSACQdQBaiACKAIQIgRBGGoQ1AYgBCgCKCEKIAQoAiQhCyACQYABaiAEEL4VIAJBkAFqIARBDGoQgAsgBCgCLCIFBEAgBSAFKAIAIgZBAWo2AgAgBkEASA0FIAQoAkAhBiAEKAI8IQcgBCgCOCEIIAQoAjQhCSAEKAIwIQQLIAJB2ABqIAJB3AFqKAIANgIAIAJBQGsgAkGIAWooAgA2AgAgAkHMAGogAkGYAWooAgA2AgAgAiACKQLUATcDUCACIAo2AmAgAiALNgJcIAIgAikCgAE3AzggAiACKQKQATcCRCACIAY2AnggAiAHNgJ0IAIgCDYCcCACIAk2AmwgAiAENgJoIAIgBTYCZCABQRhqIQQgAS0AGEEeRw0BIAIgASgCHEEwaiIFNgJ8IAJB0ABqIgYgBRDFCARAIAJBkAFqIgUgAkE4akHEAPwKAAAgAkEIaiAFEKABIAIpAwghDCAFIAEQsRggAyAEENQGIANBIGogAUEsakEAIAEoAiwbEO4lIAMgDDcCDCADIAIpApABNwIUIANBHGogAkGYAWooAgA2AgAMBwsgAiAGNgLUASACQQI2ApQBIAJBjNeFATYCkAEgAkICNwKcASACQa8DNgKMASACQa8DNgKEASACIAJBgAFqNgKYASACIAJB/ABqNgKIAQwCCyACQShqIAEQ3DsgAkE7NgI8IAJBATYClAEgAkH42IUBNgKQASACQgE3ApwBIAIgAigCLDYCgAEgAiACQYABajYCOCACIAJBOGo2ApgBIANBCGogAkGQAWoQmQ4gA0EpOgAAIANBjYCAgHg2AgQMBQsgAkEBNgKUASACQdzXhQE2ApABIAJCATcCnAEgAkGvAzYChAEgAiAENgLUASACIAJBgAFqNgKYAQsgAiACQdQBajYCgAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBCACQThqEIknDAMLIAJBGGogARDvPCACQTs2AjwgAkEBNgKUASACQajYhQE2ApABIAJCATcCnAEgAiACKAIcNgKAASACIAJBgAFqNgI4IAIgAkE4ajYCmAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBAwCCwALQQBBAEGs1oUBEMMhAAsgARCJJyACQeABaiQAIAMtAABBKUcEQCAAIANBOPwKAAAgA0HQAGokAA8LIANByABqIANBFGooAgA2AgAgA0FAayADQQxqKQIANwMAIAMgAykCBDcDOEHQ1YUBQckAIANBOGpBnM+FAUGc1oUBENUeAAupCAIKfwF+IwBB0ABrIgMkACMAQeABayICJAAgAkEwaiABENw7AkACQAJAAkACQAJAIAIoAjRBAUYEQCACQSBqIAEQ7zwgAigCJEEBRw0DIAJBEGogARDvPCACKAIURQ0FIAJB1AFqIAIoAhAiBEEYahDUBiAEKAIoIQogBCgCJCELIAJBgAFqIAQQvhUgAkGQAWogBEEMahCACyAEKAIsIgUEQCAFIAUoAgAiBkEBajYCACAGQQBIDQUgBCgCQCEGIAQoAjwhByAEKAI4IQggBCgCNCEJIAQoAjAhBAsgAkHYAGogAkHcAWooAgA2AgAgAkFAayACQYgBaigCADYCACACQcwAaiACQZgBaigCADYCACACIAIpAtQBNwNQIAIgCjYCYCACIAs2AlwgAiACKQKAATcDOCACIAIpApABNwJEIAIgBjYCeCACIAc2AnQgAiAINgJwIAIgCTYCbCACIAQ2AmggAiAFNgJkIAFBGGohBCABLQAYQRtHDQEgAiABKAIcQTBqIgU2AnwgAkHQAGoiBiAFEMUIBEAgAkGQAWoiBSACQThqQcQA/AoAACACQQhqIAUQoAEgAikDCCEMIAUgARCyGCADIAQQ1AYgA0EgaiABQSxqQQAgASgCLBsQ7iUgAyAMNwIMIAMgAikCkAE3AhQgA0EcaiACQZgBaigCADYCAAwHCyACIAY2AtQBIAJBAjYClAEgAkGM14UBNgKQASACQgI3ApwBIAJBrwM2AowBIAJBrwM2AoQBIAIgAkGAAWo2ApgBIAIgAkH8AGo2AogBDAILIAJBKGogARDcOyACQTs2AjwgAkEBNgKUASACQfjYhQE2ApABIAJCATcCnAEgAiACKAIsNgKAASACIAJBgAFqNgI4IAIgAkE4ajYCmAEgA0EIaiACQZABahCZDiADQSk6AAAgA0GNgICAeDYCBAwFCyACQQE2ApQBIAJB3NeFATYCkAEgAkIBNwKcASACQa8DNgKEASACIAQ2AtQBIAIgAkGAAWo2ApgBCyACIAJB1AFqNgKAASADQQhqIAJBkAFqEJkOIANBKToAACADQY2AgIB4NgIEIAJBOGoQiScMAwsgAkEYaiABEO88IAJBOzYCPCACQQE2ApQBIAJBqNiFATYCkAEgAkIBNwKcASACIAIoAhw2AoABIAIgAkGAAWo2AjggAiACQThqNgKYASADQQhqIAJBkAFqEJkOIANBKToAACADQY2AgIB4NgIEDAILAAtBAEEAQazWhQEQwyEACyABEIknIAJB4AFqJAAgAy0AAEEpRwRAIAAgA0E4/AoAACADQdAAaiQADwsgA0HIAGogA0EUaigCADYCACADQUBrIANBDGopAgA3AwAgAyADKQIENwM4QdDVhQFByQAgA0E4akGcz4UBQZzWhQEQ1R4AC2gBAn8CQCABIANHDQAgAQRAA0AgAC0AACACLQAARw0CIABBBGooAgAiAyACQQRqKAIAIgVHBEAgA0EIaiAFQQhqEN8nRQ0DCyAAQQhqIQAgAkEIaiECIAFBAWsiAQ0ACwtBASEECyAEC20BAn8jAEEgayIEJAAgBEEMaiIFIAEgAiADEKUaIAUgBCgCGCAEQRxqIgEoAgAiAhDTHyEDIABBEGogASgCADYCACAAQQhqIARBFGopAgA3AgAgACAEKQIMNwIAIAAgAiADazYCFCAEQSBqJAALdAEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEJcVCyAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQRqEPgjCwJAIAAoAggiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEIahDbHgsLgwEBAX8gAEEBOgAsIAAtABwhASAAQQE6ABwCQCABDQAgAEEAOgAcIAAoAhQhASAAQQA2AhQgAUUNACAAKAIYIAEoAgwRAwALIAAtACghASAAQQE6ACgCQCABDQAgAEEAOgAoIAAoAiAhASAAQQA2AiAgAUUNACAAKAIkIAEoAgQRAwALC2sBAn8jAEHAAmsiAiQAIAJBCGoiAyAAEJUaIAJBuAJqIAJBmAFqKQMANwMAIAIgAikDkAE3A7ACIAJBqAFqIANBhAH8CgAAIAIgATYCrAIgAkEANgKgASACQaABahDRKUEIaiACQcACaiQAC3UBAX8jAEEQayIEJAAgBEEEaiABEN0gQcAAQQgQrTYiAUUEQEEIQcAAEKM9AAsgASADNgIoIAEgAjcDICABIAQpAgQ3AiwgAUEAOgA4IAFBNGogBEEMaigCADYCACAAQbCYwwA2AgQgACABNgIAIARBEGokAAt5AQJ/IAAoAgAiACkDCEIDUQRAAkAgACgC2AEiAUF/Rg0AIAEgASgCBCICQQFrNgIEIAJBAUcNACABQSBBBBD4OgsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABB4AFBCBD4OgsPC0H8/8IAQR8Qhi4AC3YBAn8gACgCACIAKQMIUARAAkAgACgCcCIBQX9GDQAgASABKAIEIgJBAWs2AgQgAkEBRw0AIAFBIEEEEPg6CwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEH4AEEIEPg6Cw8LQfz/wgBBHxCGLgALdgECfyAAKAIAIgApAwhQBEACQCAAKAJQIgFBf0YNACABIAEoAgQiAkEBazYCBCACQQFHDQAgAUEgQQQQ+DoLAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQdgAQQgQ+DoLDwtB/P/CAEEfEIYuAAuwAQEDfyAAKAIIIgMgACgCAEYEQCMAQRBrIgIkACACQQhqIAAgACgCAEEBQQhBIBC3ESACKAIIIgRBgYCAgHhHBEAgBCACKAIMQZTHwwAQ/S8ACyACQRBqJAALIAAoAgQgA0EFdGoiAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAIAAgA0EBajYCCCAAIAMQkBMLewECfyMAQRBrIgMkAAJAIAMgASACQYCABE8EfyADQQhqIAEgAkEKdkHA0ABrEPcDQQAhAQJAIAMoAghBAWsOAwACAAILIAJB/wdxQYC4f3IFIAILEPcDIAMoAgQhBCADKAIAIQELIAAgBDYCBCAAIAE2AgAgA0EQaiQAC3wBAX8CQCAAKQMAQgVRDQAgACgCmAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBmAJqENkhCyAAQZACahC8KiAAQdAAahCTKiAAEP0uIAAoAvABQYCAgIB4RwRAIABB8AFqENovCyAAQaABaiIAKQMAQgZRDQAgABCxHgsLfAEBfwJAIAApAwBCBVENACAAKAKYAiIBIAEoAgAiAUEBazYCACABQQFGBEAgAEGYAmoQ2SELIABBkAJqELwqIABB0ABqEJMqIAAQ/S4gACgC8AFBgICAgHhHBEAgAEHwAWoQ2y8LIABBoAFqIgApAwBCBlENACAAELEeCwt+AQF/IwBBIGsiAyQAAkAgASkDAEICUgRAIAEtAFBFDQEgACABIAEoAkwiACACIAAgAkkbEN0OIANBIGokAA8LQZihzQBBLEGIos0AEJ8pAAsgA0EANgIYIANBATYCDCADQfChzQA2AgggA0IENwIQIANBCGpBmKLNABDvLAALdwEDfyAAKAIIIgIEQCAAKAIEIQADQCAAQQxqEJwMAkAgACgCAEGAgICAeEYEQCAAQQRqIgMoAgAiASABKAIAIgFBAWs2AgAgAUEBRw0BIAMQgyAMAQsgABC+HyAAQQRBIBDgHgsgAEEgaiEAIAJBAWsiAg0ACwsLawEDfyMAQSBrIgUkACAEKAIAIQYgBUEMaiIHIAIgAxDdEyIDQYh/TQRAIAAgByAAIAFqIARBBGogBkEQdkH/AXEQ4BhBbEFsIAEgBSgCEEEgRxsgBSgCFCAFKAIYRxshAwsgBUEgaiQAIAMLzgcBCX8jAEEgayIGJAAgBgJ/EIgsIQJBt7TCAC0AAEExRgR/QX4gAkUNARojAEGQ5gBrIgQkACACQQA2AhgCQCACKAIgIgEEQCACKAIkIgMNAQsgAkEANgIoQZwLIQMgAkGcCzYCJEGdCyEBIAJBnQs2AiALIARBEGpBAEHg5QD8CwAgBEH55QBqQgA3AAAgBEIANwL0ZSAEIAM2AohmIAQgATYChGYgBCACKAIoNgKMZiAEQYTmAGpBwABBgPEAELYbIgEEfyABQgA3AjAgAUEBNgIIIAFBADoABCABQYAINgIAIAFCADcCDCABQgA3AkwgAUEBNgJIIAFBADoAQCABQoGAgIAQNwI4IAFBIDYCbCABQgA3A3AgAUEUakIANwIAIAFBHGpCADcCACABQSRqQgA3AgAgAUHUAGpCADcCACABQdwAakIANwIAIAFB5ABqQgA3AgAgAUGAAWpCADcDACABQfgAakIANwMAIAFBADYCnAEgAUEAOgCgASABQZgBaiAEQYDmAGotAAA6AAAgAUGQAWogBEH45QBqKQMANwMAIAEgBCkD8GU3A4gBIAFBoQFqIARBDWpB4+UA/AoAACABQYTnAGpBAEHACfwLACACIAE2AhwjAEEwayIDJAACQAJAIAIoAhwiASgCDCIHQUBqQUFJBEAgB0HBAEkNAiABLQACQQ9GDQIgAUEIaiEHIANCADcCDCADQgE3AgQDQCADQQRqIAVqIggoAgAhCSAIIAUgB2oiCCgCADYCACAIIAk2AgAgBUEEaiIFQRBHDQALIAMgAygCCCIFNgIUIAVFDQEgAkEgaiADKAIEIAUQjRkMAgtB+O/8AEHKAEHE8PwAEJ8pAAsgA0EANgIYQQEgA0EUakHI//sAIANBGGpBvJX8ABCvKwALIAFBADYChAEgAUIANwMQIAFBDzoAAiABQQA6AAMgAkEANgIIIAJCADcCFCACKAIcIgFBADYCVCABLQADIgUEQCACIAVBAXE2AjALIAFBADoAACABQv////8fNwN4IAFCgICAgICAIDcCjAEgAUEAOgBAIAFCgYCAgBA3AzggAUIANwMwIAFBADoAoAEgAUEANgKcASABQQA6AJgBIAFBADYClAEgAUEANgIoIAFBfzYCZCABIAEtAAFB+AFxQQRyOgABIANBMGokAEEABUF8CyAEQZDmAGokAAVBegsLIgE2AgQgAUUEQCAAQgA3AwAgACACNgIQIABBCGpCADcDACAGQSBqJAAPCyAGQQA2AgggBkEEaiAGQQhqQcC9+wAQjisAC9IDAg1/AX4jAEFAaiIDJAAgAyACNgIMIANBEGoiDCABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjQgAyADQQxqNgI8IANBKGohCSMAQSBrIgEkACABQRRqIANBNGoiCyICKAIEIAIoAgBrQQJ2QQBBEEEQEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBCQAIAFBCGoiBSACKAIEIAIoAgBrQQJ2EOstIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQjAEEQayIFJAAgBEEEaiIGKAIEIQcgBigCACACKAIAIgggAigCBCIKRwRAIAIoAgghDyAGKAIIIAdBBHRqIQIgByAKIAhrQQJ2IgZqIQcDQCAFIA8oAgAiCikDACAKKQMIIAg0AgAiECAQQj+HEKgeIAIgBSkDADcDACACIAUpAwg3AwggCEEEaiEIIAJBEGohAiAGQQFrIgYNAAsLIAc2AgAgBUEQaiQAIARBEGokACAJQQhqIA0oAgA2AgAgCSABKQIINwIAIAFBIGokACALIAkQ7BggACALIAwQyx0gA0FAayQAC8sDAgt/AX4jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAQgAUEMahCQLyAEIAQpAwA3AjQgBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQRBBBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgckACADQQhqIgEgBSgCBCAFKAIAa0EDdhDuLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIAdBBGoiBigCBCEIIAYoAgAhDQJAAkAgBSgCACIJIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAIQQJ0aiEGIAIgCWtBA3YhAgNAIAkpAwAiDkKAgICACHxCgICAgBBaDQIgBiABKAIAKAIAIA6nbDYCACAJQQhqIQkgBkEEaiEGIAhBAWohCCACQQFrIgINAAsLIA0gCDYCAAwBC0GAroABELI7AAsgB0EQaiQAIApBCGogDCgCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUgChDoGCAAIAUgCxDKHSAEQUBrJAAL2gUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIGJAAgAkEIaiIBIAMoAgQgAygCAGtBAnYQ7y0gBiABKQIEQiCJNwIIIAYgAUEIajYCBCMAQYABayIBJAAgBkEEaiIFKAIEIQcgBSgCACADKAIAIgggAygCBCIJRwRAIAMoAgghDyAFKAIIIAdBBXRqIQMgByAJIAhrQQJ2IglqIQcDQCABQeAAaiAINAIAIhAgEEI/hxCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAhBBGohCCADQSBqIQMgCUEBayIJDQALCyAHNgIAIAFBgAFqJAAgBkEQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALtAQCEH8BfiMAQUBqIgMkACADIAI2AgwgA0EQaiIPIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiIMIgIoAgQgAigCAGtBAnZBAEEQQRAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiEEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBAnYQ6y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIRECQAJAIAIoAgAiCCACKAIEIgdHBEAgAigCCCESIAYoAgggBUEEdGohBiAHIAhrQQJ2IQ0DQEGAgICAeCEHIBIoAgAiDigCACgCACECIAYCfwJAAkAgCCgCACIKQYCAgIB4RgRAQQAhCyACQX9GDQELIAJFDQUgCiAKIAJtIgcgAmxrQQAgAkF/RxshCyAKQQBODQELIAcgCyAOKAIIKAIATGsMAQsgByALIA4oAgQoAgBOagusIhM3AwAgBiATQj+HNwMIIAhBBGohCCAGQRBqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEOwYIAAgDCAPEMsdIANBQGskAAvTBAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQQRBBBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDuLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkACQCACKAIAIgcgAigCBCIIRwRAIAIoAgghDiAGKAIIIAVBAnRqIQIgCCAHa0EDdiEGA0BCgICAgICAgICAfyEQIA4oAgAiCCgCACkDACEPAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CyIPQoCAgIAIfEKAgICAEFoNAyACIA8+AgAgB0EIaiEHIAJBBGohAiAFQQFqIQUgBkEBayIGDQALCyANIAU2AgAMAgtBtKiAARDiKwALQfCtgAEQsjsACyAEQRBqJAAgCUEIaiAMKAIANgIAIAkgASkCCDcCACABQSBqJAAgCiAJEOgYIAAgCiALEModIANBQGskAAumBAEQfyMAQUBqIgMkACADIAI2AgwgA0EQaiIPIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiIMIgIoAgQgAigCAGtBAnZBAEEIQQgQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiEEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBAnYQ7C0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIRECQAJAIAIoAgAiCCACKAIEIgdHBEAgAigCCCESIAYoAgggBUEDdGohBiAHIAhrQQJ2IQ0DQEGAgICAeCEHIBIoAgAiDigCACgCACECIAYCfwJAAkAgCCgCACIKQYCAgIB4RgRAQQAhCyACQX9GDQELIAJFDQUgCiAKIAJtIgcgAmxrQQAgAkF/RxshCyAKQQBODQELIAcgCyAOKAIIKAIATGsMAQsgByALIA4oAgQoAgBOagusNwMAIAhBBGohCCAGQQhqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEL0YIAAgDCAPEMYdIANBQGskAAu/BAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQRBBEBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDrLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkAgAigCACIHIAIoAgQiCEcEQCACKAIIIQ4gBigCCCAFQQR0aiECIAggB2tBA3YhBgNAQoCAgICAgICAgH8hECAOKAIAIggoAgApAwAhDyACAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CyIPNwMAIAIgD0I/hzcDCCAHQQhqIQcgAkEQaiECIAVBAWohBSAGQQFrIgYNAAsLIA0gBTYCAAwBC0G0qIABEOIrAAsgBEEQaiQAIAlBCGogDCgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAogCRDsGCAAIAogCxDLHSADQUBrJAALnQMBC38jAEFAaiIEJAAgBCACNgIMIARBEGoiCyABEJI2EO4lIAQgAUEMahCQLyAEIAQpAwA3AjQgBCAEQQxqNgI8IARBKGohCiMAQSBrIgMkACADQRRqIARBNGoiBSgCBCAFKAIAa0EDdkEAQQhBCBCgGCADKAIYIQEgAygCFEEBRgRAIAEgAygCHEHcj/8AEP0vAAsgA0EQaiIMQQA2AgAgAyADKAIcNgIMIAMgATYCCCMAQRBrIgckACADQQhqIgEgBSgCBCAFKAIAa0EDdhDsLSAHIAEpAgRCIIk3AgggByABQQhqNgIEIAdBBGoiBigCBCEIIAYoAgAgBSgCACIJIAUoAgQiAkcEQCAFKAIIIQEgBigCCCAIQQN0aiEGIAggAiAJa0EDdiICaiEIA0AgBiABKAIAKQMAIAkpAwB+NwMAIAlBCGohCSAGQQhqIQYgAkEBayICDQALCyAINgIAIAdBEGokACAKQQhqIAwoAgA2AgAgCiADKQIINwIAIANBIGokACAFIAoQvRggACAFIAsQxh0gBEFAayQAC50DAQt/IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgsgARCSNhDuJSAEIAFBDGoQjy8gBCAEKQMANwI0IAQgBEEMajYCPCAEQShqIQojAEEgayIDJAAgA0EUaiAEQTRqIgUoAgQgBSgCAGtBAnZBAEEEQQQQoBggAygCGCEBIAMoAhRBAUYEQCABIAMoAhxB3I//ABD9LwALIANBEGoiDEEANgIAIAMgAygCHDYCDCADIAE2AggjAEEQayIHJAAgA0EIaiIBIAUoAgQgBSgCAGtBAnYQ7i0gByABKQIEQiCJNwIIIAcgAUEIajYCBCAHQQRqIgYoAgQhCCAGKAIAIAUoAgAiCSAFKAIEIgJHBEAgBSgCCCEBIAYoAgggCEECdGohBiAIIAIgCWtBAnYiAmohCANAIAYgASgCACgCACAJKAIAbDYCACAJQQRqIQkgBkEEaiEGIAJBAWsiAg0ACwsgCDYCACAHQRBqJAAgCkEIaiAMKAIANgIAIAogAykCCDcCACADQSBqJAAgBSAKEOgYIAAgBSALEModIARBQGskAAuzBAIMfwR+IwBBQGoiAyQAIAMgAjYCDCADQRBqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwI0IAMgA0EMajYCPCADQShqIQkjAEEgayIBJAAgAUEUaiADQTRqIgoiAigCBCACKAIAa0EDdkEAQQhBCBCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHcj/8AEP0vAAsgAUEQaiIMQQA2AgAgASABKAIcNgIMIAEgBDYCCCMAQRBrIgQkACABQQhqIgUgAigCBCACKAIAa0EDdhDsLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAhDQJAAkAgAigCACIHIAIoAgQiCEcEQCACKAIIIQ4gBigCCCAFQQN0aiECIAggB2tBA3YhBgNAQoCAgICAgICAgH8hECAOKAIAIggoAgApAwAhDyACAn4CQAJAIAcpAwAiEUKAgICAgICAgIB/UQRAQgAhEiAPQn9RDQELIA9QDQUgESARIA9/IhAgD359QgAgD0J/UhshEiARQgBZDQELIBAgEiAIKAIIKQMAV619DAELIBAgEiAIKAIEKQMAWa18CzcDACAHQQhqIQcgAkEIaiECIAVBAWohBSAGQQFrIgYNAAsLIA0gBTYCAAwBC0G0qIABEOIrAAsgBEEQaiQAIAlBCGogDCgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAogCRC9GCAAIAogCxDGHSADQUBrJAAL2gUCDX8GfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIMIAEQkjYQ7iUgBCABQQxqEJAvIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAiQAIAJBFGogBEE0aiILIgMoAgQgAygCAGtBA3ZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxB3I//ABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIGJAAgAkEIaiIBIAMoAgQgAygCAGtBA3YQ7y0gBiABKQIEQiCJNwIIIAYgAUEIajYCBCMAQYABayIBJAAgBkEEaiIFKAIEIQcgBSgCACADKAIAIgggAygCBCIJRwRAIAMoAgghDyAFKAIIIAdBBXRqIQMgByAJIAhrQQN2IglqIQcDQCABQeAAaiAIKQMAIhAgEEI/hxCyLiABKQN4IRQgASkDcCEVIAEpA2ghECABQdAAaiAPKAIAIgUpAwAiEkIAIAEpA2AiE0IAEKgeIAFBQGsgEkIAIBBCABCoHiABQTBqIAUpAwgiEUIAIBNCABCoHiABQSBqIBFCACAQQgAQqB4gAUEQaiASIBEgFSAUEKgeIAEgBSkDECAFKQMYIBMgEBCoHiADIAEpA1A3AwAgAyABKQNYIhEgASkDQHwiECABKQMwfCIUNwMIIANBEGogASkDICIVIAEpAxB8IhIgASkDAHwiEyABKQNIIBAgEVStfHwiESABKQM4IBAgFFatfHwiEDcDACADQRhqIBAgEVStIBEgE1StIBIgE1atIAEpAwggEiAVVK0gASkDKCABKQMYfHx8fHx8NwMAIAhBCGohCCADQSBqIQMgCUEBayIJDQALCyAHNgIAIAFBgAFqJAAgBkEQaiQAIApBCGogDSgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALpQQBEH8jAEFAaiIDJAAgAyACNgIMIANBEGoiDyABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjQgAyADQQxqNgI8IANBKGohCSMAQSBrIgEkACABQRRqIANBNGoiDCICKAIEIAIoAgBrQQJ2QQBBBEEEEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIhBBADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBCQAIAFBCGoiBSACKAIEIAIoAgBrQQJ2EO4tIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQgBEEEaiIGKAIEIQUgBigCACERAkACQCACKAIAIgggAigCBCIHRwRAIAIoAgghEiAGKAIIIAVBAnRqIQYgByAIa0ECdiENA0BBgICAgHghByASKAIAIg4oAgAoAgAhAiAGAn8CQAJAIAgoAgAiCkGAgICAeEYEQEEAIQsgAkF/Rg0BCyACRQ0FIAogCiACbSIHIAJsa0EAIAJBf0cbIQsgCkEATg0BCyAHIAsgDigCCCgCAExrDAELIAcgCyAOKAIEKAIATmoLNgIAIAhBBGohCCAGQQRqIQYgBUEBaiEFIA1BAWsiDQ0ACwsgESAFNgIADAELQaSogAEQ4isACyAEQRBqJAAgCUEIaiAQKAIANgIAIAkgASkCCDcCACABQSBqJAAgDCAJEOgYIAAgDCAPEModIANBQGskAAudAwELfyMAQUBqIgQkACAEIAI2AgwgBEEQaiILIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiAyQAIANBFGogBEE0aiIFKAIEIAUoAgBrQQJ2QQBBCEEIEKAYIAMoAhghASADKAIUQQFGBEAgASADKAIcQdyP/wAQ/S8ACyADQRBqIgxBADYCACADIAMoAhw2AgwgAyABNgIIIwBBEGsiByQAIANBCGoiASAFKAIEIAUoAgBrQQJ2EOwtIAcgASkCBEIgiTcCCCAHIAFBCGo2AgQgB0EEaiIGKAIEIQggBigCACAFKAIAIgkgBSgCBCICRwRAIAUoAgghASAGKAIIIAhBA3RqIQYgCCACIAlrQQJ2IgJqIQgDQCAGIAEoAgApAwAgCTQCAH43AwAgCUEEaiEJIAZBCGohBiACQQFrIgINAAsLIAg2AgAgB0EQaiQAIApBCGogDCgCADYCACAKIAMpAgg3AgAgA0EgaiQAIAUgChC9GCAAIAUgCxDGHSAEQUBrJAAL0gMCDX8BfiMAQUBqIgMkACADIAI2AgwgA0EQaiIMIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCNCADIANBDGo2AjwgA0EoaiEJIwBBIGsiASQAIAFBFGogA0E0aiILIgIoAgQgAigCAGtBA3ZBAEEQQRAQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiDUEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIEJAAgAUEIaiIFIAIoAgQgAigCAGtBA3YQ6y0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCMAQRBrIgUkACAEQQRqIgYoAgQhByAGKAIAIAIoAgAiCCACKAIEIgpHBEAgAigCCCEPIAYoAgggB0EEdGohAiAHIAogCGtBA3YiBmohBwNAIAUgDygCACIKKQMAIAopAwggCCkDACIQIBBCP4cQqB4gAiAFKQMANwMAIAIgBSkDCDcDCCAIQQhqIQggAkEQaiECIAZBAWsiBg0ACwsgBzYCACAFQRBqJAAgBEEQaiQAIAlBCGogDSgCADYCACAJIAEpAgg3AgAgAUEgaiQAIAsgCRDsGCAAIAsgDBDLHSADQUBrJAAL+QQCEX8DfiMAQUBqIgQkACAEIAI2AgwgBEEQaiIQIAEQkjYQ7iUgBCABQQxqEI8vIAQgBCkDADcCNCAEIARBDGo2AjwgBEEoaiEKIwBBIGsiASQAIAFBFGogBEE0aiINIgIoAgQgAigCAGtBAnZBAEEQQSAQoBggASgCGCEDIAEoAhRBAUYEQCADIAEoAhxB3I//ABD9LwALIAFBEGoiEUEANgIAIAEgASgCHDYCDCABIAM2AggjAEEQayIHJAAgAUEIaiIDIAIoAgQgAigCAGtBAnYQ7y0gByADKQIEQiCJNwIIIAcgA0EIajYCBCMAQSBrIgMkACAHQQRqIgUoAgQhCCAFKAIAIRICQAJAIAIoAgAiCSACKAIEIgZHBEAgAigCCCETIAUoAgggCEEFdGohAiAGIAlrQQJ2IQ4DQEGAgICAeCEGIBMoAgAiDygCACgCACEFIAMCfwJAAkAgCSgCACILQYCAgIB4RgRAQQAhDCAFQX9GDQELIAVFDQUgCyALIAVtIgYgBWxrQQAgBUF/RxshDCALQQBODQELIAYgDCAPKAIIKAIATGsMAQsgBiAMIA8oAgQoAgBOagusIhQgFEI/hxCyLiADKQMAIRQgAykDCCEVIAMpAxAhFiACQRhqIAMpAxg3AwAgAkEQaiAWNwMAIAIgFTcDCCACIBQ3AwAgCUEEaiEJIAJBIGohAiAIQQFqIQggDkEBayIODQALCyASIAg2AgAgA0EgaiQADAELQaSogAEQ4isACyAHQRBqJAAgCkEIaiARKAIANgIAIAogASkCCDcCACABQSBqJAAgDSAKEO0YIAAgDSAQEM4dIARBQGskAAuEBQINfwR+IwBBQGoiBCQAIAQgAjYCDCAEQRBqIgwgARCSNhDuJSAEIAFBDGoQkC8gBCAEKQMANwI0IAQgBEEMajYCPCAEQShqIQojAEEgayIBJAAgAUEUaiAEQTRqIgsiAigCBCACKAIAa0EDdkEAQRBBIBCgGCABKAIYIQMgASgCFEEBRgRAIAMgASgCHEHcj/8AEP0vAAsgAUEQaiINQQA2AgAgASABKAIcNgIMIAEgAzYCCCMAQRBrIgYkACABQQhqIgMgAigCBCACKAIAa0EDdhDvLSAGIAMpAgRCIIk3AgggBiADQQhqNgIEIwBBIGsiAyQAIAZBBGoiBSgCBCEHIAUoAgAhDgJAAkAgAigCACIIIAIoAgQiCUcEQCACKAIIIQ8gBSgCCCAHQQV0aiECIAkgCGtBA3YhBQNAQoCAgICAgICAgH8hESAPKAIAIgkoAgApAwAhECADAn4CQAJAIAgpAwAiEkKAgICAgICAgIB/UQRAQgAhEyAQQn9RDQELIBBQDQUgEiASIBB/IhEgEH59QgAgEEJ/UhshEyASQgBZDQELIBEgEyAJKAIIKQMAV619DAELIBEgEyAJKAIEKQMAWa18CyIQIBBCP4cQsi4gAykDACEQIAMpAwghESADKQMQIRIgAkEYaiADKQMYNwMAIAJBEGogEjcDACACIBE3AwggAiAQNwMAIAhBCGohCCACQSBqIQIgB0EBaiEHIAVBAWsiBQ0ACwsgDiAHNgIAIANBIGokAAwBC0G0qIABEOIrAAsgBkEQaiQAIApBCGogDSgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAsgChDtGCAAIAsgDBDOHSAEQUBrJAALYgEDfyAAKAIAIgNBDXUiAUEBayEAIAFBAEwEQEEBIAFrQZADbkEBaiIBQc+Kd2whAiABQZADbCAAaiEACyACIANBBHZB/wNxaiAAQeQAbSIBayAAQbULbEECdWogAUECdWoLegECfyMAQRBrIgIkAEHAACEDAkAgAUHAABDRNARAIAEEQCABQcAAEK42IgNFDQILIAAgATYCDCAAIAM2AgggACABNgIEIABBwAA2AgAgAkEQaiQADwtBsPSHAUErIAJBD2pBoPSHAUGg9YcBENUeAAtBwAAgARCjPQALeAEBfyMAQeAAayIDJAAgA0EIaiAAKAIEIAAoAgggASACENAIIAMgAygCKCIANgJYIAMgAykDEDcDUCADIAMpAwg3A0ggAyADKQMgNwNAIAMgAykDGDcDOCADIAAgAygCLEEDdGo2AlwgA0E4ahDgJyADQeAAaiQAC2ICAn4BfyMAQTBrIgQkACABIAApAwgiAkIAWUEBQQBCACAAKQMAIgN9IAMgAkIAUyIAG0IAIAIgA0IAUq18fSACIAAbIARBCWoiARD6AiIAIAFqQScgAGsQgQkgBEEwaiQAC4kBAQF/AkACQAJAIAAtALwBDgQAAgIBAgsgAEGYAWoQ+SUgABCgKQ8LIABBuAFqEK0sIAAoArQBIgFBhAFPBEAgARDyHwsgAEEAOgC9ASAAKAKwASIBQYQBTwRAIAEQ8h8LAkAgACgCqAFFDQAgACgCrAEiAUGEAUkNACABEPIfCyAAQQA7Ab4BCwtsAQF/IwBB0ANrIgIkACACIAAQlRogAUEJSQRAIAJBmAFqIgAgAkGYAfwKAAAgACABEJQkIAJBuAJqIABBmAH8CgAAIAJBADYCsAIgAkGwAmoQ0SlBCGogAkHQA2okAA8LQeSCwwBBGRCXPQALbAEBfyMAQdADayICJAAgAiAAEJUaIAFBA0kEQCACQZgBaiIAIAJBmAH8CgAAIAAgAToAKiACQbgCaiAAQZgB/AoAACACQQA2ArACIAJBsAJqENEpQQhqIAJB0ANqJAAPC0HkgsMAQRkQlz0AC3YBAX8jAEFAaiIDJAAgAyABNwMIIAMgASACfEIBfTcDKCADQQI2AhQgA0GAl8MANgIQIANCAjcCHCADQTw2AjwgA0E8NgI0IAMgA0EwajYCGCADIANBKGo2AjggAyADQQhqNgIwIAAgA0EQahCZDiADQUBrJAAL4wEBA38gACgCACIAQQhqIQMjAEEQayIBJAACQAJAA0ACQCABIAMQzxkgASgCACICBEAgAkECaw0BDAMLIAEgASgCBEEIayICNgIMIAIgAigCACICQQFrNgIAIAJBAUcNASABQQxqELYfDAELCyABQRBqJAAMAQtBxIDDAEEUEIYuAAsgACgCDCIBBEAgACgCECABKAIMEQMACyADKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCADELYfCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEgQQQQ+DoLC+MBAQN/IAAoAgAiAEEIaiEDIwBBEGsiASQAAkACQANAAkAgASADEM0ZIAEoAgAiAgRAIAJBAmsNAQwDCyABIAEoAgRBCGsiAjYCDCACIAIoAgAiAkEBazYCACACQQFHDQEgAUEMahC3HwwBCwsgAUEQaiQADAELQcSAwwBBFBCGLgALIAAoAgwiAQRAIAAoAhAgASgCDBEDAAsgAygCACIBIAEoAgAiAUEBazYCACABQQFGBEAgAxC3HwsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBIEEEEPg6CwvjAQEDfyAAKAIAIgBBCGohAyMAQRBrIgEkAAJAAkADQAJAIAEgAxDOGSABKAIAIgIEQCACQQJrDQEMAwsgASABKAIEQQhrIgI2AgwgAiACKAIAIgJBAWs2AgAgAkEBRw0BIAFBDGoQuB8MAQsLIAFBEGokAAwBC0HEgMMAQRQQhi4ACyAAKAIMIgEEQCAAKAIQIAEoAgwRAwALIAMoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAMQuB8LAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQSBBBBD4OgsLcAEFfwJAIAAoAgAiASAAKAIEIgJHBEAgACgCDCEEIAAoAgghBSACIAFrQQJ2IQADQCABKAIAIgIgBE8NAiABQQRqIQEgAyAFIAJBBnRqKAIQaiEDIABBAWsiAA0ACwsgAw8LIAIgBEH8n8MAEMMhAAt5AQF/IwBBQGoiAiQAIAJBtMvDADYCFCACIAE2AhAgAiAANgIMIAJBAjYCHCACQeC7wwA2AhggAkICNwIkIAJBygE2AjwgAkE7NgI0IAIgAkEwajYCICACIAJBEGo2AjggAiACQQxqNgIwIAJBGGoQgRcgAkFAayQAC4IBAQF/AkACQAJAIAAtACwOBAACAgECCyAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABDUIgsgACgCBCIAQYQBSQ0BIAAQ8h8PCyAAQRBqEIYqIAAoAgwiASABKAIAQQFqNgIAIAAoAgAiASABKAIAQQFrIgE2AgAgAQ0AIAAQ1CILC3ABA38CQCAAKAIAIgAoAhgiAUUNACAAKAIcIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CyAAQQxqEN47AkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLdQECfyMAQRBrIgEkACAAKAIABEAgASAAKAIEIgA2AgggAUGw7cMAQRkQkz4iAjYCDCABQQhqIAFBDGoQojsgAkGEAU8EQCACEPIfIAEoAgghAAsgAEGEAU8EQCAAEPIfCyABQRBqJAAPC0HM7MMAQRwQlz0AC3oBAX8gACkDAEIFUgRAIAAoApACIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZACahDZIQsgAEGIAmoQvCogAEHQAGoQkyogABD9LiAAKALwASIBBEAgAEH8AWogACgC9AEgACgC+AEgASgCEBEBAAsgAEGgAWoQgh8LC3YBAX8jAEEwayICJAAgAiABKAIIQeTqzgAQzhggAkEBNgIMIAJBAjYCFCACQbDrzgA2AhAgAkIBNwIcIAJBOzYCLCACIAJBKGo2AhggAiACQQxqNgIoIABBBGogAkEQahCZDiAAQQA2AgAgAhDeOyACQTBqJAALdgEBfyMAQTBrIgIkACACIAEoAghB5OrOABDOGCACQRA2AgwgAkECNgIUIAJBsOvOADYCECACQgE3AhwgAkE7NgIsIAIgAkEoajYCGCACIAJBDGo2AiggAEEEaiACQRBqEJkOIABBADYCACACEN47IAJBMGokAAt2AQF/IwBBMGsiAiQAIAIgASgCCEHk6s4AEM4YIAJBDDYCDCACQQI2AhQgAkGw684ANgIQIAJCATcCHCACQTs2AiwgAiACQShqNgIYIAIgAkEMajYCKCAAQQRqIAJBEGoQmQ4gAEEANgIAIAIQ3jsgAkEwaiQAC20BAn8jAEEQayIBJAACQAJAAkAgACgC5AQiAEEIahDdJUH/AXFBBmsOAgEAAgsgAUEEaiAAKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKAKUBCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgtvAQJ/IwBBEGsiASQAAkACQAJAIAAoAoAFQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAoAFKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKAK4BCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgtvAQJ/IwBBEGsiASQAAkACQAJAIAAoApgFQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoApgFKAIUIgBBCGogACgCCEECRkECdGoQiRkgAS0ABCIAQQRGIABBDUZyDQELQQEhAgsgAUEQaiQAIAILbQECfyMAQRBrIgEkAAJAAkACQCAAKALoBCIAQQhqEN0lQf8BcUEGaw4CAQACCyABQQRqIAAoAhQiAEEIaiAAKAIIQQJGQQJ0ahCJGSABLQAEIgBBBEYgAEENRnINAQtBASECCyABQRBqJAAgAgttACAAIAJBmAH8CgAAIAAgAS0ApAE6AKQBIAAgASkDmAE3A5gBIABBoAFqIAFBoAFqKAIANgIAIAFB4ABqEN47IAFB7ABqEK4vIAFBQGsQ+CYgASgCeEGAgICAeEcEQCABQfgAakEEQQgQ4B4LC2gBBH8gACgCACIBQQRqIQMgACgCBCABa0EDdSEEQQAhAQNAIAIgBEZFBEAgASADLwEAaiEBIAAoAiggAkYEQCABQYCABGogASAAKAIkQQFGGyEBCyADQQhqIQMgAkEBaiECDAELCyABC3IBAn8CQANAAkAgAUHAACAAKAIIIgVrIgZNBEAgAUEhTw0DIAAgASAFajYCCCACIAFBAnRBhKn7AGooAgAgACkDACAFQT9xrYincTYCAAwBCyAAIAMgBBDLIA0BCwsgASAGTQ8LIAFBIUGIqvsAEMMhAAtvAQN/IAAoAggiAwRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ8iULIABBBGoiASgCACICIAIoAgAiAkEBazYCACACQQFGBEAgARC7IwsgAEEMaiEAIANBAWsiAw0ACwsLYAEDfyAAKAIIIgIEQCAAKAIEIQEDQCADIAEoAgBBCGooAhBqIQMgAUEMaiEBIAJBAWsiAg0ACwsgAyAAKAIYQQhqKAIQaiEBIAAoAiQiAAR/IAEgAEEIaigCEGoFIAELC3EBAn8CQCABKAIUIgUgACgCFCIGIAUgBkkbIgZFBEBBACEFDAELIAEoAhAhASAAKAIQIQBBACEFA0AgACABIAIgAyAEEOssRQ0BIABBxABqIQAgAUHEAGohASAGIAVBAWoiBUcNAAsgBiEFCyAFIAZPC3MBAn8jAEEQayICJAAgAkEIaiABQSBqELYZIAIoAgghAyAAIAIoAgw2AgQgACADNgIAIAAgASkDADcDCCAAQRBqIAFBCGopAwA3AwAgAEEYaiABQRBqKQMANwMAIABBIGogAUEYaikDADcDACACQRBqJAALjwEBAX8CQAJAIABBhAFPBEAgANBvJgFBoO+KASgCAA0BQaDvigFBfzYCACAAQbTvigEoAgAiAUkNAiAAIAFrIgBBrO+KASgCAE8NAkGo74oBKAIAIABBAnRqQbDvigEoAgA2AgBBsO+KASAANgIAQaDvigFBoO+KASgCAEEBajYCAAsPC0H4rogBEJs+AAsAC28BAX8jAEEQayIDJAAgAUEHakEAIAFrcSACaiICQYCAgIB4QQQgASABQQRNGyIBa0sEQEGQw4kBQSsgA0EPakGAw4kBQfzDiQEQ1R4ACyAAIAE2AgAgACABIAJqQQFrQQAgAWtxNgIEIANBEGokAAtkAQN/IwBBEGsiAiQAIAJBBGogASIDQQBBAUEAEKAYIAIoAgghASACKAIEQQFGBEAgASACKAIMQZyawwAQ/S8ACyACKAIMIQQgACADNgIIIAAgBDYCBCAAIAE2AgAgAkEQaiQAC5kBAgJ/AW8jAEFAaiICJAAgAAJ/IAEpAwBCAlEEQEEBIQMgASgCCAwBCyACQQA2AgggAkEQaiABQTD8CgAAAn9BwABBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIAJBCGpBOPwKAAAgAQwBC0EIQcAAEKM9AAtBCGoQACEEEN8SIgEgBCYBIAELNgIEIAAgAzYCACACQUBrJAALcQEDfyMAQRBrIgEkACABQQRqQccAQQBBAUEBEKAYIAEoAgghAiABKAIEQQFHBEAgASgCDCIDQajDwwBBxwD8CgAAIABBxwA2AgggACADNgIEIAAgAjYCACABQRBqJAAPCyACIAEoAgxB8MXDABD9LwALdAEDfyAAKAIUIQEgACgCGCIDKAIAIgIEQCABIAIRAwALIAMoAgQiAgRAIAEgAiADKAIIEPg6CyAAKAIcIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRxqEPgjCyAAKAIAQYCAgIB4RwRAIAAQ0C4gABDqOwsLcgECfyMAQRBrIgIkAAJAAkAgACgC8AEiAUE8TwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0cNAQtBxJ3EAEERQdidxAAQyyQACyACQQhqIAAgAUEBahCmECACKAIIIAIoAgwQgC0gAkEQaiQAC3MBAn8jAEEQayICJAACQAJAIAAoAvgHIgFB/gFPBEAgACgCBCIBQX9GDQELQX8gAWd2QQAgARsiAUF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAJBCGogACABQQFqEKUQIAIoAgggAigCDBCALSACQRBqJAALqgQCCX8BfiMAQRBrIgYkAAJAAkAgACgCZCIBQQlPBEAgACgCBCIBQX9GDQELQX8gAWd2QQAgARsiAkF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAZBCGohCUEIIQECQAJAIAJBAWoiBwJ/IAAoAmQiAkEITQRAIABBBGohBSACDAELIAAoAgghBSACIQEgACgCBAsiCE8EQAJAAkAgB0EJTwRAQYGAgIB4IQQgASAHRg0FIAetQgx+IgqnIQNBACEEIApCIIinDQUgA0EEENE0RQ0FIAJBCUkNAiABrUIMfiIKpyEBIApCIIhQDQEgASEDDAULQYGAgIB4IQQgAkEITQ0EIABBADYCACAIQQxsIgIEQCAAQQRqIAUgAvwKAAALIAAgCDYCZCMAQRBrIgAkACABrUIMfiIKpyEBAkAgCkIgiFAEQCABQQQQ0TQNAQsgACABNgIMIABBADYCCEHYnMQAQSsgAEEIakHInMQAQbSdxAAQ1R4ACyAFIAFBBBD4OiAAQRBqJAAMBAsgAUEEENE0RQ0DQQQhBCAFIAFBBCADEJc1IgFFDQMMAgtBBCEEIANBBBCtNiIBRQ0CIAhBDGwiAkUNASABIAUgAvwKAAAMAQtB6J3EAEEgQYiexAAQnykACyAAIAc2AmQgACABNgIIIAAgCDYCBCAAQQE2AgBBgYCAgHghBAsgCSADNgIEIAkgBDYCACAGKAIIIAYoAgwQgC0gBkEQaiQAC6kEAQl/IwBBEGsiByQAAkACQCAAKALcAyICQTxPBEAgACgCBCICQX9GDQELQX8gAmd2QQAgAhsiAUF/Rw0BC0HEncQAQRFB2J3EABDLJAALIAdBCGohCUE7IQICQAJAIAFBAWoiBQJ/IAAoAtwDIgFBO00EQCAAQQRqIQYgAQwBCyAAKAIIIQYgASECIAAoAgQLIghPBEACQAJAIAVBPE8EQEGBgICAeCEEIAIgBUYNBSAFQQN0IQNBACEEIAVB/////wFLDQUgA0EEENE0RQ0FIAFBPEkNAiACQQN0IQEgAkH/////AU0NASABIQMMBQtBgYCAgHghBCABQTtNDQQgAEEANgIAIAhBA3QiAQRAIABBBGogBiAB/AoAAAsgACAINgLcAyMAQRBrIgAkACACQQN0IQECQCACQf////8BTQRAIAFBBBDRNA0BCyAAIAE2AgwgAEEANgIIQdicxABBKyAAQQhqQcicxABBtJ3EABDVHgALIAYgAUEEEPg6IABBEGokAAwECyABQQQQ0TRFDQNBBCEEIAYgAUEEIAMQlzUiAkUNAwwCC0EEIQQgA0EEEK02IgJFDQIgCEEDdCIBRQ0BIAIgBiAB/AoAAAwBC0HoncQAQSBBiJ7EABCfKQALIAAgBTYC3AMgACACNgIIIAAgCDYCBCAAQQE2AgBBgYCAgHghBAsgCSADNgIEIAkgBDYCACAHKAIIIAcoAgwQgC0gB0EQaiQAC3EBAn8jAEEQayICJAACQAJAIAAoAkgiAUESTwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0cNAQtB7K7MAEERQZCvzAAQyyQACyACQQhqIAAgAUEBahCnECACKAIIIAIoAgwQgC0gAkEQaiQAC1sBA38jAEEQayIBJAAgAUEEaiAAEIcjIAEoAgQiACgCCCICBEAgACgCBCEAA0AgABCuNCADaiEDIABBFGohACACQQFrIgINAAsLIAFBBGoQgCsgAUEQaiQAIAMLaAECfyAAKAIcIQMgAEEANgIcIAAoAggiBCAAKAIYIANBA3ZqIANBB3FBAEdqIgNJBEAgAyAEQci6zgAQrzsACyABIAAoAgQgA2ogBCADayIBIAIgASACSRsiARChNiAAIAEgA2o2AhgLcQEDfyABKAIEQQFrIQQgASgCCCECAkADQCACRQ0BIAIgBGoiAyADLQAAQQFqIgM6AAAgAkEBayECIANB/wFxIANHDQALIAAgASkCADcCACAAQQhqIAFBCGooAgA2AgAPCyAAQYCAgIB4NgIAIAEQ3jsLcgEDfyMAQRBrIgMkACADQQRqIAJBAEEBQQEQoBggAygCCCEEIAMoAgRBAUcEQCADKAIMIQUgAgRAIAUgASAC/AoAAAsgACACNgIIIAAgBTYCBCAAIAQ2AgAgA0EQaiQADwsgBCADKAIMQfSOzwAQ/S8AC3IBA38jAEEQayIDJAAgA0EEaiACQQBBAUEBEKAYIAMoAgghBCADKAIEQQFHBEAgAygCDCEFIAIEQCAFIAEgAvwKAAALIAAgAjYCCCAAIAU2AgQgACAENgIAIANBEGokAA8LIAQgAygCDEHko88AEP0vAAujlAICIX8KfiMAQRBrIhckACABKAIIIRQgASgCBCEQIBcgASgCADYCCCAXIBA2AgQgFyAQNgIAIBcgECAUQbgFbGo2AgwgACEUIwBBQGoiEiQAIBJBCDYCACASQTBqIBdBCGopAgA3AwAgEiAXKQIANwMoIBIgEjYCOCMAQSBrIhYkACASQShqIhEoAgghHCARKAIAIRAgFiARKAIMNgIEIBEoAhAhACAWIBFBEGo2AhwgFiAANgIYIBYgFkEEajYCFCAWQQhqIRsgECEAIBZBFGohHiMAQZAJayIYJAACQCARKAIEIhMgESgCDCIfRg0AIBhBKGohICAYQRBqIRkDQCAYQdgDaiIOIBNBuAX8CgAAIBEgE0G4BWoiEzYCBCAYQQhqIRVBACEHQQAhCkEAIQsjAEHgDGsiDSQAAkACQAJAAkACQCAOKQMAQgJRBEAgDUGICWohBCMAQYAnayIJJAAgDkEIaiIDQQhqIQICQAJAAkACQAJAAkACQAJAAkAgAygCAEEBaw4HAQIDBAUGBwALIAkgAkGwBPwKAAAjAEGwBmsiAyQAAkACQAJAIAkoAqADRQ0AIANB2ANqIAkQ5gEgAygC2AMiAkEIRg0AIAQgAykC3AM3AgwgBEEcaiADQewDaigCADYCACAEQRRqIANB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCAJKAJYQYCAgIB4Rg0AIANB2ANqIAkQjwcgAygC2AMiAkEIRg0AIAQgAykC3AM3AgwgBEEcaiADQewDaigCADYCACAEQRRqIANB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAkoAqADRQ0AIANBGGogCRDmASADKAIYIgZBCEYNAAwBCwJAIAkoAqwCIgZFDQAgA0HgA2ohAgNAIAkgBkEBazYCrAIgCSAJKAKoAiIGQQFqIgUgCSgCoAIiB0EAIAUgB08bazYCqAIgCSgCpAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAMgIzcD2AMgAiAGQQhqQYAB/AoAACADQRhqIAkgA0HYA2oQqQogAygCGCIGQQhHDQIgCSgCrAIiBg0ACwsgA0HYA2ohBiMAQbANayICJAAgCSkDkAEhJSAJKQOIASEoIAkpA+gBISkgCSkD2AEhKiAJKQPgASEnIAkpA6ABISYgCSgCmAEhCiAJKAKUBCIFIAUoAgAiB0EBajYCAAJAIAdBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAU2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiAJKQOYAjcDgAYgCSgCoAQhCCACIAkoAqQEQQAgCSgCnAQiBxs2ApALIAIgCDYCjAsgAiAHNgKICyACQQA2AoQLIAIgB0EARyILNgKACyACIAg2AvwKIAIgBzYC+AogAkEANgL0CiACIAs2AvAKIAJB4AJqIAJB8ApqIgcQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAcgAkGwBGpBwAL8CgAAIAJB9AZqIAlB8ANqELUWIAJBiA1qIQcgAigCiA1BgICAgHhHBEAgB0EEQQgQ4B4LIAcgAikC9AY3AgAgB0EIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgcgAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACAKGyEmIAktAKwEBEAgBUEIahCqJSEFIAJBADoAqgcgAkIBNwOYByACQgA3A4AHIAIgCS0AkQIiCDoArQcgAiAJLQCQAiIKOgCsByACIAkpA/ABNwOgByACIAkpA7ABNwOQByACIAkpA6gBNwOIByACIAVB/wFxRToAqwcgAiAKQQJHOgCpByACIAhBAkc6AKgHIAJB2AdqIgUgCSACQYAHahDpBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgggB0HAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiIKIAJBwAD8CgAAIAJB0AtqIgsQwhggCyAFQdgA/AoAACACQbAIaiILIAJB8ApqIgxBwAL8CgAAIAIgCSkDwAE3A4gJIAIgCSkDuAE3A4AJIAJB6AJqIgUgCUGAAmooAgA2AgAgCSkC+AEhIyAJQYCAgIB4NgL4ASACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAUoAgA2AgAgAiACKQPgAjcC1AogDCALQcAC/AoAACAFIAlBjAJqKAIANgIAIAkpAoQCISMgCUGAgICAeDYChAIgAiAjNwPgAiACQaANahCFMCACQagNaiAFKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgByAIQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgCkHAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgA0HgAmoiAiADQegDaikDADcDACADQegCaiIGIANB8ANqKQMANwMAIAMgAykD4AM3A9gCIAMpA9gDIiNCAlEEQCAEIAMpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIANBOGogA0H4A2pBoAL8CgAAIANBKGogA0HgAmopAwA3AwAgA0EwaiADQegCaikDADcDACADICM3AxggAyADKQPYAjcDICADQdgDaiAJKALgAyAJKALkAygCEBEAACADKALYAyICQQhHBEAgBCADKQLcAzcCDCAEQRxqIANB7ANqKAIANgIAIARBFGogA0HkA2opAgA3AgAgBEICNwMAIAQgAjYCCCADQRhqEKogDAILIAlBAUECQQAgCS0AqwRBAXEbIAktAKoEGzYC+AIgCS0A/AIhAiADQdgDaiIFIAlBsAJqQdAA/AoAAAJ/IAJFBEAgBRDtJ0GAgICAeAwBCyADQbgDaiAJQcQCaigCADYCACADQagDaiAJQdACaigCADYCACADQZgDaiAJQdwCaigCADYCACADQYgDaiAJQegCaigCADYCACADIAkpArwCNwOwAyADIAkpAsgCNwOgAyADIAkpAtQCNwOQAyADIAkpAuACNwOAAyADKAKgBCEGIANB+AJqIAlB9AJqKAIANgIAIAMgCSkC7AI3A/ACIAMpAtwDISMgAygC2AMLIQICQCAJKAKwAyIFQYCAgIB4RwRAIAkpA6gDISQgAyAFNgLgAyADICQ3A9gDIANB5ANqIAlBtANqQSz8CgAAIANBwANqIANB2ANqEOgRDAELIANBgICAgHg2AsADCyAJKQNwISQgCUGAgICAeDYCcCAEICQ3A+gCIARB8AJqIAlB+ABqKAIANgIAIAkpA8gBISQgCSkD0AEhJSADQdgDaiIFIANBGGpBwAL8CgAAIANBqAZqIANB0ANqKQIANwMAIANBoAZqIANByANqKQIANwMAIAMgAykCwAM3A5gGIAQgBUHYAvwKAAAgBCAjNwP4AiAEIAI2AvQCIAQgJTcD4AIgBCAkNwPYAiAEIAMpA7ADNwKAAyAEQYgDaiADQbgDaigCADYCACAEIAMpA6ADNwKMAyAEQZQDaiADQagDaigCADYCACAEIAMpA5ADNwKYAyAEQaADaiADQZgDaigCADYCACAEIAMpA4ADNwKkAyAEQawDaiADQYgDaigCADYCACAEIAY2ArwDIARBuANqIANB+AJqKAIANgIAIAQgAykD8AI3ArADIAkoApQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCAJQZQEahDZIQsgCSgCmAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAlBmARqEK4gCyAJQeADahC8KiAJQegDahDXKSAJEPkYIAlBiANqEIUwIAlBlANqEIUwIAlB+AFqEIUwIAlBhAJqEIUwIAlBnARqEMMcIAlB8ANqQQRBCBDgHiAJQfwDahCdPCAJQYgEahCdPCAJQaACaiIEEIcZIARBCEGIARDgHgwCCyADQRBqIgIgA0EsaigCADYCACADQQhqIgUgA0EkaikCADcDACADIAMpAhw3AwAgBCAGNgIIIAQgAykDADcCDCAEQgI3AwAgBEEUaiAFKQMANwIAIARBHGogAigCADYCAAsgCSgClAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAlBlARqENkhCyAJKAKYBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgCUGYBGoQriALIAlB4ANqELwqIAlB6ANqENcpIAkQ+RggCUGIA2oQhTAgCUGUA2oQhTAgCUH4AWoQhTAgCUGEAmoQhTAgCUGcBGoQwxwgCUHwA2pBBEEIEOAeIAlB/ANqEJ08IAlBiARqEJ08IAlBoAJqIgQQhxkgBEEIQYgBEOAeIAlBsAJqEO0nIAlBqANqEMcoCyADQbAGaiQADAcLIAlBsARqIgMgAkHQBPwKAAAjAEGwBmsiBSQAAkACQAJAIAMoArgDRQ0AIAVB2ANqIAMQ5AEgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCADKAJoQYCAgIB4Rg0AIAVB2ANqIAMQjgcgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAMoArgDRQ0AIAVBGGogAxDkASAFKAIYIgZBCEYNAAwBCwJAIAMoAsQCIgZFDQAgBUHgA2ohAgNAIAMgBkEBazYCxAIgAyADKALAAiIGQQFqIgcgAygCuAIiCEEAIAcgCE8bazYCwAIgAygCvAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAUgIzcD2AMgAiAGQQhqQYAB/AoAACAFQRhqIAMgBUHYA2oQqAogBSgCGCIGQQhHDQIgAygCxAIiBg0ACwsgBUHYA2ohBiMAQbANayICJAAgAykDoAEhJSADKQOYASEoIAMpA4gCISkgAykD+AEhKiADKQOAAiEnIAMpA7ABISYgAygCqAEhCyADKAK4BCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAc2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiADKQOwAjcDgAYgAygCxAQhCiACIAMoAsgEQQAgAygCwAQiCBs2ApALIAIgCjYCjAsgAiAINgKICyACQQA2AoQLIAIgCEEARyIMNgKACyACIAo2AvwKIAIgCDYC+AogAkEANgL0CiACIAw2AvAKIAJB4AJqIAJB8ApqIggQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAggAkGwBGpBwAL8CgAAIAJB9AZqIANBlARqELUWIAJBiA1qIQggAigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggAikC9AY3AgAgCEEIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgggAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACALGyEmIAMtAM4EBEAgB0EIahCqJSEHIAJBADoAugcgAkIBNwOYByACIAMoAtgBIgo6ALkHIAIgAygC4AEiCzoAuAcgAiADKALkATYCtAcgAiALNgKwByACIAMoAtwBNgKsByACIAo2AqgHIAIgAykDkAI3A6AHIAIgAykDwAE3A5AHIAIgAykDuAE3A4gHIAIgB0H/AXFFOgC7ByACQgE3A4AHIAJB2AdqIgcgAyACQYAHahDnBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgogCEHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAHQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD0AE3A4gJIAIgAykDyAE3A4AJIAJB6AJqIgcgA0GgAmooAgA2AgAgAykCmAIhIyADQYCAgIB4NgKYAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAcoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAHIANBrAJqKAIANgIAIAMpAqQCISMgA0GAgICAeDYCpAIgAiAjNwPgAiACQaANahCFMCACQagNaiAHKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCCAKQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAL4AyADKAL8AygCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AzQRBAXEbIAMtAMwEGzYCkAMgAy0AlAMhAiAFQdgDaiIHIANByAJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQdwCaigCADYCACAFQagDaiADQegCaigCADYCACAFQZgDaiADQfQCaigCADYCACAFQYgDaiADQYADaigCADYCACAFIAMpAtQCNwOwAyAFIAMpAuACNwOgAyAFIAMpAuwCNwOQAyAFIAMpAvgCNwOAAyAFKAKgBCEGIAVB+AJqIANBjANqKAIANgIAIAUgAykChAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKALIAyIHQYCAgIB4RwRAIAMpA8ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANBzANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOAASEkIANBgICAgHg2AoABIAQgJDcD6AIgBEHwAmogA0GIAWooAgA2AgAgAykD6AEhJCADKQPwASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCuAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBuARqENkhCyADKAK8BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G8BGoQriALIANB+ANqELwqIANBgARqENcpIAMQ+hggA0GgA2oQhTAgA0GsA2oQhTAgA0GYAmoQhTAgA0GkAmoQhTAgA0HABGoQwxwgA0GUBGpBBEEIEOAeIANBoARqEJ08IANBrARqEJ08IANBuAJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAK4BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G4BGoQ2SELIAMoArwEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQbwEahCuIAsgA0H4A2oQvCogA0GABGoQ1ykgAxD6GCADQaADahCFMCADQawDahCFMCADQZgCahCFMCADQaQCahCFMCADQcAEahDDHCADQZQEakEEQQgQ4B4gA0GgBGoQnTwgA0GsBGoQnTwgA0G4AmoiBBCHGSAEQQhBiAEQ4B4gA0HIAmoQ7ScgA0HAA2oQxygLIAVBsAZqJAAMBgsgCUGACWoiAyACQYAF/AoAACMAQbAGayIFJAACQAJAAkAgAygC8ANFDQAgBUHYA2ogAxDnASAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAIAMoAnhBgICAgHhGDQAgBUHYA2ogAxCMByAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAAkAgAygC8ANFDQAgBUEYaiADEOcBIAUoAhgiBkEIRg0ADAELAkAgAygC/AIiBkUNACAFQeADaiECA0AgAyAGQQFrNgL8AiADIAMoAvgCIgZBAWoiByADKALwAiIIQQAgByAITxtrNgL4AiADKAL0AiAGQYgBbGoiBikDACIjQgxRDQEgBSAjNwPYAyACIAZBCGpBgAH8CgAAIAVBGGogAyAFQdgDahCkCiAFKAIYIgZBCEcNAiADKAL8AiIGDQALCyAFQdgDaiEGIwBBsA1rIgIkACADKQOwASEmIAMpA6gBISMgAykDqAIhJSADKQOYAiEoIAMpA6ACISkgAykDwAEhJyADKAK4ASELIAMoAuQEIgcgBygCACIIQQFqNgIAAkAgCEEATgRAIAJBADYC+AUgAkEANgLwBSACQQA2AugFIAJCCDcDkAUgAkIANwOABSACQgA3A/AEIAJCADcD4AQgAkIANwPQBCACQgA3A8AEIAJCADcDsAQgAkGIBmpBAEEs/AsAIAIgBzYC7AYgAkGAgICAeDYC4AYgAkGAgICAeDYC1AYgAkGAgICAeDYCyAYgAkGAgICAeDYCvAYgAkIBNwK0BiACIAMpA+gCNwOABiADKALwBCEKIAIgAygC9ARBACADKALsBCIIGzYCkAsgAiAKNgKMCyACIAg2AogLIAJBADYChAsgAiAIQQBHIgw2AoALIAIgCjYC/AogAiAINgL4CiACQQA2AvQKIAIgDDYC8AogAkHgAmogAkHwCmoiCBCsFSACQbAGakEBQQEQ4B4gAkG4BmogAkHoAmooAgA2AgAgAiACKQLgAjcDsAYgCCACQbAEakHAAvwKAAAgAkH0BmogA0HABGoQtRYgAkGIDWohCCACKAKIDUGAgICAeEcEQCAIQQRBCBDgHgsgCCACKQL0BjcCACAIQQhqIAJB/AZqKAIANgIAIAIpA/AKISQgAikD+AohKiACQeACaiACQYALakHQAfwKAAAgAkGAAmogAkHQDGpB4AD8CgAAIAJBQGsiCCACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJ0IAIAsbIScgAy0A+gQEQCAHQQhqEKolIQcgAkEAOgDKByACQgE3A7gHIAIgAykDyAEiKzwAyQcgAiADKQPYASIsPADIByACIAMpA7ACNwPAByACIAMpA/ABNwOwByACIAMpA+gBNwOoByACIAMpA+ABNwOgByACICw3A5gHIAIgAykD0AE3A5AHIAIgKzcDiAcgAiAHQf8BcUU6AMsHIAJCAjcDgAcgAkHYB2oiByADIAJBgAdqEOgGIAIgJjcDiAsgAiAjNwOACyACICo3A/gKIAIgJDcD8AogAkGQC2oiCiAIQcAB/AoAACACICc3A+gMIAIgKDcD4AwgAiApNwPYDCACICU3A9AMIAJB8AxqIgsgAkHAAPwKAAAgAkHQC2oiDBDCGCAMIAdB2AD8CgAAIAJBsAhqIgwgAkHwCmoiD0HAAvwKAAAgAiADKQOAAjcDiAkgAiADKQP4ATcDgAkgAkHoAmoiByADQcACaigCADYCACADKQK4AiEjIANBgICAgHg2ArgCIAIgIzcD4AIgAkHUCmoQhTAgAkHcCmogBygCADYCACACIAIpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HMAmooAgA2AgAgAykCxAIhIyADQYCAgIB4NgLEAiACICM3A+ACIAJBoA1qEIUwIAJBqA1qIAcoAgA2AgAgAiACKQPgAjcDoA0gAikD8AohJCACKQP4CiEqIAIpA4ALISMgAikDiAshJiAIIApBwAH8CgAAIAIpA+gMIScgAikD4AwhKCACKQPYDCEpIAIpA9AMISUgAiALQcAA/AoAAAsgJEICUgRAIAZBIGogAkFAa0HAAfwKAAAgBkGAAmogAkHAAPwKAAAgBiAnNwP4ASAGICg3A/ABIAYgKTcD6AEgBiAlNwPgAQsgBiAmNwMYIAYgIzcDECAGICo3AwggBiAkNwMAIAJBsA1qJAAMAQsACyAFQeACaiICIAVB6ANqKQMANwMAIAVB6AJqIgYgBUHwA2opAwA3AwAgBSAFKQPgAzcD2AIgBSkD2AMiJEICUQRAIAQgBSkD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAIpAwA3AwAMAgsgBUE4aiAFQfgDakGgAvwKAAAgBUEoaiAFQeACaikDADcDACAFQTBqIAVB6AJqKQMANwMAIAUgJDcDGCAFIAUpA9gCNwMgIAVB2ANqIAMoArAEIAMoArQEKAIQEQAAIAUoAtgDIgJBCEcEQCAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIIAVBGGoQqiAMAgsgA0EBQQJBACADLQD5BEEBcRsgAy0A+AQbNgLIAyADLQDMAyECIAVB2ANqIgcgA0GAA2pB0AD8CgAAAn8gAkUEQCAHEO0nQYCAgIB4DAELIAVBuANqIANBlANqKAIANgIAIAVBqANqIANBoANqKAIANgIAIAVBmANqIANBrANqKAIANgIAIAVBiANqIANBuANqKAIANgIAIAUgAykCjAM3A7ADIAUgAykCmAM3A6ADIAUgAykCpAM3A5ADIAUgAykCsAM3A4ADIAUoAqAEIQYgBUH4AmogA0HEA2ooAgA2AgAgBSADKQK8AzcD8AIgBSkC3AMhJCAFKALYAwshAgJAIAMoAoAEIgdBgICAgHhHBEAgAykD+AMhIyAFIAc2AuADIAUgIzcD2AMgBUHkA2ogA0GEBGpBLPwKAAAgBUHAA2ogBUHYA2oQ6BEMAQsgBUGAgICAeDYCwAMLIAMpA5ABISMgA0GAgICAeDYCkAEgBCAjNwPoAiAEQfACaiADQZgBaigCADYCACADKQOIAiEjIAMpA5ACISUgBUHYA2oiByAFQRhqQcAC/AoAACAFQagGaiAFQdADaikCADcDACAFQaAGaiAFQcgDaikCADcDACAFIAUpAsADNwOYBiAEIAdB2AL8CgAAIAQgJDcD+AIgBCACNgL0AiAEICU3A+ACIAQgIzcD2AIgBCAFKQOwAzcCgAMgBEGIA2ogBUG4A2ooAgA2AgAgBCAFKQOgAzcCjAMgBEGUA2ogBUGoA2ooAgA2AgAgBCAFKQOQAzcCmAMgBEGgA2ogBUGYA2ooAgA2AgAgBCAFKQOAAzcCpAMgBEGsA2ogBUGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiAFQfgCaigCADYCACAEIAUpA/ACNwKwAyADKALkBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HkBGoQ2SELIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahCuIAsgA0GwBGoQvCogA0G4BGoQ1ykgAxD7GCADQdgDahCFMCADQeQDahCFMCADQbgCahCFMCADQcQCahCFMCADQewEahDDHCADQcAEakEEQQgQ4B4gA0HMBGoQnTwgA0HYBGoQnTwgA0HwAmoiBBCHGSAEQQhBiAEQ4B4MAgsgBUEQaiICIAVBLGooAgA2AgAgBUEIaiIHIAVBJGopAgA3AwAgBSAFKQIcNwMAIAQgBjYCCCAEIAUpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAIoAgA2AgALIAMoAuQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQeQEahDZIQsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqEK4gCyADQbAEahC8KiADQbgEahDXKSADEPsYIANB2ANqEIUwIANB5ANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB7ARqEMMcIANBwARqQQRBCBDgHiADQcwEahCdPCADQdgEahCdPCADQfACaiIEEIcZIARBCEGIARDgHiADQYADahDtJyADQfgDahDHKAsgBUGwBmokAAwFCyAJQYAOaiIDIAJBgAX8CgAAIwBB0AZrIgIkAAJAAkACQCADKALYA0UNACACQdgDaiADEOABIAIoAtgDIgZBCEYNACAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAGNgIIDAELAkAgAygCeEGAgICAeEYNACACQdgDaiEIIwBBgAFrIgYkACADKAJ4IQUgA0GAgICAeDYCeAJAAkAgBUGAgICAeEcEQCAGIANBMGpByAD8CgAAIAZB1ABqIANBhAFqKAIANgIAIAYgBTYCSCAGIAMpAnw3AkwCQAJAIAMoAqABRQRAIwBBQGoiBSQAIAVBCGpBgAIQ6CAgBUEANgIoIAVCgICAgBA3AyAgBUEgaiELIAYoAjgiDwRAIAYoAjQhDCAPQQxsIQ8DQCALIAxBDBChNiAMQQxqIQwgD0EMayIPDQALCyAFLQAcIQwgBSAFKQMINwMwIAxBA3YgDEEHcUEAR2oiDEEJTwRAIAxBCEHojs4AELA7AAsgBUEQaiAFQTBqIg8gDBChNiAFQQA6ABwgBUIANwMIIAsgBSgCFCAFKAIYEKE2IAVBADoAHCAFQgA3AwggBUEANgIYIAVBOGogC0EIaigCADYCACAFIAspAgA3AzAgBUEANgIoIAVCgICAgBA3AyAgBkHoAGoiC0EEaiAPEOcVIAtBCDYCACAFQQhqEMouIAVBQGskACAGQeAAaiIFIAZB9ABqKQIANwMAIAYgBikCbDcDWCAGKAJoIgtBCEYNASAGKAJ8IQwgCCAGKQNYNwIMIAggDDYCHCAIIAs2AgggCEEBNgIAIAhBFGogBSkDADcCAAwCCyAGQegAakEwQQBBAUEBEKAYIAYoAmwhBSAGKAJoQQFGDQMgBigCcCILQZiJzgBBMPwKAAAgCEEwNgIUIAggCzYCECAIIAU2AgwgCEEANgIIIAhBATYCAAwBCyAIIAYpA1g3AgQgCEEMaiAFKQMANwIAIAhBADoAGCAIIAYoAjg2AhQgCEEANgIACyAGEIMtDAILIAhBADYCACAIQQI6ABgMAQsgBSAGKAJwQZyHzgAQ/S8ACyAGQYABaiQAAn8CQAJAIAIoAtgDQQFGBEAgAigC9AMhByACKALwAyEKIAIoAuwDIQsgAigC6AMhBiACKALkAyEIIAIoAuADIQUMAQsgAigC8AMiBUH/AXFBAkYEQEEAIQVBHSELIAJB2ANqQR1BAEEBQQEQoBggAigC3AMhCCACKALYA0EBRg0OIAIoAuADIgZBFWpBjYTPACkAADcAACAGQRBqQYiEzwApAAA3AAAgBkEIakGAhM8AKQAANwAAIAZB+IPPACkAADcAAAwBCyACKALsAyEHIAIoAugDIQogAigC5AMhBiACKALgAyEIIAIoAtwDIQsgAiAFNgIsIAIgBzYCKCACIAo2AiQgAiAGNgIgIAIgCDYCHCACIAs2AhggAygCoAQEQCACQdgDaiIHIAZBAEEBQQEQoBggAigC3AMhBSACKALYA0EBRg0PIAJBJGohDCACQQA2ArwGIAIgAigC4AM2ArgGIAIgBTYCtAYgByADKAKgBCAIIAYgAkG0BmoiDyADKAKkBCgCDBEHACACKALYAyIFQQhHBEAgAigC7AMhByACKALoAyEKIAIoAuQDIQsgAigC4AMhBiACKALcAyEIIA8Q3jsgDCACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACQcgGaiACQbwGaigCADYCACACIAIpArQGNwPABiACQdgDaiACQcAGahDnFSAMIAIoAhwgAkEgaiIFKAIAIAIoAhgoAhARAQAgBSACQeADaikCADcDACACIAIpAtgDNwMYIAIoAighByACLQAsIQULIAJB4AJqIgogAkEgaikDADcDACACIAIpAxg3A9gCIANB8ARqQQAQ6R4gAygCzAQiCCADKALEBEYEQCADQcQEakHog88AEJsoCyADKALIBCAIQQN0akKBgICAgMAANwIAIAMgCEEBajYCzAQgAygCmAQhCCADKAKcBCELIAJB6ANqIAopAwA3AwAgAkILNwPYAyACIAIpA9gCNwPgAyACIAY2AtgEIAIgBToA9QMgAkEAOgD0AyACIAc2AvADIAJBGGogCCACQdgDaiALKAIMEQEAIAIoAiwhByACKAIoIQogAikDGCEjIAItADQiBkEERw0BICNCIIinIQggAigCICEGIAIoAiQhCyAjpyEFCyAFQQhGDQIgBCAHNgIcIAQgCjYCGCAEIAs2AhQgBCAGNgIQIAQgCDYCDCAEIAU2AgggBEICNwMADAMLIAI1AjAhJCACKQMgISUgAyADKQOYAiAKrXw3A5gCIAMgAykDoAIgB618NwOgAiADICUgAykDiAJ8NwOIAgJAAkAgBkEBaw4CAwABCyADKQOoAVBFDQ4gA0IBNwOoAUGwAQwBCyADIAMpA6gCICR8NwOoAiADKQO4AVBFBEAMAgsgA0IBNwO4AUHAAQsgA2ogIzcDAAsCQAJAIAMoAtgDRQ0AIAJBGGogAxDgASACKAIYIgVBCEYNAAwBCwJAIAMoAuQCIgVFDQAgAkHgA2ohBgNAIAMgBUEBazYC5AIgAyADKALgAiIFQQFqIgcgAygC2AIiCEEAIAcgCE8bazYC4AIgAygC3AIgBUGIAWxqIgUpAwAiI0IMUQ0BIAIgIzcD2AMgBiAFQQhqQYAB/AoAACACQRhqIAMgAkHYA2oQpwogAigCGCIFQQhHDQIgAygC5AIiBQ0ACwsgAkHYA2ohBSMAQdANayIGJAAgAykDsAEhJSADKQOoASEoIAMpA6gCISkgAykDmAIhKiADKQOgAiEnIAMpA8ABISYgAygCuAEhCyADKALoBCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCAGQQA2AvgFIAZBADYC8AUgBkEANgLoBSAGQgg3A5AFIAZCADcDgAUgBkIANwPwBCAGQgA3A+AEIAZCADcD0AQgBkIANwPABCAGQgA3A7AEIAZBiAZqQQBBLPwLACAGIAc2AuwGIAZBgICAgHg2AuAGIAZBgICAgHg2AtQGIAZBgICAgHg2AsgGIAZBgICAgHg2ArwGIAZCATcCtAYgBiADKQPQAjcDgAYgAygC9AQhCiAGIAMoAvgEQQAgAygC8AQiCBs2ArALIAYgCjYCrAsgBiAINgKoCyAGQQA2AqQLIAYgCEEARyIMNgKgCyAGIAo2ApwLIAYgCDYCmAsgBkEANgKUCyAGIAw2ApALIAZB4AJqIAZBkAtqIggQrBUgBkGwBmpBAUEBEOAeIAZBuAZqIAZB6AJqKAIANgIAIAYgBikC4AI3A7AGIAggBkGwBGpBwAL8CgAAIAZB9AZqIANBxARqELUWIAZBqA1qIQggBigCqA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggBikC9AY3AgAgCEEIaiAGQfwGaigCADYCACAGKQOQCyEjIAYpA5gLISQgBkHgAmogBkGgC2pB0AH8CgAAIAZBgAJqIAZB8AxqQeAA/AoAACAGQUBrIAZB8AJqQcAB/AoAACAGIAZBoAJqQcAA/AoAACAmQgAgCxshJiADLQD+BARAIAdBCGoQqiUhCkEAIQdBACEIIAMoAugBQQFGBEAgBkHgB2ogA0H0AWooAgA2AgAgBiADKQLsATcD2AdBASEICyADKAL4AUEBRgRAIAZB8AdqIANBhAJqKAIANgIAIAYgAykC/AE3A+gHQQEhBwsgBkG0B2ogBkHgB2ooAgA2AgAgBkHEB2ogBkHwB2ooAgA2AgAgBiAINgKoByAGQgE3A5gHIAYgBikD2Ac3AqwHIAYgBzYCuAcgBiAGKQPoBzcCvAcgBiADKQOwAjcDoAcgBiADKQPQATcDkAcgBiADKQPIATcDiAcgBiAKQf8BcUU6AMsHIAZBADoAygcgBiAIOgDJByAGIAc6AMgHIAZCAzcDgAcgBkH4B2oiByADIAZBgAdqEOoGIAYgJTcDqAsgBiAoNwOgCyAGICQ3A5gLIAYgIzcDkAsgBkGwC2oiCCAGQUBrIgpBwAH8CgAAIAYgJjcDiA0gBiAqNwOADSAGICc3A/gMIAYgKTcD8AwgBkGQDWoiCyAGQcAA/AoAACAGQfALaiIMEMIYIAwgB0HYAPwKAAAgBkHQCGoiDCAGQZALaiIPQcAC/AoAACAGIAMpA+ABNwOoCSAGIAMpA9gBNwOgCSAGQegCaiIHIANBwAJqKAIANgIAIAMpArgCISMgA0GAgICAeDYCuAIgBiAjNwPgAiAGQfQKahCFMCAGQfwKaiAHKAIANgIAIAYgBikD4AI3AvQKIA8gDEHAAvwKAAAgByADQcwCaigCADYCACADKQLEAiEjIANBgICAgHg2AsQCIAYgIzcD4AIgBkHADWoQhTAgBkHIDWogBygCADYCACAGIAYpA+ACNwPADSAGKQOQCyEjIAYpA5gLISQgBikDoAshKCAGKQOoCyElIAogCEHAAfwKAAAgBikDiA0hJiAGKQOADSEqIAYpA/gMIScgBikD8AwhKSAGIAtBwAD8CgAACyAjQgJSBEAgBUEgaiAGQUBrQcAB/AoAACAFQYACaiAGQcAA/AoAACAFICY3A/gBIAUgKjcD8AEgBSAnNwPoASAFICk3A+ABCyAFICU3AxggBSAoNwMQIAUgJDcDCCAFICM3AwAgBkHQDWokAAwBCwALIAJB4AJqIgUgAkHoA2opAwA3AwAgAkHoAmoiBiACQfADaikDADcDACACIAIpA+ADNwPYAiACKQPYAyIjQgJRBEAgBCACKQPYAjcDCCAEQgI3AwAgBEEYaiAGKQMANwMAIARBEGogBSkDADcDAAwCCyACQThqIAJB+ANqQaAC/AoAACACQShqIAJB4AJqKQMANwMAIAJBMGogAkHoAmopAwA3AwAgAiAjNwMYIAIgAikD2AI3AyAgAkHYA2ogAygCmAQgAygCnAQoAhARAAAgAigC2AMiBUEIRwRAIAQgAikC3AM3AgwgBEEcaiACQewDaigCADYCACAEQRRqIAJB5ANqKQIANwIAIARCAjcDACAEIAU2AgggAkEYahCqIAwCCyADQQFBAkEAIAMtAP0EQQFxGyADLQD8BBs2ArADIAMtALQDIQUgAkHYA2oiByADQegCakHQAPwKAAACfyAFRQRAIAcQ7SdBgICAgHgMAQsgAkG4A2ogA0H8AmooAgA2AgAgAkGoA2ogA0GIA2ooAgA2AgAgAkGYA2ogA0GUA2ooAgA2AgAgAkGIA2ogA0GgA2ooAgA2AgAgAiADKQL0AjcDsAMgAiADKQKAAzcDoAMgAiADKQKMAzcDkAMgAiADKQKYAzcDgAMgAigCoAQhBiACQfgCaiADQawDaigCADYCACACIAMpAqQDNwPwAiACKQLcAyEjIAIoAtgDCyEFAkAgAygC6AMiB0GAgICAeEcEQCADKQPgAyEkIAIgBzYC4AMgAiAkNwPYAyACQeQDaiADQewDakEs/AoAACACQcADaiACQdgDahDoEQwBCyACQYCAgIB4NgLAAwsgAykDkAEhJCADQYCAgIB4NgKQASAEICQ3A+gCIARB8AJqIANBmAFqKAIANgIAIAMpA4gCISQgAykDkAIhJSACQdgDaiIHIAJBGGpBwAL8CgAAIAJBqAZqIAJB0ANqKQIANwMAIAJBoAZqIAJByANqKQIANwMAIAIgAikCwAM3A5gGIAQgB0HYAvwKAAAgBCAjNwP4AiAEIAU2AvQCIAQgJTcD4AIgBCAkNwPYAiAEIAIpA7ADNwKAAyAEQYgDaiACQbgDaigCADYCACAEIAIpA6ADNwKMAyAEQZQDaiACQagDaigCADYCACAEIAIpA5ADNwKYAyAEQaADaiACQZgDaigCADYCACAEIAIpA4ADNwKkAyAEQawDaiACQYgDaigCADYCACAEIAY2ArwDIARBuANqIAJB+AJqKAIANgIAIAQgAikD8AI3ArADIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahDZIQsgAygC7AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB7ARqEK4gCyADQZgEahC8KiADQaAEahDXKSADEIYZIANBwANqEIUwIANBzANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB8ARqEMMcIANBxARqQQRBCBDgHiADQdAEahCdPCADQdwEahCdPCADQdgCaiIEEIcZIARBCEGIARDgHgwCCyACQRBqIgYgAkEsaigCADYCACACQQhqIgcgAkEkaikCADcDACACIAIpAhw3AwAgBCAFNgIIIAQgAikDADcCDCAEQgI3AwAgBEEUaiAHKQMANwIAIARBHGogBigCADYCAAsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqENkhCyADKALsBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HsBGoQriALIANBmARqELwqIANBoARqENcpIAMQhhkgA0HAA2oQhTAgA0HMA2oQhTAgA0G4AmoQhTAgA0HEAmoQhTAgA0HwBGoQwxwgA0HEBGpBBEEIEOAeIANB0ARqEJ08IANB3ARqEJ08IANB2AJqIgQQhxkgBEEIQYgBEOAeIANB6AJqEO0nIANB4ANqEMcoCyACQdAGaiQADAQLIAlBgBNqIgMgAkHQBPwKAAAjAEGwBmsiBSQAAkACQAJAIAMoArgDRQ0AIAVB2ANqIAMQ6AEgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQCADKAJoQYCAgIB4Rg0AIAVB2ANqIAMQjgcgBSgC2AMiAkEIRg0AIAQgBSkC3AM3AgwgBEEcaiAFQewDaigCADYCACAEQRRqIAVB5ANqKQIANwIAIARCAjcDACAEIAI2AggMAQsCQAJAIAMoArgDRQ0AIAVBGGogAxDoASAFKAIYIgZBCEYNAAwBCwJAIAMoAsQCIgZFDQAgBUHgA2ohAgNAIAMgBkEBazYCxAIgAyADKALAAiIGQQFqIgcgAygCuAIiCEEAIAcgCE8bazYCwAIgAygCvAIgBkGIAWxqIgYpAwAiI0IMUQ0BIAUgIzcD2AMgAiAGQQhqQYAB/AoAACAFQRhqIAMgBUHYA2oQqAogBSgCGCIGQQhHDQIgAygCxAIiBg0ACwsgBUHYA2ohBiMAQbANayICJAAgAykDoAEhJSADKQOYASEoIAMpA4gCISkgAykD+AEhKiADKQOAAiEnIAMpA7ABISYgAygCqAEhCyADKAK4BCIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCACQQA2AvgFIAJBADYC8AUgAkEANgLoBSACQgg3A5AFIAJCADcDgAUgAkIANwPwBCACQgA3A+AEIAJCADcD0AQgAkIANwPABCACQgA3A7AEIAJBiAZqQQBBLPwLACACIAc2AuwGIAJBgICAgHg2AuAGIAJBgICAgHg2AtQGIAJBgICAgHg2AsgGIAJBgICAgHg2ArwGIAJCATcCtAYgAiADKQOwAjcDgAYgAygCxAQhCiACIAMoAsgEQQAgAygCwAQiCBs2ApALIAIgCjYCjAsgAiAINgKICyACQQA2AoQLIAIgCEEARyIMNgKACyACIAo2AvwKIAIgCDYC+AogAkEANgL0CiACIAw2AvAKIAJB4AJqIAJB8ApqIggQrBUgAkGwBmpBAUEBEOAeIAJBuAZqIAJB6AJqKAIANgIAIAIgAikC4AI3A7AGIAggAkGwBGpBwAL8CgAAIAJB9AZqIANBlARqELUWIAJBiA1qIQggAigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggAikC9AY3AgAgCEEIaiACQfwGaigCADYCACACKQPwCiEjIAIpA/gKISQgAkHgAmogAkGAC2pB0AH8CgAAIAJBgAJqIAJB0AxqQeAA/AoAACACQUBrIgggAkHwAmpBwAH8CgAAIAIgAkGgAmpBwAD8CgAAICZCACALGyEmIAMtAM4EBEAgB0EIahCqJSEHIAJBADoAugcgAkIBNwOYByACIAMoAtgBIgo6ALkHIAIgAygC4AEiCzoAuAcgAiADKgLkATgCtAcgAiALNgKwByACIAMqAtwBOAKsByACIAo2AqgHIAIgAykDkAI3A6AHIAIgAykDwAE3A5AHIAIgAykDuAE3A4gHIAIgB0H/AXFFOgC7ByACQgQ3A4AHIAJB2AdqIgcgAyACQYAHahDnBiACICU3A4gLIAIgKDcDgAsgAiAkNwP4CiACICM3A/AKIAJBkAtqIgogCEHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAHQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD0AE3A4gJIAIgAykDyAE3A4AJIAJB6AJqIgcgA0GgAmooAgA2AgAgAykCmAIhIyADQYCAgIB4NgKYAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAcoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAHIANBrAJqKAIANgIAIAMpAqQCISMgA0GAgICAeDYCpAIgAiAjNwPgAiACQaANahCFMCACQagNaiAHKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCCAKQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAGQSBqIAJBQGtBwAH8CgAAIAZBgAJqIAJBwAD8CgAAIAYgJjcD+AEgBiAqNwPwASAGICc3A+gBIAYgKTcD4AELIAYgJTcDGCAGICg3AxAgBiAkNwMIIAYgIzcDACACQbANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAL4AyADKAL8AygCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AzQRBAXEbIAMtAMwEGzYCkAMgAy0AlAMhAiAFQdgDaiIHIANByAJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQdwCaigCADYCACAFQagDaiADQegCaigCADYCACAFQZgDaiADQfQCaigCADYCACAFQYgDaiADQYADaigCADYCACAFIAMpAtQCNwOwAyAFIAMpAuACNwOgAyAFIAMpAuwCNwOQAyAFIAMpAvgCNwOAAyAFKAKgBCEGIAVB+AJqIANBjANqKAIANgIAIAUgAykChAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKALIAyIHQYCAgIB4RwRAIAMpA8ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANBzANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOAASEkIANBgICAgHg2AoABIAQgJDcD6AIgBEHwAmogA0GIAWooAgA2AgAgAykD6AEhJCADKQPwASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCuAQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBuARqENkhCyADKAK8BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G8BGoQriALIANB+ANqELwqIANBgARqENcpIAMQ+hggA0GgA2oQhTAgA0GsA2oQhTAgA0GYAmoQhTAgA0GkAmoQhTAgA0HABGoQwxwgA0GUBGpBBEEIEOAeIANBoARqEJ08IANBrARqEJ08IANBuAJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAK4BCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0G4BGoQ2SELIAMoArwEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQbwEahCuIAsgA0H4A2oQvCogA0GABGoQ1ykgAxD6GCADQaADahCFMCADQawDahCFMCADQZgCahCFMCADQaQCahCFMCADQcAEahDDHCADQZQEakEEQQgQ4B4gA0GgBGoQnTwgA0GsBGoQnTwgA0G4AmoiBBCHGSAEQQhBiAEQ4B4gA0HIAmoQ7ScgA0HAA2oQxygLIAVBsAZqJAAMAwsgCUHQF2oiAyACQYAF/AoAACMAQbAGayIFJAACQAJAAkAgAygC8ANFDQAgBUHYA2ogAxDqASAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAIAMoAnhBgICAgHhGDQAgBUHYA2ogAxCMByAFKALYAyICQQhGDQAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCAwBCwJAAkAgAygC8ANFDQAgBUEYaiADEOoBIAUoAhgiBkEIRg0ADAELAkAgAygC/AIiBkUNACAFQeADaiECA0AgAyAGQQFrNgL8AiADIAMoAvgCIgZBAWoiByADKALwAiIIQQAgByAITxtrNgL4AiADKAL0AiAGQYgBbGoiBikDACIjQgxRDQEgBSAjNwPYAyACIAZBCGpBgAH8CgAAIAVBGGogAyAFQdgDahCkCiAFKAIYIgZBCEcNAiADKAL8AiIGDQALCyAFQdgDaiEGIwBBsA1rIgIkACADKQOwASEmIAMpA6gBISMgAykDqAIhJSADKQOYAiEoIAMpA6ACISkgAykDwAEhJyADKAK4ASELIAMoAuQEIgcgBygCACIIQQFqNgIAAkAgCEEATgRAIAJBADYC+AUgAkEANgLwBSACQQA2AugFIAJCCDcDkAUgAkIANwOABSACQgA3A/AEIAJCADcD4AQgAkIANwPQBCACQgA3A8AEIAJCADcDsAQgAkGIBmpBAEEs/AsAIAIgBzYC7AYgAkGAgICAeDYC4AYgAkGAgICAeDYC1AYgAkGAgICAeDYCyAYgAkGAgICAeDYCvAYgAkIBNwK0BiACIAMpA+gCNwOABiADKALwBCEKIAIgAygC9ARBACADKALsBCIIGzYCkAsgAiAKNgKMCyACIAg2AogLIAJBADYChAsgAiAIQQBHIgw2AoALIAIgCjYC/AogAiAINgL4CiACQQA2AvQKIAIgDDYC8AogAkHgAmogAkHwCmoiCBCsFSACQbAGakEBQQEQ4B4gAkG4BmogAkHoAmooAgA2AgAgAiACKQLgAjcDsAYgCCACQbAEakHAAvwKAAAgAkH0BmogA0HABGoQtRYgAkGIDWohCCACKAKIDUGAgICAeEcEQCAIQQRBCBDgHgsgCCACKQL0BjcCACAIQQhqIAJB/AZqKAIANgIAIAIpA/AKISQgAikD+AohKiACQeACaiACQYALakHQAfwKAAAgAkGAAmogAkHQDGpB4AD8CgAAIAJBQGsiCCACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJ0IAIAsbIScgAy0A+gQEQCAHQQhqEKolIQcgAkEAOgDKByACQgE3A7gHIAIgAykDyAEiKzwAyQcgAiADKQPYASIsPADIByACIAMpA7ACNwPAByACIAMpA/ABNwOwByACIAMpA+gBNwOoByACIAMrA+ABOQOgByACICw3A5gHIAIgAysD0AE5A5AHIAIgKzcDiAcgAiAHQf8BcUU6AMsHIAJCBTcDgAcgAkHYB2oiByADIAJBgAdqEOgGIAIgJjcDiAsgAiAjNwOACyACICo3A/gKIAIgJDcD8AogAkGQC2oiCiAIQcAB/AoAACACICc3A+gMIAIgKDcD4AwgAiApNwPYDCACICU3A9AMIAJB8AxqIgsgAkHAAPwKAAAgAkHQC2oiDBDCGCAMIAdB2AD8CgAAIAJBsAhqIgwgAkHwCmoiD0HAAvwKAAAgAiADKQOAAjcDiAkgAiADKQP4ATcDgAkgAkHoAmoiByADQcACaigCADYCACADKQK4AiEjIANBgICAgHg2ArgCIAIgIzcD4AIgAkHUCmoQhTAgAkHcCmogBygCADYCACACIAIpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HMAmooAgA2AgAgAykCxAIhIyADQYCAgIB4NgLEAiACICM3A+ACIAJBoA1qEIUwIAJBqA1qIAcoAgA2AgAgAiACKQPgAjcDoA0gAikD8AohJCACKQP4CiEqIAIpA4ALISMgAikDiAshJiAIIApBwAH8CgAAIAIpA+gMIScgAikD4AwhKCACKQPYDCEpIAIpA9AMISUgAiALQcAA/AoAAAsgJEICUgRAIAZBIGogAkFAa0HAAfwKAAAgBkGAAmogAkHAAPwKAAAgBiAnNwP4ASAGICg3A/ABIAYgKTcD6AEgBiAlNwPgAQsgBiAmNwMYIAYgIzcDECAGICo3AwggBiAkNwMAIAJBsA1qJAAMAQsACyAFQeACaiICIAVB6ANqKQMANwMAIAVB6AJqIgYgBUHwA2opAwA3AwAgBSAFKQPgAzcD2AIgBSkD2AMiJEICUQRAIAQgBSkD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAIpAwA3AwAMAgsgBUE4aiAFQfgDakGgAvwKAAAgBUEoaiAFQeACaikDADcDACAFQTBqIAVB6AJqKQMANwMAIAUgJDcDGCAFIAUpA9gCNwMgIAVB2ANqIAMoArAEIAMoArQEKAIQEQAAIAUoAtgDIgJBCEcEQCAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIIAVBGGoQqiAMAgsgA0EBQQJBACADLQD5BEEBcRsgAy0A+AQbNgLIAyADLQDMAyECIAVB2ANqIgcgA0GAA2pB0AD8CgAAAn8gAkUEQCAHEO0nQYCAgIB4DAELIAVBuANqIANBlANqKAIANgIAIAVBqANqIANBoANqKAIANgIAIAVBmANqIANBrANqKAIANgIAIAVBiANqIANBuANqKAIANgIAIAUgAykCjAM3A7ADIAUgAykCmAM3A6ADIAUgAykCpAM3A5ADIAUgAykCsAM3A4ADIAUoAqAEIQYgBUH4AmogA0HEA2ooAgA2AgAgBSADKQK8AzcD8AIgBSkC3AMhJCAFKALYAwshAgJAIAMoAoAEIgdBgICAgHhHBEAgAykD+AMhIyAFIAc2AuADIAUgIzcD2AMgBUHkA2ogA0GEBGpBLPwKAAAgBUHAA2ogBUHYA2oQ6BEMAQsgBUGAgICAeDYCwAMLIAMpA5ABISMgA0GAgICAeDYCkAEgBCAjNwPoAiAEQfACaiADQZgBaigCADYCACADKQOIAiEjIAMpA5ACISUgBUHYA2oiByAFQRhqQcAC/AoAACAFQagGaiAFQdADaikCADcDACAFQaAGaiAFQcgDaikCADcDACAFIAUpAsADNwOYBiAEIAdB2AL8CgAAIAQgJDcD+AIgBCACNgL0AiAEICU3A+ACIAQgIzcD2AIgBCAFKQOwAzcCgAMgBEGIA2ogBUG4A2ooAgA2AgAgBCAFKQOgAzcCjAMgBEGUA2ogBUGoA2ooAgA2AgAgBCAFKQOQAzcCmAMgBEGgA2ogBUGYA2ooAgA2AgAgBCAFKQOAAzcCpAMgBEGsA2ogBUGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiAFQfgCaigCADYCACAEIAUpA/ACNwKwAyADKALkBCIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0HkBGoQ2SELIAMoAugEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQegEahCuIAsgA0GwBGoQvCogA0G4BGoQ1ykgAxD7GCADQdgDahCFMCADQeQDahCFMCADQbgCahCFMCADQcQCahCFMCADQewEahDDHCADQcAEakEEQQgQ4B4gA0HMBGoQnTwgA0HYBGoQnTwgA0HwAmoiBBCHGSAEQQhBiAEQ4B4MAgsgBUEQaiICIAVBLGooAgA2AgAgBUEIaiIHIAVBJGopAgA3AwAgBSAFKQIcNwMAIAQgBjYCCCAEIAUpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAIoAgA2AgALIAMoAuQEIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQeQEahDZIQsgAygC6AQiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANB6ARqEK4gCyADQbAEahC8KiADQbgEahDXKSADEPsYIANB2ANqEIUwIANB5ANqEIUwIANBuAJqEIUwIANBxAJqEIUwIANB7ARqEMMcIANBwARqQQRBCBDgHiADQcwEahCdPCADQdgEahCdPCADQfACaiIEEIcZIARBCEGIARDgHiADQYADahDtJyADQfgDahDHKAsgBUGwBmokAAwCCyAJQdAcaiIDIAJBmAX8CgAAIwBB0AZrIgIkAAJAAkACQCADKALoA0UNACACQdgDaiADEMsBIAIoAtgDIgZBCEYNACAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAGNgIIDAELAkAgAygCWEGAgICAeEYNACACQdgDaiEIIwBBgAFrIgUkACADKAJYIQYgA0GAgICAeDYCWAJAAkAgBkGAgICAeEcEQCAFIANBEGpByAD8CgAAIAVB1ABqIANB5ABqKAIANgIAIAUgBjYCSCAFIAMpAlw3AkwCQAJAIAMoAqgBRQRAIAVB6ABqIQ8jAEFAaiIGJAAgBkEIakGAAhDoICAGQQA2AiggBkKAgICAEDcDICAGQSBqIQwCQAJAAkACQCAFKAI4IhoEQCAFKAI0IgogGkEEdGohGgNAIAooAgBFDQIgBiAKQQhqIiEoAgA2AjAgDCAGQTBqQQQQoTYgCigCAEUNAyAMIApBBGooAgAgISgCABChNiAKQRBqIgogGkcNAAsLIAYtABwhCiAGIAYpAwg3AzAgCkEDdiAKQQdxQQBHaiIKQQlPDQIgBkEQaiAGQTBqIhogChChNiAGQQA6ABwgBkIANwMIIAwgBigCFCAGKAIYEKE2IAZBADoAHCAGQgA3AwggBkEANgIYIAZBOGogDEEIaigCADYCACAGIAwpAgA3AzAgBkEANgIoIAZCgICAgBA3AyAgD0EEaiAaEOcVIA9BCDYCACAGQQhqEMouIAZBQGskAAwDC0Gsh84AQSVB1IfOABCfKQALQeSHzgBBIEGEiM4AEMskAAsgCkEIQeiOzgAQsDsACyAFQeAAaiIGIAVB9ABqKQIANwMAIAUgBSkCbDcDWCAFKAJoIgpBCEYNASAFKAJ8IQwgCCAFKQNYNwIMIAggDDYCHCAIIAo2AgggCEEBNgIAIAhBFGogBikDADcCAAwCCyAFQegAakEwQQBBAUEBEKAYIAUoAmwhBiAFKAJoQQFGDQMgBSgCcCIKQZiJzgBBMPwKAAAgCEEwNgIUIAggCjYCECAIIAY2AgwgCEEANgIIIAhBATYCAAwBCyAIIAUpA1g3AgQgCEEMaiAGKQMANwIAIAhBADoAGCAIIAUoAjg2AhQgCEEANgIACyAFEJ4sDAILIAhBADYCACAIQQI6ABgMAQsgBiAFKAJwQZyHzgAQ/S8ACyAFQYABaiQAAn8CQAJAIAIoAtgDQQFGBEAgAigC9AMhByACKALwAyELIAIoAuwDIQogAigC6AMhBiACKALkAyEIIAIoAuADIQUMAQsgAigC8AMiBUH/AXFBAkYEQEEAIQVBHSEKIAJB2ANqQR1BAEEBQQEQoBggAigC3AMhCCACKALYA0EBRg0LIAIoAuADIgZBFWpBjYTPACkAADcAACAGQRBqQYiEzwApAAA3AAAgBkEIakGAhM8AKQAANwAAIAZB+IPPACkAADcAAAwBCyACKALsAyEHIAIoAugDIQogAigC5AMhBiACKALgAyEIIAIoAtwDIQsgAiAFNgIsIAIgBzYCKCACIAo2AiQgAiAGNgIgIAIgCDYCHCACIAs2AhggAygCsAQEQCACQdgDaiIHIAZBAEEBQQEQoBggAigC3AMhBSACKALYA0EBRg0MIAJBJGohDCACQQA2ArwGIAIgAigC4AM2ArgGIAIgBTYCtAYgByADKAKwBCAIIAYgAkG0BmoiDyADKAK0BCgCDBEHACACKALYAyIFQQhHBEAgAigC7AMhByACKALoAyELIAIoAuQDIQogAigC4AMhBiACKALcAyEIIA8Q3jsgDCACKAIcIAIoAiAgAigCGCgCEBEBAAwCCyACQcgGaiACQbwGaigCADYCACACIAIpArQGNwPABiACQdgDaiACQcAGahDnFSAMIAIoAhwgAkEgaiIFKAIAIAIoAhgoAhARAQAgBSACQeADaikCADcDACACIAIpAtgDNwMYIAIoAighByACLQAsIQULIAJB4AJqIgogAkEgaikDADcDACACIAIpAxg3A9gCIANBiAVqQQAQ6R4gAygC5AQiCCADKALcBEYEQCADQdwEakHog88AEJsoCyADKALgBCAIQQN0akKBgICAgMAANwIAIAMgCEEBajYC5AQgAygCqAQhCCADKAKsBCELIAJB6ANqIAopAwA3AwAgAkILNwPYAyACIAIpA9gCNwPgAyACIAY2AtgEIAIgBToA9QMgAkEAOgD0AyACIAc2AvADIAJBGGogCCACQdgDaiALKAIMEQEAIAIoAiwhByACKAIoIQsgAikDGCEjIAItADQiBkEERw0BICNCIIinIQggAigCICEGIAIoAiQhCiAjpyEFCyAFQQhGDQIgBCAHNgIcIAQgCzYCGCAEIAo2AhQgBCAGNgIQIAQgCDYCDCAEIAU2AgggBEICNwMADAMLIAI1AjAhJCACKQMgISUgAyADKQOAAiALrXw3A4ACIAMgAykDiAIgB618NwOIAiADICUgAykD8AF8NwPwAQJAAkAgBkEBaw4CAwABCyADKQOwAVBFDQsgA0IBNwOwAUG4AQwBCyADIAMpA5ACICR8NwOQAiADKQPAAVBFBEAMAgsgA0IBNwPAAUHIAQsgA2ogIzcDAAsCQAJAIAMoAugDRQ0AIAJBGGogAxDLASACKAIYIgVBCEYNAAwBCwJAIAMoAvQCIgVFDQAgAkHgA2ohBgNAIAMgBUEBazYC9AIgAyADKALwAiIFQQFqIgcgAygC6AIiCEEAIAcgCE8bazYC8AIgAygC7AIgBUGIAWxqIgUpAwAiI0IMUQ0BIAIgIzcD2AMgBiAFQQhqQYAB/AoAACACQRhqIAMgAkHYA2oQpgogAigCGCIFQQhHDQIgAygC9AIiBQ0ACwsgAkHYA2ohBSMAQdANayIGJAAgAykDuAEhJSADKQOwASEoIAMpA5ACISkgAykDgAIhKiADKQOIAiEnIAMpA8gBISYgAygCwAEhCyADKAKABSIHIAcoAgAiCEEBajYCAAJAIAhBAE4EQCAGQQA2AvgFIAZBADYC8AUgBkEANgLoBSAGQgg3A5AFIAZCADcDgAUgBkIANwPwBCAGQgA3A+AEIAZCADcD0AQgBkIANwPABCAGQgA3A7AEIAZBiAZqQQBBLPwLACAGIAc2AuwGIAZBgICAgHg2AuAGIAZBgICAgHg2AtQGIAZBgICAgHg2AsgGIAZBgICAgHg2ArwGIAZCATcCtAYgBiADKQPgAjcDgAYgAygCjAUhCiAGIAMoApAFQQAgAygCiAUiCBs2ApALIAYgCjYCjAsgBiAINgKICyAGQQA2AoQLIAYgCEEARyIMNgKACyAGIAo2AvwKIAYgCDYC+AogBkEANgL0CiAGIAw2AvAKIAZB4AJqIAZB8ApqIggQrBUgBkGwBmpBAUEBEOAeIAZBuAZqIAZB6AJqKAIANgIAIAYgBikC4AI3A7AGIAggBkGwBGpBwAL8CgAAIAZB9AZqIANB3ARqELUWIAZBiA1qIQggBigCiA1BgICAgHhHBEAgCEEEQQgQ4B4LIAggBikC9AY3AgAgCEEIaiAGQfwGaigCADYCACAGKQPwCiEjIAYpA/gKISQgBkHgAmogBkGAC2pB0AH8CgAAIAZBgAJqIAZB0AxqQeAA/AoAACAGQUBrIAZB8AJqQcAB/AoAACAGIAZBoAJqQcAA/AoAACAmQgAgCxshJiADLQCWBQRAIAdBCGoQqiUhCkEAIQdBACEIIAMoAqACQQFGBEACQCADKAKkAiIIBEAgBkGwDWogA0GwAmogAygCqAIgAygCrAIgCCgCABEFAAwBCyAGQQA2ArANC0EBIQgLIAMoArQCQQFGBEACQCADKAK4AiIHBEAgBkHADWogA0HEAmogAygCvAIgAygCwAIgBygCABEFAAwBCyAGQQA2AsANC0EBIQcLIAZBtAdqIAZBuA1qKQIANwIAIAZByAdqIAZByA1qKQIANwMAIAYgCDYCqAcgBkIBNwOYByAGIAYpArANNwKsByAGIAc2ArwHIAYgBikCwA03A8AHIAYgAykDmAI3A6AHIAYgAykD2AE3A5AHIAYgAykD0AE3A4gHIAYgCkH/AXFFOgDTByAGQQA6ANIHIAYgCDoA0QcgBiAHOgDQByAGQgY3A4AHIAZB2AdqIgcgAyAGQYAHahDjBiAGICU3A4gLIAYgKDcDgAsgBiAkNwP4CiAGICM3A/AKIAZBkAtqIgggBkFAayIKQcAB/AoAACAGICY3A+gMIAYgKjcD4AwgBiAnNwPYDCAGICk3A9AMIAZB8AxqIgsgBkHAAPwKAAAgBkHQC2oiDBDCGCAMIAdB2AD8CgAAIAZBsAhqIgwgBkHwCmoiD0HAAvwKAAAgBiADKQPoATcDiAkgBiADKQPgATcDgAkgBkHoAmoiByADQdACaigCADYCACADKQLIAiEjIANBgICAgHg2AsgCIAYgIzcD4AIgBkHUCmoQhTAgBkHcCmogBygCADYCACAGIAYpA+ACNwLUCiAPIAxBwAL8CgAAIAcgA0HcAmooAgA2AgAgAykC1AIhIyADQYCAgIB4NgLUAiAGICM3A+ACIAZBoA1qEIUwIAZBqA1qIAcoAgA2AgAgBiAGKQPgAjcDoA0gBikD8AohIyAGKQP4CiEkIAYpA4ALISggBikDiAshJSAKIAhBwAH8CgAAIAYpA+gMISYgBikD4AwhKiAGKQPYDCEnIAYpA9AMISkgBiALQcAA/AoAAAsgI0ICUgRAIAVBIGogBkFAa0HAAfwKAAAgBUGAAmogBkHAAPwKAAAgBSAmNwP4ASAFICo3A/ABIAUgJzcD6AEgBSApNwPgAQsgBSAlNwMYIAUgKDcDECAFICQ3AwggBSAjNwMAIAZB0A1qJAAMAQsACyACQeACaiIFIAJB6ANqKQMANwMAIAJB6AJqIgYgAkHwA2opAwA3AwAgAiACKQPgAzcD2AIgAikD2AMiI0ICUQRAIAQgAikD2AI3AwggBEICNwMAIARBGGogBikDADcDACAEQRBqIAUpAwA3AwAMAgsgAkE4aiACQfgDakGgAvwKAAAgAkEoaiACQeACaikDADcDACACQTBqIAJB6AJqKQMANwMAIAIgIzcDGCACIAIpA9gCNwMgIAJB2ANqIAMoAqgEIAMoAqwEKAIQEQAAIAIoAtgDIgVBCEcEQCAEIAIpAtwDNwIMIARBHGogAkHsA2ooAgA2AgAgBEEUaiACQeQDaikCADcCACAEQgI3AwAgBCAFNgIIIAJBGGoQqiAMAgsgA0EBQQJBACADLQCVBUEBcRsgAy0AlAUbNgLAAyADLQDEAyEFIAJB2ANqIgcgA0H4AmpB0AD8CgAAAn8gBUUEQCAHEO0nQYCAgIB4DAELIAJBuANqIANBjANqKAIANgIAIAJBqANqIANBmANqKAIANgIAIAJBmANqIANBpANqKAIANgIAIAJBiANqIANBsANqKAIANgIAIAIgAykChAM3A7ADIAIgAykCkAM3A6ADIAIgAykCnAM3A5ADIAIgAykCqAM3A4ADIAIoAqAEIQYgAkH4AmogA0G8A2ooAgA2AgAgAiADKQK0AzcD8AIgAikC3AMhIyACKALYAwshBQJAIAMoAvgDIgdBgICAgHhHBEAgAykD8AMhJCACIAc2AuADIAIgJDcD2AMgAkHkA2ogA0H8A2pBLPwKAAAgAkHAA2ogAkHYA2oQ6BEMAQsgAkGAgICAeDYCwAMLIAMpA5gBISQgA0GAgICAeDYCmAEgBCAkNwPoAiAEQfACaiADQaABaigCADYCACADKQPwASEkIAMpA/gBISUgAkHYA2oiByACQRhqQcAC/AoAACACQagGaiACQdADaikCADcDACACQaAGaiACQcgDaikCADcDACACIAIpAsADNwOYBiAEIAdB2AL8CgAAIAQgIzcD+AIgBCAFNgL0AiAEICU3A+ACIAQgJDcD2AIgBCACKQOwAzcCgAMgBEGIA2ogAkG4A2ooAgA2AgAgBCACKQOgAzcCjAMgBEGUA2ogAkGoA2ooAgA2AgAgBCACKQOQAzcCmAMgBEGgA2ogAkGYA2ooAgA2AgAgBCACKQOAAzcCpAMgBEGsA2ogAkGIA2ooAgA2AgAgBCAGNgK8AyAEQbgDaiACQfgCaigCADYCACAEIAIpA/ACNwKwAyADKAKABSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GABWoQ2SELIAMoAoQFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYQFahCuIAsgA0GoBGoQvCogA0GwBGoQ1ykgAxDXEyADQdADahCFMCADQdwDahCFMCADQbABahDSISADQYgFahDDHCADQdwEakEEQQgQ4B4gA0HoBGoQnTwgA0H0BGoQnTwgA0HoAmoiBBCHGSAEQQhBiAEQ4B4MAgsgAkEQaiIGIAJBLGooAgA2AgAgAkEIaiIHIAJBJGopAgA3AwAgAiACKQIcNwMAIAQgBTYCCCAEIAIpAwA3AgwgBEICNwMAIARBFGogBykDADcCACAEQRxqIAYoAgA2AgALIAMoAoAFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYAFahDZIQsgAygChAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBhAVqEK4gCyADQagEahC8KiADQbAEahDXKSADENcTIANB0ANqEIUwIANB3ANqEIUwIANBsAFqENIhIANBiAVqEMMcIANB3ARqQQRBCBDgHiADQegEahCdPCADQfQEahCdPCADQegCaiIEEIcZIARBCEGIARDgHiADQfgCahDtJyADQfADahDHKAsgA0G4BGoQ8SYgAkHQBmokAAwBCyAJQeghaiIDIAJBmAX8CgAAIwBBsAZrIgUkAAJAAkACQCADKALoA0UNACAFQdgDaiADEMoBIAUoAtgDIgJBCEYNACAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIDAELAkAgAygCWEGAgICAeEYNACAFQdgDaiADEI0HIAUoAtgDIgJBCEYNACAEIAUpAtwDNwIMIARBHGogBUHsA2ooAgA2AgAgBEEUaiAFQeQDaikCADcCACAEQgI3AwAgBCACNgIIDAELAkACQCADKALoA0UNACAFQRhqIAMQygEgBSgCGCIGQQhGDQAMAQsCQCADKAL0AiIGRQ0AIAVB4ANqIQIDQCADIAZBAWs2AvQCIAMgAygC8AIiBkEBaiIHIAMoAugCIghBACAHIAhPG2s2AvACIAMoAuwCIAZBiAFsaiIGKQMAIiNCDFENASAFICM3A9gDIAIgBkEIakGAAfwKAAAgBUEYaiADIAVB2ANqEKYKIAUoAhgiBkEIRw0CIAMoAvQCIgYNAAsLIAVB2ANqIQgjAEHQDWsiAiQAIAMpA7gBISUgAykDsAEhKCADKQOQAiEpIAMpA4ACISogAykDiAIhJyADKQPIASEmIAMoAsABIQsgAygCgAUiBiAGKAIAIgdBAWo2AgACQCAHQQBOBEAgAkEANgL4BSACQQA2AvAFIAJBADYC6AUgAkIINwOQBSACQgA3A4AFIAJCADcD8AQgAkIANwPgBCACQgA3A9AEIAJCADcDwAQgAkIANwOwBCACQYgGakEAQSz8CwAgAiAGNgLsBiACQYCAgIB4NgLgBiACQYCAgIB4NgLUBiACQYCAgIB4NgLIBiACQYCAgIB4NgK8BiACQgE3ArQGIAIgAykD4AI3A4AGIAMoAowFIQogAiADKAKQBUEAIAMoAogFIgcbNgKQCyACIAo2AowLIAIgBzYCiAsgAkEANgKECyACIAdBAEciDDYCgAsgAiAKNgL8CiACIAc2AvgKIAJBADYC9AogAiAMNgLwCiACQeACaiACQfAKaiIHEKwVIAJBsAZqQQFBARDgHiACQbgGaiACQegCaigCADYCACACIAIpAuACNwOwBiAHIAJBsARqQcAC/AoAACACQfQGaiADQdwEahC1FiACQYgNaiEHIAIoAogNQYCAgIB4RwRAIAdBBEEIEOAeCyAHIAIpAvQGNwIAIAdBCGogAkH8BmooAgA2AgAgAikD8AohIyACKQP4CiEkIAJB4AJqIAJBgAtqQdAB/AoAACACQYACaiACQdAMakHgAPwKAAAgAkFAayACQfACakHAAfwKAAAgAiACQaACakHAAPwKAAAgJkIAIAsbISYgAy0AlgUEQCAGQQhqEKolIQpBACEHQQAhBiADKAKgAkEBRgRAAkAgAygCpAIiBgRAIAJBsA1qIANBsAJqIAMoAqgCIAMoAqwCIAYoAgARBQAMAQsgAkEANgKwDQtBASEGCyADKAK0AkEBRgRAAkAgAygCuAIiBwRAIAJBwA1qIANBxAJqIAMoArwCIAMoAsACIAcoAgARBQAMAQsgAkEANgLADQtBASEHCyACQbQHaiACQbgNaikCADcCACACQcgHaiACQcgNaikCADcDACACIAY2AqgHIAJCATcDmAcgAiACKQKwDTcCrAcgAiAHNgK8ByACIAIpAsANNwPAByACIAMpA5gCNwOgByACIAMpA9gBNwOQByACIAMpA9ABNwOIByACIApB/wFxRToA0wcgAkEAOgDSByACIAY6ANEHIAIgBzoA0AcgAkIHNwOAByACQdgHaiIGIAMgAkGAB2oQ4wYgAiAlNwOICyACICg3A4ALIAIgJDcD+AogAiAjNwPwCiACQZALaiIHIAJBQGsiCkHAAfwKAAAgAiAmNwPoDCACICo3A+AMIAIgJzcD2AwgAiApNwPQDCACQfAMaiILIAJBwAD8CgAAIAJB0AtqIgwQwhggDCAGQdgA/AoAACACQbAIaiIMIAJB8ApqIg9BwAL8CgAAIAIgAykD6AE3A4gJIAIgAykD4AE3A4AJIAJB6AJqIgYgA0HQAmooAgA2AgAgAykCyAIhIyADQYCAgIB4NgLIAiACICM3A+ACIAJB1ApqEIUwIAJB3ApqIAYoAgA2AgAgAiACKQPgAjcC1AogDyAMQcAC/AoAACAGIANB3AJqKAIANgIAIAMpAtQCISMgA0GAgICAeDYC1AIgAiAjNwPgAiACQaANahCFMCACQagNaiAGKAIANgIAIAIgAikD4AI3A6ANIAIpA/AKISMgAikD+AohJCACKQOACyEoIAIpA4gLISUgCiAHQcAB/AoAACACKQPoDCEmIAIpA+AMISogAikD2AwhJyACKQPQDCEpIAIgC0HAAPwKAAALICNCAlIEQCAIQSBqIAJBQGtBwAH8CgAAIAhBgAJqIAJBwAD8CgAAIAggJjcD+AEgCCAqNwPwASAIICc3A+gBIAggKTcD4AELIAggJTcDGCAIICg3AxAgCCAkNwMIIAggIzcDACACQdANaiQADAELAAsgBUHgAmoiAiAFQegDaikDADcDACAFQegCaiIGIAVB8ANqKQMANwMAIAUgBSkD4AM3A9gCIAUpA9gDIiNCAlEEQCAEIAUpA9gCNwMIIARCAjcDACAEQRhqIAYpAwA3AwAgBEEQaiACKQMANwMADAILIAVBOGogBUH4A2pBoAL8CgAAIAVBKGogBUHgAmopAwA3AwAgBUEwaiAFQegCaikDADcDACAFICM3AxggBSAFKQPYAjcDICAFQdgDaiADKAKoBCADKAKsBCgCEBEAACAFKALYAyICQQhHBEAgBCAFKQLcAzcCDCAEQRxqIAVB7ANqKAIANgIAIARBFGogBUHkA2opAgA3AgAgBEICNwMAIAQgAjYCCCAFQRhqEKogDAILIANBAUECQQAgAy0AlQVBAXEbIAMtAJQFGzYCwAMgAy0AxAMhAiAFQdgDaiIHIANB+AJqQdAA/AoAAAJ/IAJFBEAgBxDtJ0GAgICAeAwBCyAFQbgDaiADQYwDaigCADYCACAFQagDaiADQZgDaigCADYCACAFQZgDaiADQaQDaigCADYCACAFQYgDaiADQbADaigCADYCACAFIAMpAoQDNwOwAyAFIAMpApADNwOgAyAFIAMpApwDNwOQAyAFIAMpAqgDNwOAAyAFKAKgBCEGIAVB+AJqIANBvANqKAIANgIAIAUgAykCtAM3A/ACIAUpAtwDISMgBSgC2AMLIQICQCADKAL4AyIHQYCAgIB4RwRAIAMpA/ADISQgBSAHNgLgAyAFICQ3A9gDIAVB5ANqIANB/ANqQSz8CgAAIAVBwANqIAVB2ANqEOgRDAELIAVBgICAgHg2AsADCyADKQOYASEkIANBgICAgHg2ApgBIAQgJDcD6AIgBEHwAmogA0GgAWooAgA2AgAgAykD8AEhJCADKQP4ASElIAVB2ANqIgcgBUEYakHAAvwKAAAgBUGoBmogBUHQA2opAgA3AwAgBUGgBmogBUHIA2opAgA3AwAgBSAFKQLAAzcDmAYgBCAHQdgC/AoAACAEICM3A/gCIAQgAjYC9AIgBCAlNwPgAiAEICQ3A9gCIAQgBSkDsAM3AoADIARBiANqIAVBuANqKAIANgIAIAQgBSkDoAM3AowDIARBlANqIAVBqANqKAIANgIAIAQgBSkDkAM3ApgDIARBoANqIAVBmANqKAIANgIAIAQgBSkDgAM3AqQDIARBrANqIAVBiANqKAIANgIAIAQgBjYCvAMgBEG4A2ogBUH4AmooAgA2AgAgBCAFKQPwAjcCsAMgAygCgAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIANBgAVqENkhCyADKAKEBSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GEBWoQriALIANBqARqELwqIANBsARqENcpIAMQ1xMgA0HQA2oQhTAgA0HcA2oQhTAgA0GwAWoQ0iEgA0GIBWoQwxwgA0HcBGpBBEEIEOAeIANB6ARqEJ08IANB9ARqEJ08IANB6AJqIgQQhxkgBEEIQYgBEOAeDAILIAVBEGoiAiAFQSxqKAIANgIAIAVBCGoiByAFQSRqKQIANwMAIAUgBSkCHDcDACAEIAY2AgggBCAFKQMANwIMIARCAjcDACAEQRRqIAcpAwA3AgAgBEEcaiACKAIANgIACyADKAKABSIEIAQoAgAiBEEBazYCACAEQQFGBEAgA0GABWoQ2SELIAMoAoQFIgQgBCgCACIEQQFrNgIAIARBAUYEQCADQYQFahCuIAsgA0GoBGoQvCogA0GwBGoQ1ykgAxDXEyADQdADahCFMCADQdwDahCFMCADQbABahDSISADQYgFahDDHCADQdwEakEEQQgQ4B4gA0HoBGoQnTwgA0H0BGoQnTwgA0HoAmoiBBCHGSAEQQhBiAEQ4B4gA0H4AmoQ7ScgA0HwA2oQxygLIANBuARqEPEmIAVBsAZqJAALIAlBgCdqJAAMAQsgDUHAA2oiAiAOQbAF/AoAACANQYgJaiEJIwBBsAZrIgMkAAJAAkACQCACKAKABEUNACADQdgDaiACEMwBIAMoAtgDIgRBCEYNACAJIAMpAtwDNwIMIAlBHGogA0HsA2ooAgA2AgAgCUEUaiADQeQDaikCADcCACAJQgI3AwAgCSAENgIIDAELAkAgAigCsAFBgICAgHhGDQAgA0HYA2ogAhCKByADKALYAyIEQQhGDQAgCSADKQLcAzcCDCAJQRxqIANB7ANqKAIANgIAIAlBFGogA0HkA2opAgA3AgAgCUICNwMAIAkgBDYCCAwBCwJAAkAgAigCgARFDQAgA0EYaiACEMwBIAMoAhgiBUEIRg0ADAELAkAgAigCjAMiBUUNACADQeADaiEEA0AgAiAFQQFrNgKMAyACIAIoAogDIgZBAWoiBSACKAKAAyIHQQAgBSAHTxtrNgKIAyACKAKEAyAGQYgBbGoiBikDACIjQgxRDQEgAyAjNwPYAyAEIAZBCGpBgAH8CgAAIANBGGogAiADQdgDahClCiADKAIYIgVBCEcNAiACKAKMAyIFDQALCyADQdgDaiEHIwBB0A1rIgQkACACKQMIISUgAikDACEoIAIpA2AhKSACKQNQISogAikDWCEnIAIpAxghJiACKAIQIQogAigCmAUiBiAGKAIAIgVBAWo2AgACQCAFQQBOBEAgBEEANgL4BSAEQQA2AvAFIARBADYC6AUgBEIINwOQBSAEQgA3A4AFIARCADcD8AQgBEIANwPgBCAEQgA3A9AEIARCADcDwAQgBEIANwOwBCAEQYgGakEAQSz8CwAgBCAGNgLsBiAEQYCAgIB4NgLgBiAEQYCAgIB4NgLUBiAEQYCAgIB4NgLIBiAEQYCAgIB4NgK8BiAEQgE3ArQGIAQgAikD+AI3A4AGIAIoAqQFIQggBCACKAKoBUEAIAIoAqAFIgUbNgKQCyAEIAg2AowLIAQgBTYCiAsgBEEANgKECyAEIAVBAEciCzYCgAsgBCAINgL8CiAEIAU2AvgKIARBADYC9AogBCALNgLwCiAEQeACaiAEQfAKaiIFEKwVIARBsAZqQQFBARDgHiAEQbgGaiAEQegCaigCADYCACAEIAQpAuACNwOwBiAFIARBsARqQcAC/AoAACAEQfQGaiACQfQEahC1FiAEQYgNaiEFIAQoAogNQYCAgIB4RwRAIAVBBEEIEOAeCyAFIAQpAvQGNwIAIAVBCGogBEH8BmooAgA2AgAgBCkD8AohIyAEKQP4CiEkIARB4AJqIARBgAtqQdAB/AoAACAEQYACaiAEQdAMakHgAPwKAAAgBEFAayAEQfACakHAAfwKAAAgBCAEQaACakHAAPwKAAAgJkIAIAobISYgAi0ArgUEQCAGQQhqEKolIQhBACEGQQAhBSACKAJwQQFGBEACQCACKAJ0IgUEQCAEQbANaiACQYABaiACKAJ4IAIoAnwgBSgCABEFAAwBCyAEQQA2ArANC0EBIQULIAIoAoQBQQFGBEACQCACKAKIASIGBEAgBEHADWogAkGUAWogAigCjAEgAigCkAEgBigCABEFAAwBCyAEQQA2AsANC0EBIQYLIARBtAdqIARBuA1qKQIANwIAIARByAdqIARByA1qKQIANwMAIAQgBTYCqAcgBEIBNwOYByAEIAQpArANNwKsByAEIAY2ArwHIAQgBCkCwA03A8AHIAQgAikDaDcDoAcgBCACKQMoNwOQByAEIAIpAyA3A4gHIAQgCEH/AXFFOgDTByAEQQA6ANIHIAQgBToA0QcgBCAGOgDQByAEQgY3A4AHIARB2AdqIgYgAiAEQYAHahDkBiAEICU3A4gLIAQgKDcDgAsgBCAkNwP4CiAEICM3A/AKIARBkAtqIgUgBEFAayIIQcAB/AoAACAEICY3A+gMIAQgKjcD4AwgBCAnNwPYDCAEICk3A9AMIARB8AxqIgogBEHAAPwKAAAgBEHQC2oiCxDCGCALIAZB2AD8CgAAIARBsAhqIgsgBEHwCmoiDEHAAvwKAAAgBCACKQM4NwOICSAEIAIpAzA3A4AJIARB6AJqIgYgAkGgAWooAgA2AgAgAikCmAEhIyACQYCAgIB4NgKYASAEICM3A+ACIARB1ApqEIUwIARB3ApqIAYoAgA2AgAgBCAEKQPgAjcC1AogDCALQcAC/AoAACAGIAJBrAFqKAIANgIAIAIpAqQBISMgAkGAgICAeDYCpAEgBCAjNwPgAiAEQaANahCFMCAEQagNaiAGKAIANgIAIAQgBCkD4AI3A6ANIAQpA/AKISMgBCkD+AohJCAEKQOACyEoIAQpA4gLISUgCCAFQcAB/AoAACAEKQPoDCEmIAQpA+AMISogBCkD2AwhJyAEKQPQDCEpIAQgCkHAAPwKAAALICNCAlIEQCAHQSBqIARBQGtBwAH8CgAAIAdBgAJqIARBwAD8CgAAIAcgJjcD+AEgByAqNwPwASAHICc3A+gBIAcgKTcD4AELIAcgJTcDGCAHICg3AxAgByAkNwMIIAcgIzcDACAEQdANaiQADAELAAsgA0HgAmoiBCADQegDaikDADcDACADQegCaiIFIANB8ANqKQMANwMAIAMgAykD4AM3A9gCIAMpA9gDIiNCAlEEQCAJIAMpA9gCNwMIIAlCAjcDACAJQRhqIAUpAwA3AwAgCUEQaiAEKQMANwMADAILIANBOGogA0H4A2pBoAL8CgAAIANBKGogA0HgAmopAwA3AwAgA0EwaiADQegCaikDADcDACADICM3AxggAyADKQPYAjcDICADQdgDaiACKALABCACKALEBCgCEBEAACADKALYAyIEQQhHBEAgCSADKQLcAzcCDCAJQRxqIANB7ANqKAIANgIAIAlBFGogA0HkA2opAgA3AgAgCUICNwMAIAkgBDYCCCADQRhqEKogDAILIAJBAUECQQAgAi0ArQVBAXEbIAItAKwFGzYC2AMgAi0A3AMhBCADQdgDaiIGIAJBkANqQdAA/AoAAAJ/IARFBEAgBhDtJ0GAgICAeAwBCyADQbgDaiACQaQDaigCADYCACADQagDaiACQbADaigCADYCACADQZgDaiACQbwDaigCADYCACADQYgDaiACQcgDaigCADYCACADIAIpApwDNwOwAyADIAIpAqgDNwOgAyADIAIpArQDNwOQAyADIAIpAsADNwOAAyADKAKgBCEFIANB+AJqIAJB1ANqKAIANgIAIAMgAikCzAM3A/ACIAMpAtwDISMgAygC2AMLIQQCQCACKAKQBCIGQYCAgIB4RwRAIAIpA4gEISQgAyAGNgLgAyADICQ3A9gDIANB5ANqIAJBlARqQSz8CgAAIANBwANqIANB2ANqEOgRDAELIANBgICAgHg2AsADCyACKQPAAiEkIAJBgICAgHg2AsACIAkgJDcD6AIgCUHwAmogAkHIAmooAgA2AgAgAikDQCEkIAIpA0ghJSADQdgDaiIGIANBGGpBwAL8CgAAIANBqAZqIANB0ANqKQIANwMAIANBoAZqIANByANqKQIANwMAIAMgAykCwAM3A5gGIAkgBkHYAvwKAAAgCSAjNwP4AiAJIAQ2AvQCIAkgJTcD4AIgCSAkNwPYAiAJIAMpA7ADNwKAAyAJQYgDaiADQbgDaigCADYCACAJIAMpA6ADNwKMAyAJQZQDaiADQagDaigCADYCACAJIAMpA5ADNwKYAyAJQaADaiADQZgDaigCADYCACAJIAMpA4ADNwKkAyAJQawDaiADQYgDaigCADYCACAJIAU2ArwDIAlBuANqIANB+AJqKAIANgIAIAkgAykD8AI3ArADIAIoApgFIgQgBCgCACIEQQFrNgIAIARBAUYEQCACQZgFahDZIQsgAigCnAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBnAVqEK4gCyACQcAEahC8KiACQcgEahDXKSACQbABahCzEiACQegDahCFMCACQfQDahCFMCACENIhIAJBoAVqEMMcIAJB9ARqQQRBCBDgHiACQYAFahCdPCACQYwFahCdPCACQYADaiIEEIcZIARBCEGIARDgHgwCCyADQRBqIgQgA0EsaigCADYCACADQQhqIgYgA0EkaikCADcDACADIAMpAhw3AwAgCSAFNgIIIAkgAykDADcCDCAJQgI3AwAgCUEUaiAGKQMANwIAIAlBHGogBCgCADYCAAsgAigCmAUiBCAEKAIAIgRBAWs2AgAgBEEBRgRAIAJBmAVqENkhCyACKAKcBSIEIAQoAgAiBEEBazYCACAEQQFGBEAgAkGcBWoQriALIAJBwARqELwqIAJByARqENcpIAJBsAFqELMSIAJB6ANqEIUwIAJB9ANqEIUwIAIQ0iEgAkGgBWoQwxwgAkH0BGpBBEEIEOAeIAJBgAVqEJ08IAJBjAVqEJ08IAJBgANqIgQQhxkgBEEIQYgBEOAeIAJBkANqEO0nIAJBiARqEMcoCyACQdAEahDxJiADQbAGaiQACyANQfgIaiIEIA1BmAlqKQMANwMAIA1BgAlqIgIgDUGgCWopAwA3AwAgDSANKQOQCTcD8AgCQCANKQOICSIjQgJRBEAgFSANKQPwCDcDCCAVQgI3AwAgFUEYaiACKQMANwMAIBVBEGogBCkDADcDACAOKAKwBSIEIAQoAgAiBEEBazYCACAEQQFHDQEgDkGwBWoQiBwMAQsgDUEIaiANQagJakGgA/wKAAAgDUGwA2ogDUH4CGopAwA3AwAgDUG4A2ogDUGACWopAwA3AwAgDSANKQPwCDcDqAMgDigCsAUiDkEAIA4oAgAiBCAEQQFGIgQbNgIAIARFBEAgDSAONgKMCSANQQE2AogJIA4gDigCACIAQQFrNgIAIABBAUYEQCANQYwJahCIHAtB2OnPABCyOwALIA1BnAlqIA5BGGooAgA2AgAgDUGUCWogDkEQaikCADcCACANIA4pAgg3AowJIA1BjAlqIQQCQCAOQX9GDQAgDiAOKAIEIgJBAWs2AgQgAkEBRw0AIA5BHEEEEPg6CyANQdgMaiAEQRBqKAIANgIAIA1B0AxqIARBCGopAgA3AwAgDSAEKQIANwPIDCAVQcgDaiANQdQMaikCADcCACAVIA0pAswMNwLAAyAVIA0pA6gDNwMIIBVBEGogDUGwA2opAwA3AwAgFUEYaiANQbgDaikDADcDACAVQSBqIA1BCGpBoAP8CgAAIBUgIzcDAAsgDUHgDGokAAwDCyAIIAIoAuADQcD1zgAQ/S8ACyAFIAIoAuADQdiDzwAQ/S8ACyACQQA2AugDIAJBATYC3AMgAkG4hM8ANgLYAyACQgQ3AuADIAJB2ANqQcCEzwAQ7ywACyAYKQMIIiNCAlEEQCAeKAIEIg4oAgBBCEcEQCAOEPAbCyAOIBkpAwA3AwAgDkEQaiAZQRBqKQMANwMAIA5BCGogGUEIaikDADcDAEEBISIMAgsgACAjNwMAIABBCGogGSkDADcDACAAQRBqIBlBCGopAwA3AwAgAEEYaiAZQRBqKQMANwMAIABBIGogIEGwA/wKAAAgAEHQA2ohACATIB9HDQALCyAbIAA2AgggGyAQNgIEIBsgIjYCACAYQZAJaiQAIBYoAhAhBiMAQRBrIgQkACARQQA2AgggESgCDCEOIBEoAgQhACARQQg2AgAgBEKAgICAgAE3AgggBEEIakEIQbgFEOAeIBFBCDYCDCARQQg2AgQgDiAAa0G4BW4hEyAAIA5HBEADQCAAELsKIABBuAVqIQAgE0EBayITDQALCyASQRxqIQ4gBEEQaiQAIBxBuAVsIgRB0ANuIQIgECEAAkAgHEUNACAEIAJB0ANsIgNGDQAgBEHPA00EQEEIIQAgBEUNASAQIARBCBD4OgwBCyAQIARBCCADEJc1IgANAEEIIAMQoz0ACyAOIAA2AgQgDiACNgIAIA4gBiAQa0HQA242AggjAEEQayIQJAAgESgCDCIEIBEoAgQiE2tBuAVuIQAgBCATRwRAA0AgExC7CiATQbgFaiETIABBAWsiAA0ACwsgECARKAIANgIMIBAgESgCCDYCCCAQQQhqQQhBuAUQ4B4gEEEQaiQAIBZBIGokAAJAIBIoAgBBCEcEQCAUIBIpAwA3AwAgFEEQaiASQRBqKQMANwMAIBRBCGogEkEIaikDADcDACAOKAIIIgQEQCAOKAIEIQIDQCACIB1B0ANsaiIAKALIAyIUBEAgACgCxAMhEANAIBBBDGogEEEEaigCACAQQQhqKAIAIBAoAgAoAhARAQAgEEEQaiEQIBRBAWsiFA0ACwsgAEHAA2pBBEEQEOAeIAAQ8BIgACgC6AJBgICAgHhHBEAgAEHoAmpBBEEgEOAeCyAAKAL0AkGAgICAeEcEQCAAQfQCahDeOyAAQYADaiIQENcrIBAQ6DsgAEGMA2oiEBDXKyAQEOg7IABBmANqEIUwIABBpANqEIUwIABBsANqEIUwCyAAKALAAkGAgICAeEcEQCAAQcACakEIQRgQ4B4gAEHMAmoQhTALIB1BAWoiHSAERw0ACwsgDkEIQdADEOAeDAELIBQgEikCHDcCBCAUQQg2AgAgFEEMaiASQSRqKAIANgIACyASQUBrJAAgASgCDCIAIAAoAgAiAEEBazYCACAAQQFGBEAgAUEMahD4IwsgF0EQaiQAC2UBAX8CQCAAKAIAIgAoAghBAkcEQCAAQRBqEN47DAELIABBFGoQ3jsgAEEwaiIBEKInIAFBBEEEEOAeCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEE8QQQQ+DoLC2YBAX8gA0EBaiEDQQggAWshBEEAIQEDQCADBEAgA0EBayEDIAFBASAALwEAIgEgAUH//wNGG8EgBHRBAnRB8I7RAGooAgAgAigCAGxqIQEgAkEEaiECIABBAmohAAwBCwsgAUEIdguFAQICfwJ+IwBBIGsiASQAIAFBADYCHCABQoCAgIDAADcCFCABQQhqIAFBFGoiAkH0qPsAEJghIAEpAwghAyABQQA2AhwgAUKAgICAIDcCFCABIAJB9Kj7ABCWISABKQMAIQQgAEEAOwEUIABBADYCECAAIAQ3AgggACADNwIAIAFBIGokAAt2AQF/IwBBEGsiASQAIAFBBGpBAEGMgv8AEM4YIABCADcCMCAAQQA2AiQgAEIENwIcIABCADcCFCAAQoCAgIDAADcCDCAAQTdqQQA2AAAgAEIENwIoIABBCGogAUEMaigCADYCACAAIAEpAgQ3AgAgAUEQaiQAC7kDAQt/IwBBIGsiBiQAIAEoAhwhAyMAQSBrIgIkACAGQQhqIgggASgCECIEIAEoAhRJBH8gASAEQQFqNgIQIAEoAgghByACQQxqIAEoAgAgBEEDdGoiBSgCACAFKAIEIgUoAghBAWtBeHFqQQhqIAUgASgCGBDbASACKAIUIQEgAigCECEFAkAgAigCDCIMQZOAgIB4RwRAIAIoAhwhBCACKAIYIQcgAygCAEGTgICAeEcEQCADEIgRCyADQRBqIQkgA0EMaiEKIANBCGohCyADIAU2AgQgAyAMNgIAQQAhAwwBCyAHIARBAnRqKAIAIgcoAkAhAyACQQRqIQkgAkEIaiEKIAJBDGohCyABIQQgBygCRCEBIAUhBwsgCyABNgIAIAogBzYCACAJIAQ2AgAgCCADNgIEIAggAigCDDYCCCAIIAIoAgg2AgwgCCACKAIENgIQQQEFQQALNgIAIAJBIGokAAJAAkAgBigCCEUNACAGKAIMIgFFDQAgBigCFCEFIAYoAhAhBCAAIAYoAhg2AgwgACAFNgIIIAAgBDYCBCAAIAE2AgAMAQsgAEEANgIACyAGQSBqJAALYQECfyAAIAIgAWsiA0EAIAIgA08bEO4tIAAoAgghAyAAIAEgAkkEfyACIANqIAFrIAAoAgQgA0ECdGohAANAIAAgATYCACAAQQRqIQAgAiABQQFqIgFHDQALBSADCzYCCAtkAQJ/IwBBEGsiAiQAIAAgACgCBAR/IAJBCGogABDBNCACKAIMIgEEQCACKAIIQf8BIAH8CwALIAAoAgQiASABQQFqQQN2QQdsIAFBCEkbBSABCzYCCCAAQQA2AgwgAkEQaiQAC9kEAQh/IwBBIGsiBCQAIARBAjYCBCAEQZjLhQE2AgAgBEIBNwIMIARBxwI2AhwgBEH4yYUBNgIYIAQgBEEYajYCCEEBIQkCQCABKAIAIAEoAgQgBBDLCg0AIwBBQGoiAiQAAkACQCAAKAIgIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIAkADQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACADEKYZIAIgAikDEDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyAIIANBAWoiA0cNAAsgB0GwAUkNASAHQdACTwRAIAJBAjYCICACQeDDhAE2AhwgAkIBNwIoIAJBOzYCOCACIAVBFGs2AjwgAiACQTRqNgIkIAIgAkE8ajYCNCABKAIAIAEoAgQgAkEcahDLCg0BCyAFQQprIgMgCCADIAhLGyIDIAVPDQEDQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBCGogACADEKYZIAIgAikDCDcCHCACQRxqIAEQsjYNBSABKAIAQfLDhAFBAiABKAIEKAIMEQYADQUMAQsgASgCAEH0w4QBQQggASgCBCgCDBEGAA0CCyADQQFqIgMgBUcNAAsMAQtBASEGDAELQQAhBgsgAkFAayQAIAYNACABKAIAQajLhQFBASABKAIEKAIMEQYAIQkLIARBIGokACAJC88EAQh/IwBBIGsiBCQAIARBAjYCBCAEQZjLhQE2AgAgBEIBNwIMIARBxwI2AhwgBEH0yoUBNgIYIAQgBEEYajYCCEEBIQkCQCABKAIAIAEoAgQgBBDLCg0AIwBBQGoiAiQAAkACQCAAKAIgIgdBEEkNAEEKIAdBBHYiBSAFQQpPGyEIAkADQAJAIAAgAxCRJUUEQEEBIQYgASgCAEHww4QBQQIgASgCBCgCDBEGAA0FIAJBEGogACADEKcZIAIoAhAgAigCFCABEMUjDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgCCADQQFqIgNHDQALIAdBsAFJDQEgB0HQAk8EQCACQQI2AiAgAkHgw4QBNgIcIAJCATcCKCACQTs2AjggAiAFQRRrNgI8IAIgAkE0ajYCJCACIAJBPGo2AjQgASgCACABKAIEIAJBHGoQywoNAQsgBUEKayIDIAggAyAISxsiAyAFTw0BA0ACQCAAIAMQkSVFBEBBASEGIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQhqIAAgAxCnGSACKAIIIAIoAgwgARDFIw0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAFRw0ACwwBC0EBIQYMAQtBACEGCyACQUBrJAAgBg0AIAEoAgBBqMuFAUEBIAEoAgQoAgwRBgAhCQsgBEEgaiQAIAkLbgEBf0EGIQUCQCAAIAEtABBBAUYEfyADIARrIQECQCADIARGDQAgASADTwRAIARFDQEMAwsgASACaiwAAEG/f0wNAgsgACABNgIIIAAgAjYCBEEABSAFCzoAAA8LIAIgA0EAIAFBsLyGARCjNgALcgEDfyMAQRBrIgMkACADQQRqIAJBAEEBQQEQoBggAygCCCEEIAMoAgRBAUcEQCADKAIMIQUgAgRAIAUgASAC/AoAAAsgACACNgIIIAAgBTYCBCAAIAQ2AgAgA0EQaiQADwsgBCADKAIMQYDjhgEQ/S8AC3IBAn8jAEEQayIBJAAgAUEEaiADQQBBAUEBEKAYIAEoAgghBCABKAIEQQFHBEAgASgCDCEFIAMEQCAFIAIgA/wKAAALIAAgAzYCCCAAIAU2AgQgACAENgIAIAFBEGokAA8LIAQgASgCDEHAhYgBEP0vAAu5BwMIfwJ9A34gASgCCCIDQYCAgAFxIQIgACoCACEKIANBgICAgAFxRQRAIAqLIgtDyhsOWmAgCkMAAAAAXCALQxe30ThdcXJFBEAgASAKIAJBAEdBARCQCQ8LIAJBAEchBkEAIQIjAEGgAWsiACQAIAq8IQMCf0EDIAqLQwAAgH9bDQAaQQIgA0GAgID8B3EiBEGAgID8B0YNABogA0H///8DcSIFQYCAgARyIANBAXRB/v//B3EgA0EXdkH/AXEiAhsiB60iDEIBgyEOIARFBEBBBCAFRQ0BGiACQZYBayECQgEhDSAOUAwBC0KAgIAQIAxCAYYgB0GAgIAERiIEGyEMQgJCASAEGyENQeh+Qel+IAQbIAJqIQIgDlALIQQgACACOwGIASAAIA03A4ABIABCATcDeCAAIAw3A3AgACAEOgCKAQJAAkACQAJAAkACQCAEQf8BcUEBTQRAIABB4ABqIABB8ABqIABBB2oQ/wIgACgCYEUNASAAQZgBaiAAQegAaigCADYCACAAIAApAmA3A5ABDAILIARB/wFxIgVBAkYNAkEBIQRB7uuJAUHv64kBIANBAEgiAhtB7uuJAUEBIAIbIAYbIQIgA0EfdiAGciEGIAVBBEcEQCAAQQM2AiAgAEHz64kBNgIcIABBAjsBGAwGCyAAQQM2AiAgAEECOwEYIABB9+uJATYCHAwFCyAAQZABaiAAQfAAaiAAQQdqEJQBCyAAKAKUASICRQ0BIAAoApABIgQtAABBME0NAkHu64kBQQEgA0EASCIFGyEHQe7riQFB7+uJASAFGyADQR92IQkgAC4BmAEhBSAAIAQ2AhwgAEECOwEYIABBATYCIAJ/IAJBAUYEQCAAQSRqIQNBAwwBCyAAQTxqIQMgAEECOwEwIABBxOuJATYCKCAAQQI7ASQgACACQQFrNgI4IABBATYCLCAAIARBAWo2AjRBBQshBCAHIAYbIQIgBiAJciEGIANBATsBDCADQQI7AQAgA0EBIAVrIAVBAWsgBUEATCIFGzsBDiADQQJBASAFGzYCCCADQerriQFB6OuJASAFGzYCBAwDCyAAQQM2AiAgAEHw64kBNgIcIABBAjsBGEEBIQJBACEGQQEhBAwCC0HA6IkBQSFByOuJARCfKQALQeDqiQFBH0HY64kBEJ8pAAsgACAENgJsIAAgBjYCZCAAIAI2AmAgACAAQRhqNgJoIAEgAEHgAGoQtQogAEGgAWokAA8LIAEgCiACQQBHIAEvAQ4Q6QcL3QcDBn8FfgJ8IAEoAggiBEGAgIABcSECIAArAwAhDSAEQYCAgIABcUUEQCANmSIORACA4Dd5w0FDZiANRAAAAAAAAAAAYiAORC1DHOviNho/Y3FyRQRAIAEgDSACQQBHQQEQ/QgPCyACQQBHIQRBACECIwBBoAFrIgAkACANvSEIAn9BAyANmUQAAAAAAADwf2ENABpBAiAIQoCAgICAgID4/wCDIglCgICAgICAgPj/AFENABogCEL/////////B4MiDEKAgICAgICACIQgCEIBhkL+////////D4MgCEI0iKdB/w9xIgIbIgpCAYMhCyAJUARAQQQgDFANARogAkGzCGshAkIBIQkgC1AMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIDGyEKQgJCASADGyEJQct3Qcx3IAMbIAJqIQIgC1ALIQMgACACOwGIASAAIAk3A4ABIABCATcDeCAAIAo3A3AgACADOgCKAQJAAkACQAJAAkACQCADQf8BcSICQQFNBEAgAEHgAGogAEHwAGogAEEHahD/AiAAKAJgRQ0BIABBmAFqIABB6ABqKAIANgIAIAAgACkCYDcDkAEMAgsgAkECRg0CQQEhAkHu64kBQe/riQEgCEIAUyIFG0Hu64kBQQEgBRsgBBshBSAIQj+IpyAEciEGIANB/wFxQQRHBEAgAEEDNgIgIABB8+uJATYCHCAAQQI7ARgMBgsgAEEDNgIgIABBAjsBGCAAQffriQE2AhwMBQsgAEGQAWogAEHwAGogAEEHahCUAQsgACgClAEiAkUNASAAKAKQASIHLQAAQTBNDQJB7uuJAUEBIAhCAFMiBRshBiAALgGYASEDIAAgBzYCHCAAQQI7ARggAEEBNgIgQe7riQFB7+uJASAFGyAGIAQbIQUgCEI/iKcgBHIhBgJ/IAJBAUYEQEEDIQIgAEEkagwBCyAAQQI7ATAgAEHE64kBNgIoIABBAjsBJCAAIAJBAWs2AjggAEEBNgIsIAAgB0EBajYCNEEFIQIgAEE8agsiBEEBOwEMIARBAjsBACAEQQEgA2sgA0EBayADQQBMIgMbOwEOIARBAkEBIAMbNgIIIARB6uuJAUHo64kBIAMbNgIEDAMLIABBAzYCICAAQfDriQE2AhwgAEECOwEYQQEhBUEBIQIMAgtBwOiJAUEhQcjriQEQnykAC0Hg6okBQR9B2OuJARCfKQALIAAgAjYCbCAAIAY2AmQgACAFNgJgIAAgAEEYajYCaCABIABB4ABqELUKIABBoAFqJAAPCyABIA0gAkEARyABLwEOEOcHC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEOk7IAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC3MBAX8gABDTJCAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDfHwsCQCAAKAIARQ0AIAAoAgQiAUGEAUkNACABEPIfCwJAIAAoAhAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEQahDpJwsLZAEBf0HIAEEEEK02IgQEQCAEIAJByAD8CgAAIAAgAUHQAPwKAAAgACAENgJQIABB5ABqIANBEGooAgA2AgAgAEHcAGogA0EIaikCADcCACAAIAMpAgA3AlQPC0EEQcgAEKM9AAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3xogASAEEOgYIAAgASADEModIAJBQGskAAvlAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQcjAEEgayIBJAAgAUEUaiADQTBqIgkiAigCBCACKAIAa0ECdkEAQQJBAhCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgBDYCCCACKAIEIgggAigCACIEa0ECdiIGIAFBCGoiAigCACACKAIIIgVrSwRAIAIgBSAGQQJBAhDQKAsgAigCCCEFIAIgBCAIRwR/IAUgBmogAigCBCAFQQF0aiECA0AgAiAEKAIAOwEAIARBBGohBCACQQJqIQIgBkEBayIGDQALBSAFCzYCCCAHQQhqIAsoAgA2AgAgByABKQIINwIAIAFBIGokACAJIAcQ6RggACAJIAoQzR0gA0FAayQAC8MCAQp/IwBBQGoiAiQAIAJBDGoiCiABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGohBSMAQSBrIgEkACABQRRqIAJBMGoiCCIDKAIEIAMoAgBrQQJ2QQBBAUEBEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASAENgIIIAFBCGoiBiADKAIEIgcgAygCACIDa0ECdiIJEIEuIAYoAgghBCADIAdHBEAgBigCBCEHA0AgBCAHaiADKAIAOgAAIANBBGohAyAEQQFqIQQgCUEBayIJDQALCyAGIAQ2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCCAFEO4YIAAgCCAKENgdIAJBQGskAAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCPLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3xogASAEEOgYIAAgASADEL8dIAJBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjC8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0EEdkEAQQRBBBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBBHYiBxDuLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBAnRqIQIDQCACIAQoAgA2AgAgBEEQaiEEIAJBBGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDoGCAAIAkgChC/HSADQUBrJAALzAIBCn8jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEI8vIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBAnZBAEEIQQgQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQJ2IgcQ7C0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQN0aiECA0AgAiAENAIANwMAIARBBGohBCACQQhqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQvRggACAJIAoQxh0gA0FAayQAC9oCAgp/AX4jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBA3ZBAEEQQRAQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQN2IgcQ6y0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQR0aiECA0AgAiAEKQMAIgw3AwAgAiAMQj+HNwMIIARBCGohBCACQRBqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ7BggACAJIAoQyx0gA0FAayQAC9kDAgx/A34jAEFAaiIDJAAgA0EMaiILIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEKIwBBIGsiAiQAIAJBFGogA0EwaiIFKAIEIAUoAgBrQQN2QQBBEEEgEKAYIAIoAhghASACKAIUQQFGBEAgASACKAIcQcTSzAAQ/S8ACyACQRBqIgxBADYCACACIAIoAhw2AgwgAiABNgIIIwBBEGsiByQAIAJBCGoiASAFKAIEIAUoAgBrQQN2EO8tIAcgASkCBEIgiTcCCCAHIAFBCGo2AgQjAEEgayIGJAAgB0EEaiIEKAIEIQggBCgCACAFKAIAIgkgBSgCBCIBRwRAIAQoAgggCEEFdGohBCAIIAEgCWtBA3YiAWohCANAIAYgCSkDACIOIA5CP4cQsi4gBikDACEPIAYpAwghECAGKQMQIQ4gBEEYaiAGKQMYNwMAIARBEGogDjcDACAEIBA3AwggBCAPNwMAIAlBCGohCSAEQSBqIQQgAUEBayIBDQALCyAINgIAIAZBIGokACAHQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgBSAKEO0YIAAgBSALEM4dIANBQGskAAvDAgEKfyMAQUBqIgIkACACQQxqIgogARCSNhDuJSACIAFBDGoQjy8gAiACKQMANwIwIAIgAkE/ajYCOCACQSRqIQUjAEEgayIBJAAgAUEUaiACQTBqIggiAygCBCADKAIAa0ECdkEAQQFBARCgGCABKAIYIQQgASgCFEEBRgRAIAQgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgBDYCCCABQQhqIgYgAygCBCIHIAMoAgAiA2tBAnYiCRDlLSAGKAIIIQQgAyAHRwRAIAYoAgQhBwNAIAQgB2ogAygCADoAACADQQRqIQMgBEEBaiEEIAlBAWsiCQ0ACwsgBiAENgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAggBRDuGCAAIAggChDBHSACQUBrJAALYgEDfyMAQUBqIgIkACACQQxqIgMgARCSNhDuJSACIAFBDGoQkC8gAiACKQMANwIwIAIgAkE/ajYCOCACQSRqIgQgAkEwaiIBEN4aIAEgBBC9GCAAIAEgAxDWHSACQUBrJAAL0gMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBAnYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0ECdiIBaiEIA0AgBiAJKAIAEMktIAYpAwAhDiAGKQMIIQ8gBikDECEQIARBGGogBikDGDcDACAEQRBqIBA3AwAgBCAPNwMIIAQgDjcDACAJQQRqIQkgBEEgaiEEIAFBAWsiAQ0ACwsgCDYCACAGQSBqJAAgB0EQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAUgChDtGCAAIAUgCxDOHSADQUBrJAALzAIBCn8jAEFAaiIDJAAgA0EMaiIKIAEQkjYQ7iUgAyABQQxqEJAvIAMgAykDADcCMCADIANBP2o2AjggA0EkaiEFIwBBIGsiASQAIAFBFGogA0EwaiIJIgQoAgQgBCgCAGtBA3ZBAEEEQQQQoBggASgCGCECIAEoAhRBAUYEQCACIAEoAhxBxNLMABD9LwALIAFBEGoiC0EANgIAIAEgASgCHDYCDCABIAI2AgggAUEIaiICIAQoAgQiBiAEKAIAIgRrQQN2IgcQ7i0gAigCCCEIIAIgBCAGRwR/IAcgCGogAigCBCAIQQJ0aiECA0AgAiAEKQMAPgIAIARBCGohBCACQQRqIQIgB0EBayIHDQALBSAICzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ6BggACAJIAoQvx0gA0FAayQAC8wCAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCMLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSIEKAIEIAQoAgBrQQR2QQBBCEEIEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASACNgIIIAFBCGoiAiAEKAIEIgYgBCgCACIEa0EEdiIHEOwtIAIoAgghCCACIAQgBkcEfyAHIAhqIAIoAgQgCEEDdGohAgNAIAIgBCkDADcDACAEQRBqIQQgAkEIaiECIAdBAWsiBw0ACwUgCAs2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCSAFEL0YIAAgCSAKENYdIANBQGskAAtiAQN/IwBBQGoiAiQAIAJBDGoiAyABEJI2EO4lIAIgAUEMahCQLyACIAIpAwA3AjAgAiACQT9qNgI4IAJBJGoiBCACQTBqIgEQ3hogASAEEL0YIAAgASADEMYdIAJBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0ECdkEAQQJBAhCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBAnYiBxDtLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBAXRqIQIDQCACIAQoAgA7AQAgBEEEaiEEIAJBAmohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDpGCAAIAkgChDaHSADQUBrJAAL2gICCn8BfiMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0ECdkEAQRBBEBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBAnYiBxDrLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBBHRqIQIDQCACIAQ0AgAiDDcDACACIAxCP4c3AwggBEEEaiEEIAJBEGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRDsGCAAIAkgChDLHSADQUBrJAAL2QMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQjy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBAnZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBAnYQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0ECdiIBaiEIA0AgBiAJNAIAIg4gDkI/hxCyLiAGKQMAIQ8gBikDCCEQIAYpAxAhDiAEQRhqIAYpAxg3AwAgBEEQaiAONwMAIAQgEDcDCCAEIA83AwAgCUEEaiEJIARBIGohBCABQQFrIgENAAsLIAg2AgAgBkEgaiQAIAdBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACAFIAoQ7RggACAFIAsQzh0gA0FAayQAC8wCAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCLLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSIEKAIEIAQoAgBrQQV2QQBBBEEEEKAYIAEoAhghAiABKAIUQQFGBEAgAiABKAIcQcTSzAAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASACNgIIIAFBCGoiAiAEKAIEIgYgBCgCACIEa0EFdiIHEO4tIAIoAgghCCACIAQgBkcEfyAHIAhqIAIoAgQgCEECdGohAgNAIAIgBCgCADYCACAEQSBqIQQgAkEEaiECIAdBAWsiBw0ACwUgCAs2AgggBUEIaiALKAIANgIAIAUgASkCCDcCACABQSBqJAAgCSAFEOgYIAAgCSAKEL8dIANBQGskAAvMAgEKfyMAQUBqIgMkACADQQxqIgogARCSNhDuJSADIAFBDGoQiy8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQUjAEEgayIBJAAgAUEUaiADQTBqIgkiBCgCBCAEKAIAa0EFdkEAQQhBCBCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHE0swAEP0vAAsgAUEQaiILQQA2AgAgASABKAIcNgIMIAEgAjYCCCABQQhqIgIgBCgCBCIGIAQoAgAiBGtBBXYiBxDsLSACKAIIIQggAiAEIAZHBH8gByAIaiACKAIEIAhBA3RqIQIDQCACIAQpAwA3AwAgBEEgaiEEIAJBCGohAiAHQQFrIgcNAAsFIAgLNgIIIAVBCGogCygCADYCACAFIAEpAgg3AgAgAUEgaiQAIAkgBRC9GCAAIAkgChDWHSADQUBrJAAL0gMCDH8DfiMAQUBqIgMkACADQQxqIgsgARCSNhDuJSADIAFBDGoQkC8gAyADKQMANwIwIAMgA0E/ajYCOCADQSRqIQojAEEgayICJAAgAkEUaiADQTBqIgUoAgQgBSgCAGtBA3ZBAEEQQSAQoBggAigCGCEBIAIoAhRBAUYEQCABIAIoAhxBxNLMABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAE2AggjAEEQayIHJAAgAkEIaiIBIAUoAgQgBSgCAGtBA3YQ7y0gByABKQIEQiCJNwIIIAcgAUEIajYCBCMAQSBrIgYkACAHQQRqIgQoAgQhCCAEKAIAIAUoAgAiCSAFKAIEIgFHBEAgBCgCCCAIQQV0aiEEIAggASAJa0EDdiIBaiEIA0AgBiAJKQMAELMuIAYpAwAhDiAGKQMIIQ8gBikDECEQIARBGGogBikDGDcDACAEQRBqIBA3AwAgBCAPNwMIIAQgDjcDACAJQQhqIQkgBEEgaiEEIAFBAWsiAQ0ACwsgCDYCACAGQSBqJAAgB0EQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAUgChDtGCAAIAUgCxDOHSADQUBrJAALZgEDfwJAIAEoAgBBgICAgHhGBEAMAQtBASEDIAEoAggiBEUEQAwBCyABKAIEIQEDQEEAIAEoAgAgAUEEai0AABsgAmohAiABQQhqIQEgBEEBayIEDQALCyAAIAI2AgQgACADNgIAC/oBAgN/AX4jAEGQAmsiAyQAAkAgAQRAIANBkAFqIQIDQCADQQhqIgQgABDfHCADKQMIQg1RDQIgAiAEQYAB/AoAACADIAE2AogBAkAgAikDACIFQgxSBEACQAJAAkBBASAFp0EJayAFQghYGw4CAQIACyACQRRqIAIoAgwgAigCECACKAIIKAIQEQEADAMLIAJB7ABqIAIoAmQgAigCaCACKAJgKAIQEQEAIAJBCGoQwhgMAgsgAkHkAGogAigCXCACKAJgIAIoAlgoAhARAQAgAhDCGAwBCyACQQhqEMkjCyABQQFrIgENAAsLQQAhAQsgA0GQAmokACABC3gBAX8gACgCvAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBvAJqENkhCyAAQYACakEBQQEQ4B4gAEGMAmoQhjAgAEHgAGoQrCkgACgCmAJBgICAgHhHBEAgAEGYAmpBBEEIEOAeCyAAQaQCahCFMCAAQbACahCFMAvVAgIGfwF+IABBIGoQvCogACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahCJKQsgAEFAaxDPLwJAIAAoAgQiBEUNACAAKAIMIgUEQCAAKAIAIgFBCGohAiABKQMAQn+FQoCBgoSIkKDAgH+DIQcDQCAHUARAA0AgAUHgAGshASACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyIHQoCBgoSIkKDAgH9RDQALIAdCgIGChIiQoMCAf4UhBwsgASAHeqdBA3ZBdGxqQQhrIgYoAgAiAyADKAIAIgNBAWs2AgAgA0EBRgRAIAYQuyMLIAdCAX0gB4MhByAFQQFrIgUNAAsLIAQgBEEMbEETakF4cSIBakEJaiICRQ0AIAAoAgAgAWsgAkEIEPg6CwJAIAAoAjgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEE4ahCBLAsLeQEBfwJAIAApAwBCAlENACAAQcgCakEEQQQQ4B4gAEHUAmoiARDRKyABEOg7IABB4AJqEK4vIABBMGoQ8SsgACgC7AJBgICAgHhHBEAgAEHsAmpBBEEMEOAeCyAAQYgBahDTLiAAKQOwAUIDUQ0AIABBkAJqEJcwCwtyAQF/IAAoAhAiAyAAKAIIRgRAIABBCGpByPvPABCzKAsgACgCDCADQQN0aiABNwMAIAAgA0EBajYCECAAKAIcIgMgACgCFEYEQCAAQRRqQdj7zwAQnSgLIAAoAhggA0ECdGogAjYCACAAIANBAWo2AhwLawEBfyAAKAIAIgBB6ABqEN47IABB9ABqEK4vIABByABqEPgmIAAoAoABQYCAgIB4RwRAIABBgAFqQQRBCBDgHgsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBoAFBCBD4OgsLZgEDfyMAQSBrIgEkACAAEOUkIAFBGGoiAiAAQcAFaigAADYCACABIAApALgFNwMQIAAoApgEIABBmARqQQBBLPwLACABQQhqIAIoAgA2AgAgASABKQMQNwMAIAEQiy0gAUEgaiQAC2YBA38gBUUgASAAKAIEIghrIgcgACgCHCIGa0GBA0lyRQRAIAAgBiAGQeAAaiACIAMgBEEBENAVIAAgCCACIAdBIGsiBiABQQFqEKAaCyAAIAYgByACIAMgBCAFENAVIAAgBzYCHAtiAQF/Qbh/IQMgAUEBQQUgAhsiAU8EfyAAIAFqQQFrLQAAIgBBA3FBAnRBwLXRAGooAgAgAWogAEEEdkEMcUHQtdEAaigCAGogAEEgcSIBRWogAUEFdiAAQcAASXFqBSADCwtpAQF/AkAgASAETwRAIAMgBEkNAUEAIQECQANAIAEgBEYNASABIAJqIQMgACABaiABQQFqIQEtAAAgAy0AAEYNAAsgAUEBayEECyAEDwsgBCABQYzS0QAQsDsACyAEIANBnNLRABCwOwALXQEEfyABKAIEIgNBEGoiBCAALwEOIgVB/wdxIgJMBH8gAiADa0EQayICQX8gASgCACIBdEF/c3EgBGogACgCCCACIAF2QQFxQQJyIAVBCnZ0akEEayABdGoFIAILC3EBAn9BASEEIwBBEGsiAyQAAn9BgYCAgHggASgCACACa0EgTw0AGiADQQhqIAEgAkEgQQFBARC3EUGBgICAeCADKAIIIgFBgYCAgHhGDQAaIAMoAgwhBCABCyEBIAAgBDYCBCAAIAE2AgAgA0EQaiQAC+ACAQp/IwBBQGoiAyQAIANBDGoiCiABEJI2EO4lIAMgAUEMahCPLyADIAMpAwA3AjAgAyADQT9qNgI4IANBJGohBSMAQSBrIgEkACABQRRqIANBMGoiCSICKAIEIAIoAgBrQQJ2QQBBCEEQEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIgtBADYCACABIAEoAhw2AgwgASAENgIIIAFBCGoiBiACKAIEIgcgAigCACIEa0ECdiIIEOktIAYoAgghAiAGIAQgB0cEfyACIAhqIAYoAgQgAkEEdGohAgNAIAJBCGpCADcDACACQQRqQQA2AgAgAiAEKAIANgIAIARBBGohBCACQRBqIQIgCEEBayIIDQALBSACCzYCCCAFQQhqIAsoAgA2AgAgBSABKQIINwIAIAFBIGokACAJIAUQ6hggACAJIAoQxR0gA0FAayQAC8ACAgl/AX4jAEEgayICJAAgACABKAIEIgMgASgCACIEa0ECdhDsLSAAKQIEIQsgAkEcaiABQRBqKAIANgIAIAIgC0IgiTcCDCACIABBCGo2AgggAiABKQIINwIUIAJBCGoiASgCBCEFIAEoAgAhAAJAAkACQCADIARHBEAgASgCFCEJIAEoAhAhBiABKAIMIQogASgCCCAFQQN0aiEHIAMgBGtBAnYhAwNAIAQoAgAiCCAGTw0CIAhBAWoiASAGTw0DIAkgCSkDACAKIAFBA3RqKQMAIAogCEEDdGopAwB9Qv////8Pg3wiCzcDACAHIAs3AwAgBEEEaiEEIAdBCGohByAFQQFqIQUgA0EBayIDDQALCyAAIAU2AgAMAgsgCCAGQbCBhAEQwyEACyABIAZBwIGEARDDIQALIAJBIGokAAvTAgIJfwF+IwBBIGsiAiQAIAAgASgCBCIDIAEoAgAiBGtBAnYQ7i0gACkCBCELIAJBHGogAUEQaigCADYCACACIAtCIIk3AgwgAiAAQQhqNgIIIAIgASkCCDcCFCACQQhqIgAoAgQhBSAAKAIAIQECQAJAIAMgBEcEQCAAKAIUIQkgACgCECEGIAAoAgwhCiAAKAIIIAVBAnRqIQcgAyAEa0ECdiEDA0AgBCgCACIIIAZPDQICQCAGIAhBAWoiAEsEQCAKIABBAnRqKAIAIAogCEECdGooAgBrIgBBAE4NAUHQgYQBQRRB5IGEARDLJAALIAAgBkHAgYQBEMMhAAsgCSAJKAIAIABqIgA2AgAgByAANgIAIARBBGohBCAHQQRqIQcgBUEBaiEFIANBAWsiAw0ACwsgASAFNgIADAELIAggBkGwgYQBEMMhAAsgAkEgaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEJ08IAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC2wBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACQQRBDBDgHiACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAtoAQR/IwBBEGsiASQAIAAoAgwiBCAAKAIEIgJrQQxuIQMgAiAERwRAA0AgAhDeOyACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAtoAQR/IwBBEGsiASQAIAAoAgwiBCAAKAIEIgJrQQxuIQMgAiAERwRAA0AgAhDjPCACQQxqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEEMEOAeIAFBEGokAAt9ACAAQpeu3Ljx4sWLFzcCDCAAQRRqQZeu3LgBNgIAIAAgASkCADcCGCAAIAIpAgA3AgAgACADKQIANwIkIABBIGogAUEIaigCADYCACAAQQhqIAJBCGooAgA2AgAgAEEsaiADQQhqKQIANwIAIABBNGogA0EQaikCADcCAAt9ACAAQpq06NChw4aNGjcCDCAAQRRqQZq06NABNgIAIAAgASkCADcCGCAAIAIpAgA3AgAgACADKQIANwIkIABBIGogAUEIaigCADYCACAAQQhqIAJBCGooAgA2AgAgAEEsaiADQQhqKQIANwIAIABBNGogA0EQaikCADcCAAuQAgEFfyMAQSBrIgMkACADQQhqIQYgASgCDCECIwBBIGsiBSQAAn9BAiABKAIAIgQgASgCBEYNABogASAEQQRqNgIAIAVBDGogBCABKAIIEJQDIAUoAhAhAUEBIAUoAgwiBEGTgICAeEYNABogAigCAEGTgICAeEcEQCACEIgRCyACIAE2AgQgAiAENgIAIAIgBUEUaiIEKQIANwIIIAJBEGogBEEIaigCADYCAEEACyECIAYgATYCBCAGIAI2AgAgBUEgaiQAIAMgAygCDCIBNgIYIAMgAygCCCICQQAgAkECRxsiAjYCFCACQQFxIgJFBEAgA0EUahC/KgsgACABNgIEIAAgAjYCACADQSBqJAALkAIBBX8jAEEgayIDJAAgA0EIaiEGIAEoAgwhAiMAQSBrIgUkAAJ/QQIgASgCACIEIAEoAgRGDQAaIAEgBEEEajYCACAFQQxqIAQgASgCCBCTAyAFKAIQIQFBASAFKAIMIgRBk4CAgHhGDQAaIAIoAgBBk4CAgHhHBEAgAhCIEQsgAiABNgIEIAIgBDYCACACIAVBFGoiBCkCADcCCCACQRBqIARBCGooAgA2AgBBAAshAiAGIAE2AgQgBiACNgIAIAVBIGokACADIAMoAgwiATYCGCADIAMoAggiAkEAIAJBAkcbIgI2AhQgAkEBcSICRQRAIANBFGoQvyoLIAAgATYCBCAAIAI2AgAgA0EgaiQAC2wBAX8jAEEQayICJAACQAJAIAFFBEAgAiAAEJgfIAIgAikDADcCCCACQQhqEMkmDAELIABFDQEgAiAAQQhrIgA2AgggACAAKAIAQQFrIgA2AgAgAA0AIAJBCGoQ7x0LIAJBEGokAA8LEJg9AAtuAQF/IABBmANqEJQMIABB+AJqELwqIABBgANqELQwIABBjANqELQwIAAoAugCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegCahDZIQsgAEHQAmoQ3jsgAEGgAmoQsiwgAEHcAmoQtDAgABDhHwtoAQF/IABBDGoQtDAgAEEYahC0MCAAEOk7IAAoAiQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBJGoQuyMLAkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwt3AQF/IwBBIGsiAiQAIAIgATYCCCACIAFBCGoQ3iU2AhwgAkIANwIUIAJCgICAgMAANwIMIAAgAkEMahDJICAAQQA2AlAgAEKAgICAgAE3A0ggASABKAIAIgBBAWs2AgAgAEEBRgRAIAJBCGoQ2SELIAJBIGokAAt3AQF/IwBBIGsiAiQAIAIgATYCCCACIAFBCGoQ3iU2AhwgAkIANwIUIAJCgICAgIABNwIMIAAgAkEMahDJICAAQQA2AlAgAEKAgICAgAE3A0ggASABKAIAIgBBAWs2AgAgAEEBRgRAIAJBCGoQ2SELIAJBIGokAAu+AQIEfwF+IwBBEGsiBCQAIARBCGohBSABQSBqIQcjAEEQayIBJAAgAUEIakEAOwEAIAFCADcDACADIAEQshUiBkELTwRAIAZBCkGsmc8AELA7AAsgBygCACABIAYQoTYgBUEEOgAAIAUgBjYCBCABQRBqJAACQAJAIAQtAAhBBEYNACAEKQMIIghC/wGDQgRRDQAgBCAINwMIIAAgBRDQCQwBCyAHKAIAIAIgAxChNiAAQQQ2AgALIARBEGokAAtyAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQZjXzgA2AgggAkIENwIQIAJBCGpBpNnOABDvLAALIAJBBGpBBCAAQQRBtNnOABDVLCACKAIEIAJBIGokAEG9z9bxAWxBEXYLcgEBfyMAQSBrIgIkACACQQA2AgQgAUEDTQRAIAJBADYCGCACQQE2AgwgAkGY184ANgIIIAJCBDcCECACQQhqQaTZzgAQ7ywACyACQQRqQQQgAEEEQbTZzgAQ1SwgAigCBCACQSBqJABBvc/W8QFsQRJ2C2UBA38gACABEIEuIAAoAgQiBCAAKAIIIgJqIQMCQAJAIAFBAk8EQCABQQFrIgEEQCADQQAgAfwLAAsgBCABIAJqIgJqIQMMAQsgAUUNAQsgA0EAOgAAIAJBAWohAgsgACACNgIIC+8BAQV/IwBBEGsiBCQAIABBEGpBmJ/PAEG4n88AEIU1IgIoAgAgAigCBCgCDBEEABDaASMAQTBrIgIkACACQSBqIARBD2pBCEGAwAAQ+xQgAiACKQIoNwIYIAIgAikCIDcCECACIAJBEGoQwTQgAigCBCIDBEAgAigCAEH/ASAD/AsACyACKAIYIQMgAigCFCEFIAIoAhAhBiAAIAIoAhw2AgwgACADNgIIIAAgBTYCBCAAIAY2AgAgAkEwaiQAIABBQGsgAUEQaigCADYCACAAQThqIAFBCGopAgA3AgAgACABKQIANwIwIARBEGokAAtyAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQdCY0gA2AgggAkIENwIQIAJBCGpBzJ3WABDvLAALIAJBBGpBBCAAQQRB3J3WABDVLCACKAIEIAJBIGokAEG9z9bxAWxBEnYLagECfwJAIAAoAhAiBARAIAAoAgwiAyACTw0BIAAgBEEBazYCECAAIANBAWo2AgwgACAAKAIIQQhrNgIIIAAgASADajEAAEI4hiAAKQMAQgiIhDcDAAsgBEEARw8LIAMgAkG4qvsAEMMhAAtoAQR/AkAgACgCCCICIAAoAgQiA00EQCAAKAIAIgUgAmovAAAgAUH//wNxIgBBAmpPBH8gACACaiIAIANLDQIgACAFai8AAAUgBAsPCyACIANBnIL/ABCvOwALIAAgA0Gcgv8AEK87AAtuAQF/IwBBMGsiASQAIAAtAABBI0YEQCAALQABIAFBMGokAA8LIAFBATYCECABQZSH/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHIif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJUYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZiG/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHYif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJkYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZCI/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakHoif8AEO8sAAtuAQF/IwBBMGsiASQAIAAtAABBJEYEQCAALQABIAFBMGokAA8LIAFBATYCECABQZyF/wA2AgwgAUIBNwIYIAFBpwQ2AiggASAANgIsIAEgAUEkajYCFCABIAFBLGo2AiQgAUEMakH4if8AEO8sAAuaBQILfwN+IwBBMGsiCiQAIAEgAhDjISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiIMIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQWBxajYCOCACIAJBCGo2AjwgAkEoaiELIwBBIGsiASQAIAFBFGogAkE0aiIFKAIEIAUoAgBrQQV2QQBBCEEIEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAyAFKAIEIAUoAgBrQQV2EOwtIAcgAykCBEIgiTcCCCAHIANBCGo2AgQjAEEwayIDJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCAFKAIAIgQgBSgCBCIJRwRAIAYoAgggCEEDdGohBiAJIARrQQV2IQkgBSgCCCEPA0AgBEEQaikDACEQIAQpAwAhESAEKQMIIRIgAyAEQRhqKQMANwMYIAMgEDcDECADIBI3AwggAyARNwMAIANBIGogAxDTDiADKAIgRQ0CIAYgAysDKEQAAAAAAAAkQCAPKAIELAAAEN4gozkDACAEQSBqIQQgBkEIaiEGIAhBAWohCCAJQQFrIgkNAAsLIA4gCDYCACADQTBqJAAMAQtB+LKAAUEaQZSzgAEQyyQACyAHQRBqJAAgC0EIaiANKAIANgIAIAsgASkCCDcCACABQSBqJAAgBSALEOcYIAogBSAMENsdIAJBQGskAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAKQTD8CgAAIABB8KWAATYCCCAAIAE2AgQgAEGTgICAeDYCACAKQTBqJAAPC0EEQTgQoz0AC5MEAQp/IwBBMGsiCSQAIAEgAhDoISECIwBBQGoiASQAIAEgBDYCDCABIAM2AgggAUEQaiILIAIQkjYQ7iUgASACQQxqEJAvIAEgASkDADcCNCABIAFBCGo2AjwgAUEoaiEKIwBBIGsiAiQAIAJBFGogAUE0aiIDKAIEIAMoAgBrQQN2QQBBCEEIEKAYIAIoAhghBCACKAIUQQFGBEAgBCACKAIcQdyP/wAQ/S8ACyACQRBqIgxBADYCACACIAIoAhw2AgwgAiAENgIIIwBBEGsiBCQAIAJBCGoiBSADKAIEIAMoAgBrQQN2EOwtIAQgBSkCBEIgiTcCCCAEIAVBCGo2AgQgBEEEaiIGKAIEIQUgBigCACADKAIAIgcgAygCBCIIRwRAIAYoAgggBUEDdGohBiAFIAggB2tBA3YiCGohBSADKAIIIQ4DQCAGIAcpAwC5RAAAAAAAACRAIA4oAgQsAAAQ3iCjOQMAIAdBCGohByAGQQhqIQYgCEEBayIIDQALCyAFNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACADIAoQ5xggCSADIAsQ2x0gAUFAayQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAlBMPwKAAAgAEHwpYABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAlBMGokAA8LQQRBOBCjPQALlAQBCn8jAEEwayIJJAAgASACEOQhIQIjAEFAaiIBJAAgASAENgIMIAEgAzYCCCABQRBqIgsgAhCSNhDuJSABIAJBDGoQjy8gASABKQMANwI0IAEgAUEIajYCPCABQShqIQojAEEgayICJAAgAkEUaiABQTRqIgMoAgQgAygCAGtBAnZBAEEEQQQQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxB3I//ABD9LwALIAJBEGoiDEEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAMoAgQgAygCAGtBAnYQ7i0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgYoAgQhBSAGKAIAIAMoAgAiByADKAIEIghHBEAgBigCCCAFQQJ0aiEGIAUgCCAHa0ECdiIIaiEFIAMoAgghDgNAIAYgBygCALdEAAAAAAAAJEAgDigCBCwAABDeIKO2OAIAIAdBBGohByAGQQRqIQYgCEEBayIIDQALCyAFNgIAIARBEGokACAKQQhqIAwoAgA2AgAgCiACKQIINwIAIAJBIGokACADIAoQ6BggCSADIAsQvh0gAUFAayQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAlBMPwKAAAgAEHIpoABNgIIIAAgATYCBCAAQZOAgIB4NgIAIAlBMGokAA8LQQRBOBCjPQALqwQBC38jAEEwayIJJAAgASACEPwhIQEjAEFAaiICJAAgAiAENgIMIAIgAzYCCCACQRBqIgsgARCSNhDuJSABKAIUIQMgAiABKAIQIgE2AjQgAiABIANBcHFqNgI4IAIgAkEIajYCPCACQShqIQojAEEgayIBJAAgAUEUaiACQTRqIgMoAgQgAygCAGtBBHZBAEEEQQQQoBggASgCGCEEIAEoAhRBAUYEQCAEIAEoAhxB3I//ABD9LwALIAFBEGoiDEEANgIAIAEgASgCHDYCDCABIAQ2AggjAEEQayIGJAAgAUEIaiIEIAMoAgQgAygCAGtBBHYQ7i0gBiAEKQIEQiCJNwIIIAYgBEEIajYCBCAGQQRqIgUoAgQhByAFKAIAIAMoAgAiBCADKAIEIghHBEAgBSgCCCAHQQJ0aiEFIAcgCCAEa0EEdiIIaiEHIAMoAgghDgNAIA4oAgQsAAAhDyAFIAQpAwAgBCkDCBDRFkQAAAAAAAAkQCAPEN4go7Y4AgAgBEEQaiEEIAVBBGohBSAIQQFrIggNAAsLIAc2AgAgBkEQaiQAIApBCGogDCgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAMgChDoGCAJIAMgCxC+HSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAuUBAEKfyMAQTBrIgkkACABIAIQ6CEhAiMAQUBqIgEkACABIAQ2AgwgASADNgIIIAFBEGoiCyACEJI2EO4lIAEgAkEMahCQLyABIAEpAwA3AjQgASABQQhqNgI8IAFBKGohCiMAQSBrIgIkACACQRRqIAFBNGoiAygCBCADKAIAa0EDdkEAQQRBBBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgAygCBCADKAIAa0EDdhDuLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAgAygCACIHIAMoAgQiCEcEQCAGKAIIIAVBAnRqIQYgBSAIIAdrQQN2IghqIQUgAygCCCEOA0AgBiAHKQMAuUQAAAAAAAAkQCAOKAIELAAAEN4go7Y4AgAgB0EIaiEHIAZBBGohBiAIQQFrIggNAAsLIAU2AgAgBEEQaiQAIApBCGogDCgCADYCACAKIAIpAgg3AgAgAkEgaiQAIAMgChDoGCAJIAMgCxC+HSABQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAubBQILfwN+IwBBMGsiCiQAIAEgAhDjISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiIMIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQWBxajYCOCACIAJBCGo2AjwgAkEoaiELIwBBIGsiASQAIAFBFGogAkE0aiIFKAIEIAUoAgBrQQV2QQBBBEEEEKAYIAEoAhghAyABKAIUQQFGBEAgAyABKAIcQdyP/wAQ/S8ACyABQRBqIg1BADYCACABIAEoAhw2AgwgASADNgIIIwBBEGsiByQAIAFBCGoiAyAFKAIEIAUoAgBrQQV2EO4tIAcgAykCBEIgiTcCCCAHIANBCGo2AgQjAEEwayIDJAAgB0EEaiIGKAIEIQggBigCACEOAkACQCAFKAIAIgQgBSgCBCIJRwRAIAYoAgggCEECdGohBiAJIARrQQV2IQkgBSgCCCEPA0AgBEEQaikDACEQIAQpAwAhESAEKQMIIRIgAyAEQRhqKQMANwMYIAMgEDcDECADIBI3AwggAyARNwMAIANBIGogAxDTDiADKAIgRQ0CIAYgAysDKEQAAAAAAAAkQCAPKAIELAAAEN4go7Y4AgAgBEEgaiEEIAZBBGohBiAIQQFqIQggCUEBayIJDQALCyAOIAg2AgAgA0EwaiQADAELQfiygAFBGkGUs4ABEMskAAsgB0EQaiQAIAtBCGogDSgCADYCACALIAEpAgg3AgAgAUEgaiQAIAUgCxDoGCAKIAUgDBC+HSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCkEw/AoAACAAQcimgAE2AgggACABNgIEIABBk4CAgHg2AgAgCkEwaiQADwtBBEE4EKM9AAuTBAEKfyMAQTBrIgkkACABIAIQ5CEhAiMAQUBqIgEkACABIAQ2AgwgASADNgIIIAFBEGoiCyACEJI2EO4lIAEgAkEMahCPLyABIAEpAwA3AjQgASABQQhqNgI8IAFBKGohCiMAQSBrIgIkACACQRRqIAFBNGoiAygCBCADKAIAa0ECdkEAQQhBCBCgGCACKAIYIQQgAigCFEEBRgRAIAQgAigCHEHcj/8AEP0vAAsgAkEQaiIMQQA2AgAgAiACKAIcNgIMIAIgBDYCCCMAQRBrIgQkACACQQhqIgUgAygCBCADKAIAa0ECdhDsLSAEIAUpAgRCIIk3AgggBCAFQQhqNgIEIARBBGoiBigCBCEFIAYoAgAgAygCACIHIAMoAgQiCEcEQCAGKAIIIAVBA3RqIQYgBSAIIAdrQQJ2IghqIQUgAygCCCEOA0AgBiAHKAIAt0QAAAAAAAAkQCAOKAIELAAAEN4gozkDACAHQQRqIQcgBkEIaiEGIAhBAWsiCA0ACwsgBTYCACAEQRBqJAAgCkEIaiAMKAIANgIAIAogAikCCDcCACACQSBqJAAgAyAKEOcYIAkgAyALENsdIAFBQGskAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAJQTD8CgAAIABB8KWAATYCCCAAIAE2AgQgAEGTgICAeDYCACAJQTBqJAAPC0EEQTgQoz0AC6oEAQt/IwBBMGsiCSQAIAEgAhD8ISEBIwBBQGoiAiQAIAIgBDYCDCACIAM2AgggAkEQaiILIAEQkjYQ7iUgASgCFCEDIAIgASgCECIBNgI0IAIgASADQXBxajYCOCACIAJBCGo2AjwgAkEoaiEKIwBBIGsiASQAIAFBFGogAkE0aiIDKAIEIAMoAgBrQQR2QQBBCEEIEKAYIAEoAhghBCABKAIUQQFGBEAgBCABKAIcQdyP/wAQ/S8ACyABQRBqIgxBADYCACABIAEoAhw2AgwgASAENgIIIwBBEGsiBiQAIAFBCGoiBCADKAIEIAMoAgBrQQR2EOwtIAYgBCkCBEIgiTcCCCAGIARBCGo2AgQgBkEEaiIFKAIEIQcgBSgCACADKAIAIgQgAygCBCIIRwRAIAUoAgggB0EDdGohBSAHIAggBGtBBHYiCGohByADKAIIIQ4DQCAOKAIELAAAIQ8gBSAEKQMAIAQpAwgQ0RZEAAAAAAAAJEAgDxDeIKM5AwAgBEEQaiEEIAVBCGohBSAIQQFrIggNAAsLIAc2AgAgBkEQaiQAIApBCGogDCgCADYCACAKIAEpAgg3AgAgAUEgaiQAIAMgChDnGCAJIAMgCxDbHSACQUBrJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogCUEw/AoAACAAQfClgAE2AgggACABNgIEIABBk4CAgHg2AgAgCUEwaiQADwtBBEE4EKM9AAt0AQJ/IAEoAghBf0cEQCAAELkQIAAoAkwiAiAAKAJERgRAIABBxABqQdjrgAEQkCgLIAAoAkggAkEMbGoiAyABKQIANwIAIANBCGogAUEIaigCADYCACAAIAJBAWo2AkwgAg8LQYzqgAFBMkHA6oABEJ8pAAtmAQN/IwBBEGsiAyQAIAAoAgAhBCADIAAoAgQiAjYCDCABIANBDGpBBBC7CSACBEAgBEEIaiEAIAJBAnQhAgNAIAAoAgBBCGogARDZCiAAQQRqIQAgAkEEayICDQALCyADQRBqJAALZQEDfyAAKAIIIgEEQCAAKAIEIQAgAUEDdCEBA0ACQCAAKAIAIgJFDQAgAiAAQQRqKAIAIgMoAghBAWtBeHFqQQhqIAMoAkwRBABFDQBBAQ8LIABBCGohACABQQhrIgENAAsLQQALfQMBfwF+AXwjAEEQayIDJAACQAJAAkACQCAAKAIAQQFrDgIBAgALIAArAwghBSADQQM6AAAgAyAFOQMIDAILIAApAwghBCADQQE6AAAgAyAENwMIDAELIAApAwghBCADQQI6AAAgAyAENwMICyADIAEgAhDRHCADQRBqJAALawEDfwJAIAEoAggiAkEASA0AIAEoAgQhAwJAIAJFBEBBASEBDAELQQEhBCACQQEQrTYiAUUNAQsgAgRAIAEgAyAC/AoAAAsgACACNgIIIAAgATYCBCAAIAI2AgAPCyAEIAJBvMOJARD9LwALZwICfwF8IABEAAAAAAAA8D8gASABQR91IgJzIAJrIgJBAXEbIQQgAkECTwRAA0AgBCAAIACiIgCiIAQgAkECcRshBCACQQNLIAJBAXYhAg0ACwtEAAAAAAAA8D8gBKMgBCABQQBIGwtyAQF/AkACQAJAAkAgAC0AHA4EAAMDAQMLIAAoAgAiAUUNAiABIAEoAgAiAUEBazYCACABQQFGDQEMAgsgAEEUahC8KiAAKAIMIgFFDQEgASABKAIAIgFBAWs2AgAgAUEBRw0BIABBDGohAAsgABD4IwsLhwEBAn8jAEHQAmsiAyQAIANBCGoiBCAAEJUaIAMgASACEPooIANBpAFqIgAgAygCACADKAIEEI81IARB4ABqEN47IARB6ABqIABBCGooAgA2AgAgBCAAKQIANwJgIANBuAFqIARBmAH8CgAAIANBADYCsAEgA0GwAWoQ0SlBCGogA0HQAmokAAtzAQN/IwBBIGsiAiQAIAEoAgAiAygCCCIEIAEoAgQiAUsEQCACQQA2AhggAkEBNgIMIAJBnKHDADYCCCACQgQ3AhAgAkEIakG8oMMAEO8sAAsgACABNgIMIAAgBDYCCCAAIAMpAgBCIIk3AgAgAkEgaiQAC1sBAX8CQAJAAkAgAC0AIA4EAQICAAILIAAtABxBA0YEQCAAQRBqELwqCyAAKAIIIgEgASgCAEEBajYCAAsgACgCACIBIAEoAgBBAWsiATYCACABDQAgABDUIgsLZAEFfyABKAIIIQMgASgCBCEEQQAhAQNAAkAgASADRgRAIAQhAgwBCyABIARqIAFBAWohAS0AACIFQSBrIQZBACECIAVBCUYgBkH/AXFB3wBJcg0BCwsgACADNgIEIAAgAjYCAAvkAQEHfyMAQRBrIgMkAAJ/IAEoAghFBEAgASgCBCECIAEoAgAMAQsgA0EEaiECIAEoAgAhByABKAIEIQQjAEEQayIBJAAgAUEEaiAEQQBBAUECEKAYIAEoAgghBQJAIAEoAgRBAUcEQCABKAIMIQYgBEEBdCIIBEAgBiAHIAj8CgAACyACIAQ2AgggAiAGNgIEIAIgBTYCACABQRBqJAAMAQsgBSABKAIMQeCtzAAQ/S8ACyADKAIMIQIgAygCBCEEIAMoAggLIQEgACAENgIIIAAgAjYCBCAAIAE2AgAgA0EQaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBFG4hAyACIARHBEADQCACEOkrIAJBFGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQRQQ4B4gAUEQaiQAC2gBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtBDG4hAyACIARHBEADQCACEIUwIAJBDGohAiADQQFrIgMNAAsLIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEEQQwQ4B4gAUEQaiQAC2sBBH8jAEEQayIBJAAgACgCDCIEIAAoAgQiAmtByABuIQMgAiAERwRAA0AgAhDCICACQcgAaiECIANBAWsiAw0ACwsgASAAKAIANgIMIAEgACgCCDYCCCABQQhqQQRByAAQ4B4gAUEQaiQAC3ABAn8jAEEQayICJAAgAkEEaiABQQBBAUEBEKAYIAIoAgghASACKAIEQQFGBEAgASACKAIMQfi1zgAQ/S8ACyACKAIMIQMgAEEANgIQIAAgAzYCDCAAIAE2AgggAEEAOgAUIABCADcDACACQRBqJAALdAEBfyAAQgA3AwAgAEIANwMgAkAgACgCCEGAgICAeEYNACAAKAIQIgFFDQAgAUEDdCIBRQ0AIAAoAgxBACAB/AsACwJAIAAoAhRBgICAgHhGDQAgACgCHCIBRQ0AIAFBA3QiAUUNACAAKAIYQQAgAfwLAAsLtQIBBX8gACgCDCIDIAAoAgAiAkYEQCAAKAIAIQMjAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQYgBELcRIAIoAggiBEGBgICAeEcEQCAEIAIoAgxBqIPPABD9LwALIAJBEGokAAJAIAAoAggiBCADIAAoAgwiBWtNDQAgAyAEayICIAUgAmsiBUsgACgCACIGIANrIAVPcUUEQCAGIAJrIQMgAkGIAWwiAgRAIAAoAgQiBSADQYgBbGogBSAEQYgBbGogAvwKAAALIAAgAzYCCAwBCyAFQYgBbCICRQ0AIAAoAgQiBCADQYgBbGogBCAC/AoAAAsgACgCACECIAAoAgwhAwsgACADQQFqNgIMIAAoAgQgACgCCCADaiIAIAJBACAAIAJPG2tBiAFsaiABQYgB/AoAAAuHBAEKfyMAQSBrIgQkACAAAn8gAUUEQCAEQQA2AhwgBEKAgICAwAA3AhQgBCAEQRRqQYyHzgAQmSEgBCgCBCEBIAQoAgAMAQsjAEEwayIFJAAgBUEANgIsIAVCATcCJCAFQoCAgIDgs/L//gA3AhwgBUEQaiEJIAVBHGohByMAQSBrIgMkACADQRRqIAFBAEEEQRQQoBggAygCGCECIAMoAhRBAUYEQCACIAMoAhxBxJ7QABD9LwALIANBEGoiC0EANgIAIAMgAygCHDYCDCADIAI2AgggA0EIaiIIKAIAIAgoAggiAmsgAUkEQCAIIAIgAUEEQRQQ0CggCCgCCCECCyAIKAIEIAJBFGxqIQYCQAJAIAFBAk8EQCABQQFrIQoDQCAGIAcpAgA3AgAgBkEQaiAHQRBqKAIANgIAIAZBCGogB0EIaikCADcCACAGQRRqIQYgCkEBayIKDQALIAEgAmpBAWshAgwBCyABRQ0BCyAGIAcpAgA3AgAgBkEQaiAHQRBqKAIANgIAIAZBCGogB0EIaikCADcCACACQQFqIQILIAggAjYCCCAJQQhqIAsoAgA2AgAgCSADKQIINwIAIANBIGokACAFQQhqIAlBzILOABCZISAEQQhqIAUpAwg3AwAgBUEwaiQAIAQoAgwhASAEKAIICzYCACAAIAE2AgQgBEEgaiQAC3MCAX8CfiMAQSBrIgIkACABKQPoASIDIAFBGEH4ASABKAIQG2opAwAiBIRCAFMEQCACQQA2AhggAkEBNgIMIAJBgPrPADYCCCACQgQ3AhAgAkEIakGI+s8AEO8sAAsgACADNwMIIAAgBDcDACACQSBqJAALVQEBf0EMQQVBICABZ2siBEEhIAJnayICIAIgBEsbIgJBHyADIAFBAWtnamsiASAAQQsgABsiACAAIAFLGyIAIAAgAkkbIgAgAEEFTRsiACAAQQxPGwtoAQF/AkACQAJAAkAgAkH/H0tBAkEBIAJBH0sbaiIDQQJrDgIBAgALIAAgAkEDdEEBcjoAAAwCCyAAIAJBBHRBBXI7AAAMAQsgACACQQR0QQ1yNgAACyAAIANqIAEtAAA6AAAgA0EBagtwAQF/IwBBIGsiAiQAIAJBADYCBCABQQNNBEAgAkEANgIYIAJBATYCDCACQdCY0gA2AgggAkIENwIQIAJBCGpBzJ3WABDvLAALIAJBBGpBBCAAQQRB3J3WABDVLCACKAIEIAJBIGokAEG9z9bxAWytC3IBBH8CQAJAIAEoAggiAiABKAIEIgNNBEAgAiABKAIAIAJqIgQvAAAiBWoiASACSQ0BIAEgA0sNAiAAIAU2AgQgACAENgIADwsgAiADQZyC/wAQrzsACyACIAFB3IL/ABCxOwALIAEgA0Hcgv8AELA7AAuFAgEEfyMAQRBrIgMkACABKAIQGiMAQRBrIgQkAAJAIAEoAgAiAiABKAIERwRAIAEgAkEEajYCACACKAIAIQUCQCADAn4gASgCCCgCACICBEAgBSACKAIQTw0CQgAgAigCBCACKAIMIAVqIgJBA3ZqLQAAIAJBB3F2QQFxRQ0BGgsgBEEIaiABKAIMIAUQoBsgBCkDCAs3AgQgA0EBNgIADAILQYyyggFBIEGssoIBEJ8pAAsgA0ECNgIACyAEQRBqJAAgAAJ/QQAgAygCACIBQQJGDQAaQQAgAUEBcUUNABogAygCBCEBIAAgAygCCDYCCCAAIAE2AgRBAQs2AgAgA0EQaiQAC6gDAQV/IwBBEGsiBSQAIAEoAhAhAiMAQSBrIgQkAAJAAkACQCAFAn4CQCABKAIAIgMgASgCBEcEQCABIANBBGo2AgAgAygCACIDQQBIBEAgBEEUakEUQQBBAUEBEKAYIAQoAhghAyAEKAIUQQFHDQIgAyAEKAIcQbSzggEQ/S8ACyABKAIIKAIAIgIEQCADIAIoAhBPDQVBASEGQgAgAigCBCACKAIMIANqIgJBA3ZqLQAAIAJBB3F2QQFxRQ0DGgsgBEEIaiABKAIMIAMQoBtBASEGIAQpAwgMAgsgBUECNgIADAILIAQoAhwiAUEQakHEtoIBKAAANgAAIAFBCGpBvLaCASkAADcAACABQbS2ggEpAAA3AAAgAhDlECACQhQ3AgwgAiABNgIIIAIgAzYCBCACQYaAgIB4NgIAQgALNwIEIAUgBjYCAAsgBEEgaiQADAELQYyyggFBIEGssoIBEJ8pAAsgAAJ/QQAgBSgCACIBQQJGDQAaQQAgAUEBcUUNABogBSgCBCEBIAAgBSgCCDYCCCAAIAE2AgRBAQs2AgAgBUEQaiQAC7cDAgV/AX4jAEEQayIFJAAgASgCECECIwBBIGsiAyQAAkACQAJAIAUCfgJAIAEoAgAiBiABKAIERwRAIAEgBkEIajYCACAGKQMAIgdCgICAgBBaBEBBACEGIANBFGpBFEEAQQFBARCgGCADKAIYIQQgAygCFEEBRw0CIAQgAygCHEG0s4IBEP0vAAsgB6chAiABKAIIKAIAIgQEQCAEKAIQIAJNDQVBASEGQgAgBCgCBCAEKAIMIAJqIgRBA3ZqLQAAIARBB3F2QQFxRQ0DGgsgA0EIaiABKAIMIAIQoBtBASEGIAMpAwgMAgsgBUECNgIADAILIAMoAhwiAUEQakHEtoIBKAAANgAAIAFBCGpBvLaCASkAADcAACABQbS2ggEpAAA3AAAgAhDlECACQhQ3AgwgAiABNgIIIAIgBDYCBCACQYaAgIB4NgIAQgALNwIEIAUgBjYCAAsgA0EgaiQADAELQYyyggFBIEGssoIBEJ8pAAsgAAJ/QQAgBSgCACIBQQJGDQAaQQAgAUEBcUUNABogBSgCBCEBIAAgBSgCCDYCCCAAIAE2AgRBAQs2AgAgBUEQaiQAC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxCiGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHg7YQBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKMZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQbjuhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtnAQJ/IwBB0ABrIgQkACAEQQhqIgUgASACIAMQpBlB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVByAD8CgAAIABBkO+EATYCBCAAIAE2AgAgBEHQAGokAA8LQQRB0AAQoz0AC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxClGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHo74QBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKUZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQcDwhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtnAQJ/IwBB0ABrIgQkACAEQQhqIgUgASACIAMQoxlB0ABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVByAD8CgAAIABBmPGEATYCBCAAIAE2AgAgBEHQAGokAA8LQQRB0AAQoz0AC2cBAn8jAEHQAGsiBCQAIARBCGoiBSABIAIgAxCiGUHQAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUHIAPwKAAAgAEHw8YQBNgIEIAAgATYCACAEQdAAaiQADwtBBEHQABCjPQALZwECfyMAQdAAayIEJAAgBEEIaiIFIAEgAiADEKQZQdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQcgA/AoAACAAQcjyhAE2AgQgACABNgIAIARB0ABqJAAPC0EEQdAAEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABBhPmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABB3PmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtiAQJ/IwBBMGsiBCQAIARBCGoiBSABIAIgAxDKGUEwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQSj8CgAAIABBtPqEATYCBCAAIAE2AgAgBEEwaiQADwtBBEEwEKM9AAtpAgF/AX4CQCACQf8BcSICQSZLDQAgACACQQR0IgJBoIeFAWopAwBUIAEgAkGoh4UBaikDACIEUyABIARRGw0AIAAgAkGwgoUBaikDAFggASACQbiChQFqKQMAIgBXIAAgAVEbIQMLIAMLowIBA38jAEFAaiIGJAAgBkEEaiEFIwBBMGsiBCQAIAQgAUEYaiACIAMQtiYgBEEMaiABEL4VAkAgASgCJARAIARBGGogAUEkaiACIAMQsR8MAQsgBEEANgIYCyAFQpq06NChw4aNGjcCDCAFIAQpAgA3AhggBSAEKQIMNwIAIAUgBCkCGDcCJCAFQRRqQZq06NABNgIAIAVBIGogBEEIaigCADYCACAFQQhqIARBFGooAgA2AgAgBUEsaiAEQSBqKQIANwIAIAVBNGogBEEoaikCADcCACAEQTBqJABBxABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBPPwKAAAgAEHMy4UBNgIEIAAgATYCACAGQUBrJAAPC0EEQcQAEKM9AAujAgEDfyMAQUBqIgYkACAGQQRqIQUjAEEwayIEJAAgBCABQRhqIAIgAxC2JiAEQQxqIAEQvhUCQCABKAIkBEAgBEEYaiABQSRqIAIgAxCxHwwBCyAEQQA2AhgLIAVCl67cuPHixYsXNwIMIAUgBCkCADcCGCAFIAQpAgw3AgAgBSAEKQIYNwIkIAVBFGpBl67cuAE2AgAgBUEgaiAEQQhqKAIANgIAIAVBCGogBEEUaigCADYCACAFQSxqIARBIGopAgA3AgAgBUE0aiAEQShqKQIANwIAIARBMGokAEHEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUE8/AoAACAAQaTMhQE2AgQgACABNgIAIAZBQGskAA8LQQRBxAAQoz0AC6sCAQV/IwBBQGoiByQAIAdBCGohBCMAQTBrIgUkACAFQQxqIAEQ1AYCQCABKAIgBEAgBUEYaiABQSBqIAIgAxCxHwwBCyAFQQA2AhgLIAEoAgwiCCAIKAIAIgZBAWo2AgAgBkEASARAAAsgASgCECEGIARBFGogAUEUaiACIANBAWoiAUF/IAEbELcmIAQgBjYCECAEIAg2AgwgBEEIaiAFQRRqKAIANgIAIAQgBSkCDDcCACAEIAUpAhg3AiAgBEEoaiAFQSBqKQIANwIAIARBMGogBUEoaikCADcCACAFQTBqJABBwABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBOPwKAAAgAEGg2YUBNgIEIAAgATYCACAHQUBrJAAPC0EEQcAAEKM9AAurAgEFfyMAQUBqIgckACAHQQhqIQQjAEEwayIFJAAgBUEMaiABENQGAkAgASgCIARAIAVBGGogAUEgaiACIAMQsR8MAQsgBUEANgIYCyABKAIMIgggCCgCACIGQQFqNgIAIAZBAEgEQAALIAEoAhAhBiAEQRRqIAFBFGogAiADQQFqIgFBfyABGxC4JiAEIAY2AhAgBCAINgIMIARBCGogBUEUaigCADYCACAEIAUpAgw3AgAgBCAFKQIYNwIgIARBKGogBUEgaikCADcCACAEQTBqIAVBKGopAgA3AgAgBUEwaiQAQcAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTj8CgAAIABB+NmFATYCBCAAIAE2AgAgB0FAayQADwtBBEHAABCjPQALyAMBC38jAEHwAGsiCCQAIAhBDGohBSMAQfAAayIEJAAgBEEMaiABQTRqENQGAkAgASgCTARAIARBGGogAUHMAGogAiADELEfDAELIARBADYCGAsgASgCGCENIARB5ABqIAFBDGoQ1AYCQAJAIAEoAhwiBwRAIAcgBygCACIGQQFqNgIAIAZBAEgNASABKAIsIQkgASgCKCEKIAEoAiQhCyABKAIgIQwgASgCMCEGCyAEQTBqIg4gARC8FSAEQcQAaiAEQewAaigCADYCACAEIA02AkggBCAGNgJgIAQgCTYCXCAEIAo2AlggBCALNgJUIAQgDDYCUCAEIAc2AkwgBCAEKQJkNwI8IAVBQGsgAUFAayACIANBAWoiAUF/IAEbELgmIAVBPGogBEEUaigCADYCACAFIAQpAgw3AjQgBSAEKQIYNwJMIAVB1ABqIARBIGopAgA3AgAgBUHcAGogBEEoaikCADcCACAFIA5BNPwKAAAgBEHwAGokAAwBCwALQewAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQeQA/AoAACAAQbThhQE2AgQgACABNgIAIAhB8ABqJAAPC0EEQewAEKM9AAvwAQEDfyMAQTBrIgYkACAGQQRqIQUjAEEwayIEJAAgBEEEaiABIAIgAxClGgJAIAEoAhQEQCAEQRhqIAFBFGogAiADELEfDAELIARBADYCGAsgBSAEKQIENwIAIAUgBCkCGDcCFCAFQRBqIARBFGooAgA2AgAgBUEIaiAEQQxqKQIANwIAIAVBHGogBEEgaikCADcCACAFQSRqIARBKGopAgA3AgAgBEEwaiQAQTRBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBLPwKAAAgAEHc74UBNgIEIAAgATYCACAGQTBqJAAPC0EEQTQQoz0AC2IBAn8jAEFAaiIEJAAgBEEMaiIFIAEgAiADEL0QQTxBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBNPwKAAAgAEG0+YUBNgIEIAAgATYCACAEQUBrJAAPC0EEQTwQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC4JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARCmLDgwIGDhowYNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGYsODAATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQdiQhgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC3JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARCmbLkyJGjxowZNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGZsuTIATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQbCRhgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC4JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARClKjQoMGChYoUNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGUqNCgATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQYiShgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC9ECAQZ/IwBBQGoiCCQAIAhBBGohBCMAQTBrIgUkACAFQQxqIAFBDGogAiADQQFqIgZBfyAGGxC3JiABKAIYIgYgBigCACIHQQFqNgIAAkAgB0EATgRAIAEoAiAhByABKAIcIQkCQCABKAIkBEAgBUEYaiABQSRqIAIgAxCxHwwBCyAFQQA2AhgLIARClqzYsOHChYsWNwIAIAQgBSkCDDcCDCAEIAc2AiAgBCAJNgIcIAQgBjYCGCAEIAUpAhg3AiQgBEEIakGWrNiwATYCACAEQRRqIAVBFGooAgA2AgAgBEEsaiAFQSBqKQIANwIAIARBNGogBUEoaikCADcCACAFQTBqJAAMAQsAC0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEE8/AoAACAAQeCShgE2AgQgACABNgIAIAhBQGskAA8LQQRBxAAQoz0AC7UCAQV/IwBB0ABrIgckACAHQQxqIQQjAEEwayIFJAAgBUEMaiABENgGAkAgASgCLARAIAVBGGogAUEsaiACIAMQsR8MAQsgBUEANgIYCyABKAIMIgggCCgCACIGQQFqNgIAIAZBAEgEQAALIAEoAhAhBiAEQRRqIAFBFGogAiADELcmIARBIGogAUEgaiACIAMQtyYgBCAGNgIQIAQgCDYCDCAEQQhqIAVBFGooAgA2AgAgBCAFKQIMNwIAIAQgBSkCGDcCLCAEQTRqIAVBIGopAgA3AgAgBEE8aiAFQShqKQIANwIAIAVBMGokAEHMAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEHEAPwKAAAgAEG0lYYBNgIEIAAgATYCACAHQdAAaiQADwtBBEHMABCjPQALtQIBBX8jAEHQAGsiByQAIAdBDGohBCMAQTBrIgUkACAFQQxqIAEQ2AYCQCABKAIsBEAgBUEYaiABQSxqIAIgAxCxHwwBCyAFQQA2AhgLIAEoAgwiCCAIKAIAIgZBAWo2AgAgBkEASARAAAsgASgCECEGIARBFGogAUEUaiACIAMQuCYgBEEgaiABQSBqIAIgAxC4JiAEIAY2AhAgBCAINgIMIARBCGogBUEUaigCADYCACAEIAUpAgw3AgAgBCAFKQIYNwIsIARBNGogBUEgaikCADcCACAEQTxqIAVBKGopAgA3AgAgBUEwaiQAQcwAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQcQA/AoAACAAQYyWhgE2AgQgACABNgIAIAdB0ABqJAAPC0EEQcwAEKM9AAvUAgEEfyMAQUBqIgckACAHQQhqIQUjAEEwayIEJAACQCABKAIwQX8gAiADaiIGIAIgBksbTwRAIAEoAjQhBiAEQQxqIAEQ2QYCQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAVBDGogAUEMaiACIAZsIAMgBmwQ5hUgBSAGNgI0IAUgAzYCMCAFQQhqIARBFGooAgA2AgAgBSAEKQIMNwIAIAUgBCkCGDcCGCAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAAwBCyAEQQA2AiggBEEBNgIcIARB7KCGATYCGCAEQgQ3AiAgBEEYakH0oIYBEO8sAAtBwABBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBOPwKAAAgAEH0ooYBNgIEIAAgATYCACAHQUBrJAAPC0EEQcAAEKM9AAuEAwEGfyMAQUBqIggkACAIQQxqIQUjAEEwayIEJAACQCABKAIwQX8gAiADaiIGIAIgBksbTwRAIAEoAiwhBiAEQQxqIAEQ2QYgBCABKAIMIAEoAhAiBygCCEEBa0F4cWpBCGogAiAGbCADIAZsIAcoAiARBQAgBCgCBCEHIAQoAgAhCQJAIAEoAhQEQCAEQRhqIAFBFGogAiADELEfDAELIARBADYCGAsgBSAEKQIMNwIAIAUgCTYCDCAFIAQpAhg3AhQgBSADNgIwIAUgBjYCLCAFIAc2AhAgBUEIaiAEQRRqKAIANgIAIAVBHGogBEEgaikCADcCACAFQSRqIARBKGopAgA3AgAgBEEwaiQADAELIARBADYCKCAEQQE2AhwgBEGUpoYBNgIYIARCBDcCICAEQRhqQZymhgEQ7ywAC0E8QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTT8CgAAIABBrKeGATYCBCAAIAE2AgAgCEFAayQADwtBBEE8EKM9AAt3AQR/IwBBEGsiAiQAIAJBBGogASgCABCcPiIEQQBBAUEBEKAYIAIoAgghAyACKAIEQQFGBEAgAyACKAIMQeSriAEQ/S8ACyABIAIoAgwiBSABKAIAEJw+EIMkIAAgBDYCCCAAIAU2AgQgACADNgIAIAJBEGokAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEBQQEQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwAL6gEBA38jAEFAaiICJAACQAJAIAFFBEAgAkEIaiEEIwBB0ABrIgEkAAJAAkAgAARAIABBCGsiAygCAEEBRw0BIAFBEGogAEHAAPwKAAAgA0EANgIAAkAgA0F/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIANByABBCBD4OgsgBCABQRhqQTj8CgAAIAFB0ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyAEENQlDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgggAQ0AIAJBCGoQ5yoLIAJBQGskAA8LEJg9AAuVAQEBfyMAQaABayICJAACQAJAIAFFBEAgAkEIaiIBIAAQlRogARDMLAwBCyAARQ0BIABBCGsiACAAKAIAQQFrIgE2AgAgAiAANgIIIAENACACQQhqKAIAIgBBEGoQzCwCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBqAFBCBD4OgsLIAJBoAFqJAAPCxCYPQALXwICfwF+IwBBwAJrIgIkACACQQhqIgMgABCVGiACKQOYASEEIAJBqAFqIANBjAH8CgAAIAIgBDcDuAIgAiABNgK0AiACQQA2AqABIAJBoAFqENEpQQhqIAJBwAJqJAALlwEBBH8CQAJAIAAoAgAiAUF/Rg0AIAEoAgAhAANAIABFDQEgAEEASA0CIAEgAEEBaiABKAIAIgIgACACRhs2AgAgACACRyACIQANAAsgASEECyAEDwsjAEEgayIAJAAgAEEBNgIEIABBmKuIATYCACAAQgE3AgwgAEKMm8OA8Cg3AxggACAAQRhqNgIIIABBpJvDABDvLAALZAEBfyMAQSBrIgIkAAJAAkAgAUUEQCACQQxqIgEgABCAHCABEJIgDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQ6hkLIAJBIGokAA8LEJg9AAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEECQQQQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALZgEDfyMAQRBrIgMkAAJAIAEoAgAiAiABKAIERyIERQ0AIAEgAkEBajYCACACLQAAIgJBJUcNACADQQhqIAEQqhkgAy0ACUElIAMtAAgbIQILIAAgAjoAASAAIAQ6AAAgA0EQaiQAC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQRBBBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQRQQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALZAEBfyMAQSBrIgIkAAJAAkAgAUUEQCACQQxqIgEgABCyFiABEOkrDAELIABFDQEgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0AIAJBDGoQzCMLIAJBIGokAA8LEJg9AAtpAQR/IAMEQCABKAIEIQUgASgCACEGA0AgBiACIAMgBigCCCIHIAMgB0kbIgQQlxogASAEIAVqIgU2AgQgB0UEQCAAQfjvzQApAwA3AgAPCyACIARqIQIgAyAEayIDDQALCyAAQQQ6AAALbQECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBBEGIFhD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtsAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQRAQ9BQgAygCCCIEQYGAgIB4Rw0BIAEoAggFIAQLNgIEIAAgASgCBDYCACADQRBqJAAPCyAEIAMoAgwgAhD9LwALbAECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBBEEgEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQRBCBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAttAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQYgREPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQJBIBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAttAQJ/IwBBEGsiAyQAAkAgACABKAIIIgQgASgCAEkEfyADQQhqIAEgBEEEQYgIEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2wBAn8jAEEQayIDJAACQCAAIAEoAggiBCABKAIASQR/IANBCGogASAEQQhBCBD0FCADKAIIIgRBgYCAgHhHDQEgASgCCAUgBAs2AgQgACABKAIENgIAIANBEGokAA8LIAQgAygCDCACEP0vAAtyAQJ/AkAgACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFLBEAgBCgCBCABQQR0aiIAKAIARQ0BIAMoAgAgACgCBCAAKAIIEM0CDwsgASAAQZSQzgAQwyEAC0Hkh84AQSBBhIjOABDLJAALbQIBfgF/AkAgACkDACIBQgNRDQAgAUICUQRAIABBFGogACgCDCAAKAIQIAAoAggoAhARAQAPCyAAKAIQIgIEQCAAQRxqIAAoAhQgACgCGCACKAIQEQEACyAAKAIwIgBFDQAgAEGAIEEEEPg6CwtnAQF/IwBBIGsiAyQAIANBCGogASgCDCACIAEoAhAoAhQRAQAgAygCDCEBIAMoAggiAkEIRwRAIAAgAykDEDcDCCAAQRBqIANBGGopAwA3AwALIAAgAjYCACAAIAE2AgQgA0EgaiQAC2cBAX8jAEEgayIDJAAgA0EIaiABKAIYIAIgASgCHCgCFBEBACADKAIMIQEgAygCCCICQQhHBEAgACADKQMQNwMIIABBEGogA0EYaikDADcDAAsgACACNgIAIAAgATYCBCADQSBqJAALdAECfyMAQSBrIgIkACABLQAAIQMgAUEBOgAAIAIgAzoAByADQQFGBEAgAkIANwIUIAJCgYCAgMAANwIMIAJB4KHQADYCCCACQQdqQcy0wgAgAkEIakHoodAAEK0rAAsgACABNgIEIABBADYCACACQSBqJAALYgEBfyACQQEgAyAEIAUQ6CMgBCAFIAMoAgBBB2oiBkEDdiAAIAEgAhCJHyADIAZBeHEgAkEDdGoiADYCACAFIABBA3YiAEsEQCAAIARqQQA6AAAPCyAAIAVB+I3SABDDIQALbAECfyMAQRBrIgMkAAJAIAAgASgCCCIEIAEoAgBJBH8gA0EIaiABIARBAkECEPQUIAMoAggiBEGBgICAeEcNASABKAIIBSAECzYCBCAAIAEoAgQ2AgAgA0EQaiQADwsgBCADKAIMIAIQ/S8AC2UBAX4gASADSQRAIAIgAUECdGoiATMBACEEIAAtABgiAiABLQACaiIBQf8BcUHAAE8EQCAAIAQgARDwEA8LIAAgAToAGCAAIAApAxAgBCACrYaENwMQDwsgASADQezc+wAQwyEAC2sBAn8CQAJAIAIgA08EQCABIANqKAAAIgQgA0EEaiIFaiIDIARJDQEgAiADSQ0CIAAgBDYCBCAAIAEgBWo2AgAPCyADIAJBnIL/ABCvOwALIAUgA0Gsgv8AELE7AAsgAyACQayC/wAQsDsAC54BAQJ/AkACQAJAAkBBAiAAKAIAIgFB/////wdqIAFBgICAgHhNG0EBaw4DAAECAwsgACgCCCIARQ0CIAAQrSEgAEEQQQQQ+DoPCyABQYCAgIB4Rg0BIAAoAggiAgRAIAAoAgQhAQNAIAEQ0RogAUEQaiEBIAJBAWsiAg0ACwsgABDuOw8LIAAoAggiAEUNACAAEK0hIABBEEEEEPg6CwvICAIUfwR+IwBBIGsiBiQAIAEoAhQhAyAGIAFBCGo2AhggBiADNgIUIAYgBkEfajYCECAGQRBqIQIjAEHgAGsiAyQAIAZBBGoiDSABKAIAIgQgASgCBEYEf0EABSACKAIIIQwgAigCBCELIAEgBEEIajYCACADIAQtAAA6ABcgDCgCACEBIwBBQGoiBCQAIAQgA0EXajYCECAEIAE2AgwgBEEUaiISIAEQ9zQgBEEsaiEOIAEoAhQhByAEQRBqIQ8gBEEMaiEQIwBBMGsiASQAQcAAIQgCQAJAAkAgB0EGdiIFIAdBP3EiEUEAR2oiAkEDdCIJQcD///8DcUFAayAJIAJBB3EbIglBwAAQ0TQEQCAJBEAgCUHAABCtNiIIRQ0CC0EAIQIgB0HAAE8EQCAFrSEZIA8oAgAhEyAQKAIAIRQDQCAUKAIQIApqIQUgEy0AACEVQgAhFkIAIRcDQCAFLQAAIBVGrSAWhiAXhCEXIAVBAWohBSAWQgF8IhZCwABSDQALIAIgCGogFzcDACAKQUBrIQogAkEIaiECIBhCAXwiGCAZUg0ACwsgEQRAIBAoAgAoAhAgB0FAcWohBSARrSEYQgAhFiAPKAIALQAAIQpCACEXA0AgBS0AACAKRq0gFoYgF4QhFyAFQQFqIQUgGCAWQgF8IhZSDQALIAIgCGogFzcAACACQQhqIQILIAEgCTYCLCABQoCAgICACDcCJCABIAg2AhwgASAHQQN2IAdBB3FBAEdqIgUgAiACIAVLGyIFNgIgIAFBCGogAUEcahDXOyABKAIIIQhBHEEEEK02IgJFDQIgAkKBgICAEDcCACACIAEpAhw3AgggAkEQaiABQSRqKQIANwIAIAJBGGogAUEsaigCADYCACABIAU2AhggASAINgIUIAEgAjYCECAOIAFBEGpBACAHEPIVIAFBMGokAAwDC0Hw9IMBQSkgAUEcakGs9YMBQZz1gwEQ1R4AC0HAACAJEKM9AAtBBEEcEKM9AAsgA0EYaiIBIA4gEhDUGCAEQUBrJAAgA0HMAGogDCgCBEGEt4IBIAEQwhAgAygCVCECIAMoAlAhAQJAIAMoAkwiBEGTgICAeEcEQCADIAMpAlg3AgwgAyACNgIIIAMgATYCBCADIAQ2AgAMAQsgAyACNgJIIAMgATYCRCADIAwoAgggAy0AFxDZKEHks4IBIANBxABqIgIQgx4QiQEgASABKAIAIgFBAWs2AgAgAUEBRw0AIAIQuyMLIANBGGoQzSYgAygCCCECIAMoAgQhASADKAIAIgRBk4CAgHhHBEAgAykCDCEWIAsQ5RAgCyAWNwIMIAsgAjYCCCALIAE2AgQgCyAENgIAQQAhAQsgDSACNgIIIA0gATYCBEEBCzYCACADQeAAaiQAIAYoAgQhASAGKAIIIQMgACAGKAIMNgIEIAAgA0EAIAEbNgIAIAZBIGokAAuiAgIGfwF+IwBBIGsiAiQAIAEoAhAhAyACIAFBCGo2AhggAiADNgIUIAIgAkEfajYCECACQRBqIQQjAEEgayIDJAAgAkEEaiIHIAEoAgAiBSABKAIERgR/QQAFIAQoAgghBiAEKAIEIQQgASAFQQhqNgIAIANBDGogBigCACAFLQAAENkoQeSzggEgBigCBBCiASADKAIUIQUgAygCECEBIAMoAgwiBkGTgICAeEcEQCADKQIYIQggBBDlECAEIAg3AgwgBCAFNgIIIAQgATYCBCAEIAY2AgBBACEBCyAHIAU2AgggByABNgIEQQELNgIAIANBIGokACACKAIEIQEgAigCCCEDIAAgAigCDDYCBCAAIANBACABGzYCACACQSBqJAALaQEBfyAAQQxqEL4MIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCyAAELMmIABBBEEIEOAeC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHYBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBmwY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALbAEBfyMAQTBrIgIkACACQQM2AgwgAkHE84QBNgIIIAJCAjcCFCACQfIENgIsIAIgAEE8ajYCKCACQcwGNgIkIAIgAEEMajYCICACIAJBIGo2AhAgASgCACABKAIEIAJBCGoQywogAkEwaiQAC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHTBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBlQY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALbAEBfyMAQTBrIgIkACACQQM2AgwgAkHE84QBNgIIIAJCAjcCFCACQfIENgIsIAIgAEE8ajYCKCACQacGNgIkIAIgAEEMajYCICACIAJBIGo2AhAgASgCACABKAIEIAJBCGoQywogAkEwaiQAC2wBAX8jAEEwayICJAAgAkEDNgIMIAJBxPOEATYCCCACQgI3AhQgAkHyBDYCLCACIABBPGo2AiggAkHdBjYCJCACIABBDGo2AiAgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEMsKIAJBMGokAAtsAQF/IwBBMGsiAiQAIAJBAzYCDCACQcTzhAE2AgggAkICNwIUIAJB8gQ2AiwgAiAAQTxqNgIoIAJBogY2AiQgAiAAQQxqNgIgIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahDLCiACQTBqJAALaQEBfyAAQQxqEMYMIAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+x4LAkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCyAAELMmIABBBEEIEOAeC2UBA38CQCAAKAIMIgIgAUECdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEBdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEDdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEEdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38CQCAAKAIMIgIgAUEFdCIEaiIBIAJNDQAgACgCBCIDIAFJBEAgACADQQF0IgIgARDdKiIDIAIgA0sbEOgZIAAoAgwhAgsgBEUNACAAKAIIIAJqQQAgBPwLAAsgACABNgIMC2UBA38jAEEQayIDJAAgA0EIakEEIAEQ8x8gAygCCCEBIAMoAgwiBAR/IAQgARCtNgUgAQsiBUUEQCABIAQQoz0ACyAFQoGAgIAQNwIAIAAgAigCADYCBCAAIAU2AgAgA0EQaiQAC2UBAn8jAEEQayIEJAAgBEEIaiABIAIQ8x8gBCgCCCEBIAQoAgwiBQR/IAUgARCtNgUgAQsiAkUEQCABIAUQoz0ACyACQoGAgIAQNwIAIAAgAygCADYCBCAAIAI2AgAgBEEQaiQACxIAIwBBMGsiACQAIABBMGokAAtqAgF/AX4jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQM2AgwgA0HQxIkBNgIIIANCAjcCFCADQoCAgICwByIEIANBBGqthDcDKCADIAQgA62ENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2oCAX8BfiMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCADQdzviQE2AgggA0ICNwIUIANCgICAgLAHIgQgA62ENwMoIAMgBCADQQRqrYQ3AyAgAyADQSBqNgIQIANBCGogAhDvLAALbgEBfyAALQAEIQEgAC0ABQRAIAACf0EBIAFBAXENABogACgCACIBLQAKQYABcUUEQCABKAIAQdfxiQFBAiABKAIEKAIMEQYADAELIAEoAgBB1vGJAUEBIAEoAgQoAgwRBgALIgE6AAQLIAFBAXELcAEEfwJAAn8CQAJAIAAtAFAOBAADAwEDCyAAKAIkIgFFDQJBKCECQTAhA0EsDAELIABBEGoQvCogACgCQCIBRQ0BQcQAIQJBzAAhA0HIAAshBCAAIANqIAAgAmooAgAgACAEaigCACABKAIQEQEACwtvAQF/IwBBMGsiASQAIAAoAgxBgYCAgHhHBEAgASAAQQxqNgIMIAFBAjYCFCABQZiTwwA2AhAgAUIBNwIcIAFBgwE2AiwgASABQShqNgIYIAEgAUEMajYCKCABQRBqQaiTwwAQ7ywACyABQTBqJAALaAEBfyAAKAIAIgBBCGoQhjAgACgCGCIBBEAgACgCHCABKAIMEQMACyAAKAIkIgEEQCAAKAIoIAEoAgwRAwALAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQTRBBBD4OgsLdAEBfwJAAkACQCAALQCABw4EAAICAQILIAAoAtABIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQdABahCdJwsgABD4Lg8LIABBsANqEM0kIAAoAqgDIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQagDahCdJwsLYgECfwJAIAAEQCAAQQhrIgEoAgBBAUcNASAAKAIEIAFBADYCAAJAIAFBf0YNACAAQQRrIgAgACgCAEEBayIANgIAIAANACABQRBBBBD4OgsPCxCYPQALQafZwwBBPxCXPQALbQECfyMAQRBrIgIkAAJAIAEoAgBFBEAgAkEIaiABQQRqENw7IAIoAgggAigCDBCTPiEBDAELIAEoAgQgASgCCBCVPSIDEPQ6IQEgA0GEAUkNACADEPIfCyAAIAE2AgQgAEEANgIAIAJBEGokAAvDAQECfyMAQRBrIgIkAAJAAkAgAUUEQAJ/AkAgAARAIABBCGsiASgCAEEBRw0BIAAoAgQgAUEANgIAAkAgAUF/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIAFBEEEEEPg6CwwCCxCYPQALQbDEzABBPxCXPQALIgAQiDUgAEEwQQgQ+DoMAQsgAEUNASACIABBCGsiADYCDCAAIAAoAgBBAWsiADYCACAADQAgAkEMahCnKQsgAkEQaiQADwsQmD0AC2IBAn8CQCAABEAgAEEIayIBKAIAQQFHDQEgACgCBCABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgAUEQQQQQ+DoLDwsQmD0AC0HMyMwAQT8Qlz0AC24BAX8gACkDAEIFUgRAIAAoApgCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQZgCahDZIQsgAEGQAmoQvCogAEHQAGoQkyogABD9LiAAKALwAUGAgICAeEcEQCAAQfABahDZLwsgAEGgAWoQwRoLC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDZLyAAQcACahCyLCAAQegCahC0MCAAEM0hC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDaLyAAQcACahCyLCAAQegCahC0MCAAELsfC24BAX8gAEGgA2oQlAwgAEGAA2oQvCogAEGIA2oQtDAgAEGUA2oQtDAgACgC9AIiASABKAIAIgFBAWs2AgAgAUEBRgRAIABB9AJqENkhCyAAQagCahDbLyAAQcACahCyLCAAQegCahC0MCAAELwfC2sBAX9BIEEIEK02IgJFBEBBCEEgEKM9AAsgAEGAv80ANgIIIAAgAjYCBCAAQQU2AgAgAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAC3QBAX8CQCAAKAJwRQ0AIAAoAnQiAUUNACAAQYABaiAAKAJ4IAAoAnwgASgCEBEBAAsCQCAAKAKEAUUNACAAKAKIASIBRQ0AIABBlAFqIAAoAowBIAAoApABIAEoAhARAQALIABBmAFqEIUwIABBpAFqEIUwC28BAX8jAEEwayIBJAAgACgCDEGBgICAeEcEQCABIABBDGo2AgwgAUECNgIUIAFBvOjOADYCECABQgE3AhwgAUGDATYCLCABIAFBKGo2AhggASABQQxqNgIoIAFBEGpBzOjOABDvLAALIAFBMGokAAtzAQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCwOO13tL+pZUshSACKQMYQvXOqKjR/trMpH+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3QBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEELCjPf26svc0YR/hSACKQMYQuWT9Jj5r/joqH+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3MBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUBsiAzYCBCAAIAFBACADGzYCACACQSBqJAALYwECfwJAIAIEQCACQQF0IQIgACgCBCEEIAAoAgghAANAIAAgAS4BACIDTQ0CIAQgA0EDdGoiAyADKQMAQgF8NwMAIAFBAmohASACQQJrIgINAAsLDwsgAyAAQcD5zwAQwyEAC1oBAn8jAEEgayICJAAgAkEMaiIDIAFBAUEAEMYsIAIgADYCGCACIABBAWo2AhwgAyACQRhqQZjg0AAQ5BQaIAMgAkEcakGo4NAAEOQUGiADENsbIAJBIGokAAtlAQF/IAAoAgAiACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahCDIAsgAEEIaiIBENErIAEQ6DsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBHEEEEPg6Cwt6AQF/IwBBEGsiAiQAIAIgADYCDCABQfzr0ABBiezQAEEEIABBCGpBrOvQAEGN7NAAQQogAEEgakG869AAQZfs0ABBDiAAQSFqQczr0ABBpezQAEEMIABBFGpB3OvQAEGx7NAAQQIgAkEMakHs69AAENcVIAJBEGokAAtYACACIAFrIQICfyAFRQRAIAEgAiADIAQgBhCtEgwBCyABIAIgAyAEIAYQihILIgJBiH9NBH8gAkUEQEEADwsgASACaiAAayIAQQAgACAEQQFrSRsFIAILC3cBAn9BzI/8ACEDQSAhAgJAAkACQAJAIAAtAKABQQFrDgMAAQIDCyAAQaQBaiEDQbQKIQIMAgsgAEH0KmohA0G0CiECDAELIABBxNQAaiEDQdAEIQILIAEgAkkEQCADIAFBAnRqKAEADwsgASACQdyQ/AAQwyEAC3MBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEEKH+dva19H8mDyFIAIpAxhCtu/otfSlgr6Wf4WEUBsiAzYCBCAAIAFBACADGzYCACACQSBqJAALcwECfyMAQSBrIgIkACACQQhqIAFBPGoQuSYgAkEQaiACKAIIIgMgAigCDCgCDBEAACAAIANBACACKQMQQp/CvqLMv8igIYUgAikDGELWxZTGmP312PgAhYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAt0AQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBC47Di8bKTqs3WAIUgAikDGEKw3+Dy+LaU9Id/hYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAt0AQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCkJ6z7tm0jZLpAIUgAikDGEKI9KuB4LHF5MIAhYRQGyIDNgIEIAAgAUEAIAMbNgIAIAJBIGokAAtzAQJ/IwBBIGsiAiQAIAJBCGogAUE8ahC5JiACQRBqIAIoAggiAyACKAIMKAIMEQAAIAAgA0EAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3QBAn8jAEEgayICJAAgAkEIaiABQTxqELkmIAJBEGogAigCCCIDIAIoAgwoAgwRAAAgACADQQAgAikDEEK1w/6+jJyqpsMAhSACKQMYQpL7x5C+7Jj+o3+FhFAbIgM2AgQgACABQQAgAxs2AgAgAkEgaiQAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuOw4vGyk6rN1gCFIAIpAxhCsN/g8vi2lPSHf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQp/CvqLMv8igIYUgAikDGELWxZTGmP312PgAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCxfnL/5Gu4aXzAIUgAikDGELu9LKa/ZmulEKFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1+Meo1t3Ut75/hSACKQMYQqfy1Pyvr4CpZYWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvqYtvqSporDHIUgAikDGEKjwLrZ1ubhqiaFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1w/6+jJyqpsMAhSACKQMYQpL7x5C+7Jj+o3+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELkqcXy3YrhxjSFIAIpAxhCtcmJlamX+rcZhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCqPiJ3+794vcZhSACKQMYQoKIosHluO7+FoWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQrWospbEp++mTIUgAikDGEL384vm1Y6BzQKFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELcp4bNlJfJvZZ/hSACKQMYQoXw5oWQ2p/jDIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQoaB0JC4h5OjmX+FIAIpAxhCo9XjoNqy+597hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsy0ov2VhIuhZIUgAikDGEL+io38urDbmtwAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCyZCt59O+2ficf4UgAikDGELx8sqr5+fRxsIAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELy/Kme5Y+hnSuFIAIpAxhC2YuNupm+7e+vf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQo2j65PMtMaQ9wCFIAIpAxhC2avs9tngxfSMf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQofA7OjEzr/RyQCFIAIpAxhCvr+ev6/DpIL4AIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtHx98ycuun+ToUgAikDGELWwo+ZmLzyo/EAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC5LbKrM/B44XgAIUgAikDGELN0Z2bnfy4qLl/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC+/bY6vDijZ/GAIUgAikDGEKZhqW/+K+hjtIAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCmcTpt9SjhcVuhSACKQMYQpiWydPQ9J6WrX+FhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKLtaPljNen43SFIAIpAxhCsKP53sDxp9eEf4WEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpfRsJvd/7iVWYUgAikDGEL8orOPiOix2PYAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCpK/0+qipnZAthSACKQMYQuOs+oXj29D1bIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQof529rX0fyYPIUgAikDGEK27+i19KWCvpZ/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC4tPyx9PVg5z+AIUgAikDGELF2bmBmqaTpYB/hYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC65CWiN2g5IZghSACKQMYQrmNv6eS/6CCYYWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQr7mw9mBkoazVoUgAikDGEK8v5Wj/azytTeFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELJ4PqEqc+Tli+FIAIpAxhCy92l0q6Ggoz8AIWEUA0BC0GI8YMBQQ9BmPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQu3Flqe9j+DYVIUgAikDGELXg/+44uuX8dwAhYRQDQELQYjxgwFBD0GY8YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC7rfKwcvC5+i5f4UgAikDGELwjuObm4jWixGFhFANAQtBiPGDAUEPQZjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKTk+716KiClmeFIAIpAxhCmJLh6biI4pZphYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCxsy654zqoIW8f4UgAikDGEK60pHvivb0+MwAhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Ou54rzv+NByhSACKQMYQtrjn43Mj+GBqX+FhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKkm/HxpumCqhCFIAIpAxhCzbvaxOvHxIIYhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC2s6AyavF6v3HAIUgAikDGEKb9N23mYvTjj+FhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKGspjZnam3pm6FIAIpAxhC3a+72du2z9ZmhYRQDQELQajxgwFBEEG48YMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Pb4rvGI1KEVhSACKQMYQu/K0/2j0b7R8ACFhFANAQtBqPGDAUEQQbjxgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELyyPrD9OmMmPMAhSACKQMYQvC4kO3DhNv9ToWEUA0BC0Go8YMBQRBBuPGDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQq/zkNiUnMf7M4UgAikDGEKgpcX0zdDRpI1/hYRQDQELQcjxgwFBEUHc8YMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCq5iR8ZX61fyAf4UgAikDGEKWlPir8LHps+EAhYRQDQELQezxgwFBEUGA8oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCvsjTtePru+NihSACKQMYQqyK4YGkm+2Qun+FhFANAQtB/PKDAUEJQYjzgwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELhwrPKg/7PuESFIAIpAxhCjanii7uO56xnhYRQDQELQfzygwFBCUGI84MBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC0b7uy62VofSpf4UgAikDGEKHt8DPz47l1JN/hYRQDQELQfzygwFBCUGI84MBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC++Ty4bGz7cN8hSACKQMYQoG3yp62q+3MboWEUA0BC0GY84MBQQpBpPODARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuP/28bZwLK/2gCFIAIpAxhC66qH95GRkJUkhYRQDQELQZjzgwFBCkGk84MBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFANAQtBtPODAUEKQcDzgwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELT2NP4/eb2kkiFIAIpAxhCotieiOGg6unMAIWEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsKM9/bqy9zRhH+FIAIpAxhC5ZP0mPmv+Oiof4WEUA0BC0G084MBQQpBwPODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsKM9/bqy9zRhH+FIAIpAxhC5ZP0mPmv+Oiof4WEUA0BC0Hs84MBQQxB+PODARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQpCes+7ZtI2S6QCFIAIpAxhCiPSrgeCxxeTCAIWEUA0BC0Hs84MBQQxB+PODARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtPY0/j95vaSSIUgAikDGEKi2J6I4aDq6cwAhYRQDQELQYj0gwFBDEGU9IMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCx9n0597Etpx3hSACKQMYQo2yzpSMypLmp3+FhFANAQtBiPSDAUEMQZT0gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK+yNO14+u742KFIAIpAxhCrIrhgaSb7ZC6f4WEUA0BC0GI9oMBQR9BqPaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtG+7sutlaH0qX+FIAIpAxhCh7fAz8+O5dSTf4WEUA0BC0GI9oMBQR9BqPaDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuHCs8qD/s+4RIUgAikDGEKNqeKLu47nrGeFhFANAQtBiPaDAUEfQaj2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELtxZanvY/g2FSFIAIpAxhC14P/uOLrl/HcAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3gBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuuQlojdoOSGYIUgAikDGEK5jb+nkv+ggmGFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELktsqsz8HjheAAhSACKQMYQs3RnZud/LiouX+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELi0/LH09WDnP4AhSACKQMYQsXZuYGappOlgH+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEL6mLb6kqaKwxyFIAIpAxhCo8C62dbm4aomhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC3KeGzZSXyb2Wf4UgAikDGEKF8OaFkNqf4wyFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK1qLKWxKfvpkyFIAIpAxhC9/OL5tWOgc0ChYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCjaPrk8y0xpD3AIUgAikDGELZq+z22eDF9Ix/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCvubD2YGShrNWhSACKQMYQry/laP9rPK1N4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQu63ysHLwufouX+FIAIpAxhC8I7jm5uI1osRhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCn8K+osy/yKAhhSACKQMYQtbFlMaY/fXY+ACFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKZxOm31KOFxW6FIAIpAxhCmJbJ09D0npatf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQuOw4vGyk6rN1gCFIAIpAxhCsN/g8vi2lPSHf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvv22Orw4o2fxgCFIAIpAxhCmYalv/ivoY7SAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3oBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQrXD/r6MnKqmwwCFIAIpAxhCkvvHkL7smP6jf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQou1o+WM16fjdIUgAikDGEKwo/newPGn14R/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCyZCt59O+2ficf4UgAikDGELx8sqr5+fRxsIAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/7qo06KElftAhSACKQMYQobt8/bs3LvmAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsX5y/+RruGl8wCFIAIpAxhC7vSymv2ZrpRChYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCl9Gwm93/uJVZhSACKQMYQvyis4+I6LHY9gCFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKkr/T6qKmdkC2FIAIpAxhC46z6hePb0PVshYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCtfjHqNbd1Le+f4UgAikDGEKn8tT8r6+AqWWFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt4AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEKo+Inf7v3i9xmFIAIpAxhCgoiiweW47v4WhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC5KnF8t2K4cY0hSACKQMYQrXJiZWpl/q3GYWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsy0ov2VhIuhZIUgAikDGEL+io38urDbmtwAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCwceoqNnZtZSwf4UgAikDGEKDrfzS9vua5l+FhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELR8ffMnLrp/k6FIAIpAxhC1sKPmZi88qPxAIWEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQsng+oSpz5OWL4UgAikDGELL3aXSroaCjPwAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALegEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCh8Ds6MTOv9HJAIUgAikDGEK+v56/r8OkgvgAhYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBChoHQkLiHk6OZf4UgAikDGEKj1eOg2rL7n3uFhFANAQtBuPaDAUElQeD2gwEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELy/Kme5Y+hnSuFIAIpAxhC2YuNupm+7e+vf4WEUA0BC0G49oMBQSVB4PaDARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQof529rX0fyYPIUgAikDGEK27+i19KWCvpZ/hYRQDQELQbj2gwFBJUHg9oMBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCpJvx8abpgqoQhSACKQMYQs272sTrx8SCGIWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvLI+sP06YyY8wCFIAIpAxhC8LiQ7cOE2/1OhYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBChrKY2Z2pt6ZuhSACKQMYQt2vu9nbts/WZoWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQtrOgMmrxer9xwCFIAIpAxhCm/Tdt5mL044/hYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeAEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBCk5Pu9eiogpZnhSACKQMYQpiS4em4iOKWaYWEUA0BC0Hd+oUBQSZBhPuFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQvz2+K7xiNShFYUgAikDGELvytP9o9G+0fAAhYRQDQELQd36hQFBJkGE+4UBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBC/Ou54rzv+NByhSACKQMYQtrjn43Mj+GBqX+FhFANAQtB3fqFAUEmQYT7hQEQyyQACyACQSBqJAAgAAt6AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEELGzLrnjOqghbx/hSACKQMYQrrSke+K9vT4zACFhFANAQtB3fqFAUEmQYT7hQEQyyQACyACQSBqJAAgAAt5AQF/IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAACQCAABEAgAikDEEK+uaqJmdKNmuAAhSACKQMYQsWRgbqRwsPNNIWEUA0BC0G8/IUBQTlB+PyFARDLJAALIAJBIGokACAAC3kBAX8jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAAAJAIAAEQCACKQMQQueZwdKG0azNs3+FIAIpAxhC5ZLhj9uJra5ShYRQDQELQYj9hQFBOEHA/YUBEMskAAsgAkEgaiQAIAALeQEBfyMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAAkAgAARAIAIpAxBClY2j2tTIv9zGAIUgAikDGEKzz/m4y5qOxTKFhFANAQtB0P2FAUE2QYj+hQEQyyQACyACQSBqJAAgAAtmAQJ/IwBBEGsiBSQAIAUgBDYCDCAFIAM2AgggBUEIahCeNiEGIABBADYCECAAIAQ2AgwgACADNgIIIAAgAjYCBCAAIAE2AgAgACAGIAIgAWtBA3YiACAAIAZLGzYCFCAFQRBqJAALZgECfyMAQRBrIgUkACAFIAI2AgwgBSABNgIIIAVBCGoQnjYhBiAAQQA2AhAgACAENgIMIAAgAzYCCCAAIAI2AgQgACABNgIAIAAgBCADa0EDdiIAIAYgACAGSRs2AhQgBUEQaiQAC4sJAhB/Bn4jAEEgayIRJAAgASgCECISIAIoAhBHBEAgEUEANgIIQQAgAUEQaiACQRBqIBFBCGpBgIKIARCvKwALIAEoAgwhBCACKAIMIQ0jAEHQAGsiAyQAIAMgASgCBCABKAIIIAQgEhCHHSADQRRqIAIoAgQgAigCCCANIBIQhx0gAygCHCEOIAMoAhQhDSADKAIIIQ8gAygCACECIAMgAygCICIHIAMoAgwiCCAHIAhJG0EDdCIKNgI0IAohCwJAAkACQAJAAkACQAJAIApBOHEiAQRAIAogAWtBQGsiCyAKSQ0BC0HAACEMIAtBwAAQ0TRFDQEgCwRAIAtBwAAQrTYiDEUNAwsgDCEJAkAgCEUNACAOQT9xrSEWIA9BP3GtIRdBACAOa0E/ca0hGEEAIA9rQT9xrSEUIAIhBSAIIQEgByEEIA0hBgNAIAUpAAAhEyAPBEAgBUEIajEAACAUhiATIBeIhCETCyAERQ0BIAYpAAAhFSAJIA4EfiAGQQhqMQAAIBiGIBUgFoiEBSAVCyATgzcAACAFQQhqIQUgBEEBayEEIAZBCGohBiAJQQhqIQkgAUEBayIBDQALCyADIAkgDGsiATYCKCABIApHDQMgAyAKNgJEIAMgDDYCQCADIAs2AjwgA0HAADYCOCADKAIQIhBBA3ZCACEUIBAEQCACIAhBA3RqIgIxAAAgD0E/ca2IIRMgDyAQaiIBQQN2IAFBB3FBAEdqIgFBAk8EQEEIIA9rIQUgAUEBayEJIAJBAWohBgNAIAYxAAAgBUE/ca2GIBOEIRMgBkEBaiEGIAVBCGohBSAJQQFrIgkNAAsLIBNCfyAQQT9xrYZCf4WDIRQLIBBBB3FBAEdqIQggAyADKAIkIgQEfiANIAdBA3RqIgIxAAAgDkE/ca2IIRMgBCAOaiIBQQN2IAFBB3FBAEdqIgFBAk8EQEEIIA5rIQUgAUEBayEJIAJBAWohBgNAIAYxAAAgBUE/ca2GIBOEIRMgBkEBaiEGIAVBCGohBSAJQQFrIgkNAAsLIBNCfyAEQT9xrYZCf4WDBUIACyAUgzcDKCAIQQlPDQQgCyAIIApqIgFJBEAgA0E4aiALQQF0IgIgARDhKiIBIAEgAkkbEOgZIAMoAkQhCiADKAJAIQwLIAgEQCAKIAxqIANBKGogCPwKAAALIAMoAkAhBCADKAI8IQ0gAygCOCECIAMoAkQhAUEcQQQQrTYiB0UNBSAHIA02AhggByACNgIUIAdBADYCECAHIAQ2AgggB0KBgICAEDcCACAAIAQ2AgQgACAHNgIAIAcgASAIaiIBNgIMIAAgATYCCCADQdAAaiQADAYLQZj8hwFBI0G8/IcBEMskAAtB8/qHAUEpIANBOGpB2PqHAUGc+4cBENUeAAtBwAAgCxCjPQALIANCADcCRCADQoGAgIDAADcCPCADQeD7hwE2AjhBACADQShqIANBNGogA0E4akHo+4cBEK8rAAsgCEEIQfj7hwEQsDsAC0EEQRwQoz0ACyAAIBI2AhAgAEEANgIMIBFBIGokAAtcAQF/An8gAUEQdiABQf//A3FBAEdqIgJAACIBQX9GBEBBACEBQQAMAQsgAkEQdCICQRBrIAIgAUEQdCIBQQAgAmtGGwshAiAAQQA2AgggACACNgIEIAAgATYCAAtkAQN/AkAgASgCBCICQQBIDQAgASgCACEDAkAgAkUEQEEBIQEMAQtBASEEIAJBARCtNiIBRQ0BCyACBEAgASADIAL8CgAACyAAIAI2AgQgACABNgIADwsgBCACQcjBiQEQ/S8AC2AAAkACQAJAAkACQCAALQAgDgUABAQBAgQLIABBCGoQ3jsPCyAAQSRqEJIuDAELIABB8ABqEN8gIABBKGoQ/RsgAEEAOgAhCyAALQAiBEAgAEEUahDeOwsgAEEAOgAiCwtjAQF/QThBBBCtNiIBBEAgAUEAOgA0IAFBADoAMCABQQA2AiggAUEAOgAkIAFBADYCHCABQQA6ABggAUEANgIIIAFCgoCAgBA3AgAgACABNgIEIAAgATYCAA8LQQRBOBCjPQALZwEBf0E0QQQQrTYiAQRAIAFBADoAMCABQQA6ACwgAUEANgIkIAFBADoAICABQQA2AhggAUEAOgAUIAFBgICAgHg2AgggAUKCgICAEDcCACAAIAE2AgQgACABNgIADwtBBEE0EKM9AAvrAgEBfyAAQQRqIQECQAJAAkACQAJAAkAgACgCAA4FAQIEAwQACyABKAIAIgBBhAFJDQQgABDyHw8LAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyABKAIAIgAoAgAiAUGAgICAeHMgAUEAThsOEAABAgMEBQYPBwgJCgsMDQ4PCyAAQQRqEN47DA4LIABBBGoQvCoMDQsgAEEEahDeOwwMCyAAQQRqEN47DAsLIABBBGoQ3jsMCgsgAEEEahDeOwwJCyAAQQRqEN47DAgLIABBBGoQ3jsMBwsgAEEEahDeOwwGCyAAQQRqEN47DAULIAAQ3jsgAEEMahC5LgwECyAAQQRqEN47DAMLIABBBGoQ3jsMAgsgAEEEahDeOwwBCyAAQQRqEN47CyAAQRRBBBD4Og8LIAEoAgAiABDJIyAAQRhBCBD4Og8LIAEoAgAiABChKSAAQQRBBBD4Og8LIAEQ3jsLC20BAX8jAEEwayICJAAgAkGAxsMANgIEIAIgATYCACACQQI2AgwgAkHAu8MANgIIIAJCAjcCFCACQcoBNgIsIAJBywE2AiQgAiAANgIgIAIgAkEgajYCECACIAI2AiggAkEIahChFSACQTBqJAALZwEBfyMAQRBrIgIkACACIAE2AgwCQCACQQxqEM8sRQRAIAIgARC4EiACKAIAIQEgACACKAIENgIEIABBAkEBIAFBAXEbNgIADAELIABBADYCACABQYQBSQ0AIAEQ8h8LIAJBEGokAAteAQN/IAEoAgwiAgR/IAEgAkEBazYCDCABIAEoAggiAkEBaiIDIAEoAgAiBEEAIAMgBE8bazYCCCABKAIEIAJBAnRqKAIAIQFBAQVBAAshAiAAIAE2AgQgACACNgIAC2gBA38CQCAAKAIAIgAoAgwiAUUNACAAKAIQIgMoAgAiAgRAIAEgAhEDAAsgAygCBCICRQ0AIAEgAiADKAIIEPg6CwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEUQQQQ+DoLC2cBAn8jAEEQayICJAACQCABKAIAIgMEQCACIAFBDGogASgCBCABKAIIIAMoAgARBQAMAQsgAkEANgIAIAIgAS0ABDoABAsgACACKQIANwIAIABBCGogAkEIaikCADcCACACQRBqJAALZgEBfyAAKAIAIgAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+CMLIABBDGoiARDeIyABQQRBFBDgHgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEcQQQQ+DoLC2oBAX8jAEEwayIDJAAgAyACNgIEIAMgATYCACADQQI2AgwgA0HA0cwANgIIIANCAjcCFCADQcoBNgIsIANBywE2AiQgAyAANgIgIAMgA0EgajYCECADIAM2AiggA0EIahChFSADQTBqJAALXwACQCADBEAgAUEYaiEBIAIgA0EEdGohAwNAIAIoAgBFDQIgASACQQRqKAIAIAJBCGooAgAQoTYgAkEQaiICIANHDQALCyAAQQg2AgAPC0Hkh84AQSBBhIjOABDLJAALZAIBfwF+IwBBEGsiAyQAAkAgACACTQRAIANCADcDCCAAQQlPDQEgAARAIANBCGogASAA/AoAAAsgAykDCCADQRBqJAAPC0G0tc4AQSNB2LXOABCfKQALIABBCEHotc4AELA7AAtkAQR/IwBBEGsiASQAAkAgAEUNACAAKAK01QEhAiAAKAIAIAFBCGogAEG41QFqKAIAIgQ2AgAgASAAKQKw1QE3AwAgARCLLSACBEAgBCAAIAIRAAAMAQsgABDSNQsgAUEQaiQAC28AAkACQAJAAkAgAkH/AXFBAWsOAwECAwALIABBP3EPCyAAQfwBcUECdg8LIAFB/wFxQbST4gBqLQAAIABB/wFxQbSR4gBqLQAAcg8LIAFB/wFxQbSV4gBqLQAAIABB/wFxQbSV4gBqLQAAQQN0agtlAQF/IABBDGoQowwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQpgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQpwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQqAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxC/EiACKAIoBEAgAikDMCEIDAMLIAJByABqQY+evPgANgIAIAJCj568+PDhw4cPNwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENUbIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBiZKkyAA2AgAgAkKJkqTIkKHChAk3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ6hwgAigCKARAIAIpAzAhCAwDCyACQcgAakGIr4ABKAIANgIAIAJBgK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxCOHCACKAIoBEAgAikDMCEIDAMLIAJByABqQayvgAEoAgA2AgAgAkGkr4ABKQIANwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADEL8SIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBj568+AA2AgAgAkKPnrz48OHDhw83A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1hsgAigCKARAIAIpAzAhCAwDCyACQcgAakGFipQoNgIAIAJChYqUqNCgwYIFNwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/gDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADEOocIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBiK+AASgCADYCACACQYCvgAEpAgA3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQjhwgAigCKARAIAIpAzAhCAwDCyACQcgAakGsr4ABKAIANgIAIAJBpK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv3AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEgAxCtKiACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL+AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASgCACADEI8sIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1RsgAigCKARAIAIpAzAhCAwDCyACQcgAakGJkqTIADYCACACQomSpMiQocKECTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv3AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxDWGyACKAIoBEAgAikDMCEIDAMLIAJByABqQYWKlCg2AgAgAkKFipSo0KDBggU3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIpAhghCCACKQIgIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSkDEDcDCEIBCzcDACAFQSBqJAAL+AMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASgCACADEI8sIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQjhwgAigCKARAIAIpAzAhCAwDCyACQcgAakGsr4ABKAIANgIAIAJBpK+AASkCADcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv6AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQvxIgAigCKARAIAIpAzAhCAwDCyACQcgAakGPnrz4ADYCACACQo+evPjw4cOHDzcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv4AwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIkIQQjAEHgAGsiAiQAAkACfgJAIAEoAhwiAyABKAIgRwRAAkACQCABKAIERQ0AIAMgASgCFE8NASABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAigCACEBIAIgAigCBCIDNgIQIAIgATYCDCACQShqIAEgAxDqHCACKAIoBEAgAikDMCEIDAMLIAJByABqQYivgAEoAgA2AgAgAkGAr4ABKQIANwNAIAJBAzYCLCACQcSugAE2AiggAkICNwI0IAJBrhA2AlwgAkHMATYCVCACIAJB0ABqNgIwIAIgAkFAayIBNgJYIAIgAkEMajYCUCACQRhqIAJBKGoQmQ4gARCqDCACKQIYIQggAikCICEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEQYKAgIB4NgIAQgAMAwtB9KeAAUEgQZSogAEQnykACyAGQgI3AwAMAgtCAQshCSAGIAg3AwggBiAJNwMACyACQeAAaiQAIAACfkIAIAUpAwgiCEICUQ0AGkIAIAinQQFxRQ0AGiAAIAUpAxA3AwhCAQs3AwAgBUEgaiQAC/cDAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENYbIAIoAigEQCACKQMwIQgMAwsgAkHIAGpBhYqUKDYCACACQoWKlKjQoMGCBTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAv6AwMGfwF+AXwjAEEgayIFJAAgBUEIaiEGIAEoAiQhBCMAQeAAayICJAACQAJ+AkAgASgCHCIDIAEoAiBHBEACQAJAIAEoAgRFDQAgAyABKAIUTw0BIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcDAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACKAIAIQEgAiACKAIEIgM2AhAgAiABNgIMIAJBKGogASADENEBIAIoAigEQCACKwMwIQkMAwsgAkHIAGpBjJiw4AA2AgAgAkKMmLDgwIGDhgw3A0AgAkEDNgIsIAJBxK6AATYCKCACQgI3AjQgAkGuEDYCXCACQcwBNgJUIAIgAkHQAGo2AjAgAiACQUBrIgE2AlggAiACQQxqNgJQIAJBGGogAkEoahCZDiABEKoMIAIrAhghCSACKQIgIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJOQIEIARBgoCAgHg2AgBCAAwDC0H0p4ABQSBBlKiAARCfKQALIAZCAjcDAAwCC0IBCyEIIAYgCTkDCCAGIAg3AwALIAJB4ABqJAAgAAJ+QgAgBSkDCCIIQgJRDQAaQgAgCKdBAXFFDQAaIAAgBSsDEDkDCEIBCzcDACAFQSBqJAAL9QMCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCJCEEIwBB4ABrIgIkAAJAAn4CQCABKAIcIgMgASgCIEcEQAJAAkAgASgCBEUNACADIAEoAhRPDQEgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhwMAwsgASADQQFqNgIcIAIgASADEK0qIAIoAgAhASACIAIoAgQiAzYCECACIAE2AgwgAkEoaiABIAMQ1RsgAigCKARAIAIpAzAhCAwDCyACQcgAakGJkqTIADYCACACQomSpMiQocKECTcDQCACQQM2AiwgAkHEroABNgIoIAJCAjcCNCACQa4QNgJcIAJBzAE2AlQgAiACQdAAajYCMCACIAJBQGsiATYCWCACIAJBDGo2AlAgAkEYaiACQShqEJkOIAEQqgwgAikCGCEIIAIpAiAhCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBEGCgICAeDYCAEIADAMLQfSngAFBIEGUqIABEJ8pAAsgBkICNwMADAILQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokACAAAn5CACAFKQMIIghCAlENABpCACAIp0EBcUUNABogACAFKQMQNwMIQgELNwMAIAVBIGokAAtlAQF/IABBDGoQtAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtAwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQtgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQtwwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsCQCAAKAIkIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBJGoQ+x4LIAAQsyYgABDqOwtlAQF/IABBDGoQuQwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQvgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtlAQF/IABBDGoQwgwgACgCGCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEYahD7HgsgABDFJyAAEOg7AkAgACgCJCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSRqEPseCwtkAQJ/AkAgAkEBaiIEIAEoAkhBAnYiA0kEQCACIANJDQEgAiADQczdhQEQwyEACyAEIANBvN2FARDDIQALIAAgASABKAJEIgAgAkECdGooAgAiASAAIARBAnRqKAIAIAFrEL0QC1sBAn8gACABRgRAQQAPCyABIABrQQN2IQJBACEBA0AgACgCACAAQQRqKAIAIgMoAghBAWtBeHFqQQhqIAMoAlQRBAAgAWohASAAQQhqIQAgAkEBayICDQALIAELYAECfyABKAIcIgQEQCABKAIYIQMDQCADEKUeIANBxABqIQMgBEEBayIEDQALCyABQRRqQQRBxAAQ4B4gAUEcaiACQQhqKAIANgIAIAEgAikCADcCFCAAIAFB3AD8CgAAC2IBAn8jAEEQayIBJAAgACgCACICBEAgASACNgIMIAEgACgCCDYCCCABQQhqQQRBBBDgHgsgACgCECICBEAgASACNgIMIAEgACgCGDYCCCABQQhqQQRBBBDgHgsgAUEQaiQAC/QDAgp/AX4jAEEQayIDJAACQCABKAIEIgRFBEAgAEEIakGg4IcBKQIANwIAIABBmOCHASkCADcCAAwBCyMAQRBrIgIkACACIAJBGEEIIARBAWoQnRQgAigCCCEEIAIoAgQhBSACKAIAIggEQCADIAIoAgw2AgwLIAMgBDYCCCADIAU2AgQgAyAINgIAIAJBEGokACMAQSBrIgYkACADKAIAIQIgASIEKAIAIQEgAygCBEEJaiIFBEAgAiABIAX8CgAACyAEKAIMIgUEQCACQRhrIQogAUEIaiEJIAEpAwBCf4VCgIGChIiQoMCAf4MhDCAGQRRqIQsgBSEIIAEhAgNAIAxQBEADQCACQcABayECIAkpAwAgCUEIaiEJQoCBgoSIkKDAgH+DIgxCgIGChIiQoMCAf1ENAAsgDEKAgYKEiJCgwIB/hSEMCyAGQQhqIAIgDHqnQQN2QWhsaiIHQRhrEN0gIAsgB0EMaxDdICAKIAEgB2tBaG1BGGxqIgcgBikCCDcCACAHQRBqIAZBGGopAgA3AgAgB0EIaiAGQRBqKQIANwIAIAxCAX0gDIMhDCAIQQFrIggNAAsLIAMgBTYCDCADIAQoAgg2AgggBkEgaiQAIABBCGogA0EIaikCADcCACAAIAMpAgA3AgALIANBEGokAAtjAQJ/IwBBEGsiAyQAIAAoAgAhAiAAQQA2AgAgAgRAIAMgAjYCDCACQQhqQQAgARDwFyACIAIoAgBBAWsiADYCACAARQRAIANBDGoQshoLIANBEGokAA8LQYyoiAFBHBCXPQALYwECfyMAQRBrIgMkACAAKAIAIQIgAEEANgIAIAIEQCADIAI2AgwgAkEIakEBIAEQ8BcgAiACKAIAQQFrIgA2AgAgAEUEQCADQQxqELIaCyADQRBqJAAPC0GMqIgBQRwQlz0AC14BBH8gACgCCCICBEAgACgCBCEAA0AgACgCACEDIABBBGooAgAiBCgCACIBBEAgAyABEQMACyAEKAIEIgEEQCADIAEgBCgCCBD4OgsgAEEIaiEAIAJBAWsiAg0ACwsLYAEBfyAAKAIIIgEEQCAAKAIEIQADQAJAIAAoAgBBCEYEQCAAQRBqIABBCGooAgAgAEEMaigCACAAQQRqKAIAKAIQEQEADAELIAAQ8BsLIABBIGohACABQQFrIgENAAsLC3YBAX8CQAJAAkACQCAALQC4Bg4EAAMDAQMLIAAQnC8gACgCsAYiAUGEAU8EQCABEPIfCyAAKAK0BiIAQYMBSw0BDAILIABBmANqEJwvIAAoArAGIgFBhAFPBEAgARDyHwsgACgCtAYiAEGDAU0NAQsgABDyHwsLcAEBfwJAAkACQAJAIAAtAFgOBAADAwEDCyAAEP8pIAAoAigiAUGEAU8EQCABEPIfCyAAKAIsIgBBgwFLDQEMAgsgAEEwahD/KSAAKAIoIgFBhAFPBEAgARDyHwsgACgCLCIAQYMBTQ0BCyAAEPIfCwtfAQJ/AkACQCABBEAgAUEIayIDIAMoAgBBAWoiAjYCACACRQ0BIAEoAgAiAkF/Rg0CIAAgAzYCCCAAIAE2AgQgACABQQhqNgIAIAEgAkEBajYCAA8LEJg9CwALEJk9AAtpAQF/IwBBEGsiAiQAIAIgACgCACIAQQhqNgIMIAFBlJ3DAEGkncMAIABBFGpB5JzDAEGyncMAIABBGGpB9JzDAEG/ncMAIABBGmpB9JzDAEHMncMAIAJBDGpBhJ3DABCxFiACQRBqJAALXwECfwJAAkAgAQRAIAFBCGsiAyADKAIAQQFqIgI2AgAgAkUNASABKAIAIgJBf0YNAiAAIAM2AgggACABNgIEIAAgAUEEajYCACABIAJBAWo2AgAPCxCYPQsACxCZPQALcAEBfwJAAkACQAJAIAAtAEgOBAADAwEDCyAAENocIAAoAiAiAUGEAU8EQCABEPIfCyAAKAIkIgBBgwFLDQEMAgsgAEEoahDaHCAAKAIgIgFBhAFPBEAgARDyHwsgACgCJCIAQYMBTQ0BCyAAEPIfCwtwAQF/AkACQAJAAkAgAC0AUA4EAAMDAQMLIAAQ4iAgACgCJCIBQYQBTwRAIAEQ8h8LIAAoAigiAEGDAUsNAQwCCyAAQSxqEOIgIAAoAiQiAUGEAU8EQCABEPIfCyAAKAIoIgBBgwFNDQELIAAQ8h8LC3ABAX8CQAJAAkACQCAALQBoDgQAAwMBAwsgABDeHyAAKAIwIgFBhAFPBEAgARDyHwsgACgCNCIAQYMBSw0BDAILIABBOGoQ3h8gACgCMCIBQYQBTwRAIAEQ8h8LIAAoAjQiAEGDAU0NAQsgABDyHwsLcAEBfwJAAkACQAJAIAAtAGgOBAADAwEDCyAAENMWIAAoAjAiAUGEAU8EQCABEPIfCyAAKAI0IgBBgwFLDQEMAgsgAEE4ahDTFiAAKAIwIgFBhAFPBEAgARDyHwsgACgCNCIAQYMBTQ0BCyAAEPIfCwtyAQF/AkACQAJAAkAgAC0AkAEOBAADAwEDCyAAEN8UIAAoAkQiAUGEAU8EQCABEPIfCyAAKAJIIgBBgwFLDQEMAgsgAEHMAGoQ3xQgACgCRCIBQYQBTwRAIAEQ8h8LIAAoAkgiAEGDAU0NAQsgABDyHwsLXwEDfwJAIAAoAgAiACgCTCICRQ0AIAAoAlAiAygCACIBBEAgAiABEQMACyADKAIEIgFFDQAgAiABIAMoAggQ+DoLIAAoAgBBAkcEQCAAQRBqEN47CyAAQdQAQQQQ+DoLawEBfyMAQRBrIgMkACADQQhqIAAgAhC6H0GAgMQAIQICQCADKAIIQQFHDQAgAyAAIAEQuh8gAygCAEECRw0AQYCAxAAgAygCBCIAIABBgLADc0GAgMQAa0GAkLx/SRshAgsgA0EQaiQAIAILWgECfyMAQRBrIgEkACABQQRqIAAQhyMgASgCBCgCACABKAIIIgIgAigCAEEBazYCACABKAIMIgIgAigCAEEBayICNgIAIAJFBEAgAUEMahCnKQsgAUEQaiQAC1kBA39BAiEBIAAoAgBBgICAgHhHBEAgACgCCEEDdCECIAAoAgQhAQNAIAIiAARAIABBCGshAiABLQAEIAFBCGohAQ0BCwsgAEEARyEBCyABQQJGIAFyQQFxC+oCAgR/An4jAEEgayIDJAAgA0EIaiEEIwBBMGsiAiQAIAJBDGoiBRDvLyABQQxqKAIAIQECQAJAIAUQ6SkNAANAIAEoAgQiBSABKQMIIgYgBa0iByAGIAdUG6ciBUYEQCACKAIQDQIgBEEEakElQcCj0ABBCxDNGkEBIQEMAwsgASAGQgF8NwMIIAJBIGogAkEMaiABKAIAIAVqLQAAENQmAkAgAi0AIEEERg0AIAIpAyAiBkL/AYNCBFENACAEIAY3AgRBASEBDAMLIAJBDGoQ6SlFDQALCyACQSBqIAJBDGoQzxhBASEBIAIoAiBBAUYEQCAEIAIpAyg3AwhBACEBDAELIARBBGpBJUHAo9AAQQsQzRoLIAQgATYCACACQTBqJABBASEBAkAgAygCCEEBRgRAIAMgAykCDDcDGCAAQQRqIANBGGoQ0AkMAQsgACADKQMQNwMIQQAhAQsgACABNgIAIANBIGokAAvvAgIFfwF+IwBBIGsiAyQAIANBCGohBCMAQTBrIgIkACACQQA6AAsgAkEMaiIFEO8vIAFBDGooAgAhAQJAAkAgBRDpKQ0AA0AgASgCACIFIAJBC2ogBSgCCCIFQQBHIgYQlxogASABKAIEIAZqNgIEIAVFBEAgAigCEA0CIARBBGpBJUHc880AQQsQzRpBASEBDAMLIAJBIGogAkEMaiACLQALENQmAkAgAi0AIEEERg0AIAIpAyAiB0L/AYNCBFENACAEIAc3AgRBASEBDAMLIAJBDGoQ6SlFDQALCyACQSBqIAJBDGoQzxhBASEBIAIoAiBBAUYEQCAEIAIpAyg3AwhBACEBDAELIARBBGpBJUHc880AQQsQzRoLIAQgATYCACACQTBqJABBASEBAkAgAygCCEEBRgRAIAMgAykCDDcDGCAAQQRqIANBGGoQ0AkMAQsgACADKQMQNwMIQQAhAQsgACABNgIAIANBIGokAAtQAQF/IABBBGohAEF/IAIgAkEASBtBAWohAgNAIAIEQCACQQFrIQIgAyAALQAARSABKAIAQQBHcXIhAyAAQQRqIQAgAUEEaiEBDAELCyADRQtkAQF/Qbh/IQMCQCABQQNJDQAgAC0AAiEBIAIgAC8AACIAQQFxNgIEIAIgAEEBdkEDcSIDNgIAIAIgACABQRB0ckEDdiIANgIIAkACQCADQQFrDgMCAQABC0FsDwsgACEDCyADC1kCAX8BfiAAUARAQQFCACABIAIgAxDlEg8LQQFCASABIAIgAxDlEkEDIAB5p0E/c0EAIABCAVIbIgStIgUgASACIAMQ5RIgBEJ/IAWGIAB8IAEgAiADEOUSC2ABA38gACgCCCIDQQJqIgQgACgCBCIFTwRAIAQgBUHEwvsAEMMhAAsgACADQQNqNgIIIAAoAgAgBGogAjoAACABIAJB/wFxQQJ0aiIAIAAvAQRBAWo7AQQgAyAFQQZrRgtsACABKAIAIAIQmiVFBEAgACADIAQgASgCDCIAIAJsIgIgACACaiABKAIQIAEoAhQQoRIPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALLAEBfyABKAIIQQxqIAIQkhkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LLAEBfyABKAIIQQxqIAIQyBkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LLAEBfyABKAIIQQxqIAIQ3xkhAiAAIAEoAgAgAiADIAQgASgCBCgCDBEHAA8LXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHYzoQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBsM+EATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQYjQhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg0IQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBuNGEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZDShAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo0oQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBwNOEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZjUhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALwAIBBn8jAEEwayIFJAAjAEEwayIEJAAgBCABENAGIwBBEGsiBiQAIAFBDGoiCCgCACIHIAcoAgAiCUEBajYCACAJQQBIBEAACyAGIAc2AgQgBiAIKQIENwIIIARBDGogBkEEaiACIAMQgR0gBkEQaiQAAkAgASgCGARAIARBGGogAUEYaiACIAMQsR8MAQsgBEEANgIYCyAFIAQpAgA3AgAgBSAEKQIMNwIMIAUgBCkCGDcCGCAFQQhqIARBCGooAgA2AgAgBUEUaiAEQRRqKAIANgIAIAVBIGogBEEgaikCADcCACAFQShqIARBKGopAgA3AgAgBEEwaiQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAVBMPwKAAAgAEHw1IQBNgIEIAAgATYCACAFQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABByNWEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQaDWhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEH41oQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC8ACAQZ/IwBBMGsiBSQAIwBBMGsiBCQAIAQgARDQBiMAQRBrIgYkACABQQxqIggoAgAiByAHKAIAIglBAWo2AgAgCUEASARAAAsgBiAHNgIEIAYgCCkCBDcCCCAEQQxqIAZBBGogAiADEP8cIAZBEGokAAJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgBSAEKQIANwIAIAUgBCkCDDcCDCAFIAQpAhg3AhggBUEIaiAEQQhqKAIANgIAIAVBFGogBEEUaigCADYCACAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABB0NeEATYCBCAAIAE2AgAgBUEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQiBhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQajYhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEGA2YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCHGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB2NmEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAv9AQECfyMAQTBrIgUkACMAQTBrIgQkACAEIAEQ0AYgBEEMaiABQQxqIAIgAxC2JgJAIAEoAhgEQCAEQRhqIAFBGGogAiADELEfDAELIARBADYCGAsgBSAEKQIANwIAIAUgBCkCDDcCDCAFIAQpAhg3AhggBUEIaiAEQQhqKAIANgIAIAVBFGogBEEUaigCADYCACAFQSBqIARBIGopAgA3AgAgBUEoaiAEQShqKQIANwIAIARBMGokAEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAFQTD8CgAAIABBsNqEATYCBCAAIAE2AgAgBUEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhxhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQYjbhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHg24QBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBuNyEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAvAAgEGfyMAQTBrIgUkACMAQTBrIgQkACAEIAEQ0AYjAEEQayIGJAAgAUEMaiIIKAIAIgcgBygCACIJQQFqNgIAIAlBAEgEQAALIAYgBzYCBCAGIAgpAgQ3AgggBEEMaiAGQQRqIAIgAxCCHSAGQRBqJAACQCABKAIYBEAgBEEYaiABQRhqIAIgAxCxHwwBCyAEQQA2AhgLIAUgBCkCADcCACAFIAQpAgw3AgwgBSAEKQIYNwIYIAVBCGogBEEIaigCADYCACAFQRRqIARBFGooAgA2AgAgBUEgaiAEQSBqKQIANwIAIAVBKGogBEEoaikCADcCACAEQTBqJABBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBUEw/AoAACAAQZDdhAE2AgQgACABNgIAIAVBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHo3YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCJGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABBwN6EATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhxhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQZjfhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIcYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEHw34QBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABByOCEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQaDhhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIkYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEH44YQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC10BAX8jAEEwayIEJAAgBCABIAIgAxCGGEE4QQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAEQTD8CgAAIABB0OKEATYCBCAAIAE2AgAgBEEwaiQADwtBBEE4EKM9AAtdAQF/IwBBMGsiBCQAIAQgASACIAMQhhhBOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogBEEw/AoAACAAQajjhAE2AgQgACABNgIAIARBMGokAA8LQQRBOBCjPQALXQEBfyMAQTBrIgQkACAEIAEgAiADEIYYQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIARBMPwKAAAgAEGA5IQBNgIEIAAgATYCACAEQTBqJAAPC0EEQTgQoz0AC7MBAQN/IwBBEGsiAiQAIAIgAEEIajYCDCACIAAoAgQiATYCCCACIAAoAgAiADYCBCABKAIAIgMEQCAAIAEoAghBAWtBeHFqQQhqIAMRAwALAkAgAkEEaiIBKAIAIgBBf0YNACAAIAAoAgQiA0EBazYCBCADQQFHDQAgASgCBCIBKAIEQQQgASgCCCIBIAFBBE0bIgFqQQdqQQAgAWtxIgNFDQAgACADIAEQ+DoLIAJBEGokAAvxBQINfwF+IwBBMGsiByQAIwBBMGsiBCQAIAQgAzYCECAEIAI2AgwCQCABKAIkBEAgBEEgaiABQSRqIAIgAxC4JiAEKQIkIREgBCgCICECIARBFGogARDhFAwBCyABKAIIIQIgBCABKAIEIgM2AiAgBCADIAJBA3RqNgIkIAQgBEEQajYCLCAEIARBDGo2AigjAEEgayICJAAgAkEUaiAEQSBqIgMoAgQgAygCAGtBA3ZBAEEEQQgQoBggAigCGCEIIAIoAhRBAUYEQCAIIAIoAhxByP+FARD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIIJAAgAygCBCADKAIAa0EDdiIJIAJBCGoiBSgCACAFKAIIIgZrSwRAIAUgBiAJQQRBCBDeKCAFKAIIIQYLIAggBSgCBDYCDCAIIAY2AgggCCAFQQhqNgIEIwBBEGsiBiQAIAhBBGoiCigCBCEJIAooAgAgAygCACIFIAMoAgQiDEcEQCADKAIMIQ8gAygCCCEQIAooAgggCUEDdGohAyAJIAwgBWtBA3YiCmohCQNAIAMgBSgCACIMBH8gBkEIaiAMIAVBBGooAgAiCygCCEEBa0F4cWpBCGogECgCACAPKAIAIAsoAiARBQAgBigCDCELIAYoAggFQQALNgIAIANBBGogCzYCACAFQQhqIQUgA0EIaiEDIApBAWsiCg0ACwsgCTYCACAGQRBqJAAgCEEQaiQAIARBFGoiA0EIaiANKAIANgIAIAMgAikCCDcCACACQSBqJABBACECCyAHQQxqIAFBDGoQ1wYgB0EYaiABQRhqIAQoAgwgBCgCEBC1JiAHIBE3AiggByACNgIkIAcgBCkCFDcCACAHQQhqIARBHGooAgA2AgAgBEEwaiQAQThBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIAdBMPwKAAAgAEH8h4YBNgIEIAAgATYCACAHQTBqJAAPC0EEQTgQoz0AC2IBAn8jAEEgayIDJAAgA0EMaiABQQEQkRoCQCADKAIMIgRBk4CAgHhHBEAgACADKQIQNwIEIABBDGogA0EYaikCADcCACAAIAQ2AgAMAQsgACABQQAgAhDFDgsgA0EgaiQAC2ABA38CQCAAKAIMIgIgAWoiAyACTQ0AIAAoAgQiBCADSQRAIAAgBEEBdCICIAMQ3SoiBCACIARLGxDoGSAAKAIMIQILIAFFDQAgACgCCCACakEAIAH8CwALIAAgAzYCDAtVAQJ/AkAgASADRw0AIAEEQANAIAAoAgAiAyACKAIAIgVHBEAgA0EIaiAFQQhqEN8nRQ0DCyAAQQRqIQAgAkEEaiECIAFBAWsiAQ0ACwtBASEECyAEC1gBAX4CQCACIAFCgICAgICAgICAf30gAVStfEIAUiACIASFQgBTcg0AIANCAX1CflQgBCADUK19IgJCf1IgAkJ/URsNACAAIAE3AwhCASEFCyAAIAU3AwALXAECfyMAQRBrIgEkACAALQAUIQIgAEEBOgAUIAEgAEEIayIANgIMAkAgAkUEQBCUDSAAEP0eDAELIAAgACgCAEEBayIANgIAIAANACABQQxqEKorCyABQRBqJAALawIBfwFvIwBBEGsiBCQAIAEoAgAlASACKAIAJQEgAygCACUBEEghBRDfEiIBIAUmASAEQQhqEM4tQQEhAyAAAn8gBCgCCEEBcQRAIAQoAgwMAQtBACEDIAELNgIEIAAgAzYCACAEQRBqJAALXgEDfyAAKAIEIQEgAC0AACIAQQRNIABBA0dxRQRAIAEoAgAhACABQQRqKAIAIgMoAgAiAgRAIAAgAhEDAAsgAygCBCICBEAgACACIAMoAggQ+DoLIAFBDEEEEPg6CwtkAQN/AkACQCAAKAIEIgJFDQAgACgCACIAKAIIIgEgAkkNASAAQQA2AgggASACRg0AIAEgAmsiAQRAIAAoAgQiAyACIANqIAH8CgAACyAAIAE2AggLDwsgAiABQZCoiQEQsDsAC1cBAX8jAEEQayIDJAAgA0EEaiACEJctIAEEQANAIAMgADYCDCADQQRqIANBDGpBoMCJARDJFCAAQQFqIQAgAUEBayIBDQALCyADQQRqEKksIANBEGokAAtWAQF+AkAgA0HAAHFFBEAgA0UNASACIANBP3GtIgSGIAFBACADa0E/ca2IhCECIAEgBIYhAQwBCyABIANBP3GthiECQgAhAQsgACABNwMAIAAgAjcDCAtWAQF+AkAgA0HAAHFFBEAgA0UNASACQQAgA2tBP3GthiABIANBP3GtIgSIhCEBIAIgBIghAgwBCyACIANBP3GtiCEBQgAhAgsgACABNwMAIAAgAjcDCAtsAQF/AkACQAJAIAAtAPgCDgQAAgIBAgsgACgCAEUNASAAKAIEIgBBhAFJDQEgABDyHw8LIABBuAFqEMIKIAAoAvQCIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQfQCahD4IwsgAEEIahCBKgsLKgACQAJAAkAgACgCAA4GAgICAgEAAQsgAEEEahC8KgsPCyAAQQRqEN47C2QBAX9BIEEIEK02IgJFBEBBCEEgEKM9AAsgAiABKQMANwMAIAJBGGogAUEYaikDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAIABBnN7CADYCBCAAIAI2AgALXwEEfyAAIAEoAgQiBCABKAIAIgJrENgtIAAoAgghAyACIARHBEAgACgCBCEFA0AgAyAFaiACLQAAOgAAIANBAWohAyACQQFqIgIgBEcNAAsgASACNgIACyAAIAM2AggLYgEBfyAAKAIAIgAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQ+CMLIABBDGoiARDDJyABEOo7AkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLYQECfwJAIAAoAgAiAUEBRw0AIAAoAgQNACAAKAIIIQEgACgCDCICBEADQCABKAIUIQEgAkEBayICDQALCyAAQgA3AgggACABNgIEQQEhASAAQQE2AgALIABBBGpBACABGwtnACAAIAEoAiQ2AiQgACABLwEoOwEoIAAgASkCFDcCFCAAIAIpAgA3AgggACABKQIANwIAIABBHGogAUEcaikCADcCACAAQRBqIAJBCGooAgA2AgAgAUEIaiIAEKInIABBBEEEEOAeC2EBAX8gAEE0ahC0DAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIAAQkCkgACgCQCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEFAaxD7HgsLWAEBfyMAQRBrIgMkACABBEAgACABQQN0aiEBA0AgAyAALQAAOgAPIAIgA0EPakEBELsJIABBBGooAgBBCGogAhDZCiAAQQhqIgAgAUcNAAsLIANBEGokAAthAQF/IABBNGoQvgwCQCAAKAJMIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBzABqEPseCyAAENIoIAAoAkAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBQGsQ+x4LC2EBAX8gAEE0ahDDDAJAIAAoAkwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEHMAGoQ+x4LIAAQ1iggACgCQCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEFAaxD7HgsLXAEBfyMAQRBrIgMkACADIAE2AgggAyACNgIMIAAgASACKAIIQQFrQXhxakEIaiACKAIUEQAAIAEgASgCACIAQQFrNgIAIABBAUYEQCADQQhqELsjCyADQRBqJAALWwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCVBEEACAAKAIUQQhqKAIQaiAAKAIgQQhqKAIQakHEAGohASAAKAIsIgAEfyABIABBCGooAhBqBSABCwtjAQF/IwBBMGsiAiQAIAJBAjYCECACQfirhgE2AgwgAkIBNwIYIAJBOzYCKCACIAAoAgA2AiwgAiACQSRqNgIUIAIgAkEsajYCJCABKAIAIAEoAgQgAkEMahDLCiACQTBqJAALTQECfgJAIAIgBIVCAFMNACADQgF8IgNCAVYgBCADUK18IgNCAFIgA1AbDQAgACABNwMQIAAgAjcDGEIBIQYLIAAgBjcDACAAIAU3AwgLYAECfyMAQTBrIgEkACABIAAoAiAiAjYCKCABIAApAwg3AyAgASAAKQMANwMYIAEgACkDGDcDECABIAApAxA3AwggASACIAAoAiRBA3RqNgIsIAFBCGoQ4CcgAUEwaiQAC1wBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQ9RgPCyAEIAQoAggiAUEBajYCCCABQQBOBEAgACAENgIMIAAgAzYCCCAAIAI2AgQgAEGAiIgBNgIADwsAC2ABAX8gACgCACIAKAIUIgEEQCAAKAIYIAEoAgwRAwALIAAoAiAiAQRAIAAoAiQgASgCDBEDAAsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBMEEEEPg6CwtgAQN/IwBBIGsiAiQAIAIgACgCACIDKAIEIgQ2AgQgASgCACAERwRAIAJBADYCCCACQQRqIAEgAkEIakHMoMMAEPUqAAsgACABKAIINgIEIAMgASgCBDYCCCACQSBqJAALZgEBfyMAQRBrIgIkACACIAAoAgAiADYCDCABQfi9wwBBiL7DACAAQQxqQci9wwBBlr7DACAAQRBqQdi9wwBBo77DACAAQRJqQdi9wwBBsL7DACACQQxqQei9wwAQsRYgAkEQaiQAC1sBBH8gACgCCCICKAIAIAAoAhAiAyAAKAIMIgRqIgVrIAFJBEAgAiAFIAFBAUEBEMUoCyABIARqIQEgAwRAIAIoAgQiAiABaiACIARqIAP8CgAACyAAIAE2AgwLYgECfyMAQRBrIgIkACACQQRqIAFBAEEEQQgQoBggAigCCCEBIAIoAgRBAUYEQCABIAIoAgxB3P3FABD9LwALIAIoAgwhAyAAQQA2AgggACADNgIEIAAgATYCACACQRBqJAALWwECfyAAKAIIIgIEQCAAKAIEQQxqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPgjCyAAQQxrIgEQwycgARDqOyAAQRRqIQAgAkEBayICDQALCwtiAgF/AX4CQCABKQMAQgZ9IgRCAVgEQCAEp0EBaw0BQdTUzQBBC0GU1s0AEMskAAsgACABIAJBABD4FA8LIAEgASgCSCIDIAMgAiACIANLGyICazYCSCAAIAFBCGogAhDdDgtUAQF/QYAQQQIQrTYiAgRAIAJBAEGAEPwLACAAQgM3AwAgAEIANwJEIAAgAjYCQCAAQcwAakEAOgAAIABBwAAgAa3DeadrOgBNDwtBAkGAEBCjPQALYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJB0PfOADYCECACQgE3AhwgAkGMCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAthAQF/IwBBMGsiAiQAIAIgADYCDCACQQE2AhQgAkHQ984ANgIQIAJCATcCHCACQY0INgIsIAIgAkEoajYCGCACIAJBDGo2AiggASgCACABKAIEIAJBEGoQywogAkEwaiQAC2EBAX8jAEEwayICJAAgAiAANgIMIAJBATYCFCACQdD3zgA2AhAgAkIBNwIcIAJBjgg2AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCiACQTBqJAALYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJB0PfOADYCECACQgE3AhwgAkGPCDYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAtOAQF/IABBBGohAEF/IAIgAkEASBtBAWohAgNAIAIEQCACQQFrIQIgAC0AACABKAIAbCADaiEDIAFBBGohASAAQQRqIQAMAQsLIANBA3YLZQACQAJAAkAgAkEFaw4CAQIACyADpyAAKAAAQbHz3fF5bHNBICABa3YPCyAAKQAAQoCAgNjLm++NT34gA4VBwAAgAWutiKcPCyAAKQAAQoCA7PzLm++NT34gA4VBwAAgAWutiKcLYQEBfyMAQTBrIgIkACACIAA2AgwgAkEBNgIUIAJBuMzRADYCECACQgE3AhwgAkH7CjYCLCACIAJBKGo2AhggAiACQQxqNgIoIAEoAgAgASgCBCACQRBqEMsKIAJBMGokAAtbAQF+QQFCACACIAMgBBDfE0ECQgRCBUIGIABBgYDAAEkbIABBgYAESRsiBUIEfSACIAMgBBDfEyAFp0ECdCAAQQFrrSACIAMgBBDfE0EBIAGtIAIgAyAEEN8TC2MBAX8jAEFAaiIEJAAgBEIBNwIwIARBATsBOCAEQQE6ADwgBEEAOgA6IARBADYCKCAEQQA2AiAgBEEANgIYIARBADYCECAEQQA2AgggACABIAIgAyAEQQhqEIYBIARBQGskAAtiAQJ/IwBBEGsiAiQAIAJBBGogAUEAQQRBCBCgGCACKAIIIQEgAigCBEEBRgRAIAEgAigCDEGQnoIBEP0vAAsgAigCDCEDIABBADYCCCAAIAM2AgQgACABNgIAIAJBEGokAAtaAQJ/IAIgAWsiA0EEdiIEIAAoAgAgACgCCCICa0sEQCAAIAIgBEEQQRAQ3iggACgCCCECCyADBEAgACgCBCACQQR0aiABIAP8CgAACyAAIAAoAgggBGo2AggLXgICfwF+IwBBIGsiASQAIAFBCGpBtMiEASgCACICNgIAIAFBrMiEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakGIyYQBKAIAIgI2AgAgAUGAyYQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQZTJhAEoAgAiAjYCACABQYzJhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBrMmEASgCACICNgIAIAFBpMmEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakHQyYQBKAIAIgI2AgAgAUHIyYQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQfTJhAEoAgAiAjYCACABQezJhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBjMqEASgCACICNgIAIAFBhMqEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakGYyoQBKAIAIgI2AgAgAUGQyoQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC14CAn8BfiMAQSBrIgEkACABQQhqQbDKhAEoAgAiAjYCACABQajKhAEpAgAiAzcDACABQRhqIAI2AgAgASADNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALXgICfwF+IwBBIGsiASQAIAFBCGpBvMqEASgCACICNgIAIAFBtMqEASkCACIDNwMAIAFBGGogAjYCACABIAM3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAteAgJ/AX4jAEEgayIBJAAgAUEIakHUyoQBKAIAIgI2AgAgAUHMyoQBKQIAIgM3AwAgAUEYaiACNgIAIAEgAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2sBAX8jAEHgAGsiAiQAIAJBADsBXCACQQA2AlggAkEANgJAIAJBADYCNCACIAE2AjAgAkEAOgAkIAJCBDcCHCACQgA3AhQgAkKAgICAwAA3AgwgAkEANgIEIAAgAkEEahDNHCACQeAAaiQAC14BAX8gACgCACIAKAIIIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQhqEIUdCyAAQRBqEJMnAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQTBBCBD4OgsLXQECfyAAKAIAIgFBfyABKAIEIgIgAkEBRhs2AgQCQCACQQFHDQAgAUEBNgIEIAEoAgBBAUcNACABIAAoAgQiACgCCEEBa0F4cWpBCGoiAUUNACABIAAoAiwRAwALC1sBAn8gASgCECIDIAEoAghGBEAgAUEIakGchIcBEJAoCyABKAIMIANBDGxqIgQgAikCADcCACAEQQhqIAJBCGooAgA2AgAgASADQQFqNgIQIAAgAUHcAPwKAAALYAEDfyMAQRBrIgIkACACQQhqIAEQ4x0gAigCDCEDIAIoAgghBEEIQQQQrTYiAUUEQEEEQQgQoz0ACyABIAQ2AgAgASADNgIEIABB1JiHATYCBCAAIAE2AgAgAkEQaiQAC2IBA38jAEEQayICJAAgAkEIaiABQQAQ5x0gAigCDCEDIAIoAgghBEEIQQQQrTYiAUUEQEEEQQgQoz0ACyABIAQ2AgAgASADNgIEIABBhJmHATYCBCAAIAE2AgAgAkEQaiQAC2ABA38jAEEQayICJAAgAkEIaiABEOYdIAIoAgwhAyACKAIIIQRBCEEEEK02IgFFBEBBBEEIEKM9AAsgASAENgIAIAEgAzYCBCAAQcyZhwE2AgQgACABNgIAIAJBEGokAAuEBAEJfyMAQSBrIgQkACABKAIIIQIgASgCBCEDIAQgASgCADYCGCAEIAM2AhQgBCADNgIQIAQgAyACQcgAbGo2AhwgBEEIaiEIIARBEGohBSMAQfAAayIBJAAjAEEQayIDJAAgAyACNgIIIAJBgICAgAJPBEBB2OCHAUErIANBD2pByOCHAUGE4YcBENUeAAsgA0EEIAJBAnQgA0EIahDAISADKAIEIQIgAUEIaiIGIAMoAgA2AgAgBiACNgIEIANBEGokACABKAIMIQYgASgCCCEDIAFBGGogBUEIaikCADcDACABIAUpAgA3AxAgAUEANgIgAkACQAJAIAEoAhQiAiABKAIcRg0AIANBCGohBQNAIAEgAkHIAGo2AhQgAigCNCIHQYCAgIB4Rg0BIAFBOGoiCSACQTT8CgAAIAFBMGoiCiACQUBrKQMANwMAIAEgAikDODcDKEHQAEEIEK02IgJFDQIgAkKBgICAEDcDACACQQhqIAlBNPwKAAAgAiAHNgI8IAIgASkDKDcDQCACQcgAaiAKKQMANwMAIAEgASgCICIHQQFqNgIgIAUgB0ECdGogAjYCACABKAIUIgIgASgCHEcNAAsLIAFBEGoQ0BwgCCAGNgIEIAggAzYCACABQfAAaiQADAELQQhB0AAQoz0ACyAAIAQpAwg3AwAgBEEgaiQAC2EBAX8jAEEwayICJAAgAiAANgIMIAJBATYCFCACQcjzhwE2AhAgAkIBNwIcIAJBoh02AiwgAiACQShqNgIYIAIgAkEMajYCKCABKAIAIAEoAgQgAkEQahDLCiACQTBqJAALYQIBfwFvIwBBEGsiBCQAIAEgAiADKAIAJQEQFyEFEN8SIgEgBSYBIARBCGoQzi1BASEDIAACfyAEKAIIQQFxBEAgBCgCDAwBC0EAIQMgAQs2AgQgACADNgIAIARBEGokAAtlAgF/AW8jAEEQayIEJAAgASgCACUBIAIgAxAgIQUQ3xIiASAFJgEgASECIARBCGoQzi1BASEBIAACfyAEKAIIQQFxBEAgBCgCDAwBC0EAIQEgAgs2AgQgACABNgIAIARBEGokAAtkAgF/AW8jAEEQayIDJAAgASgCACUBIAIoAgAlARBHIQQQ3xIiASAEJgEgA0EIahDOLUEBIQIgAAJ/IAMoAghBAXEEQCADKAIMDAELQQAhAiABCzYCBCAAIAI2AgAgA0EQaiQAC14BAn8jAEEgayIDJAAgACgCACIEEJw+IQAgAyACNgIEIAMgADYCACAAIAJHBEAgA0EANgIIQQAgAyADQQRqIANBCGpB5KuIARCvKwALIAEgAiAEJQEQWCADQSBqJAALZAECfyMAQSBrIgYkACABRQRAQfCsiAFBMhCXPQALIAZBFGoiByABIAMgBCAFIAIoAhARBwAgBkEIaiAHQeCsiAEQmCEgBiAGKAIIIAYoAgwQtTYgACAGKQMANwIAIAZBIGokAAtYAQJ/IAAgASgCACIDQQBHENctIAAoAgghAiAAIAMEfyAAKAIEIAJBBHRqIgAgAzYCACAAIAEpAgQ3AgQgAEEMaiABQQxqKAIANgIAIAJBAWoFIAILNgIIC78BAQN/AkACQAJAQQEgACgCACIBQf////8HaiABQYCAgIB4TRtBAWsOAgABAgsgACgCFCEBIAAoAhgiAigCACIDBEAgASADEQMACyACKAIEIgMEQCABIAMgAigCCBD4OgsgACgCHCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEcahD4IwsgABCPMA8LIAAoAgQhASAAKAIIIgAoAgAiAgRAIAEgAhEDAAsgACgCBCICRQ0AIAEgAiAAKAIIEPg6CwvkBQEHfyMAQRBrIgUkACAALQDcASEHIABBAToA3AEgBSAANgIMIwBBEGsiBiQAIABBCGoiAikDAEIDUgRAIAIoApgBIgEgASgCACIBQQFrNgIAIAFBAUYEQCACQZgBahCXFQsgAigCnAEiASABKAIAIgFBAWs2AgAgAUEBRgRAIAJBnAFqEPgjCyAGIAJB0ABqIgEgAigCXBD4GCABEOk7IAIoAoABQYCAgIB4RwRAIAJBgAFqEN47CyACKAKMAUGAgICAeEcEQCACQYwBahDqOwsCQCACKQMAQgJRDQAgAigCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAkE8ahCXFQsCQCACKAJAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBQGsQ2x4LAkAgAigCAEUEQCACKAIQIgFBhAFJDQEgARDyHwwBCyACQRBqEN47IAIoAhwiASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBHGoQnScLIAIoAjBBgICAgHhHBEAgAkEwaiIBEIEjIAFBBEEIEOAeCyACKAJEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAJBxABqEIEsCwJAAkACQEEBIAIoAmAiAUH/////B2ogAUGAgICAeE0bQQFrDgIAAQILIAIoAnQhASACKAJ4IgQoAgAiAwRAIAEgAxEDAAsgBCgCBCIDBEAgASADIAQoAggQ+DoLIAIoAnwiASABKAIAIgFBAWs2AgAgAUEBRgRAIAJB/ABqEPgjCyACQeAAaiIBKAIAQYCAgIB4Rg0BIAEQ0C4gARDqOwwBCyACKAJkIQEgAigCaCIEKAIAIgMEQCABIAMRAwALIAQoAgQiA0UNACABIAMgBCgCCBD4OgsgAkGoAWoiAhDeIyACEOA7CyAGQRBqJAAgAEIDNwMIAkAgBw0AIAAgACgCACIAQQFrNgIAIABBAUcNACAFQQxqELYfCyAFQRBqJAAL9AEBBH8jAEEQayIDJAAgAC0AdCEEIABBAToAdCADIAA2AgwCQCAAQQhqIgEoAgBFDQACQAJAIAEtAEwOBAACAgECCyABQUBrEN47IAEoAjwiAiACKAIAIgJBAWs2AgAgAkEBRw0BIAFBPGoQnScMAQsCQAJAIAEtADgOBAACAgECCyABQRhqEN47IAEoAjAiAiACKAIAIgJBAWs2AgAgAkEBRgRAIAFBMGoQnScLIAFBJGoQ3jsMAQsgAUE0ahCuLAsgAEIANwMIAkAgBA0AIAAgACgCACIAQQFrNgIAIABBAUcNACADQQxqELcfCyADQRBqJAALkwEBA38jAEEQayICJAAgAC0AVCEDIABBAToAVCACIAA2AgwCQCAAQQhqIgEoAgBFDQACQAJAIAEtACwOBAACAgECCyABKAIQIgFBhAFJDQEgARDyHwwBCyABQShqEK4sCyAAQgA3AwgCQCADDQAgACAAKAIAIgBBAWs2AgAgAEEBRw0AIAJBDGoQuB8LIAJBEGokAAvjAQECfyMAQeAAayICJAACQAJAIAFFBEAjAEHwAGsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQegA/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HwAEEIEPg6CyACIAFBEGpB4AD8CgAAIAFB8ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACEJsnDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ6SoLIAJB4ABqJAAPCxCYPQAL4QEBAn8jAEFAaiICJAACQAJAIAFFBEAjAEHQAGsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQcgA/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HQAEEIEPg6CyACIAFBEGpBwAD8CgAAIAFB0ABqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACEP8oDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ6yoLIAJBQGskAA8LEJg9AAvjAQECfyMAQcACayICJAACQAJAIAFFBEAjAEHQAmsiASQAAkACQCAABEAgAEEIayIDKAIAQQFHDQEgAUEIaiAAQcgC/AoAACADQQA2AgACQCADQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgA0HQAkEIEPg6CyACIAFBEGpBwAL8CgAAIAFB0AJqJAAMAgsQmD0AC0H9gsMAQT8Qlz0ACyACENgSDAELIABFDQEgAEEIayIAIAAoAgBBAWsiATYCACACIAA2AgAgAQ0AIAIQ7SoLIAJBwAJqJAAPCxCYPQALkAEBA38gACgCACEBAkADQCABKAIEIQADQCAAQX9GDQEgAEEASA0CIAEgAEEBaiABKAIEIgIgACACRhs2AgQgACACRyACIQANAAsLIAEPCyMAQSBrIgAkACAAQQE2AgQgAEGgq4gBNgIAIABCATcCDCAAQoybw4DwKDcDGCAAIABBGGo2AgggAEGUm8MAEO8sAAteAQF/IwBBMGsiAiQAIAIgATYCDCACIAA2AgggAkECNgIUIAJBhLzDADYCECACQgE3AhwgAkHMATYCLCACIAJBKGo2AhggAiACQQhqNgIoIAJBEGoQoRUgAkEwaiQAC3IBAX9BASECAkAgACABQbSGxABBBBDBLg0AIAAgAUG4hsQAQQUQwS4NACAAIAFBvYbEAEECEMEuDQAgACABQb+GxABBAxDBLg0AIAAgAUHChsQAQQMQwS4NAEEAQQIgACABQcWGxABBBBDBLhshAgsgAgtQAQJ/IwBBEGsiAiQAIAJBBGogABCHIyACKAIEIgAoAggiAyABTQRAIAEgA0HwxMwAEMMhAAsgACgCBCACQQRqEPwqIAJBEGokACABQQZ0agtcAQF/IwBBEGsiAiQAAkACQCABRQRAIAIgABD4FyACEP8qDAELIABFDQEgAiAAQQhrIgA2AgAgACAAKAIAQQFrIgA2AgAgAA0AIAIQ1iILIAJBEGokAA8LEJg9AAtXACAAIAAoAoAIIANqNgKACCACIANPBEAgAwRAA0AgACABLQAAQQJ0aiICIAIoAgBBAWo2AgAgAUEBaiEBIANBAWsiAw0ACwsPCyADIAJBvOrMABCwOwALbgIBfwJ+IwBBEGsiAyQAIANB8LHNABClKyADKQMAIQQgAykDCCEFIABBCGpBiLLNACkDADcDACAAQYCyzQApAwA3AwAgAEEANgIoIAAgAjYCJCAAIAE2AiAgACAFNwMYIAAgBDcDECADQRBqJAALXgECfyMAQSBrIgIkACABQf8BcSIDQQFGIANBB0ZyRQRAIAAgAToAKyACQSBqJAAPCyACQQA2AhggAkEBNgIMIAJB8LHOADYCCCACQgQ3AhAgAkEIakH4sc4AEO8sAAtzAgF/An4jAEEQayICJAAgAkG8yP4AEKUrIAIpAwAhAyACKQMIIQQgAEEIakHQyP4AKQMANwMAIABByMj+ACkDADcDACAAIAE6ACwgAEEANgIoIABCgICAgIABNwMgIAAgBDcDGCAAIAM3AxAgAkEQaiQAC2wCAX8CfiMAQSBrIgIkACACQQhqIAAgASgCEBEAACACQRBqIAIoAggiACACKAIMKAIMEQAAIAIpAxghAyACKQMQIQQgAkEgaiQAIABBACAEQtPY0/j95vaSSIUgA0Ki2J6I4aDq6cwAhYRQGwtsAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBELH2fTn3sS2nHeFIANCjbLOlIzKkuanf4WEUBsLVgECfyMAQRBrIgMkACADIAIoAgA2AgggAyACKAIEIgQ2AgAgAyAENgIEIAMgBCACKAIIQQxsajYCDCABQQhqIAMQriYgACABQdwA/AoAACADQRBqJAALYgEBfyMAQRBrIgIkACACIAEQyi8gAiACKAIANgIMIAJBDGoQ0R8hASAAQgE3AwAgACACKAIIQcCEPW6tIAI1AgQgAaxCgKMFfnxC6Ad+fEKA6My6sZAOfTcDCCACQRBqJAALVwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACAAKAIUQQhqKAIQaiAAKAIgQQhqKAIQaiEBIAAoAiwiAAR/IAEgAEEIaigCEGoFIAELC9IBAQh/IwBBIGsiAiQAIAIgARDcOyACQQhqIQMCQCACKAIEIgEgAigCACIEQQdqQXhxIARrIgVJBEBBASEIQQghCQwBCyAEIAVqIgkgASAFayIBQXhxaiEIIAFBB3EhByABQQN2IQYgBSEBCyADIAc2AhQgAyAINgIQIAMgBjYCDCADIAk2AgggAyABNgIEIAMgBDYCACACKAIcIAIoAgxyBEBBtKWHAUE4QeylhwEQnykACyACKAIQIQEgACACKAIUNgIEIAAgATYCACACQSBqJAALXwECfyAALQA8QR1GBEAgACgCKCICBEAgACgCJCEDIAJBzAFsIQIgACgCQCABbCEAA0AgAyAAEIcXIANBzAFqIQMgAkHMAWsiAg0ACwsPC0HIpocBQShBqKeHARCfKQALWQEBfyABKAIAIgRBAXEEQCAAIAEgBCAEIAIgAxD1GA8LIAQgBCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQYCIiAE2AgAPCwALUwECfyACIAFrIgNBAnYiBCAAKAIAIAAoAggiAmtLBEAgACACIAQQ3yggACgCCCECCyADBEAgACgCBCACQQJ0aiABIAP8CgAACyAAIAIgBGo2AggLWgEBfyMAQRBrIgIkACAAKAIAIgAEQCACIAA2AgwgAEEIakEBIAEQ8BcgACAAKAIAQQFrIgA2AgAgAEUEQCACQQxqELIaCyACQRBqJAAPC0GMqIgBQRwQlz0AC1oBAX8jAEEQayICJAAgACgCACIABEAgAiAANgIMIABBCGpBACABEPAXIAAgACgCAEEBayIANgIAIABFBEAgAkEMahCyGgsgAkEQaiQADwtBjKiIAUEcEJc9AAtjAgJ+AX8gAET////////fPyAApqAiAL0iAUI0iKdB/w9xIgNBsghNBHxCf0KAgICAgICAgIB/QoCAgICAgIB4IANB/wdrrYcgA0H/B0kbIgIgAkJ/hSABg1AbIAGDvwUgAAsLZAECfyMAQRBrIgIkACABQQJ0IQMCQCABQf////8DTQRAIANBBBDRNA0BCyACIAM2AgwgAkEANgIIQdicxABBKyACQQhqQcicxABBtJ3EABDVHgALIAAgA0EEEPg6IAJBEGokAAtQAQJ/IwBBEGsiASQAIAFBBGogABCHIyABKAIEKAIMIgAgACgCACICQQFqNgIAIAJBAEgEQAALIAFBBGoQgCtBACAAEJosQQhqIAFBEGokAAtSAQJ/IwBB0ABrIgQkACAEQQhqIgUQ0yYgBSABIAIQ3QsCQCAFELQSpyADRgRAIABBBDoAAAwBCyAEQQo6ADggACAEQThqEIspCyAEQdAAaiQAC1QAAkAgAygCGEEDa0F+TwRAA0AgAkUNAiAAIAEoAgBBCHY2AgAgAEEEaiEAIAFBBGohASACQQFrIQIMAAsACyACQQJ0IgJFDQAgACABIAL8CgAACwtPAQF/IAFFIAAgAhChH0GIf0tyRQRAIAAoAhQgAWsiAyAAKAIMSQRAIABBAToAHEEADwsgACgCECADSwRAIAAgAzYCEAsgACADNgIUCyADC1cBAn8jAEEQayICJAAgASgCECgCGCIBBH8gAkEEaiABIAEQuCoQnQkgAigCDCEDQQAgAigCCCACKAIEGwVBAAshASAAIAM2AgQgACABNgIAIAJBEGokAAvhAwIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEEQayIDJAACQCABKAIcIgIgASgCIEcEQAJAAkACQAJ+AkAgASgCBEUNACACIAEoAhRPDQIgASgCCCABKAIQIAJqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIAJBAWo2AhxCAAwBCyABIAJBAWo2AhwCQCABKAIAKAIQIAJBBHRqIgIoAgQgAigCAHIEQCADQQRqQcYAQQBBAUEBEKAYIAMoAgghASADKAIEQQFHDQEgASADKAIMQeCtgAEQ/S8ACyABKAIkKQMAIghQDQMgAikDCCIJQoCAgICAgICAgH9RIAhCf1FxDQQgCSAIfyEIQgEMAQsgAygCDCICQfSxgAFBxgD8CgAAIAQoAgBBk4CAgHhHBEAgBBCIEQsgBELGADcCDCAEIAGtIAKtQiCGhDcCBCAEQYaAgIB4NgIAQgILIQkgBiAINwMIIAYgCTcDAAwEC0H0p4ABQSBBlKiAARCfKQALQeSxgAEQ4isAC0HksYABEOYrAAsgBkIDNwMACyADQRBqJAACQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQxCcgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHMtMIANgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuUBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJBMGogASgCJCACKAIIIAIoAgwQggMgAigCPCEBIAIpAjQhCQJ/IAIoAjAiA0GTgICAeEcEQCACKAJADAELIAIgATYCGCACIAk3AxAgAkEwaiIBIAJBEGoiAxCZGiACKAIwDQIgAkECNgI0IAJB0LCAATYCMCACQgE3AjwgAkGvEDYCTCACIAJByABqNgI4IAIgAzYCSCACQSBqIAEQmQ4gAikCICEJIAIoAighAUGCgICAeCEDIAIoAiwLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQM4IQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuyBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASADEK0qIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQ4BkgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHgsIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAubBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHgAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASADEK0qIAJBQGsgASgCJCACKAIAIAIoAgQQ+QIgAkEgaiIDIAJBzABqKQIANwMAIAIgAikCRDcDGAJ+IAIoAkAiAUGTgICAeEcEQCACKQMYIQggAikDIAwBCyACQRBqIAMoAgA2AgAgAiACKQMYNwMIIAJBQGsiASACQRhqEJkaIAIoAkANAiACQQI2AkQgAkHQsIABNgJAIAJCATcCTCACQa8QNgJcIAIgAkHYAGo2AkggAiACQQhqNgJYIAJBMGogARCZDiACKQIwIQhBgoCAgHghASACKQI4CyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDSCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHgAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALngQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB4ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxDaKyACQUBrIAEoAiQgAigCACACKAIEEPkCIAJBIGoiAyACQcwAaikCADcDACACIAIpAkQ3AxgCfiACKAJAIgFBk4CAgHhHBEAgAikDGCEIIAIpAyAMAQsgAkEQaiADKAIANgIAIAIgAikDGDcDCCACQUBrIgEgAkEYahCZGiACKAJADQIgAkECNgJEIAJB0LCAATYCQCACQgE3AkwgAkGvEDYCXCACIAJB2ABqNgJIIAIgAkEIajYCWCACQTBqIAEQmQ4gAikCMCEIQYKAgIB4IQEgAikCOAshCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgIMAgsgBkIDNwMADAILIAIpA0ghCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQjywgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEJkkIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB+LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALnwQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEgAxCtKiACQShqIAEoAiQgAigCACACKAIEEIIDIAIoAjQhASACKQIsIQkCfyACKAIoIgNBk4CAgHhHBEAgAigCOAwBCyACIAE2AhAgAiAJNwMIIAJBKGoiASACQQhqIgMQxCcgAigCKA0CIAJBAjYCLCACQeiwgAE2AiggAkICNwI0IAJBsBA2AkwgAkHMtMIANgJIIAJBrxA2AkQgAiACQUBrNgIwIAIgAzYCQCACQRhqIAEQmQ4gAikCGCEJIAIoAiAhAUGCgICAeCEDIAIoAiQLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQMwIQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAv2BAIHfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIsIQQjAEGQAWsiAiQAAkAgASgCHCIDIAEoAiBHBEACQAJ+AkAgASgCBEUNACADIAEoAhRPDQIgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwBCyABIANBAWo2AhwgAiABIAMQrSogASgCKCEDIAEoAiQhByACKAIAIQEgAiACKAIEIgg2AgwgAiABNgIIIAJBEGogASAIIAcsAAAQwgECfiACKAIQQQFGBEAgAkHQAGogAkEkaigCADYCACACQcgAaiACQRxqKQIANwMAIAIgAikCFDcDQCACQfgAakHkroABKAIANgIAIAJB3K6AASkCADcDcCACQQM2AlwgAkHEroABNgJYIAJCAjcCZCACQa4QNgKMASACQcwBNgKEASACIAJBgAFqNgJgIAIgAkHwAGoiATYCiAEgAiACQQhqNgKAASACQTBqIAJB2ABqEJkOIAEQqgwgAkFAaxCIESACKQI4IQlBgoCAgHghASACKQIwDAELIAJB2ABqIAIpAxgiCSADLQAAEI0QQgEgAigCWCIBQZOAgIB4Rg0BGiACKQJkIQkgAikCXAshCiAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAo3AgQgBCABNgIAQgILIQogBiAJNwMIIAYgCjcDAAwCC0H0p4ABQSBBlKiAARCfKQALIAZCAzcDAAsgAkGQAWokAAJAIAUpAwgiCUIDUSAJQgJRckUEQCAAIAUpAxA3AwggACAJNwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQjywgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEMQnIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJBzLTCADYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAAL+QQCB38CfiMAQSBrIgUkACAFQQhqIQYgASgCLCEEIwBBkAFrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACfgJAIAEoAgRFDQAgAyABKAIUTw0CIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAQsgASADQQFqNgIcIAIgASgCACADEI8sIAEoAighAyABKAIkIQcgAigCACEBIAIgAigCBCIINgIMIAIgATYCCCACQRBqIAEgCCAHLAAAEMIBAn4gAigCEEEBRgRAIAJB0ABqIAJBJGooAgA2AgAgAkHIAGogAkEcaikCADcDACACIAIpAhQ3A0AgAkH4AGpB5K6AASgCADYCACACQdyugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEIajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAikCOCEJQYKAgIB4IQEgAikCMAwBCyACQdgAaiACKQMYIgkgAy0AABCNEEIBIAIoAlgiAUGTgICAeEYNARogAikCZCEJIAIpAlwLIQogBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAKNwIEIAQgATYCAEICCyEKIAYgCTcDCCAGIAo3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBkAFqJAACQCAFKQMIIglCA1EgCUICUXJFBEAgACAFKQMQNwMIIAAgCTcDAAwBCyAAQgI3AwALIAVBIGokAAuiBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASgCACADENorIAJBKGogASgCJCACKAIAIAIoAgQQggMgAigCNCEBIAIpAiwhCQJ/IAIoAigiA0GTgICAeEcEQCACKAI4DAELIAIgATYCECACIAk3AwggAkEoaiIBIAJBCGoiAxDgGSACKAIoDQIgAkECNgIsIAJB6LCAATYCKCACQgI3AjQgAkGwEDYCTCACQeCwgAE2AkggAkGvEDYCRCACIAJBQGs2AjAgAiADNgJAIAJBGGogARCZDiACKQIYIQkgAigCICEBQYKAgIB4IQMgAigCJAshByABrSAHrUIghoQhCCAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCDcCDCAEIAk3AgQgBCADNgIAQgIMAgsgBkIDNwMADAILIAIpAzAhCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB0ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC58EAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABIAMQrSogAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEJkkIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB+LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALsgQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEMQnIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJBzLTCADYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAAL+QQCB38CfiMAQSBrIgUkACAFQQhqIQYgASgCLCEEIwBBkAFrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACfgJAIAEoAgRFDQAgAyABKAIUTw0CIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAQsgASADQQFqNgIcIAIgASgCACADENorIAEoAighAyABKAIkIQcgAigCACEBIAIgAigCBCIINgIMIAIgATYCCCACQRBqIAEgCCAHLAAAEMIBAn4gAigCEEEBRgRAIAJB0ABqIAJBJGooAgA2AgAgAkHIAGogAkEcaikCADcDACACIAIpAhQ3A0AgAkH4AGpB5K6AASgCADYCACACQdyugAEpAgA3A3AgAkEDNgJcIAJBxK6AATYCWCACQgI3AmQgAkGuEDYCjAEgAkHMATYChAEgAiACQYABajYCYCACIAJB8ABqIgE2AogBIAIgAkEIajYCgAEgAkEwaiACQdgAahCZDiABEKoMIAJBQGsQiBEgAikCOCEJQYKAgIB4IQEgAikCMAwBCyACQdgAaiACKQMYIgkgAy0AABCNEEIBIAIoAlgiAUGTgICAeEYNARogAikCZCEJIAIpAlwLIQogBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAKNwIEIAQgATYCAEICCyEKIAYgCTcDCCAGIAo3AwAMAgtB9KeAAUEgQZSogAEQnykACyAGQgM3AwALIAJBkAFqJAACQCAFKQMIIglCA1EgCUICUXJFBEAgACAFKQMQNwMIIAAgCTcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQxCcgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHMtMIANgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQmSQgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkH4sIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuiBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAIgASgCACADENorIAJBKGogASgCJCACKAIAIAIoAgQQggMgAigCNCEBIAIpAiwhCQJ/IAIoAigiA0GTgICAeEcEQCACKAI4DAELIAIgATYCECACIAk3AwggAkEoaiIBIAJBCGoiAxCZJCACKAIoDQIgAkECNgIsIAJB6LCAATYCKCACQgI3AjQgAkGwEDYCTCACQfiwgAE2AkggAkGvEDYCRCACIAJBQGs2AjAgAiADNgJAIAJBGGogARCZDiACKQIYIQkgAigCICEBQYKAgIB4IQMgAigCJAshByABrSAHrUIghoQhCCAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCDcCDCAEIAk3AgQgBCADNgIAQgIMAgsgBkIDNwMADAILIAIpAzAhCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB0ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC6IEAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEMQnIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJBzLTCADYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALsgQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEJkkIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB+LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALtQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEoAgAgAxCPLCACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEOAZIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB4LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALngQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB4ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQUBrIAEoAiQgAigCACACKAIEEPkCIAJBIGoiAyACQcwAaikCADcDACACIAIpAkQ3AxgCfiACKAJAIgFBk4CAgHhHBEAgAikDGCEIIAIpAyAMAQsgAkEQaiADKAIANgIAIAIgAikDGDcDCCACQUBrIgEgAkEYahCZGiACKAJADQIgAkECNgJEIAJB0LCAATYCQCACQgE3AkwgAkGvEDYCXCACIAJB2ABqNgJIIAIgAkEIajYCWCACQTBqIAEQmQ4gAikCMCEIQYKAgIB4IQEgAikCOAshCSAEKAIAQZOAgIB4RwRAIAQQiBELIAQgCTcCDCAEIAg3AgQgBCABNgIAQgIMAgsgBkIDNwMADAILIAIpA0ghCEIBCyEJIAYgCDcDCCAGIAk3AwALIAJB4ABqJAAMAQtB9KeAAUEgQZSogAEQnykACwJAIAUpAwgiCEIDUSAIQgJRckUEQCAAIAUpAxA3AwggACAINwMADAELIABCAjcDAAsgBUEgaiQAC58EAgZ/An4jAEEgayIFJAAgBUEIaiEGIAEoAighBCMAQdAAayICJAACQAJAAkACfgJAIAEoAhwiAyABKAIgRwRAAkAgASgCBEUNACADIAEoAhRPDQUgASgCCCABKAIQIANqIgdBA3ZqLQAAQf8BcyAHQQdxdkEBcUUNACABIANBAWo2AhxCAAwDCyABIANBAWo2AhwgAiABIAMQrSogAkEoaiABKAIkIAIoAgAgAigCBBCCAyACKAI0IQEgAikCLCEJAn8gAigCKCIDQZOAgIB4RwRAIAIoAjgMAQsgAiABNgIQIAIgCTcDCCACQShqIgEgAkEIaiIDEOAZIAIoAigNAiACQQI2AiwgAkHosIABNgIoIAJCAjcCNCACQbAQNgJMIAJB4LCAATYCSCACQa8QNgJEIAIgAkFAazYCMCACIAM2AkAgAkEYaiABEJkOIAIpAhghCSACKAIgIQFBgoCAgHghAyACKAIkCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDMCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALkQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEgAxCtKiACQTBqIAEoAiQgAigCCCACKAIMEIIDIAIoAjwhASACKQI0IQkCfyACKAIwIgNBk4CAgHhHBEAgAigCQAwBCyACIAE2AhggAiAJNwMQIAJBMGoiASACQRBqIgMQmRogAigCMA0CIAJBAjYCNCACQdCwgAE2AjAgAkIBNwI8IAJBrxA2AkwgAiACQcgAajYCOCACIAM2AkggAkEgaiABEJkOIAIpAiAhCSACKAIoIQFBgoCAgHghAyACKAIsCyEHIAGtIAetQiCGhCEIIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAINwIMIAQgCTcCBCAEIAM2AgBCAgwCCyAGQgM3AwAMAgsgAikDOCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHQAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALtQQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB8ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACQQhqIAEoAgAgAxDaKyACQcgAaiABKAIkIAIoAgggAigCDBD5AiACQShqIgMgAkHUAGopAgA3AwAgAiACKQJMNwMgAn4gAigCSCIBQZOAgIB4RwRAIAIpAyAhCCACKQMoDAELIAJBGGogAygCADYCACACIAIpAyA3AxAgAkHIAGoiASACQSBqEJkkIAIoAkgNAiACQQI2AkwgAkHosIABNgJIIAJCAjcCVCACQbAQNgJsIAJB+LCAATYCaCACQa8QNgJkIAIgAkHgAGo2AlAgAiACQRBqNgJgIAJBOGogARCZDiACKQI4IQhBgoCAgHghASACKQJACyEJIAQoAgBBk4CAgHhHBEAgBBCIEQsgBCAJNwIMIAQgCDcCBCAEIAE2AgBCAgwCCyAGQgM3AwAMAgsgAikDUCEIQgELIQkgBiAINwMIIAYgCTcDAAsgAkHwAGokAAwBC0H0p4ABQSBBlKiAARCfKQALAkAgBSkDCCIIQgNRIAhCAlFyRQRAIAAgBSkDEDcDCCAAIAg3AwAMAQsgAEICNwMACyAFQSBqJAALogQCBn8CfiMAQSBrIgUkACAFQQhqIQYgASgCKCEEIwBB0ABrIgIkAAJAAkACQAJ+AkAgASgCHCIDIAEoAiBHBEACQCABKAIERQ0AIAMgASgCFE8NBSABKAIIIAEoAhAgA2oiB0EDdmotAABB/wFzIAdBB3F2QQFxRQ0AIAEgA0EBajYCHEIADAMLIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQShqIAEoAiQgAigCACACKAIEEIIDIAIoAjQhASACKQIsIQkCfyACKAIoIgNBk4CAgHhHBEAgAigCOAwBCyACIAE2AhAgAiAJNwMIIAJBKGoiASACQQhqIgMQ4BkgAigCKA0CIAJBAjYCLCACQeiwgAE2AiggAkICNwI0IAJBsBA2AkwgAkHgsIABNgJIIAJBrxA2AkQgAiACQUBrNgIwIAIgAzYCQCACQRhqIAEQmQ4gAikCGCEJIAIoAiAhAUGCgICAeCEDIAIoAiQLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQMwIQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAu1BAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHwAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADENorIAJByABqIAEoAiQgAigCCCACKAIMEPkCIAJBKGoiAyACQdQAaikCADcDACACIAIpAkw3AyACfiACKAJIIgFBk4CAgHhHBEAgAikDICEIIAIpAygMAQsgAkEYaiADKAIANgIAIAIgAikDIDcDECACQcgAaiIBIAJBIGoQ4BkgAigCSA0CIAJBAjYCTCACQeiwgAE2AkggAkICNwJUIAJBsBA2AmwgAkHgsIABNgJoIAJBrxA2AmQgAiACQeAAajYCUCACIAJBEGo2AmAgAkE4aiABEJkOIAIpAjghCEGCgICAeCEBIAIpAkALIQkgBCgCAEGTgICAeEcEQCAEEIgRCyAEIAk3AgwgBCAINwIEIAQgATYCAEICDAILIAZCAzcDAAwCCyACKQNQIQhCAQshCSAGIAg3AwggBiAJNwMACyACQfAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAuUBAIGfwJ+IwBBIGsiBSQAIAVBCGohBiABKAIoIQQjAEHQAGsiAiQAAkACQAJAAn4CQCABKAIcIgMgASgCIEcEQAJAIAEoAgRFDQAgAyABKAIUTw0FIAEoAgggASgCECADaiIHQQN2ai0AAEH/AXMgB0EHcXZBAXFFDQAgASADQQFqNgIcQgAMAwsgASADQQFqNgIcIAJBCGogASgCACADEI8sIAJBMGogASgCJCACKAIIIAIoAgwQggMgAigCPCEBIAIpAjQhCQJ/IAIoAjAiA0GTgICAeEcEQCACKAJADAELIAIgATYCGCACIAk3AxAgAkEwaiIBIAJBEGoiAxCZGiACKAIwDQIgAkECNgI0IAJB0LCAATYCMCACQgE3AjwgAkGvEDYCTCACIAJByABqNgI4IAIgAzYCSCACQSBqIAEQmQ4gAikCICEJIAIoAighAUGCgICAeCEDIAIoAiwLIQcgAa0gB61CIIaEIQggBCgCAEGTgICAeEcEQCAEEIgRCyAEIAg3AgwgBCAJNwIEIAQgAzYCAEICDAILIAZCAzcDAAwCCyACKQM4IQhCAQshCSAGIAg3AwggBiAJNwMACyACQdAAaiQADAELQfSngAFBIEGUqIABEJ8pAAsCQCAFKQMIIghCA1EgCEICUXJFBEAgACAFKQMQNwMIIAAgCDcDAAwBCyAAQgI3AwALIAVBIGokAAszACAAAn8gASgCCBpBk4CAgHhBlICAgHggAyABKAIAIAEoAgQgBCgCDBEGABsMAAs2AgAL9gECBX8BfiMAQRBrIgIkAEGyD0EBQQEQjiciBEUEQEHUxoUBELI7AAsgAkEANgIIIAIgAEENdSIBIAFBkANtIgFBkANsayIDQR91IgUgAWogBEENdSIBQfB8bWogAUGQA28iAUEfdmqsQrH1CH4gBUGQA3EgA2oiA0HtAmwgAEEEdkH/A3FqIANBwMaGAWotAABqQQFrrXwgAUEfdUGQA3EgAWoiAEHtAmwgBEEEdkH/A3FqIABBwMaGAWotAABqQQFrrX1CgKMFfjcDACACKQMAIQYgAigCCCEAIAJBEGokACAGIABBAEogBkIAU3GtfEKAowV/pwtYAQJ/AkACQCAAQf//D2tBgoBgSQ0AIAFBA3YhAiABQYA0Tw0BIAJBhNOGAWosAAAiAkUNACABIAJBA3RrIABBDXRyIQMLIAMPCyACQcAGQcTZhgEQwyEAC2ECAn8BbyMAQRBrIgIkACABKAIAJQEQHCEEEN8SIgEgBCYBIAEhAyACQQhqEM4tQQEhASAAAn8gAigCCEEBcQRAIAIoAgwMAQtBACEBIAMLNgIEIAAgATYCACACQRBqJAALYQICfwFvIwBBEGsiAiQAIAEoAgAlARBkIQQQ3xIiASAEJgEgASEDIAJBCGoQzi1BASEBIAACfyACKAIIQQFxBEAgAigCDAwBC0EAIQEgAws2AgQgACABNgIAIAJBEGokAAtYAQJ/IwBBEGsiAiQAIAEtAABBA0cEf0EABSACQQhqIAEoAgQiASgCACABKAIEKAIkEQAAIAIoAgwhAyACKAIICyEBIAAgAzYCBCAAIAE2AgAgAkEQaiQAC1gBAn8jAEEQayICJAAgAS0AAEEDRwR/QQAFIAJBCGogASgCBCIBKAIAIAEoAgQoAhgRAAAgAigCDCEDIAIoAggLIQEgACADNgIEIAAgATYCACACQRBqJAALXAEBfyMAQTBrIgMkACADIAE2AgwgAyAANgIIIANBATYCFCADQcDtiQE2AhAgA0IBNwIcIAMgA0EIaq1CgICAgODjA4Q3AyggAyADQShqNgIYIANBEGogAhDvLAALTgECfyMAQSBrIgIkACACQQhqIAAoAgAiACAAQR91IgNzIANrIAJBFmoQsBAgASAAQX9zQR92QQFBACACKAIIIAIoAgwQgQkgAkEgaiQAC2kBAX8CQAJAAkAgAC0AzAMOBAECAgACCyAAQcADahDkKCAAKAK8AyIBQYQBTwRAIAEQ8h8LIABBqANqEL0oIABBADoAzQMgACgCoAMiAUGEAU8EQCABEPIfCyAAQdABaiEACyAAEKkeCwtZAQF/IwBBEGsiAyQAIAMgAjkDCCADIAEoAiAoAgAgA0EIaiIBQQgQqBoCQCADLQAAQQRHBEAgAyADKQMANwMIIAAgARDQCQwBCyAAQQQ2AgALIANBEGokAAtZAQF/IwBBEGsiAyQAIAMgAjkDCCADIAEoAiAoAgAgA0EIaiIBQQgQpxoCQCADLQAAQQRHBEAgAyADKQMANwMIIAAgARDQCQwBCyAAQQQ2AgALIANBEGokAAtSAQJ/IwBBIGsiASQAIAFBCGogACgCEEEIahCEPCABIAEpAwg3AhggASAAKAIEIgI2AhAgASACIAAoAghBAnRqNgIUIAFBEGoQ3B8gAUEgaiQAC1cBAn8CQAJAIAEEQCABQQhrIgIgAigCAEEBaiIDNgIAIANFDQEgASgCAA0CIAAgAjYCCCAAIAE2AgQgAUF/NgIAIAAgAUEEajYCAA8LEJg9CwALEJk9AAtWAQN/IwBBEGsiAiQAIAAoAgQhASAAQQA2AgQCQCABRQ0AIAIgATYCDCACQQxqIgMQjjUgASABKAIAIgBBAWs2AgAgAEEBRw0AIAMQ6ScLIAJBEGokAAtWAQN/IwBBEGsiAiQAIAAoAhAhASAAQQA2AhACQCABRQ0AIAIgATYCDCACQQxqIgMQjjUgASABKAIAIgBBAWs2AgAgAEEBRw0AIAMQ6ScLIAJBEGokAAtZAQJ/IwBBIGsiAiQAIAJBDGoiAyABQYD5wwBBCxDGLCACIABBAWo2AhggAiAALQAAQQJ0QaCExABqKAIANgIcIAMgAkEYakGM+cMAEOQUENsbIAJBIGokAAuoCAEGfwJAAkACQCAALQAAQQFrDgIBAgALIAAoAgggACgCDCABEKk9DwsjAEHgAGsiAiQAIAIgAEEBaigAADYCCAJAAkACQCABLQALQRhxBEAgAkEANgIMIAJBgO6JATYCICACQgQ3AiwgAiACQQhqIgBBA3KtQoCAgICw9wCENwNQIAIgAEECcq1CgICAgLD3AIQ3A0ggAiAAQQFyrUKAgICAsPcAhDcDQCACIACtQoCAgICw9wCENwM4IAIgAkE4ajYCKCACQQQ2AiQgAkEMakH89YkBIAJBIGoQywoNASACKAIMIgBBEE8NAiABIAJBEGogABDWCSEADAMLIAJBBDYCJCACQYDuiQE2AiAgAkIENwIsIAIgAkEIaiIAQQNyrUKAgICAsPcAhDcDUCACIABBAnKtQoCAgICw9wCENwNIIAIgAEEBcq1CgICAgLD3AIQ3A0AgAiAArUKAgICAsPcAhDcDOCACIAJBOGo2AiggASgCACABKAIEIAJBIGoQywohAAwCC0HA7okBQSsgAkHfAGpBsO6JAUHs7okBENUeAAsgAEEPQaDuiQEQsDsACyACQeAAaiQAIAAPCwJ/QQEgAUHAmMQAQQEQ+zUNABpBAQJ/IwBBMGsiAiQAIAIgAEEBaiIALwAOIgNBCHQgA0EIdnI7AQ4gAiAALwAMIgNBCHQgA0EIdnI7AQwgAiAALwAKIgNBCHQgA0EIdnI7AQogAiAALwAIIgNBCHQgA0EIdnI7AQggAiAALwAGIgNBCHQgA0EIdnI7AQYgAiAALwAEIgNBCHQgA0EIdnI7AQQgAiAALwACIgNBCHQgA0EIdnI7AQIgAiAALwAAIgBBCHQgAEEIdnI7AQBBfyEGIAIhAEF/IQNBfyEEA0AgAC8BAAR/IARBAE4EQCAFIARrIgcgAyADIAdIIgcbIQMgBCAGIAcbIQYLQX8FIAUgBCAEQQBIGwshBCAAQQJqIQAgBUEBaiIFQQhHDQALQX8gBCAGQQggBGsiACADSiIFGyAGIARBAE4iBBsiByAAIAMgBRsgAyAEGyIDQQJIIgQbIQZBACEAQX4gAyAHaiIDIAQbIgVBB0ohBwJAAkADQAJAIAAgBkYEQEEBIQQgAUHCmMQAQQEQ+zUNAwJAIAZFBEAgAUHCmMQAQQEQ+zUiBCAHcg0FDAELIAVBCE4NAgsgAyEAIAVBCE8NBAsgAkHtAjYCLEEBIQQgAkEBNgIUIAJB1JjEADYCECACQgE3AhwgAiACIABBAXRqNgIoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahDLCg0CIABBB0YNACAAQQFqIQAgAUHCmMQAQQEQ+zVFDQEMAgsLQQAhBAsgAkEwaiQAIAQMAQsgBUEIQcSYxAAQwyEACw0AGiABQcGYxABBARD7NQsLUAEBfyABKAL4ByIEQf0BTQR/IAFBBGoFIAEoAgQhBCABKAIICyEBIAIgBEsEQCACIAQgAxCvOwALIAAgBCACazYCBCAAIAEgAkECdGo2AgALUQEBfyABKAJIIgNBEU0EfyABQQRqBSABKAIEIQMgASgCCAshASACIANLBEAgAiADQYifxAAQrzsACyAAIAMgAms2AgQgACABIAJBAnRqNgIAC1MBAX8jAEEgayIBJAAgAUEUaiAAQQhqKQIANwIAIAFBHGogAEEQaigCADYCACABQQA2AgggASAAKQIANwIMIAFBCGoQnydBCGoQ/TUgAUEgaiQAC1gBAX8gABCUDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAEJUMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtcAQF/IwBBMGsiASQAIAFBATYCECABQay+zQA2AgwgAUIBNwIYIAFBpgQ2AiggASABQSRqNgIUIAEgAUEvajYCJCAAQQRqIAFBDGoQmQ4gAEEANgIAIAFBMGokAAtLAQF/IwBBEGsiASQAIAFBBGogACgCmAUoAhQiAEEIaiAAKAIIQQJGQQJ0aiIAEIkZIAEtAAQEfyAALQAhQQFGBUEBCyABQRBqJAALSwEBfyMAQRBrIgEkACABQQRqIAAoAoAFKAIUIgBBCGogACgCCEECRkECdGoiABCJGSABLQAEBH8gAC0AIUEBRgVBAQsgAUEQaiQAC0sBAX8jAEEQayIBJAAgAUEEaiAAKAK4BCgCFCIAQQhqIAAoAghBAkZBAnRqIgAQiRkgAS0ABAR/IAAtACFBAUYFQQELIAFBEGokAAtLAQF/IwBBEGsiASQAIAFBBGogACgC5AQoAhQiAEEIaiAAKAIIQQJGQQJ0aiIAEIkZIAEtAAQEfyAALQAhQQFGBUEBCyABQRBqJAALSwEBfyMAQRBrIgEkACABQQRqIAAoApQEKAIUIgBBCGogACgCCEECRkECdGoiABCJGSABLQAEBH8gAC0AIUEBRgVBAQsgAUEQaiQAC0sBAX8jAEEQayIBJAAgAUEEaiAAKALoBCgCFCIAQQhqIAAoAghBAkZBAnRqIgAQiRkgAS0ABAR/IAAtACFBAUYFQQELIAFBEGokAAtdAQJ/IwBBEGsiASQAIAEgACgCGDYCDCABIAAoAiA2AgggAUEIaiICEN47IAEgACgCMDYCDCABIAAoAjg2AgggAhDtOyAAQcgAahDmICAAQeAAahDmICABQRBqJAALWAEBfyAAEJ0MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQngwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1EBAn8jAEEQayIBJAAgACgCgBMgAUEIaiAAQcAFaigCADYCACABIAApArgFNwMAIAEQiy0gACgCkBMQlxMgAEGAE2pBAEEk/AsAIAFBEGokAAtXAQF/IAAoAqwBBEBBAQ8LIAEoAjwhAwJAAkACQCACQn9RDQAgAiAAKAKQAkECdEGw+tAAajUCAFgNACADQQFGDQEMAgsgA0ECRg0BCyABKAIwRQ8LQQALYQECfyAAIAIvAQQiAzYCACAAIAIvAQYiBEEDajYCBAJAIAEoAiggAiABKAIAa0EDdUcNAAJAAkAgASgCJEEBaw4CAAECCyAAIANBgIAEcjYCAA8LIAAgBEGDgARqNgIECwtUAQJ/IAAgAiABayIEEOQtIAAoAgghAyABIAJHBEAgACgCBCECA0AgAiADaiABLQAAOgAAIAFBAWohASADQQFqIQMgBEEBayIEDQALCyAAIAM2AggLkgcBA38jAEEQayIEJAACQCAARSABRXJFBEAgACgCACIAQcAAENE0RQ0BAkAgARCaPigCBCICQXhxIgNBBEEIIAJBA3EiAhsgAGpPBEAgAkUgAyAAQSdqTXINAUGw8/wAQS5B4PP8ABCfKQALQfDy/ABBLkGg8/wAEJ8pAAsgARCaPiIAIAAoAgRBeHEiARCYPiECAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAgAxCWPiIAQdDzigEoAgBGBEAgAigCBEEDcUEDRw0BQcjzigEgATYCACAAIAEgAhCJLgwCCyAAIAMQqScLAkACQAJAAkACQAJAIAIoAgQiA0ECcUUEQCACQdTzigEoAgBGDQIgAkHQ84oBKAIARg0GIAIgA0F4cSICEKknIAAgASACaiIBENA0IABB0POKASgCAEcNAUHI84oBIAE2AgAMBwsgACABIAIQiS4LIAFBgAJJDQEgACABEPEQQejzigFB6POKASgCAEEBayIANgIAIAANBUGw8YoBKAIAIgENAkEAIQAMAwtB1POKASAANgIAQczzigFBzPOKASgCACABaiIBNgIAIAAgAUEBcjYCBEHQ84oBKAIAIABGBEBByPOKAUEANgIAQdDzigFBADYCAAsgAUHg84oBKAIATQ0EAkBB1POKASgCACIBRQ0AAkBBzPOKASgCAEEoTQ0AQajxigEhAANAIAEgACgCAE8EQCAAEK47IAFLDQILIAAoAggiAA0ACwsCQEGw8YoBKAIAIgFFBEBBACEADAELQQAhAANAIABBAWohACABKAIIIgENAAsLQejzigFB/x8gACAAQf8fTRs2AgBBzPOKASgCAEHg84oBKAIATQ0AQeDzigFBfzYCAAsMBAsCf0HA84oBKAIAIgJBASABQQN2dCIDcUUEQEHA84oBIAIgA3I2AgAgAUH4AXFBuPGKAWoiAQwBCyABQfgBcUGo8IoBaiICQZABaiEBIAJBmAFqKAIACyECIAEgADYCCCACIAA2AgwgACABNgIMIAAgAjYCCAwDC0EAIQADQCAAQQFqIQAgASgCCCIBDQALC0Ho84oBQf8fIAAgAEH/H00bNgIADAELQdDzigEgADYCAEHI84oBQcjzigEoAgAgAWoiATYCACAAIAEQ0DQLCyAEQRBqJAAPC0GA9PwAQSsgBEEPakHw8/wAQdj0/AAQ1R4AC6EEAgh/A34jAEEgayIEJAAgBEEMaiEHIAEoAhghAiMAQSBrIgMkAAJAIAEpAwAiCiABKQMIIgxZDQAgASgCECEIA0AgASAKQgF8Igo3AwAgA0EMaiAIEIgWIAMpAhQhCyADKAIQIQYCQAJAIAMoAgwiCUGTgICAeEcEQCADKAIcIQUCQCACKAIAIgFBk4CAgHhGDQACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBCyABQYCAgIB4cyABQQBOGw4QAAECAwQFBg8HCAkKCwwNDg8LIAJBBGoQ3jsMDgsgAkEEahC8KgwNCyACQQRqEN47DAwLIAJBBGoQ3jsMCwsgAkEEahDeOwwKCyACQQRqEN47DAkLIAJBBGoQ3jsMCAsgAkEEahDeOwwHCyACQQRqEN47DAYLIAJBBGoQ3jsMBQsgAhDeOyACLQAMQQNHDQQgAigCECIBELwqIAFBDEEEEPg6DAQLIAJBBGoQ3jsMAwsgAkEEahDeOwwCCyACQQRqEN47DAELIAJBBGoQ3jsLIAIgBTYCECACIAs3AgggAiAGNgIEIAIgCTYCAEEAIQYMAQsgBkUNAQsgByALNwIIIAcgBjYCBEEBIQUMAgsgCiAMUg0ACwsgByAFNgIAIANBIGokAAJAAkAgBCgCDEUNACAEKAIQIgFFDQAgACAEKQIUNwIEIAAgATYCAAwBCyAAQQA2AgALIARBIGokAAtPACABIAJHBEAgAiABayECIAAgAUEMbGohAQNAIAEoAgAiACAAKAIAIgBBAWs2AgAgAEEBRgRAIAEQ+x4LIAFBDGohASACQQFrIgINAAsLC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFB7IL/ABCMGCABIAMQzRwgACABELETIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKguIAJB4ABqIgEgAxChGyACQQRqIgMgAUH4gv8AEIwYIAEgAxDNHCAAIAEQwBMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQZyD/wAQjBggASADEM0cIAAgARDCEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCpLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBtIP/ABCMGCABIAMQzRwgACABEK0TIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKkuIAJB4ABqIgEgAxChGyACQQRqIgMgAUHMg/8AEIwYIAEgAxDNHCAAIAEQshMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqC4gAkHgAGoiASADEKEbIAJBBGoiAyABQdiD/wAQjBggASADEM0cIAAgARCpEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCpLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFB5IP/ABCMGCABIAMQzRwgACABELsTIAJBgAJqJAALTwECfyMAQYACayICJAAgAkG8AWoiAyABEKkuIAJB4ABqIgEgAxChGyACQQRqIgMgAUHwg/8AEIwYIAEgAxDNHCAAIAEQrxMgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQqS4gAkHgAGoiASADEKEbIAJBBGoiAyABQYiE/wAQjBggASADEM0cIAAgARDEEyACQYACaiQAC08BAn8jAEGAAmsiAiQAIAJBvAFqIgMgARCoLiACQeAAaiIBIAMQoRsgAkEEaiIDIAFBoIT/ABCMGCABIAMQzRwgACABEMYTIAJBgAJqJAALWAEBfyAAEKYMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQpwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABCnDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLWAEBfyAAEKgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQqQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABCyDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqELsjCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLTwECfyMAQYACayICJAAgAkG8AWoiAyABEPQ9IAJB4ABqIgEgAxChGyACQQRqIgMgAUHQ94ABEIwYIAEgAxDNHCAAIAEQiwwgAkGAAmokAAtPAQJ/IwBBgAJrIgIkACACQbwBaiIDIAEQ7j0gAkHgAGoiASADEKEbIAJBBGoiAyABQcT3gAEQjBggASADEM0cIAAgARCNDCACQYACaiQAC1gBAX8gABC0DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAELQMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQtQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABC2DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAELcMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LAkAgACgCGCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRhqEPseCwtYAQF/IAAQuQwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC1gBAX8gABC+DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCwJAIAAoAhgiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEYahD7HgsLWAEBfyAAEL4MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQvwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC04AAkAgACgCGAR/IAEgACgCKE8NASAAKAIcIAAoAiQgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQfzDhAFBIEGcxIQBEJ8pAAtOAAJAIAAoAiQEfyABIAAoAjRPDQEgACgCKCAAKAIwIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0Hk5oQBQSBBhOeEARCfKQALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARD1HiAAQeQAakGACEGACBCmFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ8B4gAEHkAGpBgAhBgAgQphQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtvAQF/QdDvigEoAgAiAkUEQBC1GSECCyAAQRBqQejHhQFBiMiFASACKAIAIAIoAgQoAgwRBAAQ2gEgAEEwaiABEPgeIABB5ABqQYAIQYAIEKYUIABBCGpBuMiFASkCADcCACAAQbDIhQEpAgA3AgALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARD4HiAAQeQAakGACEGACBClFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ+R4gAEHkAGpBgAhBgAgQpRQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtvAQF/QdDvigEoAgAiAkUEQBC1GSECCyAAQRBqQejHhQFBiMiFASACKAIAIAIoAgQoAgwRBAAQ2gEgAEEwaiABEPkeIABB5ABqQYAIQYAIEKYUIABBCGpBuMiFASkCADcCACAAQbDIhQEpAgA3AgALbwEBf0HQ74oBKAIAIgJFBEAQtRkhAgsgAEEQakHox4UBQYjIhQEgAigCACACKAIEKAIMEQQAENoBIABBMGogARDwHiAAQeQAakGACEGACBClFCAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIAC28BAX9B0O+KASgCACICRQRAELUZIQILIABBEGpB6MeFAUGIyIUBIAIoAgAgAigCBCgCDBEEABDaASAAQTBqIAEQ9R4gAEHkAGpBgAhBgAgQpRQgAEEIakG4yIUBKQIANwIAIABBsMiFASkCADcCAAtOAAJAIAAoAiQEfyABIAAoAjRPDQEgACgCKCAAKAIwIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HwyIUBQSBBkMmFARCfKQALTgACQCAAKAIgBH8gASAAKAIwTw0BIAAoAiQgACgCLCABaiIAQQN2ai0AAEH/AXMgAEEHcXYFQQALQQFxDwtBrM6FAUEgQczOhQEQnykAC04AAkAgACgCTAR/IAEgACgCXE8NASAAKAJQIAAoAlggAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQazOhQFBIEHMzoUBEJ8pAAtOAAJAIAAoAhwEfyABIAAoAixPDQEgACgCICAAKAIoIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HE6YUBQSBB5OmFARCfKQALTgACQCAAKAIUBH8gASAAKAIkTw0BIAAoAhggACgCICABaiIAQQN2ai0AAEH/AXMgAEEHcXYFQQALQQFxDwtBxOmFAUEgQeTphQEQnykAC04AAkAgACgCJAR/IAEgACgCNE8NASAAKAIoIAAoAjAgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQcCKhgFBIEHgioYBEJ8pAAtOAAJAIAAoAiwEfyABIAAoAjxPDQEgACgCMCAAKAI4IAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0HAioYBQSBB4IqGARCfKQALWAEBfyAAEMgMIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQuyMLAkAgACgCFCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRRqEPseCwtYAQF/IAAQyAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsCQCAAKAIYIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBGGoQ+x4LC04AAkAgACgCFAR/IAEgACgCJE8NASAAKAIYIAAoAiAgAWoiAEEDdmotAABB/wFzIABBB3F2BUEAC0EBcQ8LQfSahgFBIEGUm4YBEJ8pAAtOAAJAIAAoAhgEfyABIAAoAihPDQEgACgCHCAAKAIkIAFqIgBBA3ZqLQAAQf8BcyAAQQdxdgVBAAtBAXEPC0H0moYBQSBBlJuGARCfKQALTAAgARCTJyABQRhqIAJBGGopAwA3AwAgAUEQaiACQRBqKQMANwMAIAFBCGogAkEIaikDADcDACABIAIpAwA3AwAgACABQcgA/AoAAAtYAQN/AkBBCyABKAIAIgJBgICAgHhzIAJBAE4bIgRBC0cEQCAEQQFHDQEgASgCCCECIAEoAgQhAwwBCyABQQxqIQNBpPKHASECCyAAIAI2AgQgACADNgIAC0wCAX8CfiMAQSBrIgIkACABIAApAwAiA0IAWUEBQQAgAyADQj+HIgSFIAR9IAJBDGoiAUEUEO0QIgAgAWpBFCAAaxCBCSACQSBqJAALUwECfyAAKAIIIgIEQCAAKAIEQQRqIQADQAJAIAAoAgAiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgABDyJQsgAEEIaiEAIAJBAWsiAg0ACwsLUwEBfwJAAkACQCAALQAgDgQAAgIBAgsgABDeOyAAKAIYIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRhqEJ0nCyAAQQxqEN47DwsgAEEcahCuLAsLVAEBfyAAEMspIAAoAkAiAQRAIAEQ6SYgAUEQQQQQ+DoLIAAoAkgiAUGEAU8EQCABEPIfCyAAQdQAahC9KCAAKAJQIgBBEGoQ3jsgAEHIAEEEEPg6C9QJAhR/An4jAEEQayIIJAAgASgCDCEKIwBBMGsiAyQAAkACQAJAIAEiDigCACIBIA4oAgQiE0cEQCAOKAIIIREDQCAOIAFBDGoiCzYCACADIAFBBGopAgA3AgwgESgCCCEBIBEoAgQhAiADQQA2AiggAyACNgIgIAMgAiABQQxsajYCJCADIANBDGo2AiwgA0EUaiEMIwBBIGsiBCQAIAQgA0EgaiIHQQhqNgIIIAQgB0EMajYCBCAHKAIAIQEgBygCBCEPAkACQAJAAkADQCABIA9GDQEgByABQQxqIgU2AgAgBCgCCCgCACENIAQgATYCFCAEIA02AhAgBEEEaiICIARBEGoiCRCMBiAEKAIIIgEgASgCAEEBajYCACAFIQFFDQALIAFBDEYNACAJQQRBAEEEQQQQoBggBCgCFCEFIAQoAhBBAUYNAiAEKAIYIgEgDTYCACAEQQxqIhRBATYCACAEIAE2AgggBCAFNgIEIARBGGogB0EIaikCADcDACAEIAcpAgA3AxAgAiEFIwBBEGsiBiQAIAlBCGohFSAJQQxqIQ0DQCAGIBU2AgQgBiANNgIAIAkoAgAhAiAJKAIEIQ8CQANAIAIgD0YNASAJIAJBDGoiATYCACAGKAIEKAIAIRIgBiACNgIMIAYgEjYCCCAGIAZBCGoQjAYgBigCBCICIAIoAgBBAWo2AgAgASECRQ0ACyABQQxGDQAgBSgCCCIBIAUoAgBGBEAgBUEBEO4tCyAFKAIEIAFBAnRqIBI2AgAgBSABQQFqNgIIDAELCyAGQRBqJAAgDEEIaiAUKAIANgIAIAwgBCkCBDcCAAwBCyAMQQA2AgggDEKAgICAwAA3AgALIARBIGokAAwBCyAFIAQoAhhBrKDDABD9LwALAkACQCADKAIcIgJFBEAgAygCDCEBIAcgAygCECILQQBBAUEBEKAYIAMoAiQhBSADKAIgQQFGDQYgAygCKCECIAsEQCACIAEgC/wKAAALIAKtIAutQiCGhCEXIANBFGoQ6TsCQCAKKAIAIgFBBkYNACAKQQRqIQICQAJAAkACQAJAIAEOBQECBAMEAAsgAigCACIBQYQBSQ0EIAEQ8h8MBAsgAigCACIBEIgRIAFBFEEEEPg6DAMLAkACQAJAAkACQAJAIAIoAgAiASgCAA4GAAECAwUEBQsgAUEEahDeOwwECyABQQRqEN47DAMLIAFBBGoQ3jsMAgsgAUEEahDeOwwBCyABQQRqELwqCyABQRhBCBD4OgwCCyACKAIAIgEoAgAiAigCTARAIAJBzABqELwqCyACKAIAQQJHBEAgAkEQahDeOwsgAkHUAEEEEPg6IAFBBEEEEPg6DAELIAIQ3jsLIAogFzcCCCAKIAU2AgQgCkECNgIAQYCAgIB4IQEMAQsgAygCFCIBQYCAgIB4Rg0BIAM1AhggAq1CIIaEIRYgAUGBgICAeEYNAQsgCCAWNwIEIAggATYCAAwDCyALIgEgE0cNAAsLIAhBgYCAgHg2AgALIANBMGokAAwBCyAFIAMoAihBxKLDABD9LwALAkAgCCgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAIKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAIQRBqJAALUQEBfyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEOgnCyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQRBqEJcVCyAAEOk7C1MBA38jAEEQayICJAAgAiABNgIMIAJBDGoiAUEAEKc7IQMgAUEBEKc7IQEgAigCDCIEQYQBTwRAIAQQ8h8LIAAgATYCBCAAIAM2AgAgAkEQaiQAC1sBAX9BFEEEEK02IgJFBEBBBEEUEKM9AAsgAEG8v80ANgIIIAAgAjYCBCAAQQU2AgAgAiABKQIANwIAIAJBEGogAUEQaigCADYCACACQQhqIAFBCGopAgA3AgALWwEBf0EUQQQQrTYiAkUEQEEEQRQQoz0ACyAAQfi/zQA2AgggACACNgIEIABBBTYCACACIAEpAgA3AgAgAkEQaiABQRBqKAIANgIAIAJBCGogAUEIaikCADcCAAtdAQF/AkAgACgCIEUNACAAKAIkIgFFDQAgAEEwaiAAKAIoIAAoAiwgASgCEBEBAAsCQCAAKAI0RQ0AIAAoAjgiAUUNACAAQcQAaiAAKAI8IAAoAkAgASgCEBEBAAsLvwgCEn8DfiMAQRBrIgckACABKAIYIQgjAEFAaiIDJAACQCABIgUoAgAiASAFKAIEIg5HBEAgBSgCFCEPIAUoAhAhECAFKAIMIREgBSgCCCEMA0AgBSABQUBrIhI2AgAgAyAMNgIgIAFBKGooAgAhAiABQSRqKAIAIQEgAyAPNgI4IAMgEDYCNCADIBE2AjAgA0EANgIsIAMgATYCJCADIAEgAkHAAmxqNgIoIAMgA0EgajYCPCADQQhqIQkjAEHQAGsiAiQAIAJBCDYCCCACQcgAaiADQSRqIgFBGGooAgA2AgAgAkFAayABQRBqKQIANwMAIAJBOGogAUEIaikCADcDACACIAEpAgA3AzAgAiACQQhqNgJMIAJBJGohCiMAQUBqIgEkACABQQxqIAJBMGoiBBDeGwJAAkACQCABKAIMQQlHBEAgAUEgaiINQQRBAEEEQRQQoBggASgCJCELIAEoAiBBAUYNAiABKAIoIgYgASkCDDcCACAGQRBqIAFBHGooAgA2AgAgBkEIaiABQRRqKQIANwIAIAFBCGoiE0EBNgIAIAEgBjYCBCABIAs2AgAgAUE4aiAEQRhqKQIANwMAIAFBMGogBEEQaikCADcDACABQShqIARBCGopAgA3AwAgASAEKQIANwMgIwBBIGsiBCQAIARBDGogDRDeGyAEKAIMQQlHBEADQCABKAIIIgYgASgCAEYEQCABIAZBAUEEQRQQ0CgLIAEoAgQgBkEUbGoiCyAEKQIMNwIAIAtBEGogBEEcaigCADYCACALQQhqIARBFGopAgA3AgAgASAGQQFqNgIIIARBDGogDRDeGyAEKAIMQQlHDQALCyAEQSBqJAAgCkEIaiATKAIANgIAIAogASkCADcCAAwBCyAKQQA2AgggCkKAgICAwAA3AgALIAFBQGskAAwBCyALIAEoAihByJfPABD9LwALAkAgAigCCEEIRwRAIAkgAikDCDcDACAJQRBqIAJBGGopAwA3AwAgCUEIaiACQRBqKQMANwMAIAoQwxUgCkEEQRQQ4B4MAQsgCSACKQIkNwIEIAlBCDYCACAJQQxqIAJBLGooAgA2AgALIAJB0ABqJAAgAykDECEVIAMoAgwhAQJAAkACQCADKAIIIgJBCEcEQCADKQMYIRYgCCgCAEEIRwRAIAgQySMLIAggFjcDECAIIBU3AwggCCABNgIEIAggAjYCACAFIAxBAWo2AghBgICAgHghAQwBCyAFIAxBAWoiDDYCCAJAIAFBgICAgHhrDgIDAgALIBUhFAsgByAUNwIEIAcgATYCAAwECyAVIRQLIBIiASAORw0ACwsgB0GBgICAeDYCAAsgA0FAayQAAkAgBygCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAHKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAHQRBqJAALSwECfyAAIAEQ7S0gACgCCCEDIAAgAQR/IAEgA2ogACgCBCADQQF0aiEAA0AgACACOwEAIABBAmohACABQQFrIgENAAsFIAMLNgIIC00BA38jAEEQayICJAAgAkEEaiIDIAAoAgwiAUEIaiABKAIIQQJGQQJ0aiIBEIkZIAMgAS0AISAAEN0lQf8BcRDOJiACQRBqJABB/wFxC1UBAn8jAEEQayICJAAgASgCCAR/IAJBCGogASgCBCIBKAIAIAEoAgQoAiARAAAgAigCDCEDIAIoAggFQQALIQEgACADNgIEIAAgATYCACACQRBqJAALVQECfyMAQRBrIgIkACABKAIIBH8gAkEIaiABKAIEIgEoAgAgASgCBCgCJBEAACACKAIMIQMgAigCCAVBAAshASAAIAM2AgQgACABNgIAIAJBEGokAAtXAQN/IAAgACgCCCICQQdxNgIIIAAgACgCFCIDIAJB/wFxIgJBA3ZqIgQ2AhQgAyAAKAIAQSAgAmt2NgAAAkAgAQ0AIAQgACgCGCIBTQ0AIAAgATYCFAsLog4CCH8HfiMAQRBrIgokAAJ/IAK9Qv///////////wCDQv/////////3/wBYBEAjAEEQayIJJAAgAr0iDUL/////////B4MhCyANQgBTBEAgAUEtOgAAQQEhBgsCQAJ/An8CQAJAAkAgDUI0iKdB/w9xIgNFIAtQcUUEQCADQQJJIAtCAFJyIQQgC0KAgICAgICACIQgCyADGyILQgKGIQwgC0IBgyEQIANBtQhrQcx3IAMbIgNBAEgEQCALQcD8iAEgAyADQYWiU2xBFHYgA0F/R2siCGoiBUEEdGsgCCAFQbHZtX9sQRN2a0H8AGogCSAJQQhqIAQQhxIhDiAJKQMIIQsgCSkDACENIAhBAk8EQCAMQn8gCK2GQn+Fg1BFIAhBP09yDQQMBQsgDSAQfSENIBBQIARxIQdBAQwFCyALIANBwegEbEESdiADQQNLayIFQQR0QeDRiAFqIAUgA2sgBUHPpsoAbEETdmpB/QBqIAkgCUEIaiAEEIcSIQ4gCSkDCCELIAkpAwAhDSAFQRZPDQJBACAMp2sgDEIFgKdBe2xGBEBBfyEDA0AgA0EBaiEDIAxCzZmz5syZs+ZMfiIMQrPmzJmz5syZM1gNAAsgAyAFTw0EDAMLIBBQRQRAIAxCAoQhDEF/IQMDQCADQQFqIQMgDELNmbPmzJmz5kx+IgxCtObMmbPmzJkzVA0ACyANIAMgBU+tfSENDAMLIAStQn+FIAx8IQxBfyEDA0AgA0EBaiEDIAxCzZmz5syZs+ZMfiIMQrPmzJmz5syZM1gNAAsMAQsgASAGaiIDQaCliQEvAAA7AAAgA0ECakGipYkBLQAAOgAAIA1CP4inQQNqIQQMBQsgAyAFSQ0AQQEhB0EADAILQQAhBAJ/IA1C5ACAIgwgC0LkAIAiD1gEQCALIQ8gDSEMIA4hC0EADAELIA6nIA5C5ACAIgunQZx/bGpBMUshBEECCyEDIAxCCoAiDCAPQgqAIg1WBH8DQCADQQFqIQMgCyIOQgqAIQsgDEIKgCIMIA0iD0IKgCINVg0ACyAOpyALp0F2bGpBBEsFIAQLIAsgD1FyDAILQQELIQhBACEEAkAgDUIKgCIPIAtCCoAiEVgEQEEAIQMgCyEMIA4hDQwBC0EAIQMDQCAHQQAgC6drIBEiDKdBdmxGcSEHIANBAWohAyAIIARB/wFxRXEhCCAOpyAOQgqAIg2nQXZsaiEEIA0hDiAPQgqAIg8gDCILQgqAIhFWDQALCwJAAkAgB0UNAEEAIAynayAMQgqAIg6nQXZsRw0AA0AgA0EBaiEDIAggBEH/AXFFcSEIIA2nIA1CCoAiC6dBdmxqIQQgCyENQQAgDqdrIA4iDEIKgCIOp0F2bEYNAAsMAQsgDSELCyAQUCAHcUUgCyAMUXFBBEEFIAtCAYNQGyAEIAgbIAQgBEH/AXFBBUYbQf8BcUEES3ILIQQCQAJAAkAgAyAFaiIFQQBOIAUCf0ERIAsgBK1CAYN8IgtC//+D/qbe4RFWDQAaQRAgC0L//5mm6q/jAVYNABpBDyALQv//6IOx3hZWDQAaQQ4gC0L/v8rzhKMCVg0AGkENIAtC/5+UpY0dVg0AGkEMIAtC/8/bw/QCVg0AGkELIAtC/8evoCVWDQAaQQogC0L/k+vcA1YNABpBCSALQv/B1y9WDQAaQQggC0L/rOIEVg0AGkEHIAtCv4Q9Vg0AGkEGIAtCn40GVg0AGkEFIAtCj84AVg0AGkEEIAtC5wdWDQAaQQMgC0LjAFYNABpBAkEBIAtCCVYbCyIEaiIDQRFIcUUEQCADQQFrIgVBEEkNASADQQRqQQVJDQIgBEEBRw0DIAEgBmoiA0HlADoAASADIAunQTBqOgAAIAUgASAGQQJyIgNqEKgZIANqIQQMBAsgCyABIAZqIARqELAWIAVFIAMgBExyRQRAIAEgBGogBmpBMCAF/AsACyABIAMgBmoiA2pBruAAOwAAIANBAmohBAwDCyALIAEgBCAGakEBaiIEahCwFiABIAZqIQYgAwRAIAYgBkEBaiAD/AoAAAsgAyAGakEuOgAADAILIAEgBmoiB0Gw3AA7AABBAiADayEFAkAgA0EATg0AQQMgBSAFQQNNG0ECayIDRQ0AIAdBAmpBMCAD/AsACyALIAEgBCAGaiAFaiIEahCwFgwBCyALIAEgBCAGaiIEaiIHQQFqELAWIAEgBmoiAyADLQABOgAAIANBLjoAASAHQeUAOgABIAUgASAEQQJqIgNqEKgZIANqIQQLIAlBEGokACAEDAELIApBCGoiAUEDQQQgAr0iC0IAWSIDG0EDIAtC/////////weDUCIEGzYCBCABQdDRiAFB09GIASADG0HX0YgBIAQbNgIAIAooAgghASAKKAIMCyEDIAAgATYCACAAIAM2AgQgCkEQaiQAC5UDAgV/An4jAEEQayIEJAAgASgCKCEFIwBBIGsiAiQAAkAgASgCHCIDIAEoAiBHBEACQAJAAkACQCABKAIERQ0AIAMgASgCFE8NAyABKAIIIAEoAhAgA2oiBkEDdmotAABB/wFzIAZBB3F2QQFxRQ0AIAEgA0EBajYCHEEAIQEMAQsgASADQQFqNgIcIAIgASADEK0qIAJBDGogAigCACACKAIEEOAHQQAhAQJAAkAgAigCDCIDQe3///8Hag4CAQIACyACKAIcIQEgAikCFCEHIAIoAhAhBiAFKAIAQZOAgIB4RwRAIAUQiBELIAUgATYCECAFIAc3AgggBSAGNgIEIAUgAzYCAEECIQEMAgsgAjUCFEIghiEIIAI1AhAhB0EBIQELIAcgCIQhBwsgBCAHNwIEIAQgATYCAAwCC0H0p4ABQSBBlKiAARCfKQALIARBAzYCAAsgAkEgaiQAAkAgBCgCACIBQQNGIAFBAkZyRQRAIAAgBCkCBDcCBCAAIAE2AgAMAQsgAEECNgIACyAEQRBqJAALmAMCBX8CfiMAQRBrIgQkACABKAIoIQUjAEEgayICJAACQCABKAIcIgMgASgCIEcEQAJAAkACQAJAIAEoAgRFDQAgAyABKAIUTw0DIAEoAgggASgCECADaiIGQQN2ai0AAEH/AXMgBkEHcXZBAXFFDQAgASADQQFqNgIcQQAhAQwBCyABIANBAWo2AhwgAiABKAIAIAMQ2isgAkEMaiACKAIAIAIoAgQQ4AdBACEBAkACQCACKAIMIgNB7f///wdqDgIBAgALIAIoAhwhASACKQIUIQcgAigCECEGIAUoAgBBk4CAgHhHBEAgBRCIEQsgBSABNgIQIAUgBzcCCCAFIAY2AgQgBSADNgIAQQIhAQwCCyACNQIUQiCGIQggAjUCECEHQQEhAQsgByAIhCEHCyAEIAc3AgQgBCABNgIADAILQfSngAFBIEGUqIABEJ8pAAsgBEEDNgIACyACQSBqJAACQCAEKAIAIgFBA0YgAUECRnJFBEAgACAEKQIENwIEIAAgATYCAAwBCyAAQQI2AgALIARBEGokAAuYAwIFfwJ+IwBBEGsiBCQAIAEoAighBSMAQSBrIgIkAAJAIAEoAhwiAyABKAIgRwRAAkACQAJAAkAgASgCBEUNACADIAEoAhRPDQMgASgCCCABKAIQIANqIgZBA3ZqLQAAQf8BcyAGQQdxdkEBcUUNACABIANBAWo2AhxBACEBDAELIAEgA0EBajYCHCACIAEoAgAgAxCPLCACQQxqIAIoAgAgAigCBBDgB0EAIQECQAJAIAIoAgwiA0Ht////B2oOAgECAAsgAigCHCEBIAIpAhQhByACKAIQIQYgBSgCAEGTgICAeEcEQCAFEIgRCyAFIAE2AhAgBSAHNwIIIAUgBjYCBCAFIAM2AgBBAiEBDAILIAI1AhRCIIYhCCACNQIQIQdBASEBCyAHIAiEIQcLIAQgBzcCBCAEIAE2AgAMAgtB9KeAAUEgQZSogAEQnykACyAEQQM2AgALIAJBIGokAAJAIAQoAgAiAUEDRiABQQJGckUEQCAAIAQpAgQ3AgQgACABNgIADAELIABBAjYCAAsgBEEQaiQAC1MCAn8BfiMAQRBrIgMkACAAKAIAIgAoAgAgA0EIaiAAKAIEIAAoAggoAgAgASgCACACQQJ0a0EEaygCABDKJSADKAIIIAMoAgwQzQIgA0EQaiQAC4cvAhB/AX4jAEEQayIMJAAgDEEANgIMIAxCgICAgBA3AgRBASENAn8gDEEEaiEEIwBBMGsiCSQAIAlBEGogAEEsaigCADYCACAJQQhqIABBJGopAgA3AwAgCSAAKQIcNwMAIAlBFGogCRCZAQJAAkAgCS0AFEEHRg0AIAlBIGpBAXIhEQNAIAlBKGogCUEcaigCADYCACAJIAkpAhQiEjcDIAJAIBKnQf8BcSICQQRPBEACQAJAAkAgAkEFaw4CAAIBCyMAQeAAayICJAAgACgCDCELIAAoAgghBiAAKAIEIQggACgCACEHIAAoAjAhAwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBEyARLQAAIgVBBGsgBUEDTRsiCkH/AXEOFAADBAUGDQwLCgkBDw8PDw8PDw8HDwsgAw0BDA4LIAtBgICAgHhHDQZBASEFDA4LIANBA3ZB/wdxIgVB3QVPDRQgBSAFQZf8gAFqLQAAakEGdkEBayIDQQtNBEAgBCADQQN0QYiFgQFqKAIAIgMgA0EDahC9JgwMCyADQQxBmIOBARDDIQALIANFDQsgA0EDdkH/B3EiBUHdBU8NEyAFIAVBl/yAAWotAABqQQZ2QQFrIgNBC00EQCAEIANBA3QiA0GEhIEBaigCACIFIAUgA0GIhIEBaigCAGoQvSYMCwsgA0EMQaiDgQEQwyEACyADRQ0KQQAhBSAEIANBBHZB/wNxIANBB3FqQQdwIgNBAWpBACADQQZJG0EDdEHshoEBaigCACIDIANBA2oQvSYMCwsgA0UNCUEAIQUgBCADQQR2Qf8DcSADQQdxakEHcCIDQQFqQQAgA0EGSRtBA3QiA0GchoEBaigCACIGIAYgA0GghoEBaigCAGoQvSYMCgsgB0EBcUUNCEEAIQUgAkEANgIkIAJBADYCDCACQaiHgQFBpoeBASAIQb/RAksiAxs2AkAgAkGmh4EBQaSHgQEgAxs2AjwgAkEYaiEIIAJBKGohCyACQRBqIQ4DQCAFQQFxRSEDA0ACQAJAAkAgA0UEQCAOEOUrIgNBgIDEAEcNASACKAIMBEAgAigCEBogAigCFBoLQQAhBSACQQA2AgxBASEDDAQLAkAgAigCPCIDRQ0AIAMgAigCQEYNACACIANBAWo2AjwgAy0AACIGIQcCQCAGwEEATg0AIAIgA0ECajYCPCADLQABQT9xIg8gBkEfcSIKQQZ0ciEHIAZB3wFNDQAgAiADQQNqNgI8IAMtAAJBP3EgD0EGdHIiDyAKQQx0ciEHIAZB8AFJDQAgAiADQQRqNgI8IApBEnRBgIDwAHEgAy0AA0E/cSAPQQZ0cnIiB0GAgMQARg0BCyACQdQAaiAHEP0MIAIoAlghAyACQdAAaiIGIAJB3ABqKAIAIgc2AgAgAiACKQJUNwNIIAIoAgwEQCACKAIQGiACKAIUGgsgCCACKQNINwIAIAhBCGogBigCADYCACACQQNBAkEBIAMbIAcbNgIUIAJCATcCDAwCCyACKAIkIgNBAUYEfyALEOUrIgNBgIDEAEcNASACKAIkBEAgAigCKBogAigCLBoLIAJBADYCJEEAIQMgAigCDAUgBQsEfyACKAIQGiACKAIUGiACKAIkBSADC0UNDCACKAIoGiACKAIsGgwMCyAEKAIIIQYgBAJ/QQEgA0GAAUkiBw0AGkECIANBgBBJDQAaQQNBBCADQYCABEkbCyIKEIQuIAQoAgQgBCgCCGohBQJAIAdFBEAgA0GAEEkNASADQYCABE8EQCAFIANBP3FBgAFyOgADIAUgA0ESdkHwAXI6AAAgBSADQQZ2QT9xQYABcjoAAiAFIANBDHZBP3FBgAFyOgABDAQLIAUgA0E/cUGAAXI6AAIgBSADQQx2QeABcjoAACAFIANBBnZBP3FBgAFyOgABDAMLIAUgAzoAAAwCCyAFIANBP3FBgAFyOgABIAUgA0EGdkHAAXI6AAAMAQtBACEDDAELCyAEIAYgCmo2AgggAigCDCEFDAALAAsgB0EBcUUNBwJAAkACQCAFQQFrDgMAAQIKCyACQQE2AiAgAkGogoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAZBwIQ9bkHoB3A2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAoLIAJBATYCICACQcCCgQE2AhwgAkEBNgIQIAJBrPeAATYCDCACQQE2AhggAkE7NgJYIAIgBkHoB25BwIQ9cDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMCQsgAkEBNgIgIAJB2IKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQYCU69wDcDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMCAsgAiAAQQxqNgJIIAJBATYCECACQaz3gAE2AgwgAkIBNwIYIAJBhAE2AlggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAcLIAdBAXFFDQUgBEGcgoEBQZ2CgQEQvSYgAkEBNgIgIAJB2IKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQYCU69wDcDYCSCACIAJB1ABqNgIUIAIgAkHIAGo2AlQgBCACQQxqEO48IQUMBgsgB0EBcUUNBCAEQZyCgQFBnYKBARC9JiACQQE2AiAgAkHAgoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAZB6AduQcCEPXA2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAULIAdBAXFFDQMgBEGcgoEBQZ2CgQEQvSYgAkEBNgIgIAJBqIKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAGQcCEPW5B6AdwNgJIIAIgAkHUAGo2AhQgAiACQcgAajYCVCAEIAJBDGoQ7jwhBQwECyAHQQFxRQ0CIAIgBkGAlOvcA3AiAzYCRCADRQ0BIARBnIKBAUGdgoEBEL0mIAMgA0HAhD1uIgVBwIQ9bEYEQCACQQE2AiAgAkGogoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAU2AkggAiACQdQAajYCFCACIAJByABqNgJUIAQgAkEMahDuPCEFDAQLIAMgA0HoB24iBUHoB2xGBEAgAkEBNgIgIAJBwIKBATYCHCACQQE2AhAgAkGs94ABNgIMIAJBATYCGCACQTs2AlggAiAFNgJIIAIgAkHUAGo2AhQgAiACQcgAajYCVCAEIAJBDGoQ7jwhBQwECyACQQE2AiAgAkHYgoEBNgIcIAJBATYCECACQaz3gAE2AgwgAkEBNgIYIAJBOzYCWCACIAJB1ABqNgIUIAIgAkHEAGo2AlQgBCACQQxqEO48IQUMAwsgB0EBcUUNASAEQaaHgQFBpIeBASAIQb/RAksiAxtBqIeBAUGmh4EBIAMbEL0mC0EAIQUMAQtBASEFIAtBgICAgHhGDQACQAJAAkACQAJAAkAgCkH/AXFBC2sOCAABAgADAwQFBgsgAkEBOgANIAJBgQI7AA4gAiAKQQ5GOgAMIAJBDGogBCAAKAIYEP4HIQUMBQsgAkGAgoQQNgAMIAJBDGogBCAAKAIYEP4HIQUMBAsgAkGAgAQ2AAwgAkEMaiAEIAAoAhgQ/gchBQwDCyACQQI6AA0gAkGBAjsADiACIApBEEY6AAwgAkEMaiAEIAAoAhgQ/gchBQwCCyADRSAHQQFxRXINASACIAY2AhQgAiAINgIQIAIgAzYCDAJ/IAAoAhghCgJAIAJBDGoiBigCACIDQQ11IgdBj84ASw0AIAQgA0EEdkH/A3EgA0EHcWpBB3AiBUEBakEAIAVBBkkbQQN0QeixhgFqKAIAIgUgBUEDahC7JiAEQbSwhgFBtrCGARC7JgJAIANBA3YiA0H/B3EiBUHdBUkEQAJAIAMgBUGgsoYBai0AACILakEBdkEfcSIIQQpPBEAgBCAIEIsYDQQgBCgCCCEDDAELIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqIAhBMHI6AAAgBCADQQFqIgM2AggLIAQoAgAgA0YEfyAEIANBARDbKCAEKAIIBSADCyAEKAIEakEgOgAAIAQgA0EBajYCCCAFIAtqQQZ2QQFrIgNBDE8NASAEIANBA3RB8LCGAWooAgAiAyADQQNqELsmIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIIAQgB0H//wNxQeQAbiIDEIsYDQIgBCAHIANB5ABsaxCLGA0CIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIIAYoAgQiBUE8biEHIAYoAgghBiAEIAVBkBxuEIsYDQIgBCgCCCIDIAQoAgBGBH8gBCADQQEQ2yggBCgCCAUgAwsgBCgCBGpBOjoAACAEIANBAWo2AgggBCAHQTxwEIsYDQIgBCgCCCIDIAQoAgBGBH8gBCADQQEQ2yggBCgCCAUgAwsgBCgCBGpBOjoAACAEIANBAWo2AgggBCAFIAdBPGxrIAZBgJTr3ANuahCLGA0CIAQoAggiAyAEKAIARgR/IAQgA0EBENsoIAQoAggFIAMLIAQoAgRqQSA6AAAgBCADQQFqNgIIQciwhgEgBCAKEP4HDAMLIAVB3QVBgLiGARDDIQALIANBDEG4sIYBEMMhAAtBAQshBQwBCyADRSAHQQFxRXINACACIAY2AhQgAiAINgIQIAIgAzYCDCAAKAIYIQojAEEwayIDJAAgAyACQQxqIggoAgAiB0ENdSIGNgIEAkACQCAGQZDOAE8EQCADQQE2AiQgA0GEgoEBNgIgIANBATYCFCADQaz3gAE2AhAgA0EBNgIcIANBnAM2AiwgAyADQShqNgIYIAMgA0EEajYCKCAEIANBEGoQ7jxFDQEMAgsgBCAGQf//A3FB5ABuIgsQixgNASAEIAYgC0HkAGxrEIsYDQELIAQoAgghBiAEQQEQhC4gBCgCBCAEKAIIakEtOgAAIAQgBkEBajYCCAJAIAdBA3YiB0H/B3EiBkHdBUkEQCAEIAYgBkGX/IABai0AACILakEGdhCLGA0CIAQoAgghBiAEQQEQhC4gBCgCBCAEKAIIakEtOgAAIAQgBkEBajYCCCAEIAcgC2pBAXZBH3EQixgNAiAEKAIIIQYgBEEBEIQuIAQoAgQgBCgCCGpB1AA6AAAgBCAGQQFqNgIIIAgoAgQhByADIAgoAggiBkGAlOvcA2sgBiAGQf+T69wDSyIIGyIGNgIIIAQgB0GQHG4QixgNAiAEKAIIIQsgBEEBEIQuIAQoAgQgBCgCCGpBOjoAACAEIAtBAWo2AgggBCAHQTxuIgtBPHAQixgNAiAEKAIIIQ4gBEEBEIQuIAQoAgQgBCgCCGpBOjoAACAEIA5BAWo2AgggBCAHIAtBPGxrIAhqEIsYDQIgBkUNASAGIAZBwIQ9biIHQcCEPWxGBEAgA0EBNgIkIANBqIKBATYCICADQQE2AhQgA0GggoEBNgIQIANBATYCHCADQTs2AiwgAyAHNgIMIAMgA0EoajYCGCADIANBDGo2AiggBCADQRBqEO48RQ0CDAMLIAYgBkHoB24iB0HoB2xGBEAgA0EBNgIkIANBwIKBATYCICADQQE2AhQgA0GggoEBNgIQIANBATYCHCADQTs2AiwgAyAHNgIMIAMgA0EoajYCGCADIANBDGo2AiggBCADQRBqEO48RQ0CDAMLIANBATYCJCADQdiCgQE2AiAgA0EBNgIUIANBoIKBATYCECADQQE2AhwgA0E7NgIsIAMgA0EoajYCGCADIANBCGo2AiggBCADQRBqEO48RQ0BDAILIAZB3QVB9IGBARDDIQALIANBgIKECDYAECADQRBqIAQgChD+ByEFCyADQTBqJAALIAJB4ABqJAAgBQ0BDAMLAn8gCS0AIiEGIwBBIGsiByQAIAAoAgghCiAAKAIEIQggACgCACEFIAAoAjAhAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBEtAABBAWsOFAABDQIDDg8QBAUGBwgJERITFBUKCwsgAg0LDBULIAJFDRQgBCACQQ11QeQAbyICQeQAaiACIAJBAEgbIAYQzhMhAwwVCyACRQ0TIAQgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1IgIgAkHkAG0iAkHkAGxrQR91IAJqIAYQzhMhAwwUCyACRQ0SIAQgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1QeQAbyICQeQAaiACIAJBAEgbIAYQzhMhAwwTCyACRQ0RIAcgAjYCECAEIAdBEGpBBhDeJyAGEM4TIQMMEgsgAkUNECAHIAI2AhAgBCAHQRBqQQAQ3icgBhDOEyEDDBELIAJFDQ8gBCACQQ11IAJBBHZB/wNxIAJBD3EQxRhBBHZBP3EgBhDOEyEDDBALIAJFDQ4gBEKBhIyg0MABIAJBBHZB/wNxIAJBB3FqQQdwQQN0rYinEIMdIQMMDwsgAkUNDSAEIAJBBHZB/wNxIAJBB3FqQQdwQQFqEIMdIQMMDgsgAkUNDCAEQQMgAkEEdkH/A3GtIAZBABCcCSEDDA0LIAJFDQtBASEDIAVBAXFFDQwgACgCGCEDIAAoAgwhBSAHIAo2AhggByAINgIUIAcgAjYCECAHQQRqIAdBEGoQyi8gByAHKAIENgIcIARBCSAHQRxqENEfrEKAowV+IANBACAFQYCAgIB4RxusfSAHNQIIfEKAkc285wF9IAZBABCcCSEDDAwLQQEhAyACRQ0LIAJBDXUiAkHoB2tBqMYATwRAIARBBCACrCAGIAJBj84ASxCcCSEDDAwLIAQgAkH//wNxQeQAbiIFEIsYDQsgBCACIAVB5ABsaxCLGCEDDAsLIAQgAkENdSICIAJB5ABtIgJB5ABsa0EfdSACaiAGEM4TIQMMCgtBASEDIAJFDQkgAkENdSACQQR2Qf8DcSACQQ9xEMUYQQp1IgJB6AdrQajGAE8EQCAEQQQgAqwgBiACQY/OAEsQnAkhAwwKCyAEIAJB//8DcUHkAG4iBRCLGA0JIAQgAiAFQeQAbGsQixghAwwJCyACRQ0HIAJBA3ZB/wdxIgVB3QVPDQkgBCAFIAVBl/yAAWotAABqQQZ2QQFrQQNuQQFqEIMdIQMMCAsgAkUNBiACQQN2Qf8HcSIFQd0FTw0IIAQgBSAFQZf8gAFqLQAAakEGdiAGEM4TIQMMBwsgAkUNBSACQQN2IgJB/wdxIgVB3QVPDQcgBCAFQZf8gAFqLQAAIAJqQQF2QR9xIAYQzhMhAwwGC0EBIQMgBUEBcUUNBSAEIAhBkBxuIAYQzhMhAwwFC0EBIQMgBUEBcUUNBCAEIAhBkBxuQQxwIgJBDCACGyAGEM4TIQMMBAtBASEDIAVBAXFFDQMgBCAIQTxuQTxwIAYQzhMhAwwDC0EBIQMgBUEBcUUNAiAEIApBgJTr3ANuIAhBPHBqIAYQzhMhAwwCC0EBIQMgBUEBcUUNASAEQQkgCkGAlOvcA3CtIAZBABCcCSEDDAELQQEhAwsgB0EgaiQAIAMMAQsMBgtFDQILIAlBFGoQuy1BASEQDAMLIAQgCSgCJCICIAIgCSgCKGoQvSYLIAlBFGoiAhC7LSACIAkQmQEgCS0AFEEHRw0ACwsgCUEwaiQAIBAMAQsgBUHdBUH0gYEBEMMhAAtFBEAgASAMKAIIIAwoAgwQ1gkhDQsgDEEEahDeOyAMQRBqJAAgDQtLAQJ/IAAgARCFLiAAKAIIIQIgACABBH8gASACaiAAKAIEIAJBAnRqIQADQCAAQQA2AgAgAEEEaiEAIAFBAWsiAQ0ACwUgAgs2AggLSgECfyMAQZABayIEJAAgBEEIaiIFIAAgASgCFBEAACAEQcwAaiIBIAIgAygCFBEAACAFIAEQohEgARCEJyAFEIQnIARBkAFqJAALsggCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEJkVIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf//A0sNAyALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAHOwEMIAQgEDYCCCAEIAo2AgQgBEEBNgIAIARBDGoMBQsgAyAKcg0BDAMLIAUgA0HIs4MBEMMhAAsgCygCACIGKAIIIgdB//8DSw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzsBDAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBUEBdGogDC8BADsBACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahCdPCANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAutCAIXfwJ+IwBBEGsiCSQAIAEoAiwhDSMAQUBqIgIkAAJAAkACQAJAAkAgASIOKAIAIgMgASgCBCISRg0AIAEoAighEyABKAIkIQ8gASgCECEBIA4oAgghCCAOKAIYIRQDQCAOIAhBAWoiFTYCCCAOIANBBGoiFjYCACABIBRGDQEgDiABQQxqIhc2AhAgASgCACIRQYCAgIB4Rg0BIAEpAgQhGSACIAg2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQzhggGachCCAZQoCAgIAQWgRAIAggGUIgiKdBDGxqIRggCCEBA0AgAUEIaigCACEQIAFBBGooAgAhCiACIAEoAgA2AhwgAiATNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkE0aiELIA8gCiAQEKwCIRkgAkEgaiIDAn8gAwJ/AkACQAJAIA8oAiwiAyAZIA81AiCIpyIFSwRAAkAgDygCKCAFQQR0aiIEKAIAQQFGBEAgCkUgBCgCBCIDRXINASADIAQoAgggCiAQEJ87DQUMAwsgCygCACIGKAIIIgdB/wBLDQMgCygCCCgCACEMIAsoAgQoAgAhBSAGKAIAIAdGBEAgBkG4tIMBEJsoCyAGKAIEIAdBA3RqIgMgDDYCBCADIAU2AgAgBiAHQQFqNgIIIAQgBzoADCAEIBA2AgggBCAKNgIEIARBATYCACAEQQxqDAULIAMgCnINAQwDCyAFIANByLODARDDIQALIAsoAgAiBigCCCIHQf8ASw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzoADAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBWogDC0AADoAACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahDeOyANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAulBQIRfwJ+IwBBEGsiBSQAIAEoAiwhByMAQUBqIgIkAAJAAkACQAJAAkAgASIIKAIAIgMgASgCBCIKRg0AIAEoAighCyABKAIkIQwgASgCECEBIAgoAgghBCAIKAIYIQ0DQCAIIARBAWoiDjYCCCAIIANBBGoiDzYCACABIA1GDQEgCCABQQxqIhA2AhAgASgCACIJQYCAgIB4Rg0BIAEpAgQhEyACIAQ2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQvxUgE6chAyATQoCAgIAQWgRAIAMgE0IgiKdBDGxqIREgAyEBA0AgAUEIaigCACEEIAFBBGooAgAhBiACIAEoAgA2AhwgAiALNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkEgaiAMIAYgBCACQTRqEIoQIAIoAiQhBCACKAIgIgZBk4CAgHhHDQUgAigCHCIGIAIoAhgiEk8NBCACKAIUIAZBAnRqIAQoAgA2AgAgAUEMaiIBIBFHDQALCyACIAM2AiQgAiAJNgIgIAJBIGpBBEEMEOAeIAIpAhQhEwJAAkACQCACKAIQIgFBgICAgHhrDgICAQALIBMhFAwGCyATIRQLIBAhASAOIQQgDyIDIApHDQALCyAFQYGAgIB4NgIADAMLIAYgEkHUs4IBEMMhAAsgAikCKCETIAIoAjAhASACIAM2AiQgAiAJNgIgIAJBIGpBBEEMEOAeIAJBEGoQ6TsgBxDlECAHIAE2AhAgByATNwIIIAcgBDYCBCAHIAY2AgBBgICAgHghAQsgBSAUNwIEIAUgATYCAAsgAkFAayQAAkAgBSgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAFKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAFQRBqJAALrQgCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEM4YIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf8BSw0DIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIAc6AAwgBCAQNgIIIAQgCjYCBCAEQQE2AgAgBEEMagwFCyADIApyDQEMAwsgBSADQcizgwEQwyEACyALKAIAIgYoAggiB0H/AUsNACALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAQNgIIIAQgCjYCBCAEIAc6AAwMAQtBkICAgHgMAgsgBEEMags2AgRBk4CAgHgLNgIAIAIoAiQhDCACKAIgIgNBk4CAgHhHDQUgAigCHCIFIAIoAhgiA08NBCACKAIUIAVqIAwtAAA6AAAgAUEMaiIBIBhHDQALCyACIAg2AiQgAiARNgIgIAJBIGpBBEEMEOAeIAIpAhQhGQJAAkACQCACKAIQIgFBgICAgHhrDgICAQALIBkhGgwGCyAZIRoLIBchASAVIQggFiIDIBJHDQALCyAJQYGAgIB4NgIADAMLIAUgA0HUs4IBEMMhAAsgAikCKCEZIAIoAjAhASACIAg2AiQgAiARNgIgIAJBIGpBBEEMEOAeIAJBEGoQ3jsgDRDlECANIAE2AhAgDSAZNwIIIA0gDDYCBCANIAM2AgBBgICAgHghAQsgCSAaNwIEIAkgATYCAAsgAkFAayQAAkAgCSgCACIBQYGAgIB4RiABQYCAgIB4RnJFBEAgACAJKQIENwIEIAAgATYCAAwBCyAAQYCAgIB4NgIACyAJQRBqJAALsggCF38CfiMAQRBrIgkkACABKAIsIQ0jAEFAaiICJAACQAJAAkACQAJAIAEiDigCACIDIAEoAgQiEkYNACABKAIoIRMgASgCJCEPIAEoAhAhASAOKAIIIQggDigCGCEUA0AgDiAIQQFqIhU2AgggDiADQQRqIhY2AgAgASAURg0BIA4gAUEMaiIXNgIQIAEoAgAiEUGAgICAeEYNASABKQIEIRkgAiAINgIMIAJBEGogAygCAEE8ahD0LUHEs4IBEJkVIBmnIQggGUKAgICAEFoEQCAIIBlCIIinQQxsaiEYIAghAQNAIAFBCGooAgAhECABQQRqKAIAIQogAiABKAIANgIcIAIgEzYCNCACIAJBHGo2AjwgAiACQQxqNgI4IAJBNGohCyAPIAogEBCsAiEZIAJBIGoiAwJ/IAMCfwJAAkACQCAPKAIsIgMgGSAPNQIgiKciBUsEQAJAIA8oAiggBUEEdGoiBCgCAEEBRgRAIApFIAQoAgQiA0VyDQEgAyAEKAIIIAogEBCfOw0FDAMLIAsoAgAiBigCCCIHQf//AUsNAyALKAIIKAIAIQwgCygCBCgCACEFIAYoAgAgB0YEQCAGQbi0gwEQmygLIAYoAgQgB0EDdGoiAyAMNgIEIAMgBTYCACAGIAdBAWo2AgggBCAHOwEMIAQgEDYCCCAEIAo2AgQgBEEBNgIAIARBDGoMBQsgAyAKcg0BDAMLIAUgA0HIs4MBEMMhAAsgCygCACIGKAIIIgdB//8BSw0AIAsoAggoAgAhDCALKAIEKAIAIQUgBigCACAHRgRAIAZBuLSDARCbKAsgBigCBCAHQQN0aiIDIAw2AgQgAyAFNgIAIAYgB0EBajYCCCAEIBA2AgggBCAKNgIEIAQgBzsBDAwBC0GQgICAeAwCCyAEQQxqCzYCBEGTgICAeAs2AgAgAigCJCEMIAIoAiAiA0GTgICAeEcNBSACKAIcIgUgAigCGCIDTw0EIAIoAhQgBUEBdGogDC8BADsBACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBSADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBE2AiAgAkEgakEEQQwQ4B4gAkEQahCdPCANEOUQIA0gATYCECANIBk3AgggDSAMNgIEIA0gAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAunBQIRfwJ+IwBBEGsiBSQAIAEoAiwhByMAQUBqIgIkAAJAAkACQAJAAkAgASIIKAIAIgMgASgCBCIKRg0AIAEoAighCyABKAIkIQwgASgCECEBIAgoAgghBCAIKAIYIQ0DQCAIIARBAWoiDjYCCCAIIANBBGoiDzYCACABIA1GDQEgCCABQQxqIhA2AhAgASgCACIJQYCAgIB4Rg0BIAEpAgQhEyACIAQ2AgwgAkEQakEAIAMoAgBBPGoQ9C1BxLOCARCzFSATpyEDIBNCgICAgBBaBEAgAyATQiCIp0EMbGohESADIQEDQCABQQhqKAIAIQQgAUEEaigCACEGIAIgASgCADYCHCACIAs2AjQgAiACQRxqNgI8IAIgAkEMajYCOCACQSBqIAwgBiAEIAJBNGoQihAgAigCJCEEIAIoAiAiBkGTgICAeEcNBSACKAIcIgYgAigCGCISTw0EIAIoAhQgBkECdGogBCgCADYCACABQQxqIgEgEUcNAAsLIAIgAzYCJCACIAk2AiAgAkEgakEEQQwQ4B4gAikCFCETAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgEyEUDAYLIBMhFAsgECEBIA4hBCAPIgMgCkcNAAsLIAVBgYCAgHg2AgAMAwsgBiASQdSzggEQwyEACyACKQIoIRMgAigCMCEBIAIgAzYCJCACIAk2AiAgAkEgakEEQQwQ4B4gAkEQahDpOyAHEOUQIAcgATYCECAHIBM3AgggByAENgIEIAcgBjYCAEGAgICAeCEBCyAFIBQ3AgQgBSABNgIACyACQUBrJAACQCAFKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAUpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAVBEGokAAuYCAIXfwJ+IwBBEGsiCSQAIAEoAiwhDCMAQUBqIgIkAAJAAkACQAJAAkAgASINKAIAIgMgASgCBCISRg0AIAEoAighEyABKAIkIQ4gASgCECEBIA0oAgghCCANKAIYIRQDQCANIAhBAWoiFTYCCCANIANBBGoiFjYCACABIBRGDQEgDSABQQxqIhc2AhAgASgCACIQQYCAgIB4Rg0BIAEpAgQhGSACIAg2AgwgAkEQaiADKAIAQTxqEPQtQcSzggEQthUgGachCCAZQoCAgIAQWgRAIAggGUIgiKdBDGxqIRggCCEBA0AgAUEIaigCACEPIAFBBGooAgAhCiACIAEoAgA2AhwgAiATNgI0IAIgAkEcajYCPCACIAJBDGo2AjggAkEgaiERIAJBNGohBCAOIAogDxCsAiEZAn8CQAJAIA4oAiwiAyAZIA41AiCIpyIGSwRAAkAgDigCKCAGQRhsaiIFKAIAQQFGBEAgCkUgBSgCCCIDRXINASADIAUoAgwgCiAPEJ87DQQMAwsgBCgCCCgCACELIAQoAgQoAgAhBiAEKAIAIgcoAggiBCAHKAIARgRAIAdBuLSDARCbKAsgBygCBCAEQQN0aiIDIAs2AgQgAyAGNgIAIAcgBEEBajYCCCAFIAStNwMQIAUgDzYCDCAFIAo2AgggBUIBNwMAIAVBEGoMBAsgAyAKcg0BDAILIAYgA0HIs4MBEMMhAAsgBCgCCCgCACELIAQoAgQoAgAhBiAEKAIAIgcoAggiBCAHKAIARgRAIAdBuLSDARCbKAsgBygCBCAEQQN0aiIDIAs2AgQgAyAGNgIAIAcgBEEBajYCCCAFIA82AgwgBSAKNgIIIAUgBK03AxALIAVBEGoLIQMgEUGTgICAeDYCACARIAM2AgQgAigCJCELIAIoAiAiA0GTgICAeEcNBSACKAIcIgYgAigCGCIDTw0EIAIoAhQgBkEDdGogCykDADcDACABQQxqIgEgGEcNAAsLIAIgCDYCJCACIBA2AiAgAkEgakEEQQwQ4B4gAikCFCEZAkACQAJAIAIoAhAiAUGAgICAeGsOAgIBAAsgGSEaDAYLIBkhGgsgFyEBIBUhCCAWIgMgEkcNAAsLIAlBgYCAgHg2AgAMAwsgBiADQdSzggEQwyEACyACKQIoIRkgAigCMCEBIAIgCDYCJCACIBA2AiAgAkEgakEEQQwQ4B4gAkEQahDjPCAMEOUQIAwgATYCECAMIBk3AgggDCALNgIEIAwgAzYCAEGAgICAeCEBCyAJIBo3AgQgCSABNgIACyACQUBrJAACQCAJKAIAIgFBgYCAgHhGIAFBgICAgHhGckUEQCAAIAkpAgQ3AgQgACABNgIADAELIABBgICAgHg2AgALIAlBEGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBiJCgwAA2AgAgAUKIkKDAgIGChAg3AwAgAUEYakGIkKDAADYCACABQoiQoMCAgYKECDcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2QBAn8jAEEgayIBJAAgAUEIakGMmLDgADYCACABQoyYsODAgYOGDDcDACABQRhqQYyYsOAANgIAIAFCjJiw4MCBg4YMNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALZAECfyMAQSBrIgEkACABQQhqQYmSpMgANgIAIAFCiZKkyJChwoQJNwMAIAFBGGpBiZKkyAA2AgAgAUKJkqTIkKHChAk3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtiAQJ/IwBBIGsiASQAIAFBCGpBhIiQIDYCACABQoSIkKDAgIGCBDcDACABQRhqQYSIkCA2AgAgAUKEiJCgwICBggQ3AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBi5as2AA2AgAgAUKLlqzYsOHChQs3AwAgAUEYakGLlqzYADYCACABQouWrNiw4cKFCzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2QBAn8jAEEgayIBJAAgAUEIakGOnLjwADYCACABQo6cuPDgwYOHDjcDACABQRhqQY6cuPAANgIAIAFCjpy48ODBg4cONwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALYgECfyMAQSBrIgEkACABQQhqQYWKlCg2AgAgAUKFipSo0KDBggU3AwAgAUEYakGFipQoNgIAIAFChYqUqNCgwYIFNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALYgECfyMAQSBrIgEkACABQQhqQYeOnDg2AgAgAUKHjpy48ODBgwc3AwAgAUEYakGHjpw4NgIAIAFCh46cuPDgwYMHNwMQIAFBEGoiAiAAEMIIIAIQvwwgARC/DCABQSBqJAALZAECfyMAQSBrIgEkACABQQhqQY+evPgANgIAIAFCj568+PDhw4cPNwMAIAFBGGpBj568+AA2AgAgAUKPnrz48OHDhw83AxAgAUEQaiICIAAQwgggAhC/DCABEL8MIAFBIGokAAtkAQJ/IwBBIGsiASQAIAFBCGpBipSo0AA2AgAgAUKKlKjQoMGChQo3AwAgAUEYakGKlKjQADYCACABQoqUqNCgwYKFCjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGDhowYNgIAIAFCg4aMmLDgwIEDNwMAIAFBGGpBg4aMGDYCACABQoOGjJiw4MCBAzcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGChIgQNgIAIAFCgoSIkKDAgIECNwMAIAFBGGpBgoSIEDYCACABQoKEiJCgwICBAjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC2IBAn8jAEEgayIBJAAgAUEIakGGjJgwNgIAIAFChoyYsODAgYMGNwMAIAFBGGpBhoyYMDYCACABQoaMmLDgwIGDBjcDECABQRBqIgIgABDCCCACEL8MIAEQvwwgAUEgaiQAC1gBAn8CQCACIANsIgMgAmoiBCADTwRAIAQgASgCCCIFSw0BIAEoAgQhASAAIAI2AgQgACABIANqNgIADwsgAyAEQaCBhQEQsTsACyAEIAVBoIGFARCwOwALVgEBfyMAQRBrIgQkACAEQQhqIAEoAgAgASgCBCIBKAIIQQFrQXhxakEIaiACIAMgASgCIBEFACAEKAIMIQEgACAEKAIINgIAIAAgATYCBCAEQRBqJAALVwECfyMAQSBrIgMkACADQRRqIAEQgRUCQCADKAIUIgRFBEAgAEEANgIADAELIAMgAykCGDcCDCADIAQ2AgggACADQQhqEMovIAAgAjYCDAsgA0EgaiQAC1cBAn8jAEEgayIDJAAgA0EUaiABEP0VAkAgAygCFCIERQRAIABBADYCAAwBCyADIAMpAhg3AgwgAyAENgIIIAAgA0EIahDKLyAAIAI2AgwLIANBIGokAAtXAQJ/IwBBIGsiAyQAIANBFGogARDWFQJAIAMoAhQiBEUEQCAAQQA2AgAMAQsgAyADKQIYNwIMIAMgBDYCCCAAIANBCGoQyi8gACACNgIMCyADQSBqJAALVwECfyMAQSBrIgMkACADQRRqIAEQ/RcCQCADKAIUIgRFBEAgAEEANgIADAELIAMgAykCGDcCDCADIAQ2AgggACADQQhqEMovIAAgAjYCDAsgA0EgaiQAC1MBAn8gASgCKCIFBEAgASgCJCEBIAVBzAFsIQUgACgCACIAIANsIQYgACADIARqbCEAA0AgASACIAYgABDYGyABQcwBaiEBIAVBzAFrIgUNAAsLC1MBAX8gASgCKCIFBEAgASgCJCEBIAVBzAFsIQUgACgCACIAIAMgBGpsIQQgACADbCEAA0AgASACIAAgBBDYGyABQcwBaiEBIAVBzAFrIgUNAAsLC1YBAX8gASgCBCACTwRAIAFBCGohAyACBEAgAygCAEF/IAL8CwALIAEgAjYCDCAAIAEpAgA3AgAgAEEIaiADKQIANwIADwtBsPWHAUErQdz1hwEQnykAC1oCA38BbyMAQRBrIgEkABAiIQQQ3xIiAiAEJgEgAiEDIAFBCGoQzi1BASECIAACfyABKAIIQQFxBEAgASgCDAwBC0EAIQIgAws2AgQgACACNgIAIAFBEGokAAtPAQF/IABBCGoQhjAgAEEUahCHMCAAKAIsIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSxqEIYfCyAAKAIgQYCAgIB4RwRAIABBIGoQ3jsLC7cCAgV/BH4jAEHgAGsiAyQAIANBDGoiBSAAEIUjIANBIGohACADKAIMIQQjAEEgayICJAAgAkEIaiAEIAEQiC0iAUEgahDAASABKQMQIQcCQCABKAIsQYCAgIB4RwRAIAJBFGogAUEsahCTGAwBCyACQYCAgIB4NgIUCyABKQMYIQggASgCPCIEIAQoAgAiBkEBajYCACAGQQBIBEAACyAAIAIpAgg3AiAgACACKQIUNwIsIABBKGogAkEQaigCADYCACAAQTRqIAJBHGooAgA2AgAgASkDACEJIAEpAwghCiABKAI4IQEgACAENgI8IAAgATYCOCAAIAg3AxggACAHNwMQIAAgCjcDCCAAIAk3AwAgAkEgaiQAIAUQ6CogA0EANgIYIANBGGoQ0ClBCGogA0HgAGokAAvRFgIefxd+IwBB4AJrIhAkACAQQQxqIhogABCFIyAQQSBqIQMgECgCDCMAQeAAayICJAAgARCJLSIAKAK8AiIZIBkoAgAiAUEBajYCAAJAAn8CQCABQQBOBEAgAiAAQYACahDWHgJAIAAoAowCQYCAgIB4RwRAIAJBDGogAEGMAmoQ3SAMAQsgAkGAgICAeDYCDAsgACgCAEEBRgRAIAApAwghLUIBISgLIAAoAhBBAUYEQCAAKQMYIS5CASEnCyAAKQP4ASEyIAApA/ABITMgACkD6AEhNCAAKALUASEbIAAoAtABIRwgACkD4AEhNSAAKQPYASE2QgghICAAKQNgIiZCCFENAwJ+AkACQAJAAkACQAJAAkACQCAmp0EBaw4HAQIDBAUGBwALIAAtAIoBIREgAC0AiQEhEiAALQCIASEEIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgAC0AjQEhByAALQCMASEGQgAhICACQT9qIQkgAC0AiwEMCgsgAiAAKAKMASIGQQh2OgA/IAZBEHYhCyAAKAKIASEEIAAtAJsBIQcgAC0AmgEhASAALQCZASEIIAAtAJgBIQUgACkDgAEhIyAAKQN4ISEgACkDcCEkIAApA2ghIiAAKAKUASEMIAAoApABIQ1CASEgDAgLIABBmgFqLQAAIQEgAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOgASElIAAoApwBIQogAC8BjgEhCyAALQCMASEGIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgACkDkAEhICAALwGYASEOIAAoAogBIQQgAC0AjQEhDyACIAAtAJsBOgA+IAIgDzoAPyAEQRB2IREgBEEIdiESIA4gAUEQdHIiBUEIdiEIICBCIIinIQwgIKchDUICISAgAkE9aiEJIARBGHYMCAsgACgCiAFBAUcEf0EABSAAKAKUASEMIAAoApABIQ0gAC8BjgEhCyAALQCNASEBIAAtAIwBIQZBAQshBCAAKAKYAUEBRgRAIAApA6ABISUgACgCnAEhCkEBIQULIAIgAToAPyACQQA6AD4gAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOAASEjIAApA3ghISAAKQNwISQgACkDaCEiQgMhICACQT1qIQlBACEBQQAMBwsgAiAAKAKMASIGQQh2OgA/IAZBEHYhCyAAKAKUASEMIAAoAogBIQQgAC0AmwEhByAALQCaASEBIAAtAJkBIQggAC0AmAEhBSAAKQOAASEjIAApA3ghISAAKQNwISQgACkDaCEiIAAoApABIQ1CBCEgDAULIABBmgFqLQAAIQEgAC0AqwEhByAALQCqASETIAAtAKkBIRQgAC0AqAEhFSAAKQOgASElIAAoApwBIQogAC8BjgEhCyAALQCMASEGIAApA4ABISMgACkDeCEhIAApA3AhJCAAKQNoISIgACkDkAEhICAALwGYASEOIAAoAogBIQQgAC0AjQEhDyACIAAtAJsBOgA+IAIgDzoAPyAEQRB2IREgBEEIdiESIA4gAUEQdHIiBUEIdiEIICBCIIinIQwgIKchDUIFISAgAkE9aiEJIARBGHYMBQsgACgCiAFBAUYEQAJAIAAoAowBIgEEQCACQUBrIABBmAFqIAAoApABIAAoApQBIAEoAgARBQAMAQsgAkEANgJAC0EBIQQLIAAoApwBQQFGBEACQCAAKAKgASIBBEAgAkHQAGogAEGsAWogACgCpAEgACgCqAEgASgCABEFAAwBCyACQQA2AlALQQEhCgsgACgCaEEBRgRAIAApA3AhJEIBISILIAAoAnhBAUYEQCAAKQOAASEjQgEhIQsgAiACLQBBOgA/IAIgAi0ATzoAPiAALQCzASEHIAAtALIBIQ4gAC0AsQEhDyAALQCwASEWIAJBzgBqLQAAIQEgAi8BQiELIAItAEAhBiACKAJEIQ0gAigCSCEMIAIpA1AhJSACLQBYIRUgAi0AWSEUIAItAFohEyACLwFMIAIgAi0AWzoAPSABQRB0ciIFQQh2IQggAkE8aiEJQgYMAQsgACgCiAFBAUYEQAJAIAAoAowBIgEEQCACQUBrIABBmAFqIAAoApABIAAoApQBIAEoAgARBQAMAQsgAkEANgJAC0EBIQQLIAAoApwBQQFGBEACQCAAKAKgASIBBEAgAkHQAGogAEGsAWogACgCpAEgACgCqAEgASgCABEFAAwBCyACQQA2AlALQQEhCgsgACgCaEEBRgRAIAApA3AhJEIBISILIAAoAnhBAUYEQCAAKQOAASEjQgEhIQsgAiACLQBBOgA/IAIgAi0ATzoAPiAALQCzASEHIAAtALIBIQ4gAC0AsQEhDyAALQCwASEWIAJBzgBqLQAAIQEgAi8BQiELIAItAEAhBiACKAJEIQ0gAigCSCEMIAIpA1AhJSACLQBYIRUgAi0AWSEUIAItAFohEyACLwFMIAIgAi0AWzoAPSABQRB0ciIFQQh2IQggAkE8aiEJQgcLISAgAigCXCEYQQAMAgsACyACQT5qIQlBAAshFyAJIAc6AAAgBUH/AXEgCEH/AXFBCHQgAUEQdHJyIQEgBEH/AXEgEUH/AXFBEHQgF0EYdHIgEkH/AXFBCHRyciESIAItAD8hESACLQA+IQcgAi0APSEFIAItADwhBAsCQCAAKAKYAkGAgICAeEcEQCACQRhqIABBmAJqELUWDAELIAJBgICAgHg2AhgLQgAhJiAAKAIgQQFGBEAgACkDKCEvQgEhKQsgACgCMEEBRgRAQgEhJiAAKQM4ISwLIAAoAkBBAUYEQCAAKQNIITBCASErCyAAKAJQQQFGBEAgACkDWCExQgEhKgsgACgCvAEhCCAAKAK4ASEJIAAoAsQBIRcgACgCwAEhHSAAKALMASEeIAAoAsgBIR8CQCAAKAKkAkGAgICAeEcEQCACQSRqIABBpAJqEKUdDAELIAJBgICAgHg2AiQLAkAgACgCsAJBgICAgHhHBEAgAkEwaiAAQbACahClHQwBCyACQYCAgIB4NgIwCyADIAIpAgA3AoACIAMgAikCDDcCjAIgA0GIAmogAkEIaigCADYCACADQZQCaiACQRRqKAIANgIAIANBmgFqIAFBEHY6AAAgAyABOwGYASADIDI3A/gBIAMgMzcD8AEgAyA0NwPoASADIDU3A+ABIAMgNjcD2AEgAyAbNgLUASADIBw2AtABIAMgHjYCzAEgAyAfNgLIASADIBc2AsQBIAMgHTYCwAEgAyAINgK8ASADIAk2ArgBIAMgBDoAswEgAyAOOgCyASADIA86ALEBIAMgFjoAsAEgAyAYNgKsASADIAU6AKsBIAMgEzoAqgEgAyAUOgCpASADIBU6AKgBIAMgJTcDoAEgAyAKNgKcASADIAc6AJsBIAMgDDYClAEgAyANNgKQASADIAs7AY4BIAMgEToAjQEgAyAGOgCMASADIBI2AogBIAMgIzcDgAEgAyAhNwN4IAMgJDcDcCADICI3A2ggAyAgNwNgIAMgMTcDWCADICo3A1AgAyAwNwNIIAMgKzcDQCADICw3AzggAyAmNwMwIAMgLzcDKCADICk3AyAgAyAuNwMYIAMgJzcDECADIC03AwggAyAoNwMAIAMgGTYCvAIgA0GgAmogAkEgaigCADYCACADIAIpAxg3A5gCIAMgAikCJDcCpAIgA0GsAmogAkEsaigCADYCACADIAIpAzA3A7ACIANBuAJqIAJBOGooAgA2AgAgAkHgAGokACAaEOoqIBBBADYCGCAQQRhqENIpQQhqIBBB4AJqJAALSAEBfyAAKAIAIgEgACgCBEYEf0EABSAAIAFBA2o2AgAgAUECai0AAEEYdCABLwAAQQh0ckEBcgsiAEEIdkGAgMQAIABBAXEbC1UBAX8jAEEQayICJAACfyAAKAIAIgAoAgBBAUYEQCACIABBBGo2AgwgAUGQhM4AQQQgAkEMakGUhM4AENATDAELIAFBjITOAEEEEPs1CyACQRBqJAALVgEDfyMAQRBrIgIkACACQQRqIgMgASgCCCIEQeTqzgAQzhggASgCBCAEIAIoAgggAigCDBCgGSABQQA2AgggAEEEaiADEOcVIABBCDYCACACQRBqJAALVgEDfyMAQRBrIgIkACACQQRqIgMgASgCCCIEQeTqzgAQzhggASgCBCAEIAIoAgggAigCDBChGSABQQA2AgggAEEEaiADEOcVIABBCDYCACACQRBqJAALkgUCDX8BfiMAQRBrIgckACABKAIIIQgjAEEgayIJJAACQCABKAIAIgYgASgCBCINRwRAIAhBDGohCyAJQRRqIQwDQCABIAZBDGoiDjYCACAJQQhqIQIjAEEgayIEJAAgBigCACEFIwBBMGsiAyQAIAMgBTYCDCAEQQhqIgoCfyAFQQRPBEAgA0EBNgIUIANBuPrOADYCECADQgE3AhwgA0GcAzYCLCADIANBKGo2AhggAyADQQxqNgIoIApBBGogA0EQahCZDkEADAELIAogBToABEEICzYCACADQTBqJAAgBC0ADCEDAkAgBCgCCCIFQQhHBEAgAiAEKQANNwAFIAJBFGogBEEcaigAADYAACACQQ1qIARBFWopAAA3AAAgAiADOgAEIAIgBTYCAAwBCyAEQQhqIAYoAgQQxhogBC0ADCEFIAQoAggiCkEIRwRAIAIgBCkADTcABSACQRRqIARBHGooAAA2AAAgAkENaiAEQRVqKQAANwAAIAIgBToABCACIAo2AgAMAQsgAiADOgAJIAIgBToACCACQQg2AgAgAiAGKAIINgIECyAEQSBqJAAgCSkCDCEPAkACQCAJKAIIIgZBCEcEQCAIKAIAQQhHBEAgCBDJIwsgCCAPNwIEIAggBjYCACALIAwpAgA3AgAgC0EIaiAMQQhqKAIANgIAQoCAgICAgAEhDwwBCyAPQoCAgICAIIRCgICAgIDgP4NCgICAgICgAVENAQsgByAPNwIADAMLIA4iBiANRw0ACwsgB0EFOgAFCyAJQSBqJAACQAJAIActAAVBBUYNACAHKQMAIg9CgICAgIDgP4NCgICAgICAAVENACAAIA83AgAMAQsgAEEEOgAFCyAHQRBqJAALTwECfyAAKAIIIgEEQCAAKAIEIQADQCAAKAIAIgIEQCAAQQxqIABBBGooAgAgAEEIaigCACACKAIQEQEACyAAQRBqIQAgAUEBayIBDQALCwtWAQF/IwBBIGsiASQAIAAoAgwiACgCCEECRgRAIAFBADYCGCABQQE2AgwgAUGsu88ANgIIIAFCBDcCECABQQhqQbS7zwAQ7ywACyAALQA4IAFBIGokAAtWAQF/IwBBIGsiASQAIAAoAgwiACgCCEECRgRAIAFBADYCGCABQQE2AgwgAUGsu88ANgIIIAFCBDcCECABQQhqQcS7zwAQ7ywACyAAKAIsIAFBIGokAAtVAQF/IwBBEGsiAiQAAn8gACgCACIALQAAQQFGBEAgAiAAQQFqNgIMIAFBkPDQAEEEIAJBDGpBgPDQABDQEwwBCyABQfnv0ABBBBD7NQsgAkEQaiQAC00AIARBA3EEQEF/DwsgBUGAIEkEQEG+fw8LIAEoAgBB/gFNBEAgACABIAIgA0EBIAQQsAgPCyABQf8BNgIAIAAgASACIAMgBCAFEPknC1IBAn8gASgCCCACQQN0aiICKAIAIQMgASgCBCEEIAAgASgCACIAIAAgAigCBGpBEHYiABCDLCABIAQgASgCACAAdUEBdGogA0EBdGovAQA2AgALUgECfyABKAIIIAJBA3RqIgIoAgAhAyABKAIEIQQgACABKAIAIgAgACACKAIEakEQdiIAEIUsIAEgBCABKAIAIAB1QQF0aiADQQF0ai8BADYCAAtGAQJ/IAFBAWohAQNAIAEEQCAAIAAoAgAiBSACdiADIAVyQQBHaiIFNgIAIAQgBWohBCAAQQRqIQAgAUEBayEBDAELCyAEC1kBA38CQCABKAIEIgIgASgCCCIDTwRAIAEoAgwiBCACIANrIgJLDQEgACAENgIEIAAgASgCACADajYCAA8LIAMgAkHo7vwAEK87AAsgBCACQfju/AAQsDsAC1UBAX8jAEEQayICJAACfyAAKAIAIgAtAABBAUYEQCACIABBAWo2AgwgAUHEov4AQQQgAkEMakG0ov4AENATDAELIAFBsKL+AEEEEPs1CyACQRBqJAALXAEDfwJAIAEoAggiAyABKAIEIgJNBEAgASgCDCIEIAJLDQEgASgCACEBIAAgBDYCCCAAIAM2AgQgACABNgIADwsgAyACQeSj/gAQsDsACyAEIAJB9KP+ABCwOwALygECB38CfiMAQRBrIgMkACABKAIEIgVBC08EQCAFQQpB0Kj+ABCwOwALIANBBGohBCABQQhqIQdBACEBAkADQCABIAVGDQEgASAHaiABQQFqIQEtAAAiAkH/AHGtIAmGIAqEIQogAsAiAkEASARAIAlCOVQgCUIHfCEJDQELCyACQQBIDQAgBCABNgIIIARCACAKQgGDfSAKQgGIhT0BBEEBIQYLIAQgBjYCACADKAIEIQEgACADLwEIOwECIAAgATsBACADQRBqJAALVQEBfyMAQRBrIgIkAAJ/IAAoAgAiAC8BAEEBRgRAIAIgAEECajYCDCABQfSo/gBBBCACQQxqQeSo/gAQ0BMMAQsgAUHgqP4AQQQQ+zULIAJBEGokAAtGAQF/IABBOGoQ5jwgACgCXARAIABB3ABqEM8vCyAAQcQAaiIBEMUnIAEQ6DsgAEHQAGoQ3jsgACgCCARAIABBCGoQjjsLC1EAAkAgA0UNAAJAIAIgA00EQCACIANHDQEMAgsgASADaiwAAEG/f0oNAQsgASACIAMgAkHsw4ABEKM2AAsgACACIANrNgIEIAAgASADajYCAAtLAQJ/IwBBEGsiASQAIAAoAgAiAC0AMEEgRgRAIAFBCGogAEE0ahDDNCABKAIIQQRqQQAgASgCDEEBSxsQkSwhAgsgAUEQaiQAIAILVQEBfyMAQRBrIgIkAAJ/IAAoAgAiAC0AAEEBRgRAIAIgAEEBajYCDCABQaiWgQFBBCACQQxqQZiWgQEQ0BMMAQsgAUGUloEBQQQQ+zULIAJBEGokAAtOAQF/IAAoAgwgACgCECIBKAIIQQFrQXhxakEIaiABKAJUEQQAIAAoAhRBCGooAhBqQThqIQEgACgCICIABH8gASAAQQhqKAIQagUgAQsLVgECfwJAIAEEQCABKAIAIgIgAigCACIDQQFqNgIAIANBAEgNASAAIAI2AgAgACABKAIUNgIUIAAgASkCDDcCDCAAIAEpAgQ3AgQPCyAAQQA2AgAPCwALigEBA38gASgCHCIFIAEoAhRGBEAjAEEQayIDJAAgA0EIaiABQRRqIgQgBCgCAEEBQQRBxAAQtxEgAygCCCIEQYGAgIB4RwRAIAQgAygCDEGshIcBEP0vAAsgA0EQaiQACyABKAIYIAVBxABsaiACQcQA/AoAACABIAVBAWo2AhwgACABQdwA/AoAAAtVAQF/IwBBEGsiAiQAAn8gACgCACIAKAIAQQFGBEAgAiAAQQRqNgIMIAFB/MOHAUEEIAJBDGpB7MOHARDQEwwBCyABQejDhwFBBBD7NQsgAkEQaiQAC1UBAX8jAEEQayICJAACfyAAKAIAIgAtAABBAUYEQCACIABBAWo2AgwgAUHs3YcBQQQgAkEMakHc3YcBENATDAELIAFB1t2HAUEEEPs1CyACQRBqJAALTwEBfyAAKAIAIgBBPGpBAUEBEOAeIABBMGoQ0gwgAEEIahCTJwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEHQAEEIEPg6CwtcAQF/IwBBMGsiASQAIAFBAjYCDCABQdiEiAE2AgggAUICNwIUIAFBOzYCLCABQTs2AiQgASAANgIoIAEgAEEEajYCICABIAFBIGo2AhAgAUEIakHohIgBEO8sAAtMACABKAIAIgFBAXEEQCABQX5xIQEgAwRAIAEgAiAD/AoAAAsgACADNgIIIAAgATYCBCAAIAIgA2ogAWs2AgAPCyAAIAEgAiADEI0YC1YBAX8CQCAALQAUQQJGDQAgACgCACIBIAEoAgBBAWsiATYCACABRQRAIAAQmCkLIAAoAhAiAUGEAU8EQCABEPIfCyAAQQxqEKw7RQ0AIABBBGoQvCoLC1YBAn8gASgCACECIAFBADYCAAJAIAIEQCABKAIEIQNBCEEEEK02IgFFDQEgASADNgIEIAEgAjYCACAAQey1iQE2AgQgACABNgIADwsAC0EEQQgQoz0AC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQ3xgLIABBBGohACACQQFrIgINAAsLC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQ8iULIABBBGohACACQQFrIgINAAsLC94CAgR/AW8jAEEgayIBJAACQCAALQAMRQ0AIAAoAgAgAEEANgIAQQFHDQAgASAAKAIENgIMQQFBARCtNiICRQRAQQFBARCjPQALIAJBAToAACABQdjawwA2AgQgASACNgIAIAEoAgAiAkHY2sMAEJM1IQQgAUEQaiIDQdjawwA2AgQgAyACNgIAIAMgBDYCCCABQQxqKAIAJQEQJiEFEN8SIgIgBSYBIAEgAjYCHCABQRxqKAIAJQEgAygCCCUBEFAhBRDfEiIDIAUmASADQYQBTwRAIAMQ8h8gASgCHCECCyACQYQBTwRAIAIQ8h8LIAEoAhgiAkGEAU8EQCACEPIfCyABQQxqENUvCyABQSBqJAACQCAAKAIARQ0AIABBBGoQkT4gACgCBCIBQYQBSQ0AIAEQ8h8LAkAgACgCCCIBRQ0AIAEgASgCAEEBayIBNgIAIAENACAAQQhqELIaCwtaAQF/AkACQAJAAkAgAC0AsAcOBAADAwEDCyAAQaQHahDeOwwBCyAAEOYnCyAAKAKgByIBQQhqEJQfIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQaAHahDZIwsLTgEBfwJAIAAoAgBFBEAgACgCECIAQYQBSQ0BIAAQ8h8PCyAAQRBqEN47IAAoAhwiASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQnScLC6EDAgd/AX4jAEHQAGsiAyQAIANBBGoiBSAAEIUjIANBGGohASADKAIEIQIjAEEwayIAJAAgAikDACEIIAIoAjAhBgJAIAIoAghBgICAgHhHBEAgAEEIaiACQQhqEN0gDAELIABBgICAgHg2AggLAkAgAigCFEGAgICAeEcEQCAAQRRqIAJBFGoQxBAMAQsgAEGAgICAeDYCFAsgAigCLCIEIAQoAgAiB0EBajYCAAJAIAdBAE4EQAJAIAIoAiBBgICAgHhHBEAgAEEgaiACQSBqENYeDAELIABBgICAgHg2AiALIAEgACkCCDcCCCABIAApAhQ3AhQgAUEQaiAAQRBqKAIANgIAIAFBHGogAEEcaigCADYCACABIAg3AwAgASAAKQMgNwMgIAFBKGogAEEoaigCADYCACABIAY2AjAgASAENgIsIABBMGokAAwBCwALIAUQ6CogA0EANgIQAn9ByABBCBCtNiIABEAgAEKBgICAEDcDACAAQQhqIANBEGpBwAD8CgAAIAAMAQtBCEHIABCjPQALQQhqIANB0ABqJAALTwECfyMAQcACayICJAAgAkEIaiIDIAAQlRogAyABQQBHOgAoIAJBqAFqIANBmAH8CgAAIAJBADYCoAEgAkGgAWoQ0SlBCGogAkHAAmokAAtYAQF/AkACQAJAIAAtAMQHDgQBAgIAAgsgAEEIahCcJwsgAEG4B2oQ3jsgACgCtAciAUEIahCVHyABIAEoAgAiAUEBazYCACABQQFHDQAgAEG0B2oQxyELC04BAX8gAEEgaiIBEJ8sIAEQ8zsgACgCLEGAgICAeEcEQCAAQSxqEOo7CyAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEIYfCwtRAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ6CcLIABBBGoQoSwgACgCFCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEUahCXFQsLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDFKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQxiggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLSAECfyMAQTBrIgMkACADQQxqIgQgABCHIyADQRxqIAMoAgwgASACEM4WIAQQ+yogA0EANgIYIANBGGoQnydBCGogA0EwaiQAC1MBAX8gACgCACIAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPgjCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEQQQQQ+DoLC0oCAX8BfiMAQRBrIgIkACACIAEQpRggACACKAIAQQFGBH4gACACKQMIIgNCAYhCACADQgGDfYU3AwhCAQUgAws3AwAgAkEQaiQAC8MCAgN/An4jAEEQayIDJAAjAEEgayICJAAgAkEEaiIEEPAvIAFBDGooAgAhAQJAAkAgBBDpKQ0AA0AgASgCBCIEIAEpAwgiBSAErSIGIAUgBlQbpyIERgRAIAIoAggNAiADQSVBwKPQAEELEM0aDAMLIAEgBUIBfDcDCCACQRhqIAJBBGogASgCACAEai0AABDUJgJAIAItABhBBEYNACACKQMYIgVC/wGDQgRRDQAgAyAFNwIADAMLIAJBBGoQ6SlFDQALCyACIAJBBGoQ5yUgAi8BAEEBcQRAIAIvAQIhASADQQQ6AAAgAyABOwECDAELIANBJUHAo9AAQQsQzRoLIAJBIGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAy8BAjsBBCAAQQQ2AgALIANBEGokAAvLAgIEfwF+IwBBEGsiAyQAIwBBMGsiAiQAIAJBADoAEyACQRRqIgQQ8C8gAUEMaigCACEBAkACQCAEEOkpDQADQCABKAIAIgQgAkETaiAEKAIIIgRBAEciBRCXGiABIAEoAgQgBWo2AgQgBEUEQCACKAIYDQIgA0ElQdzzzQBBCxDNGgwDCyACQShqIAJBFGogAi0AExDUJgJAIAItAChBBEYNACACKQMoIgZC/wGDQgRRDQAgAyAGNwIADAMLIAJBFGoQ6SlFDQALCyACQQhqIAJBFGoQ5yUgAi8BCEEBcQRAIAIvAQohASADQQQ6AAAgAyABOwECDAELIANBJUHc880AQQsQzRoLIAJBMGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAy8BAjsBBCAAQQQ2AgALIANBEGokAAvLAgIEfwF+IwBBEGsiAyQAIwBBMGsiAiQAIAJBADoAEyACQRRqIgQQ7i8gAUEMaigCACEBAkACQCAEEOkpDQADQCABKAIAIgQgAkETaiAEKAIIIgRBAEciBRCXGiABIAEoAgQgBWo2AgQgBEUEQCACKAIYDQIgA0ElQdzzzQBBCxDNGgwDCyACQShqIAJBFGogAi0AExDUJgJAIAItAChBBEYNACACKQMoIgZC/wGDQgRRDQAgAyAGNwIADAMLIAJBFGoQ6SlFDQALCyACQQhqIAJBFGoQgCggAigCCEEBcQRAIAIoAgwhASADQQQ6AAAgAyABNgIEDAELIANBJUHc880AQQsQzRoLIAJBMGokAAJAIAMtAABBBEcEQCADIAMpAwA3AwggACADQQhqENAJDAELIAAgAygCBDYCBCAAQQQ2AgALIANBEGokAAvGAgIDfwJ+IwBBEGsiAyQAIwBBMGsiAiQAIAJBFGoiBBDuLyABQQxqKAIAIQECQAJAIAQQ6SkNAANAIAEoAgQiBCABKQMIIgUgBK0iBiAFIAZUG6ciBEYEQCACKAIYDQIgA0ElQcCj0ABBCxDNGgwDCyABIAVCAXw3AwggAkEoaiACQRRqIAEoAgAgBGotAAAQ1CYCQCACLQAoQQRGDQAgAikDKCIFQv8Bg0IEUQ0AIAMgBTcCAAwDCyACQRRqEOkpRQ0ACwsgAkEIaiACQRRqEIAoIAIoAghBAXEEQCACKAIMIQEgA0EEOgAAIAMgATYCBAwBCyADQSVBwKPQAEELEM0aCyACQTBqJAACQCADLQAAQQRHBEAgAyADKQMANwMIIAAgA0EIahDQCQwBCyAAIAMoAgQ2AgQgAEEENgIACyADQRBqJAALVwEBfyMAQSBrIgIkACABKAIAQQJGBEAgACABKQIsNwMAIAJBIGokAA8LIAJBADYCGCACQQE2AgwgAkGsrM8ANgIIIAJCBDcCECACQQhqQbSszwAQ7ywAC1IBA38gACgCBCEBIAAoAgwiAiAAKAIAIgM2AAAgACADIAFBeHF2NgIAIAAgACgCBEEHcTYCBCAAIAAoAhAiACACIAFBA3ZqIgEgACABSRs2AgwLTAEBfiABQQF0IAJyrUL/AYMhAyAALQAYIgJBA2oiAUH/AXFBwABPBEAgACADIAEQ8BAPCyAAIAE6ABggACAAKQMQIAMgAq2GhDcDEAtfAQF/IwBBEGsiAiQAIAIgACgCACIAQQxqNgIMIAFB1Kb+AEEQQeSm/gBBBCAAQaSm/gBB6Kb+AEEKIABBEGpBtKb+AEHypv4AQQIgAkEMakHEpv4AEIkXIAJBEGokAAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQ0SggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLXwEBfyMAQRBrIgIkACACIAAoAgAiADYCDCABQazQgAFBCEH9x4ABQQYgAEEIakGM0IABQZHIgAFBBCAAQQxqQYzQgAFBtNCAAUEFIAJBDGpBnNCAARCJFyACQRBqJAAL6gYCAX8FfiABKAIAIAIQhyVFBEAjAEGAAWsiBSQAIAEgAhDQGiEGAkACQAJAIAFBDGotAABBAUYEQCAGQoCAgICAgICAgH9SDQEgBUEANgJoIAVBATYCXCAFQZyV/wA2AlggBUIENwJgIAMgBUHYAGogBCgCFBECAEUNAiAAQZOAgIB4NgIADAMLIAZCgICAgICAgICAf1IEQCAFIAZC6AeBIghCP4ciByAGQugHf3w3A0AgBSAHQugHgyAIfKdBwIQ9bDYCSCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBUE4ajYCYCAFIAVBQGs2AjggAyAFQdgAaiAEKAIUEQIARQ0CIABBk4CAgHg2AgAMAwsgBUEANgJoIAVBATYCXCAFQZyV/wA2AlggBUIENwJgIAMgBUHYAGogBCgCFBECAEUNASAAQZOAgIB4NgIADAILIAUgBkLoB38iB0KYeH4gBnwiCDcDECAFIAZC4NQDfyIJQkR+IAd8Igc3AxggBSAGQoC4mSl/Igo3AwggBSAGQoDd2wF/IgZCRH4gCXw3AyAgBSAKQmh+IAZ8NwMoAkAgCEIAUwRAIAUgByAHQj+HIgaFIAZ9NwMwIAVCACAIfTcDOCAFQQU2AlQgBUGYlv8ANgJQIAVBBjYCRCAFQZiX/wA2AkAgBUHuBjYCfCAFQe4GNgJ0IAVB7gY2AmwgBUHuBjYCZCAFQe4GNgJcIAUgBUE4ajYCeCAFIAVBMGo2AnAgBSAFQSBqNgJoIAUgBUEoajYCYCAFIAVBCGo2AlggBUEFNgJMIAUgBUHYAGo2AkgMAQsgBUEFNgJUIAVBmJb/ADYCUCAFQQY2AkQgBUHolf8ANgJAIAVBBTYCTCAFQe4GNgJ8IAVB7gY2AnQgBUHuBjYCbCAFQe4GNgJkIAVB7gY2AlwgBSAFQdgAajYCSCAFIAVBEGo2AnggBSAFQRhqNgJwIAUgBUEgajYCaCAFIAVBKGo2AmAgBSAFQQhqNgJYCyADIAVBQGsgBCgCFBECAEUNACAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVBgAFqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALmAEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgQQF2IgYgAksEQCAAIAEoAgAgBSgCHCACQQF0ai4BACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8QDAQR/IAEoAhAaIwBBMGsiBSQAIAFBEGooAgAiBigCICACTQRAQciDhgFBLUH4g4YBEJ8pAAsgBigCHCACai0AACEIIAEtAAxBAUYEQAJ/IAYoAiAgAksEQAJAIAYoAiQEfyACIAYoAixBAnYiB08NASAGKAIoIAJBAnRqKAIABSACCwwCCyACIAdBvISGARDDIQALQYiEhgFBJEGshIYBEJ8pAAshAgsCQAJAIAEoAggiByAIwCIGSwRAIAEoAgQgBkEEdGoiASgCAEUNASAFIAE2AgwgBUECNgIUIAVBvPWAATYCECAFQgE3AhwgBUGDETYCLCAFIAVBKGo2AhggBSAFQQxqNgIoAkAgAyAFQRBqIAQoAhQRAgAEQCAAQZOAgIB4NgIADAELIAVBEGogASgCCCACIAMgBCABKAIMKAIMEQcAIAUoAhAiAUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgATYCAAwBCyADQf0AIAQoAhARAgAEQCAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVBMGokAAwCCyAGIAdBmPWAARDDIQALQaj1gAEQsjsACwvzAgICfwF+IAEoAhAgAhCHJUUEQCMAQYABayIFJAAgBSABQRBqIgYgAhDQGiIHNwMAIAVBJGogBxD9FQJAIAUoAiRFBEAgBSAGKAIANgJsIAVBAjYCWCAFQdyU/wA2AlQgBUICNwJgIAVBpwQ2AnwgBUHuBjYCdCAFIAVB8ABqNgJcIAUgBUHsAGo2AnggBSAFNgJwIAVBxABqIAVB1ABqEJkOIAVBEGogBUHMAGooAgAiATYCACAFIAUpAkQiBzcDGCAFIAc3AwggBSgCUCECIABBDGogATYCACAAIAc3AgQgACACNgIQIABBgoCAgHg2AgAMAQsgBUE4aiAFQSxqKAIANgIAIAUgBSkCJDcDMCAAIAMgBCAFQTBqIAEoAgAgASgCBCABKAIIIAEoAgwQhwoLIAVBgAFqJAAPCwJAIAEoAhgiAgRAIAMgASgCFCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALzAQCA38CfiABKAIAIAIQhyVFBEAgAUEMaiEGIwBB8ABrIgUkACAFIAEgAhDQGiIINwMAAkACQCAIQsCEPX8iCaciAkH/ogVNBEAgCCAJQsCEPX59p0HoB2wiB0GAqNa5B0kNAQsgBSABKAIANgIMIAVBAjYCMCAFQYCV/wA2AiwgBUICNwI4IAVBpwQ2AmwgBUHuBjYCZCAFIAVB4ABqNgI0IAUgBUEMajYCaCAFIAU2AmAgBUEYaiAFQSxqEJkOIAUpAhghCCAAIAUpAiA3AgwgACAINwIEIABBgoCAgHg2AgAMAQsgBSAHNgIQIAUgAjYCDAJAAkAgBigCACIBBEAgBUEBNgIYIAVBtJP/ADYCFCAFQgE3AiAgBUGRDDYCZCAFQQA2AlwgBUEAOgBYIAVCBDcCUCAFIAE2AkggBUGAgICAeDYCOCAFIAc2AjQgBSACNgIwIAVBATYCLCAFIAYoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvNBQICfwV+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACENAaIgc3AwACQAJAAkAgByAHQugHfyIHQugHfn0iCEI/hyIJIAd8IgcgB0KAowV/IgdCgKMFfn0iCkI/hyILIAd8IgdCxY3U/wd9QoCAgIBwVA0AIAenQbvyK2oQ8xYiAkUNACAFIAlC6AeDIAh8p0HAhD1sNgI0IAUgC0KAowWDIAp8PgIwIAUgAjYCLCAFQQxqIAVBLGoQyi8gBSgCDCICDQELIAUgASgCADYCJCAFQQI2AjAgBUGAlf8ANgIsIAVCAjcCOCAFQacENgJsIAVB7gY2AmQgBSAFQeAAajYCNCAFIAVBJGo2AmggBSAFNgJgIAVBEGogBUEsahCZDiAFKAIQIQEgBSkCFCEHIAAgBSgCHDYCECAAIAc3AgggACABNgIEIABBgoCAgHg2AgAMAQsgBSAFKQIQIgc3AmQgBSACNgJgAkACQCAGKAIAIgEEQCAFQQE2AhAgBUG0k/8ANgIMIAVCATcCGCAFQZEMNgIoIAUgAjYCXCAFQQA6AFggBUIENwJQIAUgATYCSCAFQYCAgIB4NgI4IAVBATYCLCAFIAYoAgQ2AkwgBSAHPgIwIAUgB0IgiD4CNCAFIAVBJGo2AhQgBSAFQSxqIgE2AiQgAyAFQQxqIAQoAhQRAgBFDQEgAEGTgICAeDYCACABEIkvDAMLIAVBATYCMCAFQbST/wA2AiwgBUIBNwI4IAVBkww2AhAgBSAFQQxqNgI0IAUgBUHgAGo2AgwgAyAFQSxqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQSxqEIkvCyAAQZSAgIB4NgIACyAFQfAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8oEAgN/An4gASgCACACEIclRQRAIAFBDGohBiMAQfAAayIFJAAgBSABIAIQ0BoiCDcDAAJAAkAgCCAIQoCU69wDfyIIQoCU69wDfn0iCUIAWQRAIAinIgJBgKMFSQ0BCyAFIAEoAgA2AgwgBUECNgIwIAVBgJX/ADYCLCAFQgI3AjggBUGnBDYCbCAFQe4GNgJkIAUgBUHgAGo2AjQgBSAFQQxqNgJoIAUgBTYCYCAFQRhqIAVBLGoQmQ4gBSkCGCEIIAAgBSkCIDcCDCAAIAg3AgQgAEGCgICAeDYCAAwBCyAFIAI2AgwgBSAJpyIBNgIQAkACQCAGKAIAIgcEQCAFQQE2AhggBUG0k/8ANgIUIAVCATcCICAFQZEMNgJkIAVBADYCXCAFQQA6AFggBUIENwJQIAUgBzYCSCAFQYCAgIB4NgI4IAUgATYCNCAFIAI2AjAgBUEBNgIsIAUgBigCBDYCTCAFIAVB4ABqNgIcIAUgBUEsaiIBNgJgIAMgBUEUaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAgARCJLwwDCyAFQQE2AjAgBUG0k/8ANgIsIAVCATcCOCAFQZQMNgIYIAUgBUEUajYCNCAFIAVBDGo2AhQgAyAFQSxqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQSxqEIkvCyAAQZSAgIB4NgIACyAFQfAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5gBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCIEEDdiIGIAJLBEAgACABKAIAIAUoAhwgAkEDdGooAgAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvzAgICfwF+IAEoAhAgAhCHJUUEQCMAQYABayIFJAAgBSABQRBqIgYgAhDQGiIHNwMAIAVBJGogBxDWFQJAIAUoAiRFBEAgBSAGKAIANgJsIAVBAjYCWCAFQdyU/wA2AlQgBUICNwJgIAVBpwQ2AnwgBUHuBjYCdCAFIAVB8ABqNgJcIAUgBUHsAGo2AnggBSAFNgJwIAVBxABqIAVB1ABqEJkOIAVBEGogBUHMAGooAgAiATYCACAFIAUpAkQiBzcDGCAFIAc3AwggBSgCUCECIABBDGogATYCACAAIAc3AgQgACACNgIQIABBgoCAgHg2AgAMAQsgBUE4aiAFQSxqKAIANgIAIAUgBSkCJDcDMCAAIAMgBCAFQTBqIAEoAgAgASgCBCABKAIIIAEoAgwQhwoLIAVBgAFqJAAPCwJAIAEoAhgiAgRAIAMgASgCFCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL8wICAn8BfiABKAIQIAIQhyVFBEAjAEGAAWsiBSQAIAUgAUEQaiIGIAIQ0BoiBzcDACAFQSRqIAcQ/RcCQCAFKAIkRQRAIAUgBigCADYCbCAFQQI2AlggBUHclP8ANgJUIAVCAjcCYCAFQacENgJ8IAVB7gY2AnQgBSAFQfAAajYCXCAFIAVB7ABqNgJ4IAUgBTYCcCAFQcQAaiAFQdQAahCZDiAFQRBqIAVBzABqKAIAIgE2AgAgBSAFKQJEIgc3AxggBSAHNwMIIAUoAlAhAiAAQQxqIAE2AgAgACAHNwIEIAAgAjYCECAAQYKAgIB4NgIADAELIAVBOGogBUEsaigCADYCACAFIAUpAiQ3AzAgACADIAQgBUEwaiABKAIAIAEoAgQgASgCCCABKAIMEIcKCyAFQYABaiQADwsCQCABKAIYIgIEQCADIAEoAhQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5gBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCIEECdiIGIAJLBEAgACABKAIAIAUoAhwgAkECdGooAgAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAumBAICfwF+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACEM8aIgI2AggCQCACQYCjBU8EQCAFIAEoAgA2AgwgBUECNgIwIAVBgJX/ADYCLCAFQgI3AjggBUGnBDYCbCAFQZwDNgJkIAUgBUHgAGo2AjQgBSAFQQxqNgJoIAUgBUEIajYCYCAFQRhqIAVBLGoQmQ4gBSkCGCEHIAAgBSkCIDcCDCAAIAc3AgQgAEGCgICAeDYCAAwBCyAFQQA2AhAgBSACNgIMAkACQCAGKAIAIgEEQCAFQQE2AhggBUG0k/8ANgIUIAVCATcCICAFQZEMNgJkIAVBADYCXCAFQQA6AFggBUIENwJQIAUgATYCSCAFQoCAgICAgICAgH83AjQgBSACNgIwIAVBATYCLCAFIAYoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvPBAIGfwJ+IAEoAgAgAhCHJUUEQCABQQxqIQcjAEEwayIFJAACQCABKAIAIgEoAhRBA3YiBiACSwRAIAVBJGohBiABKAIQIAJBA3RqKQMAIQsgBy0AACEIIActAAEhByMAQUBqIgEkAAJAAkACQCALQgBZBEAgAUEgakETQQBBAUEBEKAYIAEoAiQhAiABKAIgQQFGDQIgAUEANgI8IAEgASgCKDYCOCABIAI2AjQMAQsgAUEgakEUQQBBAUEBEKAYIAEoAiQhAiABKAIgQQFGDQEgAUEANgI8IAEgASgCKDYCOCABIAI2AjQgAUE0akEBEIQuIAEoAjggASgCPGpBLToAACABQQE2AjwLIAFBCGoiAkETIAsgC0I/hyIMhSAMfSABQSBqIglBExDtECIKazYCBCACIAkgCmo2AgAgAUE0aiABKAIIIgIgAiABKAIMahC9JiABQRhqIAFBPGooAgAiAjYCACABIAEpAjQ3AxAgBiABKAIUIAIgCCAHEL0JIAFBEGoQ3jsgAUFAayQADAELIAIgASgCKEGsvYUBEP0vAAsgBUGQDDYCICAFQQE2AgggBUG0k/8ANgIEIAVCATcCECAFIAY2AhwgBSAFQRxqNgIMIAMgBUEEaiAEKAIUEQIAIQEgBhDeOyAAQZOAgIB4QZSAgIB4IAEbNgIAIAVBMGokAAwBCyACIAZBmJT/ABDDIQALDwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC74EAQV/IAEoAgwgAhCUJUUEQCACIQcjAEEwayIFJAAgASgCCCEGIAEoAgQhAgJAIANB+wAgBCgCECIIEQIABEAgAEGTgICAeDYCAAwBCyACIQEgBgRAIAUgATYCDCAFQQI2AhQgBUGk9IABNgIQIAVCATcCHCAFQYMRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAQoAhQRAgAEQCAAQZOAgIB4NgIADAILIAVBEGogAigCCCAHIAMgBCACKAIMKAIMEQcAIAUoAhAiAUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgATYCAAwCCyACQRBqIQELIAIgBkEEdGoiAiABRwRAIAQoAhQhBgNAIAUgATYCDCAFQQI2AhQgBUG49IABNgIQIAVCATcCHCAFQYMRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAYRAgAEQCAAQZOAgIB4NgIADAMLIAVBEGogAUEIaigCACAHIAMgBCABQQxqKAIAKAIMEQcAIAUoAhAiCUGUgICAeEcEQCAAIAUpAhQ3AgQgAEEMaiAFQRxqKQIANwIAIAAgCTYCAAwDCyABQRBqIgEgAkcNAAsLIANB/QAgCBECAARAIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIUIgIEQCADIAEoAhAgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC7kBAQN/IAEoAgggAhCSJUUEQAJAIAJBAWoiBiABQQhqKAIAIgcoAhxBA3YiBUkEQCACIAVJDQEgAiAFQezpgAEQwyEACyAGIAVB3OmAARDDIQALIAAgAyAEIAcoAhgiACACQQN0aigCACAAIAZBA3RqKAIAIAEoAgAgASgCBBChEg8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuyBAEFfyABKAIAIAIQhyVFBEAgAUEMaiEHIwBBMGsiBSQAAkAgASgCACIBKAIUQQJ2IgYgAksEQCAFQSRqIQYgASgCECACQQJ0aigCACEIIActAAAhCSAHLQABIQcjAEEwayIBJAACQAJAAkAgCEEATgRAIAFBIGpBCkEAQQFBARCgGCABKAIkIQIgASgCIEEBRg0CIAFBADYCHCABIAEoAig2AhggASACNgIUDAELIAFBIGpBC0EAQQFBARCgGCABKAIkIQIgASgCIEEBRg0BIAFBADYCHCABIAEoAig2AhggASACNgIUIAFBFGpBARCELiABKAIYIAEoAhxqQS06AAAgAUEBNgIcCyABIAggCEEfdSICcyACayABQQpqELAQIAFBFGogASgCACICIAIgASgCBGoQvSYgAUEoaiABQRxqKAIAIgI2AgAgASABKQIUNwMgIAYgASgCJCACIAkgBxC9CSABQSBqEN47IAFBMGokAAwBCyACIAEoAihBrL2FARD9LwALIAVBkAw2AiAgBUEBNgIIIAVBtJP/ADYCBCAFQgE3AhAgBSAGNgIcIAUgBUEcajYCDCADIAVBBGogBCgCFBECACEBIAYQ3jsgAEGTgICAeEGUgICAeCABGzYCACAFQTBqJAAMAQsgAiAGQZiU/wAQwyEACw8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvKBAIDfwF+IAEoAgAgAhCHJUUEQCABQQxqIQcjAEHwAGsiBSQAIAUgASACEM8aIgY2AggCQAJAIAZB6AdtIgJB/6IFTQRAIAYgAkHoB2xrQcCEPWwiBkGAqNa5B0kNAQsgBSABKAIANgIMIAVBAjYCMCAFQYCV/wA2AiwgBUICNwI4IAVBpwQ2AmwgBUGcAzYCZCAFIAVB4ABqNgI0IAUgBUEMajYCaCAFIAVBCGo2AmAgBUEYaiAFQSxqEJkOIAUpAhghCCAAIAUpAiA3AgwgACAINwIEIABBgoCAgHg2AgAMAQsgBSAGNgIQIAUgAjYCDAJAAkAgBygCACIBBEAgBUEBNgIYIAVBtJP/ADYCFCAFQgE3AiAgBUGRDDYCZCAFQQA2AlwgBUEAOgBYIAVCBDcCUCAFIAE2AkggBUGAgICAeDYCOCAFIAY2AjQgBSACNgIwIAVBATYCLCAFIAcoAgQ2AkwgBSAFQeAAajYCHCAFIAVBLGoiATYCYCADIAVBFGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIwIAVBtJP/ADYCLCAFQgE3AjggBUGUDDYCGCAFIAVBFGo2AjQgBSAFQQxqNgIUIAMgBUEsaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBUEsahCJLwsgAEGUgICAeDYCAAsgBUHwAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvYBAIBfwN+IAEoAgAgAhCHJUUEQCMAQeAAayIFJAAgASACENAaIgZC+KeNr7qTsRB9IQcCQAJAAkAgAUEMai0AAEEBRgRAIAdCkbDloYvZnV9UDQEgBSAGQoCjBX8iBzcDCCAFIAZCPH8iCEJEfiAGfDcDECAFIAZCkBx/IgZCRH4gCHw3AxggBSAHQmh+IAZ8NwMgIAVBBTYCLCAFQbyV/wA2AiggBUIENwI0IAVB7gY2AlwgBUHuBjYCVCAFQe4GNgJMIAVB7gY2AkQgBSAFQUBrNgIwIAUgBUEQajYCWCAFIAVBGGo2AlAgBSAFQSBqNgJIIAUgBUEIajYCQCADIAVBKGogBCgCFBECAEUNAiAAQZOAgIB4NgIADAMLIAdCkbDloYvZnV9aBEAgBUEANgIwIAUgBjcDKCAFQQE2AkQgBUG0k/8ANgJAIAVCATcCTCAFQZUMNgIkIAUgBUEgajYCSCAFIAVBKGo2AiAgAyAFQUBrIAQoAhQRAgBFDQIgAEGTgICAeDYCAAwDCyAFQQA2AlAgBUEBNgJEIAVBnJX/ADYCQCAFQgQ3AkggAyAFQUBrIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFQQA2AlAgBUEBNgJEIAVBnJX/ADYCQCAFQgQ3AkggAyAFQUBrIAQoAhQRAgBFDQAgAEGTgICAeDYCAAwBCyAAQZSAgIB4NgIACyAFQeAAaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+EEAQJ/IAEoAgAgAhCHJUUEQCABQQxqIQYjAEHwAGsiBSQAIAUgASACEM8aIgI2AgwCQAJAAkAgAqxCxY3U/wd9QoCAgIBwVA0AIAJBu/IrahDzFiICRQ0AIAVCADcCLCAFIAI2AiggBUEQaiAFQShqEMovIAUoAhAiAg0BCyAFIAEoAgA2AlwgBUECNgIsIAVBgJX/ADYCKCAFQgI3AjQgBUGnBDYCbCAFQZwDNgJkIAUgBUHgAGo2AjAgBSAFQdwAajYCaCAFIAVBDGo2AmAgBUEUaiAFQShqEJkOIAAgBSkCGDcCCCAAQRBqIAVBIGooAgA2AgAgACAFKAIUNgIEIABBgoCAgHg2AgAMAQsgBSACNgJcAkACQCAGKAIAIgEEQCAFQQE2AhQgBUG0k/8ANgIQIAVCATcCHCAFQZEMNgJkIAUgAjYCWCAFQQA6AFQgBUIENwJMIAUgATYCRCAFQYCAgIB4NgI0IAVBADYCKCAFIAYoAgQ2AkggBSAFQeAAajYCGCAFIAVBKGoiATYCYCADIAVBEGogBCgCFBECAEUNASAAQZOAgIB4NgIAIAEQiS8MAwsgBUEBNgIsIAVBtJP/ADYCKCAFQgE3AjQgBUGSDDYCFCAFIAVBEGo2AjAgBSAFQdwAajYCECADIAVBKGogBCgCFBECAEUNASAAQZOAgIB4NgIADAILIAVBKGoQiS8LIABBlICAgHg2AgALIAVB8ABqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALkgEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgIgYgAksEQCAAIAEoAgAgBSgCHCACaiwAACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC5IBAQJ/IAEoAgggAhCIJUUEQAJAIAFBCGooAgAiBSgCICIGIAJLBEAgACABKAIAIAUoAhwgAmotAAAgAyAEIAEoAgQoAgwRBwAMAQsgAiAGQczpgAEQwyEACw8LAkAgASgCECICBEAgAyABKAIMIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAu5AQEDfyABKAIIIAIQkiVFBEACQCACQQFqIgYgAUEIaigCACIHKAIcQQJ2IgVJBEAgAiAFSQ0BIAIgBUHs6YABEMMhAAsgBiAFQdzpgAEQwyEACyAAIAMgBCAHKAIYIgAgAkECdGooAgAgACAGQQJ0aigCACABKAIAIAEoAgQQoRIPCwJAIAEoAhAiAgRAIAMgASgCDCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALmAEBAn8gASgCCCACEIglRQRAAkAgAUEIaigCACIFKAIgQQF2IgYgAksEQCAAIAEoAgAgBSgCHCACQQF0ai8BACADIAQgASgCBCgCDBEHAAwBCyACIAZBzOmAARDDIQALDwsCQCABKAIQIgIEQCADIAEoAgwgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC84FAgF/BX4gASgCACACEIclRQRAIwBBgAFrIgUkACABIAIQ0BohBgJAAkAgAUEMai0AAEUEQCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBkLAhD2BIghCP4ciByAGQsCEPX98NwNAIAUgB0LAhD2DIAh8p0HoB2w2AkggBSAFQThqNgJgIAUgBUFAazYCOCADIAVB2ABqIAQoAhQRAgBFDQEgAEGTgICAeDYCAAwCCyAFIAZCwIQ9fyIHQsD7Qn4gBnwiCDcDECAFIAZCgI7OHH8iCUJEfiAHfCIHNwMYIAUgBkKAwN3uwQJ/Igo3AwggBSAGQoDIzrQNfyIGQkR+IAl8NwMgIAUgCkJofiAGfDcDKAJAIAhCAFMEQCAFIAcgB0I/hyIGhSAGfTcDMCAFQgAgCH03AzggBUEFNgJUIAVByJf/ADYCUCAFQQY2AkQgBUGYl/8ANgJAIAVB7gY2AnwgBUHuBjYCdCAFQe4GNgJsIAVB7gY2AmQgBUHuBjYCXCAFIAVBOGo2AnggBSAFQTBqNgJwIAUgBUEgajYCaCAFIAVBKGo2AmAgBSAFQQhqNgJYIAVBBTYCTCAFIAVB2ABqNgJIDAELIAVBBTYCVCAFQciX/wA2AlAgBUEGNgJEIAVB6JX/ADYCQCAFQQU2AkwgBUHuBjYCfCAFQe4GNgJ0IAVB7gY2AmwgBUHuBjYCZCAFQe4GNgJcIAUgBUHYAGo2AkggBSAFQRBqNgJ4IAUgBUEYajYCcCAFIAVBIGo2AmggBSAFQShqNgJgIAUgBUEIajYCWAsgAyAFQUBrIAQoAhQRAgBFDQAgAEGTgICAeDYCAAwBCyAAQZSAgIB4NgIACyAFQYABaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC9gFAgF/BX4gASgCACACEIclRQRAIwBBgAFrIgUkACABIAIQ0BohBgJAAkAgAUEMai0AAEUEQCAFQQE2AlwgBUG0k/8ANgJYIAVCATcCZCAFQZUMNgI8IAUgBkKAlOvcA4EiCEI/hyIHIAZCgJTr3AN/fDcDQCAFIAdCgJTr3AODIAh8PgJIIAUgBUE4ajYCYCAFIAVBQGs2AjggAyAFQdgAaiAEKAIUEQIARQ0BIABBk4CAgHg2AgAMAgsgBSAGQoCU69wDfyIHQoDslKN8fiAGfCIINwMQIAUgBkKAsJ3C3wF/IglCRH4gB3wiBzcDGCAFIAZCgIC8isnSE38iCjcDCCAFIAZCgMDihePoAH8iBkJEfiAJfDcDICAFIApCaH4gBnw3AygCQCAIQgBTBEAgBSAHIAdCP4ciBoUgBn03AzAgBUIAIAh9NwM4IAVBBTYCVCAFQcCY/wA2AlAgBUEGNgJEIAVBmJf/ADYCQCAFQe4GNgJ8IAVB7gY2AnQgBUHuBjYCbCAFQe4GNgJkIAVB7gY2AlwgBSAFQThqNgJ4IAUgBUEwajYCcCAFIAVBIGo2AmggBSAFQShqNgJgIAUgBUEIajYCWCAFQQU2AkwgBSAFQdgAajYCSAwBCyAFQQU2AlQgBUHAmP8ANgJQIAVBBjYCRCAFQeiV/wA2AkAgBUEFNgJMIAVB7gY2AnwgBUHuBjYCdCAFQe4GNgJsIAVB7gY2AmQgBUHuBjYCXCAFIAVB2ABqNgJIIAUgBUEQajYCeCAFIAVBGGo2AnAgBSAFQSBqNgJoIAUgBUEoajYCYCAFIAVBCGo2AlgLIAMgBUFAayAEKAIUEQIARQ0AIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUGAAWokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvZAwIEfwR+IAEoAgAgAhCHJUUEQCABQQxqIQYjAEEwayIFJAACQCABKAIAIgEoAhRBBXYiByACSwRAIAEoAhAgAkEFdGoiASkDACEJIAEpAwghCiABKQMQIQsgASkDGCEMIAYtAAAhByAGLQABIQYjAEHQAGsiASQAIAEgDDcDGCABIAs3AxAgASAKNwMIIAEgCTcDACABQQA2AjwgAUKAgICAEDcCNCABQay8hQE2AkQgAUKggICADjcCSCABIAFBNGo2AkAgASABQUBrEIENBEBB1LyFAUE3IAFBKGpBxLyFAUGMvYUBENUeAAsgAUEwaiABQTxqKAIAIgg2AgAgASABKQI0NwMoIAVBJGoiAiABKAIsIAggByAGEL0JIAFBKGoQ3jsgAUHQAGokACAFQZAMNgIgIAVBATYCCCAFQbST/wA2AgQgBUIBNwIQIAUgAjYCHCAFIAVBHGo2AgwgAyAFQQRqIAQoAhQRAgAhASACEN47IABBk4CAgHhBlICAgHggARs2AgAgBUEwaiQADAELIAIgB0GYlP8AEMMhAAsPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL7gQCBn8CfiABKAIAIAIQhyVFBEAgAUEMaiEHIwBBMGsiBSQAAkAgASgCACIBKAIUQQR2IgYgAksEQCAFQSRqIQYgASgCECACQQR0aiIBKQMAIQwgASkDCCELIActAAAhCSAHLQABIQcjAEHQAGsiASQAAkACQAJAIAtCAFkEQCABQRxqQSdBAEEBQQEQoBggASgCICECIAEoAhxBAUYNAiABQQA2AkwgASABKAIkNgJIIAEgAjYCRAwBCyABQRxqQShBAEEBQQEQoBggASgCICECIAEoAhxBAUYNASABQQA2AkwgASABKAIkNgJIIAEgAjYCRCABQcQAakEBEIQuIAEoAkggASgCTGpBLToAACABQQE2AkwLIAFBCGoiAkEnQgAgDH0gDCALQgBTIggbQgAgCyAMQgBSrXx9IAsgCBsgAUEcaiIIEPoCIgprNgIEIAIgCCAKajYCACABQcQAaiABKAIIIgIgAiABKAIMahC9JiABQRhqIAFBzABqKAIAIgI2AgAgASABKQJENwMQIAYgASgCFCACIAkgBxC9CSABQRBqEN47IAFB0ABqJAAMAQsgAiABKAIkQay9hQEQ/S8ACyAFQZAMNgIgIAVBATYCCCAFQbST/wA2AgQgBUIBNwIQIAUgBjYCHCAFIAVBHGo2AgwgAyAFQQRqIAQoAhQRAgAhASAGEN47IABBk4CAgHhBlICAgHggARs2AgAgBUEwaiQADAELIAIgBkGYlP8AEMMhAAsPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL8wICAn8BfiABKAIQIAIQhyVFBEAjAEGAAWsiBSQAIAUgAUEQaiIGIAIQ0BoiBzcDACAFQSRqIAcQgRUCQCAFKAIkRQRAIAUgBigCADYCbCAFQQI2AlggBUHclP8ANgJUIAVCAjcCYCAFQacENgJ8IAVB7gY2AnQgBSAFQfAAajYCXCAFIAVB7ABqNgJ4IAUgBTYCcCAFQcQAaiAFQdQAahCZDiAFQRBqIAVBzABqKAIAIgE2AgAgBSAFKQJEIgc3AxggBSAHNwMIIAUoAlAhAiAAQQxqIAE2AgAgACAHNwIEIAAgAjYCECAAQYKAgIB4NgIADAELIAVBOGogBUEsaigCADYCACAFIAUpAiQ3AzAgACADIAQgBUEwaiABKAIAIAEoAgQgASgCCCABKAIMEIcKCyAFQYABaiQADwsCQCABKAIYIgIEQCADIAEoAhQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+cFAQh/IAEoAhAgAhCTJUUEQCMAQSBrIgUkAAJAAkACQAJAIAJBAWoiByABQRBqKAIAIggoAkhBAnYiBkkEQAJAIAIgBkkEQCAIKAJEIgYgB0ECdGooAgAhByAGIAJBAnRqKAIAIQIgA0H7ACAEKAIQIggRAgBFDQEMBQsgAiAGQdj0gAEQwyEACyACIAdPDQIgBUEIaiABKAIAIAIgAyAEIAEoAgQoAgwRBwAgBSgCCCIGQZSAgIB4RwRAIAAgBSkCDDcCBCAAQQxqIAVBFGopAgA3AgAMBQsgBUEANgIYIAVBATYCDCAFQej0gAE2AgggBUIENwIQIAMgBUEIaiIGIAQoAhQRAgANAyAGIAEoAgggAiADIAQgASgCDCgCDBEHACAFKAIIIgZBlICAgHhGDQEgACAFKQIMNwIEIABBDGogBUEUaikCADcCAAwECyAHIAZByPSAARDDIQALIAJBAWohAgsgAiAHSQRAIAEoAgwhCSABKAIIIQogASgCBCELIAEoAgAhDCAEKAIUIQEDQCAFQQA2AhggBUHw9IABNgIIIAVCBDcCECAFQQE2AgwgAyAFQQhqIgYgARECAA0CIAYgDCACIAMgBCALKAIMEQcAIAUoAggiBkGUgICAeEcEQCAAIAUpAgw3AgQgAEEMaiAFQRRqKQIANwIADAQLIAVBADYCGCAFQQE2AgwgBUHo9IABNgIIIAVCBDcCECADIAVBCGoiBiABEQIADQIgBiAKIAIgAyAEIAkoAgwRBwAgBSgCCCIGQZSAgIB4RwRAIAAgBSkCDDcCBCAAQQxqIAVBFGopAgA3AgAMBAsgByACQQFqIgJHDQALC0GTgICAeEGUgICAeCADQf0AIAgRAgAbIQYMAQtBk4CAgHghBgsgACAGNgIAIAVBIGokAA8LAkAgASgCGCICBEAgAyABKAIUIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAtRAQF/IAAQtAwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahC7IwsLyAEBA38gACABKAIMIAEoAgQiAmsiBEEMbiIDEP0tIAQEQCAAKAIEIAAoAghBDGxqIAIgBPwKAAALIAEgAjYCDCAAIAAoAgggA2o2AggjAEEQayICJAAgASgCDCIDIAEoAgQiAGtBDG4hBCAAIANHBEADQCAAKAIAIgMgAygCACIDQQFrNgIAIANBAUYEQCAAEPseCyAAQQxqIQAgBEEBayIEDQALCyACIAEoAgA2AgwgAiABKAIINgIIIAJBCGoQ6DsgAkEQaiQAC1EBAX8gABC2DCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSBqELsjCwtRAQF/IAAQtwwgACgCDCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEMahD7HgsgACgCICIBIAEoAgAiAUEBazYCACABQQFGBEAgAEEgahC7IwsLVgECfyMAQSBrIgMkACADIAEQyzoiBDYCBCAERQRAIAAgARDINCAAIAI2AjggA0EgaiQADwsgA0EANgIIQQAgA0EEakHIg4MBIANBCGpBzIODARCvKwALUQEBfyAAEL4MIAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+x4LIAAoAiAiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBIGoQuyMLC1ABAn8gACgCCCICBEAgACgCBCEAA0ACQCAAKAIAIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAQuyMLIABBCGohACACQQFrIgINAAsLC1EBAX8gABDBDCAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPseCyAAKAIgIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQSBqELsjCwtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEN0mIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEP0cIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEP4cIARBEGokAAtQAQN/IwBBEGsiBCQAIAEoAgAiBSAFKAIAIgZBAWo2AgAgBkEASARAAAsgBCAFNgIEIAQgASkCBDcCCCAAIARBBGogAiADEIAdIARBEGokAAtSAQF/IwBBEGsiAiQAIAJBCGogASgCACABKAIEIgEoAghBAWtBeHFqQQhqIAEoAhARAAAgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQAC1IBAX8jAEEgayIBJAAgAC0ADEEhRgRAIAAtAA0gAUEgaiQADwsgAUEANgIYIAFBATYCDCABQaCFhgE2AgggAUIENwIQIAFBCGpBqIWGARDvLAALSwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACENsoIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIC08BAX8gAiABayICIAAoAgAgACgCCCIDa0sEQCAAIAMgAkEBQQEQ3CggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDeKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtTAQJ/IwBBEGsiAiQAAkAgASgCCCIDIAEoAgRJBEAgAEEAOgAAIAAgASgCACADai0AADoAAQwBCyACQQQ2AgQgACABIAJBBGoQnSkLIAJBEGokAAtLAQF/IAIgAWsiAiAAKAIAIAAoAggiA2tLBEAgACADIAIQ4CggACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AggLTwEBfyACIAFrIgIgACgCACAAKAIIIgNrSwRAIAAgAyACQQFBARDhKCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCAtNAQF/IAAoAggiACgCACAAKAIIIgNrIAJJBEAgACADIAIQhRMgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/AkACQAJAIAAtAEQOBAECAgACCyAALQA4QQNGBEAgAEE0ahCwLAsLIAAoAggiAUGDAUsEQCABEPIfCyAAQUBrEK8sCwtnAQJ/IABBIGohAQNAIAEoAgQiAgRAIAEgAhCMHRCJJAwBCwsgACgCICICIAIoAgAiAkEBazYCACACQQFGBEAgARDbHwsgAEEsaiIBEIIjIAFBCEEgEOAeIABBQGsiABDUJyAAEO47C2cBAn8gAEEQaiEBA0AgASgCBCICBEAgASACEIsdEIgkDAELCyAAKAIQIgIgAigCACICQQFrNgIAIAJBAUYEQCABENofCyAAQRxqIgEQgiMgAUEIQSAQ4B4gAEFAayIAENQnIAAQ7jsLpgIBA38jAEEQayIEJAAgBCABNgIMAkACQAJAAkAgAUEIaiIDLQAoRQRAIAMtAAwgA0EBOgAMDQMgAygCAEGAgICAeEcNASADQQA6AAwgAyACKQIANwIAIANBCGogAkEIaigCADYCACADLQAoRQ0CIAMtAAwgA0EBOgAMDQIgAygCACECIANBgICAgHg2AgAgAkGAgICAeEcEQCAAIAMpAgQ3AgQgACACNgIAIANBADoADAwFCyADQQA6AAwMAgsMAgtBiIHDAEEgQaiBwwAQnykACyAAQYCAgIB4NgIADAELIAAgAikCADcCACAAQQhqIAJBCGooAgA2AgALIAMQlR8gASABKAIAIgBBAWs2AgAgAEEBRgRAIARBDGoQxyELIARBEGokAAugAgEDfyMAQRBrIgQkACAEIAE2AgwCQAJAAkACQCABQQhqIgMtACxFBEAgAy0AECADQQE6ABANAyADKAIADQEgA0EAOgAQIAMgAikCADcCACADQQhqIAJBCGopAgA3AgAgAy0ALEUNAiADLQAQIANBAToAEA0CIAMoAgAhAiADQQA2AgAgAgRAIAAgAjYCACADQQA6ABAgACADKQIENwIEIABBDGogA0EMaigCADYCAAwFCyADQQA6ABAMAgsMAgtBiIHDAEEgQaiBwwAQnykACyAAQQA2AgAMAQsgACACKQIANwIAIABBCGogAkEIaikCADcCAAsgAxCTHyABIAEoAgAiAEEBazYCACAAQQFGBEAgBEEMahDtHQsgBEEQaiQAC6YCAQN/IwBBEGsiBCQAIAQgATYCDAJAAkACQAJAIAFBCGoiAy0ALEUEQCADLQAQIANBAToAEA0DIAMoAgBBB0cNASADQQA6ABAgAyACKQIANwIAIANBCGogAkEIaikCADcCACADLQAsRQ0CIAMtABAgA0EBOgAQDQIgAygCACECIANBBzYCACACQQdHBEAgACACNgIAIANBADoAECAAIAMpAgQ3AgQgAEEMaiADQQxqKAIANgIADAULIANBADoAEAwCCwwCC0GIgcMAQSBBqIHDABCfKQALIABBBzYCAAwBCyAAIAIpAgA3AgAgAEEIaiACQQhqKQIANwIACyADEJMfIAEgASgCACIAQQFrNgIAIABBAUYEQCAEQQxqEJYfCyAEQRBqJAALUQEBf0EYQQgQrTYiAkUEQEEIQRgQoz0ACyAAIAI2AgQgAEEBNgIAIAIgASkDADcDACACQRBqIAFBEGopAwA3AwAgAkEIaiABQQhqKQMANwMAC1MBAX8gABDSJCAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABDUIgsCQCAAKAIEIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBBGoQ6ScLC1UBAX9BFEEEEK02IgJFBEBBBEEUEKM9AAsgACACNgIEIABBgICAgHg2AgAgAiABKQIANwIAIAJBEGogAUEQaigCADYCACACQQhqIAFBCGopAgA3AgALUAECfyABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0EDdCAEQQN2IAIQgRYgACADNgIEIAEgAiADajYCFCAAQQg2AgALUAECfyABKAIEIAEoAggiBCACIAEoAhAgASgCFCICayIFIAMgAyAFSxsiA0ECdCAEQQJ2IAIQghYgACADNgIEIAEgAiADajYCFCAAQQg2AgALUAEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCwJAIAAoAhQiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahD7HgsLhAEBAX9BASEDAkACQAJAAkACQCAALQAAQQFrDhECAgEDAwMDBAIBAQEDAgICAAELAkAgAUH/AXFBAWsOFgECAgIBAwMDAwMDAQEBAQMDAwMBAQIAC0KBgICQgIDAgAEgAkEDdK1C+AGDiKchAwsgAw8LQQIPC0EADwsgAC0AAkF/c0EBcQtLAgJ/AX4jAEEQayIDJAAgACgCACIAKAIAIANBCGogACgCBCABKAIAIAJBA3RrQQhrKQMAEPIdIAMoAgggAygCDBDNAiADQRBqJAALSQEDfwJAIAAoAhAiAUUNACABIAAoAggiAiAAKAIEIAFBAWpsakEBa0EAIAJrcSIDakEJaiIBRQ0AIAAoAgwgA2sgASACEPg6CwtZAQF/IAAgABCZPiIAQQdqQXhxIABrIgIQmD4hAEHM84oBIAEgAmsiATYCAEHU84oBIAA2AgAgACABQQFyNgIEIAAgARCYPkHg84oBQYCAgAE2AgBBKDYCBAtQAQF/AkAgASACTQRAIAIgACgCBCIESw0BIAIgAWsiAgRAIAAoAgAgAWogAyAC/AoAAAsPCyABIAJB0IH9ABCxOwALIAIgBEHQgf0AELA7AAtTACAAQgA3AhwgAEEANgIYIABCADcDECAAQQA2AgggAEEsakEANgIAIABBJGpCADcCACAAQc+Moo4GNgIMIABB95Svr3g2AgQgAEGoiI2hAjYCAAvYAQECfyABKAIEIgMgASgCAEkEQCADQQpJBEAgAEEEOgAAIAEgA0EBajYCBCABIANqIAI6AAgPCyADQQpBwLX+ABDDIQALIwBBEGsiASQAIAFBBGpBE0EAQQFBARCgGCABKAIIIQMCQAJAIAEoAgRBAUcEQCABKAIMIgRB0LX+AEET/AoAAEEMQQQQrTYiAkUNASACQRM2AgggAiAENgIEIAIgAzYCACAAQRUgAkHws/4AEMkpIAFBEGokAAwCCyADIAEoAgxBnLT+ABD9LwALQQRBDBCjPQALC0wBAX8gACgCCCIBBEAgACgCBEEIaiEAA0ACQCAAQQhrKAIARQ0AIAAoAgBBgICAgHhGDQAgABDeOwsgAEEUaiEAIAFBAWsiAQ0ACwsLTAECfyAAKAIIIgIEQCAAKAIEQQRqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAELsjCyAAQQxqIQAgAkEBayICDQALCwtJAQF/AkAgAiAEayIGIAIgA2siA08EQCACIARJDQEgACAGIANrNgIEIAAgASADajYCAA8LIAMgBiAFELE7AAsgBiACIAUQsDsAC0sBAX8jAEEQayIDJAAgASACEMUCIgIEfyADIAI2AgwgA0EMahDRH0G78itrIQFBAQVBAAshAiAAIAE2AgQgACACNgIAIANBEGokAAtLAgJ/AX4jAEEQayIDJAAgACgCACIAKAIAIANBCGogACgCBCABKAIAIAJBAnRrQQRrKAIAEIMaIAMoAgggAygCDBDNAiADQRBqJAALSwICfwF+IwBBEGsiAyQAIAAoAgAiACgCACADQQhqIAAoAgQgASgCACACQQJ0a0EEaygCABCCGiADKAIIIAMoAgwQzQIgA0EQaiQAC0wBAn8gACgCCCICBEAgACgCBEEEaiEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABD7HgsgAEEcaiEAIAJBAWsiAg0ACwsLSwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACAAKAIUQQhqKAIQaiEBIAAoAiAiAAR/IAEgAEEIaigCEGoFIAELC0wBAn8jAEEQayIEJAAgBEEEaiIFIAEgAiADEOYVIAAgBRDjGSABKAIAIgAgACgCACIAQQFrNgIAIABBAUYEQCABEPseCyAEQRBqJAALVgEBfyMAQRBrIgIkAAJ/IAAoAgAiACgCAEGAgICAeEcEQCACIAA2AgwgAUH8w4cBQQQgAkEMakGQxIcBENATDAELIAFB6MOHAUEEEPs1CyACQRBqJAALTAECfyAAKAIMIgIEQCAAKAIEQQRqIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPIlCyAAQQhqIQAgAkEBayICDQALCwtQAQN/IAAtAABBA0YEQCAAKAIEIgAoAgAhAiAAKAIEIgMoAgAiAQRAIAIgAREDAAsgAygCBCIBBEAgAiABIAMoAggQ+DoLIABBDEEEEPg6CwtTAAJAAkAgASgCFARAIAAoAgANASAAEIQNCyAAKAIARQ0BCyAAIAEoAgwiACAAIAEoAhBqIAEoAgQgASgCCBC/GA8LIAAgACgCFCABKAIQajYCFAtVAQF/IwBBIGsiAiQAIAJBGGogASgCACUBEBkgAkEQaiACKAIYIAIoAhwQtTYgAkEIaiACKAIQIAIoAhQQ+iggACACKAIIIAIoAgwQjzUgAkEgaiQAC0wBAn8jAEEQayIBJAAgAUEAOgAPQQFBARCtNiICRQRAQQFBARCjPQALIAAgAUEPaq03AwAgACACrTcDCCACQQFBARD4OiABQRBqJAALUwECfyMAQcACayICJAAgAkEIaiIDIAAQlRogAyABNgIcIANBATYCGCACQagBaiADQZgB/AoAACACQQA2AqABIAJBoAFqENEpQQhqIAJBwAJqJAALmAEBA38jAEHAAmsiAyQAIANBCGoiBCAAEJUaIANBqAFqIQAjAEEgayICJAACQCABBEAgBCABNgKQASAAIARBmAH8CgAAIAJBIGokAAwBCyACQQA2AhggAkEBNgIMIAJBoLHOADYCCCACQgQ3AhAgAkEIakGosc4AEO8sAAsgA0EANgKgASADQaABahDRKUEIaiADQcACaiQAC04BAX8gACgCAEGAgICAeEcEQCAAEN47IABBDGoiARDRKyABEOg7IABBGGoiARDRKyABEOg7IABBJGoQhTAgAEEwahCFMCAAQTxqEIUwCwtRAQF/IAAoAgAiACgCDCIBIAEoAgBBAWsiATYCACABRQRAIABBDGoQ1CILAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQRBBBBD4OgsLiQIBBX8jAEHQAGsiASQAIAFBCGoiABD+LCABQQA2AkgjAEGQAWsiAyQAAkACQAJAIAAoAkAiAgRAIAAQyylBASEEDAELIANByABqIgIQ/iwgA0EANgKIASADIABByAD8CgAAIAAgAkHIAPwKAABB0ABBCBCtNiICRQ0BIAJCgYCAgBA3AwAgAkEIaiADQcgA/AoAACAAEMspIAAoAkAiAEUNACAAKAJMBEAgAEHMAGoQvCoLIAAQ+S4gAEHUAEEEEPg6CyABIAI2AgQgASAENgIAIANBkAFqJAAMAQtBCEHQABCjPQALIAEoAgBBAXEEQEGS58MAQTEQlz0ACyABKAIEIAFB0ABqJAALiAICAX4HfwJAIAAoAgQiBkUNACAAKAIMIgcEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHAAWshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBaGxqQRhrIgQoAhAhCCAEKAIUIgQoAgAiBQRAIAggBREDAAsgBCgCBCIFBEAgCCAFIAQoAggQ+DoLIAFCAX0gAYMhASAHQQFrIgcNAAsLIAYgBkEYbEEfakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwtRAQF/IwBBEGsiAiQAAn8gACgCAARAIAIgADYCDCABQaSdxABBCEGsncQAQQYgAkEMakGUncQAEPYYDAELIAFBg53EAEEQEPs1CyACQRBqJAALUQEBfyMAQRBrIgIkAAJ/IAAoAgAEQCACIAA2AgwgAUHMrswAQQhB1K7MAEEGIAJBDGpBvK7MABD2GAwBCyABQauuzABBEBD7NQsgAkEQaiQAC/cBAgF+Bn8CQCAAKAIEIgVFDQAgACgCDCIGBEAgACgCACICQQhqIQMgAikDAEJ/hUKAgYKEiJCgwIB/gyEBA0AgAVAEQANAIAJBgAFrIQIgAykDACADQQhqIQNCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAIgAXqnQQF0QfABcWtBCGsiBygCACIEIAQoAgAiBEEBazYCACAEQQFGBEAgBxC7IwsgAUIBfSABgyEBIAZBAWsiBg0ACwsgBSAFQQR0QRdqQXhxIgJqQQlqIgNFDQAgACgCACACayADQQgQ+DoLC60CAgJ+Bn8CQCAAKAIEIgdFDQAgACgCDCIIBEAgACgCACIEQQhqIQUgBCkDAEJ/hUKAgYKEiJCgwIB/gyEBA0AgAVAEQANAIARBgAVrIQQgBSkDACAFQQhqIQVCgIGChIiQoMCAf4MiAUKAgYKEiJCgwIB/UQ0ACyABQoCBgoSIkKDAgH+FIQELIAQgAXqnQQN2QbB/bGoiA0EwaxCRDCADQcgAayIGEMUnIAYQ6DsgA0E8ayIGEKQsIAYQ9TwgAUIBfSECAkAgA0EcayIGKAIAIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIAYQ+x4LIAEgAoMhASAIQQFrIggNAAsLIAcgB0HQAGxB1wBqQXhxIgRqQQlqIgVFDQAgACgCACAEayAFQQgQ+DoLC1YBAX8gACgCACIAKAIMIgEQhzUgAUHAAEEIEPg6IAAoAhAiARCINSABQTBBCBD4OgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEUQQQQ+DoLC1ABAX8gAEEYahCVDCAAEMUnIAAQ6DsgAEEMaiIBEKQsIAEQ9TwCQCAAKAIsIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBLGoQ+x4LC0kBA38gASEDIAIhBCABKAIAIgUEQCABLwEEIQQgAkEBaiEDCyABQcQAQRQgAhtBBBD4OiAAIAU2AgAgACADrSAErUIghoQ3AgQLUQEBfwJAIAAoAgBFDQAgACgCBCIBBEAgAEEQaiAAKAIIIAAoAgwgASgCEBEBAAsgACgCFCIBRQ0AIABBIGogACgCGCAAKAIcIAEoAhARAQALC0wBAX9BAiECAkAgACgCAEGAgICAeEcEQCABIAAoAggiAk8NASAAKAIEIAFqLQAAIQILIAJBAkYgAnJBAXEPCyABIAJBhKnOABDDIQALXgACQCABKAIUQYCAgIB4Rg0AIAAoAqQBQYCAgIB4Rg0AIABBpAFqIAFBFGoQ+xcLAkAgASgCCEGAgICAeEYNACAAKAKYAUGAgICAeEYNACAAQZgBaiABQQhqEPsXCwteAAJAIAEoAhRBgICAgHhGDQAgACgCjAFBgICAgHhGDQAgAEGMAWogAUEUahD7FwsCQCABKAIIQYCAgIB4Rg0AIAAoAoABQYCAgIB4Rg0AIABBgAFqIAFBCGoQ+xcLC14AAkAgASgCFEGAgICAeEYNACAAKAKcAUGAgICAeEYNACAAQZwBaiABQRRqEPsXCwJAIAEoAghBgICAgHhGDQAgACgCkAFBgICAgHhGDQAgAEGQAWogAUEIahD7FwsLiAICAX4HfwJAIAAoAgQiBkUNACAAKAIMIgcEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHgAGshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBdGxqQQxrIgQoAgQhCCAEKAIIIgQoAgAiBQRAIAggBREDAAsgBCgCBCIFBEAgCCAFIAQoAggQ+DoLIAFCAX0gAYMhASAHQQFrIgcNAAsLIAYgBkEMbEETakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwtQAQF/IABBGGoQnQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwvhAQIBfgV/AkAgACgCBCIERQ0AIAAoAgwiBQRAIAAoAgAiAkEIaiEDIAIpAwBCf4VCgIGChIiQoMCAf4MhAQNAIAFQBEADQCACQYAEayECIAMpAwAgA0EIaiEDQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgAUKAgYKEiJCgwIB/hSEBCyACIAF6p0EDdEHAB3FrQUBqIgYQ0SsgBhDoOyABQgF9IAGDIQEgBUEBayIFDQALCyAEIARBBnRBxwBqQXhxIgJqQQlqIgNFDQAgACgCACACayADQQgQ+DoLC7EEAhZ/AX4jAEEwayIGJAAgBkEAOgAcIAZCATcCICAGQRBqIQkgBkEcaiECIwBBIGsiAyQAIANBFGogAUEAQQRBFBCgGCADKAIYIQcgAygCFEEBRgRAIAcgAygCHEHEntAAEP0vAAsgA0EQaiIOQQA2AgAgAyADKAIcNgIMIAMgBzYCCCADQQhqIggoAgAgCCgCCCIFayABSQRAIAggBSABQQRBFBDQKCAIKAIIIQULIAgoAgQgBUEUbGohBAJAAkAgAUECTwRAIAFBAWsiDCAFaiEFIAIoAgwiD0EIdiEQIAIpAgQiGEIgiKchESACLQACIRIgAi0AASETIAIoAhAhFCACKAIIIRUgAigCBCEWIAItAAAhDSAYpyEXA0AgFyEBIBEhBwJAAkACQCANQQJrDgUBAAAAAQILIAshASAKIQcMAQsgFiEBIBUhBwsgBCANOgAAIARBEGogFDYCACAEQQJqIBI6AAAgBEEBaiATOgAAIARBDGogD0H/AXEgEEEIdHI2AgAgBEEEaiABrSAHrUIghoQ3AgAgBEEUaiEEIAchCiABIQsgDEEBayIMDQALDAELIAFFDQELIAQgAikCADcCACAEQRBqIAJBEGooAgA2AgAgBEEIaiACQQhqKQIANwIAIAVBAWohBQsgCCAFNgIIIAlBCGogDigCADYCACAJIAMpAgg3AgAgA0EgaiQAIAZBCGogCUHMgs4AEJkhIAAgBikDCDcDACAGQTBqJAALUAEBfyAAQRhqEJ8MIAAQxScgABDoOyAAQQxqIgEQpCwgARD1PAJAIAAoAiwiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEsahD7HgsLjQUBC38gBEEMSwRAQVQPCyAEQQVJBEBBfw8LAn8gAiEPIAEgA0EBaiILIARsQQZqQQN2QQNqQYAEIAMbTyEMIARBAWohDiAEQQVrIQYgASAAIgNqQQJrIQ1BASAEdCIIQQFyIQlBBCEFQQAhACADIQRBASEKAkADQAJAAkACQCAJQQJJIAAgC09yDQAgCkEBcQRAIAUhByAAIQEMAgsgACALIAAgC0sbIQEgDyAAQQF0aiEHIAAhAgNAAkAgASACRwRAIAcvAQBFDQEgAiEBCyABIAtGDQJB//8DIAV0IQcDQCAAQRhqIgIgAU0EQCAMRSAEIA1LcQ0IIAQgBiAHaiIAOwAAIARBAmohBCAAQRB2IQYgAiEADAELCwNAIABBA2oiAiABTQRAQQMgBXQgBmohBiAFQQJqIQUgAiEADAELCyABIABrIAV0IAZqIQYgBUEPSARAIAVBAmohBwwECyAMRSAEIA1LcQ0GIAQgBjsAACAFQQ5rIQcgBkEQdiEGIARBAmohBAwDCyAHQQJqIQcgAkEBaiECDAALAAtBfyAJQQFHDQQaIAxFIAQgDUtxDQMgBCAGOwAAIAQgBUEHakEIbWogA2shCgwBC0F/IQogCSAPIAFBAXRqLgEAIgBBH3UiAiAAIAJza2oiAkEATA0AIAcgDmogCUF/cyAIQQF0aiIFQQAgAEEBaiIAIAhOGyAAaiIAIAVIayEFIABBAUchCiAAIAd0IAZqIQYgAUEBaiEAA0AgAiAISARAIAhBAXUhCCAOQQFrIQ4MAQsLIAIhCSAFQRFIDQEgDEUgBCANS3ENAiAEIAY7AAAgBUEQayEFIAZBEHYhBiAEQQJqIQQMAQsLIAoMAQtBun8LC0MBA38DQAJAIAIgBGoiBSADTQ0AIAAgBGoiBiABTQ0AIAZBAWstAAAgBUEBay0AAEcNACAEQQFrIQQMAQsLQQAgBGsLYQAgAQRAIAAgAUEFdGohAQNAIABChICggMCBgAg3AQAgAEEYakK0gOCBwIeAIDcBACAAQRBqQqSAoIHAhYAYNwEAIABBCGpClIDggMCDgBA3AQAgAEEgaiIAIAFHDQALCwtQAQF/IABBGGoQogwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQpgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQpwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQsgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQtAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQtgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQuAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQvQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQvwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwgwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQwwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQxQwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQxwwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtQAQF/IABBGGoQyAwgABDFJyAAEOg7IABBDGoiARCkLCABEPU8AkAgACgCLCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQSxqEPseCwtJAAJAAkAgAiADTQRAIAIgA0cNAQwCCyABIANqLAAAQb9/Sg0BCyABIAIgAyACIAQQozYACyAAIAIgA2s2AgQgACABIANqNgIAC0EBAX8gAUEMSyACQR9LcgR/IAMFIAAgAEGQA28iAEEfdUGQA3EgAGpB9MmGAWotAAAgAkEEdCABQQl0cnIQxiQLC1gBAX8CQAJAIAEoAiQiAkUEQCABKAIIRQ0CIAEoAgQoAghFDQELIAAgAUEAIAJBAWoQnxEPCyAAQQA2AgggAEKTgICAyAA3AgAPC0EAQQBBwOyGARDDIQALWAEBfwJAAkAgASgCJCICRQRAIAEoAghFDQIgASgCBCgCCEUNAQsgACABQQAgAkEBahCeEQ8LIABBADYCCCAAQpOAgICIATcCAA8LQQBBAEHA7IYBEMMhAAtPAQF/IwBBEGsiAiQAAn8gACgCACIAKAIABEAgAiAANgIMIAFB/MOHAUEEIAJBDGpBgMSHARDQEwwBCyABQejDhwFBBBD7NQsgAkEQaiQAC08BAX8jAEEQayICJAACfyAAKAIAIgAoAgAEQCACIAA2AgwgAUHs3YcBQQQgAkEMakHw3YcBENATDAELIAFB1t2HAUEEEPs1CyACQRBqJAAL6gECAX4FfwJAIAAoAgQiBEUNACAAKAIMIgUEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkHAAWshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3ZBaGxqIgZBGGtBAUEBEOAeIAZBDGtBAUEBEOAeIAFCAX0gAYMhASAFQQFrIgUNAAsLIAQgBEEYbEEfakF4cSICakEJaiIDRQ0AIAAoAgAgAmsgA0EIEPg6CwuoAQEEfyMAQRBrIgQkACAEQQhqIQUjAEEQayIDJAAgAyACNgIIIAJBAEgEQEHY4IcBQSsgA0EPakHI4IcBQYThhwEQ1R4ACyADQQEgAiADQQhqEMAhIAMoAgQhBiAFIAMoAgA2AgAgBSAGNgIEIANBEGokACAEKAIIIQMgBCgCDCEFIAIEQCADQQhqIAEgAvwKAAALIAAgBTYCBCAAIAM2AgAgBEEQaiQACzcBAX8gAQRAIAFBAUcEQEEEIQIgAUECdCEBA0AgACAAIAJqEOcZIAEgAkEEaiICRw0ACwsPCwALRwECfyMAQRBrIgIkACACQQhqIABBDGogACgCFEEBaiIDIAAoAhAiACAAIANLGxDqDCABIAIoAgggAigCDBD7KCACQRBqJAALSAEBfyAAKAIAIAAoAggiA2sgAkkEQCAAIAMgAhCFEyAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC04BAX8jAEEwayIBJAAgAUEBNgIMIAFB3KqJATYCCCABQgE3AhQgASABQS9qrUKAgICAgN4DhDcDICABIAFBIGo2AhAgAUEIaiAAEO8sAAtDAQN/AkAgAkUNAANAIAAtAAAiBCABLQAAIgVGBEAgAEEBaiEAIAFBAWohASACQQFrIgINAQwCCwsgBCAFayEDCyADC00BAX8CQAJAAkAgAC0ARA4EAAICAQILIABBOGoQ3jsgACgCNCIBIAEoAgAiAUEBazYCACABQQFHDQEgAEE0ahCdJw8LIABBEGoQoCULC1YBAX8gABDUJSAAQdAAaiIBENwYIAEQ7DsgACgCOEGAgICAeEcEQCAAQThqIgEQxiogARDoOwsgACgCREGAgICAeEcEQCAAQcQAaiIAEMcqIAAQ6DsLC1IBAX8CQAJAAkACQCAALQAYQQNrDgIAAQMLIABBIGoQqh4MAQsgAEEgahDSLQsgACgCFCIBIAEoAgAiAUEBazYCACABQQFHDQAgAEEUahCdJwsLTAEBfyAAKAIAIgBBCGoQyykgACgCSARAIABByABqEI0jCwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEHQAEEIEPg6CwtQAQF/QRxBBBCtNiIBRQRAQQRBHBCjPQALIAFCgYCAgBA3AgAgASAAKQIANwIIIAFBEGogAEEIaikCADcCACABQRhqIABBEGooAgA2AgAgAQtQAQF/QSBBBBCtNiIBRQRAQQRBIBCjPQALIAFCgYCAgBA3AgAgASAAKQIANwIIIAFBEGogAEEIaikCADcCACABQRhqIABBEGopAgA3AgAgAQtNAQF/IwBBEGsiAiQAAn8gAC0AAEERRwRAIAIgADYCDCABQYC5zQBBBCACQQxqQfC4zQAQ0BMMAQsgAUHsuM0AQQQQ+zULIAJBEGokAAtWAQF/IwBB8ABrIgEkACAAEJkoIAEQmSggAUIANwNoIAFCgICAgMAANwNgIABB4ABqIAFB8AD8CgAAIABBADYC2AEgAEKAgICAEDcD0AEgAUHwAGokAAtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQgyALIABBBGohACACQQFrIgINAAsLC0kBAn8gACgCCCICBEAgACgCBCEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDZIQsgAEEEaiEAIAJBAWsiAg0ACwsLTgECfyAAKAIAIgMoAgQiBCgCCCIAIAEoAgAgAkEDdGtBCGsoAgAiAU0EQCABIABBlJDOABDDIQALIAMoAgAgBCgCBCABQQN0akEIEM0CC04BAn8gACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFNBEAgASAAQZSQzgAQwyEACyADKAIAIAQoAgQgAUECdGpBBBDNAgtRAgF/AX4gACkDACEDIAAoAigiAiAAKAIgRgRAIABBIGpBuPvPABCzKAsgACgCJCACQQN0aiADNwMAIAAgAkEBajYCKCAAIAApAwAgAXw3AwALTQEBfyMAQRBrIgIkAAJ/IAAtAABBEUcEQCACIAA2AgwgAUG44dAAQQQgAkEMakGo4dAAENATDAELIAFBpOHQAEEEEPs1CyACQRBqJAALTQEBfyMAQRBrIgIkAAJ/IAAtAABBA0cEQCACIAA2AgwgAUG44dAAQQQgAkEMakG84dAAENATDAELIAFBpOHQAEEEEPs1CyACQRBqJAALTQEBfyABQYACTwRAIAAQrREPCyAAKAIMIgIgACgCCCIARwRAIAAgAjYCDCACIAA2AggPC0HA84oBQcDzigEoAgBBfiABQQN2d3E2AgALUQEBfyMAQRBrIgIkAAJ/IAAoAgBBgICAgHhHBEAgAiAANgIMIAFBsKX+AEEEIAJBDGpBoKX+ABDQEwwBCyABQZyl/gBBBBD7NQsgAkEQaiQAC0ICAn8BfkEBIQEgAEIBhiIDIABCP4ciAFIEQCAAIAOFIQBBACEBA0AgAUEBaiEBIABC/wBWIABCB4ghAA0ACwsgAQtFAQJ/IwBBEGsiASQAIAAoAgAiAC0AMEEgRgRAIAFBCGogAEE0ahDDNCABKAIIQQAgASgCDBsQkSwhAgsgAUEQaiQAIAILjy8CBn8EfiABKAIAIAIQhyVFBEAgACMAQUBqIgUkACABIAIQ0BohCyAFQThqQQA2AgAgBUEwaiIAQgA3AwAgBUIANwMoIAVBKGoiBkEBciECAkACQAJAAkACQAJAAkACQAJAAkACQCALQgBZBEAgC0KQzgBaBEAgBkECciEBIAtCgMivoCVaBEAgCyALQoDIr6AlgCIMQoDIr6Alfn0hDQJ/AkAgC0KAgOmDsd4WWgRAIAtCgICQu7rWrfANWg0BIAtC//+D/qbe4RFYBEAgDEK5mxp+IgxCIIghDiALQoCAmqbqr+MBWgRAIAZBBnIhACAFIA6nQQF0IgFBuYz/AGotAAA6ACkgBSABQbiM/wBqLQAAOgAoIAZBA3IhAUEBIQIDQCABIAxC/////w+DQuQAfiIMQh+IpyIGQQFyQbiM/wBqLQAAOgAAIAFBAWsgBkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIAJBAXFBACECDQALQRAMBAsgBUEoakEFciEAIAUgDqdBMHI6AChBASECA0AgASAMQv////8Pg0LkAH4iDEIfiKciBkEBckG4jP8Aai0AADoAACABQQFrIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmohASACQQFxQQAhAg0AC0EPDAMLIAxCou+bhgF+IgxCMIghDiAMQhCIIQwgC0KAgKjsha/RsQFaBEAgBSAOp0EBdCIBQbmM/wBqLQAAOgApIAUgAUG4jP8Aai0AADoAKEEAIQEDQCAFQShqIAFqIgJBA2ogDEL/////D4NC5AB+IgxCH4inIgZBAXJBuIz/AGotAAA6AAAgAkECaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBEgwDCyAFQShqQQdyIQAgBSAOp0EwcjoAKEEAIQEDQCAFQShqIAFqIgJBAmogDEL/////D4NC5AB+IgxCH4inIgZBAXJBuIz/AGotAAA6AAAgAkEBaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBEQwCCyALQv+flKWNHVgEQCAMpyEAIAtC/8/bw/QCWARAIAUgAEEwcjoAKCACIQBBCwwDCyAFIABBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggASEAQQwMAgsgDEKpuL0UfiIMQiCIIQ4gC0KAwMrzhKMCWgRAIAVBKGpBBHIhACAFIA6nQQF0IgFBuYz/AGotAAA6ACkgBSABQbiM/wBqLQAAOgAoIAUgDEL/////D4NC5AB+Qh+IpyIBQQFyQbiM/wBqLQAAOgArIAUgAUH+AXFBuIz/AGotAAA6ACpBDgwCCyAFQShqQQNyIQAgBSAOp0EwcjoAKCAFIAxC/////w+DQuQAfkIfiKciAUEBckG4jP8Aai0AADoAKiAFIAFB/gFxQbiM/wBqLQAAOgApQQ0MAQsgBUExaiEAIAUgDEKK95ivBX4iC0I5iKdBMHI6ACggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAUEBckG4jP8Aai0AADoAKiAFIAFB/gFxQbiM/wBqLQAAOgApIAUgC0L8////D4NC5AB+IgtCH4inIgFBAXJBuIz/AGotAAA6ACwgBSABQf4BcUG4jP8Aai0AADoAKyAFIAtC8P///w+DQuQAfiILQh+IpyIBQQFyQbiM/wBqLQAAOgAuIAUgAUH+AXFBuIz/AGotAAA6AC0gBSALQsD///8Pg0LkAH5CH4inIgFBAXJBuIz/AGotAAA6ADAgBSABQf4BcUG4jP8Aai0AADoAL0ETCyECIAAgDUKAwtcvgKdBAXQiAUG5jP8Aai0AADoAASAAIAFBuIz/AGotAAA6AAAgACANIA1CkM4AgCILQpDOAH59pyIBQf//A3FB5ABuIgZBAXQiB0G5jP8Aai0AADoAByAAIAdBuIz/AGotAAA6AAYgACALQpDOAIKnIgdB5ABuIghBAXQiCUG5jP8Aai0AADoAAyAAIAlBuIz/AGotAAA6AAIgACABIAZB5ABsa0H//wNxQQF0IgFBuYz/AGotAAA6AAkgACABQbiM/wBqLQAAOgAIIAAgByAIQeQAbGtB//8DcUEBdCIBQbmM/wBqLQAAOgAFIAAgAUG4jP8Aai0AADoABAwNCyALQv+T69wDWARAIAtC/8HXL1gEQCALQr+EPVgEQCALQrmbGn4iDEIgiCENIAtCoI0GWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggBUEoakEDciEBQQEhAANAIAEgDEL/////D4NC5AB+IgxCH4inIgJBAXJBuIz/AGotAAA6AAAgAUEBayACQf4BcUG4jP8Aai0AADoAACABQQJqIQEgAEEBcUEAIQANAAsMDwsgBSANp0EwcjoAKEEBIQADQCABIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIAFBAWsgAkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALDA0LIAtCou+bhgF+IgxCMIghDSAMQhCIIQwgC0KAreIEWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6AChBACEBA0AgBUEoaiABaiIAQQNqIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBAmogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALDAwLIAUgDadBMHI6AChBACEBA0AgBUEoaiABaiIAQQJqIAxC/////w+DQuQAfiIMQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBAWogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALDAoLIAUgC0KK95ivBX4iC0I5iKdBMHI6ACggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKiAFIABB/gFxQbiM/wBqLQAAOgApIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6ACwgBSAAQf4BcUG4jP8Aai0AADoAKyAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAuIAUgAEH+AXFBuIz/AGotAAA6AC0gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADAgBSAAQf4BcUG4jP8Aai0AADoALwwDCyAFQRBqIAtCAELHuMf5KkIAEKgeIAUgBSkDGEIFhiAFKQMQIgtCO4iEp0H+A3EiAEG5jP8Aai0AADoAKSAFIABBuIz/AGotAAA6ACggBSALQhyIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKyAFIABB/gFxQbiM/wBqLQAAOgAqIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC0gBSAAQf4BcUG4jP8Aai0AADoALCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAvIAUgAEH+AXFBuIz/AGotAAA6AC4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADEgBSAAQf4BcUG4jP8Aai0AADoAMEEKIQIMDAsgC0LjAFgEQCALQglYBEAgBSALp0EwcjoAKEEBIQIMDQsgBSALp0EBdCIAQbmM/wBqLQAAOgApIAUgAEG4jP8Aai0AADoAKEECIQIMDAsgC0KpuL0UfiIMQiCIIQ0gC0LoB1oEQCAFIA2nQQF0IgBBuYz/AGotAAA6ACkgBSAAQbiM/wBqLQAAOgAoIAUgDEL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgArDAcLIAUgDadBMHI6ACggBSAMQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACogBSAAQf4BcUG4jP8Aai0AADoAKUEDIQIMCwsgBUEtOgAoQgAgC30iDEKQzgBUDQQgDEKAyK+gJVoEQCAMIAxCgMivoCWAIgtCgMivoCV+fSENIAICfwJAIAxCgIDpg7HeFloEQCAMQoCAkLu61q3wDVoNASAMQv//g/6m3uERWARAIAtCuZsafiILQiCIIQ4gDEKAgJqm6q/jAVoEQCAFIA6nQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApIAVBKGpBBHIhAUEBIQADQCABIAtC/////w+DQuQAfiILQh+IpyIGQQFyQbiM/wBqLQAAOgAAIAFBAWsgBkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALQQYMBAsgBSAOp0EwcjoAKSAFQShqQQNyIQFBASEAA0AgASALQv////8Pg0LkAH4iC0IfiKciBkEBckG4jP8Aai0AADoAACABQQFrIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmohASAAQQFxQQAhAA0AC0EFDAMLIAtCou+bhgF+IgtCMIghDiALQhCIIQsgDEKAgKjsha/RsQFaBEAgBSAOp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKUEAIQEDQCAFQShqIAFqIgBBBGogC0L/////D4NC5AB+IgtCH4inIgZBAXJBuIz/AGotAAA6AAAgAEEDaiAGQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAtBCAwDCyAFIA6nQTByOgApQQAhAQNAIAVBKGogAWoiAEEDaiALQv////8Pg0LkAH4iC0IfiKciBkEBckG4jP8Aai0AADoAACAAQQJqIAZB/gFxQbiM/wBqLQAAOgAAIAFBAmoiAUEGRw0AC0EHDAILIAxC/5+UpY0dWARAIAunIQAgDEL/z9vD9AJYBEAgBSAAQTByOgApQQEMAwsgBSAAQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApQQIMAgsgC0KpuL0UfiILQiCIIQ4gDEKAwMrzhKMCWgRAIAUgDqdBAXQiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6ACkgBSALQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACwgBSAAQf4BcUG4jP8Aai0AADoAK0EEDAILIAUgDqdBMHI6ACkgBSALQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACsgBSAAQf4BcUG4jP8Aai0AADoAKkEDDAELIAUgC0KK95ivBX4iC0I5iKdBMHI6ACkgBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAKyAFIABB/gFxQbiM/wBqLQAAOgAqIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC0gBSAAQf4BcUG4jP8Aai0AADoALCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAvIAUgAEH+AXFBuIz/AGotAAA6AC4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADEgBSAAQf4BcUG4jP8Aai0AADoAMEEJCyIBaiIAIA1CgMLXL4CnQQF0IgJBuYz/AGotAAA6AAEgACACQbiM/wBqLQAAOgAAIAAgDSANQpDOAIAiC0KQzgB+faciAkH//wNxQeQAbiIGQQF0IgdBuYz/AGotAAA6AAcgACAHQbiM/wBqLQAAOgAGIAAgC0KQzgCCpyIHQeQAbiIIQQF0IglBuYz/AGotAAA6AAMgACAJQbiM/wBqLQAAOgACIAAgAiAGQeQAbGtB//8DcUEBdCICQbmM/wBqLQAAOgAJIAAgAkG4jP8Aai0AADoACCAAIAcgCEHkAGxrQf//A3FBAXQiAkG5jP8Aai0AADoABSAAIAJBuIz/AGotAAA6AAQgAUELaiECDAsLIAxC/5Pr3ANWDQMgDEL/wdcvVg0CIAxCv4Q9WARAIAtCx+RlfiILQiCIIQ0gDEKgjQZaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKSAFQShqQQRyIQFBASEAA0AgASALQv////8Pg0LkAH4iC0IfiKciAkEBckG4jP8Aai0AADoAACABQQFrIAJB/gFxQbiM/wBqLQAAOgAAIAFBAmohASAAQQFxQQAhAA0ACwwICyAFIA2nQTByOgApIAVBKGpBA3IhAUEBIQADQCABIAtC/////w+DQuQAfiILQh+IpyICQQFyQbiM/wBqLQAAOgAAIAFBAWsgAkH+AXFBuIz/AGotAAA6AAAgAUECaiEBIABBAXFBACEADQALDAoLIAtC3pDk+X5+IgtCMIghDSALQhCIIQsgDEKAreIEVA0BIAUgDadBAXQiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6AClBACEBA0AgBUEoaiABaiIAQQRqIAtC/////w+DQuQAfiILQh+IpyICQQFyQbiM/wBqLQAAOgAAIABBA2ogAkH+AXFBuIz/AGotAAA6AAAgAUECaiIBQQZHDQALC0EJIQIMCQsgBSANp0EwcjoAKUEAIQEDQCAFQShqIAFqIgBBA2ogC0L/////D4NC5AB+IgtCH4inIgJBAXJBuIz/AGotAAA6AAAgAEECaiACQf4BcUG4jP8Aai0AADoAACABQQJqIgFBBkcNAAsMBQsgBSALQvaI59B6fiILQjmIp0EwcjoAKSAFIAtCGYhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgArIAUgAEH+AXFBuIz/AGotAAA6ACogBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoALSAFIABB/gFxQbiM/wBqLQAAOgAsIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC8gBSAAQf4BcUG4jP8Aai0AADoALiAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAMSAFIABB/gFxQbiM/wBqLQAAOgAwQQohAgwHCyAFIAxCAELHuMf5KkIAEKgeIAUgBSkDCEIFhiAFKQMAIgtCO4iEp0H+A3EiAEG5jP8Aai0AADoAKiAFIABBuIz/AGotAAA6ACkgBSALQhyIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoALCAFIABB/gFxQbiM/wBqLQAAOgArIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AC4gBSAAQf4BcUG4jP8Aai0AADoALSAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAwIAUgAEH+AXFBuIz/AGotAAA6AC8gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ADIgBSAAQf4BcUG4jP8Aai0AADoAMUELIQIMBgsgDELjAFgEQCAMQglYBEAgBSAMp0EwcjoAKUECIQIMBwsgBSAMp0EBdCIAQbmM/wBqLQAAOgAqIAUgAEG4jP8Aai0AADoAKUEDIQIMBgsgC0LXx8JrfiILQiCIIQ0gDELoB1oEQCAFIA2nQQF0IgBBuYz/AGotAAA6ACogBSAAQbiM/wBqLQAAOgApIAUgC0L/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAsIAUgAEH+AXFBuIz/AGotAAA6ACsMBAsgBSANp0EwcjoAKSAFIAtC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAKwsgBSAAQf4BcUG4jP8Aai0AADoAKkEEIQIMBAtBByECDAMLQQghAgwCC0EFIQIMAQtBBiECC0GTgICAeEGUgICAeCADIAVBKGogAiAEKAIMEQYAGzYCACAFQUBrJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALhwIBAX8gASgCACACEJYlRQRAIwBBMGsiBSQAIAUgASgCACACEIAXAkAgBSgCBCICBEAgBSgCACEBIAQoAhQhBANAIAUgATYCDCAFQQE2AiQgBUHwlYEBNgIgIAVBATYCFCAFQaz3gAE2AhAgBUEBNgIcIAVBghE2AiwgBSAFQShqNgIYIAUgBUEMajYCKCADIAVBEGogBBECAARAIABBk4CAgHg2AgAMAwsgAUEBaiEBIAJBAWsiAg0ACwsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC68VAgF/An4gASgCACACEIclRQRAIwBBEGsiBSQAIAEgAhDPGiEBIAVCADcDACAFQQA2AAcgAEGTgICAeEGUgICAeCADIAUCfwJAAkACQAJAAkACQAJAAkAgAUEATgRAIAFBkM4ATwRAIAGtIQYgAUGAwtcvTwRAIAFB/5Pr3ANNBEAgBSAGQor3mK8FfiIGQjmIp0EwcjoAACAFIAZCGYhC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgACIAUgAEH+AXFBuIz/AGotAAA6AAEgBSAGQvz///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoABCAFIABB/gFxQbiM/wBqLQAAOgADIAUgBkLw////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAYgBSAAQf4BcUG4jP8Aai0AADoABSAFIAZCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACCAFIABB/gFxQbiM/wBqLQAAOgAHDAQLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAASAFIABBPnFBuIz/AGotAAA6AAAgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAUgBSAAQf4BcUG4jP8Aai0AADoABCAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAHIAUgAEH+AXFBuIz/AGotAAA6AAYgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAkgBSAAQf4BcUG4jP8Aai0AADoACEEKDAsLIAFBv4Q9TQRAIAZCuZsafiIGQiCIIQcgAUGgjQZPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAAwLCyAFIAenQTByOgAAIAVBAnIhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALDAkLIAZCou+bhgF+IgZCMIghByAGQhCIIQYgAUGAreIETwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAMCAsgBSAHp0EwcjoAAEEAIQIDQCACIAVqIgBBAmogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEEBaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAsMBgsgAUHjAE0EQCABQQlNBEAgBSABQTByOgAAQQEMCwsgBSABQQF0IgBBuYz/AGotAAA6AAEgBSAAQbiM/wBqLQAAOgAAQQIMCgsgAa1Cqbi9FH4iBkIgiCEHIAFB6AdPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAAwFCyAFIAenQTByOgAAIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgACIAUgAEH+AXFBuIz/AGotAAA6AAFBAwwJCyAFQS06AABBACABayIAQZDOAEkNAiAArSEGIABBgMLXL08EQCAAQf+T69wDTQRAIAUgBkKK95ivBX4iBkI5iKdBMHI6AAEgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAUgBSAAQf4BcUG4jP8Aai0AADoABCAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAHIAUgAEH+AXFBuIz/AGotAAA6AAYgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAkgBSAAQf4BcUG4jP8Aai0AADoACEEKDAoLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAAiAFIABB/gBxQbiM/wBqLQAAOgABIAUgBkIZiEL/////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAyAFIAZC/P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAGIAUgAEH+AXFBuIz/AGotAAA6AAUgBSAGQvD///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoACCAFIABB/gFxQbiM/wBqLQAAOgAHIAUgBkLA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAlBCwwJCyAAQb+EPU0EQCAGQrmbGn4iBkIgiCEHIABBoI0GTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAAiAFIABBuIz/AGotAAA6AAEgBUEEciECQQEhAANAIAIgBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAkEBayABQf4BcUG4jP8Aai0AADoAACACQQJqIQIgAEEAIQANAAsMBgsgBSAHp0EwcjoAAQwICyAGQqLvm4YBfiIGQjCIIQcgBkIQiCEGIABBgK3iBEkNASAFIAenQQF0IgBBuYz/AGotAAA6AAIgBSAAQbiM/wBqLQAAOgABQQAhAgNAIAIgBWoiAEEEaiAGQv////8Pg0LkAH4iBkIfiKciAUEBckG4jP8Aai0AADoAACAAQQNqIAFB/gFxQbiM/wBqLQAAOgAAIAJBAmoiAkEGRw0ACwtBCQwHCyAFIAenQTByOgABDAMLIABB4wBNBEAgAEEJTQRAIAUgAEEwcjoAAUECDAcLIAUgAEEBdCIAQbmM/wBqLQAAOgACIAUgAEG4jP8Aai0AADoAAUEDDAYLIACtQqm4vRR+IgZCIIghByAAQegHTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAAiAFIABBuIz/AGotAAA6AAEgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAwwECyAFIAenQTByOgABCyAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAAyAFIABB/gFxQbiM/wBqLQAAOgACQQQMBAtBBwwDC0EAIQIDQCACIAVqIgBBA2ogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCAwCC0EFDAELIAVBA3IhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALQQYLIAQoAgwRBgAbNgIAIAVBEGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuHAgEBfyABKAIAIAIQliVFBEAjAEEwayIFJAAgBSABKAIAIAIQ8hYCQCAFKAIEIgIEQCAFKAIAIQEgBCgCFCEEA0AgBSABNgIMIAVBATYCJCAFQfCVgQE2AiAgBUEBNgIUIAVBrPeAATYCECAFQQE2AhwgBUGCETYCLCAFIAVBKGo2AhggBSAFQQxqNgIoIAMgBUEQaiAEEQIABEAgAEGTgICAeDYCAAwDCyABQQFqIQEgAkEBayICDQALCyAAQZSAgIB4NgIACyAFQTBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALwgEBAX8gASgCACACEJUlRQRAIwBBMGsiBSQAIAEoAgAgAhCEGiEBIAVByAs2AiggBSABOgAvIAVBATYCECAFQbC1gAE2AgwgBUIBNwIYIAUgBUEvajYCJCAFIAVBJGo2AhQgAEGTgICAeEGUgICAeCADIAVBDGogBCgCFBECABs2AgAgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC4YMAgF/An4gASgCACACEIclRQRAIwBBEGsiBSQAIAEgAhDPGiEBIAVBCGpBADsBACAFQgA3AwAgAEGTgICAeEGUgICAeCADIAUCfyABQZDOAE8EQCABrSEGIAFBgMLXL08EQCABQf+T69wDTQRAIAUgBkKK95ivBX4iBkI5iKdBMHI6AAAgBSAGQhmIQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAAiAFIABB/gFxQbiM/wBqLQAAOgABIAUgBkL8////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAQgBSAAQf4BcUG4jP8Aai0AADoAAyAFIAZC8P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAGIAUgAEH+AXFBuIz/AGotAAA6AAUgBSAGQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAggBSAAQf4BcUG4jP8Aai0AADoAB0EJDAMLIAUgBkKJ95ivBX4iBkI4iKciAEEBckG4jP8Aai0AADoAASAFIABB/gBxQbiM/wBqLQAAOgAAIAUgBkIZiEL/////D4NC5AB+IgZCH4inIgBBAXJBuIz/AGotAAA6AAMgBSAAQf4BcUG4jP8Aai0AADoAAiAFIAZC/P///w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAFIAUgAEH+AXFBuIz/AGotAAA6AAQgBSAGQvD///8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoAByAFIABB/gFxQbiM/wBqLQAAOgAGIAUgBkLA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAJIAUgAEH+AXFBuIz/AGotAAA6AAhBCgwCCyABQb+EPU0EQCAGQrmbGn4iBkIgiCEHIAFBoI0GTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAgBUEDciECQQEhAANAIAIgBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAkEBayABQf4BcUG4jP8Aai0AADoAACACQQJqIQIgAEEAIQANAAtBBgwDCyAFIAenQTByOgAAIAVBAnIhAkEBIQADQCACIAZC/////w+DQuQAfiIGQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAJBAWsgAUH+AXFBuIz/AGotAAA6AAAgAkECaiECIABBACEADQALQQUMAgsgBkKi75uGAX4iBkIwiCEHIAZCEIghBiABQYCt4gRPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAEEAIQIDQCACIAVqIgBBA2ogBkL/////D4NC5AB+IgZCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCAwCCyAFIAenQTByOgAAQQAhAgNAIAIgBWoiAEECaiAGQv////8Pg0LkAH4iBkIfiKciAUEBckG4jP8Aai0AADoAACAAQQFqIAFB/gFxQbiM/wBqLQAAOgAAIAJBAmoiAkEGRw0AC0EHDAELIAFB4wBNBEAgAUEJTQRAIAUgAUEwcjoAAEEBDAILIAUgAUEBdCIAQbmM/wBqLQAAOgABIAUgAEG4jP8Aai0AADoAAEECDAELIAGtQqm4vRR+IgZCIIghByABQegHTwRAIAUgB6dBAXQiAEG5jP8Aai0AADoAASAFIABBuIz/AGotAAA6AAAgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAMgBSAAQf4BcUG4jP8Aai0AADoAAkEEDAELIAUgB6dBMHI6AAAgBSAGQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAIgBSAAQf4BcUG4jP8Aai0AADoAAUEDCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALrwQBA38gASgCACACEIclRQRAIwBB0ABrIgUkACMAQTBrIgYkACABKAIAIQEgBiACNgIAIAFBDGoQ2DwgAk0EQCAGIAEQ/Ts2AhwgBkECNgIIIAZB8Ij/ADYCBCAGQgI3AhAgBkE7NgIsIAZBOzYCJCAGIAZBIGo2AgwgBiAGQRxqNgIoIAYgBjYCICAGQQRqQYCJ/wAQ7ywACyAFQQhqIAEoAhAgAkEDdGopAgA3AwAgBkEwaiQAIAUgBSgCDCIBNgIUIAUgBSgCCCICNgIQIAVCATcCGAJAAkAgAkUEQEEBIQIMAQsgBUEDNgI0IAVB6JP/ADYCMCAFQgI3AjwgBUGcAzYCLCAFQcwBNgIkIAUgBUEgajYCOCAFIAVBEGo2AiggBSAFQRhqNgIgIAMgBUEwaiAEKAIUEQIARQRAQQEhByAFQQE2AhxBt5L/ACECIAVBt5L/ADYCGCAFKAIUIQEMAQsgAEGTgICAeDYCAAwBCwJAIAFFDQAgBSAHNgIkIAUgAjYCICAFIAE2AiggBUEBNgI0IAVBtJP/ADYCMCAFQgE3AjwgBUGODDYCTCAFIAVByABqNgI4IAUgBUEgajYCSCADIAVBMGogBCgCFBECAEUNACAAQZOAgIB4NgIADAELIABBlICAgHg2AgALIAVB0ABqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL0wQCAX8CfiABKAIAIAIQhyVFBEAjAEEQayIFJAAgASACEM4aIQEgBUEMakEAOgAAIAVBADYCCCAAQZOAgIB4QZSAgIB4IAMgBUEIagJ/IAFB//8DcSIAQY/OAE0EQCAAQeMATQRAIABBCU0EQCAFIAFBMHI6AAhBAQwDCyAFIAFBAXRB/v8HcSIAQbmM/wBqLQAAOgAJIAUgAEG4jP8Aai0AADoACEECDAILIAGtQv//A4NCqbi9FH4iBkIgiCEHIAFB//8DcUHoB08EQCAFIAenQQF0IgBBuYz/AGotAAA6AAkgBSAAQbiM/wBqLQAAOgAIIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AApBBAwCCyAFIAenQTByOgAIIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAlBAwwBCyAFIAGtQv//A4NCuZsafiIGQiCIp0EwcjoACCAFIAZC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgAKIAUgAEH+AXFBuIz/AGotAAA6AAkgBSAGQvz///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AAwgBSAAQf4BcUG4jP8Aai0AADoAC0EFCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgALvgUCA38BfiABKAIAIAIQhyVFBEAjAEHQAGsiBSQAIwBBMGsiBiQAIAEoAgAhASAGIAI2AgAgAUEMahDaPCACTQRAIAYgARD/OzYCHCAGQQI2AgggBkHwiP8ANgIEIAZCAjcCECAGQTs2AiwgBkE7NgIkIAYgBkEgajYCDCAGIAZBHGo2AiggBiAGNgIgIAZBBGpBgIn/ABDvLAALIAVBCGoiByABKAIQIAJBBHRqIgEpAwA3AwAgB0EIaiABQQhqKQMANwMAIAZBMGokACAFQgE3AhgCQAJAIAUoAghFBEBBASEBQQAhAgwBCyAFQQM2AjQgBUGAlP8ANgIwIAVCAjcCPCAFQZwDNgIsIAVBzAE2AiQgBSAFQSBqNgI4IAUgBUEIajYCKCAFIAVBGGo2AiAgAyAFQTBqIAQoAhQRAgBFBEBBASECIAVBATYCHEG3kv8AIQEgBUG3kv8ANgIYDAELIABBk4CAgHg2AgAMAQsgBSgCDARAIAVBAzYCNCAFQeiT/wA2AjAgBUICNwI8IAVBnAM2AiwgBSAFQQhqQQRyNgIoIAVBzAE2AiQgBSAFQSBqNgI4IAUgBUEYajYCICADIAVBMGogBCgCFBECAARAIABBk4CAgHg2AgAMAgsgBUEBNgIcIAVBt5L/ADYCGEEBIQJBt5L/ACEBCwJAIAUpAxAiCFANACAFIAI2AiQgBSABNgIgIAUgCDcDKCAFQQE2AjQgBUG0k/8ANgIwIAVCATcCPCAFQY8MNgJMIAUgBUHIAGo2AjggBSAFQSBqNgJIIAMgBUEwaiAEKAIUEQIARQ0AIABBk4CAgHg2AgAMAQsgAEGUgICAeDYCAAsgBUHQAGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuyAgECfyABKAIAIAIQmyVFBEAjAEEwayIFJAAjAEEQayIGJAAgBkEIaiABKAIAIAIQoBsgBigCDCEBIAUgBigCCDYCACAFIAE2AgQgBkEQaiQAAkAgBSgCBCICBEAgBSgCACEBIAQoAhQhBANAIAUgATYCDCAFQQE2AiQgBUH484ABNgIgIAVBATYCFCAFQfDzgAE2AhAgBUEBNgIcIAVBghE2AiwgBSAFQShqNgIYIAUgBUEMajYCKCADIAVBEGogBBECAARAIABBk4CAgHg2AgAMAwsgAUEBaiEBIAJBAWsiAg0ACwsgAEGUgICAeDYCAAsgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCRJUUEQCMAQTBrIgUkACAFIAEoAgAgAhCmGSAFQcwBNgIkIAVBATYCDCAFQfDzgAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvBAgIBfwF+IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQtxshASAFQQ5qQQA6AAAgBUEAOwEMIABBk4CAgHhBlICAgHggAyAFQQxqAn8gAUH/AXEiAEHjAE0EQCAAQQlNBEAgBSABQTByOgAMQQEMAgsgBSABQQF0Qf4DcSIAQbmM/wBqLQAAOgANIAUgAEG4jP8Aai0AADoADEECDAELIAUgAa1C/wGDQqm4vRR+IgZCIIinQTByOgAMIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAOIAUgAEH+AXFBuIz/AGotAAA6AA1BAwsgBCgCDBEGABs2AgAgBUEQaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC+EDAQF/IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQtxshASAFQQA2AgwgAEGTgICAeEGUgICAeCADIAVBDGoCfyABwEEATgRAIAFB/wFxIgBB4wBNBEAgAEEJTQRAIAUgAUEwcjoADEEBDAMLIAUgAUEBdEH+A3EiAEG5jP8Aai0AADoADSAFIABBuIz/AGotAAA6AAxBAgwCCyAFQTE6AAwgBSABrUL/AYNCqbi9FH5C/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoADiAFIABB/gFxQbiM/wBqLQAAOgANQQMMAQsgBUEtOgAMQQAgAWsiAEH/AXEiAUHjAE0EQCABQQlNBEAgBSAAQTByOgANQQIMAgsgBSAAQQF0Qf4DcSIAQbmM/wBqLQAAOgAOIAUgAEG4jP8Aai0AADoADUEDDAELIAVBMToADSAFIACtQv8Bg0KpuL0UfkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAPIAUgAEH+AXFBuIz/AGotAAA6AA5BBAsgBCgCDBEGABs2AgAgBUEQaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCWJUUEQCMAQTBrIgUkACAFIAEoAgAgAhDxFiAFQcwBNgIkIAVBATYCDCAFQaz3gAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAuoCAIBfwJ+IAEoAgAgAhCHJUUEQCMAQRBrIgUkACABIAIQzhohASAFQQxqQQA7AQAgBUEANgIIIABBk4CAgHhBlICAgHggAyAFQQhqAn8gAcFBAE4EQCABQf//A3EiAEGPzgBNBEAgAEHjAE0EQCAAQQlNBEAgBSABQTByOgAIQQEMBAsgBSABQQF0Qf7/B3EiAEG5jP8Aai0AADoACSAFIABBuIz/AGotAAA6AAhBAgwDCyABrUL//wODQqm4vRR+IgZCIIghByABQf//A3FB6AdPBEAgBSAHp0EBdCIAQbmM/wBqLQAAOgAJIAUgAEG4jP8Aai0AADoACCAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACyAFIABB/gFxQbiM/wBqLQAAOgAKQQQMAwsgBSAHp0EwcjoACCAFIAZC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoACiAFIABB/gFxQbiM/wBqLQAAOgAJQQMMAgsgBSABrUL//wODQrmbGn4iBkIgiKdBMHI6AAggBSAGQv////8Pg0LkAH4iBkIfiKciAEEBckG4jP8Aai0AADoACiAFIABB/gFxQbiM/wBqLQAAOgAJIAUgBkL8////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAMIAUgAEH+AXFBuIz/AGotAAA6AAtBBQwBCyAFQS06AAhBACABayIAQf//A3EiAUGPzgBNBEAgAUHjAE0EQCAAQf//A3FBCU0EQCAFIABBMHI6AAlBAgwDCyAFIABBAXRB/v8HcSIAQbmM/wBqLQAAOgAKIAUgAEG4jP8Aai0AADoACUEDDAILIACtQv//A4NCqbi9FH4iBkIgiCEHIABB//8DcUHoB08EQCAFIAenQQF0IgBBuYz/AGotAAA6AAogBSAAQbiM/wBqLQAAOgAJIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAMIAUgAEH+AXFBuIz/AGotAAA6AAtBBQwCCyAFIAenQTByOgAJIAUgBkL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AApBBAwBCyAFIACtQv//A4NCuZsafiIGQiCIp0EwcjoACSAFIAZC/////w+DQuQAfiIGQh+IpyIAQQFyQbiM/wBqLQAAOgALIAUgAEH+AXFBuIz/AGotAAA6AAogBSAGQvz///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6AA0gBSAAQf4BcUG4jP8Aai0AADoADEEGCyAEKAIMEQYAGzYCACAFQRBqJAAPCwJAIAEoAggiAgRAIAMgASgCBCACIAQoAgwRBgANAQsgAEGUgICAeDYCAA8LIABBk4CAgHg2AgAL5xoCBn8EfiABKAIAIAIQhyVFBEAgACMAQTBrIgUkACABIAIQ0BohCyAFQShqQQA2AgAgBUEgaiICQgA3AwAgBUIANwMYAkAgC0KQzgBaBEAgC0KAyK+gJVoEQCALIAtCgMivoCWAIgxCgMivoCV+fSENAn8gC0KAgOmDsd4WWgRAIAtCgICQu7rWrfANWgRAIAtC//+fz8jgyOOKf1gEQCAFQSFqIQIgBSAMQor3mK8FfiILQjmIp0EwcjoAGCAFIAtCGYhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAaIAUgAEH+AXFBuIz/AGotAAA6ABkgBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHCAFIABB/gFxQbiM/wBqLQAAOgAbIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB4gBSAAQf4BcUG4jP8Aai0AADoAHSAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAICAFIABB/gFxQbiM/wBqLQAAOgAfQRMMAwsgBUEiaiECIAUgDEKJ95ivBX4iC0I4iKciAEEBckG4jP8Aai0AADoAGSAFIABBPnFBuIz/AGotAAA6ABggBSALQhmIQv////8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAGyAFIABB/gFxQbiM/wBqLQAAOgAaIAUgC0L8////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB0gBSAAQf4BcUG4jP8Aai0AADoAHCAFIAtC8P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAfIAUgAEH+AXFBuIz/AGotAAA6AB4gBSALQsD///8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ACEgBSAAQf4BcUG4jP8Aai0AADoAIEEUDAILIAtC//+D/qbe4RFYBEAgDEK5mxp+IgxCIIghDiALQoCAmqbqr+MBWgRAIAVBGGoiAEEGciECIAUgDqdBAXQiAUG5jP8Aai0AADoAGSAFIAFBuIz/AGotAAA6ABggAEEDciEGQQEhAANAIAYgDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgBkEBayABQf4BcUG4jP8Aai0AADoAACAGQQJqIQYgAEEAIQANAAtBEAwDCyAFQRhqIgBBBXIhAiAFIA6nQTByOgAYIABBAnIhBkEBIQADQCAGIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIAZBAWsgAUH+AXFBuIz/AGotAAA6AAAgBkECaiEGIABBACEADQALQQ8MAgsgDEKi75uGAX4iDEIwiCEOIAxCEIghDCALQoCAqOyFr9GxAVoEQCAFIA6nQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYA0AgBUEYaiAGaiIAQQNqIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIABBAmogAUH+AXFBuIz/AGotAAA6AAAgBkECaiIGQQZHDQALQRIMAgsgBUEYakEHciECIAUgDqdBMHI6ABgDQCAFQRhqIAZqIgBBAmogDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgAEEBaiABQf4BcUG4jP8Aai0AADoAACAGQQJqIgZBBkcNAAtBEQwBCyALQv+flKWNHVgEQCAMpyEAIAtC/8/bw/QCWARAIAVBGGpBAXIhAiAFIABBMHI6ABhBCwwCCyAFQRhqQQJyIQIgBSAAQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYQQwMAQsgDEKpuL0UfiIMQiCIIQ4gC0KAwMrzhKMCWgRAIAVBGGpBBHIhAiAFIA6nQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYIAUgDEL/////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAbIAUgAEH+AXFBuIz/AGotAAA6ABpBDgwBCyAFQRhqQQNyIQIgBSAOp0EwcjoAGCAFIAxC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAGiAFIABB/gFxQbiM/wBqLQAAOgAZQQ0LIQYgAiANQoDC1y+Ap0EBdCIAQbmM/wBqLQAAOgABIAIgAEG4jP8Aai0AADoAACACIA0gDUKQzgCAIgtCkM4Afn2nIgBB//8DcUHkAG4iAUEBdCIHQbmM/wBqLQAAOgAHIAIgB0G4jP8Aai0AADoABiACIAtCkM4AgqciB0HkAG4iCUEBdCIKQbmM/wBqLQAAOgADIAIgCkG4jP8Aai0AADoAAiACIAAgAUHkAGxrQf//A3FBAXQiAEG5jP8Aai0AADoACSACIABBuIz/AGotAAA6AAggAiAHIAlB5ABsa0H//wNxQQF0IgBBuYz/AGotAAA6AAUgAiAAQbiM/wBqLQAAOgAEDAILIAtC/5Pr3ANYBEAgC0L/wdcvWARAIAtCv4Q9WARAIAtCuZsafiIMQiCIIQ0gC0KgjQZaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGCAFQRhqQQNyIQJBASEGA0AgAiAMQv////8Pg0LkAH4iDEIfiKciAEEBckG4jP8Aai0AADoAACACQQFrIABB/gFxQbiM/wBqLQAAOgAAIAJBAmohAiAGQQFxQQAhBg0AC0EGIQYMBQsgBSANp0EwcjoAGCAFQRhqQQJyIQJBASEGA0AgAiAMQv////8Pg0LkAH4iDEIfiKciAEEBckG4jP8Aai0AADoAACACQQFrIABB/gFxQbiM/wBqLQAAOgAAIAJBAmohAiAGQQFxQQAhBg0AC0EFIQYMBAsgC0Ki75uGAX4iDEIwiCENIAxCEIghDCALQoCt4gRaBEAgBSANp0EBdCIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGEEAIQIDQCAFQRhqIAJqIgBBA2ogDEL/////D4NC5AB+IgxCH4inIgFBAXJBuIz/AGotAAA6AAAgAEECaiABQf4BcUG4jP8Aai0AADoAACACQQJqIgJBBkcNAAtBCCEGDAQLIAUgDadBMHI6ABhBACECA0AgBUEYaiACaiIAQQJqIAxC/////w+DQuQAfiIMQh+IpyIBQQFyQbiM/wBqLQAAOgAAIABBAWogAUH+AXFBuIz/AGotAAA6AAAgAkECaiICQQZHDQALQQchBgwDCyAFIAtCiveYrwV+IgtCOYinQTByOgAYIAUgC0IZiEL/////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6ABogBSAAQf4BcUG4jP8Aai0AADoAGSAFIAtC/P///w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAcIAUgAEH+AXFBuIz/AGotAAA6ABsgBSALQvD///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHiAFIABB/gFxQbiM/wBqLQAAOgAdIAUgC0LA////D4NC5AB+Qh+IpyIAQQFyQbiM/wBqLQAAOgAgIAUgAEH+AXFBuIz/AGotAAA6AB9BCSEGDAILIAUgC0IAQse4x/kqQgAQqB4gBSAFKQMIQgWGIAUpAwAiC0I7iISnQf4DcSIAQbmM/wBqLQAAOgAZIAUgAEG4jP8Aai0AADoAGCAFIAtCHIhC/////w+DQuQAfiILQh+IpyIAQQFyQbiM/wBqLQAAOgAbIAUgAEH+AXFBuIz/AGotAAA6ABogBSALQvz///8Pg0LkAH4iC0IfiKciAEEBckG4jP8Aai0AADoAHSAFIABB/gFxQbiM/wBqLQAAOgAcIAUgC0Lw////D4NC5AB+IgtCH4inIgBBAXJBuIz/AGotAAA6AB8gBSAAQf4BcUG4jP8Aai0AADoAHiAFIAtCwP///w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAISAFIABB/gFxQbiM/wBqLQAAOgAgQQohBgwBCyALQuMAWARAIAtCCVgEQCAFIAunQTByOgAYQQEhBgwCCyAFIAunQQF0IgBBuYz/AGotAAA6ABkgBSAAQbiM/wBqLQAAOgAYQQIhBgwBCyALQqm4vRR+IgxCIIghDSALQugHWgRAIAUgDadBAXQiAEG5jP8Aai0AADoAGSAFIABBuIz/AGotAAA6ABggBSAMQv////8Pg0LkAH5CH4inIgBBAXJBuIz/AGotAAA6ABsgBSAAQf4BcUG4jP8Aai0AADoAGkEEIQYMAQsgBSANp0EwcjoAGCAFIAxC/////w+DQuQAfkIfiKciAEEBckG4jP8Aai0AADoAGiAFIABB/gFxQbiM/wBqLQAAOgAZQQMhBgtBk4CAgHhBlICAgHggAyAFQRhqIAYgBCgCDBEGABs2AgAgBUEwaiQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC8UBAQF/IAEoAgAgAhCWJUUEQCMAQTBrIgUkACAFIAEoAgAgAhD/FiAFQcwBNgIkIAVBATYCDCAFQaz3gAE2AgggBUIBNwIUIAUgBSkDADcCKCAFIAVBKGo2AiAgBSAFQSBqNgIQIABBk4CAgHhBlICAgHggAyAFQQhqIAQoAhQRAgAbNgIAIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvzAQIBfwJ8IAEoAgAgAhCHJUUEQCMAQUBqIgUkACAFIAEgAhDPGrciBkQAAAAAAAAoQKOcIgc5AwggBSAGIAdEAAAAAAAAKECioTkDECAFQQM2AhwgBUHIk/8ANgIYIAVCAjcCJCAFQYoINgI8IAVBigg2AjQgBSAFQTBqNgIgIAUgBUEQajYCOCAFIAVBCGo2AjAgAEGTgICAeEGUgICAeCADIAVBGGogBCgCFBECABs2AgAgBUFAayQADwsCQCABKAIIIgIEQCADIAEoAgQgAiAEKAIMEQYADQELIABBlICAgHg2AgAPCyAAQZOAgIB4NgIAC4cCAQF/IAEoAgAgAhCRJUUEQCMAQTBrIgUkACAFIAEoAgAgAhCnGQJAIAUoAgQiAgRAIAUoAgAhASAEKAIUIQQDQCAFIAE2AgwgBUEBNgIkIAVB+POAATYCICAFQQE2AhQgBUHw84ABNgIQIAVBATYCHCAFQYIRNgIsIAUgBUEoajYCGCAFIAVBDGo2AiggAyAFQRBqIAQRAgAEQCAAQZOAgIB4NgIADAMLIAFBAWohASACQQFrIgINAAsLIABBlICAgHg2AgALIAVBMGokAA8LAkAgASgCCCICBEAgAyABKAIEIAIgBCgCDBEGAA0BCyAAQZSAgIB4NgIADwsgAEGTgICAeDYCAAvvAgEKfyMAQRBrIgQkACAAIAEoAgQgASgCAGtBA3YQ7i0gBCAAKQIEQiCJNwIIIAQgAEEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAAkAgASgCACIAIAEoAgQiAkcEQCABKAIMIQYgAygCCCAFQQJ0aiEDIAIgAGtBA3YhByABKAIIIQgDQCAAKAIAIgIgCCgCCCIBTw0CIABBBGooAgAiAUEBaiIJIAgoAgQgAkECdGooAgAiCygCFEECdiICTw0DAkAgASACSQRAIAYgBigCACALKAIQIgIgCUECdGooAgAgAiABQQJ0aigCAGtqIgE2AgAgAUEATg0BQby1ggFBCEHEtYIBEMskAAsgASACQay1ggEQwyEACyADIAE2AgAgAEEIaiEAIANBBGohAyAFQQFqIQUgB0EBayIHDQALCyAKIAU2AgAMAgsgAiABQYy1ggEQwyEACyAJIAJBnLWCARDDIQALIARBEGokAAvYAgEKfyMAQRBrIgQkACAAIAEoAgQgASgCAGtBA3YQ7C0gBCAAKQIEQiCJNwIIIAQgAEEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQoCQAJAAkACQCABKAIAIgAgASgCBCICRwRAIAEoAgwhBiADKAIIIAVBA3RqIQMgAiAAa0EDdiEHIAEoAgghCANAIAAoAgAiAiAIKAIIIgFPDQIgAEEEaigCACIBQQFqIgkgCCgCBCACQQJ0aigCACILKAIUQQN2IgJPDQMgASACTw0EIAYgBigCACALKAIQIgIgCUEDdGooAgAgAiABQQN0aigCAGtqIgE2AgAgAyABrTcDACAAQQhqIQAgA0EIaiEDIAVBAWohBSAHQQFrIgcNAAsLIAogBTYCAAwDCyACIAFBjLWCARDDIQALIAkgAkGctYIBEMMhAAsgASACQay1ggEQwyEACyAEQRBqJAALSQECfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPseCyAAQRRqIQAgAkEBayICDQALCwtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQuyMLIABBCGohACACQQFrIgINAAsLC1EBAX8jAEEQayICJAAgAiABEMovIAIgAigCADYCDCACQQxqENEfIQEgAEIBNwMAIAAgAjUCBCABrEKAowV+fEKAkc285wF9NwMIIAJBEGokAAtJAQJ/IAAoAggiAgRAIAAoAgQhAANAIAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQ+x4LIABBDGohACACQQFrIgINAAsLC0kBAn8gACgCDCICBEAgACgCBCEAA0AgACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDyJQsgAEEEaiEAIAJBAWsiAg0ACwsLSQECfyAAKAIIIgIEQCAAKAIEIQADQCAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEPIlCyAAQQRqIQAgAkEBayICDQALCwtFACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAiADaiABazYCAA8LIAAgASACIAMQjRgLTQEBfyMAQRBrIgIkACACQQhqIAFBAWogAS0AAEECdEGghMQAaigCACgCGBEAACACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALSgEBfyAAKAJsQQdNBEAgACAAKAJwIAAoAmhqIgE2AnAgACABQfcDSxD6CyAAQQA2AmwPCyAAQQA2AmggACgCcARAIABBARD6CwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDeOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDeOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahCdPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahCdPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDpOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDpOyAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDjPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDaLwsLRwEBfwJAIAAoAgBBgICAgHhGBEAgAEEEahDjPCAAKAIQIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQRBqELsjDwsgABDbLwsLRQEBfyMAQcADayIEJAAgBCADQcAD/AoAACAAIAEgBCACKAIMEQEAIAIoAgQiAARAIAEgACACKAIIEPg6CyAEQcADaiQAC0gBAX8gACgCCCIBBEAgACgCBCEAA0AgAEEMaiAAQQRqKAIAIABBCGooAgAgACgCACgCEBEBACAAQRBqIQAgAUEBayIBDQALCwtKAQF/IAFBmAJqIQMgASgCmAJBgICAgHhHBEAgA0EEQQgQ4B4LIAMgAikCADcCACADQQhqIAJBCGooAgA2AgAgACABQcAC/AoAAAtLAQJ/AkAgACgCAEEIRgRAIAAoAgQhAiAAKAIIIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBRQ0BIAIgASAAKAIIEPg6DwsgABDJIwsLSwEBfwJAIAAoAiRFBEAgACgCCCICIAFBA2pBfHFqIgEgACgCBE0NAQsgAEEBOgAcQQAPCyAAIAE2AhAgACABNgIMIAAgATYCCCACC+YDAQN/IwBBEGsiAyQAIANBBGoiAkIANwIAIAJBCGpBADYCAAJAAkACQAJAAkACQAJAAkACQCAAQegHaw4RBgEHAgMGBgYGBgcHBgcGBAcACwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB5ABrDggBAgMEBQYHCAALAkAgAEGgAWsOBRMJCgsMAAsCQCAAQcgBaw4DEhISAAsgAEGQA2tBA0kNEyAAQQpGDREgAEH0A0cNEAwRCyACQoCA+P/vAjcCBAwSCyACQoqAgIDgAzcCBAwRCyACQoaAgIDgAzcCBAwQCyACQoaAgIDQAzcCBAwPCyACQoGAgIDQAzcCBAwOCyACQoOAgIDwADcCBAwNCyACQYCACDYCCAwMCyACQoGAgICQATcCBAwLCyACQoaAgIDgAzcCBAwKCyACQoSAgICAgAQ3AgQMCQsgAkKBgICAgAE3AgQMCAsgAkEYNgIIDAcLIAJBAzYCCAwGCyACQsCAgICAgIABNwIEDAULIAJB/////wc2AggMBAsgAkKAiICAgICAATcCBAwDCyACQVg2AgAMAgsgAkEBNgIIDAELIAJBAjYCCAsgAygCBCADKAIIIQIgAygCDCEEIANBEGokAEGJf0kgASACTnEgASAETHELQQEBfwJAIAAoAgQiA0UNACADIAIgA0EBaiABbGpBAWtBACACa3EiAWpBCWoiA0UNACAAKAIAIAFrIAMgAhD4OgsLSQEDfyMAQTBrIgIkACABEJs2IgNFBEBBjISDARCyOwALIAJBBGoiBCABIAMQyiIgAkEANgIYIAAgBCACQRhqENQYIAJBMGokAAtEAQF/IAAoAhwEQCAAQRxqENQeCyAAKAIIIgEEQCAAKAIEIQAgAUEDdCEBA0AgABD5IyAAQQhqIQAgAUEIayIBDQALCwucAQEFfyAAKAIYQQhqKAIQIQIgACgCJCIBBEAgAiABQQhqKAIQaiECCyAAKAIEIgEgASAAKAIIQQN0aiIARwRAIAAgAWtBA3YhAANAIAEoAgAiBAR/IAQgAUEEaigCACIFKAIIQQFrQXhxakEIaiAFKAJUEQQABUEACyEEIAFBCGohASADIARqIQMgAEEBayIADQALCyACIANqQTBqCzoBAX8jAEEgayIAJAAgAEEANgIYIABBATYCDCAAQaSuhgE2AgggAEIENwIQIABBCGpBrK6GARDvLAALPQEBfyAAKAIAIgBBBHZB/wNxIgIgAUH/AXEiAWogAiAAQQdxakEHcCIAQQdqIAAgACABSRtrQQZqQQdtwQtJAQF/AkAgACgCOCAAKAI8IAEoAjggASgCPBDBLkUNACAAQShqIAFBKGoQzQhFDQAgAC0AQCABLQBARw0AIAAgARDlDCECCyACC54BAgN/AX4gACkDEEIDUgRAIABBEGoiAikDACIEQgJRIASnQQFxRXJFBEAgAikDCHunIQMLAkAgAigCECIBRQ0AIAEgAigCFCICRg0AIAIgAWtBA3YhAgNAIAMgASkDAHunaiEDIAFBCGohASACQQFrIgINAAsLIAMhAQsgACkDACIEQgJSBH8gACkDCHunQQAgBKdBAXEbIAFqBSABCwtNAQN/IAEgASgCDCABQRBqIgIoAgAiAxDTHyEEIABBEGogAigCADYCACAAQQhqIAFBCGopAgA3AgAgACABKQIANwIAIAAgAyAEazYCFAtKAQN/IAAoAgAiAgRAIAAoAgQiAygCACIBBEAgAiABEQMACyADKAIEIgEEQCACIAEgAygCCBD4OgsgACgCDCAAKAIIKAIMEQMACws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHMwIkBNgIIIABCBDcCECAAQQhqQdTAiQEQ7ywAC0gBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQzxYgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtEAQF/IAAoAggiAQRAIAAoAgQhAANAIAAoAgBBgICAgHhHBEAgABD1OyAAQQxqEIUwCyAAQRhqIQAgAUEBayIBDQALCwtOAQF/AkACQAJAIAAtAJgHDgQAAgIBAgsgAEGMB2oQ3jsPCyAAEKoeIAAoAogHIgEgASgCACIBQQFrNgIAIAFBAUcNACAAQYgHahCdJwsLTQECfyABLwEkIQMgASgCCCICIAEoAgBGBEAgAUGQhsMAEK0oCyABKAIEIAJBAXRqIAM7AQAgAEEENgIAIAFBADsBJCABIAJBAWo2AggLTAEBfyAAKAIAIgBBFGogACgCDCAAKAIQIAAoAggoAhARAQACQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBGEEEEPg6CwtJAQF/IAAoAgAiACgCCCIBBEAgACgCDCABKAIMEQMACwJAIABBf0YNACAAIAAoAgQiAUEBazYCBCABQQFHDQAgAEEYQQQQ+DoLC08BAX8gAUEMaiABKAIEIAFBCGoiBCgCACABKAIAKAIQEQEAIAFBADYCFCABIAM2AhAgAEEINgIAIAQgAkEIaikCADcCACABIAIpAgA3AgALUAIBfwF+IAEoAgBBgICAgHhHBEAgAUEEQQgQ4B4LIAFBCGoiAyACQQhqKAIANgIAIAEgAikCACIENwIAIAAgBDcCACAAQQhqIAMpAgA3AgALRAEDfyAAKAIAIgMoAgAiACABKAIAIgQoAgAiAnJFIQEgAEUgAkVyBH8gAQUgAEEIaiADKAIEIAJBCGogBCgCBBDBLgsLPwEBfyAAEN47IABBDGoiARDXKyABEOg7IABBGGoiARDXKyABEOg7IABBJGoQ4zwgAEEwahCFMCAAQTxqEIUwC0oBAX8CQCABKAIgQQFHBH9BAAUgASgCJEUNASABKAIsIQIgASgCKAshASAAIAI2AgQgACABNgIADwtB5IfOAEEgQYSIzgAQyyQAC0oBAX8CQCABKAI0QQFHBH9BAAUgASgCOEUNASABKAJAIQIgASgCPAshASAAIAI2AgQgACABNgIADwtB5IfOAEEgQYSIzgAQyyQAC1YBAn8gAS8BFCEDIAEoAggiAiABKAIARgRAIAFBqLLOABCtKAsgASgCBCACQQF0aiADOwEAIABChICAgICAgICAfzcCACABQQA7ARQgASACQQFqNgIIC1YBAn8gAS8BECEDIAEoAggiAiABKAIARgRAIAFB1MbOABCtKAsgASgCBCACQQF0aiADOwEAIABChICAgICAgICAfzcCACABQQA7ARAgASACQQFqNgIIC00BAn8gAS8BJCEDIAEoAggiAiABKAIARgRAIAFB5MjOABCtKAsgASgCBCACQQF0aiADOwEAIABBBDYCACABQQA7ASQgASACQQFqNgIIC5sCAQV/IwBBEGsiAyQAIAEoAgghBCMAQSBrIgIkACADIAEoAgAiBSABKAIERgR/QQAFIAEgBUEIajYCACACQQhqIAUoAgAgBSgCBCgCGBEAACACKAIQIQEgAigCDCEFAn8gAigCCCIGQQhHBEAgBCgCAEEIRwRAIAQQySMLIAQgATYCCCAEIAU2AgQgBCAGNgIAIAQgAkEUaiIBKQIANwIMIARBFGogAUEIaigCADYCAEEAIQEgAkEEagwBCyACIAU2AgQgAgsgATYCACACKAIEIQEgAyACKAIANgIIIAMgATYCBEEBCzYCACACQSBqJAAgAygCBCEBIAMoAgAhAiAAIAMoAgg2AgQgACABQQAgAhs2AgAgA0EQaiQAC0sBAn8gACgCACIDKAIEIgQoAggiACABKAIAIAJBA3RrQQhrKAIAIgFNBEAgASAAQZSQzgAQwyEACyADKAIAIAQoAgQgAWpBARDNAgs/AQJ/IAAoAhAiAQRAIAAoAgwgACgCCCICIAAoAgQgAUEBamxqQQFrQQAgAmtxIgBrIAAgAWpBCWogAhD4OgsLsxYCG38BfiAAIQ0gASEGIAIhGCAEKAIEIRkgBCgCCCEaIAQoAhBBACAEKAIMQYCAgIB4RxshFCAEKAIUIREgBCgCHEEAIAQoAhhBgICAgHhHGyESIAQoAiAhEEEAIQQjAEEwayILJAACQAJAIBRBACASG0UEQCADIQAgFEUNASARIQAMAQsgESEAIBAgEUYNACALIBE2AgAgCyAQNgIEIAtBAjYCHCALQYj+zgA2AhggC0ICNwIkIAtBOzYCFCALQTs2AgwgCyALQQhqNgIgIAsgC0EEajYCECALIAs2AgggDUEEaiALQRhqEJkOIA1BADYCAAwBCyAGKAKQAUUEQCAGQgA3A8ABCyAGQgA3A7gBAkACQAJAAkAgAARAIAYoArwEKAKUASEcA0ACQCASRSAEIBxqIgEgACAAIAFLGyIBIBBPcg0AIBIgAUEBdGohAgNAIAIvAQBFDQEgAkECaiECIBAgAUEBaiIBRw0ACyAQIQELQQAhAkEAIQggFARAIAEgBEkNAyABIBFLDQQgFCAEQQF0aiEICyASBEAgASAESQ0FIAEgEEsNBiASIARBAXRqIQILIAtBGGohByABIARrIQkgAiEEIwBBQGoiBSQAIAkhDAJAAkACQAJAAkAgBigCuAQiCi4BGCICQQBKBH8gCEUEQCAFQQE2AhwgBUH4/84ANgIYIAVCATcCJCAFQc0BNgI4IAUgAjsBPiAFIAVBNGo2AiAgBSAFQT5qNgI0IAVBBHIgBUEYahCZDiAHIAUpAgw3AgwgB0EUaiAFQRRqKAIANgIAIAcgBSkCBDcCBCAHQQA2AgAMAwtBACEMIAkEQCACQf//A3EhDiAIIQIgCSEKA0AgDCACLwEAIA5GaiEMIAJBAmohAiAKQQFrIgoNAAsLIAYgBikDmAMgCSAMa618NwOYAyAGKAKsA0GAgICAeEcEQCAGQawDaiAIIAkQ1yELIAZBoARqIAggCRD4KSAGKAK4BAUgCgsuARoiAkEATARAIAYgBigCvAMgCWo2ArwDDAELIAQEQCAJBEAgBC8BAARAIAVBATYCHCAFQZD/zgA2AhggBUIBNwIkIAVBzQE2AgQgBSAENgIAIAUgBTYCICAHQQRqIAVBGGoQmQ4gB0EANgIADAQLIAlBAXQhCCAGKAK8AyEKIAQhAgNAIAogAi8BAEVqIQogAkECaiECIAhBAmsiCA0ACyAGIAo2ArwDCyAGKAKgA0GAgICAeEcEQCAGQaADaiAEIAkQ1yELIAZBrARqIAQgCRD4KQwBCyAFQQE2AhwgBUHAgM8ANgIYIAVCATcCJCAFQc0BNgI4IAUgAjsBPiAFIAVBNGo2AiAgBSAFQT5qNgI0IAVBBHIgBUEYahCZDiAHIAUpAgw3AgwgB0EUaiAFQRRqKAIANgIAIAcgBSkCBDcCBCAHQQA2AgAMAQsCQCAZBEAgDCAPaiICIAxJDQMgAiAaSw0EIwBBIGsiBCQAIAYgBigCkAEgDGo2ApABIAQgAzYCHCAEIBg2AhggBCAZIA9BAnRqIgI2AhAgBCACIAxBAnRqNgIUIwBBIGsiAiQAIAJBFGogBEEQaiIKKAIEIAooAgBrQQJ2QQBBBEEEEKAYIAIoAhghCCACKAIUQQFGBEAgCCACKAIcQaCDzgAQ/S8ACyAEQQRqIRcgAkEQaiIdQQA2AgAgAiACKAIcNgIMIAIgCDYCCCMAQRBrIg4kACACQQhqIgggCigCBCAKKAIAa0ECdhDuLSAOIAgpAgRCIIk3AgggDiAIQQhqNgIEIA5BBGoiEygCBCEVIBMoAgAhHgJAAkAgCigCACIIIAooAgQiFkcEQCAKKAIMIRsgCigCCCEfIBMoAgggFUECdGohCiAWIAhrQQJ2IRMDQCAIKAIAIhYgG08NAiAKIB8gFkECdGooAgA2AgAgCEEEaiEIIApBBGohCiAVQQFqIRUgE0EBayITDQALCyAeIBU2AgAMAQsgFiAbQdzl0AAQwyEACyAOQRBqJAAgF0EIaiAdKAIANgIAIBcgAikCCDcCACACQSBqJAAgBUEYaiAGIAQoAgggBCgCDBCzECAXEOk7IARBIGokACAFKAIYIgJBCEYNASAHIAUpAhw3AgQgB0EUaiAFQSxqKAIANgIAIAdBDGogBUEkaikCADcCACAHIAI2AgAMAgsgBUEYaiEEIwBB0ABrIgIkACAGIAYoApABIAxqNgKQASACIAw2AgQCQCAMIAwgD2oiCE0gAyAIT3FFBEAgAiADIA9rNgI8IAJBAjYCKCACQYiJzgA2AiQgAkICNwIwIAJBOzYCTCACQTs2AkQgAiACQUBrNgIsIAIgAkE8ajYCSCACIAJBBGo2AkAgAkEIakEEciACQSRqEJkOIAQgAikCFDcCDCAEQRRqIAJBHGooAgA2AgAgBCACKQIMNwIEIARBADYCAAwBCyAEIAYgGCAPQQJ0aiAMELMQCyACQdAAaiQAIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCyAGIAYoArgDIAlqIgI2ArgDAkAgAkUNACAGKAK8AyAGKAK8BCICKAKQAUkEQCAGEL0cIAIoAowBSQ0BCyAFQRhqIAYQ5AEgBSgCGCICQQhGDQAgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAELAkAgBigCaEGAgICAeEYNACAGKAJcIAYoArwEQQhqIAYoArgEQQhqENARSQ0AIAVBGGohBCMAQcABayICJAACQAJAIAYoArgDRQ0AIAJBIGogBhDkASACKAIgIglBCEYNACAEIAIpAiQ3AgQgBEEUaiACQTRqKAIANgIAIARBDGogAkEsaikCADcCACAEIAk2AgAMAQsgAkEgaiAGEI4HIAIoAiAiCUEIRwRAIAQgAikCJDcCBCAEQRRqIAJBNGooAgA2AgAgBEEMaiACQSxqKQIANwIAIAQgCTYCAAwBCwJAAkAgBigCuANFDQAgAkGoAWogBhDkASACKAKoASIJQQhGDQAMAQsCQCAGKALEAiIJRQ0AIAJBKGohCANAIAYgCUEBazYCxAIgBiAGKALAAiIJQQFqIgogBigCuAIiDkEAIAogDk8bazYCwAIgBigCvAIgCUGIAWxqIgkpAwAiIEIMUQ0BIAIgIDcDICAIIAlBCGpBgAH8CgAAIAJBqAFqIAYgAkEgahCoCiACKAKoASIJQQhHDQIgBigCxAIiCQ0ACwsgBEEINgIADAELIAJBGGoiCCACQbwBaigCADYCACACQRBqIgogAkG0AWopAgA3AwAgAiACKQKsATcDCCAEIAk2AgAgBCACKQMINwIEIARBDGogCikDADcCACAEQRRqIAgoAgA2AgALIAJBwAFqJAAgBSgCGCICQQhGDQAgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAELIAdBCDYCACAHIAw2AgQLIAVBQGskAAwCCyAPIAJBqP/OABCxOwALIAIgGkGo/84AELA7AAsgCygCHCECIAsoAhgiBEEIRwRAIA0gCykDIDcDCCANQRBqIAtBKGopAwA3AwAgDSACNgIEIA0gBDYCAAwHCyACIA9qIQ8gACABIgRLDQALCyANQQg2AgAgDSAPNgIEDAQLIAQgAUGY/s4AELE7AAsgASARQZj+zgAQsDsACyAEIAFBqP7OABCxOwALIAEgEEGo/s4AELA7AAsgC0EwaiQAC7MWAht/AX4gACENIAEhBiACIRggBCgCBCEZIAQoAgghGiAEKAIQQQAgBCgCDEGAgICAeEcbIRQgBCgCFCERIAQoAhxBACAEKAIYQYCAgIB4RxshEiAEKAIgIRBBACEEIwBBMGsiCyQAAkACQCAUQQAgEhtFBEAgAyEAIBRFDQEgESEADAELIBEhACAQIBFGDQAgCyARNgIAIAsgEDYCBCALQQI2AhwgC0GI/s4ANgIYIAtCAjcCJCALQTs2AhQgC0E7NgIMIAsgC0EIajYCICALIAtBBGo2AhAgCyALNgIIIA1BBGogC0EYahCZDiANQQA2AgAMAQsgBigCoAFFBEAgBkIANwPwAQsgBkIANwPoAQJAAkACQAJAIAAEQCAGKALoBCgClAEhHANAAkAgEkUgBCAcaiIBIAAgACABSxsiASAQT3INACASIAFBAXRqIQIDQCACLwEARQ0BIAJBAmohAiAQIAFBAWoiAUcNAAsgECEBC0EAIQJBACEIIBQEQCABIARJDQMgASARSw0EIBQgBEEBdGohCAsgEgRAIAEgBEkNBSABIBBLDQYgEiAEQQF0aiECCyALQRhqIQcgASAEayEJIAIhBCMAQUBqIgUkACAJIQwCQAJAAkACQAJAIAYoAuQEIgouARgiAkEASgR/IAhFBEAgBUEBNgIcIAVB+P/OADYCGCAFQgE3AiQgBUHNATYCOCAFIAI7AT4gBSAFQTRqNgIgIAUgBUE+ajYCNCAFQQRyIAVBGGoQmQ4gByAFKQIMNwIMIAdBFGogBUEUaigCADYCACAHIAUpAgQ3AgQgB0EANgIADAMLQQAhDCAJBEAgAkH//wNxIQ4gCCECIAkhCgNAIAwgAi8BACAORmohDCACQQJqIQIgCkEBayIKDQALCyAGIAYpA9ADIAkgDGutfDcD0AMgBigC5ANBgICAgHhHBEAgBkHkA2ogCCAJENchCyAGQcwEaiAIIAkQ+CkgBigC5AQFIAoLLgEaIgJBAEwEQCAGIAYoAvQDIAlqNgL0AwwBCyAEBEAgCQRAIAQvAQAEQCAFQQE2AhwgBUGQ/84ANgIYIAVCATcCJCAFQc0BNgIEIAUgBDYCACAFIAU2AiAgB0EEaiAFQRhqEJkOIAdBADYCAAwECyAJQQF0IQggBigC9AMhCiAEIQIDQCAKIAIvAQBFaiEKIAJBAmohAiAIQQJrIggNAAsgBiAKNgL0AwsgBigC2ANBgICAgHhHBEAgBkHYA2ogBCAJENchCyAGQdgEaiAEIAkQ+CkMAQsgBUEBNgIcIAVBwIDPADYCGCAFQgE3AiQgBUHNATYCOCAFIAI7AT4gBSAFQTRqNgIgIAUgBUE+ajYCNCAFQQRyIAVBGGoQmQ4gByAFKQIMNwIMIAdBFGogBUEUaigCADYCACAHIAUpAgQ3AgQgB0EANgIADAELAkAgGQRAIAwgD2oiAiAMSQ0DIAIgGksNBCMAQSBrIgQkACAGIAYoAqABIAxqNgKgASAEIAM2AhwgBCAYNgIYIAQgGSAPQQJ0aiICNgIQIAQgAiAMQQJ0ajYCFCMAQSBrIgIkACACQRRqIARBEGoiCigCBCAKKAIAa0ECdkEAQQhBCBCgGCACKAIYIQggAigCFEEBRgRAIAggAigCHEGgg84AEP0vAAsgBEEEaiEXIAJBEGoiHUEANgIAIAIgAigCHDYCDCACIAg2AggjAEEQayIOJAAgAkEIaiIIIAooAgQgCigCAGtBAnYQ7C0gDiAIKQIEQiCJNwIIIA4gCEEIajYCBCAOQQRqIhMoAgQhFSATKAIAIR4CQAJAIAooAgAiCCAKKAIEIhZHBEAgCigCDCEbIAooAgghHyATKAIIIBVBA3RqIQogFiAIa0ECdiETA0AgCCgCACIWIBtPDQIgCiAfIBZBA3RqKQMANwMAIAhBBGohCCAKQQhqIQogFUEBaiEVIBNBAWsiEw0ACwsgHiAVNgIADAELIBYgG0Hc5dAAEMMhAAsgDkEQaiQAIBdBCGogHSgCADYCACAXIAIpAgg3AgAgAkEgaiQAIAVBGGogBiAEKAIIIAQoAgwQtBAgFxDjPCAEQSBqJAAgBSgCGCICQQhGDQEgByAFKQIcNwIEIAdBFGogBUEsaigCADYCACAHQQxqIAVBJGopAgA3AgAgByACNgIADAILIAVBGGohBCMAQdAAayICJAAgBiAGKAKgASAMajYCoAEgAiAMNgIEAkAgDCAMIA9qIghNIAMgCE9xRQRAIAIgAyAPazYCPCACQQI2AiggAkGIic4ANgIkIAJCAjcCMCACQTs2AkwgAkE7NgJEIAIgAkFAazYCLCACIAJBPGo2AkggAiACQQRqNgJAIAJBCGpBBHIgAkEkahCZDiAEIAIpAhQ3AgwgBEEUaiACQRxqKAIANgIAIAQgAikCDDcCBCAEQQA2AgAMAQsgBCAGIBggD0EDdGogDBC0EAsgAkHQAGokACAFKAIYIgJBCEYNACAHIAUpAhw3AgQgB0EUaiAFQSxqKAIANgIAIAdBDGogBUEkaikCADcCACAHIAI2AgAMAQsgBiAGKALwAyAJaiICNgLwAwJAIAJFDQAgBigC9AMgBigC6AQiAigCkAFJBEAgBhC+HCACKAKMAUkNAQsgBUEYaiAGEOcBIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCwJAIAYoAnhBgICAgHhGDQAgBigCbCAGKALoBEEIaiAGKALkBEEIahDQEUkNACAFQRhqIQQjAEHAAWsiAiQAAkACQCAGKALwA0UNACACQSBqIAYQ5wEgAigCICIJQQhGDQAgBCACKQIkNwIEIARBFGogAkE0aigCADYCACAEQQxqIAJBLGopAgA3AgAgBCAJNgIADAELIAJBIGogBhCMByACKAIgIglBCEcEQCAEIAIpAiQ3AgQgBEEUaiACQTRqKAIANgIAIARBDGogAkEsaikCADcCACAEIAk2AgAMAQsCQAJAIAYoAvADRQ0AIAJBqAFqIAYQ5wEgAigCqAEiCUEIRg0ADAELAkAgBigC/AIiCUUNACACQShqIQgDQCAGIAlBAWs2AvwCIAYgBigC+AIiCUEBaiIKIAYoAvACIg5BACAKIA5PG2s2AvgCIAYoAvQCIAlBiAFsaiIJKQMAIiBCDFENASACICA3AyAgCCAJQQhqQYAB/AoAACACQagBaiAGIAJBIGoQpAogAigCqAEiCUEIRw0CIAYoAvwCIgkNAAsLIARBCDYCAAwBCyACQRhqIgggAkG8AWooAgA2AgAgAkEQaiIKIAJBtAFqKQIANwMAIAIgAikCrAE3AwggBCAJNgIAIAQgAikDCDcCBCAEQQxqIAopAwA3AgAgBEEUaiAIKAIANgIACyACQcABaiQAIAUoAhgiAkEIRg0AIAcgBSkCHDcCBCAHQRRqIAVBLGooAgA2AgAgB0EMaiAFQSRqKQIANwIAIAcgAjYCAAwBCyAHQQg2AgAgByAMNgIECyAFQUBrJAAMAgsgDyACQaj/zgAQsTsACyACIBpBqP/OABCwOwALIAsoAhwhAiALKAIYIgRBCEcEQCANIAspAyA3AwggDUEQaiALQShqKQMANwMAIA0gAjYCBCANIAQ2AgAMBwsgAiAPaiEPIAAgASIESw0ACwsgDUEINgIAIA0gDzYCBAwECyAEIAFBmP7OABCxOwALIAEgEUGY/s4AELA7AAsgBCABQaj+zgAQsTsACyABIBBBqP7OABCwOwALIAtBMGokAAtGAAJAIAEgAhCuGgRAIAAhAQwBCyAAIAEpAwA3AwAgAEEQaiABQRBqKQMANwMAIABBCGogAUEIaikDADcDAAsgAUEJNgIACz4AIANB2wtNBEAgACABIAIgAxCYFQ8LIARBA3EEQEF/DwsgBUGAIEkEQEG+fw8LIAAgASACIANBACAEELAIC0QBBH8gACgCBCAAKAIAQQJ0aiICLQACIAEgASgCBCIEIAItAAMiBWo2AgQgACACLwEAIAEoAgAgBHRBACAFa3ZqNgIAC0UBAX8CQCAAKAIkRQRAIABBARChH0GIf0sNAQsgACgCDCICIAFqIgEgACgCFEsEQCAAQQE6ABxBAA8LIAAgATYCDAsgAgtDACAAQv////8PNwMAIABCfyABKAIQIgCthkJ/hUHAACABKAIMIgEgAUHAAE8bIgEgAGtBACAAQQFrIAFJG62GNwMIC1ABAn8jAEEgayIBJAAgAUEANgIcIAFCgICAgBA3AhQgAUEIaiABQRRqQfSo+wAQkCEgASgCDCECIAAgASgCCDYCACAAIAI2AgQgAUEgaiQAC1EBAn8jAEEgayIBJAAgAUEANgIcIAFCgICAgMAANwIUIAFBCGogAUEUakH0qPsAEJghIAEoAgwhAiAAIAEoAgg2AgAgACACNgIEIAFBIGokAAtQAQJ/IwBBIGsiASQAIAFBADYCHCABQoCAgIAgNwIUIAFBCGogAUEUakH0qPsAEJYhIAEoAgwhAiAAIAEoAgg2AgAgACACNgIEIAFBIGokAAu8AQIHfwJ+IwBBEGsiAyQAIAEoAgQiBUELTwRAIAVBCkHQqP4AELA7AAsgA0EEaiEEIAFBCGohB0EAIQECQANAIAEgBUYNASABIAdqIAFBAWohAS0AACICQf8Aca0gCYYgCoQhCiACwCICQQBIBEAgCUI5VCAJQgd8IQkNAQsLIAJBAEgNACAEIAE2AgggBEIAIApCAYN9IApCAYiFPgIEQQEhBgsgBCAGNgIAIAAgAykCBDcDACADQRBqJAALsAECB38CfiMAQRBrIgMkACABKAIEIgVBC08EQCAFQQpB0Kj+ABCwOwALIANBBGohBCABQQhqIQdBACEBAkADQCABIAVGDQEgASAHaiABQQFqIQEtAAAiAkH/AHGtIAmGIAqEIQogAsAiAkEASARAIAlCOVQgCUIHfCEJDQELCyACQQBIDQAgBCABNgIIIAQgCj4CBEEBIQYLIAQgBjYCACAAIAMpAgQ3AwAgA0EQaiQAC7ACAgV/AX4jAEEQayIDJAAgASgCHCEEIwBBIGsiAiQAIAMgASgCECIFIAEoAhRJBH8gASAFQQFqNgIQIAJBDGogASgCACAFQQN0akGks4ABIAEoAgggBUECdGooAgBBMGogASgCGBCGASACKAIUIQEgAigCECEFAn8gAigCDCIGQZOAgIB4RwRAIAIpAhghByAEKAIAQZOAgIB4RwRAIAQQiBELIAQgBzcCDCAEIAE2AgggBCAFNgIEIAQgBjYCAEEAIQEgAkEIagwBCyACIAU2AgggAkEEagsgATYCACACKAIIIQEgAyACKAIENgIIIAMgATYCBEEBBUEACzYCACACQSBqJAAgAygCBCEBIAMoAgAhAiAAIAMoAgg2AgQgACABQQAgAhs2AgAgA0EQaiQAC/YBAgV/AX4jAEEQayIEJAAgASgCDCEFIwBBIGsiAiQAIAQgASgCACIDIAEoAgRGBH9BAAUgASADQQhqNgIAIAJBDGogAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAMgASgCCBCIASACKAIUIQMgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBRDlECAFIAc3AgwgBSADNgIIIAUgATYCBCAFIAY2AgBBACEBCyAEIAM2AgggBCABNgIEQQELNgIAIAJBIGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAAL9gECBX8BfiMAQRBrIgQkACABKAIMIQUjAEEgayICJAAgBCABKAIAIgMgASgCBEYEf0EABSABIANBCGo2AgAgAkEMaiADKAIAIAMoAgQiAygCCEEBa0F4cWpBCGogAyABKAIIEIcBIAIoAhQhAyACKAIQIQEgAigCDCIGQZOAgIB4RwRAIAIpAhghByAFEOUQIAUgBzcCDCAFIAM2AgggBSABNgIEIAUgBjYCAEEAIQELIAQgAzYCCCAEIAE2AgRBAQs2AgAgAkEgaiQAIAQoAgQhASAEKAIAIQIgACAEKAIINgIEIAAgAUEAIAIbNgIAIARBEGokAAv2AQIFfwF+IwBBEGsiBCQAIAEoAgwhBSMAQSBrIgIkACAEIAEoAgAiAyABKAIERgR/QQAFIAEgA0EIajYCACACQQxqIAMoAgAgAygCBCIDKAIIQQFrQXhxakEIaiADIAEoAggQigEgAigCFCEDIAIoAhAhASACKAIMIgZBk4CAgHhHBEAgAikCGCEHIAUQ5RAgBSAHNwIMIAUgAzYCCCAFIAE2AgQgBSAGNgIAQQAhAQsgBCADNgIIIAQgATYCBEEBCzYCACACQSBqJAAgBCgCBCEBIAQoAgAhAiAAIAQoAgg2AgQgACABQQAgAhs2AgAgBEEQaiQAC/YBAgV/AX4jAEEQayIEJAAgASgCDCEFIwBBIGsiAiQAIAQgASgCACIDIAEoAgRGBH9BAAUgASADQQhqNgIAIAJBDGogAygCACADKAIEIgMoAghBAWtBeHFqQQhqIAMgASgCCBCJASACKAIUIQMgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBRDlECAFIAc3AgwgBSADNgIIIAUgATYCBCAFIAY2AgBBACEBCyAEIAM2AgggBCABNgIEQQELNgIAIAJBIGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAAL4gECBX8BfiMAQRBrIgMkACABKAIMIQQjAEEgayICJAAgAyABKAIAIgUgASgCBEYEf0EABSABIAVBCGo2AgAgAkEMaiAFQeSzggEgASgCCBCiASACKAIUIQUgAigCECEBIAIoAgwiBkGTgICAeEcEQCACKQIYIQcgBBDlECAEIAc3AgwgBCAFNgIIIAQgATYCBCAEIAY2AgBBACEBCyADIAU2AgggAyABNgIEQQELNgIAIAJBIGokACADKAIEIQEgAygCACECIAAgAygCCDYCBCAAIAFBACACGzYCACADQRBqJAALswICBn8BfiMAQRBrIgQkACABKAIMIQUjAEEwayICJAAgASgCBCIDIAEoAghJBEBBASEGIAEgA0EBajYCBCACIAM2AiAgASgCACIBKAIIIQMgAiABKAIEIgE2AgwgAiABIANBAnRqNgIQIAIgAkEgajYCFCACQSRqIgEgAkEMaiIDQYizggEQhBsgAyACKAIoIAIoAiwQnQEgAUEEQQgQ4B4gAigCFCEDIAIoAhAhASACKAIMIgdBk4CAgHhHBEAgAikCGCEIIAUQ5RAgBSAINwIMIAUgAzYCCCAFIAE2AgQgBSAHNgIAQQAhAQsgBCADNgIIIAQgATYCBAsgBCAGNgIAIAJBMGokACAEKAIEIQEgBCgCACECIAAgBCgCCDYCBCAAIAFBACACGzYCACAEQRBqJAALQgEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCVBEEAEE0aiEBIAAoAhQiAAR/IAEgAEEIaigCEGoFIAELC0YAIAAgASgCBDYCBCAAIAEoAgAgAmoiASABQYCjBW0iAkGAowVsayIBQR91IAJqNgIIIAAgAUGAowVqIAEgAUEASBs2AgALRAAgAEEANgIQIAAgBDYCDCAAIAM2AgggACACNgIEIAAgATYCACAAIAQgA2tBAnYiACACIAFrQQJ2IgEgACABSRs2AhQLgwsBCH8jAEEQayIIJAAgASgCECEJIwBBIGsiByQAIAggASgCACICIAEoAgRGBH9BAAUgASACQQRqNgIAAkACQCACKAIAIgIoAhQEQCABKAIIIgUoAgAiBCACKAIQKAIkaiEDIAEoAgwtAAANAQwCC0EAQQBB/ImHARDDIQALIAUgAzYCAAsgBCEBQQAhBSMAQUBqIgQkAAJAAkACQCACLQAYQSJHDQACQAJAAkACQAJAAkACQAJAAkACQCACKAIcLQAAQQJrDggDBAEGBwgCCQALQcSQhwFBKEHskIcBEJ8pAAsgASADckEATg0DDAgLIwBBEGsiAyQAIANBCGogAkEAEOcdIAMoAgwhBSADKAIIIQZBDEEEEK02IgJFDQggAiABNgIIIAIgBjYCACACIAU2AgQgBEEwaiIBQbSbhwE2AgQgASACNgIAIANBEGokACAEKAI0IQUgBCgCMCEGDAcLIAEgA3JBgAFPDQYjAEEQayIDJAAgA0EIaiACENIeIAMoAgwhBSADKAIIIQZBDEEEEK02IgJFDQcgAiABOgAIIAIgBjYCACACIAU2AgQgBEHMm4cBNgIEIAQgAjYCACADQRBqJAAgBCgCBCEFIAQoAgAhBgwGCyABIANyQYCAAk8NBSMAQRBrIgMkACADQQhqIAIQ5B0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNBiACIAE7AQggAiAGNgIAIAIgBTYCBCAEQQhqIgFBlJyHATYCBCABIAI2AgAgA0EQaiQAIAQoAgwhBSAEKAIIIQYMBQsjAEEQayIDJAAgA0EIaiACQQAQ5x0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNBSACIAE2AgggAiAGNgIAIAIgBTYCBCAEQRBqIgFBhJuHATYCBCABIAI2AgAgA0EQaiQAIAQoAhQhBSAEKAIQIQYMBAsjAEEQayIDJAAgA0EIaiACEOMdIAMoAgwhBSADKAIIIQZBEEEIEK02IgJFBEBBCEEQEKM9AAsgAiABrTcDCCACIAY2AgAgAiAFNgIEIARBGGoiAUGcm4cBNgIEIAEgAjYCACADQRBqJAAgBCgCHCEFIAQoAhghBgwDCyABIANyQYACTw0CIwBBEGsiAyQAIANBCGogAhDSHiADKAIMIQUgAygCCCEGQQxBBBCtNiICRQ0DIAIgAToACCACIAY2AgAgAiAFNgIEIARBIGoiAUGsnIcBNgIEIAEgAjYCACADQRBqJAAgBCgCJCEFIAQoAiAhBgwCCyABIANyQYCABE8NASMAQRBrIgMkACADQQhqIAIQ5B0gAygCDCEFIAMoAgghBkEMQQQQrTYiAkUNAiACIAE7AQggAiAGNgIAIAIgBTYCBCAEQShqIgFB5JuHATYCBCABIAI2AgAgA0EQaiQAIAQoAiwhBSAEKAIoIQYMAQsjAEEQayIDJAAgA0EIaiACEOUdIAMoAgwhBSADKAIIIQZBEEEIEK02IgJFBEBBCEEQEKM9AAsgAiABrTcDCCACIAY2AgAgAiAFNgIEIARBOGoiAUH8m4cBNgIEIAEgAjYCACADQRBqJAAgBCgCPCEFIAQoAjghBgsgByAFNgIEIAcgBjYCACAEQUBrJAAMAQtBBEEMEKM9AAsgBygCBCEBIAcoAgAhAiAHQZCAgIB4NgIMAn8gAkUEQCAJKAIAQZOAgIB4RwRAIAkQiBELIAlBkICAgHg2AgBBACEBIAdBCGoMAQsgB0EMaiIDEIgRIAcgAjYCCCADCyABNgIAIAcoAgghASAIIAcoAgw2AgggCCABNgIEQQELNgIAIAdBIGokACAIKAIEIQEgCCgCACEHIAAgCCgCCDYCBCAAIAFBACAHGzYCACAIQRBqJAALRwEBfwJAIAAvAQAiAEH//wFxQYD4AUsNACABLwEAIgFB//8BcUGA+AFLDQBBASECIAAgAUYNACAAIAFyQf//AXFFIQILIAILRgECfyMAQRBrIgIkACACIAAoAgAiADYCDCACQQxqIgMgARDvEyAAIAAoAgBBAWsiADYCACAARQRAIAMQmCkLIAJBEGokAAtPAQJ/IAAoAgQhAiAAKAIAIQMCQCAAKAIIIgAtAABFDQAgA0HI8YkBQQQgAigCDBEGAEUNAEEBDwsgACABQQpGOgAAIAMgASACKAIQEQIAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQQwQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQRgQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0oBAX8gAEEoaiIBEPcdIAEQ8TsgAEE0aiIBEPQbIAEQ7zsgAEFAaxCHMCAAQcwAahCGMCAAQdgAahCRMCAAELsuIABB5ABqEIYwC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQTQQsRIgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQSQQsRIgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC/MCAQZ/IwBBEGsiAyQAIABBABDYLSACBEAgAyABNgIIIAMgAjYCDCACQQFrIQQgA0EIaigCACEFAn8DQEEBIAUQ7hIiAUGAgMQARg0BGiAAKAIIIQYgAAJ/QQEgAUGAAUkiBw0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIIENgtIAAoAgQgACgCCGohAgJAAkAgB0UEQCABQYAQSQ0BIAFBgIAETwRAIAIgAUE/cUGAAXI6AAMgAiABQRJ2QfABcjoAACACIAFBBnZBP3FBgAFyOgACIAIgAUEMdkE/cUGAAXI6AAEMAwsgAiABQT9xQYABcjoAAiACIAFBDHZB4AFyOgAAIAIgAUEGdkE/cUGAAXI6AAEMAgsgAiABOgAADAELIAIgAUE/cUGAAXI6AAEgAiABQQZ2QcABcjoAAAsgACAGIAhqNgIIIARBAWsiBEF/Rw0AC0EACyEAIAMgBDYCBCADIAA2AgALIANBEGokAAtHAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEEEELESIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtOAQF/IwBBEGsiAiQAIAIgACgCACIANgIMIAFBgLjMAEEGQYa4zABBBCAAQQRqQeC3zABBirjMAEEFIAJBDGpB8LfMABCOGCACQRBqJAALVgAgAEEgEOggIABBGGpBgIDAABDoICAAQUBrQYABQYSezgAQthUgAEIANwMwIABCgICAgIAQNwJMIABBOGpCADcDACAAQQA2AlwgAEKggICAwAA3AlQLQAEBfyAAKALMASAAKAKIASAAKAIoamogAC0ALCIBQQN2IAFBB3FBAEdqaiAALQCMASIAQQN2IABBB3FBAEdqagtHAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEEIELcRIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHAABC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBBBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBEBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSAEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRB4AAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0gBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQbgFELcRIAIoAggiAEGBgICAeEcEQCAAIAIoAgwgARD9LwALIAJBEGokAAtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHAAhC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQRBLBC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALRwEBfyMAQRBrIgIkACACQQhqIAAgACgCAEEBQQFBARC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSAEBf0EMQQQQrTYiAkUEQEEEQQwQoz0ACyAAQQE2AgggACACNgIEIABBATYCACACIAEpAgA3AgAgAkEIaiABQQhqKAIANgIAC04BAX8jAEEQayICJAAgAiAAKAIAIgBBCGo2AgwgAUGQ6M8AQQ5BnujPAEEEIABB8OfPAEGi6M8AQQsgAkEMakGA6M8AEI4YIAJBEGokAAs7AQJ/AkAgACgCACIBQRJGDQBBECABQQJrIAFBAU0bIgJBD0kNAEEEIQFBCCABIAJBD0cbIABqEIYwCwstAQF/IAAgAkEHcUECdGoiACgCACAAIAEgAmpBCGogA0EIaiAEIAUQ5iM2AgALRgEBfyAAKAKE6gFBA2tBAk8EQCAAKAK86QEPCyAAKAK86QEhAiAAKAKA6gEEfyACBUEBIAEgAiABIAJJGyIAIABBAU0bCwtBAQF/AkAgACgCBCIDIAFNBEAgASADayIBIAAoAhAiA08NASAAKAIMIAFqDwsgACgCACABag8LIAEgAyACEMMhAAupBAICfwF+AkAgAEUEQAJ/AkACQAJAAkACQAJAAn4gAwJ+AkAgAygCCCIAQTdNBEAgAEEvSw0BIAMpAwAhCiAAQR9LBEAgAyAAQSBzIgA2AgggAygCDCIJQQRqIQggCUF7Sw0JIAcgCEkNCiADIAg2AgwgAyADKAIQQQRrNgIQIAMgBiAJajUAAEIghiAKQiCIhCIKNwMACyAKIABBP3GtiAwDCyADIABBOHMiCTYCCCADKAIMIgBBCGohCCAAQXdLDQMgByAISQ0EIAMpAwAhCiADIABBB2o2AgwgAyADKAIQQQdrNgIQIAAgBmoiADUAAEIIhiAKQjiIhCAAMQAEQiiGhCAAMQAFQjCGhCAAMQAGQjiGhAwBCyADIABBMHMiCTYCCCADKAIMIgBBCGohCCAAQXdLDQQgByAISQ0FIAMpAwAhCiADIABBBmo2AgwgAyADKAIQQQZrNgIQIAAgBmoiADUAAEIQhiAKQjCIhCAAMQAEQjCGhCAAMQAFQjiGhAsiCjcDACAKIAlBP3GtiAshCkGkqfsAKAIAIAqncQwGCyAAIAhBqKr7ABCxOwALIAggB0GoqvsAELA7AAsgACAIQaiq+wAQsTsACyAIIAdBqKr7ABCwOwALIAkgCEGYqvsAELE7AAsgCCAHQZiq+wAQsDsACyIAIAJPDQEgBCABIABBAnRqIgAtAAI2AgAgBSAALwEANgIACw8LIAAgAkH8nvMAEMMhAAtCACMAQRBrIgAkACABIAJsIgFBwAAQ0TRFBEBBgPT8AEErIABBD2pB8PP8AEG49PwAENUeAAsgARDpESAAQRBqJAALTgEBfyMAQRBrIgIkACACIAAoAgAiAEEEajYCDCABQbSj/gBBCUG9o/4AQQsgAEGUo/4AQcij/gBBCSACQQxqQaSj/gAQjhggAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUECQQIQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEBQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEEQRQQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQACzsBAX8gAC0AACIAQQJrIgFB/wFxQSVPQv+PgIDgAyABrYinQQFxRXJFBEBBAQ8LIABBDWtB/wFxQQdJC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEQQRAQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC0oBAX8jAEEQayIBJAAgAUEIaiAAIAAoAgBBAUEQQSAQtxEgASgCCCIAQYGAgIB4RwRAIAAgASgCDEGQnf8AEP0vAAsgAUEQaiQAC0cBAX8jAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQQgQtxEgAigCCCIAQYGAgIB4RwRAIAAgAigCDCABEP0vAAsgAkEQaiQAC5kBAQV/IAAoAhhBCGooAhAhAiAAKAIkIgEEQCACIAFBCGooAhBqIQILIAAoAgQiASABIAAoAghBA3RqIgBHBEAgACABa0EDdiEAA0AgASgCACIEBH8gBCABQQRqKAIAIgUoAghBAWtBeHFqQQhqIAUoAlARBAAFQQALIQQgAUEIaiEBIAMgBGohAyAAQQFrIgANAAsLIAIgA2oLQgECf0EBIQMCQCABQf8BcSICQeMASw0AIAAgAkEKbiICQTByEIM2DQAgACABIAJBCmxrQTByQf8BcRCDNiEDCyADC0IAIAEoAigiAARAIAEoAiQhASAAQcwBbCEAIAMgBGohBANAIAEgAiADIAQQ2BsgAUHMAWohASAAQcwBayIADQALCwtIAQF/IwBBEGsiAiQAIAJBCGogACAAKAIAQQFBCEHIABC3ESACKAIIIgBBgYCAgHhHBEAgACACKAIMIAEQ/S8ACyACQRBqJAALSgEBfyMAQRBrIgMkACABIABrIAJqIgFBARDRNEUEQEGIhYgBQSsgA0EPakH4hIgBQeCHiAEQ1R4ACyAAIAFBARD4OiADQRBqJAALPgEBfyAALQAUIQEgAEEBOgAUAkAgAUUEQCAAQQhrIgAgACgCAEEBaiIBNgIAIAFFDQEQlA0gABD9HgsPCwALSAEBfyMAQRBrIgYkACABKAIAJQEgAiADIAQgBRAjIAZBCGoQzi0gBigCDCEBIAAgBigCCEEBcTYCACAAIAE2AgQgBkEQaiQAC0IBAX8gASgCBCICIAEoAghPBH9BAAUgASACQQFqNgIEIAEoAgAoAgAgAhDSNCEBQQELIQIgACABNgIEIAAgAjYCAAtKAQF/IwBBEGsiASQAIAFBCGogACAAKAIAQQFBBEEMELESIAEoAggiAEGBgICAeEcEQCAAIAEoAgxBuKTDABD9LwALIAFBEGokAAtMAQF/IAAQmh8gACgCECIBQYQBTwRAIAEQ8h8LIAAoAgQEQCAAKAIAIgFBhAFPBEAgARDyHwsgAEEEaiIAQQhqEKw7BEAgABC8KgsLC0MBAX8CQAJAAkAgAC0AKEEDaw4CAAIBCyAAQcQAahC8KiAAQThqIgEQ1isgARDoOyAAQSxqEOo7Cw8LIABBLGoQvCoLPwECfyMAQRBrIgEkACAAQQhrIgAgACgCACICQQFrNgIAIAEgADYCDCACQQFGBEAgAUEMahC4HwsgAUEQaiQACz8BAn8jAEEQayIBJAAgAEEIayIAIAAoAgAiAkEBazYCACABIAA2AgwgAkEBRgRAIAFBDGoQtx8LIAFBEGokAAs/AQJ/IwBBEGsiASQAIABBCGsiACAAKAIAIgJBAWs2AgAgASAANgIMIAJBAUYEQCABQQxqELYfCyABQRBqJAALOgECfyMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKALQAUECdEG8g8MAaigCACACEOwqIAFBEGokAAunAQEDfyMAQRBrIgYkACAGQQhqIQgjAEEQayIHJAACf0GBgICAeCAAKAIAQX8gBBsgAWsgAk8NABogB0EIaiAAIAEgAiADIAQQzBRBgYCAgHggBygCCCIAQYGAgIB4Rg0AGiAHKAIMIQQgAAshACAIIAQ2AgQgCCAANgIAIAdBEGokACAGKAIIIgBBgYCAgHhHBEAgACAGKAIMIAUQ/S8ACyAGQRBqJAALQQECfyMAQRBrIgEkACAAKAJIIgJBEk8EQCABIAApAgRCIIk3AgggASACNgIEIAFBBGpBBEEEEOAeCyABQRBqJAALRwEBfyMAQRBrIgUkACAFQQhqIAAgASACIAMgBBCxEiAFKAIIIgBBgYCAgHhHBEAgACAFKAIMQdywzAAQ/S8ACyAFQRBqJAALRwEBfyMAQRBrIgMkACADQQhqIAAgASACQQFBARC3ESADKAIIIgBBgYCAgHhHBEAgACADKAIMQZCxzAAQ/S8ACyADQRBqJAALMQAgACgCCEGAgICAeEcEQCAAQQhqEOM8IABBFGoQ6TsgAEEgahDjPCAAQSxqEIUwCwtHACABKAIARQRAQeinzgAQsjsACyAAIAEgAiABKAIwIgIgAyACIANJG0EBEKELIgI2AgQgAEEINgIAIAEgASgCMCACazYCMAtIAQF/AkAgACgCAEGAgICAeEYEQCAAKAIEIgEgASgCACIBQQFrNgIAIAFBAUcNASAAQQRqEIMgDwsgABC+HyAAQQRBIBDgHgsLRwECfyAAKAIAQYCAgIB4RwRAIAAoAggiAgRAIAAoAgQhAQNAIAEQ2BMgAUHoA2ohASACQQFrIgINAAsLIABBCEHoAxDgHgsLRwAgAEEANgIoIABBADYCJCAAIAE2AhAgACABNgIIIAAgATYCACAAIAEgAmoiATYCBCAAIAFBQHE2AhggABCELCAAQQA2AiALRwAgACgCqAJBAUYEQCAAIAIpAgA3AuwSIABB9BJqIAJBCGooAgA2AgALIAAoAqwCQQFGBEAgACABKAIEIAEoAghrNgL8EgsLOgEBfyADIAEgACABIAAgAyABa2oiBSACIAIgBUsbEIAUIgVqRgR/IAAgBWogBCACEIAUIAVqBSAFCwtHAQF/IwBBEGsiBCQAIARBCGogACABIAIgA0EEELcRIAQoAggiAEGBgICAeEcEQCAAIAQoAgxBpNnzABD9LwALIARBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxB5MH7ABD9LwALIANBEGokAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELcRIAUoAggiAEGBgICAeEcEQCAAIAUoAgxBoKL+ABD9LwALIAVBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBjKX+ABD9LwALIANBEGokAAtFAQF/IABBDGoQvgwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgAEEEQQgQ4B4LPAAgACgCIEEESQRAQQAPCyAAKAIkBEBBAQ8LIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACzwAIAAoAiBBCEkEQEEADwsgACgCJARAQQEPCyAAKAI8IAAoAkAiACgCCEEBa0F4cWpBCGogACgCTBEEAAs8ACAAKAIgQQJJBEBBAA8LIAAoAiQEQEEBDwsgACgCPCAAKAJAIgAoAghBAWtBeHFqQQhqIAAoAkwRBAALRQEBfyAAQQxqEMMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIABBBEEIEOAeC0MBAn8jAEEgayICJAAgAkEMaiIDIAFBgOaFAUEMEMYsIAIgACkCBDcCGCADIAJBGGpBnOaFARDkFBDbGyACQSBqJAALRQEBfyAAQQxqEMUMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIABBBEEIEOAeC0kAAkAgAcAiASAAKAIISQRAIAAoAgQgAUEDdGoiACgCAEUNASAADwtB4IKGAUE4QZiDhgEQnykAC0Gog4YBQQ9BuIOGARDLJAALPwEBfyAAKAIMIAAoAhAiASgCCEEBa0F4cWpBCGogASgCUBEEACEBIAAoAhQiAAR/IAEgAEEIaigCEGoFIAELC0cBAX8jAEEQayIDJAAgA0EIaiAAIAEgAkEBQQEQtxEgAygCCCIAQYGAgIB4RwRAIAAgAygCDEGsv4YBEP0vAAsgA0EQaiQAC0cBAX8jAEEQayIFJAAgBUEIaiAAIAEgAiADIAQQtxEgBSgCCCIAQYGAgIB4RwRAIAAgBSgCDEHM54cBEP0vAAsgBUEQaiQACz8BAn8gASgCGAR/IAEQ+hshAiABIAEoAhhBAWs2AhggAkEMayEDIAJBGGsFQQALIQEgACADNgIEIAAgATYCAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELcRIAUoAggiAEGBgICAeEcEQCAAIAUoAgxB1IOIARD9LwALIAVBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBBEEEELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBkKKIARD9LwALIANBEGokAAtHAQF/IwBBEGsiAyQAIANBCGogACABIAJBAUEBELcRIAMoAggiAEGBgICAeEcEQCAAIAMoAgxBwMWIARD9LwALIANBEGokAAtHAQF/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEELESIAUoAggiAEGBgICAeEcEQCAAIAUoAgxBzKeJARD9LwALIAVBEGokAAs9AQN/IAAoAgAiAyACaiIEIANJIARBD0tyIgVFBEAgAgRAIAAgA2pBBGogASAC/AoAAAsgACAENgIACyAFCzoBAX8jAEEgayICJAAgAUEBQQFBACAAKQMAIAJBDGoiAUEUEO0QIgAgAWpBFCAAaxCBCSACQSBqJAALTAEBfwJAAkACQCAALQAIDgQAAgIBAgsgACgCACIAQYQBSQ0BIAAQ8h8PCyAAKAIEIgEgASgCAEEBayIBNgIAIAENACAAQQRqELIaCwtKAQF/IAEQxiEgASgCCCICRQRAQdCEwwBBHkHwhMMAEMskAAsgAEEENgIAIAEgAkEBayIANgIIIAEgASgCBCAAQQF0ai8BADsBJAs6AQF/IwBBEGsiASQAAn8gACgCAEUEQCABQQhqIABBBGoQ3DsgASgCDAwBCyAAKAIICyABQRBqJABFCzkBAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBBDxLSEAIAIQ+ypBACAAEJosQQhqIAFBEGokAAtJAQF/IwBBEGsiAiQAIAIgAEEEajYCDCABQdjJzABBCUHhycwAQQsgAEG4ycwAQezJzABBCSACQQxqQcjJzAAQjhggAkEQaiQACzgAIAMEQCABQRhqIQEgA0EMbCEDA0AgASACQQwQoTYgAkEMaiECIANBDGsiAw0ACwsgAEEINgIAC0oBAX8gARDTISABKAIIIgJFBEBBpMbOAEEeQcTHzgAQyyQACyAAQQQ2AgAgASACQQFrIgA2AgggASABKAIEIABBAXRqLwEAOwEkC0kBAX8jAEEQayICJAAgAiAAQQxqNgIMIAFB9PHOAEENQYHyzgBBBSAAQdTxzgBBhvLOAEEFIAJBDGpB5PHOABCOGCACQRBqJAALSQEBfyMAQRBrIgIkACACIABBBGo2AgwgAUHQoM8AQQlB2aDPAEELIABB2J/PAEHkoM8AQQkgAkEMakHAoM8AEI4YIAJBEGokAAtDAgF/AX4gAEE0aiABQTRqEN0gIABBKGogAUEoahDDBiABLwFAIQIgASkDICEDIAAgARCxLiAAIAM3AyAgACACOwFACzEBAX8gACgCBCICBEAgACgCACACQQFqIAFsQQdqQXhxIgBrIAAgAmpBCWpBCBD4OgsLSQEBfyMAQRBrIgIkACACIABBCGo2AgwgAUGQ6M8AQQ5BnujPAEEEIABB8OfPAEGi6M8AQQsgAkEMakGA6M8AEI4YIAJBEGokAAtJAQF/IwBBEGsiAiQAIAIgAEEEajYCDCABQdzv0ABBCUHl79AAQQsgAEG879AAQfDv0ABBCSACQQxqQczv0AAQjhggAkEQaiQACzUBAX8CfyABIAJPBEBBfyEBA0BBAiABQQFqIgEgAksNAhogAC8BACAAQQJqIQANAAsLQQELC+wBAQF/AkAgAQRAIAAgACgCuOkBIAEoAgQgASgCCGpHNgKg6wEgABDhGyAAIAEoAqjVATYCnOsBIAAgASgCBCICNgK06QEgACACNgKw6QEgACACIAEoAghqIgI2ArjpASAAIAI2AqzpAQJAIAEoAqzVAQRAIABCgYCAgBA3A4jqASAAIAEoAqjQATYCrNABIAAgASgCrNABNgKw0AEgACABQaTQAGo2AgwgACABQZQgajYCCCAAIAFBnDBqNgIEIAAgAUEMajYCACAAIAEoArDQATYCtNABDAELIABCADcDiOoBCwwBCyAAEOEbCwtfACAAQQA2AkggAEKBgICAwAA3AkAgAEIENwI4IABCATcCMCAAQoCAgIAQNwIoIABCgICAgMAANwIgIABCgICAgBA3AhggAEKBgICAwAA3AhAgAEIENwIIIABCATcCAAu0AwEBfyAAQQRqIQICQAJAAkACQCAAKAIAQQFrDgMBAgMACyMAQTBrIgAkACAAIAItAAxBAnQiAkHcsP4AaigCADYCDCAAIAJBwLD+AGooAgA2AgggAEEBNgIUIABB9Kr+ADYCECAAQgE3AhwgAEHHAjYCLCAAIABBKGo2AhggACAAQQhqNgIoIAEoAgAgASgCBCAAQRBqEMsKIABBMGokAA8LIwBBMGsiACQAIAAgAi0ADEECdCICQZSx/gBqKAIANgIMIAAgAkH4sP4AaigCADYCCCAAQQE2AhQgAEH0qv4ANgIQIABCATcCHCAAQccCNgIsIAAgAEEoajYCGCAAIABBCGo2AiggASgCACABKAIEIABBEGoQywogAEEwaiQADwsjAEEwayIAJAAgACACLQAMQQJ0IgJB3LH+AGooAgA2AgwgACACQbCx/gBqKAIANgIIIABBATYCFCAAQfSq/gA2AhAgAEIBNwIcIABBxwI2AiwgACAAQShqNgIYIAAgAEEIajYCKCABKAIAIAEoAgQgAEEQahDLCiAAQTBqJAAPCyAAKAIEIAEgACgCCCgCEBECAAs8AQN/IwBBMGsiAyQAIANBBGoiBCABIAIQ5QggA0EYaiIFIAEQmzYgAhDyEiAAIAQgBRDUGCADQTBqJAALPAEDfyMAQTBrIgMkACADQQRqIgQgASACEOQIIANBGGoiBSABEJs2IAIQ8xIgACAEIAUQ1BggA0EwaiQACz0BAX8gACACIAFrIgJBA3YiAxDsLSACBEAgACgCBCAAKAIIQQN0aiABIAL8CgAACyAAIAAoAgggA2o2AggLTQEBfyAAIAEoAgw2AhggACABKAIAIgI2AhAgACACQQhqNgIIIAAgAiABKAIEakEBajYCDCAAIAIpAwBCf4VCgIGChIiQoMCAf4M3AwALRwEBfyAAIAAoAggiAUECcjYCCAJAIAENACAAKAIAIQEgAEEANgIAIAAgACgCCEF9cTYCCCABRQ0AIAAoAgQgASgCBBEDAAsLRQEBfyMAQSBrIgMkACADIAI2AhwgAyABNgIYIAMgAjYCFCADQQhqIANBFGpBiK+IARCQISAAIAMpAwg3AwAgA0EgaiQAC0MBAX9BFEEEEK02IgNFBEBBBEEUEKM9AAsgAyACNgIQIAMgATYCDCADIAApAgA3AgAgA0EIaiAAQQhqKAIANgIAIAMLOwEBfyMAQSBrIgIkACACQQhqIAAoAgAgAkEWahCwECABQQFBAUEAIAIoAgggAigCDBCBCSACQSBqJAALSQICfwF8IAEoAggiA0GAgIABcSECIAArAwAhBCADQYCAgIABcUUEQCABIAQgAkEAR0EAEP0IDwsgASAEIAJBAEcgAS8BDhDnBws6AQF/IAAoAhgiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBGGoQgyALIAAQoycgABDpOyAAQQxqEOk7Cz8BAX8gAEEgaiIBEJ8sIAEQ8zsgAEEsahCOMCAAKAI8IgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQTxqEIYfCwtBAQF/IwBBEGsiAyQAIAMgAjYCDCADIAE2AgggA0EANgIEIANBBGoQ1ikhASAAQQA2AgQgACABNgIAIANBEGokAAtOAgF/AW8jAEEQayIDJAAgAyABNgIMIAMgADYCCCADQQA2AgQgA0EEahDWKUEIaiACJQEgAhDyHxADIQQQ3xIiACAEJgEgA0EQaiQAIAALQQEBfyAAQQxqEJMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLMQAgABDpOyAAQQxqEOk7IABBMGogACgCKCAAKAIsIAAoAiQoAhARAQAgAEEYahDeOwtBAQF/IABBDGoQlQwCQCAAKAIcIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIABBHGoQ+x4LIAAQwycgABDqOwtJAQF/IwBBIGsiASQAIAFBAjYCBCABQdiuzgA2AgAgAUIBNwIMIAFBrgM2AhwgASAANgIYIAEgAUEYajYCCCABQeiuzgAQ7ywAC0ABAX8gACgCCCIBBEAgACgCBCEAA0AgACgCAEGAgICAeEcEQCAAQQRBIBDgHgsgAEEMaiEAIAFBAWsiAQ0ACwsLQQEBfyAAQQxqEJ8MAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQgEBfyABENApIQIgACgCKCIBIAAoAiBGBEAgAEEgakGo39AAEJ0oCyAAKAIkIAFBAnRqIAI2AgAgACABQQFqNgIoCzsBAX8gACgCACIAQRBqEOwmAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQcAAQQgQ+DoLC00BAX8CQCACRQ0AIAEgACgCrOkBIgJGDQAgACACNgK46QEgACABNgKs6QEgACgCsOkBIQMgACABNgKw6QEgACABIAMgAmtqNgK06QELCz8BAX9BASABLQAAdCICQfifAXFFBEAgAkGD4ABxBEAgAEEoIAEQtywPCyAAIAEpAgQ3AgAPCyAAQRUgARC3LAtCACABELAaIgFBD00EQCAAIAFBAXQiAUGE89EAai8BADsBAiAAIAFB9PPRAGovAQA7AQAPCyABQRBBlPXRABDDIQALQQEBfyAAQQxqEKMMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqEKcMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLOAEBfyAAIAEQhC4gACgCCCEDIAAgAQR/IAEEQCAAKAIEIANqIAIgAfwLAAsgASADagUgAws2AggLQQEBfyAAQQxqELQMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELYMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELcMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQQEBfyAAQQxqELkMAkAgACgCHCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQRxqEPseCyAAEMMnIAAQ6jsLQwECfyMAQdAAayICJAAgAkEMaiIDIAFBABCvASACIAMQoAEgAigCBCEBIAAgAigCADYCACAAIAE2AgQgAkHQAGokAAs6ACAAKAIgRQRAQQAPCyAAKAIkBEBBAQ8LIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACzwBAX8gAUEIaiIDEMUnIANBBEEMEOAeIAFBEGogAkEIaigCADYCACABIAIpAgA3AgggACABQdwA/AoAAAtKAQF/IwBBEGsiASQAQQBBwAAQ0TRFBEBB5vSHAUEpIAFBD2pBoPSHAUGQ9YcBENUeAAsgAELAADcCACAAQsAANwIIIAFBEGokAAvVAgEIfyAAKAIAIgRBDGoiBiEAIwBBEGsiAyQAAkAgACgCDCIBRQRAIAAoAgQhACADQQA2AgwgAyAANgIIDAELIAAoAgAhAiAAKAIIIQUgAyAAKAIEIgc2AgggAyABIAIgBSACQQAgAiAFTRtrIgBrIgVrIghBACABIAhPGzYCDCACIAAgAWogASAFSxsiASAARg0AIAEgAGshASAHIABBAnRqIQADQCAAKAIAIgIgAigCAEEBayICNgIAIAJFBEAgABCqKwsgAEEEaiEAIAFBAWsiAQ0ACwsgA0EIaiIAKAIEIgEEQCAAKAIAIQADQCAAKAIAIgIgAigCAEEBayICNgIAIAJFBEAgABCqKwsgAEEEaiEAIAFBAWsiAQ0ACwsgA0EQaiQAIAZBBEEEEOAeAkAgBEF/Rg0AIAQgBCgCBEEBayIANgIEIAANACAEQSBBBBD4OgsLPQECfyMAQRBrIgEkACAAQQhrIgAgACgCAEEBayICNgIAIAEgADYCDCACRQRAIAFBDGoQqisLIAFBEGokAAtCAQF/IwBBEGsiAyQAIAEoAgAlASACEBYgA0EIahDOLSADKAIMIQEgACADKAIIQQFxNgIAIAAgATYCBCADQRBqJAALQgEBfyMAQRBrIgMkACADQQhqIAEgASgCCBDqDCACIAMoAgggAygCDBD7KCEBIABBAjYCACAAIAE2AgQgA0EQaiQAC0IBAX8jAEEQayIDJAAgA0EIaiABIAEoAggQ6gwgAiADKAIIIAMoAgwQ+yghASAAQQE7AQAgACABNgIEIANBEGokAAtCAQF/IwBBEGsiAyQAIANBCGogASABKAIIEOoMIAIgAygCCCADKAIMEPsoIQEgAEEBOgAAIAAgATYCBCADQRBqJAALRgECfyABKAIEIQIgASgCACEDQQhBBBCtNiIBRQRAQQRBCBCjPQALIAEgAjYCBCABIAM2AgAgAEHstYkBNgIEIAAgATYCAAtCAQF/IwBBIGsiAyQAIANBADYCECADQQE2AgQgA0IENwIIIAMgATYCHCADIAA2AhggAyADQRhqNgIAIAMgAhDvLAALNAAgAEHgAGoQ3jsgAEHsAGoQhzAgAEFAaxD4JiAAKAJ4QYCAgIB4RwRAIABB+ABqEOo7Cws1ACAAKAIAIgAoAkwEQCAAQcwAahC8KgsgACgCAEECRwRAIABBEGoQ3jsLIABB1ABBBBD4OgtEAAJAAkACQCAALQAoQQNrDgIAAgELIABBMGoQvCoLDwsgAEFAaxC8KiAAQdQAaiAAKAJMIAAoAlAgACgCSCgCEBEBAAtDAAJAAkACQCAALQAQQQNrDgIAAgELIABBFGoQvCoLDwsgAEEsahC8KiAAQUBrIAAoAjggACgCPCAAKAI0KAIQEQEACzwBAX8gABC8LiAAKAJIIgFBhAFPBEAgARDyHwsgAEHUAGoQvSggACgCUCIAQRBqEN47IABByABBBBD4Ogs6AQF/IAEoAgAiAiABKAIERgR/QQAFIAEgAkECajYCACACLwAAIQJBAQshASAAIAI7AQIgACABOwEACzIBAX8gACgCSCIBQRJJBH8gAEHIAGoFIAAoAgQhASAAQQRqCyEAIAEEQCAAQQA2AgALC0IBAX8gACgCACIAKAIMIgEQiDUgAUEwQQgQ+DoCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBEEEEEPg6CwtFAQF/IAEoAggiAkUEQEG4ss4AQR5B2LLOABDLJAALIABBBDYCACABIAJBAWsiADYCCCABIAEoAgQgAEEBdGovAQA7ARQLOQEBfyMAQUBqIgMkACADIAEgAiAALQBNEJMVIAAQkiogACADQcAA/AoAACAAQgA3AkQgA0FAayQAC0UBAX8gASgCCCICRQRAQaTGzgBBHkHExs4AEMskAAsgAEEENgIAIAEgAkEBayIANgIIIAEgASgCBCAAQQF0ai8BADsBEAs7AQF/IwBBEGsiAiQAIAEQ0yEgAkEAEIscOgAPIAEoAiAgAkEPaiACQRBqIgEQvSYgAEEENgIAIAEkAAs4AgF+AX8CQCAAKQMAIgFCCFENACABpyICQQZJDQAgAkEHRgRAIABBCGoQpyUPCyAAQQhqEKclCwtBAQF/IwBBEGsiAiQAIAJBCGogASgCDCABKAIQKAIgEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCDCABKAIQKAIkEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCGCABKAIcKAIgEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAQF/IwBBEGsiAiQAIAJBCGogASgCGCABKAIcKAIkEQAAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtAAQF/IwBBEGsiAiQAIAIgACgCACIAQQxqNgIMIAFBxOfPAEEJIABBpOfPACACQQxqQbTnzwAQgw8gAkEQaiQACzoBAX8gASAAKAIEayIBIAAoAhwiAkGACGpLBEAgACABQYAEIAEgAmtBgAhrIgAgAEGABE8bazYCHAsLPwIBfwF+IwBBEGsiAiQAIAIgATYCDELJz9my8eW66icgAkEMakEEEN4TIAAoAgQhACACQRBqJACnIABBAWtxCzkAIAAgACgCAEEHaiIAQXhxNgIAIAIgAEEDdiIASwRAIAAgAWpBADoAAA8LIAAgAkHM7NEAEMMhAAs+ACABQZ8ETQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgBFBAWo2AoARDwsgAUGgBEGsm9YAEMMhAAs+ACABQf8BTQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgAhBAWo2AoAIDwsgAUGAAkGsm9YAEMMhAAs+ACABQb8FTQRAIAAgAUECdGoiASABKAIAQQFqNgIAIAAgACgCgBZBAWo2AoAWDwsgAUHABUGsm9YAEMMhAAs+AQF/IwBBIGsiASQAIAFBFGoiAyACQcSo+wAQzhggAUEIaiADQdSo+wAQkCEgACABKQMINwMAIAFBIGokAAs5AQF/IwBBIGsiASQAIAFBFGoiAyACELAVIAFBCGogA0HUqPsAEJghIAAgASkDCDcDACABQSBqJAALPQEBfyACQRBqIQMCQCACQW9NBEAgASADSQ0BIAAgAmoPCyACIANB7P7+ABCxOwALIAMgAUHs/v4AELA7AAtDAQF/IAAgASgCKCgCAEGTgICAeEYEfyABKAIAIgIQ1DoaIAEoAhwhASACENQ6IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIoKAIAQZOAgIB4RgR/IAEoAgAiAhC+PBogASgCHCEBIAIQvjwgAWsFIAILNgIIIABCgICAgBA3AgALQwEBfyAAIAEoAiQoAgBBk4CAgHhGBH8gASgCACICENM6GiABKAIcIQEgAhDTOiABawUgAgs2AgggAEKAgICAEDcCAAtDAQF/IAAgASgCJCgCAEGTgICAeEYEfyABKAIAIgIQ1DoaIAEoAhwhASACENQ6IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIoKAIAQZOAgIB4RgR/IAEoAgAiAhDTOhogASgCHCEBIAIQ0zogAWsFIAILNgIIIABCgICAgBA3AgALQwEBfyAAIAEoAiwoAgBBk4CAgHhGBH8gASgCACICENQ6GiABKAIcIQEgAhDUOiABawUgAgs2AgggAEKAgICAEDcCAAtDAQF/IAAgASgCKCgCAEGTgICAeEYEfyABKAIAIgIQwDwaIAEoAhwhASACEMA8IAFrBSACCzYCCCAAQoCAgIAQNwIAC0MBAX8gACABKAIsKAIAQZOAgIB4RgR/IAEoAgAiAhDTOhogASgCHCEBIAIQ0zogAWsFIAILNgIIIABCgICAgBA3AgALOgEBfyABKAIAIgIgASgCBEYEf0EABSABIAJBBGo2AgAgAigCACECQQELIQEgACACNgIEIAAgATYCAAs7AQF/AkAgAUH/AXEiAUEJSw0AIAAgAUECdCIBQaSOhQFqKAIASA0AIAAgAUH8jYUBaigCAEwhAgsgAgs7AQF/AkAgAUH/AXEiAUESSw0AIAAgAUEDdCIBQbCRhQFqKQMAUw0AIAAgAUGYkIUBaikDAFchAgsgAgs6AQF/IAAoAgQgASgCBCAAKAIIIgAgASgCCCIBIAAgAUkbEJknIgIgACABayACGyIAQQBKIABBAEhrC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYCBCAAQYCIiAE2AgALQAEBfyABKAIAIgEgASgCECIEQQFqNgIQIARBAEgEQAALIAAgATYCDCAAIAM2AgggACACNgIEIABB3IiIATYCAAs8AQF/QQxBBBCtNiIERQRAQQRBDBCjPQALIAQgAToACCAEIAM2AgQgBCACNgIAIAAgBK1CIIZCA4Q3AgALRwEBfwJAAkACQCAALQDcAg4EAAICAQILIAAoAtgCIgFBhAFPBEAgARDyHwsgACkDAEICUQ0BIAAQoCkPCyAAQZgBahDVHwsLgwEBAn8gACgCHCIBBEAgACgCGCABQQJ0QQIQ+DoLIABBIGoiARDfHiABENU7IABBLGoiAiIAKAIIIgEEQCAAKAIEQRxqIQADQCAAIABBCGsoAgAgAEEEaygCACAAQQxrKAIAKAIQEQEAIABBJGohACABQQFrIgENAAsLIAJBBEEkEOAeCzQBAX9BMEEEEK02IgIEQCACIAFBMPwKAAAgAEHM3cIANgIEIAAgAjYCAA8LQQRBMBCjPQALNwEBf0HQAEEIEK02IgIEQCACIAFB0AD8CgAAIABBuPjCADYCBCAAIAI2AgAPC0EIQdAAEKM9AAs0AQF/QThBBBCtNiICBEAgAiABQTj8CgAAIABB6PjCADYCBCAAIAI2AgAPC0EEQTgQoz0ACzcBAX9BwABBCBCtNiICBEAgAiABQcAA/AoAACAAQfj4wgA2AgQgACACNgIADwtBCEHAABCjPQALNgEBf0HQAEEIEK02IgEEQCABQoGAgIAQNwMAIAFBCGogAEHIAPwKAAAgAQ8LQQhB0AAQoz0ACzYBAX9BqAFBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIABBoAH8CgAAIAEPC0EIQagBEKM9AAs2AQF/QdACQQgQrTYiAQRAIAFCgYCAgBA3AwAgAUEIaiAAQcgC/AoAACABDwtBCEHQAhCjPQALOQECfyMAQRBrIgEkAAJAIAAtAAwNACABQQhqIgIgABCdGSABLQAIQQRGDQAgAhC5LgsgAUEQaiQACzkBAn8jAEEQayIBJAACQCAALQAMDQAgAUEIaiICIAAQwxkgAS0ACEEERg0AIAIQuS4LIAFBEGokAAtDAQF/QdQAQQQQrTYiAUUEQEEEQdQAEKM9AAsgAUHkssMANgJQIAFBATYCTCABIAA7AUogAUEAOwFIIAFBAjYCACABC0ABAX9BFEEEEK02IgFFBEBBBEEUEKM9AAsgAUKBgICAEDcCACABIAApAgA3AgggAUEQaiAAQQhqKAIANgIAIAELPQECfwJAIAAoAgAiAkUNACAAKAIEIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBRQ0AIAIgASAAKAIIEPg6CwtAAQF/QdQAQQQQrTYiBEUEQEEEQdQAEKM9AAsgBCADNgJQIAQgAjYCTCAEIAE7AUogBCAAOwFIIARBAjYCACAEC0cAIABBAjoARiAAQcgBOwFEIABBADsBOCAAQgQ3AzAgAEIANwMoIABCgICAgMAANwMgIABCAjcDGCAAQgA3AwAgAEEANgJAC0gBAn8jAEEQayICJAAgACgCCARAIAJBBGoiASAAKAIENgIIIAEgACgCADYCBCABIAAoAgg2AgAgAUEBQQIQ4B4LIAJBEGokAAveAQEDfyAAKAIAIgJBgICAeE8EQCAAAn8CQCACQf///wdxIgIiAEH/H0H//wMgAS0ALBtLBEAgAEGAgMQASQ0BIAEoAhRBAWsMAgsgAEEGdiIDIAEoAghJBEAgASgCBCADQQF0ai8AACAAQT9xagwCCyABKAIUQQFrDAELIAEoAhwgAEsEQCABIAAQwQ8MAQsgASgCFEECawsiACABKAIUIgRJBH8gASgCECAAQQJ0aigAAAUgAwsgASgCACAAIARJGyIAQRh0QQAgAEGA/P//A3FBgLADRhsgAnI2AgALCzMBAX9BOEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEEw/AoAACABDwtBBEE4EKM9AAspACAAKAIAIgBBCGoQ3jsgAEEgahDeOyAAQUBrEOM8IABB4ABBCBD4Ogs7AQJ/IAEoAhQiAiABKAIIIgNJBEAgASgCDCACIAEoAgQiAmogAiADahC9JiABIAM2AhQLIABBBDoAAAs8ACAAKALQASAAKALIASAAKAKAASAAKAJoIAAoAgggACgCIGpqamogACgCoAEgACgCQGpBA3RqakGwAmoLNQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEN47IABBDGoQhjAgAEEYaiEAIAFBAWsiAQ0ACwsLOQEBfyAAKAIIIgEEQCAAKAIEQTxqIQADQCAAQQxrEIUwIAAQhTAgAEHIAGohACABQQFrIgENAAsLCzgBAX8gACgCCCIBBEAgACgCBEEcaiEAA0AgAEEMaxCFMCAAEIUwIABBMGohACABQQFrIgENAAsLCzgBAX8gACgCCCIBBEAgACgCBEEsaiEAA0AgAEEMaxCFMCAAEIUwIABBOGohACABQQFrIgENAAsLCzkBAX8gACgCCCIBBEAgACgCBCEAA0AgAEEIQRgQ4B4gAEEMahCFMCAAQRhqIQAgAUEBayIBDQALCwszAQF/QTxBBBCtNiIBBEAgAUKBgICAEDcCACABQQhqIABBNPwKAAAgAQ8LQQRBPBCjPQALNQEBf0HAAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEE4/AoAACABDwtBBEHAABCjPQALOAACQCAAQf/9g3hNBEAgAEEIdiAAakGAgAggAGtBC3ZBACAAQYCACEkbaiIADQELQbh/IQALIAALXQEBf0GAgAQhAQJAAkACQAJAAkACQAJAIAAtAABBAWsOCAAAAAYCAwQFAQsAC0HAy9EAQShB6MvRABCfKQALQYCAEA8LQYCAwAAPC0GAgIACDwtBgICABCEBCyABCzkBAn8gACgCBCIBRQRAQQAPCyABQQFrIQIgAUELTwRAIAJBCkHktf4AEMMhAAsgACACaiwACEEATgtBAQJ/IAAoAhwiAUUEQEHk3v4AELI7AAsgACgCECAAKAIUIAAoAhgiAhC6KRogACABQQFrNgIcIAAgAkEQajYCGAs2AQF/QdAAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQcgA/AoAACABDwtBBEHQABCjPQALNQEBf0HEAEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEE8/AoAACABDwtBBEHEABCjPQALRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ7x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8h4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ9x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ9x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ7x4gAEHkAGpBgAhBgAgQpRQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8x4gAEHkAGpBgAhBgAgQphQLRwEBfyAAQRBqQYjlgAFBqOWAARCFNSICKAIAIAIoAgQoAgwRBAAQ2gEgABCvNCAAQTBqIAEQ8h4gAEHkAGpBgAhBgAgQpRQLMwEBf0EwQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQSj8CgAAIAEPC0EEQTAQoz0ACzMBAX9BNEEEEK02IgEEQCABQoGAgIAQNwIAIAFBCGogAEEs/AoAACABDwtBBEE0EKM9AAs2AQF/QewAQQQQrTYiAQRAIAFCgYCAgBA3AgAgAUEIaiAAQeQA/AoAACABDwtBBEHsABCjPQALOAEBfyAAIAIQ7S0gAkEBdCIDBEAgACgCBCAAKAIIQQF0aiABIAP8CgAACyAAIAAoAgggAmo2AggLPQEBfyMAQRBrIgQkACAEQQhqIAEoAgAgAiADEMslIAQoAgwhASAAIAQoAgg2AgAgACABNgIEIARBEGokAAs9AQF/IAEoAgAiASgCICECIABBBGogAUEkakEAIAEoAiQbEO4lIAAgAkEEdjYCICAAQQA2AhwgACABNgIACzYBAX8gACgCBCIBIAEgACgCCEEDdGoQ+yJBNGohASAAKAIcIgAEfyABIABBCGooAhBqBSABCwunAgIHfwFvIwBBEGsiAyQAIANBCGohByMAQRBrIgQkAAJAIAFBBGoiBS0AAARAQQIhAgwBCyMAQRBrIgYkACABKAIAJQEQSiEJEN8SIgEgCSYBIAEhAiAGQQhqEM4tQQEhASAEQQhqIggCfyAGKAIIQQFxBEAgBigCDAwBC0EAIQEgAgs2AgQgCCABNgIAIAZBEGokAEEBIQIgBCgCDCEBIAQoAghBAXEEQCAFQQE6AAAMAQsCfyABJQEQQEUEQCABJQEQQSEJEN8SIgUgCSYBQQAMAQsgBUEBOgAAQQILIQIgAUGEAU8EQCABEPIfCyAFIQELIAcgATYCBCAHIAI2AgAgBEEQaiQAIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAu+AgEEf0EBIQQCQAJ/IAEoAgAhASMAQSBrIgIkAAJAAkACQCABKAIAQQJHDQAgASgCCCEDIAFBADYCCCADRQ0BIAIgAxEDACACKAIEIQUgAigCACEDIAEoAgBBAkYEQCABIAU2AgQgASADNgIADAELIAIgBTYCDCACIAM2AgggA0ECRw0CCyACQSBqJAAgAQwCCyACQQA2AhggAkEBNgIMIAJBoKyIATYCCCACQgQ3AhAgAkEIakGorIgBEO8sAAsCQCACQQhqIgAoAgAiAUECRiABRXINACAAKAIEIgFBhAFJDQAgARDyHwsgAkEANgIYIAJBATYCDCACQcisiAE2AgggAkIENwIQIABB0KyIARDvLAALIgEoAgBBAUcEQEEAIQQMAQsgASgCBBD0OiEBCyAAIAE2AgQgACAENgIACz8BAn8gASgCACIDKAIIIgIgASgCBCIBSQRAIAEgAkHAq4kBEK87AAsgACACIAFrNgIEIAAgAygCBCABajYCAAs7AQF/IAAtACRBA0YEQAJAIAAtACANACAAKAIURQ0AIAAoAhgiAUGEAUkNACABEPIfCyAAQQhqEOQqCwtDAAJAAkACQAJAIAAtADwOBAADAwEDCyAAKAI4IgBBgwFNDQIMAQsgAEEYahDfICAAKAIIIgBBgwFNDQELIAAQ8h8LCzcAIAAoAiBBgICAgHhHBEAgAEEgahDpOwsgACgCLEGAgICAeEcEQCAAQSxqIgAQ0SsgABDoOwsLPAACQAJAAkAgAC0ANA4EAAICAQILIAAQ7TsPCyAAQSxqELwqIABBHGoQvSsgAEEQaiIAENQnIAAQ7jsLCy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCgCWCACEOgqIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQoAiggAhDqKiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIMIAIQ+CogAUEQaiQAC0MAAkACQAJAAkAgAC0AGA4EAAMDAQMLIAAoAgQiAEGDAU0NAgwBCyAAKAIMRQ0BIAAoAhAiAEGDAU0NAQsgABDyHwsLNgACQCABIAJNBEAgAiADTQ0BIAIgAyAEELA7AAsgASACIAQQsTsACyAAIAI2AgQgACABNgIACz8BAX8gACgCACEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDBGA8LIAAgARC1HA8LIAAgARC2HAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAhAgAhD7KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIIIAIQ+yogAUEQaiQACy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBBCuNCACEPsqIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAgggAhD8KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIMIAIQ/CogAUEQaiQACy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhyMgASgCBCgCACACEP4qIAFBEGokAAstAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAEoAgQoAgQgAhD+KiABQRBqJAALLQECfyMAQRBrIgEkACABQQRqIgIgABCHIyABKAIEKAIIIAIQgCsgAUEQaiQACzkBAX8gACgCECIBBEAgAEEcaiAAKAIUIAAoAhggASgCEBEBAAsgACgCMCIABEAgAEGAIEEEEPg6Cws5AQF+IAApAwAiAUIDUgRAIAFCAlEEQCAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABCRKgsLOQEBfiAAKQMAIgFCBVIEQCABQgRRBEAgAEEUaiAAKAIMIAAoAhAgACgCCCgCEBEBAA8LIAAQkioLC1EBAX9BDCEBAkACQAJAAkACQCAAKAIAQQFrDgoEBAQEAQEBAgEDAAtB5M3OAEEMQfDNzgAQ7SwAC0EUIQEMAgtBMCEBDAELQRwhAQsgACABags5AQF+IAApAwAiAUIFUgRAIAFCBFEEQCAAQRRqIAAoAgwgACgCECAAKAIIKAIQEQEADwsgABClIQsLNwAgASACOgBwIAAgAUHxAPwKAAAgACACOgBxIABB9gBqIAFB9gBqLwEAOwEAIAAgASgBcjYBcgs2ACABQYACakEBQQEQ4B4gAUGIAmogAkEIaigCADYCACABIAIpAgA3AoACIAAgAUHAAvwKAAALNgEBfyAAKAIEIgEEQCAAKAIAIAFBAnRBBBD4OgsgACgCDCIBBEAgACgCCCABQQJ0QQQQ+DoLCzYBAX8gACgCBCIBBEAgACgCACABQQJ0QQQQ+DoLIAAoAgwiAQRAIAAoAgggAUECdEECEPg6Cws/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ/CgPCyAAIAEQ0xwPCyAAIAEQ0hwLPwEBfyAAKAIAIQAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEJwSDwsgACABELccDwsgACABELQcCz8BAX8gACgCACEAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDMJA8LIAAgARDTHA8LIAAgARDSHAs4ACAAIAAoAgAgAyAEEN0HNgIAIAIgBE8EQCAEBEAgASADIAT8CgAACw8LIAQgAkGQ6fwAELA7AAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQ4ygPCyAAIAEQuRwPCyAAIAEQuBwLPwEBfyAAKAIAIQAgASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEL8QDwsgACABELccDwsgACABELQcCzwAIAEtAABBDUYEQCAAIAEoAgg2AgQgACABKAIEIgBBCGpBACAAGzYCAA8LQZCJ/wBBKEG4if8AEJ8pAAs+AQF/IAAgASgCJCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs+AQF/IAAgASgCKCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs+AQF/IAAgASgCLCgCAEGTgICAeEYEfyABEJA7GiABKAIcIQIgARCQOyACawUgAgs2AgggAEKAgICAEDcCAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEKYZIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEKcZIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEI8sIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACENorIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEP8WIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEIAXIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEPIWIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs7AQF/IwBBEGsiAyQAIANBCGogASgCACACEPEWIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAs5AQF/IwBBEGsiAiQAIAJBCGogAUEYahDcOyACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALOwEBfyMAQRBrIgMkACADQQhqIAEoAgAgAhCsHyADKAIMIQEgACADKAIINgIAIAAgATYCBCADQRBqJAALjQQBCX9BASEIAkAgASgCAEGM4oUBQQsgASgCBCgCDBEGAA0AIwBBQGoiAiQAAkACQCAAKAJIQQJ2IgZBAWsiBEUNAEEKIAQgBEEKTxshBQJAA0ACQCAAIAMQkyVFBEBBASEHIAEoAgBB8MOEAUECIAEoAgQoAgwRBgANBSACQQxqIgkgACADEPoiIAkgARDpCyAJENIoDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBSADQQFqIgNHDQALIARBC0kNASAEQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIEIAIgBkEVazYCCCACIAI2AhQgAiACQQhqNgIAIAEoAgAgASgCBCACQQxqEMsKDQELIAZBC2siAyAFIAMgBUsbIgMgBE8NAQNAAkAgACADEJMlRQRAQQEhByABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAkEMaiIFIAAgAxD6IiAFIAEQ6QsgBRDSKA0FIAEoAgBB8sOEAUECIAEoAgQoAgwRBgANBQwBCyABKAIAQfTDhAFBCCABKAIEKAIMEQYADQILIANBAWoiAyAERw0ACwwBC0EBIQcMAQtBACEHCyACQUBrJAAgBw0AIAEoAgBB7NqFAUEBIAEoAgQoAgwRBgAhCAsgCAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQniUPCyAAIAEQuRwPCyAAIAEQuBwLgAQBBn9BASEHAkAgASgCAEG07oUBQQ8gASgCBCgCDBEGAA0AIwBBMGsiAiQAAkACQCAAKAIQIgRFDQBBCiAEIARBCk8bIQYCQANAAkAgACADEJUlRQRAQQEhBSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAiAAIAMQhBo6AAwgAkEMaiABEJovDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgBiADQQFqIgNHDQALIARBC0kNASAEQRVPBEAgAkECNgIQIAJB4MOEATYCDCACQgE3AhggAkE7NgIoIAIgBEEUazYCLCACIAJBJGo2AhQgAiACQSxqNgIkIAEoAgAgASgCBCACQQxqEMsKDQELIARBCmsiAyAGIAMgBksbIgMgBE8NAQNAAkAgACADEJUlRQRAQQEhBSABKAIAQfDDhAFBAiABKAIEKAIMEQYADQUgAiAAIAMQhBo6AAwgAkEMaiABEJovDQUgASgCAEHyw4QBQQIgASgCBCgCDBEGAA0FDAELIAEoAgBB9MOEAUEIIAEoAgQoAgwRBgANAgsgA0EBaiIDIARHDQALDAELQQEhBQwBC0EAIQULIAJBMGokACAFDQAgASgCAEHD7oUBQQEgASgCBCgCDBEGACEHCyAHCzUBAX8gACgCDEEIaigCECAAKAIYQQhqKAIQaiEBIAAoAiQiAAR/IAEgAEEIaigCEGoFIAELCzkBAX8gACgCKCICBEAgACgCJCEAIAJBzAFsIQIDQCAAIAEQhxcgAEHMAWohACACQcwBayICDQALCws7AQF/IwBBEGsiAiQAIAIgADYCDCABQajWhwFBCCAAQQxqQYjWhwEgAkEMakGY1ocBEIMPIAJBEGokAAs/AQF/IAAoAgAhACABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQxRUPCyAAIAEQtRwPCyAAIAEQthwLoAcCBH8DfiACQQdxRQRAIAAgASACQQN2IANBA3YgA0EHcUEAR2oQ5hUPCyAAIQcjAEFAaiIEJABBwAAhBQJAAkACQAJAAkAgA0EDdiIGIANBB3FBAEdqIgBBwP///wNxQUBrIAAgAEE/cRsiAEHAABDRNARAIAAEQCAAQcAAEK02IgVFDQILIAZB+P///wFxIgYgAEsNAiAGBEAgBUEAIAb8CwALIAQgBjYCICAEIAU2AhwgBCAANgIYIARBwAA2AhQgBEEkaiABKAIEIAEoAgggAiADEIcdQQAhAgJ/IARBFGoiASgCDCIAIAEoAggiA0EHakF4cSADayIBSQRAQQAhBUEIDAELIAAgAWsiAEEHcSEFIABBA3YhAiABIgAgA2oLIQEgACAFcgRAQfz1hwFBOEG09ocBEJ8pAAsgBEEIaiIAIAI2AgQgACABNgIAAkAgBCgCDCICRQ0AIAQoAiQhASAEKAIIIQAgAkEDdCEFIAQoAjBBAWohAiAEKAIsIgNBP3GtIQlBACADa0E/ca0hCgNAIAJBAWsiAkUNASABKQAAIQggAwRAIAFBCGoxAAAgCoYgCCAJiIQhCAsgAUEIaiEBIAAgCDcDACAAQQhqIQAgBUEIayIFDQALCyAEKAI0IgVBA3YgBUEHcUEAR2ohAyAEIAUEfiAEKAIkIAQoAjBBA3RqIgYxAAAgBCgCLCIAQT9xrYghCCAAIAVqIgFBA3YgAUEHcUEAR2oiAkECTwRAQQggAGshASACQQFrIQIgBkEBaiEAA0AgADEAACABQT9xrYYgCIQhCCAAQQFqIQAgAUEIaiEBIAJBAWsiAg0ACwsgCEJ/IAVBP3GthkJ/hYMFQgALNwM4IANBCU8NAyAEKAIgIgEgA2oiAiAEKAIYIgBLBEAgBEEUaiAAQQF0IgAgAhDhKiIBIAAgAUsbEOgZIAQoAiAiASADaiECIAQoAhghAAsgBCgCHCEFIAMEQCABIAVqIARBOGogA/wKAAALIAQoAhQhA0EcQQQQrTYiAUUNBCABIAA2AhggASADNgIUIAFBADYCECABIAI2AgwgASAFNgIIIAFCgYCAgBA3AgAgByACNgIIIAcgBTYCBCAHIAE2AgAgBEFAayQADAULQfP6hwFBKSAEQSRqQdj6hwFBnPuHARDVHgALQcAAIAAQoz0AC0Gw9YcBQStB3PWHARCfKQALIANBCEGI/IcBELA7AAtBBEEcEKM9AAsLMgEBfyAAIAEoAgAiAiABKAIERgR+QgAFIAEgAkEIajYCACAAIAIpAwA3AwhCAQs3AwALKAACQCABRSAAIAEQ0TRFcg0AIAAEQCAAIAEQrTYiAUUNAQsgAQ8LAAsxAQJ/IAAtAABFBEBBAA8LIABBAWohAUEAIQADQCAAIAFqIABBAWohAC0AAA0ACyAACy8AIAAoAgAEQCAAEJEgCyAAKAIQBEAgAEEQahChLAsgACgCIARAIABBIGoQoSwLCzcBAX8gACgCCCIBBEAgACgCBCEAA0AgABDXHiAAQQRBzAAQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsLNgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOUnIABBBEEYEOAeIABBDGohACABQQFrIgENAAsLCzcBAn8gACgCACECIAAoAgQiACgCACIBBEAgAiABEQMACyAAKAIEIgEEQCACIAEgACgCCBD4OgsLMAEBfyAAQQhqEN47IAAoAhQiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBFGoQnScLCzcBAX8CQCAAKAIARQ0AIAAoAggiAUUNACABIAEoAgAiAUEBazYCACABQQFHDQAgAEEIahDyJQsLNwEBfwJAIAAoAgBFDQAgACgCBCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQQRqEPIlCwuZHQIhfwF+IwBBEGsiGSQAIBlBCGohGyMAQSBrIg8kACABIgdBtAFqIRwgAUGwAWohDCAPQRRqIR0gASgCsAFFIRoCQAJAA0ACQAJAIBpBAXFFBEBBACEGIwBBIGsiASQAAkACQCAMKAIEIgQgDCgCDEYNACAMIARBFGo2AgRBAyEFAkAgBCgCACIDQYCAgIB4aw4CAQIACyABQRhqIARBDGopAgA3AgAgASADNgIMIAEgBCkCBDcCECABQQxqENgkIQZBACEFDAELQQIhBQsgDyAGNgIEIA8gBTYCACABQSBqJAAgDygCACIBQQJHBEAgAUEDRg0GIA8oAgQhDAwGCyAMKAIABEAgDBDlIAsgDEEANgIADAELIA9BDGohFEEAIR4jAEEgayILJAAgC0EIaiEYIwBBkANrIgokACAHQZABaiEIIAdBgAFqIQ4DQAJAIAcoAqgBIAcoApQBIgEEfyAIKAIAKAIIQQhqIQQDQCABKALAASAERg0ACyABKALIAQVBAAsgBygCpAFqTQ0AIwBB8AJrIg0kAAJAIActAHhFBEAgDUG4AWohECMAQZAEayIDJAACQAJAAkACQAJAAkAgBygCbCIBIAcoAnRGBEBCAyEkDAELIAcgAUEEajYCbCABKAIAIRUgAwJ+IAcoAgBBAUYEQCADQegCaiAHQRBqEN0gIAcoAhwiASABKAIAIgRBAWo2AgAgBEEASA0DIANBIGogA0HwAmooAgA2AgAgAyADKQLoAjcDGCADIAE2AiQgAyAHKQMINwMQQgEMAQsgAyAHKAIQEPQ6NgIYIAMgBykDGDcDICADIAcpAwg3AxBCAAs3AwggBygCWCIEIAQoAgAiAUEBajYCACABQQBIDQEgBygCXCIFIAUoAgAiAUEBajYCACABQQBIDQEgBygCYCIBBEAgASABKAIAIgZBAWo2AgAgBkEASA0CCyADIAE2AqwCIAMgBTYCqAIgAyAENgKkAiAHKAIkIRIgBygCICEfAkAgBygCQEGAgICAeEcEQCADQagBaiAHQUBrEIkdDAELIANBgICAgHg2AqgBCyAHKAI0ISAgBygCMCEhIAcoAiwhIiAHKAIoISMCQCAHKAJMQYCAgIB4RwRAIwBBEGsiCSQAIAdBzABqIgEoAgQhESAJQQRqIAEoAggiFkEAQQRBDBCgGCAJKAIIIQUgCSgCBEEBRwRAIANB6AJqIRMgCSgCDCEGAkAgBUUNACAWQQxsIRcgBiEBIAUhBANAIBdFDQEgCUEEaiAREN0gIAFBCGogCUEMaigCADYCACABIAkpAgQ3AgAgAUEMaiEBIBdBDGshFyARQQxqIREgBEEBayIEDQALCyATIBY2AgggEyAGNgIEIBMgBTYCACAJQRBqJAAMAgsgBSAJKAIMQeiZzwAQ/S8ACyADQYCAgIB4NgLoAgsgA0HYAmogA0GwAWoiBCgCADYCACADQeQCaiADQfACaigCADYCACADIBI2ArQCIAMgHzYCsAIgAyADKQKoATcC0AIgAyAgNgLEAiADICE2AsACIAMgIjYCvAIgAyAjNgK4AiADIAMpAugCNwLcAiADIAcpAzg3AsgCIANB6AJqIgEgA0EIaiIFIANBpAJqIANBsAJqEPATIAMpA+gCQgJRDQIgBSABQfgA/AoAAEEEQQQQrTYiAUUNAyABIBU2AgAgBCADQRBqKQMANwMAIANBuAFqIANBGGopAwA3AwAgA0HAAWogA0EgaikDADcDACADQewBaiADQcwAaigCADYCACADIAMpAwg3A6gBIAMgAykDaDcDiAIgAyADKQNwNwOQAiADQQE2AuABIAMgATYC3AEgA0EBNgLYASADIAMpAkQ3AuQBIANB+AFqIANB2ABqKAIANgIAIANBhAJqIANB5ABqKAIANgIAIAMgAykDUDcD8AEgAyADKQJcNwL8ASADIAMpAyg3A8gBIAMgAykDMDcD0AEgAyADKQN4NwOYAiADQThqEJcwIAMoAtACQYCAgIB4RwRAIANB0AJqEOk7CyADKALcAkGAgICAeEcEQCADQdwCaiIBENErIAEQ6DsLIAMoAqQCIgEgASgCACIBQQFrNgIAIAFBAUYEQCADQaQCahCXFQsgAygCqAIiASABKAIAIgFBAWs2AgAgAUEBRgRAIANBqAJqEPgjCwJAIAMoAqwCIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIANBrAJqENseCyADQegCaiADQagBahDKBSADKQPoAiIkQgNRDQQgA0EIaiADQfACakGgAfwKAAALIBAgJDcDACAQQQhqIANBCGpBoAH8CgAAIBBBADYCsAEgEEKAgICAwAA3A6gBIANBkARqJAAMBAsACyADQRBqIANB+AJqKQMANwMAIAMgAykD8AI3AwhBvJrDAEErIANBCGpB6JrDAEG8n8MAENUeAAtBBEEEEKM9AAsgA0EYaiADQYADaikDADcDACADQRBqIANB+AJqKQMANwMAIAMgAykD8AI3AwhBvJrDAEErIANBCGpBrJrDAEHMn8MAENUeAAsgDSkDuAEiJEIEUQRAIApCBDcDAAwCCyANQQhqIA1BwAFqQbAB/AoAACAkQgNRBEAgB0EBOgB4CyAKICQ3AwAgCkEIaiANQQhqQbAB/AoAAAwBCyAKQgM3AwALIA1B8AJqJAAgCikDAEIDfUICVA0AIApB0AFqIgQgCkG4AfwKAAAgDiAOKQMAIiRCAXw3AwAgCiAkNwOIAyAIKAIAKAIIIQYgCBCNJCEDAkBB4AFBCBCtNiIBBEAgAUKBgICAEDcDACABQQhqIgUgBEHAAfwKAAAgAUEBOwHcASABIAM2AtgBIAFBADYC1AEgAUIANwLMASABIAZBCGo2AsgBIAhBADoACCAIKAIEIQQgCCAFNgIEAkAgBEUEQCABQQA2AsgBIAFBATYC0AEMAQsgCCgCACgCCEEIaiEGA0AgBCgCwAEgBkYNAAsgBCgCyAEhBiABIAQ2AsgBIAEgBkEBajYC0AEgBCAFNgLEAQsgAUEANgLUASAIKAIAIgEoAhggASAFNgIYIAU2AswBDAELQQhB4AEQoz0ACwwBCwsgCkG4AWohCSMAQeAAayIFJAAgDkEcaiEXAkACQCAOKAIkBEAgDigCICkDGCIkIA4pAwhRDQELIA5BEGohAyAFQSBqQQRyIQ0gBUEEciEQA0BBACEWQQAhE0EAIQEjAEFAaiIGJAAgAygCBCIEBEAgAygCACgCCEEIaiEIA0AgBCgCwAEgCEYNAAsgBCgCyAEhFgsgAygCACIEQQxqIAIoAgAiERCLFANAAkAgBkEIaiAEQQhqEM8ZAkACQAJAAkAgBigCCCIEBEAgBEECaw0BIBEoAgQgESgCACgCCBEDACAFQQo2AgAMAwsCQCAGKAIMIggpAwBCA1IEQCADIAgQih0iBC0A3AEgBEEAOgDcAQ0BQZuAwwBBFkG0gMMAEJ8pAAsgBiAIQQhrIgQ2AiggBCAEKAIAIgRBAWs2AgAgBEEBRw0EIAZBKGoQth8MBAsgBEEAOgDdASAGIARBCGoiFTYCFCAGQdiAwwA2AhAgBkEANgIgIAYgBkEQaiISNgIcIAYgEjYCGCAIKQO4ASEkIAZBKGogCCAGQRhqEOQRIAYoAigiCEEJRw0BIAMoAgQhCCADIBU2AgQgEyAELQDdAUEAR2ohEwJAIAhFBEAgBEEANgLIASAEQQE2AtABDAELIAMoAgAoAghBCGohEgNAIAgoAsABIBJGDQALIAgoAsgBIRIgBCAINgLIASAEIBJBAWo2AtABIAggFTYCxAELIBNBAU0EQCABQQFqIgEgFkcNBAsgESgCBCARKAIAKAIIEQMAIAVBCjYCAAwCCyADKAIEBEAgBUEKNgIADAILIAVBCTYCACADQQE6AAgMAQsgBSAGKQIsNwIEIAVBFGogBkE8aigCADYCACAFQQxqIAZBNGopAgA3AgAgBSAkNwMYIAUgCDYCACAEEIckCyAGQUBrJAAMAQsgAygCACEEDAELCwJAAkACQCAFKAIAIgFBCWsOAgEAAgsgCUEKNgIADAQLIAlBCTYCAAwDCyANQRhqIBBBGGooAgA2AgAgDUEQaiAQQRBqKQIANwIAIA0gECkCADcCACANQQhqIBBBCGopAgA3AgAgBSABNgIgIAUpAzgiJCAOKQMIUgRAIBcgBUEgahC5HwwBCwsgCSAFKQMgNwMAIA4gJEIBfDcDCCAJQQhqIAVBKGopAwA3AwAgCUEQaiAFQTBqKQMANwMADAELIA4gJEIBfDcDCCAFQUBrIBcQhBUgCUEQaiAFQdAAaikDADcDACAJQQhqIAVByABqKQMANwMAIAkgBSkDQDcDAAsgBUHgAGokAAJAAkACQAJAIAooArgBQQlrDgICAAELIBhBCjYCAAwCCyAYIAopA7gBNwMAIBhBEGogCkHIAWopAwA3AwAgGEEIaiAKQcABaikDADcDAAwBCyAYQQlBCiAHLQB4GzYCAAsgCkGQA2okAAJAIAsoAggiBUEKRgRAIBRBATYCAAwBCyALKAIUIQYgCygCECEEIAsoAgwhA0EAIQECQAJAAkAgBUEIaw4CAQIACyALIAspAxg3AxggCyAGNgIUIAsgBDYCECALIAM2AgwgCyAFNgIIQZzgwgBBKyALQQhqQejgwgBBhPjCABDVHgALIAQgBkEUbGohHiAEIQELIBQgHjYCECAUIAM2AgwgFCAENgIIIBQgATYCBCAUQQA2AgALIAtBIGokACAPKAIMDQMgDygCECIBRQ0BIAwoAgAEQCAMEOUgCyAMIAE2AgAgHCAdKQIANwIAIBxBCGogHUEIaigCADYCAAsgGkEBcyEaDAELC0ECIQEMAQtBAyEBCyAbIAw2AgQgGyABNgIAIA9BIGokACAZKAIMIQEgACAZKAIINgIAIAAgATYCBCAZQRBqJAALOwEBfyMAQRBrIgIkACACIAAoAgA2AgwgAUG4vcMAQQpBwr3DAEEFIAJBDGpBqL3DABD2GCACQRBqJAALNgAgAEEINgIAIAAgAiABKAIMIgAgACACSxsiAjYCBCABIAAgAms2AgwgASABKAIQIAJqNgIQC5MBAQR/IAAoAgAEQCMAQRBrIgEkACAAKAIMIgQgACgCBCICa0HIAG4hAyACIARHBEADQCACEMkOIAJByABqIQIgA0EBayIDDQALCyABIAAoAgA2AgwgASAAKAIINgIIIAFBCGpBBEHIABDgHiABQRBqJAALIAAoAhAEQCAAQRBqEOcgCyAAKAIgBEAgAEEgahDnIAsLMgEBfwJAIABBP3EiAUUNACAAIAAgAWtBQGsiAE0NAEHYls8AQSNB/JbPABDLJAALIAALnAEBA38gACgCCCIDBEAgACgCBCEBA0ACQCABKAIQRQ0AIAEoAhQiAkUNACABQSBqIAEoAhggASgCHCACKAIQEQEACwJAIAEoAiRFDQAgASgCKCICRQ0AIAFBNGogASgCLCABKAIwIAIoAhARAQALIAFBOGoQhTAgAUHEAGoQhTAgAUHQAGohASADQQFrIgMNAAsLIABBCEHQABDgHgs2AQF/IAAoAggiAQRAIAAoAgQhAANAIAAQwxUgAEEEQRQQ4B4gAEEMaiEAIAFBAWsiAQ0ACwsLNgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOQpIABBBEEYEOAeIABBDGohACABQQFrIgENAAsLCzsAIABCKIkgAEIPiYUgAIVCpb7j9NGMh9mff34iAEIjiCABfCAAhUKlvuP00YyH2Z9/fiIAQhyIIACFCzUAIAAgA0H/AXEiACABIAIQqyEgACACSQRAIAEgAEECdGovAQIaDwsgACACQfzl+wAQwyEACzcAIAAgAEEHdkGAAmogAEGAAkkbIgBB/wNNBEAgAEG07/sAai0AAA8LIABBgARBtPP7ABDDIQALMgEBfwJAIABBP3EiAUUNACAAIAAgAWtBQGsiAE0NAEHMx/4AQSNB8Mf+ABDLJAALIAALHwAgABDeOyAAQQxqEOo7IABBGGoQ6TsgAEEkahDpOwsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQcjA/wBBI0HswP8AEMskAAsgAAs3AQJ/IAAoAgghAiAAKAIMIgAoAgAiAQRAIAIgAREDAAsgACgCBCIBBEAgAiABIAAoAggQ+DoLCzIBAX8CQCAAQT9xIgFFDQAgACAAIAFrQUBrIgBNDQBB3OKAAUEjQYDjgAEQyyQACyAACzIBAX8CQCAAQT9xIgFFDQAgACAAIAFrQUBrIgBNDQBB+OuAAUEjQZzsgAEQyyQACyAACzYBAn8gACgCCCICBEAgACgCBCEBA0AgARDOKiABQRBqIQEgAkEBayICDQALCyAAQQRBEBDgHgsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQbzzgQFBI0Hg84EBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQcixggFBI0HssYIBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQfT5ggFBI0GY+oIBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdj3gwFBI0H894MBEMskAAsgAAs5AQF/IwBBEGsiAiQAIAJBCGogASgCABC5JiACKAIMIQEgACACKAIINgIAIAAgATYCBCACQRBqJAALOQECfyAAKAIEIQEgACgCAEEBRwRAIAEPC0GAgIABIQIgAUGAgIABSQRAIAAgAUEBdCICNgIECyACCzgBAX8gASgCICECIABBBGogAUEkakEAIAEoAiQbEO4lIAAgAkEEdjYCICAAQQA2AhwgACABNgIACzMBAX8gABD7KSAAKAJAQQhqKAIQakHkAGohASAAKAJMIgAEfyABIABBCGooAhBqBSABCwuFAQEEfyAAKAIEIgEgASAAKAIIQQN0aiICRgR/QQAFIAIgAWtBA3YhA0EAIQIDQCABKAIAIAFBBGooAgAiBCgCCEEBa0F4cWpBCGogBCgCUBEEACACaiECIAFBCGohASADQQFrIgMNAAsgAgshASAAKAIcIgAEfyABIABBCGooAhBqBSABCwsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQYiFhwFBI0GshYcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdiKhwFBI0H8iocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQYiYhwFBI0GsmIcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZWehwFBI0G4nocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZSkhwFBI0G4pIcBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQdSuhwFBI0H4rocBEMskAAsgAAsyAQF/AkAgAEE/cSIBRQ0AIAAgACABa0FAayIATQ0AQZj8hwFBI0G8/IcBEMskAAsgAAs4AAJAIAJBgIDEAEYNACAAIAIgASgCEBECAEUNAEEBDwsgA0UEQEEADwsgACADIAQgASgCDBEGAAs5AQF/IwBBIGsiBCQAIAQgASACIANCABCnBiAEKQMAIQEgACAEKQMINwMIIAAgATcDACAEQSBqJAALOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDKFAsLQAEBf0GIASEBAkACQAJAAkAgAC0AgAFBA2sOAgABAwsgAC0AlAFBA0cNAUGMASEBCyAAIAFqELwqCyAAENQcCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOcqCws4AQF/IAAoAgAiAEEQahDUJQJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHIAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOkqCws4AQF/IAAoAgAiAEEQahCbJwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHwAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEOsqCws4AQF/IAAoAgAiAEEQahD/KAJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHQAEEIEPg6Cws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEO0qCws4AQF/IAAoAgAiAEEQahDYEgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHQAkEIEPg6CwswAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkDACACEOYqIAFBEGokALkLMAICfwF+IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQpAxAgAhDqKiABQRBqJAC5CzACAn8BfiMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKQMYIAIQ6iogAUEQaiQAuQtoAgF+A38jAEEQayICJAAgAkEEaiIEIAAQhSMCfkIAIAIoAgQiACgCKCIDRQ0AGiAAKAIkQegBaiEAA0AgACkDACABfCEBIABBwAJqIQAgA0EBayIDDQALIAELIAQQ6iogAkEQaiQAuQsxAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkD4AEgAhDsKiABQRBqJAC5CzECAn8BfiMAQRBrIgEkACABQQRqIgIgABCFIyABKAIEKQPoASACEOwqIAFBEGokALkLMQICfwF+IwBBEGsiASQAIAFBBGoiAiAAEIUjIAEoAgQpA/ABIAIQ7CogAUEQaiQAuQs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQdynwwAgBEEMakHcp8MAIAIgAxDmDwALOAEBfyMAQRBrIgIkACACIAA2AgwgAUHgtcMAQQpB6rXDAEEFIAJBDGpB0LXDABD2GCACQRBqJAALOAEBfyAAQSRqELscAkAgACgCEEUNACAAKAIUIgFFDQAgAEEgaiAAKAIYIAAoAhwgASgCEBEBAAsLOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDqGQsLNgEBfyMAQRBrIgIkACACQQhqIAEQyScgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQACzYBAX8DQCAAKAAAIQMgACABKAAANgAAIAEgAzYAACAAQQRqIQAgAUEEaiEBIAJBAWsiAg0ACws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEMwjCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEIEfCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEIQmCws4AQF/IAAoAgQiASABKAIAQQFrNgIAIAAoAggiASABKAIAQQFrIgE2AgAgAUUEQCAAQQhqEO4mCws2AQF/IAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+CMLIAAQ3iMgAEEEQRQQ4B4LOAEBfyAAKAIEIgEgASgCAEEBazYCACAAKAIIIgEgASgCAEEBayIBNgIAIAFFBEAgAEEIahDWIgsLOwEBf0EIQQQQrTYiAkUEQEEEQQgQoz0ACyAAQcS+zQA2AgggACACNgIEIABBBTYCACACIAEpAgA3AgALJgAgAEEYakEIEO4oIAAQ3jsgAEEMakEEQQgQ4B4gAEHQAGoQ4zwLNgEBfyMAQRBrIgIkACACQQhqIAEQnSUgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQACy8BAX8gACgCCEGAgICAeEcEfyAAKAIQIAAtABQiAEEDdiAAQQdxQQBHamoFIAELCzIBAX8gACgCACIBBEAgASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQhR0LIABBCGoQkycLCzkBAX8jAEEQayIEJAAgBCABNgIMIAQgADYCCEEAIARBCGpBhOfPACAEQQxqQYTnzwAgAiADEOYPAAs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQZTnzwAgBEEMakGU588AIAIgAxDmDwALMgAgAUGkAmoQhTAgAUGsAmogAkEIaigCADYCACABIAIpAgA3AqQCIAAgAUHAAvwKAAALMgAgAUGwAmoQhTAgAUG4AmogAkEIaigCADYCACABIAIpAgA3ArACIAAgAUHAAvwKAAALMwEBfyAAKAIEIgEEQCAAKAIAIAFBARD4OgsgACgCDCIBBEAgACgCCCABQQJ0QQQQ+DoLCzMBAX8gACgCFCIBBEAgACgCECABQQEQ+DoLIAAoAhwiAQRAIAAoAhggAUEBdEECEPg6Cws5AQF/IAAoAqgCQQFGBEAgACgCxAQgACgC+BJrDwsgACgC0BIgACgCzBJrIgEEfyABBSAAKALEBAsLPAEBfyMAQRBrIgMkACADQeDx0QA2AgwgAyAANgIIQQEgA0EIakGYnuIAIANBDGpBmJ7iACABIAIQ5g8ACzwBAX8jAEEQayIDJAAgA0G8vfsANgIMIAMgADYCCEEAIANBCGpBjLz7ACADQQxqQYy8+wAgASACEOYPAAs6AgF/AX4jAEEQayIBJAAgARCHNyABKQMAIQIgACABKAIINgIIIAAgAjcDACAAQQA2AhAgAUEQaiQACzUAIAAgAUEs/AoAAAJAAkAgAS0ALEEBaw4FAAAAAAABCyABKAIwIgBFDQAgAEEYQQgQ+DoLCzgBAX8jAEEQayICJAAgAiAANgIMIAFB18H7AEENQdTB+wBBAyACQQxqQcTB+wAQ9hggAkEQaiQAC6ECAQV/AkAgAEUNACAAKAIgRQ0AIAAoAiRFDQAgACgCHEUNACMAQRBrIgMkACADQgA3AgggA0IBNwIAIAAoAhwhBANAIAEgA2oiAigCACEFIAIgASAEakEIaiICKAIANgIAIAIgBTYCACABQQRqIgFBEEcNAAsCQCADKAIEIgJBQGpBQUkEQCAAQSBqIQEgAkHBAE8EQCABIAMoAgAgAhCNGQsgAEEANgIcIwBBMGsiACQAIABBATYCDCAAIAQ2AggCQCAERQ0AIAEoAgQiAkGcC0cEQCABKAIIIARBBGsoAAAgAhEAAAwBCyAAQYDxADYCECAAQRBqIAQQ6SQLIABBMGokACADQRBqJAAMAQtB+O/8AEHKAEHE8PwAEJ8pAAsLCzUBAX8gABCmDCAAQQxqEPYkIAAoAjwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBPGoQuyMLC54BAgJ/An4gACgCACAAKAIEIgEoAghBAWtBeHFqQQhqIQIjAEEgayIAJAAgAEEIaiACIAEoAhARAAAgAEEQaiAAKAIIIgEgACgCDCgCDBEAACAAKQMYIQMgACkDECEEIABBIGokACABQQAgBEKGspjZnam3pm6FIANC3a+72du2z9ZmhYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAufAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARC/Ou54rzv+NByhSADQtrjn43Mj+GBqX+FhFAbIgBFBEBB4OGAAUEQQfDhgAEQyyQACyAAC58BAgJ/An4gACgCACAAKAIEIgEoAghBAWtBeHFqQQhqIQIjAEEgayIAJAAgAEEIaiACIAEoAhARAAAgAEEQaiAAKAIIIgEgACgCDCgCDBEAACAAKQMYIQMgACkDECEEIABBIGokACABQQAgBELyyPrD9OmMmPMAhSADQvC4kO3DhNv9ToWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALnwECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQtrOgMmrxer9xwCFIANCm/Tdt5mL044/hYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAueAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARCpJvx8abpgqoQhSADQs272sTrx8SCGIWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALoAECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQsbMuueM6qCFvH+FIANCutKR74r29PjMAIWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALnwECAn8CfiAAKAIAIAAoAgQiASgCCEEBa0F4cWpBCGohAiMAQSBrIgAkACAAQQhqIAIgASgCEBEAACAAQRBqIAAoAggiASAAKAIMKAIMEQAAIAApAxghAyAAKQMQIQQgAEEgaiQAIAFBACAEQvz2+K7xiNShFYUgA0LvytP9o9G+0fAAhYRQGyIARQRAQeDhgAFBEEHw4YABEMskAAsgAAueAQICfwJ+IAAoAgAgACgCBCIBKAIIQQFrQXhxakEIaiECIwBBIGsiACQAIABBCGogAiABKAIQEQAAIABBEGogACgCCCIBIAAoAgwoAgwRAAAgACkDGCEDIAApAxAhBCAAQSBqJAAgAUEAIARCk5Pu9eiogpZnhSADQpiS4em4iOKWaYWEUBsiAEUEQEHg4YABQRBB8OGAARDLJAALIAALNQEBfyAAELQMIABBDGoQ/iQgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELYMIABBDGoQgSUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELcMIABBDGoQgiUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAELkMIABBDGoQgyUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQEBfyAAEL4MIABBDGoQhCUgACgCPCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEE8ahC7IwsLNQECfyMAQdAAayIDJAAgA0EMaiIEIAEgAhCvASADIAQQoAEgACADKQMANwMAIANB0ABqJAALMgAgACgCDEEIaigCECAAKAIgIAAoAiQiACgCCEEBa0F4cWpBCGogACgCVBEEAGpBKGoLOQEBfyMAQRBrIgQkACAEIAE2AgwgBCAANgIIQQAgBEEIakH8uocBIARBDGpB/LqHASACIAMQ5g8ACy8AIAFBKGoQzwwgAUEwaiACQQhqKAIANgIAIAEgAikCADcCKCAAIAFByAD8CgAACz0BAX5BACABKAIAEQQAIgFFBEBB7OyHARCYJwALIAAgASkDCDcDCCAAIAEpAwAiAjcDACABIAJCAXw3AwALNgAgACABKQAANwAAIAAgASkAEDcAECAAQQhqIAFBCGopAAA3AAAgAEEYaiABQRhqKQAANwAACzYAIAEoAgBBgICAgHhHBEAgACABKQIANwIAIABBCGogAUEIaigCADYCAA8LIAAgASgCBBDpHQs5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQbSmiAEgBEEMakG0pogBIAIgAxDmDwALMAACQCAAKAIARQ0AIABBCGoQrDsEQCAAELwqCyAAQRRqEKw7RQ0AIABBDGoQvCoLCzcBAX8gACgCACIAQQxqEOInAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQSBBBBD4OgsLegECfyMAQRBrIgMkACADIAE2AgwjAEEQayICJAAgAkEEaiADQQxqEJIfIAIoAgRBgICAgHhGBEBBoq2IAUExEJc9AAsgACACKQIENwIAIABBCGogAkEMaigCADYCACACQRBqJAAgAUGEAU8EQCABEPIfCyADQRBqJAALMgEBfyMAQRBrIgIkACACQQhqIAAgACgCCBDqDCABIAIoAgggAigCDBD7KCACQRBqJAALOQEBfyMAQRBrIgQkACAEIAE2AgwgBCAANgIIQQAgBEEIakGAqIkBIARBDGpBgKiJASACIAMQ5g8ACzkBAX8jAEEQayIEJAAgBCABNgIMIAQgADYCCEEAIARBCGpB7O+JASAEQQxqQezviQEgAiADEOYPAAs5AQF/IwBBEGsiBSQAIAUgAjYCDCAFIAE2AgggACAFQQhqQfzviQEgBUEMakH874kBIAMgBBDmDwALLQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOk7IABBDGohACABQQFrIgENAAsLCzIBAX8gACgCCCIBBEAgACgCBCEAA0AgABCGKSAAEOg7IABBDGohACABQQFrIgENAAsLCzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEPwoDwsgACABENMcDwsgACABENIcCy0BAn8jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCgCMCACEOYqIAFBEGokAAswAgJ/AX4jAEEQayIBJAAgAUEEaiICIAAQhSMgASgCBCkD2AEgAhDsKiABQRBqJAALLQECfyMAQaABayIAJAAgAEEIahDVEyAAQQA2AgAgABDRKUEIaiAAQaABaiQACzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEL8QDwsgACABELccDwsgACABELQcCy8BAX8jAEEQayICJAAgAARAIAIgATYCDCACIAA2AgggAkEIahC8KgsgAkEQaiQACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFB5PPDAEEKIAJBDGpB1PPDABDQEyACQRBqJAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQzCQPCyAAIAEQ0xwPCyAAIAEQ0hwLMwEBfyAAQQg2AgAgACACIAEoAhAgASgCFCIAayIDIAIgA0kbIgI2AgQgASAAIAJqNgIUCzgBAX8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEOMoDwsgACABELkcDwsgACABELgcC/4BAgR/An4gABDzLS0AAEEaRgRAIwBBIGsiASQAIAFBCGogACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAAoAhARAAAgAUEQaiABKAIIIgAgASgCDCgCDBEAACABKQMYIQUgASkDECEGIAFBIGokACAAQQAgBkKrmJHxlfrV/IB/hSAFQpaU+Kvwsemz4QCFhFAbIgBFBEBBpN7QAEERQbje0AAQyyQACyAAENI8IAAoAiAiAUEQTwRAIAAoAhwhACABQQR2IQEDQCACIAAoAgAiBEEAIARBDEsbaiECIABBEGohACABQQFrIgENAAsLQQR0IAJqQTxqDwsgABD8LQs0AQF/IwBBEGsiASQAIAEgACgCADYCDCABIAAoAgg2AgggAUEIakEIQRAQ4B4gAUEQaiQACzgAIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHQnM4ANgIIIABCBDcCECAAQQhqQdiczgAQ7ywACzgAIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHQnM4ANgIIIABCBDcCECAAQQhqQfSdzgAQ7ywACzcBAX4gACAANQJQEKoSIAAgADUCWBCqEiAAIAA1AkwQqhIgACAAKQMwIgFCAYYgAUI/h4UQqhILOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQcygzgA2AgggAEIENwIQIABBCGpB1KDOABDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQcygzgA2AgggAEIENwIQIABBCGpBhKHOABDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQaCizgA2AgggAEIENwIQIABBCGpB2KLOABDvLAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQxRUPCyAAIAEQtRwPCyAAIAEQthwLNAEBfyMAQRBrIgIkACACIAAoAgA2AgwgAUHc6dAAQQkgAkEMakHM6dAAENATIAJBEGokAAs0AQF/IwBBEGsiAiQAIAIgACgCADYCDCABQYDq0ABBCSACQQxqQfDp0AAQ0BMgAkEQaiQACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFB5enQAEELIAJBDGpBzOnQABDQEyACQRBqJAALMwAgACABKQMANwMAIAFBCTYCACAAQRBqIAFBEGopAwA3AwAgAEEIaiABQQhqKQMANwMACzMBAX8CQAJAAkAgACgCQEEBaw4CAgABC0EBDwsgACgCHEEBRw0AIAAoAhhBAEchAQsgAQstAQF/IAAgAUEBahCGLCIDIAJ2IgJBAk8EfyAAIAEgAmdBH3NBARDjJQUgAwsLOAEBfyAApyEBIABC/////wtWBH8gAUEBdEEBdUGAgICAfHEgAUH/////A3FyQYCAgIB4cwUgAQsLMQAgACgCHCAAKAIYIAAoAhQgACgCECAAKAIMIAAoAgggACgCBCAAKAIAampqampqagtCACAAQgA3AiwgAEEAOgAoIABBADYCJCAAQYCAgIB4NgIYIABBgICAgHg2AgwgAEGAgICAeDYCACAAQTFqQgA3AAALMAAgAiAETwRAIAQEQCABIAMgBPwKAAALIAAgAyAEEOgHDwsgBCACQYDp/AAQsDsACzQBAX8jAEEQayICJAAgAiAAKAIANgIMIAFBrOX+AEEKIAJBDGpBnOX+ABDQEyACQRBqJAALOAEBfyABKAIIIgJBgICAEHFFBEAgAkGAgIAgcUUEQCAAIAEQwRgPCyAAIAEQtRwPCyAAIAEQthwLMQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAQQFBARDgHiAAQQxqIQAgAUEBayIBDQALCws4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARDUHw8LIAAgARCPFg8LIAAgARCOFgs4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARCeJQ8LIAAgARC5HA8LIAAgARC4HAs4AQF/IAEoAggiAkGAgIAQcUUEQCACQYCAgCBxRQRAIAAgARCcEg8LIAAgARC3HA8LIAAgARC0HAstAQF/IAAoAggiAQRAIAAoAgQhAANAIAAQnTwgAEEMaiEAIAFBAWsiAQ0ACwsLLQEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEOM8IABBDGohACABQQFrIgENAAsLCy0BAX8gACgCCCIBBEAgACgCBCEAA0AgABDeOyAAQQxqIQAgAUEBayIBDQALCwswACAAQQxqEL0sIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJUEQQAakHIAGoLLwEBfyAAENoqIAAoAkBBCGooAhBqIQEgACgCTCIABH8gASAAQQhqKAIQagUgAQsLMgEBfiAAIAEoAhAgAkEDdGoiAkEIaikDACACKQMAIgN9PgIEIAAgASgCHCADp2o2AgALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyphwE2AgggAEIENwIQIABBCGpB9KmHARDvLAALOAAjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeyphwE2AgggAEIENwIQIABBCGpBhKqHARDvLAALLQEBfyMAQRBrIgMkACAAKAIIIAFJBEAgA0EIaiAAIAEgAhCyAwsgA0EQaiQACzQBAX8jAEEQayIBJAAgASAAKAIANgIMIAEgACgCCDYCCCABQQhqQQRBBBDgHiABQRBqJAALWQEBfyMAQRBrIgMkACADIAI2AgwgAyABNgIIIANBCGohASADQQxqIQICQCAAKAIAIgBBAXEEQCAAQX5xIAEoAgAgAigCABC4KAwBCyAAEJQtCyADQRBqJAALVgEBfyMAQRBrIgMkACADIAI2AgwgAyABNgIIIANBCGohASADQQxqIQICQCAAKAIAIgBBAXEEQCAAIAEoAgAgAigCABC4KAwBCyAAEJQtCyADQRBqJAALJwACQCADRSABIAMQ0TRFcg0AIAAgASADIAIQlzUiAEUNACAADwsACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQaiOigE2AgggAUIENwIQIAFBCGogABDvLAALOwEBf0EBIQICQCAAIAEQ0xANACABKAIAQaztiQFBAiABKAIEKAIMEQYADQAgAEEEaiABENMQIQILIAILOgEBfyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBnPiJATYCCCAAQgQ3AhAgAEEIakGk+IkBEO8sAAszAQJ/QYCAxAAhAiAAKAIAIgEgACgCBEcEfyAAIAFBAWo2AgAgACABQQJ0aigCCAUgAgsLNwEBfyMAQSBrIgEkACABQQA2AhggAUEBNgIMIAFBhO2JATYCCCABQgQ3AhAgAUEIaiAAEO8sAAs3AQF/IwBBIGsiASQAIAFBADYCGCABQQE2AgwgAUHsjooBNgIIIAFCBDcCECABQQhqIAAQ7ywACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQZiPigE2AgggAUIENwIQIAFBCGogABDvLAALMgEBfyAAKAIMIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQQxqEPgjCyAAEMMnIAAQ6jsLMQEBfyMAQRBrIgIkACACIAA2AgwgAUHc1sIAQQ8gAkEMakHM1sIAENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQdTswgBBDyACQQxqQcTswgAQ0BMgAkEQaiQACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEHYgMMANgIACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEH4gMMANgIACzIBAX8gAUEIayICIAIoAgAiAkEBajYCACACQQBIBEAACyAAIAE2AgQgAEHogMMANgIACzIBAX8gABCrASAAEPQ7IAAoAgwiASABKAIAIgFBAWs2AgAgAUEBRgRAIABBDGoQ+CMLCzEBAX8jAEEQayICJAAgAiAANgIMIAFB77XDAEEPIAJBDGpB0LXDABDQEyACQRBqJAALLgAgACkDAEICUgRAIABBIGoQhjAgAEEsahCGMCAAQThqEIYwIABBxABqEIYwCwsnAQJ/IwBBEGsiASQAIAFBBGoiAiAAEIcjIAIQ+CogAUEQaiQAQQALLQEBfyAALQAAIABBADoAAARAIAFBhAFPBEAgARDyHwsPC0Hs2sMAQRwQlz0ACzEBAX8jAEEQayICJAAgAiAANgIMIAFBiO3DAEEPIAJBDGpB+OzDABDQEyACQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUG88cMAQREQli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHl8cMAQRIQli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHM9sMAQQ4Qli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUGU+MMAQQ0Qli0gAhDEISAAQRBqJAALLAEBfyMAQRBrIgAkACAAQQhqIgIgAUHc+MMAQREQli0gAhDEISAAQRBqJAALMQEBfyMAQRBrIgIkACACIAA2AgwgAUH0g8QAQQogAkEMakHkg8QAENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQZCExABBDyACQQxqQYCExAAQ0BMgAkEQaiQACzEBAX8jAEEQayICJAAgAiAANgIMIAFBhILOAEEIIAJBDGpB9IHOABDQEyACQRBqJAALLwEBfyAAEJ0sIABB4ABqEJ0sIABBwAFqIgEQ3CUgAUEEQRAQ4B4gAEHQAWoQ3jsLMQEBfyMAQRBrIgIkACACIAA2AgwgAUG0hM4AQREgAkEMakGkhM4AENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQazyzgBBESACQQxqQZzyzgAQ0BMgAkEQaiQACzEBAX8jAEEQayICJAAgAiAANgIMIAFBkJbPAEEIIAJBDGpBgJbPABDQEyACQRBqJAALMgEBfwJAIAAoAgAiAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQRBBBBD4OgsLMgEBfwJAIAAoAgAiAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQQxBBBD4OgsLMgEBfyAAIAAoAgQiAyACajYCBCAAIAAoAgAgAkECdEGw8tAAaigCACABcSADdHI2AgALMgAgAEEAOgAcIAAgACgCCDYCDCAAIAAoAgRBQHE2AhQgACgCJEECTwRAIABBATYCJAsLMgEBfyAAIAAoAgQiAyACajYCBCAAIAAoAgAgAkECdEHgl9EAaigCACABcSADdHI2AgALKAEBfwNAIAEEQCABQQFrIQEgACgCACACaiECIABBBGohAAwBCwsgAgsvAQF/IAAgACgCBCIDIAEgACgCACADdEEAIAJrdkEBdGoiAC0AAGo2AgQgAC0AAQskAQF/QThBBBCtNiIABEAgAEEAQTj8CwAgAA8LQQRBOBCjPQALMQEBfyMAQRBrIgIkACACIAA2AgwgAUG8hv0AQQ8gAkEMakGshv0AENATIAJBEGokAAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQcC4/gBBDyACQQxqQbC4/gAQ0BMgAkEQaiQACy0AAkACQAJAIAAoAgBBAmsOAgABAgsgAEEEahDpOw8LIABBBGpBBEEIEOAeCwuZAgIFfwJ+IwBBEGsiBSQAIAVBADYCBCAFIAEoAgA2AggjAEEQayIBJAACQAJAAkACQAJAIAVBBGoiBCgCACIDQQFrDgIBBAALIAFBBGogAiAEKAIEIgIQ+BEgASgCBCIDDQEMAgsgBCgCCCEDIAFBBGoiBiACIAQoAgQiBxD4ESABKQIIIQggASgCBCEEIAYgAiADEPgRIAEoAgQiAkUgBEVyDQEgASkCCCEJIAAgAzYCICAAIAk3AhggACACNgIUIAAgBzYCECAAIAg3AgggACAENgIEQQEhAwwCCyABKQIIIQggACACNgIQIAAgCDcCCCAAIAM2AgRBACEDDAELQQIhAwsgACADNgIAIAFBEGokACAFQRBqJAALLwAgACgCGEUEQEEADwsgACgCICAAKAIkIgAoAghBAWtBeHFqQQhqIAAoAkwRBAALLwAgACgCDEEIaigCECAAKAIgIAAoAiQiACgCCEEBa0F4cWpBCGogACgCUBEEAGoLMQEBfyAAIAEoAhAgAkECdGoiAigCACIDIAEoAhxqNgIAIAAgAkEEaigCACADazYCBAsxAQF/IwBBEGsiAiQAIAIgADYCDCABQfDihgFBDyACQQxqQeDihgEQ0BMgAkEQaiQACzEBAX8CQCAARQRAQQAhAAwBCyAAKAIAIgAgACgCACIBQQFqNgIAIAFBAE4NAAALIAALawEDfyMAQRBrIgEkACABIABBCGo2AgwgASAAKQIANwIEAkAgAUEEaiICKAIAIgBBf0YNACAAIAAoAgQiA0EBazYCBCADQQFHDQAgAigCBEELakF8cSICRQ0AIAAgAkEEEPg6CyABQRBqJAALMAEBfwJAIAAoAgQgASgCBEcNACAAKAIMIAEoAgxHDQAgACgCECABKAIQRiECCyACCygAIAAgAiABIAMgASADSRsQmSciACABIANrIAAbIgBBAEogAEEASGsLLAEBfyMAQRBrIgAkACAAQQhqIgIgAUGIqokBQQsQli0gAhDEISAAQRBqJAALJgEBf0EBIABBAXJnQR9zIgFBAXYgAUEBcWoiAXQgACABdmpBAXYLNAACQAJAAkACQCAALQAZQQNrDgIAAQMLIABBIGoQoikMAQsgAEEgahDFIQsgAEEAOgAYCws0AAJAAkACQAJAIAAtABFBA2sOAgABAwsgAEEUahCjKQwBCyAAQRhqEMUhCyAAQQA6ABALCy0BAX8jAEEQayIBJAAgASAAEJgfIAEgASkDADcCCCABQQhqEMkmIAFBEGokAAs0AQF/QRBBBBCtNiICRQRAQQRBEBCjPQALIAIgATYCDCACIAA2AgggAkKBgICAEDcCACACCysBAX4gACkDAEIGfSIBQgFYBEAgAadBAUcEQCAAQQhqEJEqCw8LIAAQsR4LMQAgACACNgIgIABBADYCCCAAQQA2AgAgACABKQIANwIQIABBGGogAUEIaikCADcCAAsaACAAQQhqEN47IABBIGoQ3jsgAEFAaxDjPAsnAQF/IABBCBDuKCAAQTBqIgEQ3CUgAUEEQRAQ4B4gAEHIAGoQ4zwLLgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEPASIABBwAJqIQAgAUEBayIBDQALCwslAQF/IAFB4ABqIgMQwhggAyACQdgA/AoAACAAIAFBwAL8CgAACzABAX8jAEEQayIBJAAgASAAKAIANgIMIAEgACgCCDYCCCABQQhqEOk7IAFBEGokAAssACAAQQxqEL0sIAAoAjwgACgCQCIAKAIIQQFrQXhxakEIaiAAKAJQEQQAagsqACAAKAIsBEAgAEEsahDUHgsgAEEMahD5IyAAQRRqENQeIABBIGoQ1B4LLgEBfyAAKAIIIgEEQCAAKAIEIQADQCAAEKUeIABBxABqIQAgAUEBayIBDQALCwsuAQF/IwBBEGsiBSQAIAUgACkCADcCCCAFQQhqIAEgAiADIAQQjRMgBUEQaiQACy4BAX8jAEEQayIFJAAgBSAAKQIANwIIIAVBCGogASACIAMgBBCOEyAFQRBqJAALLgEBfyMAQRBrIgUkACAFIAAoAgA2AgwgBUEMaiABIAIgAyAEENcBIAVBEGokAAspACABBEAgAUECdCEBA0AgACgCABDyHyAAQQRqIQAgAUEEayIBDQALCws4AQF/QQEhASAALQAERQRAIAAoAgAiASgCAEHf8YkBQQEgASgCBCgCDBEGACEBCyAAIAE6AAQgAQvKBAEGfyMAQRBrIgQkACMAQeABayICJAAgAkEQaiAAEPgXAkAgAQRAIAJBIGogARCVGgwBCyACQgI3AyALIAJBuAFqIQEjAEHQAWsiACQAIAJBEGoiAygCDCEGIAMoAgghByADKAIEIQUgACADKAIANgIwIAAgBTYCKCAAIAUgB0EUbGo2AjQgACAFNgIsAkAgAkEgaiIDKQMAQgJSBEAgAEE4aiADQZgB/AoAAAwBCyAAQThqEKISCyAAQRhqIABBKGogBiAAQThqIgUQ0AMgAEEQaiIDIABBJGooAgA2AgAgACAAKQIcNwMIAkAgACgCGCIGQQZHBEAgAEHEAGogAygCADYCACAAIAApAwg3AjwgACAGNgI4IAUQ0xkhAyABQYCAgIB4NgIAIAEgAzYCBAwBCyABIAApAwg3AgAgAUEIaiADKAIANgIACyAAQdABaiQAAn8gAigCuAFBgICAgHhGBEBBASEAIAIoArwBDAELIAJB2AFqIAJBwAFqKAIANgIAIAIgAikCuAE3A9ABIAJBCGogAkHQAWpBjJrDABCQISACIAIoAgggAigCDBC1NiACIAIoAgQ2AswBQQAhACACKAIACyEBIAIgADYCxAEgAiABNgLIAUEAIQMgAkHEAWoiACgCBCEBIAQCfyAAKAIABEBBACEAQQEMAQsgACgCCCEDIAEhAEEAIQFBAAs2AgwgBCABNgIIIAQgAzYCBCAEIAA2AgAgAkHgAWokACAEKAIAIAQoAgQgBCgCCCAEKAIMIARBEGokAAstAAJAAkACQCAALQBEDgQAAgIBAgsgAEE4ahDeOw8LIABBGGoQ3yAgABC9KgsLqQEBA38gACgCACIDQQhqIgFBAToAJCABLQAUIQIgAUEBOgAUAkAgAg0AIAFBADoAFCABKAIMIQIgAUEANgIMIAJFDQAgASgCECACKAIMEQMACyABLQAgIQIgAUEBOgAgAkAgAg0AIAFBADoAICABKAIYIQIgAUEANgIYIAJFDQAgASgCHCACKAIEEQMACyADIAMoAgAiAUEBazYCACABQQFGBEAgABDZIwsLLQEBfyAAKAIAIgFBCGoQsx8gASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQlh8LCy0BAX8gACgCACIBQQhqELMfIAEgASgCACIBQQFrNgIAIAFBAUYEQCAAEO0dCwstAQF/IAAoAgAiAUEIahCTHyABIAEoAgAiAUEBazYCACABQQFGBEAgABDtHQsLqQEBA38gACgCACIDQQhqIgFBAToAKCABLQAYIQIgAUEBOgAYAkAgAg0AIAFBADoAGCABKAIQIQIgAUEANgIQIAJFDQAgASgCFCACKAIMEQMACyABLQAkIQIgAUEBOgAkAkAgAg0AIAFBADoAJCABKAIcIQIgAUEANgIcIAJFDQAgASgCICACKAIEEQMACyADIAMoAgAiAUEBazYCACABQQFGBEAgABDHIQsLLQEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEIUdCyAAQQhqEJMnCzMBAX9BBCEBAkACQAJAIAAoAgBBgICAgHhrDgIBAgALIAAQnTxBDCEBCyAAIAFqEM8vCwszAQF/IAEgACgCACICKAIATQRAIAIgATYCCCAAIAE2AgQPC0H84tAAQSxBqOPQABCfKQALLAECfyAAKAIEIAAoAgBBAnRqIgItAAIgACACLwEAIAEgAi0AAxC1LGo2AgALLQEBfyAAIAAoAgQgAWoiAjYCBCABQQJ0QbDz0ABqKAIAIAAoAgBBACACa3ZxCy0BAX8gACAAKAIEIAFqIgI2AgQgAUECdEGwxdEAaigCACAAKAIAQQAgAmt2cQt8AQN/IwBBEGsiBCQAIARBCGohBUEYQQgQrTYiA0UEQEEIQRgQoz0ACyADIAIpAwA3AwAgA0EQaiACQRBqKQMANwMAIANBCGogAkEIaikDADcDACAFQbTI0QA2AgQgBSADNgIAIAAgASAEKAIIQbTI0QAQySkgBEEQaiQACysBAX8gABCwGiIBQRBJBEAgACABQQJ0aioCABoPCyABQRBBpPXRABDDIQALLAAgAEUEQEMAAADADwsgAEGAAk8EQCAAsxDqEg8LIABBAnRBwIfzAGoqAgALHwAgABDeOyAAQQxqEOk7IAAoAhgEQCAAQRhqEM8vCwsfACAAEN47IABBDGoQ4zwgACgCGARAIABBGGoQzy8LC4UDAQt/IwBBEGsiCSQAIAlBBGohCCMAQSBrIgIkACACQRRqIAEoAgQgASgCAGtBAEEEQQQQoBggAigCGCEEIAIoAhRBAUYEQCAEIAIoAhxBvPyBARD9LwALIAJBEGoiCkEANgIAIAIgAigCHDYCDCACIAQ2AggjAEEQayIEJAAgAkEIaiIFIAEoAgQgASgCAGsQ7i0gBCAFKQIEQiCJNwIIIAQgBUEIajYCBCAEQQRqIgMoAgQhBSADKAIAIQsCQAJAIAEoAgAiBiABKAIEIgdHBEAgASgCCCEMIAcgBmshByADKAIIIAVBAnRqIQEDQCAGLAAAIgNBAEgNAiAMIANBAnRqIgMgAygCACIDQQFqNgIAIAEgAzYCACAGQQFqIQYgAUEEaiEBIAVBAWohBSAHQQFrIgcNAAsLIAsgBTYCAAwBCyADQYABQdy3ggEQwyEACyAEQRBqJAAgCEEIaiAKKAIANgIAIAggAikCCDcCACACQSBqJAAgACAIEOgYIAlBEGokAAspAQF/IAAoAgxBCGooAhAhASAAKAIYIgAEfyABIABBCGooAhBqBSABCwstACABKAIARQRAIAAgASkCBDcCACAAQQhqIAFBDGopAgA3AgAPCyAAQQA2AgALKQEBfyAAKAIAQQhqKAIQIQEgACgCFCIABH8gASAAQQhqKAIQagUgAQsLMQEBfyMAQRBrIgQkACAEQYWAgIB4NgIAIAQgAzYCBCAAIAEgAiAEEKMBIARBEGokAAsyAQF/QQhBBBCtNiIBRQRAQQRBCBCjPQALIAFCgYCAgBA3AgAgAEEANgIEIAAgATYCAAujBAEGfyMAQRBrIgUkACAFIAApAgQ3AgggBUEIaiEDIwBBMGsiACQAAn8CQCABKAIAIgJB5IOIAUECIAEoAgQiBigCDCIEEQYADQAgAygCBCIHBEAgAygCACEDA0AgACADLQAAIgE6AAsCQAJAAkACQAJAAkACQCABQSFNBEAgAUEJaw4FAwEFBQIECyABQSJHIAFB3ABHcQ0EIABBATYCFCAAQfCDiAE2AhAgAEIBNwIcIABB7xs2AiwgACABNgIMIAAgAEEoajYCGCAAIABBDGo2AihBASACIAYgAEEQahDLCg0KGgwGCyACQeeDiAFBAiAEEQYADQgMBQsgAkHpg4gBQQIgBBEGAA0HDAQLIAJB64OIAUECIAQRBgANBgwDCyABRQ0BCyABQSBrQf8BcUHfAE8EQCAAQQE2AiQgAEGEhIgBNgIgIABBATYCFCAAQfyDiAE2AhAgAEEBNgIcIABBqh02AiwgACAAQShqNgIYIAAgAEELajYCKEEBIAIgBiAAQRBqEMsKDQYaDAILIABBATYCFCAAQZyEiAE2AhAgAEIBNwIcIABB7xs2AiwgACABNgIMIAAgAEEoajYCGCAAIABBDGo2AihBASACIAYgAEEQahDLCg0FGgwBCyACQfiDiAFBAiAEEQYADQMLIANBAWohAyAHQQFrIgcNAAsLIAJB5oOIAUEBIAQRBgAMAQtBAQsgAEEwaiQAIAVBEGokAAstAQF/IAAgACgCECIBQQFrNgIQIAFBAUYEQCAAQQFBARDgHiAAQRRBBBD4OgsLMAEBfyABQQhrIgIgAigCAEEBaiICNgIAIAJFBEAACyAAIAE2AgQgAEHYqogBNgIACygBAX8jAEEQayICJAAgAiAAKAIANgIMIAJBDGogARDTECACQRBqJAALMQAgACABKAIAIAIgAyABKAIEKAIMEQYAOgAIIAAgATYCBCAAIANFOgAJIABBADYCAAujHQIWfwN+IwBBEGsiDiQAIwBBQGoiCCQAIAhBCGogACABEPooIAhBFGoiACAIKAIIIAgoAgwQjzUgCEEgaiENIAJBAEchASMAQbABayIEJAACQCAAKAIIRQRAQeCYwwBBKRCUPiEDIA1BgICAgHg2AgAgDSADNgIEIAFFIAJBhAFJckUEQCACEPIfCyAAEN47DAELIARBOGogAEEIaigCADYCACAEIAApAgA3AzACfwJAIAFFDQAgBEH4AGogAhDHBwJAAkAgBCgCeCIBQQJrDgIAAgELIAQoAnwQgBghACANQYCAgIB4NgIAIA0gADYCBCAEQTBqEN47DAMLIAQoAnwhACAEQcgAaiAEQYABakEw/AoAACAEIAE2AkAgBEHEAGoMAQsgBEGAgICAeDYCYEEAIQAgBEEANgJAIARBgICAgHg2AmwgBEEANgJQIARBADYCSCAEQdgAagsgADYCACAEQRxqIQYgBEFAayEMIwBB4AFrIgEkACABIARBMGoQ5xUgAUEANgI4IAFBADsBPCABQfgAaiICIAEgAUE4ahDRDiABQeAAaiIAIAFBhAFqIgMoAgA2AgAgASABKQJ8NwNYAkACfwJAIAEoAngiCkEIRwRAIAEpA4gBIRkgAyAAKAIANgIAIAEgASkDWDcCfCABIBk3A4gBIAEgCjYCeCAGQQRqIAIQyCYgBkEBNgIADAELIAFBGGogACgCADYCACABIAEpA1g3AxAgAUH4AGogAUEQaiIDEMUKIAEoAoQBIQIgASgCgAEhCiABKAJ8IQAgASgCeCIFQQZHBEAgBiACNgIQIAYgCjYCDCAGIAA2AgggBiAFNgIEIAZBATYCACADELIfDAELIAFBKGogAUEIaikCADcDACABIAEpAgA3AyAgCiAKKAIAIgNBAWo2AgACQAJAIANBAE4EQCABIAo2AjRBgAghAyAMKAIAQQFGBEAgACgCCCIDIAwoAgQiBSADIAVJGyEDCyAMKAIgIhJBgICAgHhHBEAgDCkCJCEZIAFBwAFqIAFBKGopAwA3AgAgAUGAgICAeDYCrAEgAUGAgICAeDYCoAEgAUGAgICAeDYClAEgAUGAgICAeDYCiAEgAUEANgKAASABQQA2AnggASABKQMgNwK4ASABQoCAgICAgICgBjcC2AEgASADNgLUASABIAI2AtABIAEgCjYCzAEgASAANgLIASABQYgBahCXMAsgDCkCCCEaIAwpAhAhGyABQcABaiABQShqKQMANwIAIAFBgICAgHg2AqwBIAFBgICAgHg2AqABIAFBgICAgHg2ApQBIAEgGTcCjAEgASASNgKIASABIBs3AoABIAEgGjcCeCABIAEpAyA3ArgBIAFCgICAgICAgKAGNwLYASABIAM2AtQBIAEgAjYC0AEgASAKNgLMASABIAA2AsgBIAFB2ABqIQMjAEHwAWsiACQAIAFB+ABqIgIoAlAhCyAAIAIoAlg2AhQgAikCFCEZIAIoAhAhBSAAQSBqIAJBJGooAgA2AgAgACACKQIcNwMYIABBMGogAkEwaigCADYCACAAIAIpAig3AyggAigCACETIAIoAgQhFCACKAIIIRUgAigCDCEWIAAgAigCYDYCOCACKAJcIQkgCygCCCEHAkAgBUGAgICAeEcEQCAAIBk3AkAgACAFNgI8DAELIABBPGogC0EIaigCWEGQ0MMAEIo7CwJAAn8CQAJAQRhBBBCtNiIFBEAgBUKBgICAEDcCACAFIAJBQGsiDykCADcCCCAFQRBqIA9BCGopAgA3AgAgAEHQAGogAEHEAGooAgA2AgAgACALNgJYIAAgBTYCVCAAIAApAjw3A0ggACAHIAkgByAJSRs2AsQBIABBgICAgHg2ArgBIABB4ABqIABBuAFqIgsgAkE0ahDrJwJAIAAoAihBgICAgHhGDQAgACgCMCIJRQ0AIAAoAiwiBSAJQQN0aiEXIAtBBHIhCwNAIABB4ABqEJAjRQ0BAkAgBSgCACAFQQRqIgkoAgAoAgwRBAAiBygCAEGAgICAeEcEQCAAQbgBaiAHEOceDAELIABBgICAgHg2ArgBCyAAQfgAaiAAQcABaigCADYCACAAIAApArgBNwNwIABB8ABqIhAgAEEYahCRFCAAQbDWwwA2ApQBIAAoAhQhByAAQQA2ApwBIAAgAEHIAGo2ApABIAAgAEE4ajYCmAEgAEG4AWogAEGQAWogB0EIakEAIAcbIAUoAgAgCSgCACgCDBEEABCUGCAAKALAASEHIAAoArwBIQ8gACgCuAEiGEEIRwRAIAMgACkCxAE3AhQgA0EcaiAAQcwBaigCADYCACADIAc2AhAgAyAPNgIMIAMgGDYCCCADQYGAgIB4NgIAIBAQhjAMBAsgAEGYAWogAEHoAGoiECkCADcDACAAIAApAmA3A5ABIABBuAFqIABBkAFqIA8gByAFKAIAIAkoAgAQrQYgAEHoAWoiCSALQQhqKQIANwMAIAAgCykCADcD4AEgACgCuAEiB0EIRwRAIAAoAswBIQUgAyAAKQPgATcCDCADIAU2AhwgAyAHNgIIIANBgYCAgHg2AgAgA0EUaiAJKQMANwIAIABB8ABqEIYwDAULIBAgCSkDADcDACAAIAApA+ABNwNgIABB8ABqEIYwIAVBCGoiBSAXRw0ACwsgAEGw1sMANgKUASAAKAIUIQUgAEEANgKcASAAIABByABqNgKQASAAIABBOGo2ApgBIABBuAFqIABBkAFqIAVBCGpBACAFGyAAQRhqEJQYIAAoAsABIQsgACgCvAEhCSAAKAK4ASIFQQhHBEAgAyAAKQLEATcCFCADQRxqIABBzAFqKAIANgIAIAMgCzYCECADIAk2AgwgAyAFNgIIIANBgYCAgHg2AgAMAgsgAEHoAWogAEHoAGopAwA3AwAgACAAKQNgNwPgASAAQQhqIAAoAlhBCGoQhDwgACAAKQMINwLAASAAIAAoAkwiBTYCuAEgACAFIAAoAlBBAnRqNgK8ASAAQbgBaiIFIABB4AFqIAUQ3B8QnCwgAEGoAWogAEHQAWopAwA3AwAgAEGwAWogAEHYAWooAgA2AgAgACAWNgK8ASAAIBU2ArgBIAAgACkDyAE3A6ABIAAgFDYCnAEgACATNgKYASAAIAApA7gBNwOQASAFIABBkAFqEMEFIABB/ABqIgcgBRDvDiADIAkgCyAHEPkUIABByABqEKMlAkAgACgCOCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAAQThqEIEsCyAAQShqEJ4vIABBGGoQhjACQCAAKAIUIgNFDQAgAyADKAIAIgNBAWs2AgAgA0EBRw0AIABBFGoQ2x4LIAIoAlQiAyADKAIAIgNBAWs2AgAgA0EBRw0EIAJB1ABqDAMLQQRBGBCjPQALIABB4ABqEI4wCyAAQcgAahCjJQJAIAAoAjgiA0UNACADIAMoAgAiA0EBazYCACADQQFHDQAgAEE4ahCBLAsgAEEoahCeLyAAQRhqEIYwAkAgACgCFCIDRQ0AIAMgAygCACIDQQFrNgIAIANBAUcNACAAQRRqENseCyACKAJUIgMgAygCACIDQQFrNgIAIANBAUcNASACQdQAagsQ+CMLIABB8AFqJAAgASgCWCIAQYGAgIB4RgRAIAFBzABqIAFB8ABqKQMAIhk3AgAgAUHEAGogAUHoAGopAwAiGjcCACABIAEpA2AiGzcCPCABQYgBaiAZNwMAIAFBgAFqIBo3AwAgASAbNwN4IAZBBGogAhDIJiAGQQE2AgAMAwsgAUHQAGogAUH0AGooAgAiAjYCACABQcgAaiABQewAaikCACIZNwMAIAFBQGsgAUHkAGopAgAiGjcDACABIAEpAlwiGzcDOCABQZQBaiACNgIAIAFBjAFqIBk3AgAgAUGEAWogGjcCACABIBs3AnwgASAANgJ4IAFBADYCQCABQoCAgIDAADcCOCABQdgAaiABQfgAahCHBiABKAJYIgJBAkYNASABQdwAaiEAA0AgAkEBcQRAQRRBBBCtNiICRQRAQQRBFBCjPQALIAZBBGoiAyACNgIEIANBADYCACACIAApAgA3AgAgAkEQaiAAQRBqKAIANgIAIAJBCGogAEEIaikCADcCACAGQQE2AgAgAUH4AGoQ9x8gAUE4aiIAEN4jIAAQ4DsMBAsgASgCQCICIAEoAjhGBEAgAUE4akHg18MAEK8oCyABKAI8IAJBFGxqIgMgACkCADcCACADQQhqIABBCGopAgA3AgAgA0EQaiAAQRBqKAIANgIAIAEgAkEBajYCQCABQdgAaiABQfgAahCHBiABKAJYIgJBAkcNAAsMAQsACyABQfgAahD3HyAGQQxqIAFBQGsoAgA2AgAgBiABKQI4NwIEIAYgCjYCECAGQQA2AgAgAUEQahCyHwwDCyAKIAooAgAiAEEBazYCACAAQQFGBEAgAUE0ahD4IwsgAUEQahCyHyASQYCAgIB4RwwBCyABQQxqIAEoAgQgASgCCCABKAIAKAIQEQEAQQALDQAgDCgCIEGAgICAeEYNACAMQSBqEOk7CyAMQSxqEJgwIAFB4AFqJAAgBEEQaiIAIARBKGopAgA3AwAgBCAEKQIgNwMIIAQoAhxBAUYEQCAEQYABaiAAKQMANwMAIAQgBCkDCDcDeCAEQfgAahDTGSEAIA1BgICAgHg2AgAgDSAANgIEDAELIA0gBCkDCDcCACANQQhqIAApAwA3AgALIARBsAFqJAACfyAIKAIgQYCAgIB4RgRAQQEhESAIKAIkDAELIAhBOGogCEEoaikCADcDACAIIAgpAiA3AzAjAEEgayIAJAAgAEEYaiAIQTBqIgFBCGopAgA3AgAgAEEANgIMIAAgASkCADcCECAAQQxqEJ4nIABBIGokAEEIagshACAOIBEgABCBLSAIQUBrJAAgDigCACAOKAIEIA4oAgggDkEQaiQAC8oCAQZ/IwBBEGsiAiQAIwBBQGoiASQAIAFBEGoiAyAAELIWIwBBEGsiACQAIAMQ8S0hBkEUQQQQrTYiBEUEQEEEQRQQoz0ACyAEIAMpAgA3AgAgBEEQaiADQRBqKAIANgIAIARBCGogA0EIaikCADcCACAAIAY2AgwgAEEBNgIIIAAgBDYCBCAAQQE2AgAgAUEkaiAAENkHIABBEGokACACAn8gASgCJEGAgICAeEYEQEEAIQAgASgCKCEDQQEMAQsgAUE4aiABQSxqKAIANgIAIAEgASkCJDcDMCABQQhqIAFBMGpB0LjMABCQISABIAEoAgggASgCDBC1NkEAIQMgASgCBCEFIAEoAgAhAEEACzYCDCACIAM2AgggAiAFNgIEIAIgADYCACABQUBrJAAgAigCACACKAIEIAIoAgggAigCDCACQRBqJAALxQUCCn8CfiMAQRBrIgQkACMAQTBrIgEkACABQRRqIQMgABDMISEFIwBBwAFrIgAkACAAIAU2AgAgAEEANgIMIABCgICAgBA3AgQgAEG4AWoiAhC9LyAAQfgAaiIGIABBBGogBUEIaiACEKoVAkACQAJAAkAgACgCoAEiB0GAgICAeEYEQCAAQeAAaiAAQYgBaiICKAIAIgc2AgAgAEHYAGogAEGAAWoiCCkDACILNwMAIAAgACkDeCIMNwNQIAIgBzYCACAIIAs3AwAgACAMNwN4IAYQ1BkhAiADQYCAgIB4NgIAIAMgAjYCBAwBCyAAQdAAaiICIABB+ABqIgZBKPwKAAAgAEHMAGogAEG0AWooAgA2AgAgAEHEAGogAEGsAWopAgA3AgAgACAAKQKkATcCPCAAQRBqIgggAkEo/AoAACAAIAc2AjggAiAIEKsVIABBOGohAiAAKAJQIgdBk4CAgHhGDQEgAEGEAWogAEHcAGopAgA3AgAgACAAKQJUNwJ8IAAgBzYCeCAGENQZIQYgA0GAgICAeDYCACADIAY2AgQgAEEYahDtJiACEOM8CyAAQQRqEN47IAUgBSgCACIDQQFrNgIAIANBAUYNAQwCCyAAQRhqEO0mIAIQ4zwgA0EIaiAAQQxqKAIANgIAIAMgACkCBDcCACAFIAUoAgAiA0EBazYCACADQQFHDQELIAAQ+CMLIABBwAFqJAAgBAJ/IAEoAhRBgICAgHhGBEBBACEAIAEoAhghCUEBDAELIAFBKGogAUEcaigCADYCACABIAEpAhQ3AyAgAUEIaiABQSBqQYDHzAAQkCEgASABKAIIIAEoAgwQtTYgASgCBCEKIAEoAgAhAEEACzYCDCAEIAk2AgggBCAKNgIEIAQgADYCACABQTBqJAAgBCgCACAEKAIEIAQoAgggBCgCDCAEQRBqJAALlwcBDH8jAEEQayIJJAAjAEEgayIEJAAgBEEUaiAAENEkIAQoAhQgBEEIaiABIAIQ+iggBCgCCCINIQEgBCgCDCEAIwBBMGsiBSQAIAVBCGohDCgCAEEIaiEHIwBB4ABrIgIkACACIAA2AhQgAiABNgIQIAcoAgRBAnQhAyAHKAIAQQhqIQZBfyEIIAJBCGoiCgJ/A0BBACADRQ0BGiADQQRrIQMgCEEBaiEIIAYoAgAhCyAGQQRqIQYgCygCQCALKAJEIAEgABDBLkUNAAsgBkEEaws2AgQgCiAINgIAAn8gAigCDEUEQCAHKAIAQQhqIgYgBygCBEECdGohCiMAQSBrIgEkACABQRRqIAogBmtBAnZBAEEEQQQQoBggASgCGCEDIAEoAhRBAUYEQCADIAEoAhxB+NyHARD9LwALIAFBEGoiDkEANgIAIAEgASgCHDYCDCABIAM2AgggCiAGa0ECdiIIIAFBCGoiBygCACAHKAIIIgNrSwRAIAcgAyAIQQRBBBDcKCAHKAIIIQMLIAJBLGohCyAHIAYgCkcEfyADIAhqIAcoAgQgA0ECdGohAwNAIAMgBigCAEE8ajYCACAGQQRqIQYgA0EEaiEDIAhBAWsiCA0ACwUgAws2AgggC0EIaiAOKAIANgIAIAsgASkCCDcCACABQSBqJAAgAkECNgI8IAJBxN2HATYCOCACQgI3AkQgAkGDHTYCXCACQccCNgJUIAIgAkHQAGo2AkAgAiALNgJYIAIgAkEQajYCUCACQRxqIAJBOGoQmQ4gC0EEQQQQ4B4gAigCHCEBIAIoAiAhAyAMIAIpAiQ3AgwgDCADNgIIQYWAgIB4DAELIAIoAgghAUGTgICAeAshAyAMIAE2AgQgDCADNgIAIAJB4ABqJAAgBSgCDCECAn8gBSgCCCIBQZOAgIB4RwRAIAVBLGogBUEYaigCADYCACAFIAUpAhA3AiQgBSACNgIgIAUgATYCHCAFQRxqENQZIQJBAQwBC0EACyEBIAQgAjYCBCAEIAE2AgAgBUEwaiQAIAQoAgQhASAEKAIAIQIgAARAIA0gAEEBEPg6CyAEKAIYQQA2AgAgBCgCHCIAIAAoAgBBAWsiADYCACAARQRAIARBHGoQhCYLIAkgAjYCCCAJIAFBACACQQFxIgAbNgIEIAlBACABIAAbNgIAIARBIGokACAJKAIAIAkoAgQgCSgCCCAJQRBqJAAL2AEBBH8jAEEQayICJAAjAEFAaiIBJAAgAUEUaiIDIAAQ+BcgAUEkaiADENkHIAICfyABKAIkQYCAgIB4RgRAQQAhACABKAIoIQNBAQwBCyABQThqIAFBLGooAgA2AgAgASABKQIkNwMwIAFBCGogAUEwakGk0MwAEJAhIAEgASgCCCABKAIMELU2QQAhAyABKAIEIQQgASgCACEAQQALNgIMIAIgAzYCCCACIAQ2AgQgAiAANgIAIAFBQGskACACKAIAIAIoAgQgAigCCCACKAIMIAJBEGokAAslACAAQeAAahDeOyAAQewAahCHMCAAQUBrEPgmIABB+ABqEI4wCzUBAn8jAEEQayIAJAAgABCvPiIBNgIMIABBDGooAgAlAUQAAAAAAAAAABAdIABBEGokACABCyUBAn8jAEEgayIBJAAgAUEMaiICIAAQgBwgAhCSICABQSBqJAALJgEBfyMAQRBrIgEkACABQYEBNgIMIAAgAUEMahCiNiABQRBqJAALKQAgAEEINgIAIAAgAiABKAIMIgAgACACSxsiAjYCBCABIAAgAms2AgwLGgAgAEEIEO4oIABBMGoQ3jsgAEHIAGoQ4zwLGgAgAEEIEO4oIABBMGoQ6TsgAEHIAGoQ4zwLGgAgAEEIEO4oIABBMGoQ4zwgAEHIAGoQ4zwLMAACQAJAAkAgACgC0AFBAWsOAgABAgsgACABQQBBABDxDQ8LIAAgAUEAQQAQywsLCyQAIAEgA0YEQCABBEAgACACIAH8CgAACw8LIAEgAyAEELM7AAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4xUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4BUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4RUgAkHQAGokAAspAQJ/IwBB0ABrIgIkACACQQhqIgMgARDBGSAAIAMQ4hUgAkHQAGokAAsnAQJ/IwBBMGsiAiQAIAJBCGoiAyABEJMXIAAgAxD7DCACQTBqJAALJwECfyMAQTBrIgIkACACQQhqIgMgARCTFyAAIAMQ/AwgAkEwaiQACycBAn8jAEEwayICJAAgAkEIaiIDIAEQkxcgACADEPoMIAJBMGokAAstACAAQRA2AgAgACABKAIENgIIIAAgASgCCEEEdDYCDCAAIAEoAgBBBHQ2AgQLLQAgAEEINgIAIAAgASgCBDYCCCAAIAEoAghBA3Q2AgwgACABKAIAQQN0NgIECy0AIABBAjYCACAAIAEoAgQ2AgggACABKAIIQQF0NgIMIAAgASgCAEEBdDYCBAstACAAQQQ2AgAgACABKAIENgIIIAAgASgCCEECdDYCDCAAIAEoAgBBAnQ2AgQLJwECfyMAQUBqIgIkACACQQRqIgMgARCjFCAAIAMQ5xIgAkFAayQACycBAn8jAEFAaiICJAAgAkEEaiIDIAEQpBQgACADEOgSIAJBQGskAAsnAQJ/IwBBQGoiAiQAIAJBCGoiAyABEOcTIAAgAxDrDyACQUBrJAALJwECfyMAQUBqIgIkACACQQhqIgMgARDnEyAAIAMQ7A8gAkFAayQACyoAIAAoAgAiACgCACAAKAIEIgAoAghBAWtBeHFqQQhqIAEgACgCDBECAAsnAQJ/IwBBQGoiAiQAIAJBBGoiAyABELUUIAAgAxCYFCACQUBrJAALJwECfyMAQUBqIgIkACACQQRqIgMgARCyFCAAIAMQmBQgAkFAayQACycBAn8jAEFAaiICJAAgAkEEaiIDIAEQsxQgACADEJkUIAJBQGskAAsnAQJ/IwBBQGoiAiQAIAJBBGoiAyABELQUIAAgAxCZFCACQUBrJAALKQECfyMAQeAAayICJAAgAkEEaiIDIAEQ2QEgACADEM0cIAJB4ABqJAALJAEBfyAAIAEgAiADIAQQ9QYEfyAAIAEgAiADIAQQ3gcFIAULCywAIABCADcDKCAAQgA3AyAgAEIANwMYIABCADcDCCAAQgE3AwAgAEICNwMQC1EBAX8jAEEQayIDJAAgAyACNgIMIAMgATYCCCADIAA2AgQjAEEQayIAJAAgACADQQRqIgEpAgA3AgggAEEIakG0tokBIAEoAghBAUEAEPMXAAsnACAAIAEgACgCBEEBcXJBAnI2AgQgACABaiIAIAAoAgRBAXI2AgQL/AECAn8BfiMAQRBrIgIkACACQQE7AQwgAiABNgIIIAIgADYCBCMAQRBrIgEkACACQQRqIgApAgAhBCABIAA2AgwgASAENwIEIwBBEGsiACQAIAFBBGoiASgCACICKAIMIQMCQAJAAkACQCACKAIEDgIAAQILIAMNAUEBIQJBACEDDAILIAMNACACKAIAIgIoAgQhAyACKAIAIQIMAQsgAEGAgICAeDYCACAAIAE2AgwgAEGYtokBIAEoAgQgASgCCCIALQAIIAAtAAkQ8xcACyAAIAM2AgQgACACNgIAIABB/LWJASABKAIEIAEoAggiAC0ACCAALQAJEPMXAAvECQIOfwF+IwBBEGsiCSQAEN8SIgMgASYBIwBB0ANrIgYkACAGIAAQlRogBkGYAWohCyMAQeABayIEJAAgBEEoaiEFIwBBMGsiAiQAIAIgAyIANgIMAkAgAkEMahDPLEUEQCACQRBqIAAQngYgBQJ/IAIoAhBFBEAgBSACKAIUNgIEQQEMAQsgBSACKQMQNwMIIAVBIGogAkEoaikDADcDACAFQRhqIAJBIGopAwA3AwAgBUEQaiACQRhqKQMANwMAQQALNgIADAELIAVBADYCACAFQQA2AgggAEGEAUkNACAAEPIfCyACQTBqJAACQCAEKAIoQQFGBEAgBCgCLBCAGCEAIAtCAjcDACALIAA2AgggBhDMLAwBCyAEQQhqIgAgBEE8aikCADcDACAEQRBqIgMgBEHEAGopAgA3AwAgBEEYaiICIARBzABqKAIANgIAIAQgBCkCNDcDAAJAIAQoAjAiBQRAIARBzAFqIAApAwA3AgAgBEHUAWogAykDADcCACAEQdwBaiACKAIANgIAIAQgBTYCwAEgBCAEKQMANwLEASAEQShqIgMgBEHAAWoiDBD4KCAEQRxqIQUjAEFAaiIAJAAgACADEN0oAkACQAJAAkAgACgCACICRQ0AIAAoAgQhByAAQSBqIgogAhDdICAAQRRqIAcQ3SAgACgCICIIQYCAgIB4Rg0AIAApAiQhECAKQQQgAygCGEEBaiICQX8gAhsiAiACQQRNG0EAQQRBGBCgGCAAKAIkIQcgACgCIEEBRg0CIAAoAigiAiAQNwIEIAIgCDYCACACIAApAhQ3AgwgAkEUaiAAQRxqKAIANgIAIABBEGoiDUEBNgIAIAAgAjYCDCAAIAc2AgggAEE4aiADQRhqKQMANwMAIABBMGogA0EQaikDADcDACAAQShqIANBCGopAwA3AwAgACADKQMANwMgIABBCGohAiMAQTBrIgMkACADQRBqIAoQ3SgCQCADKAIQIgdFDQAgAygCFCEIIANBIGohDgNAIANBJGogBxDdICADQRhqIAgQ3SAgAygCJCIPQYCAgIB4Rg0BIAMpAighECACKAIIIgcgAigCAEYEQCACIAcgCigCGEEBaiIIQX8gCBtBBEEYENAoCyACKAIEIAdBGGxqIgggEDcCBCAIIA82AgAgCCADKQIYNwIMIAhBFGogDigCADYCACACIAdBAWo2AgggA0EIaiAKEN0oIAMoAgwhCCADKAIIIgcNAAsLIANBMGokACAFQQhqIA0oAgA2AgAgBSAAKQIINwIADAELIAVBADYCCCAFQoCAgIDAADcCAAsgAEFAayQADAELIAcgACgCKEHkgcMAEP0vAAsgDBCTJwwBCyAEQYCAgIB4NgIcCyAEQShqIgAgBkGYAfwKAAAgAEHsAGoQri8gAEH0AGogBEEcaiIDQQhqKAIANgIAIAAgAykCADcCbCALIABBmAH8CgAACyAEQeABaiQAIAkCfyAGKQOYAUICUQRAIAYoAqABIQBBAQwBCyAGQbgCaiAGQZgBakGYAfwKAAAgBkEANgKwAiAGQbACahDRKUEIaiEAQQALIAAQgS0gBkHQA2okACAJKAIAIAkoAgQgCSgCCCAJQRBqJAAL/AgCCn8DfiMAQRBrIgYkACMAQSBrIgQkACAEQQhqIAAgARD6KCAEQRRqIgAgBCgCCCAEKAIMEI81IwBBIGsiAyQAAn8gACgCCEUEQEHgmMMAQSkQlD4hASAAEN47QQEMAQsgA0EIaiAAQQhqKAIANgIAIAMgACkCADcDACADQRBqIQcjAEHQAmsiACQAIABBCGoiBSADEOcVIABBADYCGCAAQQA7ARwgAEGgAWohASMAQSBrIgIkACACQQhqIAUgAEEYahDRDiACKAIUIQggAigCECEJIAIoAgwhCgJAIAIoAggiC0EIRwRAIAEgAikDGDcDGCABIAg2AhQgASAJNgIQIAEgCjYCDCABIAs2AgggAUECNgIAIAVBDGogBSgCBCAFKAIIIAUoAgAoAhARAQAMAQsgAUGAgICAeDYCNCABQYCAgIB4NgIoIAFBgICAgHg2AhwgAUGAgICAeDYCECABQQA2AgggAUEANgIAIAFBgICAMjYCZCABQoAINwJcIAEgCDYCWCABIAk2AlQgASAKNgJQIAEgAikCCDcCOCABQUBrIAUpAgA3AgAgAUHIAGogBUEIaikCADcCAAsgAkEgaiQAAkACQAJAIAAoAqABIgJBAkYEQCAAQZQBaiAAQbgBaikDACIMNwIAIABBjAFqIABBsAFqIgIpAwAiDTcCACAAIAApA6gBIg43AoQBIAIgDDcDACAAQagBaiANNwMAIAAgDjcDoAEgByABEMgmDAELIABBmAFqIgEgAEG8AWooAgA2AgAgAEGQAWoiBSAAQbQBaikCADcDACAAQYgBaiIIIABBrAFqKQIANwMAIAAgACkCpAE3A4ABIABBiAJqIgkgAEHAAWpByAD8CgAAIABBJGogCCkDADcCACAAQSxqIAUpAwA3AgAgAEE0aiABKAIANgIAIAAgAjYCGCAAIAApA4ABNwIcIABBOGogCUHIAPwKAAAgACgCbCIBIAEoAgAiAkEBajYCACACQQBIDQEgB0EGNgIAIAcgATYCBCAAQeQAaiAAKAJcIAAoAmAgACgCWCgCEBEBACAAKAJoIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAQegAahCXFQsgACgCbCIBIAEoAgAiAUEBazYCACABQQFGBEAgAEHsAGoQ+CMLAkAgACgCcCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfAAahDbHgsgAEEoahCXMCAAQTRqEIYwIABBQGsQni8gAEHMAGoQjjAgACgCeCIBRQ0AIAEgASgCACIBQQFrNgIAIAFBAUcNACAAQfgAahCBLAsgAEHQAmokAAwBCwALIAMoAhQhASADKAIQIgBBBkcEQCADIAMpAhg3AhggAyABNgIUIAMgADYCECAHENMZIQFBAQwBC0EACyEAIAQgATYCBCAEIAA2AgAgA0EgaiQAIAQoAgQhACAGIAQoAgBBAXEEf0EBBSAAEP06IQBBAAsgABCBLSAEQSBqJAAgBigCACAGKAIEIAYoAgggBkEQaiQAC+wJAgR+G38jAEEQayIMJAAjAEEwayIHJAAgB0EYaiIWIAAQhyMgB0EEaiENIAcoAhghCSABEMwhIRAjAEHQAGsiACQAIAkoAgwiASABKAIAIghBAWo2AgACQCAIQQBOBEAgAEE8aiIIIAkQvBUgACABNgJIIAAgCSgCEDYCTCAAQSBqIQkjAEEwayIBJAAgASAQNgIEIAhBDGohDgJAAn8CQCAQQQhqIgYgCCgCDCITQQhqIgoQzxxFDQAgBkEYaiEXIAYoAggiFEEYayEYIAooAggiC0EIaiERIAspAwBCf4VCgIGChIiQoMCAf4MhAiAGKAIMIRIgBigCFCEZIAooAhQhBgNAAkAgBkUhGiAGRQ0AIAJQBEADQCALQcABayELIBEpAwAgEUEIaiERQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSECCyAZRQ0AIAZBAWshBiACQgF9IAKDIAsgAnqnQQN2QWhsaiIKQRBrIRsgCkEUayEcIBIgFyAKQRhrEPgLIgKncSEPIAJCGYhC/wCDQoGChIiQoMCAAX4hBUEAIRUDQAJAIA8gFGopAAAiAyAFhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEAgGygCACEdIBwoAgAhHgNAIB4gHSAYIAJ6p0EDdiAPaiAScUFobCIfaiIgKAIEICAoAggQwS4NAiACQgF9IAKDIgJQRQ0ACwsgAyADQgGGg0KAgYKEiJCgwIB/g1BFDQQgDyAVQQhqIhVqIBJxIQ8MAQsLIQIgCkEIaygCACAKQQRrKAIAIBQgH2oiCkEIaygCACAKQQRrKAIAEMEuDQELCyAaDAELQQALRQRAIAFBAjYCDCABQcj/hAE2AgggAUICNwIUIAFB7Bo2AiwgASAONgIoIAFB7Bo2AiQgASABQSBqNgIQIAEgAUEEaiIGNgIgIAlBCGogAUEIahCZDiAJQoGAgIDQgICAgH83AgAgASgCBCILIAsoAgAiC0EBazYCACALQQFGBEAgBhD4IwsgDigCACIGIAYoAgAiBkEBazYCACAGQQFGBEAgDhD4IwsgCBDDJyAIQQRBCBDgHgwBCyAJIBA2AhAgCUEANgIAIAkgCCkCADcCBCAJIAgoAhA2AhQgCUEMaiAIQQhqKAIANgIAIBMgEygCACIIQQFrNgIAIAhBAUcNACAOEPgjCyABQTBqJAAgAEEQaiIBIABBLGopAgA3AwAgAEEYaiIIIABBNGooAgA2AgAgACAAKQIkNwMIAkAgACgCIEEBRgRAIABBMGogCCgCADYCACAAQShqIAEpAwA3AwAgACAAKQMINwMgIAkQ1BkhASANQYCAgIB4NgIAIA0gATYCBAwBCyANIAApAwg3AgAgDUEQaiAIKAIANgIAIA1BCGogASkDADcCAAsgAEHQAGokAAwBCwALIBYQ+yogDAJ/IAcoAgRBgICAgHhGBEAgBygCCCEAQQEMAQsgB0EsaiAHQRRqKAIANgIAIAdBJGogB0EMaikCADcCACAHIAcpAgQ3AhwgB0EANgIYIAdBGGoQnydBCGohAEEACyIBNgIIIAwgAEEAIAEbNgIEIAxBACAAIAEbNgIAIAdBMGokACAMKAIAIAwoAgQgDCgCCCAMQRBqJAALpAQBCn8jAEEQayIFJAAQ3xIiAiABJgEjAEEgayIDJAAgA0EUaiAAENEkIANBCGohBiADKAIUIQQjAEHwAGsiACQAIABByABqIAIQngYgACgCTCECAkACQAJ/IAAoAkgiCEUEQCACEIAYIQJBAQwBCyAAQRhqIgkgAEHgAGopAwA3AwAgAEEQaiIKIABB2ABqKQMANwMAIAAgACkDUDcDCCAEKAIAIgQoAggiByAHKAIAIgtBAWo2AgAgACACNgIEIAAgCDYCACALQQBIDQEgBCgCDCECIABBKGogBEEQahCxLiAAIAI2AiQgACAHNgIgIABBIGoiAkEIahCTJyACQSBqIAkpAwA3AwAgAkEYaiAKKQMANwMAIAJBEGogAEEIaikDADcDACACIAApAwA3AwggAEHIAGoiBCACQSj8CgAAAn9BMEEIEK02IgIEQCACQoGAgIAQNwMAIAJBCGogBEEo/AoAACACDAELQQhBMBCjPQALIQJBAAshBCAGIAI2AgQgBiAENgIAIABB8ABqJAAMAQsACyADKAIMIQAgAygCCCADKAIYQQA2AgAgAygCHCICIAIoAgBBAWsiAjYCACACRQRAIANBHGoQhCYLQQEhAkEBcUUEQEEAIQJBACAAEJosQQhqIQALIAUgAjYCCCAFIABBACACGzYCBCAFQQAgACACGzYCACADQSBqJAAgBSgCACAFKAIEIAUoAgggBUEQaiQAC4QWAg9/An4jAEEQayIJJAAjAEEwayIHJAAgByAAIAEQ+iggB0EMaiEKIAcoAgAiDyEAIAcoAgQiDiECIwBBsAJrIgEkACABQgA3AwggASACNgIEIAEgADYCACABQYCAgIB4NgKAAiABQYABaiECIAFBgAJqIQgjAEGgAmsiACQAIABBCGogAUEIaikDADcDACAAQQA2AhggAEKAgICAEDcDECAAIAEpAwA3AwAgAEH4AWogABClCEEBIQMgAEH8AWohBAJAAkACQAJAIAAoAvgBQQFGBEAgAEHoAGogBEEQaigCACIFNgIAIABB4ABqIARBCGopAgAiETcDACAAIAQpAgAiEjcDWCACQSRqIAU2AgAgAkEcaiARNwIAIAIgEjcCFCACQYCAgIB4NgIQDAELIABBKGoiAyAEQQhqKQIANwMAIABBMGogBEEQaikCADcDACAAQThqIARBGGooAgA2AgAgACAEKQIANwMgIABBLGohDAJ/AkACQAJAAkACQAJAAkACQAJ/AkACQCAAKAIsBEAgAEHIAGogAygCACIDNgIAIAAgACkDICIRNwNAIANBBGohBSADQXtLDQYgBSAAKAJEIgRLDQcgAEH4AWoiBiARpyIFIAQgAyADIAVqIgsoAABrEPY0IAZBBhDMIEH//wNxIgYEQCADIAZqIgYgBEsNCSAFIAZqLQAAQQFGDQILIABB+AFqIgYgBSAEIAMgCygAAGsQ9jQgBkEGEMwgIgZB//8DcQ0CQQAMAwsgAEH4AWpBLEEAQQFBARCgGCAAKAL8ASEDIAAoAvgBQQFGDQ4gACgCgAIiBEGYz8wAQSz8CgAAIAJBLDYCICACIAQ2AhwgAiADNgIYIAJCgICAgMiBgICAfzcDEAwKCyAAQdgAaiAAQUBrELgUIAAoAlgiAw0DIABB+AFqQSpBAEEBQQEQoBggACgC/AEhAyAAKAL4AUEBRw0CDA0LIAMgBkH//wNxaiIDIARLDQYgAyAFai0AAAshAyAAQZoDNgJcIAAgAzoA2AEgAEEBNgL8ASAAQZDPzAA2AvgBIABCATcChAIgACAAQdgBajYCWCAAIABB2ABqNgKAAiACQRhqIABB+AFqEJkOIAJCgICAgMiBgICAfzcDEEEBDAgLIAAoAoACIgRBzM3MAEEq/AoAACACQSo2AiAgAiAENgIcIAIgAzYCGCACQoCAgIDIgICAgH83AxAMBgsgACAAKQJcNwJQIAAgAzYCTCAAQdgAaiIEIABBzABqELcDIABB+AFqIgZBnMnMABClKyAAQYgBakGwycwAKQMANwMAIABBqMnMACkDADcDgAEgACAAKQOAAjcDmAEgACAAKQP4ATcDkAFBgICAgHghAyAIKAIAQYCAgIB4RwRAIABB0AFqIAhBCGooAgAiAzYCACAAIAgpAgA3A8gBIAYgBCAAKALMASADEKcUIABB4AFqIgYgAEGEAmopAgA3AwAgAEHoAWoiAyAAQYwCaigCADYCACAAIAApAvwBNwPYASAAKAL4ASIFRQRAIAIgACkD2AE3AhQgAkGAgICAeDYCECACQSRqIAMoAgA2AgAgAkEcaiAGKQMANwIAIABByAFqEOk7IABBgAFqEOwmIAQQsSxBAAwICyAAQagBaiAAQZgCaikDADcDACAAQbgBaiAAQeABaikDADcDACAAQcABaiADKAIANgIAIAAgACkDkAI3A6ABIAAgACkD2AE3A7ABIAApAswBIREgACgCyAEhAwsgAEHwAWoiCCAAQRhqKQMANwMAIABB6AFqIgYgAEEQaikDADcDACAAQeABaiILIABBCGopAwA3AwAgACAAKQMANwPYASAAQfgBaiINIABB2ABqQSj8CgAAQTBBCBCtNiIERQ0EIARCgYCAgBA3AwAgBEEIaiANQSj8CgAAIAJB8ABqIABBmAFqKQMANwMAIAJB6ABqIABBkAFqKQMANwMAIAJB4ABqIABBiAFqKQMANwMAIAIgACkDgAE3A1ggAiAAKQOwATcCNCACQTxqIABBuAFqKQMANwIAIAJBxABqIABBwAFqKAIANgIAIAIgACkDoAE3A0ggAkHQAGogAEGoAWopAwA3AwAgAkEYaiAIKQMANwMAIAJBEGogBikDADcDACACQQhqIAspAwA3AwAgAiAAKQPYATcDACACQQA7AXwgAiAENgJ4IAIgBTYCMCACIBE3AiQgAiADNgIgIAAoAixFDQggDBDPLwwICyADIAVB0MzMABCxOwALIAUgBEHQzMwAELA7AAsgBiAEQYzJzAAQrzsACyADIARBjMnMABCvOwALQQhBMBCjPQALQQELIQMgACgCLEUNACAMEM8vCyAAQRBqEN47IANFDQAgCCgCAEGAgICAeEYNACAIEOk7CyAAQaACaiQADAELIAMgACgCgAJBsMzMABD9LwALAkAgASgCkAEiA0GAgICAeEYEQCABQagCaiABQaQBaigCACIANgIAIAFBoAJqIAFBnAFqKQIAIhE3AwAgASABKQKUASISNwOYAiABQZABaiAANgIAIAFBiAFqIBE3AwAgASASNwOAASACENQZIQAgCkGAgICAeDYCACAKIAA2AgQMAQsgAUHoAGoiAiABQYgBaiIEKQMANwMAIAFBoAJqIgUgAUGcAWoiCCkCADcDACABQagCaiIMIAFBpAFqIgYoAgA2AgAgASABKQOAATcDYCABIAEpApQBNwOYAiABQRBqIgsgAUGoAWoiDUHQAPwKAAAgASgC/AEhECABKAL4ASEAIAYgDCgCADYCACAIIAUpAwA3AgAgASABKQOYAjcClAEgACAAKAIAIgVBAWo2AgACQCAFQQBOBEAgBCACKQMANwMAIAEgADYCcCABIAEpA2A3A4ABIAEgAzYCkAEgAUEANgJ8IAFCgICAgMAANwJ0IA0gC0HQAPwKAAAgASAQNgL8ASABIAA2AvgBIAFBmAJqIAFBgAFqEO8MIAFBnAJqIQIgASgCmAINAQNAIAEoApwCQYCAgIB4RgRAIAFBgAFqENAbIApBCGogAUH8AGooAgA2AgAgCiABKQJ0NwIAIAogADYCDAwECyABQZACaiIFIAJBEGooAgA2AgAgAUGIAmoiCCACQQhqKQIANwMAIAEgAikCADcDgAIgASgCfCIDIAEoAnRGBEAgAUH0AGpBlNHMABCvKAsgASgCeCADQRRsaiIEIAEpA4ACNwIAIARBCGogCCkDADcCACAEQRBqIAUoAgA2AgAgASADQQFqNgJ8IAFBmAJqIAFBgAFqEO8MIAEoApgCRQ0ACwwBCwALIAFBkAJqIAJBEGooAgAiAzYCACABQYgCaiACQQhqKQIAIhE3AwAgASACKQIAIhI3A4ACIAFBqAJqIAM2AgAgAUGgAmogETcDACABIBI3A5gCIAFBmAJqENQZIQIgCkGAgICAeDYCACAKIAI2AgQgAUGAAWoQ0BsgAUH0AGoiAhDeIyACQQRBFBDgHiAAIAAoAgAiAEEBazYCACAAQQFHDQAgAUHwAGoQ+CMLIAFBsAJqJAAgDgRAIA8gDkEBEPg6CwJ/IAcoAgxBgICAgHhGBEBBASEAIAcoAhAMAQsgB0EoaiAHQRRqKQIANwIAIAcgBykCDDcCIEEAIQAgB0EANgIcIAdBHGoQnidBCGoLIQEgCSAANgIIIAkgAUEAIAAbNgIEIAlBACABIAAbNgIAIAdBMGokACAJKAIAIAkoAgQgCSgCCCAJQRBqJAALKgACQAJAAkAgAC0ApAEOBAACAgECCyAAQZgBahDeOw8LIABBCGoQzSILCzQBAX9BECEBAkACQAJAIAAtAPQCDgQBAgIAAgsgAEH4AWoQlyxBkAEhAQsgACABahDSFgsLNAEBf0EQIQECQAJAAkAgAC0A5AIOBAECAgACCyAAQfABahCYLEGIASEBCyAAIAFqENIWCwsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEM0bIAFBEGokAAsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEMwbIAFBEGokAAsmAQF/IwBBEGsiASQAIAEgAEEIazYCDCABQQxqEMsbIAFBEGokAAsoAAJAAkACQCAALQAcDgQAAgIBAgsgAEEIahDeOw8LIABBGGoQsCwLCyYAIAApAwBCA1IEQCAAEPErCyAAKQNoQgNSBEAgAEHoAGoQ8SsLCycBAX8gACABKAIAIgEoAkwiAgR/IAEoAlAFIAELNgIEIAAgAjYCAAsxACAAQQA7ATggAEIENwMwIABCADcDKCAAQoCAgIDAADcDICAAQgI3AxggAEIANwMACywBAX8gAS0ADyICQRBPBEAgAkEPQez2wwAQsDsACyAAIAI2AgQgACABNgIACy4AAkAgAEGBgICAeEcEQCAADQFB7K7MAEERQYCvzAAQnykACw8LIAAgARCjPQALJgAgACABNgIIIAAgAkEAIAFBAXEiARs2AgQgAEEAIAIgARs2AgALJAAgAEEUaiAAKAIMIAAoAhAgACgCCCgCEBEBACAAQShqEN47Cx4AIABBCBDuKCAAQTBqQQRBDBDgHiAAQcgAahDjPAskACAAQRxqIAAoAhQgACgCGCAAKAIQKAIQEQEAIABBQGsQ3jsLjAEBA38gACgCCCICIAFPBEAgACABEPQ0DwsgACABIAJrIgIQ7S0gACgCBCAAKAIIIgFBAXRqIQMCQAJAIAJBAk8EQCACQQFrIQQDQCADQQA7AQAgA0ECaiEDIARBAWsiBA0ACyABIAJqQQFrIQEMAQsgAkUNAQsgA0EAOwEAIAFBAWohAQsgACABNgIICyUBAX8gACgCCCICIAFPBEAgACABEPQ0DwsgACABIAJrQQAQih8LIwEBfyAAKAIIIgIgAU8EQCAAIAEQ9DQPCyAAIAEgAmsQix8LKQEBfyAAKAJYIgIgAU0EQCABIAJB5PfPABDDIQALIAAoAlQgAUEGdGoLKgEBfyAAKAIoIgIgAU0EQCABIAJB9PfPABDDIQALIAAoAiQgAUHAAmxqCzABAX8gACgCDCIBIAAoAgAiACgCBEsEQEGU8dAAQSxBwPHQABCfKQALIAAgATYCCAslAQF/IAAEQCABKAIEIgIEQCABKAIIIAAgAhEAAA8LIAAQ0jULCx0AIAJBAnYgAGytIAFnQSBqQT9zQR5srX1CgA98CyUAIAAgAUGID2ogAUHwDWpBACACIAMQ2gciAARAIAEQsRkLIAALlgEBA38gACgCCCICIAFPBEAgACABNgIIDwsgASACayICIAAoAgAgACgCCCIBa0sEQCAAIAEgAhDPKCAAKAIIIQELIAAoAgQiBCABaiEDAkACQCACQQJPBEAgAkEBayICBEAgA0EAIAL8CwALIAQgASACaiIBaiEDDAELIAJFDQELIANBADoAACABQQFqIQELIAAgATYCCAspAQF/IAAoAggiAiABTQRAIAEgAkHY/4QBEMMhAAsgACgCBCABQQN0agssAQF/QQEhAgJAIAAgARDpEg0AIAFB1AAQgzYNACAAQQRqIAEQkA4hAgsgAgsrAQF/QQEhAgJAIAAgARDpEg0AIAFBIBCDNg0AIABBBGogARCQDiECCyACCykBAX4gACABrcIiAjcDACAAIAJCP4ciAjcDGCAAIAI3AxAgACACNwMICykBAX4gACABrcMiAjcDACAAIAJCP4ciAjcDGCAAIAI3AxAgACACNwMIC2oBA38gACAAKAIIIgFBAWs2AgggAUEBRgRAIwBBEGsiASQAIAAoAgAgACgCBCIDQQEQ0TRFBEBBiIWIAUErIAFBD2pB+ISIAUHwh4gBENUeAAsgA0EBEPg6IAFBEGokACAAQQxBBBD4OgsLIwEBfyAAKAIIIgIgAU8EQCAAIAE2AggPCyAAIAEgAmsQ0xoLLQAgASgCACACIAMgASgCBCgCDBEGACECIABBADoABSAAIAI6AAQgACABNgIACzIBAX8gASgCAEH87okBQQEgASgCBCgCDBEGACECIABBADoABSAAIAI6AAQgACABNgIAC68rBCx/CX4CfQJ8IwBBEGsiHyQAIwBB0AFrIhokACAaQegAaiIpIAAQhSMgGkEIaiEQIBooAmgoAiBBCGohDCMAQdAAayIFJAAgDCkDACEzIAwoAjAhKgJAIAwoAghBgICAgHhHBEAgBUEoaiAMQQhqEN0gDAELIAVBgICAgHg2AigLAkAgDCgCFEGAgICAeEcEQCAFQTRqIAxBFGoQxBAMAQsgBUGAgICAeDYCNAsgDCgCLCImICYoAgAiAEEBajYCAAJAIABBAE4EQAJAIAwoAiBBgICAgHhHBEAgBUFAayAMQSBqENYeDAELIAVBgICAgHg2AkALIAVBGGogBUEwaigCADYCACAFQQhqIAVBPGooAgA2AgAgBSAFKQIoNwMQIAUgBSkCNDcDACAFQRxqIRIjAEFAaiIJJAAgDEHQAGoiACgCBCELIAlBNGogACgCCCIUQQBBCEHAABCgGCAJKAI4IQACQAJAIAkoAjRBAUcEQCAJKAI8IRsCQCAARQ0AIBRBBnQhASAAIREDQCABIAZGDQEgCUEoaiAGIAtqIgdBIGoQwAEgB0EQaikDACEtAkAgB0EsaiIcKAIAQYCAgIB4RwRAIAlBNGogHBCTGAwBCyAJQYCAgIB4NgI0CyAHQRhqKQMAIS4gB0E8aigCACIcIBwoAgAiA0EBajYCACADQQBIDQMgB0E4aigBACEDIAdBCGopAwAhLyAHKQMAITAgCUEgaiAJQTBqKAIAIgQ2AgAgCSAJKQIoIjE3AxggCUEQaiAJQTxqKAIAIgg2AgAgCSAJKQI0IjI3AwggBiAbaiIHQRhqIC43AwAgB0EQaiAtNwMAIAdBCGogLzcDACAHIDA3AwAgB0EgaiAxNwMAIAdBKGogBDYCACAHQSxqIDI3AgAgB0E0aiAINgIAIAdBPGogHDYCACAHQThqIAM2AgAgBkFAayEGIBFBAWsiEQ0ACwsgEiAUNgIIIBIgGzYCBCASIAA2AgAgCUFAayQADAILIAAgCSgCPEHQtcIAEP0vCwALAkAgDCgCOEGAgICAeEcEQCMAQRBrIhUkACAMQThqIgAoAgQhHiAVQQRqIAAoAggiJ0EAQQRBDBCgGCAVKAIIIRQgFSgCBEEBRwRAIAVBKGohICAVKAIMIRwCQCAURQ0AICdBDGwhIiAcIREgFCEJA0AgIkUNASAVQQRqISMjAEEgayIDJAAgHigCBCEIIANBEGogHigCCCIoQQBBBEEUEKAYIAMoAhQhGwJAAkAgAygCEEEBRwRAIAMoAhghCwJAIBtFDQAgKEEUbCEkIANBCGohFiALIRIgGyEHA0AgJEUNAQJAAkACQAJAAkACQAJAAkACQCAIKAIAIitBAWsOCAABAgMEBQYHCAsgA0EQaiEKQQAhBCMAQUBqIgEkACAIQQRqIgAoAgQhFyABQTRqIAAoAggiDUEAQQhBMBCgGCABKAI4IQACQCABKAI0QQFHBEAgASgCPCEOAkAgAEUNACANQTBsIRMgACEGA0AgBCATRg0BIAQgF2oiAkEIaikDACEtIAJBKWotAAAhDyACQShqLQAAIRggAikDACEuAkAgAkEQaiIZKAIAQYCAgIB4RwRAIAFBKGogGRClHQwBCyABQYCAgIB4NgIoCwJAIAJBHGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIhk2AgAgASABKQIoIi83AxggAUEQaiABQTxqKAIAIh02AgAgASABKQI0IjA3AwggBCAOaiICQQhqIC03AwAgAiAuNwMAIAJBEGogLzcDACACQRhqIBk2AgAgAkEcaiAwNwIAIAJBJGogHTYCACACQSlqIA86AAAgAkEoaiAYOgAAIARBMGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwMCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwHCyADQRBqIQpBACEEIwBBQGoiASQAIAhBBGoiACgCBCEXIAFBNGogACgCCCINQQBBCEE4EKAYIAEoAjghAAJAIAEoAjRBAUcEQCABKAI8IQ4CQCAARQ0AIA1BOGwhEyAAIQYDQCAEIBNGDQEgBCAXaiICQQhqKQMAIS0gAkEcaigCACEPIAJBGGooAgAhGCACQRRqKAIAIRkgAkEQaigCACEdIAIpAwAhLgJAIAJBIGoiISgCAEGAgICAeEcEQCABQShqICEQpR0MAQsgAUGAgICAeDYCKAsCQCACQSxqIgIoAgBBgICAgHhHBEAgAUE0aiACEKUdDAELIAFBgICAgHg2AjQLIAFBIGogAUEwaigCACIhNgIAIAEgASkCKCIvNwMYIAFBEGogAUE8aigCACIlNgIAIAEgASkCNCIwNwMIIAQgDmoiAkEcaiAPNgIAIAJBGGogGDYCACACQRRqIBk2AgAgAkEQaiAdNgIAIAJBCGogLTcDACACIC43AwAgAkEgaiAvNwMAIAJBKGogITYCACACQSxqIDA3AgAgAkE0aiAlNgIAIARBOGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwLCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwGCyADQRBqIQpBACEEIwBBQGoiASQAIAhBBGoiACgCBCEXIAFBNGogACgCCCINQQBBCEHIABCgGCABKAI4IQACQCABKAI0QQFHBEAgASgCPCEOAkAgAEUNACANQcgAbCETIAAhBgNAIAQgE0YNASAEIBdqIgJBKGopAwAhLSACQSBqKQMAIS4gAkEYaikDACEvIAJBEGopAwAhMCACQQhqKQMAITEgAikDACEyAkAgAkEwaiIPKAIAQYCAgIB4RwRAIAFBKGogDxClHQwBCyABQYCAgIB4NgIoCwJAIAJBPGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIg82AgAgASABKQIoIjQ3AxggAUEQaiABQTxqKAIAIhg2AgAgASABKQI0IjU3AwggBCAOaiICQShqIC03AwAgAkEgaiAuNwMAIAJBGGogLzcDACACQRBqIDA3AwAgAkEIaiAxNwMAIAIgMjcDACACQTBqIDQ3AwAgAkE4aiAPNgIAIAJBPGogNTcCACACQcQAaiAYNgIAIARByABqIQQgBkEBayIGDQALCyAKIA02AgggCiAONgIEIAogADYCACABQUBrJAAMAQsMCgsgAyAIQRBqKAIANgIcIBYgA0EYaikCADcDACADIAMpAhA3AwAMBQsgA0EQaiEKQQAhBCMAQYABayIBJAAgCEEEaiIAKAIEIRggAUH0AGogACgCCCINQQBBCEHIABCgGCABKAJ4IQACQCABKAJ0QQFHBEAgASgCfCEOAkAgAEUNACANQcgAbCEZIAFB0ABqIRcgACEGA0AgBCAZRg0BQQAhE0EAIQ8gBCAYaiICQRBqKAIAQQFGBEAgFyACQRxqKAIANgIAIAEgAkEUaikCADcDSEEBIQ8LIAJBIGooAgBBAUYEQCABQeAAaiACQSxqKAIANgIAIAEgAkEkaikCADcDWEEBIRMLIAJBCGopAwAhLSACKQMAIS4CQCACQTBqIh0oAgBBgICAgHhHBEAgAUHoAGogHRClHQwBCyABQYCAgIB4NgJoCwJAIAJBPGoiAigCAEGAgICAeEcEQCABQfQAaiACEKUdDAELIAFBgICAgHg2AnQLIAFBQGsiHSAXKAIANgIAIAEgASkDSDcDOCABQTBqIiEgAUHgAGooAgA2AgAgASABKQNYNwMoIAFBIGoiJSABQfAAaigCADYCACABIAEpAmg3AxggAUEQaiIsIAFB/ABqKAIANgIAIAEgASkCdDcDCCAEIA5qIgJBEGogDzYCACACQQhqIC03AwAgAiAuNwMAIAJBIGogEzYCACACQRRqIAEpAzg3AgAgAkEcaiAdKAIANgIAIAJBJGogASkDKDcCACACQSxqICEoAgA2AgAgAkEwaiABKQMYNwMAIAJBOGogJSgCADYCACACQTxqIAEpAwg3AgAgAkHEAGogLCgCADYCACAEQcgAaiEEIAZBAWsiBg0ACwsgCiANNgIIIAogDjYCBCAKIAA2AgAgAUGAAWokAAwBCyAAIAEoAnxB0LXCABD9LwALIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMADAQLIANBEGohCkEAIQQjAEFAaiIBJAAgCEEEaiIAKAIEIRcgAUE0aiAAKAIIIg1BAEEIQTgQoBggASgCOCEAAkAgASgCNEEBRwRAIAEoAjwhDgJAIABFDQAgDUE4bCETIAAhBgNAIAQgE0YNASAEIBdqIgJBCGopAwAhLSACQRxqKgIAITYgAkEYaigCACEPIAJBFGoqAgAhNyACQRBqKAIAIRggAikDACEuAkAgAkEgaiIZKAIAQYCAgIB4RwRAIAFBKGogGRClHQwBCyABQYCAgIB4NgIoCwJAIAJBLGoiAigCAEGAgICAeEcEQCABQTRqIAIQpR0MAQsgAUGAgICAeDYCNAsgAUEgaiABQTBqKAIAIhk2AgAgASABKQIoIi83AxggAUEQaiABQTxqKAIAIh02AgAgASABKQI0IjA3AwggBCAOaiICQRxqIDY4AgAgAkEYaiAPNgIAIAJBFGogNzgCACACQRBqIBg2AgAgAkEIaiAtNwMAIAIgLjcDACACQSBqIC83AwAgAkEoaiAZNgIAIAJBLGogMDcCACACQTRqIB02AgAgBEE4aiEEIAZBAWsiBg0ACwsgCiANNgIIIAogDjYCBCAKIAA2AgAgAUFAayQADAELDAgLIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMADAMLIANBEGohCkEAIQQjAEFAaiIBJAAgCEEEaiIAKAIEIRcgAUE0aiAAKAIIIg1BAEEIQcgAEKAYIAEoAjghAAJAIAEoAjRBAUcEQCABKAI8IQ4CQCAARQ0AIA1ByABsIRMgACEGA0AgBCATRg0BIAQgF2oiAkEoaikDACEtIAJBIGopAwAhLiACQRhqKwMAITggAkEQaikDACEvIAJBCGorAwAhOSACKQMAITACQCACQTBqIg8oAgBBgICAgHhHBEAgAUEoaiAPEKUdDAELIAFBgICAgHg2AigLAkAgAkE8aiICKAIAQYCAgIB4RwRAIAFBNGogAhClHQwBCyABQYCAgIB4NgI0CyABQSBqIAFBMGooAgAiDzYCACABIAEpAigiMTcDGCABQRBqIAFBPGooAgAiGDYCACABIAEpAjQiMjcDCCAEIA5qIgJBKGogLTcDACACQSBqIC43AwAgAkEYaiA4OQMAIAJBEGogLzcDACACQQhqIDk5AwAgAiAwNwMAIAJBMGogMTcDACACQThqIA82AgAgAkE8aiAyNwIAIAJBxABqIBg2AgAgBEHIAGohBCAGQQFrIgYNAAsLIAogDTYCCCAKIA42AgQgCiAANgIAIAFBQGskAAwBCwwHCyADIAhBEGooAgA2AhwgFiADQRhqKQIANwMAIAMgAykCEDcDAAwCCyADQRBqIAhBBGoQ/gggAyAIQRBqKAIANgIcIBYgA0EYaikCADcDACADIAMpAhA3AwAMAQsgA0EQaiAIQQRqEP4IIAMgCEEQaigCADYCHCAWIANBGGopAgA3AwAgAyADKQIQNwMACyAIQRRqIQggEiArNgIAIBJBBGogAykDADcCACASQQxqIBYpAwA3AgAgEkEUaiESICRBFGshJCAHQQFrIgcNAAsLICMgKDYCCCAjIAs2AgQgIyAbNgIAIANBIGokAAwCCyAbIAMoAhhB0LXCABD9LwALIAAgASgCPEHQtcIAEP0vAAsgEUEIaiAVQQxqKAIANgIAIBEgFSkCBDcCACARQQxqIREgIkEMayEiIB5BDGohHiAJQQFrIgkNAAsLICAgJzYCCCAgIBw2AgQgICAUNgIAIBVBEGokAAwCCyAUIBUoAgxB0LXCABD9LwALIAVBgICAgHg2AigLAkAgDCgCREGAgICAeEcEQCMAQRBrIgMkACAMQcQAaiIAKAIEIQEgA0EEaiAAKAIIIgJBAEEEQQwQoBggAygCCCESIAMoAgRBAUcEQCAFQTRqIQQgAygCDCEbAkAgEkUNACACQQxsIR4gGyEAIBIhBgNAIB5FDQEgA0EEaiEMIwBBMGsiCyQAIAEoAgQhESALIAEoAggiFUEAQQRBGBCgGCALKAIEIRQCQCALKAIAQQFHBEAgCygCCCEcAkAgFEUNACAVQRhsIQggEUEMaiEHIAtBDGohFiAcIREgFCEJA0AgCEUNASALQRhqIAdBDGsQzhUCQCAHKAIAQYCAgIB4RwRAIAtBJGogBxClHQwBCyALQYCAgIB4NgIkCyAWIAspAiQ3AgAgC0EIaiIgIAtBIGooAgA2AgAgFkEIaiALQSxqKAIANgIAIAsgCykCGCItNwMAIBFBEGogC0EQaikDADcCACARQQhqICApAwA3AgAgESAtNwIAIBFBGGohESAIQRhrIQggB0EYaiEHIAlBAWsiCQ0ACwsgDCAVNgIIIAwgHDYCBCAMIBQ2AgAgC0EwaiQADAELIBQgCygCCEHQtcIAEP0vAAsgAEEIaiADQQxqKAIANgIAIAAgAykCBDcCACAAQQxqIQAgHkEMayEeIAFBDGohASAGQQFrIgYNAAsLIAQgAjYCCCAEIBs2AgQgBCASNgIAIANBEGokAAwCCyASIAMoAgxB0LXCABD9LwALIAVBgICAgHg2AjQLIBAgMzcDACAQIAUpAxA3AwggECAFKQMANwIUIBAgBSkDQDcDICAQICo2AjAgECAmNgIsIBAgBSkCHDcCUCAQQRBqIAVBGGooAgA2AgAgEEEcaiAFQQhqKAIANgIAIBBBKGogBUHIAGooAgA2AgAgEEHYAGogBUEkaigCADYCACAQQUBrIAVBMGooAgA2AgAgECAFKQIoNwI4IBBBzABqIAVBPGooAgA2AgAgECAFKQI0NwJEIAVB0ABqJAAMAQsACyApEOQqIB8CfyAaKAJYQYCAgIB4RgRAIBooAgghAEEBDAELIBpB8ABqIBpBCGpB4AD8CgAAIBpBADYCaAJ/QfAAQQgQrTYiAARAIABCgYCAgBA3AwAgAEEIaiAaQegAakHoAPwKAAAgAAwBC0EIQfAAEKM9AAtBCGohAEEACyAAEIEtIBpB0AFqJAAgHygCACAfKAIEIB8oAgggH0EQaiQAC3EBA38jAEEQayIBJAAjAEEQayICJAAgAkEEaiAAEIUjIAIoAgQoAiQiAyADKAIAIgBBAWo2AgAgAEEASARAAAsgAkEEahDkKiABQQAgAxD9OhCBLSACQRBqJAAgASgCACABKAIEIAEoAgggAUEQaiQAC+ECAQd/IwBBEGsiAyQAIwBBIGsiBCQAIARBFGoiByAAEIUjIARBCGohBiAEKAIUIQEjAEEQayIAJAAgABCkNiICNgIEAkAgAUEUakEAIAEoAhRBgICAgHhHGyIBRQ0AIAEoAggiBUUNACAFQRhsIQUgASgCBEEUaiECA0ACQCACQQhrKAIAQYCAgIB4Rg0AIAAgAkEQaygCACACQQxrKAIAEJM+NgIIIAAgAkEEaygCACACKAIAEJM+NgIMIABBBGogAEEIaiAAQQxqEPc1IgFBhAFPBEAgARDyHwsgACgCDCIBQYQBTwRAIAEQ8h8LIAAoAggiAUGEAUkNACABEPIfCyACQRhqIQIgBUEYayIFDQALIAAoAgQhAgsgBiACNgIEIAZBADYCACAAQRBqJAAgBCgCDCEAIAcQ5iogA0EAIAAQgS0gBEEgaiQAIAMoAgAgAygCBCADKAIIIANBEGokAAuXAgEIfyMAQRBrIgMkACMAQSBrIgEkACABQRRqIgUgABCHIyABKAIUIQIjAEEQayIAJAAgAEEEaiIGIAIQkBggACgCDCEEIAAoAgghAiABQQxqIgcgACgCBCIIQYGAgIB4RwR/IAAgBDYCDCAAIAI2AgggACAINgIEQQAhAiAGEPcWBSAECzYCBCAHIAI2AgAgAEEQaiQAIAUQ+yogAwJ/IAEoAgwiAEUEQCABKAIQIQBBAQwBCyABIAEoAhA2AhwgASAANgIYIAFBADYCFCABQRRqENYpQQhqIQBBAAsiAjYCCCADIABBACACGzYCBCADQQAgACACGzYCACABQSBqJAAgAygCACADKAIEIAMoAgggA0EQaiQAC5ECAQd/IwBBEGsiAiQAIwBBMGsiASQAIAFBCGoiBCAAELIWIwBBEGsiACQAIABBBGoiBiAEEJAYIAAoAgwhAyAAKAIIIQUgACgCBCIHQYGAgIB4RwRAIAAgAzYCDCAAIAU2AgggACAHNgIEQQAhBSAGEPcWIQMLIAQQ6SsgAUEcaiIEIAM2AgQgBCAFNgIAIABBEGokACACAn8gASgCHCIARQRAIAEoAiAhAEEBDAELIAEgASgCIDYCLCABIAA2AiggAUEANgIkIAFBJGoQ1ilBCGohAEEACyIDNgIIIAIgAEEAIAMbNgIEIAJBACAAIAMbNgIAIAFBMGokACACKAIAIAIoAgQgAigCCCACQRBqJAALigIBB38jAEEQayICJAAjAEEgayIDJAAgA0EUaiIGIAAQhyMgA0EIaiEEIAMoAhQhASMAQRBrIgAkACAAQQRqIgUgASgCAEEIahD0FSAAKAIIIQECfyAAKAIEIgdBgYCAgHhHBEAgACAAKAIMNgIMIAAgATYCCCAAIAc2AgQgBRD3FiEBQQEMAQtBAAshBSAEIAE2AgQgBCAFNgIAIABBEGokAEEBIQAgAygCCCADKAIMIQEgBhD9KkEBcUUEQEEAIAEQmixBCGohAUEAIQALIAIgADYCCCACIAFBACAAGzYCBCACQQAgASAAGzYCACADQSBqJAAgAigCACACKAIEIAIoAgggAkEQaiQAC7MCAQd/IwBBEGsiAiQAIwBBEGsiBCQAIARBCGohBiAAEMwhIQEjAEEQayIAJAAgACABNgIAIABBBGoiAyABQQhqEPQVIAAoAgghBQJAAkAgACgCBCIHQYGAgIB4RwRAIAAgACgCDDYCDCAAIAU2AgggACAHNgIEIAMQ9xYhBSABIAEoAgAiA0EBazYCAEEBIQEgA0EBRg0BDAILIAEgASgCACIDQQFrNgIAQQAhASADQQFHDQELIAAQ+CMLIAYgBTYCBCAGIAE2AgAgAEEQaiQAQQEhACAEKAIMIQEgBCgCCEEBcUUEQEEAIAEQmixBCGohAUEAIQALIAIgADYCCCACIAFBACAAGzYCBCACQQAgASAAGzYCACAEQRBqJAAgAigCACACKAIEIAIoAgggAkEQaiQAC/4JAg1/AW8jAEEQayIHJAAjAEEgayIJJAAgCUEUaiIMIAAQhyMgCUEIaiEKIAkoAhQjAEEQayIIJAAoAgAhACAIQQA2AgwjAEHwAGsiAiQAIAIgAEEQaiIBKAIMNgI4IAIgASgCACIANgIwIAIgAEEIajYCKCACIAAgASgCBGpBAWo2AiwgAiAAKQMAQn+FQoCBgoSIkKDAgH+DNwMgIAJB2ABqIQECfyAIQQxqIgMtAAFFBEAQpDYhAEEADAELEK8+IQBBAQshBCABIAM2AhAgAUEANgIIIAEgADYCBCABIAQ2AgAgCAJ/AkACQCACKAJYQQJGBEAgAigCXCEADAELIAJB0ABqIAJB6ABqKAIANgIAIAJByABqIAJB4ABqKQIANwMAIAIgAikCWDcDQANAIAJBGGogAkEgahDdKCACKAIYIgBFDQIgAigCHCEBIAIgADYCbCACIAE2AlgjAEEQayIEJAAjAEEQayIAJAAgAEEIaiACQUBrIgEoAhAgAkHsAGooAgAiAygCBCADKAIIEJo1QQEhAyAAKAIMIQUgACgCCEEBcUUEQAJAIAEoAghFDQAgASgCDCIDQYQBSQ0AIAMQ8h8LIAEgBTYCDCABQQE2AghBACEDCyACQRBqIQsgAkHYAGohBiAEQQhqIg0gBTYCBCANIAM2AgAgAEEQaiQAAn8gBCgCCCIAQQFxBEAgBCgCDAwBCyMAQSBrIgMkACABKAIIIQAgAUEANgIIAkACQCAABEAgAyABKAIMIgU2AhQgA0EIaiABKAIQIAYoAgAiACgCBCAAKAIIEJo1QQEhBiADKAIMIQAgAygCCEEBcQRAIAVBhAFJDQIgBRDyHwwCCyADIAA2AhggAUEEaiEGAkACQCABKAIAQQFGBEAgAyAFNgIcIANBHGooAgAlARBtDQFBxMbMAEEzENwbIQEgBUGEAU8EQCAFEPIfCyAAQYQBTwRAIAAQ8h8LQQEhBgwFCyAGIANBFGogA0EYahD3NSIBQYQBTwRAIAEQ8h8gAygCGCEACyAAQYQBTwRAIAAQ8h8LQQAhBiADKAIUIgFBhAFJDQEgARDyHwwBCyAGKAIAJQEgBSUBIAUQ8h8gACUBIAAQ8h8QDUEAIQYLDAILQbDHzABBMRCXPQALIAAhAQsgBCABNgIEIAQgBjYCACADQSBqJAAgBCgCACEAIAQoAgQLIQEgCyAANgIAIAsgATYCBCAEQRBqJAAgAigCEEEBcUUNAAsgAigCFCEAIAIoAkQiAUGEAU8EQCABEPIfCyACKAJIRQ0AIAIoAkwiAUGEAUkNACABEPIfC0EBDAELIAJB6ABqIAJB0ABqKAIANgIAIAJB4ABqIAJByABqKQMANwMAIAIgAikDQDcDWCACQQhqIQAgAkHYAGoiASgCBCEDAkAgASgCCEUNACABKAIMIgFBhAFJDQAgARDyHwsgACADNgIEIABBADYCACACKAIMIQAgAigCCAs2AgAgCCAANgIEIAJB8ABqJABBASEBIAgoAgQhAAJAIAgoAgBBAXFFBEBBACEBDAELIAAQgBghAAsgCiAANgIEIAogATYCACAIQRBqJAAgCSgCDCEAIAkoAgghASAMEP0qIAcgATYCCCAHIABBACABQQFxIgEbNgIEIAdBACAAIAEbNgIAIAlBIGokACAHKAIAIAcoAgQgBygCCCAHQRBqJAALywIBB38jAEEQayICJAAjAEEwayIBJAAgAUEcaiIFIAAQhyMgAUEMaiEDIAEoAhwhBCMAQSBrIgAkACAAQRBqIgYgBBDQCyAAQQhqIgQgAEEcaigCADYCACAAIAApAhQ3AwACQCAAKAIQIgdBgICAgHhGBEAgAEEYaiAEKAIANgIAIAAgACkDADcDECADIAYQ9xY2AgQMAQsgAyAAKQMANwIEIANBDGogBCgCADYCAAsgAyAHNgIAIABBIGokACAFEIArIAICfyABKAIMQYCAgIB4RgRAIAEoAhAhAEEBDAELIAFBKGogAUEUaikCADcCACABIAEpAgw3AiAgAUEANgIcIAFBHGoQnidBCGohAEEACyIDNgIIIAIgAEEAIAMbNgIEIAJBACAAIAMbNgIAIAFBMGokACACKAIAIAIoAgQgAigCCCACQRBqJAALxAIBB38jAEEQayICJAAjAEFAaiIBJAAgAUEMaiIEIAAQ+BcgAUEcaiEDIwBBIGsiACQAIABBEGoiBiAEENALIABBCGoiBSAAQRxqKAIANgIAIAAgACkCFDcDAAJAIAAoAhAiB0GAgICAeEYEQCAAQRhqIAUoAgA2AgAgACAAKQMANwMQIAMgBhD3FjYCBAwBCyADIAApAwA3AgQgA0EMaiAFKAIANgIACyAEEP8qIAMgBzYCACAAQSBqJAAgAgJ/IAEoAhxBgICAgHhGBEAgASgCICEAQQEMAQsgAUE4aiABQSRqKQIANwIAIAEgASkCHDcCMCABQQA2AiwgAUEsahCeJ0EIaiEAQQALIgM2AgggAiAAQQAgAxs2AgQgAkEAIAAgAxs2AgAgAUFAayQAIAIoAgAgAigCBCACKAIIIAJBEGokAAseACAALQB4QQNGBEAgAEEYahDDJiAAQewAahDtOwsLHgAgAC0AfEEDRgRAIABBIGoQxCYgAEHwAGoQ7TsLCxsBAX8DQCAAIAFqEN47IAFBDGoiAUEYRw0ACwsnAAJAIAAoAgBFDQAgAEEEahCSPiAAKAIEIgBBhAFJDQAgABDyHwsLJAAgAC0AAARAIAFBhAFPBEAgARDyHwsPC0Hs2sMAQRwQlz0ACx8AIAAgAhDsEiAAQUBrIAJBQGsQ7BIgAkEIIAEQ/g8LHwAgACACENQWIABBIGogAkEgahDUFiACQQggARD/EQsfACAAIAIQwRUgAEEQaiACQRBqEMEVIAJBCCABEPcQCyEAIAAoAhAgACgCIGogAC0AFCIAQQN2IABBB3FBAEdqagshACAAKAJsIAAoAihqIAAtACwiAEEDdiAAQQdxQQBHamoLJQAgACACIAMQ3BAgAEFAayACQUBrIAMQ3BAgAkEIIAEgAxCsDwszAAJAAkACQCAAKAKk6wFBAWoOAwIAAQALIAAQ/DBBAA8LIABBADYCpOsBCyAAKAKY6wELJAAgAUH/AXFBAUYEQCAAQQQ2AgAgAEECOgAEDwsgACABEKgSCysAIABBADoAECAAIAI7AQ4gAEEAOwEMIAAgASkCBDcCBCAAIAEoAgA2AgALHwAgACACEPESIABBMGogAkEwahDxEiACQQggARCIEAsfACAAEN47IAAoAgwEQCAAQQxqEM8vCyAAQShqEKYMCx8AIAAQnTwgACgCDARAIABBDGoQzy8LIABBKGoQpgwLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahCmDAsfACAAEOM8IAAoAgwEQCAAQQxqEM8vCyAAQShqEKYMCx8AIAAQ5jwgACgCDARAIABBDGoQzy8LIABBKGoQpgwLHwAgABDlPCAAKAIMBEAgAEEMahDPLwsgAEEoahCmDAsfACAAEN47IAAoAgwEQCAAQQxqEM8vCyAAQShqEKkMCx8AIAAQnTwgACgCDARAIABBDGoQzy8LIABBKGoQqQwLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahCpDAsfACAAEOM8IAAoAgwEQCAAQQxqEM8vCyAAQShqEKkMCy4BAX8CQAJAIAAtAABBAWsOAwABAAELIAAoAggiAUUNACAAKAIEIAFBARD4OgsLHwAgABDpOyAAKAIMBEAgAEEMahDPLwsgAEEoahC0DAsqAQF/IAEoAhQhAiAAQQRqIAEQ9zQgACACNgIgIABBADYCHCAAIAE2AgALKgEBfyABEMA8IQIgAEEEaiABEPc0IAAgAjYCICAAQQA2AhwgACABNgIACyoBAX8gARDBPCECIABBBGogARD3NCAAIAI2AiAgAEEANgIcIAAgATYCAAsqAQF/IAEQvzwhAiAAQQRqIAEQ9zQgACACNgIgIABBADYCHCAAIAE2AgALIgAgACgCIARAIABBIGoQ1B4LIABBDGoQ+SMgAEEUahDUHgslACAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogASAAKAIMEQIACyUAIAAgASgCACABKAIEIgAoAghBAWtBeHFqQQhqIAAoAhQRAAALJQAgACABKAIAIAEoAgQiACgCCEEBa0F4cWpBCGogACgCOBEAAAslACAAKAIAIAAoAgQiACgCCEEBa0F4cWpBCGogASAAKAI8EQIACyUAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiABIAAoAkARAgALIgAgAEEMahDUHiAAQRhqENQeIAAoAiQEQCAAQSRqENQeCwsfACAAIAIQ5Q0gAEEQaiACQRBqEOUNIAJBCCABEOIOCygBAX4gACABrCICNwMAIAAgAkI/hyICNwMYIAAgAjcDECAAIAI3AwgLJgAgASACTQRAIAAgATYCBCAAQQA2AgAPCyABIAJB/JjPABCwOwALKQEBfwJAIAAoAgAiAUUNACABIAEoAgBBAWsiATYCACABDQAgABCyGgsLGwAgACgCACUBIAEEfyABKAIABUGBAQslARAuCxoAIAAoAgAlASABBH8gASgCAAVBAAslARA0Cy0BAX5B2O+KASkDACEBQdjvigFCADcDACAAIAFCIIg+AgQgACABp0EBRjYCAAsfAQJ/IAEgACgCACIDTwR/IAEgAyAAKAIEakkFIAILCx8AIAAoAgAEQCAAEL0rCyAAKAIQBEAgAEEQahC9KwsLLgACQAJAAkAgAC0AyAQOBAECAgACCyAAQbADahDlKiAAQdgBaiEACyAAENQMCwsuAAJAAkACQCAALQDcAQ4EAQICAAILIABB0AFqEOQoIABB6ABqIQALIAAQoSULCyEBAX8gAEEEaiEBIAAoAgBBA0YEQCABELwqDwsgARDeOwslAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQgyALCy4AAkACQAJAIAAtANwBDgQBAgIAAgsgAEHQAWoQ5CggAEHoAGohAAsgABCkKQsLLgACQAJAIAAtACAOBAABAQABCyAAQRBqIAAoAgggACgCDCAAKAIEKAIQEQEACwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBEBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQxSgLCyUBAX8gACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABC7IwsLIwEBfyAAKAIYIgAgACgCACIBQQFqNgIAIAFBAEgEQAALIAALJQEBfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQCAAEIgcCwskAQF/IAAoArwCIgAgACgCACIBQQFqNgIAIAFBAEgEQAALIAALKwACQAJAIAAtAABBAWsOBQAAAAAAAQsgACgCBCIARQ0AIABBGEEIEPg6CwvICQIYfwJ+An8gASESQQQgACgCyAEiASABQQVrQQNPGyEMQQAgAiITKAIAIhQgFCAAIgIoAgQiCSAAKAIMIgEgAyIGIAlrIARqIgBBASACKAK4AXQiA2sgASAAIAFrIANLGyACKAIYIgUbIhVqIhYgBkYgBmoiACAJayIIIAEgCCADayABIAggAWsgA0sbIAUbayIDSyIXGyEBQQAgEygCBCIYIAMgGEkiHBshAyAEIAZqIgpBCGshDUHAACACKALAAWutIR0gAigCvAEhDiACKAJkIQ8gAigCXCELA0ACQAJAAkACQAJAIA0gAEEBaiIETwRAQQAgAWshGSAAQYACaiEIIAkgCyAAKQAAQuPIlb3Lm++NT34gHYinIhBBAnRqKAIAIgVqIQdBASERA0AgDyAAIA4gDBCjHUECdGoiAigCACEaIAIgACAJayIbNgIAIAsgEEECdGogGzYCACABBEAgAEEBaiICIBlqKAAAIAAoAAFGDQQLIAQpAAAiHkLjyJW9y5vvjU9+IB2IpyEQAkAgBSAVTQ0AIAcpAAAgACkAAFINACAAQQhqIAdBCGogChCAFEEIaiEFIAAgB2shCANAIAcgFk0gACAGTXINBiAAQQFrIgItAAAgB0EBayIHLQAARw0GIAVBAWohBSACIQAMAAsACyAJIAsgEEECdGooAgAiBWohByAVIBpJBEAgCSAaaiICKAAAIAAoAABGDQMLIAQgCE8EQCARQQFqIREgCEGAAmohCAsgESAEIgBqIgQgDU0NAAsLIBMgASAUQQAgFxsgARs2AgAgEyADIBQgGEEAIBwbIgAgARsgACAXGyADGzYCBCAKIAZrDAYLAkAgBSAVTQ0AIAcpAAAgHlINACAEQQhqIAdBCGogChCAFEEIaiEFIAQgB2shCCAEIQIDQCAHIBZNIAIgBk1yDQQgAkEBayIALQAAIAdBAWsiBy0AAEcNBCAFQQFqIQUgACECDAALAAsgAEEEaiACQQRqIAoQgBRBBGohBSAAIAJrIQgDQCACIBZNIAAgBk1yDQIgAEEBayIDLQAAIAJBAWsiAi0AAEcNAiAFQQFqIQUgAyEADAALAAsgEiACIAZrIAYgCkEBIABBBWoiACAAIBlqIAoQgBRBBGoiBRCFEgwCCyAAIQILIBFBA00EQCALIBBBAnRqIAQgCWs2AgALIBIgAiAGayAGIAogCEEDaiAFEIUSIAEhAyAIIQELIAIgBWoiACEGIAAgDUsNACALIAkgG0ECaiICaiIEKQAAQuPIlb3Lm++NT34gHYinQQJ0aiACNgIAIAsgAEECayIGKQAAQuPIlb3Lm++NT34gHYinQQJ0aiAGIAlrNgIAIA8gBCAOIAwQox1BAnRqIAI2AgAgDyAAQQFrIgIgDiAMEKMdQQJ0aiACIAlrNgIAA0ACQCAAIA1LDQAgAyICRSAAIAJrKAAAIAAoAABHcg0AIABBBGoiBCAEIAJrIAoQgBQhAyAPIAAgDiAMEKMdQQJ0aiAAIAlrIgQ2AgAgCyAAKQAAQuPIlb3Lm++NT34gHYinQQJ0aiAENgIAIBJBACAAIApBASADQQRqIgMQhRIgACADaiEAIAEhAyACIQEMAQsLIAAhBgwACwALC6kOAh5/BH4CfyABIRggAiEUQQQgACgCyAEiASABQQVrQQNPGyEQIAMiBiAAIgEoAgQiCSAAKAIMIgMgBiAJayAEaiICQQEgACgCuAF0IgBrIAMgAiADayAASxsgASgCGBsiCmoiC2shDUEAIQBBACABKAK0ASIMKAIEIg4gDCgCACIPayAKaiIVayAEIAZqIQggDCgCvAEhAyAOIAwoAgwiGWoiGiAPayEFIAEoAsABIQQgDCgCwAEhEQJAIAEoAtgBRQ0AQQQgEXQhAgNAIAAgAk8EQEEEIAN0IQJBACEAA0AgACACTw0DIABBQGshAAwACwAFIABBQGshAAwBCwALAAsgCEEIayEbIANBCGohISAUKAIEIQIgFCgCACEDIAEoArwBIRYgASgCZCEXIAEoAlwhEiAMKAJkISIgDCgCXCEcIA5qIQwgCkEBayEdIAYgBSANRmohAEE4IBFrrSEmQcAAIARrrSEjA0ACQAJAAkAgACAbSQRAIBcgACAWIBAQox1BAnRqIgcoAgAhASAiIAAgISAQEKMdIg1BBnZB/P//H3FqKAIAIR4gEiAAKQAAIiRC48iVvcub741PfiIlICOIp0ECdGoiBSgCACEfIBwgJSAmiKciBEEGdkH8//8fcWooAgAhICAHIAAgCWsiEzYCACAFIBM2AgACQCAdIBNBAWoiESADayIFa0EDSQ0AIA4gBSAVa2ogBSAJaiAFIApJIgcbIgUoAAAgACgAAUcNACAYIABBAWoiBCAGayAGIAhBASAAQQVqIAVBBGogCCAPIAggBxsgCxDNKEEEaiIHEIUSIAMhAQwECwJAIAogH0kEQCAJIB9qIgQpAAAgJFINASAAQQhqIARBCGogCBCAFEEIaiEHIAAgBGshAQNAIAQgC00gACAGTXINBCAAQQFrIgItAAAgBEEBayIELQAARw0EIAdBAWohByACIQAMAAsACyAEICBzQf8BcQ0AICBBCHYiBCAZTQ0AIAQgDmoiBSkAACAkUg0AIABBCGogBUEIaiAIIA8gCxDNKEEIaiEHIBMgBCAVamshAQNAIAUgGk0gACAGTXINAyAAQQFrIgItAAAgBUEBayIFLQAARw0DIAdBAWohByACIQAMAAsACwJAAkACQCABIApLBEAgASAJaiIEKAAAIAAoAABHDQEMAwsgDSAec0H/AXENACAeQQh2IgEgGU0NACABIA5qIgQoAAAgACgAAEYNAQsgACAAIAZrQQh1akEBaiEADAYLIAEgFWohAQsgHCAAKQABIiRC48iVvcub741PfiIlICaIpyIFQQZ2Qfz//x9xaigCACENIBIgJSAjiKdBAnRqIgIoAgAhByACIBE2AgACQCAHIApLBEAgByAJaiIFKQAAICRSDQEgAEEJaiAFQQhqIAgQgBRBCGohByAAQQFqIAVrIQEDQCAFIAtNIABBAWoiBCAGTXINBSAALQAAIAVBAWsiBS0AAEcNBSAAQQFrIQAgB0EBaiEHDAALAAsgBSANc0H/AXENACANQQh2IgIgGU0NACACIA5qIgUpAAAgJFINACAAQQlqIAVBCGogCCAPIAsQzShBCGohByARIAIgFWprIQEDQCAFIBpNIABBAWoiBCAGTXINBCAALQAAIAVBAWsiBS0AAEcNBCAAQQFrIQAgB0EBaiEHDAALAAsgBEEEaiEFIABBBGohAiABIApJBEAgAiAFIAggDyALEM0oQQRqIQcgEyABayEBA0AgBCAaTSAAIAZNcg0DIABBAWsiAi0AACAEQQFrIgQtAABHDQMgB0EBaiEHIAIhAAwACwALIAIgBSAIEIAUQQRqIQcgACAEayEBA0AgBCALTSAAIAZNcg0CIABBAWsiAi0AACAEQQFrIgQtAABHDQIgB0EBaiEHIAIhAAwACwALIBQgAjYCBCAUIAM2AgAgCCAGawwECyAAIQQLIBggBCAGayAGIAggAUEDaiAHEIUSIAMhAiABIQMLIAQgB2oiBiEAIAYgG0sNACASIAkgE0ECaiIEaiIDKQAAQuPIlb3Lm++NT34gI4inQQJ0aiAENgIAIBIgBkECayIAKQAAQuPIlb3Lm++NT34gI4inQQJ0aiAAIAlrNgIAIBcgAyAWIBAQox1BAnRqIAQ2AgAgFyAGQQFrIgAgFiAQEKMdQQJ0aiAAIAlrNgIAA0ACQCACIQAgBiAbSw0AIAwgCSAGIAlrIgUgAGsiBCAKSSICGyAEaiEDIB0gBGtBA0kNACADKAAAIAYoAABHDQAgGEEAIAYgCEEBIAZBBGogA0EEaiAIIA8gCCACGyALEM0oQQRqIgIQhRIgFyAGIBYgEBCjHUECdGogBTYCACASIAYpAABC48iVvcub741PfiAjiKdBAnRqIAU2AgAgAiAGaiEGIAEhAiAAIQEMAQsLIAAhAiABIQMgBiEADAALAAsLuQoCF38CfgJ/IAEhESACIRJBBCAAKALIASIBIAFBBWtBA08bIRUgACgCECICIAQiASADIgQgACgCBCIJa2oiA0EBIAAoArgBdCIGayACIAMgAmsgBksbIAAoAhgbIgwgACgCDCICSQRAIAAoAggiECACIAwgAiAMSxsiDmohEyAJIA5qIQ0gDCAQaiEYIAEgBGoiB0EIayEZIAAoArwBIRYgACgCZCEXIAAoAlwhFCAOQQFrIRpBwAAgACgCwAFrrSEcIBIoAgAhAiASKAIEIQMDQCAEIQECQAJAAkACQANAIAEgGU8NAyAXIAEgFiAVEKMdQQJ0aiIFKAIAIQAgFCABKQAAIh1C48iVvcub741PfiAciKdBAnRqIgooAgAhBiAKIAEgCWsiCjYCACAFIAo2AgACQCACIApBAWoiDyAMa0sNACAaIA8gAmsiBWtBA0kNACAFIBAgCSAFIA5JIggbaiIFKAAAIAEoAAFHDQAgAUEFaiEAIBEgAUEBaiIBIARrIAQgB0EBIAAgBUEEaiAHIBMgByAIGyANEM0oQQRqIgUQhRIgAiEADAMLAkACQCAGIAxNDQAgECAJIAYgDkkiCxsgBmoiCCkAACAdUg0AIAFBCGogCEEIaiAHIBMgByALGyANEM0oQQhqIQUgGCANIAsbIQsgASAEayEPIAogBmshAANAIAggC00gASAETXINAiABQQFrIgMtAAAgCEEBayIILQAARw0CIA9BAWshDyAFQQFqIQUgAyEBDAALAAsCQCAAIAxNDQAgECAJIAAgDkkiCxsgAGoiBigAACABKAAARw0AIBQgASkAASIdQuPIlb3Lm++NT34gHIinQQJ0aiIDKAIAIQggAyAPNgIAAkACQCAIIAxNDQAgECAJIAggDkkiGxsgCGoiAykAACAdUg0AIAFBCWogA0EIaiAHIBMgByAbGyANEM0oQQhqIQUgGCANIBsbIQsgDyAIayEAIAEhBgNAIAMgC00gBCAGQQFqIgFPcg0CIAYtAAAgA0EBayIDLQAARw0CIAZBAWshBiAFQQFqIQUMAAsACyABQQRqIAZBBGogByATIAcgCxsgDRDNKEEEaiEFIBggDSALGyEIIAogAGshAANAIAYgCE0gASAETXINASABQQFrIgMtAAAgBkEBayIGLQAARw0BIAVBAWohBSADIQEMAAsACyARIAEgBGsgBCAHIABBA2ogBRCFEgwDCyABIAEgBGtBCHVqQQFqIQEMAQsLIBEgDyAEIAcgAEEDaiAFEIUSCyACIQMLIAAhAiABIAVqIgQgGUsNAiAUIAkgCkECaiIBaiICKQAAQuPIlb3Lm++NT34gHIinQQJ0aiABNgIAIBQgBEECayIGKQAAQuPIlb3Lm++NT34gHIinQQJ0aiAGIAlrNgIAIBcgAiAWIBUQox1BAnRqIAE2AgAgFyAEQQFrIgEgFiAVEKMdQQJ0aiABIAlrNgIAA0AgBCAZSw0CIBAgCSAEIAlrIgIgAyIBayIGIA5JIgobIAZqIQUgGiAGa0EDSSABIAIgDGtLcg0CIAUoAAAgBCgAAEcNAiARQQAgBCAHQQEgBEEEaiAFQQRqIAcgEyAHIAobIA0QzShBBGoiAxCFEiAXIAQgFiAVEKMdQQJ0aiACNgIAIBQgBCkAAELjyJW9y5vvjU9+IByIp0ECdGogAjYCACADIARqIQQgACEDIAEhAAwACwALIBIgAzYCBCASIAI2AgAgByAEawwDCyAAIQIMAAsACyAAIBEgEiAEIAEQ3i0LC/cIAR9/An8gASERIAIhEkEEIAAoAsgBIgEgAUEFa0EDTxshCyAAIgIoAswBIgZBAUshASAEIAMiBWohCSACKAK0ASINKALAASEOIA0oAgQiEyANKAIMIiJqIRogDSgCACIUIAUgAigCBCIMIAIoAgwiD2oiFWtqIQRBACATIBRrIA9qIhtrAkAgAigC2AFFDQBBBCAOdCEAA0AgACAHTQ0BIAdBQGshBwwACwALIAZBASABGyEcIAlBCGshFiAOQQhqIR0gEigCBCEBIBIoAgAhACACKALAASEQIAIoAlwhFyANKAJcIR4gE2ohIyAPQQFrIR8gDEECaiENIAUgBCAaRmohAgNAAkACQCAFIBxqIgYgFksNACACIBAgCxCjHSEgIB4gAiAdIAsQox0iA0EGdkH8//8fcWooAgAiCCADcyEhIAJBgAJqIQogHCEEAkADQCAXICBBAnRqIg4oAgAhGSAGIgMgECALEKMdISAgAyAdIAsQox0hByAOIAIgDGsiGDYCAAJAIB8gGCAAa0EBaiIGa0EDSQ0AIBMgBiAba2ogBiAMaiAGIA9JIg4bIgYoAAAgAigAAUcNACACQQVqIQMgESACQQFqIgIgBWsgBSAJQQEgAyAGQQRqIAkgFCAJIA4bIBUQzShBBGoiBxCFEgwCCwJAAkAgIUH/AXENACAIQQh2IgYgIk0NACAGIBNqIggoAAAgAigAAEcgDyAZSXINACACQQRqIAhBBGogCSAUIBUQzShBBGohByACIAVrIQogGCAGIBtqayEDA0AgCCAaTSACIAVNcg0CIAJBAWsiAS0AACAIQQFrIggtAABHDQIgCkEBayEKIAdBAWohByABIQIMAAsACwJAIA8gGU8NACAMIBlqIggoAAAgAigAAEcNACACQQRqIAhBBGogCRCAFEEEaiEHIAIgBWshCiACIAhrIQMDQAJAIAggFU0gAiAFTXINACACQQFrIgEtAAAgCEEBayIILQAARw0AIApBAWshCiAHQQFqIQcgASECDAELCyARIAogBSAJIANBA2ogBxCFEiAAIQEgAyEADAMLIAMgBCADIApPIgJqIgRqIgYgFksNAyAKIAJBCHRqIQogHiAHQQZ2Qfz//x9xaigCACIIIAdzISEgAyECDAELCyARIAogBSAJIANBA2ogBxCFEiAAIQEgAyEACyACIAdqIgUhAiAFIBZLDQIgFyANIBhqIBAgCxCjHUECdGogGEECajYCACAXIAVBAmsiAiAQIAsQox1BAnRqIAIgDGs2AgADQCABIQIgBSAWSw0CICMgDCAFIAxrIgMgAmsiBiAPSSIBGyAGaiEEIB8gBmtBA0kNAiAEKAAAIAUoAABHDQIgEUEAIAUgCUEBIAVBBGogBEEEaiAJIBQgCSABGyAVEM0oQQRqIgEQhRIgFyAFIBAgCxCjHUECdGogAzYCACABIAVqIQUgACEBIAIhAAwACwALIBIgATYCBCASIAA2AgAgCSAFawwCCyACIQEgBSECDAALAAsLoQkBIX8CfyABIRkgAiEVQQQgACgCyAEiASABQQVrQQNPGyENIAAoAhAiASADIgUgACgCBCIHayICIARqIgNBASAAKAK4AXQiCGsgASADIAFrIAhLGyAAKAIYGyISIAAoAgwiFk8EQCAAIBkgFSAFIAQQ3BYMAQsgACgCCCITIBYgEiASIBZJGyIOaiEaIAcgDmohGyASIBNqISEgBCAFaiILQQhrIRdBASAAKALMASIBIAFBAU0bQQFqIR4gACgCwAEhDyAAKAJcIQwgFSgCACIAQQAgACACIBJrIgFJIgMbIQJBACAAIAMbIRwgFSgCBCIAQQAgACABSSIDGyEBQQAgACADGyEfIAdBAmohIgNAAkACQCAXIAUgHmoiEEEBaiIJSwRAIAUgDyANEKMdIQAgBUEBaiIEIA8gDRCjHSEYIBMgByAMIABBAnRqKAIAIgYgDkkbIREgAiAHaiEjIAVBgAFqIR0gHiEKIAUhCANAIAkhFCATIAcgDiAQIgMgI2siCUsiJBshIAJ/IAJFIA4gCWtBBElyRQRAIAkgIGooAAAMAQsgAygAAEEBcwsgDCAAQQJ0aiAIIAdrIhA2AgAgAygAAEYEQEEFQQQgA0EBay0AACAJICBqIghBAWstAABGIgAbIQYgCCAAayEJIAMgAGshCiAaIAsgJBshFEEBIREgBCEDIAIhAAwECwJAIAYgEkkNACAIKAAAIAYgEWooAABHDQAgBCEDDAMLIAwgGEECdGoiCCgCACEGIAMgDyANEKMdIQAgCCAEIAdrIhA2AgACQCAGIBJJDQAgBCgAACATIAcgBiAWSRsiESAGaigAAEcNACAAIRggBCEIDAMLIAwgAEECdGooAgAiBiAOSSEEIBQgDyANEKMdIRggEyAHIAQbIREgCiAUaiEJIAMgCmoiECAdTwRAIB1BgAFqIR0gCkEBaiEKCyAUIQQgAyEIIAkgF0kNAAsLIBUgAiAcIAIbNgIAIBUgASAcIB8gAhsgHyAcGyABGzYCBCALIAVrDAMLIBogCyAGIBZJIgAbIRQgISAbIAAbIQEgBiARaiEEIBAgBmsiAEEDaiERQQAhBgNAAkAgBCAGaiIJIAFNIAYgCGoiCiAFTXINACAKQQFrLQAAIAlBAWstAABHDQAgBkEBayEGDAELC0EEIAZrIQYgAiEBCyAZIAogBWsgBSALIBEgBiAKaiAGIAlqIAsgFCAbEM0oIAZqIgIQhRIgAiAKaiIFIANLBEAgDCAYQQJ0aiADIAdrNgIACyAAIQIgBSAXSw0AIAwgECAiaiAPIA0Qox1BAnRqIBBBAmo2AgAgDCAFQQJrIgIgDyANEKMdQQJ0aiACIAdrNgIAA0ACQCABIQIgBSAXSw0AIBMgByAFIAdrIgQgAmsiASAOSSIIGyABaiEDIAJFIAEgDmtBfEtyDQAgAygAACAFKAAARw0AIBlBACAFIAtBASAFQQRqIANBBGogCyAaIAsgCBsgGxDNKEEEaiIBEIUSIAwgBSAPIA0Qox1BAnRqIAQ2AgAgASAFaiEFIAAhASACIQAMAQsLIAIhASAAIQIMAAsACwsgACAAIAFBA3RBOHGtiEKAgIDo+7SND34gAkE/ca2IpwsgAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABEM8oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQFBARDQKAsLHwAgACgCAARAIAAQ3isLIAAoAhAEQCAAQRBqEN4rCwslAQF/IAAoAgAiASABKAIAIgFBAWs2AgAgAUEBRgRAIAAQhh0LCyUBAX8gACgCACIBIAEoAgAiAUEBazYCACABQQFGBEAgABDyJQsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEIQRAQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEIEN4oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQRBBEBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEIQQgQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBAkECEN4oCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBBBDeKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEQQSAQ3igLCyYAIAAgAikCADcCACAAIAEoAgA2AgwgAEEIaiACQQhqKAIANgIACyMBAX8gACgCDCIAIAAoAgAiAUEBajYCACABQQBIBEAACyAACyYBAX8gACgCCCIBQQFNBEBBASABQbD3hQEQwyEACyAAKAIEQQhqCyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIcEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIkEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIoEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAIwEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAI0EQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJEEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJIEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJMEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJQEQQACyMAIAAoAgAgACgCBCIAKAIIQQFrQXhxakEIaiAAKAJUEQQACyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEMEN4oCwslAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBxAAQ3igLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEIENwoCwskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQRBBBDcKAsLJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQ3CgLCyQBAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAFBBEEMENwoCwsqACAAIAEpAxg3AxggACABKQMQNwMQIAAgASkDCDcDCCAAIAEpAwA3AwALJAEBfyAAKAIAIAAoAggiAmsgAUkEQCAAIAIgAUEBQQEQ3igLCyABAX8gACgCACAAKAIIIgJrIAFJBEAgACACIAEQ3ygLC2QBAX8jAEEQayICJAAgAiABNgIMIAIgADYCCCMAQSBrIgAkACAAQQE2AgQgAEGgq4gBNgIAIABCATcCDCAAIAJBCGqtQoCAgIDwKIQ3AxggACAAQRhqNgIIIABBqKuIARDvLAALSQEBfyAAKAIMBEAgAA8LIwBBEGsiAiQAIAJBCGogAUEMaiABKAIUEOoMIAAgAigCCCACKAIMEPsoIAJBEGokACAAQRRBBBD4OgskAQF/IAAoAgAgACgCCCICayABSQRAIAAgAiABQQFBARDhKAsLIwAgAiACKAIEQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgAL3QwDEn8FfgFvIwBBEGsiCyQAIwBBQGoiByQAIAdBKGoiDCAAEIUjIAdBIGogBygCKBCEPCAHQTRqIQMgBygCICIAIQggACAHKAIkQQZ0aiEBIwBBIGsiAiQAIAJBFGogASAIa0EGdkEAQQhBwAAQoBggAigCGCEAIAIoAhRBAUYEQCAAIAIoAhxB5IHDABD9LwALIAJBEGoiDUEANgIAIAIgAigCHDYCDCACIAA2AggjAEEQayIFJAAgASAIa0EGdiIGIAJBCGoiACgCACAAKAIIIgRrSwRAIAAgBCAGQQhBwAAQ0CggACgCCCEECyAFIAAoAgQ2AgwgBSAENgIIIAUgAEEIajYCBCMAQUBqIgAkACAFQQRqIgYoAgQhBCAGKAIAIQ4CQAJAIAEgCEcEQCAGKAIIIARBBnRqIRAgASAIa0EGdiEJQQAhBgNAIABBKGogBiAIaiIBQSBqEMABIAFBEGopAwAhEwJAIAFBLGoiCigCAEGAgICAeEcEQCAAQTRqIAoQkxgMAQsgAEGAgICAeDYCNAsgAUEYaikDACEUIAFBPGooAgAiCiAKKAIAIg9BAWo2AgAgD0EASA0CIABBIGogAEEwaigCACIPNgIAIABBEGoiESAAQTxqKAIANgIAIAAgACkCKCIVNwMYIAAgACkCNDcDCCABQThqKAEAIRIgAUEIaikDACEWIAEpAwAhFyAGIBBqIgFBGGogFDcDACABQRBqIBM3AwAgAUEIaiAWNwMAIAEgFzcDACABQSBqIBU3AwAgAUEoaiAPNgIAIAFBPGogCjYCACABQThqIBI2AgAgAUEsaiAAKQMINwIAIAFBNGogESgCADYCACAGQUBrIQYgBEEBaiEEIAlBAWsiCQ0ACwsgDiAENgIAIABBQGskAAwBCwALIAVBEGokACADQQhqIA0oAgA2AgAgAyACKQIINwIAIAJBIGokACAMEOgqIwBBEGsiACQAAkACQCAHQRhqIgEgAygCCCICIAMoAgBJBH8gAEEIaiADIAJBCEHAABD0FCAAKAIIIgJBgYCAgHhHDQEgAygCCAUgAgs2AgQgASADKAIENgIAIABBEGokAAwBCyACIAAoAgxB1IHDABD9LwALIAcoAhghACAHKAIcIQEjAEEwayICJAAgAiAANgIYIAIgADYCFCACIAE2AhwgAiAAIAFBBnRqNgIgIAJBJGohCSMAQSBrIgEkACABQRRqIAJBFGoiBCgCDCAEKAIEa0EGdkEAQQRBBBCgGCABKAIYIQAgASgCFEEBRgRAIAAgASgCHEHQtMIAEP0vAAsgAUEQaiIKQQA2AgAgASABKAIcNgIMIAEgADYCCCMAQSBrIgAkACAEKAIMIAQoAgRrQQZ2IgUgAUEIaiIDKAIAIAMoAggiCGtLBEAgAyAIIAVBBEEEENAoIAMoAgghCAsgAygCBCEFIABBCGogBEEIaikCADcDACAAIAQpAgA3AwAgACAFNgIcIAAgCDYCGCAAIANBCGo2AhQgAEEUaiEDIwBB0ABrIggkAAJAIAAoAgQiBSAAKAIMIgxGBEAgAygCBCEEDAELIAMoAgggAygCBCIEQQJ0aiEGIAhBEGohDQNAIA0gBUHAAPwKAAAgACAFQUBrIgU2AgQgCEEANgIIIAhBCGoQ0ClBCGoQASEYEN8SIg4gGCYBIAMgBEEBaiIENgIEIAYgDjYCACAGQQRqIQYgBSAMRw0ACwsgAygCACAENgIAIwBBEGsiBSQAIAAoAgwiBCAAKAIEIgNHBEAgBCADa0EGdiEEIANBPGohAwNAIANBHGsiBhCfLCAGEPM7IANBEGsQjjAgAygCACIGIAYoAgAiBkEBazYCACAGQQFGBEAgAxCGHwsgA0FAayEDIARBAWsiBA0ACwsgBSAAKAIANgIMIAUgACgCCDYCCCAFQQhqQQhBwAAQ4B4gBUEQaiQAIAhB0ABqJAAgAEEgaiQAIAlBCGogCigCADYCACAJIAEpAgg3AgAgAUEgaiQAIAJBCGogCUHEssMAEJghIAIgAigCCCACKAIMELU2IAIoAgQhACAHQRBqIgEgAigCADYCACABIAA2AgQgAkEwaiQAIAdBCGogBygCECAHKAIUELU2IAsgBykDCDcCACAHQUBrJAAgCygCACALKAIEIAtBEGokAAv7AgEJfyMAQRBrIgMkACMAQUBqIgEkACABQTBqIgcgABCFIyABQSRqIQQgASgCMCECIwBBIGsiACQAIABBCGoiBSACKAIQNgIEIAUgAigCDEEAIAIoAghBgICAgHhHGzYCAAJAAkACQCAAKAIIIglFBEAgBEGAgICAeDYCAAwBCyAAQRRqIAAoAgwiAkEAQQFBARCgGCAAKAIYIQUgACgCFEEBRg0BIAAoAhwhCCACBEAgCCAJIAL8CgAACyAEIAI2AgggBCAINgIEIAQgBTYCAAsgAEEgaiQADAELIAUgACgCHEG0gsMAEP0vAAsgBxDmKkEAIQAgASgCJEGAgICAeEcEQCABQThqIAFBLGooAgA2AgAgASABKQIkNwMwIAFBGGogB0HUgcMAEJAhIAFBEGogASgCGCABKAIcELU2IAEoAhAhBiABKAIUIQALIAFBCGogBiAAELU2IAMgASkDCDcCACABQUBrJAAgAygCACADKAIEIANBEGokAAv1IAMsfxd+AW8jAEEQayIXJAAjAEFAaiIJJAAgCUEoaiIhIAAQhSMgCUEgaiAJKAIoEIY8IAlBNGohESAJKAIgIgAhFSAAIAkoAiRBwAJsaiEDIwBBIGsiCCQAIAhBFGogAyAVa0HAAm5BAEEIQcACEKAYIAgoAhghACAIKAIUQQFGBEAgACAIKAIcQeSBwwAQ/S8ACyAIQRBqIiJBADYCACAIIAgoAhw2AgwgCCAANgIIIwBBEGsiFiQAIAMgFWtBwAJuIgEgCEEIaiIAKAIAIAAoAggiAmtLBEAgACACIAFBCEHAAhDQKCAAKAIIIQILIBYgACgCBDYCDCAWIAI2AgggFiAAQQhqNgIEQQAhAiMAQfAAayIBJAAgFkEEaiIAKAIEIRggACgCACADIBVHBEAgACgCCCEkIAMgFWtBwAJuISUgAUHeAGohHwNAIBUgGUHAAmxqIgAoArwCIiAgICgCACIDQQFqNgIAAkACfwJAIANBAE4EQCABQShqIABBgAJqENYeAkAgACgCjAJBgICAgHhHBEAgAUE0aiAAQYwCahDdIAwBCyABQYCAgIB4NgI0CyAAKQP4ASE/IAApA/ABIUAgACkD6AEhQSAAKALUASEmIAAoAtABIScgACkD4AEhQiAAKQPYASFDQgAhOkIAITsgACgCAEEBRgRAQgEhOyAAKQMIITQLIAAoAhBBAUYEQEIBITogACkDGCE1C0IIIS0gACkDYCIzQghRDQMCfgJAAkACQAJAAkACQAJAAkAgM6dBAWsOBwECAwQFBgcACyAALQCKASELIAAtAIkBIQwgAC0AiAEhAiAAKQOAASEwIAApA3ghLiAAKQNwITEgACkDaCEvIAAtAI0BIQYgAC0AjAEhBUIAIS0gAUFAayEOIAAtAIsBDAoLIAEgACgCjAEiBUEIdjoAQCAFQRB2IQ0gACgCiAEhAiAALQCbASEGIAAtAJoBIQMgAC0AmQEhByAALQCYASEEIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS8gACgClAEhDyAAKAKQASEQQgEhLQwICyAAQZoBai0AACEDIAAtAKsBIQYgAC0AqgEhEiAALQCpASETIAAtAKgBIRQgACkDoAEhMiAAKAKcASEKIAAvAY4BIQ0gAC0AjAEhBSAAKQOAASEwIAApA3ghLiAAKQNwITEgACkDaCEvIAApA5ABIS0gAC8BmAEgACgCiAEhAiAALQCNASEHIAEgAC0AmwE6ABggASAHOgBAIAJBEHYhCyACQQh2IQwgA0EQdHIiBEEIdiEHIC1CIIinIQ8gLachEEICIS0gAUEIaiEOIAJBGHYMCAtBACEEQQAhAiAAKAKIAUEBRgRAIAAoApQBIQ8gACgCkAEhECAALwGOASENIAAtAIwBIQUgAC0AjQEhA0EBIQILIAAoApgBQQFGBEAgACkCoAEhMiAAKAKcASEKQQEhBAsgASADOgBAIAFBADoAGCAALQCrASEGIAAtAKoBIRIgAC0AqQEhEyAALQCoASEUIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS9CAyEtIAFBCGohDkEAIQtBACEMQQAhA0EAIQdBAAwHCyABIAAoAowBIgVBCHY6AEAgBUEQdiENIAAoApQBIQ8gACgCiAEhAiAALQCbASEGIAAtAJoBIQMgAC0AmQEhByAALQCYASEEIAApA4ABITAgACkDeCEuIAApA3AhMSAAKQNoIS8gACgCkAEhEEIEIS0MBQsgAEGaAWotAAAhAyAALQCrASEGIAAtAKoBIRIgAC0AqQEhEyAALQCoASEUIAApA6ABITIgACgCnAEhCiAALwGOASENIAAtAIwBIQUgACkDgAEhMCAAKQN4IS4gACkDcCExIAApA2ghLyAAKQOQASEtIAAvAZgBIAAoAogBIQIgAC0AjQEhByABIAAtAJsBOgAYIAEgBzoAQCACQRB2IQsgAkEIdiEMIANBEHRyIgRBCHYhByAtQiCIpyEPIC2nIRBCBSEtIAFBCGohDiACQRh2DAULQQAhCkEAIQIgACgCiAFBAUYEQAJAIAAoAowBIgIEQCABQdAAaiAAQZgBaiAAKAKQASAAKAKUASACKAIAEQUADAELIAFBADYCUAtBASECCyAAKAKcAUEBRgRAAkAgACgCoAEiAwRAIAFB4ABqIABBrAFqIAAoAqQBIAAoAqgBIAMoAgARBQAMAQsgAUEANgJgC0EBIQoLQgAhLkIAIS8gACgCaEEBRgRAIAApA3AhMUIBIS8LIAAoAnhBAUYEQCAAKQOAASEwQgEhLgsgASABLQBROgBAIAEgAS0AXzoAGCAALQCzASEGIAAtALIBIRogAC0AsQEhGyAALQCwASEcIB8tAAAhAyABLwFSIQ0gAS0AUCEFIAEoAlQhECABKAJYIQ8gASkDYCEyIAEtAGghFCABLQBpIRMgAS0AaiESIAEvAVwgASABLQBrOgAIIANBEHRyIgRBCHYhByABQc8AaiEOQgYMAQtBACEKQQAhAiAAKAKIAUEBRgRAAkAgACgCjAEiAgRAIAFB0ABqIABBmAFqIAAoApABIAAoApQBIAIoAgARBQAMAQsgAUEANgJQC0EBIQILIAAoApwBQQFGBEACQCAAKAKgASIDBEAgAUHgAGogAEGsAWogACgCpAEgACgCqAEgAygCABEFAAwBCyABQQA2AmALQQEhCgtCACEuQgAhLyAAKAJoQQFGBEAgACkDcCExQgEhLwsgACgCeEEBRgRAIAApA4ABITBCASEuCyABIAEtAFE6AEAgASABLQBfOgAYIAAtALMBIQYgAC0AsgEhGiAALQCxASEbIAAtALABIRwgHy0AACEDIAEvAVIhDSABLQBQIQUgASgCVCEQIAEoAlghDyABKQNgITIgAS0AaCEUIAEtAGkhEyABLQBqIRIgAS8BXCABIAEtAGs6AAggA0EQdHIiBEEIdiEHIAFBzwBqIQ5CBwshLSABKAJsIR5BACELQQAhDEEADAILAAsgAUEYaiEOQQAhC0EAIQxBAAshHSAOIAY6AAAgBEH/AXEgB0H/AXFBCHQgA0EQdHJyIQMgAkH/AXEgC0H/AXFBEHQgHUEYdHIgDEH/AXFBCHRyciEMIAEtAEAhCyABLQAYIQYgAS0ACCEEIAEtAE8hAgsCQCAAKAKYAkGAgICAeEcEQCABQUBrIABBmAJqELUWDAELIAFBgICAgHg2AkALQgAhM0IAITwgACgCIEEBRgRAQgEhPCAAKQMoITYLIAAoArwBIQ4gACgCuAEhHSAAKAIwQQFGBEBCASEzIAApAzghNwsgACgCxAEhByAAKALAASEoQgAhPUIAIT4gACgCQEEBRgRAQgEhPiAAKQNIITgLIAAoAswBISkgACgCyAEhKiAAKAJQQQFGBEBCASE9IAApA1ghOQsCQCAAKAKkAkGAgICAeEcEQCABQdAAaiAAQaQCahClHQwBCyABQYCAgIB4NgJQCwJAIAAoArACQYCAgIB4RwRAIAFB4ABqIABBsAJqEKUdDAELIAFBgICAgHg2AmALIAFBIGoiKyABQTBqKAIANgIAIAFBEGoiLCABQTxqKAIANgIAIAEgASkCKDcDGCABIAEpAjQ3AwggJCAYQcACbGoiAEGaAWogA0EQdjoAACAAIAM7AZgBIAAgPzcD+AEgACBANwPwASAAIEE3A+gBIAAgQjcD4AEgACBDNwPYASAAICY2AtQBIAAgJzYC0AEgACApNgLMASAAICo2AsgBIAAgBzYCxAEgACAoNgLAASAAIA42ArwBIAAgHTYCuAEgACACOgCzASAAIBo6ALIBIAAgGzoAsQEgACAcOgCwASAAIB42AqwBIAAgBDoAqwEgACASOgCqASAAIBM6AKkBIAAgFDoAqAEgACAyNwOgASAAIAo2ApwBIAAgBjoAmwEgACAPNgKUASAAIBA2ApABIAAgDTsBjgEgACALOgCNASAAIAU6AIwBIAAgDDYCiAEgACAwNwOAASAAIC43A3ggACAxNwNwIAAgLzcDaCAAIC03A2AgACA5NwNYIAAgPTcDUCAAIDg3A0ggACA+NwNAIAAgNzcDOCAAIDM3AzAgACA2NwMoIAAgPDcDICAAIDU3AxggACA6NwMQIAAgNDcDCCAAIDs3AwAgAEGIAmogKygCADYCACAAIAEpAxg3A4ACIAAgASkDCDcCjAIgAEGUAmogLCgCADYCACAAIAEpA0A3A5gCIABBoAJqIAFByABqKAIANgIAIAAgASkCUDcCpAIgAEGsAmogAUHYAGooAgA2AgAgAEG4AmogAUHoAGooAgA2AgAgACABKQNgNwOwAiAAICA2ArwCIBhBAWohGCAZQQFqIhkgJUcNAAsLIBg2AgAgAUHwAGokACAWQRBqJAAgEUEIaiAiKAIANgIAIBEgCCkCCDcCACAIQSBqJAAgIRDqKiMAQRBrIgAkAAJAAkAgCUEYaiICIBEoAggiASARKAIASQR/IABBCGogESABQQhBwAIQ9BQgACgCCCIBQYGAgIB4Rw0BIBEoAggFIAELNgIEIAIgESgCBDYCACAAQRBqJAAMAQsgASAAKAIMQdSBwwAQ/S8ACyAJKAIYIQAgCSgCHCECIwBBMGsiASQAIAEgADYCGCABIAA2AhQgASACNgIcIAEgACACQcACbGo2AiAgAUEkaiEHIwBBIGsiAiQAIAJBFGogAUEUaiIDKAIMIAMoAgRrQcACbkEAQQRBBBCgGCACKAIYIQAgAigCFEEBRgRAIAAgAigCHEHQtMIAEP0vAAsgAkEQaiILQQA2AgAgAiACKAIcNgIMIAIgADYCCCMAQSBrIgAkACADKAIMIAMoAgRrQcACbiIGIAJBCGoiBCgCACAEKAIIIgVrSwRAIAQgBSAGQQRBBBDQKCAEKAIIIQULIAQoAgQhBiAAQQhqIANBCGopAgA3AwAgACADKQIANwMAIAAgBjYCHCAAIAU2AhggACAEQQhqNgIUIABBFGohBSMAQdACayIGJAACQCAAKAIEIgMgACgCDCIMRgRAIAUoAgQhBAwBCyAFKAIIIAUoAgQiBEECdGohCCAGQRBqIQoDQCAKIANBwAL8CgAAIAAgA0HAAmoiAzYCBCAGQQA2AgggBkEIahDSKUEIahACIUQQ3xIiDSBEJgEgBSAEQQFqIgQ2AgQgCCANNgIAIAhBBGohCCADIAxHDQALCyAFKAIAIAQ2AgAjAEEQayIFJAAgACgCDCIIIAAoAgQiA2tBwAJuIQQgAyAIRwRAA0AgAxDYEiADQcACaiEDIARBAWsiBA0ACwsgBSAAKAIANgIMIAUgACgCCDYCCCAFQQhqQQhBwAIQ4B4gBUEQaiQAIAZB0AJqJAAgAEEgaiQAIAdBCGogCygCADYCACAHIAIpAgg3AgAgAkEgaiQAIAFBCGogB0HEssMAEJghIAEgASgCCCABKAIMELU2IAEoAgQhACAJQRBqIgIgASgCADYCACACIAA2AgQgAUEwaiQAIAlBCGogCSgCECAJKAIUELU2IBcgCSkDCDcCACAJQUBrJAAgFygCACAXKAIEIBdBEGokAAv9AgEJfyMAQRBrIgMkACMAQUBqIgEkACABQTBqIgcgABCFIyABQSRqIQQgASgCMCECIwBBIGsiACQAIABBCGoiBSACKAKUAjYCBCAFIAIoApACQQAgAigCjAJBgICAgHhHGzYCAAJAAkACQCAAKAIIIgkEQCAAQRRqIAAoAgwiAkEAQQFBARCgGCAAKAIYIQUgACgCFEEBRg0CIAAoAhwhCCACBEAgCCAJIAL8CgAACyAEIAI2AgggBCAINgIEIAQgBTYCAAwBCyAEQYCAgIB4NgIACyAAQSBqJAAMAQsgBSAAKAIcQbSCwwAQ/S8ACyAHEOwqQQAhACABKAIkQYCAgIB4RwRAIAFBOGogAUEsaigCADYCACABIAEpAiQ3AzAgAUEYaiAHQdSBwwAQkCEgAUEQaiABKAIYIAEoAhwQtTYgASgCECEGIAEoAhQhAAsgAUEIaiAGIAAQtTYgAyABKQMINwIAIAFBQGskACADKAIAIAMoAgQgA0EQaiQAC5gHAQ1/IwBBEGsiCyQAIwBBMGsiBSQAIAVBGGoiCiAAEIUjIAVBJGohAyAFKAIYIQAjAEEgayICJAAgAkEIaiAAEIc8ENw7IAIoAgghByACQRRqIAIoAgwiCUEAQQRBDBCgGCACKAIYIQECQCACKAIUQQFHBEAgAigCHCEGAkAgAUUNACAJQQxsIQggBiEAIAEhBANAIAhFDQEgAkEUaiAHEN0gIABBCGogAkEcaigCADYCACAAIAIpAhQ3AgAgAEEMaiEAIAhBDGshCCAHQQxqIQcgBEEBayIEDQALCyADIAk2AgggAyAGNgIEIAMgATYCACACQSBqJAAMAQsgASACKAIcQcSCwwAQ/S8ACyAKEOwqIwBBEGsiACQAAkACQCAFQRBqIgYgAygCCCIBIAMoAgBJBH8gAEEIaiADIAFBBEEMEPQUIAAoAggiAUGBgICAeEcNASADKAIIBSABCzYCBCAGIAMoAgQ2AgAgAEEQaiQADAELIAEgACgCDEHUgcMAEP0vAAsgBSgCECEAIAUoAhQhASMAQRBrIggkACMAQTBrIgIkACACIAA2AiQgAiAANgIgIAIgATYCKCACIAAgAUEMbGo2AiwjAEEQayIJJAAgAkEgaiIEKAIIIQwgBCgCACIKIQAjAEEQayIDJAAgBCgCBCIBIAQoAgwiB0cEQANAIAQgAUEMaiIGNgIEIANBCGogAUEIaigCACINNgIAIAMgASkCADcDACADKAIEIA0QkjUhASADEN47IAAgATYCACAAQQRqIQAgBiIBIAdHDQALCyAJQQhqIgEgADYCBCABIAo2AgAgA0EQaiQAIAkoAgwhAyMAQRBrIgEkACAEQQA2AgggBCgCDCEGIAQoAgQhACAEQQQ2AgAgAUKAgICAwAA3AgggAUEIakEEQQwQ4B4gBEEENgIMIARBBDYCBCAGIABrQQxuIQcgACAGRwRAA0AgABDeOyAAQQxqIQAgB0EBayIHDQALCyABQRBqJAAgAkEUaiIAIAo2AgQgACAMQQNsNgIAIAAgAyAKa0ECdjYCCCAEELogIAlBEGokACACQQhqIABB2K6IARCYISAIQQhqIAIpAwg3AwAgAkEwaiQAIAgoAgwhACAFQQhqIgEgCCgCCDYCACABIAA2AgQgCEEQaiQAIAUgBSgCCCAFKAIMELU2IAsgBSkDADcCACAFQTBqJAAgCygCACALKAIEIAtBEGokAAumBwINfwFvIwBBEGsiCSQAIwBBMGsiBiQAIAZBGGoiByAAEIUjIAYoAhgiASgChAIhACAAIAEoAogCaiEEIwBBIGsiASQAIAFBFGogBCAAa0EAQQFBARCgGCABKAIYIQIgASgCFEEBRgRAIAIgASgCHEHkgcMAEP0vAAsgAUEQaiIIQQA2AgAgASABKAIcNgIMIAEgAjYCCCAEIABrIgUgAUEIaiIDKAIAIAMoAggiAmtLBEAgAyACIAVBAUEBENAoIAMoAgghAgsgACAERwRAIAMoAgQhBANAIAIgBGogAC0AADoAACAAQQFqIQAgAkEBaiECIAVBAWsiBQ0ACwsgAyACNgIIIAZBJGoiAEEIaiAIKAIANgIAIAAgASkCCDcCACABQSBqJAAgBxDsKiAGQRBqIABB1IHDABCQISAGKAIQIQAgBigCFCEBIwBBMGsiAiQAIAIgADYCGCACIAA2AhQgAiABNgIcIAIgACABajYCICMAQSBrIgQkACAEQRRqIAJBFGoiACgCDCAAKAIEa0EAQQRBBBCgGCAEKAIYIQEgBCgCFEEBRgRAIAEgBCgCHEHQtMIAEP0vAAsgBEEQaiIMQQA2AgAgBCAEKAIcNgIMIAQgATYCCCMAQSBrIgMkACAAKAIMIAAoAgRrIgcgBEEIaiIBKAIAIAEoAggiBWtLBEAgASAFIAdBBEEEENAoIAEoAgghBQsgAkEkaiEKIAEoAgQhByADQQhqIABBCGopAgA3AwAgAyAAKQIANwMAIAMgBzYCHCADIAU2AhggAyABQQhqNgIUIANBFGohBSMAQRBrIgckAAJAIAMoAgQiACADKAIMIg1GBEAgBSgCBCEIDAELIAUoAgggBSgCBCIIQQJ0aiELA0AgAyAAQQFqIgE2AgQgAC0AALgQeyEOEN8SIgAgDiYBIAUgCEEBaiIINgIEIAsgADYCACALQQRqIQsgASIAIA1HDQALCyAFKAIAIAg2AgAgByADKAIANgIMIAcgAygCCDYCCCAHQQhqQQFBARDgHiAHQRBqJAAgA0EgaiQAIApBCGogDCgCADYCACAKIAQpAgg3AgAgBEEgaiQAIAJBCGogCkHEssMAEJghIAIgAigCCCACKAIMELU2IAIoAgQhACAGQQhqIgEgAigCADYCACABIAA2AgQgAkEwaiQAIAYgBigCCCAGKAIMELU2IAkgBikDADcCACAGQTBqJAAgCSgCACAJKAIEIAlBEGokAAvkAgELfyMAQRBrIgUkACMAQTBrIgEkACABQRhqIgkgABCHIyABQSRqIQYgASgCGCIAKAIEIQIgAiAAKAIIQQZ0aiEDIwBBIGsiACQAIABBFGogAyACa0EGdkEAQQRBBBCgGCAAKAIYIQQgACgCFEEBRgRAIAQgACgCHEHQwMwAEP0vAAsgAEEQaiIKQQA2AgAgACAAKAIcNgIMIAAgBDYCCCAAQQhqIgQgAyACa0EGdiIHEIUuIAQoAgghCCAEIAIgA0cEfyAHIAhqIAQoAgQgCEECdGohAwNAIAMgAjYCACACQUBrIQIgA0EEaiEDIAdBAWsiBw0ACwUgCAs2AgggBkEIaiAKKAIANgIAIAYgACkCCDcCACAAQSBqJAAgCRD8KiABQRBqIAZBwMDMABCYISABQQhqIAEoAhAgASgCFBC1NiAFIAEpAwg3AgAgAUEwaiQAIAUoAgAgBSgCBCAFQRBqJAALoggBDn8jAEEQayIKJAAjAEEwayIGJAAgBkEYaiILIAAQhyMgBigCGCIAKAIEIQIgAiAAKAIIQRRsaiEFIwBBIGsiACQAIABBFGogBSACa0EUbkEAQQRBFBCgGCAAKAIYIQEgACgCFEEBRgRAIAEgACgCHEG00MwAEP0vAAsgAEEQaiIMQQA2AgAgACAAKAIcNgIMIAAgATYCCCMAQRBrIgQkACAFIAJrQRRuIgcgAEEIaiIDKAIAIAMoAggiAWtLBEAgAyABIAdBBEEUEOEoIAMoAgghAQsgBkEkaiEJIAQgAygCBDYCDCAEIAE2AgggBCADQQhqNgIEIwBBIGsiAyQAIARBBGoiASgCBCEHIAEoAgAhDgJAAkAgAiAFRwRAIAEoAgggB0EUbGohASAFIAJrQRRuIQUDQCACQQxqKAIAIgggCCgCACINQQFqNgIAIA1BAEgNAiADQQxqIAIQvBUgAkEQaigCACENIAEgAykCDDcCACABQRBqIA02AgAgAyAINgIYIAFBCGogA0EUaikCADcCACACQRRqIQIgAUEUaiEBIAdBAWohByAFQQFrIgUNAAsLIA4gBzYCACADQSBqJAAMAQsACyAEQRBqJAAgCUEIaiAMKAIANgIAIAkgACkCCDcCACAAQSBqJAAgCxCAKyAGQRBqIAlBpNDMABCZISAGKAIQIQAgBigCFCECIwBBMGsiASQAIAEgADYCJCABIAA2AiAgASACNgIoIAEgACACQRRsajYCLCMAQRBrIgckACABQSBqIgQoAgghCyAEKAIAIgkhAyAEKAIMGiMAQSBrIgUkACAEKAIEIgAgBCgCDCIMRwRAIAVBDGohCANAIAggACkCADcCACAEIABBFGoiAjYCBCAIQRBqIABBEGooAgA2AgAgCEEIaiAAQQhqKQIANwIAIAVBADYCCCADIAVBCGoQnydBCGoQ/TU2AgAgA0EEaiEDIAIiACAMRw0ACwsgB0EIaiIAIAM2AgQgACAJNgIAIAVBIGokACAHKAIMIQgjAEEQayICJAAgBEEANgIIIAQoAgwhAyAEKAIEIQAgBEEENgIAIAJCgICAgMAANwIIIAJBCGpBBEEUEOAeIARBBDYCDCAEQQQ2AgQgAyAAa0EUbiEFIAAgA0cEQANAIAAQ6SsgAEEUaiEAIAVBAWsiBQ0ACwsgAkEQaiQAIAFBFGoiACAJNgIEIAAgC0EFbDYCACAAIAggCWtBAnY2AgggBBDlICAHQRBqJAAgAUEIaiAAQeDAzAAQmCEgASABKAIIIAEoAgwQtTYgASgCBCEAIAZBCGoiAiABKAIANgIAIAIgADYCBCABQTBqJAAgBiAGKAIIIAYoAgwQtTYgCiAGKQMANwIAIAZBMGokACAKKAIAIAooAgQgCkEQaiQACyUAAkACQAJAIAAtABAOBAACAgECCyAAEN47DwsgAEEMahCsLAsLJgACQAJAAkAgAC0AkAEOBAECAgACCyAAEKItCyAAQYQBahDtOwsLJgACQAJAAkAgAC0AkAEOBAECAgACCyAAEKMtCyAAQYQBahDtOwsLJAACQAJAAkAgAC0AOA4EAQICAAILIAAQ+ywLIABBLGoQ3jsLCygAIAEgACgCAC0AAEECdCIAQaj1wwBqKAIAIABB/PTDAGooAgAQ+zULiAEBA38jAEEQayIBJAAgASAAEPcXIwBBEGsiACQAIAEoAgwiAhCINSACQTBBCBD4OiAAQQhqIAFBCGooAgAiAjYCACAAIAEpAgA3AwAgAgRAIAAoAgQhAwNAIAMQhzUgA0FAayEDIAJBAWsiAg0ACwsgAEEIQcAAEOAeIABBEGokACABQRBqJAALIAAgACgCaCAAKAIIIAAoAiBqIAAoAkBBA3RqakHQAWoLGgAgAEFAaxDjPCAAKQMAQgJSBEAgABCRKgsLGgAgAEFAaxDeOyAAKQMAQgJSBEAgABCRKgsLGgAgAEFAaxDpOyAAKQMAQgJSBEAgABCRKgsLKAAgASAAKAIALQAAQQJ0IgBBgIzPAGooAgAgAEGki88AaigCABD7NQsoACABIAAoAgAtAABBAnQiAEH8jM8AaigCACAAQdyMzwBqKAIAEPs1CygAIAEgACgCAC0AAEECdCIAQcCNzwBqKAIAIABBnI3PAGooAgAQ+zULHQAgACABbEEEaiIAQQQQrjYiASAANgIAIAFBBGoLIQEBfyAAIAAoAgQiAiABajYCBCAAKAIAIAJ0QQAgAWt2CxoAIAIgAWsgACAAIAFqIAJLGyAAIAEgAkkbCxwAIAFBCE8EQCABQQggAhDDIQALIAAgAUECdGoLIAEBf0EBIQEgAEH/AXFBAkcEfyAAEIscQf8BcQUgAQsLKAAgASAAKAIALQAAQQJ0IgBB+Kf+AGooAgAgAEG4p/4AaigCABD7NQsiAQF/IwBBMGsiAiQAIAIgARCAFSAAIAIQnBUgAkEwaiQACyIBAX8jAEEwayICJAAgAiABEIAVIAAgAhCeFSACQTBqJAALIgEBfyMAQTBrIgIkACACIAEQgBUgACACEL0VIAJBMGokAAsiAQF/IwBBMGsiAiQAIAIgARCAFSAAIAIQmhUgAkEwaiQACyIBAX8jAEEwayICJAAgAiABEIAVIAAgAhCbFSACQTBqJAALIgEBfyMAQTBrIgIkACACIAEQgBUgACACEJ0VIAJBMGokAAsgACAAKAJMBEAgAEHMAGoQ1B4LIAAQ2ycgAEFAaxDUHgslAQF/IAAgASgCACIBKAI0IgM2AgQgACABKAIQIAIgA2xqNgIACygAIAEgACgCAC0AAEECdCIAQZTOhwFqKAIAIABBiM6HAWooAgAQ+zULKAAgASAAKAIALQAAQQJ0IgBBsM6HAWooAgAgAEGgzocBaigCABD7NQsjAQF/IAAgASgCAEEIaiICNgIAIAAgAiABKAIEQQJ0ajYCBAsjAQF/IAAgASgCAEEIaiICNgIAIAAgAiABKAIEQQN0ajYCBAsnAQJ+IAEpAxAhAiABKQMYIQMgACABEP4iIAAgAzcDGCAAIAI3AxALIwAgACACNwMIIAAgATcDACAAIAJCP4ciATcDGCAAIAE3AxALIwAgACABNwMAIAAgAUI/hyIBNwMYIAAgATcDECAAIAE3AwgLIwAgAEIANwMYIABCADcDECAAQgA3AwggACABrUL/AYM3AwALJAAgAEIANwMYIABCADcDECAAQgA3AwggACABrUL//wODNwMACyABAX9BASEBIAAoAgAiAEEBcQR/IAEFIAAoAghBAUYLCyMAIAAoAghBgICAgHhHBEAgAEEIakEBQQEQ4B4PCyAAELwqCyUAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgBCAFIAEoAhARCQALIAAgAC0AAEEDRgRAIAAoAgQiABC8KiAAQQxBBBD4OgsLHgAgABCdPCAAKAIMQYGAgIB4RwRAIABBDGoQhjALCx0AIAAoAgBBAkcEQCAAQQRqEIYwIABBEGoQhjALCx8AIAAQyykgACgCQCIABEAgABDpJiAAQRBBBBD4OgsLHgAgACgCAEGAgICAeEcEQCAAEPU7IABBDGoQhTALCyUAIAEgAC0AAEECdCIAQfTnwwBqKAIAIABBzOfDAGooAgAQ+zULJQAgAC0AAEECdCIAQYD2wwBqKAIAIABB1PXDAGooAgAgARCpPQsdACAAKAIcIAFLBEAgACABEMEPDwsgACgCFEECawsZAQF/IAEgA0YEfyAAIAIgARCZJ0UFIAQLCygAIAAgASgCkAM2AgQgACABKAKMA0EAIAEoAogDQYCAgIB4Rxs2AgALKAAgACABKAKcAzYCBCAAIAEoApgDQQAgASgClANBgICAgHhHGzYCAAsoACAAIAEoAogDNgIEIAAgASgChANBACABKAKAA0GAgICAeEcbNgIACygAIAAgASgClAM2AgQgACABKAKQA0EAIAEoAowDQYCAgIB4Rxs2AgALIQAgACABKAIINgIEIAAgASgCBEEAIAEoAgBBBUYbNgIACygAIAAgASgCwAI2AgQgACABKAK8AkEAIAEoArgCQYCAgIB4Rxs2AgALKAAgACABKALMAjYCBCAAIAEoAsgCQQAgASgCxAJBgICAgHhHGzYCAAsdACACQSdOBEAgACABIAIQshAPCyAAIAEgAhCxEAsSACAAQRhqEN47IABBCGoQ3jsLGwAgACgCKCAALQAsIgBBA3YgAEEHcUEAR2pqCx4AIABBQGtBBEEMEOAeIAApAwBCAlIEQCAAEJEqCwslACABIAAtAABBAnQiAEHExc4AaigCACAAQYTFzgBqKAIAEPs1CyUAIAEgAC0AAEECdCIAQcTtzgBqKAIAIABBhO3OAGooAgAQ+zULHQAgAEEEaiABIAKnIgEgASADahDSECAAQQg2AgALIAEBfyMAQRBrIgEkACABIAAgACgCDBD4GCABQRBqJAALGwAgACgCACgCACABKAIAIAJBdGxqQQxrEOwMCxsAIAAoAgAoAgAgASgCACACQXRsakEMaxDrDAsdACAAKQMAQgJSBEAgAEEQahCFMCAAQRxqEIUwCwsjACAAKAIAQYGAgIB4SgRAIAAQ0SsgABDoOyAAQQxqEIYwCwsfACAAQSxqEN0tIAAQhjAgAEEMahCGMCAAQRhqEIYwCyUAIAEgAC0AAEECdCIAQfjs0ABqKAIAIABB2OzQAGooAgAQ+zULJQAgASAALQAAQQJ0IgBB9O3QAGooAgAgAEGY7dAAaigCABD7NQshACAAIAEgAi8BABC1LDYCACABEP0YGiAAIAJBBGo2AgQLIAEBfyABKAIAIgIEQCABKAIIIAAgAhECAA8LIAAQhi8LGgEBfyAAKAIAQQFGBH8gASAAKAIMbgUgAgsLIQAgACABIAIoAgQQtiw2AgAgARD9GBogACACQQhqNgIECyEAAkAgAQ0AIAAoAgBBAUcNACACQQI2AgAgAEEANgIACwsfACAAQQEgACgCAEGngwFsIgAgAEEBTRsiADYCACAACyUAIAEgAC0AAEECdCIAQfin/gBqKAIAIABBuKf+AGooAgAQ+zULJQAgASAALQAAQQJ0IgBBpLL+AGooAgAgAEGIsv4AaigCABD7NQslACABIAAtAABBAnQiAEHcsv4AaigCACAAQcCy/gBqKAIAEPs1CyUAIAEgAC0AAEECdCIAQaSz/gBqKAIAIABB+LL+AGooAgAQ+zULHQAgACgCACgCACABKAIAIAJBsH9sakHQAGsQjQ4LJQAgASAALQAAQQJ0IgBBrLSAAWooAgAgAEGctIABaigCABD7NQsbACAAKAIAKAIAIAEoAgAgAkFQbGpBMGsQrQwLCgAgACABEKM9AAslACABIAAtAABBAnQiAEHshIcBaigCACAAQdyEhwFqKAIAEPs1CyUAIAEgAC0AAEECdCIAQbDOhwFqKAIAIABBoM6HAWooAgAQ+zULJQAgASAALQAAQQJ0IgBBrNWHAWooAgAgAEGc1YcBaigCABD7NQslACABIAAtAABBAnQiAEGs54cBaigCACAAQZznhwFqKAIAEPs1CyUAIAEgAC0AAEECdCIAQczshwFqKAIAIABBvOyHAWooAgAQ+zULIwEBfyAAKAIAIgEgASgCAEEBayIBNgIAIAFFBEAgABCYKQsLJAAgAEUEQEHwrIgBQTIQlz0ACyAAIAIgAyAEIAEoAhARgwEACyQAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgBCABKAIQEYUBAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEFAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEKAAsjACAARQRAQfCsiAFBMhCXPQALIAAgAiADIAQgASgCEBEsAAsoAQF/IAAoAgAiAUGAgICAeHJBgICAgHhHBEAgACgCBCABQQEQ+DoLCyUAIAEgAC0AAEECdCIAQfS+iQFqKAIAIABBzL2JAWooAgAQ+zULHgAgACABQQNyNgIEIAAgAWoiACAAKAIEQQFyNgIECxkBAX8gASADTwR/IAIgACADEJknRQUgBAsLHwAgACgCAEGAgICAeEcEQCAAEOkrDwsgAEEEahDuDQsVACAALQAUQQRGBEAgAEEYahDeOwsLFQAgAC0ACEEERgRAIABBDGoQ3jsLCxsAIAApAwBCA1IEQCAAEKkeDwsgAEEIahChKQsVACAAKAIAQQJHBEAgAEEQahDeOwsLHwACQCAAKAIARQ0AIAAoAgQiAEGEAUkNACAAEPIfCwseACAAQQA2AgwgACABNgIIIAAgASgCKEVBAXQ2AgALIAAgAEEBaiABIAAtAABBAnRBoITEAGooAgAoAhARAgALHwAgACkDAEIEUgRAIAAQkiogACgCQEGAEEECEPg6CwsXACAAQTRqEN47IABBKGoQlAwgABCTJwsVACAALQAAQQpGBEAgAEEEahDeOwsLFwAgAEE0ahDeOyAAQShqEJUMIAAQkycLGQAgACgCCEGAgICAeEcEQCAAQQhqEN47CwsfACAAKQMAQgRSBEAgABClISAAKAJAQYAQQQIQ+DoLCxcAIABBNGoQ3jsgAEEoahCdDCAAEJMnCx0BAX8gACgCBCIBBEAgACgCACABQQF0QQIQ+DoLCx0BAX8gACgCBCIBBEAgACgCACABQQJ0QQQQ+DoLCxwBAX8gAEEEaiIAQQQQrTYiASAANgIAIAFBBGoLHQAgACABIAIgAyAEIAVBACAGIAcgCCAJIAoQ2AgLHQAgACABIAIgAyAEIAVBASAGIAcgCCAJIAoQ2AgLGQAgACgCDEGAgICAeEcEQCAAQQxqEN47CwsXACAAEN47IAAoAgwEQCAAQQxqEM8vCwsgAQF/IAAgASgCBCICNgIAIAAgAiABKAIIQWBxajYCBAsgAQF/IAAgASgCBCICNgIAIAAgAiABKAIIQXBxajYCBAscACAAIAFBMGtB/wFxIgE2AgQgACABQQpJNgIACxwAIAAgAUEwa0H/AXEiATsBAiAAIAFBCkk7AQALIAEBfyAAIAEoAgQiAjYCACAAIAIgASgCCEF8cWo2AgQLIAEBfyAAIAEoAgQiAjYCACAAIAIgASgCCEF4cWo2AgQLGgAgAEEMahDUHiAAKAIYBEAgAEEYahDUHgsLGgAgAEEMahD5IyAAKAIUBEAgAEEUahDUHgsLIwAgAUGAzocBQfrNhwEgACgCAC0AACIAG0EFQQYgABsQ+zULHwAgAEIANwMYIABCADcDECAAQgA3AwggACABrTcDAAsgACAAIAEoAgwiACAAIAEoAhBqIAEoAgQgASgCCBC/GAsfACAARQRAQaypiAFBMhCXPQALIAAgAiABKAIQEQAACyEAIABFBEBB8KyIAUEyEJc9AAsgACACIAMgASgCEBEBAAsdACABKAIABEAgAEHstYkBNgIEIAAgATYCAA8LAAscAQF/IAAoAgAiAgRAIAEgAiAAKAIEEPs1DwsACyQAIAAtAABFBEAgAUGE94kBQQUQ1gkPCyABQYn3iQFBBBDWCQsfACAAEN8SIgAgAiYBIAEQ3xIiASADJgEgACABEJcvCxwAIAAtAJQDQQNGBEAgABDIIyAAQYgDahDkKgsLHgAgABD5JSAAKAIUQYGAgIB4RwRAIABBFGoQ9S4LCx8AIAAoAgBBgICAgHhHBEAgABCBIyAAQQRBCBDgHgsLGwAgACgCACIABEAgABD8LCAAQYgCQQgQ+DoLCxwAIAEgAhDoE0UEQCAAIAEQ2RwPCyAAQg03AwALHAAgASACEPMVRQRAIAAgARD3FA8LIABBCTYCAAsdACAARQRAQdjiwwBBMhCXPQALIAAgASgCEBEDAAsbACABQRh0QQAgAUGA/P//A3FBgLADRhsgAHILHgAgACABKAIAIgFBGHY6AAQgACABQf///wdxNgIACxgAIABBAXEEQCABDwtBsMfMAEExEJc9AAsbAQF/IAAgARCtNiICRQRAIAEgABCjPQALIAILGwEBf0EUQQQQrTYiAEUEQEEEQRQQoz0ACyAACx0BAX9BxABBBBCtNiIARQRAQQRBxAAQoz0ACyAACxsBAX9BBEEEEK02IgBFBEBBBEEEEKM9AAsgAAsbAQF/QRxBBBCtNiIARQRAQQRBHBCjPQALIAALGAAgAUEYaiACIANBA3QQoTYgAEEINgIACxgAIAFBGGogAiADQQJ0EKE2IABBCDYCAAsaACAAKAIIIAAoAiBqIAAoAkBBA3RqQeAAagsfACAAKAIAQYCAgIB4RwRAIAAQ4CkgAEEEQRgQ4B4LCxkAIwBBEGskAEHtjc4AQQ9BnI7OABCfKQALGQAjAEEQayQAQe2NzgBBD0H8jc4AEJ8pAAsYACABIAIgAiADQQN0ahC9JiAAQQg2AgALGAAgASACIAIgA0ECdGoQvSYgAEEINgIACxkAIwBBEGskAEHtjc4AQQ9BjI7OABCfKQALGwAgACgCACgCACABKAIAIAJBBHRrQRBrEOcLCxsAIAAoAgAoAgAgASgCACACQQZ0a0FAahDuCwseACAAKAIAQYGAgIB4RwRAIABBDGoQnQwgABDJKAsLIAAgACgCAEGAgICAeEcEQCAAEPcdIABBBEHgABDgHgsLHwAgACgCAEGAgICAeEcEQCAAEMYqIABBBEEMEOAeCwsfACAAKAIAQYCAgIB4RwRAIAAQxyogAEEEQQwQ4B4LCyAAIAAoAgBBgICAgHhHBEAgABD0GyAAQQhB0AAQ4B4LCyIAIABBADsBcCAAQYCAgIB4NgJgIABBADYCCCAAQQA2AgALHAAgASACEKkgRQRAIAAgARDfHA8LIABCDTcDAAsgACAAQQA6AAQgAEGAgAE7AAUgAEEEOwECIABBADoAAAsbACAAKAIAKAIAIAEoAgAgAkEEdGtBEGsQjQ4LIgAgACACNgIUIAAgATYCECAAQgQ3AgggAEKFgICACDcCAAsbACAAKAIAKAIAIAEoAgAgAkEDdGtBCGsQrgwLGwAgACgCACgCACABKAIAIAJBA3RrQQhrEK8MCxsAIAAoAgAoAgAgASgCACACQQN0a0EIaxCrDAsbACAAKAIAKAIAIAEoAgAgAkEEdGtBEGsQrAwLGwAgACgCACgCACABKAIAIAJBBXRrQSBrELAMC4MBAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBEKKos3losKqiWqFIANCi7L53s2au945hYRQGyIARQRAQcjwgwFBDUHY8IMBEMskAAsgAAuFAQIBfwJ+IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAAgAikDGCEDIAIpAxAhBCACQSBqJAAgAEEAIARC/9nrqtfYi4zxAIUgA0KB9OGjqvjW6ot/hYRQGyIARQRAQZDygwFBFUGo8oMBEMskAAsgAAuEAQIBfwJ+IwBBIGsiAiQAIAJBCGogACABKAIQEQAAIAJBEGogAigCCCIAIAIoAgwoAgwRAAAgAikDGCEDIAIpAxAhBCACQSBqJAAgAEEAIARClY2j2tTIv9zGAIUgA0Kzz/m4y5qOxTKFhFAbIgBFBEBB4PKDAUEJQezygwEQyyQACyAAC4QBAgF/An4jAEEgayICJAAgAkEIaiAAIAEoAhARAAAgAkEQaiACKAIIIgAgAigCDCgCDBEAACACKQMYIQMgAikDECEEIAJBIGokACAAQQAgBEK+uaqJmdKNmuAAhSADQsWRgbqRwsPNNIWEUBsiAEUEQEGk9IMBQQxBsPSDARDLJAALIAALHAAgASgCACIBRQRAIABBADYCAA8LIAAgARDlOgscACAAIAEpAgA3AgAgAEEIaiABQQhqKAIANgIACxsBAX8gAEEEEK02IgFFBEBBBCAAEKM9AAsgAQsbAQF/QRBBBBCtNiIARQRAQQRBEBCjPQALIAALGwEBf0EMQQQQrTYiAEUEQEEEQQwQoz0ACyAACx4AIABCADcDGCAAQgA3AxAgAEIANwMIIAAgATcDAAsdAQF/IAAoAgQiAQRAIAAoAgggASAAKAIAEPg6CwshACAAQQA2AgwgACADNgIIIAAgAjYCBCAAQdCFiAE2AgALHgAgACABKAIAJQEQPDYCCCAAQQA2AgQgACABNgIACx8AIABFBEBB8KyIAUEyEJc9AAsgACACIAEoAhARAgALHAAgACAALQAEIAFBLkZyOgAEIAAoAgAgARCDNgscACAAQQxqIAAoAgQgACgCCCAAKAIAKAIQEQEACxoAIAAQkT4gACgCACIAQYQBTwRAIAAQ8h8LCxcAIABBAXEEQEHU28MAQTEQlz0ACyABC38CAn8BfkH484oBKAIARQRAIwBBEGsiASQAQYj0igECfgJAIABFDQAgACgCACAAQgA3AwBBAXFFDQAgACkDCCEDIAApAxAMAQsgARDjJiABKQMAIQMgASkDCAs3AwBBgPSKASADNwMAQfjzigFCATcDACABQRBqJAALQYD0igELyAMCA34Gf0G474oBKAIARQRAIwBBMGsiBiQAAn8gAEUEQEH40cwAIQRBAAwBCyAAKAIAIQQgAEEANgIAIABBCGpB+NHMACAEQQFxIgUbIQQgACgCBEEAIAUbCyEFIAZBEGogBEEIaikCACICNwMAIAYgBCkCACIDNwMIIAZBKGpByO+KASkCADcDACAGQSBqIgBBwO+KASkCADcDAEG474oBKQIAIQFBvO+KASAFNgIAQbjvigFBATYCAEHA74oBIAM3AgBByO+KASACNwIAIAYgATcDGCABpwRAAkAgACgCBCIHRQ0AIAAoAgwiCARAIAAoAgAiBEEIaiEFIAQpAwBCf4VCgIGChIiQoMCAf4MhAQNAIAFQBEADQCAEQeAAayEEIAUpAwAgBUEIaiEFQoCBgoSIkKDAgH+DIgFCgIGChIiQoMCAf1ENAAsgAUKAgYKEiJCgwIB/hSEBCyAEIAF6p0EDdkF0bGpBBGsoAgAiCUGEAU8EQCAJEPIfCyABQgF9IAGDIQEgCEEBayIIDQALCyAHIAdBDGxBE2pBeHEiBGpBCWoiBUUNACAAKAIAIARrIAVBCBD4OgsLIAZBMGokAAtBvO+KAQsWACAAEOY8IABBDGoiABDFJyAAEOg7Cw8AIAAQ6TsgAEEMahDeOwsPACAAEOM8IABBDGoQ3jsLGwAgABCdLCAAQeAAaiIAENwlIABBBEEQEOAeCx0AIAEgACgCAC0AAEECdEHkjc8AaigCAEEIEPs1CxwBAX8gARDSPSECIAAgATYCBCAAIAJBAEc2AgALHQAgACABNgIAIAAgASgCCDYCDCAAIAEpAgA3AgQLFgAgACABIAIQmSciAEEASiAAQQBIawsZACAAIAEgAiADIAQgBSAGIAdBAEEDELwCCxkAIAAgASACIAMgBCAFIAYgB0EAQQQQvAILGQAgACABIAIgAyAEIAUgBiAHQQBBBRC8AgsZACAAIAEgAiADIAQgBSAGIAdBAEEGELwCCxkAIAAgASACIAMgBCAFIAYgB0EBQQMQvAILGQAgACABIAIgAyAEIAUgBiAHQQFBBBC8AgsZACAAIAEgAiADIAQgBSAGIAdBAUEFELwCCxkAIAAgASACIAMgBCAFIAYgB0EBQQYQvAILGQAgACABIAIgAyAEIAUgBiAHQQJBAxC8AgsZACAAIAEgAiADIAQgBSAGIAdBAkEEELwCCxkAIAAgASACIAMgBCAFIAYgB0ECQQUQvAILGQAgACABIAIgAyAEIAUgBiAHQQJBBhC8AgsQACABBEAgACACIAH8CwALCxoAIABCADcCCCAAQgU3AgAgAEEQakEAOwEACxoAIABCADcCCCAAQgo3AgAgAEEQakEAOwEACxoAIABCADcCCCAAQgM3AgAgAEEQakEAOwEACxcAIAAQzy8gACgCFARAIABBFGoQzy8LCx0AIABBATYCACAAIAEoAgg2AgwgACABKQIANwIECx0AIAAoAghFBEBBAEEAQbD3hQEQwyEACyAAKAIECx0BAX8gACABKAIEIgI2AgAgACACIAEoAghqNgIECxcAIAAQ1B4gACgCFARAIABBFGoQ1B4LCxkAIAAgASgCACIAQRhqQQAgACgCGBsQ7iULFQAgACABQQN2IAFBB3FBAEdqENIfCxMAIAAgAWpBAWtBACABa3EgAGsLHAAgACgCACIAKAIAIAEgAEEEaigCACgCDBECAAsbACAAKAIIKAIAKAIQBEBB8LKJARCbPgALQQALGgEBfyAAKAIAIgEEQCAAKAIEIAFBARD4OgsLGwAgACgCCCgCACgCEARAQfCyiQEQmz4AC0EAC0IAIAAEQCAAIAEQoz0ACyMAQSBrIgAkACAAQQA2AhggAEEBNgIMIABBoMGJATYCCCAAQgQ3AhAgAEEIaiACEO8sAAsdAEMAAAAAQwAAAAAgACAAQwAAAABdGyAAIABcGwscAQFvIAAlASAAEPIfEAchARDfEiIAIAEmASAAC5wBAQN/EN8SIgMgACYBIwBB8AJrIgIkACACQQA6AOgCIAIgATYC5AIgAiADNgLgAiMAQYADayIBJAAgAUEIaiIEIAJB8AL8CgAAIAFCATcDACABIAE2AvwCIAFB/AJqQeTHwgAQkz0hAwJAIAEpAwBQDQAgAS0A8AJBA0cNACAEEMopCyABQYADaiQAIAJB8AJqJAAgAyUBIAMQ8h8L4AEBA38Q3xIiAyABJgECfyMAQUBqIgIkACACQQRqIAAQ0SQgAigCBCgCACIAIAAoAgBBAWoiBDYCACAEBEAgAkEAOgA8IAIgAzYCFCACIAA2AhAjAEFAaiIAJAAgAEEMaiIDIAJBEGpBMPwKAAAgAEEBNgIIIAAgAEEIajYCPCAAQTxqQazdwwAQkz0gACgCCARAIAMQ3h8LIABBQGskACACKAIIQQA2AgAgAigCDCIAIAAoAgBBAWsiADYCACAARQRAIAJBDGoQ5yYLIAJBQGskAAwBCwALIgAlASAAEPIfC7wBAQJ/EN8SIgMgASYBIwBBIGsiAiQAIAAQySEhACACQQA6ABwgAiADNgIEIAIgADYCACMAQTBrIgAkACAAQSRqIAJBGGopAgA3AgAgAEEcaiACQRBqKQIANwIAIABBFGogAkEIaikCADcCACAAQQE2AgggACACKQIANwIMIAAgAEEIajYCLCAAQSxqQcDdwwAQkz0hAyAAKAIIBEAgAEEMahDaHAsgAEEwaiQAIAJBIGokACADJQEgAxDyHwu3AgEEfxDfEiIEIAEmAQJ/IwBB4ABrIgIkACACQRBqIAAQ0SQgAigCECIAKAIIIgMgAygCAEEBaiIFNgIAIAUEQCACQQhqEIgdIAJBADoAXCACIAQ2AiQgAiADNgIgIAIgAigCDDYCHCAAQRBqIQMgAigCCCEEAkAgACgCECIARQ0AIAAgACgCACIAQQFrNgIAIABBAUcNACADEOknCyADIAQ2AgAjAEHQAGsiACQAIABBCGoiAyACQRxqQcQA/AoAACAAQQE2AgQgACAAQQRqNgJMIABBzABqQZjdwwAQkz0gACgCBARAIAMQ3xQLIABB0ABqJAAgAigCFEEANgIAIAIoAhgiACAAKAIAQQFrIgA2AgAgAEUEQCACQRhqEOoZCyACQeAAaiQADAELAAsiACUBIAAQ8h8LswIBBH8Q3xIiBCABJgECfyMAQdAAayICJAAgAkEUaiAAENEkIAIoAhQiACgCACIDIAMoAgBBAWoiBTYCACAFBEAgAkEIahCIHSACQQA6AEwgAiAENgIoIAIgAzYCJCACIAIoAgw2AiAgAEEEaiEDIAIoAgghBAJAIAAoAgQiAEUNACAAIAAoAgAiAEEBazYCACAAQQFHDQAgAxDpJwsgAyAENgIAIwBBQGoiACQAIABBDGoiAyACQSBqQTD8CgAAIABBATYCCCAAIABBCGo2AjwgAEE8akHU3cMAEJM9IAAoAggEQCADENMWCyAAQUBrJAAgAigCGEEANgIAIAIoAhwiACAAKAIAQQFrIgA2AgAgAEUEQCACQRxqEO8dCyACQdAAaiQADAELAAsiACUBIAAQ8h8LFgAgACgCAEGAgICAeEcEQCAAEOM8CwsWACAAKAIAQYCAgIB4RwRAIAAQ3jsLCxsAIAAoAgBBgICAgHhHBEAgABDgKSAAEPI7CwsfACAAQQhqQZzKwgApAgA3AgAgAEGUysIAKQIANwIACx8AIABBCGpBrMrCACkCADcCACAAQaTKwgApAgA3AgALFQAgAC0AGEEDRgRAIABBFGoQriwLCxYAIAAtAIQDQQNGBEAgAEEIahD2LAsLFQAgAC0ALEEDRgRAIABBCGoQoCULCx8AIABBCGpB9N/CACkCADcCACAAQezfwgApAgA3AgALFgAgACgCAEGAgICAeEcEQCAAEOo7CwsbACAAKAIAQYCAgIB4RwRAIAAQ0C4gABDqOwsLHwAgAEEIakGIiMMAKQIANwIAIABBgIjDACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQ6zsLCxsAIAAoAgBBgICAgHhHBEAgABD0GyAAEO87CwsfACAAQQhqQZimwwApAgA3AgAgAEGQpsMAKQIANwIACx8AIABBCGpBqKbDACkCADcCACAAQaCmwwApAgA3AgALHwAgAEEIakG4psMAKQIANwIAIABBsKbDACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQ8DsLCxYAIAAoAgBBgICAgHhHBEAgABDpOwsLGwAgACgCAEGAgICAeEcEQCAAENErIAAQ6DsLCx8AIABBCGpBkNvDACkCADcCACAAQYjbwwApAgA3AgALHwAgAEEIakG848MAKQIANwIAIABBtOPDACkCADcCAAsfACAAQQhqQczjwwApAgA3AgAgAEHE48MAKQIANwIACx8AIABBCGpB3OPDACkCADcCACAAQdTjwwApAgA3AgALHwAgAEEIakHs48MAKQIANwIAIABB5OPDACkCADcCAAsfACAAQQhqQaTowwApAgA3AgAgAEGc6MMAKQIANwIACx8AIABBCGpBrPfDACkCADcCACAAQaT3wwApAgA3AgALHwAgAEEIakG898MAKQIANwIAIABBtPfDACkCADcCAAsfACAAQQhqQcz3wwApAgA3AgAgAEHE98MAKQIANwIACx8AIABBCGpB3PfDACkCADcCACAAQdT3wwApAgA3AgALHwAgAEEIakHs98MAKQIANwIAIABB5PfDACkCADcCAAsfACAAQQhqQfz3wwApAgA3AgAgAEH098MAKQIANwIACx8AIABBCGpBjPjDACkCADcCACAAQYT4wwApAgA3AgALGgAgAEEANgIIIABCATcCACAAIAEpAgA3AhALHwAgAEEIakGYx8wAKQIANwIAIABBkMfMACkCADcCAAsfACAAQQhqQYj8zAApAgA3AgAgAEGA/MwAKQIANwIACx8AIABBCGpBmPzMACkCADcCACAAQZD8zAApAgA3AgALHwAgAEEIakGo/MwAKQIANwIAIABBoPzMACkCADcCAAsfACAAQQhqQbj8zAApAgA3AgAgAEGw/MwAKQIANwIACx8AIABBCGpByPzMACkCADcCACAAQcD8zAApAgA3AgALHwAgAEEIakHY/MwAKQIANwIAIABB0PzMACkCADcCAAsfACAAQQhqQej8zAApAgA3AgAgAEHg/MwAKQIANwIACx8AIABBCGpB+PzMACkCADcCACAAQfD8zAApAgA3AgALHwAgAEEIakGI/cwAKQIANwIAIABBgP3MACkCADcCAAsfACAAQQhqQZj9zAApAgA3AgAgAEGQ/cwAKQIANwIACx8AIABBCGpBqP3MACkCADcCACAAQaD9zAApAgA3AgALHwAgAEEIakG4/cwAKQIANwIAIABBsP3MACkCADcCAAsWACAAKAIAQYCAgIB4RwRAIAAQnTwLCx8AIABBCGpBuK3NACkCADcCACAAQbCtzQApAgA3AgALHwAgAEEIakHIrc0AKQIANwIAIABBwK3NACkCADcCAAsfACAAQQhqQditzQApAgA3AgAgAEHQrc0AKQIANwIACx8AIABBCGpB6K3NACkCADcCACAAQeCtzQApAgA3AgALHwAgAEEIakH4rc0AKQIANwIAIABB8K3NACkCADcCAAsfACAAQQhqQYiuzQApAgA3AgAgAEGArs0AKQIANwIACx8AIABBCGpBmK7NACkCADcCACAAQZCuzQApAgA3AgALHwAgAEEIakGors0AKQIANwIAIABBoK7NACkCADcCAAsfACAAQQhqQbiuzQApAgA3AgAgAEGwrs0AKQIANwIACx8AIABBCGpByK7NACkCADcCACAAQcCuzQApAgA3AgALHwAgAEEIakHYrs0AKQIANwIAIABB0K7NACkCADcCAAsfACAAQQhqQeiuzQApAgA3AgAgAEHgrs0AKQIANwIACx8AIABBCGpB+K7NACkCADcCACAAQfCuzQApAgA3AgALHwAgAEEIakGIr80AKQIANwIAIABBgK/NACkCADcCAAsfACAAQQhqQaitzQApAgA3AgAgAEGgrc0AKQIANwIACx8AIABBCGpBmK/NACkCADcCACAAQZCvzQApAgA3AgALHwAgAEEIakGor80AKQIANwIAIABBoK/NACkCADcCAAsfACAAQQhqQbivzQApAgA3AgAgAEGwr80AKQIANwIACx8AIABBCGpByK/NACkCADcCACAAQcCvzQApAgA3AgALHwAgAEEIakHYr80AKQIANwIAIABB0K/NACkCADcCAAsfACAAQQhqQeivzQApAgA3AgAgAEHgr80AKQIANwIACx8AIABBCGpB+K/NACkCADcCACAAQfCvzQApAgA3AgALHwAgAEEIakGIsM0AKQIANwIAIABBgLDNACkCADcCAAsfACAAQQhqQZiwzQApAgA3AgAgAEGQsM0AKQIANwIACx8AIABBCGpBqLDNACkCADcCACAAQaCwzQApAgA3AgALHwAgAEEIakG4sM0AKQIANwIAIABBsLDNACkCADcCAAsfACAAQQhqQciwzQApAgA3AgAgAEHAsM0AKQIANwIACx8AIABBCGpB2LDNACkCADcCACAAQdCwzQApAgA3AgALHwAgAEEIakGYrc0AKQIANwIAIABBkK3NACkCADcCAAsfACAAQQhqQeiwzQApAgA3AgAgAEHgsM0AKQIANwIACx8AIABBCGpB+LDNACkCADcCACAAQfCwzQApAgA3AgALHwAgAEEIakGIsc0AKQIANwIAIABBgLHNACkCADcCAAsfACAAQQhqQZixzQApAgA3AgAgAEGQsc0AKQIANwIACx8AIABBCGpBqLHNACkCADcCACAAQaCxzQApAgA3AgALHwAgAEEIakG4sc0AKQIANwIAIABBsLHNACkCADcCAAsfACAAQQhqQcixzQApAgA3AgAgAEHAsc0AKQIANwIACx8AIABBCGpB2LHNACkCADcCACAAQdCxzQApAgA3AgALHwAgAEEIakHosc0AKQIANwIAIABB4LHNACkCADcCAAsfACAAQQhqQdCyzQApAgA3AgAgAEHIss0AKQIANwIACx8AIABBCGpB4LLNACkCADcCACAAQdiyzQApAgA3AgALHwAgAEEIakHwss0AKQIANwIAIABB6LLNACkCADcCAAsfACAAQQhqQYCzzQApAgA3AgAgAEH4ss0AKQIANwIACx8AIABBCGpBsPHNACkCADcCACAAQajxzQApAgA3AgALGQAgACgCCCIAQfgAakEAIABBgICAgHhHGwsWACAAQQRqIAEgAqcQ6hQgAEEINgIACx8AIABBCGpBwJzPACkCADcCACAAQbiczwApAgA3AgALHwAgAEEIakHQnM8AKQIANwIAIABByJzPACkCADcCAAsfACAAQQhqQeCczwApAgA3AgAgAEHYnM8AKQIANwIACx8AIABBCGpB8JzPACkCADcCACAAQeiczwApAgA3AgALHwAgAEEIakGAnc8AKQIANwIAIABB+JzPACkCADcCAAsfACAAQQhqQZCdzwApAgA3AgAgAEGInc8AKQIANwIACx8AIABBCGpBoJ3PACkCADcCACAAQZidzwApAgA3AgALHwAgAEEIakGwnc8AKQIANwIAIABBqJ3PACkCADcCAAsfACAAQQhqQcCdzwApAgA3AgAgAEG4nc8AKQIANwIACx8AIABBCGpB0J3PACkCADcCACAAQcidzwApAgA3AgALHwAgAEEIakHgnc8AKQIANwIAIABB2J3PACkCADcCAAsfACAAQQhqQfCdzwApAgA3AgAgAEHonc8AKQIANwIACx8AIABBCGpBgJ7PACkCADcCACAAQfidzwApAgA3AgALHwAgAEEIakGQns8AKQIANwIAIABBiJ7PACkCADcCAAsfACAAQQhqQaCezwApAgA3AgAgAEGYns8AKQIANwIACxcAIAAQnQwgAEEYahC8KiAAQQxqEJ0MCxgAIAAQgSMgAEEEQQgQ4B4gAEEMahCdDAsbACAAKAIAQYCAgIB4RwRAIAAQ1ysgABDoOwsLHwAgAEEIakHEoNAAKQIANwIAIABBvKDQACkCADcCAAsfACAAQQhqQdSg0AApAgA3AgAgAEHMoNAAKQIANwIACx8AIABBCGpB5KDQACkCADcCACAAQdyg0AApAgA3AgALHwAgAEEIakG8otAAKQIANwIAIABBtKLQACkCADcCAAsfACAAQQhqQcyi0AApAgA3AgAgAEHEotAAKQIANwIACx8AIABBCGpBkODQACkCADcCACAAQYjg0AApAgA3AgALHwAgAEEIakHY7tAAKQIANwIAIABB0O7QACkCADcCAAs7ACAAIANBAnRqIgAgAiABQQJ0aigCACIBIAAoAghqNgIIIAAgACgCACABdiABIAFBgH5xIAQbcjYCAAseACAAKAKU6wEQ2iIgAEEANgKk6wEgAEIANwKU6wELFQAgAC0AAEECRgRAIABBBGoQuS4LCx8AIABBCGpB+MbRACkCADcCACAAQfDG0QApAgA3AgALEwBCkJQHIABBDnGtiEIOg0InfAsTACABBEAgACABQQJ0QQQQ+DoLCx8AIABBCGpB9Lv7ACkCADcCACAAQey7+wApAgA3AgALHwAgAEEIakGEvPsAKQIANwIAIABB/Lv7ACkCADcCAAuzBAECfyAAIAAoAhAgAmo2AhAgACAAKQMAIAKtfDcDACAAKAIIQX9zIQMCQCACQcAASQ0AIAFBEGohAQNAIAJBD0sEQCABQRBrLQAAIANB/wFxc0ECdEGQiv4AaigCACABQQ9rLQAAIANBCHZB/wFxc0ECdEGQgv4AaigCACABQQ5rLQAAIANBEHZB/wFxc0ECdEGQ+v0AaigCACABQQ1rLQAAIANBGHZzQQJ0QZDy/QBqKAIAIAFBDGstAABBAnRBkOr9AGooAgAgAUELay0AAEECdEGQ4v0AaigCACABQQprLQAAQQJ0QZDa/QBqKAIAIAFBCWstAABBAnRBkNL9AGooAgAgAUEIay0AAEECdEGQyv0AaigCACABQQdrLQAAQQJ0QZDC/QBqKAIAIAFBBmstAABBAnRBkLr9AGooAgAgAUEFay0AAEECdEGQsv0AaigCACABQQRrLQAAQQJ0QZCq/QBqKAIAIAFBA2stAABBAnRBkKL9AGooAgAgAUECay0AAEECdEGQmv0AaigCACABQQFrLQAAQQJ0QZCS/QBqKAIAc3Nzc3Nzc3Nzc3Nzc3NzIQMgAkEQayECAkAgBEEBaiIEQQRHDQBBACEEIAJBP0sNAAwDCyABQRBqIQEMAQsLQQ8gAkGAkv0AEMMhAAsgAgRAA0AgAS0AACADc0H/AXFBAnRBkJL9AGooAgAgA0EIdnMhAyABQQFqIQEgAkEBayICDQALCyAAIANBf3M2AggLHwAgAEEIakHQov4AKQIANwIAIABByKL+ACkCADcCAAsfACAAQQhqQdiz/gApAgA3AgAgAEHQs/4AKQIANwIACx8AIABBCGpB5NT+ACkCADcCACAAQdzU/gApAgA3AgALHwAgAEEIakH01P4AKQIANwIAIABB7NT+ACkCADcCAAsfACAAQQhqQaie/wApAgA3AgAgAEGgnv8AKQIANwIACx8AIABBCGpByJ7/ACkCADcCACAAQcCe/wApAgA3AgALHwAgAEEIakGYn/8AKQIANwIAIABBkJ//ACkCADcCAAsfACAAQQhqQaif/wApAgA3AgAgAEGgn/8AKQIANwIACx8AIABBCGpBiJ//ACkCADcCACAAQYCf/wApAgA3AgALHwAgAEEIakG4nv8AKQIANwIAIABBsJ7/ACkCADcCAAsfACAAQQhqQeie/wApAgA3AgAgAEHgnv8AKQIANwIACx8AIABBCGpBuJ//ACkCADcCACAAQbCf/wApAgA3AgALHwAgAEEIakHIn/8AKQIANwIAIABBwJ//ACkCADcCAAsfACAAQQhqQdif/wApAgA3AgAgAEHQn/8AKQIANwIACx8AIABBCGpB6J//ACkCADcCACAAQeCf/wApAgA3AgALHwAgAEEIakH4n/8AKQIANwIAIABB8J//ACkCADcCAAsfACAAQQhqQZie/wApAgA3AgAgAEGQnv8AKQIANwIACx8AIABBCGpBiKD/ACkCADcCACAAQYCg/wApAgA3AgALHwAgAEEIakGYoP8AKQIANwIAIABBkKD/ACkCADcCAAsfACAAQQhqQaig/wApAgA3AgAgAEGgoP8AKQIANwIACx8AIABBCGpBuKD/ACkCADcCACAAQbCg/wApAgA3AgALHwAgAEEIakH4nv8AKQIANwIAIABB8J7/ACkCADcCAAsfACAAQQhqQdie/wApAgA3AgAgAEHQnv8AKQIANwIACx8AIABBCGpB+J3/ACkCADcCACAAQfCd/wApAgA3AgALHwAgAEEIakHIoP8AKQIANwIAIABBwKD/ACkCADcCAAsfACAAQQhqQYie/wApAgA3AgAgAEGAnv8AKQIANwIACx8AIABBCGpB8ML/ACkCADcCACAAQejC/wApAgA3AgALHwAgAEEIakGAw/8AKQIANwIAIABB+ML/ACkCADcCAAsfACAAQQhqQZDD/wApAgA3AgAgAEGIw/8AKQIANwIACx8AIABBCGpBoMP/ACkCADcCACAAQZjD/wApAgA3AgALHwAgAEEIakGww/8AKQIANwIAIABBqMP/ACkCADcCAAsfACAAQQhqQcDD/wApAgA3AgAgAEG4w/8AKQIANwIACx8AIABBCGpB0MP/ACkCADcCACAAQcjD/wApAgA3AgALHwAgAEEIakHgw/8AKQIANwIAIABB2MP/ACkCADcCAAsfACAAQQhqQfDD/wApAgA3AgAgAEHow/8AKQIANwIACx8AIABBCGpBgMT/ACkCADcCACAAQfjD/wApAgA3AgALHwAgAEEIakGQxP8AKQIANwIAIABBiMT/ACkCADcCAAsfACAAQQhqQdDC/wApAgA3AgAgAEHIwv8AKQIANwIACx8AIABBCGpBoMT/ACkCADcCACAAQZjE/wApAgA3AgALHwAgAEEIakGwxP8AKQIANwIAIABBqMT/ACkCADcCAAsfACAAQQhqQcDE/wApAgA3AgAgAEG4xP8AKQIANwIACx8AIABBCGpB0MT/ACkCADcCACAAQcjE/wApAgA3AgALHwAgAEEIakHgxP8AKQIANwIAIABB2MT/ACkCADcCAAsfACAAQQhqQfDE/wApAgA3AgAgAEHoxP8AKQIANwIACx8AIABBCGpBgMX/ACkCADcCACAAQfjE/wApAgA3AgALHwAgAEEIakGQwv8AKQIANwIAIABBiML/ACkCADcCAAsfACAAQQhqQZDF/wApAgA3AgAgAEGIxf8AKQIANwIACx8AIABBCGpBoMX/ACkCADcCACAAQZjF/wApAgA3AgALHwAgAEEIakGwxf8AKQIANwIAIABBqMX/ACkCADcCAAsfACAAQQhqQcDF/wApAgA3AgAgAEG4xf8AKQIANwIACx8AIABBCGpB0MX/ACkCADcCACAAQcjF/wApAgA3AgALHwAgAEEIakHgxf8AKQIANwIAIABB2MX/ACkCADcCAAsfACAAQQhqQfDF/wApAgA3AgAgAEHoxf8AKQIANwIACx8AIABBCGpBgMb/ACkCADcCACAAQfjF/wApAgA3AgALHwAgAEEIakGQxv8AKQIANwIAIABBiMb/ACkCADcCAAsfACAAQQhqQaDG/wApAgA3AgAgAEGYxv8AKQIANwIACx8AIABBCGpBwML/ACkCADcCACAAQbjC/wApAgA3AgALHwAgAEEIakGwxv8AKQIANwIAIABBqMb/ACkCADcCAAsfACAAQQhqQbDC/wApAgA3AgAgAEGowv8AKQIANwIACx8AIABBCGpBoML/ACkCADcCACAAQZjC/wApAgA3AgALHwAgAEEIakHAxv8AKQIANwIAIABBuMb/ACkCADcCAAsfACAAQQhqQdDG/wApAgA3AgAgAEHIxv8AKQIANwIACx8AIABBCGpB4Mb/ACkCADcCACAAQdjG/wApAgA3AgALHwAgAEEIakGAwv8AKQIANwIAIABB+MH/ACkCADcCAAsfACAAQQhqQfDG/wApAgA3AgAgAEHoxv8AKQIANwIACx8AIABBCGpBgMf/ACkCADcCACAAQfjG/wApAgA3AgALHwAgAEEIakHgwv8AKQIANwIAIABB2ML/ACkCADcCAAsfACAAQQhqQYD4/wApAgA3AgAgAEH49/8AKQIANwIACx8AIABBCGpBkPj/ACkCADcCACAAQYj4/wApAgA3AgALHwAgAEEIakGg+P8AKQIANwIAIABBmPj/ACkCADcCAAsfACAAQQhqQbD4/wApAgA3AgAgAEGo+P8AKQIANwIACx8AIABBCGpBwPj/ACkCADcCACAAQbj4/wApAgA3AgALHwAgAEEIakHQ+P8AKQIANwIAIABByPj/ACkCADcCAAsfACAAQQhqQeD4/wApAgA3AgAgAEHY+P8AKQIANwIACx8AIABBCGpB8Pj/ACkCADcCACAAQej4/wApAgA3AgALHwAgAEEIakHw9/8AKQIANwIAIABB6Pf/ACkCADcCAAsfACAAQQhqQeD3/wApAgA3AgAgAEHY9/8AKQIANwIACx8AIABBCGpBgPn/ACkCADcCACAAQfj4/wApAgA3AgALHwAgAEEIakGQ+f8AKQIANwIAIABBiPn/ACkCADcCAAsfACAAQQhqQaD5/wApAgA3AgAgAEGY+f8AKQIANwIACx8AIABBCGpBsPn/ACkCADcCACAAQaj5/wApAgA3AgALHwAgAEEIakHA+f8AKQIANwIAIABBuPn/ACkCADcCAAsfACAAQQhqQdD5/wApAgA3AgAgAEHI+f8AKQIANwIACx8AIABBCGpB4Pn/ACkCADcCACAAQdj5/wApAgA3AgALHwAgAEEIakHw+f8AKQIANwIAIABB6Pn/ACkCADcCAAsfACAAQQhqQYD6/wApAgA3AgAgAEH4+f8AKQIANwIACx8AIABBCGpB0Pf/ACkCADcCACAAQcj3/wApAgA3AgALHwAgAEEIakGQ+v8AKQIANwIAIABBiPr/ACkCADcCAAsfACAAQQhqQaD6/wApAgA3AgAgAEGY+v8AKQIANwIACx8AIABBCGpBsPr/ACkCADcCACAAQaj6/wApAgA3AgALHwAgAEEIakHA+v8AKQIANwIAIABBuPr/ACkCADcCAAsfACAAQQhqQdD6/wApAgA3AgAgAEHI+v8AKQIANwIACx8AIABBCGpB4Pr/ACkCADcCACAAQdj6/wApAgA3AgALHwAgAEEIakHw+v8AKQIANwIAIABB6Pr/ACkCADcCAAsfACAAQQhqQbiVgAEpAgA3AgAgAEGwlYABKQIANwIACx8AIABBCGpByJWAASkCADcCACAAQcCVgAEpAgA3AgALHwAgAEEIakHYlYABKQIANwIAIABB0JWAASkCADcCAAsfACAAQQhqQeiVgAEpAgA3AgAgAEHglYABKQIANwIACx8AIABBCGpB+JWAASkCADcCACAAQfCVgAEpAgA3AgALHwAgAEEIakGIloABKQIANwIAIABBgJaAASkCADcCAAsfACAAQQhqQZiWgAEpAgA3AgAgAEGQloABKQIANwIACx8AIABBCGpBqJaAASkCADcCACAAQaCWgAEpAgA3AgALHwAgAEEIakG4loABKQIANwIAIABBsJaAASkCADcCAAsfACAAQQhqQciWgAEpAgA3AgAgAEHAloABKQIANwIACx8AIABBCGpB2JaAASkCADcCACAAQdCWgAEpAgA3AgALHwAgAEEIakHoloABKQIANwIAIABB4JaAASkCADcCAAsfACAAQQhqQfiWgAEpAgA3AgAgAEHwloABKQIANwIACx8AIABBCGpBiJeAASkCADcCACAAQYCXgAEpAgA3AgALHwAgAEEIakG85IABKQIANwIAIABBtOSAASkCADcCAAsfACAAQQhqQczkgAEpAgA3AgAgAEHE5IABKQIANwIACx8AIABBCGpB3OSAASkCADcCACAAQdTkgAEpAgA3AgALHwAgAEEIakHk94ABKQIANwIAIABB3PeAASkCADcCAAsfACAAQQhqQfT1gQEpAgA3AgAgAEHs9YEBKQIANwIACx8AIABBCGpBhPaBASkCADcCACAAQfz1gQEpAgA3AgALHwAgAEEIakGU9oEBKQIANwIAIABBjPaBASkCADcCAAsfACAAQQhqQaT2gQEpAgA3AgAgAEGc9oEBKQIANwIACx8AIABBCGpBtPaBASkCADcCACAAQaz2gQEpAgA3AgALHwAgAEEIakHE9oEBKQIANwIAIABBvPaBASkCADcCAAsfACAAQQhqQdT2gQEpAgA3AgAgAEHM9oEBKQIANwIACx8AIABBCGpB5PaBASkCADcCACAAQdz2gQEpAgA3AgALHwAgAEEIakH09oEBKQIANwIAIABB7PaBASkCADcCAAsfACAAQQhqQYT3gQEpAgA3AgAgAEH89oEBKQIANwIACx8AIABBCGpBlPeBASkCADcCACAAQYz3gQEpAgA3AgALHwAgAEEIakGk94EBKQIANwIAIABBnPeBASkCADcCAAsfACAAQQhqQbT3gQEpAgA3AgAgAEGs94EBKQIANwIACx8AIABBCGpB5PWBASkCADcCACAAQdz1gQEpAgA3AgALHwAgAEEIakHE94EBKQIANwIAIABBvPeBASkCADcCAAsfACAAQQhqQdT3gQEpAgA3AgAgAEHM94EBKQIANwIACx8AIABBCGpB5PeBASkCADcCACAAQdz3gQEpAgA3AgALHwAgAEEIakH094EBKQIANwIAIABB7PeBASkCADcCAAsfACAAQQhqQYT4gQEpAgA3AgAgAEH894EBKQIANwIACx8AIABBCGpBlPiBASkCADcCACAAQYz4gQEpAgA3AgALHwAgAEEIakGk+IEBKQIANwIAIABBnPiBASkCADcCAAsfACAAQQhqQbT4gQEpAgA3AgAgAEGs+IEBKQIANwIACx8AIABBCGpBxPiBASkCADcCACAAQbz4gQEpAgA3AgALHwAgAEEIakHU+IEBKQIANwIAIABBzPiBASkCADcCAAsfACAAQQhqQeT4gQEpAgA3AgAgAEHc+IEBKQIANwIACx8AIABBCGpB9PiBASkCADcCACAAQez4gQEpAgA3AgALHwAgAEEIakGE+YEBKQIANwIAIABB/PiBASkCADcCAAsfACAAQQhqQZT5gQEpAgA3AgAgAEGM+YEBKQIANwIACx8AIABBCGpBpPmBASkCADcCACAAQZz5gQEpAgA3AgALHwAgAEEIakG0+YEBKQIANwIAIABBrPmBASkCADcCAAsfACAAQQhqQcT5gQEpAgA3AgAgAEG8+YEBKQIANwIACx8AIABBCGpB1PmBASkCADcCACAAQcz5gQEpAgA3AgALHwAgAEEIakHk+YEBKQIANwIAIABB3PmBASkCADcCAAsfACAAQQhqQfT5gQEpAgA3AgAgAEHs+YEBKQIANwIACx8AIABBCGpBhPqBASkCADcCACAAQfz5gQEpAgA3AgALHwAgAEEIakGU+oEBKQIANwIAIABBjPqBASkCADcCAAsfACAAQQhqQaT6gQEpAgA3AgAgAEGc+oEBKQIANwIACx8AIABBCGpBtPqBASkCADcCACAAQaz6gQEpAgA3AgALHwAgAEEIakHE9YEBKQIANwIAIABBvPWBASkCADcCAAsfACAAQQhqQcT6gQEpAgA3AgAgAEG8+oEBKQIANwIACx8AIABBCGpB1PqBASkCADcCACAAQcz6gQEpAgA3AgALHwAgAEEIakHk+oEBKQIANwIAIABB3PqBASkCADcCAAsfACAAQQhqQfT6gQEpAgA3AgAgAEHs+oEBKQIANwIACx8AIABBCGpB1PWBASkCADcCACAAQcz1gQEpAgA3AgALHwAgAEEIakG09YEBKQIANwIAIABBrPWBASkCADcCAAsfACAAQQhqQYT7gQEpAgA3AgAgAEH8+oEBKQIANwIACx8AIABBCGpBlPuBASkCADcCACAAQYz7gQEpAgA3AgALHwAgAEEIakGk+4EBKQIANwIAIABBnPuBASkCADcCAAsfACAAQQhqQbT7gQEpAgA3AgAgAEGs+4EBKQIANwIACx8AIABBCGpBxPuBASkCADcCACAAQbz7gQEpAgA3AgALHwAgAEEIakHU+4EBKQIANwIAIABBzPuBASkCADcCAAsfACAAQQhqQeT7gQEpAgA3AgAgAEHc+4EBKQIANwIACx8AIABBCGpB9PuBASkCADcCACAAQez7gQEpAgA3AgALHwAgAEEIakGE/IEBKQIANwIAIABB/PuBASkCADcCAAsfACAAQQhqQZT8gQEpAgA3AgAgAEGM/IEBKQIANwIACx8AIABBCGpBpPyBASkCADcCACAAQZz8gQEpAgA3AgALHwAgAEEIakG0/IEBKQIANwIAIABBrPyBASkCADcCAAsfACAAQQhqQYCzggEpAgA3AgAgAEH4soIBKQIANwIACx8AIABBCGpBlMGCASkCADcCACAAQYzBggEpAgA3AgALHwAgAEEIakGkwYIBKQIANwIAIABBnMGCASkCADcCAAsfACAAQQhqQbTBggEpAgA3AgAgAEGswYIBKQIANwIACx8AIABBCGpBxMGCASkCADcCACAAQbzBggEpAgA3AgALHwAgAEEIakHUwYIBKQIANwIAIABBzMGCASkCADcCAAsfACAAQQhqQeTBggEpAgA3AgAgAEHcwYIBKQIANwIACx8AIABBCGpB9MGCASkCADcCACAAQezBggEpAgA3AgALHwAgAEEIakGEwoIBKQIANwIAIABB/MGCASkCADcCAAsfACAAQQhqQZTCggEpAgA3AgAgAEGMwoIBKQIANwIACx8AIABBCGpBpMKCASkCADcCACAAQZzCggEpAgA3AgALHwAgAEEIakG0woIBKQIANwIAIABBrMKCASkCADcCAAsfACAAQQhqQcTCggEpAgA3AgAgAEG8woIBKQIANwIACx8AIABBCGpB1MKCASkCADcCACAAQczCggEpAgA3AgALHwAgAEEIakHkwoIBKQIANwIAIABB3MKCASkCADcCAAsfACAAQQhqQfTCggEpAgA3AgAgAEHswoIBKQIANwIACx8AIABBCGpBhMOCASkCADcCACAAQfzCggEpAgA3AgALHwAgAEEIakGUw4IBKQIANwIAIABBjMOCASkCADcCAAsfACAAQQhqQaTDggEpAgA3AgAgAEGcw4IBKQIANwIACx8AIABBCGpBtMOCASkCADcCACAAQazDggEpAgA3AgALHwAgAEEIakHEw4IBKQIANwIAIABBvMOCASkCADcCAAsfACAAQQhqQdTDggEpAgA3AgAgAEHMw4IBKQIANwIACx8AIABBCGpB5MOCASkCADcCACAAQdzDggEpAgA3AgALHwAgAEEIakH0w4IBKQIANwIAIABB7MOCASkCADcCAAsfACAAQQhqQYTEggEpAgA3AgAgAEH8w4IBKQIANwIACx8AIABBCGpBlMSCASkCADcCACAAQYzEggEpAgA3AgALHwAgAEEIakGkxIIBKQIANwIAIABBnMSCASkCADcCAAsfACAAQQhqQbTEggEpAgA3AgAgAEGsxIIBKQIANwIACx8AIABBCGpBxMSCASkCADcCACAAQbzEggEpAgA3AgALHwAgAEEIakHUxIIBKQIANwIAIABBzMSCASkCADcCAAsfACAAQQhqQeTEggEpAgA3AgAgAEHcxIIBKQIANwIACx8AIABBCGpB9MSCASkCADcCACAAQezEggEpAgA3AgALHwAgAEEIakGExYIBKQIANwIAIABB/MSCASkCADcCAAsfACAAQQhqQZTFggEpAgA3AgAgAEGMxYIBKQIANwIACx8AIABBCGpBpMWCASkCADcCACAAQZzFggEpAgA3AgALHwAgAEEIakG0xYIBKQIANwIAIABBrMWCASkCADcCAAsfACAAQQhqQcTFggEpAgA3AgAgAEG8xYIBKQIANwIACx8AIABBCGpB1MWCASkCADcCACAAQczFggEpAgA3AgALHwAgAEEIakHkxYIBKQIANwIAIABB3MWCASkCADcCAAsfACAAQQhqQfTFggEpAgA3AgAgAEHsxYIBKQIANwIACx8AIABBCGpBhMaCASkCADcCACAAQfzFggEpAgA3AgALHwAgAEEIakGUxoIBKQIANwIAIABBjMaCASkCADcCAAsfACAAQQhqQaTGggEpAgA3AgAgAEGcxoIBKQIANwIACx8AIABBCGpBtMaCASkCADcCACAAQazGggEpAgA3AgALHwAgAEEIakHExoIBKQIANwIAIABBvMaCASkCADcCAAsfACAAQQhqQdTGggEpAgA3AgAgAEHMxoIBKQIANwIACx8AIABBCGpB5MaCASkCADcCACAAQdzGggEpAgA3AgALHwAgAEEIakH0xoIBKQIANwIAIABB7MaCASkCADcCAAsfACAAQQhqQYTHggEpAgA3AgAgAEH8xoIBKQIANwIACx8AIABBCGpBlMeCASkCADcCACAAQYzHggEpAgA3AgALHwAgAEEIakGkx4IBKQIANwIAIABBnMeCASkCADcCAAsfACAAQQhqQbTHggEpAgA3AgAgAEGsx4IBKQIANwIACx8AIABBCGpBxMeCASkCADcCACAAQbzHggEpAgA3AgALHwAgAEEIakHUx4IBKQIANwIAIABBzMeCASkCADcCAAsfACAAQQhqQej7ggEpAgA3AgAgAEHg+4IBKQIANwIACx8AIABBCGpB+PuCASkCADcCACAAQfD7ggEpAgA3AgALHwAgAEEIakGI/IIBKQIANwIAIABBgPyCASkCADcCAAsfACAAQQhqQZj8ggEpAgA3AgAgAEGQ/IIBKQIANwIACx8AIABBCGpBqPyCASkCADcCACAAQaD8ggEpAgA3AgALHwAgAEEIakG4/IIBKQIANwIAIABBsPyCASkCADcCAAsfACAAQQhqQcj8ggEpAgA3AgAgAEHA/IIBKQIANwIACx8AIABBCGpB2PyCASkCADcCACAAQdD8ggEpAgA3AgALHwAgAEEIakHo/IIBKQIANwIAIABB4PyCASkCADcCAAsfACAAQQhqQfj8ggEpAgA3AgAgAEHw/IIBKQIANwIACx8AIABBCGpBiP2CASkCADcCACAAQYD9ggEpAgA3AgALHwAgAEEIakGY/YIBKQIANwIAIABBkP2CASkCADcCAAsfACAAQQhqQaj9ggEpAgA3AgAgAEGg/YIBKQIANwIACx8AIABBCGpBuP2CASkCADcCACAAQbD9ggEpAgA3AgALHwAgAEEIakHI/YIBKQIANwIAIABBwP2CASkCADcCAAsfACAAQQhqQdj9ggEpAgA3AgAgAEHQ/YIBKQIANwIACx8AIABBCGpB6P2CASkCADcCACAAQeD9ggEpAgA3AgALHwAgAEEIakH4/YIBKQIANwIAIABB8P2CASkCADcCAAsfACAAQQhqQYj+ggEpAgA3AgAgAEGA/oIBKQIANwIACx8AIABBCGpBmP6CASkCADcCACAAQZD+ggEpAgA3AgALHwAgAEEIakGo/oIBKQIANwIAIABBoP6CASkCADcCAAsfACAAQQhqQbj+ggEpAgA3AgAgAEGw/oIBKQIANwIACx8AIABBCGpByP6CASkCADcCACAAQcD+ggEpAgA3AgALHwAgAEEIakHY/oIBKQIANwIAIABB0P6CASkCADcCAAsfACAAQQhqQej+ggEpAgA3AgAgAEHg/oIBKQIANwIACx8AIABBCGpB+P6CASkCADcCACAAQfD+ggEpAgA3AgALHwAgAEEIakGI/4IBKQIANwIAIABBgP+CASkCADcCAAsfACAAQQhqQZj/ggEpAgA3AgAgAEGQ/4IBKQIANwIACx8AIABBCGpBqP+CASkCADcCACAAQaD/ggEpAgA3AgALHwAgAEEIakG4/4IBKQIANwIAIABBsP+CASkCADcCAAsfACAAQQhqQcj/ggEpAgA3AgAgAEHA/4IBKQIANwIACx8AIABBCGpB2P+CASkCADcCACAAQdD/ggEpAgA3AgALHwAgAEEIakHo/4IBKQIANwIAIABB4P+CASkCADcCAAsfACAAQQhqQfj/ggEpAgA3AgAgAEHw/4IBKQIANwIACx8AIABBCGpBiICDASkCADcCACAAQYCAgwEpAgA3AgALHwAgAEEIakGYgIMBKQIANwIAIABBkICDASkCADcCAAsfACAAQQhqQaiAgwEpAgA3AgAgAEGggIMBKQIANwIACx8AIABBCGpBuICDASkCADcCACAAQbCAgwEpAgA3AgALHwAgAEEIakHIgIMBKQIANwIAIABBwICDASkCADcCAAsfACAAQQhqQdiAgwEpAgA3AgAgAEHQgIMBKQIANwIACx8AIABBCGpB2PuCASkCADcCACAAQdD7ggEpAgA3AgALHwAgAEEIakHogIMBKQIANwIAIABB4ICDASkCADcCAAsfACAAQQhqQfiAgwEpAgA3AgAgAEHwgIMBKQIANwIACx8AIABBCGpBiIGDASkCADcCACAAQYCBgwEpAgA3AgALHwAgAEEIakGYgYMBKQIANwIAIABBkIGDASkCADcCAAsfACAAQQhqQaiBgwEpAgA3AgAgAEGggYMBKQIANwIACx8AIABBCGpBuIGDASkCADcCACAAQbCBgwEpAgA3AgALHwAgAEEIakHIgYMBKQIANwIAIABBwIGDASkCADcCAAsfACAAQQhqQdiBgwEpAgA3AgAgAEHQgYMBKQIANwIACx8AIABBCGpB6IGDASkCADcCACAAQeCBgwEpAgA3AgALHwAgAEEIakH4gYMBKQIANwIAIABB8IGDASkCADcCAAsfACAAQQhqQYiCgwEpAgA3AgAgAEGAgoMBKQIANwIACx8AIABBCGpBmIKDASkCADcCACAAQZCCgwEpAgA3AgALHwAgAEEIakHgxYMBKQIANwIAIABB2MWDASkCADcCAAsfACAAQQhqQfDFgwEpAgA3AgAgAEHoxYMBKQIANwIACx8AIABBCGpBgMaDASkCADcCACAAQfjFgwEpAgA3AgALHwAgAEEIakGQxoMBKQIANwIAIABBiMaDASkCADcCAAsfACAAQQhqQaDGgwEpAgA3AgAgAEGYxoMBKQIANwIACx8AIABBCGpBsMaDASkCADcCACAAQajGgwEpAgA3AgALHwAgAEEIakHAxoMBKQIANwIAIABBuMaDASkCADcCAAsfACAAQQhqQdDGgwEpAgA3AgAgAEHIxoMBKQIANwIACx8AIABBCGpB4MaDASkCADcCACAAQdjGgwEpAgA3AgALHwAgAEEIakHwxoMBKQIANwIAIABB6MaDASkCADcCAAsfACAAQQhqQYDHgwEpAgA3AgAgAEH4xoMBKQIANwIACx8AIABBCGpBkMeDASkCADcCACAAQYjHgwEpAgA3AgALHwAgAEEIakGgx4MBKQIANwIAIABBmMeDASkCADcCAAsfACAAQQhqQbDHgwEpAgA3AgAgAEGox4MBKQIANwIACx8AIABBCGpBwMeDASkCADcCACAAQbjHgwEpAgA3AgALHwAgAEEIakHQx4MBKQIANwIAIABByMeDASkCADcCAAsfACAAQQhqQeDHgwEpAgA3AgAgAEHYx4MBKQIANwIACx8AIABBCGpB8MeDASkCADcCACAAQejHgwEpAgA3AgALHwAgAEEIakGAyIMBKQIANwIAIABB+MeDASkCADcCAAsfACAAQQhqQZDIgwEpAgA3AgAgAEGIyIMBKQIANwIACx8AIABBCGpBoMiDASkCADcCACAAQZjIgwEpAgA3AgALHwAgAEEIakGwyIMBKQIANwIAIABBqMiDASkCADcCAAsfACAAQQhqQcDIgwEpAgA3AgAgAEG4yIMBKQIANwIACx8AIABBCGpB0MiDASkCADcCACAAQcjIgwEpAgA3AgALHwAgAEEIakHgyIMBKQIANwIAIABB2MiDASkCADcCAAsfACAAQQhqQfDIgwEpAgA3AgAgAEHoyIMBKQIANwIACx8AIABBCGpBgMmDASkCADcCACAAQfjIgwEpAgA3AgALHwAgAEEIakGQyYMBKQIANwIAIABBiMmDASkCADcCAAsfACAAQQhqQaDJgwEpAgA3AgAgAEGYyYMBKQIANwIACx8AIABBCGpBsMmDASkCADcCACAAQajJgwEpAgA3AgALHwAgAEEIakHAyYMBKQIANwIAIABBuMmDASkCADcCAAsfACAAQQhqQdDJgwEpAgA3AgAgAEHIyYMBKQIANwIACx8AIABBCGpB4MmDASkCADcCACAAQdjJgwEpAgA3AgALHwAgAEEIakHwyYMBKQIANwIAIABB6MmDASkCADcCAAsfACAAQQhqQYDKgwEpAgA3AgAgAEH4yYMBKQIANwIACx8AIABBCGpBkMqDASkCADcCACAAQYjKgwEpAgA3AgALHwAgAEEIakGgyoMBKQIANwIAIABBmMqDASkCADcCAAsfACAAQQhqQbDKgwEpAgA3AgAgAEGoyoMBKQIANwIACx8AIABBCGpBwMqDASkCADcCACAAQbjKgwEpAgA3AgALHwAgAEEIakHQyoMBKQIANwIAIABByMqDASkCADcCAAsfACAAQQhqQeDKgwEpAgA3AgAgAEHYyoMBKQIANwIACx8AIABBCGpB8MqDASkCADcCACAAQejKgwEpAgA3AgALHwAgAEEIakGAy4MBKQIANwIAIABB+MqDASkCADcCAAsfACAAQQhqQZDLgwEpAgA3AgAgAEGIy4MBKQIANwIACx8AIABBCGpBoMuDASkCADcCACAAQZjLgwEpAgA3AgALHwAgAEEIakGwy4MBKQIANwIAIABBqMuDASkCADcCAAsfACAAQQhqQcDLgwEpAgA3AgAgAEG4y4MBKQIANwIACx8AIABBCGpBmIeEASkCADcCACAAQZCHhAEpAgA3AgALHwAgAEEIakGoh4QBKQIANwIAIABBoIeEASkCADcCAAsfACAAQQhqQbiHhAEpAgA3AgAgAEGwh4QBKQIANwIACx8AIABBCGpByIeEASkCADcCACAAQcCHhAEpAgA3AgALHwAgAEEIakHYh4QBKQIANwIAIABB0IeEASkCADcCAAsfACAAQQhqQeiHhAEpAgA3AgAgAEHgh4QBKQIANwIACx8AIABBCGpB+IeEASkCADcCACAAQfCHhAEpAgA3AgALHwAgAEEIakGIiIQBKQIANwIAIABBgIiEASkCADcCAAsfACAAQQhqQZiIhAEpAgA3AgAgAEGQiIQBKQIANwIACx8AIABBCGpBqIiEASkCADcCACAAQaCIhAEpAgA3AgALHwAgAEEIakG4iIQBKQIANwIAIABBsIiEASkCADcCAAsfACAAQQhqQciIhAEpAgA3AgAgAEHAiIQBKQIANwIACx8AIABBCGpBuIaEASkCADcCACAAQbCGhAEpAgA3AgALHwAgAEEIakHYiIQBKQIANwIAIABB0IiEASkCADcCAAsfACAAQQhqQeiIhAEpAgA3AgAgAEHgiIQBKQIANwIACx8AIABBCGpB+IiEASkCADcCACAAQfCIhAEpAgA3AgALHwAgAEEIakGIiYQBKQIANwIAIABBgImEASkCADcCAAsfACAAQQhqQZiJhAEpAgA3AgAgAEGQiYQBKQIANwIACx8AIABBCGpB+IaEASkCADcCACAAQfCGhAEpAgA3AgALHwAgAEEIakGoiYQBKQIANwIAIABBoImEASkCADcCAAsfACAAQQhqQbiJhAEpAgA3AgAgAEGwiYQBKQIANwIACx8AIABBCGpByImEASkCADcCACAAQcCJhAEpAgA3AgALHwAgAEEIakHYiYQBKQIANwIAIABB0ImEASkCADcCAAsfACAAQQhqQeiJhAEpAgA3AgAgAEHgiYQBKQIANwIACx8AIABBCGpB+ImEASkCADcCACAAQfCJhAEpAgA3AgALHwAgAEEIakGIioQBKQIANwIAIABBgIqEASkCADcCAAsfACAAQQhqQZiKhAEpAgA3AgAgAEGQioQBKQIANwIACx8AIABBCGpBqIqEASkCADcCACAAQaCKhAEpAgA3AgALHwAgAEEIakG4ioQBKQIANwIAIABBsIqEASkCADcCAAsfACAAQQhqQciKhAEpAgA3AgAgAEHAioQBKQIANwIACx8AIABBCGpB2IqEASkCADcCACAAQdCKhAEpAgA3AgALHwAgAEEIakHoioQBKQIANwIAIABB4IqEASkCADcCAAsfACAAQQhqQfiKhAEpAgA3AgAgAEHwioQBKQIANwIACx8AIABBCGpBiIuEASkCADcCACAAQYCLhAEpAgA3AgALHwAgAEEIakGYi4QBKQIANwIAIABBkIuEASkCADcCAAsfACAAQQhqQaiLhAEpAgA3AgAgAEGgi4QBKQIANwIACx8AIABBCGpBuIuEASkCADcCACAAQbCLhAEpAgA3AgALHwAgAEEIakHIi4QBKQIANwIAIABBwIuEASkCADcCAAsfACAAQQhqQdiLhAEpAgA3AgAgAEHQi4QBKQIANwIACx8AIABBCGpB6IuEASkCADcCACAAQeCLhAEpAgA3AgALHwAgAEEIakH4i4QBKQIANwIAIABB8IuEASkCADcCAAsfACAAQQhqQYiMhAEpAgA3AgAgAEGAjIQBKQIANwIACx8AIABBCGpBmIyEASkCADcCACAAQZCMhAEpAgA3AgALHwAgAEEIakGojIQBKQIANwIAIABBoIyEASkCADcCAAsfACAAQQhqQYiHhAEpAgA3AgAgAEGAh4QBKQIANwIACx8AIABBCGpBuIyEASkCADcCACAAQbCMhAEpAgA3AgALHwAgAEEIakHIjIQBKQIANwIAIABBwIyEASkCADcCAAsfACAAQQhqQdiMhAEpAgA3AgAgAEHQjIQBKQIANwIACx8AIABBCGpB6IyEASkCADcCACAAQeCMhAEpAgA3AgALHwAgAEEIakH4jIQBKQIANwIAIABB8IyEASkCADcCAAsfACAAQQhqQYiNhAEpAgA3AgAgAEGAjYQBKQIANwIACx8AIABBCGpBmI2EASkCADcCACAAQZCNhAEpAgA3AgALHwAgAEEIakGojYQBKQIANwIAIABBoI2EASkCADcCAAsfACAAQQhqQbiNhAEpAgA3AgAgAEGwjYQBKQIANwIACx8AIABBCGpByI2EASkCADcCACAAQcCNhAEpAgA3AgALHwAgAEEIakHYhoQBKQIANwIAIABB0IaEASkCADcCAAsfACAAQQhqQdiNhAEpAgA3AgAgAEHQjYQBKQIANwIACx8AIABBCGpB6IaEASkCADcCACAAQeCGhAEpAgA3AgALHwAgAEEIakHIhoQBKQIANwIAIABBwIaEASkCADcCAAsfACAAQQhqQeiNhAEpAgA3AgAgAEHgjYQBKQIANwIACx8AIABBCGpBtMSEASkCADcCACAAQazEhAEpAgA3AgALHwAgAEEIakHExIQBKQIANwIAIABBvMSEASkCADcCAAsfACAAQQhqQdTEhAEpAgA3AgAgAEHMxIQBKQIANwIACx8AIABBCGpB5MSEASkCADcCACAAQdzEhAEpAgA3AgALHwAgAEEIakH0xIQBKQIANwIAIABB7MSEASkCADcCAAsfACAAQQhqQYTFhAEpAgA3AgAgAEH8xIQBKQIANwIACx8AIABBCGpBlMWEASkCADcCACAAQYzFhAEpAgA3AgALHwAgAEEIakGkxYQBKQIANwIAIABBnMWEASkCADcCAAsfACAAQQhqQbTFhAEpAgA3AgAgAEGsxYQBKQIANwIACx8AIABBCGpBxMWEASkCADcCACAAQbzFhAEpAgA3AgALHwAgAEEIakHUxYQBKQIANwIAIABBzMWEASkCADcCAAsfACAAQQhqQeTFhAEpAgA3AgAgAEHcxYQBKQIANwIACx8AIABBCGpB9MWEASkCADcCACAAQezFhAEpAgA3AgALHwAgAEEIakGExoQBKQIANwIAIABB/MWEASkCADcCAAsfACAAQQhqQZTGhAEpAgA3AgAgAEGMxoQBKQIANwIACx8AIABBCGpBpMaEASkCADcCACAAQZzGhAEpAgA3AgALHwAgAEEIakG0xoQBKQIANwIAIABBrMaEASkCADcCAAsfACAAQQhqQcTGhAEpAgA3AgAgAEG8xoQBKQIANwIACx8AIABBCGpB1MaEASkCADcCACAAQczGhAEpAgA3AgALHwAgAEEIakHkxoQBKQIANwIAIABB3MaEASkCADcCAAsfACAAQQhqQfTGhAEpAgA3AgAgAEHsxoQBKQIANwIACx8AIABBCGpBhMeEASkCADcCACAAQfzGhAEpAgA3AgALHwAgAEEIakGUx4QBKQIANwIAIABBjMeEASkCADcCAAsfACAAQQhqQaTHhAEpAgA3AgAgAEGcx4QBKQIANwIACx8AIABBCGpBtMeEASkCADcCACAAQazHhAEpAgA3AgALHwAgAEEIakHEx4QBKQIANwIAIABBvMeEASkCADcCAAsfACAAQQhqQdTHhAEpAgA3AgAgAEHMx4QBKQIANwIACx8AIABBCGpB5MeEASkCADcCACAAQdzHhAEpAgA3AgALHwAgAEEIakH0x4QBKQIANwIAIABB7MeEASkCADcCAAsfACAAQQhqQYTIhAEpAgA3AgAgAEH8x4QBKQIANwIACx8AIABBCGpBlMiEASkCADcCACAAQYzIhAEpAgA3AgALHwAgAEEIakGkyIQBKQIANwIAIABBnMiEASkCADcCAAsfACAAQQhqQfjnhAEpAgA3AgAgAEHw54QBKQIANwIACx8AIABBCGpBiOiEASkCADcCACAAQYDohAEpAgA3AgALHwAgAEEIakGY6IQBKQIANwIAIABBkOiEASkCADcCAAsfACAAQQhqQajohAEpAgA3AgAgAEGg6IQBKQIANwIACx8AIABBCGpBuOiEASkCADcCACAAQbDohAEpAgA3AgALHwAgAEEIakHI6IQBKQIANwIAIABBwOiEASkCADcCAAsfACAAQQhqQdjohAEpAgA3AgAgAEHQ6IQBKQIANwIACx8AIABBCGpB6OiEASkCADcCACAAQeDohAEpAgA3AgALHwAgAEEIakHY9YQBKQIANwIAIABB0PWEASkCADcCAAsfACAAQQhqQej1hAEpAgA3AgAgAEHg9YQBKQIANwIACx8AIABBCGpB+PWEASkCADcCACAAQfD1hAEpAgA3AgALGQEBfyAAKAIEIgEgASAAKAIIQQN0ahD7IgsfACAAQQhqQbjIhQEpAgA3AgAgAEGwyIUBKQIANwIACx8AIABBCGpBuMmFASkCADcCACAAQbDJhQEpAgA3AgALHwAgAEEIakHIyYUBKQIANwIAIABBwMmFASkCADcCAAsfACAAQQhqQeTOhQEpAgA3AgAgAEHczoUBKQIANwIACx8AIABBCGpB9M6FASkCADcCACAAQezOhQEpAgA3AgALHwAgAEEIakGEz4UBKQIANwIAIABB/M6FASkCADcCAAsfACAAQQhqQcjqhQEpAgA3AgAgAEHA6oUBKQIANwIACx8AIABBCGpBuOqFASkCADcCACAAQbDqhQEpAgA3AgALHwAgAEEIakHA/4UBKQIANwIAIABBuP+FASkCADcCAAsfACAAQQhqQfiKhgEpAgA3AgAgAEHwioYBKQIANwIACx8AIABBCGpBiIuGASkCADcCACAAQYCLhgEpAgA3AgALHwAgAEEIakGYi4YBKQIANwIAIABBkIuGASkCADcCAAsfACAAQQhqQaiLhgEpAgA3AgAgAEGgi4YBKQIANwIACx8AIABBCGpBuIuGASkCADcCACAAQbCLhgEpAgA3AgALHwAgAEEIakHIi4YBKQIANwIAIABBwIuGASkCADcCAAsfACAAQQhqQaybhgEpAgA3AgAgAEGkm4YBKQIANwIACx8AIABBCGpBvJuGASkCADcCACAAQbSbhgEpAgA3AgALHwAgAEEIakHMm4YBKQIANwIAIABBxJuGASkCADcCAAsZACAAIAEoAgA2AgAgACABKAIEQQlqNgIEC3QBAn8gACgCACIAKAIAQQhqIQIgACgCBCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0ECdCEBA0AgACACNgIMIABBBGogAEEMakGg3ocBEMkUIAJBBGohAiABQQRrIgENAAsLIABBBGoQqSwgAEEQaiQACxkAIAAgASgCBDYCBCAAIAEoAgBBCGo2AgALGQAgACgCACIAKAIAQQhqIAAoAgQgARDcBwsZACAAKAIAIgAoAgBBCGogACgCBCABEKk9CxwAIAAoAgAoAgAiACgCACABIAAoAgQoAhARAgALHwAgAEEIakH07YcBKQIANwIAIABB7O2HASkCADcCAAsbACAAIAEoAgQgASgCCCABKAIMIAEoAhAQvxQLGwAgACABKAIEIAEoAgggASgCDCABKAIQEPoTCxcBAX8gABBTIgE2AgQgACABQQBHNgIACxcBAX8gABBUIgE2AgQgACABQQBHNgIACxcBAX8gABBVIgE2AgQgACABQQBHNgIACxcBAX8gABBWIgE2AgQgACABQQBHNgIACx8AIABBCGpB5KeJASkCADcCACAAQdyniQEpAgA3AgALHwAgAEEIakH0p4kBKQIANwIAIABB7KeJASkCADcCAAsWACAAIAFBAXI2AgQgACABaiABNgIACxUAIAFpQQFGIABBgICAgHggAWtNcQsZAQFvIAAlASABEDshAhDfEiIAIAImASAAC5YBAQR/EN8SIgEgACYBIwBB0ABrIgIkACACQQA6AEwgAiABNgJIIwBB4ABrIgEkACABQRBqIgQgAkEIakHIAPwKAAAgAUIBNwMIIAEgAUEIajYCXCABQdwAakG0yMIAEJM9IQMCQCABKQMIUA0AIAEtAFRBA0cNACAEEIAqCyABQeAAaiQAIAJB0ABqJAAgAyUBIAMQ8h8LFQAgACgCACIAQYQBTwRAIAAQ8h8LCxcAIABB7ABqQQAgACgCbEGAgICAeEcbCxMAIAAoAgAiAARAIABBADoAAAsLFwAgAEHEAGpBACAAKAJEQYCAgIB4RxsLEwAgAEHgAGpBACAAKQNgQghSGwsYACAAQZgCakEAIAAoApgCQYCAgIB4RxsLGAAgAEGkAmpBACAAKAKkAkGAgICAeEcbCxgAIABBsAJqQQAgACgCsAJBgICAgHhHGwsTACACBEAgACABIAL8CgAACyAACxIAIAIEQCAAIAEgAvwLAAsgAAsVACAAIAEgAiADIARBAUECQQAQrQILFQAgACABIAIgAyAEQQBBAkEAEK0CCxUAIAAgASACIAMgBEEAQQFBABCtAgsVACAAIAEgAiADIARBAEEAQQAQrQILFQAgACABIAIgAyAEQQFBAkECEK0CCxUAIAAgASACIAMgBEEAQQJBAhCtAgsVACAAIAEgAiADIARBAEEBQQIQrQILFQAgACABIAIgAyAEQQBBAEECEK0CCxUAIAAgASACIAMgBEEAQQJBAxCtAgsVACAAIAEgAiADIARBAEEBQQMQrQILFQAgACABIAIgAyAEQQBBAEEDEK0CCxUAIAAgASACIAMgBEECQQJBABCtAgsVACAAIAEgAiADIARBAkEBQQAQrQILFQAgACABIAIgAyAEQQJBAEEAEK0CCxUAIAAgASACIAMgBEECQQJBAhCtAgsVACAAIAEgAiADIARBAkEBQQIQrQILFQAgACABIAIgAyAEQQJBAEECEK0CCxUAIAAgASACIAMgBEECQQJBAxCtAgsVACAAIAEgAiADIARBAkEBQQMQrQILFQAgACABIAIgAyAEQQJBAEEDEK0CCxAAIAFBAnatIACtfkKPD3wLEQAgAEEybCABTSACQdQHS3ELFAAgACgCCCABTwRAIAAgATYCCAsLFwAgACACOgAFIAAgAToABCAAIAM2AgALFwAgACADNgIIIAAgAjYCBCAAIAE2AgALFAAgACABQRhqQQAgASgCGBsQ7iULEwAgACgCGEEARyAAKAIsQQBHcQsUACAAIAFBJGpBACABKAIkGxDuJQsTACAAKAIkQQBHIAAoAjhBAEdxCxUAIAAgAUHMAGpBACABKAJMGxDuJQsUACAAIAFBIGpBACABKAIgGxDuJQsTACAAKAIgQQBHIAAoAjRBAEdxCxMAIAAoAkxBAEcgACgCYEEAR3ELFAAgACABQRRqQQAgASgCFBsQ7iULFAAgACABQRxqQQAgASgCHBsQ7iULEwAgACgCHEEARyAAKAIwQQBHcQsTACAAKAIUQQBHIAAoAihBAEdxCxQAIAAgAUEsakEAIAEoAiwbEO4lCxMAIAAoAixBAEcgACgCQEEAR3ELFwEBf0HQ74oBKAIAIgAEfyAABRC1GQsLGQAgACgCACIAKAIAIAEgACgCBCgCDBECAAsVAQF/IAAoAjQiAQRAIAAgAREDAAsLFQEBfyAAKAIoIgEEQCAAIAERAwALCxkAIAAoAgAiACgCACABIAAoAgQoAhARAgALGQAgACgCACgCACIAKAIEIAAoAgggARDcBwsZACAAKAIAKAIAIgAoAgQgACgCCCABEKk9CxkAIAAoAgQgACgCCCABKAIEIAEoAggQwS4LEQAgACABIAEgAkECdGoQniQLFgAgACgCACIAQQE6ABQgAEEIahD5KAsXACAAIAI2AgggACABNgIEIAAgAjYCAAsXACAAQQA2AgggACACNgIEIAAgATYCAAsWACAAIAEQuCpBAWo2AgQgACABNgIACxcBAW8gACABEHohAhDfEiIAIAImASAACxcBAW8gACABEH0hAhDfEiIAIAImASAACxAAIAAgASABIAJqEMAmQQALEwAgAC0A7AJBA0YEQCAAEPcsCwsTACAALQDwAkEDRgRAIAAQ9ywLC/IFAQR/An8CQAJAAkACQAJAAkAgABCaPigCBCIEQXhxIgVBBEEIIARBA3EiBBsgAWpPBEAgBEEAIAFBJ2oiBCAFSRsNAQJAAkAgAkEJTwRAIAIgAxCbEiIHDQFBAAwKCyADQcz/e0sNAUEQIANBC2pBeHEgA0ELSRshASAAEJo+IgIgAigCBEF4cSIEEJg+IQUCQAJAAkAgAigCBCIGQQNxRQRAIAFBgAJJDQEgBkF4cSIEIAFBBHJJIAQgAWtBgYAIT3INAQwDCyABIARNDQFB1POKASgCACAFRwRAQdDzigEoAgAgBUcEQCAFKAIEIgZBAnENAiAGQXhxIgYgBGoiBCABSQ0CIAUgBhCFDyAEIAFrIgBBEE8NDCACIAQQ7iwMDQtByPOKASgCACAEaiIEIAFJDQECQCAEIAFrIgNBD00EQCACIAQQ7ixBACEDQQAhAAwBCyACIAEQmD4iACADEJg+IQQgAiABEO4sIAAgAxDQNCAEIAQoAgRBfnE2AgQLQdDzigEgADYCAEHI84oBIAM2AgAMDAtBzPOKASgCACAEaiIEIAFLDQkLIAMQrAEiAUUNAyADQXxBeCACKAIEIgJBA3EbIAJBeHFqIgIgAiADSxsiAgRAIAEgACAC/AoAAAsgABDwCSABDAsLIAQgAWsiAEEPSw0ICwwICyADIAEgASADSxsiAgRAIAcgACAC/AoAAAsgABCaPigCBCICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgBEsbDQQgABDwCQsgBwwHC0GIqYkBQS5BuKmJARCfKQALQcipiQFBLkH4qYkBEJ8pAAtBiKmJAUEuQbipiQEQnykAC0HIqYkBQS5B+KmJARCfKQALIAIgARCYPiEAIAIgARDuLCAAIAQgAWsiAUEBcjYCBEHM84oBIAE2AgBB1POKASAANgIAIAIQmT4MAgsgAiABEJg+IQMgAiABEO4sIAMgABDuLCADIAAQrg4LIAIQmT4LCxYAIAAoAgAiACgCFCAAKAIYIAEQqT0LEAAgACABIAEgAmoQgSZBAAsVACAAIAIgAxCTPjYCBCAAQQA2AgALsgUBDH8gASgCgAMhCyABKAKEAyEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJEPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApwCIgcEQCAHIAEoAqACRw0BCyADQQhqIAEQ2QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgCnAJFDQYLIANBCGogASACIAZrEJEPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ+BAgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAKAAyELIAEoAoQDIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgCnAIiBwRAIAcgASgCoAJHDQELIANBCGogARDTAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKcAkUNBgsgA0EIaiABIAIgBmsQlw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD6ECAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC54QAhB/AX4gASgCgAMhECABKAKEAyEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgCnAIiAyABKAKgAiIGRgR/IARBGGogASgCkAIgASgClAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENMCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCkAIgASgClAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCoAIhBiABKAKcAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0ApAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKQAiABKAKUAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlELYLDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCoAIgA2oiBzYCoAIgCSAGayEJIAEoApwCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQuhkgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ+hAgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAoADIRAgASgChAMhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApwCIgMgASgCoAIiBkYEfyAEQRhqIAEoApACIAEoApQCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDZAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoApACIAEoApQCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoAqACIQYgASgCnAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAKQCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCkAIgASgClAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRC3CwwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoAqACIANqIgc2AqACIAkgBmshCSABKAKcAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGELoZIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEPgQIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALsgUBDH8gASgCgAMhCyABKAKEAyEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJAPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApwCIgcEQCAHIAEoAqACRw0BCyADQQhqIAEQ0AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgCnAJFDQYLIANBCGogASACIAZrEJAPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ+RAgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAvHFgIYfwF+IAEoAoADIRUgASgChAMhAyMAQTBrIgwkAAJAAkACQCACRQRADAELIAxBDGohEiADKAIMIRYDQCACIBBrIQ9BACEDAkAgASkDAEIFUQ0AIAxBGGohByMAQUBqIgQkAAJAAkACQCAPBEAgAUGgAWohCyABQdAAaiETIARBLWohFCAPIQ0DQAJAAkACQAJAAkAgASgCnAIiAyABKAKgAiIFRgR/IARBGGogASgCkAIgASgClAIoAiARAAAgBC0ALCEFIAQpAiQhGyAEKAIgIQYgBCgCHCEDIAQoAhgiCEEIRwRAIAcgFC8AADsAFSAHQRdqIBRBAmotAAA6AAAgByAFOgAUIAcgGzcCDCAHIAY2AgggByADNgIEIAcgCDYCAAwLCyADQQJGDQIgBUEBcQ0BAkAgA0EBcQR/IAMFIBtCIIinIQYgG6dBACABKQMAQgRRGwtBAXEgBiANTXFFBEAgBEEYaiABENACIAQtABwhAyAEKAIYIgVBCEYNASAHIAQpAB03AAUgB0EUaiAEQSxqKAAANgAAIAdBDWogBEElaikAADcAACAHIAM6AAQgByAFNgIADAwLIARBGGogASgCkAIgASgClAIoAiQRAAAgBCgCGCIDQQhHBEAgByAEKQIcNwIEIAdBFGogBEEsaigCADYCACAHQQxqIARBJGopAgA3AgAgByADNgIADAwLIA0gBmshDQwGCyADQQFxRQRAIAdBCDYCACAHIA8gDWs2AgQMCwsgASgCoAIhBSABKAKcAgUgAwsgBWshAwJAIAEpAwBCBFIEQCAEQRhqIAEgDSADELkSIAQoAiAhBiAEKAIcIQUgBCgCGCIIQQhGDQEgByAEKQIkNwIMIAdBFGogBEEsaigCADYCACAHIAY2AgggByAFNgIEIAcgCDYCAAwLCyANIAMgAyANSxsiBSEDDAQLIAMgBkcEQCAGIQMMBAsgAS0ApAJBAUcNAyAFIA1PDQIgAS0ATCEGIAFBADoATCAFIAZqIQUMAwsgBEEYaiEGIwBBsAJrIgUkACAFQaABaiABKAKQAiABKAKUAigCHBEAACAFQZABaiIDIAVBsAFqKQMANwMAIAVBmAFqIgggBUG4AWopAwA3AwAgBSAFKQOoATcDiAECQCAFKQOgASIbQg1RBEAgBiAFKQOIATcDACAGQRBqIAgpAwA3AwAgBkEIaiADKQMANwMADAELIAVBKGogBUHAAWpB4AD8CgAAIAVBGGogBUGQAWopAwA3AwAgBUEgaiAFQZgBaikDADcDACAFIAUpA4gBNwMQIAUgGzcDCAJAAkACQCAbQgxRIBtCCVRyRQRAQQIhAyAbp0ELRg0BCyAFQaABakEnQQBBAUEBEKAYIAUoAqQBIQMgBSgCoAFBAUcNASADIAUoAqgBQfSOzwAQ/S8ACyAFQagCaiAFQZABaikDADcDACAFIAUpA4gBNwOgAiAGIAFBoAFqIAVBoAJqIAUoAiAgBS0AJCAFLQAlELoLDAELIAUoAqgBIghBpJTPAEEn/AoAACAGQSc2AgwgBiAINgIIIAYgAzYCBCAGQQA2AgAgG0IMUQ0BIBunQQlrIQMLIANBAkYgG0IJWnENACAFQQhqEJ8fCyAFQbACaiQAIAQoAhgiA0EIRg0DIAcgBCkCHDcCBCAHQRRqIARBLGooAgA2AgAgB0EMaiAEQSRqKQIANwIAIAcgAzYCAAwICyAHQQg2AgAgByAPIA1rNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCoAIgA2oiBjYCoAIgDSAFayENIAEoApwCIAZGDQAgAyIFIQYCQCATKQMAQgVRDQAgBEEYaiATIAUQww4gBCgCICEGIAQoAhwhBSAEKAIYIghBCEYNACAHIAQpAiQ3AgwgB0EUaiAEQSxqKAIANgIAIAcgBjYCCCAHIAU2AgQgByAINgIADAYLIAQgBTYCDCAEIAY2AhAgAyAGRw0EIARBGGohCUEAIQMjAEEgayIKJAACQAJAAkACQAJAIAspAwAiG0IGUQRAIApBFGpBDkEAQQFBARCgGCAKKAIYIQYgCigCFEEBRg0QIAooAhwiA0EGakGujM0AKQAANwAAIANBqIzNACkAADcAACAJQQ42AgwgCSADNgIIIAkgBjYCBCAJQQA2AgAMAQsCQAJAAkACQAJAAkBBASAbp0ECayAbQgFYG0EBaw4DAQIDAAsgCygCGCEIIApBCGogC0EIahDcOwJAAkAgCCAFIAUgCEsbIgZFDQAgCygCFCIOIAsoAhAiEU8NACAKKAIMIRcgCigCCCEYIAZBAWshGUEAIQYDQCAOQQRqIgMgF0sNAiAOQXxPDQkgCyAOIBhqKAAAIANqIg42AhQgBkEBaiEDIA4gEU8NASAGIBlHIAMhBg0ACwsgCSADNgIEIAlBCDYCACALIAggA2s2AhgMBgsgCkEUakEXQQBBAUEBEKAYIAooAhghBiAKKAIUQQFGDRQgCigCHCIDQQ9qQduGzQApAAA3AAAgA0EIakHUhs0AKQAANwAAIANBzIbNACkAADcAACAJQRc2AgwgCSADNgIIIAkgBjYCBCAJQQI2AgAMBQsgCygCUEGAgICAeEcNAyAKQRRqQStBAEEBQQEQoBggCigCGCEGIAooAhRBAUcNAgwTCyAFIAsoAhAiBiALKAIkIgNrIgggBSAISRsiCCADaiIRIAhJDQUgBiARSQ0GAkAgCEUEQEEAIQYMAQsgCygCDCADQQJ0aiEOQQAhBiAIIQMDQCAOKAIAIAZqIQYgDkEEaiEOIANBAWsiAw0ACwsgCyARNgIkIAkgCDYCBCAJQQg2AgAgCyALKAIoIAZqNgIoDAMLIAkgC0EIaiAFEKQLDAILIAooAhwiA0GokM0AQSv8CgAAIAlBKzYCDCAJIAM2AgggCSAGNgIEIAlBADYCAAwBCyALKAJYBEAgCSALIAUQkBQMAQsgCUIINwMACyAKQSBqJAAMAwsgDiADQeSQzQAQsTsACyADIBFBxJHNABCxOwALIBEgBkHEkc0AELA7AAsgBCgCHCEDIAQoAhgiBkEIRwRAIAcgBCkDIDcDCCAHQRBqIARBKGopAwA3AwAgByADNgIEIAcgBjYCAAwGCyAEIAM2AhQgAyAFRw0DCyANDQALCyAHQQg2AgAgByAPNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgB0EEaiAEQRhqEJkOIAdBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAdBBGogBEEYahCZDiAHQQA2AgALIARBQGskACAMKAIcIQMgDCgCGCIFQQhGDQAgACAMKQMgNwMIIABBEGogDEEoaikDADcDACAAIAM2AgQgACAFNgIADAMLIAMgEGohEAJAIAMgD08NACAMIBUgFhEAACAMKAIAIgNBCUYNAiAMKAIIIQ8gDCgCBCEFIANBCEcEQCAAIA82AgggACAFNgIEIAAgAzYCACAAIBIpAgA3AgwgAEEUaiASQQhqKAIANgIADAQLIAxBGGogASAFIA8Q+RAgDCgCGCIDQQhGDQAgACAMKQIcNwIEIABBFGogDEEsaigCADYCACAAQQxqIAxBJGopAgA3AgAgACADNgIADAMLIAIgEEsNAAsLIABBCDYCACAAIBA2AgQLIAxBMGokAA8LIAYgCigCHEHU/cwAEP0vAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQkg8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDVAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQkg8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhCLESAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC/0RAhB/AX4gASgC+AIhESABKAL8AiEFIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDiAFKAIMIRIDQCACIA1rIQxBACEFAkAgASkDAEIFUQ0AIAhBGGohBiMAQUBqIgMkAAJAAkACQCAMBEAgAUGgAWohCyABQdAAaiEPIANBLWohECAMIQoDQAJAAkACQAJAAkAgASgClAIiBSABKAKYAiIERgR/IANBGGogASgCiAIgASgCjAIoAiARAAAgAy0ALCEEIAMpAiQhEyADKAIgIQcgAygCHCEFIAMoAhgiCUEIRwRAIAYgEC8AADsAFSAGQRdqIBBBAmotAAA6AAAgBiAEOgAUIAYgEzcCDCAGIAc2AgggBiAFNgIEIAYgCTYCAAwLCyAFQQJGDQIgBEEBcQ0BAkAgBUEBcQR/IAUFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAKTXFFBEAgA0EYaiABENUCIAMtABwhBSADKAIYIgRBCEYNASAGIAMpAB03AAUgBkEUaiADQSxqKAAANgAAIAZBDWogA0ElaikAADcAACAGIAU6AAQgBiAENgIADAwLIANBGGogASgCiAIgASgCjAIoAiQRAAAgAygCGCIFQQhHBEAgBiADKQIcNwIEIAZBFGogA0EsaigCADYCACAGQQxqIANBJGopAgA3AgAgBiAFNgIADAwLIAogB2shCgwGCyAFQQFxRQRAIAZBCDYCACAGIAwgCms2AgQMCwsgASgCmAIhBCABKAKUAgUgBQsgBGshBQJAIAEpAwBCBFIEQCADQRhqIAEgCiAFELkSIAMoAiAhByADKAIcIQQgAygCGCIJQQhGDQEgBiADKQIkNwIMIAZBFGogA0EsaigCADYCACAGIAc2AgggBiAENgIEIAYgCTYCAAwLCyAKIAUgBSAKSxsiBCEFDAQLIAUgB0cEQCAHIQUMBAsgAS0AnAJBAUcNAyAEIApPDQIgAS0ATCEHIAFBADoATCAEIAdqIQQMAwsgA0EYaiEHIwBBsAJrIgQkACAEQaABaiABKAKIAiABKAKMAigCHBEAACAEQZABaiIFIARBsAFqKQMANwMAIARBmAFqIgkgBEG4AWopAwA3AwAgBCAEKQOoATcDiAECQCAEKQOgASITQg1RBEAgByAEKQOIATcDACAHQRBqIAkpAwA3AwAgB0EIaiAFKQMANwMADAELIARBKGogBEHAAWpB4AD8CgAAIARBGGogBEGQAWopAwA3AwAgBEEgaiAEQZgBaikDADcDACAEIAQpA4gBNwMQIAQgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhBSATp0ELRg0BCyAEQaABakEnQQBBAUEBEKAYIAQoAqQBIQUgBCgCoAFBAUcNASAFIAQoAqgBQfSOzwAQ/S8ACyAEQagCaiAEQZABaikDADcDACAEIAQpA4gBNwOgAiAHIAFBoAFqIARBoAJqIAQoAiAgBC0AJCAELQAlEJ8QDAELIAQoAqgBIglBpJTPAEEn/AoAACAHQSc2AgwgByAJNgIIIAcgBTYCBCAHQQA2AgAgE0IMUQ0BIBOnQQlrIQULIAVBAkYgE0IJWnENACAEQQhqEJ8fCyAEQbACaiQAIAMoAhgiBUEIRg0DIAYgAykCHDcCBCAGQRRqIANBLGooAgA2AgAgBkEMaiADQSRqKQIANwIAIAYgBTYCAAwICyAGQQg2AgAgBiAMIAprNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgAyAFNgIIIAEgASgCmAIgBWoiBzYCmAIgCiAEayEKIAEoApQCIAdGDQAgBSIEIQcCQCAPKQMAQgVRDQAgA0EYaiAPIAQQww4gAygCICEHIAMoAhwhBCADKAIYIglBCEYNACAGIAMpAiQ3AgwgBkEUaiADQSxqKAIANgIAIAYgBzYCCCAGIAQ2AgQgBiAJNgIADAYLIAMgBDYCDCADIAc2AhAgBSAHRw0EIANBGGohBQJAIAspAwAiE0IGUgRAAkACQAJAAkBBASATp0ECayATQgFYG0EBaw4DAgADAQsgBSALQQhqIAQQpAsMBAsgCygCYCIHBEAgBUEINgIAIAUgCygCECALKAIYIgVrIAduIgkgBCAEIAlLGyIJNgIEIAsgBSAHIAlsajYCGAwEC0H4ns0AEOIrAAsgBSALIAQQkBQMAgsgCygCYCIHBEAgBUEINgIAIAUgCygCECAHbiALKAIYIgVrIgcgBCAEIAdLGyIHNgIEIAsgBSAHajYCGAwCC0GIn80AEOIrAAtB6J7NABCyOwALIAMoAhwhBSADKAIYIgdBCEcEQCAGIAMpAyA3AwggBkEQaiADQShqKQMANwMAIAYgBTYCBCAGIAc2AgAMBgsgAyAFNgIUIAQgBUcNAwsgCg0ACwsgBkEINgIAIAYgDDYCBAwCCyADQQI2AhwgA0G8k88ANgIYIANCAjcCJCADQTs2AjwgA0E7NgI0IAMgA0EwajYCICADIANBDGo2AjggAyADQRRqNgIwIAZBBGogA0EYahCZDiAGQQA2AgAMAQsgA0EDNgIcIANBjJTPADYCGCADQgI3AiQgA0E7NgI8IANBOzYCNCADIANBMGo2AiAgAyADQRBqNgI4IAMgA0EIajYCMCAGQQRqIANBGGoQmQ4gBkEANgIACyADQUBrJAAgCCgCHCEFIAgoAhgiBEEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACAFNgIEIAAgBDYCAAwDCyAFIA1qIQ0CQCAFIAxPDQAgCCARIBIRAAAgCCgCACIFQQlGDQIgCCgCCCEMIAgoAgQhBCAFQQhHBEAgACAMNgIIIAAgBDYCBCAAIAU2AgAgACAOKQIANwIMIABBFGogDkEIaigCADYCAAwECyAIQRhqIAEgBCAMEIsRIAgoAhgiBUEIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgBTYCAAwDCyACIA1LDQALCyAAQQg2AgAgACANNgIECyAIQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJgPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ1gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJgPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDXAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQlQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCODwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABEOACIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCODyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL0LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKQPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ2AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKQPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQoQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDkAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQoQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCnDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENICIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCnDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJkPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ3gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJkPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQnQ8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDjAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQnQ8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC9CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCaDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENwCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCaDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL0LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJQPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ3AIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEJQPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvQsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQoA8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDcAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQoA8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC9CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhClDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABEOICIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxClDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKMPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ0gIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKMPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvgsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAL4AiELIAEoAvwCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQkw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgClAIiBwRAIAcgASgCmAJHDQELIANBCGogARDSAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKAKUAkUNBgsgA0EIaiABIAIgBmsQkw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhC+CyAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoAvgCIQsgASgC/AIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCfDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKAKUAiIHBEAgByABKAKYAkcNAQsgA0EIaiABENsCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoApQCRQ0GCyADQQhqIAEgAiAGaxCfDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEL4LIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgC+AIhCyABKAL8AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEKYPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoApQCIgcEQCAHIAEoApgCRw0BCyADQQhqIAEQ5QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgClAJFDQYLIANBCGogASACIAZrEKYPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQvgsgBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDlAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCJCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ3AIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQjAoMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC9CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENICIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI0KDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvgsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDkAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCHCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ2wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQiwkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC+CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENgCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI4JDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDeAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCMCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL0LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ4wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQhQkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC9CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEOACIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEIoJDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoAvgCIRAgASgC/AIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoApQCIgMgASgCmAIiBkYEfyAEQRhqIAEoAogCIAEoAowCKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDiAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAogCIAEoAowCKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoApgCIQYgASgClAIFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtAJwCQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCiAIgASgCjAIoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRCGCQwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoApgCIANqIgc2ApgCIAkgBmshCSABKAKUAiAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEN8jIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEL4LIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAL4AiEQIAEoAvwCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKAKUAiIDIAEoApgCIgZGBH8gBEEYaiABKAKIAiABKAKMAigCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ1wIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKAKIAiABKAKMAigCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKAKYAiEGIAEoApQCBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQCcAkEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAogCIAEoAowCKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQiAkMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKAKYAiADaiIHNgKYAiAJIAZrIQkgASgClAIgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDfIyAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChC+CyAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgC+AIhECABKAL8AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgClAIiAyABKAKYAiIGRgR/IARBGGogASgCiAIgASgCjAIoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENYCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCiAIgASgCjAIoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgCmAIhBiABKAKUAgUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0AnAJBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKAKIAiABKAKMAigCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEI0JDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgCmAIgA2oiBzYCmAIgCSAGayEJIAEoApQCIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQ3yMgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQvQsgCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQjw8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDfAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQjw8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEN8CIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEOoHDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQng8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDhAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQng8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoArACIQsgASgCtAIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCbDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKALUASIHBEAgByABKALYAUcNAQsgA0EIaiABENQCIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoAtQBRQ0GCyADQQhqIAEgAiAGaxCbDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEPUKIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALsgUBDH8gASgCsAIhCyABKAK0AiEGIwBBMGsiBCQAAkACQCACIglFBEAMAQsgBEEMaiEKIAYoAgwhDANAIARBGGohBSAJIAhrIg0hAkEAIQYjAEEgayIDJAACQAJAAkAgASkDAEIFUgRAIANBCGogASACEJwPAkACQCADKAIIIgdBCEYEQANAIAIgAygCDCAGaiIGRg0GIAEpAwBCBVENAgJAIAEoAtQBIgcEQCAHIAEoAtgBRw0BCyADQQhqIAEQ0QIgAy0ADCEHIAMoAggiDkEIRw0EIAdBAXFFDQYgASgC1AFFDQYLIANBCGogASACIAZrEJwPIAMoAggiB0EIRg0ACwsgBSADKQMQNwMIIAVBEGogA0EYaikDADcDACAFIAMoAgw2AgQgBSAHNgIADAULQaSHzQAQsjsACyAFIAMpAA03AAUgBUEUaiADQRxqKAAANgAAIAVBDWogA0EVaikAADcAACAFIAc6AAQgBSAONgIADAMLIAVCCDcDAAwCCyAGIQILIAVBCDYCACAFIAI2AgQLIANBIGokACAEKAIcIQIgBCgCGCIGQQhHBEAgACAEKQMgNwMIIABBEGogBEEoaikDADcDACAAIAI2AgQgACAGNgIADAMLIAIgCGohCAJAIAIgDU8NACAEIAsgDBEAACAEKAIAIgJBCUYNAiAEKAIIIQYgBCgCBCEDIAJBCEcEQCAAIAY2AgggACADNgIEIAAgAjYCACAAIAopAgA3AgwgAEEUaiAKQQhqKAIANgIADAQLIARBGGogASADIAYQ9QogBCgCGCICQQhGDQAgACAEKQIcNwIEIABBFGogBEEsaigCADYCACAAQQxqIARBJGopAgA3AgAgACACNgIADAMLIAggCUkNAAsLIABBCDYCACAAIAg2AgQLIARBMGokAAuyBQEMfyABKAKwAiELIAEoArQCIQYjAEEwayIEJAACQAJAIAIiCUUEQAwBCyAEQQxqIQogBigCDCEMA0AgBEEYaiEFIAkgCGsiDSECQQAhBiMAQSBrIgMkAAJAAkACQCABKQMAQgVSBEAgA0EIaiABIAIQlg8CQAJAIAMoAggiB0EIRgRAA0AgAiADKAIMIAZqIgZGDQYgASkDAEIFUQ0CAkAgASgC1AEiBwRAIAcgASgC2AFHDQELIANBCGogARDaAiADLQAMIQcgAygCCCIOQQhHDQQgB0EBcUUNBiABKALUAUUNBgsgA0EIaiABIAIgBmsQlg8gAygCCCIHQQhGDQALCyAFIAMpAxA3AwggBUEQaiADQRhqKQMANwMAIAUgAygCDDYCBCAFIAc2AgAMBQtBpIfNABCyOwALIAUgAykADTcABSAFQRRqIANBHGooAAA2AAAgBUENaiADQRVqKQAANwAAIAUgBzoABCAFIA42AgAMAwsgBUIINwMADAILIAYhAgsgBUEINgIAIAUgAjYCBAsgA0EgaiQAIAQoAhwhAiAEKAIYIgZBCEcEQCAAIAQpAyA3AwggAEEQaiAEQShqKQMANwMAIAAgAjYCBCAAIAY2AgAMAwsgAiAIaiEIAkAgAiANTw0AIAQgCyAMEQAAIAQoAgAiAkEJRg0CIAQoAgghBiAEKAIEIQMgAkEIRwRAIAAgBjYCCCAAIAM2AgQgACACNgIAIAAgCikCADcCDCAAQRRqIApBCGooAgA2AgAMBAsgBEEYaiABIAMgBhD1CiAEKAIYIgJBCEYNACAAIAQpAhw3AgQgAEEUaiAEQSxqKAIANgIAIABBDGogBEEkaikCADcCACAAIAI2AgAMAwsgCCAJSQ0ACwsgAEEINgIAIAAgCDYCBAsgBEEwaiQAC7IFAQx/IAEoArACIQsgASgCtAIhBiMAQTBrIgQkAAJAAkAgAiIJRQRADAELIARBDGohCiAGKAIMIQwDQCAEQRhqIQUgCSAIayINIQJBACEGIwBBIGsiAyQAAkACQAJAIAEpAwBCBVIEQCADQQhqIAEgAhCiDwJAAkAgAygCCCIHQQhGBEADQCACIAMoAgwgBmoiBkYNBiABKQMAQgVRDQICQCABKALUASIHBEAgByABKALYAUcNAQsgA0EIaiABEN0CIAMtAAwhByADKAIIIg5BCEcNBCAHQQFxRQ0GIAEoAtQBRQ0GCyADQQhqIAEgAiAGaxCiDyADKAIIIgdBCEYNAAsLIAUgAykDEDcDCCAFQRBqIANBGGopAwA3AwAgBSADKAIMNgIEIAUgBzYCAAwFC0Gkh80AELI7AAsgBSADKQANNwAFIAVBFGogA0EcaigAADYAACAFQQ1qIANBFWopAAA3AAAgBSAHOgAEIAUgDjYCAAwDCyAFQgg3AwAMAgsgBiECCyAFQQg2AgAgBSACNgIECyADQSBqJAAgBCgCHCECIAQoAhgiBkEIRwRAIAAgBCkDIDcDCCAAQRBqIARBKGopAwA3AwAgACACNgIEIAAgBjYCAAwDCyACIAhqIQgCQCACIA1PDQAgBCALIAwRAAAgBCgCACICQQlGDQIgBCgCCCEGIAQoAgQhAyACQQhHBEAgACAGNgIIIAAgAzYCBCAAIAI2AgAgACAKKQIANwIMIABBFGogCkEIaigCADYCAAwECyAEQRhqIAEgAyAGEPUKIAQoAhgiAkEIRg0AIAAgBCkCHDcCBCAAQRRqIARBLGooAgA2AgAgAEEMaiAEQSRqKQIANwIAIAAgAjYCAAwDCyAIIAlJDQALCyAAQQg2AgAgACAINgIECyAEQTBqJAALnhACEH8BfiABKAKwAiEQIAEoArQCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKALUASIDIAEoAtgBIgZGBH8gBEEYaiABKALIASABKALMASgCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ0QIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKALIASABKALMASgCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKALYASEGIAEoAtQBBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQDcAUEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAsgBIAEoAswBKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQ7AcMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKALYASADaiIHNgLYASAJIAZrIQkgASgC1AEgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDHECAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChD1CiAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABEOECIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlENcHDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAueEAIQfwF+IAEoArACIRAgASgCtAIhAyMAQTBrIggkAAJAAkAgAkUEQAwBCyAIQQxqIQ0gAygCDCERA0AgAiAMayEKQQAhAwJAIAEpAwBCBVENACAIQRhqIQUjAEFAaiIEJAACQAJAAkAgCgRAIAFBoAFqIRIgAUHQAGohDiAEQS1qIQ8gCiEJA0ACQAJAAkACQAJAIAEoAtQBIgMgASgC2AEiBkYEfyAEQRhqIAEoAsgBIAEoAswBKAIgEQAAIAQtACwhBiAEKQIkIRMgBCgCICEHIAQoAhwhAyAEKAIYIgtBCEcEQCAFIA8vAAA7ABUgBUEXaiAPQQJqLQAAOgAAIAUgBjoAFCAFIBM3AgwgBSAHNgIIIAUgAzYCBCAFIAs2AgAMCwsgA0ECRg0CIAZBAXENAQJAIANBAXEEfyADBSATQiCIpyEHIBOnQQAgASkDAEIEURsLQQFxIAcgCU1xRQRAIARBGGogARDdAiAELQAcIQMgBCgCGCIGQQhGDQEgBSAEKQAdNwAFIAVBFGogBEEsaigAADYAACAFQQ1qIARBJWopAAA3AAAgBSADOgAEIAUgBjYCAAwMCyAEQRhqIAEoAsgBIAEoAswBKAIkEQAAIAQoAhgiA0EIRwRAIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwMCyAJIAdrIQkMBgsgA0EBcUUEQCAFQQg2AgAgBSAKIAlrNgIEDAsLIAEoAtgBIQYgASgC1AEFIAMLIAZrIQMCQCABKQMAQgRSBEAgBEEYaiABIAkgAxC5EiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0BIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMCwsgCSADIAMgCUsbIgYhAwwECyADIAdHBEAgByEDDAQLIAEtANwBQQFHDQMgBiAJTw0CIAEtAEwhByABQQA6AEwgBiAHaiEGDAMLIARBGGohBiMAQbACayIDJAAgA0GgAWogASgCyAEgASgCzAEoAhwRAAAgA0GQAWoiByADQbABaikDADcDACADQZgBaiILIANBuAFqKQMANwMAIAMgAykDqAE3A4gBAkAgAykDoAEiE0INUQRAIAYgAykDiAE3AwAgBkEQaiALKQMANwMAIAZBCGogBykDADcDAAwBCyADQShqIANBwAFqQeAA/AoAACADQRhqIANBkAFqKQMANwMAIANBIGogA0GYAWopAwA3AwAgAyADKQOIATcDECADIBM3AwgCQAJAAkAgE0IMUSATQglUckUEQEECIQcgE6dBC0YNAQsgA0GgAWpBJ0EAQQFBARCgGCADKAKkASEHIAMoAqABQQFHDQEgByADKAKoAUH0js8AEP0vAAsgA0GoAmogA0GQAWopAwA3AwAgAyADKQOIATcDoAIgBiABQaABaiADQaACaiADKAIgIAMtACQgAy0AJRDrBwwBCyADKAKoASILQaSUzwBBJ/wKAAAgBkEnNgIMIAYgCzYCCCAGIAc2AgQgBkEANgIAIBNCDFENASATp0EJayEHCyAHQQJGIBNCCVpxDQAgA0EIahCfHwsgA0GwAmokACAEKAIYIgNBCEYNAyAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMCAsgBUEINgIAIAUgCiAJazYCBAwHC0HnkM8AQTJBkJPPABCfKQALIAQgAzYCCCABIAEoAtgBIANqIgc2AtgBIAkgBmshCSABKALUASAHRg0AIAMhBiADIQcCQCAOKQMAQgVRDQAgBEEYaiAOIAMQww4gBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNACAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAYLIAQgBjYCDCAEIAc2AhAgAyAHRw0EIARBGGogEiAGEMcQIAQoAhwhAyAEKAIYIgdBCEcEQCAFIAQpAyA3AwggBUEQaiAEQShqKQMANwMAIAUgAzYCBCAFIAc2AgAMBgsgBCADNgIUIAMgBkcNAwsgCQ0ACwsgBUEINgIAIAUgCjYCBAwCCyAEQQI2AhwgBEG8k88ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBDGo2AjggBCAEQRRqNgIwIAVBBGogBEEYahCZDiAFQQA2AgAMAQsgBEEDNgIcIARBjJTPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQRBqNgI4IAQgBEEIajYCMCAFQQRqIARBGGoQmQ4gBUEANgIACyAEQUBrJAAgCCgCHCEDIAgoAhgiBkEIRg0AIAAgCCkDIDcDCCAAQRBqIAhBKGopAwA3AwAgACADNgIEIAAgBjYCAAwDCyADIAxqIQwCQCADIApPDQAgCCAQIBERAAAgCCgCACIDQQlGDQIgCCgCCCEKIAgoAgQhBiADQQhHBEAgACAKNgIIIAAgBjYCBCAAIAM2AgAgACANKQIANwIMIABBFGogDUEIaigCADYCAAwECyAIQRhqIAEgBiAKEPUKIAgoAhgiA0EIRg0AIAAgCCkCHDcCBCAAQRRqIAhBLGooAgA2AgAgAEEMaiAIQSRqKQIANwIAIAAgAzYCAAwDCyACIAxLDQALCyAAQQg2AgAgACAMNgIECyAIQTBqJAALnhACEH8BfiABKAKwAiEQIAEoArQCIQMjAEEwayIIJAACQAJAIAJFBEAMAQsgCEEMaiENIAMoAgwhEQNAIAIgDGshCkEAIQMCQCABKQMAQgVRDQAgCEEYaiEFIwBBQGoiBCQAAkACQAJAIAoEQCABQaABaiESIAFB0ABqIQ4gBEEtaiEPIAohCQNAAkACQAJAAkACQCABKALUASIDIAEoAtgBIgZGBH8gBEEYaiABKALIASABKALMASgCIBEAACAELQAsIQYgBCkCJCETIAQoAiAhByAEKAIcIQMgBCgCGCILQQhHBEAgBSAPLwAAOwAVIAVBF2ogD0ECai0AADoAACAFIAY6ABQgBSATNwIMIAUgBzYCCCAFIAM2AgQgBSALNgIADAsLIANBAkYNAiAGQQFxDQECQCADQQFxBH8gAwUgE0IgiKchByATp0EAIAEpAwBCBFEbC0EBcSAHIAlNcUUEQCAEQRhqIAEQ2gIgBC0AHCEDIAQoAhgiBkEIRg0BIAUgBCkAHTcABSAFQRRqIARBLGooAAA2AAAgBUENaiAEQSVqKQAANwAAIAUgAzoABCAFIAY2AgAMDAsgBEEYaiABKALIASABKALMASgCJBEAACAEKAIYIgNBCEcEQCAFIAQpAhw3AgQgBUEUaiAEQSxqKAIANgIAIAVBDGogBEEkaikCADcCACAFIAM2AgAMDAsgCSAHayEJDAYLIANBAXFFBEAgBUEINgIAIAUgCiAJazYCBAwLCyABKALYASEGIAEoAtQBBSADCyAGayEDAkAgASkDAEIEUgRAIARBGGogASAJIAMQuRIgBCgCICEHIAQoAhwhBiAEKAIYIgtBCEYNASAFIAQpAiQ3AgwgBUEUaiAEQSxqKAIANgIAIAUgBzYCCCAFIAY2AgQgBSALNgIADAsLIAkgAyADIAlLGyIGIQMMBAsgAyAHRwRAIAchAwwECyABLQDcAUEBRw0DIAYgCU8NAiABLQBMIQcgAUEAOgBMIAYgB2ohBgwDCyAEQRhqIQYjAEGwAmsiAyQAIANBoAFqIAEoAsgBIAEoAswBKAIcEQAAIANBkAFqIgcgA0GwAWopAwA3AwAgA0GYAWoiCyADQbgBaikDADcDACADIAMpA6gBNwOIAQJAIAMpA6ABIhNCDVEEQCAGIAMpA4gBNwMAIAZBEGogCykDADcDACAGQQhqIAcpAwA3AwAMAQsgA0EoaiADQcABakHgAPwKAAAgA0EYaiADQZABaikDADcDACADQSBqIANBmAFqKQMANwMAIAMgAykDiAE3AxAgAyATNwMIAkACQAJAIBNCDFEgE0IJVHJFBEBBAiEHIBOnQQtGDQELIANBoAFqQSdBAEEBQQEQoBggAygCpAEhByADKAKgAUEBRw0BIAcgAygCqAFB9I7PABD9LwALIANBqAJqIANBkAFqKQMANwMAIAMgAykDiAE3A6ACIAYgAUGgAWogA0GgAmogAygCICADLQAkIAMtACUQ7gcMAQsgAygCqAEiC0GklM8AQSf8CgAAIAZBJzYCDCAGIAs2AgggBiAHNgIEIAZBADYCACATQgxRDQEgE6dBCWshBwsgB0ECRiATQglacQ0AIANBCGoQnx8LIANBsAJqJAAgBCgCGCIDQQhGDQMgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAgLIAVBCDYCACAFIAogCWs2AgQMBwtB55DPAEEyQZCTzwAQnykACyAEIAM2AgggASABKALYASADaiIHNgLYASAJIAZrIQkgASgC1AEgB0YNACADIQYgAyEHAkAgDikDAEIFUQ0AIARBGGogDiADEMMOIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQAgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwGCyAEIAY2AgwgBCAHNgIQIAMgB0cNBCAEQRhqIBIgBhDHECAEKAIcIQMgBCgCGCIHQQhHBEAgBSAEKQMgNwMIIAVBEGogBEEoaikDADcDACAFIAM2AgQgBSAHNgIADAYLIAQgAzYCFCADIAZHDQMLIAkNAAsLIAVBCDYCACAFIAo2AgQMAgsgBEECNgIcIARBvJPPADYCGCAEQgI3AiQgBEE7NgI8IARBOzYCNCAEIARBMGo2AiAgBCAEQQxqNgI4IAQgBEEUajYCMCAFQQRqIARBGGoQmQ4gBUEANgIADAELIARBAzYCHCAEQYyUzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEQajYCOCAEIARBCGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAsgBEFAayQAIAgoAhwhAyAIKAIYIgZBCEYNACAAIAgpAyA3AwggAEEQaiAIQShqKQMANwMAIAAgAzYCBCAAIAY2AgAMAwsgAyAMaiEMAkAgAyAKTw0AIAggECAREQAAIAgoAgAiA0EJRg0CIAgoAgghCiAIKAIEIQYgA0EIRwRAIAAgCjYCCCAAIAY2AgQgACADNgIAIAAgDSkCADcCDCAAQRRqIA1BCGooAgA2AgAMBAsgCEEYaiABIAYgChD1CiAIKAIYIgNBCEYNACAAIAgpAhw3AgQgAEEUaiAIQSxqKAIANgIAIABBDGogCEEkaikCADcCACAAIAM2AgAMAwsgAiAMSw0ACwsgAEEINgIAIAAgDDYCBAsgCEEwaiQAC54QAhB/AX4gASgCsAIhECABKAK0AiEDIwBBMGsiCCQAAkACQCACRQRADAELIAhBDGohDSADKAIMIREDQCACIAxrIQpBACEDAkAgASkDAEIFUQ0AIAhBGGohBSMAQUBqIgQkAAJAAkACQCAKBEAgAUGgAWohEiABQdAAaiEOIARBLWohDyAKIQkDQAJAAkACQAJAAkAgASgC1AEiAyABKALYASIGRgR/IARBGGogASgCyAEgASgCzAEoAiARAAAgBC0ALCEGIAQpAiQhEyAEKAIgIQcgBCgCHCEDIAQoAhgiC0EIRwRAIAUgDy8AADsAFSAFQRdqIA9BAmotAAA6AAAgBSAGOgAUIAUgEzcCDCAFIAc2AgggBSADNgIEIAUgCzYCAAwLCyADQQJGDQIgBkEBcQ0BAkAgA0EBcQR/IAMFIBNCIIinIQcgE6dBACABKQMAQgRRGwtBAXEgByAJTXFFBEAgBEEYaiABENQCIAQtABwhAyAEKAIYIgZBCEYNASAFIAQpAB03AAUgBUEUaiAEQSxqKAAANgAAIAVBDWogBEElaikAADcAACAFIAM6AAQgBSAGNgIADAwLIARBGGogASgCyAEgASgCzAEoAiQRAAAgBCgCGCIDQQhHBEAgBSAEKQIcNwIEIAVBFGogBEEsaigCADYCACAFQQxqIARBJGopAgA3AgAgBSADNgIADAwLIAkgB2shCQwGCyADQQFxRQRAIAVBCDYCACAFIAogCWs2AgQMCwsgASgC2AEhBiABKALUAQUgAwsgBmshAwJAIAEpAwBCBFIEQCAEQRhqIAEgCSADELkSIAQoAiAhByAEKAIcIQYgBCgCGCILQQhGDQEgBSAEKQIkNwIMIAVBFGogBEEsaigCADYCACAFIAc2AgggBSAGNgIEIAUgCzYCAAwLCyAJIAMgAyAJSxsiBiEDDAQLIAMgB0cEQCAHIQMMBAsgAS0A3AFBAUcNAyAGIAlPDQIgAS0ATCEHIAFBADoATCAGIAdqIQYMAwsgBEEYaiEGIwBBsAJrIgMkACADQaABaiABKALIASABKALMASgCHBEAACADQZABaiIHIANBsAFqKQMANwMAIANBmAFqIgsgA0G4AWopAwA3AwAgAyADKQOoATcDiAECQCADKQOgASITQg1RBEAgBiADKQOIATcDACAGQRBqIAspAwA3AwAgBkEIaiAHKQMANwMADAELIANBKGogA0HAAWpB4AD8CgAAIANBGGogA0GQAWopAwA3AwAgA0EgaiADQZgBaikDADcDACADIAMpA4gBNwMQIAMgEzcDCAJAAkACQCATQgxRIBNCCVRyRQRAQQIhByATp0ELRg0BCyADQaABakEnQQBBAUEBEKAYIAMoAqQBIQcgAygCoAFBAUcNASAHIAMoAqgBQfSOzwAQ/S8ACyADQagCaiADQZABaikDADcDACADIAMpA4gBNwOgAiAGIAFBoAFqIANBoAJqIAMoAiAgAy0AJCADLQAlEO0HDAELIAMoAqgBIgtBpJTPAEEn/AoAACAGQSc2AgwgBiALNgIIIAYgBzYCBCAGQQA2AgAgE0IMUQ0BIBOnQQlrIQcLIAdBAkYgE0IJWnENACADQQhqEJ8fCyADQbACaiQAIAQoAhgiA0EIRg0DIAUgBCkCHDcCBCAFQRRqIARBLGooAgA2AgAgBUEMaiAEQSRqKQIANwIAIAUgAzYCAAwICyAFQQg2AgAgBSAKIAlrNgIEDAcLQeeQzwBBMkGQk88AEJ8pAAsgBCADNgIIIAEgASgC2AEgA2oiBzYC2AEgCSAGayEJIAEoAtQBIAdGDQAgAyEGIAMhBwJAIA4pAwBCBVENACAEQRhqIA4gAxDDDiAEKAIgIQcgBCgCHCEGIAQoAhgiC0EIRg0AIAUgBCkCJDcCDCAFQRRqIARBLGooAgA2AgAgBSAHNgIIIAUgBjYCBCAFIAs2AgAMBgsgBCAGNgIMIAQgBzYCECADIAdHDQQgBEEYaiASIAYQxxAgBCgCHCEDIAQoAhgiB0EIRwRAIAUgBCkDIDcDCCAFQRBqIARBKGopAwA3AwAgBSADNgIEIAUgBzYCAAwGCyAEIAM2AhQgAyAGRw0DCyAJDQALCyAFQQg2AgAgBSAKNgIEDAILIARBAjYCHCAEQbyTzwA2AhggBEICNwIkIARBOzYCPCAEQTs2AjQgBCAEQTBqNgIgIAQgBEEMajYCOCAEIARBFGo2AjAgBUEEaiAEQRhqEJkOIAVBADYCAAwBCyAEQQM2AhwgBEGMlM8ANgIYIARCAjcCJCAEQTs2AjwgBEE7NgI0IAQgBEEwajYCICAEIARBEGo2AjggBCAEQQhqNgIwIAVBBGogBEEYahCZDiAFQQA2AgALIARBQGskACAIKAIcIQMgCCgCGCIGQQhGDQAgACAIKQMgNwMIIABBEGogCEEoaikDADcDACAAIAM2AgQgACAGNgIADAMLIAMgDGohDAJAIAMgCk8NACAIIBAgEREAACAIKAIAIgNBCUYNAiAIKAIIIQogCCgCBCEGIANBCEcEQCAAIAo2AgggACAGNgIEIAAgAzYCACAAIA0pAgA3AgwgAEEUaiANQQhqKAIANgIADAQLIAhBGGogASAGIAoQ9QogCCgCGCIDQQhGDQAgACAIKQIcNwIEIABBFGogCEEsaigCADYCACAAQQxqIAhBJGopAgA3AgAgACADNgIADAMLIAIgDEsNAAsLIABBCDYCACAAIAw2AgQLIAhBMGokAAtxAQJ/IAAoAgAiACgCBCECIAAoAgghAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBDGwhAQNAIAAgAjYCDCAAQQRqIABBDGpB+JfPABDJFCACQQxqIQIgAUEMayIBDQALCyAAQQRqEKksIABBEGokAAtxAQJ/IAAoAgAiACgCBCECIAAoAgghAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAnQhAQNAIAAgAjYCDCAAQQRqIABBDGpB6JfPABDJFCACQQRqIQIgAUEEayIBDQALCyAAQQRqEKksIABBEGokAAsWACAAIAEoAgwgAiABKAIQKAIcEQEACxYAIAAgASgCGCACIAEoAhwoAhwRAQALGwAgABCyEiAAQYCAgIB4NgKYASAAQQA6AKQBCw0AIAAgAUHAAvwKAAALEgAgACgCAEEJRwRAIAAQ1icLCxMAIABBBGsiACAAKAIAQQQQ+DoLFgAgACABKAIAIAEoAgwQgywgABCLJgsRACAAIAEgAiADIARBABDMAgsRACAAIAFBP2pBQHFBAhCmJAsWACAAIAEoAgAgASgCDBCFLCAAEIsmCxMAIAAgASACIAMgBEEAQQAQrAMLEwAgACABIAIgAyAEQQBBARCsAwsTACAAIAEgAiADIARBAEECEKwDCxMAIAAgASACIAMgBEEBQQIQrAMLEwAgACABIAIgAyAEQQJBABCsAwsTACAAIAEgAiADIARBAkEBEKwDCxMAIAAgASACIAMgBEECQQIQrAMLEwAgACABIAIgAyAEQQAgBRCwAQsTACAAIAEgAiADIARBAiAFELABCxAAIAIEQCABIAJBARD4OgsLFgAgACgCACIAKAIEIAAoAgggARDFIwsWACAAKAIAIgAoAgQgACgCCCABENwHCxAAIAAgASABIAJqEI4mQQALcQECfyAAKAIAIgAoAgQhAiAAKAIIIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQRRsIQEDQCAAIAI2AgwgAEEEaiAAQQxqQZT0/gAQyRQgAkEUaiECIAFBFGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALEAAgACABIAEgAmoQvSZBAAsVACAAKAIAIgAQqgwgAEEMQQQQ+DoLFAAgACAAKAIIIAFBAUEBIAIQwygLEgAgAEEMahCRLyAAQTxqEPkjCxIAIABBDGoQ1B4gAEEgahD5IwsTACAAIAAgACgCACIAajYCACAACxYAIAAoAgAiACgCBCAAKAIIIAEQqT0LEAAgACABIAEgAmoQuyZBAAsVACAAKAIAIgAQygwgAEEMQQQQ+DoLcQECfyAAKAIAIgAoAgQhAiAAKAIIIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQR0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQey6hwEQyRQgAkEQaiECIAFBEGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALFQAgACgCACIAEM4MIABBDEEEEPg6CxUAIAAoAgAiABDPDCAAQQxBBBD4OgsQACAAIAEgASACahC8JkEAC28BAn8gACgCAEEIaiECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBA3QhAQNAIAAgAjYCDCAAQQRqIABBDGpBkN6HARDJFCACQQhqIQIgAUEIayIBDQALCyAAQQRqEKksIABBEGokAAsVACAAKAIAIgAQ0gwgAEEMQQQQ+DoLEgAgAEEQQRQgACgCABtqKAIACxYAIAAoAgQgACAAKAIAQYCAgIB4RhsLFgAgACABKAIAIAIgASgCBCgCDBEBAAsoAQFvIAAoAgAlASABKAIAJQEgAigCACUBEEkhAxDfEiIAIAMmASAACxAAIAEEQCAAIAEgAhD4OgsLEwBB2O+KASAArUIghkIBhDcDAAsQACAAIAEgASACahC/JkEACxYAIAAoAgAgASACIAAoAgQoAgwRBgALGQAgASgCAEGgj4oBQQUgASgCBCgCDBEGAAsVAQFvIAAQCSEBEN8SIgAgASYBIAALnQECAX8BbyMAQcABayIDJAAgAyABNgK0ASADIAA2ArABIANBADoAuAEgAyACOQMAIwBB0AFrIgAkACAAQQhqIANBwAH8CgAAIABCATcDACAAIAA2AswBIABBzAFqQfjHwgAQkz0hAQJAIAApAwBQDQAgAC0AwAFBA0cNACAAQRBqEPUsCyAAQdABaiQAIANBwAFqJAAgASUBIAEQ8h8LFAAgABDfEiIAIAImASABIAAQli8LEwAgARDGISAAIAFBABCLHBCJGgsTACABEMYhIAAgAUEAEIscEIgaCxQAIAAoAgAgASAAKAIEKAIMEQIACxQAIAAoAgAgASAAKAIEKAIQEQIACxQAIAAoAgAgASAAKAIEKAIUEQAACxMAIABBACAAKAIAQYCAgIB4RxsLEwBC////v4APIAAxAACIp0EBcQsKACAAQQhqEN47CxEAIAAgASACIAMgBEEAEN41CxEAIAAgASACIAMgBEEAEN81CxEAIAAgASACIAMgBEECEN41CxEAIAAgASACIAMgBEECEN81CxEAIAAgASACIAMgBEEBEN41CxEAIAAgASACIAMgBEEBEN81CxIAIABFBEBBAA8LIAAoAqjVAQsRACAAIAEgAxC2LCACajYCAAvDNgIVfwN+IwBBEGsiFyQAIAQoAgghFSAEIAQoAgAiGBCOLSAVIAQoAggiCEsEQCAVIAhBpMH7ABCvOwALIAEpAwghHCAXQQRqIRYgBCgCBCAVaiEZIwBBMGsiEyQAIAEoAhAiB0EANgIYIAcgCCAVazYCECAHIBk2AgwgByADNgIEIAcgAiIDNgIAIAVB/wFxIQVBfiECAkAgB0UNACAHKAIgRQ0AIAcoAiRFDQAgBygCHEUgBUEFS3INACMAQdAAayIKJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBygCDEUNACAHKAIEBEAgBygCAEUNAQsgBygCHCECIAVB/wFxQQRHBEAgAi0AAEEDRg0BCyAHKAIQRQ0cIAIsAAEhCCACIAU6AAEgCkEwaiAHKAIcQdgAahDkJQJAAkACQCAKKAI0BEAgBxDiGCAHKAIQBEAgBygCBEEARyELDAILIAcoAhxB/wE6AAEMFgtBASELIAcoAgRFDQELIAtFIAcoAhwiBi0AACIJQQNHcg0BDB4LIAVB/wFxIgJBBEcEQCAFQQF0QXdBACACQQRLG2rAIAhBAXRBd0EAIAhBBEobasBMDR4LIAcoAhwiBi0AACEJCwJAAkACQCAJQf8BcUEBRw0AIAYtAAJFBEAgBkECOgAAIAcoAhwiBi0AACIJQQFHDQELIAYoAiAhCCAGKAIQIQICf0EAIAYtAANBAUsNABpBACAGLAAEIglBAkgNABpBwAAgCUEGSQ0AGkGAAUHAASAJQQZGGwsgCGhBDHRyIAJBAEdBBXRqIghBgPABa0H/8wNxQR9wIQIgBigCXCIJIAYoAmAgBigCZGoiEGtBAU0NBCAJIBBJDQUgBigCWCAQaiAIIAJrQeHvAWsiAkEIdCACQYD+A3FBCHZyOwAAIAYgBigCZEECajYCZCAHKAIcIgkoAhAEQCAJKAJcIgIgCSgCYCAJKAJkaiIIa0EDTQ0HIAIgCEkNCCAJKAJYIAhqIAcoAjAiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnI2AAAgCSAJKAJkQQRqNgJkIAcoAhwhCQsgB0EBNgIwIAlBAjoAACAHEOIYIApBKGogBygCHEHYAGoQ5CUgBygCHCEGIAooAiwNASAGLQAAIQkLIAlB/wFxQQRGDQEMEwsgBkH/AToAAQwTCyAGQQA2AqABIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBAk0NBSACIAhJDQYgCSgCWCAIaiICQdD6+wAvAAA7AABBAiELIAJBAmpB0vr7AC0AADoAACAJIAkoAmRBA2o2AmQgBygCHCIPLAAEIgJBCUcEQEEEIA8tAANBAUtBAnQgAkECSBshCwsgDygCiAEiAgRAIAIoAixBAEdBAXQgAigCAEEAR3IgAigCEEEAR0ECdHIgAigCHEEAR0EDdHIgAigCJEEAR0EEdHIhAiAPKAJcIgggDygCZCAPKAJgaiIJRg0IIAggCUkNCSAPKAJYIAlqIAI6AAAgDyAPKAJkQQFqNgJkIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBA00NCiACIAhJDQsgCSgCWCAIaiAPKAKIASgCBDYAACAJIAkoAmRBBGo2AmQgBygCHCIJKAJcIgIgCSgCYCAJKAJkaiIIa0EBTQ0MIAIgCEkNDSAJKAJYIAhqIA8oAogBKAIMQQh0IAtyOwAAIAkgCSgCZEECajYCZCAPKAKIASIIKAIQBH8gBygCHCIQKAJcIgIgECgCYCAQKAJkaiIJa0EBTQ0RIAIgCUkNEiAQKAJYIAlqIAgoAhQ7AAAgECAQKAJkQQJqNgJkIA8oAogBBSAICygCLARAIAcoAjAhAiAKQSBqIAcoAhxB2ABqEOQlIAcgAiAKKAIgIAooAiQQ3Qc2AjALIAcoAhxBADYCjAEgBygCHEEFOgAAIAcoAhwhBgwSCyAPKAJcIgIgDygCYCAPKAJkaiIIa0EGTQ0NIAIgCEkNDkEAIQkgDygCWCAIaiICQQA2AAAgAkEDOgAGIAIgCzoABSACQQRqQQA6AAAgDyAPKAJkQQdqNgJkIAcoAhxBAjoAACAHEOIYIApBGGogBygCHEHYAGoQ5CUgBygCHCEGIAooAhxFDREgBkH/AToAAQwdCyAHQeixwgA2AhhBfiEJDBwLIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQbD6+wAQ7ywACyAQIAlBsPr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQcD6+wAQ7ywACyAIIAJBwPr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQdT6+wAQ7ywACyAIIAJB1Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQfT6+wAQ7ywACyAJIAhB9Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQYT7+wAQ7ywACyAIIAJBhPv7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQZT7+wAQ7ywACyAIIAJBlPv7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQeT6+wAQ7ywACyAIIAJB5Pr7ABCvOwALIApBADYCSCAKQQE2AjwgCkGswvsANgI4IApCBDcCQCAKQThqQaT7+wAQ7ywACyAJIAJBpPv7ABCvOwALIAYtAAAiCUEFRgRAAkAgBigCiAEiCUUNACAJKAIQIghFDQAgByAIIAYoAowBIgJqIAkvARQgAmsQwwsiCUEDRw0NIAcoAhwhBgsgBkEGOgAAIAcoAhwiBi0AACEJCwJAAkACQAJAIAlB/wFxQQZGBEAgBigCiAEiAkUNASACKAIcIgIEfyAHIAIgAhC4KkEBahDDCyIJQQNHDREgBygCHAUgBgtBBzoAACAHKAIcIgYtAAAhCQsgCUH/AXFBB0YEfyAGKAKIASICRQ0BIAIoAiQiAgR/IAcgAiACELgqQQFqEMMLIglBA0cNESAHKAIcBSAGC0EIOgAAIAcoAhwiBi0AAAUgCQtB/wFxQQhHDQACQCAGKAKIASICRQ0AIAIoAixFDQAgCiAHKAIwOwE4IAcgCkE4akECEMMLIglBA0cNECAHKAIcIQYLIAZBAjoAACAHEOIYIApBEGogBygCHEHYAGoQ5CUgCigCFA0BCyAHKAIEDQEgBygCHCICKAIkDQEgBUH/AXFFDQMgAi0AAEEDRw0BDAILIAcoAhxB/wE6AAEMAgsCfyAHKAIcIgItAAQiCEUEQCAHIAUQ/QJB/wFxDAELAkACQAJAIAItAANBAmsOAgIBAAsgCMAhAiAIQQpPBEAgAkEKQciA/QAQwyEACyAHIAUgAkEMbEHYgP0AaigCABECAAwCC0EAIQsjAEEgayINJAAgBUH/AXEhDwJAAkACQANAAkACQAJAAkACQAJAAkAgBygCHCIGKAIkIgxBhgJPBEAgBigCECESDAELIAYoAiAiDkEBdCEUIA5BhgJrIRADQAJAIAYoAlAgDCAGKAIQIgJqayEMAkACQAJAAkACQAJAAkACQAJAIBAgBigCIGogAk0EQCAUIAYoAhgiAksNASAOQQBIDQIgDgRAIAYoAhQiAiACIA5qIA78CgAACyAGIAYvAQwiCSAOQf//A3EiCGsiAkEAIAIgCU0bOwEMIAggCU8EQCAGQQA7ATQLIAYgBigCECAOayIINgIQIAYgBigCPCAOazYCPCAGIAggBigCgAEiAiACIAhLGzYCgAEgBhCUFiAMIA5qIQwLIAcoAgRFBEAgBygCHCEGDAoLIAxBAU0NAiAHIAcoAhwiAigCJCACKAIQaiAMEMwTIQIgBygCHCIGIAIgBigCJGoiAjYCJCACIAYoAoABIghqQQNJDQggBigCECICIAhrIQwgBi8BNkGACE0EQCACIAhGDQggDEEBayERIAYtAAZBAUYEQCAGIBEQ2RkaDAkLIAYoAhgiAiARSQ0EIAIgEWsiAkEDTQ0FIAYoAhQgEWooAABBsfPd8XlsQRB2QQF0IgkgBigCMGovAQAiCCARQf//A3FGDQggBigCIEEBayARcSISIAYoAiwiAk8NBiAGKAIoIBJBAXRqIAg7AQAgBigCMCAJaiAROwEADAgLIAYoAhgiAiAMTQRAIAwgAkG07fwAEMMhAAsgDEEBaiIIIAJJDQYgCCACQcTt/AAQwyEACyAUIAJB9Oz8ABCwOwALIA1BADYCGCANQQE2AgwgDUH46PwANgIIIA1CBDcCECANQQhqQYTt/AAQ7ywACyANQQA2AhggDUEBNgIMIA1BnO38ADYCCCANQgQ3AhAgDUEIakGk7fwAEO8sAAsgESACQfTp/AAQrzsAC0EEIAJBhOr8ABCwOwALIBIgAkGU6vwAEMMhAAsgBiAGKAIUIgIgDGotAABBBXQgAiAIai0AACICcyACQbHz3fF5bEEQdiAGLQAGGzYChAELIAYoAoABIAYoAiRBAUZrIgJFDQACQCAGLQAGQQFGBEAgBiAMIAIQ4BMMAQsgBiAMIAIQ6xQLIAYgBigCgAEgAms2AoABCyAHKAIcIgYoAiQiDEGFAksNACAHKAIEDQELCyAGKAIQIhIgBigCUEGGAmtLBEAgDUEANgIYIA1BATYCDCANQfDt/AA2AgggDUIENwIQIA1BCGpB+O38ABDvLAALIAYoAiQiDEGGAk8NACAPRQRAQQAhBgwLCyAMRQRAIAZBADYCgAEgBUH/AXFBBEcEQCAHKAIcKAJIBEBBACEGIAdBABCSASAHKAIQRQ0NC0EBIQYMDAsgB0EBEJIBQQNBAiAHKAIQGyEGDAsLIAxBAk0NAQsgEkUEQEEAIRIMAQsCQAJAIAYoAhgiAiASQQFrIhBPBEAgAiAQayICQYICTQ0BIAYoAhQiAiAQaiIILQAAIgkgAiASaiICLQAARw0CIAkgCC0AAkcNAiAJrUKBgoSIkKDAgAF+IRtBAiELAkADQCACIAtqKQAAIh0gG1EEQEGCAiEIIAtBCGoiC0GCAkcNAQwCCwsgGyAdhXqnQQN2IAtqIQgLQYICIAwgCCAIIAxLGyICIAJBggJPGyELDAILIBAgAkGg6fwAEK87AAtBgwIgAkGw6fwAELA7AAsgCyAQaiAGKAJQQQFrSw0BCyALQQJLDQEgEiAGKAIYIgJJDQIgEiACQeTp/AAQwyEACyANQQA2AhggDUEBNgIMIA1BzOn8ADYCCCANQgQ3AhAgDUEIakHU6fwAEO8sAAsgBigCRCICIAYoAkgiCEkNAiACIAhrIgJBAk0NBCAGKAJAIAhqIgIgC0EDayIIOgACIAJBATsAACAGIAYoAkgiCUEDajYCSCAGQf8BIAYtADpBAWoiAiACQf8BTxs6ADogBigCIEGGAkYNBSAGIAYvAaQTQQFqOwGkEyAGIAhB9Or8AGotAABBAnRqQawJaiICIAIvAQBBAWo7AQAgBigCRCEIIAcoAhwiAiACKAIkIAtrNgIkIAcoAhwiAiACKAIQIAtqNgIQQQAhCyAJIAhBBmtHDQMMAQsgBkFAayAGQaQBaiAGKAIUIBJqLQAAEJYjIAcoAhwiAiACKAIkQQFrNgIkIAcoAhwiAiACKAIQQQFqNgIQRQ0CC0EAIQYgB0EAEJIBIAcoAhANAQwECwsgCCACQaTq/AAQrzsAC0EDIAJBtOr8ABCwOwALIA1BADYCGCANQQE2AgwgDUHc6vwANgIIIA1CBDcCECANQQhqQeTq/AAQ7ywACyANQSBqJAAgBkH/AXEMAQsCfyMAQSBrIg4kAAJAA0ACQAJAIAcoAhwiBigCJARAIAYoAhAhCwwBCyAGKAIgIhFBAXQhEiARQYYCayEQQQAhCwNAAkAgBigCUCALIAYoAhAiAmprIQsCQAJAAkACQAJAAkACQAJAAkAgECAGKAIgaiACTQRAIBIgBigCGCICSw0BIBFBAEgNAiARBEAgBigCFCICIAIgEWogEfwKAAALIAYgBi8BDCIJIBFB//8DcSIIayICQQAgAiAJTRs7AQwgCCAJTwRAIAZBADsBNAsgBiAGKAIQIBFrIgg2AhAgBiAGKAI8IBFrNgI8IAYgCCAGKAKAASICIAIgCEsbNgKAASAGEJQWIAsgEWohCwsgBygCBEUEQCAHKAIcIQYMCgsgC0EBTQ0CIAcgBygCHCICKAIkIAIoAhBqIAsQzBMhAiAHKAIcIgYgAiAGKAIkaiICNgIkIAIgBigCgAEiCGpBA0kNCCAGKAIQIgIgCGshFCAGLwE2QYAITQRAIAIgCEYNCCAUQQFrIQwgBi0ABkEBRgRAIAYgDBDZGRoMCQsgBigCGCICIAxJDQQgAiAMayICQQNNDQUgBigCFCAMaigAAEGx893xeWxBEHZBAXQiCSAGKAIwai8BACIIIAxB//8DcUYNCCAGKAIgQQFrIAxxIg8gBigCLCICTw0GIAYoAiggD0EBdGogCDsBACAGKAIwIAlqIAw7AQAMCAsgBigCGCICIBRNBEAgFCACQdTg/AAQwyEACyAUQQFqIgggAkkNBiAIIAJB5OD8ABDDIQALIBIgAkGU4PwAELA7AAsgDkEANgIYIA5BATYCDCAOQdze/AA2AgggDkIENwIQIA5BCGpBpOD8ABDvLAALIA5BADYCGCAOQQE2AgwgDkG84PwANgIIIA5CBDcCECAOQQhqQcTg/AAQ7ywACyAMIAJB9N78ABCvOwALQQQgAkGE3/wAELA7AAsgDyACQZTf/AAQwyEACyAGIAYoAhQiAiAUai0AAEEFdCACIAhqLQAAIgJzIAJBsfPd8XlsQRB2IAYtAAYbNgKEAQsgBigCgAEgBigCJEEBRmsiAkUNAAJAIAYtAAZBAUYEQCAGIBQgAhDgEwwBCyAGIBQgAhDrFAsgBiAGKAKAASACazYCgAELIAcoAhwiBigCJCILQYUCSw0AIAcoAgQNAQsLIAYoAhAiCyAGKAJQQYYCa0sEQCAOQQA2AhggDkEBNgIMIA5BkOH8ADYCCCAOQgQ3AhAgDkEIakGY4fwAEO8sAAsgBigCJA0AIAVB/wFxIgJFBEBBACEGDAILIAZBADYCgAEgAkEERwRAIAcoAhwoAkgEQEEAIQYgB0EAEJIBIAcoAhBFDQMLQQEhBgwCCyAHQQEQkgFBA0ECIAcoAhAbIQYMAQsgCyAGKAIYIgJPDQIgBkFAayAGQaQBaiAGKAIUIAtqLQAAEJYjIAcoAhwiAiACKAIkQQFrNgIkIAcoAhwiAiACKAIQQQFqNgIQRQ0BQQAhBiAHQQAQkgEgBygCEA0BCwsgDkEgaiQAIAYMAQsgCyACQeTe/AAQwyEAC0H/AXELQf8BcSICQQFLBEAgBygCHEEDOgAACwJAAkAgAkEBaw4DAQACAAtBACEJIAcoAhANDSAHKAIcQf8BOgABDA0LAkACQAJAAkACQAJAIAVB/wFxQQFrDgUEAQIDBQALIApBADYCSCAKQQE2AjwgCkGA/PsANgI4IApCBDcCQCAKQThqQYj8+wAQ7ywACyAHKAIcQQBBAEEAEPgMDAMLIAcoAhxBAEEAQQAQ+AwgBygCHCgCMEEAQYCACPwLACAHKAIcIgIoAiQNAiACQQA2AhAgBygCHEEANgI8IAcoAhxBADYCgAEMAgsgCkEANgJIIApBATYCPCAKQeT8+wA2AjggCkIENwJAIApBOGpB7Pz7ABDvLAALIAcoAhxB2ABqIgJBAUEAEIwmIAJBgAJB/Nz7AEGgAhCrISACEJAVCyAHEOIYIAcoAhANACAHKAIcQf8BOgABDAELIAVB/wFxQQRHDQAgBygCHCIILQACQQFrDgICAQkLQQAhCQwKCyAIKAKgASEFIAhBADYCoAEgByAFNgIwIAcoAhwiCSgCXCICIAkoAmAgCSgCZGoiCGtBA00NASACIAhJDQIgCSgCWCAIaiAFNgAAIAkgCSgCZEEEajYCZCAHKAIcIggoAlwiAiAIKAJgIAgoAmRqIgVrQQNNDQMgAiAFSQ0EIAgoAlggBWogBygCCDYAACAIIAgoAmRBBGo2AmQMBwsgCCgCXCICIAgoAmAgCCgCZGoiBWtBA00NBCACIAVJDQUgCCgCWCAFaiAHKAIwIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyNgAAIAggCCgCZEEEajYCZAwGCyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akH8/PsAEO8sAAsgCCACQfz8+wAQrzsACyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akGM/fsAEO8sAAsgBSACQYz9+wAQrzsACyAKQQA2AkggCkEBNgI8IApBrML7ADYCOCAKQgQ3AkAgCkE4akGc/fsAEO8sAAsgBSACQZz9+wAQrzsACyAHEOIYQQAhCSAKQQhqIAcoAhwiBSwAAiICQQBKBH8gBUEAIAJrOgACIAcoAhwFIAULQdgAahDkJSAKKAIMDQEgBygCHCICLQBwRQRAQQEhCQwCCyAKQgA3AkQgCkKBgICAwAA3AjwgCkHA/fsANgI4IwBBEGsiACQAIABBzLTCADYCDCAAIAJB8ABqNgIIQQAgAEEIakG4gP0AIABBDGpBuID9ACAKQThqQcj9+wAQ5g8ACyAHQduxwgA2AhhBeyEJCyAKQdAAaiQAIAkhAgsgBygCDCEIIAdCADcCDCAHKAIAIQUgB0IANwIAIAEgASkDACAFIANrrXw3AwAgASABKQMIIAggGWutfDcDCAJAAkACQAJAAkACQCACQQVqDgcCAAAEAAEDAAsgEyACNgIMIBNBATYCFCATQei9+wA2AhAgE0IBNwIcIBNBnAM2AiwgEyATQShqNgIYIBMgE0EMajYCKCATQRBqQZC++wAQ7ywACyAWQQA6AAEMAwsgFkEBOgABDAILIBZBAjoAAQwBCyATIAEQpyQgFiATKQMANwIEQQEhGgsgFiAaOgAAIBNBMGokACAAIBcpAgQ3AgAgAEEIaiAXQQxqKAIANgIAIAQgGCAVIAEpAwggHH2naiIAIAAgGEsbEI4tIBdBEGokAAsTAEL8v4CAgA8gADEAAIinQQFxCw8AIABBGGpBACAAKAIYGwsPACAAQSRqQQAgACgCJBsLEgAgACgCBCAAKAIIEMQIQQFzCxIAIAAoAgQgACgCCBC/CUEBcwsTACAAQQA2AgAgACABKAIANgIECw8AIAAoAgwEQCAAEIkgCwsQACAAKAIEIAAoAgBrQQN2Cw8AIABBIGpBACAAKAIgGwsQACAAQcwAakEAIAAoAkwbCw8AIABBFGpBACAAKAIUGwsPACAAQRxqQQAgACgCHBsLDwAgAEEsakEAIAAoAiwbCxAAIAAoAgQgACgCAGtBAnYLEwAgACABIAIoAgQgAigCCBDBLgsTACAAIAEgASgCDCABKAIQELUqCw4AIAAgASABIAJqEL0mCxUAIAAoAgAlASABKAIAJQEQd0EARwuoBwEDfyMAQfAAayIFJAAgBSADNgIMIAUgAjYCCAJ/AkACQAJAAkAgAUGBAk8EQEH9ASEGA0AgACAGaiIHQQNqLAAAQb9/Sg0DIAdBAmosAABBv39KDQIgB0EBaiwAAEG/f0oNBCAHLAAAQb9/Sg0FIAZBBGsiBkF9Rw0AC0EAIQYMBAsgBSABNgIUIAUgADYCEEEBDAQLIAZBAmohBgwCCyAGQQNqIQYMAQsgBkEBaiEGCyAFIAA2AhAgBSAGNgIUQQVBACABIAZLIgYbIQdB5PyJAUEBIAYbCyEGIAUgBzYCHCAFIAY2AhgCQAJAIAUgASACTwR/IAEgA08NASADBSACCzYCKCAFQQM2AjQgBUGs/okBNgIwIAVCAzcCPCAFIAVBGGqtQoCAgIDg4wOENwNYIAUgBUEQaq1CgICAgODjA4Q3A1AgBSAFQShqrUKAgICAsAeENwNIDAELIAIgA00EQCACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCIAJ/AkACQCABIANNDQBBACEHAkAgA0UNAANAIAAgA2osAABBv39KBEAgAyEHDAILIANBAWsiAw0ACwsgASAHRg0AAkACQCAAIAdqIgIsAAAiA0EASARAIAItAAFBP3EhACADQR9xIQEgA0FfSw0BIAFBBnQgAHIhBgwCCyAFIANB/wFxNgIkQQEMBAsgAi0AAkE/cSAAQQZ0ciEAIANBcEkEQCAAIAFBDHRyIQYMAQsgAUESdEGAgPAAcSACLQADQT9xIABBBnRyciIGQYCAxABGDQELIAUgBjYCJCAGQYABTw0BQQEMAgsgBBCyOwALQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIQAgBSAHNgIoIAUgACAHajYCLCAFQQU2AjQgBUHs/YkBNgIwIAVCBTcCPCAFIAVBGGqtQoCAgIDg4wOENwNoIAUgBUEQaq1CgICAgODjA4Q3A2AgBSAFQShqrUKAgICAgOQDhDcDWCAFIAVBJGqtQoCAgICQ5AOENwNQIAUgBUEgaq1CgICAgLAHhDcDSAwBCyAFQQQ2AjQgBUGM/YkBNgIwIAVCBDcCPCAFIAVBGGqtQoCAgIDg4wOENwNgIAUgBUEQaq1CgICAgODjA4Q3A1ggBSAFQQxqrUKAgICAsAeENwNQIAUgBUEIaq1CgICAgLAHhDcDSAsgBSAFQcgAajYCOCAFQTBqIAQQ7ywACxUCAW8BfxA+IQAQ3xIiASAAJgEgAQuWAQICfwFvIwBB4ABrIgIkACACQQA6AFggAiABNgJUIAIgADYCUCMAQfAAayIAJAAgAEEQaiIDIAJBCGpB2AD8CgAAIABCATcDCCAAIABBCGo2AmwgAEHsAGpByMjCABCTPSEBAkAgACkDCFANACAALQBgQQNHDQAgAxCrLAsgAEHwAGokACACQeAAaiQAIAElASABEPIfC48BAgJ/AW8jAEGgA2siAiQAIAJBADoAnAMgAiABNgKMAyACIAA2AogDIwBBsANrIgAkACAAQRBqIgMgAkEIakGYA/wKAAAgAEIBNwMIIAAgAEEIajYCrAMgAEGsA2pBjMjCABCTPSEBIAApAwhQRQRAIAMQnC8LIABBsANqJAAgAkGgA2okACABJQEgARDyHwuAAQICfwFvIwBBMGsiAiQAIAJBADoALCACIAE2AgwgAiAANgIIIwBBMGsiACQAIABBBGoiAyACQQhqQSj8CgAAIABBATYCACAAIAA2AiwgAEEsakGgyMIAEJM9IQEgACgCAARAIAMQ/ykLIABBMGokACACQTBqJAAgASUBIAEQ8h8LgwEBA38Q3xIiAyABJgEjAEEQayICJAAgAkEEaiAAENEkAkAgAigCBCIAKAIARQ0AIAAoAgQiBEGEAUkNACAEEPIfCyAAIAM2AgQgAEEBNgIAIAIoAghBADYCACACKAIMIgAgACgCAEEBayIANgIAIABFBEAgAkEMahDqGQsgAkEQaiQACxMAIABBKDYCBCAAQezJwgA2AgALEAAgABD3JSAAQQRBBBDgHgsTACAAQSg2AgQgAEHopcMANgIACxEAIAAoAgQgACgCCCABENwHCxsAAn8gAUEJTwRAIAEgABCbEgwBCyAAEKwBCwtAAAJAAn8gAUEJTwRAIAEgABCbEgwBCyAAEKwBCyIBRQ0AIAEQmj4tAARBA3FFIABFcg0AIAFBACAA/AsACyABCxMAIABBKDYCBCAAQYrjwwA2AgALEwAgAEEoNgIEIABB/PbDADYCAAuaAgEFfyMAQSBrIgMkACADQRRqIAFBAEECQQQQoBggAygCGCEEIAMoAhRBAUYEQCAEIAMoAhwgAhD9LwALIANBEGoiB0EANgIAIAMgAygCHDYCDCADIAQ2AgggA0EIaiIFKAIAIAUoAggiAmsgAUkEQCAFIAIgAUECQQQQ3iggBSgCCCECCyAFKAIEIAJBAnRqIQQCQAJAIAFBAk8EQCABQQFrIQYDQCAEQf//AzsBACAEQQJqQQA7AQAgBEEEaiEEIAZBAWsiBg0ACyABIAJqQQFrIQIMAQsgAUUNAQsgBEEAOwECIARB//8DOwEAIAJBAWohAgsgBSACNgIIIABBCGogBygCADYCACAAIAMpAgg3AgAgA0EgaiQACxEAIAAoAgAgACgCBCABENwHCxEAIAAoAgAgACgCBCABEKk9CxMAIABB5MfMADYCBCAAIAE2AgALEAAgACACNgIEIAAgATYCAAsTACAAQYD7zAA2AgQgACABNgIACxMAIABBkPvMADYCBCAAIAE2AgALEwAgAEGg+8wANgIEIAAgATYCAAsTACAAQbD7zAA2AgQgACABNgIACxMAIABBwPvMADYCBCAAIAE2AgALEwAgAEHQ+8wANgIEIAAgATYCAAsTACAAQeD7zAA2AgQgACABNgIACxMAIABB8PvMADYCBCAAIAE2AgALEwAgAEH8ic0ANgIEIAAgATYCAAsTACAAQYyKzQA2AgQgACABNgIACxMAIABBmJDNADYCBCAAIAE2AgALEwAgAEHgls0ANgIEIAAgATYCAAsTACAAQeSpzQA2AgQgACABNgIACxMAIABB9KnNADYCBCAAIAE2AgALEwAgAEGEqs0ANgIEIAAgATYCAAsTACAAQZSqzQA2AgQgACABNgIACxMAIABBpKrNADYCBCAAIAE2AgALEwAgAEG0qs0ANgIEIAAgATYCAAsTACAAQcSqzQA2AgQgACABNgIACxMAIABB1KrNADYCBCAAIAE2AgALEwAgAEHkqs0ANgIEIAAgATYCAAsTACAAQfSqzQA2AgQgACABNgIACxMAIABBhKvNADYCBCAAIAE2AgALEwAgAEGUq80ANgIEIAAgATYCAAsTACAAQaSrzQA2AgQgACABNgIACxMAIABBtKvNADYCBCAAIAE2AgALEwAgAEHEq80ANgIEIAAgATYCAAsTACAAQdSrzQA2AgQgACABNgIACxMAIABB5KvNADYCBCAAIAE2AgALEwAgAEH0q80ANgIEIAAgATYCAAsRACAAIAEoAgAgASgCBBDTIwsTACAAQSg2AgQgAEGgss0ANgIACxMAIABBjLzNADYCBCAAIAE2AgALEwAgAEGovM0ANgIEIAAgATYCAAsTACAAQbi8zQA2AgQgACABNgIACxMAIABB5NHNADYCBCAAIAE2AgALEwAgAEH00c0ANgIEIAAgATYCAAsTACAAQYTSzQA2AgQgACABNgIACxMAIABBlNLNADYCBCAAIAE2AgALEwAgAEGk0s0ANgIEIAAgATYCAAsTACAAQbTSzQA2AgQgACABNgIACxMAIABBxNLNADYCBCAAIAE2AgALEwAgAEHU0s0ANgIEIAAgATYCAAsTACAAQeTSzQA2AgQgACABNgIACxMAIABB9NLNADYCBCAAIAE2AgALEwAgAEGE080ANgIEIAAgATYCAAsTACAAQZTTzQA2AgQgACABNgIACxMAIABBpNPNADYCBCAAIAE2AgALEwAgAEG0080ANgIEIAAgATYCAAsTACAAQcTTzQA2AgQgACABNgIACxMAIABB1NPNADYCBCAAIAE2AgALEgAgACgCICAAKAIkKAIQEQQACxMAIABB4NfNADYCBCAAIAE2AgALEwAgAEEoNgIEIABBgPHNADYCAAtsAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQJ0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQcSChAEQyRQgAkEEaiECIAFBBGsiAQ0ACwsgAEEEahCpLCAAQRBqJAALEwAgAEHAm88ANgIEIAAgATYCAAsPACAAQQxqELwqIAAQnQwLEQAgACgCBCAAKAIIIAEQqT0LEwAgAEHUo88ANgIEIAAgATYCAAsTACAAQczJzwA2AgQgACABNgIACxMAIABB3MnPADYCBCAAIAE2AgALEwAgAEGgzc8ANgIEIAAgATYCAAsTACAAQbDNzwA2AgQgACABNgIACxMAIABBsM/PADYCBCAAIAE2AgALEwAgAEGo0M8ANgIEIAAgATYCAAsTACAAQbjQzwA2AgQgACABNgIACxMAIABByNDPADYCBCAAIAE2AgALEwAgAEHY0M8ANgIEIAAgATYCAAsTACAAQejQzwA2AgQgACABNgIACxMAIABB+NDPADYCBCAAIAE2AgALEwAgAEGI0c8ANgIEIAAgATYCAAsTACAAQZjRzwA2AgQgACABNgIACxMAIABB1J7QADYCBCAAIAE2AgALEwAgAEHkntAANgIEIAAgATYCAAsTACAAQSg2AgQgAEGMotAANgIACxMAIABBhMnQADYCBCAAIAE2AgALDwAgACABIAIgAyAEEP0HCxMAIABBKDYCBCAAQbDH0QA2AgALEAAgAEEAOgABIAAgAToAAAsTACAAQSg2AgQgAEHEu/sANgIAC2wBAn8gACgCACECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAXQhAQNAIAAgAjYCDCAAQQRqIABBDGpB+MH7ABDJFCACQQJqIQIgAUECayIBDQALCyAAQQRqEKksIABBEGokAAsQACAAQQA2AgggAEIANwMACxEAIAAoAgQgACgCCCABEMUjCxEAIAAoAgAgACgCBCABEMUjCxMAIABBrNX+ADYCBCAAIAE2AgALEwAgAEG81f4ANgIEIAAgATYCAAsQACAAQQA2AgQgACABNgIACw8AIAAgACgCACABajYCAAsTACAAQbiZ/wA2AgQgACABNgIACxMAIABByJn/ADYCBCAAIAE2AgALEwAgAEHYmf8ANgIEIAAgATYCAAsTACAAQeiZ/wA2AgQgACABNgIACxMAIABB+Jn/ADYCBCAAIAE2AgALEwAgAEGImv8ANgIEIAAgATYCAAsTACAAQZia/wA2AgQgACABNgIACxMAIABBqJr/ADYCBCAAIAE2AgALEwAgAEG4mv8ANgIEIAAgATYCAAsTACAAQcia/wA2AgQgACABNgIACxMAIABB2Jr/ADYCBCAAIAE2AgALEwAgAEHomv8ANgIEIAAgATYCAAsTACAAQfia/wA2AgQgACABNgIACxMAIABBiJv/ADYCBCAAIAE2AgALEwAgAEGYm/8ANgIEIAAgATYCAAsTACAAQaib/wA2AgQgACABNgIACxMAIABBuJv/ADYCBCAAIAE2AgALEwAgAEHIm/8ANgIEIAAgATYCAAsTACAAQdib/wA2AgQgACABNgIACxMAIABB6Jv/ADYCBCAAIAE2AgALEwAgAEH4m/8ANgIEIAAgATYCAAsTACAAQYic/wA2AgQgACABNgIACxMAIABBnLb/ADYCBCAAIAE2AgALEwAgAEGstv8ANgIEIAAgATYCAAsTACAAQby2/wA2AgQgACABNgIACxMAIABBzLb/ADYCBCAAIAE2AgALEwAgAEHctv8ANgIEIAAgATYCAAsTACAAQey2/wA2AgQgACABNgIACxMAIABB/Lb/ADYCBCAAIAE2AgALEwAgAEGMt/8ANgIEIAAgATYCAAsTACAAQZy3/wA2AgQgACABNgIACxMAIABBrLf/ADYCBCAAIAE2AgALEwAgAEG8t/8ANgIEIAAgATYCAAsTACAAQcy3/wA2AgQgACABNgIACxMAIABB3Lf/ADYCBCAAIAE2AgALEwAgAEHst/8ANgIEIAAgATYCAAsTACAAQfy3/wA2AgQgACABNgIACxMAIABBjLj/ADYCBCAAIAE2AgALEwAgAEGcuP8ANgIEIAAgATYCAAsTACAAQay4/wA2AgQgACABNgIACxMAIABBvLj/ADYCBCAAIAE2AgALEwAgAEHMuP8ANgIEIAAgATYCAAsTACAAQdy4/wA2AgQgACABNgIACxMAIABB7Lj/ADYCBCAAIAE2AgALEwAgAEH8uP8ANgIEIAAgATYCAAsTACAAQYy5/wA2AgQgACABNgIACxMAIABBnLn/ADYCBCAAIAE2AgALEwAgAEGsuf8ANgIEIAAgATYCAAsTACAAQby5/wA2AgQgACABNgIACxMAIABBzLn/ADYCBCAAIAE2AgALEwAgAEHcuf8ANgIEIAAgATYCAAsTACAAQey5/wA2AgQgACABNgIACxMAIABB/Ln/ADYCBCAAIAE2AgALEwAgAEGMuv8ANgIEIAAgATYCAAsTACAAQZy6/wA2AgQgACABNgIACxMAIABBrLr/ADYCBCAAIAE2AgALEwAgAEG8uv8ANgIEIAAgATYCAAsTACAAQcy6/wA2AgQgACABNgIACxMAIABB3Lr/ADYCBCAAIAE2AgALEwAgAEHsuv8ANgIEIAAgATYCAAsTACAAQfy6/wA2AgQgACABNgIACxMAIABBnMn/ADYCBCAAIAE2AgALEwAgAEGsyf8ANgIEIAAgATYCAAsTACAAQcDu/wA2AgQgACABNgIACxMAIABB0O7/ADYCBCAAIAE2AgALEwAgAEHg7v8ANgIEIAAgATYCAAsTACAAQfDu/wA2AgQgACABNgIACxMAIABBgO//ADYCBCAAIAE2AgALEwAgAEGQ7/8ANgIEIAAgATYCAAsTACAAQaDv/wA2AgQgACABNgIACxMAIABBsO//ADYCBCAAIAE2AgALEwAgAEHA7/8ANgIEIAAgATYCAAsTACAAQdDv/wA2AgQgACABNgIACxMAIABB4O//ADYCBCAAIAE2AgALEwAgAEHw7/8ANgIEIAAgATYCAAsTACAAQYDw/wA2AgQgACABNgIACxMAIABBkPD/ADYCBCAAIAE2AgALEwAgAEGg8P8ANgIEIAAgATYCAAsTACAAQbDw/wA2AgQgACABNgIACxMAIABBwPD/ADYCBCAAIAE2AgALEwAgAEHQ8P8ANgIEIAAgATYCAAsTACAAQeDw/wA2AgQgACABNgIACxMAIABB8PD/ADYCBCAAIAE2AgALEwAgAEGA8f8ANgIEIAAgATYCAAsTACAAQZDx/wA2AgQgACABNgIACxMAIABBoPH/ADYCBCAAIAE2AgALEwAgAEGw8f8ANgIEIAAgATYCAAsTACAAQcDx/wA2AgQgACABNgIACxMAIABB0PH/ADYCBCAAIAE2AgALEwAgAEG0+/8ANgIEIAAgATYCAAsTACAAQbCPgAE2AgQgACABNgIACxMAIABBwI+AATYCBCAAIAE2AgALEwAgAEHQj4ABNgIEIAAgATYCAAsTACAAQeCPgAE2AgQgACABNgIACxMAIABB8I+AATYCBCAAIAE2AgALEwAgAEGAkIABNgIEIAAgATYCAAsTACAAQZCQgAE2AgQgACABNgIACxMAIABBoJCAATYCBCAAIAE2AgALEwAgAEGwkIABNgIEIAAgATYCAAsTACAAQcCQgAE2AgQgACABNgIACxMAIABB0JCAATYCBCAAIAE2AgALEwAgAEHgkIABNgIEIAAgATYCAAsTACAAQfCQgAE2AgQgACABNgIACxMAIABBgJGAATYCBCAAIAE2AgALDQAgACABIAIQoTZBAAsTACAAQbDhgAE2AgQgACABNgIACxMAIABBwOGAATYCBCAAIAE2AgALEwAgAEHQ4YABNgIEIAAgATYCAAsQACAAQQA6AAQgACABNgIACw8AIAAQvCogAEEIahC8Kgs+AQJ/IAAoAggiAgRAIAAoAgQhAQNAIAEoAgAEQCABEM4qCyABQRBqIQEgAkEBayICDQALCyAAQQRBEBDgHgsTACAAQaiHgQE2AgQgACABNgIACxMAIABBoOqBATYCBCAAIAE2AgALEwAgAEGw6oEBNgIEIAAgATYCAAsTACAAQcDqgQE2AgQgACABNgIACxMAIABB0OqBATYCBCAAIAE2AgALEwAgAEHg6oEBNgIEIAAgATYCAAsTACAAQfDqgQE2AgQgACABNgIACxMAIABBgOuBATYCBCAAIAE2AgALEwAgAEGQ64EBNgIEIAAgATYCAAsTACAAQaDrgQE2AgQgACABNgIACxMAIABBsOuBATYCBCAAIAE2AgALEwAgAEHA64EBNgIEIAAgATYCAAsTACAAQdDrgQE2AgQgACABNgIACxMAIABB4OuBATYCBCAAIAE2AgALEwAgAEHw64EBNgIEIAAgATYCAAsTACAAQYDsgQE2AgQgACABNgIACxMAIABBkOyBATYCBCAAIAE2AgALEwAgAEGg7IEBNgIEIAAgATYCAAsTACAAQbDsgQE2AgQgACABNgIACxMAIABBwOyBATYCBCAAIAE2AgALEwAgAEHQ7IEBNgIEIAAgATYCAAsTACAAQeDsgQE2AgQgACABNgIACxMAIABB8OyBATYCBCAAIAE2AgALEwAgAEGA7YEBNgIEIAAgATYCAAsTACAAQZDtgQE2AgQgACABNgIACxMAIABBoO2BATYCBCAAIAE2AgALEwAgAEGw7YEBNgIEIAAgATYCAAsTACAAQcDtgQE2AgQgACABNgIACxMAIABB0O2BATYCBCAAIAE2AgALEwAgAEHg7YEBNgIEIAAgATYCAAsTACAAQfDtgQE2AgQgACABNgIACxMAIABBgO6BATYCBCAAIAE2AgALEwAgAEGQ7oEBNgIEIAAgATYCAAsTACAAQaDugQE2AgQgACABNgIACxMAIABBsO6BATYCBCAAIAE2AgALEwAgAEHA7oEBNgIEIAAgATYCAAsTACAAQdDugQE2AgQgACABNgIACxMAIABB4O6BATYCBCAAIAE2AgALEwAgAEHw7oEBNgIEIAAgATYCAAsTACAAQYDvgQE2AgQgACABNgIACxMAIABBkO+BATYCBCAAIAE2AgALEwAgAEGg74EBNgIEIAAgATYCAAsTACAAQbDvgQE2AgQgACABNgIACxMAIABBwO+BATYCBCAAIAE2AgALEwAgAEHQ74EBNgIEIAAgATYCAAsTACAAQeDvgQE2AgQgACABNgIACxMAIABB8O+BATYCBCAAIAE2AgALEwAgAEGA8IEBNgIEIAAgATYCAAsTACAAQZDwgQE2AgQgACABNgIACxMAIABBoPCBATYCBCAAIAE2AgALEwAgAEGw8IEBNgIEIAAgATYCAAsTACAAQfj8gQE2AgQgACABNgIACxMAIABBqP2BATYCBCAAIAE2AgALEwAgAEG4/YEBNgIEIAAgATYCAAsTACAAQcj9gQE2AgQgACABNgIACxMAIABB5P2BATYCBCAAIAE2AgALEwAgAEH0/YEBNgIEIAAgATYCAAsTACAAQYT+gQE2AgQgACABNgIACxMAIABB0LCCATYCBCAAIAE2AgALEwAgAEHwuIIBNgIEIAAgATYCAAsTACAAQYC5ggE2AgQgACABNgIACxMAIABBkLmCATYCBCAAIAE2AgALEwAgAEGguYIBNgIEIAAgATYCAAsTACAAQbC5ggE2AgQgACABNgIACxMAIABBwLmCATYCBCAAIAE2AgALEwAgAEHQuYIBNgIEIAAgATYCAAsTACAAQeC5ggE2AgQgACABNgIACxMAIABB8LmCATYCBCAAIAE2AgALEwAgAEGAuoIBNgIEIAAgATYCAAsTACAAQZC6ggE2AgQgACABNgIACxMAIABBoLqCATYCBCAAIAE2AgALEwAgAEGwuoIBNgIEIAAgATYCAAsTACAAQcC6ggE2AgQgACABNgIACxMAIABB0LqCATYCBCAAIAE2AgALEwAgAEHguoIBNgIEIAAgATYCAAsTACAAQfC6ggE2AgQgACABNgIACxMAIABBgLuCATYCBCAAIAE2AgALEwAgAEGQu4IBNgIEIAAgATYCAAsTACAAQaC7ggE2AgQgACABNgIACxMAIABBsLuCATYCBCAAIAE2AgALEwAgAEHAu4IBNgIEIAAgATYCAAsTACAAQdC7ggE2AgQgACABNgIACxMAIABB4LuCATYCBCAAIAE2AgALEwAgAEHwu4IBNgIEIAAgATYCAAsTACAAQYC8ggE2AgQgACABNgIACxMAIABBkLyCATYCBCAAIAE2AgALEwAgAEGgvIIBNgIEIAAgATYCAAsTACAAQbC8ggE2AgQgACABNgIACxMAIABBwLyCATYCBCAAIAE2AgALEwAgAEHQvIIBNgIEIAAgATYCAAsTACAAQeC8ggE2AgQgACABNgIACxMAIABB8LyCATYCBCAAIAE2AgALEwAgAEGAvYIBNgIEIAAgATYCAAsTACAAQZC9ggE2AgQgACABNgIACxMAIABBoL2CATYCBCAAIAE2AgALEwAgAEGwvYIBNgIEIAAgATYCAAsTACAAQcC9ggE2AgQgACABNgIACxMAIABB0L2CATYCBCAAIAE2AgALEwAgAEHgvYIBNgIEIAAgATYCAAsTACAAQfC9ggE2AgQgACABNgIACxMAIABBgL6CATYCBCAAIAE2AgALEwAgAEGQvoIBNgIEIAAgATYCAAsTACAAQaC+ggE2AgQgACABNgIACxMAIABBsL6CATYCBCAAIAE2AgALEwAgAEHAvoIBNgIEIAAgATYCAAsTACAAQdC+ggE2AgQgACABNgIACxMAIABB4L6CATYCBCAAIAE2AgALEwAgAEG0yYIBNgIEIAAgATYCAAsTACAAQcTJggE2AgQgACABNgIACxMAIABB4MmCATYCBCAAIAE2AgALEwAgAEHwyYIBNgIEIAAgATYCAAsTACAAQYDKggE2AgQgACABNgIACxMAIABBhPSCATYCBCAAIAE2AgALEwAgAEGU9IIBNgIEIAAgATYCAAsTACAAQaT0ggE2AgQgACABNgIACxMAIABBtPSCATYCBCAAIAE2AgALEwAgAEHE9IIBNgIEIAAgATYCAAsTACAAQdT0ggE2AgQgACABNgIACxMAIABB5PSCATYCBCAAIAE2AgALEwAgAEH09IIBNgIEIAAgATYCAAsTACAAQYT1ggE2AgQgACABNgIACxMAIABBlPWCATYCBCAAIAE2AgALEwAgAEGk9YIBNgIEIAAgATYCAAsTACAAQbT1ggE2AgQgACABNgIACxMAIABBxPWCATYCBCAAIAE2AgALEwAgAEHU9YIBNgIEIAAgATYCAAsTACAAQeT1ggE2AgQgACABNgIACxMAIABB9PWCATYCBCAAIAE2AgALEwAgAEGE9oIBNgIEIAAgATYCAAsTACAAQZT2ggE2AgQgACABNgIACxMAIABBpPaCATYCBCAAIAE2AgALEwAgAEG09oIBNgIEIAAgATYCAAsTACAAQcT2ggE2AgQgACABNgIACxMAIABB1PaCATYCBCAAIAE2AgALEwAgAEHk9oIBNgIEIAAgATYCAAsTACAAQfT2ggE2AgQgACABNgIACxMAIABBhPeCATYCBCAAIAE2AgALEwAgAEGU94IBNgIEIAAgATYCAAsTACAAQaT3ggE2AgQgACABNgIACxMAIABBtPeCATYCBCAAIAE2AgALEwAgAEHE94IBNgIEIAAgATYCAAsTACAAQdT3ggE2AgQgACABNgIACxMAIABB5PeCATYCBCAAIAE2AgALEwAgAEH094IBNgIEIAAgATYCAAsTACAAQYT4ggE2AgQgACABNgIACxMAIABBlPiCATYCBCAAIAE2AgALEwAgAEGk+IIBNgIEIAAgATYCAAsTACAAQbT4ggE2AgQgACABNgIACxMAIABBxPiCATYCBCAAIAE2AgALEwAgAEHU+IIBNgIEIAAgATYCAAsTACAAQeT4ggE2AgQgACABNgIACxMAIABB9PiCATYCBCAAIAE2AgALEwAgAEGE+YIBNgIEIAAgATYCAAsTACAAQZT5ggE2AgQgACABNgIACxMAIABBpPmCATYCBCAAIAE2AgALEwAgAEG0+YIBNgIEIAAgATYCAAsTACAAQcT5ggE2AgQgACABNgIACxMAIABB1PmCATYCBCAAIAE2AgALEwAgAEHk+YIBNgIEIAAgATYCAAsTACAAQdyCgwE2AgQgACABNgIACxMAIABB7IKDATYCBCAAIAE2AgALEwAgAEH8goMBNgIEIAAgATYCAAsTACAAQZiDgwE2AgQgACABNgIACxMAIABBqIODATYCBCAAIAE2AgALEwAgAEG4g4MBNgIEIAAgATYCAAsTACAAQci/gwE2AgQgACABNgIACxMAIABB2L+DATYCBCAAIAE2AgALEwAgAEHov4MBNgIEIAAgATYCAAsTACAAQfi/gwE2AgQgACABNgIACxMAIABBiMCDATYCBCAAIAE2AgALEwAgAEGYwIMBNgIEIAAgATYCAAsTACAAQajAgwE2AgQgACABNgIACxMAIABBuMCDATYCBCAAIAE2AgALEwAgAEHIwIMBNgIEIAAgATYCAAsTACAAQdjAgwE2AgQgACABNgIACxMAIABB6MCDATYCBCAAIAE2AgALEwAgAEH4wIMBNgIEIAAgATYCAAsTACAAQYjBgwE2AgQgACABNgIACxMAIABBmMGDATYCBCAAIAE2AgALEwAgAEGowYMBNgIEIAAgATYCAAsTACAAQbjBgwE2AgQgACABNgIACxMAIABByMGDATYCBCAAIAE2AgALEwAgAEHYwYMBNgIEIAAgATYCAAsTACAAQejBgwE2AgQgACABNgIACxMAIABB+MGDATYCBCAAIAE2AgALEwAgAEGIwoMBNgIEIAAgATYCAAsTACAAQZjCgwE2AgQgACABNgIACxMAIABBqMKDATYCBCAAIAE2AgALEwAgAEG4woMBNgIEIAAgATYCAAsTACAAQcjCgwE2AgQgACABNgIACxMAIABB2MKDATYCBCAAIAE2AgALEwAgAEHowoMBNgIEIAAgATYCAAsTACAAQfjCgwE2AgQgACABNgIACxMAIABBiMODATYCBCAAIAE2AgALEwAgAEGYw4MBNgIEIAAgATYCAAsTACAAQajDgwE2AgQgACABNgIACxMAIABBuMODATYCBCAAIAE2AgALEwAgAEHIw4MBNgIEIAAgATYCAAsTACAAQdjDgwE2AgQgACABNgIACxMAIABB6MODATYCBCAAIAE2AgALEwAgAEH4w4MBNgIEIAAgATYCAAsTACAAQYjEgwE2AgQgACABNgIACxMAIABBmMSDATYCBCAAIAE2AgALEwAgAEGoxIMBNgIEIAAgATYCAAsTACAAQbjEgwE2AgQgACABNgIACxMAIABByMSDATYCBCAAIAE2AgALEwAgAEHYxIMBNgIEIAAgATYCAAsTACAAQejEgwE2AgQgACABNgIACxMAIABB+MSDATYCBCAAIAE2AgALEwAgAEGIxYMBNgIEIAAgATYCAAsTACAAQZjFgwE2AgQgACABNgIACxMAIABB6MuDATYCBCAAIAE2AgALEQAgACgCACAAKAIEIAEQywoLEwAgAEHojoQBNgIEIAAgATYCAAsTACAAQYSPhAE2AgQgACABNgIACxMAIABBlI+EATYCBCAAIAE2AgALEwAgAEGkj4QBNgIEIAAgATYCAAsTACAAQbSPhAE2AgQgACABNgIACxMAIABBxI+EATYCBCAAIAE2AgALEwAgAEHUj4QBNgIEIAAgATYCAAsTACAAQeSPhAE2AgQgACABNgIACxMAIABB9I+EATYCBCAAIAE2AgALEwAgAEGEkIQBNgIEIAAgATYCAAsTACAAQZSQhAE2AgQgACABNgIACxMAIABBpJCEATYCBCAAIAE2AgALEwAgAEG0kIQBNgIEIAAgATYCAAsTACAAQYSWhAE2AgQgACABNgIACxMAIABBlJaEATYCBCAAIAE2AgALEwAgAEGkloQBNgIEIAAgATYCAAsTACAAQbSWhAE2AgQgACABNgIACxMAIABBxJaEATYCBCAAIAE2AgALEwAgAEHUloQBNgIEIAAgATYCAAsTACAAQdiXhAE2AgQgACABNgIACxMAIABB6JeEATYCBCAAIAE2AgALEwAgAEH4l4QBNgIEIAAgATYCAAsTACAAQYiYhAE2AgQgACABNgIACxMAIABBmJiEATYCBCAAIAE2AgALEwAgAEGomIQBNgIEIAAgATYCAAsTACAAQbiYhAE2AgQgACABNgIACxMAIABByJiEATYCBCAAIAE2AgALEwAgAEHYmIQBNgIEIAAgATYCAAsTACAAQeiYhAE2AgQgACABNgIACxMAIABB+JiEATYCBCAAIAE2AgALEwAgAEGImYQBNgIEIAAgATYCAAsTACAAQZiZhAE2AgQgACABNgIACxMAIABBqJmEATYCBCAAIAE2AgALEwAgAEG4mYQBNgIEIAAgATYCAAsTACAAQciZhAE2AgQgACABNgIACxMAIABB2JmEATYCBCAAIAE2AgALEwAgAEHomYQBNgIEIAAgATYCAAsTACAAQfiZhAE2AgQgACABNgIACxMAIABBiJqEATYCBCAAIAE2AgALEwAgAEGYmoQBNgIEIAAgATYCAAsTACAAQaiahAE2AgQgACABNgIACxMAIABBuJqEATYCBCAAIAE2AgALEwAgAEHImoQBNgIEIAAgATYCAAsTACAAQdiahAE2AgQgACABNgIACxMAIABB6JqEATYCBCAAIAE2AgALEwAgAEH4moQBNgIEIAAgATYCAAsTACAAQYibhAE2AgQgACABNgIACxMAIABBmJuEATYCBCAAIAE2AgALEwAgAEGom4QBNgIEIAAgATYCAAsTACAAQbibhAE2AgQgACABNgIACxMAIABByJuEATYCBCAAIAE2AgALEwAgAEGMnYQBNgIEIAAgATYCAAsTACAAQaSdhAE2AgQgACABNgIACxMAIABBtJ2EATYCBCAAIAE2AgALEwAgAEHEnYQBNgIEIAAgATYCAAsTACAAQdSdhAE2AgQgACABNgIACxMAIABB5J2EATYCBCAAIAE2AgALEwAgAEH0nYQBNgIEIAAgATYCAAsTACAAQYSehAE2AgQgACABNgIACxMAIABBlJ6EATYCBCAAIAE2AgALEwAgAEHYyoQBNgIEIAAgATYCAAsTACAAQejKhAE2AgQgACABNgIACxMAIABB+MqEATYCBCAAIAE2AgALEwAgAEGIy4QBNgIEIAAgATYCAAsTACAAQZjLhAE2AgQgACABNgIACxMAIABBqMuEATYCBCAAIAE2AgALEwAgAEG4y4QBNgIEIAAgATYCAAsTACAAQcjLhAE2AgQgACABNgIACxMAIABB2MuEATYCBCAAIAE2AgALEwAgAEHoy4QBNgIEIAAgATYCAAsTACAAQfjLhAE2AgQgACABNgIACxMAIABBiMyEATYCBCAAIAE2AgALEwAgAEGYzIQBNgIEIAAgATYCAAsTACAAQajMhAE2AgQgACABNgIACxMAIABBuMyEATYCBCAAIAE2AgALEwAgAEHIzIQBNgIEIAAgATYCAAsTACAAQdjMhAE2AgQgACABNgIACxMAIABB6MyEATYCBCAAIAE2AgALEwAgAEH4zIQBNgIEIAAgATYCAAsTACAAQYjNhAE2AgQgACABNgIACxMAIABBmM2EATYCBCAAIAE2AgALEwAgAEGozYQBNgIEIAAgATYCAAsTACAAQbjNhAE2AgQgACABNgIACxMAIABByM2EATYCBCAAIAE2AgALEwAgAEHYzYQBNgIEIAAgATYCAAsTACAAQejNhAE2AgQgACABNgIACxMAIABB+M2EATYCBCAAIAE2AgALEwAgAEGIzoQBNgIEIAAgATYCAAsTACAAQZjOhAE2AgQgACABNgIACxMAIABBqM6EATYCBCAAIAE2AgALEwAgAEG4zoQBNgIEIAAgATYCAAsTACAAQcjOhAE2AgQgACABNgIACw8AIAAoAixBACAAKAIYGwsTACAAQeDshAE2AgQgACABNgIACxMAIABB8OyEATYCBCAAIAE2AgALEwAgAEGA7YQBNgIEIAAgATYCAAsTACAAQZDthAE2AgQgACABNgIACxMAIABBoO2EATYCBCAAIAE2AgALEwAgAEGw7YQBNgIEIAAgATYCAAsTACAAQcDthAE2AgQgACABNgIACxMAIABB0O2EATYCBCAAIAE2AgALDwAgACgCOEEAIAAoAiQbCxMAIABB1PiEATYCBCAAIAE2AgALEwAgAEHk+IQBNgIEIAAgATYCAAsTACAAQfT4hAE2AgQgACABNgIACxMAIABBrMuFATYCBCAAIAE2AgALEwAgAEG8y4UBNgIEIAAgATYCAAsTACAAQYDZhQE2AgQgACABNgIACxMAIABBkNmFATYCBCAAIAE2AgALDQAgACgCHEEDdkEBawsNACAAKAIcQQJ2QQFrCw8AIAAoAjRBACAAKAIgGwsTACAAQaThhQE2AgQgACABNgIACw0AIAAoAkhBAnZBAWsLDwAgACgCYEEAIAAoAkwbC2wBAn8gACgCACECIAAoAgQhAyMAQRBrIgAkACAAQQRqIAEQly0gAwRAIANBAnQhAQNAIAAgAjYCDCAAQQRqIABBDGpBsPaEARDJFCACQQRqIQIgAUEEayIBDQALCyAAQQRqEKksIABBEGokAAtlAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQANAIAAgAjYCDCAAQQRqIABBDGpBgPaEARDJFCACQQFqIQIgA0EBayIDDQALCyAAQQRqEKksIABBEGokAAtsAQJ/IAAoAgAhAiAAKAIEIQMjAEEQayIAJAAgAEEEaiABEJctIAMEQCADQQF0IQEDQCAAIAI2AgwgAEEEaiAAQQxqQZD2hAEQyRQgAkECaiECIAFBAmsiAQ0ACwsgAEEEahCpLCAAQRBqJAALbAECfyAAKAIAIQIgACgCBCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0EDdCEBA0AgACACNgIMIABBBGogAEEMakGg9oQBEMkUIAJBCGohAiABQQhrIgENAAsLIABBBGoQqSwgAEEQaiQAC5oFAgt/AX4gACgCAEEIaiEAIwBBIGsiBSQAIAAoAgBBCGoiBiAAKAIEQQJ0aiEHIwBBIGsiAiQAIAJBFGogByAGa0ECdkEAQQRBDBCgGCACKAIYIQAgAigCFEEBRgRAIAAgAigCHEH43IcBEP0vAAsgAkEQaiIKQQA2AgAgAiACKAIcNgIMIAIgADYCCCMAQRBrIggkACAHIAZrQQJ2IgQgAkEIaiIAKAIAIAAoAggiA2tLBEAgACADIARBBEEMENwoIAAoAgghAwsgBUEUaiEJIAggACgCBDYCDCAIIAM2AgggCCAAQQhqNgIEIwBBMGsiACQAIAhBBGoiBCgCBCEDIAQoAgAhCwJAAkAgBiAHRwRAIAQoAgggA0EMbGohBCAHIAZrQQJ2IQcDQCAAQQA2AgggAEKAgICAEDcCACAAIAYoAgBBCGo2AgwgAEEBNgIUIABB+M6HATYCECAAQgE3AhwgAEHpHDYCLCAAIABBKGo2AhggACAAQQxqNgIoIABB7NqHASAAQRBqEMsKDQIgAEEYaiAAQQhqKAIAIgw2AgAgACAAKQIAIg03AxAgBEEIaiAMNgIAIAQgDTcCACAGQQRqIQYgBEEMaiEEIANBAWohAyAHQQFrIgcNAAsLIAsgAzYCACAAQTBqJAAMAQtBlNuHAUE3IABBEGpBhNuHAUHM24cBENUeAAsgCEEQaiQAIAlBCGogCigCADYCACAJIAIpAgg3AgAgAkEgaiQAIAVBCGoiAyAFKAIYIgAgBSgCHCICQdTdhwFBAhDxAyABIAUoAgwgBSgCEBD7NSADQQFBARDgHiACBEADQCAAQQFBARDgHiAAQQxqIQAgAkEBayICDQALCyAFQRRqQQRBDBDgHiAFQSBqJAALEwAgAEHA74UBNgIEIAAgATYCAAsPACAAKAIoQQAgACgCFBsLEwAgAEGk+YUBNgIEIAAgATYCAAsPACAAKAIwQQAgACgCHBsLEwAgAEHsh4YBNgIEIAAgATYCAAsTACAAQZiQhgE2AgQgACABNgIACxMAIABBqJCGATYCBCAAIAE2AgALEwAgAEG4kIYBNgIEIAAgATYCAAsTACAAQciQhgE2AgQgACABNgIACw0AIAAoAhRBAnZBAWsLDQAgACgCFEEDdkEBawsTACAAQZSVhgE2AgQgACABNgIACxMAIABBpJWGATYCBCAAIAE2AgALDwAgACgCQEEAIAAoAiwbCxMAIABB5KKGATYCBCAAIAE2AgALEwAgAEGcp4YBNgIEIAAgATYCAAsTACAAQZSphgE2AgQgACABNgIACw8AIAAgASAEIAMgBBCtDwsPACAAIAEgBCADIAQQ6RALDwAgACABIAQgAyAEEOoQCw8AIAAgASAEIAMgBBDrEAsPACAAIAEgBCADIAQQhRELDwAgACABIAQgAyAEEL8OCw8AIAAgASAEIAMgBBDADgsPACAAIAEgAiADIAQQwwoLbAECfyAAKAIEIQIgACgCCCEDIwBBEGsiACQAIABBBGogARCXLSADBEAgA0ECdCEBA0AgACACNgIMIABBBGogAEEMakGw3ocBEMkUIAJBBGohAiABQQRrIgENAAsLIABBBGoQqSwgAEEQaiQACw8AIAAgASACIAMgBBDxAwuwAQEGfyMAQRBrIgMkACADIAFBA3YgAUEHcUEAR2oQ0h8gAygCBCEGIAMoAgAhByADKAIMIQQgAygCCCEFQRxBBBCtNiICRQRAQQRBHBCjPQALIAIgBjYCGCACIAc2AhQgAkEANgIQIAIgBDYCDCACIAU2AgggAkKBgICAEDcCACAAIAE2AhAgAEEANgIMIAAgBDYCCCAAIAU2AgQgACACNgIAIANBEGokACAAIAE2AhQLEAAgACgCAEUEQCAAEIQNCwsRACAAIAAoAgwgACgCEBDTHwsQACAAIAEoAgAgAiADEI0YCxAAIAAgASgCACACIAMQxhILEAAgACABNgIEIABBADYCAAsQACAAQQA2AgAgAEEANgIICxIAIAAoAgAlASABKAIAJQEQMQsPACAAKAIAJQEgASACEDILDgAgACgCACUBEERBAEcLDwAgACAAKAIUQQFqNgIUCxMAIABB7LWJATYCBCAAIAE2AgALEQAgASAAKAIAIAAoAgQQ+zULEQAgASAAKAIAIAAoAgQQ1gkLEQAgASgCACABKAIEIAAQywoLEQEBfxDfEiIBIAAlASYBIAELgwECA38BbyMAQTBrIgEkACAAEMkhIQAgAUEAOgAsIAEgADYCDCMAQTBrIgAkACAAQQhqIgMgAUEMakEk/AoAACAAQQE2AgQgACAAQQRqNgIsIABBLGpBhN3DABCTPSECIAAoAgQEQCADEOIgCyAAQTBqJAAgAUEwaiQAIAIlASACEPIfCw8AIAAoAgAoAgAgARDbHAsPACAAKAIAKAIAIAEQnhALYgEBfwJAAkAgABCaPigCBCICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABDwCQwCC0GIqYkBQS5BuKmJARCfKQALQcipiQFBLkH4qYkBEJ8pAAsLDQBBACABIAAgARCsHgsNAEEAIAEgACABENgpCxAAIABBgPz//wNxQYCwA0YLCgAgAUEYdCAAcgsMAEEAIAAQmixBCGoLDQAgACgCCCAAKAIYagsOACAAIAFB9KjOABCtFQsNACAAKAIQIAAoAhRrCw0AIAAgASACQQIQ7SALDQAgACABIAJBABC0GwsNACAAKAIEIAAoAgBrCw0AIAAoAhAgACgCBGoLDQAgACkDABogACgCCAsOACAAKAIAQThBBBD4OgsOACAAQbO++wBBNRDLGgsNACAAKAAAIAEoAABGCwsAIAAgASACEIggCwsAIAAgASACEKQaCwwAIAAgARCHJUEBcwsMACAAIAEQiCVBAXMLlgsBDn8gACEHIwBB8ABrIgQkACAEIAE2AiwgBEEgaiABQQhqIgkQwzQCQAJAAkACfwJAAkAgBCgCJCIIIAIoAggiAEYEQCADKAIAIgwNAiAIBEAgAigCBCIAKAIAIAAoAgQiBSgCCEEBa0F4cWpBCGogBSgCJBEEAAwECyAEQTBqQTZBAEEBQQEQoBggBCgCNCEDIAQoAjBBAUcNAQwGCyAEIAA2AlAgBEEYaiAJEMM0IAQgBCgCHDYCVCAEQQM2AjQgBEG4/oQBNgIwIARCAjcCPCAEQTs2AmQgBEE7NgJcIAQgBEHYAGo2AjggBCAEQdQAajYCYCAEIARB0ABqNgJYIAdBCGogBEEwahCZDgwDCyAEKAI4IgBB0P6EAUE2/AoAACAHQTY2AhAgByAANgIMIAcgAzYCCAwCCyACKAIEIQAgAygCBAshESAEQRBqIAkQry4gBCgCECEGIAQgBCgCFDYCNCAEIAY2AjACQCAEQTBqEJ42IgUgCCAFIAhJGyINBEAgACEFA0AgBigCAC0ASEUEQCAFKAIAIAVBBGooAgAiCigCCEEBa0F4cWpBCGogCigCRBEEAA0DCyAGQQRqIQYgBUEIaiEFIA1BAWsiDQ0ACwsgACAIQQN0IgVqIRAgACEGAkADQCAFRQ0BIAVBCGshBSAGKAIEIQ4gBigCACAGQQhqIQYgDigCCEEBa0F4cWpBCGogDigCJBEEACARRg0ACyAEQTBqQT9BNyAMGyIFQQBBAUEBEKAYIAQoAjQhAyAEKAIwQQFGDQQgBCgCOCEAIAUEQCAAQe/8hAFBuPyEASAMGyAF/AoAAAsgByAFNgIQIAcgADYCDCAHIAM2AggMAgsgAy0ACCEFIARBCGogCRDDNCAEKAIMIQMgBCAEKAIIIgo2AlggBCAKIANBAnRqIgM2AlwgBEHYAGoiDxCeNiEGIARBADYCQCAEIAM2AjwgBCAKNgI4IAQgEDYCNCAEIAA2AjAgBCAGIAggBiAISRs2AkQgBEEANgJIQeoaQesaIAUbIRAgBEHIAGohDCMAQRBrIgskAAJAAkAgBEEwaiIIKAIQIgYgCCgCFCIKSQRAIAgoAgAgBkEDdGohCSAIKAIIIAZBAnRqIQ0gDCgCACEFA0AgCCAGQQFqIgY2AhAgCSgCACAJQQRqKAIAIgAoAghBAWtBeHFqQQhqIAAoAhwRBAAhACALIA0oAgBBMGo2AgwgCyAANgIIIAsgBTYCBAJAIAtBBGogEBEEAEUEQCAMIAVBAWo2AgAMAQsgCygCDCEDIAsoAgghDiALKAIEIQAgDCAFQQFqNgIAIA4NAwsgCUEIaiEJIA1BBGohDSAFQQFqIQUgBiAKRw0ACwsgD0EANgIEDAELIA8gAzYCCCAPIA42AgQgDyAANgIACyALQRBqJAAgBCgCXCIDBEAgBCgCYCEAIAQgBCgCWDYCTCAEIAM2AlAgBCAANgJUIARBAzYCXCAEQaD8hAE2AlggBEIDNwJkIARBOzYCRCAEQa8DNgI8IARBrwM2AjQgBCAINgJgIAQgBEHMAGo2AkAgBCAEQdAAajYCOCAEIARB1ABqNgIwIAdBCGogDxCZDgwCCyAHIBE2AhQgByABNgIQIAdBADYCACAHQQxqIAJBCGooAgA2AgAgByACKQIANwIEDAILIAYoAgAhACAEQYQBNgJcIARBAjYCNCAEQez9hAE2AjAgBEIBNwI8IAQgAEE8ajYCVCAEIARB1ABqNgJYIAQgBEHYAGo2AjggB0EIaiAEQTBqEJkOCyAHQoGAgIDQgYCAgH83AgAgAhDDJyACQQRBCBDgHiABIAEoAgAiAEEBazYCACAAQQFHDQAgBEEsahD4IwwACyAEQfAAaiQADwsgAyAEKAI4Qfz2hAEQ/S8ACwkAIABBBBDuKAsMACAAIAEQkSVBAXMLDQAgACgCACgCIEEEdgsMACAAIAEQkyVBAXMLDAAgACABEJIlQQFzCwwAIAAgARCUJUEBcwsMACAAIAEQlSVBAXMLDAAgACABEJYlQQFzCwwAIAAgARCXJUEBcwsMACAAIAEQmyVBAXMLDAAgACABEJolQQFzCw4AIAEgAiAAKAIAEQAACw0AIAMgASADIAMQxRILDQAgACABIAIgAxD1FAsPACAAKAIAKAIAIAEQrhALDQAgACABIAIgAxCwHwsNACAAIAEgAiADEL8jCw0AIAAgASACIAMQwS4LDQAgACgCACgCCEEBRgsNACAAKAIAKAIQQQFGCxIAIAAoAgAlASABKAIAJQEQFAsOACAAKAIAJQEQGEEARwsNACAAKAIAJQEgARAwCw0AIAAoAgAlAUEBEDMLngIBBH8CfyMAQSBrIgAkAAJAAkBB5O6KASgCAEUEQEHs7ooBKAIAIQFB7O6KAUEANgIAIAFFDQEgAREPACEBQeTuigEoAgAiAkUEQAJAIAJFDQBB6O6KASgCACIDQYQBSQ0AIAMQ8h8LQejuigEgATYCAEHk7ooBQQE2AgALIAAgATYCBCAAIAI2AgAgACAAKAIENgIMIAAgACgCACIBNgIIIAENAgsgAEEgaiQAQejuigEMAgsgAEEANgIYIABBATYCDCAAQaCsiAE2AgggAEIENwIQIABBCGpBqKyIARDvLAALIABBCGoiARD6LiAAQQA2AhggAEEBNgIMIABByKyIATYCCCAAQgQ3AhAgAUHQrIgBEO8sAAsoAgAQ9DoLDAAgACgCACABENI0CxwBAW8gACgCACUBQQAQXSEBEN8SIgAgASYBIAALDgAgACgCACUBEGpBAEcLDgAgACgCACUBEGtBAEcLDgAgACgCACUBEGxBAEcLDgAgACgCACUBEHVBAEcLDQAgACABIAIgAxD0LgsNACAAKAIAIAAoAgRqC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Hcj4oBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H8j4oBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0GwkIoBNgIIIANCAjcCFCADIANBBGqtQoCAgICwB4Q3AyggAyADrUKAgICAsAeENwMgIAMgA0EgajYCECADQQhqIAIQ7ywACw8AQf3uiQFBKyAAEJ8pAAtrAQF/IwBBMGsiAyQAIAMgADYCBCADIAE2AgAgA0EDNgIMIANBlJGKATYCCCADQgI3AhQgAyADQQRqrUKAgICAsAeENwMoIAMgA61CgICAgLAHhDcDICADIANBIGo2AhAgA0EIaiACEO8sAAuaAgIBfgJ/IAAoAgApAwAhAiMAQYABayIEJAACfwJAIAEoAggiAEGAgIAQcUUEQCAAQYCAgCBxDQEgAUEBQQFBACAEIAIgBEEUEO0QIgBqQRQgAGsQgQkMAgtBACEAA0AgACAEakH/AGogAqdBD3EiA0EwciADQdcAaiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJDAELQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQeDziQFBAiAAIARqQYABakEAIABrEIEJCyAEQYABaiQACxwCAW8BfxBmIQAQ3xIiASAAJgEgASUBIAEQ8h8LHAIBbwF/EGchABDfEiIBIAAmASABJQEgARDyHwsHACAAEN47Cw4AIAFBy9TCAEEFEPs1Cw4AIAFB69bCAEEIEPs1Cw4AIAFBs+rCAEEFEPs1Cw4AIAFB4+zCAEEIEPs1Cw4AIAFBmPrCAEEFEPs1C0YBAn8jAEEQayIBJAAgASAAQQhrIgA2AgwgAUEMaiICEM0bIAAgACgCACIAQQFrNgIAIABBAUYEQCACELYfCyABQRBqJAALRgECfyMAQRBrIgEkACABIABBCGsiADYCDCABQQxqIgIQyxsgACAAKAIAIgBBAWs2AgAgAEEBRgRAIAIQuB8LIAFBEGokAAtGAQJ/IwBBEGsiASQAIAEgAEEIayIANgIMIAFBDGoiAhDMGyAAIAAoAgAiAEEBazYCACAAQQFGBEAgAhC3HwsgAUEQaiQACwwAIAAoAgAgARCaGAsOACABQYeSwwBBBRD7NQsOACABQbiTwwBBCBD7NQsOACABQdijwwBBFBD7NQsOACABQZykwwBBChD7NQvZBQECfyAAKAIAIQIjAEEQayIAJAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQsgAigCACICKAIAIgNBgICAgHhzIANBAE4bQQFrDhIBAgMEBQYHCAkKCwwNDg8QERIACyAAIAJBBGo2AgwgAUGAwcwAQREgAEEMakHwwMwAENATDBILIAAgAkEEajYCDCABQaTBzABBDSAAQQxqQZTBzAAQ0BMMEQsgACACQQRqNgIMIAFBscHMAEEJIABBDGpB8MDMABDQEwwQCyAAIAJBBGo2AgwgAUG6wcwAQQsgAEEMakHwwMwAENATDA8LIAAgAkEEajYCDCABQcXBzABBCiAAQQxqQfDAzAAQ0BMMDgsgACACQQRqNgIMIAFBz8HMAEELIABBDGpB8MDMABDQEwwNCyAAIAJBBGo2AgwgAUHawcwAQQwgAEEMakHwwMwAENATDAwLIAFB5sHMAEEMEPs1DAsLIAAgAkEEajYCDCABQfLBzABBEiAAQQxqQfDAzAAQ0BMMCgsgACACQQRqNgIMIAFBhMLMAEEIIABBDGpB8MDMABDQEwwJCyAAIAJBBGo2AgwgAUGMwswAQQkgAEEMakHwwMwAENATDAgLIAAgAkEMajYCDCABQbjCzABBByACQZjCzAAgAEEMakGowswAEIMPDAcLIAAgAkEEajYCDCABQb/CzABBCCAAQQxqQfDAzAAQ0BMMBgsgACACQQRqNgIMIAFBx8LMAEEUIABBDGpB8MDMABDQEwwFCyAAIAJBBGo2AgwgAUHbwswAQQwgAEEMakHwwMwAENATDAQLIAAgAkEEajYCDCABQefCzABBDiAAQQxqQfDAzAAQ0BMMAwsgAUH1wswAQRoQ+zUMAgsgAUGPw8wAQRgQ+zUMAQsgACACQQRqNgIMIAFBuMPMAEETIABBDGpBqMPMABDQEwsgAEEQaiQAC+UCAQF/IAAoAgAhAiMAQRBrIgAkAAJ/AkACQAJAAkACQAJAAkACQCACKAIAIgIoAgBBAWsOBwECAwQFBgcACyAAIAJBBGo2AgwgAUGgtMMAQQcgAEEMakGQtMMAENATDAcLIAAgAkEEajYCDCABQae0wwBBAyAAQQxqQZC0wwAQ0BMMBgsgACACQQRqNgIMIAFBqrTDAEEDIABBDGpBkLTDABDQEwwFCyAAIAJBBGo2AgwgAUGttMMAQQogAEEMakGQtMMAENATDAQLIAAgAkEIajYCDCABQdi0wwBBDyACQQRqQbi0wwAgAEEMakHItMMAEIMPDAMLIAAgAkEEajYCDCABQfi0wwBBCCAAQQxqQei0wwAQ0BMMAgsgACACQQRqNgIMIAFBgLXDAEEMIABBDGpByLTDABDQEwwBCyAAIAJBCGo2AgwgAUGctcMAQREgAEEMakGMtcMAENATCyAAQRBqJAALDgAgAUGfssMAQQUQ+zULDgAgAUGItMMAQQgQ+zULDgAgAUH+tcMAQQgQ+zULDgAgAUGcy8MAQRYQ+zULDgAgAUHI38MAQQUQ+zULZwEBfyAAKAIAIQIjAEEQayIAJAAgACACLwEAOwEOAn8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgAEEOaiABEJwSDAILIABBDmogARC3HAwBCyAAQQ5qIAEQtBwLIABBEGokAAujCgEDfyAAKAIAIQAjAEFAaiIDJAAgAyAALwEAOwEmAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAvAQAiBEGPA00EQCAEQeEBTQRAAkAgBEHIAWsOCQYHCAkKCwwNDgALIARB5ABrDgMCAwRACyAEQawCaw4JDg8QERITPxQVDQsCQCAEQZADaw40FhcYGRobHB0eHyAhIiMkJSYnKD8/KSorLC0uPy8wPzE/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/MgALIARB9ANrDgwyMzQ1Njc4OTo+Ozw+C0HA/MMAIQJBCCEADD0LQcj8wwAhAkETIQAMPAtB2/zDACECQQohAAw7C0Hl/MMAIQJBAiEADDoLQef8wwAhAkEHIQAMOQtB7vzDACECQQghAAw4C0H2/MMAIQJBHSEADDcLQZP9wwAhAkEKIQAMNgtBnf3DACECQQ0hAAw1C0Gq/cMAIQJBDyEADDQLQbn9wwAhAkEMIQAMMwtBxf3DACECQRAhAAwyCyAEQeIBRw0xQdX9wwAhAkEHIQAMMQtB3P3DACECQRAhAAwwC0Hs/cMAIQJBESEADC8LQf39wwAhAkEFIQAMLgtBgv7DACECQQkhAAwtC0GL/sMAIQJBDCEADCwLQZf+wwAhAkEJIQAMKwtBoP7DACECQRIhAAwqC0Gy/sMAIQJBEiEADCkLQcT+wwAhAkELIQAMKAtBz/7DACECQQwhAAwnC0Hb/sMAIQJBECEADCYLQev+wwAhAkEJIQAMJQtB9P7DACECQQkhAAwkC0H9/sMAIQJBEiEADCMLQY//wwAhAkEOIQAMIgtBnf/DACECQR0hAAwhC0G6/8MAIQJBDyEADCALQcn/wwAhAkEIIQAMHwtB0f/DACECQQQhAAweC0HV/8MAIQJBDyEADB0LQeT/wwAhAkETIQAMHAtB9//DACECQREhAAwbC0GIgMQAIQJBDCEADBoLQZSAxAAhAkEWIQAMGQtBqoDEACECQRUhAAwYC0G/gMQAIQJBEiEADBcLQdGAxAAhAkEMIQAMFgtB3YDEACECQRMhAAwVC0HwgMQAIQJBFCEADBQLQYSBxAAhAkEGIQAMEwtBioHEACECQREhAAwSC0GbgcQAIQJBCSEADBELQaSBxAAhAkEQIQAMEAtBtIHEACECQRUhAAwPC0HJgcQAIQJBESEADA4LQdqBxAAMDAtB+YHEACECQR0hAAwMC0GWgsQAIQJBFSEADAsLQauCxAAhAkEPIQAMCgtBuoLEACECQQshAAwJC0HFgsQAIQJBEyEADAgLQdiCxAAhAkEPIQAMBwtB54LEACECQRohAAwGC0GBg8QAIQJBFyEADAULQZiDxAAhAkEUIQAMBAtBrIPEACECQQ0hAAwDC0G5g8QAIQJBDCEADAILQcWDxAALIQJBHyEACyADIAA2AgQgAyACNgIAIAMgAygCBEEVIAMoAgAiABs2AiwgAyAAQbT4wwAgABs2AiggA0ECNgIQIANBzPjDADYCDCADQgI3AhggA0HHAjYCPCADQcgCNgI0IAMgA0EwajYCFCADIANBKGo2AjggAyADQSZqNgIwIAEoAgAgASgCBCADQQxqEMsKIANBQGskAAsOACABQcPnwwBBCRD7NQsOACABQazrwwBBExD7NQsOACABQb/rwwBBGRD7NQsdAQFvIABBEGooAgAlARARIQEQ3xIiACABJgEgAAsOACABQc3xwwBBGBD7NQsOACABQffxwwBBHBD7NQsOACABQZPywwBBIRD7NQsLACAAQQRBNBDgHgsOACABQdr2wwBBEBD7NQsMACAAIAEpAgA3AwALDgAgAUGh+MMAQRMQ+zULDgAgAUHt+MMAQRMQ+zULDgAgAUH3hMQAQQUQ+zULDgAgAEGwm8QAIAEQywoLDAAgACABKQIENwMACwgAIAAoAgAaCwsAIABBAUEBEOAeC4gBAQF/IAAoAgAhAiMAQTBrIgAkACAAIAIoAgAiAjYCGCAAIAJoNgIcIABBAzYCBCAAQZTtiQE2AgAgAEICNwIMIAAgAEEcaq1CgICAgJDjA4Q3AyggACAAQRhqrUKAgICAoOMDhDcDICAAIABBIGo2AgggASgCACABKAIEIAAQywogAEEwaiQACwsAIABBBEEUEOAeCw4AIAFBoMXMAEEFEPs1Cw4AIAFBmMbMAEEFEPs1CwwAIAAgASgCABD3IwsOACABQd+7zQBBCxD7NQsMACAAIAEpAmQ3AwALRwEBfyABKAIARQRAQbz8zgAQsjsACyAAIAEgASgCMCIDIAIgAiADSxtBARCzFiICNgIEIABBCDYCACABIAEoAjAgAms2AjALgQIBBH8CQCMAQRBrIgMkAAJAIAEoAiAEQAJAIAEoAjAiBCACIAIgBEsbIgJBDGwiBSABKAIoIAEoAjQiBmtNBEAgACACNgIEIABBCDYCACABIAQgAms2AjAgASAFIAZqNgI0DAELIANBBGpBGEEAQQFBARCgGCADKAIIIQIgAygCBEEBRg0CIAMoAgwiAUEQakG0iM4AKQAANwAAIAFBCGpBrIjOACkAADcAACABQaSIzgApAAA3AAAgAEEYNgIMIAAgATYCCCAAIAI2AgQgAEECNgIACyADQRBqJAAMAgtB5IfOAEEgQZSIzgAQyyQACyACIAMoAgxBnIfOABD9LwALCwsAIABBBEEMEOAeCwsAIABBBEEEEOAeCwsAIABBBEEIEOAeCwsAIABBAUEAEOAeCwwAIABBCEHAABDgHgsLACAAQQhBEBDgHgsLACAAQQRBEBDgHgsMACAAQQhB0AAQ4B4LCwAgAEEEQSAQ4B4LDAAgAEEEQeAAEOAeCwsAIABBBEEYEOAeCwwAIABBCEHAAhDgHgsMACAAQQhBuAUQ4B4LCwAgAEEIQRgQ4B4LCgAgACgCCEEFdAvwAQECfyAAKAIAIQMjAEEQayIAJAAgA0EEaiECAn8CQAJAAkACQAJAAkACQAJAIAMoAgBBAWsOBwECAwQFBgcACyABQdj3zgBBDBD7NQwHCyABQeT3zgBBBhD7NQwGCyAAIAI2AgQgAUHq984AQQQgAEEEakHgiM8AENATDAULIAFB7vfOAEEDEPs1DAQLIAAgAjYCCCABQfH3zgBBBiAAQQhqQfCIzwAQ0BMMAwsgAUH3984AQQMQ+zUMAgsgACACNgIMIAFB+vfOAEEEIABBDGpBgInPABDQEwwBCyABQf73zgBBBxD7NQsgAEEQaiQACwwAIAAoAgAgARDTGwsOACABQcyZzwBBCxD7NQsOACABQZChzwBBCxD7NQsKACAAKAIYQQhqCwoAIABBDGoQ2zwLCgAgAEEMahDYPAsKACAAQQxqENk8CwoAIABBDGoQ2jwLCgAgAEEMahDcPAsOACABQaue0ABBDBD7NQsOACABQbee0ABBDBD7NQsOACABQaCe0ABBCxD7NQsMACAAIAEpAlQ3AwALCgAgACgCLEEIagsMACAAIAEpAiQ3AwALCwAgACgCvAJBCGoLDgAgAUH4odAAQQIQ1gkLDgAgAUHLo9AAQQ4Q+zULDgAgAUHZo9AAQQsQ+zULDAAgACgCACABEPwYCwcAIAAQnTwLDgBBnOLQAEEKIAEQ3AcLeAECfyAAKAIAIQAjAEEQayIBJAACQCAARQ0AIAAoAsgFDQACQCAAIAAoApgETwRAIAAoApwEIQIgABCvICAAIAJPDQEMAgsgABCvIAsgAUEIaiAAQcAFaigCADYCACABIAApArgFNwMAIAAgARCLLQsgAUEQaiQAC/gBAQV/IAAoAgAhACMAQSBrIgEkAAJAIABFDQAgACgCkOsBDQAgAUEYaiICIABBhOsBaigCADYCACABIAApAvzqATcDECAAEPwwIAAoArjrASABQQhqIAIoAgA2AgAgASABKQMQNwMAIAEQiy0gAEEANgK46wEgASgCFCECIAAoAqjrASIDBEAgASgCGCEEAkACQAJAAkAgAygCACIFBEAgAkUNAiAEIAUgAhEAAAwBCyACRQ0CCyAEIAMgAhEAAAwCCyAFENI1CyADENI1CyAAQQA2AqjrAQsgAgRAIAEoAhggACACEQAADAELIAAQ0jULIAFBIGokAAsLACAAIAFBAxCmJAsMACAAKAIAIAEQ1g4LDAAgACgCACABEJc+Cw4AIAFB4MzRAEEOEPs1CwwAIAAoAgAgARD8KAsPACABQeDK0QBB4AAQ+zULDgAgAUHGneIAQQIQ1gkLDAAgACgCACABELI2C2cBAX8gACgCACECIwBBEGsiACQAIAAgAigCBDYCCCAAIAIoAgAiAjYCBAJ/IAIEQCAAIABBBGo2AgwgAUGovfsAQQQgAEEMakGYvfsAENATDAELIAFBlL37AEEEEPs1CyAAQRBqJAALDgAgAUH0wfsAQQIQ1gkLzQECA38BfiAAKAIAIQIjAEGAAWsiBCQAAkAgASkCCCIFpyIAQYCAgARxRQ0AIABBgICAwABxBEAgAEGAgIAIciEADAELIAFBCjsBDCAAQYCAgMgAciEACyABIABBgICABHI2AghBACEAA0AgACAEakH/AGogAkEPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFB4POJAUECIAAgBGpBgAFqQQAgAGsQgQkgASAFNwIIIARBgAFqJAALDgAgAUGr9PwAQQsQ+zULDAAgACgCACABEJovCwsAIABBAkECEOAeCw4AIABBuKj+ACABEMsKCw4AIAFB6Kn+AEEFEPs1Cw4AIAFBnMn+AEELEPs1C2gBAX8gACgCACECIwBBMGsiACQAIAAgAjYCDCAAQQE2AhQgAEH4zocBNgIQIABCATcCHCAAQekcNgIsIAAgAEEoajYCGCAAIABBDGo2AiggASgCACABKAIEIABBEGoQywogAEEwaiQACw4AIAFB4P7+AEELEPs1CwoAIABBDGooAggLDgAgAUG8kP8AQQsQ+zULDgAgAUGAyf8AQQsQ+zULDgAgAUGo+/8AQQsQ+zULDgAgAUGYmIABQQsQ+zULDgAgAEHEwYABIAEQywoLDgAgAEHcwYABIAEQywoLDgAgAUHAuIABQQUQ+zULDgAgAUHI5YABQQsQ+zULCgAgAEEQahC8KgsMACAAIAEoAgAQ+TQLDgAgAUGX+YABQQUQ+zULDAAgACgCACABELYcCw4AIAFB3PyBAUELEPs1Cw4AIAFBqLOCAUELEPs1Cw4AIAFB8MiCAUEFEPs1Cw4AIAFBmMmCAUELEPs1CwwAIAAgASgCABDDLQsOACABQcCCgwFBCxD7NQsOACABQbyzgwFBCxD7NQsOACABQbz1gwFBCxD7NQsOACABQaj5gwFBCxD7NQsMACAAIAEoAgAQxC0LDAAgACgCACABEMUtCwwAIAAoAgAgARDGLQsOACABQaOBhAFBCxD7NQsKACAAKAIUQQV2CwoAIAAoAhRBBHYLCgAgACgCFEECdgsKACAAKAIUQQN2CwoAIAAoAhRBAXYLCgAgACgCFEEESQsKACAAKAIUQRBJCwoAIAAoAhRBCEkLCgAgACgCFEEgSQsKACAAKAIUQQJJCwoAIAAQvSxBMGoLDgAgAUGQ6YQBQQsQ+zULCgAgACgCIEECdgsKACAAKAIgQQN2CwoAIAAoAiBBAXYLCgAgACgCIEEESQsKACAAKAIgQQhJCwoAIAAoAiBBAkkLDgAgAUHw9oQBQQsQ+zULDgAgAUHMvYUBQQUQ+zULCwAgAEHcAGoQ9DULCgAgACgCIEEEdgsKACAAKAIgQRBJCwoAIAAQ7x9BPGoLCgAgACgCHEEISQsKACAAKAIcQRBJCwoAIAAoAkhBCEkLCgAgACgCCEEDdgsKACAAKAIIQQF2CwoAIAAoAghBBHYLCgAgACgCCEECdgsKACAAKAIIQQV2C1cBAn8gACgCACECIwBBIGsiACQAIABBDGoiAyABQYDmhQFBDBDGLCAAIAIoAgQ2AhggACACKAIIQQJ2NgIcIAMgAEEYakGM5oUBEOQUENsbIABBIGokAAsKACAAQRhqEPQ1CwwAIAAoAgAgARCzNgsOACABQYfuhQFBCxD7NQsKACAAEL8sQSxqCw4AIAFB+P+FAUELEPs1CwsAIABBCEEIEOAeCwsAIABBEEEwEOAeCwsAIABBEEEgEOAeCwsAIABBEEEQEOAeCwoAIAAQsSpBPGoLCgAgACgCKEECdgsKACAAKAIoQQN2CwoAIAAoAihBBEkLCgAgACgCKEEISQsKACAAEL0sQThqCwoAIAAoAgBBAEcLDgAgAEHMv4YBIAEQywoLDAAgACABKQIQNwMACwwAIAAoAgAgARDdFAsOACABQY6PhwFBCxD7NQujAgECfyAAKAIAIQIjAEEQayIAJAACfwJAAkACQAJAAkBBAiACKAIAIgIoAgAiA0H/////B2ogA0GAgICAeE0bQQFrDgQBAgMEAAsgACACQQRqNgIMIAFBxJ2HAUEGIAJBDGpBpJ2HASAAQQxqQbSdhwEQgw8MBAsgACACQQhqNgIMIAFB3J2HAUEEIAJBBGpBpJ2HASAAQQxqQcydhwEQgw8MAwsgACACNgIMIAFB8J2HAUEGIAJBDGpBpJ2HASAAQQxqQeCdhwEQgw8MAgsgACACQQhqNgIMIAFB9p2HAUEKIAJBBGpBpJ2HASAAQQxqQcydhwEQgw8MAQsgACACQQRqNgIMIAFBkJ6HAUEFIABBDGpBgJ6HARDQEwsgAEEQaiQACw4AIAFBjKaHAUELEPs1CwwAIABBBEHMARDgHgsMACAAQQRBxAAQ4B4LDAAgACgCACABEPYGCwwAIAAoAgAgARCuEAsOACABQfzbhwFBBRD7NQvCCAILfwF+IAAoAgAhAiMAQTBrIgQkACABKAIAQd7xiQFBASABKAIEKAIMEQYAIQMgBEEIaiIAQQE6AAcgAEEAOwAFIAAgAzoABCAAIAE2AgAgBCACKAIMNgIoIAQgAigCACIBNgIgIAQgAUEIajYCGCAEIAEgAigCBGpBAWo2AhwgBCABKQMAQn+FQoCBgoSIkKDAgH+DNwMQAn8jAEEQayIGJAAgBEEQaiIBKAIYIggEQCABKQMAIQ0gASgCCCEHIAEoAhAhBQNAIA1QBEADQCAFQcABayEFIAcpAwAgB0EIaiEHQoCBgoSIkKDAgH+DIg1CgIGChIiQoMCAf1ENAAsgDUKAgYKEiJCgwIB/hSENCyAGIAUgDXqnQQN2QWhsaiIBQRhrNgIIIAYgAUEMazYCDCAGQQhqIQkgBkEMaiEKIwBBMGsiASQAAn8jAEEwayICJABBASELAkAgAC0ABA0AAkACQCAALQAGRQRAIAAtAAUhDCAAKAIAIgMtAApBgAFxRQRAIAxBAXFFDQIgAygCAEHP8YkBQQIgAygCBCgCDBEGAEUNAgwECyAMQQFxRQRAIAMoAgBB3fGJAUEBIAMoAgQoAgwRBgANBAsgAEEBOgAHIAIgAEEHajYCLCACQbDxiQE2AhAgAiADKQIANwIkIAIgAykCCDcCFCACIAJBJGo2AgwgCSACQQxqQYzehwEoAgARAgANAyACKAIMQZzxiQFBAiACKAIQKAIMEQYADQMMAgsgAkEANgIcIAJBATYCECACQajyiQE2AgwgAkIENwIUIAJBDGpBsPKJARDvLAALIAkgA0GM3ocBKAIAEQIADQEgAygCAEGc8YkBQQIgAygCBCgCDBEGAA0BCyAAQQE6AAZBACELCyAAIAs6AAQgAkEwaiQAQQEgAC0ABA0AGgJAAkACQCAALQAGBEAgACgCACICLQAKQYABcUUEQEEBIAogAkGM3ocBKAIAEQIADQUaDAQLIAEgAEEHajYCLCABQbDxiQE2AhAgASACKQIANwIkIAEgAikCCDcCFCABIAFBJGo2AgwgCiABQQxqQYzehwEoAgARAgBFDQEMAgsgAUEANgIcIAFBATYCECABQfDyiQE2AgwgAUIENwIUIAFBDGpB+PKJARDvLAALIAEoAgxB1PGJAUECIAEoAhAoAgwRBgBFDQELQQEMAQsgAEEAOgAGQQALIQIgAEEBOgAFIAAgAjoABCABQTBqJAAgDUIBfSANgyENIAhBAWsiCA0ACwsgBkEQaiQAIwBBIGsiASQAQQEhBQJAIAAtAARFBEAgAC0ABg0BIAAoAgAiAigCAEHW8YkBQQEgAigCBCgCDBEGACEFCyAAIAU6AAQgAUEgaiQAIAUMAQsgAUEANgIYIAFBATYCDCABQbjziQE2AgggAUIENwIQIAFBCGpBwPOJARDvLAALIARBMGokAAsMACAAKAIAIAEQzBkLYQECfyAAKAIAIQMjAEEgayIAJAAgAEEMaiICIAFBAUEAEMYsIAAgAzYCGCAAIANBBGo2AhwgAiAAQRhqQajghwEQ5BQaIAIgAEEcakG44IcBEOQUGiACENsbIABBIGokAAsOACABQZThhwFBCxD7NQsMACAAKAIAIAEQ9wYLDAAgACgCACABEMEYCwwAIAAoAgAgARCeJQsMACAAKAIAIAEQzCQLDAAgACgCACABEMUVCw4AIABB/OyHASABEMsKCw4AIAFB/O2HAUEFEPs1CwwAIAAoAgAgARCBDQsOACABQdv0hwFBCxD7NQsMACAAIAEpAgg3AwALDAAgACgCACABEJo8Cw4AIAFB6PqHAUELEPs1Cw4AIAFB3PyHAUELEPs1CwoAIAAoAgBBEGoLCwAgACABIAIQ/RQLDgAgAUHo/4cBQQsQ+zULDgAgAUGzhYgBQQsQ+zULlAEBAn8CQCMAQRBrIgEkACABQQRqIANBAEEBQQEQoBggASgCCCEEIAEoAgRBAUcEQCABKAIMIQUgAwRAIAUgAiAD/AoAAAsgACAENgIIIAAgAzYCBCAAIAU2AgAgAEEHQSAgBEEKdmdrIgAgAEEHTxtBAnRBAXI2AgwgAUEQaiQADAELIAQgASgCDEGUiIgBEP0vAAsLCwAgACgCACUBEBoLGgEBbyAAKAIAJQEQGyEBEN8SIgAgASYBIAALGgEBbyAAKAIAJQEQHyEBEN8SIgAgASYBIAALDQAgACgCACUBIAEQLwsXAQFvIAAgARBOIQIQ3xIiACACJgEgAAsaAQFvIAAoAgAlARBaIQEQ3xIiACABJgEgAAsXAQFvIAAgARBcIQIQ3xIiACACJgEgAAsKACAAKAIAEJw+CwkAIAAgARB0AAsNAEHTrYgBQRsQlz0ACw4AQe6tiAFBzwAQlz0ACw4AIABB0MWIASABEMsKCw4AIABBpKWJASABEMsKCw4AIABBsKiJASABEMsKCw4AIABB4KiJASABEMsKCw4AIABByKiJASABEMsKCw4AIAFBnMCJAUECENYJCw4AIABB9MCJASABEMsKCw4AIAFB5MCJAUEFEPs1Cw4AIAFB6cCJAUELEPs1CxoAIAAgAUGA8IoBKAIAIgBB8x0gABsRAAAACw4AIAFBtOyJAUEvENYJCw4AIAFByO2JAUEgENYJCw4AIAFB6O2JAUEYENYJCw4AIABBsPGJASABEMsKCw4AIABB/PWJASABEMsKCwsAIAIgACABENYJCwwAIAAoAgAgARDTEAsJACAAQQA2AgALCQAgAEIANwIACw4AIAFBxqeJAUEFEPs1CwkAIAAgARDoEwsJACAAIAEQ8xULCQAgACABEL8uCwcAQQEgAHQLCgAgAEGAgIB4cgsOACABQbyliQFBCBD7NQsJACAAIAEQ3RsLCQAgACABEPg9CwgAIAAoAhhFCwcAIABBDGoLCAAgACgCMEULCQAgACABEPE9CwkAIAAgARDwPQsJACAAIAEQhj4LCQAgACABEO89CwkAIAAgARD+PQsJACAAIAEQ+T0LCAAgAEGgA2oLCAAgAEGYA2oLCQAgACABEPc9CwkAIAAgARD8PQsIACAAKAIARQsJACAAIAEQmi8LCQAgACABEPY9CwkAIAAgARCCPgsHACAAQTRqCwgAIABB0AJqCwoAIAAoAgAQyjwLCgAgACgCABDLPAsKACAAKAIAEMk8CwoAIAAoAgAoAiALCQAgAEEINgIACwkAIAAgARCEPgsJACAAIAEQ8j0LCQAgACABEK4aCwkAIAAgARCpIAsIACAAQYh/SwuYBgIIfgN/QsXP2bLx5brqJyECIAEiCkEgTwRAIAAgAWpBH2shAUL56tDQ58mh5OEAIQJC1uuC7ur9ifXgACEEQs/W077Sx6vZQiEFA0AgACkAAELP1tO+0ser2UJ+IAR8Qh+JIgZCh5Wvr5i23puef34hBCAAQRhqKQAAQs/W077Sx6vZQn4gAnxCH4kiB0KHla+vmLbem55/fiECIABBEGopAABCz9bTvtLHq9lCfiADfEIfiSIIQoeVr6+Ytt6bnn9+IQMgAEEIaikAAELP1tO+0ser2UJ+IAV8Qh+JIglCh5Wvr5i23puef34hBSAAQSBqIgAgAUkNAAsgBUIHiSAEQgGJfCADQgyJfCACQhKJfCAGQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAlCqdnl+5Dg1vlefkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gCEKp2eX7kODW+V5+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAHQqnZ5fuQ4Nb5Xn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQILIApBGHEhDCAKQR9xIQEgAiAKrXwhAiAAIQsDQCABQQhPBEAgAUEIayEBIAspAABCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiAChUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSECIAtBCGohCwwBCwsgACAMaiEBIApBB3EiAEEETwRAIABBBGshACABNQAAQoeVr6+Ytt6bnn9+IAKFQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGohAQsDQCAABEAgAEEBayEAIAExAABCxc/ZsvHluuonfiAChUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwsgAkIhiCAChULP1tO+0ser2UJ+IgJCHYggAoVC+fPd8Zn2masWfiICQiCIIAKFCwgAIABB/wFxCwkAIAAgARCIPgsJACAAIAEQ9T0LCQAgACABEPM9CwkAIAAgARD7PQsJACAAIAEQ/z0LCQAgACABEIM+CwkAIAAgARCFPgsJACAAIAEQ7j0LCQAgACABEPQ9CwoAIAAoAgAQ1DoLCgAgACgCABDTOgsJACAAIAEQgT4LCQAgACABEP09CwkAIAAgARD6PQsJACAAIAEQ1QkLCgAgACgCABD4LQsKACAAKAIAEPotCwoAIAAoAgAQ+S0LCgAgACgCABD8LQsKACAAKAIAEPstCwoAIAAoAgAQ9C0LCgAgACgCABD3LQsKACAAKAIAEPYtCwoAIAAoAgAQ9S0LCgAgACgCABDzLQsJACAAIAEQmRQLCQAgACABEOQVCwkAIAAgARCaFQsJACAAIAEQmxULCQAgACABEOsPCwkAIAAgARDjFQsJACAAIAEQmBQLCQAgACABEOIVCwkAIAAgARD2EQsJACAAIAEQvRULCQAgACABEO8XCwkAIAAgARCcFQsJACAAIAEQ+gwLCQAgACABEOAVCwkAIAAgARCtFgsJACAAIAEQ/AwLCQAgACABEJ0VCwkAIAAgARDoEgsJACAAIAEQ4Q4LCQAgACABEPsMCwkAIAAgARCDEwsJACAAIAEQ5xILCQAgACABEOwPCwkAIAAgARDhFQsJACAAIAEQnhULCQAgACABEOAOCwkAIAAgARDtDQsIACAAKAIURQsIACAAKAIgRQsIACAAKAIQRQsKACAAKAIAKAIwC70FAQl/IwBB0ABrIgIkACABQRhqIQMCQAJAAkACQAJAIAAtABgiBEEhRwRAIARBJ0YNAQwCCyADLQAAQSFHDQFBACEDIAAoAhxBCGogACgCICABKAIcQQhqIAEoAiAQnTtFDQQgAC0AGSABLQAZRg0CDAQLIAMtAABBJ0cNAAJAAkACQAJAAkAgACgCHCIDLQAwQSBHDQAgASgCHCIELQAwQSBHDQAgAkEwaiADQTRqIgMQwzQgAigCNEECRw0AIAJBKGogBEE0aiIFEMM0IAIoAixBAkcNACACQSBqIAMQwzQgAigCJEUNASACKAIgIQYgAkEYaiAFEMM0IAIoAhxFDQIgAigCGCEHIAJBEGogAxDDNCACKAIUIgNBAU0NAyACKAIQIQQgAkEIaiAFEMM0IAIoAgwiA0EBTQ0EIAIoAgghBUEBIQhBASEJIAYoAgBBMGogBygCAEEwahDLCARAIAQoAgRBMGogBSgCBEEwahDLCEEBcyEJCyAHKAIAIgNBCGohByAGKAIAIgZBCGogBi0ASCADLQBIRgRAIAQoAgQtAEggBSgCBC0ASEchCAtBACEDIAcQ5QxFDQggBCgCBEEIaiAFKAIEQQhqEOUMRSAIIAlycg0IIAAtABkgAS0AGUcNCAwGCyACQQA2AkggAkEBNgI8IAJBhMKHATYCOCACQgQ3AkAgAkE4akGMwocBEO8sAAtBAEEAQZDBhwEQwyEAC0EAQQBBoMGHARDDIQALQQEgA0GwwYcBEMMhAAtBASADQcDBhwEQwyEACyAAQRhqIAMQywhFDQELIAAoAiQiBCABKAIkRw0AQQAhAyAAKAJAQQAgACgCLBsgASgCQEEAIAEoAiwbRw0BIAAgAUEAQQAgBBD1BkUNASAAIAFBAEEAIAQQ3gchAwwBC0EAIQMLIAJB0ABqJAAgAwsIACAAKAIERQsKACAAKAIAEJQtCwoAIAAoAgAQwywLCwAgACgCACUBECULCwAgACgCACUBECwLCQAgACABEJI1CxcBAW8gACABEGghAhDfEiIAIAImASAACwkAIAEgABCHLgsHACAAIAFrC8wDAQJ/An8jAEEgayICJAACQAJAAkACQAJAAkAgAC0AAEEBaw4DAQIDAAsgAiAAKAIENgIEIAJBCGoiACABQcWxiQFBAhCWLSAAQdixiQFBBCACQQRqQcixiQEQiBIgAkEpOgATQeyxiQFBBCACQRNqQdyxiQEQiBJBFEEBEK02IgBFDQQgAEEQakH0uokBKAAANgAAIABBCGpB7LqJASkAADcAACAAQeS6iQEpAAA3AAAgAkEUNgIcIAIgADYCGCACQRQ2AhRBgLKJAUEHIAJBFGpB8LGJARCIEhDEISEAIAIoAhQiAUUNAyACKAIYIAFBARD4OgwDCyACIAAtAAE6AAggAkEUaiIAIAFBh7KJAUEEEMYsIAAgAkEIakHcsYkBEOQUENsbIQAMAgsgACgCBCEAIAJBFGoiAyABQYuyiQFBBRCWLSADQeyxiQFBBCAAQQhqQdyxiQEQiBJBgLKJAUEHIABBkLKJARCIEhDEISEADAELIAIgACgCBCIANgIUIAFBsLKJAUEGQeyxiQFBBCAAQQhqQdyxiQFBtrKJAUEFIAJBFGpBoLKJARCOGCEACyACQSBqJAAgAAwBC0EBQRRB+KiJARD9LwALCwcAIAAgAWoLBwAgAEEIagsHACAAQQhrC04BAX8jAEEwayIBJAAgAUEBNgIMIAFBwO2JATYCCCABQgE3AhQgASABQS9qrUKAgICAsOMDhDcDICABIAFBIGo2AhAgAUEIaiAAEO8sAAsIACAAJQEQVwsHACAAKAIYCwcAIAAoAjALBwAgABCVDAsHACAAKAIACwcAIAAQgS8LRgEBfyAAKAIgIgEEQCAAQSxqIAAoAiQgACgCKCABKAIQEQEACyAAKAIAIgEEQCAAQQxqIAAoAgQgACgCCCABKAIQEQEACwsHACAAEJEqCwcAIAAoAkwLBwAgACgCQAsHACAAKAJQCwcAIAAoAjgLBwAgACgCCAsHACAAELwqCwcAIAAoAhQLBwAgACgCIAsHACAAKAIcCwcAIAAoAhALBwAgACgCDAsVAgFvAX8QQyEAEN8SIgEgACYBIAELAgALBAAgAAsEAEEACwcAQZy8zQALBwBByLzNAAsEAEEICwQAQQILBABBBAsEAEEFCwQAQQYLBABBBwsEAEEACwcAQbzJ/wALBwBBxPv/AAsHAEHY/YEBCwcAQdTJggELBwBBjIODAQsEAEIACwcAQfiOhAELBwBB5JaEAQsEAEEACwQAQQELBwBB0O+FAQsHAEGkqYYBCwIACwIACwIACwIACwIACwvhtEacKgBBgIDAAAuByQJpbnZhbGlkIGxpdGVyYWwvbGVuZ3RocyBzZXQAaW52YWxpZCBjb2RlIGxlbmd0aHMgc2V0AHVua25vd24gaGVhZGVyIGZsYWdzIHNldABpbnZhbGlkIGRpc3RhbmNlcyBzZXQAaW52YWxpZCBiaXQgbGVuZ3RoIHJlcGVhdAAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL21hcC9lbnRyeS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV9hcnJheV9kaWN0aW9uYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2VxdWFsL2RpY3Rpb25hcnkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9kaWN0aW9uYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9maXhlZF9iaW5hcnkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvZml4ZWRfYmluYXJ5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29udGV4dF9tYXBfZW50cm9weS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvZW1wdHlfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2RpY3Rpb25hcnlfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2ZpeGVkX3NpemVfYmluYXJ5X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9saXN0X3ZpZXdfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2J5dGVfdmlld19hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV92aWV3X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9maXhlZF9zaXplX2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL2xpc3RfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2FycmF5L3N0cnVjdF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvc3RydWN0X2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS9tYXBfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL21hcF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvcnVuX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9hcnJheS91bmlvbl9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvYm9vbGVhbl9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvbnVsbF9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvcHJpbWl0aXZlX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9wcmltaXRpdmVfYXJyYXkucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL2ZpeGVkX2xlbl9ieXRlX2FycmF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2RlY29kZXIvZGVsdGFfYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd193cml0ZXIvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJheV9yZWFkZXIvYnl0ZV9hcnJheS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9kaXNwbGF5LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL2dlbmVyYWxfcHVycG9zZS9kZWNvZGVfc3VmZml4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9jb21wbGV4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2RlY29kZXIvZGljdGlvbmFyeV9pbmRleC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9maWxlL3BhZ2VfaW5kZXgvb2Zmc2V0X2luZGV4LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvcGFnZV9pbmRleC9pbmRleC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc2xpY2UvaW5kZXgucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9ib3Jyb3cucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9zbG93LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbGV4aWNhbC1wYXJzZS1mbG9hdC0xLjAuNi9zcmMvc2xvdy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2luZmxhdGUvd2luZG93LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS93aW5kb3cucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvYnl0ZV92aWV3LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYmlnaW50L2Rpdi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL3N0cmF0ZWd5L2dyaXN1LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9ieXRlc19tdXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J1Zi9idWZfbXV0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdXJsLTIuNS43L3NyYy9ob3N0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvYml0X2Nvc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9saXRlcmFsX2Nvc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL2ZpeGVkX3NpemVfbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9maXhlZF9saXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctY2FzdC01Ni4yLjAvc3JjL2Nhc3QvbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vbGlzdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9saXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy93YXNtL3JlcXVlc3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9mYXN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9jYXN0LnJzAGxpYnJhcnkvY29yZS9zcmMvc2xpY2Uvc29ydC9zaGFyZWQvc21hbGxzb3J0LnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9zbGljZS9zb3J0L3Vuc3RhYmxlL3F1aWNrc29ydC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc2xpY2Uvc29ydC9zdGFibGUvcXVpY2tzb3J0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvc3RyZWFtL2Z1dHVyZXNfdW5vcmRlcmVkL2Fib3J0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9jb252ZXJ0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlnaW50L2NvbnZlcnQucnMAbGlicmFyeS9hbGxvYy9zcmMvYm94ZWQvY29udmVydC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWlwYy01Ni4yLjAvc3JjL2NvbnZlcnQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLWNoYW5uZWwtMC4zLjMxL3NyYy9vbmVzaG90LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ludGVnZXItZW5jb2RpbmctMy4wLjQvc3JjL3ZhcmludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2xleGljYWwtcGFyc2UtZmxvYXQtMS4wLjYvc3JjL2JpZ2ludC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2NvbXByZXNzX2ZyYWdtZW50LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy93YXNtL2NsaWVudC5ycwBsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvdGhyaWZ0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9zaGlmdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ2ludC9zaGlmdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL2J1ZmZlci9vZmZzZXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9pcl9pbnRlcnByZXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9zdGF0aWNfZGljdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Z1dHVyZXMtdXRpbC0wLjMuMzEvc3JjL3N0cmVhbS90cnlfc3RyZWFtL3RyeV9jb2xsZWN0LnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL2luX3BsYWNlX2NvbGxlY3QucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0ZXIvdHJhaXRzL2NvbGxlY3QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi90aHJpZnQtMC4xNy4wL3NyYy9wcm90b2NvbC9jb21wYWN0LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29tcGF0LnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2RpeV9mbG9hdC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9mb3JtYXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9jb25jYXQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9udW0taW50ZWdlci0wLjEuNDYvc3JjL3Jvb3RzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY29uc3RhbnRzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbHo0X2ZsZXgtMC4xMS41L3NyYy9mcmFtZS9kZWNvbXByZXNzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc25hcC0xLjEuMS9zcmMvZGVjb21wcmVzcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvYmxvY2svY29tcHJlc3MucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9zbmFwLTEuMS4xL3NyYy9jb21wcmVzcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2NvbXByZXNzX2ZyYWdtZW50X3R3b19wYXNzLnJzAGxpYnJhcnkvY29yZS9zcmMvZm10L2J1aWxkZXJzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL29wcy5ycwBzcmMvcmVhZF9vcHRpb25zLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9zdGQvc3JjL2lvL2ltcGxzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfY29yZS0xLjAuMjI4L3NyYy9kZS9pbXBscy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vdXRpbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvdXRpbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvcmVjb3JkX3JlYWRlci9kZWZpbml0aW9uX2xldmVscy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvbGV2ZWxzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2Fycm93X3dyaXRlci9sZXZlbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9uYWl2ZS9pbnRlcm5hbHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy9wcmltaXRpdmVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc25hcC0xLjEuMS9zcmMvYnl0ZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J5dGVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnl0ZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL3R5cGVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL3NjaGVtYS90eXBlcy5ycwBzcmMvd3JpdGVyX3Byb3BlcnRpZXMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9wcm9wZXJ0aWVzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvaW5mbGF0ZS9pbmZ0cmVlcy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIuMTA0L3NyYy9jb252ZXJ0L3NsaWNlcy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvY2hhci9tZXRob2RzLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2NoZW1hLTU2LjIuMC9zcmMvZmllbGRzLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9zdGQvc3JjL3N5cy9zeW5jL211dGV4L25vX3RocmVhZHMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9zdGF0aXN0aWNzLnJzAGxpYnJhcnkvYWxsb2Mvc3JjL2ZmaS9jX3N0ci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N0ci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvcHRyL2NvbnN0X3B0ci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRidWZmZXJzLTI1LjkuMjMvc3JjL3ZlY3Rvci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL3V0aWwvYml0X2l0ZXJhdG9yLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvdXRpbC9iaXRfY2h1bmtfaXRlcmF0b3IucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0ZXIvdHJhaXRzL2l0ZXJhdG9yLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfanNvbi0xLjAuMTQ1L3NyYy9lcnJvci5ycwBsaWJyYXJ5L2NvcmUvc3JjL3NsaWNlL21lbWNoci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2Jsb2NrX3NwbGl0dGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvY2x1c3Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNlbGVjdC01Ni4yLjAvc3JjL2ZpbHRlci5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9pby9idWZmZXJlZC9idWZ3cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy92dGFibGVfd3JpdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvenN0ZC0wLjEzLjAvc3JjL3N0cmVhbS96aW8vd3JpdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvaW5mbGF0ZS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbnRlZ2VyLWVuY29kaW5nLTMuMC40L3NyYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1pcGMtNTYuMi4wL3NyYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy93cml0ZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZmlsZS9tZXRhZGF0YS93cml0ZXIucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL3NsaWNlL2l0ZXIucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9ib3hlZC9pdGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdXJsLTIuNS43L3NyYy9wYXJzZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLWNvcmUtMC4zLjMxL3NyYy90YXNrL19faW50ZXJuYWwvYXRvbWljX3dha2VyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGJ1ZmZlcnMtMjUuOS4yMy9zcmMvdmVyaWZpZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYnVmZmVyL2RpY3Rpb25hcnlfYnVmZmVyLnJzAGxpYnJhcnkvY29yZS9zcmMvbmV0L2Rpc3BsYXlfYnVmZmVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2J1ZmZlci92aWV3X2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9idWZmZXIvb2Zmc2V0X2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9yZWNvcmRfcmVhZGVyL2J1ZmZlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZW5jb2RpbmcvYnl0ZV9zdHJlYW1fc3BsaXRfZW5jb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZW5jb2RpbmcvZGljdF9lbmNvZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2NvbHVtbi93cml0ZXIvZW5jb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZGVjb2RpbmcvYnl0ZV9zdHJlYW1fc3BsaXRfZGVjb2Rlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vcmVhZGVyL2RlY29kZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZml4ZWRfc2l6ZV9iaW5hcnlfZGljdGlvbmFyeV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL2dlbmVyaWNfYnl0ZXNfZGljdGlvbmFyeV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL2ZpeGVkX3NpemVfYmluYXJ5X2J1aWxkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZ2VuZXJpY19ieXRlc192aWV3X2J1aWxkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1hcnJheS01Ni4yLjAvc3JjL2J1aWxkZXIvZ2VuZXJpY19ieXRlc19idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9idWlsZGVyL3ByaW1pdGl2ZV9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9idWlsZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGJ1ZmZlcnMtMjUuOS4yMy9zcmMvYnVpbGRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvYnVmcmVhZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2FycmF5X3JlYWRlci9jYWNoZWRfYXJyYXlfcmVhZGVyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvc2VyaWFsaXplZF9yZWFkZXIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvY29sdW1uL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ludGVnZXItZW5jb2RpbmctMy4wLjQvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWlwYy01Ni4yLjAvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS1kZWNvbXByZXNzb3ItNS4wLjAvc3JjL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9maWxlL21ldGFkYXRhL3JlYWRlci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvZnJhbWUvaGVhZGVyLnJzAGxpYnJhcnkvY29yZS9zcmMvbmV0L2lwX2FkZHIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy9lbmRpYW5fc2NhbGFyLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL3NjYWxhci5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2JhY2t3YXJkX3JlZmVyZW5jZXMvaHEucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9odHRwLTEuMy4xL3NyYy9oZWFkZXIvbWFwLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvZnV0dXJlL2Z1dHVyZS9tYXAucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0ZTItMS4xLjIvc3JjL3ppby5ycwBsaWJyYXJ5L3N0ZC9zcmMvaW8vc3RkaW8ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWZmZXIvcnVuLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9ydW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvcnVuLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9zdHIvcGF0dGVybi5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvb3B0aW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9hZGRpdGlvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvc2VsZWN0aW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbnVtLWJpZ2ludC0wLjQuNi9zcmMvYmlndWludC9zdWJ0cmFjdGlvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ3VpbnQvbXVsdGlwbGljYXRpb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvY29tcHJlc3Npb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1pcGMtNTYuMi4wL3NyYy9jb21wcmVzc2lvbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL251bS1iaWdpbnQtMC40LjYvc3JjL2JpZ3VpbnQvZGl2aXNpb24ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL3VuaW9uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2VxdWFsL3VuaW9uLnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvc3RyYXRlZ3kvZHJhZ29uLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy90cnVzdGVkX2xlbi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvcmVhZF9wbGFuLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWlsZGVyL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL2Jvb2xlYW4ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvYm9vbGVhbi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9iaWdudW0ucnMAbGlicmFyeS9jb3JlL3NyYy9mbXQvbnVtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS9hbGdvcml0aG0vbWVkaXVtLnJzAHNyYy93YXNtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLWRlY29tcHJlc3Nvci01LjAuMC9zcmMvdHJhbnNmb3JtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvenN0ZC1zeXMtMi4wLjkrenN0ZC4xLjUuNS9zcmMvd2FzbV9zaGltLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGUyLTEuMS4yL3NyYy9tZW0ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9oaXN0b2dyYW0ucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9icm90bGlfYml0X3N0cmVhbS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JhbmdlLXJlYWRlci0wLjIuMC9zcmMvc3RyZWFtLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVxd2VzdC0wLjEyLjIzL3NyYy9pbnRvX3VybC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL2J1ZmZlci9udWxsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVpbGRlci9udWxsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvdG9raW8tMS40Ny4xL3NyYy9pby91dGlsL3dyaXRlX2FsbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9idWZmZXIvYml0X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvdXRpbC9iaXRfdXRpbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWJ1ZmZlci01Ni4yLjAvc3JjL3V0aWwvYml0X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy91dGY4X3V0aWwucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9vYmplY3Rfc3RvcmUtMC4xMi40L3NyYy91dGlsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvcHJpb3JfZXZhbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL3N0cmlkZV9ldmFsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbGV4aWNhbC1wYXJzZS1mbG9hdC0xLjAuNi9zcmMvdGFibGVfZGVjaW1hbC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9jYXN0L2RlY2ltYWwucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvdXRpbC9iaXRfbWFzay5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvd3JpdGFibGUvaW50b191bmRlcmx5aW5nX3NpbmsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sejRfZmxleC0wLjExLjUvc3JjL3NpbmsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLXV0aWwtMC4zLjMxL3NyYy9zdHJlYW0vc3RyZWFtL3BlZWsucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9tZXRhYmxvY2sucnMAbGlicmFyeS9zdGQvc3JjL3N5bmMvcmVlbnRyYW50X2xvY2sucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9xdWljay5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy91dGlsL2JpdF9wYWNrLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL2ZmaS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNjaGVtYS01Ni4yLjAvc3JjL2ZmaS5ycwBzcmMvY29tbW9uL2ZldGNoLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS9sb25nZXN0X21hdGNoLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy9yZWNvcmRfYmF0Y2gucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9mb3JtYXQvZm9ybWF0dGluZy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9jYXN0L3N0cmluZy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9lbmNvZGluZ3MvZGVjb2RpbmcucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL3BlbmRpbmcucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL3N5bV9idWYucnMAL1VzZXJzL2t5bGUvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS1hYXJjaDY0LWFwcGxlLWRhcndpbi9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2lvL2JvcnJvd2VkX2J1Zi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vcmVhZF9idWYucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9odWZmLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDQvc3JjL2V4dGVybnJlZi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy90cmFuc2Zvcm0vdmFyaWFibGVfc2l6ZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC92YXJpYWJsZV9zaXplLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctZGF0YS01Ni4yLjAvc3JjL3RyYW5zZm9ybS9wcmltaXRpdmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZXF1YWwvcHJpbWl0aXZlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9wcmltaXRpdmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1zZWxlY3QtNTYuMi4wL3NyYy9pbnRlcmxlYXZlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLWZ1dHVyZXMtMC40LjU0L3NyYy9xdWV1ZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvZ3ovd3JpdGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9pbmZsYXRlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvZGVmbGF0ZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL25hdmlnYXRlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvYWxsb2NhdGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sZXhpY2FsLXBhcnNlLWZsb2F0LTEuMC42L3NyYy9wYXJzZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWNhc3QtNTYuMi4wL3NyYy9wYXJzZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JlcXdlc3QtMC4xMi4yMy9zcmMvd2FzbS9yZXNwb25zZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9zdHJ1Y3R1cmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sZXhpY2FsLXBhcnNlLWZsb2F0LTEuMC42L3NyYy9sZW1pcmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZGF0YV90eXBlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYXJyYXktNTYuMi4wL3NyYy90aW1lem9uZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvY2xvbmUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jcmMzMmZhc3QtMS41LjAvc3JjL2Jhc2VsaW5lLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvY2hyb25vLTAuNC40Mi9zcmMvZm9ybWF0L3N0cmZ0aW1lLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2VuY29kaW5ncy9ybGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2FsZ29yaXRobS9ybGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0YnVmZmVycy0yNS45LjIzL3NyYy92dGFibGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1idWZmZXItNTYuMi4wL3NyYy9idWZmZXIvaW1tdXRhYmxlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYnVmZmVyL211dGFibGUucnMAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvYmxvY2svaGFzaHRhYmxlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9naXQvY2hlY2tvdXRzL2Fycm93LXdhc20tMGM4M2Y1NmFlOWE5M2I4Ni82ZGE5NGVmL3NyYy90YWJsZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vdXRpbC90YWtlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2VsZWN0LTU2LjIuMC9zcmMvdGFrZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ljdV9jb2xsZWN0aW9ucy0yLjAuMC9zcmMvY29kZXBvaW50dHJpZS9jcHRyaWUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXJyYXlfcmVhZGVyL3Jvd19ncm91cF9jYWNoZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vcGFnZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2JhY2t3YXJkX3JlZmVyZW5jZXMvaGFzaF90b19iaW5hcnlfdHJlZS5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL25vZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pZG5hLTEuMS4wL3NyYy9wdW55Y29kZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jyb3RsaS04LjAuMi9zcmMvZW5jL2VudHJvcHlfZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLTguMC4yL3NyYy9lbmMvZW5jb2RlLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL2dlbmVyYWxfcHVycG9zZS9kZWNvZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktZGVjb21wcmVzc29yLTUuMC4wL3NyYy9kZWNvZGUucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9maW5kX3N0cmlkZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvcmVhZGFibGUvaW50b191bmRlcmx5aW5nX3NvdXJjZS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tc3RyZWFtcy0wLjQuMi9zcmMvcmVhZGFibGUvaW50b191bmRlcmx5aW5nX2J5dGVfc291cmNlLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAL3J1c3RjLzExNTllNzhjNDc0N2IwMmVmOTk2ZTU1MDgyYjcwNGMwOWI5NzA1ODgvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9pbnRlcmZhY2UucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mbGF0ZTItMS4xLjIvc3JjL2d6L21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWFycmF5LTU2LjIuMC9zcmMvYXJyYXkvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L21vZC5ycwAvcnVzdC9kZXBzL2hhc2hicm93bi0wLjE1LjQvc3JjL3Jhdy9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9oYXNoYnJvd24tMC4xNi4wL3NyYy9yYXcvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctY2FzdC01Ni4yLjAvc3JjL2Nhc3QvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctYnVmZmVyLTU2LjIuMC9zcmMvYmlnaW50L21vZC5ycwBsaWJyYXJ5L2NvcmUvc3JjL2ZtdC9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9iYWNrd2FyZF9yZWZlcmVuY2VzL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvc3RyL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvcHRyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9ibG9vbV9maWx0ZXIvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L2Fycm93X3dyaXRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXN5bmNfd3JpdGVyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9jb2x1bW4vd3JpdGVyL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9hcnJvdy9hcnJvd19yZWFkZXIvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnJvdGxpLWRlY29tcHJlc3Nvci01LjAuMC9zcmMvYml0X3JlYWRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvcmVjb3JkX3JlYWRlci9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvYXJyb3cvYXN5bmNfcmVhZGVyL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2JpbmFyeV9oZWFwL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9pby9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktZGVjb21wcmVzc29yLTUuMC4wL3NyYy9odWZmbWFuL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvbnVtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JlcXdlc3QtMC4xMi4yMy9zcmMvd2FzbS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvdHJhbnNmb3JtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvYWxnb3JpdGhtL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3RocmlmdC0wLjE3LjAvc3JjL3Byb3RvY29sL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LWRhdGEtNTYuMi4wL3NyYy9lcXVhbC9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wYXJxdWV0LTU2LjIuMC9zcmMvZW5jb2RpbmdzL2VuY29kaW5nL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL3ZlY19kZXF1ZS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy9uYWl2ZS9kYXRlL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Jhc2U2NC0wLjIyLjEvc3JjL2VuZ2luZS9nZW5lcmFsX3B1cnBvc2UvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmFzZTY0LTAuMjIuMS9zcmMvZW5naW5lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Nocm9uby0wLjQuNDIvc3JjL25haXZlL2RhdGV0aW1lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Nocm9uby0wLjQuNDIvc3JjL2RhdGV0aW1lL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2x6NF9mbGV4LTAuMTEuNS9zcmMvZnJhbWUvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZnV0dXJlcy11dGlsLTAuMy4zMS9zcmMvc3RyZWFtL2Z1dHVyZXNfdW5vcmRlcmVkL21vZC5ycwBsaWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL21vZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3plcm92ZWMtMC4xMS40L3NyYy96ZXJvdmVjL21vZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAC9ydXN0Yy8xMTU5ZTc4YzQ3NDdiMDJlZjk5NmU1NTA4MmI3MDRjMDliOTcwNTg4L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL21vZC5ycwAvcnVzdGMvMTE1OWU3OGM0NzQ3YjAyZWY5OTZlNTUwODJiNzA0YzA5Yjk3MDU4OC9saWJyYXJ5L2FsbG9jL3NyYy92ZWMvbW9kLnJzAGxpYnJhcnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2ZpbGUvbWV0YWRhdGEvbW9kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcGFycXVldC01Ni4yLjAvc3JjL2Fycm93L3NjaGVtYS9tb2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9odHRwLTEuMy4xL3NyYy9tZXRob2QucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi90b2tpby0xLjQ3LjEvc3JjL2lvL3V0aWwvcmVhZF90b19lbmQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9icm90bGktOC4wLjIvc3JjL2VuYy9jb21tYW5kLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYXJyb3ctc2NoZW1hLTU2LjIuMC9zcmMvZmllbGQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9jcmMzMi9icmFpZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3Rva2lvLTEuNDcuMS9zcmMvaW8vdXRpbC92ZWNfd2l0aF9pbml0aWFsaXplZC5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL2JveGVkLnJzAC9Vc2Vycy9reWxlLy5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUtYWFyY2g2NC1hcHBsZS1kYXJ3aW4vbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVyX25lc3RlZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvYWxnb3JpdGhtL3N0b3JlZC5ycwAvVXNlcnMva3lsZS8uY2FyZ28vZ2l0L2NoZWNrb3V0cy9hcnJvdy13YXNtLTBjODNmNTZhZTlhOTNiODYvNmRhOTRlZi9zcmMvZmZpL2NodW5rZWQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9mdXR1cmVzLXV0aWwtMC4zLjMxL3NyYy9zaW5rL2ZlZWQucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJpbmRnZW4tZnV0dXJlcy0wLjQuNTQvc3JjL3Rhc2svc2luZ2xldGhyZWFkLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfanNvbi0xLjAuMTQ1L3NyYy9yZWFkLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmxhdGUyLTEuMS4yL3NyYy9jcmMucnMAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIuMTAvc3JjL2RsbWFsbG9jLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYWxsb2Mtc3RkbGliLTAuMi4yL3NyYy9oZWFwX2FsbG9jLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYWxsb2Mtc3RkbGliLTAuMi4yL3NyYy9zdGRfYWxsb2MucnMAbGlicmFyeS9zdGQvc3JjL2FsbG9jLnJzAHNyYy93cml0ZXJfYXN5bmMucnMAc3JjL3JlYWRlcl9hc3luYy5ycwAvVXNlcnMva3lsZS8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLWFhcmNoNjQtYXBwbGUtZGFyd2luL2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N5bmMucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9kZWZsYXRlL2hhc2hfY2FsYy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BhcnF1ZXQtNTYuMi4wL3NyYy9iYXNpYy5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZsYXRlMi0xLjEuMi9zcmMvZmZpL2MucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi91cmwtMi41Ljcvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLXdhc20tYmluZGdlbi0wLjYuNS9zcmMvbGliLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLWZ1dHVyZXMtMC40LjU0L3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9vbmNlX2NlbGwtMS4yMS4zL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wZXJjZW50LWVuY29kaW5nLTIuMy4yL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hc3luYy1jb21wYXQtMC4yLjIvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2pzLXN5cy0wLjMuODEvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NtYWxsdmVjLTEuMTUuMS9zcmMvbGliLnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96c3RkLXNhZmUtNy4wLjAvc3JjL2xpYi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ljdV9ub3JtYWxpemVyLTIuMC4wL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hdG9pLTIuMC4wL3NyYy9saWIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jaHJvbm8tMC40LjQyL3NyYy90aW1lX2RlbHRhLnJzAGxpYnJhcnkvY29yZS9zcmMvdW5pY29kZS91bmljb2RlX2RhdGEucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hcnJvdy1kYXRhLTU2LjIuMC9zcmMvZGF0YS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2Fycm93LXNjaGVtYS01Ni4yLjAvc3JjL3NjaGVtYS5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC41LjIvc3JjL2RlZmxhdGUvY29tcGFyZTI1Ni5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2lkbmEtMS4xLjAvc3JjL3V0czQ2LnJzAC9Vc2Vycy9reWxlLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjUuMi9zcmMvYWRsZXIzMi5ycwAvVXNlcnMva3lsZS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3R3b3gtaGFzaC0yLjEuMi9zcmMveHhoYXNoMzIucnMAL1VzZXJzL2t5bGUvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNS4yL3NyYy9jcmMzMi5ycwB0b28gbWFueSBsZW5ndGggb3IgZGlzdGFuY2Ugc3ltYm9scwBpbnZhbGlkIHN0b3JlZCBibG9jayBsZW5ndGhzAGJ1ZmZlciBlcnJvcgBzdHJlYW0gZXJyb3IAaW52YWxpZCBjb2RlIC0tIG1pc3NpbmcgZW5kLW9mLWJsb2NrAGluY29ycmVjdCBoZWFkZXIgY2hlY2sAaW5jb3JyZWN0IGxlbmd0aCBjaGVjawBpbmNvcnJlY3QgZGF0YSBjaGVjawBpbnZhbGlkIGRpc3RhbmNlIHRvbyBmYXIgYmFjawBoZWFkZXIgY3JjIG1pc21hdGNoAGludmFsaWQgd2luZG93IHNpemUAcmVwZWF0ZWQgY2FsbCB3aXRoIGJhZCBzdGF0ZQBpbnZhbGlkIGJsb2NrIHR5cGUAaW52YWxpZCBsaXRlcmFsL2xlbmd0aCBjb2RlAGludmFsaWQgZGlzdGFuY2UgY29kZQB1bmtub3duIGNvbXByZXNzaW9uIG1ldGhvZABFcnJvciBzdHJpbmdzIHN0cmlwcGVkADEuMy4wLXpsaWItcnMtMC41LjEAIAAAAABwixAAfgAAADQAAAAFAAAA1zIQAHgAAADrBwAACQAAANAjEABdAAAA+w4AAAoAAADEShAAagAAAG0IAAAfAAAA2ocQAGgAAABdAwAAEQAAAL99EABtAAAA8gMAABsAAAC/fRAAbQAAAPQDAAAkAAAAv30QAG0AAAACBAAAKAAAAM51EABqAAAApwEAAB8AAADOdRAAagAAAL0BAAAdAAAAHRAQAHMAAAAZAAAAEQAAAI0tEAAYAAAAggAAAC8AAACNLRAAGAAAAIIAAAA/AAAAWHhIYXNoSW50VHlwZWJpdFdpZHRoaXNTaWduZWRNYXBUeXBlQWVzR2NtVjFhYWRfcHJlZml4YWFkX2ZpbGVfdW5pcXVlc3VwcGx5X2FhZF9wcmVmaXhCc29uVHlwZURhdGVUeXBlRW51bVR5cGVKc29uVHlwZUtleVZhbHVla2V5dmFsdWVMaXN0VHlwZU51bGxUeXBlUm93R3JvdXBjb2x1bW5zdG90YWxfYnl0ZV9zaXplbnVtX3Jvd3Nzb3J0aW5nX2NvbHVtbnNmaWxlX29mZnNldHRvdGFsX2NvbXByZXNzZWRfc2l6ZW9yZGluYWxUaW1lVHlwZWlzQWRqdXN0ZWRUb1VUQ3VuaXRUaW1lVW5pdE1JTExJU01JQ1JPU05BTk9TVVVJRFR5cGVTdGF0aXN0aWNzbWF4bWlubnVsbF9jb3VudGRpc3RpbmN0X2NvdW50bWF4X3ZhbHVlbWluX3ZhbHVlaXNfbWF4X3ZhbHVlX2V4YWN0aXNfbWluX3ZhbHVlX2V4YWN0U3RyaW5nVHlwZUFlc0djbUN0clYxQm91bmRpbmdCb3h4bWlueG1heHltaW55bWF4em1pbnptYXhtbWlubW1heENvbHVtbkNodW5rZmlsZV9wYXRobWV0YV9kYXRhb2Zmc2V0X2luZGV4X29mZnNldG9mZnNldF9pbmRleF9sZW5ndGhjb2x1bW5faW5kZXhfb2Zmc2V0Y29sdW1uX2luZGV4X2xlbmd0aGNyeXB0b19tZXRhZGF0YWVuY3J5cHRlZF9jb2x1bW5fbWV0YWRhdGFDb2x1bW5JbmRleG51bGxfcGFnZXNtaW5fdmFsdWVzbWF4X3ZhbHVlc2JvdW5kYXJ5X29yZGVybnVsbF9jb3VudHNyZXBldGl0aW9uX2xldmVsX2hpc3RvZ3JhbXNkZWZpbml0aW9uX2xldmVsX2hpc3RvZ3JhbXNDb2x1bW5PcmRlclRZUEVfT1JERVJEZWNpbWFsVHlwZXNjYWxlcHJlY2lzaW9uRmxvYXQxNlR5cGVMb2dpY2FsVHlwZVNUUklOR01BUExJU1RFTlVNREVDSU1BTERBVEVUSU1FVElNRVNUQU1QSU5URUdFUlVOS05PV05KU09OQlNPTlVVSURGTE9BVDE2VkFSSUFOVEdFT01FVFJZR0VPR1JBUEhZTmFub1NlY29uZHNPZmZzZXRJbmRleHBhZ2VfbG9jYXRpb25zdW5lbmNvZGVkX2J5dGVfYXJyYXlfZGF0YV9ieXRlc1ZhcmlhbnRUeXBlc3BlY2lmaWNhdGlvbl92ZXJzaW9uRmlsZU1ldGFEYXRhdmVyc2lvbnNjaGVtYXJvd19ncm91cHNrZXlfdmFsdWVfbWV0YWRhdGFjcmVhdGVkX2J5Y29sdW1uX29yZGVyc2VuY3J5cHRpb25fYWxnb3JpdGhtZm9vdGVyX3NpZ25pbmdfa2V5X21ldGFkYXRhR2VvbWV0cnlUeXBlY3JzTWljcm9TZWNvbmRzTWlsbGlTZWNvbmRzUGFnZUxvY2F0aW9ub2Zmc2V0Y29tcHJlc3NlZF9wYWdlX3NpemVmaXJzdF9yb3dfaW5kZXhVbmNvbXByZXNzZWRHZW9ncmFwaHlUeXBlYWxnb3JpdGhtU2NoZW1hRWxlbWVudHR5cGV0eXBlX2xlbmd0aHJlcGV0aXRpb25fdHlwZW5hbWVudW1fY2hpbGRyZW5jb252ZXJ0ZWRfdHlwZWZpZWxkX2lkbG9naWNhbFR5cGVTb3J0aW5nQ29sdW1uY29sdW1uX2lkeGRlc2NlbmRpbmdudWxsc19maXJzdFRpbWVzdGFtcFR5cGVDb2x1bW5NZXRhRGF0YWVuY29kaW5nc3BhdGhfaW5fc2NoZW1hY29kZWNudW1fdmFsdWVzdG90YWxfdW5jb21wcmVzc2VkX3NpemVkYXRhX3BhZ2Vfb2Zmc2V0aW5kZXhfcGFnZV9vZmZzZXRkaWN0aW9uYXJ5X3BhZ2Vfb2Zmc2V0c3RhdGlzdGljc2VuY29kaW5nX3N0YXRzYmxvb21fZmlsdGVyX29mZnNldGJsb29tX2ZpbHRlcl9sZW5ndGhzaXplX3N0YXRpc3RpY3NnZW9zcGF0aWFsX3N0YXRpc3RpY3NTaXplU3RhdGlzdGljc3JlcGV0aXRpb25fbGV2ZWxfaGlzdG9ncmFtZGVmaW5pdGlvbl9sZXZlbF9oaXN0b2dyYW1CbG9vbUZpbHRlckhhc2hYWEhBU0hUeXBlRGVmaW5lZE9yZGVyQmxvb21GaWx0ZXJIZWFkZXJudW1CeXRlc2hhc2hjb21wcmVzc2lvblBhZ2VFbmNvZGluZ1N0YXRzcGFnZV90eXBlZW5jb2Rpbmdjb3VudEVuY3J5cHRpb25BbGdvcml0aG1BRVNfR0NNX1YxQUVTX0dDTV9DVFJfVjFTcGxpdEJsb2NrQWxnb3JpdGhtQmxvb21GaWx0ZXJBbGdvcml0aG1CTE9DS0NvbHVtbkNyeXB0b01ldGFEYXRhRU5DUllQVElPTl9XSVRIX0ZPT1RFUl9LRVlFTkNSWVBUSU9OX1dJVEhfQ09MVU1OX0tFWUdlb3NwYXRpYWxTdGF0aXN0aWNzYmJveGdlb3NwYXRpYWxfdHlwZXNCbG9vbUZpbHRlckNvbXByZXNzaW9uVU5DT01QUkVTU0VERW5jcnlwdGlvbldpdGhDb2x1bW5LZXlrZXlfbWV0YWRhdGFFbmNyeXB0aW9uV2l0aEZvb3RlcktleWFscmVhZHkgbG9ja2VkIHRvIGEgcmVhZGVyAAEAAAC4AwAACAAAAAIAAAADAAAAQAMAAAgAAAAEAAAABQAAAJABAAAIAAAABgAAAAcAAAAIBQAACAAAAAgAAAAJAAAAoAAAAAgAAAAKAAAACwAAAMAAAAAIAAAADAAAAA0AAADwAgAACAAAAA4AAAAPAAAAXAAAAAQAAAAQAAAAAAAAAAQAAAAEAAAAEQAAABIAAAAAAAAABAAAAAQAAAATAAAAFAAAAAAAAAAEAAAABAAAABUAAAAWAAAAAAAAAAQAAAAEAAAAFwAAABgAAAAAAAAABAAAAAQAAAAZAAAAGgAAAAAAAAAEAAAABAAAABsAAAAcAAAAx5EQAGcAAADmAAAAFQAAAB0AAAAMAAAABAAAAB4AAAAfAAAAIABBjMnCAAuRAgEAAAAhAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXkfPiLTS+rALQ+04qby6pveHprAvv5ieL98GMLX7yHypwAAAAAAAAAAAQAAACIAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAACMAAAAkAAAAGAAAAAgAAAAlAAAAJgAAAAQAAAAEAAAAJwBBqMvCAAvZEwEAAAAoAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAB0AAAAMAAAABAAAACkAAAAdAAAADAAAAAQAAAAqAAAAKQAAAHCqEAArAAAALAAAAC0AAAAuAAAALwAAAAAAAAAEAAAABAAAADAAAABHZW5lcmFsTllJRU9GQXJyb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZQAAAMRKEABqAAAAbQgAAB8AAAAAAAAABAAAAAQAAAA0AAAAVHJ5RnJvbUludEVycm9yQ2FuY2VsZWQAv30QAG0AAADJAAAAFwAAAJp7EABtAAAABQEAADoAAACaexAAbQAAANkAAABGAAAAmnsQAG0AAAD4AAAAPAAAAJp7EABtAAAAGQEAADAAAAAkAAAAGAAAAAgAAAA1AAAAJAAAABgAAAAIAAAAJQAAADUAAADEqxAANgAAADcAAAA4AAAAOQAAADoAAACeHhAAYwAAAL0AAAA5AAAAdXJsIHBhcnNlaGVhZGVycyB0cnlfaXRlcmhlYWRlcnMgaGF2ZSBhbiBpdGVyYXRvcmhlYWRlcnMgaXRlcmF0b3IgZG9lc24ndCB0aHJvd3NlcmlhbGl6ZWQgaGVhZGVyc2Rlc2VyaWFsaXphYmxlIHNlcmlhbGl6ZWQgaGVhZGVyc0pzVmFsdWUoInJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQiKQAA8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADOdRAAagAAAL0BAAAdAAAALF4QABMAAAAIAAAAUAAAACxeEAATAAAACwAAAB4AAAAsXhAAEwAAAAsAAAAyAAAALF4QABMAAAAOAAAATwAAACxeEAATAAAAFAAAAB8AAAAsXhAAEwAAABAAAAARAAAALF4QABMAAAARAAAAOQAAACxeEAATAAAAEgAAACEAAABujxAAEwAAAPYBAAAoAAAAbo8QABMAAADzAQAAQgAAAEZhaWxlZCB0byBjcmVhdGUgVHJhbnNmb3JtU3RyZWFtWo8QABMAAAAMAAAAOgAAAFqPEAATAAAAPQAAAB4AAABajxAAEwAAAB0AAAAVAAAAbnVsbCBmaXJzdCBiYXRjaG6PEAATAAAAYwAAAEMAAABujxAAEwAAAF8AAAABAAAAbo8QABMAAAB1AAAATgAAAG6PEAATAAAAlQAAAFMAAABujxAAEwAAAJ4AAAA8AAAAbo8QABMAAAC2AAAAQgAAAG6PEAATAAAA0wAAABEAAABMUhAACwAAAPQAAAA+AAAATFIQAAsAAADvAAAAAQAAAExSEAALAAAARQEAAD4AAABMUhAACwAAAEABAAABAAAAPQAAAJgAAAAIAAAAPgAAAD8AAAAwAAAABAAAAEAAAABBAAAAcAEAAAgAAABCAAAAQwAAAJgAAAAIAAAARAAAAEUAAABIAAAACAAAAEYAAABHAAAAiAEAAAgAAABIAAAASQAAACAAAAAIAAAASgAAAPFXEABgAAAAcgAAAAEAAABLAAAAsAMAAAgAAABMAAAATQAAACgAAAAIAAAATgAAAE8AAABIAAAACAAAAFAAAABRAAAADAAAAAQAAABSAAAAUwAAACAAQYzfwgAL6QEBAAAAVAAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAANcyEAB4AAAA6wcAAAkAAAAemsC+/mJ4v3wYwtfvIfKnAAAAAAAAAAABAAAAVQAAAFYAAAAQAAAABAAAAFcAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAFgAAAAEAAAABAAAACcAAABZAAAABAAAAAQAAABaAAAAWwAAABgAAAAIAAAAXABBgOHCAAutGAEAAABdAAAAXgAAAAwAAAAEAAAAXwAAAGFjY2VwdGFjY2VwdC1jaGFyc2V0YWNjZXB0LWVuY29kaW5nYWNjZXB0LWxhbmd1YWdlYWNjZXB0LXJhbmdlc2FjY2Vzcy1jb250cm9sLWFsbG93LWNyZWRlbnRpYWxzYWNjZXNzLWNvbnRyb2wtYWxsb3ctaGVhZGVyc2FjY2Vzcy1jb250cm9sLWFsbG93LW1ldGhvZHNhY2Nlc3MtY29udHJvbC1hbGxvdy1vcmlnaW5hY2Nlc3MtY29udHJvbC1leHBvc2UtaGVhZGVyc2FjY2Vzcy1jb250cm9sLW1heC1hZ2VhY2Nlc3MtY29udHJvbC1yZXF1ZXN0LWhlYWRlcnNhY2Nlc3MtY29udHJvbC1yZXF1ZXN0LW1ldGhvZGFnZWFsbG93YWx0LXN2Y2F1dGhvcml6YXRpb25jYWNoZS1jb250cm9sY2FjaGUtc3RhdHVzY2RuLWNhY2hlLWNvbnRyb2xjb25uZWN0aW9uY29udGVudC1kaXNwb3NpdGlvbmNvbnRlbnQtZW5jb2Rpbmdjb250ZW50LWxhbmd1YWdlY29udGVudC1sZW5ndGhjb250ZW50LWxvY2F0aW9uY29udGVudC1yYW5nZWNvbnRlbnQtc2VjdXJpdHktcG9saWN5Y29udGVudC1zZWN1cml0eS1wb2xpY3ktcmVwb3J0LW9ubHljb250ZW50LXR5cGVjb29raWVkbnRkYXRlZXRhZ2V4cGVjdGV4cGlyZXNmb3J3YXJkZWRmcm9taG9zdGlmLW1hdGNoaWYtbW9kaWZpZWQtc2luY2VpZi1ub25lLW1hdGNoaWYtcmFuZ2VpZi11bm1vZGlmaWVkLXNpbmNlbGFzdC1tb2RpZmllZGxpbmtsb2NhdGlvbm1heC1mb3J3YXJkc29yaWdpbnByYWdtYXByb3h5LWF1dGhlbnRpY2F0ZXByb3h5LWF1dGhvcml6YXRpb25wdWJsaWMta2V5LXBpbnNwdWJsaWMta2V5LXBpbnMtcmVwb3J0LW9ubHlyYW5nZXJlZmVyZXJyZWZlcnJlci1wb2xpY3lyZWZyZXNocmV0cnktYWZ0ZXJzZWMtd2Vic29ja2V0LWFjY2VwdHNlYy13ZWJzb2NrZXQtZXh0ZW5zaW9uc3NlYy13ZWJzb2NrZXQta2V5c2VjLXdlYnNvY2tldC1wcm90b2NvbHNlYy13ZWJzb2NrZXQtdmVyc2lvbnNlcnZlcnNldC1jb29raWVzdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5dGV0cmFpbGVydHJhbnNmZXItZW5jb2Rpbmd1c2VyLWFnZW50dXBncmFkZXVwZ3JhZGUtaW5zZWN1cmUtcmVxdWVzdHN2YXJ5dmlhd2FybmluZ3d3dy1hdXRoZW50aWNhdGV4LWNvbnRlbnQtdHlwZS1vcHRpb25zeC1kbnMtcHJlZmV0Y2gtY29udHJvbHgtZnJhbWUtb3B0aW9uc3gteHNzLXByb3RlY3Rpb25PUFRJT05TR0VUUE9TVFBVVERFTEVURUhFQURUUkFDRUNPTk5FQ1RQQVRDSEVycm9y4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAABRAAAADAAAAAQAAAApAAAAUQAAAAwAAAAEAAAAKgAAACkAAABYtRAAYAAAAGEAAAAtAAAALgAAAGIAAAAAAAAABAAAAAQAAAAwAAAAR2VuZXJhbE5ZSUVPRkFycm93RXJyb3IAAAAAAAQAAAAEAAAAYwAAAAAAAAAEAAAABAAAADEAAABJbmRleE91dE9mQm91bmQAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsTmVlZE1vcmVEYXRhAAAAAAQAAAAEAAAAMwAAAE5lZWRNb3JlRGF0YVJhbmdlAAAAbhEQAGsAAABYAAAADgAAAAAAAAAEAAAABAAAADQAAABUcnlGcm9tSW50RXJyb3JDYW5jZWxlZGZpbGUgc2l6ZSBvZiAgaXMgbGVzcyB0aGFuIGZvb3Rlcmu2EAANAAAAeLYQABQAAACrRRAAawAAAP4CAAA8AAAAZm9vdGVyIHNpemUgc2hvdWxkIG5ldmVyIGJlIGxhcmdlciB0aGFuIHUzMgCrRRAAawAAAA4DAAAOAAAAq0UQAGsAAAAYAwAAJwAAAG1ldGFkYXRhIGxlbmd0aCBzaG91bGQgbmV2ZXIgYmUgbGFyZ2VyIHRoYW4gdTMyAKtFEABrAAAALwMAABIAAACrRRAAawAAADADAAAgAAAAIGlzIGxlc3MgdGhhbiBmb290ZXIgKyBtZXRhZGF0YSBrthAADQAAAEi3EAAgAAAAbWV0YWRhdGEgcmVxdWlyZXMgIGJ5dGVzLCBidXQgY291bGQgb25seSByZWFkIAAAeLcQABIAAACKtxAAHAAAAKtFEABrAAAAtQEAACIAAACrRRAAawAAAOUBAAAVAAAAq0UQAGsAAAA8AwAAPAAAAKtFEABrAAAAZAMAACAAAAAIAAAAZm9vdGVyIG1ldGFkYXRhIHJlcXVpcmVzIAAAAPy3EAAZAAAAircQABwAAACrRRAAawAAAMQBAAAiAAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IHJlbWFpbmRlci5sZW4oKatFEABrAAAAEAIAABEAAABGb290ZXIgbWV0YWRhdGEgaXMgbm90IHByZXNlbnQAAKtFEABrAAAA/wEAABUAAACrRRAAawAAABgCAAAJAAAAq0UQAGsAAADOAQAAZAAAAJ4eEABjAAAAvQAAADkAAAB1cmwgcGFyc2VoZWFkZXJzIHRyeV9pdGVyaGVhZGVycyBoYXZlIGFuIGl0ZXJhdG9yaGVhZGVycyBpdGVyYXRvciBkb2Vzbid0IHRocm93c2VyaWFsaXplZCBoZWFkZXJzZGVzZXJpYWxpemFibGUgc2VyaWFsaXplZCBoZWFkZXJzSnNWYWx1ZSgicmVxd2VzdDo6ZXJyb3JzOjpUaW1lZE91dCIpAADyfxAAYAAAACIAAAABAAAAcHJvbWlzZSByZXNvbHZlZCB0byB1bmV4cGVjdGVkIHR5cGUAaBgQAGQAAAAAAgAAOAAAAOVoEABlAAAAdQAAADYAAADlaBAAZQAAAIIAAAAZAAAAznUQAGoAAAC9AQAAHQAAAG6PEAATAAAA5gAAAAkAAABujxAAEwAAAPIAAAAOAAAAbo8QABMAAAD+AAAAJQAAAG6PEAATAAAABgEAAAoAAABujxAAEwAAAA0BAAAhAAAAbo8QABMAAAAUAQAACQAAAG6PEAATAAAAFwEAADEAAABujxAAEwAAACMBAAAJAAAAbo8QABMAAABDAQAARQAAAG6PEAATAAAAVAEAABgAAABujxAAEwAAAEsBAAAsAAAAbo8QABMAAABMAQAAKgAAAG6PEAATAAAATgEAABIAAABujxAAEwAAAEgBAAAVAAAAbo8QABMAAABPAQAASAAAAG6PEAATAAAAUQEAACIAAABujxAAEwAAAHYBAAAJAAAAbo8QABMAAAB9AQAAJwAAAG6PEAATAAAAeQEAABkAAABujxAAEwAAAHsBAAAlAAAAbo8QABMAAACHAQAACQAAAG6PEAATAAAAlwEAAAkAAABujxAAEwAAAKYBAAAqAAAAbo8QABMAAAC0AQAAHwAAAFJhbmdlAAAAbo8QABMAAACoAQAAEQAAAG6PEAATAAAArgEAAA4AAABujxAAEwAAALABAAAOAAAAbo8QABMAAACxAQAAKAAAAG6PEAATAAAAsgEAABwAAABhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAbo8QABMAAADMAAAALwAAAGxvc3QgcmVhZGVyIGZhY3RvcnkAv30QAG0AAACfAwAAPQAAAGQAAABQAAAACAAAAGUAAABmAAAAeAEAAAgAAABnAAAAaAAAAIgBAAAIAAAAaQAAAGoAAAA4AAAABAAAAGsAAABsAAAAQAAAAAgAAABtAAAAbgAAANgBAAAIAAAAbwAAAHAAAAAMAAAABAAAAHEAAAByAAAAIABBuPnCAAuhCgEAAABzAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQAAAEVycm9yAAAA4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAAC/fRAAbQAAALEAAAAJAAAAv30QAG0AAACeAAAACQAAAL99EABtAAAAogAAAB4AAABleHBlY3RlZCB0byByZWFkICBieXRlcywgZ290IAAAAHC9EAARAAAAgb0QAAwAAADEShAAagAAAG0IAAAfAAAAq0UQAGsAAADlAQAAFQAAAKtFEABrAAAAPAMAADwAAACrRRAAawAAAGQDAAAgAAAACAAAAGZvb3RlciBtZXRhZGF0YSByZXF1aXJlcyAgYnl0ZXMsIGJ1dCBjb3VsZCBvbmx5IHJlYWQgAAAA5L0QABkAAAD9vRAAHAAAAG1ldGFkYXRhIHJlcXVpcmVzIAAALL4QABIAAAD9vRAAHAAAAKtFEABrAAAAxAEAACIAAABhc3NlcnRpb24gZmFpbGVkOiBlbmQgPD0gcmVtYWluZGVyLmxlbigpq0UQAGsAAAAQAgAAEQAAAEZvb3RlciBtZXRhZGF0YSBpcyBub3QgcHJlc2VudAAAq0UQAGsAAAD/AQAAFQAAAKtFEABrAAAAGAIAAAkAAAC/fRAAbQAAAFwAAAAeAAAAv30QAG0AAABbAAAACQAAAL99EABtAAAAYAAAABgAAAC/fRAAbQAAANwDAAAVAAAAv30QAG0AAAARBAAAJgAAAL99EABtAAAAEwQAADcAAAC/fRAAbQAAABMEAAAgAAAAv30QAG0AAABoAgAAHAAAAL99EABtAAAAUAIAABgAAAB0AAAAIAAAAAQAAAB1AAAAdgAAAL99EABtAAAAWQIAABcAAAC/fRAAbQAAAN4CAAAkAAAAv30QAG0AAADpAgAAJAAAAL99EABtAAAA6gIAACUAAAC/fRAAbQAAAOECAAAdAAAAv30QAG0AAACSAAAACQAAAL99EABtAAAAlAAAABsAAADOdRAAagAAAL0BAAAdAAAAZnV0dXJlIHN0aWxsIGhlcmUgd2hlbiBkcm9wcGluZ2Fzc2VydGlvbiBmYWlsZWQ6IHByZXYAAABAhRAAeAAAANoBAAANAAAAaW5jb25zaXN0ZW50IGluIGRyb3B3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAH8AAACAAAAAgQAAAIIAAABhc3NlcnRpb24gZmFpbGVkOiBzbG90LmlzX25vbmUoKZwcEABmAAAAggAAAA0AAADXMhAAeAAAAOsHAAAJAAAAYXJyb3dfc2NoZW1hdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAADEShAAagAAAG0IAAAfAAAA2ocQAGgAAABdAwAAEQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQAAAM51EABqAAAApwEAAB8AAADOdRAAagAAAK4BAAAmAAAAaW52YWxpZCBlbnVtIHZhbHVlIHBhc3NlZGF0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hpcCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZAAAAAABAAAAAgAAAAcAAAADAAAABAAAAAUAAAAGAEHkg8MACw0GAAAAAQAAAAAAAAABAEGAhMMAC6UDAQAAAAIAAAAEAAAABQAAAAYAAAAHAAAAAwAAAGJvb2wgZmllbGQgc2hvdWxkIGhhdmUgYSBmaWVsZCBpZAAAAOciEABmAAAA6gEAACsAAABzaG91bGQgaGF2ZSBwcmV2aW91cyBmaWVsZCBpZHMAAOciEABmAAAAxAEAAA4AAABzaG91bGQgbm90IGhhdmUgYSBwZW5kaW5nIGJvb2wgd2hpbGUgd3JpdGluZyBhbm90aGVyIGJvb2wgd2l0aCBpZDogAIDCEABDAAAA5yIQAGYAAADMAQAAFQAAAG5vbi1zdG9wIGZpZWxkIHNob3VsZCBoYXZlIGZpZWxkIGlkAOciEABmAAAA1wEAAC4AAADnIhAAZgAAALoBAAAjAAAAiAAAAMgDAAAIAAAAiQAAAO8nEABrAAAA4wEAAA4AAADvJxAAawAAAPgBAAAOAAAA/jQQAHgAAAB6AAAAIQAAAGZhaWxlZCB0byB3cml0ZSB0aGUgYnVmZmVyZWQgZGF0YQAAAGDDEAAhAAAAFwAAAIoAAAAMAAAABAAAAIsAAACMAAAAIABBsIfDAAvdHQEAAACNAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAAHprAvv5ieL98GMLX7yHypwAAAAAAAAAAAQAAAI4AAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAI8AAAAEAAAABAAAACcAAACQAAAADAAAAAQAAABfAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAIoAAAAMAAAABAAAACkAAACKAAAADAAAAAQAAAAqAAAAKQAAACzJEACRAAAAkgAAAC0AAAAuAAAAkwAAAMRKEABqAAAAbQgAAB8AAABwZW5kaW5nIGJvb2wgZmllbGQgIG5vdCB3cml0dGVuAHjJEAATAAAAi8kQAAwAAADnIhAAZgAAAKEBAAANAAAAQ2FuY2VsZWRDb3VsZCBub3Qgd3JpdGUgYmxvb20gZmlsdGVyIGJpdCBzZXQ6IAAAwMkQACYAAABDb3VsZCBub3Qgd3JpdGUgYmxvb20gZmlsdGVyIGhlYWRlcjogAAAA8MkQACUAAACeHhAAYwAAAL0AAAA5AAAAdXJsIHBhcnNlaGVhZGVycyB0cnlfaXRlcmhlYWRlcnMgaGF2ZSBhbiBpdGVyYXRvcmhlYWRlcnMgaXRlcmF0b3IgZG9lc24ndCB0aHJvd3NlcmlhbGl6ZWQgaGVhZGVyc2Rlc2VyaWFsaXphYmxlIHNlcmlhbGl6ZWQgaGVhZGVyc0pzVmFsdWUoInJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQiKQAA8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADlaBAAZQAAAHUAAAA2AAAA5WgQAGUAAACCAAAAGQAAAM51EABqAAAAvQEAAB0AAABQZWVrIHBvbGxlZCBhZnRlciBjb21wbGV0aW9uolsQAG4AAAAKAQAADQAAAGJ5dGVzPS0AeMsQAAYAAAB+yxAAAQAAAGJ5dGVzPS0AkMsQAAcAAABSYW5nZQAAACxeEAATAAAALQAAACYAAAAsXhAAEwAAAD0AAAAfAAAALF4QABMAAABDAAAAHwAAACxeEAATAAAAPwAAABEAAAAsXhAAEwAAAEAAAABJAAAALF4QABMAAABBAAAAIQAAAIoAAAAMAAAABAAAAJQAAACVAAAAlQAAACxeEAATAAAAUgAAABcAAACWAAAAQAAAAAgAAACXAAAALF4QABMAAABVAAAALwAAACxeEAATAAAAVAAAABIAAABFbXB0eSBpbnB1dCBwcm92aWRlZCBvciBub3QgYSBVaW50OEFycmF5LkNvbHVtbiAgbm90IGZvdW5kIGluIHRhYmxlAInMEAAHAAAAkMwQABMAAABIVFRQIGVycm9yOiBgYAAAtMwQAA0AAADBzBAAAQAAAFBsYXRmb3JtIGVycm9yOiBgAAAA1MwQABEAAADBzBAAAQAAAER5biBjYXN0aW5nIGVycm9yAAAAdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAACYAAAAGAAAAAgAAACZAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQCaAAAAEAAAAAQAAACbAAAAQXJjIGNvdW50ZXIgb3ZlcmZsb3d4zRAAFAAAAIKPEABpAAAA2AYAAA0AAACCjxAAaQAAABQMAAANAAAAAAAAAAQAAAAEAAAAMAAAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAJwAAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZQAAAMRKEABqAAAAbQgAAB8AAACdAAAABAAAAAQAAACeAAAAAAAAAAIAAAACAAAAnwAAAAAAAAAEAAAABAAAAKAAAABDb2x1bW5EZXNjcmlwdG9ycHJpbWl0aXZlX3R5cGVtYXhfZGVmX2xldmVsbWF4X3JlcF9sZXZlbHBhdGg1OBAAawAAAGQAAAAuAAAANTgQAGsAAABkAAAASwAAADU4EABrAAAARgAAAC4AAAA1OBAAawAAAEYAAABLAAAAqHcQAGAAAAAkAQAAGAAAAKh3EABgAAAAJgEAABEAAAAAAAAABAAAAAQAAAChAAAAAAAAAAQAAAAEAAAAogAAAFBhcnF1ZXRFcnJvclVua25vd25Db2x1bW4AAAAAAAAABAAAAAQAAACjAAAASFRUUEVycm9yUGxhdGZvcm1TdXBwb3J0RXJyb3IAAAAAAAAABAAAAAQAAACkAAAARHluQ2FzdGluZ0Vycm9yAG6PEAATAAAAxgAAABIAAABujxAAEwAAAMgAAAAdAAAAbo8QABMAAADTAAAAEQAAAExSEAALAAAA+AAAAC8AAABxfBAAbQAAAKUDAAAWAAAA8VcQAGAAAAB/AAAALAAAAPFXEABgAAAAgAAAACcAAADXMhAAeAAAAOsHAAAJAAAAk4oQAHEAAABbAAAAEgAAAJOKEABxAAAAYgAAAAkAAACTihAAcQAAAEAAAAANAAAAZmlsbGVkIG11c3Qgbm90IGJlY29tZSBsYXJnZXIgdGhhbiBpbml0aWFsaXplZAAAbNAQAC4AAAD4YRAAYAAAAIoAAAAWAAAA+GEQAGAAAABBAAAAHgAAAGZpbGxlZCBvdmVyZmxvdwDQIxAAXQAAAPsOAAAKAAAAz4kQAGEAAAAvAAAAEQAAAMRKEABqAAAAbQgAAB8AAADahxAAaAAAAF0DAAARAAAA2ocQAGgAAACwAAAAEQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWUAAAAAbxAAYQAAAF0AAAAJAAAAAG8QAGEAAABlAAAADQAAAJ1FEAANAAAAbwAAABoAAACdRRAADQAAAHsAAAAaAAAAnUUQAA0AAAB1AAAAGgAAAGFuIGFycmF5IG9mIGxlbmd0aCAyeyEQAHkAAAAvAAAAJwAAAKUAAAAMAAAABAAAAKYAAACnAAAAJAAAAAQAAACoAAAAYSBzZXF1ZW5jZQAAWygQAGMAAACKBAAAIgAAAFsoEABjAAAAjQQAABwAAACpAAAAsAMAAAgAAACqAAAAqwAAAEgAAAAIAAAArAAAAK0AAAAoAAAACAAAAK4AAACvAAAADAAAAAQAAACwAAAAsQAAACAAQZilwwALkQIBAAAAsgAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXnPghZ9BrVA9WqugZiyrbuVHprAvv5ieL98GMLX7yHyp2XgL1A6E/FDDdG1P8gtooQAAAAAAAAAAAEAAACzAAAAtAAAABAAAAAEAAAAVwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAtQAAAAQAAAAEAAAAJwAAALYAAAAEAAAABAAAAFoAQbSnwwALBQEAAAC3AEHEp8MAC40LAQAAALgAAAC5AAAADAAAAAQAAABfAAAAAAAAAAQAAAAEAAAAugAAAOBHEABdAAAAuggAABMAAADgRxAAXQAAAK4IAAATAAAA4EcQAF0AAAC0CAAAEgAAAOBHEABdAAAAkAUAAAwAAADgRxAAXQAAAKEFAAA0AAAA4EcQAF0AAACcBQAAEQAAAOBHEABdAAAAZQYAABYAAABzaXplIG92ZXJmbG93cyBNQVhfU0laRQDgRxAAXQAAAGAFAAAOAAAAYWNjZXB0YWNjZXB0LWNoYXJzZXRhY2NlcHQtZW5jb2RpbmdhY2NlcHQtbGFuZ3VhZ2VhY2NlcHQtcmFuZ2VzYWNjZXNzLWNvbnRyb2wtYWxsb3ctY3JlZGVudGlhbHNhY2Nlc3MtY29udHJvbC1hbGxvdy1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtYWxsb3ctbWV0aG9kc2FjY2Vzcy1jb250cm9sLWFsbG93LW9yaWdpbmFjY2Vzcy1jb250cm9sLWV4cG9zZS1oZWFkZXJzYWNjZXNzLWNvbnRyb2wtbWF4LWFnZWFjY2Vzcy1jb250cm9sLXJlcXVlc3QtaGVhZGVyc2FjY2Vzcy1jb250cm9sLXJlcXVlc3QtbWV0aG9kYWdlYWxsb3dhbHQtc3ZjYXV0aG9yaXphdGlvbmNhY2hlLWNvbnRyb2xjYWNoZS1zdGF0dXNjZG4tY2FjaGUtY29udHJvbGNvbm5lY3Rpb25jb250ZW50LWRpc3Bvc2l0aW9uY29udGVudC1lbmNvZGluZ2NvbnRlbnQtbGFuZ3VhZ2Vjb250ZW50LWxlbmd0aGNvbnRlbnQtbG9jYXRpb25jb250ZW50LXJhbmdlY29udGVudC1zZWN1cml0eS1wb2xpY3ljb250ZW50LXNlY3VyaXR5LXBvbGljeS1yZXBvcnQtb25seWNvbnRlbnQtdHlwZWNvb2tpZWRudGRhdGVldGFnZXhwZWN0ZXhwaXJlc2ZvcndhcmRlZGZyb21ob3N0aWYtbWF0Y2hpZi1tb2RpZmllZC1zaW5jZWlmLW5vbmUtbWF0Y2hpZi1yYW5nZWlmLXVubW9kaWZpZWQtc2luY2VsYXN0LW1vZGlmaWVkbGlua2xvY2F0aW9ubWF4LWZvcndhcmRzb3JpZ2lucHJhZ21hcHJveHktYXV0aGVudGljYXRlcHJveHktYXV0aG9yaXphdGlvbnB1YmxpYy1rZXktcGluc3B1YmxpYy1rZXktcGlucy1yZXBvcnQtb25seXJhbmdlcmVmZXJlcnJlZmVycmVyLXBvbGljeXJlZnJlc2hyZXRyeS1hZnRlcnNlYy13ZWJzb2NrZXQtYWNjZXB0c2VjLXdlYnNvY2tldC1leHRlbnNpb25zc2VjLXdlYnNvY2tldC1rZXlzZWMtd2Vic29ja2V0LXByb3RvY29sc2VjLXdlYnNvY2tldC12ZXJzaW9uc2VydmVyc2V0LWNvb2tpZXN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHl0ZXRyYWlsZXJ0cmFuc2Zlci1lbmNvZGluZ3VzZXItYWdlbnR1cGdyYWRldXBncmFkZS1pbnNlY3VyZS1yZXF1ZXN0c3Zhcnl2aWF3YXJuaW5nd3d3LWF1dGhlbnRpY2F0ZXgtY29udGVudC10eXBlLW9wdGlvbnN4LWRucy1wcmVmZXRjaC1jb250cm9seC1mcmFtZS1vcHRpb25zeC14c3MtcHJvdGVjdGlvbk9QVElPTlNHRVRQT1NUUFVUREVMRVRFSEVBRFRSQUNFQ09OTkVDVFBBVENIRXJyb3LiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAABA5EABvAAAAkAAAAC4AQdyywwALBQEAAAC7AEHsssMACyEBAAAAvAAAALsAAABU2RAAvQAAAL4AAAC/AAAAwAAAAMEAQZizwwALBQEAAADCAEGos8MAC5kEAQAAAMMAAADCAAAAkNkQAL0AAADEAAAAvwAAAMUAAADBAAAArwAAAAwAAAAEAAAAKQAAAK8AAAAMAAAABAAAACoAAAApAAAAzNkQAMYAAADHAAAALQAAAC4AAADIAAAAVGltZWRPdXQAAAAABAAAAAQAAAAwAAAAR2VuZXJhbE5ZSUVPRkFycm93RXJyb3IAAAAAAAQAAAAEAAAAyQAAAAAAAAAEAAAABAAAADEAAABJbmRleE91dE9mQm91bmQAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsTmVlZE1vcmVEYXRhAAAAAAQAAAAEAAAAMwAAAE5lZWRNb3JlRGF0YVJhbmdlAAAAmnsQAG0AAABqAAAACQAAAJp7EABtAAAAcgAAAAkAAAAAAAAABAAAAAQAAAA0AAAAVG9TdHJFcnJvcl9wcml2VHJ5RnJvbUludEVycm9yQ2FuY2VsZWQAAJ4eEABjAAAAvQAAADkAAAB1cmwgcGFyc2VoZWFkZXJzIHRyeV9pdGVyaGVhZGVycyBoYXZlIGFuIGl0ZXJhdG9yaGVhZGVycyBpdGVyYXRvciBkb2Vzbid0IHRocm93c2VyaWFsaXplZCBoZWFkZXJzZGVzZXJpYWxpemFibGUgc2VyaWFsaXplZCBoZWFkZXJzSnNWYWx1ZSgicmVxd2VzdDo6ZXJyb3JzOjpUaW1lZE91dCIpAAABAEHUt8MACwEFAEHot8MAC5UO8n8QAGAAAAAiAAAAAQAAAHByb21pc2UgcmVzb2x2ZWQgdG8gdW5leHBlY3RlZCB0eXBlAGgYEABkAAAAAAIAADgAAADlaBAAZQAAAHUAAAA2AAAA5WgQAGUAAACCAAAAGQAAAM51EABqAAAAvQEAAB0AAABujxAAEwAAAP4AAAAlAAAAbo8QABMAAABDAQAARQAAAG6PEAATAAAAVAEAABgAAABujxAAEwAAAEsBAAAsAAAAbo8QABMAAABMAQAAKgAAAG6PEAATAAAATgEAABIAAABujxAAEwAAAEgBAAAVAAAAbo8QABMAAABPAQAASAAAAG6PEAATAAAAUQEAACIAAABujxAAEwAAAFsBAAAlAAAAbo8QABMAAABhAQAAHwAAAG6PEAATAAAAXQEAABEAAABujxAAEwAAAF8BAAAdAAAAbo8QABMAAACmAQAAKgAAAG6PEAATAAAAtAEAAB8AAABSYW5nZQAAAG6PEAATAAAAqAEAABEAAABujxAAEwAAAK4BAAAOAAAAbo8QABMAAACwAQAADgAAAG6PEAATAAAAsQEAACgAAABujxAAEwAAALIBAAAcAAAAaW52YWxpZCB2YWx1ZTogLCBleHBlY3RlZCAAAKTdEAAPAAAAs90QAAsAAABpbnZhbGlkIGxlbmd0aCAA0N0QAA8AAACz3RAACwAAAGR1cGxpY2F0ZSBmaWVsZCBgYAAA8N0QABEAAAAB3hAAAQAAANcyEAB4AAAA6wcAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBkc3QubGVuKCkgPj0gc2VsZi5yZXF1aXJlZF9zcGFjZSgpZB0QAGUAAAC9AAAACQAAAGQdEABlAAAAxwAAAAkAAABkHRAAZQAAAMIAAAANAAAADzcQAGUAAAAqAAAAHAAAAMRKEABqAAAAbQgAAB8AAAAAAAAABAAAAAQAAADQAAAAQ29sdW1uUGF0aHBhcnRzANEAAAAEAAAABAAAAJ4AAAAAAAAAAgAAAAIAAADSAAAAAAAAAAQAAAAEAAAAoAAAAENvbHVtbkRlc2NyaXB0b3JwcmltaXRpdmVfdHlwZW1heF9kZWZfbGV2ZWxtYXhfcmVwX2xldmVscGF0aNqHEABoAAAAXQMAABEAAABQQVIxTWlzc2luZyByb3cgZ3JvdXAgb3JkaW5hbAAAAKw2EABiAAAAxgEAAAoAAACsNhAAYgAAANABAAAlAAAArDYQAGIAAADQAQAAQQAAAE5lZ2F0aXZlIHJvdyBncm91cCBvcmRpbmFsOiApAAAAlN8QABwAAACw3xAAAQAAAAAAAAAUAAAABAAAANMAAAAAAAAAFAAAAAQAAADUAAAArDYQAGIAAAAAAQAAHwAAAKw2EABiAAAAAQEAACAAAACsNhAAYgAAAAIBAAAgAAAArDYQAGIAAAAKAQAAGAAAAP9/UGFycXVldCBkb2VzIG5vdCBzdXBwb3J0IG1vcmUgdGhhbiAgcm93IGdyb3VwcyBwZXIgZmlsZSAoY3VycmVudGx5OiAAACbgEAAjAAAASeAQACEAAACw3xAAAQAAAKw2EABiAAAATQEAACwAAABQcmV2aW91cyByb3cgZ3JvdXAgd3JpdGVyIHdhcyBub3QgY2xvc2VkU2VyaWFsaXplZEZpbGVXcml0ZXIgYWxyZWFkeSBmaW5pc2hlZAAAAAAAAAAcAAAABAAAANUAAAAAAAAAHAAAAAQAAADVAAAArDYQAGIAAABFAgAAGwAAAKw2EABiAAAARgIAABsAAACsNhAAYgAAAEcCAAAcAAAArDYQAGIAAABIAgAAHAAAAEluY29ycmVjdCBudW1iZXIgb2Ygcm93cywgZXhwZWN0ZWQgICE9ICByb3dzROEQACMAAABn4RAABAAAAGvhEAAFAAAArDYQAGIAAAC0AgAAMQAAAKw2EABiAAAAxgIAAEsAAABGYWlsZWQgdG8gc3BsaWNlIGNvbHVtbiBkYXRhLCBleHBlY3RlZCB7cmVhZF9sZW5ndGh9IGdvdCB7d3JpdGVfbGVuZ3RofWNvbHVtbiBkZXNjcmlwdG9yIG1pc21hdGNoLCBleHBlY3RlZCAgZ290IAAAAO/hEAAlAAAAFOIQAAUAAABleGhhdXN0ZWQgY29sdW1ucyBpbiBTZXJpYWxpemVkUm93R3JvdXBXcml0ZXJQcmV2aW91cyBjb2x1bW4gd3JpdGVyIHdhcyBub3QgY2xvc2VkAACsNhAAYgAAABsCAAAcAAAArDYQAGIAAAAcAgAAHAAAAKw2EABiAAAAHQIAAB0AAACsNhAAYgAAAB4CAAAdAAAArDYQAGIAAADxAgAAOQAAANqHEABoAAAAEQIAABEAAADahxAAaAAAADkDAAARAAAAznUQAGoAAAC9AQAAHQBBiMbDAAsFAQAAANYAQZjGwwALBQEAAADXAEGoxsMACwUBAAAA2ABBuMbDAAv8AQEAAADYAAAAVEoQAG8AAADlBQAAFAAAAFRKEABvAAAA5QUAACEAAABUShAAbwAAANkFAAAhAAAA1zIQAHgAAADrBwAACQAAAG1pZCA+IGxlbgAAAIDjEAAJAAAALX4QAIAAAACuAgAAEwAAAFRKEABvAAAAaQQAACQAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB9sjDAAszAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwQEBAQEAEG0ycMAC/4BQ291bGRuJ3QgZGVzZXJpYWxpemUgdTY0IGZyb20gYSBCaWdJbnQgb3V0c2lkZSB1NjQ6Ok1JTi4udTY0OjpNQVggYm91bmRz61UQAGYAAAAtAAAAOQAAANsnEAATAAAAUQAAADoAAADbJxAAEwAAAHUAAAA9AAAA2ycQABMAAAB2AAAARgAAAGJhdGNoU2l6ZXJvd0dyb3Vwc2xpbWl0b2Zmc2V0Y29sdW1uc2NvbmN1cnJlbmN5ADzlEAAJAAAAReUQAAkAAABO5RAABQAAAFPlEAAGAAAAWeUQAAcAAABg5RAACwAAAHN0cnVjdCBKc1JlYWRlck9wdGlvbnMAQbzLwwALsQMBAAAA2QAAAKlDEABtAAAAcgMAACYAAABFeHBlY3RlZCB0byByZWFkICBieXRlcyBvZiBwYWdlLCByZWFkIG9ubHkgANTlEAARAAAA5eUQABoAAABhc3NlcnRpb24gZmFpbGVkOiBuIDw9IHNlbGYuYnVmLmluaXQgLSBzZWxmLmJ1Zi5maWxsZWQAAIRhEABzAAAAFQEAAAkAAABmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXIAWOYQABsAAAAlAAAAAgAAAHTmEACufhAAaQAAAEECAAAfAAAABYkQAGgAAABgAAAAEgAAAGZpbGxlZCBtdXN0IG5vdCBiZWNvbWUgbGFyZ2VyIHRoYW4gaW5pdGlhbGl6ZWQAAKjmEAAuAAAA+GEQAGAAAACTAAAADgAAAPhhEABgAAAAQQAAAB4AAABmaWxsZWQgb3ZlcmZsb3didWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCk7IGJ1Zi5sZW4oKSA9ICwgcmVtYWluaW5nKCkgPSAAAA/nEAAvAAAAPucQABAAAADvkhAAXgAAAEoBAAARAEH4zsMAC/UPAQAAANoAAABxfBAAbQAAAK4DAAApAAAA3QAAABwAAAAEAAAA3gAAAN8AAADgAAAA4QAAAOIAAABIAAAACAAAAOMAAADkAAAA5QAAAOYAAADnAAAA6AAAAOkAAADqAAAAUS8QAGIAAACNAAAADgAAAOsAAADAAAAACAAAAOwAAADtAAAA7gAAANAAAAAIAAAA7wAAAPAAAADXMhAAeAAAAOsHAAAJAAAA8QAAABQAAAAEAAAA8gAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAXIIQAH4AAACyBQAAJAAAAM+JEABhAAAALwAAABEAAAAAAAAABAAAAAQAAAAwAAAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAADzAAAADAAAAAQAAAD0AAAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgDEShAAagAAAG0IAAAfAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gU2l6ZSBpcyAgYnV0IG5lZWQgAADo6RAAIAAAAAjqEAAKAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gUmFuZ2UgIGlzIGJleW9uZCBmaWxlIGJvdW5kcyAAAAAk6hAAHgAAAELqEAAXAAAAUGFycXVldCBmaWxlIHRvbyBzbWFsbC4gUGFnZSBpbmRleCByYW5nZSAgb3ZlcmxhcHMgd2l0aCBmaWxlIG1ldGFkYXRhIAAAbOoQACkAAACV6hAAHQAAAFRyaWVkIHRvIHJlYWQgcGFnZSBpbmRleGVzIHdpdGhvdXQgUGFycXVldE1ldGFEYXRhIG1ldGFkYXRhAHF8EABtAAAAwwMAABsAAABxfBAAbQAAAMQDAAAfAAAAcXwQAG0AAADEAwAAQAAAAPYAAAAUAAAABAAAAPcAAAD4AAAAcm93IGdyb3VwICBvdXQgb2YgYm91bmRzIDAuLkTrEAAKAAAATusQABIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBNdXN0IGJlIFN0cnVjdCBmb3Igcm9vdCB0eXBlAABw6xAARgAAAL99EABtAAAAEAIAABIAAADOdRAAagAAAL0BAAAdAAAAnUUQAA0AAAAuAAAAEQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU+SBAAbQAAADoAAAAxAAAATWFwIG11c3Qgbm90IGJlIHBvbGxlZCBhZnRlciBpdCByZXR1cm5lZCBgUG9sbDo6UmVhZHlgAAA+SBAAbQAAAD4AAAARAAAAznUQAGoAAAC9AQAAHQAAAFVua25vd24gZXJyb3JhbHJlYWR5IGxvY2tlZCB0byBhIHdyaXRlcmF0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hpcCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWVhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAAAAAAAABAAAAAQAAAPkAAAD6AAAARm5PbmNlIGNhbGxlZCBtb3JlIHRoYW4gb25jZR6awL7+Yni/fBjC1+8h8qf7AAAADAAAAAQAAAApAAAA+wAAAAwAAAAEAAAAKgAAACkAAACY7RAA/AAAAP0AAAAtAAAALgAAAP4AAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwX3Rocm93KClgIG9uIGFuIGBFcnJgIHZhbHVlcG9sbGVkIEZlZWQgYWZ0ZXIgY29tcGxldGlvbgAAALaMEABlAAAAJwAAACUAAAD/AAAAlAAAAAQAAAAAAQAAAQEAAGwAAAAEAAAAAgEAAAMBAABsAAAABAAAAAQBAAAFAQAATAAAAAQAAAAGAQAABwEAAFQAAAAEAAAACAEAAAAAAAAEAAAABAAAAAkBAAAKAQAAAAAAAAQAAAAEAAAACwEAAAwBAAAAAAAABAAAAAQAAAANAQAADgEAAAAAAAAEAAAABAAAAA8BAAAQAQAAAAAAAAQAAAAEAAAAEQEAABIBAADHkRAAZwAAAOYAAAAVAAAAzFoQAHgAAAA+AAAARgAAAMxaEAB4AAAATAAAADYAAADMWhAAeAAAAFAAAABIAAAAzFoQAHgAAAAcAAAAGwAAAMxaEAB4AAAAJQAAABsAAADMWhAAeAAAACwAAAAbAAAAEwEAAAwAAAAEAAAAFAEAABUBAAAgAEH43sMAC+UBAQAAABYBAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAATnUQAH8AAABuAAAAGQAAAE51EAB/AAAAcAAAAC8AAABOdRAAfwAAAGQAAAAjAAAATnUQAH8AAACAAAAALAAAANN0EAB6AAAAUAAAACMAAABOdRAAfwAAADUAAAATAAAA03QQAHoAAAAjAAAAEwBB6ODDAAu+BAEAAACzAAAA4EcQAF0AAACQBAAADAAAAOBHEABdAAAAuwYAACAAAADgRxAAXQAAALsGAAA/AAAA4EcQAF0AAAC8BgAAIAAAAOBHEABdAAAAZQYAABYAAADgRxAAXQAAAMEFAAA9AAAAc2l6ZSBvdmVyZmxvd3MgTUFYX1NJWkUA4EcQAF0AAABoBAAAHQAAAOBHEABdAAAA3AYAAA0AAADgRxAAXQAAANwGAAAsAAAA4EcQAF0AAADgBgAAIQAAAOBHEABdAAAA6gYAABYAAADgRxAAXQAAAMEKAAAhAAAA4EcQAF0AAACnCgAAIAAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBvciBhZnRlciBiZWluZyBkcm9wcGVkZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheQAA9yRbETdq5ez1Dz3bPRfbXLCEy/RX/xQlHL33xG4wOEzTvhCNO6oG2mzL/9GPJJTpcfnzCcyUAxXfG8TTvJ/PfQAAAAACAAAAAQAAABcBAAAAAAAAAgAAAAEAAAAYAQAAFwEAAPTxEAAZAQAAGgEAABsBAAAcAQAAHQEAAB4BAAAEAAAABAAAAB8BAAAeAQAABAAAAAQAAAAnAAAAHwEAADDyEAAgAQAAIQEAACIBAAAjAQAAJAEAAAAAAAABAAAAAQAAACUBAAAAAAAAAQAAAAEAAAAmAQAAJQEAAGzyEAAnAQAAKAEAABsBAAApAQAAHQEAQbDlwwALBgEAAAAqAQBBwOXDAAu5CAEAAAArAQAAKgEAAKjyEAAsAQAALQEAAC4BAAAvAQAAMAEAAEVtcHR5SG9zdElkbmFFcnJvckludmFsaWRQb3J0SW52YWxpZElwdjRBZGRyZXNzSW52YWxpZElwdjZBZGRyZXNzSW52YWxpZERvbWFpbkNoYXJhY3RlclJlbGF0aXZlVXJsV2l0aG91dEJhc2VSZWxhdGl2ZVVybFdpdGhDYW5ub3RCZUFCYXNlQmFzZVNldEhvc3RPbkNhbm5vdEJlQUJhc2VVcmxPdmVyZmxvd2NhbGxlZCBgUmVzdWx0Ojp1bndyYXBfdGhyb3coKWAgb24gYW4gYEVycmAgdmFsdWVCYWRTY2hlbWUJAAAACQAAAAsAAAASAAAAEgAAABYAAAAWAAAAIAAAABkAAAAIAAAA5PIQAO3yEAD28hAAAfMQABPzEAAl8xAAO/MQAFHzEABx8xAAivMQAB6awL7+Yni/fBjC1+8h8qc0AQAADAAAAAQAAAApAAAANAEAAAwAAAAEAAAAKgAAACkAAAAs9BAANQEAADYBAAAtAAAALgAAADcBAAByZXF3ZXN0OjpFcnJvcgAAAAAAAAQAAAACAAAAOAEAAGtpbmQAAAAACAAAAAQAAAA5AQAAdXJsADoBAAAIAAAABAAAADsBAABzb3VyY2VidWlsZGVyIGVycm9yZXJyb3Igc2VuZGluZyByZXF1ZXN0ZXJyb3IgZm9sbG93aW5nIHJlZGlyZWN0SFRUUCBzdGF0dXMgc2VydmVyIGVycm9ySFRUUCBzdGF0dXMgY2xpZW50IGVycm9yICgpAAEAAAAAAAAAIPUQAAIAAAAi9RAAAQAAAHJlcXVlc3Qgb3IgcmVzcG9uc2UgYm9keSBlcnJvcmVycm9yIGRlY29kaW5nIHJlc3BvbnNlIGJvZHllcnJvciB1cGdyYWRpbmcgY29ubmVjdGlvbiBmb3IgdXJsICgAAJD1EAAKAAAAIvUQAAEAAABvcGVyYXRpb24gdGltZWQgb3V0VVJMIHNjaGVtZSBpcyBub3QgYWxsb3dlZEJ1aWxkZXJSZXF1ZXN0UmVkaXJlY3QAAAAAAAAEAAAABAAAADwBAABTdGF0dXNCb2R5RGVjb2RlVXBncmFkZQABAAAAAAAAAFNlcnZpY2VXb3JrZXJHbG9iYWxTY29wZUABAAAIAAAABAAAAEEBAABCAQAARm5PbmNlIGNhbGxlZCBtb3JlIHRoYW4gb25jZQAAAAAAAAAAAQAAAEMBAAAAAAAABAAAAAQAAABEAQAAVHJ5RnJvbUludEVycm9ydGltZW91dAAA8n8QAGAAAABGAAAALAAAAHJlcXdlc3Q6OmVycm9yczo6VGltZWRPdXQAAAAMkRAAVQAAAE8LAAALAAAAYmxvYmh0dHC5VBAAYAAAAB0AAAAdAAAAAAAAABgAQYTuwwALtQHOdRAAagAAAKcBAAAfAAAA8VcQAGAAAACTAAAAEwAAAPFXEABgAAAAmAAAACMAAADxVxAAYAAAAJsAAAAWAAAA8VcQAGAAAACnAAAADQAAAMoZEACBAAAAOAAAABsAAAB4FBAAXgAAAJUAAAAcAAAAY2Fubm90IGFkdmFuY2UgcGFzdCBgcmVtYWluaW5nYDogIDw9IAAAAHT3EAAhAAAAlfcQAAQAAAALLBAAWgAAAMcCAAAJAEHd78MAC14hACMkJSYnAAAqKwAtLgAwMTIzNDU2Nzg5AAAAAAAAAGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6AAAAXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoAfAB+AEG88cMAC94HSW52YWxpZEhlYWRlck5hbWVpbnZhbGlkIEhUVFAgaGVhZGVyIG5hbWVJbnZhbGlkSGVhZGVyVmFsdWVmYWlsZWQgdG8gcGFyc2UgaGVhZGVyIHZhbHVlZmFpbGVkIHRvIGNvbnZlcnQgaGVhZGVyIHRvIGEgc3RyaW52YWxpZCB1cmkgY2hhcmFjdGVyaW52YWxpZCBzY2hlbWVpbnZhbGlkIGF1dGhvcml0eWludmFsaWQgcG9ydGludmFsaWQgZm9ybWF0c2NoZW1lIG1pc3NpbmdhdXRob3JpdHkgbWlzc2luZ3BhdGggbWlzc2luZ3VyaSB0b28gbG9uZ2VtcHR5IHN0cmluZ3NjaGVtZSB0b28gbG9uZwAAAAAEAAAABAAAAEYBAABJbnZhbGlkVXJpSW52YWxpZFVyaUNoYXJJbnZhbGlkU2NoZW1lSW52YWxpZEF1dGhvcml0eUludmFsaWRQb3J0SW52YWxpZEZvcm1hdFNjaGVtZU1pc3NpbmdBdXRob3JpdHlNaXNzaW5nUGF0aEFuZFF1ZXJ5TWlzc2luZ1Rvb0xvbmdFbXB0eVNjaGVtZVRvb0xvbmcAAA4AAAANAAAAEAAAAAsAAAANAAAADQAAABAAAAATAAAABwAAAAUAAAANAAAA7vkQAPz5EAAJ+hAAGfoQACT6EAAx+hAAPvoQAE76EABh+hAAaPoQAG36EAAVAAAADgAAABEAAAAMAAAADgAAAA4AAAARAAAADAAAAAwAAAAMAAAADwAAADT5EABJ+RAAV/kQAGj5EAB0+RAAgvkQAJD5EACh+RAArfkQALn5EADF+RAA4EcQAF0AAADZCAAAJgAAAOBHEABdAAAA4QgAADMAAABNYXhTaXplUmVhY2hlZG1heCBzaXplIHJlYWNoZWQAAKuIEABZAAAAUQEAADQAAABkZXNjcmlwdGlvbigpIGlzIGRlcHJlY2F0ZWQ7IHVzZSBEaXNwbGF5/boSq9eohd/PHDuR4FZOoG7m3f3FRzTMBdmXVQomhbWVJ86n0lRsQ88gelqcY4psCs5EZEhwZ1yLNTASwLCTKqGO1Laqqaf9AqPoZ9Hm65WZ4GA+TFRbkrCMdjsJUa9uGOuggV4LXZquasZ1vAzCDEludmFsaWRNZXRob2RpbnZhbGlkIEhUVFAgbWV0aG9kPHVua25vd24gc3RhdHVzIGNvZGU+IAAAAQAAAAAAAABJ/BAAAQAAAEludmFsaWRTdGF0dXNDb2RlaW52YWxpZCBzdGF0dXMgY29kZWh0dHA6OkVycm9yAAAAAAAIAAAABAAAAEkBAEGk+cMACwYBAAAASgEAQbT5wwALIgEAAABLAQAASgEAAJz8EABMAQAATQEAAE4BAABMAQAATwEAQeD5wwALBgEAAABQAQBB8PnDAAuaAQEAAABRAQAAUAEAANj8EABMAQAAUgEAAE4BAABMAQAATwEAAAAAAAABAAAAAQAAAFMBAAAAAAAAAQAAAAEAAABUAQAAUwEAABT9EABVAQAAVgEAAFcBAABYAQAAWQEAAAAAAAABAAAAAQAAAFoBAAAAAAAAAQAAAAEAAABbAQAAWgEAAFD9EABVAQAAXAEAAFcBAABYAQAAWQEAQZT7wwALBgEAAABdAQBBpPvDAAsiAQAAAF4BAABdAQAAjP0QAEwBAABfAQAATgEAAGABAABPAQBB0PvDAAsGAQAAAGEBAEHg+8MACyIBAAAAYgEAAGEBAADI/RAATAEAAGMBAABOAQAAZAEAAE8BAEGM/MMACwYBAAAAZQEAQZz8wwALnwgBAAAAswAAAGUBAAAE/hAATAEAAGYBAABOAQAAZwEAAE8BAABDb250aW51ZVN3aXRjaGluZyBQcm90b2NvbHNQcm9jZXNzaW5nT0tDcmVhdGVkQWNjZXB0ZWROb24gQXV0aG9yaXRhdGl2ZSBJbmZvcm1hdGlvbk5vIENvbnRlbnRSZXNldCBDb250ZW50UGFydGlhbCBDb250ZW50TXVsdGktU3RhdHVzQWxyZWFkeSBSZXBvcnRlZElNIFVzZWRNdWx0aXBsZSBDaG9pY2VzTW92ZWQgUGVybWFuZW50bHlGb3VuZFNlZSBPdGhlck5vdCBNb2RpZmllZFVzZSBQcm94eVRlbXBvcmFyeSBSZWRpcmVjdFBlcm1hbmVudCBSZWRpcmVjdEJhZCBSZXF1ZXN0VW5hdXRob3JpemVkUGF5bWVudCBSZXF1aXJlZEZvcmJpZGRlbk5vdCBGb3VuZE1ldGhvZCBOb3QgQWxsb3dlZE5vdCBBY2NlcHRhYmxlUHJveHkgQXV0aGVudGljYXRpb24gUmVxdWlyZWRSZXF1ZXN0IFRpbWVvdXRDb25mbGljdEdvbmVMZW5ndGggUmVxdWlyZWRQcmVjb25kaXRpb24gRmFpbGVkUGF5bG9hZCBUb28gTGFyZ2VVUkkgVG9vIExvbmdVbnN1cHBvcnRlZCBNZWRpYSBUeXBlUmFuZ2UgTm90IFNhdGlzZmlhYmxlRXhwZWN0YXRpb24gRmFpbGVkSSdtIGEgdGVhcG90TWlzZGlyZWN0ZWQgUmVxdWVzdFVucHJvY2Vzc2FibGUgRW50aXR5TG9ja2VkRmFpbGVkIERlcGVuZGVuY3lUb28gRWFybHlVcGdyYWRlIFJlcXVpcmVkUHJlY29uZGl0aW9uIFJlcXVpcmVkVG9vIE1hbnkgUmVxdWVzdHNSZXF1ZXN0IEhlYWRlciBGaWVsZHMgVG9vIExhcmdlVW5hdmFpbGFibGUgRm9yIExlZ2FsIFJlYXNvbnNJbnRlcm5hbCBTZXJ2ZXIgRXJyb3JOb3QgSW1wbGVtZW50ZWRCYWQgR2F0ZXdheVNlcnZpY2UgVW5hdmFpbGFibGVHYXRld2F5IFRpbWVvdXRIVFRQIFZlcnNpb24gTm90IFN1cHBvcnRlZFZhcmlhbnQgQWxzbyBOZWdvdGlhdGVzSW5zdWZmaWNpZW50IFN0b3JhZ2VMb29wIERldGVjdGVkTm90IEV4dGVuZGVkTmV0d29yayBBdXRoZW50aWNhdGlvbiBSZXF1aXJlZAAAAAAEAAAABAAAAEYBAABJbnZhbGlkVXJpAAAAAAAABAAAAAQAAABoAQAASW52YWxpZFVyaVBhcnRzAKz8EADo/BAAJP0QAGD9EACc/RAA2P0QABT+EABBxITEAAvsCwEAAABqAQAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUVycm9yYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5pc19jaGFyX2JvdW5kYXJ5KGlkeClhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbilhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkoYXQpAFRKEABvAAAAzgEAADcAAABUShAAbwAAAAoCAAA3AAAA4l8QAGsAAABnCQAAKQAAAGh0dHBodHRwc3dzd3NzZnRwZmlsZQAAAIA5EABYAAAAIwEAAC4AAACAORAAWAAAAJ0BAAAxAAAAgDkQAFgAAACcAQAATwAAAIA5EABYAAAAsgEAABwAAACAORAAWAAAAMUBAABEAAAALy8AAIA5EABYAAAA7gEAACAAAABmaWxlOi8vAIA5EABYAAAAEQIAACQAAACAORAAWAAAABwCAAAoAAAAgDkQAFgAAAAkAgAAGgAAAIA5EABYAAAANwIAACQAAACAORAAWAAAAD4CAABGAAAAgDkQAFgAAAA+AgAAVgAAAIA5EABYAAAAQwIAADAAAACAORAAWAAAAEACAAAwAAAAgDkQAFgAAABBAgAAMAAAAIA5EABYAAAAcAIAADsAAACAORAAWAAAAHMCAAAoAAAAgDkQAFgAAACAAgAAKAAAAIA5EABYAAAAkQIAACwAAABmaWxlOi8vL4A5EABYAAAApQIAACwAAACAORAAWAAAAL0CAAAgAAAAgDkQAFgAAADgAgAANwAAAIA5EABYAAAA4wIAACQAAACAORAAWAAAAPACAAAkAAAAgDkQAFgAAAAPAwAAJAAAAIA5EABYAAAAEAMAACQAAACAORAAWAAAAAgDAAAaAAAAgDkQAFgAAAAoAwAAJAAAAIA5EABYAAAAMAMAACgAAACAORAAWAAAAFIDAAAcAAAAgDkQAFgAAABTAwAAHAAAAIA5EABYAAAAtQMAACAAAACAORAAWAAAAJ0DAAAxAAAAgDkQAFgAAACkAwAAKAAAAP////8NgAD8AQAAeAEAALgBAAAAAAAAAIA5EABYAAAAwQMAADMAAAA6AAAAgDkQAFgAAADTAwAAJAAAAIA5EABYAAAA1gMAACQAAACAORAAWAAAANADAAA9AAAAgDkQAFgAAAAIBAAANAAAAGxvY2FsaG9zdAAAAIA5EABYAAAAMQQAAD8AAACAORAAWAAAAFEEAAA0AAAAgDkQAFgAAACfBAAAIAAAAIA5EABYAAAAjgQAACQAAACAORAAWAAAAOsEAAAsAAAAgDkQAFgAAAD6BAAALAAAAIA5EABYAAAADgUAADQAAACAORAAWAAAABkFAAAwAAAAgDkQAFgAAAAjBQAAJAAAAIA5EABYAAAAIQUAACQAAAAuLiUyZSUyZSUyZSUyRSUyRSUyZSUyRSUyRSUyZS4lMkUuLiUyZS4lMkUuJTJlJTJFAAAAgDkQAFgAAABHBQAAMAAAAIA5EABYAAAASAUAADAAAACAORAAWAAAAEkFAAAwAAAAgDkQAFgAAABLBQAANAAAAIA5EABYAAAAOgUAACgAAACAORAAWAAAADwFAAAsAAAAgDkQAFgAAAAqBQAAKAAAAIA5EABYAAAANAUAACwAAACAORAAWAAAAGAFAAArAAAAgDkQAFgAAABhBQAAIAAAAIA5EABYAAAAYgUAACAAAACAORAAWAAAALQEAAAiAAAA/////w0AANAAAAAAAQAAqP////8tgADQAAAAAAEAAKj/////LYAA0AAAABABAACogDkQAFgAAABpBQAAMAAAAIA5EABYAAAAbgUAAEkAAACAORAAWAAAAHwFAABGAAAAgDkQAFgAAACHBQAANAAAAIA5EABYAAAAhwUAAE4AAACAORAAWAAAAIwFAABKAAAAgDkQAFgAAACOBQAAJAAAAP////8AQbuQxAAL6QeAgDkQAFgAAADFBQAAIwAAADovLgCAORAAWAAAAMkFAAAYAAAALwAAAIA5EABYAAAA1AUAABYAAACAORAAWAAAANcFAAAoAAAAOi8vYXNzZXJ0aW9uIGZhaWxlZDogIXNlbGYuc2VyaWFsaXphdGlvbltzY2hlbWVfZW5kX2FzX3VzaXplLi5dLnN0YXJ0c193aXRoKCI6Ly8iKQAAgDkQAFgAAADXBQAADQAAAIA5EABYAAAAyQUAAA0AAACAORAAWAAAAL0FAAAiAAAAgDkQAFgAAADABQAAJAAAAIA5EABYAAAAwwUAACgAAACAORAAWAAAAMMFAAANAAAAgDkQAFgAAAD2BQAAJAAAAIA5EABYAAAAAwYAABwAAABQcm9ncmFtbWluZyBlcnJvci4gcGFyc2VfcXVlcnlfYW5kX2ZyYWdtZW50KCkgY2FsbGVkIHdpdGhvdXQgPyBvciAjAIA5EABYAAAA/wUAABIAAAD/////DQAAUAAAAAAAAACA/////40AAFAAAAAAAAAAgIA5EABYAAAAHwYAACcAAACAORAAWAAAACUGAAAnAAAAAAAAAAgAAAAEAAAAawEAAGwBAABsAQAAgDkQAFgAAABEBgAAJAAAAIA5EABYAAAAYAYAAA4AAACAORAAWAAAAGEGAAAcAAAAgDkQAFgAAABiBgAAHAAAAP////8FAABQAAAAAAEAAICAORAAWAAAAH4GAAAnAAAAgDkQAFgAAAD5BgAAVwAAAIA5EABYAAAAIgcAAAkAAAAMkRAAVQAAAEgLAAALAAAADJEQAFUAAABPCwAACwAAAGVtcHR5IGhvc3RpbnZhbGlkIGludGVybmF0aW9uYWwgZG9tYWluIG5hbWVpbnZhbGlkIHBvcnQgbnVtYmVyaW52YWxpZCBJUHY0IGFkZHJlc3NpbnZhbGlkIElQdjYgYWRkcmVzc2ludmFsaWQgZG9tYWluIGNoYXJhY3RlcnJlbGF0aXZlIFVSTCB3aXRob3V0IGEgYmFzZXJlbGF0aXZlIFVSTCB3aXRoIGEgY2Fubm90LWJlLWEtYmFzZSBiYXNlYSBjYW5ub3QtYmUtYS1iYXNlIFVSTCBkb2VzbuKAmXQgaGF2ZSBhIGhvc3QgdG8gc2V0VVJMcyBtb3JlIHRoYW4gNCBHQiBhcmUgbm90IHN1cHBvcnRlZAAA4l8QAGsAAADoAQAAFwAAAAyREABVAAAAQQsAAAsAAAAMkRAAVQAAAEgLAAALAAAA1zIQAHgAAADrBwAACQAAAFRKEABvAAAACgIAADcAAAA4FRAAVgAAAGEAAAApAAAA/////wBBr5jEAAvBDIA4FRAAVgAAAIAAAAApAAAAW106ADgVEABWAAAA2wAAABsAAAABAAAAAAAAADgVEABWAAAACwEAAB0AAAAweDBYOBUQAFYAAAAoAQAAFwAAADgVEABWAAAAJQEAABcAAABhIG5vbi1lbXB0eSBsaXN0IG9mIG51bWJlcnMAOBUQAFYAAABSAQAAIgAAADgVEABWAAAATQEAACQAAAA4FRAAVgAAAKgBAAAJAAAAOBUQAFYAAADnAQAAGAAAADgVEABWAAAAzgEAABEAAABYehAAawAAACQDAAABAAAA4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobilhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkoc3RhcnQpYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5pc19jaGFyX2JvdW5kYXJ5KGVuZCluAQAADAAAAAQAAABvAQAAcAEAAHEBAADiXxAAawAAAGYJAAAOAAAA4l8QAGsAAABnCQAAKQAAAP4QEABvAAAAWgMAADQAAAD+EBAAbwAAAGEDAAAyAAAA1zIQAHgAAADrBwAACQAAAAAAAAAEAAAABAAAAHIBAAD8hhAAbAAAAOIKAAAkAAAAVEoQAG8AAADOAQAANwAAAAAAAAAIAAAABAAAAHMBAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlQ2FwYWNpdHlPdmVyZmxvdwAAAAAABAAAAAQAAAB0AQAAQWxsb2NFcnJsYXlvdXQAAKiTEABbAAAAVgEAAC4AAABjYXBhY2l0eSBvdmVyZmxvdwAAAKiTEABbAAAA0gQAAA4AAABhc3NlcnRpb24gZmFpbGVkOiBuZXdfY2FwID49IGxlbqiTEABbAAAAnQQAAA0AAADiXxAAawAAANUMAAAOAAAAEHIQAFsAAAAhAAAADgAAABByEABbAAAAsQAAABsAAAAQchAAWwAAAJMBAAAOAAAAEHIQAFsAAAC4AQAAJQAAAGV4cGxpY2l0IHBhbmljAAAQchAAWwAAAM4BAAAOAAAAuZQQAGAAAACkAwAAKwAAAG1pZCA+IGxlbgAAAJgPEQAJAAAATBoQAH8AAABKAAAAHwAAAEwaEAB/AAAARAAAABcAAAAAAEAAAACAAMAA/wA+AXEBsQEAAAAAAADxATECcAKmAuYCIANdA5wDAAAAANYDFgRGBHsEAAC7BOoEKQUAAD4FfAWqBdMFCQZJBoYGpgblBiQHYQeAB70Hpgb1ByEIYAiAB5gIgAfYCO8ILgkAAGQJhAm/CcsJBgouCmsKqwrlCm8GiAaVBqsGywbbBvMGEgeIBogGiAYnBwAAEAAgADAAQABQAGAAcAAAABAAIAAwAIAAkACgALAAwADQAOAA8AD/AA8BHwEvAT4BTgFeAW4BcQGBAZEBoQGxAcEB0QHhAQAAEAAgADAAAAAQACAAMAAAABAAIAAwAPEBAQIRAiECMQJBAlECYQJwAoACkAKgAqYCtgLGAtYC5gL2AgYDFgMgAzADQANQA10DbQN9A40DnAOsA7wDzAMAABAAIAAwAAAAEAAgADAA1gPmA/YDBgQWBCYENgRGBFYEZgR2BHsEiwSbBKsEAAAQACAAMAC7BMsE2wTrBOoE+gQKBRoFKQU5BUkFWQUAABAAIAAwAD4FTgVeBW4FfAWMBZwFrAWqBboFygXaBdMF4wXzBQMGCQYZBikGOQZJBlkGaQZ5BoYGlgamBrYGpga2BsYG1gblBvUGBQcVByQHNAdEB1QHYQdxB4EHkQeAB5AHoAewB70HzQfdB+0Hpga2BsYG1gb1BwUIFQglCCEIMQhBCFEIYAhwCIAIkAiAB5AHoAewB5gIqAi4CMgIgAeQB6AHsAfYCOgI+AgICe8I/wgPCR8JLgk+CU4JXgkAABAAIAAwAGQJdAmECZQJpAm0Cb8JzwnfCe8JywnbCesJ+wkGChYKJgo2Ci4KPgpOCl4Kawp7CosKmwqrCrsKywrbCuUK9QoFCxULAAAAAB8LLgsAAAAAAAAAADkLAEGKpcQACw5IC1ILAAAAAFoLYgtvCwBBwqXEAAsCSQQAQYSmxAALBnsLAABqBwBBnKbEAAsCiQsAQbKmxAALApcLAEHEpsQACwKhCwBB3qbEAAtGrQsAAAAAAAAAAMoHuAsAAAAAAADIC9cLAAAAAAAA5gv1CwAAAQwRDAAAFgxhAwAAAAB1CwAAAAAAAH8GJgwAAAAAAAB+BgBBtqfEAAsGNgxGDFQMAEHUp8QAC0pkDHQM8QF+DI4MngyuDL4MzgzeDO4M/gwODR4NLg0+DU4NXg1uDX4Njg2eDa4Nvg3ODd4N7g3+DQ4OHg4uDj4OTQ5dDm0OfQ6NDgBBtqjEAAsMnQ6sDmQDAAAAALwOAEHOqMQACzTIDtQOAADjDgAAAAAAAPMOAAAADwAADw8AAB8PLw8/DwAASQ8AAAAAAABZDwAAAAAAAGcPAEGcqcQACwJyDwBBwqnEAAsERwRjAwBB1KnEAAsCGwkAQeKpxAALJPEB8QEAAAAAfw8AAI8Pnw+vD78PAADND9wP7A/8DwwQAAAaEABBpqrEAAsIRwQpEAAASAQAQbiqxAALAmMDAEHaqsQACwZoBwAAhwYAQfKqxAALFGoHAADxAWMDAAAAALgFAAAAAMcHAEGQq8QACwSCBsoHAEGqq8QACwo5ECIHAAAAAGgHAEHQq8QAC0aGBgAASRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEEkQSRBJEFUQAEGgrMQAC0BlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQZRBlEGUQAEGArcQAC0p1EIUQlRClELUQxRDVEOUQ9RAFERURJRE1EUURVRFlEXURhRGVEaURtRHFEdUR5RH1EQUSFRIlEjUSRRIAAAAAAABPEl8SbxJ/EgBB4K3EAAsCjxIAQZquxAALAp8SAEHarsQACwI5CwBB+K7EAAsCmgQAQYqvxAALAloDAEHEr8QACxCtEgAAuRIAAL4SAAAAAM4SAEHor8QACwLeEgBBjrDEAAsK6hIAAAAAAADyEgBBrbDEAAsdEwAAAAAAAAAAtgUAAAAAAAAAAA0TmgQAAAAAHRMAQdiwxAALOmgHAAAAAC0TAAA9E0oTVhMAAAAAAAAAAGIDAABhE3ETAAAAAAAAggYAAAAAAAAAAIETAAAAAAAAjBMAQaaxxAALLJMTAAAAAAAAAACeE60TWAi7E2ADyBPXEwAA3xPtE8oHAAAAAAAAAAD9ExUHAEHcscQACwQNFBwUAEH6scQACw5QCCIUMhQAAAAAAAAbCQBBlrLEAAsCPBQAQaSyxAALAmMHAEHAssQACwJWEwBB4LLEAAsETBSCBgBB9rLEAAsWygcAAAAAAABqB2cHAAAAAAAAAABlBwBBuLPEAAsCGwkAQdqzxAALDDMLAAAAAAAAAABnBwBBjrTEAAsCNgsAQbK0xAALBFsUahQAQdS0xAALCnoUAAAAAAAAihQAQYq1xAALApMUAEHKtcQACwKjFABB3rXEAAsCpRQAQYy2xAALGrQUxBTSFN8UAADrFPkUCRUAAAAAAAAAABcVAEHctsQACwYnFS8VPRUAQey2xAALAkcEAEGCt8QACwKKFABBnLfEAAsKFQcAAAAAAADlAQBByLfEAAsCSBUAQei3xAALAgwFAEGEuMQACwJYFQBBkrjEAAsCZBUAQaq4xAALRHQVhBWUFaQVtBXEFdQV5BX0FQQWFBYkFjQWRBZUFmQWdBaEFpQWpBa0FsQW1BbkFvQWBBcUFyQXNBdEF1QXZBd0F4QXAEGqucQAC64DTABsAIwAqwDLAOsACwEpAUkBZgF8AYsBqQHIAegBCAIoAkgCfAF8AXwBWwJtAnwBjQJ8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBpwLHAuQCBAMEAwQDBAMEAwQDBAMEAwQDBAMEAwoDKgMqAyoDKgN8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAFKA2oDfAGIA6gDyAPgA3wBfAEABA8EJgRCBF8EfQSaBLcE1gTzBA0FfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAEiBXwBfAF8AXwBNQVJBWAFfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBgAV8AXwBfAF8AXwBfAF8AXwBiwWoBXwBfAF8AXwBfAF8AcgF3gXwBXwBDwZ8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AS8GTwbu/wBB2MDEAAvEA0EAgAFBgIABQQCBAUGAgQFBAIQBQQCFAQAAAABDgJMBRQCAAUWAgAFFAIEBRQCEAUkAgAFJgIABSQCBAUkAhAEAAAAAToCBAU8AgAFPgIABTwCBAU+AgQFPAIQBAAAAAAAAAABVAIABVYCAAVUAgQFVAIQBWYCAAQAAAAAAAAAAYQCAAWGAgAFhAIEBYYCBAWEAhAFhAIUBAAAAAGOAkwFlAIABZYCAAWUAgQFlAIQBaQCAAWmAgAFpAIEBaQCEAQAAAABugIEBbwCAAW+AgAFvAIEBb4CBAW8AhAEAAAAAAAAAAHUAgAF1gIABdQCBAXUAhAF5gIABAAAAAHkAhAFBAIIBYQCCAUEAgwFhAIMBQQCUAWEAlAFDgIABY4CAAUMAgQFjAIEBQ4CDAWOAgwFDAIYBYwCGAUQAhgFkAIYBAAAAAAAAAABFAIIBZQCCAUUAgwFlAIMBRYCDAWWAgwFFAJQBZQCUAUUAhgFlAIYBRwCBAWcAgQFHAIMBZwCDAUeAgwFngIMBR4CTAWeAkwFIAIEBaACBAQAAAAAAAAAASYCBAWmAgQFJAIIBaQCCAUkAgwFpAIMBSQCUAWkAlAFJgIMBAEGoxMQACyxKAIEBagCBAUuAkwFrgJMBAAAAAEyAgAFsgIABTICTAWyAkwFMAIYBbACGAQBB4MTEAAsYToCAAW6AgAFOgJMBboCTAU4AhgFuAIYBAEGExcQAC8wBTwCCAW8AggFPAIMBbwCDAU+AhQFvgIUBAAAAAAAAAABSgIABcoCAAVKAkwFygJMBUgCGAXIAhgFTgIABc4CAAVMAgQFzAIEBU4CTAXOAkwFTAIYBcwCGAVSAkwF0gJMBVACGAXQAhgEAAAAAAAAAAFWAgQF1gIEBVQCCAXUAggFVAIMBdQCDAVUAhQF1AIUBVYCFAXWAhQFVAJQBdQCUAVcAgQF3AIEBWQCBAXkAgQFZAIQBWoCAAXqAgAFagIMBeoCDAVoAhgF6AIYBAEHQx8QACwhPgI0Bb4CNAQBBjMjEAAsIVYCNAXWAjQEAQdDIxAALkAFBAIYBYQCGAUkAhgFpAIYBTwCGAW8AhgFVAIYBdQCGAREAAgMRAP8CEQD8AhEA+QIRAPYCEQDzAhEA8AIRAO0CAAAAABEA6gIRAOcCEQDkAhEA4QLGAIIB5gCCAQAAAAAAAAAARwCGAWcAhgFLAIYBawCGAU8AlAFvAJQBEQDeAhEA2wK3AYYBkgKGAWoAhgEAQezJxAALsAFHgIABZ4CAAQAAAAAAAAAATgCAAW4AgAERANgCEQDVAsaAgAHmgIAB2ICAAfiAgAFBgIcBYYCHAUGAiAFhgIgBRYCHAWWAhwFFgIgBZYCIAUmAhwFpgIcBSYCIAWmAiAFPgIcBb4CHAU+AiAFvgIgBUoCHAXKAhwFSgIgBcoCIAVWAhwF1gIcBVYCIAXWAiAFTAJMBcwCTAVQAkwF0AJMBAAAAAAAAAABIAIYBaACGAQBBtMvEAAs4QYCDAWGAgwFFgJMBZYCTAREA0gIRAM8CEQDMAhEAyQJPgIMBb4CDAREAxgIRAMMCWQCCAXkAggEAQZzMxAALwAPm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA3NgAgNzYAIDc2ACA3NgAgOjYAIDY2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDK2ACAytgAgNzYAIDc2ACA3NgAgNzYAIDK2ACAytgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tkAwObZAMDm2ACA5tkAwObZAMDw2ACA5tgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgNzYAIDc2ACAAAAAAObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA6NgAgNzYAIDc2ACA5tgAgOnYAIDq2ACA6tgAgOnYAIDq2ACA6tgAgOnYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAEHsz8QACwS5AgBAAEGU0MQACwQ7AABAAEGs0MQACy+ogIABkYOAAbcAAECVg4ABl4OAAZmDgAEAAAAAn4OAAQAAAAClg4ABqYOAAREAHgBBwNHEAAsbmQOEAaUDhAGxg4ABtYOAAbeDgAG5g4ABEQAVAEGY0sQACxS5A4QBxQOEAb+DgAHFg4AByYOAAQBBvNLEAAsI0oOAAdIDhAEAQfDTxAALEBUEgAEVBIQBAAAAABOEgAEAQYzUxAALBAYEhAEAQaDUxAALDBqEgAEYBIABIwSDAQBB1NTEAAsEGASDAQBB1NXEAAsEOASDAQBBmNbEAAsQNQSAATUEhAEAAAAAM4SAAQBBtNbEAAsEVgSEAQBByNbEAAsMOoSAATgEgAFDBIMBAEGw18QACwh0hIcBdYSHAQBB2NfEAAsU5tgAgObYAIDm2ACA5tgAgObYAIAAQczZxAALCBYEgwE2BIMBAEGI2sQAC6gBEASDATAEgwEQBIQBMASEAQAAAAAAAAAAFQSDATUEgwEAAAAAAAAAANgEhAHZBIQBFgSEATYEhAEXBIQBNwSEAQAAAAAAAAAAGASCATgEggEYBIQBOASEAR4EhAE+BIQBAAAAAAAAAADoBIQB6QSEAS0EhAFNBIQBIwSCAUMEggEjBIQBQwSEASOEhQFDhIUBJwSEAUcEhAEAAAAAAAAAACsEhAFLBIQBAEH028QAC9wB3NgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA3tgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgN7YAIDk2ACA5tgAgArYAIAL2ACADNgAgA3YAIAO2ACAD9gAgBDYAIAR2ACAEtgAgBPYAIAT2ACAFNgAgBXYAIAW2ACAAAAAABfYAIAAAAAAGNgAgBnYAIAAAAAA5tgAgNzYAIAAAAAAEtgAgABBsN/EAAss5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAe2ACAH9gAgCDYAIAAQfjfxAALFCeGKQMnBioDSAYqAyeGKgNKBioDAEHw4MQAC1Qb2ACAHNgAgB3YAIAe2ACAH9gAgCDYAIAh2ACAItgAgObYAIDm2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIAAQYTixAALBCPYAIAAQcTixAALDNUGKgMAAAAAwQYqAwBBkOPEAAts0gYqAwAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAAAAAAAAAADm2ACA5tgAgAAAAADc2ACA5tgAgObYAIDc2ACAAEHE5MQACwQk2ACAAEHA5cQAC2jm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA5tgAgNzYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA3NgAgObYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgABB/OfEAAsk5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAEHE6MQACwTc2ACAAEGg6cQAC2Dm2ACA5tgAgObYAIDm2ACAAAAAAObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIAAQeTqxAALDNzYAIDc2ACA3NgAgABBgOzEAAsk5tgAgObYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDm2ACAAEGk7cQAC9gB5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAANzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIAb2ACAHNgAgB3YAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACAAEGg8MQACwQoCZ4EAEHA8MQACxAwCZ4EAAAAAAAAAAAzCZ4EAEHs8MQACwQH2ACAAEGk8cQACwQJ2ACAAEG08cQACxDm2ACA3NgAgObYAIDm2ACAAEHQ8cQACyAVCZ5EFgmeRBcJnkQcCZ5EIQmeRCIJnkQrCZ5ELwmeRABB4PPEAAsMB9gAgAAAAAAAAACAAEGa9MQACwrBAgAAvwIJ2ACAAEHL9MQACwGAAEHc9MQACxChCd5EogneRAAAAACvCd5EAEHk9cQACwTm2ACAAEG098QACxAyCh5FAAAAAAAAAAA4Ch5FAEHY98QACwQH2ACAAEGQ+MQACwQJ2ACAAEHA+MQACxgWCh5FFwoeRRwKHkUAAAAAAAAAACsKHkUAQcj6xAALBAfYAIAAQYD7xAALBAnYAIAAQc78xAALAr0CAEHa/MQACwq7AgAAuQIJ2ACAAEGH/cQACwWAAAAAgABBnP3EAAsIIQueRSILnkUAQa7+xAALArcCAEHX/8QACwGAAEGCgMUACw61AgAAswIAALECCdgAgABBt4DFAAsBgABB2IHFAAsERgwrBgBB7IHFAAsECdgAgABBjILFAAsIVNgAgFvYAIAAQbqDxQALCq8CAAAAAAAAAIAAQdaDxQALGq0CAACrAgAAAAAAAKgCAQCoAgAAAAAJ2ACAAEGPhMUACwWAAAAAgABBgIbFAAsQCdgAgAnYAIAAAAAAAAAAgABBuobFAAsOpgIAAKQCAACiAgnYAIAAQe+GxQALAYAAQZCIxQALBAnYAIAAQaeIxQALAYAAQdCIxQALGNkN5QYAAAAAAACfAgEAnwIAAJ0CAAAAgABByIrFAAsMZ9gAgGfYAIAJ2ACAAEH0isUACxBr2ACAa9gAgGvYAIBr2ACAAEHkjMUACwx22ACAdtgAgAnYAIAAQZCNxQALEHrYAIB62ACAetgAgHrYAIAAQfCOxQALCNzYAIDc2ACAAEHkj8UACxTc2ACAAAAAANzYAIAAAAAA2NgAgABBkpDFAAsCm0IAQbqQxQALAplCAEHOkMUACwKXQgBB4pDFAAsClUIAQfaQxQALApNCAEGqkcUACwKRQgBByJHFAAtcgdgAgILYAIAA2QDAhNgAgADZAMCyD8BHAAAAALMPwEcAAAAAgtgAgILYAICC2ACAgtgAgAAAAAAAAAAAgtgAgADZAMDm2ACA5tgAgAnYAIAAAAAA5tgAgObYAIAAQdKSxQALAo9CAEH6ksUACwKNQgBBjpPFAAsCi0IAQaKTxQALAolCAEG2k8UACwKHQgBB6pPFAAsChUIAQYSUxQALBNzYAIAAQe6VxQALAoMCAEGPlsUACwGAAEGslsUACxAH2ACAAAAAAAnYAIAJ2ACAAEHwlsUACwTc2ACAAEH/lsUACzmAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQeOXxQALPYAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQdSYxQALCAnYAIAJ2ACAAEGEmcUACwQJ2ACAAEGwmcUACwTm2ACAAEHYmcUACwTk2ACAAEGAmsUACwze2ACA5tgAgNzYAIAAQaiaxQALCObYAIDc2ACAAEHMmsUAC6QB5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAAAAAAAAAANzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA3NgAgAAAAADc2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgObYAIDm2ACA5tgAgObYAIAAQYqcxQALIoECAAAAAAAAfwIAAAAAAAB9AgAAAAAAAHsCAAAAAAAAeQIAQbacxQALAncCAEHsnMUACwgH2ACAAAAAgABBip3FAAsKdQIAAAAAAABzAgBBnp3FAAsScQIAAG8CAAAAAAAAbQIJ2ACAAEHcncUACyTm2ACA3NgAgObYAIDm2ACA5tgAgAAAAAAAAAAACdgAgAnYAIAAQbCexQALZObYAIDm2ACA5tgAgAAAAAAB2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDm2ACAAAAAAAHYAIAB2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAQaSfxQALBNzYAIAAQbifxQALBObYAIAAQcifxQALCObYAIDm2ACAAEHon8UAC5gG5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgOrYAIDW2ACA3NgAgMrYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA5NgAgOTYAIDc2ACA2tgAgObYAIDp2ACA3NgAgObYAIDc2ACAQYCSAWGAkgFCgIMBYoCDAUKAkQFigJEBQoCYAWKAmAERAGoCEQBnAkSAgwFkgIMBRICRAWSAkQFEgJgBZICYAUSAkwFkgJMBRICWAWSAlgERAGQCEQBhAhEAXgIRAFsCRYCWAWWAlgFFAJgBZQCYAREAWAIRAFUCRoCDAWaAgwFHAIIBZwCCAUiAgwFogIMBSICRAWiAkQFIAIQBaACEAUiAkwFogJMBSACXAWgAlwFJAJgBaQCYAREAUgIRAE8CS4CAAWuAgAFLgJEBa4CRAUuAmAFrgJgBTICRAWyAkQERAEwCEQBJAkyAmAFsgJgBTICWAWyAlgFNgIABbYCAAU2AgwFtgIMBTYCRAW2AkQFOgIMBboCDAU6AkQFugJEBToCYAW6AmAFOgJYBboCWAREARgIRAEMCEQBAAhEAPQIRADoCEQA3AhEANAIRADECUICAAXCAgAFQgIMBcICDAVKAgwFygIMBUoCRAXKAkQERAC4CEQArAlKAmAFygJgBU4CDAXOAgwFTgJEBc4CRAREAKAIRACUCEQAiAhEAHwIRABwCEQAZAlSAgwF0gIMBVICRAXSAkQFUgJgBdICYAVSAlgF0gJYBVQCSAXUAkgFVAJgBdQCYAVWAlgF1gJYBEQAWAhEAEwIRABACEQANAlaAgQF2gIEBVoCRAXaAkQFXAIABdwCAAVeAgAF3gIABVwCEAXcAhAFXgIMBd4CDAVeAkQF3gJEBWICDAXiAgwFYAIQBeACEAVmAgwF5gIMBWgCBAXoAgQFagJEBeoCRAVqAmAF6gJgBaICYAXQAhAF3AIUBeQCFAQAAAAB/gYMBAEGQpsUAC+gCQYCRAWGAkQFBgIQBYYCEAREACgIRAAcCEQAEAhEAAQIRAP4BEQD7AREA+AERAPUBEQDyAREA7wERAOwBEQDpAREA5gERAOMBEQDgAREA3QERANoBEQDXAREA1AERANEBRYCRAWWAkQFFgIQBZYCEAUWAgQFlgIEBEQDOAREAywERAMgBEQDFAREAwgERAL8BEQC8AREAuQERALYBEQCzAUmAhAFpgIQBSYCRAWmAkQFPgJEBb4CRAU+AhAFvgIQBEQCwAREArQERAKoBEQCnAREApAERAKEBEQCeAREAmwERAJgBEQCVAREAkgERAI8BEQCMAREAiQERAIYBEQCDAREAgAERAH0BEQB6AREAdwFVgJEBdYCRAVWAhAF1gIQBEQB0AREAcQERAG4BEQBrAREAaAERAGUBEQBiAREAXwERAFwBEQBZAVkAgAF5AIABWYCRAXmAkQFZgIQBeYCEAVmAgQF5gIEBAEGQqcUAC4QIsYOJAbEDigERAOAAEQDcABEA2AARANQAEQDQABEAzACRg4kBkQOKAREAwgARAL4AEQC6ABEAtgARALIAEQCuALWDiQG1A4oBEQBWAREAUwERAFABEQBNAQAAAAAAAAAAlYOJAZUDigERAEoBEQBHAREARAERAEEBAAAAAAAAAAC3g4kBtwOKAREApAARAKAAEQCcABEAmAARAJQAEQCQAJeDiQGXA4oBEQCGABEAggARAH4AEQB6ABEAdgARAHIAuYOJAbkDigERAD4BEQA7AREAOAERADUBEQAyAREALwGZg4kBmQOKAREALAERACkBEQAmAREAIwERACABEQAdAb+DiQG/A4oBEQAaAREAFwERABQBEQARAQAAAAAAAAAAn4OJAZ8DigERAA4BEQALAREACAERAAUBAAAAAAAAAADFg4kBxQOKAREAAgERAP8AEQD8ABEA+QARAPYAEQDzAAAAAAClA4oBAAAAABEA8AAAAAAAEQDtAAAAAAARAOoAyYOJAckDigERAGgAEQBkABEAYAARAFwAEQBYABEAVACpg4kBqQOKAREASgARAEYAEQBCABEAPgARADoAEQA2ALEDgAGxg4BBtQOAAbWDgEG3A4ABt4OAQbkDgAG5g4BBvwOAAb+DgEHFA4ABxYOAQckDgAHJg4BBAAAAAAAAAAARAOcAEQDkABIA4AASANwAEgDYABIA1AASANAAEgDMABEAyQARAMYAEgDCABIAvgASALoAEgC2ABIAsgASAK4AEQCrABEAqAASAKQAEgCgABIAnAASAJgAEgCUABIAkAARAI0AEQCKABIAhgASAIIAEgB+ABIAegASAHYAEgByABEAbwARAGwAEgBoABIAZAASAGAAEgBcABIAWAASAFQAEQBRABEATgASAEoAEgBGABIAQgASAD4AEgA6ABIANgCxA4MBsQOCAREAMwCxg6IBEQAwAAAAAACxA6EBEQAtAJEDgwGRA4IBkQOAAZGDgEGRg6IBAAAAALkDAEAAAAAAqAChAREAKgC3g6IBEQAnAAAAAAC3A6EBEQAkAJUDgAGVg4BBlwOAAZeDgEGXg6IBvx+AAb+fgAG/H6EBuQODAbkDggERACEAEQAeQAAAAAAAAAAAuQOhAREAGwCZA4MBmQOCAZkDgAGZg4BBAAAAAP4fgAH+n4AB/h+hAcUDgwHFA4IBEQAYABEAFUDBg4kBwQOKAcUDoQERABIApQODAaUDggGlA4ABpYOAQaEDigGoAIABqICAQWAAAEAAAAAAAAAAABEADwDJg6IBEQAMAAAAAADJA6EBEQAJAJ8DgAGfg4BBqQOAAamDgEGpg6IBtAAAQAAAAAAAAAAAAiAAQAMgAEAAQcyxxQALNObYAIDm2ACAAdgAgAHYAIDm2ACA5tgAgObYAIDm2ACAAdgAgAHYAIAB2ACA5tgAgObYAIAAQYyyxQALBObYAIAAQZyyxQALLAHYAIAB2ACA5tgAgNzYAIDm2ACAAdgAgAHYAIDc2ACA3NgAgNzYAIDc2ACAAEHgssUACwSpAwBAAEHwssUACwhLAABAEAAHQABBoLPFAAsIkCGcAZIhnAEAQeCzxQALBJQhnAEAQZi0xQALDNAhnAHUIZwB0iGcAQBBtLTFAAsEAyKcAQBByLTFAAsQCCKcAQAAAAAAAAAACyKcAQBB6LTFAAsMIyKcAQAAAAAlIpwBAEGYtcUACyQ8IpwBAAAAAAAAAABDIpwBAAAAAAAAAABFIpwBAAAAAEginAEAQdS1xQALDD0AnAEAAAAAYSKcAQBBiLbFAAs0TSKcATwAnAE+AJwBZCKcAWUinAEAAAAAAAAAAHIinAFzIpwBAAAAAAAAAAB2IpwBdyKcAQBB1LbFAAsoeiKcAXsinAEAAAAAAAAAAIIinAGDIpwBAAAAAAAAAACGIpwBhyKcAQBBrLfFAAsgoiKcAaginAGpIpwBqyKcAXwinAF9IpwBkSKcAZIinAEAQeS3xQALELIinAGzIpwBtCKcAbUinAEAQZi4xQALCAgwAEAJMABAAEHQuMUACwTdKpxBAEH8uMUACxja2ACA5NgAgOjYAIDe2ACA4NgAgODYAIAAQcS5xQALeEuwTBgAAAAATbBMGAAAAABPsEwYAAAAAFGwTBgAAAAAU7BMGAAAAABVsEwYAAAAAFewTBgAAAAAWbBMGAAAAABbsEwYAAAAAF2wTBgAAAAAX7BMGAAAAABhsEwYAAAAAAAAAABksEwYAAAAAGawTBgAAAAAaLBMGABB1LrFAAs4b7BMGG8wTRgAAAAAcrBMGHIwTRgAAAAAdbBMGHUwTRgAAAAAeLBMGHgwTRgAAAAAe7BMGHswTRgAQZy7xQALBEawTBgAQbC7xQALCAjYAIAI2ACAAEHEu8UACwSdsEwYAEH4u8UAC3irsEwYAAAAAK2wTBgAAAAAr7BMGAAAAACxsEwYAAAAALOwTBgAAAAAtbBMGAAAAAC3sEwYAAAAALmwTBgAAAAAu7BMGAAAAAC9sEwYAAAAAL+wTBgAAAAAwbBMGAAAAAAAAAAAxLBMGAAAAADGsEwYAAAAAMiwTBgAQYi9xQALOM+wTBjPME0YAAAAANKwTBjSME0YAAAAANWwTBjVME0YAAAAANiwTBjYME0YAAAAANuwTBjbME0YAEHQvcUACxymsEwYAAAAAAAAAADvsEwY8LBMGPGwTBjysEwYAEH4vcUACwT9sEwYAEGMvsUAC1Tm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAADm2ACAAAAAAObYAIDm2ACA3NgAgAAAAAAAAAAA5tgAgObYAIAAQfS+xQALRebYAIDm2ACAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQBB7L/FAAvcCf3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMD9/wDA/f8AwP3/AMBIjABA9GYAQMqOAEDIjABA0W4AQDJOAEDlUwBAnJ8AQJyfAEBRWQBA0ZEAQIdVAEBIWQBA9mEAQGl2AECFfwBAP4YAQLqHAED4iABAj5AAQAJqAEAbbQBA2XAAQN5zAEA9hABAapEAQPGZAECCTgBAdVMAQARrAEAbcgBALYYAQB6eAEBQXQBA628AQM2FAEBkiQBAyWIAQNiBAEAfiABAyl4AQBdnAEBqbQBA/HIAQM6QAECGTwBAt1EAQN5SAEDEZABA02oAQBByAEDndgBAAYAAQAaGAEBchgBA740AQDKXAEBvmwBA+p0AQIx4AEB/eQBAoH0AQMmDAEAEkwBAf54AQNaKAEDfWABABF8AQGB8AEB+gABAYnIAQMp4AEDCjABA95YAQNhYAEBiXABAE2oAQNptAEAPbwBAL30AQDd+AEBLlgBA0lIAQIuAAEDcUQBAzFEAQBx6AEC+fQBA8YMAQHWWAECAiwBAz2IAQAJqAED+igBAOU4AQOdbAEASYABAh3MAQHB1AEAXUwBA+3gAQL9PAECpXwBADU4AQMxsAEB4ZQBAIn0AQMNTAEBeWABAAXcAQEmEAECqigBAumsAQLCPAECIbABA/mIAQOWCAECgYwBAZXUAQK5OAEBpUQBAyVEAQIFoAEDnfABAb4IAQNKKAEDPkQBA9VIAQEJUAEBzWQBA7F4AQMVlAED+bwBAKnkAQK2VAEBqmgBAl54AQM6eAECbUgBAxmYAQHdrAEBijwBAdF4AQJBhAEAAYgBAmmQAQCNvAEBJcQBAiXQAQMp5AED0fQBAb4AAQCaPAEDuhABAI5AAQEqTAEAXUgBAo1IAQL1UAEDIcABAwogAQKqKAEDJXgBA9V8AQHtjAECuawBAPnwAQHVzAEDkTgBA+VYAQOdbAEC6XQBAHGAAQLJzAEBpdABAmn8AQEaAAEA0kgBA9pYAQEiXAEAYmABAi08AQK55AEC0kQBAuJYAQOFgAECGTgBA2lAAQO5bAEA/XABAmWUAQAJqAEDOcQBAQnYAQPyEAEB8kABAjZ8AQIhmAEAulgBAiVIAQHtnAEDzZwBAQW0AQJxuAEAJdABAWXUAQGt4AEAQfQBAXpgAQG1RAEAuYgBAeJYAQCtQAEAZXQBA6m0AQCqPAECLXwBARGEAQBdoAECHcwBAhpYAQClSAEAPVABAZVwAQBNmAEBOZwBAqGgAQOVsAEAGdABA4nUAQHl/AEDPiABA4YgAQMyRAEDilgBAP1MAQLpuAEAdVABA0HEAQJh0AED6hQBAo5YAQFecAECfngBAl2cAQMttAEDogQBAy3oAQCB7AECSfABAwHIAQJlwAEBYiwBAwE4AQDaDAEA6UgBAB1IAQKZeAEDTYgBA1nwAQIVbAEAebQBAtGYAQDuPAEBMiABATZYAQIuJAEDTXgBAQFEAQMBVAEAAAAAAAAAAAFpYAEAAAAAAdGYAQAAAAAAAAAAA3lEAQCpzAEDKdgBAPHkAQF55AEBleQBAj3kAQFaXAEC+fABAvX8AQAAAAAAShgBAAAAAAPiKAEAAAAAAAAAAADiQAED9kABAAEHUycUAC8AF75gAQPyYAEAomQBAtJ0AQN6QAEC3lgBArk8AQOdQAEBNUQBAyVIAQORSAEBRUwBAnVUAQAZWAEBoVgBAQFgAQKhYAEBkXABAblwAQJRgAEBoYQBAjmEAQPJhAEBPZQBA4mUAQJFmAECFaABAd20AQBpuAEAibwBAbnEAQCtyAEAidABAkXgAQD55AEBJeQBASHkAQFB5AEBWeQBAXXkAQI15AECOeQBAQHoAQIF6AEDAewBA9H0AQAl+AEBBfgBAcn8AQAWAAEDtgQBAeYIAQHmCAEBXhABAEIkAQJaJAEABiwBAOYsAQNOMAEAIjQBAto8AQDiQAEDjlgBA/5cAQDuYAEB1YABAEADHQxiCAEAAAAAAAAAAACZOAEC1UQBAaFEAQIBPAEBFUQBAgFEAQMdSAED6UgBAnVUAQFVVAECZVQBA4lUAQFpYAECzWABARFkAQFRZAEBiWgBAKFsAQNJeAEDZXgBAaV8AQK1fAEDYYABATmEAQAhhAECOYQBAYGEAQPJhAEA0YgBAxGMAQBxkAEBSZABAVmUAQHRmAEAXZwBAG2cAQFZnAEB5awBAumsAQEFtAEDbbgBAy24AQCJvAEAecABAbnEAQKd3AEA1cgBAr3IAQCpzAEBxdABABnUAQDt1AEAddgBAH3YAQMp2AEDbdgBA9HYAQEp3AEBAdwBAzHgAQLF6AEDAewBAe3wAQFt9AED0fQBAPn8AQAWAAEBSgwBA74MAQHmHAEBBiQBAhokAQJaJAEC/igBA+IoAQMuKAEABiwBA/ooAQO2KAEA5iwBAiosAQAiNAEA4jwBAcpAAQJmRAEB2kgBAfJYAQOOWAEBWlwBA25cAQP+XAEALmABAO5gAQBKbAECcnwBAEADGQxAAxUMQAMRDnTsAQBhAAEA5QABAEADDQxAAwkMQAMFDQ58AQI6fAEAAQcjPxQALDNkF2kIa2ACA8oXbQgBB/M/FAAvYAemF4ELpBeFCEQAEQBEAAUDQhdtC0AXcQtAF3kLRBd5C0gXeQtMF3kLUBd5C1QXeQtYF3kIAAAAA2AXeQtkF3kLaBd5C2wXeQtwF3kIAAAAA3gXeQgAAAADgBd5C4QXeQgAAAADjBd5C5AXeQgAAAADmBd5C5wXeQugF3kLpBd5C6gXeQtWF3ELRhd9C24XfQuSF30IAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgABBi9LFAAsBwABBsNLFAAsEEQC/AwBBzNLFAAsEEQC9AwBBhNPFAAsM3NgAgAAAAADm2ACAAEGw08UACwzm2ACAAdgAgNzYAIAAQczTxQALBAnYAIAAQeTTxQALCObYAIDc2ACAAEGQ1MUACxDm2ACA5tgAgObYAIDm2ACAAEHE1MUACxTm2ACA5tgAgObYAIDm2ACA5tgAgABBhNXFAAsI5tgAgObYAIAAQaTVxQALQNzYAIDc2ACA5tgAgObYAIDm2ACA3NgAgObYAIDc2ACA3NgAgNzYAIAAAAAAAAAAAObYAIDc2ACA5tgAgNzYAIAAQYzWxQALBAnYAIAAQcjWxQALBAnYAIAAQfTWxQALDBEAuwMAAAAAEQC5AwBBrNfFAAsEEQC3AwBB1NfFAAsICdgAgAfYAIAAQfvXxQALAYAAQZTYxQALCAEAtQMBALMDAEGo2MUACwgJ2ACACdgAgABB3NjFAAsECdgAgABBhNnFAAsEB9gAgABBnNnFAAsICdgAgAfYAIAAQcjZxQALCAfYAIAJ2ACAAEH82cUACxAH2ACAB9gAgAAAAAAAAACAAEG42sUACwwBALEDAQCvAwnYAIAAQdzaxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQYTbxQALDAEArQMAAAAAAQCrAwBBsNvFAAsMAQCpAwAAAAABAKcDAEH328UACwGAAEGD3MUACwGAAEGX3MUACx2AAAAAAAAAAAABAKWDAAAAAAEAo4MBAKGDAAAAgABBxNzFAAsUCdgAgAnYAIAAAAAAAAAAAAnYAIAAQeTcxQALBAfYAIAAQY/dxQALAYAAQbfdxQALIYABAJ8DAQCdAwAAAIABAJsDAAAAAAAAAAAJ2ACAB9gAgABBiN7FAAsIAQCZAwEAlwMAQZzexQALCAnYAIAH2ACAAEHg3sUACwgJ2ACAB9gAgABBi9/FAAsBgABBqN/FAAsEAQCVAwBBvN/FAAsICdgAgAnYAIAAQf/fxQALKYAAAACAAQCMgwEAj4MBAJODAQCQgwEAjYMCAJKDAgCPgwIAjIMAAACAAEG84MUACxgJ2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAQYDhxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQcPhxQALDYABAIqDAQCJAwIAiQMAQeThxQALCAbYAIAG2ACAAEGk4sUACwQB2ACAAEHg4sUACzARAIdDEQB4QxIAhEMSAIFDEgB+QxIAe0MSAHhD2NgAgNjYAIAB2ACAAdgAgAHYAIAAQZzjxQALEOLYAIDY2ACA2NgAgNjYAIAAQczjxQALONzYAIDc2ACA3NgAgNzYAIDc2ACAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACAAEGs5MUACxDm2ACA5tgAgObYAIDm2ACAAEHo5MUACxgRAG9DEQBsQxIAdUMSAHJDEgBvQxIAbEMAQbzlxQALDObYAIDm2ACA5tgAgABB9OXFAAuEAebYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgABBqOfFAAss6NgAgOjYAIDc2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIAAQfjnxQALHObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgAfYAIAAQajoxQAL+BA9TgBAOE4AQEFOAEAQAGtDYE8AQK5PAEC7TwBAAlAAQHpQAECZUABA51AAQM9QAECeNABAEABqQ01RAEBUUQBAZFEAQHdRAEAQAGlDuTQAQGdRAECNUQBAEABoQ5dRAECkUQBAzE4AQKxRAEC1UQBAEABnQ/VRAEADUgBA3zQAQDtSAEBGUgBAclIAQHdSAEAVNQBAx1IAQMlSAEDkUgBA+lIAQAVTAEAGUwBAF1MAQElTAEBRUwBAWlMAQHNTAEB9UwBAf1MAQH9TAEB/UwBAEABmQ3BwAEDKUwBA31MAQBAAZUPrUwBA8VMAQAZUAECeVABAOFQAQEhUAEBoVABAolQAQPZUAEAQVQBAU1UAQGNVAECEVQBAhFUAQJlVAECrVQBAs1UAQMJVAEAWVwBABlYAQBdXAEBRVgBAdFYAQAdSAEDuWABAzlcAQPRXAEANWABAi1cAQDJYAEAxWABArFgAQBAAZEPyWABA91gAQAZZAEAaWQBAIlkAQGJZAEAQAGNDEABiQ+xZAEAbWgBAJ1oAQNhZAEBmWgBA7jYAQPw2AEAIWwBAPlsAQD5bAEAQAGFDw1sAQNhbAEDnWwBA81sAQBAAYEP/WwBABlwAQFNfAEAiXABAgTcAQGBcAEBuXABAwFwAQI1cAEAQAF9DQ10AQBAAXkNuXQBAa10AQHxdAEDhXQBA4l0AQC84AED9XQBAKF4AQD1eAEBpXgBAYjgAQBAAXUN8OABAsF4AQLNeAEC2XgBAyl4AQBAAXEP+XgBAEABbQxAAW0MBggBAIl8AQCJfAEDHOABAEABaQxAAWUNiXwBAa18AQOM4AECaXwBAzV8AQNdfAED5XwBAgWAAQDo5AEAcOQBAlGAAQBAAWEPHYABASGEAQExhAEBOYQBATGEAQHphAECOYQBAsmEAQKRhAECvYQBA3mEAQPJhAED2YQBAEGIAQBtiAEBdYgBAsWIAQNRiAEBQYwBAEABXQz1jAED8YgBAaGMAQINjAEDkYwBAEABWQyJkAEDFYwBAqWMAQC46AEBpZABAfmQAQJ1kAEB3ZABAbDoAQE9lAEBsZQBAEABVQ+NlAED4ZgBASWYAQBk7AECRZgBACDsAQOQ6AECSUQBAlVEAQABnAECcZgBArYAAQNlDAEAXZwBAG2cAQCFnAEBeZwBAU2cAQBAAVENJOwBA+mcAQIVnAEBSaABAhWgAQBAAU0OOaABAH2gAQBRpAECdOwBAQmkAQKNpAEDqaQBAqGoAQBAAUkPbagBAGDwAQCFrAEAQAFFDVGsAQE48AEByawBAn2sAQLprAEC7awBAEABQQxAAT0MQAE5DTmwAQBAATUO/bABAzWwAQGdsAEAWbQBAPm0AQHdtAEBBbQBAaW0AQHhtAECFbQBAEABMQzRtAEAvbgBAbm4AQDM9AEDLbgBAx24AQBAAS0P5bQBAbm8AQBAASkMQAElDxm8AQDlwAEAecABAG3AAQJY9AEBKcABAfXAAQHdwAECtcABAEABIQ0VxAEAQAEdDnHEAQBAARkMocgBANXIAQFByAEAQAEVDgHIAQJVyAEAQAERDEABDQ3pzAECLcwBArD4AQKVzAEC4PgBAuD4AQEd0AEBcdABAcXQAQIV0AEDKdABAGz8AQCR1AEAQAEJDPnUAQBAAQUNwdQBAEABAQxB2AEAQAD9DEAA+QxAAPUP8PwBACEAAQPR2AEAQADxDEAA7QxAAOkMQADlDHncAQB93AEAfdwBASncAQDlAAECLdwBARkAAQJZAAEAQADhDTngAQIx4AEDMeABA40AAQBAAN0NWeQBAEAA2QxAANUOPeQBA63kAQC9BAEBAegBASnoAQE96AEAQADRDEAAzQxAAM0PuegBAAkIAQBAAMkPGewBAyXsAQCdCAEAQADFD0nwAQKBCAEDofABA43wAQAB9AEAQADBDY30AQAFDAEDHfQBAAn4AQEV+AEA0QwBAEAAvQxAALkNZQwBAEAAtQ3p/AEAQACxDlX8AQPp/AEAFgABAEAArQxAAKkNggABAEAApQ3CAAEAQAChD1UMAQLKAAEADgQBAC0QAQD6BAEC1WgBAEAAnQxAAJkMQACVDEAAkQwGCAEAEggBAno8AQGtEAECRggBAi4IAQJ2CAECzUgBAsYIAQLOCAEC9ggBA5oIAQBAAI0PlggBAHYMAQGODAECtgwBAI4MAQL2DAEDngwBAV4QAQFODAEDKgwBAzIMAQNyDAEAQACJDEAAhQxAAIEMrRQBA8YQAQPOEAEAWhQBAEAAfQ2SFAEAQAB5DXUUAQGFFAEAQAB1DEAAcQ2tFAEBQhgBAXIYAQGeGAEBphgBAqYYAQIiGAEAOhwBA4oYAQHmHAEAohwBAa4cAQIaHAEDXRQBA4YcAQAGIAED5RQBAYIgAQGOIAEAQABtD14gAQN6IAEA1RgBA+ogAQLs0AEAQABpDEAAZQ75GAEDHRgBAoIoAQO2KAECKiwBAVYwAQBAAGEOrjABAwYwAQBuNAEB3jQBAEAAXQxAAFkPLjQBAvI0AQPCNAEAQABVD1I4AQDiPAEAQABRDEAATQ5SQAEDxkABAEZEAQBAAEkMbkQBAOJIAQNeSAEDYkgBAfJIAQPmTAEAVlABAEAARQ4uVAECVSQBAt5UAQBAAEEPmSQBAw5YAQLJdAEAjlwBAEAAPQxAADkNuSgBAdkoAQOCXAEAQAA1DskoAQBAADEMLmABAC5gAQCmYAEAQAAtD4pgAQDNLAEApmQBAp5kAQMKZAED+mQBAzksAQBAACkMSmwBAQJwAQP2cAEDOTABA7UwAQGedAEAQAAlD+EwAQBAACEMQAAdDEAAGQ7ueAEBWTQBA+Z4AQP6eAEAFnwBAD58AQBafAEA7nwBAEAAFQwBBrPnFAAsbzA8RAEYHAAAAAAAAWB4RAJQXAAAAAAAAAPwCAEHQ+cUAC4kFMAB8AQEAAAAAAwAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogAADcfBEAKgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAAeG4tLVB1bnljb2RlIG92ZXJmbG93cyBzaG91bGQgbm90IGJlIHBvc3NpYmxlIGR1ZSB0byBQVU5ZQ09ERV9FTkNPREVfTUFYX0lOUFVUX0xFTkdUSAAAADR9EQBRAAAAJpcQAFgAAAC7AQAACQAAAC5pbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlAAAAJpcQAFgAAABIAgAAMAAAACaXEABYAAAANAMAAEAAAAAmlxAAWAAAAE4DAAAlAAAAJpcQAFgAAACFAwAAJQAAACaXEABYAAAAmwMAAEQAAAAmlxAAWAAAAHQDAABEAAAAJpcQAFgAAADsBAAALQAAAHgAAABuAAAALQAAAC0AAAAmlxAAWAAAAPAEAAA3AAAAJpcQAFgAAAAXBQAAMgAAACaXEABYAAAAIAUAADsAAAAmlxAAWAAAADsFAAA2AAAAJpcQAFgAAABGBQAAMwAAACaXEABYAAAACgUAACUAAAAmlxAAWAAAANIEAAAvAAAAJpcQAFgAAACYBAAANwAAACaXEABYAAAA7wUAACwAAADOdRAAagAAAF8DAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogY29kZV9wb2ludCA8IHNlbGYuaGVhZGVyLmhpZ2hfc3RhcnQgJiYgc2VsZi5oZWFkZXIuaGlnaF9zdGFydCA+IFNNQUxMX0xJTUlUAAAAw28QAHIAAAAsAQAADQBBgP/FAAuVK/z8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8VFRUVFRUVFRUVFRUVFRUVJSUlJSUlJSUlJSUlJSUlJSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkpPz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/PwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQCAgICAgICAgICAgIIAgIQAgICIAEBAQEBAQEBAQEBAAAQAB/AL8A9wD3APcA9wD3APcA/gA8AXwBjAHLAdUB9wD3ABIC9wD3APcASAKGAsYC+wIsA1YDkAPFA98DHwRdBIsEuwTxBC4FbQWsBesFKgZpBioGqAboBiYHZAekB+QHIwisBWIIhAjDCAIJOAlPCY8JngkNAtsJGQpTCqcF2QjzCAEJFwk3CVIJagmJCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCakJqQmpCaoJqQmpCakJqgmpCakJqQmqCcoJqQmpCaoJqQmpCakJqgmpCakJqQmqCQAAEAAgADAAQABQAGAAcAB/AI8AnwCvAL8AzwDfAO8A9wAHARcBJwH3AAcBFwEnAfcABwEXAScB9wAHARcBJwH+AA4BHgEuATwBTAFcAWwBfAGMAZwBrAGMAZwBrAG8AcsB2wHrAfsB1QHlAfUBBQL3AAcBFwEnAfcABwEXAScBEgIiAjICQgL3AAcBFwEnAfcABwEXAScB9wAHARcBJwFIAlgCaAJ4AoYClgKmArYCxgLWAuYC9gL7AgsDGwMrAywDPANMA1wDVgNmA3YDhgOQA6ADsAPAA8UD1QPlA/UD3wPvA/8DDwQfBC8EPwRPBF0EbQR9BI0EiwSbBKsEuwS7BMsE2wTrBPEEAQURBSEFLgU+BU4FXgVtBX0FjQWdBawFvAXMBdwF6wX7BQsGGwYqBjoGSgZaBmkGeQaJBpkGKgY6BkoGWgaoBrgGyAbYBugG+AYIBxgHJgc2B0YHVgdkB3QHhAeUB6QHtAfEB9QH5Af0BwQIFAgjCDMIQwhTCKwFvAXMBdwFYghyCIIIkgiECJQIpAi0CMMI0wjjCPMIAgkSCSIJMgk4CUgJWAloCU8JXwlvCX8JjwmfCa8JvwmeCa4JvgnOCQ0CHQItAj0C2wnrCfsJCwoZCikKOQpJClMKYwpzCoMKpwW3BccF1wX3APcAPQqTCvcAogobAq8KvQqgBfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcAPQr3APcA9wDNCvcA9wD3APcA9wD3AEAA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDdCiwB9wD3APcA9wD3APcA9wDrCvcAjQX3AI0F9wCNBfcA9wD3APcKegkBC/cAzQoRC/cA9wD3APcA9wD3APcAigX3AKQF9wD3APcA9wD3APcA9wAgCy4LPgv3APcA9wD3APcA9wD3APcATQBrAWsB9wBHC/cA9wD3AFMLYQtuC/cA9wD3AHwBrQH3APcA9wAYAvcA9wB+C6sF9wA/ChgCGgL3AIwL9wD3APcAmgsaAvcA9wA+CqkL9wD3APcA9wD3APcA9wD3APcAaAq5C8IL9wD3APcA9wD3APcA9wD3APcA9wD3APcAfAF8AXwBfAH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDMC9sLTgBOACoB6wtrAfsLCwwXDBwMLAw8DEwM9wBcDFwMXAx8AXwBGwJsDHgMhgwtAZYMawH3APcApAxrAWsBawFrAWsBawFrAbQMawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrATsA9wD3APcAUABrAWUBawFrAWsBawFrAWsBzQr3AFEB9wBrAWsBvAzEDPcA9wD3APcAUQBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsB1AxrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AGsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFIAWsBZAFrAWsBawFrAWsBawH3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA5AzzDPcA9wD3APcA9wD3APcAWQX3APcA9wD3APcA9wB8AXwBawFrAWsBawFrAT4B9wD3AGsB/AxrAWsBawFrAWsBPQBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrATsA9wBrAQwNawEbDSsN9wD3APcA9wD3ADsNQAD3APcA9wD3AMsA9wD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAUsN9wAqAfcA9wD3AGsB9wBbDfcA9wD3AGoBTwD3APcA9wD3APcA9wD3APcA9wD3AGoN9wD3APcA9wD3AE0A9wBMAPcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBrAWsBawFrAfcA9wD3APcA9wD3APcA9wD3AGsBawFrAVsI9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBOAPcA9wD3APcA9wBZBXoN9wD/BfcA9wD3APcA9wAaAmsBawE/APcA9wD3APcA9wDOAPcA9wD3APcA9wD3APcAig33AJYNFQb3APcA9wCcDPcA9wD3APcAiwX3AHwBpg33APcAkAn3AEMKGgL3APcAGQL3APcAsg33APcAqAX3APcAwA3PDdwN9wD3AKEF9wD3APcA7A2sBfcAAQanBfcA9wD3APcA9wD3AC0B9wD3APcA9wD3APcA9wD8DfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wAKDhkOjgKOAiwDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDKQ5rASwDLAMsAywDLAMsAywDOQ6FAIUAOw58Ac0KfAFrAWsBSw5bDiwDLAMsAywDLAMsAywDLANrDnsOMABAAFAAQABQADsA9wD3APcA9wD3APcA9wCLDpsO9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDVAPcA9wD3AGsBawFrAWsBTwFPAUAA9wD3APcA9wCgBfcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCrDsQM9wD3APcA9wD3APcA9wC7DvcA9wD3APcA9wD3APcA9wCOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4Cyw6OAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4C2w6OAo4C6w6OAo4CjgKOAo4CjgKOAo4CjgKOAvsOjgKOAo4CjgICD44CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CLAMsAxIPIg8yD44CPA+OAo4CjgKOAo4CjgKOAo4CjgJMD00PjgKOAlwPjgIsAywDLAP6Ao4CjgKOAiwDAAPgAiwDjgJqD44CjgKOAo4CjgKOAo4CrAX3APcAQgoVAjwBOwB6DxoC9wD3AIYPqwX3APcA9wAZAvcAkQ8XAvcA9wD3AKoFGgL3APcAoQ+AD/cA9wD3AFkFrg+sBfcA9wD3APcA9wD3APcA9wBZBZMJ9wAaAvcA9wACBhsC9wAPAhcC9wD3APcAPwqnDecGjgX3APcA9wBCCkgJWgX3APcA9wD3APcAvQ8pBvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDKDxsCAQb3APcA9wDaDxsC9wBPAfcA9wD3AF0F4gb3APcA9wD3APcAWwXqD/cA9wD3APcA9wD3APcA9wD3APcA9wD3APcAWQVQCvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APYPqgX3APcA9wD3APcA9wD3APcAhQ8bAvcABRD3APcAEhCmBSEQ9wD3AEAKMRD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AEEQ9wD3APcA9wD3AEgKURBgEPcA9wD3APcA9wD3APcAbxDiBvcA9wD3APcAfhD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCMBRoC9wD3ALsO5wajBfcA9wD3APcA9wD3APcAiRCYED8A9wD3APcA9wCgDxYC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AP8FqBD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wAXAvcA9wD3ABUC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AFkF9wD3APcAWQUZAvcA9wD3APcAuBD3APcA9wD3APcA9wD3APcA9wAABsgQ9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAWsBawFrAWsBawFrAWsBawFrAWsBawE7APcAsQ5rAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAT0A9wD3APcA9wB8AXwBrgF8ARUC9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wDmCtUQ4hD3AH8P9wD3APcALgH3AGsBawFrAWsB8hD3APcA9wD3APcA9wD3APcA9wD3APcAawFrAWsBawFrAVsI9wD3APcA9wD3APcA9wD3APcA9wD3APcA1QDLAPcAywD3ANEA9wDRAEwA9wBMAPcAzQD3AM0A9wD/EA0RDRENEXwBfAF8AR0RfAF8Aa8BqAWpBT8Kawr3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wBkCigRNhH3APcA9wD3APcAWQX3APcA9wD3APcA9wD3APcA9wD3ABUC9wD3APcA9wD3APcA9wD3APcA9wD3APcAWgX3APcA9wA+CkER9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wA+CvcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3AP8F9wCOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAlERjgKOAo4CjgKOAo4CXRGOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CLAMsAywDLAMsA44CjgKOAo4CLAMsAywDLAMsA44CjgKOAo4CjgKOAo4CjgKOAo4CjgIsAywDLAMsAywDLAMsAywDLAMsAywDLAMsAywDLAM3Do4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CjgKOAo4CawFrAVABawFrAWsBawFrAWsBPQBtEWoBagFqAWsBOwB9EfcATAD3APcA9wBRAPcA9wD3AMkA9wD3APcA9wD3APcAOwD3APcA9wD3APcA9wD3APcA9wBrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBiBFPAU8BawFrAWsBawFrAWsBawGJEWsBawFrAWsBawHNClABQABQAWsBawFrARQNzQprAWsBFA1rAT4BUAE/APcA9wD3AGsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBawFrAWsBPQA+AU8BUgFrAWsBawGUET8BzQqiEWsBawFrAWsBawFrAWsBawFrAWcBawFrAWsBawFrAbEO9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wD3APcA9wCrEYUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBfAF8AXwBhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIUAhQCFAIQAnAC8ANwA/AAcATwBXAF8AYcBpwG/Ad8B/wEfAj8CXwJ+ApwCsgLSAuICAgMiA0IDYQOBA4EDgQOBA4EDgQOFA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDpQPFA+UDBASBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDIwQ4BFgEeASYBIEDgQO4BNgE7AQGBSYFRAVjBYEFnwW/BdwF9gWBA4EDgQOBA4EDgQOBA4EDgQOBAxYGgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQMlBoEDgQOBA4EDOAaBA0wGgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDawaBA4EDgQOBA4EDgQOLBqAGtQbVBoED6waBAwsHgQOBAysHQQdTB4EDcweIB6EHwQfhB/wHDAgfCD8IWgiBA3oIgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA3oImgi5CLkIuQi5CLkIuQi5CIEDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBA4EDgQOBAxISEhISEhISEggHCAkHEhISEhISEhISEhISEhIHBwcICQoKBAQECgoKCgoDBgMGBgICAgICAgICAgIGCgoKCgoKAEGvqsYACwYKCgoKCgoAQc+qxgALRAoKCgoSEhISEgcSEhISEhISEhISEhISEhISEhISEhISEhISEgYKBAQEBAoKCgoACgoSCgoEBAICCgAKCgoCAAoKCgoKAEGqq8YACwEKAEHKq8YACwEKAEGLrMYAC5wBCgoAAAAAAAoKCgoKCgoKCgoKCgoKAAAKCgoKCgoKCgoKCgoKCgAAAAAACgoKCgoKCgoKAAoKCgoKCgoKCgoKCgoKCgoKEREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREQAAAAAKCgAAAAAAAAAACgAAAAAKCgAKAEHfrcYACwEKAEHprcYACwcRERERERERAEGmrsYAC98FCgAACgoEAREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREQEREQEREQERAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEFBQUFBQUKCg0EBA0GDQoKERERERERERERERENDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERERERERERERERERBQUFBQUFBQUFBQQFBQ0NDRENDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NEREREREREQUKERERERERDQ0REQoRERERDQ0CAgICAgICAgICDQ0NDQ0NDQ0NDQ0NDQ0NDQ0RDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NEREREREREREREREREREREQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERENDQ0NDQ0NDQ0NDQ0NDQ0BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBERERERERERERAQEKCgoKAQEBEQEBAQEBAQEBAQEBAQEBAQEBAQEBAQERERERAREREREREREREQEREREBEREREREBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBERERAQEBAQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NBQUNDQ0NDREREREREREREQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NERERERERERERERERERERERERERERERERBRERERERERERERERERERERERERERERERERERERERAEG8tMYACx0RABEAAAAREREREREREQAAAAARAAAAEREREREREQBB47TGAAsCEREAQYG1xgALAREAQby1xgALEREAAAARERERAAAAAAAAAAARAEHhtcYACwIREQBB8bXGAAsQBAQAAAAAAAAABAAAEQAREQBBurbGAAsVEQAAABERAAAAABERAAAREREAAAARAEHttsYACwYREQAAABEAQf22xgALDRERERERABERAAAAABEAQZ63xgALAhERAEGtt8YACxEEAAAAAAAAAAAREREREREAEQBB+LfGAAsZEQAAEREREQAAAAAAAAAAEQAAAAAAAAAREQBBnLjGAAsCEREAQbq4xgALAREAQfi4xgALAREAQYW5xgALAREAQau5xgALEgoKCgoKCgQKAAAAAAARAAAAEQBB9LnGAAsaEQAREQAAAAAAERERABEREREAAAAAAAAAEREAQZm6xgALAhERAEGvusYACwcKCgoKCgoKAEHCusYACwIREQBB2LrGAAsCEREAQZO7xgALEhERAAAAEREREQAAAAAAAAAAEQBBubvGAAsCEREAQde7xgALAREAQZa8xgALDREAAAAAAAAAERERABEAQdS8xgALHhEAABEREREREREAAAAABAAAAAAAAAAREREREREREQBBo73GAAsMEQAAERERERERERERAEHHvcYACwIREQBB5L3GAAsJEQARABEKCgoKAEGevsYAC2oREREREREREREREREREQAREQAAAAAAEREREREREREREREAERERERERERERERERERERERERERERERERERERERERERERERERAAAAEQAREREREREAEREAABERAAAAAAAAAAAREQAAAAARERERAEGTv8YACx8RAAAREQAAAAAAABEAAAoKCgoKCgoKCgoAAAAAAAAJAEHBv8YACwMREREAQc+/xgALSRERABEREREREREAAAAAAAAABAARAAAKCgoKCgoKCgoKChERERIREREAAAAAEREAAAAAAAAAEQAAAAAAABEREQAAAAAKAAAACgoAQaLAxgALfhERAAARAAAAAAAAEQARERERERERABEAABERERERERERAAAAEREREREREREREQAAEQAAAAARABERERERABEAAAARERERAAAREQAREREAAAAAAAARABERAAAAEQARERERAAAREQAAAAAAAAAAEQARERERERERAAAAABEAAAAREQBBrcHGAAsECgAKCgBBvMHGAAu8AQoKCgkJCQkJCQkJCQkJEhISAAEKCgoKCgoKCgkHCw4QDA8GBAQEBAQKCgoKCgoKCgoKCgYKCgoKCgoKCgoKCgoKCgoJEhISEhISFBUTFhISEhISEgIAAAACAgICAgIDAwoKCgACAgICAgICAgICAwMKCgoABAQEBAQEBAQEBAQEBAQEBAoKAAoKCgoACgoAAAAAAAAKAAoKCgAAAAAACgoKCgAKAAoACgAAAAAEAAoKCgoKAAAAAAAKCgoKAEGBw8YAC28KCgoAAAAACgoDBAoKCgoKCgoKCgoKCgICAgICAgICAgICAgAAAAAKCgoKCgoKCgoKCgoACgoKAAAAAAAKCgoKCgoAAAAAEREAAAAAAAAACgoKCgoKCgoKCgAKCgoKCgkKCgoKAAAACgoKCgoKCgoAQfnDxgALFhEREREAAAoAAAAAAAoKAAAAAAAKCgoAQZjExgALDRERCgoAAAAKCgoKCgoAQa7ExgALAQoAQbvExgALQQoKCgAAAAAAAAAKCgoKAAAAAAAREREKEREREREREREREQoKAAARAAAAEQAAAAARAAAAAAAREQAKCgoKEQAAABERAEGJxcYACwsRAAARERERAAAREQBBncXGAAsNERERERERABERAAAREQBBs8XGAAsrEQAAAAAAAAAAEQAAABEAERERAAAREQAAAAAAEREAAAAAABEAABEAAAAAEQBB68XGAAvoAgERAQEBAQEBAQEBAwEBAQEBAQ0NDQ0NDQ0NDQ0NDQ0NCgoNDQ0NDQ0NDQ0NDQ0NDQ0KCgoGCgYACgYKCgoKCgoKCgoECgoDAwoKCgAKBAQKAAAAAA0NDQ0NDQ0NDQ0NDQ0NDRIACgoEBAQKCgoKCgMGAwYGBAQKCgoEBAAKCgoKCgoKABISEhISEhISEgoKCgoKEhIRAgICAgICAgICAgICAgICAAAAAAAAEREREREAAAAAAAEBAQEBAQEBAQEBAQEBAQoBERERARERAQEBAQERERERAQEBAQEBAQEREREBAQEBEQEBAQEBEREBAQEBAQEBAQEKCgoKCgoKDQ0NDRERERENDQ0NDQ0NDQUFBQUFBQUFBQUNDQ0NDQ0FBQUFBQUFBQUFAQEBAQEBAQEBEREREREKAQUFBQUFBQUFBQUFBQUFBQUBAQEBAQEBAQEBARERAQEBEREREQEBAQEBAQEBAQERAAAREQBB3cjGAAttEREREQAAEREAAAAAAAAAEREREREAERERAAAAAAAAERERERERERERAAARABERAAAAAAAAEQAAABEREREREQARAAAAABEREREAAAAAAAAREQARAAAAEREREREREREAABEAEQAAEREREQAREREREQBB1cnGAAtmEREAEQAREREREREAABERAAAAAAAREREREREAABEREREAERERERERAAAREREAAAAAEREREREREQAREQAAAAAAABEREREREREAERERERERAAAREREREREREQAAERERERERABERABERAEHEysYAC00REREREREAAAARABERABERAAAAEQARAAAAAAAAAAAKCgoKCgoKCgQEBAoKCgoKCgoKCgoKCgoKChEREREREREREREAAAAREREAAAoAEQBBnMvGAAsEEhISEgBBrMvGAAsgEhISEhISEhIREREREQAAEREREREREQAAAAAKChEREQoAQdbLxgALAQoAQeHLxgALNAICAgICAgICAgICAgICAgIRERERERERAAAAABEREREREREREQAAEREREREAEREAEREREREAQaTMxgALWwQRERERERERAQEBAQEBAQEBEREREREREQEBAQEBCgoKCgoKCgoKCgoKCgoKAAICAgICAgICAgICCgoKCgoKCgoAAAAACgoKCgoKCgAAAAAAAAAKCgoKCgoKCgoAQY3NxgALLBISAACBEQDqCQAAAAAAANSUEQC8EQAAAAAAAAAAEQD3AAAAAAAAABABgQMBAEHCzcYAC+1BQAB/AL8A/wAuAW0BrQHlASQCUAKOAs4C3gIeA08DjAO8A/oDOgRKBHsEsgTyBDIFcgWjBc8FDwZEBl4GngbeBh4HVgeNB8oHCQhICIcIxggFCUQJgwnDCQEKPwp/Cr8K/go+C34Lvgv9Cz0MfQy8DPwMOw17DbsN+w07DnkOTAxmDHYMjAysDMsM6AwHDScNJw00DVENcQ2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDYMNgw2DDaMNgw2DDYMNww3DDcMNxA3DDcMNww3EDQAAEAAgADAAQABQAGAAcAB/AI8AnwCvAL8AzwDfAO8A/wAPAR8BLwEuAT4BTgFeAW0BfQGNAZ0BrQG9Ac0B3QHlAfUBBQIVAiQCNAJEAlQCUAJgAnACgAKOAp4CrgK+As4C3gLuAv4C3gLuAv4CDgMeAy4DPgNOA08DXwNvA38DjAOcA6wDvAO8A8wD3APsA/oDCgQaBCoEOgRKBFoEagRKBFoEagR6BHsEiwSbBKsEsgTCBNIE4gTyBAIFEgUiBTIFQgVSBWIFcgWCBZIFogWjBbMFwwXTBc8F3wXvBf8FDwYfBi8GPwZEBlQGZAZ0Bl4GbgZ+Bo4GngauBr4GzgbeBu4G/gYOBx4HLgc+B04HVgdmB3YHhgeNB50HrQe9B8oH2gfqB/oHCQgZCCkIOQhICFgIaAh4CIcIlwinCLcIxgjWCOYI9ggFCRUJJQk1CUQJVAlkCXQJgwmTCaMJswnDCdMJ4wnzCQEKEQohCjEKPwpPCl8Kbwp/Co8KnwqvCr8KzwrfCu8K/goOCx4LLgs+C04LXgtuC34LjgueC64LvgvOC94L7gv9Cw0MHQwtDD0MTQxdDG0MfQyNDJ0MrQy8DMwM3AzsDPwMDA0cDSwNOw1LDVsNaw17DYsNmw2rDbsNyw3bDesN+w0LDhsOKw47DksOWw5rDnkOiQ6ZDqkOowWjBbkOyA7YDugO9w4GDxQPJA9BAEEANA9hAGEARA+jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBVQPZA+jBaMFVA+jBaMFXA9sD+EKowWjBaMFbA+jBaMFowV0D4QPjQ+jBZ0PQQBBAEEAQQBBAK0PvQ+jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBcAPowXQD9UPowWjBaMFowXlD/QPowUEEKMFExCjBSMQZAgzEKMFowWjBUMQURBdECQLbRB9ECQLowWjBY0QowWjBZQQpBCjBasQowWjBaMFowW7EKMFDgXLENsQ6xCjBQ8F+xCjBaMFEQWjBZMQCxEZERkRowUpEaMFowWjBTkRSRFWESQLJAtmEXYRQAYYDRgNGA3JB6MFowWGEZQR2A6jEa8RywejBb8RngajBaMFzRHcEaMFowXsEfgRCBKeBqMFFRIlEkEAQQA1EkUSVRJkEm0SYQBhAHQCgAKAAoACfRKIEmEAdQKAAoACzgLOAs4CzgL/AP8A/wD/AP8A/wD/AP8A/wCYEv8A/wD/AP8A/wD/AKcStxKnEqcStxLHEqcS1xLnEucS5xL3EgYTFhMmEzYTRhNWE2YTdhOFE5MToxOzE8MT0xPjE+MT8hMCFBEUIBQwFEAUThReFG4UfhSOFI4UmxSrFLsUGRHKFNoUGRHmFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU+hQZEQoVGREZERkRGREVFRkR3xTqFCUVGREpFTcVGREZEZ0PGA08FRgNfhR+FH4UTBUZERkRGREZEVgVfhQZERkRGREZERkRGREZERkRGREZERkRwhTIFBkRGRHiFBkRGREZERkRGREZEWgVGREZERkRGREZERkRGREZERkRGREZERkRGREZERkReBWCFX4UZBUZERkRkhXqFJwV6hQZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZEeoU6hTqFOoU6hTqFOoU6hSfFacV6hTqFOoUsBXqFLwV6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hTqFOoU6hQZERkRGRHqFMoVGREZEdcVGRHhFRkRGREZERkRGREZEUEAQQBBAGEAYQBhAPEVABb/AP8A/wD/AP8A/wAPFh4WYQBhAC4WowWjBaMFPhZOFqMFXhZqCGoIaghqCM4CzgJuFnwWjBacFqwWvBYYDRgNGRHdFRkRGREZERkRGRHMFhkRGREZERkRGREZERkRGREZERkRGREZERkR3BYYDRkR7Bb6FgoXGhcBBaMFowWjBaMFKhe9D6MFowWjBaMFORf9BKMFowUBBaMFowWjBaMFDgVJF6MFowUZERkRUxejBRkRYhdOFRkRchd9FBkRGRFOFRkRGRF9FBkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGRGjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFGREZERkRGRGjBW0FowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFEAUZERkRGRFSF6MFowUVEqMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFghejBZIXGA3/AP8AoheyF/8AwhejBaMFowWjBdIX4he9AvIXAhj9AP8A/wD/ABIYIBgwGDYYQBhMGFwYGA1qGHgYowWFGJUYowWjBaMFpRi1GKMFowXBGM0YJAvOAt0YngajBe0YowV2Bf0YowUQBcoHowWjBQ0ZHBksGTwZ8RCjBaMFQxlSGWIZchmjBYIZowWjBaMFkhmiGacZtxnHGdYZuhBqCGEAYQDmGfYZYQBhAGEAYQBhAKMFowUGGiQLowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZcNowUWGqMFowURBSYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJhomGiYaJho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowUPBaMFowWjBaMFowWjBZMQGA0YDUYaUxpiGmwafBqjBaMFowWjBaMFowWKGpca/wSjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBacaGRGjBaMFowWjBQAFowWjBbcaGA0YDccazgLXGs4C5xrzGgMbEhvjCqMFowWjBaMFowWjBaMFIhsyGzAAQABQAGAAQhtSG2IbowVkG6MFDgXVGXQbhBuTG2UIowXhCqMbDwUPBRgNGA2jBaMFowWjBaMFowWjBT4Hsxt+FH4Ulg+OFI4UjhTDG8wbOhXaGxgNGA0ZERkR6hsYDRgNGA0YDRgNGA0YDRgNowUQBaMFowWjBZMJ+hv+G6MFowUGHKMFFRyjBaMFJRyjBTUcowWjBUUcVRwYDRgNQQBBAEIDYQBhAKMFowWjBaMFDwUkC0EAQQBlHGEAbRyjBaMFfRyjBaMFowWBHDUDNQORHJ8crRyjBaMFowWXDaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFXhajBbsQfRwYDb0cgAKAAsIcGA0YDRgNGA3SHKMFowXcHKMF6xyjBfscowUOBQsdGA0YDRgNowUbHaMFKx2jBTsdGA0YDRgNGA2jBaMFowVLHX4UWx1+FH4Uax1OCaMFex0BHIsdowWbHaMFqx0YDRgNux2jBcYd1h2jBaMFowXmHaMF9h2jBQYeowUWHiMeGA0YDRgNGA0YDaMFowWjBaMFlBAYDRgNGA1BAEEAQQAzHmEAYQBhAEMeowWjBVMeJAtjHkEAcx5hAIMeGA0YDRgNGA0YDRgNGA1+FPsbowWjBZMemQ2hHhgNGA32E6MFqx2xHqMFdwXBHhgNowXRHhgNGA2jBeEeGA2jBV4W8R6jBaMFdQUBH1sdER8hH8sHowWjBTEfPx+jBZQQJAtzB6MFTx+FDV8fowWjBW8fywejBaMFfx+OH54frh+5H6MFVAnJH9gf5x8YDRgNGA33H2MIBiCjBaMFMAYWICQLJiBYCGgINSBFIFUgYyAcFHMgowWjBYMgkiCiILEgGA2jBaMFowXBINEg4SCZDRgNowWjBaMF8SAAISQLGA0YDRgNGA0YDRgNGA0YDRgNGA2jBaMFECEfIS4hNiEYDRgNowWjBaMFRiFVISQLZSEYDaMFowV1IYUhJAuVIaEhGA2jBbEhwSHRIV4WGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowXJH+EhGA0YDRgNGA0YDRgNQQBBAGEAYQAjDPEhACIMIqMFHCIsIiQLGA0YDRgNGA08IqMFowVLIlsiGA1rIqMFowV4IocilyKjBaMFcwWnIrUiowWjBaMFowWUEMUiGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowXVIiQLaAijBRAh5SL1IiMMjQ9QBaMFKg4FIxQjGA0YDRgNGA1uCaMFowUkIzMjJAtDI6MFTSNdIyQLGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFbSN9I1UJowWJIywhmSMYDRgNGA0YDRgNkwl+FKkjuCPGI6MFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFkxAYDRgNGA0YDRgNGA2OFI4UjhSOFI4UjhTWI+YjowWjBaMFowWjBaMFowWjBaMFowWjBaMFlw0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFowWjBaMF9iOjBaMFowUGJBYkGxSjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBT4HowWjBaMFowVeFhgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFMQYdJCQLGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFlBCjBQ4FLBmjBaMFowWjBQ4FJAujBQ8FKiSjBaMFowU6JEokWiRoJEEHowUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNeCSjBX0kJAsYDRgNGA0YDRgNGA0YDRgNQQBBAGEAYQB+FI0kGA0YDRgNGA0YDRgNowWjBaMFowUdDp0kniSeJKYktSQYDRgNGA0YDcMk0ySjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBX0cowWjBaMFowWjBaMFowWjBaMFowWjBaMFowW7EBgNlAmUEBgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgN4ySjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWYDZEJGA3zJP8kowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFEQUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFowWjBaMFowWjBT4HEAWUEA8lHyUYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0ZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREkCxkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRzBYYDRgNGA0YDc4CzgJBBs4CGhQZERkRGREZERkRGREZEcwWGA0YDRgNGREZERkRGREZERkRGREZERkRGREZERkRGREZERkR3BYZERkRLyUZERkRGRE6JUclVCUZEWAlGREZERkRPBUYDRkRGREZERkRbiUYDRgNGA0YDRgNGA0YDX4UfiV+FH4lGREZERkRGREZEVIXfhQBHBgNGA0YDRgNGA0YDRgNGA1BALIDYQCOJa4DnBynEkEA3ACeJa4lvCWdHEEAsgNhAMkl1iVhAOQl9CUDJgcmQQDYAGEAQQCyA2EAjiWuA2EApxJBANwAByZBANgAYQBBALIDYQAXJkEAJibrAIoDNiZhAEImQQAiJucAMCbHAGEA7QBBAE4mYQBbJpUhlSGVIRkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRGRHOAs4CzgJrJs4CzgJ2JoMmjyb3E8IEGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNWgKfJq4mGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA1MDr4mzCaAAoACgALcJhgN8xMYDRgNGA0YDRgNGA0YDaMFowUQBewm/CYYDRgNGA0YDRgNGA0YDRgNGA0YDRgNowUMJxgNowWjBTMGHCcYDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDaMFiwckCxgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowUxBiwnGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNPCcOBaMFowWjBaMFowWjBaMFowWjBaMFowWjBUwnGhQYDRgNQQBBANwAYQBcJywZGA0YDRgNGA0YDRgNGA0YDRgNGA2uH34UfhRsJ3wnGA0YDRgNGA2uH34UjCf8GxgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDeQKowWcJ6kntyfHJ9Un3SdnCBEF7CcRBRgNGA0YDfwnGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0ZERkROxUZERkRGREZERkRGRHMFmIXGBEYERgRGRHcFgwoGREZERkRGREZERkRGREZERkRORUYDRgNGA1cFxkR2BsZERkROxVQF9kb3BYYDRgNGA0YDRgNGA0YDRgNGA0ZERkRGREZERkRGREZERkRGREZERkRGREZERkRGREZKBkRGREZERkRGREZERkRGREZERkRGREZERkRKSg6FToVGREZERkRGREZERkRGREqKBkRGREZERkRGRGdDzsV2hs7FRkRGREZEVEXnQ8ZERkRURcZETkVOxXZGxgNGA0YDRkRGREZERkRGREZERkRGREZERkRGREZERkRGREZERkRzBY5FToVNSgZERkRGRFEKFIonQ9QFxkRGREZERkRGREZERkRGREZEWEoGREZERkRGREZESQLowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBRgNGA2jBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZMQowWjBaMFowWjBaMFowWjBaMFowWjBaMFDwWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWZDaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBZMJowWjBaMFowWjBQ8FGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNGA0YDRgNowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBT4HowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFowWjBaMFGA0YDRgNGA0YDXEoGA0GJAYkBiQGJAYkBiQYDRgNGA0YDRgNGA0YDRgNzgLOAs4CzgLOAs4CzgLOAs4CzgLOAs4CzgLOAs4CGA02GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GjYaNho2GoEohACkAMQA5AAEASQBRAFkAYQBoAHAAdoB+gEaAjoCWgJ6ApoCuQLZAvkCGQM5A1kDeQOZA7kDuQO5A7kDuQO5A70DuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQPdA7kD9QMVBDUEVQS5A7kDuQO5A7kDuQO5A7kDuQO5A7kDdQSVBJUElQSVBLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BMUE3wT9BB0FPQVdBX0FnQW9Bd0F/QUXBjcGVwZ3BpcGtwbXBvcGEge5AzIHUgdnB2cHZwdnB24HuQO5A44HuQO5A7kDuQO5A5QHuQO0B2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB8QHZwdnB2cHuQPkB/0HGQi5A7kDuQO5A7kDuQO5A7kDOQi5A7kDWQhnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2oIigihCGcHZwdnB2cHwQhnB2cHZwdnB2cHZwfhCPYIFgk2CVYJdgmWCbYJZwfGCeYJ/QkQCjAKUApnB2kKiQqpCskKlgnpCgkLJAtnB2cHuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A0QLuQO5A7kDuQO5A7kDuQNUC3MLuQO5A7kDuQO5A7kDuQOJC7kDuQO5A7kDuQO5A7kDuQO5A7kDuQO5A7kDlAu5A7MLZwdnB2cHZwe5A7cLZwdnB7kDuQO5A7kDuQO5A7kDuQO5A9cLuQO5A7kDuQO5A7kDuQPsC2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwcMDGcHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHZwdnB2cHtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BLUEtQS1BCwMDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8MFxcXGRcXFxQVFxgXExcXCQkJCQkJCQkJCRcXGBgYFxcBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBARQXFRoWGgICAgICAgICAgICAgICAgICAgICAgICAgICFBgVGA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDBcZGRkZGxcaGwUcGBAbGhsYCwsaAhcXGgsFHQsLCxcBAQEBAQEBAQEBAQEBAQEBAQEBAQEBARgBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICGAICAgICAgICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgEBAgECAQICAQECAQIBAQIBAQECAgEBAQECAQECAQEBAgICAQECAQECAQIBAgEBAgECAgECAQECAQEBAgECAQECAgUBAgICBQUFBQEDAgEDAgEDAgECAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAgEDAgECAQEBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAgICAgICAQECAQECAQIBAQEBAgECAQIBAgECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQICAgICAgICAgICAgICAgICAgICAgICAgICAgQEBAQEBAQEBAQEBAQEBAQaGhoaBAQEBAQEBAQEBAQEGhoaGhoaGhoaGhoaGhoEBAQEBBoaGhoaGhoEGgQaGhoaGhoaGhoaGhoaGhoaGgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYBAgECBBoBAgAABAICAhcBAAAAABoaARcBAQEAAQABAQIBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgECAgEBAQICAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgICAgIBAhgBAgEBAgIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECGwYGBgYGBwcBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAQIBAgECAQIBAgECAQICAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAQIBAgECAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAEFxcXFxcXAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIXEwAAGxsZAAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBhMGFwYGFwYGFwYAAAAAAAAAAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAAAAAFBQUFFxcAQbqPxwAL3gIQEBAQEBAYGBgXFxkXFxsbBgYGBgYGBgYGBgYXEBcXFwUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBAUFBQUFBQUFBQUGBgYGBgYGBgYGBgYGBgYGBgYGBgYJCQkJCQkJCQkJFxcXFwUFBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUXBQYGBgYGBgYQGwYGBgYGBgQEBgYbBgYGBgUFCQkJCQkJCQkJCQUFBRsbBRcXFxcXFxcXFxcXFxcXABAFBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgYAAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBQBBppLHAAueBQkJCQkJCQkJCQkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBgYGBgYGBgYEBBsXFxcEAAAGGRkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBgYGBgQGBgYGBgYGBgYEBgYGBAYGBgYGAAAXFxcXFxcXFxcXFxcXFxcABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgAAFwAFBQUFBQUFBQUFBQAAAAAABQUFBQUFBQUFBQUFBQUFBRoFBQUFBQUAEBAAAAAAAAYGBgYGBgYGBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBhAGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBggFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGCAYFCAgGBgYGBgYGBggICAgGCAgFBgYGBgYGBgUFBQUFBQUFBQUGBhcXCQkJCQkJCQkJCRcEBQUFBQUFBQUFBQUFBQUGCAgABQUFBQUFBQUAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQAAAAUFBQUAAAYFCAgGBgYGAAAICAAACAgGBQAAAAAAAAAACAAAAAAFBQAFBQUGBgAACQkJCQkJCQkJCQUFGRkLCwsLCwsbGQUXBgAGBggABQUFBQUFAAAAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQUABQUABQUAAAYACAgGBgAAAAAGBgAABgYGAAAABgAAAAAAAAAFBQUFAAUAAAAAAAAACQkJCQkJCQkJCQYGBQUFBhcAQc2XxwALTwYGCAAFBQUFBQUFBQUABQUFAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQAFBQAFBQUFBQAABgUICAYGBgYGAAYGCAAICAYAAAUAQauYxwAL9AEFBQYGAAAJCQkJCQkJCQkJFxkAAAAAAAAABQYGBgYGBgAGCAgABQUFBQUFBQUAAAUFAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAUFBQUFBQUABQUABQUFBQUAAAYFCAYGBgYAAAgIAAAICAYAAAAAAAAABgYIAAAAAAUFAAUFBQYGAAAJCQkJCQkJCQkJGwULCwsLCwsAAAAAAAAAAAYFAAUFBQUFBQAAAAUFBQAFBQUFAAAABQUABQAFBQAAAAUFAAAABQUFAAAABQUFBQUFBQUFBQUFAAAAAAgIBggIAAAACAgIAAgICAYAAAUAAAAAAAAIAEGtmscAC40CCQkJCQkJCQkJCQsLCxsbGxsbGxkbAAAAAAAGCAgIBgUFBQUFBQUFAAUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFAAAGBQYGCAgICAAGBgYABgYGBgAAAAAAAAAGBgAFBQUAAAUAAAUFBgYAAAkJCQkJCQkJCQkAAAAAAAAAFwsLCwsLCwsbBQYICBcFBQUFBQUFBQAFBQUABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQUFBQAFBQUFBQAABgUIBggICAgIAAYICAAICAYGAAAAAAAAAAgIAAAAAAAABQUABQUGBgAACQkJCQkJCQkJCQAFBQgAQcacxwAL9AEGBggIBQUFBQUFBQUFAAUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBQgIBgYGBgAICAgACAgIBgUbAAAAAAUFBQgLCwsLCwsLBQUFBgYAAAkJCQkJCQkJCQkLCwsLCwsLCwsbBQUFBQUFAAYICAAFBQUFBQUFBQUFBQUFBQUFBQUAAAAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUFBQUFBQUFAAUAAAUFBQUFBQUAAAAGAAAAAAgICAYGBgAGAAgICAgICAgIAAAAAAAACQkJCQkJCQkJCQAACAgXAEHFnscAC1sFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBQUGBgYGBgYGAAAAABkFBQUFBQUEBgYGBgYGBgYXCQkJCQkJCQkJCRcXAEHEn8cAC18FBQAFAAUFBQUFAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFAAUFBQUFBQUFBQUGBQUGBgYGBgYGBgYFAAAFBQUFBQAEAAYGBgYGBgYACQkJCQkJCQkJCQAABQUFBQBBw6DHAAvZAQUbGxsXFxcXFxcXFxcXFxcXFxcbFxsbGwYGGxsbGxsbCQkJCQkJCQkJCQsLCwsLCwsLCwsbBhsGGwYUFRQVCAgFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUAAAAABgYGBgYGBgYGBgYGBgYIBgYGBgYXBgYFBQUFBQYGBgYGBgYGBgYGAAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgAbGxsbGxsGGxsbGxsbABsbFxcXFxcbGxsbFxcAQcGixwAL0QIFBQUFBQUFBQUFBQgIBgYGCAYGBgYGBggGBggIBgYFCQkJCQkJCQkJCRcXFxcXFwUFBQUFBQgIBgYFBQUFBgYFCAgIBQUICAgICAgIBQUGBgYGBQUFBQUFBQUFBQUGCAgGBggICAgICAYFCAkJCQkJCQkJCQkICAgGGxsBAQEBAQEAAQAAAAAAAQAAAgICAgICAgICAgIXBAICAgUFBQUFBQUFBQAFBQUFAAAFBQUFBQUFAAUABQUFBQAABQUFBQUFBQUFBQUAAAYGBhcXFxcXFxcXFwsLCwsLCwsLCwsLCwsAAAAbGxsbGxsbGxsbAAAAAAAAAQEBAQEBAAACAgICAgIAABMFBQUFBQUFBQUFBQUFBQUbFwUMBQUFBQUFBQUFBQUFBQUFFBUAAAAFBQUFBQUFBQUFBRcXFwoKBQUFBQUFBQUAAAAAAAAABQUGBgYIAEGbpccACwcFBQYGCBcXAEGrpccACwQFBQYGAEG7pccACwQFAAYGAEHLpccAC34FBQUFBgYIBgYGBgYGBggICAgICAYICAYGBgYGBgYXFxcEFxcXGQUGAAALCwsLCwsLCwsLAAAAAAAAFxcXFxcXExcXFxcGBgYQBgUFBQQFBQUFBQUFBQUFBQUAAAAAAAAABQUFBQUGBgUFBQUFBQUFBQYFAAAAAAAFBQUFBQUAQdOmxwALNQYGBggICAgGBggICAAAAAAICAYICAgICAgGBgYAAAAAGwAAABcXCQkJCQkJCQkJCQUFBQUFAEGTp8cAC+gFCQkJCQkJCQkJCQsAAAAbGxsbGxsbGxsbGxsbGxsbBQUFBQUFBQYGCAgGAAAXFwUFBQUFCAYIBgYGBgYGBgAGCAYICAYGBgYGBgYGCAgIBgYGBgYGBgYGBgAABhcXFxcXFxcEFxcXFxcXAAAGBgYGBgYGBgYGBgYGBgcGBQUFBQYIBgYGBgYIBggICAYICAUFBQUFBQUFABcXGxsbGxsbGxsbGwYGBgYGGxsbGxsbGxsbFxcXBQgGBgYGCAgGBggGBgYFBQUFBQUGCAYGCAgIBggGBggIAAAAAAAAAAAXFxcXBQUFBQgICAgICAgIBgYGBggIBgYAAAAXFxcXFwkJCQkJCQkJCQkAAAAFBQUFBQUFBQQEBAQEBBcXAgICAgICAgICAQIAAAAAAAEBAQEBAQEBAQEBAAABAQEXFxcXFxcXFwAAAAAAAAAABgYGFwYGBgYGBgYGBgYGBggGBgYGBgYGBQUFBQYFBQgGBgUAAAAAAAQEBAQEBAQEBAQEAgICAgICAgIEAgICAgICAgECAQIBAgICAgICAgICAQICAgICAgICAQEBAQEBAQECAgICAgIAAAEBAQEBAQAAAgICAgICAgIAAQABAAEAAQICAgICAgICAgICAgICAAACAgICAgICAgMDAwMDAwMDAgICAgIAAgIBAQEBAxoCGhoCAgIAAgIBAQEBAxoaGgICAgIAAAICAQEBAQAaGhoCAgICAgICAgEBAQEBGhoaAAACAgIAAgIBAQEBAxoaAAwMDAwMDAwMDAwMEBAQEBATExMTExMXFxwdFBwcHRQcFxcXFxcXFxcNDhAQEBAQDBcXFxcXFxcXFxwdFxcXFxYXFxcYFBUXFxcXFxcXFxcYFxYXFxcXFxcXFxcXDBAQEBAQABAQEBAQEBAQEBALBAAACwsLCwsLGBgYFBUECwsLCwsLCwsLCxgYGBQVAAQEBAQEBAQEBAQEBAQAAAAZGRkZGRkZGRkZGRkZGRkZAEGKrccACx8GBgYGBgYGBgYGBgYGBwcHBgcHBwYGBgYGBgYGBgYGAEG4rccAC58EGxsBGxsbGwEbGwIBAQECAgEBAQIbARsbGAEBAQEBGxsbGwEbARsBGwEBAQEbAgEBAQECBQUFBQIbGwICAQEYGBgYGAECAgICGxgbGwIbCwsLCwsLCwsLCwsLCwsLCwoKCgoKCgoKCgoKCgoKCgoBAgoKCgoLGxsAAAAAGBgYGBgbGxsbGxgYGxsbGxgbGxgbGxgbGxsbGxsbGBsbGxsbGxsbGxsbGxsbGBgbGxgbGBsbGxsbGxsbGxsbGBgYGBgYGBgYGBgYGBgYGBsbGxsbGxsbFBUUFRsbGxsYGBsbGxsbGxsUFRsbGxsbGxsbGxsbGxgbGxsYGBgYGxsbGxsbGxsbGxsbGBgYGBsbGxsbGxsbGxsbGxsbAAAAAAALCwsLCwsLCwsLCwsbGxsbGxsbGxsbCwsLCwsLGxsbGxsbGxsbGxsbGxsbGBsbGxsbGxsbFBUUFRQVFBULCwsLCwsLCwsLGBgYGBgUFRgYGBgYGBgYGBQVFBUUFRQVFBUUFRQVGBgYGBgYGBgUFRQVGBgYGBgYGBgYGBgYFBUYGBgYGBsbGBgYGBgYGxsbGwAAGxsbGxsbGxsbGwAbGxsbGxsbGxsBAgEBAQICAQIBAgECAQEBAgECAgECAgICAgIEBAEBAgECAhsbGxsbGwECAQIGBgECAAAAAAAXFxcXCxcXAgICAgICAAIAAAAAAAIAAAUFBQUFBQUFAAAAAAAAAAQXAEHlsccACwgGBQUFBQUFBQBB9rHHAAtiFxccHRwdFxcXHB0XHB0XFxcXFxcXExcXExccHRcXHB0UFRQVFBUUFRcXFxcXBBcXFxcXFxcXFxcTExcXFxcTFxQXFxcXFxcXFxcXFxcXGxsXFxcUFRQVFBUUFRMAABsbGxsAQeSyxwALBhsbGxsbGwBB9LLHAAttDBcXFxsEBQoUFRQVFBUUFRsbFBUUFRQVFBUTFBUVGwoKCgoKCgoKCgYGBgYICBMEBAQEBBsbCgoKBAUXGxsFBQUFBQUFAAAGBhoaBAQFBQUFBQUFBQUFBRcEBAQFGxsLCwsLGxsbGxsbGxsbGwBB6rPHAAufAxsbGxsbGxsbGxsbGxsbGwAbGxsbGxsbGwsLCwsLCwsLBQUFBQUFBQUFBQUFBBcXFwkJCQkJCQkJCQkFBQAAAAABAgECAQIBAgECAQIBAgUGBwcHFwYGBgYGBgYGBgYXBAECAQIBAgECAQIBAgQEBgYFBQUFBQUKCgoKCgoKCgoKBgYXFxcXFxcAAAAAAAAAABoaGhoaGhoEBAQEBAQEBAQaGgECAQIBAgECAQIBAgECBAICAgICAgICAQIBAgEBAgECAQIBAgQaGgECAQIFAQIBAgICAQIBAgECAQIBAgEBAQEBAgECAQIBAgECAQIBAQEBAgECAQECAAABAgACAAIBAgECAQIBAAAABAQEAQIFBAQCBQUFBQUGBQUFBgUFBQUGBQUFBQgIBgYIGxsbGwYAAAALCwsLCwsbGxkbAAAAAAAABQUFBRcXFxcAAAAAAAAAAAgIBQUFBQUFBQUFBQUFBQUICAgICAgICAgICAgGBgAAAAAAAAAAFxcGBgUFBQUFBRcXFwUXBQUGBQUFBQUFBgYGBgYGBgYXFwYGCAgAQZS3xwALTRcFBQUGCAgGBgYGCAgGBggIFxcXFxcXFxcXFxcXFwAECQkJCQkJCQkJCQAAAAAXFwUFBQUFBgQFBQUFBQUFBQUGBgYGBgYIBgYICAYGAEHqt8cAC0MFBQUGBQUFBQUFBQUGCAAACQkJCQkJCQkJCQAAFxcXFwQFBQUFBQUbGxsFCAYIBQUGBQYGBgUFBgYFBQUFBQYGBQYFAEG6uMcACxwFBQQXFwUFBQUFBQUFBQUFCAYGCAgXFwUEBAgGAEHfuMcAC3YFBQUFBQUAAAUFBQUFBQACAgICAgICAgICAhoEBAQEAgICAgICAgICBBoaAAAAAAUFBQgIBggIBggIFwgGAAAFBQUFBQUFAAAAAAUFBQUFEhISEhISEhISEhISEhISEhERERERERERERERERERERECAgICAgICAEHeuccAC0QCAgICAgAAAAAABQYFBQUFBQUFBQUYBQUFBQUFBQAFBQUFBQAFAAUFAAUFAAUFBQUFBQUFBQUaGhoaGhoaGhoaGhoaGgBBr7rHAAvsAQUFBQUFBQUFBQUFBQUFFRQFBQUFBQUFBQAAAAAAAAAbBQUFBQUFBQUFBQUFGRsbGxcXFxcXFxcUFRcAAAAAAAAXExMWFhQVFBUUFRQVFBUUFRcXFBUXFxcXFhYWFxcXABcXFxcTFBUUFRQVFxcYExgYGAAXGRcXAAAAAAUFBQUFBQUFBQUFBQUAABAAFxcXGRcXFxQVFxgXExcXAgICAgICAgICAgIUGBUYFBUXFBUXFwUFBQUFBQUFBQUEBQUFBQUFBQUFBQUFBQUFBAQAAAUFBQUFBQAABQUFAAAAGRkYGhsZGQAbGBgYGBsbAEGkvMcACz8QEBAbGwAABQUFBQUFBQUFBQUABQUABRcXFwAAAAALCwsLCwsLCwsKCgoKCgsLCwsbGxsbGxsbGxsbCwsbGxsAQfK8xwALIBsbGxsbGxsbGxsbGxsGAAAGCwsLCwsLCwsLCwsLCwsLAEGbvccAC0gFBQUKBQUFBQUFBQUKAAAAAAAFBQUFBQUGBgYGBgAAAAAABQUFBQUFBQUFBQUFBQUAFwUFBQUAAAAABQUFBQUFBQUXCgoKCgoAQe29xwALIAEBAQEAAAAAAgICAgICAgICAgICAAAAAAUFBQUFBQUFAEGYvscAC80CFwEBAQABAQACAgICAgICAgIAAgICAgICAgICAgICAgACAgICAgICAAICAAAABAQEBAQEAAQEBAQEBAQEBAAAAAAABQUFBQUFAAAFAAUFBQUFBQAFBQAAAAUAAAUFBQUFBQAXCwsLCwsLCwsFBQUFBQUFGxsLCwsLCwsLAAAAAAAAAAsLCwsLCwsLCwUFBQAFBQAAAAAACwsLCwsFBQUFBQULCwsLCwsAAAAXBQUFBQUFBQUFBQAAAAAAFwUFBQUFBQUFAAAAAAsLBQUAAAsLCwsLCwsLCwsLCwsLBQYGBgAGBgAAAAAABgYGBgUFBQUFBQAABgYGAAAAAAYXFxcXFxcXFxcAAAAAAAAABQUFBQUFBQUFBQUFBQsLFwUFBQUFBQUFBQUFBQULCwsFBQUFBQUFBRsFBQUFBQUFBgYAAAAACwsLCwsXFxcXFxcXAEHuwMcACz0FBQUFBQUAAAAXFxcXFxcXBQUFBQUFAAALCwsLCwsLCwUFBQAAAAAACwsLCwsLCwsFBQAAAAAAAAAXFxcXAEG0wccACwoLCwsLCwsLAQEBAEHLwccAC2MCAgIAAAAAAAAACwsLCwsLBQUFBQYGBgYAAAAAAAAAAAkJCQkJCQkJCQkFBQUFBAUBAQEBAQEAAAAGBgYGBhMEAgICAgICAAAAAAAAAAAYGAUFBQUFBQUFBQUABgYTAAAFBQUAQbnCxwALdgsLCwsLCwsFAAAAAAAAAAAGCwsLCxcXFxcXAAAAAAAABQUGBgYGFxcXFwAAAAAAAAUFBQUFCwsLCwsLCwAAAAAIBggFBQUFBQUFBQUFBQUFBgYGBgYGBhcXFxcXFxcAAAsLCwsLCwkJCQkJCQkJCQkGBQUGBgUAQbjDxwALEgYICAgGBgYGCAgGBhcXEBcXBgBB1MPHAAsqEAAABQUFBQUFBQYGBgYGCAYGBhcXFxcFCAgFAAAAAAAAAAAFBQUGFxcFAEGHxMcACz8FBQUICAgGBgYGBgYGBgYIBQUFBRcXFxcGBgYGFwgGCQkJCQkJCQkJCQUXBRcXFwALCwsLCwsLCwsLCwsLCwsAQdHExwALIAUFBQUFBQUFBQUFBQgICAYGCAgGCAYGFxcXFxcXBgUGAEH/xMcAC70BBQUFBQUFBQAFAAUFBQUABQUFBQUFBQUFFwAAAAAAAAgICAYGBgYGBgYGAAAAAAAGBggIAAUFBQUFBQUFAAAFAAUFAAUFBQUFAAYGBQgIBggICAgAAAgIAAAICAgAAAUAAAAAAAAIAAAAAAAFBQUICAAABgYGBgYGBgAAAAUFBQUFBQUFBQUABQAABQAFBQUFBQUABQgICAYGBgYGAAgAAAgACAgICAAICAYIBgUGBRcXABcXAAAAAAAAAAYGAEHJxscAC5kBBQUFBQUICAgGBgYGBgYGBggIBgYGCAYFBQUFFxcXFxcJCQkJCQkJCQkJFxcAFwYFCAgIBgYGBgYGCAYICAgIBggGBgUFFwUAAAAAAAAAAAUFBQUFBQUFBQUFBQUFBQgIBgYGBgAACAgICAYGCAYXFxcXFxcXFxcXFxcXFxcFBQUFBgYAAAgICAYGBgYGBgYGCAgGCAYXFxcFAEHtx8cAC0AXFxcXFxcXFxcXFxcXAAAABQUFBQUFBQUFBQUGCAYICAYGBgYGBggGBRcAAAAAAAAJCQkJCQkJCQkJCQkJCQkJAEG5yMcAC0MFBQUFBQUFBQUFBQAABggGCAgGBgYGCAYGBgYGAAAAAAkJCQkJCQkJCQkLCxcXFxsGBgYGBgYGBggGBhcAAAAACwsLAEGIyccACzMFBQUFBQUFAAAFAAAFBQUFAAUFAAUFBQUFBQUFCAgICAgIAAgIAAAGBggGBQgFCAYXFxcAQcTJxwALJAUFBQUFBQUFAAAFBQUFBQUICAgGBgYGAAAGBggICAgGBRcFCABB88nHAAtNBQYGBgYGBgYGBgYFBQUFBQYGBgYGBggFBgYGBhcXFxcXFxcGAAAAAAAAAAAFBgYGBgYGCAgGBgYFBQUFBgYGBgYGBggGBhcXFwUXFxcAQc3KxwALEhcXFxcXFxcXFxcAAAAAAAAFFwBB7crHAAsWBgYGBgYGBgAGBgYGBgYIBgUXFxcXFwBBjcvHAAsWBgYGBgYGBgYACAYGBgYGBggGBggGBgBBrMvHAAukAQUGBgYGBgYAAAAGAAYGAAYGBgYGBgUGAAAAAAAAAAAFBQUFBQUABQUABQUFBQUFBQUFBQgICAgIAAYGAAgIBggGBQAAAAAAAAAFBQUGBggIFxcAAAAAAAAABgYFCAUFBQUFBQUFBQUFBQgIBgYGBgYAAAAICAkJCQkJCQkJCQkGAAAAAAALCwsLCxsbGxsbGxsbGRkZGxsbGxsbGxsbGxsbGxsbAEHdzMcACxYXCgoKCgoKCgoKCgoKCgoKABcXFxcXAEH+zMcACwMFFxcAQY7NxwALKhAQEBAQEBAQEBAQEBAQEBAGBQUFBQUFBgYGBgYGBgYGBggICAYGBgYGFwBBws3HAAsWBgYGBgYGBhcXFxcXGxsbGwQEBAQXGwBB4s3HAAtuCQkJCQkJCQkJCQALCwsLCwAFBQUFBQUFBQUFBQUFBAQEBQUFBQUFBQUFBQUFBQQEFxcXCwsLCwsLCxcXFxcAAAAAAAUICAgICAgICAgICAgICAgIAAAAAAAAAAYGBgQEBAQEBAQEBAQEBAQXBAYAQdvOxwALAggIAEHrzscACxYEBAQEAAQEBAQEBAQABAQABQUFAAAFAEGLz8cACyAFBQUFAAAAAAAAAAAFBQUFBQUFBQUFAAAbBgYXEBAQEABBt8/HAAtFGxsbGxsbGwAAGxsbGxsbGwgIBgYGGxsbCAgIEBAQEBAQEBAGBgYGBhsbBgYGBgYGBhsbGxsbGxsbGxsGBgYGGxsGBgYbAEGG0McACwQLCwsLAEGW0McAC/MDAgICAgEBAQEBAQEBAQEBAQICAgICAgICAgICAgEAAQEAAAEAAAEBAAABAQEBAAEBAQEBAQICAgIAAgACAgICAQEAAQEBAQAAAQEBAQEAAQEBAQEBAQACAgICAgICAgEBAAEBAQEAAQEBAQEAAQAAAAEBAQEBAQACAgICAgICAgICAgICAgEBAQECAgICAgIAAAEBAQEBAQEBGAICAgICAgICAgICAgICAQEBAQEBAQEBAQEYAgICAgIYAgICAgICAQEBAQEBAQEBGAICAgICAhgCAgICAgIBAgAACQkGBgYGBgYGGxsbGwYGBgYGBgYGBgYGBgYbGxsbGwYbGxsbGxsbGxsbBhsbFxcXFxcAAAAAAgICAgICAgICAgICAgICAAAAAAACAgICAgIAAAAAAAYGBgYGBgYGBgAABgYGBgYABgYABgYGBgYAAAAAAAQEBAQEBAQEBAQEBAQEAAAGBgYGBgYGBAQEBAQEBAAACQkJCQkJCQkJCQAAAAAFGwUFBQUFBQUFBQUFBQUFBgAJCQkJCQkJCQkJAAAAAAAZBQkJCQkJCQkJCQkAAAAAFwUFBQUFBQUABQUFBQAFBQAFBQUFBQAACwsLCwsLCwsLAgICAgYGBgYGBgYEAAAAAAsLCwsLCwsLCwsLCxsLCwsZCwsLCwBBlNTHAAtyCwsLCwsLCwsLCwsLCwsbCwAFBQAFAAAFAAUFBQUFBQUABQUFBQAFAAUAAAAABQAAAAAFAAUABQAFBQUABQUABQAABQAFAAUABQAFBQAFAAAFBQUFAAUFBQUABQUFBQAFAAUFBQAFBQUFBQAFBQUFBRgYAEGU1ccAC2cLCwsLCwsLCwsLCwsLGxsbGxsbGxsbGxsaGhoaGhsbGxsbGxsbAAAAABsbGxsbGxsbGxsAAAAAABsbGxsbGxsAAAAAAAAAGxsbGxsbGxsbGxsbGwAAGxsbABsbGxsbGxsbGxsbGwAQAEGJ1scACzwREREREREREREREREREQAAAAAAwKYRAOQNAAAAAAAAiMIRAJQoAAAAAAAAAAARABgNAAAAAAAAEAFnBwEAQc7WxwALA0AAUwBB5NbHAAsDkwCjAEHw1scAC68F4AAAAAAAAAAPAU0BfQG9AfUBNQJ1AqoC6gIgA14DngPbAxUEUgSRBNAEDwVOBY0FTgXMBQwGSgaIBsgGCAdHBwwGgQejB+IHIQhXCG4IqQi4CNsA9QgvCWkJywTVBe4F+wURBjEGTAZkBoMG7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4F7gXuBe4FowYAABAAIAAwAEAAUABgAHAAUwBjAHMAgwAAABAAIAAwAAAAEAAgADAAAAAQACAAMAAAABAAIAAwAAAAEAAgADAAkwCjALMAwwCjALMAwwDTAAAAEAAgADAAAAAQACAAMADgAPAAAAEQAQAAEAAgADAAAAAQACAAMAAAABAAIAAwAA8BHwEvAT8BTQFdAW0BfQGNAZ0BrQG9Ac0B3QHtAfUBBQIVAiUCNQJFAlUCZQJ1AoUClQKlAqoCugLKAtoC6gL6AgoDGgMgAzADQANQA14DbgN+A44DngOuA74DzgPbA+sD+wMLBBUEJQQ1BEUEUgRiBHIEggSRBKEEsQTBBNAE4ATwBAAFDwUfBS8FPwVOBV4FbgV+BY0FnQWtBb0FTgVeBW4FfgXMBdwF7AX8BQwGHAYsBjwGSgZaBmoGegaIBpgGqAa4BsgG2AboBvgGCAcYBygHOAdHB1cHZwd3BwwGHAYsBjwGgQeRB6EHsQejB7MHwwfTB+IH8gcCCBIIIQgxCEEIUQhXCGcIdwiHCG4IfgiOCJ4IqQi5CMkI2Qi4CMgI2AjoCNsA6wD7AAsB9QgFCRUJJQkvCT8JTwlfCWkJeQmJCZkJywTbBOsE+wQAAAAAhgCpCQAAuAmAAMUJ0wlzAEHM3McACwGGAEGO3ccACzThCQAAsQQAALEEAACxBAAAAAAAAO0JmQj3CQAAAAAFCgAADwIPAg8CDwIPAhUKIAoPAicKAEHQ3ccACwQ3CkUKAEHs3ccAC0ZRCgAAAAAAAF0Kawp4CgAAAAAAAJMAxAAAAAAAAADPAAAAAACICn4AAACIAM8A0QAAAJYKAAAAAAAApArRAAAAAACHALMKAEHE3scACwY0BMMKzAoAQeLexwALFpMAkwCTAJMA1goAAMMFAAAAAAAA5AoAQYTfxwALBZMAkwCAAEGq38cACwNxANEAQbzfxwALAXEAQcrfxwALCpMAkwAAAAAA9AoAQeDfxwALAqoEAEGO4McACwdxAAQLAACFAEGg4McACwHRAEHC4McAC10SCwAAHgsAAA8CDwIPAi4LAAAAAAAAAACvBAAAkwA+CwAAAACqCAAAjADRAAAAAADQAAAAAABKCwAAAAB7AAAAAAD9BVULYgsAAAAAdAAAAAAAAAByC38AAAAlBXoAQbzhxwALAoILAEHg4ccACwFyAEH+4ccACwWTAAAAkwBBnOLHAAsBcQBBvOLHAAsCkAsAQfzixwALAXMAQZrjxwALAYAAQazjxwALApwLAEG+48cACwirCwAAAAC7CwBB1uPHAAsGywvZC+gLAEHu48cACwb2CwYMDQwAQZTkxwALDh0MDwIrDAAAAAAAADMMAEG25McAC3EmBQAAQQwAAAAAhwAAAAAAAABRDBkEYQwAAHEMfwwAAAAAjwyfDAAAAAAAAH8AAAAAAIsAzAAAAAAArwzRAAAAAAC7DH4AAAAAAAAA0AAAAMYMzgAAAAAAAAB9ANEAAAAAANYM9QoAAAAAAABxAOMMfwBBuOXHAAsvcQCtCAAA0QAAAAAAJgWAAAAA3QDOAAAAAAAAAIgAPwtSAbIEAAAAAAAAiwBnCHIAQfLlxwALBPIMTQUAQZLmxwALD/8MgAAlBQAAAAAAAA8NgABBrObHAAsEgQQGBgBBuubHAAsEfwQfDQBB2ObHAAsEcQBmCQBB+ubHAAsDKw19AEGO58cACxq6DIAAAAA6DQAAAABHDXkAVg0AAAAAiQBmDQBB1OfHAAsCdg0AQeDnxwALBpEAhQ2UDQBB9OfHAAsOow0GBgAAAAAAAAAAsg0AQaDoxwALDbAE0QAAAAAAnAtSAXYAQcLoxwALBZMA1QzNAEH86McACwSFAMINAEGe6ccACwnOAAAAAAAAAMwAQdDpxwALC3EAAAAAAAAAcQDQAEHk6ccACwF8AEH46ccACwMkBc8AQabqxwALCZMAkwDFAJMAzABB3OrHAAsKkguQAM8NAAD0CgBB8OrHAAsC4QkAQajrxwALFZMAkwCTANQNkwCTAMYAewB8AIgAkgBB6OvHAAsGMATfDe0NAEH468cACwFxAEGO7McACwHMAEGo7McACwlyAAAAAAAAAIcAQdTsxwALAYcAQfTsxwALAYUAQZDtxwALEMwAAAAAAA8CDwIPAg8C/Q0AQbbtxwALD38AAACTAJMAkwCTAJMAkwBB1u3HAAu+A5MAkwCTAJMAkwCTAJMAkwCTAJMAkwCTAJMAkwCTAAAAeQCJAKEAwADgAAABIAFAAWABawGBAZABsAHPAe8BgQEPAoEBgQGBAYEBgQEhAoEBQQKBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBWwJ7ApoCgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAbkCgQHZAvkCGQOBAYEBgQE5A1QDawOLA6kDyAPmAwQEJARBBFsEgQGBAYEBgQGBAYEBgQGBAYEBgQF4BIEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBhwSBAYEBgQGBAZoEgQGuBIEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAYEBgQGBAc0EgQGBAYEBgQGBAYEBgQHdBPIEDgWBAYEBgQEuBYEBgQFOBWQFdgWBAZUFgQGBAYEBgQGBAYEBgQGBAYEBgQGBAbUFAEGU8scACwEFAEGn8scAC0AFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAEH38scACwcFBQUFBQUFAEG088cACzUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUABQUABQUABQBBofTHAAtQBQUFBQUFBQUFBQUABQAAAAIABAQEBAIEAgQCAgICAgQEBAQCAgICAgICAgICAgICAQICAgICAgIEAgIFBQUFBQUFBQUFBQUFBQUFBQUFBQUAQf/0xwALegICBQQEBAAEBAQCAgICAgICAgQEBAQEBAQEBAQEBAQEBAQEBAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBAICBAQEBAQEBAQEAgQCBAICBAQABAUFBQUFBQUAAAUFBQUFBQAABQUABQUFBQQEAEGD9scACwYCAgIAAAIAQZj2xwALZgUEBQICAgQEBAQEAgICAgQCAgICAgICAgIEAgQCBAICBAUFBQUFBQUFBQUFBQUFBQUAAAQCAgICAgICAgICAgQEBAICAgICAgICAgICAgICAgQEAgICAgQCBAQCAgIEBAICAgICAgBBpPfHAAsLBQUFBQUFBQUFBQUAQb73xwALNAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUFBQUFBQUFBQAAAAAAAAEAAAUAQYj4xwALGAUFBQUABQUFBQUFBQUFAAUFBQAFBQUFBQBBsvjHAAu3AQQCAgICAgQEAgQCAgICAgICAgICBAIEBAQFBQUAAAAAAgACAgICAAQCBAQAAAAAAAQEBAQEBAQEBAQEBAQEBAQBAQECAAACAgICAgQAAAAAAAAAAAUFBQUFBQUFBQICAgICAgICAgIEBAQABAICBAQCAgICAgIEAgICAgICAgICAAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQBBoPrHAAsdBQAFAAAABQUFBQUFBQUAAAAABQAAAAUFBQUFBQUAQcf6xwALAgUFAEHl+scACwEFAEGg+8cACxEFAAAABQUFBQAAAAAAAAAABQBBxfvHAAsCBQUAQeH7xwALBAUABQUAQZ78xwALFQUAAAAFBQAAAAAFBQAABQUFAAAABQBB0fzHAAsGBQUAAAAFAEHh/McACw0FBQUFBQAFBQAAAAAFAEGC/ccACwIFBQBBmv3HAAsIBQUFBQUFAAUAQdz9xwALGQUAAAUFBQUAAAAAAAAAAAUAAAAAAAAABQUAQYD+xwALAgUFAEGe/scACwEFAEHc/scACwEFAEHp/scACwEFAEGc/8cACwUFAAAABQBB2P/HAAsaBQAFBQAAAAAABQUFAAUFBQUAAAAAAAAABQUAQf3/xwALAgUFAEGbgMgACwgFAAAAAAAFBQBBt4DIAAsCBQUAQfKAyAALEgUFAAAABQUFBQAAAAAAAAAABQBBmIHIAAsCBQUAQbaByAALAQUAQfWByAALDQUAAAAAAAAABQUFAAUAQbOCyAALGQUAAAUFBQUFBQUAAAAAAAAABQUFBQUFBQUAQf2CyAALDAUAAAUFBQUFBQUFBQBBoYPIAAsCBQUAQb6DyAALBQUABQAFAEH0g8gAC2oFBQUFBQUFBQUFBQUFBQAFBQAAAAAABQUFBQUFBQUFBQUABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAAABQAFBQUFBQUABQUAAAUFAAAAAAAAAAAFBQAAAAAFBQUFAEHphMgACxEFAAAFBQAAAAAAAAUAAAUFBQBBhYXIAAsKBQUABQUFBQUFBQBBmIXIAAvSAQUAAAAAAAAAAgAAAQUFBQAFAgICAgICAgICAAAAAAAAAAUFAgICAgICAgICBQIAAAAAAAUFBQAAAAAFBQAAAAAAAAAFAAAAAAAABQUFAAAAAAAAAAUFAAAFAAAAAAAABQAFBQUFBQUFAAUAAAUFBQUFBQUFAAAABQUFBQUFBQUFBQAABQAAAAAFAAUFBQUFAAUAAAAFBQUFAAAFBQAFBQUAAAAAAAAFAAUFAAAABQAFBQUFAAAFBQAAAAAAAAAABQAFBQUFBQUFAAAAAAUAAAAFBQBB9YbIAAsTBQABBQUFBQUAAAAAAAUFBQUFBQBBkofIAAszBQUFBQAABQUFAAUFBQUFBQUFBQUAAAUAAAAFAAAAAAUAAAAAAAUFAAAAAAAFAAAAAgIDAEHSh8gACwIFBQBB4YfIAAsPBQAABQUFBQAABQUAAAUFAEH5h8gACysFAAAAAAAAAAAFAAAABQAFBQUAAAUFAAAAAAAFBQAAAAAABQAABQAAAAAFAEGtiMgAC28FBQUAAAAAAAAFBQUFBQAAAAAABQUFAAUFAAAAAAAFBQUFAAAAAAAAAAAFBQUAAAAABQICAgICBAAEAAQEAAADBAQEAgICAgMCAgICAgQCAgQAAAQFBQAAAAACAgICBAIEBAQCAgIEAgIEAgQEAgQAQaqJyAALHQQEBAQCAgADAgICAgICAgICAgICAgICBAIFBQUFAEHQicgACwoFBQUFBQAABAICAEHlicgACxUCAgIEAgICAgICAgICAgICBQICAgQAQYWKyAALFAICAgIEBAICAgICAgICAgIFBQUFAEGjisgACyUCAAICBAQEAAIEBAICBAICAAIEBAIAAAAABAIDAAAAAAUAAAUFAEHSisgAC20FBQUFAAAFBQAAAAAAAAAFBQUFBQAFBQUAAAAAAAAFBQUFBQUFBQUAAAUABQUAAAAAAAAFAAAABQUFBQUFAAUAAAAABQUFBQAAAAAAAAUFAAUAAAAFBQUFBQUFBQAABQAFAAAFBQUFAAUFBQUFAEHKi8gAC2UFBQAFAAUFBQUFBQUFBQUAAAAAAAUFBQUFBQAABQUFBQAFBQUFBQUAAAUFBQAAAAAFBQUFBQUFAAUFAAAAAAAABQUFBQUFBQAFBQUFBQUABQUFBQUFBQUAAAUFBQUFBQAFBQAFBQBBuIzIAAuHAQUFBQUFBQAAAAUABQUABQUAAAAFAAUAAAAAAAAAAAUFBQUFBQUFBQUAAAAFBQUAAAUFBQUFBQUAAAAABQUFBQUFBQUFAAAFBQUFBQAFBQAFBQUFBQAAAAAAAgICAgUFBQUFBQUFAAAAAAAAAEzrEQCkBgAAAAAAAJT4EQAQDgAAAAAAAAACDgBByI3IAAuyROEAgQEBAAAAAAAAAEQGSQYgACcGRAZEBkcGIAA5BkQGSgZHBiAASAYzBkQGRQbpBbwFwgXpBbwFwQVBAAoDyQNCA0UDyQMBA0UDyQMAA0UDxQMIA0IDxQMIAwEDxQMIAwADuQMIA0IDuQMIAwEDuQMIAwADtwNCA0UDtwMBA0UDtwMAA0UDsQNCA0UDsQMBA0UDsQMAA0UDqQMUA0IDRQOpAxMDQgNFA6kDFAMBA0UDqQMTAwEDRQOpAxQDAANFA6kDEwMAA0UDqQMUA0UDqQMTA0UDyQMUA0IDRQPJAxMDQgNFA8kDFAMBA0UDyQMTAwEDRQPJAxQDAANFA8kDEwMAA0UDyQMUA0UDyQMTA0UDlwMUA0IDRQOXAxMDQgNFA5cDFAMBA0UDlwMTAwEDRQOXAxQDAANFA5cDEwMAA0UDlwMUA0UDlwMTA0UDtwMUA0IDRQO3AxMDQgNFA7cDFAMBA0UDtwMTAwEDRQO3AxQDAANFA7cDEwMAA0UDtwMUA0UDtwMTA0UDkQMUA0IDRQORAxMDQgNFA5EDFAMBA0UDkQMTAwEDRQORAxQDAANFA5EDEwMAA0UDkQMUA0UDkQMTA0UDsQMUA0IDRQOxAxMDQgNFA7EDFAMBA0UDsQMTAwEDRQOxAxQDAANFA7EDEwMAA0UDsQMUA0UDsQMTA0UDpQMUA0IDpQMUAwEDpQMUAwADxQMUA0IDxQMTA0IDxQMUAwEDxQMTAwEDxQMUAwADxQMTAwADnwMUAwEDnwMTAwEDnwMUAwADnwMTAwADvwMUAwEDvwMTAwEDvwMUAwADvwMTAwADmQMUA0IDmQMTA0IDmQMUAwEDmQMTAwEDmQMUAwADmQMTAwADuQMUA0IDuQMTA0IDuQMUAwEDuQMTAwEDuQMUAwADuQMTAwADlQMUAwEDlQMTAwEDlQMUAwADlQMTAwADtQMUAwEDtQMTAwEDtQMUAwADtQMTAwADdQAbAyMDVQAbAyMDdQAbAwMDVQAbAwMDdQAbAwkDVQAbAwkDdQAbAwADVQAbAwADdQAbAwEDVQAbAwEDbwAbAyMDTwAbAyMDbwAbAwMDTwAbAwMDbwAbAwkDTwAbAwkDbwAbAwADTwAbAwADbwAbAwEDTwAbAwEDbwAjAwIDTwAjAwIDbwACAwMDTwACAwMDbwACAwkDTwACAwkDbwACAwADTwACAwADbwACAwEDTwACAwEDZQAjAwIDRQAjAwIDZQACAwMDRQACAwMDZQACAwkDRQACAwkDZQACAwADRQACAwADZQACAwEDRQACAwEDYQAjAwYDQQAjAwYDYQAGAwMDQQAGAwMDYQAGAwkDQQAGAwkDYQAGAwADQQAGAwADYQAGAwEDQQAGAwEDYQAjAwIDQQAjAwIDYQACAwMDQQACAwMDYQACAwkDQQACAwkDYQACAwADQQACAwADYQACAwEDQQACAwEDdQAEAwgDVQAEAwgDdQADAwEDVQADAwEDcwAjAwcDUwAjAwcDcwAMAwcDUwAMAwcDcwABAwcDUwABAwcDcgAjAwQDUgAjAwQDbwAEAwEDTwAEAwEDbwAEAwADTwAEAwADbwADAwgDTwADAwgDbwADAwEDTwADAwEDbAAjAwQDTAAjAwQDaQAIAwEDSQAIAwEDZQAnAwYDRQAnAwYDZQAEAwEDRQAEAwEDZQAEAwADRQAEAwADYwAnAwEDQwAnAwEDQhs1Gz8bNRs+GzUbPBs1GzobNRsRGzUbDRs1GwsbNRsJGzUbBxs1GwUbNRslEC4QkA+1D6sPtw+mD7cPoQ+3D5wPtw+SD7cPQA+1D1sPtw9WD7cPUQ+3D0wPtw9CD7cP2Q3fDdkNzw3KDUYNVw1HDT4NRg0+DcYMwgzVDMYM1gzGDNUMvwzVDMYL1wvHC74Lxgu+C5IL1wtHC1cLRws+C0cLVgvHCdcJxwm+CW8ABwMEA08ABwMEA28AAwMEA08AAwMEA28ACAMEA08ACAMEA2EACgMBA0EACgMBA28AKAMEA08AKAMEA2EABwMEA0EABwMEA2EACAMEA0EACAMEA3UACAMAA1UACAMAA3UACAMMA1UACAMMA3UACAMBA1UACAMBA3UACAMEA1UACAMEAwCmApGiAg6iAgWhAs6gAjCbAraVApaUAgqUAhqSAkWRAneNAvqLAi6HAu2FAtKFAt4IAgQIAi9/Aqh8AmZ5Aq54Amd2AtJwArFvAixvAspzAtVsAmttAjZsAjxrApwzApMzArVnAqdnAl8zAqhlAiNlAtpkAj5jAtliAkdiAihiAoZfAoBcAqtbAqdaAnxZAsVWAppWAiZWAh1UAjNRAhlRAvJQAvNQAkRQArhPAqFPAp8hApJMAjZMAhRIAjVHAghGAqtDAmNCAiUFAo4/Al4/AtE+Ah49Arw8Avo6AgsdAo06Aqc4AqM2Am00AsMzAgowAvErAgwrAtQmAtphArgyAjEjApKjAoMhAuYdAuQdAhgbAsgZAuoWAqgWAuQUAmMLAiwKAt+RAksFAhwFAjoGAiIBArrRAWXRAW/RAbnRAWXRAW/RAbrRAWXRAW7RAbnRAWXRAW7RAVjRAWXRAXLRAVjRAWXRAXHRAVjRAWXRAXDRAVjRAWXRAW/RAVjRAWXRAW7RAVfRAWXRAWNtAWdtAWdtAR5hAR5hASBhAR5hASlhAR9hAR5hAR5hAR9hATUZATAZAbkVAa8VAbgVAa8VAbkUAb0UAbkUAbAUAbkUAboUAcITAckTAcITAbgTAcITAcITAZATAckTAYsTAcITAYQTAbsTAYITAckTAUcTAVcTAUcTAT4TATIRAScRATERAScRAaUQAboQAZsQAboQAZkQAboQAdoFAQcDANIFAQcDANN+AtBcAklSAtUzAkQoAkooAu5CAgD2BhIABAMAAAAAAAD+DBIAwwAAAAAAAAAUMFdlFTAUMN1SFTAUMNd2FTAUMFNiFTAUMLlwFTAUMIlbFTAUMIxOFTAUMAlOFTAUMCxnFTCzMLMwezBLMEQASgBNAFIATQBEAE0AQwBXAEMAUABQAFYAUwBTAFMARABNAFYASABWAFcAWgBDAEQAFDBTABUwKABaACkAKABZACkAKABYACkAKABXACkAKABWACkAKABVACkAKABUACkAKABTACkAKABSACkAKABRACkAKABQACkAKABPACkAKABOACkAKABNACkAKABMACkAKABLACkAKABKACkAKABJACkAKABIACkAKABHACkAKABGACkAKABFACkAKABEACkAKABDACkAKABCACkAKABBACkAOQAsADgALAA3ACwANgAsADUALAA0ACwAMwAsADIALAAxACwAMAAsADAALgBEBicGRAYnBlUGRAYnBlQGRAYnBlMGLgAuAC4ALgAuADEGzAYnBkQGLAZEBiAALAZEBicGRAZHBjUGRAZJBkgGMwZEBkUGOQZEBkoGRwYxBjMGSAZEBjUGRAY5BkUGRQYtBkUGLwYnBkMGKAYxBicGRAZEBkcGQgZEBtIGNQZEBtIGRgYsBkoGMwYuBkoGNQZFBkUGOQYsBkUGQwZFBkUGKAYtBkoGQQZFBkoGRQYsBkoGLQYsBkoGLAYtBkoGRgYsBi0GRAYsBkUGRQYuBkoGQwZFBkoGOQZFBkoGRAYtBkUGQgZFBi0GRgYtBkoGQgZFBkoGRQZFBkoGSgZFBkoGSgYsBkoGSgYtBkoGRAZFBkoGRAYsBkoGNgYtBkoGNAYtBkoGNQYtBkoGMwYuBkkGLAZFBkkGLAYtBkkGLAZFBkoGKgZFBkkGKgZFBkoGKgYuBkkGKgYuBkoGKgYsBkkGKgYsBkoGKAYuBkoGRgZFBkkGRgZFBkoGRgYsBkkGRgYsBkUGRgYtBkkGRgYtBkUGRwZFBkUGRwZFBiwGRQYsBi4GRQYuBkUGRQYuBiwGRQYsBi0GRQYtBkoGRQYtBiwGRAZFBi0GRAYuBkUGRAYsBiwGRAYtBkkGRAYtBkoGQgZFBkUGQQYuBkUGOgZFBkkGOgZFBkoGOgZFBkUGOQZFBkkGNwZFBkoGNwZFBkUGNwZFBi0GNgYuBkUGNgYtBkkGNAZFBkUGNAZFBi4GNAYsBkoGNAYtBkUGNQYtBi0GMwZFBkUGMwZFBiwGMwZFBi0GMwYsBkkGMwYsBi0GMwYtBiwGLQZFBkkGLQZFBkoGLAZFBi0GKgZFBi4GKgZFBi0GKgZFBiwGKgYuBkUGKgYtBkUGKgYtBiwGKgYsBkUGOAZFBjQGLgY0BkcGMwZHBjYGMQY1BjEGMwYxBjQGMQY2BkoGNgZJBjUGSgY1BkkGNAZKBjQGSQYzBkoGMwZJBjoGSgY6BkkGOQZKBjkGSQY3BkoGNwZJBkAGUAZRBkAGTwZRBkAGTgZRBkYGRwZDBkQGKwZHBisGRQYqBkcGKAZHBigGRQZKBlQGRwZKBlQGRQZKBi4GRwYsBkYGLgZDBi4GQwYtBkMGLAZCBi0GQQYtBkEGLAY6BiwGNwYtBjYGRQY2BiwGNQYuBigGLAZKBlQGLgZKBlQGLQZKBlQGLAZKBkkGSgYyBkoGMQZGBkoGRgZJBkYGRgZGBjIGRgYxBkUGJwZDBkoGQwZJBkMGJwZCBkoGQgZJBkEGSgZBBkkGKwZKBisGSQYrBkYGKwYyBisGMQYqBkoGKgZJBioGRgYqBjIGKgYxBigGSgYoBkkGKAZGBigGMgZKBlQGSgZKBlQGSQZKBlQGRgZKBlQGMgZKBlQGMQYgAFEGcAYgAFAGUQYgAE8GUQYgAE4GUQYgAE0GUQYgAEwGUQZHBkkGLgYtBisGLAZKBlQG0AZKBlQGyAZKBlQGxgZKBlQGxwZKBlQGSAZKBlQG1QZKBlQGJwbHBnQG0AXcBXQFbQV+BXYFdAVrBXQFZQV0BXYFcwB0AGYAZgBsAGYAZgBpAGcAYQBsADMAMQDlZTMAMADlZTIAOQDlZTIAOADlZTIANwDlZTIANgDlZTIANQDlZTIANADlZTIAMwDlZTIAMgDlZTIAMQDlZTIAMADlZTEAOQDlZTEAOADlZTEANwDlZTEANgDlZTEANQDlZTEANADlZTEAMwDlZTEAMgDlZTEAMQDlZTEAMADlZUEAFSJtAFYAFSJtAFcAYgBTAHYAcwByAFAAUgBQAFAATQBwAC4AbQAuAFAASABtAG8AbABtAGkAbABtAGIAbAB4AGwAbwBnAGwAbgBrAHQASwBNAEsASwBpAG4ASABQAGgAYQBHAHkAZABCAEMAbwAuAEMAFSJrAGcAYwBkAGMAYwBCAHEAYQAuAG0ALgBNAKkDawCpA00AVwBrAFcAvANXAG4AVwBwAFcAawBWALwDVgBuAFYAcABWAG0AcwC8A3MAbgBzAHAAcwByAGEAZAAVInMAMgBHAFAAYQBNAFAAYQBrAFAAYQBtABUicwAyAGsAbQAzAGMAbQAzAG0AbQAzAGsAbQAyAGMAbQAyAG0AbQAyALwDbQBuAG0AZgBtAGsAbABkAGwAbQBsALwDbABUAEgAegBHAEgAegBNAEgAegBrAEgAegBtAGcAvANnALwDRgBuAEYAcABGAGsAYwBhAGwARwBCAE0AQgBLAEIAawBBAG0AQQC8A0EAbgBBAHAAQQAqaA9fGk8+eQ5mu2wnWWNrLWaMVHNeEGJJAFUAZABtADMAZABtADIAcABjAG8AVgBiAGEAcgBBAFUAZABhAGgAUABhADIANAC5cDIAMwC5cDIAMgC5cDIAMQC5cDIAMAC5cDEAOQC5cDEAOAC5cDEANwC5cDEANgC5cDEANQC5cDEANAC5cDEAMwC5cDEAMgC5cDEAMQC5cDEAMAC5cO8wwzDIMOww8zDIMLEwmTDzMOww4DDrMPww1TCZMOsw6zDSMJow/DDqMOkw6jDDMMgw6zDmMKIw8zDkMPww6zDkMPwwyDCZMOEw/DDIMOsw4TCrMJkwyDDzMN8w6jDPMJkw/DDrMN8wrzDtMPMw3jDzMLcw5zDzMN4w6zCvMN4wwzDPMN4wpDDrMN4wpDCvMO0w2zD8MPMw2zD8MOsw2zCaMPMwyDCZMNsw8zDbMJkw6zDIMNswmjCkMPMwyDDYMJkw/DC/MNgwmjD8MLcwmTDYMJow8zC5MNgw6zDEMNgwmjDLMNIw2DCaML0w2DCvML8w/DDrMNUw6TDzMNUwmTDDMLcwpzDrMNUwozD8MMgw1TChMOkwwzDIMJkw0jCZMOsw0jCaMLMw0jCaMK8w6zDSMJowojC5MMgw6zDPMJkw/DDsMOswzzCaMPwwxDDPMJow/DC7MPMwyDDPMKQwxDDOMMMwyDDKMM4wyDCZMOswxjCZMLcwvzCZMPwwuTC7MPMwwTC3MOow8zCvMJkwtTDzMMEw/DDgMLUwpDCvMOswszD8MNswmjCzMOswyjCxMPwwuTCvMO0w/DDNMK8w6zC7MJkwpDDtMK8wmTDpMOAwyDDzMK0w7TDvMMMwyDCtMO0w4TD8MMgw6zCtMO0wrzCZMOkw4DCtMJkw6zC/MJkw/DCtMOUw6jD8MK0wmTDLMPwwrTCZMKswmTCrMJkw8zDeMKswmTDtMPMwqzDtMOow/DCrMOkwwzDIMKswpDDqMKow/DDgMKow8zC5MKgw/DCrMPwwqDC5MK8w/DDIMJkwpjCpMPMwpDDzMMEwpDDLMPMwrzCZMKIw/DDrMKIw8zDYMJowojCiMOsw1TChMKIwzzCaMPwwyDDkToxUTABUAEQAZQBWAGUAcgBnAEgAZwAxADIACGcxADEACGcxADAACGc5AAhnOAAIZzcACGc2AAhnNQAIZzQACGczAAhnNQAwADQAOQA0ADgANAA3ADQANgA0ADUANAA0ADQAMwA0ADIANAAxADQAMAAzADkAMwA4ADMANwAzADYACxFuEQwRbhELEXQRDhFhEbcRABFpERIRYREREWEREBFhEQ8RYREMEWERCxFhEQkRYREHEWERBhFhEQURYREDEWERAhFhEQARYREzADUAMwAzADMAMgBQAFQARQAoAPOBKQAoAOqBKQAoABFPKQAoAG15KQAoAFRTKQAoAMeMKQAoAAFPKQAoAON2KQAoAGZbKQAoAHxUKQAoAONOKQAoALRSKQAoAF15KQAoAKGMKQAoAHlyKQAoAA1UKQAoAD55KQAoAAlnKQAoACpoKQAoAOVlKQAoAB9XKQAoANGRKQAoAChnKQAoADRsKQAoAGtwKQAoAAhnKQAoAEFTKQAoAF1OKQAoAGtRKQAoAANOKQAoAG1RKQAoAJROKQAoANtWKQAoAAlOKQAoAIxOKQAoAABOKQAoAAsRaRESEW4RKQAoAAsRaREMEWURqxEpACgADBFuESkAKAASEWERKQAoABERYREpACgAEBFhESkAKAAPEWERKQAoAA4RYREpACgADBFhESkAKAALEWERKQAoAAkRYREpACgABxFhESkAKAAGEWERKQAoAAURYREpACgAAxFhESkAKAACEWERKQAoAAARYREpACgAEhEpACgAEREpACgAEBEpACgADxEpACgADhEpACgADBEpACgACxEpACgACREpACgABxEpACgABhEpACgABREpACgAAxEpACgAAhEpACgAABEpALMwyDCIMIowPQA9AD0AOgA6AD0AKyIrIisiKyIoAHoAKQAoAHkAKQAoAHgAKQAoAHcAKQAoAHYAKQAoAHUAKQAoAHQAKQAoAHMAKQAoAHIAKQAoAHEAKQAoAHAAKQAoAG8AKQAoAG4AKQAoAG0AKQAoAGwAKQAoAGsAKQAoAGoAKQAoAGkAKQAoAGgAKQAoAGcAKQAoAGYAKQAoAGUAKQAoAGQAKQAoAGMAKQAoAGIAKQAoAGEAKQAyADAALgAxADkALgAxADgALgAxADcALgAxADYALgAxADUALgAxADQALgAxADMALgAxADIALgAxADEALgAxADAALgAoADIAMAApACgAMQA5ACkAKAAxADgAKQAoADEANwApACgAMQA2ACkAKAAxADUAKQAoADEANAApACgAMQAzACkAKAAxADIAKQAoADEAMQApACgAMQAwACkAKAA5ACkAKAA4ACkAKAA3ACkAKAA2ACkAKAA1ACkAKAA0ACkAKAAzACkAKAAyACkAKAAxACkALiIuIi4iMABEIDMAeABpAGkAaQB4AHYAaQBpAGkAaQB2AFgASQBJAEkAWABWAEkASQBJAEkAVgAxAEQgNwBEIDgANQBEIDgAMwBEIDgAMQBEIDgANQBEIDYAMQBEIDYANABEIDUAMwBEIDUAMgBEIDUAMQBEIDUAMgBEIDMAMQBEIDMAMQBEIDEAMAAxAEQgOQBGAEEAWABUAE0AVABFAEwAUwBNAE4AbwCwAEYAYwAvAHUAYwAvAG8AsABDAGEALwBzAGEALwBjAFIAcwAyIDIgMiAyICEAPwA/ACEAIQAhADUgNSA1ICAACAMBAyAACAMAAyAAFANCAyAAFAMBAyAAFAMAAyAAEwNCAyAAEwMBAyAAEwMAAyAACANCA2EAvgKzD3EPgA+yD3EPgA+rDqEOqw6ZDs0Osg5NDjIOSgZ0BkgGdAYnBnQGZQWCBWQAegBEAHoARABaAG4AagBOAGoATgBKAGwAagBMAGoATABKAGQAegAMA0QAegAMA0QAWgAMA7wCbgBsALcATAC3AGkAagBJAEoAMwBEIDQAMQBEIDIAMQBEIDQAZABqAG0AcgBtAGQAbQBjAHcAYwBwAHAAdgBzAHMAcwBkAG0AdgBoAHYAdwB6ABQwcwAVMGEAFSJtAHYAFSJtAHcAYgBzAHYAcAByAHAAcABtAHAAaABrAGsAaABwAGcAeQBkAGIAYwAVImsAZwBiAHEAbQDJA2sAyQNrAHcAvAN3AG4AdwBwAHcAawB2ALwDdgBuAHYAZwBwAGEAbQBwAGEAawBwAGEAdABoAHoAZwBoAHoAbQBoAHoAawBoAHoAvANmAG4AZgBwAGYAawBiAGsAYQBtAGEAvANhAG4AYQBpAHUAbwB2AGEAdQBoAHAAYQBsAHQAZABlAHYAaABnAHAAdABlAGYAYQB4AHQAbQB0AGUAbABzAG0AbgBvALAAZgCwAGMAcgBzAMkDuQPJA0IDuQPJAwEDuQPJAwADuQO3A7kDtwNCA7kDtwMBA7kDtwMAA7kDsQO5A7EDQgO5A7EDAQO5A7EDAAO5A8kDFANCA7kDyQMTA0IDuQPJAxQDAQO5A8kDEwMBA7kDyQMUAwADuQPJAxMDAAO5A8kDFAO5A8kDEwO5A7cDFANCA7kDtwMTA0IDuQO3AxQDAQO5A7cDEwMBA7kDtwMUAwADuQO3AxMDAAO5A7cDFAO5A7cDEwO5A7EDFANCA7kDsQMTA0IDuQOxAxQDAQO5A7EDEwMBA7kDsQMUAwADuQOxAxMDAAO5A7EDFAO5A7EDEwO5AyAAuQMe3wEK3wEI3wEG3wEF3wEE3wFD6QFC6QFB6QFA6QE/6QE+6QE96QE86QE76QE66QE56QE46QE36QE26QE16QE06QEz6QEy6QEx6QEw6QEv6QEu6QEt6QEs6QEr6QEq6QEp6QEo6QEn6QEm6QEl6QEk6QEj6QEi6QF/bgF+bgF9bgF8bgF7bgF6bgF5bgF4bgF3bgF2bgF1bgF0bgFzbgFybgFxbgFwbgFvbgFubgFtbgFsbgFrbgFqbgFpbgFobgFnbgFmbgFlbgFkbgFjbgFibgFhbgFgbgHfGAHeGAHdGAHcGAHbGAHaGAHZGAHYGAHXGAHWGAHVGAHUGAHTGAHSGAHRGAHQGAHPGAHOGAHNGAHMGAHLGAHKGAHJGAHIGAHHGAHGGAHFGAHEGAHDGAHCGAHBGAHAGAGFDQGEDQGDDQGCDQGBDQGADQF/DQF+DQF9DQF8DQF7DQF6DQF5DQF4DQF3DQF2DQF1DQF0DQFzDQFyDQFxDQFwDQHyDAHxDAHwDAHvDAHuDAHtDAHsDAHrDAHqDAHpDAHoDAHnDAHmDAHlDAHkDAHjDAHiDAHhDAHgDAHfDAHeDAHdDAHcDAHbDAHaDAHZDAHYDAHXDAHWDAHVDAHUDAHTDAHSDAHRDAHQDAHPDAHODAHNDAHMDAHLDAHKDAHJDAHIDAHHDAHGDAHFDAHEDAHDDAHCDAHBDAHADAG8BQG7BQG5BQG4BQG3BQG2BQG1BQG0BQGzBQGxBQGwBQGvBQGuBQGtBQGsBQGrBQGqBQGpBQGoBQGnBQGmBQGlBQGkBQGjBQGhBQGgBQGfBQGeBQGdBQGcBQGbBQGaBQGZBQGYBQGXBQH7BAH6BAH5BAH4BAH3BAH2BAH1BAH0BAHzBAHyBAHxBAHwBAHvBAHuBAHtBAHsBAHrBAHqBAHpBAHoBAHnBAHmBAHlBAHkBAHjBAHiBAHhBAHgBAHfBAHeBAHdBAHcBAHbBAHaBAHZBAHYBAFPBAFOBAFNBAFMBAFLBAFKBAFJBAFIBAFHBAFGBAFFBAFEBAFDBAFCBAFBBAFABAE/BAE+BAE9BAE8BAE7BAE6BAE5BAE4BAE3BAE2BAE1BAE0BAEzBAEyBAExBAEwBAEvBAEuBAEtBAEsBAErBAEqBAEpBAEoBAEAAGAPEgCHCQAAAAAAAG4iEgAgAQAAAAAAAAAAQACAAMAAAAE/AX8BvAH8ATsCSwKEAsQCBANEA3oDugP0AzQEdAS0BPQELQVtBacF3AUAABwGTgaNBpsG2wYZB1kHigfABwAIPQh5CLgI9wg1CXQJsQnxCTAKbgqtCu0KKgthC6EL4QsgDGAMoAzfDB4NXQ2dDd0NGg5aDpgOkQurC7kLzwvvCw4MKwxKDKsLqwtqDIcMpwy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DLkMuQy5DEIBAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AAAARABIAEwAT8BTwFfAW8BfwGPAZ8BrwG8AcwB3AHsAfwBDAIcAiwCOwJLAlsCawJLAlsCawJ7AoQClAKkArQCxALUAuQC9AIEAxQDJAM0A0QDVANkA3QDegOKA5oDqgO6A8oD2gPqA/QDBAQUBCQENAREBFQEZAR0BIQElASkBLQExATUBOQE9AQEBRQFJAUtBT0FTQVdBW0FfQWNBZ0FpwW3BccF1wXcBewF/AUMBgAAEAAgADAAHAYsBjwGTAZOBl4GbgZ+Bo0GnQatBr0GmwarBrsGywbbBusG+wYLBxkHKQc5B0kHWQdpB3kHiQeKB5oHqge6B8AH0AfgB/AHAAgQCCAIMAg9CE0IXQhtCHkIiQiZCKkIuAjICNgI6Aj3CAcJFwknCTUJRQlVCWUJdAmECZQJpAmxCcEJ0QnhCfEJAQoRCiEKMApAClAKYApuCn4KjgqeCq0KvQrNCt0K7Qr9Cg0LHQsqCzoLSgtaC2ELcQuBC5ELoQuxC8EL0QvhC/ELAQwRDCAMMAxADFAMYAxwDIAMkAygDLAMwAzQDN8M7wz/DA8NHg0uDT4NTg1dDW0NfQ2NDZ0NrQ29Dc0N3Q3tDf0NDQ4aDioOOg5KDloOag56DooOmA6oDrgOyA4AAAAA2A7nDgAAAAAAAAAA8g4AAAIPEg8iDwAAAAAyDwBBhNLIAAtDPw9OD1gPAAAAAGAPaA91DwAAAAAAAAAAfA+MDwAAAAB8DwAAAACED78LUQcAAAAAAAC/CwAAAAAAAJwPAABzAAAAdgBB0tLIAAsCrA8AQZTTyAALAwwFcwBBotPIAAsldwAAALwPAADLDwAAfABLB9sPAAAAAAAA6w8AAPkPdgB2AAkQdgBB0tPIAAvWAncAAAAAABkQAAAAAAAAAAB6AAAAcQB0ACkQmAoAAHIAewAAAAAAdAAAAHYAbAwAAAAAORAAAAAAAABxAEkQVBB2AHYAcgBkEHMQgQCBAIEAgxCSEAAAnhCuEAAAvBCmBwAAAADMEAAAAAAAADYI2hAAAAAAAADmEG0MAAAAAAAA9hAGERYRJhF4ADYRRhFUEQAAAABkEXQRhBGUEaQRrxEAALgRyBHYEegR+BHEAgISEhIiEjISQhJSEmISchKCEpISohKyEsIS0hLiEvISAhMSEyITMhNCE1ITYhNyE4ITkhOiE7ITwhPSE+IT8hMCFBIUIhQuFD4UTRRXFGcUdxSHFJcUpxQAAH8AtxTGFNYU5hT2FAYVFRUlFTUVRRVFFVUVZRVxFQAAgBUAAAAAAACQFQAAnRWtFbwVAADMFdwV7BUAAPYVAAAAAAAABhYAAAAAAAAUFgBBwtbIAAsadgCBAHUAgQAkFjQWRBZMFlwWbBZLAEEAfBYAQf7WyAALAocWAEGM18gACwKUFgBBmNfIAAsCmxYAQazXyAALBtgIAABSBwBBvtfIAAtAqxa7FssWAAAAAAAA2xbrFvsWCxcbFysXOxdLF1sXahcAAAAAdBcAAAAAAACEF5QXAAB5AJsImwibCJsIxALEAgBBiNjIAAsKcgCBAIEAAACkFwBBnNjIAAuiAbQXxBfUF+QX9BcEGBQYJBg0GEQYVBhkGHQYhBiUGIEAgQCkGAAAqhi6GMoY2hjqGPoYAAAIGRgZKBk4GUgZAABWGXgFAAAAAGYZdhmGGZYZphm2GcYZAAAAAAAAAAB6AAAA1hnmGfYZBhoWGiYaNhpGGlYaZhp2GoYalhqmGrYaxhrWGuYa9hoGGxYbJhs2G0YbVhtmG3YbhhuWG6YbthvGGwBBztnIAAsJcwAAAAAAAAB5AEH+2cgACxB0AIEA1hvmG/YbBhwWHCYcAEGY2sgACzE0HAAAAABEHFMcYxxzHIMckRyhHLEcwRzRHOEc8RyBAP8c9Q8AAAkddgAAAAAAAAB4AEHS2sgACzQZHXYAxAKoBwAAAAAnHQAAAAA1HQAAcwAAAAAAAAA5CEUdjgUAAHEAAAAAAAAAeQByADoMAEGQ28gAC6UDVR1lHaIFAAB1HYQdmwWbCAAAAACUHaQdtB3EHdQd5B30HQAAAAAEHnYAFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHhQeFB4UHiAeAACRBQAAAAB0AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQAwHkAeUB5gHnAegB6QHqAesB7AHtAe4B7wHgAfEB8gHzAfQB9QH2AfcB+AH5AfoB+wH8Af0B/gH/AfACCBAIEAECAdIC0gPSBNIF0gayB5IIcglSClILUgfQDFINUg5SD1IAUhFSElITUhRSFVIWUhdSGFIZUhpSG1IcUh1SHlIfUhBSIVIiUiAAA1IkQiUyJjInMigyKTIqMigQCBALMiwyLTIuMi8yIDIxMjIyMzI0MjUiNhI3AjfyOOI50jrCO8I8wj3CPsI/wjDCQcJCwktRo8JEwkXCRrJHskiySaJEwHAABRB6okcgByAIEAgQBBxN7IAAtodQC5JAAAAABzDAAAAAAAAAAAcQBzAH8AgQCBAAAAAADAJIEAgQCBAIEAgQCBAIEAgQAAAHMAAAAAAAAAfwD7BXQAAAAAAGgJAAB1AAAAAADQJAAASgcAAAAA4CR6AIEAgQDwJAAlECUAQbjfyAALLXIAdgAgJTAlQCUAAHQAAAAAAHgAAAAAAAAAngVQJWAlcCVWB34ljiUAAJolfABBjODIAAtleQAAAHoAeACBAKkluSXJJdklgQCBAIEAgQDpJQAAAADzJQAAUgcAAAAAAABxAHYFgQCBAIEAAAACJgAAawwAAHoHgQCBAIEAgQAAAAAAAACQBQAACwUAAAAADiZ+CQAAHiZ3AHcAQfrgyAALK4EAgQAAAAAALiZ5AAAAAAAAAHEMAAA+DAAAgQcAADwmpAWBAIEAgQCBAIEAQa7hyAALa3cAgQCBAIEATCZcJmwmfCYAAAAAAADgCQAAAACMJnYAAACcJqwmAABiCoEAgQCBAIEAgQCBAIEAAABxAAAAAAC6Jn4A0AyBAIEAyCYAAAAAeAAAANgm5yaBAAAA9yaBAIEAAAB0AIEAAAB5AEGi4sgAC3cHJwsFAAAXJwAAJyc0J0AnfQAAAHcAdgCnBwAATideJ3gAAAAAAGsnAAAAAAAAAAB7JwAADAV7AAAAVgcAAIYnfgCBAIEAgQCPJ0oHdgAAAAAAAACeJ3YAeQiJCE8Hrie9J80n2ifiJ/InAigAAAwoGygqKDAogQBBouPIAAvNAUAoRx1+AIEAAAAAAAAAUChfKHYAgQCBAIEAgQCBAIEAgQCBAIEAgQAAAAAAbyh/KI8ocgCBAIEAAAAAAAAADQx7AHYAcwCBAAAAAAAAAJkodgAAAHwAgQAAADkMqSgAAHkAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAAAALkogQCBAIEAgQCBAIEAySjZKAAAAAAAANIL6Sj1KAAABSlrJ3YAgQCBAIEAgQA8DAAAAAA8DBMpgQAAAAAAAAAjKSwpAAAAAAAAAADyD30AQfjkyAALmAF3AHYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAB+AHYATwcAAAAAPCl6AAAAcwAAAAAACwVQB3kAgQCBAIEAgQCeCQAAAABMKVspdgBrKQAAcQB5KXYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAdwAAAFcHAABsDO8OdQCBAIEAgQCBAIEAfwAAAAAAAAAxKABBwubIAAsNdgCBAIEAgQCBAIEAgQBB3ObIAAsDcQB7AEH45sgACzN8AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQbjnyAALDX0AAAAAAAAAgQAAAHoAQYToyAALAXUAQY7oyAAL4QF5AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAiSmYKXYAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAAAAAAAAdwAAAHEAjgUAAAAAAAAAAHEAdgAAAHIAqCkAAAAAAAC4KXoATgdWB3wHAACBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAAAAAMEpdgCBAIEAgQCBAIEAgQCBAIEA0SnhKQAAAAAAAHUAgQCBAIEAgQCBAIEAQfjpyAALGI0FAAAAAAAA2wkAAIEAgQCBAIEAewDxKQBBzurIAAsBeABB6urIAAtIegCBAMIJdwCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAJkJAEHW68gACwp9AL8JgQABKg0qAEH+68gACyF0AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQazsyAALM3UAcwB3AB0qLSqBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQBB+uzIAAsGOwBLAD0qAEGg7cgACxN8AIEAgQCBAIEAAAAAAHIAAAB5AEHC7cgACwd8AIEAgQCBAEHo7cgACyF6AAAAAAA9DAAAAABNKl0qayp4KgAAhCqSKqIqAAB1AIEAQZLuyAALF7AqgQCBAIEAgQCBAIEAgQAAAHwAAAB8AEG07sgAC5YBeQAAAHcAgQCBAIEAgQCBAIEAgQCBAEEAwCpHAMYq1irmKsIqSQDIKvIqAisSKyIrQQDAKkcALis+K0MAKitOK14r2CpFAMQqSwBBAMAqRwDGKtYqQwDCKkkAyCrYKkUAxCpLAEEAwCpHAG4rfiuOK54rriuEK5QrpCt6K4ormiuqK4ArVQOgK1UDhiuWK74rzivUK9ArAEHa78gAC6MCdACiBQwFgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAABxAOQrgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQD0K/wrCiwaLCosOixKLIEAWCyBAIEAgQCBAIEAgQCBAAAAAABzAGcsjgWBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAADoCIEAAAAAALgCegeBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAdyx2AIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAAABwBo0FgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAhyxxAEGW8sgAC58BTwqXLIEAgQCnLLcsxywAANMsjgWBAIEAgQCBAIEAgQCBAIEAgQCBAAwFAAAAAAAAewCBAIEAgQCBAAwFAAAAAHIAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEA4yzzLAMtEy0hLTEtQS1RLWEtcS2ALXEtgQCBAIEAfgCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAAAAAAB0AEHC88gAC018AHEADAUMBQwFAAB6AJAtWBagLUEAsC0AAMAtAAAAANAtcgCBAIEAgQB3BQAA4C3wLQAuEC4gLjAuegCBAIEAgQCBAIEAgQCBAIEAgQBBsPTIAAsFkAVzAHMAQcT0yAALApEFAEHQ9MgACyV2AHQAfwB0AAAAAAAAAHgAdgAAAAAAeAAAAHIAdAB+AIEAgQCBAEGW9cgACxV8AHIAcwB6BwAAAAAAANwJTwZ2AHcAQb71yAALAlUHAEHK9cgACwI9KgBB6PXIAAsDgQCBAEGS9sgACwF2AEGs9sgACwFyAEHq9sgACwF+AEGo98gACwF/AEG098gAC7UBcgCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAQC5QLmAucC6ALpAuoC6wLsAu0C7gLvAuAC8QLyAvMC9AL1AvYC9wL4AvkC+gL7AvwC/QL+Av8C8AMBAwIDAwMEAwUDCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQBBkvnIAAsBdQBByvnIAAvSBYEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAgQCBAIEAwyLDIsMiwyLDIsMiwyLDIsMiwyLDIsMiwyLDIsMigQB5AJkAuQDZAPkAGQE5AVkBeQGWAbYBzgHuAQ0CLQJNAm0CjQKrArYBtgHLAusCCwMrA0sDtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AWsDiQOpA8kD6QPpA+kD6QPpA+kD6QPpA+kD6QPpA+8DtgG2AbYBtgEPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQfBD8EXwR/BJ8EvwTfBP8EHwU/BV8FeQWZBbkF2QX5BRkGOQZZBnQGtgGUBrQGDwQPBA8EDwTJBrYBtgHpBrYBtgG2AbYBtgHvBrYBDwcPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQfBw8EDwQPBLYBPwdYB3QHtgG2AbYBtgG2AbYBtgG2AZQHtgG2AbQHDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwTFB+UH/AcPBA8EDwQPBBwIDwQPBA8EDwQPBA8EPAhRCHEIkQixCNEItgHxCA8EAQkhCTgJSwlrCYsJDwSkCcQJ5AkECrYBFwo3ClIKDwQPBLYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBcgq2AbYBtgG2AbYBtgG2AYIKoQq2AbYBtgG2AbYBtgG2AbcKtgG2AbYBtgG2AbYBtgG2AbYBtgG2AbYBtgHCCrYB4QoPBA8EDwQPBAELIQsPBA8EtgG2AbYBtgG2AbYBtgG2AbYBQQu2AbYBtgG2AbYBtgG2AVYLDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBA8EDwQPBO7/AEGggckAC2hhAABAYgAAQGMAAEBkAABAZQAAQGYAAEBnAABAaAAAQGkAAEBqAABAawAAQGwAAEBtAABAbgAAQG8AAEBwAABAcQAAQHIAAEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQABBnIPJAAuEAf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQABBvITJAAvAByAAhEEAAAAAYQAAQAAAAAAAAAAA/////wAAAAAgAIJBAAAAAAAAAAAyAABAMwAAQCCAgEG8AwBAAAAAAAAAAAAggJNBMQAAQG8AAEAAAAAAAQA6TAEAN0wBADRMAAAAAGEAgEFhgIBBYQCBQWGAgUFhAIRBYQCFQeYAAEBjgJNBZQCAQWWAgEFlAIFBZQCEQWkAgEFpgIBBaQCBQWkAhEHwAABAboCBQW8AgEFvgIBBbwCBQW+AgUFvAIRBAAAAAPgAAEB1AIBBdYCAQXUAgUF1AIRBeYCAQf4AAEAAAAAAYQCAAWGAgAFhAIEBYYCBAWEAhAFhAIUBAAAAAGOAkwFlAIABZYCAAWUAgQFlAIQBaQCAAWmAgAFpAIEBaQCEAQAAAABugIEBbwCAAW+AgAFvAIEBb4CBAW8AhAEAAAAAAAAAAHUAgAF1gIABdQCBAXUAhAF5gIABAAAAAHkAhAFhAIJBYQCCAWEAg0FhAIMBYQCUQWEAlAFjgIBBY4CAAWMAgUFjAIEBY4CDQWOAgwFjAIZBYwCGAWQAhkFkAIYBEQEAQAAAAABlAIJBZQCCAWUAg0FlAIMBZYCDQWWAgwFlAJRBZQCUAWUAhkFlAIYBZwCBQWcAgQFnAINBZwCDAWeAg0FngIMBZ4CTQWeAkwFoAIFBaACBAScBAEAAAAAAaYCBQWmAgQFpAIJBaQCCAWkAg0FpAIMBaQCUQWkAlAFpgINBAAAAAAAAMEwAADBMagCBQWoAgQFrgJNBa4CTAQAAAABsgIBBbICAAWyAk0FsgJMBbACGQWwAhgEAACxMQgEAQAAAAABugIBBboCAAW6Ak0FugJMBbgCGQW4AhgEAACpMSwEAQAAAAABvAIJBbwCCAW8Ag0FvAIMBb4CFQW+AhQFTAQBAAAAAAHKAgEFygIABcoCTQXKAkwFyAIZBcgCGAXOAgEFzgIABcwCBQXMAgQFzgJNBc4CTAXMAhkFzAIYBdICTQXSAkwF0AIZBdACGAWcBAEAAAAAAdYCBQXWAgQF1AIJBdQCCAXUAg0F1AIMBdQCFQXUAhQF1gIVBdYCFAXUAlEF1AJQBdwCBQXcAgQF5AIFBeQCBAXkAhEF6gIBBeoCAAXqAg0F6gIMBegCGQXoAhgFzAABAAAAAAFMCAECDAQBAAAAAAIUBAEAAAAAAVAIAQIgBAEAAAAAAVgIAQFcCAECMAQBAAAAAAAAAAADdAQBAWQIAQFsCAECSAQBAAAAAAGACAEBjAgBAAAAAAGkCAEBoAgBAmQEAQABBiIzJAAt0bwIAQHICAEAAAAAAdQIAQG+AjUFvgI0BowEAQAAAAAClAQBAAAAAAIACAECoAQBAAAAAAIMCAEAAAAAAAAAAAK0BAEAAAAAAiAIAQHWAjUF1gI0BigIAQIsCAEC0AQBAAAAAALYBAEAAAAAAkgIAQLkBAEAAQYiNyQALBL0BAEAAQZyNyQALwAMBACFMAQAhTAEAIUwAABtMAAAbTAAAG0wAABVMAAAVTAAAFUxhAIZBYQCGAWkAhkFpAIYBbwCGQW8AhgF1AIZBdQCGAREA/0IRAP8CEQD5QhEA+QIRAPNCEQDzAhEA7UIRAO0CAAAAABEA50IRAOcCEQDhQhEA4QLmAIJB5gCCAeUBAEAAAAAAZwCGQWcAhgFrAIZBawCGAW8AlEFvAJQBEQDbQhEA2wKSAoZBkgKGAWoAhgEAAA9MAAAPTAAAD0xngIBBZ4CAAZUBAEC/AQBAbgCAQW4AgAERANVCEQDVAuaAgEHmgIAB+ICAQfiAgAFhgIdBYYCHAWGAiEFhgIgBZYCHQWWAhwFlgIhBZYCIAWmAh0FpgIcBaYCIQWmAiAFvgIdBb4CHAW+AiEFvgIgBcoCHQXKAhwFygIhBcoCIAXWAh0F1gIcBdYCIQXWAiAFzAJNBcwCTAXQAk0F0AJMBHQIAQAAAAABoAIZBaACGAZ4BAEAAAAAAIwIAQAAAAAAlAgBAAAAAAGGAg0FhgIMBZYCTQWWAkwERAM9CEQDPAhEAyUIRAMkCb4CDQW+AgwERAMNCEQDDAnkAgkF5AIIBAEH0kMkAC1BlLABAPAIAQAAAAACaAQBAZiwAQAAAAABCAgBAAAAAAIABAECJAgBAjAIAQEcCAEAAAAAASQIAQAAAAABLAgBAAAAAAE0CAEAAAAAATwIAQABBiJPJAAskaAAAQGYCAEBqAABAcgAAQHkCAEB7AgBAgQIAQHcAAEB5AABAAEGMlMkACzQgAINBIICDQSAAhUEgAJRBIICBQSCAhUEAAAAAAAAAAGMCAEBsAABAcwAAQHgAAECVAgBAAEGslckAC+wD5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA6NgAgNzYAIDc2ACA3NgAgNzYAIDo2ACA2NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACAytgAgMrYAIDc2ACA3NgAgNzYAIDc2ACAytgAgMrYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgAHYAIAB2ACAAdgAgAHYAIAB2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObZAMDm2QDA5tgAgObZAMDm2QDAuQMAQObYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgObYAIDc2ACA3NgAgP/////m2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgOjYAIDc2ACA3NgAgObYAIDp2ACA6tgAgOrYAIDp2ACA6tgAgOrYAIDp2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgHEDAEAAAAAAcwMAQAAAAAC5AgBAAAAAAHcDAEAAAAAA/f8AQP3/AEAAAE1NAEGkmckAC8sBOwAAQPMDAED9/wBA/f8AQP3/AED9/wBAIICAQREA3Euxg4BBtwAAQLWDgEG3g4BBuYOAQf3/AEC/g4BB/f8AQMWDgEHJg4BBEQAeALEDAECyAwBAswMAQLQDAEC1AwBAtgMAQLcDAEC4AwBAuQMAQLoDAEC7AwBAvAMAQL0DAEC+AwBAvwMAQMADAEDBAwBA/f8AQMMDAEDEAwBAxQMAQMYDAEDHAwBAyAMAQMkDAEC5A4RBxQOEQbGDgAG1g4ABt4OAAbmDgAERABUAQaybyQALmAO5A4QBxQOEAb+DgAHFg4AByYOAAdcDAECyAwBAuAMAQMUDAEDFg4BBxQOEQcYDAEDAAwBAAAAAANkDAEAAAAAA2wMAQAAAAADdAwBAAAAAAN8DAEAAAAAA4QMAQAAAAADjAwBAAAAAAOUDAEAAAAAA5wMAQAAAAADpAwBAAAAAAOsDAEAAAAAA7QMAQAAAAADvAwBAAAAAALoDAEDBAwBAwwMAQAAAAAC4AwBAtQMAQAAAAAD4AwBAAAAAAMMDAED7AwBAAAAAAAAAAAB7AwBAfAMAQH0DAEA1BIBBNQSEQVIEAEAzhIBBVAQAQFUEAEBWBABAVgSEQVgEAEBZBABAWgQAQFsEAEA6hIBBOASAQUMEg0FfBABAMAQAQDEEAEAyBABAMwQAQDQEAEA1BABANgQAQDcEAEA4BABAOASDQToEAEA7BABAPAQAQD0EAEA+BABAPwQAQEAEAEBBBABAQgQAQEMEAEBEBABARQQAQEYEAEBHBABASAQAQEkEAEBKBABASwQAQEwEAEBNBABATgQAQE8EAEAAQeieyQALBDgEgwEAQayfyQALEDUEgAE1BIQBAAAAADOEgAEAQcifyQALBFYEhAEAQdyfyQAL9Ac6hIABOASAAUMEgwEAAAAAYQQAQAAAAABjBABAAAAAAGUEAEAAAAAAZwQAQAAAAABpBABAAAAAAGsEAEAAAAAAbQQAQAAAAABvBABAAAAAAHEEAEAAAAAAcwQAQAAAAAB1BABAAAAAAHWEh0F1hIcBeQQAQAAAAAB7BABAAAAAAH0EAEAAAAAAfwQAQAAAAACBBABAAAAAAAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgAAAAAAAAAAAiwQAQAAAAACNBABAAAAAAI8EAEAAAAAAkQQAQAAAAACTBABAAAAAAJUEAEAAAAAAlwQAQAAAAACZBABAAAAAAJsEAEAAAAAAnQQAQAAAAACfBABAAAAAAKEEAEAAAAAAowQAQAAAAAClBABAAAAAAKcEAEAAAAAAqQQAQAAAAACrBABAAAAAAK0EAEAAAAAArwQAQAAAAACxBABAAAAAALMEAEAAAAAAtQQAQAAAAAC3BABAAAAAALkEAEAAAAAAuwQAQAAAAAC9BABAAAAAAL8EAEAAAAAAzwQAQDYEg0E2BIMBxAQAQAAAAADGBABAAAAAAMgEAEAAAAAAygQAQAAAAADMBABAAAAAAM4EAEAAAAAAAAAAADAEg0EwBIMBMASEQTAEhAHVBABAAAAAADUEg0E1BIMB2QQAQAAAAADZBIRB2QSEATYEhEE2BIQBNwSEQTcEhAHhBABAAAAAADgEgkE4BIIBOASEQTgEhAE+BIRBPgSEAekEAEAAAAAA6QSEQekEhAFNBIRBTQSEAUMEgkFDBIIBQwSEQUMEhAFDhIVBQ4SFAUcEhEFHBIQB9wQAQAAAAABLBIRBSwSEAfsEAEAAAAAA/QQAQAAAAAD/BABAAAAAAAEFAEAAAAAAAwUAQAAAAAAFBQBAAAAAAAcFAEAAAAAACQUAQAAAAAALBQBAAAAAAA0FAEAAAAAADwUAQAAAAAARBQBAAAAAABMFAEAAAAAAFQUAQAAAAAAXBQBAAAAAABkFAEAAAAAAGwUAQAAAAAAdBQBAAAAAAB8FAEAAAAAAIQUAQAAAAAAjBQBAAAAAACUFAEAAAAAAJwUAQAAAAAApBQBAAAAAACsFAEAAAAAALQUAQAAAAAAvBQBAAAAAAP3/AEBhBQBAYgUAQGMFAEBkBQBAZQUAQGYFAEBnBQBAaAUAQGkFAEBqBQBAawUAQGwFAEBtBQBAbgUAQG8FAEBwBQBAcQUAQHIFAEBzBQBAdAUAQHUFAEB2BQBAdwUAQHgFAEB5BQBAegUAQHsFAEB8BQBAfQUAQH4FAEB/BQBAgAUAQIEFAECCBQBAgwUAQIQFAECFBQBAhgUAQP3/AED9/wBAAEHuqMkACwINTABB/KjJAAsI/f8AQP3/AEAAQZCpyQALgAL9/wBA3NgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA3tgAgNzYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgN7YAIDk2ACA5tgAgArYAIAL2ACADNgAgA3YAIAO2ACAD9gAgBDYAIAR2ACAEtgAgBPYAIAT2ACAFNgAgBXYAIAW2ACAAAAAABfYAIAAAAAAGNgAgBnYAIAAAAAA5tgAgNzYAIAAAAAAEtgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEH8q8kACxD9/wBA/f8AQP3/AED9/wBAAEGkrMkACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB+KzJAAs05tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAe2ACAH9gAgCDYAIAAAAAA/f8AQABBwK3JAAsUJ4YpAycGKgNIBioDJ4YqA0oGKgMAQbiuyQALVBvYAIAc2ACAHdgAgB7YAIAf2ACAINgAgCHYAIAi2ACA5tgAgObYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgABBzK/JAAsEI9gAgABB4q/JAAsOC0wAAAlMAACeRgAAB0wAQYywyQALDNUGKgMAAAAAwQYqAwBB2LDJAAts0gYqAwAAAAAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AEAAAAAA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAAAAAAAAAADm2ACA5tgAgAAAAADc2ACA5tgAgObYAIDc2ACAAEGMsskACxD9/wBA/f8AQAAAAAAk2ACAAEGUs8kAC3Dm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA5tgAgNzYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDm2ACA3NgAgObYAIDc2ACA5tgAgNzYAIDm2ACA5tgAgP3/AED9/wBAAEHQtckACzj9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABBtLfJAAsk5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACAAEH0t8kACwz9/wBA/f8AQNzYAIAAQdi4yQALaObYAIDm2ACA5tgAgObYAIAAAAAA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAObYAIDm2ACA5tgAgAAAAADm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBAAEH8uckACwT9/wBAAEHkuskACxzc2ACA3NgAgNzYAID9/wBA/f8AQAAAAAD9/wBAAEGsu8kACxT9/wBA/f8AQP3/AED9/wBA/f8AQABBgLzJAAtE/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEDm2ACA5tgAgNzYAIDc2ACA3NgAgObYAIDm2ACA5tgAgObYAIAAQcS9yQAL2AHm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA3NgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgBvYAIAc2ACAHdgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQcDAyQALBCgJngQAQeDAyQALEDAJngQAAAAAAAAAADMJngQAQYzByQALBAfYAIAAQcTByQALBAnYAIAAQdTByQALEObYAIDc2ACA5tgAgObYAIAAQfDByQALIBUJnkQWCZ5EFwmeRBwJnkQhCZ5EIgmeRCsJnkQvCZ5EAEGQw8kACwT9/wBAAEG0w8kACxj9/wBA/f8AQAAAAAAAAAAA/f8AQP3/AEAAQaTEyQALBP3/AEAAQcTEyQALFP3/AEAAAAAA/f8AQP3/AED9/wBAAEHoxMkACxT9/wBA/f8AQAfYAIAAAAAAAAAAgABBkMXJAAts/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAADBAgAAvwIJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAgP3/AED9/wBA/f8AQP3/AEChCd5EogneRP3/AECvCd5EAEGMxskACwj9/wBA/f8AQABB9MbJAAsI5tgAgP3/AEAAQYjHyQALBP3/AEAAQaTHyQALIP3/AED9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAEGcyMkACwT9/wBAAEG8yMkACzT9/wBAAAAAADIKHkX9/wBAAAAAADgKHkX9/wBAAAAAAAAAAAD9/wBA/f8AQAfYAID9/wBAAEH8yMkAC4wB/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQP3/AEAAAAAAAAAAAAnYAID9/wBA/f8AQP3/AEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBYKHkUXCh5FHAoeRQAAAAD9/wBAKwoeRf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQczKyQALJP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB/MrJAAsE/f8AQABBpMvJAAsE/f8AQABBtMvJAAsE/f8AQABBkMzJAAsE/f8AQABBsMzJAAsQ/f8AQAAAAAAAAAAA/f8AQABB1MzJAAsM/f8AQP3/AEAH2ACAAEH4zMkACwT9/wBAAEGIzckAC1j9/wBAAAAAAAAAAAAJ2ACA/f8AQP3/AEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHwzckACwj9/wBA/f8AQABBqM7JAAsc/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB4M7JAAsE/f8AQABB8M7JAAsE/f8AQABBlM/JAAsY/f8AQP3/AEAAAAAAAAAAAP3/AED9/wBAAEGE0MkACwT9/wBAAEGk0MkACxD9/wBAAAAAAAAAAAD9/wBAAEHI0MkACxT9/wBA/f8AQAfYAIAAAAAAAAAAgABB8NDJAAto/f8AQP3/AEAAAAAAAAC9Av3/AED9/wBAAAC7AgAAuQIJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAACAAAAAgP3/AED9/wBA/f8AQP3/AEAhC55FIgueRf3/AEAAQezRyQALCP3/AED9/wBAAEG80skACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQABBgNPJAAsM/f8AQP3/AED9/wBAAEGY08kACwT9/wBAAEGm08kAC063AgAAAAD9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AEAAAAAA/f8AQAAAAAAAAAAA/f8AQP3/AED9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AEAAQYDUyQALDP3/AED9/wBA/f8AQABBvNTJAAsU/f8AQP3/AED9/wBA/f8AQAAAAIAAQdzUyQALDP3/AED9/wBA/f8AQABB9NTJAAt0/f8AQAAAtQIAALMCAACxAgnYAID9/wBA/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQbzWyQALFP3/AED9/wBA/f8AQP3/AED9/wBAAEGE18kACwT9/wBAAEGU18kACwT9/wBAAEH018kACwT9/wBAAEG42MkACwz9/wBA/f8AQAfYAIAAQdjYyQALFP3/AEAAAAAAAAAAAEYMKwb9/wBAAEH42MkACywJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQFTYAIBb2ACA/f8AQABBsNnJAAsU/f8AQP3/AEAAAAAA/f8AQP3/AEAAQdTZyQALCP3/AED9/wBAAEGE2skACxz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHU2skACwT9/wBAAEHk2skACwT9/wBAAEHE28kACwT9/wBAAEHw28kACwT9/wBAAEGI3MkACwz9/wBA/f8AQAfYAIAAQaLcyQALfq8CAAAAAAAAAIAAAAAAAAAAAP3/AEAAAAAAAACtAgAAqwL9/wBAAACoAgEAqAIAAAAACdgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAACAAAAAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA/f8AQABBsN3JAAsI/f8AQP3/AEAAQeDdyQALBP3/AEAAQfDdyQALMP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB1N7JAAsE/f8AQABB5N7JAAsE/f8AQABBjODJAAsQCdgAgAnYAIAAAAAAAAAAgABBsODJAAsE/f8AQABBwODJAAss/f8AQAAApgIAAKQCAACiAgnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AEAAQfvgyQALAYAAQazhyQALCP3/AED9/wBAAEGc4skACwT9/wBAAEGs4skACwT9/wBAAEH44skACwz9/wBA/f8AQP3/AEAAQeTjyQALBP3/AEAAQYzkyQALEP3/AEAAAAAA/f8AQP3/AEAAQbjkyQALJP3/AED9/wBA/f8AQAnYAID9/wBA/f8AQP3/AED9/wBAAAAAgABB8OTJAAtE/f8AQAAAAAD9/wBAAAAAAAAAAADZDeUGAAAAAAAAnwIBAJ8CAACdAgAAAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdzlyQALCP3/AED9/wBAAEHw5ckACyz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB5ufJAAsCBUwAQfjnyQALHGfYAIBn2ACACdgAgP3/AED9/wBA/f8AQP3/AEAAQbToyQALEGvYAIBr2ACAa9gAgGvYAIAAQYTpyQALpAH9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAAAAAAAP3/AEAAAAAA/f8AQABBvOrJAAsE/f8AQABBoOvJAAsM/f8AQAAAAAD9/wBAAEHe68kACwIDTABB8OvJAAsMdtgAgHbYAIAJ2ACAAEGI7MkACwj9/wBA/f8AQABBpOzJAAsc/f8AQAAAAAD9/wBAetgAgHrYAIB62ACAetgAgABBzOzJAAsE/f8AQABB+OzJAAuYAf3/AED9/wBAAAABTAAA/0sAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHA7skACwQLDwBAAEHw7skACwjc2ACA3NgAgABB5O/JAAsU3NgAgAAAAADc2ACAAAAAANjYAIAAQZLwyQALAptCAEGk8MkACwT9/wBAAEG68MkACwKZQgBBzvDJAAsCl0IAQeLwyQALApVCAEH28MkACwKTQgBBqvHJAAsCkUIAQbjxyQALbP3/AED9/wBA/f8AQP3/AECB2ACAgtgAgADZAMCE2ACAANkAwLIPwEcRAPxLsw/ARxEA+UuC2ACAgtgAgILYAICC2ACAAAAAAAAAAACC2ACAANkAwObYAIDm2ACACdgAgAAAAADm2ACA5tgAgABB0vLJAAsCj0IAQeTyyQALBP3/AEAAQfryyQALAo1CAEGO88kACwKLQgBBovPJAAsCiUIAQbbzyQALAodCAEHq88kACwKFQgBB+PPJAAsE/f8AQABBlPTJAAsE3NgAgABBsPTJAAsE/f8AQABB6PTJAAuUAf3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQZb2yQALAoMCAEG39skACwGAAEHU9skACxAH2ACAAAAAAAnYAIAJ2ACAAEGY98kACwTc2ACAAEGl98kAC78BLQBAAS0AQAItAEADLQBABC0AQAUtAEAGLQBABy0AQAgtAEAJLQBACi0AQAstAEAMLQBADS0AQA4tAEAPLQBAEC0AQBEtAEASLQBAEy0AQBQtAEAVLQBAFi0AQBctAEAYLQBAGS0AQBotAEAbLQBAHC0AQB0tAEAeLQBAHy0AQCAtAEAhLQBAIi0AQCMtAEAkLQBAJS0AQP3/AEAnLQBA/f8AQP3/AED9/wBA/f8AQP3/AEAtLQBA/f8AQP3/AEAAQZT5yQALBNwQAEAAQdT5yQALQP////8AAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQb/6yQALPYAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAQbD7yQALBP3/AEAAQcT7yQALCP3/AED9/wBAAEHo+8kACwz9/wBAAAAAAP3/AEAAQYT8yQALCP3/AED9/wBAAEG4/MkACxT9/wBA/f8AQObYAIDm2ACA5tgAgABB5PzJAAso/f8AQP3/AEDwEwBA8RMAQPITAEDzEwBA9BMAQPUTAED9/wBA/f8AQABBnP3JAAssCdgAgAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdj9yQALcAnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAD9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdj+yQALCP//////////AEGI/8kACwQJ2ACAAEG0/8kACwzm2ACA/f8AQP3/AEAAQez/yQALFP//////////////////////////AEGkgMoACxzk2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBAAEHkgMoACxze2ACA5tgAgNzYAID9/wBA/f8AQP3/AED9/wBAAEGcgcoACwjm2ACA3NgAgABBsIHKAAsU/f8AQP3/AEAAAAAAAAAAAAnYAIAAQYCCygALqAHm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBA3NgAgObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA5tgAgObYAIDc2ACAAAAAANzYAIDm2ACA5tgAgNzYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgP3/AEAAQcKDygALIoECAAAAAAAAfwIAAAAAAAB9AgAAAAAAAHsCAAAAAAAAeQIAQe6DygALAncCAEGkhMoACwgH2ACAAAAAgABBwoTKAAsKdQIAAAAAAABzAgBB1oTKAAsScQIAAG8CAAAAAAAAbQIJ2ACAAEGIhcoACwT9/wBAAEG4hcoACxTm2ACA3NgAgObYAIDm2ACA5tgAgABB9IXKAAsICdgAgAnYAIAAQYyGygALKAnYAIAJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdCGygALEAfYAID9/wBA/f8AQP3/AEAAQfSGygAL5AIyBABANAQAQD4EAEBBBABAQgQAQEIEAEBKBABAYwQAQEumAECKHABAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA0BAAQNEQAEDSEABA0xAAQNQQAEDVEABA1hAAQNcQAEDYEABA2RAAQNoQAEDbEABA3BAAQN0QAEDeEABA3xAAQOAQAEDhEABA4hAAQOMQAEDkEABA5RAAQOYQAEDnEABA6BAAQOkQAEDqEABA6xAAQOwQAEDtEABA7hAAQO8QAEDwEABA8RAAQPIQAEDzEABA9BAAQPUQAED2EABA9xAAQPgQAED5EABA+hAAQP3/AED9/wBA/RAAQP4QAED/EABA5tgAgObYAIDm2ACAAAAAAAHYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgObYAIDm2ACA3NgAgNzYAIDc2ACA3NgAgObYAIAAAAAAAdgAgAHYAIAB2ACAAdgAgAHYAIAB2ACAAdgAgABB6InKAAsE3NgAgABB/InKAAsE5tgAgABBjIrKAAsg5tgAgObYAIAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AEAAQdyKygAL/AFhAABA5gAAQGIAAEAAAAAAZAAAQGUAAEDdAQBAZwAAQGgAAEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEAAAAAAbwAAQCMCAEBwAABAcgAAQHQAAEB1AABAdwAAQGEAAEBQAgBAUQIAQAIdAEBiAABAZAAAQGUAAEBZAgBAWwIAQFwCAEBnAABAAAAAAGsAAEBtAABASwEAQG8AAEBUAgBAFh0AQBcdAEBwAABAdAAAQHUAAEAdHQBAbwIAQHYAAEAlHQBAsgMAQLMDAEC0AwBAxgMAQMcDAEBpAABAcgAAQHUAAEB2AABAsgMAQLMDAEDBAwBAxgMAQMcDAEAAQfiMygALBD0EAEAAQaiNygALhBNSAgBAYwAAQFUCAEDwAABAXAIAQGYAAEBfAgBAYQIAQGUCAEBoAgBAaQIAQGoCAEB7HQBAnQIAQG0CAECFHQBAnwIAQHECAEBwAgBAcgIAQHMCAEB0AgBAdQIAQHgCAECCAgBAgwIAQKsBAECJAgBAigIAQBwdAECLAgBAjAIAQHoAAECQAgBAkQIAQJICAEC4AwBA5tgAgObYAIDc2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDm2ACA5tgAgOrYAIDW2ACA3NgAgMrYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDo2ACA5NgAgOTYAIDc2ACA2tgAgObYAIDp2ACA3NgAgObYAIDc2ACAYYCSQWGAkgFigINBYoCDAWKAkUFigJEBYoCYQWKAmAERAGdCEQBnAmSAg0FkgIMBZICRQWSAkQFkgJhBZICYAWSAk0FkgJMBZICWQWSAlgERAGFCEQBhAhEAW0IRAFsCZYCWQWWAlgFlAJhBZQCYAREAVUIRAFUCZoCDQWaAgwFnAIJBZwCCAWiAg0FogIMBaICRQWiAkQFoAIRBaACEAWiAk0FogJMBaACXQWgAlwFpAJhBaQCYAREAT0IRAE8Ca4CAQWuAgAFrgJFBa4CRAWuAmEFrgJgBbICRQWyAkQERAElCEQBJAmyAmEFsgJgBbICWQWyAlgFtgIBBbYCAAW2Ag0FtgIMBbYCRQW2AkQFugINBboCDAW6AkUFugJEBboCYQW6AmAFugJZBboCWAREAQ0IRAEMCEQA9QhEAPQIRADdCEQA3AhEAMUIRADECcICAQXCAgAFwgINBcICDAXKAg0FygIMBcoCRQXKAkQERACtCEQArAnKAmEFygJgBc4CDQXOAgwFzgJFBc4CRAREAJUIRACUCEQAfQhEAHwIRABlCEQAZAnSAg0F0gIMBdICRQXSAkQF0gJhBdICYAXSAlkF0gJYBdQCSQXUAkgF1AJhBdQCYAXWAlkF1gJYBEQATQhEAEwIRAA1CEQANAnaAgUF2gIEBdoCRQXaAkQF3AIBBdwCAAXeAgEF3gIABdwCEQXcAhAF3gINBd4CDAXeAkUF3gJEBeICDQXiAgwF4AIRBeACEAXmAg0F5gIMBegCBQXoAgQF6gJFBeoCRAXqAmEF6gJgBaICYAXQAhAF3AIUBeQCFAQAA90tzgINBAAAAAAAAAADfAABAAAAAAGGAkUFhgJEBYYCEQWGAhAERAAdCEQAHAhEAAUIRAAECEQD7QREA+wERAPVBEQD1AREA70ERAO8BEQDpQREA6QERAONBEQDjAREA3UERAN0BEQDXQREA1wERANFBEQDRAWWAkUFlgJEBZYCEQWWAhAFlgIFBZYCBAREAy0ERAMsBEQDFQREAxQERAL9BEQC/AREAuUERALkBEQCzQREAswFpgIRBaYCEAWmAkUFpgJEBb4CRQW+AkQFvgIRBb4CEAREArUERAK0BEQCnQREApwERAKFBEQChAREAm0ERAJsBEQCVQREAlQERAI9BEQCPAREAiUERAIkBEQCDQREAgwERAH1BEQB9AREAd0ERAHcBdYCRQXWAkQF1gIRBdYCEAREAcUERAHEBEQBrQREAawERAGVBEQBlAREAX0ERAF8BEQBZQREAWQF5AIBBeQCAAXmAkUF5gJEBeYCEQXmAhAF5gIFBeYCBAfseAEAAAAAA/R4AQAAAAAD/HgBAAAAAALGDiQGxA4oBEQDgABEA3AARANgAEQDUABEA0AARAMwAsYOJQbEDikERAOBAEQDcQBEA2EARANRAEQDQQBEAzEC1g4kBtQOKAREAVgERAFMBEQBQAREATQH9/wBA/f8AQLWDiUG1A4pBEQBWQREAU0ERAFBBEQBNQf3/AED9/wBAt4OJAbcDigERAKQAEQCgABEAnAARAJgAEQCUABEAkAC3g4lBtwOKQREApEARAKBAEQCcQBEAmEARAJRAEQCQQLmDiQG5A4oBEQA+AREAOwERADgBEQA1AREAMgERAC8BuYOJQbkDikERAD5BEQA7QREAOEERADVBEQAyQREAL0G/g4kBvwOKAREAGgERABcBEQAUAREAEQH9/wBA/f8AQL+DiUG/A4pBEQAaQREAF0ERABRBEQARQf3/AED9/wBAxYOJAcUDigERAAIBEQD/ABEA/AARAPkAEQD2ABEA8wD9/wBAxQOKQf3/AEARAP9A/f8AQBEA+UD9/wBAEQDzQMmDiQHJA4oBEQBoABEAZAARAGAAEQBcABEAWAARAFQAyYOJQckDikERAGhAEQBkQBEAYEARAFxAEQBYQBEAVECxA4ABsYOAQbUDgAG1g4BBtwOAAbeDgEG5A4ABuYOAQb8DgAG/g4BBxQOAAcWDgEHJA4AByYOAQf3/AED9/wBAAQBKTQEAR00CAENNAgA/TQIAO00CADdNAgAzTQIAL00BAEpNAQBHTQIAQ00CAD9NAgA7TQIAN00CADNNAgAvTQEALE0BAClNAgAlTQIAIU0CAB1NAgAZTQIAFU0CABFNAQAsTQEAKU0CACVNAgAhTQIAHU0CABlNAgAVTQIAEU0BAA5NAQALTQIAB00CAANNAgD/TAIA+0wCAPdMAgDzTAEADk0BAAtNAgAHTQIAA00CAP9MAgD7TAIA90wCAPNMsQODAbEDggEBAPBMAADoTAEA7Uz9/wBAsQOhAQEA6kyxA4NBsQOCQbEDgEGxg4BBAADoTCCAiUG5AwBAIICJQSAAoUERAPRLAQDlTAAA3UwBAOJM/f8AQLcDoQEBAN9MtQOAQbWDgEG3A4BBt4OAQQAA3UwRAPFLEQDuSxEA60u5A4MBuQOCAREAIQARAB5A/f8AQP3/AEC5A6EBEQAbALkDg0G5A4JBuQOAQbmDgEH9/wBAEQDoSxEA5UsRAOJLxQODAcUDggERABgAEQAVQMGDiQHBA4oBxQOhAREAEgDFA4NBxQOCQcUDgEHFg4BBwQOKQREA30sRANxLYAAAQP3/AED9/wBAAQDaTAAA0kwBANdM/f8AQMkDoQEBANRMvwOAQb+DgEHJA4BByYOAQQAA0kwggIBBIACKQf3/AEAgAABAIAAAQCAAAEAgAABAIAAAQCAAAEAgAABAIAAAQCAAAEAgAABAIAAAQP////8AAAAAAAAAAP3/AED9/wBAAAAAABAgAEAAQcCgygALBCCAmUEAQeSgygALMP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQABBoqHKAAsSz0sBAM9LAAAAAAAA2UsBANlLAEHGocoACwrWSwAAAAAggIJBAEHuocoACwrUSwAA1UsAANNLAEGUosoACwQCAM9LAEG0osoAC4QCIAAAQP///////////////////////////f8AQP3/AED9/wBA/f8AQP3/AED///////////////////////////////8wAABAaQAAQP3/AED9/wBANAAAQDUAAEA2AABANwAAQDgAAEA5AABAKwAAQBIiAEA9AABAKAAAQCkAAEBuAABAMAAAQDEAAEAyAABAMwAAQDQAAEA1AABANgAAQDcAAEA4AABAOQAAQCsAAEASIgBAPQAAQCgAAEApAABA/f8AQGEAAEBlAABAbwAAQHgAAEBZAgBAaAAAQGsAAEBsAABAbQAAQG4AAEBwAABAcwAAQHQAAED9/wBA/f8AQP3/AEAAQdqkygALAtBMAEH4pMoACzTm2ACA5tgAgAHYAIAB2ACA5tgAgObYAIDm2ACA5tgAgAHYAIAB2ACAAdgAgObYAIDm2ACAAEG4pcoACwTm2ACAAEHIpcoAC+QBAdgAgAHYAIDm2ACA3NgAgObYAIAB2ACAAdgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAQDKSwEAx0tjAABAAADOTAAAAAABAMJLAQC/S1sCAEAAAAAAAADMTGcAAEBoAABAaAAAQGgAAEBoAABAJwEAQGkAAEBpAABAbAAAQGwAAEAAAAAAbgAAQAAAykwAAAAAAAAAAHAAAEBxAABAcgAAQHIAAEByAABAAEG2p8oAC37ITAEAxUwAAMNMAAAAAHoAAEAAAAAAyQMAQAAAAAB6AABAAAAAAGsAAEAQANVCYgAAQGMAAEAAAAAAZQAAQGYAAEBOIQBAbQAAQG8AAEDQBQBA0QUAQNIFAEDTBQBAaQAAQAAAAAABAMBMwAMAQLMDAECzAwBAwAMAQBEiAEAAQcSoygALFGQAAEBkAABAZQAAQGkAAEBqAABAAEHwqMoAC4ABAQCESwEArksCAKpLAQCnSwEApEsBAKFLAQCeSwEAm0sBAJhLAQCVSwEAkksBAI9LAQCMSwEAiUsBAIZLAACES2kAAEAAAG9LAQBvSwAAd0t2AABAAABzSwEAc0sCAHNLAABxS3gAAEAAAG5LAQBuS2wAAEBjAABAZAAAQG0AAEAAQfypygALBIQhAEAAQZSqygALHAEAa0sAAAAAAAAAAP3/AED9/wBA/f8AQP3/AEAAQdiqygALCJAhnAGSIZwBAEGYq8oACwSUIZwBAEHQq8oACwzQIZwB1CGcAdIhnAEAQeyrygALBAMinAEAQYCsygALEAginAEAAAAAAAAAAAsinAEAQaCsygALDCMinAEAAAAAJSKcAQBBwqzKAAsSrkoBAK5KAAAAAAAAaEsBAGhLAEGQrcoACyQ8IpwBAAAAAAAAAABDIpwBAAAAAAAAAABFIpwBAAAAAEginAEAQcytygALDD0AnAEAAAAAYSKcAQBBgK7KAAs0TSKcATwAnAE+AJwBZCKcAWUinAEAAAAAAAAAAHIinAFzIpwBAAAAAAAAAAB2IpwBdyKcAQBBzK7KAAsoeiKcAXsinAEAAAAAAAAAAIIinAGDIpwBAAAAAAAAAACGIpwBhyKcAQBBpK/KAAsgoiKcAaginAGpIpwBqyKcAXwinAF9IpwBkSKcAZIinAEAQdyvygALELIinAGzIpwBtCKcAbUinAEAQZCwygALCAgwAEAJMABAAEGssMoAC4wDMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAAAD2RgAA80YAAPBGAADtRgAA6kYAAOdGAADkRgAA4UYAAN5GAADbRgAA2EYBAGVLAQBiSwEAX0sBAFxLAQBZSwEAVksBAFNLAQBQSwEATUsCAElLAgBFSwIAQUsCAD1LAgA5SwIANUsCADFLAgAtSwIAKUsCACVLAgAhS/3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAEA/UoBAPpKAQD3SgEA9EoBAPFKAQDuSgEA60oBAOhKAQDlSgEA4koBAN9KAQDcSgEA2UoBANZKAQDTSgEA0EoBAM1KAQDKSgEAx0oBAMRKAQDBSgEAvkoBALtKAQC4SgEAtUoBALJKYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQGgAAEBpAABAagAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEAwAABAAEHos8oACwQCAK5KAEH8s8oACwwBAKtKAACoSgEAqEoAQbi0ygALBN0qnEEAQci0ygALmAIwLABAMSwAQDIsAEAzLABANCwAQDUsAEA2LABANywAQDgsAEA5LABAOiwAQDssAEA8LABAPSwAQD4sAEA/LABAQCwAQEEsAEBCLABAQywAQEQsAEBFLABARiwAQEcsAEBILABASSwAQEosAEBLLABATCwAQE0sAEBOLABATywAQFAsAEBRLABAUiwAQFMsAEBULABAVSwAQFYsAEBXLABAWCwAQFksAEBaLABAWywAQFwsAEBdLABAXiwAQF8sAEBhLABAAAAAAGsCAEB9HQBAfQIAQAAAAAAAAAAAaCwAQAAAAABqLABAAAAAAGwsAEAAAAAAUQIAQHECAEBQAgBAUgIAQAAAAABzLABAAAAAAAAAAAB2LABAAEH4tsoAC5wDagAAQHYAAEA/AgBAQAIAQIEsAEAAAAAAgywAQAAAAACFLABAAAAAAIcsAEAAAAAAiSwAQAAAAACLLABAAAAAAI0sAEAAAAAAjywAQAAAAACRLABAAAAAAJMsAEAAAAAAlSwAQAAAAACXLABAAAAAAJksAEAAAAAAmywAQAAAAACdLABAAAAAAJ8sAEAAAAAAoSwAQAAAAACjLABAAAAAAKUsAEAAAAAApywAQAAAAACpLABAAAAAAKssAEAAAAAArSwAQAAAAACvLABAAAAAALEsAEAAAAAAsywAQAAAAAC1LABAAAAAALcsAEAAAAAAuSwAQAAAAAC7LABAAAAAAL0sAEAAAAAAvywAQAAAAADBLABAAAAAAMMsAEAAAAAAxSwAQAAAAADHLABAAAAAAMksAEAAAAAAyywAQAAAAADNLABAAAAAAM8sAEAAAAAA0SwAQAAAAADTLABAAAAAANUsAEAAAAAA1ywAQAAAAADZLABAAAAAANssAEAAAAAA3SwAQAAAAADfLABAAAAAAOEsAEAAAAAA4ywAQABBtLrKAAs07CwAQAAAAADuLABAAAAAAObYAIDm2ACA8ywAQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQABBhLvKAAso/f8AQAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQABBzLvKAAtg/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQGEtAEAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAJ2ACAAEHUvMoACwT9/wBAAEHovMoACwTNawBAAEH4vMoAC8AHn58AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABOAEAoTgBANk4AQD9OAEBZTgBAhU4AQIxOAECgTgBAuk4AQD9RAEBlUQBAa1EAQIJRAECWUQBAq1EAQOBRAED1UQBAAFIAQJtSAED5UgBAFVMAQBpTAEA4UwBAQVMAQFxTAEBpUwBAglMAQLZTAEDIUwBA41MAQNdWAEAfVwBA61gAQAJZAEAKWQBAFVkAQCdZAEBzWQBAUFsAQIBbAED4WwBAD1wAQCJcAEA4XABAblwAQHFcAEDbXQBA5V0AQPFdAED+XQBAcl4AQHpeAEB/XgBA9F4AQP5eAEALXwBAE18AQFBfAEBhXwBAc18AQMNfAEAIYgBANmIAQEtiAEAvZQBANGUAQIdlAECXZQBApGUAQLllAEDgZQBA5WUAQPBmAEAIZwBAKGcAQCBrAEBiawBAeWsAQLNrAEDLawBA1GsAQNtrAEAPbABAFGwAQDRsAEBrcABAKnIAQDZyAEA7cgBAP3IAQEdyAEBZcgBAW3IAQKxyAECEcwBAiXMAQNx0AEDmdABAGHUAQB91AEAodQBAMHUAQIt1AECSdQBAdnYAQH12AECudgBAv3YAQO52AEDbdwBA4ncAQPN3AEA6eQBAuHkAQL55AEB0egBAy3oAQPl6AEBzfABA+HwAQDZ/AEBRfwBAin8AQL1/AEABgABADIAAQBKAAEAzgABAf4AAQImAAEDjgQBA6oEAQPOBAED8gQBADIIAQBuCAEAfggBAboIAQHKCAEB4ggBATYYAQGuGAEBAiABATIgAQGOIAEB+iQBAi4kAQNKJAEAAigBAN4wAQEaMAEBVjABAeIwAQJ2MAEBkjQBAcI0AQLONAECrjgBAyo4AQJuPAECwjwBAtY8AQJGQAEBJkQBAxpEAQMyRAEDRkQBAd5UAQICVAEAclgBAtpYAQLmWAEDolgBAUZcAQF6XAEBilwBAaZcAQMuXAEDtlwBA85cAQAGYAEComABA25gAQN+YAECWmQBAmZkAQKyZAEComgBA2JoAQN+aAEAlmwBAL5sAQDKbAEA8mwBAWpsAQOWcAEB1ngBAf54AQKWeAEC7ngBAw54AQM2eAEDRngBA+Z4AQP2eAEAOnwBAE58AQCCfAEA7nwBASp8AQFKfAECNnwBAnJ8AQKCfAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAIAAAQAAAAAAuAABAAEHsxMoACxja2ACA5NgAgOjYAIDe2ACA4NgAgODYAIAAQZzFygALFBIwAEAAAAAAQVMAQERTAEBFUwBAAEHExcoACwT9/wBAAEH0xcoAC3hLsEwYAAAAAE2wTBgAAAAAT7BMGAAAAABRsEwYAAAAAFOwTBgAAAAAVbBMGAAAAABXsEwYAAAAAFmwTBgAAAAAW7BMGAAAAABdsEwYAAAAAF+wTBgAAAAAYbBMGAAAAAAAAAAAZLBMGAAAAABmsEwYAAAAAGiwTBgAQYTHygALOG+wTBhvME0YAAAAAHKwTBhyME0YAAAAAHWwTBh1ME0YAAAAAHiwTBh4ME0YAAAAAHuwTBh7ME0YAEHMx8oACzBGsEwYAAAAAAAAAAD9/wBA/f8AQAjYAIAI2ACAIIBMWCAATVgAAAAAnbBMGAAApkoAQazIygALeKuwTBgAAAAArbBMGAAAAACvsEwYAAAAALGwTBgAAAAAs7BMGAAAAAC1sEwYAAAAALewTBgAAAAAubBMGAAAAAC7sEwYAAAAAL2wTBgAAAAAv7BMGAAAAADBsEwYAAAAAAAAAADEsEwYAAAAAMawTBgAAAAAyLBMGABBvMnKAAs4z7BMGM8wTRgAAAAA0rBMGNIwTRgAAAAA1bBMGNUwTRgAAAAA2LBMGNgwTRgAAAAA27BMGNswTRgAQYTKygALHKawTBgAAAAAAAAAAO+wTBjwsEwY8bBMGPKwTBgAQazKygALiAP9sEwYAACkSv3/AEAAEQBAAREAQKoRAMACEQBArBEAwK0RAMADEQBABBEAQAURAECwEQDAsREAwLIRAMCzEQDAtBEAwLURAMAaEQBABhEAQAcRAEAIEQBAIREAQAkRAEAKEQBACxEAQAwRAEANEQBADhEAQA8RAEAQEQBAEREAQBIRAEBhEQDAYhEAwGMRAMBkEQDAZREAwGYRAMBnEQDAaBEAwGkRAMBqEQDAaxEAwGwRAMBtEQDAbhEAwG8RAMBwEQDAcREAwHIRAMBzEQDAdBEAwHURAMD/////FBEAQBURAEDHEQBAyBEAQMwRAEDOEQBA0xEAQNcRAEDZEQBAHBEAQN0RAEDfEQBAHREAQB4RAEAgEQBAIhEAQCMRAEAnEQBAKREAQCsRAEAsEQBALREAQC4RAEAvEQBAMhEAQDYRAEBAEQBARxEAQEwRAEDxEQBA8hEAQFcRAEBYEQBAWREAQIQRAECFEQBAiBEAQJERAECSEQBAlBEAQJ4RAEChEQBA/f8AQABBvc3KAAvXAk4AQIxOAEAJTgBA21YAQApOAEAtTgBAC04AQDJ1AEBZTgBAGU4AQAFOAEApWQBAMFcAQLpOAEABAKFKAQCeSgEAm0oBAJhKAQCVSgEAkkoBAI9KAQCMSgEAiUoBAIZKAQCDSgEAgEoBAH1KAQB6SgIAdkoCAHJKAgBuSgIAakoCAGZKAgBiSgIAXkoCAFpKAgBWSgIAUkoCAE5KAgBKSgIARkoCAEJKAgA+SgUAN0oEADFK/f8AQAEALkoBACtKAQAoSgEAJUoBACJKAQAfSgEAHEoBABlKAQAWSgEAE0oBABBKAQANSgEACkoBAAdKAQAESgEAAUoBAP5JAQD7SQEA+EkBAPVJAQDySQEA70kBAOxJAQDpSQEA5kkBAONJAQDgSQEA3UkBANpJAQDXSQEA1EkBANFJAQDOSQEAy0kBAMhJAQDFSU9VAEB8XgBAh2UAQI97AEAAQbTQygALgA8BAL1MAADVRgAA0kYAAM9GAADMRgAAyUYAAMZGAADDRgAAwEYAAL1GAAC6RgAAt0YAAMBJAAC+SQAAiEkAALxJABEAQAIRAEADEQBABREAQAYRAEAHEQBACREAQAsRAEAMEQBADhEAQA8RAEAQEQBAEREAQBIRAEAAALpJAAC4SQAAtkkAALRJAACySQAAsEkAAK5JAACsSQAAqkkAAJ1JAACoSQAApkkAAKRJAACiSQMAnUkCAJlJAACXSQAAAAAATgBAjE4AQAlOAEDbVgBAlE4AQG1RAEADTgBAa1EAQF1OAEBBUwBACGcAQGtwAEA0bABAKGcAQNGRAEAfVwBA5WUAQCpoAEAJZwBAPnkAQA1UAEB5cgBAoYwAQF15AEC0UgBA2HkAQDd1AEBzWQBAaZAAQCpRAEBwUwBA6GwAQAWYAEARTwBAmVEAQGNrAEAKTgBALU4AQAtOAEDmXQBA81MAQDtTAECXWwBAZlsAQON2AEABTwBAx4wAQFRTAEAcWQBAAACVSQAAk0kAAJFJAACPSQAAjUkAAItJAACJSQAAh0kAAIVJAACDSQAAgUkAAH9JAAB9SQAAe0kAAHlJAABmSQAAY0kAAHdJAAB1SQAAc0kAAHFJAABvSQAAbUkAAGtJAQBoSQEAZUkBAGJJAAC7TAEAXUkAALlMAQC2TKIwAECkMABApjAAQKgwAECqMABAqzAAQK0wAECvMABAsTAAQLMwAEC1MABAtzAAQLkwAEC7MABAvTAAQL8wAEDBMABAxDAAQMYwAEDIMABAyjAAQMswAEDMMABAzTAAQM4wAEDPMABA0jAAQNUwAEDYMABA2zAAQN4wAEDfMABA4DAAQOEwAEDiMABA5DAAQOYwAEDoMABA6TAAQOowAEDrMABA7DAAQO0wAEDvMABA8DAAQPEwAEDyMABAAABWSQMAUUkCAE1JAwBISQEARUkDAEBJAQA9SQEAOkkEADRJAgAwSQEALUkBACpJAQAnSQIAI0kCAB9JAgAbSQIAF0kCABNJAgAPSQIAC0kEAAVJAAD0SAQA/0gEAPlIAwD0SAIA7kgEAO5IBADoSAIA5EgBAOFIAQDeSAIA2kgCANZIAwDRSAMAzEgBAMlIAQC0SAIAxUgBAMJIAQC/SAAANUgAAL1IAQC6SAEAt0gEALFIAgCtSAMAqEgEAKJIAgCeSAEAm0gBAJhIBACSSAIAjkgEAIhIAQCFSAMAgEgBAH1IAgB5SAEAdkgCAHJIAwBtSAIAaUgDAGRIAgBgSAAAXkgDAFlIAQBWSAEAU0gCAE9IAQBMSAEASUgBAEZIAwBBSAIAPUgAADdIBAA3SAEAMkgDADJIAgAuSAIAKkgBACdIAQAkSAIAIEgAAB5IAgAaSAMAFUgAABNIBAANSAEACkgAAOpHAADnRwAA5EcAAOFHAADeRwAA+UcAAPZHAADzRwAA8EcAAO1HAQAHSAEABEgBAAFIAQD+RwEA+0cBAPhHAQD1RwEA8kcBAO9HAQDsRwEA6UcBAOZHAQDjRwEA4EcBAN1HAQCzTAAA2EcAALFMAQDTRwAAr0wAAM9HAADJRwEAzEcBAMlHAACtTAAAxUcAAMNHAADBRwAAv0cCALtHAACJTAAAq0wAAKlMAACnTAAApUwAAKNMAAAWRwAAc0wBAKhHAgCnRwAAoUwAAJ9MAACdTAAAn0cAAJ1HAAA0RwAAkkwBAJpMAQCXTAEAlEwBAJFMAACPRwAAjUcAAItHAACJRwAAh0cAAIVHAACDRwAAd0cAAHRHAABxRwEAgEcBAH1HAAB7RwEAekcBAHdHAQB0RwAAckcBAHFHAQBtRwIAbUcAAIlMAQCOTAEAi0wBAIhMAQBeRwMAXkcEAF5HAABcRwAAWkcAAFhHAABWRwAASEwAAIZMAACETAAATkwAAIJMAABOTAAAgEwAAH5MAAB8TAAAXEwAAHpMAABcTAAAeEwAAHZM/f8AQAAAdEwAADhHAAA2RwIAcEz9/wBAAABuTAAAbEwAAClHAABqTAAAJUcAAGhMAABxRwAAH0cAABJHAAAdRwEAGkcAABhHAAAWRwEAE0cBABBHAABmTP3/AEABAGNMAABhTAAAA0cAAF9MAABdTAEAWkwBAFdMAAC4RgAA00YAANBGAADNRgAAykYAAMdGAADERgAAwUYAAL5GAQD2RgEA80YBAPBGAQDtRgEA6kYBAOdGAQDkRgEA4UYBAN5GAQDbRgEA2EYBANVGAQDSRgEAz0YBAMxGAQDJRgEAxkYBAMNGAQDARgEAvUYBALpGAQC3RgEAtEZBpgBAAAAAAEOmAEAAAAAARaYAQAAAAABHpgBAAAAAAEmmAEAAAAAAS6YAQAAAAABNpgBAAAAAAE+mAEAAAAAAUaYAQAAAAABTpgBAAAAAAFWmAEAAAAAAV6YAQAAAAABZpgBAAAAAAFumAEAAAAAAXaYAQAAAAABfpgBAAAAAAGGmAEAAAAAAY6YAQAAAAABlpgBAAAAAAGemAEAAAAAAaaYAQAAAAABrpgBAAAAAAG2mAEAAAAAAAAAAAObYAIAAQcTfygALsAHm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACAAAAAAAAAAACBpgBAAAAAAIOmAEAAAAAAhaYAQAAAAACHpgBAAAAAAImmAEAAAAAAi6YAQAAAAACNpgBAAAAAAI+mAEAAAAAAkaYAQAAAAACTpgBAAAAAAJWmAEAAAAAAl6YAQAAAAACZpgBAAAAAAJumAEAAAAAASgQAQEwEAEDm2ACA5tgAgABBjOHKAAvYAv3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAAAAAAAAjpwBAAAAAACWnAEAAAAAAJ6cAQAAAAAAppwBAAAAAACunAEAAAAAALacAQAAAAAAvpwBAAAAAAAAAAAAzpwBAAAAAADWnAEAAAAAAN6cAQAAAAAA5pwBAAAAAADunAEAAAAAAPacAQAAAAAA/pwBAAAAAAEGnAEAAAAAAQ6cAQAAAAABFpwBAAAAAAEenAEAAAAAASacAQAAAAABLpwBAAAAAAE2nAEAAAAAAT6cAQAAAAABRpwBAAAAAAFOnAEAAAAAAVacAQAAAAABXpwBAAAAAAFmnAEAAAAAAW6cAQAAAAABdpwBAAAAAAF+nAEAAAAAAYacAQAAAAABjpwBAAAAAAGWnAEAAAAAAZ6cAQAAAAABppwBAAAAAAGunAEAAAAAAbacAQAAAAABvpwBAAEGE5MoACzh6pwBAAAAAAHynAEAAAAAAeR0AQH+nAEAAAAAAgacAQAAAAACDpwBAAAAAAIWnAEAAAAAAh6cAQABBzOTKAAsgjKcAQAAAAABlAgBAAAAAAAAAAACRpwBAAAAAAJOnAEAAQfjkygALyAKXpwBAAAAAAJmnAEAAAAAAm6cAQAAAAACdpwBAAAAAAJ+nAEAAAAAAoacAQAAAAACjpwBAAAAAAKWnAEAAAAAAp6cAQAAAAACppwBAAAAAAGYCAEBcAgBAYQIAQGwCAEBqAgBAAAAAAJ4CAECHAgBAnQIAQFOrAEC1pwBAAAAAALenAEAAAAAAuacAQAAAAAC7pwBAAAAAAL2nAEAAAAAAv6cAQAAAAADBpwBAAAAAAMOnAEAAAAAAlKcAQIICAECOHQBAyKcAQAAAAADKpwBAAAAAAGQCAEDNpwBAAAAAAP3/AED9/wBA0acAQAAAAAD9/wBAAAAAAP3/AEAAAAAA16cAQAAAAADZpwBAAAAAANunAEAAAAAAmwEAQP3/AED9/wBA/f8AQGMAAEBmAABAcQAAQPanAEAAAAAAAAAAACcBAEBTAQBAAEHw58oACxAJ2ACA/f8AQP3/AED9/wBAAEGQ6MoACygJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHk6MoACwzc2ACA3NgAgNzYAIAAQfzoygALOAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAJ2ACAAEHo6coACyz9/wBAAAAAAObYAIAAAAAA5tgAgObYAIDc2ACAAAAAAAAAAADm2ACA5tgAgABBqOrKAAtI5tgAgObYAIAAAAAA5tgAgAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEGI68oACygJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHI68oACwj9/wBA/f8AQABB6OvKAAsE/f8AQABBnOzKAAsQJ6cAQDerAEBrAgBAUqsAQABB0OzKAAvcAo0CAEAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AECgEwBAoRMAQKITAECjEwBApBMAQKUTAECmEwBApxMAQKgTAECpEwBAqhMAQKsTAECsEwBArRMAQK4TAECvEwBAsBMAQLETAECyEwBAsxMAQLQTAEC1EwBAthMAQLcTAEC4EwBAuRMAQLoTAEC7EwBAvBMAQL0TAEC+EwBAvxMAQMATAEDBEwBAwhMAQMMTAEDEEwBAxRMAQMYTAEDHEwBAyBMAQMkTAEDKEwBAyxMAQMwTAEDNEwBAzhMAQM8TAEDQEwBA0RMAQNITAEDTEwBA1BMAQNUTAEDWEwBA1xMAQNgTAEDZEwBA2hMAQNsTAEDcEwBA3RMAQN4TAEDfEwBA4BMAQOETAEDiEwBA4xMAQOQTAEDlEwBA5hMAQOcTAEDoEwBA6RMAQOoTAEDrEwBA7BMAQO0TAEDuEwBA7xMAQABB4O/KAAuYCgnYAID9/wBA/f8AQAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEBIjABA9GYAQMqOAEDIjABA0W4AQDJOAEDlUwBAnJ8AQJyfAEBRWQBA0ZEAQIdVAEBIWQBA9mEAQGl2AECFfwBAP4YAQLqHAED4iABAj5AAQAJqAEAbbQBA2XAAQN5zAEA9hABAapEAQPGZAECCTgBAdVMAQARrAEAbcgBALYYAQB6eAEBQXQBA628AQM2FAEBkiQBAyWIAQNiBAEAfiABAyl4AQBdnAEBqbQBA/HIAQM6QAECGTwBAt1EAQN5SAEDEZABA02oAQBByAEDndgBAAYAAQAaGAEBchgBA740AQDKXAEBvmwBA+p0AQIx4AEB/eQBAoH0AQMmDAEAEkwBAf54AQNaKAEDfWABABF8AQGB8AEB+gABAYnIAQMp4AEDCjABA95YAQNhYAEBiXABAE2oAQNptAEAPbwBAL30AQDd+AEBLlgBA0lIAQIuAAEDcUQBAzFEAQBx6AEC+fQBA8YMAQHWWAECAiwBAz2IAQAJqAED+igBAOU4AQOdbAEASYABAh3MAQHB1AEAXUwBA+3gAQL9PAECpXwBADU4AQMxsAEB4ZQBAIn0AQMNTAEBeWABAAXcAQEmEAECqigBAumsAQLCPAECIbABA/mIAQOWCAECgYwBAZXUAQK5OAEBpUQBAyVEAQIFoAEDnfABAb4IAQNKKAEDPkQBA9VIAQEJUAEBzWQBA7F4AQMVlAED+bwBAKnkAQK2VAEBqmgBAl54AQM6eAECbUgBAxmYAQHdrAEBijwBAdF4AQJBhAEAAYgBAmmQAQCNvAEBJcQBAiXQAQMp5AED0fQBAb4AAQCaPAEDuhABAI5AAQEqTAEAXUgBAo1IAQL1UAEDIcABAwogAQKqKAEDJXgBA9V8AQHtjAECuawBAPnwAQHVzAEDkTgBA+VYAQOdbAEC6XQBAHGAAQLJzAEBpdABAmn8AQEaAAEA0kgBA9pYAQEiXAEAYmABAi08AQK55AEC0kQBAuJYAQOFgAECGTgBA2lAAQO5bAEA/XABAmWUAQAJqAEDOcQBAQnYAQPyEAEB8kABAjZ8AQIhmAEAulgBAiVIAQHtnAEDzZwBAQW0AQJxuAEAJdABAWXUAQGt4AEAQfQBAXpgAQG1RAEAuYgBAeJYAQCtQAEAZXQBA6m0AQCqPAECLXwBARGEAQBdoAECHcwBAhpYAQClSAEAPVABAZVwAQBNmAEBOZwBAqGgAQOVsAEAGdABA4nUAQHl/AEDPiABA4YgAQMyRAEDilgBAP1MAQLpuAEAdVABA0HEAQJh0AED6hQBAo5YAQFecAECfngBAl2cAQMttAEDogQBAy3oAQCB7AECSfABAwHIAQJlwAEBYiwBAwE4AQDaDAEA6UgBAB1IAQKZeAEDTYgBA1nwAQIVbAEAebQBAtGYAQDuPAEBMiABATZYAQIuJAEDTXgBAQFEAQMBVAEAAAAAAAAAAAFpYAEAAAAAAdGYAQAAAAAAAAAAA3lEAQCpzAEDKdgBAPHkAQF55AEBleQBAj3kAQFaXAEC+fABAvX8AQAAAAAAShgBAAAAAAPiKAEAAAAAAAAAAADiQAED9kABAAEGE+soAC/QK75gAQPyYAEAomQBAtJ0AQN6QAEC3lgBArk8AQOdQAEBNUQBAyVIAQORSAEBRUwBAnVUAQAZWAEBoVgBAQFgAQKhYAEBkXABAblwAQJRgAEBoYQBAjmEAQPJhAEBPZQBA4mUAQJFmAECFaABAd20AQBpuAEAibwBAbnEAQCtyAEAidABAkXgAQD55AEBJeQBASHkAQFB5AEBWeQBAXXkAQI15AECOeQBAQHoAQIF6AEDAewBA9H0AQAl+AEBBfgBAcn8AQAWAAEDtgQBAeYIAQHmCAEBXhABAEIkAQJaJAEABiwBAOYsAQNOMAEAIjQBAto8AQDiQAEDjlgBA/5cAQDuYAEB1YABAEADHQxiCAED9/wBA/f8AQCZOAEC1UQBAaFEAQIBPAEBFUQBAgFEAQMdSAED6UgBAnVUAQFVVAECZVQBA4lUAQFpYAECzWABARFkAQFRZAEBiWgBAKFsAQNJeAEDZXgBAaV8AQK1fAEDYYABATmEAQAhhAECOYQBAYGEAQPJhAEA0YgBAxGMAQBxkAEBSZABAVmUAQHRmAEAXZwBAG2cAQFZnAEB5awBAumsAQEFtAEDbbgBAy24AQCJvAEAecABAbnEAQKd3AEA1cgBAr3IAQCpzAEBxdABABnUAQDt1AEAddgBAH3YAQMp2AEDbdgBA9HYAQEp3AEBAdwBAzHgAQLF6AEDAewBAe3wAQFt9AED0fQBAPn8AQAWAAEBSgwBA74MAQHmHAEBBiQBAhokAQJaJAEC/igBA+IoAQMuKAEABiwBA/ooAQO2KAEA5iwBAiosAQAiNAEA4jwBAcpAAQJmRAEB2kgBAfJYAQOOWAEBWlwBA25cAQP+XAEALmABAO5gAQBKbAECcnwBAEADGQxAAxUMQAMRDnTsAQBhAAEA5QABAEADDQxAAwkMQAMFDQ58AQI6fAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAK5GAACyRgAAr0YBALFGAQCuRgAArEYAAKxG/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAACqRgAAqEYAAKZGAACkRgAAokb9/wBA/f8AQP3/AED9/wBA/f8AQNkF2kIa2ACA8oXbQuIFAEDQBQBA0wUAQNQFAEDbBQBA3AUAQN0FAEDoBQBA6gUAQCsAAEDpheBC6QXhQhEABEARAAFA0IXbQtAF3ELQBd5C0QXeQtIF3kLTBd5C1AXeQtUF3kLWBd5C/f8AQNgF3kLZBd5C2gXeQtsF3kLcBd5C/f8AQN4F3kL9/wBA4AXeQuEF3kL9/wBA4wXeQuQF3kL9/wBA5gXeQucF3kLoBd5C6QXeQuoF3kLVhdxC0YXfQtuF30Lkhd9CAACgRnEGAEBxBgBAewYAQHsGAEB7BgBAewYAQH4GAEB+BgBAfgYAQH4GAECABgBAgAYAQIAGAECABgBAegYAQHoGAEB/BgBAfwYAQH8GAEB/BgBAeQYAQHkGAEB5BgBAeQYAQKQGAECkBgBApAYAQKQGAECmBgBApgYAQIQGAECEBgBAhAYAQIQGAECDBgBAgwYAQIMGAECDBgBAhgYAQIYGAECGBgBAhgYAQIcGAECHBgBAjQYAQI0GAECMBgBAjAYAQI4GAECOBgBAiAYAQIgGAECYBgBAmAYAQJEGAECRBgBAqQYAQKkGAECvBgBArwYAQK8GAECvBgBAswYAQLMGAECzBgBAswYAQLEGAECxBgBAsQYAQLEGAEC6BgBAugYAQLsGAEC7BgBAuwYAQLsGAEDVBipD1QYqQ8EGAEDBBgBAwQYAQMEGAEC+BgBAvgYAQL4GAEC+BgBA0gYAQNIGAEDSBipD0gYqQwBBsIXLAAvsD/3/AED9/wBA/f8AQK0GAECtBgBArQYAQK0GAEDHBgBAxwYAQMYGAEDGBgBAyAYAQMgGAEAAAJ5GywYAQMsGAEDFBgBAxQYAQMkGAEDJBgBA0AYAQNAGAEDQBgBA0AYAQEkGAEBJBgBAAQCbRgEAm0YBAJhGAQCYRgEAlUYBAJVGAQCSRgEAkkYBAI9GAQCPRgEAjEYBAIxGAQCJRgEAiUYBAIlGAQBlRgEAZUYBAGVGzAYAQMwGAEDMBgBAzAYAQAEAI0YBACBGAQD8RQEAZUYBAGJGAAAbRgAAt0QAABpFAAD3RQAAXEYAAFpGAAAURQAArUUAAA5FAAAIRQAAUkYAAFBGAACHRgAA8UUAAEhGAABGRgAAw0QAALJEAADARAAAl0QAADxFAACFRgAAN0UAAI9FAACVRQAAq0QAAIZFAAD5RAAArkQAABdGAADzRAAAcUUAABVGAAATRgAAaEUAALZFAACxRAAAlEQAABFGAABcRQAAD0YAAA1GAABZRQAAukQAAERGAABCRgAAC0YAANhEAABARgAAPkYAADxGAAAJRgAAB0YAAAVGAADtRQAAtEQAADpGAAA4RgAAekQAANVEAABKRQAAiEQAAIREAACLRAAAvUQAAJZEAADMRAAAlUQAAABFAAC7RAAAqEQAANtEAAADRgAAHUUAAC5GAAAsRgAAAUYAAC9FAACDRgAA+0UAAMJEAAC/RAAA/0UAALxEAAAmRgAA40QwBjhDMQY4Q0kGOEMRAIBGEQB9RhEAekYRAHdGEQB0RhEAcUYBAG5GAQBrRgEA/EUBAGhGAQBlRgEAYkYAAJxEAABgRgAA90UAAF5GAABcRgAAWkYAAFhGAABWRgAACEUAAFRGAABSRgAAUEYAAE5GAABMRgAA8UUAAEpGAABIRgAARkYAAERGAABCRgAAQEYAAD5GAAA8RgAA7UUAALREAAA6RgAAOEYAAIhEAACERAAAi0QAADZGAACVRAAANEYAADJGAAAdRQAAMEYAAC5GAAAsRkkGOEMAACpGAAAoRgAAvEQAAMVEAAAmRgAA40QBACNGAQAgRgEAHUYBAPxFAQD5RQAAG0YAALdEAAAaRQAA90UAAPVFAAAURQAArUUAAA5FAAAIRQAA80UAAPFFAADDRAAAskQAAMBEAACXRAAAPEUAADdFAACPRQAAlUUAAKtEAACGRQAA+UQAABlGAACuRAAAF0YAAPNEAABxRQAAFUYAABNGAAC2RQAAsUQAAJREAAARRgAAXEUAAA9GAAANRgAAWUUAALpEAAALRgAA2EQAAAlGAAAHRgAABUYAAO1FAAC0RAAAekQAANVEAABKRQAAiEQAAIFEAAC9RAAAlkQAAMxEAACVRAAAqEQAANtEAAADRgAAHUUAAOtFAAABRgAAL0VHBjhDAADCRAAAv0QAAP9FAAC8RAAAjEQBAPxFAQD5RQAA90UAAPVFAAAIRQAA80UAAPFFAADvRQAAhkUAALxFAAB3RQAAukUAAO1FAAC0RAAAiEQAAB1FAADrRQAAvEQAAIxEEQDoRREA5UURAOJFAADgRQAA3kUAANxFAADaRQAA2EUAANZFAADURQAA0kUAANBFAADORQAAA0UAALhEAAAVRQAAqUQAAP1EAACsRAAAzEUAAMpFAADIRQAAxkUAAH1FAAD2RAAAuEUAAHdFAADERQAAwkUAAMBFAAC+RQAA4EUAAN5FAADcRQAA2kUAANhFAADWRQAA1EUAANJFAADQRQAAzkUAAANFAAC4RAAAFUUAAKlEAAD9RAAArEQAAMxFAADKRQAAyEUAAMZFAAB9RQAA9kQAALhFAAB3RQAAxEUAAMJFAADARQAAvkUAAH1FAAD2RAAAuEUAAHdFAAC8RQAAukUAAGhFAACPRQAAlUUAAKtEAAB9RQAA9kQAALhFAABoRQAAtkUnhiVDJ4YlQwAAAAAAAAAAAQCzRQEAsEUBALBFAQCtRQEAqkUBAKdFAQCkRQEAoUUBAJ5FAQCeRQEAm0UBAJhFAQCVRQEAkkUBAI9FAQCMRQEAiUUBAIZFAQCGRQEAg0UBAINFAQCuRAEAgEUBAIBFAQB9RQEAekUBAHpFAQB3RQEAd0UBAHRFAQBxRQEAbkUBAG5FAQBrRQEAaEUBALFEAQCURAEAlEQBAGVFAQBiRQEAX0UBAFxFAQBZRQEAWUUBANhEAQBWRQEA1UQBAFNFAQBQRQEATUUBAE1FAQBKRQEASkUBAEdFAQBHRQEAREUBAJZEAQBBRQEAPkUBADNFAQA7RQEAOEX9/wBA/f8AQAEANUUBADJFAQAvRQEALEUBAClFAQAmRQEAJkUBACNFAQAgRQEAHUUBAOBEAQDgRAEAGkUBABdFAQAURQEAEUUBAA5FAQALRQEACEUBAAVFAQACRQEA/0QBAPxEAQD5RAEA9kQBAPNEAQDwRAEA7UQBAOpEAQDnRAEA5EQBAOFEAQDeRAEA20QBANhEAQDVRAEA0kQBAM9EAQDGRAEAzEQBAMlEAQC0RAEAyUQBAMZEAQDDRAEAwEQBAL1EAQC6RAEAt0QBALREAQCxRAEArkQBAKtEAQCoRP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAAAQClRAEAokQCAJ5EAgCaRAIAlkQCAJJEAgCORAIAikQCAIZEAQCDRAEAAEAGAHtEAgB3RABBqJXLAAucD/////////////////////////////////////////////////////////////////////////////////////8sAABAATAAQP3/AEA6AABAOwAAQCEAAEA/AABAFjAAQBcwAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgNzYAIDm2ACA5tgAgP3/AEAUIABAEyAAQF8AAEBfAABAKAAAQCkAAEB7AABAfQAAQBQwAEAVMABAEDAAQBEwAEAKMABACzAAQAgwAEAJMABADDAAQA0wAEAOMABADzAAQAAAAAAAAAAAWwAAQF0AAEAggIJBIICCQSCAgkEggIJBXwAAQF8AAEBfAABALAAAQAEwAED9/wBA/f8AQDsAAEA6AABAPwAAQCEAAEAUIABAKAAAQCkAAEB7AABAfQAAQBQwAEAVMABAIwAAQCYAAEAqAABAKwAAQC0AAEA8AABAPgAAQD0AAED9/wBAXAAAQCQAAEAlAABAQAAAQP3/AED9/wBA/f8AQP3/AEAggCVDQIYlQyAAJkMAAAAAIIAmQ/3/AEAgACdDQAYnQyCAJ0NAhidDIAAoQ0AGKEMggChDQIYoQyAAKUNABilDIQYAQCeGKUMnhilDJwYqQycGKkNIBipDSAYqQyeGKkMnhipDSgYqQ0oGKkNKBipDSgYqQycGAEAnBgBAKAYAQCgGAEAoBgBAKQYAQCkGAEAqBgBAKgYAQCoGAEAqBgBAKwYAQCsGAEArBgBAKwYAQCwGAEAsBgBALAYAQC0GAEAtBgBALQYAQC0GAEAuBgBALgYAQC4GAEAuBgBALwYAQC8GAEAwBgBAMAYAQDEGAEAxBgBAMgYAQDMGAEAzBgBAMwYAQDMGAEA0BgBANAYAQDQGAEA0BgBANQYAQDUGAEA1BgBANQYAQDYGAEA2BgBANgYAQDcGAEA3BgBANwYAQDcGAEA4BgBAOAYAQDgGAEA4BgBAOQYAQDkGAEA5BgBAOQYAQDoGAEA6BgBAOgYAQEEGAEBBBgBAQQYAQEEGAEBCBgBAQgYAQEIGAEBCBgBAQwYAQEMGAEBDBgBAQwYAQEQGAEBEBgBARAYAQEUGAEBFBgBARQYAQEUGAEBGBgBARgYAQEYGAEBGBgBARwYAQEcGAEBHBgBARwYAQEgGAEBIBgBASQYAQEoGAEBKBgBASgYAQEoGAEABAG9EAQBvRAEAbEQBAGxEAQBpRAEAaUQAAGdEAABnRP3/AED9/wBA//////3/AEAhAABAIgAAQCMAAEAkAABAJQAAQCYAAEAnAABAKAAAQCkAAEAqAABAKwAAQCwAAEAtAABALgAAQC8AAEAwAABAMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAOgAAQDsAAEA8AABAPQAAQD4AAEA/AABAQAAAQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAbwAAQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAWwAAQFwAAEBdAABAXgAAQF8AAEBgAABAYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQGgAAEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEB7AABAfAAAQH0AAEB+AABAhSkAQIYpAEAuAABADDAAQA0wAEABMABA+zAAQPIwAEChMABAozAAQKUwAECnMABAqTAAQOMwAEDlMABA5zAAQMMwAED8MABAojAAQKQwAECmMABAqDAAQKowAECrMABArTAAQK8wAECxMABAszAAQLUwAEC3MABAuTAAQLswAEC9MABA3zAAQOAwAEDhMABA4jAAQOQwAEDmMABA6DAAQOkwAEDqMABA6zAAQOwwAEDtMABA7zAAQPMwAEAA2QDAANkAwP////8AEQBAAREAQKoRAMACEQBArBEAwK0RAMADEQBABBEAQAURAECwEQDAsREAwLIRAMCzEQDAtBEAwLURAMAaEQBABhEAQAcRAEAIEQBAIREAQAkRAEAKEQBACxEAQAwRAEANEQBADhEAQA8RAEAQEQBAEREAQBIRAED9/wBA/f8AQGERAMBiEQDAYxEAwGQRAMBlEQDAZhEAwP3/AED9/wBAZxEAwGgRAMBpEQDAahEAwGsRAMBsEQDA/f8AQP3/AEBtEQDAbhEAwG8RAMBwEQDAcREAwHIRAMD9/wBA/f8AQHMRAMB0EQDAdREAwP3/AED9/wBA/f8AQKIAAECjAABArAAAQCAAgkGmAABApQAAQKkgAED9/wBAAiUAQJAhAECRIQBAkiEAQJMhAECgJQBAyyUAQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAAADA/f8AQP3/AEAAQfCkywALEP3/AEAAAAAAAAAAAP3/AEAAQYylywALEP3/AED9/wBA/f8AQP3/AEAAQdClywALDNzYAID9/wBA/f8AQABB9KXLAAso5tgAgObYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQABBrKbLAAsQ/f8AQP3/AED9/wBA/f8AQABB3KbLAAugARAAbk4QAG1OEABsThAAa04QAGpOEABpThAAaE4QAGdOEABmThAAZU4QAGROEABjThAAYk4QAGFOEABgThAAX04QAF5OEABdThAAXE4QAFtOEABaThAAWU4QAFhOEABXThAAVk4QAFVOEABUThAAU04QAFJOEABRThAAUE4QAE9OEABOThAATU4QAExOEABLThAASk4QAElOEABIThAAR04AQZyoywALoAEQAEZOEABFThAARE4QAENOEABCThAAQU4QAEBOEAA/ThAAPk4QAD1OEAA8ThAAO04QADpOEAA5ThAAOE4QADdOEAA2ThAANU4QADROEAAzThAAMk4QADFOEAAwThAAL04QAC5OEAAtThAALE4QACtOEAAqThAAKU4QAChOEAAnThAAJk4QACVOEAAkThAAI079/wBA/f8AQP3/AED9/wBAAEHcqcsAC5wBEAAiThAAIU4QACBOEAAfThAAHk4QAB1OEAAcThAAG04QABpOEAAZThAAGE79/wBAEAAXThAAFk4QABVOEAAUThAAE04QABJOEAARThAAEE4QAA9OEAAOThAADU4QAAxOEAALThAACk4QAAlO/f8AQBAACE4QAAdOEAAGThAABU4QAAROEAADThAAAk79/wBAEAABThAAAE79/wBAAEGcq8sACwT9/wBAAEG8q8sACxj9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AEAAQfirywALBBEAvwMAQZSsywALBBEAvQMAQcSsywAL/AHQAgBA0QIAQOYAAECZAgBAUwIAQP3/AECjAgBAZqsAQKUCAECkAgBAVgIAQFcCAECRHQBAWAIAQF4CAECpAgBAZAIAQGICAEBgAgBAmwIAQCcBAECcAgBAZwIAQIQCAECqAgBAqwIAQGwCAEAQAFRNjqcAQG4CAEAQAFNNjgIAQBAAUk34AABAdgIAQHcCAEBxAABAegIAQBAAUU19AgBAfgIAQIACAECoAgBApgIAQGerAECnAgBAiAIAQHEsAED9/wBAjwIAQKECAECiAgBAmAIAQMABAEDBAQBAwgEAQBAAUE0QAE9N/f8AQP3/AED9/wBA/f8AQP3/AEAAQdiuywALEP3/AED9/wBAAAAAAP3/AEAAQYCvywALJP3/AEAAAAAAAAAAAP3/AED9/wBA/f8AQAAAAAD9/wBA/f8AQABBsK/LAAsg/f8AQAAAAAAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AEAAQeSvywALMP3/AEAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBAAAAAANzYAIAAAAAA5tgAgABBrLDLAAso/f8AQP3/AEDm2ACAAdgAgNzYAID9/wBA/f8AQP3/AED9/wBACdgAgABB6LDLAAsY5tgAgNzYAID9/wBA/f8AQP3/AED9/wBAAEGUscsACxz9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHAscsAC4wC/f8AQP3/AED9/wBAEAD/TRAA/k0QAP1NEAD8TRAA+00QAPpNEAD5TRAA+E0QAPdNEAD2TRAA9U0QAPRNEADzTRAA8k0QAPFNEADwTRAA700QAO5NEADtTRAA7E0QAOtNEADqTRAA6U0QAOhNEADnTRAA5k0QAOVNEADkTRAA400QAOJNEADhTRAA4E0QAN9NEADeTRAA3U0QANxNEADbTRAA2k0QANlNEADYTRAA100QANZNEADVTRAA1E0QANNNEADSTRAA0U0QANBNEADPTRAAzk0QAM1N/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABB3LPLAAuoAebYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBAAzE0QAMtNEADKTRAAyU0QAMhNEADHTRAAxk0QAMVNEADETRAAw00QAMJNEADBTRAAwE0QAL9NEAC+TRAAvU0QALxNEAC7TRAAuk0QALlNEAC4TRAAt039/wBA/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgABBrLXLAAtQ/f8AQObYAIDm2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAADc2ACA3NgAgNzYAIAAQZS2ywALKNzYAIDc2ACA5tgAgObYAIDm2ACA3NgAgObYAIDc2ACA3NgAgNzYAIAAQeC2ywALMP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAAAAAAAA5tgAgNzYAIDm2ACA3NgAgABBoLfLAAsY/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHQt8sACwQJ2ACAAEHwt8sACwz9/wBA/f8AQAnYAIAAQZC4ywALKP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAnYAIAAQeC4ywALDBEAuwMAAAAAEQC5AwBBmLnLAAsEEQC3AwBBwLnLAAsUCdgAgAfYAIAAAAAAAAAAAP3/AEAAQfO5ywALAYAAQYy6ywALCAEAtQMBALMDAEGgussACwwJ2ACACdgAgP3/AEAAQdS6ywALBAfYAIAAQeS6ywALKP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAnYAIAAQbC7ywALBAfYAIAAQci7ywALCAnYAIAH2ACAAEH0u8sACwz9/wBAAAAAAP3/AEAAQZC8ywALBP3/AEAAQbi8ywALMAfYAIAJ2ACA/f8AQP3/AED9/wBA/f8AQP3/AEAAAAAA/f8AQAAAAAAAAAAA/f8AQABB/LzLAAsU/f8AQAfYAIAH2ACAAAAAAAAAAIAAQaS9ywALYP3/AED9/wBAAAAAAAAAAAD9/wBA/f8AQAEAsQMBAK8DCdgAgP3/AED9/wBAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQAAAAID9/wBA/f8AQP3/AED9/wBA/f8AQABBlL7LAAtQ/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfC+ywALDAEArQMAAAAAAQCrAwBBjL/LAAsg/f8AQAAAAAD9/wBA/f8AQAEAqQP9/wBAAAAAAAEApwMAQeS/ywALDP3/AEAAAAAAAAAAgABB+7/LAAsBgABBjMDLAAs8/f8AQAAAAID9/wBA/f8AQAEApYP9/wBAAQCjgwEAoYMAAACAAAAAAP3/AEAAAAAAAAAAAAnYAIAJ2ACAAEHcwMsAC0z9/wBAAAAAAAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAAAAAAAAAAAJ2ACAAEG0wcsACwQH2ACAAEHfwcsACwGAAEGHwssACyGAAQCfAwEAnQMAAACAAQCbAwAAAAAAAAAACdgAgAfYAIAAQbjCywALIP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEGXw8sACwGAAEGww8sACxj9/wBA/f8AQAAAAAAAAAAAAQCZAwEAlwMAQdTDywALCAnYAIAH2ACAAEGYxMsACygJ2ACAB9gAgAAAAAAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHsxMsACxQJ2ACA/f8AQP3/AED9/wBA/f8AQABBpMXLAAucAQnYAIAH2ACAAAAAAP3/AED9/wBA/f8AQP3/AEAQALZNEAC1TRAAtE0QALNNEACyTRAAsU0QALBNEACvTRAArk0QAK1NEACsTRAAq00QAKpNEACpTRAAqE0QAKdNEACmTRAApU0QAKRNEACjTRAAok0QAKFNEACgTRAAn00QAJ5NEACdTRAAnE0QAJtNEACaTRAAmU0QAJhNEACXTQBB3MbLAAsU/f8AQP3/AEAAAAAA/f8AQP3/AEAAQYDHywALEP3/AEAAAAAAAAAAAP3/AEAAQbPHywALAYAAQcjHywALJP3/AEAAAAAAAQCVA/3/AED9/wBAAAAAAAAAAAAJ2ACACdgAgABB/MfLAAss/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQbjIywALBAnYAIAAQejIywALJAnYAID9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQABBqMnLAAsE/f8AQABByMnLAAsECdgAgABB6MnLAAtg/f8AQP3/AED9/wBAAAAAAP3/AEAAAAAAAAAAAP3/AEAAAAAAAAAAAAfYAIAAAAAACdgAgAnYAIAAAAAAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEHgyssACxD9/wBAAAAAAAAAAAD9/wBAAEGIy8sACwT9/wBAAEGcy8sACyQJ2ACAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfvLywALKYAAAACAAQCMgwEAj4MBAJODAQCQgwEAjYMCAJKDAgCPgwIAjIMAAACAAEG4zMsAC2AJ2ACAAdgAgAHYAIAB2ACAAdgAgAHYAIAAAAAA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAAQb/NywALDYABAIqDAQCJAwIAiQMAQeDNywALwAEQAJZNEACVTRAAlE0QAJNNEACSTRAAkU0QAJBNEACPTRAAjk0QAI1NEACMTRAAi00QAIpNEACJTRAAiE0QAIdNEACGTRAAhU0QAIRNEACDTRAAgk0QAIFNEACATRAAf00QAH5NEAB9TRAAfE0QAHtNEAB6TRAAeU0QAHhNEAB3TQbYAIAG2ACA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQazPywALNP3/AED9/wBAAAAAAP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQfDPywALIP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAAEG40MsAC5gB/f8AQP3/AEAAAAAAAAAAAAHYAIAAAAAA//////////////////////3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQDAAAEAxAABAMgAAQDMAAEA0AABANQAAQDYAAEA3AABAOAAAQDkAAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEAAQYjSywALMBEAh0MRAHhDEgCEQxIAgUMSAH5DEgB7QxIAeEPY2ACA2NgAgAHYAIAB2ACAAdgAgABBxNLLAAto4tgAgNjYAIDY2ACA2NgAgP//////////////////////////////////////////3NgAgNzYAIDc2ACA3NgAgNzYAIAAAAAAAAAAAObYAIDm2ACA5tgAgObYAIDm2ACA3NgAgNzYAIAAQdTTywALEObYAIDm2ACA5tgAgObYAIAAQZDUywALGBEAb0MRAGxDEgB1QxIAckMSAG9DEgBsQwBB5NTLAAvcCebYAIDm2ACA5tgAgAAAAAD9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAcQAAQHIAAEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAbwAAQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAYQAAQGIAAEBjAABAZAAAQGUAAEBmAABAZwAAQP3/AEBpAABAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEBhAABA/f8AQGMAAEBkAABA/f8AQP3/AEBnAABA/f8AQP3/AEBqAABAawAAQP3/AED9/wBAbgAAQG8AAEBwAABAcQAAQP3/AEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABAegAAQGEAAEBiAABAYwAAQGQAAED9/wBAZgAAQP3/AEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABA/f8AQHAAAEBxAABAcgAAQHMAAEB0AABAdQAAQHYAAEB3AABAeAAAQHkAAEB6AABAYQAAQGIAAED9/wBAZAAAQGUAAEBmAABAZwAAQP3/AED9/wBAagAAQGsAAEBsAABAbQAAQG4AAEBvAABAcAAAQHEAAED9/wBAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQP3/AEBhAABAYgAAQGkAAEBqAABAawAAQGwAAEBtAABA/f8AQG8AAED9/wBA/f8AQP3/AEBzAABAdAAAQHUAAEB2AABAdwAAQHgAAEB5AABA/f8AQGEAAEBiAABAYwAAQGQAAEBlAABAZgAAQGcAAEBoAABAaQAAQGoAAEBrAABAbAAAQG0AAEBuAABAdwAAQHgAAEB5AABAegAAQDEBAEA3AgBA/f8AQP3/AECxAwBAsgMAQLMDAEC0AwBAtQMAQLYDAEC3AwBAuAMAQLkDAEC6AwBAuwMAQLwDAEC9AwBAvgMAQL8DAEDAAwBAwQMAQLgDAEDDAwBAxAMAQMUDAEDGAwBAxwMAQMgDAEDJAwBAByIAQLEDAECyAwBAswMAQLQDAEC1AwBAtgMAQLcDAEC4AwBAuQMAQLoDAEC7AwBAvAMAQL0DAEC+AwBAvwMAQMADAEDBAwBAwwMAQMMDAEDEAwBAxQMAQMYDAEDHAwBAyAMAQMkDAEACIgBAtQMAQLgDAEC6AwBAxgMAQMEDAEDAAwBAsQMAQLIDAECzAwBAtAMAQLUDAEC2AwBAtwMAQLgDAEC5AwBAugMAQLsDAEC8AwBAvQMAQL4DAEDHAwBAyAMAQMkDAEACIgBAtQMAQLgDAEC6AwBAxgMAQMEDAEDAAwBA3QMAQN0DAED9/wBA/f8AQDAAAEAxAABAMgAAQDMAAEA0AABANQAAQDYAAEA3AABAOAAAQDkAAEAwAABAMQAAQDIAAEAzAABANAAAQDUAAEA2AABANwAAQDgAAEA5AABAMAAAQDEAAEAyAABAMwAAQP3/AED9/wBA/f8AQP3/AED9/wBAAEHY3ssAC/wD/f8AQP3/AED9/wBA/f8AQP3/AEDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA/f8AQObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA5tgAgObYAID9/wBA5tgAgObYAIDm2ACA5tgAgObYAID9/wBA/f8AQP3/AED9/wBA/f8AQDAEAEAxBABAMgQAQDMEAEA0BABANQQAQDYEAEA3BABAOAQAQDoEAEA7BABAPAQAQD4EAEA/BABAQAQAQEEEAEBCBABAQwQAQEQEAEBFBABARgQAQEcEAEBIBABASwQAQE0EAEBOBABAiaYAQNkEAEBWBABAWAQAQOkEAECvBABAzwQAQDAEAEAxBABAMgQAQDMEAEA0BABANQQAQDYEAEA3BABAOAQAQDoEAEA7BABAPgQAQD8EAEBBBABAQwQAQEQEAEBFBABARgQAQEcEAEBIBABASgQAQEsEAECRBABAVgQAQFUEAEBfBABAqwQAQFGmAECxBABA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA5tgAgObYAIDm2ACA5tgAgObYAIDm2ACA5tgAgABB8OLLAAsI/f8AQP3/AEAAQajjywALEOjYAIDo2ACA3NgAgObYAIAAQdTjywALBP3/AEAAQejjywAL2AH9/wBAAAAAAAAAAAD9/wBA3NgAgNzYAIDc2ACA3NgAgNzYAIDc2ACA3NgAgP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQBAAdk0QAHVNEAB0TRAAc00QAHJNEABxTRAAcE0QAG9NEABuTRAAbU0QAGxNEABrTRAAak0QAGlNEABoTRAAZ00QAGZNEABlTRAAZE0QAGNNEABiTRAAYU0QAGBNEABfTRAAXk0QAF1NEABcTRAAW00QAFpNEABZTRAAWE0QAFdNEABWTRAAVU0AQfjlywALkAbm2ACA5tgAgObYAIDm2ACA5tgAgObYAIAH2ACAAAAAAP3/AED9/wBA/f8AQP3/AEAnBgBAKAYAQCwGAEAvBgBA/f8AQEgGAEAyBgBALQYAQDcGAEBKBgBAQwYAQEQGAEBFBgBARgYAQDMGAEA5BgBAQQYAQDUGAEBCBgBAMQYAQDQGAEAqBgBAKwYAQC4GAEAwBgBANgYAQDgGAEA6BgBAbgYAQLoGAEChBgBAbwYAQP3/AEAoBgBALAYAQP3/AEBHBgBA/f8AQP3/AEAtBgBA/f8AQEoGAEBDBgBARAYAQEUGAEBGBgBAMwYAQDkGAEBBBgBANQYAQEIGAED9/wBANAYAQCoGAEArBgBALgYAQP3/AEA2BgBA/f8AQDoGAED9/wBA/f8AQP3/AED9/wBALAYAQP3/AED9/wBA/f8AQP3/AEAtBgBA/f8AQEoGAED9/wBARAYAQP3/AEBGBgBAMwYAQDkGAED9/wBANQYAQEIGAED9/wBANAYAQP3/AED9/wBALgYAQP3/AEA2BgBA/f8AQDoGAED9/wBAugYAQP3/AEBvBgBA/f8AQCgGAEAsBgBA/f8AQEcGAED9/wBA/f8AQC0GAEA3BgBASgYAQEMGAED9/wBARQYAQEYGAEAzBgBAOQYAQEEGAEA1BgBAQgYAQP3/AEA0BgBAKgYAQCsGAEAuBgBA/f8AQDYGAEA4BgBAOgYAQG4GAED9/wBAoQYAQP3/AEAnBgBAKAYAQCwGAEAvBgBARwYAQEgGAEAyBgBALQYAQDcGAEBKBgBA/f8AQEQGAEBFBgBARgYAQDMGAEA5BgBAQQYAQDUGAEBCBgBAMQYAQDQGAEAqBgBAKwYAQC4GAEAwBgBANgYAQDgGAEA6BgBA/f8AQP3/AED9/wBA/f8AQCgGAEAsBgBALwYAQP3/AEBIBgBAMgYAQC0GAEA3BgBASgYAQP3/AEBEBgBARQYAQEYGAEAzBgBAOQYAQP3/AEAAAGNEAABhRAAAX0QAAF1EAABbRAAAWUQAAFdEAABVRAAAU0QAAFFEAEGc7MsAC4ABAQDNSgEAykoBAMdKAQDESgEAwUoBAL5KAQC7SgEAuEoBALVKAQCySgEAVExjAABAcgAAQAAANkcAAFJMAAAAAHEAAEByAABAcwAAQHQAAEB1AABAdgAAQHcAAEB4AABAeQAAQHoAAEAAAFBMAABOTAAATEwAAEpMAQBHTAAARUwAQcbtywALCkNMAABBTAAAP0wAQd7tywALAj1MAEGe7ssAC+tN5UMAAONDtTAAQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AEBLYgBAV1sAQMxTAEDGsExYjE4AQBpZAEDjiQBAKVkAQKROAEAgZgBAIXEAQJllAEBNUgBAjF8AQI1RAECwZQBAHVIAQEJ9AEAfdQBAqYwAQPBYAEA5VABAFG8AQJViAEBVYwBAAE4AQAlOAEBKkABA5l0AQC1OAEDzUwBAB2MAQHCNAEBTYgBAgXkAQHp6AEAIVABAgG4AQAlnAEAIZwBAM3UAQHJSAEC2VQBATZEAQP3/AED9/wBA/f8AQP3/AEABAOBDAQDdQwEA2kMBANdDAQDUQwEA0UMBAM5DAQDLQwEAyEP9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBAl18AQO9TAED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQP3/AED9/wBA/f8AQD1OAEA4TgBAQU4AQBAAa0NgTwBArk8AQLtPAEACUABAelAAQJlQAEDnUABAz1AAQJ40AEAQAGpDTVEAQFRRAEBkUQBAd1EAQBAAaUO5NABAZ1EAQI1RAEAQAGhDl1EAQKRRAEDMTgBArFEAQLVRAEAQAGdD9VEAQANSAEDfNABAO1IAQEZSAEByUgBAd1IAQBU1AEDHUgBAyVIAQORSAED6UgBABVMAQAZTAEAXUwBASVMAQFFTAEBaUwBAc1MAQH1TAEB/UwBAf1MAQH9TAEAQAGZDcHAAQMpTAEDfUwBAEABlQ+tTAEDxUwBABlQAQJ5UAEA4VABASFQAQGhUAECiVABA9lQAQBBVAEBTVQBAY1UAQIRVAECEVQBAmVUAQKtVAECzVQBAwlUAQBZXAEAGVgBAF1cAQFFWAEB0VgBAB1IAQO5YAEDOVwBA9FcAQA1YAECLVwBAMlgAQDFYAECsWABAEABkQ/JYAED3WABABlkAQBpZAEAiWQBAYlkAQBAAY0MQAGJD7FkAQBtaAEAnWgBA2FkAQGZaAEDuNgBA/DYAQAhbAEA+WwBAPlsAQBAAYUPDWwBA2FsAQOdbAEDzWwBAEABgQ/9bAEAGXABAU18AQCJcAECBNwBAYFwAQG5cAEDAXABAjVwAQBAAX0NDXQBAEABeQ25dAEBrXQBAfF0AQOFdAEDiXQBALzgAQP1dAEAoXgBAPV4AQGleAEBiOABAEABdQ3w4AECwXgBAs14AQLZeAEDKXgBAEABcQ/5eAEAQAFtDEABbQwGCAEAiXwBAIl8AQMc4AEAQAFpDEABZQ2JfAEBrXwBA4zgAQJpfAEDNXwBA118AQPlfAECBYABAOjkAQBw5AECUYABAEABYQ8dgAEBIYQBATGEAQE5hAEBMYQBAemEAQI5hAECyYQBApGEAQK9hAEDeYQBA8mEAQPZhAEAQYgBAG2IAQF1iAECxYgBA1GIAQFBjAEAQAFdDPWMAQPxiAEBoYwBAg2MAQORjAEAQAFZDImQAQMVjAECpYwBALjoAQGlkAEB+ZABAnWQAQHdkAEBsOgBAT2UAQGxlAEAQAFVD42UAQPhmAEBJZgBAGTsAQJFmAEAIOwBA5DoAQJJRAECVUQBAAGcAQJxmAECtgABA2UMAQBdnAEAbZwBAIWcAQF5nAEBTZwBAEABUQ0k7AED6ZwBAhWcAQFJoAECFaABAEABTQ45oAEAfaABAFGkAQJ07AEBCaQBAo2kAQOppAECoagBAEABSQ9tqAEAYPABAIWsAQBAAUUNUawBATjwAQHJrAECfawBAumsAQLtrAEAQAFBDEABPQxAATkNObABAEABNQ79sAEDNbABAZ2wAQBZtAEA+bQBAd20AQEFtAEBpbQBAeG0AQIVtAEAQAExDNG0AQC9uAEBubgBAMz0AQMtuAEDHbgBAEABLQ/ltAEBubwBAEABKQxAASUPGbwBAOXAAQB5wAEAbcABAlj0AQEpwAEB9cABAd3AAQK1wAEAQAEhDRXEAQBAAR0OccQBAEABGQyhyAEA1cgBAUHIAQBAARUOAcgBAlXIAQBAAREMQAENDenMAQItzAECsPgBApXMAQLg+AEC4PgBAR3QAQFx0AEBxdABAhXQAQMp0AEAbPwBAJHUAQBAAQkM+dQBAEABBQ3B1AEAQAEBDEHYAQBAAP0MQAD5DEAA9Q/w/AEAIQABA9HYAQBAAPEMQADtDEAA6QxAAOUMedwBAH3cAQB93AEBKdwBAOUAAQIt3AEBGQABAlkAAQBAAOENOeABAjHgAQMx4AEDjQABAEAA3Q1Z5AEAQADZDEAA1Q495AEDreQBAL0EAQEB6AEBKegBAT3oAQBAANEMQADNDEAAzQ+56AEACQgBAEAAyQ8Z7AEDJewBAJ0IAQBAAMUPSfABAoEIAQOh8AEDjfABAAH0AQBAAMENjfQBAAUMAQMd9AEACfgBARX4AQDRDAEAQAC9DEAAuQ1lDAEAQAC1Den8AQBAALEOVfwBA+n8AQAWAAEAQACtDEAAqQ2CAAEAQAClDcIAAQBAAKEPVQwBAsoAAQAOBAEALRABAPoEAQLVaAEAQACdDEAAmQxAAJUMQACRDAYIAQASCAECejwBAa0QAQJGCAECLggBAnYIAQLNSAECxggBAs4IAQL2CAEDmggBAEAAjQ+WCAEAdgwBAY4MAQK2DAEAjgwBAvYMAQOeDAEBXhABAU4MAQMqDAEDMgwBA3IMAQBAAIkMQACFDEAAgQytFAEDxhABA84QAQBaFAEAQAB9DZIUAQBAAHkNdRQBAYUUAQBAAHUMQABxDa0UAQFCGAEBchgBAZ4YAQGmGAECphgBAiIYAQA6HAEDihgBAeYcAQCiHAEBrhwBAhocAQNdFAEDhhwBAAYgAQPlFAEBgiABAY4gAQBAAG0PXiABA3ogAQDVGAED6iABAuzQAQBAAGkMQABlDvkYAQMdGAECgigBA7YoAQIqLAEBVjABAEAAYQ6uMAEDBjABAG40AQHeNAEAQABdDEAAWQ8uNAEC8jQBA8I0AQBAAFUPUjgBAOI8AQBAAFEMQABNDlJAAQPGQAEARkQBAEAASQxuRAEA4kgBA15IAQNiSAEB8kgBA+ZMAQBWUAEAQABFDi5UAQJVJAEC3lQBAEAAQQ+ZJAEDDlgBAsl0AQCOXAEAQAA9DEAAOQ25KAEB2SgBA4JcAQBAADUOySgBAEAAMQwuYAEALmABAKZgAQBAAC0PimABAM0sAQCmZAECnmQBAwpkAQP6ZAEDOSwBAEAAKQxKbAEBAnABA/ZwAQM5MAEDtTABAZ50AQBAACUP4TABAEAAIQxAAB0MQAAZDu54AQFZNAED5ngBA/p4AQAWfAEAPnwBAFp8AQDufAEAQAAVD/f8AQP3/AEAAAAAAAAAAAOglEgDaDAAAAAAAAJw/EgBhMAAAAAAAAAACDgCBAAAA/f8AQOEADwQBAAAAQQAAAAAAOgBFA5gC1gyWATUbbQEF2GQABdgSAAbYMAAY2DQAG9gxAGfdG9gCAGPdAcBpbWfdAcBobWndAcBqbQMAsNwOALrcEQC93BQAr90wAAXYAQC43QHAuhW53QHAuxUxAAXYudwBwLwUMQAF2LncAcC7FDEABdi53AHAvhQyADDdBtg13QHAOBkDAB7dCgAf3Q0AIN0aACndMQAY2B7dAcAiYTEAGNge3QHAIWEwABjYAwAe3QHAI2Eh3QHAJmEi3QHAJ2Ep3QHAJGEwABjYAQAe3QHAJWEh3QHAKGE1G1QAmTBtAJow6gAE2AcAuN8mALjfEQC73xQAwt8XAMnfMAAE2AIAgt8BwIMTkN8BwJETwt8BwMgTMQAE2MLfAcDHEzEABNiE3wHAhRMwAATYAQCL3wHAjhPC3wHAxRO63AoAJ90UAD7fGwBX3zEABNhH3wHATBMwAATYAgCZ3AHAmhCb3AHAnBCl3AHAqxAwAATYAQAx3QHALhEy3QHALxExAATYR98BwEsTCgARGw4APhsGAD4bQJs/G0GbQhtDmxEbEps6GzubPBs9mwUbBpsHGwibCRsKmwsbDJsNGw6bLwCtMD4AxjAeANswDgDxMAYA8TD5sPIw+rD9MP6w2zDcsO8w97DwMPiw0jAGANIw07DVMNaw2DDZsMYwx7DIMMmwzzDQsLkwDgC/MAYAvzDAsMEwwrDEMMWwuTC6sLswvLC9ML6wszAGALMwtLC1MLawtzC4sK0wrrCvMLCwsTCysGEwHgB1MA4AnTAGAJ0wnrCmMPSwqzCssHUwdrB4MHmwezB8sGgwBgBoMGmwbzBwsHIwc7BhMGKwZDBlsGYwZ7BVMA4AWzAGAFswXLBdMF6wXzBgsFUwVrBXMFiwWTBasE8wBgBPMFCwUTBSsFMwVLBGMJSwSzBMsE0wTrAJAM8wCgDPMNGw0jDUsNUw17DYMNqw2zDdsG8wcbByMHSwdTB3sHgwerB7MH2wyg0VAMoNCADPDQsA3w0MAC4QMAAlECaQAQDZDdqN3A3djTAA2Q3cjTAA2Q3ejdYMBgA+DQcAVw0wAEYNTI0wAMYMyIwBAEYNSo1HDUuNPgswANcLGQDXCwwAVgwPAMIMEADVDAIAvwzAjMYMx4zKDMuMAQCSC5SLxgvMizAARgxIjDAAxgzKjD4LCgBWCwsAVwsMAL4LAQDGC8qLxwvLizAARwtLizAARwtIizAARwtMi1UGFwBVBggAPAkJAL4JDgDXCTAAxwnMiTAAJwYlhgIAKAkpiTAJMYkzCTSJMADHCcuJRQMSAFMGrgBUBgUAwQYGAMEGwobSBtOG1QbAhicGI4ZIBiSGSgYmhgAAPgAmH04AZh8mAG4fEgB8HwgAfB/yn7Yft5/GH8ef9h/3n24frp9vH6+fcB+yn3Qfwp9qHwgAah+qn2sfq59sH6yfbR+tn2Yfpp9nH6efaB+on2kfqZ8uHxIAYh8IAGIfop9jH6OfZB+kn2UfpZ8uH56fLx+fn2AfoJ9hH6GfKh8IACofmp8rH5ufLB+cny0fnZ8mH5afJx+XnygfmJ8pH5mfBh8mAA4fEgAiHwgAIh+SnyMfk58kH5SfJR+Vnw4fjp8PH4+fIB+QnyEfkZ8KHwgACh+Knwsfi58MH4yfDR+NnwYfhp8HH4efCB+InwkfiZ/JAxIAAh8IAAIfgp8DH4OfBB+EnwUfhZ/JA/OfzgP0nwAfgJ8BH4GfrAMIAKwDtJ+uA8SfsQOzn7cDw5+RA7yflwPMn6kD/J8wACcGIoYTA08CJwNyATAD9wAwA04AMQNbADgDggBCAxwAKB8kAFEfEgBoHwgAaB9un2kfb5+/H8+f/h/fn1EfV59ZH1+fYB9mn2EfZ58xHwgAMR83nzgfPp85Hz+fUB9WnygfLp8pHy+fMB82n8sDEAAIHwgACB8OnwkfD58gHyafIR8nn8sD558AHwafAR8Hn7kDCAC5A9afxQPmn8kD9p/KA9efqADBn7EDtp+3A8afBQBlAAYAZQAbnmkALZ51AHWeRQAankkALJ5VAHSeEABiABQAbAAKAGwAO55uAEmecgBfnnQAb556AJWeYgAHnmQAD55oAJaeawA1nk4ACABOAEieUgBenlQAbp5aAJSeQgAGnkQADp5LADSeTAA6nisAciI2AIciGgCpIg4AsyIGALMi66K0IuyitSLtoqkirqKrIq+isiLqoociiaKRIuKikiLjoqIirKKoIq2ieyIOAIIiBgCCIoSigyKFooYiiKJ7IoGifCLgon0i4aJyInSicyJ1onYieKJ3InmieiKAogsiGgBFIg4AYSIGAGEiYqJkInCiZSJxokUiR6JIIkmiTSJtogsiDKIjIiSiJSImojwiQaJDIkSilCEOANQhBgDUIc6hAyIEoggiCaKUIa6h0CHNodIhz6E8AG6iPQBgoj4Ab6KQIZqhkiGboScDCgAoAz8ALQNUAC4DAQBIACqeaAArnhUAYwAaAGsADgByAAYAcgBXgXMAX4F0AGOBawA3gWwAPIFuAEaBYwDngGQAEZ5lACmCZwAjgWgAKZ5LAA4AUgAGAFIAVoFTAF6BVABigUsANoFMADuBTgBFgUMAx4BEABCeRQAogkcAIoFIACieCQBhAAoAYQAFgWUAGYFpAC+BbwDrgXUAc4FBAASBRQAYgUkALoFPAOqBVQBygQsAZAAOAG4ABgBuAEuedABxnnUAd55kABOeZQAZnmwAPZ5OAAYATgBKnlQAcJ5VAHaeRAASnkUAGJ5MADyeIwOBACMDDgAkA3MAJQN2ACYDAwBTABiCVAAagnMAGYJ0ABuCKQBkADIAcwAaAHkADgChAQYAoQHjnq8B8J6wAfGeeQD1nnoAk56gAeKecwBjnnQAbZ51AOWedgB/nncAiZ5sAAoAbAA3nm0AQ55uAEeebwDNnnIAW55kAA2eZQC5nmgAJZ5pAMueawAznk8AGgBWAA4AWgAGAFoAkp5hAKGeYgAFnlYAfp5XAIieWQD0nk8AzJ5SAFqeUwBinlQAbJ5VAOSeSQAKAEkAyp5LADKeTAA2nk0AQp5OAEaeQQCgnkIABJ5EAAyeRQC4nkgAJJ4BAFUAcp51AHOeAQBBAACeYQABnhMDDAAUAy0AGwMDAE8AoIFVAK+BbwChgXUAsIENALUDEAC/AwgAvwNAn8ED5J/FA1CfyQNgn7UDEJ+3AyCfuQMwn5kDCACZAzifnwNIn6kDaJ+xAwCfkQMIn5UDGJ+XAyifDwCxAxIAvwMIAL8DQZ/BA+WfxQNRn8kDYZ+xAwGftQMRn7cDIZ+5AzGfnwMIAJ8DSZ+hA+yfpQNZn6kDaZ+RAwmflQMZn5cDKZ+ZAzmfCAOSAQsDsQALAyQADAMxAA8DiAARAwsAYQAOAG8ABgBvAA+CcgATgnUAF4JhAAOCZQAHgmkAC4JPAAYATwAOglIAEoJVABaCQQACgkUABoJJAAqCBQB1AAYAdQBxgSME8oRDBPOETwBQgVUAcIFvAFGBJABkACwAbwAWAHoACgB6AH6B3ADZgfwA2oG3Ae6BkgLvgW8A0oFyAFmBcwBhgXQAZYF1ANSBaQAKAGkA0IFqAPCBawDpgWwAPoFuAEiBZAAPgWUAG4FnAOeBaAAfgk4AFABUAAoAVABkgVUA04FaAH2BYQDOgWMADYFOAEeBTwDRgVIAWIFTAGCBRwAKAEcA5oFIAB6CSQDPgUsA6IFMAD2BQQDNgUMADIFEAA6BRQAagQ0AZQAQAHIACAByABGCdQAVgnQEdoR1BHeEZQAFgmkACYJvAA2CTwAIAE8ADIJSABCCVQAUgmEAAYJBAACCRQAEgkkACIIIAxIACQOcAAoDBQB1AAYAdQBvgXcAmJ55AJmeQQDFgFUAboFhAOWAAAA1ANIDRAA1BCIASwQQANgECADYBNqE2QTbhOgE6oTpBOuESwT5hE0E7YRWBFeEOAQIADgE5YQ+BOeEQwTxhEcE9YQ1BFGENgTdhDcE34QYBBAAJwQIACcE9IQrBPiELQTshDAE04QYBOSEHgTmhCME8IQVBAYAFQQBhBYE3IQXBN6E0gPUgwYEB4QQBNKEbwAiAPUAEACZAwgAmQOqg6UDq4O5A8qDxQPLg/UAT55qAXqeawF7nncACAB3AIWeeACNnnkA/4DVAE6ebwD2gHQAl551APyAVwAQAGEACABhAOSAZQDrgGgAJ55pAO+AVwCEnlgAjJ5ZAHiBSQAGAEkAz4BPANaAVQDcgEEAxIBFAMuASAAmnhcAwgAeAAIBDgChAQYAoQHfnq8B7J6wAe2eAgGyngMBs56gAd6e4gAGAOIAqZ7qAMOe9ADVnsIAqJ7KAMKe1ADUnmEADgBvAAYAbwDPnnUA5555APeeYQCjnmUAu55pAMmeTwAGAE8Azp5VAOaeWQD2nkEAop5FALqeSQDIngMDjQEDA4YABAPLAAYDOAEHAy4AZABEAHcAJABgARQAYh4MAGIeaJ5jHmmeAdgBANLdAcDJBdrdAcDkBWABZp5hAWeefwGbnnoABgB6AHyBWgFknlsBZZ53AIeeeACLnnkAj55uAA4AcgAGAHIAWZ5zAGGedABrnm4ARZ5vAC+CcABXnmcABgBnACGBaAAjnm0AQZ5kAAueZQAXgWYAH55PAB4AWAAOAGEABgBhACeCYgADnmMAC4FYAIqeWQCOnloAe4FTAAYAUwBgnlQAap5XAIaeTwAuglAAVp5SAFieRgAOAEkABgBJADCBTQBAnk4ARJ5GAB6eRwAggUgAIp5BACaCQgACnkMACoFEAAqeRQAWgRsAdgAiAPQAEACgAQgAoAHgnqEB4Z6vAe6esAHvnvQA154CAbSeAwG1nsoACADKAMSe1ADWnuIAq57qAMWedgB9nnkA+Z7CAKqeWQAQAGkACABpACmBbgDxgG8A9YB1AGmBWQD4nmEA44BlAL2eTgAIAE4A0YBPANWAVQBogVYAfJ5BAMOARQC8nkkAKIErAPYANgCxAxoAOAQOADceBgA3HjmeWh5cnlseXZ44BOOEQwTvhDYeOJ6xA7GfuQPRn8UD4Z8YBOKEIwTuhCcCDgCRAwYAkQO5n5kD2Z+lA+mfJwLhgS4CMIIvAjGC9gArgvwA1oHqAeyB6wHtgSYC4IFvABoA1QAOAOQABgDkAN+B5gDjgfUALYLVACyC1gAqgtwA1YFvAE2BdQBrgXkAM4LEAN6BxgDigVUADgBlAAYAZQATgWcAIZ5pACuBVQBqgVkAMoJhAAGBQQAAgUUAEoFHACCeSQAqgU8ATIEfAKUDJgAjBBIAOAQIADgEOYRDBF6EoB62nqEet54jBA6EMATRhDUE14Q2BMKEEAQIABAE0IQVBNaEFgTBhBgEGYSlA+ifsQOwn7kD0J/FA+CfZwASACgCCAAoAhyeKQIdnpEDuJ+ZA9ifZwAfgWkALYFvAE+BdQBtgU8ACABPAE6BVQBsgWEAA4FlABWBQQACgUUAFIFHAB6BSQAsgQADUgABAyABAgMfAGcAJgB5ABIAuB4IALgexp65HseezB7Yns0e2Z55AHeBegCRnqAerJ6hHq2ebwAIAG8A9IBzAF2BdQD7gHcAdYFnAB2BaAAlgWkA7oBqADWBUwASAFoACABaAJCeYQDigGMACYFlAOqAUwBcgVUA24BXAHSBWQB2gUgACABIACSBSQDOgEoANIFPANSAQQDCgEMACIFFAMqARwAcgQAAUwCxA2YAIB8yAEgfGgBgHw4AaR8GAGkfa5+/H82f/h/dn2AfYp9hH2OfaB9qn0gfSp9JH0ufUB9Sn1EfU59ZH1ufMR8KADEfM584HzqfOR87n0AfQp9BH0OfIB8inyEfI58oHyqfKR8rnzAfMp8YBBoACB8OABEfBgARHxOfGB8anxkfG58IHwqfCR8LnxAfEp8YBA2ENQRQhDgEXYQAHwKfAR8Dn8UDCgDFA3qfyQN8n8oD0p/LA+KfFQQAhLEDcJ+1A3KftwN0n7kDdp+/A3if4gAyAKABGgCVAw4AnwMGAJ8D+J+lA+qfqQP6n5UDyJ+XA8qfmQPan6AB3J6hAd2erwHqnrAB656RA7qfAwEKAAMBsZ4SARSeEwEVnkwBUJ5NAVGe4gCnnuoAwZ70ANOe/ADcgQIBsJ5pABoAeQAOAMoABgDKAMCe1ADSntwA24F5APOeqADtn8IApp5pAOyAbgD5gW8A8oB1APmAdwCBnlUACgBVANmAVwCAnlkA8p5hAOCAZQDogEEAwIBFAMiASQDMgE4A+IFPANKAAAB0ABMBlAA6BEoAOB8kAFEfEgBoHwgAaB9sn2kfbZ+/H86f/h/en1EfVZ9ZH12fYB9kn2EfZZ9BHwgAQR9Fn0gfTJ9JH02fUB9UnzgfPJ85Hz2fQB9EnxgfEgAoHwgAKB8snykfLZ8wHzSfMR81nxgfHJ8ZHx2fIB8knyEfJZ8IHwgACB8MnwkfDZ8QHxSfER8VnzoEXIQAHwSfAR8Fn6UDJADFAxIA0gMIANID04MTBAOEGgQMhDMEU4TFA82DyQPOg8oDkIPLA7CDtQMIALUDrYO3A66DuQOvg78DzIOlA46DqQOPg7EDrIOvARAAlQMIAJUDiIOXA4mDmQOKg58DjIOvAeiesAHpnpEDhoNoAQgAaAF4nmkBeZ6gAdqeoQHbnhMBF55MAVKeTQFTnnMASADYACQA7wASAPwACAD8ANiBAgGungMBr54SARae7wAvnvQA0Z71AE2e+AD/geUACADlAPuB5gD9gecACZ7qAL+e2AD+gdwA14HiAKWexQAQAMoACADKAL6ezwAuntQA0J7VAEyexQD6gcYA/IHHAAieeQAIAHkA/YB6AHqBqACFg8IApJ5zAFuBdQD6gHcAg55XACQAaQASAG4ACABuAESBbwDzgHAAVZ5yAFWBaQDtgGsAMZ5sADqBbQA/nmEACABhAOGAYwAHgWUA6YBnAPWBVwCCnlkA3YBaAHmBTQAQAFAACABQAFSeUgBUgVMAWoFVANqATQA+nk4AQ4FPANOARwAIAEcA9IFJAM2ASwAwnkwAOYFBAMGAQwAGgUUAyYBUARMAXgoAAAAAAABtaWQgPiBsZW4AAAAcFhMACQAAAEwaEAB/AAAASgAAAB8AAABMGhAAfwAAAEQAAAAXAAAA14UQAGIAAADGAAAAOwAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvZGVfcG9pbnQgPCBzZWxmLmhlYWRlci5oaWdoX3N0YXJ0ICYmIHNlbGYuaGVhZGVyLmhpZ2hfc3RhcnQgPiBTTUFMTF9MSU1JVAAAAMNvEAByAAAALAEAAA0AAADOdRAAagAAAF8DAAAJAAAAznUQAGoAAAC9AQAAHQAAAAAAAAAIAAAABAAAAHUBAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlQ2FwYWNpdHlPdmVyZmxvdwAAAAAABAAAAAQAAAB0AQAAQWxsb2NFcnJsYXlvdXQAAKiTEABbAAAAVgEAAC4AAABjYXBhY2l0eSBvdmVyZmxvdwAAAKiTEABbAAAARQEAADYAAACokxAAWwAAANIEAAAOAAAAYXNzZXJ0aW9uIGZhaWxlZDogc3RhcnQgPD0gZW5kAACokxAAWwAAABAEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IGxlbqiTEABbAAAAEQQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBpbmRleCA8IGxlbgAAAKiTEABbAAAATAUAAA0AAABhc3NlcnRpb24gZmFpbGVkOiBuZXdfY2FwID49IGxlbqiTEABbAAAAnQQAAA0AAAA6hhAAcAAAAC4CAAARAAAAznUQAGoAAAC9AQAAHQAAAG1pZCA+IGxlbgAAAHwYEwAJAAAAOoYQAHAAAAAuAgAAEQAAAM51EABqAAAAvQEAAB0AAAAlMDAlMDElMDIlMDMlMDQlMDUlMDYlMDclMDglMDklMEElMEIlMEMlMEQlMEUlMEYlMTAlMTElMTIlMTMlMTQlMTUlMTYlMTclMTglMTklMUElMUIlMUMlMUQlMUUlMUYlMjAlMjElMjIlMjMlMjQlMjUlMjYlMjclMjglMjklMkElMkIlMkMlMkQlMkUlMkYlMzAlMzElMzIlMzMlMzQlMzUlMzYlMzclMzglMzklM0ElM0IlM0MlM0QlM0UlM0YlNDAlNDElNDIlNDMlNDQlNDUlNDYlNDclNDglNDklNEElNEIlNEMlNEQlNEUlNEYlNTAlNTElNTIlNTMlNTQlNTUlNTYlNTclNTglNTklNUElNUIlNUMlNUQlNUUlNUYlNjAlNjElNjIlNjMlNjQlNjUlNjYlNjclNjglNjklNkElNkIlNkMlNkQlNkUlNkYlNzAlNzElNzIlNzMlNzQlNzUlNzYlNzclNzglNzklN0ElN0IlN0MlN0QlN0UlN0YlODAlODElODIlODMlODQlODUlODYlODclODglODklOEElOEIlOEMlOEQlOEUlOEYlOTAlOTElOTIlOTMlOTQlOTUlOTYlOTclOTglOTklOUElOUIlOUMlOUQlOUUlOUYlQTAlQTElQTIlQTMlQTQlQTUlQTYlQTclQTglQTklQUElQUIlQUMlQUQlQUUlQUYlQjAlQjElQjIlQjMlQjQlQjUlQjYlQjclQjglQjklQkElQkIlQkMlQkQlQkUlQkYlQzAlQzElQzIlQzMlQzQlQzUlQzYlQzclQzglQzklQ0ElQ0IlQ0MlQ0QlQ0UlQ0YlRDAlRDElRDIlRDMlRDQlRDUlRDYlRDclRDglRDklREElREIlREMlREQlREUlREYlRTAlRTElRTIlRTMlRTQlRTUlRTYlRTclRTglRTklRUElRUIlRUMlRUQlRUUlRUYlRjAlRjElRjIlRjMlRjQlRjUlRjYlRjclRjglRjklRkElRkIlRkMlRkQlRkUlRkaMkhAAYgAAAKEAAABHAAAAjJIQAGIAAAAqAQAAMAAAAIySEABiAAAAKwEAABkAAAAAAAAABAAAAAQAAAB2AQAAAAAAAAQAAAAEAAAAdwEAAExheW91dHNpemVhbGlnbmZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgAADxwTABsAAAAlAAAAAgAAACwcEwD1IRAAeQAAAPsAAAABAAAAdC4QAGsAAAAjAQAADgAAAO8nEABrAAAA+AEAAA4AAAB5AQAAFAAAAAQAAAB6AQAAAAAAAAQAAAAEAAAAMAAAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAewEAAAwAAAAEAAAAfAEAAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IArF4QAGcAAADJAAAACgAAAM51EABqAAAAvQEAAB0AAAB1NxAAXwAAAMMFAAAIAEHMvMwAC7EIdTcQAF8AAADfBQAAHgAAAEFycm93IGRhdGEgbm90IGFsaWduZWQAAHU3EABfAAAA9wUAACIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBPcHRpb25zIHdpdGggdGhlIG1ldGFkYXRhIHZlcnNpb24gY2Fubm90IGJlIGNyZWF0ZWQAAACEHhMAXQAAAHU3EABfAAAACgYAAA0AAAD/////VW5zdXBwb3J0ZWQgY3JhdGU6Ok1ldGFkYXRhVmVyc2lvbiAAAB8TACMAAAB1NxAAXwAAABkGAAAOAAAAU3RyZWFtV3JpdGVyIGlzIGNvbmZpZ3VyZWQgdG8gbm90IGVycm9yIG9uIGRpY3Rpb25hcnkgcmVwbGFjZW1lbnQAAAB1NxAAXwAAAFAFAAAOAAAAQ2Fubm90IHdyaXRlIHJlY29yZCBiYXRjaCB0byBzdHJlYW0gd3JpdGVyIGFzIGl0IGlzIGNsb3NlZENhbm5vdCB3cml0ZSBmb290ZXIgdG8gc3RyZWFtIHdyaXRlciBhcyBpdCBpcyBjbG9zZWRhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAAAB0LhAAawAAACMBAAAOAAAA1zIQAHgAAADrBwAACQAAABA5EABvAAAAkAAAAC4AAAAAAAAABAAAAAQAAAAwAAAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAAB9AQAADAAAAAQAAAB+AQAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgCsXhAAZwAAAMkAAAAKAAAAznUQAGoAAAC9AQAAHQAAAK5uEABRAAAAnwAAAB8AAACubhAAUQAAAKEAAAAZAAAASW50ZXJuYWwgZXJyb3I6IGBgAAAMIhMAEQAAAB0iEwABAAAAYXR0ZW1wdGVkIHRvIHRha2Ugb3duZXJzaGlwIG9mIFJ1c3QgdmFsdWUgd2hpbGUgaXQgd2FzIGJvcnJvd2VkAF6MEABXAAAATQAAABUAQYjFzAALBgEAAAB/AQBBmMXMAAslAQAAANoAAABhIG1hcAAAAIABAAAMAAAABAAAAIEBAACCAQAAIABByMXMAAvjAwEAAACDAQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAARXJyb3IAAADiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAIQBAABNYXAga2V5IGlzIG5vdCBhIHN0cmluZyBhbmQgY2Fubm90IGJlIGFuIG9iamVjdCBrZXkA//////////90LhAAawAAACMBAAAOAAAAvpwqkZE2NGDFSEAXEQ6bNKxeEABnAAAAyQAAAAoAAABjYWxsZWQgYE9wdGlvbjo6dW53cmFwX3Rocm93KClgIG9uIGEgYE5vbmVgIHZhbHVlAAAAhQEAADQAAAAEAAAAhgEAAIUBAAA0AAAABAAAAIcBAACIAQAAiQEAAIoBAACLAQAAjAEAAI0BAACOAQAAjwEAAJABAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQAnEYQAGkAAACjAAAAEwAAAJ0BAAD//////////6AkEwBBvMnMAAu/CAQAAAAEAAAAngEAAAAAAAAEAAAABAAAAJ8BAABVdGY4RXJyb3J2YWxpZF91cF90b2Vycm9yX2xlbgAAAKABAAAMAAAABAAAAKEBAAAAAAAABAAAAAQAAACiAQAATWlzc2luZ1JlcXVpcmVkRmllbGRyZXF1aXJlZGVycm9yX3RyYWNlSW5jb25zaXN0ZW50VW5pb25maWVsZGZpZWxkX3R5cGUAAAAAAAgAAAAEAAAAowEAAAAAAAAIAAAABAAAAKQBAABlcnJvcnJhbmdlTWlzc2luZ051bGxUZXJtaW5hdG9yVW5hbGlnbmVkcG9zaXRpb251bmFsaWduZWRfdHlwZVJhbmdlT3V0T2ZCb3VuZHMAAAAAAAAEAAAABAAAAKUBAABTaWduZWRPZmZzZXRPdXRPZkJvdW5kc3NvZmZzZXRUb29NYW55VGFibGVzQXBwYXJlbnRTaXplVG9vTGFyZ2VEZXB0aExpbWl0UmVhY2hlZM51EABqAAAAvQEAAB0AAABLKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAAEV4cGVjdGVkIGEgcmVjb3JkIGJhdGNoLCBidXQgZm91bmQgYSBzY2hlbWFVbnN1cHBvcnRlZCBtZXNzYWdlIGhlYWRlciB0eXBlIGluIElQQyBzdHJlYW06ICcniyYTADAAAAC7JhMAAQAAAEZhaWxlZCB0byBwYXJzZSBzY2hlbWEgZnJvbSBtZXNzYWdlIGhlYWRlckZhaWxlZCB0byBwYXJzZSBkaWN0aW9uYXJ5IGJhdGNoIGZyb20gbWVzc2FnZSBoZWFkZXJVbmFibGUgdG8gcmVhZCBJUEMgbWVzc2FnZSBhcyByZWNvcmQgYmF0Y2hFeHBlY3RlZCBhIHNjaGVtYSBhcyB0aGUgZmlyc3QgbWVzc2FnZSBpbiB0aGUgc3RyZWFtLCBnb3Q6IABUJxMAOwAAAEV4cGVjdGVkIHNjaGVtYSBtZXNzYWdlLCBmb3VuZCBlbXB0eSBzdHJlYW0u4kQQAF8AAADPBgAAEgAAAFVuYWJsZSB0byBnZXQgcm9vdCBhcyBtZXNzYWdlOiAA1CcTAB8AAAD/////SW52YWxpZCBtZXRhZGF0YSBsZW5ndGg6IAAAAAAoEwAZAAAAdC4QAGsAAAAjAQAADgAAANcyEAB4AAAA6wcAAAkAAACsXhAAZwAAAMkAAAAKAAAAYXR0ZW1wdGVkIHRvIHRha2Ugb3duZXJzaGlwIG9mIFJ1c3QgdmFsdWUgd2hpbGUgaXQgd2FzIGJvcnJvd2VkAK5uEABRAAAAiQAAABUAAABpbnZhbGlkIHR5cGU6ICwgZXhwZWN0ZWQgAAAApCgTAA4AAACyKBMACwAAAPJZEABvAAAAGQEAABkAAADOdRAAagAAAL0BAAAdAAAA///////////wKBMAQYjSzAAL+18BAAAAAAAAAKcBAABikRAAZAAAADUAAAAOAAAAtlgQAGQAAAAUAQAAFgAAALZYEABkAAAAJAEAABMAAADXMhAAeAAAAOsHAAAJAAAAbWlkID4gbGVuAAAAVCkTAAkAAABMGhAAfwAAAEoAAAAfAAAATBoQAH8AAABEAAAAFwAAAKgBAACpAQAAqgEAAKsBAACsAQAAtlgQAGQAAAC1AAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuc2NvcmUuc2xpY2UoKS5sZW4oKSA+IHN0cmlkZV9kYXRhLmxlbigpAAC2WBAAZAAAALYAAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5zY29yZS5zbGljZSgpLmxlbigpID4gKHN0cmlkZV9kYXRhLmxlbigpIDw8IDMpICsgNyArIDgAAAC2WBAAZAAAALcAAAAJAAAAtlgQAGQAAAC8AAAAEgAAALZYEABkAAAAvgAAABIAAAC2WBAAZAAAAO0AAAARAAAAtlgQAGQAAADgAAAAEQAAANIzEABnAAAA8wAAABwAAADSMxAAZwAAAP0AAAAcAAAA0jMQAGcAAAAOAQAAHgAAANIzEABnAAAAEQEAACgAAADSMxAAZwAAAE4BAAAeAAAA0jMQAGcAAABTAQAAEAAAANIzEABnAAAAVQEAACUAAADSMxAAZwAAAFoBAAANAAAA0jMQAGcAAAASAQAAIQAAANIzEABnAAAAGQEAAC0AAADSMxAAZwAAABsBAAAOAAAA0jMQAGcAAAAxAQAADgAAANIzEABnAAAAMwEAAA4AAADSMxAAZwAAADcBAAAiAAAA0jMQAGcAAAA5AQAAGQAAANIzEABnAAAAOgEAACUAAADSMxAAZwAAACMBAAA1AAAA0jMQAGcAAAAjAQAATAAAANIzEABnAAAAJgEAACsAAADSMxAAZwAAAAgBAAARAAAA0jMQAGcAAAAIAQAAKgAAANIzEABnAAAABwEAAA0AAADSMxAAZwAAAAEBAAAjAAAA0jMQAGcAAAABAQAACQAAANIzEABnAAAA+QAAAA0AAADSMxAAZwAAALEAAAAnAAAA0jMQAGcAAACzAAAAJQAAANIzEABnAAAANAIAACUAAADSMxAAZwAAAIACAAAiAAAA0jMQAGcAAACBAgAAEgAAANIzEABnAAAAkwIAACIAAADSMxAAZwAAAKACAAAyAAAA0jMQAGcAAACiAgAAFAAAANIzEABnAAAAogIAADQAAADSMxAAZwAAAKQCAAAxAAAA0jMQAGcAAACkAgAAHgAAANIzEABnAAAApQIAABEAAADSMxAAZwAAAKYCAAARAAAA0jMQAGcAAABTAgAAHwAAANIzEABnAAAAWAIAABEAAADSMxAAZwAAAFoCAAARAAAA0jMQAGcAAABeAgAAFgAAANIzEABnAAAAbAIAAA0AAADSMxAAZwAAAG0CAAAQAAAA0jMQAGcAAABkAgAANgAAANIzEABnAAAAZAIAABoAAADSMxAAZwAAAFQCAAA4AAAA0jMQAGcAAAD5AQAAKgAAANIzEABnAAAA+gEAAEIAAADSMxAAZwAAAA0CAAAqAAAA0jMQAGcAAAAOAgAAQAAAANIzEABnAAAAIAIAADgAAADSMxAAZwAAAB8CAAARAAAA0jMQAGcAAAAYAgAAKAAAANIzEABnAAAAGAIAABUAAADSMxAAZwAAABcCAAARAAAA0jMQAGcAAAAaAgAAPwAAANIzEABnAAAAGgIAABEAAADSMxAAZwAAABwCAAARAAAA0jMQAGcAAADTAQAAJQAAANIzEABnAAAA1AEAACMAAADSMxAAZwAAANcBAAAjAAAA0jMQAGcAAADBAQAAJQAAANIzEABnAAAAxQEAABgAAADSMxAAZwAAAMUBAAAvAAAA0jMQAGcAAADNAgAALAAAANIzEABnAAAA4QIAACYAAADSMxAAZwAAAOICAAAWAAAA0jMQAGcAAAD0AgAAJgAAANIzEABnAAAA/QIAAAkAAADSMxAAZwAAAP4CAAAJAAAA0jMQAGcAAACNAwAAGAAAANIzEABnAAAAjwMAABEAAADSMxAAZwAAAHkDAAANAAAA0jMQAGcAAADEAAAACgAAANIzEABnAAAAygAAAAoAAADSMxAAZwAAANEAAAASAAAA0jMQAGcAAACSAAAAJgAAANIzEABnAAAAlwAAAEEAAADSMxAAZwAAAJwAAAA1AAAA0jMQAGcAAACJAQAAHgAAANIzEABnAAAAiQEAABIAAADSMxAAZwAAAIoBAAAXAAAA0jMQAGcAAABFAAAAIQAAANIzEABnAAAATwAAAAkAAABOIxAAXwAAANUAAAAUAAAATiMQAF8AAADVAAAAHgAAAE4jEABfAAAA1gAAABQAAABOIxAAXwAAANYAAAAeAAAATiMQAF8AAADXAAAAFAAAAE4jEABfAAAA1wAAAB4AAABOIxAAXwAAANgAAAAUAAAATiMQAF8AAADYAAAAHgAAAE4jEABfAAAA2QAAABQAAABOIxAAXwAAANkAAAAeAAAATiMQAF8AAADaAAAAFAAAAE4jEABfAAAA2gAAAB4AAABOIxAAXwAAANsAAAAUAAAATiMQAF8AAADbAAAAHgAAAE4jEABfAAAA3AAAABQAAABOIxAAXwAAANwAAAAeAAAATiMQAF8AAADiAAAAFgAAAE4jEABfAAAA4gAAAB4AAABOIxAAXwAAAOMAAAAWAAAATiMQAF8AAADjAAAAHgAAAE4jEABfAAAA5AAAABYAAABOIxAAXwAAAOQAAAAeAAAATiMQAF8AAADlAAAAFgAAAE4jEABfAAAA5QAAAB4AAABOIxAAXwAAAOYAAAAWAAAATiMQAF8AAADmAAAAHgAAAE4jEABfAAAA5wAAABYAAABOIxAAXwAAAOcAAAAeAAAATiMQAF8AAADoAAAAFgAAAE4jEABfAAAA6AAAAB4AAABOIxAAXwAAAOkAAAAWAAAATiMQAF8AAADpAAAAHgAAADo0EABgAAAALgEAACkAAAA6NBAAYAAAAC4BAAAkAAAAOjQQAGAAAAAuAQAAQQAAADo0EABgAAAAKwEAACIAAAA6NBAAYAAAACsBAAAdAAAAOjQQAGAAAAAXAQAADQAAADo0EABgAAAAGQEAAA0AAAA6NBAAYAAAABwBAAAtAAAAOjQQAGAAAAAcAQAAOgAAADo0EABgAAAAKAEAAAkAAAA6NBAAYAAAACABAAAbAAAAOjQQAGAAAAAgAQAAFgAAADo0EABgAAAAoAAAAAwAAAA6NBAAYAAAAKsAAAAJAAAAOjQQAGAAAACtAAAAGAAAADo0EABgAAAArgAAAB0AAAA6NBAAYAAAALkAAAAUAAAAOjQQAGAAAADoAAAAEQAAADo0EABgAAAAygAAADAAAAA6NBAAYAAAANkAAAAdAAAAOjQQAGAAAADXAAAAHQAAADo0EABgAAAAuwAAADAAAAA6NBAAYAAAALIAAAAQAAAAOjQQAGAAAACUAAAAFQAAADo0EABgAAAAlQAAABUAAAA6NBAAYAAAAGABAAASAAAAOjQQAGAAAABgAQAACQAAADo0EABgAAAAVgEAAB8AAAA6NBAAYAAAAFYBAAAMAAAAOjQQAGAAAABXAQAANgAAADo0EABgAAAAVwEAAA0AAAA6NBAAYAAAAFoBAAAWAAAAOjQQAGAAAABOAQAAHwAAADo0EABgAAAATgEAAAwAAAA6NBAAYAAAAEoBAAAJAAAAOjQQAGAAAACvAQAAJgAAADo0EABgAAAAsAEAADUAAAA6NBAAYAAAAJEBAAAnAAAAOjQQAGAAAACSAQAAKgAAADo0EABgAAAAjAEAABEAAAA6NBAAYAAAAIIBAAASAAAAOjQQAGAAAACCAQAACQAAADo0EABgAAAAhAEAAAkAAAA6NBAAYAAAAH8BAAAJAAAAOjQQAGAAAABQAAAAEQAAADo0EABgAAAAUQAAABEAAAA6NBAAYAAAAFMAAAAYAAAAOjQQAGAAAABUAAAAGAAAADo0EABgAAAAXwAAABEAAAA6NBAAYAAAAGwAAAA8AAAAOjQQAGAAAAB0AAAAEQAAADo0EABgAAAAbwAAABUAAACJUxAAYgAAAJQBAAAWAAAAiVMQAGIAAAB+AQAAFAAAAIlTEABiAAAAgQEAABkAAACJUxAAYgAAALIBAAASAAAAiVMQAGIAAACzAQAAEgAAAIlTEABiAAAAXgEAABoAAACJUxAAYgAAAF8BAAAcAAAAiVMQAGIAAADpAQAAFAAAAIlTEABiAAAA7QEAABIAAACJUxAAYgAAAAkCAAAaAAAAiVMQAGIAAAAKAgAAGQAAAIlTEABiAAAAEAIAABoAAACJUxAAYgAAAPgBAAAZAAAAiVMQAGIAAAD+AQAAGgAAAIlTEABiAAAA/wEAABUAAAARXBAAYgAAAI4BAAAtAAAAEVwQAGIAAACrAQAAJgAAABFcEABiAAAArAEAABYAAAARXBAAYgAAAL8BAAAiAAAAEVwQAGIAAADOAQAAGQAAABFcEABiAAAAVgMAACUAAAARXBAAYgAAAFUDAAANAAAAEVwQAGIAAAAXAQAAHwAAABFcEABiAAAAGAEAABUAAAARXBAAYgAAACQDAAAbAAAAEVwQAGIAAAAzAgAACQAAABFcEABiAAAANAIAAAkAAAARXBAAYgAAADUCAAAuAAAAEVwQAGIAAAA7AgAAIQAAABFcEABiAAAAQAIAAA0AAAARXBAAYgAAAHgCAAAhAAAAEVwQAGIAAAB7AgAADQAAABFcEABiAAAAZwIAAA0AAAARXBAAYgAAAGkCAAARAAAAEVwQAGIAAABoAgAADQAAABFcEABiAAAAbQIAAA0AAAARXBAAYgAAAFcCAAANAAAAEVwQAGIAAABYAgAADQAAABFcEABiAAAAYQIAACUAAAARXBAAYgAAAEwCAAA8AAAAEVwQAGIAAABQBAAADQAAABFcEABiAAAASQQAAA0AAAARXBAAYgAAAEIEAAANAAAAEVwQAGIAAADgAQAALQAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9jb250ZXh0cyA8PSBCUk9UTElfTUFYX1NUQVRJQ19DT05URVhUUxFcEABiAAAA4gEAAAUAAAARXBAAYgAAAOYBAAAmAAAAEVwQAGIAAAD/AQAAJgAAABFcEABiAAAAAAIAABYAAAARXBAAYgAAABQCAAAmAAAAEVwQAGIAAAA3AwAADgAAABFcEABiAAAAowIAAAkAAAARXBAAYgAAAKQCAAAJAAAAEVwQAGIAAACuAgAAIAAAABFcEABiAAAApgIAADIAAAARXBAAYgAAAKcCAAANAAAAEVwQAGIAAAD7AgAAIQAAABFcEABiAAAAAQMAABUAAAARXBAAYgAAAAADAAARAAAAEVwQAGIAAAACAwAAKgAAABFcEABiAAAABAMAABUAAAARXBAAYgAAAAYDAAAlAAAAEVwQAGIAAADmAgAADQAAABFcEABiAAAA5wIAABgAAAARXBAAYgAAAOgCAAANAAAAEVwQAGIAAADvAgAAFQAAABFcEABiAAAA7gIAABEAAAARXBAAYgAAAPACAAARAAAAEVwQAGIAAADyAgAAJQAAABFcEABiAAAA0QIAAA0AAAARXBAAYgAAANICAAANAAAAEVwQAGIAAADeAgAAJAAAABFcEABiAAAA1gIAABEAAAARXBAAYgAAANcCAAAqAAAAEVwQAGIAAAC7AgAAJgAAABFcEABiAAAAuwIAAA0AAAARXBAAYgAAAMECAAAVAAAAEVwQAGIAAADEAgAAHgAAABFcEABiAAAAxgIAABUAAAARXBAAYgAAAKMDAAAcAAAAEVwQAGIAAADOAwAAGgAAABFcEABiAAAAzwMAABkAAAARXBAAYgAAAK8DAAAjAAAAEVwQAGIAAADCAwAAHQAAABFcEABiAAAAcwMAADIAAAC/VhAAZAAAALIAAAAGAAAAv1YQAGQAAADqAAAAOAAAAL9WEABkAAAA6wAAABUAAAC/VhAAZAAAAPgAAAAVAAAAv1YQAGQAAAAnAQAAEgAAAL9WEABkAAAAOQEAABUAAAC/VhAAZAAAAEUBAAAUAAAAED4QAIMAAAA6AAAAFwAAABA+EACDAAAAPQAAACYAAAAQPhAAgwAAAD0AAAANAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmZmVyLmxlbigpID49IG51bGxfY291bnROYBAAaQAAAMwAAAAJAAAATmAQAGkAAADhAAAAGAAAAE51bWJlciBvZiB2YWx1ZXMgcmVhZDogLCBkb2Vzbid0IG1hdGNoIGV4cGVjdGVkOiAAAACUOxMAFwAAAKs7EwAaAAAAYXNzZXJ0aW9uIGZhaWxlZDogYml0X3dpZHRoIDw9IDY0AAAAFGwQAGQAAABXAAAACQAAABRsEABkAAAA8QAAACcAAABiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQUbBAAZAAAAIIBAAA7AAAAFGwQAGQAAACFAQAAIAAAABRsEABkAAAAewEAAEcAAAAUbBAAZAAAAHwBAAAXAAAAFGwQAGQAAACiAQAAOwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSA+PSBtYXhfdmFsdWVzFGwQAGQAAAC+AQAACQAAABRsEABkAAAAzgEAADsAAAAUbBAAZAAAAOEBAAAbAAAAFGwQAGQAAADjAQAAJwAAABRsEABkAAAAxgEAADMAAAAUbBAAZAAAAMcBAAAiAAAAFGwQAGQAAADJAQAAFwAAABRsEABkAAAA5AEAADoAAAAUbBAAZAAAAPUBAAAzAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5jdXJyZW50X3ZhbHVlLmlzX3NvbWUoKQAAFGwQAGQAAAAEAgAAEQAAALIBAAAwAAAABAAAALMBAACyAQAAMAAAAAQAAAC0AQAAsgEAADAAAAAEAAAAtQEAALIBAAAwAAAABAAAALYBAACyAQAAMAAAAAQAAAC3AQAAsgEAADAAAAAEAAAAuAEAALIBAAAwAAAABAAAALkBAAC6AQAAOAAAAAQAAAC7AQAASbCekHpOLC/LbknqMggYfB2y9+s5jHY/bp6hQw4xO1cGFsb1IWxDVWzMGSiQApVawHHNK/WXKix1JwoV9WuZpB+hT8T8IUEh1iLFiOnXsXiCl9us/xj5ogqzS4zEu4wpNZTMQjy9Tcz3+cJcdQSaAv0tEgMJOI1CEVkINR0E9PCH/FZ7jfIxPLY3ukYvCXyWtaHfx+CoTEOS/RHiY2P8o2OYOC6bqJpWsC9YjrdR6IcHIBtNdP6iSb6f5/cakgR4bWlkID4gbGVuAAAAwD4TAAkAAADOdRAAagAAAL0BAAAdAAAAc2V0X2RhdGEgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQeahAAYAAAABcDAAA6AAAAHmoQAGAAAACuAwAAEgAAAB5qEABgAAAAvQMAADUAAAAeahAAYAAAAL4DAAA1AAAAHmoQAGAAAAC/AwAANQAAAE5vdCBlbm91Z2ggYnl0ZXMgdG8gZGVjb2RlAACDTxAAcwAAAHAAAAAeAAAAg08QAHMAAABxAAAAHgAAAEFycm93UHJlZGljYXRlIHByZWRpY2F0ZSByZXR1cm5lZCAgcm93cywgZXhwZWN0ZWQgAACQPxMAIgAAALI/EwAQAAAAAAAAAJlLEABzAAAAdQAAAA0AAACZSxAAcwAAAIEAAAAvAAAAmUsQAHMAAACYAAAAFwAAAG91dCBvZiBvcmRlcghAEwAMAAAAmUsQAHMAAACSAAAAIwAAAJlLEABzAAAAjAAAACcAAACZSxAAcwAAAIsAAABUAAAAmUsQAHMAAACPAAAAHwAAAJlLEABzAAAAkAAAAB8AAACZSxAAcwAAALQAAAAYAAAAmUsQAHMAAADoAAAALAAAAJlLEABzAAAA7wAAABwAAABzZWxlY3Rpb24gZXhjZWVkcyB0aGUgbnVtYmVyIG9mIHNlbGVjdGVkIHJvd3MAAACZSxAAcwAAABoBAAASAAAAmUsQAHMAAAA3AQAAIwAAAJlLEABzAAAAOgEAAB8AAACZSxAAcwAAAEoBAAAXAAAAc2VsZWN0aW9uIGNvbnRhaW5zIGxlc3MgdGhhbiB0aGUgbnVtYmVyIG9mIHNlbGVjdGVkIHJvd3MMQRMAOAAAAJlLEABzAAAAQQEAABEAAACZSxAAcwAAAJEBAAAdAAAAmUsQAHMAAACSAQAAEwAAAJlLEABzAAAAkwEAABMAAACZSxAAcwAAAOcBAAAjAAAAmUsQAHMAAADrAQAAHwAAAJlLEABzAAAA1gEAACEAAACZSxAAcwAAAP4BAAAdAAAAmUsQAHMAAAACAgAAFwAAAJlLEABzAAAACwIAAC0AAACZSxAAcwAAAA8CAAAbAAAAmUsQAHMAAAANAgAASgAAAFQ7EABvAAAAKgAAABYAAABUOxAAbwAAADoAAAAUAAAAVDsQAG8AAABDAAAAFAAAAFVuc3VwcG9ydGVkIGRhdGEgdHlwZTogADxCEwAXAAAAVDsQAG8AAABeAAAAEgAAAJIMEAB1AAAAKQAAACIAAACSDBAAdQAAACoAAAAJAAAAkgwQAHUAAAAwAAAAIgAAAJIMEAB1AAAAMQAAAAkAAACSDBAAdQAAADkAAAAJAAAAaW5jb25zaXN0ZW50IERFTFRBX0JZVEVfQVJSQVkgbGVuZ3RocywgcHJlZml4ZXM6ICwgc3VmZml4ZXM6IAAAALxCEwAxAAAA7UITAAwAAACSDBAAdQAAAFUAAAAnAAAAkgwQAHUAAABXAAAAJgAAAJIMEAB1AAAAZQAAACkAAACSDBAAdQAAAGUAAAASAAAAZW9mIGRlY29kaW5nIGJ5dGUgYXJyYXkAkgwQAHUAAAB0AAAAJwAAAJIMEAB1AAAAdgAAACYAAACSDBAAdQAAAIQAAAApAAAAkgwQAHUAAACEAAAAEgAAAFB9EABuAAAAewAAAEwAAABQfRAAbgAAANQAAAApAAAARGVmaW5pdGlvbiBsZXZlbHMgc2hvdWxkIGV4aXN0IHdoZW4gZGF0YSBpcyBsZXNzIHRoYW4gbGV2ZWxzIQAAAB5qEABgAAAAjAMAAAUAAAAeahAAYAAAAI0DAAAFAAAAHmoQAGAAAACOAwAABQAAAB5qEABgAAAAjwMAAAUAAAC/VhAAZAAAALIAAAAGAAAAZW5jb3VudGVyZWQgbm9uIFVURi04IGRhdGE6IFREEwAcAAAAvAEAALABAAAIAAAAvQEAAL4BAAC/AQAAwAEAAMEBAADCAQAAwwEAAMQBAACwAQAACAAAAMUBAAC+AQAAxgEAAMcBAADIAQAAwgEAAMMBAABpbnZhbGlkIGRhdGEgdHlwZSBmb3IgYnl0ZSBhcnJheSByZWFkZXIgLSAAAMhEEwAqAAAAvAEAALABAAAIAAAAyQEAAMQBAACwAQAACAAAAMoBAADpDRAAdAAAAIAAAABLAAAAsgEAADAAAAAEAAAAywEAAMwBAADNAQAAzgEAAM8BAADQAQAA0QEAANIBAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkNEAB0AAAAjAAAAEsAAACyAQAAMAAAAAQAAADeAQAA3wEAAOABAADhAQAAzwEAAOIBAADjAQAA5AEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAASW52YWxpZC9VbnN1cHBvcnRlZCBlbmNvZGluZyB0eXBlIGZvciBkaWN0aW9uYXJ5OiAAAOxFEwAyAAAAbm8gZGVjb2RlciBzZXR1bnN1cHBvcnRlZCBlbmNvZGluZyBmb3IgYnl0ZSBhcnJheTogADZGEwAlAAAAbWlzc2luZyBkaWN0aW9uYXJ5IHBhZ2UgZm9yIGNvbHVtbgAA6Q0QAHQAAAByAQAAGAAAAOkNEAB0AAAAfgEAABcAAADpDRAAdAAAAIcBAAApAAAA6Q0QAHQAAACQAQAAIQAAAOkNEAB0AAAAewEAABYAAADpDRAAdAAAAKYBAAApAAAA6Q0QAHQAAAC/AQAAGwAAAEluc3VmZmljaWVudCBkZWx0YSBsZW5ndGggYnl0ZSBhcnJheSBieXRlc25lZ2F0aXZlIGRlbHRhIGxlbmd0aCBieXRlIGFycmF5IGxlbmd0aAAAAOkNEAB0AAAA5AEAABgAAADpDRAAdAAAAOYBAAAoAAAA6Q0QAHQAAADpAQAAFwAAAOkNEAB0AAAA7wEAACQAAADpDRAAdAAAAAICAAAoAAAA6Q0QAHQAAAAfAgAAGAAAAOUBAACwAQAACAAAAOYBAAC+AQAA5wEAAOgBAADpAQAAwgEAAMMBAABpbnZhbGlkIGRhdGEgdHlwZSBmb3IgYnl0ZSBhcnJheSByZWFkZXIgcmVhZCB0byB2aWV3IHR5cGUgLSDURxMAPAAAAOUBAACwAQAACAAAAOoBAABkaWN0aW9uYXJ5IHJlcXVpcmVkIGZvciBkaWN0aW9uYXJ5IGVuY29kaW5nAN8FEAB5AAAATgEAABYAAADfBRAAeQAAAJ4BAAApAAAA3wUQAHkAAADPAQAAIAAAAN8FEAB5AAAACwIAABsAAADfBRAAeQAAACoCAAAWAAAA3wUQAHkAAAAsAgAAKAAAAN8FEAB5AAAAQAIAACgAAADfBRAAeQAAAE0CAAAoAAAA3wUQAHkAAABtAgAAFgAAAN8FEAB5AAAAcAIAACkAAADfBRAAeQAAAIkCAAAuAAAA3wUQAHkAAACkAgAACQAAAN8FEAB5AAAAegIAACIAAADfBRAAeQAAAJICAAAsAAAA3wUQAHkAAACQAgAAIgAAAGZsb2F0IDE2IHR5cGUgbXVzdCBiZSAyIGJ5dGVzLCBnb3QgAERJEwAjAAAAaW50ZXJ2YWwgdHlwZSBtdXN0IGNvbnNpc3Qgb2YgMTIgYnl0ZXMgZ290IABwSRMAKwAAAGRlY2ltYWwgMzIgdHlwZSB0b28gbGFyZ2UsIG11c3QgYmUgbGVzcyB0aGVuIDQgYnl0ZXMsIGdvdCAAAKRJEwA6AAAAZGVjaW1hbCA2NCB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoZW4gOCBieXRlcywgZ290IAAA6EkTADoAAABkZWNpbWFsIDEyOCB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoYW4gMTYgYnl0ZXMsIGdvdCAsShMAPAAAAOsBAACoAQAACAAAAOwBAADtAQAA7gEAAO8BAADwAQAA8QEAAPIBAABkZWNpbWFsIDI1NiB0eXBlIHRvbyBsYXJnZSwgbXVzdCBiZSBsZXNzIHRoYW4gMzIgYnl0ZXMsIGdvdCCYShMAPAAAAGludmFsaWQgZGF0YSB0eXBlIGZvciBmaXhlZCBsZW5ndGggYnl0ZSBhcnJheSByZWFkZXIgLSAA3EoTADcAAABpbnZhbGlkIHBoeXNpY2FsIHR5cGUgZm9yIGZpeGVkIGxlbmd0aCBieXRlIGFycmF5IHJlYWRlciAtIAAcSxMAOwAAAOsBAACoAQAACAAAAPMBAACyAQAAMAAAAAQAAAD0AQAA9QEAAPYBAAD3AQAAzwEAAPgBAAD5AQAA+gEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAsgEAADAAAAAEAAAA+wEAAPwBAAD9AQAA/gEAAM8BAAD/AQAAAAIAAAECAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAALIBAAAwAAAABAAAAAICAAADAgAABAIAAAUCAADPAQAABgIAAAcCAAAIAgAA0wEAANQBAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABNb250aERheU5hbm8gaW50ZXJ2YWxzIG5vdCBzdXBwb3J0ZWSyAQAAMAAAAAQAAAAJAgAACgIAAAsCAAAMAgAAzwEAAA0CAAAAAgAAAQIAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAsgEAADAAAAAEAAAADgIAAA8CAAAQAgAAEQIAAM8BAAASAgAABwIAAAgCAADTAQAA1AEAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAALoBAAA4AAAABAAAABMCAAAUAgAAFQIAABYCAAAXAgAAGAIAABkCAAAaAgAAGwIAANQBAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAAATDBAAfgAAACgBAAAJAAAAEwwQAH4AAAAqAQAADgAAABMMEAB+AAAANAEAACQAAAATDBAAfgAAADUBAAAnAAAAEwwQAH4AAAA2AQAAIwAAABMMEAB+AAAAPQEAADkAAAATDBAAfgAAAD0BAAAbAAAAdG9vIGZldyBieXRlcyBpbiBkaWN0aW9uYXJ5IHBhZ2UsIGV4cGVjdGVkICBnb3QgFE4TACsAAAA/ThMABQAAAHVuc3VwcG9ydGVkIGVuY29kaW5nIGZvciBmaXhlZCBsZW5ndGggYnl0ZSBhcnJheTogAABUThMAMgAAABMMEAB+AAAAlQEAABgAAAATDBAAfgAAAJkBAAAlAAAAEwwQAH4AAACcAQAAFQAAABMMEAB+AAAAnwEAADUAAAATDBAAfgAAAJ8BAAAWAAAAEwwQAH4AAACkAQAANAAAABMMEAB+AAAAtgEAABwAAAATDBAAfgAAAMgBAAAkAAAAEwwQAH4AAADAAQAAIAAAAGVuY291bnRlcmVkIGFycmF5IHdpdGggaW5jb3JyZWN0IGxlbmd0aCwgZ290ICBleHBlY3RlZCAAIE8TAC0AAABNTxMACgAAABMMEAB+AAAA1QEAACUAAAATDBAAfgAAANcBAAAuAAAAEwwQAH4AAADeAQAAJAAAABMMEAB+AAAA9QEAAAkAAAATDBAAfgAAAPYBAAAbAAAAEwwQAH4AAAD4AQAAGwAAABMMEAB+AAAA+gEAAA0AAACZSxAAcwAAAGMAAAARAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmZmVyLmxlbigpID49IG51bGxfY291bnROYBAAaQAAAMwAAAAJAAAATmAQAGkAAADhAAAAGAAAAE51bWJlciBvZiB2YWx1ZXMgcmVhZDogLCBkb2Vzbid0IG1hdGNoIGV4cGVjdGVkOiAAAAA0UBMAFwAAAEtQEwAaAAAATmAQAGkAAAB3AQAAGQAAAE5gEABpAAAAgQEAABkAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLnJsZV9kZWNvZGVyLmlzX3NvbWUoKU5gEABpAAAAigEAAAkAAABNdXN0IGNhbGwgc2V0X2RpY3QoKSBmaXJzdCEA1FATABsAAABOYBAAaQAAAIsBAAAJAAAATmAQAGkAAACcAQAACQAAAE5gEABpAAAAnQEAAAkAAABCaXQgcmVhZGVyIGlzIG5vdCBpbml0aWFsaXplZAAAAChREwAdAAAATmAQAGkAAAA8AgAACQAAAGluc3VmZmljaWVudCBtaW5pIGJsb2NrIGJpdCB3aWR0aHNOb3QgZW5vdWdoIGRhdGEgdG8gZGVjb2RlICdtaW5fZGVsdGEnJ21pbl9kZWx0YScgdG9vIGxhcmdlTmAQAGkAAACsAgAADAAAACd2YWx1ZXNfcGVyX21pbmlfYmxvY2snIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAzMiBnb3QgAAAAzFETADUAAAAnYmxvY2tfc2l6ZScgbXVzdCBiZSBhIG11bHRpcGxlIG9mICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snIGdvdCAgYW5kIAxSEwA/AAAAS1ITAAUAAAAnYmxvY2tfc2l6ZScgbXVzdCBiZSBhIG11bHRpcGxlIG9mIDEyOCwgZ290IGBSEwAsAAAATm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAnYmxvY2tfc2l6ZSdpbnZhbGlkICdibG9ja19zaXplJ05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ21pbmlfYmxvY2tzX3Blcl9ibG9jaydpbnZhbGlkICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snTm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAndmFsdWVzX2xlZnQnaW52YWxpZCAndmFsdWVzX2xlZnQnTm90IGVub3VnaCBkYXRhIHRvIGRlY29kZSAnZmlyc3RfdmFsdWUnZmlyc3QgdmFsdWUgdG9vIGxhcmdlAABOYBAAaQAAAMUCAAAJAAAATmAQAGkAAADZAgAANwAAAE5gEABpAAAA3gIAACcAAABFeHBlY3RlZCB0byByZWFkICB2YWx1ZXMgZnJvbSBtaW5pYmxvY2sgZ290IMhTEwARAAAA2VMTABsAAABOYBAAaQAAABkDAAAfAAAATmAQAGkAAAAfAwAANwAAAE5gEABpAAAAJQMAACwAAABFeHBlY3RlZCB0byBza2lwICB2YWx1ZXMgZnJvbSBtaW5pIGJsb2NrIGdvdCAuAAA0VBMAEQAAAEVUEwAcAAAAYVQTAAEAAABiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQUbBAAZAAAAPUBAAAzAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5jdXJyZW50X3ZhbHVlLmlzX3NvbWUoKQAAFGwQAGQAAAAEAgAAEQAAACwCAAAwAAAABAAAAC0CAAAsAgAAMAAAAAQAAAAuAgAALAIAADAAAAAEAAAALwIAACwCAAAwAAAABAAAADACAAAsAgAAMAAAAAQAAAAxAgAALAIAADAAAAAEAAAAMgIAACwCAAAwAAAABAAAADMCAAAsAgAAMAAAAAQAAAA0AgAALAIAADAAAAAEAAAANQIAACwCAAAwAAAABAAAADYCAAAsAgAAMAAAAAQAAAA3AgAALAIAADAAAAAEAAAAOAIAACwCAAAwAAAABAAAADkCAAAsAgAAMAAAAAQAAAA6AgAALAIAADAAAAAEAAAAOwIAACwCAAAwAAAABAAAADwCAAAsAgAAMAAAAAQAAAA9AgAALAIAADAAAAAEAAAAPgIAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAGJQEABrAAAAuAAAADwAAABiUBAAawAAAL0AAAA8AAAApBddj0p1IC1jlr4w3kLr7I3ResKkGSF32RXbngUX6YzI38/gHY6V+Cw560n3/WZPTJqoXyEsQuR+RYOvg201XDJloBydQ7YeYZGsDLUK81pubCjo7Cqwtv0vbsrQ3pWAH6FPxPwhQSHWIsWI6dexeJSCiwjcagIZQeaoCR/zc2V7O1YNFzc+RhlD6Yd/hRxS5FRR3lWEjTS1ZKKSuuhvGRCfZPHaaP4G7yatjQonws2L2qjMuJ7G9LBR3guMn66EGWL6Rh0Viu4YS3IKpXssrUlI6zz1ZfGccblydT5HjUK+nCqRkTY0YMVIQBcRDps0aqMshJxtVfiTNJy32PbsKziwhsyCKnpMRRJS+jEiJkOmJuXsSwD/GzcFFWtUvOvO4glLZyaNXdZwj6AmoOh7no71r478nL35Zpxe86FyNeCH/FZ7jfIxPLY3ukYvCXyW0fidydGl/c5W4SOD4clHcTX8EWXtUm++JzmV/3oBUuVyfspTfoQ6K9lFQ5fxtd+vtaHfx+CoTEOS/RHiY2P8o2OYOC6bqJpWsC9YjrdR6IetR+fPNHAYPwCyAEDGFTLI7BeAjnZ3GipCNpjMZUnJ/DrxxBg8KB1fOIpReT+M5+xqRqZKJ4y4Jm5AmvMNgeyB87zQDEnzJyLDyjNAJ+6YoVR1LppKF+jONZMioJSSTzvck6FJuSR7lgW4uQDRfsYMKdvkcvmpKCl5lOgRihwXuhNJIe4A56RTQvckt1Iyvvlkm5L1DI4LYM1oZ9Ph41C5ClGzLBKqEuoLWd7b1Oy8Oe6bMrgUntG5cMd4s0FYFxE/AgAAAAAAAP//////////+FgTAEGQss0AC4YB1zIQAHgAAADrBwAACQAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXnUvQwWTYxmnA9FZIsitp6dQooM/ty6wqcqBMgFsqzLt84FA5hqJmElzQK+h5WqMNlLOwZ2P6xfPXMpxYUMHCaTQAIAABQAAAAEAAAAQQIAQaCzzQAL+ggBAAAAQgIAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAgAAAAIAAAAQwIAAAAAAAAEAAAABAAAAEQCAABUb29CaWdnaXZlbm1heEJ1ZmZlclRvb1NtYWxsbWluRW1wdHlIZWFkZXJIZWFkZXJNaXNtYXRjaGV4cGVjdGVkX2xlbmdvdF9sZW5MaXRlcmFsbGVuc3JjX2xlbmRzdF9sZW5Db3B5UmVhZENvcHlXcml0ZU9mZnNldG9mZnNldGRzdF9wb3MAAAAAAAQAAAAEAAAARQIAAFN0cmVhbUhlYWRlcmJ5dGUAAAAABAAAAAQAAABGAgAAU3RyZWFtSGVhZGVyTWlzbWF0Y2hieXRlc1Vuc3VwcG9ydGVkQ2h1bmtUeXBlAAAAAAAAAAQAAAAEAAAARwIAAFVuc3VwcG9ydGVkQ2h1bmtMZW5ndGhoZWFkZXIAAAAABAAAAAQAAABIAgAAAAAAAAQAAAAEAAAASQIAAENoZWNrc3VtZXhwZWN0ZWRnb3QAfgAQAIAAAAChAQAALgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IENBUEFDSVRZYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5oZWlnaHQgLSAxlHEQAHsAAACtAgAACQAAAJRxEAB7AAAAsQIAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBzcmMubGVuKCkgPT0gZHN0LmxlbigplHEQAHsAAABKBwAABQAAAJRxEAB7AAAAxwQAACMAAACUcRAAewAAAAoFAAAkAAAAYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5ub2RlLmhlaWdodCAtIDEAAACUcRAAewAAAPoDAAAJAAAAPmcQAH8AAABYAgAAMAAAAE5vbmUAAAAABAAAAAQAAAAqAgAAU29tZQAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAEsCAAAMAAAABAAAAEwCAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yTGF5b3V0RXJyb3IAALEHEABtAAAATAAAAAoAAADOdRAAagAAAL0BAAAdAAAAAAAAAAQAAAAEAAAATQIAQai8zQALIU4CAAA0AAAABAAAAE8CAABQAgAALAAAAAQAAABRAgAAAQBB1LzNAAuJJlBhcnF1ZXQgZXJyb3I6IABUXhMADwAAAE5ZSTogAAAAbF4TAAUAAABFT0Y6IAAAAHxeEwAFAAAAQXJyb3c6IACMXhMABwAAAEluZGV4ICBvdXQgb2YgYm91bmQ6IAAAAJxeEwAGAAAAol4TAA8AAABFeHRlcm5hbDogAADEXhMACgAAAE5lZWRNb3JlRGF0YTogAADYXhMADgAAAE5lZWRNb3JlRGF0YVJhbmdlOiAuLgAAAPBeEwATAAAAA18TAAIAAABJbnRlZ2VyIG92ZXJmbG93OiAAABhfEwASAAAAUgIAAAgAAAAEAAAAhgAAAFICAAAIAAAABAAAAFMCAACGAAAANF8TAFQCAABVAgAAVgIAAFcCAABYAgAAWQIAACAAAAAIAAAAWgIAAFkCAAAgAAAACAAAAFsCAABaAgAAcF8TAFwCAABdAgAAXgIAAF8CAABgAgAAYQIAABQAAAAEAAAAhwAAAGECAAAUAAAABAAAAGICAACHAAAArF8TAGMCAABkAgAAZQIAAGYCAABYAgAAQAIAABQAAAAEAAAAZwIAAEACAAAUAAAABAAAAEECAABnAgAA6F8TAGgCAABpAgAAZQIAAGoCAABYAgAASW5jb21wYXRpYmxlIHR5cGUuIEZpZWxkICcnIGhhcyB0eXBlICwgYXJyYXkgaGFzIHR5cGUgAAAkYBMAGgAAAD5gEwALAAAASWATABEAAABOAgAANAAAAAQAAACHAQAAawIAAIkBAABsAgAAbQIAAIwBAABuAgAAbwIAAI8BAABwAgAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZXQqEABwAAAA3gAAABoAAABEYXRhdHlwZSAgaXMgbm90IHlldCBzdXBwb3J0ZWQAAARhEwAJAAAADWETABUAAAB0KhAAcAAAAA4BAAAfAAAAdCoQAHAAAAAUAQAAPwAAAHQqEABwAAAAGQEAAC8AAAB0KhAAcAAAACoBAAA7AAAAdCoQAHAAAAArAQAAHAAAAHQqEABwAAAALAEAADsAAAB0KhAAcAAAAC0BAAAcAAAAdCoQAHAAAAAzAQAAOwAAAHQqEABwAAAANAEAABwAAAB0KhAAcAAAADUBAAA7AAAAdCoQAHAAAAA2AQAAHAAAAHQqEABwAAAAZQEAAD8AAAB0KhAAcAAAAGYBAAAgAAAAdCoQAHAAAABpAQAAJAAAAHQqEABwAAAApgEAADsAAAB0KhAAcAAAAMABAAA7AAAAdCoQAHAAAADBAQAAHAAAAHQqEABwAAAAwgEAADsAAAB0KhAAcAAAAMMBAAAcAAAAdCoQAHAAAADdAQAARwAAAHQqEABwAAAA3gEAACgAAAB0KhAAcAAAAN8BAABHAAAAdCoQAHAAAADgAQAAKAAAAHQqEABwAAAADAIAACsAAAB0KhAAcAAAAPQBAAAcAAAAdCoQAHAAAAD1AQAAJwAAAHQqEABwAAAABwIAACQAAAB0KhAAcAAAAAgCAAAvAAAAYXNzZXJ0aW9uIGZhaWxlZDogcmFuZ2UuZW5kIDw9IG51bGxzLmxlbigpAAB0KhAAcAAAAPkBAAAZAAAAdCoQAHAAAAD7AQAAJAAAAHQqEABwAAAAAAIAAC8AAAB0KhAAcAAAABACAAAYAAAAYXNzZXJ0aW9uIGZhaWxlZDogSzo6ZnJvbV91c2l6ZShkaWN0aW9uYXJ5LmxlbigpKS5pc19zb21lKCkAtzoQAHUAAAA7AAAACQAAALc6EAB1AAAAZgAAACQAAAC3OhAAdQAAAGcAAAAjAAAAtzoQAHUAAABrAAAAJQAAALc6EAB1AAAAeAAAABoAAAC3OhAAdQAAAIsAAAA7AAAAZGljdGlvbmFyeSBrZXkgYmV5b25kIGJvdW5kcyBvZiBkaWN0aW9uYXJ5OiAwLi4A/GMTAC8AAABxAgAACAAAAAQAAAByAgAAcwIAAHQCAAB1AgAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAtzoQAHUAAAChAAAAUgAAAGNhc3Qgc2hvdWxkIGJlIGluZmFsbGlibGUAAAC3OhAAdQAAALwAAAAaAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF0Y2hlcyEoZGF0YV90eXBlLCBBcnJvd1R5cGU6OkRpY3Rpb25hcnkoXywgXykpAAC3OhAAdQAAAIQAAAAJAAAAtzoQAHUAAADOAAAAFgAAAJEQEABsAAAAwwAAACAAAACREBAAbAAAAMkAAAAiAAAAkRAQAGwAAADKAAAAHwAAAJEQEABsAAAAzQAAACkAAACREBAAbAAAAM4AAAAZAAAAkRAQAGwAAADSAAAAEQAAAAAAAAAEAAAABAAAAIUCAABNSUxMSVMAAAAAAAAEAAAABAAAAIYCAABNSUNST1MAAAAAAAAEAAAABAAAAIcCAABOQU5PUwAAAIgCAACoAQAACAAAAIkCAACKAgAAiwIAAIwCAACNAgAAjgIAAI8CAACQAgAAqAEAAAgAAACRAgAAigIAAJICAACTAgAAlAIAAI4CAACPAgAAlQIAAKgBAAAIAAAAlgIAAIoCAACXAgAAmAIAAJkCAACOAgAAjwIAAJoCAACoAQAACAAAAJsCAACKAgAAnAIAAJ0CAACeAgAAjgIAAI8CAACfAgAAqAEAAAgAAACgAgAAigIAAKECAACiAgAAowIAAI4CAACPAgAApAIAAKgBAAAIAAAApQIAAIoCAACmAgAApwIAAKgCAACOAgAAjwIAAKkCAACoAQAACAAAAKoCAACKAgAAqwIAAKwCAACtAgAAjgIAAI8CAACuAgAAqAEAAAgAAACvAgAAigIAALACAACxAgAAsgIAAI4CAACPAgAAswIAAKgBAAAIAAAAtAIAAIoCAAC1AgAAtgIAALcCAACOAgAAjwIAALgCAACoAQAACAAAALkCAACKAgAAugIAALsCAAC8AgAAjgIAAI8CAAC9AgAAqAEAAAgAAAC+AgAAigIAAL8CAADAAgAAwQIAAI4CAACPAgAAwgIAAKgBAAAIAAAAwwIAAIoCAADEAgAAxQIAAMYCAACOAgAAjwIAAMcCAACoAQAACAAAAMgCAACKAgAAyQIAAMoCAADLAgAAjgIAAI8CAADMAgAAqAEAAAgAAADNAgAAigIAAM4CAADPAgAA0AIAAI4CAACPAgAA0QIAAKgBAAAIAAAA0gIAAIoCAADTAgAA1AIAANUCAACOAgAAjwIAANYCAACoAQAACAAAANcCAACKAgAA2AIAANkCAADaAgAAjgIAAI8CAAB1bnN1cHBvcnRlZCBkYXRhIHR5cGUgZm9yIGJ5dGUgYXJyYXkgZGljdGlvbmFyeSByZWFkZXIgLSAAAABUaBMAOQAAAGludmFsaWQgbm9uLWRpY3Rpb25hcnkgZGF0YSB0eXBlIGZvciBieXRlIGFycmF5IGRpY3Rpb25hcnkgcmVhZGVyIC0gmGgTAEQAAACpAgAAqAEAAAgAAADbAgAAmgIAAKgBAAAIAAAA3AIAANECAACoAQAACAAAAN0CAADHAgAAqAEAAAgAAADeAgAAlQIAAKgBAAAIAAAA3wIAAJ8CAACoAQAACAAAAOACAADCAgAAqAEAAAgAAADhAgAAiAIAAKgBAAAIAAAA4gIAAL0CAACoAQAACAAAAOMCAACzAgAAqAEAAAgAAADkAgAAkAIAAKgBAAAIAAAA5QIAAK4CAACoAQAACAAAAOYCAAC4AgAAqAEAAAgAAADnAgAA1gIAAKgBAAAIAAAA6AIAAKQCAACoAQAACAAAAOkCAADMAgAAqAEAAAgAAADqAgAAZGljdGlvbmFyeSB0b28gbGFyZ2UgZm9yIGluZGV4IHR5cGVJbnZhbGlkL1Vuc3VwcG9ydGVkIGVuY29kaW5nIHR5cGUgZm9yIGRpY3Rpb25hcnk6IAAAAAdqEwAyAAAA/wAQAH8AAAAlAQAAIQAAAGRlY29kZXIgc2V0AP8AEAB/AAAAOwEAACUAAAD/ABAAfwAAAEoBAAARAAAA/wAQAH8AAABjAQAAKAAAAP8AEAB/AAAAZgEAABkAAAD/ABAAfwAAAGoBAAAsAAAA/wAQAH8AAABrAQAAKwAAAP8AEAB/AAAAbQEAADwAAAD/ABAAfwAAAFcBAAAeAAAA/wAQAH8AAABYAQAAPgAAAG1pc3NpbmcgZGljdGlvbmFyeSBwYWdlIGZvciBjb2x1bW4AAP8AEAB/AAAAdwEAACUAAAArQxAAfQAAAHcAAAASAAAAK0MQAH0AAACGAAAADQAAACtDEAB9AAAAGAEAABsAAABkYXRhIG11c3QgYmUgYWxyZWFkeSBjYWNoZWQgaW4gdGhlIHJlYWRfcmVjb3JkcyBjYWxsLCB0aGlzIGlzIGEgYnVnACtDEAB9AAAANgEAABIAAAArQxAAfQAAADkBAAAdAAAA6wIAABQAAAAEAAAA7AIAAO0CAADuAgAA7wIAAPACAABjAgAAYwIAAOsCAAAUAAAABAAAAPECAACcAxAAdQAAAEYAAAAOAAAAAAAAAAQAAAAEAAAA8gIAAPMCAAD0AgAA9QIAAPYCAAD3AgAA+AIAAPkCAAD6AgAAcAIAAPsCAAD8AgAA/QIAAP4CAAD/AgAA+AIAAAADAABwAgAAAQMAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IElOVDk2IG11c3QgYmUgYSB0aW1lc3RhbXAuWGwTAEQAAACZCxAAeQAAAMgAAAAWAAAAUAIAACwAAAAEAAAAAgMAAAMDAAAEAwAABQMAAAYDAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAACwCAAAwAAAABAAAABUDAAAWAwAAFwMAABgDAAAZAwAAGgMAAAACAAABAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAsAgAAMAAAAAQAAAAbAwAAHAMAAB0DAAAeAwAAGQMAAB8DAAAAAgAAAQIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAACQIAACADAAALAgAAIQMAABkDAAANAgAAAAIAAAECAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAA4wAAABYAAAAsAgAAMAAAAAQAAAAiAwAAIwMAACQDAAAlAwAAGQMAACYDAAAHAgAACAIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAAJwMAACgDAAApAwAAKgMAABkDAAArAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACwCAAAwAAAABAAAAA4CAAAsAwAAEAIAAC0DAAAZAwAAEgIAAAcCAAAIAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACZCxAAeQAAAOkAAAAWAAAALAIAADAAAAAEAAAALgMAAC8DAAAwAwAAMQMAABkDAAAyAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACwCAAAwAAAABAAAADMDAAA0AwAANQMAADYDAAAZAwAANwMAAAcCAAAIAgAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAsAgAAMAAAAAQAAAA4AwAAOQMAADoDAAA7AwAAGQMAADwDAAAHAgAACAIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAAPQMAAD4DAAA/AwAAQAMAABkDAABBAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAA+gAAABYAAAAsAgAAMAAAAAQAAABCAwAAQwMAAEQDAABFAwAAGQMAAEYDAAAAAgAAAQIAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAALAIAADAAAAAEAAAARwMAAEgDAABJAwAASgMAABkDAABLAwAABwIAAAgCAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAQAQejizQALoQOZCxAAeQAAACABAAAWAAAALAIAADAAAAAEAAAATAMAAE0DAABOAwAATwMAABkDAABQAwAAUQMAAFIDAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAMAEAABYAAAAsAgAAMAAAAAQAAABTAwAAVAMAAFUDAABWAwAAGQMAAFcDAAD5AQAA+gEAANMBAABwAgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmQsQAHkAAAAYAQAAFgAAACwCAAAwAAAABAAAAFgDAABZAwAAWgMAAFsDAAAZAwAAXAMAAFEDAABSAwAA0wEAAHACAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACZCxAAeQAAACgBAAAWAAAALAIAADAAAAAEAAAAXQMAAF4DAABfAwAAYAMAABkDAABhAwAA+QEAAPoBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAA4AQZTmzQAL5x2ZCxAAeQAAAIkBAAAeAAAAQ2Fubm90IGNvbnZlcnQgIHRvIGRlY2ltYWwgZGljdGlvbmFyeQAAACRzEwAPAAAAM3MTABYAAACZCxAAeQAAAJwBAAAeAAAAmQsQAHkAAACiAQAAHgAAAJkLEAB5AAAAtQEAAB4AAACZCxAAeQAAALsBAAAeAAAALAIAADAAAAAEAAAAywEAAGIDAADNAQAAYwMAABkDAADQAQAA0QEAANIBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAzgEAAB4AAACZCxAAeQAAANQBAAAeAAAALAIAADAAAAAEAAAA3gEAAGQDAADgAQAAZQMAABkDAADiAQAA4wEAAOQBAADTAQAAcAIAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJkLEAB5AAAAQQEAABoAAAAgdG8gZGVjaW1hbAAkcxMADwAAAHx0EwALAAAAmQsQAHkAAABVAQAAGgAAAJkLEAB5AAAAWwEAABoAAACZCxAAeQAAAG8BAAAaAAAAmQsQAHkAAAB1AQAAGgAAAGFzc2VydGlvbiBmYWlsZWQ6IGV4aXN0aW5nLmlzX25vbmUoKTZwEAB5AAAAZgAAAAkAAADlZBAAbQAAAIIAAAAjAAAAc2NhbGUgY2Fubm90IGJlIG5lZ2F0aXZlOiAAABx1EwAaAAAAcHJlY2lzaW9uIGNhbm5vdCBiZSBuZWdhdGl2ZTogAABAdRMAHgAAAENhbm5vdCBjcmVhdGUgSU5UMzIgcGh5c2ljYWwgdHlwZSBmcm9tIABodRMAJwAAAFVuYWJsZSB0byBjb252ZXJ0IHBhcnF1ZXQgSU5UMzIgbG9naWNhbCB0eXBlICBvciBjb252ZXJ0ZWQgdHlwZSCYdRMALQAAAMV1EwATAAAAVVRDQ2Fubm90IGNyZWF0ZSBJTlQ2NCBmcm9tIE1JTExJUyB0aW1lIHVuaXRVbmFibGUgdG8gY29udmVydCBwYXJxdWV0IElOVDY0IGxvZ2ljYWwgdHlwZSAAAAAUdhMALQAAAMV1EwATAAAAVW5hYmxlIHRvIGNvbnZlcnQgcGFycXVldCBCWVRFX0FSUkFZIGxvZ2ljYWwgdHlwZSAAAFR2EwAyAAAAxXUTABMAAABGTE9BVDE2IGxvZ2ljYWwgdHlwZSBtdXN0IGJlIEZpeGVkIExlbmd0aCBCeXRlIEFycmF5IHdpdGggbGVuZ3RoIDJiaXRfcmVhZGVyIHNob3VsZCBiZSBzZXQAABRsEABkAAAA9QEAADMAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmN1cnJlbnRfdmFsdWUuaXNfc29tZSgpAAAUbBAAZAAAAAQCAAARAAAA1TcQAF8AAABAAQAAHgAAANU3EABfAAAAJQEAACoAAADVNxAAXwAAACYBAAA0AAAA1TcQAF8AAAA2AQAAPgAAAGFzc2VydGlvbiBmYWlsZWQ6IG4gPD0gc2VsZi5idWYuaW5pdCAtIHNlbGYuYnVmLmZpbGxlZAAAhGEQAHMAAAAVAQAACQAAAGZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgDMdxMAGwAAACUAAAAAAAAAAgAAAOh3EwCufhAAaQAAALIBAAAxAAAArn4QAGkAAACyAQAAGQAAAGZhaWxlZCB0byB3cml0ZSB3aG9sZSBidWZmZXIgeBMAHAAAABcAAAACAAAAPHgTAK5+EABpAAAAMQcAACQAAADvJxAAawAAAOMBAAAOAAAA7ycQAGsAAAD4AQAADgAAAGRlc2NyaXB0aW9uKCkgaXMgZGVwcmVjYXRlZDsgdXNlIERpc3BsYXkfPiLTS+rALQ+04qby6pveZwMAABgAAAAIAAAAaAMAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA4TUQAGUAAAAqAAAAFQAAAGluY29tcGxldGUgZnJhbWVudW1iZXIgb2YgcmVhZCBieXRlcyBleGNlZWRzIGxpbWl0AAAUeRMAIgAAAK5+EABpAAAA4QsAAAkAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEYBYsQAGoAAACLAgAAEgAAAGcDAAAYAAAACAAAADUAAABnAwAAGAAAAAgAAABoAwAANQAAAKB5EwA2AAAAaQMAAGoDAAA5AAAAawMAAFJlYWNoZWQgRU9GSW52YWxpZCBEYXRhTm8gcm9vbSBpbiBvdXRwdXQuAAAA1TcQAF8AAADQAAAAKgAAANU3EABfAAAA0QAAADQAAADVNxAAXwAAAN4AAAA+AAAAJGYQAF0AAABqAAAAJQAAAGNvcnJ1cHQgZGVmbGF0ZSBzdHJlYW0AAKxIEABYAAAAqQAAABIAAACsSBAAWAAAAPcAAAAnAAAArEgQAFgAAADFAAAAGwAAAAAAAAAkZhAAXQAAAJAAAAAdAAAAJGYQAF0AAACNAAAACQAAAM51EABqAAAAvQEAAB0AAAABAAAAAAAAAHVuc3VwcG9ydGVkIGVuY29kaW5nICBmb3IgYnl0ZSBhcnJhecx6EwAVAAAA4XoTAA8AAAB0DRAAdAAAAK8AAAAcAAAAdA0QAHQAAACwAAAAHAAAAHQNEAB0AAAAuAAAADgAAAB0DRAAdAAAALkAAAAcAAAAdA0QAHQAAADSAAAAIAAAAHQNEAB0AAAA1AAAADQAAAB0DRAAdAAAANQAAAAcAAAAdA0QAHQAAADVAAAAQQAAAHQNEAB0AAAA1gAAAEEAAAB0DRAAdAAAAP4AAAAfAAAAdA0QAHQAAAD/AAAAFQAAAHQNEAB0AAAAAAEAABUAAAB0DRAAdAAAAA4BAAAVAAAAdA0QAHQAAAAPAQAAFQAAAHQNEAB0AAAAEAEAABUAAAB0DRAAdAAAABEBAAAVAAAAdA0QAHQAAAA1AQAAHwAAAHQNEAB0AAAANQEAABMAAAB0DRAAdAAAADsBAAATAAAAdA0QAHQAAAA8AQAAEwAAAHQNEAB0AAAAPwEAABMAAAB0DRAAdAAAAEABAAAVAAAAdA0QAHQAAABbAQAAFgAAAHQNEAB0AAAAYAEAABoAAAB0DRAAdAAAAIgBAAAaAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogc2hvdWxkIGNhbGwgd3JpdGVfZ2F0aGVyIGluc3RlYWQAAJB8EwBKAAAAdA0QAHQAAADNAQAACQAAAHQNEAB0AAAA0QEAAAkAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogY2Fubm90IGRvd25jYXN0ICBkaWN0aW9uYXJ5IHZhbHVlIHRvIGJ5dGUgYXJyYXkAAAAsfRMAOgAAAGZ9EwAfAAAAIHRvIGJ5dGUgYXJyYXkAACx9EwA6AAAAmH0TAA4AAABNdXN0IGZsdXNoIGRhdGEgcGFnZXMgYmVmb3JlIGZsdXNoaW5nIGRpY3Rpb25hcnlEYXRhUGFnZSB2MiBoZWFkZXIgY29udGFpbnMgaW1wbGF1c2libGUgdmFsdWVzIGZvciBkZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aCAoKSBhbmQgcmVwZXRpdGlvbl9sZXZlbHNfYnl0ZV9sZW5ndGggKCkgZ2l2ZW4gRGF0YVBhZ2UgaGVhZGVyIHByb3ZpZGVzIHVuY29tcHJlc3NlZF9wYWdlX3NpemUgKCkAAADofRMAUgAAADp+EwAlAAAAX34TADkAAACYfhMAAQAAAKlDEABtAAAAjQEAACQAAACpQxAAbQAAAI4BAAA8AAAAqUMQAG0AAACOAQAAGgAAAKlDEABtAAAAkAEAADIAAABBY3R1YWwgZGVjb21wcmVzc2VkIHNpemUgZG9lc24ndCBtYXRjaCB0aGUgZXhwZWN0ZWQgb25lICggdnMgAAAA/H4TADkAAAA1fxMABAAAAJh+EwABAAAAbm90IGltcGxlbWVudGVkOiBQYWdlIHR5cGUgIGlzIG5vdCBzdXBwb3J0ZWRUfxMAGwAAAG9/EwARAAAAqUMQAG0AAADOAQAADQAAAE1pc3NpbmcgZGljdGlvbmFyeSBwYWdlIGhlYWRlck1pc3NpbmcgVjEgZGF0YSBwYWdlIGhlYWRlck1pc3NpbmcgVjIgZGF0YSBwYWdlIGhlYWRlckludmFsaWQgcGFnZSBoZWFkZXIAqUMQAG0AAAByAwAAJgAAAEV4cGVjdGVkIHRvIHJlYWQgIGJ5dGVzIG9mIHBhZ2UsIHJlYWQgb25seSAAGIATABEAAAApgBMAGgAAAAAAAAAEAAAABAAAAEoCAABHZW5lcmFsTllJRU9GQXJyb3dFcnJvcgAAAAAABAAAAAQAAABsAwAAAAAAAAQAAAAEAAAAMQAAAEluZGV4T3V0T2ZCb3VuZAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxOZWVkTW9yZURhdGEAAAAABAAAAAQAAAAzAAAATmVlZE1vcmVEYXRhUmFuZ2UAAAAAAAAABAAAAAQAAABtAwAAUGFnZVR5cGW/VhAAZAAAAOoAAAA4AAAAv1YQAGQAAADrAAAAFQAAAOpMEABiAAAA3QEAAC0AAAAUbBAAZAAAAJIAAAAJAAAAdo4QAGUAAAAOAAAAFgAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAADvJxAAawAAAPgBAAAOAAAA1zIQAHgAAADrBwAACQAAAMRKEABqAAAA9gcAAB8AAABvAwAAGAAAAAgAAABwAwAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQBBhITOAAuvIQEAAABxAwAATm9uZVNvbWUAAAAABAAAAAQAAABtAwAAAAAAAAQAAAAEAAAANAAAAFRyeUZyb21TbGljZUVycm9yAAAAxEoQAGoAAABtCAAAHwAAAFJYEABjAAAA2QEAACEAAABSWBAAYwAAANoBAAAmAAAAUlgQAGMAAADbAQAAJgAAAFJYEABjAAAA3AEAACYAAABSWBAAYwAAAN0BAAAmAAAAUlgQAGMAAADeAQAAJgAAAFJYEABjAAAA3wEAACYAAABSWBAAYwAAAO0BAAAiAAAAUlgQAGMAAAAPAgAAEQAAAFJYEABjAAAA/gEAABEAAABSWBAAYwAAAPwBAAARAAAAUlgQAGMAAAD4AQAAEQAAAFJYEABjAAAA8wEAABEAAABSWBAAYwAAABcDAAAJAAAAUlgQAGMAAAAYAwAACQAAAAAAAABSWBAAYwAAAFQBAAAcAAAAUlgQAGMAAAAzAAAAGAAAAIR2EABiAAAAlwAAABEAAACEdhAAYgAAAJgAAAAOAAAAdo4QAGUAAAAbAAAAEgAAAM51EABqAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmRhdGEuaXNfc29tZSgpAAAAHmoQAGAAAADeAAAACQAAAHNldF9kYXRhIHNob3VsZCBoYXZlIGJlZW4gY2FsbGVkHmoQAGAAAADtAAAADgAAAB5qEABgAAAAzQMAABIAAABOb3QgZW5vdWdoIGJ5dGVzIHRvIHNraXCnDxAAdQAAAC4AAAAZAAAApw8QAHUAAABRAAAAHgAAAEV4cGVjdGVkIHRvIHdyaXRlICB2YWx1ZXMsIGJ1dCBoYXZlIG9ubHkgAAAAXIQTABIAAABuhBMAFwAAAE11c3QgZmx1c2ggZGF0YSBwYWdlcyBiZWZvcmUgZmx1c2hpbmcgZGljdGlvbmFyeaM9EABsAAAAawEAAEEAAAAAgAAAoz0QAGwAAABtAQAATQAAAAh8EABoAAAAYwUAACsAAAAIfBAAaAAAAGMFAAAzAAAADAAAADEwEABmAAAA1gAAABkAAAAxMBAAZgAAANwAAAAZAAAAU3RhdGlzdGljcyBudWxsIGNvdW50IGlzIG5lZ2F0aXZlIAAAMIUTACIAAABJbnN1ZmZpY2llbnQgYnl0ZXMgdG8gcGFyc2UgbWluIHN0YXRpc3RpY0luc3VmZmljaWVudCBieXRlcyB0byBwYXJzZSBtYXggc3RhdGlzdGljAAAxMBAAZgAAAL8AAAAoAAAAMTAQAGYAAADAAAAAKAAAADEwEABmAAAAxgAAADsAAAAxMBAAZgAAAMcAAAA7AAAAMTAQAGYAAADNAAAAOwAAADEwEABmAAAAzgAAADsAAAAxMBAAZgAAAOQAAAA7AAAAMTAQAGYAAADlAAAAOwAAADEwEABmAAAA6wAAADsAAAAxMBAAZgAAAOwAAAA7AAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAHIDAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZW5vdCBpbXBsZW1lbnRlZB5qEABgAAAAbQIAAAEAAAAeahAAYAAAAG4CAAABAAAAHmoQAGAAAABvAgAAAQAAAGVycm9yIGNvbnZlcnRpbmcgdmFsdWUsIGV4cGVjdGVkICBieXRlcyBnb3QgLIcTACEAAABNhxMACwAAAL9WEABkAAAA6gAAADgAAAC/VhAAZAAAAOsAAAAVAAAAv1YQAGQAAAD4AAAAFQAAAL9WEABkAAAAJwEAABIAAAC/VhAAZAAAADkBAAAVAAAAaW52YWxpZCBrZXk9IGZvciBkaWN0aW9uYXJ5ALiHEwAMAAAAxIcTAA8AAAATDBAAfgAAAKsBAAAgAAAAEwwQAH4AAACuAQAAMQAAABMMEAB+AAAArwEAACQAAAAsPRAAdgAAADAAAAAWAAAALD0QAHYAAAA+AAAAFgAAACw9EAB2AAAAgwAAABoAAAAsPRAAdgAAAIQAAAAQAAAALD0QAHYAAACQAAAAFgAAACw9EAB2AAAAmwAAABYAAABzAwAAKAAAAAgAAAB0AwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAHoDAAB7AwAAfAMAAH0DAAB+AwAAfwMAAHAAAAAIAAAAgAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAACGAwAAhwMAAIgDAACJAwAAigMAAENhbm5vdCBpbml0aWFsaXplIHRoaXMgZW5jb2RpbmcgdGhyb3VnaCB0aGlzIGZ1bmN0aW9uAAAAiwMAAAwAAAAEAAAAjAMAAI0DAACOAwAAjwMAAJADAABFbmNvZGluZyAgaXMgbm90IHN1cHBvcnRlZAAATIkTAAkAAABViRMAEQAAAHMDAAAoAAAACAAAAJEDAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAkgMAAHsDAAB8AwAAfQMAAJMDAACUAwAAYAAAAAgAAACVAwAAlgMAAJcDAACYAwAAmQMAAH8DAABwAAAACAAAAJoDAACBAwAAggMAAIMDAACEAwAAhQMAAOAAAAAIAAAAmwMAAIcDAACIAwAAiQMAAIoDAACLAwAADAAAAAQAAACcAwAAjQMAAI4DAACPAwAAnQMAAHMDAAAoAAAACAAAAJ4DAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAnwMAAHsDAAB8AwAAfQMAAJMDAAB/AwAAcAAAAAgAAACgAwAAgQMAAIIDAACDAwAAhAMAAIUDAADgAAAACAAAAKEDAACHAwAAiAMAAIkDAACKAwAAiwMAAAwAAAAEAAAAogMAAI0DAACOAwAAjwMAAKMDAABzAwAAKAAAAAgAAACkAwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAKUDAAB7AwAAfAMAAH0DAACTAwAAfwMAAHAAAAAIAAAApgMAAIEDAACCAwAAgwMAAKcDAACFAwAA4AAAAAgAAACoAwAAhwMAAIgDAACJAwAAqQMAAIsDAAAMAAAABAAAAKoDAACNAwAAjgMAAI8DAACrAwAAcwMAACgAAAAIAAAArAMAAHUDAAB2AwAAdwMAAHgDAAB5AwAAeAAAAAgAAAClAwAAewMAAHwDAAB9AwAAkwMAAH8DAABwAAAACAAAAK0DAACBAwAAggMAAIMDAACnAwAAhQMAAOAAAAAIAAAArgMAAIcDAACIAwAAiQMAAKkDAACvAwAAEAAAAAQAAACwAwAAjQMAALEDAACyAwAAswMAAHMDAAAoAAAACAAAAJEDAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHgAAAAIAAAAkgMAAHsDAAB8AwAAfQMAAJMDAAB/AwAAcAAAAAgAAACaAwAAgQMAAIIDAACDAwAAhAMAAIUDAADgAAAACAAAAJsDAACHAwAAiAMAAIkDAACKAwAAiwMAAAwAAAAEAAAAnAMAAI0DAACOAwAAjwMAAJ0DAABzAwAAKAAAAAgAAAC0AwAAdQMAAHYDAAB3AwAAeAMAAHkDAAB4AAAACAAAAJ8DAAB7AwAAfAMAAH0DAACTAwAAfwMAAHAAAAAIAAAAoAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAAChAwAAhwMAAIgDAACJAwAAigMAAIsDAAAMAAAABAAAALUDAACNAwAAjgMAAI8DAAC2AwAAcwMAACgAAAAIAAAAngMAAHUDAAB2AwAAdwMAAHgDAAB5AwAAeAAAAAgAAACfAwAAewMAAHwDAAB9AwAAkwMAAJQDAABgAAAACAAAALcDAACWAwAAlwMAAJgDAAC4AwAAfwMAAHAAAAAIAAAAoAMAAIEDAACCAwAAgwMAAIQDAACFAwAA4AAAAAgAAAChAwAAhwMAAIgDAACJAwAAigMAAIsDAAAMAAAABAAAAKIDAACNAwAAjgMAAI8DAACjAwAA7oEQAG0AAACiAAAADgAAAFJsZVZhbHVlRW5jb2RlciBvbmx5IHN1cHBvcnRzIEJvb2xUeXBlAAAojhMAJgAAAO6BEABtAAAA1AAAAAkAAADugRAAbQAAANcAAAAeAAAA7oEQAG0AAADZAAAAFAAAAFJMRSB2YWx1ZSBlbmNvZGVyIGlzIG5vdCBpbml0aWFsaXplZO6BEABtAAAA+gAAAA4AAABzaG91bGQgaGF2ZSBoYWQgcGFkZGluZyBpbnNlcnRlZLyOEwAgAAAA7oEQAG0AAAD+AAAACQAAAO6BEABtAAAA9gAAAAkAAADugRAAbQAAAFsBAAAVAAAARXhwZWN0ZWQgMCB2YWx1ZXMgaW4gYmxvY2ssIGZvdW5kIAAAFI8TACIAAADugRAAbQAAAK0BAAAJAAAA7oEQAG0AAAChAQAAMgAAAO6BEABtAAAAlwEAADwAAADugRAAbQAAAHwBAAA4AAAA7oEQAG0AAADMAQAAGAAAAO6BEABtAAAA6gEAABAAAADugRAAbQAAAOsBAAAQAAAARGVsdGFCaXRQYWNrRGVjb2RlciBvbmx5IHN1cHBvcnRzIEludDMyVHlwZSBhbmQgSW50NjRUeXBlAAAAsI8TADkAAADugRAAbQAAABACAAAJAAAA7oEQAG0AAABlAgAAFwAAAERlbHRhTGVuZ3RoQnl0ZUFycmF5RW5jb2RlciBvbmx5IHN1cHBvcnRzIEJ5dGVBcnJheVR5cGUAFJATADcAAADugRAAbQAAAFYCAAAJAAAA7oEQAG0AAABeAgAAQQAAAO6BEABtAAAAfwIAABUAAADugRAAbQAAAHgCAAAJAAAA7oEQAG0AAACBAgAAGQAAAO6BEABtAAAAxgIAABwAAADugRAAbQAAAMcCAAAWAAAA7oEQAG0AAADKAgAAGwAAAERlbHRhQnl0ZUFycmF5RW5jb2RlciBvbmx5IHN1cHBvcnRzIEJ5dGVBcnJheVR5cGUgYW5kIEZpeGVkTGVuQnl0ZUFycmF5VHlwZQDUkBMASwAAAO6BEABtAAAAuAIAABYAAADugRAAbQAAAOcCAAAdAAAA7oEQAG0AAADqAgAAHQAAAO6BEABtAAAA7wIAABIAAAAUbBAAZAAAAJIAAAAJAAAAYml0X3JlYWRlciBzaG91bGQgYmUgc2V0FGwQAGQAAAD1AQAAMwAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuY3VycmVudF92YWx1ZS5pc19zb21lKCkAABRsEABkAAAABAIAABEAAAAqAAAAOgAAAEoAAABKAAAAOgAAAEoAAABSAAAAUgAAACsAAAA7AAAASwAAAEsAAAA7AAAASwAAAFMAAABTAAAACAAAAAgAAAAoAAAACAAAAAgAAAAoAAAACAAAAAgAAAAQAAAAEAAAADAAAAAQAAAAEAAAADAAAAAQAAAAEAAAABgAAAAYAAAAOAAAABgAAAAYAAAAOAAAABgAAAAYAAAAIAAAACAAAABAAAAAIAAAACAAAABAAAAAIAAAACAAAAC8AwAAAAAAAP//////////qJITAEHApc4AC69K1zIQAHgAAADrBwAACQAAAFN0b3BWb2lkQm9vbEkwOERvdWJsZUkxNkkzMkk2NFN0cmluZ1V0ZjdTdHJ1Y3RNYXBTZXRMaXN0VXRmOFV0ZjE2AAAAxEoQAGoAAABtCAAAHwAAAGNhbm5vdCBwYXJzZSBwYXN0IAAAJJMTABIAAABub24temVybyBzaXplZCBtYXAgc2hvdWxkIGNvbnRhaW4ga2V5IHR5cGUAACeBEABiAAAA8AAAABoAAABub24temVybyBzaXplZCBtYXAgc2hvdWxkIGNvbnRhaW4gdmFsdWUgdHlwZSeBEABiAAAA8wAAABoAAABjYW5ub3Qgc2tpcCBmaWVsZCB0eXBlIAC4kxMAFwAAAM51EABqAAAAvQEAAB0AAAAeahAAYAAAABcDAAA6AAAAc2V0X2RhdGEgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQeahAAYAAAAK4DAAASAAAAHmoQAGAAAAC9AwAANQAAAB5qEABgAAAAvgMAADUAAAAeahAAYAAAAL8DAAA1AAAATm90IGVub3VnaCBieXRlcyB0byBkZWNvZGUAAKh3EABgAAAAGgEAABgAAACodxAAYAAAAIQBAAAlAAAASW52YWxpZC9VbnN1cHBvcnRlZCBlbmNvZGluZyB0eXBlIGZvciBkaWN0aW9uYXJ5OiAAAJSUEwAyAAAAvQMAAEAAAAAIAAAAvgMAAL8DAADAAwAAwQMAAMIDAADDAwAAxAMAAFgAAAAIAAAAxQMAAMYDAADHAwAAyAMAAMkDAADKAwAAQ29sdW1uIGNhbm5vdCBoYXZlIG1vcmUgdGhhbiBvbmUgZGljdGlvbmFyeQC9AwAAQAAAAAgAAADLAwAAzAMAAM0DAADBAwAAwgMAAM4DAADPAwAAWAAAAAgAAADFAwAA0AMAANEDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA0gMAANMDAADBAwAAwgMAANQDAADVAwAAWAAAAAgAAADFAwAA1gMAANcDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA2AMAANkDAADBAwAAwgMAANoDAADbAwAAWAAAAAgAAADFAwAA3AMAAN0DAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA3gMAAN8DAADBAwAAwgMAAOADAADhAwAAWAAAAAgAAADFAwAA4gMAAOMDAADIAwAAyQMAAMoDAAC9AwAAQAAAAAgAAADLAwAA5AMAAOUDAADBAwAAwgMAAOYDAADnAwAAWAAAAAgAAADFAwAA6AMAAOkDAADIAwAAyQMAAMoDAABEZWNvZGVyIGZvciBkaWN0IHNob3VsZCBoYXZlIGJlZW4gc2V0AAAAlD4QAGwAAADPAAAAEgAAAGN1cnJlbnRfZW5jb2Rpbmcgc2hvdWxkIGJlIHNldAAAlD4QAGwAAADjAAAADgAAAJQ+EABsAAAA7AAAAA0AAACUPhAAbAAAAO0AAAAwAAAAZGVjb2RlciBmb3IgZW5jb2RpbmcgIHNob3VsZCBiZSBzZXQANJcTABUAAABJlxMADgAAAJQ+EABsAAAA6AAAACAAAACUPhAAbAAAAPUAAAAOAAAAlD4QAGwAAAD6AAAAIAAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGludmFsaWQgbGV2ZWwgZW5jb2Rpbmc6IAAAmJcTAEIAAACUPhAAbAAAABEBAAASAAAAlD4QAGwAAABBAQAADQAAAJQ+EABsAAAAQgEAADEAAACUPhAAbAAAAEIBAABHAAAAlD4QAGwAAABSAQAAEQAAAJQ+EABsAAAAewEAACoAAACUPhAAbAAAALoBAAAdAAAAlD4QAGwAAAC5AQAAEQAAAHBhcnF1ZXQtcnMgdmVyc2lvbiA1Ni4yLjBDYW5ub3QgaGF2ZSBhIDAgbWF4IHJvdyBncm91cCBzaXplAH2YEwAiAAAApi0QAGYAAABCAgAACQAAAERpY3Rpb25hcnkgZW5jb2RpbmcgY2FuIG5vdCBiZSB1c2VkIGFzIGZhbGxiYWNrIGVuY29kaW5nuJgTADgAAACmLRAAZgAAADsEAAANAAAAGx8QAF0AAABGAAAAIgAAAG5vdCBpbXBsZW1lbnRlZAAbHxAAXQAAAIQAAAAiAAAAc2hvdWxkIGhhdmUgcHJldmlvdXMgZmllbGQgaWRzAAAbHxAAXQAAAI0AAAAOAAAAY2Fubm90IGFkZCAgdG8gAGiZEwALAAAAc5kTAAQAAABjYW5ub3QgY29udmVydCAgaW50byBib29sAAAAiJkTAA8AAACXmRMACgAAABsfEABdAAAA5QAAAB0AAAAbHxAAXQAAAPoAAAAeAAAAGx8QAF0AAAAgAQAAHQAAACBpbnRvIFRUeXBlAIiZEwAPAAAA5JkTAAsAAABVbmV4cGVjdGVkIEVPRgAAHmoQAGAAAACMAwAABQAAAE5vdCBlbm91Z2ggYnl0ZXMgdG8gc2tpcB5qEABgAAAAjQMAAAUAAAAeahAAYAAAAI4DAAAFAAAAHmoQAGAAAACPAwAABQAAAAIAAABlcnJvciBjb252ZXJ0aW5nIHZhbHVlLCBleHBlY3RlZCAgYnl0ZXMgZ290IGyaEwAhAAAAjZoTAAsAAAAEAAAAAQAAAAgAAABhc3NlcnRpb24gZmFpbGVkOiBzaXplIDw9IHNyYy5sZW4oKQC/VhAAZAAAAI4AAAAFAAAAv1YQAGQAAACQAAAAFAAAAL9WEABkAAAAwAAAABUAAAC/VhAAZAAAABcBAAAUAAAAYXNzZXJ0aW9uIGZhaWxlZDogbnVtX2JpdHMgPD0gNjS/VhAAZAAAAJoBAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogbnVtX2JpdHMgPD0gc2l6ZV9vZjo6PFQ+KCkgKiA4v1YQAGQAAACbAQAACQAAAL9WEABkAAAAxgEAAAkAAAC/VhAAZAAAAMwBAAAeAAAAAAAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9iaXRzIDw9IFQ6OkJJVF9DQVBBQ0lUWQAAAL9WEABkAAAA3AEAAAkAAAC/VhAAZAAAAOgBAAAuAAAAv1YQAGQAAADpAQAAKQAAAL9WEABkAAAA9gEAAC4AAAC/VhAAZAAAAPcBAAAqAAAAv1YQAGQAAAAEAgAALgAAAL9WEABkAAAABQIAACoAAAC/VhAAZAAAAB4CAAAiAAAAv1YQAGQAAAAsAgAAIgAAAL9WEABkAAAAOgIAACEAAABleHBlY3RlZCB0byBoYXZlIG1vcmUgZGF0YQAAv1YQAGQAAABKAgAAEgAAAL9WEABkAAAASwIAAA0AAAC/VhAAZAAAAEECAAARAAAAv1YQAGQAAAAzAgAAEQAAAL9WEABkAAAAJQIAABEAAAC/VhAAZAAAABICAAAuAAAAv1YQAGQAAAATAgAAKgAAAL9WEABkAAAA1gEAABYAAAC/VhAAZAAAANQBAAARAAAAv1YQAGQAAABWAgAACQAAAL9WEABkAAAAXAIAABUAAAC/VhAAZAAAAHICAAAfAAAAv1YQAGQAAAB0AgAADQAAAL9WEABkAAAAiwIAADwAAAAKAAAATnVtIG9mIGJ5dGVzIGV4Y2VlZCBNQVhfVkxRX0JZVEVfTEVOICgpAHydEwAmAAAAop0TAAEAAAC/VhAAZAAAAJsCAAANAAAAv1YQAGQAAAC/AgAAPgAAAAldEABkAAAAXAAAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBpbnB1dC5sZW4oKSA+PSBOVU1fQklUUyAqIDEAAAAJXRAAZAAAAF0AAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5wdXQubGVuKCkgPj0gTlVNX0JJVFMgKiAyRW5jb2RpbmcgIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIHR5cGVRnhMACQAAAFqeEwAaAAAAQ2Fubm90IGluaXRpYWxpemUgdGhpcyBlbmNvZGluZyB0aHJvdWdoIHRoaXMgZnVuY3Rpb24gaXMgbm90IHN1cHBvcnRlZAAAUZ4TAAkAAAC5nhMAEQAAAOoDAABIAAAACAAAAOsDAADsAwAA7QMAAO4DAADvAwAA8AMAAPEDAABgAAAACAAAAPIDAADzAwAA9AMAAPUDAAD2AwAA9wMAAPgDAAAYAAAABAAAAPkDAAD6AwAA+wMAAPwDAAD9AwAA/gMAAP8DAABwAAAACAAAAAAEAAABBAAAAgQAAAMEAAD2AwAABAQAAPgDAAAYAAAABAAAAPkDAAAFBAAABgQAAPwDAAD9AwAA/gMAAPgDAAAYAAAABAAAAPkDAAD6AwAABwQAAPwDAAD9AwAA/gMAAPgDAAAYAAAABAAAAPkDAAAFBAAACAQAAPwDAAD9AwAA/gMAAE5gEABpAAAArAIAAAwAAAAndmFsdWVzX3Blcl9taW5pX2Jsb2NrJyBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgMzIgZ290IAAAAOifEwA1AAAAJ2Jsb2NrX3NpemUnIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAnbWluaV9ibG9ja3NfcGVyX2Jsb2NrJyBnb3QgIGFuZCAooBMAPwAAAGegEwAFAAAAJ2Jsb2NrX3NpemUnIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAxMjgsIGdvdCB8oBMALAAAAE5vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ2Jsb2NrX3NpemUnaW52YWxpZCAnYmxvY2tfc2l6ZSdOb3QgZW5vdWdoIGRhdGEgdG8gZGVjb2RlICdtaW5pX2Jsb2Nrc19wZXJfYmxvY2snaW52YWxpZCAnbWluaV9ibG9ja3NfcGVyX2Jsb2NrJ05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ3ZhbHVlc19sZWZ0J2ludmFsaWQgJ3ZhbHVlc19sZWZ0J05vdCBlbm91Z2ggZGF0YSB0byBkZWNvZGUgJ2ZpcnN0X3ZhbHVlJ2ZpcnN0IHZhbHVlIHRvbyBsYXJnZVVuc3VwcG9ydGVkIGVuY29kaW5nIHR5cGUgsqETABoAAAAMKhAAZwAAACQAAAAOAAAADCoQAGcAAAA6AAAAGgAAAAwqEABnAAAAPwAAABgAAAAMKhAAZwAAAFEAAAAWAAAAYml0X3JlYWRlciBzaG91bGQgYmUgc2V0FGwQAGQAAAD1AQAAMwAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuY3VycmVudF92YWx1ZS5pc19zb21lKCkAABRsEABkAAAABAIAABEAAAABAgQIECBAgAQAAAAEAAAABAAAAAMAAAAGAAAAAwAAAAMAAAADAAAABgAAAAQAAAAGAAAAAwAAAAMAAAAEAAAABAAAAAUAAADQkhMA1JITANiSEwDckhMA35ITAOWSEwDokhMA65ITAO6SEwD0khMA+JITAP6SEwABkxMABJMTAAiTEwAMkxMAUlgQAGMAAAAxAwAAEwAAAOciEABmAAAA4wAAABcAAABzaG91bGQgaGF2ZSBwcmV2aW91cyBmaWVsZCBpZHMAAOciEABmAAAAngAAAA4AAADnIhAAZgAAAJUAAAAiAAAAY2Fubm90IGNvbnZlcnQgIGludG8gYm9vbAAAAGSjEwAPAAAAc6MTAAoAAABib29sIGZpZWxkIHNob3VsZCBoYXZlIGEgZmllbGQgaWQAAADnIhAAZgAAAOoBAAArAAAA5yIQAGYAAADEAQAADgAAAHNob3VsZCBub3QgaGF2ZSBhIHBlbmRpbmcgYm9vbCB3aGlsZSB3cml0aW5nIGFub3RoZXIgYm9vbCB3aXRoIGlkOiAA1KMTAEMAAADnIhAAZgAAAMwBAAAVAAAAbm9uLXN0b3AgZmllbGQgc2hvdWxkIGhhdmUgZmllbGQgaWQA5yIQAGYAAADXAQAALgAAAOciEABmAAAAugEAACMAAAB7eRAAcAAAABADAAArAAAAe3kQAHAAAAAUAwAAEgAAAHt5EABwAAAAFgMAABIAAAB7eRAAcAAAABoDAAAlAAAAe3kQAHAAAAAhAwAAJQAAAHt5EABwAAAAKwMAACkAAAB7eRAAcAAAADEDAAAeAAAAe3kQAHAAAABFAwAALQAAAHt5EABwAAAATgMAACYAAAAAAQIDAAAAAAAAAQEBAQEBe3kQAHAAAADuAgAAEgAAAAAAAAD/Af4C/QP/Af4C/QN7eRAAcAAAAPkCAAAUAAAAe3kQAHAAAAD6AgAAGAAAAHt5EABwAAAAAAMAADMAAAB7eRAAcAAAAAADAABFAAAAe3kQAHAAAABfAwAAJQAAAHt5EABwAAAAYQMAACEAAAB7eRAAcAAAAGMDAAAJAAAAe3kQAHAAAABuAQAALAAAAHt5EABwAAAAbwEAACUAAAB7eRAAcAAAAHIBAAAmAAAAe3kQAHAAAAB4AQAAIAAAAHt5EABwAAAAegEAABoAAAB7eRAAcAAAAIUBAAAkAAAAe3kQAHAAAACHAQAAGQAAAHt5EABwAAAAkQEAABcAAAB7eRAAcAAAAJUBAAAgAAAAe3kQAHAAAACcAQAAMwAAAHt5EABwAAAApgEAACcAAAB7eRAAcAAAAKYBAAA/AAAAe3kQAHAAAADTAQAACQAAAHt5EABwAAAAqwEAACQAAAB7eRAAcAAAALIBAAAaAAAAe3kQAHAAAADAAQAAKAAAAHt5EABwAAAAOQEAACUAAAB7eRAAcAAAADwBAAAJAAAAe3kQAHAAAABNAQAALwAAAHt5EABwAAAATwEAADYAAABVTklOVElBTElaRUR7eRAAcAAAAJkIAAAJAAAAe3kQAHAAAAC0CAAACQAAAHt5EABwAAAAnwgAAAkAAAAvAxAAbAAAABICAAATAAAAe3kQAHAAAAAnBgAAIAAAAHt5EABwAAAAKAYAABoAAAB7eRAAcAAAACkGAAAaAAAAe3kQAHAAAAAqBgAAGgAAAHt5EABwAAAAKwYAACAAAAB7eRAAcAAAACwGAAAaAAAAe3kQAHAAAAAtBgAAGgAAAHt5EABwAAAALgYAABoAAAB7eRAAcAAAADAGAAAgAAAAe3kQAHAAAAAxBgAAGgAAAHt5EABwAAAAMgYAABoAAAB7eRAAcAAAADMGAAAaAAAAe3kQAHAAAAA1BgAAIAAAAHt5EABwAAAANgYAABoAAAB7eRAAcAAAADcGAAAaAAAAe3kQAHAAAAA4BgAAGgAAAHt5EABwAAAARgYAACYAAAB7eRAAcAAAAEkGAAAmAAAAe3kQAHAAAABMBgAAJgAAAHt5EABwAAAATwYAACYAAAB7eRAAcAAAAFYGAAAJAAAAe3kQAHAAAABXBgAACQAAAHt5EABwAAAAWAYAAAkAAAB7eRAAcAAAAFkGAAAJAAAAe3kQAHAAAADwBQAAHwAAAHt5EABwAAAA8QUAABoAAAB7eRAAcAAAAPIFAAAaAAAAe3kQAHAAAADzBQAAGgAAAHt5EABwAAAA9AUAABoAAAB7eRAAcAAAAPUFAAAaAAAAe3kQAHAAAAD2BQAAGgAAAHt5EABwAAAA9wUAABoAAAB7eRAAcAAAAPkFAAAfAAAAe3kQAHAAAAD5BQAANgAAAHt5EABwAAAABwYAACYAAAB7eRAAcAAAAAoGAAAmAAAAe3kQAHAAAAANBgAAJgAAAHt5EABwAAAAEAYAACYAAAB7eRAAcAAAABcGAAAJAAAAe3kQAHAAAAAYBgAACQAAAHt5EABwAAAAGQYAAAkAAAB7eRAAcAAAABoGAAAJAAAAe3kQAHAAAACZBgAAHQAAAHt5EABwAAAAvwYAACAAAAB7eRAAcAAAAMQGAAAOAAAAe3kQAHAAAADGBgAADgAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1Y2tldC5sZW4oKSA+IHNlbGYuc3BlY2lhbGl6YXRpb24uYmxvY2tfbWFzaygpIGFzIHVzaXplAAB7eRAAcAAAAMgGAAAJAAAAe3kQAHAAAADRBgAAIwAAAHt5EABwAAAA1gYAABgAAAB7eRAAcAAAANYGAAAuAAAAe3kQAHAAAADgBgAAJgAAAHt5EABwAAAA8AYAAAkAAAB7eRAAcAAAAJsGAAAjAAAAe3kQAHAAAACjBgAAFAAAAHt5EABwAAAAowYAACoAAAB7eRAAcAAAAKcGAAAiAAAAe3kQAHAAAABcBgAAJQAAAHt5EABwAAAAXwYAAA4AAAB7eRAAcAAAAGIGAAAJAAAAe3kQAHAAAABkBgAAHQAAAHt5EABwAAAAzgUAACUAAAB7eRAAcAAAAMkFAAAvAAAAe3kQAHAAAADKBQAAEQAAAO8nEABrAAAA4wEAAA4AAADvJxAAawAAAPgBAAAOAAAAbWlkID4gbGVuAAAAjKsTAAkAAABTdG9wVm9pZEJvb2xJMDhEb3VibGVJMTZJMzJJNjRTdHJpbmdVdGY3U3RydWN0TWFwU2V0TGlzdFV0ZjhVdGYxNgAAAMRKEABqAAAAbQgAAB8AAABudBAAZAAAANYCAAAVAAAAbnQQAGQAAADXAgAAHQAAAG50EABkAAAA0QIAABEAAABudBAAZAAAAJ4BAAAuAAAAbnQQAGQAAACiAQAALgAAAG50EABkAAAAqAEAADEAAABudBAAZAAAAKwBAAAxAAAAbnQQAGQAAADAAQAACQAAAG50EABkAAAA5gAAAA0AAABudBAAZAAAADYAAAAOAAAAbnQQAGQAAABgAAAAGgAAABYhEABkAAAAIwAAAB8AAAAWIRAAZAAAACMAAAALAAAAFiEQAGQAAAAuAAAAHwAAABYhEABkAAAALgAAAAsAAAAzHhAAagAAAL4CAAAJAAAAMx4QAGoAAAD6AwAAHwAAADMeEABqAAAArwMAAC8AAAAzHhAAagAAAOQDAAAjAAAAMx4QAGoAAADHAwAAIwAAADMeEABqAAAA0QIAAB8AAAAzHhAAagAAAOYCAAA4AAAAMx4QAGoAAADoAgAAMgAAADMeEABqAAAA6AIAAEoAAAAzHhAAagAAAO4CAAA+AAAAMx4QAGoAAADwAgAASgAAADMeEABqAAAA6wIAACEAAAAzHhAAagAAAAEDAAAjAAAAMx4QAGoAAAACAwAAIwAAADMeEABqAAAALQMAACMAAAAzHhAAagAAADYDAAAdAAAAMx4QAGoAAAA3AwAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlwX2luZGV4ID49IDMAMx4QAGoAAABZAwAAFQAAADMeEABqAAAAWgMAAE4AAAAzHhAAagAAAF0DAAAVAAAAMx4QAGoAAABgAwAAFQAAADMeEABqAAAAYwMAABUAAAAzHhAAagAAAGUDAAA2AAAAMx4QAGoAAABoAwAARQAAADMeEABqAAAAawMAACcAAAAzHhAAagAAAGwDAAAnAAAAMx4QAGoAAACKAwAAGQAAADMeEABqAAAAiwMAAFIAAAAzHhAAagAAAI4DAAAZAAAAMx4QAGoAAACRAwAAGQAAADMeEABqAAAAlAMAABkAAAAzHhAAagAAAJYDAAA6AAAAMx4QAGoAAACeAwAAJwAAADMeEABqAAAAuAIAACUAAAAzHhAAagAAAE8AAAArAAAAMx4QAGoAAAB7AAAADgAAADMeEABqAAAAdgAAAD0AAAAzHhAAagAAADgAAAAnAAAAE3EQAIAAAAC+AQAAJAAAABNxEACAAAAAwAEAABcAAAATcRAAgAAAANoBAAAWAAAAE3EQAIAAAADbAQAAFgAAABNxEACAAAAA4QEAACMAAAATcRAAgAAAAO0BAAAMAAAAE3EQAIAAAADtAQAANAAAABNxEACAAAAA9wEAABEAAAATcRAAgAAAAPoBAAAXAAAAE3EQAIAAAADwAQAAEQAAABNxEACAAAAA8wEAABcAAAATcRAAgAAAAOcBAAAlAAAAE3EQAIAAAADnAQAAEQAAABNxEACAAAAA6AEAACYAAAATcRAAgAAAAOgBAAARAAAAE3EQAIAAAADQAQAAEQAAABNxEACAAAAA0QEAABEAAAB7eRAAcAAAAAEBAAAjAAAAe3kQAHAAAAABAQAAMQAAAHt5EABwAAAACwEAABEAAAB7eRAAcAAAAAwBAAARAAAAe3kQAHAAAAANAQAAEQAAAHt5EABwAAAADgEAABEAAAB7eRAAcAAAALAJAAAlAAAAe3kQAHAAAACwCQAAFQAAAHt5EABwAAAAuAkAAEoAAAB7eRAAcAAAAJsHAAAfAAAAd29ya2luZyB3aXRoIHVuaW5pdGlhbGl6ZWQgaGFzaCBtYXAAe3kQAHAAAAD/CQAAJQAAAHt5EABwAAAAhQQAAA0AAAB7eRAAcAAAAIYEAAANAAAAe3kQAHAAAACQBAAAJgAAAHt5EABwAAAAkQQAACIAAAB7eRAAcAAAAJIEAAAiAAAAe3kQAHAAAACTBAAAIgAAAHt5EABwAAAAlAQAACIAAAB7eRAAcAAAAJUEAAAiAAAAe3kQAHAAAACWBAAAIgAAAHt5EABwAAAAowQAAC4AAAB7eRAAcAAAAKYEAAAuAAAAe3kQAHAAAACpBAAALgAAAHt5EABwAAAArAQAAC4AAAB7eRAAcAAAALcEAAARAAAAe3kQAHAAAAC4BAAAEQAAAHt5EABwAAAAuQQAABEAAAB7eRAAcAAAALoEAAARAAAAAAABAAEAAQACAAQACAAQABAAIABAAIAAgAAAAoAGgAYvAxAAbAAAAHEBAAARAAAAIAAgAIAAAEAABAAEACAwAAAgABAAQAABAEAAQABAAEAvAxAAbAAAAHUBAAARAAAA3yYQAHMAAABZAgAAGAAAAN8mEABzAAAAXQIAAA0AAADfJhAAcwAAAGoCAAAkAAAA3yYQAHMAAAA0AgAAHQAAAN8mEABzAAAANwIAACEAAADfJhAAcwAAACQCAAAjAAAA3yYQAHMAAACpAgAAIwAAAG6JEABgAAAAMwAAADsAAABuiRAAYAAAADQAAAA7AAAAbokQAGAAAAA9AAAAHwAAAG6JEABgAAAAPwAAAB8AAABjYW5ub3QgcGFyc2UgcGFzdCAAAGizEwASAAAAbm9uLXplcm8gc2l6ZWQgbWFwIHNob3VsZCBjb250YWluIGtleSB0eXBlAAAngRAAYgAAAPAAAAAaAAAAbm9uLXplcm8gc2l6ZWQgbWFwIHNob3VsZCBjb250YWluIHZhbHVlIHR5cGUngRAAYgAAAPMAAAAaAAAAY2Fubm90IHNraXAgZmllbGQgdHlwZSAA/LMTABcAAABwZW5kaW5nIGJvb2wgZmllbGQgIG5vdCB3cml0dGVuABy0EwATAAAAL7QTAAwAAADnIhAAZgAAAKEBAAANAAAA1xQQAGAAAACBBgAADgAAAHsTtkeRTZdEW60kiJ0ot6LHlVRwS0LxLUdJ/J4x+2tcRmFsc2UgcG9zaXRpdmUgcHJvYmFiaWxpdHkgbXVzdCBiZSBiZXR3ZWVuIDAuMCBhbmQgMS4wLCBnb3QgjLQTADwAAAAAAAAAxHoQAGcAAAD5AAAAFgAAAMR6EABnAAAA9wAAAAkAAADEehAAZwAAAIIBAAAPAAAAqDwQAIMAAAAzAAAAIwAAAKg8EACDAAAAMwAAAA0AAACoPBAAgwAAADsAAAASAAAAqDwQAIMAAABAAAAALgAAAKg8EACDAAAAQAAAABEAAACoPBAAgwAAAEkAAAAOAAAAqDwQAIMAAABcAAAAGwAAAGJ5dGUgc3RyZWFtIHNwbGl0IHVuc3VwcG9ydGVkIGZvciBkYXRhIHR5cGVzIG9mIHNpemUgIGJ5dGVzAHS1EwA1AAAAqbUTAAYAAACoPBAAgwAAAI4AAAAMAAAABAAAAE1pc21hdGNoZWQgRml4ZWRMZW5CeXRlQXJyYXkgc2l6ZXM6ICAhPSDUtRMAJAAAAPi1EwAEAAAAqDwQAIMAAACIAAAADQAAAAcAAAACAAAACAAAAAMAAAAGAAAABQAAAKg8EACDAAAAngAAAAwAAACoPBAAgwAAAJgAAAANAAAAqDwQAIMAAACvAAAAFQAAAKg8EACDAAAAswAAACcAAACoPBAAgwAAAM4AAAAbAAAABAAAAAQAAAAEAAAAAwAAAAYAAAADAAAAAwAAAAMAAAAGAAAABAAAAAYAAAADAAAAAwAAAAQAAAAEAAAABQAAAKCrEwCkqxMAqKsTAKyrEwCvqxMAtasTALirEwC7qxMAvqsTAMSrEwDIqxMAzqsTANGrEwDUqxMA2KsTANyrEwAJXRAAZAAAAF4AAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5wdXQubGVuKCkgPj0gTlVNX0JJVFMgKiA0AAAACV0QAGQAAABfAAAAAQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlucHV0LmxlbigpID49IE5VTV9CSVRTICogOAAAAOAuEABwAAAAKAcAAAkAAADXMhAAeAAAAOsHAAAJAAAAEQQAABQAAAAEAAAAEgQAABMEAAAYAAAACAAAABQEAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAEH4784AC6EeAQAAABUEAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiAAAAC4EwAqAAAAqAEAAKkBAACqAQAAFgQAABcEAAByYW5nZSBzdGFydCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gZW5kOiAgPD0gAABIuBMAKgAAAHK4EwAEAAAACywQAFoAAACGAQAACQAAAHJhbmdlIGVuZCBvdXQgb2YgYm91bmRzOiAAAACYuBMAGQAAAHK4EwAEAAAACywQAFoAAACMAQAACQAAABgEAAAMAAAABAAAAF8AAAAAAAAABAAAAAQAAAAZBAAARnJvbVV0ZjhFcnJvcmJ5dGVzZXJyb3IARVsQAFwAAACuAAAAKgAAAAAAAAAEAAAABAAAADQAAABUcnlGcm9tU2xpY2VFcnJvcgAAANRyEABcAAAAUAAAADMAAAB1c2l6ZSBvdmVyZmxvdyB3aGVuIGNhbGN1bGF0aW5nIGI2NCBsZW5ndGgAANRyEABcAAAAVwAAAAoAAACxgxAAYAAAAPoAAAAeAAAAVmVjIGlzIHNpemVkIGNvbnNlcnZhdGl2ZWx5AJy5EwAbAAAAsYMQAGAAAAABAQAAGQAAAGludGVnZXIgb3ZlcmZsb3cgd2hlbiBjYWxjdWxhdGluZyBidWZmZXIgc2l6ZQAAALGDEABgAAAAeQAAABIAAACxgxAAYAAAAHsAAAAbAAAASW52YWxpZCBVVEY4sYMQAGAAAAB/AAAAJAAAAIR2EABiAAAAPQEAABkAAACEdhAAYgAAAD4BAAAaAAAAhHYQAGIAAAA/AQAAFwAAAIR2EABiAAAAQAEAABgAAACEdhAAYgAAACsBAAAZAAAAhHYQAGIAAAAsAQAAGgAAAIR2EABiAAAALQEAABcAAACEdhAAYgAAAC4BAAAYAAAALi4AAM51EABqAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBpbnB1dF9wb3MgPD0gaW5wdXQubGVuKCkAABwmEABmAAAAZQEAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBleHRfZGljdC5pc19lbXB0eSgpAAAAHCYQAGYAAABvAQAACQAAABwmEABmAAAAFQEAACQAAABQTEFJTlBMQUlOX0RJQ1RJT05BUllSTEVCSVRfUEFDS0VEREVMVEFfQklOQVJZX1BBQ0tFRERFTFRBX0xFTkdUSF9CWVRFX0FSUkFZREVMVEFfQllURV9BUlJBWVJMRV9ESUNUSU9OQVJZQllURV9TVFJFQU1fU1BMSVQAAQAAAAAAAABVTkNPTVBSRVNTRURTTkFQUFlHWklQTFpPQlJPVExJTFo0WlNURExaNF9SQVd1bmV4cGVjdGVkIHBhcnF1ZXQgdHlwZTogAAAFvBMAGQAAAHVuZXhwZWN0ZWQgcGFycXVldCBjb252ZXJ0ZWQgdHlwZTogACi8EwAjAAAASW50ZWdlciB0eXBlICBpcyBub3Qgc3VwcG9ydGVkAABUvBMADQAAAGG8EwARAAAAVJAQAFwAAACwAwAAGgAAAHVuZXhwZWN0ZWQgcGFycXVldCByZXBldGl0aW9uIHR5cGU6IJS8EwAkAAAAdW5leHBlY3RlZCBwYXJxdWV0IGVuY29kaW5nOiAAAADAvBMAHQAAAHVuZXhwZWN0ZWQgcGFycXVldCBjb21wcmVzc2lvbiBjb2RlYzogAADovBMAJgAAAHVuZXhwZWN0ZWQgcGFycXVldCBwYWdlIHR5cGU6IAAAGL0TAB4AAABSRVFVSVJFRE9QVElPTkFMUkVQRUFURURCT09MRUFOSU5UMzJJTlQ2NElOVDk2RkxPQVRET1VCTEVCWVRFX0FSUkFZRklYRURfTEVOX0JZVEVfQVJSQVlOT05FVVRGOE1BUE1BUF9LRVlfVkFMVUVMSVNURU5VTURFQ0lNQUxEQVRFVElNRV9NSUxMSVNUSU1FX01JQ1JPU1RJTUVTVEFNUF9NSUxMSVNUSU1FU1RBTVBfTUlDUk9TVUlOVF84VUlOVF8xNlVJTlRfMzJVSU5UXzY0SU5UXzhJTlRfMTZJTlRfMzJJTlRfNjRKU09OQlNPTklOVEVSVkFMAAAeahAAYAAAAB8DAAA6AAAAIAAAAEFycmF5IHRvbyBsYXJnZSwgZXhwZWN0ZWQgbGVzcyB0aGFuIFC+EwAkAAAAUlYQAGwAAAA3AAAABQAAAFJWEABsAAAAOAAAABgAAAAQAAAABAAAAAgAAAAIfBAAaAAAAGwBAAA+AAAACHwQAGgAAABtAQAAOgAAAEluY29uc2lzdGVudCBsZW5ndGggb2YgZGVmaW5pdGlvbiBhbmQgcmVwZXRpdGlvbiBsZXZlbHM6ICAhPSAAAADIvhMAOQAAAAG/EwAEAAAACHwQAGgAAADqAQAAKAAAAAh8EABoAAAA6wEAACgAAAAIfBAAaAAAAJkCAAAiAAAAV3JpdGUgbXVzdCBzdGFydCBhdCBhIHJlY29yZCBib3VuZGFyeSwgZ290IG5vbi16ZXJvIHJlcGV0aXRpb24gbGV2ZWwgb2YgSL8TAEgAAAAIfBAAaAAAALgCAAAiAAAACHwQAGgAAADBAgAAJwAAAERlZmluaXRpb24gbGV2ZWxzIGFyZSByZXF1aXJlZCwgYmVjYXVzZSBtYXggZGVmaW5pdGlvbiBsZXZlbCA9IAC4vxMAPwAAAFJlcGV0aXRpb24gbGV2ZWxzIGFyZSByZXF1aXJlZCwgYmVjYXVzZSBtYXggcmVwZXRpdGlvbiBsZXZlbCA9IAAAwBMAPwAAAAh8EABoAAAAGgMAADIAAAAIfBAAaAAAABsDAAAyAAAACHwQAGgAAABDAwAAMgAAAAh8EABoAAAARAMAADIAAAAIfBAAaAAAADYDAAA2AAAACHwQAGgAAAA7AwAANgAAAAh8EABoAAAAiAMAAB4AAAAIfBAAaAAAAIUDAAAsAAAACHwQAGgAAACnAwAAIwAAAAh8EABoAAAApAMAADEAAAAIfBAAaAAAALYDAAArAAAACHwQAGgAAAC6AwAAKwAAAAh8EABoAAAAzQMAACsAAAAIfBAAaAAAANEDAAArAAAACHwQAGgAAAAXBAAAHAAAAAh8EABoAAAAIQQAABwAAAAIfBAAaAAAACoEAAAYAAAACHwQAGgAAAAuBAAALgAAAAh8EABoAAAARgQAABwAAAAIfBAAaAAAAEwEAAAcAAAACHwQAGgAAABgBAAAIAAAAAh8EABoAAAAWQQAACQAAAAIfBAAaAAAAHcEAAAdAAAACHwQAGgAAACjBAAAOgAAAAh8EABoAAAA6QQAACUAAAAIfBAAaAAAAAcFAAAmAAAACHwQAGgAAAAWBQAAHQAAAERpY3Rpb25hcnkgZW5jb2RlciBpcyBub3Qgc2V0RGljdGlvbmFyeSBvZmZzZXQgaXMgYWxyZWFkeSBzZXQAAAAVwhMAIAAAAAh8EABoAAAAMAUAABEAAAAIfBAAaAAAAGMFAAArAAAACHwQAGgAAABjBQAAMwAAAAh8EABoAAAAzQUAAC0AAAAIfBAAaAAAAM4FAAAtAAAACHwQAGgAAAAHBgAAGQAAAAh8EABoAAAAIgYAADEAAAAIfBAAaAAAACMGAAAyAAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9yAAAAAAAEAAAABAAAAAsEAAAAAAAABAAAAAQAAAAxAAAASW5kZXhPdXRPZkJvdW5kAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbE5lZWRNb3JlRGF0YQAAAAAEAAAABAAAADMAAABOZWVkTW9yZURhdGFSYW5nZVN0cmluZ01hcExpc3RFbnVtAAAAAAAABAAAAAQAAAAaBAAAAAAAAAQAAAAEAAAAbQMAAERlY2ltYWxzY2FsZXByZWNpc2lvbkRhdGUAAAAAAAAAAQAAAAEAAAAbBAAAAAAAAAQAAAAEAAAAHAQAAFRpbWVpc19hZGp1c3RlZF90b191X3RfY3VuaXRUaW1lc3RhbXAAAAAAAAAAAQAAAAEAAAAdBAAAAAAAAAQAAAAEAAAARwIAAEludGVnZXJiaXRfd2lkdGhpc19zaWduZWRVbmtub3duSnNvbkJzb25VdWlkRmxvYXQxNlZhcmlhbnRHZW9tZXRyeUdlb2dyYXBoeQAAAAAABAAAAAQAAAAeBAAAAAAAAAQAAAAEAAAAHwQAAAAAAAAEAAAABAAAACAEAAC/VhAAZAAAAOoAAAA4AAAAv1YQAGQAAADrAAAAFQAAAL9WEABkAAAAJwEAABIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbnZhbGlkIG51bV9iaXRzIADAxBMAOwAAAAldEABkAAAAXAAAAAEAAAAJXRAAZAAAAF0AAAABAAAACV0QAGQAAABeAAAAAQAAAAldEABkAAAAXwAAAAEAAADqTBAAYgAAAOoAAAAYAAAA6kwQAGIAAADsAAAANwAAAOpMEABiAAAA8wAAABgAAADqTBAAYgAAAPYAAAA1AAAADCoQAGcAAAB6AAAAHQAAABRsEABkAAAAkgAAAAkAAAAEAAAABAAAAAMAAAANAAAABAAAAAQAAAAHAAAABAAAAAsAAAALAAAAEAAAABAAAAAGAAAABwAAAAcAAAAHAAAABQAAAAYAAAAGAAAABgAAAAQAAAAEAAAACAAAAJe9EwCbvRMAn70TAKK9EwCvvRMAs70TALe9EwC+vRMAwr0TAM29EwDYvRMA6L0TAPi9EwD+vRMABb4TAAy+EwATvhMAGL4TAB6+EwAkvhMAKr4TAC6+EwAyvhMABwAAAAUAAAAFAAAABQAAAAUAAAAGAAAACgAAABQAAABYvRMAX70TAGS9EwBpvRMAbr0TAHO9EwB5vRMAg70TAAUAAAAQAAAAAwAAAAoAAAATAAAAFwAAABAAAAAOAAAAEQAAAFS7EwBZuxMAabsTAGy7EwB2uxMAibsTAKC7EwCwuxMAvrsTAEC9EwBIvRMAUL0TAAAAAQIDBAUGBwgAAAYAAAAGAAAABgAAAAYAAAABAAAABgAAAAEAAAAGAEGtjs8AC9kJAwAAAAAAAAACAAB0AAAAfQAAABwAAABcghAAfgAAALIFAAAkAAAAbWlzc2luZyByZXF1aXJlZCBmaWVsZCAAVMcTABcAAADOdRAAagAAAL0BAAAdAAAAUGFnZSBjb21wcmVzc2VkIHNpemUgb3ZlcmZsb3c6IACExxMAHwAAAFBhZ2UgdW5jb21wcmVzc2VkIHNpemUgb3ZlcmZsb3c6IAAAAKzHEwAhAAAAsHAQAGIAAABgAQAAPgAAALBwEABiAAAAbQEAAEEAAABwYWdlIHR5cGUgIGNhbm5vdCBiZSBjb252ZXJ0ZWQgdG8gUGFnZU1ldGFkYXRhAAD4xxMACgAAAALIEwAkAAAASW5zdWZmaWNpZW50IHJlcGV0aXRpb24gbGV2ZWxzIHJlYWQgZnJvbSBjb2x1bW5hc3NlcnRpb24gZmFpbGVkOiByZWNvcmRzX3JlYWQgPCByZW1haW5pbmdfcmVjb3JkcwAAABdEEABkAAAA6wAAABkAAABpbnN1ZmZpY2llbnQgdmFsdWVzIHJlYWQgZnJvbSBjb2x1bW4gLSBleHBlY3RlZDogLCBnb3Q6IKzIEwAxAAAA3cgTAAcAAABpbnN1ZmZpY2llbnQgZGVmaW5pdGlvbiBsZXZlbHMgcmVhZCBmcm9tIGNvbHVtbiAtIGV4cGVjdGVkIHtsZXZlbHNfdG9fcmVhZH0sIGdvdCB7bGV2ZWxzX3JlYWR9bXVzdCBzcGVjaWZ5IHJlcGV0aXRpb24gbGV2ZWxzbXVzdCBzcGVjaWZ5IGRlZmluaXRpb24gbGV2ZWxzAAAXRBAAZAAAAFABAAAZAAAAc2tpcHBlZCAgdmFsdWVzLCBleHBlY3RlZCAAAKDJEwAIAAAAqMkTABIAAABsZXZlbHMgbWlzbWF0Y2gsIHJlYWQgIHJlcGV0aXRpb24gbGV2ZWxzIGFuZCAgZGVmaW5pdGlvbiBsZXZlbHMAzMkTABYAAADiyRMAFwAAAPnJEwASAAAASW52YWxpZCBwYWdlLiBFeHBlY3RpbmcgZGljdGlvbmFyeSBwYWdlABdEEABkAAAAwwEAACYAAAAXRBAAZAAAANIBAAAmAAAAF0QQAGQAAAD6AQAAQQAAABdEEABkAAAAAwIAAEEAAABtb3JlIG51bGxzIHRoYW4gdmFsdWVzIGluIHBhZ2UsIGNvbnRhaW5lZCAgdmFsdWVzIGFuZCAgbnVsbHOMyhMAKgAAALbKEwAMAAAAwsoTAAYAAABpbnZhbGlkIGxldmVsIGVuY29kaW5nOiDgyhMAGAAAAAAAAAAEAAAABAAAAG0DAABQYWdlVHlwZWAAAABYAAAACAAAAAAAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAHCLEAB+AAAANAAAAAUAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQAAAO8nEABrAAAA+AEAAA4AAAAAAAAABAAAAAQAAAAiBAAAAAAAAAQAAAAEAAAASgIAQZCYzwALgwIBAAAAIwQAAGFzc2VydGlvbiBmYWlsZWQ6IGRzdC5sZW4oKSA+PSBzZWxmLnJlcXVpcmVkX3NwYWNlKClkHRAAZQAAAL0AAAAJAAAAZB0QAGUAAADHAAAACQAAAGQdEABlAAAAwgAAAA0AAAD8hhAAbAAAAOIKAAAkAAAA9SEQAHkAAAD7AAAAAQAAAM51EABqAAAAXwMAAAkAAAAPNxAAZQAAACoAAAAcAAAA8o0QAFgAAABmAAAAHgAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADOdRAAagAAAKcBAAAfAAAAznUQAGoAAACuAQAAJgAAAP//////////CM0TAEGgms8AC4sCNjwQAHEAAAA1AAAADgAAADY8EABxAAAAPQAAACMAAAA2PBAAcQAAAD0AAAARAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogSW52YWxpZCB0YXJnZXRfdHlwZSBmb3IgSW50OTYuUM0TAEgAAACZCxAAeQAAAF8AAAASAAAA2ocQAGgAAABdAwAAEQAAACsEAAA0AAAABAAAACwEAACcRhAAaQAAAKMAAAATAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAAAAAAP//////////IM4TAEG4nM8AC/IB51HfowBlUvxOFPrNbmSQKZI5xUazPs0y+5WJbRIdLyTtA0ifzjw4VLrw3c09UEgQC29pMjKk4R6lrzqBzmZDgPjVTFc7mE2LIvXN/3hfC9MKhZW/IEozSXDxY79wngdrV/CMI74HCC3mkyVvVPH/eZXGSEtF/rhGs2cet9Q4ijL7Dn/dZKwIGe04xkamSdSL/Y6QvO2ptyOVAXsvNSuJ2xOZG0KIJu5t/Uj5ePZkrnH0JZQYRfOIB4x2dfTv2t/lc+0rTZv+6HdM4/H+feiAUv/sWnXFLhhxAXp4pMJb1YsVpshLeyZ5LwFLe1wZZMGGLQQAQbSezwALlUUBAAAALgQAAC8EAAAYAAAACAAAADAEAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAOJfEABrAAAA6AEAABcAAADiXxAAawAAAFQLAAABAAAA+tUy8Ua+bfM61IAWL3iSWKdIDPBnX5Oh8meN+VtzX/0NuNmGge7izitUvNdouZYAN4ELy7Hkxk7fovYO625hGAAAAAAEAAAABAAAADEEAAAAAAAABAAAAAQAAABFAgAASW52YWxpZEJ5dGUAAAAAAAQAAAAEAAAAMQAAAEludmFsaWRMZW5ndGhJbnZhbGlkTGFzdFN5bWJvbEludmFsaWRQYWRkaW5nAAAAAAQAAAAEAAAAMgQAAFV0ZjhFcnJvcnZhbGlkX3VwX3RvZXJyb3JfbGVuAAAAz4kQAGEAAAAvAAAAEQAAAMRKEABqAAAAbQgAAB8AAABMYXlvdXRFcnJvcgAzBAAADAAAAAQAAAChAQAAAAAAAAQAAAAEAAAAogEAAE1pc3NpbmdSZXF1aXJlZEZpZWxkcmVxdWlyZWRlcnJvcl90cmFjZUluY29uc2lzdGVudFVuaW9uZmllbGRmaWVsZF90eXBlAAAAAAAIAAAABAAAADQEAAAAAAAACAAAAAQAAACkAQAAZXJyb3JyYW5nZU1pc3NpbmdOdWxsVGVybWluYXRvclVuYWxpZ25lZHBvc2l0aW9udW5hbGlnbmVkX3R5cGVSYW5nZU91dE9mQm91bmRzAAAAAAAABAAAAAQAAAA1BAAAU2lnbmVkT2Zmc2V0T3V0T2ZCb3VuZHNzb2Zmc2V0VG9vTWFueVRhYmxlc0FwcGFyZW50U2l6ZVRvb0xhcmdlRGVwdGhMaW1pdFJlYWNoZWQ2BAAAZAAAAAQAAAA3BAAAznUQAGoAAAC9AQAAHQAAAEsrEABmAAAAsgAAABkAAABLKxAAZgAAAOUAAAAZAAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAOgQAADsEAAA7BAAAAAAAAAQAAAAEAAAAPAQAAD0EAAA9BAAAAAAAAAQAAAAEAAAAPgQAAD8EAAA/BAAAAAAAAAQAAAAEAAAAQAQAAEEEAABBBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAQgQAAEMEAABDBAAAAAAAAAQAAAAEAAAARAQAAEUEAABFBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAARgQAAEcEAABHBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAASAQAAEkEAABJBAAAAAAAAAQAAAAEAAAAOAQAADkEAAA5BAAAAAAAAAQAAAAEAAAASgQAAEsEAABLBAAAAAAAAAQAAAAEAAAATAQAAE0EAABNBAAALCBJbmNvbXBhdGlibGUgc3VwcGxpZWQgQXJyb3cgc2NoZW1hOiAAAJbTEwAkAAAAZGF0YSB0eXBlIG1pc21hdGNoIGZvciBmaWVsZCA6IHJlcXVlc3RlZCAgYnV0IGZvdW5kIMTTEwAdAAAA4dMTAAwAAADt0xMACwAAAHF8EABtAAAAgAIAABgAAABudWxsYWJpbGl0eSBtaXNtYXRjaCBmb3IgZmllbGQgOiBleHBlY3RlZCAAACDUEwAfAAAAP9QTAAsAAADt0xMACwAAAHF8EABtAAAAiAIAABgAAABtZXRhZGF0YSBtaXNtYXRjaCBmb3IgZmllbGQgdNQTABwAAAA/1BMACwAAAO3TEwALAAAAcXwQAG0AAACQAgAAGAAAAEluY29tcGF0aWJsZSBzdXBwbGllZCBBcnJvdyBzY2hlbWE6IGV4cGVjdGVkICBjb2x1bW5zIHJlY2VpdmVkIAC41BMALQAAAOXUEwASAAAAcXwQAG0AAAD+AwAANwAAAHF8EABtAAAAGAQAACcAAABmYWlsZWQgdG8gc2tpcCByb3dzLCBleHBlY3RlZCAsIGdvdCAo1RMAHgAAAEbVEwAGAAAAU3RydWN0IGFycmF5IHJlYWRlciBzaG91bGQgcmV0dXJuIHN0cnVjdCBhcnJheWludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IFN0cnVjdCBhcnJheSByZWFkZXIncyBkYXRhIHR5cGUgaXMgbm90IHN0cnVjdCEAAIrVEwBYAAAAcXwQAG0AAABpBAAAEgAAACcpQ2Fubm90IGNhbGwgZ2V0X2ZpZWxkcygpIG9uIGEgbm9uLWdyb3VwIHR5cGUAAP7VEwAsAAAAKS0QAGMAAABwAAAAEgAAAENhbm5vdCBjYWxsIGdldF9waHlzaWNhbF90eXBlKCkgb24gYSBub24tcHJpbWl0aXZlIHR5cGUARNYTADcAAAApLRAAYwAAAH0AAAASAAAAIGNhbm5vdCBiZSBhcHBsaWVkIHRvIGEgcHJpbWl0aXZlIHR5cGUgZm9yIGZpZWxkICcAAAEAAAAAAAAAlNYTADIAAAD81RMAAQAAAERFQ0lNQUwgbG9naWNhbCB0eXBlIHByZWNpc2lvbiAgbXVzdCBtYXRjaCBzZWxmLnByZWNpc2lvbiAgZm9yIGZpZWxkICcAAODWEwAfAAAA/9YTABsAAAAa1xMADAAAAPzVEwABAAAAREVDSU1BTCBsb2dpY2FsIHR5cGUgc2NhbGUgIG11c3QgbWF0Y2ggc2VsZi5zY2FsZSAAAEjXEwAbAAAAY9cTABcAAAAa1xMADAAAAPzVEwABAAAAQ2Fubm90IHVzZSBtaWxsaXNlY29uZCB1bml0IG9uIElOVDY0IHR5cGUgZm9yIGZpZWxkICcAAACc1xMANQAAAPzVEwABAAAAVVVJRCBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBGSVhFRF9MRU5fQllURV9BUlJBWSgxNikgZmllbGTk1xMAHAAAAADYEwA0AAAARkxPQVQxNiBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBGSVhFRF9MRU5fQllURV9BUlJBWSgyKSBmaWVsZAAARNgTAB8AAABj2BMAMwAAAENhbm5vdCBhbm5vdGF0ZSAgZnJvbSAAAKjYEwAQAAAAuNgTAAYAAAAa1xMADAAAAPzVEwABAAAATG9naWNhbCB0eXBlICBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb252ZXJ0ZWQgdHlwZSAAAODYEwANAAAA7dgTACUAAAAa1xMADAAAAPzVEwABAAAARU5VTSBjYW5ub3QgYW5ub3RhdGUgZmllbGQgJycgYmVjYXVzZSBpdCBpcyBub3QgYSBCWVRFX0FSUkFZIGZpZWxkAAA02RMAHAAAAFDZEwAmAAAAIGNhbm5vdCBhbm5vdGF0ZSBmaWVsZCAnJyBiZWNhdXNlIGl0IGlzIG5vdCBhIElOVDMyIGZpZWxkAAAAAQAAAAAAAACI2RMAGAAAAKDZEwAhAAAAJyBiZWNhdXNlIGl0IGlzIG5vdCBhIElOVDY0IGZpZWxkAAAAAQAAAAAAAACI2RMAGAAAANzZEwAhAAAAAQAAAAAAAACI2RMAGAAAAFDZEwAmAAAASU5URVJWQUwgY2Fubm90IGFubm90YXRlIGZpZWxkICcnIGJlY2F1c2UgaXQgaXMgbm90IGEgRklYRURfTEVOX0JZVEVfQVJSQVkoMTIpIGZpZWxkMNoTACAAAABQ2hMANAAAACBjYW5ub3QgYmUgYXBwbGllZCB0byBwcmltaXRpdmUgZmllbGQgJwABAAAAAAAAAJTaEwAnAAAA/NUTAAEAAABJbnZhbGlkIEZJWEVEX0xFTl9CWVRFX0FSUkFZIGxlbmd0aDogAAAA1NoTACUAAAAa1xMADAAAAPzVEwABAAAAQ2Fubm90IHJlcHJlc2VudCBJTlQzMiBhcyBERUNJTUFMIHdpdGggcHJlY2lzaW9uIAAAABTbEwAxAAAAQ2Fubm90IHJlcHJlc2VudCBJTlQ2NCBhcyBERUNJTUFMIHdpdGggcHJlY2lzaW9uIAAAAFDbEwAxAAAASW52YWxpZCBsZW5ndGggIGZvciBEZWNpbWFsAIzbEwAPAAAAm9sTAAwAAABDYW5ub3QgcmVwcmVzZW50IEZJWEVEX0xFTl9CWVRFX0FSUkFZIGFzIERFQ0lNQUwgd2l0aCBsZW5ndGggIGFuZCBwcmVjaXNpb24gLiBUaGUgbWF4IHByZWNpc2lvbiBjYW4gb25seSBiZSC42xMAPQAAAPXbEwAPAAAABNwTACAAAABJbnZhbGlkIERFQ0lNQUw6IHNjYWxlICgpIGNhbm5vdCBiZSBncmVhdGVyIHRoYW4gcHJlY2lzaW9uICg83BMAGAAAAFTcEwAkAAAA/dUTAAEAAABJbnZhbGlkIERFQ0lNQUwgc2NhbGU6IACQ3BMAFwAAAEludmFsaWQgREVDSU1BTCBwcmVjaXNpb246IACw3BMAGwAAAERFQ0lNQUwgY2FuIG9ubHkgYW5ub3RhdGUgSU5UMzIsIElOVDY0LCBCWVRFX0FSUkFZIGFuZCBGSVhFRF9MRU5fQllURV9BUlJBWWFzc2VydGlvbiBmYWlsZWQ6IHNlbGYucmVwZXRpdGlvbi5pc19zb21lKCkAACktEABjAAAAuAIAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlkLmlzX3NvbWUoKQApLRAAYwAAAM4CAAAJAAAALkV4cGVjdGVkIHByaW1pdGl2ZSB0eXBlIQAAAJHdEwAYAAAAKS0QAGMAAACSAwAAEgAAACktEABjAAAAmwMAABIAAABTY2hlbWFEZXNjcmlwdG9yIHNob3VsZCB0YWtlIGEgR3JvdXBUeXBl1N0TACgAAAApLRAAYwAAAAYEAAAJAAAASW5kZXggb3V0IG9mIGJvdW5kOiAgbm90IGluIFswLCAU3hMAFAAAACjeEwAMAAAA/dUTAAEAAAApLRAAYwAAADgEAAAJAAAARXhwZWN0ZWQgYSB2YWx1ZSBmb3IgaW5kZXggIGJ1dCBmb3VuZCBOb25lAABc3hMAGwAAAHfeEwAPAAAAKS0QAGMAAABCBAAAIAAAAGFzc2VydGlvbiBmYWlsZWQ6IHRwLmdldF9iYXNpY19pbmZvKCkuaGFzX3JlcGV0aXRpb24oKQAAKS0QAGMAAABiBAAABQAAACktEABjAAAAZAQAABEAAAApLRAAYwAAAHMEAAASAAAAKS0QAGMAAAB0BAAAFAAAACktEABjAAAAegQAABoAAABFeHBlY3RlZCByb290IG5vZGUgdG8gYmUgYSBncm91cCB0eXBlRXhwZWN0ZWQgZXhhY3RseSBvbmUgcm9vdCBub2RlLCBidXQgZm91bmQgAFXfEwAqAAAAKS0QAGMAAACUBAAAFgAAAEJpdCB3aWR0aCBtdXN0IGJlIDgsIDE2LCAzMiwgb3IgNjQgZm9yIEludGVnZXIgbG9naWNhbCB0eXBlACktEABjAAAAxQQAADgAAAApLRAAYwAAAP8EAAA5AAAAUmVwZXRpdGlvbiBsZXZlbCBtdXN0IGJlIGRlZmluZWQgZm9yIGEgcHJpbWl0aXZlIHR5cGUAAAApLRAAYwAAACEFAAA2AAAAKS0QAGMAAAANBQAAGAAAAEluZGV4IG91dCBvZiBib3VuZCwgaW5kZXggPSAsIGxlbiA9IEzgEwAcAAAAaOATAAgAAABSb290IHNjaGVtYSBtdXN0IGJlIEdyb3VwIHR5cGUAACktEABjAAAAVAUAABYAAAApLRAAYwAAAHEFAAAWAAAAAAAAAAQAAAAEAAAASgIAAEdlbmVyYWxOWUlFT0ZBcnJvd0Vycm9ySW5kZXhPdXRPZkJvdW5kAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxOZWVkTW9yZURhdGEAAAAABAAAAAQAAAAzAAAATmVlZE1vcmVEYXRhUmFuZ2UAAABOBAAAWAAAAAgAAABPBAAAUAQAAFEEAABSBAAAUwQAAFQEAABUBAAAbm90IGltcGxlbWVudGVkOiByZWFkaW5nIGdyb3VwIHR5cGUgIG5vdCBpbXBsZW1lbnRlZGjhEwAkAAAAjOETABAAAAD2QRAAcQAAAKIAAAAWAAAAAgAAAPZBEABxAAAAvwAAACUAAAD2QRAAcQAAAMAAAAAlAAAAVQQAACgAAAAEAAAAVgQAAFcEAABYBAAAWQQAAFoEAABbBAAAXAQAAPZBEABxAAAAvAAAAB0AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2Rl9kEQAHEAAADFAAAAHgAAAHBhcnRpYWwgcHJvamVjdGlvbiBvZiBNYXBBcnJheSBpcyBub3Qgc3VwcG9ydGVkAPZBEABxAAAArgAAAAkAAAD2QRAAcQAAAOEAAAApAAAAAQAAAF0EAAAcAAAABAAAAF4EAABfBAAAYAQAAGEEAABiBAAAYwQAAGQEAABdBAAAHAAAAAQAAABlBAAAXwQAAGAEAABmBAAAYgQAAGMEAABkBAAA9kEQAHEAAADvAAAAGgAAAPZBEABxAAAA4gAAAAkAAABnBAAAIAAAAAQAAABoBAAAaQQAAGoEAABrBAAAbAQAAG0EAABuBAAA9kEQAHEAAAAQAQAACQAAAG8EAABgAQAACAAAAHAEAABxBAAAcgQAAHMEAAB0BAAAdQQAAHYEAAB3BAAAYAEAAAgAAAB4BAAAcQQAAHkEAAB6BAAAewQAAHUEAAB2BAAAdwQAAGABAAAIAAAAfAQAAHEEAAB5BAAAfQQAAHsEAAB1BAAAdgQAAH4EAABgAQAACAAAAH8EAABxBAAAgAQAAIEEAACCBAAAdQQAAHYEAACDBAAAYAEAAAgAAACEBAAAcQQAAIUEAACGBAAAhwQAAHUEAAB2BAAAiAQAAGABAAAIAAAAiQQAAHEEAACKBAAAiwQAAIwEAAB1BAAAdgQAAI0EAABgAQAACAAAAI4EAABxBAAAjwQAAJAEAACRBAAAdQQAAHYEAAD2QRAAcQAAADoBAAArAAAA9kEQAHEAAACaAQAACQAAAPZBEABxAAAAnAEAABsAAACSBAAAIAAAAAQAAACTBAAAlAQAAJUEAACWBAAAlwQAAJgEAACZBAAA9kEQAHEAAACkAQAAGQAAAE4EAABYAAAACAAAAJoEAABnBAAAIAAAAAQAAACbBAAAZmlyc3QgcmVwZXRpdGlvbiBsZXZlbCBvZiBiYXRjaCBtdXN0IGJlIDAAAAArBAAANAAAAAQAAACcBAAAnQQAAJ4EAACfBAAAoAQAAKEEAACiBAAAowQAAKQEAAClBAAApgQAAKcEAACoBAAAqQQAAKoEAACrBAAArAQAAK0EAACuBAAAZml4ZWQtc2l6ZSBsaXN0IGxlbmd0aCBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgIGJ1dCBhcnJheSBjb250YWlucyAgZWxlbWVudHMAAHDlEwAtAAAAneUTABQAAACx5RMACQAAAGl0ZW1fcmVhZGVyIGRlZiBsZXZlbHMgYXJlIE5vbmVpdGVtX3JlYWRlciByZXAgbGV2ZWxzIGFyZSBOb25lRW5jb3VudGVyZWQgbWlzYWxpZ25lZCByb3cgd2l0aCBsZW5ndGggIChleHBlY3RlZCBsZW5ndGggABLmEwAnAAAAOeYTABIAAAD91RMAAQAAAEVuY291bnRlcmVkIHJlcGV0aXRpb24gbGV2ZWwgdG9vIGxhcmdlIGZvciBkZWZpbml0aW9uIGxldmVsAF0EAAAcAAAABAAAAK8EAABdBAAAHAAAAAQAAACwBAAAbWFwIHN0cnVjdCBjYW5ub3QgYmUgbnVsbGFibGUAAADA5hMAHQAAAAEJEABzAAAANgAAABUAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBleHBlY3RlZCBzdHJ1Y3Qgd2l0aCB0d28gZmllbGRzAAAA+OYTAEkAAAABCRAAcwAAADkAAAAWAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogZXhwZWN0ZWQgbWFwIHR5cGUAXOcTADsAAAABCRAAcwAAADsAAAASAAAAVQQAACgAAAAEAAAAsQQAAAEJEABzAAAAYgAAADEAAAA2BAAAZAAAAAQAAACyBAAAswQAALQEAAC1BAAAtgQAALcEAAC4BAAAuQQAALoEAAClBAAAuwQAALwEAAC9BAAAvgQAAL8EAADABAAAwQQAAMIEAADDBAAAdwQAAGABAAAIAAAAxAQAAG8EAABgAQAACAAAAMUEAACNBAAAYAEAAAgAAADGBAAAgwQAAGABAAAIAAAAxwQAAH4EAABgAQAACAAAAMgEAACIBAAAYAEAAAgAAADJBAAAdwQAAGABAAAIAAAAygQAAJIEAAAgAAAABAAAAMsEAAA7DxAAawAAAMUAAAAcAAAAOw8QAGsAAADLAAAAIgAAADsPEABrAAAA4wAAABoAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBmaWVsZCBuYW1lZCAgZ290IAAAANjoEwAwAAAACOkTAAUAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCAgc3RydWN0IGZpZWxkcyBnb3QgACDpEwAkAAAAROkTABMAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBzdHJ1Y3QgZ290IABo6RMALwAAADsPEABrAAAA2AAAADYAAAA7DxAAawAAAA0BAAAeAAAAOw8QAGsAAAAgAQAAGAAAADsPEABrAAAAIQEAABoAAAA7DxAAawAAAD4BAAAqAAAAOw8QAGsAAAA+AQAAPQAAAE1hcCBkYXRhIHR5cGUgc2hvdWxkIGNvbnRhaW4gc3RydWN0IHdpdGggdHdvIGNoaWxkcmVuLCBnb3QgAADqEwA7AAAATWFwIGRhdGEgdHlwZSBzaG91bGQgY29udGFpbiBzdHJ1Y3QgZ290IETqEwAoAAAAaW5jb21wYXRpYmxlIGFycm93IHNjaGVtYSwgZXhwZWN0ZWQgbWFwIGdvdCB06hMALAAAAE1hcCB2YWx1ZXMgY2Fubm90IGJlIHJlcGVhdGVkTWFwIGtleXMgY2Fubm90IGJlIHJlcGVhdGVkQ2hpbGQgb2YgbWFwIGZpZWxkIG11c3QgaGF2ZSB0d28gY2hpbGRyZW4sIGZvdW5kIAAAAODqEwAxAAAAQ2hpbGQgb2YgbWFwIGZpZWxkIG11c3QgYmUgcmVwZWF0ZWRNYXAgZmllbGQgbXVzdCBoYXZlIGV4YWN0bHkgb25lIGtleV92YWx1ZSBjaGlsZCwgZm91bmQgAAA/6xMANwAAAE1hcCBjYW5ub3QgYmUgcmVwZWF0ZWRhcnJheV90dXBsZQAAAAEAAAAAAAAAm+sTAAYAAABpbmNvbXBhdGlibGUgYXJyb3cgc2NoZW1hLCBleHBlY3RlZCBsaXN0IGdvdCAAAAC06xMALQAAAExpc3QgdHlwZSBjYW5ub3QgYmUgcmVwZWF0ZWRMaXN0IGNoaWxkIG11c3QgYmUgcmVwZWF0ZWRsaXN0IHR5cGUgbXVzdCBoYXZlIGEgc2luZ2xlIGNoaWxkLCBmb3VuZCAAAAAj7BMAKgAAACBpcyBhIGxpc3QgdHlwZSBhbmQgY2FuJ3QgYmUgcHJvY2Vzc2VkIGFzIHByaW1pdGl2ZS4BAAAAAAAAAFjsEwA0AAAAUEFSUVVFVDpmaWVsZF9pZDsPEABrAAAAbAIAADEAAABBUlJPVzpzY2hlbWFDiBAAZwAAAFEAAAAeAAAAQ4gQAGcAAABRAAAAOwAAAEOIEABnAAAAhwAAABIAAAABAAFBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSsv/////////////////////////////////////////////////////////z7///8/NDU2Nzg5Ojs8Pf////////8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGf///////xobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIz//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AvOwTAAwAAABVbmFibGUgdG8gZ2V0IHJvb3QgYXMgbWVzc2FnZSBzdG9yZWQgaW4gOiAAAEjuEwAoAAAAcO4TAAIAAABVbmFibGUgdG8gZGVjb2RlIHRoZSBlbmNvZGVkIHNjaGVtYSBzdG9yZWQgaW4gAACE7hMALgAAAJTTEwACAAAAdGhlIG1lc3NhZ2UgaXMgbm90IEFycm93IFNjaGVtYQBDiBAAZwAAAL8AAAAhAAAAQ4gQAGcAAADAAAAAFwAAAEOIEABnAAAAwQAAABcAAABDiBAAZwAAAMIAAAAXAAAAQ4gQAGcAAADkAAAAEgAAAEOIEABnAAAA4AAAABIAAABDiBAAZwAAAOEAAAASAAAAQ4gQAGcAAABxAQAALgAAAEOIEABnAAAAcQEAAD0AAABhZGp1c3RlZF90b191dGNpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHVuaXQgZm9yIFRpbWUzMjogAACD7xMAQwAAAEOIEABnAAAAPwIAABoAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHVuaXQgZm9yIFRpbWU2NDogAODvEwBDAAAAQ4gQAGcAAABLAgAAGgAAAGVsZW1lbnRsaXN0bm90IGltcGxlbWVudGVkOiBMaXN0Vmlldy9MYXJnZUxpc3RWaWV3IG5vdCBpbXBsZW1lbnRlZAAAR/ATADcAAABDiBAAZwAAAMwCAAANAAAAUGFycXVldCBkb2VzIG5vdCBzdXBwb3J0IHdyaXRpbmcgZW1wdHkgc3RydWN0cwAAmPATAC4AAABub3QgaW1wbGVtZW50ZWQ6IFNlZSBBUlJPVy04ODE3LtDwEwAgAAAAQ4gQAGcAAAADAwAAIgAAAGtleV92YWx1ZQAAAEOIEABnAAAA7wIAAEgAAABrZXkAQ4gQAGcAAADwAgAASgAAAHZhbHVlRGF0YVR5cGU6Ok1hcCBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBmaWVsZCBjaGlsZAAAPfETADEAAABDb252ZXJ0aW5nIFJ1bkVuZEVuY29kZWRUeXBlIHRvIHBhcnF1ZXQgbm90IHN1cHBvcnRlZAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAQAAAAEAQdjjzwALhQUBAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEQAAABIAAAATAAAAFAAAABUAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAAIjyEwAlAAAArfITACEAAAAoCxAAcAAAAOcCAAAJAAAAIGZyb20gYSBUeXBlZERpY3Rpb25hcnlBcnJheSBvZiBsZW5ndGggAIjyEwAlAAAA8PITACcAAAASBBAAcQAAAKwDAAAJAAAA1zIQAHgAAADrBwAACQAAAM0EAAAEAAAABAAAAM4EAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAM8EAAAAAAAABAAAAAQAAADQBAAAAAAAAAwAAAAEAAAA0QQAAAAAAAAEAAAABAAAANIEAABJbnB1dFBhaXIAAADOdRAAagAAADwDAAAQAAAAaW5jb21wbGV0ZSBmcmFtZQAAAAAIAAAABAAAANMEAAAAAAAABAAAAAQAAAAxAAAASW5wdXRSZWZlcmVuY2VkYXRhb3JpZ19vZmZzZXQAAADOdRAAagAAAL0BAAAdAAAAznUQAGoAAACnAQAAHwAAAM51EABqAAAArgEAACYAQejozwAL5QQsexAAbQAAAAMCAAAXAAAALHsQAG0AAAABAgAACQAAACx7EABtAAAAHgIAABQAAAAsexAAbQAAAEsCAAAeAAAALHsQAG0AAABdAgAALgAAACx7EABtAAAAawIAABIAAAAsexAAbQAAAGwCAAASAAAALHsQAG0AAAAZAwAANgAAACx7EABtAAAAUwMAACAAAAAsexAAbQAAAKcDAAAXAAAALHsQAG0AAAAjBAAAfAAAACx7EABtAAAAIwQAAGUAAAAsexAAbQAAACoEAAAuAAAALHsQAG0AAAAqBAAAFQAAACx7EABtAAAARQQAADIAAAAsexAAbQAAAEUEAAAZAAAALHsQAG0AAAA/BAAAMgAAACx7EABtAAAAPwQAABkAAAAsexAAbQAAAEIEAAAyAAAALHsQAG0AAABCBAAAGQAAACx7EABtAAAASAQAADAAAAAsexAAbQAAAEgEAAAZAAAALHsQAG0AAAA4BAAAMgAAACx7EABtAAAAOQQAADIAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbnZhbGlkIG1hcCB0eXBlAADo9RMAOgAAACx7EABtAAAAOwQAABYAAABBdHRlbXB0aW5nIHRvIHdyaXRlIGFuIEFycm93IHR5cGUgIHRvIHBhcnF1ZXQgdGhhdCBpcyBub3QgeWV0IGltcGxlbWVudGVkAAAAPPYTACIAAABe9hMAJwAAACx7EABtAAAAIgQAAEkAAAAsexAAbQAAACIEAAAyAAAA1AQAAAQAAAAEAAAA1QQAANYEAAAOAEHY7c8AC1nXBAAACAAAAAQAAAByAgAAcwIAAHQCAADYBAAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAABABBvO7PAAsBBQBByO7PAAvmNGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IEN1cnJlbnRseSB1bnJlYWNoYWJsZSBiZWNhdXNlIGRhdGEgdHlwZSBub3Qgc3VwcG9ydGVkAEj3EwBfAAAALHsQAG0AAAACBQAADQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHNob3VsZCB1c2UgQnl0ZUFycmF5V3JpdGVywPcTAEQAAAAsexAAbQAAAA0FAAANAAAALHsQAG0AAAAWBQAAHgAAACx7EABtAAAAHQUAAB4AAABBdHRlbXB0aW5nIHRvIHdyaXRlIGFuIEFycm93IGludGVydmFsIHR5cGUgADz4EwArAAAAXvYTACcAAAAsexAAbQAAACwFAAAaAAAALHsQAG0AAAA/BQAAGgAAAEF0dGVtcHRpbmcgdG8gd3JpdGUgYW4gQXJyb3cgdHlwZSB0aGF0IGlzIG5vdCB5ZXQgaW1wbGVtZW50ZWQAAAAsexAAbQAAAGIFAAAWAAAALHsQAG0AAABkBQAAEAAAACx7EABtAAAAbwUAABYAAAAsexAAbQAAAHIFAAAaAAAALHsQAG0AAABzBQAADwAAACx7EABtAAAAdAUAABAAAAAsexAAbQAAAH8FAAAWAAAALHsQAG0AAACFBQAAEAAAACx7EABtAAAAjgUAABYAAAAsexAAbQAAAJIFAAAoAAAALHsQAG0AAACTBQAAEAAAACx7EABtAAAAnAUAABYAAAAsexAAbQAAAKAFAAAoAAAALHsQAG0AAAChBQAAEAAAACx7EABtAAAAqgUAABYAAAAsexAAbQAAAK4FAAAoAAAALHsQAG0AAACvBQAAEAAAACx7EABtAAAAuAUAABYAAAAsexAAbQAAALwFAAAoAAAALHsQAG0AAAC9BQAAEAAAACx7EABtAAAAxgUAABYAAAAsexAAbQAAAMkFAAAQAAAALHsQAG0AAADSBQAAFgAAACx7EABtAAAA1QUAABAAAABjb3VsZCBub3QgcGFyc2UgcGFycXVldCBtZXRhZGF0YatFEABrAAAAIQIAAC8AAACrRRAAawAAAGoCAAAvAAAAq0UQAGsAAABtAgAAIwAAAKtFEABrAAAAbwIAAC0AAACrRRAAawAAAI4CAAAdAAAAbWlzc2luZyBvZmZzZXQgaW5kZXirRRAAawAAAHYCAAAnAAAAq0UQAGsAAACBAgAAOAAAAFBBUkVQQVIxSW52YWxpZCBQYXJxdWV0IGZpbGUuIENvcnJ1cHQgZm9vdGVyUGFycXVldCBmaWxlIGhhcyBhbiBlbmNyeXB0ZWQgZm9vdGVyIGJ1dCB0aGUgZW5jcnlwdGlvbiBmZWF0dXJlIGlzIGRpc2FibGVkAKtFEABrAAAALQQAABgAAABDb3VsZCBub3QgcGFyc2UgbWV0YWRhdGE6IAAAhPsTABoAAACrRRAAawAAAEwEAAAhAAAAq0UQAGsAAABTBAAAIQAAAENvbHVtbiBvcmRlciBsZW5ndGggbWlzbWF0Y2jahxAAaAAAAOwAAAAZAAAA2ocQAGgAAAArAgAAFgAAANqHEABoAAAAxAIAABUAAABDb2x1bW4gY291bnQgbWlzbWF0Y2guIFNjaGVtYSBoYXMgIGNvbHVtbnMgd2hpbGUgUm93IEdyb3VwIGhhcyAAFPwTACIAAAA2/BMAHQAAANqHEABoAAAA7QIAABYAAABDb2x1bW4gbGVuZ3RoIG1pc21hdGNoOiAgIT0gdPwTABgAAACM/BMABAAAANqHEABoAAAAawMAABgAAADahxAAaAAAAIoDAAAJAAAA2ocQAGgAAACoAwAAFwAAAGNvbHVtbiBzdGFydCBhbmQgbGVuZ3RoIHNob3VsZCBub3QgYmUgbmVnYXRpdmUAAND8EwAuAAAA2ocQAGgAAAAbBAAACQAAAEV4cGVjdGVkIHRvIGhhdmUgY29sdW1uIG1ldGFkYXRh2ocQAGgAAAAiBgAAGQAAANqHEABoAAAAIwYAABkAAADahxAAaAAAACQGAAAZAAAA2ocQAGgAAAAlBgAAGgAAANqHEABoAAAANAYAABIAAADahxAAaAAAADUGAAASAAAA2ocQAGgAAAA5BgAAEgAAANqHEABoAAAAOgYAABIAAADahxAAaAAAAIMGAAAkAAAA2ocQAGgAAACJBgAAGwAAANqHEABoAAAAigYAACkAAADahxAAaAAAAJUGAAASAAAA0CMQAF0AAAAHAwAAIwAAANAjEABdAAAACgMAABEAAADQIxAAXQAAABEDAAAjAAAA0CMQAF0AAAAUAwAAEQAAAEJvdW5kaW5nQm94LnhtaW5Cb3VuZGluZ0JveC54bWF4Qm91bmRpbmdCb3gueW1pbkJvdW5kaW5nQm94LnltYXhhdXRvLWdlbmVyYXRlZCBjb2RlIHNob3VsZCBoYXZlIGNoZWNrZWQgZm9yIHByZXNlbmNlIG9mIHJlcXVpcmVkIGZpZWxkcwDQIxAAXQAAAKUDAAARAAAA0CMQAF0AAACmAwAAEQAAANAjEABdAAAApwMAABEAAADQIxAAXQAAAKgDAAARAAAA0CMQAF0AAAAABAAAIwAAANAjEABdAAAAAwQAABEAAABTdGF0aXN0aWNzbWF4bWlubnVsbF9jb3VudGRpc3RpbmN0X2NvdW50bWF4X3ZhbHVlbWluX3ZhbHVlaXNfbWF4X3ZhbHVlX2V4YWN0aXNfbWluX3ZhbHVlX2V4YWN0RGVjaW1hbFR5cGUuc2NhbGVEZWNpbWFsVHlwZS5wcmVjaXNpb27QIxAAXQAAAEcGAAASAAAA0CMQAF0AAABIBgAAFgAAAHJlY2VpdmVkIGVtcHR5IHVuaW9uIGZyb20gcmVtb3RlIFRpbWVVbml0cmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBUaW1lVW5pdHJldHVybiB2YWx1ZSBzaG91bGQgaGF2ZSBiZWVuIGNvbnN0cnVjdGVkVGltZXN0YW1wVHlwZS5pc19hZGp1c3RlZF90b191X3RfY1RpbWVzdGFtcFR5cGUudW5pdAAAANAjEABdAAAAYQcAACEAAADQIxAAXQAAAGIHAAARAAAAVGltZVR5cGUuaXNfYWRqdXN0ZWRfdG9fdV90X2NUaW1lVHlwZS51bml0AADQIxAAXQAAAKgHAAAhAAAA0CMQAF0AAACpBwAAEQAAAEludFR5cGUuYml0X3dpZHRoSW50VHlwZS5pc19zaWduZWQAANAjEABdAAAA8QcAABYAAADQIxAAXQAAAPIHAAAWAAAAcmVjZWl2ZWQgZW1wdHkgdW5pb24gZnJvbSByZW1vdGUgTG9naWNhbFR5cGVyZWNlaXZlZCBtdWx0aXBsZSBmaWVsZHMgZm9yIHVuaW9uIGZyb20gcmVtb3RlIExvZ2ljYWxUeXBlU2NoZW1hRWxlbWVudC5uYW1l0CMQAF0AAADKCgAAEQAAAERhdGFQYWdlSGVhZGVyLm51bV92YWx1ZXNEYXRhUGFnZUhlYWRlci5lbmNvZGluZ0RhdGFQYWdlSGVhZGVyLmRlZmluaXRpb25fbGV2ZWxfZW5jb2RpbmdEYXRhUGFnZUhlYWRlci5yZXBldGl0aW9uX2xldmVsX2VuY29kaW5n0CMQAF0AAABfCwAAFwAAANAjEABdAAAAYAsAABUAAADQIxAAXQAAAGELAAAmAAAA0CMQAF0AAABiCwAAJgAAAERhdGFQYWdlSGVhZGVybnVtX3ZhbHVlc2VuY29kaW5nZGVmaW5pdGlvbl9sZXZlbF9lbmNvZGluZ3JlcGV0aXRpb25fbGV2ZWxfZW5jb2RpbmdzdGF0aXN0aWNzSW5kZXhQYWdlSGVhZGVyRGljdGlvbmFyeVBhZ2VIZWFkZXIubnVtX3ZhbHVlc0RpY3Rpb25hcnlQYWdlSGVhZGVyLmVuY29kaW5nANAjEABdAAAA5AsAABcAAADQIxAAXQAAAOULAAAVAAAARGljdGlvbmFyeVBhZ2VIZWFkZXJpc19zb3J0ZWREYXRhUGFnZUhlYWRlclYyLm51bV92YWx1ZXNEYXRhUGFnZUhlYWRlclYyLm51bV9udWxsc0RhdGFQYWdlSGVhZGVyVjIubnVtX3Jvd3NEYXRhUGFnZUhlYWRlclYyLmVuY29kaW5nRGF0YVBhZ2VIZWFkZXJWMi5kZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aERhdGFQYWdlSGVhZGVyVjIucmVwZXRpdGlvbl9sZXZlbHNfYnl0ZV9sZW5ndGjQIxAAXQAAAHAMAAAXAAAA0CMQAF0AAABxDAAAFgAAANAjEABdAAAAcgwAABUAAADQIxAAXQAAAHMMAAAVAAAA0CMQAF0AAAB0DAAAKgAAANAjEABdAAAAdQwAACoAAABEYXRhUGFnZUhlYWRlclYybnVtX251bGxzbnVtX3Jvd3NkZWZpbml0aW9uX2xldmVsc19ieXRlX2xlbmd0aHJlcGV0aXRpb25fbGV2ZWxzX2J5dGVfbGVuZ3RoaXNfY29tcHJlc3NlZFBhZ2VIZWFkZXIudHlwZV9QYWdlSGVhZGVyLnVuY29tcHJlc3NlZF9wYWdlX3NpemVQYWdlSGVhZGVyLmNvbXByZXNzZWRfcGFnZV9zaXpl0CMQAF0AAADBDgAAEgAAANAjEABdAAAAwg4AACMAAADQIxAAXQAAAMMOAAAhAAAAUGFnZUhlYWRlcnR5cGV1bmNvbXByZXNzZWRfcGFnZV9zaXplY29tcHJlc3NlZF9wYWdlX3NpemVjcmNkYXRhX3BhZ2VfaGVhZGVyaW5kZXhfcGFnZV9oZWFkZXJkaWN0aW9uYXJ5X3BhZ2VfaGVhZGVyZGF0YV9wYWdlX2hlYWRlcl92MktleVZhbHVlLmtleQAAANAjEABdAAAAJw8AABAAAABTb3J0aW5nQ29sdW1uLmNvbHVtbl9pZHhTb3J0aW5nQ29sdW1uLmRlc2NlbmRpbmdTb3J0aW5nQ29sdW1uLm51bGxzX2ZpcnN0AAAA0CMQAF0AAAB6DwAAFwAAANAjEABdAAAAew8AABcAAADQIxAAXQAAAHwPAAAYAAAAUGFnZUVuY29kaW5nU3RhdHMucGFnZV90eXBlUGFnZUVuY29kaW5nU3RhdHMuZW5jb2RpbmdQYWdlRW5jb2RpbmdTdGF0cy5jb3VudNAjEABdAAAAzg8AABYAAADQIxAAXQAAAM8PAAAVAAAA0CMQAF0AAADQDwAAEgAAANAjEABdAAAAVBAAACgAAADQIxAAXQAAAFcQAAARAAAA0CMQAF0AAABeEAAAJgAAANAjEABdAAAAYRAAABEAAADQIxAAXQAAAHgQAAAoAAAA0CMQAF0AAAB7EAAAEQAAANAjEABdAAAAkhAAADEAAADQIxAAXQAAAJUQAAARAAAAQ29sdW1uTWV0YURhdGEudHlwZV9Db2x1bW5NZXRhRGF0YS5lbmNvZGluZ3NDb2x1bW5NZXRhRGF0YS5wYXRoX2luX3NjaGVtYUNvbHVtbk1ldGFEYXRhLmNvZGVjQ29sdW1uTWV0YURhdGEubnVtX3ZhbHVlc0NvbHVtbk1ldGFEYXRhLnRvdGFsX3VuY29tcHJlc3NlZF9zaXplQ29sdW1uTWV0YURhdGEudG90YWxfY29tcHJlc3NlZF9zaXplQ29sdW1uTWV0YURhdGEuZGF0YV9wYWdlX29mZnNldADQIxAAXQAAALoQAAASAAAA0CMQAF0AAAC7EAAAFgAAANAjEABdAAAAvBAAABsAAADQIxAAXQAAAL0QAAASAAAA0CMQAF0AAAC+EAAAFwAAANAjEABdAAAAvxAAACQAAADQIxAAXQAAAMAQAAAiAAAA0CMQAF0AAADCEAAAHQAAANAjEABdAAAAcxEAACYAAADQIxAAXQAAAHYRAAARAAAARW5jcnlwdGlvbldpdGhDb2x1bW5LZXkucGF0aF9pbl9zY2hlbWEAANAjEABdAAAAiBEAABsAAAByZWNlaXZlZCBlbXB0eSB1bmlvbiBmcm9tIHJlbW90ZSBDb2x1bW5DcnlwdG9NZXRhRGF0YXJlY2VpdmVkIG11bHRpcGxlIGZpZWxkcyBmb3IgdW5pb24gZnJvbSByZW1vdGUgQ29sdW1uQ3J5cHRvTWV0YURhdGFDb2x1bW5DaHVuay5maWxlX29mZnNldADQIxAAXQAAAG8SAAAYAAAA0CMQAF0AAADpEgAAKwAAANAjEABdAAAA7BIAABEAAADQIxAAXQAAAPsSAAAtAAAA0CMQAF0AAAD+EgAAEQAAAFJvd0dyb3VwLmNvbHVtbnNSb3dHcm91cC50b3RhbF9ieXRlX3NpemVSb3dHcm91cC5udW1fcm93cwAAANAjEABdAAAAGhMAABQAAADQIxAAXQAAABsTAAAcAAAA0CMQAF0AAAAcEwAAFQAAAHJlY2VpdmVkIGVtcHR5IHVuaW9uIGZyb20gcmVtb3RlIENvbHVtbk9yZGVycmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBDb2x1bW5PcmRlclBhZ2VMb2NhdGlvbi5vZmZzZXRQYWdlTG9jYXRpb24uY29tcHJlc3NlZF9wYWdlX3NpemVQYWdlTG9jYXRpb24uZmlyc3Rfcm93X2luZGV4AADQIxAAXQAAAP8TAAATAAAA0CMQAF0AAAAAFAAAIQAAANAjEABdAAAAARQAABwAAADQIxAAXQAAAEIUAAAsAAAA0CMQAF0AAABFFAAAEQAAANAjEABdAAAATBQAACMAAADQIxAAXQAAAE8UAAARAAAAT2Zmc2V0SW5kZXgucGFnZV9sb2NhdGlvbnMAANAjEABdAAAAXRQAABsAAADQIxAAXQAAANgUAAAkAAAA0CMQAF0AAADbFAAAEQAAANAjEABdAAAA4hQAACcAAADQIxAAXQAAAOUUAAARAAAA0CMQAF0AAADsFAAAJwAAANAjEABdAAAA7xQAABEAAADQIxAAXQAAAPoUAAAjAAAA0CMQAF0AAAD9FAAAEQAAANAjEABdAAAABBUAACMAAADQIxAAXQAAAAcVAAARAAAA0CMQAF0AAAAOFQAAIwAAANAjEABdAAAAERUAABEAAABDb2x1bW5JbmRleC5udWxsX3BhZ2VzQ29sdW1uSW5kZXgubWluX3ZhbHVlc0NvbHVtbkluZGV4Lm1heF92YWx1ZXNDb2x1bW5JbmRleC5ib3VuZGFyeV9vcmRlctAjEABdAAAAIhUAABcAAADQIxAAXQAAACMVAAAXAAAA0CMQAF0AAAAkFQAAFwAAANAjEABdAAAAJRUAABsAAAByZWNlaXZlZCBlbXB0eSB1bmlvbiBmcm9tIHJlbW90ZSBFbmNyeXB0aW9uQWxnb3JpdGhtcmVjZWl2ZWQgbXVsdGlwbGUgZmllbGRzIGZvciB1bmlvbiBmcm9tIHJlbW90ZSBFbmNyeXB0aW9uQWxnb3JpdGhtAADQIxAAXQAAAMcWAAAtAAAA0CMQAF0AAADKFgAAEQAAANAjEABdAAAA1RYAACgAAADQIxAAXQAAANgWAAARAAAA0CMQAF0AAADfFgAAKAAAANAjEABdAAAA4hYAABEAAADQIxAAXQAAAO0WAAArAAAA0CMQAF0AAADwFgAAEQAAAEZpbGVNZXRhRGF0YS52ZXJzaW9uRmlsZU1ldGFEYXRhLnNjaGVtYUZpbGVNZXRhRGF0YS5udW1fcm93c0ZpbGVNZXRhRGF0YS5yb3dfZ3JvdXBzANAjEABdAAAACRcAABQAAADQIxAAXQAAAAoXAAATAAAA0CMQAF0AAAALFwAAFQAAANAjEABdAAAADBcAABcAAAAAAAAABAAAAAQAAACFAgAATUlMTElTAAAAAAAABAAAAAQAAACGAgAATUlDUk9TAAAAAAAABAAAAAQAAACHAgAATkFOT1MAAADahxAAaAAAAF0DAAARAAAATmFub1NlY29uZHNNaWNyb1NlY29uZHNNaWxsaVNlY29uZHMA3I4QAGQAAAAJAAAACAAAANkEAAA4AAAABAAAANoEAADZBAAAOAAAAAQAAADbBAAA7FMQAGoAAACcAAAAEgAAAOxTEABqAAAApQAAAA0AAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAEJFEABoAAAAQAEAAEMAAABJbnZhbGlkIERhdGFCRRAAaAAAAAgBAABBAAAAQkUQAGgAAAAKAQAAOAAAAEJFEABoAAAACgEAACAAAAC+nCqRkTY0YMVIQBcRDps0e7I8HJu1h/yBm9JjW7WZ7uP/1pgFyn5aa9XhHolAKiRtaWQgPiBsZW4AAABsEBQACQAAAGZhaWxlZCB0byBmaWxsIHdob2xlIGJ1ZmZlcgCAEBQAGwAAACUAAAACAAAAnBAUAO8nEABrAAAA4wEAAA4AAABjYW5ub3QgcmVjdXJzaXZlbHkgYWNxdWlyZSBtdXRleMAQFAAgAAAAtC8QAHwAAAATAAAACQAAACgpAADXMhAAeAAAAOsHAAAJAAAAZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheckgGuicZTtMR0lZw82Iv4xV8+nEOaizMm8aTlBX3KIqAAAAAAAAAAABAAAA3AQAAN0EAAAIAAAABAAAAN4EAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAN8EAAAIAAAABAAAAOAEAEG4o9AAC4UGAQAAAOEEAABSZWFjaGVkIEVPRk91dHB1dFRvb1NtYWxsTGF5b3V0RXJyb3IAAAAABAAAAAQAAADiBAAAAAAAAAQAAAAEAAAAMQAAAGV4cGVjdGVkYWN0dWFsTGl0ZXJhbE91dE9mQm91bmRzRXhwZWN0ZWRBbm90aGVyQnl0ZU9mZnNldE91dE9mQm91bmRz7FMQAGoAAAC5AQAABQAAAOxTEABqAAAAvQEAAAUAAADsUxAAagAAAMEBAAAFAAAA7FMQAGoAAADUAQAAEgAAAOxTEABqAAAA2gEAABIAAADsUxAAagAAAHYCAAAiAAAA7FMQAGoAAAAvBwAAHwAAAOxTEABqAAAAMgcAAA0AAADsUxAAagAAABUHAAAkAAAA7FMQAGoAAAAVBwAAGQAAAOxTEABqAAAAEggAABYAAADsUxAAagAAAJIIAAAcAAAA7FMQAGoAAACbCAAALgAAAOxTEABqAAAAuQgAABoAAADsUxAAagAAALoIAAAZAAAA7FMQAGoAAACnCAAAJwAAAOxTEABqAAAA0gkAABIAAADsUxAAagAAANgJAAASAAAA7FMQAGoAAADfCQAADgAAAOxTEABqAAAA5gkAABIAAADsUxAAagAAAOwJAAASAAAA7FMQAGoAAAD1CQAAEgAAAOxTEABqAAAA+wkAABIAAADsUxAAagAAAAIKAAAOAAAA7FMQAGoAAADvAAAACQAAAOxTEABqAAAA9AAAAAkAAADsUxAAagAAAPkAAAAJAAAA7FMQAGoAAAAMAQAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGluc2VydHMubGVuKCkgPD0gbWJfbGVuAAAA7FMQAGoAAAAUAQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvcHlfbGVuID49IDQA7FMQAGoAAAA8AQAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IGNvcHlfbGVuIDwgMjUA7FMQAGoAAAA9AQAADQAAAAAAAAAKCgsLCgoKCgoJCQgHBwgHBwYGBQUAQdWp0AALjAQQAAAAJAAAAFQAAACMAAAArAAAANAAAAD4AAAAJAEAAFQBAABuAQAAigEAAJkBAAChAQCAqQEAgLsBAADFAQAAzwEAQNQBAMDZAQCg3AEA7FMQAGoAAABEAQAALgAAAOxTEABqAAAAZAEAABEAAADsUxAAagAAAFgBAAA0AAAA7FMQAGoAAABVAQAAEQAAAOxTEABqAAAAhQEAACIAAADsUxAAagAAAJMBAAAiAAAA7FMQAGoAAAAnAQAAIgAAAOxTEABqAAAALQoAABYAAADsUxAAagAAAEMKAAAgAAAA7FMQAGoAAABKCgAAMwAAAOxTEABqAAAASAkAABYAAADsUxAAagAAAGkHAAAiAAAA7FMQAGoAAABqBwAAIgAAAOxTEABqAAAAegcAABEAAADsUxAAagAAAHsHAAARAAAA7FMQAGoAAADKBwAAIgAAAOxTEABqAAAAywcAACIAAADsUxAAagAAANkHAAAjAAAA7FMQAGoAAADeBwAAEQAAAOxTEABqAAAA3wcAABEAAADsUxAAagAAAFYHAAAWAAAA7FMQAGoAAABaBwAAMgAAAOxTEABqAAAAWwcAADAAAADsUxAAagAAAIMAAAAkAAAA7FMQAGoAAADwCgAADAAAAOxTEABqAAAA8AoAADYAAADsUxAAagAAAPMKAAAMAAAA7FMQAGoAAADzCgAANgBB9K3QAAvhLOxTEABqAAAAvAMAABwAAADsUxAAagAAAOADAAAVAAAA7FMQAGoAAADhAwAAFQAAAOxTEABqAAAAOQQAAB0AAADsUxAAagAAAD0EAAAiAAAA7FMQAGoAAABGBAAAFQAAAOxTEABqAAAATgQAABkAAADsUxAAagAAAGIEAAAZAAAA7FMQAGoAAABZBAAAHQAAAOxTEABqAAAAKgQAABQAAADsUxAAagAAABcEAAAUAAAA7FMQAGoAAAAXBAAAMQAAAOxTEABqAAAA6AMAACAAAADsUxAAagAAAOkDAAAkAAAA7FMQAGoAAADxAwAAIAAAAOxTEABqAAAA8gMAACQAAADsUxAAagAAAPoDAAAtAAAA7FMQAGoAAAD8AwAALwAAAOxTEABqAAAAAQQAAB0AAADsUxAAagAAAM0DAAAYAAAA7FMQAGoAAADSAwAAHQAAAOxTEABqAAAAzwMAAB0AAADsUxAAagAAALgDAAAJAAAA7FMQAGoAAAC5AwAACQAAAOxTEABqAAAArAMAAAwAAAAAAQIDAAAAAAAAAQEBAQEBAAAAAP8B/gL9A/8B/gL9A3BHEABvAAAAwAIAACQAAABwRxAAbwAAAN0CAAAkAAAAcEcQAG8AAADjAgAAIAAAAHBHEABvAAAA5AIAACAAAABwRxAAbwAAAPACAAAdAAAAcEcQAG8AAAACAwAAKAAAAHBHEABvAAAAJAMAADUAAABwRxAAbwAAAAkCAAAjAAAAcEcQAG8AAABbAgAABQAAAHBHEABvAAAAkwQAAAUAAABwRxAAbwAAAKMEAAARAAAAcEcQAG8AAACkBAAAGQAAAHBHEABvAAAArgQAACIAAABwRxAAbwAAAMYEAABAAAAAcEcQAG8AAABPAgAABQAAAHBHEABvAAAAVwEAAAwAAABwRxAAbwAAAFcBAAAjAAAAcEcQAG8AAABYAQAAEAAAAHBHEABvAAAAWAEAADcAAABwRxAAbwAAAF4BAAAnAAAAcEcQAG8AAABuAQAAFQAAAHBHEABvAAAAegEAABYAAABhc3NlcnRpb24gZmFpbGVkOiBwYXJhbXMudXNlX2RpY3Rpb25hcnkAcEcQAG8AAACAAQAADQAAAHBHEABvAAAAigEAAC8AAABwRxAAbwAAAD4AAAAJAAAAcEcQAG8AAAC3AQAADwAAAHBHEABvAAAAPwIAABMAAABwRxAAbwAAAEYDAAAMAAAAcEcQAG8AAABLAwAAEwAAAHBHEABvAAAATQMAAAkAAABwRxAAbwAAAGECAAAJAAAAcEcQAG8AAABVAgAACQAAAHBHEABvAAAAwQEAAAkAAABwRxAAbwAAAMEBAAArAAAAcEcQAG8AAAB1BAAADQAAAHBHEABvAAAAeAQAACIAAABwRxAAbwAAAHkEAAARAAAAcEcQAG8AAABDBAAAKAAAAHBHEABvAAAASQQAACUAAABwRxAAbwAAAE4EAAAlAAAAcEcQAG8AAABUBAAAGwAAAHBHEABvAAAA7QAAAB8AAABwRxAAbwAAAPkAAAANAAAAcEcQAG8AAADxAAAALQAAAHBHEABvAAAAeQMAAAUAAABwRxAAbwAAAJUDAAAiAAAAcEcQAG8AAABdBQAAGQAAAHBHEABvAAAAEAUAAB4AAABwRxAAbwAAABMFAAAyAAAAcEcQAG8AAAAtBQAAKQAAAHBHEABvAAAANQUAAA0AAABwRxAAbwAAADgFAAAjAAAAcEcQAG8AAAA8BQAAFQAAAHBHEABvAAAASQUAABoAAAAxcxAAXwAAAOcCAAAfAAAAMXMQAF8AAADoAgAAJQAAADFzEABfAAAA6AIAAA4AAAAxcxAAXwAAAO0CAAAJAAAAMXMQAF8AAADxAgAACQAAADFzEABfAAAAAQMAACcAAAAxcxAAXwAAAAEDAABVAAAAMXMQAF8AAAABAwAAPgAAADFzEABfAAAABgMAACMAAAAxcxAAXwAAAAcDAAApAAAAMXMQAF8AAAAHAwAAEgAAADFzEABfAAAA/AIAACMAAAAxcxAAXwAAAPwCAABPAAAAMXMQAF8AAAD8AgAAOAAAADFzEABfAAAACgMAABIAAAAxcxAAXwAAAA4DAAAFAAAAMXMQAF8AAAAPAwAAEgAAADFzEABfAAAAEwMAAAUAAAAxcxAAXwAAANoCAAAfAAAAMXMQAF8AAADaAgAATQAAADFzEABfAAAA2gIAADYAAAAxcxAAXwAAAJEGAAAWAAAAMXMQAF8AAADAAgAAHQAAADFzEABfAAAAwAIAAEkAAAAxcxAAXwAAAMACAAAlAAAAMXMQAF8AAADGAgAABQAAADFzEABfAAAAxwIAAAUAAAAxcxAAXwAAAMkCAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogIXBhcmFtcy5jYXRhYmxlAAAAMXMQAF8AAACaBwAACQAAADFzEABfAAAAwwcAAAsAAAAxcxAAXwAAALIIAAANAAAAMXMQAF8AAACzCAAADQAAADFzEABfAAAAvQgAACQAAAAxcxAAXwAAAL4IAAAZAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5sYXN0X3Byb2Nlc3NlZF9wb3NfIDwgMiB8fCBzZWxmLmN1c3RvbV9kaWN0aW9uYXJ5MXMQAF8AAADLCAAADQAAADFzEABfAAAAzwgAAD4AAAAxcxAAXwAAAN4IAAAkAAAAMXMQAF8AAADfCAAAGQAAADFzEABfAAAA4ggAACMAAAAxcxAAXwAAAOUIAAAnAAAAMXMQAF8AAAAJCQAAPgAAADFzEABfAAAAFAkAACIAAAAxcxAAXwAAACMJAAAiAAAAMXMQAF8AAAAuCQAAJAAAADFzEABfAAAALwkAABkAAAAxcxAAXwAAAEIJAAAtAAAAMXMQAF8AAABDCQAAQgAAADFzEABfAAAATwkAADYAAAAxcxAAXwAAAGYJAAA2AAAAMXMQAF8AAABtCQAALAAAADFzEABfAAAAigkAAA0AAAAxcxAAXwAAAJsJAAA6AAAAMXMQAF8AAACyCQAAIAAAADFzEABfAAAAswkAABUAAAAxcxAAXwAAALkJAAA5AAAAMXMQAF8AAAC8CQAAFQAAADFzEABfAAAAwAkAABUAAAAxcxAAXwAAAFsLAABPAAAAMXMQAF8AAABGCgAAJgAAADFzEABfAAAARwoAACcAAAAxcxAAXwAAAEYKAAA6AAAAMXMQAF8AAAA2CgAAIwAAADFzEABfAAAAOAoAACsAAAAxcxAAXwAAADcKAAAaAAAAMXMQAF8AAABgAQAAIQAAADFzEABfAAAAcgEAABgAAAAxcxAAXwAAAHQBAAAcAAAAMXMQAF8AAAC2CgAAMgAAADFzEABfAAAAvAoAABEAAAAxcxAAXwAAAL0KAAARAAAAMXMQAF8AAADDCgAAKQAAADFzEABfAAAA0goAACkAAAAxcxAAXwAAAOwKAAAkAAAAMXMQAF8AAADtCgAAGQAAADFzEABfAAAA0QkAAAkAAAAxcxAAXwAAANIJAAAJAAAAMXMQAF8AAAAqAwAAPwAAADFzEABfAAAA/gUAADIAAAAxcxAAXwAAAAMGAAAJAAAAMXMQAF8AAAAFBgAADQAAADFzEABfAAAACAYAAA0AAAAxcxAAXwAAAB8GAAAeAAAAMXMQAF8AAAAgBgAANQAAADFzEABfAAAAIAYAABIAAACPFRAAYQAAAF8AAAANAAAAjxUQAGEAAABqAAAAHwAAAI8VEABhAAAAawAAAB8AAACPFRAAYQAAAGwAAAAfAAAAjxUQAGEAAAB2AAAAHAAAAIR2EABiAAAAnQAAABYAAACEdhAAYgAAAIcAAAANAAAAhHYQAGIAAACIAAAADQAAAIR2EABiAAAAfQAAAA0AAACEdhAAYgAAAH8AAAANAAAAhHYQAGIAAACjAAAADQAAAIR2EABiAAAApQAAAA0AAADndhAAWwAAAAcBAAAYAAAAZ3ppcCBoZWFkZXIgZmllbGQgdG9vIGxvbmcAAOd2EABbAAAAogAAADIAAADndhAAWwAAAKoAAAA8AAAAzEIQAF4AAAAoAAAAHQAAAMxCEABeAAAALgAAABYAAADMQhAAXgAAAGIAAAAVAAAAVSUQAGgAAABnAQAAOgAAAM51EABqAAAAvQEAAB0AAABFWxAAXAAAACcAAAANAAAARVsQAFwAAABtAAAAHAAAAEZuEABnAAAAZAAAABQAAABGbhAAZwAAAGUAAAAOAAAARm4QAGcAAABnAAAADgAAAEZuEABnAAAAQwAAABQAAABGbhAAZwAAAEQAAAAOAAAARm4QAGcAAABGAAAADgAAAFUlEABoAAAAvwAAADsAAABVJRAAaAAAABUBAAA5AAAAVSUQAGgAAAApAQAAIgAAAFUlEABoAAAAHAEAADEAAABVJRAAaAAAAB0BAAApAAAAVSUQAGgAAAAhAQAAIgAAAFUlEABoAAAAAgEAACIAAABVJRAAaAAAAFIBAAAhAAAAVSUQAGgAAACHAAAAKAAAAFUlEABoAAAAnwAAABIAAABVJRAAaAAAAKAAAAASAAAAVSUQAGgAAAC9AQAACwAAAFUlEABoAAAAvwEAAAsAAADjBAAANAAAAAQAAADkBAAA3ZcQAGAAAABUAAAAHwAAAN2XEABgAAAAfQAAABsAAADEOxAAcQAAACYAAAARAAAAZW5jb3VudGVyZWQgbm9uIFVURi04IGRhdGEAAMQ7EABxAAAASwAAABUAAADEOxAAcQAAAFAAAAAWAAAAxDsQAHEAAABoAAAAIAAAAMQ7EABxAAAAbAAAACcAAABkaWN0aW9uYXJ5IGtleSBiZXlvbmQgYm91bmRzIG9mIGRpY3Rpb25hcnk6IDAuLgAgJRQALwAAAMQ7EABxAAAAeQAAADEAAADEOxAAcQAAAJUAAAAJAAAAxDsQAHEAAACXAAAADgAAAMQ7EABxAAAAuQAAAB4AAABhc3NlcnRpb24gZmFpbGVkOiBsZXZlbF9wb3MgPj0gdmFsdWVfcG9zxDsQAHEAAACkAAAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxldmVsX3BvcyA8IGxhc3RfcG9zAADEOxAAcQAAAKUAAAANAAAAxDsQAHEAAACnAAAAJQAAAMQ7EABxAAAAqwAAACIAAADEOxAAcQAAALMAAAAUAAAAAQAAAG1heCByZXBldGl0aW9uIGxldmVsIG11c3QgYmUgMCB0byBvbmx5IGNvbXB1dGUgbnVsbCBiaXRtYXNrADwmFAA7AAAAjykQAHwAAABBAAAAEQAAAG1heCBkZWZpbml0aW9uIGxldmVsIG11c3QgYmUgMSB0byBvbmx5IGNvbXB1dGUgbnVsbCBiaXRtYXNrAJAmFAA7AAAAjykQAHwAAAA7AAAAEQAAAI8pEAB8AAAAnQAAABEAAACPKRAAfAAAAKMAAAAhAAAAjykQAHwAAACqAAAAEQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGluY29uc2lzdGVudCBudWxsIG1hc2sUJxQAQAAAAI8pEAB8AAAAsgAAABIAAAB1bmV4cGVjdGVkIGVuZCBvZiBmaWxlIHdoaWxzdCBkZWNvZGluZyBkZWZpbml0aW9uIGxldmVscyBybGUgdmFsdWV0b28gbWFueSBieXRlcyBmb3IgVkxRdW5leHBlY3RlZCBlbmQgb2YgZmlsZSB3aGlsc3QgZGVjb2RpbmcgZGVmaW5pdGlvbiBsZXZlbHMgcmxlIGhlYWRlcmludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGludmFsaWQgbGV2ZWwgZW5jb2Rpbmc6IAAAAAcoFABCAAAAjykQAHwAAAAZAQAAEgAAAGVuY291bnRlcmVkIG5vbiBVVEYtOCBkYXRhOiBkKBQAHAAAAGZpcnN0IHJlcGV0aXRpb24gbGV2ZWwgb2YgYmF0Y2ggbXVzdCBiZSAwAAAAPAcQAHQAAACAAAAAMQAAADwHEAB0AAAAxQAAAD4AAAA8BxAAdAAAAMUAAAAWAAAAPAcQAHQAAADfAAAADQAAANkEAAA4AAAABAAAAOUEAADmBAAA5wQAAOgEAADpBAAA6gQAAOsEAADsBAAA7QQAAO4EAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABGYWlsZWQgdG8gcmVjb25zdHJ1Y3QgbGlzdCBmcm9tIGxldmVsIGRhdGFvZmZzZXQgb2YgIHdvdWxkIG92ZXJmbG93IGxpc3QgYXJyYXkAAHYpFAAKAAAAgCkUABoAAADZBAAAOAAAAAQAAAD4BAAA+QQAAPoEAAD7BAAA6QQAAPwEAAD9BAAA/gQAAO0EAADuBAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAaXRlbV9yZWFkZXIgZGVmIGxldmVscyBhcmUgTm9uZS5pdGVtX3JlYWRlciByZXAgbGV2ZWxzIGFyZSBOb25lLjwHEAB0AAAApgAAAEoAAAA8BxAAdAAAAKYAAAAiAAAARW5jb3VudGVyZWQgcmVwZXRpdGlvbiBsZXZlbCB0b28gbGFyZ2UgZm9yIGRlZmluaXRpb24gbGV2ZWxTdHJ1Y3RBcnJheVJlYWRlciBvdXQgb2Ygc3luYyBpbiByZWFkX3JlY29yZHMsIGV4cGVjdGVkICByZWFkLCBnb3QgAACfKhQAOAAAANcqFAALAAAATm90IGFsbCBjaGlsZHJlbiBhcnJheSBsZW5ndGggYXJlIHRoZSBzYW1lIWNoaWxkIHdpdGggbnVsbGFibGUgcGFyZW50cyBtdXN0IGhhdmUgZGVmaW5pdGlvbiBsZXZlbAAAAB8IEAB2AAAAjwAAABIAAAAfCBAAdgAAAJcAAAAVAAAA4wQAADQAAAAEAAAAhwEAAP8EAACJAQAAAAUAAAEFAACMAQAAAgUAAAMFAACPAQAA7gQAAJEBAACSAQAAkwEAAJQBAACVAQAAlgEAAJcBAACYAQAAmQEAAEZhaWxlZCB0byBkZWNvZGUgbGV2ZWwgZGF0YSBmb3Igc3RydWN0IGFycmF5U3RydWN0IGFycmF5IHJlYWRlciBzaG91bGQgaGF2ZSBhdCBsZWFzdCBvbmUgY2hpbGQhU3RydWN0QXJyYXlSZWFkZXIgb3V0IG9mIHN5bmMsIGV4cGVjdGVkICBza2lwcGVkLCBnb3QgAAAALywUACgAAABXLBQADgAAAExaNFJhd0NvZGVjIHVuc3VwcG9ydGVkIHdpdGhvdXQgdW5jb21wcmVzc19zaXplAOpMEABiAAAAZQIAABgAAADqTBAAYgAAAGYCAABOAAAATFo0UmF3Q29kZWMgdW5jb21wcmVzc19zaXplIGlzIG5vdCB0aGUgZXhwZWN0ZWQgb25lAAAAAAAMAAAABAAAAAQFAAAAAAAADAAAAAQAAAAFBQAABAUAAPwsFAAGBQAABwUAAAgFAAAGBQAACQUAAOpMEABiAAAAdgIAABgAAADqTBAAYgAAAHcCAABMAEHg2tAACwYBAAAACgUAQfDa0AALkg4BAAAACwUAAAoFAABYLRQADAUAAA0FAAAOBQAADAUAAA8FAADqTBAAYgAAALgCAAApAAAA6kwQAGIAAAC7AgAAKQAAAOpMEABiAAAAygIAADEAAABOb3QgYWxsIGlucHV0IGFyZSBjb25zdW1lZAAA6kwQAGIAAADUAgAAJQAAAFVuZXhwZWN0ZWQgZGVjb21wcmVzc2VkIHNpemVOb3QgZW5vdWdoIGJ5dGVzIHRvIGhvbGQgYWR2ZXJ0aXNlZCBvdXRwdXROb3QgZW5vdWdoIGJ5dGVzIGZvciBIYWRvb3AgZnJhbWVMWjRIYWRvb3BDb2RlYyB1bnN1cHBvcnRlZCB3aXRob3V0IHVuY29tcHJlc3Nfc2l6ZQAAAOpMEABiAAAA8AIAABgAAADqTBAAYgAAAPECAABDAAAATFo0SGFkb29wQ29kZWMgdW5jb21wcmVzc19zaXplIGlzIG5vdCB0aGUgZXhwZWN0ZWQgb25lAADqTBAAYgAAAA8DAAAYAAAA6kwQAGIAAAAWAwAALQAAAOpMEABiAAAAGgMAABcAAADqTBAAYgAAABsDAAAXAAAAc3RyaW5nIHZpZXcgYXJyYXkAAAA6GRAAXwAAAG4DAAAhAAAAZml4ZWQgc2l6ZSBsaXN0IGFycmF5AAAAOhkQAF8AAACyAwAADgAAAG1hcCBhcnJheQAAADoZEABfAAAAugMAABsAAABsaXN0IGFycmF5AAA6GRAAXwAAAJgDAAAcAAAAWpYQAGIAAAAyAAAAFQAAAGZhaWxlZCB0byB3cml0ZSB3aG9sZSBidWZmZXK4LxQAHAAAABcAAAACAAAA1C8UAK5+EABpAAAAMQcAACQAAABuERAAawAAAFgAAAAOAAAAHprAvv5ieL98GMLX7yHypwAAAAAEAAAABAAAABEFAAAAAAAABAAAAAQAAABHAgAAPmcQAH8AAADGAAAAJwAAAD5nEAB/AAAAFgIAAC8AAAA+ZxAAfwAAAKEAAAAkAAAAEgUAAAwAAAAEAAAAKQAAABIFAAAMAAAABAAAACoAAAApAAAAaDAUABMFAAAUBQAALQAAABUFAAAWBQAATm9uZQAAAAAEAAAABAAAACoCAABTb21lAAAAAAQAAAAEAAAAFwUAAGxyEABnAAAAZwAAADAAAABschAAZwAAAGgAAABGAAAAbHIQAGcAAABuAAAAFQAAAGxyEABnAAAATwAAACgAAABschAAZwAAAF4AAAANAAAAV291bGRCbG9jawAAznUQAGoAAAC9AQAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYucG9zIDw9IHNlbGYuZHN0LmNhcGFjaXR5KCkAAABdlBAAWwAAALUGAAAJAAAAR2l2ZW4gcG9zaXRpb24gb3V0c2lkZSBvZiB0aGUgYnVmZmVyIGJvdW5kcy5dlBAAWwAAAMkGAAANAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5kYXRhLmlzX3NvbWUoKQAAAB5qEABgAAAA3gAAAAkAAAC/fRAAbQAAAEgEAAAiAAAASW52YWxpZCBjb2x1bW4gaW5kZXggLCBjb2x1bW4gd2FzIG5vdCBmZXRjaGVkAAAAADIUABUAAAAVMhQAGAAAABgFAABIAAAACAAAABkFAAAaBQAAGwUAABwFAAAdBQAAHgUAAB8FAAAgBQAAIQUAABgAAAAIAAAAIgUAABoFAAAjBQAAJAUAAL99EABtAAAAUQQAACIAAAC/fRAAbQAAAFEEAAA6AAAASW52YWxpZCBvZmZzZXQgaW4gc3BhcnNlIGNvbHVtbiBjaHVuayBkYXRhOiCoMhQALAAAAKM9EABsAAAA6QAAADYAAACrRRAAawAAADACAAArAAAAQk9PTEVBTklOVDMySU5UNjRJTlQ5NkZMT0FURE9VQkxFQllURV9BUlJBWUZJWEVEX0xFTl9CWVRFX0FSUkFZTk9ORVVURjhNQVBNQVBfS0VZX1ZBTFVFTElTVEVOVU1ERUNJTUFMREFURVRJTUVfTUlMTElTVElNRV9NSUNST1NUSU1FU1RBTVBfTUlMTElTVElNRVNUQU1QX01JQ1JPU1VJTlRfOFVJTlRfMTZVSU5UXzMyVUlOVF82NElOVF84SU5UXzE2SU5UXzMySU5UXzY0SlNPTkJTT05JTlRFUlZBTAAAEwwQAH4AAADUAAAAQAAAABMMEAB+AAAA2gAAADUAAAATDBAAfgAAANsAAAA1AAAAEwwQAH4AAADmAAAAOAAAACUFAAAMCAAABAAAACYFAAAnBQAAAAAAAAQAAAAEAAAAKAUAACkFAAAAAAAABAAAAAQAAAAqBQAAKwUAAAAAAAABAAAAAQAAACwFAAAtBQAAAAAAAAQAAAAEAAAALgUAAC8FAEGM6dAAC/0IAQAAADAFAAAxBQAAVGhlIGNvZGVjIHR5cGUgIGlzIG5vdCBzdXBwb3J0ZWQgeWV0mDQUAA8AAACnNBQAFQAAAAAAAAAEAAAABAAAAEkCAABHemlwTGV2ZWxCcm90bGlMZXZlbAAAAAAEAAAABAAAAG0DAABac3RkTGV2ZWwAAADugRAAbQAAAF4CAABBAAAAMgUAACQAAAAEAAAAMwUAAAAAAAABAAAAAQAAADQFAAAAAAAABAAAAAQAAAA1BQAAUHJpbWl0aXZlVHlwZWJhc2ljX2luZm9waHlzaWNhbF90eXBldHlwZV9sZW5ndGhzY2FsZXByZWNpc2lvbgAAAAAAAAAEAAAABAAAADYFAABHcm91cFR5cGVmaWVsZHMAEgUAAAwAAAAEAAAANwUAAAAAAAABAAAAAQAAADgFAAAAAAAAAQAAAAEAAAA5BQAAAAAAAAwAAAAEAAAAOgUAAAAAAAAEAAAABAAAADsFAABCYXNpY1R5cGVJbmZvbmFtZXJlcGV0aXRpb25jb252ZXJ0ZWRfdHlwZWxvZ2ljYWxfdHlwZWlkAAAAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAcAAAAFAAAABQAAAAUAAAAFAAAABgAAAAoAAAAUAAAA/DIUAAMzFAAIMxQADTMUABIzFAAXMxQAHTMUACczFAAEAAAABAAAAAMAAAANAAAABAAAAAQAAAAHAAAABAAAAAsAAAALAAAAEAAAABAAAAAGAAAABwAAAAcAAAAHAAAABQAAAAYAAAAGAAAABgAAAAQAAAAEAAAACAAAADszFAA/MxQAQzMUAEYzFABTMxQAVzMUAFszFABiMxQAZjMUAHEzFAB8MxQAjDMUAJwzFACiMxQAqTMUALAzFAC3MxQAvDMUAMIzFADIMxQAzjMUANIzFADWMxQAHprAvv5ieL98GMLX7yHypzwFAAAMAAAABAAAACkAAAA8BQAADAAAAAQAAAAqAAAAKQAAAGA3FAA9BQAAPgUAAC0AAAA9BQAAPwUAAM51EABqAAAAvQEAAB0AAAAAAAAACAAAAAQAAABABQAAAAAAAAQAAAAEAAAAQQUAAAAAAAAEAAAABAAAAEIFAABVdGY4RXJyb3J2YWxpZF91cF90b2Vycm9yX2xlbk5vbmUAAAAAAAAABAAAAAQAAABDBQAAU29tZXpzdGQgcmV0dXJuZWQgbnVsbCBwb2ludGVyIHdoZW4gY3JlYXRpbmcgbmV3IGNvbnRleHRdlBAAWwAAAPMAAAAOAAAAYmFkIGVycm9yIG1lc3NhZ2UgZnJvbSB6c3RkAF2UEABbAAAAOgMAAAoAAABdlBAAWwAAAGcDAAAOAAAAR2l2ZW4gcG9zaXRpb24gb3V0c2lkZSBvZiB0aGUgYnVmZmVyIGJvdW5kcy5dlBAAWwAAABkHAAANAAAAyhkQAIEAAAA4AAAAGwAAAFVuc3VwcG9ydGVkIHFzb3J0IGl0ZW0gc2l6ZQDEUhAAawAAABUAAAASAEGU8tAAC5IDazgHAA2yBwCc8gcAcGQIAGCuCgCwcQsAMKoMAAAAAAABAAAAAwAAAAcAAAAPAAAAHwAAAD8AAAB/AAAA/wAAAP8BAAD/AwAA/wcAAP8PAAD/HwAA/z8AAP9/AAD//wAA//8BAP//AwD//wcA//8PAP//HwD//z8A//9/AP///wD///8B////A////wf///8P////H////z////9/AAAAAAEAAAADAAAABwAAAA8AAAAfAAAAPwAAAH8AAAD/AAAA/wEAAP8DAAD/BwAA/w8AAP8fAAD/PwAA/38AAP//AAD//wEA//8DAP//BwD//w8A//8fAP//PwD//38A////AP///wH///8D////B////w////8f////P////39EBQAARAUAAEUFAABGBQAARwUAAEgFAABJBQAASgUAAEsFAABMBQAATQUAAE0FAABOBQAATwUAAFAFAABRBQAAUgUAAFMFAABUBQAAVAUAAFUFAABVBQAAVgUAAFcFAABYBQAAWQUAAFoFAABbBQAAXAUAAFwFAEG09dAACwpdBQAAXgUAAF8FAEHQ9dAAC+oDYAUAAGEFAABiBQAAYwUAAGQFAABlBQAAZgUAAGcFAABoBQAAaQUAAGoFAABrBQAAAAECAwQFBgcICQoLDA0ODxAQERESEhMTFBQUFBUVFRUWFhYWFhYWFhcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGAABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICAhISIiIyMkJCQkJSUlJSYmJiYmJiYmJycnJycnJycoKCgoKCgoKCgoKCgoKCgoKSkpKSkpKSkpKSkpKSkpKSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqBAADAAIAAgACAAIAAgACAAIAAgACAAIAAgABAAEAAQACAAIAAgACAAIAAgACAAIAAgADAAIAAQABAAEAAQABAP//////////AAAAAAAAAAABAAEAAQABAAEAAQACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD/////////////AAAAAAAAAQAEAAMAAgACAAIAAgACAAIAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD//////////////////wBB0PnQAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQZD60AALFQEBAQECAgMDBAQFBwgJCgsMDQ4PEABBsfrQAAslIAAAACAAAABAAAAAgAAAAIAAAACAAAAAgAAAAIAAAAAgAAAAIABB4PrQAAuNHBMAAAAMAAAADQAAAAEAAAAGAAAAAQAAAAEAAAATAAAADQAAAA4AAAABAAAABwAAAAAAAAABAAAAFAAAAA8AAAAQAAAAAQAAAAYAAAAAAAAAAQAAABUAAAAQAAAAEQAAAAEAAAAFAAAAAAAAAAIAAAAVAAAAEgAAABIAAAABAAAABQAAAAAAAAACAAAAFQAAABIAAAATAAAAAwAAAAUAAAACAAAAAwAAABUAAAASAAAAEwAAAAMAAAAFAAAABAAAAAQAAAAVAAAAEwAAABQAAAAEAAAABQAAAAgAAAAEAAAAFQAAABMAAAAUAAAABAAAAAUAAAAQAAAABQAAABYAAAAUAAAAFQAAAAQAAAAFAAAAEAAAAAUAAAAWAAAAFQAAABYAAAAFAAAABQAAABAAAAAFAAAAFgAAABUAAAAWAAAABgAAAAUAAAAQAAAABQAAABYAAAAWAAAAFwAAAAYAAAAFAAAAIAAAAAUAAAAWAAAAFgAAABYAAAAEAAAABQAAACAAAAAGAAAAFgAAABYAAAAXAAAABQAAAAUAAAAgAAAABgAAABYAAAAXAAAAFwAAAAYAAAAFAAAAIAAAAAYAAAAWAAAAFgAAABYAAAAFAAAABQAAADAAAAAHAAAAFwAAABcAAAAWAAAABQAAAAQAAABAAAAABwAAABcAAAAXAAAAFgAAAAYAAAADAAAAQAAAAAgAAAAXAAAAGAAAABYAAAAHAAAAAwAAAAABAAAJAAAAGQAAABkAAAAXAAAABwAAAAMAAAAAAQAACQAAABoAAAAaAAAAGAAAAAcAAAADAAAAAAIAAAkAAAAbAAAAGwAAABkAAAAJAAAAAwAAAOcDAAAJAAAAEgAAAAwAAAANAAAAAQAAAAUAAAABAAAAAQAAABIAAAANAAAADgAAAAEAAAAGAAAAAAAAAAEAAAASAAAADgAAAA4AAAABAAAABQAAAAAAAAACAAAAEgAAABAAAAAQAAAAAQAAAAQAAAAAAAAAAgAAABIAAAAQAAAAEQAAAAMAAAAFAAAAAgAAAAMAAAASAAAAEQAAABIAAAAFAAAABQAAAAIAAAADAAAAEgAAABIAAAATAAAAAwAAAAUAAAAEAAAABAAAABIAAAASAAAAEwAAAAQAAAAEAAAABAAAAAQAAAASAAAAEgAAABMAAAAEAAAABAAAAAgAAAAFAAAAEgAAABIAAAATAAAABQAAAAQAAAAIAAAABQAAABIAAAASAAAAEwAAAAYAAAAEAAAACAAAAAUAAAASAAAAEgAAABMAAAAFAAAABAAAAAwAAAAGAAAAEgAAABMAAAATAAAABwAAAAQAAAAMAAAABgAAABIAAAASAAAAEwAAAAQAAAAEAAAAEAAAAAcAAAASAAAAEgAAABMAAAAEAAAAAwAAACAAAAAHAAAAEgAAABIAAAATAAAABgAAAAMAAACAAAAABwAAABIAAAATAAAAEwAAAAYAAAADAAAAgAAAAAgAAAASAAAAEwAAABMAAAAIAAAAAwAAAAABAAAIAAAAEgAAABMAAAATAAAABgAAAAMAAACAAAAACQAAABIAAAATAAAAEwAAAAgAAAADAAAAAAEAAAkAAAASAAAAEwAAABMAAAAKAAAAAwAAAAACAAAJAAAAEgAAABMAAAATAAAADAAAAAMAAAAAAgAACQAAABIAAAATAAAAEwAAAA0AAAADAAAA5wMAAAkAAAARAAAADAAAAAwAAAABAAAABQAAAAEAAAABAAAAEQAAAAwAAAANAAAAAQAAAAYAAAAAAAAAAQAAABEAAAANAAAADwAAAAEAAAAFAAAAAAAAAAEAAAARAAAADwAAABAAAAACAAAABQAAAAAAAAACAAAAEQAAABEAAAARAAAAAgAAAAQAAAAAAAAAAgAAABEAAAAQAAAAEQAAAAMAAAAEAAAAAgAAAAMAAAARAAAAEAAAABEAAAADAAAABAAAAAQAAAAEAAAAEQAAABAAAAARAAAAAwAAAAQAAAAIAAAABQAAABEAAAAQAAAAEQAAAAQAAAAEAAAACAAAAAUAAAARAAAAEAAAABEAAAAFAAAABAAAAAgAAAAFAAAAEQAAABAAAAARAAAABgAAAAQAAAAIAAAABQAAABEAAAARAAAAEQAAAAUAAAAEAAAACAAAAAYAAAARAAAAEgAAABEAAAAHAAAABAAAAAwAAAAGAAAAEQAAABIAAAARAAAAAwAAAAQAAAAMAAAABwAAABEAAAASAAAAEQAAAAQAAAADAAAAIAAAAAcAAAARAAAAEgAAABEAAAAGAAAAAwAAAAABAAAHAAAAEQAAABIAAAARAAAABgAAAAMAAACAAAAACAAAABEAAAASAAAAEQAAAAgAAAADAAAAAAEAAAgAAAARAAAAEgAAABEAAAAKAAAAAwAAAAACAAAIAAAAEQAAABIAAAARAAAABQAAAAMAAAAAAQAACQAAABEAAAASAAAAEQAAAAcAAAADAAAAAAIAAAkAAAARAAAAEgAAABEAAAAJAAAAAwAAAAACAAAJAAAAEQAAABIAAAARAAAACwAAAAMAAADnAwAACQAAAA4AAAAMAAAADQAAAAEAAAAFAAAAAQAAAAEAAAAOAAAADgAAAA8AAAABAAAABQAAAAAAAAABAAAADgAAAA4AAAAPAAAAAQAAAAQAAAAAAAAAAQAAAA4AAAAOAAAADwAAAAIAAAAEAAAAAAAAAAIAAAAOAAAADgAAAA4AAAAEAAAABAAAAAIAAAADAAAADgAAAA4AAAAOAAAAAwAAAAQAAAAEAAAABAAAAA4AAAAOAAAADgAAAAQAAAAEAAAACAAAAAUAAAAOAAAADgAAAA4AAAAGAAAABAAAAAgAAAAFAAAADgAAAA4AAAAOAAAACAAAAAQAAAAIAAAABQAAAA4AAAAPAAAADgAAAAUAAAAEAAAACAAAAAYAAAAOAAAADwAAAA4AAAAJAAAABAAAAAgAAAAGAAAADgAAAA8AAAAOAAAAAwAAAAQAAAAMAAAABwAAAA4AAAAPAAAADgAAAAQAAAADAAAAGAAAAAcAAAAOAAAADwAAAA4AAAAFAAAAAwAAACAAAAAIAAAADgAAAA8AAAAPAAAABgAAAAMAAABAAAAACAAAAA4AAAAPAAAADwAAAAcAAAADAAAAAAEAAAgAAAAOAAAADwAAAA8AAAAFAAAAAwAAADAAAAAJAAAADgAAAA8AAAAPAAAABgAAAAMAAACAAAAACQAAAA4AAAAPAAAADwAAAAcAAAADAAAAAAEAAAkAAAAOAAAADwAAAA8AAAAIAAAAAwAAAAABAAAJAAAADgAAAA8AAAAPAAAACAAAAAMAAAAAAgAACQAAAA4AAAAPAAAADwAAAAkAAAADAAAAAAIAAAkAAAAOAAAADwAAAA8AAAAKAAAAAwAAAOcDAAAJAAAAAAAAAAAIAAAABwAAagYAAAAGAACtBQAAagUAADEFAAAABQAA1AQAAK0EAACKBAAAagQAAEwEAAAxBAAAFwQAAAAEAADpAwAA1AMAAMADAACtAwAAmwMAAIoDAAB5AwAAagMAAFsDAABMAwAAPgMAADEDAAAkAwAAFwMAAAsDAAAAAwAA9AIAAOkCAADeAgAA1AIAAMoCAADAAgAAtgIAAK0CAACkAgAAmwIAAJICAACKAgAAggIAAHkCAAByAgAAagIAAGICAABbAgAAUwIAAEwCAABFAgAAPgIAADcCAAAxAgAAKgIAACQCAAAeAgAAFwIAABECAAALAgAABQIAAAACAAD6AQAA9AEAAO8BAADpAQAA5AEAAN4BAADZAQAA1AEAAM8BAADKAQAAxQEAAMABAAC7AQAAtgEAALIBAACtAQAAqAEAAKQBAACfAQAAmwEAAJcBAACSAQAAjgEAAIoBAACGAQAAggEAAH4BAAB5AQAAdQEAAHIBAABuAQAAagEAAGYBAABiAQAAXgEAAFsBAABXAQAAUwEAAFABAABMAQAASQEAAEUBAABCAQAAPgEAADsBAAA3AQAANAEAADEBAAAuAQAAKgEAACcBAAAkAQAAIQEAAB4BAAAaAQAAFwEAABQBAAARAQAADgEAAAsBAAAIAQAABQEAAAIBAAAAAQAA/QAAAPoAAAD3AAAA9AAAAPEAAADvAAAA7AAAAOkAAADmAAAA5AAAAOEAAADeAAAA3AAAANkAAADXAAAA1AAAANEAAADPAAAAzAAAAMoAAADHAAAAxQAAAMIAAADAAAAAvgAAALsAAAC5AAAAtgAAALQAAACyAAAArwAAAK0AAACrAAAAqAAAAKYAAACkAAAAogAAAJ8AAACdAAAAmwAAAJkAAACXAAAAlQAAAJIAAACQAAAAjgAAAIwAAACKAAAAiAAAAIYAAACEAAAAggAAAIAAAAB+AAAAewAAAHkAAAB3AAAAdQAAAHMAAAByAAAAcAAAAG4AAABsAAAAagAAAGgAAABmAAAAZAAAAGIAAABgAAAAXgAAAF0AAABbAAAAWQAAAFcAAABVAAAAUwAAAFIAAABQAAAATgAAAEwAAABKAAAASQAAAEcAAABFAAAAQwAAAEIAAABAAAAAPgAAAD0AAAA7AAAAOQAAADcAAAA2AAAANAAAADIAAAAxAAAALwAAAC4AAAAsAAAAKgAAACkAAAAnAAAAJQAAACQAAAAiAAAAIQAAAB8AAAAeAAAAHAAAABoAAAAZAAAAFwAAABYAAAAUAAAAEwAAABEAAAAQAAAADgAAAA0AAAALAAAACgAAAAgAAAAHAAAABQAAAAQAAAACAAAAAQBBgJfRAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcCX0QALFQEBAQECAgMDBAQFBwgJCgsMDQ4PEABB5JfRAAu2AQEAAAADAAAABwAAAA8AAAAfAAAAPwAAAH8AAAD/AAAA/wEAAP8DAAD/BwAA/w8AAP8fAAD/PwAA/38AAP//AAD//wEA//8DAP//BwD//w8A//8fAP//PwD//38A////AP///wH///8D////B////w////8f////P////38BAAEAAQABAAEAAQACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQD/////////////AEGwmdEACxQBAQEBAgIDAwQGBwgJCgsMDQ4PEABB0JnRAAtIBAADAAIAAgACAAIAAgACAAIAAgACAAIAAgABAAEAAQACAAIAAgACAAIAAgACAAIAAgADAAIAAQABAAEAAQABAP//////////AEHAmtEACxUBAQEBAgIDAwQEBQcICQoLDA0ODxAAQeCa0QALrRMBAAQAAwACAAIAAgACAAIAAgABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAP//////////////////AAAAAAAAXHd3Xyz3uPUSxHprJl+ThMwMc8qprUe23rFPEUu7ZbDQnzqMfk5YNAVr4mp84ZdOBKaZvEPXAzpPBMQiJATNzp4lJIXFdt52yuqtW/YohZwpdQniBjdWhonYdaNfRwIp5uulOZcqs6855oM42hQnzp7mIheCrx4CKLYghmJ7AwD1yohdRY2aBECBleYR11aFH1xg/HSu9wQgOr1oNAyfgp4XJcaFyP1PG689igTec4SyRlawIogAUV/M0bISXddpvFSRFRlKnYwDQL2r9BDMw5Fzuewc3G3QLjCA7efmSL5HNeDOMduBNBDSodp89sOszJZ/jB13y2XdI1cFd3Gyjr6UzUQNlYnHK7EAN9zqT5OC8b3tEV9IXnp2ZP1GKi4efPou2HHKaSkuurtek+lGnSuC5gV+tlbgoAOdc1U/15QDWpu2vRBwzfSCm9f8+V5FYcFJh0q1nIYl0oVh+qTROLvpu5RvFnW08VkJckg1FKS6Jmu6gEftehIj4DlEJs7QCNV4YHRtNoS+F+1yPJfOqAELQ5qiI8Mh7oCv4xfWYplb94ycHekMq7xNmtHmjg5Tcl0/9QyM9i4GVahAFmg6wGcJMZyfTm5JoBSbtXIEWHh3hTg7wiQ4J1O1XNQ6kr9mhrqSJFoarkdZliKeVgTjNW8Lh0YqGGVHEpQJ6SW2umzBIoVZLpqs3fIkZmZuCHJxN3g7UMoDUN8JPVZ428HAiJ0o/KxlGNVY8SRSxq5xdhfXZ+lBoth5+5qk2coB4eEraxgpbi9oJWZQbsB6RVOVOXS7OsK0/10D3qpUH1mynUIJEH0DqAIoxfMlCx84J8tqO4JP7lElXvT3woCV2aIOi+HhtLycUe07CgG7PYJS9A9n0j1PYe1CnXvFV2LAE5NbQhReiwC4FKFLPcERHDH+wWhVTKM+duhmXfBiwvEqmIu3+3Wq+naI7iq7ctHQpGKKl5pEt6OUPcF8A13Bnbq7bfHgkh0fEIbHm7egB6mBhte5q8liKa8a9tl6y9P8Fv0sIU1iRGdbjIbX3XSciVDmJWN0w6f0KgS6yj5aRjmlsU7K1QU78NsJvrpyVCs2Wk53zYPRKRIioUffovWOoQxLULluReK93/vfNEbjvi8rzUbDmJ2B/viu8mGdWdR2Un8141PEeThIpSS5tJKRiCaACOzbghdnltooqpqOWEB8806zn7xRBrk3iNbl8NNB92TBunBLcApaE7zaKmL3aNicBqvAueCJuje89lI1MgFKwUe7mO6sS3kAT9VpemN93gdxXiXytjt5r4iYtZmHa0bG81k7f6oWxojC/aP8Qs9jyoFLZ6I2zlrYiOeJI3nTawUNLdOdTmw5XOWmwOZxRVD7vszokV4RMquW0TiP3hjLir8GJmcBiOXaZvsXI4cXYDuDZCjJ0fIWfLicZovldGp2274XFMaFn2WJDOoRYIWt2siufv62ZbWkdhJzI/aF0GmkbOmjg1Y28Kq49ySEb3S7TcGs5PRadTgGhkTmvfUHeD05drtbj22+F9w13ETN8AMJbBnx/epytmfxgkztk/92pp09BcUEEB1SApLMnNCaujdR+6x6KU3lhEU0FGp3SwsKjjQL4nHUIAjcRj24PDh0GBzh76HH7u2XqkLcGwvlMLMy4HDOVRnZHdU5KY+4zRSl07kN2T8jkSebeg/FTApne6XfxgUqfcB3+qbQRmaLd+NJZ7VH2o6csyjv261I1D6T9At9q/ZqhK9JbmbrCPJaDmrNNDX3ImZeblvvQsqufSmmOVXT864thqkejo9JIofmctXAPQlTHJj1+4a/v7AJ+hWfIWZh6bEwg/vEvWbU53DpqPI1bnNmWu+6wbfSWdvNlolt0kfSx9ajG97I6jlO6vKvo5+xi5xT2AjVX0wO+QmFM6/7VllOo3XzPh0Vji8uwa4/uOmRNhd5YwG/Vo1auOOKQGcSOIKDbQnAvRuQD7ll7LwzKdNqfJXViiwvXrt2KG30bBqFDzly2sKhTQbmw4lT+hwQDCrFMMX7o4Svjtd+mYso4rmBN8QFPaje9sJz115bTDaOIgQROaQN3z56nVZnaCTa/tyOobOpt6dndl4deUOhnzhPTNzNpz0CwYuwzLEp5Tq+tHr5T+fbMmFOdUXfOahCVGNx3lK+P2Sxby93gXrPQgoeluryntiDXbTzmz5uSs/kPe7nlTIsVEhozS9meExm4c7kxGhMR4tUR5kLi+2ldzfXJfy3NtaxFckA2tKw2XW6wiGhZIpgz11rXwxX+V8lM/Pc7tTOGCSSO2NKswSw4N02wVovS12wg8xY0kKOot0ktF6YzTmXNkffYhfO5IUktOC059Go+cHw4Ra/DlYHZ5HDjrOdzPItbrpiFjrYd//0+cvEvCt90NfZePRBLODhTFXvTfnMfhKBdY0FijzLNjO1qZFPXPQLLMQ4Y4hI9M2TCGRopV5XvDTsgECqjrT1JPM5f1L/jh/t2ekUosWMBfwkkkF3/kywALq6r1LPDxKfmjASYmJl7PNYpS++2nqL7EtCM6SuphMlYkGYp0wy1aKNuKQoVSQ7c4fSw65obX5pRJoou0kvvpMQe62KPS5j7LtQg4Lq4SMH2WzzK7AxdJ57iUdwijPL/Z4hVgZ8ovARAzvnltvAkb8X27KlhU5r/dSMnUCmSwVxsPrZ36kfg/7WQB55fa3rjTWvWD5epiUOjeuAheAU39PLuyurzX7yUfcM9NgTJk+hTStuBQAAbwUAAHAFAABxBQAAcgUAAHMFAAB0BQAAdQUAAHYFAAB3BQAAeAUAAHkFAAAEAAAAAgAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAGAAAAAgAAAAEAAAABAAAAAgAAAAMAAAAEAAAABAAAAAQAAAADAAAAAgAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQBBoK7RAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcGu0QALPwECAwQFBgcICQoLDA0ODxAQERESEhMTFBQUFBUVFRUWFhYWFhYWFhcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGABBoK/RAAsVAQEBAQICAwMEBAUHCAkKCwwNDg8QAEHBr9EAC/IDAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAgISEiIiMjJCQkJCUlJSUmJiYmJiYmJicnJycnJycnKCgoKCgoKCgoKCgoKCgoKCkpKSkpKSkpKSkpKSkpKSkqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgAAAAABAAAAAQAAAAUAAAANAAAAHQAAAD0AAAB9AAAA/QAAAP0BAAD9AwAA/QcAAP0PAAD9HwAA/T8AAP1/AAD9/wAA/f8BAP3/AwD9/wcA/f8PAP3/HwD9/z8A/f9/AP3//wD9//8B/f//A/3//wf9//8P/f//H/3//z/9//9/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8DAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAAEAAAABEAAAASAAAAEwAAABQAAAAVAAAAFgAAABcAAAAYAAAAGQAAABoAAAAbAAAAHAAAAB0AAAAeAAAAHwAAACAAAAAhAAAAIgAAACMAAAAlAAAAJwAAACkAAAArAAAALwAAADMAAAA7AAAAQwAAAFMAAABjAAAAgwAAAAMBAAADAgAAAwQAAAMIAAADEAAAAyAAAANAAAADgAAAAwABAEHgs9EACxUBAQEBAgIDAwQEBQcICQoLDA0ODxAAQYS00QALiwEBAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEgAAABQAAAAWAAAAGAAAABwAAAAgAAAAKAAAADAAAABAAAAAgAAAAAABAAAAAgAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAAABAEGgtdEAC1UBAQEBAgIDAwQGBwgJCgsMDQ4PEAEAAAAEAAAACAAAAAAAAAABAAAAAgAAAAQAAAAAAAAAAgAAAAQAAAAIAAAAAQAAAAIAAAADAAAABAAAAAUAAAAFAEGEttEAC4sBAQAAAAIAAAADAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAAEAAAABIAAAAUAAAAFgAAABgAAAAcAAAAIAAAACgAAAAwAAAAQAAAAIAAAAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAAAAQBBoLfRAAsUAQEBAQICAwMEBgcICQoLDA0ODxAAQcC30QALhgQBAAEBBgAAAAAAAAQAAAAAEAAABAAAAAAgAAAFAQAAAAAAAAUDAAAAAAAABQQAAAAAAAAFBgAAAAAAAAUHAAAAAAAABQkAAAAAAAAFCgAAAAAAAAUMAAAAAAAABg4AAAAAAAEFEAAAAAAAAQUUAAAAAAABBRYAAAAAAAIFHAAAAAAAAwUgAAAAAAAEBTAAAAAgAAYFQAAAAAAABwWAAAAAAAAIBgABAAAAAAoGAAQAAAAADAYAEAAAIAAABAAAAAAAAAAEAQAAAAAAAAUCAAAAIAAABQQAAAAAAAAFBQAAACAAAAUHAAAAAAAABQgAAAAgAAAFCgAAAAAAAAULAAAAAAAABg0AAAAgAAEFEAAAAAAAAQUSAAAAIAABBRYAAAAAAAIFGAAAACAAAwUgAAAAAAADBSgAAAAAAAYEQAAAABAABgRAAAAAIAAHBYAAAAAAAAkGAAIAAAAACwYACAAAMAAABAAAAAAQAAAEAQAAACAAAAUCAAAAIAAABQMAAAAgAAAFBQAAACAAAAUGAAAAIAAABQgAAAAgAAAFCQAAACAAAAULAAAAIAAABQwAAAAAAAAGDwAAACAAAQUSAAAAIAABBRQAAAAgAAIFGAAAACAAAgUcAAAAIAADBSgAAAAgAAQFMAAAAAAAEAYAAAEAAAAPBgCAAAAAAA4GAEAAAAAADQYAIABB1LvRAAujAwEAAAABAAAABQAAAA0AAAAdAAAAPQAAAH0AAAD9AAAA/QEAAP0DAAD9BwAA/Q8AAP0fAAD9PwAA/X8AAP3/AAD9/wEA/f8DAP3/BwD9/w8A/f8fAP3/PwD9/38A/f//AP3//wH9//8D/f//B/3//w/9//8f/f//P/3//38AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHwEAAQEFAAAAAAAABQAAAAAAAAYEPQAAAAAACQX9AQAAAAAPBf1/AAAAABUF/f8fAAAAAwUFAAAAAAAHBH0AAAAAAAwF/Q8AAAAAEgX9/wMAAAAXBf3/fwAAAAUFHQAAAAAACAT9AAAAAAAOBf0/AAAAABQF/f8PAAAAAgUBAAAAEAAHBH0AAAAAAAsF/QcAAAAAEQX9/wEAAAAWBf3/PwAAAAQFDQAAABAACAT9AAAAAAANBf0fAAAAABMF/f8HAAAAAQUBAAAAEAAGBD0AAAAAAAoF/QMAAAAAEAX9/wAAAAAcBf3//w8AABsF/f//BwAAGgX9//8DAAAZBf3//wEAABgF/f//AEGAv9EAC9MBAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAAAAFQAAABYAAAAXAAAAGAAAABkAAAAaAAAAGwAAABwAAAAdAAAAHgAAAB8AAAAgAAAAIQAAACIAAAAjAAAAJQAAACcAAAApAAAAKwAAAC8AAAAzAAAAOwAAAEMAAABTAAAAYwAAAIMAAAADAQAAAwIAAAMEAAADCAAAAxAAAAMgAAADQAAAA4AAAAMAAQBBgMHRAAsVAQEBAQICAwMEBAUHCAkKCwwNDg8QAEGgwdEAC4YEAQABAQYAAAAAAAAGAwAAAAAAAAQEAAAAIAAABQUAAAAAAAAFBgAAAAAAAAUIAAAAAAAABQkAAAAAAAAFCwAAAAAAAAYNAAAAAAAABhAAAAAAAAAGEwAAAAAAAAYWAAAAAAAABhkAAAAAAAAGHAAAAAAAAAYfAAAAAAAABiIAAAAAAAEGJQAAAAAAAQYpAAAAAAACBi8AAAAAAAMGOwAAAAAABAZTAAAAAAAHBoMAAAAAAAkGAwIAABAAAAQEAAAAAAAABAUAAAAgAAAFBgAAAAAAAAUHAAAAIAAABQkAAAAAAAAFCgAAAAAAAAYMAAAAAAAABg8AAAAAAAAGEgAAAAAAAAYVAAAAAAAABhgAAAAAAAAGGwAAAAAAAAYeAAAAAAAABiEAAAAAAAEGIwAAAAAAAQYnAAAAAAACBisAAAAAAAMGMwAAAAAABAZDAAAAAAAFBmMAAAAAAAgGAwEAACAAAAQEAAAAMAAABAQAAAAQAAAEBQAAACAAAAUHAAAAIAAABQgAAAAgAAAFCgAAACAAAAULAAAAAAAABg4AAAAAAAAGEQAAAAAAAAYUAAAAAAAABhcAAAAAAAAGGgAAAAAAAAYdAAAAAAAABiAAAAAAABAGAwABAAAADwYDgAAAAAAOBgNAAAAAAA0GAyAAAAAADAYDEAAAAAALBgMIAAAAAAoGAwQAQbTF0QALhQcBAAAAAwAAAAcAAAAPAAAAHwAAAD8AAAB/AAAA/wAAAP8BAAD/AwAA/wcAAP8PAAD/HwAA/z8AAP9/AAD//wAA//8BAP//AwD//wcA//8PAP//HwD//z8A//9/AP///wD///8B////A////wf///8P////H////z////9/AAAAAAEAAAACAAAAAQAAAAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAgAAAAHAAAACAAAAAkAAAAKAAAACwAAAAkWP6g+/VMSKY86sfVjroxmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXIAgGMUABsAAAAlAAAAAgAAAJxjFABkZXNjcmlwdGlvbigpIGlzIGRlcHJlY2F0ZWQ7IHVzZSBEaXNwbGF5fAUAAAgAAAAEAAAAfQUAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAfgUAAAgAAAAEAAAAUwIAAH8FAAAYAAAACAAAAIAFAAB/BQAAGAAAAAgAAACBBQAAgAUAACRkFACCBQAAgwUAAIQFAACCBQAAhQUAAN2XEABgAAAAVAAAAB8AAADdlxAAYAAAAH0AAAAbAAAAcHJvdmlkZWQgb3V0cHV0IGlzIHRvbyBzbWFsbCBmb3IgdGhlIGRlY29tcHJlc3NlZCBkYXRhLCBhY3R1YWwgLCBleHBlY3RlZCAAAIBkFAA/AAAAv2QUAAsAAABsaXRlcmFsIGlzIG91dCBvZiBib3VuZHMgb2YgdGhlIGlucHV0ZXhwZWN0ZWQgYW5vdGhlciBieXRlLCBmb3VuZCBub25ldGhlIG9mZnNldCB0byBjb3B5IGlzIG5vdCBjb250YWluZWQgaW4gdGhlIGRlY29tcHJlc3NlZCBidWZmZXJvdXRwdXQgaXMgdG9vIHNtYWxsIGZvciB0aGUgY29tcHJlc3NlZCBkYXRhLCB1c2UgZ2V0X21heGltdW1fb3V0cHV0X3NpemUgdG8gcmVzZXJ2ZSBlbm91Z2ggc3BhY2VpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlF0YQAGQAAABGAAAAIAAAABdGEABkAAAAxAAAADEAAAAXRhAAZAAAAFMBAAArAAAAF0YQAGQAAABlAQAAJQAAAN6EEABhAAAAYwAAAEUAAAABAEHEzNEAC5UEBAAAAAQAAACGBQAAAAAAAAQAAAAEAAAAhwUAAE91dHB1dFRvb1NtYWxsZXhwZWN0ZWRhY3R1YWxMaXRlcmFsT3V0T2ZCb3VuZHNFeHBlY3RlZEFub3RoZXJCeXRlT2Zmc2V0T3V0T2ZCb3VuZHMAAAAAAAAEAAAABAAAAIgFAABDb21wcmVzc2lvbkVycm9yAAAAAAQAAAAEAAAAiQUAAERlY29tcHJlc3Npb25FcnJvcgAAAAAAAAQAAAAEAAAAigUAAElvRXJyb3IAAAAAAAQAAAAEAAAAQwUAAFVuc3VwcG9ydGVkQmxvY2tzaXplVW5zdXBwb3J0ZWRWZXJzaW9uV3JvbmdNYWdpY051bWJlclJlc2VydmVkQml0c1NldEludmFsaWRCbG9ja0luZm9CbG9ja1Rvb0JpZ0hlYWRlckNoZWNrc3VtRXJyb3JCbG9ja0NoZWNrc3VtRXJyb3JDb250ZW50Q2hlY2tzdW1FcnJvcgAAAAAAAAAEAAAABAAAAIsFAABTa2lwcGFibGVGcmFtZURpY3Rpb25hcnlOb3RTdXBwb3J0ZWQAAAAACAAAAAgAAACMBQAAAAAAAAQAAAAEAAAAjQUAAENvbnRlbnRMZW5ndGhFcnJvcgAMGxcqPzgwO0BtaWQgPiBsZW4AAAAsaBQACQAAAAAAAAAKCgsLCgoKCgoJCQgHBwgHBwYGBQUAQfHQ0QALuBQQAAAAJAAAAFQAAACMAAAArAAAANAAAAD4AAAAJAEAAFQBAABuAQAAigEAAJkBAAChAQCAqQEAgLsBAADFAQAAzwEAQNQBAMDZAQCg3AEAQGgUAFxoFACk9BwAFiEQAGQAAAAjAAAAHwAAABYhEABkAAAAIwAAAAsAAAAWIRAAZAAAAC4AAAAfAAAAFiEQAGQAAAAuAAAACwAAABYhEABkAAAAfgAAABwAAAAWIRAAZAAAAH4AAAAzAAAAFiEQAGQAAACHAAAAIgAAABYhEABkAAAAiAAAACIAAAAWIRAAZAAAAKEAAAARAAAAFiEQAGQAAACyAAAAEQAAABYhEABkAAAAwAAAABUAAABhc3NlcnRpb24gZmFpbGVkOiBzMS5sZW4oKSA+PSAobGltaXQgJiA3dXNpemUpAAAWIRAAZAAAAOMAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogczIubGVuKCkgPj0gKGxpbWl0ICYgN3VzaXplKQAAFiEQAGQAAADkAAAABQAAABYhEABkAAAAzgAAABkAAAAWIRAAZAAAAPsAAAAeAAAAFiEQAGQAAAD9AAAAJQAAABYhEABkAAAABQEAABAAAAAWIRAAZAAAAAcBAAAvAAAAFiEQAGQAAAAUAQAAFAAAABYhEABkAAAAGAEAAC0AAAAWIRAAZAAAABUBAAAyAAAAFiEQAGQAAAAkAQAAGAAAABYhEABkAAAAMQEAAC4AAAAWIRAAZAAAAEEBAAAjAAAAFiEQAGQAAABEAQAAJgAAABYhEABkAAAAXAEAAB0AAAAWIRAAZAAAAF0BAAAdAAAAFiEQAGQAAABeAQAAHQAAABYhEABkAAAAXwEAAB0AAAAWIRAAZAAAAIABAAAlAAAAFiEQAGQAAACBAQAAFAAAABYhEABkAAAAhAEAABgAAAAWIRAAZAAAAIUBAAAcAAAAFiEQAGQAAACOAQAAIAAAABYhEABkAAAAmAEAACAAAAAWIRAAZAAAAKIBAAAgAAAAFiEQAGQAAACjAQAAIQAAABYhEABkAAAArgEAABwAAAAWIRAAZAAAAK4BAAA7AAAAFiEQAGQAAAC4AQAAHAAAABYhEABkAAAAuQEAACAAAAAWIRAAZAAAAMIBAABBAAAAFiEQAGQAAADMAQAAHAAAABYhEABkAAAAzQEAACAAAAAWIRAAZAAAAM0BAAA/AAAAFiEQAGQAAADXAQAAIAAAABYhEABkAAAA2AEAACEAAAAWIRAAZAAAANkBAAAhAAAAFiEQAGQAAADkAQAAHAAAABYhEABkAAAA5QEAACAAAAAWIRAAZAAAAO4BAABBAAAAFiEQAGQAAAD4AQAAHAAAABYhEABkAAAA+QEAACEAAAAWIRAAZAAAAPoBAAAhAAAAFiEQAGQAAAAFAgAAHAAAABYhEABkAAAABgIAACAAAAAWIRAAZAAAAAcCAAAkAAAAFiEQAGQAAAARAgAAJAAAABYhEABkAAAAEgIAACUAAAAWIRAAZAAAABwCAABBAAAAFiEQAGQAAAAmAgAAHAAAABYhEABkAAAAJwIAAB0AAAAWIRAAZAAAACgCAAAdAAAAFiEQAGQAAAApAgAAHQAAABYhEABkAAAAOwIAABgAAAAWIRAAZAAAAEwCAAAYAAAAFiEQAGQAAABUAgAAHAAAABYhEABkAAAAVAIAADsAAAAWIRAAZAAAAFUCAAAgAAAAFiEQAGQAAABWAgAAJAAAABYhEABkAAAAYAIAACQAAAAWIRAAZAAAAGECAAAlAAAAFiEQAGQAAAB1AgAAGAAAABYhEABkAAAAhgIAABgAAAAWIRAAZAAAALACAAAYAAAAFiEQAGQAAADCAgAAGAAAABYhEABkAAAAwgIAADcAAAAWIRAAZAAAAMwCAAAYAAAAFiEQAGQAAADNAgAAHAAAABYhEABkAAAA1wIAABwAAAAWIRAAZAAAAOECAAAcAAAAFiEQAGQAAADiAgAAHQAAABYhEABkAAAA7QIAABgAAAAWIRAAZAAAAO4CAAAdAAAAFiEQAGQAAADvAgAAHQAAABYhEABkAAAA+gIAABgAAAAWIRAAZAAAAPsCAAAcAAAAFiEQAGQAAAD7AgAAOwAAABYhEABkAAAABQMAABwAAAAWIRAAZAAAAAYDAAAdAAAAFiEQAGQAAAARAwAAGAAAABYhEABkAAAAEgMAABwAAAAWIRAAZAAAABMDAAAhAAAAFiEQAGQAAAAUAwAAIQAAABYhEABkAAAAHgMAAD0AAAAWIRAAZAAAACgDAAAYAAAAFiEQAGQAAAApAwAAGQAAABYhEABkAAAAKgMAABkAAAAWIRAAZAAAAHQBAAAeAAAAFiEQAGQAAABFAwAAJQAAABYhEABkAAAARgMAABQAAAAWIRAAZAAAAFoDAAAYAAAAFiEQAGQAAABvAwAAGAAAABYhEABkAAAAhAMAABgAAAAWIRAAZAAAAKQDAAAYAAAAFiEQAGQAAADDAwAAIwAAABYhEABkAAAAxgMAACYAAAAWIRAAZAAAAN8DAAAlAAAAFiEQAGQAAADgAwAAFAAAABYhEABkAAAA+QMAABwAAAAWIRAAZAAAAAoEAAAcAAAAFiEQAGQAAAAUBAAAHAAAABYhEABkAAAAPgQAACUAAAAWIRAAZAAAAD8EAAAUAAAAFiEQAGQAAABTBAAAGAAAABYhEABkAAAAaAQAABgAAAAWIRAAZAAAAHQEAAAYAAAAFiEQAGQAAACYBAAAIwAAABYhEABkAAAAmwQAACYAAAAWIRAAZAAAALEEAAAZAAAAFiEQAGQAAADLBAAAEQAAABYhEABkAAAA0AQAABUAAAAWIRAAZAAAANYEAAAjAAAAFiEQAGQAAADZBAAAJgAAABYhEABkAAAA9QQAACkAAAAWIRAAZAAAAPgEAAAdAAAAFiEQAGQAAAD5BAAAHQAAABYhEABkAAAA+gQAAB0AAAAWIRAAZAAAAPsEAAAdAAAAFiEQAGQAAAAFBQAAIQAAABYhEABkAAAABgUAACEAAAAWIRAAZAAAAAcFAAAhAAAAFiEQAGQAAAAIBQAAIQAAAAECAwQABREGEAcICQoLDA0ODwAHAwIBDwIEAwICBE5lZWQgdG8gZnJlZSBlbnRyb3B5X3RhbGx5X3NjcmF0Y2ggYmVmb3JlIGRyb3BwaW5nIENvbW1hbmRRdWV1ZQoAAAEAAAACAAAABQAAAAIAAAAJAAAAAgAAAA0AAAACAAAAEQAAAAMAAAAZAAAAAwAAACEAAAADAAAAKQAAAAMAAAAxAAAABAAAAEEAAAAEAAAAUQAAAAQAAABhAAAABAAAAHEAAAAFAAAAkQAAAAUAAACxAAAABQAAANEAAAAFAAAA8QAAAAYAAAAxAQAABgAAAHEBAAAHAAAA8QEAAAgAAADxAgAACQAAAPEEAAAKAAAA8QgAAAsAAADxEAAADAAAAPEgAAANAAAA8UAAABgAQbjl0QALxQlhc3NlcnRpb24gZmFpbGVkOiBuX2JpdHMgPD0gNTYAAOxTEABqAAAA6AIAAAUAAADsUxAAagAAAOoCAAARAAAA7FMQAGoAAADsAgAABQAAAOxTEABqAAAA5wIAAAUAAAAAAAAA7FMQAGoAAAD5AgAABQAAAOxTEABqAAAA+AIAAAUAAADsUxAAagAAAAoDAAAUAAAA7FMQAGoAAAAgAwAAJgAAAOxTEABqAAAAIAMAABEAAADsUxAAagAAACIDAAANAAAA7FMQAGoAAAA0AwAAGQAAAOxTEABqAAAANgMAAA0AAADsUxAAagAAAF0DAAAwAAAA7FMQAGoAAABdAwAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxlbmd0aCA+IDDsUxAAagAAAAQFAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogbGVuZ3RoIDw9ICgxIDw8IDI0KQAAAOxTEABqAAAABQUAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBsZyA8PSAyNAAA7FMQAGoAAAAGBQAABQAAAOxTEABqAAAAmgUAABAAAADsUxAAagAAAIYFAAAUAAAA7FMQAGoAAACGBQAAKQAAAOxTEABqAAAAtgUAABAAAADsUxAAagAAANAFAAAcAAAA7FMQAGoAAADLBQAACQAAAOxTEABqAAAAzAUAAAkAAADsUxAAagAAAN4FAAAQAAAA7FMQAGoAAAA1BgAAIAAAAOxTEABqAAAANQYAACwAAADsUxAAagAAABEGAABRAAAA7FMQAGoAAAAZBgAARAAAAOxTEABqAAAAGQYAACEAAADsUxAAagAAAF4GAAAJAAAA7FMQAGoAAABzBgAAHQAAAOxTEABqAAAAYQYAAA0AAADsUxAAagAAAIQGAAAQAAAA7FMQAGoAAACOBgAAFQAAAOxTEABqAAAAoAYAABEAAADsUxAAagAAAKwGAAA8AAAA7FMQAGoAAACtBgAADQAAAOxTEABqAAAApwYAAAkAAADsUxAAagAAAKIGAAAMAAAA7FMQAGoAAADUBgAADAAAAOxTEABqAAAA3AYAACMAAADsUxAAagAAAO4GAAAVAAAA7FMQAGoAAADnBgAAFQAAAOxTEABqAAAA1QYAAA0AAADsUxAAagAAAL8GAAAfAAAA7FMQAGoAAADCBgAAHwAAAOxTEABqAAAAjAcAAAUAAADsUxAAagAAAJQHAAAFAAAA7FMQAGoAAADwBwAABQAAAOxTEABqAAAA4wgAABwAAADsUxAAagAAAOkIAAAtAAAA7FMQAGoAAAAFCQAAHAAAAOxTEABqAAAACQkAAA0AAADsUxAAagAAAAoJAAANAAAA7FMQAGoAAAAjCQAAEQAAAOxTEABqAAAAJAkAABEAAADsUxAAagAAABIJAAAjAAAA7FMQAGoAAAAUCQAAFQAAAOxTEABqAAAAFQkAABUAAADsUxAAagAAANQKAAAMAAAA7FMQAGoAAADQCgAAEwAAAOxTEABqAAAA0QoAABMAAADsUxAAagAAAEYLAAAdAAAAAAQEBQYGBwcHBwcICAgICAAAAAQEBAQEBQUGBgYGBwcHBwoKCgoKCgAEBAUFBQYGBwgICQoKCgoKCgoKCgoKCgUAQYzv0QALiQgGBgYGBgYFBQUFBQUEBAQEBAQEBQUFBQUFBgYHBwcICgwMDAwMDAwMDAwMDAAAAAD/d9W/597qnlFd3sZwV7xYWFjY2FjVy4zq4MOHH4PBYBxnsqoGg8FgMBjMoc6IVJRG4bDQTrL3BABtaWQgPiBsZW4AAPV3FAAJAAAALwMQAGwAAAAnAAAACgAAAC8DEABsAAAAKQAAAAoAAAAvAxAAbAAAAC8AAAAKAAAALwMQAGwAAAAxAAAACgAAAC8DEABsAAAANwAAAAoAAAAvAxAAbAAAADkAAAAKAAAALwMQAGwAAAA/AAAACgAAAC8DEABsAAAAQQAAAAoAAAAAAAAALwMQAGwAAABLAAAAEgAAAC8DEABsAAAATQAAABIAAAAvAxAAbAAAAEUAAAAFAAAAAAEAAC8DEABsAAAAbQAAABIAAAAvAxAAbAAAAHUAAAATAAAAAAAAAC8DEABsAAAAfAAAAA0AAAAvAxAAbAAAAH8AAAANAAAALwMQAGwAAABgAAAABQAAAC8DEABsAAAAmQAAABIAAAAvAxAAbAAAAKYAAAANAAAALwMQAGwAAACpAAAADQAAAC8DEABsAAAAjQAAAAUAAAAvAxAAbAAAANUAAAARAAAALwMQAGwAAADZAAAAGwAAAC8DEABsAAAA1wAAABEAAAAgACAAgAAAQAAEAAQAIDAAACAAEABAAAEAQABAAEAAQAEAAgADAAQABQAGAAcACAAJAAoACwAMAA0ADgAPABAALwMQAGwAAAC8AAAAEQAAAC8DEABsAAAAwAAAABsAAAAvAxAAbAAAAL4AAAARAAAAAAABAAEAAQACAAQACAAQABAAIABAAIAAgAAAAoAGgAYvAxAAbAAAALQAAAANAAAALwMQAGwAAACwAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGluZGV4IDwgTlVNX1NQRUVEU19UT19UUlkALwMQAGwAAADkAAAABQAAAC8DEABsAAAA4wAAAAUAAAAQAAAALwMQAGwAAAD8AAAABQAAAC8DEABsAAAACQEAABEAAAAvAxAAbAAAAA4BAAAFAAAAMXMQAF8AAAB0AAAAOQAAADFzEABfAAAAdQAAADMAAAAxcxAAXwAAAIACAAAUAAAAMXMQAF8AAACBAgAAEgAAADFzEABfAAAAggIAAA0AAAAxcxAAXwAAAIICAAArAAAAAAAAAAgACQADACMABwBHACcAZwAXAC8ArwBvAO8AHwAAAAAAAAAEAAwAAgAKAAYADQAdAAsAKwAbADsAVwA3AA8ATwA/AT8DvwC/Ar8BvwMAAA4AAQAZAAUAFQATADMAdwCfAF8A3wDfAd8DPwA/An8AfwJ/AX8D/wD/Av8B/wMOAEG099EAC30bADsABwAnABcANwAeAAEAEQAJABkABQAAAAgABAAMAAIACgAGABUADQAdAAMAEwALAA8ALwAfAF8APwB/AP8A/wL/Cv8G/w7/Af8J/wX/Df8D/wv/B/8PAAAAAAAAAAAxcxAAXwAAADAFAAAsAAAAAQAAAAEAAAACAAAAAgBBrPrRAAsFAQAAAAEAQaT80QALDQsAAAALAAAADAAAAAwAQcT80QALgQEBAAAAAQAAAAkAAAAJAAAAAgAAAAIAAAACAAAAAgAAAAEAAAABAAAAAQAAAAEAAAAIAAAAAwAAAAMAAAADAAAAAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAgAAAAIAAAAIAAAABAAAAAQAAAAEAAAACAAAAAcAAAAEAAAABAAAAAgAQdT90QALzQEDAAAAAwAAAAMAAAADAAAABQAAAAUAAAAKAAAABQAAAAUAAAAFAAAACgAAAAUAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAADFzEABfAAAAFAcAAB0AAAAxcxAAXwAAABUHAAAdAAAAMXMQAF8AAAAaBwAAHwAAADFzEABfAAAAGwcAAB8AAAAxcxAAXwAAACAHAAARAAAAMXMQAF8AAABcBwAAKgAAADFzEABfAAAAYQcAACsAAAAxcxAAXwAAAGUHAAAtAEGs/9EAC+kJAQAAAAIAAABtaWQgPiBsZW4AAAC0fxQACQAAAN8mEABzAAAAKwAAAAkAAADfJhAAcwAAACgAAAAJAAAA3yYQAHMAAAAlAAAACQAAAN8mEABzAAAAIgAAAAkAAADfJhAAcwAAABwAAAAJAAAA3yYQAHMAAAAVAAAACQAAAN8mEABzAAAAPAAAAAUAAADfJhAAcwAAAGsAAAAJAAAA3yYQAHMAAABuAAAACQAAAN8mEABzAAAAYgAAAAkAAADfJhAAcwAAAGUAAAAJAAAA3yYQAHMAAABWAAAACQAAAN8mEABzAAAAWQAAAAkAAADfJhAAcwAAAE4AAAAJAAAA3yYQAHMAAABEAAAACQAAAN8mEABzAAAAiwAAAAkAAADfJhAAcwAAAIgAAAAJAAAA3yYQAHMAAACCAAAACQAAAN8mEABzAAAAewAAAAkAAADfJhAAcwAAAJkAAAAdAAAA3yYQAHMAAACZAAAAJgAAAN8mEABzAAAAmQAAAC8AAADfJhAAcwAAAJkAAAA4AAAA3yYQAHMAAAC6AAAAFQAAAN8mEABzAAAA1AAAADYAAADfJhAAcwAAANYAAAAwAAAA3yYQAHMAAADWAAAARgAAAN8mEABzAAAA3gAAACkAAADfJhAAcwAAAOEAAABCAAAA3yYQAHMAAADZAAAAIQAAAN8mEABzAAAA8wAAAB0AAADfJhAAcwAAAPQAAAAdAAAA3yYQAHMAAAD7AAAAHAAAAN8mEABzAAAA/AAAAC8AAADfJhAAcwAAAPwAAAAWAAAA3yYQAHMAAAABAQAAFQAAAN8mEABzAAAAFgEAAEcAAADfJhAAcwAAABkBAAAZAAAA3yYQAHMAAAAbAQAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGlwX2luZGV4ID49IDUA3yYQAHMAAAAfAQAAGQAAAN8mEABzAAAAIQEAAEcAAADfJhAAcwAAACMBAAAZAAAA3yYQAHMAAAAlAQAAGQAAAN8mEABzAAAAJwEAABkAAADfJhAAcwAAACwBAAAZAAAA3yYQAHMAAAAuAQAAGQAAAN8mEABzAAAAMAEAACEAAADfJhAAcwAAADYBAAAkAAAA3yYQAHMAAAA2AQAAOgAAAN8mEABzAAAAOgEAAB0AAADfJhAAcwAAADsBAAAdAAAA3yYQAHMAAABKAQAAFQAAAN8mEABzAAAAWQEAAEcAAADfJhAAcwAAAFsBAAAZAAAA3yYQAHMAAABdAQAAGQAAAN8mEABzAAAAXwEAABkAAADfJhAAcwAAAGQBAAAZAAAA3yYQAHMAAABmAQAAGQAAAN8mEABzAAAAUAEAAEcAAADfJhAAcwAAAFMBAAAZAAAA3yYQAHMAAABVAQAAGQAAAN8mEABzAAAAVwEAABkAAADfJhAAcwAAAGgBAAAhAAAA3yYQAHMAAABuAQAAHQAAAN8mEABzAAAAewEAABEAAADfJhAAcwAAAHwBAAAnAAAA3yYQAHMAAAB8AQAADgAAAN8mEABzAAAAjwEAAC8AAADfJhAAcwAAAJkBAAAXAAAA3yYQAHMAAACaAQAAFgAAAN8mEABzAAAAvgEAAAgAAADfJhAAcwAAAL8BAAAfAAAA3yYQAHMAAAC/AQAACgAAAN8mEABzAAAAzQEAABMAAADfJhAAcwAAANEBAAATAEGwidIAC0UBAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABAAAAAUAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAAMAAAADgAAABgAQZiK0gALHQEAAAABAAAAAgAAAAIAAAADAAAAAwAAAAQAAAAEAEHYitIACz0BAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABAAAAAUAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAAYAEHYi9IAC8IPAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAGAAAABwAAAAcAAAAIAAAACAAAAAkAAAAJAAAACgAAAAoAAAALAAAACwAAAAwAAAAMAAAADQAAAA0AAAAOAAAADgAAAA8AAAAPAAAAEAAAABAAAAARAAAAEQAAABIAAAASAAAAEwAAABMAAAAUAAAAFAAAABUAAAAVAAAAFgAAABYAAAAXAAAAFwAAABgAAAAYAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAgAAAAKAAAADgAAABIAAAAaAAAAIgAAADIAAABCAAAAYgAAAIIAAADCAAAAQgEAAEICAABCBAAAQggAAEIYAABCWAAA3yYQAHMAAACBAgAABQAAAN8mEABzAAAA6gIAABkAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAABYhEABkAAAALgAAAB8AAAAWIRAAZAAAAC4AAAALAAAAFiEQAGQAAABEAAAACgAAABYhEABkAAAARAAAABwAAABschAAZwAAACEAAAAMAAAAbHIQAGcAAAAtAAAADQAAAGxyEABnAAAALwAAACEAAABschAAZwAAACYAAAANAAAAbHIQAGcAAABnAAAAMAAAAGxyEABnAAAAaAAAAEYAAABschAAZwAAAG4AAAAVAAAAbHIQAGcAAABPAAAAKAAAAGxyEABnAAAAXgAAAA0AAACEAAAAOQAAABcAAAAKAAAABAAAAAEAAABschAAZwAAAJ4AAAAYAAAAbHIQAGcAAACeAAAAEQAAAGxyEABnAAAApAAAAA0AAABschAAZwAAAKUAAAANAAAAbHIQAGcAAACtAAAAGAAAAGxyEABnAAAArQAAADIAAABschAAZwAAALQAAAAYAAAAbHIQAGcAAAC0AAAAMgAAAGxyEABnAAAAvQAAADYAAABschAAZwAAAL8AAAArAAAAbHIQAGcAAADCAAAAGQAAAGxyEABnAAAAlwAAABQAAABschAAZwAAAJkAAAAVAAAAbHIQAGcAAAAfAQAAMAAAAGxyEABnAAAAHwEAAEgAAABschAAZwAAACUBAAAQAAAAbHIQAGcAAAAnAQAAJwAAAGxyEABnAAAAPwEAABkAAABschAAZwAAAEABAAArAAAAbHIQAGcAAABBAQAAKwAAAGxyEABnAAAATQEAACQAAABschAAZwAAADcBAAAVAAAAbHIQAGcAAAAOAQAAHwAAAGxyEABnAAAAFgEAAB4AAABschAAZwAAABEBAAAZAAAAbHIQAGcAAAD9AAAAGAAAAGxyEABnAAAA3gAAAAwAAABschAAZwAAAGQBAAAZAAAAbHIQAGcAAABoAQAAHgAAAGxyEABnAAAAgQEAAAsAAABschAAZwAAAJABAAAJAAAAbHIQAGcAAACRAQAACQAAAGxyEABnAAAAlgEAAAkAAABschAAZwAAAJcBAAAJAAAAbHIQAGcAAAClAQAADQAAAGxyEABnAAAApgEAAA0AAABschAAZwAAAJ0BAAANAAAAbHIQAGcAAACeAQAADQAAAGxyEABnAAAAugEAAAkAAABschAAZwAAALsBAAAJAAAAbHIQAGcAAADJAQAADQAAAGxyEABnAAAAygEAAA0AAABschAAZwAAAMEBAAANAAAAbHIQAGcAAADCAQAADQAAAGxyEABnAAAA5gEAABAAAABschAAZwAAAPMBAAAZAAAAbHIQAGcAAAD4AQAAJgAAAAAAAAAIAAAABAAAAAwAAAACAAAACgAAAAYAAAAOAAAAAQAAAAkAAAAFAAAADQAAAAMAAAALAAAABwAAAA8AAABschAAZwAAADYCAAAMAAAAbHIQAGcAAAA5AgAAIQAAAGxyEABnAAAANwIAAA0AAABschAAZwAAACwCAAAiAAAAbHIQAGcAAAAsAgAAGQAAAG1pZCA+IGxlbgAAAKCLFAAJAAAAjxUQAGEAAAAXAAAAIAAAAI8VEABhAAAAXwAAAA0AAACPFRAAYQAAAGoAAAAfAAAAjxUQAGEAAABrAAAAHwAAAI8VEABhAAAAbAAAAB8AAACPFRAAYQAAAHYAAAAcAAAAEVwQAGIAAAAwAAAAFwAAABFcEABiAAAASgAAABUAAAARXBAAYgAAAGsAAAAVAAAAbWlkID4gbGVuAAAARIwUAAkAAAB7eRAAcAAAAG8CAAAiAAAAe3kQAHAAAABwAgAACQAAAHt5EABwAAAAcQIAAAkAAAB7eRAAcAAAAHICAAAJAAAAe3kQAHAAAABzAgAACQAAAHt5EABwAAAAdAIAAAkAAAB7eRAAcAAAAHUCAAAJAAAAe3kQAHAAAAB4AgAADQAAAHt5EABwAAAAeQIAAA0AAAB7eRAAcAAAAHoCAAANAAAAe3kQAHAAAAB7AgAADQAAAHt5EABwAAAAfAIAAA0AAAB7eRAAcAAAAH0CAAANAAAAPB4AAKEdAACLHQAAgR0AAKMdAACjHQAAoB0AAKAdAACdHQAAnR0AAJcdAACXHQAAjR0AAI0dAACDHQAAgx0AAHt5EABwAAAAtwIAACEAAAB7eRAAcAAAAGUHAAAKAAAAe3kQAHAAAABpBwAASgAAAEh9AEGqm9IACwJkVQBBupvSAAsCJp4AQcab0gALAuayAEHUm9IACxQMBQAAAAAAAAAAZBMWAaVcAAAETgBBgJzSAAsMTgjmPgAAAAAAAGU4AEGanNIACwpnaM0IAAAAAGRDAEG2nNIACwwmDgAAAAAAAAAAyFkAQc6c0gALBgdBAADHhQBB3pzSAAsCZr0AQfyc0gALAs8JAEHAndIACxBMTAAAAADEXQAAAAAAAGQmAEHundIACwKFeABBsp7SAAsC5nwAQcSe0gALEKpQZAkAACVRjQZHIwAABBkAQfqe0gALAqfKAEGYn9IACxZpGiYcAAAAAOhVx1kAAAAAyQ0AAEgHAEG6n9IACxomKwAAAACpJQAAAAAAAGsZAAAAAEaQSFSn8wBB5p/SAAsCZiAAQfaf0gALDGefAAAAAAAA5pnIHwBBkKDSAAsCqyIAQbqg0gALFgUfAAAAAAlkAAAAAAAAqAOEDo0MRz0AQdqg0gALHifNAADlQwAAAAAAAAAAKAWlFgAAJVIAAAAASBknAwBBjKHSAAsc6TQAAAAAAAAoDgAAAAAAAOpzZHgAAAV6AADEGQBBuqHSAAsCRvoAQdKh0gALGgZXAABGkgAAAAAAAAAASBynAQAAJGDJVOREAEH4odIACxQpBwAAAAAAAEgBhRcAAAAAAAAGTgBBnqLSAAsmp/JSEAAAAAAAAAAARC+pIQAAAAAEQgAARo8AAAAAAAAmigAABsoAQeKi0gALBgZSAACG8gBB8qLSAAsCphUAQYqj0gALECU5yCpHZQAAAAAAAAAAiU0AQaij0gALIOh45gvqN8YyAAAAAAAApDsAAIaeCHam8gAAAAAAAKROAEHSo9IACxrlLgAAAAAAAIbMAAAAAAAAAADKYAAALABHgQBB9qPSAAsCBGcAQYKk0gALCsUOAAAAAAhGByUAQZyk0gALBCl+xW8AQbqk0gALBEa4yy0AQdCk0gALCugJZ9cAAAAAChkAQeqk0gALDObbii4AABECAADodQBBmqXSAAsORSAAAAAAiHDm5WlYxQMAQc6l0gALDof6AAAAAEsBZA4AAEUGAEHwpdIACwwKQSUAAABGXEgMRTwAQZCm0gALA6tXRQBBpKbSAAsCqEUAQbim0gALDGkrAAAAAAAAAACFRwBB1qbSAAsKBmgAAAAAqGMnZQBB9qbSAAsYBUIAAAAAAACmawAAAADKJAAAAAAAALQNAEGep9IACxxmlEkkRSEAAAAAAAAAACoGRAaIXQAAAABEOu0xAEHIp9IACwZJLwAA6UAAQean0gALBmRT6CvGcABBkKjSAAsIjBYAAAAApGwAQaao0gALAoQgAEG8qNIACxJsQYUEAAAAAGpJxD8qZacDjSAAQd6o0gALCkZHAACmRgAABrcAQfSo0gALHlMBAAAAAGRi7DGGLwkZAAAAAAAAAACEQAAAhGnrbgBBoKnSAAsMjAUAAAAAAAAoJufOAEHIqdIACwRLYkQBAEHeqdIACwLm/QBB6qnSAAsChVUAQfap0gALEga5AAAAAAAAZgMAAAAAAABmMQBBrqrSAAsEpGXoPwBB0KrSAAsMEQcAAAAAAADJGQY+AEHmqtIACwakcQAAZG8AQf6q0gALCuRVAAAAAAAAxqcAQZyr0gALBA0UJgUAQbar0gALBMbWSGEAQc6r0gALAkbJAEHaq9IACxplDgAAAAAAAAAATifEJAAAAAAAAOR6TBYlGABBhqzSAAsCxxUAQZys0gALBAhqhuAAQays0gALGKwbAADpVYbPAAAAAAAAAADNIAAAAABlFgBBzqzSAAsKRAgAAKZgAAAHLABB+KzSAAsMbQQAAAkTAAAAAKaVAEGcrdIACxAMRgAAAACFRgAAAAAAAKZjAEHKrdIACwaGRQAAZmYAQeCt0gALB+hZB0SoT6QAQf6t0gALDqcMAAAntAAAAAAAAKRvAEGertIACwLFHQBBvq7SAAsOBqIAAAAAKHkm2EgnhAcAQdau0gALBgaPAABnjwBB8K7SAAsEqjan5wBBkq/SAAsGhWcAAAcWAEGkr9IACwRJNuUEAEGyr9IACwrnEwAAAAAAAMVwAEHer9IACw7GIQAAAAAAAAAAKWSERQBB+q/SAAsIBDRsAqUYKy4AQZSw0gALLogDRwQAAKVeAAAAAEhwJ8IAACVaAAAAAAAAAACIfgAAAAAAAAAAx4kAAERw6hYAQdCw0gALAgkRAEGYsdIACwztHqUiAAAAAAAAZDYAQa6x0gALAuajAEG8sdIACxJuGqU2AAAAAAAAhwMAAAAAyl0AQfax0gALFob7AADEVwAABWUAAAAAAAAAAGhcxRQAQZiy0gALBulZRRWJPgBBrrLSAAsihrvpKAAAAABEOAAAAAAAAMekAAAAAAAARsgAAAAAailEXgBB2rLSAAsSBqsAAAAAqkUAAAAAAADoY0VqAEH8stIACwKKcQBBiLPSAAsGcgLEB2w5AEGms9IACwJG4QBBurPSAAsOpq4AAAAAAAAAAAgPxx0AQd6z0gALAoalAEHws9IACwpISyQZAAAAAIgUAEGWtNIACwLlTABBsrTSAAsMZ5sAAAAAAAAAAAh5AEHKtNIACw5GbgAAAAAAAGRxKimFDABB7rTSAAsOBBZIAycBAAAAACghBiAAQY610gALAmRQAEG0tdIACxDqD0ZMAAAAAAAAAACoeSb6AEHQtdIACwJMQQBB6LXSAAsCKkUAQfa10gALBsbFAABHxQBBkrbSAAsKZmMAAAAAAAAHNgBBqLbSAAsoiArHDwAAAAAAAAAAyGIAACwvBggAACa/AAAAAAAAAABJQifoa0MHigBB6LbSAAsKK3oAAAAAAABJBABBiLfSAAsKCANHAwAAAADKcgBBwLfSAAsE6BZmLwBB0rfSAAsCBWMAQea30gALAgfwAEH6t9IACxBmYAAAAAAAAGf3AACkcM4fAEHQuNIACwKOEQBB3LjSAAsQCDekBAAAhD8AAAAAAAAlQABBoLnSAAsIFAEAAAAApEIAQeS50gALGAxeBXMAAAeDAAAlEwAAAADqMAAAAAAH9ABBkLrSAAsUzg8AAAAAAAAAAAZQAABkPKkIB8oAQa660gALAsdbAEG8utIACwoKPAAA6T0AAAk7AEHWutIACw5EbakcAAAAAAAAAACGdgBB9LrSAAsIK36EXQAAZkUAQYi70gALBigYAACoUQBBorvSAAsKBHsAAAAAAACFFQBBvLvSAAsKbQoGxAAAAAALMABB1LvSAAsEiRQHbgBB7rvSAAsK5i0yDwAAAACEZwBBhrzSAAsCpsAAQZa80gALAuUqAEGovNIACwQpRicHAEG6vNIACxDGcwAAAAAAAAAAaWcAAEgYAEHyvNIACwLHAgBBiL3SAAsEC3AnnABBlr3SAAsKxskAAAAAAACHawBBsL3SAAsEi3jEDABB8r3SAAsSZHAAACRHAAAAAAAAAABoY6b/AEGQvtIACwQJDYYGAEGevtIACwyESwAAAAAAAAAAaGEAQci+0gALEBMEAAAAAAAAAADGPQAAplQAQea+0gALAoc/AEH6vtIACyLGfgAApncAAAAAyk7GJgAAAAAAAEdHAAAAACg4AAAICCdDAEGqv9IACwKEHgBByL/SAAsGyldGzjQGAEH4v9IACwxJKgAAAAAAAAAA5p8AQZLA0gALCAVwAAAAAFIWAEG0wNIACxAJZeZWAAAAAAAAAABoQ6eLAEHUwNIAC1AsIAAAbH0AAAAAAAArAAY4AACFQAAAAAAMeAAArA+FAAAAh57LA4ZdAAAAAItqAAAAAAAAzAAAAAAABGqMHSetyGtm4gAAAAAAAAAASFdlZABBssHSAAsOREwLfAAAAADGbQAA5+YAQc7B0gALFOUvAACGrwAAAAAAAAAASHsAAGorAEH4wdIACwgJSodHAABnsABBpMLSAAsCCwgAQcbC0gALAsdLAEHiwtIACwKm5ABB/MLSAAsEi1eHXQBBjMPSAAsQqi0AAAAA5Q8AAAAAbArGGABBqMPSAAsQCmzmBgAAAAAAAAAAyFoG2wBB0sPSAAs2R4UAAIVfAAAAAAAAAABrVQAAykSmJgAAAABIbYaXAAAAAAAAhqoAAEd7qi9mWgAAAAAAAKfEAEGSxNIACwImgABBusTSAAsa58IAAAAAAAAAAKo9pxAAAAAAAAAAAIoS5g4AQeDE0gALIihDxQGrQwAAaE/EDwAAAAAAAOQ9AAAAAAAAAACpa8R8KH4AQZDF0gALEOssBi4AAAAAAAAAAAomJ8UAQarF0gALAmaKAEG2xdIACx4mdAAAAAAAAMeOAAAAAAAAAAApJOYVAAAFNgAAZxsAQd7F0gALCCdiAAAAAGtKAEGAxtIACwIMCgBBjsbSAAsCZXQAQbbG0gALLmalAAAAAAAAAABNJAAA6EXm2u0PAAAAAAAAy3TnkQAAZ3gAAIYgAAAAAAAApkcAQZTH0gALBIlIJtMAQarH0gALDoaRAAAAAMl6RvAAAOYHAEHCx9IACwIlYwBB3sfSAAsEZQjJYgBB9sfSAAsE5DBpNwBBqsjSAAsC5CEAQcLI0gALEoaOAAAAAAAAAACJKoclAAAncABB6MjSAAsQSm8AAAAAAAAAAEVmKyilBgBBisnSAAsmhDoAAGceAADGbAAAAAAAAKbcNA8AAAAAAACKFsdAAADFZm40RE8AQcLJ0gALDkZwAAAAAAAAAADIOIYEAEH4ydIACwLJZABBksrSAAsGxqUAAAQNAEGqytIACwKHIABBxMrSAAsOyUOnBQAAAADrIIa9TwUAQdzK0gALBoo6AACofQBBhMvSAAsEDiTnCgBBmMvSAAsGyT6He60QAEGqy9IACwqnEQAAAAAIbUbmAEHEy9IACxCpIGRNAAAAAAAAAACoF8UeAEH6y9IACwLFVABBlMzSAAsIqCNlBAAApEAAQbDM0gALEIxDxhpoUwAATAkAAAAApw8AQcrM0gALBCVfahAAQejM0gALAqgpAEGSzdIACwRHp84LAEGuzdIACxUlOAAAxVDoDMcKKlCH/QAAAAAAACYAQdrN0gALCqZs8gqmIq4O5wQAQfTN0gALEEt1JiUAAAAAAAAAAMhFBzoAQZjO0gALAmxbAEG2ztIACwIGyQBBxs7SAAseprIAAAAAq1tHfgAAAABKKgfPAAAAAAAAxoFoekb7AEHyztIACxKmfQAAAAAzDwAAAAAAAGkbhQIAQZDP0gALIgttB7QAAAAAAABnVQAAxoUAAAAAS0EAAAAAAAAAAOQ2qFMAQcLP0gALAqabAEHOz9IACwpGmAAAAABoRCQdAEHqz9IACwJEPABB+s/SAAsCxG4AQaLQ0gALAmVjAEHG0NIACwJnLgBB4tDSAAsgx00AACdOAAAAAAAAZyqvAwAAAABFKgAAAAAAAAAAShAAQZTR0gALAmwmAEGq0dIACwKH/wBBvNHSAAsEiSZGYABBytHSAAsCR54AQd7R0gALAgQyAEGA0tIACwRLVmdcAEGS0tIACwrGewAAAAAAAOfkAEG20tIACwKkTABB0tLSAAsSZV8AAMRtAAAAAAAAJHoAAIQMAEH20tIACyjmOQAAAAAAAAAA603GJwAAAAAIJeU5LhEAAAAAxDgAAAAAAADnvlEHAEGs09IACwRNAgUGAEG609IACxolWwAAAAAAAEU3AAAAAAAAAAAQBSY4AACkagBB4NPSAAsCbBwAQe7T0gALAma6AEGE1NIACxIsFOUGAABFOAAAxpLKBwAA7BkAQabU0gALDqdsAAAAAAAAAAAICqQaAEHI1NIACyxILIdmAAAAAGhdAAAAAAAASHcAAAAAJoYAAIdFAAAAAAAAhVYAAOYXAACEZABBpNXSAAsK6GdGFAAAAAB2BABBvtXSAAsCZ5oAQcrV0gALAkaaAEHg1dIACwINDABB8NXSAAsYshIAAAAAAADJcIQZAAAAAChoAADpI8ctAEGU1tIACwQIfIb8AEGu1tIACwKFLABBztbSAAsYBmIAAAAA6UbHTgAAAAAAAGZDAAAAAG4DAEH61tIACwJmXgBBlNfSAAsCy2UAQbDX0gALEGh7AAAAAOcfKl9EGAAAxocAQczX0gALCAh/AAAAAIeuAEH619IACwZFRukhJnIAQZDY0gALCAsoJhOsBWc7AEGm2NIACwYmWQAA5SgAQbjY0gALFIlLBkVrAOYsAAAAAAAAAACpagUKAEHa2NIACxQG/MgA5W4AAAAAAAAAAOh5AAAqeABB+NjSAAsEiXJm7ABBpNnSAAsUiQylDMowh1gAAAAAAABlSeh6B0AAQc7Z0gALCqZQAAAAAAAAZmoAQeLZ0gALDkQ+iBEnGwAAAAAAAAa1AEGC2tIACwIlcQBBoNrSAAsIaFAnDQAABmMAQcDa0gALAhYHAEHW2tIACwLlQgBB9trSAAsCh9oAQYLb0gALAkVeAEGc29IACyxxCwAAAACmwwAAZgsMY2R1cwBGLgAAAAAAAAAA8AsAAAAAAAAAAOdE7wBnTQBB6tvSAAsCxo8AQYbc0gALAudTAEGS3NIACzIEbwoupBIAAAAAKA3HjQAA53oAAAAASTnkAwAAZlAAAAAAAAAEJwAAhVwAAAAAAABHzQBB0tzSAAsChB0AQeLc0gALBGcHiggAQfDc0gALEGtsZ2MAAAAAAAAAAEx5JvcAQY7d0gALBoaPAADkYABBxN3SAAsCSHkAQdjd0gALDipT5AgAAAAAAAAAAGtnAEH63dIACwLkOwBBjN7SAAsEaAznSwBBnt7SAAsqBvUAAAAAAAAkYwAAAADrbCQFAAAAACwexwsAAAAAAAAAACkaAAAAACa7AEHa3tIACxRFDAAAAAAAAOQ5AAAAAAAAAABuJABBgt/SAAsCBXsAQY7f0gALAqYZAEGc39IACwipGUQFAAAmZABBrt/SAAsIZE8AAAAAq0IAQdLf0gALDmQuAABGoAAAAAAAACVnAEHy39IACwqnLOltZjoAAKcnAEGK4NIACxyGcwAAAAAAAAAAKGpm4AAAAAAAAAAA6m/m4GsFAEG64NIACwKH4wBByuDSAAsCpUEAQfbg0gALDMYNAAClPQAAxBUoNABBjOHSAAsE6UinWwBBnOHSAAsOLTzlGgAAAAAAAAAAqDsAQbrh0gALAoUmAEHM4dIACwwoJcUPAAAAACst58EAQeTh0gALBOhs5uEAQfLh0gALBmejAACkVQBBhuLSAAsKpWMAAEZrAAClRgBBqOLSAAsGSjaEH0lnAEG64tIACxLkYgAAAAAAAAAAqj/lHEoWJ0sAQdzi0gALBHAF58YAQeri0gALDGfSAAAAAAAAAACrBQBBiuPSAAsCB4wAQbDj0gALEIlFxT0AAMQxAAAAAAAAx4AAQczj0gALAg0VAEHi49IACwaneQAARFAAQfrj0gALAubJAEGs5NIACyxNL0dKAACniAAA5FQQDgAAAAAAAAAAhrqIQ8erSVnHuQAAAAAAAAAAKGfmvABB8uTSAAsSBncAAAAACFzlEQAAhFcAAIbAAEGq5dIACxSnwgAAAAAAAIVry3sHAAAAAADrZABByOXSAAsYaRBlQAAAxFAAAAAAAAAAAKkOB1uIPyYPAEHs5dIACwKqLABB+uXSAAsCpR0AQY7m0gALAgffAEGm5tIACwokWYorBsAAAEdcAEG+5tIACwJFNgBBzObSAAsGyi2n6uoEAEHe5tIACwKESABB/ObSAAsYKW0AAAAAAAAAAGcVAAAmTshEZw3sKuR1AEGi59IACwMFYA4AQbLn0gALCuRjAAAAAAAAxG8AQd7n0gALAifRAEH259IACwKGgwBBlujSAAsaBiIAACQ3AAAAAHQAJAEAAAAAAADHkwAARqgAQcDo0gALF0hVAAAAAIZ9DwMAAAAABnkAAAAAAABEAEGU6dIACwwsFwAAAAAAAElIRzsAQbzp0gALBC4ORUIAQerp0gALAoVFAEH46dIACxIIAqakAAAAADIMAAAAAAAA6lcAQZrq0gALFoZvAAAAAAAAZsQAAAAASTVGFwAApokAQcDq0gALBCl1JEkAQeTq0gALGItQZyQAAAAAAAAAAKldAABJFAAAAACkLwBBnuvSAAsCRl8AQdDr0gALBIlOpQIAQeTr0gALAutyAEH469IACwwqTwAAAAAAAAAAhykAQZbs0gALAie6AEHK7NIACxAEaMgxAACoUAAAAAAAALABAEHu7NIACwaGAgAABGQAQY7t0gALFCb5AAAAAAAAAAAoYAAAAAAAACtTAEG27dIACxpGsgAAAAAAAAAAiwcAAAAAAAApUEfqAACGUABB7u3SAAsCp9sAQfrt0gALCid1AACHzgAAxlEAQZLu0gALAudBAEGu7tIACwJFHABBuu7SAAsCxrkAQdLu0gALAqYoAEHi7tIACwwmqAAAAAByCwAAiDIAQYbv0gALAqV5AEGW79IACwYHkwAApEQAQbDv0gALAgh6AEG879IACwKwAgBByO/SAAsMcAYAAAAAAAAAAEcnAEH079IACwGSAEGI8NIACwjJGMcAAACmiABBqvDSAAsCB94AQbbw0gALBga/AABkNABBzPDSAAsQiQlEEQAAAAAAAAAAzE+lAwBB6vDSAAsCR7EAQaLx0gALAsbVAEG88dIACwSMQuUCAEHO8dIACwrFawAAAABKdgZKAEH88dIACwLICABBkPLSAAsciWUAAAAAAACLCQAAAACGewAARjcAAAAAAAAHcABBuPLSAAsMaDwAAAAAAAAAAKbVAEHQ8tIACw7zDgAAAAAAAKwOAACpJgBB6PLSAAsEikoHegBBgvPSAAsCBGAAQZbz0gALAsRAAEG089IACxTpawAAAAAAABADJxKMfwAAAAAG+ABB1vPSAAsCRlIAQezz0gALCEwNZuQAAEV+AEGU9NIACwTKSOUKAEGm9NIACwpkIQAAAAAAAOVXAEHM9NIACwwJPgAAAAAAAAAAJ4wAQfz00gALBCofJEYAQY710gALFgRfAAAAAEkTAAAAAAAA6B8AAGw0ZCgAQa710gALAgQuAEHE9dIACwJIQQBB1PXSAAsE6ERHRgBBjPbSAAsCiQsAQZz20gALBIwjpkEAQcD20gALCMt3AAAAAEVKAEHU9tIACwTNAOY7AEH09tIACwKxBwBBhPfSAAsIiGYmzQAAhsIAQZr30gALAsQlAEGm99IACwiGEgAAAACJVABBuvfSAAsCRtEAQcj30gALAksWAEHY99IACxDKC6YwAAAAAAAAAABoCwYBAEH899IACwIJDgBBkvjSAAsCZl0AQaL40gALAkfaAEGu+NIACxYHAwAABqnKE0e/AAAAAMpZRRALIyavAEHO+NIACw5H8xABAAAAAAAAAADmyABB6PjSAAsCSm4AQZL50gALDiU0AAAAAAAAp8cpTyU2AEHE+dIACwRJAkYdAEHY+dIACw8IVcfzAAAAAAAAAAArH6YAQfr50gALBgaYAACm3QBBnPrSAAsEqD+HFgBBrvrSAAsCRH0AQcr60gALAmR0AEHc+tIACwhsXed1AACn5QBB8vrSAAsTJlAAAAAAAAAAAAkjAAAAAAAAtwBBkPvSAAsECgklRABBpvvSAAsMxFwAAAAAyx/nEgptAEHK+9IACxgmcwAAAACoQCdoAAAH0gAAAACINmcfCEkAQfj70gALBA4DhT4AQYz80gALCHIY5t1IQKcwAEGi/NIACwLkXABBsPzSAAsQiyQAAAAAAABpHGegzGCm4QBB1PzSAAsE7A4lCgBB9PzSAAsOKXLG7gAAAAAAAEfkSz0AQbL90gALGEaRiFfHAwAAAAAAACZa6mgAAAAAAAApTQBB3P3SAAsEKBWGNQBB6v3SAAsWBs6qT6eWAAAAAAAAh8cAAAAAiABEIQBBlv7SAAsCxGsAQaz+0gALAhMCAEHA/tIACxToIqcT6DCGSwAAAAArWSd2qm2keQBB8P7SAAsIaWvkRohOx+YAQYr/0gALGkVfAAAAAO0XAAAAAAAAAABFJQAAAADpX6dxAEGy/9IACw5kYwAAAACrJQAAAABH9gBB0v/SAAsChpoAQeD/0gALDIxQJy7zAQAACBTmCABB9v/SAAsC5rQAQYiA0wALBupb5pyICQBBooDTAAsCRjsAQbiA0wALAippAEHOgNMACwKGaABB2oDTAAsYx8oAAAAA7FsAAAAAAAAAACbIiWTGrU4xAEH+gNMACxoGDAAAJSQAAAAAaAQHVgAAAAAAAGZTAAAkQABBpoHTAAsCRv4AQdKB0wALCgRYAACGvgAAx4YAQfqB0wALAkUmAEGKgtMACxblNQAAh5UAAAAAygYAAOkBB7UAAEaxAEGygtMACwJmcQBBwILTAAsETBjm3ABBzoLTAAsGBWkAAIZwAEHqgtMACw6GswAAAAAAAAAASVAHwwBBhIPTAAsEywtGMABBnIPTAAsMy2cHNAAAAACNAmdbAEG4g9MACwgsVwAAAADEUgBB0oPTAAsCpGsAQeKD0wALGuZs61MFbAAABXTtAAAAiCkAAAAAAAAAAOaDAEGIhNMACwJLewBBlITTAAsEiAWHCQBBrITTAAsCiyUAQbyE0wALFOsVxUDpZ4aKAAAAAAAAhGgAAIfnAEH0hNMACwRoaYbhAEGYhdMACx7KHgAAAAAAAEhMRRkAAAAAiQQAAAAAAAAIHsdRqQEAQcaF0wALBucwAABmMgBB4IXTAAsOawkAAM0t5mUAAAAA6U4AQf6F0wALAiUrAEGehtMACwIHdwBBtobTAAsKJVR1BMZSAADkIwBB3IbTAAsEuABFBABB8IbTAAsa6hIAAGg1AAAAAMYvAAAAAAAAJCkAAAAA6SIAQZ6H0wALHkRxAAAAAMgtZmkAAGa0AACHqwp8AACIBGQPAAAkUQBBxofTAAsG5V8AAEZ/AEHuh9MACwJlfABB/ofTAAsSBgkMLgAAAAAnqAAAAAAAAKVJAEGiiNMACxKG+AAAAACIG6ZDAAAAAAAAxVUAQeSI0wALBA8EhxgAQYKJ0wALAqUvAEGWidMACwqGtQAAAAAYAAdNAEGyidMACwKnmQBByInTAAsEaVMGDwBB2onTAAsCR48AQfKJ0wALAgQsAEH+idMACwKmJABBmorTAAsS5nQAAEaDAABkEgwLAAAAAGdzAEG2itMACwLFdABByIrTAAsCTw4AQYCL0wALBKgqxxsAQZiL0wALAqgkAEGyi9MACwKkTwBB0ovTAAsK5pAAAAAAAADmaQBB6IvTAAsIaVUAAGlsBnYAQfqL0wALAifiAEGQjNMACwRoMUYVAEGojNMACwhITeRCAAAnywBBwIzTAAsC9gIAQeaM0wALAkRhAEHyjNMACxbEBQAAB/4AAAAAtQRHtgAAR3VpLUYEAEGkjdMACwJKJwBBso3TAAsCJ28AQcqN0wALEsQ5AAAAAAAAAACoQQAAAADmAgBB8o3TAAsChFQAQYyO0wALDUg+p1oAAAAAAAAAAPcAQaKO0wALCqdgAAAAAAAAhBQAQbyO0wALHgl15EhrUse2AACFGwAAAAAAAAAAa2QAAAAABET0DgBB8I7TAAsIqxYFFgAAB5UAQaKP0wALAsfqAEHEj9MACwJVAwBB0o/TAAsCB3YAQeKP0wALAiUiAEHuj9MACw7magAAAAAAAAAAqwDmDwBBjJDTAAsECV7GHABBtJDTAAsMiAhFFAAAxFEJBoQTAEHykNMACwIEHgBBqJHTAAsCqRgAQbiR0wALAmp4AEHOkdMACwJHawBB5JHTAAsMiFRH9wAAAADLDId5AEH+kdMACw4kLQAApDkAAAAAAAAEOwBBqJLTAAsMal0mcQAAAAAAAGUTAEHIktMACwToJ2cUAEHektMACwoGagAAAACVBOZOAEHyktMACwIm3QBB/pLTAAsCBBIAQZST0wALAi4uAEG0k9MACxBpReYeAAAAAIh8AAAAAKcXAEHYk9MACwIKIwBB8JPTAAsSyEFHXQAAAAArKwAAAAAAACh/AEGglNMACxxqUYU1AAAAAAAAR5HNHOcoSkQEYwAAAAAAAGaWAEHOlNMACwQFVKoXAEHelNMACwplDAAAAAAAAEclAEH0lNMACwRoRaQxAEGCldMACwKmkABBmJXTAAsWzDFnvgAAxi0AAAAAamIAAAAAAABJIwBBypXTAAsGpBMAAKZ1AEHaldMACwgHpwAAAACIDgBB7pXTAAsCZmIAQYSW0wALCEoVBRQAAObiAEGWltMACwJEbABBqpbTAAsqJFYAAAAAAAAAAIlmAABLPoQNAAAAAAAA5osAAAAAAACFHixMp30AAKVIAEHeltMACwrkbwAAAAAAAEftAEHyltMACwLEcwBBjpfTAAsWREMNPsYkqiUAAAAAAABRAgAAAACkXgBBrpfTAAsK5p0AAIRmAABFWgBB3pfTAAsehv0AAAAAAAAAAIsPZ+oAAAAAAAAnbgAAAAAAAIaoAEGKmNMACxrmcQAARHcAAAAAAAAAAMgzAAAAAAAAAAClQABBrpjTAAsCBGYAQcCY0wALAilZAEHQmNMACwIpBABB/JjTAAsEKUrFEgBBipnTAAsCJkUAQaCZ0wALDIwNAAAAAAAAAACHNABBwpnTAAsWJ94AAAAA8AakPQAAAAArCgAAKCiGegBB9JnTAAsISC0HDgAARAkAQYqa0wALAiROAEGYmtMACwwoLwYCAAAAAKgHJyMAQcCa0wALBAoc54AAQdCa0wALAmkGAEHgmtMACwhsGqUm6gGlDwBBiJvTAAsSqmKlFQAA5TYyAQdRAAAAAM4kAEGom9MACwjJLgQBAABniQBBvpvTAAsS5UcAAAAAAADGQAAAAAAAAMZXAEHcm9MACwroCgAAAAAAAMo2AEGInNMACwwKOkUPAAAAAAAAR+EAQaCc0wALDGs+AAAAAAAA6gqHOwBBypzTAAsOBGluIwAAAAAAAAAAhsoAQfSc0wALBCtMB5EAQaad0wALEgVLbiiGLgAAAAAAAAAA6zpEWgBB2J3TAAsBqQBB8J3TAAsUqjsHowAAxt0AAAAACQsAAMk2hQEAQZSe0wALBOpTpnwAQbSe0wALDOhPxgIAAAAAyGElVQBB1J7TAAsMq34EUwAAxnUAAKaoAEH4ntMACwiLLAAAAAAFBABBrJ/TAAsM7BokJAAA5vaoDUY4AEHMn9MACwgoWAAAAAAFUwBB4p/TAAsIx5oAAAAAzScAQYSg0wALBAl4BuoAQaSg0wALAukMAEG4oNMACwjsHSdhAABGAwBB2KDTAAsU7S7EMwAAJwIAAAAAAADHqAAAZ3cAQfyg0wALBOpuBHgAQZSh0wALBIlYxVgAQbqh0wALKuZyAAAAAAAAAADKPgYj9QClBQAAAAAAAAAAKGEAAAAAAAAAAEQzAADHigBB8KHTAAsEyzOlKgBBmqLTAAsKZ2IAAAAAAACENgBBsqLTAAsSZ9WpTCYvCwwAAAAAAAAAAGQ4AEHeotMACwgGVQAAZzyKcgBB8qLTAAsCJnUAQZaj0wALAmVcAEGoo9MACwhTCgAAAADnUgBB2KPTAAsCEhAAQeqj0wALAuaHAEH6o9MACwLnPgBBiKTTAAsMKQEkDgoNhCgAAIc5AEHCpNMACxLkdMlXRzapPMd+qnbkNAAAh3AAQeKk0wALBEb8zEcAQf6k0wALAsaWAEGQpdMACwLUBABBrqXTAAsMxn8AAAAAAAAAAO4RAEHmpdMACwKn/QBBgKbTAAsCaEEAQY6m0wALEiVOAAAAACg1pwQAAAAAAADn8gBBqqbTAAsCpF8AQcCm0wALAutEAEHaptMACyAEFQAAAABIfgAAAABG+QAAAAAAAGcLAAAAAAAAAACKQgBBlqfTAAsCh+sAQcin0wALEAoe5gEAAAAAAABmmQAAxr8AQfSn0wALAgsxAEGOqNMACxznUUlGZzEAAAAAAACkPmh/AAAAAAAAAACmP2shAEHiqNMACwJmiQBB8KjTAAsCinYAQYCp0wALIM05RA4AAAAATCCGMgAAptYAAAAAAAAAAEgKp4QAAIdaAEGqqdMACwKmjQBBuKnTAAsIrH8maQAApH8AQdSp0wALEAk9py62BAAAAAAAAAAAhEYAQe6p0wALIiZAAAAAAAAAJGcAAAAAaXAAAAAARmEAAAAAmAEnsQAAh4sAQayq0wALB0oOJkQAAKUAQcKq0wALCAcYAAAAAGhfAEHYqtMACwRqXuVeAEHuqtMACwZHLgAAp5oAQYCr0wALBE0l5AoAQbyr0wALAvIDAEHKq9MACwrHZex7AACpXiQHAEHmq9MACwyEQwAAAAAAAAAACEwAQYKs0wALFsR+AAAAAAAAx3AAAAAAAAAAAChFh9AAQaqs0wALBORFkgcAQbis0wALDuo/AAAAAGVUAAAAAIsTAEHSrNMACw6lWAAARlcAAAAAAAAm2gBB8qzTAAsCRVkAQYSt0wALBMgZBwEAQbat0wALAgRhAEHKrdMACwIHnwBB1q3TAAsCZoQAQeSt0wALAsgyAEH6rdMACwJkdgBBiK7TAAsCChUAQZau0wALAsRsAEHErtMACw5MRQAAAAAAAAAABWKIcQBB4K7TAAsEiDHGLABB9K7TAAsEVACHHABBjq/TAAsapGnJAQAAjFmG40hKAAAuCoeyAAAlFAAAxGEAQdCv0wALAhEIAEHcr9MACwLKfABB9q/TAAsGZoIAAAa7AEGMsNMACwKsYQBBnLDTAAsUKWZGiwAAx+LMdwAAAAAAAAAAhGUAQdiw0wALAmgRAEH8sNMACwSIHWdQAEGSsdMACwKGkgBBprHTAAsCRqcAQb6x0wALKsUGAAAAAAAABCAAAAAA6SsAAGx3pusAAKU6AAAAAAAAxp4AAARdAAAmJwBB+LHTAAsESjIneQBBiLLTAAsWSAYAAAAAAAAAAIRHAAAAAAAAAADqaQBBrLLTAAsICB9mBQAAJS4AQc6y0wALBsVfAABlLQBB6rLTAAsOxlQAAAAALDNGIFQKJR8AQZCz0wALMAkEJTEAAIViAAAAAAAAJqCtPwf2AAAAAAAAAADvBGYkAAAAAAAApkkAAAAAzQZnhABBzLPTAAsCCWcAQeKz0wALBqV9AADHxwBB8rPTAAsC5HIAQYS00wALBIoGhhAAQZK00wALDAYpAAAAAAAAAACpFQBBqLTTAAsEMwhmsABBwLTTAAsGTTcAAEtpAEHYtNMACwLIQgBB9LTTAAsEqmlGGgBBiLXTAAskim8AAAAA5hsAAAAAAAAAAChCAAAAAAAA6WQAAC8RRBsAAIa0AEG2tdMACwSGKaxSAEHItdMACwSOCae9AEHitdMACwJFNABB9LXTAAsEKDxnLwBBgrbTAAsEphJKAgBBlrbTAAsGx1wIJsQRAEHYttMACxzpY6dzahhlBgAAAAAAAAAACFYAAAAAAAAAACRXAEGSt9MACyImkuxdAAAAAAAAijgndAAApRsAAKazAAAAAAAAAABod2ecAEHet9MACwYGGAAAhBAAQe630wALAidsAEH+t9MACw7kXwlURgUAAAAAAABHgwBBnLjTAAsECC6GBQBBrrjTAAsEREesAwBBvrjTAAsCZhwAQd640wALAkVBAEHuuNMACwInvwBB/LjTAAsCbFwAQZq50wALAmbQAEGoudMACxiMEOY/AABGEQkahH8AAAAA6AKkRgAABisAQcq50wALAkRzAEHaudMACwoGHgAAAADpM2YVAEGYutMACxJIMgAAAABGXu0DhFkAAMV6aFsAQbi60wALEghvAAAAAAAAamTlaQAAAADpZgBB1rrTAAsHJmIAAAAAWABB7LrTAAsUiEIAAAAAJ1UAAAAATCcAAAgwhFUAQaS70wALHClR5zcAAEbj6H0AACooAABJCActAAAAAAAAJTAAQc670wALEoRwKAnFHwAAAAAAAAAAaFXn9ABBmLzTAAsI0woAAAAApFoAQaq80wALAoYYAEG2vNMACwzlZwAAAAAAAAAAaFoAQcy80wALBEh8Zk4AQeS80wALEIhfRggAAAAAAAAAAKoZhAQAQYK90wALFsZ2AAAAAAAA5G70DQAAAADnZ4owphQAQaK90wALAmcTAEHAvdMACxCKYWdeAAAAAAAAAABJcEYSAEHevdMACwOkBewAQfK90wALAuRLAEGAvtMACwIsCABBlL7TAAsCCwsAQaC+0wALCKlNBEsAAOUtAEG2vtMACwomRgAA5kUAACZJAEHivtMACwLmIwBBlr/TAAsOBlSpEwAAAAAAAAAAR1kAQa6/0wALBgY5AAClcwBBxL/TAAsMaQIAAAAAAAAAACa4AEHkv9MACwIrDgBBgMDTAAsasQjnOQAAAABNCiYYTgDmOgAAAAAAAAAAKE8AQabA0wALCoePLBAHrshDZ2QAQcjA0wALAsg2AEHWwNMACwJkbQBB4sDTAAsCpB0AQfLA0wALAicIAEGYwdMACxRsRgAAAAAAACwBhDcAAAAAagWHnQBBuMHTAAsIankAAAAAZlcAQcrB0wALAoaLAEH2wdMACwqkZ0weAAAAACZKAEGQwtMACwYoGYcEDBwAQaLC0wALGsayAADG4QAAZEEAAAAAkhom7AAAAAAAAGZnAEHGwtMACwZm/woRRh4AQdjC0wALBogjhxJOAQBB6sLTAAsKJpwAAAAAAADkZABBmMPTAAsK0wsAAAAAAADIPQBBssPTAAsCx7wAQcjD0wALDCg/R6MAAAAAil+FIQBBjsTTAAsCBDAAQbLE0wALEOfUAAAAAAAAAADpE4R46EgAQc7E0wALCGRAAAAAAMlqAEHuxNMACwJmjABB/sTTAAsCBBEAQYrF0wALCsbeAAAAAIkF56AAQZ7F0wALHoVbAAAAAAAAAAAoJ+dUAAAAAI4nAAAAAAAAAABmSgBByMXTAAsEKV5mEgBB8MXTAAsQKhEAAAAAAAAAAMUzAABH3ABBlsbTAAsC5koAQarG0wALDqbaAAAAAAAAZssAAAQ9AEHCxtMACxJkCgAAAAAAAAAAjFQAAAAA58wAQebG0wALAsYiAEH0xtMACwgsDAAA0AGmhwBBiMfTAAsMq2GHMAAAJGpoB6ccAEGex9MACxZmiwAAAAAAAAAAkA0AAAAAAAAAAIZXAEHGx9MACwLGsABB4sfTAAsGhFIqXGeBAEH0x9MACwQsQUdWAEGQyNMACwIKIgBBpsjTAAsCBtoAQbTI0wALCg0QpFsAAAAAqiIAQdDI0wALAZMAQezI0wALBgh1pvcWBQBBgsnTAAsC5mAAQZbJ0wALAkcmAEGmydMACwJlegBBssnTAAsCZUwAQb7J0wALCkUWAAAAAAAAJvYAQdbJ0wALAgZTAEH2ydMACwrEMAAAAAAAAMa8AEGWytMACxKnPQAAAACyBAAAAAAAAAAAhloAQdTK0wALIA4MJ8AAAAAACxUlOwAAAAAAACUNAAAAAAAAAABsTsU2AEGIy9MACxp4AQadAAAAAAAAR8sAAGRhAAAAAAAAAAAoAwBBvsvTAAsChCYAQcrL0wALKqdcAADkUwAAAAAAAAAAKFHHEgAAAABpDCZBAAAAAG4AZSoAAAAAAADmQwBBhszTAAsCxqkAQbTM0wALBEwdZhMAQcbM0wALBobLAADEXwBB5szTAAsop2cAAAAAAACntAAAAAAAAMU8AAAAAAAAAABMAGfMAAAAAAAAAADKRQBBos3TAAsCprYAQa7N0wALAuVKAEHCzdMACwIGrABB6M3TAAsCqQsAQfbN0wALCuY3AAAAAE0IB7MAQYzO0wALHG4mAACrMyRMAAAAAAAARHQAAAAAAAAAAK4CZXUAQbLO0wALEkV4iwBlUQAAAAAAAAAA9gFlSABBzs7TAAsCp0oAQdrO0wALCqR6AAAAAAAAJEQAQfLO0wALAsbCAEGQz9MACyQKZCYCAAAAADECAABqcQAAAAAAAMgNAAAAAAAAswZFORIA5/cAQcjP0wALAmo3AEHgz9MACxiKc4bmAAAGmgAAAAAAAAAAygjkQAAAJHwAQYTQ0wALCM4BR0IAAGVxAEGW0NMACwKmWwBBqNDTAAsQ6AYAAIkXZkIMBwAAAACm0wBByNDTAAsILDcAAAoYBnQAQdrQ0wALAiQeAEGC0dMACwanvgAAZCAAQa7R0wALCgVALRcAAAk6Z8gAQc7R0wALDCeLiSMHWgAAAABIWgBB5NHTAAsCtgEAQfTR0wALBpcAJiRuBQBBhtLTAAsWx9MAAAAAAAAAACsYAAAAAAAAAAAnMwBBtNLTAAsIiiYAAAAA5ugAQc7S0wALCsZiAAAAAChdRX0AQerS0wALCCckiwimO7UBAEGG09MACwIlTABBntPTAAsC5C0AQcbT0wALAgZCAEHa09MACwbEVkkHh0QAQezT0wALDOxVAAAAAAAAAACn2gBBiNTTAAsEin2kUgBBmNTTAAsUqTcAAAAAAABUCQAAAAAAAAAApxoAQcbU0wALCkZoAAAAAKsXB9EAQd7U0wALBIbBDxgAQfzU0wALCAwE5F0AAMUJAEGQ1dMACwgLREfIMQ0mOwBBpNXTAAsIjxOm8wAAZ94AQcLV0wALAmZfAEHU1dMACwKuAwBB6tXTAAsCZ24AQfrV0wALFAY9AAAlTQAAAABLBgAAy1bHvSliAEG21tMACwJERABBzNbTAAsU0QIAAAAAAAAAAAZ/AAAAAAAAJUgAQezW0wALDggX53RJDgZaAAAAAI4MAEGM19MACwFwAEGY19MACwjoC8cBAAAkeQBBrtfTAAsG5loAAKV/AEG+19MACwLGlABB2tfTAAsCJBMAQe7X0wALLsVjAABkSQAAAADoVkcFAAAm8awRpXcAACc68gCHcQAAAABIOIUSAAAAAAAAxpEAQbTY0wALBqofAABrfQBB0NjTAAsQyQUAAAAA5G0AAMZkAACH6QBB6tjTAAsKxuYAAAAAAABGWwBBgtnTAAscp3gAAAAAAAAAAEg/AAAAAAAATwEAAAAAAADKAgBBuNnTAAsECngGJQBB0tnTAAsWZkkAAAAAAAAAAJcCAAAAAAAACgTHegBB/NnTAAsMqHUAAAAAAAAAAGU2AEGU2tMACwToCGY0AEGk2tMACxAMVodcyQsnKwAAAADqVMZIAEHC2tMACwImdgBB3NrTAAscaUMAAIhVJ/kAAAAAAABmUgAA5kgAAGRkAAAFWABBgtvTAAsGxRioFmcrAEG+29MACw4nPKoyZRkAAAAAawxGZwBB2tvTAAsGhj0AAAYzAEH029MACwGOAEH+29MACxIkU6krJxEAAAAAAAAAAItMx54AQZrc0wALGmUuAAAAAAAAR2cAAAAAAAAAALcC5r9La8QuAEHA3NMACxjpJgAAAAAAAOp7BvYAAAAAAAAAAMk95s0AQf7c0wALAiZgAEGK3dMACxJGUAAAAACqE2YPAAAAAAAAZ7MAQbDd0wALAvQJAEG+3dMACwImsgBB7N3TAAsITQ0mMcs8R9MAQYze0wALHIpeBRcAAAAAAADGrAAAAAAAAOUVAACmugAA5n0AQb7e0wALEmYbAAAAAAAAAABoQGcMAABlagBB2t7TAAsCxp8AQere0wALCAR9ynoAAEhfAEGU39MACwTKcWbjAEGk39MACwJKcQBBut/TAAsCRtgAQdLf0wALAiaUAEHk39MACwoKBQAAAAAAAGkSAEGI4NMACwJMUQBBqODTAAsUCwfGAwAAJEUAAAAAjgKlSgAAx8kAQcbg0wALBOYoMAYAQdjg0wALFMoJAAAAAEdizxAAAAAAAACLAQc+AEGA4dMACwhIBYcZAADETABBtOHTAAsUchLlHgAAAAAAAAAAyHUAAAAA5vwAQdTh0wALCmkIpSMAAAAAFwEAQYbi0wALAqajAEHU4tMACwQwBYZCAEHm4tMACyCH0wAAAAAAAAAA7wYH1QAAAAAAAAAAiHsAAAAAAADuGwBBlOPTAAsEMAdnjABBouPTAAsCh9wAQcbj0wALCub7AAAAAAAA5scAQYrk0wALAiYQAEGi5NMACwLEQgBBvOTTAAsKDAAGP6tNB5wpKABB7uTTAAsCp64AQZDl0wALBC03ZwkAQajl0wALAilpAEG05dMACwisVgAASlFFJwBB5uXTAAsCJHIAQYTm0wALQApuAABoOwAAAAAFf2gWR0vqDSYpAAAAAAAAB+kAAAAAAAAAAMxpBuwAAAAAiWEAAAAAAABMCgAAAAAAAAAApWYAQdrm0wALDoR3Cg4AAAAAAACqIOU4AEH05tMACwQpKiYwAEGU59MACxgSFybpAAAAAClaBQIAAMQ8AAAAAAAAJiEAQfLn0wALAqVNAEGE6NMACxRJHQAAAADlZQAAAADoXGf4qBmmGABBqujTAAsCRicAQcjo0wALDGobhjiqSQAACRakKQBB4ujTAAsExorrBQBB/OjTAAsMCGwAAAAAhiUAAKaaAEGe6dMACwKm0gBBwOnTAAsG6ADnEGkxAEH66dMACwLnTgBBiOrTAAsQamgAAAAAAADIS2c5AABmegBBwurTAAsChUwAQdTq0wALCMgThC4AAMVqAEHq6tMACwqHugAAAAAAACZoAEGC69MACwJn2QBBruvTAAsCZRgAQcDr0wALBEhbp/kAQdTr0wALArYHAEHk69MACwRIIeVdAEH269MACxanZgAAAAAAAGZZAAAAAAAAhmwAAOZ3AEGi7NMACxyngwAAAAAAAMV2AAAmhwAAZ8cAAAAAAAAAAHQHAEHS7NMACwTnBYlVAEHi7NMACxLGyAAAJmEAAId/AAAAAAAAx4gAQYLt0wALAsQrAEGQ7dMACxZOHofiAAAAAAAA5XgAAAAAFgAkO8ojAEGy7dMACwbEY6hOxBsAQdzt0wALBitAJSpNJgBB9O3TAAsISBIAAAAAx80AQYbu0wALCiQ6AAAAAAAApEEAQZzu0wALBGolpxQAQa7u0wALAgaFAEG67tMACwKESgBB2O7TAAsYyx2n2QAAJ5puOAbkAAAAAAAAAACpW+U9AEH67tMACxKGlgAAAAAAAOVFqioAAAgcpgIAQZzv0wALBCkMx7QAQa7v0wALFiZbAAAAAKhG5FoAAIbzAAAAAAAA5UAAQdbv0wALAiaVAEHk79MACwLMYgBBiPDTAAs0aChHAC4ZAAAAAGUHAAAAAFIEAAAIcCR4AACmoAAAAADUBQAA7TsAAAAAAAAAAKdEAADkUgBBxvDTAAsG5GEoCERVAEHW8NMACwJmAQBB4vDTAAsKREEAAAAAAACEBgBB9vDTAAsC5C8AQYjx0wALAu4PAEGU8dMACwqpMUcYAAAAAGlPAEGy8dMACwLkeQBByPHTAAsUlA4AAG4GAAAAAERrAABmhuhCBTgAQebx0wALAkdMAEH88dMACwLoFwBBpvLTAAsmZyEqVOQnzAuHCwAA5kQAAAAASRvHr6oIBSAAAAAACHeG9wAAJGgAQeTy0wALAvEEAEH08tMACwwyCgAAAAAAAA4sR08AQYrz0wALAkRNAEGY89MACwQxCWQqAEG489MACwQtFeReAEHW89MACwJnhgBB5PPTAAsESDwmUQBB+PPTAAsMSDAFKgAAAAAAAGaBAEGa9NMACwaFcwAAJwkAQar00wALAmf2AEG+9NMACwYHqAAApj4AQdT00wALBMgF5WMAQeb00wALAociAEH29NMACwJFYABBkvXTAAsCxxMAQZ710wALAgazAEG09dMACwg3AwAAAAAn+gBB1vXTAAsCxDsAQeT10wALCGwLp7ZoGkRLAEH+9dMACxKGhQAAAACJD+VGAAAAAAAAx30AQaL20wALEuRbimUAAAAAZygAAAAAAAAFJgBBxvbTAAsChBIAQdr20wALHGVBAAAAABISR1sAAAAAqHoAAAAA5Q0AAAAAihAAQYL30wALAkZvAEGO99MACwaFNwAAZ98AQaj30wALAfAAQbL30wALBCb/iHQAQdr30wALKiV1AABmfAAAAADqHwAAAABFEeprpHgAAAAA7E4AAAAAAAAAAEauFgKEUQBBnvjTAAsGJnAAACUoAEGu+NMACwZHcwAAZU0AQdz40wALAoxpAEHq+NMACxZmzwAAh4kAAAAAAACmkgAARvGIIWUfAEGk+dMACwTIMOVYAEHC+dMACwIGXQBB1vnTAAsKBU4AAAAAAADH+QBBhvrTAAsKpowAAAAAAABESgBBtvrTAAsChCEAQcb60wALAmVGAEHY+tMACwxQAOYEAAAAAAAAhqYAQfL60wALAoY/AEGU+9MACx5MCIdjAAAAAAAAAADpQQAAAAAAAAAARgwAAAAAC0gAQbz70wALCE0PAACJIqYEAEHy+9MACwKlUABBivzTAAsWRCQAAAAASl+HoQAAAAAAAGekAABm9ABBtPzTAAsgSBpnEAAAAAAAAAAAq2MAAM8EAAB2AQc9AAAEdQAAJjcAQd780wALAmdKAEH+/NMACwLmewBBlv3TAAsOpFEAAGdBAAAAAAAA5nAAQbz90wALAhIKAEHQ/dMACxYONgAAAABEJwAAAAAAAAAACB0Hq8lCAEHw/dMACwppAwAAAAAAAI4BAEGM/tMACwgLIQdcAAAmzwBBsv7TAAscposAAOcPAAAAAAAABpcAAMahAAAAAAAAAACILQBB2P7TAAsEqw/HpgBB+P7TAAsCCWMAQYj/0wALBClqZFcAQZb/0wALAgR5AEHK/9MACwbGtIgPpzEAQeb/0wALAiVQAEGAgNQACwzoD0YrAAAAAKlAZQkAQZyA1AALAm4KAEGqgNQACwLmgABBuoDUAAsaxrcAAEV3AAAAACorBiZJMwAAAAAAAAAAxlsAQd6A1AALCsbjAAAAAAAAx+AAQYKB1AALAsYBAEGQgdQACwYrFCfprAgAQaKB1AALAkZzAEG6gdQACwakQwAAZU4AQdKB1AALAscUAEHmgdQACwImagBB9oHUAAsCpVkAQZSC1AALAghLAEGigtQACyrFUQAAAACKFyYiAAAAAAAA5EMAAEcz7QoAAAAApHUAAAAASxdEHwAAJt8AQdaC1AALCmanyDkneAAAhGEAQYKD1AALAiVCAEGQg9QACwRIO4efAEGwg9QACxoUA4V2AAAAAAAAAAAsUiZeAAAAAAAAAACrdQBB7oPUAAsKRVgre6VoAACn6ABBlITUAAsEiCSndABBqoTUAAsC518AQbqE1AALIiRQAAAAAAAAJppRDgAAaW4AAEoiBvsAAEbgrCMAAAAAZEcAQfCE1AALDOhmBXgMAidNAADkNQBBkIXUAAss60YAACkyAABKAKZhCzUlBAAAx/oAAAAASCIAAAAAR+sAAERjAAAAAAAAB+cAQciF1AALDAg45gUAAAAAAADmlQBB5IXUAAsCKTQAQfqF1AALAuYkAEGKhtQACwJlfwBBpobUAAsWhE0AAAAAAAAAAAs6AAAAAAAAAAAGGgBB7IbUAAsGSjcAAEp0AEH8htQACwSIQIYIAEGKh9QACwQGjQwNAEGeh9QACwJlYgBBwIfUAAsCaD0AQc6H1AALDuZYAAAAADABAACrDCU3AEHwh9QACwQKFIcxAEGeiNQACwTlVMkoAEHGiNQACwIHjQBB0ojUAAsGJlwAAIfgAEHwiNQACwRIKsRHAEH+iNQACwYGiWo9pzIAQY6J1AALAieHAEGqidQACwaH0QAA5pYAQbyJ1AALEil5RSwAAAAAAAAAAMhKAAApJQBB3onUAAsOh93qXQAArQQAAAAAhuQAQf6J1AALBiYg6RfESABBkIrUAAsCymIAQZyK1AALAuoFAEGsitQACwYqOEYma34AQbyK1AALAmklAEHKitQACwKkaABB2IrUAAsESgElKQBB5orUAAsCBqUAQfSK1AALCNITJFIAAOeUAEGIi9QACxb4AAAAyHlm8gAAJ9AAAAAAAAAAAA8BAEG4i9QACxQIJEUIAAAAAAAAAADKPecVAABmzQBB3IvUAAsGSEfFXepZAEH8i9QACxCrAQAAAADmmwAAAACoG4csAEGgjNQACwTMVibiAEGyjNQACxZkMwAAhQXvAwAAAAAAAAAAp1MAACdUAEHajNQACxbmogpYZSUAAAAAAABmIgAAAAAIGyfcAEGGjdQACwjnpAAAAACMNQBBoo3UAAsCRUAAQbCN1AALBi4G5AbSDABB0o3UAAsUhS0AAAAAAAAAAGsvAAAqc2R5iQYAQZKO1AALCkadAAAAAAAARoQAQaaO1AALAgRSAEGyjtQACwIHEgBByo7UAAsGp6tNAadLAEHejtQACwbFaAAAhX4AQYCP1AALBEgTpy0AQZaP1AALAoUqAEGij9QACwJGZQBBsI/UAAsC6z0AQcSP1AALDKggAADqQgYfAADELABB7o/UAAsE5kaoNwBBmpDUAAsKJlcAAAAAAAAGpwBBtJDUAAsEqnLGFQBB8pDUAAsChXkAQZKR1AALAuQrAEGukdQACwrEIwAAAAAJB8c2AEHCkdQACwLG8wBB4pHUAAsCRFwAQfiR1AALBCp55v8AQYqS1AALAkZmAEGaktQACwJFbABBqpLUAAsCZrcAQcaS1AALDoR5AABmLAAAAAAAAIUOAEGQk9QACxBoIaYXCw0AAAAAAAAAAKbJAEGuk9QACwKGDgBBzpPUAAsGxm4AAMQKAEH4k9QACwi2BQAAAADmawBBjpTUAAsGJvRKOKfdAEHAlNQACwKuLwBB2pTUAAsOxo4AAKaUAAAAAAAA5VIAQfaU1AALDsVpAAAAAApCAAArMUUvAEGQldQACwyuKGdwCVUH6wAARt0AQaaV1AALAgRRAEG0ldQACwgrF+cUAADG/wBByJXUAAsQKR+nzQAABBMAAAAAAACn2ABB4pXUAAsCxX0AQe6V1AALCoU0AAAAAAAAB2gAQYKW1AALIuUrAAAAAAAAAADRAAUFAAAAAIgHAAAAAAAAAABGqSldhFoAQbSW1AALCohg5/NrIocN6U8AQdCW1AALBIg+x9sAQeqW1AALLsbr6VilGQAAAACoeCZsAAAAAAAAxUIAAAAAAAAAAGlWAAAAAAAAqR1mNwAAx20AQaKX1AALAkawAEG+l9QACwJkfABB2pfUAAsMREgAAAAAAAAAACpuAEH2l9QACwbEZgAAZXMAQaKY1AALCoRzAAAAAAAAJVMAQbaY1AALAqftAEHCmNQACw7Hdk0+pQsAAAAAAABntQBB2pjUAAsOZ12JZ4ZiCzIHFwAAxxgAQf6Y1AALAkd8AEGQmdQACxDoTAUoAAAAAAAARXppaSRxAEGwmdQACw1IasR5AAAAAAAAAADYAEHqmdQACwKkPwBB9pnUAAsCJyIAQZKa1AALEiYZAAAAAAAAJ4IAAAAAAAAGggBBtprUAAsipVZLHcZgAAAEKgAA567UAgAAqGRFZClh5RSpYgAAAAAm1QBB7prUAAseRwG3AWUBAAAAAIgZBCEAAAAACgcAAAAApu8AAMU6AEGim9QACwLHlQBBuJvUAAsC634AQeab1AALEGVZAAAAAEl9AAAAAAAASiUAQZac1AALCGRsAAAAAIhaAEG2nNQACwIHYABBwpzUAAsSRoUAAAAAAAAAAG4IAADSFYR2AEHunNQACxKEXwAAAAAAAAAAaQkmEQAAhF4AQYyd1AALDgh+RGlrUAAAAAAAAGsIAEGwndQACwToEKRmAEHEndQACw4MXAAAqjBnLAAAAABKYgBB3p3UAAsChv8AQYqe1AALCsaAAAAAAAAAZocAQZ6e1AALEkaZAAAAAAAAAACILOYnCgGkMABB1p7UAAsSRTsAAAAAAABkNQAApjMAAERbAEHyntQACwKlLgBBhp/UAAsS52MAAAAAAAAn4AAAAAAAAEQoAEHQn9QACwUxC0ckSwBB6p/UAAsWBFRsV4boAAAAAAAAJVwAAAAAAACGyQBBlqDUAAsGJRKMD4duAEGmoNQACwJkMABBvqDUAAsG5lQAAMdEAEHioNQACwInowBB8qDUAAsCBEgAQYKh1AALDMZVAADmSwAAAAC0BABBoKHUAAsEqAzH1wBBrqHUAAsUxHcAAAAAAADlcAAAAAAAAAAAbBIAQdih1AALGOotAAAAAAAAAABGVgAAJFgtIgAAAADnbgBBhqLUAAsCRgsAQZai1AALAoZxAEGmotQACyamnQAAAAAsPmaaAACnNQAAAAAAAAAACnEAAJcBpg8AAAAAAAAkaQBB1qLUAAsEhmtIdgBBmKPUAAsICmAAAElgBhQAQcij1AALAuwhAEHYo9QACwjrWQAAaVenSABB9KPUAAsUyWsHJgAA5E4AAAAAAAAAAAhuJ70AQZKk1AALAqd6AEGypNQACwJENgBBvqTUAAsYxkQAAAAAijtHdApnJUUAAAAAiDgAAOgSAEHipNQACwiEYAAAhSTqEABB+KTUAAsICT8AAAAAJogAQZal1AALAudhAEGkpdQACwTLGScxAEG4pdQACwQJHQRyAEHGpdQACwomegAAAACIWUcMAEHapdQACwKlWwBB7KXUAAsQagIAAAAAAAAAAIVTAAAELQBBiKbUAAsCDFIAQaim1AALBDgBx1oAQcSm1AALDgkJAAAAAKaeAAAAAOk5AEHeptQACwzHtQAA5qCtHgAAqHsAQfym1AALBGkNhxQAQY6n1AALDqaEAAAAAAAAAABIAIU8AEGqp9QACwLmjABBuqfUAAsChDkAQcan1AALAoR0AEHWp9QACxCGSShOAAAAAAAAAACGCYgLAEGAqNQACwIODQBBnqjUAAtCZF8AAMRNAAAAAAAApR8AAEdEAAAAAMoNAAAKIIdyAAAAAGwEhRoAAAAASV0AAAAAAADKEgAAAABGtwAAAAAAAGaiAEHyqNQACwLGvQBBjqnUAAsKppkAAAAAAAAFZgBBpKnUAAsC7BMAQbCp1AALCMhbpWzND4bWAEHEqdQACw5JGQQdAAAAAAAAAACIGgBB3KnUAAsE6A1nfQBB9qnUAAsSBtYAAAAADhsAAAAAAAAAAIZAAEGSqtQAC0JGUQAAAAAAAAAAMQdmDAAAAAAAAAAAjCXGRwAAAAAAAAAA6H8AAAAAxyUAAOfpAAAEW4kfAAAAAKY5AAAAAAAAZigAQeCq1AALBOhgpzkAQfCq1AALCIsVAAAAAAQ6AEGgq9QACwgyCedaAADkfwBBvKvUAAsCKEgAQc6r1AALAqaBAEHgq9QACwQMI6VUAEH6q9QACxLmYwAAAAAAAAAA6BMAAMs3R9gAQZ6s1AALDGQxAAAAAAAAAAArEgBBuKzUAAsKlQIAAAAARjUKTABBzKzUAAsGKXoAAEofAEHcrNQACwyLDAAAAAAAAAAAxvcAQfKs1AALAoU7AEGArdQACwRKSoUJAEGordQACxToNwAAAAAAAAAAxEEAAAAA1wGHjABB8q3UAAsChxcAQYSu1AALEEktpyUAAAAAAADn2QAARBYAQdau1AALDgRtAADmZwAAAAALGkYZAEHyrtQACzpG9AAAAAAAAAAAikAHbQAAAAApJwQcAAAAAAsDAABoAUVEAAAAAAAAJ/JIHiUe1gUAAAAAAADJZyafAEG6r9QACwYmZ+ooxH0AQcqv1AALBofFiUDELQBB2q/UAAsCBtkAQfKv1AALEubxAABEZwAAAAAAAAAAaxFmKQBBmrDUAAsGByQAAIZyAEGqsNQACwIH7ABBurDUAAsK5rcAAEbEAABEMQBB0rDUAAsMZ/EAAOfWAABEUo0cAEHosNQACwzILgAAAAAAAAAA51sAQYCx1AALEmsoRj4AAOeEAAAAAAAAAABpEwBBorHUAAsCRXEAQcqx1AALAmaOAEH0sdQACwKKDQBBurLUAAsEBE3IcABByLLUAAsCiFYAQday1AALCuZmAAAAAAAAJCYAQe6y1AALECZVAAAAAAAAAAANAMUaiH0AQYyz1AALCO4CAAAAAObUAEGms9QAC0JntAAAAABxAkZZAAAAAAAAAAANCCRcAAAAACkrxtsAAAAAakjlBQAAAABqQ2URAAAAAAAAAACNMAAAAAAAAAAAph8AQfSz1AALBoofAAAsXQBBkLTUAAsQCD9kDQAA5GwAAAAAAACkHABBqrTUAAsS5HAAAAAA7AgAAAAApUTJAOQFAEHOtNQACzaFeihsJVgAAAAAAAAnFAAAAAAAAAAA6BFnpgAAAAAAAIatLASFWgAAAAAAAGUCAAAAAAAAZTEAQY611AALDMRpTBoAAAAAAABJDwBB2rXUAAsG5FYodSc+AEHqtdQACwLGWQBB+rXUAAsCpsUAQYi21AALBCkUJgYAQZ621AALFKRKAAAAAAAAxogAAAAAAABkZYtxAEHGttQACwLntwBB3LbUAAsWTAXn8QAAAAAAAMf7Sgjn+gAAAABLSQBBhLfUAAsSiwOnhgAAAAAAAKaYAAAAAMsHAEGqt9QACwLG3ABBxLfUAAsQNgMAAGo+h60AAAAAKAxFAQBB3rfUAAsCJTwAQfS31AALDKkExhBoE8c8AABGtABBirjUAAsC5UkAQZi41AALIMgmp5IAAAAAAAAAACkzh5AAAAAAAABGPAAAAADoIMdzAEHSuNQACwKGZABB7rjUAAsSJ54AAOQzAACFKwAAAAAAAIR+AEG4udQACwSyFGbhAEHKudQACwIEMwBB2LnUAAsEKSAmpQBBhrrUAAskRo4AAAAAAAAkHwAAAAAAAAVIAAAAAAAAAADuHAAAAAAAAAkkAEG8utQACwgpNue5LEfH0QBB/LrUAAsC7AoAQYi71AALDGxhR0MAAAAAAAClMwBBqLvUAAsC6D0AQbS71AALBOoXxwYAQdy71AALBEhC50YAQeq71AALAoa5AEH4u9QACwTpZSZMAEGGvNQACwKGPABBnLzUAAsQiXAAAAAAAAAAAOemAACG1wBBwrzUAAsCBVAAQdq81AALAubkAEH2vNQACwJEOwBBir3UAAsK5okAAAe87FFGgQBBnr3UAAsCJSYAQbK91AALFoeaAAAAAKg1JhsAAAAAAAAAAGpcxyIAQda91AALAoZYAEHivdQACwQG5iwdAEH2vdQACwIm/ABBgr7UAAsKBroAAAAAAADGxgBBlr7UAAsEBuGQAwBBrL7UAAsOqQUAAJEEAADOAke0SC8AQca+1AALAma8AEHcvtQACxDrBAAAAADGg6haZ/QAAIb+AEGAv9QACwQMcObpAEGYv9QACyKpZAAAAAAAAAAAx/8AAAAAAAAAACsCBVkAACRN6QYGKOghAEHMv9QACwiqNwAACxfnDABB5L/UAAsCaVIAQZLA1AALAoZUAEGwwNQACworKgAAAAAAAEw/AEHEwNQACwhqaaUJAABEOQBB1sDUAAsKh7HKL6YNyxFGKQBB+MDUAAsK8QoAAAAAAACLPQBBpsHUAAsC5poAQbTB1AALAmsaAEHawdQACwYmgwAAJygAQf7B1AALFif4AAAAAEgPAAAAAEQdAAAAAAAARokAQaDC1AALBKhEpx8AQcTC1AALCklBZhAAAAAArhIAQerC1AALFmQ/AAAAAAAAAABpZcZOAAAAAAAA5CoAQYrD1AALCgQ46knnOAAAp6wAQaLD1AALAuZHAEGuw9QACwLmkgBBwsPUAAsaplEAAAAAAAAm3AAAxpUAAAAAAAAAACol54wAQfrD1AALCMRUAAAAAJIUAEGsxNQACwZuBAAArQUAQbzE1AALAioPAEHOxNQACwqkDwAAAAAAAMbKAEHixNQACxYkWigSAAAAAAAAS3kHYwAAAAAAAGRZAEGCxdQACxrn+QAAAABICWVCAAAAADAIAAAAAAAALQ2GGwBBqsXUAAsaBngAAAAAAAAAABQAAACLNWYCAAAAACgyBwwAQc7F1AALCGbHkQ4AAKh/AEHgxdQACwrIXSf1AAAAAIkSAEGExtQACwhuCQAAAADmrABBqMbUAAsCaWEAQbrG1AALBsRKAAAHNQBBzsbUAAsKxpgAAAAAAACEbQBB+sbUAAsQpRAAAAAAAAAAAGgXAAAIAQBBmMfUAAsGqzUAAKhVAEG0x9QACwSIEAY7AEHKx9QACwhGdQAAAABJbQBB3MfUAAsCyGAAQejH1AALApILAEH2x9QACwTEZ6lXAEGEyNQACwRINcUrAEGkyNQACwRpS2YHAEG8yNQACwKtJABB2sjUAAsFJzdoFIcAQfLI1AALAsRkAEGAydQACyQuHQAAAAAAAAAAR/kAAGbZAAAAACgxAAD0BceBAAAAAAAApyYAQdDJ1AALCmgtAAAAAAAA7hUAQejJ1AALFEhTAAAAAGfRAAAGyAAAAAAAAAdlAEGSytQACwQEI8wGAEGmytQACwKkNABBzsrUAAsPJx8AAAAA6gzGHwAAxSAwAEH+ytQACwKmZABBksvUAAsCxssAQa7L1AALBuVTiHmkewBBwsvUAAsKJG8AAAAAAADHrABB2svUAAsC5WAAQfDL1AALJowwRxkAAAAAAAAAAA0CBkYAAAAAAAAnaQAAAADIRgAAAAAAAEh1AEGqzNQACwoFcgAAAAAAACeqAEHAzNQACxRLTYUdAADG5wAAAADIJ8UXAAAHrABB4szUAAsOpysAAAAAAAAAAOh2hvYAQfzM1AALAgkrAEGOzdQACwJEagBBxs3UAAsCxnEAQeTN1AALDG4CAABqFKcKAADkPABBnM7UAAseKhIAAHMKAAAAAKR+AAAAAAAAR/AAAAAAKxWlRUsIAEHWztQACxonlVAKAAAKLMU4MgcAAAAAp6aJMWYNAABFLgBBgs/UAAsChRkAQY7P1AALAkbVAEGoz9QACwRIMYeWAEG2z9QACw7lfQAAAAAAAAfUAADmvQBB4M/UAAsYqXoAAAAAAAAAAAaGAAAAAAAABFkAAKbLAEGG0NQACwIGWwBBrtDUAAsW5p4AAAAAAAAHyRcCAAAAAAAAAAClPABB0NDUAAsEKBNlAwBB/tDUAAsC5vgAQZDR1AALBo4GAAC0AgBBqNHUAAsCaGYAQbTR1AALFqtyAAAAAAAAAAAHYgAAAAAAAAAA7xAAQdTR1AALAso4AEHo0dQACwSJaubWAEH20dQACwKHagBBgtLUAAsMBHcAAAAAAAAAAApHAEGY0tQACwoJOAAAAAAAAGgIAEG+0tQACwpG5CpSAAArW0ZTAEHm0tQACwKkUwBB9tLUAAsSRTIAAAAACxMAAAAAAAAAAAdyAEGU09QACxJoBgcoAACkNwAAAAAAAAAAiyYAQbDT1AALGEswAAAAAOUdAAAAAEgQZwoAAOQRAACHKwBB1tPUAAsCxncAQeLT1AALAkQaAEGS1NQACwLENQBBrNTUAAsE6gClGgBB3tTUAAsCJ2QAQfLU1AALBgZ1AACFDQBBitXUAAsYpG5rSWUbyjGHLQAAp5EAAAAAySomHuklAEG21dQACwLGtQBBzNXUAAsIyR9ERgAARGIAQfLV1AALAsehAEGo1tQACxCoPQYbAAAAAAAAAABrG6cqAEHM1tQACwZLEMfYTBMAQfTW1AALEKhXhUsAAAAA6G0AAGkYRVMAQarX1AALCqbQAAAAAAAA5t8AQdrX1AALAoeZAEHm19QACwLkTQBB9tfUAAsCx2MAQZDY1AALDIoKRw8AAAAAAACmaABBqNjUAAsSqH4AAAAAJkgAAAAAAACGOYp0AEHQ2NQACyboA2UQAAAAAAAApksAAAAAAADGmwAAAAAAAAAAiQjFIqgUZSaoYQBBgtnUAAsCJgQAQarZ1AALDCaLAAAAAAhaJ/RqGQBBxNnUAAsEKTXGKABB3NnUAAsEKx6HpABB6tnUAAsiBTQAAAAAAACGogAA52kAAAAAylLFLAAAAAAAAAAA6Gjm4wBBqNrUAAsEzFFGvgBBuNrUAAsCaxQAQcTa1AALDE0nRHoAAAAAAAAkSwBB2trUAAsORXZINgAAAAAAAEwyZzMAQYzb1AALBqwBZ7dOMwBBrtvUAAsCZjwAQerb1AALAqRUAEGE3NQACwzJCAAAAAAAAAAAp68AQZzc1AALAokNAEG63NQACwIkYQBBxtzUAAsCZV0AQejc1AALAo4IAEGe3dQACxokPwAAxSgAAAAAjxSGTspRAAAAAAAAqAQGBABB4N3UAAsEiVMGEwBB+t3UAAsQpEgAAAAAAAAAAI4Fxg8qCwBBmt7UAAsCZr8AQaze1AALBGwZ5pEAQcDe1AALBGlCB5oAQc7e1AALFuZ1AADFU+scBG4AACbKAAAAAAAAp/QAQfLe1AALAuZ5AEGK39QACwJHHgBBnt/UAAsKpTQAAAAAyAFFaABBwN/UAAsCKjoAQczf1AALEEloBlapM+RqAAAAAAAAxEkAQezf1AALAksOAEGE4NQACwSoBSUVAEGe4NQACwrEGAAAAACrRiVJAEHC4NQACwpmVgAAAAAAACVKAEHe4NQACxYncowOAAAAAAAAAAAGqgAAAAAAAERkAEGg4dQACxgpVIYmAACkWMl95uwAAIQcAAAAAAAAB+YAQd7h1AALAgRMAEHy4dQACwqmxAAA5/4IEYZDAEGK4tQACwokcAAAAABJdcbqAEGm4tQACwqmtwAA5XwAAGQlAEG+4tQACwJFSABByuLUAAsOBTkAAAAAAADn0WwUp1YAQeTi1AALBBIGZF4AQYDj1AALHEsqAAAAAAAAAABmiAAAAAAAAAAA7FYAAAAAB7cAQabj1AALHud5AAAAAO0pAAAAAGb3AAAAAAAAAACoIcfDyU6GMQBB6uPUAAsM5+JKTwUAAAAAAMh4AEGE5NQACyYoAYYzAADHdwAAAABoSMQvAACEGgAAAAAAAAAAqngkVQAAAAAOAgBBwuTUAAsM5VEAAAAAAAAAAHEIAEHa5NQACzLmXQAAAAAAAAAA6DTmHAAAAAAKf4UlAAAAAAAAAACIDKYdAAAAAAAARqsAAAAAAAAHlwBBluXUAAsEZpguEABBtuXUAAsU5RgAAAAAbDUAAAAAAAAAAKZ2KFMAQZLm1AALAgdZAEGe5tQACwJGlABBtObUAAsE7CQGJwBB1ObUAAsN6RIAAAAAAAAAAIRJmABB7ObUAAsYzDMGDQAAAACqXuYgAAAlRgAAAAAAAAQoAEGa59QACxIkHAAAAAAAAAAAsQQnZgAAxXkAQcbn1AALDkb9axBlHQkCAADISaeQAEHk59QACwKqGwBBjOjUAAsEihHHMABBnujUAAsKB48AAAAAAAAGOgBBwOjUAAskixnlMuglR5gAAAAAAAAAAKgApSgAAAAAAAAAAIoBB2QAAOfeAEH46NQACwQNP6ZNAEGO6dQACwYGcwAABC8AQZ7p1AALCkYbjEgAAAhgxzgAQbzp1AALBhAAAACKVABBzunUAAsChhQAQeDp1AALAlYGAEH86dQACwQND6YjAEGg6tQACwRJHOYqAEHA6tQACxi2AwAAAACG4gAAAAAVAQAAAAAAALYCp4wAQYLr1AALDualAAAAAAAAAADpR8bHAEGi69QACwrmbwAAAAAAAOV3AEG269QACxDn26gVAAAAAAAAAABGIa4gAEGK7NQACwpmsgAAAACIJSaBAEGq7NQACxoGSQAAAAAAAAAAiAbFWwAAAAArG+cdAAAmjQBB1OzUAAsEiFuHAgBB7uzUAAsKRjQAAAAAAAClTABBiu3UAAsaBE8AAAAAqAoHewAAAAAAAAAAqHHFVusAp4oAQcLt1AALHuQUAAAAAAAAAAAII8UHAAAAACoEAAAAAOQsTReHegBB9u3UAAsiJ0kAAAAAAABlGgAAAAANKiYSAABGjQAAJ20AAAAACGnkIABBqu7UAAsChHIAQcDu1AALDG8TAAAAAAAAqjknDABB1u7UAAsCh6kAQebu1AALAiRKAEHy7tQACxYGrgAAAAAAAAAA0w8AAAAAAAAAAGaTAEGS79QACwJEFABBnu/UAAsKpl8AAGUXAADHoABBuu/UAAsaZk8AAAAA6wLkGgAAAAAAAEajAAAAAC0Mh1kAQfzv1AALAihSAEGO8NQACwJmJQBBnPDUAAsCzhAAQbTw1AALBExSRocAQcLw1AALAkf6AEHQ8NQACwQraAcfAEHe8NQACwjGzgAAAABqQgBB8vDUAAsCRk8AQYbx1AALBqVqq0cmHwBBnPHUAAsM6kEAAAAAAAAAAGaxAEG08dQACxSIAicGAAAAAAAABXwAAAAAAAAFWwBB4PHUAAsQKD5nxQAAAAAAAAAAyQeGIQBB/vHUAAsCJpYAQZjy1AALGuo9JxgAAAAAAAAAAEoNAAAAAGZrAAAAAO0CAEHA8tQACw6pZaZzAAAAAOgbpkwodwBB3vLUAAsCRFMAQfLy1AALCsRTAAAAAAkFBxsAQYjz1AALDGsgAAAAAAAACjdHiwBBpPPUAAsQSQlmOwAAAACMF2QRAACkYwBB0vPUAAsMhsQAAAAAAAAAAPUEAEH289QACwJGxwBBhvTUAAsMRiQAAAUdAAAAAOluAEG49NQACwQoQcQBAEHG9NQACwqmXAAAAAAAAAZ8AEHg9NQACwjwDQAAAAAkNQBB8vTUAAsep2IAAAAAAAAmxwAABt0AAAAAKx0AAAAAAAAAAOV1AEGe9dQACwZkdygcpR4AQbD11AALFC4eAAAAAAAAAADm8gAAAAAAAIagAEHy9dQACwKnWABBgPbUAAsCSEUAQZL21AALCobDAAAAAAAAZDcAQaj21AALAg4jAEG69tQACwokWwAAAAAAAIQrAEHS9tQACwbGXglqRCUAQfT21AALFqlnxrGuFycPAAAAAAlPh2UAAAAAi0UAQZT31AALDIo2hBVLQoVpDR0GewBBtPfUAAsCahIAQcb31AALAiVDAEHS99QACwhkawAAAABJaQBB7vfUAAsCZ6EAQYb41AALEEa5jEwFMQAAAAAAAMYg7gMAQar41AALBSReqUQEAEG6+NQACwIFVwBByvjUAAsCRGgAQdb41AALAmRgAEHy+NQACwolcwAAAAAAAEVUAEGQ+dQACwSIJoY3AEGg+dQACxirZIYWAAAAAM0i5yEAAAAAzRomPwAA55cAQcT51AALBGgw5iEAQfL51AALEqbNSgWGCwAAZDkAAAAATCmmwgBBlPrUAAsUKg5GAgAAAAAAAMbZAAAAAAAApXgAQcL61AALCMYWAAAAACoIAEHi+tQACwKmeQBB7vrUAAsIBykAAAAAiUkAQar71AALFEbfAAAAAEh4JvgAAAAAAACHJos/AEH8+9QACwKISQBBivzUAAsExUwsYwBBzPzUAAsCTCQAQeL81AALAgaOAEH4/NQACySIY+dZAAAAAMgoRRoAAAAAAACkV8leBTsAAAAAAABn88oi5oYAQaj91AALGik+JwUAAAAASE/FBSh4AABIZYRBAAAAAC0EAEHa/dQACwaFQgAApXwAQfb91AALAqaiAEGe/tQACw5GogAA5lMAAAAAAABEJgBBwP7UAAsMq1bn4wAAAAAAAOdeAEHW/tQACwKH8QBB9P7UAAsMEQvFFgAAAAAAAIf1AEGm/9QACwIkQQBBtP/UAAsUCTUnawAAAAAAAAAA6FMFKQAAJEIAQdL/1AALFoZZAACmvA4KZggAAAAAAAAAAGkHphEAQfT/1AALAuhhAEG2gNUACxRGuwAAAAAAAAAA7irHNWlk55OoVABBwoHVAAsOpqmwBgAAAAAAAAAAxkkAQeqB1QALAicpAEH6gdUACwKkOgBBkILVAAsQjjkAAAAA5tkAAAAAaHiGKgBBqoLVAAsIZsgAAAAATB8AQbyC1QALHMhQRRsAAEfgCwAAAAAAZUcAAOQ4AAAAAAAAhn4AQfCC1QALDKlKJhQAAKQrAACGQQBBlIPVAAsESygGNgBBpIPVAAsEqijlGwBBsoPVAAsmxEYAAAAAAABHris8hjYAAAQGKDlFTIleRU0AAAAAAABlXgAAJ5gAQeKD1QALAqQYAEGAhNUACwgIRIU9bg3HMwBBnoTVAAsS5H0AAAAAAAAAALAAAAAAAIbFAEHKhNUACwIkVABB6oTVAAsCZuYAQf6E1QALAqQUAEGMhdUACwQpZaZuAEGwhdUACwxJPgAAAAAAAEwmJQEAQcqF1QALBqQ2KlpFEgBB5oXVAAsCJhYAQfaF1QALAiasAEGihtUACw4FGQAA5HcAAAAAAAAG8QBB3obVAAsGZrMAACY8AEHwhtUACwTKEYQKAEH+htUACwrlfgAAAAAAAGQnAEGUh9UACwLpXgBBpofVAAsKBlkAAAAAAABG1wBByIfVAAsIyBsAACp7x7AAQYaI1QALBiefSkNHWABBnIjVAAsCbw4AQbKI1QALAqfeAEG+iNUACxjnNSoMJ1NJBacdAAAAAAAAByEAAAAAqBoAQeSI1QALCuk4AAAAAAAASHEAQYyJ1QALBgtOAADIRwBBqonVAAsKRCwAAAAAAADHwgBB0InVAAsUjwhnHWxapuIAAAAAAACndwAAxWcAQfyJ1QALCPICAAAAAAU+AEGSitUACwZmROkdBQsAQaqK1QALAsejAEG8itUACxQJCoeGAAAAAM4OAAAAAAAA6ztHIgBB5orVAAsUJD4AAAAAq1OnIAAAAAAAAAAAqAEAQYaL1QALEuZiSB9HUAAAAAAAAKeyanWkdgBBsovVAAsCRGYAQdyL1QALDsh6RykAAAAAAAAAACpEAEH2i9UACwZmdgAAhpQAQYaM1QALAgRxAEGSjNUACwKGqwBBuozVAAsEpFYrLwBB2ozVAAsW51YAAAAAKllHMAAAAAAAAAAACRDnxABB/IzVAAsEDTWnbwBBqI3VAAsCCHEAQbSN1QALBAlFRigAQdiN1QALEIkDBuIsBgAAAAAAAAAABuUAQZqO1QALEKc0AAAAAEk35jMAAAAAKyQAQbSO1QALBM4ZxA0AQcKO1QALAqcZAEH0jtUACwR3AmfAAEGCj9UACwaGpwAAR5UAQZiP1QALAqxEAEGqj9UACwIG1wBBvo/VAAsO5ScAAAAAAAAAABQOh5MAQeKP1QALAuZ4AEH2j9UACwKH8gBBnJDVAAsC6FsAQbCQ1QALBCtwhRAAQciQ1QALFMoExGgAAAAAAABlL0gbBQGKUiR/AEHokNUACxDtDWYw6VCnbQAAAACqBsdiAEGIkdUACwJOOQBBlpHVAAsORncAAAAAAABHMQAA5qoAQcKR1QALAkRuAEHSkdUACwInsABB9JHVAAsIyASHD8oq5xgAQZCS1QALEIxahE4AAAAAAAAAAIhkRyEAQaqS1QALBgcaAADmCQBBwJLVAAsCqFwAQdaS1QALGsZLAADGuqlmJsIAAAAA7BClMgAAAABIFoYMAEGKk9UACwokPAAAAAAAAEasAEGuk9UACwzlYigEZ5kpawAAaDoAQdqT1QALAuQ3AEHok9UACwTLCgQQAEH4k9UACxBoSQAAAAAAAIpWR38AAGQYAEGWlNUACwJGwQBBrpTVAAsIhlUAAAAAKCsAQcKU1QALEKUtAABm0gAAAAAKOwAALjYAQeCU1QALD5cDAAAAAAAArHwAACpYZQBBgpXVAAsYpRwAAAAAAAAAAMgMAAAAAAAAAABGbMh/AEGsldUACxD2BgAAaA4AAAAAAAAAAKZ0AEHKldUACwLFVwBB2pXVAAsWBthSA4Q8AAAAAAAAJxdKTSY0AABmZABBhpbVAAsCxp0AQaKW1QALAiRPAEG+ltUACwTnO8ogAEHOltUACw7GZwAAAAAAAAAASwPFCABB7JbVAAsQLxsAAAhQZgYAAAAADS1HxgBBhpfVAAsCh1EAQZKX1QALDsdfAAAAAAAAAABIJSdcAEG0l9UAC0bpUcUbSXEAAAAApn7oeyb7AAAAAAAAAADqPgAAAAAAABIbRRMAAAAAAACFWQAAh2kAAAAAAAAAAKhNhh8AAAAAAAAAAIldAEGgmNUACwXuDAAAVwBBwpjVAAsSB0gAAAAAAAAGUQAAAAAAAGUpAEHsmNUACwwMTwAAAAAAAMhAZQ0AQYiZ1QALDGlqAAAAAAAAAAAEPwBBrJnVAAsE9ABlbgBBvpnVAAsCRXMAQdCZ1QALBGkLJXwAQeCZ1QALBggZZBBYAQBBgJrVAAsYqS0nswAAAAAAAAAAigPlDAAAAADIY6V+AEGomtUACyTsBKfwAACmagAAAADqIeZAAAAAAAAAAABOKgAAAACEJck6ZTQAQdia1QALAoloAEHmmtUACwIm8gBB8prVAAsIJDEAAAAAqCwAQYSb1QALAutXAEGym9UACwJlMABBwJvVAAsSaAmFWKs456gAAOQlAAAAAIpgAEHim9UACwKkXQBB/pvVAAsKJoUAAAAAq1lGHABBkpzVAAsaRW/uNUZOAAAAAAAAAABKWAAAAAAAAG0GRFcAQcKc1QALEoZnAAAAACoCAAAAAAAAAAAn8QBB9pzVAAsChgoAQZSd1QALDHMD52xMPgAAqgwm4ABBrJ3VAAsCajYAQbid1QALCMp4AAApEIfNAEHandUACwSnfMg+AEH2ndUACxLkZgAA5/AAAAAAAAAAAEkMh9sAQaCe1QALDBgBAAALFMeCAACHPQBBuJ7VAAsEKBCmBQBByJ7VAAsEKCzHRQBB1p7VAAsWJWIAAAAAAAAmj6kXAAAAAAAAVwMlLABB9p7VAAsKBv0AAAAAAADFSwBBoJ/VAAsEEATnagBBvp/VAAsaZvsAAAAAsgCEAAAAAACrOYdfAAAAAAAAJrUAQfaf1QALEqa0AAAAAAAABpIAAAAAAAAmHQBBqqDVAAsi5h8AAAAACRsAAAAAAADLIwAAAAAAAHcAAAAAAAAAaloEQwBB1qDVAAsKpyMAAAAAAAAHRgBB6qDVAAsCRFYAQfag1QALDMebAAAAAPMHAAArBABBjKHVAAsEDEHH6ABBqKHVAAsMy04AAAAAAAAAAEVFAEG+odUACwIlfQBByqHVAAsCxTcAQdqh1QALCiakAAAAAKlohk8AQYSi1QALAssiAEGWotUACwyEbAAAAAAAAAAASn4AQc6i1QALCueZAAAEJgAARz8AQYSj1QALKFYDAACoCwewSmNkaQtYAACtI0UOqDxHcCkSAABoAmf+AAAAAAAAp/EAQbqj1QALAgfYAEHMo9UACwJIXQBB3KPVAAsEaHyG9QBB9qPVAAsGxsEAAEZtAEGmpNUACxpEfwAAAAAAAMRlyw8AAAAABp4AAAAAyGVldwBBzqTVAAsCpnoAQeCk1QALCmhyBQcAAAAAlAwAQfyk1QALDMtPAAAAAAAAAABFXABBmqXVAAsCxV4AQb6l1QALFgeLAAAAAM4aAAAAAAAAqRAAAI0YBxUAQd6l1QALLAaQAACnmwAAAABIQyYV6mwG4wAAAACoM6YQAAAAAAAARnoAAAAAbAWmC2kuAEGWptUACxTFQSkDAABMXuQpAAAAAAAAAADLFgBBwKbVAAsE6AQlSwBB0qbVAAsMpBZILgAAAACGzsgsAEHwptUACwgNFsYjAACHYgBBgqfVAAsS5piIYccfaH0GcAAAAAAAAOe0AEG4p9UACwIMXQBBxKfVAAsQ0g8AACsFhGIAAAAAAAClTgBB6qfVAAsCpSQAQbKo1QALFIQ0rgSG7QAAAAAAAAAAzENHxKh3AEHUqNUACxCoLucDAAAAAAAAAACqD6QoAEHwqNUACwhqKAAAAABmwQBBkqnVAAsCB5gAQaCp1QALCM8YJu6pTucBAEG0qdUACxWPAmYJ60MnqQAAAAAAAKdCAAAAANUAQdap1QALAkVDAEHuqdUACxpEKgAAAAAAAAAAcQEGAAAAAACKI2VSAAClewBBmqrVAAsIB2oAAAAAaj8AQbKq1QALEoQX63uFbgAAAAAAAAAAkAfndwBBzqrVAAsUps4AAAAASHMnKgAAxE8AAAAAij4AQfiq1QALAswUAEGSq9UACwJHNABBuKvVAAsCCF8AQcar1QALAqafAEH8q9UACwJIYABBjKzVAAsEah4kCwBBoqzVAAsOhq4AAAVGAAAAAGkARs8AQdCs1QALEEpJAAAAAOeeAAAAAAAAJT8AQY6t1QALAqZPAEGyrdUACwZm8yoFpzcAQcit1QALHCgHpBcAAAAAai4AAAAAAAAAAARFAABmbgAAZnMAQaqu1QALDGdtAAAAAAAAh98xBgBBzK7VAAsIqlIAAAAAJ/MAQd6u1QALAkZjAEGOr9UACwrmjQAAAAAAACVdAEGmr9UACwKFCgBBtq/VAAsGRTMAAAR6AEHGr9UACwLmVwBB1K/VAAscahdFKAAAAAAAAGUcAAAAAAAAAAAJRgAA8wNnrgBB+q/VAAsaRzoAAAAAAAAAAGpQ5hQAAAAAAACGsgAAhTMAQaaw1QALBMaLSEYAQbSw1QALAgsgAEHCsNUACwJm3QBBzrDVAAsIx5SJEAAATwgAQeqw1QALCqQnAAAAAAAA5QcAQYKx1QALAma4AEGSsdUACwwEJAAAAAAAAAAACUwAQa6x1QALBiaZAACnlABBwrHVAAsChrcAQc6x1QALBCZWCg8AQeCx1QALEDcAAAAuKQAAAAAAAAAARxwAQfqx1QALEufnAAAAAKk5AAAAAAAAAABHqABBlrLVAAsIpgoAAAAAbiUAQdKy1QALCmaSAAAAAAAAhHoAQeyy1QALBKlP5SIAQfqy1QALF6QkAAAAAAAAAAAJQiUCAAAAAAAAAAC2AEHEs9UACwIWBgBB1LPVAAsCKksAQeKz1QALBmVhAACEGABBkrTVAAsGRqUrXAReAEG2tNUACw6HMw4YBwoAAAAADAHHtwBB1rTVAAsCJG0AQeK01QALEGZoAAAAAAAAAAAIIMYESnsAQYS11QALCGoLJyDIIuVxAEGctdUACwSoXeQSAEG4tdUACxCqewAAAADFewAAAABJC0UYAEHStdUACwIlNQBB3rXVAAsCxGAAQfS11QALFMxQZGcLXgAAAAAAAMlSAADLAqcCAEGUttUACyjqC+YdAAAAAAAA5jUAAAAAAAAAAA8ARW0AAAAAKyEmCAAAAAAAAMaoAEHittUACwLn6wBB8rbVAAsKJGUAAARXAABGhgBBorfVAAscxU4AAAAASGQAAAAAAAATBwdhAABEeQAAAACpYwBByLfVAAsUCjIAAAAA5vMAAAAALQUAAGwBxg4AQey31QALDGof50wAAAAAAACHggBBjrjVAAsCJRwAQbK41QALEEQuAAAAAAAAAAANDQcGKhoAQfq41QALAkZ0AEGSudUACxTGoAAA5l4AAAQPKTAAAAAAAACqNQBBtrnVAAsChWYAQcS51QALEuoYAABXAeYSAAAAAAAAJl+oLQBB6LnVAAsk0QXHhwAAAAAAAAAAawEGy1YHBSsAAAAACX6G6QAAAAAAAAVvAEGqutUACwLkWABByLrVAAsCCTcAQei61QALDElyJu8AAMV3AACnbgBBjrvVAAsW5GmLIgAAySUkCAAAAAAAAMc/AABHvQBBsLvVAAsEDBNkJABBzLvVAAsESyOkSQBB6rvVAAsKRBAAAAAA6zlFBQBB/rvVAAsChS4AQZK81QALAgVVAEGkvNUACwwoeqb5AAAAAAAARGUAQcK81QALEsetAAAAAAAAhFAAAAAAamzEegBB4rzVAAsih0MAAGcPAAAAAAAARvcAAAAAAAAAAKhi5k0AAGbXAACGmABBkr3VAAsCBzwAQaq91QALAgZvAEHEvdUACwRoJWf5AEH0vdUACwSKYmYWAEGEvtUACwTpNYUTAEG+vtUACxamq/YEBgqMGAAAAABmPwAAAAAAAMZQAEHevtUACxbHlwAAAAAAAAAAy3MAAAAAAAApAEcOAEH+vtUACwLENwBBxr/VAAsjRj0AAAAAAABmPQAABsYAAAAAaD9HHwAAAAAAAMQTSQFHLTMAQfy/1QALHAkzhhyKawY8AABmYQAAAAAAAKRFAAAAAMgRpxgAQa7A1QALGka6cAFHL4onJoQAAAAAVwJmSGslR8EAACQWAEHawNUACw5lMwAAAAAAAAAA6lrnNgBB8sDVAAsCB78AQYDB1QALEE8HAABKPAAAAAAAAC4/BvQAQabB1QALAkUeAEG2wdUACwwldwAAAAAAAAAAS2QAQdbB1QALCkUkAAAAAOtihQYAQfbB1QALAgQOAEGCwtUACxKGgAAAAABKEQAAAAAAAAAAZ+IAQaDC1QALGMp0puMAAAAAAAAAAGguxAQAAAAAAAAHogBB1sLVAAsCZVoAQfLC1QALAkamAEGCw9UACwbnnAwlpQ0AQZLD1QALDoZSAAAAAAAAAADJIeZJAEGuw9UACxpGiCkKAAAAAAAAAADmMAAAAAAAAAAAKB9HKABB1sPVAAsChrAAQezD1QALBMpBBU8AQfzD1QALBGgdBhIAQYrE1QALCoZ1AAAAAAAAhwYAQbDE1QALBKgmhRgAQb7E1QALEAfvAABHoQAAxFUAAAAAKk4AQeTE1QALGoszAAAAAAAAAABlBQAAAAAAAAAAbQHneMxeAEGaxdUACwKEGwBBsMXVAAsEKG1nAQBB3sXVAAsHR28AAAAATQBB9sXVAAsGx90qMeUgAEGIxtUACxBJZgc5AAAAAGgfRhYpMSUMAEGixtUACwRGVAwVAEG0xtUACwTyE+bMAEHIxtUACxhzB8d0AADkFwAAAAAAAAAASSulFAAApW0AQfzG1QALAggQAEGKx9UACwInogBBmMfVAAsQjhQAAAAAAAD3AYcQKB4nhgBB2MfVAAsMiByGKLYGAAAAAMdxAEH0x9UACwjJWydYKBskCQBBjMjVAAsIiE+lMAAAJrAAQZ7I1QALDKZvAAAAAAAAAACoAgBBxMjVAAsULFoAAAAAAADodwAAAAAAAAAAJrMAQfDI1QALBMwVpRcAQYjJ1QALIMgCRgAAAAAA62VHLAAAAAAAAAAALDUAAGgzhgezAWfJAEHCydUACw7GuItKAAAAAMYxAABHBgBB9MnVAAsECxjnkABBgsrVAAsEBErqGwBBlMrVAAsaqB4HCAAAAAAAAAAAziIAAIhLAAAAAMa7KiEAQbzK1QALBMwmZ9wAQeLK1QALAiUQAEH2ytUACwKGqQBBiMvVAAsCLT8AQZjL1QALCAt9AAAAAMZ4AEG+y9UACwLmaABB2svVAAsCpU8AQfjL1QALIMlJAAAAAAAAAAAFIwAAAAAAAEatAAAAAAAAJSMAAAeFAEGizNUACyqmcgAAAAD1AWdFAAAAAMl+ZusAAAAAAACmeAAAAACtDicEAAAAAAAAJWQAQdbM1QALBqRtAAAGZwBB8szVAAsCpC0AQYDN1QALEMtg5QAAAMY1AAAAAOocBS0AQaDN1QALDMlmhlwAAAAAKHSnuQBB0s3VAAsMhGoAAAAAAAAAACkCAEHqzdUAC0YmfQAAAAAAAAAAbwTkZwAAAAAMMCc5AAAAAAAA5qgAAGcDAAAAAAh7AAAJIQVFAAAkMgAAAAAAAMZYAABmlwAAAAB3AaQZAEHIztUACw6qAGdIAACkWQAAAABofgBB8s7VAAsCpGQAQYrP1QALCiQ9AAAAAAAABoAAQabP1QALAodvAEHAz9UACwwpOwAAAAAAAGxSBmwAQdjP1QALCAoTZ2YAAGcGAEH0z9UACwJJEABBgNDVAAsMqBwAAAAAAAAAAERUAEGe0NUACxJEYIsG5QkAAAAAAABG0AAAJjMAQb7Q1QALBmYYAAAEVgBB2tDVAAsGJW/IFQQUAEH60NUACxYGbQAAxnIoR4chAAAAAAAABpkAACaqAEGi0dUACwLFLgBBrtHVAAsMZVsAAAAAAAAAAMsXAEHI0dUACwZKGUU/iTcAQYjS1QALCGhoAAA3Ase+AEGa0tUACwynOwAAAABKfMarkgkAQbTS1QALCGgs5yMAAKatAEHI0tUACwzoOAUwAAAAAAAABSEAQezS1QALAih9AEGG09UACw6GAwAAAAAAAGRq7BXnLABBpNPVAAsE6iOEXABBztPVAAsCJmsAQezT1QALBGlmRq8AQfzT1QALBM0VBRwAQa7U1QALAifOAEHU1NUACwToUaRHAEHo1NUACwQLEOcrAEGC1dUACwLFcgBBqtXVAAsC5lUAQb7V1QALCqa+AAAAAAAAJH4AQdbV1QALAoQqAEHs1dUACwaqawAACxYAQYTW1QALCBEMJXsAAORMAEGa1tUACwLn7wBBptbVAAsCZo0AQbbW1QALDuQeAAAAAAAAAABoA+cCAEHU1tUACwLNBABB/tbVAAsC5H4AQYrX1QALAgaIAEGW19UACx4mxgAAAAAAAAAAahwAAAAAAADIOwYtAAAAAAAA5wsAQcDX1QALHGhXAAAAAAAATgMAAAAAAAAAAOeLAAAAAAAAZFwAQfzX1QALBKlcZAgAQYzY1QALAgg6AEG42NUACxBOBQAACgwAAAAAAABQA8UqAEHU2NUACwhoGQAAAAAkOABB8NjVAAsECSDmJgBBgNnVAAsCyl4AQZLZ1QALEmVnAAAAAAAAAACsSAUIAADnggBBrtnVAAsCBiQAQbrZ1QALAuarAEHS2dUACwKnowBB5NnVAAsEDC+GAQBB8tnVAAsORxMAAAa+AAAm2+wLxj4AQY7a1QALBqQhaCSnlQBByNrVAAsQ9AEAAAAAAAAAAKanAAAmfwBB6NrVAAsMKmtG4qhCAAAAAKa1AEGc29UACwSIaGQaAEHA29UACxBwAgAAiBMAAAAAAAAAACV+AEHq29UACwKGZgBB/NvVAAsQFwCFHAAAAAAAAGeNAACGnwBBpNzVAAsMKmoG4AAAAACpMGUkAEH03NUACy6qQQAAAAAAAK44AAAAAAAAAABHUwAAAAAAAMQ0EQBlLAAAAAAAAAAAqxQAAIkgAEHC3dUACwIlbABB0t3VAAsOJssAAAAAAABFHQAA56wAQfDd1QALDEgmAAAAAAAATGQm8ABBiN7VAAsOjRYAAAAAAAAAAAekyWUAQare1QALIGVYAAAAAAAAp7pqAacHrFsAAAAAAACpKgAAAAAAAE4MAEHg3tUACwLIfgBB8N7VAAsgzxHGDAAAAADXAwAAAADnZgAApoIAAAAAAABH8QAABr0AQZ7f1QALCOYKAABmm6keAEG039UACwQIBocIAEHI39UACxzID6cJKU5EdQAAAADqKwAAAAAAAMoVhtAAAGdYAEH639UACwJlMgBBlODVAAsI1wAAAAAARiMAQajg1QALDAkBhAUAAAAAai1nDgBBzODVAAsYKUQnXwAAAABpaMacAAAAAAAAAABIdAbyAEH04NUACwKsUQBBgOHVAAsYCCsAAAAAZrkrVCYXAAAAAIg5pwsoXsU7AEGi4dUACwKFfwBBsuHVAAsK5AwAAAAAAABkPgBByOHVAAsC6hkAQebh1QALBgQMAAAHeQBBjOLVAAsBagBBluLVAAsO5zEAAAAAAAAAAAkcZkYAQa7i1QALAgZYAEHG4tUACwLmwgBB8OLVAAsQqGsAAAAAAAAAAEZ2rClFXQBBjuPVAAsCxHEAQarj1QALAoZRAEHS49UACwImrgBB8uPVAAs6Rr0AAAAAAAAAACoZAADKP6dZAAAAAAhCAAAAAAAAAACEAgAAAAAAAGacAAAAAAAAZpEAAAAAAABmJgBBtuTVAAsCZ4gAQc7k1QALCqU1AAAAAAAAJG4AQeLk1QALAqRNAEHy5NUACygGXAAAhisAAIVsAAAAAAAAAAAoNgAAAAAAAGpg57oAAAAAAAAAAOoaAEGk5dUACwKNDwBBvOXVAAsC7AYAQczl1QALGBMOxwcAAARrzCEAAIhHAAAAAAAAAABmdQBB8uXVAAsCBiwAQYbm1QALDORQAAAAAAAAAABSAQBBoObVAAsCihsAQbzm1QALIA46AAAAAKQNAAAAAAAARtoAAAAAAABmQAAAAAAAAMdGAEHo5tUACxJqCAQFAAAAAElaB3wAAAAAa3MAQYbn1QALAiePAEGe59UACwIHRwBBvOfVAAsS6R4AAAAAAAAAAKRQAAAAAAwpAEHm59UACwJmqgBB8ufVAAsCBqAAQYjo1QALCPYAhQMJLUcUAEGm6NUACw6GXwAAAAApaMZrAAAFawBBwOjVAAsqClyFCwAAAACIdgbzAADmuOoHxUkAAAAAAAAmvgAAAAAAAKZYAAAAALQHAEGc6dUACyBpPAAAAAAAAAAAppcAAAAAAAAAALEDxH8AAAfWAABGOgBB1unVAAsCZFsAQeTp1QALAm4VAEGI6tUACwIqHgBBoOrVAAsEiHim+gBBwurVAAsKhokAAAAAAABHdwBB3urVAAsqx/QAAAAASASmREx8AAAAACc4MhFHagAAAADIU0QSAAAAAAAAAADJQOYTAEGY69UACwjtEgAAAABmgABBtOvVAAsM6noAAAAAAAAAACd8AEHs69UACwSqEac+AEGC7NUACwKFOABBmOzVAAsEKB2lEgBBrOzVAAsKzEgAAAAAAAAoZABBwuzVAAsMxAgAAAAAKi4AAJAEAEHc7NUACwiMGSdayjUnHgBBuu3VAAsOJuMQAsaGqn8AAAAAxTIAQdLt1QALAqYIAEHe7dUACwrH5AAAAAAAAAdnAEH67dUACwJFZwBBoO7VAAsCCWYAQcLu1QALCgV9qFmn5gAA5zQAQdzu1QALIsg/AAAAAAaDAAAAAAAARk0AAAAAAAAEQQAAAAAAAAAAyHsAQa7v1QALAiQoAEG+79UACxLnjQAAAAAocwAAAAAAAAkDpTEAQe7v1QALHgZrAAAAAAAAZxFNI6V6AAAFJAAAAAAAAEfsaFEEBwBBnPDVAAsCrCAAQbTw1QALDihNZq8AAKaWAAAAAGtGAEHS8NUACwKmKQBB3vDVAAsCJC4AQfLw1QALCsZNAAAAAAAA5q8AQZTx1QALCApOBxQAAGQtAEHw8dUACxhpTQAAyxWGJAAAAAAKUgZNAAAAAAAAplUAQaLy1QALCudQAAAAAAAA5U4AQdLy1QALIGaeAAAAAAAApuAAAAAAAACH0gAAAACpOgAAaELHmSsJAEGE89UACwKMIQBBkPPVAAsIyQzGRaoNJQgAQcDz1QALAmhKAEHM89UACwTKLgflAEHc89UACwcLAgAAqTLGAEGG9NUACwYlbgAA5roAQZ701QALAsURAEG09NUACwivAkU67AIlIABByPTVAAsErAmHMgBB2PTVAAsCCFkAQfz01QALHIhrBucAAAAAjFGmTgAAAAAAAAAAuAEkLwAAR+YAQbr11QALCqa7AAAAAAAAR+4AQd711QALEmQ9Sh1kFQAAAAAAAAAA6k5HlABBiPbVAAsGaXQAAEsVAEGi9tUACwJmxgBBxvbVAAsCpV8AQfL21QALEgU1AAAAAEhZAAAAAAAAAACnVQBBkPfVAAsCqiMAQZ731QALAqQ1AEG099UACwTqCEcCAEHM99UACwSODodnAEHc99UACwIqJABB7vfVAAsKZFQAAAAAAAAGsgBBgvjVAAsK5lAAAAAAAADGpgBBqPjVAAsEiwQmGgBBuvjVAAsKxCoAAAAAAAAEdABBzvjVAAsKx+XUDgdry1HEJwBBhPnVAAsQEwBnculvxjgAAAAALEAnsgBBoPnVAAsG6mIAACwTAEGy+dUACwiEY6lxpjctKwBByvnVAAsSRkgAAAAAAABmrQAAAAAAAGVFAEHo+dUACwLIXwBB/vnVAAsCp0MAQZr61QALAgZuAEGm+tUACxZGvAAAAADregAACWAAAAAAAAAAAARJAEHg+tUACwIsXABB/vrVAAsGRBzIA0U1AEGs+9UACwKzDgBB2vvVAAsOxzkAAAAAAAAkMAAAxTEAQfr71QALEmQrAAAAAAAAAACpD2ediFAFEQBBqvzVAAsCpzoAQbb81QALAueqAEHO/NUACwLlWQBB6vzVAAsC5rEAQf781QALDqZdAAAAAAAAAABIRKdQAEGY/dUACwisIgAAAABmnwBBrv3VAAsUpjgIQ2RFAAAAAGp7Z4oAAAAASgsAQdL91QALAoRrAEGC/tUACwYkIAAAB90AQar+1QALAuaFAEHG/tUACwZmCgAAZGgAQdr+1QALAsb6AEGI/9UACwIJVwBBqP/VAAsE6QvH1gBBuv/VAAsGRQMAAMREAEHK/9UACwKmcABB2P/VAAsQyGYAAAAARg8AAAAAAADmZABB8v/VAAsaxyAAAIVNKEtEBAAAAABJFQAAAAAAAAAAJEMAQZ6A1gALFoUpAAAAAA8apu7IFqYgAAAAAAAAJtcAQb6A1gALAqR0AEHigNYACwYmyQAA528AQYaB1gALCoVlAAAAAMl1hu8AQZ6B1gALDkdhAAAAAAAAJBEAAEakAEG6gdYACwKmzwBByoHWAAsC5sYAQdiB1gALAotmAEGEgtYACwspFyULAAAGkcwcxQBBsILWAAsE6wemAwBB3oLWAAsOhtkAAAAAKBZHFQAAJvUAQYSD1gALCGsLAAAsAocFAEGeg9YACwbFIQAABSUAQbKD1gALAma+AEHIg9YACwOrXuQAQeCD1gALBEpCh0kAQfaD1gALAkZiAEGChNYACwqHSGhOBwvpNyYHAEGchNYACwSoaeZbAEGqhNYACxblA+wBAACKOSVBjAEGNQAAAAAAAMeiAEHOhNYACw5lSgAAAAAAAKUBiUQmDABB+oTWAAsGB7iLOOfcAEGUhdYACwJxDgBBooXWAAsi5sAAAOeKAAAAAAAAAAAoAAAA6CwFPQAAZiEAAAAAAADm9wBB0oXWAAsUZpAAAObEAADGs+kDAAAAACUvsQwAQYCG1gALAok7AEGShtYACwLn/ABBnobWAAsOh+UAAAAAAAAAAHAEZWkAQbqG1gALHkRFAAAAAAAABUMrTuUZAABnqwAAAAAAAAQ1KGIHKgBB/obWAAsCBHAAQaCH1gALDmsDx10AAAAAAAAAAMwdAEG4h9YACwLsLwBByofWAAsGZEuqWmQBAEHih9YACwKEOwBB7ofWAAsCBsIAQf6H1gALAgRVAEGgiNYACwJrNgBBwojWAAsQ57IAAAAAtAEFDgAAAACKLABB5ojWAAsMZvUAAAAAAACGm0wCAEH+iNYACwJmbABBjInWAAsMSQaEWCoJB0oAAMQ+AEGkidYACyIqFGYrAAAAAAAAAADIOiQEAADHHmhHRgEAACY6yEwAAKodAEHQidYACwgNA0UCAABGPwBB5InWAAsENgSkJgBB/InWAAsUiREAAAAAAAAAAAaEAAAAAAAABtUAQZ6K1gALAoaBAEGyitYACwpmpAo2xQoIIYVBAEHcitYACwJqDQBB6IrWAAsMag/kcwAAAACqd6ePAEH+itYACxJFYQAAxT6IGAAAAAAAAAAABqQAQZ6L1gALAuVqAEG0i9YACwyqBQevAAAAAAAAZH0AQcqL1gALAiaJAEHci9YACwQoRIdMAEH4i9YACxTLBgAAAAAAAAAAhxUAAAAAAACmgABBnozWAAsYBEcAAAAAAACEWypNAAAAAMZ5zQune6hbAEHCjNYACwqn3wAAAAAsU+f7AEHYjNYACwTKZOUjAEHmjNYACwJmwABB/IzWAAsEzRZnwwBBko3WAAsChzwAQZ6N1gALAubKAEGwjdYACwjIbSblAAAmxABByI3WAAsIrAsAAGhZRHwAQdqN1gALBuQHAADkSQBB7o3WAAsWpV0AAAAAAAAAAGxExS0AAAAAAABn2gBBko7WAAsCJwsAQbaO1gALIua2AACGYKpvAAAAAAAAFAYAAAAApXUAAAAASlYn30sNBzcAQeyO1gALCBEEAACJKQQbAEHCj9YACyiFagAAAAAKNIdGAADEcgAAhtwAAAAAeAAAAAAARSIAAAAAAAAAAKg+AEH4j9YACxJqauVcAAAkBgAA5m0AAAAA6AUAQZaQ1gALBiRsAABGlgBBqJDWAAsE6QUFIgBBwpDWAAsO5rUAAAAAAAAAAGlv5+4AQfKQ1gALAiRfAEGGkdYACwzkMgAA5xYAAAAATT0AQaCR1gALBGsEZlsAQbKR1gALAmRmAEHOkdYACy7kRwAAAAAAAAAAsQVHZgAAAACrCcYbAAAAAAAAAAAsagbrAAAAAAAAJk8AAIajAEGQktYACwLKCgBBrpLWAAsCJGYAQcKS1gALCkVuAAAAAAAARnIAQeCS1gALDCpsAAAAAEQ16DFGBwBB+JLWAAsESUPHDABBnpPWAAsCh20AQdCT1gALCmkRxUYAAOcHkgEAQfST1gALBGgARg4AQYiU1gALAghIAEGalNYACwKldABB0pTWAAsChlYAQeyU1gALAgpeAEH+lNYACwzkLgAAZn4AAAAACQwAQZyV1gALAo0SAEG0ldYACwwoKgcHSlMAAMgeRTEAQdCV1gALHKk2AAAAAAAASj8AAAAAAAAAAGZ9AABnkQAABCkAQfyV1gALAgh9AEGIltYACwQIXaQMAEGWltYACw7FWgAAAAAKFgAATBImAQBBypbWAAsC5GgAQdiW1gALAuwbAEGMl9YACwzSHmbxqwMAAAAAZ90AQaKX1gALBsZpygClEwBBupfWAAsOZW0AAAAAqTulYCwW5E8AQeaX1gALEmbaAAAAAAAAAADNEyZtAABkUgBBnpjWAAsC5TAAQbiY1gALCohTZG4AAMYJjE4AQdqY1gALBoa2AABGeABB6pjWAAsChTkAQYiZ1gALGEsE5BgAAAAAAACGME47AADrIQAAqSkGTABBrJnWAAsMNgYAAIx7AABoWCZNAEHGmdYACwKGXgBB0pnWAAsC5sUAQeiZ1gALAqsjAEGGmtYACwIHKwBBmJrWAAsEakCn1QBBrJrWAAsMiTIAAAAAAAAAAIQ+AEHKmtYACwSFCAsbAEHcmtYACxQIPSYsAAAAACkWhx0AAAAATDlEPQBB/JrWAAsUjF4GvAAApl4AAOfYAAAAAIgNxUoAQZqb1gALtwcBAG50EABkAAAADwAAAAUAAACJUxAAYgAAAGsBAAAZAAAA8RUQAGUAAAAcAAAAHAAAAPEVEABlAAAAWgAAABUAAADxFRAAZQAAAGMAAAAVAAAA8RUQAGUAAABtAAAAGgAAAPEVEABlAAAAdwAAACAAAADxFRAAZQAAAHwAAAAlAAAA8RUQAGUAAACFAAAAGgAAAPEVEABlAAAAkgAAABUAAADxFRAAZQAAAJcAAAAVAAAA8RUQAGUAAACbAAAAPAAAAPEVEABlAAAAqwAAABEAAADxFRAAZQAAAEIAAAAgAAAA8RUQAGUAAADOAAAAHgAAAPEVEABlAAAA1wAAAB4AAADxFRAAZQAAANwAAAAjAAAA8RUQAGUAAADpAAAAFQAAAPEVEABlAAAAwwAAACcAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAAI5XEABiAAAABAAAAAkAAACOVxAAYgAAAAkAAAAyAAAAjlcQAGIAAAARAAAADQAAAI5XEABiAAAAEgAAAA0AAACOVxAAYgAAAB0AAAANAAAAjlcQAGIAAAAeAAAADQAAAI5XEABiAAAAHwAAAA0AAACOVxAAYgAAADcAAAA3AAAAbWlkID4gbGVuAAAAbI8VAAkAAABwRxAAbwAAAGwAAAAhAAAAcEcQAG8AAAB1AAAAJgAAAHBHEABvAAAAhwAAABEAAABwRxAAbwAAAI8AAAAlAAAAcEcQAG8AAACPAAAAFQAAAHBHEABvAAAAzAEAAB4AAABwRxAAbwAAAOEBAAA6AAAAcEcQAG8AAADgAQAADQAAAHBHEABvAAAA0QEAABwAAABwRxAAbwAAANQBAAAJAAAAcEcQAG8AAADZAQAAEwAAAHBHEABvAAAAGwQAABAAAABwRxAAbwAAACMEAAAMAAAAcEcQAG8AAAAkBAAADQAAAHBHEABvAAAAJgQAAA0AAABwRxAAbwAAABQEAAAqAAAA0jMQAGcAAABYAAAAMgAAANIzEABnAAAAaAAAACUAAADSMxAAZwAAAGsAAAAVAAAA0jMQAGcAAABsAAAAKAAAANIzEABnAAAAbAAAABIAAADSMxAAZwAAAHIAAAAVAAAA0jMQAGcAAABzAAAAKAAAANIzEABnAAAAcwAAABIAAADSMxAAZwAAAHUBAAAgAAAA0jMQAGcAAAB1AQAAGAAAANIzEABnAAAAbAEAABQAAADSMxAAZwAAAGwBAAAMAAAA0jMQAGcAAABpAQAACQAAAAEAQeKi1gALAwMABgBB8KLWAAsNFAAAAAAAAAAVAAAAFgBBjqPWAAsPFwAAAAAAGQAAAB0AAAA1AEGqo9YACwE3AEG4o9YACws9AEwAAAAAAAAAXgBB0KPWAAsJYAAAAGEAAABiAEHoo9YACwdjAGUAagBsAEH6o9YACw9uAAAAbwBwAAAAcQB2AHwAQZSk1gALA30AgABBoKTWAAsHgQAAAAAAgwBBtKTWAAsPhAAAAAAAhwAAAAAAAACJAEHOpNYACwOKAIsAQeCk1gALBY4AjwCQAEHwpNYACxWRAAAAAAAAAJIAlQCXAJgAAAAAAJkAQaSl1gALAZoAQbKl1gALAZsAQbyl1gALA6AAtgBBzKXWAAsRtwAAAAAAAAC8AL0AAAAAAMAAQeql1gALAcIAQfyl1gALF8UAygDRAAAAAADSAAAA4AAAAAAAAADhAEGoptYACxPnAAAAAAAAAOgAAADwAAAAAADyAEHSptYACxP0AAAAAAAAAPYAAAAAAPkA+wD9AEHwptYACxwCAQAAAAAFAQcBAAAAAAAACwEAAAAADAEAAA0BAEGep9YACwIPAQBBrKfWAAsyEAEAABEBAAAVAQAAFgEeAQAAAAAAAAAAHwEAACEBIgEjAQAAAAAAACcBAAAAACgBKQEAQfKn1gALFCoBAAAAAAAAKwEAAAAAMQEAAEQBAEGQqNYACypHAQAASAFJAQAAAAAAAAAAUAEAAAAAVAEAAFUBVgFXAQAAAABaAQAAXAEAQcao1gALHF0BXwEAAAAAYwEAAGsBAABsAQAAcAFxAQAAcgEAQfCo1gALAnQBAEGIqdYACzx1AQAAdwEAAAAAAAAAAHgBeQEAAAAAigGLAYwBAAAAAI4BAAAAAAAAAACQAQAAAACYAQAAAAAAAAAApAEAQdCp1gALKqUBAAAAAKYBpwEAAAAArQGzAbQBugEAAAAAuwEAALwBvQHFAcgBAADJAQBBhKrWAAsaygEAAAAAAADLAQAAAAAAAMwBAADOAc8B0QEAQaqq1gALBNIB1QEAQbqq1gALaNYBAAAAAAAA2gEAANwBAAAAAAAAAADjAQAA5QEAAAAAAADmAQAAAADoAesB7AEAAAAA8QHzAfQBAAD1AQAAAAAAAPkBAAAAAPoBAAAAAAAA+wEAAAAAAAD9AQAAAAAAAAAA/wEAAgcCAEGuq9YACxYRAhICAAAAAAAAFgIAAAAAAAAAAB8CAEHWq9YACw4pAgAAAAAAAAAALQIwAgBB8KvWAAsGMQIAADQCAEGCrNYACzw1AjYCAAA/AgAAawIAAGwCAAAAAG8CcAIAAAAAAABxAgAAAAByAnMCAAAAAHQCAAAAAAAAAAB2AgAAdwIAQdCs1gALIIECAAAAAAAAAACDApACnAIAAAAAAAChAgAAAAAAAKICAEGArdYACxKqAgAArwIAALICAAC1ArsCvAIAQZ6t1gALLsACwQIAAAAAAAAAAMMCxgIAAMcCAAAAAAAAAADWAgAAAADZAgAAAAAAANoC2wIAQdat1gALJPACAAAAAAAA+gIAAPsCAAAAAP8CAAAAAAAAAgMGAwAAAAAHAwBBjq7WAAtmCAMAAAAAAAAJAw8DAAAAAAAAEQMUAwAAAAAAAAAAFgMAAAAAAAAZAwAAAAAAAAAAGgMAAAAAJAMzAzUDAAA7AwAAAAAAAEIDAAAAAEMDAAAAAAAASQMAAEwDAABSA1MDWwMAAFwDAEGCr9YACwxqAwAAbAMAAG0DegMAQZ6v1gALBn0DfgOCAwBBwq/WAAsqgwMAAAAAAACEA4gDigMAAAAAAACLAwAAjAONAwAAjgMAAAAAAAAAAI8DAEH2r9YACxSUAwAAAAAAAJoDnQMAAKIDAACmAwBBlLDWAAsOrwMAAAAAsAMAALkDugMAQa6w1gALOLsDAADCA8MDAAAAANADAAAAANED0gPTA9QDAADVAwAAAAAAAAAA2AMAAAAA2QMAAAAA2wPdA98DAEH4sNYACwrgAwAAAAAAAOEDAEGOsdYACwrkAwAAAAAAAOgDAEGisdYACx7qAwAAAAAAAAAA7QPvAwAAAAAAAPEDAAAAAAAA8gMAQcyx1gALMPMDAAD0AwAAAAAAAAAA9gP4AwAAAAAAAPwDAAD9AwAAAAAAAAAA/gMAAAAAAAAABABBiLLWAAsKAQQAAAAAAgQDBABBnLLWAAtCBwQAAAkEAAAAAAAAAAAKBAAAAAAAAA0EEAQAAAAAAAASBBMEAAAAAB0EAAAeBAAAAAAhBAAAAAAAACIEAAAAACQEAEHsstYACxwlBAAAAAAmBAAAAAAAAAAAJwQAAAAAAAAAACgEAEGSs9YACxopBAAAAAAAAAAAKgQrBAAAAAAAAC0ELgQwBABBuLPWAAsGMQQAADMEAEHKs9YACw44BDwEAAAAAAAAAABABABB5LPWAAsqRgQAAEcEAABTBAAAAAAAAFgEWgQAAF8EAABiBAAAAABmBAAAaQQAAGoEAEGYtNYACwJsBABBprTWAAsmeAQAAAAAeQR6BAAAfAR9BAAAAAB+BH8EAAAAAAAAAACABAAAgQQAQda01gALDoIEAACLBAAAAAAAAIwEAEHutNYACwqNBAAAjwQAAJIEAEGCtdYACwSTBJQEAEGWtdYACwqVBJcEmQQAAKIEAEG0tdYACxSrBAAAAADFBAAAAADIBAAAAADLBABB0rXWAAsKzATNBAAAAADOBABB7rXWAAtEzwQAAAAAAADRBAAAAADbBNwE3gTgBAAAAAAAAAAA5gTnBOoE6wQAAAAAAADsBAAAAADtBAAAAAAAAO4E8AQAAAAA8QQAQcq21gALOPIEAADzBAAAAAAAAAAA+QT6BPwECQUAAAAACwUMBQ0FAAAAAA4FDwUQBQAAAAAAAAAAFgUAABgFAEGUt9YACxAfBSAFAAAiBQAAJAUoBSkFAEGyt9YACywqBSsFLAUAADcFAAA4BQAAAAAAAAAAPQU+BQAAQgUAAE0FAAAAAAAATgVQBQBB6rfWAAsQUQUAAAAAAABSBVUFAABWBQBBiLjWAAsCYwUAQaK41gALBmoFAABsBQBBxLjWAAsWcwUAAAAAAAAAAHsFAAB9BQAAAAB/BQBB5LjWAAsigAWBBQAAggUAAAAAAACEBYUFiAUAAAAAlQWrBQAAAACuBQBBlLnWAAsCrwUAQaS51gALErAFAAAAAAAAAACzBbQFtQXDBQBBwrnWAAtgxQUAAMgFAADJBQAAAADOBQAAAADXBQAAAAAAANgFAAAAANoF2wXdBfAF8QUAAAAAAAD2BQAAAAAAAAAA+AX5BQAA/QUABgAAAAAAAAEGAgYNBgAADgYWBhcGJAYAACUGAEG0utYACwInBgBBwLrWAAsSKwYAAD8GAABDBgAARAYAAEUGAEHcutYACzxIBkoGAAAAAAAAAABLBgAATwYAAFAGUgYAAFMGAAAAAFYGAAAAAAAAAABiBgAAAAAAAGMGAAAAAAAAaQYAQaq71gALEGsGAAAAAAAAcgYAAAAAdAYAQcS71gALNHUGAAAAAAAAdgYAAAAAAAAAAHcGAAB+BgAAAAB/BoAGAAAAAIQGAAAAAIUGhgYAAIgGiQYAQYK81gALGIoGAAAAAAAAiwaMBpAGAACSBgAAAACXBgBBpLzWAAs0qAYAAAAAqQYAAAAAuQYAAAAAAAAAAMYGxwYAAAAAAAAAAMkGAAAAAAAAAADLBgAAAADMBgBB7LzWAAsezQbPBgAAAAAAAAAA0QYAAAAAAADVBgAAAAAAANcGAEGWvdYACwzgBgAAAAAAAAAA5QYAQay91gALTPgGAAD5BvsGAAAAAAAAAAD8Bv0GAAAAAAAAAAD+Bv8GAQcAAAYHBwcAAAAAAAAAAAkHAAALBw0HAAAAAAAADgcTBwAAFAcWBwAAHQcAQYK+1gALBB4HKQcAQZK+1gALAjgHAEGgvtYACxRBBwAAAAAAAEMHAAAAAAAAAABFBwBBwr7WAAsSSgcAAIEHhQcAAAAAAACJB4oHAEHmvtYACxSLBwAAAAAAAAAAjAcAAAAAAACOBwBBir/WAAsamgcAAAAAnAcAAAAAAAAAAJ4HAAClBwAApgcAQa6/1gALGK0HrwcAAAAAAAAAALAHAACxBwAAswe0BwBB5L/WAAtAtQcAAAAAAAAAALcHAAAAAAAAAAC4B7sHAAC+BwAAAAAAAAAAwAfEBwAAAAAAAAAAxgfUB9gHAAAAAAAA3AfdBwBBuMDWAAsY3wcAAOAH4QcAAAAAAAAAAOUHAAAAAOkHAEHawNYACwrtB/QH+AcAAPoHAEGAwdYACwL7BwBBjMHWAAsC/QcAQZzB1gALIP4H/wcAAAAIAQgAAAsIAAAAAA8IAAAQCBEIAAAAABIIAEHIwdYACyIVCAAAAAAAAAAAFggAABcIAAAYCAAAAAAAAAAAIAgiCCMIAEH0wdYACyglCAAAJggoCCkIOQgAAAAAAAAAADsIAAAAAEQIRQgAAEgIAAAAAEoIAEGmwtYACyJLCAAAAABNCE8IUAgAAAAAAABSCAAAAAAAAFkIWwhcCF0IAEHawtYACyZgCGEIAAAAAGIIZQgAAAAAAAAAAGYIAAAAAGcIbggAAG8IAABwCABBjMPWAAsMcQhyCAAAAACSCJoIAEGkw9YACxydCKkIAACsCAAArQgAAK4IsAgAAAAAAAAAAL0IAEHKw9YACw6+CAAAvwjBCAAAAADCCABB4sPWAAsCwwgAQfDD1gALGswIAAAAAM0IAAAAAAAA0QjSCAAAAAAAANQIAEGYxNYACwbWCAAA2AgAQajE1gALBN0I3ggAQb7E1gALLN8IAADhCAAAAAAAAAAA5QgAAAAAAAAAAOYIAAAAAAAAAADnCAAA6AgAAOsIAEGOxdYACwLvCABBnsXWAAse8QjyCAAAAAAAAAAA8wgAAPQIAAAAAAAA9Qj3CPgIAEHKxdYACwL6CABB1sXWAAsQ/wgAAAEJAAAAAAIJAAADCQBB/sXWAAskCQkKCQsJDAkAAAAADgkAAA8JAAASCQAAAAATCQAAFAkAABYJAEGwxtYACzgfCQAAIAkiCSMJAAAkCQAAAAAAADMJAABHCQAATglSCQAAUwkAAAAAWgkAAAAAAAAAAFsJAABdCQBB8sbWAAsCXgkAQYLH1gALEl8JYglkCWgJawkAAAAAAABtCQBBsMfWAAsQbwkAAAAAcAlxCXMJAAB0CQBBysfWAAsKeQkAAAAAAAB6CQBB7MfWAAsUewl8CQAAfQkAAAAAfgmCCQAAhAkAQYzI1gALUIkJigkAAI0JAAAAAI4JmQkAAJsJAAAAAJ4JAACgCQAArQkAAK4JtgkAAAAAAAC7CQAAAAC9CQAAAAC+CQAAvwkAANEJ2wkAAAAAAAAAANwJAEHoyNYACzLgCeEJ4gkAAAAA4wkAAOUJAAAAAOYJ5wkAAOgJ6QkAAOoJAADrCewJAAAAAAAA8QnyCQBBqMnWAAsO9AkAAAAA9QkAAPYJ+wkAQcDJ1gALBv0JAAAACgBB3MnWAAsGAQoAABAKAEH0ydYACwwRChIKAAAAAAAAEwoAQY7K1gALYBQKAAAAAAAAAAAVCgAAAAAAAAAAFwoAABgKAAAcCh4KAAAAAAAAHwoAAAAAAAAAACEKIgoAACMKAAApCioKAAAAACsKAAAtCgAAAAAAAC4KLwozCgAANwoAAAAAAAA5CgBBiMvWAAtKOwoAAAAAPAoAAAAAAAA9CgAAPwoAAEEKAAAAAEQKRQoAAAAASwpMCk0KAAAAAE8KAAAAAAAAUgoAAAAAAAAAAFMKAABUCgAAWQoAQd7L1gALCl8KYAoAAAAAYQoAQfLL1gALAmIKAEH+y9YAC2RjCgAAAAAAAAAAaAp9CgAAfwoAAIAKAAAAAIEKAAAAAIYKAACHCgAAAACKCgAAjQqSCgAAAAAAAJMKAACVCpYKlwoAAAAAAACgCqoKrwoAAAAAAAAAALIKtAoAAAAAAAAAALsKAEHuzNYACwi8CgAAAAC9CgBBgM3WAAsKvgoAAAAAwArCCgBBlM3WAAsWxgoAAAAAAAAAAMoKAAAAAAAAAADLCgBBuM3WAAsUzArPCgAAAAAAAAAA0AoAAAAA0goAQdrN1gALAtMKAEHuzdYACwLUCgBB+s3WAAsg1QrYCgAAAADfCgAAAADgCgAA5QoAAOYKAAAAAAAA6AoAQa7O1gALBOkK6woAQb7O1gALAuwKAEHMztYACyLtCu8KAAAAAAAAAADzCgAAAAAAAAAA9goAAPcK+AoBCwMLAEH4ztYACw4FCwAAAAAAAAAABgsHCwBBlM/WAAsMCAsAAAAADAsAABILAEGsz9YACwwUCwAAFgsAAAAAFwsAQdrP1gALChkLAAAAAAAAGgsAQe7P1gALHBsLHAsAAAAAAAAAAB4LAAAAAB8LAAAhCwAAJQsAQZTQ1gALUikLAAAAAAAAAAAqCwAAKwsAAAAALAsAAC4LNAsAAAAAAAAAADsLAAA8CwAAAAA9Cz4LRAtJC0oLAAAAAEsLAAAAAEwLAAAAAAAAWgtgCwAAYQsAQfbQ1gALBmQLAAB2CwBBhtHWAAsQdwsAAAAAAAAAAHsLAAB8CwBBpNHWAAssfQsAAAAAAACCCwAAhQsAAAAAhguKC4sLAAAAAAAAjwuRCwAAAACSCwAAkwsAQdzR1gALCJQLlQuWC5cLAEHy0dYACwKZCwBB/tHWAAsMmgufCwAApgunC6gLAEGU0tYACwitCwAAAACuCwBBqtLWAAsCrwsAQbzS1gALWLYLAAC4C7kLAAAAALoLAAAAAAAAuwsAAAAAxAsAAAAAzgsAAAAA0AsAAAAA0QvTCwAAAAAAANYLAAAAAAAAAADaC9sLAAAAANwLAADfCwAA6QsAAAAA6gsAQaDT1gALFOsLAADtCwAAAAAAAAAA8QsAAPILAEHE09YACxT3CwAAAAABDAIMBgwHDAAACAwODABB6NPWAAssDwwAABQMAAAXDAAAGwwAAAAAAAAcDAAAHQweDAAAMgwAAAAAAAA0DAAANQwAQaDU1gALCjwMPgwAAAAAQAwAQbjU1gALCEsMAAAAAE0MAEHK1NYACzhODE8MUAwAAAAAAAAAAFYMAAAAAFgMAAAAAFkMAAAAAFoMAABbDF4MYAwAAAAAYQxiDAAAAABjDABBkNXWAAsSbgwAAHAMAAAAAHQMAAAAAHoMAEGu1dYACwyEDAAAAAAAAAAAiQwAQdDV1gALBJAMkQwAQeLV1gALOJMMAAAAAJQMlgwAAJcMAAAAAAAAAACYDAAAmQyaDAAAnAyhDAAApwypDKoMAAAAALMMtAy1DLcMAEGq1tYACxC8DAAAAAC9DAAAAAAAAMMMAEHK1tYACyDHDAAAAAAAAM4MAADSDAAAAAAAANQMAAAAAAAA1QzWDABB+NbWAAse1wzcDAAAAAAAAAAA3gzgDAAAAADjDOQM5QwAAOYMAEGg19YACwToDOoMAEGw19YACwLsDABBxNfWAAsC7wwAQdbX1gALCvAM8gzzDAAA9gwAQfDX1gALAvcMAEH819YACwL5DABBkNjWAAtE+gwAAAAA/Az9DAAAAAD+DAAAAAAADQENAw0AAAAABw0AAAAACQ0AAAoNAAAAAAAAAAAPDRMNAAAAAAAAFA0AAAAAFw0AQeDY1gALAhoNAEH22NYACwwbDQAAAAAlDSYNJw0AQY7Z1gALICgNKQ0AACoNAAAAAC0NAAAAADANAAAAADENAAAzDTsNAEG42dYACwI+DQBByNnWAAsoSg0AAEsNbA1tDW8NAAAAAHENAAAAAAAAcg0AAAAAeQ0AAAAAAAB6DQBB/tnWAAscew0AAAAAfA0AAH0NgA0AAIENAAAAAIINAACDDQBBrNrWAAt6hA0AAAAAjQ2ODQAAAACTDQAAAAAAAJgNnw2hDQAAog0AAAAAow2rDQAArA0AAAAArQ0AAAAAAACuDQAAug0AAAAAAAC8Db0NAAAAAAAAvg0AAAAAAAAAAMANwQ3CDQAAAADGDcoNAAAAAAAAAADLDQAAAAAAAAAA0A0AQbTb1gALHNMN1Q0AAAAA1g3YDQAA2w3cDQAAAADeDQAA4Q0AQd7b1gALDuINAADjDQAA5g0AAOcNAEH829YACy7rDQAA/Q0AAAAAAAAPDgAAAAAAABAOAAARDgAAEg4TDgAAAAAWDhgOAAAaDhsOAEG83NYACwYcDiAOIw4AQdzc1gALDCgOLA4AAC0OMg4zDgBB9NzWAAsONA4AADUOAAAAADYOQw4AQY7d1gALEEQORQ4AAAAAAAAAAEgOSQ4AQajd1gALJkoOAAAAAAAAAABLDgAATQ5PDlAOAABRDgAAbA4AAAAAAABuDnAOAEHm3dYACwJyDgBBht7WAAscdA4AAAAAdQ4AAAAAAAB8Dn0OAAAAAAAAfw6ADgBBrN7WAAsOiw4AAIwOjQ4AAAAAjg4AQcbe1gALSpAOkQ4AAJYOlw6ZDgAAAAAAAJ8OAAChDgAAAACiDgAAAACjDqQOAACtDgAArw62DrcOAAC4DgAAAAAAAAAAuQ4AAAAAuw4AAL4OAEGc39YACwK/DgBBqt/WAAsOwA4AAMEOyg4AAMwOzQ4AQcrf1gALBs8OAADjDgBB2t/WAAsI5g7nDugO7A4AQfDf1gALOO0OAAAAAPEOAAAAAAAAAAD7DgAAAAAIDwkPAAAAAAAAAAAKDwsPDQ8AAAAAAAAAABMPAAAUDxYPAEGy4NYACwIXDwBBxODWAAtKIQ8AACIPAAAjDy4PAAAvDwAAAAAAAAAANA9JDwAASg8AAAAAAABVD1sPAAAAAAAAAABeD2UPZg8AAAAAAAAAAGcPAAAAAAAAaA8AQZjh1gALEGkPAABrDwAAAAAAAHQPdQ8AQbrh1gALJHYPAAB3D30PAAAAAAAAAAB+DwAAAAAAAH8PAAAAAAAAgA+GDwBB6OHWAAsUhw+JD4oPAAAAAAAAAACMDwAAkQ8AQYzi1gALCpIPqw8AAAAAsQ8AQazi1gALGrIPAAAAAAAAAACzDwAAtw8AAAAAAAC7D7wPAEHW4tYACxC/D8IPAAAAAMMPxQ/HD8gPAEHw4tYACxbbDwAA3A/dDwAA3g/fD+IPAAAAAOgPAEGg49YACwL4DwBBrOPWAAsU+w8AAAAAAAAAAP4P/w8AAAAAABAAQcrj1gALMAIQAxAAAAAAAAAFEAAACBAAAAAAAAAJEAwQAAAREAAAAAATEBQQAAAeEAAAAAAfEABBiOTWAAu+ASAQJBAlEAAAJhAAAAAAAAApEAAAAAAtEAAAAAAAAAAAMBAyEDMQAAAAAAAAAAA0EAAAAADXEAAAAAAAANoQ6RAAAOsQ7BAAAO0QAADuEAAAAAAAAO8QAADwEAAAAAAAAPEQAAAAAAAA9hD5EPoQ/hAAAP8QABEAAAIRAxEAAAAADBEAAAAAAAAAABERAAAAAAAAFREAABYRAAAAAAAAAAAZEQAAAAAAAAAAGhEAAAAAAAAcEQAAAAAAAB0RHhEAQdTl1gALUiARAAAAAAAAAAAhEQAAAAAAACIRAAAAAAAAJxEuEQAAAAAAAAAANxE5EQAAAAAAAAAAOhEAAAAAOxEAAD4RPxFCEQAASxFMEU4RAABPEQAAYBEAQbDm1gALFmERAAAAAAAAYxFkEQAAZRFmEQAAaBEAQdTm1gALBmsRAABvEQBB5ObWAAsKchEAAHMRAAB1EQBBiOfWAAssdhF3EQAAeREAAAAAexEAAAAAAAAAAH0RfhEAAAAAAAB/EYERAACCEQAAhBEAQcLn1gALToYRAAAAAIgRAAAAAJERAACcEQAAAACeEZ8RAACoEasRAACsEQAArREAAK8RAAAAALARAAAAAAAAAACyEQAAsxEAAAAAtBEAAAAAAAC1EQBBmujWAAsKtxEAAAAAAAC4EQBBrujWAAtOvRG/EcARwRHDEQAAxBEAAAAAAAAAAMYRxxEAAMkRAAAAAAAAAADSEQAAAADbEQAAAAAAAN4RAAAAAAAA3xEAAOARAADhEQAAAAAAAOURAEGG6dYAC0LmEQAAAADqEQAAAAAAAOwRAAAAAPURAAD2EQAAAAAAAAAACBIJEgAAChIAAAAAAAAAAAsSAAAMEgAAAAANEgAAEBIAQdLp1gALIhESAAAAAAAAAAAxEgAAMxIAADsSAAAAAAAAPBI+EgAAQBIAQf7p1gALSEESRBIAAAAAAAAAAE8SAAAAAAAAAABZEgAAAAAAAAAAWxIAAF0SAAAAAAAAAABeEgAAAABiEgAAAABpEgAAAAAAAGoSaxJsEgBB3urWAAswbRIAAAAAcBIAAHESeRJ/EgAAAAAAAIESAAAAAAAAgxIAAAAAAACEEgAAAAAAAIUSAEGY69YACwqGEgAAiRKKEosSAEGy69YACwqMEgAAAAAAAI0SAEHm69YACyqPErISAACzEgAAtBK8EgAAAAC9Er4SAAC/EsYSxxIAAAAAAAAAAMkSyhIAQZzs1gALAssSAEGo7NYACxzMEgAAzRIAAAAAzxIAANUS1hIAAAAAAAAAANcSAEHY7NYACy7YEgAAAAAAAAAA2hIAAAAAAADcEgAA3RIAAAAAAADrEgAAAADvEgAA9RL3EvoSAEGQ7dYACyT7EgAAABMAAAAADxMAAAAAAAAAABATAAAAAAAAAAAREwAAEhMAQcbt1gALDBMTAAAAAAAAAAAUEwBB3O3WAAsaFhMXExgTHhMgEwAAJhMAAAAAKRMAAAAAMxMAQYTu1gALCDQTNRM3EzkTAEGW7tYACww+EwAAAAAAAAAAPxMAQbLu1gALGkETAABCE0MTAABKEwAAWBMAAFkTXRNgE2QTAEHa7tYACwabE5wTnhMAQeru1gALLp8TAAAAAAAAoBMAAAAAAAChEwAAAAAAAAAApBMAAAAAAAAAAKUTphOnEwAAqRMAQarv1gALRqoTqxMAAKwTAAAAAK0TAAAAAAAAAACuEwAAAACvEwAAAAAAALETshMAAAAAAAAAALQTuRO+EwAAvxMAAMETAAAAAAAAxBMAQfrv1gALFMcTAADIE8kTAADLEwAAAAAAAMwTAEG28NYACwLUEwBBxvDWAAsQ1RMAAAAA1hPYEwAAAADbEwBB5vDWAAsC3RMAQfTw1gALEuoT6xPtE/ET8xMAAPQTAAD1EwBBlPHWAAsC9hMAQaDx1gALIv0T/hMAAAEUAAACFAAAAAAKFAAAAAAAABEUAAAAAAAAHBQAQdDx1gALMB8UIhQAAAAAAAAjFAAAAAAkFCcUKRQAAAAAAAAAACoUAAAAAAAAAAArFCwUAAAuFABBlPLWAAsKLxQAAAAAAAA0FABBqvLWAAscOhQ7FAAAAABGFAAAAABHFEgUShQAAAAAThRRFABB0PLWAAsIUxQAAFYUWRQAQeTy1gALCF0UAABeFGAUAEH28tYACwJhFABBiPPWAAseYhRjFAAAbxQAAAAAfBSBFAAAhhQAAIcUAAAAAIkUAEGw89YACwyKFAAAjBSWFAAAnRQAQcjz1gALCKAUoRSiFKMUAEHa89YACwakFAAApRQAQerz1gALBKcUqBQAQYL01gALEKkUqxQAAAAArhQAAAAArxQAQaD01gALJrgUAAAAALoUuxS8FAAAvRQAAAAAvhQAAAAAAAAAAL8UwBQAAMEUAEHQ9NYACwrEFAAAAAAAAMUUAEHs9NYACwLNFABB+vTWAAsWzhQAAM8U0RQAANQUAAAAAAAAAADaFABBoPXWAAsc3BQAAAAA3RQAAAAAAADeFAAA3xTgFAAAAADhFABByPXWAAsE4xTkFABB3vXWAAtK5RQAAOYUAADqFAAAAAAAAAAA7hQAAAAA7xQAAAAA8RQAAAAA9RQAAPcUAAD9FAAAAAAAAAMVAAAAAAAABBUAAAAAAAAGFQAACBUAQbT21gALDAkVAAAAAAAAAAALFQBBzPbWAAsGDBUOFREVAEHo9tYACw4UFQAAAAAAAAAAFRUaFQBBgPfWAAsMGxUAAAAAAAAcFR0VAEGk99YACyIeFQAAAAAAAAAAIhUAAAAAIxUAACcVAAAAAAAAAAAoFToVAEHc99YACwY+FQAAQBUAQe731gALNEEVQhUAAAAAAABDFUQVRxUAAAAASBVJFUsVAAAAAAAAUBVRFQAAAAAAAFMVAAAAAAAAVRUAQb741gALIlgVAABaFQAAAABbFQAAXhUAAAAAYRUAAAAAYhUAAAAAZBUAQfb41gALAmUVAEGG+dYACwpsFQAAAABtFW4VAEGa+dYACwJwFQBBqvnWAAsCcRUAQbb51gALMoMVAAAAAAAAhhUAAIcVAAAAAIgVAAAAAAAAiRUAAIsVAAAAAIwVjRUAAI4VAAAAAJIVAEHy+dYAC16eFZ8VAAAAAKAVAACiFQAAAACnFQAAqBUAAAAAqRUAAKsVAAC1FQAAAAC2FQAAuBW/FQAAAAAAAAAAwBUAAAAAAADDFcUVAADGFQAAxxUAAAAAAAAAAMkVAAAAAN4VAEHi+tYACy7gFekVAAAAAAAAAADqFQAAAADsFQAA+BUAAPkVAAAAAAAA/RUAAAkWAAAKFgsWAEGc+9YACyQTFgAAAAAAABQWFRYAAB0WHhYuFgAALxYAAAAAAAAAADUWNhYAQcr71gALCDoWPBYAAEcWAEHc+9YACwxKFgAAAAAAAAAASxYAQfT71gALJkwWAAAAAE0WAABOFgAAAAAAAFAWAABlFgAAZhZnFgAAAABwFncWAEGy/NYACwZ4FgAAehYAQcT81gALTH0WfhYAAIAWgRYAAAAAAAAAAIMWhBaFFgAAhhYAAIcWiBYAAIoWAAAAAAAAAACQFpQWAAAAAAAAAACWFgAAAAAAAAAAmBYAAAAAnBYAQab91gALAqUWAEHG/dYACxCnFgAAAACpFgAAAAAAALMWAEHi/dYACwi4FgAAAADDFgBB+v3WAAscxhbHFgAAAADIFgAAAADJFgAAyxbUFtUWAADWFgBBoP7WAAsC2hYAQaz+1gALRtwWAADfFuEWAAAAAOMWAADlFgAAAADnFgAA6RYAAAAAAADxFvMWAAAAAAAA9RYAAPcWAAAAAAAAABcAAAAAARcDFwAABhcAQf7+1gALBgcXAAAJFwBBkP/WAAs6ExcAABcXAAAAABgXAAAZFyIXJBcAACcXKBcAAAAAAAAAACkXKhcAAC0XAAAAAAAAAAA9FwAAAAA/FwBB2v/WAAsiQRcAAAAAQhcAAEcXSBdJFwAATBcAAAAAAABYF1oXYxdmFwBBhoDXAAsoZxcAAGgXAAAAAAAAahdrFwAAAABsFwAAAABxF3MXAAAAAAAAAAB3FwBBuIDXAAsieBcAAAAAeRcAAHoXAAAAAAAAexd/FwAAgRcAAIMXAACHFwBB6IDXAAsCiRcAQf6A1wALOIoXAACOFwAAAACQFwAAAAAAAJEXlheYFwAAAAAAAJkXnRcAAAAAnhcAAAAApRcAAAAAphcAAKcXAEHCgdcACxapFwAArxcAAAAAAACwFwAAshe3F7gXAEHkgdcACwq7F7wXAAAAAL0XAEGAgtcACwS+F78XAEGUgtcACwbAFwAAwxcAQaSC1wALRsQXAAAAAMgXAADJFwAAAADNF9kXAAAAANsXAADeFwAAAAAAAN8X7RfuFwAAAAAAAPEXAAAAAAAAAADyFwAAAAAAAPMX9hcAQfaC1wALAv4XAEGDg9cACxkYAAAAAAIYBxgJGAAADBgAABMYAAAkGCUYAEGmg9cACzYmGAAAAAAAAAAAKBgzGAAAAAA+GAAAQBgAAAAARBhFGEYYAABHGAAAAAAAAFQYAAAAAAAAWhgAQeiD1wALElsYYBgAAGIYYxhkGAAAahhvGABBhITXAAsYcRgAAAAAAAByGIYYAACMGAAAAAAAAI0YAEGshNcACxKOGAAAAAAAALAYAAAAALIYvBgAQc6E1wALAr4YAEHehNcACyy/GAAAAADBGAAAwhgAAMMYxBgAAAAA1BjVGOEYAAAAAAAA4hjjGOQYAADlGABBlIXXAAsC6BgAQaCF1wALHu4Y7xjwGAAAAAAAAAAA8hgAAPUY/RgAGQsZAAAOGQBBzIXXAAsEDxkQGQBB3IXXAAsMERkAAAAAAAAAABIZAEH2hdcACxYUGQAAFRkXGRkZAAAdGR4ZAAAhGSYZAEGghtcACz4nGSgZAAAAACkZAAAAACwZAAAAAAAAAAAuGQAAAAAAAAAALxkwGQAAAAAyGQAAAAAAADYZAAAAADcZAAA9GQBB6obXAAsgPhkAAAAAPxkAAEAZAABBGUMZAAAAAAAARBkAAE8ZUBkAQZiH1wALClEZAAAAAFUZVxkAQa6H1wALAl0ZAEHAh9cACwZeGV8ZYBkAQdCH1wALDGIZAAAAAAAAaxlsGQBB8IfXAAsWbxlwGQAAAAAAAAAAcRkAAAAAAAByGQBBkIjXAAtUdBkAAAAAdRl2GQAAAAAAAHcZeBl5GQAAexkAAAAAAAAAAHwZgBkAAIIZAAAAAIQZAACyGQAAAAAAALcZAAC4GQAAAAAAALsZAAAAAAAAvhkAAL8ZAEHuiNcACw7AGQAAAAAAAAAAwRnCGQBBhonXAAsOxxnIGQAAAADJGcoZzBkAQbCJ1wALAtAZAEHCidcAC0zSGdMZAADXGQAA2BnaGdwZAADtGQAAAAAAAAAA7xkAAAAAAAAAAPEZAADyGQAAAAAAAPcZAAAEGgcaAAAIGgAAChoNGgAAExoUGhUaAEGgitcACw4WGgAAAAAAABcaAAAYGgBBvIrXAAsCJRoAQdCK1wALDjAaMRoyGgAAAAA3GjkaAEHoitcACxA8GgAAAAAAAD0aAAA/GkQaAEGIi9cACwRFGkYaAEGWi9cACyBIGkkaTxoAAFEaVhoAAAAAVxpeGgAAXxoAAAAAYBphGgBBwovXAAsCYhoAQc6L1wALAmQaAEHci9cACyxrGgAAAABsGm0aAAAAAAAAchoAAAAAAAB4GnwaAAB9GgAAAAAAAH8aAACAGgBBrozXAAsYgRoAAAAAAACIGgAAAAAAAIkaAAAAAJIaAEHQjNcACzSTGgAAAAAAAJQaAAAAAAAAnBoAAAAApxoAAKgatxoAAAAAAAAAAMQaAAAAAMYaAADIGskaAEGWjdcACxTTGgAA1BrWGtgaAAAAAAAA2RraGgBBtI3XAAsI2xoAAAAA3RoAQcqN1wALDt4aAAAAAAAA3xoAAOAaAEHsjdcACw7nGgAA6BrrGu0aAADvGgBBio7XAAs68xoAAAAAAAAAAPUaAAAAAAAAAAD+GgAA/xoAAAAAABsAAAAAARsCGwAAAAAAAAMbAAAAAAAABBsHGwBB0I7XAAs0DBsAAA0bAAAAAAAADhsPGxAbAAARGwAAEhsAAAAAExsXGwAAGBsAAAAAAAAAABsbHBsdGwBBoo/XAAsGHhskGyUbAEG2j9cACxIoGyobMxs1GzYbAAAAADcbOBsAQdqP1wALFjkbAAAAADobQxsAAAAARBsAAAAARxsAQfqP1wALAkgbAEGKkNcACwZMG04bUBsAQZ6Q1wALClMbAAAAAAAAZBsAQbqQ1wALAmsbAEHMkNcACxJtGwAAAABuG28bdBsAAHYbeRsAQeqQ1wALAn4bAEGAkdcACwJ/GwBBjJHXAAsGhhsAAIcbAEGokdcACwSIG4wbAEG2kdcAC06OGwAAlBsAAAAAAAAAAJUbAACZGwAAAAAAAAAAmxudGwAAnhufG6AbAAAAAKYbAACoG6kbAACrGwAAAAAAAKwbrxuwGwAAAACyGwAAtRsAQaKS1wALCMMbAAAAAMQbAEG6ktcACwbGGwAAyhsAQc6S1wALBssbAADMGwBB3pLXAAsizRsAAAAAzhsAAAAA1BsAANUbAAAAANYbAAAAAAAAAADYGwBBipPXAAs02RsAANobAADcG90bAAAAAN4bAAAAAOMbAADsG+4bAAAAAAAAAADwGwAAAAAAAPEb9Bv1GwBByJPXAAsC9hsAQd6T1wALCvsb/RsBHAAAAxwAQfqT1wALCAQcAAAFHA0cAEGMlNcACxQOHBEcAAAAAAAAAAATHAAAIRwkHABBqpTXAAtIJhwnHAAAAAAAAAAAKxwwHAAAMhwAAAAAAAAAADocPBw+HEAcQRxDHEUcAAAAAAAAAABGHEkcAABKHAAAAABPHAAAAAAAAGIcAEGAldcACxR5HAAAAAB6HHscAAAAAHwcAACBHABBqJXXAAsGhBwAAIUcAEHGldcACyKGHAAAAAAAAAAAiRwAAAAAAAAAAIscAACMHAAAjhwAAKccAEH2ldcACwipHAAArxyzHABBiJbXAAswtBwAALUcthy4HLocAAAAAAAAAAC9HAAAvhzGHAAAxxzIHAAAAADNHAAAAAAAAM4cAEHGltcACwrQHAAAAAAAANEcAEHaltcACwjSHAAA0xzUHABB7JbXAAsg1xwAAAAA2hwAAAAAAAAAAOYcAAAAAAAA5xzoHAAA6RwAQZqX1wALAuocAEGml9cACwLtHABBspfXAAsC7hwAQcSX1wALHP0cAx0FHQAAAAAAAAsdAAAAAAwdAAAAAAAADR0AQeyX1wALDA4dEx0AABYdAAAYHQBBjJjXAAsCIB0AQZiY1wALCCEdAAAAACUdAEGqmNcACwImHQBByJjXAAsqJx0qHTAdAAA0HQAAAABCHQAAQx0AAAAARR0AAAAAAABKHUsdAAAAAFQdAEH8mNcAC0xYHQAAAAAAAFkdWh1cHQAAAAAAAAAAXh0AAAAAXx1hHWIdAAAAAAAAZh0AAAAAaR0AAAAAax0AAHAdAAByHQAAcx0AAAAAdR12HXodAEHSmdcACwZ7HQAAfB0AQeKZ1wALCn4dAAAAAIAdgR0AQYCa1wALCIIdix0AAJUdAEGUmtcACxiWHZgdAACaHZ0dnx0AAAAAAACgHQAAox0AQbaa1wALGqUdAAAAAAAAqh0AAAAAqx0AAAAAsB2yHbodAEHamtcAC0C8HQAAvR2+HQAAAAC/HQAAAADAHQAAxB0AAMUdxh0AAMcdAAAAAAAAAADKHQAAAAAAAAAAyx3NHc8dAAAAANEdAEGkm9cACxjXHQAA2B3aHQAAAADbHQAAAAAAAAAA3B0AQcqb1wALAt0dAEHWm9cACxztHe4d7x3xHQAA8h0AAPMdAAAEHggeCh4AAAseAEH+m9cACyQMHgAAAAAUHgAAGx4AABweAAAdHgAAKR4AAAAAAAAqHgAALB4AQa6c1wALDjEeMx4AADQeAAA1HjceAEHKnNcACx47HgAAAAA9HkEeAABEHgAAAAAAAEceAAAAAAAASB4AQfac1wALPkkeAAAAAEweAABNHgAATx4AAFAeAAAAAAAAAABRHlgeAAAAAFkeAAAAAFoeAAAAAFseAAAAAFweAAAAAF0eAEG+ndcACwRiHmceAEHMndcACxZoHmkeAABuHgAAAAAAAAAAcB4AAHYeAEHsndcACz53HgAAgh4AAAAAhR4AAIYeAACIHgAAih6QHpEekh4AAJQelh4AAAAAAACgHgAAoh4AAKMeAAAAAAAAAACkHgBBuJ7XAAsCph4AQcSe1wALMrAesR6yHrYeAAC5HgAAAAC6HgAAAADpHgAAAAAAAAAA6h4AAAAA6x7tHu4e7x4AAPAeAEGUn9cACyDxHvIeAAD0HgAAAAD1HgAAAAD3HgAA+h7/HgAAAAABHwBBwJ/XAAsGAx8AAAQfAEHQn9cACxYFHwAAAAAAAAAACR8AAAAAAAAAAA0fAEH2n9cACwYOHwAAER8AQYqg1wALFCAfAAAAAAAAAAAhHyQfOB8AADkfAEG0oNcACw46HwAAAAAAAAAARx9IHwBB2qDXAAsKSh8AAAAAAABMHwBB9KDXAAseUh8AAFwfXR8AAAAAXh8AAAAAYB9hHwAAAABiH2QfAEGmodcACzplHwAAAAAAAGsfdB97H3wfAAAAAH0fAAAAAAAAfh8AAH8fAACAHwAAgh+EHwAAAAAAAJAfkR8AAJkfAEHqodcACwKcHwBB+KHXAAsEnR+uHwBBiqLXAAsCrx8AQZai1wALCLAfsx8AALUfAEG+otcACyi4H7kfuh/AH8Efwh/DHwAAAADLHwAAAADQHwAAAAAAAAAA0R/SH9kfAEH2otcAC0DaHwAA3R/gH+IfAADkH+UfAAAAAAAAAADmH+cfAAAAAPMfAAAAAAAA+R8AAAAAAAD6HwAAAAD7HwAAAAAAAPwfAEHAo9cACwwMIAAAAAAAAAAAEiAAQdaj1wALDBUgAAAWIAAAAAAXIABB7qPXAAsCGiAAQYKk1wALDBsgAAAdIAAAAAAeIABBrqTXAAsQISAAAAAAAAApIAAAAAAyIABB1KTXAAssNyAAADggPCAAAEAgQSAAAAAARSAAAEggSSAAAAAAAAAAAEsgAAAAAAAATSAAQZKl1wALLk4gAAAAAAAAViAAAFcgWyAAAAAAXSBeIGEgZCAAAAAAAAAAAGUgZyBrIGwgbSAAQcyl1wALBHAgcyAAQd6l1wALIIEgAAAAAAAAgiCDIIUghiCHIAAAAACMIJIgAAAAAJQgAEGIptcACw6eIAAAAACfIAAAoiCjIABBsqbXAAsEqCC0IABBxqbXAAsquSAAAAAAAAAAALwgAAAAAAAAvyAAAMAgAAAAAAAAAADCIMggAAAAAMogAEH+ptcACwzMIM0gAADOIAAAzyAAQZSn1wALLNAgAADRINog2yAAANwg3SDmIAAAAAAAAAAA5yAAAAAAAAAAAOggAAAAAOkgAEHOp9cACwT5IPogAEHep9cAC0T7IAAAAAD8IAAA/yAAAAAAAAAAAAMhAAAKIQAADiEAAAAAFCEAABUhAAAAAAAAFiEAABkhHyEgIQAAAAAAAAAAISEjIQBBtKjXAAsIJCEAAAAAKiEAQcio1wALCishLSEuIQAAUCEAQeCo1wALAlIhAEHyqNcACzhWIVohXCEAAAAAXSEAAAAAYSEAAG0hAAAAAHkheiEAAAAAeyF+IX8hgyEAAIchAAAAAAAAAACPIQBBuqnXAAsGniEAAJ8hAEHSqdcACzKgIQAAAAChIQAAAAAAAKIhAAAAAAAAoyEAAAAApSGpIa0hAAAAAK4hAACvIQAAsCGxIQBBlqrXAAsWvSG+Ib8hyiEAAAAAAAAAAMwhziHPIQBBwKrXAAsC0CEAQcyq1wALAtEhAEHgqtcACwjSIQAAAADTIQBBkKvXAAsC1CEAQZ6r1wALFNUh1yHYIQAAAAAAAAAA2SEAAN0hAEHAq9cACyDfIeIhAADsIQAA7iEAAAAAAADxIQAAAAAAAPIhAAACIgBB9qvXAAs0BiIAAAciCSIKIhQiFyIYIh0iICIAACEiIyIAAAAAAAAAACYiJyIpIjIiAAAAAAAAAAA0IgBBtqzXAAsENSI4IgBBxKzXAAsuOiI7IjwiAAA+IkEiQiJFIgAARiIAAEsiAAAAAAAAAABMIgAAAABNIgAAAABPIgBBnq3XAAsCUCIAQbCt1wALJlEiAAAAAAAAAABSIgAAAAAAAAAAVCJWIgAAAAAAAGMiAABtIm4iAEHgrdcAC0ZvInAiAAAAAAAAAAByIgAAAAAAAAAAdiJ8In0iAAB/IgAAAAAAAAAAgSIAAAAAAACCIgAAAAAAAIMiAACEIgAAAAAAAIUiAEGyrtcACwSGIociAEHMrtcACxaIIgAAAAAAAIkiAACKIgAAAAAAAI4iAEHwrtcACyKPIgAAkCIAAAAAoCIAAAAAoiIAAAAApiKoIgAAAACpIqoiAEGer9cACxyrIgAArCIAAAAAAAAAAMAixCIAAAAAAAAAAMUiAEHEr9cACyDIIgAAyyIAAAAAAAAAAM8i0CLRIgAAAAAAANIiAADTIgBB/K/XAAsK1CIAAAAAAADhIgBBmrDXAAtc4iIAAOQiAADvIgAAAAAAAPEi8yIAAAAAAAAAAPUiAAD2IgAA+iL9IgAAAAAKIwAAAAAAAAAACyMAACQjAAAAAAAAAAAlIygjAAAAAAAAAAApIyojAAAsIzEjQCMAQY6x1wALDEMjeiMAAAAAeyOBIwBBprHXAAsggiMAAAAAAACEIwAAAACFIwAAhyMAAAAAiCOJI40jjiMAQdax1wALApgjAEHksdcAC0iaIwAAAACgIwAAoSOiIwAAAAAAAKMjpCMAAAAApSMAAAAApiMAAKcjAAAAAKkjqyMAAAAAAACsIwAAAACwIwAAuCMAAAAAvCMAQbiy1wALDr0jAADAI8sjAAAAAM0jAEHgstcACwbOIwAA0SMAQfSy1wALGNIjAAAAAAAAAADUIwAA1iPXI9gjAADZIwBBnLPXAAs+4iMAAOMjAAAAAAAA5CPlIwAAAADmIwAAAAAAAAAA5yMAAAAAAADpIwAAAAAAAAAA7SPuIwAAAAAAAPgj+yMAQeOz1wALNSQBJAAABCQAAAAAAAAAAAUkBiQHJAAACCQJJAAAAAALJAAADCQNJAAAAAAOJAAAECQAABEkAEGitNcACwoSJBMkAAAAABUkAEG8tNcACx4WJBgkAAAAABkkAAAAAAAAAAAcJAAAAAAAAAAAHyQAQe601wALCiAkAAAAAAAAISQAQYK11wALHCIkAAAAAAAAAAAjJAAAAAAkJCckAAAAAAAAKCQAQay11wALCCkkAAAAACokAEHAtdcACwIrJABBzLXXAAsMLiQvJAAAAAAxJDIkAEHotdcACwQ0JDckAEH+tdcACw45JAAAAAAAADwkPSQ/JABBmrbXAAsIQCQAAAAATSQAQay21wALBFEkVSQAQca21wALMFwkXSRhJGkkaiQAAG4kbyQAAAAABSUAAAclAAAAAAAAAAAKJQAAAAAAAAslAAAMJQBBiLfXAAssDSUAAAAADiUAAAAAAAARJQAAAAAAAAAAEiUTJQAAAAAAAAAAFSUAABclGCUAQcS31wALBhwlAAAeJQBB1LfXAAsSICUjJQAAJSUAACclAAAAACklAEH2t9cACwIrJQBBhLjXAAsyLCUtJQAAAAAAAAAAPCUAAAAAPSUAAAAAQiUAAEMlRCUAAAAAAAAAAEUlAAAAAAAARiUAQca41wALCEglSSUAAEolAEHauNcAC0ZLJUwlAAAAAAAATiUAAFUlAABWJQAAWSUAAFslYiUAAGQlZiVnJQAAAAAAAGkleCUAAAAAfCUAAAAAAAB+JQAAgCUAAIElAEGsudcACwiIJQAApiWnJQBBwrnXAAsWqSUAAAAAqyWsJa0lriUAAAAAAACwJQBB5rnXAAsEsiW2JQBB+rnXAAsCtyUAQYa61wALKLglAAC5JQAAAAAAAAAAuiUAAAAAuyUAAAAAwCUAAAAAwSUAAMMlxSUAQca61wALaMclAADJJdElAAAAAAAAAADSJdMl1CUAAAAAAAAAANYl4iUAAAAA5CXlJeYlAADnJfUlAAAAAAAAAAD2JQAA/iUAAAAAAAAAAP8lAAAAAAAAACYAAA4mAAAQJgAAAAAAABYmAAAaJhsmAEG4u9cAC04cJgAAHSYoJgAAKSYAAAAAAAAqJismAAAtJgAALiYAAC8mAAAAAAAAMCYxJjgmAAAAAAAAOiYAAD0mAAAAAAAAAABBJkImAAAAAAAAUCYAQZC81wALAlMmAEGqvNcAC0pUJgAAXCYAAF8mAABkJgAAAAAAAAAAZiYAAAAAaSZsJgAAAAAAAHAmAAAAAAAAcSYAAAAAciYAAHUmAAAAAAAAdyZ4JgAAAAB/JgBBgL3XAAsGgCaHJokmAEGWvdcACwqKJosmjCaRJpMmAEGsvdcACxSYJgAAniYAAAAAAACfJgAAAACjJgBBzr3XAAsOsiazJrQmAAAAAAAAtSYAQei91wALFrYmAAAAAAAAAAC5JgAAAAAAAAAAuiYAQYi+1wALDsImAAAAAAAAAADDJsUmAEGivtcACwrKJgAAAAAAAMsmAEHKvtcACyzMJgAA0yYAAAAA1CbqJu4mAADxJvImAAAAAPYmAAD7Jv0m/iYAAAAAAAABJwBBgr/XAAsCAycAQZK/1wALFgQnCScAAAAACicAAAAAAAANJwAAFCcAQbK/1wALEBcnIyckJyYnAAAAAAAALycAQcy/1wALIDAnAAAAADInAAA0JwAAAAAAAAAANicAADcnOCc5JzonAEH2v9cACwI7JwBBgsDXAAsWPSdGJwAAAAAAAAAARycAAAAASSdKJwBBpMDXAAsCSycAQbTA1wALAkwnAEHEwNcACzJPJwAAUicAAAAAAABWJwAAWCcAAAAAXCddJwAAAABkJwAAZydqJ2snAAAAAAAAbidxJwBBgsHXAAsCcicAQZDB1wALCncnAAB4JwAAfCcAQarB1wALmAGIJwAAAAAAAIonAAAAAI0nAAAAAAAAAACPJ5AnAAAAAJYnAACXJ5gnAACZJwAAAACjJwAApSemJwAAAACsJwAArievJ7AnuCcAAAAAuycAAL0nAAAAAAAAwCcAAAAAAAAAAMEnAAAAAAAAAADCJwAAAAAAAAAA0icAANonAAAAANsn3CcAAN0n3icAAN8nAAAAAAAAAADhJwBB0MLXAAsC5ScAQd7C1wALHOknAAD1JwAA9if3JwAAAAD4JwAAAAD9J/4nBCgAQYTD1wALBgooAAAMKABBlsPXAAsIDygAAAAAESgAQarD1wALBhIoAAATKABBwMPXAAsCFCgAQdDD1wALEiwoMCgxKAAAAAAAADIoAAA4KABB7MPXAAsCOSgAQfrD1wALDjooAAAAAAAAAAA7KD8oAEGSxNcACxhCKAAAAAAAAEMoAABEKAAAAAAAAAAARygAQbjE1wALLksoTSgAAAAAAABOKE8oAABRKAAAVigAAFgoAAAAAAAAAABZKAAAAABbKAAAXCgAQfLE1wALCl4oAAAAAF8oYigAQYbF1wALBGMobSgAQZbF1wALBm8oAABxKABBqMXXAAsUeigAAIAoAACBKAAAAAAAAIQohSgAQcbF1wALGIYoAAAAAAAAhygAAIgoAAAAAJIolCiWKABB7MXXAAsYlygAAAAAmCiaKAAAAACcKAAAnSgAAKMoAEGUxtcACxKkKAAApSiqKAAAAACrKAAArCgAQbTG1wALBrUotii3KABBzMbXAAsOuSgAAAAAuygAAAAAvigAQeTG1wALIsAoAADBKMIoAAAAAAAAAADEKMUoAADGKAAAxygAAMwozigAQZDH1wALAtAoAEGcx9cACwLRKABBrMfXAAsa0ygAANUoAAAAAAAA1ijZKAAAAADbKAAA5SgAQdDH1wALBOgo8SgAQd7H1wALCPIo8ygAAPwoAEH6x9cACyADKQAAAAAAAAYpAAAAAA4pAAAZKRwpAAAAAB0pHikgKQBBqsjXAAsQIikAAAAAAAAAACUpAAAmKQBBzsjXAAsWJykoKQAAAAAwKQAAOSk8KQAAPSk/KQBB7sjXAAsqQilDKUQpAABFKQAAAAAAAEYpAABHKQAAAAAAAAAATykAAAAAUCkAAFIpAEGsydcACxJZKVopWyldKQAAXikAAAAAYikAQcjJ1wALKmYpAAAAAGkpAAAAAAAAaikAAGspAABsKQAAbSkAAAAAbykAAIIpAACDKQBB/MnXAAtChSmGKYcpAAAAAAAAlikAAAAAAACXKQAAmikAAJspAAAAAAAAnCmdKZ8pAACiKQAAAACjKQAAqykAAAAAAAAAAK0pAEHQytcACyKuKQAAAAAAAK8pAAAAAAAAAACwKbEpAACyKQAAAAAAALQpAEH+ytcACyK2KQAAuikAAAAAxCkAAMkpAAAAAAAAAADKKQAAAAAAAMwpAEGqy9cACwbPKQAA0CkAQb7L1wALENEpAADbKd4p4CkAAAAA4ikAQd7L1wALDOMpAAAAAAAAAADmKQBB9MvXAAsG5ynqKfcpAEGGzNcACwj4KQAAAAD5KQBBmszXAAsc/CkAAAAAAAAAAP4pAAAAAAAqASoAAAAAAAAEKgBBwszXAAsUBioAAAAAAAAHKgAAESoAAAAAFCoAQeLM1wALEBUqAAAAAAAAGSoAAAAAGyoAQYLN1wALFBwqICoAAAAAAAAlKgAAAAAAACcqAEGozdcACyYrKgAAAAAsKgAAOCoAADkqAAAAAAAAOioAAAAAAAA8KgAAAAA+KgBB4M3XAAtWPyoAAAAAAAAAAEAqQSoAAAAAAAAAAEMqAABEKgAAAAAAAAAARSpGKkcqAABKKmEqAAAAAAAAAABiKgAAAABkKgAAZSoAAAAAaCoAAAAAaSpqKmsqbCoAQcLO1wALFG8qAAByKnMqeCqKKgAAAACLKowqAEHgztcACxSNKgAAAAAAAJAqkyoAAAAAlCqWKgBB/s7XAAsClyoAQZjP1wALHJkqAACaKgAAAAAAAAAAnCqfKgAAoCoAAAAApCoAQb7P1wALDqUqAACmKgAAAAAAAKsqAEHWz9cACzasKgAAAACwKrEqAAAAALIqAAAAAAAAtCoAAAAAAAAAALsqAAAAAMEqAAAAAAAAwyoAAAAAxCoAQaTQ1wALFs4qAADQKtIqAAAAANQqAAAAAAAA1ioAQc7Q1wALEtcqAAAAAAAA2CoAAAAAAADdKgBB6tDXAAtW3yoAAAAAAADgKuIqAAAAAOYq6CrrKgAAAADsKgAA7SoAAAAA7yoAAAAAAAAAAPAqAAAAAAAA8SoAAPMqAAAAAAAA9Cr1KgAAAAAAAPYqAAD3KgAA+SoAQczR1wALFgIrBCsAAAUrCCsJKwAAAAALKwwrDSsAQfrR1wALJg4rAAAAAA8rFSsAAAAAAAAAABcrAAAAAAAAGisAAAAAAAAAAC8rAEGq0tcACwQwKzQrAEG60tcACxY1KwAAAAA4KzkrAAA6KwAAPSsAAE0rAEHa0tcACxxOKwAAAAAAAFArAAAAAAAAVisAAAAAAABXK1grAEGC09cACwRZK1orAEGS09cACzJbKwAAAABeK2QrAAAAAAAAZSsAAGorbysAAHsrAAAAAAAAhisAAAAAhysAAIorAACLKwBB4tPXAAskjCsAAI0rkCuRK5IrAACUKwAAlSsAAAAAAACWKwAAAACXK5grAEGe1NcACxybKwAAAACcK54rAAAAAAAApCumKwAAAAAAAKgrAEHE1NcACxauK68rAAAAAAAAsCuzKwAAAAC0K7UrAEHm1NcACwK6KwBB9tTXAAsEwCvCKwBBhtXXAAsGwysAAMQrAEGW1dcAC3DFKwAAAAAAAMYrAADHKwAAAADJKwAAyysAAM4rAAAAAN8rAAAAAAAAHSwfLAAAAAAgLCEsJiwAAAAAAAArLAAAAAAAAAAALSwuLAAALywAAAAAAAAxLAAAMiwAAAAAAAAAAEYsAABKLAAAAAAAAEssAEGQ1tcACyhMLAAATSxOLAAAUCwAAFEsAAAAAAAAVCxVLAAAAABWLAAAAAAAAFssAEHE1tcAC1xcLAAAXSxqLAAAAABrLAAAbixwLAAAAAAAAHEsAAAAAHIsdywAAHoshywAAIgsjiwAAAAAAACQLAAAAACRLJQsAAAAAAAAAACZLAAAAAAAAJosAACdLAAAoiylLABBqtfXAAsKpiwAAK0sAACuLABBvtfXAAsEsCy9LABBztfXAAtQviwAAAAAAAAAAL8sAAAAAMAsxCzFLMcsAADNLAAA0SwAAAAAAAAAANIsAAAAAAAA0ywAANQs1SzYLAAAAAAAAAAA2SwAAAAA3CwAAAAA3ywAQbLY1wALFuksAAAAAO4sAAD1LAAAAAD2LPcs+SwAQdzY1wALEvssAAAAAAAAAAD8LAAAAC0BLQBBhNnXAAsOCS0KLQstDi0AAAAAFy0AQZzZ1wALBhstAAAcLQBBrNnXAAsSIC0kLQAAJS0AAAAAJy0AACgtAEHK2dcAC0gpLQAAAAArLSwtAAAtLQAAAAAAAAAALy0AAAAAAAAxLQAANi0AADctAAAAAAAAOS0AADotAAAAAAAAPC09LQAAAAAAAD4tQC0AQaDa1wALDEMtAABELUctAABLLQBBvNrXAAsaTC0AAE0tAAAAAAAAAABOLVEtAAAAAAAAUi0AQfra1wALSlMtVC0AAFYtAAAAAFgtAAAAAAAAAABaLQAAAABbLQAAAAAAAAAAXS0AAGYtAAAAAAAAZy0AAAAAAAAAAGktAAAAAGotay1sLW4tAEHQ29cACxJ3LQAAAAB+LQAAgC2BLQAAgi0AQfTb1wALKIMtAAAAAIQthS2ILQAAAACdLZ8tAAAAAAAAAACgLQAAAAChLQAApS0AQazc1wALDqgtAAAAAAAAxC0AAMctAEHE3NcACwrJLQAAAADMLd8tAEHe3NcACwbhLeQt5i0AQe7c1wALEOctAAAAAAAA6C3qLQAA6y0AQYzd1wALAu8tAEGa3dcACwrwLQAAAAAAAPEtAEGw3dcACxj2LfctAAD8Lf0tAAD+LQAAAAD/LQAAAS4AQe7d1wALBAIuBC4AQYDe1wALagcuAAAILgAAAAAAAAkuAAAAAAAACi4AAAAAAAAAAAwuAAAAAA0uDy4QLgAAAAAAAAAAEy46LjsuPC4AAAAAPS4AAAAAAAA+LgAAAABGLksuAABMLgAAXS4AAAAAAABfLgAAAAAAAGAuYi4AQfbe1wALCGMuAABkLmUuAEGS39cACwJrLgBBot/XAAtAbC4AAG0uAABuLgAAAABvLgAAdi53LnkuhS6GLgAAiC6OLgAAAACQLgAAki6ULpcumC4AAAAAAAAAAJkuAACeLgBB7N/XAAsspS6nLqguAACpLgAAAAAAAAAArC6tLgAAAAAAAAAAsS4AALIuAACzLgAAtC4AQaLg1wALCLUuAAAAALcuAEG64NcACwK5LgBBxuDXAAsUyi4AAAAAAADLLswu0i7TLgAA2C4AQeTg1wALFNkuAAAAAAAA2i4AAN8u5C7lLuYuAEGC4dcACzzrLgAAAADsLu4uAAAAAO8uAAAAAPMu/C4AAAAA/S4AAAAAAC8BLwAAAAAAAAAAAi8AAAkvCy8AAAAADC8AQczh1wALAg4vAEHc4dcACxIWLxcvAAAYLwAAAAAAABwvIC8AQfjh1wALBiEvIy8kLwBBjuLXAAs6Ki8AAAAAAAArLywvAAAAAAAALy8AADEvNi83LwAAAAA4LwAAAAAAAAAAOS8AADwvAAAAAAAAAABBLwBB2OLXAAsCQi8AQfTi1wALLkYvRy9IL08vAAAAAFIvVC8AAAAAAABWLwAAAAAAAFcvWC9gLwAAAAAAAAAAYi8AQa7j1wALLGMvAAAAAAAAZC9mLwAAAAAAAAAAaS8AAGsvAABtLwAAAABuLwAAAAAAAHAvAEHk49cACypxLwAAdC8AAHkvAAAAAAAAAAB6L4svjS8AAAAAAACPLwAAAAAAAAAAki8AQZzk1wALApcvAEGu5NcACwqYLwAAAAAAAJovAEHC5NcAC0CbL5wvAAAAAJ0vAACkLwAApS8AAAAApi8AAKkvAAAAAAAAAACrLwAAsS8AAAAAAAAAALIvsy+0L7UvAAC5L7ovAEGU5dcACwK+LwBBpOXXAAtGvy8AAAAAxS8AAAAAAAAAAMkvAAAAAAAAAADKLwAAAADML9IvAAAAAAAA0y8AAAAAAADUL90vAADeL+AvAADhLwAAAADzLwBB9OXXAAsC9S8AQYDm1wALNPYvAAABMAAAAAACMAAABDAFMAAAAAAGMAAABzAAAAAACDAAAAkwAAAKMAAAAAAAAAAADTAAQc7m1wALEhUwAAAyMDQwAAAAAAAAAAA1MABB8ObXAAsINjA3MAAAODAAQYrn1wALAjkwAEGc59cACww6MAAAAAAAAAAAPDAAQcDn1wALAj4wAEHg59cACxQ/MAAAQzBEMEUwAAAAAE8wUjBTMABB/ufXAAsEVDBYMABBkujXAAsyWzAAAF4wAABfMAAAAABgMAAAAAAAAAAAaTAAAAAAajAAAAAAAAAAAG4wczAAAAAAdDAAQd7o1wALIHowAAAAAAAAezAAAAAAAAB8MAAAAAAAAAAAhDAAAIUwAEGI6dcACxKHMAAAiTCNMAAAAAAAAI8wkDAAQbLp1wALApIwAEG+6dcACwSTMJQwAEHS6dcACwKVMABB3unXAAsCljAAQfDp1wALDJ0wAAAAAAAAojCjMABBjOrXAAtQpDC7MAAAAADNMM4wAAAAAAAAzzAAAAAAAAAAANAw1jDdMAAAAAAAAAAA3jAAAOAw4TAAAAAAAAAAAOIwAAAAAAAA4zAAAOgwAAAAAAAA7DAAQfzq1wALEu8wAAAAAAAA8DAAAAAAAADxMABBmOvXAAsQ8jAAAPcwAAAAAPgwAAD6MABBwOvXAAsG/DAAAAQxAEHQ69cACxQGMQAAAAAAAAcxCDEAAAAAAAAKMQBB9OvXAAsQCzEAAAAAEjEAABUxAAAWMQBBnOzXAAsMGTEAAAAAAAAbMR4xAEG27NcACwIhMQBBxuzXAAsyIjEjMTsxAABAMQAAAABDMQAARDEAAEcxAABRMQAAAAAAAAAAUzFmMQAAaDEAAAAAcTEAQZTt1wALDn4xAAAAAH8xAACBMYUxAEG47dcAC0KHMQAAiTEAAIoxlTEAAJYxAACZMQAAnTEAAAAAAACfMaAxAAAAAAAAAACjMcExAAAAAMMxAAAAAMQxAAAAAMYxxzEAQYzu1wALJMkxAADKMcsxAADMMQAAAADXMd8xAAAAAAAAAADlMQAA5jHqMQBBvu7XAAsC6zEAQcru1wALHuwx+TEAABgyAAAZMgAAJDIAAAAAAAAAACcyAAAqMgBBgO/XAAtQKzItMgAALjIAAAAAAAAAAC8yAAAAADIyNDI1MgAAAAAAADYyAAAAAAAANzIAADgyAAA6MgAAAAA7MgAAPjIAAD8yAAAAAEIyAABFMkgySTIAQeLv1wALDEsyAABNMgAAAABOMgBBgPDXAAsgVDJVMlgyAABZMgAAAAAAAAAAXTIAAAAAAABfMmAyYjIAQa7w1wALLGYyAABtMm4yAAB+MgAAgDIAAAAAAACBMgAAgjIAAAAAAAAAAIMyAACEMoUyAEH68NcACxCGMgAAjjIAAAAAAAAAAJAyAEGa8dcACzaSMgAAAACUMgAAAACVMgAAAAAAAAAAljIAAAAAAAAAAJcyAACYMgAAmTIAAAAAAACaMp4ynzIAQdrx1wALBKAypDIAQejx1wALAqYyAEH68dcACwaqMgAAqzIAQYzy1wALRqwyAAAAALYyAAAAAAAAuDK5MgAAujLEMsUyyTLKMgAAAAAAAAAAzDIAAAAAzTIAAAAAzzLRMgAA2TIAAAAAAADcMgAA3TIAQeby1wALAt4yAEH48tcACwTgMuMyAEGG89cACwjkMgAAAADlMgBBnPPXAAsG6DIAAO0yAEGu89cACx7wMgAAAADxMgAAAAAAAPMy9DL2MgAAAAAAAAAA9zIAQdrz1wALEPky/jIAAAAzAAAAAAQzBTMAQfTz1wALDAszAAAAAAwzAAAPMwBBivTXAAsEFTMWMwBBmPTXAAsSFzMYMxkzAAAaMwAAAAAAAB0zAEG49NcACwgeMwAAHzMgMwBByvTXAAsmJjMAACszAAAsMwAAAAAAAC0zAABFM0YzSDNJMwAAAABKMwAASzMAQfz01wALAk4zAEGU9dcACwZeMwAAcDMAQaz11wALGnEzAAAAAHIzAAAAAAAAAAB2MwAAAAAAAHgzAEHQ9dcACyx5MwAAejN/M4MzAAAAAAAAhTMAAAAAhjMAAAAAhzMAAAAAljMAAAAAAACXMwBBkPbXAAsYnDMAAAAAozOwMwAAAAAAALkzAADBM8UzAEGy9tcAC17HM8szAADMM80zAADOMwAA2DMAAAAAAAAAANwzAAAAAAAAAADdM/MzAAAAAPUz9jMAAAAA9zMAAAAA+TMAAP4zAAAAAAAA/zMAAAAAAAAAAA00AAAQNAAAAAAAABE0AEGc99cACxISNAAAAAATNAAAFzQAAAAAHjQAQbj31wALOh80AAAqNAAAMjQAADY0NzQ5NAAAAAA7NDw0AAA9ND40AABANAAARDRFNEo0AABLNEw0AABNNE80UzQAQfz31wALElk0YTQAAGI0AAAAAAAAAABsNABBmPjXAAsWbjQAAAAAAAAAAG80AAAAAAAAAABxNABBuPjXAAsgczQAAAAAAAB0NAAAAAB2NH40AAB/NAAAhTQAAIg0iTQAQeT41wALXos0AACRNAAAAAAAAAAAkjSTNAAAlDQAAAAAAAAAAJg0mTSaNJ40AACfNKA0ojSjNAAApDQAAAAApjSnNAAAqTQAAAAAAAAAAK80AACyNAAAtTQAAAAAtjQAAAAAtzQAQd751wALNLg0uTQAALw0AAAAAMw00jQAAAAA1TTYNAAAAAAAANo03zQAAOE04zQAAOQ0AADnNAAA6DQAQZ761wALAuk0AEGs+tcACxbrNAAAAAAAAO008zQAAAAAAAD0NPU0AEHQ+tcACxD2NAAA+zQAAAAAAAAAAPw0AEHw+tcACwL+NABB/vrXAAsSATUAAAAAAzUAAAAAAAAAAAU1AEGc+9cACwIKNQBBsvvXAAsODTUAABI1AAAbNQAAIDUAQdD71wALFiE1IzUAACQ1JTUmNSc1AAAAADE1MjUAQfT71wALCDc1AAA5NTs1AEGM/NcACxI9NQAAAAAAAEI1AAAAAAAARjUAQa781wALAlY1AEHE/NcACx5YNQAAWzUAAAAAXDUAAAAAXjUAAAAAAABfNQAAYDUAQez81wALDmQ1AABlNWc1AAAAAGg1AEGG/dcACyRrNXU1AAB2NQAAAAAAAHc1AAAAAAAAfDV+NYE1AAAAAAAAhjUAQbT91wALFIk1AAAAAAAAAACLNQAAAAAAAJI1AEHa/dcACxSTNQAAlDWVNQAAAACXNZw1ojWjNQBB/v3XAAsCpDUAQY7+1wALRqY1AACoNQAAAACpNao1szUAALc1AAAAALg1AAAAAAAAuTUAAL01AAAAAMI1wzUAAMQ1xTUAAMY1AAAAAMc1AAAAAAAAyDUAQeL+1wALDMk1AAAAAMw1AADPNQBBkv/XAAso0DXSNds1AAAAAAAA5TUAAOY1AADpNQAA7DXuNQAAAAAAAAAA+DX5NQBB1P/XAAsgCjYAAAw2AAAAAA42AAAAAA82AAAQNgAAAAAAAAAAEjYAQYCA2AALAhM2AEGUgNgACwIVNgBBoIDYAAsgIjYAAAAAJDYAAAAAJTYAAAAAJjYnNgAALDYAAC02LjYAQdSA2AALDjA2AAAAAAAAAAAxNjY2AEH2gNgACzo+NgAAQDZBNkI2AAAAAEM2RjYAAEk2SzZMNlA2AAAAAFI2AAAAAAAAVTYAAAAAAABWNgAAAAAAAFc2AEG6gdgACyZYNl02AAAAAAAAAABeNgAAXzYAAAAAYDYAAAAAAABhNgAAAABiNgBB7oHYAAsGZDYAAGc2AEH+gdgACzZsNgAAbTYAAG42AAAAAG82AAB4NgAAAAAAAII2AAAAAIM2AAAAAAAAAACENgAAhTYAAI82kTYAQcyC2AALLpI2pjYAAKc2qjYAAKs2AAAAAAAAAACsNgAAAACvNgAAAAAAAMI2AADDNgAAxTYAQYaD2AALAtk2AEGYg9gACxbbNgAAAAAAAAAA3jYAAAAAAADgNuE2AEHCg9gACxrjNgAAAADkNug2AADvNgAA8DbyNgAAAADzNgBB7oPYAAso9DYAAAAAAAD4NgAA+jb7NgAA/Db/NgU3BjcHNw03AAAAAAAAAAAPNwBBooTYAAsEEDcRNwBBtITYAAsGEjcAABY3AEHEhNgACyAXNwAAAAAAABg3AAAAABk3AAAAAAAAGzccNwAAAAAdNwBB9ITYAAtkJTcAAAAAAAAAACY3AAAAAAAAAAAnNwAAAAAoNwAAAAApNwAAKjcvNwAAMDc4NwAAAAA6NwAAPDcAAAAAAAA9Nz43AAAAAAAAAABCNwAAAABFNwAARzcAAAAAAABINwAAAABJNwBB6oXYAAscSjcAAEw3TTcAAAAATzcAAFE3AAAAAAAAAABSNwBBkobYAAsIUzcAAAAAXTcAQaaG2AALKl43AAAAAGA3AAAAAGI3AAAAAGM3ZTcAAAAAZjdpN2s3AABuNwAAAAB1NwBB6IbYAAsCdjcAQfaG2AALEnc3eDcAAAAAAAB8NwAAAACANwBBnofYAAsClzcAQbKH2AALqgGaNwAAAACbNwAAAAAAAKA3oTcAAAAAAACmNwAAAAAAAKc3AACqNwAAAACrNwAAAACuNwAAAACwNwAAAAAAALQ3AAC1NwAAAAAAAAAAtje7N703AAAAAMU3AAAAAMY3AADHN8o3AAAAAAAAyzcAAAAAAADMN803AAAAAAAAAADONwAAAAAAANA3AAAAAAAA0TcAANI3AADVN9033jfgN+E3AADjNwAA5DflNwBB8ojYAAsK5zfoNwAAAADtNwBBionYAAsY7jcAAAAAAAAAAPA3AAAAAAAAAADxN/I3AEGsidgACwT2N/k3AEHMidgACzj6N/s3AAAAAAAAAAD8NwAAAAAAAP03AAAAAAE4BDgAAAU4AAAAAAY4AAAJOAo4AAAAAAs4AAAaOABBjorYAAsYHDgdOCM4AAAlOAAAAAAmOAAAKzgAAEA4AEGwitgACyBBOAAAAABFOAAARjgAAEg4STgAAAAAAABROAAAAABYOABB4orYAAsUXjgAAAAAAABfOAAAAABjOAAAaDgAQYKL2AALCGo4AAAAAGs4AEGUi9gACwJuOABBpIvYAAsQdjgAAHk4AAB8OAAAAACCOABBvovYAAsCgzgAQcyL2AALBoU4AACNOABB3ovYAAs2jjiSOAAAAAAAAJM4AAAAAAAAlTiWOAAAAAAAAJc4mDiZOJw4nTieOJ84oDihOAAAozgAAKU4AEGojNgACwymOAAAqziwOLE4sjgAQcqM2AALQrM4vjjCOAAAyTgAANA4AADTOAAAAADUONY41zgAAAAA2DgAAAAAAADZOAAA2jgAAAAAAAAAANw45DgAAAAA5TjmOABBmI3YAAss6DgAAAAA6TgAAAAAAADrOPA4AAAAAPE48jjzOAAAAAD0OAAAAAAAAAAA9jgAQdyN2AALAvc4AEHojdgACwz7OAAA/DgAAAAACDkAQZyO2AALGgk5AAAAAAw5DTkTOQAAFTkAAAAAAAAAABc5AEHCjtgACyAjOQAAJDkAAAAAAAAAACc5AAApOSo5AAAAAAAAAAArOQBB8o7YAAtCLDkAAAAALzkyOQAAAAAAAAAANDkAAAAAAAAAADU5NjkAAD05AAAAAD45AABCOQAARTkAAAAAAABJOQAAAAAAAEw5AEHGj9gACxZNOQAAAABOOQAAAAAAAFg5AAAAAFk5AEHmj9gACyhaOVs5AAAAAAAAAABeOQAAAAAAAAAAXzlpOQAAAAAAAAAAazlxOXc5AEGikNgACzB4OQAAAAAAAHk5AAAAAAAAAAB/OQAAgDmBOYY5AAAAAAAAiDmJOQAAAAAAAAAAizkAQeCQ2AALJo05kDmROQAAAACUOZY5AAAAAAAAmDmhOQAAAAAAAAAAozmmOag5AEGQkdgACzypOao5rTmzOQAAtDkAALU5tjkAAAAAtzkAAAAAuDkAAAAAAAAAALk5AAC7OQAAAAC+OQAAAADBOcI5xDkAQdaR2AALAss5AEHkkdgACxLOOQAA0znUOdY5AAAAAAAA2TkAQYKS2AALENo5AAAAAAAAAADbOQAA3DkAQZyS2AALAt85AEGuktgACwbgOQAA4jkAQcCS2AALGuM5AADkOQAA5zkAAAAAAADoOQAAAADqOes5AEHyktgACwLuOQBB/pLYAAsG8TkAAP05AEGOk9gACxr+OQAAAAD/ORc6AAAZOgAAHDoAAB06HjogOgBBspPYAAsaIToAACI6LjoAAAAAAAAAAC86AAA7OgAAPDoAQdqT2AALJD86AAAAAAAAAABIOgAAAABTOgAAVDpWOlc6AAAAAFg6AABhOgBBjJTYAAs8YzoAAAAAZDplOmc6AAAAAGg6AAAAAAAAdDp9OgAAAACOOgAAAAAAAAAAkzoAAAAAljqZOgAAAACaOqw6AEHUlNgACyqtOgAArjoAAAAAAAAAAK86AAAAALE6tTq5OgAAAAAAALo6AAAAAAAAuzoAQYiV2AALMsM6xDoAAAAAAADFOsY6yDrKOgAA2ToAAAAAAAAAANo6AAAAAOM66jrsOgAAAADtOu46AEHKldgACybwOgAAAAAAAPE6AAAAAAAAAAD2OgAA+DoAAPk6AAD8OgAAAAD+OgBBgJbYAAsaATsAAAAAAjsAAAU7CTsAAAAAAAALOwAADjsAQaaW2AALCA87AAAAABA7AEG4ltgACyQTOxk7AAAAAAAAGjsAABs7AAAAAB47AAAfOwAAAAAAACE7IjsAQeiW2AALAiM7AEH0ltgACxQkOwAAAAAyOzo7AABBO0I7AABHOwBBppfYAAsISTsAAEo7SzsAQbiX2AALAk87AEHSl9gACwxRO1M7AABaO1s7XDsAQeyX2AALDGQ7AAAAAAAAAABmOwBBgpjYAAsCZzsAQZaY2AALBm07AABuOwBBqpjYAAsigDsAAAAAAAAAAII7AACGO4g7AACQOwAAAAAAAAAAkjuTOwBB2pjYAAsslDsAAAAAAACXO547ojsAAAAAAACjOwAAAAAAAK07rzsAAAAAAACwO7E7sjsAQZCZ2AALErU7AAAAAAAAAAC5OwAAAAC7OwBBsJnYAAsUwDvBOwAAAADIOwAAAAAAAAAAyjsAQdCZ2AALFss7zDsAAM07AAAAAM87AAAAANA70TsAQf6Z2AALGNI71TsAAAAAAADWO9c7AAAAAAAAAADYOwBBtprYAAsC2TsAQcKa2AALTtw7AADdO947AADiOwAAAAAAAAAA5jsAAOc7AADtOwAAAADuOwAAAADvO/A7AAAAAAAAAADxOwAAAAAAAAAA8zsAAAAA9Dv1O/Y7AAD8OwBBsJvYAAsG/TsAAP47AEHEm9gACwr/OwA8BDwAABQ8AEHYm9gACwwgPAAAAAAhPAAAIzwAQfSb2AALCiQ8AAAAACU8JjwAQZCc2AALKic8AAAoPAAAAAAAACo8AAAtPDI8AAAAAAAAAAAzPAAAAAAAADQ8AAA4PABByJzYAAsqRDwAAEs8AAAAAE48AAAAAAAAAABPPAAAAAAAAFA8AAAAAAAAUTxZPFs8AEGAndgACxxcPAAAAABfPAAAAAAAAGA8AAAAAGI8AABkPGU8AEGmndgACxRmPGg8AABpPAAAAABqPAAAAABrPABBxJ3YAAsgbDwAAAAAAAAAAHk8AAAAAHw8AAB9PH48AAAAAAAAfzwAQe6d2AALbIA8AACEPIo8AAAAAAAAizwAAAAAAACMPAAAjTwAAAAAmDwAAKI8AAAAAAAApDwAAKU8pjwAAAAApzwAAAAAuTy6PAAAvDzAPAAAwTwAAAAAAADCPAAAwzwAAMU8zTzVPNk82jwAAN48AADfPABB9J7YAAsC4jwAQZKf2AALAuQ8AEGen9gACwLlPABBrp/YAAsO6TzqPAAAAAAAAAAA6zwAQcif2AALJuw8AAAAAAAA7TwAAAAAAAAAAPA8AAAAAPE8AAAAAAAAAADyPPM8AEH6n9gACy70PAAA+TwAAAAA/DwAAAAA/TwAAAAA/zwBPQI9AAAAAAQ9AAAUPRU9AAAAACE9AEG2oNgACygiPQAAAAAjPQAAAAAAACg9AAAqPQAAAAAAADA9AAAAADE9AAAAADQ9AEHooNgACxg1PQAAAAA6PQAAAAA7PQAAAAAAAAAAPD0AQZah2AALDD09AAAAAAAAAAA+PQBBrKHYAAsuPz0AAAAAQT0AAEY9AAAAAAAAAABHPQAASD0AAAAASj0AAAAAAABRPQAAUz1UPQBB7KHYAAsoVT0AAFY9Vz0AAFg9AABZPQAAWz0AAF09AABgPWQ9AABlPQAAZj1oPQBBnqLYAAsmbD0AAAAAAABtPQAAbj0AAAAAAAB8PQAAgT2CPQAAAACDPQAAhD0AQc6i2AALDoU9AAAAAAAAiD0AAIk9AEHootgACwqPPQAAAAAAAJU9AEGEo9gACzCXPQAAAAAAAJs9AAAAAKg9AAAAAAAAAACpPa49rz0AAAAAsD0AAAAAAAC/PQAAwz0AQcyj2AALFMo9AAAAAAAAyz0AAAAAAAAAAM09AEHqo9gACybOPdA9AAAAANM9AAAAANU91z0AANg9AAAAANk9AADbPd493z3jPQBBpqTYAAsQ5D0AAAAAAAAAAOU96z3wPQBBxKTYAAsa8j30PQAA9T0AAAAAAAD4PQAAAAAAAAAA+T0AQeqk2AALIvo9AAAAPgAAAAAEPgAAAAAAAAAABT4GPgs+DT4AAAAAED4AQZal2AALBBE+Ej4AQaql2AALAhQ+AEG6pdgACzIVPgAAAAAWPgAAAAAAABc+AAAYPhk+AAAaPh0+Hj4AACc+Kz4AACw+AAA0Pj8+AABBPgBB9qXYAAsCTj4AQYam2AALKlY+AAAAAAAAWT4AAAAAXj4AAF8+AAAAAGk+AAAAAGo+AAAAAG0+bj5vPgBBvqbYAAskcj4AAAAAAAB2PgAAdz57Pn4+AAB/PgAAgD4AAAAAAAAAAIg+AEGIp9gACwiJPos+AACNPgBBoKfYAAsgjj4AAAAAjz6XPpg+mT4AAAAAmj4AAJ4+AACgPgAAoT4AQcyn2AALBqM+pD6lPgBB3KfYAAsMpz4AAAAAAAAAAKk+AEHyp9gACxyrPqw+AAAAAK8+AAAAAAAAsD4AAAAAsT6yPrQ+AEGYqNgACwK3PgBBqqjYAAsCuD4AQbqo2AALQLo+vD69PgAAAAC/PgAAAADAPgAAAAAAAMM+xD4AAAAAxT7OPgAAAAAAAM8+AAAAAAAA0D4AANE+AAAAAAAA2D4AQZCp2AALHtk+3T4AAOE+AADnPgAA6D7pPgAAAACAPwAAAACDPwBBvKnYAAsUhD+FPwAAAACGPwAAAACHPwAAjD8AQd6p2AALNI0/AAAAAI4/kT8AAJI/AAAAAAAAAACTP5Q/lT+YPwAAAAAAAJk/nD8AAAAAAACePwAAoT8AQaSq2AALDKI/AAAAAAAAAACjPwBBvqrYAAsCpD8AQdCq2AALFqU/pz+pPwAArj8AALA/AACxPwAAsj8AQf6q2AALBrM/tD+4PwBBkKvYAAsQuT+7PwAAvj8AAAAAAADBPwBBrqvYAAsSxj/NP9A/AAAAAAAAAADRP9Q/AEHKq9gACwjZPwAAAADaPwBB5KvYAAtS2z8AAAAA3D8AAAAAAAAAAN0/AAAAAAAA3j8AAOU/AAAAAAAAAADnP+g/AAAAAAAAAADqP+s/7D/tPwAAAADuPwAAAAAAAAAA7z/wPwAA8T/2PwBBxKzYAAsc+D8AAAAAAAAAAPo/+z8AAPw/AAAAAAAA/T//PwBB6qzYAAswBkAAAAAAAAAPQAAAEkAUQBZAF0AAAAAAAAAZQBtAAAAAAAAAAAAcQAAAHUAfQCdAAEGkrdgACx4oQAAAAAAAACxAMkAzQEFAAABCQENAAAAAAAAARUAAQeCt2AALKkZAAAAAAEhASkAAAAAAS0AAAAAATEAAAAAAAAAAAE5AAABPQAAAAABSQABBlK7YAAsOX0AAAAAAYEAAAGFAZEAAQbau2AALAmVAAEHErtgACwJpQABB0K7YAAsSa0AAAAAAckAAAAAAd0AAAHlAAEHyrtgACwx6QAAAAAAAAHxAfUAAQY6v2AALHn9AgUAAAAAAAACEQAAAhUAAAIdAAACRQAAAAACTQABBuK/YAAsKlkAAAAAAnUCeQABB1K/YAAtWn0CjQKRAAAAAAAAAp0AAAKhAAAAAAAAAqUAAAAAArkAAAAAAskC1QAAAAAAAALpAAAAAAAAAvUDJQAAAAAAAAMpAy0DTQAAA1EAAANZAAAAAAAAA2EAAQcSw2AALDNlAAAAAAAAAAADbQABB3rDYAAsg3EDkQAAAAAAAAAAA5UAAAOpAAAAAAAAAAEEAAAAAAUEAQYqx2AALDAVBAAAAAAAAAAAGQQBBorHYAAs0C0EAAAAAAAAAAA1BDkEAAAAAAAAPQQAAAAAQQRtBAAAAAAAAAAAfQQAAIEEAAAAAAAAhQQBB4LHYAAssJEEAAC5BAAAAAAAAAAAxQQAAMkEAADRBAAA1QQAANkEAADhBAAAAAAAAQUEAQZiy2AALLENBAAAAAAAARUEAAAAAAAAAAEdBAABIQUlBAAAAAAAAS0EAAAAAAAAAAExBAEHWstgACwxOQVRBAAAAAFZBV0EAQfCy2AALDFhBAABZQQAAAABaQQBBhrPYAAsWW0EAAAAAAABcQQAAAAAAAAAAXkFiQQBBrLPYAAsIZ0EAAAAAaUEAQb6z2AALGm1BAABwQQAAAAAAAAAAdEEAAAAAdkEAAHdBAEHis9gACwJ4QQBB8rPYAAsYekEAAIFBAACCQQAAhEEAAAAAAACJQYxBAEGWtNgACziNQQAAAACOQQAAkEEAAAAAkUGTQZhBAAAAAJpBAAAAAAAAnkEAAAAAqUEAAAAArkGwQbFBAACzQQBB4rTYAAsitEEAAAAAxEHHQQAAAADJQdNB2UEAAAAA2kHbQQAAAADcQQBBlLXYAAsG3kEAAN9BAEGotdgACwLgQQBBuLXYAAsc7EEAAPFB8kEAAPVB9kEAAPdBAAAAAAAA+UH7QQBB3rXYAAsE/kH/QQBB+LXYAAsGAUIAAAJCAEGIttgAC5ABEUIAAAAAHEIdQh5CAAAAAB9CAAAAAAAAKUIqQgAAAAAAACxCLUIAAAAAAAAuQjFCAAAyQjVCNkIAAAAAAAA4QjtCAAAAAAAARUIAAElCAAAAAE9CAAAAAFBCAAAAAAAAAABSQgAAAABVQgAAV0JdQgAAAAAAAAAAXkIAAAAAX0IAAAAAAABhQgAAYkJkQmhCAEGit9gACxxqQmxCAABuQgAAAABvQgAAAAAAAAAAcEJ1QnZCAEHQt9gACwZ9QgAAh0IAQeC32AALOIlCjEIAAI5CAAAAAI9CAACVQgAAAACWQpdCAAAAAAAAAACYQgAAmUKaQgAAm0KdQgAAnkIAAJ9CAEGiuNgACwinQgAAAACoQgBBuLjYAAsIqUIAAAAArEIAQcq42AALArBCAEHYuNgACwKxQgBB/rjYAAsGskIAALhCAEGuudgACxi5QrtCvEIAAAAAAAC9QgAAAAAAAAAAxEIAQdi52AALCMVCAADHQs5CAEHsudgACxbPQgAAAADRQgAA00IAAAAAAAAAANpCAEGMutgACxrbQuVC50IAAAAA6EIAAAAAAADpQupCAADrQgBBsLrYAAsG7ELvQvlCAEHGutgACwr6QgAA+0IAAPxCAEHcutgACzD9Qv5CAAD/QgFDAAADQwAAAAAAAAAAC0MTQwAAFkMAAAAAAAAAABtDAAAAAB5DIUMAQZa72AALCCJDAAAAACRDAEGsu9gACwglQydDAAAqQwBBxrvYAAsQK0MsQzNDNEMAAAAANUNBQwBB4LvYAAsaQkMAAAAAAAAAAENDAABEQwAARUMAAAAATkMAQYS82AALXFRDAABWQ1dDAAAAAAAAWUNcQwAAAABdQwAAYEMAAAAAY0MAAGRDAAAAAHBDAAByQwAAAAAAAHRDAAAAAAAAAAB3Q3hDAAB5QwAAj0MAAJZDAACZQwAAAAAAAJpDAEHuvNgACwKcQwBBkL3YAAsinUMAAJ5DoUMAAAAAAAAAAKJDo0MAAKVDAAAAAAAAAACmQwBBwL3YAAsCqEMAQc692AALHrZDAADAQ8RDAAAAAAAAxkPHQwAAAADJQwAAAADKQwBB/r3YAAsCy0MAQYy+2AALKMxDzUMAAAAAz0MAAAAAAADbQwAA3EMAAAAAAADxQwAAAAAAAAAA8kMAQb6+2AALGvNDAAAAAPdDAAAAAAAA+UMJRAAACkQAAAtEAEHivtgACwQORA9EAEHwvtgACwIQRABB/L7YAAsgFEQVRBlEAAAAAAAAHUQAAAAAIUQAAAAAIkQAAAAALUQAQay/2AALJi5EMEQ2RAAAAAA6RAAAAAA8RAAAAAA9RAAAAAAAAAAAPkQAAENEAEHcv9gACz5HRAAAAAAAAEtETEQAAE1EAABORAAAU0RURAAAAABVRAAAVkRXRAAAAAAAAFhEAAAAAAAAWUQAAAAAAABeRABBpMDYAAsyX0QAAGFEAABjRAAAAAAAAGhEaURqRAAAAABrRAAAAAAAAG9EAAAAAAAAckQAAAAAc0QAQejA2AALLHdEAAAAAAAAeEQAAAAAAAB+RAAAAAAAAAAAgEQAAAAAAACDRAAAhESHRI1EAEG0wdgACxqURAAAAACWRAAAl0QAAAAAmEQAAAAAAACbRABB2sHYAAsOnEQAAAAAnUSeRAAAn0QAQfTB2AALCKFEokQAAKdEAEGSwtgACxatRAAAAAAAAK5Er0QAALJEAAAAALNEAEG2wtgACxa0RAAAAAAAAAAAvES9RAAAAAC+RMBEAEHYwtgACxbBRAAAAAAAAMREAAAAAMVEAAAAAMdEAEGUw9gACy7MRAAAAADSRAAA1UTWRAAAAAAAAAAA10QAAAAA2EQAAAAA3kQAAAAA30ThROJEAEHQw9gACxbjRAAAAADkRAAAAADlRAAA5kQAAOhEAEH6w9gACwLpRABBkMTYAAsM60QAAAAAAAAAAO1EAEGsxNgACwTuRP5EAEHCxNgACxr/RABFAAABRQJFAAAAAAAABUUHRQlFAAAPRQBB6sTYAAuKARRFAAAAAAAAFkUAADJFAAAAADhFOkU+RQAAAABARQAAAABBRQAAAAAAAERFAABFRQAARkUAAAAAAABHRQAAAAAAAAAASUUAAAAAAAAAAEtFAAAAAAAATUVORQAAAAAAAAAAT0VQRVFFAAAAAAAAVUUAAFZFV0VYRVpFYUViRQAAY0UAAGZFAABsRQBB/sXYAAsCb0UAQY7G2AALFnBFAAAAAHFFAAAAAHJFc0UAAHZFd0UAQbjG2AALAnhFAEHIxtgACxSdRQAAAAAAAJ5FAAAAAAAAn0WhRQBB5sbYAAssokWnRahFqUUAAAAAtUUAAAAAAAC2RQAAAAAAALhFukW+RQAAv0UAAAAAw0UAQZ7H2AALBMRFxUUAQcjH2AALBM5Fz0UAQdjH2AALRtBFAAAAAAAA10UAAAAAAADZRdtFAADcRQAA3UUAAAAA3kUAAAAA30XjRSFGAAAAAAAAAAAiRgAAAAAjRgAAMEYAAAAANEYAQajI2AALHjZGAAAAAAAAAAA4RjpGAAAAAD9GAAAAAAAAAABTRgBB0MjYAAsCV0YAQdzI2AALAllGAEHsyNgACwJaRgBB+sjYAAskXEYAAAAAXkYAAAAAAABfRgAAAAAAAGBGAABhRgAAAAAAAG5GAEGsydgACx5vRgAAAAB0RnVGdkYAAAAAgUaIRgAAiUaKRgAAi0YAQdrJ2AALDI5GAAAAAAAAAACQRgBB9snYAAsak0YAAAAAAACURgAAAACbRgAAAACeRq1GrkYAQaDK2AALArFGAEGsytgACzqyRrRGAAAAAAAAvEYAAL9GAAAAAMBGAADBRgAAAADDRsRGAADGRgAAAAAAAAAAyUYAAAAAAAAAAMtGAEH4ytgACxrMRgAAAAAAAAAAzUbORgAAz0YAAAAA0EbXRgBBpMvYAAsC5kYAQbDL2AALEudG6EYAAAAA7Eb0RgAA9kb7RgBB1MvYAAsW/EYHRwAACEcAAAAAAAAAAAlHAAALRwBB9MvYAAsCDEcAQYbM2AALXA1HAAAAAA5HAAAAAA9HEEcAAAAAEkcTRxRHAAAAAAAAFUcAABtHAAAcRwAAAAAAAAAAHUcAAAAAAAAfRyBHAAAAACZHAAAAAAAAJ0coRwAAAAAAACxHAAAAAC5HAEHszNgACyIvRwAAMUc3RwAAOkcAADtHAAAAAAAAAABARwAAAABBR0JHAEGYzdgACxRDR0tHAABNRwAATkcAAAAAAABaRwBBuM3YAAsKXUdeR19HYUdpRwBB2s3YAAsKakcAAGtHAABsRwBB8M3YAAsgbUcAAG9HcUcAAAAAckcAAAAAAAAAAIRHAAAAAAAAhkcAQajO2AALLodHAACIR4lHAACLRwAAAACMR5BHAACbRwAAnEcAAKBHAAAAAAAAAAChRwAApEcAQejO2AALDKVHAACoR6lHAACqRwBB/s7YAAsMrEcAAK9HAAAAALRHAEGWz9gACwK1RwBBos/YAAsev0cAAAAAAADARwAAwUcAAMJHw0cAAAAAAAAFSAxIAEHcz9gACxoNSBJIAAAAAAAAAAATSAAAFEgAAAAAAAAVSABBgNDYAAsYF0gAAAAAAAAYSAAAGUgAABxIAAAAAB1IAEGo0NgACzoiSAAAAAAjSAAAAAAAAAAAKUgAAAAAAAAsSAAALUgAAAAAAAAuSC9IMEgAAAAAAAA1SAAAAAAAADZIAEHu0NgACwQ4SDpIAEH+0NgACwI7SABBitHYAAsIP0gAAAAAQEgAQZ7R2AALFklIAABZSAAAWkhbSAAAAAAAAF1IXkgAQb7R2AALEl9IAAAAAAAAAABkSGVIAABmSABB3NHYAAsIZ0hpSAAAakgAQfDR2AALPGxIbUhuSG9IAABySAAAAAAAAAAAeUh8SAAAAAB+SAAAAACJSItIAAAAAAAAjEgAAI5IAAAAAAAAAACaSABBttLYAAsInEgAAAAAnUgAQcrS2AALTp5IAACgSAAAAAAAAAAAokgAAAAAAACkSAAAAAClSKZIAAAAAKlIAAAAAAAAAACqSAAAAAAAAKtIrEgAAK1IAAAAAAAAAACwSAAAAACzSABBqtPYAAsktEgAALhIAAAAALlIu0gAAAAAAADESAAAAAAAAMVIAAAAAMZIAEHc09gACw7HSAAAyEgAAAAAy0jNSABB9tPYAAtA0UjTSNhIAADcSAAAAADdSAAA30jgSAAAAAAAAOFIAAAAAOpI8kgAAAAAAAAAAPVI/Ej9SAAAAAD+SAAAAAACSQBBxNTYAAsEB0kISQBB3NTYAAsICUkAAAAADEkAQfDU2AALIA5JAAAUSQAAAAAVSQAAFkkAAAAAF0kAABpJAAAAAB5JAEGc1dgACwwfSQAAAAAiSQAAJkkAQcLV2AALAitJAEHO1dgACzYzSTVJAAAAADZJAAA3SThJOkk8SQAAQElBSQAAAABCSUtJAABNSQAAAAAAAE5JAAAAAAAAUUkAQY7W2AALGFVJWklbSV1JAAAAAGBJY0kAAGRJAABpSQBBstbYAAsIa0kAAAAAcEkAQcTW2AALBHFJdEkAQdbW2AALWnZJAAAAAAAAe0l/SYBJAAAAAAAAAACJSQAAAACLSY1JAAAAAI5JAAAAAAAAAACPSQAAAACQSQAAAAAAAAAAkUkAAJhJAACZSQAAmkkAAAAAAAAAAJtJAACcSQBBvNfYAAsEnUmeSQBB5tfYAAsmoEkAAAAAAAClSaxJAAAAAK5JskkAAAAAs0m1SQAAAAC6ScFJy0kAQaDY2AALAsxJAEGy2NgACx7PSQAA0EkAAAAAAADUSQAAAAAAANVJAADWSeNJ5EkAQeDY2AALAudJAEHs2NgACxboSQAAAAAAAOlJ8UkAAAAAAAAAAPJJAEGO2dgAC1L0SQAAAAAAAAAA9kn+SQAAAAAAAAdKDUoAAAAAAAAAAA5KAAAAAAAAAAAPShBKAAAAABFKAAAAABJKAAAAAAAAAAATShRKAAAAAAAAFUoAABdKAEHy2dgACw4YSgAAGUoAABpKHUogSgBBjNrYAAsWIUoAAAAAAAAlSgAAAAAAAC5KAAA2SgBBrNrYAAsSN0o7SgAAAAA9SgAAAAAAAD5KAEHK2tgAC3BASkNKAAAAAEpKAAAAAEtKAABQSgAAV0pYSgAAX0oAAGFKakoAAAAAAABrSm9KcEoAAHNKd0p4SgAAAACQSgAAAAAAAJVKlkoAAAAAAAAAAJdKAACYSgAAAAAAAJlKAAAAAJpKAACbSpxKAAAAAJ9KAEHI29gACwKnSgBB1tvYAAsSqEoAAAAAAACsSq1KAACxSrJKAEGU3NgACwSzSrRKAEGm3NgACwi1SrZKAAC4SgBBwtzYAAsYuUq6SrtKvEoAAAAAykoAAAAAy0rUStZKAEHq3NgACxLuSvFKAAAAAPNKAAAAAAAA+UoAQYbd2AALEPpKAAD9SgAAAAAAAAAA/koAQard2AALAgJLAEHc3dgACzADSwAABUsKSwAAAAAAAA1LAAASSwAAAAAAABdLHUsAAAAAHksAAAAAH0sgSyFLJ0sAQZbe2AALNChLAAAwSzFLAAAAAAAAAAA2SwAAOEs6SztLAAAAAD1LAABCSwAAAAAAAEhLAABOS1FLUksAQeLe2AALEFNLAAAAAFRLAAAAAFVLV0sAQY7f2AALRFhLW0sAAFxLAAAAAAAAAABhSwAAYksAAAAAAAAAAGZLZ0sAAAAAAAAAAGhLaUsAAAAAAAAAAHJLAAAAAHNLAAAAAHlLAEHg39gACxJ6SwAAhUsAAIZLh0sAAIhLiUsAQYjg2AALJpJLAAAAAJlLAACaS6JLAACmS6dLAAAAAKlLAACvSwAAsUu0S7xLAEG44NgACw69S75LAAAAAAAAAADASwBB0ODYAAsCyksAQeLg2AALKNRLAAAAANVL3ksAAOBLAAAAAAAA4UsAAAAAAADkSwAAAAAAAAAA50sAQZTh2AALAuhLAEGg4dgACyz4SwNMAAAAAAVMAAAGTAdMAAALTBJMGkwAAAAAAAAAACZMAAAAAAAAAAAtTABB4OHYAAsELkwwTABB8uHYAAsuMUwAAAAAAAAAADJMM0wAAAAAAAA0TAAAAAA3TAAAAAA6TAAAO0wAADxMAAA+TABBxOLYAAsUSkwAAFFMUkwAAFdMWkwAAFtMX0wAQeTi2AALBGBMYUwAQYDj2AALCGNMAAAAAGRMAEGg49gACwpoTGlMAAAAAGpMAEG249gACyxtTG9MAABwTAAAAAAAAHFMckwAAHpMAAAAAAAAAAB8TAAAAAAAAAAAfUyATABB8OPYAAsSgUyCTAAAAAAAAINMhEwAAIVMAEGO5NgACySITIlMj0wAAJBMAAAAAJRMAAAAAJVMAACWTJhMmkwAAJ1MnkwAQb7k2AALMqBMoUwAAAAAokwAAAAAo0wAAAAAAACkTKVMr0wAAAAAsEyyTLRMAAC7TAAAAAC8TMpMAEGY5dgACwLLTABBsOXYAAsW20zdTAAAAAAAAAAA30wAAONMAADkTABB0uXYAAsC50wAQeTl2AALBuhM6UzsTABB+OXYAAsE70zxTABBhubYAAsU8kzzTAAAAAD0TAAA9kwAAAAA90wAQabm2AALHvhM/EwAAP5MAAABTQAAAAAAAANNAAAAAAAAAAAGTQBB0ubYAAsMCE0AAApNAAAAAA1NAEH45tgACwISTQBBhOfYAAsmE00AABZNF00bTQAAAAAcTQAAHU0AAAAAAAAiTQAAAAAjTQAAO00AQbrn2AALBDxNP00AQcrn2AALAkJNAEHW59gAC1RDTQAAAABETU5NAABPTQAAAABQTQAAAAAAAFFNAAAAAFRNVU0AAAAAAABXTQAAAAAAAFlNAAAAAAAAAABbTQAAXE0AAF1NAAAAAF9NAAAAAAAAYE0AQbbo2AALAmFNAEHa6NgACxZoTQAAbU0AAG5Ndk13TQAAAAAAAHlNAEGE6dgACzB+TQAAAAAAAAAAf00AAAAAg00AAAAAAAAAAIVNAAAAAAAAAACHTQAAAACITQAAiU0AQcLp2AALCotNAAAAAAAAjk0AQd7p2AALCphNAACZTQAAmk0AQfbp2AALKpxNAAAAAJ5NAAAAAJ9NAAAAAKBNoU2jTQAAqE2qTaxNAAAAAK1Nrk2wTQBBuOrYAAtKsk20TbVNAAAAALZNAAAAAAAAt00AALhNvk0AAAAAv00AAAAAwU0AAAAAAADCTQAAxE0AAMVNx00AAAAAAADJTdBNAADiTeNN5E0AQZDr2AALIOZNAADnTQAA6U0AAAAAAADvTfBN8k34TQAA/U0AAANOAEG669gACzAHTgAACE4AABZOAAAAABdOAAAZTgAAG04AAAAAAAAeTh9OIU4AACNOJU4AACtOLE4AQfbr2AALEC5OAAA0TgAAAAAAAAAANU4AQZDs2AALBDdOOE4AQZ7s2AALODlOAAAAADtOAAAAAD1OAAAAAEBOAAAAAAAAAABMTk1OAABQTlFOAAAAAFJOAABUTgAAAABWTllOAEHo7NgACyZbTgAAAABdTgAAXk4AAGBOAAAAAGJOAAAAAGNOAAAAAAAAAABlTgBBmu3YAAsEZk5nTgBBtO3YAAsKaE4AAAAAaU5qTgBByO3YAAsUa04AAG5OAAAAAAAAAABwTgAAcU4AQejt2AALBn9OAACCTgBB/O3YAAsCi04AQY7u2AALXJBOAAAAAAAAkU6STgAAAAAAAJNOm06cTgAAAAAAAKNOpU6mTgAAAAAAAAAAqE4AAAAAqU6qTrZOAAC4TgAAAAAAALlOAAAAALpOAAAAAAAAvk4AAMNOAAAAAMROAEH47tgACx7GTgAAyE4AAMpOAADPTgAAAADSTgAAAAAAAAAA/04AQZ/v2AALKU8AAAJPAAAAAAZPAAAHTwAAAAAAAAAACE8AAAAACU8KTwAAFE8AABdPAEHU79gAC0YZTwAAAAAAABpPAAAAAAAAAAAbTwAAHU8AAB5PAAAAAAAAAAAgTwAAAAAoTwAAAAAAAAAAKk8AAAAAAAA2TwAAAAA3TzpPAEGk8NgACyY7TwAAPE8AAD1PAAA/T0JPAAAAAAAAAABETwAAAAAAAAAARU9JTwBB1vDYAAsIS08AAExPT08AQerw2AALEFNPAAAAAFRPAABVTwAAVk8AQYbx2AALGlhPAAAAAAAAWk8AAAAAAAAAAFtPXE8AAGJPAEGs8dgACxRzTwAAAAAAAHZPAAAAAAAAAACATwBB1PHYAAsOik8AAAAAjU8AAJdPmU8AQfjx2AALGppPm08AAJxPAAAAAJ1PAACeTwAAn08AAKRPAEGu8tgACwymT6hPqU8AAAAAq08AQcTy2AALAqxPAEHW8tgACzauT79PAAAAAAAAwU8AAAAAxE8AAAAAyk/MTwAAz08AAAAA0E8AANFP0k/TTwAAAAAAAAAA2E8AQZbz2AALGNpPAADbTwAA3k8AAAAAAAAAAOBPAADjTwBBwPPYAAsK5E/lTwAAAADmTwBB1vPYAAsO6U8AAOpPAAAAAAAA8U8AQe7z2AALDvVPAAAAAAAA+U8AAPxPAEGM9NgACyL9TwAAAAAFUAAAAAAGUAAAAAAHUAAAEFAAABFQAAAAABJQAEHC9NgACwgTUBRQAAAVUABB1PTYAAsoKFAvUAAAMVAAAAAAAAAAADtQAAAAADxQAAAAAAAAP1AAAAAAAABCUABBhvXYAAsSRFAAAAAAU1AAAAAAVFAAAFZQAEGi9dgAC0JtUAAAAAAAAAAAblAAAAAAcVByUAAAAAAAAAAAc1AAAHVQdlAAAAAAAACKUIxQAAAAAAAAAACNUAAAAAAAAAAAk1AAQe712AALFJRQAAAAAAAAlVAAAJZQAAAAAJ9QAEGM9tgACxLjUAAAAADlUAAAAAAAAOlQ6lAAQaj22AALOPRQ9VAAAAAAAAAAAPZQ+FD5UAAA/VAAAP5QAAD/UABRAAABUQAAAAAIUQAACVEAAAxRAAAAAA1RAEHw9tgACxoOUQAAAAAAAAAAElEAAAAAAAAZUQAAAAAbUQBBmPfYAAsCHlEAQbb32AALEh9RAAAAAAAAAAAgUQAAIVEpUQBB1PfYAAssMVEAAAAAAAAyUTtRQVEAAEJRAABHUQAAAABIUQAAAABKUQAAAABLUQAATFEAQYr42AALIE1RAAAAAFJRVFFVUQAAAAAAAFZRAABXUQAAAAAAAFpRAEG4+NgAC0ZdUV5RX1EAAGBRZFEAAAAAZ1EAAAAAaFFqUQAAa1EAAGxRAAB2UQAAAAAAAHdRAAAAAAAAAAB4UQAAAAAAAIVRAAAAAIdRAEGM+dgACwKJUQBBmPnYAAsCjFEAQaT52AALGpBRAAAAAJJRAAAAAAAAAACTUZRRAAAAAJpRAEHQ+dgACwKbUQBB3PnYAAsQqVEAAKpRrlEAAAAAsFGzUQBB9vnYAAs+tFEAALVRAAC3UbhRulEAAL9RAADAUcFRwlEAAAAAx1EAAAAAy1EAAAAAzVEAAAAAAADPUQAAAAAAANJR01EAQb762AALFNZRAADaUQAAAADbUeRRAAAAAOdRAEHc+tgACxLtUe9RAAAAAAAA+FEAAPtR/FEAQfj62AALOv1RAAAAAAAAA1IAAAZSAAAHUgAAAAAAAAAACFIJUgAAAAAAAAAAEFIAABJSAAAYUgAAAAAAABlSGlIAQbz72AALDh1SIlIjUiRSAAAAACVSAEHU+9gACwImUgBB8PvYAAsEJ1IoUgBB/vvYAAsILVIAAAAALlIAQZj82AALaC9SAAAxUgAANlI3UgAAAAAAADlSPVIAAAAAQVJIUklSAAAAAEpSS1IAAAAAAABNUgAAAAAAAE9SUFIAAAAAUVIAAFJSAAAAAFZSAAAAAAAAAABXUgAAAABYUllSAAAAAF5SX1IAAGFSAEGO/dgACwpjUgAAZVIAAGZSAEGo/dgACwJnUgBBtP3YAAsGaFIAAGpSAEHI/dgACwxrUgAAAABsUm1SblIAQd792AALBm9SAABwUgBB7v3YAAsOcVJ0UnVSAAAAAHhSeVIAQYj+2AALBntSglKDUgBBmP7YAAsChVIAQar+2AALNolSi1IAAAAAjlIAAAAAAACRUpZSAACXUgAAAACYUgAAmVKaUgAAoFKiUqNSpFIAAAAAAACoUgBB7P7YAAssqVIAAKxSAACuUgAAAAAAAAAAslIAAAAAAAAAALNSAAAAALRSAAC2UgAAt1IAQaL/2AALNLhSu1LEUgAAAAAAAMVSAAAAAMZSAAAAAAAAyFIAAAAAyVIAAAAAAADOUgAA3FIAAAAA3VIAQeL/2AALLt9S4FIAAAAA51LpUgAA6lIAAAAAAAAAAOtS7FIAAAAA7VIAAAAAAAAAAO5S9FIAQaqA2QALFPVSAAAAAPZS91IAAAAAAAAAAAhTAEHIgNkACwIJUwBB2IDZAAsWC1MAAAAAAAAPUwAAGFMAABpTAAAiUwBB/oDZAAsCI1MAQZCB2QALTi5TAAAAADFTAAAAAAAAAAAyUwAAAAAAADNTAAA0UzZTAABEUwAARlNKU0tTAABMUwAATlMAAAAAAABPU1BTAAAAAAAAaFMAAAAAalNxUwBB+IHZAAsKclMAAAAAAABzUwBBlILZAAsidlMAAAAAd1N8U35TAAAAAAAAf1OBUwAAglMAAAAAAACEUwBByoLZAAsChVMAQdiC2QALHoZTAACHUwAAAACIUwAAAACJUwAAAAAAAAAAjVOOUwBBkIPZAAsElVOWUwBBqIPZAAsol1MAAJhTAAAAAAAAAACaUwAAAAAAAJtTnFMAAJ1TnlMAAAAAAACfUwBB6IPZAAsooFMAAAAAAAAAAKFTAACtUwAArlMAAAAAAACxU7RTAAAAAAAAAAC1UwBBmoTZAAsCuVMAQbCE2QALTLpTAADDUwAAxFPJUwAAzFMAAM1TzlMAAAAAAADRUwAAAADSUwAAAAAAANRT1VMAAAAA2FMAAAAAAADhU+ZTAAAAAOdTAAAAAOlT61MAQYyF2QALEOxTAAAAAO1T7lMAAAAA8FMAQaiF2QALCBNUAAAAABVUAEG+hdkACwIWVABBzIXZAAscGVQaVAAAAAAbVAAAAAAdVAAAAAAjVDxUAAA/VABB+IXZAAsMR1QAAAAAAAAAAElUAEGOhtkACwhXVAAAAABkVABBqIbZAAsSZVQAAGZUAAAAAHFUclRzVHRUAEHUhtkAC0B3VAAAAAAAAAAAf1QAAINUAAAAAAAAAACHVI5UlVSeVAAAAACfVKBUAACiVAAAAACjVAAAplSoVKlUAACqVLNUAEGeh9kACyi0VAAAvlQAAAAAAAAAAL9UxFQAAMdUAADIVAAAAADNVAAAAAAAAM5UAEHWh9kACzbPVAAAAAAAANBUAADVVAAA4lQAAAAAAADjVOVUAAAAAAAAAADpVO1U7lQAAPNUAAAAAAAA9VQAQaaI2QALAvZUAEGyiNkACwz4VAAAAAAAAAAA+VQAQcqI2QALCPtU/FQAAP1UAEHfiNkACwdVAAAAAANVAEH4iNkACw4EVQAAAAAGVQAAAAAHVQBBmInZAAscDVUAAA5VAAAAAA9VAAAAAAAAAAAQVQAAAAARVQBBxonZAAsQFFUbVRxVH1UAAAAAAAAlVQBB4InZAAs2LVUAAAAAAAAAAC5VAAAvVTFVAAAyVTNVAAA5VTtVPFUAAD9VAABAVQAAAABBVQAAAABCVUhVAEGgitkACxpJVVhVWVUAAAAAa1VuVW9VcVUAAAAAAAByVQBBzIrZAAtYc1UAAHZVAAAAAAAAd1UAAHlVflUAAAAAAAAAAH9VAAAAAIBVhlWHVYlVAACNVQAAkFUAAAAAklUAAAAAAACVVZZVl1UAAAAAmFUAAAAAmVWaVZtVAACfVQBBsovZAAsMoVUAAAAAolWtVbNVAEHUi9kACwK4VQBB4IvZAAsGuVUAALtVAEH6i9kACwq9VQAAAAAAAL5VAEGejNkACwa/VQAAwFUAQbaM2QALEsJVxVUAAAAAAAAAAMZVAADHVQBB1IzZAAsEylXLVQBB6IzZAAsgzFXNVQAAAADRVdJVAAAAAAAA1lUAAAAA3FXdVQAA3lUAQZKN2QALDuFVAADkVQAA6FUAAO9VAEGsjdkACwbxVQAA8lUAQb6N2QALAvNVAEHKjdkACyD0VQAAAAAAAPhVAAD5Vf9VAAAAAABWAAAAAAAAAVYDVgBB/I3ZAAsCBFYAQZKO2QALPgVWFVYAABdWAAAAAAAAGFYAAAAAAAAgViFWAAAAACVWJ1YoVitWAAAAACxWLVYAAAAAMFYAAAAAAAAAADJWAEHejtkACww5VgAAAAAAADpWO1YAQfiO2QALEDxWAAAAAAAAAAA9VkRWU1YAQZaP2QALFFhWAAAAAFtWAABcVgAAXVYAAF5WAEG4j9kACx5fVmdWAABoVmpWAAAAAAAAAABtVgAAAAAAAHBWcVYAQeKP2QALSH1WAAAAAAAAflYAAAAAgFaCVgAAhFaFVodWilYAAAAAAACSVgAAAAAAAAAAlFahVgAAAAAAAAAAo1YAAKZWp1YAAAAAqFasVgBBupDZAAs8rlYAALJWuVYAAAAAwFYAAMFWAADEVgAAAADHVgAAz1bXVgAAAADYVgAA2lYAAAAA21bcVgAA3VYAAOBWAEGAkdkACxzhVgAAAAAAAOJW5lbnVgAAAAAAAPNW/FYAAP1WAEGqkdkACxT+VgAAAAAAAAAA/1YAAABXAAAFVwBByJHZAAsaBlcIVwtXDlcAAAAAD1cRVwAAAAASVwAAFVcAQfaR2QALFBdXAAAdVx5XAAAAAAAAIVcAACRXAEGektkACxYrVwAAAAAAAC1XAAA+VwAAAAAAAD9XAEG+ktkACxJAVwAAQldIVwAAS1dNVwAATlcAQd6S2QALAlVXAEHqktkACwJWVwBBgJPZAAsEV1dYVwBBlJPZAAsQWVdeVwAAAABhVwAAYldlVwBBrpPZAAsGZ1cAAGlXAEG+k9kACxpqVwAAAAAAAAAAbVcAAAAAAAAAAG5XAABvVwBB6pPZAAsOd1cAAAAAeFd7V3xXglcAQZKU2QALFoVXAAAAAIZXAAAAAIhXAAAAAIlXilcAQbSU2QALLphXAAAAAAAAAACaVwAAAAAAAJtXAACcVwAAoFcAAKNXqlerVwAAAAAAAAAArFcAQeyU2QALQq5XAAC2VwAAt1cAAAAAAADBVwAAxlcAAMdXAAAAAAAAAADIV8lXAADXVwAAAAAAANhXAAAAAAAAAADZVwAAAADjVwBBupXZAAsI8lcAAAAA81cAQdCV2QALOvRXAAAAAAAA9Vf4VwAAAAAAAAZYAAAAAAdYAAAAAAhYAAAMWBlYAAAbWAAAAAAAAAAAIVgAAAAAIlgAQaCW2QALICZYAAAAAAAAAAAnWChYAAAAAC9YAAAzWAAANlg3WDlYAEHKltkACw46WAAAAAA7WAAAAAA+WABB4pbZAAsGP1gAAEBYAEHyltkACxhBWAAASlgAAAAATFgAAAAAUVgAAAAAWlgAQZaX2QALDltYAABgWGFYAAAAAG5YAEGul9kACwhvWAAAAABwWABBxJfZAAsodFgAAHVYd1gAAAAAAAAAAHxYfVgAAAAAAAB+WAAAf1gAAAAAAACAWABBgJjZAAsSkViTWJRYAAAAAJZYl1gAAKNYAEGgmNkACxClWAAAAACoWAAAq1izWLRYAEHAmNkACxq+WAAAv1gAAAAAAAAAAMNYAAAAAAAAxFjFWABB9pjZAAsExljIWABBipnZAAsqyVgAAAAAy1gAAAAAAAAAAMxYz1jQWAAAAAAAAAAA01gAAN1YAAAAAN9YAEHKmdkACwLmWABB1pnZAAsC6FgAQeKZ2QALCuxY7VjuWAAA8FgAQfaZ2QALBPFY8lgAQYaa2QALJPNYAAAAAPRY91gAAPhY+Vj8WAAAAAD+WABZAAADWQAABVkMWQBBtJrZAAsCDlkAQcKa2QALCBJZAAATWRRZAEHemtkACxoVWQAAAAAaWRtZHlkgWQAAKVkqWQAAL1kxWQBBipvZAAsMMlkAADRZNlkAADdZAEGgm9kACwY4WQAAP1kAQbCb2QALIEhZSVkAAEpZS1kAAAAATlkAAAAAUFkAAAAAAAAAAFFZAEHmm9kACyZSWQAAU1lUWQAAAAAAAAAAVVkAAFdZAABYWQAAWVlhWWJZZFllWQBBmpzZAAtqZllnWQAAblkAAG9ZAAAAAAAAdFkAAHVZAAAAAAAAAAB4WQAAAAAAAAAAeVl7WQAAAAAAAINZhVkAAAAAhlkAAAAAAACIWQAAAAAAAJFZklkAAAAAAACdWZ5ZAAAAAAAAn1kAAAAAAACgWQBBkp3ZAAsWolkAAKNZAAAAAKpZAACsWQAAAACyWQBBtp3ZAAsIs1kAAAAAtFkAQcyd2QALDrVZAAC4WQAAAAAAALlZAEHkndkACwa6WQAAu1kAQfSd2QALEsJZAAAAAMNZAADLWQAAAADNWQBBkp7ZAAsGzlkAAN1ZAEGmntkACxreWd9Z4FkAAAAA71nwWfVZAAAAAAAAAAD2WQBByp7ZAAsC+FkAQdae2QALRvtZAAAAAAAAAAD+WQAAAAAAAAhaAAAJWgxaDVoUWhVaAAAXWgAAAAAAAAAAG1ocWgAAAAAAAB1aIVoAAAAAAABXWgAAWFoAQaaf2QALGllaAABiWmVaAABtWgAAAABuWgAAAAAAAHBaAEHQn9kACxByWgAAAAAAAAAAdVp3WnhaAEH4n9kACxaMWgAAAAAAAAAAjVoAAAAAlFoAAJVaAEGmoNkACwqbWgAAAACcWp9aAEHCoNkACxCiWgAApFoAAKdaAACpWqpaAEHeoNkACy67Wr1aAAAAAL5awlrGWgAAAAAAAM1azlrQWgAAAAAAAAAA0VrWWgAAAAAAAOFaAEGaodkAC2jkWgAA7FoAAAAAAAAAAO1aAAABWwAAAlsAAAAAAAAAAANbAAAGWwAAAAAHWxBbAAAAABJbAAAYWwAAAAAAAAAAHFsAAB1bAAAgWwAAJlsAAAAAAAApWwAAAAAAAAAAL1swWzJbAAA0WwBBkqLZAAs6OVsAAAAAAAAAADtbAAA8Wz5bAAAAAAAAP1tAWwAAQVsAAEdbAABJWwAAAABNWwAAUltTWwAAVltXWwBB6KLZAAsCW1sAQfai2QALLlxbXlsAAAAAYVtmWwAAAAAAAGdbAAAAAAAAaFsAAAAAAAAAAGlbAAAAAAAAd1sAQbSj2QALGnhbAAB+WwAAk1uUWwAAAAAAAAAAmFsAAJ5bAEHao9kACwqgWwAAAACiW6hbAEHwo9kACxypWwAAAAAAAK5br1sAAAAAsFsAAAAAAACxW8hbAEGcpNkACz7JWwAAy1sAAAAAzlsAAAAAz1sAAAAA2VsAAAAA21sAAAAAAADdWwAAAAAAAAAA3lvfW+Fb5FsAAOVb6FvzWwBB5KTZAAsU9VsAAAAA+FsAAAAABFwAAAAABVwAQZKl2QALEgdcAAAIXAAAAAAJXAAAAAAOXABBrqXZAAsUEFwRXBJcAAAAAAAAAAATXAAAFlwAQdil2QALDBdcAAAbXAAAAAAdXABB8KXZAAsCI1wAQYCm2QALJCxcLlwAAAAAAAAAADJcNlwAAAAAN1wAADhcAAAAAAAAPlxAXABBrqbZAAsYQlwAAAAAQ1wAAAAAAAAAAEVcSlwAAEtcAEHUptkACxRNXAAATlwAAAAAAAAAAFJcAABUXABB9KbZAAsaVlwAAAAAAAAAAFhcc1wAAHVcAAAAAAAAgVwAQZyn2QALBoJcAACDXABBrKfZAAschFwAAAAAAACFXIlcAACNXI5clFwAAJZcAACdXABB1qfZAAsCoFwAQeKn2QALQKJcAAAAAKNcAAAAAAAAAACmXAAAAACoXAAAAAAAAAAAqlwAAAAAAACuXLFcAAC9XMJcAADEXAAAAAAAAAAAxVwAQayo2QALJMZcAAAAAAAAAADHXAAAyVwAAAAAAAAAAM1c1VwAAAAAAADaXABB3qjZAAtQ21wAANxc5VwAAAAA9FwAAAAAAAAAAPZcAAD3XAAAAAAAAPpcAAAAAP5cAAD/XAAAAAAAXQAAAV0AAAtdAAAAAAAADV0AABNdAAAAAAAAFV0AQbyp2QALAhZdAEHKqdkACxQYXRldGl0bXQAAAAAAAAAAHV0eXQBB6KnZAAsCJl0AQfap2QALAiddAEGCqtkACxxHXUldAAAAAEpdS11XXQAAW10AAAAAAAAAAF1dAEGqqtkACwJeXQBBtqrZAAsuX11hXQAAYl0AAGNdbl1vXXBdAAByXQAAdF0AAHddAAB+XQAAgV2FXQAAhl2KXQBB7qrZAAsGk12UXZZdAEGAq9kACzKXXQAAml2dXQAAnl0AAAAAAAAAAJ9doF0AAAAApV0AAAAApl0AAAAAAAAAAKddAACoXQBBzKvZAAsCqV0AQd6r2QALHKxdAAAAALBdAACxXQAAAACzXQAAAAC0XbZdt10AQYas2QALArhdAEGYrNkACwq6XQAAAAAAAL5dAEG0rNkACx6/XQAAAADDXQAAxF0AAMZdAAAAAAAAx10AAAAAyF0AQeCs2QALKsldAAAAAMpdAAAAAMtdAAAAAM1dzl0AAAAAz13QXdtdAADcXd1dAADeXQBBlK3ZAAto4V3iXQAA410AAAAA5F0AAAAA7F0AAPBd8V3/XQNeAAAEXgZeAAAAAAdeDl4XXgAAGl4AAAAAAAAfXgAAIl4lXiheKl4AACteAAAAAAAALF4AAAAAAAAAAC5eL14AADFeAAAAADNeOF4AQYiu2QALDjxeAAA9XgAAPl4AAD9eAEGgrtkACzBHXgAAAABIXgAASV5OXgAAAAAAAFJeAAAAAFNeVV5aXgAAY14AAAAAAABlXmZeZ14AQeSu2QALJmleal5vXgAAAAAAAHJeAAAAAHNeAAAAAHVeAAB4XoVeAACJXoxeAEGWr9kACw6OXpRenF4AAAAAAACgXgBBtK/ZAAsGol4AAKpeAEHar9kACwarXgAArF4AQeqv2QALFq9esF6xXgAAAAC4XgAAAAC5XgAAu14AQYyw2QALKr1eAADMXgAAAAAAAM1eAADPXtBeAAAAAAAAAADRXgAAAADSXgAAAADXXgBBxLDZAAsI2F4AAOVe5l4AQdiw2QALOOheAAAAAANfAAAAAAAACV8KXwtfE18AAB9fAAAAADFfMl8AAAAAAAAzXwAAAAAAAAAANF81XzZfAEGasdkAC0Y6XwAAAAAAAAAAO18AAD1fAAA/X0VfAABGXwAAAABKX0tfUF8AAAAAAABRX1JfAABWXwAAAAAAAFtfAAAAAAAAX18AAGBfAEHqsdkAC1BhXwAAY18AAGZfAABnX2xfAABzXwAAAAAAAHdfAAAAAAAAeF96X35fAAAAAAAAf1+AX4FfhF8AAAAAAAAAAIVfiV8AAAAAil+LX4xfAACRXwBByLLZAAsCll8AQe6y2QALGpdfAACZX5pfm1+cXwAAnl8AAAAAAAAAAKBfAEGcs9kACwKhXwBBsrPZAAtOol+lXwAAAAAAAAAApl8AAAAAAACoXwAAAAAAAK5fAAAAAAAAAACxXwAAAACyXwAAAAAAALNful8AAAAAAAC7XwAAAAC/XwAAAADBX8JfAEGKtNkACxLFXwAAxl8AAMhfAADJX8xfzV8AQaa02QALAs9fAEHEtNkACwLQXwBB5rTZAAsQ2V/bXwAA3F8AAAAAAADkXwBBgLXZAAsa5V/mXwAAAAAAAOlf6l8AAOtfAADsXwAA7l8AQaS12QALCvBfAAAAAAAA8V8AQbi12QALAvJfAEHUtdkACwL3XwBB4LXZAAsO+V8AAAAAAAD+XwAA/18AQYS22QALCAFgBWAAAAhgAEGWttkACwIJYABBorbZAAsMCmAAAAAAC2AAAAxgAEHCttkACw4OYA9gAAAAAAAAAAAQYABB3rbZAAsCEmAAQe622QALXhRgFWAAAAAAAAAAABpgG2AAAAAAAAAAABxgAAAAAB1gAAAiYAAAAAAjYAAAAAAAAAAAJGAnYChgMGAAAAAAAAAzYAAAPmA/YAAAAAAAAAAAQGAAAAAAAABPYFBgUWAAQdy32QALCFZgAABXYFhgAEHut9kACwxZYAAAAAAAAAAAW2AAQYa42QALUFxgXWAAAF5gYmAAAAAAAABjYAAAZmAAAAAAZ2AAAAAAAABpYAAAa2AAAAAAAAAAAGxgAABtYAAAAABuYAAAAABwYHFgAAAAAAAAAAByYHNgAEHkuNkACwZ5YAAAemAAQfq42QALAoVgAEGGudkACwaGYAAAiGAAQZi52QALRolgimAAAItgAACMYI5gAACPYAAAAAAAAAAAkGAAAAAAlWAAAAAAomAAAK1grmAAAAAAAACwYAAAAAAAALFgAAAAAAAAtmAAQei52QALBrpgAAC7YABB/LnZAAsCvGAAQYi62QALHr1gv2DAYAAAxGAAAAAAAAAAAMVgAAAAAAAAAADJYABBsLrZAAs80WAAANJg1GAAAAAAAADVYAAAAAAAAAAA2mDeYAAA32DgYAAAAAAAAONgAADkYOZgAADnYAAAAAAAAOpgAEH4utkACwj7YPxgAAADYQBBjLvZAAsCBGEAQZi72QALCAdhAAALYQxhAEG0u9kACwgPYQAAAAAQYQBByLvZAAsUEWEAABJhE2EAAAAAAAAUYQAAFWEAQe672QALIhZhAAAXYQAAAAAkYQAAAAAAADNhAAAAAAAANGEAAD9hQWEAQZq82QALAkNhAEGmvNkACwZEYQAAUWEAQbi82QALIFJhAAAAAFVhYmFjYQAAAAAAAGRhAAAAAGthAAAAAG5hAEHqvNkACzJxYXZhAAB3YQAAAAB5YQAAAAAAAHphAAB/YQAAAAAAAIFhAAAAAIJhAACEYYhhimGMYQBBpr3ZAAtYkGEAAAAAAACRYQAAlmEAAAAAl2EAAAAAmGEAAAAAAAChYQAAAAAAAKJhAAAAAKlhAAAAAAAAq2EAAAAAumEAAAAAv2EAAAAAAADKYQAAAADLYcxhAADNYQBBjL7ZAAsCz2EAQZi+2QALAtBhAEGovtkACwrSYQAAAADTYdVhAEG+vtkAC1TZYQAAAADbYQAA3GHdYQAAAADeYQAAAAAAAN9hAAAAAAAAAADhYeNhAAAAAORh6GEAAOlh7WHuYQAAAAAAAAAA8GEAAPFhAAACYgAAAAAEYgViDWIAQZ6/2QALEhFiFGIAAAAAGWIAAAAAG2IcYgBBvL/ZAAsMHWIAAAAAAAAgYiFiAEHWv9kACyQlYgAAAAAAACZiAAAqYi5iAAAzYgAAN2IAAAAAAAA/YgAASWIAQaDA2QALAktiAEGwwNkAC0BWYgAAV2IAAHdiAAAAAAAAeWIAAAAAAAAAAH1iAACDYgAAh2IAAIliAAAAAAAAi2IAAAAAAACMYgAAAAAAAI1iAEH+wNkAC0aPYpFiAAAAAAAAAACVYpdiAAAAAAAAm2IAAAAAAACkYgAAqWKqYgAAAAAAAAAArGKxYgAAtGIAAAAAuWLsYgAA7WIAAO5iAEHUwdkACwLvYgBB4MHZAAsC8GIAQe7B2QALIPRiAAAAAAAA9WIAAAAAAAD4Yvli+mIAAAAA/2IAAAZjAEGcwtkACxgIYwAACmMAAB9jAAAjYwAAAAAAAAAAKGMAQcbC2QALJipjAAAsYwAALmMAAAAAN2MAAAAAOWMAAAAAAAA6YwAAAAAAAD9jAEGCw9kACwpFY0djAAAAAEljAEGaw9kACxxLYwAAAAAAAE1jAAAAAAAAUGMAAAAAAAAAAFljAEHIw9kACwJbYwBB1sPZAAsQXGMAAAAAAABdYwAAAABgYwBB8sPZAAtIYmMAAAAAY2MAAGZjAAAAAGljAAAAAAAAamMAAAAAAAAAAGxjAABtY25jb2MAAAAAAABwYwAAcWMAAAAAAABzYwAAdWMAAHxjAEHKxNkACwJ9YwBB1sTZAAsCf2MAQeLE2QALAoJjAEH0xNkACxaDYwAAAAAAAAAAhWMAAAAAAAAAAItjAEGUxdkACwKMYwBBrsXZAAsgjWMAAJljAAAAAJpjAACgYwAApmMAAKhjAAAAAKljqmMAQdrF2QALCq1jrmOvYwAAsGMAQfLF2QALJLFjAACyY7djvmMAAMBjAADBYwAAAADMY85jAAAAAM9jAADQYwBBoMbZAAsY0mMAANNjAADUY9Vj4GMAAAAAAADiY+NjAEHExtkACxzmYwAAAAAAAAAA62MAAAAAAADtYwAAAAAAAO5jAEHyxtkACzD0YwAAAAAAAAAA9WMAAAAAAAAAAPZjAAD3Y/hj+WMAAPpjAAAAAAAA/GMAAP1jD2QAQazH2QALVBJkAAAAAAAAAAATZBdkAAAAAB1kAAAAAB9kAAAAAAAAI2QkZAAAAAAxZAAAAAAAAAAANmQAAAAAAAA9ZD9kAAAAAEdkAAAAAE5kYmQAAGNkZmRnZABBkMjZAAsCaGQAQZzI2QALKmpkAAAAAG5kAABvZAAAcGQAAHNkdGR1ZAAAAAB2ZIBkhGQAAAAAAACGZABB2MjZAAsiiWQAAAAAi2QAAAAAAACMZAAAjWSRZAAAkmQAAJRkrGSyZABBhMnZAAsctGQAAAAAAAAAALVkAAC2ZLhkuWQAAAAAAAC9ZABBrMnZAAsexWTJZAAAAAAAANBk0WQAAAAA02TWZNdkAAAAANlkAEHaydkACyDcZAAAAAAAAAAA6GTpZAAAAAAAAPZkAAAAAAAA92T4ZABBjMrZAAse+WT6ZAAAAAD7ZAAAAAD8ZAAABmUAAAAAAAAHZQllAEG4ytkACyALZQxlAAANZRJlAAATZQAAFGUVZQAAAAAAAAAAFmUuZQBB5srZAAsaL2UwZTFlAAAAAAAANGU1ZQAAAAAAAAAANmUAQY7L2QALBjhlAAA5ZQBBpMvZAAsIOmUAAAAAPGUAQbbL2QALJD1lR2UAAAAAAAAAAEhlAAAAAEplAAAAAAAATWUAAAAAUmVWZQBB6MvZAAsgWWUAAF5lAABkZQAAAABpZWplAAAAAGtlAABsZW1lbmUAQZLM2QALFm9lAAAAAAAAAABwZQAAAAAAAHFlc2UAQbLM2QALBHVld2UAQcTM2QALFnplAAB9ZQAAAAAAAH5lAAAAAAAAgGUAQejM2QALAollAEGEzdkACx6SZQAAAAAAAJVlAAAAAAAAlmWXZQAAAACeZZ9loGUAQa7N2QALIKFlomWkZQAApmWnZQAAAAAAAKhlrGUAAK1lsWWyZbxlAEHYzdkACxa+ZQAAAAC/ZQAAAADBZQAAwmUAAMNlAEH4zdkACw7FZQAAAAAAAAAAxmXLZQBBks7ZAAsGzGUAANJlAEGwztkACzbTZQAA1WUAAAAA12UAAAAAAADZZQAA2mXdZQAAAAAAAAAA3mUAAAAAAADfZQAA6mUAAAAA7mUAQfbO2QALAu9lAEGOz9kACxTwZfVlAAD7ZQpmAAAMZgAAAAANZgBBrs/ZAAsGGGYdZitmAEHGz9kACx40ZjZmAAAAAAAAN2YAADpmO2YAAAAAPGYAAAAAPmYAQf7P2QALHD9mAAAAAAAAQGZBZgAA0WbSZgAA02YAAAAA1GYAQajQ2QALBtVmAADbZgBButDZAAsu32YAAAAAAADuZgAAAAAAAAtnAAAAAA5nD2cRZwAAAAAYZyZnAAAAAAAAAAArZwBB8tDZAAsWLGcAAAAANGcAAAAAN2cAADhnOmdAZwBBqNHZAAsGQ2cAAERnAEG40dkAC05JZwAATGcAAAAAAABOZwAAAAAAAAAAT2cAAAAAAAAAAFFnAABSZ1RnAABVZ1ZnAAAAAAAAV2cAAAAAAABYZwAAAABaZwAAAABcZwAAX2cAQZbS2QALBGBnZmcAQazS2QALCGlnAAAAAGpnAEHC0tkACwJrZwBB0tLZAAsobWcAAHVnAAAAAHZnAAB3ZwAAAAB4Z31nfmcAAAAAf2cAAIFniGeKZwBBhNPZAAsCi2cAQZDT2QALCI1nAAAAAI5nAEGy09kAC1CQZwAAkWeTZwAAAAAAAJZnAAAAAAAAl2cAAJxnnmcAAAAAAACfZwAApGcAAKVnqWe+ZwAAAAAAAL9nAAAAAAAAy2cAAAAAzWcAANxnAADhZwBBjtTZAAsG62cAAOxnAEGo1NkACwLuZwBBuNTZAAsW72fxZ/Nn9mcAAAAAAAD4Z/xnAAD9ZwBB2NTZAAscA2gAAAVoAAAAAAZoAAAAAAhoE2gAAAAAAAAUaABBhtXZAAtqFmgXaAAAAAAAABpoAAAAACBoAAAAAAAAAAAnaC5oL2gAAAAAAAA9aD5oP2gAAEFoAAAAAAAAAAB4aAAAeWgAAHtofGgAAH1ofmh/aAAAAAAAAAAAgGiDaAAAAAAAAIRokWgAAAAAAACWaABB+tXZAAsUl2gAAJlommgAAKJoAAAAAAAAo2gAQajW2QALCKRoAAAAAKVoAEG61tkACyinaAAAqGipaAAAAAAAAKpoAACtaK5oAAAAAAAAsGgAAAAAs2gAALRoAEH01tkACw61aAAAAAC4aAAAAAC5aABBkNfZAAsGvGgAAMloAEGk19kACyDKaAAAAADLaM1o0mgAAAAAAAAAANNoAAAAAOFoAADjaABB1tfZAAsQ5GgAAOVo6WgAAOpoAADraABB9NfZAAsi/GgAAP5oAmkDaQAAAAAAAAAACmkOaQAAAAAAAAAAD2kQaQBBoNjZAAsCFGkAQbDY2QALOB9pIWkiaSNpJGknaQAAAAAAAClpKmkAAAAALWkAAAAAAAAwaQAAAAAxaTJpAAAAAAAAM2kAADRpAEHy2NkACwI1aQBBgNnZAAsWOWkAAAAAP2kAAAAAQGkAAAAAAABCaQBBpNnZAAsMTGkAAE5pAAAAAFNpAEG+2dkACwpVaQAAWWlaaVxpAEHS2dkACw5daQAAXmkAAGJpAABkaQBB7NnZAAskZmkAAGppa2kAAG5pAAAAAAAAAAB7aX5pAAAAAH9pgmmEaYVpAEGg2tkACwqGaYdpimkAAItpAEG02tkACzSRaQAAAAAAAJJpAAAAAAAAAACVaZZpl2maaQAAAACcaZ1pAAAAAAAAnmmiaQAAAAAAAKRpAEGE29kACwKlaQBBlNvZAAsCpmkAQaTb2QALFqdpqWkAAKppAAAAAAAAq2msaQAAr2kAQeDb2QALDrBpsmmzaQAAtWkAALhpAEH429kACwi9aQAAAAC+aQBBjtzZAAsCwGkAQaDc2QALAsRpAEGs3NkACw7GaQAAx2kAAAAAAADJaQBBxtzZAAsSymkAAMtpzmkAAAAAAAAAAM9pAEHi3NkACy7QadJpAADWaQAAAADXaQAA22neaQAAAAAAAN9pAAAAAAAAAADhaQAAAAAAAOJpAEGc3dkACyrjaQAAAAAAAAAA5GntaQAAAAAAAAAA7mkAAAAA9GkAAPZpAAAAAPpp+2kAQdLd2QALKgtqAAAAAAAAAAAMag1qAAAAAAAAAAAOag9qAAAQagAAF2oAAAAAAAAcagBBit7ZAAsYJ2oAADVqAAAAADdqAAA5agAAO2oAAD5qAEGs3tkAC2hAagAAAAAAAAAAQmoAAAAAAAAAAENqAAAAAERqAAAAAEZqAABHagAAAAAAAAAASWoAAAAAAABNagAAAABQalNqVGpWaldqAABYagAAWWpaagAAAABhagAAAAAAAAAAY2oAAGVqAABmagBBsN/ZAAsYZ2oAAGpqa2oAAHJqAAAAAAAAc2oAAHVqAEHy39kACw52andqemoAAAAAAAB7agBBjODZAAsIg2oAAIxqjmoAQabg2QALBqBqoWqlagBBuODZAAsCpmoAQcbg2QALBLBqsWoAQdTg2QALJrZqAAC4agAAwWoAAMJqw2oAAMRqAAAAAAAAAADMagAAAAAAANRqAEGG4dkACzLWagAA12oAAAAAAAAAANtqAAAAAN5q32rhagAAAAAAAOVqAADnagAA8GryagAAAADzagBBxOHZAAsIBGsAAAVrDGsAQdbh2QALHBBrAAAAAAAAAAA9awAAAAAAAEBrAAAAAAAAQmsAQYDi2QALKkNrAAAAAAAARGsAAAAARWsAAElrS2sAAAAATWsAAE5rAABPawAAVWtaawBBtuLZAAsCXGsAQcTi2QALAl1rAEHQ4tkACwhlawAAZmtuawBB8OLZAAsWd2uMawAAAAAAAI1rmWsAAAAAAACaawBBmuPZAAsOm2sAAAAAnWueawAAn2sAQbbj2QALHqNrAAAAALNrAAC1a7Zrt2u5awAAumsAAAAAu2vBawBB3uPZAAsawmsAAAAAxGvFawAAAAAAAAAAzGsAAAAA0GsAQY7k2QALAthrAEGm5NkACzTaawAAAAAAAOJrAAAAAORrAAAAAAAA72sAAAAA8GvyawAA9Gv2awAAAAAAAPtrAAD8awFsAEH05NkACwgDbAxsAAANbABBiuXZAAtGDmwAAAAAEGwAABFsAAAAAAAAFWwAABdsAAAAAAAAGWwabAAAAAAAACJsAAAAAAAAP2wAAEBsQWxHbEhsAAAAAFBsAABRbABB4uXZAAsiU2wAAAAAVGwAAFVsAABabAAAAAAAAF5sAAAAAAAAX2xgbABBkObZAAtOYWxibAAAAAAAAGNsZGxnbGhsAAAAAAAAeGx6bAAAAAAAAH5sf2wAAIBsgWwAAAAAhWwAAIhsAACKbAAAAACPbAAAkGyRbJxsAACkbKVsAEHu5tkACy6mbAAAsWwAALNsAAAAAAAAAAC0bNVs1mwAAAAAAADYbAAAAAAAANls7GwAAPFsAEGm59kACw7ybAAA82wAAAAAAAD0bABBvufZAAsu+Wz6bAAAAAD7bAAAAAAAAP1sAW0AAAAAEG0AAAAAEW0AABJtAAAAAAAAG20ebQBBgOjZAAscJW0AACZtAAApbQAAK20ybQAAAAAAAAAAOG07bQBBrOjZAAskPG09bQAAAAAAAD9tAABBbUdtAABIbUltAABNbQAAT22TbZRtAEHa6NkACwKYbQBB6OjZAAsKmm2bbQAAAACdbQBBgOnZAAsCn20AQY7p2QALAqJtAEGc6dkACxqlbaZtqG0AAKltAAAAAKptAAAAAAAAAACrbQBBxOnZAAsWrm0AAAAAAAAAALVtAAAAAAAAAAC2bQBB5unZAAsCuG0AQfjp2QALCrptAADBbdJt020AQZDq2QALAtRtAEGc6tkAC0jWbQAA4W0AAONtAAAAAOdtAAAAAAAA7G3tbQAAAAAAAPJtAAAAAAAAAAD4bQAAAAAAAAAA+239bQFuAAAAAAAAAAAGbgAAB24AQfrq2QALAgxuAEGI69kACwgNbgAAAAAPbgBBouvZAAsIEm4cbgAAHm4AQbTr2QALPh9uAAAhbi5uAAAAAC9uMW4AADNuAAA1bgAAAAAAADduOG45bgAAPm4AAD9uQW4AAAAAAABCbgAAQ25FbkhuAEGE7NkACy5LbgAAUW4AAAAAUm4AAAAAAAAAAFNuAAAAAAAAVW4AAAAAAABYblpuAABbblxuAEG+7NkACxZdbgAAAABebl9uAAAAAGBuAAAAAGJuAEHe7NkAC2JjbgAAAABkbgAAAABlbgAAAAAAAAAAZm5nbgAAAABobgAAAAAAAGpuAABsbm1uAABubnBucm4AAHVudm4AAAAAAAB3bgAAeG55bntuAACEbgAAhm4AAIluAAAAAAAAAACLbgBByu3ZAAsCjG4AQdrt2QALAo1uAEH27dkACx6Obo9uAAAAAAAAAACQbgAAAACRbgAAmG4AAJlumm4AQaDu2QALJptuAAAAAAAAoG6hbgAAAACobgAAAAAAAKlusm4AALNuAAAAALhuAEHW7tkACwK7bgBB6O7ZAAsCvG4AQfTu2QALFPtuAAD8bv1uAAAAbwAAAAAAAARvAEGS79kACxoFbwAAAAAAAAAAB28AAAAAAAAIbwAAAAAMbwBBtu/ZAAsQDW8AAAAAAAAPbxJvAAAqbwBB3O/ZAAsQMG8AAAAAAAAAADFvAAAzbwBB+O/ZAAuoATdvAAAAAAAAAAA6bwAAQG8AAEFvAAAAAEVvAAAAAAAAAABGb0hvAAAAAElvAAAAAAAAAABMbwAAAAAAAE9vAABRbwAAU28AAAAAAAAAAFRvAAAAAFZvV28AAAAAAABcbwAAAAAAAF5vAAAAAGBvYW9ib2lvAABubwAAb29wbwAAAAAAAAAAcW8AAAAAdG8AAAAAeW96bwAAAAAAAHtvAACEbwAAiW+KbwBBuPHZAAsUkG+TbwAAAACUbwAAAAAAAAAAlW8AQdrx2QALBJZvmG8AQerx2QALVplvAAAAAAAAmm8AAJxvnW8AAAAAAAAAAJ9vAAAAAAAAAACgb6VvrG8AAAAArW8AAAAAAACub7NvAAC2bwAAAAC5bwAAAAC9bwAAAAAAAAAAxm/Hb8tvAEHM8tkACxTMbwAA0m8AAAAA1G8AANdvAADYbwBB7PLZAAsM228AAAAAAADdb95vAEGi89kACxrfbwAA428AAAAA7G8AAAAAAAD2bwAA/m//bwBBz/PZAAsHcAFwA3AEcABB5PPZAAskE3AAAAAAAAAXcAAAAAAAABhwAAAZcBpwAAAhcAAAI3AkcCZwAEGW9NkACxQncDhwAAAAAAAAQHAAAAAAAABBcABBvPTZAAsQQnAAAENwAABFcAAAAABGcABB4vTZAAsCSXAAQfD02QALGk1wTnBQcFJwVHAAAFVwAAAAAAAAAABXcFhwAEGW9dkACwpacAAAAAAAAFxwAEGs9dkACxRecAAAX3BgcAAAAAAAAAAAYXBicABB2vXZAAsCY3AAQfr12QALCmRwAABlcAAAbnAAQZD22QALGnBwAABxcAAAcnAAAAAAAABzcAAAAAAAAH1wAEG29tkACyJ/cAAAAACBcAAAAAAAAAAAgnAAAIVwAAAAAIZwAAAAAIdwAEHm9tkACwKIcABB8vbZAAtUinCMcAAAAACQcJNwAAAAAJVwAACacAAAAAAAAKpwtHAAAAAAtXAAALZwt3AAAAAAAAC5cAAAAAAAALpwAADDcMRwxXAAAAAAAADKcNBw0nDacNxwAEHU99kACyjfcAAAAAAAAOJw43AAAAAAAADkcAAAAADocAAA6nAAAAAAAAAAAOtwAEGI+NkACw7scAAAAAAAAO5wAADycABBpPjZAAsQ83D0cPdwAAAAAPhwAAD5cABBxPjZAAso/HAAAAAAAAAAAP5wAXEAAAAAAAACcQAACHEAAAtxAAAAAAAAAAAOcQBB+PjZAAsUHHEAAAAAAAAmcQAAAAAAAAAAJ3EAQZ752QALIChxAAArcQAAL3EwcQAANnE3cQAAAAA4cT1xRHFFcUZxAEHK+dkACwJHcQBB1vnZAAsoSHEAAElxAAAAAAAAUXEAAAAAU3EAAAAAXXEAAAAAAAAAAGBxAABhcQBBiPrZAAskYnEAAAAAAABscQAAAAAAAG1xAAAAAAAAAABucQAAdXEAAHdxAEG++tkACxx7cQAAAAAAAH5xgHGGcQAAjnGacQAAAAAAAJtxAEH6+tkACw6ccQAAAAAAAAAAnXGgcQBBlvvZAAsMonGpcQAAAAAAAK9xAEGy+9kACwKxcQBBvvvZAAscs3EAALVxAAAAAAAAu3EAAAAAwHEAAAAA0nHUcQBB7PvZAAsW4HEAAOhx9nEAAPhxAAAAAPxxAAD9cQBBkvzZAAsOLHIAAAAALXIAAAAALnIAQbT82QALHjJyAAAAAAAAOXIAAD1yAABAcgAAQnJIcmByAABicgBB8PzZAAsaZXIAAAAAZnJrcmxyAAAAAAAAAABucgAAb3IAQZT92QALNHBycXJycnRyAAB2cgAAAAB4cntyAACAcgAAAAAAAIpyAAAAAItyAAAAAIxyjnKQcgAAl3IAQdb92QALBJpym3IAQeT92QALDp1yn3IAAAAAAAAAAKByAEH8/dkACwyhcgAAAAAAAAAAonIAQaj+2QALEqNypHKlcgAAAACqcgAAAACrcgBByv7ZAAsQrXIAAAAAAAAAALRyAAC1cgBB6P7ZAAsItnIAAAAAuHIAQYD/2QALBsJyAADFcgBBlv/ZAAsCynIAQaT/2QALHs1yAAAAAAAAznIAAAAAz3LVcgAA1nLkcuZy6nLrcgBB0P/ZAAsC7HIAQeD/2QALLu9yAAAAAAAA+3IAAAAAAAD9cgAAAAD/cgAAAXMAAAAAAAAAAANzAAAGcwpzDHMAQZiA2gALAhBzAEGkgNoACwoVcwAAAAAAABhzAEG+gNoAC1QccwAAIXMAAAAAAAAucwAAAAAAADJzAAAAAAAAM3M0cwAAAAA5cwAAAAAAADpzAAA7cwAAPnNBcwAARXMAAAAAAABGcwAAAAAAAEhzAAAAAAAATHMAQaKB2gALBk5zAABPcwBBsoHaAAsGUHNRc1lzAEHIgdoAC1hacwAAAABbc2JzAABkcwAAAAAAAGZzAABnc2hza3MAAAAAbHMAAAAAAABtcwAAAAAAAG5zAAAAAHBzAAAAAAAAAAB2c3lzAAB6c3xzAAAAAH1zAAAAAH5zAEG0gtoAC0KKc5BzknOXcwAAAAAAAAAAmXOacwAAAACdcwAAAACtcwAArnMAAK9zAAAAAAAAAACwc7FzAAAAALlzAAAAAAAAwHMAQYSD2gALAsFzAEGQg9oACxDCc8NzxXMAAMZzAADJc8tzAEGsg9oACxbMcwAAzXMAANFzAAAAAAAA0nMAANVzAEHeg9oACxLYc9tzAAAAANxzAAAAAAAA3XMAQfqD2gALDOBzAAAAAAAA53PpcwBBlITaAAsO63MAAO1z73MAAAAA9HMAQayE2gALKvVzAAAAAAAA93MAAAAAAAD4cwAA+XP6cwR0AAAFdAAAAAAAAAZ0AAAKdABB5ITaAAsaGHQAABl0AAAfdAAAJXQmdAAANnRBdAAAQ3QAQYiF2gALEER0AAAAAEV0AAAAAAAAS3QAQbCF2gALDkx0AAAAAAAATXROdE90AEHUhdoACw5+dAAAAAAAAIB0AACBdABB7IXaAAsCg3QAQf6F2gALFoV0AACIdIp0AAAAAIt0AAAAAI10jnQAQbiG2gALDpN0AAAAAAAAAACUdJV0AEHYhtoACw6ZdAAAAACtdLB0wnTRdABB8IbaAAsU03ThdAAA4nQAAAAA43TmdPh0+nQAQZKH2gALDPt0/HQAAAAAAAD/dABBqIfaAAskAXUAAAAABHUAAAV1AAAAAAp1AAAAAAAAAAATdQAAAAAAABR1AEHWh9oACyIadQAAG3UodTd1OHU6dQAAAAAAAD11AAAAAAAAAAA+dUB1AEGOiNoACwJBdQBBmojaAAsKR3VPdQAAAABRdQBBuIjaAAsOUnUAAFZ1AABXdQAAWHUAQdKI2gALInN1dHUAAAAAAAB1dQAAeHUAAAAAAAB5dQAAAAAAAAAAe3UAQYCJ2gALCH91AAAAAIB1AEGSidoACwKCdQBBqonaAAsghHWKdQAAAACLdQAAAAAAAAAAknWmdQAAp3UAAKl1snUAQeSJ2gALBrN1tHW1dQBB9onaAAsCt3UAQY6K2gALFLh1AAAAALl1unUAAAAAAAC7dcJ1AEGsitoACxjDdQAAAADEdcd1AAAAAAAA2HUAANx13XUAQdSK2gALCOR15XUAAPB1AEHqitoACxrydfR1AAAAAPd1AAAAAPp1AAAAAAAAAAD7dQBBmIvaAAssBXYAAAAAAAAIdgAAAAAJdgAAAAAAAAp2AAAAAAAAAAALdgAADHYAAA52E3YAQc6L2gALVhd2AAAAABl2G3YAAAAAAAAAAB52AAAgdiN2JXYAACp2LHYAAAAAAAA9dgAAAAA/dkB2AAAAAAAARnZIdgAAAABKdgAATHYAAFZ2AAAAAAAAAABXdlh2AEGujNoACwpadlt2XnZgdmJ2AEHEjNoACxxsdm12AAAAAAAAbnYAAAAAAABvdgAAcHZydnZ2AEHqjNoACxB3dgAAfHaMdo12AAAAAJR2AEGKjdoAC0KVdgAAlnYAAJd2mHYAAAAAnXaedqp2AAAAAAAAAACrdgAAAACtdgAAsXYAALR2vXYAAAAAAADBdgAAAAAAAAAAw3YAQdaN2gALOsR2AAAAAMV2AADGdsh2AADJdgAAynYAAAAAAADRdgAAAADSdtN2AADUdgAA2HYAAAAAAADbdt524HYAQbaO2gALAuF2AEHGjtoACzDkdgAA5XbmdgAA6XbqdgAAAAAAAO12AAAAAAAAAAD0dvh2+XYAAAAAAAD6dgAAAHcAQYKP2gALBgN3AAAFdwBBko/aAAsIDXcAAAAAFHcAQaSP2gALAhV3AEGwj9oACwgWdxd3IXcidwBBzI/aAAsWKXcAACx3AAAAAAAALXcudwAAMnc0dwBB+I/aAAsaO3cAADx3AAA9dwAAAAAAAAAASXcAAAAASncAQZyQ2gALGll3AAAAAFt3XHded193YHcAAAAAYXcAAGJ3AEHGkNoAC0pjd2p3a3cAAHp3e3cAAAAAfncAAAAAgncAAAAAAAAAAJN3lHefd6p3AAAAAKx3sHe/d8B3AADBdwAAAADCd813AADOdwAA1HfWdwBBnpHaAAsC13cAQbaR2gALPud3AAAAAOp3AAAAAAAAAADsdwAAAAAAAAAA7XcAAO5373cAAAAAAAAAAPN3AAAAAAAA9XcAAAAA9nf/dwl4AEGGktoACxALeAAAAAANeAAAAAAAAA54AEGgktoACzYQeBF4AAAAAAAAFHgAAAAAAAAXeAAAGngAABt4HHgAAAAAH3ggeCF4AAAAAAAAIngAAAAAKHgAQeSS2gALPit4AAAseAAAAAAueAAAMXgyeDN4Nng5eAAAAAA7eDx4PXgAAAAAAAAAAEZ4AAAAAAAASHgAAAAAAAAAAFp4AEGwk9oACxRceGN4AAAAAGd4aHgAAGl4AABreABB0JPaAAsebHgAAAAAbngAAAAAAAByeAAAc3gAAHV4dngAAH14AEH4k9oACw5+eH94AAAAAIF4AACDeABBkJTaAAsqhHiKeAAAAACLeAAAkXgAAAAAkngAAAAAlHgAAAAAlXgAAAAAAACheKN4AEHElNoACyqpeAAAq3gAAAAAAAAAAK54AACveAAAsXgAALJ4AAAAAAAAuHi6eAAAvXgAQfqU2gALHr54AAAAAAAAw3jVeN54AAAAAAAAAADfeAAAAADheABBpJXaAAs84ngAAAAA43gAAAAA63jseAAAAADweAAAAADxePJ49ngAAAAA+Xj+eAAAAAAAAAB5AAAAAAF5AAACeQZ5AEHuldoAC0ASeRN5FnkAABh5AAAAABl5AAAAABt5HXkAAAAAHnkjeQAAAAAmeQAAKHkAAAAAAAAAACp5AAAAACx5L3kweTF5AEHKltoACwYzeTR5NXkAQdyW2gALAjh5AEH0ltoACzQ8eT15PnkAAAAAAABBeUN5RXkAAEd5AAAAAAAASHkAAEl5AAAAAAAATXlOeU95AAAAAFd5AEGyl9oACzBaeQAAXHlfeQAAAAAAAGB5YXkAAAAAAAAAAGN5AAAAAGR5AAAAAAAAZXlneQAAaHkAQfaX2gALFG95AACmeQAAqHkAAAAAqXmqeat5AEGmmNoACwiteQAAr3mweQBBvJjaAAsQunnDecZ5x3kAAAAAAADIeQBB2pjaAAsay3kAAAAAAADSeQAAAAAAANh523kAAAAA3HkAQYSZ2gALAt55AEGQmdoACyTfeQAAAAAAAOV5AAAAAAAAAADree95AAAAAAAAAAD/eQAAAHoAQciZ2gALCgF6BHoVegAAFnoAQd6Z2gALCBd6AAAAABl6AEH4mdoACw4aeht6AAAAABx6AAAdegBBkJraAAsSHnofegAAAAAgegAAInoAACN6AEGsmtoACywxegAAMnoAADR6AAAAADV6N3o4egAAAAA6egAAAAAAADx6P3oAAEN6AABEegBB4praAAsMRnoAAAAAAAAAAEd6AEH6mtoACwJIegBBhpvaAAsMSXpMek16U3oAAFV6AEGcm9oACwZbegAAXHoAQayb2gALCl16X3oAAAAAY3oAQcCb2gALAmV6AEHMm9oACwhoegAAAABpegBB4JvaAAsCanoAQfqb2gALAmt6AEGKnNoACwxuegAAAAAAAAAAcXoAQaac2gALAnN6AEG0nNoACyR0egAAAAB2end6AAB4egAAAAB6egAAAAAAAAAAe3oAAAAAfHoAQeyc2gALDIN6AACMegAAAACNegBBip3aAAsekHoAAJx6AACdegAAoHoAAKl6AACteq96sHoAALF6AEG0ndoACw61erd6AAAAAAAAuHq6egBBzp3aAAsQvnq/egAAAADAegAAwXrIegBB8J3aAAsCyXoAQYKe2gALAsp6AEGQntoACwzLegAAAAAAAAAAznoAQcCe2gALTNJ6AADUegAA2HoAAAAA23oAAAAAAAAAANx6AADleul6AAAAAOp6AAAAAOt6AAAAAOx6AAAAAAAA7XrxegAA9HoAAAAAAAAAAAF7AnsAQZqf2gALFAR7BXsGewAAAAAAAAAADXsQexF7AEHAn9oACxgVewAAAAAAAAAAFnsAAAAAF3sAAAAAGXsAQeqf2gALEBp7AAAiezB7M3s0ewAANXsAQYag2gALMDp7QXtHewAAAAAAAEh7SXtKewAAAABMe097AABRewAAAAAAAFJ7AAAAAAAAAABTewBBwqDaAAtUVHtWe1x7XXsAAAAAXntge2F7YntrewAAbHsAAAAAAAAAAG17AABvewAAcHtxewAAAABze3R7AAAAAHh7ensAAAAAAAB7ewAAf3sAAAAAAAAAAIB7AEGiodoACwKBewBBrqHaAAsCgnsAQbyh2gALAoV7AEHQodoACx6Ge4l7AAAAAAAAAACLewAAmXsAAAAAmnsAAAAAm3sAQYCi2gALJpx7AACeewAAAAAAAAAAoHsAAAAAAACkewAAAAAAAKl7AAAAALx7AEG0otoAC4DhB8l7y3vMewAAznsAAAAAAADQewAA1nsAANd7AAAAAAAACADqA4gA9wMEAKsCBApFAYoKfQAHCzwCCQtQAgsLqAILC0oDCwucAwwLZAEMCyYCDQs9AQ0LcgENC9UBDQvXAQ4LjQESC0UAkguRAIYA8QSICxYChgCXBQsAigCMACgABACbAAcAmQYECs4ChwrABAQA9QAFAJcABQDlAgYAewQHAPIBBwBmAwcABgYMANUADgAkAA4AhwERAG8AEgAGABIALgASAJcAEwAkABQAIAAUADgAFABFABQAZgAVAAQAFgAIABYACgAWAA4AlgAfAAQAcAKHANgGBQp8AAUKkAAGCiQCBwoPAAcKmQCJCnUCBgD3AQkASgINANQBDgBCABAAOgAHCvsFCAqgAQkKEwEKCmQACwqSAgsK0wMMClYADgrPAA8KFACPChkABQBbAgcAvAQJADUCDgAtAQUKkwMGCvcGBwrTAAcKSQUJClMACgp4AQoKrwELCh8CDAqYAg0KGAENCqwBDgqAABEKNACRClEABADsAYUAwwGHAEMDjQBGAIQAGwIHC+wCiwu8AgcL7QULC1UCDgtMAA4LTwGUCyEABgBxAIcAtAEEClIBhQqQAYgAzgKFC38AhQuiAQYA4QUHAAgCBgvGAAsKfAOMC1MABArdAAUKkwIFCt0DBwq5AgcKuwSKChwBhwAuBAULFAEGCzcAhwtZBYYA6wUGC9gGiAvWAooK+wEPAE4ABAq8AIcKJQMFCnQDiwrfA4UL/AKGCnUGBgs1AQcLSwGKCyYChwtFB4QLXAGHC9oDhwslBgwAYgINAK8BkAA7AAkLHwOMCqYAhgD6BYQA7gKEADMBhQDEAwYLwgAHC4UACgvtAQoLOgKLC5gCBQsYAAULOQIGCwMABgt3AAYLjwAGC7gBBwsnAQcLVwIHC5YGBws+BwgLqAEJCysACQtIAgkL+AIKC5QACgtIAQsLnwALC/0ACwv6AQwL5wEMCxMCkAshAIgK+AIFCw4ABQt8AwYLGwEHC+oAiAsZAocL4wQEC34ACAt7ApMLIgAECzwBhwsZBgYA5wMGAB4FiQtdAwQLQAAFC2ABBQvQAgYLcAGLC2cBBABLAAUAtAAGAPQBBwA6AAcAxgIKAIUCiAoCA4UAiQIGABQBBwAaAQcAbwMHAJwDCADLAQkAVwIJAPICCwA+AgwAgAAMAO4BDQA0AA0ALQEPAB4AjwCEAIQAyAAEClkABQrpAQYKOwEHCikCBwrRBooK8wCHCxoEBwBVBgYKegYJCgMACgqaAAsKgQINClUADQrJAI0KWgEGC68AiQshAQULsAGFC5EDBgDhAIkA0wAHAM4CCACvAosAdgEECqYAhQr5AQkAbgCGCoYGCAA6AAkA1AILACkDDQBxAJEASAAGAFkBBwDfBJALUgAFC6MDhguiBggA/wIIACMDCQAtAYkAhwOLAMsAhgCCBAcAnQeIAKIChgADAYcA+wQFCwYDBgtlBgYLlgaGC9cGhgDPBAcKvQEICjMBCArAAgoKKQAKCrcBCwrtAAsKbgKMCskAiAD+AAYLBAGHC8wFiwAVAYcKuQcECr0ABQrJAgYLPQKICjkAigpzAYQKKAKGC1gBhQD4AAkAIAMKALUCCwDiAQsA3gILABUDhgvwAAQAdAAFAF8ABQC9AQcAmAYIAB0ACQAQAQsA/QELAJMDBAskAQQL4AIFC2cDBgurAAYLmQYHCywFBwuYBwkLnwEJC0QCDgvmAJILRAAHAOoBDQBkAI8ASwCHAGkGhQAfAgcL0QAIC5UCCgsqAAsLOgAMCzoADAt2AI0LIAAFALUACAApAAYLPwCHC5gDhQCRAoULGQOKAMUCBwAZAAgAygCKABgCBQuZAocK/AaRCjEACQCnAYwAWQAFC0MABgs+AAYLdgGHC28FCABxAAkAbQMKACoCCwBTAAwAiAATAG0ACQsWA4wLLwCKCpUCBADDAwoAnwMOALoBhwqZB4UA0AOEAM4ABAuHAYcLkQSGANIHBgC4AoYA8AOGAJIEhAsPAQcADQAIAOIACgAZAgsAOgILAF0CCwAfAwsAJAMMAFUADAAEAgwAbwINAHAADQBpAQ4ATQAOAE4AEQAcABMAbgCMCzoBhAABA4YACAYEACcCiQCmAgUKVACGCqMACQA5AAkAywEKAKkBCwB3AAwAuAAMAHMBDQBmAZEAMwAFALwABQAuAwgACgAJAKUBCQDZAgoAYQILALECBAv9AAUKmgEFCyACBwssAYkLVAGGAHACigtBAYcAlQcSAIIABQpCAQgKugAJCgYBCgq7AI4K0AAFCzUABQsdAgYLXgAGC/MBBwvmAIsLQQGFCuMABAB6AQQLmAMFCxkABQsWAwYLyQGHC1UDiQANAYQAEAKGAHoEBwpzBQgK5gEJCuwACQpuAwoK2gALCl8AEwoRAJMKHwAHCvsHCAqgAo0KwAGGAFEEhgBQBoYL5QaMC6MABQqcAYULNgOEC3oCBgCQAoYLwgaGAJQHBQBoAAYArQCHAF8GiAoyAgYLJAAHC5ICCAvGAZMLVgAFAMkBhgrrBgcAKgMIAIoACABWAQkAVAAKAMEACwBzA4wAZwEJAGwChwqmBIkKhAAHC88DiQsVAwYAXwAGAI4HiADHA40LTwEGAJYBCgCZAQoAvwELACwAjABkAAQKPQGHCv8EhADdAYYA9AQGAJUHCACwAwUKPwCFCv0BhAB1AoQLaAAEAPYAhQB3AQYAZAaECiABhwtOBgkAMQAKAAYDCApZAAgKbAILCnQCDApCAY8KfAAEABoBBwAKBAsAjgELAHoCDAABAAwATwAMACACDgDtABEACgCSABQAhAA4AwcLLQAJCx4CCQs2AooL2AIFAHYABQDzAQYA3AEGAJkCBgCYBAYArAQHAFgCBwB4A4cASAQHACgBBwBUAggAMAIIAEoCCQBkAgsAMAEMAC4ADQBZAA4AcACRAHoABQB+AwYA7AYJAPEDigp4AAULFQIHC/MCigsMA5cKAQAGAMIFBwtXAI4LIAGLAG4BiQrNAQcL3AMHC5MHCQtAAAkL9gEMCwcADAsiAA0LDAANC+oAkwtNAAcAPwYHALsGCABPAAgAagAIAL4ACAAuAQgAfwEIAMkCCQB3AAkA6QAJAKMBCQDXAQoAtQAKAJYBCwA5AAsAVQALAHgACwCxAAsAKAELAH4BCwDGAQsA9gILAOcDDAAbAAwAYgAMAIMADAD1AAwAOAEMAL4BDADGAQ0AGQANAGIADQCqAQ0A/AEOAEYADgCjAA4AEAEOABUBDgByAQ8AXwAPAIoADwCnABEAJgCUAGAAhwpCBQoAyAATAAIAlwAWAIcLjQCGClUAhgDfBooAdAGRABAACACvA4QLawKLC1gABQv2AAgLvQAJC2MBCQsAAgoLfAAKC8UBCwuPAAsLoAELC1sDjQtVAQUAAgGGAM8CBgAGBwYALwcIAIQDCgBqAwoAdgMMALoCDADcAgwAAgMQAGoAEgCjABIAqgASAKsAmAAUAAkAwwILAEYBCwBTAQwApwEMAPYBFAA+AAkLwwILC0YBCwtTAQwLpwEMC/YBlAs+AAUAHgAHAO8BCACGAAkAFAOMALYBhQumAgUKFwEGCusABwrUAQgKvgEJCn0CCgrNAgsK4gKMCgICBQsjAAYLHwEHC14DBwteB4oLswAHAJwHBwDUB4QLBQIFChEABgpzAYkKEAIEAHMABQCdAgYAlwEIADcBCwAKAI0ABQCJAH0BBQAyAAYAtwEHAAwDhwAQBIgLmwILC5MBkgtTAAUAAQAGAFEAigAIAoYA4gIFAOIBCABiAAkArAAKAGgBCgC8AgoANgMLAC4BCwAKAwwAMgAMAH8ADACMAQ0APgANAEgBDgB6AJMASAAJC50ACguDAIwLSACHC8oChwsbAgUAAgAGAAACBwAdAwcA1gUIAP0ACABNAgkATQAKAAEACgCBAAoA4QALAHYACwDiAAsA+wALAK4BCwC9AgsAzgMLANYDDABAAAwABAEMAOgBjACyAgULigEHC28BBwvnAQcLWQMHC7EGCAv2AAkLGQIKC6UADAvbAIwLMQKIAC0CBQoLAwUKJwMGCncGhgqMBgQKxAAFCi4ChQq1AwsLOwMMCzgADgsiAI8LlACJAFsBhQA8AoYAQAMEAAwABwD4AQcACgIHACkDCAAdA40AWAAECvAChQvBAQcLVgAIC2cAkQtFAAcL7AeKC4ECBQAQAgYLAQCOCwIAhgBdAwoAJgEECuMABQqfAAUKmQEHClAACgrfAQwKogEOCjIADgr5AI4KJwEHCr4FCApCAAgKiQAICvkCCQp+AgsKUAALCtQACwpwAQsKogEMCggADQoPABAKPQARCjsAEwocAJQKVAAUAG0Ahwt8BAYLFQEHC/oEBwtqBQcLcAUMC4EAkgtXAAYLuwAHCycABwuzBAgLfAEICx4CDgt1AJULHACGAKMEBQAKAQkAIgEJAGwBCgAlAQsAXgKOAC0ABgspAQcLGQOLC6oDBAAyAAYAUgIJAHkACgAxAAoAnAGLAEIDiADsAgcL0AEIC7YBCwtpAAsLawEMC+cADguCAQ8LZgCUC0sAhADSAQ0AjwEOAFEBBgomAAcKxAQICrkACAoAAQkKFgAJCksBCgriAgsKzQALChwCCwrqAg0K0QGOCsIACQB6AY0AogCJAAcCBAqfAAYKcwAHCvwABwoBAQcKiAcICkUACQqAAQoKWwAKCmcCDAp3AQ4K6wASCnUAkwp7AAULXAIFCo8DiAoWAYQAmwIIAF8BCQBCAQQKlwCHCh8GhgCGA4UK3gMMALQABQrCAAcKfgaJCloABABlA4YAzAeGAC0DhQqpAYkL+QKEAAQBhQrLAwULFAAGCyoBBwuTAgcLVgWJC9sABAAnAAUAJAAHADMHCACXAQsAkACMAAsCBAD+AQoASwKLCvACBwAdAAcAQgAHALwHCgDnAYoAKQMNAAQBDgBSABIAPwCJCpYCBQpIAAYKCAEHChUABwouAAcK3QcICtcACAoBAgoKCgGLChYAhgA6AgYANQIHAIMGBAu3AQoKXwALClsCDAvyAA0KuwEOCqAAjwoEAIYAuAWGCq8BCQB0AQ8AAgATAAoAEwASAAUKagMGCo0GjwoAAIQAEwMGAHwBDACPARUAEwAHCqsDBwqUBAcKhwYJChwCCgq4AgsKCQELCtwCCwqgAwsKqQONCrYBiQDIAIQL6QCEAAQChgtBAoQATAMLAHcDDgBtAY4AdwGEC+IBCAA1A4wALAAHAHcGiAAxAQUKqgKHCl8HhwtaAYQKuAIEAAoABwCVA4sAEgMFCxsDBgvNBggLoQGJCw4DBAD4A4YA7wcFAKwCBArWAoUKdgIGAP0DhgDIBQgKIgOICkYDhgAbAIYAiwGHC24CBwtxAocL1gYEC8sAhwuQBwYKdgAHCtcABwrxBYwKCwCEAC0DiAD/AQcKZwKKCvsAhwoUBJEAOACFCuEABgBWAQYA8AEIABMBiQDOAAQAjQOFAKwDhAB7AwcLNwEJCzQBjAv/AAQKcgEFCvQChwouBQQArwKGADwGhgA+BQYKfgYHCjAACAoDAwoKdAANCmgADgppAA4KuAAPCqgAEwpcAJQKRACKCtEABAuQAQULCwGHC+gAlwsMAAYAKQCNAKAAjQs6AYYAtgaIAAoDjgsFAYYASgaFAHMAhAAmAQ4AOgGECngAhADXAwUAwQCMALIAigqtAQUKNAOHCqMDBgDiAwYAGwQGAJ8FBwCuAIUL3AIEC2QABwunAggLOQGKCscABgqXAAYKiwYHCn8BlwoKAAYABAcIAFADCABjAwgAiwMKAFcDjAC/AowA3QAEAHoABQAcAwUAuAMGAHwGBgCHBggANwIJAK8CCQDmAgoArgILAKoCCwCNA4wAGQEFC2oBBQu7AQYLPgEHC/sDiwtvAgULzwGICygBCwBHAg0ABgEGClgGDAqmAY4KaAEFALMABwBHBIcAvQQECisABAvGAQUKWAGFCmUBBABCAAcA0gKHAIgDhgAFAwcAYAGFCngDBQswAAULlAEGCy0CBwvKAQgLVQIKC8cBCgteAgsLMQALCyQCDAvcAQ0LEgCNC8IBhguiAYQKxwIFC7oBhwvAB40AIwCJAJgAhgCtBIcLRQSJC8sAiQq4AQoAUAIKAPECDAA9AQwAYwEMANEBDADVAQwAMAIMAEICjQDzAIUANAKGAB0DBQq+A4UK2wMFCzcABwt4AYwLoQCFC8IBhgAsAoYAMwMLChQBjgolAQcAIAKKAD0ACADPAgQKQQAFCt8BBQrsAwcKeQcICj0BCQouAQoKZAKNChYABAAFAAUA8gEIAH0CCQAJAgQL1QAECgUBBwvfAAcK/gGIC1AABQCfAwcAZQAECiMBBwt9AQcLJgMHCzQDCAtiAQgLtQEICxMDCQoDAgkLkQIKCzoACgtTAQoL7QILC5IDDAqYAAwLogAMCrsBDQtLAA0KiAEOC2oADgvGAA4LQAEOCmUBDgudAZILKwAGAIEEBwChBYgL6wIEAH0DBQAMA4UAfQOKC44ChQu0AoUA7gCGC78ABAqCAIcKSwMGABAFBQoqAAUKbwMHCvUABwpEAQcK/AULCs8BCwrYAQ0KawGQCjQAhgDBBgYAzweIAMkDBAqGAIUKdAEEADwABwCtAwcACAcIADoBCQC8AosA5wGGAHgEBguiAAcLqAeICz8DhAvCAocAewSKC6oBigtZAAcAPQeKALUBiACjAYcKYgaFADwDBQAmAwcAsAAHALIABwDYBAcAuAeECoQChwtVBwULpAGHC6kFBAAzAAUAJwAGAAQABwBPAgcAUQMHALcDBwBNBgcA4AYHAMQHCQCyAQoA8gILABkAiwAlAAoLOQCKCxUBhwocAoQLzACHAJ8AiwvnAIUAhgMHAKADBwtuAQkLHwEMC8cADAssAowLQQIGCm8CiAoVAwQKjAMFCmcBBQr8AQYKuwYHClcBBwrMB4cK6geGAA4BBApVAYcK4AEFC2QBhwvgAAsLTAILC2ADCwvIA48LoACEACwCiQAhA4QAoAGOAHQBBQCYAAUAxQAHAFQBBwBjAwoAJAIKAEUCCwAGAAwAAwAMABMADgBuAI4AIQGLAHEBBwt2AgkLNwILC5YACwu8AY0LdwCGCxsCBwrLBwgKKwELCnoDjAqiAgcAIgAHAL4ACAAcAAgAjQAIALwBCAArAwkA1AELAE4BDAAYAAwAggGMAEAChQD1AgcAEQaIAIIDhQDRAogA9AMEABUDBQCHAocATgSEAIIDCgC3AAQK7gAFCvcBBgqzAAcK0wcICn0BCArZAQkKlQAKChQDDwotAA8KVgAUCm4Algo5AAkAiAATAGsABAp5AAUKnAAFCl0BCgpdAo4KVgEEC+sAhwv/AAQLwgAFC0gCBguAAQcLRwIKC/kCCwv4AosLUwMGClAABgqeBgcKrQAHCrYHCQojAgoK2gIOChIAlgonAAQKmwOGCq8GBQAVAY0A9wCEALMBhQsyAoYAHwUFC78AiQsPAYQKUwIHCwEGDgtgAI8LSQAFALUBBwD2AQcABwIHAGIEBwDXBg4A0wAGCssBBwrZBgcKDQcICpICCQoBAAsKvwONCr4BBgAuAwQL1gEFC9kBBguZAAcL3wUHC4MHCgu9AgsLhAALC6gACwvjAAsLQAELC7QBCwsNAgsLVwMMCykADAseAQ0LZwANCxwBDgv/AA4LBgEPC3UAjwt/AAUACQEGANQAhwAcAIoA7gKFC0cBBgsoAgcL2gaJC1wChgDcB4QAvgIFC1AABguVAQcLkwEHC94FBwtaBggLyAEJC+cBCQtVAwkLeQMKCzUBCwvRAgsL4gMMC64BjQulAAUAKAOHAP0HBQCmAAgA4wKMAP8BhgrqAQQLxQEFC3cDBgsXAggLBgCICx8CBAB3AAUAqgAFAL8BBwCsBgcAYQcJAGUBCQDPAgwA5gGMAFQCiQD0AQcK+gCICvsBhAqeAAYAKQOGANwFCQBHAQsAXgELAD8DDQBgAQQKjAAHCmoBCArRAAkKCgAJCvcBCQpmAgoKsQILCkcBCwrVAgwK/AAMCkcCDQrAAA4KDQEOCmQBlAoyAIcL5QIEAMIBBwCGBBMKAQATChoAlgoJAAYAVQKHACYFhgBCBgYK5AAHCj0FCQqYAYoKVwEHAF8FBwC6BYoASwGEAPIChAotAgULZQAGC1gABgsfAgcLjQYJC2QACgulAg4LqQAOCy4BDgs5AQ8LMACPC1QAhgBYBQQLNgEJCxsDCgvdAgsLwwEMC/kADgtzAA4LHgGPC2QAhAokAgoALQIHCsUACAqOAAgKRQEJCpYACQpUAgoKYQELCkoACwo7AQwKlgIMCqkCDgqnAY8KjQCFC0sCBQBSA4gAHwMKAIwDDAC9AgwA9QKOANIBBAA+AAUAEwESABMABgqPAQYKQwIHCrQCBwpOAwcK9wMHCgcHCAqTAQkKigEKCoUADAoEAAwKKQEMCsQBEApRABIKGQAVCg4AFgoMAJcKEgAMAMsBBwoKBgsKKwGOCpcBhAqxAIQL8gEHC9kACAuMAIoLYgIFCpsBhwqNAoYACgcHCrcBCgrXAgsKBAGLCqwChQuJAwsLRAKOC8kAhgB1BQUK0AAHCvEChwr4BQcA7gAHAPEHCAB4AAgAvAAIAJMCCQBWAgoA0gEMAFYBDABMAg0A9wEOAPYAjwBcAIcLEQQEC8gBBwtpAAcLZgEHC2UGCAuDAosL4wEGACYFhgAsBQQAyQAHANAGCABaAgsA9wALADoDEQBBAIUK8gAIAKQAkgA+AIUKuQOLCiIDhQBnAgcLHgYICw0BCQvUAAkLzgIOCw8ADguEAI4L4wCFCiIBhAp8AQUKNAAHChUBCQpwAYsKFwOHANsEhQsbAgsLlwONC5kBiADIA4UL1gGGAHIDhACLAwUAZAAKAEkBDACgAZUAHQAKCooAiwrcAQUK1QIFCtcCBgtbAAcLswGHChMHBAsQAAULPAEFC0oDBgtyAQYL8gYIC6YACwssAwwLzgAMC18BDguiARALDwAQCyIAEgsDABMLAwATCwcAFAsEAJULFQCEALAABQB8AgUA5gMHAAkABwDkBQgAGgAJAD0BCQBmAQoA0gAKACQBCgAVAgsAKwIMAA4CDABfAg0ABwENAMsBjgAPAQYAAAEIAAkBBAomAAcKMwEHCucDBwrJBQcKxAYHCsoGCQqeAQsKPAEMCjQADQqkAZMKZACHChAFBAtjAoULXgIEAIMCjgsVAIULywKFCtMCBgBiAocLVQIKAH8AjQAbAAYAywcGANEHCAB3AIgAzQMEC5UAigtwAQwACgIEC5oABQptAAYK+AYHC24EBwpnBwgLaQAMCigBjAouAQQLHwAGC60BBwvCAwkLygGLC7MCCgApAgsAbAMNAMEADQCnAQ4ApgATAFQABAs4AQUK2AAHClcHCQqNAAkKDgEJCqcCCgqfAAsKxQAMChoCDAovAg4KkAAOCqcAjwpDAIYALgYHACoGhwsqBokKUQCEC+wAhgqHAYYAGwMHCkIBiAr5AAULRAMFC1kDBguQBgcLOwCTCzUAhwCwAQoLRACLC+4BBAtRAIsLYwMHAH4AiABUAI4LGAEFCxoBCAuKAgkLJwEJC4sDigu7AYgAFgMFCngCigoOAgYAQAAMAHkBDQA1AQ4AjQAOAK0BDguNAI4LrQGGAPkFBgBBAQcAQQcJABICEwBjAAcKtAMHChIECArrAAgKzQEJCsUBCgpiAZEKTQAHAFAECwANAQsAGwILAHMCCwDCAgsAzwMMAPgADACyAQwAWAIMAG4CDQApAQ0A5QEOAEUADgCZAY8AbAAECmoBBwo0AAcKLwEKC0YADAsaAA4LEQAOC7IADwsiAJULDAALANEDjQD7AQkAIgCLAOQBBQrEAAYK5gEHCtQACAo1AYgKWgEGAKQGBwAaAAcAJQEHAH4BBwACBAcAPwQHAOsHCAAYAAgAcgAIAPwACADXAggA2QIJAB4ACQDHAAkA5wAJAPsACQBOAQkAaQEJAMgCCgA3AAoAPAAKAOgACgBMAQoAgAEKAIwBCgD4AQoAHgIKAIwCCwAUAAsAMAALAM8ACwAjAQsAKgELAFYBCwBtAQsAigELAGwCCwDBAgsA+QMMAHsADABUAQwAlgEMAIMCDQA9AA0ADQENADcBDQA/AQ0A5gEOAOoADwA+AA8AVQAQAEcAEgB3ABQAaQCHCngHBAtHAAULeAEHC3cAiguZAgoAlgMKAJ4DBAquAogLNwCKCnECiArCAoQL3wEECh4AhQorAAYAewEHAA4BCACwAAgAtwAJALABCQCVAgwA9wAMAGkCEgB9AAcLXwIIC2MAmAsEAAUAGAOFAIQDBAtkAoULMQIECykABArcAAULSgAHCv8FBwtbBgsLZwOMC2sChwCABwcLXgALC0kBCwvFAwwL8QAOC2IBDwsWAJQLPwAJC9EAiQssAYYAAwOHALsHBACFA4UACAOOAP4AhQtiAAkLEACNC4IBhQvYAwQLtgAGC80AhwvcAAcKvQYHCu4GigqJAQUKBwGGCp4BBAsqAAkLzQAJCxIDiguTAg4AjACUACkACAC4AQoAZwEGCrIABgshAQYK1gYHC4YGCQqyAgoKmwAKCnUBCwq6AgwLOQANCpsAFApdAJcLBAAEACUABQBOAQcA5QSXCxkABAD8AQQLewIFCmEAiQqJAYsLFQIEAIAChQABAoYKZwaEC3MBBAsQAQcLRAMHC3MGkQtZAAULOQMGC7wBBgtoBogLNAEECr8ABwqmAwgKhwKRCmEADAD2AA8AogATAEAAFAAIABQAXwAWABgAmAARAAQAFQIFCqUACQpaAYoKjwIFC+ECiwp1A4UKbQMICoAAiwqzAIkLMwGMAPAChQCYA4cAGAQFAJkABgBEAgYKfwYHCoQABwqCBAcKhwUHCuMFDArtAQ8KaQCXCg8ABQrLAQcKMQQICvEAiApOAYoAhwGHAKAHhQsNAggLgQILC4QBjAtEAo4AfgCGAIAChADjAQcAUAYJAEUABgpEAQYKCAIHClIBBwrBBggK5ACLCu4CBQvtAYYLEAKHAN4CBAuuAIcLjwOKAOABCQDvAZIAaACHCsECCQDYAQQKSQAGCmQCBwqfAwcKMgUHCh4HCArZAAkK/QIJCv4CCgqYAQsKMwALChkDDAoKAQ8KngAUClkAlgogAAcLJAKJCzoABAsgAAUL1wAGCw0BBwv2BgcLZAcKCxAACws2AwsLugONC+EBhABqAwkA5QAFCoUBiAp8AgcL1QaIC90BhgC0AwULNAGHC0AEBADsAosA8QOIChUABgArAocA5QEFC34ACAspAQkLbgEJC70BDAs1AAwLdgGNC+wBBwsPBosLaQGIAMEAiADYAQgAjQINAF0AkwAOAIQA2AOEC68ABQCsAAYAsweEC60ClQsIAIULHQMNAFMABQq9AAcKugEHCrsBCAoZAQwKrgCNCgUBhgAgBoULNQKLAIABhQAEAQcA9gIHAHADBwBPBQkApAAJAKcACgCcAAoATAIMAGUADgAwAA8ARgAGCgIABwruBAcKyQYIChYACAoOAQgKZAIJCjgBCQq0AQoKNwEKCm8CCwpIAAsKSgELCscBDApBAQwK+AEMChICDAofAg0KEQANCpwADQpOAREKPACUCkAABAv8AAcLLAQKC7IBCwvkAAsLqgENC+cAEgtqAJQLVwAHCmIBCgqaAYsKLwMGAG8BBwqeAgcKLwUICpsBCAqzAQkKjQIJCuQCCgqBAQsK3gALCkQBCwo9A4wKYwIHAJYEBgqmAIcKdgGSAHkAhAA8AwUL5wCKC/0BBwtZAgkLFQEJC6ICCguyAAoLAQEKC6IBCwsTAgsLIAILC0kCDAtxAAwL2wENC2MAjgusAYYABQaHC/MGBQBXAYYKjgGHCjIAhwuTBgQAuAEHADkACACnAAgAdwEJAFIACQAxAgkA6AIKAGwCiQvoAoYAngMGCgUCBwqHBAoKbQKLCsAAiQA7AwgAwgCIAPQCCgrfAIsKhQIHCkAAiAr1AAQLjwEFC3cABQvuAQcL7wKJCywChAAoA4cAFgAHCuMGjAo2AQUAfwIHAOEECwCAA4YLSAKGAE4GhwBcA4cLYQQFCoEABgo9AIcKswMEAGYABwAvAwcAowaLAMQDDQr5AY0K+gGLCugDhAunAoQAgwOEADkCBQu2AokLygKIABsDBgD9B4sLBwAGADQACQBoAAkALwIMADQBkwBXAAQALQGEAFwChQp9AogACwMFC48ABQsBAwYL4AYHC6oCBwvIB4gL4AKJCk4CkwAgAIkLDwIFChgBhwrKBIYA7gEGAKUCBgCqAoYAFASFChkBhwooBAcA/AGFC1wDBgumAQcLAAAHCwgGCQtBAgsL3gMMC40ADAvFAQ0LLwCNCwoBhgD2AwULAwKJC4MAhgC9A4QLhgIGADYBBwA5BwgASAAIABABCACvAQkADAAJAHgBCgAzAgoAdgIKABwDCgAqAwsAbwELAFcCCwCuAowAoAIHADoCBAuMAQcKeAAHC9gCCArpAQkLdQAJCj8BCgo0AwsK7AMMCnsBDAqnAg0KdQANC8oADQqcAQ4KGQAPCjQADwqhABAKLwAUCzMAlQoCAAYLeQAGC3wABgtlAQcLcgQHCw8FCAuiAIsLjwIIAMEBBAqpAwUKIQOIC8EBiwu+AwYAtQAHABkCCABAAAkAfwAKAPABDAD+AY0AgAGKC/0ABAD0AIcA6QCFC+0AhAptAQYAcgYKAL4CiwD1AAUKBwCLCgYDDQDPARQAMQANC88BlAsxAAQK3gIFCpYChgquAQQK6gKHCkIEBQpoAYgK7QCJAFIBjwsKAAcLOwKKC24BhgD/BAkLAQIKCxYACgsnAAwLegCMC7sAhQCAA5IAsgCGALcCiQAoA4YLSwIHC2sABwtGAwgLJgKKC5EBBwBdBIgAGwIEChUBBQpgAgYK7QEHCskBjAqAAYULAAMMAAEBBwobAIcKPAGMAOsDBADPAAUASgIFAKQCBgDAAQgA9AALAAEADQADABAANgARAAQAEgANAIUKKAIECpEBiQoIAQUABAIHAFsHhwtbBwwAwAOEC34DBQAEAAUAKgMGAA0ABgAaAgYAmgYGAL4GBwDzAQcAGwcIAJQACAC4AggAFwMMAH0AjwAJAIcA9AQLAB4ADgA7AQkKHwIKCgwCDAoMAhAKEgAUChoAlApBAAYA7AIECs0ABQpvAgcKaACICgcCCwAeAosAVAOMAAYAhABQAwcAaQULAEYCCwCKAgsAhQMLALUDDADoAAwA7AANAJ0BDQD1ARIAdAAHCkMCCQopAAkK9AAJCp0CCgoFAAsKXQMLCrcDiwrUAwQAsQMGABMHBgA1BwYAPQcGAEIHCABeAwwADgMMABQDEgCgAJQAdQCECs0CBACdAwUAIwMIALoCigA8A4YAiAWEAGICiwDgAwYAbgOGAMUFhwA3B4oLEwKJCxsChgsQAYUAfwGGAHwFhArpAQQLCQAFC4AABwtwAQsL4AGUCwMAiADaAwkAlAKKAFsBhwp8A4gLqgIHADwCCQBQAgsAqAIMAGQBjAAmAgcAgwWKCw8CBAsCAAcLIQKHC34DiQrZAQsAQAAHC+EBBwozAwkKGgAJCogBCQsYAwoKmAAKCuIADAoUAQwKqgEMCk0CDQrMAQ8KYQATCjAAlApoAIcKMwCIC70BiAuGAocAXgKECqICBgAlB4YAJgeECgIDBQpPAAcKAwQHCsUFiwo0AAULEgKOC3EAhgqCBgcA7AKLALwChgrDAIUKFQMJAFcACgBtAQQK+wAECrACBwoBAocKBAWIC28AhQB/AAYAxgCMAFMAhQssAoUKeQMECqAABQpKAQcKmgWICq4ABQAUAQYANwAHAFkFigBgAwgLEACMCzgCBgDYBogA1gKHACoEhQD8AgYLugCJC6oBCwCrAosLqwIGADUBBwBLAYoAJgKFCnYBBgC8BAYAPAcHACYECABqAwgAcgOKAKgDhAtJAoYAVAUHANoDhQrbAgYA0wIGAIAFigB9AYcAJQaGAAEEBApyAgUKggIGCqkBCgrKAIsKjQAEC10ABQv8AAYL5QAHCyMBCQsmAosLhAKJC+0CiQuiAIQLfQGHABcGBgDCAAcAhQAKAO0BCgA6AosAmAIFABgABQA5AgYAAwAGAHcABgCPAAYAuAEHACcBBwBXAgcAlgYHAD4HCACoAQkAKwAJAEgCCQD4AgoAlAAKAEgBCwCfAAsA/QALAPoBDADnAYwAEwIGAJUChgDtBYgKQwOXChEABQAOAAUAfAMGABsBBwDqAIgAGQKLAB0CBAB+AAgAewKTACIABAA8AQQA7wGHABkGBAu7AAULuAAFC7ICBwtNB4oL9AKLCw8DBADmA4kAXQOIAPEDiwskAQULFQAGC00ABgudAAcLzgMHCxUFBws7BQcL0gUHC1EHiQt0AgcLAwUJC+MACQvzAQoLVQELC0UBCwuYAQ4LtAAPC5AAEgsvAJMLMQAEAEAABQBgAQUA0AIGAHABiwBnAQUKgAEICscBjAowAAUKCAGGCrgABwApBgoAMAEKACUCDABtAQ0A3AANAPAAjgAhAIYAUwSGAKEDhwB2BAYArwCJACEBBQCwAYUAkQMGABcBBwDbAAUKeQKHCisFBwARAwcKZwEICvMAjAqvAIsAUwKECmkACAuOAQkLqQKLC3gCjABQAAUAowOGAKIGjgvxAIYLFACGACsFCwAOAgsAqwONACIBBQAGAwYADAMGAGUGBgCWBgYA1wYIAC8CjQBtAI0AfwAHAI8ECwCmAw0AhwERAEwAhwvFAocAwwMGAAQBhwDMBYYAPQIECvYCiwutA4cKcQaRCyQABAAkAYkARAIEAOACBQBnAwYAmQaHAJgHBwuxAwsLyQKLC+gChgCMBIcLqQMGAIIHCQDWAw8ArQAPALIADwDIABIAvQASAM8AFQAvAIcLdAYHAJ8GiwqAAAYAPwCHAJgDhQAZA48LhgCFCpYDBQBDAAYAPgAGAHYBhwBvBQkAFgMMAC8ABAtDAgUL4gAFC0MBhwvAAwoLEAONC78ABACHAYcAkQSJALsBDQvoAJILIwCEClQBhAAPAYkLOQEFC80DiQuTAoYAdAQGC4cAhwuYBAQA/QAFACACBwAsAYkAVAEHAIEDBQrZAwcK/QGRCmAAigvfAocKfweKAHoDBQAyA4YAYgQFADUABQAdAgYAXgAGAPMBBwDmAIsAQQEEAJgDBQAZAAUAFgMGAMkBBwBVAwgAFAOOCx8AhAr3AIcLOgGEANQBBwDzAAYKUQEHCu4BCAobAAgKVwKKCpkABAq4AAUKhgEHCmoCBwqwBYsKxgKGAGYDhgDWBIYA5QYKAFUDCgCvAw4AtQEOALcBDgC7AQ4AvgEOAMQBDgDVAQ4A1wEOANkBEABdABAAZgAQAG4AlAB5AAQAXQIHAAYCBwACBQcAfgcKALQAiwDaAIUANgMEAHoCCwCUA44AowEGCxkBBwsGAAgLGgEIC+ABCAvzAQkLxgAKC48ACgupAAoL0wAKC6EBCgs+AgsLkwALC4sBDAtLAAwLlwEMC2ACDQv0AY4L+wCGAIIDBgAkAAcAkgIIAMYBlgswAIULogKHC/AGBAujAQoK4wALCvEBCwrFAowKnwEGCmgBBwqABogK3gGJACYDDAv8AQ4LZgAOC+IAkAs5AIcLYwQEC4oABwv0AwcLAAWJC0wABQsdAIwLfgKICrsChgAuBYQAaACHC98ChArjAoYAMwUHAAQBhwsEAYcLJwQHAC0ACQAeAgkANgIKANgCiQplAwQKQwAFCqYBBwoNBAcKCQUHChMGCQrlApEKbACLAAcBhgDsBQ4AkgAPACoAEAAXABEAVgCSABEAigDUAYgA7QMECxEABQsXAAcL4wMLC38BCwu1AQwLzAGMCxQCBwBXAI4AIAGKCmAAhwtyApAKGgAHANwDBwCTBwkAQAAJAPYBDAAWAAwAIgANAAwADQDqAJMATQANAIUACArLAAsKNwMLCk4DDAriAQ0KFQENCi4BDQrQAQ4KzQCOCt0ABArBAYUKzgKHAI0ABgAyB4gAaAMIC0YADAurAI0LEAEECmMBBgo3AQkKAAGKCpQBhABrAokABQEKC+kACgr2AosLTAAFAPYACAC9AAkAYwEJAAACCgB8AAoAxQELAI8ACwCgAQsAWwONAFUBhgu6AYUKOwMFCkAAjApFAgQKugEHChcEBwpIBYcKawaGC60GBQCmAgYAMQEHAAcDBwApBIUK0QMLC0UADAtpAAwLdQANC9UADgsNAA4LPgAOC7EADgulAQ8LEwCSC40AiQs1AQUAIwAHAF4DBwBeB4oAswCIAB0BhAAFAgcL0AMJC5IACgvOAAoLVAINC9oAjguZAIQK/gAGANYADAAcAgQKEwEHCsMEjAp4AQgAmwILAJMBkgBTAAwASgAKC4gCCwufAo8LLgCHAH0AhgrZBoUA+QIGAJADBAsGAgYKcQEGCvYBBwoMBAcLcAQIClwBCQrEAQoKGgALCuAACwqDAQsKBAMMCl8ADAp1Ag0KwwANCs8ADQrxAA4KBAEOCg4BjwqMAAoAgwCMAEgAhAoNAQUK4AEHChQCBwqtBAcKTgUICiMBCwpdAY4KjAEIC7ECiQtfAwgATQGKALYABAsSAAcLkQAHC7wBBwv+BAgLMQAIC5ABCQtHAAkL+gAKC8sBDAugAJALGAAOCyMAjgu/AIcLSAeHADoFlAoPAA4AXgAPAEEAEAAEABAATQAQAFAAkQAFAAwLUgCPCyQAhQvyA4UAwQGFAIYCBwBWAAgAZwCHCpECBwDsB4oAgQKIChUChgABAIsLygMFC1cABws5AQcLTwQKC3AACgtGAgsLhQELCy0DDAuBAQ0LHgEOC3wAkgtsAAYAZQOECwsBBgAVAQcA+gQHAGoFkgBXAAYAuwAHACcABwCzBAgAfAEOAHUAlQAcAAQK0wAECkwBBQpPAQYK7gAHCg0BBworAwcKBQcICkQDCQr7AY0K8gAEABEDBQBwAQYAKQEHABkDiwCqAwcA0AEIAC4CCwBpAAwA5wAOAIIBDwBmAJQASwCFCvEDCABtA4wA2wKLCyEBCgv5AIsL0QCECzEChgBIBoQL+AKGAJUFCQuaAIwL5QEFCuQABgrLAAcKnAAIClsBiQoJAQcA8gMLAN0CCwD3Ag0AIgAOAKsBkgAtAAcKawSHCrwFiAv/AAcAeAYJAHEBCgBSAQoA6gELAJoACwAhAgsABwMNAE0AjQASAYULbQKGAA4EBAtwAYcLgQIGANoHCADTAwgA2QMKALcDigDzA4YA7QMTAHkABQojAQUKPgEHCv0CCQqFAYwKJAIFABQABgAqAQcAkwKJANsABwCgBQsAVgMLAGgDCwCZAwwAJwINANgBjgBvAQUA6gEGAGcCBgBsAocAqwIGAC4EhgA9BosACgKEALcBiACdAgYA/gIGAHcEBgDdBAoKDQKLClIACQtcAJMLWwAGAJwChgDCBAYLDQIJC2wDjAscAYQA6QCIACMChAqmAQUKYwGRCgAABgssAYcL6wUEAOIBiQqJAwQAdgMHAFoBhQtSAoUKYQMFCpIDhgpZBocATgEFABsDBgDNBoUK6gCHCmcFBgtpBogLNAOHAHMBBwshBYoLlAKHCiAFhwBuAgcAcQKHANYGhwBTAQQAywCHAJAHDwAdABAAJgAPCx0AkAsmAAUAUgGHAOgEhwrVBQoAggAGCqUBBwo9AAcKBAaKCvUBBguFAQcLlQAJC44AigteAIkKVQELAKYCDAAzAY4KYgAGCwgABwtZB4gLWwCHAPwHBgACAwYAIgMGACwDBwA3AQkANAEMAP8ABgpmAAcKSAAPCo4AkwpDAJcKHgCHCjcDhwDyBIcL0gaHCk4HBACQAQUACwGHAOgABwsYAAsLHgKLC1QDhwvLBgQL9wGHC30GBQuCAAcLIgUJC2ICCgvOAgsLWQILCzMDCwuyA4wLGAIKC5UACwsYAY4LUAEHAOMCCwCyAgcLmgcICjAACApYAAgKRgIICqkCCQp1AQkKYAMLCp0ACwpLA5QKGwCGAN4DBApYAAUKiQAFCq4ABQoJAwYKgAYGCr0GBwpNAAcKqgEHCiUFBwpLBQgKfgAICjMCCQoLAgkK7gIKCjYBCgpEAwsKKgALCj4BCwrbAgwKRAAMClwADAr7AQwKtAINClEADQruAA0KdgEOCrQBEgqKABMKTgATCm8AFAo3ABQKTQCUClwAjQqiAQcAJweECqoDBgAIA4YAkwOKCl8BBQtcAQYLCgIGCoQGBwrbBQgKdQAJCjoBigquAIcKwwKEAGUChQqTAYQLiAEFC7EBCQt5AosLdQKFAPsChABuA4QA0QOEAGQABgDPAQQKLAAFCjcBBwp/AgcK+gIHCiMHCQoIAAkKzgGUClMAhgvqAAQKWgEHCnMACQq0AAkKyAGKCmsBBQBqAQUAuwEGAD4BBwD7A4sAbwIFAM8BCAAoAQcLjAAHC54HCAuoAgsLMQOTC1gABwvGBIoLggGOAIkAhADGAQcAegcGCwUABwobBAkKIQILC/kADAs5ARALQgCRCxoAhwD3BZEAOgCUCzsABQAwAAUAlAEGAC0CBwDKAQgAVQIKAMcBCgBeAgsAMQALACQCDADcAQ0AEgCNAMIBBQvDA4YL7QaFANkCigtKAgUAugGHAMAHhgDBAZAAKAAEAFUDBwu0AAgL/QGICxgDBgq5AAcKawcJCmsDiwqhAoYLDAIMAOMABApHAQUK3gEHCjQFiArxAgYA0wUFCvwDhQr+AwQKZwCFCpEBhAujAwQK8wGHCo0FBQA3AAcAeAGMAKEAhQDCAQYAlgSGABoGCgA+AA0AkAGHCy0HjADPAIcAZQMECwUDBQtqAokL9AKECmAABADVAAcA3wAIAFAAhwrIAwQLWgAFC1EBBQshAgcL8gIJC7oACgtIAAoLDgMLCwECCwtBAgsLYgILC3kDCwvBAwwLYgEMC2oBDAvNAQwLUwINC08Ajwt5AAcAfQEHACYDBwA0AwgAYgEIALUBCAATAwkAkQIKADoACgBTAQoA7QILAJIDDACiAA0ASwAOAGoADgDGAA4AQAEOAJ0BkgArAIgA6wKIALoDhgAxBIcALAIHC5cACQtJAYsL/gAFALQChgBzBQYKMwKJCuAAhgC/AIQAJAMJC7sACgskABELLACSC0AABwulAAcLlwOICwUCBAv6AQULJwEHC5AGDwsOAJALBQAEAMICBgCiAAcAqAeIAD8DhwtgBQcL2wMJC7ACCgsKAgsLFAOMCzYClgAjAIoAqgGHANMEhwvNBgcLhQEHC7wCBwusAwgLAgIJC3QACQsXAgoLdgALC2sACwuUAAsLmgMMC/4ADAulAY4L7gCGANIEhAvnAgQKjgMFCkADhws3BY0AYACHC7kAkgCVAAQAzACJAIYDBAsQA4UL6QKIAEEDiAC1AwcAbgEJAB8BDADHAAwALAIMAEECBQtRAAcLkgAHCz4FBwumBQgLNQAICzECCAu2AggL8gIJC2EACQtzAAkLfgMKC84BCgstAwsL5gALC5ECCwu7AgsL7AIMC3cADAvIAAwLGwEOCxEBkQsPAAULmAGJC+sCCQvyAYwLtQAGAOQHiADgAwUAZAGHAOAAhgAQAwcAdgIJADcCCwCWAAsAvAENAHcACAoQAokKXAGGABsCBAoUAIUKaAKOABsABwseAAgLVgAICzsBCAu8AgkLQAIJC1oDCws2AQsLeAMLC4gDDAtpAY0L+ACKC0cDhgDzAoYAJwQHCkMEhwrlBoYLrAEHCwwCCAupAAgL6gAJC+ABiguGAosALgMHC7YFiwuTAgQKGgAFCq0BBgr1AAcKwAIHCmMFhwrCBQcLtQSKC30CiwsjA4QKbQKIANsDBAsKAQgLBAAJCycACgumAAsLlgMMC3sCFAsKABYLGwCWCysABADrAIcA/wAEAMIABQBIAgYAgAEHAEcCCgD5AgsA+AKLAFMDhQoeAoYAPgSFCmQDCAD4A4gA+gMHAHQFBwt0BYgKsQGHCtcFigrXAI0KfAAHC50ACAsXAQkL9wIQCx8AEAsnABALSwASCxgAFAsqAJgLAQAFADIChgtcAoYAkQMFAL8AiQAPAQQA1gEGAJkABwDfBQcAgwcKAL0CCwCEAAsA4wALAEABCwC0AQsADQILAFcDCwBpAwwAKQAMAB4BDQBnAA0AHAEOAP8ADgAGAQ8AdQCPAH8ABwDbAQwALQCTCnAAhAs3AokLWwMGAMkCBgDJAwYACgWGAA8GhQBHAQYAKAIGAAwFBwDaBokAXAIEAN8ABgBnAQsAAwANAGwADgBZABAAFgAFC/oCBwtYBwkLqAKLCx4DBQBQAAYAlQEHAJMBBwDeBQgAyAEJAOcBCQBVAwkAeQMKADUBCwDRAgsA4gMMAK4BjQClAIULKgGECocChgDgBxIKCgCSCwoABADFAQUAdwMGABcCCAAGAAgAHwKIADoDiADPAwoAwQOKAMIDigrcAAYAYwcGAGUHCQCUAwkAxQMJAMwDDAAhAwwAWwMMAHMDDwDiAJUAMwCECm0AhwsLAQcLXAAHC7YACAvFAQkLzAALC7YDDAteAAwLhAIQCxQAEAtGABALWgCTCzcAhgrSBgYLRwAHC00DBwscBQgLoACJCz4BBQBlAAYAWAAHAAcBBwB0AgcAjQYIAF0BCQBkAAoApQIOAKkADgAuAQ4AOQEPADAADwBUAAcL7QAIC5gCCQsqAAkLCgEJC3wBCQuFAgoLsQCKCxQBigtFAAQANgEHAMQCBwDkAwkAGwMKAIYBCgDdAgsAwwEMAPkADgBzAA4AHgGPAGQABQBLAgQKKAAKCkMACwp1AAsKAAOLCqcDBgCWBwcAAAKIANcDBwrgAwgKLQEJCtICDAo/AA0KHQAOCqEAjwoSAIgLTACLCpsDhgCFAoYAUwMEAPIBhAslAQcA2QAIAIwACgBiAg4LYAERCzUAEguSABILmAATCwsAlgs2AIYAqAWKC0kDhQCJAwQLXQIHCwYCBwsCBQcLfgcKC7QAiwvaAIsLlQOHCjkDjApIAQQAyAEHAGkABwBmAQcAZQYIAIMCiwDjAYYAGAMGC2AAhwuSBYkLswIEC4sChQshAQcLsAIICyMACQv/AQoL/wKTC3YAlgA4AAUA8wAFABcCBgrMAAoKQAEKCkcCDQr2AQ4KSAAOChIBDgo4AQ4KWAEPCp8AEAo+ABAKRQARCh4AEgoqABIKNQASClQAEgqMABMKRAATClUAFAoFABQKLQAUCmUAFgoHAJYKFAAECi4CBgqGAQcKogAHCrECCQpoAYoKjQKSCxcAhwDUBgUKWAMGCogGBgrdBoYK9QYFABsCBQDyAgYAbAOEC8AChws2BAUKXAAKCuACjApmABEAWwAFCk4CiQrVAIYAHQYGAFsAhwCzAQQAqwOMABgDhgB3BQQAEAAFADwBBQBKAwYAcgEGAPIGCACmAAsALAMMAM4ADABfAQ4AogEQAA8AEAAiABIAAwATAAMAEwAHABQABAAVABUABAvQAoULMgGQAF8AhQuvAYQL6gCHACcCBADnAwYArgeGAPoHBwBrAgoAIwILAHoADABZAg8ABwCUABQABQvQAQYL7AAHCxQBBwu4AgcLkgMHC1QEBwuoBQkLDwAJCzQCCgsOAAwLNQINC8EBDgs1AA8LDQAQC0AAkQspAAYAdAMGAPsDhgB+BAYL5wYMC8IAkQtrAIgK9wGFC0gDBwCfAoYK0gGEAHgDBACVAIoAcAEEAJoABwBuBIgAaQCHANcDCQuCAgsL7ACOC8EABAAfAAYArQEHAMIDCQDKAYsAswIGAIMChgBOBIQAOAEEC0QABQt6AgYLggEHCxoDCAsRAQkLMwIKC2kACgurAAsLXgCLC2IBhQDkAocAagYEC18ABwugAQgL0wCLCz4DhADsAIoK8QAHC9sCDQsUAI8LCwAFAEQDBQBZAwYAkAaHADsACgBEAAsA7gGYCwYABABRAIsAYwOHABsDhQuxAgQA6QMFABoBBgCMBwYAuQcGAMMHBgDIBwgAigIIAJcDCACYAwgAmwMIAJ4DCACfAwgAowMIAKsDCACzAwgAvAMIAOUDCQCLAwoAtgMKALkDCgC6AwoAvAMKAL4DCgC/AwoAxAMKAMoDCgDMAwoAzQMKAM8DCgDQAwoA1AMKANUDCgDYAwoA3AMKAN4DCgDjAwoA5wMKAOoDCgDrAwoA7QMKAO4DCgDwAwoA8QMKAPQDCgD2AwoA9wMKAPsDCgD8AwoA/gMMAL8DDADBAwwAwgMMAMMDDADEAwwAxQMMAMcDDADIAwwAyQMMAMoDDADLAwwAzAMMAM0DDADOAwwAzwMMANADDADRAwwA0wMMANUDDADWAwwA1wMMANgDDADZAwwA2gMMANsDDADdAwwA3gMMAOADDADhAwwA4wMMAOYDDADnAwwA6AMMAOkDDADqAwwA7AMMAO0DDADuAwwA7wMMAPADDADxAwwA8gMMAPMDDAD0AwwA9gMMAPcDDAD4AwwA+QMMAPoDDAD7AwwA/gMMAP8DDgDbAQ4A3QEOAN4BDgDfAQ4A4AEOAOIBDgDjAQ4A5AEOAOUBDgDmAQ4A5wEOAOgBDgDpAQ4A6gEOAOsBDgDsAQ4A7QEOAO4BDgDvAQ4A8AEOAPEBDgDyAQ4A8wEOAPQBDgD1AQ4A9gEOAPcBDgD4AQ4A+gEOAPsBDgD8AQ4A/QEOAP4BDgD/ARAAcQAQAHIAEABzABAAdQAQAHYAEAB3ABAAeQAQAHoAEAB7ABAAfAAQAH0AEAB+ABAAfwASAPIAEgDzABIA9AASAPUAEgD4ABIA+QASAPoAEgD7ABIA/AASAP0AEgD+ABIA/wAUAH0AFAB+AJQAfwAHC7UGBwvpBooLIgIHC2cEBwskBgoLKQEKC6YBCwv8AgsLKgMMCwgBDQtmAA0LLAENC+QBDguTAA4L5QARC0cAEgt2AJMLeAAGAHwEhgAyBoQABwOHCroDhQtgA4ULoAOKC70AhwqmBwYKJQIICiIACAobAQkKpQCKCtsBBQqMAgUKvQKHCsEBhwu3AgQKjwIHClIDEQpLAJIKiQCMC6oChQsLAggAygOICp4CiAsrAgcLTAAICywACQt0AwoLRAILC48BCwt+Aw8LegASC5AAkws9AAYKnwAGCmwBBwoEAgcKnwWJCgYCBABHAAUAeAEHAHcAigCZAo0KlwALADsDDgAiAI8AlACFCwYCBADfAYcL+waHCzwHhwrhAwcAXwKIAGMAhgCoB4QAGQMEACkABQBKAAcAWwYLAGcDjABrAgcAXgALAEkBCwDFAwwA8QAOAGIBDwAWAJQAPwAHCvUBCQpvAAoKjQALCkwBDQorAA0KrQEOCoIADgqfAZEKZgAJANEAiQAsAYYA2QWKC/8ABAumAwULigCIC2IChQBiAAYAJAUKCyQDigtAAwgLYAAJCyQACgtfAgsLpwELC7oBDAs1AQ4LxwAPC1oAkQtuAIQAzwEFCpUAiArpAIUKpwMEC4wCCAtAAQkLDQAJC44BCQvXAgoLSwAKC7gACgvmAAoLNAIKCzkCCwvNAwwLRgAMC70ADQs5AA0LAQEWCwYAlgsQAI4AIwEMCkYCkgqDAIgKIQOFANgDkQt0AAQLtAKFC0EBBAC2AAYAzQCHANwABAAqAAkAzQAJABIDigCTAgYAIQMLC4IAjAthAoQAewIFC1kBhwv4A4sAFQKEAHMBBAAQAYcARAMGAAIFhwtMBAUAOQOGAGgGhwstBYULoQIECx8BhQv6A4cAZQEGANMBiQBvAwcAPQGHADkCBgCcA4YANAYFCyIABQqWAQoL1AIMC7wBDQtiARILIAAXCxgAFwsfAJgLBQAGAAMHBgArBwYALAcGAEAHCABMAwgAUQMIAFYDCABmAwgAdwMKAFQDigCuAwYKRQCHCnUAiQAzAQQAsAMGAAcHBgAhBwoAUAMKAGsDCgB/AwoAgwMKAIYDjAAFAwsAKwANAEgAjQCOAIcKJgeGC34BBAqwAYcKOAOEC0kBBwAcB4sLfACFCjoDhQANAoQLigMHC5QHiAtuAYoLCgAEC3sABAuJAgULXQIHC+UFiAskAAYAbgCHAJEGhQDtAYUL/wIEAK4AhwCPA4oLEgMIAKEBiQAOA4UK6AMHAN0CiQBHAgQKKQEGChECBwqYAAcKyQIHCjUHCArGAggKzQIMCn8CjAqtAgQAIAAFANcABgANAQcA9gYHAGQHCgAQAAsANgMLALoDjQDhAQQLEQEFC5IChQvjA4gA3QGGC0gAhwtBBQUANAEHAEAEBAoIAocKPwKFC00CBQB+AAgAKQEJAG4BjAB2AQcADwaLAGkBBQt1AAYLAgIGCx0CBwuMBAcLnAUIC9wACAuIAgoLsAKLCzAChQuuAgQAsgMGAA8HCABnAwoAVgMKAGYDCgB4AwoAgQMKAJgDDADSAgwA+QIMAPsCDAD8Ag4AxgEOANEBEABrABIApwASAKgAkgCsAIQArwCHABsFhACtAocLKgeFAB0DBgDpAgYAWgOGAMMDhQA1AgUKjQEGCpoABwvEAAcKpAIICrsBCAphAgkKGAAJCkUBCgojAAoL/QILC1sBCwoXAgsLKAILC0ACCwqgAgsLFgMLCvoDDAsHAQwKfQINC/YADQsOAQ0LiwEOC0oADguwAA4LvgAOC44BDgucAQ8LIAAPCz8AEAoeABALWACTC2kADQtUAI0LegAEAPwABwAsBAoAsgELAOQACwCqAQ0A5wASAGoAlABXAIkAOgMEC00CiwsaAQULfQGHCwAHhAAXAwUA5wAKAP0BhQrVAwcAWQIJABUBCQCiAgoAsgAKAKIBCgA7AgsAEwIMAHEADADbAQ0AYwCOAKwBBAo4AAcLaAIHCv8GCApfAggKiwIKC50BCwrRAQsKQwMMClEBjQrgAQcANwaQACsACQqeAIoKmwGHAJMGCAAhAQsALQAMABYBjAAZAgYLeAAHC6QEBwuuBggLHgEJC5sCCwtQAosL2gKICmkChwBgBIcLegSLCjMCBAtgAQQKcQGHC68CjwsmAAQAjwEFAHcABQDuAQcA7wIJACwCDguzAA8LlwCWCwsABAvAAAULMQAGC8gABgslAQYLoAaHC+gBBACOAYUAlAIHAAYEhgpuAocLUwKNAKgAhAuTAAcAzQMKCnACjgoXAYQKawGEAIIChQumA4YATwYHC/kBhwsLAgcAUgIHAFMDBwBCBwkAmwEJAD4CCQCaAgkA4QIKAFoBCgDIAgsA9gALALABCwAFAgsAhwILAKcCCwDXAgwAMAEMADEBDABDAQwA4wEMADwCDABRAgwAWgINAF8ADQBlAA0AqwANADsBDQB6AQ0AqQENANsBDgA/AA4AfAEOAIABDwCFABIAcACUAEgAhwBFBIQApwIIAJEDCgCHAwoAkwMMAIgCDACJAg4AxwEQAHAAigu2AYkAywCGCiQBhgDUBQcAXgUIABwCBQqxAAYKaAIHCjsDCQoNAooKkAKHAM4FCQDKAooKHwCIADkDhgDnBYQLfQKGALgDBAqhAIUKdwIFAI8ABQABAwYA4AYHAKoCBwDIB4gA4AKEALwChgAEBoQLCQMJC2MDigtFAwcAFQaHCpQGhQBcAwYApgEHAAAABwAIBgkAXQILAN4DDADrAAwAxQENAC8ADQAKAQkK1QEJCsUCDAoAAg4KQQCRCgwACwAnAwoK5QALCkkAiwp4AQYLqgAHCzgECAuLAQgL5wELC30AjQuTAAUAAwKJAIMABwBFBgsAwgOSAIsAhACGAgQAjAEHANgCCQB1AA0AygCUADMABgB5AAYAfAAGAGUBBwByBAcADwUIAKIACAD8AQsAjwIECxcCBgouAgcKiwIIC2oCCQoAAAoKIgCLCvADhwvdBIoAZQGWCxcAhQDtAIcA+AYHCigHigp2AYQAyQKECy4ABgAABgoAXAEFCysDBguPBgYLsgaHC/AHCwu2AI4LwwAGAAsCBwDiAgcKAwMHCsMGCQqVAYoKpQEHC7IFCQuXAYsLDwAGCyIABwtFAAcLgAIHC0EECAvEAggL0QIJC2sBCQuDAgoLdAKUC2IAhQCyAYcAVQcHADsCigBuAQUKcQOFCnUDCQABAgoAGQAKACcADAB6AIwAuwCEAEQCBQqOAIYKIgKEC84BiQBpAwUK0gELCjsCDArGAA0KGwEOCroADwoVAI8KZwAHAKsABAq5AAUKAQEFCkcDBQqoAwkKjwEKCgIBCgqLAQoK3gILCvYDDAoXAA0KXgEOCpYAkwoGAIYAcQIHAGsABwBGAwgAJgKKAJEBBQtJAAYLFwCGC1IBBACvAwYAOgcMAMkCjgCyAQsATAILAGADCwCoAwsAyAMMAEkADABXAQwAigENABMBDgABAQ8AoAAHCpQBBwphBQcKlgUHCuEHCAqVAAgK7wAICgACCAoZAwgKMgMJCtoBCQpTAgoKegAKCjUCCgqJAgoKDwMLCu8ACwonAQsKvwELChACCwp/AgsKIAMMChkADAqdAAwKPAEMCoYBDAqHAQwKiwEMCt4BDAr3AQwKUAIMCqgCDQoyAA0KNQANCoQADQrGAA0KQgENCp8BDQr/AQ4KRwAOCosBDwpHAA8KiAARCnsAEgpdAJMKOgCFAAADCwBnAI4AAACICsgChAAfA4QAfgMHC9UCCAvyAYsLDAGHCwYHhwsFA40LaAEECnkBmAoNAIcAiQaEC0cChgAcBIUL3ACMC0UAhAsgAgQKtACHCnIHhgAQAQQAuQGGAI0FBAAJAAUAgAAHAHABCwDgAZQAAwAFC7AABgu1AQYLNAILC7UAjQu3AIQK6wEHAJ4EjQtDAAYAQgUECqsAigrqAAQKSgIHCqIEigp3AogAqgKGAOwDDwAYAI8LGACGAMgDBAACAAYA5gIGABkDBwAhAgcAfgMJCqMDCgpOAZQKRwCIC1gChQr9AgkAAQOMALkABAsWAwULEQGGC4oBBwDaAYkAQgIEC4cABgt/AAcLoQQHC+cFCAtlAgsLBQAMC4UADAvvAQwLSgIOC4EBDwt2ABELFACSC2IAhQqoAQUAEgKOAHEABgvmAAcLwQMHCz0EiAvOAQcLogeJC3wCiArKApULBgCHCq0CCQqkAQoKDQEKCh0BCgpAAgsKjQENCq8AkQpaAIQKrQEFACwCBQuiAIgLRACEC44CBAucAAcL5gMHCxUEBwtEBwkLMAAJC7QCCwujAYsLWgIGACUFCAAQAAkAOQMMADgCBwv8BAgL2gGJC4wCEgBhAAcKEgAHCrsCBwquBwgK8AIJChEBCQqcAQkKvwIKCkcACgqrAYoK/AEKAL8CBwuuBYoLvwIECjUABQq6AIcK8AKGAHwDhgAjBggKPwIKCiEBiwo/AQYAugCJAKoBhgBNBIQKowKEAEkCBgBOB4kAqQOYCwoACQvFAAoLLAEMC9kBDQtaAI0LlQEEAF0ABQD8AAYA5QAHACMBCQAmAosAhAKJAO0CCQCiAAYK0QAICtQBCQrSAAsKJAAMChwADAp2Ag0KFQANCl0BDgoHAJEKDQCEAH0BhAteAgQKVgGHCpsEBwszBgcLqwYKCxACiwv4AQwLJwANCwkBjQu3AQQKoAOFCo4DBwouBwcLugeIC6QCBgD6AgYAHAOGALwDBAo+AQQK8AEHClgDiwqOAokL8gAEC2kBhQs7AYQLzQGEC9gBhABZAwUAFQAGAE0ABgCdAAcAzgMHABUFBwA7BQcA0gUHAFEHCQB0AgcKkwMICvcAkwoAAAQKygAFCn4BBgrGAQcKqAMHCgsHCAr2AgkKdwEJCn8DCgrnAgoKGAMLCtIDCwr0A44KbQAHC2kCCgvyAQsL9QEMCxAAjAuWAAcKfgQHCpEFBwqtBQoL6wKMCgEChQubAAsAlwONAJkBigoXAwoAeQKLC9kCBwujAAgLPwEJC5IBCgsYAAoLqQILC8gACws3AgwL/QAMC5oBjgvbAAUL2wEHC/QGCQvmAAsLKQELCy4CDgtCAZMLTAAHAEwBBgq9AYkKjQOHC6QHiAsSAYYKQgKHANEFhws4BwULsAOGC+kGhAuQAIgK/gIEAEADhwodAggAjgEJAKkCiwB4AogAhQIJABcDCgBdABAADQARABcAEgCHABMADAAUAAEAFAAMAJQADgAGC/cAiQsrAoYAFACEACADhwAxB4sK1wOJCgADhApIAo0LMwAGAMkHBAtsAooLGAGIAAEDCwAiAQsAmQIHCxIHCwtiAwwLZwANC+8BEQtDAJMLSgCGAJIFiwA8AAQKRgGHCuoGBwBSBwkAgQKECuIABgCEAgUKqgEICh4ACQoCAAsKJQKTCnoABQusAYoLugGHC08HhwDdBpMKdQCHAKkDhwB0BgYAjgKGAMQFhQtjAIcADwKEClkBBAqBAQQLjQEHCgkBhwpLAgQAQwIFAOIABQBDAYcAwAOGAM4FCAv2AZALCQAEClsBBQqnAQUK5AOHCjEFBwvXApILSQAEC+UBBwthAQcK6wQHC/MFCQp9AIsKQQAGAEUBBQqIAAYLbgEHC2gFBwtBBogKhAKKC6AABgBBBYkLGgESAFsAkwBGAIgAlAEEC50AhQvXAYUAzQMGAIcAhwCYBAgLdAALCycCjgufAAQAJQIECrEBhQrPAogA0AMFC6AABwtrAQcLTQIKC6oAjQs3AJAAFQCQADMAhwA6AYcKUwUEC2wABwuVAQoL6wGLC/IBkgAEAAQKKwIIChgCCgogAYsK7QOHC+0DBgAZAQcABgAIABoBCADgAQgA8wEJAMYACgCPAAoAqQAKANMACgChAQoAPgILAJMACwCLAQwASwAMAJcBDABgAg0A9AGOAPsABgBFBAYAfQUJCnIBigpaAAQLngOFC9cDhwDwBoYA+AWEAKMBhAsaAgYLJgEHC/MEiAtwAocL7AaKCy0BBAoBAYcK7wcEAIoABwD0AwcAAAUJAEwAhwroBoQL9QIFAB0AjAB+AgcLjwKHCzQHBwCKBQYLAQGHC/IFCAvVAYoLLwCOCxYBBgpTAAYKxQaHCm0FCwvMAAsL8wCMCyUBhwtTBwYArgaHAPYHiQsrAQQAEQAFABcABwDjAwsAfwELALUBDADMAYwAFAKFAF4DiQq4AgYAUAKKALIDigtXAgcKtgYJCl8ACQoSAQoKFwEKCj0BCgqkAQsKLwELCigDDAqGAAwKbwENCpUADQpbAQ4KXQEOCpYBEgoWABIKWQASCnoAkwovAAgARgAMAKsAjQAQAYUKGgCECiYCiQAsAwoA6QCLAEwAhgDcA4YAugGICjYDBwCAAwQKhgMFCikDhgp6AAULlgAHC2oACAtbAgkLUQIJC3oCCgssAAoLrQALC84BCwsDAg0L2AANCyABjguQAYgA4wGHCgYBBgCtBoUKbAIECiIABQo+AgcKFwEHClgGiApZAokKqgCTAHcADAtsAI0LIwELAEUADABpAAwAdQANANUADgANAA4APgAOALEADgClAQ8AEwCSAI0AiQA1AQsLFgGOC0kABwBgAgcA0AMJAJIACgDOAAoAVAINANoAjgCZAIUKTAEGCgUBCAq2AIsKrwMEC+0BkAs3AIYKuQaEAAADBAqlA4UKcAMHCysCBwskBQcLhAUHCy8HCQvAAAkLTQILC/EACwukAgsLKwMLC3sDDAuMAAwLWgEMC98BDQseAA0LMQANC30BDgu8AA8LlgAQC0wAEgseAJQLNAAEAAYChwBwBAYLOAIHC3AABwsMBwgLagEIC5oBCAs+AwkLAgILC4kCjgudAIcLoQIIALECiQBfAwQAEgAHAJEABwC8AQcA/gQIADEACACQAQkARwAJAPoACgDLAQwAoAAQABgAhAtxAowA/AMEAOUDBgCaBwYAwAeGAM4HBgsQAAYLngAHCysABwuBAAcLtQAICxQBCAt5AQoLCwILCzADDAvHAQ0LLwGOC4cAhQosA4YAkgIECwEABwt3BAcLtwUICz0ACQvPAAkLhgEJC9MBiwtEA5YLGgCMAGoABgAjBwoAowMSAKYAFAByAAQKiQAHCpoEBwsnBYcK8AWFAPIDBAvTAgULfwMHCwcECAvHAAgLVAEJC5kACQvXAAoLFQAKCzsACgtQAAoL4AALC+UACwuMAgwLwAANC5IAjgtbAIQLJwEGC2sCBwuCAwcLRAQIC+UBEgscAJMLdACJCzMABgp9BgcKtwcHCtkHhwrbBwULNQGMC9MABQBXAAcAOQEHAE8ECgDQAAoARgILAIUBCwAtAwwAgQENAB4BDgB8AJIAbAAFC30ACAtNAIoLDwCEAAsBhQC/AokLmwCFC7cBCwukAIwLTAAJAPABBQpZAAcKewcJCrkACQrrAAoKQAAKCg4BCgqTAQoK1QEKChECCgpOAgsKjAALClwDDQoBAA0KpgEOClUBDgpsAREKXQASCnEAEwphAJMKcQCFCrcChwBhBAUKBgAGCrcABwqoAgcK0gMHCvUDBwofBAwK5gANCqwAkgodAAQLCAAHC4AEBwuBBAcLswYJC3YBCgveAYsLiAKHC0sEBgodAIsKPwAEADECCgD5AIsA0QCEAPgCBwsfA4oL/wGIC1cACQCaAIwA5QGIAP8AhABDAYwAowGECjcBhgrMBgQAcAGHAIECBwqqAAgKWgAICrEACAqfAQsKygKOChkBBAtFAAULegAJC5ACigvQAQULUQOGC2EGCAAKAo4ASAELClsADQqBAA8KZQCRCn0ABwAyAggAJwIECu4BBgpKAAcKLAALC/MBDAoRAA8KBQCUCgsABAoUAYUKKAEJAFwAkwBbAAQKBwAFCloABQqeAAYKHgIHCt0ABwomBgkK6gEKChwCCwq7AYsK9QIGAA0CBgC4BwgAJgMJAGwDjAAcAQULWwMHCkwCBwuIBAgLawAJCq8ACQsjAQkLtwEKChICCguXAgsLYQKMC8UABwuoAA0LxACNC+0AiwC+A4UAUgKHCkQCBwpYAIgKcwIGAN8BBgAyAgcAJAQNAAYABQpoAwYKOQAHCtcBCQq/AYkKxgGIC50BkQsTAAQLdQAGC3QBBwtxB44LQwEEC9ICiwvXAREAPQAFCh8AhgpmAggKSgGMCt0BBwqwBIoKzAEGCqgBhwpKBwYAaQaIADQDBgAUBoYAUgYJCwUADAvYAAwLJgEMCyoBDAuQAQwLBgINC+UAjwuLAA8LmwCQC08ABAAuAYcA5gYFCg0AhgqOAAYAlAAHACEFBwp0AAgKQgEICvMCCQokAgoKygILCnQDjQpEAYkApAIJC1gAiwsOAQULDAAHC3cBiQu2AYYAigYHCsAFhwoSBgsAsgAHCi8EBwoFBgcK5wYHCg4HCwqiAAsK8gAMCl0CDwoaAJAKLAAGAIUBBwCVAAkAjgCKAF4AjAtHAJEKcwAGAAgABwBZBwgAWwALC8YDDAsfAQ0LVgENC5IBDwtuAI8LowAECwIBiAt/AgYLFgAHC4cDigtBAoULqQKHClcEhwsGBQkAcAAICgEAigpGAQUK6AEGCg8CBwrpAQcKZAYICnkACAqQAAgKZwEJCsEACQrxAAkKUAEJCnIDCwoKAQsKdAELCrADDAqRAYwKgQIEC5gChQskAwYA6wKGAPcDhwDSBgkKHwAKCvQACgq7AgwKlQCNCvEBhQp5AYcAGAAGAEgFBQsgAJEKZQAHAPoFCgCeAA0ADQANAIkADQACAQ4AbwAOAOEADgD9AA4AMAEOAFMBDgChAZIAIQAEAPcBhwB9BgUAggAGAE0DBwAiBQkAYgIKAM4CCwBZAgsAMwMLALIDjAAYAgoAlQALABgBjgBQAYYAeQWHAJoHCACXApAACACGAEcGhwrnBwQLIQEHC3UCBwuiBgcLrwaMC9cABgvCAYgLbQAKAHIDCgBzAwoAkgOKAKADhQpLA4gLwQKECioChQoYAgUAoQEJCk8ACwpxApEKBwAHC9YEjgslAAQAiAGHAD0GBQCxAQkAeQILAHUChAqoAQcKUAGIChEDhgtjAQYA6gAHAAEDCQASAIoAZgEECoADhgrxBooLQwEHAIwABwCeBwgAqAILADEDkwBYAAcAxgSKAIIBiwuMAwsA+QAMADkBEABCAJEAGgCGAAUABwruAgkK3wALChsACwrSAQwKcAIOCgkBkgo9AIYLGgCGAMAEBQDDA4YA7QYEC54BBQvTAQkLjgIKC8MBDAs7AI0LdwGHCxEABApbAoUKlQIECgsABgqAAAcK5wAHCv0FigrVAocLuwMHALQACAD9AYgAGAOECtwBhADqA4ULGgKHCg8HhACjAwcArwMLAGYCjADrAocALQcJChQACgpEAQoKJwOLCugBhgCBAgYLGAEKC/YBCwtYAYwLJgAFCy0ABwuJBAsLwAELC3ADDQuLAA0LlwEPCxAAEQtfABILQgASC1gAEgt7AJULBwAJABgBigCGABYAFgAXAAUAlwAdAIgLCQMEAFoABQAhAgcA8gIJALoACgBIAAoADgMLAEECCwBiAgsAwAMMAGIBDABqAQwAUwIEC5oBhwsJAocL8gYFCnAABgpnAIYKlgCKCmQBhADmAgcAlwAJAEkBiwD+AAgAVQMIAHEDCACPAwgAkAMKAGgDDADlAgwA5gKYABIABAs9AogLjwIGAJkDhgCmAwkAuwAKACQACwD4AxEALACSAEAABwBBA4gABQIEAPoBBQAnAYcAkAYECsQCCAoPAAkKMgAJCoIBCwoSAAsKEQKMCuQABwD7AAcApQYIALQBBAozAgcKUAIHCn0CBwoCAwgKzwEJCjwACQpPAQkKiAMKCkkACwqyAQwKSQINCksBEgpuAJQKPACECvYBiABIAgYKWwGKCqEABwDbAwkAsAIKAAoCCwAUAwwAiQAMADYCDgAJAA4AGAAOAEAABwuDA44LRQEEANYABQD0AQUKZgAGChwBBwo3BAcKjwUHCqYGCArWAQkKKgIJCtMCiwpNAQcK9gCHCkgDBgoKAAgKOwIJCuMCjwpbAIUKcgKSAMMAhgDvBgcAhQEHALwCBwCsAwgAAgIJAHQACQAXAgoAdgALAGsACwCUAAsAmgMMAP4ADAClAY4A7gAFChIABgoOAg0KGAANCm4AEwoFAJMKLACEAOcCCwAkAQQKNQEFCs4BBwrKA4cKSQQWCh4AlgohAIsLUgGHCz4GBwADBQkA4wALAEUBCwCYAQ4AtACSAC8ABAC5AwYADQcGABYHBgBGB4wABgMGC2MChwvFBocLuAUFAFEABwCSAAcAPgUIADUACAAxAggAtgIIAPICCQBzAAkAswAJAH4DCgDOAQoALQMLAOYACwCRAgsAuwILAOwCDAB3AAwAyAAMABsBjgARAQUAmAEGABUDBgBtAwYA5QQGAIUFiQDrAoYKqAaHC5cCBgB2BwYAewcGAIMHCQCRAwkAoAMJALYDCQC6AwkA0gMJAOEDDAAsAwwAMwMMAD8DDABBAwwARgMMAI0DDACgAwwAowMMALYDDwC6AA8AuwAPAMMADwDEAA8A0QAPANcADwDsAA8A8QAPAPkADwD9ABIAtAASAN0AEgDgABIA4wASAOUAlQA8AAcAIgeHAJIHCwDqARIAjwAFClYABwrnAgkKVQAKChkBCgqwAQwK+wANCnYAjgp6AQUKDAKFCugCjQu6AQoKawCMCrQBhwv3AYYAigSECp8DBwAeAAgAVgAIADsBCAC8AgkAQAIJAFoDCgCeAQsANgELAHgDCwCIAwwAaQENAPgADQBzAQ4AjgAMCp4CkgpeAIYA0QIEC3EABQujAAUL3wIHC/EDBwp9BAkLCQAJCpwACQsDAwwLWgANC4oADQuaAY8LgACKAEcDhQoKA4kAaQKFCvYBCArEAAoKGwGLCpYBBgCsAQcADAIIAKkACADqAAkA4AGKAIYChQpXA4YAcAYHALUEigB9AgcAPAYEC6cDhQs3AwULDQEHC7IBBwt7AwgLUwEJC74CCwtSAgsLzgKRC2QABwtuAwkL5QGNCwgBBAAKAQgABAAJACcACgCmAAsAlgMMAHsCFAAKABYAGwAWACsAFgA0AIYLsQYHCngFCQq+AYoKLQCHC4QDhABeA4YAEgaHCwkEEwAQAJMLEACHC7gEBwCdAIgAFwEGAFwCiACHAQ0KxwEPCmMADwqBAJAKRACHCqwABwCxAwsAyQKLAOgCBADNAwoAbQMKAKkDCgCqA4wAxwKLAP4DhAo4Ao4LjwAEADcCCQBbA4QK3AIHADYHiAB0AogK3QKFAPoCBAqsAYcK/QYKABADDQC/AAcK3weMCpkChQAqAQcAeQIHAIkDBwCNAwcAAgYJAP8CjAB8AooKJgOEABsDiwAtAYcAsgcFC3EChwtRBocLEwEHCyUACAupAQgLtQIJC9ACCgt8AQoLfgILCxEBCwszAQsL2QEMCz0AjwsrAIcLxgCGANQEBwBxAQwAhAIMAIUCkABaABMADwCVABsABgBHAAcATQMIAKAACQA+AQYKVwaGCpEGhgCnBYYA5wSKAN8CCABMAIQLqAAGCtQGCArLAgkKIgMKCi4ACgozAw0KNAEOCl8BDgprAZIKQwCHC1sABgDaAQQKPwCFClsBhQrtAooASQOFCm4BBgBEA4QL4QCHAFYGhwpZAIwA3wKGAEEGiguRAAYAbgWJACQDjgCKAQYLDwAHC0YACgvwAJMLXQAGAGAAhwCSBQQAiwKFACEBBwu8AwcK0QMHC4UEBwviBQcLRgYHC08GBwtTBgcLyAYHC+8GCAtOAgkLRAEJC+ACCQsGAwkLCAMJCxADCgs3AgoLxAILCwYCCwtlAgsLtwILC8wCCwvjAgsLAgMLCwMDCwtQAwsLWQMLC6MDCwuzAwwLRgEMC4MBDAvkAQwLEAIMCygCDAtlAg0LvQANCwABDQtUAQ0LsAENC7QBDQu4AQ0LxgEOC64ADgvcAA4LHAEOC4YBkQt5AAcAsAIIACMACQD/AQoA/wKTAHYAhgCbAgQAAQIFCjgDhQqtAwcKuAEICuYAiwpqAIYA8geHC3cFjwtCAIcL+QUEC5EABguwAAcLiwEJCzICkAscAIQL9QGEAMAChgD0BQcANgSGC9ABBgv9AQoLUgAUC1sAlwsNAAQA0AKFADIBhQCvAQcArAQECpIDBQogA4UKVAOHC6UECgA2AI0KcwAHCjQCjgqoAAUA0AEGAOwABwC4AgcAkgMHAFQEBwCoBQkADwAJADQCCgAOAAwANQINAMEBDgA1AA8ADQAQAEAAEQApAAQKlgOFCmwDBgCKBYYK5AYEClwAhQoSAYYAiwMEC3IACAr1AQkL7AENC84BjgvXAAQLTQAFC2kBBguLAAYLkQEGC5QBBwudAQcLywIHC7QGCwsXAQwLswAMCwIBDQv0AI4LZgEGAOcGDADCAJEAawCGC7UGBQrnAo4LSQEECjEABwoYAYcKYQYFAEgDBwslBAgLUgALC/oADAukAY0LuACHC9QChgCEA4gKLwCGAJwFkAsAAAYAowIHAPADBwAYBgkAggILAOwADgDBAAUKEAEFCowDBQquAwgKxQAJCi8ACwoaAosK5gIEAEQABQB0AgUAegIGAIIBBwAaAwgAEQEJADMCCgBpAAoAqwALAF4AiwBiAYcKdweJCnsDBABfAAYAEQUGAEQGBwCgAYsAPgMGCwEChwscBAcA2wINABQAjwALAIkLgwMKAFIDjAC5AgQAlgIHC4kFDAt+ARELMACYCwwAhQDgAoQAXQMECpcBhAowAo0K6gEGCyECBws1AgcLhQYKC3IACwuCAowLagIGAGcDhgDoAwUAYAMKAIgCCwCfAg8ALgCFCwUAhQCgAwsAWgANAAcABArbAQsKIwANCkcADQqxAI4KpgGIAEwBhwvAAIYAHwSIC/sCCwDaA4wAqgIHAEwACAAsAAkAdAMKAEQCCwCPAQsAfgOPAHoAhwvVBIcKfAILACwBBgreAAcKVAYICpkBiQq1AgQLVwAFC/oACgtZAg0LKgENC2EBjQt4AQUABgIKAFQBCwCvAJUAEACMAAMDBgBUBIkAPwOEAEQDhwA8BwQAvQMGAAwHCABKAwgASwMIAFMDCABXA4wA/wKHCy4DBAs5AAcLqwQHC54FBwsMBgcLKwcHC3AHCQv1AgoLXAKLCwcChQpyA4oA9gAEAKYDBQDKAAgAYgIHC2kHDAsiAQ0LUAANC7UBkQtKAAgAYAAJACQACgBfAgoAJAMKAEADCwCnAQsAugEMADUBDgDHAA8AWgCRAG4AhAqqAQcAjgIIAPAABgo6AAcK6QIHCrEHCAqjAgkK3wEJCtsCCgpKAQoKUQIKCjEDCwogAAsKhQALCt0AkQpEAAkADQAJAI4BCQDXAgoASwAKALgACgDmAAoANAIKADkCCwDNAwwARgAMAL0ADQA5AI0AAQEEC9EAhwuGAwcAhwGJChoChgCTAQYLLwEHC08BBwudBQcLhAYICykCCAuMAggLkAIJCy4CCwvnApULEgCECy8CCwBLAI4ACwEGAC8DjQsCAI0AbgGJAHcChQv5AwUAWQGHAPgDhQvFAoYL0QaFCjYCBwC4AwYKMAAJCosACgqPAQsK1QEMCnoCjQrfAIUAoQIJAFIDBwsIAIgLzgAGAJYClQAjAAQAHwGFAPoDBgpyAAcKyAQHChQGiAoDAAgKQAKJCgsBBAB0AwUAIgAKANQCDAC8AQ0AYgESACAAFwAYABcAHwCYAAUAhQqlA4QLCAOKAJcAiACrAYYAfgGEAEkBCQBOAwoAOwOKCyEACQAXAQoAlwEOAFQAFgASAIcLEQWIC5YBhACKA4gAbgGGAEsDhgCjBYcAXAWKAOADBAB7AAUAXQIHAOUFiAAkAIQAiQIIC68ACguoAIoLPQKFAP8ChgD6A4cLGQUMCh4ADQqUAA4KVwAOCrYAEAoqAJQKRgCGC18CBAARAQUAkgKFAOMDBgBIAIsLrgAKAOMBDABwAQcKOAAHCsUHCApRAQgK4gIJClgCDQq/AY4KXAAFCxADigqaAocAQQWLC3IDhgANBYUATQKGAMQHBQB1AAYAAgIGAB0CBwCMBAcAnAUIANwACACIAgoAsAKLADACiAB7AQUArgIHCmIDhwqLBIQKSAEJCw4ACQu5AQoLMgGLCwkABAplAIcKkwQFCkEDiAroAgULoQAHC0cDhwt3AwcAxAAKAP0CCwBbAQsAKAILABYDDAAHAQ0A9gANAA4BDQCLAQ4AsAAOAL4ADgCOAQ4AnAEPACAADwA/ABAAWACTAGkABgoJAAYKjQEHCjUABwrOBgoKeAILCjwDjAqSAAUAfQGHAAAHhgCsBYcLrQEIAG8BCgD4Ag4ATwAUABEAmAAAAAcAaAKKAJ0BCwqhAQwK3wCMCgkBBwtLBg0LDgAPCywAEwsNAJQLTACHAM0EBgB4AAcApAQHAK4GCAAeAQkAmwILAFACiwDaAocLFgeHAHoEBAq6AAUKnQAICqgAigoGAAQAYAGHAK8CBADAAAUAMQAGAMgABgAlAQYAoAaHAH8EhQprAwUKBQMFCt8DBgpjBoYK/AYHCm8AiApFAgYApwOGAH8EhgAaBIQAigKEAJMACwDCAAwAPgAMAFgACwvCAAwLPgCMC1gABgBTAYcAmwOGCtMGBwuDAogL7ACFAKYDBwpUBQcKcweNCp4AhAqTAgQKlAGHCqMCBwtFAgkLhAKJC7sCDQDTAA4AhQAOAMwADwBAAA8ARQAPAHIAEAAKABMAFwATACMAEwAnABMAMwATAEcAEwBLAJgADwCFCocBBQs2AIcL6QUHAN4ACABVAQUKHAKGCqEGhgpOAIQL6AKIACUBiQu9AgcLogMKC5IBCgvcAQ0LxAESCzcAkwtoAIQAfQKFCswBCAsyAIkLcAKECzwChgCHBAQKxwCLCiIAhgBPA4YKhAEGCysABwsmAAgL+AAJC/gBigsBAgkAqwIECv8BBgpgAgkKTQEKCloCCwq5AQsK0wILCtADjAplAQkAYwOKAEUDBgCwA4cLRgGHABEHBQqqAwcLDwOICsMChQv+AoULawEGAKoABwA4BAgAiwEIAOcBjQCTAAYLAgGMC5kBBAAXAggAagIFC/kAlAtSAAYAYwWVCw8AhwBZBpYAFwAFC4kBBgt6AQcLvQcJCyAACQtPAgoLrQIKC+UCjgt+AYULFAMHC7AHCgsTAIsLjwMHC3kFhwvEBQQLPQAFCzoABQurAAULewIFC6sCBQu8AgYLIwEGCzYCBwtyBgsLCwIMCxEBDAsvAQ8LJwCPC28ABgrVAQcKrQaKCgMCBAAKA4YLTQKEAC4ABQArAwYAjwYGALIGhwDwBwcAsgUJAJcBCwAPAAwAiwKVACUABwCqA4QK9AEGACIABwBFAAcAQQQHAAEFCADEAggA0QIJAGsBlABiAAoL5wCTC3wABwvWApgLCQAFCkQAhgp/AYgLRwIEC5UDhQvtAwsK2ACLClQBhwuLBggAuQEKADoBjwADAIQLlwMEClEBBgphAQcKjgcICugBiQqtAQcAeQMHCgMHCAoDAQkKhwAJCrEACQpcAwoKOQMLCnMACwpyAQsKlQELClwCDAoKAAwKmwIMCp0CDQpMAA4KNgEPCkwADwqTAJQKFwAECg8ABAv/AAUKFgAFCy4BBguEAAYK9AAHCigABwuAAAcKyAAHCxsBBwqKAwcKrwQHCxMFCQpoAgoLNAAKCwICCgrMAgsKewILCiEDCwudAwwKygENC1wAjgs1AYQAzgGJC60AhwrHBggADQIFClYCBwoXAwgKbACJCnsABQBJAAYAFwCGAFIBhACkAoQKqwIHANUCCADyAYsADAEMABUAlwAHAIcABQMECpsAhwqZBgQApAAFANoCBQqXAAUK5QIGC9IABwryAQcKZgMHCgYGDArVAA4KJAAOCocBEQpvABIKBgASCi4AEgqXABMKJAAUCiAAFAo4ABQKRQAUCmYAFQoEABYKCAAWCgoAFgoOAJYKHwAECnAChwrYBgQARwIJAKgDDwDWABIAxwAYABoAhgtMAgcAtgULAJMCBAscAYYL3wCFANwAiwAjA4QAIAIECuwBhQrDARAAYgCUAHcABAvaAAcLDgKPC4kAhwpDAwQLDgEFC8AABgtMAQcLKgUNCwkADQpGAA4LaACOCzcBhAobAowLlQIFALAABgC1AQYANAILALUAjQC3AIcAqAQGCnEAhwq0AYgKzgKHCggChwBWB4wLxAAHC3sBCAvhAYkLeQEFC+sDBguVAIkL6gIICwYBCQtzAgoLEgALC9YACwuUAQsLyQELCwwDCwtRAwsLkQMNC0oBDQuRAY4LyACVABoAiAswAYQLjgCHALADBAAWAwUAEQGGAIoBhgBXAwQAhwAGAH8ABwChBAcA5wUIAGUCCwAFAAwAUAEMAO8BDABKAgwAlAIMAJwCDgCBAQ8AdgARABQAkgBiAAYA5gAJAPACEgBtAAwKYgINCq8BkAo7AAcAogeHC50DBAvXAQULMwAGC1oCCAvkAQoLwwCMC58AhAozAYgLsAKEC7kCBwssAwcL7QQHC1AFCQt4AowLYAEFAKIACABEAIUKxAMEAI4CiAvUAAQAnAAHAOYDBwAVBAcARAcJADAACQC0AgsAowGLAFoChQvdAAQLdQEFCxsBBgvgAYcLYQKOC9gAhADwAAYLwAAJCxkDkQs3AAQKSwAFCrQABgr0AQcKOgAHCsYCigqFAgQLhAAFC0UABQqJAocL2gQGChQBBwoaAQcKbwMHCpwDCArLAQkKVwIJCvICCwo+AgwKgAAMCu4BDQo0AA0KLQEPCh4AjwqEAIQKyAAEC28AhwsuAQkAxQAKACwBDADZAQ0AWgCNAJUBhAv/AgYLKgAHC4gFBws2BgcL1QcIC4MACAvSAQkLoAINC/wAlAtnAAgAvgMIAOcDCgDDA4oA6QOHClUGhwBaAwQAXgKJC7wBBgssAIgLcAGLC6wABAs6AoULeACLC3ACBwC6BwgApAIGCuEAiQrTAAcAzAMLAGYAiAqvAgYL4wCHCzUGCAo6AAkK1AILCikDDQpxAJEKSAAEAGkBhQA7AYQAzQEGClkBhwrfBIQA2AEICv8CCAojAwkKLQGJCocDhws1BYcL3QEHCp0HiAqiAgYAiQOKAOsChQCbAIYKAwEHAKMACAA/AQkAkgEKABgACgCpAgsAyAAMAP0ADACaAY4A2wAFANsBBwD0BgkA5gALACkBCwAuAg4AQgETAEwABguDBgcL9AeKC1gCiAr+AAYAUAOHAKQHBgv/AYwLhAAFCzgCBguKAIcLDQUGAHcCiQBGA5UAJAAECzUCCAsXAIgLOwMFALADhgDpBgQAkAAGAEoDBgB4BQQLmgOFC/8DhQr4AAkKIAMKCrUCCwriAQsK3gKLChUDBwvqA4sLkQAECnQABQpfAAUKvQEHCpgGCAodAAkKEAELCv0BiwqTAw4AcQGSAEgAhwppBoQL5AKFCh8CjAt0AAYA9wAJACsCBQq1AIgKKQCFCpECiADkA4oKxQIHAL0ACArKAIoKGAKIC5IBBAvMAo0LHwAKABgBigAdAwkKpwGMClkACApxAAkKbQMKCioCCwpTAAwKiACTCm0AhQrQAwcA6gKECs4AiAAOAosAWQGIAPkDCAuYAAkLNQAJCwwBCQuFAwoLBgIKCz0DCwu8AA0LSgAOCy4ADwsRAA8LIQARCygAEgskABMLFAAWCwEAmAsCAIUL4AKICxQCBQCsAYoAiwKHC6kChwCKBAcARwENAOYAEQBxAAgK4gAKChkCCwo6AgsKXQILCh8DCwokAwwKVQAMCgQCDApvAgwLpQINCmkBDgpNAA4KTgCTCm4ABAAYAwcAtQYKACIChAoBAwQLrAKIC4ABhAonAoYAswQJCjkACQrLAQoKqQELCncADAq4AAwKcwENCmYBkQozAAUAoAIFCi4DCAoKAAkKpQEJCtkCCgphAosKsQKKAL0AhgpwAgcLbgAHC7wACAsiAQgLTwIJC34BCQuJAgsLRwALC5sACws5AQwLBQANC0UBjgsfAYUAYwAGAB0EhwAqAQcLaAEHC6kBCQtCAAkLFgGKC4QCBACNAYgAKwKJCg0BhAoQAgQLhAOFC10DBgCFBAUL/gAHC9kDiAtJAAcLpweIC6sCDACOARQAJwAVAAsAlgApAAQA5QEHAGEBhwDzBQYAbgEHAGgFhwBBBooAEwOJABoBBQpoAAYKrQCHCl8GiwuSAAQAnQCFANcBhgCtA4QL1QIHADgFCAqKAAgKVgEJClQACgrBAAsKcwOMCmcBhgvEAIgAdACFCz8DhgATA4YKXwAGCpYBCgqZAQoKvwELCiwAjApkAAUAoAAHAGsBBwBNAgoAqgCNADcAhgAXB4QAYgMGAHkDBgArBAYAnwQEC0EBhgs5AgULUAOGC0IABAskAAYKZAYHC2sFCgvNAAsL8wKNCw8BhACxAgkANAMEChoBBwoKBAsKjgELCnoCDAoBAAwKTwAMCiACDgrtABEKCgCSChQABABsAAcAJAOLAPIBhAt3AwYAXwSHC2wCBgulAIoLhAEFAPQABQrzAQYK3AEHClgCBwp4A4cKSASMAGEChwDtAwQAnAGFAEUCBAvPAocLmwAHCigBBwpUAggKMAIICkoCCQpkAgsKMAEMCi4ADQpZAA4KcACRCnoABAB/A4UABAOOCzMBhwBqBwQAngOFANcDBAthAQYLkgAGC/0GBwsgAQcL3gMHC0QFCQuZAgkLggMLC30DjgvUAIQAGgKFCxQCBgAmAQcA8wQIAHACjQDwAQcALQUECy0AhwvpBIoALQEJACoBDAAjAQ0AFAEOAAYAEQASABUAIAAHCj8GBwq7BggKTwAICmoACAq+AAgKLgEICn8BCArJAgkKdwAJCukACQqjAQkK1wEKCrUACgqWAQsKOQALClUACwp4AAsKsQALCigBCwp+AQsKxgELCvYCCwrnAwwKGwAMCoMADAr1AAwKOAEMCr4BDArGAQ0KYgANCqoBDQr8AQ4KowAOChABDgoVAQ4KcgEPCl8ADwqKAA8KpwARCiYAlApgAIQA9QKGAO8EBAA0A4YK3waFANICiAswA4oKdAGRChAAhgAPBAQA3wOGAOwHhQoCAQcAUweLAHwABgsvAgYLmwaHC0oCBQBEAQcAcQMICoYACQoUA4wKtgEHCx8Hiwu1AgYARAWGAAkGhgCPA4QAugMIAEkBCACeAQcKnAeHCtQHBQAFAgYKtwEHCgwDhwoQBIQAMAMFCgEABgpRAIoKCAIJAMkCCgDeAAUK4gEICmIACgq8AgoKNgMLCi4BCwoKAwwKMgAMCn8ADAqMAQ0KPgANCkgBDgp6AJMKSACJACEABQoCAAcK1gWICk0CBgoAAgcKHQMICv0ACQpNAAoKAQAKC2wACgqBAAoK4QALC3QACwp2AAsK4gALCvsACwquAQsKvQILCs4DCwrWAwwKQAAMCgQBDAroAYwKsgKGC8gBhQudAwUAlgAHAGoABwAGAwgAWwIJAFECCQB6AgoALAAKAK0ACwDOAQsAAwINANgADQAgAY4AkAGJClsBBQDsAoYAKQIMAGwAjQAjAQcApAEECgwABwoKAgcKKQMICh0DjQpYAAYLwQAHC/AABwuSBgoLMwAKC4ACCwuaAQ0LUgAOC/cADgtLAY4LeQGFChAChwDxBgQA7QGQADcAiAt5AosAUQAGANQDiABBAZQKbQAFCgoBCQoiAQkKbAEKCiUBCwpeAo4KLQAGADgCBwBwAAcADAcIAGoBCACaAQgAPgMJAAICCwCJAo4AnQAEAEoABgD+AQYKUgIJCnkACgoxAAoKnAGLCkIDhgBGA4gK7AKECtIBhABxAocLowUEC+0AhwsCAgkKegGNCqIABgAQAAYAngAHACsABwCBAAcAtQAIABQBCAB5AQoACwILADADDADHAQ0ALwGOAIcAhwAZAQQAAQAHAHcEBwC3BQgAPQAJAM8ACQCGAQkA0wGLAEQDBguIAQcLQQCHC+MHhAqbAgQA0wIFAH8DBwAHBAgAxwAIAFQBCQCZAAkA1wAKABUACgA7AAoAUAAKAOAACgBGAwsA5QALAIwCDADAAA0AkgCOAFsAhAAnAYkAMwAJC94ACgsrAIsLhAMFADUBjADTAAUAfQAIAE0AigAPAIgLXAKKABUDBQCtAAQKJwAHCjMHCAqXAQsKkACMCgsCigsJAYUAtwGECv4BBwCIAgcAagMLAKQADABMABIACQAHCrwHCgrnAYoKKQMMAG8ADgAmARMALQANCgQBkgo/AIULJQKGCjoCBAAIAAcAgAQHAIEEBwCzBgkAdgEKAN4BiwCIAocASwQFAD8CBgBiAYcAvQIHCyQACAvJAIgLXQIEChMDiAucAAYABgKVCw0AjAvgAIYAvgKECgQCBQvUAgoLMQELC5cADAshAAwLeQAMC30BEQsDABELGwARC04AEgsSABMLNgCVCwUACABXAAQLCwIFC34CCwp3Aw4KbQGOCncBigC2AYgKNQOHC3QHBgvyAAcL4wAHCy0GCAtoAAkLcQAJC9wACQurAQoLSgAKC+8ACwtDAgsL/wMNCwQADQvMAA0LPAESC18AlAtWAAQARQAFAHoABQBRAwYAYQYJAJACigDQAQcACgcECgoAiwoSA4cLXQOLAPMBBwDcAQcAOAaKAFcAhQqsAgQASAOGChsAjgAbAQYAVAYHCzAFiAvuAQUAWwMHAIgECABrAAkAIwEJALcBCgCXAgsAYQKMAMUABwsaBQgL+QEJC+IBCgt+AAsL4QAMC1sBDAvBAQ0LEwCOC9oABQsMAQoL/AIMC3gADQsnAJELfwCRCjgABwuIBgoL2AELC70AjwszAAYKVgEGCvABCAoTAYkKzgCFAFgCBAB1AAYAdAEHAHEHjgBDAQQKjQMFCqwDhwu/BYQKewMEANICiwDXAQQLgAGHC/4DhAqvAgkABQAMANgADAAmAQwAKgEMAJABDAAGAg0A5QCPAIsAhwunBgcLQgYKC7oCDAvUAI0LMwEGCikAjQqgAIcLNQQJC58ACwscAIwLWwIEAAICBwAYBYoA3QGGAO4GCQBYAIsADgEFAAwABwB3AQkAtgGGCrYGhAsDAogKCgMIC3gCCAu5AokLVgMGAGoBBgDlA5IAMwAHADADBwDZBAkAGwEJAAgCCgDVAAoAMwEKAM8BCgCfAgoA6gILAJEBCwAaAwwABQISAGsAkwBzAIUKcwCWCxwABAuIAIULJwKOCjoBhAACAQYAFgAHAIcDBwCrBwgAfwKKAEECBQCpAggADgMNAIIAEQBUAAUKwQCMCrIACQsRAIoLIwEHCwcFCQssAAoLKAIKC4ICCwtHAwwLEgEMCxMBDAt0AQ0LWwCOC30AhwquAAQAmAIFACQDiwD1A4YArgMGAEUFBgBJBQYAqgUHC+4Fiwu2AgsAZAEECnoABQocAwUKuAMGCnwGBgqHBggKNwIJCq8CCQrmAgoKrgILCqoCjAoZAQUAIAAGC5MABwt2AwkL8QKKCwwBBQqzAAcKRwSHCr0EBApCAAcK0gKHCogDhwpgAQkL9QCKC4kABAAhAQcAdQIHAKIGBwCvBgwA1wCFC54BBgC3B4cL4gYGAMIBiABtAI0KIwCGC1cCiADBAoUAmAKGC9UGCwuSAQwLbQAMC68BDQuzAA0LzgAOC68ADgvZABALAwCUCzUAhwDWBIYLWwaEC+gBDQA+AQoKUAIKCvECDAo9AQwKYwEMCtEBDArVAQwKMAKMCkIChQo0AoQLUwCMC6QCBgBQBwYAcgcGAHMHCQCmAwkAvAMJAMADCQDkAwwAGgMMAGwDDABwAwwAlgMPAOYAEgDqABIA7gAVACYAlQA+AIYKLAKGCxYBiQBnAAcKIAIICs8Cigo9AAQKBQAFCvIBCAp9AokKCQIHAAkDDADlAAwA7wAPAAwADAvlAAwL7wCPCwwABgAaAAcLhAEHC4QCiwsNAwcL5QAICzsACQu+AAkLAQEKC3oBjAu/AIUKnwOHCqEFBAp9AwUKDAOFCn0DBACeAQUA0wEJAI4CCgDDAQwAOwCNAHcBjgCtAIcAEQAHAEYFhQruAIcAuwMEAMADCgB3AwwA8QISAKEAEgCiAJgAEwCIC1gBBgrBBokLIAGEC5QCBADZAAUAxgIHAPgCBwCGBwkArAEJAMQCCgD+AAoAKAEKANACCwBtAAsA/wAMAKUADAA7AQ0AawANAMsADgA2AA4AYwAOAHIADgCEARAAVQARAAkAEQAhABQAGQAUABwAFAAdABUACQAVAAoAFQAiABYAEQAECjwABwoIBwgKOgEJCrwCiwrnAQcLCwSKC+ECBwuyAgkL2QAJC0sCjAsJAgYAlwMHC8ICBwsiBIoLGgIHCj0Higq1AYgKowEGABgBCgD2AQsAWAGMACYABQAtAAcAiQQLAMABCwBwAw0AiwANAJcBDwAQABEAXwASAEIAEgBYABIAewCVAAcACwtcAAsLxAALC5kBCwvCAQsLmgILCwkDDAsGAQ0LgQENC4kBDwtzABALLQCRC1IAiAAJA4YL0AYEAJoBBwAJAoUKPAOGAKECBwBWBAcA8gYHCrAAhwqyAAUKJgMHCwwBBwq4B4gLOQIEC90CCQvCAAoLXAALC8YADAtUAAwLVwANC4AAkAtKAAUAVQEHAGkECwCeAQQKMwAGCgQABwpPAgcKUQMHCrcDBwpNBgcK4AYHCsQHCQqyAQoK8gILChkAiwolAIUKhgOHCqADhwATA4QAtAGGCg4BBwAzBocAqwYGAHkBBwABBAkAZQKRAGgABwvWAwcLUQUKCyAAjws4AIsAYACEAMMBhAqgAY4KdAEFCpgABQrFAAcLMgEHClQBBwpjAwoKJAIKCkUCCwoGAAwKAwAMChMADgpuAI4KIQGGAKgChgthAgcA4wEHCr4ACAocAAgKjQAICrwBCAorAwkK1AELCk4BDAoYAAwKggGMCkACCgCUA4UK9QIFCtEChwoRBoULsgCGAKkDhAqCA4UA4wKTAFIAhwCXApIAgAAFChUBjQr3AIYAPwSECrMBBgt9AQcLhQIHC7YCiAsiAgcA9wGHAF0HBgCtBwgAnQOKALsDBABxAAUAowAFAN8CBwDxAwkACQAJAAMDDABaAA0AigANAJoBjwCAAAQARAGKAGgABwDMAQUKCQGGCtQAhQtpAAcLBQEHC1MEBwtbBAcLSgUHCzQGBwupBgcLbgcJC9EBCgv4AAoLXQEKC4cCCwsPAgsLlAILC50CDAsRAo0LMQEFC7YBCQu2AgwLcwKNC9IAmAsLAAQApwOFADcDhAq+AgUADQEHALIBBwB7AwgAUwEJAL4CCwBSAgsAzgIRAGQABQooA4cK/QcHAPYDCQDlAY0ACAGGALEGBwASBwsAYgMMAGcADQDvAYwL6QAEAKcBCgC1A4oA9QOHAIQDCAsZAIoLOgMFCqYACArjAowK/wGGAOIHBwv2BIsLZAIECncABQqqAAUKvwEHCqwGBwphBwkKZQEJCs8CDArmAYwKVAIMAD4CjAs+AoQLNAEGAMQDBgC2BIYAFgUECsIBhwqGBIcLlgCIC4kCDgDVAJQAJgAJCy0ACQs3AY0LKgCGCwkCBwpfBQcKugWKCksBhAryAgULUwEHC6IFDgsDAA8LKQCTC0IAiAt6AYYA/gMFClIDiAofA44AjwCHAO0HhgtcBggACwKWACIABQBxAocAUQYHABMBBwruAAcK8QcICngACAq8AAgKkwIJClYCCgrSAQwKVgEMCkwCDQr3AQ4K9gCPClwABwAlAAgAqQEIALUCCQDQAgoAfAEKAH4CCwARAQsA2QEMAD0AjwArAIcLPQOHAJcHhAD9AgUL5gGHC0UFBwtjBggLEQAKC9kAigsnAQQKyQAHCtAGCApaAgsK9wALCjoDkQpBAIoLLgILACcCjgCfAAgKpACSCj4AiwuwAIQAqACIAPIDhgDKB4cAWwCKABQChwrbBIcAXAeECosDBQpkAAoKSQEMCqABlQodAIYLvwGECrAABQp8AgUK5gMHCgkABwrkBQgKGgAJCj0BCQpmAQoK0gAKCiQBCgoVAgsKKwIMCg4CDApfAg0KBwENCssBjgoPAQQLYQKHC/QCBgAPAAcARgAKAPAAkwBdAAQLogOFC7MDhgDLBIYA/gWFC6sDhQvCAwULiwIIC6oACQs9AAkLPwAKCxcACgslAAoLQgMLCwQACwu7AAsLGQELC/cBCwulAgwLYAAMC4IADAv0AA4LBQAOCygADguiAA4LygCSC4UABAuWAQULQwIMC+wBlgsPAIsAiAEGCmICCgp/AI0KGwAHAI8CBwA0B4gKdwAEAJEABgCwAAcAiwGJADIChAD1AYwLkQCIAPsDhgD9AYsACwEGCxEABwsQAAcL6QMHC74HCQt2AwoL6QEKCyADCwsOAwwLQAENC9MBDguRAA4LgwGPC3cAkQsRAAYASwSFC8oBBwu/BwgLAAAIC6sACQt4AAkL3AIKC9kBCwuQAgsL5gMSCwAAEgsCAJMLFQAMC6sBkgsmAAoAtAOKAMgDBwp+AIgKVACIChYDBAByAAkA7AENAM4BjgDXAAYKQAAMCnkBjQo1AQQATQAFAGkBBgCLAAYAkQEGAJQBBwCdAQcAywIHALQGCwAXAQwAswAMAAIBDQD0AI4AZgGGALUGBwAEAwcAJQQHAG8GCABSAAsA+gALAF8CDAA3AQwApAENALgADQBvAQcKUAQLCg0BCwobAgsKcwILCsICCwrPAwwK+AAMCrIBDApYAgwKbgINCikBDQrlAQ4KRQAOCpkBjwpsAIcA1AIECwACBAsHAoULVgGGAG0EkQsdAAsK0QONCvsBBgBJAwYAEgQGAKoECgDhA4wA/QMGCx8ABwvrAQcLEgIIC1ACCQoiAAsLNQALCuQBCwsLAwwLpwAMC5sBDgsOAA4LiAAPC0gAEAsRAJALSAAEAP0DBgD1B4ULiwMHAHUBCABPAQgAVAIJAOgBBgqkBgcKJQEHCn4BBwoCBAcKPwQHCusHCAr8AAgK1wIICtkCCQoeAAkKxwAJCucACQr7AAkKTgEJCmkBCQrIAgoKNwAKCjwACgroAAoKTAEKCoABCgqMAQoK+AEKCh4CCgqMAgsKFAALCjAACwrPAAsKIwELCioBCwpWAQsKbQELCooBCwpsAgsKwQILCvkDDAp7AAwKVAEMCpYBDAqDAg0KPQANCg0BDQo3AQ0KPwENCuYBDgrqAA8KPgAPClUAEApHABIKdwCUCmkAlgAlAAQL0AAFC2oABgsTAggLmAEJC7wAigs8AoQANAIGAAEChwAcBIQAOQMJAIMDjAu5AYYACgOFC3sBBwCJBQwAfgERADAAmAAMAIQL8QAHAFwEBgp7AQcKDgEICrAACAq3AAkKsAEJCpUCDAr3AAwKaQKSCn0ABQoYA4UKhAMGACECBwA1AgcAhQYKAHIACwCCAowAagKFAAUAigsHAIQLAwGHAMAAhgC9AogA+wKHCrsHBAqFA4UKCAMKAPMCkwAdAIUA9wIEC60ABQs4AQULAAKHCwUFBwtDBgcLmwYJC9ABCwvDAAwLFwEMC8ABDgsLAJMLZgAHAHIBBwDvAwcAmQSHAB0GhwDVBAQAVwAFAPoAjQAqAQQLxAEFC0cCBQsxAwYLsQEHC1ECBwvQAgcLYgUIC6EACQscAQoLOQGLC3YDBAsjAocLgQWIC9ICBAolAAUKTgGHCuUEhAr8AQwAawCSAB8ACAukAYsLwQCHAC4DhwuZAYwA3wMEADkABwCrBAcAngUHAAwGBwArBwcAcAcJAPUCCgBcAosABwKEABwCigs0AYQKFQKIAGACkAtBAAQA9gOGAO0HBADRAAcAhgMFC+oDiAvpAoYA7gcGAC8BBwBPAQcAnQUHAIQGCAApAggAjAIIAJACCQAuAgsA5wKVABIABQs/AgYLYgGHC70CBAvvAAYL3QEHC0cGCwtEAIsLaQKEAC8CCAAPAhIAPACTABgAhQqYA4oA/wGFAPkDhQCjAooKhwELAJwAhwqgB4oLcQGEC28BhQDFAgYAugKGAHcDjgp+AIYA0QaECuMBDQsrAY4LSwCFAMoCBwAIAIgAzgCKCuABBAu2AgkK7wGSCmgABwvgBAsLbQKLC74CjAuvAoQACAOLCvEDhwD4BIYAIwQICo0CDQpdAJMKDgCHC9UAiACWAYUKrACEALMDCACvAAoAqACKAD0ChABmAwYAHwaXCxwAhgvYAQUKBAGIC4QABAvvAgsLhgGMCyAABAuZAYULTgAMACoCBgvZAZELaQCFABADCACMA4gLMgGLAHIDBgBmAQcAcQUIAIwBCgAHAQ4AmgAQADAAEQAIAAcL3wYIC4wBCgsHAQ4LmgAQCzAAkQsIAA0LowANC7QAEgtOAJQLIwAOACAAEgBVABQAAgCYABAABwDkAAoAAgMICqcACAp3AQkKUgAJCjECigpsAoQATQMJAA4ACQC5AQoAMgGLAAkACwDGAwwAHwENAFYBDQCSAQ8AbgAPAKMACArCAIgK9AKGACoGBADHAwYAHAcGADcHjADMAogAUgIHAJQFBwBoBgcASwcJAKkACQC2AAkAbwEJAN4BCQD6AQkAJwIJAC0CCQCIAgkAuQIJAMECCQDVAgkAEwMJABoDCgDGAAoA1gAKAAsBCgATAQoAyAEKACcCCgAxAgoAZQIKAHMCCgCcAgoAowIKALMCCgC3AgoAwwIKAMsCCwC3AAsAyQALAPQACwAGAQsAYAELALcBCwDtAQsAPAILAE8CCwBgAgsAYwILAIYCCwCiAgsAxwILAO8CCwD5AgsACAMLABEDCwBSAwsAVQMLAF4DCwBhAwsAZAMLAGsDCwCCAwsAhgMLAIcDCwCOAwsApAMLAK4DCwC9AwsAxwMLAMwDDACUAAwAwwAMANwADADtAAwAPgEMAFMBDACJAQwAvQEMAMIBDADaAQwA+QEMAP0BDAAVAgwATwIMAFICDABVAgwAbQIMAHkCDACCAg0AOwANADwADQCRAA0A7wANAPoADQBJAQ0AWAENAG0BDQB0AQ0AgwENAJMBDQCeAQ0AyAENANYBDQDeAQ0A4wENAOkBDgA3AA4AOQAOAFEADgBaAA4AlAAOAO8ADgAKAQ4AQQEOAEYBDgBHAQ4ASgEOAFsBDgBjAQ4AkQEOAJQBDgCbAQ4AngEOAKABDgCkAQ8APQAPAEoADwBXAA8AWAAPAF4ADwBgAA8AdAAPAJUADwCaABAAMgAQAD8AEABJABEAAgARAEIAEQBcABEAZwARAHAAEQB4ABIAMgASADYAEgBSABIAVgASAFoAEgBvABIAcwASAJwAEwAoABMATwAUAE4AFQAWAIcLcwMFAKEAhwBHAwQADgMNCyUBjgs4AIULaQKLCzIAhwoWAJEAQAAFCn8CBwrhBIsKgAOKAOYDhwv6BwQLIgKOC+kABgATBIYAJgaGANgFBApmAAcKLwMHCqMGiwrEAwwADQOOAM0BBAs5AYULQQIGAH8CBgBaBIkAMQMIC7gAjQuxAQcAFgeHC6cDCgDlA4wAvgMEACwDiQtxAoQKgwOIChsDBQt2AwYLLgAGC/4GBwsOAAcL3AIHC3YGCAtfAAgLRwEIC2gCCgtWAgoLAQMLC4YACwvrAgwLegGOC2EAiACLAAYKNAAJCmgACQovAgwKNAGTClcAhQv9A4QKXAKECi0BiAoLAwcAgwKIAOwAhAuZAIYAlASTCiAAhQseAwYAOgWEC0sCBgtWAgcLKgAIC7cCCgvUAAsLngAOC8QAkQtVAIcK/AEFC70DBQvwA4cL+QAEC4EAhwvRAQUANgAHC9YBBwshBAcLsQQJC/MCCwuKA4wLDwIHC4wDkgsHAAULlACIC8IBkAsBAAQAAAGHANAFCQBfAQYKNgEHCjkHCApIAAgKEAEICq8BCQoMAAoKMwIKCnYCCgocAwoKKgMLCm8BCwpXAgsKrgKMCqACBgBdBwYAagcGAGsHjAC7AwQAygKFANUBBgD2BIYAsAWEAOgCBgA5AQcKGQIICkAACQp/AAoK8AEMCv4BjQqAAQQL2QAECvQABQvGAgcK6QAHC4YHCQusAQkLxAIKC/4ACgsoAQoL0AILC20ACwv/AAwLpQAMCzsBDQtrAA0LywAOCzYADgtjAA4LcgAOC4QBEAtVABELCQARCyEAFAsZABQLHAAUCx0AFQsJABULCgAVCyIAlgsRAIoAkgEHAMkDkgA3AAgAMgCJAHAChgBLBYQAPAKGCnIGCgq+AosK9QAKAE8DjgC9AQYAKwAHACYACAD4AIoAAQKFAHEBiQpSAYUA/gKFAGsBhQqAAwgLiAELCzYADQutAA0LJgGUCwcAhgCmAgcLzgSICxMCBgACAYwAmQEFAPkAlABSAAcKXQSIChsCBQCJAQYAegEHAL0HCQAgAAkATwIKAK0CCgDlAo4AfgGFABQDhgABBYYADwUHALAHjQD9AQQAPQAFADoABQCrAAUAqwIGACMBBgA2AgcAcgYLAAsCDAARAQwALwEPACcAjwBvAAYAwgKGAAMFhgBNAocLmQWFC7MBBwAjBA0ANgAFCgQABQoqAwYKDQAGChoCBgqaBgYKvgYHChsHCAqUAAgKuAIIChcDDAp9AI8KCQCHCvQEBQtVAAYLowEHC4YABwsxAQcLaQEHCzkFCAtHAIwLBwKJADgDjAuwAgULswIHC1kBBwppBQkLXgALCkYCCwqKAgsKhQMLCrUDDAupAAwK6AAMCuwADQqdAQ0K9QGSCnQABACVA4UA7QMHAD4GBQu3AAYLRgIJC1gBCgunAowLswEECp0DBQojAwgKugKKCjwDhACXA4cL/wGLCuADBAD/AAUALgEGAIQABwCAAAcAGwEHABMFCgA0AAoAAgILAJ0DDQBcAI4ANQGGAFkFhwo3B4YASAEHC8kHiAusAoUKfwGJAK0AhgtHAoYAgwUTAEEABQvAAggLZQEKC+kCDguqARELXgCTCzkACQqUAooKWwEEC7MABQvGAIULuQIHC1sBBwvLAwgLtQCKC8cCjQC6AQsASgMLAJwDDQA9AQ0AcgENANUBDQDXAQ4AjQESAEUAEgCRAAcKPAIJClACCwqoAgwKZAGMCiYCDgsTAA4LHACQCx0AiAAWAgQL8wAFC8sABwsTAAcLRwAHC3EACguVAQsLZQGOC/AABgDSAAoATQOKAF4DBwtHBQkLRQIKC38CCwvFAYwLSAIHC6oFiwtjAAoAfAMMAM8CkABpAAQAHAEGAN8AhgvsAQULhgAGC5gBBgvvAYcLOQaIABECiQAnAwQA2gAHAA4CjwCJAAYApAWOCwQAhAuZAgQADgEFAMAABgBMAQcAKgUEC/gABwuJAIkLXQGMAJUCBwDtBQsAVQIOAEwADgBPARQAIQAHCuwCiwq8AgULcwGHCzMCkgs5AIUKfwCFAKIBBAt2AQcLIwIHC6QGBwspB4sLWgMGCsYAjApTAAcLFAcNCwMBDQtkAQ4L8gCTC3IABwB7AQgA4QEJAHkBBQoUAQYKNwCHClkFigseAQUA6wMGAJUABgrYBogK1gIIAAYBCQBzAgoAEgALANYACwCUAQsAyQELAAwDCwCRAw0AkQEOAMgABgtvBgcLEAYHC9oHCQvuAYkL/QGHAOYCiAAwAYQAjgCFCvwCBgo1AQcKSwGKCiYChwomBAYLewAHC9YABwraAwkL2AIKC50ACwtaAQsLlgKPC2oAhwolBgcAnQOJAB8DBADXAQUAMwAGAFoCCADkAYoAwwCIALAChAC5AgYAkQQGANkEBgrCAAcKhQAKCu0BCgo6AosKmAKMAO8CBwChAwoAxAELAG4DEAAhAAUKGAAFCjkCBgoDAAYKdwAGCo8ABgq4AQcKVwIHCpYGBwo+BwgKqAEJCisACQpIAgkK+AIKCkgBCwqfAAsK/QAMCucBjAoTAgQLwwINC2oAEgsxAJMLKQAFAN0ABQtMAoYLiQGGAJ0FBgvTAAcLmgYLC+YBjAtxAQUKDgAFCnwDBgobAQcK6gCIChkCBADcA4gAuwOHAOMEBAp+AAgKewKTCiIABAo8AYcKGQaJCl0DBApAAAUKYAEFCtACBgpwAYsKZwGGAMAABACEAAUARQCHANoEBwopBgoKMAEKCiUCDAptAQ0K3AANCvAAjgohAAQAbwAHAGEDhgvbAAULRgIGC24GBwtjAAcLqgcHC8IHCAsDAggLBQMJCxcACQvrAQwLbAIOCzQAkQsyAIQA/wIHCzgClAsVAAYAKgAHAIgFBwDVBwgAgwAIANIBCQCgAg0A/AAUAGcAhQtTA4cAGgQGCq8AiQohAQUKsAGFCpEDBgAsAIgAcAGHCxADhAA6AoUAeACLClMCjAAdAAYA4wCHADUGBAtiAAcLVQUJC6YBCQueAgoLBwMLC9IADQsaAA0LyQGNC9wBjApQAAUKowOGCqIGhQAKAoYAYASHAPkFDADjAg4AwAGOANMBCwoOAgsKqwONCiIBBQoGAwYKZQYGCpYGhgrXBgYAgwaHAPQHBwqPBAsKpgMNCocBkQpMAIkLkwAGCgQBBwrMBQsLNQMMC24ADAuZABILKQCWCxMABgD/AQwAhACGCj0CBQA4AgYAigCHAA0FhAD8AwgAAgEJANAAiQBnAQQANQIIABcAiAA7A4YAWAEEAJoDBQD/Aw0L3QEOC3gAlAs9AIYA8AAFC9EABgseAAsLOACLCzEBBgCrAAcA6gMHACwFCQCfAQ4A5gASAEQABAokAQQK4AIFCmcDBgqZBgcKmAeJCkQCCQt7AosLLwIEC5YABQsvAYYLRwEGCj8AhwqYA4UKGQMIC8AACgtOAAoLKwILCzQBDQtnAZMLXwCHCxIDhwuwBogAkgEGAPICBgtmBgcLTwAHC/ABCQuKAAoLUAELCwwADAucAQwLuAGOCzEBBADMAo0AHwCFANYDCACzAggA2wIFCkMABgo+AAYKdgGHCm8FCQoWA4wKLwCLCywClwsBAAcLzAAHC58BCAsqAAoLVQALCyEACws0AgwLOwKVCwEACAB4AwcLYgKHC90FBAqHAYcKkQQFAE8DCQBIA4oAIwOJADcDhgARAwgAmAAJADUACQAMAQkAhQMKAAYCCgA9AwsAvAANAEoADgAuAA8AEQAPACEAEQAoABIAJAATABQAFgABAJgAAgAECwMABQv3AAULhAIHC+gCBwu3BAcLyQQHC3UHkguTAIgAFAKHAKkChAoPAYwAOgGMAKUCBACsAogAgAEFCx0BCQtDAA0L2QGPC1IABAr9AAUKIAIHCiwBiQpUAQcAbgAHAL8BCAAiAQgATwIJAH4BCQCJAgsARwALAJsACwA5AQwABQANAEUBjgAfAYYAGgeIAO8DigBBAQcAaAEHAKkBCQBCAAkAFgGKAIQChQoyAwUAgQEFCh0CBgpeAAYK8wEHCuYAiwpBAQQKmAMFChkABQoWAwYKyQEHClUDiAoUAwQAhAOFAF0DBQD+AAcA2QOIAEkABwCnB4gAqwKGCuUGhQo2A4QKegIECx0ABgsUAgcLXAYHC3AGCQsvAQkLXgEKC7EBCwthAAsLLQILC+kCDAshAQwLTwEMC1wBDAteAg0LdAANC+kADQvSAQ4LtQAOC9EADgvoAA4L7AAOCywBEAspAJQLYQATAFYABgokAAcKkgKICsYBhwucBoQA1QIFC/UBBwuoBgkLKQILCwgCDAstAo0L+QCGAMQAhQA/A4gA0wIHAGkHDQBQAA0AtQGRAEoABADgAwYAcwKIAOIDhwsOBYQKaAAFAFADBgBCAIgA/AIEACQABwBrBQoAzQCLAPMCBgAWBIYAzQWGALYDhAB3Aw4AwgGUAG8ABwBsAgcAPwMJCh4CCQo2AooK2AIGAKUAigCEAYsKBwEEAM8ChwCbAIoK1AEGC8UBkAskAIYLgQAFABUCBwDzAooADAOGALkFBABhAQYAkgAGAP0GBwCrAQcA3gMHAEQFCQCZAgkAggMLAH0DjgDUAAcKVwCOCiABBAAtAIcA6QQMAAcABwrcAwcKkwcJCkAACQr2AQwKIgANCgwADQrqAJMKTQAEAF8CBQs8AAYL+AEHC2YCBwuDBIwLAACHCo0ACAvGAAsLHQCMCxYCjABBAIgAMAOECmsCiwBYAAUK9gAICr0ACQpjAQkKAAIKCnwACgrFAQsKjwALCqABCwpbA40KVQEEC3sBhwt1BQQAWAKJAG0ChQBvAYYAMQIGAC8ChgCbBgYASQKGC0kChwvMBAQLdgAFCqYCBgsSAQYLaQEHC0sAjQu5AYcLGgeJC0kDBQA9AgYAHwEHCl4DBwpeB4oKswCECgUCjAu1AgULOgEGC90ABwujAQoLigILC4wBDAucAA0LcQEOC00BkQsvAIwKHAKICpsCCwqTAZIKUwAGAKAChQr5AgkAnQAKCoMAjApIAAcAygKGC8wBhgDIAYUAnQMFC6oChwtfB4gL/gGIC9sBhQv4AwkAEwAHC1oCCAuzAAoLDQOMC34ABgtJAYoLbwAGADYDhgDBBZALVgALAHEAiwtxAAULNQOGC5cGhQrBAQcAzwERAEUAiApnAAcK7AeKCoECBgDBAAcA8AAHAJIGCgAzAAoAgAILAJoBDQBSAA4A9wAOAEsBjgB5AQYA1wELAJsBjgACAAULRwAHC38FCQuEAQkLwAIKCwUBCgtrAgsLIwILC2sCjwudAIgAeQKHAHwEBgAqAgcAcAUMAIEABwr6BAcKagUHC9gHCQtRAQoLBQKSClcABwAjAwgAHgIGCrsABwqzBAgKfAEOCnUAlQocAAYKKQEHChkDiwqqAwgAtgELAGsBBwrQAQsKaQAMCucADgqCAQ8KZgCUCksABQsQAAYLVgAGC1sCBwskAQcLMQIICwEBCAt+AQkL0QIJCwoDCwtFAowL0gEGAM0CBAvmAYUL6wGEAGsDhAtIAAYLCQGHC08DBADtAIcAAgIGAIgBBwBBAIcA4weMCwUBhwuaA4kLlAEMADMCDgBlABIAgQAHCvIDCwrdAgsK9wINCiIAkgotAAcKeAYJCnEBCgpSAQoK6gELCpoACwohAgsKBwMNCk0AjQoSAQQAvAEKAJIAjAAJAIsLowAHAOwEhwD+BgkA3gAKACsAiwCEA4kL6gCKAMsDiQD5AoYAuwKIC7IBBgBcBAcAVgUFChQABgvFAAYKKgEHCpMCCAvNAIkK2wCEC+oBCws0A5YLMwAHCqAFCwpWAwsKaAMLCpkDDAonAg0K2AGOCm8BjAsNAIQAPQMMAPIAhAq3AYgKnQIGAFECBgvEAQcLOAGKC9sABAtNAQkLsAAMC2EBjQu7AAcAJAAIAMkAiABdAowA4ACECukAhgCWBYYADgcEAAsChQB+AgYAYQcJAL4DCQDLAwkA0AMMABwDDAAfAwwAKAMMAEMDDABEAwwAkgMMALIDDwDYAA8A6AASALcAEgC7ABIAwgASANQAEgDoAJUAMQCECuIBBgA7A4YAmgWHCloBhgD7BwYA8gAHAOMABwAtBggAaAAJAHEACQDcAAkAqwEKAIgACgDvAAsAQwILAP8DDQAEAA0AzAANADwBlABWAIYLlQYHAJQACAAcAY0APwCOAAoAhwtIAoYA4QQHAF0DhwpOAQUKGwMGCs0GiQtGAIQAJwMHC4cACAsHAAgLPgAJC/MACguSAgoLuQILC8gBiwv0AgkLiwGKC08AiQtsAJMAXgCIAO4Bhwt3AocKbgIHAOYFhwrWBgQKywCHCpAHBwuWAQcLywEIC14CiwvWAgcAGgUIAPkBCQDiAQoAfgALAOEADABbAQwAwQENABMADgDaAI4AswEFAAwBCgD8AgwAeAANACcAkQB/AI4LRAALCqYCjAozAQwLDAEMC4ACjgt3AIcK/AeFC2QCBAt0AQcL4gEIC54ACQtaAgkLZwIKC/UACgumAgoL6AILC/gAiwsmAwcKNwEJCjQBjAr/AAQAgAGHAP4DBQtWA4cLxweHCvIEBAqQAQUKCwGHCugAhwCnBgkAnwALAJUCjABbAgQAxAMOALYBDgC8AQ4AyAEWADwAFgA/AAkLagAJC6MACQsoAQoLpwAKC6wACgsJA4sLEACIAEcChAADAggAeAIIALkCiQBWAwULwwCHC5UGBgBjBIYAVQWGC0gBBwvNBwgL2gKLC+4DBACIAIUAJwKGAPYGBwAHBQkALAAKACgCCgCCAgsARwMMABIBDAATAQwAdAENAFsAjgB9AAUL7wILCx0DjAvLAIUA3AIHAKcCCAA5AQQKZACHCzUDCgBpAY4APAGGAFMCBgCTAAcAdgMJAPECigAMAQUKagEFCrsBBgo+AQcK+wOLCm8CBQrPAYgKKAEECsYBBQu2AwUL4gOGC18BigCJAAUKMAAFCpQBBgotAgcKygEIClUCCgrHAQoKXgILCjEACwokAgwK3AENChIAjQrCAYUAngGHAOIGBQulAYcLLwAFCroBhwrAB4YAVwKGANUGhgBbBgQA6AGEC14BiQvvAoQAUwCMAKQChQvHAwcAZwYFCjcAjAqhAAQL2QEHC28CCAsoAwkLZwMJC30DCwsmAAsLrwEMC3AADAvZAAwL8wAMCzICDAurAg0LjQANC8UADQvjAA0LlgENC+cBDgucAA4LywAOC+AADgsAARILOgCWCwAAhQrCAQcL4AKLCwgBhgAWAQQL3gAHCx4BiAt1AocKZQOMAGEAkAAOAIYAPQQECtUABwrfAIgKUAAHAIQBBwCEAosADQOEAFEDBwDlAAgAOwAJAL4ACgB6AYwAvwAHCn0BBwomAwcKNAMICmIBCAq1AQgKEwMJCpECCgo6AAoKUwEKCu0CCwqSAwwKogANCksADgpqAA4KxgAOCkABDgqdAZIKKwCNCzIBiArrAoYAWwQQAF4AEABsAIgLkgAGALwCBgAxA4YA6gOFCrQCBAvRAYcLfwaGCr8ABgCGBYcLkQOEAJQCBwALBIoA4QIGCqIABwqoB4gKPwOECsICBwCyAgkA2QAJAEsCjAAJAooKqgGHCtMEBgtSAAcLigAHCwUCCQuhAosL7gCKABABBQvvAQcLQgMJC90Ciwt6AYYA0AaEAPMDBws8A44LdAAEAN0CCQDCAAoAXAALAMYADABUAA0AgACFCy8CCgA5AAoAFQEGCxUABgvJBgcLpAWIC+AABArMAIkKhgOICkEDCwBcAQwAYwASAAEAEgALABMABAAHCm4BCQofAQwKxwAMCiwCjApBAgYAvQeIAKgDFQAhAJYAKAAFCwcCigvMAAUKZAGHCuAAhgAHA4cAMgEHCnYCCQo3AgsKlgALCrwBjQp3AAUA0wOGChsChQBjAgQLkgGHC48GBQCyAAcLAgAIC0MBiAvfAQULOwCHC6ACBADyAwYAsQeKC+0AhQucAZILIgAHC8wGkgswAIYAmAKLCi4DBAtVAIcLJQKFC14AhQvJAYQAhgGGAOYFBArrAIcK/wAECsIABQpIAgYLCwAGCoABBwu7AAcKRwIKCvkCCwr4AosKUwMECwoCiwsiA4cA7QEKCwgDDQtZAY4LqQGSACUABAs0AIcLlQKGANQChgA9A4ULCAKFCjICBAsZAQULJgAHC8IABwucAgcLZQeJC40BBQq/AIkKDwEHAAEGDgBgAI8ASQAFANkBCwCoAAQK1gEGCpkABwrfBQcKgwcKCr0CCwqEAAsK4wALCkABCwq0AQsKDQILClcDDAopAAwKHgENCmcADQocAQ4K/wAOCgYBDwp1AI8KfwCFAGkABQC2AQkAtgIMAHMCjQDSAIUKRwEGCigCBwraBokKXAKGAOgEmAALAAULwAELC2IAiwsMAgcAWgYFClAABgqVAQcKkwEHCt4FCArIAQkK5wEJClUDCQp5AwoKNQELCtECCwriAwwKrgENCqUADgsQAJILLACEAAsDCAAZAIoAOgMECsUBBQp3AwYKFwIICgYACAofAogKOgOJC80BjAt4AoQANAGHAOUChACfAgcAlgAIAIkCiAD8AwkAYwAGC1ABCAsoAgkLHQEKC2MAiws4AoYACQIFAFMBDgADAA8AKQAPAKYAkwBCAAYLpwEHC5kCBwu6BAkL2gCNC94ABgAfAgUKZQAFCwABBgpYAAcKjQYJCmQACgqlAg4KqQAOCi4BDgo5AQ8KMACPClQABAo2AQcKxAIHCuQDCQobAwoKhgEKCt0CCwrDAQwK+QAOCnMADgoeAY8KZACFCksCDQuhAQ4LgQCPCw8AhgBOBYgLKgKECvIBBwrZAAgKjACKCmIChwvdA4cLegIGAJsAjADqAIcLzgGEC2oChgBcBoQA/gIEC1MBBQqJA4cLAwGHAD0DBAv3Ao0LqQAHAKUFBArIAQcKZgEHCmUGCAqDAosK4wEFAOYBhwBFBQULsAKHC8gCBwBjBggAEQAKANkACgAnAQwAAgCMCwIAigAuApYKOAAECxYBBQvRAYcLVwWIC+IBhQoXAgYAUgUGALUFCgsSAQoLcQKLCxICBQBXAgULUAEGC1UBBgveAQYL4waIC4IBBwrUBokLlwCGAGAFhQobAocLSQCHC7MHiwsbAQkAXQCLANoBBgpbAIcKswEGAL8BBQuMAYYL9QEEChAABQo8AQUKSgMGCnIBBgryBggKpgALCiwDDArOAAwKXwEOCqIBEAoPABAKIgASCgMAEwoDABMKBwAUCgQAlQoVAAcAQQIHAJgFCQDbAQkA+QEJAA4CCQBhAgkAsQIJANYCCQDfAgkA4gIKACwCCgCiAgoArAILAFkACwDKAAsAEAELAHwBCwCfAQsA+QELABkCCwAmAgsAMgILAIACCwCbAgsAsAILAE8DCwCfAwsAogMLAKwDDACQAAwARQEMAEkBDACFAQwAkwEMAMMBDAADAgwAXAIMAGgCDAByAg0AQgANAIMADQCnAA0A7AANAHABDQCbAQ0AsgENAMUBDQDNAQ0A2gEOADsADgA8AA4AiwAOAJgADgAUAQ4AYQEOAJIBDwAcAA8AUQAPAHsADwCYABIAiACUAFgABAuhA4ULHwOICy4AjgAzAQQAYQIHAPQCCQAgAgsAnQGQABkACgCvAgcKawIKCiMCCwp6AIwKWQIEAKIDhQCzA4UAqwOOABUABAt8A4ULAgOFAMIDBQCLAggAqgAJAD0ACQA/AAoAFwAKACUACgBCAwsABAALALsACwAZAQsA9wELAKUCDABgAAwAggAMAPQADgAFAA4AKAAOAKIADgDKAJIAhQAEAJYBBQBDAgwA7AGWAA8AhwueAIcAVQKEANUDhAp4AwQKlQCKCnABhAAhAgQKmgAHCm4EiAppAIcL0QeGABYGBAofAAYKrQEHCsIDCQrKAYsKswKECjgBhwpqBgYAEQAGABgFBwAQAAcA6QMJAHYDCgDpAQoAIAMLAA4DDABAAQ0A0wEOAJEADgCDAY8AdwCHAL4HEQARAAcLtQWMC1sABArsAIQLWgKKAIsDiABuAAcAEAETADUABQpEAwUKWQOGCpAGBQDKAQcLwgSICy8BBwC/BwgAAAAIAKsACQB4AAkA3AIKANkBCwCQAgsA5gMSAAAAEgACABMAFQAKCkQAiwruAYkLlgIECw0ABQs3AgcL2gUJC3wACwsJAowLlQEEClEAiwpjA4cL7gMHCyADBwv3BooLDAAJACcBCgC7AQUKGgEICooCiQqLA4QL3wIEC6oABAoHA4cLQwEGADQHCgCcAwsLTAMMC2gAjAtxAgULMAEHC3sFjAvyAYYA0AQEAAcCCgBGAAwAGgAOABEADgCyAA8AIgCVAAwAhADhAwQLlACFC+YCBgAfAAcA6wEHABICCABQAgsANQALAAsDDACnAAwAmwEOAA4ADgCIAA8ASAAQABEAkABIAIUAiwOGAN0ChQtvAAQKRwAFCngBBwp3AIoKmQKIADcACACuAYgLrgEEANAABQBqAAYAEwIIAJgBCQC8AIoAPAIMADgACwo7Aw4KIgCPCpQAhgCdBoULvAGECt8BjAC5AQkAwQEKAMAAigDkAoYAoAMEAPEABwpfAogKYwAIC3sADwsGAJALBwAGCx0BCAuOAgsL7QIMC74ADAtHAQ0LeAANC3kADQtHAQ8LLwCSCygABAopAAUKSgAHClsGCwpnA4wKawIHAPUFCwpJAQsKxQMMCvEADgpiAQ8KFgCUCj8AhAADAYcLtwAJCtEAiQosAQULqQOHC2QAhQpiAAQArQAFADgBBQAAAocABQWNALkABwBDBgcAmwYJANABCwDDAAwAFwEMAMABDgALAJMAZgCHAFkEhQrYAwQAxAEFAEcChwDQAgQAIwIFADEDBgCxAQcAUQIHAGIFCAChAAkAHAEKADkBiwB2AwgA0gIECrYABgrNAIcK3ACWAA0ABAoqAAkKzQAJChIDigqTAgYAIQEHAIYGDAA5AJcABACECnsCDgArAJIAFQCLChUChwCeBggApAGLAMEAhwCZAYQKcwEEChABhwpEAwUKOQOGCmgGBQv7AAULvAMICwwBCQvWAJILjgCKADQBBgBHB40LJQCJCm8DBwo9AYcKOQKECyYBhgAWAwUA6gOIAOkCBQtaAQULxwKIC4YBhwAhAQUA+AELAEQAiQozAQQA7wAGAN0BBwBHBosAaQKVAA0AhQBhAoULcAIFCw8DBwvOB4cL/weFCg0ChABvAYQLUgIGABAChQrtAQQKrgCHCo8DCAqhAYkKDgOEALYCBwAkAokAOgAECiAABQrXAAYKDQEHCvYGBwpkBwoKEAALCjYDCwq6A40K4QGMAK8CBwDVBogK3QGECzkChQo0AYcKQAQEAJUCigDsAwULJQAGCycABgvDAQcL2gAHC5sCBwuOBAcLlwYIC5YCkAsCAAkAvQEMADUADQDsAQUKfgAICikBCQpuAYwKdgEHCg8GiwppAZQASgCGC/wBhwDVAIQKrwCECq0CBgD4AgYAQgOGAOAEBwvFAQcLewIHCxwDCAtLAQkLSAEJC0oBCQthAwoLdwAKC+sACwtvAAsLgQALC/AADAsfAAwLQgAMC94ADAsNAQwLVwIMC7ECDQu6AA0LbAGOC1kBBwCIBosAvQCFCh0DhQo1AgYADAYGC2IABwtJAocLvgIJAMgDDwDAAJUAOAAECvwABgslAAcLKwEHCiwEBwuCBggLwwAICzwBCQuyAAkLFAEJC1MBCQsYAgoLZgAKC2oBCgqyAQoLEQMLCzcACwuVAAsK5AALCqoBCwsFAw0K5wANC6ABDQujAQ4LJgAOCykADgvSABIKagCUClcABADvAgsAhgGMACAABACZAYUATgALC8oBDAsPAIwLsAEHAEIGCgABAQoAugILACACCwBJAgwA1AANADMBBQrnAAcKWQIJChUBCQqiAgoKsgAKCqIBCgr9AQsKEwIMCnEADArbAQ0KYwCOCqwBBgDZAZEAaQAGAJ0HDwCcAIULhQIHCjcGkAorAIcA8waHCpMGBAsiAYcLTAWGAPsCBgtGAAcLDAUKC/oCiwsgAY4AHQCMC6wBBwBzAwcLgwAHC6YBCAvSAIwLPQKGAOgBBAqPAQUKdwAFCu4BBwrvAokKLAKFAGkChAuoA4sAMgAHAO4FiwC2AokAEQMEACIChwD6BwcLzAINC2EAjQv7AIQLjQKRABYAhgD4AwQAOQGFAEECiAuRAggAuACNALEBhwCnAwYA0AIJAHIAkgtQAAwAugAMACQBDgBkABIARgAHClICBwpTAwcKQgcJCpsBCQo+AgkKmgIJCuECCgpaAQoKyAILCvYACwqwAQsKBQILCocCCwqnAgsK1wIMCjABDAoxAQwKQwEMCuMBDAo8AgwKUQIMCloCDQpfAA0KZQANCqsADQo7AQ0KegENCqkBDQrbAQ4KPwAOCnwBDgqAAQ8KhQASCnAAlApIAIcKRQSHCywHhAqnAokKywALAJIBDABtAAwArwENALMADQDOAA4A2QAQAAMAlAA1AAcLWAUIC+gACAtpAQoLqgKKC+YCiQrKAgUAdgMGAC4ABgD+BgcADgAHANwCBwB2BggAXwAIAEcBCABoAgkAfAMKAFYCCgABAwsAhgALAOsCDAB6AQ4AYQCJCxYCBADJA4gKOQOJCxsABgDXAo4LDACFAP0DhgCmBIYLeQYFCo8ABQoBAwYK4AYHCqoCBwrIB4gK4AKEAJkAhwt/AIUAHgOEAEsCBgBWAgcAKgAIALcCCgDUAAsAngAOAMQAkQBVAIUKXAMGAIkHhgCNBwUAvQMFAPADCQBBAgwAjQAGCqYBBwoAAAcKCAYIC2wBCwreAwwKxQENCi8AjQoKAYYAJwUEAIEAhwDRAQcA1gEHACEEBwCxBAkA8wILAIoDjAAPAgcAjAOSAAcABQCUAIgAwgEFCgMCiQqDAAcKRQYLCsIDkgqLAIQKhgKGAI4EBAqMAQcK2AIJCnUADQrKAJQKMwAGCnkABgp8AAYKZQEHCnIEBwoPBQgKogCLCo8CDgB2AY4LdgGKAP0AiwDrAwULjQMJC1EDigslA4UK7QAHCw0CBwsrBggL8QGICz0CiQAuAIQAbwOGACYDhwBMBwYALQeGADYHBgDaAoYAcQMHAMUDBwC0BQcARAYHC8EABwuNAQcLUQQIC3wACAtrAgkLMQEKCwgBCwsoAAwLXQENC4YADQsnAQ4LmwAPC3gAkgtpAIgA+gGPAAoABAsGAQcLVgEHCjsCBwpVBwoKbgGNCxcAhQuBAgoAFgAJCgECCgonAAwKegCMCrsAhwuXBZYLMQAEC2MABgv6AAYLWgEIC38AigtRAAYA3gcIAKADCgDAAwoA0wOMAOQDhgAoAYQLkwMFC0sACQsFAgoL1gEMC5sAjQvgAIkKaQMEAFYDjAsSAIYASwIHCmsABwpGAwgKJgKKCpEBCwB8Ag8AkQARACIAEwAyABcAFAALCkwCCwpgAwsKyAOPCqAAhwvYAAcA1gMKACAAjwA4AIUKAAOFC7oDBgswAQcLWgQIC6IBCgtZAQsLVQELC6MCjQsoAAkLmgGLC6kBiACtAwUAswGECn4DBQBVAAYAowEHAIYABwAxAQcAaQEHADkFCABHAIwABwKMALAChwDkAgUAswIHAFkBCQBeAIwAqQAFALcABgBGAgoApwKMALMBhgsOAAYAsQOHAP8BhgusBgULcQAGC/MABwtJBwsLoQAQCyUAkQtjAIQLEgGJABsCBwDJBwgArAKGChABBgCTAoYA1gMECgkABQqAAAcKcAELCuABlAoDAIYARwKEACMDhQDAAgQAswAFAMYAhQC5AgcAWwEHAMsDCAC1AAoAxwKHC6YAiAqqAgQKAgAHCiECBwp+A4gLCQKHAOEBhADzAAUAywAHABMABwBHAAcAcQAKAJUBCwBlAY4A8AAFC9UCBQvXAocLEwcGADoDiQswAQcAqgWLAGMAhQuOAoYA7AEFAIYABgCYAQYA7wEHADkGBgsRAQoLvAANC3kBkgtNAAkKAQOMCrkAhwuaAY4ABAAEAJkChgv5BgQA+AAHAIkAiQBdAQUKEgKOCnEABwD2BIsAZAKECwwDBQBzAYcAMwKHADoDBgD/BRcAFQCXABcABAB2AQcAIwIHAKQGBwApB4sAWgOFCiwCBwtkAggLIQIICzgCCAuCAgkLzQIKCx0CCgv7AgsLwQEMC+kBDQuZAA0LKAEOC4oADguIAQ8LMgAQCwYAEAsMAJQLCQAJADcBjQAqAAgKEACMCjgCBgCwBwYA6weKAN8DBgBvBgcAEAYHANoHCQDuAYkA/QGFC7QDBgq6AIkKqgGGAAEDhgCCAoQKSQIGAHsABwDWAAkA2AIKAJ0ACwBaAQsAlgKPAGoAjgt9AYcAmwUECxQCBQvCAocLlgIFC0UDhgtzBgQKXQAFCvwABgrlAAcKIwEJCiYCiwqEApQATwCJCu0ChgCRBYkKogAEC2oBBws0AAcLLwGMC6YAhAp9AQQLSgEHC6UDBwvcB4gLJAGHC/8CBADDAgUATAIGAIkBDQBqABIAMQCTACkABgDTAAcAmgYLAOYBjABxAYkLcwMEC78ChwvPAAQAuwAFALgABQCyAgcATQcKAPQCiwAPA4QLOwKGAGYFBQCvAAYKTQAGCp0ABwrOAwcKFQUHCjsFBwrSBQcKUQeJCnQChgDVBQULaQOFC8ADhgDvAwwLXQAMC/UBDQtqAQ4LlwAPCygADws7ABALLgARCxkAEgsOABILhgATCxkAEwtFABQLEAAUCxMAFAtCABULFwAVCxkAlgsqAAsKlwONCpkBhgDbAAUARgIGAG4GBwBjAAcAqgcHAMIHCAADAggABQMJABcACQDrAQwAbAKOAF0AhQBTAwULIQCGC9YBhwsLBYYA/gSHC1oHhwrRBYQA6AOKANYDCAD6AggALAOJAI4DBgsvAAcLWgAHC5gCBws+AwcLZAUHC+kHCAvAAYgLPAMEAGIABACsAwYAGwcGACoHBgAxBwcAVQUIAFsDCACBAwgAlgMJAKYBCQCeAgoABwMKAH4DCgCNAwoAjgMKAKcDCwDSAAwA7gIMAPMCDQAaAA0AyQENANwBEABkABAAbQASAK0AEgCvAAgKjgEJCqkCiwp4AgkLoQGJC+0BiAqFAooAigOGAMIGhgoUAIUL+wOGAKEECgAoAIgKAQMJAJMAhgvQAIwAigIFANEABgAeAAsAOACLADEBhAApAooLWAEGC0QABwuOAQcLwAEHC10GBwsVBwgLgwEIC7oBCQvGAgoLGgGKC9ICBQBVAg4AFACOCxQAhwBOBocK3QYEAJYABQAvAQYARwGHCqkDEAAxAAcKdAaQCzEACADAAAoATgCNAGcBhwASA48AhgAGAGYGBwBPAAcA8AEJAIoACgBQAQsADAAMAJwBDAC4AY4AMQGIC+sBBApDAgUK4gAFCkMBhwrAAwcAzAAHAJ8BCAAqAAoAVQCLADQChABmAgQLkwEFC7kBBwvCAQsLZQAMC8EAjQuuAYcLhweHCzIFBAADAAUA9wAFAIQCBwDoAgcAtwQHAMkEBwB1B5IAkwCIAK4DBAD7A4YA5wcFC6cChQrNAwUAHQEJAEMADQDZAY8AUgAHC0gBiQtGAZcACAAGCocAhwqYBIcLaASGAB0FhwsEB4cKOgEECz4CBwteAQcLAAQIC1IBCQulAgoLKAOLC/wBBwsyAxELDgARCy0AEgtLAJQLEgCSCgQAhws5BAQAHQAGABQCBwBcBgcAcAYJAF4BCgCxAQsAYQALAC0CCwDpAgwAIQEMAE8BDABcAQwAXgINAHQADQDpAA0A0gEOALUADgDRAA4A6AAOAOwADgAsARAAKQCUAGEABwA+AQYKGQEIChoBCArgAQgK8wEJCsYACgqPAAoKqQAKCtMACgqhAQoKPgILCpMACwqLAQwKSwAMCpcBDApgAg0K9AGOCvsAhwuMBocL9QeHAJwGBQD1AQcAqAYJACkCCwAIAgwALQKNAPkABgD3BQ4ARAEPADcADwBQAA4LRAEPCzcAjwtQAIcK8AYIANwDiQspAYQKowGOAN8AiwvqAAcAYwQMAPwBDgBmAA4A4gCQADkABAqKAAcK9AMHCgAFiQpMAAcA5AYFCh0AjAp+AoYA3weGAD8Gigs4AAYLMgEHC3QEBws8BQgLhQCKC8EBiwvzAwYKrgaHCvYHBwvjBowLNgEGAIEABAoRAAUKFwAHCuMDCwp/AQsKtQEMCswBjAoUAgULSQGICwQBhQpeA4QAFgIGACsDhwByAoQLkQIEABkABQA8AAYA+AEHAGYCBwCDBAwAAACYCwcABwDgBAsAbQKLAL4CiQBBAQgKRgAMCqsAjQoQAQoK6QCLCkwABAB7AQcAdQWGCroBBQtCAAcLaAeICyABhgtrBoYKrQYECxUABQtbAAULOgIFC4gCBQvuAgULDQMGCzYABgtwAAYLkgEGC8QGBws7AQcL7QIHC0MFBwtsBwkLTgAJC/wBCgtjAgsL/gELC9gCDQskAA4LJwAQC1MAEQt8AJQLHgAEAHYABgASAQYAaQEHAEsAjQC5AQoLQgEKC88CiwuXAZMKdwAMCyUCDgtDAJMLPAALCkUADAppAAwKdQANCtUADgoNAA4KPgAOCrEADgqlAQ8KEwCSCo0ACQBJA4kKNQEHCmACBwrQAwgLfQAIC3EBCAsMAgkKkgAKCs4ACgvmAQoKVAILCw0ACwt9AQsL4AILC/4CCwtNAw0LcgANCtoADQskAQ4LLwCOCpkADAC1AocL9wIFADoBBgDdAAcAowEKAIoCCwCMAQwAnAANAHEBDgBNAZEALwAGC5QGBgvDBgcLZAEHC4wHCAs2AAgL3QAJC+EACQtkAQoLTQAKC74BCgvbAgwLlAGNC+sBhAt3AQQKBgKHCnAEBACRAwQLmwELC4MCjAtzAAQLUACFCywACAqxAokKXwOKAHADBAoSAAcKkQAHCrwBBwr+BAgKMQAICpABCQpHAAkK+gAKCssBDAqgAJAKGACIANsBBQD4AwULKwGHCzsEBwBaAggAswAKAA0DjAB+AAYASQGKAG8AhwBIBwQL2wAHC+EGiQtWAAYAYAcGAGQHBgBtBwYAcAcJALkDCQDZAwkA3wMJAOkDDAAyAwwATgMMAE8DDABdAwwAXgMMAGkDDABrAwwAbQMMAG8DDABxAwwAdAMMAIcDDACTAwwAngMMAKsDDwC2AA8A2wAPAP8AEgC/ABIA0QASANMAlQApAAULSAGHC5YDiQAMAwwAUgCPACQAhQryAwUANQOGAJcGhQsCAoQAvAOGAJwECgBwAAUKVwAHCjkBBwpPBAoKRgILCoUBCwotAwwKgQENCh4BDgp8AJIKbAAFAEcABwB/BQkAwAIKAAUBCgBrAgsAIwILAGsCjwCdAAQAEwIFAMcBBQstAQYLOwIOCzEAkgtmAIQKCwEGAIEBBwDYBwkAUQGKAAUChQvWAoULbAEEC0wABwsOBgkLMgEJC64BCQuXAgoLqwILC6sBCwvxAgwLTgEMC7oBDgsCAQ4LbgGPC4MABgBJBwYAVwcGAFkHBgBmBwYAdAcJAJMDCQCeAwkArAMJAK8DCQDGAwkA1AMJAN0DCQDtAwkA8gMMAC0DDAAxAwwASAMMAEsDDABXAwwAYAMMAGcDDABoAwwAgwMMAIkDDACcAw8AqwAPALUADwDgAA8A6wAPAPsAkgC4AIkLNAAFABAABgBWAAYAWwIHACQBBwAxAggAAQEIAH4BCQDRAgkACgMLAEUCjADSAQQA5gEFAOsBhwphBAQASAAGAAkBhwAUBYcLnwQKCvkAiwrRAIQKMQKJCwcCBAuQAgQK+AKHCwsDCQqaAIwK5QGHCwEHhwuQAIgK/wCFAG0CBApwAYcKgQKHC10FBwsqAgcLXQKNCwoAiQDqAAUALwMGAJgGhgDbBgULRgMFC0kDhgtxBgcAwwcHAPgHiADnAoUL9AMGAMUAiADNAAYAOgGGCzoBkAs1AAYL+wAHC20BBwtNBQcL2QUIC5oAjQsZAYULVAEGAMQBBwA4AYoA2wCKAE0CBABNAQkAsAAMAGEBjQC7AAkKXACTClsAhgBWBAsALwCLC+8BBgoNAggKJgMJCmwDjAocAQgLBQEJC5AACQvSAQoLcgEMC9YBDQuQAI4LXAGJC4EDCABfAwgAYAMIAGQDCAB0AwoAYgMKAGQDCgBpAwoAjwMKAJADCgCwAwwA1wIGC/gACQsiAgoLFwILC6kCjQuHAAYALAGHAOsFhgDVBIsKvgOFClICjAv6AIYAlQaGCzcCBwCHAAgABwAIAD4ACQDzAAoAkgIKALkCCwDIAYsA9AIJAIsBigBPAAYKaQaICjQDBAouAYcK5gaGC64AhwohBYcAdwKGCooGhguLAYoAQwMHAJYBBwDLAQgAXgKLANYChgtpAoYA0wMGCoUBBwqVAAkKjgCKCl4ABQtuA4ULzAMGCggABwpZBwgKWwCIC/8BhQBkAoQLXwEEAHQBBwDiAQgAngAJAFoCCQBnAgoA9QAKAKYCCgDoAgsA+ACLACYDBQBWA4cAxweECx4BhwtYAQcLtgEHC3MCBwvsBQgLKAAJCzgACQsmAQoLHgAKCwMBCwvJA5ILlACHANQFBQsDAQcLngEHC1YDjgtrAIcK0gYGAEEDhgDmA4cKGAAGAO4ChwDLBgQK9wGHCn0GBQqCAAcKIgUJCmICCgrOAgsKWQILCjMDCwqyA4wKGAIKCpUACwoYAY4KUAGEC+IChwqaBwUAwwCHAJUGBwDNBwgA2gKLAO4DlwsRAIULYgMOAM8BDgDWAZYAPQAFAO8CCAAKAQsAQgIECogBhwo9BgUKsQEJCnkCiwp1AocANQMGAMsChgAtBYULdAAGAGQDhAvJAYYAvwMGCuoAigvHAAcAHQQHCp4HCAqoAgsKMQOTClgABwrGBIoKggEFALYDBQDiAwYAXwGGAGQEhgA5BAcAOwYGCgUACwr5AAwKOQEQCkIAkQoaAJQAOwAFCw8CBgu9AIcLWwMFCsMDBgrtBgsLaAALCyoCDws8AI8LfQCHAC8AiQCsAoYLdACGAEYGhgAJAwcA/AMICv0BiAoYA4cARgSEAF4BhQvnAQQLVgAFC5sCBQvxAgYLPAEGC8cBhwuyAwcAFAcNAAMBDQBkAQ4A8gCTAHIAhAqjA4UAxwMEANkBBwBvAggAKAMJAGcDCQB9AwsAJgALAK8BDABwAAwA2QAMAPMADAAyAgwAlwIMAKsCDQCNAA0AxQANAOMADQCWAQ0A5wEOAJwADgDLAA4A4AAOAAABEgA6AJYAAACKAB4BBwqvA4sKZgKHCi0HlgstAIQAHgMEAN4ABwAeAYgAdQIEC08ABwvtBgoLwgELC00CDQtMAQ0L7QEOC7cADgtOAQ4LagEOC3ABDgt4AQ4LewETC1oAEwtnABMLfwCUC1oABQBRAQsAAQILAHkDCwDBAwwAzQENAE8ADwB5AAQKWgAFCiECBwryAgkKugAKCkgACgoOAwsKQQILCmICDApiAQwKagGMClMCjQAyAYgAkgAHAG4GCQpJAQsK/gCNC3wABADRAYcAfwaEAA0ChQuXAgoAKwESAEoACQq7AAsK+AORCiwABwClAAcAlwMECvoBiAoFAgUKJwGHCpAGhQtOA4YAKAQFC3oBBwt6BQcLhgUIC9EBCQseAQoLuQAKCzICCgt7AgsLHwALC4kBDAvIAQ0LOAESC0EAEgtgAJMLWQCEAFQCBwrbAwkKsAIKCgoCCwoUA4wKNgIGAFIABwCKAAcABQIHAM0GCwDuAAQLiAKGCu8GBwDRBAcKvAIHCqwDCAoCAgkKdAAJChcCCgp2AAsKawALCpQACwqaAwwK/gAMCqUBjgruAAQAwgMGACAHCAB+AwwAxAIMANUCDgDDARQAXgAWADsAlgA+AAULsQMGC3gGBgv7BgcLpwAICzgDCQuHAQoLdwGLC7kABQDvAQcAQgMJAN0CiwB6AQQK5wKHC/kEBgC0BAcLbQYIC2ABiQv5AIsKJAGFAC8ChAuYAAkA8wEKAFUBDwCQABMAMQAHCgMFCQrjAAsKRQELCpgBDgq0AJIKLwAGABUABgDJBgcApAWIAOAAhQvuAwcApgUJAGEAEQAPAAUKUQAHCpIABwo+BQgKNQAICjECCAq2AggK8gIJCnMACQp+AwoKzgEKCi0DCwrmAAsKkQILCrsCCwrsAgwKdwAMCsgADAobAY4KEQEFCpgBiQrrAocLrwGHC0ADBgDZAoYAuQMEANcCCAA1AgULXwEHCwgBiAs1AoYAnAcFAAcCBQsoAAcLVgIHC2YGCAtOAAkLpgAJC4ACCQutAgkLBQMLC9cADQtBAA4LrAAOCz0BkQsGAAgLPAAJC1cBiwsBA4kLxwGGAKkEjAAWAwcLnwcIC/0CCAsEA4wLnwIHC2wACAvbAAgLhAEJC38CCQsHAwsLEwGMC9ABhAvUAQcKHgAIClYACAo7AQgKvAIJCkACCQpaAwsKNgELCngDCwqIAwwKaQGNCvgABQsPAAYLOAAHC94GCAv0AQkL2gILC0sBDQuWAI4LGgEEAJIBBwACAAgAQwGIAN8BigpHAwsARAKOAMkABQA7AIcAoAKJCmkCkgAiAIYLXgcEAMEDiACAAwYABQUFC80ABgu2AYkLxwKGCqwBBwoMAggKqQAICuoACQrgAYoKhgKUAC4AjQDfAYULFgIGAOMHhgpwBgQAVQAHACUCBwq1BIoKfQIEAJcCBQBeAAcL6wAHC8MFDwtEAJILeAAGC7sBCQvtAAkLOwIJC7cCCguLAAsLywIMC6EBjQulAYQADwMEAKoCCABBAAkKJwAKCqYACwqWAwwKewIUCgoAFgobABYKKwCWCjQABgALAIcAuwCEAAoCBAA0AIcAlQIEAH8BhQAIAocLIgILAFcBjgB/AAQLQgIHCp0ABwtwAgcLlAMIChcBCgsAAQsLVwCLC78ChgpcAgQAGQEFACYABwDCAAcAnAIHAGUHiQCNAQcKsQMLCskCiwroAosK/gMJAHsCiwAvAgULmwMHC+oBDAspAg0LZAAOC3YAjwtLAIQAzwOECjcCiQpbAwcKNgcHCzYHCAp0AogLdAKUAHQAigvuAg4AMwAOCzMADwsHAJQLFACEAFoDhgAzBAQLnAOFCvoCiAAXAoUAwAEKChADjQq/AIUKKgEHAGIChwDdBQcKeQIHCokDBwqNAwcKAgYJCv8CjAp8AgQLCQEHCycDhwu2AwULXQAMCwsBkAsaAIgAvwCLCi0BhwqyB4cACwEEAD8BBQC7AooAoQIGAFABBwBcAAcAtgAIAMUBCAAoAgkAzAAJAB0BCgBjAAsAOAILALYDDABeABAAFAAQAEYAEwA3AAwKhAKQCloABgAnAgcAHAUHCk0DBwviAwgKoACJCj4BEwsBABMLGgCWCwkABwB+BQkA2gCNAN4ABQAAAYoARQAFC+kABQtAAQYLjAAHC0oBiAsnAQYAvAeIALgDBABBA4kLpgKFC9IDBAuJAwYLpQaJC0sDigrfAogKTAARACcAlAAkABIAUQCSC1EADgBgAREANQASAJIAEgCYABMACwCWADYAhwB6AooKSQOEAGoCBABTAQcAAwERAEkABAsTAYwLeAGEC/0BBwsRAYsLeQEEAPcCDQCpAIkKJAMGCmAAhwqSBQQKiwKFCiEBBwAzBAgKIwAJCv8BCgr/ApMKdgAGAIkCBgCeAogA4gEFAFABBgBVAQYA3gEGAOMGiACCAQULIgMHC+UHCAslAw4LXgAPC0EAEAsEABALTQAQC1AAkQsFAAYACwQFC6cABQuDAwYLmgGJCwkDhgupBgUAnAOFAMkDhArAAocASQCHCwoAhwo2BAULCwAGC3UABgvlAQcLbQQJC0YCCQtSAgsLFQALCzIDDAsXAo0LVgCHALMHBAsIAQcLKwQIC8wACAuBAYsLuQMGALIFhwBABQUAjAGGAPUBBArQAoUKMgEEAKEDBQAfAwgALgAIAOQChQqvAQcLhgIHC8IGCwu+AY0LsgAHABQBBQrQAQYK7AAHCrgCBwqSAwcKVAQHCqgFCQoPAAkKNAIKCg4ADAo1Ag0KwQEOCjUADwoNABAKQACRCikABAB8A4UAAgMGCucGDArCAJEKawCHAJ4ABQpIA4oLYAKGAJgFigv6AAgLGgMJC5ABCgsqAY4L5ACXABkABwtrBIcLvAWHANEHCQqCAgsK7ACOCsEABApEAAUKegIGCoIBBwoaAwgKEQEJCjMCCgppAAoKqwALCl4AiwpiAYgL1AKEAN4BCwsAAg0LzQATCx4AFgskAJcLEwAHALUFjABbAAYLvgAHCwADhwuSBAQAWgIIANMABApfAAcKoAGLCj4DBwrbAg0KFACPCgsABgAsBIcAUAcEAA0ABQA3AgcA2gUJAHwACwAJAgwAlQGHC/8DhwDuA4QA3wKKACwDBACqAIcAQwEGC4kACQtLAAkL/QAKC8IAigu8AQUAMAEHAHsFBQpgAwoKiAILCp8CjwouAIcLnASFCqADBACUAIUA5gILCtoDjAqqAoUACwKHC88GBwDaAhIAkAATAD0ACAosAAkKdAMKCkQCCwqPAQsKfgOPCnoABQv4AgcLHgIIC4cAiAvwAYgA1QOFAG8ACgCEAAsAvwALAGYBiwDMAQcLPwEHC2MBBwv7AgoLhQGRCysAhgB6A4YAjAWICy0ChQoGAoUAvAGHAPsGhwo8BwgAewAPAAYAkAAHAAYA+QcKCyYAiwsQA4gApAMFAKkDhwBkAAYA4wMECzoABQseAQYLPwEHC5IBBwvmBAcLbwcIC2QBjAuYAQQLhQEJC7UACQv/AAoLCAAKCx0ACgswAwsLNwELCzECDAtDAI0LtQCKAP8ABQCKAAQKpgOICmICBADFAwoAXwOKAIIDCgokA4oKQAMMAHcCCApgAAkKJAAKCl8CCwqnAQsKugEMCjUBDgrHAA8KWgCRCm4AhgByBQQAjAIIAEABFgAGABYAEAAJCg0ACQqOAQkK1wIKCksACgq4AAoK5gAKCjQCCgo5AgsKzQMMCkYADAq9AA0KOQCNCgEBBgCBA4YANQUEALQChQBBAYULdQGHAJoDBQBrAoUAugKJCncCBQpZAYcK+AMJAL0DCQD6AwwAPAMMAEwDDACBAwwAhQMMAK8DDwC0ABIAxQASAMgAEgDVABIA1gCSAOIABQCVA4YAewaHAEwEhgCVBIYAigcFAPsABQC8AwgADAEJANYAkgCOAIUKoQKJClIDBAofAYUK+gOEC6ACBQBaAQUAxwIIAIYBCwvwAosLdQMFCiIACgrUAgwKvAENCmIBEgogABcKGAAXCh8AmAoFAAQLxgKGC14ChgDoAoYKfgGFC5EABApJAQcLdAOMC3wABAvTAQULlQGGCyACCQpOA4oKOwOFAHACCQt0AQ8LAgATCwoAkwsSAAQLgwGHCwgFBQAPAwcAzgeHAP8HhAqKA4gKbgGHCyYCBAp7AAQKiQIFCl0CBwrlBYgKJACGAGUEhABSAoUK/wKHC8sEiAvTAQQLQAKHC+8EBAAMAQcA/gWHC/4FBAoRAQUKkgIFC5cDBQrjA4YLiQaFADMChgpIAIcKQQUEC1IABQtNAQULiAMGC88ABwtFAQcLvgYIC2UACgsKA4sL3AAFACUABgAnAAYAwwEHANoABwCbAgcAjgQHAJcGCACWAhAAAgCFCk0ChgA0BYULhwOGAPwBBQp1AAYKAgIGCh0CBwqMBAcKnAUICtwACAqIAgoKsAILCjACjAuTAAYLKwKHC+UBhQquAgcAxQEHAHsCBwAcAwgASwEJAEoBCQBhAwoAdwAKAOsACwBvAAsAgQALAPAADAAfAAwAQgAMAN4ADAANAQwAVwIMAKwCDACxAgwAswKOAFkBhwAqBwQLwQIHC2cCigv7AIgLWQGJAA8CBgBiAAcAvgKHAN8DCwBAAg4ASgAHCsQACgr9AgsKWwELCigCCwoWAwwKBwENCvYADQoOAQ0KiwEOCrAADgq+AA4KjgEOCpwBDwogAA8KPwAQClgAkwppAIYLWgANAFQAjQB6AAYAJQAHACsBBwCCBggAwwAIADwBCQCyAAkAFAEJAFMBCQAYAgoAZgAKAGoBCgARAwsANwALAJUACwAFAw0AoAENAKMBDgAmAA4AKQCOANIABQp9AYcKAAcHCy0DDAvxAY0LOAAHCmgCigqdAYUAhQIGC30Ahwv9BIQAIgEGAEYABwAMBQoA+gKLACABBgp4AAcKpAQHCq4GCAoeAQkKmwILClACiwraAocL+AYHACMFhwsjBYYAoweHCnoEBwCDAAcApgEIANIAjAA9AgQKYAGHCq8CiwAdA48AJgAOALMADwCXAJYACwAHAOgBBArAAAUKMQAGCsgABgolAYYKoAaEAKgDhwu/AgYLoAAHC1IECQsCAwoLagILC3AAjAudAQUAxQGGALkBhwBTAoQKigKECpMABgDfAwYAngQMCw8BkQttAIUKpgOMC90AhACNAgcA+QGHAAsChgCHA4cL3wEHCzABCQuGAgkLXgMKCwYBCwu4AgwL0AAPC08AkwtsAJIAUACHC9UDjgCwAYQAOgGJC5gABwBYBQgA6AAIAGkBCgCqAooA5gKHCzIGCQAWAgQLsgELC5cCDAvSAA0LpgANCzYBDgt1AZMLKwAHC0MEhwvlBgYLJgKHC4wCiQAbAI4ADAAECn0CBQspAgcL/gKKCzgDBwvhAggLKgGIC8QBBwDgAosACAGGAHkGhQskAYoLhwAGAEwDhgBdBIcAfwAJCmMDigpFAwYAoASGALgEhgAOBYgAbAEGAIcFBwA2BQsAfQAGCqoABwuJAQgKiwEICucBCgtbAgsLzgCNCpMAiQvsAgQLkAOJC+gABAoXAogKagKJABgDBwu1B4gLzAKHC2IABQCNAwkAUQOKACUDBAB2AoQAuwIFC90CDgtnAJYKFwAMC54AEgsIABMLPgAUCwYAFgsEABcLAgCXCwkAhADIA4QKCgOECi4ABQorAwYKjwYGCrIGhwrwBwYApgUHCrIFCQqXAYsKDwAHAM4ABwCNAQcAbQIHAIACCAB8AAgAawIJADEBCQCDAgoACAEKAHQCCwAoAAwAXQENAIYADQAnAQ4AmwAPAHgAEgBpAAYKIgAHCkEECArEAggK0QIJCmsBlApiAAQABgEFAIEChwBWAYkLSAAEAGMABgD6AAYAWgEIAH8AigBRAIQAkwMFAEsACQAFAgoA1gEMAJsAjQDgAIQKzgELC1gCCwueAo0L9QCOAFMABQpJAAYKFwCGClIBBgAHBIsLmwMHC6QABwsjBgkLawCMC+EAhgC+BYUAugMGADABCACiAQoAWQELAFUBiwCjAgkAmgGLAKkBBAsbAAUL5AEFC/4BBguyAQcL6AMHC0oECAsCAIgLyACGAN4CjAsBAQcK1QIICvIBiwoMAYYAHgeHAAYHhwoFA4QLzAEEC6QDhQt7A4YADgCECkcCBwq2BQgLcQKLCpMCBQBxAAYA8wAGAKwGBwBJBwsAoQAQACUAEQBjAIUK3ACGC0wABQvNAYcLhQeMAEUACAtcAIkL3QCLCiMDhAogAgQAEgGGAJoDhAAdAgUAcwIGCrUBBgo0AgsKtQCNCrcAhwqoBAcApgCEC/sChQv9AIYAUQMJC0kACgtuAA4LuQCRC3cABQvUAAwLIwCNC34BhQDNAokAMAGIAFgChQCOAgYAEQEKALwADQB5AZIATQAEChYDBQoRAYYKigGEAB8ChwCaAQsAYgALAAwCjQBXAIQArQOHC5cEBAD6AAcATAYLALoADACFAAYKfwAHCucFCAplAgwK7wEMCkoCDAqUAgwKnAIOCoEBDwp2ABEKFACSCmIABgD5BoULMAOGADsFBwDBAwcAPQQHAL8GCADOAQYK5gCHC78GCQB8AocKogeEAAwDBQtlAwULyAMGC1oGCAveAogLEAMECx4CBgu0BgYLvwYHCzoEBwsJBggLOAAIC3YACAucAQgLNAIJC3gDCQuMAwoLMgAKC6cBCwutAgsLuQILC6UDDAsrAQ0LfgANC4gADQuqAI0LvgCGC+IABAvoAAkLygAKC9oBjAuxAYkL9AEFABECiApEAIQKjgIECpwABwrmAwcKFQQHCkQHCQowAAkKtAILCqMBiwpaAgcA/AQIANoBCQCMAgYLbAAHC+sDBwudBIgLVwEHC/AEBwuOBgsLsQMMC1UBDAvXAYwLOQKGC7AGBQC0AwwA1AETAGAAlAAYAAQLhQAHC8cCBwsSBQcLMQaHC4kHBgDxAowAkQKLAK0DBgtjAAcLEAeRCzkABgs+AgcLrAEHC+IECgudAgsL5QELC0gDDAssAY4L+gAEABQCBQDCAocAlgIFAEUDBgBzBosA2QMHAEUHCQrFAAoKLAEMCtkBDQpaAI0KlQGJC/wABgtDAYcLHAYEAEoBBABfAwcApQMHANwHCAAkAQcLzQEICwcDiguzAYQKXgIEC48CBwtSAxELSwCSC4kAhwD/AgcKugeICqQChACBAocLFwaGANEEiQDyABEAcgAECmkBhQo7AYkAcwOECs0BigASAYYA2AeGAAIHBAC/AocAzwAMAB0BhArYAYQAOwIFAGkDBQDAAwgANwMJAHEDiAtBAgcAaQIKAPIBCwD1AQwAEACMAJYAigrrAoQArwGFCpsACwAbAQsANwIHCqMACAo/AQkKkgEKChgACgqpAgsKyAAMCv0ADAqaAY4K2wAEC50BBQulAggLsAGMCxgBCQCRAQUK2wEHCvQGCwopAQsKLgIOCkIBkwpMAAYADQMJAIYACgACAAoAGwAKAE0BCwDSAo8AAQAFACEABgDWAYsAqAGHANYHDAAPA4cKpAeIABIBhwBaB4QAGgOHADgHBQqwA4YK6QYGAC8ABwBaAAcAmAIHAD4DBwBkBQcA6QcIAMABiAA8A4QKkACGAK8EBAuLAYsL+gKHC+AFCQChAYkA7QEJC64ACgukAAsLuAELC0kDjwtiAIYLqgGLC+oDhgAnAYYAMAMGCvcAiQorAoUA+wMEAGwCBQvcAQoKGAGKCh0DiwDQAQULTAAGC8oBBgvxAQcL/AIHC2QDCQuSAgoLUgILC60ACws2AgwLFAAMC1IBjQvIAIYA0AAECw4CBwsFBIcLHgSEC3wCBgvpAAcLlAIHC2QEEQsfABMLFgCXCw4ACgC6AYUKrAEKAKIDjAAKAwYARAAHAMABBwBdBgcA6QYHABUHCAC6AQgABAIJAMYCCgAaAQoA0gIHCrUGigoiAoYAaAQLAEwDDABoAIwAcQIEC7ABhws4A4oKvQCFABMDhQpjAAQLFwEHCy0BiQtqAQgA6wEECo0BiAorAgQLsgCFC48BhgDHApAACQAEAJMBBQC5AQcAwgEKAEgDCwBlAAwAwQCNAK4BhwveBAwKjgEUCicAFQoLAJYKKQAECuUBBwphAYcK8wUGCm4BBwpoBQcKQQaHC3gHBwCMAQoAoACHC4wBiQoaAYYLnAYECp0ABQrXAQYLygAKC8ABCwvQAAwLaAERC3UAEQt2ABILGwCUC0MAhQCnAokARgGICnQABwtoAwoLBAKLC6cAhAvgAAULIgIHCyMACAsLAAgLDAAJCzsBCQsVAgoLIgMLC6YADAsNAo4L8wAHAGgEhwuABwUL8QAIC/IACQvDAQoLmwILC1YCjAutAQYA4QIFCqAABwprAQcKTQIKCqoAjQo3AIcABAeOC/4ABAA+AgcAXgEHAAAECABSAQkApQKKACgDhgBIBIkLBAIHAJUBCgDrAQQKbAAEC24BiwryAQsLUQGOCy8BhgvIBgcAOQSMC2wBBwrtA4wKYQIHAIwGBAp/A4UKBAOHAPUHBgC3BAsLlAOOC6MBDguMAJQLKQAGC0sBiAtvAgkAsAMJAMkDCQD+AwwAkQMMAKgDDwCxAA8AwQAECp4DhQrXAwUAYgGHC/oBCABWAgkAmAKKALkBBAuAAoULAQKJACkBhAoaAgYKJgEHCvMEiApwAgcA7AYHC2AHCAshAQsLLQAMCxYBjAsZAocKLQWKAO8CjQAlAIYAJAeECvUChAuKAQYAAQGHAPIFBABGAgkAvwCHC4sHBws+AgcLtwaJC5EAhAuSAgoAFgOEC3EBCQsNAwoLkAALC4EBDQuhAA0L5AANCwwBlAtrAAgA1QEKAC8AiAt2AQYAMgEHAHQEBwA8BQgAhQCKAMEBiwDzAwcKUweLCnwABAtYAQYL8gGLC0MBiQArAYQARQOFC4oDBQBJAQgABAGKAAoAhgAoBQQAkQKSAJ4AhwCnBJgABwAGAJMHCADOA4oA5AOHAIEGCwt+AIsLHwGPAAgADguVAA4LjwGPCzkABQBCAAcAaAeIACABBwCvAAoA7gEFCpYACApbAgkKUQIJCnoCCgqtAAsKzgELCgMCDQrYAA0KIAGOCpABhgBrBogLFQAEABUABQBbAAUAiAIFAO4CBQANAwYANgAGAHAABgCSAQYAxAYHADsBBwDtAgcAkwUHAGwHCQBOAAkA/AEKAGMCCgArAwsA/gELANgCDQAkAA4AJwAQAFMAEQB8AJQAHgAEAJwCiAA6AgoAQgEKAM8CiwCXAYcLZQWIC8EADApsAI0KIwGEC2gCiAu0AggAfQAIAHEBCAAMAgoA5gELAA0ACwB9AQsA4AILAP4CCwBNAw0AcgANACQBjgAvAIYA3wQGAJQGBgDDBgcAZAEIADYACADdAAkA4QAJAGQBCgBNAAoAvgEKANsCDACUAY0A6wGHCvEGBAsxAQQK7QGQCjcABAC3AwYAEQcGADkHCABOAwgAYgMIAIMDCgCAAwwAtgKOANQBBQvWAAcLWwIIC2MCCQuuAgoLWAALC8sBCwvwAQwLzwEMC04CDQsAAI4L1gCEAJsBBABQAIUALACMC0oAjwAfAAcAnQIGCjgCBwoMBwgKagEICpoBCAo+AwkKAgILCokCjgqdAAcAoQKGC6cGhApxAoYAFwUFACsBhwA7BIoAwAIGABMBBwCYAQYKngAHCoEABwq1AAgKFAEICnkBCgoLAgsKMAMMCscBDQovAY4KhwAEANsABwBvAQcAsQYHAOEGCQBWAAkAGQIKAKUADADbAIwAMQIIANgABAoBAAQL4QIGCz0BBwp3BAcKtwUJCs8ACQqGAQkK0wEKC2IACwsmAQsKRAMMCzwADAu1AQ0LQAANC3wBjguuAQYL3gYICwgCCQtZAQkLkwGOC14BBQsvAAoL8gCKC0MCBQuLAAcLkASKCxsChwAnBQQKJwEECtMCBQp/AwcKBwQICscACApUAQkKmQAJCtcACgoVAAoKOwAKClAACgrgAAoKRgMLCuUACwqMAgwKwAANCpIAjgpbAIwArAGJCjMAhQACAgUKNQGMCtMABgDyAwUKfQAICk0AigoPAAQANwAFAC0BBgA7Ao4AMQCSAGYAiAtyAQQLawAHC2UCCAtmAQgLtwEIC/gBCQv1AQoLfwGLC90BhAvlAIUAbAGFCrcBBAuHA4cLGAcLAHsBjApMAAQATAAEAMsDBwAOBgkAMgEJAK4BCQCXAgoAqwIKAJkDCwCrAQsA8QIMAE4BDAC6AQ4AAgEOAG4BjwCDAIkANAAECy8ABgt1AQcLxAEHCx8CBwuyBgcLQAcJCwYACwsBAYsLhwEECggABwqABAcKgQQHCrMGCQp2AQoK3gGLCogCBAsRA4ULcAGHCksEhwtcAwUL1AOGC9oGhgDqBAYAIgQGAE8FBwsYAgcLMwWIC48ABACQAocACwOIClcABQsTAAYLFQKSC34ABwCQAIoKtgEFC4sBBQu3A4YL8AaHAF0FBwAqAgcAXQKNAAoABApFAAUKegAJCpACigrQAQUKUQOGCmEGBQBGAwUASQOGAHEGhQD0A4sK8wEHCtwBBwo4BooKVwAGAPsABwBtAQcATQUHANkFCACaAI0AGQGEC7kBhAu3AgcL8QEJC4MBkwtRAIUAVAEOChsBjgsbAYYAKgOHC2YHiwDvAQULHAEGCzEABgteAQcLAQAHC3kBBwudBggLEgAIC6YCCQuhAAkLSQIJC58CCQtHAwsLkAONC6sBBQpbAwcKiAQICmsACQojAQkKtwEKCpcCCwphAowKxQAIAAUBCQCQAAkA0gEKAHIBDADWAQ0AkACOAFwBiQCBAwYA+AAJACICCgAXAgsAqQKNAIcABABmAYcA2AWGADcCiAC9AQQKdQAGCnQBBwpxB44KQwEECtICiwrXAQYAuQKGAOQDBwvXBwkLZQAJC8IBCgtCAAoLSgMLCxgCjAtLAoQAQQKGADgFCQoFAAwK2AAMCiYBDAoqAQwKkAEMCgYCDQrlAI8KiwAGAK4AigCVA4YK7gYFCgwABwp3AQkKWAAJCrYBCws+AIsKDgGGC+YGBgsAAAcLVAAHCjADBwrZBAkKGwEJCggCCgrVAAoKMwEKCs8BCgqfAgoK6gILCpEBCwoaAwsLfwMMCgUCEQsLABIKawCTCnMABQBuA4UAzAMGC4EGBwsAAQcLbAWKC/MBBAoCAYgKfwIECxYABQsKAAYKFgAHC1ADBwqHAwcKqwcIC2EAigpBAgUKqQKICg4DhQvhAYQAXwEECpgCBQokA4sK9QMGC4YABwu1AQcLvwMJCyUADgsdAQ4LcwGQCzwABwvmAQgLmwALC10AjAukAIQAHgEHALYBBwBzAgcA7AUIACgACQA4AAkAJgEKAB4ACwDJAwsA4wOSAJQABQtPAocLUQGGAJ4HhQogAIoL9AEFC3wBBQuKAogLNgEEC2wBBwuEBAcLowSJC5kBBADiAoYL4gEECw0DBgvnAQcLngMICwcBiwv0AYcLogEGAP8HCgDJAwQKIQEHCnUCBwqiBgcKrwaMCtcABgrCAYgKbQCGADIDiArBAoUAYgMEC14AhwvxBIQLoQGGALsFhwrWBAQAzAMGADsHhgBBB4YAYwGFAHQAhADJAYcLgwUEC5gBBAvlAocL9AGGChoAjguJAAUADwIGAL0ABwBbA4gACwELAGgACwAqAg8APACPAH0AhgBNBgQKngEFCtMBCQqOAgoKwwEMCjsAjQp3AYcKEQCGAHQAhwsdAocKuwMGC0kAhwuxAIULQAKGAHYDhQDnAQQAVgAFAJsCBQDxAgYAPAEGAMcBhwCyA44L5wCWAC0AhgBfA4YAoQcGChgBCgr2AQsKWAGMCiYABABPAAcA7QYKAMIBCwBNAg0ATAENAO0BDgC3AA4ATgEOAGoBDgBwAQ4AeAEOAHsBEwBaABMAZwATAH8AlABaAAUKLQAHCokECwrAAQsKcAMNCosADQqXAQ8KEAARCl8AEgpCABIKWAASCnsAlQoHAIgKCQMECpoBhwoJAocK8gaHCxoCjgB9AYULnQGGAHYEBgClBIgL7wEFAJcCBgCqB4YA0wcHCzYACAs4AQoLvwAKC2YCjAs3AoQKtAGFAE4DCgAQAgsA+AEHCjMGhwqrBgUAegEIANEBCQAeAQoAuQAKADICCgB7AgsAHwALAIkBDQA4ARIAQQASAGAAkwBZAAcAgwMOAEUBBgvUAQcLNwIHC8YFCAsSAo4LIgEHAFgHCQCoAosAHgOGAOoGhACIApYLIwAFALEDBgB4BgYA+wYHAKcACAA4AwkAhwEKAHcBiwC5AAYL5AGHCzYDhgD+BwcAbQYIAGABiQD5AIQAmAAGAGMChwDFBgYLvAaHC+YHhQDuA40LYAAFAKQBhwCpBZILlQCHAEADhwqXAoUAXwEFACgABwBWAgcAZgYIAE4ACQCmAAkAgAIJAK0CCQAFAwsA1wANAEEADgCsAA4APQGRAAYACAA8AAkAVwGLAAEDhgBKBYQA1AKJAOkChAvaAQcAnwcIAP0CCAAEA4wAnwIHAGwACADbAAgAhAEJAAcDCwATAYwA0AGJAH8Chwr3AYULbgEFAA8ABgA4AAcA3gYIAPQBCQDaAgsASwENAJYADgAaAQULMQEJCzACjQvQAAQKcQAFCqMABQrfAgcK8QMJCgkACQoDAwwKWgANCooADQqaAY8KgAAECkQBigpoAIcL0gGOCxsAhgBeBwUAzQAGALYBCQDHAgQL4AEGC6cABgsuAQYLagYHC4IABwuQAgcLRQMHCwsGBwt5BggLrQEJC+QACguDAg0LIQENC1cBkwtlAIYAYQMGAOkHiADFAwcLFgEKC+MCCwvEAo0LXAGFABYChwuCB4kAswIECqcDhQo3AwYAuwEJAO0ACQA7AgkAtwIKAIsACwDLAgwAoQGNAKUBBQoNAQcKsgEHCnsDCApTAQkKvgILClICCwrOApEKZAAGABMGBwBuAwkK5QGNCggBhgqxBgcKEgcLCmIDDApnAI0K7wGHCoQDBgCCBQkLPAGLCwABBADjA4cACQSEAEICCgBxAwwA5AIMAOcCjAD3AoQANgOFAJsDjgqPAIcLoAYGC2sBBwujB4gL1QKEAJwDhQCZAocK7QeHAG0HBAAJAQYARAQGAIkFBwAnA4cAtgMFAF0ADAALAY0A8gGHAKsFBQstA4cL/gcFCnEChwpRBocA6wIGABQDiQA8AwcAuAALADMBCwCQAQ8AggAFC8gCBws/BwgKqQEICrUCCQrQAgoKfAEKCn4CCwsRAAsK2QEMCj0ADQtBAZALQwCHAMYABgtAAQcLDQMHC4EHCQs3AAoLugAKCxEBCguYAgoLIQMLC+QDCwvlAw0LnQCOC6oAiAsPAYcA4gMHC2cABwtfAwsLuAAOCysBkQs+AAsKJwKOCp8ABQDpAAUAQAEGAIwACAAnAQgAZwKIC2cChQDSAwQAiQMGAKUGiQBLA4QKqAAEAM4DCABSAwwAxQIMAAADjAASA4cKWwCYAAYAigoUAocKXAeEAP0BBgAbBYcAEQEFC00ABwuvBQoLSwMTC0kAlgsFAIQLygGHC4wFBgttAIoLfgEGAMkABgtKAQcKRgAHCzwECgrwAAsLjgCTCl0ABwARBIwLSAGFC2IBhgAQBIUAtQKGAAYDiwDqAIQAUAEHAHcFiwqIARQAFgCUCxYABQAiAwcA5QeIACUDBQCnAAUAgwMGAJoBiQAJA4kAFQOGAKkGBwqPAocKNAcECpEABgqwAAcKiwGJCjIChAr1AYcACgAFAAsABgB1AAYA5QEHAG0ECQBGAgkAUgIKAFIACwAVAAsAMgMMABcCDQBWABQAWwAXAA0Ahgr9AQQACAEHACsECADMAAgAgQGLALkDiwvhAooAOACGAH0HhQDWAQoLkQIOCykBjgtpAYcLnAEHAK4EBwuuBAgLLAIOC3sADgvAAI8LGwAHC8EHDguSAA8LKgAQCxcAEQtWAJILEQALAPcDiAt6AAQKcgAJCuwBDQrOAY4K1wAECk0ABQppAQYKiwAGCpEBBgqUAQcKnQEHCssCBwq0BgsKFwEMCrMADAoCAQ0K9ACOCmYBhgq1BgcKJQQIClIACwr6AAwKpAGNCrgAhQDLAocK1AIJAJcDCQCaAwkAnwMJAKUDCQDCAwkA6AMJAOoDCQD9AwwAegMMAIsDDACiAw8AzwAPAOQADwDuAJUAPQAIABoDCQCQAQoAKgGOAOQABQuuAQULpAMGC4MABwuhAQkLCgILCzoBjQuGAYQAYwMIANQChAv7AYkLBQEEC1cBhQv/AQYAvgAHAAADhwCSBAYKAQKHChwEBwvHAYoLTwKGACoEiQqDAw4AQwCTADwABAC0AxIArgCSALAAhwD/AwcKiQUMCn4BEQowAJgKDACGCz8ChAD8AgYKIQIHCjUCBwqFBgoKcgALCoICjApqAgYAiQAJAEsACQD9AAoAwgCKALwBBAD0AoUKBQAIAPADhwrAAIQASgMLAIMCDABzAIgK+wKLAEMAhQr3AgQANQMFAPgCBwAeAggAhwAIAPABhwtEAgcKcgEHCu8DBwqZBIcKHQaHCtUEjADgAgcAPwEHAGMBBwD7AgoAhQGRACsACAtNAYoLtgAEClcABQr6AI0KKgGKABIDhgD8BwgLSgGMC90Bhws6BYQLfQCGAAYEhgA7BIQL0QKHCi4DBwsIAwgLkQCTCzgAhgDKBAQKOQAHCqsEBwqeBQcKDAYHCisHBwpwBwkK9QIKClwCiwoHAgcLGAMIC5MACgs1A4sL/QOJCx0DBAA6AAUAHgEGAD8BBwCSAQcA5gQHAG8HCABkAYwAmAEEAIUBBAAvAwkAtQAJAP8ACgAIAAoAHQAKADADCwA3AQsAMQIMAEMAjQC1AAcLwAWHCxIGBwsvBAcLBQYHC+cGBwsOBwcLzwcJC/gACguQAQsLogALC7IACwvyAAwLXQIPCxoAkAssAAULqAAFC6IDCAtKAAkLbwIMC/QBDAtDAg0LKQCPC10ABgvcAAcLTQSNC2kABQDaAQcA+wEECtEABwv7AYcKhgOEAKsBBgCdAQcKTwEHCp0FBwqEBggKKQIICowCCAqQAgkKLgILCucClQoSAIQA2gIGCxMABwuFBYsLrAGFAHUBhAovAgcLYAAIC5EBiQuAAwcAHwMHALQHBQr5A4oK/wGHAAEHBwupBwcLrQcIC74CiAvuAggLlgAIC+ECjAtuAYQAQgGFCsUCCAsgAwkLlAAJC2gDCQt6AwsLNQELC+kDDQsLAY0LQwGGCtEGBwAiAYgKzgAHAHMGkQBZAIsAAgCEAKACBgBEBwgAiQMKAEwDCgBOAwoAWgMMALsCDADqAowABAOHC6gBhQsjAoUA4QIFC+oBBgtnAgYLbAKHC6sCBgDqAoYATAaECggDCQuBAZULEQCFAJEAhwr4BAcAdAOMAHwABACDAYcACAUFC4UAiAqWAYgLuwAGAKcCCAsIAIoLAACHACYChwseA4gLrQIHCz4EkQsuAAgKrwAKCqgAigo9AocAGQUEAEAChwDvBAYArgKGABsGhgBfAgUAlwOGAIkGlAAlAAgLBgMKC54CjAszAIUKEAOLCnIDBABSAAUATQEFAIgDBgDPAAcARQEHAL4GCABlAAoACgOLANwAhwtzAYQAvgOFAIcDBAt/AAULXgEGC2QBCAuqAQkLPAIKC/cAiws4AYwAkwAGCzsABwt1AwkLWwKNC40BCgBvAQkKDgAJCrkBiwoJAAsKxgMMCh8BDQpWAQ0KkgEPCm4AjwqjAIYAsgKEAMECCQCLAgsAywMNABEBBwqUBQcKaAYHCksHCQqpAAkKtgAJCm8BCQreAQkK+gEJCicCCQotAgkKiAIJCrkCCQrBAgkK1QIJChMDCQoaAwoKxgAKCtYACgoLAQoKEwEKCsgBCgonAgoKMQIKCmUCCgpzAgoKnAIKCqMCCgqzAgoKtwIKCsMCCgrLAgsKtwALCskACwoGAQsKYAELCrcBCwrtAQsKPAILCk8CCwpgAgsKYwILCoYCCwqiAgsKxwILCu8CCwr5AgsKCAMLChEDCwpSAwsKVQMLCl4DCwphAwsKZAMLCmsDCwqCAwsKhgMLCocDCwqOAwsKpAMLCq4DCwq9AwsKxwMLCswDDAqUAAwKwwAMCtwADArtAAwKPgEMClMBDAqJAQwKvQEMCsIBDAraAQwK+QEMCv0BDAoVAgwKTwIMClICDApVAgwKbQIMCnkCDAqCAg0KOwANCjwADQqRAA0K7wANCvoADQpJAQ0KWAENCm0BDQp0AQ0KgwENCpMBDQqeAQ0KyAENCtYBDQreAQ0K4wENCukBDgo3AA4KOQAOClEADgpaAA4KlAAOCu8ADgoKAQ4KQQEOCkYBDgpHAQ4KSgEOClsBDgpjAQ4KkQEOCpQBDgqbAQ4KngEOCqABDgqkAQ8KPQAPCkoADwpXAA8KWAAPCl4ADwpgAA8KdAAPCpUADwqaABAKMgAQCj8AEApJABEKAgARCkIAEQpcABEKZwARCnAAEQp4ABIKMgASCjYAEgpSABIKVgASCloAEgpvABIKcwASCpwAEwooABMKTwAUCk4AlQoWAAcAdwMFCqEAhwpHA44LYgCGAFoAigtkAYcLuQEGC28ABwsEAAgLowAICwgDigs2AoYAjAOGAO0EBwAtAwwA8QGNADgAhgDTBIcArQGHC8oHigCIAwYAfQAHAP0EiQAEA5cADAAEAEkDBQCCAYULggEFCykBhwsOBAYAXAMGAC0Ehws1AYgAsgOHChYHjQuiAYgLawEKAAADiwATAxYLHgCWCyEABgCgAAcAUgQJAAIDCwBwAIwAnQELC9gAiwtUAYgKiwCHC24FhwsoA4QLGAEMAA8BEQBtAAcKgwKICuwAjAs2AAQLpQGFCyQCCwDPAgwAJACNAFEBBwBFAgkAhAKJALsCCwv/AQ0LigEOCyoBDgs+AZILZwAHADABCQCGAgkAXgMLALgCDADQAA8ATwCTAGwABAB3AgcAZgSHAAAGhwv3BQgAcAMKAGUDigCRAwcA6QUFCjYABgv+AAkLbQCKC2cAhwDVA4UL2QKECugChACyAYYAJgIHAKIDCgDcAQ0AxAETAGgABgteBgoKkgGSCjcABQApAooAOAOIAMQBCACXAIkKcAKECjwChAAEA4ULnwKFACQBigCHAIQLeQOMC88ACQD4AQYKKwAHCiYACAr4AIoKAQIGAEEEhwt2BwQLcwKFCwcDhwAPA4UK/gKFCmsBBwCDAYcLgwEHAIkBCgBbAgsAzgAHC8oACwtqAQsLtAOMC4QBBgv7AQcLwwEIC4UBDAvqAQ0LEAANC9cADQtfARILhACTC30ABACQAwkA6ACHC0kDBgoCAYwKmQEFCvkAlApSAIgLNgIGANEDhwu+BAcAtQeIAMwChwBiAIUA3QIFC5ADhgufBgUKiQEGCnoBBwq9BwkKIAAJCk8CCgqtAgoK5QKOCn4BhQoUAwoAEwALAI8DBwqwB40K/QEFAJwCBQvsAAYLPAIIC+wBCwtqApALOACHC/0GBABoAQUAewIFALwCBQo6AAUKqwAFCqsCBgojAQYKNgIHCnIGCwoLAgwKEQEMCi8BDwonAI8KbwCFAIUDhgpNAgULvgCICz4BjACQAgcA1gKYAAkABAqVA4UK7QOHCj4GhgvrAQQKlwOFC7IBiQBIAAYA9QQGAB4GhgBVBgkAzwEKAFMCBAr/AAUKLgEGCoQABwqAAAcKGwEHChMFCgo0AAoKAgILCp0DDQpcAI4KNQGHAK4FhgAHBQsAWAINAPUAiQqtAIgA3QMHAKQABwAjBgkAawCMAOEABgAlBI0KugEEABsABQDkAQUA/gEGALIBBwDoAwcASgSIAAIABwtVAAcL9wAIC0kCCgujAIoLPAELC2cAjgsAAIYAZwQEAMwBhgBUA4YK0gAEAKQDhQB7AwYATAKTC1MACABxAgQKHAGGCt8AhgBMAAgAXACJAN0ABAt8AAoLyQELC3kACwupAAsLpgELC2YDDAvWAA0LhQEOC7sAjwtNAAkLagKKC+IBBAraAAcKDgKPCokADQAJAA4AaAAOADcBBAoOAQUKwAAGCkwBhwoqBYwKlQKHC6kEBgtrAAcLfgIHC2AGiQuMAYQA+wIEAG4CBQtyAYYL3AaFAP0AhwAiAgkASQAKAG4ADgC5ABEAdwCFC8wABwBwAgcAlAMKAAABiwBXAAcKewEICuEBiQp5AQUA1AAMACMADQB+AQULygOGC6oGCQDqAgUK6wOGCpUACgCWAAsAUQMNAEoBCAoGAQkKcwILCtYACwqUAQsKyQELCgwDCwqRAw0KkQGOCsgAhgC6BYcLAwAGABMFBAsjAAULeQAFC+MBBQutAgYL6QEHC7QEiAuKAYcK5gIECo4AiAowAQQLmQOFC+8DhgDuBQYAzQSHAJcEhQAwAwwAnwAECtcBBAvIAgUKMwAGCloCBwqdAwgK5AGKCsMAhgtdBgUAZQMFAMgDBgBaBggA3gKIABADBAAeAgYAtAYGAL8GBwA6BAcACQYIADgACAB2AAgAnAEIADQCCQB4AwkAjAMKADIACgCnAQsArQILALkCCwClAwwAKwENAH4ADQCIAA0AqgANAL4AiAqwAoQKuQIEAOgACQDKAAoA2gGMALEBiADUAAYAbAAHAOsDBwCdBAgAbwCIAFcBBQrdAIcL5wSFC+UBhgCwBo4A2AAFAIMCBgAEAgQLHQEFCz0BBgstAQcLBwAIC5kACgv+AgsL1AEMC9MBjQuPAAQAhQAHAMcCBwASBYcAMQaGAIoChwsAAgYAYwAHABAHkQA5AAYA9gAGAD4CBwCsAQkAGQMKAJ0CCwDlAQsASAMMACwBDgD6AJEANwAECoQABQpFAIcK2gSIAP8DBwAuAYQKbwCHAE8HhADYAgkA/ACECv8CBgDNAQcANgYHCogFBwrVBwgKgwAICtIBCQqgAg0K/ACUCmcABgBDAYcAHAYHAM0BiAAHAwYKLACICnABiwCsAIQA0AEECjoChQp4AIkLDQEGCuMAhwo1BgYLtwYGC8cGBwvgBwcL5AcIC0UDiQtUAwcA1wKSAEkAhAD/A4cLVAOHCvkFiABBAooLOAKGAA0ECAtDAIoLowEEAJ0BBQClAggAsAGMABgBCgBYAgYKgwYHC8cDBwr0B40LCwAGCv8BjAqEAAYAHwMFCjgCBgqKAIcKDQUIAJ8ABAo1AogKOwMHAIYCBwDCBgsAvgGNALIABAqaA4UK/wOHCwsAhACLAQsAkQCHCuoDCQCuAAoApAALALgBCwACAgsASQMPAGIAlQAUAIYAqgEKAGACiwDqAwcLQAEICzMADAvhAQwLOgKUC2oACQDRAwkA1wOEC70BigD6AIsAZAAGAL4HiAqSAYUL7wAECswCjQofAAUA3AEHC1MABwvGBwgLggCLC9ACCAqzAogK2wIFC3sABgsSAgcLXAGHC4sFBQBMAAYAygEGAPEBBwBkAwkAkgIKAFICCwCtAAsANgIMABQADABSAY0AyAAJC4sACguPAQsL1QEMC3oCjQvfAAkKSAOKCiMDhQpPAwsL3wCMC6gAhAvSAAgAvwEJCjUACQoMAQkKhQMKCgYCCgo9AwsKvAANCkoADgouAA8KEQAPCiEAEQooABIKJAATChQAFgoBAJgKAgAEAA4CBwAFBIcAHgQTCzsAlgsCAAQAfAIGAFMHBgCABwkA5wMMACcDDAA5Aw8AswAPAL4AEgC2AIgKFAIGAKMGBwCUAgcAZAQRAB8AEwAWAJcADgCHCqkChAuuAYwKpQIECqwCiAqAAYQL9AKFC9UABwC8AAcKbgAICiIBCApPAgkKfgEJCokCCwpHAAsKmwALCjkBDAoFAA0KRQGOCh8BBwpoAQcKqQEJCkIACQoWAYoKhAKOC6QABAAXAQcALQGJAGoBhgtKAocAzwYEALIAhQCPAQQKhAOFCl0DBQr+AAcK2QOICkkAhQtsAAcKpweICqsChQvbAAQLwQAFC5QDBwtsAQoLjgEKC9YCCws9AQsLcgIMC44ADAsgAQwLpgINCzkBDwtxABILcgAVCx4Algs1AAYL8QAHC4sDCAtAAwkLVgEKC9kCCwscAQsLvQELC4sCCwtfAw0LjgGSC2MAhABoA4YAPwOGAJwGBgDKAAYA7gMJAEADCgB8AgsA0AAMAGgBEQB2ABIAGwAUAEMAiQveAoQK1QIHC+EDiguaAoYAogeGCsQABwBoAwoABAKLAKcAhQo/AwQLMgIJC/4AiwtvA4kAOQEEAOAAhAsSAwsAGAAMAKoAiArTAgUAIgIHACMACAALAAgADAAJADsBCQAVAgoAIgMLAKYADAANAo4A8wAHAJEHDQpQAA0KtQGRCkoABQDxAAgA8gAJAMMBCgCbAgsAVgKMAK0BlgAuAAYA+QSJAD4DBQpQAwYKQgCICvwCBgA5A4YA4QMEAO4DCgBHAQ0ADwEECiQABwprBYsK8wKGAP8DhwAsBgQAbgGJAAQChAp3AwYAyAaHAGMHBgvYAAcLhQMHCz8FiAvtAQYKpQCKCoQBBwtVAYsL2wAECs8ChwqbAIYAjweEADoDBgBLAQYARQYIAG8CCwCLAIsAqwCHC8YGCgtzAAsLpAEMC5oADQuUAQ4LWgEPCzYAjwtwAAcAIAEECmEBBgqSAAYK/QYHCt4DBwpEBQkKmQIJCoIDCwp9A44K1AAGAJQDhgA4BgcAYAcECi0AhwrpBAUL8wOIC70CiwtUAgQLNgAFC5oCBwsPBAcLagQJC8MAigsuAYYAvwWGACIGhACKAYwKQQCICjADhwCLBwcAPgKHALcGhgvTAYQAkgIJAA0DCgCQAAsAgQENAKEADQDkAA0ADAEUAGsAhguFBogAdgGHAN8CBABYAQYA8gGLAEMBBwBKAgcAJwQGCi8ChgqbBokAmwCFAIoDBwt6AAkLAwEKC1QACwvWAQwLHQKNC3sBhgBzBAoAbACLAHQAhgrIAYUKnQMFC1IABQuDAAcL2wYICx8ACQuoAAkL/AKLC2UDhgtdAgULFgGJC0QABAujAAULyQAFCzMBBQs2AQYLTwEHCxwBiAulAIcLfAYGCyEAhwvcBAQAaAKIC+MBCABZAwgAhgMIAI4DCgBvAwwA1gIEC8cAiwsiAIgAtAIGCsEABwrwAAcKkgYKCjMACgqAAgsKmgENClIADgr3AA4KSwGOCnkBBgA3A4YA1wOLCpsBhAAxAYgKeQKKC8sAhgCpAgYLRgEHC6UCiQupAQUA1gAHAFsCCABjAgkArgIKAFgACwDLAQsA8AEMAM8BDABOAo0AAACIAOwDjgAXAIYApwaTCwgAkQs4AIcAowUECu0AhwoCAgYAygKRABMABQtmAQcL2QEHC6AECguWAg0L1AANCzABDQtNAZELYgAEAOECCgBiAAsAJgEMADwADAC1AQ0AQAANAHwBjgCuAQYKiAEHCkEAhwrjBwYA3gYIAAgCCQBZAQkAkwGOAF4BBQAvAAoA8gCKAEMCBQCLAAcAkASKABsChgCzBQ0AhAGNC4QBhgD9AAcK7ASHCv4GCgD8AAkK3gCLCoQDjADpAoULsgMEAGsABwBlAggAtwEIAPgBCQD1AQoAfwGLAN0BhwvNBYQAZwMHC5sBBwtOAggLdwIJC0MBCgtjAQsL6wEMC48ADAuSAQ0LSQAOC5gBDwtrAJILRwCEAOUAhACHA4wARwCFACUCBAAvAAYAdQEHAMQBBwAfAgcAJAcHAEAHCQAGAAsAAQGLAIcBBwu7BQgLSAEKCyACCwu7Aw0LQAGRC1MABQDUA4YA2gaIAGEDBQDBAokAXgIHAKEACArJAIgKXQKPCyMABQtDAwYL4wGMCuAABwAYAgcAMwWIAI8AhgBsBQUA1AIKADEBCwCXAAwAIQAMAHkADAB9AREAAwARABsAEQBOABIAEgATADYAlQAFAAQKCwKFCn4CBQATAIYAFQIFAIsBBQC3A4YA8AaHAHQHhABOAwoASgALAJcCDADSAA0ApgANADYBDgB1ARIAXwATACsABgryAAcK4wAHCi0GCApoAAkKcQAJCtwACQqrAQoK7wALCkMCCwr/Aw0KBAANCswADQo8AZQKVgAJC8wCCwtsAA0LewAOC/wAEwsmABULAwCXCwsACAB0AQkAegCKAK8AhAulAgcLXgWICxwChwpdA4QAtwIHAPEBCQCDAZMAUQCIAKkDhgDOAgcAMAWICu4BhAtLAQYALQaFC+sCBQAcAQYAMQAGAF4BBwABAAcAeQEHAJ0GCAASAAgApgIJAKEACQBJAgkAnwIJAEcDCwCQA40AqwEHChoFCAr5AQkK4gEKCn4ACwrhAAwKWwEMCsEBDQoTAA4K2gCOCrMBCgr8AgwKeAANCicAkQp/AAQAVQKFCgwBhgBGBAQA8AOGALUHhAArA4sAjAOHAL8FhQtGAQQKgAGHCv4DBwCPBwgARAEMACoABAuzAgcLjwcIC0QBCQsjAAoLqAILC2wBDAsqAA0LZQGSCxAAhwDeBwcA1wcJAGUACQDCAQoAQgAKAEoDCwAYAgwASwIGCyAABwuBAQcL9QIHC3wHCAslAAgLXgAIC8cCCQsdAgoLogAKCxsDCwvdAwsL8gMMCw4Ajgs0AYsASgKHCqcGBwA1BAsAHAAJCp8AjApbAgYAxQSICkcCBguYAAYLXQEGC5IGBwvkBAgLcAAJC7MBCQucAgoLIgEKCz8BCgsvAwsLtAALC0UDDAvwAA0LmAANC9sAjgueAIsAPgCECgMCCAp4AggKuQKJClYDhgDmBoQLRQIGC34ABws9AggLjQGOCywAlgAcAAsAngIWABkABAqIAIUKJwIGAIEGBwAAAQcAbAWKAPMBBAAWAAUACgAHACgGiABhAIYK9gYFAOEBBwoHBQkKLAAKCigCCgqCAgsKRwMMChIBDAoTAQwKdAENClsAjgp9AIULngMHC9AEiQsTAgYAhgAHALUBBwAgBwkAJQAOAB0BjgBzAQcA5gEIAJsACwBdAIwApAAGAG8FhgCiBYULngKFAE8CBgqTAAcKdgMHC6UHCQrxAooKDAEFAHwBBQCKAgcAlQSIADYBBABsAQcAhAQHAKMEiQCZAYcLVQaGAOIBhQv6AQQADQMGAOcBBwCeAwgABwGLAPQBigqJAIcL8gCLC2AAhQqeAYcK4gaGACQDBQtCAwcLsgQICw4ACQvhAYkLcAOGClcCBABeAIcA8QQEAJ8BhAChAQUAXAEGAAoCBgrVBgcL9gWKC9EBhgpbBoQA9AOECugBBAtlAQYLrAAHC48AiQudAQQKUwAEC04CkgtMAIwKpAIHCx8BCAtjAQkLJQGJC+cChgoWAQYACwcSAKUAGAAVAAULqQAHC00BiAstAAwKYQCMC2EABACYAQQA5QKHAPQBhAvGAAcKhAEHCoQCiwoNAwQLGAAFC4wABQu5AAcL3AULCzUCiwtGAwYAKQUJAAEBBwrlAAgKOwAJCr4ACgp6AYwKvwAEC04BhQtRAocLXQeGAHIEBAD5AAYASQCHALEAhQBAAo4A5wCJACABhAqUAgcKCwSKCuEChwDPBQYA3QMJALEBBwqyAgkKSwKMCgkCBwDwBAcAjgYLALEDDABVAQwA1wGMADkChAvFAoULgQMFC+AADQuuAJILNACHCzAHhgrQBgwAVwAQAEoABArdAgkKwgAKClwACwrGAAwKVACNCoAAjAALA4cAGgIEC2AChQvxAYUAnQEHC18FBwu6BYoLSwGIAO8BBgscAogLiAAHADYACAA4AQoAvwAKAGYCjAA3AgYA1AEHADcCBwDGBQgAEgIOACIBhQvnAwQLKwEHCjIBhwvsA44LKAGGAMwFhQrTAwYAYQIJAC8DDAuJAA4LCQAOCxgAjgtAAIULyAEGAOQBhwA2A4UKsgCIC7QAhAvzAokAhAOHADcFBgC8BocA5geHC3MEBQCAAoQKhgEGACcHigt5AocLNgIEC3oDBQslAwULMwMFC8EDBguMAQYLXwYGC44GBwuvBwcL+QcJC3YCCwsIAAsL+wMMC7AADQvhAA4LJAGVCxgAhADaAYYATwSHAOAFhgAoBgYAwQMGAAoEjACPAgsLAgKVCxQABQAxAYcLFwcHC+EFCgu+AAoLegILCxgDDAtmAYwLvwEFCwAABgsYAgcLXAINC70BkQt+AAcA1ASFCmkABADgAQYA2QAGAC4BBgBqBgcAggAHAEUDBwApBQcACwYHAHkGCACtAQkA5AANACEBDQBXARMAZQAGC+gABgucAQcLMgQICwkACAudAAgLEgMJC8QACQtgAQkLyQEKC1EBCwvoAAsLbQMMC+ABjAsiAgUKtgEHC74DCQq2AgwKcwINCyYAjQrSAAQLfgGIC0MCBwAWAQoA4wILAMQCjQBcAQQL1ACHC7YEhwtqBwYAxAIGAEAFmAoLAIkLAAOGADAHjADpAAgKGQCKCjoDBgDhB4ULjwIGANAFiwsiAYQKNAGGADYGhgAIB4YA6wQQABwABgvnAAcLXwCIC6cBhQssAYcKlgCICokCBwtSB4kLgQIGC+0ABwtjAggLZAAJC6ABCwtPAQwLrQCSC2UAiQAtAIYKCQIRACQADgsaAJILlgAHAKIFDgAWAAUKUwEPCikADwqmAJMKQgAIAHoBBgtFAocLXwSGAOMFkwt1AIsAJwCGAB4EBgBrAQcAoweIANUChgD0B4ULxwAGAE8HCQCnAwkAwQMJAOwDCQD4AwwAJQMMAFQDDABVAwwAZQMMAHIDDACAAwwAigMMAJUDDACsAw8AqgAPALAADwC8AA8AyQAPAM0ADwDUAA8A6gAPAPQAEgC1ABIAwQASAMQAEgDJABIAygASANIAEgDZABIA6wASAOwAEgDtABUANgAVADcAFQA6ABUAOwCYABYAhgpcBokAJQMFAC0DhwD+B44LKgAFAMgCBgDYBAsAEQANAEEBkABDAIQAaQKHCj0DBgBAAQcADQMHAIEHCQA3AAoAugAKABEBCgCYAgoAIQMLAOQDCwDlAw0AnQCOAKoAiAAPAQUK5gGHCkUFEgtbAJMLRgAKAL0BBwpjBggKEQCKCicBiAuUAQcAZwAHAF8DCwC4AJEAPgCKCi4CiQCTAgYLOAEGC7MGCgtIAgsLIgILC7QCDAsDAQwLJwENCy4AjQuaAIYApAKEC0wCBAvnAAULPQAGC2gABwvZAgcLxAMHC3oGjAueAQYLBwGKC/UCCwBRAY4ALwGHC1MFhAtAAYwA+gGGCr8BBQBNAAcArwUKAEsDkwBJAAcKQQIHCpgFCQrbAQkK+QEJCg4CCQphAgkKsQIJCtYCCQrfAgkK4gIKCiwCCgqiAgoKrAILClkACwrKAAsKEAELCnwBCwqfAQsK+QELChkCCwomAgsKMgILCoACCwqbAgsKsAILCk8DCwqfAwsKogMLCqwDDAqQAAwKRQEMCkkBDAqFAQwKkwEMCsMBDAoDAgwKXAIMCmgCDApyAg0KQgANCoMADQqnAA0K7AANCnABDQqbAQ0KsgENCsUBDQrNAQ0K2gEOCjsADgo8AA4KiwAOCpgADgoUAQ4KYQEOCpIBDwocAA8KUQAPCnsADwqYABIKiACUClgAhADKAYcAjAUGAG0ACgB+AQQLlQEECmECBwr0AgcLMQMJCiACCwqdAQ4LOgAOCjMBEAoZABELJQCSC3wABgBKAQcAPAQLAI4AhQvOAwQKogOFCrMDBQqrA44LigEQAFsAkQBXAAUL6wAFCsIDBwvXBAsLgwCMC3IBCwDsAQUKiwIICqoACQo9AAkKPwAKChcACgolAAoKQgMLCgQACwoZAQsK9wELCqUCDApgAAwKggAMCvQADgoFAA4KKAAOCqIADgrKAJIKhQAECpYBBQpDAgwK7AGWCg8ACQuJAIoL3QCGANcECwDTAIwAkQAHC4YBiguMAIcLigWHC3gEhgAZBAcAQQEGChEABwrpAwcKvgcJCnYDCgrpAQoKIAMLCg4DDApAAQ0K0wEOCpEADgqDAY8KdwCRChEABQuXAQsL6QETCyUAFAtJAJYLJgCFCsoBhwDBBwcKvwcICgAACAqrAAkKeAAJCtwCCgrZAQsKkAILCuYDEgoAABIKAgCTChUABQtFAQcLywUICwUACAvjAAkLaQAKC0kCjAtmAogAegCEAOoAhwusBAYA0AMGAEoEhgChBQcA/QCIACUCBgttAg0L+AGQCxMAhAoHAgUArgEFAKQDBgCDAAcAoQEJAAoCCwA6AY0AhgEOAJUADgCPAY8AOQAFCosDBgofAAYL2gAHCusBBwoSAggKUAILCjUACwoLAwwKpwAMCpsBDgoOAA4KiAAPCkgAEAoRAJAKSACMC0oBBwvGAQcLDgOICwADhAD7AQoLpAKMC84BBgB2AgkAKwMECtAABQpqAAYKEwIICpgBCQq8AIoKPAIEAFcBBQD/AYYKnQaGC6QAhADAAQcAxwGKAE8ChwBlBQwKuQGWCzIACQrBAQoKwACKCuQCBgA/AoQK8QCGAJcEhgCNAoYA4QaGAK4EhAoDAQYLVwEHC8MACQviAAoLxQAKCz8CCwv2AYsLgwMHAGcEBwAkBgoAKQEKAKYBCwD8AgsAKgMMAAgBDQBmAA0ALAENAOQBDgCTAA4A5QARAEcAEgB2AJMAeACHC5oChACmAgQKrQAFCjgBBQoAAocKBQUHCkMGBwqbBgkK0AELCsMADAoXAQwKwAEOCgsAkwpmABAAYwCSAKQABwtlBAkLjwALCz0ADguVAZYLFQCJCwQBBArEAQUKRwIFCjEDBgqxAQcKUQIHCtACBwpiBQgKoQAJChwBCgo5AYsKdgOECiMCiArSAg4AIwCOAL8AjQAtAIoAeQCEAH0AhgBWBoULvwMICqQBiwrBAIQA0QKHCpkBiACRAAcAGAMIAJMACgA1AwsAygMLAP0DiAutAIYLCgGEAMsCBwDPB4oKNAGFABMCBQCoAAUAogMIAEoACQBvAgwA9AGMAEMCkABBAIoL9gAGANwABwBNBA0AaQCOCzoBBQrqA4gK6QKGAMADFAAAAJQLAAAEAO0DBArvAAYK3QEHCkcGCwpEAIsKaQIGABMABwCFBYsArAGVCg0ABwBgAAgAkQEIAL8CCQCAA4gLLAGGADsGkQB0AIgA/QMHAKkHBwCtBwcA7gcIAJYACAC+AggA4QIIAO4CjABuAQsLSwCOCwsBhApvAQgAIAMJAJQACQBoAwkAegMLADUBCwDpAw0ACwENAEMBBQurAQUL3gIHC94BiAs0AAcL7wALC9kAjgulAIQLQwGMC6MBDQArAY4ASwAGC1cABgvGBgcLFAAHCyAECAvcAgkLlgEJC48Digu2AoYAZwWECrYChQtlAokACwMEAFYCjAqvAgYAygOHAKgBhQAjAgcLIAAHC9gDCAtVAAgLxQIJC0MCCQtPAwkLWAMKCx8DCwsCAQsL7wMMC0sBDAtnAg0LvAANC7MBDgsIAA8LpQAQCxsAlAsoAAYAxgSGAGkFhABsA4oLlwCHCtUABAunAIcLUgCFAIUABgsYAAcLSgAHC6YCiQsCAQULPgAGCxYCBwusAgcLEwQHCzAECAsYAQgLHQIIC64CCgsHAgsL/ACMCxoBiAC7AAgACAAKAAAACgAyA4sA3AOEC2cBCwCtAQ8AMwCHCogGiACtAgUL0wAHC1gAiAtzAoYA2AGIAIQABguRAI0LUAEECu8CCwqGAYwKIAAGAKoDBgAkBAQLBwEECpkBhQpOAIkAagMIAAYDCgCeAgwAMwAEC5QDBgrZAQcKQgYKCroCDArUAA0KMwGRCmkAkgBcAI8KnACEAD4DiQC9AgQLVwIGC2IGBwsFAAcLNwAHC0MABwthAAcLswIHC9MDBwuhBggLzwAIC9YACAvnAAgLJgEIC1ABCAusAQgLwwEIC8wBCAvXAQgLbgIIC3ICCAunAggL9wIICz0DCQsLAAkL9gAJC+QBCQs9AgkLwgIJC/oCCQseAwkLVwMJC2YDCQuQAwoLLwEKC08BCguoAQoLzQEKCx8CCgv3AgoLLgMLCzsACwvHAAsL6wALC9sBCwtOAgsLoQMLC8MDDAtyAAwLtgAMC+IADAtMAQwLtwEMCz8CDAtWAg0LCAANC30ADQvCAA0LHwEOC8UADgt/AQ8LNQARCz8AEwsuABMLYgATC2oAlAtVAAQAfwAFAF4BBgBkAQgAqgEJADwCCgD3AIsAOAGGAL8EBgA7AAkAWwINAI0BBws9B4oLtQGGAOIGkwt+AIcKcwMNACUBjgA4AIUKaQKLCjIABQu7AAcK7gWLCrYChwC5AQYAbwAHAAQACACjAAgACAOKADYChAAmAwQL1wAJCyYACgsDAAsLFwALC38AiwscAw4A6QAECiIChwr6B4cAygeGAMsGhwv6BYgAiQEFACkBBwAOBA4AZwETADQAlAAvAIcANQEECjkBhQpBAggKuACNCrEBhwqnAwwKugAMCiQBDgpkAJIKRgCIAGsBDgCvAAsKkgEMCm0ADAqvAQ0KswANCs4ADgrZABAKAwCUCjUABQp2AwYKLgAGCv4GBwoOAAcK3AIHCnYGCApfAAgKRwEICmgCCQp8AwoKVgIKCgEDCwqGAAsK6wIMCnoBjgphAIgAmgKHAIsGBgCPAoYAQAaHACgDhQr9AwQLHAAFC7gBBwv4AAsLQQOMC1gBhgt2BoQAGAGMADYABAClAYUAJAKECpkABgtTAYcLmwOFC1UDhQoeA4QKSwIGC/kABwvSBIsLPQIGClYCBwoqAAgKtwIKCtQACwqeAA4KxACRClUABwD5AAUKvQOFCvADBAqBAIcK0QEGAP4ABwBKAwcAewYJAG0ACgBnAAcKjAMHCrEECQrzAgsKigMMCg8CkgoHAAUABgGICsIBkAABAAoLyQCOCz8BBwsxAAcLiAEICxQACAusAAgLsgIJC38BCQtNAwoLMAALCyUBCwtAAwsLmAONC90ABQtaA4UL4AOGACUDiwrrAwYAXgaGCzMBBwvoBYcLAgcGCwwBiQs+AIcKTAeFAJ8CBADdAwgAzAOIAOYDhAunAYQAeQOHAGYFhwB2BwcKxQMHCrQFhwpEBgQAcwIFAAcDigtqAIYLXAEHAMoACwBqAQsAtAOMAIQBigsDAwYLZQKIC98ABgAwAgcAwwEIAIUBDADqAQ0AEAANANcADQBfARIAhACTAH0AhwBJA4gANgKIAKoDhAueAgUAkAMGAJ8GjAs3AAkLKACLC4gABwBRBQcK1gMKCiAAjwo4AAsLAwGMCw4BBQDsAAYAPAIIAOwBCwBqApAAOAAICzwCCQs2AQkLqgKJC7oChgA+BwUAvgCIAD4BhQqzAYcAYAUECygBBgtgAQcLkQEHC4IFBws6BgcLigYICz8ACAuUAokLSgAHAF0BBQpVAAYKowEHCjEBBwppAQcKOQUICkcAjAoHAgQLiwAEC4QBjAu8AAYAtAcGAN0HCAC3AwoAswMKAM4DCgD6A44A3AGMCrAChwrkAgUKswIHClkBCQpeAIwKqQAJAFgBBQq3AAYKRgIKCqcCjAqzAYcK/wGEAFIDCAu5AQoLOgGPCwMABwrJB4gKrAIEC+sCBgsiAQYKRwIHC4kCBwvHBYcLLwaFC+gAhQrAAoYAjgMECrMABQrGAIUKuQIHClsBBwrLAwgKtQCKCscCiAsNAg4AEwAOABwAkAAdAAcAVQAHAPcACABJAooAowAEAOcBBwvYAQcLCQcKC+wCjQvKAQQK8wAFCssABwoTAAcKRwAHCnEACgqVAQsKZQGOCvAABwqqBYsKYwCEC6kBigCRAJMAUwAGCuwBiQv3AAQA9QOGAPEHBQqGAAYKmAEGCu8Bhwo5BocAggeGC+gGBAB8AAoAyQELAHkACwCpAAsAZgMLAGoDDADWAA4AuwCPAE0ABQAtAocAsQWLAEIABQuvAwYL8waOCgQABAr4AAQKmQIHCokAiQpdAQcAqQQFC/UABgtAAgcLRgKIC+EAkABSAAcK9gSLCmQCBQDGAQoAYAGKC2ABEgA5AAUKcwGHCjMChwA1BQYAawAHAH4CBwBgBgkAjAGGC2ICBQByAYYA3AYECnYBBwojAgcKpAYHCikHiwpaA4UAzAAGABkFCQo3AY0KKgAFAMoDhgCqBgYKbwYHChAGBwraBwkK7gGJCv0BDQvHAQ8LYwAPC4EAkAtEAIcAAwAEACMABQB5AAUA4wEFAK0CBgDpAQYADgMGAAgEBwC0BIgAigEEAJkDhQDvAwgLaAGKCz8AhwCgBoYA7wWEC7sBhwuwAwYKewAHCtYACQrYAgoKnQALCloBCwqWAo8KagCJANUDhwqbBYYAMASEAMgChgBdBoYA2AIECyoBiQvjAQYAmQQGAPcEBQukAAcLeQCOC70ABwBIBgQKwwIFCkwCBgqJAQ0KagASCjEAkwopABcAEACXCxAABgrTAAcKmgYLCuYBjApxAYUA5QETCw8AlQsbAAQLrAAJC2MCCgu0AQwLoQKNC/8ABQtMAwoL5AELC/ICDAvJAQ4LqwAOC4UBkguZAAQAHQEFABsABQA9AQYALQEHAAcACACZAAoA/gILANQBDADTAY0AjwCGALYFCQsHAQoLkwCKC+wBhQsZAgYAmQcGAMIHBgDHB4YA9geGCtsAiQtKAw4ANAARADIABQpGAgYKbgYHCmMABwqqBwcKwgcICgMCCAoFAwkKFwAJCusBDApsAo4KXQCKC2EAFAAVABQALACFClMDiAAzA4sAlQMFC+YABQuIAQYLpAEICvoCCAosAwkLOAIJCo4DjAtkAocAEAMPAIcAjwuHAAoAxgGMAEQBBAsAAAULKQAHC7MFBwu9BQcLUgYHC0MHCQslAosLiQMECmIABwpVBQkKpgEJCp4CCgoHAwsK0gANChoADQrJAY0K3AEGALcGBgDHBgcA4AcHAOQHCABFA4kAVAOFC7gChwBUA4QAuAOGCsIGhAsDA4oAOAKJAMABiwCSAAgAQwCKAKMBhQuZA4kKkwCGACIHCgCRAg4AKQGOAGkBBgCaAgYA/wKGAAYGiwDZAgYLtAAHC3EECAvvAosLJQMEC7cABwsPAQsLOAMLC7gDDQsWAQ0LUwENC+IBDguoAZQLYwAEAJ0CBQvdAQULVAIGC/kBBwvFBAsLiwMMC9EAjQvWAIcLvwQFAJIBBgoeAAsKOACLCjEBBws0Ao4LqACLAJgABwCQA4cKTgYECpYABQovAYYKRwEHAEABCAAzAAkAZAMKAEEDDADhAQwAOgKUAGoAhAC9AQcLEgELCwcBCwvfAQsL+wGMCxUBCgArAgsANAETAF8ABgttBggKwAAKCk4AjQpnAYcKEgMGC1wABgu8AAcL9QQHC/QFBwtUBwoL5ACLC/wDBAvLAYULxgMLAIIBBgpmBgcKTwAHCvABCQqKAAoKUAEMCpwBDAq4AY4KMQGFAO8ABwBTAAcAxgcIAIIAiwDQAooLxQIEAI8ABQAmAoUA8AIFAHsABgASAgcAXAGHAIsFhwDoBwYLEgAHC7MABwvRAgcLpAMICyQCCAv1AgkLNgAJC0EACQsUAgkLTAMKC3EACgt1AAoL7AAKCzsBCguuAQoLHgMLC5kACwtfAQsLdwEMC04ADAuXAAwLiAEOC/gAjwsXAAcKzAAHCp8BCAoqAAoKVQCLCjQChgC+A4ULxQOEANIAhwuVBYoL4AGGC7YAiwtZAQoLQQAKC+gBigvxAQQKAwAFCvcABQqEAgcK6AIHCrcEBwrJBAcKdQeSCpMAhACuAQUKHQEJCkMADQrZAY8KUgCQCxAABwuKBAkLTAIKCwQBlwoIAIUA1QCKAAcAhwAhA4YL+gaHCzQBBgCoA4YACQWFAGwAhAB1A4UA2wCLAEsCBADBAAUAlAMGABEEBwBsAQoAjgEKANYCCwA9AQsAcgIMAI4ADAAgAQwApgINADkBDwBxAJIAcgCHAI0EBgDxAAkAVgEKANkCCwAcAQsAvQELAIsCCwBfAw0AjgGSAGMABwCLA4gAQAMJAC8BBAodAAYKFAIHClwGBwpwBgkKXgEKCrEBCwphAAsKLQILCukCDAohAQwKTwEMClwBDApeAg0KdAANCukADQrSAQ4KtQAOCtEADgroAA4K7AAOCiwBEAopAJQKYQAHC6cBBwqcBogLTAIGAKMDhgCuBQUK9QEHCqgGCQopAgsKCAIMCi0CjQr5AIgLHwEEADICCQD+AIsAbwOEABIDDgsgABILVQAUCwIAmAsQAIcADgUHC9MChwtvBAYA2AAHAIUDBwA/BQgA7QGGC5MBBwvPAggLKQOIC0IDBQvSAAYL1QAHCzwACgtsAYsLhwAHAFUBCwDbAAULXwIIC0YBiAvqAQQLvQIFC9gBBQt/AgcL4QQJC/YCiwuAA4cLfAGHC5sHiwCCAIcAxgYKAHMACwCkAQwAmgANAJQBDgBaAY8ANgCGCoEABAuCAQcLKQAIC5UBCQvxAQsLbgALC2gBDwslAJALVACNCxoBBQsuAAcLrAUHC8gFCAt6AowL2AEECwwCiAsqAwoL7gCNCyEAhQBcAgUA8wOIAL0CCABYAwgAWgMIAG8DDAC+Ao4AvwEEADYABQCaAgcADwQHAGoECQDDAIoALgEEChkABQo8AAYK+AEHCmYCBwqDBIwKAAAHCuAECwptAosKvgKFC+UDiQpBAYYAhQaGAP8GBAp7AYcKdQWKC3QBBQsOAwULPQOGC8oGhwDMBAQKdgAGChIBBgppAQcKSwCNCrkBhABvAgkLFwEKC5cBDgtUAJYLEgCJCkkDhwAeA4wKtQIFCjoBBgrdAAcKowEKCooCCwqMAQwKnAANCnEBDgpNAZEKLwCHC1wFBwB6AAkAAwEKAFQACwDWAQwAHQKNAHsBhgBFAwgA9QMEC04ABQtgAAULtgAHC7wGBwshBwoLigEKC9cBCwsUAg4LVAGRC1gAhgBBAocLrAeECpEDhgDMAQgAewMKAIUDCgCXAwoApAMMAMsCDADYAgwACQMOAMkBkABnAAUAUgAFAIMABwDbBggAHwAJAKgACQD8AosAZQOICtsBBgBdAgUK+AMJC1kCCQtrAgoL+QEKC9wCCwtjAYwLiwAHCloCCAqzAAoKDQOMCn4AhgDeBAYKSQGKCm8ABgvXAAcLBAQHC8EFBwu5BgkLqAGKCwsDBQAWAYkARAAGAKQDBgA8BJAAVgAEAKMABQDJAAUAMwEFADYBBgBPAQcAHAEHAHwGiAClAIgADQOGAMMCBgAhAIcA3AQFCjUDBgtDAAYKlwYHCwIBBwteBgkLYgEJC6MCCgs+Aw4LUACRC1AABguNAAcL4QAJCzsACQtfAgoLOAELC68CDAsrAg0LdQENC+4BlAs6AIYAWQQJAIQBBQpHAAcKfwUJCsACCgoFAQoKawILCiMCCwprAo8KnQAHAKEHiADQAooAywAHCtgHCQpRAYoKBQIGAEYBBwClAokAqQGLC1EABwAkBQcAhAUHAC8HCQBNAgsA8QALAKQCCwArAwsAewMMAIwADABaAQwA3wENAIwADQB9AQ4AvAASAB4AlABsAAUAoAEGClYABgpbAgcKJAEHCjECCAoBAQgKfgEJCtECCQoKAwsKRQKMCtIBBArmAYUK6wGGABQFhApIAAcATwMGCgkBBwuuAYsLLgAFC1oCBgtqAAcL+gYHCx0HBwviBwkLogGJC/sCBQBmAQcAFwIHAKAECgCWAg0A1AANADABDQBNAZEAYgAFC0EABgugAQcLuAYHC4QHCAulAgoLbQALCw4ACwtGAAsLOQILC98CDwuZAJQLUAAGAB8HCABHAwgAVAMIAIcDCgCsAwwAwwKMAAcDhwvNBAYA8gWMAI4CiAtTAosAowCNADoBhADSAwQAWQIGAPMHiQrqAAUKLwMGCpgGhgrbBoUAsgOIALIBBgrFAIgKzQAHAJsBBwBOAggAdwIJAEMBCgBjAQsA6wEMAI8ADACSAQ0ASQAOAJgBDwBrAJIARwAHALsFCABIAQoAIAILALsDDAANAA0AQAGRAFMAjgCaAQsA/wENAIoBDgAqAQ4APgGSAGcABgrEAQcKOAGKCtsAigpNAgQKTQEJCrAADAphAY0KuwCHC0kBhAvVAQUAQwOGAOMBhgvPBgULoQMGC1QBCAt4AYgLJwOGCpUGhAClAgUL2gAHC0oGigtTAAULOwKHCzIHhAvHAYkARgCHAH0FBwqHAAgKBwAICj4ACQrzAAoKkgIKCrkCCwrIAYsK9AIJCosBigpPAIkAbAAGC6EABwt0AYkLVQKEC10BhAAJA4QASwGHCncChQDrAgYLsAEGC2ACiwtCAYoKQwMFC9QBBwsRBwoLRQELC1gDDAtZAY8LaACFC98ABwqWAQcKywEICl4CiwrWAoQLNgKOAEQABAs7AIcLcgUGC7QBiwvhAQQLMAAFCw8Bhwu5A4sLqgAFC2ICiAvJAYUL8wKHC8EEhQpkAoQLxQCEAPkBBAp0AQcK4gEICp4ACQpaAgkKZwIKCvUACgqmAgoK6AILCvgAiwomA4UARgEFClYDhwrHBwQAswKSABAABgB0AgkAIwAKAKgCCgAZAwsAbAENAGUBjwCkAIoAjgIGACAABwCBAQcA9QIHAHwHCAAlAAgAXgAIAMcCCQAdAgoAogAKABsDCwDdAwsA8gMMAA4AjgA0AYUL2QAGAJgABgBdAQYAkgYHAOQECABwAAkAswEJAJwCCgAiAQoAPwEKAC8DCwC0AAsARQMMAPAADQCYAA0A2wCOAJ4ABABFAoYA1gIFCsMAhwqVBgYAfgAHAD0CCACNAY4ALACKAFkABwrNBwgK2gKLCu4DhgD7BYYAjwQFAJ4DDADLAIUK7wIEC6UABwt2BYcLJQcHANAEiQATAocKNQOGAK8DhQCeAgQAcAOLAOcAhgBRBocApQcFCwkABwspAQcLxgOMCzIBBgDPA4YA2QMFCrYDBQriA4YKXwEMCxUAlwsHAAULkgAGC5sBigvRAgcA8gCHAJYHBguxAIcL0wEFAKUBBwovAIkKrAIFAEIDBwCyBAgADgAJAOEBiQBwA4oA0QEGALACCQBCA4QKXgGEAFcDBABlAQYArAAHAI8AiQCdAYULyACEAE4CBwoUBw0KAwENCmQBDgryAJMKcgCFCscDCwByAAQK2QEHCm8CCAooAwkKZwMJCn0DCwqvAQwKcAAMCtkADArzAAwKMgIMCpcCDAqrAg0KjQANCsUADQrjAA0KlgENCucBDgqcAA4KywAOCuAADgoAARIKOgCWCgAAigoeAQQK3gAHCh4BiAp1AgUAqQAHAE0BiAAtAIYL4QGEAMYABAAYAAUAjAAFALkABwDcBQsANQILAEYDBAtUAAcLygUKC0wAiguOAIUASQKNCjIBhQv3AwQLOwEFC/sBhwtaBYgKkgAGALMChgDfBQQATgGFAFECBArRAYcKfwaOC60AhwCRAwwAdACGC7oGhgBQBYQAIgMIC94ACAvcAQkL7gALCwQCCws/Ag8LbQCSC2QABgA0AQkAoQIHCooABwoFAosK7gCEAMUCBgBUBwYAZwcJAOIDCQDuAwwAPQMMAHgDDAB7A5IAuQCUCl4ABADkAIUAgQMHADAHBQrvAQcKQgMJCt0Ciwp6AYUKLwIGChUABgrJBgcKpAWICuAABABgAoUA8QEGCygAhwv1BoYAJQaHAPcHBgAcAogAiAAEAIEDBQASA4UKBwIGAFYHBgBcBwkAqgMJALQDCQC7AwkAzQMJAPQDDAB/AwwAnwOPAP4AhgC9BYUA5wMEACsBhwDsAwQA6QKFAEICiAs+AoUAyAGGALEFBwCPBoQKkgEHALUCCAC0AAwAowAICkMBiArfAQsKRAKOCskABQo7AIcKoAKEC2IBkgoiAAQA8wKHCxYGBwDMBpIAMAAEClUAhwolAosAUgGFCl4AhgBDBIcL1QEMALcCDADAAhQAcQAFCz4DDgtSAZQLUQCHALgFBgoLAIcKuwCHAM8DDQBPAYQKCgKGALsHBQvwAYcLywAECjQAhwqVAgcAHgYIAA0BCQDUAAkAzgIOAA8ADgCEAI4A4wAEAHoDBQAlAwUAMwMFAMEDBgCMAQYAXwYGAI4GBwCvBwcA+QcJAHYCCwAIAAsA+wMMALAADQDhAA4AJAEVABgABAp/AYUKCAKGCyMChwvUBgULWACJC+8AkguAAAcLigKHCx4FBAoZAQUKJgAHCsIABwqcAgcKZQeJCo0BhwAXBwkKewKLCi8CBwDhBQoAvgAKAHoCCwAYAwwAZgGMAL8BBQAAAAYAGAIHAFwCDQC9AZEAfgAHCzQECQtQAAsLTgALC6UBCwsWAowLIQIIAMYDCgD/Aw4LcQGSC0gAhwtpBgYA6AAGAJwBBwAyBAgACQAIAJ0ACAASAwkAxAAJAGABCQDJAQoAUQELAOgACwBtAwwA4AGMACIChwC+AwQAfgGIAEMCBADUAIcAtgQEC/EBBQuRAocLMAaEAKkCCADLA4oAxQMFCsABiAoXAg4AEACSACwACwBIAgsAaAIOABMBCwtIAgsLaAKOCxMBiAsNAAcKYgKHCt0FBwuCAggL+gALC3sACwuJAA0LMACOC18AhQCPAhEAQwCTAEoAhgDvAoYArwcGAOcAiACnAQUALAGKAPgDBAo/AQUKuwKKCqECBgDtAAcAYwIIAGQACQCgAQsATwEMAK0AEgBlAAYKUAEICigCCQodAQoKYwCLCjgChgBaBQcKfgUJCtoAjQreAIUKAAGHALgEDgvVAJQLJgAGAMMEhwtqBg0AoQEOAIEAjwAPAAoLIQKMCy0BEQonAJQKJACFAMcABAuIA4ULGgMMAKsBkgAmAIYAtQMIAJkChwp6AoQKagKHCgMBhApTAYUL+QKNCqkAhAr3AgUAsAIHABsChwDIAgcLggGKC8kChgCiBAYLBwAGCyMABwuTAAcLLQQHCyAGBwsnBgcLfQcICysACAvQAAkLgAAJC2IDCgsUAAsL1QOTCyEABwt9AwgK4gGNC6gBBgA4AQYAswYKAEgCCwAiAgsAtAIMAAMBDAAnAQ0ALgCNAJoABQpQAQYKVQEGCt4BBgrjBogKggGJAJcAhABMApgABAAGC0IBCQsoAgsLEgENC9EADQvzAQ4LVQAPC34AkQtGAIcKSQAEAOcABQA9AAYAaAAHANkCBwDEAwcAegaMAJ4BBgAHAYoA9QKHCrMHBABkAoUAMQKEAEABhwpABQgLUwAICzEDCQscAAkLHQAJC3UDCguDAQsLeQILC+QCDQvrAA0L/gAPC48AjwuSAAUKjAGGCvUBjAsxAIQA4QAECqEDBQofAwgKLgCICuQCBACVAQcAMQMOADoAEQAlAJIAfACFAM4DBAucAYULRQIECnwDhQoCAwQA5AOGAOoHBAAPAgUA6wAHANcECwCDAIwAcgEJABAADQCCAYcLpQEHALwDBwCFBAcA4gUHAEYGBwBPBgcAUwYHAMgGBwDvBggATgIJAEQBCQDgAgkABgMJAAgDCQAQAwoANwIKAMQCCwAGAgsAZQILALcCCwDMAgsA4wILAAIDCwADAwsAUAMLAFkDCwCjAwsAswMMAEYBDACDAQwA5AEMABACDAAoAgwAZQINAL0ADQAAAQ0AVAENALABDQC0AQ0AuAENAMYBDgCuAA4A3AAOABwBDgCGAZEAeQCHCp4ACQCJAIoA3QAEC24ACgufAQoLVQKOC84AjQvwAYcLzQCXChkAhwsKAwcLeAYHCtEHCQtxAQoLUgEKC+oBCwuaAAsLIQILCwcDDQtNAI0LEgEEC7wBCguSAIwLCQAHAIYBigCMAIcAeASGANABBwq1BYwKWwCECloCBAsbAYcLqgQFAJcBCwDMAAsA8wALAOkBDAAlARMAJQAUAEkAlgAmAAcAwgSIAC8BBQBFAQgABQAIAOMACQBpAAoASQIMAGYCBAoNAAUKNwIHCtoFCQp8AAsKCQKMCpUBhwruAwcAIAMKAAwAhgu4BocA9waECt8CigosAwQKqgCHCkMBBgBtAg0A+AGQAFkABQowAYcKewWJC9gABgCYAwYAUAQJC7cAiwseAQQAeAGFCuYChgDaAAgAgQILAIQBjABEAgcAxgEHAA4DCAAAA4wArgKJCyEAhQpvAJAAAAAKAKQCjADOAQYApACIC98ChQq8AZYAMgAHC0YHDAvrAQwLCAINC38BDgv0AJILDAAFC4QACQvmAQkLywIKC8oBCwt1AQsLnAILCxsDCwuBAwwLEAEMC6gBDAsbAgwLLgIOC/UADgsHAQ4LCAEOC4kBjguTAQgKewAPCgYAkAoHAAYAHQEIAI4CCwDtAgwAvgAMAEcBDQB4AA0AeQANAEcBDwAvAJIAKAAFCwgABgtZAAYLkAEHCyEGBwtXBgcLOgcIC9oACAumAQkLOgKKC3ICBguDAQcLcgONC28ABgBXAQcAwwAJAOIACgDFAAoAPwILAPYBCwCDAwYL4AAHC20DiQuHAgUKqQOHCmQAhwsWA5YAHQCTAAgAhgAUB5UACACHC4oBBwBlBAkAjwALAD0ADgCVAZYAFQAKC/MCkwsdAAkLegGNC6IAhwqaAwUKawKFCroChgAvBQYAPgaJAD8CCQs5AgwLDAAMC1EADAs/AQ0LRQAOCwMBEAtXABELAQARCxUAEQsYABILDwASCzgAEgs7ABILfwASC5oAEwsTAJQLHwAGAH8DhwvPBAUAvwMHC3wAiAsmAAULBQEHC04ABwvHAAgLLwMJC34AigtWAQUKlQOGCnsGBwDfBgULUwKHC0cHiACtAIYACgGOAAUBhAt0AgUK+wAFCrwDCAoMAQkK1gCSCo4ABwsKAYgLJAOHC9AABgtPAAcL/QOHC+8FCwvAAo0LjAEFCloBBQrHAogKhgGIC+UChgt4AYYAkwUGAAkEBgDBBIgALAGFCnACBgtkAAcL9AAHC3gCBwtJBggLsgAIC34CjQs6AAYASAIFCg8DBwrOB4cK/wcFAKsBBQDeAgcA3gGIADQABwDvAAsA2QCOAKUAhgBpBAYAqAAGAMYGBwAUAAcAIAQIANwCCQCWAQkAjwOKALYChApSAoULFwMHC64CCAshAAgL7gAKC2gCCwvTAQsLcQMNC9kADQv9AI4LDAGJC9wBhgCiAYUAZQKEAHgChAu/AQcAIAAHANgDCABVAAgAxQIJAEMCCQBPAwkAWAMKAB8DCwACAQsA7wMMAEsBDABnAg0AvAANALMBDgAIAA8ApQAQABsAFAAoAJALIwAEC4AABQufAQYLzgEHCyYBBwtCAgoLxgKLC1YABQC2AogAjQMHAFUECwAHAAUKJQAGCicABgrDAQcK2gAHCo4EBwqXBggKlgKQCgIAiAtLAgYLqwEHC/oDigu0AgQLwwAGCvwBhwsiAwQApwCHAFIABQA+AAYAGAAGABYCBwBKAAcApgIHAKwCBwATBAcAMAQIABgBCAAdAggArgIJAAIBCgAHAgsA/ACMABoBigAhAAQAZwGFC+ICBwDUAwkASAENALoADQBsAQcKewIHChwDCApLAQkKSgEJCmEDCgp3AAoK6wALCm8ACwqBAAsK8AAMCh8ADApCAAwK3gAMCg0BDApXAgwKrAIMCrECDAqzAo4KWQGJCg8CBgBUAgcASQKHCr4ChguTBoUA0wAGAJEAjQBQAYYAagQHAGkDBgolAAcKggYICsMACAo8AQkKsgAJChQBCQpTAQkKGAIKCmYACgpqAQoKEQMLCjcACwqVAAsKBQMNCqABDQqjAQ4KJgAOCikAjgrSAAgASAOIAEkDhAAHAQULAwAIC0ICCQt2AAoLwQIMC38BjQsXAYQAlAOFC+UAhQqFAg8AmwAQAE8ACAtmAAoLQgIKC6ACDAvwAQ0LmAEOC3kAkQtqAAQAVwIFAFACBgBiBgcABQAHADcABwBDAAcAYQAHALMCBwDTAwcAQAYHAKEGCADPAAgA1gAIAOcACAAmAQgAUAEIAKwBCADXAQgAbgIIAHICCACnAggA9wIIAD0DCQALAAkA9gAJAOQBCQA9AgkAwgIJAPoCCQAeAwkAVwMJAGYDCQCQAwoALwEKAE8BCgCoAQoAzQEKAB8CCgD3AgoALgMLADsACwDHAAsA6wALAE4CCwB3AgsAoQMLAMMDCwDbAwwAcgAMALYADADiAAwATAEMALcBDAA/AgwAVgIMAKMCDQAIAA0AfQANAMIADQAfAQ4AxQAOAH8BDwA1ABEAPwATAC4AEwBiABMAagCUAFUABwBMBYQKIgEGCkYABwoMBQoK+gKLCiABlgs3AAQAUQIIC3MACAteAQkL6QEKC4AACwsyAQwLdQEOCx4AEQtPAJMLUACHC9MEhgBwBQQL5gCFC74CkwB+AAcKgwAHCqYBCArSAIwKPQKGAJsEiwuzAYsKHQOGC8AGBACiABILGgATCyoAFAsrABULAAAXCxsAmAsOAIQKqAMGAP0CBQrFAYYKuQGFALsAhwAGBQYAewIGAIgDBgC6BIYA0QUEANcACAB6AwkAJgAKAJsDCwAXAAsAfwCLABwDBgCNBIYAGgUHAMwCDQBhAI0A+wCECo0CiACRApIKUAAFC24CBwsIBAsLGgALC9UACwvDAgwLfAENC+IAjQtjAQYAKwEFC0YABgtOAQkLqwALC30CDAvKAA4L3gCRCyoAjgCGAAQLFwAFCzkBBQv2AwYLMgAGCzMABwuOAAcLgAEJCw8DiwvlAgQLjQAHCy8CCAuAAgkLzAEMC7cAjQvoAYgLZgIHClgFCAroAAgKaQEKCqoCigrmAokKFgIGADoEjACSAokKGwCHANIHjgoMAAQAHAAFALgBBwD4AAsAQQOMAFgBBwrgAosKCAGGCnkGhgB2BooAEwIFC94ACQuMAIoLFgIGAHoCBgAeA4YASAOKC/cBhwp/AIUAVQMFC5oABwvTBQoLewGKC+UBBgD5AAcA0gSLAD0ChQvMAgcLIgaMCx4CiApsAYoADwIEC1sABQuEAQULTQMGC84ABgv8AAYLbQEHC4gABwsTAggLCAGIC20ChgCLBYcLoQUHADEABwCIAQgAFAAIAKwACACyAgkAfwEJAE0DCgAwAAsAJQELAEADCwCYAwsA2AONAN0ABQBaA4UA4AMFANgCiQoYAwUKjQMJClEDigolAwcADQIHACsGCADxAYgAPQIGAAwBiQA+AIcLQAKGALEEBQsDAwULXwMFC4IDBgtgBgYLbAaGC/QGhQtLAQcAwQAHAFEECgDvAQcKjQEICnwACAprAgkKMQELCigADApdAQ0KhgANCicBDgqbAA8KeACSCmkAigBqAAYAWwMFC2sABwvJAIgLBgIGC74BhwsZBw0AFwAECgYBhwpWAYUKgQKJC1MDBgCdA4kALQOEC/gBBgBlAogA3wAECmMABgr6AAYKWgEICn8AigpRAIgAuQOECpMDiwt8AwUKSwAJCgUCCgrWAQwKmwCNCuAABACaAgcA+QMHC+QDiguGAQULcwOFC88DDgpTAI4LUwAEAJ4CBQuaA4YLqwaHANgACQAoAAsAiACHCxMDBQq6AwUL4QMHCwMCiQtbAIsAAwEHAFoECQA2AQkAqgIKALgBDQAoAAYKMAEICqIBCwpVAYsKowIOACgBCQqaAYsKqQEKC3kBDAtrAQ0LRAANC14ADgtsAI4LMgEHAHkFhwDEBQQAKAEGANsBBwCRAQcAggUHADoGBwCKBggAPwAIAJQCiQBKAAQAiwAEAIQBjAC8AIQAHQOEC/4CBQtnAAcLmQMIC0QCCAtRAggLdgKKCxwABAuPAwULYwOFC/UDhgoOAIYAJAaGCqwGFQAnAAUKcQAGCvMABwpJBwsKoQAQCiUAkQpjAAcLGwaNC7YABQuHAAYLBwIHC7oGCgsPAQsLBQGRCzYAhAoSAYYAOgYECywBBQu0AYcL5AEEAOsCBgAiAQcAiQIHAMcFhwAvBoULFwKTC1IAhQDoAIkAdwOHCqYAiAAJAgQADgAHANgBBwAJBwoA7AKNAMoBhgDlAoYA4AMQAG8AiQowAQQAqQEFC4MBBwstAgwLIwKOC1YAhwvTBgUKjgKHC9EFBwAVAwQLBgAFC8QCiAtLAAYKEQEKCrwADQp5AZIKTQAGADkGBAsvAQcLawIKCyMCCguvAgsLegCMC1kChgDoBocKmgGKCwQDCwDpAIsKDAIFAK8DhgDzBoYK+QaICxEChAC7AwUA9QAGAEACBwBGAogA4QCECgwDjgDxAIYAlwcEC2oABws2AQcL+QYKC7ICiwvNAoYABAUFC3oDhQvcAwYLcgKOC68BCgvCApELIACJC0wBhAu6AocAxQIFCrQDigsRAIgAKgKGABwGiwqtA4QAuwGGAI0DhgtUAI4AGAEEChQCBQrCAocKlgKEANkCBQpFAwYKcwaLCtkDhwpFBwQAXAGYCwMABQvaAwYLggAHCy4GCAvKAQoLZQAKCz4Bigs3A4YA9gIEACoBiQBQAwQKSgEHCqUDBwrcB4gKJAEHC2wGiQuBAAYAjgUJAD0Dhwr/AgUApAAHAHkAjgC9AAcALAMHAO0EBwBQBQkAeAKMAGABhwv8BosALAKHC+UDkQpyAAQArAAJAGMCCgC0AQwAoQINAP8AiQpzAwsAEgKKChIBhQBMA4YA2AMNAOgAEgAjAAQKvwKHCs8AhAo7AgkABwEKAJMAigDsAQcL3AaJC2IABQppAwUKwAMICjcDiQpxA4UAGQKEAFsDBwsWBIsLoACJAEoDiwobAQUKIQAGCtYBiwqoAQYLLQAHC7EBCAuBAAkLFQAKC4gBCwtPAAwL8wENC8cAjQvDAYcACwWHCloHBwsuAogLYQGGAMoFBQDmAAUAiAEGAKQBCQA4AowAZAIGAAYBBwpaAAcKmAIHCj4DBwpkBQcK6QcIC1EACArAAQgKPAMJC70ACQvJAAsL3gELC8gCjQtSAY4AHwAFC2EBlwsaAIQA8QIEAAAABQApAAcAswUHAL0FBwBDBwkAJQKLAIkDCQqhAYkK7QGHC1kEhQC4Ao0LwAGGCicBhABCAwQAAwMFCvsDBgsZAAcLVwMHC+oEkAsgAIYANASFAJkDhQCiAgQLBAAHC14EBwsoBQcLqgYICxUBCQtuAgoLCQALC9QCDAteAQwLjQENCxwADQufAA8LWQASCwUAEwsJABQLIgCWCy8AhgrQAAYAvAGIADQBBgC0AAcAcQQIAO8CiwAlAwQAtwAHAA8BCwA4AwsAuAMNABYBDQBTAQ0A4gEOAKgBlABjAAcLPQGHCzkCBAATAAUA3QEFAFQCBgD5AQcAxQQLAIsDDADRAI0A1gCHAL8EBgAPAQcAjgEIAIMBCgBYAQcKwAEHCl0GBwoVBwgKugEJCsYCCgoaAYoK0gILCkwDDApoAIwKcQKGC/8AhQoTA4YAbQYLC7wDlwsDAAYAXAAGALwABwDRAAcA9QQHAPQFBwBUBwgAlQIKACoACgDkAAsAOgALAPwDDAA6AAwAdgCNACAABADLAYUAxgMECxgCBwt1BAoL0wKLC3MBjABKAYYAFQYHCx0BhwtsA4gK6wGHCzACBgASAAcAswAHAKQDCAAkAggA9QIJADYACQBBAAkAFAIJAEwDCgBxAAoAdQAKADsBCgAwAgoAbgIKAB4DCwCZAAsAXwELAHcBDABOAAwAlwAMAIgBDACaAg4A+ACPABcABgDOBoQLsgIECpMBBQq5AQcKwgEKCkgDCwplAAwKwQCNCq4BhQDFA4YAtgAKAEEACgDoAYoA8QGHC0IFBgDNAwYAhgQKC8gAEwsCAJcLFgAEC74AhQsqAoUKpwIHAEgBiQpGAYUL6QMJAEwCigAEAYULvgGHCmgEhwoEB5MLdwCGAPoGBgAwBQYAwQcIAMIDigD5A4cANAELAPwBBAo+AgcKXgEHCgAECApSAQkKpQKKCigDigvwAocKOQSJC2AABwqMBocK9QeIAEwChAswAYUAZgKMABkDiAAfAYkKKQGNCiUABgs1AAYLxwAHC4AFCAsgAAgLXQAJC7UBCguNAQoLdQILC1ECCwv7Ag0LRgGRCyMAhgtpAAkLQAEKC/oBigsaAwULcgAFC/8AjQsdAYwAIgEHC/MHCAsTAAkLWQCKCz8DhgBwBAcAzwIIABwDCAApAwgAQgMGCjIBBwp0BAcKPAUICoUAigrBAYsK8wMFANIABgDVAAcAPAAKAGwBiwCHAAUAXwIIAEYBiADqAYoLsACEAL0CBQDYAQcAfAGJAPYChwCbBwYANwSKABYBiguHAQUKSQEICgQBiwucAAQAggEHACkACACVAQgA2AIJAPEBCwBuAAsAaAEPACUAkABUAAUALgAHAKwFBwDIBQgAegKMANgBiADBAwQADAKIACoDCgDuAI0AIQCECpECmAoHAIUAFAIFAOUDhwqBBgcLUgIHC1MDBwtCBwkLmwEJCz4CCQuaAgkL4QIKC1oBCgvIAgsL9gALC7ABCwsFAgsLhwILC6cCCwvXAgwLMAEMCzEBDAtDAQwL4wEMCzwCDAtRAgwLWgINC18ADQtlAA0LqwANCzsBDQt6AQ0LqQENC9sBDgs/AA4LfAEOC4ABDwuFABILcACUC0gABQu7A4gLLgOGABUFBQpCAAcKaAeICiABhQs4AIYKawYGABIFlAtkAAUADgMFAD0DBgCfAgYAhAQGAMoGiQttAgQAMgEFADoCBwBDBQUKWwAFCogCBQruAgUKDQMGCjYABgpwAAYKkgEGCsQGBwo7AQcK7QIHCmwHCQpOAAkK/AEKCmMCCgorAwsK/gELCtgCDQokAA4KJwAQClMAEQp8AJQKHgAICjoCCQvdAY0LTgAEC38CCgsEAAoKQgEKCs8CCwqXAQsLfgIMC7EAlAs5AAcAHweLALUCBwD3AgUL9gIICn0ACApxAQgKDAIKCuYBCwoNAAsKfQELCuACCwr+AgsKTQMNCnIADQokAY4KLwAHAIwHBgqUBgYKwwYHCmQBCAo2AAgK3QAJCuEACQpkAQoKTQAKCr4BCgrbAgwKlAGNCusBhwsoAocLWAQEAE4ABQBgAAUAtgAGAOkEBwC8BgcAIQcKAIoBCgDXAQsAFAIOAFQBkQBYAIsLSAGHAKwHhAqbAQQKUAAFCiwAiQuFAAULbgAGC6kABgumBgcLkAEICxoCCQu4AAkLDAKMC9oABAAJAgUKKwEHCjsEjAsqAgYLhQAJC2EBDAt0ApILTwAGANcABwBIAgcABAQHAMEFBwC5BgkAqAGKAAsDBwBZAwcAuQQHCrEGCQoZAgoKpQAMCtsAjAoxAgQK2wAGC10ABwuOBQcK4QYHCzsHCAuhAgkKVgAJCxECjAsrAIkLcwGIAJ8CBQBIAYcAlgOEABECCQsZAAoL0wGKCy8CBAtPAYcLrgOGAMwChgDlBQYAQwAHAAIBBwBeBgkAYgEJAKMCCgA+Aw4AUAARAFAAjAqsAYYAWAQGAI0ABwDhAAkAOwAJAF8CCgA4AQsArwIMACsCDQB1AQ0A7gGUADoAhQoCAggLJwAKCwUDCwtUAAwLzQCOCwEACAAPAwULWQKFC2YDiAtSAgQKNwAFCi0BBgo7Ag4KMQCSCmYAhAu1AIYLdAaFCmwBBAthAAULkwAGCx4BBwtSBY0LsAAECkwABwoOBgkKMgEJCq4BCQqXAgoKqwILCqsBCwrxAgwKTgEMCroBDgoCAQ4KbgGPCoMAiQo0AAYAuwOGANoFBgt3AQcLqQAHC/4AiAsMAwcArgELAC4ADgBXAY4LVwGHAJ8EBQBaAgcA4gcJAKIBCQAjA4cLpwUIAKUChwsUBIsLHQEECpAChwoLA4cKkAAFC3UChwsNBocKXQWKC9EABwoqAgcKXQKNCgoABQpGAwUKSQOGCnEGhQr0AwYATQWGAGQFkAA1AAYATgIHCm0BBwpNBQcK2QUICpoAjQoZAYUKVAGEC6QBhwBJAZMLIAAEANUBCgutAYsK7wEICgUBCQqQAAkK0gEKCnIBDArWAQ0KkACOClwBjgDMAQQLRQEJCoEDigt9AAYAzwYGCvgACQoiAgoKFwILCqkCjQqHAAQA3gMFAKEDBgBUAQgAeAEIACcDCADDAwgA1AOKAO8DhgBDBowA+gAEC8oChQvVAYYKNwKICr0BBQDaAAcASgYIAIYCCgBTAAsLigCMCygABwDoBYcAAgeHC8AECwAAABAATgCEC84ChQA7AoQAxwGGAPQDBQt8AAULkAAGCyQCBwsPAAcLmQCJC3UCjgsKAAYLSwAHC/sFCAugAQkL8AAJCxMBCgtkAAsLkgILC9MDDAtWAA0L1AEOC0IADgvPAA8LFAAPCxkAkAs6AIQKQQIFC40ABQuTAwYL9wYHC9MABwu6AgcLSQUJC1MACQsZAQoLeAEKC68BCwsfAgwLmAINCxgBDQusAQ4LPQAOC4AAEQs0AJELUQAGAKEABwB0AYkAVQKEAF0BCgu+AosL9QCGAAwChgquAAYAsAEJAO8CiwBCAZMLXgAEC1IBhQuQAQUA1AEKAEUBCwBYAwwAWQGPAGgAhQDfAIQANgIEC90ABQuTAgUL3QMHC7kCBwu7BIoLHAGHCy4EBAA7AIcAcgUGALQBCwDhAQUKbgOFCswDBAAwAAUADwGHALkDBQBiAogAyQEEAAUDBQBqAokA9AKFAPMChwDBBIoL+wGECl8BhADFAI8LTgAEC7wABwslAwsLFAGOCyUBBQt0A4sL3wOECh4BCgADAQoArAEHCrYBBwpzAgcK7AUICigACQo4AAkKJgELCskDCwrjA5IKlAAEAGQBBQDZAAUA7AEFAJACCAAgAogLIAIFAAMBBgDOBAcAngEHAFYDjgBrAIQA7wMPAA4AkAAFAAYALAaECuIChAtUAoQAoQKFCmIDBgAzB4cLNwcEAKUABwB2BYcAJQeHC2IGkwtBAAYAdQMGAPEDiQApA4UKdACECskBiAsCAwkA8gEMALUACgtpAY4LPAGGC1MCBQAJAAcAKQEHAMYDjAAyAQQLWQAFC+kBBgs7AQcLKQIHC9EGigvzAIYAzwWEALUBBQCSAAYAmwGKANECBQoPAgYKvQCHClsDCwpoAAsKKgIPCjwAjwp9AAYLegYJCwMACguaAAsLgQINC1UADQvJAI0LWgEGALEAhwDTAYYAYQWGCnQAiAuFAgQLpgAFC/kBBguGBokLbgCFCucBBApWAAUKmwIFCvECBgo8AQYKxwGHCrIDhQDIAIQAvwMGAIgHhgClB4sLywCWCi0ABApPAAcK7QYKCsIBCwpNAg0KTAENCu0BDgq3AA4KTgEOCmoBDgpwAQ4KeAEOCnsBEwpaABMKZwATCn8AlApaAAYAmwWHC/sEhgDhAQcLvQEICzMBCAvAAgoLKQAKC7cBCwvtAAsLbgKMC8kAhwtlAwQAVAAHAMoFCgBMAIoAjgALCxUBkAsOAIcLuQcEC70ABQvJAogLOQCFAPcDigtzAQQAOwEFAPsBhwBaBQQLKAKOCn0BCQD3AhAAHwAQACcAEABLABIAGAAUACoAmAABAIYAyAKGALoGhQqXAoUKTgMIAN4ACADcAQkA7gALAAQCCwA/Ag8AbQCSAGQABwB6BQcAhgUMAMgBBQp6AQgK0QEJCh4BCgq5AAoKMgIKCnsCCwofAAsKiQENCjgBEgpBABIKYACTClkABADaAwYApgcGAPAHCACmA4oA2QMHClgHCQqoAosKHgOGCuoGkQsxAIQLZgKECogCBQqxAwYKeAYGCvsGBwqnAAgKOAMJCocBCgp3AYsKuQCKC5UCBwD5BIcLmQcHAMICBwAiBIoAGgIHCm0GCApgAYkK+QCECpgACwBcAAsAxAALAJkBCwDCAQsAmgILAAkDDAAGAQ0AgQENAIkBDwBzABAALQCRAFIAhQruAwYAKACHAPUGCQtmAosLRwEFCqQBhwqpBYcArwEKAGEAhwpAAwYApwEHAJkChwC6BAcA7QAIAJgCCQAqAAkACgEJAHwBCQCFAgoAsQCKABQBBwAIAYUKXwEIANUABQooAAcKVgIHCmYGCQqmAAkKgAIJCq0CCQoFAwsK1wANCkEADgqsAA4KPQGRCgYABQtUAIYLowAICjwACQpXAYsKAQOJAMcBhQuaAQgAigMMALwCDADCAowA2QIVCyEAlgsoAAcKnwcICv0CCAoEA4wKnwIHCmwACArbAAgKhAEJCn8CCQoHAwsKEwGMCtABBQtCAQcLlQcIC7oACQsGAQoLuwAOC9AAkguCAIsAcAIIAD4CBQvjAIwLHQAHCwoGCwsrAY4LlwEFCg8ABgo4AAcK3gYICvQBCQraAgsKSwENCpYAjgoaAQcLcwUIC+YBCQvsAAkLbgMKC9oACwtfABMLEQCTCx8Ahwv7BwQAYgGSCwQAjAtQAIcAFgaGCl4HBQrNAAYKtgGJCscChQsKAoUKFgIHAOsABwDDBQ8ARACSAHgAiQqzAgQArgMGABUHCACVAwoAdAMMALgCDADNAgwA0wIMAOICDADtAgwADAMQAGEAkgCpAAYKuwEICzICCQrtAAkKOwIJCrcCCgqLAAsKywIMCqEBjQqlAYcAvQOFAD4DhgvrBpIAFwAFAPABBgC2AgcAywAHC6YEiQtsAokLhAAGACMChgANBggLAgEJC9AAiQtnAQQAYAMFAFgAiQDvAIcL7QEECz0Bhwv/BIQL3QEECkICBQs/AIUL/QEHAIoChwAeBQcANAQJAFAACwBOAAsApQELABYCjAAhAoQLIAEMACkCDgB2AIUKmwMHABIBCwDfAYsA+wEIC1kACAtsAgkLMQAKCwYDCwt0AgwLQgGPC3wABADxAYcAMAYHAAUBBwBbBAcASgUHAHwFBwA0BgcAqQYHAG4HCQDRAQoA+AAKAF0BCgCHAgsADwILAJQCCwCdAgwAEQINADEBhAqcA4UKmQKIAA0ABgAXA4oLeAAHAIICCAD6AAsAewALAIkADQAwAI4AXwAECgkBBwonA4cKtgMFCl0AjAoLAYcAlQUEALUDCgB1AwoAewMKAIQDCgCrAwwA+AKOAMEBiwtuAYQAMgOGC1UAhwriAwcASgEFCukABQpAAQYKjACICicBBADsAwgA1gOIAOEDhQrSAwQKiQMGCqUGiQpLAwoAIQKMAC0BBgCzA4YAJgSGAKQEBACIAwUAGgOYCgYAhgBcBYcLYAIFCxcBBgvrAAcL1AEIC74BCQt9AgoLzQILC+ICjAsCAoQK/QEFCxEABgtzAYkLEAKEALUCBAtzAAULnQIGC5cBCAs3AQsLCgCNCwUACwB5AQcKEQGJC30BhwC3AgcAggGKAMkChwoRBIYACwUGAAcABgAjAAcAkwAHAC0EBwAgBgcAJwYHAH0HCAArAAgA0AAJAIAACQBiAwoAFAALANUDkwAhAAcAfQONAKgBiwrqAJYLOAAFCwsDBQsnAwYLdwaGC4wGBQoiAwcK5QeICiUDBAvEAAUKpwAFCy4CBQqDAwULtQMGCpoBiQoJA4kKFQOGCqkGCACIA4wAEwMGAEIBCQAoAgsAEgENANEADQDzAQ4AVQAPAH4AkQBGAIcKCgAFCgsABgp1AAYK5QEHCm0ECQpGAgkKUgILChUACwoyAwwKFwKNClYABAoIAQcKKwQICswACAqBAYsKuQOEC/ACigo4AIUK1gEGABAHCABTAAgA5gIIADEDCQAcAAkAHQAJAHUDCgCDAQsAeQILAOQCDQDrAA0A/gAPAI8AjwCSAIwAMQCGACgHBAvjAAULnwAFC5kBBwtQAAoLJgEKC98BDAuiAQ4LMgAOC/kAjgsnAQcLvgUIC0IACAuJAAgL+QIJC34CCwtQAAsL1AALC3ABCwuiAQwLCAANCw8AEAs9ABELOwATCxwAlAtUAIsK9wOKC9QBhwClAQYAnwEHABkEiQC6AQYLJgAHC8QECAu5AAgLAAEJCxYACQtLAQoL4gILC80ACwscAgsL6gINC48BDQvRAQ4LWACOC8IAiwAhAYUKywIEAG4ACgCfAQoAVQKOAM4ABAufAAYLcwAHC/wABwsBAQcLiAcIC0UACQuAAQoLWwAKC2cCDAt3AQ4L6wASC3UAkwt7AAULjwOICxYBBwDNAAcA0AcIChoDCQqQAQoKKgGOCuQAhwvuBgQLlwAHCx8GCAtfAYkLQgGICtQChQveAwcAAwYLAAACDQDNABMAHgAWACQAFwATAIcLAwYFC8IABwt+BgkLWgCMC7QABgq+AAcKAAOHCpIEhgA8BQQAGwGHAKoEhQupAYULywMMACUCDgpDAJMKPACHCv8DhgC4BooLSwIFC0gABgsIAQcLFQAHCy4ABwvdBwgL1wAICwECCgsKAYsLFgAFAD8BhwAWAgYKiQAJCksACQr9AAoKwgCKCrwBBwCcBBQAcAAGC+8ABwt2AAoLXwALC1sCDQu7AQ4LoACPCwQAhguvAQULagMGC40GCwqDAgwKcwCPCwAAhgDHAwYLQQAHC6sDBwuUBAcLhwYJCxwCCgu4AgsLCQELC9wCCwugAwsLqQMMC48BDQu2AZULEwCJC8gAhwCUBwUK+AIHCh4CCAqHAIgK8AGMCywABwt3BogLMQEHCj8BBwpjAQcK+wIKCoUBkQorAIgA3wKKChIDiQsTAIQLuAIFAIQACQDmAQkAywIKAMoBCwB1AQsAnAILABsDCwCBAwwAEAEMAKgBDAAbAgwALgIOAPUADgAHAQ4ACAEOAIkBjgCTAQoAJgCLABADhABGAwQLLgGHC+YGhQB7AQUACAAGAFkABgCQAQcAIQYHAFcGBwA6BwgA2gAIAKYBCQA6AgoAcgIEC9YChQt2AgQA+QOKAJQCBgCDAQcAcgONAG8ABgDgAAcAbQOJAIcCBAo6AAUKHgEGCj8BBwqSAQcK5gQHCm8HCApkAYwKmAGHABYDCQD+AQoANQAECoUBCQq1AAoKHQAKCjADCwo3AQsKMQIMCkMAjQq1AI4AygEGC3YABwvXAAcL8QWMCwsAhgC6A4cAigGGAFcFBQvhAIUKdQGEAHIDBwCBBYcKtAeHCgEHBAtyAQUL9AKHCy4FlgsNAAcLYgEKC5oBiwsvAwYLfgYHCzAACAsDAwoLdAANC2gADgtpAA4LuAAPC6gAEwtcAJQLRAAHAHwAiAAmAAUABQEHAE4ABwDHAAgALwMJAH4ACgBWAYwAhwIEAHQCjADUAgcACgEIACQDBwpzBpEKWQCHANAAhgCaBAYATwCHAO8FhAqgAoUK4QKIAOUChAt4AAQAxgIGAHgBhgBeAoYAQwWGANYFBgBSAwYAEQaJADUDBQqRAIYLUQIHAB8FjACHAAQA0wEFAJUBhgAgAgULNAOHC6MDBgBkAAcA9AAHAHgCBwBJBggAsgAIAH4CjQA6AAQKgwGHCggFBguXAAYLiwYHC38BlwsKAIQA4QGHCiYChgBiBQYLWAYLCwsADAumAQ0LBgGOC2gBhQAXAwQLKwAFC1gBhQtlAQcAywSMANIDBwCuAggAIQAIAO4ACgBoAgsA0wELAHEDDQDZAA0A/QCOAAwBiQBZAwgA0wEIAO4DBwuUAAgLHAGNCz8ABApAAocK7wSFC3gDBQqXA4YKiQYUCiUAlAslAIQAvwGEC8cCBACAAAUAnwEGAM4BBwAmAQcAQgIKAMYCiwBWAAQKUgAFCk0BBQqIAwYKzwAHCkUBBwq+BggKZQAKCgoDiwrcAIgASwKJC7gBhQqHAwYAqwEHAPoDigC0AgQAwwCHACIDjAqTAIYACgaGAKwChArBAogAWQELC6YCjAszAYUAbQGGAJMGBAtBAAUL3wEFC+wDBwt5BwgLPQEJCy4BCgtkAo0LFgCKANgBBAsFAYcL/gGGCloAjgCxAZcAHAAECyMBBwtlAAkLAwIMC5gADAu7AQ0LiAGOC2UBjADlAwUAAwAIAEICCQB2AAoAwQKNABcBhwvyBAcKLQMMCvEBjQo4AIUA5QAGCn0Ahwr9BAgAZgAKAEICCgCgAgwA8AENAJgBDgB5ABEAagCXCgwABgBiA4YAOASIAP4DBAuCAIcLSwMFCyoABQtvAwcL9QAHC0QBBwv8BQsLzwELC9gBDQtrAZALNACWADcACABzAAgAXgEJAOkBCgCAAAsAMgEMAHUBDgAeABEATwATAFAABAuGAIULdAGGAJEChgClA4cLewQEAOYAhQC+AoYAwAYEAOQBEgAaABMAKgAUACsAFQAAABcAGwCYAA4ABwC5AIcAvwIGAKEBCgBqAgcKUgQJCgIDCwpwAIwKnQGGACMDhAuEAoYA7gQHCxwCDAoPAZEKbQCHC3sAhAB5AoYLbwIEC4wDBQtnAQUL/AEGC7sGBwtXAQcLzAeHC+oHhwDfAQoABgEHCjABCQqGAgkKXgMLCrgCDArQAA8KTwCTCmwABAtVAYcL4AGGAD4DBQBGAAUAbgIGAE4BBwAIBAkAqwALABoACwDVAAsAfQILAMMCDADKAAwAfAENAOIADQBjAQ4A3gCRACoAhwrVA48A2QCJC3IABAAXAAQAjQAFADkBBQD2AwYAMgAGADMABwCOAAcAgAEHAC8CCACAAgkAzAEJAA8DCwDlAgwAtwCNAOgBjQBoAQcAMgYHC8sHCAsrAQsLegOMC6IChAqyAQcAjAKGCiYCBwD+AgUKKQKKCjgDBwDhAggAKgGICsQBBAvuAAUL9wEGC7MABwvTBwgLfQEIC9kBCQuVAAoLtwAPCy0AjwtWAIUKJAEFAN4ACQCPAooAFgKKCocABAt5AAULnAAFC10BCQuIAAoLXQIOC1YBkwtrAIkAigMGAPUDhgDiBAYApAcGANkHCADfA5AAeACHC6gEigD3AQUAmgAHANMFCgB7AYoA5QEGAEsHBgB6BwYAhQcJAJUDCQCdAwkApAMJALcDCQDvAwkA9QMMACYDDAAqAwwALgMMADADDAA4AwwAQAMMAEUDDABfAwwAZAMMAGYDDAB5AwwAfAMMAIQDDACGAwwAjAMMAKUDDACuAwwAtQMMALoDDwCvAA8AywAPANUADwDaAA8A4QAPAOcADwDvAA8A+AAPAPwAEgC+ABIAzAASANcAEgDYABIA3gASAOEAEgDmABIA7wASAPEAFQAqABUAKwAVACwAFQAtABUALgAVADUAGAAbAJgAHwCFAMwChwBMAwQAWwAFAIQBBQBNAwYAzgAGAPwABgBtAQcAiAAHABMCiABtAgcKiQEKClsCiwrOAAYLUAAGC54GBwutAAcLtgcJCyMCCgvaAg4LEgCWCycAiQDsAgQLmwOGC68GBAqQA4kK6AAHCmIABwq1B4gKzAIOAGcAhQrdAoQLUwIMAJ4AEgAIABMAPgAUAAYAFgAEABcAAgAXAAkABQvwAAYLywEHCwwABwtyAAcL9gEHC9cGBwvZBgcLDQcIC5ICCQsBAAsLvwMNC74BjgvTAIcAQAIFAAMDBQBfAwUAggMGAIgCBgBgBgYAbAaGAPQGhQBLAQcLeQIHC4kDBwuNAwcLAgYJC/8CjAt8AowAeAIFAGsABwDJAIgABgIGAL4BBwAZB4YL6gEJAFMDjQD+AQcL+gAIC/oBiAv7AQQA+AGJCkgAhAueAAQLjAAHC2oBCAvRAAkLCgAJC6AACQv3AQoLsQILC14BCwspAgsL1QIMC/wADAtHAg0LwAANC2ABDgsNAQ4LZAGUCzIABgtVAocLJgWHCq4FBQBzAwUAzwMIAIgBlAAHAAYL5AAHCz0FCQuYAYoLVwELC1wBCwpYAgwLYwANCvUAEgsBABILCwCTCwQAhgsoAQUAmgOGAKsGhAstAgQLJAIHCqQABwojBgkKawCMCuEABwvFAAgLjgAIC0UBCQuWAAkLVAIKC14BCgthAQsLSgALCzsBDgunAY8LjQAFAOEDBwADAokAWwAEAIMACADIAAUK5AEFCv4BBgqyAQcK6AMHCkoEiAoCAJgACgAECz4ABQtTAAYLjwEGC0MCBwu0AgcLTgMHC/cDBwsHBwgLkwEJC4oBCguFAAwLBAAMCykBDAvEARALUQASCxMAEgsZABULDgAWCwwAlwsSAIwLywGEC7EABwCZBQkAbQGJC20BhArMAQUAZwAGANQHBwCZAwgARAIIAFECCAB2AgoAHAAFC5sBhwuNAgQKpAOFCnsDBACPAwUAYwMFAPUDBwDyBwgAHgOIAC0DBwu3AQoL1wILCwQBiwusAogKcQIFC9AABwvxAocL+AUFAM0BBwCFBwwAJwANAAkBDQC3AYYKTAAGAFUDCApcAIkK3QAFAIcABgAHAgcAugYKAA8BCwAFAZEANgCLCy4DDgBSAZQAUQAEACwBhQC0AQUAowEFAK8CBwBgAwkA1gGHC2ADCQBEA4UL8gCGAJEHBAr7AoULuQOECm4ChACJAYUK/QAIAGUBCgDpAg4AqgERAF4AEwA5AIcKIgIFC2cCkgslAAkKSQAKCm4ADgq5AJEKdwALAL8CBwpwAgcKlAMKCgABiwpXAIULIgEFCtQADAojAI0KfgGEC3wBBQs0AAcLFQEJC3ABiwsXA4UAgwEKC4oAiwvcAQQABgAFAMQCiABLAAcARwUJAEUCCgB/AgsAxQGMAEgChAAvAYoABAOHCpcEBADtAgUKMAMGCwABBwszAQcL5wMHC8kFBwvEBgcLygYICwkBCQueAQsLPAEMCzQADQukAZMLZACHCxAFBgApBAUKZQMFCsgDBgpaBggK3gKIChADBAoeAgYKtAYGCr8GBwo6BAcKCQYICjgACAp2AAgKnAEICjQCCQp4AwkKjAMKCjIACgqnAQsKrQILCrkCCwqlAwwKKwENCn4ADQqIAA0KqgCNCr4AhgDiAAQAagAHADYBCwDNAoUL0wIFAHoDBQDcAwQK6AAJCsoACgraAYwKsQEGAHICjgCvAQoAwgKWACwADQAzAAYKbAAHCusDBwqdBAgKbwCIClcBhAC6AgULbQAGC/gGBwtnBwwLKAGMCy4BhgA8A4YKsAaKABEABwCJBwQKhQAFC9gABwrHAgcKEgUHCjEGBwtXBwkLjQAJCw4BCQunAgoLnwAKCykCCwvFAAsLtgEMCxoCDAsvAg0LwQANC6cBDguQAA4LpgAOC6cADwtDAJMLVACNC38ABwtQB4kLUQAGCmMABwoQB5EKOQCGC4cBBQCxAgYAVAAHAOIEBgo+AgcKrAEKCp0CCwrlAQsKSAMMCiwBjgr6AAcLQgGIC/kABwuwAYcLcQaHCk8HiQr8AAYLmwCMC+oABwBnAxMAGwCTCxsAjADyAQUA2gMGAIIAigA3AwYAAQcHAC4GCADKAQoAZQAKAD4BCgCxAwwA3gIQAGgAEgCxAAYKQwGHChwGBQt4AooLDgIKALMBBwrNAYgKBwMGC5AABwu0AwcLEgQHC0EHCAvrAAgLzQEJC8UBCQsSAgoLYgERC00AEwtjAJQLTwCKAMYDBwBsBokAgQCHAOUDiAD2AQULxAAGC+YBBwvUAAgLNQGIC1oBBwrXApIKSQCEADcDhAuuAocAhwcEAPoCBwDcBokAYgCICkECGAAIAAQLHgAFCysAmAsIAAcAFgSLAKAABwDsAQQKnQEFCqUCBwvsAQgKsAGMChgBBgAtAAcAsQEIAIEACQAVAAoAiAELAE8ADADzAQ0AxwCNAMMBBwAuAogAYQEEC9wABwv/BQkLXQCLC9oBBwqGAgcKwgYLCr4BjQqyAIUAEQOGAHkECABRAAkAvQAJAMkACwDeAQsAyAKNAFIBBQBhAZcAGgALAPoChAqLAYYA6AcEAGMChQBeAgkKrgAKCqQACwq4AQsKSQOPCmIAhgqqAQoKYAKLCuoDigr6AAYAGQAHAFcDBwDqBJAAIAAHC70GiguJAQULBwGGC54BBgDbB4UK3AEEAAQABwBeBAcAKAUHAKoGCAAVAQkAbgIKAAkACwDUAgwAXgEMAI0BDQAcAA0AnwAPAFkAEgAFABMACQAUACIAFgAvAAYLsgAGC9YGCAv7AAkLsgIKC5sACgvEAAoLdQELC7oCDQubAJQLXQAFC2EAiQuJAQcA/AILAM0BDACsAAUKTAAGCsoBBgrxAQcKZAMJCpICCgpSAgsKNgIMClIBjQrIAIYAqQWKCygAhgtnBoYApQUGAJAEBAoOAgcKBQSHCh4EBAu/AAcLpgMIC4cCkQthAIQKfAIGAOkABwqUAgcKZAQRCh8AEwoWAJcKDgAGCqMGiAtuAAwL9gAPC6IAEwtAABQLCAAUC18AFgsYAJgLEQAFC6UACQtaAYoLjwIFCz8BhwsWAoYA/wAJANgACAuAAIsLswAJALcAiwAeAQsAvAOXAAMABAAYAgcAdQQKANMCiwBzAQQKFwEHCi0BiQpqAQcAHQEFCzkABgtlAAYLfwYHC4QABwsYBAcLggQHC4cFBwvjBQwL7QEPC2kAlwsPAAULywEHCzEEBwrPBggL8QCIC04BBAqyAIUKjwGHADAChACyAocA3gQSAJ0AkwA/AAoAVwILACEADAA7ApUAAQAGC0QBBgsIAgcLUgEHC1AGBwvBBggL5AAJC0UAiwvuAgcARgcMAOsBDAAIAg0AfwGOAPQAhwveAoYKnAYKAMABCwB2AhEAdQAGCsoABwvBAgwKaAERCnYAEgobAJQKQwAEC0kABgtkAgcLnwMHCx4HCAvZAAkL2AEJC/0CCQv+AgoLmAELCzMACwsZAwwLCgEPC54AFAtZAJYLIAAEAL4AhQAqAoUA6QMFC4UBCAt8AokL5QAFAL4BBwpoAwoKBAKLCqcAiQo5AYQK4ACGACEFBQoiAgcKIwAICgsACAoMAAkKOwEJChUCCgoiAwsKpgAMCg0CjgrzAAYAfAKJAEUDBQrxAAgK8gAJCsMBCgqbAgsKVgKMCq0BFgouAJYLLgCIC9gBCwAWAY4ASQCNC7kAhABkA4YAzAMECm4BiQoEAooA8gMFC70ABgrIBgcLugEHC7sBCAsZAQwLrgANC1MAjQsFAYsLgAEGCwIABwu/AAcLvgEHC/YCBwvuBAcLyQYICxYACAsOAQgLZAIJCwQACQunAAkLOAEJC7QBCgucAAoL2AAKCzcBCgtvAgsLSAALC0oBCwvHAQwLZQAMC0EBDAv4AQwLEgIMCx8CDQsRAA0LnAANC04BDgswAA8LRgARCzwAlAtAAAYKSwGICm8ChwDPBIQAMAEGCzwABwueAgcLLwUIC5sBCAuzAQkLjQIJC+QCCguBAQsL3gALC0QBCws9A4wLYwIHAPoBBgumAAcLdgGHC5YEDgsrAJILFQCHC54GhwpgBwULzgCGC44BhwsyAJYAGgAGADUABgDHAAcAgAUIACAACABdAAoAjQEKAHUCCwBRAgsA+wINAEYBkQAjAIYAaQCECooBBABLA4oAGgMLAMACjQCMAQUAcgAFAP8AjQAdAQYAawIHAIIDBwBEBAgA5QESABwAEwB0AIcKiwcJAJEABwo+AocKtwYHAPMHCAATAAkAWQCKAD8DhAqSAgYLBQIHC4cECgttAosLwAAHAI0HBwuNBwkKDQMKCpAACwqBAQ0KoQANCuQADQoMAZQKawCICnYBCgvfAIsLhQKHAMAGBwtAAAcLIQGIC/UABApYAQYK8gGLCkMBiADqAocKJwSJCpsABADbAwYArAcGALYHBgDGB4gA4wOFC2EChQqKA4YADgaGAGoDBQuBAAYLPQCHC7MDBAD6AwYAkgcGAOUHhgD3B4QALgMLAH4AiwAfAYYA8AQFALsDiAAuA40L+gGECzoBBgDVA4sL6AMFADgACAB8AwgAkwOMAAgDlABkAAoABAAKAA0ACwB+ApQAOQCUC0oABQDiAoQKaAKFC30CiAq0AoUA9gKECjEBiQtOAgULGAGHC8oEhgvuAYcAWASFCxkBDQAsAA4A1gAFCtYABwpbAggKYwIJCq4CCgpYAAsKywELCvABDArPAYwKTgKLAEgBhwsoBIkAhQAHAKgADQDEAI0A7QCGCqcGhgCABIcA3QQFAG4ABgCpAAYApgYHAJABCAAaAgkAuAAJAAwCjADaAAYAGAcKAGcDDAABA4wAEQOEC3YCBwshAAcLeAAIC+kBCQs/AQoLNAMLC+wDDAt7AQ0LdQANC5wBDgsZAA8LNAAPC6EAEAsvAJULAgAGAIUACACdAQkAYQGLAOEDkQoTAAQLqQOFCyEDhgDSAwYAXQAGAOQFBwCOBQcAOwcIAKECCQARAowAKwAGAD0BCgAAAgQK4QILCiYBDAo8AAwKtQENCkAADQp8AY4KrgEJAHMBBws3BpALKwAGCt4GCAoIAgkKWQEJCpMBjgpeAQUADgIKCvIAigpDAgkAGQAKANMBigAvAgUKiwAHCpAEigobAgQATwGHAK4DjADyAoQLbQELALYAjgDDAI4LHQAFCwcAiwsGAwQL6gKHC0IECAAnAAoABQMLAFQADADNAI4AAQAFAFkCBQBmAwULaAGIC+0AhAC1AIgAcgGGAHQGCABmAQQKawAHCmUCCAq3AQgK+AEJCvUBCgp/AYsK3QGECuUAiQsRAwQAYQAFAJMABgAeAQcAUgWNALAABgAZAgcAFAMHABgHhAqHA4wKRwAGAOcChgDHBAYAdwEHAKkABwD+AAgADAOHC9UFBwCyBgQKLwAGCnUBBwrEAQcKHwIHCkAHCQoGAAsKAQGLCocBBgCAA4gA6wOHAKcFiQtVAQUK1AOGCtoGkQsWAAQLFQEFC2ACBgvtAQcLyQGMC4ABBwoYAgcKMwWICo8AjADoAgcLGwCHCzwBEgB+AAUKEwCGChUCBAAUAwsAKQAFCygCBQtKAgULpAIGC8ABCAv0AAsLAQALCykADQsDABALNgARCwQAkgsNAAQA2QMGAAkHBAuRAYkLCAEFCosBBQq3A4YK8AYFAHUChwANBgsKlwIMCtIADQqmAA0KNgEOCnUBkworAAkLHwIKCwwCCwseAAwLDAIOCzsBEAsSABQLGgCUC0EABAvNAAULbwIHC2gAiAsHAgUAJQGGAFkCBwtDAgkLKQAJC/QACQudAgoLBQALC10DCwu3A4sL1AOEC80ChAq3AgcK8QEJCoMBkwpRAIQApAGOACUABgBuBAYAbAcMAD4DDABuAwwAfgMPAN0AjwD1AIQL6QEHACIGjAAeAggApQOIAL0DBgBbBQcAHwAIAHUBBQocAQYKMQAGCl4BBwp5AQcKnQYICqYCCQqhAAkKSQIJCp8CCQpHAwsKkAONCqsBhwt8AwQARQGKAH0AiwsvAIQKVQKKAEMBBgALBgcLRQYJC9kBCwvCA5ILiwCLCowDBwszAwkLGgAJC4gBCguYAAoL4gALCxMADAsUAQwLqgEMC00CDQvMAQ8LYQATCzAAlAtoAIcLMwAEAM4ChwDABAYAaAcGAHEHBgB4BwkAswMJAM4DDAApAwwAUgMMAFoDDABqAwwAdwMMAIgDDAChAwwAtAMMALgDDwDGAA8AzgAPANwADwDjAA8A9wASALwAFQAwABUAMgAYABkAGAAdAAcL+QIHCxsEiQshAgUAfAAFAJAABgAkAgcADwAHAJkAiQB1AocLXgKHCt4HBwrXBwkLLgAJCmUACQrCAQoKQgAKCkoDCwoYAowKSwIGAEsABwD7BQgAoAEJAPAACQATAQoAZAALAJICCwDTAwwAVgAOAM8ADwAUAI8AGQAFAI0ABQCTAwYA9wYHANMABwC6AgcASQUJAFMACQAZAQoAeAEKAK8BCwAfAgwAmAINABgBDQCsAQ4APQAOAIAAEQA0AJEAUQCEC6IChwAVApUABgCECwIDhQAaAgULTwAHCwMEBwvFBYsLNACLCj4ABABSAYUAkAEFCxUDhgvDAAQL+wAEC7ACBwsBAgcLBAUJC1cAigttAYYK5gYGAAAABwBUAAsAfwORAAsAiwB8AwQA3QAFAJMCBwC5AgcAuwSKABwBhQDdA4ULeQMEC6AABQtKAQcLmgWIC64ABgqBBgcKAAEHCmwFCgrzAYsKngIHAFADBAoWAAUKCgCICmEAigD7AYUK4QEEALwAhwAlAwUAdAMGANwCiwDfA4cLyAMLC3wCDwuRABELIgATCzIAlwsUAAcAvwMQADwABgqGAAcKtQEJCiUADgodAY4KcwEHCuYBCAqbAAsKXQCMCqQAhgB1BgcAUQGFCk8CBgDFBwgAmgMIANIDhQt2AYQAfgKKAPQBhQvbAgUKfAEFCooCiAo2AYoLfQEECmwBBwqEBAcKowSJCpkBiQvgAIwApgCGCuIBBAtyAgULggIGC6kBCgvKAIsLjQAECg0DBgrnAQcKngMICgcBiwr0AYcAogEECl4AhwrxBIgA+AKECqEBiAtDAwUKXAGGCgoCBgD9BIYAAgaLCx0Chws9BgULgAEIC8cBjAswAIgAAgMFCwgBhgu4AAQAWQAFAOkBBgA7AQcAKQIHANEGigDzAAQKmAEECuUChwr0AYYAdAWFADACBgB6BgkAAwAKAJoACwCBAg0AVQANAMkAjQBaAYcLOwYFC3kCBgscAAcL2wCHCysFCQsBA4wLuQCHCxEDBwtnAQgL8wCMC68AigBKAgcA9wSGCkkAhAtpAAQApgAFAPkBhgCGBoUKQAIEC0QBigtoAI4K5wAGAH0CBwrwBAcKjgYLCrEDDApVAQwK1wEMCjkCFwsVAJcLFwAICy8CjQttAIYAmwcHAL0BCAAzAQgAwAIKACkACgC3AQsA7QALAG4CjADJAIcLwwOHALkHBAC9AAUAyQKIADkAigBzAYcKGgKEACgCBgBzA4UKnQEGAJsDhAv2AooL1wCICu8BBwo2AAgKOAEKCr8ACgpmAowKNwIHC18BiwuAAAcAawMGCtQBBwrGBQgKEgKOCiIBhwD8BhEAMQCFC5YDDAuOARQLJwAVCwsAlgspAAoAlQIGCuQBhwo2A4cAmQeGABoDiQqEA4cKNwUGCrwGhwrmB4QLVAGGAG8EBAAQA4UA6QIFAFQAhgCjAIUAmgEEANADBQvZAwcL/QEHCxECkQtgAIQK2gGGAL8Chwt/BwUAQgEIALoACQAGAQoAuwCOANAAhwrgBYUA4wAJADACDQDQAIUKMQGEC/cABwBzBQgA5gEJAOwACQBuAwoA2gALAF8AEwARAJMAHwAHAPsHCACgAo0AwAEEC7gABQuGAQYLUQEHCxcABwvuAQcLagIHC7AFCAsbAAgLVwIKC5kAiwvGAocA0gGHCtQEBgCnAAcAugAHAJACCgCDAgQK4AEGCi4BBgpqBgcKRQMHCgsGBwp5BggKrQEJCuQADQohAQ0KVwGTCmUAhgCUBYYAoAUFAJwBBwoWAQoK4wILCsQCjQpcAYYAXgSIADIClAsuAAkAPAGLAAABhgDrBocApgSJAIQACgvjAAsL8QELC8UCjAufAY8AQgAGC2gBBwuABogL3gGQChwABAA9AYcA/wQFAD8AhQD9AYgLuwKRCiQAhgDDBQsLVwGOC38AhAvjAoQAIAGHC90GCABZAAgAbAIJAGACCwB0AgwAQgGPAHwAhgDJBAcApQQEC0MABQumAQYKawEHCw0EBwsJBQcLEwYHCqMHCArVAgkL5QKRC2wAhgC8BQYAsQKGAKsFigB4AJcAAQCJCiUDjgBJAQUKLQOHCv4HhwDiAIoLYAAHAD8HBQrIAgsKEQANCkEBkApDAAkAzQEGCkABBwoNAwcKgQcJCjcACgq6AAoKEQEKCpgCCgohAwsK5AMLCuUDDQqdAI4KqgAIC8sACAoPAQsLNwMLC04DDAviAQ0LhQANCxUBDQsuAQ0L0AEOC80AjgvdAIcAQgUEC8EBhQvOAoYAVQAOACsBBwpnAAcKXwMLCrgAkQo+AAQLYwEGCzcBCQsAAYoLlAGJCpMCigv2AoULOwMFC0AAjAtFAoYAkwQEC7oBBwsXBAcLSAWHC2sGhADUAwUL0QMGCyABBwsQAocLKQQFABcBBgDrAAcA1AEIAL4BCQB9AgoAzQILAOICjAACAoQAJQELClEBjgovAYgLHQEFABEABgBzAQkAEAIMAGwBhAv+AAUKTQAHCq8FCgpLA5MKSQCWAAUAhArKAQYLDAAHC8MEkQtJAIcKjAUGCm0Aigp+AYcLfQAGCkoBBwo8BIsKjgAGC3EBBgv2AQcLDAQIC1wBCQvEAQoLGgALC+AACwuDAQsLBAMMC18ADAt1Ag0LwwANC88ADQvxAA4LBAEOCw4BjwuMAIQLDQEFC+ABBwsUAgcLrQQHC04FCAsjAQsLXQGOC4wBlgAwAAoAWQINAGEBjQB4AQUACwMFACcDBgB3BoYAjAaOC98ABADEAAUALgKFALUDlAsPAIcL5AaGACoFhADwAosA4QKHC5ECiAsVAocAnAEEAOMABQCfAAUAmQEHAFAACAAsAgoA3wEMAKIBDgAyAA4AewAOAMAADgD5AA4AJwGPABsABwC+BQgAQgAIAIkACAD5AgkAfgILAFAACwDUAAsAcAELAKIBDAAIAA0ADwAQAD0AEQA7ABMAHACUAFQAhwrBBwQL0wAEC0wBBQtPAQYL7gAHCw0BBwsrAwcLBQcICnoACAtEAwkL+wGNC/IABgCrAoYA5AQEAGkDhArqAIYAQwMGACYABwDEBAgAuQAIAAABCQAWAAkASwEKAOICCwDNAAsAHAILAOoCDQDRAQ4AWACOAMIAigDaAwUL8QMMC0YCkguDAAQAnwAGAHMABwD8AAcAAQEHAIgHCABFAAkAgAEKAFsACgBnAgwAdwEOAOsAEgB1AJMAewCFAI8DiAAWAQUKrgEFCqQDBgqDAAcKoQEJCgoCCwo6AY0KhgEOCpUADgqPAY8KOQAEAJcABwAfBogA7QIFC+QABgvLAAcLnAAIC1sBiQsJAYQK+wEKAN0DjAC8A4UA3gMFAMIABgCfAwcAfgYJAFoAjAA0AgQKVwGFCv8BhQCpAQcKxwGKCk8CBAAGAwcL3AEHCzgGigtXAAUAywOHCmUFBQs+AZMLeQAFCyMBBwv9AgkLhQGMCyQChgo/AgQAOwMMAIYCDADBAgwAyAKMAMoCiwDwAokAlgIFAEgABgAIAQcAFQAHAC4ABwDdBwgA1wAIAAECCgAKAYsAFgCLCwoCBgDvAAcAdgAKAF8ACwBbAg0AuwEOAKAAjwAEAAYArwGGAJ0CBwpnBAcKJAYKCikBCgqmAQsK/AILCioDDAoIAQ0KZgANCiwBDQrkAQ4KkwAOCuUAEQpHABIKdgCTCngABQBqAwYAjQYPAAAACgsNAosLUgAGAEEABwCrAwcAlAQHAIcGCQAcAgoAuAILAAkBCwDcAgsAoAMLAKkDjQC2AYYARgWICyMChAumAQULYwGRCwAAiQuJAwUAqgKHAF8HhAApAwQAuAKFC2EDBgAyBAYAwAUOCiMAjgq/AAULkgOGC1kGhQvqAIcLZwWJCwwDhAp9AAQA1gKFAHYCCAAiA4gARgOECtECBgA5BQcACAMTADgAiAqRAIQAygMHChgDCAqTAAoKNQOLCv0DiwrKAwgArAOJAB0DhwsgBQkA+AAKAJABBwswAwcL2QQHCs8HCQsbAQkLCAIKC9UACgszAQoLzwEKC58CCgvqAgsLkQELCxoDDAsFAhILawCTC3MABgCfB4YA+AeHC1MBDQApAA8AXQAFCqgABQqiAwgKSgAJCm8CDAr0AYwKQwIGAHYABwDXAAcA8QWMAAsABgrcAAcKTQSNCmkABgulAQcLPQAHCwQGCgsLAIoL9QEHAGcCigD7AIwLdwKHABQEBgoTAAcKhQWLCqwBhQDhAAcKYAAICpEBCAq/AokKgAORCnQABgtmAAcLSAAPC44AkwtDAAcKqQcHCq0HCAq+AogK7gIHCu4HCAqWAAgK4QIMCm4BlwseAAQAcgEFAPQCBwAuBYcLNwMICiADCQqUAAkKaAMJCnoDCwo1AQsK6QMNCgsBjQpDAQYAfgYHADAACAADAwoAdAANAGgADgBpAA4AuAAPAKgAEwBcAJQARAAKANEAhwtOBwcLRAAICzAACAtYAAgLRgIIC6kCCQt1AQkLYAMLC50ACwtQAQsLSwOUCxsAhgCiAwQLWAAFC4kABQuuAAULCQMGC4AGBgu9BgcLTQAHC6oBBwslBQcLSwUIC34ACAszAgkLCwIJC+4CCgs2AQoLRAMLCyoACws+AQsL2wIMC0QADAtcAAwL+wEMC7QCDQtRAA0L7gANC3YBEguKABMLTgATC28AFAs3ABQLTQCUC1wABAuqA4cLJwcFCiMCBwqoAQgLaQKKC18BBgAGBQYLhAYHC9sFCAt1AAkLOgGKC64ABgD3AgYAfgMHC8MCiwszAgQAeACHAGYHCQCBAZUAEQCKAK0BhQuTAQUANAOHAKMDCgDHAIUKhQAGAJcABgCLBgcAfwGXAAoABgD5AogKuwAIAG0BCgoAAAoKMgOLCtwDBAssAAULNwEGC5wABwt/AgcL+gIHCyMHCQsIAAkLzgGUC1MABAtaAQcLcwAJC7QACQvIAYoLawGICq0CBwA+BJEALgAGAFgGCwALAAwApgENALwBjgBoAQYA/AMGAOwEhgA1BgQAKwAFAFgBBQBlAQ4A2AGWADoABgBIBwYASgcGAEwHBgBNBwYAUgcGAFUHBgBvBwYAdwcJAJgDCQCZAwkAnAMJALIDCQC/AwkAwwMJAMoDCQDlAwkA8AMJAPkDDAAbAwwAHQMMAB4DDAAgAwwAIwMMACsDDAA0AwwANQMMAEcDDABJAwwAUAMMAI8DDACZAwwAmgMMAJ0DDACpAwwAsAMMALEDDAC5Aw8AuAAPAL8ADwDHAA8A7QAPAPAADwDzAA8A9gASAMsAFQAoABUANAAVADkAGAAXABgAHACYAB4AhgDVApELOgCFAHgDiQpqAwQAxwIICgYDCgqeAowKMwCQCygABgu5AAcLaweLC6ECiQq9AokAuAEEC0cBBQveAQcLNAUIC/ECjAvjAAQKfwAFCl4BBgpkAQgKqgEJCjwCCgr3AIsKOAEFC/wDhQv+AwQLZwCFC5EBBgB5BwYAhgcGAKcHCQCSAwkAqwMJALgDCQDTAwkA3gMJAOYDCQDrAwkA/wMMADsDDABCAwwATQMMAJADDACnAwwAtwMPAKwADwCuABIAxgCVAD8ABQC+AwUA2wMEC/MBhwuNBQcAdQMGCjsABgriBgkKWwKNCo0BCgs+AI0LpAAEAE8DhwBGAQsAFAGOACUBBABBAAUA3wEFAOwDBwB5BwgAPQEJAC4BCgBkAg0AFgCEC2AABAAFAYcA/gGHAOoFBgpvAAcKBAAICqMACAoIA4oKNgIEACMBCQADAgwAmAAMALsBDQCIAY4AZQEHC48BhwvUBQQATQKLABoBBgszAocKygcFCikBhwoOBAQAggAHAEsDhwAaBgUAKgAFAG8DBwD1AAcARAEHAPwFCwDPAQsA2AENAGsBkAA0AAQAhgCFAHQBhQCoAogKawEGAM0HCACnA4gA0QMEACoDhwBiBocKiwYHAG4FBAuOA4ULQAMHCigDCAsKAYsLQgKEAIQCBADWA4oAYwOEChgBhwAcAowKNgCHAHsAhgC6BwQKpQGFCiQCBgBvAogAFQMEAIwDBQBnAQUA/AEGALsGBwBXAQcAzAeHAOoHhgDEBAQAVQGHAOABBgr+AAkKbQCKCmcAhgB4AwgLEAKJC1wBBwDLBwgAKwELAHoDDACiAgQLFACFC2gChwtGBIYKXgYEAO4ABQD3AQYAswAHANMHCAB9AQgA2QEJAJUACgAUAw8ALQAPAFYAFABuAJYAOQCFCp8CBAsaAAULrQEGC/UABwvAAgcLYwWHC8IFBAB5AAUAnAAFAF0BCQCvAQoAXQKOAFYBBwuvA4sLZgKECnkDhAttAgcKZgUHC2YFhwp2B4QKcwKFCgcDhQseAoULZAOIC7EBBgBdBQcA8wMLCmoBCwq0A4wKhAEGAFAABwCtAAkAIwIKANoCDgASABYAJwCHC9cFBgCeBocAtgeMAMQABACbAwYA+wEGAK8GBwrDAQgKhQEMCuoBDQoQAA0K1wANCl8BEgqEAJMKfQAGAIYChgAXBIcKSQOICjYCBgBLBocAvgSLAJ4DhAsNAoQAUwIFAPAABgDLAQcADAAHAHIABwC1AwcA2QYHAA0HCACSAgkAAQALAL8DjQC+AQUKkAOGCp8GhAC+AQcLPgAMCy0AkwtwAAUK7AAGCjwCCArsAQsKagKQCjgABQq+AIgKPgGHCmAFBAvfAAYLZwELCwMADQtsAA4LWQCQCxYAhAuHAoYA6gGGAOsBhgAwBocLrQKKC9wABwD6AIgA+wGEAJ4ABACMAAcAagEIANEACQAKAAkAoAAJAPcBCQBmAgoAsQILAEcBCwApAgsA1QILAP8CDAD8AAwARwINAMAADgANAQ4AZAGUADIAEwABABMAGgCWAAkAhAttAAYA5AAHAD0FCQCYAYoAVwEEAHUBBQAbAQYA4AEHAGECCgBcA4oAbgMGAAsDhgC5BAQALQIHCwcBBwt0AogLXQGEACQCBwDFAAgAjgAIAEUBCQCWAAkAVAIKAF4BCgBhAQsASgALADsBDACWAgwAqQIOAKcBjwCNAAQLKAAKC0MACwt1AAsLAAOLC6cDBwvgAwgLLQEJC9ICDAs/AA0LHQAOC6EAjwsSAAYA0gWKCxQCBQBEAgcAegEHAKICBwCQBQ8AUwAQAAsADwtTAJALCwAGACEEBgA3BQoAPAEHClUABwr3AAgKSQKKCqMABACpAAUAUwAGAI8BBgBDAgYA6QUHALQCBwBOAwcA9wMHAAcHCACTAQkAigEKAIUADAAEAAwAKQEMAMQBEABRABIAGQAVAA4AFgAMAJcAEgCGAFIEBwAKBgsAKwGOAJcBhgCoBIQAsQAFAJsBhwCNAgcAtwEKANcCCwAEAYsArAKKCpEAkwpTAAUA0AAHAPEChwD4BYkLaQKHCoIHhws5AwsApgENAIUBBAp8AAoKyQELCnkACwqpAAsKZgMMCtYADgq7AI8KTQALAGcCDwA6AAsLZwKPCzoACQBqAooA4gEGAKAHBgCyB44A+QEHCqkEhwsuB4UA8gCHCjUFBgprAAcKfgIHCmAGiQqMAYUAuQMFCnIBhgrcBgULHAAGC8wACgtAAQoLRwINC/YBDgtIAA4LEgEOCzgBDgtYAQ8LnwAQCz4AEAtFABELHgASCyoAEgs1ABILVAASC4wAEwtEABMLVQAUCwUAFAstABQLZQAWCwcAlgsUAAQLLgIGC4YBBwuiAAcLsQIJC2gBiguNAgsAIgONAEMAhQrMAIUAIgEFCsoDhgqqBoQAfAEFADQABwAVAQkAcAGLABcDBQtYAwYLiAYGC90GBgv1BgcLfgQHC5EFBwutBYwLAQIFC1wABwoDAAoL4AKMC2YABABwAAUAjQIFCuMBBQqtAgYK6QEHCrQEiAqKAYQKmQMGAAQEhQrvAwULTgIJC9UAkQtbAIcKoAYKAIoAiwDcAQUA1QIFANcChwATBwQA0wMGAB0HBgAuBwgAbAMIAHMDCAB5AwgAfQMIAH8DCgCmAwwA0AIOAMsBlAB7AIcLJwIEACYABgCzAQcAMwEHAOcDBwDJBQcAxAYHAMoGCABzAQkAngELADwBDAA0AA0ApAGTAGQAhwAQBYQKyAKGCl0GhQDTAoYAiwKIC78ACQsXAwoLXQALCy0BEAsNABELFwASC4cAEwsMABQLAQAUCwwAlAsOAIgL9wEGC9IBhwufAgYAsASGADIFhwDnBIYA2gMFAG0ABgD4BgcAZwcMACgBjAAuAYcL1wOFCuUBhgCUAoYAIAMFANgABQAmAQYATwIHAFcHCQCNAAkADgEJAKcCCgCfAAsAxQALALYBDAAaAgwALwIOAJAADgCnAA8AQwAECh0BBQo9AQYKLQEHCgcACAqZAAoK/gILCtQBDArTAY0KjwCIALEDhgBCBIkAUQAMC9QBEwtgAJQLGACGAIcBigvxAAcAQgGIAPkAhgCEBYcLGwMFAHgCigAOAogKMwMGAJAABwC0AwcAEgQIAOsACADNAQkAxQEJABwDCgBiAREATQCHC7oDiwqVAwYArAOGAMwEBABqAQcANACHAC8BBgslAggLIgAICxsBCQulAIoL2wEHC3IBBwvvAwcLmQSHCx0GBQuMAgULvQKHC8EBBQDEAAYA5gEHANQACAA1AYgAWgEGCrcGBgrHBgcK4AcHCuQHCApFA4kKVAMGC58ABgtsAQcLBAIHC58FiQsGAocAeAeHAAoFhACuAo0LlwCKAHECiADCAooKOAKLAJwBBAAeAIUAKwAICkMAigqjAQcAxwONAAsADAD2Ag4AuQGOAM4BCgqRAg4KKQGOCmkBiwrZAgQA3ACHAP8FBwv1AQkLbwAKC40ACwtMAQ0LKwANC60BDguCAA4LnwGRC2YABAC2AwYAQwcHAAsACABpAwwAxgIMAM4CDADsAgwA/QKUAHwABQuVAAULpwOIC+kAjgsjAYYAKwYHAHoDCAozAAkKZAMKCkEDDArhAQwKOgKUCmoAjQACAIQKvQGICyEDhwDuBgcAvQaKAIkBBQAHAYYAngGEC0IBhQrvAAcAyAEHCsYHCAqCAIsK0AKJADIDBQp7AAYKEgIHClwBhwqLBYcK6AcGALIABgDWBggA+wAJALICCgCbAAoAxAAKAHUBCwC6Ag0AmwCUAF0ABQBhAIkAiQGGAKICCwDfAIwAqACECtIAiwvQAQYAZwaSAJ8AiwsCAAcApgMIAIcCEQBhABMAOwCWAAIAhAC/AAUApQAJAFoBCgCPAgsAdQMECq4BhwtlAYUAbQMFCtUAhQuWAQgAgACLALMABgtFAIcLdQCHABEFCwsrAA0LSACNC44AhwsmB44ApAAFADkABgBlAAYASgIGAH8GBwCEAAcAggQHAIcFBwDjBQwA7QEPAGkAlwAPAAUAywEHADEECADxAIgATgGFCzoDhQpsAAUK2wAKC4QACwu/AAsLZgGLC8wBBgBEAQYACAIHAFIBBwDBBggA5ACLAO4CFQAeABYANQAECsEABQqUAwcKbAEKCo4BCgrWAgsKPQELCnICDAqOAAwKIAEMCqYCDQo5AQ8KcQCSCnIABgtuAIcLkQaHAI4DBgrxAAcKiwMICkADCQpWAQoK2QILChwBCwq9AQsKiwILCl8DDQqOAZIKYwAHAMECCQDeAgUL6AMHC90CiQtHAgQASQAGAGQCBwCfAwcAHgcIANkACQD9AgkA/gIKAJgBCwAzAAsAGQMMAAoBDwCeABQAWQCWACAABwAyBQQLKQEGCxECBwuYAAcLyQIHCzUHCAvGAggLzQKMC38CBQCFAYgAfAKGAIEFBAoyAgkK/gCLCm8DhgB9A4QKEgMECwgChws/AogAFQCMANECiAC/AwcLlAUHC2gGCQupAAkLtgAJC28BCQveAQkL+gEJCycCCQuIAgkLiwIJC7kCCQvBAgkL1QIJCxMDCQsaAwoLxgAKC9YACgsLAQoLEwEKC8gBCgsnAgoLMQIKC2UCCgtzAgoLnAIKC6MCCguzAgoLtwIKC8MCCgvLAgsLtwALC8kACwv0AAsLBgELC2ABCwu3AQsL7QELCzwCCwtPAgsLYAILC2MCCwuGAgsLogILC8cCCwvvAgsL+QILCwgDCwsRAwsLUgMLC1UDCwteAwsLYQMLC2QDCwuCAwsLhgMLC4cDCwuOAwsLpAMLC64DCwu9AwsLxwMLC8wDDAuUAAwLwwAMC9wADAvtAAwLPgEMC1MBDAuJAQwLvQEMC8IBDAvaAQwL/QEMCxUCDAtPAgwLUgIMC1UCDAttAgwLeQIMC4ICDQs7AA0LPAANC5EADQvvAA0L+gANCxEBDQtJAQ0LWAENC20BDQt0AQ0LgwENC5MBDQueAQ0LyAENC94BDQvjAQ0L6QEOCzcADgs5AA4LUQAOC1oADguUAA4L7wAOCwoBDgtBAQ4LRgEOC0cBDgtKAQ4LWwEOC2MBDguRAQ4LmwEOC54BDgugAQ4LpAEPCz0ADwtKAA8LVwAPC1gADwteAA8LYAAPC3QADwuVAA8LmgAQCzIAEAs/ABALSQARCwIAEQtCABELXAARC2cAEQtwABILMgASCzYAEgtSABILVgASC1oAEgtvABILcwASC5wAEwsoABMLTwAUC04AlQsWAIkLqgCGAJkFhwsbBYsLmwEFAL0ABwC6AQcAuwEIABkBDACuAI0ABQEGCtgABwqFAwcKPwWICu0BBQuNAQYLmgAHClUBBwukAggLuwEIC2ECCQsYAAkLRQEKCyMACwrbAAsLFwILC6ACCwv6AwwLfQKQCx4ABgACAAcAvwAHAL4BBwDuBAcAyQYIABYACAAOAQgAZAIJAAQACQA4AQkAtAEJAHICCgDYAAoANwEKAAkCCgBvAgsASAALAEoBCwDHAQwAQQEMAPgBDAASAgwAHwINABEADQCcAA0ATgEOAIMAEQA8AJQAQAAHAGIBCgCaAYsALwOLCoIABwrGBokLdwIMAKkBDwBwAAoKcwALCqQBDQqUAQ4KWgGPCjYABgA8AAYApgAHAHYBBwCeAgcALwUIAJsBCACzAQkAjQIJAOQCCgCBAQsA3gALAEQBCwA9A4wAYwIHAEsGDQAOAA8ALAATAA0AlABMAIUL1QMECzgABwv/BggLXwIIC4sCCwvRAQsLQwMMC1EBjQvgAQYAxgUFCvMDiAq9AosAVAIFAM4AhgCOAQQKNgAFCpoCBwoPBAcKagQJCsMAigouAQcAMgAJC54AigubAYcLYAQGAAUCBwCHBAoAbQILAMAAhgqFBgQAUAIGAFgChwB1BgoA3wCLAIUCiAuLAAcAQACIAPUAjgAWAQYLbgKHCwYEiABcAoYA3gWKAAkBjQuoAAcA4waMADYBBwoeA4sLzwIHC6AACgtwAo4LFwGEC2sBBwp6AAkKAwEKClQACwrWAQwKHQKNCnsBBQCBAAYAPQCHALMDhgBMBYcLpwQNAPkBjQD6AQsA6AMFClIABQqDAAcK2wYICh8ACQqoAAkK/AKLCmUDhgDGA4YKXQKGCyQBBQuxAAYLaAIHCzsDCQsNAooLkAKHC84FigsfAAUKFgGJCkQABAqjAAUKyQAFCjMBBQo2AQYKTwEHChwBiAqlAAYARwOHCnwGiAoNAwYKIQCHCtwEhQB9AgQLoQCFC3cCiQBOAgcKoQeICtACBQAYAQcAygSKCssAhgBqBQUAGQEGAAIEBgpGAQcKpQKJCqkBBwsVBocLlAaHACgECQvVAQkLxQIMCwACDgtBAJELDACGAJUDCgvlAAsLSQALC3gBiwuxAQcAKwIJAMAADQAeAA0AMQAPAJYAEABMABQANAAHCiQFBwqEBQcKLwcJCk0CCwrxAAsKpAILCisDCwp7AwwKjAAMCloBDArfAQ0KfQEOCrwAkgoeAJUADwAGAFoHBgBbBwYAaQcJALEDCQD2AwkA/AMMADcDDABKAwwAYgMMAKYDDwDyAJIA0AAGAMUDhgDbBQcAIQAHAHgACADpAQkAPwEKADQDCwDsAwwAewEMAKcCDQB1AA0AnAEOABkADwA0AA8AoQAQAC8AlQACAAYLLgIHC4sCCAulAQkLAACKCyIABACpAwUAIQMHANkBBQpmAQcKoAQKCpYCDQrUAA0KMAENCk0BkQpiAIQAbQMGALUChgA4A4QAbQEHCygHigt2AQUABwCLAAYDBADeAgUAlgKGAK4BBADqAocAQgQFAGgBCADtAAoA5wCTAHwAigtcAQYLBgAHC1EABwsDAwcLwwYJC5UBigulAQYA5AKJADYDhQqyAwcAzQWIAKEDBwqbAQgKdwIJCkMBCgpjAQsK6wEMCo8ADAqSAQ0KSQAOCpgBDwprAJIKRwCHCk4CBQtxA4ULdQOWCxkABABUAwULjgCGCyICBwq7BQgKSAEKCiACCwq7Aw0KQAGRClMACQARAAoAIwELCv8BDQqKAQ4KKgEOCj4BkgpnAAUL0gELCzsCDAvGAA0LGwEOC7oADwsVAI8LZwCGAOkDBAu5AAULAQEFC0cDBQuoAwcLqwAJC48BCgsCAQoLiwEKC94CCwv2AwwLFwANC14BDguWAJMLBgCPACMAhAA/AwUKQwOGCuMBBAAVAQUAYAIGAO0BBwDJAQwAgAEHC5QBBwthBQcLlgUHC+EHCAuVAAgL7wAICwACCAsZAwgLMgMJC9oBCQtTAgoLegAKCzUCCguJAgoLDwMLC+8ACwsnAQsLvwELCxACCwt/AgsLIAMLC6gDDAsZAAwLSQAMC00ADAudAAwLPAEMC4YBDAuHAQwLigEMC4sBDAveAQwL9wEMC1ACDAuoAg0LMgANCzUADQuEAA0LxgANCxMBDQtCAQ0LnwEOC0cADgsBAQ4LiwEPC0cADwuIABELewASC10Akws6AIYARwUHABsAhwA8AYgLyAKIANgDhQAoAokACAGEAJEBBgDGAgYAVwSGAD8FhgC7BAkAHwIKAAwCCwBsAAsAjQIMAAwCDQB7AA4A/AAQABIAEwAmABQAGgAUAEEAFQADAJcACwAEAM0ABQBvAgcAaAAIAAcCiQDMAoQKpQIEC3kBmAsNAIcLiQYHAEMCCQApAAkA9AAJAJ0CCgAFAAsAXQMLALcDiwDUA4QAzQKIAPMDhAAlAwQLtACHC3IHhAoJA4QKSwGEAOkBBgAABAQL6wGFCusChwueBAQLqwCKC+oABAtKAgcLogSKC3cChwB8A4cLUAEJC6MDCgtOAZQLRwCJANkBBgBgAwwAkwKLC54DBwAzAwkAGgAJAIgBCgCYAAoA4gALABMADAAUAQwAqgEMAE0CDQDMAQ8AYQATADAAlABoAIcAMwCFCkYBBAqzApIKEAAJAIIACwD9AgoKqAIKChkDjQplAYUL/QIIAOUABgogAAcKgQEHCvUCBwp8BwgKXgAICscCCQodAgoKogAKChsDCwrdAwsK8gMMCg4Ajgo0AQcL2gGJC0IChACiAoQAAgMFAE8ABwADBAcAxQWLADQAhQuoAYYAggYGAJkBBgpdAQYKkgYHCuQECApwAAgLygIJCrMBCQqcAgoKIgEKCj8BCgovAwsKtAALCkUDDArwAA0KmAANCtsAjgqeAAUAFQOGAMMABAD7AAQAsAIHAAEChwAEBYQKRQIJC6QBCgsNAQoLHQEKC0ACCwuNAQ0LrwCRC1oABgp+AAcKPQIICo0BjgosAIQLrQGFAHkDBACgAAUASgEHAJoFiACuAAcLEgAHC7sCBwuuBwgL8AIJCxEBCQucAQkLvwIKC0cACgurAQoL/AGSC2EABgBoA4YAgwOFCp4DhgBmBIYAlgMECzUABQu6AIcL8AIHAAwBiAA5AoYAyAQGAFEFBwrQBIkKEwIICz8CCgshAYsLPwGFCp4ChAujAoUAdgGHCqUHhQDbAgsAvgAPADEACwu+AI8LMQAEAHICBQD6AQUAggIGAKkBCgDKAIsAjQCJALwBBwryAIcKlgcGC9EACAvUAQkL0gALCyQADAscAAwLdgINCxUADQtdAQ4LBwCRCw0ABAtWAYcLmwQFCkIDBwqyBAgKDgAJCuEBiQpwAwQLoAOFC44DBAs+AQQL8AEHC1gDiwuOAogAQwMHAPYFigrRAZcAEQCHAN0BBAplAQYKrAAHCo8AiQqdAQYAXgWKAOIDEgBMAIQKTgIHAB8BCABjAQkAJQGJAOcChgBtBQcLkwMIC/cAkwsAAAQLygAFC34BBgvGAQcLqAMHCwsHCAv2AgkLdwEJC38DCgvnAgoLGAMLC9IDCwv0A44LbQAFAIABCADHAYwAMACEC4YBBQqpAAcKTQGICi0ABQAIAYYAuACKCxcDhQvNAoQKxgAGC70BBwtMAYkLjQOIAOkDBAoYAAUKjAAFCrkABwrcBQsKNQKLCkYDhgtCAgUAeQIGABwAhwArBYQAUwOICwsBBwBnAQgA8wCMAK8ABApOAYUKUQKNC1cAiAv+AgoAHwEMAIoACgsfAYwLigAEAGkAhADkAowKdACGAFkDhwsxBwYAegWJADMDhAtIAoQKxQKFCoEDBQDgAA0ArgCSADQAhwowBwQKYAKFCvEBiws8AAQA9gKHAHEGBAviAAQLRgGHC+oGBQuqAQgLHgAJCwIACwslApMLegCHCvcHBgocAogKiAAEAD0CCACPAgQKgQOFChIDBwBfAYsAgACFCucDBAorAYcK7AOFAJYDhAtZAQQLgQEHCwkBhwtLAoUKyAGICrQABgCvAoYAAQYEC1sBBQunAQUL5AOHCzEFhArzAgcL6wQJC30ACwtBAIwLHQEFC4gABguIAIgLhAKGAPUFBADxA4cAcwSLClIBhABUAYcKuAUIAE8DCgBdAwoAbAMKAHkDCgCaAwoAoQMKAKUDDAAQA4wAFwOLALAACQuGAAoLAgAKCxsACgtNAQsL0gKPCwEABAuxAYULzwIFANkDBwD9AQcAEQKRAGAAhABnAgQKegMFCiUDBQozAwUKwQMGCowBBgpfBgYKjgYHCq8HBwr5BwkKdgILCggACwr7AwwKsAANCuEADgokAZUKGACHAH8HhgBrBJALFQCQCzMAhwoXBwQA9wAHCuEFCgq+AAoKegILChgDDApmAYwKvwEFCgAABgoYAgcKXAINCr0BkQp+AAQAuAAFAIYBBgBRAQcAFwAHAO4BBwBqAgcAsAUIABsACABXAgoAmQCLAMYCBgroAAYKnAEHCjIECAoJAAgKnQAIChIDCQrEAAkKYAEJCskBCgpRAQsK6AALCm0DDArgAYwKIgINACYAhwq+AwQKfgGICkMCBArUAIcKtgQECysCCAsYAooLIAELC4sAiwurAAkLcgGKC1oAhAD3A4YAQAQFCo8ChwvRA4YAMQYRCkMAkwpKAAoA4wALAPEBCwDFAowAnwEGAGgBBwCABogA3gEHAF8ABgrnAIgKpwGMC0EABAsBAYcL7weHC+gGhQosAYsL0wCIALsCBgrtAAcKYwIICmQACQqgAQsKTwEMCq0AkgplAA4AGgCSAJYABgBFAocAXwSHCrgEhADjAgYLUwAGC8UGhwttBYkAZQMEAEMABQCmAQcADQQHAAkFBwATBgkA5QKRAGwAhQrHAAwKqwGSCiYAiADQAY4AKgAKAGAACAv1AYkLuAKGC1ACBAAAAgQAxgMFAFYBBgA/BwgAZQMIAGsDCACFA5AAGgAIAMsACwA3AwsATgMMAOIBDQAVAQ0ALgENANABDgDNAI4A3QAEAMEBhQDOAgcLtgYJC18ACQsSAQoLFwEKCz0BCgukAQsLLwELCygDDAuGAAwLbwENC5UADQtbAQ4LXQEOC5YBEgsWABILWQASC3oAkwsvAIULGgAEAGMBBgA3AQkAAAGKAJQBhAsmAgoA9gIGCjgBBgqzBgoKSAILCiICCwq0AgwKAwEMCicBDQouAI0KmgCICzYDBQA7AwQLhgMFCykDBgt6AIcLgAMFAEAAjABFAgQAugEGAOMCBwAXBAcASAUHAGsGBwt3BwkLwQEKC8AAigvkAocLBgGECkwChQtsAgUA0QMGACABBwAQAgQLIgAFCz4CBwsXAQcLWAaIC1kCBgBfBQQK5wAFCj0ABgpoAAcK2QIHCsQDBwp6BowKngEGCgcBigr1AoQKQAEEAP4ABwAdBQULTAGHCx0FBgsFAQgLtgCLC68DhArhAAYADACHAMMEBAATAQwAeAEGC7kGjQvqAQQLpQOFC3ADBgC3AwYAVQQGAJ0EBwCaAAQKlQEHCjEDDgo6ABEKJQCSCnwABgDwBYUKzgOGANkGBgBxAQYA9gEHAAwECABcAQkAxAEKABoACwDgAAsAgwELAAQDDABfAAwAdQINAMMADQDPAA0A8QAOAAQBDgAOAY8AjACEAA0BBQDgAQcAFAIHAK0EBwBOBQgAIwELAF0BjgCMAQUK6wAHCtcECwqDAIwKcgEHCrwDBwqFBAcK4gUHCkYGBwpPBgcKUwYHCsgGBwrvBggKTgIJCkQBCQrgAgkKBgMJCggDCQoQAwoKNwIKCsQCCwoGAgsKZQILCrcCCwrMAgsK4wILCgIDCwoDAwsKUAMLClkDCwqjAwsKswMMCkYBDAqDAQwK5AEMChACDAooAgwKZQINCr0ADQoAAQ0KVAENCrABDQq0AQ0KuAENCsYBDgquAA4K3AAOChwBDgqGAZEKeQAIC1YCCQuYAooLuQEJCokAigrdAIULLAOUAA8AhgA9BQYA+QMEC4kABwuaBIcL8AUHCoYBigqMAAcL7ASHC/4GiQu/AIcKeAQGABIHBwCRAggAdgMKAFkDDgC4AZAAYAAIABUCBgt9BgcLtwcHC9kHhwvbBwYArQWGCtABhAvLAgUKlwELCswACwrzAAsK6QEMCiUBEwolABQKSQCWCiYAhQu/AgQA0wAHAMsFBQpFAQgKBQAICuMACQppAAoKSQKMCmYCBABMAQUATwEGAO4ABwANAQcAKwMHAAUHCABEAwkA+wGNAPIABQtZAAcLewcJC7kACQvrAAkL8AEKC0AACgsOAQoLkwEKC9UBCgsRAgoLTgILC4wACwtcAw0LAQANC6YBDgtVAQ4LbAERC10AEgtxABMLYQCTC3EAhQu3AhAAEwAFCwYABgu3AAYKbQIHC6gCBwvSAwcL9QMHCx8EDAvmAA0LrAANCvgBkgsdAIgAnACFAPEDBgsdAIsLPwCGADQDhgraAAcKxgEHCg4DCAoAA4wKrgIFAOQABgDLAAcAnAAIAFsBCQAJARIAJwAUADYAFQAfABYAAwAXAAAADwsIABILJwAUCzYAFQsfABYLAwCXCwAABwBrBIcAvAWQCgAAhgD8BAoKpAKMCs4BhAs3AYYLzAYHC6oACAtaAAgLsQAIC58BCwvKAo4LGQGGCqQABgAAB4oAUQOWCjIABQAjAQUAPgEHAP0CCQCFAQwAJAIICwoCjgtIAQsLWwANC4EADwtlAJELfQAEC+4BBgtKAAcLLAAHC5cBCAsnAgwLEQAPCwUAlAsLAAQLFAGFCygBBgpXAQcKwwAHC/EGCQriAAoKxQAKCj8CCwr2AYsKgwMKAA0CiwBSAA4AxQEECwcABQtaAAULngAGCx4CBwvdAAcLJgYJC+oBCgscAgsLuwGLC/UChwCaAhYKHQCWCx0ABACmAZMKCAAFAGMBkQAAAAYAUQcJAJYDBwtMAgkLrwCKCxICjwsfAAsApQAHCmUECQqPAA4KlQGWChUACQAEAYkAiQMFC2gDBgs5AAYL3wEGCzICBwvXAQcLJAQJC78BCQvGAY0LBgCKC8AChQBhAwUAkgOGAFkGhQDqAAcAZwUFCx8ABgtmApELPQAHC7AEigvMAQYLqAGHC0oHiAAyAQUKvwMMCx4ADQuUAA4LVwAOC7YAEAsqABILXACUC0YABgB/BwYAgQcJAJsDCQCiAwkArQMJALUDCQDbAwkA3AMJAOADDAAiAwwALwMMAFgDDAB1AwwAfQMMAIIDDACXAwwAmAMMAK0DDACzAw8AtwAPALkADwC9AA8AxQAPAMoADwDpABIA2gASANsAEgDpAI8LnACHCt8GiAqtAA0AowANALQAEgBOABQAIwAFCw0AhguOAIYKCgEGC2EABwt0AAgLQgEIC/MCCQskAgoLygILC3QDjQtEAYcAIAUJAC4DiQukAoUAwwKHANUFBgClAQcAPQAHAAQGCgALAIoA9QEMAN0CDAD+AgcLYgOHC4sEiQBVAY4AYgCRC3MAhwtXBIgKLAGIAPYDCAsBAAkLcACKC0YBhAvaAgUL6AEGCw8CBwvpAQcLZAYIC3kACAuQAAgLZwEJC8EACQvxAAkLUAEJC3IDCwsKAQsLdAELC7ADDAuRAYwLgQIGAMsDhgBhBAYAZgAHAEgADwCOAJMAQwCXAB4AhwA3A4YAFQQFCqsBBQreAgcK3gGICjQABwCKBwsK2QCOCqUABgDoBYcATgcJCx8ACgv0AAoLuwIMC5UAjQvxAYULeQGRC2UACgueAA0LDQANC4kADQsCAQ4LbwAOC+EADgv9AA4LMAEOC1MBDguhAZILIQAGAFcABgrGBgcKFAAHCiAECArcAgkKlgEJCo8Digq2AoYA2wSJAPUABwBEAAgAMAAIAFgACABGAggAqQIJAHUBCQBgAwsAnQALAFABCwBLA5QAGwAIC5cCkAsIAIUKZQIEAFgABQCJAAUArgAFAAkDBgCABgYAvQYHAE0ABwCqAQcAJQUHAEsFCAB+AAgAMwIJAAsCCQDuAgoANgEKAEQDCwAqAAsAPgELANsCDABEAAwAXAAMAPsBDAC0Ag0AUQANAO4ADQB2AQ4AtAESAIoAEwBOABMAbwAUADcAFABNAJQAXACNAKIBBACqA4kAcQKKAF8BBQtLAwcKIAAHCtgDCApVAAgKxQIJCkMCCQpPAwkKWAMKCh8DCwoCAQsK7wMMCksBDApnAg0KvAANCrMBDgoIAA8KpQAQChsAlAooAAYAhAYHANsFCAB1AAkAOgGKAK4AhwDDAoQLKgKFCxgCBQCTAQULzwAJC08ACwtxApELBwCEC6gBiAsRAwQKpwCHClIACQAHABcABgAJCwcAlwsGAAYAGgEFCj4ABgoWAgcKSgAHCqYCBwqsAgcKEwQHCjAECAoYAQgKHQIICq4CCQoCAQoKBwILCvwAjAoaAYoKIQCECmcBBAAsAAUANwEGAJwABwB/AgcA+gIHACMHCQAIAAkAzgGUAFMABwsBAwkLEgCKC2YBBABaAQcAcwAJALQACQDIAQoAawEEC4ADhgvxBoUK0wAHAPkCBwAbBIkAIQIGCpEAjQpQAQcL7gIJC98ACwsbAAsL0gEMC3ACDgsJAZILPQAGAPACBgAAAwYAqwQGAOYEBgBTBokAQwMGAJAHCACiA4gAwAOECgcBhAv5AAwAjQKECpQDBAtbAoULlQIIAFgBBAsLAAYLgAAHC+cABwv9BYoL1QKGAMsFhgBrAwYAuQAHAGsHCQBrA4sAoQIPCpsAkApPAAcAXQAHANIABwDHBAgAwwEIAMwBCwBhAQsA2wEEClcCBgpiBgcKQwAHCrMCBwrTAwcKoQYICs8ACArWAAgK5wAICiYBCApQAQgKrAEICtcBCApuAggKcgIICqcCCAr3AggKPQMJCgsACQr2AAkK5AEJCj0CCQrCAgkK+gIJCh4DCQpXAwkKZgMJCpADCgovAQoKTwEKCqgBCgrNAQoKHwIKCvcCCgouAwsKOwALCusACwpOAgsKoQMLCsMDCwrbAwwKcgAMCrYADAriAAwKTAEMCrcBDAo/AgwKVgIMCqMCDQoIAA0KfQANCsIADQofAQ4KxQAOCn8BDwo1ABEKPwATCi4AEwpiABMKagCUClUAhAvcAQQARwEFAN4BBwA0BYgA8QIFAPwDhQD+A4cLDwcEAGcAhQCRAQQA8wGHAI0FCgDPAA0ApACTCn4ACQsUAAoLRAGLC+gBhABgAAkLGAGKC4YAhwDIA4UKuwCHCgYFBQtwAAYLZwCGC5YACACSAwoAAwAECtcACQomAAsKFwALCn8AiwocA4cAjwEGADMCiQDgAAYAwAKGAL4EBAvEAggLDwAJCzIACQuCAQsLEgALCxECjAvkAAQLMwIHC20ABwtQAgcLfQIHCwIDBwulBggLtAEIC88BCQs8AAkLTwEJC4gDCgtJAAsLsgEMC0kCDQtLARILbgCUCzwAhgAXBoQL9gEGC1sBiguhAAQLIQAFC2YABQv0AQYLHAEHCzcEBwuPBQcLpgYIC9YBCQsqAgkL0wKLC00BBwv2AIcLSAMGCwoACAs7AgkL4wKPC1sACABdAwoAiQMMANoCDAAVA4ULcgKGALIDBQDqAgwATQEOAEwBDAtNAY4LTAEFCxIABgsOAg0LGAANC24AEwsFAJMLLAAEAI4DBQBAA4cK0gcKCwADiwsTAwQLNQEFC84BBwvKA4cLSQQEChwABQq4AQcK+AALCkEDjApYAYYKdgYGAHgCBgCMAgYA+AQGAGgFhgAYBoYLqAYGAHEFhQpVAwYK+QAHCtIEiwo9AgULVgAHC+cCCQtVAAoLGQEKC7ABCwvqAQwL+wANC3YADgt6AZILjwAFCwwChQvoAoYA6gUKAMkAjgA/AQcAzQIKAP4BBwqIAQgKFAAICqwACAqyAgkKfwEJCk0DCwolAQsKQAMLCpgDCwrYA40K3QCGAGUFBQpaA4UK4AMIABACiQBcAQoLawCMC7QBBAAUAIUAaAKGAOMEhAufAwoLewAMC54CDQtzAQ4LjgCSC14AhgCLBAcLfQSJC5wAhgAzAYULCgMHAEMEhwDlBgUL9gEGCgwBiQo+AAgLxAAKCxsBiwuWAQQAGgAFAK0BBgD1AAcAwAIHAGMFhwDCBYULVwOEAHEDBABtAocLPAYHC3gFCQu+AYoLLQAGAOACigpqAIUAHgKGAFwBhQBkA4gAsQGHANcFigADAwYKZQKICt8AigDXAI0AfACIC4cBhwusAIQKngKMADcACQooAIsKiAAHAD4AkwBwAIQAWAOECzgCDAAOAYsKAwEIADwCiQC6AgQL3AIJCjYBiQqqAo4KKAGGAKsDiAvdAocLmwUHCnkFhwrEBQYAYAEECigBBwqRAQcKggUHCjoGBwqKBggKPwAICpQCiQpKAAQLrAGFC5wCBAqLAAQKhAGMCrwABwvfB4wLmQKEAIcCkgAKAIoA3ACOANABhABtAIYA0gYGAAMCBArrAgYLVwYGC5EGBwqJAgcKxwWHCi8GhQroAIcANgKJCncDBAAoAAoAQwALAHUACwAAA4sApwOEACEDBwDgAwgALQEJANICDAA/AA0AHQAOAKEAjwASAIsAmwMGC9QGCAvLAgkLIgMKCy4ACgszAw0LNAEOC18BDgtrAZILQwCJC+kCBwB5BAQKDgAHCgkHCgrsAo0KygEECz8ABQtbAYYL2gGHADgCBAqpAQcLQQIHC5gFCQvbAQkL+QEJCw4CCQthAgkLsQIJC9YCCQvfAgkL4gIKCywCCguiAgoLrAILC1kACwvKAAsLEAELC3wBCwufAQsL+QELCxkCCwsmAgsLMgILC4ACCwubAgsLsAILC08DCwufAwsLogMLC6wDDAuQAAwLRQEMC0kBDAuFAQwLkwEMC8MBDAsDAgwLXAIMC2gCDAtyAg0LQgANC4MADQunAA0L7AANC3ABDQubAQ0LsgENC8UBDQvNAQ0L2gEOCzsADgs8AA4LiwAOC5gADgsUAQ4LYQEOC5IBDwscAA8LUQAPC3sADwuYABILiACUC1gAiQD3AIcLVgYJCyACCwudAZALGQAEAIUCBwA5AwYK6AaHC1kAjABIAQUKrwOGCvMGhgBTBQUK9QAGCkACBwpGAogK4QCGAAAFBQs4A4ULrQMHC7gBCAvmAIsLagAFABwABgDMAAoAQAEKAEcCDQD2AQ4ASAAOABIBDgA4AQ4AWAEPAJ8AEAA+ABAARQARAB4AEgAqABIANQASAFQAEgCMABMARAATAFUAFAAFABQALQAUAGUAFgAHAJYAFAAEAC4CBgCGAQcAogAHALECCQBoAYoAjQKGAPwCBgBeA4kAQQMFAFgDBgCIBgYA3QaGAPUGBQBcAAoA4AKMAGYABgCHBwYAmAcIAJwDCAC0AwoAxwOKANIDhgDHBQUATgIIAGgBCQDVAIoAPwCGAPEFBgDFAoYAewOECrsBDQDdAQ4AeACUAD0ABAuSAwULIAOFC1QDCgs2AI0LcwAEC5YDhQtsA4sLmAAEC1wAhQsSAYcLbQcJCyADCgu1AgsL4gELC94CiwsVAwkA4wGECioBBgC9BI0L8gGHC6sFhQvnAgQA/gMKAOgDDAC9AwwA1AMMAPUDDgDhAZAAdAAIAPcBEQAdAAQLMQAHCxgBhwthBocAsAaGANIBiAsvAAUKpAAHCnkAjgq9AAcKLAMHCu0EBwpQBQkKeAKMCmABiwosAoQA2wIFCxABBQuMAwULrgMHC/ADBwsYBggLxQAJCy8ACwsaAosL5gIECqwACQpjAgoKtAEMCqECjQr/AIUKTAMKAOQBCwDyAgwAyQEOAKsADgCFAZIAmQAJCgcBCgqTAIoK7AGJC3sDigDxAIUKGQIGANUHiADEA4kKSgOXCwgABAuXAYQLMAKHC1wHBgBMBIYA2gSHALoDBQrmAAUKiAEGCqQBCQo4AowKZAIEC9sBCwsjAAsLWgANCwcADQtHAA0LsQCOC6YBiAtMAYcApgcGACUCCAAiAAgAGwEJAKUAigDbAQoAuAMMAMYDjADiAwUAjAIFAL0ChwDBAQQAjwIHAFIDEQBLAJIAiQAEAJIABwBSBggAngIFCikABwqzBQcKvQUHCkMHCQolAosKiQOFCrgCBgCfAAYAbAEHAAQCiQAGAocAnwUGC94ABwt8AgcLVAYIC5kBCQu1AosLTQANAJcAjQstAAYAAwQEC1ABhAoDA4sLiAEKC3kACwuvAJULEAAIALYDigDXA4UKmQOHAOEDBgq0AAcKcQQICu8CiwolAwcA9QEJAG8ACgCNAAsATAENACsADQCtAQ4AggAOAJ8BkQBmAAQKtwAFC3IDBwoPAQsKOAMLCrgDDQoWAQ0KUwENCuIBDgqoAZQKYwAEChMABQrdAQUKVAIGCvkBBwrFBAsKiwMMCtEAjQrWAIcKvwSFAMQBhAuqAQUAlQCIAOkAhQCnAwYLOgAHC44CBwvpAgcLsQcIC/AACAujAgkL3wEJC9sCCgtKAQoLUQIKCzEDCwsgAAsLhQALC90AkQtEAAwARgISAIMABwtmAIkLGgKIACEDhgptBoQARgAGClwABgq8AAcK9QQHCvQFBwpUBwoK5ACLCvwDBArLAYUKxgOKAHEBEAAkAIwKSgGNC24BBwDRAgoA7AAMAMwABgoSAAcKpAMICvUCCQo2AAkKQQAJCkwDCgpxAAoKOwEKCh4DCwqZAAwKlwAMCogBDAqaAo4K+AAHAPEACgCuAQgKJAIJChQCCgp1AAsKXwELCncBjwoXAIYKzgaFCsUDhQs2AgYLMACHCz8Ahgq2AAoKQQAKCugBigrxAQYLcgAHC8gEBwsUBogLAwCGABkHCAtAAokLCwEGADYEkAAQAAkKTAKKCgQBigD9AwUAlgGGAOYHhQulAwYARQCHAHUABwAmB4gLqwEEALABhwA4A4YK+gaFADoDiwtDAIUL9wKHCjQBiQAwA4UA6AMEACkBBgARAgcAmAAHAMkCBwA1BwgAxgIIAM0CDAB/AowArQIHAKcBiApMAogKHwGIAP4BhgAYBAYAagIHCzgABwvFBwgLUQEIC+ICCQtYAgoL4wEMCyUADQu/AY4LXAAEAAgChwA/AggA3gOKANEDhwsGAwkLWwELCxgAjAuqAIgLewGMCiIBhAtIAQQAQQGGADkCBAtlAIcLkwQHANMCBwBvBAULQQOIC+gCBwrPAggKKQOICkIDCACZA4gKHAMFCtIABgrVAAcKPAAKCmwBiwqHAAUAjQEGAJoABwCkAggAuwEIAGECCQAYAAkARQEKACMACwAXAgsAoAILAPoDDAB9AhAAHgAFCl8CCApGAYgK6gEECr0CBQrYAQYLCQAGC40BBws1AAcLzgYJCvYCCgt4AgsLPAOMC5IAhwp8AYcKmweUC20ACgoWAYoLFgGGAFgDBwCLAAQKggEICpUBCArYAgkK8QELCm4ACwpoAQ8KJQCQClQAjQAaAYUA1QMFACABBwqsBQcKyAUICnoCjArYAQcAYgcIC28BCgv4Ag4LTwAUCxEAmAsAAAQKDAKICioDBAA4AAcA/wYIAF8CCACLAgsA0QELAEMDDABRAY0A4AEKCu4AjQohAAsLoQEMC98AjAsJAQkAngAKAJsBjAAFAYUKFAKFCuUDDAu6AAwLJAEOC2QAkgtGAAYAewWIAGkChgC1BIsAMwIEAPIAhgBNAQQLugAFC50ACAuoAIoLBgCEAHEBhQtrAwUKDgMFCj0DhgrKBoYAbgKHC/gEBgB/BQcLbwCIC0UCBwofB4sKtQIHAKAACgBwAo4AFwGEAGsBCgtNAgwLbwANCwQBDgtSABILPwCTCy0ABwtUBQcLcweNC54ABAuUAQQLkwKHC6MCDQvTAA4LhQAOC8wADwtAAA8LRQAPC3IAEAsKABMLFwATCyMAEwsnABMLMwATC0cAEwtLAJgLDwAECk4ABQpgAAUKtgAHCrwGBwohBwoKigEKCtcBCwoUAg4KVAGRClgAhwqsB4ULhwELC3cDDgttAY4LdwEFCxwCBguhBgcL3gCIC1UBhgtOAAkAWQIJAGsCCgD5AQoA3AILAGMBjACLAIYAJAGLAK4ABQCxAAYAaAIHADsDCQANAooAkAIKAB8ABgrXAAcKBAQHCsEFBwq5BgkKqAGKCgsDhwpIAogLJQGGAK0ChwtMB4ULzAEHAIcCBgpDAAcKXgYJCmIBCQqjAgoKPgMOClAAkQpQAAQAoQCFAHcCBgqNAAcK4QAJCjsACQpfAgoKOAELCq8CDAorAg0KdQENCu4BlAo6AAcLxQMHC7QFhwtEBogKDwOGC4QBBgDSAgYA8wQEC/8BCQtNAQkLewEKC1oCCwu5AQsL0wILC9ADjAtlAYYABQeHAJQGCQDVAQkAxQIMAAACDgBBABEADAAFC6oDiAvDAgcAzgSIABMCCgDlAAsASQALAHgBiwCxAQwADAEMAIACjgB3AAcKrgGLCi4ABgAuAgcAiwIIAKUBCQAAAAoAIgCLAPADBgBqAAcA+gYHAB0HCQBmAAkA+wIFCloCBwriB4kKogEFAEEABgCgAQcAuAYHAIQHCgBtAAsADgALAEYACwA5AgsA3wIPAJkAFABQAIgKpQKHC1kGiQsEA4gAUwIGC9UBBwutBooLAwIHACgHigB2AQkAagAJAKMACQAoAQoApwAKAKwACgAJA4sAEAAGAAYABwBRAAcAAwMHAMMGCQCVAYoApQEEC/QBhwuqAwULRACGC38BBQBxA4UAdQMGAFYDBgBsBAYA1wUGAPYFBgD9BYYAKQYEC1EBBgthAQcLjgcIC+gBiQutAQcL7AAHCwMHCAsDAQkLhwAJC7EACgs5AwsLcwALC3IBCwuVAQsLXAIMCwoADAubAgwLnQINC0wADgs2AQ8LTAAPC5MAlAsXAAUAjgCGACICBAsPAAULFgAGC/QABwsoAAcLyAAHC4oDBwuvBAkLaAIKC8wCCwt7AgsLIQOMC8oBBQDSAQsAOwIMAMYADQAbAQ4AugAPABUADwBnAIcKSQEEALkABQABAQUARwMFAKgDCQCPAQoAAgEKAIsBCgDeAgsA9gMMABcADQBeAQ4AlgATAAYAhwvHBgwLJACNC1EBBQtWAgcLFwMIC2wAiQt7AIQK1QEHAJQBBwBhBQcAlgUHAOEHCACVAAgA7wAIAAACCAAZAwgAMgMJANoBCQBTAgoAegAKADUCCgCJAgoADwMLAO8ACwAnAQsAvwELABACCwB/AgsAIAMMABkADABNAAwAnQAMAAABDAA8AQwAhgEMAIcBDACLAQwA3gEMAPcBDABQAgwAqAINADIADQA1AA0AhAANAMYADQBCAQ0AnwENAP8BDgBHAA4AiwEPAEcADwCIABEAewASAF0AkwA6AIgAyAKGCs8GBQqhAwYKVAEICngBiAonAwYAOAcIAFwDCgBYAwoAWwMKAJ0DCgCtA4wA+gIGAHUCBgCKAwkAKgOMAIwCBQraAAcKSgaKClMABwroBYcKAgcEAHkBGAANAAQLmwAHC5kGCwoAAJAKTgAEC6QABQuXAAUL2gIFC+UCBwvyAQcLZgMHCwYGDAvVAA4LJAAOC4cBEQtvABILBgASCy4AEguXABMLJAAUCyAAFAs4ABQLRQAUC2YAFQsEABYLCAAWCwoAFgsOAJYLHwAHADIHhQo7AgQKxwEEC3AChwvYBoYA3QUEC+wBBQvDAQYKoQAHCnQBiQpVAoQKXQEEALQAhwByB4cLQwONC0YAhADrAYkK7wIGCrABiwpCAQQAqwCKAOoABgtxAIcLtAEEAEoCBwCiBIoAdwIFCtQBCgpFAQsKWAMMClkBjwpoAAUK3wAKC1ACCgvxAgwLPQEMC2MBDAvRAQwL1QEMCzACDAtCAo0L8wCECjYChwsIAgQKOwCHCnIFBgq0AYsK4QEJAKMDCgBOARQARwAECjAABQoPAQcKuQOHC1YHCwCqAAUKYgKICskBhQrzAgYAMwaHCsEEBArFAJULGgCFC0kCiQsJAoUA/QKFCtkAiwtKAoUAqAEJC/ACDAtiAg0LrwEQCzsAkgttAIgAygIHAK0ChAszAQkApAEKAA0BCgAdAQoAQAILAI0BDQCvAJEAWgCEAK0BhQvEAwkLzwGKC1MCBwASAAcAuwIHAK4HCADwAgkAEQEJAJwBCQC/AgoARwAKAKsBigD8AQQKpQAHCnYFhwolBwQANQAFALoABwDwAgcAPAOOAHQACAA/AgoAIQGLAD8BhACjAoYAkAUEC0sABQu0AAYL9AEHCzoABwvGAooLhQKFC4kCBgsUAQcLGgEHC28DBwucAwgLywEJC1cCCQvyAgsLPgIMC4AADAvuAQ0LNAANCy0BDwseAI8LhAAGAIcChgBHBAUKCQAHCikBBwrGA4wKMgGEC8gAhgA2BQUKkgAGCpsBigrRAgYA0QAGAHUEBgAIBQgA1AEJANIACwAkAAwAHAAMAHYCDQAVAA0AXQEOAAcAkQANAAYKsQCHCtMBBABWAYcAmwQKC8YBjAtEAQQAoAOFAI4DBwAuBwYL4QCJC9MAEABlABQAcwAUAHYAlAB6AAQA8AGHAFgDBAA+AQsAjgIHC84CiwtmAAgLOgAJC9QCCwspAw0LcQCRC0gABQrIAAYLWQGHC98ECAv/AggLIwMJCy0BiQuHAwcAkwMIAPcAEwAAAAcLnQeIC6ICBADKAAUAfgEGAMYBBwCoAwcACwcIAPYCCQB3AQkAfwMKAOcCCgAYAwsA0gMLAPQDjgBtAAcAfgQHAJEFBwCtBYwAAQKGCwMBigAXAwsANQMMAG4ADACZABIAKQCWABMAhgrhAYQAHAMGAL0BCQCNA4gL/gAKAAgDDQBZAY4AqQEEClQABwrKBQoKTACKCo4AhwvmAgYAQgKFCvcDBgBrBQQKOwEFCvsBhwpaBQQAtgGFACsCiAD+AoUL+ACGCroGBAt0AAULXwAFC70BBwuYBggLHQAJCxABCwv9AYsLkwOHAB0ChQsfAggK3gAICtwBCQruAAsKBAILCj8CDwptAJIKZAAGAHADhgCnBAULtQCICykAhgDiBYQLqQIHCxkACAvKAIoLGAKLANcDiQAAA4QASAIJC6cBjAtZAAgLcQAJC20DCgsqAgsLUwAMC4gAkwttAAcKwgIHCiIEigoaAoUL0AMEC84AhwvqAogLDgKMAOECCwpcAAsKxAALCpkBCwrCAQsKmgILCgkDDAoGAQ0KgQENCokBDwpzABAKLQCRClIABADiAAQARgEHAOoGBAs/AQULuwKKC6ECBgooAIcK9QYFAKoBCAAeAAkAAgALACUCkwB6AAYAiQSGADEFigphAAYKpwEHCpkChwq6BAcLDQAIC+IACgsZAgsLOgILC10CCwsfAwsLJAMMC1UADAsEAgwLbwINC3AADQtpAQ4LTQAOC04AEQscAJMLbgCECwEDhAsnAoQL2AKTAHUACQs5AAkLywEKC6kBCwt3AAwLuAAMC3MBDQtmAZELMwAFC7wABQsuAwgLCgAJC6UBCQvZAgoLYQKLC7EChgtwAocLKgGHAM4BBABZAYsKcAKICj4CBACBAQcACQGHAEsCBgAoA4QLEAKFAI4BhApiAQQAWwEFAKcBBQDkA4cAMQWHChYGBwDrBAkAfQCLAEEABQCIAAYAiACIAIQCBQtoAAYLrQCHC18GhwDVAYUKPgMEABYBBQDRAYcAVwUHCyoDCAuKAAgLVgEJC1QACgvBAAsLcwOMC2cBBQrwAYcKywAEALEBhQDPAgYLXwCGCiMCBQpYAIkK7wAGC5YBCguZAQoLvwELCywAjAtkAIYAjwUHCooChwoeBYYA7QKHC9sEhwBTBQYAfQEHAIUCBwC2AggAIgIHCjQECQpQAAsKTgALCqUBCwoWAowKIQKGC2QGhwtABQwAFQEHChIBCwrfAYsK+wEGAMECBgAPAwYA+wQGAMkFBAsaAQcLCgQLC44BCwt6AgwLAQAMC08ADAsgAg4L7QARCwoAkgsUAIYAxQEEACsCCAAYAgoAIAELAO0DBArxAYcKMAYFC3YABQvzAQYL3AEHC1gCBwt4A4cLSASKANsDBwBTBAcKBQEHClsEBwpKBQcKNAYHCqkGBwpuBwkK0QEKCvgACgpdAQoKhwILCg8CCwqUAgsKnQIMChECjQoxAQcLKAEHC1QCCAswAggLSgIJC2QCCwtkAAsLMAEMCy4ADQtZAA4LcACRC3oACQByAYoAWgCICg0AhABcAwcKggIICvoACwp7AAsKiQANCjAAjgpfAIcKlQWJC0EBhAABAYcA7wcHAOgGBws/BgcLuwYIC08ACAtqAAgLvgAICy4BCAt/AQkLdwAJC+kACQsqAQkLowEJC9cBCgu1AAoLlgELCzkACwtVAAsLeAALC7EACwsoAQsLfgELC8YBCwv2AgsL5wMMCxsADAtiAAwLgwAMC/UADAs4AQwLvgEMC8YBDQsZAA0LYgANC6oBDQv8AQ4LBgAOC6MADgsQAQ4LFQEOC3IBDwtfAA8LigAPC6cAEQsSABELJgAUC2AAlQsgAAUL0gKGC98GkQsQAAYALwSGABkGCgohAowKLQEGAFMABgDFBocAbQUEAEMDhwAaB4ULAgEECogDhQoaA4YA1gcFCx4ABwvvAQgLhgAJCxQDjAu2AYcL1AeJALgCBQsyAAYLtwEHCwwDhwsQBAcLBAMHC1AEBwtvBgsLDQELCxsCCwtfAgsLcwILC8ICCwvPAwwL+AAMCzcBDAuyAQwLWAIMC24CDQspAQ0LbwENC+UBDgtFAA4LmQGPC2wABQsBAAYLUQCKCwgCBwC2BgkAXwAJABIBCgAXAQoAPQEKAKQBCwAvAQsAKAMMAIYADABvAQ0AlQANAFsBDgBdAQ4AlgESABYAEgBZABIAegCTAC8ABQviAQgLYgAJC6wACgveAAoLvAIKCzYDCwsuAQsLCgMMCzIADAt/AAwLjAENCz4ADQtIAQ4LegCTC0gABwqCAYoKyQIGCgcABgojAAcKkwAHCi0EBwogBgcKJwYHCn0HCAorAAgK0AAJCoAACQpiAwoKFAALCtUDkwohAIUAGgCEACYCBQsCAAcL1gWIC00CBgsAAgcLHQMIC/0ACQtNAAoLAQAKC4EACgvhAAsLdgALC+IACwv7AAsLrgELC70CCwvOAwsL1gMMC0AADAsEAQwL6AGMC7ICBwp9A40KqAGGAIUDiAA2AwQAhgMFACkDhgB6AAYAJwOGAFYFBwAGAQUL7AKGCykChQBsAgQAIgAFAD4CBwAXAQcAWAaIAFkCCQCqAAYKQgEJCigCCwoSAQ0K0QANCvMBDgpVAA8KfgCRCkYAhAAZAgQLDAAHC6QBBwsKAgcLKQMICx0DjQtYAIUATAEIClMACArmAggKMQMJChwACQodAAkKdQMKCoMBCwp5AgsK5AINCusADQr+AA8KjwCPCpIABgB1BwkAxAMMADYDDABWAwwAYQMMAI4DDACqAw8AqQAPANAADwDTABIAzQASAM4AEgDcABIA3wCYABgAjAoxAAULEAKHCywGBgAFAQgAtgCLAK8DhgC5BgQApQOFAHADiAtBAQULCgEJCyIBCQtsAQoLJQELC14CjgstAAYASQYECzIABgv+AQYLUgIJC3kACgsxAAoLnAGLC0IDBwB/A4gL7AKEC9IBBApuAAoKnwEKClUCjgrOAIUALAOHCxkBBgBiBwYAbgcGAHwHCQChAwkArgMJAM8DCQDYAwkA2gMJAPMDCQD7AwwAJAMMAFMDDABjAwwAlAMMAJsDDwDCAA8AzAAPANIADwDeAA8A3wAPAOUADwD6ABIAswASALoAEgDAAAcKzQCHCtAHhAubAocACgMEAIkABwCaBIcA8AWGACIFBAvyAIYLTQEGAH0GBwC3BwcA2QeHANsHhgA3BgQKGwGHCqoECwA0A5YAMwAECycABQskAAcLMwcIC5cBCwuQAIwLCwKGCrgGBAv+AQcLHQAHC0IABwu8BwoL5wEKCykDkgsJAAUAWQAHAHsHCQC5AAkA6wAKAEAACgAOAQoAkwEKANUBCgARAgoATgILAIwACwBcAw0AAQANAKYBDgBVAQ4AbAERAF0AEgBxABMAYQCTAHEAhQC3AgYA2wOGAIgEBQAGAAYAtwAHAKgCBwDSAwcA9QMHAB8EDADmAA0ArACSAB0Ahgs6AoQLEwOGCwYCBgAdAIsAPwCECwQCiAs1A4QANwGGAMwGBwCqAAgAWgAIALEACACfAQsAygIOABkBiArfAoYAqQeHC30FBAsKAAcLlQOLCxIDBQqEAAkK5gEJCssCCgrKAQsKdQELCpwCCwobAwsKgQMMChABDAqoAQwKGwIMCi4CDgr1AA4KBwEOCggBDgqJAY4KkwELAFsADQCBAA8AZQCRAH0AhwBsBAQA7gEGAEoABwAsAAcAlwEMABEADwAFAJQACwCFCnsBBQAOAQULrAIGClkABgqQAQcKIQYHClcGBwo6BwgK2gAICqYBCQo6AooKcgIEABQBhQAoAQYA8wWGCxsABgqDAQcKcgONCm8ABgrgAAcKbQOJCocChwoWAwQABwAFAFoABQCeAAYAHgIHAN0ABwAmBgkA6gEKABwCCwC7AYsA9QIHAEwCCQCvAIoAEgKHCooBjgsXAIYAEgOHAEQCBwBYAIgAcwIFAGgDBgA5AAcA1wEJAL8BiQDGAQYLVgEGC/ABCAsTAYkLzgAEC40DhQusAwYA3wKEC3sDCABNAwgAlAOHCoEFBQAfAIYAZgILAMoBDAAPAIwAsAEIAEoBjADdAQQAEgIFAAkCBwCwBAoAzAGEC68CBgCoAYcASgcJADkCDAAMAAwAUQAMAD8BDQBFAA4AAwEQAFcAEQABABEAFQARABgAEgAPABIAOAASADsAEgB/ABIAmgATABMAlAAfAAcAFgWICiYAhgv9AAUKBQEHCk4ABwrHAAgKLwMJCn4AigpWAQUAUwKHAEcHBgspAI0LoAAFAA0AhgCOAAYAYQAHAHQACABCAQgA8wIJACQCCgDKAgsAdAMNAEQBBwsYBYoL3QGECnQChgu2BgcKCgGICiQDhwrQAAcA/QMGCk8AhwrvBQcAwAWHABIGBgtqAZILMwAHAC8EBwAFBgcA5wYHAA4HCwCiAAsA8gALAMQBDABdAg8AGgCQACwAiArlAoULcwCRAHMAhgp4AQYAfgWGAAcGBQvBAAwLsgANC4IAkQtUAIcAVwQIAAEACQCKAgoARgEFC8ECiQteAgUA6AEGAA8CBwDpAQcAZAYIAHkACACQAAgAZwEJAMEACQDxAAkAUAEJAHIDCwAKAQsAdAELALADDACRAYwAgQKHC64ABgALAQcK9AAHCngCBwpJBggKsgAICn4CjQo6AIYAvweGAIMEhgAnBoYAngUJAB8ACgD0AAoAuwIMAJUAjQDxAYUAeQEEC3oABQscAwULuAMGC3wGBguHBggLNwIJC68CCQvmAgoLrgILC2QBCwuqAowLGQGRAGUACwsAAJALTgAFC7MABQoXAwcLRwSHC70ECAt0AQkLegCKC68ABwquAggKIQAICu4ACgpoAgsK0wELCnEDDQrZAA0K/QCOCgwBCQDcAQQLQgAHC9IChwuIAwcLYAGJC6wChwDnB4cALAeECr8BBQBLA5AAIwCJCwsDjQsjAAQKgAAFCp8BBgrOAQcKJgEHCkICCgrGAosKVgCEACoChQAYAogKSwIFAM8ACQBPAAsAcQKRAAcABwBbBQYKqwGKCrQCBACoAQQKwwCHCiIDCAARA4ULNAKHAFABBACAAwYA8QaGCywCiQtnAIYKkwYHCyACCAvPAooLPQCKCtgBBAsFAAUL8gGIC30CBwDuAgkA3wALABsACwDSAQwAcAIOAAkBkgA9AAwA7gASAJsADAvuAJILmwCXChwAhQufAwwAfwEFCgMACApCAgkKdgAKCsECjQoXAQQLfQMFCwwDhQt9AwQAWwKFAJUCBAALAAYAgAAHAOcABwD9BQoA1QIFCuUABQvuAIcLRgUICmYACgpCAgoKoAIMCvABDQqYAQ4KeQCRCmoAhADcAYYAEAaGC8EGCApzAAgKXgEJCukBCgqAAAsKMgEMCnUBDgoeABEKTwATClAAlgo3AIcADwcEAKgCBAs8AAcL+AIHCwgHCAs6AQkLvAKLC+cBBArmAAUKvgKUC14AhAvkAIsAswEJABQACgBEAQoAJwOLAOgBBgrABogLowEECuQBEgoaABMKKgAUCisAFQoAABcKGwCYCg4AhwCXBYULPAMFAHAABgBnAAYAlgAHABcFCQAkAQoA4QEUAA0ABwuwAAcLsgAHC1YECgvhAZQLDQCKAGQBBAszAAULJwAGCwQABwtPAgcLUQMHC7cDBwtpBAcLTQYHC+AGBwvEBwkLsgEKC/ICCwsZAAsLJQCLC54BBgCrB4YA0AeECnkCBgDcBIULhgOHC6ADjAASAIoAzACHC5UEhgBjAwQAxAIIAA8ACQAyAAkAggELABIACwARAowA5ACGCw4BBAAzAgcAbQAHAFACBwB9AgcAAgMIAM8BCQA8AAkATwEJAIgDCgBJAAsAsgEMAEkCDQBLARIAbgCUADwAhAD2AQ4LZwETCzQAlAsvAAYLeQEHCwEECQtlApELaAAGAFsBCgChAAUKRgAFCm4CBgpOAQcKCAQJCqsACwoaAAsK1QALCn0CCwrDAgwKygAMCnwBDQriAA0KYwEOCt4AkQoqAIQLoAEEACEABQBmAAYAHAEHADcEBwCPBQcApgYIANYBCQAqAgkA0wILAE0Bjgt0AQULmAAFC8UABwtUAQcLYwMKCyQCCgtFAgsLBgAMCwMADAsTAA4LbgCOCyEBBwD2AIcASAMGAAoACAA7AgkA4wKPAFsABgDRAQcAuQUEChcABAqNAAUKOQEFCvYDBgoyAAcKjgAHCi8CCAqAAgkKzAEJCg8DCwrlAgwKtwCNCugBhQByAogAZgKKAO0ABwsiAAcLvgAICxwACAuNAAgLvAEICysDCQvUAQsLTgEMCxgADAuCAYwLQAKFC/UCBQASAAYADgINABgADQBuABMABQCTACwABgD6AYYL+gGHCxEGBAA1AQUAzgEHAMoDBwBJBBYAHgAWACEABwtpBQsLRgILC4oCCwuFAwsLtQMMC+gADAvsAA0LnQENC/UBkgt0AAkAjAAFCt4AigoWAgYAIASJCooDhgCoBooK9wGGAAwEBQqaAAcK0wUKCnsBigrlAQQLfwGFCswChgAjBQUAVgAHAOcCCQBVAAoAGQEKALABCwA5AwwA+wANAHYAjgB6AQgACAEEClsABQqEAQUKTQMGCs4ABgr8AAYKbQEHCogABwoTAogKbQIFAAwChQDoAgULFQGNC/cAhAuzAQoAawCMALQBhACfAwoAewAMAJ4CkgBeAAcAfQQJAJwAigC9AwULCQEGC9QAhwscAIUACgOFAPYBCADEAAoAGwGLAJYBhwpAAogLFwKGACAFBQoDAwUKXwMFCoIDBgpgBgYKbAaGCvQGBQBXAwUKSwGHC88FhAu+AgULKAOHC/0HBwB4BQkAvgGKAC0AjAp4AoQA6wMFC6YACAvjAowL/wEFCmsABwrJAIgKBgIGCr4BhwoZB4YA/AWGAEkEBAt3AAULqgAFC78BBwusBgcLYQcJC2UBCQvPAgwL5gGMC1QCCQpTA40K/gEHAGQCCAAhAggAOAIIAIICCQDNAgoAHQIKAPsCCwDBAQwA6QENAJkADQAoAQ4AigAOAIgBDwAyABAABgAQAAwAFAAJAIQK+AEEC8IBhwuGBAsANgANAK0ADQAmAQUKcwMFCs8DCAqIAZQKBwANAMcBDwBjAA8AgQCQAEQAhwCsAIQL8gIFCpoDhgqrBoYABQQRCycAlAskAAQAOAIFCuEDBwoDAokKWwCEANwCCgBpAooLaQKGAM4DBwDdAwoAeQEMAGsBDQBEAA0AXgAOAGwAjgAyAYgA3QKEAKwBBwD9BocLJgQHAN8HjACZAocKmQUFAB8BBwqZAwgKRAIIClECCAp2AooKHACKACYDBAqPAwUKYwMFCvUDBwryBwgKHgOICi0DhgADBggLCwKWCyIAhwvkAgcL7gAHC/EHCAt4AAgLvAAIC5MCCQtWAgoL0gEMC1YBDAtMAg0L9wEOC/YAjwtcAAcAGwaNALYABQqHAAYKBwIHCroGCgoPAQsKBQGRCjYADgpSAZQKUQAHAOQBBAosAYUKtAGRC3IABgBXBoYAkQaFC4ACBAvJAAcL0AYIC1oCCwv3AAsLOgORC0EACAukAJILPgAGACkHBgBFB4gAbgOGACEGCAplAQoK6QIOCqoBEQpeAJMKOQAMAF0ADAD1AQ0AagEOAJcADwAoAA8AOwAQAC4AEQAZABIADgASAIYAEwAZABMARQAUABAAFAATABQAQgAVABcAFQAZAJYAKgAGANQGCADLAgkAIgMKAC4ACgAzAw0ANAEOAF8BDgBrAZIAQwCEAOIDBAA/AIUAWwGEAE8ChQDtAgcLKQYKCzABCgslAgsLqAEMC20BDQvcAA0L8ACOCyEAhQBuAQcALQIMACMCDgBWAIUKgwGHANMGhAuLAwULZAAKC0kBDAugAZULHQAECgYABQrEAogKSwAHCkcFCQpFAgoKfwILCsUBjApIAgcAWQCECi8BigoEA4QLsAAFC3wCBQvmAwgLGgCJC2YBBwsJAAcL5AUJCz0BCgvSAAoLJAEKCxUCCwsrAgwLDgIMC18CDQsHAQ0LywGOCw8BhgC3BQYABAMGAHEEiwtTAgcA0QOLC0IAigB9AxQAMACUCzAABQA4A4UArQOGCycBBwAHBgcA+QYKALICBApqAIsKzQIHALgBCADmAIsAagAFCnoDhQrcAwYKcgKOCq8BCgt/AI0LGwARACAACgrCApYKLACEANgAiQBMAQQKugKIC3cAiwsLAYoKEQALCw4CCwurA40LIgEHC48ECwumAw0LhwGRC0wAiwsnAIYKVAAEAJIDBQAgA4UAVAMKAKABjQBzAAcANAKOAKgABACWA4UAbAOGAOQGmAADAAQAXAAFABIBBwt+AIgLVACMCvIBiAsWAwgA9QEFCtoDBgqCAAcKLgYICsoBCgplAAoKPgGKCjcDBgtAAAwLeQGNCzUBBQDnAooAUwMEADEABwAYAYcAYQaGAG8DiAAvAAcKbAaJCoEAhABhA4YAsgQJCyIAiwvkAYcK5QMFABABBQCMAwUArgMIAMUACQAvAAsAGgKLAOYCBgukBgcLGgAHCyUBBwt+AQcLAgQHCz8EBwvrBwgLGAAIC3IACAv8AAgL1wIIC9kCCQseAAkLxwAJC+cACQv7AAkLTgEJC2kBCQvoAQkLyAIKCzcACgs8AAoL6AAKC0wBCguAAQoLjAEKC/gBCgseAgoLjAILCxQACwswAAsLzwALCyMBCwsqAQsLVgELC20BCwuKAQsLbAILC8ECCwv5AwwLewAMC1QBDAuWAQwLgwINCz0ADQsNAQ0LNwENCz8BDQvmAQ4L6gAPCz4ADwtVABALRwASC3cAlAtpAAYArwWWCyUAhwqHB4cAdweJAHsDBwrcBokKYgAHChYEiwqgAIQA+QIGC3sBBwsOAQcLXAQIC7AACAu3AAkLsAEJC5UCDAv3AAwLaQKSC30ABgotAAcKsQEICoEACQoVAAoKiAELCk8ADArzAQ0KxwCNCsMBBACXAQULGAOFC4QDhAAwAocAtwANAOoBBwouAogKYQEEANsBBgDbAgsAIwANAEcADQCxAA4ApgGFChEDCApRAAkKvQAJCskACwreAQsKyAKNClIBBACiAQQAMwOFCmEBlwoaAAQLhQOFCwgDhAA/AgcAMgMQAFwAEQAOABEALQASAEsAlAASAAYA3gAHAHwCBwBUBggAmQEJALUCiwBNAAYKGQAHClcDBwrqBJAKIAAGAFgHBgBfBwYAfgcGAIQHCQDHAwkA4wMJAPcDDAA6AwwAUQMMAFkDDABcAwwAdgMMAKQDEgDkABIA5wCSAPAAhgB5AoYAHAUECyUABQtOAYcL5QQKAFYABAoEAAcKXgQHCigFBwqqBggKFQEJCm4CCwrUAgwKXgEMCo0BDQocAA0KnwAPClkAEgoFABMKCQAUCiIAlgovAIQL/AGJC8ABDAtrAJILHwCEADEDhgCXAoUAcgOGAJIDhAscAoQLFQKIC2ACCAB1A4oAYQOEAKoBBgA6AAcA6QIHALEHCACPAQgAowIJAN8BCQDbAgoASgEKAFECCgAxAwsAIAALAIUACwDdAJEARACGCv8ABwBmAIkAGgKJCtgABwv9AIgLJQKHC5ADCQq3AIsKHgELCrwDlwoDAAgLDwISCzwAkwsYAAQKGAIHCnUECgrTAosKcwGFC5gDBwBsA4cKHQGHCjAChAqyAo4LfgALCiEADAo7ApUKAQCFADYCCQCLAAoAjwELANUBDAB6Ag0A3wCEC+MBBgAwAIcAPwASAAwABwpGBwwK6wEMCggCDQp/AY4K9ACHC4EGhAvAAQkL7wGSC2gABgByAAcAyAQHABQGiAADAAQKvgCFCioCCABAAgkACwGFCukDhQq+AYUApQOLC/EDCAuNAg0LXQCTCw4ABgC0AgYANQOGADUEBQusAIcLIQOKAPACBAB3AYYAfgKGAPMDjAscAgkAYACFCwQBiwtLAocKzwQMAB4ADQCUAA4AVwAOALYAEAAqABQARgCECjABBgB2BQcAOAAHAMUHCABRAQgA4gIJAFgCDAAlAA0AvwGOAFwAigCaAgUAigEHAOcBiAD2AAkAtQEGCjUABgrHAAcKgAUICiAACApdAAoKjQEKCnUCCwpRAgsK+wINCkYBkQojAIYKaQAJAEABCgD6AYoKGgMHCzkACAunAAgLdwEJC1IACQsxAgoLbAIKCwIDCwrAAo0KjAEGAOsDBQpyAAUK/wCNCh0BBwBiA4cAiwSFCxMChABIAQcK8wcIChMACQpZAIoKPwMIC8IAiAv0AogA6AMFC8UBhgu5AQQAZQAFAEEDBwCTBIgA6AKFANYCiArqAooAsAAGAAkABgCNAQcANQAHAM4GCgB4AgsAPAOMAJIAhwsWAJELQACEAEcDCwChAQwA3wCMAAkBBAtmAAcLLwMHC6MGiwvEAwUKuwOICi4DBgCLBwYA1wcSAPYAkgD3AAgAxgALAB0AjAAWAocA6wYGAE4DBwvyAwsL3QILC/cCDAszAg0LIgAOC2UAEgstAJILgQAEALoABQCdAAgAqACKAAYAhAuDA4UKOACUCmQAhQBrAwUABQMFAN8DBgBjBoYA/AYGAPoECQDdAY0ATgAEAH8CBwBvAAgARQIMALEABgs0AAkLaAAJCy8CCgoEAAoKDQALCn4CDAs0ARMLVwCUCjkAhAtcAgQLLQGFCuIChQr2AoYA0wYHC6AFCwtWAwsLaAMLC5kDDAsnAg0L2AGOC28BBwBUBQcAcweNAJ4AhgBpAwQAlAEEAJMCBwAoAocAowKHClgEiwpIAQcL/AGJCoUAhQCHAQUKbgAGCqkABgqmBgcKkAEIChoCCQq4AAkKDAKMCtoABgs2AQcLOQcIC0gACAsQAQgLrwEJCwwACQtfAQoLMwIKC3YCCgsqAwsLbwELC1cCCwuuAowLoAIFABwCBgChBogAnAKEAHMDhgBOAAwAdAISAE8ABgqFAAkKYQGLCuEDBgu1AAcLGQIIC0AACQt/AAoL8AEMC/4BjQuAAQYKXQAHCo4FBwo7BwgKoQIJChECjAorAIkKcwGGALQFhgDCAwQL9ACHC+kACQoZAAoK0wGKCi8CBApPAYcKrgOFAMwBhwtOAYYLcgYEAMcAiwAiAAUKWQIICicACgoFAwsKVAAMCs0AjgoBAIUKZgOGAIQBDgDaAZQAeACFC3EBiwAPAQQA/wEJAE0BCQB7AQoAWgILALkBCwDTAgsA0AMMAGUBhAq1AIYAYAKGCnQGFgAxAIkLUgGMANwDhgBpAgUAqgOIAMMChAphAAUKkwAGCh4BBwpSBY0KsAAGAPQChgB9BIULgAMGCncBBwqpAAcK/gCICgwDhgAvBocKpwWLAB0BBwtdBAgLiQGICxsChwBYAQYA1QEHAK0GigADAgUKdQKHCg0GBQsEAAULKgMGCw0ABgsaAgYLmgYGC74GBwvzAQcLGwcIC5QACAu4AggLFwMMC30ADQs2AI8LCQCHC/QEiQCUAYQA9AEFAEQAhgB/AQsA2ACLAFQBBAudAwULIwMIC7oCigs8AwQAUQEGAGEBBwCOBwgA6AGJAK0BBwDsAAcAAwcIAAMBCQCHAAkAsQAJAFwDCgA5AwsAcwALAHIBCwCVAQsAXAIMAAoADACbAgwAnQINAEwADgA2AQ8ATAAPAJMAlAAXAAQADwAEAOoBBQAWAAYA9AAHACgABwDIAAcAigMHAK8ECQBoAgoAzAILAHsCCwAhA4wAygEMAPQChAqkAYYA4AUGAPUChQt/AQYA8gSHAMcGBQBWAgcAFwMIAGwACQB7AAcKIgaMCh4CjguaAQkLlAKKC1sBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwBBuIXiAAv8AQEBAQECAgICAwMDAwQEBAQFBQUFBgYGBgcHBwcICAgICQkJCQoKCgoLCwsLDAwMDA0NDQ0ODg4ODw8PDxAQEBAREREREhISEhMTExMUFBQUFRUVFRYWFhYXFxcXGBgYGBkZGRkaGhoaGxsbGxwcHBwdHR0dHh4eHh8fHx8gICAgISEhISIiIiIjIyMjJCQkJCUlJSUmJiYmJycnJygoKCgpKSkpKioqKisrKyssLCwsLS0tLS4uLi4vLy8vMDAwMDExMTEyMjIyMzMzMzQ0NDQ1NTU1NjY2Njc3Nzc4ODg4OTk5OTo6Ojo7Ozs7PDw8PD09PT0+Pj4+Pz8/PwBBvYniAAsFBAQAAAQAQdSJ4gAL4AEIDBAMDBQMEBgcDAwgDCQMLCwsLCwsLCwsLCAgGCgcDAwwNDQ0MDQ0NDA0NDQ0NDA0NDQ0NDA0NDQ0NBgMHAwMDDg8PDw4PDw8ODw8PDw8ODw8PDw8ODw8PDw8GAwcDAAAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwBB1YviAAteAQEBAQEBAQEBAQEBAQEBAgICAgICAgICAgEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgEBAQEBAQMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAQEBAQBBlI3iAAugBAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAgICAgICAgICAgICAgICBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoMDAwMDAwMDAwMDAwMDAwOAABAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgcAQb2R4gALBQQEAAAEAEHUkeIAC+ABCAwQDAwUDBAYHAwMIAwkDCwsLCwsLCwsLCwgIBgoHAwMMDQ0NDA0NDQwNDQ0NDQwNDQ0NDQwNDQ0NDQYDBwMDAw4PDw8ODw8PDg8PDw8PDg8PDw8PDg8PDw8PBgMHAwAAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAQdWT4gALXgEBAQEBAQEBAQEBAQEBAQICAgICAgICAgIBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgIBAQEBAQEDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwEBAQEAQZSV4gALxQgCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgABAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgcEBAQEBAQEBAQEBAQEBQUABAQGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsoKW1pZCA+IGxlbgAAAMiOGAAJAEHkneIAC6IBAQAAAI4FAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAI8FAAAAAAAAAQAAAAIAAAADAAAABAAAAAUAAAAGAAAACAAAAAoAAAAOAAAAEgAAABoAAAAiAAAAMgAAAEIAAABiAAAAggAAAMIAAABCAQAAQgIAAEIEAABCCAAAQhgAAEJYAEGgn+IAC6YBAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAADAAAAA4AAAAYAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAADAAAAA4AAAASAAAAFgAAAB4AAAAmAAAANgAAAEYAAABmAAAAhgAAAMYAAABGAQAARgIAAEYEAABGCABB6KDiAAtdAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAAGAAAAPIkEABiAAAAdgAAAAUAAADyJBAAYgAAAHYAAAAaAEHUoeIAC/VkBwAAABcAAAAnAAAANwAAAEcAAABXAAAAZwAAAHcAAABwBwAAhwsAAIcTAACHGwAAhyMAAIcrAACHMwAAhzsAAJcDAACXCwAAlxMAAJcbAACXIwAAlysAAJczAACXOwAApwMAAKcLAACnEwAApxsAAKcjAACnKwAApzMAAKc7AAC3AwAAtwsAALcTAAC3GwAAtyMAALcrAAC3MwAAtzsAAMcDAADHCwAAxxMAAMcbAADHIwAAxysAAMczAADHOwAA1wMAANcLAADXEwAA1xsAANcjAADXKwAA1zMAANc7AADnAwAA5wsAAOcTAADnGwAA5yMAAOcrAADnMwAA5zsAAPcDAAD3CwAA9xMAAPcbAAD3IwAA9ysAAPczAAD3OwAAh8MBAIfDBQCHwwkAh8MNAIfDEQCHwxUAh8MZAIfDHQCHywEAh8sFAIfLCQCHyw0Ah8sRAIfLFQCHyxkAh8sdAIfTAQCH0wUAh9MJAIfTDQCH0xEAh9MVAIfTGQCH0x0Ah9sBAIfbBQCH2wkAh9sNAIfbEQCH2xUAh9sZAIfbHQCH4wEAh+MFAIfjCQCH4w0Ah+MRAIfjFQCH4xkAh+MdAIfrAQCH6wUAh+sJAIfrDQCH6xEAh+sVAIfrGQCH6x0Ah/MBAIfzBQCH8wkAh/MNAIfzEQCH8xUAh/MZAIfzHQCH+wEAh/sFAIf7CQCH+w0Ah/sRAIf7FQCH+xkAh/sdAJfDAQCXwwUAl8MJAJfDDQCXwxEAl8MVAJfDGQCXwx0Al8sBAJfLBQCXywkAl8sNAJfLEQCXyxUAl8sZAJfLHQCX0wEAl9MFAJfTCQCX0w0Al9MRAJfTFQCX0xkAl9MdAJfbAQCX2wUAl9sJAJfbDQCX2xEAl9sVAJfbGQCX2x0Al+MBAJfjBQCX4wkAl+MNAJfjEQCX4xUAl+MZAJfjHQCX6wEAl+sFAJfrCQCX6w0Al+sRAJfrFQCX6xkAl+sdAJfzAQCX8wUAl/MJAJfzDQCX8xEAl/MVAJfzGQCX8x0Al/sBAJf7BQCX+wkAl/sNAJf7EQCX+xUAl/sZAJf7HQCnwwEAp8MFAKfDCQCnww0Ap8MRAKfDFQCnwxkAp8MdAKfLAQCnywUAp8sJAKfLDQCnyxEAp8sVAKfLGQCnyx0Ap9MBAKfTBQCn0wkAp9MNAKfTEQCn0xUAp9MZAKfTHQCn2wEAp9sFAKfbCQCn2w0Ap9sRAKfbFQCn2xkAp9sdAKfjAQCn4wUAp+MJAKfjDQCn4xEAp+MVAKfjGQCn4x0Ap+sBAKfrBQCn6wkAp+sNAKfrEQCn6xUAp+sZAKfrHQCn8wEAp/MFAKfzCQCn8w0Ap/MRAKfzFQCn8xkAp/MdAKf7AQCn+wUAp/sJAKf7DQCn+xEAp/sVAKf7GQCn+x0At8MBALfDBQC3wwkAt8MNALfDEQC3wxUAt8MZALfDHQC3ywEAt8sFALfLCQC3yw0At8sRALfLFQC3yxkAt8sdALfTAQC30wUAt9MJALfTDQC30xEAt9MVALfTGQC30x0At9sBALfbBQC32wkAt9sNALfbEQC32xUAt9sZALfbHQC34wEAt+MFALfjCQC34w0At+MRALfjFQC34xkAt+MdALfrAQC36wUAt+sJALfrDQC36xEAt+sVALfrGQC36x0At/MBALfzBQC38wkAt/MNALfzEQC38xUAt/MZALfzHQC3+wEAt/sFALf7CQC3+w0At/sRALf7FQC3+xkAt/sdAMfDAQDHwwUAx8MJAMfDDQDHwxEAx8MVAMfDGQDHwx0Ax8sBAMfLBQDHywkAx8sNAMfLEQDHyxUAx8sZAMfLHQDH0wEAx9MFAMfTCQDH0w0Ax9MRAMfTFQDH0xkAx9MdAMfbAQDH2wUAx9sJAMfbDQDH2xEAx9sVAMfbGQDH2x0Ax+MBAMfjBQDH4wkAx+MNAMfjEQDH4xUAx+MZAMfjHQDH6wEAx+sFAMfrCQDH6w0Ax+sRAMfrFQDH6xkAx+sdAMfzAQDH8wUAx/MJAMfzDQDH8xEAx/MVAMfzGQDH8x0Ax/sBAMf7BQDH+wkAx/sNAMf7EQDH+xUAx/sZAMf7HQDXwwEA18MFANfDCQDXww0A18MRANfDFQDXwxkA18MdANfLAQDXywUA18sJANfLDQDXyxEA18sVANfLGQDXyx0A19MBANfTBQDX0wkA19MNANfTEQDX0xUA19MZANfTHQDX2wEA19sFANfbCQDX2w0A19sRANfbFQDX2xkA19sdANfjAQDX4wUA1+MJANfjDQDX4xEA1+MVANfjGQDX4x0A1+sBANfrBQDX6wkA1+sNANfrEQDX6xUA1+sZANfrHQDX8wEA1/MFANfzCQDX8w0A1/MRANfzFQDX8xkA1/MdANf7AQDX+wUA1/sJANf7DQDX+xEA1/sVANf7GQDX+x0A58MBAOfDBQDnwwkA58MNAOfDEQDnwxUA58MZAOfDHQDnywEA58sFAOfLCQDnyw0A58sRAOfLFQDnyxkA58sdAOfTAQDn0wUA59MJAOfTDQDn0xEA59MVAOfTGQDn0x0A59sBAOfbBQDn2wkA59sNAOfbEQDn2xUA59sZAOfbHQDn4wEA5+MFAOfjCQDn4w0A5+MRAOfjFQDn4xkA5+MdAOfrAQDn6wUA5+sJAOfrDQDn6xEA5+sVAOfrGQDn6x0A5/MBAOfzBQDn8wkA5/MNAOfzEQDn8xUA5/MZAOfzHQDn+wEA5/sFAOf7CQDn+w0A5/sRAOf7FQDn+xkA5/sdAPfDAQD3wwUA98MJAPfDDQD3wxEA98MVAPfDGQD3wx0A98sBAPfLBQD3ywkA98sNAPfLEQD3yxUA98sZAPfLHQD30wEA99MFAPfTCQD30w0A99MRAPfTFQD30xkA99MdAPfbAQD32wUA99sJAPfbDQD32xEA99sVAPfbGQD32x0A9+MBAPfjBQD34wkA9+MNAPfjEQD34xUA9+MZAPfjHQD36wEA9+sFAPfrCQD36w0A9+sRAPfrFQD36xkA9+sdAPfzAQD38wUA9/MJAPfzDQD38xEA9/MVAPfzGQD38x0A9/sBAPf7BQD3+wkA9/sNAPf7EQD3+xUA9/sZAPf7HQCHw+EAh8PhAofD4QSHw+EGh8PhCIfD4QqHw+EMh8PhDofD5QCHw+UCh8PlBIfD5QaHw+UIh8PlCofD5QyHw+UOh8PpAIfD6QKHw+kEh8PpBofD6QiHw+kKh8PpDIfD6Q6Hw+0Ah8PtAofD7QSHw+0Gh8PtCIfD7QqHw+0Mh8PtDofD8QCHw/ECh8PxBIfD8QaHw/EIh8PxCofD8QyHw/EOh8P1AIfD9QKHw/UEh8P1BofD9QiHw/UKh8P1DIfD9Q6Hw/kAh8P5AofD+QSHw/kGh8P5CIfD+QqHw/kMh8P5DofD/QCHw/0Ch8P9BIfD/QaHw/0Ih8P9CofD/QyHw/0Oh8vhAIfL4QKHy+EEh8vhBofL4QiHy+EKh8vhDIfL4Q6Hy+UAh8vlAofL5QSHy+UGh8vlCIfL5QqHy+UMh8vlDofL6QCHy+kCh8vpBIfL6QaHy+kIh8vpCofL6QyHy+kOh8vtAIfL7QKHy+0Eh8vtBofL7QiHy+0Kh8vtDIfL7Q6Hy/EAh8vxAofL8QSHy/EGh8vxCIfL8QqHy/EMh8vxDofL9QCHy/UCh8v1BIfL9QaHy/UIh8v1CofL9QyHy/UOh8v5AIfL+QKHy/kEh8v5BofL+QgAAAAABAAAAAgAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAsAAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABUAAAAVAAAAFQAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAAAAAAIAAAABAAAAAwAAAACAAAACgAAAAYAAAAOAAAAAQAAAAkAAAAFAAAADQAAAAMAAAAPAAAAHwAAAAAAAAALAAAABwAAAAsAAAAbAAAAKwAAADsAAADLAgAAywYAAMsKAADLDgAA2wIAANsGAADbCgAA2w4AAOsCAADrBgAA6woAAOsOAAD7AgAA+wYAAPsKAAD7DgAAy7IAAMuyAQDLsgIAy7IDAMu2AADLtgEAy7YCAMu2AwDLugAAy7oBAMu6AgDLugMAy74AAMu+AQDLvgIAy74DANuyAADbsgEA27ICANuyAwDbtgAA27YBANu2AgDbtgMA27oAANu6AQDbugIA27oDANu+AADbvgEA274CANu+AwDrsgAA67IBAOuyAgDrsgMA67YAAOu2AQDrtgIA67YDAOu6AADrugEA67oCAOu6AwDrvgAA674BAOu+AgDrvgMA+7IAAPuyAQD7sgIA+7IDAPu2AAD7tgEA+7YCAPu2AwD7ugAA+7oBAPu6AgD7ugMA+74AAPu+AQD7vgIA+74DAMuyLADLsmwAy7KsAMuy7ADLsi0Ay7JtAMuyrQDLsu0Ay7IuAMuybgDLsq4Ay7LuAMuyLwDLsm8Ay7KvAMuy7wDLtiwAy7ZsAMu2rADLtuwAy7YtAMu2bQDLtq0Ay7btAMu2LgDLtm4Ay7auAMu27gDLti8Ay7ZvAMu2rwDLtu8Ay7osAMu6bADLuqwAy7rsAMu6LQDLum0Ay7qtAMu67QDLui4Ay7puAMu6rgDLuu4Ay7ovAMu6bwDLuq8Ay7rvAMu+LADLvmwAy76sAMu+7ADLvi0Ay75tAMu+rQDLvu0Ay74uAMu+bgDLvq4Ay77uAMu+LwDLvm8Ay76vAMu+7wDbsiwA27JsANuyrADbsuwA27ItANuybQDbsq0A27LtANuyLgDbsm4A27KuANuy7gDbsi8A27JvANuyrwDbsu8A27YsANu2bADbtqwA27bsANu2LQDbtm0A27atANu27QDbti4A27ZuANu2rgDbtu4A27YvANu2bwDbtq8A27bvANu6LADbumwA27qsANu67ADbui0A27ptANu6rQDbuu0A27ouANu6bgDbuq4A27ruANu6LwDbum8A27qvANu67wDbviwA275sANu+rADbvuwA274tANu+bQDbvq0A277tANu+LgDbvm4A276uANu+7gDbvi8A275vANu+rwDbvu8A67IsAOuybADrsqwA67LsAOuyLQDrsm0A67KtAOuy7QDrsi4A67JuAOuyrgDrsu4A67IvAOuybwDrsq8A67LvAOu2LADrtmwA67asAOu27ADrti0A67ZtAOu2rQDrtu0A67YuAOu2bgDrtq4A67buAOu2LwDrtm8A67avAOu27wDruiwA67psAOu6rADruuwA67otAOu6bQDruq0A67rtAOu6LgDrum4A67quAOu67gDrui8A67pvAOu6rwDruu8A674sAOu+bADrvqwA677sAOu+LQDrvm0A676tAOu+7QDrvi4A675uAOu+rgDrvu4A674vAOu+bwDrvq8A677vAPuyLAD7smwA+7KsAPuy7AD7si0A+7JtAPuyrQD7su0A+7IuAPuybgD7sq4A+7LuAPuyLwD7sm8A+7KvAPuy7wD7tiwA+7ZsAPu2rAD7tuwA+7YtAPu2bQD7tq0A+7btAPu2LgD7tm4A+7auAPu27gD7ti8A+7ZvAPu2rwD7tu8A+7osAPu6bAD7uqwA+7rsAPu6LQD7um0A+7qtAPu67QD7ui4A+7puAPu6rgD7uu4A+7ovAPu6bwD7uq8A+7rvAPu+LAD7vmwA+76sAPu+7AD7vi0A+75tAPu+rQD7vu0A+74uAPu+bgD7vq4A+77uAPu+LwD7vm8A+76vAPu+7wDLsiwLy7IsG8uyLCvLsiw7y7JsC8uybBvLsmwry7JsO8uyrAvLsqwby7KsK8uyrDvLsuwLy7LsG8uy7CvLsuw7y7ItC8uyLRvLsi0ry7ItO8uybQvLsm0by7JtK8uybTvLsq0Ly7KtG8uyrSvLsq07y7LtC8uy7RvLsu0ry7LtO8uyLgvLsi4by7IuK8uyLjvLsm4Ly7JuG8uybivLsm47y7KuC8uyrhvLsq4ry7KuO8uy7gvLsu4by7LuK8uy7jvLsi8Ly7IvG8uyLyvLsi87y7JvC8uybxvLsm8ry7JvO8uyrwvLsq8by7KvK8uyrzvLsu8Ly7LvG8uy7yvLsu87y7YsC8u2LBvLtiwry7YsO8u2bAvLtmwby7ZsK8u2bDvLtqwLy7asG8u2rCvLtqw7y7bsC8u27BvLtuwry7bsO8u2LQvLti0by7YtK8u2LTvLtm0Ly7ZtG8u2bSvLtm07y7atC8u2rRvLtq0ry7atO8u27QvLtu0by7btK8u27TvLti4Ly7YuG8u2LivLti47y7ZuC8u2bhvLtm4ry7ZuO8u2rgvLtq4by7auK8u2rjvLtu4Ly7buG8u27ivLtu47y7YvC8u2LxvLti8ry7YvO8u2bwvLtm8by7ZvK8u2bzvLtq8Ly7avG8u2ryvLtq87y7bvC8u27xvLtu8ry7bvO8u6LAvLuiwby7osK8u6LDvLumwLy7psG8u6bCvLumw7y7qsC8u6rBvLuqwry7qsO8u67AvLuuwby7rsK8u67DvLui0Ly7otG8u6LSvLui07y7ptC8u6bRvLum0ry7ptO8u6rQvLuq0by7qtK8u6rTvLuu0Ly7rtG8u67SvLuu07y7ouC8u6LhvLui4ry7ouO8u6bgvLum4by7puK8u6bjvLuq4Ly7quG8u6rivLuq47y7ruC8u67hvLuu4ry7ruO8u6LwvLui8by7ovK8u6LzvLum8Ly7pvG8u6byvLum87y7qvC8u6rxvLuq8ry7qvO8u67wvLuu8by7rvK8u67zvLviwLy74sG8u+LCvLviw7y75sC8u+bBvLvmwry75sO8u+rAvLvqwby76sK8u+rDvLvuwLy77sG8u+7CvLvuw7y74tC8u+LRvLvi0ry74tO8u+bQvLvm0by75tK8u+bTvLvq0Ly76tG8u+rSvLvq07y77tC8u+7RvLvu0ry77tO8u+LgvLvi4by74uK8u+LjvLvm4Ly75uG8u+bivLvm47y76uC8u+rhvLvq4ry76uO8u+7gvLvu4by77uK8u+7jvLvi8Ly74vG8u+LyvLvi87y75vC8u+bxvLvm8ry75vO8u+rwvLvq8by76vK8u+rzvLvu8Ly77vG8u+7yvLvu8727IsC9uyLBvbsiwr27IsO9uybAvbsmwb27JsK9uybDvbsqwL27KsG9uyrCvbsqw727LsC9uy7Bvbsuwr27LsO9uyLQvbsi0b27ItK9uyLTvbsm0L27JtG9uybSvbsm0727KtC9uyrRvbsq0r27KtO9uy7Qvbsu0b27LtK9uy7Tvbsi4L27IuG9uyLivbsi4727JuC9uybhvbsm4r27JuO9uyrgvbsq4b27KuK9uyrjvbsu4L27LuG9uy7ivbsu4727IvC9uyLxvbsi8r27IvO9uybwvbsm8b27JvK9uybzvbsq8L27KvG9uyryvbsq8727LvC9uy7xvbsu8r27LvO9u2LAvbtiwb27YsK9u2LDvbtmwL27ZsG9u2bCvbtmw727asC9u2rBvbtqwr27asO9u27Avbtuwb27bsK9u27Dvbti0L27YtG9u2LSvbti0727ZtC9u2bRvbtm0r27ZtO9u2rQvbtq0b27atK9u2rTvbtu0L27btG9u27Svbtu0727YuC9u2Lhvbti4r27YuO9u2bgvbtm4b27ZuK9u2bjvbtq4L27auG9u2rivbtq47BgAAAAYAAAAGAAAABgAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAEgAAABIAAAASAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAeAAAAHgAAAB4AAAAAACAAEAAwAAgAKAAYADgABAAkABQANAAMACwAHAA8AAIAIgASADIACgAqABoAOgAGACYAFgA2AA4ALgAeAD4AAQAhABEAMQAJACkAGQA5AAUAJQAVADUADQAtAB0APQADACMAEwAzAAsAKwAbADsABwAnABcANwAPAC8AHwA/AAAAAAGAAIABQABAAcAAwAEgACABoACgAWAAYAHgAOABEAAQAZAAkAFQAFAB0ADQATAAMAGwALABcABwAfAA8AEIAAgBiACIAUgASAHIAMgBKAAoAagAqAFoAGgB6ADoARgAGAGYAJgBWABYAdgA2AE4ADgBuAC4AXgAeAH4APgBBAAEAYQAhAFEAEQBxADEASQAJAGkAKQBZABkAeQA5AEUABQBlACUAVQAVAHUANQBNAA0AbQAtAF0AHQB9AD0AQwADAGMAIwBTABMAcwAzAEsACwBrACsAWwAbAHsAOwBHAAcAZwAnAFcAFwB3ADcATwAPAG8ALwBfAB8AfwA/AECAAIBggCCAUIAQgHCAMIBIgAiAaIAogFiAGIB4gDiARIAEgGSAJIBUgBSAdIA0gEyADIBsgCyAXIAcgHyAPIBCgAKAYoAigFKAEoBygDKASoAKgGqAKoBagBqAeoA6gEaABoBmgCaAVoAWgHaANoBOgA6AboAugF6AHoB+gD6AQYABgGGAIYBRgBGAcYAxgEmACYBpgCmAWYAZgHmAOYBFgAWAZYAlgFWAFYB1gDWATYANgG2ALYBdgB2AfYA9gEOAA4BjgCOAU4ATgHOAM4BLgAuAa4ArgFuAG4B7gDuAR4AHgGeAJ4BXgBeAd4A3gE+AD4BvgC+AX4AfgH+AP4BAQABAYEAgQFBAEEBwQDBASEAIQGhAKEBYQBhAeEA4QERABEBkQCRAVEAUQHRANEBMQAxAbEAsQFxAHEB8QDxAQkACQGJAIkBSQBJAckAyQEpACkBqQCpAWkAaQHpAOkBGQAZAZkAmQFZAFkB2QDZATkAOQG5ALkBeQB5AfkA+QEFAAUBhQCFAUUARQHFAMUBJQAlAaUApQFlAGUB5QDlARUAFQGVAJUBVQBVAdUA1QE1ADUBtQC1AXUAdQH1APUBDQANAY0AjQFNAE0BzQDNAS0ALQGtAK0BbQBtAe0A7QEdAB0BnQCdAV0AXQHdAN0BPQA9Ab0AvQF9AH0B/QD9AQMAAwGDAIMBQwBDAcMAwwEjACMBowCjAWMAYwHjAOMBEwATAZMAkwFTAFMB0wDTATMAMwGzALMBcwBzAfMA8wELAAsBiwCLAUsASwHLAMsBKwArAasAqwFrAGsB6wDrARsAGwGbAJsBWwBbAdsA2wE7ADsBuwC7AXsAewH7APsBBwAHBAcCBwYHAQcFBwMHB4cAhwSHAocGhwGHBYcDhwdHAEcERwJHBkcBRwVHA0cHxwDHBMcCxwbHAccFxwPHBycAJwQnAicGJwEnBScDJwenAKcEpwKnBqcBpwWnA6cHZwBnBGcCZwZnAWcFZwNnB+cA5wTnAucG5wHnBecD5wcXABcEFwIXBhcBFwUXAxcHlwCXBJcClwaXAZcFlwOXB1cAVwRXAlcGVwFXBVcDVwfXANcE1wLXBtcB1wXXA9cHNwA3BDcCNwY3ATcFNwM3B7cAtwS3ArcGtwG3BbcDtwd3AHcEdwJ3BncBdwV3A3cH9wD3BPcC9wb3AfcF9wP3Bw8ADwQPAg8GDwEPBQ8DDwePAI8EjwKPBo8BjwWPA48HTwBPBE8CTwZPAU8FTwNPB88AzwTPAs8GzwHPBc8DzwcvAC8ELwIvBi8BLwUvAy8HrwCvBK8CrwavAa8FrwOvB28AbwRvAm8GbwFvBW8DbwfvAO8E7wLvBu8B7wXvA+8HHwAfBB8CHwYfAR8FHwMfB58AnwSfAp8GnwGfBZ8DnwdfAF8EXwJfBl8BXwVfA18H3wDfBN8C3wbfAd8F3wPfBz8APwQ/Aj8GPwE/BT8DPwe/AL8EvwK/Br8BvwW/A78HfwB/BH8CfwZ/AX8FfwN/B/8A/wT/Av8G/wH/Bf8D/wewIBAAZQAAAGAAAAArAAAAYXNzZXJ0aW9uIGZhaWxlZDogcHJpb3IgPCA2NLAgEABlAAAAYgAAAAUAQdaG4wAL54AQgD8N4Mo/AAAAQHiaFEAHcCVAtKszQAAAQEAN4EpAeJpUQFRnXUAHcGVAAdRsQLSrc0B/CnpAAACAQH/MgkAHcIVABu+HQDxNikDdjYxAqrOOQAXBkEADuJJAeJqUQAFqlkAKKJhA2tWZQJV0m0A/BZ1Ax4ieQAAAoECta6FAf8yiQBYjpEAHcKVA2LOmQAbvp0AEIqlAPE2qQBFxq0DdjaxA9qOtQKqzrkBDva9ABcGwQDG/sUADuLJAtKuzQHiatECChLVAAWq2QCBLt0AKKLhA5gC5QNrVuUAJp7pAlXS7QJ0+vEA/Bb1Amsi9QMeIvkDhRb9AAADAQD23wECta8FAZx3CQH/MwkAIecNAFiPEQLrKxEAHcMVACxPGQNizxkB8UsdABu/HQISJyEAEIslAkrjJQDxNykAN4MpAEXHLQFMAzEDdjcxAuxnNQPajzUCYLM5AqrPOQDU5z0BDvc9A2z/QQAXB0EDKQNFAMb/RQEI80kADuNJAfDLTQLSr00CwI9RAeJrUQBIQ1UCChNVA0PfVQAFq1kAZ29ZAIEvXQBm610AKKNhA95TYQOYA2UDba9lA2tXZQOg+2kAJp9pAQQ7bQJV020AH2ttAnT7cQFmi3EA/Bd1AVGfdQJrI3UAUKd5Ax4jeQLTn3kDhRd9ATqPfQAAA4ED5W+BAPbfgQM0R4UCta+FA4MThQGcd4kBGdeJAf8ziQBQj40AIeeNAXs7jQBYj5EA0d+RAusrkQKod5UAHcOVA0cHlQAsT5kC3Y+ZA2LPmQG4D50B8UudAA6HnQAbv50CFPOhAhInoQAPW6EAEIulAiG3pQJK46UAjA+pAPE3qQN+W6kAN4OpAyCjrQBFx60DpuOtAUwDsQE5H7EDdjexAAdTsQLsZ7UAMX+1A9qPtQHno7UCYLO5AUnDuQKqz7kCg9u5ANTnvQGt770BDve9Avf7vQNs/8ECdgPBABcHwQBQB8UDKQPFAKYDxQDG/8UDk/fFAQjzyQEx68kADuPJAaPXyQHwy80BAb/NAtKvzQNnn80CwI/RAO1/0QHia9EBq1fRAEhD1QG9K9UCChPVATb71QND39UAMMfZAAWr2QLCi9kAZ2/ZAPxP3QCBL90C+gvdAGbr3QDLx90AKKPhAoV74QPeU+EAOy/hA5gD5QH82+UDba/lA+aD5QNrV+UB/CvpA6D76QBZz+kAJp/pAwtr6QEEO+0CHQftAlXT7QGqn+0AH2vtAbQz8QJ0+/ECWcPxAWaL8QOfT/EA/Bf1AZDb9QFRn/UAQmP1Amsj9QPD4/UAUKf5ABln+QMeI/kBWuP5AtOf+QOMW/0DhRf9Ar3T/QE6j/0C+0f9AAAAAQQoXAEH9LQBB2UQAQZ5bAEFOcgBB54gAQWqfAEHXtQBBLswAQXDiAEGc+ABBtA4BQbYkAUGjOgFBfFABQT9mAUHvewFBipEBQRGnAUGEvAFB49EBQS/nAUFn/AFBixECQZwmAkGaOwJBhVACQV1lAkEjegJB1Y4CQXWjAkEDuAJBf8wCQejgAkFA9QJBhQkDQbkdA0HcMQNB7EUDQexZA0HabQNBt4EDQYOVA0E+qQNB6LwDQYHQA0EK5ANBg/cDQesKBEFDHgRBijEEQcJEBEHqVwRBAWsEQQl+BEECkQRB66MEQcS2BEGOyQRBSdwEQfXuBEGSAQVBHxQFQZ4mBUEOOQVBb0sFQcJdBUEHcAVBPIIFQWSUBUF9pgVBiLgFQYbKBUF13AVBVu4FQSkABkHvEQZBpyMGQVI1BkHvRgZBflgGQQFqBkF2ewZB3owGQTieBkGGrwZBx8AGQfvRBkEi4wZBPfQGQUsFB0FMFgdBQScHQSk4B0EFSQdB1VkHQZlqB0FQewdB+4sHQZucB0EurQdBtr0HQTHOB0Gh3gdBBu8HQV7/B0GsDwhB7R8IQSQwCEFOQAhBblAIQYNgCEGMcAhBioAIQX2QCEFloAhBQrAIQRTACEHczwhBmd8IQUvvCEHy/ghBjw4JQSEeCUGpLQlBJj0JQZlMCUECXAlBYGsJQbR6CUH+iQlBPpkJQXSoCUGgtwlBwsYJQdrVCUHo5AlB7fMJQecCCkHYEQpBwCAKQZ0vCkFxPgpBPE0KQf1bCkG1agpBZHkKQQmICkGllgpBN6UKQcGzCkFBwgpBuNAKQSffCkGM7QpB6PsKQTsKC0GGGAtBxyYLQQA1C0EwQwtBWFELQXdfC0GNbQtBmnsLQZ+JC0GclwtBkKULQXyzC0FfwQtBOs8LQQzdC0HX6gtBmfgLQVMGDEEFFAxBryEMQVAvDEHqPAxBfEoMQQVYDEGHZQxBAXMMQXOADEHdjQxBQJsMQZqoDEHttQxBOcMMQXzQDEG43QxB7eoMQRr4DEE/BQ1BXRINQXQfDUGDLA1BizkNQYtGDUGEUw1BdmANQWFtDUFEeg1BIYcNQfaTDUHEoA1Biq0NQUq6DUEDxw1BtdMNQWDgDUEE7Q1BofkNQTcGDkHGEg5BTh8OQdArDkFLOA5Bv0QOQSxRDkGTXQ5B82kOQU12DkGggg5B7I4OQTKbDkFxpw5BqrMOQdy/DkEIzA5BLtgOQU3kDkFm8A5BePwOQYQID0GKFA9BiiAPQYMsD0F2OA9BY0QPQUpQD0ErXA9BBmgPQdpzD0Gpfw9BcYsPQTSXD0Hwog9Bp64PQVe6D0ECxg9Bp9EPQUbdD0Hf6A9BcvQPQQAAEEGICxBBChcQQYYiEEH9LRBBbjkQQdlEEEE+UBBBnlsQQflmEEFOchBBnX0QQeeIEEErlBBBap8QQaOqEEHXtRBBBcEQQS7MEEFS1xBBcOIQQYntEEGc+BBBqwMRQbQOEUG3GRFBtiQRQa8vEUGjOhFBkkURQXxQEUFgWxFBP2YRQRpxEUHvexFBv4YRQYqREUFQnBFBEacRQc2xEUGEvBFBNscRQePREUGL3BFBL+cRQc3xEUFn/BFB+wYSQYsREkEWHBJBnCYSQR4xEkGaOxJBEkYSQYVQEkH0WhJBXWUSQcJvEkEjehJBfoQSQdWOEkEomRJBdaMSQb+tEkEDuBJBQ8ISQX/MEkG21hJB6OASQRbrEkFA9RJBZf8SQYUJE0GiExNBuR0TQc0nE0HcMRNB5jsTQexFE0HuTxNB7FkTQeVjE0HabRNBy3cTQbeBE0GfixNBg5UTQWKfE0E+qRNBFbMTQei8E0G3xhNBgdATQUjaE0EK5BNBye0TQYP3E0E5ARRB6woUQZkUFEFDHhRB6ScUQYoxFEEoOxRBwkQUQVhOFEHqVxRBd2EUQQFrFEGHdBRBCX4UQYiHFEECkRRBeJoUQeujFEFZrRRBxLYUQSvAFEGOyRRB7tIUQUncFEGh5RRB9e4UQUX4FEGSARVB2goVQR8UFUFhHRVBniYVQdgvFUEOORVBQUIVQW9LFUGbVBVBwl0VQeZmFUEHcBVBI3kVQTyCFUFSixVBZJQVQXKdFUF9phVBha8VQYi4FUGJwRVBhsoVQX/TFUF13BVBZ+UVQVbuFUFB9xVBKQAWQQ4JFkHvERZBzRoWQacjFkF+LBZBUjUWQSI+FkHvRhZBuE8WQX5YFkFBYRZBAWoWQb1yFkF2exZBK4QWQd6MFkGNlRZBOJ4WQeGmFkGGrxZBKLgWQcfAFkFjyRZB+9EWQZDaFkEi4xZBsesWQT30FkHF/BZBSwUXQc0NF0FMFhdByB4XQUEnF0G2LxdBKTgXQZlAF0EFSRdBb1EXQdVZF0E4YhdBmWoXQfZyF0FQexdBp4MXQfuLF0FMlBdBm5wXQeakF0EurRdBc7UXQba9F0H1xRdBMc4XQWvWF0Gh3hdB1eYXQQbvF0Ez9xdBXv8XQYYHGEGsDxhBzhcYQe0fGEEKKBhBJDAYQTo4GEFOQBhBYEgYQW5QGEF6WBhBg2AYQYloGEGMcBhBjHgYQYqAGEGFiBhBfZAYQXKYGEFloBhBVagYQUKwGEEtuBhBFMAYQfnHGEHczxhBvNcYQZnfGEFz5xhBS+8YQSD3GEHy/hhBwgYZQY8OGUFZFhlBIR4ZQeYlGUGpLRlBaTUZQSY9GUHhRBlBmUwZQU9UGUECXBlBsmMZQWBrGUELcxlBtHoZQVuCGUH+iRlBn5EZQT6ZGUHaoBlBdKgZQQuwGUGgtxlBMr8ZQcLGGUFPzhlB2tUZQWLdGUHo5BlBbOwZQe3zGUFr+xlB5wIaQWEKGkHYERpBTRkaQcAgGkEwKBpBnS8aQQk3GkFxPhpB2EUaQTxNGkGeVBpB/VsaQVpjGkG1ahpBDnIaQWR5GkG3gBpBCYgaQViPGkGllhpB750aQTelGkF9rBpBwbMaQQK7GkFBwhpBfskaQbjQGkHx1xpBJ98aQVrmGkGM7RpBu/QaQej7GkETAxtBOwobQWIRG0GGGBtBqB8bQccmG0HlLRtBADUbQRk8G0EwQxtBRUobQVhRG0FoWBtBd18bQYNmG0GNbRtBlXQbQZp7G0GeghtBn4kbQZ+QG0GclxtBl54bQZClG0GHrBtBfLMbQW66G0FfwRtBTcgbQTrPG0Ek1htBDN0bQfPjG0HX6htBufEbQZn4G0F3/xtBUwYcQS0NHEEFFBxB2xocQa8hHEGBKBxBUC8cQR42HEHqPBxBtEMcQXxKHEFBURxBBVgcQcdeHEGHZRxBRWwcQQFzHEG7eRxBc4AcQSmHHEHdjRxBj5QcQUCbHEHuoRxBmqgcQUWvHEHttRxBlLwcQTnDHEHcyRxBfNAcQRvXHEG43RxBVOQcQe3qHEGE8RxBGvgcQa7+HEE/BR1BzwsdQV0SHUHqGB1BdB8dQfwlHUGDLB1BCDMdQYs5HUEMQB1Bi0YdQQlNHUGEUx1B/lkdQXZgHUHtZh1BYW0dQdRzHUFEeh1Bs4AdQSGHHUGMjR1B9pMdQV6aHUHEoB1BKKcdQYqtHUHrsx1BSrodQajAHUEDxx1BXc0dQbXTHUEL2h1BYOAdQbLmHUEE7R1BU/MdQaH5HUHs/x1BNwYeQX8MHkHGEh5BCxkeQU4fHkGQJR5B0CseQQ4yHkFLOB5Bhj4eQb9EHkH3Sh5BLFEeQWFXHkGTXR5BxGMeQfNpHkEhcB5BTXYeQXd8HkGggh5Bx4geQeyOHkEQlR5BMpseQVKhHkFxpx5Bjq0eQaqzHkHEuR5B3L8eQfPFHkEIzB5BHNIeQS7YHkE+3h5BTeQeQVrqHkFm8B5BcPYeQXj8HkF/Ah9BhAgfQYgOH0GKFB9BixofQYogH0GHJh9BgywfQX0yH0F2OB9Bbj4fQWNEH0FYSh9BSlAfQTtWH0ErXB9BGWIfQQZoH0HxbR9B2nMfQcJ5H0Gpfx9BjoUfQXGLH0FTkR9BNJcfQROdH0Hwoh9BzKgfQaeuH0GAtB9BV7ofQS7AH0ECxh9B1csfQafRH0F31x9BRt0fQRPjH0Hf6B9Bqu4fQXL0H0E6+h9BAAAgQcUFIEGICyBBSREgQQoXIEHJHCBBhiIgQUIoIEH9LSBBtjMgQW45IEEkPyBB2UQgQYxKIEE+UCBB71UgQZ5bIEFMYSBB+WYgQaRsIEFOciBB9ncgQZ19IEFCgyBB54ggQYmOIEErlCBBy5kgQWqfIEEHpSBBo6ogQT2wIEHXtSBBbrsgQQXBIEGaxiBBLswgQcDRIEFS1yBB4dwgQXDiIEH95yBBie0gQRPzIEGc+CBBJP4gQasDIUEwCSFBtA4hQTYUIUG3GSFBNx8hQbYkIUEzKiFBry8hQSo1IUGjOiFBG0AhQZJFIUEHSyFBfFAhQe5VIUFgWyFB0GAhQT9mIUGtayFBGnEhQYV2IUHveyFBWIEhQb+GIUEljCFBipEhQe6WIUFQnCFBsaEhQRGnIUFwrCFBzbEhQSm3IUGEvCFB3sEhQTbHIUGNzCFB49EhQTjXIUGL3CFB3uEhQS/nIUF/7CFBzfEhQRr3IUFn/CFBsgEiQfsGIkFEDCJBixEiQdEWIkEWHCJBWiEiQZwmIkHeKyJBHjEiQVw2IkGaOyJB10AiQRJGIkFMSyJBhVAiQb1VIkH0WiJBKWAiQV1lIkGQaiJBwm8iQfN0IkEjeiJBUX8iQX6EIkGqiSJB1Y4iQf+TIkEomSJBT54iQXWjIkGbqCJBv60iQeKyIkEDuCJBJL0iQUPCIkFixyJBf8wiQZvRIkG21iJB0NsiQejgIkEA5iJBFusiQSzwIkFA9SJBU/oiQWX/IkF2BCNBhQkjQZQOI0GiEyNBrhgjQbkdI0HEIiNBzScjQdUsI0HcMSNB4TYjQeY7I0HqQCNB7EUjQe5KI0HuTyNB7lQjQexZI0HpXiNB5WMjQeBoI0HabSNB03IjQct3I0HBfCNBt4EjQauGI0GfiyNBkZAjQYOVI0FzmiNBYp8jQVGkI0E+qSNBKq4jQRWzI0H/tyNB6LwjQdDBI0G3xiNBncsjQYHQI0Fl1SNBSNojQSrfI0EK5CNB6ugjQcntI0Gm8iNBg/cjQV78I0E5ASRBEgYkQesKJEHCDyRBmRQkQW4ZJEFDHiRBFiMkQeknJEG6LCRBijEkQVo2JEEoOyRB9j8kQcJEJEGNSSRBWE4kQSFTJEHqVyRBsVwkQXdhJEE9ZiRBAWskQcVvJEGHdCRBSXkkQQl+JEHJgiRBiIckQUWMJEECkSRBvpUkQXiaJEEynyRB66MkQaOoJEFZrSRBD7IkQcS2JEF4uyRBK8AkQd3EJEGOySRBPs4kQe7SJEGc1yRBSdwkQfbgJEGh5SRBS+okQfXuJEGd8yRBRfgkQez8JEGSASVBNgYlQdoKJUF9DyVBHxQlQcAYJUFhHSVBACIlQZ4mJUE7KyVB2C8lQXM0JUEOOSVBqD0lQUFCJUHZRiVBb0slQQZQJUGbVCVBL1klQcJdJUFVYiVB5mYlQXdrJUEHcCVBlXQlQSN5JUGwfSVBPIIlQciGJUFSiyVB248lQWSUJUHsmCVBcp0lQfihJUF9piVBAaslQYWvJUEHtCVBiLglQQm9JUGJwSVBCMYlQYbKJUEDzyVBf9MlQfrXJUF13CVB7uAlQWflJUHf6SVBVu4lQczyJUFB9yVBtvslQSkAJkGcBCZBDgkmQX8NJkHvESZBXhYmQc0aJkE6HyZBpyMmQRMoJkF+LCZB6DAmQVI1JkG6OSZBIj4mQYlCJkHvRiZBVEsmQbhPJkEcVCZBflgmQeBcJkFBYSZBoWUmQQFqJkFfbiZBvXImQRp3JkF2eyZB0X8mQSuEJkGFiCZB3owmQTWRJkGNlSZB45kmQTieJkGNoiZB4aYmQTSrJkGGryZB2LMmQSi4JkF4vCZBx8AmQRXFJkFjySZBr80mQfvRJkFG1iZBkNomQdreJkEi4yZBaucmQbHrJkH37yZBPfQmQYH4JkHF/CZBCAEnQUsFJ0GMCSdBzQ0nQQ0SJ0FMFidBihonQcgeJ0EFIydBQScnQXwrJ0G2LydB8DMnQSk4J0FhPCdBmUAnQc9EJ0EFSSdBOk0nQW9RJ0GiVSdB1VknQQdeJ0E4YidBaWYnQZlqJ0HIbidB9nInQSN3J0FQeydBfH8nQaeDJ0HShydB+4snQSSQJ0FMlCdBdJgnQZucJ0HBoCdB5qQnQQqpJ0EurSdBUbEnQXO1J0GVuSdBtr0nQdbBJ0H1xSdBFMonQTHOJ0FO0idBa9YnQYbaJ0Gh3idBvOInQdXmJ0Hu6idBBu8nQR3zJ0Ez9ydBSfsnQV7/J0FzAyhBhgcoQZkLKEGsDyhBvRMoQc4XKEHeGyhB7R8oQfwjKEEKKChBFywoQSQwKEEvNChBOjgoQUU8KEFOQChBV0QoQWBIKEFnTChBblAoQXRUKEF6WChBflwoQYNgKEGGZChBiWgoQYpsKEGMcChBjHQoQYx4KEGLfChBioAoQYiEKEGFiChBgYwoQX2QKEF4lChBcpgoQWycKEFloChBXaQoQVWoKEFMrChBQrAoQTi0KEEtuChBIbwoQRTAKEEHxChB+ccoQevLKEHczyhBzNMoQbzXKEGq2yhBmd8oQYbjKEFz5yhBX+soQUvvKEE18yhBIPcoQQn7KEHy/ihB2gIpQcIGKUGoCilBjw4pQXQSKUFZFilBPRopQSEeKUEEIilB5iUpQcgpKUGpLSlBiTEpQWk1KUFIOSlBJj0pQQRBKUHhRClBvUgpQZlMKUF0UClBT1QpQShYKUECXClB2l8pQbJjKUGJZylBYGspQTZvKUELcylB4HYpQbR6KUGIfilBW4IpQS2GKUH+iSlBz40pQZ+RKUFvlSlBPpkpQQ2dKUHaoClBqKQpQXSoKUFArClBC7ApQdazKUGgtylBabspQTK/KUH6wilBwsYpQYnKKUFPzilBFdIpQdrVKUGe2SlBYt0pQSbhKUHo5ClBqugpQWzsKUEs8ClB7fMpQaz3KUFr+ylBKv8pQecCKkGkBipBYQoqQR0OKkHYESpBkxUqQU0ZKkEHHSpBwCAqQXgkKkEwKCpB5ysqQZ0vKkFTMypBCTcqQb06KkFxPipBJUIqQdhFKkGKSSpBPE0qQe1QKkGeVCpBTlgqQf1bKkGsXypBWmMqQQhnKkG1aipBYm4qQQ5yKkG5dSpBZHkqQQ59KkG3gCpBYIQqQQmIKkGxiypBWI8qQf+SKkGllipBSpoqQe+dKkGToSpBN6UqQdqoKkF9rCpBH7AqQcGzKkFitypBArsqQaK+KkFBwipB4MUqQX7JKkEbzSpBuNAqQVXUKkHx1ypBjNsqQSffKkHB4ipBWuYqQfPpKkGM7SpBJPEqQbv0KkFS+CpB6PsqQX7/KkETAytBpwYrQTsKK0HPDStBYhErQfQUK0GGGCtBFxwrQagfK0E4IytBxyYrQVYqK0HlLStBczErQQA1K0GNOCtBGTwrQaU/K0EwQytBu0YrQUVKK0HPTStBWFErQeBUK0FoWCtB8FsrQXdfK0H9YitBg2YrQQhqK0GNbStBEXErQZV0K0EYeCtBmnsrQRx/K0GegitBH4YrQZ+JK0EfjStBn5ArQR2UK0GclytBGpsrQZeeK0EUoitBkKUrQQypK0GHrCtBAbArQXyzK0H1titBbrorQee9K0FfwStB1sQrQU3IK0HEyytBOs8rQa/SK0Ek1itBmdkrQQzdK0GA4CtB8+MrQWXnK0HX6itBSO4rQbnxK0Ep9StBmfgrQQj8K0F3/ytB5QIsQVMGLEHACSxBLQ0sQZkQLEEFFCxBcBcsQdsaLEFFHixBryEsQRglLEGBKCxB6SssQVAvLEG4MixBHjYsQYQ5LEHqPCxBT0AsQbRDLEEYRyxBfEosQd9NLEFBUSxBpFQsQQVYLEFnWyxBx14sQSdiLEGHZSxB5mgsQUVsLEGjbyxBAXMsQV52LEG7eSxBF30sQXOALEHOgyxBKYcsQYOKLEHdjSxBN5EsQY+ULEHolyxBQJssQZeeLEHuoSxBRKUsQZqoLEHwqyxBRa8sQZmyLEHttSxBQbksQZS8LEHnvyxBOcMsQYrGLEHcySxBLM0sQXzQLEHM0yxBG9csQWraLEG43SxBBuEsQVTkLEGh5yxB7eosQTnuLEGE8SxBz/QsQRr4LEFk+yxBrv4sQfcBLUE/BS1BiAgtQc8LLUEXDy1BXRItQaQVLUHqGC1BLxwtQXQfLUG4Ii1B/CUtQUApLUGDLC1Bxi8tQQgzLUFKNi1BizktQcw8LUEMQC1BTEMtQYtGLUHKSS1BCU0tQUdQLUGEUy1BwlYtQf5ZLUE7XS1BdmAtQbJjLUHtZi1BJ2otQWFtLUGacC1B1HMtQQx3LUFEei1BfH0tQbOALUHqgy1BIYctQVeKLUGMjS1BwZAtQfaTLUEqly1BXpotQZGdLUHEoC1B9qMtQSinLUFZqi1Biq0tQbuwLUHrsy1BG7ctQUq6LUF5vS1BqMAtQdbDLUEDxy1BMMotQV3NLUGJ0C1BtdMtQeDWLUEL2i1BNt0tQWDgLUGJ4y1BsuYtQdvpLUEE7S1BK/AtQVPzLUF69i1BofktQcf8LUHs/y1BEgMuQTcGLkFbCS5BfwwuQaMPLkHGEi5B6RUuQQsZLkEtHC5BTh8uQW8iLkGQJS5BsCguQdArLkHvLi5BDjIuQS01LkFLOC5BaTsuQYY+LkGjQS5Bv0QuQdtHLkH3Si5BEk4uQSxRLkFHVC5BYVcuQXpaLkGTXS5BrGAuQcRjLkHcZi5B82kuQQptLkEhcC5BN3MuQU12LkFieS5Bd3wuQYx/LkGggi5Bs4UuQceILkHaiy5B7I4uQf6RLkEQlS5BIZguQTKbLkFCni5BUqEuQWKkLkFxpy5BgKouQY6tLkGcsC5BqrMuQbe2LkHEuS5B0LwuQdy/LkHowi5B88UuQf7ILkEIzC5BEs8uQRzSLkEl1S5BLtguQTbbLkE+3i5BRuEuQU3kLkFU5y5BWuouQWDtLkFm8C5Ba/MuQXD2LkF0+S5BePwuQXz/LkF/Ai9BggUvQYQIL0GGCy9BiA4vQYkRL0GKFC9BixcvQYsaL0GKHS9BiiAvQYkjL0GHJi9BhSkvQYMsL0GALy9BfTIvQXo1L0F2OC9BcjsvQW4+L0FpQS9BY0QvQV5HL0FYSi9BUU0vQUpQL0FDUy9BO1YvQTNZL0ErXC9BIl8vQRliL0EQZS9BBmgvQftqL0HxbS9B5nAvQdpzL0HOdi9BwnkvQbZ8L0Gpfy9Bm4IvQY6FL0GAiC9BcYsvQWKOL0FTkS9BRJQvQTSXL0Ejmi9BE50vQQKgL0Hwoi9B3qUvQcyoL0G6qy9Bp64vQZSxL0GAtC9BbLcvQVe6L0FDvS9BLsAvQRjDL0ECxi9B7MgvQdXLL0G+zi9Bp9EvQY/UL0F31y9BX9ovQUbdL0Et4C9BE+MvQfnlL0Hf6C9BxesvQaruL0GO8S9BcvQvQVb3L0E6+i9BHf0vQQAAMEHiAjBBxQUwQaYIMEGICzBBaQ4wQUkRMEEqFDBBChcwQekZMEHJHDBBqB8wQYYiMEFkJTBBQigwQSArMEH9LTBB2TAwQbYzMEGSNjBBbjkwQUk8MEEkPzBB/kEwQdlEMEGzRzBBjEowQWVNMEE+UDBBF1MwQe9VMEHHWDBBnlswQXVeMEFMYTBBI2QwQflmMEHOaTBBpGwwQXlvMEFOcjBBInUwQfZ3MEHKejBBnX0wQXCAMEFCgzBBFYYwQeeIMEG4izBBiY4wQVqRMEErlDBB+5YwQcuZMEGanDBBap8wQTiiMEEHpTBB1acwQaOqMEFwrTBBPbAwQQqzMEHXtTBBo7gwQW67MEE6vjBBBcEwQdDDMEGaxjBBZMkwQS7MMEH3zjBBwNEwQYnUMEFS1zBBGtowQeHcMEGp3zBBcOIwQTflMEH95zBBw+owQYntMEFO8DBBE/MwQdj1MEGc+DBBYPswQST+MEHnADFBqwMxQW0GMUEwCTFB8gsxQbQOMUF1ETFBNhQxQfcWMUG3GTFBdxwxQTcfMUH3ITFBtiQxQXUnMUEzKjFB8SwxQa8vMUFsMjFBKjUxQeY3MUGjOjFBXz0xQRtAMUHXQjFBkkUxQU1IMUEHSzFBwk0xQXxQMUE1UzFB7lUxQadYMUFgWzFBGF4xQdBgMUGIYzFBP2YxQfZoMUGtazFBZG4xQRpxMUHPczFBhXYxQTp5MUHvezFBo34xQViBMUELhDFBv4YxQXKJMUEljDFB2I4xQYqRMUE8lDFB7pYxQZ+ZMUFQnDFBAZ8xQbGhMUFhpDFBEacxQcGpMUFwrDFBH68xQc2xMUF7tDFBKbcxQde5MUGEvDFBMb8xQd7BMUGKxDFBNscxQeLJMUGNzDFBOM8xQePRMUGO1DFBONcxQeLZMUGL3DFBNd8xQd7hMUGG5DFBL+cxQdfpMUF/7DFBJu8xQc3xMUF09DFBGvcxQcH5MUFn/DFBDP8xQbIBMkFXBDJB+wYyQaAJMkFEDDJB6A4yQYsRMkEuFDJB0RYyQXQZMkEWHDJBuB4yQVohMkH7IzJBnCYyQT0pMkHeKzJBfi4yQR4xMkG9MzJBXDYyQfs4MkGaOzJBOT4yQddAMkF1QzJBEkYyQa9IMkFMSzJB6U0yQYVQMkEhUzJBvVUyQVhYMkH0WjJBjl0yQSlgMkHDYjJBXWUyQfdnMkGQajJBKW0yQcJvMkFbcjJB83QyQYt3MkEjejJBunwyQVF/MkHogTJBfoQyQRSHMkGqiTJBQIwyQdWOMkFqkTJB/5MyQZOWMkEomTJBvJsyQU+eMkHioDJBdaMyQQimMkGbqDJBLasyQb+tMkFQsDJB4rIyQXO1MkEDuDJBlLoyQSS9MkG0vzJBQ8IyQdPEMkFixzJB8MkyQX/MMkENzzJBm9EyQSnUMkG21jJBQ9kyQdDbMkFc3jJB6OAyQXTjMkEA5jJBi+gyQRbrMkGh7TJBLPAyQbbyMkFA9TJByvcyQVP6MkHc/DJBZf8yQe0BM0F2BDNB/gYzQYUJM0ENDDNBlA4zQRsRM0GiEzNBKBYzQa4YM0E0GzNBuR0zQT8gM0HEIjNBSCUzQc0nM0FRKjNB1SwzQVgvM0HcMTNBXzQzQeE2M0FkOTNB5jszQWg+M0HqQDNBa0MzQexFM0FtSDNB7kozQW5NM0HuTzNBblIzQe5UM0FtVzNB7FkzQWpcM0HpXjNBZ2EzQeVjM0FjZjNB4GgzQV1rM0HabTNBVnAzQdNyM0FPdTNBy3czQUZ6M0HBfDNBPH8zQbeBM0ExhDNBq4YzQSWJM0GfizNBGI4zQZGQM0EKkzNBg5UzQfuXM0FzmjNB65wzQWKfM0HaoTNBUaQzQcemM0E+qTNBtKszQSquM0GgsDNBFbMzQYq1M0H/tzNBdLozQei8M0FcvzNB0MEzQUTEM0G3xjNBKskzQZ3LM0EPzjNBgdAzQfTSM0Fl1TNB19czQUjaM0G53DNBKt8zQZrhM0EK5DNBeuYzQeroM0FZ6zNBye0zQTjwM0Gm8jNBFfUzQYP3M0Hx+TNBXvwzQcz+M0E5ATRBpgM0QRIGNEF/CDRB6wo0QVcNNEHCDzRBLhI0QZkUNEEEFzRBbhk0QdkbNEFDHjRBrSA0QRYjNEF/JTRB6Sc0QVEqNEG6LDRBIi80QYoxNEHyMzRBWjY0QcE4NEEoOzRBjz00QfY/NEFcQjRBwkQ0QShHNEGNSTRB80s0QVhONEG9UDRBIVM0QYZVNEHqVzRBTVo0QbFcNEEUXzRBd2E0QdpjNEE9ZjRBn2g0QQFrNEFjbTRBxW80QSZyNEGHdDRB6HY0QUl5NEGpezRBCX40QWmANEHJgjRBKIU0QYiHNEHniTRBRYw0QaSONEECkTRBYJM0Qb6VNEEbmDRBeJo0QdWcNEEynzRBj6E0QeujNEFHpjRBo6g0Qf6qNEFZrTRBta80QQ+yNEFqtDRBxLY0QR65NEF4uzRB0r00QSvANEGEwjRB3cQ0QTbHNEGOyTRB58s0QT7ONEGW0DRB7tI0QUXVNEGc1zRB89k0QUncNEGf3jRB9uA0QUvjNEGh5TRB9uc0QUvqNEGg7DRB9e40QUnxNEGd8zRB8fU0QUX4NEGZ+jRB7Pw0QT//NEGSATVB5AM1QTYGNUGICDVB2go1QSwNNUF9DzVBzhE1QR8UNUFwFjVBwBg1QREbNUFhHTVBsB81QQAiNUFPJDVBniY1Qe0oNUE7KzVBii01QdgvNUEmMjVBczQ1QcE2NUEOOTVBWzs1Qag9NUH0PzVBQUI1QY1ENUHZRjVBJEk1QW9LNUG7TTVBBlA1QVBSNUGbVDVB5VY1QS9ZNUF5WzVBwl01QQxgNUFVYjVBnmQ1QeZmNUEvaTVBd2s1Qb9tNUEHcDVBTnI1QZV0NUHcdjVBI3k1QWp7NUGwfTVB9n81QTyCNUGChDVByIY1QQ2JNUFSizVBl401QduPNUEgkjVBZJQ1QaiWNUHsmDVBL5s1QXKdNUG1nzVB+KE1QTukNUF9pjVBv6g1QQGrNUFDrTVBha81QcaxNUEHtDVBSLY1QYi4NUHJujVBCb01QUm/NUGJwTVByMM1QQjGNUFHyDVBhso1QcTMNUEDzzVBQdE1QX/TNUG91TVB+tc1QTjaNUF13DVBst41Qe7gNUEr4zVBZ+U1QaPnNUHf6TVBG+w1QVbuNUGR8DVBzPI1QQf1NUFB9zVBfPk1Qbb7NUHw/TVBKQA2QWMCNkGcBDZB1QY2QQ4JNkFHCzZBfw02QbcPNkHvETZBJxQ2QV4WNkGWGDZBzRo2QQQdNkE6HzZBcSE2QacjNkHdJTZBEyg2QUkqNkF+LDZBsy42QegwNkEdMzZBUjU2QYY3NkG6OTZB7js2QSI+NkFVQDZBiUI2QbxENkHvRjZBIUk2QVRLNkGGTTZBuE82QepRNkEcVDZBTVY2QX5YNkGvWjZB4Fw2QRFfNkFBYTZBcWM2QaFlNkHRZzZBAWo2QTBsNkFfbjZBjnA2Qb1yNkHrdDZBGnc2QUh5NkF2ezZBo302QdF/NkH+gTZBK4Q2QViGNkGFiDZBsYo2Qd6MNkEKjzZBNZE2QWGTNkGNlTZBuJc2QeOZNkEOnDZBOJ42QWOgNkGNojZBt6Q2QeGmNkEKqTZBNKs2QV2tNkGGrzZBr7E2QdizNkEAtjZBKLg2QVC6NkF4vDZBoL42QcfANkHuwjZBFcU2QTzHNkFjyTZBics2Qa/NNkHVzzZB+9E2QSHUNkFG1jZBa9g2QZDaNkG13DZB2t42Qf7gNkEi4zZBRuU2QWrnNkGO6TZBses2QdTtNkH37zZBGvI2QT30NkFf9jZBgfg2QaP6NkHF/DZB5/42QQgBN0EqAzdBSwU3QWsHN0GMCTdBrQs3Qc0NN0HtDzdBDRI3QSwUN0FMFjdBaxg3QYoaN0GpHDdByB43QeYgN0EFIzdBIyU3QUEnN0FeKTdBfCs3QZktN0G2LzdB0zE3QfAzN0ENNjdBKTg3QUU6N0FhPDdBfT43QZlAN0G0QjdBz0Q3QepGN0EFSTdBIEs3QTpNN0FVTzdBb1E3QYhTN0GiVTdBvFc3QdVZN0HuWzdBB143QSBgN0E4YjdBUWQ3QWlmN0GBaDdBmWo3QbBsN0HIbjdB33A3QfZyN0ENdTdBI3c3QTp5N0FQezdBZn03QXx/N0GSgTdBp4M3QbyFN0HShzdB54k3QfuLN0EQjjdBJJA3QTiSN0FMlDdBYJY3QXSYN0GHmjdBm5w3Qa6eN0HBoDdB06I3QeakN0H4pjdBCqk3QRyrN0EurTdBQK83QVGxN0FiszdBc7U3QYS3N0GVuTdBpbs3Qba9N0HGvzdB1sE3QeXDN0H1xTdBBMg3QRTKN0EjzDdBMc43QUDQN0FO0jdBXdQ3QWvWN0F52DdBhto3QZTcN0Gh3jdBr+A3QbziN0HI5DdB1eY3QeHoN0Hu6jdB+uw3QQbvN0ER8TdBHfM3QSj1N0Ez9zdBPvk3QUn7N0FU/TdBXv83QWkBOEFzAzhBfQU4QYYHOEGQCThBmQs4QaMNOEGsDzhBtBE4Qb0TOEHGFThBzhc4QdYZOEHeGzhB5h04Qe0fOEH1IThB/CM4QQMmOEEKKDhBESo4QRcsOEEdLjhBJDA4QSoyOEEvNDhBNTY4QTo4OEFAOjhBRTw4QUo+OEFOQDhBU0I4QVdEOEFcRjhBYEg4QWRKOEFnTDhBa044QW5QOEFxUjhBdFQ4QXdWOEF6WDhBfFo4QX5cOEGBXjhBg2A4QYRiOEGGZDhBh2Y4QYloOEGKajhBimw4QYtuOEGMcDhBjHI4QYx0OEGMdjhBjHg4QYx6OEGLfDhBi344QYqAOEGJgjhBiIQ4QYaGOEGFiDhBg4o4QYGMOEF/jjhBfZA4QXuSOEF4lDhBdZY4QXKYOEFvmjhBbJw4QWmeOEFloDhBYaI4QV2kOEFZpjhBVag4QVCqOEFMrDhBR644QUKwOEE9sjhBOLQ4QTK2OEEtuDhBJ7o4QSG8OEEbvjhBFMA4QQ7COEEHxDhBAMY4QfnHOEHyyThB68s4QeTNOEHczzhB1NE4QczTOEHE1ThBvNc4QbPZOEGq2zhBot04QZnfOEGP4ThBhuM4QX3lOEFz5zhBaek4QV/rOEFV7ThBS+84QUDxOEE18zhBK/U4QSD3OEEU+ThBCfs4Qf78OEHy/jhB5gA5QdoCOUHOBDlBwgY5QbUIOUGoCjlBnAw5QY8OOUGCEDlBdBI5QWcUOUFZFjlBSxg5QT0aOUEvHDlBIR45QRIgOUEEIjlB9SM5QeYlOUHXJzlByCk5QbgrOUGpLTlBmS85QYkxOUF5MzlBaTU5QVg3OUFIOTlBNzs5QSY9OUEVPzlBBEE5QfJCOUHhRDlBz0Y5Qb1IOUGrSjlBmUw5QYdOOUF0UDlBYVI5QU9UOUE8VjlBKFg5QRVaOUECXDlB7l05QdpfOUHGYTlBsmM5QZ5lOUGJZzlBdWk5QWBrOUFLbTlBNm85QSFxOUELczlB9nQ5QeB2OUHKeDlBtHo5QZ58OUGIfjlBcYA5QVuCOUFEhDlBLYY5QRaIOUH+iTlB54s5Qc+NOUG3jzlBn5E5QYeTOUFvlTlBV5c5QT6ZOUElmzlBDZ05QfSeOUHaoDlBwaI5QaikOUGOpjlBdKg5QVqqOUFArDlBJq45QQuwOUHxsTlB1rM5Qbu1OUGgtzlBhbk5QWm7OUFOvTlBMr85QRbBOUH6wjlB3sQ5QcLGOUGlyDlBico5QWzMOUFPzjlBMtA5QRXSOUH40zlB2tU5QbzXOUGe2TlBgNs5QWLdOUFE3zlBJuE5QQfjOUHo5DlByeY5QaroOUGL6jlBbOw5QUzuOUEs8DlBDfI5Qe3zOUHM9TlBrPc5QYz5OUFr+zlBSv05QSr/OUEIATpB5wI6QcYEOkGkBjpBgwg6QWEKOkE/DDpBHQ46QfsPOkHYETpBthM6QZMVOkFwFzpBTRk6QSobOkEHHTpB4x46QcAgOkGcIjpBeCQ6QVQmOkEwKDpBCyo6QecrOkHCLTpBnS86QXgxOkFTMzpBLjU6QQk3OkHjODpBvTo6QZc8OkFxPjpBS0A6QSVCOkH/QzpB2EU6QbFHOkGKSTpBY0s6QTxNOkEVTzpB7VA6QcZSOkGeVDpBdlY6QU5YOkEmWjpB/Vs6QdVdOkGsXzpBg2E6QVpjOkExZTpBCGc6Qd9oOkG1ajpBi2w6QWJuOkE4cDpBDnI6QeNzOkG5dTpBjnc6QWR5OkE5ezpBDn06QeN+OkG3gDpBjII6QWCEOkE1hjpBCYg6Qd2JOkGxizpBhI06QViPOkErkTpB/5I6QdKUOkGlljpBd5g6QUqaOkEdnDpB7506QcGfOkGToTpBZaM6QTelOkEJpzpB2qg6QayqOkF9rDpBTq46QR+wOkHwsTpBwbM6QZG1OkFitzpBMrk6QQK7OkHSvDpBor46QXLAOkFBwjpBEMQ6QeDFOkGvxzpBfsk6QU3LOkEbzTpB6s46QbjQOkGH0jpBVdQ6QSPWOkHx1zpBvtk6QYzbOkFZ3TpBJ986QfTgOkHB4jpBjuQ6QVrmOkEn6DpB8+k6QcDrOkGM7TpBWO86QSTxOkHv8jpBu/Q6QYb2OkFS+DpBHfo6Qej7OkGz/TpBfv86QUgBO0ETAztB3QQ7QacGO0FxCDtBOwo7QQUMO0HPDTtBmA87QWIRO0ErEztB9BQ7Qb0WO0GGGDtBTho7QRccO0HfHTtBqB87QXAhO0E4IztBACU7QccmO0GPKDtBVio7QR4sO0HlLTtBrC87QXMxO0E6MztBADU7Qcc2O0GNODtBUzo7QRk8O0HfPTtBpT87QWtBO0EwQztB9kQ7QbtGO0GASDtBRUo7QQpMO0HPTTtBk087QVhRO0EcUztB4FQ7QaRWO0FoWDtBLFo7QfBbO0GzXTtBd187QTphO0H9YjtBwGQ7QYNmO0FFaDtBCGo7QcprO0GNbTtBT287QRFxO0HTcjtBlXQ7QVZ2O0EYeDtB2Xk7QZp7O0FbfTtBHH87Qd2AO0GegjtBXoQ7QR+GO0HfhztBn4k7QV+LO0EfjTtB3447QZ+QO0FekjtBHZQ7Qd2VO0GclztBW5k7QRqbO0HYnDtBl547QVWgO0EUojtB0qM7QZClO0FOpztBDKk7QcmqO0GHrDtBRK47QQGwO0G/sTtBfLM7QTi1O0H1tjtBsrg7QW66O0ErvDtB5707QaO/O0FfwTtBG8M7QdbEO0GSxjtBTcg7QQnKO0HEyztBf807QTrPO0H10DtBr9I7QWrUO0Ek1jtB3tc7QZnZO0FT2ztBDN07QcbeO0GA4DtBOeI7QfPjO0Gs5TtBZec7QR7pO0HX6jtBkOw7QUjuO0EB8DtBufE7QXHzO0Ep9TtB4fY7QZn4O0FR+jtBCPw7QcD9O0F3/ztBLgE8QeUCPEGcBDxBUwY8QQoIPEHACTxBdws8QS0NPEHjDjxBmRA8QU8SPEEFFDxBuxU8QXAXPEEmGTxB2xo8QZAcPEFFHjxB+h88Qa8hPEFjIzxBGCU8QcwmPEGBKDxBNSo8QekrPEGdLTxBUC88QQQxPEG4MjxBazQ8QR42PEHRNzxBhDk8QTc7PEHqPDxBnT48QU9APEECQjxBtEM8QWZFPEEYRzxBykg8QXxKPEEtTDxB3008QZBPPEFBUTxB81I8QaRUPEFVVjxBBVg8QbZZPEFnWzxBF108QcdePEF3YDxBJ2I8QddjPEGHZTxBN2c8QeZoPEGWajxBRWw8QfRtPEGjbzxBUnE8QQFzPEGwdDxBXnY8QQ14PEG7eTxBaXs8QRd9PEHFfjxBc4A8QSGCPEHOgzxBfIU8QSmHPEHWiDxBg4o8QTCMPEHdjTxBio88QTeRPEHjkjxBj5Q8QTyWPEHolzxBlJk8QUCbPEHrnDxBl548QUOgPEHuoTxBmaM8QUSlPEHwpjxBmqg8QUWqPEHwqzxBmq08QUWvPEHvsDxBmbI8QUO0PEHttTxBl7c8QUG5PEHrujxBlLw8QT2+PEHnvzxBkME8QTnDPEHixDxBisY8QTPIPEHcyTxBhMs8QSzNPEHUzjxBfNA8QSTSPEHM0zxBdNU8QRvXPEHD2DxBato8QRHcPEG43TxBX988QQbhPEGt4jxBVOQ8QfrlPEGh5zxBR+k8Qe3qPEGT7DxBOe48Qd/vPEGE8TxBKvM8Qc/0PEF19jxBGvg8Qb/5PEFk+zxBCf08Qa7+PEFSAD1B9wE9QZsDPUE/BT1B5AY9QYgIPUEsCj1Bzws9QXMNPUEXDz1BuhA9QV0SPUEBFD1BpBU9QUcXPUHqGD1BjBo9QS8cPUHSHT1BdB89QRYhPUG4Ij1BWyQ9QfwlPUGeJz1BQCk9QeIqPUGDLD1BJS49QcYvPUFnMT1BCDM9Qak0PUFKNj1B6jc9QYs5PUErOz1BzDw9QWw+PUEMQD1BrEE9QUxDPUHsRD1Bi0Y9QStIPUHKST1Baks9QQlNPUGoTj1BR1A9QeZRPUGEUz1BI1U9QcJWPUFgWD1B/lk9QZxbPUE7XT1B2V49QXZgPUEUYj1BsmM9QU9lPUHtZj1Bimg9QSdqPUHEaz1BYW09Qf5uPUGacD1BN3I9QdRzPUFwdT1BDHc9Qah4PUFEej1B4Hs9QXx9PUEYfz1Bs4A9QU+CPUHqgz1BhYU9QSGHPUG8iD1BV4o9QfGLPUGMjT1BJ489QcGQPUFbkj1B9pM9QZCVPUEqlz1BxJg9QV6aPUH3mz1BkZ09QSqfPUHEoD1BXaI9QfajPUGPpT1BKKc9QcGoPUFZqj1B8qs9QYqtPUEjrz1Bu7A9QVOyPUHrsz1Bg7U9QRu3PUGzuD1BSro9QeK7PUF5vT1BEL89QajAPUE/wj1B1sM9QWzFPUEDxz1Bmsg9QTDKPUHHyz1BXc09QfPOPUGJ0D1BH9I9QbXTPUFL1T1B4NY9QXbYPUEL2j1BoNs9QTbdPUHL3j1BYOA9QfXhPUGJ4z1BHuU9QbLmPUFH6D1B2+k9QW/rPUEE7T1BmO49QSvwPUG/8T1BU/M9Qeb0PUF69j1BDfg9QaH5PUE0+z1Bx/w9QVr+PUHs/z1BfwE+QRIDPkGkBD5BNwY+QckHPkFbCT5B7Qo+QX8MPkERDj5Bow8+QTQRPkHGEj5BVxQ+QekVPkF6Fz5BCxk+QZwaPkEtHD5Bvh0+QU4fPkHfID5BbyI+QQAkPkGQJT5BICc+QbAoPkFAKj5B0Cs+QWAtPkHvLj5BfzA+QQ4yPkGeMz5BLTU+Qbw2PkFLOD5B2jk+QWk7PkH3PD5Bhj4+QRRAPkGjQT5BMUM+Qb9EPkFNRj5B20c+QWlJPkH3Sj5BhEw+QRJOPkGfTz5BLFE+QbpSPkFHVD5B1FU+QWFXPkHtWD5Belo+QQdcPkGTXT5BIF8+QaxgPkE4Yj5BxGM+QVBlPkHcZj5BaGg+QfNpPkF/az5BCm0+QZZuPkEhcD5BrHE+QTdzPkHCdD5BTXY+Qdh3PkFieT5B7Xo+QXd8PkEBfj5BjH8+QRaBPkGggj5BKoQ+QbOFPkE9hz5Bx4g+QVCKPkHaiz5BY40+QeyOPkF1kD5B/pE+QYeTPkEQlT5BmJY+QSGYPkGpmT5BMps+QbqcPkFCnj5Byp8+QVKhPkHaoj5BYqQ+QeqlPkFxpz5B+ag+QYCqPkEHrD5Bjq0+QRWvPkGcsD5BI7I+QaqzPkExtT5Bt7Y+QT64PkHEuT5BSrs+QdC8PkFWvj5B3L8+QWLBPkHowj5BbsQ+QfPFPkF4xz5B/sg+QYPKPkEIzD5Bjc0+QRLPPkGX0D5BHNI+QaDTPkEl1T5BqdY+QS7YPkGy2T5BNts+QbrcPkE+3j5Bwt8+QUbhPkHJ4j5BTeQ+QdDlPkFU5z5B1+g+QVrqPkHd6z5BYO0+QePuPkFm8D5B6PE+QWvzPkHt9D5BcPY+QfL3PkF0+T5B9vo+QXj8PkH6/T5BfP8+Qf0AP0F/Aj9BAAQ/QYIFP0EDBz9BhAg/QQUKP0GGCz9BBw0/QYgOP0EJED9BiRE/QQoTP0GKFD9BChY/QYsXP0ELGT9Bixo/QQscP0GKHT9BCh8/QYogP0EJIj9BiSM/QQglP0GHJj9BBig/QYUpP0EEKz9Bgyw/QQIuP0GALz9B/zA/QX0yP0H8Mz9BejU/Qfg2P0F2OD9B9Dk/QXI7P0HwPD9Bbj4/Qes/P0FpQT9B5kI/QWNEP0HhRT9BXkc/QdtIP0FYSj9B1Es/QVFNP0HOTj9BSlA/QcdRP0FDUz9Bv1Q/QTtWP0G3Vz9BM1k/Qa9aP0ErXD9Bp10/QSJfP0GeYD9BGWI/QZRjP0EQZT9Bi2Y/QQZoP0GBaT9B+2o/QXZsP0HxbT9Ba28/QeZwP0Fgcj9B2nM/QVR1P0HOdj9BSHg/QcJ5P0E8ez9Btnw/QS9+P0Gpfz9BIoE/QZuCP0EVhD9BjoU/QQeHP0GAiD9B+Yk/QXGLP0HqjD9BYo4/QduPP0FTkT9BzJI/QUSUP0G8lT9BNJc/QayYP0Ejmj9Bm5s/QROdP0GKnj9BAqA/QXmhP0Hwoj9BZ6Q/Qd6lP0FVpz9BzKg/QUOqP0G6qz9BMK0/QaeuP0EdsD9BlLE/QQqzP0GAtD9B9rU/QWy3P0HiuD9BV7o/Qc27P0FDvT9BuL4/QS7AP0GjwT9BGMM/QY3EP0ECxj9Bd8c/QezIP0Fhyj9B1cs/QUrNP0G+zj9BM9A/QafRP0Eb0z9Bj9Q/QQPWP0F31z9B69g/QV/aP0HS2z9BRt0/QbneP0Et4D9BoOE/QRPjP0GG5D9B+eU/QWznP0Hf6D9BUuo/QcXrP0E37T9Bqu4/QRzwP0GO8T9BAPM/QXL0P0Hk9T9BVvc/Qcj4P0E6+j9BrPs/QR39P0GP/j9BAABAQXEBQEHiAkBBVARAQcUFQEE2B0BBpghAQRcKQEGIC0BB+AxAQWkOQEHZD0BBSRFAQboSQEEqFEBBmhVAQQoXQEF6GEBB6RlAQVkbQEHJHEBBOB5AQagfQEEXIUBBhiJAQfUjQEFkJUBB0yZAQUIoQEGxKUBBICtAQY4sQEH9LUBBay9AQdkwQEFIMkBBtjNAQSQ1QEGSNkBBADhAQW45QEHbOkBBSTxAQbY9QEEkP0BBkUBAQf5BQEFsQ0BB2URAQUZGQEGzR0BBIElAQYxKQEH5S0BBZU1AQdJOQEE+UEBBq1FAQRdTQEGDVEBB71VAQVtXQEHHWEBBM1pAQZ5bQEEKXUBBdV5AQeFfQEFMYUBBt2JAQSNkQEGOZUBB+WZAQWRoQEHOaUBBOWtAQaRsQEEObkBBeW9AQeNwQEFOckBBuHNAQSJ1QEGMdkBB9ndAQWB5QEHKekBBM3xAQZ19QEEGf0BBcIBAQdmBQEFCg0BBrIRAQRWGQEF+h0BB54hAQU+KQEG4i0BBIY1AQYmOQEHyj0BBWpFAQcOSQEErlEBBk5VAQfuWQEFjmEBBy5lAQTObQEGanEBBAp5AQWqfQEHRoEBBOKJAQaCjQEEHpUBBbqZAQdWnQEE8qUBBo6pAQQqsQEFwrUBB165AQT2wQEGksUBBCrNAQXC0QEHXtUBBPbdAQaO4QEEJukBBbrtAQdS8QEE6vkBBn79AQQXBQEFqwkBB0MNAQTXFQEGaxkBB/8dAQWTJQEHJykBBLsxAQZPNQEH3zkBBXNBAQcDRQEEl00BBidRAQe3VQEFS10BBtthAQRraQEF+20BB4dxAQUXeQEGp30BBDOFAQXDiQEHT40BBN+VAQZrmQEH950BBYOlAQcPqQEEm7EBBie1AQevuQEFO8EBBsfFAQRPzQEF29EBB2PVAQTr3QEGc+EBB/vlAQWD7QEHC/EBBJP5AQYb/QEHnAEFBSQJBQasDQUEMBUFBbQZBQc8HQUEwCUFBkQpBQfILQUFTDUFBtA5BQRQQQUF1EUFB1hJBQTYUQUGWFUFB9xZBQVcYQUG3GUFBFxtBQXccQUHXHUFBNx9BQZcgQUH3IUFBViNBQbYkQUEVJkFBdSdBQdQoQUEzKkFBkitBQfEsQUFQLkFBry9BQQ4xQUFsMkFByzNBQSo1QUGINkFB5jdBQUU5QUGjOkFBATxBQV89QUG9PkFBG0BBQXlBQUHXQkFBNERBQZJFQUHvRkFBTUhBQapJQUEHS0FBZExBQcJNQUEfT0FBfFBBQdhRQUE1U0FBklRBQe5VQUFLV0FBp1hBQQRaQUFgW0FBvFxBQRheQUF0X0FB0GBBQSxiQUGIY0FB5GRBQT9mQUGbZ0FB9mhBQVJqQUGta0FBCG1BQWRuQUG/b0FBGnFBQXVyQUHPc0FBKnVBQYV2QUHgd0FBOnlBQZV6QUHve0FBSX1BQaN+QUH+f0FBWIFBQbKCQUELhEFBZYVBQb+GQUEZiEFBcolBQcyKQUEljEFBf41BQdiOQUExkEFBipFBQeOSQUE8lEFBlZVBQe6WQUFGmEFBn5lBQfiaQUFQnEFBqZ1BQQGfQUFZoEFBsaFBQQmjQUFhpEFBuaVBQRGnQUFpqEFBwalBQRirQUFwrEFBx61BQR+vQUF2sEFBzbFBQSSzQUF7tEFB0rVBQSm3QUGAuEFB17lBQS67QUGEvEFB271BQTG/QUGHwEFB3sFBQTTDQUGKxEFB4MVBQTbHQUGMyEFB4slBQTjLQUGNzEFB481BQTjPQUGO0EFB49FBQTnTQUGO1EFB49VBQTjXQUGN2EFB4tlBQTfbQUGL3EFB4N1BQTXfQUGJ4EFB3uFBQTLjQUGG5EFB2+VBQS/nQUGD6EFB1+lBQSvrQUF/7EFB0u1BQSbvQUF68EFBzfFBQSHzQUF09EFBx/VBQRr3QUFu+EFBwflBQRT7QUFn/EFBuf1BQQz/QUFfAEJBsgFCQQQDQkFXBEJBqQVCQfsGQkFOCEJBoAlCQfIKQkFEDEJBlg1CQegOQkE5EEJBixFCQd0SQkEuFEJBgBVCQdEWQkEiGEJBdBlCQcUaQkEWHEJBZx1CQbgeQkEJIEJBWiFCQaoiQkH7I0JBTCVCQZwmQkHtJ0JBPSlCQY0qQkHeK0JBLi1CQX4uQkHOL0JBHjFCQW0yQkG9M0JBDTVCQVw2QkGsN0JB+zhCQUs6QkGaO0JB6TxCQTk+QkGIP0JB10BCQSZCQkF1Q0JBw0RCQRJGQkFhR0JBr0hCQf5JQkFMS0JBm0xCQelNQkE3T0JBhVBCQdNRQkEhU0JBb1RCQb1VQkELV0JBWFhCQaZZQkH0WkJBQVxCQY5dQkHcXkJBKWBCQXZhQkHDYkJBEGRCQV1lQkGqZkJB92dCQURpQkGQakJB3WtCQSltQkF2bkJBwm9CQQ9xQkFbckJBp3NCQfN0QkE/dkJBi3dCQdd4QkEjekJBbntCQbp8QkEFfkJBUX9CQZyAQkHogUJBM4NCQX6EQkHJhUJBFIdCQV+IQkGqiUJB9YpCQUCMQkGLjUJB1Y5CQSCQQkFqkUJBtZJCQf+TQkFJlUJBk5ZCQd6XQkEomUJBcppCQbybQkEFnUJBT55CQZmfQkHioEJBLKJCQXWjQkG/pEJBCKZCQVGnQkGbqEJB5KlCQS2rQkF2rEJBv61CQQevQkFQsEJBmbFCQeKyQkEqtEJBc7VCQbu2QkEDuEJBTLlCQZS6QkHcu0JBJL1CQWy+QkG0v0JB/MBCQUPCQkGLw0JB08RCQRrGQkFix0JBqchCQfDJQkE4y0JBf8xCQcbNQkENz0JBVNBCQZvRQkHi0kJBKdRCQW/VQkG21kJB/NdCQUPZQkGJ2kJB0NtCQRbdQkFc3kJBot9CQejgQkEu4kJBdONCQbrkQkEA5kJBRudCQYvoQkHR6UJBFutCQVzsQkGh7UJB5u5CQSzwQkFx8UJBtvJCQfvzQkFA9UJBhfZCQcr3QkEO+UJBU/pCQZj7QkHc/EJBIf5CQWX/QkGpAENB7QFDQTIDQ0F2BENBugVDQf4GQ0FCCENBhQlDQckKQ0ENDENBUQ1DQZQOQ0HYD0NBGxFDQV4SQ0GiE0NB5RRDQSgWQ0FrF0NBrhhDQfEZQ0E0G0NBdxxDQbkdQ0H8HkNBPyBDQYEhQ0HEIkNBBiRDQUglQ0GLJkNBzSdDQQ8pQ0FRKkNBkytDQdUsQ0EXLkNBWC9DQZowQ0HcMUNBHTNDQV80Q0GgNUNB4TZDQSM4Q0FkOUNBpTpDQeY7Q0EnPUNBaD5DQak/Q0HqQENBK0JDQWtDQ0GsRENB7EVDQS1HQ0FtSENBrklDQe5KQ0EuTENBbk1DQa5OQ0HuT0NBLlFDQW5SQ0GuU0NB7lRDQS1WQ0FtV0NBrFhDQexZQ0ErW0NBalxDQapdQ0HpXkNBKGBDQWdhQ0GmYkNB5WNDQSRlQ0FjZkNBoWdDQeBoQ0EfakNBXWtDQZxsQ0HabUNBGG9DQVZwQ0GVcUNB03JDQRF0Q0FPdUNBjXZDQct3Q0EIeUNBRnpDQYR7Q0HBfENB/31DQTx/Q0F6gENBt4FDQfSCQ0ExhENBboVDQauGQ0Hoh0NBJYlDQWKKQ0Gfi0NB3IxDQRiOQ0FVj0NBkZBDQc6RQ0EKk0NBR5RDQYOVQ0G/lkNB+5dDQTeZQ0FzmkNBr5tDQeucQ0EnnkNBYp9DQZ6gQ0HaoUNBFaNDQVGkQ0GMpUNBx6ZDQQOoQ0E+qUNBeapDQbSrQ0HvrENBKq5DQWWvQ0GgsENB2rFDQRWzQ0FQtENBirVDQcW2Q0H/t0NBOblDQXS6Q0Guu0NB6LxDQSK+Q0Fcv0NBlsBDQdDBQ0EKw0NBRMRDQX3FQ0G3xkNB8MdDQSrJQ0FjykNBnctDQdbMQ0EPzkNBSM9DQYHQQ0G70UNB9NJDQSzUQ0Fl1UNBntZDQdfXQ0EP2UNBSNpDQYHbQ0G53ENB8d1DQSrfQ0Fi4ENBmuFDQdLiQ0EK5ENBQuVDQXrmQ0Gy50NB6uhDQSLqQ0FZ60NBkexDQcntQ0EA70NBOPBDQW/xQ0Gm8kNB3vNDQRX1Q0FM9kNBg/dDQbr4Q0Hx+UNBKPtDQV78Q0GV/UNBzP5DQQIAREE5AURBbwJEQaYDREHcBERBEgZEQUkHREF/CERBtQlEQesKREEhDERBVw1EQY0OREHCD0RB+BBEQS4SREFjE0RBmRREQc4VREEEF0RBORhEQW4ZREGjGkRB2RtEQQ4dREFDHkRBeB9EQa0gREHhIURBFiNEQUskREF/JURBtCZEQeknREEdKURBUSpEQYYrREG6LERB7i1EQSIvREFWMERBijFEQb4yREHyM0RBJjVEQVo2REGNN0RBwThEQfU5REEoO0RBXDxEQY89REHCPkRB9j9EQSlBREFcQkRBj0NEQcJEREH1RURBKEdEQVtIREGNSURBwEpEQfNLREElTURBWE5EQYpPREG9UERB71FEQSFTREFTVERBhlVEQbhWREHqV0RBHFlEQU1aREF/W0RBsVxEQeNdREEUX0RBRmBEQXdhREGpYkRB2mNEQQxlREE9ZkRBbmdEQZ9oREHQaURBAWtEQTJsREFjbURBlG5EQcVvREH2cERBJnJEQVdzREGHdERBuHVEQeh2REEZeERBSXlEQXl6REGpe0RB2XxEQQl+REE5f0RBaYBEQZmBREHJgkRB+YNEQSiFREFYhkRBiIdEQbeIREHniURBFotEQUWMREF1jURBpI5EQdOPREECkURBMZJEQWCTREGPlERBvpVEQeyWREEbmERBSplEQXiaREGnm0RB1ZxEQQSeREEyn0RBYKBEQY+hREG9okRB66NEQRmlREFHpkRBdadEQaOoREHQqURB/qpEQSysREFZrURBh65EQbWvREHisERBD7JEQT2zREFqtERBl7VEQcS2REHxt0RBHrlEQUu6REF4u0RBpbxEQdK9REH/vkRBK8BEQVjBREGEwkRBscNEQd3EREEKxkRBNsdEQWLIREGOyURBuspEQefLREETzURBPs5EQWrPREGW0ERBwtFEQe7SREEZ1ERBRdVEQXDWREGc10RBx9hEQfPZREEe20RBSdxEQXTdREGf3kRBy99EQfbgREEg4kRBS+NEQXbkREGh5URBzOZEQfbnREEh6URBS+pEQXbrREGg7ERBy+1EQfXuREEf8ERBSfFEQXPyREGd80RBx/REQfH1REEb90RBRfhEQW/5REGZ+kRBwvtEQez8REEV/kRBP/9EQWgARUGSAUVBuwJFQeQDRUENBUVBNgZFQV8HRUGICEVBsQlFQdoKRUEDDEVBLA1FQVUORUF9D0VBphBFQc4RRUH3EkVBHxRFQUgVRUFwFkVBmBdFQcAYRUHoGUVBERtFQTkcRUFhHUVBiB5FQbAfRUHYIEVBACJFQScjRUFPJEVBdyVFQZ4mRUHGJ0VB7ShFQRQqRUE7K0VBYyxFQYotRUGxLkVB2C9FQf8wRUEmMkVBTTNFQXM0RUGaNUVBwTZFQeg3RUEOOUVBNTpFQVs7RUGBPEVBqD1FQc4+RUH0P0VBG0FFQUFCRUFnQ0VBjURFQbNFRUHZRkVB/kdFQSRJRUFKSkVBb0tFQZVMRUG7TUVB4E5FQQZQRUErUUVBUFJFQXZTRUGbVEVBwFVFQeVWRUEKWEVBL1lFQVRaRUF5W0VBnlxFQcJdRUHnXkVBDGBFQTBhRUFVYkVBeWNFQZ5kRUHCZUVB5mZFQQpoRUEvaUVBU2pFQXdrRUGbbEVBv21FQeNuRUEHcEVBKnFFQU5yRUFyc0VBlXRFQbl1RUHcdkVBAHhFQSN5RUFHekVBantFQY18RUGwfUVB035FQfZ/RUEZgUVBPIJFQV+DRUGChEVBpYVFQciGRUHqh0VBDYlFQS+KRUFSi0VBdIxFQZeNRUG5jkVB249FQf6QRUEgkkVBQpNFQWSURUGGlUVBqJZFQcqXRUHsmEVBDZpFQS+bRUFRnEVBcp1FQZSeRUG1n0VB16BFQfihRUEao0VBO6RFQVylRUF9pkVBnqdFQb+oRUHgqUVBAatFQSKsRUFDrUVBZK5FQYWvRUGlsEVBxrFFQeayRUEHtEVBJ7VFQUi2RUFot0VBiLhFQam5RUHJukVB6btFQQm9RUEpvkVBSb9FQWnARUGJwUVBqcJFQcjDRUHoxEVBCMZFQSfHRUFHyEVBZslFQYbKRUGly0VBxMxFQePNRUEDz0VBItBFQUHRRUFg0kVBf9NFQZ7URUG91UVB29ZFQfrXRUEZ2UVBONpFQVbbRUF13EVBk91FQbLeRUHQ30VB7uBFQQ3iRUEr40VBSeRFQWflRUGF5kVBo+dFQcHoRUHf6UVB/epFQRvsRUE47UVBVu5FQXTvRUGR8EVBr/FFQczyRUHp80VBB/VFQST2RUFB90VBX/hFQXz5RUGZ+kVBtvtFQdP8RUHw/UVBDf9FQSkARkFGAUZBYwJGQX8DRkGcBEZBuQVGQdUGRkHyB0ZBDglGQSoKRkFHC0ZBYwxGQX8NRkGbDkZBtw9GQdMQRkHvEUZBCxNGQScURkFDFUZBXhZGQXoXRkGWGEZBsRlGQc0aRkHoG0ZBBB1GQR8eRkE6H0ZBViBGQXEhRkGMIkZBpyNGQcIkRkHdJUZB+CZGQRMoRkEuKUZBSSpGQWMrRkF+LEZBmS1GQbMuRkHOL0ZB6DBGQQMyRkEdM0ZBNzRGQVI1RkFsNkZBhjdGQaA4RkG6OUZB1DpGQe47RkEIPUZBIj5GQTw/RkFVQEZBb0FGQYlCRkGiQ0ZBvERGQdVFRkHvRkZBCEhGQSFJRkE7SkZBVEtGQW1MRkGGTUZBn05GQbhPRkHRUEZB6lFGQQNTRkEcVEZBNFVGQU1WRkFmV0ZBflhGQZdZRkGvWkZByFtGQeBcRkH4XUZBEV9GQSlgRkFBYUZBWWJGQXFjRkGJZEZBoWVGQblmRkHRZ0ZB6WhGQQFqRkEYa0ZBMGxGQUhtRkFfbkZBd29GQY5wRkGlcUZBvXJGQdRzRkHrdEZBAnZGQRp3RkExeEZBSHlGQV96RkF2e0ZBjHxGQaN9RkG6fkZB0X9GQeeARkH+gUZBFYNGQSuERkFChUZBWIZGQW6HRkGFiEZBm4lGQbGKRkHHi0ZB3oxGQfSNRkEKj0ZBIJBGQTWRRkFLkkZBYZNGQXeURkGNlUZBopZGQbiXRkHNmEZB45lGQfiaRkEOnEZBI51GQTieRkFOn0ZBY6BGQXihRkGNokZBoqNGQbekRkHMpUZB4aZGQfanRkEKqUZBH6pGQTSrRkFJrEZBXa1GQXKuRkGGr0ZBm7BGQa+xRkHDskZB2LNGQey0RkEAtkZBFLdGQSi4RkE8uUZBULpGQWS7RkF4vEZBjL1GQaC+RkGzv0ZBx8BGQdvBRkHuwkZBAsRGQRXFRkEpxkZBPMdGQU/IRkFjyUZBdspGQYnLRkGczEZBr81GQcLORkHVz0ZB6NBGQfvRRkEO00ZBIdRGQTPVRkFG1kZBWddGQWvYRkF+2UZBkNpGQaPbRkG13EZBx91GQdreRkHs30ZB/uBGQRDiRkEi40ZBNORGQUblRkFY5kZBaudGQXzoRkGO6UZBn+pGQbHrRkHD7EZB1O1GQebuRkH370ZBCfFGQRryRkEr80ZBPfRGQU71RkFf9kZBcPdGQYH4RkGS+UZBo/pGQbT7RkHF/EZB1v1GQef+RkH4/0ZBCAFHQRkCR0EqA0dBOgRHQUsFR0FbBkdBawdHQXwIR0GMCUdBnApHQa0LR0G9DEdBzQ1HQd0OR0HtD0dB/RBHQQ0SR0EdE0dBLBRHQTwVR0FMFkdBXBdHQWsYR0F7GUdBihpHQZobR0GpHEdBuR1HQcgeR0HXH0dB5iBHQfYhR0EFI0dBFCRHQSMlR0EyJkdBQSdHQVAoR0FeKUdBbSpHQXwrR0GLLEdBmS1HQaguR0G2L0dBxTBHQdMxR0HiMkdB8DNHQf80R0ENNkdBGzdHQSk4R0E3OUdBRTpHQVM7R0FhPEdBbz1HQX0+R0GLP0dBmUBHQaZBR0G0QkdBwkNHQc9ER0HdRUdB6kZHQfhHR0EFSUdBE0pHQSBLR0EtTEdBOk1HQUdOR0FVT0dBYlBHQW9RR0F8UkdBiFNHQZVUR0GiVUdBr1ZHQbxXR0HIWEdB1VlHQeJaR0HuW0dB+1xHQQdeR0ETX0dBIGBHQSxhR0E4YkdBRGNHQVFkR0FdZUdBaWZHQXVnR0GBaEdBjWlHQZlqR0Gka0dBsGxHQbxtR0HIbkdB029HQd9wR0HqcUdB9nJHQQF0R0ENdUdBGHZHQSN3R0EueEdBOnlHQUV6R0FQe0dBW3xHQWZ9R0FxfkdBfH9HQYeAR0GSgUdBnIJHQaeDR0GyhEdBvIVHQceGR0HSh0dB3IhHQeeJR0HxikdB+4tHQQaNR0EQjkdBGo9HQSSQR0EukUdBOJJHQUKTR0FMlEdBVpVHQWCWR0Fql0dBdJhHQX6ZR0GHmkdBkZtHQZucR0GknUdBrp5HQbefR0HBoEdByqFHQdOiR0Hdo0dB5qRHQe+lR0H4pkdBAahHQQqpR0ETqkdBHKtHQSWsR0EurUdBN65HQUCvR0FIsEdBUbFHQVqyR0Fis0dBa7RHQXO1R0F8tkdBhLdHQY24R0GVuUdBnbpHQaW7R0GtvEdBtr1HQb6+R0HGv0dBzsBHQdbBR0HewkdB5cNHQe3ER0H1xUdB/cZHQQTIR0EMyUdBFMpHQRvLR0EjzEdBKs1HQTHOR0E5z0dBQNBHQUfRR0FO0kdBVtNHQV3UR0Fk1UdBa9ZHQXLXR0F52EdBgNlHQYbaR0GN20dBlNxHQZvdR0Gh3kdBqN9HQa/gR0G14UdBvOJHQcLjR0HI5EdBz+VHQdXmR0Hb50dB4ehHQejpR0Hu6kdB9OtHQfrsR0EA7kdBBu9HQQzwR0ER8UdBF/JHQR3zR0Ej9EdBKPVHQS72R0Ez90dBOfhHQT75R0FE+kdBSftHQU/8R0FU/UdBWf5HQV7/R0FkAEhBaQFIQW4CSEFzA0hBeARIQX0FSEGCBkhBhgdIQYsISEGQCUhBlQpIQZkLSEGeDEhBow1IQacOSEGsD0hBsBBIQbQRSEG5EkhBvRNIQcEUSEHGFUhByhZIQc4XSEHSGEhB1hlIQdoaSEHeG0hB4hxIQeYdSEHqHkhB7R9IQfEgSEH1IUhB+CJIQfwjSEH/JEhBAyZIQQYnSEEKKEhBDSlIQREqSEEUK0hBFyxIQRotSEEdLkhBIC9IQSQwSEEnMUhBKjJIQSwzSEEvNEhBMjVIQTU2SEE4N0hBOjhIQT05SEFAOkhBQjtIQUU8SEFHPUhBSj5IQUw/SEFOQEhBUUFIQVNCSEFVQ0hBV0RIQVpFSEFcRkhBXkdIQWBISEFiSUhBZEpIQWVLSEFnTEhBaU1IQWtOSEFsT0hBblBIQXBRSEFxUkhBc1NIQXRUSEF2VUhBd1ZIQXhXSEF6WEhBe1lIQXxaSEF9W0hBflxIQYBdSEGBXkhBgl9IQYNgSEGDYUhBhGJIQYVjSEGGZEhBh2VIQYdmSEGIZ0hBiWhIQYlpSEGKakhBimtIQYpsSEGLbUhBi25IQYtvSEGMcEhBjHFIQYxySEGMc0hBjHRIQYx1SEGMdkhBjHdIQYx4SEGMeUhBjHpIQYx7SEGLfEhBi31IQYt+SEGKf0hBioBIQYmBSEGJgkhBiINIQYiESEGHhUhBhoZIQYaHSEGFiEhBhIlIQYOKSEGCi0hBgYxIQYCNSEF/jkhBfo9IQX2QSEF8kUhBe5JIQXmTSEF4lEhBd5VIQXWWSEF0l0hBcphIQXGZSEFvmkhBbptIQWycSEFqnUhBaZ5IQWefSEFloEhBY6FIQWGiSEFfo0hBXaRIQVulSEFZpkhBV6dIQVWoSEFTqUhBUKpIQU6rSEFMrEhBSa1IQUeuSEFFr0hBQrBIQUCxSEE9skhBOrNIQTi0SEE1tUhBMrZIQS+3SEEtuEhBKrlIQSe6SEEku0hBIbxIQR69SEEbvkhBGL9IQRTASEERwUhBDsJIQQvDSEEHxEhBBMVIQQDGSEH9xkhB+cdIQfbISEHyyUhB78pIQevLSEHnzEhB5M1IQeDOSEHcz0hB2NBIQdTRSEHQ0khBzNNIQcjUSEHE1UhBwNZIQbzXSEG32EhBs9lIQa/aSEGq20hBptxIQaLdSEGd3khBmd9IQZTgSEGP4UhBi+JIQYbjSEGB5EhBfeVIQXjmSEFz50hBbuhIQWnpSEFk6khBX+tIQVrsSEFV7UhBUO5IQUvvSEFF8EhBQPFIQTvySEE180hBMPRIQSv1SEEl9khBIPdIQRr4SEEU+UhBD/pIQQn7SEED/EhB/vxIQfj9SEHy/khB7P9IQeYASUHgAUlB2gJJQdQDSUHOBElByAVJQcIGSUG7B0lBtQhJQa8JSUGoCklBogtJQZwMSUGVDUlBjw5JQYgPSUGCEElBexFJQXQSSUFuE0lBZxRJQWAVSUFZFklBUhdJQUsYSUFEGUlBPRpJQTYbSUEvHElBKB1JQSEeSUEaH0lBEiBJQQshSUEEIklB/CJJQfUjSUHuJElB5iVJQd8mSUHXJ0lBzyhJQcgpSUHAKklBuCtJQbAsSUGpLUlBoS5JQZkvSUGRMElBiTFJQYEySUF5M0lBcTRJQWk1SUFgNklBWDdJQVA4SUFIOUlBPzpJQTc7SUEuPElBJj1JQR0+SUEVP0lBDEBJQQRBSUH7QUlB8kJJQepDSUHhRElB2EVJQc9GSUHGR0lBvUhJQbRJSUGrSklBoktJQZlMSUGQTUlBh05JQX1PSUF0UElBa1FJQWFSSUFYU0lBT1RJQUVVSUE8VklBMldJQShYSUEfWUlBFVpJQQtbSUECXElB+FxJQe5dSUHkXklB2l9JQdBgSUHGYUlBvGJJQbJjSUGoZElBnmVJQZRmSUGJZ0lBf2hJQXVpSUFqaklBYGtJQVZsSUFLbUlBQW5JQTZvSUErcElBIXFJQRZySUELc0lBAXRJQfZ0SUHrdUlB4HZJQdV3SUHKeElBv3lJQbR6SUGpe0lBnnxJQZN9SUGIfklBfH9JQXGASUFmgUlBW4JJQU+DSUFEhElBOIVJQS2GSUEhh0lBFohJQQqJSUH+iUlB84pJQeeLSUHbjElBz41JQcOOSUG3j0lBq5BJQZ+RSUGTkklBh5NJQXuUSUFvlUlBY5ZJQVeXSUFLmElBPplJQTKaSUElm0lBGZxJQQ2dSUEAnklB9J5JQeefSUHaoElBzqFJQcGiSUG0o0lBqKRJQZulSUGOpklBgadJQXSoSUFnqUlBWqpJQU2rSUFArElBM61JQSauSUEZr0lBC7BJQf6wSUHxsUlB47JJQdazSUHJtElBu7VJQa62SUGgt0lBkrhJQYW5SUF3uklBabtJQVy8SUFOvUlBQL5JQTK/SUEkwElBFsFJQQjCSUH6wklB7MNJQd7ESUHQxUlBwsZJQbTHSUGlyElBl8lJQYnKSUF7y0lBbMxJQV7NSUFPzklBQc9JQTLQSUEk0UlBFdJJQQbTSUH400lB6dRJQdrVSUHL1klBvNdJQa3YSUGe2UlBj9pJQYDbSUFx3ElBYt1JQVPeSUFE30lBNeBJQSbhSUEW4klBB+NJQfjjSUHo5ElB2eVJQcnmSUG650lBquhJQZvpSUGL6klBe+tJQWzsSUFc7UlBTO5JQTzvSUEs8ElBHfFJQQ3ySUH98klB7fNJQd30SUHM9UlBvPZJQaz3SUGc+ElBjPlJQXv6SUFr+0lBW/xJQUr9SUE6/klBKv9JQRkASkEIAUpB+AFKQecCSkHXA0pBxgRKQbUFSkGkBkpBlAdKQYMISkFyCUpBYQpKQVALSkE/DEpBLg1KQR0OSkEMD0pB+w9KQekQSkHYEUpBxxJKQbYTSkGkFEpBkxVKQYIWSkFwF0pBXxhKQU0ZSkE8GkpBKhtKQRgcSkEHHUpB9R1KQeMeSkHRH0pBwCBKQa4hSkGcIkpBiiNKQXgkSkFmJUpBVCZKQUInSkEwKEpBHSlKQQsqSkH5KkpB5ytKQdQsSkHCLUpBsC5KQZ0vSkGLMEpBeDFKQWYySkFTM0pBQTRKQS41SkEbNkpBCTdKQfY3SkHjOEpB0DlKQb06SkGqO0pBlzxKQYQ9SkFxPkpBXj9KQUtASkE4QUpBJUJKQRJDSkH/Q0pB60RKQdhFSkHFRkpBsUdKQZ5ISkGKSUpBd0pKQWNLSkFQTEpBPE1KQSlOSkEVT0pBAVBKQe1QSkHaUUpBxlJKQbJTSkGeVEpBilVKQXZWSkFiV0pBTlhKQTpZSkEmWkpBEltKQf1bSkHpXEpB1V1KQcFeSkGsX0pBmGBKQYNhSkFvYkpBWmNKQUZkSkExZUpBHWZKQQhnSkHzZ0pB32hKQcppSkG1akpBoGtKQYtsSkF3bUpBYm5KQU1vSkE4cEpBI3FKQQ5ySkH4ckpB43NKQc50SkG5dUpBpHZKQY53SkF5eEpBZHlKQU56SkE5e0pBI3xKQQ59SkH4fUpB435KQc1/SkG3gEpBooFKQYyCSkF2g0pBYIRKQUuFSkE1hkpBH4dKQQmISkHziEpB3YlKQceKSkGxi0pBmoxKQYSNSkFujkpBWI9KQUKQSkErkUpBFZJKQf+SSkHok0pB0pRKQbuVSkGllkpBjpdKQXeYSkFhmUpBSppKQTObSkEdnEpBBp1KQe+dSkHYnkpBwZ9KQaqgSkGToUpBfKJKQWWjSkFOpEpBN6VKQSCmSkEJp0pB8qdKQdqoSkHDqUpBrKpKQZWrSkF9rEpBZq1KQU6uSkE3r0pBH7BKQQixSkHwsUpB2LJKQcGzSkGptEpBkbVKQXm2SkFit0pBSrhKQTK5SkEaukpBArtKQeq7SkHSvEpBur1KQaK+SkGKv0pBcsBKQVnBSkFBwkpBKcNKQRDESkH4xEpB4MVKQcfGSkGvx0pBlshKQX7JSkFlykpBTctKQTTMSkEbzUpBA85KQerOSkHRz0pBuNBKQZ/RSkGH0kpBbtNKQVXUSkE81UpBI9ZKQQrXSkHx10pB19hKQb7ZSkGl2kpBjNtKQXPcSkFZ3UpBQN5KQSffSkEN4EpB9OBKQdrhSkHB4kpBp+NKQY7kSkF05UpBWuZKQUHnSkEn6EpBDelKQfPpSkHZ6kpBwOtKQabsSkGM7UpBcu5KQVjvSkE+8EpBJPFKQQrySkHv8kpB1fNKQbv0SkGh9UpBhvZKQWz3SkFS+EpBN/lKQR36SkEC+0pB6PtKQc38SkGz/UpBmP5KQX7/SkFjAEtBSAFLQS4CS0ETA0tB+ANLQd0ES0HCBUtBpwZLQYwHS0FxCEtBVglLQTsKS0EgC0tBBQxLQeoMS0HPDUtBtA5LQZgPS0F9EEtBYhFLQUYSS0ErE0tBDxRLQfQUS0HYFUtBvRZLQaEXS0GGGEtBahlLQU4aS0EzG0tBFxxLQfscS0HfHUtBxB5LQagfS0GMIEtBcCFLQVQiS0E4I0tBHCRLQQAlS0HkJUtBxyZLQasnS0GPKEtBcylLQVYqS0E6K0tBHixLQQEtS0HlLUtByC5LQawvS0GPMEtBczFLQVYyS0E6M0tBHTRLQQA1S0HkNUtBxzZLQao3S0GNOEtBcDlLQVM6S0E2O0tBGTxLQfw8S0HfPUtBwj5LQaU/S0GIQEtBa0FLQU5CS0EwQ0tBE0RLQfZES0HYRUtBu0ZLQZ5HS0GASEtBY0lLQUVKS0EoS0tBCkxLQexMS0HPTUtBsU5LQZNPS0F2UEtBWFFLQTpSS0EcU0tB/lNLQeBUS0HCVUtBpFZLQYZXS0FoWEtBSllLQSxaS0EOW0tB8FtLQdFcS0GzXUtBlV5LQXdfS0FYYEtBOmFLQRtiS0H9YktB3mNLQcBkS0GhZUtBg2ZLQWRnS0FFaEtBJ2lLQQhqS0HpaktBymtLQaxsS0GNbUtBbm5LQU9vS0EwcEtBEXFLQfJxS0HTcktBtHNLQZV0S0F1dUtBVnZLQTd3S0EYeEtB+HhLQdl5S0G6ektBmntLQXt8S0FbfUtBPH5LQRx/S0H9f0tB3YBLQb6BS0GegktBfoNLQV6ES0E/hUtBH4ZLQf+GS0Hfh0tBv4hLQZ+JS0F/iktBX4tLQT+MS0EfjUtB/41LQd+OS0G/j0tBn5BLQX6RS0FekktBPpNLQR2US0H9lEtB3ZVLQbyWS0Gcl0tBe5hLQVuZS0E6mktBGptLQfmbS0HYnEtBuJ1LQZeeS0F2n0tBVaBLQTWhS0EUoktB86JLQdKjS0GxpEtBkKVLQW+mS0FOp0tBLahLQQypS0HqqUtByapLQairS0GHrEtBZq1LQUSuS0Ejr0tBAbBLQeCwS0G/sUtBnbJLQXyzS0FatEtBOLVLQRe2S0H1tktB1LdLQbK4S0GQuUtBbrpLQUy7S0ErvEtBCb1LQee9S0HFvktBo79LQYHAS0FfwUtBPcJLQRvDS0H5w0tB1sRLQbTFS0GSxktBcMdLQU3IS0EryUtBCcpLQebKS0HEy0tBocxLQX/NS0FczktBOs9LQRfQS0H10EtB0tFLQa/SS0GN00tBatRLQUfVS0Ek1ktBAddLQd7XS0G82EtBmdlLQXbaS0FT20tBMNxLQQzdS0Hp3UtBxt5LQaPfS0GA4EtBXeFLQTniS0EW40tB8+NLQc/kS0Gs5UtBieZLQWXnS0FC6EtBHulLQfrpS0HX6ktBs+tLQZDsS0Fs7UtBSO5LQSTvS0EB8EtB3fBLQbnxS0GV8ktBcfNLQU30S0Ep9UtBBfZLQeH2S0G990tBmfhLQXX5S0FR+ktBLftLQQj8S0Hk/EtBwP1LQZv+S0F3/0tBUwBMQS4BTEEKAkxB5QJMQcEDTEGcBExBeAVMQVMGTEEuB0xBCghMQeUITEHACUxBnApMQXcLTEFSDExBLQ1MQQgOTEHjDkxBvg9MQZkQTEF0EUxBTxJMQSoTTEEFFExB4BRMQbsVTEGVFkxBcBdMQUsYTEEmGUxBABpMQdsaTEG1G0xBkBxMQWodTEFFHkxBHx9MQfofTEHUIExBryFMQYkiTEFjI0xBPiRMQRglTEHyJUxBzCZMQaYnTEGBKExBWylMQTUqTEEPK0xB6StMQcMsTEGdLUxBdi5MQVAvTEEqMExBBDFMQd4xTEG4MkxBkTNMQWs0TEFFNUxBHjZMQfg2TEHRN0xBqzhMQYQ5TEFeOkxBNztMQRE8TEHqPExBwz1MQZ0+TEF2P0xBT0BMQShBTEECQkxB20JMQbRDTEGNRExBZkVMQT9GTEEYR0xB8UdMQcpITEGjSUxBfEpMQVRLTEEtTExBBk1MQd9NTEG4TkxBkE9MQWlQTEFBUUxBGlJMQfNSTEHLU0xBpFRMQXxVTEFVVkxBLVdMQQVYTEHeWExBtllMQY5aTEFnW0xBP1xMQRddTEHvXUxBx15MQZ9fTEF3YExBT2FMQSdiTEH/YkxB12NMQa9kTEGHZUxBX2ZMQTdnTEEPaExB5mhMQb5pTEGWakxBbWtMQUVsTEEdbUxB9G1MQcxuTEGjb0xBe3BMQVJxTEEqckxBAXNMQdhzTEGwdExBh3VMQV52TEE1d0xBDXhMQeR4TEG7eUxBknpMQWl7TEFAfExBF31MQe59TEHFfkxBnH9MQXOATEFKgUxBIYJMQfiCTEHOg0xBpYRMQXyFTEFShkxBKYdMQQCITEHWiExBrYlMQYOKTEFai0xBMIxMQQeNTEHdjUxBtI5MQYqPTEFgkExBN5FMQQ2STEHjkkxBuZNMQY+UTEFmlUxBPJZMQRKXTEHol0xBvphMQZSZTEFqmkxBQJtMQRacTEHrnExBwZ1MQZeeTEFtn0xBQ6BMQRihTEHuoUxBxKJMQZmjTEFvpExBRKVMQRqmTEHwpkxBxadMQZqoTEFwqUxBRapMQRurTEHwq0xBxaxMQZqtTEFwrkxBRa9MQRqwTEHvsExBxLFMQZmyTEFus0xBQ7RMQRi1TEHttUxBwrZMQZe3TEFsuExBQblMQRa6TEHrukxBv7tMQZS8TEFpvUxBPb5MQRK/TEHnv0xBu8BMQZDBTEFkwkxBOcNMQQ3ETEHixExBtsVMQYrGTEFfx0xBM8hMQQfJTEHcyUxBsMpMQYTLTEFYzExBLM1MQQDOTEHUzkxBqM9MQXzQTEFQ0UxBJNJMQfjSTEHM00xBoNRMQXTVTEFI1kxBG9dMQe/XTEHD2ExBl9lMQWraTEE+20xBEdxMQeXcTEG43UxBjN5MQV/fTEEz4ExBBuFMQdrhTEGt4kxBgONMQVTkTEEn5UxB+uVMQc3mTEGh50xBdOhMQUfpTEEa6kxB7epMQcDrTEGT7ExBZu1MQTnuTEEM70xB3+9MQbLwTEGE8UxBV/JMQSrzTEH980xBz/RMQaL1TEF19kxBR/dMQRr4TEHt+ExBv/lMQZL6TEFk+0xBNvxMQQn9TEHb/UxBrv5MQYD/TEFSAE1BJQFNQfcBTUHJAk1BmwNNQW0ETUE/BU1BEgZNQeQGTUG2B01BiAhNQVoJTUEsCk1B/QpNQc8LTUGhDE1Bcw1NQUUOTUEXD01B6A9NQboQTUGMEU1BXRJNQS8TTUEBFE1B0hRNQaQVTUF1Fk1BRxdNQRgYTUHqGE1BuxlNQYwaTUFeG01BLxxNQQAdTUHSHU1Box5NQXQfTUFFIE1BFiFNQechTUG4Ik1BiiNNQVskTUEsJU1B/CVNQc0mTUGeJ01BbyhNQUApTUERKk1B4ipNQbIrTUGDLE1BVC1NQSUuTUH1Lk1Bxi9NQZYwTUFnMU1BNzJNQQgzTUHYM01BqTRNQXk1TUFKNk1BGjdNQeo3TUG7OE1BizlNQVs6TUErO01B/DtNQcw8TUGcPU1BbD5NQTw/TUEMQE1B3EBNQaxBTUF8Qk1BTENNQRxETUHsRE1BvEVNQYtGTUFbR01BK0hNQftITUHKSU1BmkpNQWpLTUE5TE1BCU1NQdhNTUGoTk1Bd09NQUdQTUEWUU1B5lFNQbVSTUGEU01BVFRNQSNVTUHyVU1BwlZNQZFXTUFgWE1BL1lNQf5ZTUHNWk1BnFtNQWxcTUE7XU1BCl5NQdleTUGnX01BdmBNQUVhTUEUYk1B42JNQbJjTUGAZE1BT2VNQR5mTUHtZk1Bu2dNQYpoTUFYaU1BJ2pNQfZqTUHEa01BkmxNQWFtTUEvbk1B/m5NQcxvTUGacE1BaXFNQTdyTUEFc01B1HNNQaJ0TUFwdU1BPnZNQQx3TUHad01BqHhNQXZ5TUFEek1BEntNQeB7TUGufE1BfH1NQUp+TUEYf01B5n9NQbOATUGBgU1BT4JNQR2DTUHqg01BuIRNQYWFTUFThk1BIYdNQe6HTUG8iE1BiYlNQVeKTUEki01B8YtNQb+MTUGMjU1BWY5NQSePTUH0j01BwZBNQY6RTUFbkk1BKZNNQfaTTUHDlE1BkJVNQV2WTUEql01B95dNQcSYTUGRmU1BXppNQSqbTUH3m01BxJxNQZGdTUFenk1BKp9NQfefTUHEoE1BkKFNQV2iTUEpo01B9qNNQcOkTUGPpU1BW6ZNQSinTUH0p01BwahNQY2pTUFZqk1BJqtNQfKrTUG+rE1Biq1NQVeuTUEjr01B769NQbuwTUGHsU1BU7JNQR+zTUHrs01Bt7RNQYO1TUFPtk1BG7dNQee3TUGzuE1BfrlNQUq6TUEWu01B4rtNQa28TUF5vU1BRb5NQRC/TUHcv01BqMBNQXPBTUE/wk1BCsNNQdbDTUGhxE1BbMVNQTjGTUEDx01BzsdNQZrITUFlyU1BMMpNQfvKTUHHy01BksxNQV3NTUEozk1B885NQb7PTUGJ0E1BVNFNQR/STUHq0k1BtdNNQYDUTUFL1U1BFdZNQeDWTUGr101BdthNQUDZTUEL2k1B1tpNQaDbTUFr3E1BNt1NQQDeTUHL3k1Bld9NQWDgTUEq4U1B9eFNQb/iTUGJ401BVORNQR7lTUHo5U1BsuZNQX3nTUFH6E1BEelNQdvpTUGl6k1Bb+tNQTrsTUEE7U1Bzu1NQZjuTUFi701BK/BNQfXwTUG/8U1BifJNQVPzTUEd9E1B5vRNQbD1TUF69k1BRPdNQQ34TUHX+E1BoflNQWr6TUE0+01B/ftNQcf8TUGQ/U1BWv5NQSP/TUHs/01BtgBOQX8BTkFIAk5BEgNOQdsDTkGkBE5BbQVOQTcGTkEAB05ByQdOQZIITkFbCU5BJApOQe0KTkG2C05BfwxOQUgNTkERDk5B2g5OQaMPTkFsEE5BNBFOQf0RTkHGEk5BjxNOQVcUTkEgFU5B6RVOQbEWTkF6F05BQhhOQQsZTkHTGU5BnBpOQWQbTkEtHE5B9RxOQb4dTkGGHk5BTh9OQRcgTkHfIE5BpyFOQW8iTkE4I05BACROQcgkTkGQJU5BWCZOQSAnTkHoJ05BsChOQXgpTkFAKk5BCCtOQdArTkGYLE5BYC1OQSguTkHvLk5Bty9OQX8wTkFHMU5BDjJOQdYyTkGeM05BZTROQS01TkH0NU5BvDZOQYM3TkFLOE5BEjlOQdo5TkGhOk5BaTtOQTA8TkH3PE5Bvj1OQYY+TkFNP05BFEBOQdtATkGjQU5BakJOQTFDTkH4Q05Bv0ROQYZFTkFNRk5BFEdOQdtHTkGiSE5BaUlOQTBKTkH3Sk5BvUtOQYRMTkFLTU5BEk5OQdhOTkGfT05BZlBOQSxRTkHzUU5BulJOQYBTTkFHVE5BDVVOQdRVTkGaVk5BYVdOQSdYTkHtWE5BtFlOQXpaTkFAW05BB1xOQc1cTkGTXU5BWV5OQSBfTkHmX05BrGBOQXJhTkE4Yk5B/mJOQcRjTkGKZE5BUGVOQRZmTkHcZk5BomdOQWhoTkEuaU5B82lOQblqTkF/a05BRWxOQQptTkHQbU5Blm5OQVtvTkEhcE5B5nBOQaxxTkFyck5BN3NOQf1zTkHCdE5Bh3VOQU12TkESd05B2HdOQZ14TkFieU5BJ3pOQe16TkGye05Bd3xOQTx9TkEBfk5Bx35OQYx/TkFRgE5BFoFOQduBTkGggk5BZYNOQSqETkHvhE5Bs4VOQXiGTkE9h05BAohOQceITkGLiU5BUIpOQRWLTkHai05BnoxOQWONTkEnjk5B7I5OQbGPTkF1kE5BOpFOQf6RTkHDkk5Bh5NOQUuUTkEQlU5B1JVOQZiWTkFdl05BIZhOQeWYTkGpmU5BbppOQTKbTkH2m05BupxOQX6dTkFCnk5BBp9OQcqfTkGOoE5BUqFOQRaiTkHaok5BnqNOQWKkTkEmpU5B6qVOQa2mTkFxp05BNahOQfmoTkG8qU5BgKpOQUSrTkEHrE5By6xOQY6tTkFSrk5BFa9OQdmvTkGcsE5BYLFOQSOyTkHnsk5BqrNOQW20TkExtU5B9LVOQbe2TkF6t05BPrhOQQG5TkHEuU5Bh7pOQUq7TkENvE5B0LxOQZO9TkFWvk5BGb9OQdy/TkGfwE5BYsFOQSXCTkHowk5Bq8NOQW7ETkEwxU5B88VOQbbGTkF4x05BO8hOQf7ITkHAyU5Bg8pOQUbLTkEIzE5By8xOQY3NTkFQzk5BEs9OQdXPTkGX0E5BWdFOQRzSTkHe0k5BoNNOQWPUTkEl1U5B59VOQanWTkFs105BLthOQfDYTkGy2U5BdNpOQTbbTkH4205ButxOQXzdTkE+3k5BAN9OQcLfTkGE4E5BRuFOQQfiTkHJ4k5Bi+NOQU3kTkEP5U5B0OVOQZLmTkFU505BFehOQdfoTkGY6U5BWupOQRzrTkHd605Bn+xOQWDtTkEh7k5B4+5OQaTvTkFm8E5BJ/FOQejxTkGq8k5Ba/NOQSz0TkHt9E5BrvVOQXD2TkEx905B8vdOQbP4TkF0+U5BNfpOQfb6TkG3+05BePxOQTn9TkH6/U5Bu/5OQXz/TkE9AE9B/QBPQb4BT0F/Ak9BQANPQQAET0HBBE9BggVPQUIGT0EDB09BxAdPQYQIT0FFCU9BBQpPQcYKT0GGC09BRwxPQQcNT0HIDU9BiA5PQUgPT0EJEE9ByRBPQYkRT0FJEk9BChNPQcoTT0GKFE9BShVPQQoWT0HKFk9BixdPQUsYT0ELGU9ByxlPQYsaT0FLG09BCxxPQcscT0GKHU9BSh5PQQofT0HKH09BiiBPQUkhT0EJIk9BySJPQYkjT0FIJE9BCCVPQcglT0GHJk9BRydPQQYoT0HGKE9BhSlPQUUqT0EEK09BxCtPQYMsT0FCLU9BAi5PQcEuT0GAL09BQDBPQf8wT0G+MU9BfTJPQT0zT0H8M09BuzRPQXo1T0E5Nk9B+DZPQbc3T0F2OE9BNTlPQfQ5T0GzOk9BcjtPQTE8T0HwPE9Brz1PQW4+T0EsP09B6z9PQapAT0FpQU9BJ0JPQeZCT0GlQ09BY0RPQSJFT0HhRU9Bn0ZPQV5HT0EcSE9B20hPQZlJT0FYSk9BFktPQdRLT0GTTE9BUU1PQQ9OT0HOTk9BjE9PQUpQT0EIUU9Bx1FPQYVST0FDU09BAVRPQb9UT0F9VU9BO1ZPQflWT0G3V09BdVhPQTNZT0HxWU9Br1pPQW1bT0ErXE9B6VxPQaddT0FkXk9BIl9PQeBfT0GeYE9BW2FPQRliT0HXYk9BlGNPQVJkT0EQZU9BzWVPQYtmT0FIZ09BBmhPQcNoT0GBaU9BPmpPQftqT0G5a09BdmxPQTNtT0HxbU9Brm5PQWtvT0EocE9B5nBPQaNxT0Fgck9BHXNPQdpzT0GXdE9BVHVPQRF2T0HOdk9Bi3dPQUh4T0EFeU9BwnlPQX96T0E8e09B+XtPQbZ8T0FyfU9BL35PQex+T0Gpf09BZYBPQSKBT0HfgU9Bm4JPQViDT0EVhE9B0YRPQY6FT0FKhk9BB4dPQcOHT0GAiE9BPIlPQfmJT0G1ik9BcYtPQS6MT0HqjE9Bpo1PQWKOT0Efj09B249PQZeQT0FTkU9BD5JPQcyST0GIk09BRJRPQQCVT0G8lU9BeJZPQTSXT0Hwl09BrJhPQWiZT0Ejmk9B35pPQZubT0FXnE9BE51PQc+dT0GKnk9BRp9PQQKgT0G9oE9BeaFPQTWiT0Hwok9BrKNPQWekT0EjpU9B3qVPQZqmT0FVp09BEahPQcyoT0GIqU9BQ6pPQf6qT0G6q09BdaxPQTCtT0HsrU9Bp65PQWKvT0EdsE9B2LBPQZSxT0FPsk9BCrNPQcWzT0GAtE9BO7VPQfa1T0Gxtk9BbLdPQSe4T0HiuE9BnblPQVe6T0ESu09BzbtPQYi8T0FDvU9B/b1PQbi+T0Fzv09BLsBPQejAT0GjwU9BXcJPQRjDT0HTw09BjcRPQUjFT0ECxk9BvcZPQXfHT0EyyE9B7MhPQabJT0Fhyk9BG8tPQdXLT0GQzE9BSs1PQQTOT0G+zk9Bec9PQTPQT0Ht0E9Bp9FPQWHST0Eb009B1dNPQY/UT0FJ1U9BA9ZPQb3WT0F3109BMdhPQevYT0Gl2U9BX9pPQRnbT0HS209BjNxPQUbdT0EA3k9Bud5PQXPfT0Et4E9B5uBPQaDhT0Fa4k9BE+NPQc3jT0GG5E9BQOVPQfnlT0Gz5k9BbOdPQSboT0Hf6E9BmelPQVLqT0EL609BxetPQX7sT0E37U9B8O1PQaruT0Fj709BHPBPQdXwT0GO8U9BR/JPQQDzT0G5809BcvRPQSv1T0Hk9U9BnfZPQVb3T0EP+E9ByPhPQYH5T0E6+k9B8/pPQaz7T0Fk/E9BHf1PQdb9T0GP/k9BR/9PQQAAUEG5AFBBcQFQQSoCUEHiAlBBmwNQQVQEUEEMBVBBxQVQQX0GUEE2B1BB7gdQQaYIUEFfCVBBFwpQQc8KUEGIC1BBQAxQQfgMUEGxDVBBaQ5QQSEPUEHZD1BBkRBQQUkRUEECElBBuhJQQXITUEEqFFBB4hRQQZoVUEFSFlBBChdQQcIXUEF6GFBBMhlQQekZUEGhGlBBWRtQQREcUEHJHFBBgB1QQTgeUEHwHlBBqB9QQV8gUEEXIVBBziFQQYYiUEE+I1BB9SNQQa0kUEFkJVBBHCZQQdMmUEGLJ1BBQihQQfkoUEGxKVBBaCpQQSArUEHXK1BBjixQQUUtUEH9LVBBtC5QQWsvUEEiMFBB2TBQQZExUEFIMlBB/zJQQbYzUEFtNFBBJDVQQds1UEGSNlBBSTdQQQA4UEG3OFBBbjlQQSQ6UEHbOlBBkjtQQUk8UEEAPVBBtj1QQW0+UEEkP1BB2z9QQZFAUEFIQVBB/kFQQbVCUEFsQ1BBIkRQQdlEUEGPRVBBRkZQQfxGUEGzR1BBaUhQQSBJUEHWSVBBjEpQQUNLUEH5S1BBr0xQQWVNUEEcTlBB0k5QQYhPUEE+UFBB9VBQQatRUEFhUlBBF1NQQc1TUEGDVFBBOVVQQe9VUEGlVlBBW1dQQRFYUEHHWFBBfVlQQTNaUEHpWlBBnltQQVRcUEEKXVBBwF1QQXVeUEErX1BB4V9QQZdgUEFMYVBBAmJQQbdiUEFtY1BBI2RQQdhkUEGOZVBBQ2ZQQflmUEGuZ1BBZGhQQRlpUEHOaVBBhGpQQTlrUEHva1BBpGxQQVltUEEOblBBxG5QQXlvUEEucFBB43BQQZhxUEFOclBBA3NQQbhzUEFtdFBBInVQQdd1UEGMdlBBQXdQQfZ3UEGreFBBYHlQQRV6UEHKelBBfntQQTN8UEHofFBBnX1QQVJ+UEEGf1BBu39QQXCAUEEkgVBB2YFQQY6CUEFCg1BB94NQQayEUEFghVBBFYZQQcmGUEF+h1BBMohQQeeIUEGbiVBBT4pQQQSLUEG4i1BBbIxQQSGNUEHVjVBBiY5QQT6PUEHyj1BBppBQQVqRUEEOklBBw5JQQXeTUEErlFBB35RQQZOVUEFHllBB+5ZQQa+XUEFjmFBBF5lQQcuZUEF/mlBBM5tQQeebUEGanFBBTp1QQQKeUEG2nlBBap9QQR2gUEHRoFBBhaFQQTiiUEHsolBBoKNQQVOkUEEHpVBBuqVQQW6mUEEhp1BB1adQQYioUEE8qVBB76lQQaOqUEFWq1BBCqxQQb2sUEFwrVBBJK5QQdeuUEGKr1BBPbBQQfGwUEGksVBBV7JQQQqzUEG9s1BBcLRQQSS1UEHXtVBBirZQQT23UEHwt1BBo7hQQVa5UEEJulBBvLpQQW67UEEhvFBB1LxQQYe9UEE6vlBB7b5QQZ+/UEFSwFBBBcFQQbjBUEFqwlBBHcNQQdDDUEGCxFBBNcVQQejFUEGaxlBBTcdQQf/HUEGyyFBBZMlQQRfKUEHJylBBfMtQQS7MUEHgzFBBk81QQUXOUEH3zlBBqs9QQVzQUEEO0VBBwNFQQXPSUEEl01BB19NQQYnUUEE71VBB7dVQQaDWUEFS11BBBNhQQbbYUEFo2VBBGtpQQczaUEF+21BBL9xQQeHcUEGT3VBBRd5QQffeUEGp31BBW+BQQQzhUEG+4VBBcOJQQSLjUEHT41BBheRQQTflUEHo5VBBmuZQQUvnUEH951BBruhQQWDpUEES6lBBw+pQQXTrUEEm7FBB1+xQQYntUEE67lBB6+5QQZ3vUEFO8FBB//BQQbHxUEFi8lBBE/NQQcTzUEF29FBBJ/VQQdj1UEGJ9lBBOvdQQev3UEGc+FBBTflQQf75UEGv+lBBYPtQQRH8UEHC/FBBc/1QQST+UEHV/lBBhv9QQTcAUUHnAFFBmAFRQUkCUUH6AlFBqwNRQVsEUUEMBVFBvQVRQW0GUUEeB1FBzwdRQX8IUUEwCVFB4AlRQZEKUUFBC1FB8gtRQaIMUUFTDVFBAw5RQbQOUUFkD1FBFBBRQcUQUUF1EVFBJRJRQdYSUUGGE1FBNhRRQeYUUUGWFVFBRxZRQfcWUUGnF1FBVxhRQQcZUUG3GVFBZxpRQRcbUUHHG1FBdxxRQScdUUHXHVFBhx5RQTcfUUHnH1FBlyBRQUchUUH3IVFBpiJRQVYjUUEGJFFBtiRRQWUlUUEVJlFBxSZRQXUnUUEkKFFB1ChRQYMpUUEzKlFB4ypRQZIrUUFCLFFB8SxRQaEtUUFQLlFBAC9RQa8vUUFeMFFBDjFRQb0xUUFsMlFBHDNRQcszUUF6NFFBKjVRQdk1UUGINlFBNzdRQeY3UUGWOFFBRTlRQfQ5UUGjOlFBUjtRQQE8UUGwPFFBXz1RQQ4+UUG9PlFBbD9RQRtAUUHKQFFBeUFRQShCUUHXQlFBhUNRQTREUUHjRFFBkkVRQUFGUUHvRlFBnkdRQU1IUUH7SFFBqklRQVlKUUEHS1FBtktRQWRMUUETTVFBwk1RQXBOUUEfT1FBzU9RQXxQUUEqUVFB2FFRQYdSUUE1U1FB41NRQZJUUUFAVVFB7lVRQZ1WUUFLV1FB+VdRQadYUUFWWVFBBFpRQbJaUUFgW1FBDlxRQbxcUUFqXVFBGF5RQcZeUUF0X1FBImBRQdBgUUF+YVFBLGJRQdpiUUGIY1FBNmRRQeRkUUGSZVFBP2ZRQe1mUUGbZ1FBSWhRQfZoUUGkaVFBUmpRQQBrUUGta1FBW2xRQQhtUUG2bVFBZG5RQRFvUUG/b1FBbHBRQRpxUUHHcVFBdXJRQSJzUUHPc1FBfXRRQSp1UUHYdVFBhXZRQTJ3UUHgd1FBjXhRQTp5UUHneVFBlXpRQUJ7UUHve1FBnHxRQUl9UUH2fVFBo35RQVB/UUH+f1FBq4BRQViBUUEFglFBsoJRQV+DUUELhFFBuIRRQWWFUUEShlFBv4ZRQWyHUUEZiFFBxYhRQXKJUUEfilFBzIpRQXiLUUEljFFB0oxRQX+NUUErjlFB2I5RQYSPUUExkFFB3pBRQYqRUUE3klFB45JRQZCTUUE8lFFB6ZRRQZWVUUFBllFB7pZRQZqXUUFGmFFB85hRQZ+ZUUFLmlFB+JpRQaSbUUFQnFFB/JxRQamdUUFVnlFBAZ9RQa2fUUFZoFFBBaFRQbGhUUFdolFBCaNRQbWjUUFhpFFBDaVRQbmlUUFlplFBEadRQb2nUUFpqFFBFalRQcGpUUFsqlFBGKtRQcSrUUFwrFFBG61RQcetUUFzrlFBH69RQcqvUUF2sFFBIrFRQc2xUUF5slFBJLNRQdCzUUF7tFFBJ7VRQdK1UUF+tlFBKbdRQdW3UUGAuFFBK7lRQde5UUGCulFBLrtRQdm7UUGEvFFBL71RQdu9UUGGvlFBMb9RQdy/UUGHwFFBM8FRQd7BUUGJwlFBNMNRQd/DUUGKxFFBNcVRQeDFUUGLxlFBNsdRQeHHUUGMyFFBN8lRQeLJUUGNylFBOMtRQePLUUGNzFFBOM1RQePNUUGOzlFBOM9RQePPUUGO0FFBOdFRQePRUUGO0lFBOdNRQePTUUGO1FFBONVRQePVUUGN1lFBONdRQePXUUGN2FFBN9lRQeLZUUGM2lFBN9tRQeHbUUGL3FFBNt1RQeDdUUGK3lFBNd9RQd/fUUGJ4FFBNOFRQd7hUUGI4lFBMuNRQdzjUUGG5FFBMeVRQdvlUUGF5lFBL+dRQdnnUUGD6FFBLelRQdfpUUGB6lFBK+tRQdXrUUF/7FFBKO1RQdLtUUF87lFBJu9RQdDvUUF68FFBI/FRQc3xUUF38lFBIfNRQcrzUUF09FFBHvVRQcf1UUFx9lFBGvdRQcT3UUFu+FFBF/lRQcH5UUFq+lFBFPtRQb37UUFn/FFBEP1RQbn9UUFj/lFBDP9RQbb/UUFfAFJBCAFSQbIBUkFbAlJBBANSQa0DUkFXBFJBAAVSQakFUkFSBlJB+wZSQaQHUkFOCFJB9whSQaAJUkFJClJB8gpSQZsLUkFEDFJB7QxSQZYNUkE/DlJB6A5SQZAPUkE5EFJB4hBSQYsRUkE0ElJB3RJSQYUTUkEuFFJB1xRSQYAVUkEoFlJB0RZSQXoXUkEiGFJByxhSQXQZUkEcGlJBxRpSQW0bUkEWHFJBvxxSQWcdUkEQHlJBuB5SQWAfUkEJIFJBsSBSQVohUkECIlJBqiJSQVMjUkH7I1JBoyRSQUwlUkH0JVJBnCZSQUQnUkHtJ1JBlShSQT0pUkHlKVJBjSpSQTUrUkHeK1JBhixSQS4tUkHWLVJBfi5SQSYvUkHOL1JBdjBSQR4xUkHGMVJBbTJSQRUzUkG9M1JBZTRSQQ01UkG1NVJBXDZSQQQ3UkGsN1JBVDhSQfs4UkGjOVJBSzpSQfM6UkGaO1JBQjxSQek8UkGRPVJBOT5SQeA+UkGIP1JBL0BSQddAUkF+QVJBJkJSQc1CUkF1Q1JBHERSQcNEUkFrRVJBEkZSQblGUkFhR1JBCEhSQa9IUkFXSVJB/klSQaVKUkFMS1JB80tSQZtMUkFCTVJB6U1SQZBOUkE3T1JB3k9SQYVQUkEsUVJB01FSQXpSUkEhU1JByFNSQW9UUkEWVVJBvVVSQWRWUkELV1JBsldSQVhYUkH/WFJBpllSQU1aUkH0WlJBmltSQUFcUkHoXFJBjl1SQTVeUkHcXlJBgl9SQSlgUkHQYFJBdmFSQR1iUkHDYlJBamNSQRBkUkG3ZFJBXWVSQQRmUkGqZlJBUWdSQfdnUkGdaFJBRGlSQeppUkGQalJBN2tSQd1rUkGDbFJBKW1SQdBtUkF2blJBHG9SQcJvUkFocFJBD3FSQbVxUkFbclJBAXNSQadzUkFNdFJB83RSQZl1UkE/dlJB5XZSQYt3UkExeFJB13hSQX15UkEjelJByHpSQW57UkEUfFJBunxSQWB9UkEFflJBq35SQVF/UkH3f1JBnIBSQUKBUkHogVJBjYJSQTODUkHZg1JBfoRSQSSFUkHJhVJBb4ZSQRSHUkG6h1JBX4hSQQWJUkGqiVJBUIpSQfWKUkGbi1JBQIxSQeWMUkGLjVJBMI5SQdWOUkF7j1JBIJBSQcWQUkFqkVJBD5JSQbWSUkFak1JB/5NSQaSUUkFJlVJB7pVSQZOWUkE5l1JB3pdSQYOYUkEomVJBzZlSQXKaUkEXm1JBvJtSQWCcUkEFnVJBqp1SQU+eUkH0nlJBmZ9SQT6gUkHioFJBh6FSQSyiUkHRolJBdaNSQRqkUkG/pFJBZKVSQQimUkGtplJBUadSQfanUkGbqFJBP6lSQeSpUkGIqlJBLatSQdGrUkF2rFJBGq1SQb+tUkFjrlJBB69SQayvUkFQsFJB9bBSQZmxUkE9slJB4rJSQYazUkEqtFJBzrRSQXO1UkEXtlJBu7ZSQV+3UkEDuFJBp7hSQUy5UkHwuVJBlLpSQTi7UkHcu1JBgLxSQSS9UkHIvVJBbL5SQRC/UkG0v1JBWMBSQfzAUkGfwVJBQ8JSQefCUkGLw1JBL8RSQdPEUkF2xVJBGsZSQb7GUkFix1JBBchSQanIUkFNyVJB8MlSQZTKUkE4y1JB28tSQX/MUkEizVJBxs1SQWrOUkENz1JBsc9SQVTQUkH30FJBm9FSQT7SUkHi0lJBhdNSQSnUUkHM1FJBb9VSQRPWUkG21lJBWddSQfzXUkGg2FJBQ9lSQebZUkGJ2lJBLdtSQdDbUkFz3FJBFt1SQbndUkFc3lJB/95SQaLfUkFF4FJB6OBSQYvhUkEu4lJB0eJSQXTjUkEX5FJBuuRSQV3lUkEA5lJBo+ZSQUbnUkHo51JBi+hSQS7pUkHR6VJBdOpSQRbrUkG561JBXOxSQf7sUkGh7VJBRO5SQebuUkGJ71JBLPBSQc7wUkFx8VJBE/JSQbbyUkFY81JB+/NSQZ30UkFA9VJB4vVSQYX2UkEn91JByvdSQWz4UkEO+VJBsflSQVP6UkH1+lJBmPtSQTr8UkHc/FJBfv1SQSH+UkHD/lJBZf9SQQcAU0GpAFNBSwFTQe0BU0GQAlNBMgNTQdQDU0F2BFNBGAVTQboFU0FcBlNB/gZTQaAHU0FCCFNB5AhTQYUJU0EnClNByQpTQWsLU0ENDFNBrwxTQVENU0HyDVNBlA5TQTYPU0HYD1NBeRBTQRsRU0G9EVNBXhJTQQATU0GiE1NBQxRTQeUUU0GGFVNBKBZTQcoWU0FrF1NBDRhTQa4YU0FQGVNB8RlTQZIaU0E0G1NB1RtTQXccU0EYHVNBuR1TQVseU0H8HlNBnR9TQT8gU0HgIFNBgSFTQSIiU0HEIlNBZSNTQQYkU0GnJFNBSCVTQeklU0GLJlNBLCdTQc0nU0FuKFNBDylTQbApU0FRKlNB8ipTQZMrU0E0LFNB1SxTQXYtU0EXLlNBty5TQVgvU0H5L1NBmjBTQTsxU0HcMVNBfDJTQR0zU0G+M1NBXzRTQf80U0GgNVNBQTZTQeE2U0GCN1NBIzhTQcM4U0FkOVNBBTpTQaU6U0FGO1NB5jtTQYc8U0EnPVNByD1TQWg+U0EJP1NBqT9TQUlAU0HqQFNBikFTQStCU0HLQlNBa0NTQQxEU0GsRFNBTEVTQexFU0GNRlNBLUdTQc1HU0FtSFNBDUlTQa5JU0FOSlNB7kpTQY5LU0EuTFNBzkxTQW5NU0EOTlNBrk5TQU5PU0HuT1NBjlBTQS5RU0HOUVNBblJTQQ5TU0GuU1NBTlRTQe5UU0GNVVNBLVZTQc1WU0FtV1NBDVhTQaxYU0FMWVNB7FlTQYtaU0ErW1NBy1tTQWpcU0EKXVNBql1TQUleU0HpXlNBiF9TQShgU0HIYFNBZ2FTQQdiU0GmYlNBRmNTQeVjU0GEZFNBJGVTQcNlU0FjZlNBAmdTQaFnU0FBaFNB4GhTQX9pU0EfalNBvmpTQV1rU0H8a1NBnGxTQTttU0HabVNBeW5TQRhvU0G3b1NBVnBTQfZwU0GVcVNBNHJTQdNyU0Fyc1NBEXRTQbB0U0FPdVNB7nVTQY12U0Esd1NBy3dTQWl4U0EIeVNBp3lTQUZ6U0HlelNBhHtTQSJ8U0HBfFNBYH1TQf99U0GdflNBPH9TQdt/U0F6gFNBGIFTQbeBU0FVglNB9IJTQZODU0ExhFNB0IRTQW6FU0ENhlNBq4ZTQUqHU0Hoh1NBh4hTQSWJU0HEiVNBYopTQQGLU0Gfi1NBPYxTQdyMU0F6jVNBGI5TQbeOU0FVj1NB849TQZGQU0EwkVNBzpFTQWySU0EKk1NBqJNTQUeUU0HllFNBg5VTQSGWU0G/llNBXZdTQfuXU0GZmFNBN5lTQdWZU0FzmlNBEZtTQa+bU0FNnFNB65xTQYmdU0EnnlNBxZ5TQWKfU0EAoFNBnqBTQTyhU0HaoVNBd6JTQRWjU0Gzo1NBUaRTQe6kU0GMpVNBKqZTQcemU0Flp1NBA6hTQaCoU0E+qVNB26lTQXmqU0EWq1NBtKtTQVGsU0HvrFNBjK1TQSquU0HHrlNBZa9TQQKwU0GgsFNBPbFTQdqxU0F4slNBFbNTQbKzU0FQtFNB7bRTQYq1U0EntlNBxbZTQWK3U0H/t1NBnLhTQTm5U0HWuVNBdLpTQRG7U0Guu1NBS7xTQei8U0GFvVNBIr5TQb++U0Fcv1NB+b9TQZbAU0EzwVNB0MFTQW3CU0EKw1NBp8NTQUTEU0HgxFNBfcVTQRrGU0G3xlNBVMdTQfDHU0GNyFNBKslTQcfJU0FjylNBAMtTQZ3LU0E5zFNB1sxTQXPNU0EPzlNBrM5TQUjPU0Hlz1NBgdBTQR7RU0G70VNBV9JTQfTSU0GQ01NBLNRTQcnUU0Fl1VNBAtZTQZ7WU0E611NB19dTQXPYU0EP2VNBrNlTQUjaU0Hk2lNBgdtTQR3cU0G53FNBVd1TQfHdU0GO3lNBKt9TQcbfU0Fi4FNB/uBTQZrhU0E24lNB0uJTQW7jU0EK5FNBpuRTQULlU0He5VNBeuZTQRbnU0Gy51NBTuhTQeroU0GG6VNBIupTQb7qU0FZ61NB9etTQZHsU0Et7VNBye1TQWTuU0EA71NBnO9TQTjwU0HT8FNBb/FTQQvyU0Gm8lNBQvNTQd7zU0F59FNBFfVTQbD1U0FM9lNB5/ZTQYP3U0Ee+FNBuvhTQVX5U0Hx+VNBjPpTQSj7U0HD+1NBXvxTQfr8U0GV/VNBMP5TQcz+U0Fn/1NBAgBUQZ4AVEE5AVRB1AFUQW8CVEELA1RBpgNUQUEEVEHcBFRBdwVUQRIGVEGuBlRBSQdUQeQHVEF/CFRBGglUQbUJVEFQClRB6wpUQYYLVEEhDFRBvAxUQVcNVEHyDVRBjQ5UQSgPVEHCD1RBXRBUQfgQVEGTEVRBLhJUQckSVEFjE1RB/hNUQZkUVEE0FVRBzhVUQWkWVEEEF1RBnhdUQTkYVEHUGFRBbhlUQQkaVEGjGlRBPhtUQdkbVEFzHFRBDh1UQagdVEFDHlRB3R5UQXgfVEESIFRBrSBUQUchVEHhIVRBfCJUQRYjVEGwI1RBSyRUQeUkVEF/JVRBGiZUQbQmVEFOJ1RB6SdUQYMoVEEdKVRBtylUQVEqVEHsKlRBhitUQSAsVEG6LFRBVC1UQe4tVEGILlRBIi9UQbwvVEFWMFRB8DBUQYoxVEEkMlRBvjJUQVgzVEHyM1RBjDRUQSY1VEHANVRBWjZUQfQ2VEGNN1RBJzhUQcE4VEFbOVRB9TlUQY46VEEoO1RBwjtUQVw8VEH1PFRBjz1UQSk+VEHCPlRBXD9UQfY/VEGPQFRBKUFUQcJBVEFcQlRB9UJUQY9DVEEoRFRBwkRUQVtFVEH1RVRBjkZUQShHVEHBR1RBW0hUQfRIVEGNSVRBJ0pUQcBKVEFZS1RB80tUQYxMVEElTVRBv01UQVhOVEHxTlRBik9UQSNQVEG9UFRBVlFUQe9RVEGIUlRBIVNUQbpTVEFTVFRB7FRUQYZVVEEfVlRBuFZUQVFXVEHqV1RBg1hUQRxZVEG1WVRBTVpUQeZaVEF/W1RBGFxUQbFcVEFKXVRB411UQXxeVEEUX1RBrV9UQUZgVEHfYFRBd2FUQRBiVEGpYlRBQmNUQdpjVEFzZFRBDGVUQaRlVEE9ZlRB1mZUQW5nVEEHaFRBn2hUQThpVEHQaVRBaWpUQQFrVEGaa1RBMmxUQctsVEFjbVRB/G1UQZRuVEEtb1RBxW9UQV1wVEH2cFRBjnFUQSZyVEG/clRBV3NUQe9zVEGHdFRBIHVUQbh1VEFQdlRB6HZUQYB3VEEZeFRBsXhUQUl5VEHheVRBeXpUQRF7VEGpe1RBQXxUQdl8VEFxfVRBCX5UQaF+VEE5f1RB0X9UQWmAVEEBgVRBmYFUQTGCVEHJglRBYYNUQfmDVEGRhFRBKIVUQcCFVEFYhlRB8IZUQYiHVEEfiFRBt4hUQU+JVEHniVRBfopUQRaLVEGui1RBRYxUQd2MVEF1jVRBDI5UQaSOVEE7j1RB049UQWqQVEECkVRBmZFUQTGSVEHIklRBYJNUQfeTVEGPlFRBJpVUQb6VVEFVllRB7JZUQYSXVEEbmFRBsphUQUqZVEHhmVRBeJpUQRCbVEGnm1RBPpxUQdWcVEFsnVRBBJ5UQZueVEEyn1RByZ9UQWCgVEH3oFRBj6FUQSaiVEG9olRBVKNUQeujVEGCpFRBGaVUQbClVEFHplRB3qZUQXWnVEEMqFRBo6hUQTqpVEHQqVRBZ6pUQf6qVEGVq1RBLKxUQcOsVEFZrVRB8K1UQYeuVEEer1RBta9UQUuwVEHisFRBebFUQQ+yVEGmslRBPbNUQdOzVEFqtFRBAbVUQZe1VEEutlRBxLZUQVu3VEHxt1RBiLhUQR65VEG1uVRBS7pUQeK6VEF4u1RBD7xUQaW8VEE7vVRB0r1UQWi+VEH/vlRBlb9UQSvAVEHCwFRBWMFUQe7BVEGEwlRBG8NUQbHDVEFHxFRB3cRUQXPFVEEKxlRBoMZUQTbHVEHMx1RBYshUQfjIVEGOyVRBJMpUQbrKVEFRy1RB58tUQX3MVEETzVRBqc1UQT7OVEHUzlRBas9UQQDQVEGW0FRBLNFUQcLRVEFY0lRB7tJUQYTTVEEZ1FRBr9RUQUXVVEHb1VRBcNZUQQbXVEGc11RBMthUQcfYVEFd2VRB89lUQYjaVEEe21RBtNtUQUncVEHf3FRBdN1UQQreVEGf3lRBNd9UQcvfVEFg4FRB9uBUQYvhVEEg4lRBtuJUQUvjVEHh41RBduRUQQzlVEGh5VRBNuZUQczmVEFh51RB9udUQYzoVEEh6VRBtulUQUvqVEHh6lRBdutUQQvsVEGg7FRBNe1UQcvtVEFg7lRB9e5UQYrvVEEf8FRBtPBUQUnxVEHe8VRBc/JUQQjzVEGd81RBMvRUQcf0VEFc9VRB8fVUQYb2VEEb91RBsPdUQUX4VEHa+FRBb/lUQQT6VEGZ+lRBLftUQcL7VEFX/FRB7PxUQYH9VEEV/lRBqv5UQT//VEHU/1RBaABVQf0AVUGSAVVBJgJVQbsCVUFPA1VB5ANVQXkEVUENBVVBogVVQTYGVUHLBlVBXwdVQfQHVUGICFVBHQlVQbEJVUFGClVB2gpVQW8LVUEDDFVBlwxVQSwNVUHADVVBVQ5VQekOVUF9D1VBEhBVQaYQVUE6EVVBzhFVQWMSVUH3ElVBixNVQR8UVUGzFFVBSBVVQdwVVUFwFlVBBBdVQZgXVUEsGFVBwBhVQVQZVUHoGVVBfRpVQREbVUGlG1VBORxVQc0cVUFhHVVB9B1VQYgeVUEcH1VBsB9VQUQgVUHYIFVBbCFVQQAiVUGUIlVBJyNVQbsjVUFPJFVB4yRVQXclVUEKJlVBniZVQTInVUHGJ1VBWShVQe0oVUGBKVVBFCpVQagqVUE7K1VBzytVQWMsVUH2LFVBii1VQR0uVUGxLlVBRC9VQdgvVUFrMFVB/zBVQZIxVUEmMlVBuTJVQU0zVUHgM1VBczRVQQc1VUGaNVVBLjZVQcE2VUFUN1VB6DdVQXs4VUEOOVVBoTlVQTU6VUHIOlVBWztVQe47VUGBPFVBFT1VQag9VUE7PlVBzj5VQWE/VUH0P1VBh0BVQRtBVUGuQVVBQUJVQdRCVUFnQ1VB+kNVQY1EVUEgRVVBs0VVQUZGVUHZRlVBa0dVQf5HVUGRSFVBJElVQbdJVUFKSlVB3UpVQW9LVUECTFVBlUxVQShNVUG7TVVBTU5VQeBOVUFzT1VBBlBVQZhQVUErUVVBvlFVQVBSVUHjUlVBdlNVQQhUVUGbVFVBLVVVQcBVVUFSVlVB5VZVQXdXVUEKWFVBnFhVQS9ZVUHBWVVBVFpVQeZaVUF5W1VBC1xVQZ5cVUEwXVVBwl1VQVVeVUHnXlVBeV9VQQxgVUGeYFVBMGFVQcJhVUFVYlVB52JVQXljVUELZFVBnmRVQTBlVUHCZVVBVGZVQeZmVUF4Z1VBCmhVQZ1oVUEvaVVBwWlVQVNqVUHlalVBd2tVQQlsVUGbbFVBLW1VQb9tVUFRblVB425VQXVvVUEHcFVBmHBVQSpxVUG8cVVBTnJVQeByVUFyc1VBBHRVQZV0VUEndVVBuXVVQUt2VUHcdlVBbndVQQB4VUGSeFVBI3lVQbV5VUFHelVB2HpVQWp7VUH8e1VBjXxVQR99VUGwfVVBQn5VQdN+VUFlf1VB9n9VQYiAVUEZgVVBq4FVQTyCVUHOglVBX4NVQfGDVUGChFVBFIVVQaWFVUE2hlVByIZVQVmHVUHqh1VBfIhVQQ2JVUGeiVVBL4pVQcGKVUFSi1VB44tVQXSMVUEGjVVBl41VQSiOVUG5jlVBSo9VQduPVUFtkFVB/pBVQY+RVUEgklVBsZJVQUKTVUHTk1VBZJRVQfWUVUGGlVVBF5ZVQaiWVUE5l1VBypdVQVuYVUHsmFVBfZlVQQ2aVUGemlVBL5tVQcCbVUFRnFVB4pxVQXKdVUEDnlVBlJ5VQSWfVUG1n1VBRqBVQdegVUFooVVB+KFVQYmiVUEao1VBqqNVQTukVUHMpFVBXKVVQe2lVUF9plVBDqdVQZ6nVUEvqFVBv6hVQVCpVUHgqVVBcapVQQGrVUGSq1VBIqxVQbOsVUFDrVVB1K1VQWSuVUH0rlVBha9VQRWwVUGlsFVBNrFVQcaxVUFWslVB5rJVQXezVUEHtFVBl7RVQSe1VUG4tVVBSLZVQdi2VUFot1VB+LdVQYi4VUEZuVVBqblVQTm6VUHJulVBWbtVQem7VUF5vFVBCb1VQZm9VUEpvlVBub5VQUm/VUHZv1VBacBVQfnAVUGJwVVBGcJVQanCVUE4w1VByMNVQVjEVUHoxFVBeMVVQQjGVUGXxlVBJ8dVQbfHVUFHyFVB1shVQWbJVUH2yVVBhspVQRXLVUGly1VBNcxVQcTMVUFUzVVB481VQXPOVUEDz1VBks9VQSLQVUGx0FVBQdFVQdDRVUFg0lVB79JVQX/TVUEO1FVBntRVQS3VVUG91VVBTNZVQdvWVUFr11VB+tdVQYrYVUEZ2VVBqNlVQTjaVUHH2lVBVttVQeXbVUF13FVBBN1VQZPdVUEi3lVBst5VQUHfVUHQ31VBX+BVQe7gVUF94VVBDeJVQZziVUEr41VBuuNVQUnkVUHY5FVBZ+VVQfblVUGF5lVBFOdVQaPnVUEy6FVBwehVQVDpVUHf6VVBbupVQf3qVUGM61VBG+xVQansVUE47VVBx+1VQVbuVUHl7lVBdO9VQQLwVUGR8FVBIPFVQa/xVUE98lVBzPJVQVvzVUHp81VBePRVQQf1VUGV9VVBJPZVQbP2VUFB91VB0PdVQV/4VUHt+FVBfPlVQQr6VUGZ+lVBJ/tVQbb7VUFE/FVB0/xVQWH9VUHw/VVBfv5VQQ3/VUGb/1VBKQBWQbgAVkFGAVZB1AFWQWMCVkHxAlZBfwNWQQ4EVkGcBFZBKgVWQbkFVkFHBlZB1QZWQWMHVkHyB1ZBgAhWQQ4JVkGcCVZBKgpWQbgKVkFHC1ZB1QtWQWMMVkHxDFZBfw1WQQ0OVkGbDlZBKQ9WQbcPVkFFEFZB0xBWQWERVkHvEVZBfRJWQQsTVkGZE1ZBJxRWQbUUVkFDFVZB0BVWQV4WVkHsFlZBehdWQQgYVkGWGFZBIxlWQbEZVkE/GlZBzRpWQVsbVkHoG1ZBdhxWQQQdVkGRHVZBHx5WQa0eVkE6H1ZByB9WQVYgVkHjIFZBcSFWQf4hVkGMIlZBGiNWQacjVkE1JFZBwiRWQVAlVkHdJVZBayZWQfgmVkGGJ1ZBEyhWQaAoVkEuKVZBuylWQUkqVkHWKlZBYytWQfErVkF+LFZBCy1WQZktVkEmLlZBsy5WQUEvVkHOL1ZBWzBWQegwVkF1MVZBAzJWQZAyVkEdM1ZBqjNWQTc0VkHENFZBUjVWQd81VkFsNlZB+TZWQYY3VkETOFZBoDhWQS05VkG6OVZBRzpWQdQ6VkFhO1ZB7jtWQXs8VkEIPVZBlT1WQSI+VkGvPlZBPD9WQcg/VkFVQFZB4kBWQW9BVkH8QVZBiUJWQRVDVkGiQ1ZBL0RWQbxEVkFIRVZB1UVWQWJGVkHvRlZBe0dWQQhIVkGVSFZBIUlWQa5JVkE7SlZBx0pWQVRLVkHgS1ZBbUxWQfpMVkGGTVZBE05WQZ9OVkEsT1ZBuE9WQUVQVkHRUFZBXlFWQepRVkF2UlZBA1NWQY9TVkEcVFZBqFRWQTRVVkHBVVZBTVZWQdlWVkFmV1ZB8ldWQX5YVkELWVZBl1lWQSNaVkGvWlZBO1tWQchbVkFUXFZB4FxWQWxdVkH4XVZBhV5WQRFfVkGdX1ZBKWBWQbVgVkFBYVZBzWFWQVliVkHlYlZBcWNWQf1jVkGJZFZBFWVWQaFlVkEtZlZBuWZWQUVnVkHRZ1ZBXWhWQeloVkF1aVZBAWpWQYxqVkEYa1ZBpGtWQTBsVkG8bFZBSG1WQdNtVkFfblZB625WQXdvVkECcFZBjnBWQRpxVkGlcVZBMXJWQb1yVkFIc1ZB1HNWQWB0VkHrdFZBd3VWQQJ2VkGOdlZBGndWQaV3VkExeFZBvHhWQUh5VkHTeVZBX3pWQep6VkF2e1ZBAXxWQYx8VkEYfVZBo31WQS9+VkG6flZBRX9WQdF/VkFcgFZB54BWQXOBVkH+gVZBiYJWQRWDVkGgg1ZBK4RWQbaEVkFChVZBzYVWQViGVkHjhlZBbodWQfqHVkGFiFZBEIlWQZuJVkEmilZBsYpWQTyLVkHHi1ZBUoxWQd6MVkFpjVZB9I1WQX+OVkEKj1ZBlY9WQSCQVkGqkFZBNZFWQcCRVkFLklZB1pJWQWGTVkHsk1ZBd5RWQQKVVkGNlVZBF5ZWQaKWVkEtl1ZBuJdWQUOYVkHNmFZBWJlWQeOZVkFumlZB+JpWQYObVkEOnFZBmJxWQSOdVkGunVZBOJ5WQcOeVkFOn1ZB2J9WQWOgVkHtoFZBeKFWQQKiVkGNolZBGKNWQaKjVkEtpFZBt6RWQUGlVkHMpVZBVqZWQeGmVkFrp1ZB9qdWQYCoVkEKqVZBlalWQR+qVkGqqlZBNKtWQb6rVkFJrFZB06xWQV2tVkHnrVZBcq5WQfyuVkGGr1ZBELBWQZuwVkElsVZBr7FWQTmyVkHDslZBTbNWQdizVkFitFZB7LRWQXa1VkEAtlZBirZWQRS3VkGet1ZBKLhWQbK4VkE8uVZBxrlWQVC6VkHaulZBZLtWQe67VkF4vFZBAr1WQYy9VkEWvlZBoL5WQSm/VkGzv1ZBPcBWQcfAVkFRwVZB28FWQWTCVkHuwlZBeMNWQQLEVkGLxFZBFcVWQZ/FVkEpxlZBssZWQTzHVkHGx1ZBT8hWQdnIVkFjyVZB7MlWQXbKVkH/ylZBictWQRPMVkGczFZBJs1WQa/NVkE5zlZBws5WQUzPVkHVz1ZBX9BWQejQVkFy0VZB+9FWQYTSVkEO01ZBl9NWQSHUVkGq1FZBM9VWQb3VVkFG1lZBz9ZWQVnXVkHi11ZBa9hWQfTYVkF+2VZBB9pWQZDaVkEZ21ZBo9tWQSzcVkG13FZBPt1WQcfdVkFQ3lZB2t5WQWPfVkHs31ZBdeBWQf7gVkGH4VZBEOJWQZniVkEi41ZBq+NWQTTkVkG95FZBRuVWQc/lVkFY5lZB4eZWQWrnVkHz51ZBfOhWQQXpVkGO6VZBF+pWQZ/qVkEo61ZBsetWQTrsVkHD7FZBS+1WQdTtVkFd7lZB5u5WQW/vVkH371ZBgPBWQQnxVkGR8VZBGvJWQaPyVkEr81ZBtPNWQT30VkHF9FZBTvVWQdf1VkFf9lZB6PZWQXD3VkH591ZBgfhWQQr5VkGS+VZBG/pWQaP6VkEs+1ZBtPtWQT38VkHF/FZBTv1WQdb9VkFe/lZB5/5WQW//VkH4/1ZBgABXQQgBV0GRAVdBGQJXQaECV0EqA1dBsgNXQToEV0HCBFdBSwVXQdMFV0FbBldB4wZXQWsHV0H0B1dBfAhXQQQJV0GMCVdBFApXQZwKV0EkC1dBrQtXQTUMV0G9DFdBRQ1XQc0NV0FVDldB3Q5XQWUPV0HtD1dBdRBXQf0QV0GFEVdBDRJXQZUSV0EdE1dBpRNXQSwUV0G0FFdBPBVXQcQVV0FMFldB1BZXQVwXV0HjF1dBaxhXQfMYV0F7GVdBAxpXQYoaV0ESG1dBmhtXQSEcV0GpHFdBMR1XQbkdV0FAHldByB5XQVAfV0HXH1dBXyBXQeYgV0FuIVdB9iFXQX0iV0EFI1dBjCNXQRQkV0GbJFdBIyVXQaolV0EyJldBuSZXQUEnV0HIJ1dBUChXQdcoV0FeKVdB5ilXQW0qV0H1KldBfCtXQQMsV0GLLFdBEi1XQZktV0EhLldBqC5XQS8vV0G2L1dBPjBXQcUwV0FMMVdB0zFXQVsyV0HiMldBaTNXQfAzV0F3NFdB/zRXQYY1V0ENNldBlDZXQRs3V0GiN1dBKThXQbA4V0E3OVdBvjlXQUU6V0HMOldBUztXQdo7V0FhPFdB6DxXQW89V0H2PVdBfT5XQQQ/V0GLP1dBEkBXQZlAV0EgQVdBpkFXQS1CV0G0QldBO0NXQcJDV0FJRFdBz0RXQVZFV0HdRVdBZEZXQepGV0FxR1dB+EdXQX9IV0EFSVdBjElXQRNKV0GZSldBIEtXQaZLV0EtTFdBtExXQTpNV0HBTVdBR05XQc5OV0FVT1dB209XQWJQV0HoUFdBb1FXQfVRV0F8UldBAlNXQYhTV0EPVFdBlVRXQRxVV0GiVVdBKVZXQa9WV0E1V1dBvFdXQUJYV0HIWFdBT1lXQdVZV0FbWldB4lpXQWhbV0HuW1dBdFxXQftcV0GBXVdBB15XQY1eV0ETX1dBml9XQSBgV0GmYFdBLGFXQbJhV0E4YldBvmJXQURjV0HLY1dBUWRXQddkV0FdZVdB42VXQWlmV0HvZldBdWdXQftnV0GBaFdBB2lXQY1pV0ETaldBmWpXQR5rV0Gka1dBKmxXQbBsV0E2bVdBvG1XQUJuV0HIbldBTW9XQdNvV0FZcFdB33BXQWVxV0HqcVdBcHJXQfZyV0F7c1dBAXRXQYd0V0ENdVdBknVXQRh2V0GedldBI3dXQal3V0EueFdBtHhXQTp5V0G/eVdBRXpXQcp6V0FQe1dB1XtXQVt8V0HhfFdBZn1XQex9V0FxfldB9n5XQXx/V0EBgFdBh4BXQQyBV0GSgVdBF4JXQZyCV0Eig1dBp4NXQSyEV0GyhFdBN4VXQbyFV0FChldBx4ZXQUyHV0HSh1dBV4hXQdyIV0FhiVdB54lXQWyKV0HxildBdotXQfuLV0GAjFdBBo1XQYuNV0EQjldBlY5XQRqPV0Gfj1dBJJBXQamQV0EukVdBs5FXQTiSV0G9kldBQpNXQceTV0FMlFdB0ZRXQVaVV0HblVdBYJZXQeWWV0Fql1dB75dXQXSYV0H5mFdBfplXQQOaV0GHmldBDJtXQZGbV0EWnFdBm5xXQR+dV0GknVdBKZ5XQa6eV0Eyn1dBt59XQTygV0HBoFdBRaFXQcqhV0FPoldB06JXQVijV0Hdo1dBYaRXQeakV0FqpVdB76VXQXSmV0H4pldBfadXQQGoV0GGqFdBCqlXQY+pV0ETqldBmKpXQRyrV0Ghq1dBJaxXQaqsV0EurVdBsq1XQTeuV0G7rldBQK9XQcSvV0FIsFdBzbBXQVGxV0HVsVdBWrJXQd6yV0Fis1dB57NXQWu0V0HvtFdBc7VXQfi1V0F8tldBALdXQYS3V0EIuFdBjbhXQRG5V0GVuVdBGbpXQZ26V0Ehu1dBpbtXQSm8V0GtvFdBMr1XQba9V0E6vldBvr5XQUK/V0HGv1dBSsBXQc7AV0FSwVdB1sFXQVrCV0HewldBYcNXQeXDV0FpxFdB7cRXQXHFV0H1xVdBecZXQf3GV0GBx1dBBMhXQYjIV0EMyVdBkMlXQRTKV0GXyldBG8tXQZ/LV0EjzFdBpsxXQSrNV0GuzVdBMc5XQbXOV0E5z1dBvM9XQUDQV0HE0FdBR9FXQcvRV0FO0ldB0tJXQVbTV0HZ01dBXdRXQeDUV0Fk1VdB59VXQWvWV0Hu1ldBctdXQfXXV0F52FdB/NhXQYDZV0ED2ldBhtpXQQrbV0GN21dBEdxXQZTcV0EX3VdBm91XQR7eV0Gh3ldBJd9XQajfV0Er4FdBr+BXQTLhV0G14VdBOOJXQbziV0E/41dBwuNXQUXkV0HI5FdBTOVXQc/lV0FS5ldB1eZXQVjnV0Hb51dBXuhXQeHoV0Fl6VdB6OlXQWvqV0Hu6ldBcetXQfTrV0F37FdB+uxXQX3tV0EA7ldBg+5XQQbvV0GJ71dBDPBXQY7wV0ER8VdBlPFXQRfyV0Ga8ldBHfNXQaDzV0Ej9FdBpfRXQSj1V0Gr9VdBLvZXQbH2V0Ez91dBtvdXQTn4V0G8+FdBPvlXQcH5V0FE+ldBx/pXQUn7V0HM+1dBT/xXQdH8V0FU/VdB1/1XQVn+V0Hc/ldBXv9XQeH/V0FkAFhB5gBYQWkBWEHrAVhBbgJYQfACWEFzA1hB9QNYQXgEWEH6BFhBfQVYQf8FWEGCBlhBBAdYQYYHWEEJCFhBiwhYQQ4JWEGQCVhBEgpYQZUKWEEXC1hBmQtYQRwMWEGeDFhBIA1YQaMNWEElDlhBpw5YQSkPWEGsD1hBLhBYQbAQWEEyEVhBtBFYQTcSWEG5ElhBOxNYQb0TWEE/FFhBwRRYQUMVWEHGFVhBSBZYQcoWWEFMF1hBzhdYQVAYWEHSGFhBVBlYQdYZWEFYGlhB2hpYQVwbWEHeG1hBYBxYQeIcWEFkHVhB5h1YQWgeWEHqHlhBax9YQe0fWEFvIFhB8SBYQXMhWEH1IVhBdyJYQfgiWEF6I1hB/CNYQX4kWEH/JFhBgSVYQQMmWEGFJlhBBidYQYgnWEEKKFhBjChYQQ0pWEGPKVhBESpYQZIqWEEUK1hBlStYQRcsWEGZLFhBGi1YQZwtWEEdLlhBny5YQSAvWEGiL1hBJDBYQaUwWEEnMVhBqDFYQSoyWEGrMlhBLDNYQa4zWEEvNFhBsTRYQTI1WEG0NVhBNTZYQbY2WEE4N1hBuTdYQTo4WEG8OFhBPTlYQb45WEFAOlhBwTpYQUI7WEHEO1hBRTxYQcY8WEFHPVhByT1YQUo+WEHLPlhBTD9YQc0/WEFOQFhB0EBYQVFBWEHSQVhBU0JYQdRCWEFVQ1hB1kNYQVdEWEHZRFhBWkVYQdtFWEFcRlhB3UZYQV5HWEHfR1hBYEhYQeFIWEFiSVhB40lYQWRKWEHlSlhBZUtYQeZLWEFnTFhB6ExYQWlNWEHqTVhBa05YQexOWEFsT1hB7U9YQW5QWEHvUFhBcFFYQfBRWEFxUlhB8lJYQXNTWEH0U1hBdFRYQfVUWEF2VVhB9lVYQXdWWEH4VlhBeFdYQflXWEF6WFhB+lhYQXtZWEH8WVhBfFpYQf1aWEF9W1hB/ltYQX5cWEH/XFhBgF1YQQBeWEGBXlhBAV9YQYJfWEECYFhBg2BYQQNhWEGDYVhBBGJYQYRiWEEFY1hBhWNYQQVkWEGGZFhBBmVYQYdlWEEHZlhBh2ZYQQhnWEGIZ1hBCGhYQYloWEEJaVhBiWlYQQlqWEGKalhBCmtYQYprWEEKbFhBimxYQQttWEGLbVhBC25YQYtuWEELb1hBi29YQQxwWEGMcFhBDHFYQYxxWEEMclhBjHJYQQxzWEGMc1hBDHRYQYx0WEEMdVhBjHVYQQx2WEGMdlhBDHdYQYx3WEEMeFhBjHhYQQx5WEGMeVhBDHpYQYx6WEEMe1hBjHtYQQt8WEGLfFhBC31YQYt9WEELflhBi35YQQp/WEGKf1hBCoBYQYqAWEEKgVhBiYFYQQmCWEGJglhBCYNYQYiDWEEIhFhBiIRYQQeFWEGHhVhBB4ZYQYaGWEEGh1hBhodYQQWIWEGFiFhBBIlYQYSJWEEDilhBg4pYQQOLWEGCi1hBAoxYQYGMWEEBjVhBgI1YQQCOWEF/jlhB/45YQX6PWEH9j1hBfZBYQfyQWEF8kVhB+5FYQXuSWEH6klhBeZNYQfmTWEF4lFhB95RYQXeVWEH2lVhBdZZYQfWWWEF0l1hB85dYQXKYWEHymFhBcZlYQfCZWEFvmlhB7ppYQW6bWEHtm1hBbJxYQeucWEFqnVhB6Z1YQWmeWEHonlhBZ59YQeafWEFloFhB5KBYQWOhWEHioVhBYaJYQeCiWEFfo1hB3qNYQV2kWEHcpFhBW6VYQdqlWEFZplhB2KZYQVenWEHWp1hBVahYQdSoWEFTqVhB0qlYQVCqWEHPqlhBTqtYQc2rWEFMrFhBy6xYQUmtWEHIrVhBR65YQcauWEFFr1hBw69YQUKwWEHBsFhBQLFYQb6xWEE9slhBvLJYQTqzWEG5s1hBOLRYQba0WEE1tVhBtLVYQTK2WEGxtlhBL7dYQa63WEEtuFhBq7hYQSq5WEGouVhBJ7pYQaW6WEEku1hBortYQSG8WEGfvFhBHr1YQZy9WEEbvlhBmb5YQRi/WEGWv1hBFMBYQZPAWEERwVhBkMFYQQ7CWEGMwlhBC8NYQYnDWEEHxFhBhsRYQQTFWEGCxVhBAMZYQX/GWEH9xlhBe8dYQfnHWEF4yFhB9shYQXTJWEHyyVhBccpYQe/KWEFty1hB68tYQWnMWEHnzFhBZc1YQeTNWEFizlhB4M5YQV7PWEHcz1hBWtBYQdjQWEFW0VhB1NFYQVLSWEHQ0lhBTtNYQczTWEFK1FhByNRYQUbVWEHE1VhBQtZYQcDWWEE+11hBvNdYQTnYWEG32FhBNdlYQbPZWEEx2lhBr9pYQS3bWEGq21hBKNxYQabcWEEk3VhBot1YQR/eWEGd3lhBG99YQZnfWEEW4FhBlOBYQRLhWEGP4VhBDeJYQYviWEEI41hBhuNYQQTkWEGB5FhB/+RYQX3lWEH65VhBeOZYQfXmWEFz51hB8OdYQW7oWEHs6FhBaelYQefpWEFk6lhB4upYQV/rWEHd61hBWuxYQdfsWEFV7VhB0u1YQVDuWEHN7lhBS+9YQcjvWEFF8FhBw/BYQUDxWEG98VhBO/JYQbjyWEE181hBs/NYQTD0WEGt9FhBK/VYQaj1WEEl9lhBovZYQSD3WEGd91hBGvhYQZf4WEEU+VhBkvlYQQ/6WEGM+lhBCftYQYb7WEED/FhBgPxYQf78WEF7/VhB+P1YQXX+WEHy/lhBb/9YQez/WEFpAFlB5gBZQWMBWUHgAVlBXQJZQdoCWUFXA1lB1ANZQVEEWUHOBFlBSwVZQcgFWUFFBllBwgZZQT8HWUG7B1lBOAhZQbUIWUEyCVlBrwlZQSwKWUGoCllBJQtZQaILWUEfDFlBnAxZQRgNWUGVDVlBEg5ZQY8OWUELD1lBiA9ZQQUQWUGCEFlB/hBZQXsRWUH4EVlBdBJZQfESWUFuE1lB6hNZQWcUWUHjFFlBYBVZQd0VWUFZFllB1hZZQVIXWUHPF1lBSxhZQcgYWUFEGVlBwRlZQT0aWUG6GllBNhtZQbMbWUEvHFlBrBxZQSgdWUGlHVlBIR5ZQZ0eWUEaH1lBlh9ZQRIgWUGPIFlBCyFZQYghWUEEIllBgCJZQfwiWUF5I1lB9SNZQXEkWUHuJFlBaiVZQeYlWUFiJllB3yZZQVsnWUHXJ1lBUyhZQc8oWUFMKVlByClZQUQqWUHAKllBPCtZQbgrWUE0LFlBsCxZQS0tWUGpLVlBJS5ZQaEuWUEdL1lBmS9ZQRUwWUGRMFlBDTFZQYkxWUEFMllBgTJZQf0yWUF5M1lB9TNZQXE0WUHtNFlBaTVZQeU1WUFgNllB3DZZQVg3WUHUN1lBUDhZQcw4WUFIOVlBwzlZQT86WUG7OllBNztZQbM7WUEuPFlBqjxZQSY9WUGiPVlBHT5ZQZk+WUEVP1lBkT9ZQQxAWUGIQFlBBEFZQX9BWUH7QVlBd0JZQfJCWUFuQ1lB6kNZQWVEWUHhRFlBXEVZQdhFWUFURllBz0ZZQUtHWUHGR1lBQkhZQb1IWUE5SVlBtElZQTBKWUGrSllBJ0tZQaJLWUEeTFlBmUxZQRRNWUGQTVlBC05ZQYdOWUECT1lBfU9ZQflPWUF0UFlB71BZQWtRWUHmUVlBYVJZQd1SWUFYU1lB01NZQU9UWUHKVFlBRVVZQcBVWUE8VllBt1ZZQTJXWUGtV1lBKFhZQaRYWUEfWVlBmllZQRVaWUGQWllBC1tZQYdbWUECXFlBfVxZQfhcWUFzXVlB7l1ZQWleWUHkXllBX19ZQdpfWUFVYFlB0GBZQUthWUHGYVlBQWJZQbxiWUE3Y1lBsmNZQS1kWUGoZFlBI2VZQZ5lWUEZZllBlGZZQQ9nWUGJZ1lBBGhZQX9oWUH6aFlBdWlZQfBpWUFqallB5WpZQWBrWUHba1lBVmxZQdBsWUFLbVlBxm1ZQUFuWUG7bllBNm9ZQbFvWUErcFlBpnBZQSFxWUGbcVlBFnJZQZFyWUELc1lBhnNZQQF0WUF7dFlB9nRZQXB1WUHrdVlBZnZZQeB2WUFbd1lB1XdZQVB4WUHKeFlBRXlZQb95WUE6ellBtHpZQS97WUGpe1lBJHxZQZ58WUEYfVlBk31ZQQ1+WUGIfllBAn9ZQXx/WUH3f1lBcYBZQeyAWUFmgVlB4IFZQVuCWUHVgllBT4NZQcmDWUFEhFlBvoRZQTiFWUGyhVlBLYZZQaeGWUEhh1lBm4dZQRaIWUGQiFlBColZQYSJWUH+iVlBeIpZQfOKWUFti1lB54tZQWGMWUHbjFlBVY1ZQc+NWUFJjllBw45ZQT2PWUG3j1lBMZBZQauQWUElkVlBn5FZQRmSWUGTkllBDZNZQYeTWUEBlFlBe5RZQfWUWUFvlVlB6ZVZQWOWWUHdlllBV5dZQdGXWUFLmFlBxJhZQT6ZWUG4mVlBMppZQayaWUElm1lBn5tZQRmcWUGTnFlBDZ1ZQYadWUEAnllBep5ZQfSeWUFtn1lB559ZQWGgWUHaoFlBVKFZQc6hWUFHollBwaJZQTujWUG0o1lBLqRZQaikWUEhpVlBm6VZQRSmWUGOpllBB6dZQYGnWUH7p1lBdKhZQe6oWUFnqVlB4alZQVqqWUHUqllBTatZQcerWUFArFlBuaxZQTOtWUGsrVlBJq5ZQZ+uWUEZr1lBkq9ZQQuwWUGFsFlB/rBZQXexWUHxsVlBarJZQeOyWUFds1lB1rNZQU+0WUHJtFlBQrVZQbu1WUE0tllBrrZZQSe3WUGgt1lBGbhZQZK4WUEMuVlBhblZQf65WUF3ullB8LpZQWm7WUHju1lBXLxZQdW8WUFOvVlBx71ZQUC+WUG5vllBMr9ZQau/WUEkwFlBncBZQRbBWUGPwVlBCMJZQYHCWUH6wllBc8NZQezDWUFlxFlB3sRZQVfFWUHQxVlBScZZQcLGWUE7x1lBtMdZQS3IWUGlyFlBHslZQZfJWUEQyllBicpZQQLLWUF7y1lB88tZQWzMWUHlzFlBXs1ZQdbNWUFPzllByM5ZQUHPWUG5z1lBMtBZQavQWUEk0VlBnNFZQRXSWUGO0llBBtNZQX/TWUH401lBcNRZQenUWUFh1VlB2tVZQVPWWUHL1llBRNdZQbzXWUE12FlBrdhZQSbZWUGe2VlBF9pZQY/aWUEI21lBgNtZQfnbWUFx3FlB6txZQWLdWUHb3VlBU95ZQczeWUFE31lBvN9ZQTXgWUGt4FlBJuFZQZ7hWUEW4llBj+JZQQfjWUF/41lB+ONZQXDkWUHo5FlBYOVZQdnlWUFR5llByeZZQULnWUG651lBMuhZQaroWUEi6VlBm+lZQRPqWUGL6llBA+tZQXvrWUHz61lBbOxZQeTsWUFc7VlB1O1ZQUzuWUHE7llBPO9ZQbTvWUEs8FlBpPBZQR3xWUGV8VlBDfJZQYXyWUH98llBdfNZQe3zWUFl9FlB3fRZQVX1WUHM9VlBRPZZQbz2WUE091lBrPdZQST4WUGc+FlBFPlZQYz5WUEE+llBe/pZQfP6WUFr+1lB4/tZQVv8WUHT/FlBSv1ZQcL9WUE6/llBsv5ZQSr/WUGh/1lBGQBaQZEAWkEIAVpBgAFaQfgBWkFwAlpB5wJaQV8DWkHXA1pBTgRaQcYEWkE+BVpBtQVaQS0GWkGkBlpBHAdaQZQHWkELCFpBgwhaQfoIWkFyCVpB6QlaQWEKWkHYClpBUAtaQcgLWkE/DFpBtwxaQS4NWkGlDVpBHQ5aQZQOWkEMD1pBgw9aQfsPWkFyEFpB6RBaQWERWkHYEVpBUBJaQccSWkE+E1pBthNaQS0UWkGkFFpBHBVaQZMVWkEKFlpBghZaQfkWWkFwF1pB5xdaQV8YWkHWGFpBTRlaQcQZWkE8GlpBsxpaQSobWkGhG1pBGBxaQY8cWkEHHVpBfh1aQfUdWkFsHlpB4x5aQVofWkHRH1pBSCBaQcAgWkE3IVpBriFaQSUiWkGcIlpBEyNaQYojWkEBJFpBeCRaQe8kWkFmJVpB3SVaQVQmWkHLJlpBQidaQbknWkEwKFpBpyhaQR0pWkGUKVpBCypaQYIqWkH5KlpBcCtaQecrWkFeLFpB1CxaQUstWkHCLVpBOS5aQbAuWkEnL1pBnS9aQRQwWkGLMFpBAjFaQXgxWkHvMVpBZjJaQd0yWkFTM1pByjNaQUE0WkG3NFpBLjVaQaU1WkEbNlpBkjZaQQk3WkF/N1pB9jdaQWw4WkHjOFpBWjlaQdA5WkFHOlpBvTpaQTQ7WkGqO1pBITxaQZc8WkEOPVpBhD1aQfs9WkFxPlpB6D5aQV4/WkHVP1pBS0BaQcJAWkE4QVpBr0FaQSVCWkGbQlpBEkNaQYhDWkH/Q1pBdURaQetEWkFiRVpB2EVaQU5GWkHFRlpBO0daQbFHWkEoSFpBnkhaQRRJWkGKSVpBAUpaQXdKWkHtSlpBY0taQdpLWkFQTFpBxkxaQTxNWkGyTVpBKU5aQZ9OWkEVT1pBi09aQQFQWkF3UFpB7VBaQWNRWkHaUVpBUFJaQcZSWkE8U1pBslNaQShUWkGeVFpBFFVaQYpVWkEAVlpBdlZaQexWWkFiV1pB2FdaQU5YWkHEWFpBOllaQbBZWkEmWlpBnFpaQRJbWkGHW1pB/VtaQXNcWkHpXFpBX11aQdVdWkFLXlpBwV5aQTZfWkGsX1pBImBaQZhgWkEOYVpBg2FaQflhWkFvYlpB5WJaQVpjWkHQY1pBRmRaQbxkWkExZVpBp2VaQR1mWkGSZlpBCGdaQX5nWkHzZ1pBaWhaQd9oWkFUaVpBymlaQUBqWkG1alpBK2taQaBrWkEWbFpBi2xaQQFtWkF3bVpB7G1aQWJuWkHXblpBTW9aQcJvWkE4cFpBrXBaQSNxWkGYcVpBDnJaQYNyWkH4clpBbnNaQeNzWkFZdFpBznRaQUR1WkG5dVpBLnZaQaR2WkEZd1pBjndaQQR4WkF5eFpB7nhaQWR5WkHZeVpBTnpaQcR6WkE5e1pBrntaQSN8WkGZfFpBDn1aQYN9WkH4fVpBbX5aQeN+WkFYf1pBzX9aQUKAWkG3gFpBLYFaQaKBWkEXglpBjIJaQQGDWkF2g1pB64NaQWCEWkHVhFpBS4VaQcCFWkE1hlpBqoZaQR+HWkGUh1pBCYhaQX6IWkHziFpBaIlaQd2JWkFSilpBx4paQTyLWkGxi1pBJoxaQZqMWkEPjVpBhI1aQfmNWkFujlpB445aQViPWkHNj1pBQpBaQbaQWkErkVpBoJFaQRWSWkGKklpB/5JaQXOTWkHok1pBXZRaQdKUWkFGlVpBu5VaQTCWWkGlllpBGZdaQY6XWkEDmFpBd5haQeyYWkFhmVpB1ZlaQUqaWkG/mlpBM5taQaibWkEdnFpBkZxaQQadWkF7nVpB751aQWSeWkHYnlpBTZ9aQcGfWkE2oFpBqqBaQR+hWkGToVpBCKJaQXyiWkHxolpBZaNaQdqjWkFOpFpBw6RaQTelWkGspVpBIKZaQZWmWkEJp1pBfadaQfKnWkFmqFpB2qhaQU+pWkHDqVpBOKpaQayqWkEgq1pBlataQQmsWkF9rFpB8axaQWatWkHarVpBTq5aQcOuWkE3r1pBq69aQR+wWkGTsFpBCLFaQXyxWkHwsVpBZLJaQdiyWkFNs1pBwbNaQTW0WkGptFpBHbVaQZG1WkEFtlpBebZaQe62WkFit1pB1rdaQUq4WkG+uFpBMrlaQaa5WkEaulpBjrpaQQK7WkF2u1pB6rtaQV68WkHSvFpBRr1aQbq9WkEuvlpBor5aQRa/WkGKv1pB/r9aQXLAWkHlwFpBWcFaQc3BWkFBwlpBtcJaQSnDWkGdw1pBEMRaQYTEWkH4xFpBbMVaQeDFWkFUxlpBx8ZaQTvHWkGvx1pBI8haQZbIWkEKyVpBfslaQfLJWkFlylpB2cpaQU3LWkHAy1pBNMxaQajMWkEbzVpBj81aQQPOWkF2zlpB6s5aQV7PWkHRz1pBRdBaQbjQWkEs0VpBn9FaQRPSWkGH0lpB+tJaQW7TWkHh01pBVdRaQcjUWkE81VpBr9VaQSPWWkGW1lpBCtdaQX3XWkHx11pBZNhaQdfYWkFL2VpBvtlaQTLaWkGl2lpBGNtaQYzbWkH/21pBc9xaQebcWkFZ3VpBzd1aQUDeWkGz3lpBJ99aQZrfWkEN4FpBgOBaQfTgWkFn4VpB2uFaQU3iWkHB4lpBNONaQafjWkEa5FpBjuRaQQHlWkF05VpB5+VaQVrmWkHN5lpBQedaQbTnWkEn6FpBmuhaQQ3pWkGA6VpB8+laQWbqWkHZ6lpBTetaQcDrWkEz7FpBpuxaQRntWkGM7VpB/+1aQXLuWkHl7lpBWO9aQcvvWkE+8FpBsfBaQSTxWkGX8VpBCvJaQXzyWkHv8lpBYvNaQdXzWkFI9FpBu/RaQS71WkGh9VpBFPZaQYb2WkH59lpBbPdaQd/3WkFS+FpBxfhaQTf5WkGq+VpBHfpaQZD6WkEC+1pBdftaQej7WkFb/FpBzfxaQUD9WkGz/VpBJv5aQZj+WkEL/1pBfv9aQfD/WkFjAFtB1gBbQUgBW0G7AVtBLgJbQaACW0ETA1tBhQNbQfgDW0FrBFtB3QRbQVAFW0HCBVtBNQZbQacGW0EaB1tBjAdbQf8HW0FxCFtB5AhbQVYJW0HJCVtBOwpbQa4KW0EgC1tBkwtbQQUMW0F4DFtB6gxbQVwNW0HPDVtBQQ5bQbQOW0EmD1tBmA9bQQsQW0F9EFtB7xBbQWIRW0HUEVtBRhJbQbkSW0ErE1tBnRNbQQ8UW0GCFFtB9BRbQWYVW0HYFVtBSxZbQb0WW0EvF1tBoRdbQRQYW0GGGFtB+BhbQWoZW0HcGVtBThpbQcEaW0EzG1tBpRtbQRccW0GJHFtB+xxbQW0dW0HfHVtBUh5bQcQeW0E2H1tBqB9bQRogW0GMIFtB/iBbQXAhW0HiIVtBVCJbQcYiW0E4I1tBqiNbQRwkW0GOJFtBACVbQXIlW0HkJVtBViZbQccmW0E5J1tBqydbQR0oW0GPKFtBASlbQXMpW0HlKVtBVipbQcgqW0E6K1tBrCtbQR4sW0GQLFtBAS1bQXMtW0HlLVtBVy5bQcguW0E6L1tBrC9bQR4wW0GPMFtBATFbQXMxW0HlMVtBVjJbQcgyW0E6M1tBqzNbQR00W0GPNFtBADVbQXI1W0HkNVtBVTZbQcc2W0E4N1tBqjdbQRw4W0GNOFtB/zhbQXA5W0HiOVtBUzpbQcU6W0E2O1tBqDtbQRk8W0GLPFtB/DxbQW49W0HfPVtBUT5bQcI+W0E0P1tBpT9bQRdAW0GIQFtB+UBbQWtBW0HcQVtBTkJbQb9CW0EwQ1tBokNbQRNEW0GERFtB9kRbQWdFW0HYRVtBSkZbQbtGW0EsR1tBnkdbQQ9IW0GASFtB8UhbQWNJW0HUSVtBRUpbQbZKW0EoS1tBmUtbQQpMW0F7TFtB7ExbQV5NW0HPTVtBQE5bQbFOW0EiT1tBk09bQQRQW0F2UFtB51BbQVhRW0HJUVtBOlJbQatSW0EcU1tBjVNbQf5TW0FvVFtB4FRbQVFVW0HCVVtBM1ZbQaRWW0EVV1tBhldbQfdXW0FoWFtB2VhbQUpZW0G7WVtBLFpbQZ1aW0EOW1tBf1tbQfBbW0FhXFtB0VxbQUJdW0GzXVtBJF5bQZVeW0EGX1tBd19bQedfW0FYYFtByWBbQTphW0GrYVtBG2JbQYxiW0H9YltBbmNbQd5jW0FPZFtBwGRbQTFlW0GhZVtBEmZbQYNmW0HzZltBZGdbQdVnW0FFaFtBtmhbQSdpW0GXaVtBCGpbQXlqW0HpaltBWmtbQcprW0E7bFtBrGxbQRxtW0GNbVtB/W1bQW5uW0HebltBT29bQb9vW0EwcFtBoHBbQRFxW0GBcVtB8nFbQWJyW0HTcltBQ3NbQbRzW0EkdFtBlXRbQQV1W0F1dVtB5nVbQVZ2W0HHdltBN3dbQad3W0EYeFtBiHhbQfh4W0FpeVtB2XlbQUl6W0G6eltBKntbQZp7W0ELfFtBe3xbQet8W0FbfVtBzH1bQTx+W0GsfltBHH9bQY1/W0H9f1tBbYBbQd2AW0FNgVtBvoFbQS6CW0GegltBDoNbQX6DW0Hug1tBXoRbQc+EW0E/hVtBr4VbQR+GW0GPhltB/4ZbQW+HW0Hfh1tBT4hbQb+IW0EviVtBn4lbQQ+KW0F/iltB74pbQV+LW0HPi1tBP4xbQa+MW0EfjVtBj41bQf+NW0FvjltB345bQU+PW0G/j1tBL5BbQZ+QW0EPkVtBfpFbQe6RW0FekltBzpJbQT6TW0Guk1tBHZRbQY2UW0H9lFtBbZVbQd2VW0FNlltBvJZbQSyXW0Gcl1tBDJhbQXuYW0HrmFtBW5lbQcuZW0E6mltBqppbQRqbW0GJm1tB+ZtbQWmcW0HYnFtBSJ1bQbidW0EnnltBl55bQQefW0F2n1tB5p9bQVWgW0HFoFtBNaFbQaShW0EUoltBg6JbQfOiW0Fio1tB0qNbQUGkW0GxpFtBIKVbQZClW0H/pVtBb6ZbQd6mW0FOp1tBvadbQS2oW0GcqFtBDKlbQXupW0HqqVtBWqpbQcmqW0E5q1tBqKtbQResW0GHrFtB9qxbQWatW0HVrVtBRK5bQbSuW0Ejr1tBkq9bQQGwW0FxsFtB4LBbQU+xW0G/sVtBLrJbQZ2yW0EMs1tBfLNbQeuzW0FatFtBybRbQTi1W0GotVtBF7ZbQYa2W0H1tltBZLdbQdS3W0FDuFtBsrhbQSG5W0GQuVtB/7lbQW66W0HdultBTLtbQby7W0ErvFtBmrxbQQm9W0F4vVtB571bQVa+W0HFvltBNL9bQaO/W0ESwFtBgcBbQfDAW0FfwVtBzsFbQT3CW0GswltBG8NbQYrDW0H5w1tBZ8RbQdbEW0FFxVtBtMVbQSPGW0GSxltBAcdbQXDHW0Hfx1tBTchbQbzIW0EryVtBmslbQQnKW0F4yltB5spbQVXLW0HEy1tBM8xbQaHMW0EQzVtBf81bQe7NW0FczltBy85bQTrPW0Gpz1tBF9BbQYbQW0H10FtBY9FbQdLRW0FB0ltBr9JbQR7TW0GN01tB+9NbQWrUW0HY1FtBR9VbQbbVW0Ek1ltBk9ZbQQHXW0Fw11tB3tdbQU3YW0G82FtBKtlbQZnZW0EH2ltBdtpbQeTaW0FT21tBwdtbQTDcW0Ge3FtBDN1bQXvdW0Hp3VtBWN5bQcbeW0E131tBo99bQRHgW0GA4FtB7uBbQV3hW0HL4VtBOeJbQajiW0EW41tBhONbQfPjW0Fh5FtBz+RbQT7lW0Gs5VtBGuZbQYnmW0H35ltBZedbQdPnW0FC6FtBsOhbQR7pW0GM6VtB+ulbQWnqW0HX6ltBRetbQbPrW0Eh7FtBkOxbQf7sW0Fs7VtB2u1bQUjuW0G27ltBJO9bQZPvW0EB8FtBb/BbQd3wW0FL8VtBufFbQSfyW0GV8ltBA/NbQXHzW0Hf81tBTfRbQbv0W0Ep9VtBl/VbQQX2W0Fz9ltB4fZbQU/3W0G991tBK/hbQZn4W0EH+VtBdflbQeP5W0FR+ltBv/pbQS37W0Ga+1tBCPxbQXb8W0Hk/FtBUv1bQcD9W0Eu/ltBm/5bQQn/W0F3/1tB5f9bQVMAXEHAAFxBLgFcQZwBXEEKAlxBeAJcQeUCXEFTA1xBwQNcQS8EXEGcBFxBCgVcQXgFXEHlBVxBUwZcQcEGXEEuB1xBnAdcQQoIXEF3CFxB5QhcQVMJXEHACVxBLgpcQZwKXEEJC1xBdwtcQeQLXEFSDFxBvwxcQS0NXEGbDVxBCA5cQXYOXEHjDlxBUQ9cQb4PXEEsEFxBmRBcQQcRXEF0EVxB4hFcQU8SXEG9ElxBKhNcQZcTXEEFFFxBchRcQeAUXEFNFVxBuxVcQSgWXEGVFlxBAxdcQXAXXEHdF1xBSxhcQbgYXEEmGVxBkxlcQQAaXEFtGlxB2xpcQUgbXEG1G1xBIxxcQZAcXEH9HFxBah1cQdgdXEFFHlxBsh5cQR8fXEGNH1xB+h9cQWcgXEHUIFxBQSFcQa8hXEEcIlxBiSJcQfYiXEFjI1xB0CNcQT4kXEGrJFxBGCVcQYUlXEHyJVxBXyZcQcwmXEE5J1xBpidcQRMoXEGBKFxB7ihcQVspXEHIKVxBNSpcQaIqXEEPK1xBfCtcQekrXEFWLFxBwyxcQTAtXEGdLVxBCi5cQXYuXEHjLlxBUC9cQb0vXEEqMFxBlzBcQQQxXEFxMVxB3jFcQUsyXEG4MlxBJDNcQZEzXEH+M1xBazRcQdg0XEFFNVxBsTVcQR42XEGLNlxB+DZcQWU3XEHRN1xBPjhcQas4XEEYOVxBhDlcQfE5XEFeOlxByzpcQTc7XEGkO1xBETxcQX08XEHqPFxBVz1cQcM9XEEwPlxBnT5cQQk/XEF2P1xB4z9cQU9AXEG8QFxBKEFcQZVBXEECQlxBbkJcQdtCXEFHQ1xBtENcQSBEXEGNRFxB+URcQWZFXEHSRVxBP0ZcQatGXEEYR1xBhEdcQfFHXEFdSFxBykhcQTZJXEGjSVxBD0pcQXxKXEHoSlxBVEtcQcFLXEEtTFxBmkxcQQZNXEFyTVxB301cQUtOXEG4TlxBJE9cQZBPXEH9T1xBaVBcQdVQXEFBUVxBrlFcQRpSXEGGUlxB81JcQV9TXEHLU1xBN1RcQaRUXEEQVVxBfFVcQehVXEFVVlxBwVZcQS1XXEGZV1xBBVhcQXJYXEHeWFxBSllcQbZZXEEiWlxBjlpcQfpaXEFnW1xB01tcQT9cXEGrXFxBF11cQYNdXEHvXVxBW15cQcdeXEEzX1xBn19cQQtgXEF3YFxB42BcQU9hXEG7YVxBJ2JcQZNiXEH/YlxBa2NcQddjXEFDZFxBr2RcQRtlXEGHZVxB82VcQV9mXEHLZlxBN2dcQaNnXEEPaFxBemhcQeZoXEFSaVxBvmlcQSpqXEGWalxBAmtcQW1rXEHZa1xBRWxcQbFsXEEdbVxBiG1cQfRtXEFgblxBzG5cQThvXEGjb1xBD3BcQXtwXEHmcFxBUnFcQb5xXEEqclxBlXJcQQFzXEFtc1xB2HNcQUR0XEGwdFxBG3VcQYd1XEHzdVxBXnZcQcp2XEE1d1xBoXdcQQ14XEF4eFxB5HhcQU95XEG7eVxBJ3pcQZJ6XEH+elxBaXtcQdV7XEFAfFxBrHxcQRd9XEGDfVxB7n1cQVp+XEHFflxBMX9cQZx/XEEIgFxBc4BcQd6AXEFKgVxBtYFcQSGCXEGMglxB+IJcQWODXEHOg1xBOoRcQaWEXEEQhVxBfIVcQeeFXEFShlxBvoZcQSmHXEGUh1xBAIhcQWuIXEHWiFxBQolcQa2JXEEYilxBg4pcQe+KXEFai1xBxYtcQTCMXEGcjFxBB41cQXKNXEHdjVxBSI5cQbSOXEEfj1xBio9cQfWPXEFgkFxBy5BcQTeRXEGikVxBDZJcQXiSXEHjklxBTpNcQbmTXEEklFxBj5RcQfuUXEFmlVxB0ZVcQTyWXEGnllxBEpdcQX2XXEHol1xBU5hcQb6YXEEpmVxBlJlcQf+ZXEFqmlxB1ZpcQUCbXEGrm1xBFpxcQYGcXEHrnFxBVp1cQcGdXEEsnlxBl55cQQKfXEFtn1xB2J9cQUOgXEGtoFxBGKFcQYOhXEHuoVxBWaJcQcSiXEEvo1xBmaNcQQSkXEFvpFxB2qRcQUSlXEGvpVxBGqZcQYWmXEHwplxBWqdcQcWnXEEwqFxBmqhcQQWpXEFwqVxB26lcQUWqXEGwqlxBG6tcQYWrXEHwq1xBW6xcQcWsXEEwrVxBmq1cQQWuXEFwrlxB2q5cQUWvXEGvr1xBGrBcQYWwXEHvsFxBWrFcQcSxXEEvslxBmbJcQQSzXEFus1xB2bNcQUO0XEGutFxBGLVcQYO1XEHttVxBWLZcQcK2XEEtt1xBl7dcQQK4XEFsuFxB17hcQUG5XEGruVxBFrpcQYC6XEHrulxBVbtcQb+7XEEqvFxBlLxcQf68XEFpvVxB071cQT2+XEGovlxBEr9cQXy/XEHnv1xBUcBcQbvAXEElwVxBkMFcQfrBXEFkwlxBzsJcQTnDXEGjw1xBDcRcQXfEXEHixFxBTMVcQbbFXEEgxlxBisZcQfXGXEFfx1xBycdcQTPIXEGdyFxBB8lcQXHJXEHcyVxBRspcQbDKXEEay1xBhMtcQe7LXEFYzFxBwsxcQSzNXEGWzVxBAM5cQWrOXEHUzlxBPs9cQajPXEES0FxBfNBcQebQXEFQ0VxButFcQSTSXEGO0lxB+NJcQWLTXEHM01xBNtRcQaDUXEEK1VxBdNVcQd7VXEFI1lxBstZcQRvXXEGF11xB79dcQVnYXEHD2FxBLdlcQZfZXEEA2lxBatpcQdTaXEE+21xBqNtcQRHcXEF73FxB5dxcQU/dXEG43VxBIt5cQYzeXEH23lxBX99cQcnfXEEz4FxBneBcQQbhXEFw4VxB2uFcQUPiXEGt4lxBF+NcQYDjXEHq41xBVORcQb3kXEEn5VxBkeVcQfrlXEFk5lxBzeZcQTfnXEGh51xBCuhcQXToXEHd6FxBR+lcQbDpXEEa6lxBg+pcQe3qXEFX61xBwOtcQSrsXEGT7FxB/excQWbtXEHP7VxBOe5cQaLuXEEM71xBde9cQd/vXEFI8FxBsvBcQRvxXEGE8VxB7vFcQVfyXEHB8lxBKvNcQZPzXEH981xBZvRcQc/0XEE59VxBovVcQQv2XEF19lxB3vZcQUf3XEGx91xBGvhcQYP4XEHt+FxBVvlcQb/5XEEo+lxBkvpcQfv6XEFk+1xBzftcQTb8XEGg/FxBCf1cQXL9XEHb/VxBRP5cQa7+XEEX/1xBgP9cQen/XEFSAF1BuwBdQSUBXUGOAV1B9wFdQWACXUHJAl1BMgNdQZsDXUEEBF1BbQRdQdYEXUE/BV1BqAVdQRIGXUF7Bl1B5AZdQU0HXUG2B11BHwhdQYgIXUHxCF1BWgldQcMJXUEsCl1BlQpdQf0KXUFmC11BzwtdQTgMXUGhDF1BCg1dQXMNXUHcDV1BRQ5dQa4OXUEXD11Bfw9dQegPXUFREF1BuhBdQSMRXUGMEV1B9RFdQV0SXUHGEl1BLxNdQZgTXUEBFF1BaRRdQdIUXUE7FV1BpBVdQQ0WXUF1Fl1B3hZdQUcXXUGvF11BGBhdQYEYXUHqGF1BUhldQbsZXUEkGl1BjBpdQfUaXUFeG11BxhtdQS8cXUGYHF1BAB1dQWkdXUHSHV1BOh5dQaMeXUELH11BdB9dQd0fXUFFIF1BriBdQRYhXUF/IV1B5yFdQVAiXUG4Il1BISNdQYojXUHyI11BWyRdQcMkXUEsJV1BlCVdQfwlXUFlJl1BzSZdQTYnXUGeJ11BByhdQW8oXUHYKF1BQCldQagpXUERKl1BeSpdQeIqXUFKK11BsitdQRssXUGDLF1B6yxdQVQtXUG8LV1BJS5dQY0uXUH1Ll1BXS9dQcYvXUEuMF1BljBdQf8wXUFnMV1BzzFdQTcyXUGgMl1BCDNdQXAzXUHYM11BQTRdQak0XUERNV1BeTVdQeE1XUFKNl1BsjZdQRo3XUGCN11B6jddQVI4XUG7OF1BIzldQYs5XUHzOV1BWzpdQcM6XUErO11BkztdQfw7XUFkPF1BzDxdQTQ9XUGcPV1BBD5dQWw+XUHUPl1BPD9dQaQ/XUEMQF1BdEBdQdxAXUFEQV1BrEFdQRRCXUF8Ql1B5EJdQUxDXUG0Q11BHERdQYREXUHsRF1BVEVdQbxFXUEjRl1Bi0ZdQfNGXUFbR11Bw0ddQStIXUGTSF1B+0hdQWJJXUHKSV1BMkpdQZpKXUECS11BaktdQdFLXUE5TF1BoUxdQQlNXUFxTV1B2E1dQUBOXUGoTl1BEE9dQXdPXUHfT11BR1BdQa9QXUEWUV1BflFdQeZRXUFNUl1BtVJdQR1TXUGEU11B7FNdQVRUXUG7VF1BI1VdQYtVXUHyVV1BWlZdQcJWXUEpV11BkVddQfhXXUFgWF1ByFhdQS9ZXUGXWV1B/lldQWZaXUHNWl1BNVtdQZxbXUEEXF1BbFxdQdNcXUE7XV1Bol1dQQpeXUFxXl1B2V5dQUBfXUGnX11BD2BdQXZgXUHeYF1BRWFdQa1hXUEUYl1Be2JdQeNiXUFKY11BsmNdQRlkXUGAZF1B6GRdQU9lXUG3ZV1BHmZdQYVmXUHtZl1BVGddQbtnXUEjaF1BimhdQfFoXUFYaV1BwGldQSdqXUGOal1B9mpdQV1rXUHEa11BK2xdQZJsXUH6bF1BYW1dQchtXUEvbl1Bl25dQf5uXUFlb11BzG9dQTNwXUGacF1BAnFdQWlxXUHQcV1BN3JdQZ5yXUEFc11BbHNdQdRzXUE7dF1BonRdQQl1XUFwdV1B13VdQT52XUGldl1BDHddQXN3XUHad11BQXhdQah4XUEPeV1BdnldQd15XUFEel1Bq3pdQRJ7XUF5e11B4HtdQUd8XUGufF1BFX1dQXx9XUHjfV1BSn5dQbF+XUEYf11Bf39dQeZ/XUFMgF1Bs4BdQRqBXUGBgV1B6IFdQU+CXUG2gl1BHYNdQYODXUHqg11BUYRdQbiEXUEfhV1BhYVdQeyFXUFThl1BuoZdQSGHXUGHh11B7oddQVWIXUG8iF1BIoldQYmJXUHwiV1BV4pdQb2KXUEki11Bi4tdQfGLXUFYjF1Bv4xdQSWNXUGMjV1B841dQVmOXUHAjl1BJ49dQY2PXUH0j11BWpBdQcGQXUEokV1BjpFdQfWRXUFbkl1BwpJdQSmTXUGPk11B9pNdQVyUXUHDlF1BKZVdQZCVXUH2lV1BXZZdQcOWXUEql11BkJddQfeXXUFdmF1BxJhdQSqZXUGRmV1B95ldQV6aXUHEml1BKptdQZGbXUH3m11BXpxdQcScXUEqnV1BkZ1dQfedXUFenl1BxJ5dQSqfXUGRn11B959dQV2gXUHEoF1BKqFdQZChXUH3oV1BXaJdQcOiXUEpo11BkKNdQfajXUFcpF1Bw6RdQSmlXUGPpV1B9aVdQVumXUHCpl1BKKddQY6nXUH0p11BW6hdQcGoXUEnqV1BjaldQfOpXUFZql1BwKpdQSarXUGMq11B8qtdQVisXUG+rF1BJK1dQYqtXUHxrV1BV65dQb2uXUEjr11Bia9dQe+vXUFVsF1Bu7BdQSGxXUGHsV1B7bFdQVOyXUG5sl1BH7NdQYWzXUHrs11BUbRdQbe0XUEdtV1Bg7VdQem1XUFPtl1BtbZdQRu3XUGBt11B57ddQU24XUGzuF1BGbldQX65XUHkuV1BSrpdQbC6XUEWu11BfLtdQeK7XUFIvF1BrbxdQRO9XUF5vV1B371dQUW+XUGrvl1BEL9dQXa/XUHcv11BQsBdQajAXUENwV1Bc8FdQdnBXUE/wl1BpMJdQQrDXUFww11B1sNdQTvEXUGhxF1BB8VdQWzFXUHSxV1BOMZdQZ3GXUEDx11BacddQc7HXUE0yF1BmshdQf/IXUFlyV1By8ldQTDKXUGWyl1B+8pdQWHLXUHHy11BLMxdQZLMXUH3zF1BXc1dQcLNXUEozl1Bjc5dQfPOXUFZz11Bvs9dQSTQXUGJ0F1B79BdQVTRXUG60V1BH9JdQYTSXUHq0l1BT9NdQbXTXUEa1F1BgNRdQeXUXUFL1V1BsNVdQRXWXUF71l1B4NZdQUbXXUGr111BENhdQXbYXUHb2F1BQNldQabZXUEL2l1BcNpdQdbaXUE7211BoNtdQQbcXUFr3F1B0NxdQTbdXUGb3V1BAN5dQWXeXUHL3l1BMN9dQZXfXUH6311BYOBdQcXgXUEq4V1Bj+FdQfXhXUFa4l1Bv+JdQSTjXUGJ411B7uNdQVTkXUG55F1BHuVdQYPlXUHo5V1BTeZdQbLmXUEY511BfeddQeLnXUFH6F1BrOhdQRHpXUF26V1B2+ldQUDqXUGl6l1BCutdQW/rXUHU611BOuxdQZ/sXUEE7V1Bae1dQc7tXUEz7l1BmO5dQf3uXUFi711Bxu9dQSvwXUGQ8F1B9fBdQVrxXUG/8V1BJPJdQYnyXUHu8l1BU/NdQbjzXUEd9F1BgvRdQeb0XUFL9V1BsPVdQRX2XUF69l1B3/ZdQUT3XUGo911BDfhdQXL4XUHX+F1BPPldQaH5XUEF+l1BavpdQc/6XUE0+11BmPtdQf37XUFi/F1Bx/xdQSv9XUGQ/V1B9f1dQVr+XUG+/l1BI/9dQYj/XUHs/11BUQBeQbYAXkEaAV5BfwFeQeQBXkFIAl5BrQJeQRIDXkF2A15B2wNeQUAEXkGkBF5BCQVeQW0FXkHSBV5BNwZeQZsGXkEAB15BZAdeQckHXkEtCF5BkgheQfcIXkFbCV5BwAleQSQKXkGJCl5B7QpeQVILXkG2C15BGwxeQX8MXkHkDF5BSA1eQa0NXkERDl5BdQ5eQdoOXkE+D15Bow9eQQcQXkFsEF5B0BBeQTQRXkGZEV5B/RFeQWISXkHGEl5BKhNeQY8TXkHzE15BVxReQbwUXkEgFV5BhBVeQekVXkFNFl5BsRZeQRYXXkF6F15B3hdeQUIYXkGnGF5BCxleQW8ZXkHTGV5BOBpeQZwaXkEAG15BZBteQckbXkEtHF5BkRxeQfUcXkFZHV5Bvh1eQSIeXkGGHl5B6h5eQU4fXkGyH15BFyBeQXsgXkHfIF5BQyFeQachXkELIl5BbyJeQdMiXkE4I15BnCNeQQAkXkFkJF5ByCReQSwlXkGQJV5B9CVeQVgmXkG8Jl5BICdeQYQnXkHoJ15BTCheQbAoXkEUKV5BeCleQdwpXkFAKl5BpCpeQQgrXkFsK15B0CteQTQsXkGYLF5B/CxeQWAtXkHELV5BKC5eQYsuXkHvLl5BUy9eQbcvXkEbMF5BfzBeQeMwXkFHMV5BqjFeQQ4yXkFyMl5B1jJeQTozXkGeM15BATReQWU0XkHJNF5BLTVeQZE1XkH0NV5BWDZeQbw2XkEgN15BgzdeQec3XkFLOF5BrzheQRI5XkF2OV5B2jleQT06XkGhOl5BBTteQWk7XkHMO15BMDxeQZQ8XkH3PF5BWz1eQb49XkEiPl5Bhj5eQek+XkFNP15BsT9eQRRAXkF4QF5B20BeQT9BXkGjQV5BBkJeQWpCXkHNQl5BMUNeQZRDXkH4Q15BW0ReQb9EXkEjRV5BhkVeQepFXkFNRl5BsUZeQRRHXkF4R15B20deQT5IXkGiSF5BBUleQWlJXkHMSV5BMEpeQZNKXkH3Sl5BWkteQb1LXkEhTF5BhExeQehMXkFLTV5Brk1eQRJOXkF1Tl5B2E5eQTxPXkGfT15BAlBeQWZQXkHJUF5BLFFeQZBRXkHzUV5BVlJeQbpSXkEdU15BgFNeQeNTXkFHVF5BqlReQQ1VXkFxVV5B1FVeQTdWXkGaVl5B/VZeQWFXXkHEV15BJ1heQYpYXkHtWF5BUVleQbRZXkEXWl5BelpeQd1aXkFAW15BpFteQQdcXkFqXF5BzVxeQTBdXkGTXV5B9l1eQVleXkG8Xl5BIF9eQYNfXkHmX15BSWBeQaxgXkEPYV5BcmFeQdVhXkE4Yl5Bm2JeQf5iXkFhY15BxGNeQSdkXkGKZF5B7WReQVBlXkGzZV5BFmZeQXlmXkHcZl5BP2deQaJnXkEFaF5BaGheQctoXkEuaV5BkGleQfNpXkFWal5BuWpeQRxrXkF/a15B4mteQUVsXkGnbF5BCm1eQW1tXkHQbV5BM25eQZZuXkH4bl5BW29eQb5vXkEhcF5BhHBeQeZwXkFJcV5BrHFeQQ9yXkFycl5B1HJeQTdzXkGac15B/XNeQV90XkHCdF5BJXVeQYd1XkHqdV5BTXZeQbB2XkESd15BdXdeQdh3XkE6eF5BnXheQQB5XkFieV5BxXleQSd6XkGKel5B7XpeQU97XkGye15BFHxeQXd8XkHafF5BPH1eQZ99XkEBfl5BZH5eQcd+XkEpf15BjH9eQe5/XkFRgF5Bs4BeQRaBXkF4gV5B24FeQT2CXkGggl5BAoNeQWWDXkHHg15BKoReQYyEXkHvhF5BUYVeQbOFXkEWhl5BeIZeQduGXkE9h15BoIdeQQKIXkFkiF5Bx4heQSmJXkGLiV5B7oleQVCKXkGzil5BFYteQXeLXkHai15BPIxeQZ6MXkEBjV5BY41eQcWNXkEnjl5Bio5eQeyOXkFOj15BsY9eQROQXkF1kF5B15BeQTqRXkGckV5B/pFeQWCSXkHDkl5BJZNeQYeTXkHpk15BS5ReQa6UXkEQlV5BcpVeQdSVXkE2ll5BmJZeQfuWXkFdl15Bv5deQSGYXkGDmF5B5ZheQUeZXkGpmV5BDJpeQW6aXkHQml5BMpteQZSbXkH2m15BWJxeQbqcXkEcnV5Bfp1eQeCdXkFCnl5BpJ5eQQafXkFon15Byp9eQSygXkGOoF5B8KBeQVKhXkG0oV5BFqJeQXiiXkHaol5BPKNeQZ6jXkEApF5BYqReQcSkXkEmpV5BiKVeQeqlXkFLpl5BraZeQQ+nXkFxp15B06deQTWoXkGXqF5B+aheQVqpXkG8qV5BHqpeQYCqXkHiql5BRKteQaWrXkEHrF5BaaxeQcusXkEtrV5Bjq1eQfCtXkFSrl5BtK5eQRWvXkF3r15B2a9eQTuwXkGcsF5B/rBeQWCxXkHBsV5BI7JeQYWyXkHnsl5BSLNeQaqzXkEMtF5BbbReQc+0XkExtV5BkrVeQfS1XkFWtl5Bt7ZeQRm3XkF6t15B3LdeQT64XkGfuF5BAbleQWK5XkHEuV5BJbpeQYe6XkHpul5BSrteQay7XkENvF5Bb7xeQdC8XkEyvV5Bk71eQfW9XkFWvl5BuL5eQRm/XkF7v15B3L9eQT7AXkGfwF5BAcFeQWLBXkHEwV5BJcJeQYbCXkHowl5BScNeQavDXkEMxF5BbsReQc/EXkEwxV5BksVeQfPFXkFUxl5BtsZeQRfHXkF4x15B2sdeQTvIXkGcyF5B/sheQV/JXkHAyV5BIspeQYPKXkHkyl5BRsteQafLXkEIzF5BacxeQcvMXkEszV5Bjc1eQe7NXkFQzl5Bsc5eQRLPXkFzz15B1c9eQTbQXkGX0F5B+NBeQVnRXkG70V5BHNJeQX3SXkHe0l5BP9NeQaDTXkEC1F5BY9ReQcTUXkEl1V5BhtVeQefVXkFI1l5BqdZeQQrXXkFs115BzddeQS7YXkGP2F5B8NheQVHZXkGy2V5BE9peQXTaXkHV2l5BNtteQZfbXkH4215BWdxeQbrcXkEb3V5BfN1eQd3dXkE+3l5Bn95eQQDfXkFh315Bwt9eQSPgXkGE4F5B5eBeQUbhXkGn4V5BB+JeQWjiXkHJ4l5BKuNeQYvjXkHs415BTeReQa7kXkEP5V5Bb+VeQdDlXkEx5l5BkuZeQfPmXkFU515BtOdeQRXoXkF26F5B1+heQTjpXkGY6V5B+eleQVrqXkG76l5BHOteQXzrXkHd615BPuxeQZ/sXkH/7F5BYO1eQcHtXkEh7l5Bgu5eQePuXkFE715BpO9eQQXwXkFm8F5BxvBeQSfxXkGI8V5B6PFeQUnyXkGq8l5BCvNeQWvzXkHL815BLPReQY30XkHt9F5BTvVeQa71XkEP9l5BcPZeQdD2XkEx915BkfdeQfL3XkFS+F5Bs/heQRT5XkF0+V5B1fleQTX6XkGW+l5B9vpeQVf7XkG3+15BGPxeQXj8XkHZ/F5BOf1eQZn9XkH6/V5BWv5eQbv+XkEb/15BfP9eQdz/XkE9AF9BnQBfQf0AX0FeAV9BvgFfQR8CX0F/Al9B3wJfQUADX0GgA19BAARfQWEEX0HBBF9BIQVfQYIFX0HiBV9BQgZfQaMGX0EDB19BYwdfQcQHX0EkCF9BhAhfQeQIX0FFCV9BpQlfQQUKX0FmCl9BxgpfQSYLX0GGC19B5gtfQUcMX0GnDF9BBw1fQWcNX0HIDV9BKA5fQYgOX0HoDl9BSA9fQagPX0EJEF9BaRBfQckQX0EpEV9BiRFfQekRX0FJEl9BqhJfQQoTX0FqE19ByhNfQSoUX0GKFF9B6hRfQUoVX0GqFV9BChZfQWoWX0HKFl9BKxdfQYsXX0HrF19BSxhfQasYX0ELGV9BaxlfQcsZX0ErGl9BixpfQesaX0FLG19BqxtfQQscX0FrHF9ByxxfQSodX0GKHV9B6h1fQUoeX0GqHl9BCh9fQWofX0HKH19BKiBfQYogX0HqIF9BSSFfQakhX0EJIl9BaSJfQckiX0EpI19BiSNfQegjX0FIJF9BqCRfQQglX0FoJV9ByCVfQScmX0GHJl9B5yZfQUcnX0GnJ19BBihfQWYoX0HGKF9BJilfQYUpX0HlKV9BRSpfQaUqX0EEK19BZCtfQcQrX0EjLF9BgyxfQeMsX0FCLV9Boi1fQQIuX0FiLl9BwS5fQSEvX0GAL19B4C9fQUAwX0GfMF9B/zBfQV8xX0G+MV9BHjJfQX0yX0HdMl9BPTNfQZwzX0H8M19BWzRfQbs0X0EbNV9BejVfQdo1X0E5Nl9BmTZfQfg2X0FYN19BtzdfQRc4X0F2OF9B1jhfQTU5X0GVOV9B9DlfQVQ6X0GzOl9BEztfQXI7X0HSO19BMTxfQZA8X0HwPF9BTz1fQa89X0EOPl9Bbj5fQc0+X0EsP19BjD9fQes/X0FLQF9BqkBfQQlBX0FpQV9ByEFfQSdCX0GHQl9B5kJfQUVDX0GlQ19BBERfQWNEX0HDRF9BIkVfQYFFX0HhRV9BQEZfQZ9GX0H+Rl9BXkdfQb1HX0EcSF9Be0hfQdtIX0E6SV9BmUlfQfhJX0FYSl9Bt0pfQRZLX0F1S19B1EtfQTRMX0GTTF9B8kxfQVFNX0GwTV9BD05fQW9OX0HOTl9BLU9fQYxPX0HrT19BSlBfQalQX0EIUV9BaFFfQcdRX0EmUl9BhVJfQeRSX0FDU19BolNfQQFUX0FgVF9Bv1RfQR5VX0F9VV9B3FVfQTtWX0GaVl9B+VZfQVhXX0G3V19BFlhfQXVYX0HUWF9BM1lfQZJZX0HxWV9BUFpfQa9aX0EOW19BbVtfQcxbX0ErXF9BilxfQelcX0FIXV9Bp11fQQZeX0FkXl9Bw15fQSJfX0GBX19B4F9fQT9gX0GeYF9B/WBfQVthX0G6YV9BGWJfQXhiX0HXYl9BNmNfQZRjX0HzY19BUmRfQbFkX0EQZV9BbmVfQc1lX0EsZl9Bi2ZfQelmX0FIZ19Bp2dfQQZoX0FkaF9Bw2hfQSJpX0GBaV9B32lfQT5qX0Gdal9B+2pfQVprX0G5a19BF2xfQXZsX0HVbF9BM21fQZJtX0HxbV9BT25fQa5uX0ENb19Ba29fQcpvX0EocF9Bh3BfQeZwX0FEcV9Bo3FfQQFyX0Fgcl9Bv3JfQR1zX0F8c19B2nNfQTl0X0GXdF9B9nRfQVR1X0GzdV9BEXZfQXB2X0HOdl9BLXdfQYt3X0Hqd19BSHhfQad4X0EFeV9BZHlfQcJ5X0Ehel9Bf3pfQd56X0E8e19BmntfQfl7X0FXfF9BtnxfQRR9X0FyfV9B0X1fQS9+X0GOfl9B7H5fQUp/X0Gpf19BB4BfQWWAX0HEgF9BIoFfQYCBX0HfgV9BPYJfQZuCX0H6gl9BWINfQbaDX0EVhF9Bc4RfQdGEX0EvhV9BjoVfQeyFX0FKhl9BqYZfQQeHX0Flh19Bw4dfQSGIX0GAiF9B3ohfQTyJX0GaiV9B+YlfQVeKX0G1il9BE4tfQXGLX0HPi19BLoxfQYyMX0HqjF9BSI1fQaaNX0EEjl9BYo5fQcGOX0Efj19BfY9fQduPX0E5kF9Bl5BfQfWQX0FTkV9BsZFfQQ+SX0Ftkl9BzJJfQSqTX0GIk19B5pNfQUSUX0GilF9BAJVfQV6VX0G8lV9BGpZfQXiWX0HWll9BNJdfQZKXX0Hwl19BTphfQayYX0EKmV9BaJlfQcaZX0Ejml9BgZpfQd+aX0E9m19Bm5tfQfmbX0FXnF9BtZxfQROdX0FxnV9Bz51fQSyeX0GKnl9B6J5fQUafX0Gkn19BAqBfQWCgX0G9oF9BG6FfQXmhX0HXoV9BNaJfQZKiX0Hwol9BTqNfQayjX0EKpF9BZ6RfQcWkX0EjpV9BgaVfQd6lX0E8pl9BmqZfQfimX0FVp19Bs6dfQRGoX0FvqF9BzKhfQSqpX0GIqV9B5alfQUOqX0Ghql9B/qpfQVyrX0G6q19BF6xfQXWsX0HTrF9BMK1fQY6tX0HsrV9BSa5fQaeuX0EEr19BYq9fQcCvX0EdsF9Be7BfQdiwX0E2sV9BlLFfQfGxX0FPsl9BrLJfQQqzX0Fns19BxbNfQSK0X0GAtF9B3bRfQTu1X0GYtV9B9rVfQVO2X0Gxtl9BDrdfQWy3X0HJt19BJ7hfQYS4X0HiuF9BP7lfQZ25X0H6uV9BV7pfQbW6X0ESu19BcLtfQc27X0ErvF9BiLxfQeW8X0FDvV9BoL1fQf29X0Fbvl9BuL5fQRa/X0Fzv19B0L9fQS7AX0GLwF9B6MBfQUbBX0GjwV9BAMJfQV3CX0G7wl9BGMNfQXXDX0HTw19BMMRfQY3EX0HqxF9BSMVfQaXFX0ECxl9BX8ZfQb3GX0Eax19Bd8dfQdTHX0EyyF9Bj8hfQezIX0FJyV9BpslfQQTKX0Fhyl9BvspfQRvLX0F4y19B1ctfQTLMX0GQzF9B7cxfQUrNX0GnzV9BBM5fQWHOX0G+zl9BG89fQXnPX0HWz19BM9BfQZDQX0Ht0F9BStFfQafRX0EE0l9BYdJfQb7SX0Eb019BeNNfQdXTX0Ey1F9Bj9RfQezUX0FJ1V9BptVfQQPWX0Fg1l9BvdZfQRrXX0F3119B1NdfQTHYX0GO2F9B69hfQUjZX0Gl2V9BAtpfQV/aX0G82l9BGdtfQXbbX0HS219BL9xfQYzcX0Hp3F9BRt1fQaPdX0EA3l9BXd5fQbneX0EW319Bc99fQdDfX0Et4F9BiuBfQebgX0FD4V9BoOFfQf3hX0Fa4l9Bt+JfQRPjX0Fw419BzeNfQSrkX0GG5F9B4+RfQUDlX0Gd5V9B+eVfQVbmX0Gz5l9BEOdfQWznX0HJ519BJuhfQYLoX0Hf6F9BPOlfQZnpX0H16V9BUupfQa/qX0EL619BaOtfQcXrX0Eh7F9BfuxfQdrsX0E37V9BlO1fQfDtX0FN7l9Bqu5fQQbvX0Fj719Bv+9fQRzwX0F48F9B1fBfQTLxX0GO8V9B6/FfQUfyX0Gk8l9BAPNfQV3zX0G5819BFvRfQXL0X0HP9F9BK/VfQYj1X0Hk9V9BQfZfQZ32X0H69l9BVvdfQbP3X0EP+F9BbPhfQcj4X0El+V9BgflfQd75X0E6+l9BlvpfQfP6X0FP+19BrPtfQQj8X0Fk/F9BwfxfQR39X0F6/V9B1v1fQTL+X0GP/l9B6/5fQUf/X0Gk/19BAABgQVwAYEG5AGBBFQFgQXEBYEHOAWBBKgJgQYYCYEHiAmBBPwNgQZsDYEH3A2BBVARgQbAEYEEMBWBBaAVgQcUFYEEhBmBBfQZgQdkGYEE2B2BBkgdgQe4HYEFKCGBBpghgQQMJYEFfCWBBuwlgQRcKYEFzCmBBzwpgQSwLYEGIC2BB5AtgQUAMYEGcDGBB+AxgQVQNYEGxDWBBDQ5gQWkOYEHFDmBBIQ9gQX0PYEHZD2BBNRBgQZEQYEHtEGBBSRFgQaYRYEECEmBBXhJgQboSYEEWE2BBchNgQc4TYEEqFGBBhhRgQeIUYEE+FWBBmhVgQfYVYEFSFmBBrhZgQQoXYEFmF2BBwhdgQR4YYEF6GGBB1hhgQTIZYEGNGWBB6RlgQUUaYEGhGmBB/RpgQVkbYEG1G2BBERxgQW0cYEHJHGBBJR1gQYAdYEHcHWBBOB5gQZQeYEHwHmBBTB9gQagfYEEDIGBBXyBgQbsgYEEXIWBBcyFgQc4hYEEqImBBhiJgQeIiYEE+I2BBmSNgQfUjYEFRJGBBrSRgQQglYEFkJWBBwCVgQRwmYEF3JmBB0yZgQS8nYEGLJ2BB5idgQUIoYEGeKGBB+ShgQVUpYEGxKWBBDSpgQWgqYEHEKmBBICtgQXsrYEHXK2BBMixgQY4sYEHqLGBBRS1gQaEtYEH9LWBBWC5gQbQuYEEPL2BBay9gQccvYEEiMGBBfjBgQdkwYEE1MWBBkTFgQewxYEFIMmBBozJgQf8yYEFaM2BBtjNgQRE0YEFtNGBByDRgQSQ1YEF/NWBB2zVgQTY2YEGSNmBB7TZgQUk3YEGkN2BBADhgQVs4YEG3OGBBEjlgQW45YEHJOWBBJDpgQYA6YEHbOmBBNztgQZI7YEHtO2BBSTxgQaQ8YEEAPWBBWz1gQbY9YEESPmBBbT5gQck+YEEkP2BBfz9gQds/YEE2QGBBkUBgQe1AYEFIQWBBo0FgQf5BYEFaQmBBtUJgQRBDYEFsQ2BBx0NgQSJEYEF+RGBB2URgQTRFYEGPRWBB60VgQUZGYEGhRmBB/EZgQVdHYEGzR2BBDkhgQWlIYEHESGBBIElgQXtJYEHWSWBBMUpgQYxKYEHnSmBBQ0tgQZ5LYEH5S2BBVExgQa9MYEEKTWBBZU1gQcFNYEEcTmBBd05gQdJOYEEtT2BBiE9gQeNPYEE+UGBBmVBgQfVQYEFQUWBBq1FgQQZSYEFhUmBBvFJgQRdTYEFyU2BBzVNgQShUYEGDVGBB3lRgQTlVYEGUVWBB71VgQUpWYEGlVmBBAFdgQVtXYEG2V2BBEVhgQWxYYEHHWGBBIllgQX1ZYEHYWWBBM1pgQY5aYEHpWmBBQ1tgQZ5bYEH5W2BBVFxgQa9cYEEKXWBBZV1gQcBdYEEbXmBBdV5gQdBeYEErX2BBhl9gQeFfYEE8YGBBl2BgQfFgYEFMYWBBp2FgQQJiYEFdYmBBt2JgQRJjYEFtY2BByGNgQSNkYEF9ZGBB2GRgQTNlYEGOZWBB6WVgQUNmYEGeZmBB+WZgQVNnYEGuZ2BBCWhgQWRoYEG+aGBBGWlgQXRpYEHOaWBBKWpgQYRqYEHfamBBOWtgQZRrYEHva2BBSWxgQaRsYEH+bGBBWW1gQbRtYEEObmBBaW5gQcRuYEEeb2BBeW9gQdNvYEEucGBBiXBgQeNwYEE+cWBBmHFgQfNxYEFOcmBBqHJgQQNzYEFdc2BBuHNgQRJ0YEFtdGBBx3RgQSJ1YEF8dWBB13VgQTF2YEGMdmBB5nZgQUF3YEGbd2BB9ndgQVB4YEGreGBBBXlgQWB5YEG6eWBBFXpgQW96YEHKemBBJHtgQX57YEHZe2BBM3xgQY58YEHofGBBQn1gQZ19YEH3fWBBUn5gQax+YEEGf2BBYX9gQbt/YEEVgGBBcIBgQcqAYEEkgWBBf4FgQdmBYEEzgmBBjoJgQeiCYEFCg2BBnYNgQfeDYEFRhGBBrIRgQQaFYEFghWBBuoVgQRWGYEFvhmBByYZgQSOHYEF+h2BB2IdgQTKIYEGMiGBB54hgQUGJYEGbiWBB9YlgQU+KYEGqimBBBItgQV6LYEG4i2BBEoxgQWyMYEHHjGBBIY1gQXuNYEHVjWBBL45gQYmOYEHjjmBBPo9gQZiPYEHyj2BBTJBgQaaQYEEAkWBBWpFgQbSRYEEOkmBBaJJgQcOSYEEdk2BBd5NgQdGTYEErlGBBhZRgQd+UYEE5lWBBk5VgQe2VYEFHlmBBoZZgQfuWYEFVl2BBr5dgQQmYYEFjmGBBvZhgQReZYEFxmWBBy5lgQSWaYEF/mmBB2ZpgQTObYEGNm2BB55tgQUCcYEGanGBB9JxgQU6dYEGonWBBAp5gQVyeYEG2nmBBEJ9gQWqfYEHDn2BBHaBgQXegYEHRoGBBK6FgQYWhYEHfoWBBOKJgQZKiYEHsomBBRqNgQaCjYEH5o2BBU6RgQa2kYEEHpWBBYaVgQbqlYEEUpmBBbqZgQcimYEEhp2BBe6dgQdWnYEEvqGBBiKhgQeKoYEE8qWBBlqlgQe+pYEFJqmBBo6pgQfyqYEFWq2BBsKtgQQqsYEFjrGBBvaxgQRetYEFwrWBByq1gQSSuYEF9rmBB165gQTCvYEGKr2BB5K9gQT2wYEGXsGBB8bBgQUqxYEGksWBB/bFgQVeyYEGxsmBBCrNgQWSzYEG9s2BBF7RgQXC0YEHKtGBBJLVgQX21YEHXtWBBMLZgQYq2YEHjtmBBPbdgQZa3YEHwt2BBSbhgQaO4YEH8uGBBVrlgQa+5YEEJumBBYrpgQby6YEEVu2BBbrtgQci7YEEhvGBBe7xgQdS8YEEuvWBBh71gQeG9YEE6vmBBk75gQe2+YEFGv2BBn79gQfm/YEFSwGBBrMBgQQXBYEFewWBBuMFgQRHCYEFqwmBBxMJgQR3DYEF2w2BB0MNgQSnEYEGCxGBB3MRgQTXFYEGOxWBB6MVgQUHGYEGaxmBB88ZgQU3HYEGmx2BB/8dgQVnIYEGyyGBBC8lgQWTJYEG9yWBBF8pgQXDKYEHJymBBIstgQXzLYEHVy2BBLsxgQYfMYEHgzGBBOs1gQZPNYEHszWBBRc5gQZ7OYEH3zmBBUc9gQarPYEED0GBBXNBgQbXQYEEO0WBBZ9FgQcDRYEEa0mBBc9JgQczSYEEl02BBftNgQdfTYEEw1GBBidRgQeLUYEE71WBBlNVgQe3VYEFG1mBBoNZgQfnWYEFS12BBq9dgQQTYYEFd2GBBtthgQQ/ZYEFo2WBBwdlgQRraYEFz2mBBzNpgQSXbYEF+22BB19tgQS/cYEGI3GBB4dxgQTrdYEGT3WBB7N1gQUXeYEGe3mBB995gQVDfYEGp32BBAuBgQVvgYEGz4GBBDOFgQWXhYEG+4WBBF+JgQXDiYEHJ4mBBIuNgQXrjYEHT42BBLORgQYXkYEHe5GBBN+VgQY/lYEHo5WBBQeZgQZrmYEHz5mBBS+dgQaTnYEH952BBVuhgQa7oYEEH6WBBYOlgQbnpYEES6mBBaupgQcPqYEEc62BBdOtgQc3rYEEm7GBBf+xgQdfsYEEw7WBBie1gQeHtYEE67mBBk+5gQevuYEFE72BBne9gQfXvYEFO8GBBp/BgQf/wYEFY8WBBsfFgQQnyYEFi8mBBu/JgQRPzYEFs82BBxPNgQR30YEF29GBBzvRgQSf1YEF/9WBB2PVgQTD2YEGJ9mBB4vZgQTr3YEGT92BB6/dgQUT4YEGc+GBB9fhgQU35YEGm+WBB/vlgQVf6YEGv+mBBCPtgQWD7YEG5+2BBEfxgQWr8YEHC/GBBG/1gQXP9YEHM/WBBJP5gQX3+YEHV/mBBLf9gQYb/YEHe/2BBNwBhQY8AYUHnAGFBQAFhQZgBYUHxAWFBSQJhQaECYUH6AmFBUgNhQasDYUEDBGFBWwRhQbQEYUEMBWFBZAVhQb0FYUEVBmFBbQZhQcYGYUEeB2FBdgdhQc8HYUEnCGFBfwhhQdcIYUEwCWFBiAlhQeAJYUE5CmFBkQphQekKYUFBC2FBmgthQfILYUFKDGFBogxhQfoMYUFTDWFBqw1hQQMOYUFbDmFBtA5hQQwPYUFkD2FBvA9hQRQQYUFsEGFBxRBhQR0RYUF1EWFBzRFhQSUSYUF9EmFB1hJhQS4TYUGGE2FB3hNhQTYUYUGOFGFB5hRhQT4VYUGWFWFB7xVhQUcWYUGfFmFB9xZhQU8XYUGnF2FB/xdhQVcYYUGvGGFBBxlhQV8ZYUG3GWFBDxphQWcaYUG/GmFBFxthQW8bYUHHG2FBHxxhQXccYUHPHGFBJx1hQX8dYUHXHWFBLx5hQYceYUHfHmFBNx9hQY8fYUHnH2FBPyBhQZcgYUHvIGFBRyFhQZ8hYUH3IWFBTyJhQaYiYUH+ImFBViNhQa4jYUEGJGFBXiRhQbYkYUEOJWFBZSVhQb0lYUEVJmFBbSZhQcUmYUEdJ2FBdSdhQcwnYUEkKGFBfChhQdQoYUEsKWFBgylhQdspYUEzKmFBiyphQeMqYUE6K2FBkithQeorYUFCLGFBmSxhQfEsYUFJLWFBoS1hQfgtYUFQLmFBqC5hQQAvYUFXL2FBry9hQQcwYUFeMGFBtjBhQQ4xYUFlMWFBvTFhQRUyYUFsMmFBxDJhQRwzYUFzM2FByzNhQSM0YUF6NGFB0jRhQSo1YUGBNWFB2TVhQTA2YUGINmFB4DZhQTc3YUGPN2FB5jdhQT44YUGWOGFB7ThhQUU5YUGcOWFB9DlhQUs6YUGjOmFB+zphQVI7YUGqO2FBATxhQVk8YUGwPGFBCD1hQV89YUG3PWFBDj5hQWY+YUG9PmFBFT9hQWw/YUHEP2FBG0BhQXNAYUHKQGFBIUFhQXlBYUHQQWFBKEJhQX9CYUHXQmFBLkNhQYVDYUHdQ2FBNERhQYxEYUHjRGFBOkVhQZJFYUHpRWFBQUZhQZhGYUHvRmFBR0dhQZ5HYUH1R2FBTUhhQaRIYUH7SGFBU0lhQapJYUEBSmFBWUphQbBKYUEHS2FBX0thQbZLYUENTGFBZExhQbxMYUETTWFBak1hQcJNYUEZTmFBcE5hQcdOYUEfT2FBdk9hQc1PYUEkUGFBfFBhQdNQYUEqUWFBgVFhQdhRYUEwUmFBh1JhQd5SYUE1U2FBjFNhQeNTYUE7VGFBklRhQelUYUFAVWFBl1VhQe5VYUFGVmFBnVZhQfRWYUFLV2FBoldhQflXYUFQWGFBp1hhQf5YYUFWWWFBrVlhQQRaYUFbWmFBslphQQlbYUFgW2FBt1thQQ5cYUFlXGFBvFxhQRNdYUFqXWFBwV1hQRheYUFvXmFBxl5hQR1fYUF0X2FBy19hQSJgYUF5YGFB0GBhQSdhYUF+YWFB1WFhQSxiYUGDYmFB2mJhQTFjYUGIY2FB32NhQTZkYUGNZGFB5GRhQTtlYUGSZWFB6WVhQT9mYUGWZmFB7WZhQURnYUGbZ2FB8mdhQUloYUGgaGFB9mhhQU1pYUGkaWFB+2lhQVJqYUGpamFBAGthQVZrYUGta2FBBGxhQVtsYUGybGFBCG1hQV9tYUG2bWFBDW5hQWRuYUG6bmFBEW9hQWhvYUG/b2FBFXBhQWxwYUHDcGFBGnFhQXBxYUHHcWFBHnJhQXVyYUHLcmFBInNhQXlzYUHPc2FBJnRhQX10YUHUdGFBKnVhQYF1YUHYdWFBLnZhQYV2YUHcdmFBMndhQYl3YUHgd2FBNnhhQY14YUHjeGFBOnlhQZF5YUHneWFBPnphQZV6YUHremFBQnthQZh7YUHve2FBRXxhQZx8YUHzfGFBSX1hQaB9YUH2fWFBTX5hQaN+YUH6fmFBUH9hQad/YUH+f2FBVIBhQauAYUEBgWFBWIFhQa6BYUEFgmFBW4JhQbKCYUEIg2FBX4NhQbWDYUELhGFBYoRhQbiEYUEPhWFBZYVhQbyFYUEShmFBaYZhQb+GYUEVh2FBbIdhQcKHYUEZiGFBb4hhQcWIYUEciWFBcolhQcmJYUEfimFBdYphQcyKYUEii2FBeIthQc+LYUEljGFBfIxhQdKMYUEojWFBf41hQdWNYUErjmFBgY5hQdiOYUEuj2FBhI9hQduPYUExkGFBh5BhQd6QYUE0kWFBipFhQeCRYUE3kmFBjZJhQeOSYUE5k2FBkJNhQeaTYUE8lGFBkpRhQemUYUE/lWFBlZVhQeuVYUFBlmFBmJZhQe6WYUFEl2FBmpdhQfCXYUFGmGFBnZhhQfOYYUFJmWFBn5lhQfWZYUFLmmFBopphQfiaYUFOm2FBpJthQfqbYUFQnGFBppxhQfycYUFSnWFBqZ1hQf+dYUFVnmFBq55hQQGfYUFXn2FBrZ9hQQOgYUFZoGFBr6BhQQWhYUFboWFBsaFhQQeiYUFdomFBs6JhQQmjYUFfo2FBtaNhQQukYUFhpGFBt6RhQQ2lYUFjpWFBuaVhQQ+mYUFlpmFBu6ZhQRGnYUFnp2FBvadhQROoYUFpqGFBv6hhQRWpYUFrqWFBwalhQRaqYUFsqmFBwqphQRirYUFuq2FBxKthQRqsYUFwrGFBxqxhQRutYUFxrWFBx61hQR2uYUFzrmFBya5hQR+vYUF0r2FByq9hQSCwYUF2sGFBzLBhQSKxYUF3sWFBzbFhQSOyYUF5smFBzrJhQSSzYUF6s2FB0LNhQSa0YUF7tGFB0bRhQSe1YUF9tWFB0rVhQSi2YUF+tmFB1LZhQSm3YUF/t2FB1bdhQSq4YUGAuGFB1rhhQSu5YUGBuWFB17lhQS26YUGCumFB2LphQS67YUGDu2FB2bthQS68YUGEvGFB2rxhQS+9YUGFvWFB271hQTC+YUGGvmFB3L5hQTG/YUGHv2FB3L9hQTLAYUGHwGFB3cBhQTPBYUGIwWFB3sFhQTPCYUGJwmFB3sJhQTTDYUGKw2FB38NhQTXEYUGKxGFB4MRhQTXFYUGLxWFB4MVhQTbGYUGLxmFB4cZhQTbHYUGMx2FB4cdhQTfIYUGMyGFB4shhQTfJYUGMyWFB4slhQTfKYUGNymFB4sphQTjLYUGNy2FB48thQTjMYUGNzGFB48xhQTjNYUGOzWFB481hQTjOYUGOzmFB485hQTjPYUGOz2FB489hQTnQYUGO0GFB49BhQTnRYUGO0WFB49FhQTnSYUGO0mFB49JhQTnTYUGO02FB49NhQTnUYUGO1GFB49RhQTjVYUGO1WFB49VhQTjWYUGN1mFB49ZhQTjXYUGN12FB49dhQTjYYUGN2GFB4thhQTfZYUGN2WFB4tlhQTfaYUGM2mFB4tphQTfbYUGM22FB4dthQTbcYUGL3GFB4dxhQTbdYUGL3WFB4N1hQTXeYUGK3mFB4N5hQTXfYUGK32FB399hQTTgYUGJ4GFB3uBhQTThYUGJ4WFB3uFhQTPiYUGI4mFB3eJhQTLjYUGH42FB3ONhQTHkYUGG5GFB2+RhQTHlYUGG5WFB2+VhQTDmYUGF5mFB2uZhQS/nYUGE52FB2edhQS7oYUGD6GFB2OhhQS3pYUGC6WFB1+lhQSzqYUGB6mFB1uphQSvrYUGA62FB1ethQSrsYUF/7GFB0+xhQSjtYUF97WFB0u1hQSfuYUF87mFB0e5hQSbvYUF772FB0O9hQSXwYUF68GFBzvBhQSPxYUF48WFBzfFhQSLyYUF38mFBzPJhQSHzYUF182FByvNhQR/0YUF09GFByfRhQR71YUFy9WFBx/VhQRz2YUFx9mFBxvZhQRr3YUFv92FBxPdhQRn4YUFu+GFBwvhhQRf5YUFs+WFBwflhQRX6YUFq+mFBv/phQRT7YUFo+2FBvfthQRL8YUFn/GFBu/xhQRD9YUFl/WFBuf1hQQ7+YUFj/mFBuP5hQQz/YUFh/2FBtv9hQQoAYkFfAGJBtABiQQgBYkFdAWJBsgFiQQYCYkFbAmJBrwJiQQQDYkFZA2JBrQNiQQIEYkFXBGJBqwRiQQAFYkFUBWJBqQViQf4FYkFSBmJBpwZiQfsGYkFQB2JBpAdiQfkHYkFOCGJBoghiQfcIYkFLCWJBoAliQfQJYkFJCmJBnQpiQfIKYkFGC2JBmwtiQe8LYkFEDGJBmAxiQe0MYkFBDWJBlg1iQeoNYkE/DmJBkw5iQegOYkE8D2JBkA9iQeUPYkE5EGJBjhBiQeIQYkE3EWJBixFiQd8RYkE0EmJBiBJiQd0SYkExE2JBhRNiQdoTYkEuFGJBgxRiQdcUYkErFWJBgBViQdQVYkEoFmJBfRZiQdEWYkElF2JBehdiQc4XYkEiGGJBdxhiQcsYYkEfGWJBdBliQcgZYkEcGmJBcRpiQcUaYkEZG2JBbRtiQcIbYkEWHGJBahxiQb8cYkETHWJBZx1iQbsdYkEQHmJBZB5iQbgeYkEMH2JBYB9iQbUfYkEJIGJBXSBiQbEgYkEGIWJBWiFiQa4hYkECImJBViJiQaoiYkH/ImJBUyNiQacjYkH7I2JBTyRiQaMkYkH4JGJBTCViQaAlYkH0JWJBSCZiQZwmYkHwJmJBRCdiQZknYkHtJ2JBQShiQZUoYkHpKGJBPSliQZEpYkHlKWJBOSpiQY0qYkHhKmJBNStiQYkrYkHeK2JBMixiQYYsYkHaLGJBLi1iQYItYkHWLWJBKi5iQX4uYkHSLmJBJi9iQXovYkHOL2JBIjBiQXYwYkHKMGJBHjFiQXIxYkHGMWJBGTJiQW0yYkHBMmJBFTNiQWkzYkG9M2JBETRiQWU0YkG5NGJBDTViQWE1YkG1NWJBCTZiQVw2YkGwNmJBBDdiQVg3YkGsN2JBADhiQVQ4YkGoOGJB+zhiQU85YkGjOWJB9zliQUs6YkGfOmJB8zpiQUY7YkGaO2JB7jtiQUI8YkGWPGJB6TxiQT09YkGRPWJB5T1iQTk+YkGMPmJB4D5iQTQ/YkGIP2JB2z9iQS9AYkGDQGJB10BiQSpBYkF+QWJB0kFiQSZCYkF5QmJBzUJiQSFDYkF1Q2JByENiQRxEYkFwRGJBw0RiQRdFYkFrRWJBvkViQRJGYkFmRmJBuUZiQQ1HYkFhR2JBtEdiQQhIYkFcSGJBr0hiQQNJYkFXSWJBqkliQf5JYkFRSmJBpUpiQflKYkFMS2JBoEtiQfNLYkFHTGJBm0xiQe5MYkFCTWJBlU1iQelNYkE8TmJBkE5iQeNOYkE3T2JBi09iQd5PYkEyUGJBhVBiQdlQYkEsUWJBgFFiQdNRYkEnUmJBelJiQc5SYkEhU2JBdVNiQchTYkEcVGJBb1RiQcNUYkEWVWJBaVViQb1VYkEQVmJBZFZiQbdWYkELV2JBXldiQbJXYkEFWGJBWFhiQaxYYkH/WGJBU1liQaZZYkH5WWJBTVpiQaBaYkH0WmJBR1tiQZpbYkHuW2JBQVxiQZRcYkHoXGJBO11iQY5dYkHiXWJBNV5iQYheYkHcXmJBL19iQYJfYkHWX2JBKWBiQXxgYkHQYGJBI2FiQXZhYkHJYWJBHWJiQXBiYkHDYmJBF2NiQWpjYkG9Y2JBEGRiQWRkYkG3ZGJBCmViQV1lYkGwZWJBBGZiQVdmYkGqZmJB/WZiQVFnYkGkZ2JB92diQUpoYkGdaGJB8GhiQURpYkGXaWJB6mliQT1qYkGQamJB42piQTdrYkGKa2JB3WtiQTBsYkGDbGJB1mxiQSltYkF9bWJB0G1iQSNuYkF2bmJByW5iQRxvYkFvb2JBwm9iQRVwYkFocGJBu3BiQQ9xYkFicWJBtXFiQQhyYkFbcmJBrnJiQQFzYkFUc2JBp3NiQfpzYkFNdGJBoHRiQfN0YkFGdWJBmXViQex1YkE/dmJBknZiQeV2YkE4d2JBi3diQd53YkExeGJBhHhiQdd4YkEqeWJBfXliQdB5YkEjemJBdXpiQch6YkEbe2JBbntiQcF7YkEUfGJBZ3xiQbp8YkENfWJBYH1iQbN9YkEFfmJBWH5iQat+YkH+fmJBUX9iQaR/YkH3f2JBSoBiQZyAYkHvgGJBQoFiQZWBYkHogWJBO4JiQY2CYkHggmJBM4NiQYaDYkHZg2JBK4RiQX6EYkHRhGJBJIViQXeFYkHJhWJBHIZiQW+GYkHChmJBFIdiQWeHYkG6h2JBDYhiQV+IYkGyiGJBBYliQViJYkGqiWJB/YliQVCKYkGiimJB9YpiQUiLYkGbi2JB7YtiQUCMYkGTjGJB5YxiQTiNYkGLjWJB3Y1iQTCOYkGDjmJB1Y5iQSiPYkF7j2JBzY9iQSCQYkFykGJBxZBiQRiRYkFqkWJBvZFiQQ+SYkFikmJBtZJiQQeTYkFak2JBrJNiQf+TYkFSlGJBpJRiQfeUYkFJlWJBnJViQe6VYkFBlmJBk5ZiQeaWYkE5l2JBi5diQd6XYkEwmGJBg5hiQdWYYkEomWJBepliQc2ZYkEfmmJBcppiQcSaYkEXm2JBaZtiQbybYkEOnGJBYJxiQbOcYkEFnWJBWJ1iQaqdYkH9nWJBT55iQaKeYkH0nmJBRp9iQZmfYkHrn2JBPqBiQZCgYkHioGJBNaFiQYehYkHaoWJBLKJiQX6iYkHRomJBI6NiQXWjYkHIo2JBGqRiQW2kYkG/pGJBEaViQWSlYkG2pWJBCKZiQVqmYkGtpmJB/6ZiQVGnYkGkp2JB9qdiQUioYkGbqGJB7ahiQT+pYkGRqWJB5KliQTaqYkGIqmJB26piQS2rYkF/q2JB0atiQSSsYkF2rGJByKxiQRqtYkFsrWJBv61iQRGuYkFjrmJBta5iQQevYkFar2JBrK9iQf6vYkFQsGJBorBiQfWwYkFHsWJBmbFiQeuxYkE9smJBj7JiQeKyYkE0s2JBhrNiQdizYkEqtGJBfLRiQc60YkEgtWJBc7ViQcW1YkEXtmJBabZiQbu2YkENt2JBX7diQbG3YkEDuGJBVbhiQae4YkH5uGJBTLliQZ65YkHwuWJBQrpiQZS6YkHmumJBOLtiQYq7YkHcu2JBLrxiQYC8YkHSvGJBJL1iQXa9YkHIvWJBGr5iQWy+YkG+vmJBEL9iQWK/YkG0v2JBBsBiQVjAYkGqwGJB/MBiQU7BYkGfwWJB8cFiQUPCYkGVwmJB58JiQTnDYkGLw2JB3cNiQS/EYkGBxGJB08RiQSXFYkF2xWJByMViQRrGYkFsxmJBvsZiQRDHYkFix2JBtMdiQQXIYkFXyGJBqchiQfvIYkFNyWJBn8liQfDJYkFCymJBlMpiQebKYkE4y2JBictiQdvLYkEtzGJBf8xiQdHMYkEizWJBdM1iQcbNYkEYzmJBas5iQbvOYkENz2JBX89iQbHPYkEC0GJBVNBiQabQYkH30GJBSdFiQZvRYkHt0WJBPtJiQZDSYkHi0mJBM9NiQYXTYkHX02JBKdRiQXrUYkHM1GJBHtViQW/VYkHB1WJBE9ZiQWTWYkG21mJBCNdiQVnXYkGr12JB/NdiQU7YYkGg2GJB8dhiQUPZYkGV2WJB5tliQTjaYkGJ2mJB29piQS3bYkF+22JB0NtiQSHcYkFz3GJBxNxiQRbdYkFo3WJBud1iQQveYkFc3mJBrt5iQf/eYkFR32JBot9iQfTfYkFF4GJBl+BiQejgYkE64WJBi+FiQd3hYkEu4mJBgOJiQdHiYkEj42JBdONiQcbjYkEX5GJBaeRiQbrkYkEM5WJBXeViQa7lYkEA5mJBUeZiQaPmYkH05mJBRudiQZfnYkHo52JBOuhiQYvoYkHd6GJBLuliQX/pYkHR6WJBIupiQXTqYkHF6mJBFutiQWjrYkG562JBCuxiQVzsYkGt7GJB/uxiQVDtYkGh7WJB8u1iQUTuYkGV7mJB5u5iQTjvYkGJ72JB2u9iQSzwYkF98GJBzvBiQSDxYkFx8WJBwvFiQRPyYkFl8mJBtvJiQQfzYkFY82JBqvNiQfvzYkFM9GJBnfRiQe/0YkFA9WJBkfViQeL1YkE09mJBhfZiQdb2YkEn92JBePdiQcr3YkEb+GJBbPhiQb34YkEO+WJBX/liQbH5YkEC+mJBU/piQaT6YkH1+mJBRvtiQZj7YkHp+2JBOvxiQYv8YkHc/GJBLf1iQX79YkHP/WJBIf5iQXL+YkHD/mJBFP9iQWX/YkG2/2JBBwBjQVgAY0GpAGNB+gBjQUsBY0GcAWNB7QFjQT8CY0GQAmNB4QJjQTIDY0GDA2NB1ANjQSUEY0F2BGNBxwRjQRgFY0FpBWNBugVjQQsGY0FcBmNBrQZjQf4GY0FPB2NBoAdjQfEHY0FCCGNBkwhjQeQIY0E1CWNBhQljQdYJY0EnCmNBeApjQckKY0EaC2NBawtjQbwLY0ENDGNBXgxjQa8MY0EADWNBUQ1jQaENY0HyDWNBQw5jQZQOY0HlDmNBNg9jQYcPY0HYD2NBKBBjQXkQY0HKEGNBGxFjQWwRY0G9EWNBDhJjQV4SY0GvEmNBABNjQVETY0GiE2NB8hNjQUMUY0GUFGNB5RRjQTYVY0GGFWNB1xVjQSgWY0F5FmNByhZjQRoXY0FrF2NBvBdjQQ0YY0FdGGNBrhhjQf8YY0FQGWNBoBljQfEZY0FCGmNBkhpjQeMaY0E0G2NBhRtjQdUbY0EmHGNBdxxjQcccY0EYHWNBaR1jQbkdY0EKHmNBWx5jQaseY0H8HmNBTR9jQZ0fY0HuH2NBPyBjQY8gY0HgIGNBMSFjQYEhY0HSIWNBIiJjQXMiY0HEImNBFCNjQWUjY0G1I2NBBiRjQVckY0GnJGNB+CRjQUglY0GZJWNB6SVjQTomY0GLJmNB2yZjQSwnY0F8J2NBzSdjQR0oY0FuKGNBvihjQQ8pY0FfKWNBsCljQQAqY0FRKmNBoSpjQfIqY0FCK2NBkytjQeMrY0E0LGNBhCxjQdUsY0ElLWNBdi1jQcYtY0EXLmNBZy5jQbcuY0EIL2NBWC9jQakvY0H5L2NBSjBjQZowY0HqMGNBOzFjQYsxY0HcMWNBLDJjQXwyY0HNMmNBHTNjQW4zY0G+M2NBDjRjQV80Y0GvNGNB/zRjQVA1Y0GgNWNB8DVjQUE2Y0GRNmNB4TZjQTI3Y0GCN2NB0jdjQSM4Y0FzOGNBwzhjQRQ5Y0FkOWNBtDljQQU6Y0FVOmNBpTpjQfU6Y0FGO2NBljtjQeY7Y0E2PGNBhzxjQdc8Y0EnPWNBdz1jQcg9Y0EYPmNBaD5jQbg+Y0EJP2NBWT9jQak/Y0H5P2NBSUBjQZpAY0HqQGNBOkFjQYpBY0HaQWNBK0JjQXtCY0HLQmNBG0NjQWtDY0G7Q2NBDERjQVxEY0GsRGNB/ERjQUxFY0GcRWNB7EVjQT1GY0GNRmNB3UZjQS1HY0F9R2NBzUdjQR1IY0FtSGNBvUhjQQ1JY0FeSWNBrkljQf5JY0FOSmNBnkpjQe5KY0E+S2NBjktjQd5LY0EuTGNBfkxjQc5MY0EeTWNBbk1jQb5NY0EOTmNBXk5jQa5OY0H+TmNBTk9jQZ5PY0HuT2NBPlBjQY5QY0HeUGNBLlFjQX5RY0HOUWNBHlJjQW5SY0G+UmNBDlNjQV5TY0GuU2NB/lNjQU5UY0GeVGNB7lRjQT1VY0GNVWNB3VVjQS1WY0F9VmNBzVZjQR1XY0FtV2NBvVdjQQ1YY0FcWGNBrFhjQfxYY0FMWWNBnFljQexZY0E8WmNBi1pjQdtaY0ErW2NBe1tjQctbY0EbXGNBalxjQbpcY0EKXWNBWl1jQapdY0H6XWNBSV5jQZleY0HpXmNBOV9jQYhfY0HYX2NBKGBjQXhgY0HIYGNBF2FjQWdhY0G3YWNBB2JjQVZiY0GmYmNB9mJjQUZjY0GVY2NB5WNjQTVkY0GEZGNB1GRjQSRlY0F0ZWNBw2VjQRNmY0FjZmNBsmZjQQJnY0FSZ2NBoWdjQfFnY0FBaGNBkGhjQeBoY0EwaWNBf2ljQc9pY0EfamNBbmpjQb5qY0ENa2NBXWtjQa1rY0H8a2NBTGxjQZxsY0HrbGNBO21jQYptY0HabWNBKW5jQXluY0HJbmNBGG9jQWhvY0G3b2NBB3BjQVZwY0GmcGNB9nBjQUVxY0GVcWNB5HFjQTRyY0GDcmNB03JjQSJzY0Fyc2NBwXNjQRF0Y0FgdGNBsHRjQf90Y0FPdWNBnnVjQe51Y0E9dmNBjXZjQdx2Y0Esd2NBe3djQct3Y0EaeGNBaXhjQbl4Y0EIeWNBWHljQad5Y0H3eWNBRnpjQZV6Y0HlemNBNHtjQYR7Y0HTe2NBInxjQXJ8Y0HBfGNBEX1jQWB9Y0GvfWNB/31jQU5+Y0GdfmNB7X5jQTx/Y0GMf2NB239jQSqAY0F6gGNByYBjQRiBY0FogWNBt4FjQQaCY0FVgmNBpYJjQfSCY0FDg2NBk4NjQeKDY0ExhGNBgYRjQdCEY0EfhWNBboVjQb6FY0ENhmNBXIZjQauGY0H7hmNBSodjQZmHY0Hoh2NBOIhjQYeIY0HWiGNBJYljQXWJY0HEiWNBE4pjQWKKY0GximNBAYtjQVCLY0Gfi2NB7otjQT2MY0GMjGNB3IxjQSuNY0F6jWNByY1jQRiOY0FnjmNBt45jQQaPY0FVj2NBpI9jQfOPY0FCkGNBkZBjQeGQY0EwkWNBf5FjQc6RY0EdkmNBbJJjQbuSY0EKk2NBWZNjQaiTY0H3k2NBR5RjQZaUY0HllGNBNJVjQYOVY0HSlWNBIZZjQXCWY0G/lmNBDpdjQV2XY0Gsl2NB+5djQUqYY0GZmGNB6JhjQTeZY0GGmWNB1ZljQSSaY0FzmmNBwppjQRGbY0Fgm2NBr5tjQf6bY0FNnGNBnJxjQeucY0E6nWNBiZ1jQdidY0EnnmNBdp5jQcWeY0ETn2NBYp9jQbGfY0EAoGNBT6BjQZ6gY0HtoGNBPKFjQYuhY0HaoWNBKaJjQXeiY0HGomNBFaNjQWSjY0Gzo2NBAqRjQVGkY0GfpGNB7qRjQT2lY0GMpWNB26VjQSqmY0F5pmNBx6ZjQRanY0Flp2NBtKdjQQOoY0FRqGNBoKhjQe+oY0E+qWNBjaljQdupY0EqqmNBeapjQciqY0EWq2NBZatjQbSrY0EDrGNBUaxjQaCsY0HvrGNBPq1jQYytY0HbrWNBKq5jQXmuY0HHrmNBFq9jQWWvY0Gzr2NBArBjQVGwY0GgsGNB7rBjQT2xY0GMsWNB2rFjQSmyY0F4smNBxrJjQRWzY0Fks2NBsrNjQQG0Y0FQtGNBnrRjQe20Y0E7tWNBirVjQdm1Y0EntmNBdrZjQcW2Y0ETt2NBYrdjQbC3Y0H/t2NBTrhjQZy4Y0HruGNBObljQYi5Y0HWuWNBJbpjQXS6Y0HCumNBEbtjQV+7Y0Guu2NB/LtjQUu8Y0GZvGNB6LxjQTe9Y0GFvWNB1L1jQSK+Y0FxvmNBv75jQQ6/Y0Fcv2NBq79jQfm/Y0FIwGNBlsBjQeXAY0EzwWNBgcFjQdDBY0EewmNBbcJjQbvCY0EKw2NBWMNjQafDY0H1w2NBRMRjQZLEY0HgxGNBL8VjQX3FY0HMxWNBGsZjQWjGY0G3xmNBBcdjQVTHY0Gix2NB8MdjQT/IY0GNyGNB3MhjQSrJY0F4yWNBx8ljQRXKY0FjymNBsspjQQDLY0FOy2NBnctjQevLY0E5zGNBiMxjQdbMY0EkzWNBc81jQcHNY0EPzmNBXs5jQazOY0H6zmNBSM9jQZfPY0Hlz2NBM9BjQYHQY0HQ0GNBHtFjQWzRY0G70WNBCdJjQVfSY0Gl0mNB9NJjQULTY0GQ02NB3tNjQSzUY0F71GNBydRjQRfVY0Fl1WNBs9VjQQLWY0FQ1mNBntZjQezWY0E612NBiddjQdfXY0El2GNBc9hjQcHYY0EP2WNBXtljQazZY0H62WNBSNpjQZbaY0Hk2mNBMttjQYHbY0HP22NBHdxjQWvcY0G53GNBB91jQVXdY0Gj3WNB8d1jQT/eY0GO3mNB3N5jQSrfY0F432NBxt9jQRTgY0Fi4GNBsOBjQf7gY0FM4WNBmuFjQejhY0E24mNBhOJjQdLiY0Eg42NBbuNjQbzjY0EK5GNBWORjQabkY0H05GNBQuVjQZDlY0He5WNBLOZjQXrmY0HI5mNBFudjQWTnY0Gy52NBAOhjQU7oY0Gc6GNB6uhjQTjpY0GG6WNB1OljQSLqY0Fw6mNBvupjQQzrY0FZ62NBp+tjQfXrY0FD7GNBkexjQd/sY0Et7WNBe+1jQcntY0EX7mNBZO5jQbLuY0EA72NBTu9jQZzvY0Hq72NBOPBjQYXwY0HT8GNBIfFjQW/xY0G98WNBC/JjQVjyY0Gm8mNB9PJjQULzY0GQ82NB3vNjQSv0Y0F59GNBx/RjQRX1Y0Fi9WNBsPVjQf71Y0FM9mNBmvZjQef2Y0E192NBg/djQdH3Y0Ee+GNBbPhjQbr4Y0EI+WNBVfljQaP5Y0Hx+WNBPvpjQYz6Y0Ha+mNBKPtjQXX7Y0HD+2NBEfxjQV78Y0Gs/GNB+vxjQUf9Y0GV/WNB4/1jQTD+Y0F+/mNBzP5jQRn/Y0Fn/2NBtf9jQQIAZEFQAGRBngBkQesAZEE5AWRBhwFkQdQBZEEiAmRBbwJkQb0CZEELA2RBWANkQaYDZEHzA2RBQQRkQY8EZEHcBGRBKgVkQXcFZEHFBWRBEgZkQWAGZEGuBmRB+wZkQUkHZEGWB2RB5AdkQTEIZEF/CGRBzAhkQRoJZEFnCWRBtQlkQQIKZEFQCmRBnQpkQesKZEE4C2RBhgtkQdMLZEEhDGRBbgxkQbwMZEEJDWRBVw1kQaQNZEHyDWRBPw5kQY0OZEHaDmRBKA9kQXUPZEHCD2RBEBBkQV0QZEGrEGRB+BBkQUYRZEGTEWRB4BFkQS4SZEF7EmRByRJkQRYTZEFjE2RBsRNkQf4TZEFLFGRBmRRkQeYUZEE0FWRBgRVkQc4VZEEcFmRBaRZkQbYWZEEEF2RBURdkQZ4XZEHsF2RBORhkQYYYZEHUGGRBIRlkQW4ZZEG8GWRBCRpkQVYaZEGjGmRB8RpkQT4bZEGLG2RB2RtkQSYcZEFzHGRBwBxkQQ4dZEFbHWRBqB1kQfUdZEFDHmRBkB5kQd0eZEEqH2RBeB9kQcUfZEESIGRBXyBkQa0gZEH6IGRBRyFkQZQhZEHhIWRBLyJkQXwiZEHJImRBFiNkQWMjZEGwI2RB/iNkQUskZEGYJGRB5SRkQTIlZEF/JWRBzSVkQRomZEFnJmRBtCZkQQEnZEFOJ2RBmydkQeknZEE2KGRBgyhkQdAoZEEdKWRBailkQbcpZEEEKmRBUSpkQZ4qZEHsKmRBOStkQYYrZEHTK2RBICxkQW0sZEG6LGRBBy1kQVQtZEGhLWRB7i1kQTsuZEGILmRB1S5kQSIvZEFvL2RBvC9kQQkwZEFWMGRBozBkQfAwZEE9MWRBijFkQdcxZEEkMmRBcTJkQb4yZEELM2RBWDNkQaUzZEHyM2RBPzRkQYw0ZEHZNGRBJjVkQXM1ZEHANWRBDTZkQVo2ZEGnNmRB9DZkQUE3ZEGNN2RB2jdkQSc4ZEF0OGRBwThkQQ45ZEFbOWRBqDlkQfU5ZEFCOmRBjjpkQds6ZEEoO2RBdTtkQcI7ZEEPPGRBXDxkQag8ZEH1PGRBQj1kQY89ZEHcPWRBKT5kQXU+ZEHCPmRBDz9kQVw/ZEGpP2RB9j9kQUJAZEGPQGRB3EBkQSlBZEF2QWRBwkFkQQ9CZEFcQmRBqUJkQfVCZEFCQ2RBj0NkQdxDZEEoRGRBdURkQcJEZEEPRWRBW0VkQahFZEH1RWRBQkZkQY5GZEHbRmRBKEdkQXVHZEHBR2RBDkhkQVtIZEGnSGRB9EhkQUFJZEGNSWRB2klkQSdKZEFzSmRBwEpkQQ1LZEFZS2RBpktkQfNLZEE/TGRBjExkQdlMZEElTWRBck1kQb9NZEELTmRBWE5kQaROZEHxTmRBPk9kQYpPZEHXT2RBI1BkQXBQZEG9UGRBCVFkQVZRZEGiUWRB71FkQTxSZEGIUmRB1VJkQSFTZEFuU2RBulNkQQdUZEFTVGRBoFRkQexUZEE5VWRBhlVkQdJVZEEfVmRBa1ZkQbhWZEEEV2RBUVdkQZ1XZEHqV2RBNlhkQYNYZEHPWGRBHFlkQWhZZEG1WWRBAVpkQU1aZEGaWmRB5lpkQTNbZEF/W2RBzFtkQRhcZEFlXGRBsVxkQf1cZEFKXWRBll1kQeNdZEEvXmRBfF5kQcheZEEUX2RBYV9kQa1fZEH6X2RBRmBkQZJgZEHfYGRBK2FkQXdhZEHEYWRBEGJkQV1iZEGpYmRB9WJkQUJjZEGOY2RB2mNkQSdkZEFzZGRBv2RkQQxlZEFYZWRBpGVkQfFlZEE9ZmRBiWZkQdZmZEEiZ2RBbmdkQbpnZEEHaGRBU2hkQZ9oZEHsaGRBOGlkQYRpZEHQaWRBHWpkQWlqZEG1amRBAWtkQU5rZEGaa2RB5mtkQTJsZEF/bGRBy2xkQRdtZEFjbWRBsG1kQfxtZEFIbmRBlG5kQeBuZEEtb2RBeW9kQcVvZEERcGRBXXBkQalwZEH2cGRBQnFkQY5xZEHacWRBJnJkQXJyZEG/cmRBC3NkQVdzZEGjc2RB73NkQTt0ZEGHdGRB1HRkQSB1ZEFsdWRBuHVkQQR2ZEFQdmRBnHZkQeh2ZEE0d2RBgHdkQc13ZEEZeGRBZXhkQbF4ZEH9eGRBSXlkQZV5ZEHheWRBLXpkQXl6ZEHFemRBEXtkQV17ZEGpe2RB9XtkQUF8ZEGNfGRB2XxkQSV9ZEFxfWRBvX1kQQl+ZEFVfmRBoX5kQe1+ZEE5f2RBhX9kQdF/ZEEdgGRBaYBkQbWAZEEBgWRBTYFkQZmBZEHlgWRBMYJkQX2CZEHJgmRBFYNkQWGDZEGtg2RB+YNkQUWEZEGRhGRB3YRkQSiFZEF0hWRBwIVkQQyGZEFYhmRBpIZkQfCGZEE8h2RBiIdkQdSHZEEfiGRBa4hkQbeIZEEDiWRBT4lkQZuJZEHniWRBMopkQX6KZEHKimRBFotkQWKLZEGui2RB+YtkQUWMZEGRjGRB3YxkQSmNZEF1jWRBwI1kQQyOZEFYjmRBpI5kQfCOZEE7j2RBh49kQdOPZEEfkGRBapBkQbaQZEECkWRBTpFkQZmRZEHlkWRBMZJkQX2SZEHIkmRBFJNkQWCTZEGsk2RB95NkQUOUZEGPlGRB2pRkQSaVZEFylWRBvpVkQQmWZEFVlmRBoZZkQeyWZEE4l2RBhJdkQc+XZEEbmGRBZ5hkQbKYZEH+mGRBSplkQZWZZEHhmWRBLZpkQXiaZEHEmmRBEJtkQVubZEGnm2RB8ptkQT6cZEGKnGRB1ZxkQSGdZEFsnWRBuJ1kQQSeZEFPnmRBm55kQeaeZEEyn2RBfp9kQcmfZEEVoGRBYKBkQaygZEH3oGRBQ6FkQY+hZEHaoWRBJqJkQXGiZEG9omRBCKNkQVSjZEGfo2RB66NkQTakZEGCpGRBzaRkQRmlZEFkpWRBsKVkQfulZEFHpmRBkqZkQd6mZEEpp2RBdadkQcCnZEEMqGRBV6hkQaOoZEHuqGRBOqlkQYWpZEHQqWRBHKpkQWeqZEGzqmRB/qpkQUqrZEGVq2RB4KtkQSysZEF3rGRBw6xkQQ6tZEFZrWRBpa1kQfCtZEE8rmRBh65kQdKuZEEer2RBaa9kQbWvZEEAsGRBS7BkQZewZEHisGRBLbFkQXmxZEHEsWRBD7JkQVuyZEGmsmRB8bJkQT2zZEGIs2RB07NkQR+0ZEFqtGRBtbRkQQG1ZEFMtWRBl7VkQeK1ZEEutmRBebZkQcS2ZEEQt2RBW7dkQaa3ZEHxt2RBPbhkQYi4ZEHTuGRBHrlkQWq5ZEG1uWRBALpkQUu6ZEGXumRB4rpkQS27ZEF4u2RBw7tkQQ+8ZEFavGRBpbxkQfC8ZEE7vWRBh71kQdK9ZEEdvmRBaL5kQbO+ZEH/vmRBSr9kQZW/ZEHgv2RBK8BkQXbAZEHCwGRBDcFkQVjBZEGjwWRB7sFkQTnCZEGEwmRBz8JkQRvDZEFmw2RBscNkQfzDZEFHxGRBksRkQd3EZEEoxWRBc8VkQb/FZEEKxmRBVcZkQaDGZEHrxmRBNsdkQYHHZEHMx2RBF8hkQWLIZEGtyGRB+MhkQUPJZEGOyWRB2clkQSTKZEFvymRBuspkQQXLZEFRy2RBnMtkQefLZEEyzGRBfcxkQcjMZEETzWRBXs1kQanNZEH0zWRBPs5kQYnOZEHUzmRBH89kQWrPZEG1z2RBANBkQUvQZEGW0GRB4dBkQSzRZEF30WRBwtFkQQ3SZEFY0mRBo9JkQe7SZEE502RBhNNkQc7TZEEZ1GRBZNRkQa/UZEH61GRBRdVkQZDVZEHb1WRBJtZkQXDWZEG71mRBBtdkQVHXZEGc12RB59dkQTLYZEF82GRBx9hkQRLZZEFd2WRBqNlkQfPZZEE+2mRBiNpkQdPaZEEe22RBadtkQbTbZEH+22RBSdxkQZTcZEHf3GRBKt1kQXTdZEG/3WRBCt5kQVXeZEGf3mRB6t5kQTXfZEGA32RBy99kQRXgZEFg4GRBq+BkQfbgZEFA4WRBi+FkQdbhZEEg4mRBa+JkQbbiZEEB42RBS+NkQZbjZEHh42RBK+RkQXbkZEHB5GRBDOVkQVblZEGh5WRB7OVkQTbmZEGB5mRBzOZkQRbnZEFh52RBrOdkQfbnZEFB6GRBjOhkQdboZEEh6WRBbOlkQbbpZEEB6mRBS+pkQZbqZEHh6mRBK+tkQXbrZEHA62RBC+xkQVbsZEGg7GRB6+xkQTXtZEGA7WRBy+1kQRXuZEFg7mRBqu5kQfXuZEE/72RBiu9kQdXvZEEf8GRBavBkQbTwZEH/8GRBSfFkQZTxZEHe8WRBKfJkQXPyZEG+8mRBCPNkQVPzZEGd82RB6PNkQTL0ZEF99GRBx/RkQRL1ZEFc9WRBp/VkQfH1ZEE89mRBhvZkQdH2ZEEb92RBZvdkQbD3ZEH792RBRfhkQZD4ZEHa+GRBJPlkQW/5ZEG5+WRBBPpkQU76ZEGZ+mRB4/pkQS37ZEF4+2RBwvtkQQ38ZEFX/GRBofxkQez8ZEE2/WRBgf1kQcv9ZEEV/mRBYP5kQar+ZEH0/mRBP/9kQYn/ZEHU/2RBHgBlQWgAZUGzAGVB/QBlQUcBZUGSAWVB3AFlQSYCZUFxAmVBuwJlQQUDZUFPA2VBmgNlQeQDZUEuBGVBeQRlQcMEZUENBWVBWAVlQaIFZUHsBWVBNgZlQYEGZUHLBmVBFQdlQV8HZUGqB2VB9AdlQT4IZUGICGVB0whlQR0JZUFnCWVBsQllQfwJZUFGCmVBkAplQdoKZUEkC2VBbwtlQbkLZUEDDGVBTQxlQZcMZUHiDGVBLA1lQXYNZUHADWVBCg5lQVUOZUGfDmVB6Q5lQTMPZUF9D2VBxw9lQRIQZUFcEGVBphBlQfAQZUE6EWVBhBFlQc4RZUEYEmVBYxJlQa0SZUH3EmVBQRNlQYsTZUHVE2VBHxRlQWkUZUGzFGVB/hRlQUgVZUGSFWVB3BVlQSYWZUFwFmVBuhZlQQQXZUFOF2VBmBdlQeIXZUEsGGVBdhhlQcAYZUEKGWVBVBllQZ4ZZUHoGWVBMhplQX0aZUHHGmVBERtlQVsbZUGlG2VB7xtlQTkcZUGDHGVBzRxlQRcdZUFhHWVBqh1lQfQdZUE+HmVBiB5lQdIeZUEcH2VBZh9lQbAfZUH6H2VBRCBlQY4gZUHYIGVBIiFlQWwhZUG2IWVBACJlQUoiZUGUImVB3iJlQScjZUFxI2VBuyNlQQUkZUFPJGVBmSRlQeMkZUEtJWVBdyVlQcAlZUEKJmVBVCZlQZ4mZUHoJmVBMidlQXwnZUHGJ2VBDyhlQVkoZUGjKGVB7ShlQTcpZUGBKWVByillQRQqZUFeKmVBqCplQfIqZUE7K2VBhStlQc8rZUEZLGVBYyxlQawsZUH2LGVBQC1lQYotZUHULWVBHS5lQWcuZUGxLmVB+y5lQUQvZUGOL2VB2C9lQSIwZUFrMGVBtTBlQf8wZUFJMWVBkjFlQdwxZUEmMmVBcDJlQbkyZUEDM2VBTTNlQZYzZUHgM2VBKjRlQXM0ZUG9NGVBBzVlQVE1ZUGaNWVB5DVlQS42ZUF3NmVBwTZlQQs3ZUFUN2VBnjdlQeg3ZUExOGVBezhlQcQ4ZUEOOWVBWDllQaE5ZUHrOWVBNTplQX46ZUHIOmVBETtlQVs7ZUGlO2VB7jtlQTg8ZUGBPGVByzxlQRU9ZUFePWVBqD1lQfE9ZUE7PmVBhT5lQc4+ZUEYP2VBYT9lQas/ZUH0P2VBPkBlQYdAZUHRQGVBG0FlQWRBZUGuQWVB90FlQUFCZUGKQmVB1EJlQR1DZUFnQ2VBsENlQfpDZUFDRGVBjURlQdZEZUEgRWVBaUVlQbNFZUH8RWVBRkZlQY9GZUHZRmVBIkdlQWtHZUG1R2VB/kdlQUhIZUGRSGVB20hlQSRJZUFuSWVBt0llQQBKZUFKSmVBk0plQd1KZUEmS2VBb0tlQblLZUECTGVBTExlQZVMZUHeTGVBKE1lQXFNZUG7TWVBBE5lQU1OZUGXTmVB4E5lQSlPZUFzT2VBvE9lQQZQZUFPUGVBmFBlQeJQZUErUWVBdFFlQb5RZUEHUmVBUFJlQZpSZUHjUmVBLFNlQXZTZUG/U2VBCFRlQVFUZUGbVGVB5FRlQS1VZUF3VWVBwFVlQQlWZUFSVmVBnFZlQeVWZUEuV2VBd1dlQcFXZUEKWGVBU1hlQZxYZUHmWGVBL1llQXhZZUHBWWVBC1plQVRaZUGdWmVB5lplQTBbZUF5W2VBwltlQQtcZUFUXGVBnlxlQedcZUEwXWVBeV1lQcJdZUELXmVBVV5lQZ5eZUHnXmVBMF9lQXlfZUHCX2VBDGBlQVVgZUGeYGVB52BlQTBhZUF5YWVBwmFlQQxiZUFVYmVBnmJlQediZUEwY2VBeWNlQcJjZUELZGVBVGRlQZ5kZUHnZGVBMGVlQXllZUHCZWVBC2ZlQVRmZUGdZmVB5mZlQS9nZUF4Z2VBwWdlQQpoZUFUaGVBnWhlQeZoZUEvaWVBeGllQcFpZUEKamVBU2plQZxqZUHlamVBLmtlQXdrZUHAa2VBCWxlQVJsZUGbbGVB5GxlQS1tZUF2bWVBv21lQQhuZUFRbmVBmm5lQeNuZUEsb2VBdW9lQb5vZUEHcGVBUHBlQZhwZUHhcGVBKnFlQXNxZUG8cWVBBXJlQU5yZUGXcmVB4HJlQSlzZUFyc2VBu3NlQQR0ZUFMdGVBlXRlQd50ZUEndWVBcHVlQbl1ZUECdmVBS3ZlQZR2ZUHcdmVBJXdlQW53ZUG3d2VBAHhlQUl4ZUGSeGVB2nhlQSN5ZUFseWVBtXllQf55ZUFHemVBj3plQdh6ZUEhe2VBantlQbN7ZUH8e2VBRHxlQY18ZUHWfGVBH31lQWh9ZUGwfWVB+X1lQUJ+ZUGLfmVB035lQRx/ZUFlf2VBrn9lQfZ/ZUE/gGVBiIBlQdGAZUEZgWVBYoFlQauBZUH0gWVBPIJlQYWCZUHOgmVBF4NlQV+DZUGog2VB8YNlQTmEZUGChGVBy4RlQRSFZUFchWVBpYVlQe6FZUE2hmVBf4ZlQciGZUEQh2VBWYdlQaKHZUHqh2VBM4hlQXyIZUHEiGVBDYllQVaJZUGeiWVB54llQS+KZUF4imVBwYplQQmLZUFSi2VBm4tlQeOLZUEsjGVBdIxlQb2MZUEGjWVBTo1lQZeNZUHfjWVBKI5lQXGOZUG5jmVBAo9lQUqPZUGTj2VB249lQSSQZUFtkGVBtZBlQf6QZUFGkWVBj5FlQdeRZUEgkmVBaJJlQbGSZUH5kmVBQpNlQYqTZUHTk2VBG5RlQWSUZUGslGVB9ZRlQT2VZUGGlWVBzpVlQReWZUFflmVBqJZlQfCWZUE5l2VBgZdlQcqXZUESmGVBW5hlQaOYZUHsmGVBNJllQX2ZZUHFmWVBDZplQVaaZUGemmVB55plQS+bZUF4m2VBwJtlQQicZUFRnGVBmZxlQeKcZUEqnWVBcp1lQbudZUEDnmVBTJ5lQZSeZUHcnmVBJZ9lQW2fZUG1n2VB/p9lQUagZUGPoGVB16BlQR+hZUFooWVBsKFlQfihZUFBomVBiaJlQdGiZUEao2VBYqNlQaqjZUHzo2VBO6RlQYOkZUHMpGVBFKVlQVylZUGkpWVB7aVlQTWmZUF9pmVBxqZlQQ6nZUFWp2VBnqdlQeenZUEvqGVBd6hlQb+oZUEIqWVBUKllQZipZUHgqWVBKaplQXGqZUG5qmVBAatlQUqrZUGSq2VB2qtlQSKsZUFrrGVBs6xlQfusZUFDrWVBi61lQdStZUEcrmVBZK5lQayuZUH0rmVBPK9lQYWvZUHNr2VBFbBlQV2wZUGlsGVB7bBlQTaxZUF+sWVBxrFlQQ6yZUFWsmVBnrJlQeayZUEvs2VBd7NlQb+zZUEHtGVBT7RlQZe0ZUHftGVBJ7VlQXC1ZUG4tWVBALZlQUi2ZUGQtmVB2LZlQSC3ZUFot2VBsLdlQfi3ZUFAuGVBiLhlQdG4ZUEZuWVBYbllQam5ZUHxuWVBObplQYG6ZUHJumVBEbtlQVm7ZUGhu2VB6btlQTG8ZUF5vGVBwbxlQQm9ZUFRvWVBmb1lQeG9ZUEpvmVBcb5lQbm+ZUEBv2VBSb9lQZG/ZUHZv2VBIcBlQWnAZUGxwGVB+cBlQUHBZUGJwWVB0cFlQRnCZUFhwmVBqcJlQfDCZUE4w2VBgMNlQcjDZUEQxGVBWMRlQaDEZUHoxGVBMMVlQXjFZUHAxWVBCMZlQU/GZUGXxmVB38ZlQSfHZUFvx2VBt8dlQf/HZUFHyGVBj8hlQdbIZUEeyWVBZsllQa7JZUH2yWVBPsplQYbKZUHNymVBFctlQV3LZUGly2VB7ctlQTXMZUF8zGVBxMxlQQzNZUFUzWVBnM1lQePNZUErzmVBc85lQbvOZUEDz2VBSs9lQZLPZUHaz2VBItBlQWrQZUGx0GVB+dBlQUHRZUGJ0WVB0NFlQRjSZUFg0mVBqNJlQe/SZUE302VBf9NlQcfTZUEO1GVBVtRlQZ7UZUHl1GVBLdVlQXXVZUG91WVBBNZlQUzWZUGU1mVB29ZlQSPXZUFr12VBs9dlQfrXZUFC2GVBithlQdHYZUEZ2WVBYdllQajZZUHw2WVBONplQX/aZUHH2mVBD9tlQVbbZUGe22VB5dtlQS3cZUF13GVBvNxlQQTdZUFM3WVBk91lQdvdZUEi3mVBat5lQbLeZUH53mVBQd9lQYjfZUHQ32VBGOBlQV/gZUGn4GVB7uBlQTbhZUF94WVBxeFlQQ3iZUFU4mVBnOJlQePiZUEr42VBcuNlQbrjZUEB5GVBSeRlQZDkZUHY5GVBIOVlQWflZUGv5WVB9uVlQT7mZUGF5mVBzeZlQRTnZUFc52VBo+dlQevnZUEy6GVBeuhlQcHoZUEI6WVBUOllQZfpZUHf6WVBJuplQW7qZUG16mVB/eplQUTrZUGM62VB0+tlQRvsZUFi7GVBqexlQfHsZUE47WVBgO1lQcftZUEP7mVBVu5lQZ3uZUHl7mVBLO9lQXTvZUG772VBAvBlQUrwZUGR8GVB2PBlQSDxZUFn8WVBr/FlQfbxZUE98mVBhfJlQczyZUET82VBW/NlQaLzZUHp82VBMfRlQXj0ZUG/9GVBB/VlQU71ZUGV9WVB3fVlQST2ZUFr9mVBs/ZlQfr2ZUFB92VBifdlQdD3ZUEX+GVBX/hlQab4ZUHt+GVBNPllQXz5ZUHD+WVBCvplQVH6ZUGZ+mVB4PplQSf7ZUFv+2VBtvtlQf37ZUFE/GVBjPxlQdP8ZUEa/WVBYf1lQaj9ZUHw/WVBN/5lQX7+ZUHF/mVBDf9lQVT/ZUGb/2VB4v9lQSkAZkFxAGZBuABmQf8AZkFGAWZBjQFmQdQBZkEcAmZBYwJmQaoCZkHxAmZBOANmQX8DZkHHA2ZBDgRmQVUEZkGcBGZB4wRmQSoFZkFxBWZBuQVmQQAGZkFHBmZBjgZmQdUGZkEcB2ZBYwdmQaoHZkHyB2ZBOQhmQYAIZkHHCGZBDglmQVUJZkGcCWZB4wlmQSoKZkFxCmZBuApmQf8KZkFHC2ZBjgtmQdULZkEcDGZBYwxmQaoMZkHxDGZBOA1mQX8NZkHGDWZBDQ5mQVQOZkGbDmZB4g5mQSkPZkFwD2ZBtw9mQf4PZkFFEGZBjBBmQdMQZkEaEWZBYRFmQagRZkHvEWZBNhJmQX0SZkHEEmZBCxNmQVITZkGZE2ZB4BNmQScUZkFuFGZBtRRmQfwUZkFDFWZBihVmQdAVZkEXFmZBXhZmQaUWZkHsFmZBMxdmQXoXZkHBF2ZBCBhmQU8YZkGWGGZB3RhmQSMZZkFqGWZBsRlmQfgZZkE/GmZBhhpmQc0aZkEUG2ZBWxtmQaEbZkHoG2ZBLxxmQXYcZkG9HGZBBB1mQUsdZkGRHWZB2B1mQR8eZkFmHmZBrR5mQfQeZkE6H2ZBgR9mQcgfZkEPIGZBViBmQZwgZkHjIGZBKiFmQXEhZkG4IWZB/iFmQUUiZkGMImZB0yJmQRojZkFgI2ZBpyNmQe4jZkE1JGZBeyRmQcIkZkEJJWZBUCVmQZYlZkHdJWZBJCZmQWsmZkGxJmZB+CZmQT8nZkGGJ2ZBzCdmQRMoZkFaKGZBoChmQecoZkEuKWZBdSlmQbspZkECKmZBSSpmQY8qZkHWKmZBHStmQWMrZkGqK2ZB8StmQTcsZkF+LGZBxSxmQQstZkFSLWZBmS1mQd8tZkEmLmZBbS5mQbMuZkH6LmZBQS9mQYcvZkHOL2ZBFDBmQVswZkGiMGZB6DBmQS8xZkF1MWZBvDFmQQMyZkFJMmZBkDJmQdYyZkEdM2ZBZDNmQaozZkHxM2ZBNzRmQX40ZkHENGZBCzVmQVI1ZkGYNWZB3zVmQSU2ZkFsNmZBsjZmQfk2ZkE/N2ZBhjdmQc03ZkETOGZBWjhmQaA4ZkHnOGZBLTlmQXQ5ZkG6OWZBATpmQUc6ZkGOOmZB1DpmQRs7ZkFhO2ZBqDtmQe47ZkE1PGZBezxmQcE8ZkEIPWZBTj1mQZU9ZkHbPWZBIj5mQWg+ZkGvPmZB9T5mQTw/ZkGCP2ZByD9mQQ9AZkFVQGZBnEBmQeJAZkEpQWZBb0FmQbVBZkH8QWZBQkJmQYlCZkHPQmZBFUNmQVxDZkGiQ2ZB6UNmQS9EZkF1RGZBvERmQQJFZkFIRWZBj0VmQdVFZkEcRmZBYkZmQahGZkHvRmZBNUdmQXtHZkHCR2ZBCEhmQU5IZkGVSGZB20hmQSFJZkFoSWZBrklmQfRJZkE7SmZBgUpmQcdKZkENS2ZBVEtmQZpLZkHgS2ZBJ0xmQW1MZkGzTGZB+kxmQUBNZkGGTWZBzE1mQRNOZkFZTmZBn05mQeVOZkEsT2ZBck9mQbhPZkH+T2ZBRVBmQYtQZkHRUGZBF1FmQV5RZkGkUWZB6lFmQTBSZkF2UmZBvVJmQQNTZkFJU2ZBj1NmQdVTZkEcVGZBYlRmQahUZkHuVGZBNFVmQXtVZkHBVWZBB1ZmQU1WZkGTVmZB2VZmQSBXZkFmV2ZBrFdmQfJXZkE4WGZBflhmQcRYZkELWWZBUVlmQZdZZkHdWWZBI1pmQWlaZkGvWmZB9VpmQTtbZkGCW2ZByFtmQQ5cZkFUXGZBmlxmQeBcZkEmXWZBbF1mQbJdZkH4XWZBPl5mQYVeZkHLXmZBEV9mQVdfZkGdX2ZB419mQSlgZkFvYGZBtWBmQftgZkFBYWZBh2FmQc1hZkETYmZBWWJmQZ9iZkHlYmZBK2NmQXFjZkG3Y2ZB/WNmQUNkZkGJZGZBz2RmQRVlZkFbZWZBoWVmQedlZkEtZmZBc2ZmQblmZkH/ZmZBRWdmQYtnZkHRZ2ZBF2hmQV1oZkGjaGZB6WhmQS9pZkF1aWZBu2lmQQFqZkFGamZBjGpmQdJqZkEYa2ZBXmtmQaRrZkHqa2ZBMGxmQXZsZkG8bGZBAm1mQUhtZkGNbWZB021mQRluZkFfbmZBpW5mQetuZkExb2ZBd29mQbxvZkECcGZBSHBmQY5wZkHUcGZBGnFmQWBxZkGlcWZB63FmQTFyZkF3cmZBvXJmQQNzZkFIc2ZBjnNmQdRzZkEadGZBYHRmQaV0ZkHrdGZBMXVmQXd1ZkG9dWZBAnZmQUh2ZkGOdmZB1HZmQRp3ZkFfd2ZBpXdmQet3ZkExeGZBdnhmQbx4ZkECeWZBSHlmQY15ZkHTeWZBGXpmQV96ZkGkemZB6npmQTB7ZkF2e2ZBu3tmQQF8ZkFHfGZBjHxmQdJ8ZkEYfWZBXn1mQaN9ZkHpfWZBL35mQXR+ZkG6fmZBAH9mQUV/ZkGLf2ZB0X9mQRaAZkFcgGZBooBmQeeAZkEtgWZBc4FmQbiBZkH+gWZBRIJmQYmCZkHPgmZBFYNmQVqDZkGgg2ZB5oNmQSuEZkFxhGZBtoRmQfyEZkFChWZBh4VmQc2FZkEShmZBWIZmQZ6GZkHjhmZBKYdmQW6HZkG0h2ZB+odmQT+IZkGFiGZByohmQRCJZkFViWZBm4lmQeGJZkEmimZBbIpmQbGKZkH3imZBPItmQYKLZkHHi2ZBDYxmQVKMZkGYjGZB3oxmQSONZkFpjWZBro1mQfSNZkE5jmZBf45mQcSOZkEKj2ZBT49mQZWPZkHaj2ZBIJBmQWWQZkGqkGZB8JBmQTWRZkF7kWZBwJFmQQaSZkFLkmZBkZJmQdaSZkEck2ZBYZNmQaeTZkHsk2ZBMZRmQXeUZkG8lGZBApVmQUeVZkGNlWZB0pVmQReWZkFdlmZBopZmQeiWZkEtl2ZBcpdmQbiXZkH9l2ZBQ5hmQYiYZkHNmGZBE5lmQViZZkGdmWZB45lmQSiaZkFummZBs5pmQfiaZkE+m2ZBg5tmQcibZkEOnGZBU5xmQZicZkHenGZBI51mQWidZkGunWZB851mQTieZkF+nmZBw55mQQifZkFOn2ZBk59mQdifZkEdoGZBY6BmQaigZkHtoGZBM6FmQXihZkG9oWZBAqJmQUiiZkGNomZB0qJmQRijZkFdo2ZBoqNmQeejZkEtpGZBcqRmQbekZkH8pGZBQaVmQYelZkHMpWZBEaZmQVamZkGcpmZB4aZmQSanZkFrp2ZBsKdmQfanZkE7qGZBgKhmQcWoZkEKqWZBUKlmQZWpZkHaqWZBH6pmQWSqZkGqqmZB76pmQTSrZkF5q2ZBvqtmQQOsZkFJrGZBjqxmQdOsZkEYrWZBXa1mQaKtZkHnrWZBLa5mQXKuZkG3rmZB/K5mQUGvZkGGr2ZBy69mQRCwZkFVsGZBm7BmQeCwZkElsWZBarFmQa+xZkH0sWZBObJmQX6yZkHDsmZBCLNmQU2zZkGSs2ZB2LNmQR20ZkFitGZBp7RmQey0ZkExtWZBdrVmQbu1ZkEAtmZBRbZmQYq2ZkHPtmZBFLdmQVm3ZkGet2ZB47dmQSi4ZkFtuGZBsrhmQfe4ZkE8uWZBgblmQca5ZkELumZBULpmQZW6ZkHaumZBH7tmQWS7ZkGpu2ZB7rtmQTO8ZkF4vGZBvbxmQQK9ZkFHvWZBjL1mQdG9ZkEWvmZBW75mQaC+ZkHlvmZBKb9mQW6/ZkGzv2ZB+L9mQT3AZkGCwGZBx8BmQQzBZkFRwWZBlsFmQdvBZkEgwmZBZMJmQanCZkHuwmZBM8NmQXjDZkG9w2ZBAsRmQUfEZkGLxGZB0MRmQRXFZkFaxWZBn8VmQeTFZkEpxmZBbcZmQbLGZkH3xmZBPMdmQYHHZkHGx2ZBCshmQU/IZkGUyGZB2chmQR7JZkFjyWZBp8lmQezJZkExymZBdspmQbvKZkH/ymZBRMtmQYnLZkHOy2ZBE8xmQVfMZkGczGZB4cxmQSbNZkFqzWZBr81mQfTNZkE5zmZBfc5mQcLOZkEHz2ZBTM9mQZDPZkHVz2ZBGtBmQV/QZkGj0GZB6NBmQS3RZkFy0WZBttFmQfvRZkFA0mZBhNJmQcnSZkEO02ZBU9NmQZfTZkHc02ZBIdRmQWXUZkGq1GZB79RmQTPVZkF41WZBvdVmQQHWZkFG1mZBi9ZmQc/WZkEU12ZBWddmQZ3XZkHi12ZBJ9hmQWvYZkGw2GZB9NhmQTnZZkF+2WZBwtlmQQfaZkFM2mZBkNpmQdXaZkEZ22ZBXttmQaPbZkHn22ZBLNxmQXDcZkG13GZB+txmQT7dZkGD3WZBx91mQQzeZkFQ3mZBld5mQdreZkEe32ZBY99mQaffZkHs32ZBMOBmQXXgZkG54GZB/uBmQUPhZkGH4WZBzOFmQRDiZkFV4mZBmeJmQd7iZkEi42ZBZ+NmQavjZkHw42ZBNORmQXnkZkG95GZBAuVmQUblZkGL5WZBz+VmQRTmZkFY5mZBneZmQeHmZkEm52ZBaudmQa7nZkHz52ZBN+hmQXzoZkHA6GZBBelmQUnpZkGO6WZB0ulmQRfqZkFb6mZBn+pmQeTqZkEo62ZBbetmQbHrZkH162ZBOuxmQX7sZkHD7GZBB+1mQUvtZkGQ7WZB1O1mQRnuZkFd7mZBoe5mQebuZkEq72ZBb+9mQbPvZkH372ZBPPBmQYDwZkHE8GZBCfFmQU3xZkGR8WZB1vFmQRryZkFe8mZBo/JmQefyZkEr82ZBcPNmQbTzZkH482ZBPfRmQYH0ZkHF9GZBCvVmQU71ZkGS9WZB1/VmQRv2ZkFf9mZBo/ZmQej2ZkEs92ZBcPdmQbX3ZkH592ZBPfhmQYH4ZkHG+GZBCvlmQU75ZkGS+WZB1/lmQRv6ZkFf+mZBo/pmQej6ZkEs+2ZBcPtmQbT7ZkH5+2ZBPfxmQYH8ZkHF/GZBCf1mQU79ZkGS/WZB1v1mQRr+ZkFe/mZBo/5mQef+ZkEr/2ZBb/9mQbP/ZkH4/2ZBPABnQYAAZ0HEAGdBCAFnQUwBZ0GRAWdB1QFnQRkCZ0FdAmdBoQJnQeUCZ0EqA2dBbgNnQbIDZ0H2A2dBOgRnQX4EZ0HCBGdBBgVnQUsFZ0GPBWdB0wVnQRcGZ0FbBmdBnwZnQeMGZ0EnB2dBawdnQbAHZ0H0B2dBOAhnQXwIZ0HACGdBBAlnQUgJZ0GMCWdB0AlnQRQKZ0FYCmdBnApnQeAKZ0EkC2dBaQtnQa0LZ0HxC2dBNQxnQXkMZ0G9DGdBAQ1nQUUNZ0GJDWdBzQ1nQREOZ0FVDmdBmQ5nQd0OZ0EhD2dBZQ9nQakPZ0HtD2dBMRBnQXUQZ0G5EGdB/RBnQUERZ0GFEWdByRFnQQ0SZ0FREmdBlRJnQdkSZ0EdE2dBYRNnQaUTZ0HoE2dBLBRnQXAUZ0G0FGdB+BRnQTwVZ0GAFWdBxBVnQQgWZ0FMFmdBkBZnQdQWZ0EYF2dBXBdnQZ8XZ0HjF2dBJxhnQWsYZ0GvGGdB8xhnQTcZZ0F7GWdBvxlnQQMaZ0FGGmdBihpnQc4aZ0ESG2dBVhtnQZobZ0HeG2dBIRxnQWUcZ0GpHGdB7RxnQTEdZ0F1HWdBuR1nQfwdZ0FAHmdBhB5nQcgeZ0EMH2dBUB9nQZMfZ0HXH2dBGyBnQV8gZ0GjIGdB5iBnQSohZ0FuIWdBsiFnQfYhZ0E5ImdBfSJnQcEiZ0EFI2dBSCNnQYwjZ0HQI2dBFCRnQVgkZ0GbJGdB3yRnQSMlZ0FnJWdBqiVnQe4lZ0EyJmdBdiZnQbkmZ0H9JmdBQSdnQYQnZ0HIJ2dBDChnQVAoZ0GTKGdB1yhnQRspZ0FeKWdBoilnQeYpZ0EqKmdBbSpnQbEqZ0H1KmdBOCtnQXwrZ0HAK2dBAyxnQUcsZ0GLLGdBzixnQRItZ0FWLWdBmS1nQd0tZ0EhLmdBZC5nQaguZ0HsLmdBLy9nQXMvZ0G2L2dB+i9nQT4wZ0GBMGdBxTBnQQkxZ0FMMWdBkDFnQdMxZ0EXMmdBWzJnQZ4yZ0HiMmdBJTNnQWkzZ0GtM2dB8DNnQTQ0Z0F3NGdBuzRnQf80Z0FCNWdBhjVnQck1Z0ENNmdBUDZnQZQ2Z0HXNmdBGzdnQV83Z0GiN2dB5jdnQSk4Z0FtOGdBsDhnQfQ4Z0E3OWdBezlnQb45Z0ECOmdBRTpnQYk6Z0HMOmdBEDtnQVM7Z0GXO2dB2jtnQR48Z0FhPGdBpTxnQeg8Z0EsPWdBbz1nQbM9Z0H2PWdBOj5nQX0+Z0HBPmdBBD9nQUc/Z0GLP2dBzj9nQRJAZ0FVQGdBmUBnQdxAZ0EgQWdBY0FnQaZBZ0HqQWdBLUJnQXFCZ0G0QmdB+EJnQTtDZ0F+Q2dBwkNnQQVEZ0FJRGdBjERnQc9EZ0ETRWdBVkVnQZlFZ0HdRWdBIEZnQWRGZ0GnRmdB6kZnQS5HZ0FxR2dBtEdnQfhHZ0E7SGdBf0hnQcJIZ0EFSWdBSUlnQYxJZ0HPSWdBE0pnQVZKZ0GZSmdB3UpnQSBLZ0FjS2dBpktnQepLZ0EtTGdBcExnQbRMZ0H3TGdBOk1nQX5NZ0HBTWdBBE5nQUdOZ0GLTmdBzk5nQRFPZ0FVT2dBmE9nQdtPZ0EeUGdBYlBnQaVQZ0HoUGdBK1FnQW9RZ0GyUWdB9VFnQThSZ0F8UmdBv1JnQQJTZ0FFU2dBiFNnQcxTZ0EPVGdBUlRnQZVUZ0HZVGdBHFVnQV9VZ0GiVWdB5VVnQSlWZ0FsVmdBr1ZnQfJWZ0E1V2dBeFdnQbxXZ0H/V2dBQlhnQYVYZ0HIWGdBDFlnQU9ZZ0GSWWdB1VlnQRhaZ0FbWmdBnlpnQeJaZ0ElW2dBaFtnQatbZ0HuW2dBMVxnQXRcZ0G3XGdB+1xnQT5dZ0GBXWdBxF1nQQdeZ0FKXmdBjV5nQdBeZ0ETX2dBVl9nQZpfZ0HdX2dBIGBnQWNgZ0GmYGdB6WBnQSxhZ0FvYWdBsmFnQfVhZ0E4YmdBe2JnQb5iZ0EBY2dBRGNnQYhjZ0HLY2dBDmRnQVFkZ0GUZGdB12RnQRplZ0FdZWdBoGVnQeNlZ0EmZmdBaWZnQaxmZ0HvZmdBMmdnQXVnZ0G4Z2dB+2dnQT5oZ0GBaGdBxGhnQQdpZ0FKaWdBjWlnQdBpZ0ETamdBVmpnQZlqZ0HbamdBHmtnQWFrZ0Gka2dB52tnQSpsZ0FtbGdBsGxnQfNsZ0E2bWdBeW1nQbxtZ0H/bWdBQm5nQYVuZ0HIbmdBCm9nQU1vZ0GQb2dB029nQRZwZ0FZcGdBnHBnQd9wZ0EicWdBZXFnQadxZ0HqcWdBLXJnQXByZ0GzcmdB9nJnQTlzZ0F7c2dBvnNnQQF0Z0FEdGdBh3RnQcp0Z0ENdWdBT3VnQZJ1Z0HVdWdBGHZnQVt2Z0GedmdB4HZnQSN3Z0Fmd2dBqXdnQex3Z0EueGdBcXhnQbR4Z0H3eGdBOnlnQXx5Z0G/eWdBAnpnQUV6Z0GIemdBynpnQQ17Z0FQe2dBk3tnQdV7Z0EYfGdBW3xnQZ58Z0HhfGdBI31nQWZ9Z0GpfWdB7H1nQS5+Z0FxfmdBtH5nQfZ+Z0E5f2dBfH9nQb9/Z0EBgGdBRIBnQYeAZ0HKgGdBDIFnQU+BZ0GSgWdB1IFnQReCZ0FagmdBnIJnQd+CZ0Eig2dBZINnQaeDZ0Hqg2dBLIRnQW+EZ0GyhGdB9IRnQTeFZ0F6hWdBvIVnQf+FZ0FChmdBhIZnQceGZ0EKh2dBTIdnQY+HZ0HSh2dBFIhnQVeIZ0GZiGdB3IhnQR+JZ0FhiWdBpIlnQeeJZ0EpimdBbIpnQa6KZ0HximdBNItnQXaLZ0G5i2dB+4tnQT6MZ0GAjGdBw4xnQQaNZ0FIjWdBi41nQc2NZ0EQjmdBUo5nQZWOZ0HYjmdBGo9nQV2PZ0Gfj2dB4o9nQSSQZ0FnkGdBqZBnQeyQZ0EukWdBcZFnQbORZ0H2kWdBOJJnQXuSZ0G9kmdBAJNnQUKTZ0GFk2dBx5NnQQqUZ0FMlGdBj5RnQdGUZ0EUlWdBVpVnQZmVZ0HblWdBHpZnQWCWZ0GjlmdB5ZZnQSiXZ0Fql2dBrZdnQe+XZ0ExmGdBdJhnQbaYZ0H5mGdBO5lnQX6ZZ0HAmWdBA5pnQUWaZ0GHmmdByppnQQybZ0FPm2dBkZtnQdObZ0EWnGdBWJxnQZucZ0HdnGdBH51nQWKdZ0GknWdB551nQSmeZ0FrnmdBrp5nQfCeZ0Eyn2dBdZ9nQbefZ0H6n2dBPKBnQX6gZ0HBoGdBA6FnQUWhZ0GIoWdByqFnQQyiZ0FPomdBkaJnQdOiZ0EWo2dBWKNnQZqjZ0Hdo2dBH6RnQWGkZ0GkpGdB5qRnQSilZ0FqpWdBraVnQe+lZ0ExpmdBdKZnQbamZ0H4pmdBOqdnQX2nZ0G/p2dBAahnQUSoZ0GGqGdByKhnQQqpZ0FNqWdBj6lnQdGpZ0ETqmdBVqpnQZiqZ0HaqmdBHKtnQV+rZ0Ghq2dB46tnQSWsZ0FnrGdBqqxnQeysZ0EurWdBcK1nQbKtZ0H1rWdBN65nQXmuZ0G7rmdB/a5nQUCvZ0GCr2dBxK9nQQawZ0FIsGdBi7BnQc2wZ0EPsWdBUbFnQZOxZ0HVsWdBGLJnQVqyZ0GcsmdB3rJnQSCzZ0Fis2dBpLNnQeezZ0EptGdBa7RnQa20Z0HvtGdBMbVnQXO1Z0G1tWdB+LVnQTq2Z0F8tmdBvrZnQQC3Z0FCt2dBhLdnQca3Z0EIuGdBSrhnQY24Z0HPuGdBEblnQVO5Z0GVuWdB17lnQRm6Z0FbumdBnbpnQd+6Z0Ehu2dBY7tnQaW7Z0Hnu2dBKbxnQWu8Z0GtvGdB8LxnQTK9Z0F0vWdBtr1nQfi9Z0E6vmdBfL5nQb6+Z0EAv2dBQr9nQYS/Z0HGv2dBCMBnQUrAZ0GMwGdBzsBnQRDBZ0FSwWdBlMFnQdbBZ0EYwmdBWsJnQZzCZ0HewmdBIMNnQWHDZ0Gjw2dB5cNnQSfEZ0FpxGdBq8RnQe3EZ0EvxWdBccVnQbPFZ0H1xWdBN8ZnQXnGZ0G7xmdB/cZnQT/HZ0GBx2dBwsdnQQTIZ0FGyGdBiMhnQcrIZ0EMyWdBTslnQZDJZ0HSyWdBFMpnQVXKZ0GXymdB2cpnQRvLZ0Fdy2dBn8tnQeHLZ0EjzGdBZMxnQabMZ0HozGdBKs1nQWzNZ0GuzWdB8M1nQTHOZ0FzzmdBtc5nQffOZ0E5z2dBe89nQbzPZ0H+z2dBQNBnQYLQZ0HE0GdBBdFnQUfRZ0GJ0WdBy9FnQQ3SZ0FO0mdBkNJnQdLSZ0EU02dBVtNnQZfTZ0HZ02dBG9RnQV3UZ0Ge1GdB4NRnQSLVZ0Fk1WdBptVnQefVZ0Ep1mdBa9ZnQa3WZ0Hu1mdBMNdnQXLXZ0G012dB9ddnQTfYZ0F52GdButhnQfzYZ0E+2WdBgNlnQcHZZ0ED2mdBRdpnQYbaZ0HI2mdBCttnQUzbZ0GN22dBz9tnQRHcZ0FS3GdBlNxnQdbcZ0EX3WdBWd1nQZvdZ0Hc3WdBHt5nQWDeZ0Gh3mdB495nQSXfZ0Fm32dBqN9nQerfZ0Er4GdBbeBnQa/gZ0Hw4GdBMuFnQXPhZ0G14WdB9+FnQTjiZ0F64mdBvOJnQf3iZ0E/42dBgONnQcLjZ0EE5GdBReRnQYfkZ0HI5GdBCuVnQUzlZ0GN5WdBz+VnQRDmZ0FS5mdBk+ZnQdXmZ0EX52dBWOdnQZrnZ0Hb52dBHehnQV7oZ0Gg6GdB4ehnQSPpZ0Fl6WdBpulnQejpZ0Ep6mdBa+pnQazqZ0Hu6mdBL+tnQXHrZ0Gy62dB9OtnQTXsZ0F37GdBuOxnQfrsZ0E77WdBfe1nQb7tZ0EA7mdBQe5nQYPuZ0HE7mdBBu9nQUfvZ0GJ72dByu9nQQzwZ0FN8GdBjvBnQdDwZ0ER8WdBU/FnQZTxZ0HW8WdBF/JnQVnyZ0Ga8mdB3PJnQR3zZ0Fe82dBoPNnQeHzZ0Ej9GdBZPRnQaX0Z0Hn9GdBKPVnQWr1Z0Gr9WdB7fVnQS72Z0Fv9mdBsfZnQfL2Z0Ez92dBdfdnQbb3Z0H492dBOfhnQXr4Z0G8+GdB/fhnQT75Z0GA+WdBwflnQQP6Z0FE+mdBhfpnQcf6Z0EI+2dBSftnQYv7Z0HM+2dBDfxnQU/8Z0GQ/GdB0fxnQRP9Z0FU/WdBlf1nQdf9Z0EY/mdBWf5nQZv+Z0Hc/mdBHf9nQV7/Z0Gg/2dB4f9nQSIAaEFkAGhBpQBoQeYAaEEnAWhBaQFoQaoBaEHrAWhBLAJoQW4CaEGvAmhB8AJoQTIDaEFzA2hBtANoQfUDaEE3BGhBeARoQbkEaEH6BGhBOwVoQX0FaEG+BWhB/wVoQUAGaEGCBmhBwwZoQQQHaEFFB2hBhgdoQcgHaEEJCGhBSghoQYsIaEHMCGhBDgloQU8JaEGQCWhB0QloQRIKaEFUCmhBlQpoQdYKaEEXC2hBWAtoQZkLaEHbC2hBHAxoQV0MaEGeDGhB3wxoQSANaEFhDWhBow1oQeQNaEElDmhBZg5oQacOaEHoDmhBKQ9oQWoPaEGsD2hB7Q9oQS4QaEFvEGhBsBBoQfEQaEEyEWhBcxFoQbQRaEH2EWhBNxJoQXgSaEG5EmhB+hJoQTsTaEF8E2hBvRNoQf4TaEE/FGhBgBRoQcEUaEECFWhBQxVoQYUVaEHGFWhBBxZoQUgWaEGJFmhByhZoQQsXaEFMF2hBjRdoQc4XaEEPGGhBUBhoQZEYaEHSGGhBExloQVQZaEGVGWhB1hloQRcaaEFYGmhBmRpoQdoaaEEbG2hBXBtoQZ0baEHeG2hBHxxoQWAcaEGhHGhB4hxoQSMdaEFkHWhBpR1oQeYdaEEnHmhBaB5oQakeaEHqHmhBKh9oQWsfaEGsH2hB7R9oQS4gaEFvIGhBsCBoQfEgaEEyIWhBcyFoQbQhaEH1IWhBNiJoQXciaEG3ImhB+CJoQTkjaEF6I2hBuyNoQfwjaEE9JGhBfiRoQb8kaEH/JGhBQCVoQYElaEHCJWhBAyZoQUQmaEGFJmhBxiZoQQYnaEFHJ2hBiCdoQcknaEEKKGhBSyhoQYwoaEHMKGhBDSloQU4paEGPKWhB0CloQREqaEFRKmhBkipoQdMqaEEUK2hBVStoQZUraEHWK2hBFyxoQVgsaEGZLGhB2SxoQRotaEFbLWhBnC1oQd0taEEdLmhBXi5oQZ8uaEHgLmhBIC9oQWEvaEGiL2hB4y9oQSQwaEFkMGhBpTBoQeYwaEEnMWhBZzFoQagxaEHpMWhBKjJoQWoyaEGrMmhB7DJoQSwzaEFtM2hBrjNoQe8zaEEvNGhBcDRoQbE0aEHxNGhBMjVoQXM1aEG0NWhB9DVoQTU2aEF2NmhBtjZoQfc2aEE4N2hBeDdoQbk3aEH6N2hBOjhoQXs4aEG8OGhB/DhoQT05aEF+OWhBvjloQf85aEFAOmhBgDpoQcE6aEECO2hBQjtoQYM7aEHEO2hBBDxoQUU8aEGFPGhBxjxoQQc9aEFHPWhBiD1oQck9aEEJPmhBSj5oQYo+aEHLPmhBDD9oQUw/aEGNP2hBzT9oQQ5AaEFOQGhBj0BoQdBAaEEQQWhBUUFoQZFBaEHSQWhBEkJoQVNCaEGUQmhB1EJoQRVDaEFVQ2hBlkNoQdZDaEEXRGhBV0RoQZhEaEHZRGhBGUVoQVpFaEGaRWhB20VoQRtGaEFcRmhBnEZoQd1GaEEdR2hBXkdoQZ5HaEHfR2hBH0hoQWBIaEGgSGhB4UhoQSFJaEFiSWhBokloQeNJaEEjSmhBZEpoQaRKaEHlSmhBJUtoQWVLaEGmS2hB5ktoQSdMaEFnTGhBqExoQehMaEEpTWhBaU1oQalNaEHqTWhBKk5oQWtOaEGrTmhB7E5oQSxPaEFsT2hBrU9oQe1PaEEuUGhBblBoQa9QaEHvUGhBL1FoQXBRaEGwUWhB8FFoQTFSaEFxUmhBslJoQfJSaEEyU2hBc1NoQbNTaEH0U2hBNFRoQXRUaEG1VGhB9VRoQTVVaEF2VWhBtlVoQfZVaEE3VmhBd1ZoQbdWaEH4VmhBOFdoQXhXaEG5V2hB+VdoQTlYaEF6WGhBulhoQfpYaEE7WWhBe1loQbtZaEH8WWhBPFpoQXxaaEG8WmhB/VpoQT1baEF9W2hBvltoQf5baEE+XGhBflxoQb9caEH/XGhBP11oQYBdaEHAXWhBAF5oQUBeaEGBXmhBwV5oQQFfaEFBX2hBgl9oQcJfaEECYGhBQmBoQYNgaEHDYGhBA2FoQUNhaEGDYWhBxGFoQQRiaEFEYmhBhGJoQcRiaEEFY2hBRWNoQYVjaEHFY2hBBWRoQUZkaEGGZGhBxmRoQQZlaEFGZWhBh2VoQcdlaEEHZmhBR2ZoQYdmaEHHZmhBCGdoQUhnaEGIZ2hByGdoQQhoaEFIaGhBiWhoQcloaEEJaWhBSWloQYlpaEHJaWhBCWpoQUlqaEGKamhBympoQQpraEFKa2hBimtoQcpraEEKbGhBSmxoQYpsaEHLbGhBC21oQUttaEGLbWhBy21oQQtuaEFLbmhBi25oQctuaEELb2hBS29oQYtvaEHMb2hBDHBoQUxwaEGMcGhBzHBoQQxxaEFMcWhBjHFoQcxxaEEMcmhBTHJoQYxyaEHMcmhBDHNoQUxzaEGMc2hBzHNoQQx0aEFMdGhBjHRoQcx0aEEMdWhBTHVoQYx1aEHMdWhBDHZoQUx2aEGMdmhBzHZoQQx3aEFMd2hBjHdoQcx3aEEMeGhBTHhoQYx4aEHMeGhBDHloQUx5aEGMeWhBzHloQQx6aEFMemhBjHpoQcx6aEEMe2hBTHtoQYx7aEHMe2hBC3xoQUt8aEGLfGhBy3xoQQt9aEFLfWhBi31oQct9aEELfmhBS35oQYt+aEHLfmhBCn9oQUp/aEGKf2hByn9oQQqAaEFKgGhBioBoQcqAaEEKgWhBSYFoQYmBaEHJgWhBCYJoQUmCaEGJgmhByYJoQQmDaEFIg2hBiINoQciDaEEIhGhBSIRoQYiEaEHHhGhBB4VoQUeFaEGHhWhBx4VoQQeGaEFGhmhBhoZoQcaGaEEGh2hBRodoQYaHaEHFh2hBBYhoQUWIaEGFiGhBxYhoQQSJaEFEiWhBhIloQcSJaEEDimhBQ4poQYOKaEHDimhBA4toQUKLaEGCi2hBwotoQQKMaEFBjGhBgYxoQcGMaEEBjWhBQI1oQYCNaEHAjWhBAI5oQT+OaEF/jmhBv45oQf+OaEE+j2hBfo9oQb6PaEH9j2hBPZBoQX2QaEG9kGhB/JBoQTyRaEF8kWhBu5FoQfuRaEE7kmhBe5JoQbqSaEH6kmhBOpNoQXmTaEG5k2hB+ZNoQTiUaEF4lGhBuJRoQfeUaEE3lWhBd5VoQbaVaEH2lWhBNpZoQXWWaEG1lmhB9ZZoQTSXaEF0l2hBs5doQfOXaEEzmGhBcphoQbKYaEHymGhBMZloQXGZaEGwmWhB8JloQTCaaEFvmmhBr5poQe6aaEEum2hBbptoQa2baEHtm2hBLJxoQWycaEGsnGhB65xoQSudaEFqnWhBqp1oQemdaEEpnmhBaZ5oQaieaEHonmhBJ59oQWefaEGmn2hB5p9oQSWgaEFloGhBpaBoQeSgaEEkoWhBY6FoQaOhaEHioWhBIqJoQWGiaEGhomhB4KJoQSCjaEFfo2hBn6NoQd6jaEEepGhBXaRoQZ2kaEHcpGhBHKVoQVulaEGbpWhB2qVoQRqmaEFZpmhBmaZoQdimaEEYp2hBV6doQZenaEHWp2hBFahoQVWoaEGUqGhB1KhoQROpaEFTqWhBkqloQdKpaEERqmhBUKpoQZCqaEHPqmhBD6toQU6raEGOq2hBzatoQQysaEFMrGhBi6xoQcusaEEKrWhBSa1oQYmtaEHIrWhBCK5oQUeuaEGGrmhBxq5oQQWvaEFFr2hBhK9oQcOvaEEDsGhBQrBoQYKwaEHBsGhBALFoQUCxaEF/sWhBvrFoQf6xaEE9smhBfLJoQbyyaEH7smhBOrNoQXqzaEG5s2hB+LNoQTi0aEF3tGhBtrRoQfa0aEE1tWhBdLVoQbS1aEHztWhBMrZoQXK2aEGxtmhB8LZoQS+3aEFvt2hBrrdoQe23aEEtuGhBbLhoQau4aEHquGhBKrloQWm5aEGouWhB6LloQSe6aEFmumhBpbpoQeW6aEEku2hBY7toQaK7aEHiu2hBIbxoQWC8aEGfvGhB37xoQR69aEFdvWhBnL1oQdu9aEEbvmhBWr5oQZm+aEHYvmhBGL9oQVe/aEGWv2hB1b9oQRTAaEFUwGhBk8BoQdLAaEERwWhBUMFoQZDBaEHPwWhBDsJoQU3CaEGMwmhBy8JoQQvDaEFKw2hBicNoQcjDaEEHxGhBRsRoQYbEaEHFxGhBBMVoQUPFaEGCxWhBwcVoQQDGaEFAxmhBf8ZoQb7GaEH9xmhBPMdoQXvHaEG6x2hB+cdoQTnIaEF4yGhBt8hoQfbIaEE1yWhBdMloQbPJaEHyyWhBMcpoQXHKaEGwymhB78poQS7LaEFty2hBrMtoQevLaEEqzGhBacxoQajMaEHnzGhBJs1oQWXNaEGkzWhB5M1oQSPOaEFizmhBoc5oQeDOaEEfz2hBXs9oQZ3PaEHcz2hBG9BoQVrQaEGZ0GhB2NBoQRfRaEFW0WhBldFoQdTRaEET0mhBUtJoQZHSaEHQ0mhBD9NoQU7TaEGN02hBzNNoQQvUaEFK1GhBidRoQcjUaEEH1WhBRtVoQYXVaEHE1WhBA9ZoQULWaEGB1mhBwNZoQf/WaEE+12hBfddoQbzXaEH612hBOdhoQXjYaEG32GhB9thoQTXZaEF02WhBs9loQfLZaEEx2mhBcNpoQa/aaEHu2mhBLdtoQWvbaEGq22hB6dtoQSjcaEFn3GhBptxoQeXcaEEk3WhBY91oQaLdaEHg3WhBH95oQV7eaEGd3mhB3N5oQRvfaEFa32hBmd9oQdffaEEW4GhBVeBoQZTgaEHT4GhBEuFoQVHhaEGP4WhBzuFoQQ3iaEFM4mhBi+JoQcriaEEI42hBR+NoQYbjaEHF42hBBORoQUPkaEGB5GhBwORoQf/kaEE+5WhBfeVoQbvlaEH65WhBOeZoQXjmaEG35mhB9eZoQTTnaEFz52hBsudoQfDnaEEv6GhBbuhoQa3oaEHs6GhBKuloQWnpaEGo6WhB5+loQSXqaEFk6mhBo+poQeLqaEEg62hBX+toQZ7raEHd62hBG+xoQVrsaEGZ7GhB1+xoQRbtaEFV7WhBlO1oQdLtaEER7mhBUO5oQY7uaEHN7mhBDO9oQUvvaEGJ72hByO9oQQfwaEFF8GhBhPBoQcPwaEEB8WhBQPFoQX/xaEG98WhB/PFoQTvyaEF58mhBuPJoQffyaEE182hBdPNoQbPzaEHx82hBMPRoQW/0aEGt9GhB7PRoQSv1aEFp9WhBqPVoQeb1aEEl9mhBZPZoQaL2aEHh9mhBIPdoQV73aEGd92hB2/doQRr4aEFZ+GhBl/hoQdb4aEEU+WhBU/loQZL5aEHQ+WhBD/poQU36aEGM+mhByvpoQQn7aEFI+2hBhvtoQcX7aEED/GhBQvxoQYD8aEG//GhB/vxoQTz9aEF7/WhBuf1oQfj9aEE2/mhBdf5oQbP+aEHy/mhBMP9oQW//aEGt/2hB7P9oQSsAaUFpAGlBqABpQeYAaUElAWlBYwFpQaIBaUHgAWlBHwJpQV0CaUGcAmlB2gJpQRkDaUFXA2lBlgNpQdQDaUETBGlBUQRpQY8EaUHOBGlBDAVpQUsFaUGJBWlByAVpQQYGaUFFBmlBgwZpQcIGaUEAB2lBPwdpQX0HaUG7B2lB+gdpQTgIaUF3CGlBtQhpQfQIaUEyCWlBcAlpQa8JaUHtCWlBLAppQWoKaUGoCmlB5wppQSULaUFkC2lBogtpQeALaUEfDGlBXQxpQZwMaUHaDGlBGA1pQVcNaUGVDWlB1A1pQRIOaUFQDmlBjw5pQc0OaUELD2lBSg9pQYgPaUHGD2lBBRBpQUMQaUGCEGlBwBBpQf4QaUE9EWlBexFpQbkRaUH4EWlBNhJpQXQSaUGzEmlB8RJpQS8TaUFuE2lBrBNpQeoTaUEoFGlBZxRpQaUUaUHjFGlBIhVpQWAVaUGeFWlB3RVpQRsWaUFZFmlBlxZpQdYWaUEUF2lBUhdpQZEXaUHPF2lBDRhpQUsYaUGKGGlByBhpQQYZaUFEGWlBgxlpQcEZaUH/GWlBPRppQXwaaUG6GmlB+BppQTYbaUF1G2lBsxtpQfEbaUEvHGlBbRxpQawcaUHqHGlBKB1pQWYdaUGlHWlB4x1pQSEeaUFfHmlBnR5pQdweaUEaH2lBWB9pQZYfaUHUH2lBEiBpQVEgaUGPIGlBzSBpQQshaUFJIWlBiCFpQcYhaUEEImlBQiJpQYAiaUG+ImlB/CJpQTsjaUF5I2lBtyNpQfUjaUEzJGlBcSRpQa8kaUHuJGlBLCVpQWolaUGoJWlB5iVpQSQmaUFiJmlBoCZpQd8maUEdJ2lBWydpQZknaUHXJ2lBFShpQVMoaUGRKGlBzyhpQQ0paUFMKWlBiilpQcgpaUEGKmlBRCppQYIqaUHAKmlB/ippQTwraUF6K2lBuCtpQfYraUE0LGlBcixpQbAsaUHvLGlBLS1pQWstaUGpLWlB5y1pQSUuaUFjLmlBoS5pQd8uaUEdL2lBWy9pQZkvaUHXL2lBFTBpQVMwaUGRMGlBzzBpQQ0xaUFLMWlBiTFpQccxaUEFMmlBQzJpQYEyaUG/MmlB/TJpQTszaUF5M2lBtzNpQfUzaUEzNGlBcTRpQa80aUHtNGlBKzVpQWk1aUGnNWlB5TVpQSM2aUFgNmlBnjZpQdw2aUEaN2lBWDdpQZY3aUHUN2lBEjhpQVA4aUGOOGlBzDhpQQo5aUFIOWlBhjlpQcM5aUEBOmlBPzppQX06aUG7OmlB+TppQTc7aUF1O2lBsztpQfE7aUEuPGlBbDxpQao8aUHoPGlBJj1pQWQ9aUGiPWlB4D1pQR0+aUFbPmlBmT5pQdc+aUEVP2lBUz9pQZE/aUHPP2lBDEBpQUpAaUGIQGlBxkBpQQRBaUFCQWlBf0FpQb1BaUH7QWlBOUJpQXdCaUG1QmlB8kJpQTBDaUFuQ2lBrENpQepDaUEnRGlBZURpQaNEaUHhRGlBH0VpQVxFaUGaRWlB2EVpQRZGaUFURmlBkUZpQc9GaUENR2lBS0dpQYhHaUHGR2lBBEhpQUJIaUF/SGlBvUhpQftIaUE5SWlBdklpQbRJaUHySWlBMEppQW1KaUGrSmlB6UppQSdLaUFkS2lBoktpQeBLaUEeTGlBW0xpQZlMaUHXTGlBFE1pQVJNaUGQTWlBzk1pQQtOaUFJTmlBh05pQcROaUECT2lBQE9pQX1PaUG7T2lB+U9pQTZQaUF0UGlBslBpQe9QaUEtUWlBa1FpQahRaUHmUWlBJFJpQWFSaUGfUmlB3VJpQRpTaUFYU2lBllNpQdNTaUERVGlBT1RpQYxUaUHKVGlBB1VpQUVVaUGDVWlBwFVpQf5VaUE8VmlBeVZpQbdWaUH0VmlBMldpQXBXaUGtV2lB61dpQShYaUFmWGlBpFhpQeFYaUEfWWlBXFlpQZpZaUHYWWlBFVppQVNaaUGQWmlBzlppQQtbaUFJW2lBh1tpQcRbaUECXGlBP1xpQX1caUG6XGlB+FxpQTVdaUFzXWlBsF1pQe5daUEsXmlBaV5pQadeaUHkXmlBIl9pQV9faUGdX2lB2l9pQRhgaUFVYGlBk2BpQdBgaUEOYWlBS2FpQYlhaUHGYWlBBGJpQUFiaUF/YmlBvGJpQfpiaUE3Y2lBdWNpQbJjaUHwY2lBLWRpQWtkaUGoZGlB5WRpQSNlaUFgZWlBnmVpQdtlaUEZZmlBVmZpQZRmaUHRZmlBD2dpQUxnaUGJZ2lBx2dpQQRoaUFCaGlBf2hpQb1oaUH6aGlBN2lpQXVpaUGyaWlB8GlpQS1qaUFqamlBqGppQeVqaUEja2lBYGtpQZ1raUHba2lBGGxpQVZsaUGTbGlB0GxpQQ5taUFLbWlBiG1pQcZtaUEDbmlBQW5pQX5uaUG7bmlB+W5pQTZvaUFzb2lBsW9pQe5vaUErcGlBaXBpQaZwaUHjcGlBIXFpQV5xaUGbcWlB2XFpQRZyaUFTcmlBkXJpQc5yaUELc2lBSXNpQYZzaUHDc2lBAXRpQT50aUF7dGlBuXRpQfZ0aUEzdWlBcHVpQa51aUHrdWlBKHZpQWZ2aUGjdmlB4HZpQR13aUFbd2lBmHdpQdV3aUESeGlBUHhpQY14aUHKeGlBCHlpQUV5aUGCeWlBv3lpQf15aUE6emlBd3ppQbR6aUHxemlBL3tpQWx7aUGpe2lB5ntpQSR8aUFhfGlBnnxpQdt8aUEYfWlBVn1pQZN9aUHQfWlBDX5pQUp+aUGIfmlBxX5pQQJ/aUE/f2lBfH9pQbp/aUH3f2lBNIBpQXGAaUGugGlB7IBpQSmBaUFmgWlBo4FpQeCBaUEdgmlBW4JpQZiCaUHVgmlBEoNpQU+DaUGMg2lByYNpQQeEaUFEhGlBgYRpQb6EaUH7hGlBOIVpQXWFaUGyhWlB8IVpQS2GaUFqhmlBp4ZpQeSGaUEhh2lBXodpQZuHaUHYh2lBFohpQVOIaUGQiGlBzYhpQQqJaUFHiWlBhIlpQcGJaUH+iWlBO4ppQXiKaUG1imlB84ppQTCLaUFti2lBqotpQeeLaUEkjGlBYYxpQZ6MaUHbjGlBGI1pQVWNaUGSjWlBz41pQQyOaUFJjmlBho5pQcOOaUEAj2lBPY9pQXqPaUG3j2lB9I9pQTGQaUFukGlBq5BpQeiQaUElkWlBYpFpQZ+RaUHckWlBGZJpQVaSaUGTkmlB0JJpQQ2TaUFKk2lBh5NpQcSTaUEBlGlBPpRpQXuUaUG4lGlB9ZRpQTKVaUFvlWlBrJVpQemVaUEmlmlBY5ZpQaCWaUHdlmlBGpdpQVeXaUGUl2lB0ZdpQQ6YaUFLmGlBh5hpQcSYaUEBmWlBPplpQXuZaUG4mWlB9ZlpQTKaaUFvmmlBrJppQemaaUElm2lBYptpQZ+baUHcm2lBGZxpQVacaUGTnGlB0JxpQQ2daUFKnWlBhp1pQcOdaUEAnmlBPZ5pQXqeaUG3nmlB9J5pQTCfaUFtn2lBqp9pQeefaUEkoGlBYaBpQZ6gaUHaoGlBF6FpQVShaUGRoWlBzqFpQQuiaUFHomlBhKJpQcGiaUH+omlBO6NpQXijaUG0o2lB8aNpQS6kaUFrpGlBqKRpQeSkaUEhpWlBXqVpQZulaUHYpWlBFKZpQVGmaUGOpmlBy6ZpQQenaUFEp2lBgadpQb6naUH7p2lBN6hpQXSoaUGxqGlB7qhpQSqpaUFnqWlBpKlpQeGpaUEdqmlBWqppQZeqaUHUqmlBEKtpQU2raUGKq2lBx6tpQQOsaUFArGlBfaxpQbmsaUH2rGlBM61pQXCtaUGsrWlB6a1pQSauaUFirmlBn65pQdyuaUEZr2lBVa9pQZKvaUHPr2lBC7BpQUiwaUGFsGlBwbBpQf6waUE7sWlBd7FpQbSxaUHxsWlBLbJpQWqyaUGnsmlB47JpQSCzaUFds2lBmbNpQdazaUETtGlBT7RpQYy0aUHJtGlBBbVpQUK1aUF+tWlBu7VpQfi1aUE0tmlBcbZpQa62aUHqtmlBJ7dpQWO3aUGgt2lB3bdpQRm4aUFWuGlBkrhpQc+4aUEMuWlBSLlpQYW5aUHBuWlB/rlpQTu6aUF3umlBtLppQfC6aUEtu2lBabtpQaa7aUHju2lBH7xpQVy8aUGYvGlB1bxpQRG9aUFOvWlBir1pQce9aUEEvmlBQL5pQX2+aUG5vmlB9r5pQTK/aUFvv2lBq79pQei/aUEkwGlBYcBpQZ3AaUHawGlBFsFpQVPBaUGPwWlBzMFpQQjCaUFFwmlBgcJpQb7CaUH6wmlBN8NpQXPDaUGww2lB7MNpQSnEaUFlxGlBosRpQd7EaUEbxWlBV8VpQZTFaUHQxWlBDcZpQUnGaUGFxmlBwsZpQf7GaUE7x2lBd8dpQbTHaUHwx2lBLchpQWnIaUGlyGlB4shpQR7JaUFbyWlBl8lpQdTJaUEQymlBTMppQYnKaUHFymlBAstpQT7LaUF7y2lBt8tpQfPLaUEwzGlBbMxpQanMaUHlzGlBIc1pQV7NaUGazWlB1s1pQRPOaUFPzmlBjM5pQcjOaUEEz2lBQc9pQX3PaUG5z2lB9s9pQTLQaUFu0GlBq9BpQefQaUEk0WlBYNFpQZzRaUHZ0WlBFdJpQVHSaUGO0mlBytJpQQbTaUFD02lBf9NpQbvTaUH402lBNNRpQXDUaUGs1GlB6dRpQSXVaUFh1WlBntVpQdrVaUEW1mlBU9ZpQY/WaUHL1mlBB9dpQUTXaUGA12lBvNdpQfnXaUE12GlBcdhpQa3YaUHq2GlBJtlpQWLZaUGe2WlB29lpQRfaaUFT2mlBj9ppQczaaUEI22lBRNtpQYDbaUG922lB+dtpQTXcaUFx3GlBrtxpQercaUEm3WlBYt1pQZ/daUHb3WlBF95pQVPeaUGP3mlBzN5pQQjfaUFE32lBgN9pQbzfaUH532lBNeBpQXHgaUGt4GlB6eBpQSbhaUFi4WlBnuFpQdrhaUEW4mlBUuJpQY/iaUHL4mlBB+NpQUPjaUF/42lBu+NpQfjjaUE05GlBcORpQazkaUHo5GlBJOVpQWDlaUGd5WlB2eVpQRXmaUFR5mlBjeZpQcnmaUEF52lBQudpQX7naUG652lB9udpQTLoaUFu6GlBquhpQeboaUEi6WlBX+lpQZvpaUHX6WlBE+ppQU/qaUGL6mlBx+ppQQPraUE/62lBe+tpQbfraUHz62lBMOxpQWzsaUGo7GlB5OxpQSDtaUFc7WlBmO1pQdTtaUEQ7mlBTO5pQYjuaUHE7mlBAO9pQTzvaUF472lBtO9pQfDvaUEs8GlBaPBpQaTwaUHh8GlBHfFpQVnxaUGV8WlB0fFpQQ3yaUFJ8mlBhfJpQcHyaUH98mlBOfNpQXXzaUGx82lB7fNpQSn0aUFl9GlBofRpQd30aUEZ9WlBVfVpQZD1aUHM9WlBCPZpQUT2aUGA9mlBvPZpQfj2aUE092lBcPdpQaz3aUHo92lBJPhpQWD4aUGc+GlB2PhpQRT5aUFQ+WlBjPlpQcj5aUEE+mlBQPppQXv6aUG3+mlB8/ppQS/7aUFr+2lBp/tpQeP7aUEf/GlBW/xpQZf8aUHT/GlBD/1pQUr9aUGG/WlBwv1pQf79aUE6/mlBdv5pQbL+aUHu/mlBKv9pQWX/aUGh/2lB3f9pQRkAakFVAGpBkQBqQc0AakEIAWpBRAFqQYABakG8AWpB+AFqQTQCakFwAmpBqwJqQecCakEjA2pBXwNqQZsDakHXA2pBEgRqQU4EakGKBGpBxgRqQQIFakE+BWpBeQVqQbUFakHxBWpBLQZqQWkGakGkBmpB4AZqQRwHakFYB2pBlAdqQc8HakELCGpBRwhqQYMIakG/CGpB+ghqQTYJakFyCWpBrglqQekJakElCmpBYQpqQZ0KakHYCmpBFAtqQVALakGMC2pByAtqQQMMakE/DGpBewxqQbcMakHyDGpBLg1qQWoNakGlDWpB4Q1qQR0OakFZDmpBlA5qQdAOakEMD2pBSA9qQYMPakG/D2pB+w9qQTYQakFyEGpBrhBqQekQakElEWpBYRFqQZ0RakHYEWpBFBJqQVASakGLEmpBxxJqQQMTakE+E2pBehNqQbYTakHxE2pBLRRqQWkUakGkFGpB4BRqQRwVakFXFWpBkxVqQc8VakEKFmpBRhZqQYIWakG9FmpB+RZqQTQXakFwF2pBrBdqQecXakEjGGpBXxhqQZoYakHWGGpBERlqQU0ZakGJGWpBxBlqQQAaakE8GmpBdxpqQbMaakHuGmpBKhtqQWYbakGhG2pB3RtqQRgcakFUHGpBjxxqQcscakEHHWpBQh1qQX4dakG5HWpB9R1qQTAeakFsHmpBqB5qQeMeakEfH2pBWh9qQZYfakHRH2pBDSBqQUggakGEIGpBwCBqQfsgakE3IWpBciFqQa4hakHpIWpBJSJqQWAiakGcImpB1yJqQRMjakFOI2pBiiNqQcUjakEBJGpBPCRqQXgkakGzJGpB7yRqQSolakFmJWpBoSVqQd0lakEYJmpBVCZqQY8makHLJmpBBidqQUInakF9J2pBuSdqQfQnakEwKGpBayhqQacoakHiKGpBHSlqQVkpakGUKWpB0ClqQQsqakFHKmpBgipqQb4qakH5KmpBNCtqQXArakGrK2pB5ytqQSIsakFeLGpBmSxqQdQsakEQLWpBSy1qQYctakHCLWpB/i1qQTkuakF0LmpBsC5qQesuakEnL2pBYi9qQZ0vakHZL2pBFDBqQU8wakGLMGpBxjBqQQIxakE9MWpBeDFqQbQxakHvMWpBKjJqQWYyakGhMmpB3TJqQRgzakFTM2pBjzNqQcozakEFNGpBQTRqQXw0akG3NGpB8zRqQS41akFpNWpBpTVqQeA1akEbNmpBVzZqQZI2akHNNmpBCTdqQUQ3akF/N2pBuzdqQfY3akExOGpBbDhqQag4akHjOGpBHjlqQVo5akGVOWpB0DlqQQs6akFHOmpBgjpqQb06akH5OmpBNDtqQW87akGqO2pB5jtqQSE8akFcPGpBlzxqQdM8akEOPWpBST1qQYQ9akHAPWpB+z1qQTY+akFxPmpBrT5qQeg+akEjP2pBXj9qQZo/akHVP2pBEEBqQUtAakGHQGpBwkBqQf1AakE4QWpBc0FqQa9BakHqQWpBJUJqQWBCakGbQmpB10JqQRJDakFNQ2pBiENqQcNDakH/Q2pBOkRqQXVEakGwRGpB60RqQSZFakFiRWpBnUVqQdhFakETRmpBTkZqQYlGakHFRmpBAEdqQTtHakF2R2pBsUdqQexHakEoSGpBY0hqQZ5IakHZSGpBFElqQU9JakGKSWpBxUlqQQFKakE8SmpBd0pqQbJKakHtSmpBKEtqQWNLakGeS2pB2ktqQRVMakFQTGpBi0xqQcZMakEBTWpBPE1qQXdNakGyTWpB7U1qQSlOakFkTmpBn05qQdpOakEVT2pBUE9qQYtPakHGT2pBAVBqQTxQakF3UGpBslBqQe1QakEoUWpBY1FqQZ5RakHaUWpBFVJqQVBSakGLUmpBxlJqQQFTakE8U2pBd1NqQbJTakHtU2pBKFRqQWNUakGeVGpB2VRqQRRVakFPVWpBilVqQcVVakEAVmpBO1ZqQXZWakGxVmpB7FZqQSdXakFiV2pBnVdqQdhXakETWGpBTlhqQYlYakHEWGpB/1hqQTpZakF1WWpBsFlqQetZakEmWmpBYVpqQZxaakHXWmpBEltqQU1bakGHW2pBwltqQf1bakE4XGpBc1xqQa5cakHpXGpBJF1qQV9dakGaXWpB1V1qQRBeakFLXmpBhl5qQcFeakH7XmpBNl9qQXFfakGsX2pB519qQSJgakFdYGpBmGBqQdNgakEOYWpBSWFqQYNhakG+YWpB+WFqQTRiakFvYmpBqmJqQeViakEgY2pBWmNqQZVjakHQY2pBC2RqQUZkakGBZGpBvGRqQfZkakExZWpBbGVqQadlakHiZWpBHWZqQVhmakGSZmpBzWZqQQhnakFDZ2pBfmdqQblnakHzZ2pBLmhqQWloakGkaGpB32hqQRppakFUaWpBj2lqQcppakEFampBQGpqQXpqakG1ampB8GpqQStrakFma2pBoGtqQdtrakEWbGpBUWxqQYtsakHGbGpBAW1qQTxtakF3bWpBsW1qQextakEnbmpBYm5qQZxuakHXbmpBEm9qQU1vakGHb2pBwm9qQf1vakE4cGpBcnBqQa1wakHocGpBI3FqQV1xakGYcWpB03FqQQ5yakFIcmpBg3JqQb5yakH4cmpBM3NqQW5zakGpc2pB43NqQR50akFZdGpBk3RqQc50akEJdWpBRHVqQX51akG5dWpB9HVqQS52akFpdmpBpHZqQd52akEZd2pBVHdqQY53akHJd2pBBHhqQT54akF5eGpBtHhqQe54akEpeWpBZHlqQZ55akHZeWpBFHpqQU56akGJempBxHpqQf56akE5e2pBc3tqQa57akHpe2pBI3xqQV58akGZfGpB03xqQQ59akFIfWpBg31qQb59akH4fWpBM35qQW1+akGofmpB435qQR1/akFYf2pBkn9qQc1/akEIgGpBQoBqQX2AakG3gGpB8oBqQS2BakFngWpBooFqQdyBakEXgmpBUYJqQYyCakHGgmpBAYNqQTyDakF2g2pBsYNqQeuDakEmhGpBYIRqQZuEakHVhGpBEIVqQUuFakGFhWpBwIVqQfqFakE1hmpBb4ZqQaqGakHkhmpBH4dqQVmHakGUh2pBzodqQQmIakFDiGpBfohqQbiIakHziGpBLYlqQWiJakGiiWpB3YlqQReKakFSimpBjIpqQceKakEBi2pBPItqQXaLakGxi2pB64tqQSaMakFgjGpBmoxqQdWMakEPjWpBSo1qQYSNakG/jWpB+Y1qQTSOakFujmpBqY5qQeOOakEdj2pBWI9qQZKPakHNj2pBB5BqQUKQakF8kGpBtpBqQfGQakErkWpBZpFqQaCRakHbkWpBFZJqQU+SakGKkmpBxJJqQf+SakE5k2pBc5NqQa6TakHok2pBIpRqQV2UakGXlGpB0pRqQQyVakFGlWpBgZVqQbuVakH2lWpBMJZqQWqWakGllmpB35ZqQRmXakFUl2pBjpdqQciXakEDmGpBPZhqQXeYakGymGpB7JhqQSaZakFhmWpBm5lqQdWZakEQmmpBSppqQYSaakG/mmpB+ZpqQTObakFum2pBqJtqQeKbakEdnGpBV5xqQZGcakHMnGpBBp1qQUCdakF7nWpBtZ1qQe+dakEpnmpBZJ5qQZ6eakHYnmpBE59qQU2fakGHn2pBwZ9qQfyfakE2oGpBcKBqQaqgakHloGpBH6FqQVmhakGToWpBzqFqQQiiakFCompBfKJqQbeiakHxompBK6NqQWWjakGgo2pB2qNqQRSkakFOpGpBiaRqQcOkakH9pGpBN6VqQXGlakGspWpB5qVqQSCmakFapmpBlaZqQc+makEJp2pBQ6dqQX2nakG4p2pB8qdqQSyoakFmqGpBoKhqQdqoakEVqWpBT6lqQYmpakHDqWpB/alqQTiqakFyqmpBrKpqQeaqakEgq2pBWqtqQZWrakHPq2pBCaxqQUOsakF9rGpBt6xqQfGsakEsrWpBZq1qQaCtakHarWpBFK5qQU6uakGIrmpBw65qQf2uakE3r2pBca9qQauvakHlr2pBH7BqQVmwakGTsGpBzrBqQQixakFCsWpBfLFqQbaxakHwsWpBKrJqQWSyakGesmpB2LJqQROzakFNs2pBh7NqQcGzakH7s2pBNbRqQW+0akGptGpB47RqQR21akFXtWpBkbVqQcu1akEFtmpBP7ZqQXm2akG0tmpB7rZqQSi3akFit2pBnLdqQda3akEQuGpBSrhqQYS4akG+uGpB+LhqQTK5akFsuWpBprlqQeC5akEaumpBVLpqQY66akHIumpBArtqQTy7akF2u2pBsLtqQeq7akEkvGpBXrxqQZi8akHSvGpBDL1qQUa9akGAvWpBur1qQfS9akEuvmpBaL5qQaK+akHcvmpBFr9qQVC/akGKv2pBxL9qQf6/akE4wGpBcsBqQavAakHlwGpBH8FqQVnBakGTwWpBzcFqQQfCakFBwmpBe8JqQbXCakHvwmpBKcNqQWPDakGdw2pB18NqQRDEakFKxGpBhMRqQb7EakH4xGpBMsVqQWzFakGmxWpB4MVqQRrGakFUxmpBjcZqQcfGakEBx2pBO8dqQXXHakGvx2pB6cdqQSPIakFcyGpBlshqQdDIakEKyWpBRMlqQX7JakG4yWpB8slqQSvKakFlympBn8pqQdnKakETy2pBTctqQYfLakHAy2pB+stqQTTMakFuzGpBqMxqQeLMakEbzWpBVc1qQY/NakHJzWpBA85qQTzOakF2zmpBsM5qQerOakEkz2pBXs9qQZfPakHRz2pBC9BqQUXQakF/0GpBuNBqQfLQakEs0WpBZtFqQZ/RakHZ0WpBE9JqQU3SakGH0mpBwNJqQfrSakE002pBbtNqQafTakHh02pBG9RqQVXUakGO1GpByNRqQQLVakE81WpBddVqQa/VakHp1WpBI9ZqQVzWakGW1mpB0NZqQQrXakFD12pBfddqQbfXakHx12pBKthqQWTYakGe2GpB19hqQRHZakFL2WpBhdlqQb7ZakH42WpBMtpqQWvaakGl2mpB39pqQRjbakFS22pBjNtqQcbbakH/22pBOdxqQXPcakGs3GpB5txqQSDdakFZ3WpBk91qQc3dakEG3mpBQN5qQXreakGz3mpB7d5qQSffakFg32pBmt9qQdPfakEN4GpBR+BqQYDgakG64GpB9OBqQS3hakFn4WpBoeFqQdrhakEU4mpBTeJqQYfiakHB4mpB+uJqQTTjakFu42pBp+NqQeHjakEa5GpBVORqQY7kakHH5GpBAeVqQTrlakF05WpBreVqQeflakEh5mpBWuZqQZTmakHN5mpBB+dqQUHnakF652pBtOdqQe3nakEn6GpBYOhqQZroakHU6GpBDelqQUfpakGA6WpBuulqQfPpakEt6mpBZupqQaDqakHZ6mpBE+tqQU3rakGG62pBwOtqQfnrakEz7GpBbOxqQabsakHf7GpBGe1qQVLtakGM7WpBxe1qQf/takE47mpBcu5qQavuakHl7mpBHu9qQVjvakGR72pBy+9qQQTwakE+8GpBd/BqQbHwakHq8GpBJPFqQV3xakGX8WpB0PFqQQryakFD8mpBfPJqQbbyakHv8mpBKfNqQWLzakGc82pB1fNqQQ/0akFI9GpBgvRqQbv0akH09GpBLvVqQWf1akGh9WpB2vVqQRT2akFN9mpBhvZqQcD2akH59mpBM/dqQWz3akGm92pB3/dqQRj4akFS+GpBi/hqQcX4akH++GpBN/lqQXH5akGq+WpB5PlqQR36akFW+mpBkPpqQcn6akEC+2pBPPtqQXX7akGv+2pB6PtqQSH8akFb/GpBlPxqQc38akEH/WpBQP1qQXr9akGz/WpB7P1qQSb+akFf/mpBmP5qQdL+akEL/2pBRP9qQX7/akG3/2pB8P9qQSoAa0FjAGtBnABrQdYAa0EPAWtBSAFrQYIBa0G7AWtB9AFrQS4Ca0FnAmtBoAJrQdkCa0ETA2tBTANrQYUDa0G/A2tB+ANrQTEEa0FrBGtBpARrQd0Ea0EWBWtBUAVrQYkFa0HCBWtB/AVrQTUGa0FuBmtBpwZrQeEGa0EaB2tBUwdrQYwHa0HGB2tB/wdrQTgIa0FxCGtBqwhrQeQIa0EdCWtBVglrQZAJa0HJCWtBAgprQTsKa0F1CmtBrgprQecKa0EgC2tBWQtrQZMLa0HMC2tBBQxrQT4Ma0F4DGtBsQxrQeoMa0EjDWtBXA1rQZYNa0HPDWtBCA5rQUEOa0F6DmtBtA5rQe0Oa0EmD2tBXw9rQZgPa0HRD2tBCxBrQUQQa0F9EGtBthBrQe8Qa0EoEWtBYhFrQZsRa0HUEWtBDRJrQUYSa0F/EmtBuRJrQfISa0ErE2tBZBNrQZ0Ta0HWE2tBDxRrQUkUa0GCFGtBuxRrQfQUa0EtFWtBZhVrQZ8Va0HYFWtBEhZrQUsWa0GEFmtBvRZrQfYWa0EvF2tBaBdrQaEXa0HaF2tBFBhrQU0Ya0GGGGtBvxhrQfgYa0ExGWtBahlrQaMZa0HcGWtBFRprQU4aa0GIGmtBwRprQfoaa0EzG2tBbBtrQaUba0HeG2tBFxxrQVAca0GJHGtBwhxrQfsca0E0HWtBbR1rQaYda0HfHWtBGB5rQVIea0GLHmtBxB5rQf0ea0E2H2tBbx9rQagfa0HhH2tBGiBrQVMga0GMIGtBxSBrQf4ga0E3IWtBcCFrQakha0HiIWtBGyJrQVQia0GNImtBxiJrQf8ia0E4I2tBcSNrQaoja0HjI2tBHCRrQVUka0GOJGtBxyRrQQAla0E5JWtBciVrQasla0HkJWtBHSZrQVYma0GOJmtBxyZrQQAna0E5J2tBcidrQasna0HkJ2tBHShrQVYoa0GPKGtByChrQQEpa0E6KWtBcylrQawpa0HlKWtBHiprQVYqa0GPKmtByCprQQEra0E6K2tBcytrQawra0HlK2tBHixrQVcsa0GQLGtByCxrQQEta0E6LWtBcy1rQawta0HlLWtBHi5rQVcua0GQLmtByC5rQQEva0E6L2tBcy9rQawva0HlL2tBHjBrQVcwa0GPMGtByDBrQQExa0E6MWtBczFrQawxa0HlMWtBHTJrQVYya0GPMmtByDJrQQEza0E6M2tBcjNrQasza0HkM2tBHTRrQVY0a0GPNGtBxzRrQQA1a0E5NWtBcjVrQas1a0HkNWtBHDZrQVU2a0GONmtBxzZrQQA3a0E4N2tBcTdrQao3a0HjN2tBHDhrQVQ4a0GNOGtBxjhrQf84a0E3OWtBcDlrQak5a0HiOWtBGzprQVM6a0GMOmtBxTprQf46a0E2O2tBbztrQag7a0HhO2tBGTxrQVI8a0GLPGtBxDxrQfw8a0E1PWtBbj1rQac9a0HfPWtBGD5rQVE+a0GKPmtBwj5rQfs+a0E0P2tBbD9rQaU/a0HeP2tBF0BrQU9Aa0GIQGtBwUBrQflAa0EyQWtBa0FrQaRBa0HcQWtBFUJrQU5Ca0GGQmtBv0JrQfhCa0EwQ2tBaUNrQaJDa0HaQ2tBE0RrQUxEa0GERGtBvURrQfZEa0EuRWtBZ0VrQaBFa0HYRWtBEUZrQUpGa0GCRmtBu0ZrQfRGa0EsR2tBZUdrQZ5Ha0HWR2tBD0hrQUhIa0GASGtBuUhrQfFIa0EqSWtBY0lrQZtJa0HUSWtBDUprQUVKa0F+SmtBtkprQe9Ka0EoS2tBYEtrQZlLa0HRS2tBCkxrQUNMa0F7TGtBtExrQexMa0ElTWtBXk1rQZZNa0HPTWtBB05rQUBOa0F5TmtBsU5rQepOa0EiT2tBW09rQZNPa0HMT2tBBFBrQT1Qa0F2UGtBrlBrQedQa0EfUWtBWFFrQZBRa0HJUWtBAVJrQTpSa0FzUmtBq1JrQeRSa0EcU2tBVVNrQY1Ta0HGU2tB/lNrQTdUa0FvVGtBqFRrQeBUa0EZVWtBUVVrQYpVa0HCVWtB+1VrQTNWa0FsVmtBpFZrQd1Wa0EVV2tBTldrQYZXa0G/V2tB91drQTBYa0FoWGtBoVhrQdlYa0ESWWtBSllrQYNZa0G7WWtB9FlrQSxaa0FlWmtBnVprQdVaa0EOW2tBRltrQX9ba0G3W2tB8FtrQShca0FhXGtBmVxrQdFca0EKXWtBQl1rQXtda0GzXWtB7F1rQSRea0FcXmtBlV5rQc1ea0EGX2tBPl9rQXdfa0GvX2tB519rQSBga0FYYGtBkWBrQclga0EBYWtBOmFrQXJha0GrYWtB42FrQRtia0FUYmtBjGJrQcVia0H9YmtBNWNrQW5ja0GmY2tB3mNrQRdka0FPZGtBiGRrQcBka0H4ZGtBMWVrQWlla0GhZWtB2mVrQRJma0FKZmtBg2ZrQbtma0HzZmtBLGdrQWRna0GcZ2tB1WdrQQ1oa0FFaGtBfmhrQbZoa0HuaGtBJ2lrQV9pa0GXaWtB0GlrQQhqa0FAamtBeWprQbFqa0HpamtBImtrQVpra0GSa2tBymtrQQNsa0E7bGtBc2xrQaxsa0HkbGtBHG1rQVRta0GNbWtBxW1rQf1ta0E2bmtBbm5rQaZua0HebmtBF29rQU9va0GHb2tBv29rQfhva0EwcGtBaHBrQaBwa0HZcGtBEXFrQUlxa0GBcWtBunFrQfJxa0EqcmtBYnJrQZtya0HTcmtBC3NrQUNza0F7c2tBtHNrQexza0EkdGtBXHRrQZV0a0HNdGtBBXVrQT11a0F1dWtBrnVrQeZ1a0EedmtBVnZrQY52a0HHdmtB/3ZrQTd3a0Fvd2tBp3drQeB3a0EYeGtBUHhrQYh4a0HAeGtB+HhrQTF5a0FpeWtBoXlrQdl5a0ERemtBSXprQYJ6a0G6emtB8nprQSp7a0Fie2tBmntrQdJ7a0ELfGtBQ3xrQXt8a0GzfGtB63xrQSN9a0FbfWtBk31rQcx9a0EEfmtBPH5rQXR+a0GsfmtB5H5rQRx/a0FUf2tBjX9rQcV/a0H9f2tBNYBrQW2Aa0GlgGtB3YBrQRWBa0FNgWtBhYFrQb6Ba0H2gWtBLoJrQWaCa0GegmtB1oJrQQ6Da0FGg2tBfoNrQbaDa0Hug2tBJoRrQV6Ea0GWhGtBz4RrQQeFa0E/hWtBd4VrQa+Fa0HnhWtBH4ZrQVeGa0GPhmtBx4ZrQf+Ga0E3h2tBb4drQaeHa0Hfh2tBF4hrQU+Ia0GHiGtBv4hrQfeIa0EviWtBZ4lrQZ+Ja0HXiWtBD4prQUeKa0F/imtBt4prQe+Ka0Eni2tBX4trQZeLa0HPi2tBB4xrQT+Ma0F3jGtBr4xrQeeMa0EfjWtBV41rQY+Na0HHjWtB/41rQTeOa0FvjmtBp45rQd+Oa0EXj2tBT49rQYePa0G/j2tB949rQS+Qa0FnkGtBn5BrQdeQa0EPkWtBRpFrQX6Ra0G2kWtB7pFrQSaSa0FekmtBlpJrQc6Sa0EGk2tBPpNrQXaTa0Guk2tB5pNrQR2Ua0FVlGtBjZRrQcWUa0H9lGtBNZVrQW2Va0GllWtB3ZVrQRWWa0FNlmtBhJZrQbyWa0H0lmtBLJdrQWSXa0Gcl2tB1JdrQQyYa0FDmGtBe5hrQbOYa0HrmGtBI5lrQVuZa0GTmWtBy5lrQQKaa0E6mmtBcpprQaqaa0HimmtBGptrQVGba0GJm2tBwZtrQfmba0ExnGtBaZxrQaGca0HYnGtBEJ1rQUida0GAnWtBuJ1rQe+da0EnnmtBX55rQZeea0HPnmtBB59rQT6fa0F2n2tBrp9rQeafa0EeoGtBVaBrQY2ga0HFoGtB/aBrQTWha0FsoWtBpKFrQdyha0EUomtBS6JrQYOia0G7omtB86JrQSuja0Fio2tBmqNrQdKja0EKpGtBQaRrQXmka0GxpGtB6aRrQSCla0FYpWtBkKVrQcila0H/pWtBN6ZrQW+ma0GnpmtB3qZrQRana0FOp2tBhqdrQb2na0H1p2tBLahrQWSoa0GcqGtB1KhrQQypa0FDqWtBe6lrQbOpa0HqqWtBIqprQVqqa0GSqmtByaprQQGra0E5q2tBcKtrQaira0Hgq2tBF6xrQU+sa0GHrGtBvqxrQfasa0EurWtBZq1rQZ2ta0HVrWtBDa5rQUSua0F8rmtBtK5rQeuua0Ejr2tBWq9rQZKva0HKr2tBAbBrQTmwa0FxsGtBqLBrQeCwa0EYsWtBT7FrQYexa0G/sWtB9rFrQS6ya0FlsmtBnbJrQdWya0EMs2tBRLNrQXyza0Gzs2tB67NrQSK0a0FatGtBkrRrQcm0a0EBtWtBOLVrQXC1a0GotWtB37VrQRe2a0FOtmtBhrZrQb62a0H1tmtBLbdrQWS3a0Gct2tB1LdrQQu4a0FDuGtBerhrQbK4a0HpuGtBIblrQVi5a0GQuWtByLlrQf+5a0E3umtBbrprQaa6a0HdumtBFbtrQUy7a0GEu2tBvLtrQfO7a0ErvGtBYrxrQZq8a0HRvGtBCb1rQUC9a0F4vWtBr71rQee9a0EevmtBVr5rQY2+a0HFvmtB/L5rQTS/a0Frv2tBo79rQdq/a0ESwGtBScBrQYHAa0G4wGtB8MBrQSfBa0FfwWtBlsFrQc7Ba0EFwmtBPcJrQXTCa0GswmtB48JrQRvDa0FSw2tBisNrQcHDa0H5w2tBMMRrQWfEa0GfxGtB1sRrQQ7Fa0FFxWtBfcVrQbTFa0HsxWtBI8ZrQVvGa0GSxmtBycZrQQHHa0E4x2tBcMdrQafHa0Hfx2tBFshrQU3Ia0GFyGtBvMhrQfTIa0EryWtBYslrQZrJa0HRyWtBCcprQUDKa0F4ymtBr8prQebKa0Eey2tBVctrQYzLa0HEy2tB+8trQTPMa0FqzGtBocxrQdnMa0EQzWtBSM1rQX/Na0G2zWtB7s1rQSXOa0FczmtBlM5rQcvOa0ECz2tBOs9rQXHPa0Gpz2tB4M9rQRfQa0FP0GtBhtBrQb3Qa0H10GtBLNFrQWPRa0Gb0WtB0tFrQQnSa0FB0mtBeNJrQa/Sa0Hn0mtBHtNrQVXTa0GN02tBxNNrQfvTa0Ey1GtBatRrQaHUa0HY1GtBENVrQUfVa0F+1WtBttVrQe3Va0Ek1mtBW9ZrQZPWa0HK1mtBAddrQTnXa0Fw12tBp9drQd7Xa0EW2GtBTdhrQYTYa0G82GtB89hrQSrZa0Fh2WtBmdlrQdDZa0EH2mtBPtprQXbaa0Gt2mtB5NprQRvba0FT22tBittrQcHba0H422tBMNxrQWfca0Ge3GtB1dxrQQzda0FE3WtBe91rQbLda0Hp3WtBId5rQVjea0GP3mtBxt5rQf3ea0E132tBbN9rQaPfa0Ha32tBEeBrQUnga0GA4GtBt+BrQe7ga0El4WtBXeFrQZTha0HL4WtBAuJrQTnia0Fx4mtBqOJrQd/ia0EW42tBTeNrQYTja0G842tB8+NrQSrka0Fh5GtBmORrQc/ka0EH5WtBPuVrQXXla0Gs5WtB4+VrQRrma0FR5mtBieZrQcDma0H35mtBLudrQWXna0Gc52tB0+drQQroa0FC6GtBeehrQbDoa0Hn6GtBHulrQVXpa0GM6WtBw+lrQfrpa0Ey6mtBaeprQaDqa0HX6mtBDutrQUXra0F862tBs+trQerra0Eh7GtBWexrQZDsa0HH7GtB/uxrQTXta0Fs7WtBo+1rQdrta0ER7mtBSO5rQX/ua0G27mtB7e5rQSTva0Fc72tBk+9rQcrva0EB8GtBOPBrQW/wa0Gm8GtB3fBrQRTxa0FL8WtBgvFrQbnxa0Hw8WtBJ/JrQV7ya0GV8mtBzPJrQQPza0E682tBcfNrQajza0Hf82tBFvRrQU30a0GE9GtBu/RrQfL0a0Ep9WtBYPVrQZf1a0HO9WtBBfZrQTz2a0Fz9mtBqvZrQeH2a0EY92tBT/drQYb3a0G992tB9PdrQSv4a0Fi+GtBmfhrQdD4a0EH+WtBPvlrQXX5a0Gs+WtB4/lrQRr6a0FR+mtBiPprQb/6a0H2+mtBLftrQWT7a0Ga+2tB0ftrQQj8a0E//GtBdvxrQa38a0Hk/GtBG/1rQVL9a0GJ/WtBwP1rQff9a0Eu/mtBZf5rQZv+a0HS/mtBCf9rQUD/a0F3/2tBrv9rQeX/a0EcAGxBUwBsQYoAbEHAAGxB9wBsQS4BbEFlAWxBnAFsQdMBbEEKAmxBQQJsQXgCbEGuAmxB5QJsQRwDbEFTA2xBigNsQcEDbEH4A2xBLwRsQWUEbEGcBGxB0wRsQQoFbEFBBWxBeAVsQa8FbEHlBWxBHAZsQVMGbEGKBmxBwQZsQfgGbEEuB2xBZQdsQZwHbEHTB2xBCghsQUEIbEF3CGxBrghsQeUIbEEcCWxBUwlsQYkJbEHACWxB9wlsQS4KbEFlCmxBnApsQdIKbEEJC2xBQAtsQXcLbEGuC2xB5AtsQRsMbEFSDGxBiQxsQb8MbEH2DGxBLQ1sQWQNbEGbDWxB0Q1sQQgObEE/DmxBdg5sQawObEHjDmxBGg9sQVEPbEGHD2xBvg9sQfUPbEEsEGxBYhBsQZkQbEHQEGxBBxFsQT0RbEF0EWxBqxFsQeIRbEEYEmxBTxJsQYYSbEG9EmxB8xJsQSoTbEFhE2xBlxNsQc4TbEEFFGxBPBRsQXIUbEGpFGxB4BRsQRYVbEFNFWxBhBVsQbsVbEHxFWxBKBZsQV8WbEGVFmxBzBZsQQMXbEE5F2xBcBdsQacXbEHdF2xBFBhsQUsYbEGCGGxBuBhsQe8YbEEmGWxBXBlsQZMZbEHKGWxBABpsQTcabEFtGmxBpBpsQdsabEERG2xBSBtsQX8bbEG1G2xB7BtsQSMcbEFZHGxBkBxsQcccbEH9HGxBNB1sQWodbEGhHWxB2B1sQQ4ebEFFHmxBfB5sQbIebEHpHmxBHx9sQVYfbEGNH2xBwx9sQfofbEEwIGxBZyBsQZ4gbEHUIGxBCyFsQUEhbEF4IWxBryFsQeUhbEEcImxBUiJsQYkibEHAImxB9iJsQS0jbEFjI2xBmiNsQdAjbEEHJGxBPiRsQXQkbEGrJGxB4SRsQRglbEFOJWxBhSVsQbwlbEHyJWxBKSZsQV8mbEGWJmxBzCZsQQMnbEE5J2xBcCdsQaYnbEHdJ2xBEyhsQUoobEGBKGxBtyhsQe4obEEkKWxBWylsQZEpbEHIKWxB/ilsQTUqbEFrKmxBoipsQdgqbEEPK2xBRStsQXwrbEGyK2xB6StsQR8sbEFWLGxBjCxsQcMsbEH5LGxBMC1sQWYtbEGdLWxB0y1sQQoubEFALmxBdi5sQa0ubEHjLmxBGi9sQVAvbEGHL2xBvS9sQfQvbEEqMGxBYTBsQZcwbEHOMGxBBDFsQToxbEFxMWxBpzFsQd4xbEEUMmxBSzJsQYEybEG4MmxB7jJsQSQzbEFbM2xBkTNsQcgzbEH+M2xBNDRsQWs0bEGhNGxB2DRsQQ41bEFFNWxBezVsQbE1bEHoNWxBHjZsQVU2bEGLNmxBwTZsQfg2bEEuN2xBZTdsQZs3bEHRN2xBCDhsQT44bEF0OGxBqzhsQeE4bEEYOWxBTjlsQYQ5bEG7OWxB8TlsQSc6bEFeOmxBlDpsQcs6bEEBO2xBNztsQW47bEGkO2xB2jtsQRE8bEFHPGxBfTxsQbQ8bEHqPGxBID1sQVc9bEGNPWxBwz1sQfo9bEEwPmxBZj5sQZ0+bEHTPmxBCT9sQUA/bEF2P2xBrD9sQeM/bEEZQGxBT0BsQYVAbEG8QGxB8kBsQShBbEFfQWxBlUFsQctBbEECQmxBOEJsQW5CbEGkQmxB20JsQRFDbEFHQ2xBfkNsQbRDbEHqQ2xBIERsQVdEbEGNRGxBw0RsQflEbEEwRWxBZkVsQZxFbEHSRWxBCUZsQT9GbEF1RmxBq0ZsQeJGbEEYR2xBTkdsQYRHbEG7R2xB8UdsQSdIbEFdSGxBlEhsQcpIbEEASWxBNklsQW1JbEGjSWxB2UlsQQ9KbEFFSmxBfEpsQbJKbEHoSmxBHktsQVRLbEGLS2xBwUtsQfdLbEEtTGxBY0xsQZpMbEHQTGxBBk1sQTxNbEFyTWxBqU1sQd9NbEEVTmxBS05sQYFObEG4TmxB7k5sQSRPbEFaT2xBkE9sQcZPbEH9T2xBM1BsQWlQbEGfUGxB1VBsQQtRbEFBUWxBeFFsQa5RbEHkUWxBGlJsQVBSbEGGUmxBvFJsQfNSbEEpU2xBX1NsQZVTbEHLU2xBAVRsQTdUbEFuVGxBpFRsQdpUbEEQVWxBRlVsQXxVbEGyVWxB6FVsQR5WbEFVVmxBi1ZsQcFWbEH3VmxBLVdsQWNXbEGZV2xBz1dsQQVYbEE7WGxBclhsQahYbEHeWGxBFFlsQUpZbEGAWWxBtllsQexZbEEiWmxBWFpsQY5abEHEWmxB+lpsQTBbbEFnW2xBnVtsQdNbbEEJXGxBP1xsQXVcbEGrXGxB4VxsQRddbEFNXWxBg11sQbldbEHvXWxBJV5sQVtebEGRXmxBx15sQf1ebEEzX2xBaV9sQZ9fbEHVX2xBC2BsQUFgbEF3YGxBrWBsQeNgbEEZYWxBT2FsQYVhbEG7YWxB8WFsQSdibEFdYmxBk2JsQclibEH/YmxBNWNsQWtjbEGhY2xB12NsQQ1kbEFDZGxBeWRsQa9kbEHlZGxBG2VsQVFlbEGHZWxBvWVsQfNlbEEpZmxBX2ZsQZVmbEHLZmxBAWdsQTdnbEFtZ2xBo2dsQdlnbEEPaGxBRWhsQXpobEGwaGxB5mhsQRxpbEFSaWxBiGlsQb5pbEH0aWxBKmpsQWBqbEGWamxBzGpsQQJrbEE3a2xBbWtsQaNrbEHZa2xBD2xsQUVsbEF7bGxBsWxsQedsbEEdbWxBU21sQYhtbEG+bWxB9G1sQSpubEFgbmxBlm5sQcxubEECb2xBOG9sQW1vbEGjb2xB2W9sQQ9wbEFFcGxBe3BsQbFwbEHmcGxBHHFsQVJxbEGIcWxBvnFsQfRxbEEqcmxBX3JsQZVybEHLcmxBAXNsQTdzbEFtc2xBo3NsQdhzbEEOdGxBRHRsQXp0bEGwdGxB5nRsQRt1bEFRdWxBh3VsQb11bEHzdWxBKHZsQV52bEGUdmxBynZsQQB3bEE1d2xBa3dsQaF3bEHXd2xBDXhsQUJ4bEF4eGxBrnhsQeR4bEEaeWxBT3lsQYV5bEG7eWxB8XlsQSd6bEFcemxBknpsQch6bEH+emxBM3tsQWl7bEGfe2xB1XtsQQp8bEFAfGxBdnxsQax8bEHifGxBF31sQU19bEGDfWxBuX1sQe59bEEkfmxBWn5sQY9+bEHFfmxB+35sQTF/bEFmf2xBnH9sQdJ/bEEIgGxBPYBsQXOAbEGpgGxB3oBsQRSBbEFKgWxBgIFsQbWBbEHrgWxBIYJsQVaCbEGMgmxBwoJsQfiCbEEtg2xBY4NsQZmDbEHOg2xBBIRsQTqEbEFvhGxBpYRsQduEbEEQhWxBRoVsQXyFbEGxhWxB54VsQR2GbEFShmxBiIZsQb6GbEHzhmxBKYdsQV+HbEGUh2xByodsQQCIbEE1iGxBa4hsQaGIbEHWiGxBDIlsQUKJbEF3iWxBrYlsQeOJbEEYimxBTopsQYOKbEG5imxB74psQSSLbEFai2xBkItsQcWLbEH7i2xBMIxsQWaMbEGcjGxB0YxsQQeNbEE8jWxBco1sQaiNbEHdjWxBE45sQUiObEF+jmxBtI5sQemObEEfj2xBVI9sQYqPbEHAj2xB9Y9sQSuQbEFgkGxBlpBsQcuQbEEBkWxBN5FsQWyRbEGikWxB15FsQQ2SbEFCkmxBeJJsQa6SbEHjkmxBGZNsQU6TbEGEk2xBuZNsQe+TbEEklGxBWpRsQY+UbEHFlGxB+5RsQTCVbEFmlWxBm5VsQdGVbEEGlmxBPJZsQXGWbEGnlmxB3JZsQRKXbEFHl2xBfZdsQbKXbEHol2xBHZhsQVOYbEGImGxBvphsQfOYbEEpmWxBXplsQZSZbEHJmWxB/5lsQTSabEFqmmxBn5psQdWabEEKm2xBQJtsQXWbbEGrm2xB4JtsQRacbEFLnGxBgZxsQbacbEHrnGxBIZ1sQVadbEGMnWxBwZ1sQfedbEEsnmxBYp5sQZeebEHNnmxBAp9sQTefbEFtn2xBop9sQdifbEENoGxBQ6BsQXigbEGtoGxB46BsQRihbEFOoWxBg6FsQbmhbEHuoWxBI6JsQVmibEGOomxBxKJsQfmibEEvo2xBZKNsQZmjbEHPo2xBBKRsQTqkbEFvpGxBpKRsQdqkbEEPpWxBRKVsQXqlbEGvpWxB5aVsQRqmbEFPpmxBhaZsQbqmbEHwpmxBJadsQVqnbEGQp2xBxadsQfqnbEEwqGxBZahsQZqobEHQqGxBBalsQTqpbEFwqWxBpalsQdupbEEQqmxBRapsQXuqbEGwqmxB5apsQRurbEFQq2xBhatsQburbEHwq2xBJaxsQVusbEGQrGxBxaxsQfqsbEEwrWxBZa1sQZqtbEHQrWxBBa5sQTqubEFwrmxBpa5sQdqubEEQr2xBRa9sQXqvbEGvr2xB5a9sQRqwbEFPsGxBhbBsQbqwbEHvsGxBJLFsQVqxbEGPsWxBxLFsQfqxbEEvsmxBZLJsQZmybEHPsmxBBLNsQTmzbEFus2xBpLNsQdmzbEEOtGxBQ7RsQXm0bEGutGxB47RsQRi1bEFOtWxBg7VsQbi1bEHttWxBI7ZsQVi2bEGNtmxBwrZsQfi2bEEtt2xBYrdsQZe3bEHMt2xBArhsQTe4bEFsuGxBobhsQde4bEEMuWxBQblsQXa5bEGruWxB4blsQRa6bEFLumxBgLpsQbW6bEHrumxBILtsQVW7bEGKu2xBv7tsQfS7bEEqvGxBX7xsQZS8bEHJvGxB/rxsQTS9bEFpvWxBnr1sQdO9bEEIvmxBPb5sQXO+bEGovmxB3b5sQRK/bEFHv2xBfL9sQbG/bEHnv2xBHMBsQVHAbEGGwGxBu8BsQfDAbEElwWxBW8FsQZDBbEHFwWxB+sFsQS/CbEFkwmxBmcJsQc7CbEEEw2xBOcNsQW7DbEGjw2xB2MNsQQ3EbEFCxGxBd8RsQa3EbEHixGxBF8VsQUzFbEGBxWxBtsVsQevFbEEgxmxBVcZsQYrGbEG/xmxB9cZsQSrHbEFfx2xBlMdsQcnHbEH+x2xBM8hsQWjIbEGdyGxB0shsQQfJbEE8yWxBcclsQabJbEHcyWxBEcpsQUbKbEF7ymxBsMpsQeXKbEEay2xBT8tsQYTLbEG5y2xB7stsQSPMbEFYzGxBjcxsQcLMbEH3zGxBLM1sQWHNbEGWzWxBy81sQQDObEE1zmxBas5sQZ/ObEHUzmxBCc9sQT7PbEFzz2xBqM9sQd3PbEES0GxBR9BsQXzQbEGx0GxB5tBsQRvRbEFQ0WxBhdFsQbrRbEHv0WxBJNJsQVnSbEGO0mxBw9JsQfjSbEEt02xBYtNsQZfTbEHM02xBAdRsQTbUbEFr1GxBoNRsQdXUbEEK1WxBP9VsQXTVbEGp1WxB3tVsQRPWbEFI1mxBfdZsQbLWbEHm1mxBG9dsQVDXbEGF12xButdsQe/XbEEk2GxBWdhsQY7YbEHD2GxB+NhsQS3ZbEFi2WxBl9lsQcvZbEEA2mxBNdpsQWrabEGf2mxB1NpsQQnbbEE+22xBc9tsQajbbEHc22xBEdxsQUbcbEF73GxBsNxsQeXcbEEa3WxBT91sQYTdbEG43WxB7d1sQSLebEFX3mxBjN5sQcHebEH23mxBK99sQV/fbEGU32xByd9sQf7fbEEz4GxBaOBsQZ3gbEHR4GxBBuFsQTvhbEFw4WxBpeFsQdrhbEEP4mxBQ+JsQXjibEGt4mxB4uJsQRfjbEFM42xBgONsQbXjbEHq42xBH+RsQVTkbEGJ5GxBveRsQfLkbEEn5WxBXOVsQZHlbEHF5WxB+uVsQS/mbEFk5mxBmeZsQc3mbEEC52xBN+dsQWznbEGh52xB1edsQQrobEE/6GxBdOhsQanobEHd6GxBEulsQUfpbEF86WxBsOlsQeXpbEEa6mxBT+psQYPqbEG46mxB7epsQSLrbEFX62xBi+tsQcDrbEH162xBKuxsQV7sbEGT7GxByOxsQf3sbEEx7WxBZu1sQZvtbEHP7WxBBO5sQTnubEFu7mxBou5sQdfubEEM72xBQe9sQXXvbEGq72xB3+9sQRPwbEFI8GxBffBsQbLwbEHm8GxBG/FsQVDxbEGE8WxBufFsQe7xbEEj8mxBV/JsQYzybEHB8mxB9fJsQSrzbEFf82xBk/NsQcjzbEH982xBMfRsQWb0bEGb9GxBz/RsQQT1bEE59WxBbfVsQaL1bEHX9WxBC/ZsQUD2bEF19mxBqfZsQd72bEET92xBR/dsQXz3bEGx92xB5fdsQRr4bEFP+GxBg/hsQbj4bEHt+GxBIflsQVb5bEGK+WxBv/lsQfT5bEEo+mxBXfpsQZL6bEHG+mxB+/psQS/7bEFk+2xBmftsQc37bEEC/GxBNvxsQWv8bEGg/GxB1PxsQQn9bEE9/WxBcv1sQaf9bEHb/WxBEP5sQUT+bEF5/mxBrv5sQeL+bEEX/2xBS/9sQYD/bEG1/2xB6f9sQR4AbUFSAG1BhwBtQbsAbUHwAG1BJQFtQVkBbUGOAW1BwgFtQfcBbUErAm1BYAJtQZQCbUHJAm1B/gJtQTIDbUFnA21BmwNtQdADbUEEBG1BOQRtQW0EbUGiBG1B1gRtQQsFbUE/BW1BdAVtQagFbUHdBW1BEgZtQUYGbUF7Bm1BrwZtQeQGbUEYB21BTQdtQYEHbUG2B21B6gdtQR8IbUFTCG1BiAhtQbwIbUHxCG1BJQltQVoJbUGOCW1BwwltQfcJbUEsCm1BYAptQZUKbUHJCm1B/QptQTILbUFmC21BmwttQc8LbUEEDG1BOAxtQW0MbUGhDG1B1gxtQQoNbUE/DW1Bcw1tQacNbUHcDW1BEA5tQUUObUF5Dm1Brg5tQeIObUEXD21BSw9tQX8PbUG0D21B6A9tQR0QbUFREG1BhhBtQboQbUHvEG1BIxFtQVcRbUGMEW1BwBFtQfURbUEpEm1BXRJtQZISbUHGEm1B+xJtQS8TbUFjE21BmBNtQcwTbUEBFG1BNRRtQWkUbUGeFG1B0hRtQQcVbUE7FW1BbxVtQaQVbUHYFW1BDRZtQUEWbUF1Fm1BqhZtQd4WbUESF21BRxdtQXsXbUGvF21B5BdtQRgYbUFNGG1BgRhtQbUYbUHqGG1BHhltQVIZbUGHGW1BuxltQe8ZbUEkGm1BWBptQYwabUHBGm1B9RptQSkbbUFeG21BkhttQcYbbUH7G21BLxxtQWMcbUGYHG1BzBxtQQAdbUE1HW1BaR1tQZ0dbUHSHW1BBh5tQToebUFuHm1Box5tQdcebUELH21BQB9tQXQfbUGoH21B3R9tQREgbUFFIG1BeSBtQa4gbUHiIG1BFiFtQUshbUF/IW1BsyFtQechbUEcIm1BUCJtQYQibUG4Im1B7SJtQSEjbUFVI21BiiNtQb4jbUHyI21BJiRtQVskbUGPJG1BwyRtQfckbUEsJW1BYCVtQZQlbUHIJW1B/CVtQTEmbUFlJm1BmSZtQc0mbUECJ21BNidtQWonbUGeJ21B0ydtQQcobUE7KG1BbyhtQaMobUHYKG1BDCltQUApbUF0KW1BqCltQd0pbUERKm1BRSptQXkqbUGtKm1B4iptQRYrbUFKK21BfittQbIrbUHnK21BGyxtQU8sbUGDLG1BtyxtQessbUEgLW1BVC1tQYgtbUG8LW1B8C1tQSUubUFZLm1BjS5tQcEubUH1Lm1BKS9tQV0vbUGSL21Bxi9tQfovbUEuMG1BYjBtQZYwbUHKMG1B/zBtQTMxbUFnMW1BmzFtQc8xbUEDMm1BNzJtQWwybUGgMm1B1DJtQQgzbUE8M21BcDNtQaQzbUHYM21BDTRtQUE0bUF1NG1BqTRtQd00bUERNW1BRTVtQXk1bUGtNW1B4TVtQRY2bUFKNm1BfjZtQbI2bUHmNm1BGjdtQU43bUGCN21BtjdtQeo3bUEeOG1BUjhtQYc4bUG7OG1B7zhtQSM5bUFXOW1BizltQb85bUHzOW1BJzptQVs6bUGPOm1BwzptQfc6bUErO21BXzttQZM7bUHIO21B/DttQTA8bUFkPG1BmDxtQcw8bUEAPW1BND1tQWg9bUGcPW1B0D1tQQQ+bUE4Pm1BbD5tQaA+bUHUPm1BCD9tQTw/bUFwP21BpD9tQdg/bUEMQG1BQEBtQXRAbUGoQG1B3EBtQRBBbUFEQW1BeEFtQaxBbUHgQW1BFEJtQUhCbUF8Qm1BsEJtQeRCbUEYQ21BTENtQYBDbUG0Q21B6ENtQRxEbUFQRG1BhERtQbhEbUHsRG1BIEVtQVRFbUGIRW1BvEVtQe9FbUEjRm1BV0ZtQYtGbUG/Rm1B80ZtQSdHbUFbR21Bj0dtQcNHbUH3R21BK0htQV9IbUGTSG1Bx0htQftIbUEvSW1BYkltQZZJbUHKSW1B/kltQTJKbUFmSm1BmkptQc5KbUECS21BNkttQWpLbUGeS21B0UttQQVMbUE5TG1BbUxtQaFMbUHVTG1BCU1tQT1NbUFxTW1BpE1tQdhNbUEMTm1BQE5tQXRObUGoTm1B3E5tQRBPbUFET21Bd09tQatPbUHfT21BE1BtQUdQbUF7UG1Br1BtQeJQbUEWUW1BSlFtQX5RbUGyUW1B5lFtQRpSbUFNUm1BgVJtQbVSbUHpUm1BHVNtQVFTbUGEU21BuFNtQexTbUEgVG1BVFRtQYhUbUG7VG1B71RtQSNVbUFXVW1Bi1VtQb9VbUHyVW1BJlZtQVpWbUGOVm1BwlZtQfVWbUEpV21BXVdtQZFXbUHFV21B+FdtQSxYbUFgWG1BlFhtQchYbUH7WG1BL1ltQWNZbUGXWW1By1ltQf5ZbUEyWm1BZlptQZpabUHNWm1BAVttQTVbbUFpW21BnFttQdBbbUEEXG1BOFxtQWxcbUGfXG1B01xtQQddbUE7XW1Bbl1tQaJdbUHWXW1BCl5tQT1ebUFxXm1BpV5tQdlebUEMX21BQF9tQXRfbUGnX21B219tQQ9gbUFDYG1BdmBtQapgbUHeYG1BEWFtQUVhbUF5YW1BrWFtQeBhbUEUYm1BSGJtQXtibUGvYm1B42JtQRdjbUFKY21BfmNtQbJjbUHlY21BGWRtQU1kbUGAZG1BtGRtQehkbUEbZW1BT2VtQYNlbUG3ZW1B6mVtQR5mbUFSZm1BhWZtQblmbUHtZm1BIGdtQVRnbUGIZ21Bu2dtQe9nbUEjaG1BVmhtQYpobUG9aG1B8WhtQSVpbUFYaW1BjGltQcBpbUHzaW1BJ2ptQVtqbUGOam1BwmptQfZqbUEpa21BXWttQZBrbUHEa21B+GttQStsbUFfbG1BkmxtQcZsbUH6bG1BLW1tQWFtbUGVbW1ByG1tQfxtbUEvbm1BY25tQZdubUHKbm1B/m5tQTFvbUFlb21BmW9tQcxvbUEAcG1BM3BtQWdwbUGacG1BznBtQQJxbUE1cW1BaXFtQZxxbUHQcW1BBHJtQTdybUFrcm1BnnJtQdJybUEFc21BOXNtQWxzbUGgc21B1HNtQQd0bUE7dG1BbnRtQaJ0bUHVdG1BCXVtQTx1bUFwdW1Bo3VtQdd1bUELdm1BPnZtQXJ2bUGldm1B2XZtQQx3bUFAd21Bc3dtQad3bUHad21BDnhtQUF4bUF1eG1BqHhtQdx4bUEPeW1BQ3ltQXZ5bUGqeW1B3XltQRF6bUFEem1BeHptQat6bUHfem1BEnttQUZ7bUF5e21BrXttQeB7bUEUfG1BR3xtQXt8bUGufG1B4nxtQRV9bUFJfW1BfH1tQbB9bUHjfW1BFn5tQUp+bUF9fm1BsX5tQeR+bUEYf21BS39tQX9/bUGyf21B5n9tQRmAbUFMgG1BgIBtQbOAbUHngG1BGoFtQU6BbUGBgW1BtYFtQeiBbUEbgm1BT4JtQYKCbUG2gm1B6YJtQR2DbUFQg21Bg4NtQbeDbUHqg21BHoRtQVGEbUGEhG1BuIRtQeuEbUEfhW1BUoVtQYWFbUG5hW1B7IVtQSCGbUFThm1BhoZtQbqGbUHthm1BIYdtQVSHbUGHh21Bu4dtQe6HbUEhiG1BVYhtQYiIbUG8iG1B74htQSKJbUFWiW1BiYltQbyJbUHwiW1BI4ptQVeKbUGKim1BvYptQfGKbUEki21BV4ttQYuLbUG+i21B8YttQSWMbUFYjG1Bi4xtQb+MbUHyjG1BJY1tQVmNbUGMjW1Bv41tQfONbUEmjm1BWY5tQY2ObUHAjm1B845tQSePbUFaj21BjY9tQcGPbUH0j21BJ5BtQVqQbUGOkG1BwZBtQfSQbUEokW1BW5FtQY6RbUHCkW1B9ZFtQSiSbUFbkm1Bj5JtQcKSbUH1km1BKZNtQVyTbUGPk21BwpNtQfaTbUEplG1BXJRtQY+UbUHDlG1B9pRtQSmVbUFdlW1BkJVtQcOVbUH2lW1BKpZtQV2WbUGQlm1Bw5ZtQfeWbUEql21BXZdtQZCXbUHEl21B95dtQSqYbUFdmG1BkJhtQcSYbUH3mG1BKpltQV2ZbUGRmW1BxJltQfeZbUEqmm1BXpptQZGabUHEmm1B95ptQSqbbUFem21BkZttQcSbbUH3m21BKpxtQV6cbUGRnG1BxJxtQfecbUEqnW1BXp1tQZGdbUHEnW1B951tQSqebUFenm1BkZ5tQcSebUH3nm1BKp9tQV2fbUGRn21BxJ9tQfefbUEqoG1BXaBtQZCgbUHEoG1B96BtQSqhbUFdoW1BkKFtQcOhbUH3oW1BKqJtQV2ibUGQom1Bw6JtQfaibUEpo21BXaNtQZCjbUHDo21B9qNtQSmkbUFcpG1Bj6RtQcOkbUH2pG1BKaVtQVylbUGPpW1BwqVtQfWlbUEopm1BW6ZtQY+mbUHCpm1B9aZtQSinbUFbp21BjqdtQcGnbUH0p21BJ6htQVuobUGOqG1BwahtQfSobUEnqW1BWqltQY2pbUHAqW1B86ltQSaqbUFZqm1BjKptQcCqbUHzqm1BJqttQVmrbUGMq21Bv6ttQfKrbUElrG1BWKxtQYusbUG+rG1B8axtQSStbUFXrW1Biq1tQb6tbUHxrW1BJK5tQVeubUGKrm1Bva5tQfCubUEjr21BVq9tQYmvbUG8r21B769tQSKwbUFVsG1BiLBtQbuwbUHusG1BIbFtQVSxbUGHsW1BurFtQe2xbUEgsm1BU7JtQYaybUG5sm1B7LJtQR+zbUFSs21BhbNtQbizbUHrs21BHrRtQVG0bUGEtG1Bt7RtQeq0bUEdtW1BULVtQYO1bUG2tW1B6bVtQRy2bUFPtm1BgrZtQbW2bUHotm1BG7dtQU63bUGBt21BtLdtQee3bUEauG1BTbhtQYC4bUGzuG1B5rhtQRm5bUFMuW1BfrltQbG5bUHkuW1BF7ptQUq6bUF9um1BsLptQeO6bUEWu21BSbttQXy7bUGvu21B4rttQRW8bUFIvG1Be7xtQa28bUHgvG1BE71tQUa9bUF5vW1BrL1tQd+9bUESvm1BRb5tQXi+bUGrvm1B3b5tQRC/bUFDv21Bdr9tQam/bUHcv21BD8BtQULAbUF1wG1BqMBtQdrAbUENwW1BQMFtQXPBbUGmwW1B2cFtQQzCbUE/wm1BccJtQaTCbUHXwm1BCsNtQT3DbUFww21Bo8NtQdbDbUEIxG1BO8RtQW7EbUGhxG1B1MRtQQfFbUE6xW1BbMVtQZ/FbUHSxW1BBcZtQTjGbUFrxm1BncZtQdDGbUEDx21BNsdtQWnHbUGcx21BzsdtQQHIbUE0yG1BZ8htQZrIbUHMyG1B/8htQTLJbUFlyW1BmMltQcvJbUH9yW1BMMptQWPKbUGWym1BycptQfvKbUEuy21BYcttQZTLbUHHy21B+cttQSzMbUFfzG1BksxtQcTMbUH3zG1BKs1tQV3NbUGQzW1Bws1tQfXNbUEozm1BW85tQY3ObUHAzm1B885tQSbPbUFZz21Bi89tQb7PbUHxz21BJNBtQVbQbUGJ0G1BvNBtQe/QbUEh0W1BVNFtQYfRbUG60W1B7NFtQR/SbUFS0m1BhNJtQbfSbUHq0m1BHdNtQU/TbUGC021BtdNtQejTbUEa1G1BTdRtQYDUbUGy1G1B5dRtQRjVbUFL1W1BfdVtQbDVbUHj1W1BFdZtQUjWbUF71m1BrtZtQeDWbUET121BRtdtQXjXbUGr121B3tdtQRDYbUFD2G1BdthtQajYbUHb2G1BDtltQUDZbUFz2W1BptltQdjZbUEL2m1BPtptQXDabUGj2m1B1tptQQjbbUE7221BbtttQaDbbUHT221BBtxtQTjcbUFr3G1BntxtQdDcbUED3W1BNt1tQWjdbUGb3W1Bzt1tQQDebUEz3m1BZd5tQZjebUHL3m1B/d5tQTDfbUFj321Bld9tQcjfbUH6321BLeBtQWDgbUGS4G1BxeBtQfjgbUEq4W1BXeFtQY/hbUHC4W1B9eFtQSfibUFa4m1BjOJtQb/ibUHy4m1BJONtQVfjbUGJ421BvONtQe7jbUEh5G1BVORtQYbkbUG55G1B6+RtQR7lbUFR5W1Bg+VtQbblbUHo5W1BG+ZtQU3mbUGA5m1BsuZtQeXmbUEY521BSudtQX3nbUGv521B4udtQRTobUFH6G1BeehtQazobUHf6G1BEeltQUTpbUF26W1BqeltQdvpbUEO6m1BQOptQXPqbUGl6m1B2OptQQrrbUE9621Bb+ttQaLrbUHU621BB+xtQTrsbUFs7G1Bn+xtQdHsbUEE7W1BNu1tQWntbUGb7W1Bzu1tQQDubUEz7m1BZe5tQZjubUHK7m1B/e5tQS/vbUFi721BlO9tQcbvbUH5721BK/BtQV7wbUGQ8G1Bw/BtQfXwbUEo8W1BWvFtQY3xbUG/8W1B8vFtQSTybUFX8m1BifJtQbzybUHu8m1BIPNtQVPzbUGF821BuPNtQerzbUEd9G1BT/RtQYL0bUG09G1B5vRtQRn1bUFL9W1BfvVtQbD1bUHj9W1BFfZtQUj2bUF69m1BrPZtQd/2bUER921BRPdtQXb3bUGo921B2/dtQQ34bUFA+G1BcvhtQaX4bUHX+G1BCfltQTz5bUFu+W1BofltQdP5bUEF+m1BOPptQWr6bUGd+m1Bz/ptQQH7bUE0+21BZvttQZj7bUHL+21B/fttQTD8bUFi/G1BlPxtQcf8bUH5/G1BK/1tQV79bUGQ/W1Bw/1tQfX9bUEn/m1BWv5tQYz+bUG+/m1B8f5tQSP/bUFV/21BiP9tQbr/bUHs/21BHwBuQVEAbkGDAG5BtgBuQegAbkEaAW5BTQFuQX8BbkGxAW5B5AFuQRYCbkFIAm5BewJuQa0CbkHfAm5BEgNuQUQDbkF2A25BqQNuQdsDbkENBG5BQARuQXIEbkGkBG5B1wRuQQkFbkE7BW5BbQVuQaAFbkHSBW5BBAZuQTcGbkFpBm5BmwZuQc4GbkEAB25BMgduQWQHbkGXB25ByQduQfsHbkEtCG5BYAhuQZIIbkHECG5B9whuQSkJbkFbCW5BjQluQcAJbkHyCW5BJApuQVYKbkGJCm5BuwpuQe0KbkEfC25BUgtuQYQLbkG2C25B6AtuQRsMbkFNDG5BfwxuQbEMbkHkDG5BFg1uQUgNbkF6DW5BrQ1uQd8NbkERDm5BQw5uQXUObkGoDm5B2g5uQQwPbkE+D25BcQ9uQaMPbkHVD25BBxBuQTkQbkFsEG5BnhBuQdAQbkECEW5BNBFuQWcRbkGZEW5ByxFuQf0RbkEvEm5BYhJuQZQSbkHGEm5B+BJuQSoTbkFcE25BjxNuQcETbkHzE25BJRRuQVcUbkGJFG5BvBRuQe4UbkEgFW5BUhVuQYQVbkG2FW5B6RVuQRsWbkFNFm5BfxZuQbEWbkHjFm5BFhduQUgXbkF6F25BrBduQd4XbkEQGG5BQhhuQXUYbkGnGG5B2RhuQQsZbkE9GW5BbxluQaEZbkHTGW5BBhpuQTgabkFqGm5BnBpuQc4abkEAG25BMhtuQWQbbkGXG25ByRtuQfsbbkEtHG5BXxxuQZEcbkHDHG5B9RxuQScdbkFZHW5BjB1uQb4dbkHwHW5BIh5uQVQebkGGHm5BuB5uQeoebkEcH25BTh9uQYAfbkGyH25B5R9uQRcgbkFJIG5BeyBuQa0gbkHfIG5BESFuQUMhbkF1IW5BpyFuQdkhbkELIm5BPSJuQW8ibkGhIm5B0yJuQQYjbkE4I25BaiNuQZwjbkHOI25BACRuQTIkbkFkJG5BliRuQcgkbkH6JG5BLCVuQV4lbkGQJW5BwiVuQfQlbkEmJm5BWCZuQYombkG8Jm5B7iZuQSAnbkFSJ25BhCduQbYnbkHoJ25BGihuQUwobkF+KG5BsChuQeIobkEUKW5BRiluQXgpbkGqKW5B3CluQQ4qbkFAKm5BcipuQaQqbkHWKm5BCCtuQTorbkFsK25BnituQdArbkECLG5BNCxuQWYsbkGYLG5ByixuQfwsbkEuLW5BYC1uQZItbkHELW5B9i1uQSgubkFZLm5Biy5uQb0ubkHvLm5BIS9uQVMvbkGFL25Bty9uQekvbkEbMG5BTTBuQX8wbkGxMG5B4zBuQRUxbkFHMW5BeDFuQaoxbkHcMW5BDjJuQUAybkFyMm5BpDJuQdYybkEIM25BOjNuQWwzbkGeM25BzzNuQQE0bkEzNG5BZTRuQZc0bkHJNG5B+zRuQS01bkFfNW5BkTVuQcI1bkH0NW5BJjZuQVg2bkGKNm5BvDZuQe42bkEgN25BUTduQYM3bkG1N25B5zduQRk4bkFLOG5BfThuQa84bkHgOG5BEjluQUQ5bkF2OW5BqDluQdo5bkEMOm5BPTpuQW86bkGhOm5B0zpuQQU7bkE3O25BaTtuQZo7bkHMO25B/jtuQTA8bkFiPG5BlDxuQcU8bkH3PG5BKT1uQVs9bkGNPW5Bvj1uQfA9bkEiPm5BVD5uQYY+bkG4Pm5B6T5uQRs/bkFNP25Bfz9uQbE/bkHiP25BFEBuQUZAbkF4QG5BqkBuQdtAbkENQW5BP0FuQXFBbkGjQW5B1EFuQQZCbkE4Qm5BakJuQZxCbkHNQm5B/0JuQTFDbkFjQ25BlENuQcZDbkH4Q25BKkRuQVtEbkGNRG5Bv0RuQfFEbkEjRW5BVEVuQYZFbkG4RW5B6kVuQRtGbkFNRm5Bf0ZuQbFGbkHiRm5BFEduQUZHbkF4R25BqUduQdtHbkENSG5BPkhuQXBIbkGiSG5B1EhuQQVJbkE3SW5BaUluQZtJbkHMSW5B/kluQTBKbkFhSm5Bk0puQcVKbkH3Sm5BKEtuQVpLbkGMS25BvUtuQe9LbkEhTG5BUkxuQYRMbkG2TG5B6ExuQRlNbkFLTW5BfU1uQa5NbkHgTW5BEk5uQUNObkF1Tm5Bp05uQdhObkEKT25BPE9uQW1PbkGfT25B0U9uQQJQbkE0UG5BZlBuQZdQbkHJUG5B+1BuQSxRbkFeUW5BkFFuQcFRbkHzUW5BJVJuQVZSbkGIUm5BulJuQetSbkEdU25BT1NuQYBTbkGyU25B41NuQRVUbkFHVG5BeFRuQapUbkHcVG5BDVVuQT9VbkFxVW5BolVuQdRVbkEFVm5BN1ZuQWlWbkGaVm5BzFZuQf1WbkEvV25BYVduQZJXbkHEV25B9VduQSdYbkFZWG5BilhuQbxYbkHtWG5BH1luQVFZbkGCWW5BtFluQeVZbkEXWm5BSVpuQXpabkGsWm5B3VpuQQ9bbkFAW25BcltuQaRbbkHVW25BB1xuQThcbkFqXG5Bm1xuQc1cbkH/XG5BMF1uQWJdbkGTXW5BxV1uQfZdbkEoXm5BWV5uQYtebkG8Xm5B7l5uQSBfbkFRX25Bg19uQbRfbkHmX25BF2BuQUlgbkF6YG5BrGBuQd1gbkEPYW5BQGFuQXJhbkGjYW5B1WFuQQdibkE4Ym5BamJuQZtibkHNYm5B/mJuQTBjbkFhY25Bk2NuQcRjbkH2Y25BJ2RuQVlkbkGKZG5BvGRuQe1kbkEfZW5BUGVuQYJlbkGzZW5B5WVuQRZmbkFHZm5BeWZuQapmbkHcZm5BDWduQT9nbkFwZ25BomduQdNnbkEFaG5BNmhuQWhobkGZaG5By2huQfxobkEuaW5BX2luQZBpbkHCaW5B82luQSVqbkFWam5BiGpuQblqbkHram5BHGtuQU1rbkF/a25BsGtuQeJrbkETbG5BRWxuQXZsbkGnbG5B2WxuQQptbkE8bW5BbW1uQZ9tbkHQbW5BAW5uQTNubkFkbm5Blm5uQcdubkH4bm5BKm9uQVtvbkGNb25Bvm9uQe9vbkEhcG5BUnBuQYRwbkG1cG5B5nBuQRhxbkFJcW5Be3FuQaxxbkHdcW5BD3JuQUBybkFycm5Bo3JuQdRybkEGc25BN3NuQWhzbkGac25By3NuQf1zbkEudG5BX3RuQZF0bkHCdG5B83RuQSV1bkFWdW5Bh3VuQbl1bkHqdW5BG3ZuQU12bkF+dm5BsHZuQeF2bkESd25BRHduQXV3bkGmd25B2HduQQl4bkE6eG5BbHhuQZ14bkHOeG5BAHluQTF5bkFieW5Bk3luQcV5bkH2eW5BJ3puQVl6bkGKem5Bu3puQe16bkEee25BT3tuQYF7bkGye25B43tuQRR8bkFGfG5Bd3xuQah8bkHafG5BC31uQTx9bkFufW5Bn31uQdB9bkEBfm5BM35uQWR+bkGVfm5Bx35uQfh+bkEpf25BWn9uQYx/bkG9f25B7n9uQR+AbkFRgG5BgoBuQbOAbkHkgG5BFoFuQUeBbkF4gW5BqYFuQduBbkEMgm5BPYJuQW6CbkGggm5B0YJuQQKDbkEzg25BZYNuQZaDbkHHg25B+INuQSqEbkFbhG5BjIRuQb2EbkHvhG5BIIVuQVGFbkGChW5Bs4VuQeWFbkEWhm5BR4ZuQXiGbkGphm5B24ZuQQyHbkE9h25BboduQaCHbkHRh25BAohuQTOIbkFkiG5BlohuQceIbkH4iG5BKYluQVqJbkGLiW5BvYluQe6JbkEfim5BUIpuQYGKbkGzim5B5IpuQRWLbkFGi25Bd4tuQaiLbkHai25BC4xuQTyMbkFtjG5BnoxuQc+MbkEBjW5BMo1uQWONbkGUjW5BxY1uQfaNbkEnjm5BWY5uQYqObkG7jm5B7I5uQR2PbkFOj25Bf49uQbGPbkHij25BE5BuQUSQbkF1kG5BppBuQdeQbkEJkW5BOpFuQWuRbkGckW5BzZFuQf6RbkEvkm5BYJJuQZGSbkHDkm5B9JJuQSWTbkFWk25Bh5NuQbiTbkHpk25BGpRuQUuUbkF8lG5BrpRuQd+UbkEQlW5BQZVuQXKVbkGjlW5B1JVuQQWWbkE2lm5BZ5ZuQZiWbkHKlm5B+5ZuQSyXbkFdl25BjpduQb+XbkHwl25BIZhuQVKYbkGDmG5BtJhuQeWYbkEWmW5BR5luQXiZbkGpmW5B25luQQyabkE9mm5BbppuQZ+abkHQmm5BAZtuQTKbbkFjm25BlJtuQcWbbkH2m25BJ5xuQVicbkGJnG5BupxuQeucbkEcnW5BTZ1uQX6dbkGvnW5B4J1uQRGebkFCnm5Bc55uQaSebkHVnm5BBp9uQTefbkFon25BmZ9uQcqfbkH7n25BLKBuQV2gbkGOoG5Bv6BuQfCgbkEhoW5BUqFuQYOhbkG0oW5B5aFuQRaibkFHom5BeKJuQamibkHaom5BC6NuQTyjbkFto25BnqNuQc+jbkEApG5BMaRuQWKkbkGTpG5BxKRuQfWkbkEmpW5BV6VuQYilbkG5pW5B6qVuQRumbkFLpm5BfKZuQa2mbkHepm5BD6duQUCnbkFxp25BoqduQdOnbkEEqG5BNahuQWaobkGXqG5ByKhuQfmobkEqqW5BWqluQYupbkG8qW5B7aluQR6qbkFPqm5BgKpuQbGqbkHiqm5BE6tuQUSrbkF0q25BpatuQdarbkEHrG5BOKxuQWmsbkGarG5By6xuQfysbkEtrW5BXa1uQY6tbkG/rW5B8K1uQSGubkFSrm5Bg65uQbSubkHlrm5BFa9uQUavbkF3r25BqK9uQdmvbkEKsG5BO7BuQWuwbkGcsG5BzbBuQf6wbkEvsW5BYLFuQZGxbkHBsW5B8rFuQSOybkFUsm5BhbJuQbaybkHnsm5BF7NuQUizbkF5s25BqrNuQduzbkEMtG5BPLRuQW20bkGetG5Bz7RuQQC1bkExtW5BYbVuQZK1bkHDtW5B9LVuQSW2bkFWtm5BhrZuQbe2bkHotm5BGbduQUq3bkF6t25Bq7duQdy3bkENuG5BPrhuQW64bkGfuG5B0LhuQQG5bkEyuW5BYrluQZO5bkHEuW5B9bluQSW6bkFWum5Bh7puQbi6bkHpum5BGbtuQUq7bkF7u25BrLtuQdy7bkENvG5BPrxuQW+8bkGgvG5B0LxuQQG9bkEyvW5BY71uQZO9bkHEvW5B9b1uQSa+bkFWvm5Bh75uQbi+bkHpvm5BGb9uQUq/bkF7v25BrL9uQdy/bkENwG5BPsBuQW7AbkGfwG5B0MBuQQHBbkExwW5BYsFuQZPBbkHEwW5B9MFuQSXCbkFWwm5BhsJuQbfCbkHowm5BGcNuQUnDbkF6w25Bq8NuQdvDbkEMxG5BPcRuQW7EbkGexG5Bz8RuQQDFbkEwxW5BYcVuQZLFbkHCxW5B88VuQSTGbkFUxm5BhcZuQbbGbkHmxm5BF8duQUjHbkF4x25BqcduQdrHbkEKyG5BO8huQWzIbkGcyG5BzchuQf7IbkEuyW5BX8luQZDJbkHAyW5B8cluQSLKbkFSym5Bg8puQbTKbkHkym5BFctuQUbLbkF2y25Bp8tuQdjLbkEIzG5BOcxuQWnMbkGazG5By8xuQfvMbkEszW5BXc1uQY3NbkG+zW5B7s1uQR/ObkFQzm5BgM5uQbHObkHizm5BEs9uQUPPbkFzz25BpM9uQdXPbkEF0G5BNtBuQWbQbkGX0G5ByNBuQfjQbkEp0W5BWdFuQYrRbkG70W5B69FuQRzSbkFM0m5BfdJuQa7SbkHe0m5BD9NuQT/TbkFw025BoNNuQdHTbkEC1G5BMtRuQWPUbkGT1G5BxNRuQfTUbkEl1W5BVdVuQYbVbkG31W5B59VuQRjWbkFI1m5BedZuQanWbkHa1m5BCtduQTvXbkFs125BnNduQc3XbkH9125BLthuQV7YbkGP2G5Bv9huQfDYbkEg2W5BUdluQYHZbkGy2W5B4tluQRPabkFE2m5BdNpuQaXabkHV2m5BBttuQTbbbkFn225Bl9tuQcjbbkH4225BKdxuQVncbkGK3G5ButxuQevcbkEb3W5BTN1uQXzdbkGt3W5B3d1uQQ7ebkE+3m5Bb95uQZ/ebkHQ3m5BAN9uQTDfbkFh325Bkd9uQcLfbkHy325BI+BuQVPgbkGE4G5BtOBuQeXgbkEV4W5BRuFuQXbhbkGn4W5B1+FuQQfibkE44m5BaOJuQZnibkHJ4m5B+uJuQSrjbkFb425Bi+NuQbzjbkHs425BHORuQU3kbkF95G5BruRuQd7kbkEP5W5BP+VuQW/lbkGg5W5B0OVuQQHmbkEx5m5BYuZuQZLmbkHC5m5B8+ZuQSPnbkFU525BhOduQbTnbkHl525BFehuQUbobkF26G5BpuhuQdfobkEH6W5BOOluQWjpbkGY6W5ByeluQfnpbkEq6m5BWupuQYrqbkG76m5B6+puQRzrbkFM625BfOtuQa3rbkHd625BDexuQT7sbkFu7G5Bn+xuQc/sbkH/7G5BMO1uQWDtbkGQ7W5Bwe1uQfHtbkEh7m5BUu5uQYLubkGz7m5B4+5uQRPvbkFE725BdO9uQaTvbkHV725BBfBuQTXwbkFm8G5BlvBuQcbwbkH38G5BJ/FuQVfxbkGI8W5BuPFuQejxbkEZ8m5BSfJuQXnybkGq8m5B2vJuQQrzbkE7825Ba/NuQZvzbkHL825B/PNuQSz0bkFc9G5BjfRuQb30bkHt9G5BHvVuQU71bkF+9W5BrvVuQd/1bkEP9m5BP/ZuQXD2bkGg9m5B0PZuQQD3bkEx925BYfduQZH3bkHC925B8vduQSL4bkFS+G5Bg/huQbP4bkHj+G5BFPluQUT5bkF0+W5BpPluQdX5bkEF+m5BNfpuQWX6bkGW+m5BxvpuQfb6bkEm+25BV/tuQYf7bkG3+25B5/tuQRj8bkFI/G5BePxuQaj8bkHZ/G5BCf1uQTn9bkFp/W5Bmf1uQcr9bkH6/W5BKv5uQVr+bkGL/m5Bu/5uQev+bkEb/25BS/9uQXz/bkGs/25B3P9uQQwAb0E9AG9BbQBvQZ0Ab0HNAG9B/QBvQS4Bb0FeAW9BjgFvQb4Bb0HuAW9BHwJvQU8Cb0F/Am9BrwJvQd8Cb0EPA29BQANvQXADb0GgA29B0ANvQQAEb0ExBG9BYQRvQZEEb0HBBG9B8QRvQSEFb0FSBW9BggVvQbIFb0HiBW9BEgZvQUIGb0FzBm9BowZvQdMGb0EDB29BMwdvQWMHb0GTB29BxAdvQfQHb0EkCG9BVAhvQYQIb0G0CG9B5AhvQRUJb0FFCW9BdQlvQaUJb0HVCW9BBQpvQTUKb0FmCm9BlgpvQcYKb0H2Cm9BJgtvQVYLb0GGC29BtgtvQeYLb0EXDG9BRwxvQXcMb0GnDG9B1wxvQQcNb0E3DW9BZw1vQZcNb0HIDW9B+A1vQSgOb0FYDm9BiA5vQbgOb0HoDm9BGA9vQUgPb0F4D29BqA9vQdkPb0EJEG9BORBvQWkQb0GZEG9ByRBvQfkQb0EpEW9BWRFvQYkRb0G5EW9B6RFvQRkSb0FJEm9BehJvQaoSb0HaEm9BChNvQToTb0FqE29BmhNvQcoTb0H6E29BKhRvQVoUb0GKFG9BuhRvQeoUb0EaFW9BShVvQXoVb0GqFW9B2hVvQQoWb0E6Fm9BahZvQZoWb0HKFm9B+xZvQSsXb0FbF29BixdvQbsXb0HrF29BGxhvQUsYb0F7GG9BqxhvQdsYb0ELGW9BOxlvQWsZb0GbGW9ByxlvQfsZb0ErGm9BWxpvQYsab0G7Gm9B6xpvQRsbb0FLG29BextvQasbb0HbG29BCxxvQTscb0FrHG9BmxxvQcscb0H6HG9BKh1vQVodb0GKHW9Buh1vQeodb0EaHm9BSh5vQXoeb0GqHm9B2h5vQQofb0E6H29Bah9vQZofb0HKH29B+h9vQSogb0FaIG9BiiBvQbogb0HqIG9BGiFvQUkhb0F5IW9BqSFvQdkhb0EJIm9BOSJvQWkib0GZIm9BySJvQfkib0EpI29BWSNvQYkjb0G5I29B6CNvQRgkb0FIJG9BeCRvQagkb0HYJG9BCCVvQTglb0FoJW9BmCVvQcglb0H3JW9BJyZvQVcmb0GHJm9BtyZvQecmb0EXJ29BRydvQXcnb0GnJ29B1idvQQYob0E2KG9BZihvQZYob0HGKG9B9ihvQSYpb0FVKW9BhSlvQbUpb0HlKW9BFSpvQUUqb0F1Km9BpSpvQdQqb0EEK29BNCtvQWQrb0GUK29BxCtvQfQrb0EjLG9BUyxvQYMsb0GzLG9B4yxvQRMtb0FCLW9Bci1vQaItb0HSLW9BAi5vQTIub0FiLm9BkS5vQcEub0HxLm9BIS9vQVEvb0GAL29BsC9vQeAvb0EQMG9BQDBvQXAwb0GfMG9BzzBvQf8wb0EvMW9BXzFvQY4xb0G+MW9B7jFvQR4yb0FOMm9BfTJvQa0yb0HdMm9BDTNvQT0zb0FsM29BnDNvQcwzb0H8M29BLDRvQVs0b0GLNG9BuzRvQes0b0EbNW9BSjVvQXo1b0GqNW9B2jVvQQk2b0E5Nm9BaTZvQZk2b0HINm9B+DZvQSg3b0FYN29BiDdvQbc3b0HnN29BFzhvQUc4b0F2OG9BpjhvQdY4b0EGOW9BNTlvQWU5b0GVOW9BxTlvQfQ5b0EkOm9BVDpvQYM6b0GzOm9B4zpvQRM7b0FCO29BcjtvQaI7b0HSO29BATxvQTE8b0FhPG9BkDxvQcA8b0HwPG9BID1vQU89b0F/PW9Brz1vQd49b0EOPm9BPj5vQW4+b0GdPm9BzT5vQf0+b0EsP29BXD9vQYw/b0G7P29B6z9vQRtAb0FLQG9BekBvQapAb0HaQG9BCUFvQTlBb0FpQW9BmEFvQchBb0H4QW9BJ0JvQVdCb0GHQm9BtkJvQeZCb0EWQ29BRUNvQXVDb0GlQ29B1ENvQQREb0E0RG9BY0RvQZNEb0HDRG9B8kRvQSJFb0FSRW9BgUVvQbFFb0HhRW9BEEZvQUBGb0FvRm9Bn0ZvQc9Gb0H+Rm9BLkdvQV5Hb0GNR29BvUdvQe1Hb0EcSG9BTEhvQXtIb0GrSG9B20hvQQpJb0E6SW9BaklvQZlJb0HJSW9B+ElvQShKb0FYSm9Bh0pvQbdKb0HmSm9BFktvQUZLb0F1S29BpUtvQdRLb0EETG9BNExvQWNMb0GTTG9BwkxvQfJMb0EiTW9BUU1vQYFNb0GwTW9B4E1vQQ9Ob0E/Tm9Bb05vQZ5Ob0HOTm9B/U5vQS1Pb0FcT29BjE9vQbxPb0HrT29BG1BvQUpQb0F6UG9BqVBvQdlQb0EIUW9BOFFvQWhRb0GXUW9Bx1FvQfZRb0EmUm9BVVJvQYVSb0G0Um9B5FJvQRNTb0FDU29Bc1NvQaJTb0HSU29BAVRvQTFUb0FgVG9BkFRvQb9Ub0HvVG9BHlVvQU5Vb0F9VW9BrVVvQdxVb0EMVm9BO1ZvQWtWb0GaVm9BylZvQflWb0EpV29BWFdvQYhXb0G3V29B51dvQRZYb0FGWG9BdVhvQaVYb0HUWG9BBFlvQTNZb0FjWW9BkllvQcJZb0HxWW9BIVpvQVBab0GAWm9Br1pvQd9ab0EOW29BPltvQW1bb0GdW29BzFtvQfxbb0ErXG9BWlxvQYpcb0G5XG9B6VxvQRhdb0FIXW9Bd11vQaddb0HWXW9BBl5vQTVeb0FkXm9BlF5vQcNeb0HzXm9BIl9vQVJfb0GBX29BsV9vQeBfb0EPYG9BP2BvQW5gb0GeYG9BzWBvQf1gb0EsYW9BW2FvQYthb0G6YW9B6mFvQRlib0FIYm9BeGJvQadib0HXYm9BBmNvQTZjb0FlY29BlGNvQcRjb0HzY29BI2RvQVJkb0GBZG9BsWRvQeBkb0EQZW9BP2VvQW5lb0GeZW9BzWVvQfxlb0EsZm9BW2ZvQYtmb0G6Zm9B6WZvQRlnb0FIZ29BeGdvQadnb0HWZ29BBmhvQTVob0FkaG9BlGhvQcNob0HyaG9BImlvQVFpb0GBaW9BsGlvQd9pb0EPam9BPmpvQW1qb0Gdam9BzGpvQftqb0Era29BWmtvQYlrb0G5a29B6GtvQRdsb0FHbG9BdmxvQaVsb0HVbG9BBG1vQTNtb0FjbW9Bkm1vQcFtb0HxbW9BIG5vQU9ub0F/bm9Brm5vQd1ub0ENb29BPG9vQWtvb0Gbb29Bym9vQflvb0EocG9BWHBvQYdwb0G2cG9B5nBvQRVxb0FEcW9BdHFvQaNxb0HScW9BAXJvQTFyb0Fgcm9Bj3JvQb9yb0Hucm9BHXNvQUxzb0F8c29Bq3NvQdpzb0EJdG9BOXRvQWh0b0GXdG9Bx3RvQfZ0b0EldW9BVHVvQYR1b0GzdW9B4nVvQRF2b0FBdm9BcHZvQZ92b0HOdm9B/nZvQS13b0Fcd29Bi3dvQbt3b0Hqd29BGXhvQUh4b0F4eG9Bp3hvQdZ4b0EFeW9BNXlvQWR5b0GTeW9BwnlvQfF5b0Ehem9BUHpvQX96b0Guem9B3npvQQ17b0E8e29Ba3tvQZp7b0HKe29B+XtvQSh8b0FXfG9BhnxvQbZ8b0HlfG9BFH1vQUN9b0FyfW9Bon1vQdF9b0EAfm9BL35vQV5+b0GOfm9BvX5vQex+b0Ebf29BSn9vQXp/b0Gpf29B2H9vQQeAb0E2gG9BZYBvQZWAb0HEgG9B84BvQSKBb0FRgW9BgIFvQbCBb0HfgW9BDoJvQT2Cb0Fsgm9Bm4JvQcuCb0H6gm9BKYNvQViDb0GHg29BtoNvQeWDb0EVhG9BRIRvQXOEb0GihG9B0YRvQQCFb0EvhW9BX4VvQY6Fb0G9hW9B7IVvQRuGb0FKhm9BeYZvQamGb0HYhm9BB4dvQTaHb0Flh29BlIdvQcOHb0Hyh29BIYhvQVGIb0GAiG9Br4hvQd6Ib0ENiW9BPIlvQWuJb0GaiW9ByYlvQfmJb0Eoim9BV4pvQYaKb0G1im9B5IpvQROLb0FCi29BcYtvQaCLb0HPi29B/4tvQS6Mb0FdjG9BjIxvQbuMb0HqjG9BGY1vQUiNb0F3jW9Bpo1vQdWNb0EEjm9BM45vQWKOb0GSjm9BwY5vQfCOb0Efj29BTo9vQX2Pb0Gsj29B249vQQqQb0E5kG9BaJBvQZeQb0HGkG9B9ZBvQSSRb0FTkW9BgpFvQbGRb0HgkW9BD5JvQT6Sb0Ftkm9BnJJvQcySb0H7km9BKpNvQVmTb0GIk29Bt5NvQeaTb0EVlG9BRJRvQXOUb0GilG9B0ZRvQQCVb0EvlW9BXpVvQY2Vb0G8lW9B65VvQRqWb0FJlm9BeJZvQaeWb0HWlm9BBZdvQTSXb0Fjl29BkpdvQcGXb0Hwl29BH5hvQU6Yb0F9mG9BrJhvQduYb0EKmW9BOZlvQWiZb0GXmW9BxplvQfSZb0Ejmm9BUppvQYGab0Gwmm9B35pvQQ6bb0E9m29BbJtvQZubb0HKm29B+ZtvQSicb0FXnG9BhpxvQbWcb0HknG9BE51vQUKdb0FxnW9BoJ1vQc+db0H9nW9BLJ5vQVueb0GKnm9BuZ5vQeieb0EXn29BRp9vQXWfb0Gkn29B059vQQKgb0ExoG9BYKBvQY6gb0G9oG9B7KBvQRuhb0FKoW9BeaFvQaihb0HXoW9BBqJvQTWib0Fkom9BkqJvQcGib0Hwom9BH6NvQU6jb0F9o29BrKNvQdujb0EKpG9BOaRvQWekb0GWpG9BxaRvQfSkb0EjpW9BUqVvQYGlb0GwpW9B3qVvQQ2mb0E8pm9Ba6ZvQZqmb0HJpm9B+KZvQSenb0FVp29BhKdvQbOnb0Hip29BEahvQUCob0FvqG9BnahvQcyob0H7qG9BKqlvQVmpb0GIqW9Bt6lvQeWpb0EUqm9BQ6pvQXKqb0Ghqm9B0KpvQf6qb0Etq29BXKtvQYurb0G6q29B6atvQResb0FGrG9BdaxvQaSsb0HTrG9BAq1vQTCtb0FfrW9Bjq1vQb2tb0HsrW9BGq5vQUmub0F4rm9Bp65vQdaub0EEr29BM69vQWKvb0GRr29BwK9vQe6vb0EdsG9BTLBvQXuwb0GqsG9B2LBvQQexb0E2sW9BZbFvQZSxb0HCsW9B8bFvQSCyb0FPsm9BfbJvQayyb0Hbsm9BCrNvQTmzb0Fns29BlrNvQcWzb0H0s29BIrRvQVG0b0GAtG9Br7RvQd20b0EMtW9BO7VvQWq1b0GYtW9Bx7VvQfa1b0Eltm9BU7ZvQYK2b0Gxtm9B4LZvQQ63b0E9t29BbLdvQZu3b0HJt29B+LdvQSe4b0FWuG9BhLhvQbO4b0HiuG9BELlvQT+5b0FuuW9BnblvQcu5b0H6uW9BKbpvQVe6b0GGum9BtbpvQeS6b0ESu29BQbtvQXC7b0Geu29BzbtvQfy7b0ErvG9BWbxvQYi8b0G3vG9B5bxvQRS9b0FDvW9Bcb1vQaC9b0HPvW9B/b1vQSy+b0Fbvm9Bir5vQbi+b0Hnvm9BFr9vQUS/b0Fzv29Bor9vQdC/b0H/v29BLsBvQVzAb0GLwG9BusBvQejAb0EXwW9BRsFvQXTBb0GjwW9B0sFvQQDCb0Evwm9BXcJvQYzCb0G7wm9B6cJvQRjDb0FHw29BdcNvQaTDb0HTw29BAcRvQTDEb0FfxG9BjcRvQbzEb0HqxG9BGcVvQUjFb0F2xW9BpcVvQdTFb0ECxm9BMcZvQV/Gb0GOxm9BvcZvQevGb0Eax29BScdvQXfHb0Gmx29B1MdvQQPIb0EyyG9BYMhvQY/Ib0G9yG9B7MhvQRvJb0FJyW9BeMlvQabJb0HVyW9BBMpvQTLKb0Fhym9Bj8pvQb7Kb0Hsym9BG8tvQUrLb0F4y29Bp8tvQdXLb0EEzG9BMsxvQWHMb0GQzG9BvsxvQe3Mb0EbzW9BSs1vQXjNb0GnzW9B1s1vQQTOb0Ezzm9BYc5vQZDOb0G+zm9B7c5vQRvPb0FKz29Bec9vQafPb0HWz29BBNBvQTPQb0Fh0G9BkNBvQb7Qb0Ht0G9BG9FvQUrRb0F50W9Bp9FvQdbRb0EE0m9BM9JvQWHSb0GQ0m9BvtJvQe3Sb0Eb029BStNvQXjTb0Gn029B1dNvQQTUb0Ey1G9BYdRvQY/Ub0G+1G9B7NRvQRvVb0FJ1W9BeNVvQabVb0HV1W9BA9ZvQTLWb0Fg1m9Bj9ZvQb3Wb0Hs1m9BGtdvQUnXb0F3129BptdvQdTXb0ED2G9BMdhvQWDYb0GO2G9BvdhvQevYb0Ea2W9BSNlvQXbZb0Gl2W9B09lvQQLab0Ew2m9BX9pvQY3ab0G82m9B6tpvQRnbb0FH229BdttvQaTbb0HS229BAdxvQS/cb0Fe3G9BjNxvQbvcb0Hp3G9BGN1vQUbdb0F03W9Bo91vQdHdb0EA3m9BLt5vQV3eb0GL3m9Bud5vQejeb0EW329BRd9vQXPfb0Gi329B0N9vQf7fb0Et4G9BW+BvQYrgb0G44G9B5uBvQRXhb0FD4W9BcuFvQaDhb0HP4W9B/eFvQSvib0Fa4m9BiOJvQbfib0Hl4m9BE+NvQULjb0Fw429BnuNvQc3jb0H7429BKuRvQVjkb0GG5G9BteRvQePkb0ES5W9BQOVvQW7lb0Gd5W9By+VvQfnlb0Eo5m9BVuZvQYXmb0Gz5m9B4eZvQRDnb0E+529BbOdvQZvnb0HJ529B9+dvQSbob0FU6G9BguhvQbHob0Hf6G9BDelvQTzpb0Fq6W9BmelvQcfpb0H16W9BJOpvQVLqb0GA6m9Br+pvQd3qb0EL629BOutvQWjrb0GW629BxetvQfPrb0Eh7G9BT+xvQX7sb0Gs7G9B2uxvQQntb0E37W9BZe1vQZTtb0HC7W9B8O1vQR/ub0FN7m9Be+5vQarub0HY7m9BBu9vQTTvb0Fj729Bke9vQb/vb0Hu729BHPBvQUrwb0F48G9Bp/BvQdXwb0ED8W9BMvFvQWDxb0GO8W9BvPFvQevxb0EZ8m9BR/JvQXbyb0Gk8m9B0vJvQQDzb0Ev829BXfNvQYvzb0G5829B6PNvQRb0b0FE9G9BcvRvQaH0b0HP9G9B/fRvQSv1b0Fa9W9BiPVvQbb1b0Hk9W9BE/ZvQUH2b0Fv9m9BnfZvQcz2b0H69m9BKPdvQVb3b0GF929Bs/dvQeH3b0EP+G9BPvhvQWz4b0Ga+G9ByPhvQfb4b0El+W9BU/lvQYH5b0Gv+W9B3vlvQQz6b0E6+m9BaPpvQZb6b0HF+m9B8/pvQSH7b0FP+29BfftvQaz7b0Ha+29BCPxvQTb8b0Fk/G9Bk/xvQcH8b0Hv/G9BHf1vQUv9b0F6/W9BqP1vQdb9b0EE/m9BMv5vQWD+b0GP/m9Bvf5vQev+b0EZ/29BR/9vQXX/b0Gk/29B0v9vQQAAcEEuAHBBXABwQYoAcEG5AHBB5wBwQRUBcEFDAXBBcQFwQZ8BcEHOAXBB/AFwQSoCcEFYAnBBhgJwQbQCcEHiAnBBEQNwQT8DcEFtA3BBmwNwQckDcEH3A3BBJQRwQVQEcEGCBHBBsARwQd4EcEEMBXBBOgVwQWgFcEGWBXBBxQVwQfMFcEEhBnBBTwZwQX0GcEGrBnBB2QZwQQcHcEE2B3BBZAdwQZIHcEHAB3BB7gdwQRwIcEFKCHBBeAhwQaYIcEHUCHBBAwlwQTEJcEFfCXBBjQlwQbsJcEHpCXBBFwpwQUUKcEFzCnBBoQpwQc8KcEH+CnBBLAtwQVoLcEGIC3BBtgtwQeQLcEESDHBBQAxwQW4McEGcDHBBygxwQfgMcEEmDXBBVA1wQYMNcEGxDXBB3w1wQQ0OcEE7DnBBaQ5wQZcOcEHFDnBB8w5wQSEPcEFPD3BBfQ9wQasPcEHZD3BBBxBwQTUQcEFjEHBBkRBwQb8QcEHtEHBBGxFwQUkRcEF4EXBBphFwQdQRcEECEnBBMBJwQV4ScEGMEnBBuhJwQegScEEWE3BBRBNwQXITcEGgE3BBzhNwQfwTcEEqFHBBWBRwQYYUcEG0FHBB4hRwQRAVcEE+FXBBbBVwQZoVcEHIFXBB9hVwQSQWcEFSFnBBgBZwQa4WcEHcFnBBChdwQTgXcEFmF3BBlBdwQcIXcEHwF3BBHhhwQUwYcEF6GHBBqBhwQdYYcEEEGXBBMhlwQV8ZcEGNGXBBuxlwQekZcEEXGnBBRRpwQXMacEGhGnBBzxpwQf0acEErG3BBWRtwQYcbcEG1G3BB4xtwQREccEE/HHBBbRxwQZsccEHJHHBB9xxwQSUdcEFSHXBBgB1wQa4dcEHcHXBBCh5wQTgecEFmHnBBlB5wQcIecEHwHnBBHh9wQUwfcEF6H3BBqB9wQdUfcEEDIHBBMSBwQV8gcEGNIHBBuyBwQekgcEEXIXBBRSFwQXMhcEGhIXBBziFwQfwhcEEqInBBWCJwQYYicEG0InBB4iJwQRAjcEE+I3BBbCNwQZkjcEHHI3BB9SNwQSMkcEFRJHBBfyRwQa0kcEHbJHBBCCVwQTYlcEFkJXBBkiVwQcAlcEHuJXBBHCZwQUomcEF3JnBBpSZwQdMmcEEBJ3BBLydwQV0ncEGLJ3BBuCdwQeYncEEUKHBBQihwQXAocEGeKHBBzChwQfkocEEnKXBBVSlwQYMpcEGxKXBB3ylwQQ0qcEE6KnBBaCpwQZYqcEHEKnBB8ipwQSArcEFNK3BBeytwQakrcEHXK3BBBSxwQTIscEFgLHBBjixwQbwscEHqLHBBGC1wQUUtcEFzLXBBoS1wQc8tcEH9LXBBKi5wQVgucEGGLnBBtC5wQeIucEEPL3BBPS9wQWsvcEGZL3BBxy9wQfQvcEEiMHBBUDBwQX4wcEGsMHBB2TBwQQcxcEE1MXBBYzFwQZExcEG+MXBB7DFwQRoycEFIMnBBdTJwQaMycEHRMnBB/zJwQSwzcEFaM3BBiDNwQbYzcEHkM3BBETRwQT80cEFtNHBBmzRwQcg0cEH2NHBBJDVwQVI1cEF/NXBBrTVwQds1cEEJNnBBNjZwQWQ2cEGSNnBBwDZwQe02cEEbN3BBSTdwQXc3cEGkN3BB0jdwQQA4cEEtOHBBWzhwQYk4cEG3OHBB5DhwQRI5cEFAOXBBbjlwQZs5cEHJOXBB9zlwQSQ6cEFSOnBBgDpwQa46cEHbOnBBCTtwQTc7cEFkO3BBkjtwQcA7cEHtO3BBGzxwQUk8cEF3PHBBpDxwQdI8cEEAPXBBLT1wQVs9cEGJPXBBtj1wQeQ9cEESPnBBPz5wQW0+cEGbPnBByT5wQfY+cEEkP3BBUj9wQX8/cEGtP3BB2z9wQQhAcEE2QHBBZEBwQZFAcEG/QHBB7UBwQRpBcEFIQXBBdkFwQaNBcEHRQXBB/kFwQSxCcEFaQnBBh0JwQbVCcEHjQnBBEENwQT5DcEFsQ3BBmUNwQcdDcEH1Q3BBIkRwQVBEcEF+RHBBq0RwQdlEcEEGRXBBNEVwQWJFcEGPRXBBvUVwQetFcEEYRnBBRkZwQXNGcEGhRnBBz0ZwQfxGcEEqR3BBV0dwQYVHcEGzR3BB4EdwQQ5IcEE8SHBBaUhwQZdIcEHESHBB8khwQSBJcEFNSXBBe0lwQahJcEHWSXBBBEpwQTFKcEFfSnBBjEpwQbpKcEHnSnBBFUtwQUNLcEFwS3BBnktwQctLcEH5S3BBJ0xwQVRMcEGCTHBBr0xwQd1McEEKTXBBOE1wQWVNcEGTTXBBwU1wQe5NcEEcTnBBSU5wQXdOcEGkTnBB0k5wQQBPcEEtT3BBW09wQYhPcEG2T3BB409wQRFQcEE+UHBBbFBwQZlQcEHHUHBB9VBwQSJRcEFQUXBBfVFwQatRcEHYUXBBBlJwQTNScEFhUnBBjlJwQbxScEHpUnBBF1NwQURTcEFyU3BBn1NwQc1TcEH6U3BBKFRwQVZUcEGDVHBBsVRwQd5UcEEMVXBBOVVwQWdVcEGUVXBBwlVwQe9VcEEdVnBBSlZwQXhWcEGlVnBB01ZwQQBXcEEuV3BBW1dwQYlXcEG2V3BB41dwQRFYcEE+WHBBbFhwQZlYcEHHWHBB9FhwQSJZcEFPWXBBfVlwQapZcEHYWXBBBVpwQTNacEFgWnBBjlpwQbtacEHpWnBBFltwQUNbcEFxW3BBnltwQcxbcEH5W3BBJ1xwQVRccEGCXHBBr1xwQd1ccEEKXXBBN11wQWVdcEGSXXBBwF1wQe1dcEEbXnBBSF5wQXVecEGjXnBB0F5wQf5ecEErX3BBWV9wQYZfcEGzX3BB4V9wQQ5gcEE8YHBBaWBwQZdgcEHEYHBB8WBwQR9hcEFMYXBBemFwQadhcEHUYXBBAmJwQS9icEFdYnBBimJwQbdicEHlYnBBEmNwQUBjcEFtY3BBmmNwQchjcEH1Y3BBI2RwQVBkcEF9ZHBBq2RwQdhkcEEGZXBBM2VwQWBlcEGOZXBBu2VwQellcEEWZnBBQ2ZwQXFmcEGeZnBBy2ZwQflmcEEmZ3BBU2dwQYFncEGuZ3BB3GdwQQlocEE2aHBBZGhwQZFocEG+aHBB7GhwQRlpcEFGaXBBdGlwQaFpcEHOaXBB/GlwQSlqcEFXanBBhGpwQbFqcEHfanBBDGtwQTlrcEFna3BBlGtwQcFrcEHva3BBHGxwQUlscEF3bHBBpGxwQdFscEH+bHBBLG1wQVltcEGGbXBBtG1wQeFtcEEObnBBPG5wQWlucEGWbnBBxG5wQfFucEEeb3BBTG9wQXlvcEGmb3BB029wQQFwcEEucHBBW3BwQYlwcEG2cHBB43BwQRFxcEE+cXBBa3FwQZhxcEHGcXBB83FwQSBycEFOcnBBe3JwQahycEHVcnBBA3NwQTBzcEFdc3BBinNwQbhzcEHlc3BBEnRwQUB0cEFtdHBBmnRwQcd0cEH1dHBBInVwQU91cEF8dXBBqnVwQdd1cEEEdnBBMXZwQV92cEGMdnBBuXZwQeZ2cEEUd3BBQXdwQW53cEGbd3BByXdwQfZ3cEEjeHBBUHhwQX54cEGreHBB2HhwQQV5cEEzeXBBYHlwQY15cEG6eXBB53lwQRV6cEFCenBBb3pwQZx6cEHKenBB93pwQSR7cEFRe3BBfntwQax7cEHZe3BBBnxwQTN8cEFgfHBBjnxwQbt8cEHofHBBFX1wQUJ9cEFwfXBBnX1wQcp9cEH3fXBBJH5wQVJ+cEF/fnBBrH5wQdl+cEEGf3BBNH9wQWF/cEGOf3BBu39wQeh/cEEVgHBBQ4BwQXCAcEGdgHBByoBwQfeAcEEkgXBBUoFwQX+BcEGsgXBB2YFwQQaCcEEzgnBBYYJwQY6CcEG7gnBB6IJwQRWDcEFCg3BBcINwQZ2DcEHKg3BB94NwQSSEcEFRhHBBfoRwQayEcEHZhHBBBoVwQTOFcEFghXBBjYVwQbqFcEHohXBBFYZwQUKGcEFvhnBBnIZwQcmGcEH2hnBBI4dwQVGHcEF+h3BBq4dwQdiHcEEFiHBBMohwQV+IcEGMiHBBuYhwQeeIcEEUiXBBQYlwQW6JcEGbiXBByIlwQfWJcEEiinBBT4pwQXyKcEGqinBB14pwQQSLcEExi3BBXotwQYuLcEG4i3BB5YtwQRKMcEE/jHBBbIxwQZqMcEHHjHBB9IxwQSGNcEFOjXBBe41wQaiNcEHVjXBBAo5wQS+OcEFcjnBBiY5wQbaOcEHjjnBBEY9wQT6PcEFrj3BBmI9wQcWPcEHyj3BBH5BwQUyQcEF5kHBBppBwQdOQcEEAkXBBLZFwQVqRcEGHkXBBtJFwQeGRcEEOknBBO5JwQWiScEGWknBBw5JwQfCScEEdk3BBSpNwQXeTcEGkk3BB0ZNwQf6TcEErlHBBWJRwQYWUcEGylHBB35RwQQyVcEE5lXBBZpVwQZOVcEHAlXBB7ZVwQRqWcEFHlnBBdJZwQaGWcEHOlnBB+5ZwQSiXcEFVl3BBgpdwQa+XcEHcl3BBCZhwQTaYcEFjmHBBkJhwQb2YcEHqmHBBF5lwQUSZcEFxmXBBnplwQcuZcEH4mXBBJZpwQVKacEF/mnBBrJpwQdmacEEGm3BBM5twQWCbcEGNm3BBuptwQeebcEETnHBBQJxwQW2ccEGanHBBx5xwQfSccEEhnXBBTp1wQXudcEGonXBB1Z1wQQKecEEvnnBBXJ5wQYmecEG2nnBB455wQRCfcEE9n3BBap9wQZafcEHDn3BB8J9wQR2gcEFKoHBBd6BwQaSgcEHRoHBB/qBwQSuhcEFYoXBBhaFwQbKhcEHfoXBBC6JwQTiicEFlonBBkqJwQb+icEHsonBBGaNwQUajcEFzo3BBoKNwQc2jcEH5o3BBJqRwQVOkcEGApHBBraRwQdqkcEEHpXBBNKVwQWGlcEGOpXBBuqVwQeelcEEUpnBBQaZwQW6mcEGbpnBByKZwQfWmcEEhp3BBTqdwQXuncEGop3BB1adwQQKocEEvqHBBXKhwQYiocEG1qHBB4qhwQQ+pcEE8qXBBaalwQZapcEHDqXBB76lwQRyqcEFJqnBBdqpwQaOqcEHQqnBB/KpwQSmrcEFWq3BBg6twQbCrcEHdq3BBCqxwQTascEFjrHBBkKxwQb2scEHqrHBBF61wQUOtcEFwrXBBna1wQcqtcEH3rXBBJK5wQVCucEF9rnBBqq5wQdeucEEEr3BBMK9wQV2vcEGKr3BBt69wQeSvcEERsHBBPbBwQWqwcEGXsHBBxLBwQfGwcEEdsXBBSrFwQXexcEGksXBB0bFwQf2xcEEqsnBBV7JwQYSycEGxsnBB3bJwQQqzcEE3s3BBZLNwQZGzcEG9s3BB6rNwQRe0cEFEtHBBcLRwQZ20cEHKtHBB97RwQSS1cEFQtXBBfbVwQaq1cEHXtXBBA7ZwQTC2cEFdtnBBirZwQba2cEHjtnBBELdwQT23cEFpt3BBlrdwQcO3cEHwt3BBHLhwQUm4cEF2uHBBo7hwQc+4cEH8uHBBKblwQVa5cEGCuXBBr7lwQdy5cEEJunBBNbpwQWK6cEGPunBBvLpwQei6cEEVu3BBQrtwQW67cEGbu3BByLtwQfW7cEEhvHBBTrxwQXu8cEGovHBB1LxwQQG9cEEuvXBBWr1wQYe9cEG0vXBB4b1wQQ2+cEE6vnBBZ75wQZO+cEHAvnBB7b5wQRm/cEFGv3BBc79wQZ+/cEHMv3BB+b9wQSbAcEFSwHBBf8BwQazAcEHYwHBBBcFwQTLBcEFewXBBi8FwQbjBcEHkwXBBEcJwQT7CcEFqwnBBl8JwQcTCcEHwwnBBHcNwQUrDcEF2w3BBo8NwQdDDcEH8w3BBKcRwQVbEcEGCxHBBr8RwQdzEcEEIxXBBNcVwQWLFcEGOxXBBu8VwQejFcEEUxnBBQcZwQW7GcEGaxnBBx8ZwQfPGcEEgx3BBTcdwQXnHcEGmx3BB08dwQf/HcEEsyHBBWchwQYXIcEGyyHBB3shwQQvJcEE4yXBBZMlwQZHJcEG9yXBB6slwQRfKcEFDynBBcMpwQZ3KcEHJynBB9spwQSLLcEFPy3BBfMtwQajLcEHVy3BBAcxwQS7McEFbzHBBh8xwQbTMcEHgzHBBDc1wQTrNcEFmzXBBk81wQb/NcEHszXBBGM5wQUXOcEFyznBBns5wQcvOcEH3znBBJM9wQVHPcEF9z3BBqs9wQdbPcEED0HBBL9BwQVzQcEGJ0HBBtdBwQeLQcEEO0XBBO9FwQWfRcEGU0XBBwNFwQe3RcEEa0nBBRtJwQXPScEGf0nBBzNJwQfjScEEl03BBUdNwQX7TcEGr03BB19NwQQTUcEEw1HBBXdRwQYnUcEG21HBB4tRwQQ/VcEE71XBBaNVwQZTVcEHB1XBB7dVwQRrWcEFG1nBBc9ZwQaDWcEHM1nBB+dZwQSXXcEFS13BBftdwQavXcEHX13BBBNhwQTDYcEFd2HBBidhwQbbYcEHi2HBBD9lwQTvZcEFo2XBBlNlwQcHZcEHt2XBBGtpwQUbacEFz2nBBn9pwQczacEH42nBBJdtwQVHbcEF+23BBqttwQdfbcEED3HBBL9xwQVzccEGI3HBBtdxwQeHccEEO3XBBOt1wQWfdcEGT3XBBwN1wQezdcEEZ3nBBRd5wQXLecEGe3nBBy95wQffecEEj33BBUN9wQXzfcEGp33BB1d9wQQLgcEEu4HBBW+BwQYfgcEGz4HBB4OBwQQzhcEE54XBBZeFwQZLhcEG+4XBB6+FwQRficEFD4nBBcOJwQZzicEHJ4nBB9eJwQSLjcEFO43BBeuNwQafjcEHT43BBAORwQSzkcEFY5HBBheRwQbHkcEHe5HBBCuVwQTflcEFj5XBBj+VwQbzlcEHo5XBBFeZwQUHmcEFt5nBBmuZwQcbmcEHz5nBBH+dwQUvncEF453BBpOdwQdHncEH953BBKehwQVbocEGC6HBBruhwQdvocEEH6XBBNOlwQWDpcEGM6XBBuelwQeXpcEES6nBBPupwQWrqcEGX6nBBw+pwQe/qcEEc63BBSOtwQXTrcEGh63BBzetwQfrrcEEm7HBBUuxwQX/scEGr7HBB1+xwQQTtcEEw7XBBXO1wQYntcEG17XBB4e1wQQ7ucEE67nBBZu5wQZPucEG/7nBB6+5wQRjvcEFE73BBcO9wQZ3vcEHJ73BB9e9wQSLwcEFO8HBBevBwQafwcEHT8HBB//BwQSzxcEFY8XBBhPFwQbHxcEHd8XBBCfJwQTbycEFi8nBBjvJwQbvycEHn8nBBE/NwQT/zcEFs83BBmPNwQcTzcEHx83BBHfRwQUn0cEF29HBBovRwQc70cEH69HBBJ/VwQVP1cEF/9XBBrPVwQdj1cEEE9nBBMPZwQV32cEGJ9nBBtfZwQeL2cEEO93BBOvdwQWb3cEGT93BBv/dwQev3cEEX+HBBRPhwQXD4cEGc+HBByfhwQfX4cEEh+XBBTflwQXr5cEGm+XBB0vlwQf75cEEr+nBBV/pwQYP6cEGv+nBB3PpwQQj7cEE0+3BBYPtwQY37cEG5+3BB5ftwQRH8cEE+/HBBavxwQZb8cEHC/HBB7vxwQRv9cEFH/XBBc/1wQZ/9cEHM/XBB+P1wQST+cEFQ/nBBff5wQan+cEHV/nBBAf9wQS3/cEFa/3BBhv9wQbL/cEHe/3BBCgBxQTcAcUFjAHFBjwBxQbsAcUHnAHFBFAFxQUABcUFsAXFBmAFxQcQBcUHxAXFBHQJxQUkCcUF1AnFBoQJxQc4CcUH6AnFBJgNxQVIDcUF+A3FBqwNxQdcDcUEDBHFBLwRxQVsEcUGHBHFBtARxQeAEcUEMBXFBOAVxQWQFcUGQBXFBvQVxQekFcUEVBnFBQQZxQW0GcUGZBnFBxgZxQfIGcUEeB3FBSgdxQXYHcUGiB3FBzwdxQfsHcUEnCHFBUwhxQX8IcUGrCHFB1whxQQQJcUEwCXFBXAlxQYgJcUG0CXFB4AlxQQwKcUE5CnFBZQpxQZEKcUG9CnFB6QpxQRULcUFBC3FBbQtxQZoLcUHGC3FB8gtxQR4McUFKDHFBdgxxQaIMcUHODHFB+gxxQScNcUFTDXFBfw1xQasNcUHXDXFBAw5xQS8OcUFbDnFBhw5xQbQOcUHgDnFBDA9xQTgPcUFkD3FBkA9xQbwPcUHoD3FBFBBxQUAQcUFsEHFBmRBxQcUQcUHxEHFBHRFxQUkRcUF1EXFBoRFxQc0RcUH5EXFBJRJxQVEScUF9EnFBqRJxQdYScUECE3FBLhNxQVoTcUGGE3FBshNxQd4TcUEKFHFBNhRxQWIUcUGOFHFBuhRxQeYUcUESFXFBPhVxQWoVcUGWFXFBwxVxQe8VcUEbFnFBRxZxQXMWcUGfFnFByxZxQfcWcUEjF3FBTxdxQXsXcUGnF3FB0xdxQf8XcUErGHFBVxhxQYMYcUGvGHFB2xhxQQcZcUEzGXFBXxlxQYsZcUG3GXFB4xlxQQ8acUE7GnFBZxpxQZMacUG/GnFB6xpxQRcbcUFDG3FBbxtxQZsbcUHHG3FB8xtxQR8ccUFLHHFBdxxxQaMccUHPHHFB+xxxQScdcUFTHXFBfx1xQasdcUHXHXFBAx5xQS8ecUFbHnFBhx5xQbMecUHfHnFBCx9xQTcfcUFjH3FBjx9xQbsfcUHnH3FBEyBxQT8gcUFrIHFBlyBxQcMgcUHvIHFBGyFxQUchcUFzIXFBnyFxQcshcUH3IXFBIyJxQU8icUF6InFBpiJxQdIicUH+InFBKiNxQVYjcUGCI3FBriNxQdojcUEGJHFBMiRxQV4kcUGKJHFBtiRxQeIkcUEOJXFBOiVxQWUlcUGRJXFBvSVxQeklcUEVJnFBQSZxQW0mcUGZJnFBxSZxQfEmcUEdJ3FBSSdxQXUncUGgJ3FBzCdxQfgncUEkKHFBUChxQXwocUGoKHFB1ChxQQApcUEsKXFBWClxQYMpcUGvKXFB2ylxQQcqcUEzKnFBXypxQYsqcUG3KnFB4ypxQQ4rcUE6K3FBZitxQZIrcUG+K3FB6itxQRYscUFCLHFBbixxQZkscUHFLHFB8SxxQR0tcUFJLXFBdS1xQaEtcUHMLXFB+C1xQSQucUFQLnFBfC5xQagucUHULnFBAC9xQSsvcUFXL3FBgy9xQa8vcUHbL3FBBzBxQTMwcUFeMHFBijBxQbYwcUHiMHFBDjFxQToxcUFlMXFBkTFxQb0xcUHpMXFBFTJxQUEycUFsMnFBmDJxQcQycUHwMnFBHDNxQUgzcUFzM3FBnzNxQcszcUH3M3FBIzRxQU80cUF6NHFBpjRxQdI0cUH+NHFBKjVxQVU1cUGBNXFBrTVxQdk1cUEFNnFBMDZxQVw2cUGINnFBtDZxQeA2cUELN3FBNzdxQWM3cUGPN3FBuzdxQeY3cUESOHFBPjhxQWo4cUGWOHFBwThxQe04cUEZOXFBRTlxQXE5cUGcOXFByDlxQfQ5cUEgOnFBSzpxQXc6cUGjOnFBzzpxQfs6cUEmO3FBUjtxQX47cUGqO3FB1TtxQQE8cUEtPHFBWTxxQYQ8cUGwPHFB3DxxQQg9cUEzPXFBXz1xQYs9cUG3PXFB4j1xQQ4+cUE6PnFBZj5xQZE+cUG9PnFB6T5xQRU/cUFAP3FBbD9xQZg/cUHEP3FB7z9xQRtAcUFHQHFBc0BxQZ5AcUHKQHFB9kBxQSFBcUFNQXFBeUFxQaVBcUHQQXFB/EFxQShCcUFTQnFBf0JxQatCcUHXQnFBAkNxQS5DcUFaQ3FBhUNxQbFDcUHdQ3FBCURxQTREcUFgRHFBjERxQbdEcUHjRHFBD0VxQTpFcUFmRXFBkkVxQb5FcUHpRXFBFUZxQUFGcUFsRnFBmEZxQcRGcUHvRnFBG0dxQUdHcUFyR3FBnkdxQcpHcUH1R3FBIUhxQU1IcUF4SHFBpEhxQdBIcUH7SHFBJ0lxQVNJcUF+SXFBqklxQdZJcUEBSnFBLUpxQVlKcUGESnFBsEpxQdxKcUEHS3FBM0txQV9LcUGKS3FBtktxQeJLcUENTHFBOUxxQWRMcUGQTHFBvExxQedMcUETTXFBP01xQWpNcUGWTXFBwk1xQe1NcUEZTnFBRE5xQXBOcUGcTnFBx05xQfNOcUEfT3FBSk9xQXZPcUGhT3FBzU9xQflPcUEkUHFBUFBxQXxQcUGnUHFB01BxQf5QcUEqUXFBVlFxQYFRcUGtUXFB2FFxQQRScUEwUnFBW1JxQYdScUGyUnFB3lJxQQpTcUE1U3FBYVNxQYxTcUG4U3FB41NxQQ9UcUE7VHFBZlRxQZJUcUG9VHFB6VRxQRVVcUFAVXFBbFVxQZdVcUHDVXFB7lVxQRpWcUFGVnFBcVZxQZ1WcUHIVnFB9FZxQR9XcUFLV3FBd1dxQaJXcUHOV3FB+VdxQSVYcUFQWHFBfFhxQadYcUHTWHFB/lhxQSpZcUFWWXFBgVlxQa1ZcUHYWXFBBFpxQS9acUFbWnFBhlpxQbJacUHdWnFBCVtxQTVbcUFgW3FBjFtxQbdbcUHjW3FBDlxxQTpccUFlXHFBkVxxQbxccUHoXHFBE11xQT9dcUFqXXFBll1xQcFdcUHtXXFBGF5xQURecUFvXnFBm15xQcZecUHyXnFBHV9xQUlfcUF0X3FBoF9xQctfcUH3X3FBImBxQU5gcUF5YHFBpWBxQdBgcUH8YHFBJ2FxQVNhcUF+YXFBqmFxQdVhcUEBYnFBLGJxQVhicUGDYnFBr2JxQdpicUEGY3FBMWNxQV1jcUGIY3FBtGNxQd9jcUEKZHFBNmRxQWFkcUGNZHFBuGRxQeRkcUEPZXFBO2VxQWZlcUGSZXFBvWVxQellcUEUZnFBP2ZxQWtmcUGWZnFBwmZxQe1mcUEZZ3FBRGdxQXBncUGbZ3FBxmdxQfJncUEdaHFBSWhxQXRocUGgaHFBy2hxQfZocUEiaXFBTWlxQXlpcUGkaXFB0GlxQftpcUEmanFBUmpxQX1qcUGpanFB1GpxQQBrcUEra3FBVmtxQYJrcUGta3FB2WtxQQRscUEvbHFBW2xxQYZscUGybHFB3WxxQQhtcUE0bXFBX21xQYttcUG2bXFB4W1xQQ1ucUE4bnFBZG5xQY9ucUG6bnFB5m5xQRFvcUE9b3FBaG9xQZNvcUG/b3FB6m9xQRVwcUFBcHFBbHBxQZhwcUHDcHFB7nBxQRpxcUFFcXFBcHFxQZxxcUHHcXFB83FxQR5ycUFJcnFBdXJxQaBycUHLcnFB93JxQSJzcUFNc3FBeXNxQaRzcUHPc3FB+3NxQSZ0cUFSdHFBfXRxQah0cUHUdHFB/3RxQSp1cUFWdXFBgXVxQax1cUHYdXFBA3ZxQS52cUFadnFBhXZxQbB2cUHcdnFBB3dxQTJ3cUFed3FBiXdxQbR3cUHgd3FBC3hxQTZ4cUFieHFBjXhxQbh4cUHjeHFBD3lxQTp5cUFleXFBkXlxQbx5cUHneXFBE3pxQT56cUFpenFBlXpxQcB6cUHrenFBFntxQUJ7cUFte3FBmHtxQcR7cUHve3FBGnxxQUV8cUFxfHFBnHxxQcd8cUHzfHFBHn1xQUl9cUF0fXFBoH1xQct9cUH2fXFBIn5xQU1+cUF4fnFBo35xQc9+cUH6fnFBJX9xQVB/cUF8f3FBp39xQdJ/cUH+f3FBKYBxQVSAcUF/gHFBq4BxQdaAcUEBgXFBLIFxQViBcUGDgXFBroFxQdmBcUEFgnFBMIJxQVuCcUGGgnFBsoJxQd2CcUEIg3FBM4NxQV+DcUGKg3FBtYNxQeCDcUELhHFBN4RxQWKEcUGNhHFBuIRxQeSEcUEPhXFBOoVxQWWFcUGRhXFBvIVxQeeFcUEShnFBPYZxQWmGcUGUhnFBv4ZxQeqGcUEVh3FBQYdxQWyHcUGXh3FBwodxQe2HcUEZiHFBRIhxQW+IcUGaiHFBxYhxQfGIcUEciXFBR4lxQXKJcUGdiXFByYlxQfSJcUEfinFBSopxQXWKcUGhinFBzIpxQfeKcUEii3FBTYtxQXiLcUGki3FBz4txQfqLcUEljHFBUIxxQXyMcUGnjHFB0oxxQf2McUEojXFBU41xQX+NcUGqjXFB1Y1xQQCOcUErjnFBVo5xQYGOcUGtjnFB2I5xQQOPcUEuj3FBWY9xQYSPcUGwj3FB249xQQaQcUExkHFBXJBxQYeQcUGykHFB3pBxQQmRcUE0kXFBX5FxQYqRcUG1kXFB4JFxQQuScUE3knFBYpJxQY2ScUG4knFB45JxQQ6TcUE5k3FBZJNxQZCTcUG7k3FB5pNxQRGUcUE8lHFBZ5RxQZKUcUG9lHFB6ZRxQRSVcUE/lXFBapVxQZWVcUHAlXFB65VxQRaWcUFBlnFBbJZxQZiWcUHDlnFB7pZxQRmXcUFEl3FBb5dxQZqXcUHFl3FB8JdxQRuYcUFGmHFBcphxQZ2YcUHImHFB85hxQR6ZcUFJmXFBdJlxQZ+ZcUHKmXFB9ZlxQSCacUFLmnFBdppxQaKacUHNmnFB+JpxQSObcUFOm3FBeZtxQaSbcUHPm3FB+ptxQSWccUFQnHFBe5xxQaaccUHRnHFB/JxxQSedcUFSnXFBfZ1xQamdcUHUnXFB/51xQSqecUFVnnFBgJ5xQauecUHWnnFBAZ9xQSyfcUFXn3FBgp9xQa2fcUHYn3FBA6BxQS6gcUFZoHFBhKBxQa+gcUHaoHFBBaFxQTChcUFboXFBhqFxQbGhcUHcoXFBB6JxQTKicUFdonFBiKJxQbOicUHeonFBCaNxQTSjcUFfo3FBiqNxQbWjcUHgo3FBC6RxQTakcUFhpHFBjKRxQbekcUHipHFBDaVxQTilcUFjpXFBjqVxQbmlcUHkpXFBD6ZxQTqmcUFlpnFBkKZxQbumcUHmpnFBEadxQTyncUFnp3FBkqdxQb2ncUHop3FBE6hxQT6ocUFpqHFBlKhxQb+ocUHqqHFBFalxQUCpcUFrqXFBlqlxQcGpcUHsqXFBFqpxQUGqcUFsqnFBl6pxQcKqcUHtqnFBGKtxQUOrcUFuq3FBmatxQcSrcUHvq3FBGqxxQUWscUFwrHFBm6xxQcascUHxrHFBG61xQUatcUFxrXFBnK1xQcetcUHyrXFBHa5xQUiucUFzrnFBnq5xQcmucUH0rnFBH69xQUqvcUF0r3FBn69xQcqvcUH1r3FBILBxQUuwcUF2sHFBobBxQcywcUH3sHFBIrFxQUyxcUF3sXFBorFxQc2xcUH4sXFBI7JxQU6ycUF5snFBpLJxQc6ycUH5snFBJLNxQU+zcUF6s3FBpbNxQdCzcUH7s3FBJrRxQVC0cUF7tHFBprRxQdG0cUH8tHFBJ7VxQVK1cUF9tXFBp7VxQdK1cUH9tXFBKLZxQVO2cUF+tnFBqbZxQdS2cUH+tnFBKbdxQVS3cUF/t3FBqrdxQdW3cUEAuHFBKrhxQVW4cUGAuHFBq7hxQda4cUEBuXFBK7lxQVa5cUGBuXFBrLlxQde5cUECunFBLbpxQVe6cUGCunFBrbpxQdi6cUEDu3FBLrtxQVi7cUGDu3FBrrtxQdm7cUEEvHFBLrxxQVm8cUGEvHFBr7xxQdq8cUEFvXFBL71xQVq9cUGFvXFBsL1xQdu9cUEFvnFBML5xQVu+cUGGvnFBsb5xQdy+cUEGv3FBMb9xQVy/cUGHv3FBsr9xQdy/cUEHwHFBMsBxQV3AcUGHwHFBssBxQd3AcUEIwXFBM8FxQV3BcUGIwXFBs8FxQd7BcUEJwnFBM8JxQV7CcUGJwnFBtMJxQd7CcUEJw3FBNMNxQV/DcUGKw3FBtMNxQd/DcUEKxHFBNcRxQV/EcUGKxHFBtcRxQeDEcUEKxXFBNcVxQWDFcUGLxXFBtcVxQeDFcUELxnFBNsZxQWDGcUGLxnFBtsZxQeHGcUELx3FBNsdxQWHHcUGMx3FBtsdxQeHHcUEMyHFBN8hxQWHIcUGMyHFBt8hxQeLIcUEMyXFBN8lxQWLJcUGMyXFBt8lxQeLJcUENynFBN8pxQWLKcUGNynFBuMpxQeLKcUENy3FBOMtxQWLLcUGNy3FBuMtxQePLcUENzHFBOMxxQWPMcUGNzHFBuMxxQePMcUENzXFBOM1xQWPNcUGOzXFBuM1xQePNcUEOznFBOM5xQWPOcUGOznFBuM5xQePOcUEOz3FBOM9xQWPPcUGOz3FBuc9xQePPcUEO0HFBOdBxQWPQcUGO0HFBudBxQePQcUEO0XFBOdFxQWPRcUGO0XFBudFxQePRcUEO0nFBOdJxQWPScUGO0nFBudJxQePScUEO03FBOdNxQWPTcUGO03FBudNxQePTcUEO1HFBOdRxQWPUcUGO1HFBuNRxQePUcUEO1XFBONVxQWPVcUGO1XFBuNVxQePVcUEO1nFBONZxQWPWcUGN1nFBuNZxQePWcUEN13FBONdxQWPXcUGN13FBuNdxQePXcUEN2HFBONhxQWLYcUGN2HFBuNhxQeLYcUEN2XFBN9lxQWLZcUGN2XFBt9lxQeLZcUEN2nFBN9pxQWLacUGM2nFBt9pxQeLacUEM23FBN9txQWHbcUGM23FBt9txQeHbcUEM3HFBNtxxQWHccUGL3HFBttxxQeHccUEL3XFBNt1xQWDdcUGL3XFBtt1xQeDdcUEL3nFBNd5xQWDecUGK3nFBtd5xQeDecUEK33FBNd9xQV/fcUGK33FBtN9xQd/fcUEK4HFBNOBxQV/gcUGJ4HFBtOBxQd7gcUEJ4XFBNOFxQV7hcUGJ4XFBs+FxQd7hcUEI4nFBM+JxQV3icUGI4nFBsuJxQd3icUEI43FBMuNxQV3jcUGH43FBsuNxQdzjcUEH5HFBMeRxQVzkcUGG5HFBseRxQdvkcUEG5XFBMeVxQVvlcUGG5XFBsOVxQdvlcUEF5nFBMOZxQVrmcUGF5nFBr+ZxQdrmcUEE53FBL+dxQVnncUGE53FBrudxQdnncUED6HFBLuhxQVjocUGD6HFBrehxQdjocUEC6XFBLelxQVfpcUGC6XFBrOlxQdfpcUEB6nFBLOpxQVbqcUGB6nFBq+pxQdbqcUEA63FBK+txQVXrcUGA63FBqutxQdXrcUH/63FBKuxxQVTscUF/7HFBqexxQdPscUH+7HFBKO1xQVPtcUF97XFBqO1xQdLtcUH97XFBJ+5xQVLucUF87nFBp+5xQdHucUH87nFBJu9xQVDvcUF773FBpe9xQdDvcUH673FBJfBxQU/wcUF68HFBpPBxQc7wcUH58HFBI/FxQU7xcUF48XFBo/FxQc3xcUH48XFBIvJxQUzycUF38nFBofJxQczycUH28nFBIfNxQUvzcUF183FBoPNxQcrzcUH183FBH/RxQUr0cUF09HFBnvRxQcn0cUHz9HFBHvVxQUj1cUFy9XFBnfVxQcf1cUHy9XFBHPZxQUb2cUFx9nFBm/ZxQcb2cUHw9nFBGvdxQUX3cUFv93FBmvdxQcT3cUHu93FBGfhxQUP4cUFu+HFBmPhxQcL4cUHt+HFBF/lxQUL5cUFs+XFBlvlxQcH5cUHr+XFBFfpxQUD6cUFq+nFBlfpxQb/6cUHp+nFBFPtxQT77cUFo+3FBk/txQb37cUHo+3FBEvxxQTz8cUFn/HFBkfxxQbv8cUHm/HFBEP1xQTr9cUFl/XFBj/1xQbn9cUHk/XFBDv5xQTn+cUFj/nFBjf5xQbj+cUHi/nFBDP9xQTf/cUFh/3FBi/9xQbb/cUHg/3FBCgByQTUAckFfAHJBiQByQbQAckHeAHJBCAFyQTMBckFdAXJBhwFyQbIBckHcAXJBBgJyQTECckFbAnJBhQJyQa8CckHaAnJBBANyQS4DckFZA3JBgwNyQa0DckHYA3JBAgRyQSwEckFXBHJBgQRyQasEckHVBHJBAAVyQSoFckFUBXJBfwVyQakFckHTBXJB/gVyQSgGckFSBnJBfAZyQacGckHRBnJB+wZyQSYHckFQB3JBegdyQaQHckHPB3JB+QdyQSMIckFOCHJBeAhyQaIIckHMCHJB9whyQSEJckFLCXJBdQlyQaAJckHKCXJB9AlyQR4KckFJCnJBcwpyQZ0KckHICnJB8gpyQRwLckFGC3JBcQtyQZsLckHFC3JB7wtyQRoMckFEDHJBbgxyQZgMckHDDHJB7QxyQRcNckFBDXJBaw1yQZYNckHADXJB6g1yQRQOckE/DnJBaQ5yQZMOckG9DnJB6A5yQRIPckE8D3JBZg9yQZAPckG7D3JB5Q9yQQ8QckE5EHJBZBByQY4QckG4EHJB4hByQQwRckE3EXJBYRFyQYsRckG1EXJB3xFyQQoSckE0EnJBXhJyQYgSckGzEnJB3RJyQQcTckExE3JBWxNyQYUTckGwE3JB2hNyQQQUckEuFHJBWBRyQYMUckGtFHJB1xRyQQEVckErFXJBVhVyQYAVckGqFXJB1BVyQf4VckEoFnJBUxZyQX0WckGnFnJB0RZyQfsWckElF3JBUBdyQXoXckGkF3JBzhdyQfgXckEiGHJBTRhyQXcYckGhGHJByxhyQfUYckEfGXJBShlyQXQZckGeGXJByBlyQfIZckEcGnJBRxpyQXEackGbGnJBxRpyQe8ackEZG3JBQxtyQW0bckGYG3JBwhtyQewbckEWHHJBQBxyQWocckGUHHJBvxxyQekcckETHXJBPR1yQWcdckGRHXJBux1yQeUdckEQHnJBOh5yQWQeckGOHnJBuB5yQeIeckEMH3JBNh9yQWAfckGLH3JBtR9yQd8fckEJIHJBMyByQV0gckGHIHJBsSByQdsgckEGIXJBMCFyQVohckGEIXJBriFyQdghckECInJBLCJyQVYickGAInJBqiJyQdUickH/InJBKSNyQVMjckF9I3JBpyNyQdEjckH7I3JBJSRyQU8kckF5JHJBoyRyQc0kckH4JHJBIiVyQUwlckF2JXJBoCVyQcolckH0JXJBHiZyQUgmckFyJnJBnCZyQcYmckHwJnJBGidyQUQnckFuJ3JBmSdyQcMnckHtJ3JBFyhyQUEockFrKHJBlShyQb8ockHpKHJBEylyQT0pckFnKXJBkSlyQbspckHlKXJBDypyQTkqckFjKnJBjSpyQbcqckHhKnJBCytyQTUrckFfK3JBiStyQbMrckHeK3JBCCxyQTIsckFcLHJBhixyQbAsckHaLHJBBC1yQS4tckFYLXJBgi1yQawtckHWLXJBAC5yQSouckFULnJBfi5yQaguckHSLnJB/C5yQSYvckFQL3JBei9yQaQvckHOL3JB+C9yQSIwckFMMHJBdjByQaAwckHKMHJB9DByQR4xckFIMXJBcjFyQZwxckHGMXJB7zFyQRkyckFDMnJBbTJyQZcyckHBMnJB6zJyQRUzckE/M3JBaTNyQZMzckG9M3JB5zNyQRE0ckE7NHJBZTRyQY80ckG5NHJB4zRyQQ01ckE3NXJBYTVyQYs1ckG1NXJB3zVyQQk2ckEzNnJBXDZyQYY2ckGwNnJB2jZyQQQ3ckEuN3JBWDdyQYI3ckGsN3JB1jdyQQA4ckEqOHJBVDhyQX44ckGoOHJB0jhyQfs4ckElOXJBTzlyQXk5ckGjOXJBzTlyQfc5ckEhOnJBSzpyQXU6ckGfOnJByTpyQfM6ckEcO3JBRjtyQXA7ckGaO3JBxDtyQe47ckEYPHJBQjxyQWw8ckGWPHJBwDxyQek8ckETPXJBPT1yQWc9ckGRPXJBuz1yQeU9ckEPPnJBOT5yQWI+ckGMPnJBtj5yQeA+ckEKP3JBND9yQV4/ckGIP3JBsj9yQds/ckEFQHJBL0ByQVlAckGDQHJBrUByQddAckEBQXJBKkFyQVRBckF+QXJBqEFyQdJBckH8QXJBJkJyQVBCckF5QnJBo0JyQc1CckH3QnJBIUNyQUtDckF1Q3JBnkNyQchDckHyQ3JBHERyQUZEckFwRHJBmURyQcNEckHtRHJBF0VyQUFFckFrRXJBlUVyQb5FckHoRXJBEkZyQTxGckFmRnJBkEZyQblGckHjRnJBDUdyQTdHckFhR3JBi0dyQbRHckHeR3JBCEhyQTJIckFcSHJBhUhyQa9IckHZSHJBA0lyQS1JckFXSXJBgElyQapJckHUSXJB/klyQShKckFRSnJBe0pyQaVKckHPSnJB+UpyQSJLckFMS3JBdktyQaBLckHKS3JB80tyQR1MckFHTHJBcUxyQZtMckHETHJB7kxyQRhNckFCTXJBa01yQZVNckG/TXJB6U1yQRNOckE8TnJBZk5yQZBOckG6TnJB405yQQ1PckE3T3JBYU9yQYtPckG0T3JB3k9yQQhQckEyUHJBW1ByQYVQckGvUHJB2VByQQJRckEsUXJBVlFyQYBRckGpUXJB01FyQf1RckEnUnJBUFJyQXpSckGkUnJBzlJyQfdSckEhU3JBS1NyQXVTckGeU3JByFNyQfJTckEcVHJBRVRyQW9UckGZVHJBw1RyQexUckEWVXJBQFVyQWlVckGTVXJBvVVyQedVckEQVnJBOlZyQWRWckGOVnJBt1ZyQeFWckELV3JBNFdyQV5XckGIV3JBsldyQdtXckEFWHJBL1hyQVhYckGCWHJBrFhyQdZYckH/WHJBKVlyQVNZckF8WXJBpllyQdBZckH5WXJBI1pyQU1ackF2WnJBoFpyQcpackH0WnJBHVtyQUdbckFxW3JBmltyQcRbckHuW3JBF1xyQUFcckFrXHJBlFxyQb5cckHoXHJBEV1yQTtdckFlXXJBjl1yQbhdckHiXXJBC15yQTVeckFfXnJBiF5yQbJeckHcXnJBBV9yQS9fckFZX3JBgl9yQaxfckHWX3JB/19yQSlgckFTYHJBfGByQaZgckHQYHJB+WByQSNhckFNYXJBdmFyQaBhckHJYXJB82FyQR1ickFGYnJBcGJyQZpickHDYnJB7WJyQRdjckFAY3JBamNyQZNjckG9Y3JB52NyQRBkckE6ZHJBZGRyQY1kckG3ZHJB4GRyQQplckE0ZXJBXWVyQYdlckGwZXJB2mVyQQRmckEtZnJBV2ZyQYFmckGqZnJB1GZyQf1mckEnZ3JBUWdyQXpnckGkZ3JBzWdyQfdnckEhaHJBSmhyQXRockGdaHJBx2hyQfBockEaaXJBRGlyQW1pckGXaXJBwGlyQeppckEUanJBPWpyQWdqckGQanJBumpyQeNqckENa3JBN2tyQWBrckGKa3JBs2tyQd1rckEGbHJBMGxyQVpsckGDbHJBrWxyQdZsckEAbXJBKW1yQVNtckF9bXJBpm1yQdBtckH5bXJBI25yQUxuckF2bnJBn25yQcluckHzbnJBHG9yQUZvckFvb3JBmW9yQcJvckHsb3JBFXByQT9wckFocHJBknByQbtwckHlcHJBD3FyQThxckFicXJBi3FyQbVxckHecXJBCHJyQTFyckFbcnJBhHJyQa5yckHXcnJBAXNyQSpzckFUc3JBfXNyQadzckHQc3JB+nNyQSN0ckFNdHJBdnRyQaB0ckHJdHJB83RyQRx1ckFGdXJBb3VyQZl1ckHCdXJB7HVyQRV2ckE/dnJBaHZyQZJ2ckG7dnJB5XZyQQ53ckE4d3JBYXdyQYt3ckG0d3JB3ndyQQd4ckExeHJBWnhyQYR4ckGteHJB13hyQQB5ckEqeXJBU3lyQX15ckGmeXJB0HlyQfl5ckEjenJBTHpyQXV6ckGfenJByHpyQfJ6ckEbe3JBRXtyQW57ckGYe3JBwXtyQet7ckEUfHJBPnxyQWd8ckGQfHJBunxyQeN8ckENfXJBNn1yQWB9ckGJfXJBs31yQdx9ckEFfnJBL35yQVh+ckGCfnJBq35yQdV+ckH+fnJBKH9yQVF/ckF6f3JBpH9yQc1/ckH3f3JBIIByQUqAckFzgHJBnIByQcaAckHvgHJBGYFyQUKBckFrgXJBlYFyQb6BckHogXJBEYJyQTuCckFkgnJBjYJyQbeCckHggnJBCoNyQTODckFcg3JBhoNyQa+DckHZg3JBAoRyQSuEckFVhHJBfoRyQaiEckHRhHJB+oRyQSSFckFNhXJBd4VyQaCFckHJhXJB84VyQRyGckFGhnJBb4ZyQZiGckHChnJB64ZyQRSHckE+h3JBZ4dyQZGHckG6h3JB44dyQQ2IckE2iHJBX4hyQYmIckGyiHJB24hyQQWJckEuiXJBWIlyQYGJckGqiXJB1IlyQf2JckEminJBUIpyQXmKckGiinJBzIpyQfWKckEfi3JBSItyQXGLckGbi3JBxItyQe2LckEXjHJBQIxyQWmMckGTjHJBvIxyQeWMckEPjXJBOI1yQWGNckGLjXJBtI1yQd2NckEHjnJBMI5yQVmOckGDjnJBrI5yQdWOckH/jnJBKI9yQVGPckF7j3JBpI9yQc2PckH2j3JBIJByQUmQckFykHJBnJByQcWQckHukHJBGJFyQUGRckFqkXJBlJFyQb2RckHmkXJBD5JyQTmSckFiknJBi5JyQbWSckHeknJBB5NyQTGTckFak3JBg5NyQayTckHWk3JB/5NyQSiUckFSlHJBe5RyQaSUckHNlHJB95RyQSCVckFJlXJBc5VyQZyVckHFlXJB7pVyQRiWckFBlnJBapZyQZOWckG9lnJB5pZyQQ+XckE5l3JBYpdyQYuXckG0l3JB3pdyQQeYckEwmHJBWZhyQYOYckGsmHJB1ZhyQf6YckEomXJBUZlyQXqZckGjmXJBzZlyQfaZckEfmnJBSJpyQXKackGbmnJBxJpyQe2ackEXm3JBQJtyQWmbckGSm3JBvJtyQeWbckEOnHJBN5xyQWCcckGKnHJBs5xyQdycckEFnXJBL51yQVidckGBnXJBqp1yQdOdckH9nXJBJp5yQU+eckF4nnJBop5yQcueckH0nnJBHZ9yQUafckFwn3JBmZ9yQcKfckHrn3JBFKByQT6gckFnoHJBkKByQbmgckHioHJBDKFyQTWhckFeoXJBh6FyQbChckHaoXJBA6JyQSyickFVonJBfqJyQaiickHRonJB+qJyQSOjckFMo3JBdaNyQZ+jckHIo3JB8aNyQRqkckFDpHJBbaRyQZakckG/pHJB6KRyQRGlckE6pXJBZKVyQY2lckG2pXJB36VyQQimckExpnJBWqZyQYSmckGtpnJB1qZyQf+mckEop3JBUadyQXunckGkp3JBzadyQfanckEfqHJBSKhyQXGockGbqHJBxKhyQe2ockEWqXJBP6lyQWipckGRqXJBu6lyQeSpckENqnJBNqpyQV+qckGIqnJBsapyQduqckEEq3JBLatyQVarckF/q3JBqKtyQdGrckH6q3JBJKxyQU2sckF2rHJBn6xyQcisckHxrHJBGq1yQUOtckFsrXJBlq1yQb+tckHorXJBEa5yQTquckFjrnJBjK5yQbWuckHernJBB69yQTGvckFar3JBg69yQayvckHVr3JB/q9yQSewckFQsHJBebByQaKwckHMsHJB9bByQR6xckFHsXJBcLFyQZmxckHCsXJB67FyQRSyckE9snJBZrJyQY+yckG4snJB4rJyQQuzckE0s3JBXbNyQYazckGvs3JB2LNyQQG0ckEqtHJBU7RyQXy0ckGltHJBzrRyQfe0ckEgtXJBSbVyQXO1ckGctXJBxbVyQe61ckEXtnJBQLZyQWm2ckGStnJBu7ZyQeS2ckENt3JBNrdyQV+3ckGIt3JBsbdyQdq3ckEDuHJBLLhyQVW4ckF+uHJBp7hyQdC4ckH5uHJBI7lyQUy5ckF1uXJBnrlyQce5ckHwuXJBGbpyQUK6ckFrunJBlLpyQb26ckHmunJBD7tyQTi7ckFhu3JBirtyQbO7ckHcu3JBBbxyQS68ckFXvHJBgLxyQam8ckHSvHJB+7xyQSS9ckFNvXJBdr1yQZ+9ckHIvXJB8b1yQRq+ckFDvnJBbL5yQZW+ckG+vnJB575yQRC/ckE5v3JBYr9yQYu/ckG0v3JB3b9yQQbAckEvwHJBWMByQYHAckGqwHJB08ByQfzAckElwXJBTsFyQXfBckGfwXJByMFyQfHBckEawnJBQ8JyQWzCckGVwnJBvsJyQefCckEQw3JBOcNyQWLDckGLw3JBtMNyQd3DckEGxHJBL8RyQVjEckGBxHJBqsRyQdPEckH8xHJBJcVyQU3FckF2xXJBn8VyQcjFckHxxXJBGsZyQUPGckFsxnJBlcZyQb7GckHnxnJBEMdyQTnHckFix3JBi8dyQbTHckHcx3JBBchyQS7IckFXyHJBgMhyQanIckHSyHJB+8hyQSTJckFNyXJBdslyQZ/JckHIyXJB8MlyQRnKckFCynJBa8pyQZTKckG9ynJB5spyQQ/LckE4y3JBYctyQYnLckGyy3JB28tyQQTMckEtzHJBVsxyQX/MckGozHJB0cxyQfrMckEizXJBS81yQXTNckGdzXJBxs1yQe/NckEYznJBQc5yQWrOckGSznJBu85yQeTOckENz3JBNs9yQV/PckGIz3JBsc9yQdnPckEC0HJBK9ByQVTQckF90HJBptByQc/QckH30HJBINFyQUnRckFy0XJBm9FyQcTRckHt0XJBFtJyQT7SckFn0nJBkNJyQbnSckHi0nJBC9NyQTPTckFc03JBhdNyQa7TckHX03JBANRyQSnUckFR1HJBetRyQaPUckHM1HJB9dRyQR7VckFG1XJBb9VyQZjVckHB1XJB6tVyQRPWckE71nJBZNZyQY3WckG21nJB39ZyQQjXckEw13JBWddyQYLXckGr13JB1NdyQfzXckEl2HJBTthyQXfYckGg2HJByNhyQfHYckEa2XJBQ9lyQWzZckGV2XJBvdlyQebZckEP2nJBONpyQWHackGJ2nJBstpyQdvackEE23JBLdtyQVXbckF+23JBp9tyQdDbckH423JBIdxyQUrcckFz3HJBnNxyQcTcckHt3HJBFt1yQT/dckFo3XJBkN1yQbndckHi3XJBC95yQTPeckFc3nJBhd5yQa7eckHW3nJB/95yQSjfckFR33JBet9yQaLfckHL33JB9N9yQR3gckFF4HJBbuByQZfgckHA4HJB6OByQRHhckE64XJBY+FyQYvhckG04XJB3eFyQQbickEu4nJBV+JyQYDickGp4nJB0eJyQfrickEj43JBTONyQXTjckGd43JBxuNyQe7jckEX5HJBQORyQWnkckGR5HJBuuRyQePkckEM5XJBNOVyQV3lckGG5XJBruVyQdflckEA5nJBKeZyQVHmckF65nJBo+ZyQcvmckH05nJBHedyQUbnckFu53JBl+dyQcDnckHo53JBEehyQTrockFj6HJBi+hyQbTockHd6HJBBelyQS7pckFX6XJBf+lyQajpckHR6XJB+ulyQSLqckFL6nJBdOpyQZzqckHF6nJB7upyQRbrckE/63JBaOtyQZDrckG563JB4utyQQrsckEz7HJBXOxyQYTsckGt7HJB1uxyQf7sckEn7XJBUO1yQXjtckGh7XJByu1yQfLtckEb7nJBRO5yQWzuckGV7nJBvu5yQebuckEP73JBOO9yQWDvckGJ73JBsu9yQdrvckED8HJBLPByQVTwckF98HJBpvByQc7wckH38HJBIPFyQUjxckFx8XJBmfFyQcLxckHr8XJBE/JyQTzyckFl8nJBjfJyQbbyckHf8nJBB/NyQTDzckFY83JBgfNyQarzckHS83JB+/NyQST0ckFM9HJBdfRyQZ30ckHG9HJB7/RyQRf1ckFA9XJBaPVyQZH1ckG69XJB4vVyQQv2ckE09nJBXPZyQYX2ckGt9nJB1vZyQf/2ckEn93JBUPdyQXj3ckGh93JByvdyQfL3ckEb+HJBQ/hyQWz4ckGU+HJBvfhyQeb4ckEO+XJBN/lyQV/5ckGI+XJBsflyQdn5ckEC+nJBKvpyQVP6ckF8+nJBpPpyQc36ckH1+nJBHvtyQUb7ckFv+3JBmPtyQcD7ckHp+3JBEfxyQTr8ckFi/HJBi/xyQbP8ckHc/HJBBf1yQS39ckFW/XJBfv1yQaf9ckHP/XJB+P1yQSH+ckFJ/nJBcv5yQZr+ckHD/nJB6/5yQRT/ckE8/3JBZf9yQY3/ckG2/3JB3/9yQQcAc0EwAHNBWABzQYEAc0GpAHNB0gBzQfoAc0EjAXNBSwFzQXQBc0GcAXNBxQFzQe0Bc0EWAnNBPwJzQWcCc0GQAnNBuAJzQeECc0EJA3NBMgNzQVoDc0GDA3NBqwNzQdQDc0H8A3NBJQRzQU0Ec0F2BHNBngRzQccEc0HvBHNBGAVzQUAFc0FpBXNBkQVzQboFc0HiBXNBCwZzQTMGc0FcBnNBhAZzQa0Gc0HVBnNB/gZzQSYHc0FPB3NBdwdzQaAHc0HIB3NB8QdzQRkIc0FCCHNBaghzQZMIc0G7CHNB5AhzQQwJc0E1CXNBXQlzQYUJc0GuCXNB1glzQf8Jc0EnCnNBUApzQXgKc0GhCnNByQpzQfIKc0EaC3NBQwtzQWsLc0GUC3NBvAtzQeQLc0ENDHNBNQxzQV4Mc0GGDHNBrwxzQdcMc0EADXNBKA1zQVENc0F5DXNBoQ1zQcoNc0HyDXNBGw5zQUMOc0FsDnNBlA5zQb0Oc0HlDnNBDQ9zQTYPc0FeD3NBhw9zQa8Pc0HYD3NBABBzQSgQc0FREHNBeRBzQaIQc0HKEHNB8xBzQRsRc0FDEXNBbBFzQZQRc0G9EXNB5RFzQQ4Sc0E2EnNBXhJzQYcSc0GvEnNB2BJzQQATc0EoE3NBURNzQXkTc0GiE3NByhNzQfITc0EbFHNBQxRzQWwUc0GUFHNBvBRzQeUUc0ENFXNBNhVzQV4Vc0GGFXNBrxVzQdcVc0EAFnNBKBZzQVAWc0F5FnNBoRZzQcoWc0HyFnNBGhdzQUMXc0FrF3NBkxdzQbwXc0HkF3NBDRhzQTUYc0FdGHNBhhhzQa4Yc0HWGHNB/xhzQScZc0FQGXNBeBlzQaAZc0HJGXNB8RlzQRkac0FCGnNBahpzQZIac0G7GnNB4xpzQQsbc0E0G3NBXBtzQYUbc0GtG3NB1RtzQf4bc0EmHHNBThxzQXccc0GfHHNBxxxzQfAcc0EYHXNBQB1zQWkdc0GRHXNBuR1zQeIdc0EKHnNBMh5zQVsec0GDHnNBqx5zQdQec0H8HnNBJB9zQU0fc0F1H3NBnR9zQcYfc0HuH3NBFiBzQT8gc0FnIHNBjyBzQbggc0HgIHNBCCFzQTEhc0FZIXNBgSFzQakhc0HSIXNB+iFzQSIic0FLInNBcyJzQZsic0HEInNB7CJzQRQjc0E8I3NBZSNzQY0jc0G1I3NB3iNzQQYkc0EuJHNBVyRzQX8kc0GnJHNBzyRzQfgkc0EgJXNBSCVzQXElc0GZJXNBwSVzQeklc0ESJnNBOiZzQWImc0GLJnNBsyZzQdsmc0EDJ3NBLCdzQVQnc0F8J3NBpCdzQc0nc0H1J3NBHShzQUUoc0FuKHNBlihzQb4oc0HnKHNBDylzQTcpc0FfKXNBiClzQbApc0HYKXNBACpzQSkqc0FRKnNBeSpzQaEqc0HKKnNB8ipzQRorc0FCK3NBaytzQZMrc0G7K3NB4ytzQQwsc0E0LHNBXCxzQYQsc0GsLHNB1SxzQf0sc0ElLXNBTS1zQXYtc0GeLXNBxi1zQe4tc0EXLnNBPy5zQWcuc0GPLnNBty5zQeAuc0EIL3NBMC9zQVgvc0GBL3NBqS9zQdEvc0H5L3NBITBzQUowc0FyMHNBmjBzQcIwc0HqMHNBEzFzQTsxc0FjMXNBizFzQbMxc0HcMXNBBDJzQSwyc0FUMnNBfDJzQaUyc0HNMnNB9TJzQR0zc0FFM3NBbjNzQZYzc0G+M3NB5jNzQQ40c0E2NHNBXzRzQYc0c0GvNHNB1zRzQf80c0EoNXNBUDVzQXg1c0GgNXNByDVzQfA1c0EZNnNBQTZzQWk2c0GRNnNBuTZzQeE2c0EKN3NBMjdzQVo3c0GCN3NBqjdzQdI3c0H7N3NBIzhzQUs4c0FzOHNBmzhzQcM4c0HsOHNBFDlzQTw5c0FkOXNBjDlzQbQ5c0HcOXNBBTpzQS06c0FVOnNBfTpzQaU6c0HNOnNB9TpzQR47c0FGO3NBbjtzQZY7c0G+O3NB5jtzQQ48c0E2PHNBXzxzQYc8c0GvPHNB1zxzQf88c0EnPXNBTz1zQXc9c0GgPXNByD1zQfA9c0EYPnNBQD5zQWg+c0GQPnNBuD5zQeA+c0EJP3NBMT9zQVk/c0GBP3NBqT9zQdE/c0H5P3NBIUBzQUlAc0FyQHNBmkBzQcJAc0HqQHNBEkFzQTpBc0FiQXNBikFzQbJBc0HaQXNBAkJzQStCc0FTQnNBe0JzQaNCc0HLQnNB80JzQRtDc0FDQ3NBa0NzQZNDc0G7Q3NB40NzQQxEc0E0RHNBXERzQYREc0GsRHNB1ERzQfxEc0EkRXNBTEVzQXRFc0GcRXNBxEVzQexFc0EURnNBPUZzQWVGc0GNRnNBtUZzQd1Gc0EFR3NBLUdzQVVHc0F9R3NBpUdzQc1Hc0H1R3NBHUhzQUVIc0FtSHNBlUhzQb1Ic0HlSHNBDUlzQTVJc0FeSXNBhklzQa5Jc0HWSXNB/klzQSZKc0FOSnNBdkpzQZ5Kc0HGSnNB7kpzQRZLc0E+S3NBZktzQY5Lc0G2S3NB3ktzQQZMc0EuTHNBVkxzQX5Mc0GmTHNBzkxzQfZMc0EeTXNBRk1zQW5Nc0GWTXNBvk1zQeZNc0EOTnNBNk5zQV5Oc0GGTnNBrk5zQdZOc0H+TnNBJk9zQU5Pc0F2T3NBnk9zQcZPc0HuT3NBFlBzQT5Qc0FmUHNBjlBzQbZQc0HeUHNBBlFzQS5Rc0FWUXNBflFzQaZRc0HOUXNB9lFzQR5Sc0FGUnNBblJzQZZSc0G+UnNB5lJzQQ5Tc0E2U3NBXlNzQYZTc0GuU3NB1lNzQf5Tc0EmVHNBTlRzQXZUc0GeVHNBxlRzQe5Uc0EWVXNBPVVzQWVVc0GNVXNBtVVzQd1Vc0EFVnNBLVZzQVVWc0F9VnNBpVZzQc1Wc0H1VnNBHVdzQUVXc0FtV3NBlVdzQb1Xc0HlV3NBDVhzQTVYc0FcWHNBhFhzQaxYc0HUWHNB/FhzQSRZc0FMWXNBdFlzQZxZc0HEWXNB7FlzQRRac0E8WnNBZFpzQYtac0GzWnNB21pzQQNbc0ErW3NBU1tzQXtbc0GjW3NBy1tzQfNbc0EbXHNBQ1xzQWpcc0GSXHNBulxzQeJcc0EKXXNBMl1zQVpdc0GCXXNBql1zQdJdc0H6XXNBIV5zQUlec0FxXnNBmV5zQcFec0HpXnNBEV9zQTlfc0FhX3NBiF9zQbBfc0HYX3NBAGBzQShgc0FQYHNBeGBzQaBgc0HIYHNB72BzQRdhc0E/YXNBZ2FzQY9hc0G3YXNB32FzQQdic0EuYnNBVmJzQX5ic0GmYnNBzmJzQfZic0EeY3NBRmNzQW1jc0GVY3NBvWNzQeVjc0ENZHNBNWRzQV1kc0GEZHNBrGRzQdRkc0H8ZHNBJGVzQUxlc0F0ZXNBm2VzQcNlc0HrZXNBE2ZzQTtmc0FjZnNBimZzQbJmc0HaZnNBAmdzQSpnc0FSZ3NBeWdzQaFnc0HJZ3NB8WdzQRloc0FBaHNBaGhzQZBoc0G4aHNB4GhzQQhpc0EwaXNBV2lzQX9pc0GnaXNBz2lzQfdpc0EfanNBRmpzQW5qc0GWanNBvmpzQeZqc0ENa3NBNWtzQV1rc0GFa3NBrWtzQdRrc0H8a3NBJGxzQUxsc0F0bHNBnGxzQcNsc0HrbHNBE21zQTttc0FjbXNBim1zQbJtc0HabXNBAm5zQSluc0FRbnNBeW5zQaFuc0HJbnNB8G5zQRhvc0FAb3NBaG9zQZBvc0G3b3NB329zQQdwc0EvcHNBVnBzQX5wc0GmcHNBznBzQfZwc0EdcXNBRXFzQW1xc0GVcXNBvHFzQeRxc0EMcnNBNHJzQVtyc0GDcnNBq3JzQdNyc0H6cnNBInNzQUpzc0Fyc3NBmnNzQcFzc0Hpc3NBEXRzQTl0c0FgdHNBiHRzQbB0c0HYdHNB/3RzQSd1c0FPdXNBdnVzQZ51c0HGdXNB7nVzQRV2c0E9dnNBZXZzQY12c0G0dnNB3HZzQQR3c0Esd3NBU3dzQXt3c0Gjd3NBy3dzQfJ3c0EaeHNBQnhzQWl4c0GReHNBuXhzQeF4c0EIeXNBMHlzQVh5c0F/eXNBp3lzQc95c0H3eXNBHnpzQUZ6c0FuenNBlXpzQb16c0HlenNBDXtzQTR7c0Fce3NBhHtzQat7c0HTe3NB+3tzQSJ8c0FKfHNBcnxzQZp8c0HBfHNB6XxzQRF9c0E4fXNBYH1zQYh9c0GvfXNB131zQf99c0EmfnNBTn5zQXZ+c0GdfnNBxX5zQe1+c0EUf3NBPH9zQWR/c0GMf3NBs39zQdt/c0EDgHNBKoBzQVKAc0F6gHNBoYBzQcmAc0HxgHNBGIFzQUCBc0FogXNBj4FzQbeBc0HfgXNBBoJzQS6Cc0FVgnNBfYJzQaWCc0HMgnNB9IJzQRyDc0FDg3NBa4NzQZODc0G6g3NB4oNzQQqEc0ExhHNBWYRzQYGEc0GohHNB0IRzQfeEc0EfhXNBR4VzQW6Fc0GWhXNBvoVzQeWFc0ENhnNBNYZzQVyGc0GEhnNBq4ZzQdOGc0H7hnNBIodzQUqHc0Fyh3NBmYdzQcGHc0Hoh3NBEIhzQTiIc0FfiHNBh4hzQa6Ic0HWiHNB/ohzQSWJc0FNiXNBdYlzQZyJc0HEiXNB64lzQROKc0E7inNBYopzQYqKc0GxinNB2YpzQQGLc0Eoi3NBUItzQXeLc0Gfi3NBx4tzQe6Lc0EWjHNBPYxzQWWMc0GMjHNBtIxzQdyMc0EDjXNBK41zQVKNc0F6jXNBoo1zQcmNc0HxjXNBGI5zQUCOc0FnjnNBj45zQbeOc0HejnNBBo9zQS2Pc0FVj3NBfI9zQaSPc0HMj3NB849zQRuQc0FCkHNBapBzQZGQc0G5kHNB4ZBzQQiRc0EwkXNBV5FzQX+Rc0GmkXNBzpFzQfWRc0EdknNBRJJzQWySc0GUknNBu5JzQeOSc0EKk3NBMpNzQVmTc0GBk3NBqJNzQdCTc0H3k3NBH5RzQUeUc0FulHNBlpRzQb2Uc0HllHNBDJVzQTSVc0FblXNBg5VzQaqVc0HSlXNB+ZVzQSGWc0FIlnNBcJZzQZeWc0G/lnNB5pZzQQ6Xc0E2l3NBXZdzQYWXc0Gsl3NB1JdzQfuXc0EjmHNBSphzQXKYc0GZmHNBwZhzQeiYc0EQmXNBN5lzQV+Zc0GGmXNBrplzQdWZc0H9mXNBJJpzQUyac0FzmnNBm5pzQcKac0HqmnNBEZtzQTmbc0Fgm3NBiJtzQa+bc0HXm3NB/ptzQSWcc0FNnHNBdJxzQZycc0HDnHNB65xzQRKdc0E6nXNBYZ1zQYmdc0GwnXNB2J1zQf+dc0EnnnNBTp5zQXaec0GdnnNBxZ5zQeyec0ETn3NBO59zQWKfc0GKn3NBsZ9zQdmfc0EAoHNBKKBzQU+gc0F3oHNBnqBzQcWgc0HtoHNBFKFzQTyhc0FjoXNBi6FzQbKhc0HaoXNBAaJzQSmic0FQonNBd6JzQZ+ic0HGonNB7qJzQRWjc0E9o3NBZKNzQYujc0Gzo3NB2qNzQQKkc0EppHNBUaRzQXikc0GfpHNBx6RzQe6kc0EWpXNBPaVzQWWlc0GMpXNBs6VzQdulc0ECpnNBKqZzQVGmc0F5pnNBoKZzQcemc0HvpnNBFqdzQT6nc0Flp3NBjKdzQbSnc0Hbp3NBA6hzQSqoc0FRqHNBeahzQaCoc0HIqHNB76hzQRapc0E+qXNBZalzQY2pc0G0qXNB26lzQQOqc0EqqnNBUqpzQXmqc0GgqnNByKpzQe+qc0EWq3NBPqtzQWWrc0GNq3NBtKtzQdurc0EDrHNBKqxzQVGsc0F5rHNBoKxzQcisc0HvrHNBFq1zQT6tc0FlrXNBjK1zQbStc0HbrXNBA65zQSquc0FRrnNBea5zQaCuc0HHrnNB765zQRavc0E9r3NBZa9zQYyvc0Gzr3NB269zQQKwc0EqsHNBUbBzQXiwc0GgsHNBx7BzQe6wc0EWsXNBPbFzQWSxc0GMsXNBs7FzQdqxc0ECsnNBKbJzQVCyc0F4snNBn7JzQcayc0HusnNBFbNzQTyzc0Fks3NBi7NzQbKzc0Has3NBAbRzQSi0c0FQtHNBd7RzQZ60c0HGtHNB7bRzQRS1c0E7tXNBY7VzQYq1c0GxtXNB2bVzQQC2c0EntnNBT7ZzQXa2c0GdtnNBxbZzQey2c0ETt3NBO7dzQWK3c0GJt3NBsLdzQdi3c0H/t3NBJrhzQU64c0F1uHNBnLhzQcO4c0HruHNBErlzQTm5c0FhuXNBiLlzQa+5c0HWuXNB/rlzQSW6c0FMunNBdLpzQZu6c0HCunNB6bpzQRG7c0E4u3NBX7tzQYe7c0Guu3NB1btzQfy7c0EkvHNBS7xzQXK8c0GZvHNBwbxzQei8c0EPvXNBN71zQV69c0GFvXNBrL1zQdS9c0H7vXNBIr5zQUm+c0FxvnNBmL5zQb++c0HmvnNBDr9zQTW/c0Fcv3NBg79zQau/c0HSv3NB+b9zQSDAc0FIwHNBb8BzQZbAc0G9wHNB5cBzQQzBc0EzwXNBWsFzQYHBc0GpwXNB0MFzQffBc0EewnNBRsJzQW3Cc0GUwnNBu8JzQePCc0EKw3NBMcNzQVjDc0F/w3NBp8NzQc7Dc0H1w3NBHMRzQUTEc0FrxHNBksRzQbnEc0HgxHNBCMVzQS/Fc0FWxXNBfcVzQaTFc0HMxXNB88VzQRrGc0FBxnNBaMZzQZDGc0G3xnNB3sZzQQXHc0Esx3NBVMdzQXvHc0Gix3NBycdzQfDHc0EYyHNBP8hzQWbIc0GNyHNBtMhzQdzIc0EDyXNBKslzQVHJc0F4yXNBn8lzQcfJc0HuyXNBFcpzQTzKc0FjynNBispzQbLKc0HZynNBAMtzQSfLc0FOy3NBdstzQZ3Lc0HEy3NB68tzQRLMc0E5zHNBYMxzQYjMc0GvzHNB1sxzQf3Mc0EkzXNBS81zQXPNc0GazXNBwc1zQejNc0EPznNBNs5zQV7Oc0GFznNBrM5zQdPOc0H6znNBIc9zQUjPc0Fwz3NBl89zQb7Pc0Hlz3NBDNBzQTPQc0Fa0HNBgdBzQanQc0HQ0HNB99BzQR7Rc0FF0XNBbNFzQZPRc0G70XNB4tFzQQnSc0Ew0nNBV9JzQX7Sc0Gl0nNBzNJzQfTSc0Eb03NBQtNzQWnTc0GQ03NBt9NzQd7Tc0EF1HNBLNRzQVTUc0F71HNBotRzQcnUc0Hw1HNBF9VzQT7Vc0Fl1XNBjNVzQbPVc0Hb1XNBAtZzQSnWc0FQ1nNBd9ZzQZ7Wc0HF1nNB7NZzQRPXc0E613NBYtdzQYnXc0Gw13NB19dzQf7Xc0El2HNBTNhzQXPYc0Ga2HNBwdhzQejYc0EP2XNBNtlzQV7Zc0GF2XNBrNlzQdPZc0H62XNBIdpzQUjac0Fv2nNBltpzQb3ac0Hk2nNBC9tzQTLbc0FZ23NBgdtzQajbc0HP23NB9ttzQR3cc0FE3HNBa9xzQZLcc0G53HNB4NxzQQfdc0Eu3XNBVd1zQXzdc0Gj3XNByt1zQfHdc0EY3nNBP95zQWfec0GO3nNBtd5zQdzec0ED33NBKt9zQVHfc0F433NBn99zQcbfc0Ht33NBFOBzQTvgc0Fi4HNBieBzQbDgc0HX4HNB/uBzQSXhc0FM4XNBc+FzQZrhc0HB4XNB6OFzQQ/ic0E24nNBXeJzQYTic0Gr4nNB0uJzQfnic0Eg43NBR+NzQW7jc0GV43NBvONzQePjc0EK5HNBMeRzQVjkc0F/5HNBpuRzQc3kc0H05HNBG+VzQULlc0Fp5XNBkOVzQbflc0He5XNBBeZzQSzmc0FT5nNBeuZzQaHmc0HI5nNB7+ZzQRbnc0E953NBZOdzQYvnc0Gy53NB2edzQQDoc0En6HNBTuhzQXXoc0Gc6HNBw+hzQeroc0ER6XNBOOlzQV/pc0GG6XNBrelzQdTpc0H76XNBIupzQUnqc0Fw6nNBl+pzQb7qc0Hl6nNBDOtzQTPrc0FZ63NBgOtzQafrc0HO63NB9etzQRzsc0FD7HNBauxzQZHsc0G47HNB3+xzQQbtc0Et7XNBVO1zQXvtc0Gi7XNBye1zQfDtc0EX7nNBPe5zQWTuc0GL7nNBsu5zQdnuc0EA73NBJ+9zQU7vc0F173NBnO9zQcPvc0Hq73NBEfBzQTjwc0Ff8HNBhfBzQazwc0HT8HNB+vBzQSHxc0FI8XNBb/FzQZbxc0G98XNB5PFzQQvyc0Ey8nNBWPJzQX/yc0Gm8nNBzfJzQfTyc0Eb83NBQvNzQWnzc0GQ83NBt/NzQd7zc0EE9HNBK/RzQVL0c0F59HNBoPRzQcf0c0Hu9HNBFfVzQTz1c0Fi9XNBifVzQbD1c0HX9XNB/vVzQSX2c0FM9nNBc/ZzQZr2c0HA9nNB5/ZzQQ73c0E193NBXPdzQYP3c0Gq93NB0fdzQff3c0Ee+HNBRfhzQWz4c0GT+HNBuvhzQeH4c0EI+XNBLvlzQVX5c0F8+XNBo/lzQcr5c0Hx+XNBGPpzQT76c0Fl+nNBjPpzQbP6c0Ha+nNBAftzQSj7c0FO+3NBdftzQZz7c0HD+3NB6vtzQRH8c0E4/HNBXvxzQYX8c0Gs/HNB0/xzQfr8c0Eh/XNBR/1zQW79c0GV/XNBvP1zQeP9c0EK/nNBMP5zQVf+c0F+/nNBpf5zQcz+c0Hz/nNBGf9zQUD/c0Fn/3NBjv9zQbX/c0Hc/3NBAgB0QSkAdEFQAHRBdwB0QZ4AdEHEAHRB6wB0QRIBdEE5AXRBYAF0QYcBdEGtAXRB1AF0QfsBdEEiAnRBSQJ0QW8CdEGWAnRBvQJ0QeQCdEELA3RBMQN0QVgDdEF/A3RBpgN0Qc0DdEHzA3RBGgR0QUEEdEFoBHRBjwR0QbUEdEHcBHRBAwV0QSoFdEFRBXRBdwV0QZ4FdEHFBXRB7AV0QRIGdEE5BnRBYAZ0QYcGdEGuBnRB1AZ0QfsGdEEiB3RBSQd0QW8HdEGWB3RBvQd0QeQHdEEKCHRBMQh0QVgIdEF/CHRBpgh0QcwIdEHzCHRBGgl0QUEJdEFnCXRBjgl0QbUJdEHcCXRBAgp0QSkKdEFQCnRBdwp0QZ0KdEHECnRB6wp0QRILdEE4C3RBXwt0QYYLdEGtC3RB0wt0QfoLdEEhDHRBSAx0QW4MdEGVDHRBvAx0QeMMdEEJDXRBMA10QVcNdEF+DXRBpA10QcsNdEHyDXRBGA50QT8OdEFmDnRBjQ50QbMOdEHaDnRBAQ90QSgPdEFOD3RBdQ90QZwPdEHCD3RB6Q90QRAQdEE3EHRBXRB0QYQQdEGrEHRB0RB0QfgQdEEfEXRBRhF0QWwRdEGTEXRBuhF0QeARdEEHEnRBLhJ0QVQSdEF7EnRBohJ0QckSdEHvEnRBFhN0QT0TdEFjE3RBihN0QbETdEHXE3RB/hN0QSUUdEFLFHRBchR0QZkUdEHAFHRB5hR0QQ0VdEE0FXRBWhV0QYEVdEGoFXRBzhV0QfUVdEEcFnRBQhZ0QWkWdEGQFnRBthZ0Qd0WdEEEF3RBKhd0QVEXdEF4F3RBnhd0QcUXdEHsF3RBEhh0QTkYdEFgGHRBhhh0Qa0YdEHUGHRB+hh0QSEZdEFIGXRBbhl0QZUZdEG8GXRB4hl0QQkadEEwGnRBVhp0QX0adEGjGnRByhp0QfEadEEXG3RBPht0QWUbdEGLG3RBsht0QdkbdEH/G3RBJhx0QU0cdEFzHHRBmhx0QcAcdEHnHHRBDh10QTQddEFbHXRBgh10QagddEHPHXRB9R10QRwedEFDHnRBaR50QZAedEG3HnRB3R50QQQfdEEqH3RBUR90QXgfdEGeH3RBxR90QewfdEESIHRBOSB0QV8gdEGGIHRBrSB0QdMgdEH6IHRBICF0QUchdEFuIXRBlCF0QbshdEHhIXRBCCJ0QS8idEFVInRBfCJ0QaIidEHJInRB8CJ0QRYjdEE9I3RBYyN0QYojdEGwI3RB1yN0Qf4jdEEkJHRBSyR0QXEkdEGYJHRBvyR0QeUkdEEMJXRBMiV0QVkldEF/JXRBpiV0Qc0ldEHzJXRBGiZ0QUAmdEFnJnRBjSZ0QbQmdEHbJnRBASd0QSgndEFOJ3RBdSd0QZsndEHCJ3RB6Sd0QQ8odEE2KHRBXCh0QYModEGpKHRB0Ch0QfYodEEdKXRBRCl0QWopdEGRKXRBtyl0Qd4pdEEEKnRBKyp0QVEqdEF4KnRBnip0QcUqdEHsKnRBEit0QTkrdEFfK3RBhit0QawrdEHTK3RB+St0QSAsdEFGLHRBbSx0QZMsdEG6LHRB4Cx0QQctdEEuLXRBVC10QXstdEGhLXRByC10Qe4tdEEVLnRBOy50QWIudEGILnRBry50QdUudEH8LnRBIi90QUkvdEFvL3RBli90QbwvdEHjL3RBCTB0QTAwdEFWMHRBfTB0QaMwdEHKMHRB8DB0QRcxdEE9MXRBZDF0QYoxdEGxMXRB1zF0Qf4xdEEkMnRBSzJ0QXEydEGYMnRBvjJ0QeUydEELM3RBMjN0QVgzdEF/M3RBpTN0QcwzdEHyM3RBGTR0QT80dEFmNHRBjDR0QbM0dEHZNHRBADV0QSY1dEFMNXRBczV0QZk1dEHANXRB5jV0QQ02dEEzNnRBWjZ0QYA2dEGnNnRBzTZ0QfQ2dEEaN3RBQTd0QWc3dEGNN3RBtDd0Qdo3dEEBOHRBJzh0QU44dEF0OHRBmzh0QcE4dEHoOHRBDjl0QTQ5dEFbOXRBgTl0Qag5dEHOOXRB9Tl0QRs6dEFCOnRBaDp0QY46dEG1OnRB2zp0QQI7dEEoO3RBTzt0QXU7dEGbO3RBwjt0Qeg7dEEPPHRBNTx0QVw8dEGCPHRBqDx0Qc88dEH1PHRBHD10QUI9dEFpPXRBjz10QbU9dEHcPXRBAj50QSk+dEFPPnRBdT50QZw+dEHCPnRB6T50QQ8/dEE2P3RBXD90QYI/dEGpP3RBzz90QfY/dEEcQHRBQkB0QWlAdEGPQHRBtkB0QdxAdEECQXRBKUF0QU9BdEF2QXRBnEF0QcJBdEHpQXRBD0J0QTVCdEFcQnRBgkJ0QalCdEHPQnRB9UJ0QRxDdEFCQ3RBaUN0QY9DdEG1Q3RB3EN0QQJEdEEoRHRBT0R0QXVEdEGcRHRBwkR0QehEdEEPRXRBNUV0QVtFdEGCRXRBqEV0Qc9FdEH1RXRBG0Z0QUJGdEFoRnRBjkZ0QbVGdEHbRnRBAUd0QShHdEFOR3RBdUd0QZtHdEHBR3RB6Ed0QQ5IdEE0SHRBW0h0QYFIdEGnSHRBzkh0QfRIdEEaSXRBQUl0QWdJdEGNSXRBtEl0QdpJdEEASnRBJ0p0QU1KdEFzSnRBmkp0QcBKdEHmSnRBDUt0QTNLdEFZS3RBgEt0QaZLdEHMS3RB80t0QRlMdEE/THRBZkx0QYxMdEGyTHRB2Ux0Qf9MdEElTXRBTE10QXJNdEGYTXRBv010QeVNdEELTnRBMU50QVhOdEF+TnRBpE50QctOdEHxTnRBF090QT5PdEFkT3RBik90QbFPdEHXT3RB/U90QSNQdEFKUHRBcFB0QZZQdEG9UHRB41B0QQlRdEEvUXRBVlF0QXxRdEGiUXRByVF0Qe9RdEEVUnRBPFJ0QWJSdEGIUnRBrlJ0QdVSdEH7UnRBIVN0QUdTdEFuU3RBlFN0QbpTdEHhU3RBB1R0QS1UdEFTVHRBelR0QaBUdEHGVHRB7FR0QRNVdEE5VXRBX1V0QYZVdEGsVXRB0lV0QfhVdEEfVnRBRVZ0QWtWdEGRVnRBuFZ0Qd5WdEEEV3RBKld0QVFXdEF3V3RBnVd0QcNXdEHqV3RBEFh0QTZYdEFcWHRBg1h0QalYdEHPWHRB9Vh0QRxZdEFCWXRBaFl0QY5ZdEG1WXRB21l0QQFadEEnWnRBTVp0QXRadEGaWnRBwFp0QeZadEENW3RBM1t0QVlbdEF/W3RBplt0QcxbdEHyW3RBGFx0QT5cdEFlXHRBi1x0QbFcdEHXXHRB/Vx0QSRddEFKXXRBcF10QZZddEG9XXRB4110QQledEEvXnRBVV50QXxedEGiXnRByF50Qe5edEEUX3RBO190QWFfdEGHX3RBrV90QdNfdEH6X3RBIGB0QUZgdEFsYHRBkmB0QblgdEHfYHRBBWF0QSthdEFRYXRBd2F0QZ5hdEHEYXRB6mF0QRBidEE2YnRBXWJ0QYNidEGpYnRBz2J0QfVidEEbY3RBQmN0QWhjdEGOY3RBtGN0QdpjdEEBZHRBJ2R0QU1kdEFzZHRBmWR0Qb9kdEHmZHRBDGV0QTJldEFYZXRBfmV0QaRldEHKZXRB8WV0QRdmdEE9ZnRBY2Z0QYlmdEGvZnRB1mZ0QfxmdEEiZ3RBSGd0QW5ndEGUZ3RBumd0QeFndEEHaHRBLWh0QVNodEF5aHRBn2h0QcVodEHsaHRBEml0QThpdEFeaXRBhGl0QappdEHQaXRB92l0QR1qdEFDanRBaWp0QY9qdEG1anRB22p0QQFrdEEoa3RBTmt0QXRrdEGaa3RBwGt0QeZrdEEMbHRBMmx0QVlsdEF/bHRBpWx0QctsdEHxbHRBF210QT1tdEFjbXRBiW10QbBtdEHWbXRB/G10QSJudEFIbnRBbm50QZRudEG6bnRB4G50QQZvdEEtb3RBU290QXlvdEGfb3RBxW90QetvdEERcHRBN3B0QV1wdEGDcHRBqXB0QdBwdEH2cHRBHHF0QUJxdEFocXRBjnF0QbRxdEHacXRBAHJ0QSZydEFMcnRBcnJ0QZlydEG/cnRB5XJ0QQtzdEExc3RBV3N0QX1zdEGjc3RByXN0Qe9zdEEVdHRBO3R0QWF0dEGHdHRBrXR0QdR0dEH6dHRBIHV0QUZ1dEFsdXRBknV0Qbh1dEHedXRBBHZ0QSp2dEFQdnRBdnZ0QZx2dEHCdnRB6HZ0QQ53dEE0d3RBWnd0QYB3dEGnd3RBzXd0QfN3dEEZeHRBP3h0QWV4dEGLeHRBsXh0Qdd4dEH9eHRBI3l0QUl5dEFveXRBlXl0Qbt5dEHheXRBB3p0QS16dEFTenRBeXp0QZ96dEHFenRB63p0QRF7dEE3e3RBXXt0QYN7dEGpe3RBz3t0QfV7dEEbfHRBQXx0QWd8dEGNfHRBs3x0Qdl8dEH/fHRBJX10QUt9dEFxfXRBl310Qb19dEHjfXRBCX50QS9+dEFVfnRBe350QaF+dEHHfnRB7X50QRN/dEE5f3RBX390QYV/dEGrf3RB0X90Qfd/dEEdgHRBQ4B0QWmAdEGPgHRBtYB0QduAdEEBgXRBJ4F0QU2BdEFzgXRBmYF0Qb+BdEHlgXRBC4J0QTGCdEFXgnRBfYJ0QaOCdEHJgnRB74J0QRWDdEE7g3RBYYN0QYeDdEGtg3RB04N0QfmDdEEfhHRBRYR0QWuEdEGRhHRBt4R0Qd2EdEEDhXRBKIV0QU6FdEF0hXRBmoV0QcCFdEHmhXRBDIZ0QTKGdEFYhnRBfoZ0QaSGdEHKhnRB8IZ0QRaHdEE8h3RBYod0QYiHdEGuh3RB1Id0QfmHdEEfiHRBRYh0QWuIdEGRiHRBt4h0Qd2IdEEDiXRBKYl0QU+JdEF1iXRBm4l0QcGJdEHniXRBDYp0QTKKdEFYinRBfop0QaSKdEHKinRB8Ip0QRaLdEE8i3RBYot0QYiLdEGui3RB1It0QfmLdEEfjHRBRYx0QWuMdEGRjHRBt4x0Qd2MdEEDjXRBKY10QU+NdEF1jXRBmo10QcCNdEHmjXRBDI50QTKOdEFYjnRBfo50QaSOdEHKjnRB8I50QRWPdEE7j3RBYY90QYePdEGtj3RB0490QfmPdEEfkHRBRZB0QWqQdEGQkHRBtpB0QdyQdEECkXRBKJF0QU6RdEF0kXRBmZF0Qb+RdEHlkXRBC5J0QTGSdEFXknRBfZJ0QaOSdEHIknRB7pJ0QRSTdEE6k3RBYJN0QYaTdEGsk3RB0ZN0QfeTdEEdlHRBQ5R0QWmUdEGPlHRBtZR0QdqUdEEAlXRBJpV0QUyVdEFylXRBmJV0Qb6VdEHjlXRBCZZ0QS+WdEFVlnRBe5Z0QaGWdEHHlnRB7JZ0QRKXdEE4l3RBXpd0QYSXdEGql3RBz5d0QfWXdEEbmHRBQZh0QWeYdEGNmHRBsph0QdiYdEH+mHRBJJl0QUqZdEFwmXRBlZl0QbuZdEHhmXRBB5p0QS2adEFSmnRBeJp0QZ6adEHEmnRB6pp0QRCbdEE1m3RBW5t0QYGbdEGnm3RBzZt0QfKbdEEYnHRBPpx0QWScdEGKnHRBr5x0QdWcdEH7nHRBIZ10QUeddEFsnXRBkp10QbiddEHenXRBBJ50QSmedEFPnnRBdZ50QZuedEHBnnRB5p50QQyfdEEyn3RBWJ90QX6fdEGjn3RByZ90Qe+fdEEVoHRBO6B0QWCgdEGGoHRBrKB0QdKgdEH3oHRBHaF0QUOhdEFpoXRBj6F0QbShdEHaoXRBAKJ0QSaidEFLonRBcaJ0QZeidEG9onRB4qJ0QQijdEEuo3RBVKN0QXqjdEGfo3RBxaN0QeujdEERpHRBNqR0QVykdEGCpHRBqKR0Qc2kdEHzpHRBGaV0QT+ldEFkpXRBiqV0QbCldEHWpXRB+6V0QSGmdEFHpnRBbaZ0QZKmdEG4pnRB3qZ0QQSndEEpp3RBT6d0QXWndEGap3RBwKd0QeandEEMqHRBMah0QVeodEF9qHRBo6h0QciodEHuqHRBFKl0QTqpdEFfqXRBhal0QaupdEHQqXRB9ql0QRyqdEFCqnRBZ6p0QY2qdEGzqnRB2Kp0Qf6qdEEkq3RBSqt0QW+rdEGVq3RBu6t0QeCrdEEGrHRBLKx0QVKsdEF3rHRBnax0QcOsdEHorHRBDq10QTStdEFZrXRBf610QaWtdEHLrXRB8K10QRaudEE8rnRBYa50QYeudEGtrnRB0q50QfiudEEer3RBQ690QWmvdEGPr3RBta90QdqvdEEAsHRBJrB0QUuwdEFxsHRBl7B0QbywdEHisHRBCLF0QS2xdEFTsXRBebF0QZ6xdEHEsXRB6rF0QQ+ydEE1snRBW7J0QYCydEGmsnRBzLJ0QfGydEEXs3RBPbN0QWKzdEGIs3RBrrN0QdOzdEH5s3RBH7R0QUS0dEFqtHRBkLR0QbW0dEHbtHRBAbV0QSa1dEFMtXRBcbV0QZe1dEG9tXRB4rV0QQi2dEEutnRBU7Z0QXm2dEGftnRBxLZ0Qeq2dEEQt3RBNbd0QVu3dEGAt3RBprd0Qcy3dEHxt3RBF7h0QT24dEFiuHRBiLh0Qa24dEHTuHRB+bh0QR65dEFEuXRBarl0QY+5dEG1uXRB2rl0QQC6dEEmunRBS7p0QXG6dEGXunRBvLp0QeK6dEEHu3RBLbt0QVO7dEF4u3RBnrt0QcO7dEHpu3RBD7x0QTS8dEFavHRBf7x0QaW8dEHLvHRB8Lx0QRa9dEE7vXRBYb10QYe9dEGsvXRB0r10Qfe9dEEdvnRBQ750QWi+dEGOvnRBs750Qdm+dEH/vnRBJL90QUq/dEFvv3RBlb90Qbq/dEHgv3RBBsB0QSvAdEFRwHRBdsB0QZzAdEHCwHRB58B0QQ3BdEEywXRBWMF0QX3BdEGjwXRBycF0Qe7BdEEUwnRBOcJ0QV/CdEGEwnRBqsJ0Qc/CdEH1wnRBG8N0QUDDdEFmw3RBi8N0QbHDdEHWw3RB/MN0QSHEdEFHxHRBbcR0QZLEdEG4xHRB3cR0QQPFdEEoxXRBTsV0QXPFdEGZxXRBv8V0QeTFdEEKxnRBL8Z0QVXGdEF6xnRBoMZ0QcXGdEHrxnRBEMd0QTbHdEFbx3RBgcd0QafHdEHMx3RB8sd0QRfIdEE9yHRBYsh0QYjIdEGtyHRB08h0QfjIdEEeyXRBQ8l0QWnJdEGOyXRBtMl0QdnJdEH/yXRBJMp0QUrKdEFvynRBlcp0QbrKdEHgynRBBct0QSvLdEFRy3RBdst0QZzLdEHBy3RB58t0QQzMdEEyzHRBV8x0QX3MdEGizHRByMx0Qe3MdEETzXRBOM10QV7NdEGDzXRBqc10Qc7NdEH0zXRBGc50QT7OdEFkznRBic50Qa/OdEHUznRB+s50QR/PdEFFz3RBas90QZDPdEG1z3RB2890QQDQdEEm0HRBS9B0QXHQdEGW0HRBvNB0QeHQdEEH0XRBLNF0QVLRdEF30XRBnNF0QcLRdEHn0XRBDdJ0QTLSdEFY0nRBfdJ0QaPSdEHI0nRB7tJ0QRPTdEE503RBXtN0QYTTdEGp03RBztN0QfTTdEEZ1HRBP9R0QWTUdEGK1HRBr9R0QdXUdEH61HRBH9V0QUXVdEFq1XRBkNV0QbXVdEHb1XRBANZ0QSbWdEFL1nRBcNZ0QZbWdEG71nRB4dZ0QQbXdEEs13RBUdd0QXbXdEGc13RBwdd0QefXdEEM2HRBMth0QVfYdEF82HRBoth0QcfYdEHt2HRBEtl0QTjZdEFd2XRBgtl0QajZdEHN2XRB89l0QRjadEE+2nRBY9p0QYjadEGu2nRB09p0QfnadEEe23RBQ9t0QWnbdEGO23RBtNt0QdnbdEH+23RBJNx0QUncdEFv3HRBlNx0QbncdEHf3HRBBN10QSrddEFP3XRBdN10QZrddEG/3XRB5d10QQredEEv3nRBVd50QXredEGf3nRBxd50QeredEEQ33RBNd90QVrfdEGA33RBpd90QcvfdEHw33RBFeB0QTvgdEFg4HRBheB0QavgdEHQ4HRB9uB0QRvhdEFA4XRBZuF0QYvhdEGw4XRB1uF0QfvhdEEg4nRBRuJ0QWvidEGR4nRBtuJ0QdvidEEB43RBJuN0QUvjdEFx43RBluN0QbvjdEHh43RBBuR0QSvkdEFR5HRBduR0QZzkdEHB5HRB5uR0QQzldEEx5XRBVuV0QXzldEGh5XRBxuV0QezldEER5nRBNuZ0QVzmdEGB5nRBpuZ0QczmdEHx5nRBFud0QTzndEFh53RBhud0QazndEHR53RB9ud0QRzodEFB6HRBZuh0QYzodEGx6HRB1uh0QfzodEEh6XRBRul0QWzpdEGR6XRBtul0QdvpdEEB6nRBJup0QUvqdEFx6nRBlup0QbvqdEHh6nRBBut0QSvrdEFR63RBdut0QZvrdEHA63RB5ut0QQvsdEEw7HRBVux0QXvsdEGg7HRBxux0QevsdEEQ7XRBNe10QVvtdEGA7XRBpe10QcvtdEHw7XRBFe50QTrudEFg7nRBhe50QarudEHQ7nRB9e50QRrvdEE/73RBZe90QYrvdEGv73RB1e90QfrvdEEf8HRBRPB0QWrwdEGP8HRBtPB0QdrwdEH/8HRBJPF0QUnxdEFv8XRBlPF0QbnxdEHe8XRBBPJ0QSnydEFO8nRBc/J0QZnydEG+8nRB4/J0QQjzdEEu83RBU/N0QXjzdEGd83RBw/N0QejzdEEN9HRBMvR0QVj0dEF99HRBovR0Qcf0dEHt9HRBEvV0QTf1dEFc9XRBgvV0Qaf1dEHM9XRB8fV0QRf2dEE89nRBYfZ0QYb2dEGs9nRB0fZ0Qfb2dEEb93RBQfd0QWb3dEGL93RBsPd0QdX3dEH793RBIPh0QUX4dEFq+HRBkPh0QbX4dEHa+HRB//h0QST5dEFK+XRBb/l0QZT5dEG5+XRB3/l0QQT6dEEp+nRBTvp0QXP6dEGZ+nRBvvp0QeP6dEEI+3RBLft0QVP7dEF4+3RBnft0QcL7dEHn+3RBDfx0QTL8dEFX/HRBfPx0QaH8dEHH/HRB7Px0QRH9dEE2/XRBW/10QYH9dEGm/XRBy/10QfD9dEEV/nRBO/50QWD+dEGF/nRBqv50Qc/+dEH0/nRBGv90QT//dEFk/3RBif90Qa7/dEHU/3RB+f90QR4AdUFDAHVBaAB1QY0AdUGzAHVB2AB1Qf0AdUEiAXVBRwF1QWwBdUGSAXVBtwF1QdwBdUEBAnVBJgJ1QUsCdUFxAnVBlgJ1QbsCdUHgAnVBBQN1QSoDdUFPA3VBdQN1QZoDdUG/A3VB5AN1QQkEdUEuBHVBVAR1QXkEdUGeBHVBwwR1QegEdUENBXVBMgV1QVgFdUF9BXVBogV1QccFdUHsBXVBEQZ1QTYGdUFcBnVBgQZ1QaYGdUHLBnVB8AZ1QRUHdUE6B3VBXwd1QYUHdUGqB3VBzwd1QfQHdUEZCHVBPgh1QWMIdUGICHVBrgh1QdMIdUH4CHVBHQl1QUIJdUFnCXVBjAl1QbEJdUHWCXVB/Al1QSEKdUFGCnVBawp1QZAKdUG1CnVB2gp1Qf8KdUEkC3VBSgt1QW8LdUGUC3VBuQt1Qd4LdUEDDHVBKAx1QU0MdUFyDHVBlwx1Qb0MdUHiDHVBBw11QSwNdUFRDXVBdg11QZsNdUHADXVB5Q11QQoOdUEvDnVBVQ51QXoOdUGfDnVBxA51QekOdUEOD3VBMw91QVgPdUF9D3VBog91QccPdUHsD3VBEhB1QTcQdUFcEHVBgRB1QaYQdUHLEHVB8BB1QRURdUE6EXVBXxF1QYQRdUGpEXVBzhF1QfMRdUEYEnVBPhJ1QWMSdUGIEnVBrRJ1QdISdUH3EnVBHBN1QUETdUFmE3VBixN1QbATdUHVE3VB+hN1QR8UdUFEFHVBaRR1QY4UdUGzFHVB2BR1Qf4UdUEjFXVBSBV1QW0VdUGSFXVBtxV1QdwVdUEBFnVBJhZ1QUsWdUFwFnVBlRZ1QboWdUHfFnVBBBd1QSkXdUFOF3VBcxd1QZgXdUG9F3VB4hd1QQcYdUEsGHVBURh1QXYYdUGbGHVBwBh1QeUYdUEKGXVBLxl1QVQZdUF5GXVBnhl1QcMZdUHoGXVBDRp1QTIadUFYGnVBfRp1QaIadUHHGnVB7Bp1QREbdUE2G3VBWxt1QYAbdUGlG3VByht1Qe8bdUEUHHVBORx1QV4cdUGDHHVBqBx1Qc0cdUHyHHVBFx11QTwddUFhHXVBhh11QaoddUHPHXVB9B11QRkedUE+HnVBYx51QYgedUGtHnVB0h51QfcedUEcH3VBQR91QWYfdUGLH3VBsB91QdUfdUH6H3VBHyB1QUQgdUFpIHVBjiB1QbMgdUHYIHVB/SB1QSIhdUFHIXVBbCF1QZEhdUG2IXVB2yF1QQAidUElInVBSiJ1QW8idUGUInVBuSJ1Qd4idUECI3VBJyN1QUwjdUFxI3VBliN1QbsjdUHgI3VBBSR1QSokdUFPJHVBdCR1QZkkdUG+JHVB4yR1QQgldUEtJXVBUiV1QXcldUGcJXVBwCV1QeUldUEKJnVBLyZ1QVQmdUF5JnVBniZ1QcMmdUHoJnVBDSd1QTIndUFXJ3VBfCd1QaEndUHGJ3VB6id1QQ8odUE0KHVBWSh1QX4odUGjKHVByCh1Qe0odUESKXVBNyl1QVwpdUGBKXVBpSl1QcopdUHvKXVBFCp1QTkqdUFeKnVBgyp1QagqdUHNKnVB8ip1QRcrdUE7K3VBYCt1QYUrdUGqK3VBzyt1QfQrdUEZLHVBPix1QWMsdUGILHVBrCx1QdEsdUH2LHVBGy11QUAtdUFlLXVBii11Qa8tdUHULXVB+C11QR0udUFCLnVBZy51QYwudUGxLnVB1i51QfsudUEgL3VBRC91QWkvdUGOL3VBsy91QdgvdUH9L3VBIjB1QUcwdUFrMHVBkDB1QbUwdUHaMHVB/zB1QSQxdUFJMXVBbjF1QZIxdUG3MXVB3DF1QQEydUEmMnVBSzJ1QXAydUGUMnVBuTJ1Qd4ydUEDM3VBKDN1QU0zdUFyM3VBljN1QbszdUHgM3VBBTR1QSo0dUFPNHVBczR1QZg0dUG9NHVB4jR1QQc1dUEsNXVBUTV1QXU1dUGaNXVBvzV1QeQ1dUEJNnVBLjZ1QVI2dUF3NnVBnDZ1QcE2dUHmNnVBCzd1QS83dUFUN3VBeTd1QZ43dUHDN3VB6Dd1QQw4dUExOHVBVjh1QXs4dUGgOHVBxDh1Qek4dUEOOXVBMzl1QVg5dUF9OXVBoTl1QcY5dUHrOXVBEDp1QTU6dUFZOnVBfjp1QaM6dUHIOnVB7Tp1QRE7dUE2O3VBWzt1QYA7dUGlO3VByjt1Qe47dUETPHVBODx1QV08dUGBPHVBpjx1Qcs8dUHwPHVBFT11QTk9dUFePXVBgz11Qag9dUHNPXVB8T11QRY+dUE7PnVBYD51QYU+dUGpPnVBzj51QfM+dUEYP3VBPD91QWE/dUGGP3VBqz91QdA/dUH0P3VBGUB1QT5AdUFjQHVBh0B1QaxAdUHRQHVB9kB1QRtBdUE/QXVBZEF1QYlBdUGuQXVB0kF1QfdBdUEcQnVBQUJ1QWVCdUGKQnVBr0J1QdRCdUH4QnVBHUN1QUJDdUFnQ3VBi0N1QbBDdUHVQ3VB+kN1QR5EdUFDRHVBaER1QY1EdUGxRHVB1kR1QftEdUEgRXVBREV1QWlFdUGORXVBs0V1QddFdUH8RXVBIUZ1QUZGdUFqRnVBj0Z1QbRGdUHZRnVB/UZ1QSJHdUFHR3VBa0d1QZBHdUG1R3VB2kd1Qf5HdUEjSHVBSEh1QW1IdUGRSHVBtkh1QdtIdUH/SHVBJEl1QUlJdUFuSXVBkkl1QbdJdUHcSXVBAEp1QSVKdUFKSnVBb0p1QZNKdUG4SnVB3Up1QQFLdUEmS3VBS0t1QW9LdUGUS3VBuUt1Qd5LdUECTHVBJ0x1QUxMdUFwTHVBlUx1QbpMdUHeTHVBA011QShNdUFNTXVBcU11QZZNdUG7TXVB3011QQROdUEpTnVBTU51QXJOdUGXTnVBu051QeBOdUEFT3VBKU91QU5PdUFzT3VBmE91QbxPdUHhT3VBBlB1QSpQdUFPUHVBdFB1QZhQdUG9UHVB4lB1QQZRdUErUXVBUFF1QXRRdUGZUXVBvlF1QeJRdUEHUnVBLFJ1QVBSdUF1UnVBmlJ1Qb5SdUHjUnVBCFN1QSxTdUFRU3VBdlN1QZpTdUG/U3VB41N1QQhUdUEtVHVBUVR1QXZUdUGbVHVBv1R1QeRUdUEJVXVBLVV1QVJVdUF3VXVBm1V1QcBVdUHkVXVBCVZ1QS5WdUFSVnVBd1Z1QZxWdUHAVnVB5VZ1QQpXdUEuV3VBU1d1QXdXdUGcV3VBwVd1QeVXdUEKWHVBL1h1QVNYdUF4WHVBnFh1QcFYdUHmWHVBCll1QS9ZdUFUWXVBeFl1QZ1ZdUHBWXVB5ll1QQtadUEvWnVBVFp1QXhadUGdWnVBwlp1QeZadUELW3VBMFt1QVRbdUF5W3VBnVt1QcJbdUHnW3VBC1x1QTBcdUFUXHVBeVx1QZ5cdUHCXHVB51x1QQtddUEwXXVBVV11QXlddUGeXXVBwl11QedddUELXnVBMF51QVVedUF5XnVBnl51QcJedUHnXnVBDF91QTBfdUFVX3VBeV91QZ5fdUHCX3VB5191QQxgdUEwYHVBVWB1QXlgdUGeYHVBwmB1QedgdUEMYXVBMGF1QVVhdUF5YXVBnmF1QcJhdUHnYXVBDGJ1QTBidUFVYnVBeWJ1QZ5idUHCYnVB52J1QQtjdUEwY3VBVWN1QXljdUGeY3VBwmN1QedjdUELZHVBMGR1QVRkdUF5ZHVBnmR1QcJkdUHnZHVBC2V1QTBldUFUZXVBeWV1QZ1ldUHCZXVB5mV1QQtmdUEwZnVBVGZ1QXlmdUGdZnVBwmZ1QeZmdUELZ3VBL2d1QVRndUF4Z3VBnWd1QcFndUHmZ3VBCmh1QS9odUFUaHVBeGh1QZ1odUHBaHVB5mh1QQppdUEvaXVBU2l1QXhpdUGcaXVBwWl1QeVpdUEKanVBLmp1QVNqdUF3anVBnGp1QcBqdUHlanVBCWt1QS5rdUFSa3VBd2t1QZtrdUHAa3VB5Gt1QQlsdUEtbHVBUmx1QXZsdUGbbHVBv2x1QeRsdUEIbXVBLW11QVFtdUF2bXVBmm11Qb9tdUHjbXVBCG51QSxudUFRbnVBdW51QZpudUG+bnVB4251QQdvdUEsb3VBUG91QXVvdUGZb3VBvm91QeJvdUEHcHVBK3B1QVBwdUF0cHVBmHB1Qb1wdUHhcHVBBnF1QSpxdUFPcXVBc3F1QZhxdUG8cXVB4XF1QQVydUEqcnVBTnJ1QXNydUGXcnVBu3J1QeBydUEEc3VBKXN1QU1zdUFyc3VBlnN1QbtzdUHfc3VBBHR1QSh0dUFMdHVBcXR1QZV0dUG6dHVB3nR1QQN1dUEndXVBTHV1QXB1dUGUdXVBuXV1Qd11dUECdnVBJnZ1QUt2dUFvdnVBlHZ1Qbh2dUHcdnVBAXd1QSV3dUFKd3VBbnd1QZN3dUG3d3VB23d1QQB4dUEkeHVBSXh1QW14dUGSeHVBtnh1Qdp4dUH/eHVBI3l1QUh5dUFseXVBkXl1QbV5dUHZeXVB/nl1QSJ6dUFHenVBa3p1QY96dUG0enVB2Hp1Qf16dUEhe3VBRnt1QWp7dUGOe3VBs3t1Qdd7dUH8e3VBIHx1QUR8dUFpfHVBjXx1QbJ8dUHWfHVB+nx1QR99dUFDfXVBaH11QYx9dUGwfXVB1X11Qfl9dUEdfnVBQn51QWZ+dUGLfnVBr351QdN+dUH4fnVBHH91QUF/dUFlf3VBiX91Qa5/dUHSf3VB9n91QRuAdUE/gHVBZIB1QYiAdUGsgHVB0YB1QfWAdUEZgXVBPoF1QWKBdUGHgXVBq4F1Qc+BdUH0gXVBGIJ1QTyCdUFhgnVBhYJ1QaqCdUHOgnVB8oJ1QReDdUE7g3VBX4N1QYSDdUGog3VBzIN1QfGDdUEVhHVBOYR1QV6EdUGChHVBp4R1QcuEdUHvhHVBFIV1QTiFdUFchXVBgYV1QaWFdUHJhXVB7oV1QRKGdUE2hnVBW4Z1QX+GdUGjhnVByIZ1QeyGdUEQh3VBNYd1QVmHdUF9h3VBood1QcaHdUHqh3VBD4h1QTOIdUFXiHVBfIh1QaCIdUHEiHVB6Yh1QQ2JdUExiXVBVol1QXqJdUGeiXVBw4l1QeeJdUELinVBL4p1QVSKdUF4inVBnIp1QcGKdUHlinVBCYt1QS6LdUFSi3VBdot1QZuLdUG/i3VB44t1QQiMdUEsjHVBUIx1QXSMdUGZjHVBvYx1QeGMdUEGjXVBKo11QU6NdUFzjXVBl411QbuNdUHfjXVBBI51QSiOdUFMjnVBcY51QZWOdUG5jnVB3Y51QQKPdUEmj3VBSo91QW+PdUGTj3VBt491QduPdUEAkHVBJJB1QUiQdUFtkHVBkZB1QbWQdUHZkHVB/pB1QSKRdUFGkXVBapF1QY+RdUGzkXVB15F1QfyRdUEgknVBRJJ1QWiSdUGNknVBsZJ1QdWSdUH5knVBHpN1QUKTdUFmk3VBipN1Qa+TdUHTk3VB95N1QRuUdUFAlHVBZJR1QYiUdUGslHVB0ZR1QfWUdUEZlXVBPZV1QWKVdUGGlXVBqpV1Qc6VdUHzlXVBF5Z1QTuWdUFflnVBhJZ1QaiWdUHMlnVB8JZ1QRWXdUE5l3VBXZd1QYGXdUGml3VBypd1Qe6XdUESmHVBNph1QVuYdUF/mHVBo5h1QceYdUHsmHVBEJl1QTSZdUFYmXVBfZl1QaGZdUHFmXVB6Zl1QQ2adUEymnVBVpp1QXqadUGemnVBwpp1QeeadUELm3VBL5t1QVObdUF4m3VBnJt1QcCbdUHkm3VBCJx1QS2cdUFRnHVBdZx1QZmcdUG9nHVB4px1QQaddUEqnXVBTp11QXKddUGXnXVBu511Qd+ddUEDnnVBJ551QUyedUFwnnVBlJ51QbiedUHcnnVBAZ91QSWfdUFJn3VBbZ91QZGfdUG1n3VB2p91Qf6fdUEioHVBRqB1QWqgdUGPoHVBs6B1QdegdUH7oHVBH6F1QUOhdUFooXVBjKF1QbChdUHUoXVB+KF1QRyidUFBonVBZaJ1QYmidUGtonVB0aJ1QfWidUEao3VBPqN1QWKjdUGGo3VBqqN1Qc6jdUHzo3VBF6R1QTukdUFfpHVBg6R1QaekdUHMpHVB8KR1QRSldUE4pXVBXKV1QYCldUGkpXVByaV1Qe2ldUERpnVBNaZ1QVmmdUF9pnVBoaZ1QcamdUHqpnVBDqd1QTKndUFWp3VBeqd1QZ6ndUHDp3VB56d1QQuodUEvqHVBU6h1QXeodUGbqHVBv6h1QeSodUEIqXVBLKl1QVCpdUF0qXVBmKl1QbypdUHgqXVBBap1QSmqdUFNqnVBcap1QZWqdUG5qnVB3ap1QQGrdUEmq3VBSqt1QW6rdUGSq3VBtqt1QdqrdUH+q3VBIqx1QUasdUFrrHVBj6x1QbOsdUHXrHVB+6x1QR+tdUFDrXVBZ611QYutdUGvrXVB1K11QfitdUEcrnVBQK51QWSudUGIrnVBrK51QdCudUH0rnVBGK91QTyvdUFhr3VBha91QamvdUHNr3VB8a91QRWwdUE5sHVBXbB1QYGwdUGlsHVBybB1Qe2wdUESsXVBNrF1QVqxdUF+sXVBorF1QcaxdUHqsXVBDrJ1QTKydUFWsnVBerJ1QZ6ydUHCsnVB5rJ1QQuzdUEvs3VBU7N1QXezdUGbs3VBv7N1QeOzdUEHtHVBK7R1QU+0dUFztHVBl7R1Qbu0dUHftHVBA7V1QSe1dUFLtXVBcLV1QZS1dUG4tXVB3LV1QQC2dUEktnVBSLZ1QWy2dUGQtnVBtLZ1Qdi2dUH8tnVBILd1QUS3dUFot3VBjLd1QbC3dUHUt3VB+Ld1QRy4dUFAuHVBZLh1QYi4dUGsuHVB0bh1QfW4dUEZuXVBPbl1QWG5dUGFuXVBqbl1Qc25dUHxuXVBFbp1QTm6dUFdunVBgbp1QaW6dUHJunVB7bp1QRG7dUE1u3VBWbt1QX27dUGhu3VBxbt1Qem7dUENvHVBMbx1QVW8dUF5vHVBnbx1QcG8dUHlvHVBCb11QS29dUFRvXVBdb11QZm9dUG9vXVB4b11QQW+dUEpvnVBTb51QXG+dUGVvnVBub51Qd2+dUEBv3VBJb91QUm/dUFtv3VBkb91QbW/dUHZv3VB/b91QSHAdUFFwHVBacB1QY3AdUGxwHVB1cB1QfnAdUEdwXVBQcF1QWXBdUGJwXVBrcF1QdHBdUH1wXVBGcJ1QT3CdUFhwnVBhcJ1QanCdUHNwnVB8MJ1QRTDdUE4w3VBXMN1QYDDdUGkw3VByMN1QezDdUEQxHVBNMR1QVjEdUF8xHVBoMR1QcTEdUHoxHVBDMV1QTDFdUFUxXVBeMV1QZzFdUHAxXVB5MV1QQjGdUEsxnVBT8Z1QXPGdUGXxnVBu8Z1Qd/GdUEDx3VBJ8d1QUvHdUFvx3VBk8d1QbfHdUHbx3VB/8d1QSPIdUFHyHVBa8h1QY/IdUGyyHVB1sh1QfrIdUEeyXVBQsl1QWbJdUGKyXVBrsl1QdLJdUH2yXVBGsp1QT7KdUFiynVBhsp1QanKdUHNynVB8cp1QRXLdUE5y3VBXct1QYHLdUGly3VByct1Qe3LdUERzHVBNcx1QVjMdUF8zHVBoMx1QcTMdUHozHVBDM11QTDNdUFUzXVBeM11QZzNdUHAzXVB4811QQfOdUErznVBT851QXPOdUGXznVBu851Qd/OdUEDz3VBJ891QUrPdUFuz3VBks91QbbPdUHaz3VB/s91QSLQdUFG0HVBatB1QY3QdUGx0HVB1dB1QfnQdUEd0XVBQdF1QWXRdUGJ0XVBrdF1QdDRdUH00XVBGNJ1QTzSdUFg0nVBhNJ1QajSdUHM0nVB79J1QRPTdUE303VBW9N1QX/TdUGj03VBx9N1QerTdUEO1HVBMtR1QVbUdUF61HVBntR1QcLUdUHl1HVBCdV1QS3VdUFR1XVBddV1QZnVdUG91XVB4NV1QQTWdUEo1nVBTNZ1QXDWdUGU1nVBuNZ1QdvWdUH/1nVBI9d1QUfXdUFr13VBj9d1QbPXdUHW13VB+td1QR7YdUFC2HVBZth1QYrYdUGt2HVB0dh1QfXYdUEZ2XVBPdl1QWHZdUGE2XVBqNl1QczZdUHw2XVBFNp1QTjadUFb2nVBf9p1QaPadUHH2nVB69p1QQ/bdUEy23VBVtt1QXrbdUGe23VBwtt1QeXbdUEJ3HVBLdx1QVHcdUF13HVBmNx1QbzcdUHg3HVBBN11QSjddUFM3XVBb911QZPddUG33XVB2911Qf/ddUEi3nVBRt51QWredUGO3nVBst51QdXedUH53nVBHd91QUHfdUFl33VBiN91QazfdUHQ33VB9N91QRjgdUE74HVBX+B1QYPgdUGn4HVBy+B1Qe7gdUES4XVBNuF1QVrhdUF94XVBoeF1QcXhdUHp4XVBDeJ1QTDidUFU4nVBeOJ1QZzidUG/4nVB4+J1QQfjdUEr43VBT+N1QXLjdUGW43VBuuN1Qd7jdUEB5HVBJeR1QUnkdUFt5HVBkOR1QbTkdUHY5HVB/OR1QSDldUFD5XVBZ+V1QYvldUGv5XVB0uV1QfbldUEa5nVBPuZ1QWHmdUGF5nVBqeZ1Qc3mdUHw5nVBFOd1QTjndUFc53VBf+d1QaPndUHH53VB6+d1QQ7odUEy6HVBVuh1QXrodUGd6HVBweh1QeXodUEI6XVBLOl1QVDpdUF06XVBl+l1QbvpdUHf6XVBA+p1QSbqdUFK6nVBbup1QZLqdUG16nVB2ep1Qf3qdUEg63VBROt1QWjrdUGM63VBr+t1QdPrdUH363VBG+x1QT7sdUFi7HVBhux1QansdUHN7HVB8ex1QRXtdUE47XVBXO11QYDtdUGj7XVBx+11QevtdUEP7nVBMu51QVbudUF67nVBne51QcHudUHl7nVBCO91QSzvdUFQ73VBdO91QZfvdUG773VB3+91QQLwdUEm8HVBSvB1QW3wdUGR8HVBtfB1QdjwdUH88HVBIPF1QUTxdUFn8XVBi/F1Qa/xdUHS8XVB9vF1QRrydUE98nVBYfJ1QYXydUGo8nVBzPJ1QfDydUET83VBN/N1QVvzdUF+83VBovN1QcbzdUHp83VBDfR1QTH0dUFU9HVBePR1QZz0dUG/9HVB4/R1QQf1dUEq9XVBTvV1QXL1dUGV9XVBufV1Qd31dUEA9nVBJPZ1QUj2dUFr9nVBj/Z1QbP2dUHW9nVB+vZ1QR73dUFB93VBZfd1QYn3dUGs93VB0Pd1QfT3dUEX+HVBO/h1QV/4dUGC+HVBpvh1Qcn4dUHt+HVBEfl1QTT5dUFY+XVBfPl1QZ/5dUHD+XVB5/l1QQr6dUEu+nVBUfp1QXX6dUGZ+nVBvPp1QeD6dUEE+3VBJ/t1QUv7dUFv+3VBkvt1Qbb7dUHZ+3VB/ft1QSH8dUFE/HVBaPx1QYz8dUGv/HVB0/x1Qfb8dUEa/XVBPv11QWH9dUGF/XVBqP11Qcz9dUHw/XVBE/51QTf+dUFb/nVBfv51QaL+dUHF/nVB6f51QQ3/dUEw/3VBVP91QXf/dUGb/3VBv/91QeL/dUEGAHZBKQB2QU0AdkFxAHZBlAB2QbgAdkHbAHZB/wB2QSMBdkFGAXZBagF2QY0BdkGxAXZB1AF2QfgBdkEcAnZBPwJ2QWMCdkGGAnZBqgJ2Qc4CdkHxAnZBFQN2QTgDdkFcA3ZBfwN2QaMDdkHHA3ZB6gN2QQ4EdkExBHZBVQR2QXgEdkGcBHZBwAR2QeMEdkEHBXZBKgV2QU4FdkFxBXZBlQV2QbkFdkHcBXZBAAZ2QSMGdkFHBnZBagZ2QY4GdkGyBnZB1QZ2QfkGdkEcB3ZBQAd2QWMHdkGHB3ZBqgd2Qc4HdkHyB3ZBFQh2QTkIdkFcCHZBgAh2QaMIdkHHCHZB6gh2QQ4JdkExCXZBVQl2QXkJdkGcCXZBwAl2QeMJdkEHCnZBKgp2QU4KdkFxCnZBlQp2QbgKdkHcCnZB/wp2QSMLdkFHC3ZBagt2QY4LdkGxC3ZB1Qt2QfgLdkEcDHZBPwx2QWMMdkGGDHZBqgx2Qc0MdkHxDHZBFA12QTgNdkFbDXZBfw12QaINdkHGDXZB6Q12QQ0OdkEwDnZBVA52QXgOdkGbDnZBvw52QeIOdkEGD3ZBKQ92QU0PdkFwD3ZBlA92QbcPdkHbD3ZB/g92QSIQdkFFEHZBaRB2QYwQdkGwEHZB0xB2QfcQdkEaEXZBPhF2QWERdkGFEXZBqBF2QcwRdkHvEXZBExJ2QTYSdkFaEnZBfRJ2QaASdkHEEnZB5xJ2QQsTdkEuE3ZBUhN2QXUTdkGZE3ZBvBN2QeATdkEDFHZBJxR2QUoUdkFuFHZBkRR2QbUUdkHYFHZB/BR2QR8VdkFDFXZBZhV2QYoVdkGtFXZB0BV2QfQVdkEXFnZBOxZ2QV4WdkGCFnZBpRZ2QckWdkHsFnZBEBd2QTMXdkFXF3ZBehd2QZ0XdkHBF3ZB5Bd2QQgYdkErGHZBTxh2QXIYdkGWGHZBuRh2Qd0YdkEAGXZBIxl2QUcZdkFqGXZBjhl2QbEZdkHVGXZB+Bl2QRwadkE/GnZBYhp2QYYadkGpGnZBzRp2QfAadkEUG3ZBNxt2QVsbdkF+G3ZBoRt2QcUbdkHoG3ZBDBx2QS8cdkFTHHZBdhx2QZkcdkG9HHZB4Bx2QQQddkEnHXZBSx12QW4ddkGRHXZBtR12QdgddkH8HXZBHx52QUIedkFmHnZBiR52Qa0edkHQHnZB9B52QRcfdkE6H3ZBXh92QYEfdkGlH3ZByB92QesfdkEPIHZBMiB2QVYgdkF5IHZBnCB2QcAgdkHjIHZBByF2QSohdkFNIXZBcSF2QZQhdkG4IXZB2yF2Qf4hdkEiInZBRSJ2QWkidkGMInZBryJ2QdMidkH2InZBGiN2QT0jdkFgI3ZBhCN2QacjdkHKI3ZB7iN2QREkdkE1JHZBWCR2QXskdkGfJHZBwiR2QeYkdkEJJXZBLCV2QVAldkFzJXZBliV2QboldkHdJXZBASZ2QSQmdkFHJnZBayZ2QY4mdkGxJnZB1SZ2QfgmdkEbJ3ZBPyd2QWIndkGGJ3ZBqSd2QcwndkHwJ3ZBEyh2QTYodkFaKHZBfSh2QaAodkHEKHZB5yh2QQopdkEuKXZBUSl2QXUpdkGYKXZBuyl2Qd8pdkECKnZBJSp2QUkqdkFsKnZBjyp2QbMqdkHWKnZB+Sp2QR0rdkFAK3ZBYyt2QYcrdkGqK3ZBzSt2QfErdkEULHZBNyx2QVssdkF+LHZBoSx2QcUsdkHoLHZBCy12QS8tdkFSLXZBdS12QZktdkG8LXZB3y12QQMudkEmLnZBSS52QW0udkGQLnZBsy52QdcudkH6LnZBHS92QUEvdkFkL3ZBhy92QaovdkHOL3ZB8S92QRQwdkE4MHZBWzB2QX4wdkGiMHZBxTB2QegwdkEMMXZBLzF2QVIxdkF1MXZBmTF2QbwxdkHfMXZBAzJ2QSYydkFJMnZBbTJ2QZAydkGzMnZB1jJ2QfoydkEdM3ZBQDN2QWQzdkGHM3ZBqjN2Qc0zdkHxM3ZBFDR2QTc0dkFbNHZBfjR2QaE0dkHENHZB6DR2QQs1dkEuNXZBUjV2QXU1dkGYNXZBuzV2Qd81dkECNnZBJTZ2QUk2dkFsNnZBjzZ2QbI2dkHWNnZB+TZ2QRw3dkE/N3ZBYzd2QYY3dkGpN3ZBzTd2QfA3dkETOHZBNjh2QVo4dkF9OHZBoDh2QcM4dkHnOHZBCjl2QS05dkFQOXZBdDl2QZc5dkG6OXZB3Tl2QQE6dkEkOnZBRzp2QWo6dkGOOnZBsTp2QdQ6dkH3OnZBGzt2QT47dkFhO3ZBhDt2Qag7dkHLO3ZB7jt2QRE8dkE1PHZBWDx2QXs8dkGePHZBwTx2QeU8dkEIPXZBKz12QU49dkFyPXZBlT12Qbg9dkHbPXZB/z12QSI+dkFFPnZBaD52QYs+dkGvPnZB0j52QfU+dkEYP3ZBPD92QV8/dkGCP3ZBpT92Qcg/dkHsP3ZBD0B2QTJAdkFVQHZBeUB2QZxAdkG/QHZB4kB2QQVBdkEpQXZBTEF2QW9BdkGSQXZBtUF2QdlBdkH8QXZBH0J2QUJCdkFlQnZBiUJ2QaxCdkHPQnZB8kJ2QRVDdkE5Q3ZBXEN2QX9DdkGiQ3ZBxUN2QelDdkEMRHZBL0R2QVJEdkF1RHZBmUR2QbxEdkHfRHZBAkV2QSVFdkFIRXZBbEV2QY9FdkGyRXZB1UV2QfhFdkEcRnZBP0Z2QWJGdkGFRnZBqEZ2QctGdkHvRnZBEkd2QTVHdkFYR3ZBe0d2QZ5HdkHCR3ZB5Ud2QQhIdkErSHZBTkh2QXJIdkGVSHZBuEh2QdtIdkH+SHZBIUl2QURJdkFoSXZBi0l2Qa5JdkHRSXZB9El2QRdKdkE7SnZBXkp2QYFKdkGkSnZBx0p2QepKdkENS3ZBMUt2QVRLdkF3S3ZBmkt2Qb1LdkHgS3ZBBEx2QSdMdkFKTHZBbUx2QZBMdkGzTHZB1kx2QfpMdkEdTXZBQE12QWNNdkGGTXZBqU12QcxNdkHvTXZBE052QTZOdkFZTnZBfE52QZ9OdkHCTnZB5U52QQhPdkEsT3ZBT092QXJPdkGVT3ZBuE92QdtPdkH+T3ZBIVB2QUVQdkFoUHZBi1B2Qa5QdkHRUHZB9FB2QRdRdkE6UXZBXlF2QYFRdkGkUXZBx1F2QepRdkENUnZBMFJ2QVNSdkF2UnZBmVJ2Qb1SdkHgUnZBA1N2QSZTdkFJU3ZBbFN2QY9TdkGyU3ZB1VN2QflTdkEcVHZBP1R2QWJUdkGFVHZBqFR2QctUdkHuVHZBEVV2QTRVdkFXVXZBe1V2QZ5VdkHBVXZB5FV2QQdWdkEqVnZBTVZ2QXBWdkGTVnZBtlZ2QdlWdkH8VnZBIFd2QUNXdkFmV3ZBiVd2QaxXdkHPV3ZB8ld2QRVYdkE4WHZBW1h2QX5YdkGhWHZBxFh2QedYdkELWXZBLll2QVFZdkF0WXZBl1l2QbpZdkHdWXZBAFp2QSNadkFGWnZBaVp2QYxadkGvWnZB0lp2QfVadkEYW3ZBO1t2QV9bdkGCW3ZBpVt2QchbdkHrW3ZBDlx2QTFcdkFUXHZBd1x2QZpcdkG9XHZB4Fx2QQNddkEmXXZBSV12QWxddkGPXXZBsl12QdVddkH4XXZBG152QT5edkFiXnZBhV52QahedkHLXnZB7l52QRFfdkE0X3ZBV192QXpfdkGdX3ZBwF92QeNfdkEGYHZBKWB2QUxgdkFvYHZBkmB2QbVgdkHYYHZB+2B2QR5hdkFBYXZBZGF2QYdhdkGqYXZBzWF2QfBhdkETYnZBNmJ2QVlidkF8YnZBn2J2QcJidkHlYnZBCGN2QStjdkFOY3ZBcWN2QZRjdkG3Y3ZB2mN2Qf1jdkEgZHZBQ2R2QWZkdkGJZHZBrGR2Qc9kdkHyZHZBFWV2QThldkFbZXZBfmV2QaFldkHEZXZB52V2QQpmdkEtZnZBUGZ2QXNmdkGWZnZBuWZ2QdxmdkH/ZnZBImd2QUVndkFoZ3ZBi2d2Qa5ndkHRZ3ZB9Gd2QRdodkE6aHZBXWh2QYBodkGjaHZBxmh2QelodkEMaXZBL2l2QVJpdkF1aXZBmGl2QbtpdkHeaXZBAWp2QSRqdkFGanZBaWp2QYxqdkGvanZB0mp2QfVqdkEYa3ZBO2t2QV5rdkGBa3ZBpGt2QcdrdkHqa3ZBDWx2QTBsdkFTbHZBdmx2QZlsdkG8bHZB32x2QQJtdkElbXZBSG12QWptdkGNbXZBsG12QdNtdkH2bXZBGW52QTxudkFfbnZBgm52QaVudkHIbnZB6252QQ5vdkExb3ZBVG92QXdvdkGZb3ZBvG92Qd9vdkECcHZBJXB2QUhwdkFrcHZBjnB2QbFwdkHUcHZB93B2QRpxdkE9cXZBYHF2QYJxdkGlcXZByHF2QetxdkEOcnZBMXJ2QVRydkF3cnZBmnJ2Qb1ydkHgcnZBA3N2QSVzdkFIc3ZBa3N2QY5zdkGxc3ZB1HN2QfdzdkEadHZBPXR2QWB0dkGDdHZBpXR2Qch0dkHrdHZBDnV2QTF1dkFUdXZBd3V2QZp1dkG9dXZB4HV2QQJ2dkEldnZBSHZ2QWt2dkGOdnZBsXZ2QdR2dkH3dnZBGnd2QTx3dkFfd3ZBgnd2QaV3dkHId3ZB63d2QQ54dkExeHZBVHh2QXZ4dkGZeHZBvHh2Qd94dkECeXZBJXl2QUh5dkFreXZBjXl2QbB5dkHTeXZB9nl2QRl6dkE8enZBX3p2QYJ6dkGkenZBx3p2Qep6dkENe3ZBMHt2QVN7dkF2e3ZBmHt2Qbt7dkHee3ZBAXx2QSR8dkFHfHZBanx2QYx8dkGvfHZB0nx2QfV8dkEYfXZBO312QV59dkGAfXZBo312QcZ9dkHpfXZBDH52QS9+dkFSfnZBdH52QZd+dkG6fnZB3X52QQB/dkEjf3ZBRX92QWh/dkGLf3ZBrn92QdF/dkH0f3ZBFoB2QTmAdkFcgHZBf4B2QaKAdkHFgHZB54B2QQqBdkEtgXZBUIF2QXOBdkGWgXZBuIF2QduBdkH+gXZBIYJ2QUSCdkFngnZBiYJ2QayCdkHPgnZB8oJ2QRWDdkE4g3ZBWoN2QX2DdkGgg3ZBw4N2QeaDdkEIhHZBK4R2QU6EdkFxhHZBlIR2QbaEdkHZhHZB/IR2QR+FdkFChXZBZIV2QYeFdkGqhXZBzYV2QfCFdkEShnZBNYZ2QViGdkF7hnZBnoZ2QcCGdkHjhnZBBod2QSmHdkFMh3ZBbod2QZGHdkG0h3ZB14d2QfqHdkEciHZBP4h2QWKIdkGFiHZBqIh2QcqIdkHtiHZBEIl2QTOJdkFViXZBeIl2QZuJdkG+iXZB4Yl2QQOKdkEminZBSYp2QWyKdkGOinZBsYp2QdSKdkH3inZBGot2QTyLdkFfi3ZBgot2QaWLdkHHi3ZB6ot2QQ2MdkEwjHZBUox2QXWMdkGYjHZBu4x2Qd6MdkEAjXZBI412QUaNdkFpjXZBi412Qa6NdkHRjXZB9I12QRaOdkE5jnZBXI52QX+OdkGhjnZBxI52QeeOdkEKj3ZBLI92QU+PdkFyj3ZBlY92QbePdkHaj3ZB/Y92QSCQdkFCkHZBZZB2QYiQdkGqkHZBzZB2QfCQdkETkXZBNZF2QViRdkF7kXZBnpF2QcCRdkHjkXZBBpJ2QSmSdkFLknZBbpJ2QZGSdkGzknZB1pJ2QfmSdkEck3ZBPpN2QWGTdkGEk3ZBp5N2QcmTdkHsk3ZBD5R2QTGUdkFUlHZBd5R2QZqUdkG8lHZB35R2QQKVdkEklXZBR5V2QWqVdkGNlXZBr5V2QdKVdkH1lXZBF5Z2QTqWdkFdlnZBf5Z2QaKWdkHFlnZB6JZ2QQqXdkEtl3ZBUJd2QXKXdkGVl3ZBuJd2QdqXdkH9l3ZBIJh2QUOYdkFlmHZBiJh2QauYdkHNmHZB8Jh2QROZdkE1mXZBWJl2QXuZdkGdmXZBwJl2QeOZdkEGmnZBKJp2QUuadkFumnZBkJp2QbOadkHWmnZB+Jp2QRubdkE+m3ZBYJt2QYObdkGmm3ZByJt2QeubdkEOnHZBMJx2QVOcdkF2nHZBmJx2QbucdkHenHZBAJ12QSOddkFGnXZBaJ12QYuddkGunXZB0J12QfOddkEWnnZBOJ52QVuedkF+nnZBoJ52QcOedkHmnnZBCJ92QSufdkFOn3ZBcJ92QZOfdkG2n3ZB2J92QfufdkEdoHZBQKB2QWOgdkGFoHZBqKB2QcugdkHtoHZBEKF2QTOhdkFVoXZBeKF2QZuhdkG9oXZB4KF2QQKidkElonZBSKJ2QWqidkGNonZBsKJ2QdKidkH1onZBGKN2QTqjdkFdo3ZBf6N2QaKjdkHFo3ZB56N2QQqkdkEtpHZBT6R2QXKkdkGUpHZBt6R2QdqkdkH8pHZBH6V2QUGldkFkpXZBh6V2QamldkHMpXZB76V2QRGmdkE0pnZBVqZ2QXmmdkGcpnZBvqZ2QeGmdkEDp3ZBJqd2QUmndkFrp3ZBjqd2QbCndkHTp3ZB9qd2QRiodkE7qHZBXah2QYCodkGjqHZBxah2QeiodkEKqXZBLal2QVCpdkFyqXZBlal2QbepdkHaqXZB/al2QR+qdkFCqnZBZKp2QYeqdkGqqnZBzKp2Qe+qdkERq3ZBNKt2QVardkF5q3ZBnKt2Qb6rdkHhq3ZBA6x2QSasdkFJrHZBa6x2QY6sdkGwrHZB06x2QfWsdkEYrXZBO612QV2tdkGArXZBoq12QcWtdkHnrXZBCq52QS2udkFPrnZBcq52QZSudkG3rnZB2a52QfyudkEer3ZBQa92QWSvdkGGr3ZBqa92QcuvdkHur3ZBELB2QTOwdkFVsHZBeLB2QZuwdkG9sHZB4LB2QQKxdkElsXZBR7F2QWqxdkGMsXZBr7F2QdGxdkH0sXZBF7J2QTmydkFcsnZBfrJ2QaGydkHDsnZB5rJ2QQizdkErs3ZBTbN2QXCzdkGSs3ZBtbN2QdizdkH6s3ZBHbR2QT+0dkFitHZBhLR2Qae0dkHJtHZB7LR2QQ61dkExtXZBU7V2QXa1dkGYtXZBu7V2Qd21dkEAtnZBIrZ2QUW2dkFotnZBirZ2Qa22dkHPtnZB8rZ2QRS3dkE3t3ZBWbd2QXy3dkGet3ZBwbd2QeO3dkEGuHZBKLh2QUu4dkFtuHZBkLh2QbK4dkHVuHZB97h2QRq5dkE8uXZBX7l2QYG5dkGkuXZBxrl2Qem5dkELunZBLrp2QVC6dkFzunZBlbp2Qbi6dkHaunZB/bp2QR+7dkFCu3ZBZLt2QYe7dkGpu3ZBzLt2Qe67dkERvHZBM7x2QVW8dkF4vHZBmrx2Qb28dkHfvHZBAr12QSS9dkFHvXZBab12QYy9dkGuvXZB0b12QfO9dkEWvnZBOL52QVu+dkF9vnZBoL52QcK+dkHlvnZBB792QSm/dkFMv3ZBbr92QZG/dkGzv3ZB1r92Qfi/dkEbwHZBPcB2QWDAdkGCwHZBpcB2QcfAdkHpwHZBDMF2QS7BdkFRwXZBc8F2QZbBdkG4wXZB28F2Qf3BdkEgwnZBQsJ2QWTCdkGHwnZBqcJ2QczCdkHuwnZBEcN2QTPDdkFWw3ZBeMN2QZrDdkG9w3ZB38N2QQLEdkEkxHZBR8R2QWnEdkGLxHZBrsR2QdDEdkHzxHZBFcV2QTjFdkFaxXZBfMV2QZ/FdkHBxXZB5MV2QQbGdkEpxnZBS8Z2QW3GdkGQxnZBssZ2QdXGdkH3xnZBGsd2QTzHdkFex3ZBgcd2QaPHdkHGx3ZB6Md2QQrIdkEtyHZBT8h2QXLIdkGUyHZBt8h2QdnIdkH7yHZBHsl2QUDJdkFjyXZBhcl2QafJdkHKyXZB7Ml2QQ/KdkExynZBU8p2QXbKdkGYynZBu8p2Qd3KdkH/ynZBIst2QUTLdkFny3ZBict2QavLdkHOy3ZB8Mt2QRPMdkE1zHZBV8x2QXrMdkGczHZBv8x2QeHMdkEDzXZBJs12QUjNdkFqzXZBjc12Qa/NdkHSzXZB9M12QRbOdkE5znZBW852QX3OdkGgznZBws52QeXOdkEHz3ZBKc92QUzPdkFuz3ZBkM92QbPPdkHVz3ZB+M92QRrQdkE80HZBX9B2QYHQdkGj0HZBxtB2QejQdkEK0XZBLdF2QU/RdkFy0XZBlNF2QbbRdkHZ0XZB+9F2QR3SdkFA0nZBYtJ2QYTSdkGn0nZBydJ2QevSdkEO03ZBMNN2QVPTdkF103ZBl9N2QbrTdkHc03ZB/tN2QSHUdkFD1HZBZdR2QYjUdkGq1HZBzNR2Qe/UdkER1XZBM9V2QVbVdkF41XZBmtV2Qb3VdkHf1XZBAdZ2QSTWdkFG1nZBaNZ2QYvWdkGt1nZBz9Z2QfLWdkEU13ZBNtd2QVnXdkF713ZBndd2QcDXdkHi13ZBBNh2QSfYdkFJ2HZBa9h2QY7YdkGw2HZB0th2QfTYdkEX2XZBOdl2QVvZdkF+2XZBoNl2QcLZdkHl2XZBB9p2QSnadkFM2nZBbtp2QZDadkGz2nZB1dp2QffadkEZ23ZBPNt2QV7bdkGA23ZBo9t2QcXbdkHn23ZBCtx2QSzcdkFO3HZBcNx2QZPcdkG13HZB19x2QfrcdkEc3XZBPt12QWDddkGD3XZBpd12QcfddkHq3XZBDN52QS7edkFQ3nZBc952QZXedkG33nZB2t52QfzedkEe33ZBQN92QWPfdkGF33ZBp992QcrfdkHs33ZBDuB2QTDgdkFT4HZBdeB2QZfgdkG54HZB3OB2Qf7gdkEg4XZBQ+F2QWXhdkGH4XZBqeF2QczhdkHu4XZBEOJ2QTLidkFV4nZBd+J2QZnidkG74nZB3uJ2QQDjdkEi43ZBRON2QWfjdkGJ43ZBq+N2Qc3jdkHw43ZBEuR2QTTkdkFW5HZBeeR2QZvkdkG95HZB3+R2QQLldkEk5XZBRuV2QWjldkGL5XZBreV2Qc/ldkHx5XZBFOZ2QTbmdkFY5nZBeuZ2QZ3mdkG/5nZB4eZ2QQPndkEm53ZBSOd2QWrndkGM53ZBrud2QdHndkHz53ZBFeh2QTfodkFa6HZBfOh2QZ7odkHA6HZB4+h2QQXpdkEn6XZBSel2QWvpdkGO6XZBsOl2QdLpdkH06XZBF+p2QTnqdkFb6nZBfep2QZ/qdkHC6nZB5Op2QQbrdkEo63ZBSut2QW3rdkGP63ZBset2QdPrdkH163ZBGOx2QTrsdkFc7HZBfux2QaDsdkHD7HZB5ex2QQftdkEp7XZBS+12QW7tdkGQ7XZBsu12QdTtdkH27XZBGe52QTvudkFd7nZBf+52QaHudkHE7nZB5u52QQjvdkEq73ZBTO92QW/vdkGR73ZBs+92QdXvdkH373ZBGfB2QTzwdkFe8HZBgPB2QaLwdkHE8HZB5/B2QQnxdkEr8XZBTfF2QW/xdkGR8XZBtPF2QdbxdkH48XZBGvJ2QTzydkFe8nZBgfJ2QaPydkHF8nZB5/J2QQnzdkEr83ZBTvN2QXDzdkGS83ZBtPN2QdbzdkH483ZBG/R2QT30dkFf9HZBgfR2QaP0dkHF9HZB6PR2QQr1dkEs9XZBTvV2QXD1dkGS9XZBtPV2Qdf1dkH59XZBG/Z2QT32dkFf9nZBgfZ2QaP2dkHG9nZB6PZ2QQr3dkEs93ZBTvd2QXD3dkGS93ZBtfd2Qdf3dkH593ZBG/h2QT34dkFf+HZBgfh2QaT4dkHG+HZB6Ph2QQr5dkEs+XZBTvl2QXD5dkGS+XZBtfl2Qdf5dkH5+XZBG/p2QT36dkFf+nZBgfp2QaP6dkHG+nZB6Pp2QQr7dkEs+3ZBTvt2QXD7dkGS+3ZBtPt2Qdb7dkH5+3ZBG/x2QT38dkFf/HZBgfx2QaP8dkHF/HZB5/x2QQn9dkEs/XZBTv12QXD9dkGS/XZBtP12Qdb9dkH4/XZBGv52QTz+dkFe/nZBgf52QaP+dkHF/nZB5/52QQn/dkEr/3ZBTf92QW//dkGR/3ZBs/92Qdb/dkH4/3ZBGgB3QTwAd0FeAHdBgAB3QaIAd0HEAHdB5gB3QQgBd0EqAXdBTAF3QW8Bd0GRAXdBswF3QdUBd0H3AXdBGQJ3QTsCd0FdAndBfwJ3QaECd0HDAndB5QJ3QQcDd0EqA3dBTAN3QW4Dd0GQA3dBsgN3QdQDd0H2A3dBGAR3QToEd0FcBHdBfgR3QaAEd0HCBHdB5AR3QQYFd0EpBXdBSwV3QW0Fd0GPBXdBsQV3QdMFd0H1BXdBFwZ3QTkGd0FbBndBfQZ3QZ8Gd0HBBndB4wZ3QQUHd0EnB3dBSQd3QWsHd0GOB3dBsAd3QdIHd0H0B3dBFgh3QTgId0FaCHdBfAh3QZ4Id0HACHdB4gh3QQQJd0EmCXdBSAl3QWoJd0GMCXdBrgl3QdAJd0HyCXdBFAp3QTYKd0FYCndBegp3QZwKd0G+CndB4Ap3QQILd0EkC3dBRgt3QWkLd0GLC3dBrQt3Qc8Ld0HxC3dBEwx3QTUMd0FXDHdBeQx3QZsMd0G9DHdB3wx3QQENd0EjDXdBRQ13QWcNd0GJDXdBqw13Qc0Nd0HvDXdBEQ53QTMOd0FVDndBdw53QZkOd0G7DndB3Q53Qf8Od0EhD3dBQw93QWUPd0GHD3dBqQ93QcsPd0HtD3dBDxB3QTEQd0FTEHdBdRB3QZcQd0G5EHdB2xB3Qf0Qd0EfEXdBQRF3QWMRd0GFEXdBpxF3QckRd0HrEXdBDRJ3QS8Sd0FREndBcxJ3QZUSd0G3EndB2RJ3QfsSd0EdE3dBPxN3QWETd0GDE3dBpRN3QccTd0HoE3dBChR3QSwUd0FOFHdBcBR3QZIUd0G0FHdB1hR3QfgUd0EaFXdBPBV3QV4Vd0GAFXdBohV3QcQVd0HmFXdBCBZ3QSoWd0FMFndBbhZ3QZAWd0GyFndB1BZ3QfYWd0EYF3dBOhd3QVwXd0F+F3dBnxd3QcEXd0HjF3dBBRh3QScYd0FJGHdBaxh3QY0Yd0GvGHdB0Rh3QfMYd0EVGXdBNxl3QVkZd0F7GXdBnRl3Qb8Zd0HhGXdBAxp3QSQad0FGGndBaBp3QYoad0GsGndBzhp3QfAad0ESG3dBNBt3QVYbd0F4G3dBmht3Qbwbd0HeG3dBABx3QSEcd0FDHHdBZRx3QYccd0GpHHdByxx3Qe0cd0EPHXdBMR13QVMdd0F1HXdBlx13Qbkdd0HaHXdB/B13QR4ed0FAHndBYh53QYQed0GmHndByB53Qeoed0EMH3dBLh93QVAfd0FxH3dBkx93QbUfd0HXH3dB+R93QRsgd0E9IHdBXyB3QYEgd0GjIHdBxCB3QeYgd0EIIXdBKiF3QUwhd0FuIXdBkCF3QbIhd0HUIXdB9iF3QRcid0E5IndBWyJ3QX0id0GfIndBwSJ3QeMid0EFI3dBJyN3QUgjd0FqI3dBjCN3Qa4jd0HQI3dB8iN3QRQkd0E2JHdBWCR3QXkkd0GbJHdBvSR3Qd8kd0EBJXdBIyV3QUUld0FnJXdBiCV3Qaold0HMJXdB7iV3QRAmd0EyJndBVCZ3QXYmd0GXJndBuSZ3Qdsmd0H9JndBHyd3QUEnd0FjJ3dBhCd3QaYnd0HIJ3dB6id3QQwod0EuKHdBUCh3QXEod0GTKHdBtSh3Qdcod0H5KHdBGyl3QT0pd0FeKXdBgCl3QaIpd0HEKXdB5il3QQgqd0EqKndBSyp3QW0qd0GPKndBsSp3QdMqd0H1KndBFit3QTgrd0FaK3dBfCt3QZ4rd0HAK3dB4it3QQMsd0ElLHdBRyx3QWksd0GLLHdBrSx3Qc4sd0HwLHdBEi13QTQtd0FWLXdBeC13QZktd0G7LXdB3S13Qf8td0EhLndBQi53QWQud0GGLndBqC53Qcoud0HsLndBDS93QS8vd0FRL3dBcy93QZUvd0G2L3dB2C93Qfovd0EcMHdBPjB3QWAwd0GBMHdBozB3QcUwd0HnMHdBCTF3QSoxd0FMMXdBbjF3QZAxd0GyMXdB0zF3QfUxd0EXMndBOTJ3QVsyd0F8MndBnjJ3QcAyd0HiMndBBDN3QSUzd0FHM3dBaTN3QYszd0GtM3dBzjN3QfAzd0ESNHdBNDR3QVY0d0F3NHdBmTR3Qbs0d0HdNHdB/zR3QSA1d0FCNXdBZDV3QYY1d0GnNXdByTV3Qes1d0ENNndBLzZ3QVA2d0FyNndBlDZ3QbY2d0HXNndB+TZ3QRs3d0E9N3dBXzd3QYA3d0GiN3dBxDd3QeY3d0EHOHdBKTh3QUs4d0FtOHdBjjh3QbA4d0HSOHdB9Dh3QRU5d0E3OXdBWTl3QXs5d0GdOXdBvjl3QeA5d0ECOndBJDp3QUU6d0FnOndBiTp3Qas6d0HMOndB7jp3QRA7d0EyO3dBUzt3QXU7d0GXO3dBuTt3Qdo7d0H8O3dBHjx3QUA8d0FhPHdBgzx3QaU8d0HHPHdB6Dx3QQo9d0EsPXdBTT13QW89d0GRPXdBsz13QdQ9d0H2PXdBGD53QTo+d0FbPndBfT53QZ8+d0HBPndB4j53QQQ/d0EmP3dBRz93QWk/d0GLP3dBrT93Qc4/d0HwP3dBEkB3QTRAd0FVQHdBd0B3QZlAd0G6QHdB3EB3Qf5Ad0EgQXdBQUF3QWNBd0GFQXdBpkF3QchBd0HqQXdBDEJ3QS1Cd0FPQndBcUJ3QZJCd0G0QndB1kJ3QfhCd0EZQ3dBO0N3QV1Dd0F+Q3dBoEN3QcJDd0HjQ3dBBUR3QSdEd0FJRHdBakR3QYxEd0GuRHdBz0R3QfFEd0ETRXdBNEV3QVZFd0F4RXdBmUV3QbtFd0HdRXdB/0V3QSBGd0FCRndBZEZ3QYVGd0GnRndByUZ3QepGd0EMR3dBLkd3QU9Hd0FxR3dBk0d3QbRHd0HWR3dB+Ed3QRlId0E7SHdBXUh3QX9Id0GgSHdBwkh3QeRId0EFSXdBJ0l3QUlJd0FqSXdBjEl3Qa5Jd0HPSXdB8Ul3QRNKd0E0SndBVkp3QXhKd0GZSndBu0p3Qd1Kd0H+SndBIEt3QUFLd0FjS3dBhUt3QaZLd0HIS3dB6kt3QQtMd0EtTHdBT0x3QXBMd0GSTHdBtEx3QdVMd0H3THdBGU13QTpNd0FcTXdBfk13QZ9Nd0HBTXdB4013QQROd0EmTndBR053QWlOd0GLTndBrE53Qc5Od0HwTndBEU93QTNPd0FVT3dBdk93QZhPd0G5T3dB2093Qf1Pd0EeUHdBQFB3QWJQd0GDUHdBpVB3QcZQd0HoUHdBClF3QStRd0FNUXdBb1F3QZBRd0GyUXdB01F3QfVRd0EXUndBOFJ3QVpSd0F8UndBnVJ3Qb9Sd0HgUndBAlN3QSRTd0FFU3dBZ1N3QYhTd0GqU3dBzFN3Qe1Td0EPVHdBMVR3QVJUd0F0VHdBlVR3QbdUd0HZVHdB+lR3QRxVd0E9VXdBX1V3QYFVd0GiVXdBxFV3QeVVd0EHVndBKVZ3QUpWd0FsVndBjVZ3Qa9Wd0HRVndB8lZ3QRRXd0E1V3dBV1d3QXhXd0GaV3dBvFd3Qd1Xd0H/V3dBIFh3QUJYd0FkWHdBhVh3QadYd0HIWHdB6lh3QQxZd0EtWXdBT1l3QXBZd0GSWXdBs1l3QdVZd0H3WXdBGFp3QTpad0FbWndBfVp3QZ5ad0HAWndB4lp3QQNbd0ElW3dBRlt3QWhbd0GJW3dBq1t3Qc1bd0HuW3dBEFx3QTFcd0FTXHdBdFx3QZZcd0G3XHdB2Vx3Qftcd0EcXXdBPl13QV9dd0GBXXdBol13QcRdd0HlXXdBB153QSled0FKXndBbF53QY1ed0GvXndB0F53QfJed0ETX3dBNV93QVZfd0F4X3dBml93Qbtfd0HdX3dB/l93QSBgd0FBYHdBY2B3QYRgd0GmYHdBx2B3Qelgd0EKYXdBLGF3QU5hd0FvYXdBkWF3QbJhd0HUYXdB9WF3QRdid0E4YndBWmJ3QXtid0GdYndBvmJ3QeBid0EBY3dBI2N3QURjd0FmY3dBiGN3Qaljd0HLY3dB7GN3QQ5kd0EvZHdBUWR3QXJkd0GUZHdBtWR3Qddkd0H4ZHdBGmV3QTtld0FdZXdBfmV3QaBld0HBZXdB42V3QQRmd0EmZndBR2Z3QWlmd0GKZndBrGZ3Qc1md0HvZndBEGd3QTJnd0FTZ3dBdWd3QZZnd0G4Z3dB2Wd3Qftnd0EcaHdBPmh3QV9od0GBaHdBomh3QcRod0HlaHdBB2l3QShpd0FKaXdBa2l3QY1pd0GuaXdB0Gl3QfFpd0ETandBNGp3QVZqd0F3andBmWp3Qbpqd0HbandB/Wp3QR5rd0FAa3dBYWt3QYNrd0Gka3dBxmt3Qedrd0EJbHdBKmx3QUxsd0FtbHdBj2x3QbBsd0HSbHdB82x3QRVtd0E2bXdBV213QXltd0GabXdBvG13Qd1td0H/bXdBIG53QUJud0FjbndBhW53QaZud0HIbndB6W53QQpvd0Esb3dBTW93QW9vd0GQb3dBsm93QdNvd0H1b3dBFnB3QThwd0FZcHdBenB3QZxwd0G9cHdB33B3QQBxd0EicXdBQ3F3QWVxd0GGcXdBp3F3Qclxd0HqcXdBDHJ3QS1yd0FPcndBcHJ3QZFyd0GzcndB1HJ3QfZyd0EXc3dBOXN3QVpzd0F7c3dBnXN3Qb5zd0Hgc3dBAXR3QSN0d0FEdHdBZXR3QYd0d0GodHdBynR3Qet0d0ENdXdBLnV3QU91d0FxdXdBknV3QbR1d0HVdXdB93V3QRh2d0E5dndBW3Z3QXx2d0GedndBv3Z3QeB2d0ECd3dBI3d3QUV3d0Fmd3dBh3d3Qal3d0HKd3dB7Hd3QQ14d0EueHdBUHh3QXF4d0GTeHdBtHh3QdV4d0H3eHdBGHl3QTp5d0FbeXdBfHl3QZ55d0G/eXdB4Xl3QQJ6d0EjendBRXp3QWZ6d0GIendBqXp3Qcp6d0HsendBDXt3QS97d0FQe3dBcXt3QZN7d0G0e3dB1Xt3Qfd7d0EYfHdBOnx3QVt8d0F8fHdBnnx3Qb98d0HhfHdBAn13QSN9d0FFfXdBZn13QYd9d0GpfXdByn13Qex9d0ENfndBLn53QVB+d0FxfndBkn53QbR+d0HVfndB9n53QRh/d0E5f3dBW393QXx/d0Gdf3dBv393QeB/d0EBgHdBI4B3QUSAd0FlgHdBh4B3QaiAd0HKgHdB64B3QQyBd0EugXdBT4F3QXCBd0GSgXdBs4F3QdSBd0H2gXdBF4J3QTiCd0FagndBe4J3QZyCd0G+gndB34J3QQCDd0Eig3dBQ4N3QWSDd0GGg3dBp4N3QciDd0Hqg3dBC4R3QSyEd0FOhHdBb4R3QZCEd0GyhHdB04R3QfSEd0EWhXdBN4V3QViFd0F6hXdBm4V3QbyFd0HehXdB/4V3QSCGd0FChndBY4Z3QYSGd0GmhndBx4Z3QeiGd0EKh3dBK4d3QUyHd0Fuh3dBj4d3QbCHd0HSh3dB84d3QRSId0E2iHdBV4h3QXiId0GZiHdBu4h3QdyId0H9iHdBH4l3QUCJd0FhiXdBg4l3QaSJd0HFiXdB54l3QQiKd0EpindBSop3QWyKd0GNindBrop3QdCKd0HxindBEot3QTSLd0FVi3dBdot3QZeLd0G5i3dB2ot3QfuLd0EdjHdBPox3QV+Md0GAjHdBoox3QcOMd0HkjHdBBo13QSeNd0FIjXdBaY13QYuNd0GsjXdBzY13Qe+Nd0EQjndBMY53QVKOd0F0jndBlY53QbaOd0HYjndB+Y53QRqPd0E7j3dBXY93QX6Pd0Gfj3dBwI93QeKPd0EDkHdBJJB3QUaQd0FnkHdBiJB3QamQd0HLkHdB7JB3QQ2Rd0EukXdBUJF3QXGRd0GSkXdBs5F3QdWRd0H2kXdBF5J3QTiSd0FakndBe5J3QZySd0G9kndB35J3QQCTd0Ehk3dBQpN3QWSTd0GFk3dBppN3QceTd0Hpk3dBCpR3QSuUd0FMlHdBbpR3QY+Ud0GwlHdB0ZR3QfOUd0EUlXdBNZV3QVaVd0F4lXdBmZV3QbqVd0HblXdB/ZV3QR6Wd0E/lndBYJZ3QYKWd0GjlndBxJZ3QeWWd0EGl3dBKJd3QUmXd0Fql3dBi5d3Qa2Xd0HOl3dB75d3QRCYd0ExmHdBU5h3QXSYd0GVmHdBtph3QdiYd0H5mHdBGpl3QTuZd0FcmXdBfpl3QZ+Zd0HAmXdB4Zl3QQOad0EkmndBRZp3QWaad0GHmndBqZp3Qcqad0HrmndBDJt3QS2bd0FPm3dBcJt3QZGbd0Gym3dB05t3QfWbd0EWnHdBN5x3QVicd0F5nHdBm5x3Qbycd0HdnHdB/px3QR+dd0FBnXdBYp13QYOdd0GknXdBxZ13Qeedd0EInndBKZ53QUqed0FrnndBjZ53Qa6ed0HPnndB8J53QRGfd0Eyn3dBVJ93QXWfd0GWn3dBt593Qdifd0H6n3dBG6B3QTygd0FdoHdBfqB3QZ+gd0HBoHdB4qB3QQOhd0EkoXdBRaF3QWahd0GIoXdBqaF3Qcqhd0HroXdBDKJ3QS6id0FPondBcKJ3QZGid0GyondB06J3QfSid0EWo3dBN6N3QVijd0F5o3dBmqN3Qbujd0Hdo3dB/qN3QR+kd0FApHdBYaR3QYKkd0GkpHdBxaR3Qeakd0EHpXdBKKV3QUmld0FqpXdBjKV3Qa2ld0HOpXdB76V3QRCmd0ExpndBUqZ3QXSmd0GVpndBtqZ3Qdemd0H4pndBGad3QTqnd0Fcp3dBfad3QZ6nd0G/p3dB4Kd3QQGod0EiqHdBRKh3QWWod0GGqHdBp6h3Qciod0HpqHdBCql3QSupd0FNqXdBbql3QY+pd0GwqXdB0al3QfKpd0ETqndBNKp3QVaqd0F3qndBmKp3Qbmqd0HaqndB+6p3QRyrd0E9q3dBX6t3QYCrd0Ghq3dBwqt3QeOrd0EErHdBJax3QUasd0FnrHdBiax3Qaqsd0HLrHdB7Kx3QQ2td0EurXdBT613QXCtd0GRrXdBsq13QdStd0H1rXdBFq53QTeud0FYrndBea53QZqud0G7rndB3K53Qf2ud0Efr3dBQK93QWGvd0GCr3dBo693QcSvd0Hlr3dBBrB3QSewd0FIsHdBabB3QYuwd0GssHdBzbB3Qe6wd0EPsXdBMLF3QVGxd0FysXdBk7F3QbSxd0HVsXdB9rF3QRiyd0E5sndBWrJ3QXuyd0GcsndBvbJ3Qd6yd0H/sndBILN3QUGzd0Fis3dBg7N3QaSzd0HFs3dB57N3QQi0d0EptHdBSrR3QWu0d0GMtHdBrbR3Qc60d0HvtHdBELV3QTG1d0FStXdBc7V3QZS1d0G1tXdB1rV3Qfi1d0EZtndBOrZ3QVu2d0F8tndBnbZ3Qb62d0HftndBALd3QSG3d0FCt3dBY7d3QYS3d0Glt3dBxrd3Qee3d0EIuHdBKbh3QUq4d0FruHdBjbh3Qa64d0HPuHdB8Lh3QRG5d0EyuXdBU7l3QXS5d0GVuXdBtrl3Qde5d0H4uXdBGbp3QTq6d0FbundBfLp3QZ26d0G+undB37p3QQC7d0Ehu3dBQrt3QWO7d0GEu3dBpbt3Qca7d0Hnu3dBCLx3QSm8d0FKvHdBa7x3QYy8d0GtvHdBz7x3QfC8d0ERvXdBMr13QVO9d0F0vXdBlb13Qba9d0HXvXdB+L13QRm+d0E6vndBW753QXy+d0GdvndBvr53Qd++d0EAv3dBIb93QUK/d0Fjv3dBhL93QaW/d0HGv3dB5793QQjAd0EpwHdBSsB3QWvAd0GMwHdBrcB3Qc7Ad0HvwHdBEMF3QTHBd0FSwXdBc8F3QZTBd0G1wXdB1sF3QffBd0EYwndBOcJ3QVrCd0F7wndBnMJ3Qb3Cd0HewndB/8J3QSDDd0FAw3dBYcN3QYLDd0Gjw3dBxMN3QeXDd0EGxHdBJ8R3QUjEd0FpxHdBisR3QavEd0HMxHdB7cR3QQ7Fd0EvxXdBUMV3QXHFd0GSxXdBs8V3QdTFd0H1xXdBFsZ3QTfGd0FYxndBecZ3QZrGd0G7xndB3MZ3Qf3Gd0Eex3dBP8d3QWDHd0GBx3dBocd3QcLHd0Hjx3dBBMh3QSXId0FGyHdBZ8h3QYjId0GpyHdBysh3QevId0EMyXdBLcl3QU7Jd0FvyXdBkMl3QbHJd0HSyXdB88l3QRTKd0E0yndBVcp3QXbKd0GXyndBuMp3QdnKd0H6yndBG8t3QTzLd0Fdy3dBfst3QZ/Ld0HAy3dB4ct3QQLMd0EjzHdBQ8x3QWTMd0GFzHdBpsx3QcfMd0HozHdBCc13QSrNd0FLzXdBbM13QY3Nd0GuzXdBz813QfDNd0EQzndBMc53QVLOd0FzzndBlM53QbXOd0HWzndB9853QRjPd0E5z3dBWs93QXvPd0Gbz3dBvM93Qd3Pd0H+z3dBH9B3QUDQd0Fh0HdBgtB3QaPQd0HE0HdB5dB3QQXRd0Em0XdBR9F3QWjRd0GJ0XdBqtF3QcvRd0Hs0XdBDdJ3QS7Sd0FO0ndBb9J3QZDSd0Gx0ndB0tJ3QfPSd0EU03dBNdN3QVbTd0F303dBl9N3QbjTd0HZ03dB+tN3QRvUd0E81HdBXdR3QX7Ud0Ge1HdBv9R3QeDUd0EB1XdBItV3QUPVd0Fk1XdBhdV3QabVd0HG1XdB59V3QQjWd0Ep1ndBStZ3QWvWd0GM1ndBrdZ3Qc3Wd0Hu1ndBD9d3QTDXd0FR13dBctd3QZPXd0G013dB1Nd3QfXXd0EW2HdBN9h3QVjYd0F52HdBmth3QbrYd0Hb2HdB/Nh3QR3Zd0E+2XdBX9l3QYDZd0Gg2XdBwdl3QeLZd0ED2ndBJNp3QUXad0Fm2ndBhtp3Qafad0HI2ndB6dp3QQrbd0Er23dBTNt3QWzbd0GN23dBrtt3Qc/bd0Hw23dBEdx3QTHcd0FS3HdBc9x3QZTcd0G13HdB1tx3Qffcd0EX3XdBON13QVndd0F63XdBm913Qbzdd0Hc3XdB/d13QR7ed0E/3ndBYN53QYHed0Gh3ndBwt53QePed0EE33dBJd93QUXfd0Fm33dBh993Qajfd0HJ33dB6t93QQrgd0Er4HdBTOB3QW3gd0GO4HdBr+B3Qc/gd0Hw4HdBEeF3QTLhd0FT4XdBc+F3QZThd0G14XdB1uF3Qffhd0EX4ndBOOJ3QVnid0F64ndBm+J3Qbzid0Hc4ndB/eJ3QR7jd0E/43dBYON3QYDjd0Gh43dBwuN3QePjd0EE5HdBJOR3QUXkd0Fm5HdBh+R3Qajkd0HI5HdB6eR3QQrld0Er5XdBTOV3QWzld0GN5XdBruV3Qc/ld0Hv5XdBEOZ3QTHmd0FS5ndBc+Z3QZPmd0G05ndB1eZ3Qfbmd0EX53dBN+d3QVjnd0F553dBmud3Qbrnd0Hb53dB/Od3QR3od0E+6HdBXuh3QX/od0Gg6HdBweh3QeHod0EC6XdBI+l3QUTpd0Fl6XdBhel3Qabpd0HH6XdB6Ol3QQjqd0Ep6ndBSup3QWvqd0GL6ndBrOp3Qc3qd0Hu6ndBDut3QS/rd0FQ63dBcet3QZHrd0Gy63dB0+t3QfTrd0EV7HdBNex3QVbsd0F37HdBmOx3Qbjsd0HZ7HdB+ux3QRvtd0E77XdBXO13QX3td0Ge7XdBvu13Qd/td0EA7ndBIO53QUHud0Fi7ndBg+53QaPud0HE7ndB5e53QQbvd0Em73dBR+93QWjvd0GJ73dBqe93Qcrvd0Hr73dBDPB3QSzwd0FN8HdBbvB3QY7wd0Gv8HdB0PB3QfHwd0ER8XdBMvF3QVPxd0F08XdBlPF3QbXxd0HW8XdB9vF3QRfyd0E48ndBWfJ3QXnyd0Ga8ndBu/J3Qdzyd0H88ndBHfN3QT7zd0Fe83dBf/N3QaDzd0HB83dB4fN3QQL0d0Ej9HdBQ/R3QWT0d0GF9HdBpfR3Qcb0d0Hn9HdBCPV3QSj1d0FJ9XdBavV3QYr1d0Gr9XdBzPV3Qe31d0EN9ndBLvZ3QU/2d0Fv9ndBkPZ3QbH2d0HR9ndB8vZ3QRP3d0Ez93dBVPd3QXX3d0GW93dBtvd3Qdf3d0H493dBGPh3QTn4d0Fa+HdBevh3QZv4d0G8+HdB3Ph3Qf34d0Ee+XdBPvl3QV/5d0GA+XdBofl3QcH5d0Hi+XdBA/p3QSP6d0FE+ndBZfp3QYX6d0Gm+ndBx/p3Qef6d0EI+3dBKft3QUn7d0Fq+3dBi/t3Qav7d0HM+3dB7ft3QQ38d0Eu/HdBT/x3QW/8d0GQ/HdBsfx3QdH8d0Hy/HdBE/13QTP9d0FU/XdBdf13QZX9d0G2/XdB1/13Qff9d0EY/ndBOf53QVn+d0F6/ndBm/53Qbv+d0Hc/ndB/P53QR3/d0E+/3dBXv93QX//d0Gg/3dBwP93QeH/d0ECAHhBIgB4QUMAeEFkAHhBhAB4QaUAeEHFAHhB5gB4QQcBeEEnAXhBSAF4QWkBeEGJAXhBqgF4QcsBeEHrAXhBDAJ4QSwCeEFNAnhBbgJ4QY4CeEGvAnhB0AJ4QfACeEERA3hBMgN4QVIDeEFzA3hBkwN4QbQDeEHVA3hB9QN4QRYEeEE3BHhBVwR4QXgEeEGYBHhBuQR4QdoEeEH6BHhBGwV4QTsFeEFcBXhBfQV4QZ0FeEG+BXhB3wV4Qf8FeEEgBnhBQAZ4QWEGeEGCBnhBogZ4QcMGeEHjBnhBBAd4QSUHeEFFB3hBZgd4QYYHeEGnB3hByAd4QegHeEEJCHhBKQh4QUoIeEFrCHhBiwh4QawIeEHMCHhB7Qh4QQ4JeEEuCXhBTwl4QW8JeEGQCXhBsQl4QdEJeEHyCXhBEgp4QTMKeEFUCnhBdAp4QZUKeEG1CnhB1gp4QfYKeEEXC3hBOAt4QVgLeEF5C3hBmQt4QboLeEHbC3hB+wt4QRwMeEE8DHhBXQx4QX0MeEGeDHhBvwx4Qd8MeEEADXhBIA14QUENeEFhDXhBgg14QaMNeEHDDXhB5A14QQQOeEElDnhBRQ54QWYOeEGHDnhBpw54QcgOeEHoDnhBCQ94QSkPeEFKD3hBag94QYsPeEGsD3hBzA94Qe0PeEENEHhBLhB4QU4QeEFvEHhBjxB4QbAQeEHREHhB8RB4QRIReEEyEXhBUxF4QXMReEGUEXhBtBF4QdUReEH2EXhBFhJ4QTcSeEFXEnhBeBJ4QZgSeEG5EnhB2RJ4QfoSeEEaE3hBOxN4QVsTeEF8E3hBnRN4Qb0TeEHeE3hB/hN4QR8UeEE/FHhBYBR4QYAUeEGhFHhBwRR4QeIUeEECFXhBIxV4QUMVeEFkFXhBhRV4QaUVeEHGFXhB5hV4QQcWeEEnFnhBSBZ4QWgWeEGJFnhBqRZ4QcoWeEHqFnhBCxd4QSsXeEFMF3hBbBd4QY0XeEGtF3hBzhd4Qe4XeEEPGHhBLxh4QVAYeEFwGHhBkRh4QbEYeEHSGHhB8hh4QRMZeEEzGXhBVBl4QXQZeEGVGXhBtRl4QdYZeEH2GXhBFxp4QTcaeEFYGnhBeBp4QZkaeEG5GnhB2hp4QfoaeEEbG3hBOxt4QVwbeEF8G3hBnRt4Qb0beEHeG3hB/ht4QR8ceEE/HHhBYBx4QYAceEGhHHhBwRx4QeIceEECHXhBIx14QUMdeEFkHXhBhB14QaUdeEHFHXhB5h14QQYeeEEnHnhBRx54QWgeeEGIHnhBqR54QckeeEHqHnhBCh94QSofeEFLH3hBax94QYwfeEGsH3hBzR94Qe0feEEOIHhBLiB4QU8geEFvIHhBkCB4QbAgeEHRIHhB8SB4QREheEEyIXhBUiF4QXMheEGTIXhBtCF4QdQheEH1IXhBFSJ4QTYieEFWInhBdyJ4QZcieEG3InhB2CJ4QfgieEEZI3hBOSN4QVojeEF6I3hBmyN4QbsjeEHbI3hB/CN4QRwkeEE9JHhBXSR4QX4keEGeJHhBvyR4Qd8keEH/JHhBICV4QUAleEFhJXhBgSV4QaIleEHCJXhB4yV4QQMmeEEjJnhBRCZ4QWQmeEGFJnhBpSZ4QcYmeEHmJnhBBid4QScneEFHJ3hBaCd4QYgneEGpJ3hBySd4QekneEEKKHhBKih4QUsoeEFrKHhBjCh4QawoeEHMKHhB7Sh4QQ0peEEuKXhBTil4QW4peEGPKXhBryl4QdApeEHwKXhBESp4QTEqeEFRKnhBcip4QZIqeEGzKnhB0yp4QfMqeEEUK3hBNCt4QVUreEF1K3hBlSt4QbYreEHWK3hB9yt4QRcseEE3LHhBWCx4QXgseEGZLHhBuSx4QdkseEH6LHhBGi14QTsteEFbLXhBey14QZwteEG8LXhB3S14Qf0teEEdLnhBPi54QV4ueEF/LnhBny54Qb8ueEHgLnhBAC94QSAveEFBL3hBYS94QYIveEGiL3hBwi94QeMveEEDMHhBJDB4QUQweEFkMHhBhTB4QaUweEHFMHhB5jB4QQYxeEEnMXhBRzF4QWcxeEGIMXhBqDF4QcgxeEHpMXhBCTJ4QSoyeEFKMnhBajJ4QYsyeEGrMnhByzJ4QewyeEEMM3hBLDN4QU0zeEFtM3hBjjN4Qa4zeEHOM3hB7zN4QQ80eEEvNHhBUDR4QXA0eEGQNHhBsTR4QdE0eEHxNHhBEjV4QTI1eEFTNXhBczV4QZM1eEG0NXhB1DV4QfQ1eEEVNnhBNTZ4QVU2eEF2NnhBljZ4QbY2eEHXNnhB9zZ4QRc3eEE4N3hBWDd4QXg3eEGZN3hBuTd4Qdk3eEH6N3hBGjh4QTo4eEFbOHhBezh4QZs4eEG8OHhB3Dh4Qfw4eEEdOXhBPTl4QV05eEF+OXhBnjl4Qb45eEHfOXhB/zl4QR86eEFAOnhBYDp4QYA6eEGhOnhBwTp4QeE6eEECO3hBIjt4QUI7eEFjO3hBgzt4QaM7eEHEO3hB5Dt4QQQ8eEEkPHhBRTx4QWU8eEGFPHhBpjx4QcY8eEHmPHhBBz14QSc9eEFHPXhBaD14QYg9eEGoPXhByT14Qek9eEEJPnhBKT54QUo+eEFqPnhBij54Qas+eEHLPnhB6z54QQw/eEEsP3hBTD94QWw/eEGNP3hBrT94Qc0/eEHuP3hBDkB4QS5AeEFOQHhBb0B4QY9AeEGvQHhB0EB4QfBAeEEQQXhBMEF4QVFBeEFxQXhBkUF4QbJBeEHSQXhB8kF4QRJCeEEzQnhBU0J4QXNCeEGUQnhBtEJ4QdRCeEH0QnhBFUN4QTVDeEFVQ3hBdkN4QZZDeEG2Q3hB1kN4QfdDeEEXRHhBN0R4QVdEeEF4RHhBmER4QbhEeEHZRHhB+UR4QRlFeEE5RXhBWkV4QXpFeEGaRXhBukV4QdtFeEH7RXhBG0Z4QTtGeEFcRnhBfEZ4QZxGeEG8RnhB3UZ4Qf1GeEEdR3hBPUd4QV5HeEF+R3hBnkd4Qb5HeEHfR3hB/0d4QR9IeEE/SHhBYEh4QYBIeEGgSHhBwEh4QeFIeEEBSXhBIUl4QUFJeEFiSXhBgkl4QaJJeEHCSXhB40l4QQNKeEEjSnhBQ0p4QWRKeEGESnhBpEp4QcRKeEHlSnhBBUt4QSVLeEFFS3hBZUt4QYZLeEGmS3hBxkt4QeZLeEEHTHhBJ0x4QUdMeEFnTHhBh0x4QahMeEHITHhB6Ex4QQhNeEEpTXhBSU14QWlNeEGJTXhBqU14QcpNeEHqTXhBCk54QSpOeEFLTnhBa054QYtOeEGrTnhBy054QexOeEEMT3hBLE94QUxPeEFsT3hBjU94Qa1PeEHNT3hB7U94QQ1QeEEuUHhBTlB4QW5QeEGOUHhBr1B4Qc9QeEHvUHhBD1F4QS9ReEFQUXhBcFF4QZBReEGwUXhB0FF4QfBReEERUnhBMVJ4QVFSeEFxUnhBkVJ4QbJSeEHSUnhB8lJ4QRJTeEEyU3hBU1N4QXNTeEGTU3hBs1N4QdNTeEH0U3hBFFR4QTRUeEFUVHhBdFR4QZRUeEG1VHhB1VR4QfVUeEEVVXhBNVV4QVZVeEF2VXhBllV4QbZVeEHWVXhB9lV4QRdWeEE3VnhBV1Z4QXdWeEGXVnhBt1Z4QdhWeEH4VnhBGFd4QThXeEFYV3hBeFd4QZlXeEG5V3hB2Vd4QflXeEEZWHhBOVh4QVpYeEF6WHhBmlh4QbpYeEHaWHhB+lh4QRpZeEE7WXhBW1l4QXtZeEGbWXhBu1l4QdtZeEH8WXhBHFp4QTxaeEFcWnhBfFp4QZxaeEG8WnhB3Vp4Qf1aeEEdW3hBPVt4QV1beEF9W3hBnVt4Qb5beEHeW3hB/lt4QR5ceEE+XHhBXlx4QX5ceEGfXHhBv1x4Qd9ceEH/XHhBH114QT9deEFfXXhBgF14QaBdeEHAXXhB4F14QQBeeEEgXnhBQF54QWBeeEGBXnhBoV54QcFeeEHhXnhBAV94QSFfeEFBX3hBYV94QYJfeEGiX3hBwl94QeJfeEECYHhBImB4QUJgeEFiYHhBg2B4QaNgeEHDYHhB42B4QQNheEEjYXhBQ2F4QWNheEGDYXhBpGF4QcRheEHkYXhBBGJ4QSRieEFEYnhBZGJ4QYRieEGkYnhBxGJ4QeVieEEFY3hBJWN4QUVjeEFlY3hBhWN4QaVjeEHFY3hB5WN4QQVkeEEmZHhBRmR4QWZkeEGGZHhBpmR4QcZkeEHmZHhBBmV4QSZleEFGZXhBZmV4QYdleEGnZXhBx2V4QedleEEHZnhBJ2Z4QUdmeEFnZnhBh2Z4QadmeEHHZnhB6GZ4QQhneEEoZ3hBSGd4QWhneEGIZ3hBqGd4QchneEHoZ3hBCGh4QShoeEFIaHhBaGh4QYloeEGpaHhByWh4QeloeEEJaXhBKWl4QUlpeEFpaXhBiWl4QalpeEHJaXhB6Wl4QQlqeEEpanhBSWp4QWpqeEGKanhBqmp4QcpqeEHqanhBCmt4QSpreEFKa3hBamt4QYpreEGqa3hBymt4QepreEEKbHhBKmx4QUpseEFqbHhBimx4QatseEHLbHhB62x4QQtteEErbXhBS214QWtteEGLbXhBq214QctteEHrbXhBC254QStueEFLbnhBa254QYtueEGrbnhBy254QetueEELb3hBK294QUtveEFrb3hBi294QaxveEHMb3hB7G94QQxweEEscHhBTHB4QWxweEGMcHhBrHB4QcxweEHscHhBDHF4QSxxeEFMcXhBbHF4QYxxeEGscXhBzHF4QexxeEEMcnhBLHJ4QUxyeEFscnhBjHJ4QaxyeEHMcnhB7HJ4QQxzeEEsc3hBTHN4QWxzeEGMc3hBrHN4QcxzeEHsc3hBDHR4QSx0eEFMdHhBbHR4QYx0eEGsdHhBzHR4Qex0eEEMdXhBLHV4QUx1eEFsdXhBjHV4Qax1eEHMdXhB7HV4QQx2eEEsdnhBTHZ4QWx2eEGMdnhBrHZ4Qcx2eEHsdnhBDHd4QSx3eEFMd3hBbHd4QYx3eEGsd3hBzHd4Qex3eEEMeHhBLHh4QUx4eEFseHhBjHh4Qax4eEHMeHhB7Hh4QQx5eEEseXhBTHl4QWx5eEGMeXhBrHl4Qcx5eEHseXhBDHp4QSx6eEFMenhBbHp4QYx6eEGsenhBzHp4Qex6eEEMe3hBLHt4QUx7eEFse3hBjHt4Qax7eEHMe3hB7Ht4QQt8eEErfHhBS3x4QWt8eEGLfHhBq3x4Qct8eEHrfHhBC314QSt9eEFLfXhBa314QYt9eEGrfXhBy314Qet9eEELfnhBK354QUt+eEFrfnhBi354Qat+eEHLfnhB6354QQp/eEEqf3hBSn94QWp/eEGKf3hBqn94Qcp/eEHqf3hBCoB4QSqAeEFKgHhBaoB4QYqAeEGqgHhByoB4QeqAeEEKgXhBKoF4QUmBeEFpgXhBiYF4QamBeEHJgXhB6YF4QQmCeEEpgnhBSYJ4QWmCeEGJgnhBqYJ4QcmCeEHpgnhBCYN4QSiDeEFIg3hBaIN4QYiDeEGog3hByIN4QeiDeEEIhHhBKIR4QUiEeEFohHhBiIR4QaiEeEHHhHhB54R4QQeFeEEnhXhBR4V4QWeFeEGHhXhBp4V4QceFeEHnhXhBB4Z4QSeGeEFGhnhBZoZ4QYaGeEGmhnhBxoZ4QeaGeEEGh3hBJod4QUaHeEFmh3hBhod4QaWHeEHFh3hB5Yd4QQWIeEEliHhBRYh4QWWIeEGFiHhBpYh4QcWIeEHkiHhBBIl4QSSJeEFEiXhBZIl4QYSJeEGkiXhBxIl4QeSJeEEDinhBI4p4QUOKeEFjinhBg4p4QaOKeEHDinhB44p4QQOLeEEii3hBQot4QWKLeEGCi3hBoot4QcKLeEHii3hBAox4QSKMeEFBjHhBYYx4QYGMeEGhjHhBwYx4QeGMeEEBjXhBIY14QUCNeEFgjXhBgI14QaCNeEHAjXhB4I14QQCOeEEgjnhBP454QV+OeEF/jnhBn454Qb+OeEHfjnhB/454QR6PeEE+j3hBXo94QX6PeEGej3hBvo94Qd6PeEH9j3hBHZB4QT2QeEFdkHhBfZB4QZ2QeEG9kHhB3JB4QfyQeEEckXhBPJF4QVyReEF8kXhBnJF4QbuReEHbkXhB+5F4QRuSeEE7knhBW5J4QXuSeEGaknhBupJ4QdqSeEH6knhBGpN4QTqTeEFZk3hBeZN4QZmTeEG5k3hB2ZN4QfmTeEEYlHhBOJR4QViUeEF4lHhBmJR4QbiUeEHXlHhB95R4QReVeEE3lXhBV5V4QXeVeEGWlXhBtpV4QdaVeEH2lXhBFpZ4QTaWeEFVlnhBdZZ4QZWWeEG1lnhB1ZZ4QfWWeEEUl3hBNJd4QVSXeEF0l3hBlJd4QbOXeEHTl3hB85d4QROYeEEzmHhBU5h4QXKYeEGSmHhBsph4QdKYeEHymHhBEZl4QTGZeEFRmXhBcZl4QZGZeEGwmXhB0Jl4QfCZeEEQmnhBMJp4QU+aeEFvmnhBj5p4Qa+aeEHPmnhB7pp4QQ6beEEum3hBTpt4QW6beEGNm3hBrZt4Qc2beEHtm3hBDZx4QSyceEFMnHhBbJx4QYyceEGsnHhBy5x4QeuceEELnXhBK514QUudeEFqnXhBip14QaqdeEHKnXhB6Z14QQmeeEEpnnhBSZ54QWmeeEGInnhBqJ54QcieeEHonnhBB594QSefeEFHn3hBZ594QYefeEGmn3hBxp94QeafeEEGoHhBJaB4QUWgeEFloHhBhaB4QaWgeEHEoHhB5KB4QQSheEEkoXhBQ6F4QWOheEGDoXhBo6F4QcKheEHioXhBAqJ4QSKieEFBonhBYaJ4QYGieEGhonhBwaJ4QeCieEEAo3hBIKN4QUCjeEFfo3hBf6N4QZ+jeEG/o3hB3qN4Qf6jeEEepHhBPqR4QV2keEF9pHhBnaR4Qb2keEHcpHhB/KR4QRyleEE8pXhBW6V4QXuleEGbpXhBuqV4QdqleEH6pXhBGqZ4QTmmeEFZpnhBeaZ4QZmmeEG4pnhB2KZ4QfimeEEYp3hBN6d4QVeneEF3p3hBl6d4QbaneEHWp3hB9qd4QRWoeEE1qHhBVah4QXWoeEGUqHhBtKh4QdSoeEH0qHhBE6l4QTOpeEFTqXhBcql4QZKpeEGyqXhB0ql4QfGpeEERqnhBMap4QVCqeEFwqnhBkKp4QbCqeEHPqnhB76p4QQ+reEEuq3hBTqt4QW6reEGOq3hBrat4Qc2reEHtq3hBDKx4QSyseEFMrHhBbKx4QYuseEGrrHhBy6x4QeqseEEKrXhBKq14QUmteEFprXhBia14QamteEHIrXhB6K14QQiueEEnrnhBR654QWeueEGGrnhBpq54QcaueEHmrnhBBa94QSWveEFFr3hBZK94QYSveEGkr3hBw694QeOveEEDsHhBIrB4QUKweEFisHhBgrB4QaGweEHBsHhB4bB4QQCxeEEgsXhBQLF4QV+xeEF/sXhBn7F4Qb6xeEHesXhB/rF4QR2yeEE9snhBXbJ4QXyyeEGcsnhBvLJ4QduyeEH7snhBG7N4QTqzeEFas3hBerN4QZmzeEG5s3hB2bN4QfizeEEYtHhBOLR4QVe0eEF3tHhBl7R4Qba0eEHWtHhB9rR4QRW1eEE1tXhBVbV4QXS1eEGUtXhBtLV4QdO1eEHztXhBE7Z4QTK2eEFStnhBcrZ4QZG2eEGxtnhB0bZ4QfC2eEEQt3hBL7d4QU+3eEFvt3hBjrd4Qa63eEHOt3hB7bd4QQ24eEEtuHhBTLh4QWy4eEGMuHhBq7h4Qcu4eEHquHhBCrl4QSq5eEFJuXhBabl4QYm5eEGouXhByLl4Qei5eEEHunhBJ7p4QUa6eEFmunhBhrp4QaW6eEHFunhB5bp4QQS7eEEku3hBQ7t4QWO7eEGDu3hBort4QcK7eEHiu3hBAbx4QSG8eEFAvHhBYLx4QYC8eEGfvHhBv7x4Qd+8eEH+vHhBHr14QT29eEFdvXhBfb14QZy9eEG8vXhB2714Qfu9eEEbvnhBOr54QVq+eEF6vnhBmb54Qbm+eEHYvnhB+L54QRi/eEE3v3hBV794QXa/eEGWv3hBtr94QdW/eEH1v3hBFMB4QTTAeEFUwHhBc8B4QZPAeEGywHhB0sB4QfLAeEERwXhBMcF4QVDBeEFwwXhBkMF4Qa/BeEHPwXhB7sF4QQ7CeEEuwnhBTcJ4QW3CeEGMwnhBrMJ4QcvCeEHrwnhBC8N4QSrDeEFKw3hBacN4QYnDeEGpw3hByMN4QejDeEEHxHhBJ8R4QUbEeEFmxHhBhsR4QaXEeEHFxHhB5MR4QQTFeEEjxXhBQ8V4QWPFeEGCxXhBosV4QcHFeEHhxXhBAMZ4QSDGeEFAxnhBX8Z4QX/GeEGexnhBvsZ4Qd3GeEH9xnhBHcd4QTzHeEFcx3hBe8d4QZvHeEG6x3hB2sd4QfnHeEEZyHhBOch4QVjIeEF4yHhBl8h4QbfIeEHWyHhB9sh4QRXJeEE1yXhBVcl4QXTJeEGUyXhBs8l4QdPJeEHyyXhBEsp4QTHKeEFRynhBccp4QZDKeEGwynhBz8p4Qe/KeEEOy3hBLst4QU3LeEFty3hBjMt4QazLeEHLy3hB68t4QQvMeEEqzHhBSsx4QWnMeEGJzHhBqMx4QcjMeEHnzHhBB814QSbNeEFGzXhBZc14QYXNeEGkzXhBxM14QeTNeEEDznhBI854QULOeEFiznhBgc54QaHOeEHAznhB4M54Qf/OeEEfz3hBPs94QV7PeEF9z3hBnc94QbzPeEHcz3hB+894QRvQeEE60HhBWtB4QXnQeEGZ0HhBuNB4QdjQeEH30HhBF9F4QTbReEFW0XhBdtF4QZXReEG10XhB1NF4QfTReEET0nhBM9J4QVLSeEFy0nhBkdJ4QbHSeEHQ0nhB8NJ4QQ/TeEEv03hBTtN4QW7TeEGN03hBrdN4QczTeEHs03hBC9R4QSvUeEFK1HhBatR4QYnUeEGo1HhByNR4QefUeEEH1XhBJtV4QUbVeEFl1XhBhdV4QaTVeEHE1XhB49V4QQPWeEEi1nhBQtZ4QWHWeEGB1nhBoNZ4QcDWeEHf1nhB/9Z4QR7XeEE+13hBXdd4QX3XeEGc13hBvNd4QdvXeEH613hBGth4QTnYeEFZ2HhBeNh4QZjYeEG32HhB19h4QfbYeEEW2XhBNdl4QVXZeEF02XhBlNl4QbPZeEHT2XhB8tl4QRHaeEEx2nhBUNp4QXDaeEGP2nhBr9p4Qc7aeEHu2nhBDdt4QS3beEFM23hBa9t4QYvbeEGq23hBytt4QenbeEEJ3HhBKNx4QUjceEFn3HhBh9x4QabceEHF3HhB5dx4QQTdeEEk3XhBQ914QWPdeEGC3XhBot14QcHdeEHg3XhBAN54QR/eeEE/3nhBXt54QX7eeEGd3nhBvd54QdzeeEH73nhBG994QTrfeEFa33hBed94QZnfeEG433hB1994QfffeEEW4HhBNuB4QVXgeEF14HhBlOB4QbPgeEHT4HhB8uB4QRLheEEx4XhBUeF4QXDheEGP4XhBr+F4Qc7heEHu4XhBDeJ4QSzieEFM4nhBa+J4QYvieEGq4nhByuJ4QenieEEI43hBKON4QUfjeEFn43hBhuN4QaXjeEHF43hB5ON4QQTkeEEj5HhBQ+R4QWLkeEGB5HhBoeR4QcDkeEHg5HhB/+R4QR7leEE+5XhBXeV4QX3leEGc5XhBu+V4QdvleEH65XhBGuZ4QTnmeEFY5nhBeOZ4QZfmeEG35nhB1uZ4QfXmeEEV53hBNOd4QVTneEFz53hBkud4QbLneEHR53hB8Od4QRDoeEEv6HhBT+h4QW7oeEGN6HhBreh4QczoeEHs6HhBC+l4QSrpeEFK6XhBael4QYjpeEGo6XhBx+l4QefpeEEG6nhBJep4QUXqeEFk6nhBg+p4QaPqeEHC6nhB4up4QQHreEEg63hBQOt4QV/reEF+63hBnut4Qb3reEHd63hB/Ot4QRvseEE77HhBWux4QXnseEGZ7HhBuOx4QdfseEH37HhBFu14QTbteEFV7XhBdO14QZTteEGz7XhB0u14QfLteEER7nhBMO54QVDueEFv7nhBju54Qa7ueEHN7nhB7e54QQzveEEr73hBS+94QWrveEGJ73hBqe94QcjveEHn73hBB/B4QSbweEFF8HhBZfB4QYTweEGj8HhBw/B4QeLweEEB8XhBIfF4QUDxeEFf8XhBf/F4QZ7xeEG98XhB3fF4QfzxeEEb8nhBO/J4QVryeEF58nhBmfJ4QbjyeEHX8nhB9/J4QRbzeEE183hBVfN4QXTzeEGT83hBs/N4QdLzeEHx83hBEfR4QTD0eEFP9HhBb/R4QY70eEGt9HhBzfR4Qez0eEEL9XhBK/V4QUr1eEFp9XhBifV4Qaj1eEHH9XhB5vV4QQb2eEEl9nhBRPZ4QWT2eEGD9nhBovZ4QcL2eEHh9nhBAPd4QSD3eEE/93hBXvd4QX33eEGd93hBvPd4Qdv3eEH793hBGvh4QTn4eEFZ+HhBePh4QZf4eEG3+HhB1vh4QfX4eEEU+XhBNPl4QVP5eEFy+XhBkvl4QbH5eEHQ+XhB7/l4QQ/6eEEu+nhBTfp4QW36eEGM+nhBq/p4Qcr6eEHq+nhBCft4QSj7eEFI+3hBZ/t4QYb7eEGl+3hBxft4QeT7eEED/HhBI/x4QUL8eEFh/HhBgPx4QaD8eEG//HhB3vx4Qf78eEEd/XhBPP14QVv9eEF7/XhBmv14Qbn9eEHY/XhB+P14QRf+eEE2/nhBVv54QXX+eEGU/nhBs/54QdP+eEHy/nhBEf94QTD/eEFQ/3hBb/94QY7/eEGt/3hBzf94Qez/eEELAHlBKwB5QUoAeUFpAHlBiAB5QagAeUHHAHlB5gB5QQUBeUElAXlBRAF5QWMBeUGCAXlBogF5QcEBeUHgAXlB/wF5QR8CeUE+AnlBXQJ5QXwCeUGcAnlBuwJ5QdoCeUH5AnlBGQN5QTgDeUFXA3lBdgN5QZYDeUG1A3lB1AN5QfMDeUETBHlBMgR5QVEEeUFwBHlBjwR5Qa8EeUHOBHlB7QR5QQwFeUEsBXlBSwV5QWoFeUGJBXlBqQV5QcgFeUHnBXlBBgZ5QSUGeUFFBnlBZAZ5QYMGeUGiBnlBwgZ5QeEGeUEAB3lBHwd5QT8HeUFeB3lBfQd5QZwHeUG7B3lB2wd5QfoHeUEZCHlBOAh5QVcIeUF3CHlBlgh5QbUIeUHUCHlB9Ah5QRMJeUEyCXlBUQl5QXAJeUGQCXlBrwl5Qc4JeUHtCXlBDAp5QSwKeUFLCnlBagp5QYkKeUGoCnlByAp5QecKeUEGC3lBJQt5QUQLeUFkC3lBgwt5QaILeUHBC3lB4At5QQAMeUEfDHlBPgx5QV0MeUF8DHlBnAx5QbsMeUHaDHlB+Qx5QRgNeUE4DXlBVw15QXYNeUGVDXlBtA15QdQNeUHzDXlBEg55QTEOeUFQDnlBbw55QY8OeUGuDnlBzQ55QewOeUELD3lBKw95QUoPeUFpD3lBiA95QacPeUHGD3lB5g95QQUQeUEkEHlBQxB5QWIQeUGCEHlBoRB5QcAQeUHfEHlB/hB5QR0ReUE9EXlBXBF5QXsReUGaEXlBuRF5QdgReUH4EXlBFxJ5QTYSeUFVEnlBdBJ5QZMSeUGzEnlB0hJ5QfESeUEQE3lBLxN5QU4TeUFuE3lBjRN5QawTeUHLE3lB6hN5QQkUeUEoFHlBSBR5QWcUeUGGFHlBpRR5QcQUeUHjFHlBAxV5QSIVeUFBFXlBYBV5QX8VeUGeFXlBvRV5Qd0VeUH8FXlBGxZ5QToWeUFZFnlBeBZ5QZcWeUG3FnlB1hZ5QfUWeUEUF3lBMxd5QVIXeUFxF3lBkRd5QbAXeUHPF3lB7hd5QQ0YeUEsGHlBSxh5QWoYeUGKGHlBqRh5QcgYeUHnGHlBBhl5QSUZeUFEGXlBYxl5QYMZeUGiGXlBwRl5QeAZeUH/GXlBHhp5QT0aeUFcGnlBfBp5QZsaeUG6GnlB2Rp5QfgaeUEXG3lBNht5QVUbeUF1G3lBlBt5QbMbeUHSG3lB8Rt5QRAceUEvHHlBThx5QW0ceUGNHHlBrBx5QcsceUHqHHlBCR15QSgdeUFHHXlBZh15QYUdeUGlHXlBxB15QeMdeUECHnlBIR55QUAeeUFfHnlBfh55QZ0eeUG8HnlB3B55QfseeUEaH3lBOR95QVgfeUF3H3lBlh95QbUfeUHUH3lB8x95QRIgeUEyIHlBUSB5QXAgeUGPIHlBriB5Qc0geUHsIHlBCyF5QSoheUFJIXlBaCF5QYgheUGnIXlBxiF5QeUheUEEInlBIyJ5QUIieUFhInlBgCJ5QZ8ieUG+InlB3SJ5QfwieUEcI3lBOyN5QVojeUF5I3lBmCN5QbcjeUHWI3lB9SN5QRQkeUEzJHlBUiR5QXEkeUGQJHlBryR5Qc8keUHuJHlBDSV5QSwleUFLJXlBaiV5QYkleUGoJXlBxyV5QeYleUEFJnlBJCZ5QUMmeUFiJnlBgSZ5QaAmeUHAJnlB3yZ5Qf4meUEdJ3lBPCd5QVsneUF6J3lBmSd5QbgneUHXJ3lB9id5QRUoeUE0KHlBUyh5QXIoeUGRKHlBsCh5Qc8oeUHuKHlBDSl5QS0peUFMKXlBayl5QYopeUGpKXlByCl5QecpeUEGKnlBJSp5QUQqeUFjKnlBgip5QaEqeUHAKnlB3yp5Qf4qeUEdK3lBPCt5QVsreUF6K3lBmSt5QbgreUHXK3lB9it5QRUseUE0LHlBUyx5QXIseUGRLHlBsCx5QdAseUHvLHlBDi15QS0teUFMLXlBay15QYoteUGpLXlByC15QecteUEGLnlBJS55QUQueUFjLnlBgi55QaEueUHALnlB3y55Qf4ueUEdL3lBPC95QVsveUF6L3lBmS95QbgveUHXL3lB9i95QRUweUE0MHlBUzB5QXIweUGRMHlBsDB5Qc8weUHuMHlBDTF5QSwxeUFLMXlBajF5QYkxeUGoMXlBxzF5QeYxeUEFMnlBJDJ5QUMyeUFiMnlBgTJ5QaAyeUG/MnlB3jJ5Qf0yeUEcM3lBOzN5QVozeUF5M3lBmDN5QbczeUHWM3lB9TN5QRQ0eUEzNHlBUjR5QXE0eUGQNHlBrzR5Qc40eUHtNHlBDDV5QSs1eUFKNXlBaTV5QYg1eUGnNXlBxjV5QeU1eUEENnlBIzZ5QUE2eUFgNnlBfzZ5QZ42eUG9NnlB3DZ5Qfs2eUEaN3lBOTd5QVg3eUF3N3lBljd5QbU3eUHUN3lB8zd5QRI4eUExOHlBUDh5QW84eUGOOHlBrTh5Qcw4eUHrOHlBCjl5QSk5eUFIOXlBZzl5QYY5eUGlOXlBwzl5QeI5eUEBOnlBIDp5QT86eUFeOnlBfTp5QZw6eUG7OnlB2jp5Qfk6eUEYO3lBNzt5QVY7eUF1O3lBlDt5QbM7eUHSO3lB8Tt5QRA8eUEuPHlBTTx5QWw8eUGLPHlBqjx5Qck8eUHoPHlBBz15QSY9eUFFPXlBZD15QYM9eUGiPXlBwT15QeA9eUH/PXlBHT55QTw+eUFbPnlBej55QZk+eUG4PnlB1z55QfY+eUEVP3lBND95QVM/eUFyP3lBkT95QbA/eUHPP3lB7T95QQxAeUErQHlBSkB5QWlAeUGIQHlBp0B5QcZAeUHlQHlBBEF5QSNBeUFCQXlBYEF5QX9BeUGeQXlBvUF5QdxBeUH7QXlBGkJ5QTlCeUFYQnlBd0J5QZZCeUG1QnlB00J5QfJCeUERQ3lBMEN5QU9DeUFuQ3lBjUN5QaxDeUHLQ3lB6kN5QQhEeUEnRHlBRkR5QWVEeUGERHlBo0R5QcJEeUHhRHlBAEV5QR9FeUE9RXlBXEV5QXtFeUGaRXlBuUV5QdhFeUH3RXlBFkZ5QTVGeUFURnlBckZ5QZFGeUGwRnlBz0Z5Qe5GeUENR3lBLEd5QUtHeUFqR3lBiEd5QadHeUHGR3lB5Ud5QQRIeUEjSHlBQkh5QWFIeUF/SHlBnkh5Qb1IeUHcSHlB+0h5QRpJeUE5SXlBWEl5QXZJeUGVSXlBtEl5QdNJeUHySXlBEUp5QTBKeUFPSnlBbUp5QYxKeUGrSnlBykp5QelKeUEIS3lBJ0t5QUZLeUFkS3lBg0t5QaJLeUHBS3lB4Et5Qf9LeUEeTHlBPEx5QVtMeUF6THlBmUx5QbhMeUHXTHlB9kx5QRRNeUEzTXlBUk15QXFNeUGQTXlBr015Qc5NeUHsTXlBC055QSpOeUFJTnlBaE55QYdOeUGlTnlBxE55QeNOeUECT3lBIU95QUBPeUFfT3lBfU95QZxPeUG7T3lB2k95QflPeUEYUHlBNlB5QVVQeUF0UHlBk1B5QbJQeUHRUHlB71B5QQ5ReUEtUXlBTFF5QWtReUGKUXlBqFF5QcdReUHmUXlBBVJ5QSRSeUFDUnlBYVJ5QYBSeUGfUnlBvlJ5Qd1SeUH8UnlBGlN5QTlTeUFYU3lBd1N5QZZTeUG1U3lB01N5QfJTeUERVHlBMFR5QU9UeUFtVHlBjFR5QatUeUHKVHlB6VR5QQdVeUEmVXlBRVV5QWRVeUGDVXlBolV5QcBVeUHfVXlB/lV5QR1WeUE8VnlBWlZ5QXlWeUGYVnlBt1Z5QdZWeUH0VnlBE1d5QTJXeUFRV3lBcFd5QY5XeUGtV3lBzFd5QetXeUEKWHlBKFh5QUdYeUFmWHlBhVh5QaRYeUHCWHlB4Vh5QQBZeUEfWXlBPll5QVxZeUF7WXlBmll5QblZeUHYWXlB9ll5QRVaeUE0WnlBU1p5QXFaeUGQWnlBr1p5Qc5aeUHtWnlBC1t5QSpbeUFJW3lBaFt5QYdbeUGlW3lBxFt5QeNbeUECXHlBIFx5QT9ceUFeXHlBfVx5QZxceUG6XHlB2Vx5QfhceUEXXXlBNV15QVRdeUFzXXlBkl15QbBdeUHPXXlB7l15QQ1eeUEsXnlBSl55QWleeUGIXnlBp155QcVeeUHkXnlBA195QSJfeUFAX3lBX195QX5feUGdX3lBu195QdpfeUH5X3lBGGB5QTZgeUFVYHlBdGB5QZNgeUGxYHlB0GB5Qe9geUEOYXlBLGF5QUtheUFqYXlBiWF5QadheUHGYXlB5WF5QQRieUEiYnlBQWJ5QWBieUF/YnlBnWJ5QbxieUHbYnlB+mJ5QRhjeUE3Y3lBVmN5QXVjeUGTY3lBsmN5QdFjeUHwY3lBDmR5QS1keUFMZHlBa2R5QYlkeUGoZHlBx2R5QeVkeUEEZXlBI2V5QUJleUFgZXlBf2V5QZ5leUG9ZXlB22V5QfpleUEZZnlBN2Z5QVZmeUF1ZnlBlGZ5QbJmeUHRZnlB8GZ5QQ9neUEtZ3lBTGd5QWtneUGJZ3lBqGd5QcdneUHmZ3lBBGh5QSNoeUFCaHlBYGh5QX9oeUGeaHlBvWh5QdtoeUH6aHlBGWl5QTdpeUFWaXlBdWl5QZRpeUGyaXlB0Wl5QfBpeUEOanlBLWp5QUxqeUFqanlBiWp5QahqeUHHanlB5Wp5QQRreUEja3lBQWt5QWBreUF/a3lBnWt5QbxreUHba3lB+mt5QRhseUE3bHlBVmx5QXRseUGTbHlBsmx5QdBseUHvbHlBDm15QSxteUFLbXlBam15QYhteUGnbXlBxm15QeVteUEDbnlBIm55QUFueUFfbnlBfm55QZ1ueUG7bnlB2m55QflueUEXb3lBNm95QVVveUFzb3lBkm95QbFveUHPb3lB7m95QQ1weUErcHlBSnB5QWlweUGHcHlBpnB5QcVweUHjcHlBAnF5QSFxeUE/cXlBXnF5QX1xeUGbcXlBunF5QdlxeUH3cXlBFnJ5QTVyeUFTcnlBcnJ5QZFyeUGvcnlBznJ5Qe1yeUELc3lBKnN5QUlzeUFnc3lBhnN5QaVzeUHDc3lB4nN5QQF0eUEfdHlBPnR5QV10eUF7dHlBmnR5Qbl0eUHXdHlB9nR5QRR1eUEzdXlBUnV5QXB1eUGPdXlBrnV5Qcx1eUHrdXlBCnZ5QSh2eUFHdnlBZnZ5QYR2eUGjdnlBwXZ5QeB2eUH/dnlBHXd5QTx3eUFbd3lBeXd5QZh3eUG3d3lB1Xd5QfR3eUESeHlBMXh5QVB4eUFueHlBjXh5Qax4eUHKeHlB6Xh5QQh5eUEmeXlBRXl5QWN5eUGCeXlBoXl5Qb95eUHeeXlB/Xl5QRt6eUE6enlBWHp5QXd6eUGWenlBtHp5QdN6eUHxenlBEHt5QS97eUFNe3lBbHt5QYt7eUGpe3lByHt5QeZ7eUEFfHlBJHx5QUJ8eUFhfHlBf3x5QZ58eUG9fHlB23x5Qfp8eUEYfXlBN315QVZ9eUF0fXlBk315QbF9eUHQfXlB7315QQ1+eUEsfnlBSn55QWl+eUGIfnlBpn55QcV+eUHjfnlBAn95QSF/eUE/f3lBXn95QXx/eUGbf3lBun95Qdh/eUH3f3lBFYB5QTSAeUFTgHlBcYB5QZCAeUGugHlBzYB5QeyAeUEKgXlBKYF5QUeBeUFmgXlBhIF5QaOBeUHCgXlB4IF5Qf+BeUEdgnlBPIJ5QVuCeUF5gnlBmIJ5QbaCeUHVgnlB84J5QRKDeUExg3lBT4N5QW6DeUGMg3lBq4N5QcmDeUHog3lBB4R5QSWEeUFEhHlBYoR5QYGEeUGfhHlBvoR5Qd2EeUH7hHlBGoV5QTiFeUFXhXlBdYV5QZSFeUGyhXlB0YV5QfCFeUEOhnlBLYZ5QUuGeUFqhnlBiIZ5QaeGeUHFhnlB5IZ5QQOHeUEhh3lBQId5QV6HeUF9h3lBm4d5QbqHeUHYh3lB94d5QRaIeUE0iHlBU4h5QXGIeUGQiHlBroh5Qc2IeUHriHlBCol5QSiJeUFHiXlBZol5QYSJeUGjiXlBwYl5QeCJeUH+iXlBHYp5QTuKeUFainlBeIp5QZeKeUG1inlB1Ip5QfOKeUERi3lBMIt5QU6LeUFti3lBi4t5QaqLeUHIi3lB54t5QQWMeUEkjHlBQox5QWGMeUF/jHlBnox5Qb2MeUHbjHlB+ox5QRiNeUE3jXlBVY15QXSNeUGSjXlBsY15Qc+NeUHujXlBDI55QSuOeUFJjnlBaI55QYaOeUGljnlBw455QeKOeUEAj3lBH495QT2PeUFcj3lBeo95QZmPeUG3j3lB1o95QfSPeUETkHlBMZB5QVCQeUFukHlBjZB5QauQeUHKkHlB6JB5QQeReUElkXlBRJF5QWKReUGBkXlBn5F5Qb6ReUHckXlB+5F5QRmSeUE4knlBVpJ5QXWSeUGTknlBspJ5QdCSeUHvknlBDZN5QSyTeUFKk3lBaZN5QYeTeUGmk3lBxJN5QeOTeUEBlHlBIJR5QT6UeUFdlHlBe5R5QZqUeUG4lHlB15R5QfWUeUEUlXlBMpV5QVGVeUFvlXlBjpV5QayVeUHLlXlB6ZV5QQiWeUEmlnlBRZZ5QWOWeUGBlnlBoJZ5Qb6WeUHdlnlB+5Z5QRqXeUE4l3lBV5d5QXWXeUGUl3lBspd5QdGXeUHvl3lBDph5QSyYeUFLmHlBaZh5QYeYeUGmmHlBxJh5QeOYeUEBmXlBIJl5QT6ZeUFdmXlBe5l5QZqZeUG4mXlB15l5QfWZeUETmnlBMpp5QVCaeUFvmnlBjZp5QayaeUHKmnlB6Zp5QQebeUElm3lBRJt5QWKbeUGBm3lBn5t5Qb6beUHcm3lB+5t5QRmceUE4nHlBVpx5QXSceUGTnHlBsZx5QdCceUHunHlBDZ15QSudeUFKnXlBaJ15QYadeUGlnXlBw515QeKdeUEAnnlBH555QT2eeUFbnnlBep55QZieeUG3nnlB1Z55QfSeeUESn3lBMJ95QU+feUFtn3lBjJ95QaqfeUHJn3lB5595QQWgeUEkoHlBQqB5QWGgeUF/oHlBnqB5QbygeUHaoHlB+aB5QReheUE2oXlBVKF5QXOheUGRoXlBr6F5Qc6heUHsoXlBC6J5QSmieUFHonlBZqJ5QYSieUGjonlBwaJ5Qd+ieUH+onlBHKN5QTujeUFZo3lBeKN5QZajeUG0o3lB06N5QfGjeUEQpHlBLqR5QUykeUFrpHlBiaR5QaikeUHGpHlB5KR5QQOleUEhpXlBQKV5QV6leUF8pXlBm6V5QbmleUHYpXlB9qV5QRSmeUEzpnlBUaZ5QXCmeUGOpnlBrKZ5QcumeUHppnlBB6d5QSaneUFEp3lBY6d5QYGneUGfp3lBvqd5QdyneUH7p3lBGah5QTeoeUFWqHlBdKh5QZKoeUGxqHlBz6h5Qe6oeUEMqXlBKql5QUmpeUFnqXlBhql5QaSpeUHCqXlB4al5Qf+peUEdqnlBPKp5QVqqeUF5qnlBl6p5QbWqeUHUqnlB8qp5QRCreUEvq3lBTat5QWureUGKq3lBqKt5QcereUHlq3lBA6x5QSKseUFArHlBXqx5QX2seUGbrHlBuax5QdiseUH2rHlBFa15QTOteUFRrXlBcK15QY6teUGsrXlBy615QemteUEHrnlBJq55QUSueUFirnlBga55QZ+ueUG9rnlB3K55QfqueUEZr3lBN695QVWveUF0r3lBkq95QbCveUHPr3lB7a95QQuweUEqsHlBSLB5QWaweUGFsHlBo7B5QcGweUHgsHlB/rB5QRyxeUE7sXlBWbF5QXexeUGWsXlBtLF5QdKxeUHxsXlBD7J5QS2yeUFMsnlBarJ5QYiyeUGnsnlBxbJ5QeOyeUECs3lBILN5QT6zeUFds3lBe7N5QZmzeUG4s3lB1rN5QfSzeUETtHlBMbR5QU+0eUFutHlBjLR5Qaq0eUHJtHlB57R5QQW1eUEjtXlBQrV5QWC1eUF+tXlBnbV5Qbu1eUHZtXlB+LV5QRa2eUE0tnlBU7Z5QXG2eUGPtnlBrrZ5Qcy2eUHqtnlBCLd5QSe3eUFFt3lBY7d5QYK3eUGgt3lBvrd5Qd23eUH7t3lBGbh5QTi4eUFWuHlBdLh5QZK4eUGxuHlBz7h5Qe24eUEMuXlBKrl5QUi5eUFmuXlBhbl5QaO5eUHBuXlB4Ll5Qf65eUEcunlBO7p5QVm6eUF3unlBlbp5QbS6eUHSunlB8Lp5QQ+7eUEtu3lBS7t5QWm7eUGIu3lBprt5QcS7eUHju3lBAbx5QR+8eUE9vHlBXLx5QXq8eUGYvHlBt7x5QdW8eUHzvHlBEb15QTC9eUFOvXlBbL15QYq9eUGpvXlBx715QeW9eUEEvnlBIr55QUC+eUFevnlBfb55QZu+eUG5vnlB1755Qfa+eUEUv3lBMr95QVC/eUFvv3lBjb95Qau/eUHKv3lB6L95QQbAeUEkwHlBQ8B5QWHAeUF/wHlBncB5QbzAeUHawHlB+MB5QRbBeUE1wXlBU8F5QXHBeUGPwXlBrsF5QczBeUHqwXlBCMJ5QSfCeUFFwnlBY8J5QYHCeUGgwnlBvsJ5QdzCeUH6wnlBGcN5QTfDeUFVw3lBc8N5QZLDeUGww3lBzsN5QezDeUELxHlBKcR5QUfEeUFlxHlBhMR5QaLEeUHAxHlB3sR5QfzEeUEbxXlBOcV5QVfFeUF1xXlBlMV5QbLFeUHQxXlB7sV5QQ3GeUErxnlBScZ5QWfGeUGFxnlBpMZ5QcLGeUHgxnlB/sZ5QR3HeUE7x3lBWcd5QXfHeUGWx3lBtMd5QdLHeUHwx3lBDsh5QS3IeUFLyHlBach5QYfIeUGlyHlBxMh5QeLIeUEAyXlBHsl5QT3JeUFbyXlBecl5QZfJeUG1yXlB1Ml5QfLJeUEQynlBLsp5QUzKeUFrynlBicp5QafKeUHFynlB48p5QQLLeUEgy3lBPst5QVzLeUF7y3lBmct5QbfLeUHVy3lB88t5QRLMeUEwzHlBTsx5QWzMeUGKzHlBqcx5QcfMeUHlzHlBA815QSHNeUE/zXlBXs15QXzNeUGazXlBuM15QdbNeUH1zXlBE855QTHOeUFPznlBbc55QYzOeUGqznlByM55QebOeUEEz3lBIs95QUHPeUFfz3lBfc95QZvPeUG5z3lB2M95QfbPeUEU0HlBMtB5QVDQeUFu0HlBjdB5QavQeUHJ0HlB59B5QQXReUEk0XlBQtF5QWDReUF+0XlBnNF5QbrReUHZ0XlB99F5QRXSeUEz0nlBUdJ5QW/SeUGO0nlBrNJ5QcrSeUHo0nlBBtN5QSTTeUFD03lBYdN5QX/TeUGd03lBu9N5QdnTeUH403lBFtR5QTTUeUFS1HlBcNR5QY7UeUGs1HlBy9R5QenUeUEH1XlBJdV5QUPVeUFh1XlBgNV5QZ7VeUG81XlB2tV5QfjVeUEW1nlBNNZ5QVPWeUFx1nlBj9Z5Qa3WeUHL1nlB6dZ5QQfXeUEm13lBRNd5QWLXeUGA13lBntd5QbzXeUHa13lB+dd5QRfYeUE12HlBU9h5QXHYeUGP2HlBrdh5QczYeUHq2HlBCNl5QSbZeUFE2XlBYtl5QYDZeUGe2XlBvdl5QdvZeUH52XlBF9p5QTXaeUFT2nlBcdp5QY/aeUGu2nlBzNp5QeraeUEI23lBJtt5QUTbeUFi23lBgNt5QZ/beUG923lB29t5QfnbeUEX3HlBNdx5QVPceUFx3HlBkNx5Qa7ceUHM3HlB6tx5QQjdeUEm3XlBRN15QWLdeUGA3XlBn915Qb3deUHb3XlB+d15QRfeeUE13nlBU955QXHeeUGP3nlBrt55QczeeUHq3nlBCN95QSbfeUFE33lBYt95QYDfeUGe33lBvN95QdvfeUH533lBF+B5QTXgeUFT4HlBceB5QY/geUGt4HlBy+B5QengeUEH4XlBJuF5QUTheUFi4XlBgOF5QZ7heUG84XlB2uF5QfjheUEW4nlBNOJ5QVLieUFx4nlBj+J5Qa3ieUHL4nlB6eJ5QQfjeUEl43lBQ+N5QWHjeUF/43lBneN5QbvjeUHa43lB+ON5QRbkeUE05HlBUuR5QXDkeUGO5HlBrOR5QcrkeUHo5HlBBuV5QSTleUFC5XlBYOV5QX/leUGd5XlBu+V5QdnleUH35XlBFeZ5QTPmeUFR5nlBb+Z5QY3meUGr5nlByeZ5QefmeUEF53lBI+d5QULneUFg53lBfud5QZzneUG653lB2Od5QfbneUEU6HlBMuh5QVDoeUFu6HlBjOh5QaroeUHI6HlB5uh5QQTpeUEi6XlBQOl5QV/peUF96XlBm+l5QbnpeUHX6XlB9el5QRPqeUEx6nlBT+p5QW3qeUGL6nlBqep5QcfqeUHl6nlBA+t5QSHreUE/63lBXet5QXvreUGZ63lBt+t5QdXreUHz63lBEux5QTDseUFO7HlBbOx5QYrseUGo7HlBxux5QeTseUEC7XlBIO15QT7teUFc7XlBeu15QZjteUG27XlB1O15QfLteUEQ7nlBLu55QUzueUFq7nlBiO55QabueUHE7nlB4u55QQDveUEe73lBPO95QVrveUF473lBlu95QbTveUHS73lB8O95QQ7weUEs8HlBSvB5QWjweUGG8HlBpPB5QcLweUHh8HlB//B5QR3xeUE78XlBWfF5QXfxeUGV8XlBs/F5QdHxeUHv8XlBDfJ5QSvyeUFJ8nlBZ/J5QYXyeUGj8nlBwfJ5Qd/yeUH98nlBG/N5QTnzeUFX83lBdfN5QZPzeUGx83lBz/N5Qe3zeUEL9HlBKfR5QUf0eUFl9HlBg/R5QaH0eUG/9HlB3fR5Qfv0eUEZ9XlBN/V5QVX1eUFz9XlBkPV5Qa71eUHM9XlB6vV5QQj2eUEm9nlBRPZ5QWL2eUGA9nlBnvZ5Qbz2eUHa9nlB+PZ5QRb3eUE093lBUvd5QXD3eUGO93lBrPd5Qcr3eUHo93lBBvh5QST4eUFC+HlBYPh5QX74eUGc+HlBuvh5Qdj4eUH2+HlBFPl5QTL5eUFQ+XlBbvl5QYz5eUGq+XlByPl5Qeb5eUEE+nlBIvp5QUD6eUFe+nlBe/p5QZn6eUG3+nlB1fp5QfP6eUER+3lBL/t5QU37eUFr+3lBift5Qaf7eUHF+3lB4/t5QQH8eUEf/HlBPfx5QVv8eUF5/HlBl/x5QbX8eUHT/HlB8fx5QQ/9eUEs/XlBSv15QWj9eUGG/XlBpP15QcL9eUHg/XlB/v15QRz+eUE6/nlBWP55QXb+eUGU/nlBsv55QdD+eUHu/nlBDP95QSr/eUFH/3lBZf95QYP/eUGh/3lBv/95Qd3/eUH7/3lBGQB6QTcAekFVAHpBcwB6QZEAekGvAHpBzQB6QesAekEIAXpBJgF6QUQBekFiAXpBgAF6QZ4BekG8AXpB2gF6QfgBekEWAnpBNAJ6QVICekFwAnpBjgJ6QasCekHJAnpB5wJ6QQUDekEjA3pBQQN6QV8DekF9A3pBmwN6QbkDekHXA3pB9QN6QRIEekEwBHpBTgR6QWwEekGKBHpBqAR6QcYEekHkBHpBAgV6QSAFekE+BXpBWwV6QXkFekGXBXpBtQV6QdMFekHxBXpBDwZ6QS0GekFLBnpBaQZ6QYcGekGkBnpBwgZ6QeAGekH+BnpBHAd6QToHekFYB3pBdgd6QZQHekGyB3pBzwd6Qe0HekELCHpBKQh6QUcIekFlCHpBgwh6QaEIekG/CHpB3Ah6QfoIekEYCXpBNgl6QVQJekFyCXpBkAl6Qa4JekHMCXpB6Ql6QQcKekElCnpBQwp6QWEKekF/CnpBnQp6QbsKekHYCnpB9gp6QRQLekEyC3pBUAt6QW4LekGMC3pBqgt6QcgLekHlC3pBAwx6QSEMekE/DHpBXQx6QXsMekGZDHpBtwx6QdQMekHyDHpBEA16QS4NekFMDXpBag16QYgNekGlDXpBww16QeENekH/DXpBHQ56QTsOekFZDnpBdg56QZQOekGyDnpB0A56Qe4OekEMD3pBKg96QUgPekFlD3pBgw96QaEPekG/D3pB3Q96QfsPekEZEHpBNhB6QVQQekFyEHpBkBB6Qa4QekHMEHpB6RB6QQcRekElEXpBQxF6QWERekF/EXpBnRF6QboRekHYEXpB9hF6QRQSekEyEnpBUBJ6QW0SekGLEnpBqRJ6QccSekHlEnpBAxN6QSETekE+E3pBXBN6QXoTekGYE3pBthN6QdQTekHxE3pBDxR6QS0UekFLFHpBaRR6QYcUekGkFHpBwhR6QeAUekH+FHpBHBV6QToVekFXFXpBdRV6QZMVekGxFXpBzxV6QewVekEKFnpBKBZ6QUYWekFkFnpBghZ6QZ8WekG9FnpB2xZ6QfkWekEXF3pBNBd6QVIXekFwF3pBjhd6QawXekHKF3pB5xd6QQUYekEjGHpBQRh6QV8YekF8GHpBmhh6QbgYekHWGHpB9Bh6QREZekEvGXpBTRl6QWsZekGJGXpBpxl6QcQZekHiGXpBABp6QR4aekE8GnpBWRp6QXcaekGVGnpBsxp6QdEaekHuGnpBDBt6QSobekFIG3pBZht6QYMbekGhG3pBvxt6Qd0bekH7G3pBGBx6QTYcekFUHHpBchx6QY8cekGtHHpByxx6QekcekEHHXpBJB16QUIdekFgHXpBfh16QZwdekG5HXpB1x16QfUdekETHnpBMB56QU4eekFsHnpBih56QageekHFHnpB4x56QQEfekEfH3pBPR96QVofekF4H3pBlh96QbQfekHRH3pB7x96QQ0gekErIHpBSCB6QWYgekGEIHpBoiB6QcAgekHdIHpB+yB6QRkhekE3IXpBVCF6QXIhekGQIXpBriF6QcshekHpIXpBByJ6QSUiekFDInpBYCJ6QX4iekGcInpBuiJ6QdciekH1InpBEyN6QTEjekFOI3pBbCN6QYojekGoI3pBxSN6QeMjekEBJHpBHyR6QTwkekFaJHpBeCR6QZYkekGzJHpB0SR6Qe8kekENJXpBKiV6QUglekFmJXpBhCV6QaElekG/JXpB3SV6QfslekEYJnpBNiZ6QVQmekFyJnpBjyZ6Qa0mekHLJnpB6SZ6QQYnekEkJ3pBQid6QV8nekF9J3pBmyd6QbknekHWJ3pB9Cd6QRIoekEwKHpBTSh6QWsoekGJKHpBpyh6QcQoekHiKHpBACl6QR0pekE7KXpBWSl6QXcpekGUKXpBsil6QdApekHuKXpBCyp6QSkqekFHKnpBZCp6QYIqekGgKnpBvip6QdsqekH5KnpBFyt6QTQrekFSK3pBcCt6QY4rekGrK3pBySt6QecrekEELHpBIix6QUAsekFeLHpBeyx6QZksekG3LHpB1Cx6QfIsekEQLXpBLi16QUstekFpLXpBhy16QaQtekHCLXpB4C16Qf4tekEbLnpBOS56QVcuekF0LnpBki56QbAuekHNLnpB6y56QQkvekEnL3pBRC96QWIvekGAL3pBnS96QbsvekHZL3pB9i96QRQwekEyMHpBTzB6QW0wekGLMHpBqTB6QcYwekHkMHpBAjF6QR8xekE9MXpBWzF6QXgxekGWMXpBtDF6QdExekHvMXpBDTJ6QSoyekFIMnpBZjJ6QYMyekGhMnpBvzJ6Qd0yekH6MnpBGDN6QTYzekFTM3pBcTN6QY8zekGsM3pByjN6QegzekEFNHpBIzR6QUE0ekFeNHpBfDR6QZo0ekG3NHpB1TR6QfM0ekEQNXpBLjV6QUw1ekFpNXpBhzV6QaU1ekHCNXpB4DV6Qf41ekEbNnpBOTZ6QVc2ekF0NnpBkjZ6QbA2ekHNNnpB6zZ6QQk3ekEmN3pBRDd6QWI3ekF/N3pBnTd6Qbs3ekHYN3pB9jd6QRM4ekExOHpBTzh6QWw4ekGKOHpBqDh6QcU4ekHjOHpBATl6QR45ekE8OXpBWjl6QXc5ekGVOXpBszl6QdA5ekHuOXpBCzp6QSk6ekFHOnpBZDp6QYI6ekGgOnpBvTp6Qds6ekH5OnpBFjt6QTQ7ekFSO3pBbzt6QY07ekGqO3pByDt6QeY7ekEDPHpBITx6QT88ekFcPHpBejx6QZc8ekG1PHpB0zx6QfA8ekEOPXpBLD16QUk9ekFnPXpBhD16QaI9ekHAPXpB3T16Qfs9ekEZPnpBNj56QVQ+ekFxPnpBjz56Qa0+ekHKPnpB6D56QQY/ekEjP3pBQT96QV4/ekF8P3pBmj96Qbc/ekHVP3pB8j96QRBAekEuQHpBS0B6QWlAekGHQHpBpEB6QcJAekHfQHpB/UB6QRtBekE4QXpBVkF6QXNBekGRQXpBr0F6QcxBekHqQXpBB0J6QSVCekFDQnpBYEJ6QX5CekGbQnpBuUJ6QddCekH0QnpBEkN6QS9DekFNQ3pBa0N6QYhDekGmQ3pBw0N6QeFDekH/Q3pBHER6QTpEekFXRHpBdUR6QZNEekGwRHpBzkR6QetEekEJRXpBJkV6QURFekFiRXpBf0V6QZ1FekG6RXpB2EV6QfZFekETRnpBMUZ6QU5GekFsRnpBiUZ6QadGekHFRnpB4kZ6QQBHekEdR3pBO0d6QVlHekF2R3pBlEd6QbFHekHPR3pB7Ed6QQpIekEoSHpBRUh6QWNIekGASHpBnkh6QbtIekHZSHpB90h6QRRJekEySXpBT0l6QW1JekGKSXpBqEl6QcVJekHjSXpBAUp6QR5KekE8SnpBWUp6QXdKekGUSnpBskp6QdBKekHtSnpBC0t6QShLekFGS3pBY0t6QYFLekGeS3pBvEt6QdpLekH3S3pBFUx6QTJMekFQTHpBbUx6QYtMekGoTHpBxkx6QeRMekEBTXpBH016QTxNekFaTXpBd016QZVNekGyTXpB0E16Qe1NekELTnpBKU56QUZOekFkTnpBgU56QZ9OekG8TnpB2k56QfdOekEVT3pBMk96QVBPekFtT3pBi096QahPekHGT3pB5E96QQFQekEfUHpBPFB6QVpQekF3UHpBlVB6QbJQekHQUHpB7VB6QQtRekEoUXpBRlF6QWNRekGBUXpBnlF6QbxRekHaUXpB91F6QRVSekEyUnpBUFJ6QW1SekGLUnpBqFJ6QcZSekHjUnpBAVN6QR5TekE8U3pBWVN6QXdTekGUU3pBslN6Qc9TekHtU3pBClR6QShUekFFVHpBY1R6QYBUekGeVHpBu1R6QdlUekH2VHpBFFV6QTFVekFPVXpBbFV6QYpVekGnVXpBxVV6QeNVekEAVnpBHlZ6QTtWekFZVnpBdlZ6QZRWekGxVnpBz1Z6QexWekEKV3pBJ1d6QUVXekFiV3pBf1d6QZ1XekG6V3pB2Fd6QfVXekETWHpBMFh6QU5YekFrWHpBiVh6QaZYekHEWHpB4Vh6Qf9YekEcWXpBOll6QVdZekF1WXpBkll6QbBZekHNWXpB61l6QQhaekEmWnpBQ1p6QWFaekF+WnpBnFp6QblaekHXWnpB9Fp6QRJbekEvW3pBTVt6QWpbekGHW3pBpVt6QcJbekHgW3pB/Vt6QRtcekE4XHpBVlx6QXNcekGRXHpBrlx6QcxcekHpXHpBB116QSRdekFCXXpBX116QXxdekGaXXpBt116QdVdekHyXXpBEF56QS1eekFLXnpBaF56QYZeekGjXnpBwV56Qd5eekH7XnpBGV96QTZfekFUX3pBcV96QY9fekGsX3pByl96QedfekEFYHpBImB6QT9gekFdYHpBemB6QZhgekG1YHpB02B6QfBgekEOYXpBK2F6QUlhekFmYXpBg2F6QaFhekG+YXpB3GF6QflhekEXYnpBNGJ6QVFiekFvYnpBjGJ6QapiekHHYnpB5WJ6QQJjekEgY3pBPWN6QVpjekF4Y3pBlWN6QbNjekHQY3pB7mN6QQtkekEoZHpBRmR6QWNkekGBZHpBnmR6QbxkekHZZHpB9mR6QRRlekExZXpBT2V6QWxlekGKZXpBp2V6QcRlekHiZXpB/2V6QR1mekE6ZnpBWGZ6QXVmekGSZnpBsGZ6Qc1mekHrZnpBCGd6QSZnekFDZ3pBYGd6QX5nekGbZ3pBuWd6QdZnekHzZ3pBEWh6QS5oekFMaHpBaWh6QYZoekGkaHpBwWh6Qd9oekH8aHpBGml6QTdpekFUaXpBcml6QY9pekGtaXpByml6QedpekEFanpBImp6QUBqekFdanpBemp6QZhqekG1anpB02p6QfBqekENa3pBK2t6QUhrekFma3pBg2t6QaBrekG+a3pB22t6QflrekEWbHpBM2x6QVFsekFubHpBi2x6QalsekHGbHpB5Gx6QQFtekEebXpBPG16QVltekF3bXpBlG16QbFtekHPbXpB7G16QQpuekEnbnpBRG56QWJuekF/bnpBnG56QbpuekHXbnpB9W56QRJvekEvb3pBTW96QWpvekGHb3pBpW96QcJvekHgb3pB/W96QRpwekE4cHpBVXB6QXJwekGQcHpBrXB6QctwekHocHpBBXF6QSNxekFAcXpBXXF6QXtxekGYcXpBtXF6QdNxekHwcXpBDnJ6QStyekFIcnpBZnJ6QYNyekGgcnpBvnJ6QdtyekH4cnpBFnN6QTNzekFRc3pBbnN6QYtzekGpc3pBxnN6QeNzekEBdHpBHnR6QTt0ekFZdHpBdnR6QZN0ekGxdHpBznR6Qet0ekEJdXpBJnV6QUR1ekFhdXpBfnV6QZx1ekG5dXpB1nV6QfR1ekERdnpBLnZ6QUx2ekFpdnpBhnZ6QaR2ekHBdnpB3nZ6Qfx2ekEZd3pBNnd6QVR3ekFxd3pBjnd6Qax3ekHJd3pB5nd6QQR4ekEheHpBPnh6QVx4ekF5eHpBlnh6QbR4ekHReHpB7nh6QQx5ekEpeXpBRnl6QWR5ekGBeXpBnnl6Qbx5ekHZeXpB9nl6QRR6ekExenpBTnp6QWx6ekGJenpBpnp6QcR6ekHhenpB/np6QRt7ekE5e3pBVnt6QXN7ekGRe3pBrnt6Qct7ekHpe3pBBnx6QSN8ekFBfHpBXnx6QXt8ekGZfHpBtnx6QdN8ekHwfHpBDn16QSt9ekFIfXpBZn16QYN9ekGgfXpBvn16Qdt9ekH4fXpBFn56QTN+ekFQfnpBbX56QYt+ekGofnpBxX56QeN+ekEAf3pBHX96QTt/ekFYf3pBdX96QZJ/ekGwf3pBzX96Qep/ekEIgHpBJYB6QUKAekFfgHpBfYB6QZqAekG3gHpB1YB6QfKAekEPgXpBLYF6QUqBekFngXpBhIF6QaKBekG/gXpB3IF6QfqBekEXgnpBNIJ6QVGCekFvgnpBjIJ6QamCekHGgnpB5IJ6QQGDekEeg3pBPIN6QVmDekF2g3pBk4N6QbGDekHOg3pB64N6QQmEekEmhHpBQ4R6QWCEekF+hHpBm4R6QbiEekHVhHpB84R6QRCFekEthXpBS4V6QWiFekGFhXpBooV6QcCFekHdhXpB+oV6QReGekE1hnpBUoZ6QW+GekGMhnpBqoZ6QceGekHkhnpBAYd6QR+HekE8h3pBWYd6QXaHekGUh3pBsYd6Qc6HekHsh3pBCYh6QSaIekFDiHpBYYh6QX6IekGbiHpBuIh6QdaIekHziHpBEIl6QS2JekFLiXpBaIl6QYWJekGiiXpBwIl6Qd2JekH6iXpBF4p6QTSKekFSinpBb4p6QYyKekGpinpBx4p6QeSKekEBi3pBHot6QTyLekFZi3pBdot6QZOLekGxi3pBzot6QeuLekEIjHpBJox6QUOMekFgjHpBfYx6QZqMekG4jHpB1Yx6QfKMekEPjXpBLY16QUqNekFnjXpBhI16QaKNekG/jXpB3I16QfmNekEWjnpBNI56QVGOekFujnpBi456QamOekHGjnpB4456QQCPekEdj3pBO496QViPekF1j3pBko96QbCPekHNj3pB6o96QQeQekEkkHpBQpB6QV+QekF8kHpBmZB6QbaQekHUkHpB8ZB6QQ6RekErkXpBSJF6QWaRekGDkXpBoJF6Qb2RekHbkXpB+JF6QRWSekEyknpBT5J6QW2SekGKknpBp5J6QcSSekHhknpB/5J6QRyTekE5k3pBVpN6QXOTekGRk3pBrpN6QcuTekHok3pBBZR6QSKUekFAlHpBXZR6QXqUekGXlHpBtJR6QdKUekHvlHpBDJV6QSmVekFGlXpBZJV6QYGVekGelXpBu5V6QdiVekH2lXpBE5Z6QTCWekFNlnpBapZ6QYeWekGllnpBwpZ6Qd+WekH8lnpBGZd6QTeXekFUl3pBcZd6QY6XekGrl3pByJd6QeaXekEDmHpBIJh6QT2YekFamHpBd5h6QZWYekGymHpBz5h6QeyYekEJmXpBJpl6QUSZekFhmXpBfpl6QZuZekG4mXpB1Zl6QfOZekEQmnpBLZp6QUqaekFnmnpBhJp6QaKaekG/mnpB3Jp6QfmaekEWm3pBM5t6QVGbekFum3pBi5t6QaibekHFm3pB4pt6QQCcekEdnHpBOpx6QVecekF0nHpBkZx6Qa6cekHMnHpB6Zx6QQadekEjnXpBQJ16QV2dekF7nXpBmJ16QbWdekHSnXpB7516QQyeekEpnnpBR556QWSeekGBnnpBnp56QbueekHYnnpB9Z56QROfekEwn3pBTZ96QWqfekGHn3pBpJ96QcGfekHen3pB/J96QRmgekE2oHpBU6B6QXCgekGNoHpBqqB6QcigekHloHpBAqF6QR+hekE8oXpBWaF6QXahekGToXpBsaF6Qc6hekHroXpBCKJ6QSWiekFConpBX6J6QXyiekGaonpBt6J6QdSiekHxonpBDqN6QSujekFIo3pBZaN6QYOjekGgo3pBvaN6QdqjekH3o3pBFKR6QTGkekFOpHpBa6R6QYmkekGmpHpBw6R6QeCkekH9pHpBGqV6QTelekFUpXpBcaV6QY+lekGspXpByaV6QealekEDpnpBIKZ6QT2mekFapnpBd6Z6QZWmekGypnpBz6Z6QeymekEJp3pBJqd6QUOnekFgp3pBfad6QZqnekG4p3pB1ad6QfKnekEPqHpBLKh6QUmoekFmqHpBg6h6QaCoekG9qHpB2qh6QfioekEVqXpBMql6QU+pekFsqXpBial6QaapekHDqXpB4Kl6Qf2pekEaqnpBOKp6QVWqekFyqnpBj6p6QayqekHJqnpB5qp6QQOrekEgq3pBPat6QVqrekF3q3pBlat6QbKrekHPq3pB7Kt6QQmsekEmrHpBQ6x6QWCsekF9rHpBmqx6QbesekHUrHpB8ax6QQ+tekEsrXpBSa16QWatekGDrXpBoK16Qb2tekHarXpB9616QRSuekExrnpBTq56QWuuekGIrnpBpa56QcOuekHgrnpB/a56QRqvekE3r3pBVK96QXGvekGOr3pBq696QcivekHlr3pBArB6QR+wekE8sHpBWbB6QXawekGTsHpBsbB6Qc6wekHrsHpBCLF6QSWxekFCsXpBX7F6QXyxekGZsXpBtrF6QdOxekHwsXpBDbJ6QSqyekFHsnpBZLJ6QYGyekGesnpBu7J6QdiyekH1snpBE7N6QTCzekFNs3pBarN6QYezekGks3pBwbN6Qd6zekH7s3pBGLR6QTW0ekFStHpBb7R6QYy0ekGptHpBxrR6QeO0ekEAtXpBHbV6QTq1ekFXtXpBdLV6QZG1ekGutXpBy7V6Qei1ekEFtnpBIrZ6QT+2ekFctnpBebZ6QZe2ekG0tnpB0bZ6Qe62ekELt3pBKLd6QUW3ekFit3pBf7d6QZy3ekG5t3pB1rd6QfO3ekEQuHpBLbh6QUq4ekFnuHpBhLh6QaG4ekG+uHpB27h6Qfi4ekEVuXpBMrl6QU+5ekFsuXpBibl6Qaa5ekHDuXpB4Ll6Qf25ekEaunpBN7p6QVS6ekFxunpBjrp6Qau6ekHIunpB5bp6QQK7ekEfu3pBPLt6QVm7ekF2u3pBk7t6QbC7ekHNu3pB6rt6QQe8ekEkvHpBQbx6QV68ekF7vHpBmLx6QbW8ekHSvHpB77x6QQy9ekEpvXpBRr16QWO9ekGAvXpBnb16Qbq9ekHXvXpB9L16QRG+ekEuvnpBS756QWi+ekGFvnpBor56Qb++ekHcvnpB+b56QRa/ekEzv3pBUL96QW2/ekGKv3pBp796QcS/ekHhv3pB/r96QRvAekE4wHpBVcB6QXLAekGPwHpBq8B6QcjAekHlwHpBAsF6QR/BekE8wXpBWcF6QXbBekGTwXpBsMF6Qc3BekHqwXpBB8J6QSTCekFBwnpBXsJ6QXvCekGYwnpBtcJ6QdLCekHvwnpBDMN6QSnDekFGw3pBY8N6QYDDekGdw3pBusN6QdfDekH0w3pBEMR6QS3EekFKxHpBZ8R6QYTEekGhxHpBvsR6QdvEekH4xHpBFcV6QTLFekFPxXpBbMV6QYnFekGmxXpBw8V6QeDFekH9xXpBGsZ6QTfGekFUxnpBcMZ6QY3GekGqxnpBx8Z6QeTGekEBx3pBHsd6QTvHekFYx3pBdcd6QZLHekGvx3pBzMd6QenHekEGyHpBI8h6QUDIekFcyHpBech6QZbIekGzyHpB0Mh6Qe3IekEKyXpBJ8l6QUTJekFhyXpBfsl6QZvJekG4yXpB1cl6QfLJekEOynpBK8p6QUjKekFlynpBgsp6QZ/KekG8ynpB2cp6QfbKekETy3pBMMt6QU3LekFqy3pBh8t6QaPLekHAy3pB3ct6QfrLekEXzHpBNMx6QVHMekFuzHpBi8x6QajMekHFzHpB4sx6Qf7MekEbzXpBOM16QVXNekFyzXpBj816QazNekHJzXpB5s16QQPOekEgznpBPM56QVnOekF2znpBk856QbDOekHNznpB6s56QQfPekEkz3pBQc96QV7PekF6z3pBl896QbTPekHRz3pB7s96QQvQekEo0HpBRdB6QWLQekF/0HpBm9B6QbjQekHV0HpB8tB6QQ/RekEs0XpBSdF6QWbRekGD0XpBn9F6QbzRekHZ0XpB9tF6QRPSekEw0npBTdJ6QWrSekGH0npBo9J6QcDSekHd0npB+tJ6QRfTekE003pBUdN6QW7TekGL03pBp9N6QcTTekHh03pB/tN6QRvUekE41HpBVdR6QXLUekGO1HpBq9R6QcjUekHl1HpBAtV6QR/VekE81XpBWdV6QXXVekGS1XpBr9V6QczVekHp1XpBBtZ6QSPWekFA1npBXNZ6QXnWekGW1npBs9Z6QdDWekHt1npBCtd6QSfXekFD13pBYNd6QX3XekGa13pBt9d6QdTXekHx13pBDdh6QSrYekFH2HpBZNh6QYHYekGe2HpBu9h6QdfYekH02HpBEdl6QS7ZekFL2XpBaNl6QYXZekGh2XpBvtl6QdvZekH42XpBFdp6QTLaekFP2npBa9p6QYjaekGl2npBwtp6Qd/aekH82npBGNt6QTXbekFS23pBb9t6QYzbekGp23pBxtt6QeLbekH/23pBHNx6QTncekFW3HpBc9x6QY/cekGs3HpBydx6QebcekED3XpBIN16QTzdekFZ3XpBdt16QZPdekGw3XpBzd16QendekEG3npBI956QUDeekFd3npBet56QZbeekGz3npB0N56Qe3eekEK33pBJ996QUPfekFg33pBfd96QZrfekG333pB0996QfDfekEN4HpBKuB6QUfgekFk4HpBgOB6QZ3gekG64HpB1+B6QfTgekEQ4XpBLeF6QUrhekFn4XpBhOF6QaHhekG94XpB2uF6QffhekEU4npBMeJ6QU3iekFq4npBh+J6QaTiekHB4npB3eJ6QfriekEX43pBNON6QVHjekFu43pBiuN6QafjekHE43pB4eN6Qf7jekEa5HpBN+R6QVTkekFx5HpBjuR6QarkekHH5HpB5OR6QQHlekEe5XpBOuV6QVflekF05XpBkeV6Qa3lekHK5XpB5+V6QQTmekEh5npBPeZ6QVrmekF35npBlOZ6QbHmekHN5npB6uZ6QQfnekEk53pBQed6QV3nekF653pBl+d6QbTnekHQ53pB7ed6QQroekEn6HpBROh6QWDoekF96HpBmuh6QbfoekHU6HpB8Oh6QQ3pekEq6XpBR+l6QWPpekGA6XpBnel6QbrpekHW6XpB8+l6QRDqekEt6npBSup6QWbqekGD6npBoOp6Qb3qekHZ6npB9up6QRPrekEw63pBTet6QWnrekGG63pBo+t6QcDrekHc63pB+et6QRbsekEz7HpBT+x6QWzsekGJ7HpBpux6QcLsekHf7HpB/Ox6QRntekE17XpBUu16QW/tekGM7XpBqO16QcXtekHi7XpB/+16QRvuekE47npBVe56QXLuekGP7npBq+56QcjuekHl7npBAu96QR7vekE773pBWO96QXTvekGR73pBru96QcvvekHn73pBBPB6QSHwekE+8HpBWvB6QXfwekGU8HpBsfB6Qc3wekHq8HpBB/F6QSTxekFA8XpBXfF6QXrxekGX8XpBs/F6QdDxekHt8XpBCvJ6QSbyekFD8npBYPJ6QXzyekGZ8npBtvJ6QdPyekHv8npBDPN6QSnzekFG83pBYvN6QX/zekGc83pBuPN6QdXzekHy83pBD/R6QSv0ekFI9HpBZfR6QYL0ekGe9HpBu/R6Qdj0ekH09HpBEfV6QS71ekFL9XpBZ/V6QYT1ekGh9XpBvfV6Qdr1ekH39XpBFPZ6QTD2ekFN9npBavZ6QYb2ekGj9npBwPZ6Qd32ekH59npBFvd6QTP3ekFP93pBbPd6QYn3ekGm93pBwvd6Qd/3ekH893pBGPh6QTX4ekFS+HpBbvh6QYv4ekGo+HpBxfh6QeH4ekH++HpBG/l6QTf5ekFU+XpBcfl6QY35ekGq+XpBx/l6QeT5ekEA+npBHfp6QTr6ekFW+npBc/p6QZD6ekGs+npByfp6Qeb6ekEC+3pBH/t6QTz7ekFZ+3pBdft6QZL7ekGv+3pBy/t6Qej7ekEF/HpBIfx6QT78ekFb/HpBd/x6QZT8ekGx/HpBzfx6Qer8ekEH/XpBI/16QUD9ekFd/XpBev16QZb9ekGz/XpB0P16Qez9ekEJ/npBJv56QUL+ekFf/npBfP56QZj+ekG1/npB0v56Qe7+ekEL/3pBKP96QUT/ekFh/3pBfv96QZr/ekG3/3pB1P96QfD/ekENAHtBKgB7QUYAe0FjAHtBgAB7QZwAe0G5AHtB1gB7QfIAe0EPAXtBLAF7QUgBe0FlAXtBggF7QZ4Be0G7AXtB2AF7QfQBe0ERAntBLgJ7QUoCe0FnAntBgwJ7QaACe0G9AntB2QJ7QfYCe0ETA3tBLwN7QUwDe0FpA3tBhQN7QaIDe0G/A3tB2wN7QfgDe0EVBHtBMQR7QU4Ee0FrBHtBhwR7QaQEe0HABHtB3QR7QfoEe0EWBXtBMwV7QVAFe0FsBXtBiQV7QaYFe0HCBXtB3wV7QfwFe0EYBntBNQZ7QVEGe0FuBntBiwZ7QacGe0HEBntB4QZ7Qf0Ge0EaB3tBNgd7QVMHe0FwB3tBjAd7QakHe0HGB3tB4gd7Qf8He0EcCHtBOAh7QVUIe0FxCHtBjgh7QasIe0HHCHtB5Ah7QQEJe0EdCXtBOgl7QVYJe0FzCXtBkAl7QawJe0HJCXtB5Ql7QQIKe0EfCntBOwp7QVgKe0F1CntBkQp7Qa4Ke0HKCntB5wp7QQQLe0EgC3tBPQt7QVkLe0F2C3tBkwt7Qa8Le0HMC3tB6At7QQUMe0EiDHtBPgx7QVsMe0F4DHtBlAx7QbEMe0HNDHtB6gx7QQcNe0EjDXtBQA17QVwNe0F5DXtBlg17QbINe0HPDXtB6w17QQgOe0ElDntBQQ57QV4Oe0F6DntBlw57QbQOe0HQDntB7Q57QQkPe0EmD3tBQw97QV8Pe0F8D3tBmA97QbUPe0HRD3tB7g97QQsQe0EnEHtBRBB7QWAQe0F9EHtBmhB7QbYQe0HTEHtB7xB7QQwRe0EoEXtBRRF7QWIRe0F+EXtBmxF7QbcRe0HUEXtB8RF7QQ0Se0EqEntBRhJ7QWMSe0F/EntBnBJ7QbkSe0HVEntB8hJ7QQ4Te0ErE3tBRxN7QWQTe0GBE3tBnRN7QboTe0HWE3tB8xN7QQ8Ue0EsFHtBSRR7QWUUe0GCFHtBnhR7QbsUe0HXFHtB9BR7QREVe0EtFXtBShV7QWYVe0GDFXtBnxV7QbwVe0HYFXtB9RV7QRIWe0EuFntBSxZ7QWcWe0GEFntBoBZ7Qb0We0HaFntB9hZ7QRMXe0EvF3tBTBd7QWgXe0GFF3tBoRd7Qb4Xe0HaF3tB9xd7QRQYe0EwGHtBTRh7QWkYe0GGGHtBohh7Qb8Ye0HbGHtB+Bh7QRUZe0ExGXtBThl7QWoZe0GHGXtBoxl7QcAZe0HcGXtB+Rl7QRUae0EyGntBThp7QWsae0GIGntBpBp7QcEae0HdGntB+hp7QRYbe0EzG3tBTxt7QWwbe0GIG3tBpRt7QcEbe0HeG3tB+ht7QRcce0E0HHtBUBx7QW0ce0GJHHtBphx7QcIce0HfHHtB+xx7QRgde0E0HXtBUR17QW0de0GKHXtBph17QcMde0HfHXtB/B17QRgee0E1HntBUh57QW4ee0GLHntBpx57QcQee0HgHntB/R57QRkfe0E2H3tBUh97QW8fe0GLH3tBqB97QcQfe0HhH3tB/R97QRoge0E2IHtBUyB7QW8ge0GMIHtBqCB7QcUge0HhIHtB/iB7QRohe0E3IXtBUyF7QXAhe0GMIXtBqSF7QcUhe0HiIXtB/iF7QRsie0E3IntBVCJ7QXAie0GNIntBqSJ7QcYie0HiIntB/yJ7QRsje0E4I3tBVCN7QXEje0GNI3tBqiN7QcYje0HjI3tB/yN7QRwke0E4JHtBVSR7QXEke0GOJHtBqiR7Qccke0HjJHtBACV7QRwle0E5JXtBVSV7QXIle0GOJXtBqyV7Qccle0HkJXtBACZ7QR0me0E5JntBViZ7QXIme0GOJntBqyZ7Qccme0HkJntBACd7QR0ne0E5J3tBVid7QXIne0GPJ3tBqyd7Qcgne0HkJ3tBASh7QR0oe0E6KHtBVih7QXMoe0GPKHtBqyh7Qcgoe0HkKHtBASl7QR0pe0E6KXtBVil7QXMpe0GPKXtBrCl7Qcgpe0HlKXtBASp7QR4qe0E6KntBVip7QXMqe0GPKntBrCp7Qcgqe0HlKntBASt7QR4re0E6K3tBVyt7QXMre0GPK3tBrCt7Qcgre0HlK3tBASx7QR4se0E6LHtBVyx7QXMse0GQLHtBrCx7Qcgse0HlLHtBAS17QR4te0E6LXtBVy17QXMte0GQLXtBrC17Qckte0HlLXtBAS57QR4ue0E6LntBVy57QXMue0GQLntBrC57Qcgue0HlLntBAS97QR4ve0E6L3tBVy97QXMve0GQL3tBrC97Qcgve0HlL3tBATB7QR4we0E6MHtBVzB7QXMwe0GPMHtBrDB7Qcgwe0HlMHtBATF7QR4xe0E6MXtBVjF7QXMxe0GPMXtBrDF7Qcgxe0HlMXtBATJ7QR0ye0E6MntBVjJ7QXMye0GPMntBrDJ7Qcgye0HkMntBATN7QR0ze0E6M3tBVjN7QXIze0GPM3tBqzN7Qcgze0HkM3tBATR7QR00e0E5NHtBVjR7QXI0e0GPNHtBqzR7Qcc0e0HkNHtBADV7QR01e0E5NXtBVjV7QXI1e0GONXtBqzV7Qcc1e0HkNXtBADZ7QRw2e0E5NntBVTZ7QXI2e0GONntBqjZ7Qcc2e0HjNntBADd7QRw3e0E4N3tBVTd7QXE3e0GON3tBqjd7QcY3e0HjN3tB/zd7QRw4e0E4OHtBVDh7QXE4e0GNOHtBqjh7QcY4e0HiOHtB/zh7QRs5e0E3OXtBVDl7QXA5e0GNOXtBqTl7QcU5e0HiOXtB/jl7QRs6e0E3OntBUzp7QXA6e0GMOntBqDp7QcU6e0HhOntB/jp7QRo7e0E2O3tBUzt7QW87e0GMO3tBqDt7QcQ7e0HhO3tB/Tt7QRk8e0E2PHtBUjx7QW88e0GLPHtBpzx7QcQ8e0HgPHtB/Dx7QRk9e0E1PXtBUj17QW49e0GKPXtBpz17QcM9e0HfPXtB/D17QRg+e0E0PntBUT57QW0+e0GKPntBpj57QcI+e0HfPntB+z57QRc/e0E0P3tBUD97QWw/e0GJP3tBpT97QcI/e0HeP3tB+j97QRdAe0EzQHtBT0B7QWxAe0GIQHtBpEB7QcFAe0HdQHtB+UB7QRZBe0EyQXtBT0F7QWtBe0GHQXtBpEF7QcBBe0HcQXtB+UF7QRVCe0ExQntBTkJ7QWpCe0GGQntBo0J7Qb9Ce0HbQntB+EJ7QRRDe0EwQ3tBTUN7QWlDe0GFQ3tBokN7Qb5De0HaQ3tB90N7QRNEe0EvRHtBTER7QWhEe0GERHtBoUR7Qb1Ee0HZRHtB9kR7QRJFe0EuRXtBS0V7QWdFe0GDRXtBoEV7QbxFe0HYRXtB9UV7QRFGe0EtRntBSkZ7QWZGe0GCRntBn0Z7QbtGe0HXRntB9EZ7QRBHe0EsR3tBSUd7QWVHe0GBR3tBnkd7QbpHe0HWR3tB80d7QQ9Ie0ErSHtBSEh7QWRIe0GASHtBnUh7QblIe0HVSHtB8Uh7QQ5Je0EqSXtBRkl7QWNJe0F/SXtBm0l7QbhJe0HUSXtB8El7QQ1Ke0EpSntBRUp7QWFKe0F+SntBmkp7QbZKe0HTSntB70p7QQtLe0EoS3tBREt7QWBLe0F9S3tBmUt7QbVLe0HRS3tB7kt7QQpMe0EmTHtBQ0x7QV9Me0F7THtBmEx7QbRMe0HQTHtB7Ex7QQlNe0ElTXtBQU17QV5Ne0F6TXtBlk17QbJNe0HPTXtB6017QQdOe0EkTntBQE57QVxOe0F5TntBlU57QbFOe0HNTntB6k57QQZPe0EiT3tBP097QVtPe0F3T3tBk097QbBPe0HMT3tB6E97QQRQe0EhUHtBPVB7QVlQe0F2UHtBklB7Qa5Qe0HKUHtB51B7QQNRe0EfUXtBPFF7QVhRe0F0UXtBkFF7Qa1Re0HJUXtB5VF7QQFSe0EeUntBOlJ7QVZSe0FzUntBj1J7QatSe0HHUntB5FJ7QQBTe0EcU3tBOFN7QVVTe0FxU3tBjVN7QalTe0HGU3tB4lN7Qf5Te0EaVHtBN1R7QVNUe0FvVHtBjFR7QahUe0HEVHtB4FR7Qf1Ue0EZVXtBNVV7QVFVe0FuVXtBilV7QaZVe0HCVXtB31V7QftVe0EXVntBM1Z7QVBWe0FsVntBiFZ7QaRWe0HBVntB3VZ7QflWe0EVV3tBMld7QU5Xe0FqV3tBhld7QaNXe0G/V3tB21d7QfdXe0EUWHtBMFh7QUxYe0FoWHtBhVh7QaFYe0G9WHtB2Vh7QfVYe0ESWXtBLll7QUpZe0FmWXtBg1l7QZ9Ze0G7WXtB11l7QfRZe0EQWntBLFp7QUhae0FlWntBgVp7QZ1ae0G5WntB1Vp7QfJae0EOW3tBKlt7QUZbe0FjW3tBf1t7QZtbe0G3W3tB01t7QfBbe0EMXHtBKFx7QURce0FhXHtBfVx7QZlce0G1XHtB0Vx7Qe5ce0EKXXtBJl17QUJde0FfXXtBe117QZdde0GzXXtBz117Qexde0EIXntBJF57QUBee0FcXntBeV57QZVee0GxXntBzV57Qepee0EGX3tBIl97QT5fe0FaX3tBd197QZNfe0GvX3tBy197Qedfe0EEYHtBIGB7QTxge0FYYHtBdGB7QZFge0GtYHtByWB7QeVge0EBYXtBHmF7QTphe0FWYXtBcmF7QY5he0GrYXtBx2F7QeNhe0H/YXtBG2J7QThie0FUYntBcGJ7QYxie0GoYntBxWJ7QeFie0H9YntBGWN7QTVje0FRY3tBbmN7QYpje0GmY3tBwmN7Qd5je0H7Y3tBF2R7QTNke0FPZHtBa2R7QYhke0GkZHtBwGR7Qdxke0H4ZHtBFGV7QTFle0FNZXtBaWV7QYVle0GhZXtBvWV7Qdple0H2ZXtBEmZ7QS5me0FKZntBZ2Z7QYNme0GfZntBu2Z7Qddme0HzZntBEGd7QSxne0FIZ3tBZGd7QYBne0GcZ3tBuWd7QdVne0HxZ3tBDWh7QSloe0FFaHtBYmh7QX5oe0GaaHtBtmh7QdJoe0HuaHtBC2l7QSdpe0FDaXtBX2l7QXtpe0GXaXtBtGl7QdBpe0HsaXtBCGp7QSRqe0FAantBXGp7QXlqe0GVantBsWp7Qc1qe0HpantBBWt7QSJre0E+a3tBWmt7QXZre0GSa3tBrmt7Qcpre0Hna3tBA2x7QR9se0E7bHtBV2x7QXNse0GPbHtBrGx7Qchse0HkbHtBAG17QRxte0E4bXtBVG17QXFte0GNbXtBqW17QcVte0HhbXtB/W17QRlue0E2bntBUm57QW5ue0GKbntBpm57QcJue0HebntB+m57QRdve0Ezb3tBT297QWtve0GHb3tBo297Qb9ve0Hcb3tB+G97QRRwe0EwcHtBTHB7QWhwe0GEcHtBoHB7Qb1we0HZcHtB9XB7QRFxe0EtcXtBSXF7QWVxe0GBcXtBnnF7Qbpxe0HWcXtB8nF7QQ5ye0EqcntBRnJ7QWJye0F+cntBm3J7Qbdye0HTcntB73J7QQtze0Enc3tBQ3N7QV9ze0F7c3tBmHN7QbRze0HQc3tB7HN7QQh0e0EkdHtBQHR7QVx0e0F4dHtBlXR7QbF0e0HNdHtB6XR7QQV1e0EhdXtBPXV7QVl1e0F1dXtBkXV7Qa51e0HKdXtB5nV7QQJ2e0EedntBOnZ7QVZ2e0FydntBjnZ7Qap2e0HHdntB43Z7Qf92e0Ebd3tBN3d7QVN3e0Fvd3tBi3d7Qad3e0HDd3tB4Hd7Qfx3e0EYeHtBNHh7QVB4e0FseHtBiHh7QaR4e0HAeHtB3Hh7Qfh4e0EUeXtBMXl7QU15e0FpeXtBhXl7QaF5e0G9eXtB2Xl7QfV5e0ERentBLXp7QUl6e0FlentBgnp7QZ56e0G6entB1np7QfJ6e0EOe3tBKnt7QUZ7e0Fie3tBfnt7QZp7e0G2e3tB0nt7Qe57e0ELfHtBJ3x7QUN8e0FffHtBe3x7QZd8e0GzfHtBz3x7Qet8e0EHfXtBI317QT99e0FbfXtBd317QZN9e0GwfXtBzH17Qeh9e0EEfntBIH57QTx+e0FYfntBdH57QZB+e0GsfntByH57QeR+e0EAf3tBHH97QTh/e0FUf3tBcH97QY1/e0Gpf3tBxX97QeF/e0H9f3tBGYB7QTWAe0FRgHtBbYB7QYmAe0GlgHtBwYB7Qd2Ae0H5gHtBFYF7QTGBe0FNgXtBaYF7QYWBe0GhgXtBvoF7QdqBe0H2gXtBEoJ7QS6Ce0FKgntBZoJ7QYKCe0GegntBuoJ7QdaCe0HygntBDoN7QSqDe0FGg3tBYoN7QX6De0Gag3tBtoN7QdKDe0Hug3tBCoR7QSaEe0FChHtBXoR7QXqEe0GWhHtBs4R7Qc+Ee0HrhHtBB4V7QSOFe0E/hXtBW4V7QXeFe0GThXtBr4V7QcuFe0HnhXtBA4Z7QR+Ge0E7hntBV4Z7QXOGe0GPhntBq4Z7QceGe0HjhntB/4Z7QRuHe0E3h3tBU4d7QW+He0GLh3tBp4d7QcOHe0Hfh3tB+4d7QReIe0EziHtBT4h7QWuIe0GHiHtBo4h7Qb+Ie0HbiHtB94h7QROJe0EviXtBS4l7QWeJe0GDiXtBn4l7QbuJe0HXiXtB84l7QQ+Ke0ErintBR4p7QWOKe0F/intBm4p7QbeKe0HTintB74p7QQuLe0Eni3tBQ4t7QV+Le0F7i3tBl4t7QbOLe0HPi3tB64t7QQeMe0EjjHtBP4x7QVuMe0F3jHtBk4x7Qa+Me0HLjHtB54x7QQONe0EfjXtBO417QVeNe0FzjXtBj417QauNe0HHjXtB4417Qf+Ne0EbjntBN457QVOOe0FvjntBi457QaeOe0HDjntB3457QfuOe0EXj3tBM497QU+Pe0Frj3tBh497QaOPe0G/j3tB2497QfePe0ETkHtBL5B7QUuQe0FnkHtBg5B7QZ+Qe0G7kHtB15B7QfOQe0EPkXtBKpF7QUaRe0FikXtBfpF7QZqRe0G2kXtB0pF7Qe6Re0EKkntBJpJ7QUKSe0FekntBepJ7QZaSe0GykntBzpJ7QeqSe0EGk3tBIpN7QT6Te0Fak3tBdpN7QZKTe0Guk3tBypN7QeaTe0EClHtBHZR7QTmUe0FVlHtBcZR7QY2Ue0GplHtBxZR7QeGUe0H9lHtBGZV7QTWVe0FRlXtBbZV7QYmVe0GllXtBwZV7Qd2Ve0H5lXtBFZZ7QTGWe0FNlntBaJZ7QYSWe0GglntBvJZ7QdiWe0H0lntBEJd7QSyXe0FIl3tBZJd7QYCXe0Gcl3tBuJd7QdSXe0Hwl3tBDJh7QSiYe0FDmHtBX5h7QXuYe0GXmHtBs5h7Qc+Ye0HrmHtBB5l7QSOZe0E/mXtBW5l7QXeZe0GTmXtBr5l7QcuZe0HmmXtBApp7QR6ae0E6mntBVpp7QXKae0GOmntBqpp7Qcaae0HimntB/pp7QRqbe0E2m3tBUZt7QW2be0GJm3tBpZt7QcGbe0Hdm3tB+Zt7QRWce0ExnHtBTZx7QWmce0GFnHtBoZx7Qbyce0HYnHtB9Jx7QRCde0EsnXtBSJ17QWSde0GAnXtBnJ17Qbide0HUnXtB7517QQuee0EnnntBQ557QV+ee0F7nntBl557QbOee0HPnntB6557QQefe0Ein3tBPp97QVqfe0F2n3tBkp97Qa6fe0HKn3tB5p97QQKge0EeoHtBOaB7QVWge0FxoHtBjaB7Qamge0HFoHtB4aB7Qf2ge0EZoXtBNaF7QVChe0FsoXtBiKF7QaShe0HAoXtB3KF7Qfihe0EUontBMKJ7QUuie0FnontBg6J7QZ+ie0G7ontB16J7QfOie0EPo3tBK6N7QUaje0Fio3tBfqN7QZqje0G2o3tB0qN7Qe6je0EKpHtBJqR7QUGke0FdpHtBeaR7QZWke0GxpHtBzaR7Qemke0EFpXtBIKV7QTyle0FYpXtBdKV7QZCle0GspXtByKV7QeSle0H/pXtBG6Z7QTeme0FTpntBb6Z7QYume0GnpntBw6Z7Qd6me0H6pntBFqd7QTKne0FOp3tBaqd7QYane0Ghp3tBvad7Qdmne0H1p3tBEah7QS2oe0FJqHtBZKh7QYCoe0GcqHtBuKh7QdSoe0HwqHtBDKl7QSepe0FDqXtBX6l7QXupe0GXqXtBs6l7Qc+pe0HqqXtBBqp7QSKqe0E+qntBWqp7QXaqe0GSqntBrap7Qcmqe0HlqntBAat7QR2re0E5q3tBVat7QXCre0GMq3tBqKt7QcSre0Hgq3tB/Kt7QRese0EzrHtBT6x7QWuse0GHrHtBo6x7Qb6se0HarHtB9qx7QRKte0EurXtBSq17QWate0GBrXtBna17Qbmte0HVrXtB8a17QQ2ue0EorntBRK57QWCue0F8rntBmK57QbSue0HPrntB6657QQeve0Ejr3tBP697QVqve0F2r3tBkq97Qa6ve0HKr3tB5q97QQGwe0EdsHtBObB7QVWwe0FxsHtBjbB7Qaiwe0HEsHtB4LB7Qfywe0EYsXtBM7F7QU+xe0FrsXtBh7F7QaOxe0G/sXtB2rF7Qfaxe0ESsntBLrJ7QUqye0FlsntBgbJ7QZ2ye0G5sntB1bJ7QfGye0EMs3tBKLN7QUSze0Fgs3tBfLN7QZeze0Gzs3tBz7N7Qeuze0EHtHtBIrR7QT60e0FatHtBdrR7QZK0e0GttHtBybR7QeW0e0EBtXtBHbV7QTi1e0FUtXtBcLV7QYy1e0GotXtBw7V7Qd+1e0H7tXtBF7Z7QTO2e0FOtntBarZ7QYa2e0GitntBvrZ7Qdm2e0H1tntBEbd7QS23e0FJt3tBZLd7QYC3e0Gct3tBuLd7QdS3e0Hvt3tBC7h7QSe4e0FDuHtBXrh7QXq4e0GWuHtBsrh7Qc64e0HpuHtBBbl7QSG5e0E9uXtBWLl7QXS5e0GQuXtBrLl7Qci5e0HjuXtB/7l7QRu6e0E3untBUrp7QW66e0GKuntBprp7QcK6e0HduntB+bp7QRW7e0Exu3tBTLt7QWi7e0GEu3tBoLt7Qby7e0HXu3tB87t7QQ+8e0ErvHtBRrx7QWK8e0F+vHtBmrx7QbW8e0HRvHtB7bx7QQm9e0ElvXtBQL17QVy9e0F4vXtBlL17Qa+9e0HLvXtB5717QQO+e0EevntBOr57QVa+e0FyvntBjb57Qam+e0HFvntB4b57Qfy+e0EYv3tBNL97QVC/e0Frv3tBh797QaO/e0G/v3tB2r97Qfa/e0ESwHtBLsB7QUnAe0FlwHtBgcB7QZ3Ae0G4wHtB1MB7QfDAe0EMwXtBJ8F7QUPBe0FfwXtBe8F7QZbBe0GywXtBzsF7QerBe0EFwntBIcJ7QT3Ce0FZwntBdMJ7QZDCe0GswntBx8J7QePCe0H/wntBG8N7QTbDe0FSw3tBbsN7QYrDe0Glw3tBwcN7Qd3De0H5w3tBFMR7QTDEe0FMxHtBZ8R7QYPEe0GfxHtBu8R7QdbEe0HyxHtBDsV7QSrFe0FFxXtBYcV7QX3Fe0GYxXtBtMV7QdDFe0HsxXtBB8Z7QSPGe0E/xntBW8Z7QXbGe0GSxntBrsZ7QcnGe0HlxntBAcd7QR3He0E4x3tBVMd7QXDHe0GLx3tBp8d7QcPHe0Hfx3tB+sd7QRbIe0EyyHtBTch7QWnIe0GFyHtBoch7QbzIe0HYyHtB9Mh7QQ/Je0EryXtBR8l7QWLJe0F+yXtBmsl7QbbJe0HRyXtB7cl7QQnKe0EkyntBQMp7QVzKe0F4yntBk8p7Qa/Ke0HLyntB5sp7QQLLe0Eey3tBOct7QVXLe0Fxy3tBjMt7QajLe0HEy3tB4Mt7QfvLe0EXzHtBM8x7QU7Me0FqzHtBhsx7QaHMe0G9zHtB2cx7QfTMe0EQzXtBLM17QUjNe0FjzXtBf817QZvNe0G2zXtB0s17Qe7Ne0EJzntBJc57QUHOe0FczntBeM57QZTOe0GvzntBy857QefOe0ECz3tBHs97QTrPe0FWz3tBcc97QY3Pe0Gpz3tBxM97QeDPe0H8z3tBF9B7QTPQe0FP0HtBatB7QYbQe0Gi0HtBvdB7QdnQe0H10HtBENF7QSzRe0FI0XtBY9F7QX/Re0Gb0XtBttF7QdLRe0Hu0XtBCdJ7QSXSe0FB0ntBXNJ7QXjSe0GU0ntBr9J7QcvSe0Hn0ntBAtN7QR7Te0E603tBVdN7QXHTe0GN03tBqNN7QcTTe0Hg03tB+9N7QRfUe0Ey1HtBTtR7QWrUe0GF1HtBodR7Qb3Ue0HY1HtB9NR7QRDVe0Er1XtBR9V7QWPVe0F+1XtBmtV7QbbVe0HR1XtB7dV7QQnWe0Ek1ntBQNZ7QVvWe0F31ntBk9Z7Qa7We0HK1ntB5tZ7QQHXe0Ed13tBOdd7QVTXe0Fw13tBjNd7QafXe0HD13tB3td7QfrXe0EW2HtBMdh7QU3Ye0Fp2HtBhNh7QaDYe0G82HtB19h7QfPYe0EO2XtBKtl7QUbZe0Fh2XtBfdl7QZnZe0G02XtB0Nl7QevZe0EH2ntBI9p7QT7ae0Fa2ntBdtp7QZHae0Gt2ntByNp7QeTae0EA23tBG9t7QTfbe0FT23tBbtt7QYrbe0Gl23tBwdt7Qd3be0H423tBFNx7QTDce0FL3HtBZ9x7QYLce0Ge3HtButx7QdXce0Hx3HtBDN17QSjde0FE3XtBX917QXvde0GX3XtBst17Qc7de0Hp3XtBBd57QSHee0E83ntBWN57QXPee0GP3ntBq957Qcbee0Hi3ntB/d57QRnfe0E133tBUN97QWzfe0GH33tBo997Qb/fe0Ha33tB9t97QRHge0Et4HtBSeB7QWTge0GA4HtBm+B7Qbfge0HT4HtB7uB7QQrhe0El4XtBQeF7QV3he0F44XtBlOF7Qa/he0HL4XtB5+F7QQLie0Ee4ntBOeJ7QVXie0Fx4ntBjOJ7Qajie0HD4ntB3+J7Qfrie0EW43tBMuN7QU3je0Fp43tBhON7QaDje0G843tB1+N7QfPje0EO5HtBKuR7QUXke0Fh5HtBfeR7QZjke0G05HtBz+R7Qevke0EH5XtBIuV7QT7le0FZ5XtBdeV7QZDle0Gs5XtByOV7QePle0H/5XtBGuZ7QTbme0FR5ntBbeZ7QYnme0Gk5ntBwOZ7Qdvme0H35ntBEud7QS7ne0FJ53tBZed7QYHne0Gc53tBuOd7QdPne0Hv53tBCuh7QSboe0FC6HtBXeh7QXnoe0GU6HtBsOh7Qcvoe0Hn6HtBAul7QR7pe0E66XtBVel7QXHpe0GM6XtBqOl7QcPpe0Hf6XtB+ul7QRbqe0Ey6ntBTep7QWnqe0GE6ntBoOp7Qbvqe0HX6ntB8up7QQ7re0Eq63tBRet7QWHre0F863tBmOt7QbPre0HP63tB6ut7QQbse0Eh7HtBPex7QVnse0F07HtBkOx7Qavse0HH7HtB4ux7Qf7se0EZ7XtBNe17QVDte0Fs7XtBh+17QaPte0G/7XtB2u17Qfbte0ER7ntBLe57QUjue0Fk7ntBf+57QZvue0G27ntB0u57Qe3ue0EJ73tBJO97QUDve0Fc73tBd+97QZPve0Gu73tByu97QeXve0EB8HtBHPB7QTjwe0FT8HtBb/B7QYrwe0Gm8HtBwfB7Qd3we0H48HtBFPF7QS/xe0FL8XtBZvF7QYLxe0Gd8XtBufF7QdXxe0Hw8XtBDPJ7QSfye0FD8ntBXvJ7QXrye0GV8ntBsfJ7Qczye0Ho8ntBA/N7QR/ze0E683tBVvN7QXHze0GN83tBqPN7QcTze0Hf83tB+/N7QRb0e0Ey9HtBTfR7QWn0e0GE9HtBoPR7Qbv0e0HX9HtB8vR7QQ71e0Ep9XtBRfV7QWD1e0F89XtBl/V7QbP1e0HO9XtB6vV7QQX2e0Eh9ntBPPZ7QVj2e0Fz9ntBj/Z7Qar2e0HG9ntB4fZ7Qf32e0EY93tBNPd7QU/3e0Fr93tBhvd7QaL3e0G993tB2fd7QfT3e0EQ+HtBK/h7QUf4e0Fi+HtBfvh7QZn4e0G1+HtB0Ph7Qez4e0EH+XtBIvl7QT75e0FZ+XtBdfl7QZD5e0Gs+XtBx/l7QeP5e0H++XtBGvp7QTX6e0FR+ntBbPp7QYj6e0Gj+ntBv/p7Qdr6e0H2+ntBEft7QS37e0FI+3tBZPt7QX/7e0Ga+3tBtvt7QdH7e0Ht+3tBCPx7QST8e0E//HtBW/x7QXb8e0GS/HtBrfx7Qcn8e0Hk/HtBAP17QRv9e0E2/XtBUv17QW39e0GJ/XtBpP17QcD9e0Hb/XtB9/17QRL+e0Eu/ntBSf57QWX+e0GA/ntBm/57Qbf+e0HS/ntB7v57QQn/e0El/3tBQP97QVz/e0F3/3tBk/97Qa7/e0HJ/3tB5f97QQAAfEEcAHxBNwB8QVMAfEFuAHxBigB8QaUAfEHAAHxB3AB8QfcAfEETAXxBLgF8QUoBfEFlAXxBgQF8QZwBfEG3AXxB0wF8Qe4BfEEKAnxBJQJ8QUECfEFcAnxBeAJ8QZMCfEGuAnxBygJ8QeUCfEEBA3xBHAN8QTgDfEFTA3xBbwN8QYoDfEGlA3xBwQN8QdwDfEH4A3xBEwR8QS8EfEFKBHxBZQR8QYEEfEGcBHxBuAR8QdMEfEHvBHxBCgV8QSUFfEFBBXxBXAV8QXgFfEGTBXxBrwV8QcoFfEHlBXxBAQZ8QRwGfEE4BnxBUwZ8QW4GfEGKBnxBpQZ8QcEGfEHcBnxB+AZ8QRMHfEEuB3xBSgd8QWUHfEGBB3xBnAd8QbcHfEHTB3xB7gd8QQoIfEElCHxBQQh8QVwIfEF3CHxBkwh8Qa4IfEHKCHxB5Qh8QQAJfEEcCXxBNwl8QVMJfEFuCXxBiQl8QaUJfEHACXxB3Al8QfcJfEETCnxBLgp8QUkKfEFlCnxBgAp8QZwKfEG3CnxB0gp8Qe4KfEEJC3xBJQt8QUALfEFbC3xBdwt8QZILfEGuC3xByQt8QeQLfEEADHxBGwx8QTYMfEFSDHxBbQx8QYkMfEGkDHxBvwx8QdsMfEH2DHxBEg18QS0NfEFIDXxBZA18QX8NfEGbDXxBtg18QdENfEHtDXxBCA58QSMOfEE/DnxBWg58QXYOfEGRDnxBrA58QcgOfEHjDnxB/w58QRoPfEE1D3xBUQ98QWwPfEGHD3xBow98Qb4PfEHaD3xB9Q98QRAQfEEsEHxBRxB8QWIQfEF+EHxBmRB8QbUQfEHQEHxB6xB8QQcRfEEiEXxBPRF8QVkRfEF0EXxBkBF8QasRfEHGEXxB4hF8Qf0RfEEYEnxBNBJ8QU8SfEFqEnxBhhJ8QaESfEG9EnxB2BJ8QfMSfEEPE3xBKhN8QUUTfEFhE3xBfBN8QZcTfEGzE3xBzhN8QeoTfEEFFHxBIBR8QTwUfEFXFHxBchR8QY4UfEGpFHxBxBR8QeAUfEH7FHxBFhV8QTIVfEFNFXxBaRV8QYQVfEGfFXxBuxV8QdYVfEHxFXxBDRZ8QSgWfEFDFnxBXxZ8QXoWfEGVFnxBsRZ8QcwWfEHnFnxBAxd8QR4XfEE5F3xBVRd8QXAXfEGLF3xBpxd8QcIXfEHdF3xB+Rd8QRQYfEEvGHxBSxh8QWYYfEGCGHxBnRh8QbgYfEHUGHxB7xh8QQoZfEEmGXxBQRl8QVwZfEF4GXxBkxl8Qa4ZfEHKGXxB5Rl8QQAafEEcGnxBNxp8QVIafEFtGnxBiRp8QaQafEG/GnxB2xp8QfYafEERG3xBLRt8QUgbfEFjG3xBfxt8QZobfEG1G3xB0Rt8QewbfEEHHHxBIxx8QT4cfEFZHHxBdRx8QZAcfEGrHHxBxxx8QeIcfEH9HHxBGR18QTQdfEFPHXxBah18QYYdfEGhHXxBvB18QdgdfEHzHXxBDh58QSoefEFFHnxBYB58QXwefEGXHnxBsh58Qc4efEHpHnxBBB98QR8ffEE7H3xBVh98QXEffEGNH3xBqB98QcMffEHfH3xB+h98QRUgfEEwIHxBTCB8QWcgfEGCIHxBniB8QbkgfEHUIHxB8CB8QQshfEEmIXxBQSF8QV0hfEF4IXxBkyF8Qa8hfEHKIXxB5SF8QQEifEEcInxBNyJ8QVIifEFuInxBiSJ8QaQifEHAInxB2yJ8QfYifEERI3xBLSN8QUgjfEFjI3xBfyN8QZojfEG1I3xB0CN8QewjfEEHJHxBIiR8QT4kfEFZJHxBdCR8QY8kfEGrJHxBxiR8QeEkfEH9JHxBGCV8QTMlfEFOJXxBaiV8QYUlfEGgJXxBvCV8QdclfEHyJXxBDSZ8QSkmfEFEJnxBXyZ8QXomfEGWJnxBsSZ8QcwmfEHoJnxBAyd8QR4nfEE5J3xBVSd8QXAnfEGLJ3xBpid8QcInfEHdJ3xB+Cd8QRMofEEvKHxBSih8QWUofEGBKHxBnCh8QbcofEHSKHxB7ih8QQkpfEEkKXxBPyl8QVspfEF2KXxBkSl8QawpfEHIKXxB4yl8Qf4pfEEZKnxBNSp8QVAqfEFrKnxBhip8QaIqfEG9KnxB2Cp8QfMqfEEPK3xBKit8QUUrfEFgK3xBfCt8QZcrfEGyK3xBzSt8QekrfEEELHxBHyx8QTosfEFWLHxBcSx8QYwsfEGnLHxBwyx8Qd4sfEH5LHxBFC18QTAtfEFLLXxBZi18QYEtfEGdLXxBuC18QdMtfEHuLXxBCi58QSUufEFALnxBWy58QXYufEGSLnxBrS58QcgufEHjLnxB/y58QRovfEE1L3xBUC98QWwvfEGHL3xBoi98Qb0vfEHYL3xB9C98QQ8wfEEqMHxBRTB8QWEwfEF8MHxBlzB8QbIwfEHOMHxB6TB8QQQxfEEfMXxBOjF8QVYxfEFxMXxBjDF8QacxfEHDMXxB3jF8QfkxfEEUMnxBLzJ8QUsyfEFmMnxBgTJ8QZwyfEG4MnxB0zJ8Qe4yfEEJM3xBJDN8QUAzfEFbM3xBdjN8QZEzfEGsM3xByDN8QeMzfEH+M3xBGTR8QTQ0fEFQNHxBazR8QYY0fEGhNHxBvTR8Qdg0fEHzNHxBDjV8QSk1fEFFNXxBYDV8QXs1fEGWNXxBsTV8Qc01fEHoNXxBAzZ8QR42fEE5NnxBVTZ8QXA2fEGLNnxBpjZ8QcE2fEHdNnxB+DZ8QRM3fEEuN3xBSTd8QWU3fEGAN3xBmzd8QbY3fEHRN3xB7Td8QQg4fEEjOHxBPjh8QVk4fEF0OHxBkDh8Qas4fEHGOHxB4Th8Qfw4fEEYOXxBMzl8QU45fEFpOXxBhDl8QaA5fEG7OXxB1jl8QfE5fEEMOnxBJzp8QUM6fEFeOnxBeTp8QZQ6fEGvOnxByzp8QeY6fEEBO3xBHDt8QTc7fEFSO3xBbjt8QYk7fEGkO3xBvzt8Qdo7fEH1O3xBETx8QSw8fEFHPHxBYjx8QX08fEGYPHxBtDx8Qc88fEHqPHxBBT18QSA9fEE7PXxBVz18QXI9fEGNPXxBqD18QcM9fEHePXxB+j18QRU+fEEwPnxBSz58QWY+fEGBPnxBnT58Qbg+fEHTPnxB7j58QQk/fEEkP3xBQD98QVs/fEF2P3xBkT98Qaw/fEHHP3xB4z98Qf4/fEEZQHxBNEB8QU9AfEFqQHxBhUB8QaFAfEG8QHxB10B8QfJAfEENQXxBKEF8QURBfEFfQXxBekF8QZVBfEGwQXxBy0F8QeZBfEECQnxBHUJ8QThCfEFTQnxBbkJ8QYlCfEGkQnxBwEJ8QdtCfEH2QnxBEUN8QSxDfEFHQ3xBYkN8QX5DfEGZQ3xBtEN8Qc9DfEHqQ3xBBUR8QSBEfEE8RHxBV0R8QXJEfEGNRHxBqER8QcNEfEHeRHxB+UR8QRVFfEEwRXxBS0V8QWZFfEGBRXxBnEV8QbdFfEHSRXxB7kV8QQlGfEEkRnxBP0Z8QVpGfEF1RnxBkEZ8QatGfEHHRnxB4kZ8Qf1GfEEYR3xBM0d8QU5HfEFpR3xBhEd8QaBHfEG7R3xB1kd8QfFHfEEMSHxBJ0h8QUJIfEFdSHxBeUh8QZRIfEGvSHxBykh8QeVIfEEASXxBG0l8QTZJfEFRSXxBbUl8QYhJfEGjSXxBvkl8QdlJfEH0SXxBD0p8QSpKfEFFSnxBYUp8QXxKfEGXSnxBskp8Qc1KfEHoSnxBA0t8QR5LfEE5S3xBVEt8QXBLfEGLS3xBpkt8QcFLfEHcS3xB90t8QRJMfEEtTHxBSEx8QWNMfEF/THxBmkx8QbVMfEHQTHxB60x8QQZNfEEhTXxBPE18QVdNfEFyTXxBjk18QalNfEHETXxB3018QfpNfEEVTnxBME58QUtOfEFmTnxBgU58QZxOfEG4TnxB0058Qe5OfEEJT3xBJE98QT9PfEFaT3xBdU98QZBPfEGrT3xBxk98QeFPfEH9T3xBGFB8QTNQfEFOUHxBaVB8QYRQfEGfUHxBulB8QdVQfEHwUHxBC1F8QSZRfEFBUXxBXVF8QXhRfEGTUXxBrlF8QclRfEHkUXxB/1F8QRpSfEE1UnxBUFJ8QWtSfEGGUnxBoVJ8QbxSfEHYUnxB81J8QQ5TfEEpU3xBRFN8QV9TfEF6U3xBlVN8QbBTfEHLU3xB5lN8QQFUfEEcVHxBN1R8QVJUfEFuVHxBiVR8QaRUfEG/VHxB2lR8QfVUfEEQVXxBK1V8QUZVfEFhVXxBfFV8QZdVfEGyVXxBzVV8QehVfEEDVnxBHlZ8QTpWfEFVVnxBcFZ8QYtWfEGmVnxBwVZ8QdxWfEH3VnxBEld8QS1XfEFIV3xBY1d8QX5XfEGZV3xBtFd8Qc9XfEHqV3xBBVh8QSBYfEE7WHxBVlh8QXJYfEGNWHxBqFh8QcNYfEHeWHxB+Vh8QRRZfEEvWXxBSll8QWVZfEGAWXxBm1l8QbZZfEHRWXxB7Fl8QQdafEEiWnxBPVp8QVhafEFzWnxBjlp8QalafEHEWnxB31p8QfpafEEVW3xBMFt8QUtbfEFnW3xBglt8QZ1bfEG4W3xB01t8Qe5bfEEJXHxBJFx8QT9cfEFaXHxBdVx8QZBcfEGrXHxBxlx8QeFcfEH8XHxBF118QTJdfEFNXXxBaF18QYNdfEGeXXxBuV18QdRdfEHvXXxBCl58QSVefEFAXnxBW158QXZefEGRXnxBrF58QcdefEHiXnxB/V58QRhffEEzX3xBTl98QWlffEGEX3xBn198QbpffEHVX3xB8F98QQtgfEEmYHxBQWB8QVxgfEF3YHxBkmB8Qa1gfEHIYHxB42B8Qf5gfEEZYXxBNGF8QU9hfEFqYXxBhWF8QaBhfEG7YXxB1mF8QfFhfEEMYnxBJ2J8QUJifEFdYnxBeGJ8QZNifEGuYnxByWJ8QeRifEH/YnxBGmN8QTVjfEFQY3xBa2N8QYZjfEGhY3xBvGN8QddjfEHyY3xBDWR8QShkfEFDZHxBXmR8QXlkfEGUZHxBr2R8QcpkfEHlZHxBAGV8QRtlfEE2ZXxBUWV8QWxlfEGHZXxBomV8Qb1lfEHYZXxB82V8QQ5mfEEpZnxBRGZ8QV9mfEF6ZnxBlWZ8QbBmfEHLZnxB5mZ8QQFnfEEcZ3xBN2d8QVJnfEFtZ3xBiGd8QaNnfEG+Z3xB2Wd8QfRnfEEPaHxBKmh8QUVofEFfaHxBemh8QZVofEGwaHxBy2h8QeZofEEBaXxBHGl8QTdpfEFSaXxBbWl8QYhpfEGjaXxBvml8QdlpfEH0aXxBD2p8QSpqfEFFanxBYGp8QXtqfEGWanxBsWp8QcxqfEHnanxBAmt8QR1rfEE3a3xBUmt8QW1rfEGIa3xBo2t8Qb5rfEHZa3xB9Gt8QQ9sfEEqbHxBRWx8QWBsfEF7bHxBlmx8QbFsfEHMbHxB52x8QQJtfEEdbXxBOG18QVNtfEFtbXxBiG18QaNtfEG+bXxB2W18QfRtfEEPbnxBKm58QUVufEFgbnxBe258QZZufEGxbnxBzG58QedufEECb3xBHW98QThvfEFSb3xBbW98QYhvfEGjb3xBvm98QdlvfEH0b3xBD3B8QSpwfEFFcHxBYHB8QXtwfEGWcHxBsXB8QcxwfEHmcHxBAXF8QRxxfEE3cXxBUnF8QW1xfEGIcXxBo3F8Qb5xfEHZcXxB9HF8QQ9yfEEqcnxBRXJ8QV9yfEF6cnxBlXJ8QbByfEHLcnxB5nJ8QQFzfEEcc3xBN3N8QVJzfEFtc3xBiHN8QaNzfEG9c3xB2HN8QfNzfEEOdHxBKXR8QUR0fEFfdHxBenR8QZV0fEGwdHxBy3R8QeZ0fEEAdXxBG3V8QTZ1fEFRdXxBbHV8QYd1fEGidXxBvXV8Qdh1fEHzdXxBDnZ8QSh2fEFDdnxBXnZ8QXl2fEGUdnxBr3Z8Qcp2fEHldnxBAHd8QRt3fEE1d3xBUHd8QWt3fEGGd3xBoXd8Qbx3fEHXd3xB8nd8QQ14fEEoeHxBQnh8QV14fEF4eHxBk3h8Qa54fEHJeHxB5Hh8Qf94fEEaeXxBNXl8QU95fEFqeXxBhXl8QaB5fEG7eXxB1nl8QfF5fEEMenxBJ3p8QUF6fEFcenxBd3p8QZJ6fEGtenxByHp8QeN6fEH+enxBGXt8QTN7fEFOe3xBaXt8QYR7fEGfe3xBunt8QdV7fEHwe3xBCnx8QSV8fEFAfHxBW3x8QXZ8fEGRfHxBrHx8Qcd8fEHifHxB/Hx8QRd9fEEyfXxBTX18QWh9fEGDfXxBnn18Qbl9fEHTfXxB7n18QQl+fEEkfnxBP358QVp+fEF1fnxBj358Qap+fEHFfnxB4H58Qft+fEEWf3xBMX98QUx/fEFmf3xBgX98QZx/fEG3f3xB0n98Qe1/fEEIgHxBIoB8QT2AfEFYgHxBc4B8QY6AfEGpgHxBxIB8Qd6AfEH5gHxBFIF8QS+BfEFKgXxBZYF8QYCBfEGagXxBtYF8QdCBfEHrgXxBBoJ8QSGCfEE8gnxBVoJ8QXGCfEGMgnxBp4J8QcKCfEHdgnxB+IJ8QRKDfEEtg3xBSIN8QWODfEF+g3xBmYN8QbODfEHOg3xB6YN8QQSEfEEfhHxBOoR8QVWEfEFvhHxBioR8QaWEfEHAhHxB24R8QfaEfEEQhXxBK4V8QUaFfEFhhXxBfIV8QZeFfEGxhXxBzIV8QeeFfEEChnxBHYZ8QTiGfEFShnxBbYZ8QYiGfEGjhnxBvoZ8QdmGfEHzhnxBDod8QSmHfEFEh3xBX4d8QXqHfEGUh3xBr4d8QcqHfEHlh3xBAIh8QRuIfEE1iHxBUIh8QWuIfEGGiHxBoYh8QbyIfEHWiHxB8Yh8QQyJfEEniXxBQol8QVyJfEF3iXxBkol8Qa2JfEHIiXxB44l8Qf2JfEEYinxBM4p8QU6KfEFpinxBg4p8QZ6KfEG5inxB1Ip8Qe+KfEEKi3xBJIt8QT+LfEFai3xBdYt8QZCLfEGqi3xBxYt8QeCLfEH7i3xBFox8QTCMfEFLjHxBZox8QYGMfEGcjHxBtox8QdGMfEHsjHxBB418QSKNfEE8jXxBV418QXKNfEGNjXxBqI18QcKNfEHdjXxB+I18QROOfEEujnxBSI58QWOOfEF+jnxBmY58QbSOfEHOjnxB6Y58QQSPfEEfj3xBOo98QVSPfEFvj3xBio98QaWPfEHAj3xB2o98QfWPfEEQkHxBK5B8QUaQfEFgkHxBe5B8QZaQfEGxkHxBy5B8QeaQfEEBkXxBHJF8QTeRfEFRkXxBbJF8QYeRfEGikXxBvZF8QdeRfEHykXxBDZJ8QSiSfEFCknxBXZJ8QXiSfEGTknxBrpJ8QciSfEHjknxB/pJ8QRmTfEEzk3xBTpN8QWmTfEGEk3xBn5N8QbmTfEHUk3xB75N8QQqUfEEklHxBP5R8QVqUfEF1lHxBj5R8QaqUfEHFlHxB4JR8QfuUfEEVlXxBMJV8QUuVfEFmlXxBgJV8QZuVfEG2lXxB0ZV8QeuVfEEGlnxBIZZ8QTyWfEFWlnxBcZZ8QYyWfEGnlnxBwpZ8QdyWfEH3lnxBEpd8QS2XfEFHl3xBYpd8QX2XfEGYl3xBspd8Qc2XfEHol3xBA5h8QR2YfEE4mHxBU5h8QW6YfEGImHxBo5h8Qb6YfEHZmHxB85h8QQ6ZfEEpmXxBRJl8QV6ZfEF5mXxBlJl8Qa+ZfEHJmXxB5Jl8Qf+ZfEEamnxBNJp8QU+afEFqmnxBhZp8QZ+afEG6mnxB1Zp8Qe+afEEKm3xBJZt8QUCbfEFam3xBdZt8QZCbfEGrm3xBxZt8QeCbfEH7m3xBFpx8QTCcfEFLnHxBZpx8QYGcfEGbnHxBtpx8QdGcfEHrnHxBBp18QSGdfEE8nXxBVp18QXGdfEGMnXxBp518QcGdfEHcnXxB9518QRGefEEsnnxBR558QWKefEF8nnxBl558QbKefEHNnnxB5558QQKffEEdn3xBN598QVKffEFtn3xBiJ98QaKffEG9n3xB2J98QfKffEENoHxBKKB8QUOgfEFdoHxBeKB8QZOgfEGtoHxByKB8QeOgfEH+oHxBGKF8QTOhfEFOoXxBaKF8QYOhfEGeoXxBuaF8QdOhfEHuoXxBCaJ8QSOifEE+onxBWaJ8QXSifEGOonxBqaJ8QcSifEHeonxB+aJ8QRSjfEEvo3xBSaN8QWSjfEF/o3xBmaN8QbSjfEHPo3xB6aN8QQSkfEEfpHxBOqR8QVSkfEFvpHxBiqR8QaSkfEG/pHxB2qR8QfSkfEEPpXxBKqV8QUSlfEFfpXxBeqV8QZWlfEGvpXxByqV8QeWlfEH/pXxBGqZ8QTWmfEFPpnxBaqZ8QYWmfEGfpnxBuqZ8QdWmfEHwpnxBCqd8QSWnfEFAp3xBWqd8QXWnfEGQp3xBqqd8QcWnfEHgp3xB+qd8QRWofEEwqHxBSqh8QWWofEGAqHxBmqh8QbWofEHQqHxB6qh8QQWpfEEgqXxBOql8QVWpfEFwqXxBi6l8QaWpfEHAqXxB26l8QfWpfEEQqnxBK6p8QUWqfEFgqnxBe6p8QZWqfEGwqnxBy6p8QeWqfEEAq3xBG6t8QTWrfEFQq3xBa6t8QYWrfEGgq3xBu6t8QdWrfEHwq3xBC6x8QSWsfEFArHxBW6x8QXWsfEGQrHxBq6x8QcWsfEHgrHxB+qx8QRWtfEEwrXxBSq18QWWtfEGArXxBmq18QbWtfEHQrXxB6q18QQWufEEgrnxBOq58QVWufEFwrnxBiq58QaWufEHArnxB2q58QfWufEEQr3xBKq98QUWvfEFgr3xBeq98QZWvfEGvr3xByq98QeWvfEH/r3xBGrB8QTWwfEFPsHxBarB8QYWwfEGfsHxBurB8QdWwfEHvsHxBCrF8QSSxfEE/sXxBWrF8QXSxfEGPsXxBqrF8QcSxfEHfsXxB+rF8QRSyfEEvsnxBSbJ8QWSyfEF/snxBmbJ8QbSyfEHPsnxB6bJ8QQSzfEEfs3xBObN8QVSzfEFus3xBibN8QaSzfEG+s3xB2bN8QfSzfEEOtHxBKbR8QUO0fEFetHxBebR8QZO0fEGutHxBybR8QeO0fEH+tHxBGLV8QTO1fEFOtXxBaLV8QYO1fEGetXxBuLV8QdO1fEHttXxBCLZ8QSO2fEE9tnxBWLZ8QXK2fEGNtnxBqLZ8QcK2fEHdtnxB+LZ8QRK3fEEtt3xBR7d8QWK3fEF9t3xBl7d8QbK3fEHMt3xB57d8QQK4fEEcuHxBN7h8QVK4fEFsuHxBh7h8QaG4fEG8uHxB17h8QfG4fEEMuXxBJrl8QUG5fEFcuXxBdrl8QZG5fEGruXxBxrl8QeG5fEH7uXxBFrp8QTC6fEFLunxBZrp8QYC6fEGbunxBtbp8QdC6fEHrunxBBbt8QSC7fEE6u3xBVbt8QXC7fEGKu3xBpbt8Qb+7fEHau3xB9Lt8QQ+8fEEqvHxBRLx8QV+8fEF5vHxBlLx8Qa+8fEHJvHxB5Lx8Qf68fEEZvXxBNL18QU69fEFpvXxBg718QZ69fEG4vXxB0718Qe69fEEIvnxBI758QT2+fEFYvnxBc758QY2+fEGovnxBwr58Qd2+fEH3vnxBEr98QS2/fEFHv3xBYr98QXy/fEGXv3xBsb98Qcy/fEHnv3xBAcB8QRzAfEE2wHxBUcB8QWvAfEGGwHxBocB8QbvAfEHWwHxB8MB8QQvBfEElwXxBQMF8QVvBfEF1wXxBkMF8QarBfEHFwXxB38F8QfrBfEEVwnxBL8J8QUrCfEFkwnxBf8J8QZnCfEG0wnxBzsJ8QenCfEEEw3xBHsN8QTnDfEFTw3xBbsN8QYjDfEGjw3xBvsN8QdjDfEHzw3xBDcR8QSjEfEFCxHxBXcR8QXfEfEGSxHxBrcR8QcfEfEHixHxB/MR8QRfFfEExxXxBTMV8QWbFfEGBxXxBm8V8QbbFfEHRxXxB68V8QQbGfEEgxnxBO8Z8QVXGfEFwxnxBisZ8QaXGfEG/xnxB2sZ8QfXGfEEPx3xBKsd8QUTHfEFfx3xBecd8QZTHfEGux3xBycd8QePHfEH+x3xBGMh8QTPIfEFOyHxBaMh8QYPIfEGdyHxBuMh8QdLIfEHtyHxBB8l8QSLJfEE8yXxBV8l8QXHJfEGMyXxBpsl8QcHJfEHcyXxB9sl8QRHKfEErynxBRsp8QWDKfEF7ynxBlcp8QbDKfEHKynxB5cp8Qf/KfEEay3xBNMt8QU/LfEFpy3xBhMt8QZ7LfEG5y3xB08t8Qe7LfEEJzHxBI8x8QT7MfEFYzHxBc8x8QY3MfEGozHxBwsx8Qd3MfEH3zHxBEs18QSzNfEFHzXxBYc18QXzNfEGWzXxBsc18QcvNfEHmzXxBAM58QRvOfEE1znxBUM58QWrOfEGFznxBn858QbrOfEHUznxB7858QQnPfEEkz3xBPs98QVnPfEFzz3xBjs98QajPfEHDz3xB3c98QfjPfEES0HxBLdB8QUfQfEFi0HxBfNB8QZfQfEGx0HxBzNB8QebQfEEB0XxBG9F8QTbRfEFQ0XxBa9F8QYXRfEGg0XxButF8QdXRfEHv0XxBCtJ8QSTSfEE/0nxBWdJ8QXTSfEGO0nxBqdJ8QcPSfEHe0nxB+NJ8QRPTfEEt03xBSNN8QWLTfEF903xBl9N8QbLTfEHM03xB59N8QQHUfEEc1HxBNtR8QVHUfEFr1HxBhtR8QaDUfEG61HxB1dR8Qe/UfEEK1XxBJNV8QT/VfEFZ1XxBdNV8QY7VfEGp1XxBw9V8Qd7VfEH41XxBE9Z8QS3WfEFI1nxBYtZ8QX3WfEGX1nxBstZ8QczWfEHm1nxBAdd8QRvXfEE213xBUNd8QWvXfEGF13xBoNd8QbrXfEHV13xB79d8QQrYfEEk2HxBP9h8QVnYfEFz2HxBjth8QajYfEHD2HxB3dh8QfjYfEES2XxBLdl8QUfZfEFi2XxBfNl8QZfZfEGx2XxBy9l8QebZfEEA2nxBG9p8QTXafEFQ2nxBatp8QYXafEGf2nxButp8QdTafEHu2nxBCdt8QSPbfEE+23xBWNt8QXPbfEGN23xBqNt8QcLbfEHc23xB99t8QRHcfEEs3HxBRtx8QWHcfEF73HxBltx8QbDcfEHL3HxB5dx8Qf/cfEEa3XxBNN18QU/dfEFp3XxBhN18QZ7dfEG43XxB0918Qe3dfEEI3nxBIt58QT3efEFX3nxBct58QYzefEGm3nxBwd58QdvefEH23nxBEN98QSvffEFF33xBX998QXrffEGU33xBr998QcnffEHk33xB/t98QRjgfEEz4HxBTeB8QWjgfEGC4HxBneB8QbfgfEHR4HxB7OB8QQbhfEEh4XxBO+F8QVbhfEFw4XxBiuF8QaXhfEG/4XxB2uF8QfThfEEP4nxBKeJ8QUPifEFe4nxBeOJ8QZPifEGt4nxBx+J8QeLifEH84nxBF+N8QTHjfEFM43xBZuN8QYDjfEGb43xBteN8QdDjfEHq43xBBOR8QR/kfEE55HxBVOR8QW7kfEGJ5HxBo+R8Qb3kfEHY5HxB8uR8QQ3lfEEn5XxBQeV8QVzlfEF25XxBkeV8QavlfEHF5XxB4OV8QfrlfEEV5nxBL+Z8QUnmfEFk5nxBfuZ8QZnmfEGz5nxBzeZ8QejmfEEC53xBHed8QTfnfEFR53xBbOd8QYbnfEGh53xBu+d8QdXnfEHw53xBCuh8QSXofEE/6HxBWeh8QXTofEGO6HxBqeh8QcPofEHd6HxB+Oh8QRLpfEEs6XxBR+l8QWHpfEF86XxBlul8QbDpfEHL6XxB5el8QQDqfEEa6nxBNOp8QU/qfEFp6nxBg+p8QZ7qfEG46nxB0+p8Qe3qfEEH63xBIut8QTzrfEFX63xBcet8QYvrfEGm63xBwOt8QdrrfEH163xBD+x8QSrsfEFE7HxBXux8QXnsfEGT7HxBrex8QcjsfEHi7HxB/ex8QRftfEEx7XxBTO18QWbtfEGA7XxBm+18QbXtfEHP7XxB6u18QQTufEEf7nxBOe58QVPufEFu7nxBiO58QaLufEG97nxB1+58QfHufEEM73xBJu98QUHvfEFb73xBde98QZDvfEGq73xBxO98Qd/vfEH573xBE/B8QS7wfEFI8HxBY/B8QX3wfEGX8HxBsvB8QczwfEHm8HxBAfF8QRvxfEE18XxBUPF8QWrxfEGE8XxBn/F8QbnxfEHT8XxB7vF8QQjyfEEj8nxBPfJ8QVfyfEFy8nxBjPJ8QabyfEHB8nxB2/J8QfXyfEEQ83xBKvN8QUTzfEFf83xBefN8QZPzfEGu83xByPN8QeLzfEH983xBF/R8QTH0fEFM9HxBZvR8QYD0fEGb9HxBtfR8Qc/0fEHq9HxBBPV8QR71fEE59XxBU/V8QW31fEGI9XxBovV8Qbz1fEHX9XxB8fV8QQv2fEEm9nxBQPZ8QVr2fEF19nxBj/Z8Qan2fEHE9nxB3vZ8Qfj2fEET93xBLfd8QUf3fEFi93xBfPd8QZb3fEGx93xBy/d8QeX3fEEA+HxBGvh8QTT4fEFP+HxBafh8QYP4fEGe+HxBuPh8QdL4fEHt+HxBB/l8QSH5fEE7+XxBVvl8QXD5fEGK+XxBpfl8Qb/5fEHZ+XxB9Pl8QQ76fEEo+nxBQ/p8QV36fEF3+nxBkvp8Qaz6fEHG+nxB4Pp8Qfv6fEEV+3xBL/t8QUr7fEFk+3xBfvt8QZn7fEGz+3xBzft8Qej7fEEC/HxBHPx8QTb8fEFR/HxBa/x8QYX8fEGg/HxBuvx8QdT8fEHv/HxBCf18QSP9fEE9/XxBWP18QXL9fEGM/XxBp/18QcH9fEHb/XxB9v18QRD+fEEq/nxBRP58QV/+fEF5/nxBk/58Qa7+fEHI/nxB4v58Qf3+fEEX/3xBMf98QUv/fEFm/3xBgP98QZr/fEG1/3xBz/98Qen/fEEDAH1BHgB9QTgAfUFSAH1BbQB9QYcAfUGhAH1BuwB9QdYAfUHwAH1BCgF9QSUBfUE/AX1BWQF9QXMBfUGOAX1BqAF9QcIBfUHcAX1B9wF9QRECfUErAn1BRgJ9QWACfUF6An1BlAJ9Qa8CfUHJAn1B4wJ9Qf4CfUEYA31BMgN9QUwDfUFnA31BgQN9QZsDfUG1A31B0AN9QeoDfUEEBH1BHwR9QTkEfUFTBH1BbQR9QYgEfUGiBH1BvAR9QdYEfUHxBH1BCwV9QSUFfUE/BX1BWgV9QXQFfUGOBX1BqAV9QcMFfUHdBX1B9wV9QRIGfUEsBn1BRgZ9QWAGfUF7Bn1BlQZ9Qa8GfUHJBn1B5AZ9Qf4GfUEYB31BMgd9QU0HfUFnB31BgQd9QZsHfUG2B31B0Ad9QeoHfUEECH1BHwh9QTkIfUFTCH1BbQh9QYgIfUGiCH1BvAh9QdYIfUHxCH1BCwl9QSUJfUE/CX1BWgl9QXQJfUGOCX1BqAl9QcMJfUHdCX1B9wl9QREKfUEsCn1BRgp9QWAKfUF6Cn1BlQp9Qa8KfUHJCn1B4wp9Qf0KfUEYC31BMgt9QUwLfUFmC31BgQt9QZsLfUG1C31Bzwt9QeoLfUEEDH1BHgx9QTgMfUFTDH1BbQx9QYcMfUGhDH1Buwx9QdYMfUHwDH1BCg19QSQNfUE/DX1BWQ19QXMNfUGNDX1Bpw19QcINfUHcDX1B9g19QRAOfUErDn1BRQ59QV8OfUF5Dn1BlA59Qa4OfUHIDn1B4g59QfwOfUEXD31BMQ99QUsPfUFlD31Bfw99QZoPfUG0D31Bzg99QegPfUEDEH1BHRB9QTcQfUFREH1BaxB9QYYQfUGgEH1BuhB9QdQQfUHvEH1BCRF9QSMRfUE9EX1BVxF9QXIRfUGMEX1BphF9QcARfUHaEX1B9RF9QQ8SfUEpEn1BQxJ9QV0SfUF4En1BkhJ9QawSfUHGEn1B4BJ9QfsSfUEVE31BLxN9QUkTfUFjE31BfhN9QZgTfUGyE31BzBN9QeYTfUEBFH1BGxR9QTUUfUFPFH1BaRR9QYQUfUGeFH1BuBR9QdIUfUHsFH1BBxV9QSEVfUE7FX1BVRV9QW8VfUGKFX1BpBV9Qb4VfUHYFX1B8hV9QQ0WfUEnFn1BQRZ9QVsWfUF1Fn1BjxZ9QaoWfUHEFn1B3hZ9QfgWfUESF31BLRd9QUcXfUFhF31Bexd9QZUXfUGvF31Byhd9QeQXfUH+F31BGBh9QTIYfUFNGH1BZxh9QYEYfUGbGH1BtRh9Qc8YfUHqGH1BBBl9QR4ZfUE4GX1BUhl9QW0ZfUGHGX1BoRl9QbsZfUHVGX1B7xl9QQoafUEkGn1BPhp9QVgafUFyGn1BjBp9QacafUHBGn1B2xp9QfUafUEPG31BKRt9QUQbfUFeG31BeBt9QZIbfUGsG31Bxht9QeEbfUH7G31BFRx9QS8cfUFJHH1BYxx9QX4cfUGYHH1Bshx9QcwcfUHmHH1BAB19QRodfUE1HX1BTx19QWkdfUGDHX1BnR19QbcdfUHSHX1B7B19QQYefUEgHn1BOh59QVQefUFuHn1BiR59QaMefUG9Hn1B1x59QfEefUELH31BJh99QUAffUFaH31BdB99QY4ffUGoH31Bwh99Qd0ffUH3H31BESB9QSsgfUFFIH1BXyB9QXkgfUGUIH1BriB9QcggfUHiIH1B/CB9QRYhfUEwIX1BSyF9QWUhfUF/IX1BmSF9QbMhfUHNIX1B5yF9QQIifUEcIn1BNiJ9QVAifUFqIn1BhCJ9QZ4ifUG4In1B0yJ9Qe0ifUEHI31BISN9QTsjfUFVI31BbyN9QYojfUGkI31BviN9QdgjfUHyI31BDCR9QSYkfUFAJH1BWyR9QXUkfUGPJH1BqSR9QcMkfUHdJH1B9yR9QRElfUEsJX1BRiV9QWAlfUF6JX1BlCV9Qa4lfUHIJX1B4iV9QfwlfUEXJn1BMSZ9QUsmfUFlJn1BfyZ9QZkmfUGzJn1BzSZ9QegmfUECJ31BHCd9QTYnfUFQJ31Baid9QYQnfUGeJ31BuCd9QdMnfUHtJ31BByh9QSEofUE7KH1BVSh9QW8ofUGJKH1Boyh9Qb4ofUHYKH1B8ih9QQwpfUEmKX1BQCl9QVopfUF0KX1Bjil9QagpfUHDKX1B3Sl9QfcpfUERKn1BKyp9QUUqfUFfKn1BeSp9QZMqfUGtKn1ByCp9QeIqfUH8Kn1BFit9QTArfUFKK31BZCt9QX4rfUGYK31Bsit9QcwrfUHnK31BASx9QRssfUE1LH1BTyx9QWksfUGDLH1BnSx9QbcsfUHRLH1B6yx9QQYtfUEgLX1BOi19QVQtfUFuLX1BiC19QaItfUG8LX1B1i19QfAtfUEKLn1BJS59QT8ufUFZLn1Bcy59QY0ufUGnLn1BwS59QdsufUH1Ln1BDy99QSkvfUFDL31BXS99QXgvfUGSL31BrC99QcYvfUHgL31B+i99QRQwfUEuMH1BSDB9QWIwfUF8MH1BljB9QbAwfUHKMH1B5TB9Qf8wfUEZMX1BMzF9QU0xfUFnMX1BgTF9QZsxfUG1MX1BzzF9QekxfUEDMn1BHTJ9QTcyfUFRMn1BbDJ9QYYyfUGgMn1BujJ9QdQyfUHuMn1BCDN9QSIzfUE8M31BVjN9QXAzfUGKM31BpDN9Qb4zfUHYM31B8jN9QQ00fUEnNH1BQTR9QVs0fUF1NH1BjzR9Qak0fUHDNH1B3TR9Qfc0fUERNX1BKzV9QUU1fUFfNX1BeTV9QZM1fUGtNX1BxzV9QeE1fUH8NX1BFjZ9QTA2fUFKNn1BZDZ9QX42fUGYNn1BsjZ9Qcw2fUHmNn1BADd9QRo3fUE0N31BTjd9QWg3fUGCN31BnDd9QbY3fUHQN31B6jd9QQQ4fUEeOH1BODh9QVI4fUFtOH1Bhzh9QaE4fUG7OH1B1Th9Qe84fUEJOX1BIzl9QT05fUFXOX1BcTl9QYs5fUGlOX1Bvzl9Qdk5fUHzOX1BDTp9QSc6fUFBOn1BWzp9QXU6fUGPOn1BqTp9QcM6fUHdOn1B9zp9QRE7fUErO31BRTt9QV87fUF5O31Bkzt9Qa07fUHIO31B4jt9Qfw7fUEWPH1BMDx9QUo8fUFkPH1Bfjx9QZg8fUGyPH1BzDx9QeY8fUEAPX1BGj19QTQ9fUFOPX1BaD19QYI9fUGcPX1Btj19QdA9fUHqPX1BBD59QR4+fUE4Pn1BUj59QWw+fUGGPn1BoD59Qbo+fUHUPn1B7j59QQg/fUEiP31BPD99QVY/fUFwP31Bij99QaQ/fUG+P31B2D99QfI/fUEMQH1BJkB9QUBAfUFaQH1BdEB9QY5AfUGoQH1BwkB9QdxAfUH2QH1BEEF9QSpBfUFEQX1BXkF9QXhBfUGSQX1BrEF9QcZBfUHgQX1B+kF9QRRCfUEuQn1BSEJ9QWJCfUF8Qn1BlkJ9QbBCfUHKQn1B5EJ9Qf5CfUEYQ31BMkN9QUxDfUFmQ31BgEN9QZpDfUG0Q31BzkN9QehDfUECRH1BHER9QTZEfUFQRH1BakR9QYREfUGeRH1BuER9QdJEfUHsRH1BBkV9QSBFfUE6RX1BVEV9QW5FfUGIRX1BokV9QbxFfUHWRX1B70V9QQlGfUEjRn1BPUZ9QVdGfUFxRn1Bi0Z9QaVGfUG/Rn1B2UZ9QfNGfUENR31BJ0d9QUFHfUFbR31BdUd9QY9HfUGpR31Bw0d9Qd1HfUH3R31BEUh9QStIfUFFSH1BX0h9QXlIfUGTSH1BrUh9QcdIfUHhSH1B+0h9QRVJfUEvSX1BSUl9QWJJfUF8SX1Blkl9QbBJfUHKSX1B5El9Qf5JfUEYSn1BMkp9QUxKfUFmSn1BgEp9QZpKfUG0Sn1Bzkp9QehKfUECS31BHEt9QTZLfUFQS31Bakt9QYRLfUGeS31Bt0t9QdFLfUHrS31BBUx9QR9MfUE5TH1BU0x9QW1MfUGHTH1BoUx9QbtMfUHVTH1B70x9QQlNfUEjTX1BPU19QVdNfUFxTX1Bi019QaRNfUG+TX1B2E19QfJNfUEMTn1BJk59QUBOfUFaTn1BdE59QY5OfUGoTn1Bwk59QdxOfUH2Tn1BEE99QSpPfUFET31BXU99QXdPfUGRT31Bq099QcVPfUHfT31B+U99QRNQfUEtUH1BR1B9QWFQfUF7UH1BlVB9Qa9QfUHJUH1B4lB9QfxQfUEWUX1BMFF9QUpRfUFkUX1BflF9QZhRfUGyUX1BzFF9QeZRfUEAUn1BGlJ9QTRSfUFNUn1BZ1J9QYFSfUGbUn1BtVJ9Qc9SfUHpUn1BA1N9QR1TfUE3U31BUVN9QWtTfUGEU31BnlN9QbhTfUHSU31B7FN9QQZUfUEgVH1BOlR9QVRUfUFuVH1BiFR9QaJUfUG7VH1B1VR9Qe9UfUEJVX1BI1V9QT1VfUFXVX1BcVV9QYtVfUGlVX1Bv1V9QdhVfUHyVX1BDFZ9QSZWfUFAVn1BWlZ9QXRWfUGOVn1BqFZ9QcJWfUHcVn1B9VZ9QQ9XfUEpV31BQ1d9QV1XfUF3V31BkVd9QatXfUHFV31B31d9QfhXfUESWH1BLFh9QUZYfUFgWH1Belh9QZRYfUGuWH1ByFh9QeJYfUH7WH1BFVl9QS9ZfUFJWX1BY1l9QX1ZfUGXWX1BsVl9QctZfUHkWX1B/ll9QRhafUEyWn1BTFp9QWZafUGAWn1Bmlp9QbRafUHNWn1B51p9QQFbfUEbW31BNVt9QU9bfUFpW31Bg1t9QZxbfUG2W31B0Ft9QepbfUEEXH1BHlx9QThcfUFSXH1BbFx9QYVcfUGfXH1BuVx9QdNcfUHtXH1BB119QSFdfUE7XX1BVF19QW5dfUGIXX1Bol19QbxdfUHWXX1B8F19QQpefUEjXn1BPV59QVdefUFxXn1Bi159QaVefUG/Xn1B2V59QfJefUEMX31BJl99QUBffUFaX31BdF99QY5ffUGnX31BwV99QdtffUH1X31BD2B9QSlgfUFDYH1BXGB9QXZgfUGQYH1BqmB9QcRgfUHeYH1B+GB9QRFhfUErYX1BRWF9QV9hfUF5YX1Bk2F9Qa1hfUHGYX1B4GF9QfphfUEUYn1BLmJ9QUhifUFiYn1Be2J9QZVifUGvYn1ByWJ9QeNifUH9Yn1BF2N9QTBjfUFKY31BZGN9QX5jfUGYY31BsmN9QcxjfUHlY31B/2N9QRlkfUEzZH1BTWR9QWdkfUGAZH1BmmR9QbRkfUHOZH1B6GR9QQJlfUEbZX1BNWV9QU9lfUFpZX1Bg2V9QZ1lfUG3ZX1B0GV9QeplfUEEZn1BHmZ9QThmfUFSZn1Ba2Z9QYVmfUGfZn1BuWZ9QdNmfUHtZn1BBmd9QSBnfUE6Z31BVGd9QW5nfUGIZ31BoWd9QbtnfUHVZ31B72d9QQlofUEjaH1BPGh9QVZofUFwaH1Bimh9QaRofUG9aH1B12h9QfFofUELaX1BJWl9QT9pfUFYaX1Bcml9QYxpfUGmaX1BwGl9QdppfUHzaX1BDWp9QSdqfUFBan1BW2p9QXRqfUGOan1BqGp9QcJqfUHcan1B9mp9QQ9rfUEpa31BQ2t9QV1rfUF3a31BkGt9QaprfUHEa31B3mt9QfhrfUERbH1BK2x9QUVsfUFfbH1BeWx9QZJsfUGsbH1Bxmx9QeBsfUH6bH1BFG19QS1tfUFHbX1BYW19QXttfUGVbX1Brm19QchtfUHibX1B/G19QRZufUEvbn1BSW59QWNufUF9bn1Bl259QbBufUHKbn1B5G59Qf5ufUEYb31BMW99QUtvfUFlb31Bf299QZlvfUGyb31BzG99QeZvfUEAcH1BGnB9QTNwfUFNcH1BZ3B9QYFwfUGacH1BtHB9Qc5wfUHocH1BAnF9QRtxfUE1cX1BT3F9QWlxfUGDcX1BnHF9QbZxfUHQcX1B6nF9QQRyfUEdcn1BN3J9QVFyfUFrcn1BhHJ9QZ5yfUG4cn1B0nJ9QexyfUEFc31BH3N9QTlzfUFTc31BbHN9QYZzfUGgc31BunN9QdRzfUHtc31BB3R9QSF0fUE7dH1BVHR9QW50fUGIdH1BonR9Qbx0fUHVdH1B73R9QQl1fUEjdX1BPHV9QVZ1fUFwdX1BinV9QaN1fUG9dX1B13V9QfF1fUELdn1BJHZ9QT52fUFYdn1BcnZ9QYt2fUGldn1Bv3Z9Qdl2fUHydn1BDHd9QSZ3fUFAd31BWXd9QXN3fUGNd31Bp3d9QcF3fUHad31B9Hd9QQ54fUEoeH1BQXh9QVt4fUF1eH1Bj3h9Qah4fUHCeH1B3Hh9QfZ4fUEPeX1BKXl9QUN5fUFdeX1Bdnl9QZB5fUGqeX1BxHl9Qd15fUH3eX1BEXp9QSt6fUFEen1BXnp9QXh6fUGSen1Bq3p9QcV6fUHfen1B+Xp9QRJ7fUEse31BRnt9QWB7fUF5e31Bk3t9Qa17fUHHe31B4Ht9Qfp7fUEUfH1BLXx9QUd8fUFhfH1Be3x9QZR8fUGufH1ByHx9QeJ8fUH7fH1BFX19QS99fUFJfX1BYn19QXx9fUGWfX1BsH19Qcl9fUHjfX1B/X19QRZ+fUEwfn1BSn59QWR+fUF9fn1Bl359QbF+fUHLfn1B5H59Qf5+fUEYf31BMn99QUt/fUFlf31Bf399QZh/fUGyf31BzH99QeZ/fUH/f31BGYB9QTOAfUFMgH1BZoB9QYCAfUGagH1Bs4B9Qc2AfUHngH1BAYF9QRqBfUE0gX1BToF9QWeBfUGBgX1Bm4F9QbWBfUHOgX1B6IF9QQKCfUEbgn1BNYJ9QU+CfUFpgn1BgoJ9QZyCfUG2gn1Bz4J9QemCfUEDg31BHYN9QTaDfUFQg31BaoN9QYODfUGdg31Bt4N9QdCDfUHqg31BBIR9QR6EfUE3hH1BUYR9QWuEfUGEhH1BnoR9QbiEfUHShH1B64R9QQWFfUEfhX1BOIV9QVKFfUFshX1BhYV9QZ+FfUG5hX1B04V9QeyFfUEGhn1BIIZ9QTmGfUFThn1BbYZ9QYaGfUGghn1BuoZ9QdOGfUHthn1BB4d9QSGHfUE6h31BVId9QW6HfUGHh31BoYd9QbuHfUHUh31B7od9QQiIfUEhiH1BO4h9QVWIfUFviH1BiIh9QaKIfUG8iH1B1Yh9Qe+IfUEJiX1BIol9QTyJfUFWiX1Bb4l9QYmJfUGjiX1BvIl9QdaJfUHwiX1BCYp9QSOKfUE9in1BV4p9QXCKfUGKin1BpIp9Qb2KfUHXin1B8Yp9QQqLfUEki31BPot9QVeLfUFxi31Bi4t9QaSLfUG+i31B2It9QfGLfUELjH1BJYx9QT6MfUFYjH1Bcox9QYuMfUGljH1Bv4x9QdiMfUHyjH1BDI19QSWNfUE/jX1BWY19QXKNfUGMjX1Bpo19Qb+NfUHZjX1B8419QQyOfUEmjn1BQI59QVmOfUFzjn1BjY59QaaOfUHAjn1B2o59QfOOfUENj31BJ499QUCPfUFaj31BdI99QY2PfUGnj31BwY99QdqPfUH0j31BDZB9QSeQfUFBkH1BWpB9QXSQfUGOkH1Bp5B9QcGQfUHbkH1B9JB9QQ6RfUEokX1BQZF9QVuRfUF1kX1BjpF9QaiRfUHCkX1B25F9QfWRfUEOkn1BKJJ9QUKSfUFbkn1BdZJ9QY+SfUGokn1BwpJ9QdySfUH1kn1BD5N9QSmTfUFCk31BXJN9QXWTfUGPk31BqZN9QcKTfUHck31B9pN9QQ+UfUEplH1BQ5R9QVyUfUF2lH1Bj5R9QamUfUHDlH1B3JR9QfaUfUEQlX1BKZV9QUOVfUFdlX1BdpV9QZCVfUGplX1Bw5V9Qd2VfUH2lX1BEJZ9QSqWfUFDln1BXZZ9QXaWfUGQln1BqpZ9QcOWfUHdln1B95Z9QRCXfUEql31BQ5d9QV2XfUF3l31BkJd9QaqXfUHEl31B3Zd9QfeXfUEQmH1BKph9QUSYfUFdmH1Bd5h9QZCYfUGqmH1BxJh9Qd2YfUH3mH1BEZl9QSqZfUFEmX1BXZl9QXeZfUGRmX1Bqpl9QcSZfUHdmX1B95l9QRGafUEqmn1BRJp9QV6afUF3mn1BkZp9QaqafUHEmn1B3pp9QfeafUERm31BKpt9QUSbfUFem31Bd5t9QZGbfUGqm31BxJt9Qd6bfUH3m31BEZx9QSqcfUFEnH1BXpx9QXecfUGRnH1Bqpx9QcScfUHenH1B95x9QRGdfUEqnX1BRJ19QV6dfUF3nX1BkZ19QaqdfUHEnX1B3p19QfedfUERnn1BKp59QUSefUFenn1Bd559QZGefUGqnn1BxJ59Qd2efUH3nn1BEZ99QSqffUFEn31BXZ99QXeffUGRn31Bqp99QcSffUHdn31B9599QRGgfUEqoH1BRKB9QV2gfUF3oH1BkKB9QaqgfUHEoH1B3aB9QfegfUEQoX1BKqF9QUShfUFdoX1Bd6F9QZChfUGqoX1Bw6F9Qd2hfUH3oX1BEKJ9QSqifUFDon1BXaJ9QXaifUGQon1BqqJ9QcOifUHdon1B9qJ9QRCjfUEpo31BQ6N9QV2jfUF2o31BkKN9QamjfUHDo31B3KN9QfajfUEQpH1BKaR9QUOkfUFcpH1BdqR9QY+kfUGppH1Bw6R9QdykfUH2pH1BD6V9QSmlfUFCpX1BXKV9QXWlfUGPpX1BqaV9QcKlfUHcpX1B9aV9QQ+mfUEopn1BQqZ9QVumfUF1pn1Bj6Z9QaimfUHCpn1B26Z9QfWmfUEOp31BKKd9QUGnfUFbp31Bdad9QY6nfUGop31Bwad9QdunfUH0p31BDqh9QSeofUFBqH1BW6h9QXSofUGOqH1Bp6h9QcGofUHaqH1B9Kh9QQ2pfUEnqX1BQKl9QVqpfUF0qX1Bjal9QaepfUHAqX1B2ql9QfOpfUENqn1BJqp9QUCqfUFZqn1Bc6p9QYyqfUGmqn1BwKp9QdmqfUHzqn1BDKt9QSarfUE/q31BWat9QXKrfUGMq31Bpat9Qb+rfUHYq31B8qt9QQysfUElrH1BP6x9QVisfUFyrH1Bi6x9QaWsfUG+rH1B2Kx9QfGsfUELrX1BJK19QT6tfUFXrX1Bca19QYqtfUGkrX1Bvq19QdetfUHxrX1BCq59QSSufUE9rn1BV659QXCufUGKrn1Bo659Qb2ufUHWrn1B8K59QQmvfUEjr31BPK99QVavfUFvr31Bia99QaKvfUG8r31B1a99Qe+vfUEIsH1BIrB9QTywfUFVsH1Bb7B9QYiwfUGisH1Bu7B9QdWwfUHusH1BCLF9QSGxfUE7sX1BVLF9QW6xfUGHsX1BobF9QbqxfUHUsX1B7bF9QQeyfUEgsn1BOrJ9QVOyfUFtsn1BhrJ9QaCyfUG5sn1B07J9QeyyfUEGs31BH7N9QTmzfUFSs31BbLN9QYWzfUGfs31BuLN9QdKzfUHrs31BBbR9QR60fUE4tH1BUbR9QWu0fUGEtH1BnrR9Qbe0fUHRtH1B6rR9QQS1fUEdtX1BN7V9QVC1fUFqtX1Bg7V9QZ21fUG2tX1B0LV9Qem1fUEDtn1BHLZ9QTa2fUFPtn1BabZ9QYK2fUGctn1BtbZ9Qc+2fUHotn1BArd9QRu3fUE0t31BTrd9QWe3fUGBt31Bmrd9QbS3fUHNt31B57d9QQC4fUEauH1BM7h9QU24fUFmuH1BgLh9QZm4fUGzuH1BzLh9Qea4fUH/uH1BGbl9QTK5fUFMuX1BZbl9QX65fUGYuX1Bsbl9Qcu5fUHkuX1B/rl9QRe6fUExun1BSrp9QWS6fUF9un1Bl7p9QbC6fUHKun1B47p9Qf26fUEWu31BMLt9QUm7fUFiu31BfLt9QZW7fUGvu31ByLt9QeK7fUH7u31BFbx9QS68fUFIvH1BYbx9QXu8fUGUvH1Brbx9Qce8fUHgvH1B+rx9QRO9fUEtvX1BRr19QWC9fUF5vX1Bk719Qay9fUHGvX1B3719Qfi9fUESvn1BK759QUW+fUFevn1BeL59QZG+fUGrvn1BxL59Qd2+fUH3vn1BEL99QSq/fUFDv31BXb99QXa/fUGQv31Bqb99QcO/fUHcv31B9b99QQ/AfUEowH1BQsB9QVvAfUF1wH1BjsB9QajAfUHBwH1B2sB9QfTAfUENwX1BJ8F9QUDBfUFawX1Bc8F9QY3BfUGmwX1Bv8F9QdnBfUHywX1BDMJ9QSXCfUE/wn1BWMJ9QXHCfUGLwn1BpMJ9Qb7CfUHXwn1B8cJ9QQrDfUEkw31BPcN9QVbDfUFww31BicN9QaPDfUG8w31B1sN9Qe/DfUEIxH1BIsR9QTvEfUFVxH1BbsR9QYjEfUGhxH1BusR9QdTEfUHtxH1BB8V9QSDFfUE6xX1BU8V9QWzFfUGGxX1Bn8V9QbnFfUHSxX1B68V9QQXGfUEexn1BOMZ9QVHGfUFrxn1BhMZ9QZ3GfUG3xn1B0MZ9QerGfUEDx31BHMd9QTbHfUFPx31Bacd9QYLHfUGcx31Btcd9Qc7HfUHox31BAch9QRvIfUE0yH1BTch9QWfIfUGAyH1Bmsh9QbPIfUHMyH1B5sh9Qf/IfUEZyX1BMsl9QUzJfUFlyX1Bfsl9QZjJfUGxyX1By8l9QeTJfUH9yX1BF8p9QTDKfUFKyn1BY8p9QXzKfUGWyn1Br8p9QcnKfUHiyn1B+8p9QRXLfUEuy31BSMt9QWHLfUF6y31BlMt9Qa3LfUHHy31B4Mt9QfnLfUETzH1BLMx9QUbMfUFfzH1BeMx9QZLMfUGrzH1BxMx9Qd7MfUH3zH1BEc19QSrNfUFDzX1BXc19QXbNfUGQzX1Bqc19QcLNfUHczX1B9c19QQ/OfUEozn1BQc59QVvOfUF0zn1Bjc59QafOfUHAzn1B2s59QfPOfUEMz31BJs99QT/PfUFZz31Bcs99QYvPfUGlz31Bvs99QdfPfUHxz31BCtB9QSTQfUE90H1BVtB9QXDQfUGJ0H1BotB9QbzQfUHV0H1B79B9QQjRfUEh0X1BO9F9QVTRfUFt0X1Bh9F9QaDRfUG60X1B09F9QezRfUEG0n1BH9J9QTjSfUFS0n1Ba9J9QYTSfUGe0n1Bt9J9QdHSfUHq0n1BA9N9QR3TfUE2031BT9N9QWnTfUGC031Bm9N9QbXTfUHO031B6NN9QQHUfUEa1H1BNNR9QU3UfUFm1H1BgNR9QZnUfUGy1H1BzNR9QeXUfUH/1H1BGNV9QTHVfUFL1X1BZNV9QX3VfUGX1X1BsNV9QcnVfUHj1X1B/NV9QRXWfUEv1n1BSNZ9QWHWfUF71n1BlNZ9Qa7WfUHH1n1B4NZ9QfrWfUET131BLNd9QUbXfUFf131BeNd9QZLXfUGr131BxNd9Qd7XfUH3131BENh9QSrYfUFD2H1BXNh9QXbYfUGP2H1BqNh9QcLYfUHb2H1B9Nh9QQ7ZfUEn2X1BQNl9QVrZfUFz2X1BjNl9QabZfUG/2X1B2Nl9QfLZfUEL2n1BJNp9QT7afUFX2n1BcNp9QYrafUGj2n1BvNp9QdbafUHv2n1BCNt9QSLbfUE7231BVNt9QW7bfUGH231BoNt9QbrbfUHT231B7Nt9QQbcfUEf3H1BONx9QVLcfUFr3H1BhNx9QZ7cfUG33H1B0Nx9QercfUED3X1BHN19QTbdfUFP3X1BaN19QYLdfUGb3X1BtN19Qc7dfUHn3X1BAN59QRnefUEz3n1BTN59QWXefUF/3n1BmN59QbHefUHL3n1B5N59Qf3efUEX331BMN99QUnffUFj331BfN99QZXffUGv331ByN99QeHffUH6331BFOB9QS3gfUFG4H1BYOB9QXngfUGS4H1BrOB9QcXgfUHe4H1B+OB9QRHhfUEq4X1BQ+F9QV3hfUF24X1Bj+F9QanhfUHC4X1B2+F9QfXhfUEO4n1BJ+J9QUDifUFa4n1Bc+J9QYzifUGm4n1Bv+J9QdjifUHy4n1BC+N9QSTjfUE9431BV+N9QXDjfUGJ431Bo+N9QbzjfUHV431B7uN9QQjkfUEh5H1BOuR9QVTkfUFt5H1BhuR9QZ/kfUG55H1B0uR9QevkfUEF5X1BHuV9QTflfUFR5X1BauV9QYPlfUGc5X1BtuV9Qc/lfUHo5X1BAuZ9QRvmfUE05n1BTeZ9QWfmfUGA5n1BmeZ9QbLmfUHM5n1B5eZ9Qf7mfUEY531BMed9QUrnfUFj531Bfed9QZbnfUGv531Byed9QeLnfUH7531BFOh9QS7ofUFH6H1BYOh9QXnofUGT6H1BrOh9QcXofUHf6H1B+Oh9QRHpfUEq6X1BROl9QV3pfUF26X1Bj+l9QanpfUHC6X1B2+l9QfXpfUEO6n1BJ+p9QUDqfUFa6n1Bc+p9QYzqfUGl6n1Bv+p9QdjqfUHx6n1BCut9QSTrfUE9631BVut9QW/rfUGJ631Bout9QbvrfUHU631B7ut9QQfsfUEg7H1BOux9QVPsfUFs7H1Bhex9QZ/sfUG47H1B0ex9QersfUEE7X1BHe19QTbtfUFP7X1Bae19QYLtfUGb7X1BtO19Qc7tfUHn7X1BAO59QRnufUEz7n1BTO59QWXufUF+7n1BmO59QbHufUHK7n1B4+59Qf3ufUEW731BL+99QUjvfUFi731Be+99QZTvfUGt731Bxu99QeDvfUH5731BEvB9QSvwfUFF8H1BXvB9QXfwfUGQ8H1BqvB9QcPwfUHc8H1B9fB9QQ/xfUEo8X1BQfF9QVrxfUF08X1BjfF9QabxfUG/8X1B2PF9QfLxfUEL8n1BJPJ9QT3yfUFX8n1BcPJ9QYnyfUGi8n1BvPJ9QdXyfUHu8n1BB/N9QSDzfUE6831BU/N9QWzzfUGF831Bn/N9QbjzfUHR831B6vN9QQP0fUEd9H1BNvR9QU/0fUFo9H1BgvR9QZv0fUG09H1BzfR9Qeb0fUEA9X1BGfV9QTL1fUFL9X1BZfV9QX71fUGX9X1BsPV9Qcn1fUHj9X1B/PV9QRX2fUEu9n1BSPZ9QWH2fUF69n1Bk/Z9Qaz2fUHG9n1B3/Z9Qfj2fUER931BKvd9QUT3fUFd931Bdvd9QY/3fUGo931Bwvd9Qdv3fUH0931BDfh9QSb4fUFA+H1BWfh9QXL4fUGL+H1Bpfh9Qb74fUHX+H1B8Ph9QQn5fUEj+X1BPPl9QVX5fUFu+X1Bh/l9QaH5fUG6+X1B0/l9Qez5fUEF+n1BH/p9QTj6fUFR+n1Bavp9QYP6fUGd+n1Btvp9Qc/6fUHo+n1BAft9QRr7fUE0+31BTft9QWb7fUF/+31BmPt9QbL7fUHL+31B5Pt9Qf37fUEW/H1BMPx9QUn8fUFi/H1Be/x9QZT8fUGu/H1Bx/x9QeD8fUH5/H1BEv19QSv9fUFF/X1BXv19QXf9fUGQ/X1Bqf19QcP9fUHc/X1B9f19QQ7+fUEn/n1BQP59QVr+fUFz/n1BjP59QaX+fUG+/n1B2P59QfH+fUEK/31BI/99QTz/fUFV/31Bb/99QYj/fUGh/31Buv99QdP/fUHs/31BBgB+QR8AfkE4AH5BUQB+QWoAfkGDAH5BnQB+QbYAfkHPAH5B6AB+QQEBfkEaAX5BNAF+QU0BfkFmAX5BfwF+QZgBfkGxAX5BywF+QeQBfkH9AX5BFgJ+QS8CfkFIAn5BYgJ+QXsCfkGUAn5BrQJ+QcYCfkHfAn5B+QJ+QRIDfkErA35BRAN+QV0DfkF2A35BkAN+QakDfkHCA35B2wN+QfQDfkENBH5BJgR+QUAEfkFZBH5BcgR+QYsEfkGkBH5BvQR+QdcEfkHwBH5BCQV+QSIFfkE7BX5BVAV+QW0FfkGHBX5BoAV+QbkFfkHSBX5B6wV+QQQGfkEdBn5BNwZ+QVAGfkFpBn5BggZ+QZsGfkG0Bn5BzgZ+QecGfkEAB35BGQd+QTIHfkFLB35BZAd+QX0HfkGXB35BsAd+QckHfkHiB35B+wd+QRQIfkEtCH5BRwh+QWAIfkF5CH5Bkgh+QasIfkHECH5B3Qh+QfcIfkEQCX5BKQl+QUIJfkFbCX5BdAl+QY0JfkGmCX5BwAl+QdkJfkHyCX5BCwp+QSQKfkE9Cn5BVgp+QXAKfkGJCn5Bogp+QbsKfkHUCn5B7Qp+QQYLfkEfC35BOQt+QVILfkFrC35BhAt+QZ0LfkG2C35Bzwt+QegLfkECDH5BGwx+QTQMfkFNDH5BZgx+QX8MfkGYDH5BsQx+QcoMfkHkDH5B/Qx+QRYNfkEvDX5BSA1+QWENfkF6DX5Bkw1+Qa0NfkHGDX5B3w1+QfgNfkERDn5BKg5+QUMOfkFcDn5BdQ5+QY8OfkGoDn5BwQ5+QdoOfkHzDn5BDA9+QSUPfkE+D35BVw9+QXEPfkGKD35Bow9+QbwPfkHVD35B7g9+QQcQfkEgEH5BORB+QVIQfkFsEH5BhRB+QZ4QfkG3EH5B0BB+QekQfkECEX5BGxF+QTQRfkFNEX5BZxF+QYARfkGZEX5BshF+QcsRfkHkEX5B/RF+QRYSfkEvEn5BSBJ+QWISfkF7En5BlBJ+Qa0SfkHGEn5B3xJ+QfgSfkERE35BKhN+QUMTfkFcE35BdhN+QY8TfkGoE35BwRN+QdoTfkHzE35BDBR+QSUUfkE+FH5BVxR+QXAUfkGJFH5BoxR+QbwUfkHVFH5B7hR+QQcVfkEgFX5BORV+QVIVfkFrFX5BhBV+QZ0VfkG2FX5B0BV+QekVfkECFn5BGxZ+QTQWfkFNFn5BZhZ+QX8WfkGYFn5BsRZ+QcoWfkHjFn5B/BZ+QRYXfkEvF35BSBd+QWEXfkF6F35Bkxd+QawXfkHFF35B3hd+QfcXfkEQGH5BKRh+QUIYfkFbGH5BdRh+QY4YfkGnGH5BwBh+QdkYfkHyGH5BCxl+QSQZfkE9GX5BVhl+QW8ZfkGIGX5BoRl+QboZfkHTGX5B7Rl+QQYafkEfGn5BOBp+QVEafkFqGn5Bgxp+QZwafkG1Gn5Bzhp+QecafkEAG35BGRt+QTIbfkFLG35BZBt+QX0bfkGXG35BsBt+QckbfkHiG35B+xt+QRQcfkEtHH5BRhx+QV8cfkF4HH5BkRx+QaocfkHDHH5B3Bx+QfUcfkEOHX5BJx1+QUAdfkFZHX5Bch1+QYwdfkGlHX5Bvh1+QdcdfkHwHX5BCR5+QSIefkE7Hn5BVB5+QW0efkGGHn5Bnx5+QbgefkHRHn5B6h5+QQMffkEcH35BNR9+QU4ffkFnH35BgB9+QZkffkGyH35BzB9+QeUffkH+H35BFyB+QTAgfkFJIH5BYiB+QXsgfkGUIH5BrSB+QcYgfkHfIH5B+CB+QREhfkEqIX5BQyF+QVwhfkF1IX5BjiF+QachfkHAIX5B2SF+QfIhfkELIn5BJCJ+QT0ifkFWIn5BbyJ+QYgifkGhIn5BuiJ+QdMifkHsIn5BBiN+QR8jfkE4I35BUSN+QWojfkGDI35BnCN+QbUjfkHOI35B5yN+QQAkfkEZJH5BMiR+QUskfkFkJH5BfSR+QZYkfkGvJH5ByCR+QeEkfkH6JH5BEyV+QSwlfkFFJX5BXiV+QXclfkGQJX5BqSV+QcIlfkHbJX5B9CV+QQ0mfkEmJn5BPyZ+QVgmfkFxJn5BiiZ+QaMmfkG8Jn5B1SZ+Qe4mfkEHJ35BICd+QTknfkFSJ35Bayd+QYQnfkGdJ35Btid+Qc8nfkHoJ35BASh+QRoofkEzKH5BTCh+QWUofkF+KH5Blyh+QbAofkHJKH5B4ih+QfsofkEUKX5BLSl+QUYpfkFfKX5BeCl+QZEpfkGqKX5Bwyl+QdwpfkH1KX5BDip+QScqfkFAKn5BWSp+QXIqfkGLKn5BpCp+Qb0qfkHWKn5B7yp+QQgrfkEhK35BOit+QVMrfkFsK35BhSt+QZ4rfkG3K35B0Ct+QekrfkECLH5BGyx+QTQsfkFNLH5BZix+QX8sfkGYLH5BsSx+QcosfkHjLH5B/Cx+QRUtfkEuLX5BRy1+QWAtfkF5LX5Bki1+QastfkHELX5B3S1+QfYtfkEPLn5BKC5+QUAufkFZLn5Bci5+QYsufkGkLn5BvS5+QdYufkHvLn5BCC9+QSEvfkE6L35BUy9+QWwvfkGFL35Bni9+QbcvfkHQL35B6S9+QQIwfkEbMH5BNDB+QU0wfkFmMH5BfzB+QZgwfkGxMH5ByjB+QeMwfkH8MH5BFTF+QS4xfkFHMX5BYDF+QXgxfkGRMX5BqjF+QcMxfkHcMX5B9TF+QQ4yfkEnMn5BQDJ+QVkyfkFyMn5BizJ+QaQyfkG9Mn5B1jJ+Qe8yfkEIM35BITN+QTozfkFTM35BbDN+QYUzfkGeM35BtzN+Qc8zfkHoM35BATR+QRo0fkEzNH5BTDR+QWU0fkF+NH5BlzR+QbA0fkHJNH5B4jR+Qfs0fkEUNX5BLTV+QUY1fkFfNX5BeDV+QZE1fkGpNX5BwjV+Qds1fkH0NX5BDTZ+QSY2fkE/Nn5BWDZ+QXE2fkGKNn5BozZ+Qbw2fkHVNn5B7jZ+QQc3fkEgN35BOTd+QVE3fkFqN35Bgzd+QZw3fkG1N35Bzjd+Qec3fkEAOH5BGTh+QTI4fkFLOH5BZDh+QX04fkGWOH5Brzh+Qcg4fkHgOH5B+Th+QRI5fkErOX5BRDl+QV05fkF2OX5Bjzl+Qag5fkHBOX5B2jl+QfM5fkEMOn5BJTp+QT06fkFWOn5Bbzp+QYg6fkGhOn5Bujp+QdM6fkHsOn5BBTt+QR47fkE3O35BUDt+QWk7fkGBO35Bmjt+QbM7fkHMO35B5Tt+Qf47fkEXPH5BMDx+QUk8fkFiPH5Bezx+QZQ8fkGsPH5BxTx+Qd48fkH3PH5BED1+QSk9fkFCPX5BWz1+QXQ9fkGNPX5Bpj1+Qb49fkHXPX5B8D1+QQk+fkEiPn5BOz5+QVQ+fkFtPn5Bhj5+QZ8+fkG4Pn5B0D5+Qek+fkECP35BGz9+QTQ/fkFNP35BZj9+QX8/fkGYP35BsT9+Qco/fkHiP35B+z9+QRRAfkEtQH5BRkB+QV9AfkF4QH5BkUB+QapAfkHDQH5B20B+QfRAfkENQX5BJkF+QT9BfkFYQX5BcUF+QYpBfkGjQX5Bu0F+QdRBfkHtQX5BBkJ+QR9CfkE4Qn5BUUJ+QWpCfkGDQn5BnEJ+QbRCfkHNQn5B5kJ+Qf9CfkEYQ35BMUN+QUpDfkFjQ35Be0N+QZRDfkGtQ35BxkN+Qd9DfkH4Q35BEUR+QSpEfkFDRH5BW0R+QXREfkGNRH5BpkR+Qb9EfkHYRH5B8UR+QQpFfkEjRX5BO0V+QVRFfkFtRX5BhkV+QZ9FfkG4RX5B0UV+QepFfkECRn5BG0Z+QTRGfkFNRn5BZkZ+QX9GfkGYRn5BsUZ+QclGfkHiRn5B+0Z+QRRHfkEtR35BRkd+QV9HfkF4R35BkEd+QalHfkHCR35B20d+QfRHfkENSH5BJkh+QT5IfkFXSH5BcEh+QYlIfkGiSH5Bu0h+QdRIfkHtSH5BBUl+QR5JfkE3SX5BUEl+QWlJfkGCSX5Bm0l+QbNJfkHMSX5B5Ul+Qf5JfkEXSn5BMEp+QUlKfkFhSn5Bekp+QZNKfkGsSn5BxUp+Qd5KfkH3Sn5BD0t+QShLfkFBS35BWkt+QXNLfkGMS35BpUt+Qb1LfkHWS35B70t+QQhMfkEhTH5BOkx+QVJMfkFrTH5BhEx+QZ1MfkG2TH5Bz0x+QehMfkEATX5BGU1+QTJNfkFLTX5BZE1+QX1NfkGVTX5Brk1+QcdNfkHgTX5B+U1+QRJOfkErTn5BQ05+QVxOfkF1Tn5Bjk5+QadOfkHATn5B2E5+QfFOfkEKT35BI09+QTxPfkFVT35BbU9+QYZPfkGfT35BuE9+QdFPfkHqT35BAlB+QRtQfkE0UH5BTVB+QWZQfkF/UH5Bl1B+QbBQfkHJUH5B4lB+QftQfkEUUX5BLFF+QUVRfkFeUX5Bd1F+QZBRfkGpUX5BwVF+QdpRfkHzUX5BDFJ+QSVSfkE+Un5BVlJ+QW9SfkGIUn5BoVJ+QbpSfkHSUn5B61J+QQRTfkEdU35BNlN+QU9TfkFnU35BgFN+QZlTfkGyU35By1N+QeNTfkH8U35BFVR+QS5UfkFHVH5BYFR+QXhUfkGRVH5BqlR+QcNUfkHcVH5B9FR+QQ1VfkEmVX5BP1V+QVhVfkFxVX5BiVV+QaJVfkG7VX5B1FV+Qe1VfkEFVn5BHlZ+QTdWfkFQVn5BaVZ+QYFWfkGaVn5Bs1Z+QcxWfkHlVn5B/VZ+QRZXfkEvV35BSFd+QWFXfkF5V35Bkld+QatXfkHEV35B3Vd+QfVXfkEOWH5BJ1h+QUBYfkFZWH5BcVh+QYpYfkGjWH5BvFh+QdVYfkHtWH5BBll+QR9ZfkE4WX5BUVl+QWlZfkGCWX5Bm1l+QbRZfkHNWX5B5Vl+Qf5ZfkEXWn5BMFp+QUlafkFhWn5Belp+QZNafkGsWn5BxFp+Qd1afkH2Wn5BD1t+QShbfkFAW35BWVt+QXJbfkGLW35BpFt+QbxbfkHVW35B7lt+QQdcfkEfXH5BOFx+QVFcfkFqXH5Bg1x+QZtcfkG0XH5BzVx+QeZcfkH/XH5BF11+QTBdfkFJXX5BYl1+QXpdfkGTXX5BrF1+QcVdfkHeXX5B9l1+QQ9efkEoXn5BQV5+QVlefkFyXn5Bi15+QaRefkG8Xn5B1V5+Qe5efkEHX35BIF9+QThffkFRX35Bal9+QYNffkGbX35BtF9+Qc1ffkHmX35B/l9+QRdgfkEwYH5BSWB+QWJgfkF6YH5Bk2B+QaxgfkHFYH5B3WB+QfZgfkEPYX5BKGF+QUBhfkFZYX5BcmF+QYthfkGjYX5BvGF+QdVhfkHuYX5BB2J+QR9ifkE4Yn5BUWJ+QWpifkGCYn5Bm2J+QbRifkHNYn5B5WJ+Qf5ifkEXY35BMGN+QUhjfkFhY35BemN+QZNjfkGrY35BxGN+Qd1jfkH2Y35BDmR+QSdkfkFAZH5BWWR+QXFkfkGKZH5Bo2R+QbxkfkHUZH5B7WR+QQZlfkEfZX5BN2V+QVBlfkFpZX5BgmV+QZplfkGzZX5BzGV+QeVlfkH9ZX5BFmZ+QS9mfkFHZn5BYGZ+QXlmfkGSZn5BqmZ+QcNmfkHcZn5B9WZ+QQ1nfkEmZ35BP2d+QVhnfkFwZ35BiWd+QaJnfkG7Z35B02d+QexnfkEFaH5BHWh+QTZofkFPaH5BaGh+QYBofkGZaH5Bsmh+QctofkHjaH5B/Gh+QRVpfkEuaX5BRml+QV9pfkF4aX5BkGl+QalpfkHCaX5B22l+QfNpfkEMan5BJWp+QT1qfkFWan5Bb2p+QYhqfkGgan5BuWp+QdJqfkHran5BA2t+QRxrfkE1a35BTWt+QWZrfkF/a35BmGt+QbBrfkHJa35B4mt+QfprfkETbH5BLGx+QUVsfkFdbH5Bdmx+QY9sfkGnbH5BwGx+QdlsfkHybH5BCm1+QSNtfkE8bX5BVG1+QW1tfkGGbX5Bn21+QbdtfkHQbX5B6W1+QQFufkEabn5BM25+QUxufkFkbn5BfW5+QZZufkGubn5Bx25+QeBufkH4bn5BEW9+QSpvfkFDb35BW29+QXRvfkGNb35BpW9+Qb5vfkHXb35B729+QQhwfkEhcH5BOnB+QVJwfkFrcH5BhHB+QZxwfkG1cH5BznB+QeZwfkH/cH5BGHF+QTFxfkFJcX5BYnF+QXtxfkGTcX5BrHF+QcVxfkHdcX5B9nF+QQ9yfkEncn5BQHJ+QVlyfkFycn5BinJ+QaNyfkG8cn5B1HJ+Qe1yfkEGc35BHnN+QTdzfkFQc35BaHN+QYFzfkGac35BsnN+QctzfkHkc35B/XN+QRV0fkEudH5BR3R+QV90fkF4dH5BkXR+Qal0fkHCdH5B23R+QfN0fkEMdX5BJXV+QT11fkFWdX5Bb3V+QYd1fkGgdX5BuXV+QdF1fkHqdX5BA3Z+QRt2fkE0dn5BTXZ+QWV2fkF+dn5Bl3Z+QbB2fkHIdn5B4XZ+Qfp2fkESd35BK3d+QUR3fkFcd35BdXd+QY53fkGmd35Bv3d+Qdh3fkHwd35BCXh+QSJ4fkE6eH5BU3h+QWx4fkGEeH5BnXh+QbZ4fkHOeH5B53h+QQB5fkEYeX5BMXl+QUl5fkFieX5Be3l+QZN5fkGseX5BxXl+Qd15fkH2eX5BD3p+QSd6fkFAen5BWXp+QXF6fkGKen5Bo3p+Qbt6fkHUen5B7Xp+QQV7fkEee35BN3t+QU97fkFoe35BgXt+QZl7fkGye35By3t+QeN7fkH8e35BFHx+QS18fkFGfH5BXnx+QXd8fkGQfH5BqHx+QcF8fkHafH5B8nx+QQt9fkEkfX5BPH1+QVV9fkFufX5Bhn1+QZ99fkG3fX5B0H1+Qel9fkEBfn5BGn5+QTN+fkFLfn5BZH5+QX1+fkGVfn5Brn5+Qcd+fkHffn5B+H5+QRB/fkEpf35BQn9+QVp/fkFzf35BjH9+QaR/fkG9f35B1n9+Qe5/fkEHgH5BH4B+QTiAfkFRgH5BaYB+QYKAfkGbgH5Bs4B+QcyAfkHkgH5B/YB+QRaBfkEugX5BR4F+QWCBfkF4gX5BkYF+QamBfkHCgX5B24F+QfOBfkEMgn5BJYJ+QT2CfkFWgn5BboJ+QYeCfkGggn5BuIJ+QdGCfkHqgn5BAoN+QRuDfkEzg35BTIN+QWWDfkF9g35BloN+Qa+DfkHHg35B4IN+QfiDfkERhH5BKoR+QUKEfkFbhH5Bc4R+QYyEfkGlhH5BvYR+QdaEfkHvhH5BB4V+QSCFfkE4hX5BUYV+QWqFfkGChX5Bm4V+QbOFfkHMhX5B5YV+Qf2FfkEWhn5BLoZ+QUeGfkFghn5BeIZ+QZGGfkGphn5BwoZ+QduGfkHzhn5BDId+QSWHfkE9h35BVod+QW6HfkGHh35BoId+QbiHfkHRh35B6Yd+QQKIfkEbiH5BM4h+QUyIfkFkiH5BfYh+QZaIfkGuiH5Bx4h+Qd+IfkH4iH5BEIl+QSmJfkFCiX5BWol+QXOJfkGLiX5BpIl+Qb2JfkHViX5B7ol+QQaKfkEfin5BOIp+QVCKfkFpin5BgYp+QZqKfkGzin5By4p+QeSKfkH8in5BFYt+QS2LfkFGi35BX4t+QXeLfkGQi35BqIt+QcGLfkHai35B8ot+QQuMfkEjjH5BPIx+QVSMfkFtjH5Bhox+QZ6MfkG3jH5Bz4x+QeiMfkEBjX5BGY1+QTKNfkFKjX5BY41+QXuNfkGUjX5BrY1+QcWNfkHejX5B9o1+QQ+OfkEnjn5BQI5+QVmOfkFxjn5Bio5+QaKOfkG7jn5B045+QeyOfkEFj35BHY9+QTaPfkFOj35BZ49+QX+PfkGYj35BsY9+QcmPfkHij35B+o9+QROQfkErkH5BRJB+QV2QfkF1kH5BjpB+QaaQfkG/kH5B15B+QfCQfkEJkX5BIZF+QTqRfkFSkX5Ba5F+QYORfkGckX5BtJF+Qc2RfkHmkX5B/pF+QReSfkEvkn5BSJJ+QWCSfkF5kn5BkZJ+QaqSfkHDkn5B25J+QfSSfkEMk35BJZN+QT2TfkFWk35BbpN+QYeTfkGgk35BuJN+QdGTfkHpk35BApR+QRqUfkEzlH5BS5R+QWSUfkF8lH5BlZR+Qa6UfkHGlH5B35R+QfeUfkEQlX5BKJV+QUGVfkFZlX5BcpV+QYqVfkGjlX5BvJV+QdSVfkHtlX5BBZZ+QR6WfkE2ln5BT5Z+QWeWfkGAln5BmJZ+QbGWfkHKln5B4pZ+QfuWfkETl35BLJd+QUSXfkFdl35BdZd+QY6XfkGml35Bv5d+QdeXfkHwl35BCJh+QSGYfkE6mH5BUph+QWuYfkGDmH5BnJh+QbSYfkHNmH5B5Zh+Qf6YfkEWmX5BL5l+QUeZfkFgmX5BeJl+QZGZfkGpmX5Bwpl+QduZfkHzmX5BDJp+QSSafkE9mn5BVZp+QW6afkGGmn5Bn5p+QbeafkHQmn5B6Jp+QQGbfkEZm35BMpt+QUqbfkFjm35Be5t+QZSbfkGsm35BxZt+Qd2bfkH2m35BD5x+QSecfkFAnH5BWJx+QXGcfkGJnH5Bopx+QbqcfkHTnH5B65x+QQSdfkEcnX5BNZ1+QU2dfkFmnX5Bfp1+QZedfkGvnX5ByJ1+QeCdfkH5nX5BEZ5+QSqefkFCnn5BW55+QXOefkGMnn5BpJ5+Qb2efkHVnn5B7p5+QQaffkEfn35BN59+QVCffkFon35BgZ9+QZmffkGyn35Byp9+QeOffkH7n35BFKB+QSygfkFFoH5BXaB+QXagfkGOoH5Bp6B+Qb+gfkHYoH5B8KB+QQmhfkEhoX5BOqF+QVKhfkFroX5Bg6F+QZyhfkG0oX5BzaF+QeWhfkH+oX5BFqJ+QS+ifkFHon5BYKJ+QXiifkGRon5BqaJ+QcKifkHaon5B86J+QQujfkEko35BPKN+QVWjfkFto35BhqN+QZ6jfkG3o35Bz6N+QeijfkEApH5BGKR+QTGkfkFJpH5BYqR+QXqkfkGTpH5Bq6R+QcSkfkHcpH5B9aR+QQ2lfkEmpX5BPqV+QVelfkFvpX5BiKV+QaClfkG5pX5B0aV+QeqlfkECpn5BG6Z+QTOmfkFLpn5BZKZ+QXymfkGVpn5BraZ+QcamfkHepn5B96Z+QQ+nfkEop35BQKd+QVmnfkFxp35Biqd+QaKnfkG7p35B06d+QeunfkEEqH5BHKh+QTWofkFNqH5BZqh+QX6ofkGXqH5Br6h+QciofkHgqH5B+ah+QRGpfkEqqX5BQql+QVqpfkFzqX5Bi6l+QaSpfkG8qX5B1al+Qe2pfkEGqn5BHqp+QTeqfkFPqn5BZ6p+QYCqfkGYqn5Bsap+QcmqfkHiqn5B+qp+QROrfkErq35BRKt+QVyrfkF0q35Bjat+QaWrfkG+q35B1qt+Qe+rfkEHrH5BIKx+QTisfkFRrH5Baax+QYGsfkGarH5Bsqx+QcusfkHjrH5B/Kx+QRStfkEtrX5BRa1+QV2tfkF2rX5Bjq1+QaetfkG/rX5B2K1+QfCtfkEJrn5BIa5+QTmufkFSrn5Baq5+QYOufkGbrn5BtK5+QcyufkHlrn5B/a5+QRWvfkEur35BRq9+QV+vfkF3r35BkK9+QaivfkHAr35B2a9+QfGvfkEKsH5BIrB+QTuwfkFTsH5Ba7B+QYSwfkGcsH5BtbB+Qc2wfkHmsH5B/rB+QRaxfkEvsX5BR7F+QWCxfkF4sX5BkbF+QamxfkHBsX5B2rF+QfKxfkELsn5BI7J+QTyyfkFUsn5BbLJ+QYWyfkGdsn5BtrJ+Qc6yfkHnsn5B/7J+QRezfkEws35BSLN+QWGzfkF5s35BkrN+QaqzfkHCs35B27N+QfOzfkEMtH5BJLR+QTy0fkFVtH5BbbR+QYa0fkGetH5Bt7R+Qc+0fkHntH5BALV+QRi1fkExtX5BSbV+QWG1fkF6tX5BkrV+Qau1fkHDtX5B27V+QfS1fkEMtn5BJbZ+QT22fkFWtn5BbrZ+QYa2fkGftn5Bt7Z+QdC2fkHotn5BALd+QRm3fkExt35BSrd+QWK3fkF6t35Bk7d+Qau3fkHEt35B3Ld+QfS3fkENuH5BJbh+QT64fkFWuH5Bbrh+QYe4fkGfuH5BuLh+QdC4fkHouH5BAbl+QRm5fkEyuX5BSrl+QWK5fkF7uX5Bk7l+Qay5fkHEuX5B3Ll+QfW5fkENun5BJbp+QT66fkFWun5Bb7p+QYe6fkGfun5BuLp+QdC6fkHpun5BAbt+QRm7fkEyu35BSrt+QWO7fkF7u35Bk7t+Qay7fkHEu35B3Lt+QfW7fkENvH5BJrx+QT68fkFWvH5Bb7x+QYe8fkGgvH5BuLx+QdC8fkHpvH5BAb1+QRm9fkEyvX5BSr1+QWO9fkF7vX5Bk71+Qay9fkHEvX5B3L1+QfW9fkENvn5BJr5+QT6+fkFWvn5Bb75+QYe+fkGfvn5BuL5+QdC+fkHpvn5BAb9+QRm/fkEyv35BSr9+QWK/fkF7v35Bk79+Qay/fkHEv35B3L9+QfW/fkENwH5BJcB+QT7AfkFWwH5BbsB+QYfAfkGfwH5BuMB+QdDAfkHowH5BAcF+QRnBfkExwX5BSsF+QWLBfkF6wX5Bk8F+QavBfkHEwX5B3MF+QfTBfkENwn5BJcJ+QT3CfkFWwn5BbsJ+QYbCfkGfwn5Bt8J+QdDCfkHown5BAMN+QRnDfkExw35BScN+QWLDfkF6w35BksN+QavDfkHDw35B28N+QfTDfkEMxH5BJMR+QT3EfkFVxH5BbsR+QYbEfkGexH5Bt8R+Qc/EfkHnxH5BAMV+QRjFfkEwxX5BScV+QWHFfkF5xX5BksV+QarFfkHCxX5B28V+QfPFfkELxn5BJMZ+QTzGfkFUxn5BbcZ+QYXGfkGdxn5BtsZ+Qc7GfkHmxn5B/8Z+QRfHfkEvx35BSMd+QWDHfkF4x35Bkcd+QanHfkHBx35B2sd+QfLHfkEKyH5BI8h+QTvIfkFTyH5BbMh+QYTIfkGcyH5Btch+Qc3IfkHlyH5B/sh+QRbJfkEuyX5BR8l+QV/JfkF3yX5BkMl+QajJfkHAyX5B2cl+QfHJfkEJyn5BIsp+QTrKfkFSyn5Ba8p+QYPKfkGbyn5BtMp+QczKfkHkyn5B/cp+QRXLfkEty35BRst+QV7LfkF2y35Bj8t+QafLfkG/y35B2Mt+QfDLfkEIzH5BIcx+QTnMfkFRzH5Bacx+QYLMfkGazH5Bssx+QcvMfkHjzH5B+8x+QRTNfkEszX5BRM1+QV3NfkF1zX5Bjc1+QabNfkG+zX5B1s1+Qe7NfkEHzn5BH85+QTfOfkFQzn5BaM5+QYDOfkGZzn5Bsc5+QcnOfkHizn5B+s5+QRLPfkEqz35BQ89+QVvPfkFzz35BjM9+QaTPfkG8z35B1c9+Qe3PfkEF0H5BHtB+QTbQfkFO0H5BZtB+QX/QfkGX0H5Br9B+QcjQfkHg0H5B+NB+QRHRfkEp0X5BQdF+QVnRfkFy0X5BitF+QaLRfkG70X5B09F+QevRfkED0n5BHNJ+QTTSfkFM0n5BZdJ+QX3SfkGV0n5BrtJ+QcbSfkHe0n5B9tJ+QQ/TfkEn035BP9N+QVjTfkFw035BiNN+QaDTfkG5035B0dN+QenTfkEC1H5BGtR+QTLUfkFK1H5BY9R+QXvUfkGT1H5BrNR+QcTUfkHc1H5B9NR+QQ3VfkEl1X5BPdV+QVXVfkFu1X5BhtV+QZ7VfkG31X5Bz9V+QefVfkH/1X5BGNZ+QTDWfkFI1n5BYdZ+QXnWfkGR1n5BqdZ+QcLWfkHa1n5B8tZ+QQrXfkEj135BO9d+QVPXfkFs135BhNd+QZzXfkG0135Bzdd+QeXXfkH9135BFdh+QS7YfkFG2H5BXth+QXfYfkGP2H5Bp9h+Qb/YfkHY2H5B8Nh+QQjZfkEg2X5BOdl+QVHZfkFp2X5Bgdl+QZrZfkGy2X5Bytl+QeLZfkH72X5BE9p+QSvafkFE2n5BXNp+QXTafkGM2n5Bpdp+Qb3afkHV2n5B7dp+QQbbfkEe235BNtt+QU7bfkFn235Bf9t+QZfbfkGv235ByNt+QeDbfkH4235BENx+QSncfkFB3H5BWdx+QXHcfkGK3H5Botx+QbrcfkHS3H5B69x+QQPdfkEb3X5BM91+QUzdfkFk3X5BfN1+QZTdfkGt3X5Bxd1+Qd3dfkH13X5BDt5+QSbefkE+3n5BVt5+QW/efkGH3n5Bn95+QbfefkHQ3n5B6N5+QQDffkEY335BMN9+QUnffkFh335Bed9+QZHffkGq335Bwt9+QdrffkHy335BC+B+QSPgfkE74H5BU+B+QWzgfkGE4H5BnOB+QbTgfkHM4H5B5eB+Qf3gfkEV4X5BLeF+QUbhfkFe4X5BduF+QY7hfkGn4X5Bv+F+QdfhfkHv4X5BB+J+QSDifkE44n5BUOJ+QWjifkGB4n5BmeJ+QbHifkHJ4n5B4uJ+QfrifkES435BKuN+QULjfkFb435Bc+N+QYvjfkGj435BvON+QdTjfkHs435BBOR+QRzkfkE15H5BTeR+QWXkfkF95H5BleR+Qa7kfkHG5H5B3uR+QfbkfkEP5X5BJ+V+QT/lfkFX5X5Bb+V+QYjlfkGg5X5BuOV+QdDlfkHo5X5BAeZ+QRnmfkEx5n5BSeZ+QWLmfkF65n5BkuZ+QarmfkHC5n5B2+Z+QfPmfkEL535BI+d+QTvnfkFU535BbOd+QYTnfkGc535BtOd+Qc3nfkHl535B/ed+QRXofkEt6H5BRuh+QV7ofkF26H5Bjuh+QabofkG/6H5B1+h+Qe/ofkEH6X5BH+l+QTjpfkFQ6X5BaOl+QYDpfkGY6X5Bsel+QcnpfkHh6X5B+el+QRHqfkEq6n5BQup+QVrqfkFy6n5Biup+QaPqfkG76n5B0+p+QevqfkED635BHOt+QTTrfkFM635BZOt+QXzrfkGU635Bret+QcXrfkHd635B9et+QQ3sfkEm7H5BPux+QVbsfkFu7H5Bhux+QZ/sfkG37H5Bz+x+QefsfkH/7H5BF+1+QTDtfkFI7X5BYO1+QXjtfkGQ7X5Bqe1+QcHtfkHZ7X5B8e1+QQnufkEh7n5BOu5+QVLufkFq7n5Bgu5+QZrufkGz7n5By+5+QePufkH77n5BE+9+QSvvfkFE735BXO9+QXTvfkGM735BpO9+QbzvfkHV735B7e9+QQXwfkEd8H5BNfB+QU3wfkFm8H5BfvB+QZbwfkGu8H5BxvB+Qd7wfkH38H5BD/F+QSfxfkE/8X5BV/F+QW/xfkGI8X5BoPF+QbjxfkHQ8X5B6PF+QQDyfkEZ8n5BMfJ+QUnyfkFh8n5BefJ+QZHyfkGq8n5BwvJ+QdryfkHy8n5BCvN+QSLzfkE7835BU/N+QWvzfkGD835Bm/N+QbPzfkHL835B5PN+QfzzfkEU9H5BLPR+QUT0fkFc9H5BdfR+QY30fkGl9H5BvfR+QdX0fkHt9H5BBfV+QR71fkE29X5BTvV+QWb1fkF+9X5BlvV+Qa71fkHH9X5B3/V+Qff1fkEP9n5BJ/Z+QT/2fkFX9n5BcPZ+QYj2fkGg9n5BuPZ+QdD2fkHo9n5BAPd+QRn3fkEx935BSfd+QWH3fkF5935Bkfd+Qan3fkHC935B2vd+QfL3fkEK+H5BIvh+QTr4fkFS+H5Ba/h+QYP4fkGb+H5Bs/h+Qcv4fkHj+H5B+/h+QRT5fkEs+X5BRPl+QVz5fkF0+X5BjPl+QaT5fkG8+X5B1fl+Qe35fkEF+n5BHfp+QTX6fkFN+n5BZfp+QX36fkGW+n5Brvp+Qcb6fkHe+n5B9vp+QQ77fkEm+35BPvt+QVf7fkFv+35Bh/t+QZ/7fkG3+35Bz/t+Qef7fkH/+35BGPx+QTD8fkFI/H5BYPx+QXj8fkGQ/H5BqPx+QcD8fkHZ/H5B8fx+QQn9fkEh/X5BOf1+QVH9fkFp/X5Bgf1+QZn9fkGy/X5Byv1+QeL9fkH6/X5BEv5+QSr+fkFC/n5BWv5+QXL+fkGL/n5Bo/5+Qbv+fkHT/n5B6/5+QQP/fkEb/35BM/9+QUv/fkFk/35BfP9+QZT/fkGs/35BxP9+Qdz/fkH0/35BDAB/QSQAf0E9AH9BVQB/QW0Af0GFAH9BnQB/QbUAf0HNAH9B5QB/Qf0Af0EVAX9BLgF/QUYBf0FeAX9BdgF/QY4Bf0GmAX9BvgF/QdYBf0HuAX9BBgJ/QR8Cf0E3An9BTwJ/QWcCf0F/An9BlwJ/Qa8Cf0HHAn9B3wJ/QfcCf0EPA39BKAN/QUADf0FYA39BcAN/QYgDf0GgA39BuAN/QdADf0HoA39BAAR/QRgEf0ExBH9BSQR/QWEEf0F5BH9BkQR/QakEf0HBBH9B2QR/QfEEf0EJBX9BIQV/QToFf0FSBX9BagV/QYIFf0GaBX9BsgV/QcoFf0HiBX9B+gV/QRIGf0EqBn9BQgZ/QVoGf0FzBn9BiwZ/QaMGf0G7Bn9B0wZ/QesGf0EDB39BGwd/QTMHf0FLB39BYwd/QXsHf0GTB39BrAd/QcQHf0HcB39B9Ad/QQwIf0EkCH9BPAh/QVQIf0FsCH9BhAh/QZwIf0G0CH9BzAh/QeQIf0H9CH9BFQl/QS0Jf0FFCX9BXQl/QXUJf0GNCX9BpQl/Qb0Jf0HVCX9B7Ql/QQUKf0EdCn9BNQp/QU0Kf0FmCn9Bfgp/QZYKf0GuCn9Bxgp/Qd4Kf0H2Cn9BDgt/QSYLf0E+C39BVgt/QW4Lf0GGC39Bngt/QbYLf0HOC39B5gt/Qf8Lf0EXDH9BLwx/QUcMf0FfDH9Bdwx/QY8Mf0GnDH9Bvwx/QdcMf0HvDH9BBw1/QR8Nf0E3DX9BTw1/QWcNf0F/DX9Blw1/QbANf0HIDX9B4A1/QfgNf0EQDn9BKA5/QUAOf0FYDn9BcA5/QYgOf0GgDn9BuA5/QdAOf0HoDn9BAA9/QRgPf0EwD39BSA9/QWAPf0F4D39BkA9/QagPf0HAD39B2Q9/QfEPf0EJEH9BIRB/QTkQf0FREH9BaRB/QYEQf0GZEH9BsRB/QckQf0HhEH9B+RB/QRERf0EpEX9BQRF/QVkRf0FxEX9BiRF/QaERf0G5EX9B0RF/QekRf0EBEn9BGRJ/QTESf0FJEn9BYRJ/QXoSf0GSEn9BqhJ/QcISf0HaEn9B8hJ/QQoTf0EiE39BOhN/QVITf0FqE39BghN/QZoTf0GyE39ByhN/QeITf0H6E39BEhR/QSoUf0FCFH9BWhR/QXIUf0GKFH9BohR/QboUf0HSFH9B6hR/QQIVf0EaFX9BMhV/QUoVf0FiFX9BehV/QZIVf0GqFX9BwhV/QdoVf0HyFX9BChZ/QSIWf0E6Fn9BUhZ/QWoWf0GCFn9BmhZ/QbIWf0HKFn9B4xZ/QfsWf0ETF39BKxd/QUMXf0FbF39Bcxd/QYsXf0GjF39Buxd/QdMXf0HrF39BAxh/QRsYf0EzGH9BSxh/QWMYf0F7GH9Bkxh/QasYf0HDGH9B2xh/QfMYf0ELGX9BIxl/QTsZf0FTGX9Baxl/QYMZf0GbGX9Bsxl/QcsZf0HjGX9B+xl/QRMaf0ErGn9BQxp/QVsaf0FzGn9Bixp/QaMaf0G7Gn9B0xp/Qesaf0EDG39BGxt/QTMbf0FLG39BYxt/QXsbf0GTG39Bqxt/QcMbf0HbG39B8xt/QQscf0EjHH9BOxx/QVMcf0FrHH9Bgxx/QZscf0GzHH9Byxx/QeIcf0H6HH9BEh1/QSodf0FCHX9BWh1/QXIdf0GKHX9Boh1/Qbodf0HSHX9B6h1/QQIef0EaHn9BMh5/QUoef0FiHn9Beh5/QZIef0GqHn9Bwh5/Qdoef0HyHn9BCh9/QSIff0E6H39BUh9/QWoff0GCH39Bmh9/QbIff0HKH39B4h9/Qfoff0ESIH9BKiB/QUIgf0FaIH9BciB/QYogf0GiIH9BuiB/QdIgf0HqIH9BAiF/QRohf0EyIX9BSSF/QWEhf0F5IX9BkSF/Qakhf0HBIX9B2SF/QfEhf0EJIn9BISJ/QTkif0FRIn9BaSJ/QYEif0GZIn9BsSJ/Qckif0HhIn9B+SJ/QREjf0EpI39BQSN/QVkjf0FxI39BiSN/QaEjf0G5I39B0SN/Qegjf0EAJH9BGCR/QTAkf0FIJH9BYCR/QXgkf0GQJH9BqCR/QcAkf0HYJH9B8CR/QQglf0EgJX9BOCV/QVAlf0FoJX9BgCV/QZglf0GwJX9ByCV/QeAlf0H3JX9BDyZ/QScmf0E/Jn9BVyZ/QW8mf0GHJn9BnyZ/Qbcmf0HPJn9B5yZ/Qf8mf0EXJ39BLyd/QUcnf0FfJ39Bdyd/QY8nf0GnJ39Bvid/QdYnf0HuJ39BBih/QR4of0E2KH9BTih/QWYof0F+KH9Blih/Qa4of0HGKH9B3ih/QfYof0EOKX9BJil/QT4pf0FVKX9BbSl/QYUpf0GdKX9BtSl/Qc0pf0HlKX9B/Sl/QRUqf0EtKn9BRSp/QV0qf0F1Kn9BjSp/QaUqf0G8Kn9B1Cp/Qewqf0EEK39BHCt/QTQrf0FMK39BZCt/QXwrf0GUK39BrCt/QcQrf0HcK39B9Ct/QQssf0EjLH9BOyx/QVMsf0FrLH9Bgyx/QZssf0GzLH9Byyx/QeMsf0H7LH9BEy1/QSstf0FCLX9BWi1/QXItf0GKLX9Boi1/Qbotf0HSLX9B6i1/QQIuf0EaLn9BMi5/QUouf0FiLn9BeS5/QZEuf0GpLn9BwS5/Qdkuf0HxLn9BCS9/QSEvf0E5L39BUS9/QWkvf0GAL39BmC9/QbAvf0HIL39B4C9/Qfgvf0EQMH9BKDB/QUAwf0FYMH9BcDB/QYgwf0GfMH9BtzB/Qc8wf0HnMH9B/zB/QRcxf0EvMX9BRzF/QV8xf0F3MX9BjjF/QaYxf0G+MX9B1jF/Qe4xf0EGMn9BHjJ/QTYyf0FOMn9BZjJ/QX0yf0GVMn9BrTJ/QcUyf0HdMn9B9TJ/QQ0zf0ElM39BPTN/QVUzf0FsM39BhDN/QZwzf0G0M39BzDN/QeQzf0H8M39BFDR/QSw0f0FENH9BWzR/QXM0f0GLNH9BozR/Qbs0f0HTNH9B6zR/QQM1f0EbNX9BMjV/QUo1f0FiNX9BejV/QZI1f0GqNX9BwjV/Qdo1f0HyNX9BCTZ/QSE2f0E5Nn9BUTZ/QWk2f0GBNn9BmTZ/QbE2f0HINn9B4DZ/Qfg2f0EQN39BKDd/QUA3f0FYN39BcDd/QYg3f0GfN39Btzd/Qc83f0HnN39B/zd/QRc4f0EvOH9BRzh/QV44f0F2OH9Bjjh/QaY4f0G+OH9B1jh/Qe44f0EGOX9BHTl/QTU5f0FNOX9BZTl/QX05f0GVOX9BrTl/QcU5f0HcOX9B9Dl/QQw6f0EkOn9BPDp/QVQ6f0FsOn9Bgzp/QZs6f0GzOn9Byzp/QeM6f0H7On9BEzt/QSs7f0FCO39BWjt/QXI7f0GKO39Bojt/Qbo7f0HSO39B6Tt/QQE8f0EZPH9BMTx/QUk8f0FhPH9BeTx/QZA8f0GoPH9BwDx/Qdg8f0HwPH9BCD1/QSA9f0E4PX9BTz1/QWc9f0F/PX9Blz1/Qa89f0HHPX9B3j1/QfY9f0EOPn9BJj5/QT4+f0FWPn9Bbj5/QYU+f0GdPn9BtT5/Qc0+f0HlPn9B/T5/QRU/f0EsP39BRD9/QVw/f0F0P39BjD9/QaQ/f0G7P39B0z9/Qes/f0EDQH9BG0B/QTNAf0FLQH9BYkB/QXpAf0GSQH9BqkB/QcJAf0HaQH9B8UB/QQlBf0EhQX9BOUF/QVFBf0FpQX9BgUF/QZhBf0GwQX9ByEF/QeBBf0H4QX9BEEJ/QSdCf0E/Qn9BV0J/QW9Cf0GHQn9Bn0J/QbZCf0HOQn9B5kJ/Qf5Cf0EWQ39BLkN/QUVDf0FdQ39BdUN/QY1Df0GlQ39BvUN/QdRDf0HsQ39BBER/QRxEf0E0RH9BTER/QWNEf0F7RH9Bk0R/QatEf0HDRH9B2kR/QfJEf0EKRX9BIkV/QTpFf0FSRX9BaUV/QYFFf0GZRX9BsUV/QclFf0HhRX9B+EV/QRBGf0EoRn9BQEZ/QVhGf0FvRn9Bh0Z/QZ9Gf0G3Rn9Bz0Z/QedGf0H+Rn9BFkd/QS5Hf0FGR39BXkd/QXVHf0GNR39BpUd/Qb1Hf0HVR39B7Ud/QQRIf0EcSH9BNEh/QUxIf0FkSH9Be0h/QZNIf0GrSH9Bw0h/QdtIf0HySH9BCkl/QSJJf0E6SX9BUkl/QWpJf0GBSX9BmUl/QbFJf0HJSX9B4Ul/QfhJf0EQSn9BKEp/QUBKf0FYSn9Bb0p/QYdKf0GfSn9Bt0p/Qc9Kf0HmSn9B/kp/QRZLf0EuS39BRkt/QV1Lf0F1S39BjUt/QaVLf0G9S39B1Et/QexLf0EETH9BHEx/QTRMf0FLTH9BY0x/QXtMf0GTTH9Bq0x/QcJMf0HaTH9B8kx/QQpNf0EiTX9BOU1/QVFNf0FpTX9BgU1/QZhNf0GwTX9ByE1/QeBNf0H4TX9BD05/QSdOf0E/Tn9BV05/QW9Of0GGTn9Bnk5/QbZOf0HOTn9B5U5/Qf1Of0EVT39BLU9/QUVPf0FcT39BdE9/QYxPf0GkT39BvE9/QdNPf0HrT39BA1B/QRtQf0EyUH9BSlB/QWJQf0F6UH9BklB/QalQf0HBUH9B2VB/QfFQf0EIUX9BIFF/QThRf0FQUX9BaFF/QX9Rf0GXUX9Br1F/QcdRf0HeUX9B9lF/QQ5Sf0EmUn9BPlJ/QVVSf0FtUn9BhVJ/QZ1Sf0G0Un9BzFJ/QeRSf0H8Un9BE1N/QStTf0FDU39BW1N/QXNTf0GKU39BolN/QbpTf0HSU39B6VN/QQFUf0EZVH9BMVR/QUhUf0FgVH9BeFR/QZBUf0GnVH9Bv1R/QddUf0HvVH9BB1V/QR5Vf0E2VX9BTlV/QWZVf0F9VX9BlVV/Qa1Vf0HFVX9B3FV/QfRVf0EMVn9BJFZ/QTtWf0FTVn9Ba1Z/QYNWf0GaVn9BslZ/QcpWf0HiVn9B+VZ/QRFXf0EpV39BQVd/QVhXf0FwV39BiFd/QaBXf0G3V39Bz1d/QedXf0H/V39BFlh/QS5Yf0FGWH9BXlh/QXVYf0GNWH9BpVh/Qb1Yf0HUWH9B7Fh/QQRZf0EcWX9BM1l/QUtZf0FjWX9Be1l/QZJZf0GqWX9Bwll/QdpZf0HxWX9BCVp/QSFaf0E5Wn9BUFp/QWhaf0GAWn9Bl1p/Qa9af0HHWn9B31p/QfZaf0EOW39BJlt/QT5bf0FVW39BbVt/QYVbf0GdW39BtFt/Qcxbf0HkW39B/Ft/QRNcf0ErXH9BQ1x/QVpcf0FyXH9Bilx/QaJcf0G5XH9B0Vx/Qelcf0EBXX9BGF1/QTBdf0FIXX9BX11/QXddf0GPXX9Bp11/Qb5df0HWXX9B7l1/QQZef0EdXn9BNV5/QU1ef0FkXn9BfF5/QZRef0GsXn9Bw15/Qdtef0HzXn9BC19/QSJff0E6X39BUl9/QWlff0GBX39BmV9/QbFff0HIX39B4F9/Qfhff0EPYH9BJ2B/QT9gf0FXYH9BbmB/QYZgf0GeYH9BtWB/Qc1gf0HlYH9B/WB/QRRhf0EsYX9BRGF/QVthf0FzYX9Bi2F/QaNhf0G6YX9B0mF/Qephf0EBYn9BGWJ/QTFif0FIYn9BYGJ/QXhif0GQYn9Bp2J/Qb9if0HXYn9B7mJ/QQZjf0EeY39BNmN/QU1jf0FlY39BfWN/QZRjf0GsY39BxGN/Qdtjf0HzY39BC2R/QSNkf0E6ZH9BUmR/QWpkf0GBZH9BmWR/QbFkf0HIZH9B4GR/Qfhkf0EQZX9BJ2V/QT9lf0FXZX9BbmV/QYZlf0GeZX9BtWV/Qc1lf0HlZX9B/GV/QRRmf0EsZn9BRGZ/QVtmf0FzZn9Bi2Z/QaJmf0G6Zn9B0mZ/Qelmf0EBZ39BGWd/QTBnf0FIZ39BYGd/QXhnf0GPZ39Bp2d/Qb9nf0HWZ39B7md/QQZof0EdaH9BNWh/QU1of0FkaH9BfGh/QZRof0GraH9Bw2h/Qdtof0HyaH9BCml/QSJpf0E6aX9BUWl/QWlpf0GBaX9BmGl/QbBpf0HIaX9B32l/Qfdpf0EPan9BJmp/QT5qf0FWan9BbWp/QYVqf0Gdan9BtGp/Qcxqf0Hkan9B+2p/QRNrf0Era39BQmt/QVprf0Fya39BiWt/QaFrf0G5a39B0Gt/Qehrf0EAbH9BF2x/QS9sf0FHbH9BXmx/QXZsf0GObH9BpWx/Qb1sf0HVbH9B7Gx/QQRtf0EcbX9BM21/QUttf0FjbX9Bem1/QZJtf0GqbX9BwW1/Qdltf0HxbX9BCG5/QSBuf0E4bn9BT25/QWduf0F/bn9Blm5/Qa5uf0HGbn9B3W5/QfVuf0ENb39BJG9/QTxvf0FUb39Ba29/QYNvf0Gbb39Bsm9/Qcpvf0Hhb39B+W9/QRFwf0EocH9BQHB/QVhwf0FvcH9Bh3B/QZ9wf0G2cH9BznB/QeZwf0H9cH9BFXF/QS1xf0FEcX9BXHF/QXRxf0GLcX9Bo3F/Qbpxf0HScX9B6nF/QQFyf0EZcn9BMXJ/QUhyf0Fgcn9BeHJ/QY9yf0Gncn9Bv3J/QdZyf0Hucn9BBXN/QR1zf0E1c39BTHN/QWRzf0F8c39Bk3N/Qatzf0HDc39B2nN/QfJzf0EJdH9BIXR/QTl0f0FQdH9BaHR/QYB0f0GXdH9Br3R/Qcd0f0HedH9B9nR/QQ11f0EldX9BPXV/QVR1f0FsdX9BhHV/QZt1f0GzdX9By3V/QeJ1f0H6dX9BEXZ/QSl2f0FBdn9BWHZ/QXB2f0GIdn9Bn3Z/Qbd2f0HOdn9B5nZ/Qf52f0EVd39BLXd/QUV3f0Fcd39BdHd/QYt3f0Gjd39Bu3d/QdJ3f0Hqd39BAnh/QRl4f0ExeH9BSHh/QWB4f0F4eH9Bj3h/Qad4f0G+eH9B1nh/Qe54f0EFeX9BHXl/QTV5f0FMeX9BZHl/QXt5f0GTeX9Bq3l/QcJ5f0HaeX9B8Xl/QQl6f0Ehen9BOHp/QVB6f0Foen9Bf3p/QZd6f0Guen9Bxnp/Qd56f0H1en9BDXt/QSR7f0E8e39BVHt/QWt7f0GDe39Bmnt/QbJ7f0HKe39B4Xt/Qfl7f0EQfH9BKHx/QUB8f0FXfH9Bb3x/QYZ8f0GefH9Btnx/Qc18f0HlfH9B/Hx/QRR9f0EsfX9BQ31/QVt9f0FyfX9Bin1/QaJ9f0G5fX9B0X1/Qeh9f0EAfn9BGH5/QS9+f0FHfn9BXn5/QXZ+f0GOfn9BpX5/Qb1+f0HUfn9B7H5/QQR/f0Ebf39BM39/QUp/f0Fif39Ben9/QZF/f0Gpf39BwH9/Qdh/f0Hwf39BB4B/QR+Af0E2gH9BToB/QWWAf0F9gH9BlYB/QayAf0HEgH9B24B/QfOAf0ELgX9BIoF/QTqBf0FRgX9BaYF/QYCBf0GYgX9BsIF/QceBf0HfgX9B9oF/QQ6Cf0Emgn9BPYJ/QVWCf0Fsgn9BhIJ/QZuCf0Gzgn9By4J/QeKCf0H6gn9BEYN/QSmDf0FAg39BWIN/QXCDf0GHg39Bn4N/QbaDf0HOg39B5YN/Qf2Df0EVhH9BLIR/QUSEf0FbhH9Bc4R/QYuEf0GihH9BuoR/QdGEf0HphH9BAIV/QRiFf0EvhX9BR4V/QV+Ff0F2hX9BjoV/QaWFf0G9hX9B1IV/QeyFf0EEhn9BG4Z/QTOGf0FKhn9BYoZ/QXmGf0GRhn9BqYZ/QcCGf0HYhn9B74Z/QQeHf0Eeh39BNod/QU2Hf0Flh39BfYd/QZSHf0Gsh39Bw4d/QduHf0Hyh39BCoh/QSGIf0E5iH9BUYh/QWiIf0GAiH9Bl4h/Qa+If0HGiH9B3oh/QfWIf0ENiX9BJYl/QTyJf0FUiX9Ba4l/QYOJf0GaiX9Bsol/QcmJf0HhiX9B+Yl/QRCKf0Eoin9BP4p/QVeKf0Fuin9Bhop/QZ2Kf0G1in9BzIp/QeSKf0H8in9BE4t/QSuLf0FCi39BWot/QXGLf0GJi39BoIt/QbiLf0HPi39B54t/Qf+Lf0EWjH9BLox/QUWMf0FdjH9BdIx/QYyMf0GjjH9Bu4x/QdKMf0HqjH9BAY1/QRmNf0ExjX9BSI1/QWCNf0F3jX9Bj41/QaaNf0G+jX9B1Y1/Qe2Nf0EEjn9BHI5/QTOOf0FLjn9BYo5/QXqOf0GSjn9BqY5/QcGOf0HYjn9B8I5/QQePf0Efj39BNo9/QU6Pf0Flj39BfY9/QZSPf0Gsj39Bw49/QduPf0Hyj39BCpB/QSGQf0E5kH9BUZB/QWiQf0GAkH9Bl5B/Qa+Qf0HGkH9B3pB/QfWQf0ENkX9BJJF/QTyRf0FTkX9Ba5F/QYKRf0GakX9BsZF/QcmRf0HgkX9B+JF/QQ+Sf0Enkn9BPpJ/QVaSf0Ftkn9BhZJ/QZySf0G0kn9BzJJ/QeOSf0H7kn9BEpN/QSqTf0FBk39BWZN/QXCTf0GIk39Bn5N/QbeTf0HOk39B5pN/Qf2Tf0EVlH9BLJR/QUSUf0FblH9Bc5R/QYqUf0GilH9BuZR/QdGUf0HolH9BAJV/QReVf0EvlX9BRpV/QV6Vf0F1lX9BjZV/QaSVf0G8lX9B05V/QeuVf0ECln9BGpZ/QTGWf0FJln9BYJZ/QXiWf0GPln9Bp5Z/Qb6Wf0HWln9B7ZZ/QQWXf0Ecl39BNJd/QUuXf0Fjl39Bepd/QZKXf0Gpl39BwZd/QdiXf0Hwl39BB5h/QR+Yf0E2mH9BTph/QWWYf0F9mH9BlJh/QayYf0HDmH9B25h/QfKYf0EKmX9BIZl/QTmZf0FQmX9BaJl/QX+Zf0GXmX9Brpl/QcaZf0HdmX9B9Jl/QQyaf0Ejmn9BO5p/QVKaf0Fqmn9BgZp/QZmaf0Gwmn9ByJp/Qd+af0H3mn9BDpt/QSabf0E9m39BVZt/QWybf0GEm39Bm5t/QbObf0HKm39B4pt/Qfmbf0ERnH9BKJx/QT+cf0FXnH9Bbpx/QYacf0GdnH9BtZx/Qcycf0HknH9B+5x/QROdf0EqnX9BQp1/QVmdf0FxnX9BiJ1/QaCdf0G3nX9Bz51/Qeadf0H9nX9BFZ5/QSyef0FEnn9BW55/QXOef0GKnn9Bop5/Qbmef0HRnn9B6J5/QQCff0EXn39BL59/QUaff0Fdn39BdZ9/QYyff0Gkn39Bu59/QdOff0Hqn39BAqB/QRmgf0ExoH9BSKB/QWCgf0F3oH9BjqB/Qaagf0G9oH9B1aB/Qeygf0EEoX9BG6F/QTOhf0FKoX9BYqF/QXmhf0GQoX9BqKF/Qb+hf0HXoX9B7qF/QQaif0Edon9BNaJ/QUyif0Fkon9Be6J/QZKif0Gqon9BwaJ/Qdmif0Hwon9BCKN/QR+jf0E3o39BTqN/QWajf0F9o39BlKN/Qayjf0HDo39B26N/QfKjf0EKpH9BIaR/QTmkf0FQpH9BZ6R/QX+kf0GWpH9BrqR/QcWkf0HdpH9B9KR/QQylf0EjpX9BOqV/QVKlf0FppX9BgaV/QZilf0GwpX9Bx6V/Qd6lf0H2pX9BDaZ/QSWmf0E8pn9BVKZ/QWumf0GDpn9BmqZ/QbGmf0HJpn9B4KZ/Qfimf0EPp39BJ6d/QT6nf0FVp39Bbad/QYSnf0Gcp39Bs6d/Qcunf0Hip39B+ad/QRGof0EoqH9BQKh/QVeof0FvqH9Bhqh/QZ2of0G1qH9BzKh/QeSof0H7qH9BE6l/QSqpf0FBqX9BWal/QXCpf0GIqX9Bn6l/Qbepf0HOqX9B5al/Qf2pf0EUqn9BLKp/QUOqf0Faqn9Bcqp/QYmqf0Ghqn9BuKp/QdCqf0Hnqn9B/qp/QRarf0Etq39BRat/QVyrf0F0q39Bi6t/QaKrf0G6q39B0at/Qemrf0EArH9BF6x/QS+sf0FGrH9BXqx/QXWsf0GMrH9BpKx/Qbusf0HTrH9B6qx/QQKtf0EZrX9BMK1/QUitf0FfrX9Bd61/QY6tf0GlrX9Bva1/QdStf0HsrX9BA65/QRquf0Eyrn9BSa5/QWGuf0F4rn9Bj65/Qaeuf0G+rn9B1q5/Qe2uf0EEr39BHK9/QTOvf0FLr39BYq9/QXmvf0GRr39BqK9/QcCvf0HXr39B7q9/QQawf0EdsH9BNbB/QUywf0FjsH9Be7B/QZKwf0GqsH9BwbB/Qdiwf0HwsH9BB7F/QR+xf0E2sX9BTbF/QWWxf0F8sX9BlLF/Qauxf0HCsX9B2rF/QfGxf0EJsn9BILJ/QTeyf0FPsn9BZrJ/QX2yf0GVsn9BrLJ/QcSyf0Hbsn9B8rJ/QQqzf0Ehs39BObN/QVCzf0Fns39Bf7N/QZazf0Gts39BxbN/Qdyzf0H0s39BC7R/QSK0f0E6tH9BUbR/QWm0f0GAtH9Bl7R/Qa+0f0HGtH9B3bR/QfW0f0EMtX9BJLV/QTu1f0FStX9BarV/QYG1f0GYtX9BsLV/Qce1f0HftX9B9rV/QQ22f0Eltn9BPLZ/QVO2f0Frtn9BgrZ/QZq2f0Gxtn9ByLZ/QeC2f0H3tn9BDrd/QSa3f0E9t39BVLd/QWy3f0GDt39Bm7d/QbK3f0HJt39B4bd/Qfi3f0EPuH9BJ7h/QT64f0FWuH9Bbbh/QYS4f0GcuH9Bs7h/Qcq4f0HiuH9B+bh/QRC5f0EouX9BP7l/QVe5f0FuuX9Bhbl/QZ25f0G0uX9By7l/QeO5f0H6uX9BEbp/QSm6f0FAun9BV7p/QW+6f0GGun9Bnrp/QbW6f0HMun9B5Lp/Qfu6f0ESu39BKrt/QUG7f0FYu39BcLt/QYe7f0Geu39Btrt/Qc27f0Hku39B/Lt/QRO8f0ErvH9BQrx/QVm8f0FxvH9BiLx/QZ+8f0G3vH9Bzrx/QeW8f0H9vH9BFL1/QSu9f0FDvX9BWr1/QXG9f0GJvX9BoL1/Qbe9f0HPvX9B5r1/Qf29f0EVvn9BLL5/QUO+f0Fbvn9Bcr5/QYq+f0Ghvn9BuL5/QdC+f0Hnvn9B/r5/QRa/f0Etv39BRL9/QVy/f0Fzv39Bir9/QaK/f0G5v39B0L9/Qei/f0H/v39BFsB/QS7Af0FFwH9BXMB/QXTAf0GLwH9BosB/QbrAf0HRwH9B6MB/QQDBf0EXwX9BLsF/QUbBf0FdwX9BdMF/QYzBf0GjwX9BusF/QdLBf0HpwX9BAMJ/QRfCf0Evwn9BRsJ/QV3Cf0F1wn9BjMJ/QaPCf0G7wn9B0sJ/QenCf0EBw39BGMN/QS/Df0FHw39BXsN/QXXDf0GNw39BpMN/QbvDf0HTw39B6sN/QQHEf0EZxH9BMMR/QUfEf0FfxH9BdsR/QY3Ef0GkxH9BvMR/QdPEf0HqxH9BAsV/QRnFf0EwxX9BSMV/QV/Ff0F2xX9BjsV/QaXFf0G8xX9B1MV/QevFf0ECxn9BGsZ/QTHGf0FIxn9BX8Z/QXfGf0GOxn9BpcZ/Qb3Gf0HUxn9B68Z/QQPHf0Eax39BMcd/QUnHf0Fgx39Bd8d/QY7Hf0Gmx39Bvcd/QdTHf0Hsx39BA8h/QRrIf0EyyH9BSch/QWDIf0F3yH9Bj8h/QabIf0G9yH9B1ch/QezIf0EDyX9BG8l/QTLJf0FJyX9BYMl/QXjJf0GPyX9Bpsl/Qb7Jf0HVyX9B7Ml/QQTKf0Ebyn9BMsp/QUnKf0Fhyn9BeMp/QY/Kf0Gnyn9Bvsp/QdXKf0Hsyn9BBMt/QRvLf0Eyy39BSst/QWHLf0F4y39Bj8t/QafLf0G+y39B1ct/Qe3Lf0EEzH9BG8x/QTLMf0FKzH9BYcx/QXjMf0GQzH9Bp8x/Qb7Mf0HVzH9B7cx/QQTNf0EbzX9BM81/QUrNf0FhzX9BeM1/QZDNf0GnzX9Bvs1/QdbNf0HtzX9BBM5/QRvOf0Ezzn9BSs5/QWHOf0F5zn9BkM5/QafOf0G+zn9B1s5/Qe3Of0EEz39BG89/QTPPf0FKz39BYc9/QXnPf0GQz39Bp89/Qb7Pf0HWz39B7c9/QQTQf0Eb0H9BM9B/QUrQf0Fh0H9BedB/QZDQf0Gn0H9BvtB/QdbQf0Ht0H9BBNF/QRvRf0Ez0X9BStF/QWHRf0F50X9BkNF/QafRf0G+0X9B1tF/Qe3Rf0EE0n9BG9J/QTPSf0FK0n9BYdJ/QXjSf0GQ0n9Bp9J/Qb7Sf0HV0n9B7dJ/QQTTf0Eb039BMtN/QUrTf0Fh039BeNN/QZDTf0Gn039BvtN/QdXTf0Ht039BBNR/QRvUf0Ey1H9BStR/QWHUf0F41H9Bj9R/QafUf0G+1H9B1dR/QezUf0EE1X9BG9V/QTLVf0FJ1X9BYdV/QXjVf0GP1X9BptV/Qb7Vf0HV1X9B7NV/QQPWf0Eb1n9BMtZ/QUnWf0Fg1n9BeNZ/QY/Wf0Gm1n9BvdZ/QdXWf0Hs1n9BA9d/QRrXf0Ey139BSdd/QWDXf0F3139Bjtd/QabXf0G9139B1Nd/QevXf0ED2H9BGth/QTHYf0FI2H9BYNh/QXfYf0GO2H9Bpdh/Qb3Yf0HU2H9B69h/QQLZf0Ea2X9BMdl/QUjZf0Ff2X9Bdtl/QY7Zf0Gl2X9BvNl/QdPZf0Hr2X9BAtp/QRnaf0Ew2n9BSNp/QV/af0F22n9Bjdp/QaXaf0G82n9B09p/Qeraf0EB239BGdt/QTDbf0FH239BXtt/QXbbf0GN239BpNt/Qbvbf0HS239B6tt/QQHcf0EY3H9BL9x/QUfcf0Fe3H9Bddx/QYzcf0Gj3H9Bu9x/QdLcf0Hp3H9BAN1/QRjdf0Ev3X9BRt1/QV3df0F03X9BjN1/QaPdf0G63X9B0d1/Qendf0EA3n9BF95/QS7ef0FF3n9BXd5/QXTef0GL3n9Bot5/Qbnef0HR3n9B6N5/Qf/ef0EW339BLt9/QUXff0Fc339Bc99/QYrff0Gi339Bud9/QdDff0Hn339B/t9/QRbgf0Et4H9BROB/QVvgf0Fy4H9BiuB/QaHgf0G44H9Bz+B/Qebgf0H+4H9BFeF/QSzhf0FD4X9BW+F/QXLhf0GJ4X9BoOF/Qbfhf0HP4X9B5uF/Qf3hf0EU4n9BK+J/QUPif0Fa4n9BceJ/QYjif0Gf4n9Bt+J/Qc7if0Hl4n9B/OJ/QRPjf0Er439BQuN/QVnjf0Fw439Bh+N/QZ7jf0G2439BzeN/QeTjf0H7439BEuR/QSrkf0FB5H9BWOR/QW/kf0GG5H9BnuR/QbXkf0HM5H9B4+R/Qfrkf0ES5X9BKeV/QUDlf0FX5X9BbuV/QYXlf0Gd5X9BtOV/Qcvlf0Hi5X9B+eV/QRHmf0Eo5n9BP+Z/QVbmf0Ft5n9BheZ/QZzmf0Gz5n9ByuZ/QeHmf0H45n9BEOd/QSfnf0E+539BVed/QWznf0GE539Bm+d/QbLnf0HJ539B4Od/Qffnf0EP6H9BJuh/QT3of0FU6H9Ba+h/QYLof0Ga6H9Bseh/Qcjof0Hf6H9B9uh/QQ3pf0El6X9BPOl/QVPpf0Fq6X9Bgel/QZnpf0Gw6X9Bx+l/Qd7pf0H16X9BDOp/QSTqf0E76n9BUup/QWnqf0GA6n9Bl+p/Qa/qf0HG6n9B3ep/QfTqf0EL639BIut/QTrrf0FR639BaOt/QX/rf0GW639Bret/QcXrf0Hc639B8+t/QQrsf0Eh7H9BOOx/QU/sf0Fn7H9Bfux/QZXsf0Gs7H9Bw+x/Qdrsf0Hy7H9BCe1/QSDtf0E37X9BTu1/QWXtf0F97X9BlO1/Qavtf0HC7X9B2e1/QfDtf0EH7n9BH+5/QTbuf0FN7n9BZO5/QXvuf0GS7n9Bqu5/QcHuf0HY7n9B7+5/QQbvf0Ed739BNO9/QUzvf0Fj739Beu9/QZHvf0Go739Bv+9/Qdbvf0Hu739BBfB/QRzwf0Ez8H9BSvB/QWHwf0F48H9BkPB/Qafwf0G+8H9B1fB/Qezwf0ED8X9BGvF/QTLxf0FJ8X9BYPF/QXfxf0GO8X9BpfF/Qbzxf0HU8X9B6/F/QQLyf0EZ8n9BMPJ/QUfyf0Fe8n9BdvJ/QY3yf0Gk8n9Bu/J/QdLyf0Hp8n9BAPN/QRjzf0Ev839BRvN/QV3zf0F0839Bi/N/QaLzf0G5839B0fN/Qejzf0H/839BFvR/QS30f0FE9H9BW/R/QXL0f0GK9H9BofR/Qbj0f0HP9H9B5vR/Qf30f0EU9X9BK/V/QUP1f0Fa9X9BcfV/QYj1f0Gf9X9BtvV/Qc31f0Hk9X9B/PV/QRP2f0Eq9n9BQfZ/QVj2f0Fv9n9BhvZ/QZ32f0G19n9BzPZ/QeP2f0H69n9BEfd/QSj3f0E/939BVvd/QW73f0GF939BnPd/QbP3f0HK939B4fd/Qfj3f0EP+H9BJvh/QT74f0FV+H9BbPh/QYP4f0Ga+H9Bsfh/Qcj4f0Hf+H9B9vh/QQ75f0El+X9BPPl/QVP5f0Fq+X9Bgfl/QZj5f0Gv+X9Bxvl/Qd75f0H1+X9BDPp/QSP6f0E6+n9BUfp/QWj6f0F/+n9Blvp/Qa36f0HF+n9B3Pp/QfP6f0EK+39BIft/QTj7f0FP+39BZvt/QX37f0GV+39BrPt/QcP7f0Ha+39B8ft/QQj8f0Ef/H9BNvx/QU38f0Fk/H9Be/x/QZP8f0Gq/H9Bwfx/Qdj8f0Hv/H9BBv1/QR39f0E0/X9BS/1/QWL9f0F6/X9Bkf1/Qaj9f0G//X9B1v1/Qe39f0EE/n9BG/5/QTL+f0FJ/n9BYP5/QXj+f0GP/n9Bpv5/Qb3+f0HU/n9B6/5/QQL/f0EZ/39BMP9/QUf/f0Fe/39Bdf9/QY3/f0Gk/39Bu/9/QdL/f0Hp/39BtlgQAGQAAAA4AAAAGAAAALZYEABkAAAAOAAAAC4AAAAQAAAAtlgQAGQAAABCAAAAFAAAALZYEABkAAAAPgAAAAkAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQALZYEABkAAAARwAAAAkAQcqH8wALxwiAPw3gyj8AAABAeJoUQAdwJUC0qzNAAABAQA3gSkB4mlRAVGddQAdwZUAB1GxAtKtzQH8KekAAAIBAf8yCQAdwhUAG74dAPE2KQN2NjECqs45ABcGQQAO4kkB4mpRAAWqWQAoomEDa1ZlAlXSbQD8FnUDHiJ5AAACgQK1roUB/zKJAFiOkQAdwpUDYs6ZABu+nQAQiqUA8TapAEXGrQN2NrED2o61AqrOuQEO9r0AFwbBAMb+xQAO4skC0q7NAeJq0QIKEtUABarZAIEu3QAoouEDmALlA2tW5QAmnukCVdLtAnT68QD8FvUCayL1Ax4i+QOFFv0AAAMBAPbfAQK1rwUBnHcJAf8zCQAh5w0AWI8RAusrEQAdwxUALE8ZA2LPGQHxSx0AG78dAhInIQAQiyUCSuMlAPE3KQA3gykARcctAUwDMQN2NzEC7Gc1A9qPNQJgszkCqs85ANTnPQEO9z0DbP9BABcHQQMpA0UAxv9FAQjzSQAO40kB8MtNAtKvTQLAj1EB4mtRAEhDVQIKE1UDQ99VAAWrWQBnb1kAgS9dAGbrXQAoo2ED3lNhA5gDZQNtr2UDa1dlA6D7aQAmn2kBBDttAlXTbQAfa20CdPtxAWaLcQD8F3UBUZ91AmsjdQBQp3kDHiN5AtOfeQOFF30BOo99AAADgQPlb4EA9t+BAzRHhQK1r4UDgxOFAZx3iQEZ14kB/zOJAFCPjQAh540BezuNAFiPkQDR35EC6yuRAqh3lQAdw5UDRweVACxPmQLdj5kDYs+ZAbgPnQHxS50ADoedABu/nQIU86ECEiehAA9boQAQi6UCIbelAkrjpQCMD6kA8TepA35bqQA3g6kDIKOtAEXHrQOm460BTAOxATkfsQN2N7EAB1OxAuxntQAxf7UD2o+1AeejtQJgs7kBScO5AqrPuQKD27kA1Oe9Aa3vvQEO970C9/u9A2z/wQJ2A8EAFwfBAFAHxQMpA8UApgPFAMb/xQOT98UBCPPJATHryQAO48kBo9fJAfDLzQEBv80C0q/NA2efzQLAj9EA7X/RAeJr0QGrV9EASEPVAb0r1QIKE9UBNvvVA0Pf1QAwx9kABavZAsKL2QBnb9kA/E/dAIEv3QL6C90AZuvdAMvH3QAoo+EChXvhA95T4QA7L+EDmAPlAfzb5QNtr+UD5oPlA2tX5QH8K+kDoPvpAFnP6QAmn+kDC2vpAQQ77QIdB+0CVdPtAaqf7QAfa+0BtDPxAnT78QJZw/EBZovxA59P8QD8F/UBkNv1AVGf9QBCY/UCayP1A8Pj9QBQp/kAGWf5Ax4j+QFa4/kC05/5A4xb/QOFF/0CvdP9ATqP/QL7R/0BtaWQgPiBsZW4AAADAxxwACQAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAQaCQ8wALtQEBAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAEGUkvMAC60BAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAQdST8wALjUIzHhAAagAAACYAAABEAAAAMx4QAGoAAAAmAAAAVAAAADMeEABqAAAAyAAAABkAAAAzHhAAagAAAMgAAAAtAAAAMx4QAGoAAADRAAAAHQAAADMeEABqAAAAtwAAAA0AAAAzHhAAagAAALgAAAANAAAAMx4QAGoAAADEAAAAHQAAADMeEABqAAAAogAAAA0AAAAzHhAAagAAAKMAAAANAAAAMx4QAGoAAACvAAAAHQAAADMeEABqAAAAkAAAAA0AAAAzHhAAagAAAJEAAAANAAAAMx4QAGoAAACXAAAAHQAAADMeEABqAAAA5gAAABkAAAAzHhAAagAAAPgAAAAFAAAAMx4QAGoAAAARAQAAGQAAADMeEABqAAAAEQEAAC0AAAAzHhAAagAAABoBAAAdAAAAMx4QAGoAAAAEAQAAGQAAADMeEABqAAAABAEAAC0AAAAzHhAAagAAAA0BAAAdAAAAMx4QAGoAAAApAQAAFwAAADMeEABqAAAAKwEAAA0AAAAzHhAAagAAACwBAAANAAAAMx4QAGoAAABDAQAACQAAADMeEABqAAAARAEAAAkAAAAzHhAAagAAAEsBAAAZAAAAMx4QAGoAAACrAQAAGQAAADMeEABqAAAAqwEAAC0AAAAzHhAAagAAALIBAAAZAAAAMx4QAGoAAACyAQAALQAAADMeEABqAAAAtQEAAB0AAAAzHhAAagAAALoBAAAdAAAAMx4QAGoAAACUAQAADQAAADMeEABqAAAAlQEAAA0AAAAzHhAAagAAAJ8BAAAZAAAAMx4QAGoAAACfAQAALQAAADMeEABqAAAAogEAAB0AAAAzHhAAagAAAKcBAAAdAAAAMx4QAGoAAAB+AQAADQAAADMeEABqAAAAfwEAAA0AAAAzHhAAagAAAIQBAAAZAAAAMx4QAGoAAACEAQAALQAAADMeEABqAAAAhwEAAB0AAAAzHhAAagAAAIwBAAAdAAAAMx4QAGoAAABqAQAADQAAADMeEABqAAAAawEAAA0AAAAzHhAAagAAAHcBAAAdAAAAMx4QAGoAAABaAQAADQAAADMeEABqAAAAWwEAAA0AAAAzHhAAagAAAGEBAAAdAAAAMx4QAGoAAAAHAgAAGQAAADMeEABqAAAABwIAAC0AAAAzHhAAagAAABACAAAdAAAAMx4QAGoAAAD2AQAADQAAADMeEABqAAAA9wEAAA0AAAAzHhAAagAAAAMCAAAdAAAAMx4QAGoAAADhAQAADQAAADMeEABqAAAA4gEAAA0AAAAzHhAAagAAAO4BAAAdAAAAMx4QAGoAAADPAQAADQAAADMeEABqAAAA0AEAAA0AAAAzHhAAagAAANYBAAAdAAAAMx4QAGoAAAAqAgAAKwAAADMeEABqAAAAHgIAACMAAAAzHhAAagAAADgCAAAjAAAAMx4QAGoAAABOAgAAEwAAADMeEABqAAAAUgIAABMAAAAWIRAAZAAAACMAAAAfAAAAFiEQAGQAAAAjAAAACwAAABYhEABkAAAALgAAAB8AAAAWIRAAZAAAAC4AAAALAAAAbWlkID4gbGVuAAAAZM4cAAkAAAAAAAAAAQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwD//x8A//8/AP//fwD///8A////Af///wP///8H////D////x////8/////f//////ffBAAcAAAACAAAAAFAAAA33wQAHAAAAB0AAAAHgAAAN98EABwAAAAfQAAAB8AAAAFdBAAaAAAAHwBAAAbAAAABXQQAGgAAACBAQAAFQAAAAV0EABoAAAAmAEAAAkAAAAFdBAAaAAAAKABAAAXAAAABXQQAGgAAACxAQAAGwAAAAV0EABoAAAA1QEAAAUAAAAFdBAAaAAAAOkBAAAPAAAABXQQAGgAAAAOAgAAHQAAAAV0EABoAAAAIAIAABwAAAAFdBAAaAAAACECAAAXAAAABXQQAGgAAABBAgAAHgAAAAV0EABoAAAAQAIAAAUAAAAFdBAAaAAAAEYCAAAFAAAABXQQAGgAAACAAgAAGQAAAAV0EABoAAAAggIAAAcAAAAFdBAAaAAAAIwCAAAIAAAAAQIDBAAFEQYQBwgJCgsMDQ4PAAAFdBAAaAAAACoDAAAHAAAAAgICAwICAgQCAgIDAgICBAAEAwIABAMBAAQDAgAEAwUFdBAAaAAAAEIDAAAFAAAABXQQAGgAAABHAwAABwAAAAV0EABoAAAAqwMAAEcAAAAFdBAAaAAAAMoDAAALAAAABXQQAGgAAADmAwAANwAAAAV0EABoAAAA/QMAAAsAAAABAAIABQACAAkAAgANAAIAEQADABkAAwAhAAMAKQADADEABABBAAQAUQAEAGEABABxAAUAkQAFALEABQDRAAUA8QAGADEBBgBxAQcA8QEIAPECCQDxBAoA8QgLAPEQDADxIA0A8UAYAAV0EABoAAAAIQQAAA8AAAAFdBAAaAAAAEwEAAAUAAAABXQQAGgAAABSBAAADgAAAAV0EABoAAAAnAQAAAcAAAAFdBAAaAAAAFIFAAAPAAAABXQQAGgAAABYBQAADwAAAAV0EABoAAAAbgUAAA8AAAAFdBAAaAAAAJ4FAAA3AAAAAQAAAAV0EABoAAAAnwUAADcAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlBXQQAGgAAACgBQAACgAAAAV0EABoAAAAwQUAABgAAAAFdBAAaAAAAMoFAAAdAAAABXQQAGgAAADMBQAAFwAAAAV0EABoAAAAzwUAABkAAAAFdBAAaAAAANkFAAAuAAAABXQQAGgAAAD+BQAAGQAAAAV0EABoAAAACwYAAAcAAAAFdBAAaAAAAAEGAAAQAAAABXQQAGgAAAADBgAAEAAAAAV0EABoAAAABQYAABAAAAAFdBAAaAAAAAcGAAAQAAAABXQQAGgAAAAZBgAAEQAAAAV0EABoAAAAHAYAABsAAAAFdBAAaAAAAB4GAAAcAAAABXQQAGgAAAB1BgAAGAAAAAV0EABoAAAArwYAAA8AAAAFdBAAaAAAALEGAAAFAAAABXQQAGgAAADQBgAASQAAAAV0EABoAAAA0gYAABcAAAAFdBAAaAAAANIGAABMAAAABXQQAGgAAADuBgAAJQAAAAV0EABoAAAAMAcAAAcAAAAFdBAAaAAAACwHAAAQAAAABXQQAGgAAABFBwAABQAAAAV0EABoAAAARgcAAAUAAAAFdBAAaAAAAEkHAAAHAAAABXQQAGgAAABJBwAAXAAAAAV0EABoAAAAXQcAABwAAAAFdBAAaAAAAPEHAAAbAAAABXQQAGgAAAD2BwAAGQAAAAAAAgAAAAAAAAADAAAAAAEAAAQAAAAAAgAABQAAAAADAAAGAAAAAAMAAAcAAAAAAwAACAAAAAADAAAJAAAAAAMBAAIAAAAAAAEAAwAAAAABAQAEAAAAAAIBAAUAAAAAAwEABgAAAAADAQAHAAAAAAMBAAgAAAAAAwEACQAAAAADAgACAAAAAAACAAMAAAAAAQIABAAAAAACAgAFAAAAAAMCAAYAAAAAAwIABwAAAAADAgAIAAAAAAMCAAkAAAAAAwMAAgAAAAAAAwADAAAAAAEDAAQAAAAAAgMABQAAAAADAwAGAAAAAAMDAAcAAAAAAwMACAAAAAADAwAJAAAAAAMEAAIAAAAAAAQAAwAAAAABBAAEAAAAAAIEAAUAAAAAAwQABgAAAAADBAAHAAAAAAMEAAgAAAAAAwQACQAAAAADBQACAAAAAAAFAAMAAAAAAQUABAAAAAACBQAFAAAAAAMFAAYAAAAAAwUABwAAAAADBQAIAAAAAAMFAAkAAAAAAwYAAgABAAAABgADAAEAAAEGAAQAAQAAAgYABQABAAADBgAGAAEAAAMGAAcAAQAAAwYACAABAAADBgAJAAEAAAMIAAIAAQAAAAgAAwABAAABCAAEAAEAAAIIAAUAAQAAAwgABgABAAADCAAHAAEAAAMIAAgAAQAAAwgACQABAAADAAAKAAABAAMAAAwAAAEAAwAADgAAAgADAAASAAACAAMAABYAAAMAAwAAHgAAAwADAAAmAAAEAAMAADYAAAQAAwEACgAAAQADAQAMAAABAAMBAA4AAAIAAwEAEgAAAgADAQAWAAADAAMBAB4AAAMAAwEAJgAABAADAQA2AAAEAAMCAAoAAAEAAwIADAAAAQADAgAOAAACAAMCABIAAAIAAwIAFgAAAwADAgAeAAADAAMCACYAAAQAAwIANgAABAADAwAKAAABAAMDAAwAAAEAAwMADgAAAgADAwASAAACAAMDABYAAAMAAwMAHgAAAwADAwAmAAAEAAMDADYAAAQAAwQACgAAAQADBAAMAAABAAMEAA4AAAIAAwQAEgAAAgADBAAWAAADAAMEAB4AAAMAAwQAJgAABAADBAA2AAAEAAMFAAoAAAEAAwUADAAAAQADBQAOAAACAAMFABIAAAIAAwUAFgAAAwADBQAeAAADAAMFACYAAAQAAwUANgAABAADBgAKAAEBAAMGAAwAAQEAAwYADgABAgADBgASAAECAAMGABYAAQMAAwYAHgABAwADBgAmAAEEAAMGADYAAQQAAwgACgABAQADCAAMAAEBAAMIAA4AAQIAAwgAEgABAgADCAAWAAEDAAMIAB4AAQMAAwgAJgABBAADCAA2AAEEAAMAAAIAAAD/AAAAAwAAAP8BAAAEAAAA/wIAAAUAAAD/AwAABgAAAP8DAAAHAAAA/wMAAAgAAAD/AwAACQAAAP8DAQACAAAA/wABAAMAAAD/AQEABAAAAP8CAQAFAAAA/wMBAAYAAAD/AwEABwAAAP8DAQAIAAAA/wMBAAkAAAD/AwIAAgAAAP8AAgADAAAA/wECAAQAAAD/AgIABQAAAP8DAgAGAAAA/wMCAAcAAAD/AwIACAAAAP8DAgAJAAAA/wMDAAIAAAD/AAMAAwAAAP8BAwAEAAAA/wIDAAUAAAD/AwMABgAAAP8DAwAHAAAA/wMDAAgAAAD/AwMACQAAAP8DBAACAAAA/wAEAAMAAAD/AQQABAAAAP8CBAAFAAAA/wMEAAYAAAD/AwQABwAAAP8DBAAIAAAA/wMEAAkAAAD/AwUAAgAAAP8ABQADAAAA/wEFAAQAAAD/AgUABQAAAP8DBQAGAAAA/wMFAAcAAAD/AwUACAAAAP8DBQAJAAAA/wMGAAIAAQD/AAYAAwABAP8BBgAEAAEA/wIGAAUAAQD/AwYABgABAP8DBgAHAAEA/wMGAAgAAQD/AwYACQABAP8DCAACAAEA/wAIAAMAAQD/AQgABAABAP8CCAAFAAEA/wMIAAYAAQD/AwgABwABAP8DCAAIAAEA/wMIAAkAAQD/AwAACgAAAf8DAAAMAAAB/wMAAA4AAAL/AwAAEgAAAv8DAAAWAAAD/wMAAB4AAAP/AwAAJgAABP8DAAA2AAAE/wMBAAoAAAH/AwEADAAAAf8DAQAOAAAC/wMBABIAAAL/AwEAFgAAA/8DAQAeAAAD/wMBACYAAAT/AwEANgAABP8DAgAKAAAB/wMCAAwAAAH/AwIADgAAAv8DAgASAAAC/wMCABYAAAP/AwIAHgAAA/8DAgAmAAAE/wMCADYAAAT/AwMACgAAAf8DAwAMAAAB/wMDAA4AAAL/AwMAEgAAAv8DAwAWAAAD/wMDAB4AAAP/AwMAJgAABP8DAwA2AAAE/wMEAAoAAAH/AwQADAAAAf8DBAAOAAAC/wMEABIAAAL/AwQAFgAAA/8DBAAeAAAD/wMEACYAAAT/AwQANgAABP8DBQAKAAAB/wMFAAwAAAH/AwUADgAAAv8DBQASAAAC/wMFABYAAAP/AwUAHgAAA/8DBQAmAAAE/wMFADYAAAT/AwYACgABAf8DBgAMAAEB/wMGAA4AAQL/AwYAEgABAv8DBgAWAAED/wMGAB4AAQP/AwYAJgABBP8DBgA2AAEE/wMIAAoAAQH/AwgADAABAf8DCAAOAAEC/wMIABIAAQL/AwgAFgABA/8DCAAeAAED/wMIACYAAQT/AwgANgABBP8DCgACAAIA/wAKAAMAAgD/AQoABAACAP8CCgAFAAIA/wMKAAYAAgD/AwoABwACAP8DCgAIAAIA/wMKAAkAAgD/Aw4AAgACAP8ADgADAAIA/wEOAAQAAgD/Ag4ABQACAP8DDgAGAAIA/wMOAAcAAgD/Aw4ACAACAP8DDgAJAAIA/wMSAAIAAwD/ABIAAwADAP8BEgAEAAMA/wISAAUAAwD/AxIABgADAP8DEgAHAAMA/wMSAAgAAwD/AxIACQADAP8DGgACAAMA/wAaAAMAAwD/ARoABAADAP8CGgAFAAMA/wMaAAYAAwD/AxoABwADAP8DGgAIAAMA/wMaAAkAAwD/AyIAAgAEAP8AIgADAAQA/wEiAAQABAD/AiIABQAEAP8DIgAGAAQA/wMiAAcABAD/AyIACAAEAP8DIgAJAAQA/wMyAAIABAD/ADIAAwAEAP8BMgAEAAQA/wIyAAUABAD/AzIABgAEAP8DMgAHAAQA/wMyAAgABAD/AzIACQAEAP8DQgACAAUA/wBCAAMABQD/AUIABAAFAP8CQgAFAAUA/wNCAAYABQD/A0IABwAFAP8DQgAIAAUA/wNCAAkABQD/A2IAAgAFAP8AYgADAAUA/wFiAAQABQD/AmIABQAFAP8DYgAGAAUA/wNiAAcABQD/A2IACAAFAP8DYgAJAAUA/wMKAAoAAgH/AwoADAACAf8DCgAOAAIC/wMKABIAAgL/AwoAFgACA/8DCgAeAAID/wMKACYAAgT/AwoANgACBP8DDgAKAAIB/wMOAAwAAgH/Aw4ADgACAv8DDgASAAIC/wMOABYAAgP/Aw4AHgACA/8DDgAmAAIE/wMOADYAAgT/AxIACgADAf8DEgAMAAMB/wMSAA4AAwL/AxIAEgADAv8DEgAWAAMD/wMSAB4AAwP/AxIAJgADBP8DEgA2AAME/wMaAAoAAwH/AxoADAADAf8DGgAOAAMC/wMaABIAAwL/AxoAFgADA/8DGgAeAAMD/wMaACYAAwT/AxoANgADBP8DIgAKAAQB/wMiAAwABAH/AyIADgAEAv8DIgASAAQC/wMiABYABAP/AyIAHgAEA/8DIgAmAAQE/wMiADYABAT/AzIACgAEAf8DMgAMAAQB/wMyAA4ABAL/AzIAEgAEAv8DMgAWAAQD/wMyAB4ABAP/AzIAJgAEBP8DMgA2AAQE/wNCAAoABQH/A0IADAAFAf8DQgAOAAUC/wNCABIABQL/A0IAFgAFA/8DQgAeAAUD/wNCACYABQT/A0IANgAFBP8DYgAKAAUB/wNiAAwABQH/A2IADgAFAv8DYgASAAUC/wNiABYABQP/A2IAHgAFA/8DYgAmAAUE/wNiADYABQT/AwAARgAABf8DAABmAAAF/wMAAIYAAAb/AwAAxgAAB/8DAABGAQAI/wMAAEYCAAn/AwAARgQACv8DAABGCAAY/wMBAEYAAAX/AwEAZgAABf8DAQCGAAAG/wMBAMYAAAf/AwEARgEACP8DAQBGAgAJ/wMBAEYEAAr/AwEARggAGP8DAgBGAAAF/wMCAGYAAAX/AwIAhgAABv8DAgDGAAAH/wMCAEYBAAj/AwIARgIACf8DAgBGBAAK/wMCAEYIABj/AwMARgAABf8DAwBmAAAF/wMDAIYAAAb/AwMAxgAAB/8DAwBGAQAI/wMDAEYCAAn/AwMARgQACv8DAwBGCAAY/wMEAEYAAAX/AwQAZgAABf8DBACGAAAG/wMEAMYAAAf/AwQARgEACP8DBABGAgAJ/wMEAEYEAAr/AwQARggAGP8DBQBGAAAF/wMFAGYAAAX/AwUAhgAABv8DBQDGAAAH/wMFAEYBAAj/AwUARgIACf8DBQBGBAAK/wMFAEYIABj/AwYARgABBf8DBgBmAAEF/wMGAIYAAQb/AwYAxgABB/8DBgBGAQEI/wMGAEYCAQn/AwYARgQBCv8DBgBGCAEY/wMIAEYAAQX/AwgAZgABBf8DCACGAAEG/wMIAMYAAQf/AwgARgEBCP8DCABGAgEJ/wMIAEYEAQr/AwgARggBGP8DggACAAYA/wCCAAMABgD/AYIABAAGAP8CggAFAAYA/wOCAAYABgD/A4IABwAGAP8DggAIAAYA/wOCAAkABgD/A8IAAgAHAP8AwgADAAcA/wHCAAQABwD/AsIABQAHAP8DwgAGAAcA/wPCAAcABwD/A8IACAAHAP8DwgAJAAcA/wNCAQIACAD/AEIBAwAIAP8BQgEEAAgA/wJCAQUACAD/A0IBBgAIAP8DQgEHAAgA/wNCAQgACAD/A0IBCQAIAP8DQgICAAkA/wBCAgMACQD/AUICBAAJAP8CQgIFAAkA/wNCAgYACQD/A0ICBwAJAP8DQgIIAAkA/wNCAgkACQD/A0IEAgAKAP8AQgQDAAoA/wFCBAQACgD/AkIEBQAKAP8DQgQGAAoA/wNCBAcACgD/A0IECAAKAP8DQgQJAAoA/wNCCAIADAD/AEIIAwAMAP8BQggEAAwA/wJCCAUADAD/A0IIBgAMAP8DQggHAAwA/wNCCAgADAD/A0IICQAMAP8DQhgCAA4A/wBCGAMADgD/AUIYBAAOAP8CQhgFAA4A/wNCGAYADgD/A0IYBwAOAP8DQhgIAA4A/wNCGAkADgD/A0JYAgAYAP8AQlgDABgA/wFCWAQAGAD/AkJYBQAYAP8DQlgGABgA/wNCWAcAGAD/A0JYCAAYAP8DQlgJABgA/wMKAEYAAgX/AwoAZgACBf8DCgCGAAIG/wMKAMYAAgf/AwoARgECCP8DCgBGAgIJ/wMKAEYEAgr/AwoARggCGP8DDgBGAAIF/wMOAGYAAgX/Aw4AhgACBv8DDgDGAAIH/wMOAEYBAgj/Aw4ARgICCf8DDgBGBAIK/wMOAEYIAhj/AxIARgADBf8DEgBmAAMF/wMSAIYAAwb/AxIAxgADB/8DEgBGAQMI/wMSAEYCAwn/AxIARgQDCv8DEgBGCAMY/wMaAEYAAwX/AxoAZgADBf8DGgCGAAMG/wMaAMYAAwf/AxoARgEDCP8DGgBGAgMJ/wMaAEYEAwr/AxoARggDGP8DIgBGAAQF/wMiAGYABAX/AyIAhgAEBv8DIgDGAAQH/wMiAEYBBAj/AyIARgIECf8DIgBGBAQK/wMiAEYIBBj/AzIARgAEBf8DMgBmAAQF/wMyAIYABAb/AzIAxgAEB/8DMgBGAQQI/wMyAEYCBAn/AzIARgQECv8DMgBGCAQY/wNCAEYABQX/A0IAZgAFBf8DQgCGAAUG/wNCAMYABQf/A0IARgEFCP8DQgBGAgUJ/wNCAEYEBQr/A0IARggFGP8DYgBGAAUF/wNiAGYABQX/A2IAhgAFBv8DYgDGAAUH/wNiAEYBBQj/A2IARgIFCf8DYgBGBAUK/wNiAEYIBRj/A4IACgAGAf8DggAMAAYB/wOCAA4ABgL/A4IAEgAGAv8DggAWAAYD/wOCAB4ABgP/A4IAJgAGBP8DggA2AAYE/wPCAAoABwH/A8IADAAHAf8DwgAOAAcC/wPCABIABwL/A8IAFgAHA/8DwgAeAAcD/wPCACYABwT/A8IANgAHBP8DQgEKAAgB/wNCAQwACAH/A0IBDgAIAv8DQgESAAgC/wNCARYACAP/A0IBHgAIA/8DQgEmAAgE/wNCATYACAT/A0ICCgAJAf8DQgIMAAkB/wNCAg4ACQL/A0ICEgAJAv8DQgIWAAkD/wNCAh4ACQP/A0ICJgAJBP8DQgI2AAkE/wNCBAoACgH/A0IEDAAKAf8DQgQOAAoC/wNCBBIACgL/A0IEFgAKA/8DQgQeAAoD/wNCBCYACgT/A0IENgAKBP8DQggKAAwB/wNCCAwADAH/A0IIDgAMAv8DQggSAAwC/wNCCBYADAP/A0IIHgAMA/8DQggmAAwE/wNCCDYADAT/A0IYCgAOAf8DQhgMAA4B/wNCGA4ADgL/A0IYEgAOAv8DQhgWAA4D/wNCGB4ADgP/A0IYJgAOBP8DQhg2AA4E/wNCWAoAGAH/A0JYDAAYAf8DQlgOABgC/wNCWBIAGAL/A0JYFgAYA/8DQlgeABgD/wNCWCYAGAT/A0JYNgAYBP8DggBGAAYF/wOCAGYABgX/A4IAhgAGBv8DggDGAAYH/wOCAEYBBgj/A4IARgIGCf8DggBGBAYK/wOCAEYIBhj/A8IARgAHBf8DwgBmAAcF/wPCAIYABwb/A8IAxgAHB/8DwgBGAQcI/wPCAEYCBwn/A8IARgQHCv8DwgBGCAcY/wNCAUYACAX/A0IBZgAIBf8DQgGGAAgG/wNCAcYACAf/A0IBRgEICP8DQgFGAggJ/wNCAUYECAr/A0IBRggIGP8DQgJGAAkF/wNCAmYACQX/A0IChgAJBv8DQgLGAAkH/wNCAkYBCQj/A0ICRgIJCf8DQgJGBAkK/wNCAkYICRj/A0IERgAKBf8DQgRmAAoF/wNCBIYACgb/A0IExgAKB/8DQgRGAQoI/wNCBEYCCgn/A0IERgQKCv8DQgRGCAoY/wNCCEYADAX/A0IIZgAMBf8DQgiGAAwG/wNCCMYADAf/A0IIRgEMCP8DQghGAgwJ/wNCCEYEDAr/A0IIRggMGP8DQhhGAA4F/wNCGGYADgX/A0IYhgAOBv8DQhjGAA4H/wNCGEYBDgj/A0IYRgIOCf8DQhhGBA4K/wNCGEYIDhj/A0JYRgAYBf8DQlhmABgF/wNCWIYAGAb/A0JYxgAYB/8DQlhGARgI/wNCWEYCGAn/A0JYRgQYCv8DQlhGCBgY/wMFdBAAaAAAAP0HAAAHAAAABXQQAGgAAAAACAAAGAAAAAV0EABoAAAAPAgAACAAAAAFdBAAaAAAAD0IAAADAAAABXQQAGgAAABKCAAAGwAAAAV0EABoAAAASwgAABUAAAAFdBAAaAAAAEwIAAAFAAAABXQQAGgAAABGCAAAGwAAAAV0EABoAAAARwgAABUAAAAFdBAAaAAAAEgIAAAFAAAABXQQAGgAAAAtCQAAGgAAAAV0EABoAAAALgkAABoAAAAFdBAAaAAAAFcJAAAZAAAABXQQAGgAAABmCQAADwAAAAV0EABoAAAABAkAABEAAAAFdBAAaAAAAA0JAAARAEH51fMAC8vXBxAAAAAkAAAAVAAAAIwAAACsAAAA0AAAAPgAAAAkAQAAVAEAAG4BAACKAQAAmQEAAKEBAICpAQCAuwEAAMUBAADPAQBA1AEAwNkBAKDcAQAAAAAACgoLCwoKCgoKCQkIBwcIBwcGBgUFAAAABXQQAGgAAAC+CQAAHAAAAAV0EABoAAAAwAkAABMAAAAFdBAAaAAAAMMJAAAxAAAABXQQAGgAAAAVCgAADwAAAAV0EABoAAAAFAoAAA0AAAAFdBAAaAAAAF8KAAARAAAABXQQAGgAAACQCgAABwAAAAV0EABoAAAAkQoAABsAAAAFdBAAaAAAAHgLAAAmAAAABXQQAGgAAAB/CwAACwAAAAV0EABoAAAAgQsAAA4AAAAFdBAAaAAAAI0LAAAfAAAABXQQAGgAAAC5CwAALgAAAAV0EABoAAAAxQsAAAsAAAAFdBAAaAAAANUKAABDAAAABXQQAGgAAADVCgAAEQAAAAV0EABoAAAAuwoAACAAAAAFdBAAaAAAALwKAAARAAAABXQQAGgAAAC/CgAAHAAAAAV0EABoAAAAvwoAABEAAAA6hhAAcAAAAC4CAAARAAAAWFIQAGsAAADRAgAABwAAAFhSEABrAAAA3QIAAAMAAABYUhAAawAAANkCAAAFAAAAAAAAAAABAQABAAwAAAoBAAAJAQAAFAABAAAPAAoAAAAZAA0AAAEAAwABAAADAQoBAAAfAAAmDAABAAAkAAAXAAArAAAuAAMAAAAzAAA1AA4AAAIAAAA7AAA/AQoAAAAwFwAAAQADAA8AAABIAABGAABPAABWABAAABEACQAAAAQAAABdAAsAAABkAABpAABuAAcAAAFzAAB4AAB7AQAwAAB9ABQAABIAAAYAAABbAAoDAAgAAACEAACJCQAPAAUAAAkAAQoDAAokFwBbAAsBAAorAACBAQAXkgAACQAGAApGAACYAACNFwABAApbAAoXAACgAQCBAACmAQsBAACqAQsAAACPAAskAAowAQBbAACuAQowAACzAAC4AAtGAAC+AQoXAAsrAQCPAAqNAADDAAsXyAAAAQCNAAqBAAuBAADLAAsDAAqPAQqNAQuBAQsDAAuNAAtbAAswAQsXAAuPAQswAQqBAQuPAQqPAFhSEABrAAAA6QIAAB4AAAAAIAAsIAAgb2YgdGhlIAAgb2YgAHMgAC4AIGFuZCAAIGluIAAiACB0byAAIj4ACgAuIABdACBmb3IgACBhIAAgdGhhdCAAJwAgd2l0aCAAIGZyb20gACBieSAAKAAuIFRoZSAAIG9uIAAgYXMgACBpcyAAaW5nIAAKCQA6AGVkIAA9IgAgYXQgAGx5IAAsAD0nAC5jb20vAC4gVGhpcyAAIG5vdCAAZXIgAGFsIABmdWwgAGl2ZSAAbGVzcyAAZXN0IABpemUgAMKgAG91cyAAWFIQAGsAAADpAgAACAAAAFhSEABrAAAA6gIAAAwAAABYUhAAawAAAPoCAAAMAAAAWFIQAGsAAAAEAwAAGgAAAFhSEABrAAAACgMAACUAAABYUhAAawAAABIDAAAIAAAAWFIQAGsAAAAUAwAADAAAAFhSEABrAAAAFQMAAAcAAABYUhAAawAAAAADAAAoAAAAWFIQAGsAAAAAAwAABwAAAFhSEABrAAAA6wIAAAcAAAAYfxAAbQAAAG4AAAAYAAAAGH8QAG0AAABuAAAACwAAAACAQMAgoGDgEJBQ0DCwcPAIiEjIKKho6BiYWNg4uHj4BIRExCSkZOQUlFTUNLR09AyMTMwsrGzsHJxc3Dy8fPwCgkLCIqJi4hKSUtIysnLyCopKyiqqauoamlraOrp6+gaGRsYmpmbmFpZW1ja2dvYOjk7OLq5u7h6eXt4+vn7+AYFBwSGhYeERkVHRMbFx8QmJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5RWVVdU1tXX1DY1NzS2tbe0dnV3dPb19/QODQ8Mjo2PjE5NT0zOzc/MLi0vLK6tr6xubW9s7u3v7B4dHxyenZ+cXl1fXN7d39w+PT88vr2/vH59f3z+/f/8YfxAAbQAAAKAAAAADAAAAGH8QAG0AAACsAAAABQAAABh/EABtAAAAuQAAAA0AAAAYfxAAbQAAAO4AAAAQAAAAGH8QAG0AAAD/AAAAHwAAABh/EABtAAAAAgEAABQAAAAYfxAAbQAAAN0AAAAiAAAAGH8QAG0AAADdAAAAEwAAABh/EABtAAAA3wAAAAcAAAAYfxAAbQAAANEAAAAPAAAAYXNzZXJ0aW9uIGZhaWxlZDogcm9vdF9iaXRzIGFzIGlzaXplIDw9IEJST1RMSV9SRVZFUlNFX0JJVFNfTUFYIGFzIGlzaXplGH8QAG0AAAAdAQAAAwAAAGFzc2VydGlvbiBmYWlsZWQ6IEJST1RMSV9IVUZGTUFOX01BWF9DT0RFX0xFTkdUSCBhcyBpc2l6ZSAtIHJvb3RfYml0cyBhcyBpc2l6ZSA8PQogICAgQlJPVExJX1JFVkVSU0VfQklUU19NQVggYXMgaXNpemUAABh/EABtAAAAHgEAAAMAAAAYfxAAbQAAACEBAAAJAAAAGH8QAG0AAAA6AQAAHwAAABh/EABtAAAAZAEAAAsAAAAYfxAAbQAAAGwBAAAJAAAAGH8QAG0AAABzAQAACQAAABh/EABtAAAAVQEAAAkAAAAYfxAAbQAAAFQBAAAHAAAAGH8QAG0AAAA9AQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IG51bV9zeW1ib2xzIDw9IDQAABh/EABtAAAAjQEAAAMAAAAYfxAAbQAAAI8BAAAFAAAAGH8QAG0AAACQAQAAIwAAABh/EABtAAAAkgEAAAUAAAAYfxAAbQAAAJMBAAAFAAAAGH8QAG0AAACUAQAACAAAABh/EABtAAAAnQEAAAUAAAAYfxAAbQAAAJ4BAAAjAAAAGH8QAG0AAACfAQAABQAAABh/EABtAAAAoQEAAAgAAAAYfxAAbQAAAKYBAAAHAAAAGH8QAG0AAACjAQAABwAAABh/EABtAAAArQEAAB8AAAAYfxAAbQAAAK0BAAAwAAAAGH8QAG0AAACtAQAAQQAAABh/EABtAAAAtgEAAAcAAAAYfxAAbQAAAL4BAAAfAAAAGH8QAG0AAAC+AQAAMAAAABh/EABtAAAAvgEAAEEAAAAYfxAAbQAAAL4BAABSAAAAGH8QAG0AAADJAQAABQAAABh/EABtAAAA0gEAADsAAAAYfxAAbQAAANIBAAAHAAAAGH8QAG0AAADDAQAABwAAAHRpbWVkb3dubGlmZWxlZnRiYWNrY29kZWRhdGFzaG93b25seXNpdGVjaXR5b3Blbmp1c3RsaWtlZnJlZXdvcmt0ZXh0eWVhcm92ZXJib2R5bG92ZWZvcm1ib29rcGxheWxpdmVsaW5laGVscGhvbWVzaWRlbW9yZXdvcmRsb25ndGhlbXZpZXdmaW5kcGFnZWRheXNmdWxsaGVhZHRlcm1lYWNoYXJlYWZyb210cnVlbWFya2FibGV1cG9uaGlnaGRhdGVsYW5kbmV3c2V2ZW5uZXh0Y2FzZWJvdGhwb3N0dXNlZG1hZGVoYW5kaGVyZXdoYXRuYW1lTGlua2Jsb2dzaXplYmFzZWhlbGRtYWtlbWFpbnVzZXInKSAraG9sZGVuZHN3aXRoTmV3c3JlYWR3ZXJlc2lnbnRha2VoYXZlZ2FtZXNlZW5jYWxscGF0aHdlbGxwbHVzbWVudWZpbG1wYXJ0am9pbnRoaXNsaXN0Z29vZG5lZWR3YXlzd2VzdGpvYnNtaW5kYWxzb2xvZ29yaWNodXNlc2xhc3R0ZWFtYXJteWZvb2RraW5nd2lsbGVhc3R3YXJkYmVzdGZpcmVQYWdla25vd2F3YXkucG5nbW92ZXRoYW5sb2FkZ2l2ZXNlbGZub3RlbXVjaGZlZWRtYW55cm9ja2ljb25vbmNlbG9va2hpZGVkaWVkSG9tZXJ1bGVob3N0YWpheGluZm9jbHVibGF3c2xlc3NoYWxmc29tZXN1Y2h6b25lMTAwJW9uZXNjYXJlVGltZXJhY2VibHVlZm91cndlZWtmYWNlaG9wZWdhdmVoYXJkbG9zdHdoZW5wYXJra2VwdHBhc3NzaGlwcm9vbUhUTUxwbGFuVHlwZWRvbmVzYXZla2VlcGZsYWdsaW5rc29sZGZpdmV0b29rcmF0ZXRvd25qdW1wdGh1c2RhcmtjYXJkZmlsZWZlYXJzdGF5a2lsbHRoYXRmYWxsYXV0b2V2ZXIuY29tdGFsa3Nob3B2b3RlZGVlcG1vZGVyZXN0dHVybmJvcm5iYW5kZmVsbHJvc2V1cmwoc2tpbnJvbGVjb21lYWN0c2FnZXNtZWV0Z29sZC5qcGdpdGVtdmFyeWZlbHR0aGVuc2VuZGRyb3BWaWV3Y29weTEuMCI8L2E+c3RvcGVsc2VsaWVzdG91cnBhY2suZ2lmcGFzdGNzcz9ncmF5bWVhbiZndDtyaWRlc2hvdGxhdGVzYWlkcm9hZHZhciBmZWVsam9obnJpY2twb3J0ZmFzdCdVQS1kZWFkPC9iPnBvb3JiaWxsdHlwZVUuUy53b29kbXVzdDJweDtJbmZvcmFua3dpZGV3YW50d2FsbGxlYWRbMF07cGF1bHdhdmVzdXJlJCgnI3dhaXRtYXNzYXJtc2dvZXNnYWlubGFuZ3BhaWQhLS0gbG9ja3VuaXRyb290d2Fsa2Zpcm13aWZleG1sInNvbmd0ZXN0MjBweGtpbmRyb3dzdG9vbGZvbnRtYWlsc2FmZXN0YXJtYXBzY29yZXJhaW5mbG93YmFieXNwYW5zYXlzNHB4OzZweDthcnRzZm9vdHJlYWx3aWtpaGVhdHN0ZXB0cmlwb3JnL2xha2V3ZWFrdG9sZEZvcm1jYXN0ZmFuc2Jhbmt2ZXJ5cnVuc2p1bHl0YXNrMXB4O2dvYWxncmV3c2xvd2VkZ2VpZD0ic2V0czVweDsuanM/NDBweGlmIChzb29uc2VhdG5vbmV0dWJlemVyb3NlbnRyZWVkZmFjdGludG9naWZ0aGFybTE4cHhjYW1laGlsbGJvbGR6b29tdm9pZGVhc3lyaW5nZmlsbHBlYWtpbml0Y29zdDNweDtqYWNrdGFnc2JpdHNyb2xsZWRpdGtuZXduZWFyPCEtLWdyb3dKU09OZHV0eU5hbWVzYWxleW91IGxvdHNwYWluamF6emNvbGRleWVzZmlzaHd3dy5yaXNrdGFic3ByZXYxMHB4cmlzZTI1cHhCbHVlZGluZzMwMCxiYWxsZm9yZGVhcm53aWxkYm94LmZhaXJsYWNrdmVyc3BhaXJqdW5ldGVjaGlmKCFwaWNrZXZpbCQoIiN3YXJtbG9yZGRvZXNwdWxsLDAwMGlkZWFkcmF3aHVnZXNwb3RmdW5kYnVybmhyZWZjZWxsa2V5c3RpY2tob3VybG9zc2Z1ZWwxMnB4c3VpdGRlYWxSU1MiYWdlZGdyZXlHRVQiZWFzZWFpbXNnaXJsYWlkczhweDtuYXZ5Z3JpZHRpcHMjOTk5d2Fyc2xhZHljYXJzKTsgfXBocD9oZWxsdGFsbHdob216aDrlKi8NCiAxMDBoYWxsLgoKQTdweDtwdXNoY2hhdDBweDtjcmV3Ki88L2hhc2g3NXB4ZmxhdHJhcmUgJiYgdGVsbGNhbXBvbnRvbGFpZG1pc3Nza2lwdGVudGZpbmVtYWxlZ2V0c3Bsb3Q0MDAsDQoNCmNvb2xmZWV0LnBocDxicj5lcmljbW9zdGd1aWRiZWxsZGVzY2hhaXJtYXRoYXRvbS9pbWcmIzgybHVja2NlbnQwMDA7dGlueWdvbmVodG1sc2VsbGRydWdGUkVFbm9kZW5pY2s/aWQ9bG9zZW51bGx2YXN0d2luZFJTUyB3ZWFycmVseWJlZW5zYW1lZHVrZW5hc2FjYXBld2lzaGd1bGZUMjM6aGl0c3Nsb3RnYXRla2lja2JsdXJ0aGV5MTVweCcnKTspOyI+bXNpZXdpbnNiaXJkc29ydGJldGFzZWVrVDE4Om9yZHN0cmVlbWFsbDYwcHhmYXJt4oCZc2JveXNbMF0uJyk7IlBPU1RiZWFya2lkcyk7fX1tYXJ5dGVuZChVSylxdWFkemg65i1zaXotLS0tcHJvcCcpOw1saWZ0VDE5OnZpY2VhbmR5ZGVidD5SU1Nwb29sbmVja2Jsb3dUMTY6ZG9vcmV2YWxUMTc6bGV0c2ZhaWxvcmFscG9sbG5vdmFjb2xzZ2VuZSDigJRzb2Z0cm9tZXRpbGxyb3NzPGgzPnBvdXJmYWRlcGluazx0cj5taW5pKXwhKG1pbmV6aDroYmFyc2hlYXIwMCk7bWlsayAtLT5pcm9uZnJlZGRpc2t3ZW50c29pbHB1dHMvanMvaG9seVQyMjpJU0JOVDIwOmFkYW1zZWVzPGgyPmpzb24nLCAnY29udFQyMTogUlNTbG9vcGFzaWFtb29uPC9wPnNvdWxMSU5FZm9ydGNhcnRUMTQ6PGgxPjgwcHghLS08OXB4O1QwNDptaWtlOjQ2Wm5pY2VpbmNoWW9ya3JpY2V6aDrkJykpO3B1cmVtYWdlcGFyYXRvbmVib25kOjM3Wl9vZl8nXSk7MDAwLHpoOud0YW5reWFyZGJvd2xidXNoOjU2WkphdmEzMHB4Cnx9CiVDMyU6MzRaamVmZkVYUEljYXNodmlzYWdvbGZzbm93emg66XF1ZXIuY3Nzc2lja21lYXRtaW4uYmluZGRlbGxoaXJlcGljc3JlbnQ6MzZaSFRUUC0yMDFmb3Rvd29sZkVORCB4Ym94OjU0WkJPRFlkaWNrOwp9CmV4aXQ6MzVadmFyc2JlYXQnfSk7ZGlldDk5OTthbm5lfX08L1tpXS5MYW5na23CsndpcmV0b3lzYWRkc3NlYWxhbGV4OwoJfWVjaG9uaW5lLm9yZzAwNSl0b255amV3c3NhbmRsZWdzcm9vZjAwMCkgMjAwd2luZWdlYXJkb2dzYm9vdGdhcnljdXRzdHlsZXRlbXB0aW9uLnhtbGNvY2tnYW5nJCgnLjUwcHhQaC5EbWlzY2FsYW5sb2FuZGVza21pbGVyeWFudW5peGRpc2MpO30KZHVzdGNsaXApLgoKNzBweC0yMDBEVkRzN10+PHRhcGVkZW1vaSsrKXdhZ2VldXJvcGhpbG9wdHNob2xlRkFRc2FzaW4tMjZUbGFic3BldHNVUkwgYnVsa2Nvb2s7fQ0KSEVBRFswXSlhYmJyanVhbigxOThsZXNodHdpbjwvaT5zb255Z3V5c2Z1Y2twaXBlfC0KITAwMiluZG93WzFdO1tdOwpMb2cgc2FsdA0KCQliYW5ndHJpbWJhdGgpew0KMDBweAp9KTtrbzrsZmVlc2FkPg1zOi8vIFtdO3RvbGxwbHVnKCl7CnsNCiAuanMnMjAwcGR1YWxib2F0LkpQRyk7Cn1xdW90KTsKCicpOwoNCn0NMjAxNDIwMTUyMDE2MjAxNzIwMTgyMDE5MjAyMDIwMjEyMDIyMjAyMzIwMjQyMDI1MjAyNjIwMjcyMDI4MjAyOTIwMzAyMDMxMjAzMjIwMzMyMDM0MjAzNTIwMzYyMDM3MjAxMzIwMTIyMDExMjAxMDIwMDkyMDA4MjAwNzIwMDYyMDA1MjAwNDIwMDMyMDAyMjAwMTIwMDAxOTk5MTk5ODE5OTcxOTk2MTk5NTE5OTQxOTkzMTk5MjE5OTExOTkwMTk4OTE5ODgxOTg3MTk4NjE5ODUxOTg0MTk4MzE5ODIxOTgxMTk4MDE5NzkxOTc4MTk3NzE5NzYxOTc1MTk3NDE5NzMxOTcyMTk3MTE5NzAxOTY5MTk2ODE5NjcxOTY2MTk2NTE5NjQxOTYzMTk2MjE5NjExOTYwMTk1OTE5NTgxOTU3MTk1NjE5NTUxOTU0MTk1MzE5NTIxOTUxMTk1MDEwMDAxMDI0MTM5NDAwMDA5OTk5Y29tb23DoXNlc3RlZXN0YXBlcm90b2RvaGFjZWNhZGFhw7FvYmllbmTDrWFhc8OtdmlkYWNhc29vdHJvZm9yb3NvbG9vdHJhY3VhbGRpam9zaWRvZ3JhbnRpcG90ZW1hZGViZWFsZ29xdcOpZXN0b25hZGF0cmVzcG9jb2Nhc2FiYWpvdG9kYXNpbm9hZ3VhcHVlc3Vub3NhbnRlZGljZWx1aXNlbGxhbWF5b3pvbmFhbW9ycGlzb29icmFjbGljZWxsb2Rpb3Nob3JhY2FzadC30LDQvdCw0L7QvNGA0LDRgNGD0YLQsNC90LXQv9C+0L7RgtC40LfQvdC+0LTQvtGC0L7QttC10L7QvdC40YXQndCw0LXQtdCx0YvQvNGL0JLRi9GB0L7QstGL0LLQvtCd0L7QvtCx0J/QvtC70LjQvdC40KDQpNCd0LXQnNGL0YLRi9Ce0L3QuNC80LTQsNCX0LDQlNCw0J3Rg9Ce0LHRgtC10JjQt9C10LnQvdGD0LzQvNCi0YvRg9C22YHZitij2YbZhdin2YXYudmD2YTYo9mI2LHYr9mK2KfZgdmJ2YfZiNmE2YXZhNmD2KfZiNmE2YfYqNiz2KfZhNil2YbZh9mK2KPZitmC2K/Zh9mE2KvZhdio2YfZhNmI2YTZitio2YTYp9mK2KjZg9i02YrYp9mF2KPZhdmG2KrYqNmK2YTZhtit2KjZh9mF2YXYtNmI2LRmaXJzdHZpZGVvbGlnaHR3b3JsZG1lZGlhd2hpdGVjbG9zZWJsYWNrcmlnaHRzbWFsbGJvb2tzcGxhY2VtdXNpY2ZpZWxkb3JkZXJwb2ludHZhbHVlbGV2ZWx0YWJsZWJvYXJkaG91c2Vncm91cHdvcmtzeWVhcnNzdGF0ZXRvZGF5d2F0ZXJzdGFydHN0eWxlZGVhdGhwb3dlcnBob25lbmlnaHRlcnJvcmlucHV0YWJvdXR0ZXJtc3RpdGxldG9vbHNldmVudGxvY2FsdGltZXNsYXJnZXdvcmRzZ2FtZXNzaG9ydHNwYWNlZm9jdXNjbGVhcm1vZGVsYmxvY2tndWlkZXJhZGlvc2hhcmV3b21lbmFnYWlubW9uZXlpbWFnZW5hbWVzeW91bmdsaW5lc2xhdGVyY29sb3JncmVlbmZyb250JmFtcDt3YXRjaGZvcmNlcHJpY2VydWxlc2JlZ2luYWZ0ZXJ2aXNpdGlzc3VlYXJlYXNiZWxvd2luZGV4dG90YWxob3Vyc2xhYmVscHJpbnRwcmVzc2J1aWx0bGlua3NzcGVlZHN0dWR5dHJhZGVmb3VuZHNlbnNldW5kZXJzaG93bmZvcm1zcmFuZ2VhZGRlZHN0aWxsbW92ZWR0YWtlbmFib3ZlZmxhc2hmaXhlZG9mdGVub3RoZXJ2aWV3c2NoZWNrbGVnYWxyaXZlcml0ZW1zcXVpY2tzaGFwZWh1bWFuZXhpc3Rnb2luZ21vdmlldGhpcmRiYXNpY3BlYWNlc3RhZ2V3aWR0aGxvZ2luaWRlYXN3cm90ZXBhZ2VzdXNlcnNkcml2ZXN0b3JlYnJlYWtzb3V0aHZvaWNlc2l0ZXNtb250aHdoZXJlYnVpbGR3aGljaGVhcnRoZm9ydW10aHJlZXNwb3J0cGFydHlDbGlja2xvd2VybGl2ZXNjbGFzc2xheWVyZW50cnlzdG9yeXVzYWdlc291bmRjb3VydHlvdXIgYmlydGhwb3B1cHR5cGVzYXBwbHlJbWFnZWJlaW5ndXBwZXJub3Rlc2V2ZXJ5c2hvd3NtZWFuc2V4dHJhbWF0Y2h0cmFja2tub3duZWFybHliZWdhbnN1cGVycGFwZXJub3J0aGxlYXJuZ2l2ZW5uYW1lZGVuZGVkVGVybXNwYXJ0c0dyb3VwYnJhbmR1c2luZ3dvbWFuZmFsc2VyZWFkeWF1ZGlvdGFrZXN3aGlsZS5jb20vbGl2ZWRjYXNlc2RhaWx5Y2hpbGRncmVhdGp1ZGdldGhvc2V1bml0c25ldmVyYnJvYWRjb2FzdGNvdmVyYXBwbGVmaWxlc2N5Y2xlc2NlbmVwbGFuc2NsaWNrd3JpdGVxdWVlbnBpZWNlZW1haWxmcmFtZW9sZGVycGhvdG9saW1pdGNhY2hlY2l2aWxzY2FsZWVudGVydGhlbWV0aGVyZXRvdWNoYm91bmRyb3lhbGFza2Vkd2hvbGVzaW5jZXN0b2NrIG5hbWVmYWl0aGhlYXJ0ZW1wdHlvZmZlcnNjb3Blb3duZWRtaWdodGFsYnVtdGhpbmtibG9vZGFycmF5bWFqb3J0cnVzdGNhbm9udW5pb25jb3VudHZhbGlkc3RvbmVTdHlsZUxvZ2luaGFwcHlvY2N1cmxlZnQ6ZnJlc2hxdWl0ZWZpbG1zZ3JhZGVuZWVkc3VyYmFuZmlnaHRiYXNpc2hvdmVyYXV0bztyb3V0ZS5odG1sbWl4ZWRmaW5hbFlvdXIgc2xpZGV0b3BpY2Jyb3duYWxvbmVkcmF3bnNwbGl0cmVhY2hSaWdodGRhdGVzbWFyY2hxdW90ZWdvb2RzTGlua3Nkb3VidGFzeW5jdGh1bWJhbGxvd2NoaWVmeW91dGhub3ZlbDEwcHg7c2VydmV1bnRpbGhhbmRzQ2hlY2tTcGFjZXF1ZXJ5amFtZXNlcXVhbHR3aWNlMCwwMDBTdGFydHBhbmVsc29uZ3Nyb3VuZGVpZ2h0c2hpZnR3b3J0aHBvc3RzbGVhZHN3ZWVrc2F2b2lkdGhlc2VtaWxlc3BsYW5lc21hcnRhbHBoYXBsYW50bWFya3NyYXRlc3BsYXlzY2xhaW1zYWxlc3RleHRzc3RhcnN3cm9uZzwvaDM+dGhpbmcub3JnL211bHRpaGVhcmRQb3dlcnN0YW5kdG9rZW5zb2xpZCh0aGlzYnJpbmdzaGlwc3N0YWZmdHJpZWRjYWxsc2Z1bGx5ZmFjdHNhZ2VudFRoaXMgLy8tLT5hZG1pbmVneXB0RXZlbnQxNXB4O0VtYWlsdHJ1ZSJjcm9zc3NwZW50YmxvZ3Nib3giPm5vdGVkbGVhdmVjaGluYXNpemVzZ3Vlc3Q8L2g0PnJvYm90aGVhdnl0cnVlLHNldmVuZ3JhbmRjcmltZXNpZ25zYXdhcmVkYW5jZXBoYXNlPjwhLS1lbl9VUyYjMzk7MjAwcHhfbmFtZWxhdGluZW5qb3lhamF4LmF0aW9uc21pdGhVLlMuIGhvbGRzcGV0ZXJpbmRpYW5hdiI+Y2hhaW5zY29yZWNvbWVzZG9pbmdwcmlvclNoYXJlMTk5MHNyb21hbmxpc3RzamFwYW5mYWxsc3RyaWFsb3duZXJhZ3JlZTwvaDI+YWJ1c2VhbGVydG9wZXJhIi0vL1djYXJkc2hpbGxzdGVhbXNQaG90b3RydXRoY2xlYW4ucGhwP3NhaW50bWV0YWxsb3Vpc21lYW50cHJvb2ZicmllZnJvdyI+Z2VucmV0cnVja2xvb2tzVmFsdWVGcmFtZS5uZXQvLS0+Cjx0cnkgewp2YXIgbWFrZXNjb3N0c3BsYWluYWR1bHRxdWVzdHRyYWlubGFib3JoZWxwc2NhdXNlbWFnaWNtb3RvcnRoZWlyMjUwcHhsZWFzdHN0ZXBzQ291bnRjb3VsZGdsYXNzc2lkZXNmdW5kc2hvdGVsYXdhcmRtb3V0aG1vdmVzcGFyaXNnaXZlc2R1dGNodGV4YXNmcnVpdG51bGwsfHxbXTt0b3AiPgo8IS0tUE9TVCJvY2Vhbjxici8+Zmxvb3JzcGVha2RlcHRoIHNpemViYW5rc2NhdGNoY2hhcnQyMHB4O2FsaWduZGVhbHN3b3VsZDUwcHg7dXJsPSJwYXJrc21vdXNlTW9zdCAuLi48L2Ftb25nYnJhaW5ib2R5IG5vbmU7YmFzZWRjYXJyeWRyYWZ0cmVmZXJwYWdlX2hvbWUubWV0ZXJkZWxheWRyZWFtcHJvdmVqb2ludDwvdHI+ZHJ1Z3M8IS0tIGFwcmlsaWRlYWxhbGxlbmV4YWN0Zm9ydGhjb2Rlc2xvZ2ljVmlldyBzZWVtc2JsYW5rcG9ydHMgKDIwMHNhdmVkX2xpbmtnb2Fsc2dyYW50Z3JlZWtob21lc3JpbmdzcmF0ZWQzMHB4O3dob3NlcGFyc2UoKTsiIEJsb2NrbGludXhqb25lc3BpeGVsJyk7Ij4pO2lmKC1sZWZ0ZGF2aWRob3JzZUZvY3VzcmFpc2Vib3hlc1RyYWNrZW1lbnQ8L2VtPmJhciI+LnNyYz10b3dlcmFsdD0iY2FibGVoZW5yeTI0cHg7c2V0dXBpdGFseXNoYXJwbWlub3J0YXN0ZXdhbnRzdGhpcy5yZXNldHdoZWVsZ2lybHMvY3NzLzEwMCU7Y2x1YnNzdHVmZmJpYmxldm90ZXMgMTAwMGtvcmVhfSk7DQpiYW5kc3F1ZXVlPSB7fTs4MHB4O2NraW5new0KCQlhaGVhZGNsb2NraXJpc2hsaWtlIHJhdGlvc3RhdHNGb3JtInlhaG9vKVswXTtBYm91dGZpbmRzPC9oMT5kZWJ1Z3Rhc2tzVVJMID1jZWxsc30pKCk7MTJweDtwcmltZXRlbGxzdHVybnMweDYwMC5qcGcic3BhaW5iZWFjaHRheGVzbWljcm9hbmdlbC0tPjwvZ2lmdHNzdGV2ZS1saW5rYm9keS59KTsKCW1vdW50ICgxOTlGQVE8L3JvZ2VyZnJhbmtDbGFzczI4cHg7ZmVlZHM8aDE+PHNjb3R0dGVzdHMyMnB4O2RyaW5rKSB8fCBsZXdpc3NoYWxsIzAzOTsgZm9yIGxvdmVkd2FzdGUwMHB4O2phOuOCc2ltb248Zm9udHJlcGx5bWVldHN1bnRlcmNoZWFwdGlnaHRCcmFuZCkgIT0gZHJlc3NjbGlwc3Jvb21zb25rZXltb2JpbG1haW4uTmFtZSBwbGF0ZWZ1bm55dHJlZXNjb20vIjEuanBnd21vZGVwYXJhbVNUQVJUbGVmdCBpZGRlbiwgMjAxKTsKfQpmb3JtLnZpcnVzY2hhaXJ0cmFuc3dvcnN0UGFnZXNpdGlvbnBhdGNoPCEtLQpvLWNhY2Zpcm1zdG91cnMsMDAwIGFzaWFuaSsrKXthZG9iZScpWzBdaWQ9MTBib3RoO21lbnUgLjIubWkucG5nImtldmluY29hY2hDaGlsZGJydWNlMi5qcGdVUkwpKy5qcGd8c3VpdGVzbGljZWhhcnJ5MTIwIiBzd2VldHRyPg0KbmFtZT1kaWVnb3BhZ2Ugc3dpc3MtLT4KCiNmZmY7Ij5Mb2cuY29tInRyZWF0c2hlZXQpICYmIDE0cHg7c2xlZXBudGVudGZpbGVkamE644NpZD0iY05hbWUid29yc2VzaG90cy1ib3gtZGVsdGEKJmx0O2JlYXJzOjQ4WjxkYXRhLXJ1cmFsPC9hPiBzcGVuZGJha2Vyc2hvcHM9ICIiO3BocCI+Y3Rpb24xM3B4O2JyaWFuaGVsbG9zaXplPW89JTJGIGpvaW5tYXliZTxpbWcgaW1nIj4sIGZqc2ltZyIgIilbMF1NVG9wQlR5cGUibmV3bHlEYW5za2N6ZWNodHJhaWxrbm93czwvaDU+ZmFxIj56aC1jbjEwKTsKLTEiKTt0eXBlPWJsdWVzdHJ1bHlkYXZpcy5qcyc7Pg0KPCFzdGVlbCB5b3UgaDI+DQpmb3JtIGplc3VzMTAwJSBtZW51Lg0KCQ0Kd2FsZXNyaXNrc3VtZW50ZGRpbmdiLWxpa3RlYWNoZ2lmIiB2ZWdhc2RhbnNrZWVzdGlzaHFpcHN1b21pc29icmVkZXNkZWVudHJldG9kb3NwdWVkZWHDsW9zZXN0w6F0aWVuZWhhc3Rhb3Ryb3NwYXJ0ZWRvbmRlbnVldm9oYWNlcmZvcm1hbWlzbW9tZWpvcm11bmRvYXF1w61kw61hc3PDs2xvYXl1ZGFmZWNoYXRvZGFzdGFudG9tZW5vc2RhdG9zb3RyYXNzaXRpb211Y2hvYWhvcmFsdWdhcm1heW9yZXN0b3Nob3Jhc3RlbmVyYW50ZXNmb3Rvc2VzdGFzcGHDrXNudWV2YXNhbHVkZm9yb3NtZWRpb3F1aWVubWVzZXNwb2RlcmNoaWxlc2Vyw6F2ZWNlc2RlY2lyam9zw6llc3RhcnZlbnRhZ3J1cG9oZWNob2VsbG9zdGVuZ29hbWlnb2Nvc2Fzbml2ZWxnZW50ZW1pc21hYWlyZXNqdWxpb3RlbWFzaGFjaWFmYXZvcmp1bmlvbGlicmVwdW50b2J1ZW5vYXV0b3JhYnJpbGJ1ZW5hdGV4dG9tYXJ6b3NhYmVybGlzdGFsdWVnb2PDs21vZW5lcm9qdWVnb3BlcsO6aGFiZXJlc3RveW51bmNhbXVqZXJ2YWxvcmZ1ZXJhbGlicm9ndXN0YWlndWFsdm90b3NjYXNvc2d1w61hcHVlZG9zb21vc2F2aXNvdXN0ZWRkZWJlbm5vY2hlYnVzY2FmYWx0YWV1cm9zc2VyaWVkaWNob2N1cnNvY2xhdmVjYXNhc2xlw7NucGxhem9sYXJnb29icmFzdmlzdGFhcG95b2p1bnRvdHJhdGF2aXN0b2NyZWFyY2FtcG9oZW1vc2NpbmNvY2FyZ29waXNvc29yZGVuaGFjZW7DoXJlYWRpc2NvcGVkcm9jZXJjYXB1ZWRhcGFwZWxtZW5vcsO6dGlsY2xhcm9qb3JnZWNhbGxlcG9uZXJ0YXJkZW5hZGllbWFyY2FzaWd1ZWVsbGFzc2lnbG9jb2NoZW1vdG9zbWFkcmVjbGFzZXJlc3RvbmnDsW9xdWVkYXBhc2FyYmFuY29oaWpvc3ZpYWplcGFibG/DqXN0ZXZpZW5lcmVpbm9kZWphcmZvbmRvY2FuYWxub3J0ZWxldHJhY2F1c2F0b21hcm1hbm9zbHVuZXNhdXRvc3ZpbGxhdmVuZG9wZXNhcnRpcG9zdGVuZ2FtYXJjb2xsZXZhcGFkcmV1bmlkb3ZhbW9zem9uYXNhbWJvc2JhbmRhbWFyaWFhYnVzb211Y2hhc3ViaXJyaW9qYXZpdmlyZ3JhZG9jaGljYWFsbMOtam92ZW5kaWNoYWVzdGFudGFsZXNzYWxpcnN1ZWxvcGVzb3NmaW5lc2xsYW1hYnVzY2/DqXN0YWxsZWdhbmVncm9wbGF6YWh1bW9ycGFnYXJqdW50YWRvYmxlaXNsYXNib2xzYWJhw7FvaGFibGFsdWNoYcOBcmVhZGljZW5qdWdhcm5vdGFzdmFsbGVhbGzDoWNhcmdhZG9sb3JhYmFqb2VzdMOpZ3VzdG9tZW50ZW1hcmlvZmlybWFjb3N0b2ZpY2hhcGxhdGFob2dhcmFydGVzbGV5ZXNhcXVlbG11c2VvYmFzZXNwb2Nvc21pdGFkY2llbG9jaGljb21pZWRvZ2FuYXJzYW50b2V0YXBhZGViZXNwbGF5YXJlZGVzc2lldGVjb3J0ZWNvcmVhZHVkYXNkZXNlb3ZpZWpvZGVzZWFhZ3VhcyZxdW90O2RvbWFpbmNvbW1vbnN0YXR1c2V2ZW50c21hc3RlcnN5c3RlbWFjdGlvbmJhbm5lcnJlbW92ZXNjcm9sbHVwZGF0ZWdsb2JhbG1lZGl1bWZpbHRlcm51bWJlcmNoYW5nZXJlc3VsdHB1YmxpY3NjcmVlbmNob29zZW5vcm1hbHRyYXZlbGlzc3Vlc3NvdXJjZXRhcmdldHNwcmluZ21vZHVsZW1vYmlsZXN3aXRjaHBob3Rvc2JvcmRlcnJlZ2lvbml0c2VsZnNvY2lhbGFjdGl2ZWNvbHVtbnJlY29yZGZvbGxvd3RpdGxlPmVpdGhlcmxlbmd0aGZhbWlseWZyaWVuZGxheW91dGF1dGhvcmNyZWF0ZXJldmlld3N1bW1lcnNlcnZlcnBsYXllZHBsYXllcmV4cGFuZHBvbGljeWZvcm1hdGRvdWJsZXBvaW50c3Nlcmllc3BlcnNvbmxpdmluZ2Rlc2lnbm1vbnRoc2ZvcmNlc3VuaXF1ZXdlaWdodHBlb3BsZWVuZXJneW5hdHVyZXNlYXJjaGZpZ3VyZWhhdmluZ2N1c3RvbW9mZnNldGxldHRlcndpbmRvd3N1Ym1pdHJlbmRlcmdyb3Vwc3VwbG9hZGhlYWx0aG1ldGhvZHZpZGVvc3NjaG9vbGZ1dHVyZXNoYWRvd2RlYmF0ZXZhbHVlc09iamVjdG90aGVyc3JpZ2h0c2xlYWd1ZWNocm9tZXNpbXBsZW5vdGljZXNoYXJlZGVuZGluZ3NlYXNvbnJlcG9ydG9ubGluZXNxdWFyZWJ1dHRvbmltYWdlc2VuYWJsZW1vdmluZ2xhdGVzdHdpbnRlckZyYW5jZXBlcmlvZHN0cm9uZ3JlcGVhdExvbmRvbmRldGFpbGZvcm1lZGRlbWFuZHNlY3VyZXBhc3NlZHRvZ2dsZXBsYWNlc2RldmljZXN0YXRpY2NpdGllc3N0cmVhbXllbGxvd2F0dGFja3N0cmVldGZsaWdodGhpZGRlbmluZm8iPm9wZW5lZHVzZWZ1bHZhbGxleWNhdXNlc2xlYWRlcnNlY3JldHNlY29uZGRhbWFnZXNwb3J0c2V4Y2VwdHJhdGluZ3NpZ25lZHRoaW5nc2VmZmVjdGZpZWxkc3N0YXRlc29mZmljZXZpc3VhbGVkaXRvcnZvbHVtZVJlcG9ydG11c2V1bW1vdmllc3BhcmVudGFjY2Vzc21vc3RseW1vdGhlciIgaWQ9Im1hcmtldGdyb3VuZGNoYW5jZXN1cnZleWJlZm9yZXN5bWJvbG1vbWVudHNwZWVjaG1vdGlvbmluc2lkZW1hdHRlckNlbnRlcm9iamVjdGV4aXN0c21pZGRsZUV1cm9wZWdyb3d0aGxlZ2FjeW1hbm5lcmVub3VnaGNhcmVlcmFuc3dlcm9yaWdpbnBvcnRhbGNsaWVudHNlbGVjdHJhbmRvbWNsb3NlZHRvcGljc2NvbWluZ2ZhdGhlcm9wdGlvbnNpbXBseXJhaXNlZGVzY2FwZWNob3NlbmNodXJjaGRlZmluZXJlYXNvbmNvcm5lcm91dHB1dG1lbW9yeWlmcmFtZXBvbGljZW1vZGVsc051bWJlcmR1cmluZ29mZmVyc3N0eWxlc2tpbGxlZGxpc3RlZGNhbGxlZHNpbHZlcm1hcmdpbmRlbGV0ZWJldHRlcmJyb3dzZWxpbWl0c0dsb2JhbHNpbmdsZXdpZGdldGNlbnRlcmJ1ZGdldG5vd3JhcGNyZWRpdGNsYWltc2VuZ2luZXNhZmV0eWNob2ljZXNwaXJpdC1zdHlsZXNwcmVhZG1ha2luZ25lZWRlZHJ1c3NpYXBsZWFzZWV4dGVudFNjcmlwdGJyb2tlbmFsbG93c2NoYXJnZWRpdmlkZWZhY3Rvcm1lbWJlci1iYXNlZHRoZW9yeWNvbmZpZ2Fyb3VuZHdvcmtlZGhlbHBlZENodXJjaGltcGFjdHNob3VsZGFsd2F5c2xvZ28iIGJvdHRvbWxpc3QiPil7dmFyIHByZWZpeG9yYW5nZUhlYWRlci5wdXNoKGNvdXBsZWdhcmRlbmJyaWRnZWxhdW5jaFJldmlld3Rha2luZ3Zpc2lvbmxpdHRsZWRhdGluZ0J1dHRvbmJlYXV0eXRoZW1lc2ZvcmdvdFNlYXJjaGFuY2hvcmFsbW9zdGxvYWRlZENoYW5nZXJldHVybnN0cmluZ3JlbG9hZE1vYmlsZWluY29tZXN1cHBseVNvdXJjZW9yZGVyc3ZpZXdlZCZuYnNwO2NvdXJzZUFib3V0IGlzbGFuZDxodG1sIGNvb2tpZW5hbWU9ImFtYXpvbm1vZGVybmFkdmljZWluPC9hPjogVGhlIGRpYWxvZ2hvdXNlc0JFR0lOIE1leGljb3N0YXJ0c2NlbnRyZWhlaWdodGFkZGluZ0lzbGFuZGFzc2V0c0VtcGlyZVNjaG9vbGVmZm9ydGRpcmVjdG5lYXJseW1hbnVhbFNlbGVjdC4KCk9uZWpvaW5lZG1lbnUiPlBoaWxpcGF3YXJkc2hhbmRsZWltcG9ydE9mZmljZXJlZ2FyZHNraWxsc25hdGlvblNwb3J0c2RlZ3JlZXdlZWtseSAoZS5nLmJlaGluZGRvY3RvcmxvZ2dlZHVuaXRlZDwvYj48L2JlZ2luc3BsYW50c2Fzc2lzdGFydGlzdGlzc3VlZDMwMHB4fGNhbmFkYWFnZW5jeXNjaGVtZXJlbWFpbkJyYXppbHNhbXBsZWxvZ28iPmJleW9uZC1zY2FsZWFjY2VwdHNlcnZlZG1hcmluZUZvb3RlcmNhbWVyYTwvaDE+Cl9mb3JtImxlYXZlc3N0cmVzcyIgLz4NCi5naWYiIG9ubG9hZGxvYWRlck94Zm9yZHNpc3RlcnN1cnZpdmxpc3RlbmZlbWFsZURlc2lnbnNpemU9ImFwcGVhbHRleHQiPmxldmVsc3RoYW5rc2hpZ2hlcmZvcmNlZGFuaW1hbGFueW9uZUFmcmljYWFncmVlZHJlY2VudFBlb3BsZTxiciAvPndvbmRlcnByaWNlc3R1cm5lZHx8IHt9O21haW4iPmlubGluZXN1bmRheXdyYXAiPmZhaWxlZGNlbnN1c21pbnV0ZWJlYWNvbnF1b3RlczE1MHB4fGVzdGF0ZXJlbW90ZWVtYWlsImxpbmtlZHJpZ2h0O3NpZ25hbGZvcm1hbDEuaHRtbHNpZ251cHByaW5jZWZsb2F0Oi5wbmciIGZvcnVtLkFjY2Vzc3BhcGVyc3NvdW5kc2V4dGVuZEhlaWdodHNsaWRlclVURi04IiZhbXA7IEJlZm9yZS4gV2l0aHN0dWRpb293bmVyc21hbmFnZXByb2ZpdGpRdWVyeWFubnVhbHBhcmFtc2JvdWdodGZhbW91c2dvb2dsZWxvbmdlcmkrKykge2lzcmFlbHNheWluZ2RlY2lkZWhvbWUiPmhlYWRlcmVuc3VyZWJyYW5jaHBpZWNlc2Jsb2NrO3N0YXRlZHRvcCI+PHJhY2luZ3Jlc2l6ZS0tJmd0O3BhY2l0eXNleHVhbGJ1cmVhdS5qcGciIDEwLDAwMG9idGFpbnRpdGxlc2Ftb3VudCwgSW5jLmNvbWVkeW1lbnUiIGx5cmljc3RvZGF5LmluZGVlZGNvdW50eV9sb2dvLkZhbWlseWxvb2tlZE1hcmtldGxzZSBpZlBsYXllcnR1cmtleSk7dmFyIGZvcmVzdGdpdmluZ2Vycm9yc0RvbWFpbn1lbHNle2luc2VydEJsb2c8L2Zvb3RlcmxvZ2luLmZhc3RlcmFnZW50czxib2R5IDEwcHggMHByYWdtYWZyaWRheWp1bmlvcmRvbGxhcnBsYWNlZGNvdmVyc3BsdWdpbjUsMDAwIHBhZ2UiPmJvc3Rvbi50ZXN0KGF2YXRhcnRlc3RlZF9jb3VudGZvcnVtc3NjaGVtYWluZGV4LGZpbGxlZHNoYXJlc3JlYWRlcmFsZXJ0KGFwcGVhclN1Ym1pdGxpbmUiPmJvZHkiPgoqIFRoZVRob3VnaHNlZWluZ2plcnNleU5ld3M8L3ZlcmlmeWV4cGVydGluanVyeXdpZHRoPUNvb2tpZVNUQVJUIGFjcm9zc19pbWFnZXRocmVhZG5hdGl2ZXBvY2tldGJveCI+ClN5c3RlbSBEYXZpZGNhbmNlcnRhYmxlc3Byb3ZlZEFwcmlsIHJlYWxseWRyaXZlcml0ZW0iPm1vcmUiPmJvYXJkc2NvbG9yc2NhbXB1c2ZpcnN0IHx8IFtdO21lZGlhLmd1aXRhcmZpbmlzaHdpZHRoOnNob3dlZE90aGVyIC5waHAiIGFzc3VtZWxheWVyc3dpbHNvbnN0b3Jlc3JlbGllZnN3ZWRlbkN1c3RvbWVhc2lseSB5b3VyIFN0cmluZwoKV2hpbHRheWxvcmNsZWFyOnJlc29ydGZyZW5jaHRob3VnaCIpICsgIjxib2R5PmJ1eWluZ2JyYW5kc01lbWJlcm5hbWUiPm9wcGluZ3NlY3RvcjVweDsiPnZzcGFjZXBvc3Rlcm1ham9yIGNvZmZlZW1hcnRpbm1hdHVyZWhhcHBlbjwvbmF2PmthbnNhc2xpbmsiPkltYWdlcz1mYWxzZXdoaWxlIGhzcGFjZTAmYW1wOyAKCkluICBwb3dlclBvbHNraS1jb2xvcmpvcmRhbkJvdHRvbVN0YXJ0IC1jb3VudDIuaHRtbG5ld3MiPjAxLmpwZ09ubGluZS1yaWdodG1pbGxlcnNlbmlvcklTQk4gMDAsMDAwIGd1aWRlc3ZhbHVlKWVjdGlvbnJlcGFpci54bWwiICByaWdodHMuaHRtbC1ibG9ja3JlZ0V4cDpob3ZlcndpdGhpbnZpcmdpbnBob25lczwvdHI+DXVzaW5nIAoJdmFyID4nKTsKCTwvdGQ+CjwvdHI+CmJhaGFzYWJyYXNpbGdhbGVnb21hZ3lhcnBvbHNraXNycHNradix2K/ZiOS4reaWh+eugOS9k+e5gemrlOS/oeaBr+S4reWbveaIkeS7rOS4gOS4quWFrOWPuOeuoeeQhuiuuuWdm+WPr+S7peacjeWKoeaXtumXtOS4quS6uuS6p+WTgeiHquW3seS8geS4muafpeeci+W3peS9nOiBlOezu+ayoeaciee9keermeaJgOacieivhOiuuuS4reW/g+aWh+eroOeUqOaIt+mmlumhteS9nOiAheaKgOacr+mXrumimOebuOWFs+S4i+i9veaQnOe0ouS9v+eUqOi9r+S7tuWcqOe6v+S4u+mimOi1hOaWmeinhumikeWbnuWkjeazqOWGjOe9kee7nOaUtuiXj+WGheWuueaOqOiNkOW4guWcuua2iOaBr+epuumXtOWPkeW4g+S7gOS5iOWlveWPi+eUn+a0u+WbvueJh+WPkeWxleWmguaenOaJi+acuuaWsOmXu+acgOaWsOaWueW8j+WMl+S6rOaPkOS+m+WFs+S6juabtOWkmui/meS4quezu+e7n+efpemBk+a4uOaIj+W5v+WRiuWFtuS7luWPkeihqOWuieWFqOesrOS4gOS8muWRmOi/m+ihjOeCueWHu+eJiOadg+eUteWtkOS4lueVjOiuvuiuoeWFjei0ueaVmeiCsuWKoOWFpea0u+WKqOS7luS7rOWVhuWTgeWNmuWuoueOsOWcqOS4iua1t+WmguS9leW3sue7j+eVmeiogOivpue7huekvuWMuueZu+W9leacrOermemcgOimgeS7t+agvOaUr+aMgeWbvemZhemTvuaOpeWbveWutuW7uuiuvuaci+WPi+mYheivu+azleW+i+S9jee9rue7j+a1jumAieaLqei/meagt+W9k+WJjeWIhuexu+aOkuihjOWboOS4uuS6pOaYk+acgOWQjumfs+S5kOS4jeiDvemAmui/h+ihjOS4muenkeaKgOWPr+iDveiuvuWkh+WQiOS9nOWkp+WutuekvuS8mueglOeptuS4k+S4muWFqOmDqOmhueebrui/memHjOi/mOaYr+W8gOWni+aDheWGteeUteiEkeaWh+S7tuWTgeeJjOW4ruWKqeaWh+WMlui1hOa6kOWkp+WtpuWtpuS5oOWcsOWdgOa1j+iniOaKlei1hOW3peeoi+imgeaxguaAjuS5iOaXtuWAmeWKn+iDveS4u+imgeebruWJjei1hOiur+WfjuW4guaWueazleeUteW9seaLm+iBmOWjsOaYjuS7u+S9leWBpeW6t+aVsOaNrue+juWbveaxvei9puS7i+e7jeS9huaYr+S6pOa1geeUn+S6p+aJgOS7peeUteivneaYvuekuuS4gOS6m+WNleS9jeS6uuWRmOWIhuaekOWcsOWbvuaXhea4uOW3peWFt+WtpueUn+ezu+WIl+e9keWPi+W4luWtkOWvhueggemikemBk+aOp+WItuWcsOWMuuWfuuacrOWFqOWbvee9keS4iumHjeimgeesrOS6jOWWnOasoui/m+WFpeWPi+aDhei/meS6m+iAg+ivleWPkeeOsOWfueiureS7peS4iuaUv+W6nOaIkOS4uueOr+Wig+mmmea4r+WQjOaXtuWoseS5kOWPkemAgeS4gOWumuW8gOWPkeS9nOWTgeagh+WHhuasoui/juino+WGs+WcsOaWueS4gOS4i+S7peWPiui0o+S7u+aIluiAheWuouaIt+S7o+ihqOenr+WIhuWls+S6uuaVsOeggemUgOWUruWHuueOsOemu+e6v+W6lOeUqOWIl+ihqOS4jeWQjOe8lui+kee7n+iuoeafpeivouS4jeimgeacieWFs+acuuaehOW+iOWkmuaSreaUvue7hOe7h+aUv+etluebtOaOpeiDveWKm+adpea6kOaZgumWk+eci+WIsOeDremXqOWFs+mUruS4k+WMuumdnuW4uOiLseivreeZvuW6puW4jOacm+e+juWls+avlOi+g+efpeivhuinhOWumuW7uuiurumDqOmXqOaEj+ingeeyvuW9qeaXpeacrOaPkOmrmOWPkeiogOaWuemdouWfuumHkeWkhOeQhuadg+mZkOW9seeJh+mTtuihjOi/mOacieWIhuS6q+eJqeWTgee7j+iQpea3u+WKoOS4k+Wutui/meenjeivnemimOi1t+adpeS4muWKoeWFrOWRiuiusOW9leeugOS7i+i0qOmHj+eUt+S6uuW9seWTjeW8leeUqOaKpeWRiumDqOWIhuW/q+mAn+WSqOivouaXtuWwmuazqOaEj+eUs+ivt+WtpuagoeW6lOivpeWOhuWPsuWPquaYr+i/lOWbnui0reS5sOWQjeensOS4uuS6huaIkOWKn+ivtOaYjuS+m+W6lOWtqeWtkOS4k+mimOeoi+W6j+S4gOiIrOacg+WToeWPquacieWFtuWug+S/neaKpOiAjOS4lOS7iuWkqeeql+WPo+WKqOaAgeeKtuaAgeeJueWIq+iupOS4uuW/hemhu+abtOaWsOWwj+ivtOaIkeWAkeS9nOS4uuWqkuS9k+WMheaLrOmCo+S5iOS4gOagt+WbveWGheaYr+WQpuagueaNrueUteinhuWtpumZouWFt+aciei/h+eoi+eUseS6juS6uuaJjeWHuuadpeS4jei/h+ato+WcqOaYjuaYn+aVheS6i+WFs+ezu+agh+mimOWVhuWKoei+k+WFpeS4gOebtOWfuuehgOaVmeWtpuS6huino+W7uuetkee7k+aenOWFqOeQg+mAmuefpeiuoeWIkuWvueS6juiJuuacr+ebuOWGjOWPkeeUn+ecn+eahOW7uueri+etiee6p+exu+Wei+e7j+mqjOWunueOsOWItuS9nOadpeiHquagh+etvuS7peS4i+WOn+WIm+aXoOazleWFtuS4reWAi+S6uuS4gOWIh+aMh+WNl+WFs+mXrembhuWbouesrOS4ieWFs+azqOWboOatpOeFp+eJh+a3seWcs+WVhuS4muW5v+W3nuaXpeacn+mrmOe6p+acgOi/kee7vOWQiOihqOekuuS4k+i+keihjOS4uuS6pOmAmuivhOS7t+inieW+l+eyvuWNjuWutuW6reWujOaIkOaEn+inieWuieijheW+l+WIsOmCruS7tuWItuW6pumjn+WTgeiZveeEtui9rOi9veaKpeS7t+iusOiAheaWueahiOihjOaUv+S6uuawkeeUqOWTgeS4nOilv+aPkOWHuumFkuW6l+eEtuWQjuS7mOasvueDreeCueS7peWJjeWujOWFqOWPkeW4luiuvue9rumihuWvvOW3peS4muWMu+mZoueci+eci+e7j+WFuOWOn+WboOW5s+WPsOWQhOenjeWinuWKoOadkOaWmeaWsOWinuS5i+WQjuiBjOS4muaViOaenOS7iuW5tOiuuuaWh+aIkeWbveWRiuivieeJiOS4u+S/ruaUueWPguS4juaJk+WNsOW/q+S5kOacuuaisOingueCueWtmOWcqOeyvuelnuiOt+W+l+WIqeeUqOe7p+e7reS9oOS7rOi/meS5iOaooeW8j+ivreiogOiDveWkn+mbheiZjuaTjeS9nOmjjuagvOS4gOi1t+enkeWtpuS9k+iCsuefreS/oeadoeS7tuayu+eWl+i/kOWKqOS6p+S4muS8muiuruWvvOiIquWFiOeUn+iBlOebn+WPr+aYr+WVj+mhjOe7k+aehOS9nOeUqOiwg+afpeizh+aWmeiHquWKqOi0n+i0o+WGnOS4muiuv+mXruWunuaWveaOpeWPl+iuqOiuuumCo+S4quWPjemmiOWKoOW8uuWls+aAp+iMg+WbtOacjeWLmeS8kemXsuS7iuaXpeWuouacjeingOeci+WPguWKoOeahOivneS4gOeCueS/neivgeWbvuS5puacieaViOa1i+ivleenu+WKqOaJjeiDveWGs+WumuiCoeelqOS4jeaWremcgOaxguS4jeW+l+WKnuazleS5i+mXtOmHh+eUqOiQpemUgOaKleivieebruagh+eIseaDheaRhOW9seacieS6m+ikh+ijveaWh+WtpuacuuS8muaVsOWtl+ijheS/rui0reeJqeWGnOadkeWFqOmdoueyvuWTgeWFtuWunuS6i+aDheawtOW5s+aPkOekuuS4iuW4guiwouiwouaZrumAmuaVmeW4iOS4iuS8oOexu+WIq+atjOabsuaLpeacieWIm+aWsOmFjeS7tuWPquimgeaXtuS7o+izh+ioiui+vuWIsOS6uueUn+iuoumYheiAgeW4iOWxleekuuW/g+eQhui0tOWtkOe2suermeS4u+mhjOiHqueEtue6p+WIq+eugOWNleaUuemdqemCo+S6m+adpeivtOaJk+W8gOS7o+eggeWIoOmZpOivgeWIuOiKguebrumHjeeCueasoeaVuOWkmuWwkeinhOWIkui1hOmHkeaJvuWIsOS7peWQjuWkp+WFqOS4u+mhteacgOS9s+WbnuetlOWkqeS4i+S/nemanOeOsOS7o+ajgOafpeaKleelqOWwj+aXtuaykuacieato+W4uOeUmuiHs+S7o+eQhuebruW9leWFrOW8gOWkjeWItumHkeiejeW5uOemj+eJiOacrOW9ouaIkOWHhuWkh+ihjOaDheWbnuWIsOaAneaDs+aAjuagt+WNj+iuruiupOivgeacgOWlveS6p+eUn+aMieeFp+acjeijheW5v+S4nOWKqOa8q+mHh+i0reaWsOaJi+e7hOWbvumdouadv+WPguiAg+aUv+ayu+WuueaYk+WkqeWcsOWKquWKm+S6uuS7rOWNh+e6p+mAn+W6puS6uueJqeiwg+aVtOa1geihjOmAoOaIkOaWh+Wtl+mfqeWbvei0uOaYk+W8gOWxleebuOmXnOihqOeOsOW9seinhuWmguatpOe+juWuueWkp+Wwj+aKpemBk+adoeasvuW/g+aDheiuuOWkmuazleinhOWutuWxheS5puW6l+i/nuaOpeeri+WNs+S4vuaKpeaKgOW3p+Wlpei/kOeZu+WFpeS7peadpeeQhuiuuuS6i+S7tuiHqueUseS4reWNjuWKnuWFrOWmiOWmiOecn+ato+S4jemUmeWFqOaWh+WQiOWQjOS7t+WAvOWIq+S6uuebkeedo+WFt+S9k+S4lue6quWboumYn+WIm+S4muaJv+aLheWinumVv+acieS6uuS/neaMgeWVhuWutue7tOS/ruWPsOa5vuW3puWPs+iCoeS7veetlOahiOWunumZheeUteS/oee7j+eQhueUn+WRveWuo+S8oOS7u+WKoeato+W8j+eJueiJsuS4i+adpeWNj+S8muWPquiDveW9k+eEtumHjeaWsOWFp+WuueaMh+WvvOi/kOihjOaXpeW/l+izo+Wutui2hei/h+Wcn+WcsOa1meaxn+aUr+S7mOaOqOWHuuermemVv+adreW3nuaJp+ihjOWItumAoOS5i+S4gOaOqOW5v+eOsOWcuuaPj+i/sOWPmOWMluS8oOe7n+atjOaJi+S/nemZqeivvueoi+WMu+eWl+e7j+i/h+i/h+WOu+S5i+WJjeaUtuWFpeW5tOW6puadguW/l+e+juS4veacgOmrmOeZu+mZhuacquadpeWKoOW3peWFjei0o+aVmeeoi+eJiOWdl+i6q+S9k+mHjeW6huWHuuWUruaIkOacrOW9ouW8j+Wcn+ixhuWHuuWDueS4nOaWuemCrueuseWNl+S6rOaxguiBjOWPluW+l+iBjOS9jeebuOS/oemhtemdouWIhumSn+e9kemhteehruWumuWbvuS+i+e9keWdgOenr+aegemUmeivr+ebrueahOWunei0neacuuWFs+mjjumZqeaOiOadg+eXheavkuWuoOeJqemZpOS6huipleirlueWvueXheWPiuaXtuaxgui0reermeeCueWEv+erpeavj+WkqeS4reWkruiupOivhuavj+S4quWkqea0peWtl+S9k+WPsOeBo+e7tOaKpOacrOmhteS4quaAp+WumOaWueW4uOingeebuOacuuaImOeVpeW6lOW9k+W+i+W4iOaWueS+v+agoeWbreiCoeW4guaIv+Wxi+agj+ebruWRmOW3peWvvOiHtOeqgeeEtumBk+WFt+acrOe9kee7k+WQiOaho+ahiOWKs+WKqOWPpuWklue+juWFg+W8lei1t+aUueWPmOesrOWbm+S8muiuoeiqquaYjumakOengeWuneWuneinhOiMg+a2iOi0ueWFseWQjOW/mOiusOS9k+ezu+W4puadpeWQjeWtl+eZvOihqOW8gOaUvuWKoOebn+WPl+WIsOS6jOaJi+Wkp+mHj+aIkOS6uuaVsOmHj+WFseS6q+WMuuWfn+Wls+WtqeWOn+WImeaJgOWcqOe7k+adn+mAmuS/oei2hee6p+mFjee9ruW9k+aXtuS8mOengOaAp+aEn+aIv+S6p+mBiuaIsuWHuuWPo+aPkOS6pOWwseS4muS/neWBpeeoi+W6puWPguaVsOS6i+S4muaVtOS4quWxseS4nOaDheaEn+eJueauiuWIhumhnuaQnOWwi+WxnuS6jumXqOaIt+i0ouWKoeWjsOmfs+WPiuWFtui0oue7j+WdmuaMgeW5sumDqOaIkOeri+WIqeebiuiAg+iZkeaIkOmDveWMheijheeUqOaItuavlOi1m+aWh+aYjuaLm+WVhuWujOaVtOecn+aYr+ecvOedm+S8meS8tOWogeacm+mihuWfn+WNq+eUn+S8mOaDoOirluWjh+WFrOWFseiJr+WlveWFheWIhuespuWQiOmZhOS7tueJueeCueS4jeWPr+iLseaWh+i1hOS6p+agueacrOaYjuaYvuWvhueivOWFrOS8l+awkeaXj+abtOWKoOS6q+WPl+WQjOWtpuWQr+WKqOmAguWQiOWOn+adpemXruetlOacrOaWh+e+jumjn+e7v+iJsueos+Wumue7iOS6jueUn+eJqeS+m+axguaQnOeLkOWKm+mHj+S4pemHjeawuOi/nOWGmeecn+aciemZkOernuS6ieWvueixoei0ueeUqOS4jeWlvee7neWvueWNgeWIhuS/g+i/m+eCueivhOW9semfs+S8mOWKv+S4jeWwkeaso+i1j+W5tuS4lOacieeCueaWueWQkeWFqOaWsOS/oeeUqOiuvuaWveW9ouixoei1hOagvOeqgeegtOmaj+edgOmHjeWkp+S6juaYr+avleS4muaZuuiDveWMluW3peWujOe+juWVhuWfjue7n+S4gOWHuueJiOaJk+mAoOeUouWTgeamguWGteeUqOS6juS/neeVmeWboOe0oOS4reWci+WtmOWCqOi0tOWbvuacgOaEm+mVv+acn+WPo+S7t+eQhui0ouWfuuWcsOWuieaOkuatpuaxiemHjOmdouWIm+W7uuWkqeepuummluWFiOWujOWWhOmpseWKqOS4i+mdouS4jeWGjeivmuS/oeaEj+S5iemYs+WFieiLseWbvea8guS6ruWGm+S6i+eOqeWutue+pOS8l+WGnOawkeWNs+WPr+WQjeeoseWutuWFt+WKqOeUu+aDs+WIsOazqOaYjuWwj+WtpuaAp+iDveiAg+eglOehrOS7tuingueci+a4healmuaQnueskemmlumggem7hOmHkemAgueUqOaxn+iLj+ecn+WunuS4u+euoemYtuauteiou+WGiue/u+ivkeadg+WIqeWBmuWlveS8vOS5jumAmuiur+aWveW3peeLgOaFi+S5n+iuuOeOr+S/neWfueWFu+amguW/teWkp+Wei+acuuelqOeQhuino+WMv+WQjWN1YW5kb2Vudmlhcm1hZHJpZGJ1c2NhcmluaWNpb3RpZW1wb3BvcnF1ZWN1ZW50YWVzdGFkb3B1ZWRlbmp1ZWdvc2NvbnRyYWVzdMOhbm5vbWJyZXRpZW5lbnBlcmZpbG1hbmVyYWFtaWdvc2NpdWRhZGNlbnRyb2F1bnF1ZXB1ZWRlc2RlbnRyb3ByaW1lcnByZWNpb3NlZ8O6bmJ1ZW5vc3ZvbHZlcnB1bnRvc3NlbWFuYWhhYsOtYWFnb3N0b251ZXZvc3VuaWRvc2Nhcmxvc2VxdWlwb25pw7Fvc211Y2hvc2FsZ3VuYWNvcnJlb2ltYWdlbnBhcnRpcmFycmliYW1hcsOtYWhvbWJyZWVtcGxlb3ZlcmRhZGNhbWJpb211Y2hhc2Z1ZXJvbnBhc2Fkb2zDrW5lYXBhcmVjZW51ZXZhc2N1cnNvc2VzdGFiYXF1aWVyb2xpYnJvc2N1YW50b2FjY2Vzb21pZ3VlbHZhcmlvc2N1YXRyb3RpZW5lc2dydXBvc3NlcsOhbmV1cm9wYW1lZGlvc2ZyZW50ZWFjZXJjYWRlbcOhc29mZXJ0YWNvY2hlc21vZGVsb2l0YWxpYWxldHJhc2FsZ8O6bmNvbXByYWN1YWxlc2V4aXN0ZWN1ZXJwb3NpZW5kb3ByZW5zYWxsZWdhcnZpYWplc2RpbmVyb211cmNpYXBvZHLDoXB1ZXN0b2RpYXJpb3B1ZWJsb3F1aWVyZW1hbnVlbHByb3Bpb2NyaXNpc2NpZXJ0b3NlZ3Vyb211ZXJ0ZWZ1ZW50ZWNlcnJhcmdyYW5kZWVmZWN0b3BhcnRlc21lZGlkYXByb3BpYW9mcmVjZXRpZXJyYWUtbWFpbHZhcmlhc2Zvcm1hc2Z1dHVyb29iamV0b3NlZ3VpcnJpZXNnb25vcm1hc21pc21vc8O6bmljb2NhbWlub3NpdGlvc3JhesOzbmRlYmlkb3BydWViYXRvbGVkb3RlbsOtYWplc8O6c2VzcGVyb2NvY2luYW9yaWdlbnRpZW5kYWNpZW50b2PDoWRpemhhYmxhcnNlcsOtYWxhdGluYWZ1ZXJ6YWVzdGlsb2d1ZXJyYWVudHJhcsOpeGl0b2zDs3BlemFnZW5kYXbDrWRlb2V2aXRhcnBhZ2luYW1ldHJvc2phdmllcnBhZHJlc2bDoWNpbGNhYmV6YcOhcmVhc3NhbGlkYWVudsOtb2phcMOzbmFidXNvc2JpZW5lc3RleHRvc2xsZXZhcnB1ZWRhbmZ1ZXJ0ZWNvbcO6bmNsYXNlc2h1bWFub3Rlbmlkb2JpbGJhb3VuaWRhZGVzdMOhc2VkaXRhcmNyZWFkb9C00LvRj9GH0YLQvtC60LDQutC40LvQuNGN0YLQvtCy0YHQtdC10LPQvtC/0YDQuNGC0LDQutC10YnQtdGD0LbQtdCa0LDQutCx0LXQt9Cx0YvQu9C+0L3QuNCS0YHQtdC/0L7QtNCt0YLQvtGC0L7QvNGH0LXQvNC90LXRgtC70LXRgtGA0LDQt9C+0L3QsNCz0LTQtdC80L3QtdCU0LvRj9Cf0YDQuNC90LDRgdC90LjRhdGC0LXQvNC60YLQvtCz0L7QtNCy0L7RgtGC0LDQvNCh0KjQkNC80LDRj9Cn0YLQvtCy0LDRgdCy0LDQvNC10LzRg9Ci0LDQutC00LLQsNC90LDQvNGN0YLQuNGN0YLRg9CS0LDQvNGC0LXRhdC/0YDQvtGC0YPRgtC90LDQtNC00L3Rj9CS0L7RgtGC0YDQuNC90LXQudCS0LDRgdC90LjQvNGB0LDQvNGC0L7RgtGA0YPQsdCe0L3QuNC80LjRgNC90LXQtdCe0J7QntC70LjRhtGN0YLQsNCe0L3QsNC90LXQvNC00L7QvNC80L7QudC00LLQtdC+0L3QvtGB0YPQtOCkleClh+CkueCliOCkleClgOCkuOClh+CkleCkvuCkleCli+CklOCksOCkquCksOCkqOClh+Ckj+CkleCkleCkv+CkreClgOCkh+CkuOCkleCksOCkpOCli+CkueCli+CkhuCkquCkueClgOCkr+CkueCkr+CkvuCkpOCkleCkpeCkvmphZ3JhbuCkhuCknOCknOCli+CkheCkrOCkpuCli+Ckl+CkiOCknOCkvuCkl+Ckj+CkueCkruCkh+CkqOCkteCkueCkr+Clh+CkpeClh+CkpeClgOCkmOCksOCknOCkrOCkpuClgOCkleCkiOCknOClgOCkteClh+CkqOCkiOCkqOCkj+CkueCksOCkieCkuOCkruClh+CkleCkruCkteCli+CksuClh+CkuOCkrOCkruCkiOCkpuClh+Ckk+CksOCkhuCkruCkrOCkuOCkreCksOCkrOCkqOCkmuCksuCkruCkqOCkhuCkl+CkuOClgOCksuClgNi52YTZidil2YTZidmH2LDYp9ii2K7Ysdi52K/Yr9in2YTZidmH2LDZh9i12YjYsdi62YrYsdmD2KfZhtmI2YTYp9io2YrZhti52LHYttiw2YTZg9mH2YbYp9mK2YjZhdmC2KfZhNi52YTZitin2YbYp9mE2YPZhtit2KrZidmC2KjZhNmI2K3Yqdin2K7YsdmB2YLYt9i52KjYr9ix2YPZhtil2LDYp9mD2YXYp9in2K3Yr9il2YTYp9mB2YrZh9io2LnYttmD2YrZgdio2K3Yq9mI2YXZhtmI2YfZiNij2YbYp9is2K/Yp9mE2YfYp9iz2YTZhdi52YbYr9mE2YrYs9i52KjYsdi12YTZidmF2YbYsNio2YfYp9ij2YbZh9mF2KvZhNmD2YbYqtin2YTYp9it2YrYq9mF2LXYsdi02LHYrdit2YjZhNmI2YHZitin2LDYp9mE2YPZhNmF2LHYqdin2YbYqtin2YTZgdij2KjZiNiu2KfYtdij2YbYqtin2YbZh9in2YTZiti52LbZiNmI2YLYr9in2KjZhtiu2YrYsdio2YbYqtmE2YPZhdi02KfYodmI2YfZitin2KjZiNmC2LXYtdmI2YXYp9ix2YLZhdij2K3Yr9mG2K3Zhti52K/Zhdix2KPZitin2K3YqdmD2KrYqNiv2YjZhtmK2KzYqNmF2YbZh9iq2K3Yqtis2YfYqdiz2YbYqdmK2KrZhdmD2LHYqdi62LLYqdmG2YHYs9io2YrYqtmE2YTZh9mE2YbYp9iq2YTZg9mC2YTYqNmE2YXYp9i52YbZh9ij2YjZhNi02YrYodmG2YjYsdij2YXYp9mB2YrZg9io2YPZhNiw2KfYqtix2KrYqNio2KPZhtmH2YXYs9in2YbZg9io2YrYudmB2YLYr9it2LPZhtmE2YfZhdi02LnYsdij2YfZhNi02YfYsdmC2LfYsdi32YTYqHByb2ZpbGVzZXJ2aWNlZGVmYXVsdGhpbXNlbGZkZXRhaWxzY29udGVudHN1cHBvcnRzdGFydGVkbWVzc2FnZXN1Y2Nlc3NmYXNoaW9uPHRpdGxlPmNvdW50cnlhY2NvdW50Y3JlYXRlZHN0b3JpZXNyZXN1bHRzcnVubmluZ3Byb2Nlc3N3cml0aW5nb2JqZWN0c3Zpc2libGV3ZWxjb21lYXJ0aWNsZXVua25vd25uZXR3b3JrY29tcGFueWR5bmFtaWNicm93c2VycHJpdmFjeXByb2JsZW1TZXJ2aWNlcmVzcGVjdGRpc3BsYXlyZXF1ZXN0cmVzZXJ2ZXdlYnNpdGVoaXN0b3J5ZnJpZW5kc29wdGlvbnN3b3JraW5ndmVyc2lvbm1pbGxpb25jaGFubmVsd2luZG93LmFkZHJlc3N2aXNpdGVkd2VhdGhlcmNvcnJlY3Rwcm9kdWN0ZWRpcmVjdGZvcndhcmR5b3UgY2FucmVtb3ZlZHN1YmplY3Rjb250cm9sYXJjaGl2ZWN1cnJlbnRyZWFkaW5nbGlicmFyeWxpbWl0ZWRtYW5hZ2VyZnVydGhlcnN1bW1hcnltYWNoaW5lbWludXRlc3ByaXZhdGVjb250ZXh0cHJvZ3JhbXNvY2lldHludW1iZXJzd3JpdHRlbmVuYWJsZWR0cmlnZ2Vyc291cmNlc2xvYWRpbmdlbGVtZW50cGFydG5lcmZpbmFsbHlwZXJmZWN0bWVhbmluZ3N5c3RlbXNrZWVwaW5nY3VsdHVyZSZxdW90Oyxqb3VybmFscHJvamVjdHN1cmZhY2VzJnF1b3Q7ZXhwaXJlc3Jldmlld3NiYWxhbmNlRW5nbGlzaENvbnRlbnR0aHJvdWdoUGxlYXNlIG9waW5pb25jb250YWN0YXZlcmFnZXByaW1hcnl2aWxsYWdlU3BhbmlzaGdhbGxlcnlkZWNsaW5lbWVldGluZ21pc3Npb25wb3B1bGFycXVhbGl0eW1lYXN1cmVnZW5lcmFsc3BlY2llc3Nlc3Npb25zZWN0aW9ud3JpdGVyc2NvdW50ZXJpbml0aWFscmVwb3J0c2ZpZ3VyZXNtZW1iZXJzaG9sZGluZ2Rpc3B1dGVlYXJsaWVyZXhwcmVzc2RpZ2l0YWxwaWN0dXJlQW5vdGhlcm1hcnJpZWR0cmFmZmljbGVhZGluZ2NoYW5nZWRjZW50cmFsdmljdG9yeWltYWdlcy9yZWFzb25zc3R1ZGllc2ZlYXR1cmVsaXN0aW5nbXVzdCBiZXNjaG9vbHNWZXJzaW9udXN1YWxseWVwaXNvZGVwbGF5aW5nZ3Jvd2luZ29idmlvdXNvdmVybGF5cHJlc2VudGFjdGlvbnM8L3VsPg0Kd3JhcHBlcmFscmVhZHljZXJ0YWlucmVhbGl0eXN0b3JhZ2Vhbm90aGVyZGVza3RvcG9mZmVyZWRwYXR0ZXJudW51c3VhbERpZ2l0YWxjYXBpdGFsV2Vic2l0ZWZhaWx1cmVjb25uZWN0cmVkdWNlZEFuZHJvaWRkZWNhZGVzcmVndWxhciAmYW1wOyBhbmltYWxzcmVsZWFzZUF1dG9tYXRnZXR0aW5nbWV0aG9kc25vdGhpbmdQb3B1bGFyY2FwdGlvbmxldHRlcnNjYXB0dXJlc2NpZW5jZWxpY2Vuc2VjaGFuZ2VzRW5nbGFuZD0xJmFtcDtIaXN0b3J5ID0gbmV3IENlbnRyYWx1cGRhdGVkU3BlY2lhbE5ldHdvcmtyZXF1aXJlY29tbWVudHdhcm5pbmdDb2xsZWdldG9vbGJhcnJlbWFpbnNiZWNhdXNlZWxlY3RlZERldXRzY2hmaW5hbmNld29ya2Vyc3F1aWNrbHliZXR3ZWVuZXhhY3RseXNldHRpbmdkaXNlYXNlU29jaWV0eXdlYXBvbnNleGhpYml0Jmx0OyEtLUNvbnRyb2xjbGFzc2VzY292ZXJlZG91dGxpbmVhdHRhY2tzZGV2aWNlcyh3aW5kb3dwdXJwb3NldGl0bGU9Ik1vYmlsZSBraWxsaW5nc2hvd2luZ0l0YWxpYW5kcm9wcGVkaGVhdmlseWVmZmVjdHMtMSddKTsKY29uZmlybUN1cnJlbnRhZHZhbmNlc2hhcmluZ29wZW5pbmdkcmF3aW5nYmlsbGlvbm9yZGVyZWRHZXJtYW55cmVsYXRlZDwvZm9ybT5pbmNsdWRld2hldGhlcmRlZmluZWRTY2llbmNlY2F0YWxvZ0FydGljbGVidXR0b25zbGFyZ2VzdHVuaWZvcm1qb3VybmV5c2lkZWJhckNoaWNhZ29ob2xpZGF5R2VuZXJhbHBhc3NhZ2UsJnF1b3Q7YW5pbWF0ZWZlZWxpbmdhcnJpdmVkcGFzc2luZ25hdHVyYWxyb3VnaGx5LgoKVGhlIGJ1dCBub3RkZW5zaXR5QnJpdGFpbkNoaW5lc2VsYWNrIG9mdHJpYnV0ZUlyZWxhbmQiIGRhdGEtZmFjdG9yc3JlY2VpdmV0aGF0IGlzTGlicmFyeWh1c2JhbmRpbiBmYWN0YWZmYWlyc0NoYXJsZXNyYWRpY2FsYnJvdWdodGZpbmRpbmdsYW5kaW5nOmxhbmc9InJldHVybiBsZWFkZXJzcGxhbm5lZHByZW1pdW1wYWNrYWdlQW1lcmljYUVkaXRpb25dJnF1b3Q7TWVzc2FnZW5lZWQgdG92YWx1ZT0iY29tcGxleGxvb2tpbmdzdGF0aW9uYmVsaWV2ZXNtYWxsZXItbW9iaWxlcmVjb3Jkc3dhbnQgdG9raW5kIG9mRmlyZWZveHlvdSBhcmVzaW1pbGFyc3R1ZGllZG1heGltdW1oZWFkaW5ncmFwaWRseWNsaW1hdGVraW5nZG9tZW1lcmdlZGFtb3VudHNmb3VuZGVkcGlvbmVlcmZvcm11bGFkeW5hc3R5aG93IHRvIFN1cHBvcnRyZXZlbnVlZWNvbm9teVJlc3VsdHNicm90aGVyc29sZGllcmxhcmdlbHljYWxsaW5nLiZxdW90O0FjY291bnRFZHdhcmQgc2VnbWVudFJvYmVydCBlZmZvcnRzUGFjaWZpY2xlYXJuZWR1cCB3aXRoaGVpZ2h0OndlIGhhdmVBbmdlbGVzbmF0aW9uc19zZWFyY2hhcHBsaWVkYWNxdWlyZW1hc3NpdmVncmFudGVkOiBmYWxzZXRyZWF0ZWRiaWdnZXN0YmVuZWZpdGRyaXZpbmdTdHVkaWVzbWluaW11bXBlcmhhcHNtb3JuaW5nc2VsbGluZ2lzIHVzZWRyZXZlcnNldmFyaWFudCByb2xlPSJtaXNzaW5nYWNoaWV2ZXByb21vdGVzdHVkZW50c29tZW9uZWV4dHJlbWVyZXN0b3JlYm90dG9tOmV2b2x2ZWRhbGwgdGhlc2l0ZW1hcGVuZ2xpc2h3YXkgdG8gIEF1Z3VzdHN5bWJvbHNDb21wYW55bWF0dGVyc211c2ljYWxhZ2FpbnN0c2VydmluZ30pKCk7DQpwYXltZW50dHJvdWJsZWNvbmNlcHRjb21wYXJlcGFyZW50c3BsYXllcnNyZWdpb25zbW9uaXRvciAnJ1RoZSB3aW5uaW5nZXhwbG9yZWFkYXB0ZWRHYWxsZXJ5cHJvZHVjZWFiaWxpdHllbmhhbmNlY2FyZWVycykuIFRoZSBjb2xsZWN0U2VhcmNoIGFuY2llbnRleGlzdGVkZm9vdGVyIGhhbmRsZXJwcmludGVkY29uc29sZUVhc3Rlcm5leHBvcnRzd2luZG93c0NoYW5uZWxpbGxlZ2FsbmV1dHJhbHN1Z2dlc3RfaGVhZGVyc2lnbmluZy5odG1sIj5zZXR0bGVkd2VzdGVybmNhdXNpbmctd2Via2l0Y2xhaW1lZEp1c3RpY2VjaGFwdGVydmljdGltc1Rob21hcyBtb3ppbGxhcHJvbWlzZXBhcnRpZXNlZGl0aW9ub3V0c2lkZTpmYWxzZSxodW5kcmVkT2x5bXBpY19idXR0b25hdXRob3JzcmVhY2hlZGNocm9uaWNkZW1hbmRzc2Vjb25kc3Byb3RlY3RhZG9wdGVkcHJlcGFyZW5laXRoZXJncmVhdGx5Z3JlYXRlcm92ZXJhbGxpbXByb3ZlY29tbWFuZHNwZWNpYWxzZWFyY2gud29yc2hpcGZ1bmRpbmd0aG91Z2h0aGlnaGVzdGluc3RlYWR1dGlsaXR5cXVhcnRlckN1bHR1cmV0ZXN0aW5nY2xlYXJseWV4cG9zZWRCcm93c2VybGliZXJhbH0gY2F0Y2hQcm9qZWN0ZXhhbXBsZWhpZGUoKTtGbG9yaWRhYW5zd2Vyc2FsbG93ZWRFbXBlcm9yZGVmZW5zZXNlcmlvdXNmcmVlZG9tU2V2ZXJhbC1idXR0b25GdXJ0aGVyb3V0IG9mICE9IG51bGx0cmFpbmVkRGVubWFya3ZvaWQoMCkvYWxsLmpzcHJldmVudFJlcXVlc3RTdGVwaGVuCgpXaGVuIG9ic2VydmU8L2gyPg0KTW9kZXJuIHByb3ZpZGUiIGFsdD0iYm9yZGVycy4KCkZvciAKCk1hbnkgYXJ0aXN0c3Bvd2VyZWRwZXJmb3JtZmljdGlvbnR5cGUgb2ZtZWRpY2FsdGlja2V0c29wcG9zZWRDb3VuY2lsd2l0bmVzc2p1c3RpY2VHZW9yZ2UgQmVsZ2l1bS4uLjwvYT50d2l0dGVybm90YWJseXdhaXRpbmd3YXJmYXJlIE90aGVyIHJhbmtpbmdwaHJhc2VzbWVudGlvbnN1cnZpdmVzY2hvbGFyPC9wPg0KIENvdW50cnlpZ25vcmVkbG9zcyBvZmp1c3QgYXNHZW9yZ2lhc3RyYW5nZTxoZWFkPjxzdG9wcGVkMSddKTsNCmlzbGFuZHNub3RhYmxlYm9yZGVyOmxpc3Qgb2ZjYXJyaWVkMTAwLDAwMDwvaDM+CiBzZXZlcmFsYmVjb21lc3NlbGVjdCB3ZWRkaW5nMDAuaHRtbG1vbmFyY2hvZmYgdGhldGVhY2hlcmhpZ2hseSBiaW9sb2d5bGlmZSBvZm9yIGV2ZW5yaXNlIG9mJnJhcXVvO3BsdXNvbmVodW50aW5nKHRob3VnaERvdWdsYXNqb2luaW5nY2lyY2xlc0ZvciB0aGVBbmNpZW50VmlldG5hbXZlaGljbGVzdWNoIGFzY3J5c3RhbHZhbHVlID1XaW5kb3dzZW5qb3llZGEgc21hbGxhc3N1bWVkPGEgaWQ9ImZvcmVpZ24gQWxsIHJpaG93IHRoZURpc3BsYXlyZXRpcmVkaG93ZXZlcmhpZGRlbjtiYXR0bGVzc2Vla2luZ2NhYmluZXR3YXMgbm90bG9vayBhdGNvbmR1Y3RnZXQgdGhlSmFudWFyeWhhcHBlbnN0dXJuaW5nYTpob3Zlck9ubGluZSBGcmVuY2ggbGFja2luZ3R5cGljYWxleHRyYWN0ZW5lbWllc2V2ZW4gaWZnZW5lcmF0ZGVjaWRlZGFyZSBub3Qvc2VhcmNoYmVsaWVmcy1pbWFnZTpsb2NhdGVkc3RhdGljLmxvZ2luIj5jb252ZXJ0dmlvbGVudGVudGVyZWRmaXJzdCI+Y2lyY3VpdEZpbmxhbmRjaGVtaXN0c2hlIHdhczEwcHg7Ij5hcyBzdWNoZGl2aWRlZDwvc3Bhbj53aWxsIGJlbGluZSBvZmEgZ3JlYXRteXN0ZXJ5L2luZGV4LmZhbGxpbmdkdWUgdG8gcmFpbHdheWNvbGxlZ2Vtb25zdGVyZGVzY2VudGl0IHdpdGhudWNsZWFySmV3aXNoIHByb3Rlc3RCcml0aXNoZmxvd2Vyc3ByZWRpY3RyZWZvcm1zYnV0dG9uIHdobyB3YXNsZWN0dXJlaW5zdGFudHN1aWNpZGVnZW5lcmljcGVyaW9kc21hcmtldHNTb2NpYWwgZmlzaGluZ2NvbWJpbmVncmFwaGljd2lubmVyczxiciAvPjxieSB0aGUgTmF0dXJhbFByaXZhY3ljb29raWVzb3V0Y29tZXJlc29sdmVTd2VkaXNoYnJpZWZseVBlcnNpYW5zbyBtdWNoQ2VudHVyeWRlcGljdHNjb2x1bW5zaG91c2luZ3NjcmlwdHNuZXh0IHRvYmVhcmluZ21hcHBpbmdyZXZpc2VkalF1ZXJ5KC13aWR0aDp0aXRsZSI+dG9vbHRpcFNlY3Rpb25kZXNpZ25zVHVya2lzaHlvdW5nZXIubWF0Y2gofSkoKTsKCmJ1cm5pbmdvcGVyYXRlZGVncmVlc3NvdXJjZT1SaWNoYXJkY2xvc2VseXBsYXN0aWNlbnRyaWVzPC90cj4NCmNvbG9yOiN1bCBpZD0icG9zc2Vzc3JvbGxpbmdwaHlzaWNzZmFpbGluZ2V4ZWN1dGVjb250ZXN0bGluayB0b0RlZmF1bHQ8YnIgLz4KOiB0cnVlLGNoYXJ0ZXJ0b3VyaXNtY2xhc3NpY3Byb2NlZWRleHBsYWluPC9oMT4NCm9ubGluZS4/eG1sIHZlaGVscGluZ2RpYW1vbmR1c2UgdGhlYWlybGluZWVuZCAtLT4pLmF0dHIocmVhZGVyc2hvc3RpbmcjZmZmZmZmcmVhbGl6ZVZpbmNlbnRzaWduYWxzIHNyYz0iL1Byb2R1Y3RkZXNwaXRlZGl2ZXJzZXRlbGxpbmdQdWJsaWMgaGVsZCBpbkpvc2VwaCB0aGVhdHJlYWZmZWN0czxzdHlsZT5hIGxhcmdlZG9lc24ndGxhdGVyLCBFbGVtZW50ZmF2aWNvbmNyZWF0b3JIdW5nYXJ5QWlycG9ydHNlZSB0aGVzbyB0aGF0TWljaGFlbFN5c3RlbXNQcm9ncmFtcywgYW5kICB3aWR0aD1lJnF1b3Q7dHJhZGluZ2xlZnQiPgpwZXJzb25zR29sZGVuIEFmZmFpcnNncmFtbWFyZm9ybWluZ2Rlc3Ryb3lpZGVhIG9mY2FzZSBvZm9sZGVzdCB0aGlzIGlzLnNyYyA9IGNhcnRvb25yZWdpc3RyQ29tbW9uc011c2xpbXNXaGF0IGlzaW4gbWFueW1hcmtpbmdyZXZlYWxzSW5kZWVkLGVxdWFsbHkvc2hvd19hb3V0ZG9vcmVzY2FwZShBdXN0cmlhZ2VuZXRpY3N5c3RlbSxJbiB0aGUgc2l0dGluZ0hlIGFsc29Jc2xhbmRzQWNhZGVteQoJCTwhLS1EYW5pZWwgYmluZGluZ2Jsb2NrIj5pbXBvc2VkdXRpbGl6ZUFicmFoYW0oZXhjZXB0e3dpZHRoOnB1dHRpbmcpLmh0bWwofHwgW107CkRBVEFbICpraXRjaGVubW91bnRlZGFjdHVhbCBkaWFsZWN0bWFpbmx5IF9ibGFuaydpbnN0YWxsZXhwZXJ0c2lmKHR5cGVJdCBhbHNvJmNvcHk7ICI+VGVybXNib3JuIGluT3B0aW9uc2Vhc3Rlcm50YWxraW5nY29uY2VybmdhaW5lZCBvbmdvaW5nanVzdGlmeWNyaXRpY3NmYWN0b3J5aXRzIG93bmFzc2F1bHRpbnZpdGVkbGFzdGluZ2hpcyBvd25ocmVmPSIvIiByZWw9ImRldmVsb3Bjb25jZXJ0ZGlhZ3JhbWRvbGxhcnNjbHVzdGVycGhwP2lkPWFsY29ob2wpO30pKCk7dXNpbmcgYT48c3Bhbj52ZXNzZWxzcmV2aXZhbEFkZHJlc3NhbWF0ZXVyYW5kcm9pZGFsbGVnZWRpbGxuZXNzd2Fsa2luZ2NlbnRlcnNxdWFsaWZ5bWF0Y2hlc3VuaWZpZWRleHRpbmN0RGVmZW5zZWRpZWQgaW4KCTwhLS0gY3VzdG9tc2xpbmtpbmdMaXR0bGUgQm9vayBvZmV2ZW5pbmdtaW4uanM/YXJlIHRoZWtvbnRha3R0b2RheSdzLmh0bWwiIHRhcmdldD13ZWFyaW5nQWxsIFJpZzsKfSkoKTtyYWlzaW5nIEFsc28sIGNydWNpYWxhYm91dCI+ZGVjbGFyZS0tPgo8c2NmaXJlZm94YXMgbXVjaGFwcGxpZXNpbmRleCwgcywgYnV0IHR5cGUgPSAKDQo8IS0tdG93YXJkc1JlY29yZHNQcml2YXRlRm9yZWlnblByZW1pZXJjaG9pY2VzVmlydHVhbHJldHVybnNDb21tZW50UG93ZXJlZGlubGluZTtwb3ZlcnR5Y2hhbWJlckxpdmluZyB2b2x1bWVzQW50aG9ueWxvZ2luIiBSZWxhdGVkRWNvbm9teXJlYWNoZXNjdXR0aW5nZ3Jhdml0eWxpZmUgaW5DaGFwdGVyLXNoYWRvd05vdGFibGU8L3RkPg0KIHJldHVybnN0YWRpdW13aWRnZXRzdmFyeWluZ3RyYXZlbHNoZWxkIGJ5d2hvIGFyZXdvcmsgaW5mYWN1bHR5YW5ndWxhcndobyBoYWRhaXJwb3J0dG93biBvZgoKU29tZSAnY2xpY2snY2hhcmdlc2tleXdvcmRpdCB3aWxsY2l0eSBvZih0aGlzKTtBbmRyZXcgdW5pcXVlIGNoZWNrZWRvciBtb3JlMzAwcHg7IHJldHVybjtyc2lvbj0icGx1Z2luc3dpdGhpbiBoZXJzZWxmU3RhdGlvbkZlZGVyYWx2ZW50dXJlcHVibGlzaHNlbnQgdG90ZW5zaW9uYWN0cmVzc2NvbWUgdG9maW5nZXJzRHVrZSBvZnBlb3BsZSxleHBsb2l0d2hhdCBpc2hhcm1vbnlhIG1ham9yIjoiaHR0cGluIGhpcyBtZW51Ij4KbW9udGhseW9mZmljZXJjb3VuY2lsZ2FpbmluZ2V2ZW4gaW5TdW1tYXJ5ZGF0ZSBvZmxveWFsdHlmaXRuZXNzYW5kIHdhc2VtcGVyb3JzdXByZW1lU2Vjb25kIGhlYXJpbmdSdXNzaWFubG9uZ2VzdEFsYmVydGFsYXRlcmFsc2V0IG9mIHNtYWxsIj4uYXBwZW5kZG8gd2l0aGZlZGVyYWxiYW5rIG9mYmVuZWF0aERlc3BpdGVDYXBpdGFsZ3JvdW5kcyksIGFuZCBwZXJjZW50aXQgZnJvbWNsb3Npbmdjb250YWluSW5zdGVhZGZpZnRlZW5hcyB3ZWxsLnlhaG9vLnJlc3BvbmRmaWdodGVyb2JzY3VyZXJlZmxlY3RvcmdhbmljPSBNYXRoLmVkaXRpbmdvbmxpbmUgcGFkZGluZ2Egd2hvbGVvbmVycm9yeWVhciBvZmVuZCBvZiBiYXJyaWVyd2hlbiBpdGhlYWRlciBob21lIG9mcmVzdW1lZHJlbmFtZWRzdHJvbmc+aGVhdGluZ3JldGFpbnNjbG91ZGZyd2F5IG9mIE1hcmNoIDFrbm93aW5naW4gcGFydEJldHdlZW5sZXNzb25zY2xvc2VzdHZpcnR1YWxsaW5rcyI+Y3Jvc3NlZEVORCAtLT5mYW1vdXMgYXdhcmRlZExpY2Vuc2VIZWFsdGggZmFpcmx5IHdlYWx0aHltaW5pbWFsQWZyaWNhbmNvbXBldGVsYWJlbCI+c2luZ2luZ2Zhcm1lcnNCcmFzaWwpZGlzY3Vzc3JlcGxhY2VHcmVnb3J5Zm9udCBjb3B1cnN1ZWRhcHBlYXJzbWFrZSB1cHJvdW5kZWRib3RoIG9mYmxvY2tlZHNhdyB0aGVvZmZpY2VzY29sb3Vyc2lmKGRvY3V3aGVuIGhlZW5mb3JjZXB1c2goZnVBdWd1c3QgVVRGLTgiPkZhbnRhc3lpbiBtb3N0aW5qdXJlZFVzdWFsbHlmYXJtaW5nY2xvc3VyZW9iamVjdCBkZWZlbmNldXNlIG9mIE1lZGljYWw8Ym9keT4KZXZpZGVudGJlIHVzZWRrZXlDb2Rlc2l4dGVlbklzbGFtaWMjMDAwMDAwZW50aXJlIHdpZGVseSBhY3RpdmUgKHR5cGVvZm9uZSBjYW5jb2xvciA9c3BlYWtlcmV4dGVuZHNQaHlzaWNzdGVycmFpbjx0Ym9keT5mdW5lcmFsdmlld2luZ21pZGRsZSBjcmlja2V0cHJvcGhldHNoaWZ0ZWRkb2N0b3JzUnVzc2VsbCB0YXJnZXRjb21wYWN0YWxnZWJyYXNvY2lhbC1idWxrIG9mbWFuIGFuZDwvdGQ+CiBoZSBsZWZ0KS52YWwoKWZhbHNlKTtsb2dpY2FsYmFua2luZ2hvbWUgdG9uYW1pbmcgQXJpem9uYWNyZWRpdHMpOwp9KTsKZm91bmRlcmluIHR1cm5Db2xsaW5zYmVmb3JlIEJ1dCB0aGVjaGFyZ2VkVGl0bGUiPkNhcHRhaW5zcGVsbGVkZ29kZGVzc1RhZyAtLT5BZGRpbmc6YnV0IHdhc1JlY2VudCBwYXRpZW50YmFjayBpbj1mYWxzZSZMaW5jb2xud2Uga25vd0NvdW50ZXJKdWRhaXNtc2NyaXB0IGFsdGVyZWQnXSk7CiAgaGFzIHRoZXVuY2xlYXJFdmVudCcsYm90aCBpbm5vdCBhbGwKCjwhLS0gcGxhY2luZ2hhcmQgdG8gY2VudGVyc29ydCBvZmNsaWVudHNzdHJlZXRzQmVybmFyZGFzc2VydHN0ZW5kIHRvZmFudGFzeWRvd24gaW5oYXJib3VyRnJlZWRvbWpld2VscnkvYWJvdXQuLnNlYXJjaGxlZ2VuZHNpcyBtYWRlbW9kZXJuIG9ubHkgb25vbmx5IHRvaW1hZ2UiIGxpbmVhciBwYWludGVyYW5kIG5vdHJhcmVseSBhY3JvbnltZGVsaXZlcnNob3J0ZXIwMCZhbXA7YXMgbWFueXdpZHRoPSIvKiA8IVtDdGl0bGUgPW9mIHRoZSBsb3dlc3QgcGlja2VkIGVzY2FwZWR1c2VzIG9mcGVvcGxlcyBQdWJsaWNNYXR0aGV3dGFjdGljc2RhbWFnZWR3YXkgZm9ybGF3cyBvZmVhc3kgdG8gd2luZG93c3Ryb25nICBzaW1wbGV9Y2F0Y2goc2V2ZW50aGluZm9ib3h3ZW50IHRvcGFpbnRlZGNpdGl6ZW5JIGRvbid0cmV0cmVhdC4gU29tZSB3dy4iKTsKYm9tYmluZ21haWx0bzptYWRlIGluLiBNYW55IGNhcnJpZXN8fHt9O3dpd29yayBvZnN5bm9ueW1kZWZlYXRzZmF2b3JlZG9wdGljYWxwYWdlVHJhdW5sZXNzIHNlbmRpbmdsZWZ0Ij48Y29tU2NvckFsbCB0aGVqUXVlcnkudG91cmlzdENsYXNzaWNmYWxzZSIgV2lsaGVsbXN1YnVyYnNnZW51aW5lYmlzaG9wcy5zcGxpdChnbG9iYWwgZm9sbG93c2JvZHkgb2Zub21pbmFsQ29udGFjdHNlY3VsYXJsZWZ0IHRvY2hpZWZseS1oaWRkZW4tYmFubmVyPC9saT4KCi4gV2hlbiBpbiBib3RoZGlzbWlzc0V4cGxvcmVhbHdheXMgdmlhIHRoZXNwYcOxb2x3ZWxmYXJlcnVsaW5nIGFycmFuZ2VjYXB0YWluaGlzIHNvbnJ1bGUgb2ZoZSB0b29raXRzZWxmLD0wJmFtcDsoY2FsbGVkc2FtcGxlc3RvIG1ha2Vjb20vcGFnTWFydGluIEtlbm5lZHlhY2NlcHRzZnVsbCBvZmhhbmRsZWRCZXNpZGVzLy8tLT48L2FibGUgdG90YXJnZXRzZXNzZW5jZWhpbSB0byBpdHMgYnkgY29tbW9uLm1pbmVyYWx0byB0YWtld2F5cyB0b3Mub3JnL2xhZHZpc2VkcGVuYWx0eXNpbXBsZTppZiB0aGV5TGV0dGVyc2Egc2hvcnRIZXJiZXJ0c3RyaWtlcyBncm91cHMubGVuZ3RoZmxpZ2h0c292ZXJsYXBzbG93bHkgbGVzc2VyIHNvY2lhbCA8L3A+CgkJaXQgaW50b3JhbmtlZCByYXRlIG9mdWw+DQogIGF0dGVtcHRwYWlyIG9mbWFrZSBpdEtvbnRha3RBbnRvbmlvaGF2aW5nIHJhdGluZ3MgYWN0aXZlc3RyZWFtc3RyYXBwZWQiKS5jc3MoaG9zdGlsZWxlYWQgdG9saXR0bGUgZ3JvdXBzLFBpY3R1cmUtLT4NCg0KIHJvd3M9IiBvYmplY3RpbnZlcnNlPGZvb3RlckN1c3RvbVY+PFwvc2Nyc29sdmluZ0NoYW1iZXJzbGF2ZXJ5d291bmRlZHdoZXJlYXMhPSAndW5kZm9yIGFsbHBhcnRseSAtcmlnaHQ6QXJhYmlhbmJhY2tlZCBjZW50dXJ5dW5pdCBvZm1vYmlsZS1FdXJvcGUsaXMgaG9tZXJpc2sgb2ZkZXNpcmVkQ2xpbnRvbmNvc3Qgb2ZhZ2Ugb2YgYmVjb21lIG5vbmUgb2ZwJnF1b3Q7TWlkZGxlIGVhZCcpWzBDcml0aWNzc3R1ZGlvcz4mY29weTtncm91cCI+YXNzZW1ibG1ha2luZyBwcmVzc2Vkd2lkZ2V0LnBzOiIgPyByZWJ1aWx0Ynkgc29tZUZvcm1lciBlZGl0b3JzZGVsYXllZENhbm9uaWNoYWQgdGhlcHVzaGluZ2NsYXNzPSJidXQgYXJlcGFydGlhbEJhYnlsb25ib3R0b20gY2FycmllckNvbW1hbmRpdHMgdXNlQXMgd2l0aGNvdXJzZXNhIHRoaXJkZGVub3Rlc2Fsc28gaW5Ib3VzdG9uMjBweDsiPmFjY3VzZWRkb3VibGUgZ29hbCBvZkZhbW91cyApLmJpbmQocHJpZXN0cyBPbmxpbmVpbiBKdWx5c3QgKyAiZ2NvbnN1bHRkZWNpbWFsaGVscGZ1bHJldml2ZWRpcyB2ZXJ5cicrJ2lwdGxvc2luZyBmZW1hbGVzaXMgYWxzb3N0cmluZ3NkYXlzIG9mYXJyaXZhbGZ1dHVyZSA8b2JqZWN0Zm9yY2luZ1N0cmluZygiIC8+CgkJaGVyZSBpc2VuY29kZWQuICBUaGUgYmFsbG9vbmRvbmUgYnkvY29tbW9uYmdjb2xvcmxhdyBvZiBJbmRpYW5hYXZvaWRlZGJ1dCB0aGUycHggM3B4anF1ZXJ5LmFmdGVyIGFwb2xpY3kubWVuIGFuZGZvb3Rlci09IHRydWU7Zm9yIHVzZXNjcmVlbi5JbmRpYW4gaW1hZ2UgPWZhbWlseSxodHRwOi8vICZuYnNwO2RyaXZlcnNldGVybmFsc2FtZSBhc25vdGljZWR2aWV3ZXJzfSkoKTsKIGlzIG1vcmVzZWFzb25zZm9ybWVyIHRoZSBuZXdpcyBqdXN0Y29uc2VudCBTZWFyY2h3YXMgdGhld2h5IHRoZXNoaXBwZWRicj48YnI+d2lkdGg6IGhlaWdodD1tYWRlIG9mY3Vpc2luZWlzIHRoYXRhIHZlcnkgQWRtaXJhbCBmaXhlZDtub3JtYWwgTWlzc2lvblByZXNzLCBvbnRhcmlvY2hhcnNldHRyeSB0byBpbnZhZGVkPSJ0cnVlInNwYWNpbmdpcyBtb3N0YSBtb3JlIHRvdGFsbHlmYWxsIG9mfSk7DQogIGltbWVuc2V0aW1lIGluc2V0IG91dHNhdGlzZnl0byBmaW5kZG93biB0b2xvdCBvZiBQbGF5ZXJzaW4gSnVuZXF1YW50dW1ub3QgdGhldGltZSB0b2Rpc3RhbnRGaW5uaXNoc3JjID0gKHNpbmdsZSBoZWxwIG9mR2VybWFuIGxhdyBhbmRsYWJlbGVkZm9yZXN0c2Nvb2tpbmdzcGFjZSI+aGVhZGVyLXdlbGwgYXNTdGFubGV5YnJpZGdlcy9nbG9iYWxDcm9hdGlhIEFib3V0IFswXTsKICBpdCwgYW5kZ3JvdXBlZGJlaW5nIGEpe3Rocm93aGUgbWFkZWxpZ2h0ZXJldGhpY2FsRkZGRkZGImJvdHRvbSJsaWtlIGEgZW1wbG95c2xpdmUgaW5hcyBzZWVucHJpbnRlcm1vc3Qgb2Z1Yi1saW5rcmVqZWN0c2FuZCB1c2VpbWFnZSI+c3VjY2VlZGZlZWRpbmdOdWNsZWFyaW5mb3JtYXRvIGhlbHBXb21lbidzTmVpdGhlck1leGljYW5wcm90ZWluPHRhYmxlIGJ5IG1hbnloZWFsdGh5bGF3c3VpdGRldmlzZWQucHVzaCh7c2VsbGVyc3NpbXBseSBUaHJvdWdoLmNvb2tpZSBJbWFnZShvbGRlciI+dXMuanMiPiBTaW5jZSB1bml2ZXJzbGFyZ2VyIG9wZW4gdG8hLS0gZW5kbGllcyBpbiddKTsNCiAgbWFya2V0d2hvIGlzICgiRE9NQ29tYW5hZ2Vkb25lIGZvcnR5cGVvZiBLaW5nZG9tcHJvZml0c3Byb3Bvc2V0byBzaG93Y2VudGVyO21hZGUgaXRkcmVzc2Vkd2VyZSBpbm1peHR1cmVwcmVjaXNlYXJpc2luZ3NyYyA9ICdtYWtlIGEgc2VjdXJlZEJhcHRpc3R2b3RpbmcgCgkJdmFyIE1hcmNoIDJncmV3IHVwQ2xpbWF0ZS5yZW1vdmVza2lsbGVkd2F5IHRoZTwvaGVhZD5mYWNlIG9mYWN0aW5nIHJpZ2h0Ij50byB3b3JrcmVkdWNlc2hhcyBoYWRlcmVjdGVkc2hvdygpO2FjdGlvbj1ib29rIG9mYW4gYXJlYT09ICJodHQ8aGVhZGVyCjxodG1sPmNvbmZvcm1mYWNpbmcgY29va2llLnJlbHkgb25ob3N0ZWQgLmN1c3RvbWhlIHdlbnRidXQgZm9yc3ByZWFkIEZhbWlseSBhIG1lYW5zb3V0IHRoZWZvcnVtcy5mb290YWdlIj5Nb2JpbENsZW1lbnRzIiBpZD0iYXMgaGlnaGludGVuc2UtLT48IS0tZmVtYWxlIGlzIHNlZW5pbXBsaWVkc2V0IHRoZWEgc3RhdGVhbmQgaGlzZmFzdGVzdGJlc2lkZXNidXR0b25fYm91bmRlZCI+PGltZyBJbmZvYm94ZXZlbnRzLGEgeW91bmdhbmQgYXJlTmF0aXZlIGNoZWFwZXJUaW1lb3V0YW5kIGhhc2VuZ2luZXN3b24gdGhlKG1vc3RseXJpZ2h0OiBmaW5kIGEgLWJvdHRvbVByaW5jZSBhcmVhIG9mbW9yZSBvZnNlYXJjaF9uYXR1cmUsbGVnYWxseXBlcmlvZCxsYW5kIG9mb3Igd2l0aGluZHVjZWRwcm92aW5nbWlzc2lsZWxvY2FsbHlBZ2FpbnN0dGhlIHdheWsmcXVvdDtweDsiPg0KcHVzaGVkIGFiYW5kb25udW1lcmFsQ2VydGFpbkluIHRoaXNtb3JlIGlub3Igc29tZW5hbWUgaXNhbmQsIGluY3Jvd25lZElTQk4gMC1jcmVhdGVzT2N0b2Jlcm1heSBub3RjZW50ZXIgbGF0ZSBpbkRlZmVuY2VlbmFjdGVkd2lzaCB0b2Jyb2FkbHljb29saW5nb25sb2FkPWl0LiBUaGVyZWNvdmVyTWVtYmVyc2hlaWdodCBhc3N1bWVzPGh0bWw+CnBlb3BsZS5pbiBvbmUgPXdpbmRvd2Zvb3Rlcl9hIGdvb2QgcmVrbGFtYW90aGVycyx0byB0aGlzX2Nvb2tpZXBhbmVsIj5Mb25kb24sZGVmaW5lc2NydXNoZWRiYXB0aXNtY29hc3RhbHN0YXR1cyB0aXRsZSIgbW92ZSB0b2xvc3QgaW5iZXR0ZXIgaW1wbGllc3JpdmFscnlzZXJ2ZXJzIFN5c3RlbVBlcmhhcHNlcyBhbmQgY29udGVuZGZsb3dpbmdsYXN0ZWQgcmlzZSBpbkdlbmVzaXN2aWV3IG9mcmlzaW5nIHNlZW0gdG9idXQgaW4gYmFja2luZ2hlIHdpbGxnaXZlbiBhZ2l2aW5nIGNpdGllcy5mbG93IG9mIExhdGVyIGFsbCBidXRIaWdod2F5b25seSBieXNpZ24gb2ZoZSBkb2VzZGlmZmVyc2JhdHRlcnkmYW1wO2xhc2luZ2xlc3RocmVhdHNpbnRlZ2VydGFrZSBvbnJlZnVzZWRjYWxsZWQgPVVTJmFtcFNlZSB0aGVuYXRpdmVzYnkgdGhpc3N5c3RlbS5oZWFkIG9mOmhvdmVyLGxlc2JpYW5zdXJuYW1lYW5kIGFsbGNvbW1vbi9oZWFkZXJfX3BhcmFtc0hhcnZhcmQvcGl4ZWwucmVtb3ZhbHNvIGxvbmdyb2xlIG9mam9pbnRseXNreXNjcmFVbmljb2RlYnIgLz4NCkF0bGFudGFudWNsZXVzQ291bnR5LHB1cmVseSBjb3VudCI+ZWFzaWx5IGJ1aWxkIGFvbmNsaWNrYSBnaXZlbnBvaW50ZXJoJnF1b3Q7ZXZlbnRzIGVsc2UgewpkaXRpb25zbm93IHRoZSwgd2l0aCBtYW4gd2hvb3JnL1dlYm9uZSBhbmRjYXZhbHJ5SGUgZGllZHNlYXR0bGUwMCwwMDAge3dpbmRvd2hhdmUgdG9pZih3aW5kYW5kIGl0c3NvbGVseSBtJnF1b3Q7cmVuZXdlZERldHJvaXRhbW9uZ3N0ZWl0aGVyIHRoZW0gaW5TZW5hdG9yVXM8L2E+PEtpbmcgb2ZGcmFuY2lzLXByb2R1Y2hlIHVzZWRhcnQgYW5kaGltIGFuZHVzZWQgYnlzY29yaW5nYXQgaG9tZXRvIGhhdmVyZWxhdGVzaWJpbGl0eWZhY3Rpb25CdWZmYWxvbGluayI+PHdoYXQgaGVmcmVlIHRvQ2l0eSBvZmNvbWUgaW5zZWN0b3JzY291bnRlZG9uZSBkYXluZXJ2b3Vzc3F1YXJlIH07aWYoZ29pbiB3aGF0aW1nIiBhbGlzIG9ubHlzZWFyY2gvdHVlc2RheWxvb3NlbHlTb2xvbW9uc2V4dWFsIC0gPGEgaHJtZWRpdW0iRE8gTk9UIEZyYW5jZSx3aXRoIGEgd2FyIGFuZHNlY29uZCB0YWtlIGEgPg0KDQoNCm1hcmtldC5oaWdod2F5ZG9uZSBpbmN0aXZpdHkibGFzdCI+b2JsaWdlZHJpc2UgdG8idW5kZWZpbWFkZSB0byBFYXJseSBwcmFpc2VkaW4gaXRzIGZvciBoaXNhdGhsZXRlSnVwaXRlcllhaG9vISB0ZXJtZWQgc28gbWFueXJlYWxseSBzLiBUaGUgYSB3b21hbj92YWx1ZT1kaXJlY3QgcmlnaHQiIGJpY3ljbGVhY2luZz0iZGF5IGFuZHN0YXRpbmdSYXRoZXIsaGlnaGVyIE9mZmljZSBhcmUgbm93dGltZXMsIHdoZW4gYSBwYXkgZm9yb24gdGhpcy1saW5rIj47Ym9yZGVyYXJvdW5kIGFubnVhbCB0aGUgTmV3cHV0IHRoZS5jb20iIHRha2luIHRvYSBicmllZihpbiB0aGVncm91cHMuOyB3aWR0aGVuenltZXNzaW1wbGUgaW4gbGF0ZXtyZXR1cm50aGVyYXB5YSBwb2ludGJhbm5pbmdpbmtzIj4KKCk7IiByZWEgcGxhY2VcdTAwM0NhYWJvdXQgYXRyPg0KCQljY291bnQgZ2l2ZXMgYTxTQ1JJUFRSYWlsd2F5dGhlbWVzL3Rvb2xib3hCeUlkKCJ4aHVtYW5zLHdhdGNoZXNpbiBzb21lIGlmICh3aWNvbWluZyBmb3JtYXRzIFVuZGVyIGJ1dCBoYXNoYW5kZWQgbWFkZSBieXRoYW4gaW5mZWFyIG9mZGVub3RlZC9pZnJhbWVsZWZ0IGludm9sdGFnZWluIGVhY2hhJnF1b3Q7YmFzZSBvZkluIG1hbnl1bmRlcmdvcmVnaW1lc2FjdGlvbiA8L3A+DQo8dXN0b21WYTsmZ3Q7PC9pbXBvcnRzb3IgdGhhdG1vc3RseSAmYW1wO3JlIHNpemU9IjwvYT48L2hhIGNsYXNzcGFzc2l2ZUhvc3QgPSBXaGV0aGVyZmVydGlsZVZhcmlvdXM9W107KGZ1Y2FtZXJhcy8+PC90ZD5hY3RzIGFzSW4gc29tZT4NCg0KPCFvcmdhbmlzIDxiciAvPkJlaWppbmdjYXRhbMOgZGV1dHNjaGV1cm9wZXVldXNrYXJhZ2FlaWxnZXN2ZW5za2Flc3Bhw7FhbWVuc2FqZXVzdWFyaW90cmFiYWpvbcOpeGljb3DDoWdpbmFzaWVtcHJlc2lzdGVtYW9jdHVicmVkdXJhbnRlYcOxYWRpcmVtcHJlc2Ftb21lbnRvbnVlc3Ryb3ByaW1lcmF0cmF2w6lzZ3JhY2lhc251ZXN0cmFwcm9jZXNvZXN0YWRvc2NhbGlkYWRwZXJzb25hbsO6bWVyb2FjdWVyZG9tw7pzaWNhbWllbWJyb29mZXJ0YXNhbGd1bm9zcGHDrXNlc2VqZW1wbG9kZXJlY2hvYWRlbcOhc3ByaXZhZG9hZ3JlZ2FyZW5sYWNlc3Bvc2libGVob3RlbGVzc2V2aWxsYXByaW1lcm/Dumx0aW1vZXZlbnRvc2FyY2hpdm9jdWx0dXJhbXVqZXJlc2VudHJhZGFhbnVuY2lvZW1iYXJnb21lcmNhZG9ncmFuZGVzZXN0dWRpb21lam9yZXNmZWJyZXJvZGlzZcOxb3R1cmlzbW9jw7NkaWdvcG9ydGFkYWVzcGFjaW9mYW1pbGlhYW50b25pb3Blcm1pdGVndWFyZGFyYWxndW5hc3ByZWNpb3NhbGd1aWVuc2VudGlkb3Zpc2l0YXN0w610dWxvY29ub2NlcnNlZ3VuZG9jb25zZWpvZnJhbmNpYW1pbnV0b3NzZWd1bmRhdGVuZW1vc2VmZWN0b3Ntw6FsYWdhc2VzacOzbnJldmlzdGFncmFuYWRhY29tcHJhcmluZ3Jlc29nYXJjw61hYWNjacOzbmVjdWFkb3JxdWllbmVzaW5jbHVzb2RlYmVyw6FtYXRlcmlhaG9tYnJlc211ZXN0cmFwb2Ryw61hbWHDsWFuYcO6bHRpbWFlc3RhbW9zb2ZpY2lhbHRhbWJpZW5uaW5nw7puc2FsdWRvc3BvZGVtb3NtZWpvcmFycG9zaXRpb25idXNpbmVzc2hvbWVwYWdlc2VjdXJpdHlsYW5ndWFnZXN0YW5kYXJkY2FtcGFpZ25mZWF0dXJlc2NhdGVnb3J5ZXh0ZXJuYWxjaGlsZHJlbnJlc2VydmVkcmVzZWFyY2hleGNoYW5nZWZhdm9yaXRldGVtcGxhdGVtaWxpdGFyeWluZHVzdHJ5c2VydmljZXNtYXRlcmlhbHByb2R1Y3Rzei1pbmRleDpjb21tZW50c3NvZnR3YXJlY29tcGxldGVjYWxlbmRhcnBsYXRmb3JtYXJ0aWNsZXNyZXF1aXJlZG1vdmVtZW50cXVlc3Rpb25idWlsZGluZ3BvbGl0aWNzcG9zc2libGVyZWxpZ2lvbnBoeXNpY2FsZmVlZGJhY2tyZWdpc3RlcnBpY3R1cmVzZGlzYWJsZWRwcm90b2NvbGF1ZGllbmNlc2V0dGluZ3NhY3Rpdml0eWVsZW1lbnRzbGVhcm5pbmdhbnl0aGluZ2Fic3RyYWN0cHJvZ3Jlc3NvdmVydmlld21hZ2F6aW5lZWNvbm9taWN0cmFpbmluZ3ByZXNzdXJldmFyaW91cyA8c3Ryb25nPnByb3BlcnR5c2hvcHBpbmd0b2dldGhlcmFkdmFuY2VkYmVoYXZpb3Jkb3dubG9hZGZlYXR1cmVkZm9vdGJhbGxzZWxlY3RlZExhbmd1YWdlZGlzdGFuY2VyZW1lbWJlcnRyYWNraW5ncGFzc3dvcmRtb2RpZmllZHN0dWRlbnRzZGlyZWN0bHlmaWdodGluZ25vcnRoZXJuZGF0YWJhc2VmZXN0aXZhbGJyZWFraW5nbG9jYXRpb25pbnRlcm5ldGRyb3Bkb3ducHJhY3RpY2VldmlkZW5jZWZ1bmN0aW9ubWFycmlhZ2VyZXNwb25zZXByb2JsZW1zbmVnYXRpdmVwcm9ncmFtc2FuYWx5c2lzcmVsZWFzZWRiYW5uZXIiPnB1cmNoYXNlcG9saWNpZXNyZWdpb25hbGNyZWF0aXZlYXJndW1lbnRib29rbWFya3JlZmVycmVyY2hlbWljYWxkaXZpc2lvbmNhbGxiYWNrc2VwYXJhdGVwcm9qZWN0c2NvbmZsaWN0aGFyZHdhcmVpbnRlcmVzdGRlbGl2ZXJ5bW91bnRhaW5vYnRhaW5lZD0gZmFsc2U7Zm9yKHZhciBhY2NlcHRlZGNhcGFjaXR5Y29tcHV0ZXJpZGVudGl0eWFpcmNyYWZ0ZW1wbG95ZWRwcm9wb3NlZGRvbWVzdGljaW5jbHVkZXNwcm92aWRlZGhvc3BpdGFsdmVydGljYWxjb2xsYXBzZWFwcHJvYWNocGFydG5lcnNsb2dvIj48YWRhdWdodGVyYXV0aG9yIiBjdWx0dXJhbGZhbWlsaWVzL2ltYWdlcy9hc3NlbWJseXBvd2VyZnVsdGVhY2hpbmdmaW5pc2hlZGRpc3RyaWN0Y3JpdGljYWxjZ2ktYmluL3B1cnBvc2VzcmVxdWlyZXNlbGVjdGlvbmJlY29taW5ncHJvdmlkZXNhY2FkZW1pY2V4ZXJjaXNlYWN0dWFsbHltZWRpY2luZWNvbnN0YW50YWNjaWRlbnRNYWdhemluZWRvY3VtZW50c3RhcnRpbmdib3R0b20iPm9ic2VydmVkOiAmcXVvdDtleHRlbmRlZHByZXZpb3VzU29mdHdhcmVjdXN0b21lcmRlY2lzaW9uc3RyZW5ndGhkZXRhaWxlZHNsaWdodGx5cGxhbm5pbmd0ZXh0YXJlYWN1cnJlbmN5ZXZlcnlvbmVzdHJhaWdodHRyYW5zZmVycG9zaXRpdmVwcm9kdWNlZGhlcml0YWdlc2hpcHBpbmdhYnNvbHV0ZXJlY2VpdmVkcmVsZXZhbnRidXR0b24iIHZpb2xlbmNlYW55d2hlcmViZW5lZml0c2xhdW5jaGVkcmVjZW50bHlhbGxpYW5jZWZvbGxvd2VkbXVsdGlwbGVidWxsZXRpbmluY2x1ZGVkb2NjdXJyZWRpbnRlcm5hbCQodGhpcykucmVwdWJsaWM+PHRyPjx0ZGNvbmdyZXNzcmVjb3JkZWR1bHRpbWF0ZXNvbHV0aW9uPHVsIGlkPSJkaXNjb3ZlckhvbWU8L2E+d2Vic2l0ZXNuZXR3b3Jrc2FsdGhvdWdoZW50aXJlbHltZW1vcmlhbG1lc3NhZ2VzY29udGludWVhY3RpdmUiPnNvbWV3aGF0dmljdG9yaWFXZXN0ZXJuICB0aXRsZT0iTG9jYXRpb25jb250cmFjdHZpc2l0b3JzRG93bmxvYWR3aXRob3V0IHJpZ2h0Ij4KbWVhc3VyZXN3aWR0aCA9IHZhcmlhYmxlaW52b2x2ZWR2aXJnaW5pYW5vcm1hbGx5aGFwcGVuZWRhY2NvdW50c3N0YW5kaW5nbmF0aW9uYWxSZWdpc3RlcnByZXBhcmVkY29udHJvbHNhY2N1cmF0ZWJpcnRoZGF5c3RyYXRlZ3lvZmZpY2lhbGdyYXBoaWNzY3JpbWluYWxwb3NzaWJseWNvbnN1bWVyUGVyc29uYWxzcGVha2luZ3ZhbGlkYXRlYWNoaWV2ZWQuanBnIiAvPm1hY2hpbmVzPC9oMj4KICBrZXl3b3Jkc2ZyaWVuZGx5YnJvdGhlcnNjb21iaW5lZG9yaWdpbmFsY29tcG9zZWRleHBlY3RlZGFkZXF1YXRlcGFraXN0YW5mb2xsb3ciIHZhbHVhYmxlPC9sYWJlbD5yZWxhdGl2ZWJyaW5naW5naW5jcmVhc2Vnb3Zlcm5vcnBsdWdpbnMvTGlzdCBvZiBIZWFkZXIiPiIgbmFtZT0iICgmcXVvdDtncmFkdWF0ZTwvaGVhZD4KY29tbWVyY2VtYWxheXNpYWRpcmVjdG9ybWFpbnRhaW47aGVpZ2h0OnNjaGVkdWxlY2hhbmdpbmdiYWNrIHRvIGNhdGhvbGljcGF0dGVybnNjb2xvcjogI2dyZWF0ZXN0c3VwcGxpZXNyZWxpYWJsZTwvdWw+CgkJPHNlbGVjdCBjaXRpemVuc2Nsb3RoaW5nd2F0Y2hpbmc8bGkgaWQ9InNwZWNpZmljY2FycnlpbmdzZW50ZW5jZTxjZW50ZXI+Y29udHJhc3R0aGlua2luZ2NhdGNoKGUpc291dGhlcm5NaWNoYWVsIG1lcmNoYW50Y2Fyb3VzZWxwYWRkaW5nOmludGVyaW9yLnNwbGl0KCJsaXphdGlvbk9jdG9iZXIgKXtyZXR1cm5pbXByb3ZlZC0tJmd0OwoKY292ZXJhZ2VjaGFpcm1hbi5wbmciIC8+c3ViamVjdHNSaWNoYXJkIHdoYXRldmVycHJvYmFibHlyZWNvdmVyeWJhc2ViYWxsanVkZ21lbnRjb25uZWN0Li5jc3MiIC8+IHdlYnNpdGVyZXBvcnRlZGRlZmF1bHQiLz48L2E+DQplbGVjdHJpY3Njb3RsYW5kY3JlYXRpb25xdWFudGl0eS4gSVNCTiAwZGlkIG5vdCBpbnN0YW5jZS1zZWFyY2gtIiBsYW5nPSJzcGVha2Vyc0NvbXB1dGVyY29udGFpbnNhcmNoaXZlc21pbmlzdGVycmVhY3Rpb25kaXNjb3VudEl0YWxpYW5vY3JpdGVyaWFzdHJvbmdseTogJ2h0dHA6J3NjcmlwdCdjb3ZlcmluZ29mZmVyaW5nYXBwZWFyZWRCcml0aXNoIGlkZW50aWZ5RmFjZWJvb2tudW1lcm91c3ZlaGljbGVzY29uY2VybnNBbWVyaWNhbmhhbmRsaW5nZGl2IGlkPSJXaWxsaWFtIHByb3ZpZGVyX2NvbnRlbnRhY2N1cmFjeXNlY3Rpb24gYW5kZXJzb25mbGV4aWJsZUNhdGVnb3J5bGF3cmVuY2U8c2NyaXB0PmxheW91dD0iYXBwcm92ZWQgbWF4aW11bWhlYWRlciI+PC90YWJsZT5TZXJ2aWNlc2hhbWlsdG9uY3VycmVudCBjYW5hZGlhbmNoYW5uZWxzL3RoZW1lcy8vYXJ0aWNsZW9wdGlvbmFscG9ydHVnYWx2YWx1ZT0iImludGVydmFsd2lyZWxlc3NlbnRpdGxlZGFnZW5jaWVzU2VhcmNoIiBtZWFzdXJlZHRob3VzYW5kc3BlbmRpbmcmaGVsbGlwO25ldyBEYXRlIiBzaXplPSJwYWdlTmFtZW1pZGRsZSIgIiAvPjwvYT5oaWRkZW4iPnNlcXVlbmNlcGVyc29uYWxvdmVyZmxvd29waW5pb25zaWxsaW5vaXNsaW5rcyI+Cgk8dGl0bGU+dmVyc2lvbnNzYXR1cmRheXRlcm1pbmFsaXRlbXByb3BlbmdpbmVlcnNlY3Rpb25zZGVzaWduZXJwcm9wb3NhbD0iZmFsc2UiRXNwYcOxb2xyZWxlYXNlc3N1Ym1pdCIgZXImcXVvdDthZGRpdGlvbnN5bXB0b21zb3JpZW50ZWRyZXNvdXJjZXJpZ2h0Ij48cGxlYXN1cmVzdGF0aW9uc2hpc3RvcnkubGVhdmluZyAgYm9yZGVyPWNvbnRlbnRzY2VudGVyIj4uCgpTb21lIGRpcmVjdGVkc3VpdGFibGVidWxnYXJpYS5zaG93KCk7ZGVzaWduZWRHZW5lcmFsIGNvbmNlcHRzRXhhbXBsZXN3aWxsaWFtc09yaWdpbmFsIj48c3Bhbj5zZWFyY2giPm9wZXJhdG9ycmVxdWVzdHNhICZxdW90O2FsbG93aW5nRG9jdW1lbnRyZXZpc2lvbi4gCgpUaGUgeW91cnNlbGZDb250YWN0IG1pY2hpZ2FuRW5nbGlzaCBjb2x1bWJpYXByaW9yaXR5cHJpbnRpbmdkcmlua2luZ2ZhY2lsaXR5cmV0dXJuZWRDb250ZW50IG9mZmljZXJzUnVzc2lhbiBnZW5lcmF0ZS04ODU5LTEiaW5kaWNhdGVmYW1pbGlhciBxdWFsaXR5bWFyZ2luOjAgY29udGVudHZpZXdwb3J0Y29udGFjdHMtdGl0bGUiPnBvcnRhYmxlLmxlbmd0aCBlbGlnaWJsZWludm9sdmVzYXRsYW50aWNvbmxvYWQ9ImRlZmF1bHQuc3VwcGxpZWRwYXltZW50c2dsb3NzYXJ5CgpBZnRlciBndWlkYW5jZTwvdGQ+PHRkZW5jb2RpbmdtaWRkbGUiPmNhbWUgdG8gZGlzcGxheXNzY290dGlzaGpvbmF0aGFubWFqb3JpdHl3aWRnZXRzLmNsaW5pY2FsdGhhaWxhbmR0ZWFjaGVyczxoZWFkPgoJYWZmZWN0ZWRzdXBwb3J0c3BvaW50ZXI7dG9TdHJpbmc8L3NtYWxsPm9rbGFob21hd2lsbCBiZSBpbnZlc3RvcjAiIGFsdD0iaG9saWRheXNSZXNvdXJjZWxpY2Vuc2VkICh3aGljaCAuIEFmdGVyIGNvbnNpZGVydmlzaXRpbmdleHBsb3JlcnByaW1hcnkgc2VhcmNoIiBhbmRyb2lkInF1aWNrbHkgbWVldGluZ3Nlc3RpbWF0ZTtyZXR1cm4gO2NvbG9yOiMgaGVpZ2h0PWFwcHJvdmFsLCAmcXVvdDsgY2hlY2tlZC5taW4uanMibWFnbmV0aWM+PC9hPjwvaGZvcmVjYXN0LiBXaGlsZSB0aHVyc2RheWR2ZXJ0aXNlJmVhY3V0ZTtoYXNDbGFzc2V2YWx1YXRlb3JkZXJpbmdleGlzdGluZ3BhdGllbnRzIE9ubGluZSBjb2xvcmFkb09wdGlvbnMiY2FtcGJlbGw8IS0tIGVuZDwvc3Bhbj48PGJyIC8+DQpfcG9wdXBzfHNjaWVuY2VzLCZxdW90OyBxdWFsaXR5IFdpbmRvd3MgYXNzaWduZWRoZWlnaHQ6IDxiIGNsYXNzbGUmcXVvdDsgdmFsdWU9IiBDb21wYW55ZXhhbXBsZXM8aWZyYW1lIGJlbGlldmVzcHJlc2VudHNtYXJzaGFsbHBhcnQgb2YgcHJvcGVybHkpLgoKVGhlIHRheG9ub215bXVjaCBvZiA8L3NwYW4+CiIgZGF0YS1zcnR1Z3XDqnNzY3JvbGxUbyBwcm9qZWN0PGhlYWQ+DQphdHRvcm5leWVtcGhhc2lzc3BvbnNvcnNmYW5jeWJveHdvcmxkJ3Mgd2lsZGxpZmVjaGVja2VkPXNlc3Npb25zcHJvZ3JhbW1weDtmb250LSBQcm9qZWN0am91cm5hbHNiZWxpZXZlZHZhY2F0aW9udGhvbXBzb25saWdodGluZ2FuZCB0aGUgc3BlY2lhbCBib3JkZXI9MGNoZWNraW5nPC90Ym9keT48YnV0dG9uIENvbXBsZXRlY2xlYXJmaXgKPGhlYWQ+CmFydGljbGUgPHNlY3Rpb25maW5kaW5nc3JvbGUgaW4gcG9wdWxhciAgT2N0b2JlcndlYnNpdGUgZXhwb3N1cmV1c2VkIHRvICBjaGFuZ2Vzb3BlcmF0ZWRjbGlja2luZ2VudGVyaW5nY29tbWFuZHNpbmZvcm1lZCBudW1iZXJzICA8L2Rpdj5jcmVhdGluZ29uU3VibWl0bWFyeWxhbmRjb2xsZWdlc2FuYWx5dGljbGlzdGluZ3Njb250YWN0LmxvZ2dlZEluYWR2aXNvcnlzaWJsaW5nc2NvbnRlbnQicyZxdW90OylzLiBUaGlzIHBhY2thZ2VzY2hlY2tib3hzdWdnZXN0c3ByZWduYW50dG9tb3Jyb3dzcGFjaW5nPWljb24ucG5namFwYW5lc2Vjb2RlYmFzZWJ1dHRvbiI+Z2FtYmxpbmdzdWNoIGFzICwgd2hpbGUgPC9zcGFuPiBtaXNzb3VyaXNwb3J0aW5ndG9wOjFweCAuPC9zcGFuPnRlbnNpb25zd2lkdGg9IjJsYXp5bG9hZG5vdmVtYmVydXNlZCBpbiBoZWlnaHQ9ImNyaXB0Ij4KJm5ic3A7PC88dHI+PHRkIGhlaWdodDoyL3Byb2R1Y3Rjb3VudHJ5IGluY2x1ZGUgZm9vdGVyIiAmbHQ7IS0tIHRpdGxlIj48L2pxdWVyeS48L2Zvcm0+CijnroDkvZMpKOe5gemrlClocnZhdHNraWl0YWxpYW5vcm9tw6JuxIN0w7xya8OnZdin2LHYr9mIdGFtYmnDqW5ub3RpY2lhc21lbnNhamVzcGVyc29uYXNkZXJlY2hvc25hY2lvbmFsc2VydmljaW9jb250YWN0b3VzdWFyaW9zcHJvZ3JhbWFnb2JpZXJub2VtcHJlc2FzYW51bmNpb3N2YWxlbmNpYWNvbG9tYmlhZGVzcHXDqXNkZXBvcnRlc3Byb3llY3RvcHJvZHVjdG9ww7pibGljb25vc290cm9zaGlzdG9yaWFwcmVzZW50ZW1pbGxvbmVzbWVkaWFudGVwcmVndW50YWFudGVyaW9ycmVjdXJzb3Nwcm9ibGVtYXNhbnRpYWdvbnVlc3Ryb3NvcGluacOzbmltcHJpbWlybWllbnRyYXNhbcOpcmljYXZlbmRlZG9yc29jaWVkYWRyZXNwZWN0b3JlYWxpemFycmVnaXN0cm9wYWxhYnJhc2ludGVyw6lzZW50b25jZXNlc3BlY2lhbG1pZW1icm9zcmVhbGlkYWRjw7NyZG9iYXphcmFnb3phcMOhZ2luYXNzb2NpYWxlc2Jsb3F1ZWFyZ2VzdGnDs25hbHF1aWxlcnNpc3RlbWFzY2llbmNpYXNjb21wbGV0b3ZlcnNpw7NuY29tcGxldGFlc3R1ZGlvc3DDumJsaWNhb2JqZXRpdm9hbGljYW50ZWJ1c2NhZG9yY2FudGlkYWRlbnRyYWRhc2FjY2lvbmVzYXJjaGl2b3NzdXBlcmlvcm1heW9yw61hYWxlbWFuaWFmdW5jacOzbsO6bHRpbW9zaGFjaWVuZG9hcXVlbGxvc2VkaWNpw7NuZmVybmFuZG9hbWJpZW50ZWZhY2Vib29rbnVlc3RyYXNjbGllbnRlc3Byb2Nlc29zYmFzdGFudGVwcmVzZW50YXJlcG9ydGFyY29uZ3Jlc29wdWJsaWNhcmNvbWVyY2lvY29udHJhdG9qw7N2ZW5lc2Rpc3RyaXRvdMOpY25pY2Fjb25qdW50b2VuZXJnw61hdHJhYmFqYXJhc3R1cmlhc3JlY2llbnRldXRpbGl6YXJib2xldMOtbnNhbHZhZG9yY29ycmVjdGF0cmFiYWpvc3ByaW1lcm9zbmVnb2Npb3NsaWJlcnRhZGRldGFsbGVzcGFudGFsbGFwcsOzeGltb2FsbWVyw61hYW5pbWFsZXNxdWnDqW5lc2NvcmF6w7Nuc2VjY2nDs25idXNjYW5kb29wY2lvbmVzZXh0ZXJpb3Jjb25jZXB0b3RvZGF2w61hZ2FsZXLDrWFlc2NyaWJpcm1lZGljaW5hbGljZW5jaWFjb25zdWx0YWFzcGVjdG9zY3LDrXRpY2Fkw7NsYXJlc2p1c3RpY2lhZGViZXLDoW5wZXLDrW9kb25lY2VzaXRhbWFudGVuZXJwZXF1ZcOxb3JlY2liaWRhdHJpYnVuYWx0ZW5lcmlmZWNhbmNpw7NuY2FuYXJpYXNkZXNjYXJnYWRpdmVyc29zbWFsbG9yY2FyZXF1aWVyZXTDqWNuaWNvZGViZXLDrWF2aXZpZW5kYWZpbmFuemFzYWRlbGFudGVmdW5jaW9uYWNvbnNlam9zZGlmw61jaWxjaXVkYWRlc2FudGlndWFzYXZhbnphZGF0w6lybWlub3VuaWRhZGVzc8OhbmNoZXpjYW1wYcOxYXNvZnRvbmljcmV2aXN0YXNjb250aWVuZXNlY3RvcmVzbW9tZW50b3NmYWN1bHRhZGNyw6lkaXRvZGl2ZXJzYXNzdXB1ZXN0b2ZhY3RvcmVzc2VndW5kb3NwZXF1ZcOxYdCz0L7QtNCw0LXRgdC70LjQtdGB0YLRjNCx0YvQu9C+0LHRi9GC0YzRjdGC0L7QvNCV0YHQu9C40YLQvtCz0L7QvNC10L3Rj9Cy0YHQtdGF0Y3RgtC+0LnQtNCw0LbQtdCx0YvQu9C40LPQvtC00YPQtNC10L3RjNGN0YLQvtGC0LHRi9C70LDRgdC10LHRj9C+0LTQuNC90YHQtdCx0LXQvdCw0LTQvtGB0LDQudGC0YTQvtGC0L7QvdC10LPQvtGB0LLQvtC40YHQstC+0LnQuNCz0YDRi9GC0L7QttC10LLRgdC10LzRgdCy0L7RjtC70LjRiNGM0Y3RgtC40YXQv9C+0LrQsNC00L3QtdC50LTQvtC80LDQvNC40YDQsNC70LjQsdC+0YLQtdC80YPRhdC+0YLRj9C00LLRg9GF0YHQtdGC0LjQu9GO0LTQuNC00LXQu9C+0LzQuNGA0LXRgtC10LHRj9GB0LLQvtC10LLQuNC00LXRh9C10LPQvtGN0YLQuNC80YHRh9C10YLRgtC10LzRi9GG0LXQvdGL0YHRgtCw0LvQstC10LTRjNGC0LXQvNC10LLQvtC00YvRgtC10LHQtdCy0YvRiNC10L3QsNC80LjRgtC40L/QsNGC0L7QvNGD0L/RgNCw0LLQu9C40YbQsNC+0LTQvdCw0LPQvtC00YvQt9C90LDRjtC80L7Qs9GD0LTRgNGD0LPQstGB0LXQudC40LTQtdGC0LrQuNC90L7QvtC00L3QvtC00LXQu9Cw0LTQtdC70LXRgdGA0L7QutC40Y7QvdGP0LLQtdGB0YzQldGB0YLRjNGA0LDQt9Cw0L3QsNGI0LjYp9mE2YTZh9in2YTYqtmK2KzZhdmK2LnYrtin2LXYqdin2YTYsNmK2LnZhNmK2YfYrNiv2YrYr9in2YTYotmG2KfZhNix2K/Yqtit2YPZhdi12YHYrdip2YPYp9mG2KrYp9mE2YTZitmK2YPZiNmG2LTYqNmD2KnZgdmK2YfYp9io2YbYp9iq2K3ZiNin2KHYo9mD2KvYsdiu2YTYp9mE2KfZhNit2KjYr9mE2YrZhNiv2LHZiNiz2KfYtti62LfYqtmD2YjZhtmH2YbYp9mD2LPYp9it2KnZhtin2K/Zitin2YTYt9io2LnZhNmK2YPYtNmD2LHYp9mK2YXZg9mG2YXZhtmH2KfYtNix2YPYqdix2KbZitiz2YbYtNmK2LfZhdin2LDYp9in2YTZgdmG2LTYqNin2KjYqti52KjYsdix2K3Zhdip2YPYp9mB2KnZitmC2YjZhNmF2LHZg9iy2YPZhNmF2KnYo9it2YXYr9mC2YTYqNmK2YrYudmG2YrYtdmI2LHYqdi32LHZitmC2LTYp9ix2YPYrNmI2KfZhNij2K7YsdmJ2YXYudmG2KfYp9io2K3Yq9i52LHZiNi22KjYtNmD2YTZhdiz2KzZhNio2YbYp9mG2K7Yp9mE2K/Zg9iq2KfYqNmD2YTZitip2KjYr9mI2YbYo9mK2LbYp9mK2YjYrNiv2YHYsdmK2YLZg9iq2KjYqtij2YHYttmE2YXYt9io2K7Yp9mD2KvYsdio2KfYsdmD2KfZgdi22YTYp9it2YTZidmG2YHYs9mH2KPZitin2YXYsdiv2YjYr9ij2YbZh9in2K/ZitmG2KfYp9mE2KfZhtmF2LnYsdi22KrYudmE2YXYr9in2K7ZhNmF2YXZg9mGAAAAAAAAAAABAAEAAQABAAIAAgACAAIABAAEAAQABAAAAQIDBAUGBwcGBQQDAgEACAkKCwwNDg8PDg0MCwoJCBAREhMUFRYXFxYVFBMSERAYGRobHB0eHx8eHRwbGhkY/////wAAAAAAAAAA/////wEAAAACAAAAAgAAAAEAAAABAAAAAwAAAP//AAEAAAABAAD//wABAAAACAAIAAgACAAAAAEAAgADAAQABQAGAAdyZXNvdXJjZXNjb3VudHJpZXNxdWVzdGlvbnNlcXVpcG1lbnRjb21tdW5pdHlhdmFpbGFibGVoaWdobGlnaHREVEQveGh0bWxtYXJrZXRpbmdrbm93bGVkZ2Vzb21ldGhpbmdjb250YWluZXJkaXJlY3Rpb25zdWJzY3JpYmVhZHZlcnRpc2VjaGFyYWN0ZXIiIHZhbHVlPSI8L3NlbGVjdD5BdXN0cmFsaWEiIGNsYXNzPSJzaXR1YXRpb25hdXRob3JpdHlmb2xsb3dpbmdwcmltYXJpbHlvcGVyYXRpb25jaGFsbGVuZ2VkZXZlbG9wZWRhbm9ueW1vdXNmdW5jdGlvbiBmdW5jdGlvbnNjb21wYW5pZXNzdHJ1Y3R1cmVhZ3JlZW1lbnQiIHRpdGxlPSJwb3RlbnRpYWxlZHVjYXRpb25hcmd1bWVudHNzZWNvbmRhcnljb3B5cmlnaHRsYW5ndWFnZXNleGNsdXNpdmVjb25kaXRpb248L2Zvcm0+DQpzdGF0ZW1lbnRhdHRlbnRpb25CaW9ncmFwaHl9IGVsc2Ugewpzb2x1dGlvbnN3aGVuIHRoZSBBbmFseXRpY3N0ZW1wbGF0ZXNkYW5nZXJvdXNzYXRlbGxpdGVkb2N1bWVudHNwdWJsaXNoZXJpbXBvcnRhbnRwcm90b3R5cGVpbmZsdWVuY2UmcmFxdW87PC9lZmZlY3RpdmVnZW5lcmFsbHl0cmFuc2Zvcm1iZWF1dGlmdWx0cmFuc3BvcnRvcmdhbml6ZWRwdWJsaXNoZWRwcm9taW5lbnR1bnRpbCB0aGV0aHVtYm5haWxOYXRpb25hbCAuZm9jdXMoKTtvdmVyIHRoZSBtaWdyYXRpb25hbm5vdW5jZWRmb290ZXIiPgpleGNlcHRpb25sZXNzIHRoYW5leHBlbnNpdmVmb3JtYXRpb25mcmFtZXdvcmt0ZXJyaXRvcnluZGljYXRpb25jdXJyZW50bHljbGFzc05hbWVjcml0aWNpc210cmFkaXRpb25lbHNld2hlcmVBbGV4YW5kZXJhcHBvaW50ZWRtYXRlcmlhbHNicm9hZGNhc3RtZW50aW9uZWRhZmZpbGlhdGU8L29wdGlvbj50cmVhdG1lbnRkaWZmZXJlbnQvZGVmYXVsdC5QcmVzaWRlbnRvbmNsaWNrPSJiaW9ncmFwaHlvdGhlcndpc2VwZXJtYW5lbnRGcmFuw6dhaXNIb2xseXdvb2RleHBhbnNpb25zdGFuZGFyZHM8L3N0eWxlPgpyZWR1Y3Rpb25EZWNlbWJlciBwcmVmZXJyZWRDYW1icmlkZ2VvcHBvbmVudHNCdXNpbmVzcyBjb25mdXNpb24+Cjx0aXRsZT5wcmVzZW50ZWRleHBsYWluZWRkb2VzIG5vdCB3b3JsZHdpZGVpbnRlcmZhY2Vwb3NpdGlvbnNuZXdzcGFwZXI8L3RhYmxlPgptb3VudGFpbnNsaWtlIHRoZSBlc3NlbnRpYWxmaW5hbmNpYWxzZWxlY3Rpb25hY3Rpb249Ii9hYmFuZG9uZWRFZHVjYXRpb25wYXJzZUludChzdGFiaWxpdHl1bmFibGUgdG88L3RpdGxlPgpyZWxhdGlvbnNOb3RlIHRoYXRlZmZpY2llbnRwZXJmb3JtZWR0d28geWVhcnNTaW5jZSB0aGV0aGVyZWZvcmV3cmFwcGVyIj5hbHRlcm5hdGVpbmNyZWFzZWRCYXR0bGUgb2ZwZXJjZWl2ZWR0cnlpbmcgdG9uZWNlc3Nhcnlwb3J0cmF5ZWRlbGVjdGlvbnNFbGl6YWJldGg8L2lmcmFtZT5kaXNjb3ZlcnlpbnN1cmFuY2VzLmxlbmd0aDtsZWdlbmRhcnlHZW9ncmFwaHljYW5kaWRhdGVjb3Jwb3JhdGVzb21ldGltZXNzZXJ2aWNlcy5pbmhlcml0ZWQ8L3N0cm9uZz5Db21tdW5pdHlyZWxpZ2lvdXNsb2NhdGlvbnNDb21taXR0ZWVidWlsZGluZ3N0aGUgd29ybGRubyBsb25nZXJiZWdpbm5pbmdyZWZlcmVuY2VjYW5ub3QgYmVmcmVxdWVuY3l0eXBpY2FsbHlpbnRvIHRoZSByZWxhdGl2ZTtyZWNvcmRpbmdwcmVzaWRlbnRpbml0aWFsbHl0ZWNobmlxdWV0aGUgb3RoZXJpdCBjYW4gYmVleGlzdGVuY2V1bmRlcmxpbmV0aGlzIHRpbWV0ZWxlcGhvbmVpdGVtc2NvcGVwcmFjdGljZXNhZHZhbnRhZ2UpO3JldHVybiBGb3Igb3RoZXJwcm92aWRpbmdkZW1vY3JhY3lib3RoIHRoZSBleHRlbnNpdmVzdWZmZXJpbmdzdXBwb3J0ZWRjb21wdXRlcnMgZnVuY3Rpb25wcmFjdGljYWxzYWlkIHRoYXRpdCBtYXkgYmVFbmdsaXNoPC9mcm9tIHRoZSBzY2hlZHVsZWRkb3dubG9hZHM8L2xhYmVsPgpzdXNwZWN0ZWRtYXJnaW46IDBzcGlyaXR1YWw8L2hlYWQ+CgptaWNyb3NvZnRncmFkdWFsbHlkaXNjdXNzZWRoZSBiZWNhbWVleGVjdXRpdmVqcXVlcnkuanNob3VzZWhvbGRjb25maXJtZWRwdXJjaGFzZWRsaXRlcmFsbHlkZXN0cm95ZWR1cCB0byB0aGV2YXJpYXRpb25yZW1haW5pbmdpdCBpcyBub3RjZW50dXJpZXNKYXBhbmVzZSBhbW9uZyB0aGVjb21wbGV0ZWRhbGdvcml0aG1pbnRlcmVzdHNyZWJlbGxpb251bmRlZmluZWRlbmNvdXJhZ2VyZXNpemFibGVpbnZvbHZpbmdzZW5zaXRpdmV1bml2ZXJzYWxwcm92aXNpb24oYWx0aG91Z2hmZWF0dXJpbmdjb25kdWN0ZWQpLCB3aGljaCBjb250aW51ZWQtaGVhZGVyIj5GZWJydWFyeSBudW1lcm91cyBvdmVyZmxvdzpjb21wb25lbnRmcmFnbWVudHNleGNlbGxlbnRjb2xzcGFuPSJ0ZWNobmljYWxuZWFyIHRoZSBBZHZhbmNlZCBzb3VyY2Ugb2ZleHByZXNzZWRIb25nIEtvbmcgRmFjZWJvb2ttdWx0aXBsZSBtZWNoYW5pc21lbGV2YXRpb25vZmZlbnNpdmU8L2Zvcm0+CglzcG9uc29yZWRkb2N1bWVudC5vciAmcXVvdDt0aGVyZSBhcmV0aG9zZSB3aG9tb3ZlbWVudHNwcm9jZXNzZXNkaWZmaWN1bHRzdWJtaXR0ZWRyZWNvbW1lbmRjb252aW5jZWRwcm9tb3RpbmciIHdpZHRoPSIucmVwbGFjZShjbGFzc2ljYWxjb2FsaXRpb25oaXMgZmlyc3RkZWNpc2lvbnNhc3Npc3RhbnRpbmRpY2F0ZWRldm9sdXRpb24td3JhcHBlciJlbm91Z2ggdG9hbG9uZyB0aGVkZWxpdmVyZWQtLT4NCjwhLS1BbWVyaWNhbiBwcm90ZWN0ZWROb3ZlbWJlciA8L3N0eWxlPjxmdXJuaXR1cmVJbnRlcm5ldCAgb25ibHVyPSJzdXNwZW5kZWRyZWNpcGllbnRiYXNlZCBvbiBNb3Jlb3ZlcixhYm9saXNoZWRjb2xsZWN0ZWR3ZXJlIG1hZGVlbW90aW9uYWxlbWVyZ2VuY3luYXJyYXRpdmVhZHZvY2F0ZXNweDtib3JkZXJjb21taXR0ZWRkaXI9Imx0ciJlbXBsb3llZXNyZXNlYXJjaC4gc2VsZWN0ZWRzdWNjZXNzb3JjdXN0b21lcnNkaXNwbGF5ZWRTZXB0ZW1iZXJhZGRDbGFzcyhGYWNlYm9vayBzdWdnZXN0ZWRhbmQgbGF0ZXJvcGVyYXRpbmdlbGFib3JhdGVTb21ldGltZXNJbnN0aXR1dGVjZXJ0YWlubHlpbnN0YWxsZWRmb2xsb3dlcnNKZXJ1c2FsZW10aGV5IGhhdmVjb21wdXRpbmdnZW5lcmF0ZWRwcm92aW5jZXNndWFyYW50ZWVhcmJpdHJhcnlyZWNvZ25pemV3YW50ZWQgdG9weDt3aWR0aDp0aGVvcnkgb2ZiZWhhdmlvdXJXaGlsZSB0aGVlc3RpbWF0ZWRiZWdhbiB0byBpdCBiZWNhbWVtYWduaXR1ZGVtdXN0IGhhdmVtb3JlIHRoYW5EaXJlY3RvcnlleHRlbnNpb25zZWNyZXRhcnluYXR1cmFsbHlvY2N1cnJpbmd2YXJpYWJsZXNnaXZlbiB0aGVwbGF0Zm9ybS48L2xhYmVsPjxmYWlsZWQgdG9jb21wb3VuZHNraW5kcyBvZiBzb2NpZXRpZXNhbG9uZ3NpZGUgLS0mZ3Q7Cgpzb3V0aHdlc3R0aGUgcmlnaHRyYWRpYXRpb25tYXkgaGF2ZSB1bmVzY2FwZShzcG9rZW4gaW4iIGhyZWY9Ii9wcm9ncmFtbWVvbmx5IHRoZSBjb21lIGZyb21kaXJlY3RvcnlidXJpZWQgaW5hIHNpbWlsYXJ0aGV5IHdlcmU8L2ZvbnQ+PC9Ob3J3ZWdpYW5zcGVjaWZpZWRwcm9kdWNpbmdwYXNzZW5nZXIobmV3IERhdGV0ZW1wb3JhcnlmaWN0aW9uYWxBZnRlciB0aGVlcXVhdGlvbnNkb3dubG9hZC5yZWd1bGFybHlkZXZlbG9wZXJhYm92ZSB0aGVsaW5rZWQgdG9waGVub21lbmFwZXJpb2Qgb2Z0b29sdGlwIj5zdWJzdGFuY2VhdXRvbWF0aWNhc3BlY3Qgb2ZBbW9uZyB0aGVjb25uZWN0ZWRlc3RpbWF0ZXNBaXIgRm9yY2VzeXN0ZW0gb2ZvYmplY3RpdmVpbW1lZGlhdGVtYWtpbmcgaXRwYWludGluZ3Njb25xdWVyZWRhcmUgc3RpbGxwcm9jZWR1cmVncm93dGggb2ZoZWFkZWQgYnlFdXJvcGVhbiBkaXZpc2lvbnNtb2xlY3VsZXNmcmFuY2hpc2VpbnRlbnRpb25hdHRyYWN0ZWRjaGlsZGhvb2RhbHNvIHVzZWRkZWRpY2F0ZWRzaW5nYXBvcmVkZWdyZWUgb2ZmYXRoZXIgb2Zjb25mbGljdHM8L2E+PC9wPgpjYW1lIGZyb213ZXJlIHVzZWRub3RlIHRoYXRyZWNlaXZpbmdFeGVjdXRpdmVldmVuIG1vcmVhY2Nlc3MgdG9jb21tYW5kZXJQb2xpdGljYWxtdXNpY2lhbnNkZWxpY2lvdXNwcmlzb25lcnNhZHZlbnQgb2ZVVEYtOCIgLz48IVtDREFUQVsiPkNvbnRhY3RTb3V0aGVybiBiZ2NvbG9yPSJzZXJpZXMgb2YuIEl0IHdhcyBpbiBFdXJvcGVwZXJtaXR0ZWR2YWxpZGF0ZS5hcHBlYXJpbmdvZmZpY2lhbHNzZXJpb3VzbHktbGFuZ3VhZ2Vpbml0aWF0ZWRleHRlbmRpbmdsb25nLXRlcm1pbmZsYXRpb25zdWNoIHRoYXRnZXRDb29raWVtYXJrZWQgYnk8L2J1dHRvbj5pbXBsZW1lbnRidXQgaXQgaXNpbmNyZWFzZXNkb3duIHRoZSByZXF1aXJpbmdkZXBlbmRlbnQtLT4KPCEtLSBpbnRlcnZpZXdXaXRoIHRoZSBjb3BpZXMgb2Zjb25zZW5zdXN3YXMgYnVpbHRWZW5lenVlbGEoZm9ybWVybHl0aGUgc3RhdGVwZXJzb25uZWxzdHJhdGVnaWNmYXZvdXIgb2ZpbnZlbnRpb25XaWtpcGVkaWFjb250aW5lbnR2aXJ0dWFsbHl3aGljaCB3YXNwcmluY2lwbGVDb21wbGV0ZSBpZGVudGljYWxzaG93IHRoYXRwcmltaXRpdmVhd2F5IGZyb21tb2xlY3VsYXJwcmVjaXNlbHlkaXNzb2x2ZWRVbmRlciB0aGV2ZXJzaW9uPSI+Jm5ic3A7PC9JdCBpcyB0aGUgVGhpcyBpcyB3aWxsIGhhdmVvcmdhbmlzbXNzb21lIHRpbWVGcmllZHJpY2h3YXMgZmlyc3R0aGUgb25seSBmYWN0IHRoYXRmb3JtIGlkPSJwcmVjZWRpbmdUZWNobmljYWxwaHlzaWNpc3RvY2N1cnMgaW5uYXZpZ2F0b3JzZWN0aW9uIj5zcGFuIGlkPSJzb3VnaHQgdG9iZWxvdyB0aGVzdXJ2aXZpbmd9PC9zdHlsZT5oaXMgZGVhdGhhcyBpbiB0aGVjYXVzZWQgYnlwYXJ0aWFsbHlleGlzdGluZyB1c2luZyB0aGV3YXMgZ2l2ZW5hIGxpc3Qgb2ZsZXZlbHMgb2Zub3Rpb24gb2ZPZmZpY2lhbCBkaXNtaXNzZWRzY2llbnRpc3RyZXNlbWJsZXNkdXBsaWNhdGVleHBsb3NpdmVyZWNvdmVyZWRhbGwgb3RoZXJnYWxsZXJpZXN7cGFkZGluZzpwZW9wbGUgb2ZyZWdpb24gb2ZhZGRyZXNzZXNhc3NvY2lhdGVpbWcgYWx0PSJpbiBtb2Rlcm5zaG91bGQgYmVtZXRob2Qgb2ZyZXBvcnRpbmd0aW1lc3RhbXBuZWVkZWQgdG90aGUgR3JlYXRyZWdhcmRpbmdzZWVtZWQgdG92aWV3ZWQgYXNpbXBhY3Qgb25pZGVhIHRoYXR0aGUgV29ybGRoZWlnaHQgb2ZleHBhbmRpbmdUaGVzZSBhcmVjdXJyZW50Ij5jYXJlZnVsbHltYWludGFpbnNjaGFyZ2Ugb2ZDbGFzc2ljYWxhZGRyZXNzZWRwcmVkaWN0ZWRvd25lcnNoaXA8ZGl2IGlkPSJyaWdodCI+DQpyZXNpZGVuY2VsZWF2ZSB0aGVjb250ZW50Ij5hcmUgb2Z0ZW4gIH0pKCk7DQpwcm9iYWJseSBQcm9mZXNzb3ItYnV0dG9uIiByZXNwb25kZWRzYXlzIHRoYXRoYWQgdG8gYmVwbGFjZWQgaW5IdW5nYXJpYW5zdGF0dXMgb2ZzZXJ2ZXMgYXNVbml2ZXJzYWxleGVjdXRpb25hZ2dyZWdhdGVmb3Igd2hpY2hpbmZlY3Rpb25hZ3JlZWQgdG9ob3dldmVyLCBwb3B1bGFyIj5wbGFjZWQgb25jb25zdHJ1Y3RlbGVjdG9yYWxzeW1ib2wgb2ZpbmNsdWRpbmdyZXR1cm4gdG9hcmNoaXRlY3RDaHJpc3RpYW5wcmV2aW91cyBsaXZpbmcgaW5lYXNpZXIgdG9wcm9mZXNzb3IKJmx0OyEtLSBlZmZlY3Qgb2ZhbmFseXRpY3N3YXMgdGFrZW53aGVyZSB0aGV0b29rIG92ZXJiZWxpZWYgaW5BZnJpa2FhbnNhcyBmYXIgYXNwcmV2ZW50ZWR3b3JrIHdpdGhhIHNwZWNpYWw8ZmllbGRzZXRDaHJpc3RtYXNSZXRyaWV2ZWQKCkluIHRoZSBiYWNrIGludG9ub3J0aGVhc3RtYWdhemluZXM+PHN0cm9uZz5jb21taXR0ZWVnb3Zlcm5pbmdncm91cHMgb2ZzdG9yZWQgaW5lc3RhYmxpc2hhIGdlbmVyYWxpdHMgZmlyc3R0aGVpciBvd25wb3B1bGF0ZWRhbiBvYmplY3RDYXJpYmJlYW5hbGxvdyB0aGVkaXN0cmljdHN3aXNjb25zaW5sb2NhdGlvbi47IHdpZHRoOiBpbmhhYml0ZWRTb2NpYWxpc3RKYW51YXJ5IDE8L2Zvb3Rlcj5zaW1pbGFybHljaG9pY2Ugb2Z0aGUgc2FtZSBzcGVjaWZpYyBidXNpbmVzcyBUaGUgZmlyc3QubGVuZ3RoOyBkZXNpcmUgdG9kZWFsIHdpdGhzaW5jZSB0aGV1c2VyQWdlbnRjb25jZWl2ZWRpbmRleC5waHBhcyAmcXVvdDtlbmdhZ2UgaW5yZWNlbnRseSxmZXcgeWVhcnN3ZXJlIGFsc28KPGhlYWQ+CjxlZGl0ZWQgYnlhcmUga25vd25jaXRpZXMgaW5hY2Nlc3NrZXljb25kZW1uZWRhbHNvIGhhdmVzZXJ2aWNlcyxmYW1pbHkgb2ZTY2hvb2wgb2Zjb252ZXJ0ZWRuYXR1cmUgb2YgbGFuZ3VhZ2VtaW5pc3RlcnM8L29iamVjdD50aGVyZSBpcyBhIHBvcHVsYXJzZXF1ZW5jZXNhZHZvY2F0ZWRUaGV5IHdlcmVhbnkgb3RoZXJsb2NhdGlvbj1lbnRlciB0aGVtdWNoIG1vcmVyZWZsZWN0ZWR3YXMgbmFtZWRvcmlnaW5hbCBhIHR5cGljYWx3aGVuIHRoZXllbmdpbmVlcnNjb3VsZCBub3RyZXNpZGVudHN3ZWRuZXNkYXl0aGUgdGhpcmQgcHJvZHVjdHNKYW51YXJ5IDJ3aGF0IHRoZXlhIGNlcnRhaW5yZWFjdGlvbnNwcm9jZXNzb3JhZnRlciBoaXN0aGUgbGFzdCBjb250YWluZWQiPjwvZGl2Pgo8L2E+PC90ZD5kZXBlbmQgb25zZWFyY2giPgpwaWVjZXMgb2Zjb21wZXRpbmdSZWZlcmVuY2V0ZW5uZXNzZWV3aGljaCBoYXMgdmVyc2lvbj08L3NwYW4+IDw8L2hlYWRlcj5naXZlcyB0aGVoaXN0b3JpYW52YWx1ZT0iIj5wYWRkaW5nOjB2aWV3IHRoYXR0b2dldGhlcix0aGUgbW9zdCB3YXMgZm91bmRzdWJzZXQgb2ZhdHRhY2sgb25jaGlsZHJlbixwb2ludHMgb2ZwZXJzb25hbCBwb3NpdGlvbjphbGxlZ2VkbHlDbGV2ZWxhbmR3YXMgbGF0ZXJhbmQgYWZ0ZXJhcmUgZ2l2ZW53YXMgc3RpbGxzY3JvbGxpbmdkZXNpZ24gb2ZtYWtlcyB0aGVtdWNoIGxlc3NBbWVyaWNhbnMuCgpBZnRlciAsIGJ1dCB0aGVNdXNldW0gb2Zsb3Vpc2lhbmEoZnJvbSB0aGVtaW5uZXNvdGFwYXJ0aWNsZXNhIHByb2Nlc3NEb21pbmljYW52b2x1bWUgb2ZyZXR1cm5pbmdkZWZlbnNpdmUwMHB4fHJpZ2htYWRlIGZyb21tb3VzZW92ZXIiIHN0eWxlPSJzdGF0ZXMgb2Yod2hpY2ggaXNjb250aW51ZXNGcmFuY2lzY29idWlsZGluZyB3aXRob3V0IGF3aXRoIHNvbWV3aG8gd291bGRhIGZvcm0gb2ZhIHBhcnQgb2ZiZWZvcmUgaXRrbm93biBhcyAgU2VydmljZXNsb2NhdGlvbiBhbmQgb2Z0ZW5tZWFzdXJpbmdhbmQgaXQgaXNwYXBlcmJhY2t2YWx1ZXMgb2YNCjx0aXRsZT49IHdpbmRvdy5kZXRlcm1pbmVlciZxdW90OyBwbGF5ZWQgYnlhbmQgZWFybHk8L2NlbnRlcj5mcm9tIHRoaXN0aGUgdGhyZWVwb3dlciBhbmRvZiAmcXVvdDtpbm5lckhUTUw8YSBocmVmPSJ5OmlubGluZTtDaHVyY2ggb2Z0aGUgZXZlbnR2ZXJ5IGhpZ2hvZmZpY2lhbCAtaGVpZ2h0OiBjb250ZW50PSIvY2dpLWJpbi90byBjcmVhdGVhZnJpa2FhbnNlc3BlcmFudG9mcmFuw6dhaXNsYXR2aWXFoXVsaWV0dXZpxbPEjGXFoXRpbmHEjWXFoXRpbmHguYTguJfguKLml6XmnKzoqp7nroDkvZPlrZfnuYHpq5TlrZftlZzqta3slrTkuLrku4DkuYjorqHnrpfmnLrnrJTorrDmnKzoqI7oq5bljYDmnI3liqHlmajkupLogZTnvZHmiL/lnLDkuqfkv7HkuZDpg6jlh7rniYjnpL7mjpLooYzmppzpg6jokL3moLzov5vkuIDmraXmlK/ku5jlrp3pqozor4HnoIHlp5TlkZjkvJrmlbDmja7lupPmtojotLnogIXlip7lhazlrqTorqjorrrljLrmt7HlnLPluILmkq3mlL7lmajljJfkuqzluILlpKflrabnlJ/otormnaXotornrqHnkIblkZjkv6Hmga/nvZFzZXJ2aWNpb3NhcnTDrWN1bG9hcmdlbnRpbmFiYXJjZWxvbmFjdWFscXVpZXJwdWJsaWNhZG9wcm9kdWN0b3Nwb2zDrXRpY2FyZXNwdWVzdGF3aWtpcGVkaWFzaWd1aWVudGViw7pzcXVlZGFjb211bmlkYWRzZWd1cmlkYWRwcmluY2lwYWxwcmVndW50YXNjb250ZW5pZG9yZXNwb25kZXJ2ZW5lenVlbGFwcm9ibGVtYXNkaWNpZW1icmVyZWxhY2nDs25ub3ZpZW1icmVzaW1pbGFyZXNwcm95ZWN0b3Nwcm9ncmFtYXNpbnN0aXR1dG9hY3RpdmlkYWRlbmN1ZW50cmFlY29ub23DrWFpbcOhZ2VuZXNjb250YWN0YXJkZXNjYXJnYXJuZWNlc2FyaW9hdGVuY2nDs250ZWzDqWZvbm9jb21pc2nDs25jYW5jaW9uZXNjYXBhY2lkYWRlbmNvbnRyYXJhbsOhbGlzaXNmYXZvcml0b3N0w6lybWlub3Nwcm92aW5jaWFldGlxdWV0YXNlbGVtZW50b3NmdW5jaW9uZXNyZXN1bHRhZG9jYXLDoWN0ZXJwcm9waWVkYWRwcmluY2lwaW9uZWNlc2lkYWRtdW5pY2lwYWxjcmVhY2nDs25kZXNjYXJnYXNwcmVzZW5jaWFjb21lcmNpYWxvcGluaW9uZXNlamVyY2ljaW9lZGl0b3JpYWxzYWxhbWFuY2Fnb256w6FsZXpkb2N1bWVudG9wZWzDrWN1bGFyZWNpZW50ZXNnZW5lcmFsZXN0YXJyYWdvbmFwcsOhY3RpY2Fub3ZlZGFkZXNwcm9wdWVzdGFwYWNpZW50ZXN0w6ljbmljYXNvYmpldGl2b3Njb250YWN0b3PgpK7gpYfgpILgpLLgpL/gpI/gpLngpYjgpILgpJfgpK/gpL7gpLjgpL7gpKXgpI/gpLXgpILgpLDgpLngpYfgpJXgpYvgpIjgpJXgpYHgpJvgpLDgpLngpL7gpKzgpL7gpKbgpJXgpLngpL7gpLjgpK3gpYDgpLngpYHgpI/gpLDgpLngpYDgpK7gpYjgpILgpKbgpL/gpKjgpKzgpL7gpKRkaXBsb2RvY3PgpLjgpK7gpK/gpLDgpYLgpKrgpKjgpL7gpK7gpKrgpKTgpL7gpKvgpL/gpLDgpJTgpLjgpKTgpKTgpLDgpLngpLLgpYvgpJfgpLngpYHgpIbgpKzgpL7gpLDgpKbgpYfgpLbgpLngpYHgpIjgpJbgpYfgpLLgpK/gpKbgpL/gpJXgpL7gpK7gpLXgpYfgpKzgpKTgpYDgpKjgpKzgpYDgpJrgpK7gpYzgpKTgpLjgpL7gpLLgpLLgpYfgpJbgpJzgpYngpKzgpK7gpKbgpKbgpKTgpKXgpL7gpKjgpLngpYDgpLbgpLngpLDgpIXgpLLgpJfgpJXgpK3gpYDgpKjgpJfgpLDgpKrgpL7gpLjgpLDgpL7gpKTgpJXgpL/gpI/gpIngpLjgpYfgpJfgpK/gpYDgpLngpYLgpIHgpIbgpJfgpYfgpJ/gpYDgpK7gpJbgpYvgpJzgpJXgpL7gpLDgpIXgpK3gpYDgpJfgpK/gpYfgpKTgpYHgpK7gpLXgpYvgpJ/gpKbgpYfgpILgpIXgpJfgpLDgpJDgpLjgpYfgpK7gpYfgpLLgpLLgpJfgpL7gpLngpL7gpLLgpIrgpKrgpLDgpJrgpL7gpLDgpJDgpLjgpL7gpKbgpYfgpLDgpJzgpL/gpLjgpKbgpL/gpLLgpKzgpILgpKbgpKzgpKjgpL7gpLngpYLgpILgpLLgpL7gpJbgpJzgpYDgpKTgpKzgpJ/gpKjgpK7gpL/gpLLgpIfgpLjgpYfgpIbgpKjgpYfgpKjgpK/gpL7gpJXgpYHgpLLgpLLgpYngpJfgpK3gpL7gpJfgpLDgpYfgpLLgpJzgpJfgpLngpLDgpL7gpK7gpLLgpJfgpYfgpKrgpYfgpJzgpLngpL7gpKXgpIfgpLjgpYDgpLjgpLngpYDgpJXgpLLgpL7gpKDgpYDgpJXgpLngpL7gpIHgpKbgpYLgpLDgpKTgpLngpKTgpLjgpL7gpKTgpK/gpL7gpKbgpIbgpK/gpL7gpKrgpL7gpJXgpJXgpYzgpKjgpLbgpL7gpK7gpKbgpYfgpJbgpK/gpLngpYDgpLDgpL7gpK/gpJbgpYHgpKbgpLLgpJfgpYBjYXRlZ29yaWVzZXhwZXJpZW5jZTwvdGl0bGU+DQpDb3B5cmlnaHQgamF2YXNjcmlwdGNvbmRpdGlvbnNldmVyeXRoaW5nPHAgY2xhc3M9InRlY2hub2xvZ3liYWNrZ3JvdW5kPGEgY2xhc3M9Im1hbmFnZW1lbnQmY29weTsgMjAxamF2YVNjcmlwdGNoYXJhY3RlcnNicmVhZGNydW1idGhlbXNlbHZlc2hvcml6b250YWxnb3Zlcm5tZW50Q2FsaWZvcm5pYWFjdGl2aXRpZXNkaXNjb3ZlcmVkTmF2aWdhdGlvbnRyYW5zaXRpb25jb25uZWN0aW9ubmF2aWdhdGlvbmFwcGVhcmFuY2U8L3RpdGxlPjxtY2hlY2tib3giIHRlY2huaXF1ZXNwcm90ZWN0aW9uYXBwYXJlbnRseWFzIHdlbGwgYXN1bnQnLCAnVUEtcmVzb2x1dGlvbm9wZXJhdGlvbnN0ZWxldmlzaW9udHJhbnNsYXRlZFdhc2hpbmd0b25uYXZpZ2F0b3IuID0gd2luZG93LmltcHJlc3Npb24mbHQ7YnImZ3Q7bGl0ZXJhdHVyZXBvcHVsYXRpb25iZ2NvbG9yPSIjZXNwZWNpYWxseSBjb250ZW50PSJwcm9kdWN0aW9ubmV3c2xldHRlcnByb3BlcnRpZXNkZWZpbml0aW9ubGVhZGVyc2hpcFRlY2hub2xvZ3lQYXJsaWFtZW50Y29tcGFyaXNvbnVsIGNsYXNzPSIuaW5kZXhPZigiY29uY2x1c2lvbmRpc2N1c3Npb25jb21wb25lbnRzYmlvbG9naWNhbFJldm9sdXRpb25fY29udGFpbmVydW5kZXJzdG9vZG5vc2NyaXB0PjxwZXJtaXNzaW9uZWFjaCBvdGhlcmF0bW9zcGhlcmUgb25mb2N1cz0iPGZvcm0gaWQ9InByb2Nlc3Npbmd0aGlzLnZhbHVlZ2VuZXJhdGlvbkNvbmZlcmVuY2VzdWJzZXF1ZW50d2VsbC1rbm93bnZhcmlhdGlvbnNyZXB1dGF0aW9ucGhlbm9tZW5vbmRpc2NpcGxpbmVsb2dvLnBuZyIgKGRvY3VtZW50LGJvdW5kYXJpZXNleHByZXNzaW9uc2V0dGxlbWVudEJhY2tncm91bmRvdXQgb2YgdGhlZW50ZXJwcmlzZSgiaHR0cHM6IiB1bmVzY2FwZSgicGFzc3dvcmQiIGRlbW9jcmF0aWM8YSBocmVmPSIvd3JhcHBlciI+Cm1lbWJlcnNoaXBsaW5ndWlzdGljcHg7cGFkZGluZ3BoaWxvc29waHlhc3Npc3RhbmNldW5pdmVyc2l0eWZhY2lsaXRpZXNyZWNvZ25pemVkcHJlZmVyZW5jZWlmICh0eXBlb2ZtYWludGFpbmVkdm9jYWJ1bGFyeWh5cG90aGVzaXMuc3VibWl0KCk7JmFtcDtuYnNwO2Fubm90YXRpb25iZWhpbmQgdGhlRm91bmRhdGlvbnB1Ymxpc2hlciJhc3N1bXB0aW9uaW50cm9kdWNlZGNvcnJ1cHRpb25zY2llbnRpc3RzZXhwbGljaXRseWluc3RlYWQgb2ZkaW1lbnNpb25zIG9uQ2xpY2s9ImNvbnNpZGVyZWRkZXBhcnRtZW50b2NjdXBhdGlvbnNvb24gYWZ0ZXJpbnZlc3RtZW50cHJvbm91bmNlZGlkZW50aWZpZWRleHBlcmltZW50TWFuYWdlbWVudGdlb2dyYXBoaWMiIGhlaWdodD0ibGluayByZWw9Ii5yZXBsYWNlKC9kZXByZXNzaW9uY29uZmVyZW5jZXB1bmlzaG1lbnRlbGltaW5hdGVkcmVzaXN0YW5jZWFkYXB0YXRpb25vcHBvc2l0aW9ud2VsbCBrbm93bnN1cHBsZW1lbnRkZXRlcm1pbmVkaDEgY2xhc3M9IjBweDttYXJnaW5tZWNoYW5pY2Fsc3RhdGlzdGljc2NlbGVicmF0ZWRHb3Zlcm5tZW50CgpEdXJpbmcgdGRldmVsb3BlcnNhcnRpZmljaWFsZXF1aXZhbGVudG9yaWdpbmF0ZWRDb21taXNzaW9uYXR0YWNobWVudDxzcGFuIGlkPSJ0aGVyZSB3ZXJlTmVkZXJsYW5kc2JleW9uZCB0aGVyZWdpc3RlcmVkam91cm5hbGlzdGZyZXF1ZW50bHlhbGwgb2YgdGhlbGFuZz0iZW4iIDwvc3R5bGU+DQphYnNvbHV0ZTsgc3VwcG9ydGluZ2V4dHJlbWVseSBtYWluc3RyZWFtPC9zdHJvbmc+IHBvcHVsYXJpdHllbXBsb3ltZW50PC90YWJsZT4NCiBjb2xzcGFuPSI8L2Zvcm0+CiAgY29udmVyc2lvbmFib3V0IHRoZSA8L3A+PC9kaXY+aW50ZWdyYXRlZCIgbGFuZz0iZW5Qb3J0dWd1ZXNlc3Vic3RpdHV0ZWluZGl2aWR1YWxpbXBvc3NpYmxlbXVsdGltZWRpYWFsbW9zdCBhbGxweCBzb2xpZCAjYXBhcnQgZnJvbXN1YmplY3QgdG9pbiBFbmdsaXNoY3JpdGljaXplZGV4Y2VwdCBmb3JndWlkZWxpbmVzb3JpZ2luYWxseXJlbWFya2FibGV0aGUgc2Vjb25kaDIgY2xhc3M9IjxhIHRpdGxlPSIoaW5jbHVkaW5ncGFyYW1ldGVyc3Byb2hpYml0ZWQ9ICJodHRwOi8vZGljdGlvbmFyeXBlcmNlcHRpb25yZXZvbHV0aW9uZm91bmRhdGlvbnB4O2hlaWdodDpzdWNjZXNzZnVsc3VwcG9ydGVyc21pbGxlbm5pdW1oaXMgZmF0aGVydGhlICZxdW90O25vLXJlcGVhdDtjb21tZXJjaWFsaW5kdXN0cmlhbGVuY291cmFnZWRhbW91bnQgb2YgdW5vZmZpY2lhbGVmZmljaWVuY3lSZWZlcmVuY2VzY29vcmRpbmF0ZWRpc2NsYWltZXJleHBlZGl0aW9uZGV2ZWxvcGluZ2NhbGN1bGF0ZWRzaW1wbGlmaWVkbGVnaXRpbWF0ZXN1YnN0cmluZygwIiBjbGFzcz0iY29tcGxldGVseWlsbHVzdHJhdGVmaXZlIHllYXJzaW5zdHJ1bWVudFB1Ymxpc2hpbmcxIiBjbGFzcz0icHN5Y2hvbG9neWNvbmZpZGVuY2VudW1iZXIgb2YgYWJzZW5jZSBvZmZvY3VzZWQgb25qb2luZWQgdGhlc3RydWN0dXJlc3ByZXZpb3VzbHk+PC9pZnJhbWU+b25jZSBhZ2FpbmJ1dCByYXRoZXJpbW1pZ3JhbnRzb2YgY291cnNlLGEgZ3JvdXAgb2ZMaXRlcmF0dXJlVW5saWtlIHRoZTwvYT4mbmJzcDsKZnVuY3Rpb24gaXQgd2FzIHRoZUNvbnZlbnRpb25hdXRvbW9iaWxlUHJvdGVzdGFudGFnZ3Jlc3NpdmVhZnRlciB0aGUgU2ltaWxhcmx5LCIgLz48L2Rpdj5jb2xsZWN0aW9uDQpmdW5jdGlvbnZpc2liaWxpdHl0aGUgdXNlIG9mdm9sdW50ZWVyc2F0dHJhY3Rpb251bmRlciB0aGUgdGhyZWF0ZW5lZCo8IVtDREFUQVtpbXBvcnRhbmNlaW4gZ2VuZXJhbHRoZSBsYXR0ZXI8L2Zvcm0+CjwvLmluZGV4T2YoJ2kgPSAwOyBpIDxkaWZmZXJlbmNlZGV2b3RlZCB0b3RyYWRpdGlvbnNzZWFyY2ggZm9ydWx0aW1hdGVseXRvdXJuYW1lbnRhdHRyaWJ1dGVzc28tY2FsbGVkIH0KPC9zdHlsZT5ldmFsdWF0aW9uZW1waGFzaXplZGFjY2Vzc2libGU8L3NlY3Rpb24+c3VjY2Vzc2lvbmFsb25nIHdpdGhNZWFud2hpbGUsaW5kdXN0cmllczwvYT48YnIgLz5oYXMgYmVjb21lYXNwZWN0cyBvZlRlbGV2aXNpb25zdWZmaWNpZW50YmFza2V0YmFsbGJvdGggc2lkZXNjb250aW51aW5nYW4gYXJ0aWNsZTxpbWcgYWx0PSJhZHZlbnR1cmVzaGlzIG1vdGhlcm1hbmNoZXN0ZXJwcmluY2lwbGVzcGFydGljdWxhcmNvbW1lbnRhcnllZmZlY3RzIG9mZGVjaWRlZCB0byI+PHN0cm9uZz5wdWJsaXNoZXJzSm91cm5hbCBvZmRpZmZpY3VsdHlmYWNpbGl0YXRlYWNjZXB0YWJsZXN0eWxlLmNzcyIJZnVuY3Rpb24gaW5ub3ZhdGlvbj5Db3B5cmlnaHRzaXR1YXRpb25zd291bGQgaGF2ZWJ1c2luZXNzZXNEaWN0aW9uYXJ5c3RhdGVtZW50c29mdGVuIHVzZWRwZXJzaXN0ZW50aW4gSmFudWFyeWNvbXByaXNpbmc8L3RpdGxlPgoJZGlwbG9tYXRpY2NvbnRhaW5pbmdwZXJmb3JtaW5nZXh0ZW5zaW9uc21heSBub3QgYmVjb25jZXB0IG9mIG9uY2xpY2s9Ikl0IGlzIGFsc29maW5hbmNpYWwgbWFraW5nIHRoZUx1eGVtYm91cmdhZGRpdGlvbmFsYXJlIGNhbGxlZGVuZ2FnZWQgaW4ic2NyaXB0Iik7YnV0IGl0IHdhc2VsZWN0cm9uaWNvbnN1Ym1pdD0iCjwhLS0gRW5kIGVsZWN0cmljYWxvZmZpY2lhbGx5c3VnZ2VzdGlvbnRvcCBvZiB0aGV1bmxpa2UgdGhlQXVzdHJhbGlhbk9yaWdpbmFsbHlyZWZlcmVuY2VzCjwvaGVhZD4NCnJlY29nbmlzZWRpbml0aWFsaXplbGltaXRlZCB0b0FsZXhhbmRyaWFyZXRpcmVtZW50QWR2ZW50dXJlc2ZvdXIgeWVhcnMKCiZsdDshLS0gaW5jcmVhc2luZ2RlY29yYXRpb25oMyBjbGFzcz0ib3JpZ2lucyBvZm9ibGlnYXRpb25yZWd1bGF0aW9uY2xhc3NpZmllZChmdW5jdGlvbihhZHZhbnRhZ2VzYmVpbmcgdGhlIGhpc3RvcmlhbnM8YmFzZSBocmVmcmVwZWF0ZWRseXdpbGxpbmcgdG9jb21wYXJhYmxlZGVzaWduYXRlZG5vbWluYXRpb25mdW5jdGlvbmFsaW5zaWRlIHRoZXJldmVsYXRpb25lbmQgb2YgdGhlcyBmb3IgdGhlIGF1dGhvcml6ZWRyZWZ1c2VkIHRvdGFrZSBwbGFjZWF1dG9ub21vdXNjb21wcm9taXNlcG9saXRpY2FsIHJlc3RhdXJhbnR0d28gb2YgdGhlRmVicnVhcnkgMnF1YWxpdHkgb2Zzd2ZvYmplY3QudW5kZXJzdGFuZG5lYXJseSBhbGx3cml0dGVuIGJ5aW50ZXJ2aWV3cyIgd2lkdGg9IjF3aXRoZHJhd2FsZmxvYXQ6bGVmdGlzIHVzdWFsbHljYW5kaWRhdGVzbmV3c3BhcGVyc215c3RlcmlvdXNEZXBhcnRtZW50YmVzdCBrbm93bnBhcmxpYW1lbnRzdXBwcmVzc2VkY29udmVuaWVudHJlbWVtYmVyZWRkaWZmZXJlbnQgc3lzdGVtYXRpY2hhcyBsZWQgdG9wcm9wYWdhbmRhY29udHJvbGxlZGluZmx1ZW5jZXNjZXJlbW9uaWFscHJvY2xhaW1lZFByb3RlY3Rpb25saSBjbGFzcz0iU2NpZW50aWZpY2NsYXNzPSJuby10cmFkZW1hcmtzbW9yZSB0aGFuIHdpZGVzcHJlYWRMaWJlcmF0aW9udG9vayBwbGFjZWRheSBvZiB0aGVhcyBsb25nIGFzaW1wcmlzb25lZEFkZGl0aW9uYWwKPGhlYWQ+CjxtTGFib3JhdG9yeU5vdmVtYmVyIDJleGNlcHRpb25zSW5kdXN0cmlhbHZhcmlldHkgb2ZmbG9hdDogbGVmRHVyaW5nIHRoZWFzc2Vzc21lbnRoYXZlIGJlZW4gZGVhbHMgd2l0aFN0YXRpc3RpY3NvY2N1cnJlbmNlL3VsPjwvZGl2PmNsZWFyZml4Ij50aGUgcHVibGljbWFueSB5ZWFyc3doaWNoIHdlcmVvdmVyIHRpbWUsc3lub255bW91c2NvbnRlbnQiPgpwcmVzdW1hYmx5aGlzIGZhbWlseXVzZXJBZ2VudC51bmV4cGVjdGVkaW5jbHVkaW5nIGNoYWxsZW5nZWRhIG1pbm9yaXR5dW5kZWZpbmVkImJlbG9uZ3MgdG90YWtlbiBmcm9taW4gT2N0b2JlcnBvc2l0aW9uOiBzYWlkIHRvIGJlcmVsaWdpb3VzIEZlZGVyYXRpb24gcm93c3Bhbj0ib25seSBhIGZld21lYW50IHRoYXRsZWQgdG8gdGhlLS0+DQo8ZGl2IDxmaWVsZHNldD5BcmNoYmlzaG9wIGNsYXNzPSJub2JlaW5nIHVzZWRhcHByb2FjaGVzcHJpdmlsZWdlc25vc2NyaXB0PgpyZXN1bHRzIGlubWF5IGJlIHRoZUVhc3RlciBlZ2dtZWNoYW5pc21zcmVhc29uYWJsZVBvcHVsYXRpb25Db2xsZWN0aW9uc2VsZWN0ZWQiPm5vc2NyaXB0Pg0vaW5kZXgucGhwYXJyaXZhbCBvZi1qc3NkaycpKTttYW5hZ2VkIHRvaW5jb21wbGV0ZWNhc3VhbHRpZXNjb21wbGV0aW9uQ2hyaXN0aWFuc1NlcHRlbWJlciBhcml0aG1ldGljcHJvY2VkdXJlc21pZ2h0IGhhdmVQcm9kdWN0aW9uaXQgYXBwZWFyc1BoaWxvc29waHlmcmllbmRzaGlwbGVhZGluZyB0b2dpdmluZyB0aGV0b3dhcmQgdGhlZ3VhcmFudGVlZGRvY3VtZW50ZWRjb2xvcjojMDAwdmlkZW8gZ2FtZWNvbW1pc3Npb25yZWZsZWN0aW5nY2hhbmdlIHRoZWFzc29jaWF0ZWRzYW5zLXNlcmlmb25rZXlwcmVzczsgcGFkZGluZzpIZSB3YXMgdGhldW5kZXJseWluZ3R5cGljYWxseSAsIGFuZCB0aGUgc3JjRWxlbWVudHN1Y2Nlc3NpdmVzaW5jZSB0aGUgc2hvdWxkIGJlIG5ldHdvcmtpbmdhY2NvdW50aW5ndXNlIG9mIHRoZWxvd2VyIHRoYW5zaG93cyB0aGF0PC9zcGFuPgoJCWNvbXBsYWludHNjb250aW51b3VzcXVhbnRpdGllc2FzdHJvbm9tZXJoZSBkaWQgbm90ZHVlIHRvIGl0c2FwcGxpZWQgdG9hbiBhdmVyYWdlZWZmb3J0cyB0b3RoZSBmdXR1cmVhdHRlbXB0IHRvVGhlcmVmb3JlLGNhcGFiaWxpdHlSZXB1YmxpY2Fud2FzIGZvcm1lZEVsZWN0cm9uaWNraWxvbWV0ZXJzY2hhbGxlbmdlc3B1Ymxpc2hpbmd0aGUgZm9ybWVyaW5kaWdlbm91c2RpcmVjdGlvbnNzdWJzaWRpYXJ5Y29uc3BpcmFjeWRldGFpbHMgb2ZhbmQgaW4gdGhlYWZmb3JkYWJsZXN1YnN0YW5jZXNyZWFzb24gZm9yY29udmVudGlvbml0ZW10eXBlPSJhYnNvbHV0ZWx5c3VwcG9zZWRseXJlbWFpbmVkIGFhdHRyYWN0aXZldHJhdmVsbGluZ3NlcGFyYXRlbHlmb2N1c2VzIG9uZWxlbWVudGFyeWFwcGxpY2FibGVmb3VuZCB0aGF0c3R5bGVzaGVldG1hbnVzY3JpcHRzdGFuZHMgZm9yIG5vLXJlcGVhdChzb21ldGltZXNDb21tZXJjaWFsaW4gQW1lcmljYXVuZGVydGFrZW5xdWFydGVyIG9mYW4gZXhhbXBsZXBlcnNvbmFsbHlpbmRleC5waHA/PC9idXR0b24+CnBlcmNlbnRhZ2ViZXN0LWtub3duY3JlYXRpbmcgYSIgZGlyPSJsdHJMaWV1dGVuYW50CjxkaXYgaWQ9InRoZXkgd291bGRhYmlsaXR5IG9mbWFkZSB1cCBvZm5vdGVkIHRoYXRjbGVhciB0aGF0YXJndWUgdGhhdHRvIGFub3RoZXJjaGlsZHJlbidzcHVycG9zZSBvZmZvcm11bGF0ZWRiYXNlZCB1cG9udGhlIHJlZ2lvbnN1YmplY3Qgb2ZwYXNzZW5nZXJzcG9zc2Vzc2lvbi4KCkluIHRoZSBCZWZvcmUgdGhlYWZ0ZXJ3YXJkc2N1cnJlbnRseSBhY3Jvc3MgdGhlc2NpZW50aWZpY2NvbW11bml0eS5jYXBpdGFsaXNtaW4gR2VybWFueXJpZ2h0LXdpbmd0aGUgc3lzdGVtU29jaWV0eSBvZnBvbGl0aWNpYW5kaXJlY3Rpb246d2VudCBvbiB0b3JlbW92YWwgb2YgTmV3IFlvcmsgYXBhcnRtZW50c2luZGljYXRpb25kdXJpbmcgdGhldW5sZXNzIHRoZWhpc3RvcmljYWxoYWQgYmVlbiBhZGVmaW5pdGl2ZWluZ3JlZGllbnRhdHRlbmRhbmNlQ2VudGVyIGZvcnByb21pbmVuY2VyZWFkeVN0YXRlc3RyYXRlZ2llc2J1dCBpbiB0aGVhcyBwYXJ0IG9mY29uc3RpdHV0ZWNsYWltIHRoYXRsYWJvcmF0b3J5Y29tcGF0aWJsZWZhaWx1cmUgb2YsIHN1Y2ggYXMgYmVnYW4gd2l0aHVzaW5nIHRoZSB0byBwcm92aWRlZmVhdHVyZSBvZmZyb20gd2hpY2gvIiBjbGFzcz0iZ2VvbG9naWNhbHNldmVyYWwgb2ZkZWxpYmVyYXRlaW1wb3J0YW50IGhvbGRzIHRoYXRpbmcmcXVvdDsgdmFsaWduPXRvcHRoZSBHZXJtYW5vdXRzaWRlIG9mbmVnb3RpYXRlZGhpcyBjYXJlZXJzZXBhcmF0aW9uaWQ9InNlYXJjaHdhcyBjYWxsZWR0aGUgZm91cnRocmVjcmVhdGlvbm90aGVyIHRoYW5wcmV2ZW50aW9ud2hpbGUgdGhlIGVkdWNhdGlvbixjb25uZWN0aW5nYWNjdXJhdGVseXdlcmUgYnVpbHR3YXMga2lsbGVkYWdyZWVtZW50c211Y2ggbW9yZSBEdWUgdG8gdGhld2lkdGg6IDEwMHNvbWUgb3RoZXJLaW5nZG9tIG9mdGhlIGVudGlyZWZhbW91cyBmb3J0byBjb25uZWN0b2JqZWN0aXZlc3RoZSBGcmVuY2hwZW9wbGUgYW5kZmVhdHVyZWQiPmlzIHNhaWQgdG9zdHJ1Y3R1cmFscmVmZXJlbmR1bW1vc3Qgb2Z0ZW5hIHNlcGFyYXRlLT4KPGRpdiBpZCBPZmZpY2lhbCB3b3JsZHdpZGUuYXJpYS1sYWJlbHRoZSBwbGFuZXRhbmQgaXQgd2FzZCIgdmFsdWU9Imxvb2tpbmcgYXRiZW5lZmljaWFsYXJlIGluIHRoZW1vbml0b3JpbmdyZXBvcnRlZGx5dGhlIG1vZGVybndvcmtpbmcgb25hbGxvd2VkIHRvd2hlcmUgdGhlIGlubm92YXRpdmU8L2E+PC9kaXY+c291bmR0cmFja3NlYXJjaEZvcm10ZW5kIHRvIGJlaW5wdXQgaWQ9Im9wZW5pbmcgb2ZyZXN0cmljdGVkYWRvcHRlZCBieWFkZHJlc3Npbmd0aGVvbG9naWFubWV0aG9kcyBvZnZhcmlhbnQgb2ZDaHJpc3RpYW4gdmVyeSBsYXJnZWF1dG9tb3RpdmVieSBmYXIgdGhlcmFuZ2UgZnJvbXB1cnN1aXQgb2Zmb2xsb3cgdGhlYnJvdWdodCB0b2luIEVuZ2xhbmRhZ3JlZSB0aGF0YWNjdXNlZCBvZmNvbWVzIGZyb21wcmV2ZW50aW5nZGl2IHN0eWxlPWhpcyBvciBoZXJ0cmVtZW5kb3VzZnJlZWRvbSBvZmNvbmNlcm5pbmcwIDFlbSAxZW07QmFza2V0YmFsbC9zdHlsZS5jc3NhbiBlYXJsaWVyZXZlbiBhZnRlci8iIHRpdGxlPSIuY29tL2luZGV4dGFraW5nIHRoZXBpdHRzYnVyZ2hjb250ZW50Ij4NPHNjcmlwdD4oZnR1cm5lZCBvdXRoYXZpbmcgdGhlPC9zcGFuPg0KIG9jY2FzaW9uYWxiZWNhdXNlIGl0c3RhcnRlZCB0b3BoeXNpY2FsbHk+PC9kaXY+CiAgY3JlYXRlZCBieUN1cnJlbnRseSwgYmdjb2xvcj0idGFiaW5kZXg9ImRpc2FzdHJvdXNBbmFseXRpY3MgYWxzbyBoYXMgYT48ZGl2IGlkPSI8L3N0eWxlPgo8Y2FsbGVkIGZvcnNpbmdlciBhbmQuc3JjID0gIi8vdmlvbGF0aW9uc3RoaXMgcG9pbnRjb25zdGFudGx5aXMgbG9jYXRlZHJlY29yZGluZ3NkIGZyb20gdGhlbmVkZXJsYW5kc3BvcnR1Z3XDqnPXoteR16jXmdeq2YHYp9ix2LPbjGRlc2Fycm9sbG9jb21lbnRhcmlvZWR1Y2FjacOzbnNlcHRpZW1icmVyZWdpc3RyYWRvZGlyZWNjacOzbnViaWNhY2nDs25wdWJsaWNpZGFkcmVzcHVlc3Rhc3Jlc3VsdGFkb3NpbXBvcnRhbnRlcmVzZXJ2YWRvc2FydMOtY3Vsb3NkaWZlcmVudGVzc2lndWllbnRlc3JlcMO6YmxpY2FzaXR1YWNpw7NubWluaXN0ZXJpb3ByaXZhY2lkYWRkaXJlY3RvcmlvZm9ybWFjacOzbnBvYmxhY2nDs25wcmVzaWRlbnRlY29udGVuaWRvc2FjY2Vzb3Jpb3N0ZWNobm9yYXRpcGVyc29uYWxlc2NhdGVnb3LDrWFlc3BlY2lhbGVzZGlzcG9uaWJsZWFjdHVhbGlkYWRyZWZlcmVuY2lhdmFsbGFkb2xpZGJpYmxpb3RlY2FyZWxhY2lvbmVzY2FsZW5kYXJpb3BvbMOtdGljYXNhbnRlcmlvcmVzZG9jdW1lbnRvc25hdHVyYWxlemFtYXRlcmlhbGVzZGlmZXJlbmNpYWVjb27Ds21pY2F0cmFuc3BvcnRlcm9kcsOtZ3VlenBhcnRpY2lwYXJlbmN1ZW50cmFuZGlzY3VzacOzbmVzdHJ1Y3R1cmFmdW5kYWNpw7NuZnJlY3VlbnRlc3Blcm1hbmVudGV0b3RhbG1lbnRl0LzQvtC20L3QvtCx0YPQtNC10YLQvNC+0LbQtdGC0LLRgNC10LzRj9GC0LDQutC20LXRh9GC0L7QsdGL0LHQvtC70LXQtdC+0YfQtdC90YzRjdGC0L7Qs9C+0LrQvtCz0LTQsNC/0L7RgdC70LXQstGB0LXQs9C+0YHQsNC50YLQtdGH0LXRgNC10LfQvNC+0LPRg9GC0YHQsNC50YLQsNC20LjQt9C90LjQvNC10LbQtNGD0LHRg9C00YPRgtCf0L7QuNGB0LrQt9C00LXRgdGM0LLQuNC00LXQvtGB0LLRj9C30LjQvdGD0LbQvdC+0YHQstC+0LXQudC70Y7QtNC10LnQv9C+0YDQvdC+0LzQvdC+0LPQvtC00LXRgtC10LnRgdCy0L7QuNGF0L/RgNCw0LLQsNGC0LDQutC+0LnQvNC10YHRgtC+0LjQvNC10LXRgtC20LjQt9C90YzQvtC00L3QvtC50LvRg9GH0YjQtdC/0LXRgNC10LTRh9Cw0YHRgtC40YfQsNGB0YLRjNGA0LDQsdC+0YLQvdC+0LLRi9GF0L/RgNCw0LLQvtGB0L7QsdC+0LnQv9C+0YLQvtC80LzQtdC90LXQtdGH0LjRgdC70LXQvdC+0LLRi9C10YPRgdC70YPQs9C+0LrQvtC70L7QvdCw0LfQsNC00YLQsNC60L7QtdGC0L7Qs9C00LDQv9C+0YfRgtC40J/QvtGB0LvQtdGC0LDQutC40LXQvdC+0LLRi9C50YHRgtC+0LjRgtGC0LDQutC40YXRgdGA0LDQt9GD0KHQsNC90LrRgtGE0L7RgNGD0LzQmtC+0LPQtNCw0LrQvdC40LPQuNGB0LvQvtCy0LDQvdCw0YjQtdC50L3QsNC50YLQuNGB0LLQvtC40LzRgdCy0Y/Qt9GM0LvRjtCx0L7QudGH0LDRgdGC0L7RgdGA0LXQtNC40JrRgNC+0LzQtdCk0L7RgNGD0LzRgNGL0L3QutC10YHRgtCw0LvQuNC/0L7QuNGB0LrRgtGL0YHRj9GH0LzQtdGB0Y/RhtGG0LXQvdGC0YDRgtGA0YPQtNCw0YHQsNC80YvRhdGA0YvQvdC60LDQndC+0LLRi9C50YfQsNGB0L7QstC80LXRgdGC0LDRhNC40LvRjNC80LzQsNGA0YLQsNGB0YLRgNCw0L3QvNC10YHRgtC10YLQtdC60YHRgtC90LDRiNC40YXQvNC40L3Rg9GC0LjQvNC10L3QuNC40LzQtdGO0YLQvdC+0LzQtdGA0LPQvtGA0L7QtNGB0LDQvNC+0LzRjdGC0L7QvNGD0LrQvtC90YbQtdGB0LLQvtC10LzQutCw0LrQvtC50JDRgNGF0LjQstmF2YbYqtiv2YnYpdix2LPYp9mE2LHYs9in2YTYqdin2YTYudin2YXZg9iq2KjZh9in2KjYsdin2YXYrNin2YTZitmI2YXYp9mE2LXZiNix2KzYr9mK2K/Yqdin2YTYudi22YjYpdi22KfZgdip2KfZhNmC2LPZhdin2YTYudin2KjYqtit2YXZitmE2YXZhNmB2KfYqtmF2YTYqtmC2YnYqti52K/ZitmE2KfZhNi02LnYsdij2K7YqNin2LHYqti32YjZitix2LnZhNmK2YPZhdil2LHZgdin2YLYt9mE2KjYp9iq2KfZhNmE2LrYqdiq2LHYqtmK2KjYp9mE2YbYp9iz2KfZhNi02YrYrtmF2YbYqtiv2YrYp9mE2LnYsdio2KfZhNmC2LXYtdin2YHZhNin2YXYudmE2YrZh9in2KrYrdiv2YrYq9in2YTZhNmH2YXYp9mE2LnZhdmE2YXZg9iq2KjYqdmK2YXZg9mG2YPYp9mE2LfZgdmE2YHZitiv2YrZiNil2K/Yp9ix2KnYqtin2LHZitiu2KfZhNi12K3Yqdiq2LPYrNmK2YTYp9mE2YjZgtiq2LnZhtiv2YXYp9mF2K/ZitmG2KnYqti12YXZitmF2KPYsdi02YrZgdin2YTYsNmK2YbYudix2KjZitip2KjZiNin2KjYqdij2YTYudin2KjYp9mE2LPZgdix2YXYtNin2YPZhNiq2LnYp9mE2YnYp9mE2KPZiNmE2KfZhNiz2YbYqdis2KfZhdi52KnYp9mE2LXYrdmB2KfZhNiv2YrZhtmD2YTZhdin2KrYp9mE2K7Yp9i12KfZhNmF2YTZgdij2LnYttin2KHZg9iq2KfYqNip2KfZhNiu2YrYsdix2LPYp9im2YTYp9mE2YLZhNio2KfZhNij2K/YqNmF2YLYp9i32LnZhdix2KfYs9mE2YXZhti32YLYqdin2YTZg9iq2KjYp9mE2LHYrNmE2KfYtNiq2LHZg9in2YTZgtiv2YXZiti52LfZitmDc0J5VGFnTmFtZSguanBnIiBhbHQ9IjFweCBzb2xpZCAjLmdpZiIgYWx0PSJ0cmFuc3BhcmVudGluZm9ybWF0aW9uYXBwbGljYXRpb24iIG9uY2xpY2s9ImVzdGFibGlzaGVkYWR2ZXJ0aXNpbmcucG5nIiBhbHQ9ImVudmlyb25tZW50cGVyZm9ybWFuY2VhcHByb3ByaWF0ZSZhbXA7bWRhc2g7aW1tZWRpYXRlbHk8L3N0cm9uZz48L3JhdGhlciB0aGFudGVtcGVyYXR1cmVkZXZlbG9wbWVudGNvbXBldGl0aW9ucGxhY2Vob2xkZXJ2aXNpYmlsaXR5OmNvcHlyaWdodCI+MCIgaGVpZ2h0PSJldmVuIHRob3VnaHJlcGxhY2VtZW50ZGVzdGluYXRpb25Db3Jwb3JhdGlvbjx1bCBjbGFzcz0iQXNzb2NpYXRpb25pbmRpdmlkdWFsc3BlcnNwZWN0aXZlc2V0VGltZW91dCh1cmwoaHR0cDovL21hdGhlbWF0aWNzbWFyZ2luLXRvcDpldmVudHVhbGx5IGRlc2NyaXB0aW9uKSBuby1yZXBlYXRjb2xsZWN0aW9ucy5KUEd8dGh1bWJ8cGFydGljaXBhdGUvaGVhZD48Ym9keWZsb2F0OmxlZnQ7PGxpIGNsYXNzPSJodW5kcmVkcyBvZgoKSG93ZXZlciwgY29tcG9zaXRpb25jbGVhcjpib3RoO2Nvb3BlcmF0aW9ud2l0aGluIHRoZSBsYWJlbCBmb3I9ImJvcmRlci10b3A6TmV3IFplYWxhbmRyZWNvbW1lbmRlZHBob3RvZ3JhcGh5aW50ZXJlc3RpbmcmbHQ7c3VwJmd0O2NvbnRyb3ZlcnN5TmV0aGVybGFuZHNhbHRlcm5hdGl2ZW1heGxlbmd0aD0ic3dpdHplcmxhbmREZXZlbG9wbWVudGVzc2VudGlhbGx5CgpBbHRob3VnaCA8L3RleHRhcmVhPnRodW5kZXJiaXJkcmVwcmVzZW50ZWQmYW1wO25kYXNoO3NwZWN1bGF0aW9uY29tbXVuaXRpZXNsZWdpc2xhdGlvbmVsZWN0cm9uaWNzCgk8ZGl2IGlkPSJpbGx1c3RyYXRlZGVuZ2luZWVyaW5ndGVycml0b3JpZXNhdXRob3JpdGllc2Rpc3RyaWJ1dGVkNiIgaGVpZ2h0PSJzYW5zLXNlcmlmO2NhcGFibGUgb2YgZGlzYXBwZWFyZWRpbnRlcmFjdGl2ZWxvb2tpbmcgZm9yaXQgd291bGQgYmVBZmdoYW5pc3RhbndhcyBjcmVhdGVkTWF0aC5mbG9vcihzdXJyb3VuZGluZ2NhbiBhbHNvIGJlb2JzZXJ2YXRpb25tYWludGVuYW5jZWVuY291bnRlcmVkPGgyIGNsYXNzPSJtb3JlIHJlY2VudGl0IGhhcyBiZWVuaW52YXNpb24gb2YpLmdldFRpbWUoKWZ1bmRhbWVudGFsRGVzcGl0ZSB0aGUiPjxkaXYgaWQ9Imluc3BpcmF0aW9uZXhhbWluYXRpb25wcmVwYXJhdGlvbmV4cGxhbmF0aW9uPGlucHV0IGlkPSI8L2E+PC9zcGFuPnZlcnNpb25zIG9maW5zdHJ1bWVudHNiZWZvcmUgdGhlICA9ICdodHRwOi8vRGVzY3JpcHRpb25yZWxhdGl2ZWx5IC5zdWJzdHJpbmcoZWFjaCBvZiB0aGVleHBlcmltZW50c2luZmx1ZW50aWFsaW50ZWdyYXRpb25tYW55IHBlb3BsZWR1ZSB0byB0aGUgY29tYmluYXRpb25kbyBub3QgaGF2ZU1pZGRsZSBFYXN0PG5vc2NyaXB0Pjxjb3B5cmlnaHQiIHBlcmhhcHMgdGhlaW5zdGl0dXRpb25pbiBEZWNlbWJlcmFycmFuZ2VtZW50bW9zdCBmYW1vdXNwZXJzb25hbGl0eWNyZWF0aW9uIG9mbGltaXRhdGlvbnNleGNsdXNpdmVseXNvdmVyZWlnbnR5LWNvbnRlbnQiPgo8dGQgY2xhc3M9InVuZGVyZ3JvdW5kcGFyYWxsZWwgdG9kb2N0cmluZSBvZm9jY3VwaWVkIGJ5dGVybWlub2xvZ3lSZW5haXNzYW5jZWEgbnVtYmVyIG9mc3VwcG9ydCBmb3JleHBsb3JhdGlvbnJlY29nbml0aW9ucHJlZGVjZXNzb3I8aW1nIHNyYz0iLzxoMSBjbGFzcz0icHVibGljYXRpb25tYXkgYWxzbyBiZXNwZWNpYWxpemVkPC9maWVsZHNldD5wcm9ncmVzc2l2ZW1pbGxpb25zIG9mc3RhdGVzIHRoYXRlbmZvcmNlbWVudGFyb3VuZCB0aGUgb25lIGFub3RoZXIucGFyZW50Tm9kZWFncmljdWx0dXJlQWx0ZXJuYXRpdmVyZXNlYXJjaGVyc3Rvd2FyZHMgdGhlTW9zdCBvZiB0aGVtYW55IG90aGVyIChlc3BlY2lhbGx5PHRkIHdpZHRoPSI7d2lkdGg6MTAwJWluZGVwZW5kZW50PGgzIGNsYXNzPSIgb25jaGFuZ2U9IikuYWRkQ2xhc3MoaW50ZXJhY3Rpb25PbmUgb2YgdGhlIGRhdWdodGVyIG9mYWNjZXNzb3JpZXNicmFuY2hlcyBvZg0KPGRpdiBpZD0idGhlIGxhcmdlc3RkZWNsYXJhdGlvbnJlZ3VsYXRpb25zSW5mb3JtYXRpb250cmFuc2xhdGlvbmRvY3VtZW50YXJ5aW4gb3JkZXIgdG8iPgo8aGVhZD4KPCIgaGVpZ2h0PSIxYWNyb3NzIHRoZSBvcmllbnRhdGlvbik7PC9zY3JpcHQ+aW1wbGVtZW50ZWRjYW4gYmUgc2VlbnRoZXJlIHdhcyBhZGVtb25zdHJhdGVjb250YWluZXIiPmNvbm5lY3Rpb25zdGhlIEJyaXRpc2h3YXMgd3JpdHRlbiFpbXBvcnRhbnQ7cHg7IG1hcmdpbi1mb2xsb3dlZCBieWFiaWxpdHkgdG8gY29tcGxpY2F0ZWRkdXJpbmcgdGhlIGltbWlncmF0aW9uYWxzbyBjYWxsZWQ8aDQgY2xhc3M9ImRpc3RpbmN0aW9ucmVwbGFjZWQgYnlnb3Zlcm5tZW50c2xvY2F0aW9uIG9maW4gTm92ZW1iZXJ3aGV0aGVyIHRoZTwvcD4KPC9kaXY+YWNxdWlzaXRpb25jYWxsZWQgdGhlIHBlcnNlY3V0aW9uZGVzaWduYXRpb257Zm9udC1zaXplOmFwcGVhcmVkIGluaW52ZXN0aWdhdGVleHBlcmllbmNlZG1vc3QgbGlrZWx5d2lkZWx5IHVzZWRkaXNjdXNzaW9uc3ByZXNlbmNlIG9mIChkb2N1bWVudC5leHRlbnNpdmVseUl0IGhhcyBiZWVuaXQgZG9lcyBub3Rjb250cmFyeSB0b2luaGFiaXRhbnRzaW1wcm92ZW1lbnRzY2hvbGFyc2hpcGNvbnN1bXB0aW9uaW5zdHJ1Y3Rpb25mb3IgZXhhbXBsZW9uZSBvciBtb3JlcHg7IHBhZGRpbmd0aGUgY3VycmVudGEgc2VyaWVzIG9mYXJlIHVzdWFsbHlyb2xlIGluIHRoZXByZXZpb3VzbHkgZGVyaXZhdGl2ZXNldmlkZW5jZSBvZmV4cGVyaWVuY2VzY29sb3JzY2hlbWVzdGF0ZWQgdGhhdGNlcnRpZmljYXRlPC9hPjwvZGl2Pgogc2VsZWN0ZWQ9ImhpZ2ggc2Nob29scmVzcG9uc2UgdG9jb21mb3J0YWJsZWFkb3B0aW9uIG9mdGhyZWUgeWVhcnN0aGUgY291bnRyeWluIEZlYnJ1YXJ5c28gdGhhdCB0aGVwZW9wbGUgd2hvIHByb3ZpZGVkIGJ5PHBhcmFtIG5hbWVhZmZlY3RlZCBieWluIHRlcm1zIG9mYXBwb2ludG1lbnRJU08tODg1OS0xIndhcyBib3JuIGluaGlzdG9yaWNhbCByZWdhcmRlZCBhc21lYXN1cmVtZW50aXMgYmFzZWQgb24gYW5kIG90aGVyIDogZnVuY3Rpb24oc2lnbmlmaWNhbnRjZWxlYnJhdGlvbnRyYW5zbWl0dGVkL2pzL2pxdWVyeS5pcyBrbm93biBhc3RoZW9yZXRpY2FsIHRhYmluZGV4PSJpdCBjb3VsZCBiZTxub3NjcmlwdD4KaGF2aW5nIGJlZW4NCjxoZWFkPg0KPCAmcXVvdDtUaGUgY29tcGlsYXRpb25oZSBoYWQgYmVlbnByb2R1Y2VkIGJ5cGhpbG9zb3BoZXJjb25zdHJ1Y3RlZGludGVuZGVkIHRvYW1vbmcgb3RoZXJjb21wYXJlZCB0b3RvIHNheSB0aGF0RW5naW5lZXJpbmdhIGRpZmZlcmVudHJlZmVycmVkIHRvZGlmZmVyZW5jZXNiZWxpZWYgdGhhdHBob3RvZ3JhcGhzaWRlbnRpZnlpbmdIaXN0b3J5IG9mIFJlcHVibGljIG9mbmVjZXNzYXJpbHlwcm9iYWJpbGl0eXRlY2huaWNhbGx5bGVhdmluZyB0aGVzcGVjdGFjdWxhcmZyYWN0aW9uIG9mZWxlY3RyaWNpdHloZWFkIG9mIHRoZXJlc3RhdXJhbnRzcGFydG5lcnNoaXBlbXBoYXNpcyBvbm1vc3QgcmVjZW50c2hhcmUgd2l0aCBzYXlpbmcgdGhhdGZpbGxlZCB3aXRoZGVzaWduZWQgdG9pdCBpcyBvZnRlbiI+PC9pZnJhbWU+YXMgZm9sbG93czptZXJnZWQgd2l0aHRocm91Z2ggdGhlY29tbWVyY2lhbCBwb2ludGVkIG91dG9wcG9ydHVuaXR5dmlldyBvZiB0aGVyZXF1aXJlbWVudGRpdmlzaW9uIG9mcHJvZ3JhbW1pbmdoZSByZWNlaXZlZHNldEludGVydmFsIj48L3NwYW4+PC9pbiBOZXcgWW9ya2FkZGl0aW9uYWwgY29tcHJlc3Npb24KCjxkaXYgaWQ9ImluY29ycG9yYXRlOzwvc2NyaXB0PjxhdHRhY2hFdmVudGJlY2FtZSB0aGUgIiB0YXJnZXQ9Il9jYXJyaWVkIG91dFNvbWUgb2YgdGhlc2NpZW5jZSBhbmR0aGUgdGltZSBvZkNvbnRhaW5lciI+bWFpbnRhaW5pbmdDaHJpc3RvcGhlck11Y2ggb2YgdGhld3JpdGluZ3Mgb2YiIGhlaWdodD0iMnNpemUgb2YgdGhldmVyc2lvbiBvZiBtaXh0dXJlIG9mIGJldHdlZW4gdGhlRXhhbXBsZXMgb2ZlZHVjYXRpb25hbGNvbXBldGl0aXZlIG9uc3VibWl0PSJkaXJlY3RvciBvZmRpc3RpbmN0aXZlL0RURCBYSFRNTCByZWxhdGluZyB0b3RlbmRlbmN5IHRvcHJvdmluY2Ugb2Z3aGljaCB3b3VsZGRlc3BpdGUgdGhlc2NpZW50aWZpYyBsZWdpc2xhdHVyZS5pbm5lckhUTUwgYWxsZWdhdGlvbnNBZ3JpY3VsdHVyZXdhcyB1c2VkIGluYXBwcm9hY2ggdG9pbnRlbGxpZ2VudHllYXJzIGxhdGVyLHNhbnMtc2VyaWZkZXRlcm1pbmluZ1BlcmZvcm1hbmNlYXBwZWFyYW5jZXMsIHdoaWNoIGlzIGZvdW5kYXRpb25zYWJicmV2aWF0ZWRoaWdoZXIgdGhhbnMgZnJvbSB0aGUgaW5kaXZpZHVhbCBjb21wb3NlZCBvZnN1cHBvc2VkIHRvY2xhaW1zIHRoYXRhdHRyaWJ1dGlvbmZvbnQtc2l6ZToxZWxlbWVudHMgb2ZIaXN0b3JpY2FsIGhpcyBicm90aGVyYXQgdGhlIHRpbWVhbm5pdmVyc2FyeWdvdmVybmVkIGJ5cmVsYXRlZCB0byB1bHRpbWF0ZWx5IGlubm92YXRpb25zaXQgaXMgc3RpbGxjYW4gb25seSBiZWRlZmluaXRpb25zdG9HTVRTdHJpbmdBIG51bWJlciBvZmltZyBjbGFzcz0iRXZlbnR1YWxseSx3YXMgY2hhbmdlZG9jY3VycmVkIGlubmVpZ2hib3JpbmdkaXN0aW5ndWlzaHdoZW4gaGUgd2FzaW50cm9kdWNpbmd0ZXJyZXN0cmlhbE1hbnkgb2YgdGhlYXJndWVzIHRoYXRhbiBBbWVyaWNhbmNvbnF1ZXN0IG9md2lkZXNwcmVhZCB3ZXJlIGtpbGxlZHNjcmVlbiBhbmQgSW4gb3JkZXIgdG9leHBlY3RlZCB0b2Rlc2NlbmRhbnRzYXJlIGxvY2F0ZWRsZWdpc2xhdGl2ZWdlbmVyYXRpb25zIGJhY2tncm91bmRtb3N0IHBlb3BsZXllYXJzIGFmdGVydGhlcmUgaXMgbm90aGUgaGlnaGVzdGZyZXF1ZW50bHkgdGhleSBkbyBub3Rhcmd1ZWQgdGhhdHNob3dlZCB0aGF0cHJlZG9taW5hbnR0aGVvbG9naWNhbGJ5IHRoZSB0aW1lY29uc2lkZXJpbmdzaG9ydC1saXZlZDwvc3Bhbj48L2E+Y2FuIGJlIHVzZWR2ZXJ5IGxpdHRsZW9uZSBvZiB0aGUgaGFkIGFscmVhZHlpbnRlcnByZXRlZGNvbW11bmljYXRlZmVhdHVyZXMgb2Znb3Zlcm5tZW50LDwvbm9zY3JpcHQ+ZW50ZXJlZCB0aGUiIGhlaWdodD0iM0luZGVwZW5kZW50cG9wdWxhdGlvbnNsYXJnZS1zY2FsZS4gQWx0aG91Z2ggdXNlZCBpbiB0aGVkZXN0cnVjdGlvbnBvc3NpYmlsaXR5c3RhcnRpbmcgaW50d28gb3IgbW9yZWV4cHJlc3Npb25zc3Vib3JkaW5hdGVsYXJnZXIgdGhhbmhpc3RvcnkgYW5kPC9vcHRpb24+DQpDb250aW5lbnRhbGVsaW1pbmF0aW5nd2lsbCBub3QgYmVwcmFjdGljZSBvZmluIGZyb250IG9mc2l0ZSBvZiB0aGVlbnN1cmUgdGhhdHRvIGNyZWF0ZSBhbWlzc2lzc2lwcGlwb3RlbnRpYWxseW91dHN0YW5kaW5nYmV0dGVyIHRoYW53aGF0IGlzIG5vd3NpdHVhdGVkIGlubWV0YSBuYW1lPSJUcmFkaXRpb25hbHN1Z2dlc3Rpb25zVHJhbnNsYXRpb250aGUgZm9ybSBvZmF0bW9zcGhlcmljaWRlb2xvZ2ljYWxlbnRlcnByaXNlc2NhbGN1bGF0aW5nZWFzdCBvZiB0aGVyZW1uYW50cyBvZnBsdWdpbnNwYWdlL2luZGV4LnBocD9yZW1haW5lZCBpbnRyYW5zZm9ybWVkSGUgd2FzIGFsc293YXMgYWxyZWFkeXN0YXRpc3RpY2FsaW4gZmF2b3Igb2ZNaW5pc3RyeSBvZm1vdmVtZW50IG9mZm9ybXVsYXRpb25pcyByZXF1aXJlZDxsaW5rIHJlbD0iVGhpcyBpcyB0aGUgPGEgaHJlZj0iL3BvcHVsYXJpemVkaW52b2x2ZWQgaW5hcmUgdXNlZCB0b2FuZCBzZXZlcmFsbWFkZSBieSB0aGVzZWVtcyB0byBiZWxpa2VseSB0aGF0UGFsZXN0aW5pYW5uYW1lZCBhZnRlcml0IGhhZCBiZWVubW9zdCBjb21tb250byByZWZlciB0b2J1dCB0aGlzIGlzY29uc2VjdXRpdmV0ZW1wb3JhcmlseUluIGdlbmVyYWwsY29udmVudGlvbnN0YWtlcyBwbGFjZXN1YmRpdmlzaW9udGVycml0b3JpYWxvcGVyYXRpb25hbHBlcm1hbmVudGx5d2FzIGxhcmdlbHlvdXRicmVhayBvZmluIHRoZSBwYXN0Zm9sbG93aW5nIGEgeG1sbnM6b2c9Ij48YSBjbGFzcz0iY2xhc3M9InRleHRDb252ZXJzaW9uIG1heSBiZSB1c2VkbWFudWZhY3R1cmVhZnRlciBiZWluZ2NsZWFyZml4Ij4KcXVlc3Rpb24gb2Z3YXMgZWxlY3RlZHRvIGJlY29tZSBhYmVjYXVzZSBvZiBzb21lIHBlb3BsZWluc3BpcmVkIGJ5c3VjY2Vzc2Z1bCBhIHRpbWUgd2hlbm1vcmUgY29tbW9uYW1vbmdzdCB0aGVhbiBvZmZpY2lhbHdpZHRoOjEwMCU7dGVjaG5vbG9neSx3YXMgYWRvcHRlZHRvIGtlZXAgdGhlc2V0dGxlbWVudHNsaXZlIGJpcnRoc2luZGV4Lmh0bWwiQ29ubmVjdGljdXRhc3NpZ25lZCB0byZhbXA7dGltZXM7YWNjb3VudCBmb3JhbGlnbj1yaWdodHRoZSBjb21wYW55YWx3YXlzIGJlZW5yZXR1cm5lZCB0b2ludm9sdmVtZW50QmVjYXVzZSB0aGV0aGlzIHBlcmlvZCIgbmFtZT0icSIgY29uZmluZWQgdG9hIHJlc3VsdCBvZnZhbHVlPSIiIC8+aXMgYWN0dWFsbHlFbnZpcm9ubWVudA0KPC9oZWFkPg0KQ29udmVyc2VseSw+CjxkaXYgaWQ9IjAiIHdpZHRoPSIxaXMgcHJvYmFibHloYXZlIGJlY29tZWNvbnRyb2xsaW5ndGhlIHByb2JsZW1jaXRpemVucyBvZnBvbGl0aWNpYW5zcmVhY2hlZCB0aGVhcyBlYXJseSBhczpub25lOyBvdmVyPHRhYmxlIGNlbGx2YWxpZGl0eSBvZmRpcmVjdGx5IHRvb25tb3VzZWRvd253aGVyZSBpdCBpc3doZW4gaXQgd2FzbWVtYmVycyBvZiByZWxhdGlvbiB0b2FjY29tbW9kYXRlYWxvbmcgd2l0aCBJbiB0aGUgbGF0ZXRoZSBFbmdsaXNoZGVsaWNpb3VzIj50aGlzIGlzIG5vdHRoZSBwcmVzZW50aWYgdGhleSBhcmVhbmQgZmluYWxseWEgbWF0dGVyIG9mDQoJPC9kaXY+DQoNCjwvc2NyaXB0PmZhc3RlciB0aGFubWFqb3JpdHkgb2ZhZnRlciB3aGljaGNvbXBhcmF0aXZldG8gbWFpbnRhaW5pbXByb3ZlIHRoZWF3YXJkZWQgdGhlZXIiIGNsYXNzPSJmcmFtZWJvcmRlcnJlc3RvcmF0aW9uaW4gdGhlIHNhbWVhbmFseXNpcyBvZnRoZWlyIGZpcnN0RHVyaW5nIHRoZSBjb250aW5lbnRhbHNlcXVlbmNlIG9mZnVuY3Rpb24oKXtmb250LXNpemU6IHdvcmsgb24gdGhlPC9zY3JpcHQ+CjxiZWdpbnMgd2l0aGphdmFzY3JpcHQ6Y29uc3RpdHVlbnR3YXMgZm91bmRlZGVxdWlsaWJyaXVtYXNzdW1lIHRoYXRpcyBnaXZlbiBieW5lZWRzIHRvIGJlY29vcmRpbmF0ZXN0aGUgdmFyaW91c2FyZSBwYXJ0IG9mb25seSBpbiB0aGVzZWN0aW9ucyBvZmlzIGEgY29tbW9udGhlb3JpZXMgb2ZkaXNjb3Zlcmllc2Fzc29jaWF0aW9uZWRnZSBvZiB0aGVzdHJlbmd0aCBvZnBvc2l0aW9uIGlucHJlc2VudC1kYXl1bml2ZXJzYWxseXRvIGZvcm0gdGhlYnV0IGluc3RlYWRjb3Jwb3JhdGlvbmF0dGFjaGVkIHRvaXMgY29tbW9ubHlyZWFzb25zIGZvciAmcXVvdDt0aGUgY2FuIGJlIG1hZGV3YXMgYWJsZSB0b3doaWNoIG1lYW5zYnV0IGRpZCBub3Rvbk1vdXNlT3ZlcmFzIHBvc3NpYmxlb3BlcmF0ZWQgYnljb21pbmcgZnJvbXRoZSBwcmltYXJ5YWRkaXRpb24gb2Zmb3Igc2V2ZXJhbHRyYW5zZmVycmVkYSBwZXJpb2Qgb2ZhcmUgYWJsZSB0b2hvd2V2ZXIsIGl0c2hvdWxkIGhhdmVtdWNoIGxhcmdlcgoJPC9zY3JpcHQ+YWRvcHRlZCB0aGVwcm9wZXJ0eSBvZmRpcmVjdGVkIGJ5ZWZmZWN0aXZlbHl3YXMgYnJvdWdodGNoaWxkcmVuIG9mUHJvZ3JhbW1pbmdsb25nZXIgdGhhbm1hbnVzY3JpcHRzd2FyIGFnYWluc3RieSBtZWFucyBvZmFuZCBtb3N0IG9mc2ltaWxhciB0byBwcm9wcmlldGFyeW9yaWdpbmF0aW5ncHJlc3RpZ2lvdXNncmFtbWF0aWNhbGV4cGVyaWVuY2UudG8gbWFrZSB0aGVJdCB3YXMgYWxzb2lzIGZvdW5kIGluY29tcGV0aXRvcnNpbiB0aGUgVS5TLnJlcGxhY2UgdGhlYnJvdWdodCB0aGVjYWxjdWxhdGlvbmZhbGwgb2YgdGhldGhlIGdlbmVyYWxwcmFjdGljYWxseWluIGhvbm9yIG9mcmVsZWFzZWQgaW5yZXNpZGVudGlhbGFuZCBzb21lIG9ma2luZyBvZiB0aGVyZWFjdGlvbiB0bzFzdCBFYXJsIG9mY3VsdHVyZSBhbmRwcmluY2lwYWxseTwvdGl0bGU+CiAgdGhleSBjYW4gYmViYWNrIHRvIHRoZXNvbWUgb2YgaGlzZXhwb3N1cmUgdG9hcmUgc2ltaWxhcmZvcm0gb2YgdGhlYWRkRmF2b3JpdGVjaXRpemVuc2hpcHBhcnQgaW4gdGhlcGVvcGxlIHdpdGhpbiBwcmFjdGljZXRvIGNvbnRpbnVlJmFtcDttaW51czthcHByb3ZlZCBieSB0aGUgZmlyc3QgYWxsb3dlZCB0aGVhbmQgZm9yIHRoZWZ1bmN0aW9uaW5ncGxheWluZyB0aGVzb2x1dGlvbiB0b2hlaWdodD0iMCIgaW4gaGlzIGJvb2ttb3JlIHRoYW4gYWZvbGxvd3MgdGhlY3JlYXRlZCB0aGVwcmVzZW5jZSBpbiZuYnNwOzwvdGQ+bmF0aW9uYWxpc3R0aGUgaWRlYSBvZmEgY2hhcmFjdGVyd2VyZSBmb3JjZWQgY2xhc3M9ImJ0bmRheXMgb2YgdGhlZmVhdHVyZWQgaW5zaG93aW5nIHRoZWludGVyZXN0IGluaW4gcGxhY2Ugb2Z0dXJuIG9mIHRoZXRoZSBoZWFkIG9mTG9yZCBvZiB0aGVwb2xpdGljYWxseWhhcyBpdHMgb3duRWR1Y2F0aW9uYWxhcHByb3ZhbCBvZnNvbWUgb2YgdGhlZWFjaCBvdGhlcixiZWhhdmlvciBvZmFuZCBiZWNhdXNlYW5kIGFub3RoZXJhcHBlYXJlZCBvbnJlY29yZGVkIGluYmxhY2smcXVvdDttYXkgaW5jbHVkZXRoZSB3b3JsZCdzY2FuIGxlYWQgdG9yZWZlcnMgdG8gYWJvcmRlcj0iMCIgZ292ZXJubWVudCB3aW5uaW5nIHRoZXJlc3VsdGVkIGluIHdoaWxlIHRoZSBXYXNoaW5ndG9uLHRoZSBzdWJqZWN0Y2l0eSBpbiB0aGU+PC9kaXY+DQoJCXJlZmxlY3QgdGhldG8gY29tcGxldGViZWNhbWUgbW9yZXJhZGlvYWN0aXZlcmVqZWN0ZWQgYnl3aXRob3V0IGFueWhpcyBmYXRoZXIsd2hpY2ggY291bGRjb3B5IG9mIHRoZXRvIGluZGljYXRlYSBwb2xpdGljYWxhY2NvdW50cyBvZmNvbnN0aXR1dGVzd29ya2VkIHdpdGhlcjwvYT48L2xpPm9mIGhpcyBsaWZlYWNjb21wYW5pZWRjbGllbnRXaWR0aHByZXZlbnQgdGhlTGVnaXNsYXRpdmVkaWZmZXJlbnRseXRvZ2V0aGVyIGluaGFzIHNldmVyYWxmb3IgYW5vdGhlcnRleHQgb2YgdGhlZm91bmRlZCB0aGVlIHdpdGggdGhlIGlzIHVzZWQgZm9yY2hhbmdlZCB0aGV1c3VhbGx5IHRoZXBsYWNlIHdoZXJld2hlcmVhcyB0aGU+IDxhIGhyZWY9IiI+PGEgaHJlZj0idGhlbXNlbHZlcyxhbHRob3VnaCBoZXRoYXQgY2FuIGJldHJhZGl0aW9uYWxyb2xlIG9mIHRoZWFzIGEgcmVzdWx0cmVtb3ZlQ2hpbGRkZXNpZ25lZCBieXdlc3Qgb2YgdGhlU29tZSBwZW9wbGVwcm9kdWN0aW9uLHNpZGUgb2YgdGhlbmV3c2xldHRlcnN1c2VkIGJ5IHRoZWRvd24gdG8gdGhlYWNjZXB0ZWQgYnlsaXZlIGluIHRoZWF0dGVtcHRzIHRvb3V0c2lkZSB0aGVmcmVxdWVuY2llc0hvd2V2ZXIsIGlucHJvZ3JhbW1lcnNhdCBsZWFzdCBpbmFwcHJveGltYXRlYWx0aG91Z2ggaXR3YXMgcGFydCBvZmFuZCB2YXJpb3VzR292ZXJub3Igb2Z0aGUgYXJ0aWNsZXR1cm5lZCBpbnRvPjxhIGhyZWY9Ii90aGUgZWNvbm9teWlzIHRoZSBtb3N0bW9zdCB3aWRlbHl3b3VsZCBsYXRlcmFuZCBwZXJoYXBzcmlzZSB0byB0aGVvY2N1cnMgd2hlbnVuZGVyIHdoaWNoY29uZGl0aW9ucy50aGUgd2VzdGVybnRoZW9yeSB0aGF0aXMgcHJvZHVjZWR0aGUgY2l0eSBvZmluIHdoaWNoIGhlc2VlbiBpbiB0aGV0aGUgY2VudHJhbGJ1aWxkaW5nIG9mbWFueSBvZiBoaXNhcmVhIG9mIHRoZWlzIHRoZSBvbmx5bW9zdCBvZiB0aGVtYW55IG9mIHRoZXRoZSBXZXN0ZXJuVGhlcmUgaXMgbm9leHRlbmRlZCB0b1N0YXRpc3RpY2FsY29sc3Bhbj0yIHxzaG9ydCBzdG9yeXBvc3NpYmxlIHRvdG9wb2xvZ2ljYWxjcml0aWNhbCBvZnJlcG9ydGVkIHRvYSBDaHJpc3RpYW5kZWNpc2lvbiB0b2lzIGVxdWFsIHRvcHJvYmxlbXMgb2ZUaGlzIGNhbiBiZW1lcmNoYW5kaXNlZm9yIG1vc3Qgb2ZubyBldmlkZW5jZWVkaXRpb25zIG9mZWxlbWVudHMgaW4mcXVvdDsuIFRoZWNvbS9pbWFnZXMvd2hpY2ggbWFrZXN0aGUgcHJvY2Vzc3JlbWFpbnMgdGhlbGl0ZXJhdHVyZSxpcyBhIG1lbWJlcnRoZSBwb3B1bGFydGhlIGFuY2llbnRwcm9ibGVtcyBpbnRpbWUgb2YgdGhlZGVmZWF0ZWQgYnlib2R5IG9mIHRoZWEgZmV3IHllYXJzbXVjaCBvZiB0aGV0aGUgd29yayBvZkNhbGlmb3JuaWEsc2VydmVkIGFzIGFnb3Zlcm5tZW50LmNvbmNlcHRzIG9mbW92ZW1lbnQgaW4JCTxkaXYgaWQ9Iml0IiB2YWx1ZT0ibGFuZ3VhZ2Ugb2ZhcyB0aGV5IGFyZXByb2R1Y2VkIGluaXMgdGhhdCB0aGVleHBsYWluIHRoZWRpdj48L2Rpdj4KSG93ZXZlciB0aGVsZWFkIHRvIHRoZQk8YSBocmVmPSIvd2FzIGdyYW50ZWRwZW9wbGUgaGF2ZWNvbnRpbnVhbGx5d2FzIHNlZW4gYXNhbmQgcmVsYXRlZHRoZSByb2xlIG9mcHJvcG9zZWQgYnlvZiB0aGUgYmVzdGVhY2ggb3RoZXIuQ29uc3RhbnRpbmVwZW9wbGUgZnJvbWRpYWxlY3RzIG9mdG8gcmV2aXNpb253YXMgcmVuYW1lZGEgc291cmNlIG9mdGhlIGluaXRpYWxsYXVuY2hlZCBpbnByb3ZpZGUgdGhldG8gdGhlIHdlc3R3aGVyZSB0aGVyZWFuZCBzaW1pbGFyYmV0d2VlbiB0d29pcyBhbHNvIHRoZUVuZ2xpc2ggYW5kY29uZGl0aW9ucyx0aGF0IGl0IHdhc2VudGl0bGVkIHRvdGhlbXNlbHZlcy5xdWFudGl0eSBvZnJhbnNwYXJlbmN5dGhlIHNhbWUgYXN0byBqb2luIHRoZWNvdW50cnkgYW5kdGhpcyBpcyB0aGVUaGlzIGxlZCB0b2Egc3RhdGVtZW50Y29udHJhc3QgdG9sYXN0SW5kZXhPZnRocm91Z2ggaGlzaXMgZGVzaWduZWR0aGUgdGVybSBpc2lzIHByb3ZpZGVkcHJvdGVjdCB0aGVuZzwvYT48L2xpPlRoZSBjdXJyZW50dGhlIHNpdGUgb2ZzdWJzdGFudGlhbGV4cGVyaWVuY2UsaW4gdGhlIFdlc3R0aGV5IHNob3VsZHNsb3ZlbsSNaW5hY29tZW50YXJpb3N1bml2ZXJzaWRhZGNvbmRpY2lvbmVzYWN0aXZpZGFkZXNleHBlcmllbmNpYXRlY25vbG9nw61hcHJvZHVjY2nDs25wdW50dWFjacOzbmFwbGljYWNpw7NuY29udHJhc2XDsWFjYXRlZ29yw61hc3JlZ2lzdHJhcnNlcHJvZmVzaW9uYWx0cmF0YW1pZW50b3JlZ8Otc3RyYXRlc2VjcmV0YXLDrWFwcmluY2lwYWxlc3Byb3RlY2Npw7NuaW1wb3J0YW50ZXNpbXBvcnRhbmNpYXBvc2liaWxpZGFkaW50ZXJlc2FudGVjcmVjaW1pZW50b25lY2VzaWRhZGVzc3VzY3JpYmlyc2Vhc29jaWFjacOzbmRpc3BvbmlibGVzZXZhbHVhY2nDs25lc3R1ZGlhbnRlc3Jlc3BvbnNhYmxlcmVzb2x1Y2nDs25ndWFkYWxhamFyYXJlZ2lzdHJhZG9zb3BvcnR1bmlkYWRjb21lcmNpYWxlc2ZvdG9ncmFmw61hYXV0b3JpZGFkZXNpbmdlbmllcsOtYXRlbGV2aXNpw7NuY29tcGV0ZW5jaWFvcGVyYWNpb25lc2VzdGFibGVjaWRvc2ltcGxlbWVudGVhY3R1YWxtZW50ZW5hdmVnYWNpw7NuY29uZm9ybWlkYWRsaW5lLWhlaWdodDpmb250LWZhbWlseToiIDogImh0dHA6Ly9hcHBsaWNhdGlvbnNsaW5rIiBocmVmPSJzcGVjaWZpY2FsbHkvLzwhW0NEQVRBWwpPcmdhbml6YXRpb25kaXN0cmlidXRpb24wcHg7IGhlaWdodDpyZWxhdGlvbnNoaXBkZXZpY2Utd2lkdGg8ZGl2IGNsYXNzPSI8bGFiZWwgZm9yPSJyZWdpc3RyYXRpb248L25vc2NyaXB0PgovaW5kZXguaHRtbCJ3aW5kb3cub3BlbiggIWltcG9ydGFudDthcHBsaWNhdGlvbi9pbmRlcGVuZGVuY2UvL3d3dy5nb29nbGVvcmdhbml6YXRpb25hdXRvY29tcGxldGVyZXF1aXJlbWVudHNjb25zZXJ2YXRpdmU8Zm9ybSBuYW1lPSJpbnRlbGxlY3R1YWxtYXJnaW4tbGVmdDoxOHRoIGNlbnR1cnlhbiBpbXBvcnRhbnRpbnN0aXR1dGlvbnNhYmJyZXZpYXRpb248aW1nIGNsYXNzPSJvcmdhbmlzYXRpb25jaXZpbGl6YXRpb24xOXRoIGNlbnR1cnlhcmNoaXRlY3R1cmVpbmNvcnBvcmF0ZWQyMHRoIGNlbnR1cnktY29udGFpbmVyIj5tb3N0IG5vdGFibHkvPjwvYT48L2Rpdj5ub3RpZmljYXRpb24ndW5kZWZpbmVkJylGdXJ0aGVybW9yZSxiZWxpZXZlIHRoYXRpbm5lckhUTUwgPSBwcmlvciB0byB0aGVkcmFtYXRpY2FsbHlyZWZlcnJpbmcgdG9uZWdvdGlhdGlvbnNoZWFkcXVhcnRlcnNTb3V0aCBBZnJpY2F1bnN1Y2Nlc3NmdWxQZW5uc3lsdmFuaWFBcyBhIHJlc3VsdCw8aHRtbCBsYW5nPSImbHQ7L3N1cCZndDtkZWFsaW5nIHdpdGhwaGlsYWRlbHBoaWFoaXN0b3JpY2FsbHkpOzwvc2NyaXB0PgpwYWRkaW5nLXRvcDpleHBlcmltZW50YWxnZXRBdHRyaWJ1dGVpbnN0cnVjdGlvbnN0ZWNobm9sb2dpZXNwYXJ0IG9mIHRoZSA9ZnVuY3Rpb24oKXtzdWJzY3JpcHRpb25sLmR0ZCI+DQo8aHRnZW9ncmFwaGljYWxDb25zdGl0dXRpb24nLCBmdW5jdGlvbihzdXBwb3J0ZWQgYnlhZ3JpY3VsdHVyYWxjb25zdHJ1Y3Rpb25wdWJsaWNhdGlvbnNmb250LXNpemU6IDFhIHZhcmlldHkgb2Y8ZGl2IHN0eWxlPSJFbmN5Y2xvcGVkaWFpZnJhbWUgc3JjPSJkZW1vbnN0cmF0ZWRhY2NvbXBsaXNoZWR1bml2ZXJzaXRpZXNEZW1vZ3JhcGhpY3MpOzwvc2NyaXB0PjxkZWRpY2F0ZWQgdG9rbm93bGVkZ2Ugb2ZzYXRpc2ZhY3Rpb25wYXJ0aWN1bGFybHk8L2Rpdj48L2Rpdj5FbmdsaXNoIChVUylhcHBlbmRDaGlsZCh0cmFuc21pc3Npb25zLiBIb3dldmVyLCBpbnRlbGxpZ2VuY2UiIHRhYmluZGV4PSJmbG9hdDpyaWdodDtDb21tb253ZWFsdGhyYW5naW5nIGZyb21pbiB3aGljaCB0aGVhdCBsZWFzdCBvbmVyZXByb2R1Y3Rpb25lbmN5Y2xvcGVkaWE7Zm9udC1zaXplOjFqdXJpc2RpY3Rpb25hdCB0aGF0IHRpbWUiPjxhIGNsYXNzPSJJbiBhZGRpdGlvbixkZXNjcmlwdGlvbitjb252ZXJzYXRpb25jb250YWN0IHdpdGhpcyBnZW5lcmFsbHlyIiBjb250ZW50PSJyZXByZXNlbnRpbmcmbHQ7bWF0aCZndDtwcmVzZW50YXRpb25vY2Nhc2lvbmFsbHk8aW1nIHdpZHRoPSJuYXZpZ2F0aW9uIj5jb21wZW5zYXRpb25jaGFtcGlvbnNoaXBtZWRpYT0iYWxsIiB2aW9sYXRpb24gb2ZyZWZlcmVuY2UgdG9yZXR1cm4gdHJ1ZTtTdHJpY3QvL0VOIiB0cmFuc2FjdGlvbnNpbnRlcnZlbnRpb252ZXJpZmljYXRpb25JbmZvcm1hdGlvbiBkaWZmaWN1bHRpZXNDaGFtcGlvbnNoaXBjYXBhYmlsaXRpZXM8IVtlbmRpZl0tLT59Cjwvc2NyaXB0PgpDaHJpc3RpYW5pdHlmb3IgZXhhbXBsZSxQcm9mZXNzaW9uYWxyZXN0cmljdGlvbnNzdWdnZXN0IHRoYXR3YXMgcmVsZWFzZWQoc3VjaCBhcyB0aGVyZW1vdmVDbGFzcyh1bmVtcGxveW1lbnR0aGUgQW1lcmljYW5zdHJ1Y3R1cmUgb2YvaW5kZXguaHRtbCBwdWJsaXNoZWQgaW5zcGFuIGNsYXNzPSIiPjxhIGhyZWY9Ii9pbnRyb2R1Y3Rpb25iZWxvbmdpbmcgdG9jbGFpbWVkIHRoYXRjb25zZXF1ZW5jZXM8bWV0YSBuYW1lPSJHdWlkZSB0byB0aGVvdmVyd2hlbG1pbmdhZ2FpbnN0IHRoZSBjb25jZW50cmF0ZWQsCi5ub250b3VjaCBvYnNlcnZhdGlvbnM8L2E+CjwvZGl2PgpmIChkb2N1bWVudC5ib3JkZXI6IDFweCB7Zm9udC1zaXplOjF0cmVhdG1lbnQgb2YwIiBoZWlnaHQ9IjFtb2RpZmljYXRpb25JbmRlcGVuZGVuY2VkaXZpZGVkIGludG9ncmVhdGVyIHRoYW5hY2hpZXZlbWVudHNlc3RhYmxpc2hpbmdKYXZhU2NyaXB0IiBuZXZlcnRoZWxlc3NzaWduaWZpY2FuY2VCcm9hZGNhc3Rpbmc+Jm5ic3A7PC90ZD5jb250YWluZXIiPgpzdWNoIGFzIHRoZSBpbmZsdWVuY2Ugb2ZhIHBhcnRpY3VsYXJzcmM9J2h0dHA6Ly9uYXZpZ2F0aW9uIiBoYWxmIG9mIHRoZSBzdWJzdGFudGlhbCAmbmJzcDs8L2Rpdj5hZHZhbnRhZ2Ugb2ZkaXNjb3Zlcnkgb2ZmdW5kYW1lbnRhbCBtZXRyb3BvbGl0YW50aGUgb3Bwb3NpdGUiIHhtbDpsYW5nPSJkZWxpYmVyYXRlbHlhbGlnbj1jZW50ZXJldm9sdXRpb24gb2ZwcmVzZXJ2YXRpb25pbXByb3ZlbWVudHNiZWdpbm5pbmcgaW5KZXN1cyBDaHJpc3RQdWJsaWNhdGlvbnNkaXNhZ3JlZW1lbnR0ZXh0LWFsaWduOnIsIGZ1bmN0aW9uKClzaW1pbGFyaXRpZXNib2R5PjwvaHRtbD5pcyBjdXJyZW50bHlhbHBoYWJldGljYWxpcyBzb21ldGltZXN0eXBlPSJpbWFnZS9tYW55IG9mIHRoZSBmbG93OmhpZGRlbjthdmFpbGFibGUgaW5kZXNjcmliZSB0aGVleGlzdGVuY2Ugb2ZhbGwgb3ZlciB0aGV0aGUgSW50ZXJuZXQJPHVsIGNsYXNzPSJpbnN0YWxsYXRpb25uZWlnaGJvcmhvb2Rhcm1lZCBmb3JjZXNyZWR1Y2luZyB0aGVjb250aW51ZXMgdG9Ob25ldGhlbGVzcyx0ZW1wZXJhdHVyZXMKCQk8YSBocmVmPSJjbG9zZSB0byB0aGVleGFtcGxlcyBvZiBpcyBhYm91dCB0aGUoc2VlIGJlbG93KS4iIGlkPSJzZWFyY2hwcm9mZXNzaW9uYWxpcyBhdmFpbGFibGV0aGUgb2ZmaWNpYWwJCTwvc2NyaXB0PgoKCQk8ZGl2IGlkPSJhY2NlbGVyYXRpb250aHJvdWdoIHRoZSBIYWxsIG9mIEZhbWVkZXNjcmlwdGlvbnN0cmFuc2xhdGlvbnNpbnRlcmZlcmVuY2UgdHlwZT0ndGV4dC9yZWNlbnQgeWVhcnNpbiB0aGUgd29ybGR2ZXJ5IHBvcHVsYXJ7YmFja2dyb3VuZDp0cmFkaXRpb25hbCBzb21lIG9mIHRoZSBjb25uZWN0ZWQgdG9leHBsb2l0YXRpb25lbWVyZ2VuY2Ugb2Zjb25zdGl0dXRpb25BIEhpc3Rvcnkgb2ZzaWduaWZpY2FudCBtYW51ZmFjdHVyZWRleHBlY3RhdGlvbnM+PG5vc2NyaXB0PjxjYW4gYmUgZm91bmRiZWNhdXNlIHRoZSBoYXMgbm90IGJlZW5uZWlnaGJvdXJpbmd3aXRob3V0IHRoZSBhZGRlZCB0byB0aGUJPGxpIGNsYXNzPSJpbnN0cnVtZW50YWxTb3ZpZXQgVW5pb25hY2tub3dsZWRnZWR3aGljaCBjYW4gYmVuYW1lIGZvciB0aGVhdHRlbnRpb24gdG9hdHRlbXB0cyB0byBkZXZlbG9wbWVudHNJbiBmYWN0LCB0aGU8bGkgY2xhc3M9ImFpbXBsaWNhdGlvbnNzdWl0YWJsZSBmb3JtdWNoIG9mIHRoZSBjb2xvbml6YXRpb25wcmVzaWRlbnRpYWxjYW5jZWxCdWJibGUgSW5mb3JtYXRpb25tb3N0IG9mIHRoZSBpcyBkZXNjcmliZWRyZXN0IG9mIHRoZSBtb3JlIG9yIGxlc3NpbiBTZXB0ZW1iZXJJbnRlbGxpZ2VuY2VzcmM9Imh0dHA6Ly9weDsgaGVpZ2h0OiBhdmFpbGFibGUgdG9tYW51ZmFjdHVyZXJodW1hbiByaWdodHNsaW5rIGhyZWY9Ii9hdmFpbGFiaWxpdHlwcm9wb3J0aW9uYWxvdXRzaWRlIHRoZSBhc3Ryb25vbWljYWxodW1hbiBiZWluZ3NuYW1lIG9mIHRoZSBhcmUgZm91bmQgaW5hcmUgYmFzZWQgb25zbWFsbGVyIHRoYW5hIHBlcnNvbiB3aG9leHBhbnNpb24gb2Zhcmd1aW5nIHRoYXRub3cga25vd24gYXNJbiB0aGUgZWFybHlpbnRlcm1lZGlhdGVkZXJpdmVkIGZyb21TY2FuZGluYXZpYW48L2E+PC9kaXY+DQpjb25zaWRlciB0aGVhbiBlc3RpbWF0ZWR0aGUgTmF0aW9uYWw8ZGl2IGlkPSJwYWdyZXN1bHRpbmcgaW5jb21taXNzaW9uZWRhbmFsb2dvdXMgdG9hcmUgcmVxdWlyZWQvdWw+CjwvZGl2Pgp3YXMgYmFzZWQgb25hbmQgYmVjYW1lIGEmbmJzcDsmbmJzcDt0IiB2YWx1ZT0iIiB3YXMgY2FwdHVyZWRubyBtb3JlIHRoYW5yZXNwZWN0aXZlbHljb250aW51ZSB0byA+DQo8aGVhZD4NCjx3ZXJlIGNyZWF0ZWRtb3JlIGdlbmVyYWxpbmZvcm1hdGlvbiB1c2VkIGZvciB0aGVpbmRlcGVuZGVudCB0aGUgSW1wZXJpYWxjb21wb25lbnQgb2Z0byB0aGUgbm9ydGhpbmNsdWRlIHRoZSBDb25zdHJ1Y3Rpb25zaWRlIG9mIHRoZSB3b3VsZCBub3QgYmVmb3IgaW5zdGFuY2VpbnZlbnRpb24gb2Ztb3JlIGNvbXBsZXhjb2xsZWN0aXZlbHliYWNrZ3JvdW5kOiB0ZXh0LWFsaWduOiBpdHMgb3JpZ2luYWxpbnRvIGFjY291bnR0aGlzIHByb2Nlc3NhbiBleHRlbnNpdmVob3dldmVyLCB0aGV0aGV5IGFyZSBub3RyZWplY3RlZCB0aGVjcml0aWNpc20gb2ZkdXJpbmcgd2hpY2hwcm9iYWJseSB0aGV0aGlzIGFydGljbGUoZnVuY3Rpb24oKXtJdCBzaG91bGQgYmVhbiBhZ3JlZW1lbnRhY2NpZGVudGFsbHlkaWZmZXJzIGZyb21BcmNoaXRlY3R1cmViZXR0ZXIga25vd25hcnJhbmdlbWVudHNpbmZsdWVuY2Ugb25hdHRlbmRlZCB0aGVpZGVudGljYWwgdG9zb3V0aCBvZiB0aGVwYXNzIHRocm91Z2h4bWwiIHRpdGxlPSJ3ZWlnaHQ6Ym9sZDtjcmVhdGluZyB0aGVkaXNwbGF5Om5vbmVyZXBsYWNlZCB0aGU8aW1nIHNyYz0iL2lodHRwczovL3d3dy5Xb3JsZCBXYXIgSUl0ZXN0aW1vbmlhbHNmb3VuZCBpbiB0aGVyZXF1aXJlZCB0byBhbmQgdGhhdCB0aGViZXR3ZWVuIHRoZSB3YXMgZGVzaWduZWRjb25zaXN0cyBvZiBjb25zaWRlcmFibHlwdWJsaXNoZWQgYnl0aGUgbGFuZ3VhZ2VDb25zZXJ2YXRpb25jb25zaXN0ZWQgb2ZyZWZlciB0byB0aGViYWNrIHRvIHRoZSBjc3MiIG1lZGlhPSJQZW9wbGUgZnJvbSBhdmFpbGFibGUgb25wcm92ZWQgdG8gYmVzdWdnZXN0aW9ucyJ3YXMga25vd24gYXN2YXJpZXRpZXMgb2ZsaWtlbHkgdG8gYmVjb21wcmlzZWQgb2ZzdXBwb3J0IHRoZSBoYW5kcyBvZiB0aGVjb3VwbGVkIHdpdGhjb25uZWN0IGFuZCBib3JkZXI6bm9uZTtwZXJmb3JtYW5jZXNiZWZvcmUgYmVpbmdsYXRlciBiZWNhbWVjYWxjdWxhdGlvbnNvZnRlbiBjYWxsZWRyZXNpZGVudHMgb2ZtZWFuaW5nIHRoYXQ+PGxpIGNsYXNzPSJldmlkZW5jZSBmb3JleHBsYW5hdGlvbnNlbnZpcm9ubWVudHMiPjwvYT48L2Rpdj53aGljaCBhbGxvd3NJbnRyb2R1Y3Rpb25kZXZlbG9wZWQgYnlhIHdpZGUgcmFuZ2VvbiBiZWhhbGYgb2Z2YWxpZ249InRvcCJwcmluY2lwbGUgb2ZhdCB0aGUgdGltZSw8L25vc2NyaXB0Pg1zYWlkIHRvIGhhdmVpbiB0aGUgZmlyc3R3aGlsZSBvdGhlcnNoeXBvdGhldGljYWxwaGlsb3NvcGhlcnNwb3dlciBvZiB0aGVjb250YWluZWQgaW5wZXJmb3JtZWQgYnlpbmFiaWxpdHkgdG93ZXJlIHdyaXR0ZW5zcGFuIHN0eWxlPSJpbnB1dCBuYW1lPSJ0aGUgcXVlc3Rpb25pbnRlbmRlZCBmb3JyZWplY3Rpb24gb2ZpbXBsaWVzIHRoYXRpbnZlbnRlZCB0aGV0aGUgc3RhbmRhcmR3YXMgcHJvYmFibHlsaW5rIGJldHdlZW5wcm9mZXNzb3Igb2ZpbnRlcmFjdGlvbnNjaGFuZ2luZyB0aGVJbmRpYW4gT2NlYW4gY2xhc3M9Imxhc3R3b3JraW5nIHdpdGgnaHR0cDovL3d3dy55ZWFycyBiZWZvcmVUaGlzIHdhcyB0aGVyZWNyZWF0aW9uYWxlbnRlcmluZyB0aGVtZWFzdXJlbWVudHNhbiBleHRyZW1lbHl2YWx1ZSBvZiB0aGVzdGFydCBvZiB0aGUKPC9zY3JpcHQ+CgphbiBlZmZvcnQgdG9pbmNyZWFzZSB0aGV0byB0aGUgc291dGhzcGFjaW5nPSIwIj5zdWZmaWNpZW50bHl0aGUgRXVyb3BlYW5jb252ZXJ0ZWQgdG9jbGVhclRpbWVvdXRkaWQgbm90IGhhdmVjb25zZXF1ZW50bHlmb3IgdGhlIG5leHRleHRlbnNpb24gb2ZlY29ub21pYyBhbmRhbHRob3VnaCB0aGVhcmUgcHJvZHVjZWRhbmQgd2l0aCB0aGVpbnN1ZmZpY2llbnRnaXZlbiBieSB0aGVzdGF0aW5nIHRoYXRleHBlbmRpdHVyZXM8L3NwYW4+PC9hPgp0aG91Z2h0IHRoYXRvbiB0aGUgYmFzaXNjZWxscGFkZGluZz1pbWFnZSBvZiB0aGVyZXR1cm5pbmcgdG9pbmZvcm1hdGlvbixzZXBhcmF0ZWQgYnlhc3Nhc3NpbmF0ZWRzIiBjb250ZW50PSJhdXRob3JpdHkgb2Zub3J0aHdlc3Rlcm48L2Rpdj4KPGRpdiAiPjwvZGl2Pg0KICBjb25zdWx0YXRpb25jb21tdW5pdHkgb2Z0aGUgbmF0aW9uYWxpdCBzaG91bGQgYmVwYXJ0aWNpcGFudHMgYWxpZ249ImxlZnR0aGUgZ3JlYXRlc3RzZWxlY3Rpb24gb2ZzdXBlcm5hdHVyYWxkZXBlbmRlbnQgb25pcyBtZW50aW9uZWRhbGxvd2luZyB0aGV3YXMgaW52ZW50ZWRhY2NvbXBhbnlpbmdoaXMgcGVyc29uYWxhdmFpbGFibGUgYXRzdHVkeSBvZiB0aGVvbiB0aGUgb3RoZXJleGVjdXRpb24gb2ZIdW1hbiBSaWdodHN0ZXJtcyBvZiB0aGVhc3NvY2lhdGlvbnNyZXNlYXJjaCBhbmRzdWNjZWVkZWQgYnlkZWZlYXRlZCB0aGVhbmQgZnJvbSB0aGVidXQgdGhleSBhcmVjb21tYW5kZXIgb2ZzdGF0ZSBvZiB0aGV5ZWFycyBvZiBhZ2V0aGUgc3R1ZHkgb2Y8dWwgY2xhc3M9InNwbGFjZSBpbiB0aGV3aGVyZSBoZSB3YXM8bGkgY2xhc3M9ImZ0aGVyZSBhcmUgbm93aGljaCBiZWNhbWVoZSBwdWJsaXNoZWRleHByZXNzZWQgaW50byB3aGljaCB0aGVjb21taXNzaW9uZXJmb250LXdlaWdodDp0ZXJyaXRvcnkgb2ZleHRlbnNpb25zIj5Sb21hbiBFbXBpcmVlcXVhbCB0byB0aGVJbiBjb250cmFzdCxob3dldmVyLCBhbmRpcyB0eXBpY2FsbHlhbmQgaGlzIHdpZmUoYWxzbyBjYWxsZWQ+PHVsIGNsYXNzPSJlZmZlY3RpdmVseSBldm9sdmVkIGludG9zZWVtIHRvIGhhdmV3aGljaCBpcyB0aGV0aGVyZSB3YXMgbm9hbiBleGNlbGxlbnRhbGwgb2YgdGhlc2VkZXNjcmliZWQgYnlJbiBwcmFjdGljZSxicm9hZGNhc3RpbmdjaGFyZ2VkIHdpdGhyZWZsZWN0ZWQgaW5zdWJqZWN0ZWQgdG9taWxpdGFyeSBhbmR0byB0aGUgcG9pbnRlY29ub21pY2FsbHlzZXRUYXJnZXRpbmdhcmUgYWN0dWFsbHl2aWN0b3J5IG92ZXIoKTs8L3NjcmlwdD5jb250aW51b3VzbHlyZXF1aXJlZCBmb3Jldm9sdXRpb25hcnlhbiBlZmZlY3RpdmVub3J0aCBvZiB0aGUsIHdoaWNoIHdhcyBmcm9udCBvZiB0aGVvciBvdGhlcndpc2Vzb21lIGZvcm0gb2ZoYWQgbm90IGJlZW5nZW5lcmF0ZWQgYnlpbmZvcm1hdGlvbi5wZXJtaXR0ZWQgdG9pbmNsdWRlcyB0aGVkZXZlbG9wbWVudCxlbnRlcmVkIGludG90aGUgcHJldmlvdXNjb25zaXN0ZW50bHlhcmUga25vd24gYXN0aGUgZmllbGQgb2Z0aGlzIHR5cGUgb2ZnaXZlbiB0byB0aGV0aGUgdGl0bGUgb2Zjb250YWlucyB0aGVpbnN0YW5jZXMgb2ZpbiB0aGUgbm9ydGhkdWUgdG8gdGhlaXJhcmUgZGVzaWduZWRjb3Jwb3JhdGlvbnN3YXMgdGhhdCB0aGVvbmUgb2YgdGhlc2Vtb3JlIHBvcHVsYXJzdWNjZWVkZWQgaW5zdXBwb3J0IGZyb21pbiBkaWZmZXJlbnRkb21pbmF0ZWQgYnlkZXNpZ25lZCBmb3Jvd25lcnNoaXAgb2ZhbmQgcG9zc2libHlzdGFuZGFyZGl6ZWRyZXNwb25zZVRleHR3YXMgaW50ZW5kZWRyZWNlaXZlZCB0aGVhc3N1bWVkIHRoYXRhcmVhcyBvZiB0aGVwcmltYXJpbHkgaW50aGUgYmFzaXMgb2ZpbiB0aGUgc2Vuc2VhY2NvdW50cyBmb3JkZXN0cm95ZWQgYnlhdCBsZWFzdCB0d293YXMgZGVjbGFyZWRjb3VsZCBub3QgYmVTZWNyZXRhcnkgb2ZhcHBlYXIgdG8gYmVtYXJnaW4tdG9wOjEvXlxzK3xccyskL2dlKXt0aHJvdyBlfTt0aGUgc3RhcnQgb2Z0d28gc2VwYXJhdGVsYW5ndWFnZSBhbmR3aG8gaGFkIGJlZW5vcGVyYXRpb24gb2ZkZWF0aCBvZiB0aGVyZWFsIG51bWJlcnMJPGxpbmsgcmVsPSJwcm92aWRlZCB0aGV0aGUgc3Rvcnkgb2Zjb21wZXRpdGlvbnNlbmdsaXNoIChVSyllbmdsaXNoIChVUynQnNC+0L3Qs9C+0LvQodGA0L/RgdC60LjRgdGA0L/RgdC60LjRgdGA0L/RgdC60L7ZhNi52LHYqNmK2KnmraPpq5TkuK3mlofnroDkvZPkuK3mlofnuYHkvZPkuK3mlofmnInpmZDlhazlj7jkurrmsJHmlL/lupzpmL/ph4zlt7Tlt7TnpL7kvJrkuLvkuYnmk43kvZzns7vnu5/mlL/nrZbms5Xop4RpbmZvcm1hY2nDs25oZXJyYW1pZW50YXNlbGVjdHLDs25pY29kZXNjcmlwY2nDs25jbGFzaWZpY2Fkb3Njb25vY2ltaWVudG9wdWJsaWNhY2nDs25yZWxhY2lvbmFkYXNpbmZvcm3DoXRpY2FyZWxhY2lvbmFkb3NkZXBhcnRhbWVudG90cmFiYWphZG9yZXNkaXJlY3RhbWVudGVheXVudGFtaWVudG9tZXJjYWRvTGlicmVjb250w6FjdGVub3NoYWJpdGFjaW9uZXNjdW1wbGltaWVudG9yZXN0YXVyYW50ZXNkaXNwb3NpY2nDs25jb25zZWN1ZW5jaWFlbGVjdHLDs25pY2FhcGxpY2FjaW9uZXNkZXNjb25lY3RhZG9pbnN0YWxhY2nDs25yZWFsaXphY2nDs251dGlsaXphY2nDs25lbmNpY2xvcGVkaWFlbmZlcm1lZGFkZXNpbnN0cnVtZW50b3NleHBlcmllbmNpYXNpbnN0aXR1Y2nDs25wYXJ0aWN1bGFyZXNzdWJjYXRlZ29yaWHRgtC+0LvRjNC60L7QoNC+0YHRgdC40LjRgNCw0LHQvtGC0YvQsdC+0LvRjNGI0LXQv9GA0L7RgdGC0L7QvNC+0LbQtdGC0LXQtNGA0YPQs9C40YXRgdC70YPRh9Cw0LXRgdC10LnRh9Cw0YHQstGB0LXQs9C00LDQoNC+0YHRgdC40Y/QnNC+0YHQutCy0LXQtNGA0YPQs9C40LXQs9C+0YDQvtC00LDQstC+0L/RgNC+0YHQtNCw0L3QvdGL0YXQtNC+0LvQttC90YvQuNC80LXQvdC90L7QnNC+0YHQutCy0YvRgNGD0LHQu9C10LnQnNC+0YHQutCy0LDRgdGC0YDQsNC90YvQvdC40YfQtdCz0L7RgNCw0LHQvtGC0LXQtNC+0LvQttC10L3Rg9GB0LvRg9Cz0LjRgtC10L/QtdGA0YzQntC00L3QsNC60L7Qv9C+0YLQvtC80YPRgNCw0LHQvtGC0YPQsNC/0YDQtdC70Y/QstC+0L7QsdGJ0LXQvtC00L3QvtCz0L7RgdCy0L7QtdCz0L7RgdGC0LDRgtGM0LjQtNGA0YPQs9C+0LnRhNC+0YDRg9C80LXRhdC+0YDQvtGI0L7Qv9GA0L7RgtC40LLRgdGB0YvQu9C60LDQutCw0LbQtNGL0LnQstC70LDRgdGC0LjQs9GA0YPQv9C/0YvQstC80LXRgdGC0LXRgNCw0LHQvtGC0LDRgdC60LDQt9Cw0LvQv9C10YDQstGL0LnQtNC10LvQsNGC0YzQtNC10L3RjNCz0LjQv9C10YDQuNC+0LTQsdC40LfQvdC10YHQvtGB0L3QvtCy0LXQvNC+0LzQtdC90YLQutGD0L/QuNGC0YzQtNC+0LvQttC90LDRgNCw0LzQutCw0YXQvdCw0YfQsNC70L7QoNCw0LHQvtGC0LDQotC+0LvRjNC60L7RgdC+0LLRgdC10LzQstGC0L7RgNC+0LnQvdCw0YfQsNC70LDRgdC/0LjRgdC+0LrRgdC70YPQttCx0YvRgdC40YHRgtC10LzQv9C10YfQsNGC0LjQvdC+0LLQvtCz0L7Qv9C+0LzQvtGJ0LjRgdCw0LnRgtC+0LLQv9C+0YfQtdC80YPQv9C+0LzQvtGJ0YzQtNC+0LvQttC90L7RgdGB0YvQu9C60LjQsdGL0YHRgtGA0L7QtNCw0L3QvdGL0LXQvNC90L7Qs9C40LXQv9GA0L7QtdC60YLQodC10LnRh9Cw0YHQvNC+0LTQtdC70LjRgtCw0LrQvtCz0L7QvtC90LvQsNC50L3Qs9C+0YDQvtC00LXQstC10YDRgdC40Y/RgdGC0YDQsNC90LXRhNC40LvRjNC80YvRg9GA0L7QstC90Y/RgNCw0LfQvdGL0YXQuNGB0LrQsNGC0YzQvdC10LTQtdC70Y7Rj9C90LLQsNGA0Y/QvNC10L3RjNGI0LXQvNC90L7Qs9C40YXQtNCw0L3QvdC+0LnQt9C90LDRh9C40YLQvdC10LvRjNC30Y/RhNC+0YDRg9C80LDQotC10L/QtdGA0YzQvNC10YHRj9GG0LDQt9Cw0YnQuNGC0YvQm9GD0YfRiNC40LXgpKjgpLngpYDgpILgpJXgpLDgpKjgpYfgpIXgpKrgpKjgpYfgpJXgpL/gpK/gpL7gpJXgpLDgpYfgpILgpIXgpKjgpY3gpK/gpJXgpY3gpK/gpL7gpJfgpL7gpIfgpKHgpKzgpL7gpLDgpYfgpJXgpL/gpLjgpYDgpKbgpL/gpK/gpL7gpKrgpLngpLLgpYfgpLjgpL/gpILgpLngpK3gpL7gpLDgpKTgpIXgpKrgpKjgpYDgpLXgpL7gpLLgpYfgpLjgpYfgpLXgpL7gpJXgpLDgpKTgpYfgpK7gpYfgpLDgpYfgpLngpYvgpKjgpYfgpLjgpJXgpKTgpYfgpKzgpLngpYHgpKTgpLjgpL7gpIfgpJ/gpLngpYvgpJfgpL7gpJzgpL7gpKjgpYfgpK7gpL/gpKjgpJ/gpJXgpLDgpKTgpL7gpJXgpLDgpKjgpL7gpIngpKjgpJXgpYfgpK/gpLngpL7gpIHgpLjgpKzgpLjgpYfgpK3gpL7gpLfgpL7gpIbgpKrgpJXgpYfgpLLgpL/gpK/gpYfgpLbgpYHgpLDgpYLgpIfgpLjgpJXgpYfgpJjgpILgpJ/gpYfgpK7gpYfgpLDgpYDgpLjgpJXgpKTgpL7gpK7gpYfgpLDgpL7gpLLgpYfgpJXgpLDgpIXgpKfgpL/gpJXgpIXgpKrgpKjgpL7gpLjgpK7gpL7gpJzgpK7gpYHgpJ3gpYfgpJXgpL7gpLDgpKPgpLngpYvgpKTgpL7gpJXgpKHgpLzgpYDgpK/gpLngpL7gpILgpLngpYvgpJ/gpLLgpLbgpKzgpY3gpKbgpLLgpL/gpK/gpL7gpJzgpYDgpLXgpKjgpJzgpL7gpKTgpL7gpJXgpYjgpLjgpYfgpIbgpKrgpJXgpL7gpLXgpL7gpLLgpYDgpKbgpYfgpKjgpYfgpKrgpYLgpLDgpYDgpKrgpL7gpKjgpYDgpIngpLjgpJXgpYfgpLngpYvgpJfgpYDgpKzgpYjgpKDgpJXgpIbgpKrgpJXgpYDgpLXgpLDgpY3gpLfgpJfgpL7gpILgpLXgpIbgpKrgpJXgpYvgpJzgpL/gpLLgpL7gpJzgpL7gpKjgpL7gpLjgpLngpK7gpKTgpLngpK7gpYfgpILgpIngpKjgpJXgpYDgpK/gpL7gpLngpYLgpKbgpLDgpY3gpJzgpLjgpYLgpJrgpYDgpKrgpLjgpILgpKbgpLjgpLXgpL7gpLLgpLngpYvgpKjgpL7gpLngpYvgpKTgpYDgpJzgpYjgpLjgpYfgpLXgpL7gpKrgpLjgpJzgpKjgpKTgpL7gpKjgpYfgpKTgpL7gpJzgpL7gpLDgpYDgpJjgpL7gpK/gpLLgpJzgpL/gpLLgpYfgpKjgpYDgpJrgpYfgpJzgpL7gpILgpJrgpKrgpKTgpY3gpLDgpJfgpYLgpJfgpLLgpJzgpL7gpKTgpYfgpKzgpL7gpLngpLDgpIbgpKrgpKjgpYfgpLXgpL7gpLngpKjgpIfgpLjgpJXgpL7gpLjgpYHgpKzgpLngpLDgpLngpKjgpYfgpIfgpLjgpLjgpYfgpLjgpLngpL/gpKTgpKzgpKHgpLzgpYfgpJjgpJ/gpKjgpL7gpKTgpLLgpL7gpLbgpKrgpL7gpILgpJrgpLbgpY3gpLDgpYDgpKzgpKHgpLzgpYDgpLngpYvgpKTgpYfgpLjgpL7gpIjgpJ/gpLbgpL7gpK/gpKbgpLjgpJXgpKTgpYDgpJzgpL7gpKTgpYDgpLXgpL7gpLLgpL7gpLngpJzgpL7gpLDgpKrgpJ/gpKjgpL7gpLDgpJbgpKjgpYfgpLjgpKHgpLzgpJXgpK7gpL/gpLLgpL7gpIngpLjgpJXgpYDgpJXgpYfgpLXgpLLgpLLgpJfgpKTgpL7gpJbgpL7gpKjgpL7gpIXgpLDgpY3gpKXgpJzgpLngpL7gpILgpKbgpYfgpJbgpL7gpKrgpLngpLLgpYDgpKjgpL/gpK/gpK7gpKzgpL/gpKjgpL7gpKzgpYjgpILgpJXgpJXgpLngpYDgpILgpJXgpLngpKjgpL7gpKbgpYfgpKTgpL7gpLngpK7gpLLgpYfgpJXgpL7gpKvgpYDgpJzgpKzgpJXgpL/gpKTgpYHgpLDgpKTgpK7gpL7gpILgpJfgpLXgpLngpYDgpILgpLDgpYvgpJzgpLzgpK7gpL/gpLLgpYDgpIbgpLDgpYvgpKrgpLjgpYfgpKjgpL7gpK/gpL7gpKbgpLXgpLLgpYfgpKjgpYfgpJbgpL7gpKTgpL7gpJXgpLDgpYDgpKzgpIngpKjgpJXgpL7gpJzgpLXgpL7gpKzgpKrgpYLgpLDgpL7gpKzgpKHgpLzgpL7gpLjgpYzgpKbgpL7gpLbgpYfgpK/gpLDgpJXgpL/gpK/gpYfgpJXgpLngpL7gpILgpIXgpJXgpLjgpLDgpKzgpKjgpL7gpI/gpLXgpLngpL7gpILgpLjgpY3gpKXgpLLgpK7gpL/gpLLgpYfgpLLgpYfgpJbgpJXgpLXgpL/gpLfgpK/gpJXgpY3gpLDgpILgpLjgpK7gpYLgpLngpKXgpL7gpKjgpL7Yqtiz2KrYt9mK2LnZhdi02KfYsdmD2KnYqNmI2KfYs9i32KnYp9mE2LXZgdit2KnZhdmI2KfYttmK2LnYp9mE2K7Yp9i12KnYp9mE2YXYstmK2K/Yp9mE2LnYp9mF2KnYp9mE2YPYp9iq2KjYp9mE2LHYr9mI2K/YqNix2YbYp9mF2KzYp9mE2K/ZiNmE2KnYp9mE2LnYp9mE2YXYp9mE2YXZiNmC2LnYp9mE2LnYsdio2YrYp9mE2LPYsdmK2LnYp9mE2KzZiNin2YTYp9mE2LDZh9in2KjYp9mE2K3Zitin2KnYp9mE2K3ZgtmI2YLYp9mE2YPYsdmK2YXYp9mE2LnYsdin2YLZhdit2YHZiNi42KnYp9mE2KvYp9mG2YrZhdi02KfZh9iv2KnYp9mE2YXYsdij2KnYp9mE2YLYsdii2YbYp9mE2LTYqNin2KjYp9mE2K3ZiNin2LHYp9mE2KzYr9mK2K/Yp9mE2KPYs9ix2KnYp9mE2LnZhNmI2YXZhdis2YXZiNi52KnYp9mE2LHYrdmF2YbYp9mE2YbZgtin2LfZgdmE2LPYt9mK2YbYp9mE2YPZiNmK2KrYp9mE2K/ZhtmK2KfYqNix2YPYp9iq2YfYp9mE2LHZitin2LbYqtit2YrYp9iq2YrYqNiq2YjZgtmK2KrYp9mE2KPZiNmE2YnYp9mE2KjYsdmK2K/Yp9mE2YPZhNin2YXYp9mE2LHYp9io2LfYp9mE2LTYrti12YrYs9mK2KfYsdin2KrYp9mE2KvYp9mE2KvYp9mE2LXZhNin2KnYp9mE2K3Yr9mK2KvYp9mE2LLZiNin2LHYp9mE2K7ZhNmK2KzYp9mE2KzZhdmK2LnYp9mE2LnYp9mF2YfYp9mE2KzZhdin2YTYp9mE2LPYp9i52KnZhdi02KfZh9iv2YfYp9mE2LHYptmK2LPYp9mE2K/YrtmI2YTYp9mE2YHZhtmK2KnYp9mE2YPYqtin2KjYp9mE2K/ZiNix2YrYp9mE2K/YsdmI2LPYp9iz2KrYutix2YLYqti12KfZhdmK2YXYp9mE2KjZhtin2KrYp9mE2LnYuNmK2YVlbnRlcnRhaW5tZW50dW5kZXJzdGFuZGluZyA9IGZ1bmN0aW9uKCkuanBnIiB3aWR0aD0iY29uZmlndXJhdGlvbi5wbmciIHdpZHRoPSI8Ym9keSBjbGFzcz0iTWF0aC5yYW5kb20oKWNvbnRlbXBvcmFyeSBVbml0ZWQgU3RhdGVzY2lyY3Vtc3RhbmNlcy5hcHBlbmRDaGlsZChvcmdhbml6YXRpb25zPHNwYW4gY2xhc3M9IiI+PGltZyBzcmM9Ii9kaXN0aW5ndWlzaGVkdGhvdXNhbmRzIG9mIGNvbW11bmljYXRpb25jbGVhciI+PC9kaXY+aW52ZXN0aWdhdGlvbmZhdmljb24uaWNvIiBtYXJnaW4tcmlnaHQ6YmFzZWQgb24gdGhlIE1hc3NhY2h1c2V0dHN0YWJsZSBib3JkZXI9aW50ZXJuYXRpb25hbGFsc28ga25vd24gYXNwcm9udW5jaWF0aW9uYmFja2dyb3VuZDojZnBhZGRpbmctbGVmdDpGb3IgZXhhbXBsZSwgbWlzY2VsbGFuZW91cyZsdDsvbWF0aCZndDtwc3ljaG9sb2dpY2FsaW4gcGFydGljdWxhcmVhcmNoIiB0eXBlPSJmb3JtIG1ldGhvZD0iYXMgb3Bwb3NlZCB0b1N1cHJlbWUgQ291cnRvY2Nhc2lvbmFsbHkgQWRkaXRpb25hbGx5LE5vcnRoIEFtZXJpY2FweDtiYWNrZ3JvdW5kb3Bwb3J0dW5pdGllc0VudGVydGFpbm1lbnQudG9Mb3dlckNhc2UobWFudWZhY3R1cmluZ3Byb2Zlc3Npb25hbCBjb21iaW5lZCB3aXRoRm9yIGluc3RhbmNlLGNvbnNpc3Rpbmcgb2YiIG1heGxlbmd0aD0icmV0dXJuIGZhbHNlO2NvbnNjaW91c25lc3NNZWRpdGVycmFuZWFuZXh0cmFvcmRpbmFyeWFzc2Fzc2luYXRpb25zdWJzZXF1ZW50bHkgYnV0dG9uIHR5cGU9InRoZSBudW1iZXIgb2Z0aGUgb3JpZ2luYWwgY29tcHJlaGVuc2l2ZXJlZmVycyB0byB0aGU8L3VsPgo8L2Rpdj4KcGhpbG9zb3BoaWNhbGxvY2F0aW9uLmhyZWZ3YXMgcHVibGlzaGVkU2FuIEZyYW5jaXNjbyhmdW5jdGlvbigpewo8ZGl2IGlkPSJtYWluc29waGlzdGljYXRlZG1hdGhlbWF0aWNhbCAvaGVhZD4NCjxib2R5c3VnZ2VzdHMgdGhhdGRvY3VtZW50YXRpb25jb25jZW50cmF0aW9ucmVsYXRpb25zaGlwc21heSBoYXZlIGJlZW4oZm9yIGV4YW1wbGUsVGhpcyBhcnRpY2xlIGluIHNvbWUgY2FzZXNwYXJ0cyBvZiB0aGUgZGVmaW5pdGlvbiBvZkdyZWF0IEJyaXRhaW4gY2VsbHBhZGRpbmc9ZXF1aXZhbGVudCB0b3BsYWNlaG9sZGVyPSI7IGZvbnQtc2l6ZToganVzdGlmaWNhdGlvbmJlbGlldmVkIHRoYXRzdWZmZXJlZCBmcm9tYXR0ZW1wdGVkIHRvIGxlYWRlciBvZiB0aGVjcmlwdCIgc3JjPSIvKGZ1bmN0aW9uKCkge2FyZSBhdmFpbGFibGUKCTxsaW5rIHJlbD0iIHNyYz0naHR0cDovL2ludGVyZXN0ZWQgaW5jb252ZW50aW9uYWwgIiBhbHQ9IiIgLz48L2FyZSBnZW5lcmFsbHloYXMgYWxzbyBiZWVubW9zdCBwb3B1bGFyIGNvcnJlc3BvbmRpbmdjcmVkaXRlZCB3aXRodHlsZT0iYm9yZGVyOjwvYT48L3NwYW4+PC8uZ2lmIiB3aWR0aD0iPGlmcmFtZSBzcmM9InRhYmxlIGNsYXNzPSJpbmxpbmUtYmxvY2s7YWNjb3JkaW5nIHRvIHRvZ2V0aGVyIHdpdGhhcHByb3hpbWF0ZWx5cGFybGlhbWVudGFyeW1vcmUgYW5kIG1vcmVkaXNwbGF5Om5vbmU7dHJhZGl0aW9uYWxseXByZWRvbWluYW50bHkmbmJzcDt8Jm5ic3A7Jm5ic3A7PC9zcGFuPiBjZWxsc3BhY2luZz08aW5wdXQgbmFtZT0ib3IiIGNvbnRlbnQ9ImNvbnRyb3ZlcnNpYWxwcm9wZXJ0eT0ib2c6L3gtc2hvY2t3YXZlLWRlbW9uc3RyYXRpb25zdXJyb3VuZGVkIGJ5TmV2ZXJ0aGVsZXNzLHdhcyB0aGUgZmlyc3Rjb25zaWRlcmFibGUgQWx0aG91Z2ggdGhlIGNvbGxhYm9yYXRpb25zaG91bGQgbm90IGJlcHJvcG9ydGlvbiBvZjxzcGFuIHN0eWxlPSJrbm93biBhcyB0aGUgc2hvcnRseSBhZnRlcmZvciBpbnN0YW5jZSxkZXNjcmliZWQgYXMgL2hlYWQ+Cjxib2R5IHN0YXJ0aW5nIHdpdGhpbmNyZWFzaW5nbHkgdGhlIGZhY3QgdGhhdGRpc2N1c3Npb24gb2ZtaWRkbGUgb2YgdGhlYW4gaW5kaXZpZHVhbGRpZmZpY3VsdCB0byBwb2ludCBvZiB2aWV3aG9tb3NleHVhbGl0eWFjY2VwdGFuY2Ugb2Y8L3NwYW4+PC9kaXY+bWFudWZhY3R1cmVyc29yaWdpbiBvZiB0aGVjb21tb25seSB1c2VkaW1wb3J0YW5jZSBvZmRlbm9taW5hdGlvbnNiYWNrZ3JvdW5kOiAjbGVuZ3RoIG9mIHRoZWRldGVybWluYXRpb25hIHNpZ25pZmljYW50IiBib3JkZXI9IjAiPnJldm9sdXRpb25hcnlwcmluY2lwbGVzIG9maXMgY29uc2lkZXJlZHdhcyBkZXZlbG9wZWRJbmRvLUV1cm9wZWFudnVsbmVyYWJsZSB0b3Byb3BvbmVudHMgb2ZhcmUgc29tZXRpbWVzY2xvc2VyIHRvIHRoZU5ldyBZb3JrIENpdHkgbmFtZT0ic2VhcmNoYXR0cmlidXRlZCB0b2NvdXJzZSBvZiB0aGVtYXRoZW1hdGljaWFuYnkgdGhlIGVuZCBvZmF0IHRoZSBlbmQgb2YiIGJvcmRlcj0iMCIgdGVjaG5vbG9naWNhbC5yZW1vdmVDbGFzcyhicmFuY2ggb2YgdGhlZXZpZGVuY2UgdGhhdCFbZW5kaWZdLS0+DQpJbnN0aXR1dGUgb2YgaW50byBhIHNpbmdsZXJlc3BlY3RpdmVseS5hbmQgdGhlcmVmb3JlcHJvcGVydGllcyBvZmlzIGxvY2F0ZWQgaW5zb21lIG9mIHdoaWNoVGhlcmUgaXMgYWxzb2NvbnRpbnVlZCB0byBhcHBlYXJhbmNlIG9mICZhbXA7bmRhc2g7IGRlc2NyaWJlcyB0aGVjb25zaWRlcmF0aW9uYXV0aG9yIG9mIHRoZWluZGVwZW5kZW50bHllcXVpcHBlZCB3aXRoZG9lcyBub3QgaGF2ZTwvYT48YSBocmVmPSJjb25mdXNlZCB3aXRoPGxpbmsgaHJlZj0iL2F0IHRoZSBhZ2Ugb2ZhcHBlYXIgaW4gdGhlVGhlc2UgaW5jbHVkZXJlZ2FyZGxlc3Mgb2Zjb3VsZCBiZSB1c2VkIHN0eWxlPSZxdW90O3NldmVyYWwgdGltZXNyZXByZXNlbnQgdGhlYm9keT4KPC9odG1sPnRob3VnaHQgdG8gYmVwb3B1bGF0aW9uIG9mcG9zc2liaWxpdGllc3BlcmNlbnRhZ2Ugb2ZhY2Nlc3MgdG8gdGhlYW4gYXR0ZW1wdCB0b3Byb2R1Y3Rpb24gb2ZqcXVlcnkvanF1ZXJ5dHdvIGRpZmZlcmVudGJlbG9uZyB0byB0aGVlc3RhYmxpc2htZW50cmVwbGFjaW5nIHRoZWRlc2NyaXB0aW9uIiBkZXRlcm1pbmUgdGhlYXZhaWxhYmxlIGZvckFjY29yZGluZyB0byB3aWRlIHJhbmdlIG9mCTxkaXYgY2xhc3M9Im1vcmUgY29tbW9ubHlvcmdhbmlzYXRpb25zZnVuY3Rpb25hbGl0eXdhcyBjb21wbGV0ZWQgJmFtcDttZGFzaDsgcGFydGljaXBhdGlvbnRoZSBjaGFyYWN0ZXJhbiBhZGRpdGlvbmFsYXBwZWFycyB0byBiZWZhY3QgdGhhdCB0aGVhbiBleGFtcGxlIG9mc2lnbmlmaWNhbnRseW9ubW91c2VvdmVyPSJiZWNhdXNlIHRoZXkgYXN5bmMgPSB0cnVlO3Byb2JsZW1zIHdpdGhzZWVtcyB0byBoYXZldGhlIHJlc3VsdCBvZiBzcmM9Imh0dHA6Ly9mYW1pbGlhciB3aXRocG9zc2Vzc2lvbiBvZmZ1bmN0aW9uICgpIHt0b29rIHBsYWNlIGluYW5kIHNvbWV0aW1lc3N1YnN0YW50aWFsbHk8c3Bhbj48L3NwYW4+aXMgb2Z0ZW4gdXNlZGluIGFuIGF0dGVtcHRncmVhdCBkZWFsIG9mRW52aXJvbm1lbnRhbHN1Y2Nlc3NmdWxseSB2aXJ0dWFsbHkgYWxsMjB0aCBjZW50dXJ5LHByb2Zlc3Npb25hbHNuZWNlc3NhcnkgdG8gZGV0ZXJtaW5lZCBieWNvbXBhdGliaWxpdHliZWNhdXNlIGl0IGlzRGljdGlvbmFyeSBvZm1vZGlmaWNhdGlvbnNUaGUgZm9sbG93aW5nbWF5IHJlZmVyIHRvOkNvbnNlcXVlbnRseSxJbnRlcm5hdGlvbmFsYWx0aG91Z2ggc29tZXRoYXQgd291bGQgYmV3b3JsZCdzIGZpcnN0Y2xhc3NpZmllZCBhc2JvdHRvbSBvZiB0aGUocGFydGljdWxhcmx5YWxpZ249ImxlZnQiIG1vc3QgY29tbW9ubHliYXNpcyBmb3IgdGhlZm91bmRhdGlvbiBvZmNvbnRyaWJ1dGlvbnNwb3B1bGFyaXR5IG9mY2VudGVyIG9mIHRoZXRvIHJlZHVjZSB0aGVqdXJpc2RpY3Rpb25zYXBwcm94aW1hdGlvbiBvbm1vdXNlb3V0PSJOZXcgVGVzdGFtZW50Y29sbGVjdGlvbiBvZjwvc3Bhbj48L2E+PC9pbiB0aGUgVW5pdGVkZmlsbSBkaXJlY3Rvci1zdHJpY3QuZHRkIj5oYXMgYmVlbiB1c2VkcmV0dXJuIHRvIHRoZWFsdGhvdWdoIHRoaXNjaGFuZ2UgaW4gdGhlc2V2ZXJhbCBvdGhlcmJ1dCB0aGVyZSBhcmV1bnByZWNlZGVudGVkaXMgc2ltaWxhciB0b2VzcGVjaWFsbHkgaW53ZWlnaHQ6IGJvbGQ7aXMgY2FsbGVkIHRoZWNvbXB1dGF0aW9uYWxpbmRpY2F0ZSB0aGF0cmVzdHJpY3RlZCB0bwk8bWV0YSBuYW1lPSJhcmUgdHlwaWNhbGx5Y29uZmxpY3Qgd2l0aEhvd2V2ZXIsIHRoZSBBbiBleGFtcGxlIG9mY29tcGFyZWQgd2l0aHF1YW50aXRpZXMgb2ZyYXRoZXIgdGhhbiBhY29uc3RlbGxhdGlvbm5lY2Vzc2FyeSBmb3JyZXBvcnRlZCB0aGF0c3BlY2lmaWNhdGlvbnBvbGl0aWNhbCBhbmQmbmJzcDsmbmJzcDs8cmVmZXJlbmNlcyB0b3RoZSBzYW1lIHllYXJHb3Zlcm5tZW50IG9mZ2VuZXJhdGlvbiBvZmhhdmUgbm90IGJlZW5zZXZlcmFsIHllYXJzY29tbWl0bWVudCB0bwkJPHVsIGNsYXNzPSJ2aXN1YWxpemF0aW9uMTl0aCBjZW50dXJ5LHByYWN0aXRpb25lcnN0aGF0IGhlIHdvdWxkYW5kIGNvbnRpbnVlZG9jY3VwYXRpb24gb2ZpcyBkZWZpbmVkIGFzY2VudHJlIG9mIHRoZXRoZSBhbW91bnQgb2Y+PGRpdiBzdHlsZT0iZXF1aXZhbGVudCBvZmRpZmZlcmVudGlhdGVicm91Z2h0IGFib3V0bWFyZ2luLWxlZnQ6IGF1dG9tYXRpY2FsbHl0aG91Z2h0IG9mIGFzU29tZSBvZiB0aGVzZQo8ZGl2IGNsYXNzPSJpbnB1dCBjbGFzcz0icmVwbGFjZWQgd2l0aGlzIG9uZSBvZiB0aGVlZHVjYXRpb24gYW5kaW5mbHVlbmNlZCBieXJlcHV0YXRpb24gYXMKPG1ldGEgbmFtZT0iYWNjb21tb2RhdGlvbjwvZGl2Pgo8L2Rpdj5sYXJnZSBwYXJ0IG9mSW5zdGl0dXRlIGZvcnRoZSBzby1jYWxsZWQgYWdhaW5zdCB0aGUgSW4gdGhpcyBjYXNlLHdhcyBhcHBvaW50ZWRjbGFpbWVkIHRvIGJlSG93ZXZlciwgdGhpc0RlcGFydG1lbnQgb2Z0aGUgcmVtYWluaW5nZWZmZWN0IG9uIHRoZXBhcnRpY3VsYXJseSBkZWFsIHdpdGggdGhlCjxkaXYgc3R5bGU9ImFsbW9zdCBhbHdheXNhcmUgY3VycmVudGx5ZXhwcmVzc2lvbiBvZnBoaWxvc29waHkgb2Zmb3IgbW9yZSB0aGFuY2l2aWxpemF0aW9uc29uIHRoZSBpc2xhbmRzZWxlY3RlZEluZGV4Y2FuIHJlc3VsdCBpbiIgdmFsdWU9IiIgLz50aGUgc3RydWN0dXJlIC8+PC9hPjwvZGl2Pk1hbnkgb2YgdGhlc2VjYXVzZWQgYnkgdGhlb2YgdGhlIFVuaXRlZHNwYW4gY2xhc3M9Im1jYW4gYmUgdHJhY2VkaXMgcmVsYXRlZCB0b2JlY2FtZSBvbmUgb2ZpcyBmcmVxdWVudGx5bGl2aW5nIGluIHRoZXRoZW9yZXRpY2FsbHlGb2xsb3dpbmcgdGhlUmV2b2x1dGlvbmFyeWdvdmVybm1lbnQgaW5pcyBkZXRlcm1pbmVkdGhlIHBvbGl0aWNhbGludHJvZHVjZWQgaW5zdWZmaWNpZW50IHRvZGVzY3JpcHRpb24iPnNob3J0IHN0b3JpZXNzZXBhcmF0aW9uIG9mYXMgdG8gd2hldGhlcmtub3duIGZvciBpdHN3YXMgaW5pdGlhbGx5ZGlzcGxheTpibG9ja2lzIGFuIGV4YW1wbGV0aGUgcHJpbmNpcGFsY29uc2lzdHMgb2YgYXJlY29nbml6ZWQgYXMvYm9keT48L2h0bWw+YSBzdWJzdGFudGlhbHJlY29uc3RydWN0ZWRoZWFkIG9mIHN0YXRlcmVzaXN0YW5jZSB0b3VuZGVyZ3JhZHVhdGVUaGVyZSBhcmUgdHdvZ3Jhdml0YXRpb25hbGFyZSBkZXNjcmliZWRpbnRlbnRpb25hbGx5c2VydmVkIGFzIHRoZWNsYXNzPSJoZWFkZXJvcHBvc2l0aW9uIHRvZnVuZGFtZW50YWxseWRvbWluYXRlZCB0aGVhbmQgdGhlIG90aGVyYWxsaWFuY2Ugd2l0aHdhcyBmb3JjZWQgdG9yZXNwZWN0aXZlbHksYW5kIHBvbGl0aWNhbGluIHN1cHBvcnQgb2ZwZW9wbGUgaW4gdGhlMjB0aCBjZW50dXJ5LmFuZCBwdWJsaXNoZWRsb2FkQ2hhcnRiZWF0dG8gdW5kZXJzdGFuZG1lbWJlciBzdGF0ZXNlbnZpcm9ubWVudGFsZmlyc3QgaGFsZiBvZmNvdW50cmllcyBhbmRhcmNoaXRlY3R1cmFsYmUgY29uc2lkZXJlZGNoYXJhY3Rlcml6ZWRjbGVhckludGVydmFsYXV0aG9yaXRhdGl2ZUZlZGVyYXRpb24gb2Z3YXMgc3VjY2VlZGVkYW5kIHRoZXJlIGFyZWEgY29uc2VxdWVuY2V0aGUgUHJlc2lkZW50YWxzbyBpbmNsdWRlZGZyZWUgc29mdHdhcmVzdWNjZXNzaW9uIG9mZGV2ZWxvcGVkIHRoZXdhcyBkZXN0cm95ZWRhd2F5IGZyb20gdGhlOwo8L3NjcmlwdD4KPGFsdGhvdWdoIHRoZXlmb2xsb3dlZCBieSBhbW9yZSBwb3dlcmZ1bHJlc3VsdGVkIGluIGFVbml2ZXJzaXR5IG9mSG93ZXZlciwgbWFueXRoZSBwcmVzaWRlbnRIb3dldmVyLCBzb21laXMgdGhvdWdodCB0b3VudGlsIHRoZSBlbmR3YXMgYW5ub3VuY2VkYXJlIGltcG9ydGFudGFsc28gaW5jbHVkZXM+PGlucHV0IHR5cGU9dGhlIGNlbnRlciBvZiBETyBOT1QgQUxURVJ1c2VkIHRvIHJlZmVydGhlbWVzLz9zb3J0PXRoYXQgaGFkIGJlZW50aGUgYmFzaXMgZm9yaGFzIGRldmVsb3BlZGluIHRoZSBzdW1tZXJjb21wYXJhdGl2ZWx5ZGVzY3JpYmVkIHRoZXN1Y2ggYXMgdGhvc2V0aGUgcmVzdWx0aW5naXMgaW1wb3NzaWJsZXZhcmlvdXMgb3RoZXJTb3V0aCBBZnJpY2FuaGF2ZSB0aGUgc2FtZWVmZmVjdGl2ZW5lc3NpbiB3aGljaCBjYXNlOyB0ZXh0LWFsaWduOnN0cnVjdHVyZSBhbmQ7IGJhY2tncm91bmQ6cmVnYXJkaW5nIHRoZXN1cHBvcnRlZCB0aGVpcyBhbHNvIGtub3duc3R5bGU9Im1hcmdpbmluY2x1ZGluZyB0aGViYWhhc2EgTWVsYXl1bm9yc2sgYm9rbcOlbG5vcnNrIG55bm9yc2tzbG92ZW7FocSNaW5haW50ZXJuYWNpb25hbGNhbGlmaWNhY2nDs25jb211bmljYWNpw7NuY29uc3RydWNjacOzbiI+PGRpdiBjbGFzcz0iZGlzYW1iaWd1YXRpb25Eb21haW5OYW1lJywgJ2FkbWluaXN0cmF0aW9uc2ltdWx0YW5lb3VzbHl0cmFuc3BvcnRhdGlvbkludGVybmF0aW9uYWwgbWFyZ2luLWJvdHRvbTpyZXNwb25zaWJpbGl0eTwhW2VuZGlmXS0tPgo8Lz48bWV0YSBuYW1lPSJpbXBsZW1lbnRhdGlvbmluZnJhc3RydWN0dXJlcmVwcmVzZW50YXRpb25ib3JkZXItYm90dG9tOjwvaGVhZD4KPGJvZHk+PWh0dHAlM0ElMkYlMkY8Zm9ybSBtZXRob2Q9Im1ldGhvZD0icG9zdCIgL2Zhdmljb24uaWNvIiB9KTsKPC9zY3JpcHQ+Ci5zZXRBdHRyaWJ1dGUoQWRtaW5pc3RyYXRpb249IG5ldyBBcnJheSgpOzwhW2VuZGlmXS0tPg0KZGlzcGxheTpibG9jaztVbmZvcnR1bmF0ZWx5LCI+Jm5ic3A7PC9kaXY+L2Zhdmljb24uaWNvIj49J3N0eWxlc2hlZXQnIGlkZW50aWZpY2F0aW9uLCBmb3IgZXhhbXBsZSw8bGk+PGEgaHJlZj0iL2FuIGFsdGVybmF0aXZlYXMgYSByZXN1bHQgb2ZwdCI+PC9zY3JpcHQ+CnR5cGU9InN1Ym1pdCIgCihmdW5jdGlvbigpIHtyZWNvbW1lbmRhdGlvbmZvcm0gYWN0aW9uPSIvdHJhbnNmb3JtYXRpb25yZWNvbnN0cnVjdGlvbi5zdHlsZS5kaXNwbGF5IEFjY29yZGluZyB0byBoaWRkZW4iIG5hbWU9ImFsb25nIHdpdGggdGhlZG9jdW1lbnQuYm9keS5hcHByb3hpbWF0ZWx5IENvbW11bmljYXRpb25zcG9zdCIgYWN0aW9uPSJtZWFuaW5nICZxdW90Oy0tPCFbZW5kaWZdLS0+UHJpbWUgTWluaXN0ZXJjaGFyYWN0ZXJpc3RpYzwvYT4gPGEgY2xhc3M9dGhlIGhpc3Rvcnkgb2Ygb25tb3VzZW92ZXI9InRoZSBnb3Zlcm5tZW50aHJlZj0iaHR0cHM6Ly93YXMgb3JpZ2luYWxseXdhcyBpbnRyb2R1Y2VkY2xhc3NpZmljYXRpb25yZXByZXNlbnRhdGl2ZWFyZSBjb25zaWRlcmVkPCFbZW5kaWZdLS0+CgpkZXBlbmRzIG9uIHRoZVVuaXZlcnNpdHkgb2YgaW4gY29udHJhc3QgdG8gcGxhY2Vob2xkZXI9ImluIHRoZSBjYXNlIG9maW50ZXJuYXRpb25hbCBjb25zdGl0dXRpb25hbHN0eWxlPSJib3JkZXItOiBmdW5jdGlvbigpIHtCZWNhdXNlIG9mIHRoZS1zdHJpY3QuZHRkIj4KPHRhYmxlIGNsYXNzPSJhY2NvbXBhbmllZCBieWFjY291bnQgb2YgdGhlPHNjcmlwdCBzcmM9Ii9uYXR1cmUgb2YgdGhlIHRoZSBwZW9wbGUgaW4gaW4gYWRkaXRpb24gdG9zKTsganMuaWQgPSBpZCIgd2lkdGg9IjEwMCUicmVnYXJkaW5nIHRoZSBSb21hbiBDYXRob2xpY2FuIGluZGVwZW5kZW50Zm9sbG93aW5nIHRoZSAuZ2lmIiB3aWR0aD0iMXRoZSBmb2xsb3dpbmcgZGlzY3JpbWluYXRpb25hcmNoYWVvbG9naWNhbHByaW1lIG1pbmlzdGVyLmpzIj48L3NjcmlwdD5jb21iaW5hdGlvbiBvZiBtYXJnaW53aWR0aD0iY3JlYXRlRWxlbWVudCh3LmF0dGFjaEV2ZW50KDwvYT48L3RkPjwvdHI+c3JjPSJodHRwczovL2FJbiBwYXJ0aWN1bGFyLCBhbGlnbj0ibGVmdCIgQ3plY2ggUmVwdWJsaWNVbml0ZWQgS2luZ2RvbWNvcnJlc3BvbmRlbmNlY29uY2x1ZGVkIHRoYXQuaHRtbCIgdGl0bGU9IihmdW5jdGlvbiAoKSB7Y29tZXMgZnJvbSB0aGVhcHBsaWNhdGlvbiBvZjxzcGFuIGNsYXNzPSJzYmVsaWV2ZWQgdG8gYmVlbWVudCgnc2NyaXB0JzwvYT4KPC9saT4KPGxpdmVyeSBkaWZmZXJlbnQ+PHNwYW4gY2xhc3M9Im9wdGlvbiB2YWx1ZT0iKGFsc28ga25vd24gYXMJPGxpPjxhIGhyZWY9Ij48aW5wdXQgbmFtZT0ic2VwYXJhdGVkIGZyb21yZWZlcnJlZCB0byBhcyB2YWxpZ249InRvcCI+Zm91bmRlciBvZiB0aGVhdHRlbXB0aW5nIHRvIGNhcmJvbiBkaW94aWRlCgo8ZGl2IGNsYXNzPSJjbGFzcz0ic2VhcmNoLS9ib2R5Pgo8L2h0bWw+b3Bwb3J0dW5pdHkgdG9jb21tdW5pY2F0aW9uczwvaGVhZD4NCjxib2R5IHN0eWxlPSJ3aWR0aDpUaeG6v25nIFZp4buHdGNoYW5nZXMgaW4gdGhlYm9yZGVyLWNvbG9yOiMwIiBib3JkZXI9IjAiIDwvc3Bhbj48L2Rpdj48d2FzIGRpc2NvdmVyZWQiIHR5cGU9InRleHQiICk7Cjwvc2NyaXB0PgoKRGVwYXJ0bWVudCBvZiBlY2NsZXNpYXN0aWNhbHRoZXJlIGhhcyBiZWVucmVzdWx0aW5nIGZyb208L2JvZHk+PC9odG1sPmhhcyBuZXZlciBiZWVudGhlIGZpcnN0IHRpbWVpbiByZXNwb25zZSB0b2F1dG9tYXRpY2FsbHkgPC9kaXY+Cgo8ZGl2IGl3YXMgY29uc2lkZXJlZHBlcmNlbnQgb2YgdGhlIiAvPjwvYT48L2Rpdj5jb2xsZWN0aW9uIG9mIGRlc2NlbmRlZCBmcm9tc2VjdGlvbiBvZiB0aGVhY2NlcHQtY2hhcnNldHRvIGJlIGNvbmZ1c2VkbWVtYmVyIG9mIHRoZSBwYWRkaW5nLXJpZ2h0OnRyYW5zbGF0aW9uIG9maW50ZXJwcmV0YXRpb24gaHJlZj0naHR0cDovL3doZXRoZXIgb3Igbm90VGhlcmUgYXJlIGFsc290aGVyZSBhcmUgbWFueWEgc21hbGwgbnVtYmVyb3RoZXIgcGFydHMgb2ZpbXBvc3NpYmxlIHRvICBjbGFzcz0iYnV0dG9ubG9jYXRlZCBpbiB0aGUuIEhvd2V2ZXIsIHRoZWFuZCBldmVudHVhbGx5QXQgdGhlIGVuZCBvZiBiZWNhdXNlIG9mIGl0c3JlcHJlc2VudHMgdGhlPGZvcm0gYWN0aW9uPSIgbWV0aG9kPSJwb3N0Iml0IGlzIHBvc3NpYmxlbW9yZSBsaWtlbHkgdG9hbiBpbmNyZWFzZSBpbmhhdmUgYWxzbyBiZWVuY29ycmVzcG9uZHMgdG9hbm5vdW5jZWQgdGhhdGFsaWduPSJyaWdodCI+bWFueSBjb3VudHJpZXNmb3IgbWFueSB5ZWFyc2VhcmxpZXN0IGtub3duYmVjYXVzZSBpdCB3YXNwdCI+PC9zY3JpcHQ+DSB2YWxpZ249InRvcCIgaW5oYWJpdGFudHMgb2Zmb2xsb3dpbmcgeWVhcg0KPGRpdiBjbGFzcz0ibWlsbGlvbiBwZW9wbGVjb250cm92ZXJzaWFsIGNvbmNlcm5pbmcgdGhlYXJndWUgdGhhdCB0aGVnb3Zlcm5tZW50IGFuZGEgcmVmZXJlbmNlIHRvdHJhbnNmZXJyZWQgdG9kZXNjcmliaW5nIHRoZSBzdHlsZT0iY29sb3I6YWx0aG91Z2ggdGhlcmViZXN0IGtub3duIGZvcnN1Ym1pdCIgbmFtZT0ibXVsdGlwbGljYXRpb25tb3JlIHRoYW4gb25lIHJlY29nbml0aW9uIG9mQ291bmNpbCBvZiB0aGVlZGl0aW9uIG9mIHRoZSAgPG1ldGEgbmFtZT0iRW50ZXJ0YWlubWVudCBhd2F5IGZyb20gdGhlIDttYXJnaW4tcmlnaHQ6YXQgdGhlIHRpbWUgb2ZpbnZlc3RpZ2F0aW9uc2Nvbm5lY3RlZCB3aXRoYW5kIG1hbnkgb3RoZXJhbHRob3VnaCBpdCBpc2JlZ2lubmluZyB3aXRoIDxzcGFuIGNsYXNzPSJkZXNjZW5kYW50cyBvZjxzcGFuIGNsYXNzPSJpIGFsaWduPSJyaWdodCI8L2hlYWQ+Cjxib2R5IGFzcGVjdHMgb2YgdGhlaGFzIHNpbmNlIGJlZW5FdXJvcGVhbiBVbmlvbnJlbWluaXNjZW50IG9mbW9yZSBkaWZmaWN1bHRWaWNlIFByZXNpZGVudGNvbXBvc2l0aW9uIG9mcGFzc2VkIHRocm91Z2htb3JlIGltcG9ydGFudGZvbnQtc2l6ZToxMXB4ZXhwbGFuYXRpb24gb2Z0aGUgY29uY2VwdCBvZndyaXR0ZW4gaW4gdGhlCTxzcGFuIGNsYXNzPSJpcyBvbmUgb2YgdGhlIHJlc2VtYmxhbmNlIHRvb24gdGhlIGdyb3VuZHN3aGljaCBjb250YWluc2luY2x1ZGluZyB0aGUgZGVmaW5lZCBieSB0aGVwdWJsaWNhdGlvbiBvZm1lYW5zIHRoYXQgdGhlb3V0c2lkZSBvZiB0aGVzdXBwb3J0IG9mIHRoZTxpbnB1dCBjbGFzcz0iPHNwYW4gY2xhc3M9InQoTWF0aC5yYW5kb20oKW1vc3QgcHJvbWluZW50ZGVzY3JpcHRpb24gb2ZDb25zdGFudGlub3BsZXdlcmUgcHVibGlzaGVkPGRpdiBjbGFzcz0ic2VhcHBlYXJzIGluIHRoZTEiIGhlaWdodD0iMSIgbW9zdCBpbXBvcnRhbnR3aGljaCBpbmNsdWRlc3doaWNoIGhhZCBiZWVuZGVzdHJ1Y3Rpb24gb2Z0aGUgcG9wdWxhdGlvbgoJPGRpdiBjbGFzcz0icG9zc2liaWxpdHkgb2Zzb21ldGltZXMgdXNlZGFwcGVhciB0byBoYXZlc3VjY2VzcyBvZiB0aGVpbnRlbmRlZCB0byBiZXByZXNlbnQgaW4gdGhlc3R5bGU9ImNsZWFyOmINCjwvc2NyaXB0Pg0KPHdhcyBmb3VuZGVkIGluaW50ZXJ2aWV3IHdpdGhfaWQiIGNvbnRlbnQ9ImNhcGl0YWwgb2YgdGhlDQo8bGluayByZWw9InNyZWxlYXNlIG9mIHRoZXBvaW50IG91dCB0aGF0eE1MSHR0cFJlcXVlc3RhbmQgc3Vic2VxdWVudHNlY29uZCBsYXJnZXN0dmVyeSBpbXBvcnRhbnRzcGVjaWZpY2F0aW9uc3N1cmZhY2Ugb2YgdGhlYXBwbGllZCB0byB0aGVmb3JlaWduIHBvbGljeV9zZXREb21haW5OYW1lZXN0YWJsaXNoZWQgaW5pcyBiZWxpZXZlZCB0b0luIGFkZGl0aW9uIHRvbWVhbmluZyBvZiB0aGVpcyBuYW1lZCBhZnRlcnRvIHByb3RlY3QgdGhlaXMgcmVwcmVzZW50ZWREZWNsYXJhdGlvbiBvZm1vcmUgZWZmaWNpZW50Q2xhc3NpZmljYXRpb25vdGhlciBmb3JtcyBvZmhlIHJldHVybmVkIHRvPHNwYW4gY2xhc3M9ImNwZXJmb3JtYW5jZSBvZihmdW5jdGlvbigpIHsNaWYgYW5kIG9ubHkgaWZyZWdpb25zIG9mIHRoZWxlYWRpbmcgdG8gdGhlcmVsYXRpb25zIHdpdGhVbml0ZWQgTmF0aW9uc3N0eWxlPSJoZWlnaHQ6b3RoZXIgdGhhbiB0aGV5cGUiIGNvbnRlbnQ9IkFzc29jaWF0aW9uIG9mCjwvaGVhZD4KPGJvZHlsb2NhdGVkIG9uIHRoZWlzIHJlZmVycmVkIHRvKGluY2x1ZGluZyB0aGVjb25jZW50cmF0aW9uc3RoZSBpbmRpdmlkdWFsYW1vbmcgdGhlIG1vc3R0aGFuIGFueSBvdGhlci8+CjxsaW5rIHJlbD0iIHJldHVybiBmYWxzZTt0aGUgcHVycG9zZSBvZnRoZSBhYmlsaXR5IHRvO2NvbG9yOiNmZmZ9Ci4KPHNwYW4gY2xhc3M9InRoZSBzdWJqZWN0IG9mZGVmaW5pdGlvbnMgb2Y+DQo8bGluayByZWw9ImNsYWltIHRoYXQgdGhlaGF2ZSBkZXZlbG9wZWQ8dGFibGUgd2lkdGg9ImNlbGVicmF0aW9uIG9mRm9sbG93aW5nIHRoZSB0byBkaXN0aW5ndWlzaDxzcGFuIGNsYXNzPSJidGFrZXMgcGxhY2UgaW51bmRlciB0aGUgbmFtZW5vdGVkIHRoYXQgdGhlPjwhW2VuZGlmXS0tPgpzdHlsZT0ibWFyZ2luLWluc3RlYWQgb2YgdGhlaW50cm9kdWNlZCB0aGV0aGUgcHJvY2VzcyBvZmluY3JlYXNpbmcgdGhlZGlmZmVyZW5jZXMgaW5lc3RpbWF0ZWQgdGhhdGVzcGVjaWFsbHkgdGhlL2Rpdj48ZGl2IGlkPSJ3YXMgZXZlbnR1YWxseXRocm91Z2hvdXQgaGlzdGhlIGRpZmZlcmVuY2Vzb21ldGhpbmcgdGhhdHNwYW4+PC9zcGFuPjwvc2lnbmlmaWNhbnRseSA+PC9zY3JpcHQ+DQoNCmVudmlyb25tZW50YWwgdG8gcHJldmVudCB0aGVoYXZlIGJlZW4gdXNlZGVzcGVjaWFsbHkgZm9ydW5kZXJzdGFuZCB0aGVpcyBlc3NlbnRpYWxseXdlcmUgdGhlIGZpcnN0aXMgdGhlIGxhcmdlc3RoYXZlIGJlZW4gbWFkZSIgc3JjPSJodHRwOi8vaW50ZXJwcmV0ZWQgYXNzZWNvbmQgaGFsZiBvZmNyb2xsaW5nPSJubyIgaXMgY29tcG9zZWQgb2ZJSSwgSG9seSBSb21hbmlzIGV4cGVjdGVkIHRvaGF2ZSB0aGVpciBvd25kZWZpbmVkIGFzIHRoZXRyYWRpdGlvbmFsbHkgaGF2ZSBkaWZmZXJlbnRhcmUgb2Z0ZW4gdXNlZHRvIGVuc3VyZSB0aGF0YWdyZWVtZW50IHdpdGhjb250YWluaW5nIHRoZWFyZSBmcmVxdWVudGx5aW5mb3JtYXRpb24gb25leGFtcGxlIGlzIHRoZXJlc3VsdGluZyBpbiBhPC9hPjwvbGk+PC91bD4gY2xhc3M9ImZvb3RlcmFuZCBlc3BlY2lhbGx5dHlwZT0iYnV0dG9uIiA8L3NwYW4+PC9zcGFuPndoaWNoIGluY2x1ZGVkPgo8bWV0YSBuYW1lPSJjb25zaWRlcmVkIHRoZWNhcnJpZWQgb3V0IGJ5SG93ZXZlciwgaXQgaXNiZWNhbWUgcGFydCBvZmluIHJlbGF0aW9uIHRvcG9wdWxhciBpbiB0aGV0aGUgY2FwaXRhbCBvZndhcyBvZmZpY2lhbGx5d2hpY2ggaGFzIGJlZW50aGUgSGlzdG9yeSBvZmFsdGVybmF0aXZlIHRvZGlmZmVyZW50IGZyb210byBzdXBwb3J0IHRoZXN1Z2dlc3RlZCB0aGF0aW4gdGhlIHByb2Nlc3MgIDxkaXYgY2xhc3M9InRoZSBmb3VuZGF0aW9uYmVjYXVzZSBvZiBoaXNjb25jZXJuZWQgd2l0aHRoZSB1bml2ZXJzaXR5b3Bwb3NlZCB0byB0aGV0aGUgY29udGV4dCBvZjxzcGFuIGNsYXNzPSJwdGV4dCIgbmFtZT0icSIJCTxkaXYgY2xhc3M9InRoZSBzY2llbnRpZmljcmVwcmVzZW50ZWQgYnltYXRoZW1hdGljaWFuc2VsZWN0ZWQgYnkgdGhldGhhdCBoYXZlIGJlZW4+PGRpdiBjbGFzcz0iY2RpdiBpZD0iaGVhZGVyaW4gcGFydGljdWxhcixjb252ZXJ0ZWQgaW50byk7Cjwvc2NyaXB0Pgo8cGhpbG9zb3BoaWNhbCBzcnBza29ocnZhdHNraXRp4bq/bmcgVmnhu4d00KDRg9GB0YHQutC40LnRgNGD0YHRgdC60LjQuWludmVzdGlnYWNpw7NucGFydGljaXBhY2nDs27QutC+0YLQvtGA0YvQtdC+0LHQu9Cw0YHRgtC40LrQvtGC0L7RgNGL0LnRh9C10LvQvtCy0LXQutGB0LjRgdGC0LXQvNGL0J3QvtCy0L7RgdGC0LjQutC+0YLQvtGA0YvRhdC+0LHQu9Cw0YHRgtGM0LLRgNC10LzQtdC90LjQutC+0YLQvtGA0LDRj9GB0LXQs9C+0LTQvdGP0YHQutCw0YfQsNGC0YzQvdC+0LLQvtGB0YLQuNCj0LrRgNCw0LjQvdGL0LLQvtC/0YDQvtGB0YvQutC+0YLQvtGA0L7QudGB0LTQtdC70LDRgtGM0L/QvtC80L7RidGM0Y7RgdGA0LXQtNGB0YLQstC+0LHRgNCw0LfQvtC80YHRgtC+0YDQvtC90YvRg9GH0LDRgdGC0LjQtdGC0LXRh9C10L3QuNC10JPQu9Cw0LLQvdCw0Y/QuNGB0YLQvtGA0LjQuNGB0LjRgdGC0LXQvNCw0YDQtdGI0LXQvdC40Y/QodC60LDRh9Cw0YLRjNC/0L7RjdGC0L7QvNGD0YHQu9C10LTRg9C10YLRgdC60LDQt9Cw0YLRjNGC0L7QstCw0YDQvtCy0LrQvtC90LXRh9C90L7RgNC10YjQtdC90LjQtdC60L7RgtC+0YDQvtC10L7RgNCz0LDQvdC+0LLQutC+0YLQvtGA0L7QvNCg0LXQutC70LDQvNCw2KfZhNmF2YbYqtiv2YnZhdmG2KrYr9mK2KfYqtin2YTZhdmI2LbZiNi52KfZhNio2LHYp9mF2KzYp9mE2YXZiNin2YLYudin2YTYsdiz2KfYptmE2YXYtNin2LHZg9in2KrYp9mE2KPYudi22KfYodin2YTYsdmK2KfYttip2KfZhNiq2LXZhdmK2YXYp9mE2KfYudi22KfYodin2YTZhtiq2KfYptis2KfZhNij2YTYudin2KjYp9mE2KrYs9is2YrZhNin2YTYo9mC2LPYp9mF2KfZhNi22LrYt9in2KrYp9mE2YHZitiv2YrZiNin2YTYqtix2K3Zitio2KfZhNis2K/Zitiv2KnYp9mE2KrYudmE2YrZhdin2YTYo9iu2KjYp9ix2KfZhNin2YHZhNin2YXYp9mE2KPZgdmE2KfZhdin2YTYqtin2LHZitiu2KfZhNiq2YLZhtmK2KnYp9mE2KfZhNi52KfYqNin2YTYrtmI2KfYt9ix2KfZhNmF2KzYqtmF2LnYp9mE2K/ZitmD2YjYsdin2YTYs9mK2KfYrdip2LnYqNiv2KfZhNmE2YfYp9mE2KrYsdio2YrYqdin2YTYsdmI2KfYqNi32KfZhNij2K/YqNmK2KnYp9mE2KfYrtio2KfYsdin2YTZhdiq2K3Yr9ip2KfZhNin2LrYp9mG2YpjdXJzb3I6cG9pbnRlcjs8L3RpdGxlPgo8bWV0YSAiIGhyZWY9Imh0dHA6Ly8iPjxzcGFuIGNsYXNzPSJtZW1iZXJzIG9mIHRoZSB3aW5kb3cubG9jYXRpb252ZXJ0aWNhbC1hbGlnbjovYT4gfCA8YSBocmVmPSI8IWRvY3R5cGUgaHRtbD5tZWRpYT0ic2NyZWVuIiA8b3B0aW9uIHZhbHVlPSJmYXZpY29uLmljbyIgLz4KCQk8ZGl2IGNsYXNzPSJjaGFyYWN0ZXJpc3RpY3MiIG1ldGhvZD0iZ2V0IiAvYm9keT4KPC9odG1sPgpzaG9ydGN1dCBpY29uIiBkb2N1bWVudC53cml0ZShwYWRkaW5nLWJvdHRvbTpyZXByZXNlbnRhdGl2ZXNzdWJtaXQiIHZhbHVlPSJhbGlnbj0iY2VudGVyIiB0aHJvdWdob3V0IHRoZSBzY2llbmNlIGZpY3Rpb24KICA8ZGl2IGNsYXNzPSJzdWJtaXQiIGNsYXNzPSJvbmUgb2YgdGhlIG1vc3QgdmFsaWduPSJ0b3AiPjx3YXMgZXN0YWJsaXNoZWQpOw0KPC9zY3JpcHQ+DQpyZXR1cm4gZmFsc2U7Ij4pLnN0eWxlLmRpc3BsYXliZWNhdXNlIG9mIHRoZSBkb2N1bWVudC5jb29raWU8Zm9ybSBhY3Rpb249Ii99Ym9keXttYXJnaW46MDtFbmN5Y2xvcGVkaWEgb2Z2ZXJzaW9uIG9mIHRoZSAuY3JlYXRlRWxlbWVudChuYW1lIiBjb250ZW50PSI8L2Rpdj4KPC9kaXY+CgphZG1pbmlzdHJhdGl2ZSA8L2JvZHk+CjwvaHRtbD5oaXN0b3J5IG9mIHRoZSAiPjxpbnB1dCB0eXBlPSJwb3J0aW9uIG9mIHRoZSBhcyBwYXJ0IG9mIHRoZSAmbmJzcDs8YSBocmVmPSJvdGhlciBjb3VudHJpZXMiPgo8ZGl2IGNsYXNzPSI8L3NwYW4+PC9zcGFuPjxJbiBvdGhlciB3b3JkcyxkaXNwbGF5OiBibG9jaztjb250cm9sIG9mIHRoZSBpbnRyb2R1Y3Rpb24gb2YvPgo8bWV0YSBuYW1lPSJhcyB3ZWxsIGFzIHRoZSBpbiByZWNlbnQgeWVhcnMNCgk8ZGl2IGNsYXNzPSI8L2Rpdj4KCTwvZGl2PgppbnNwaXJlZCBieSB0aGV0aGUgZW5kIG9mIHRoZSBjb21wYXRpYmxlIHdpdGhiZWNhbWUga25vd24gYXMgc3R5bGU9Im1hcmdpbjouanMiPjwvc2NyaXB0PjwgSW50ZXJuYXRpb25hbCB0aGVyZSBoYXZlIGJlZW5HZXJtYW4gbGFuZ3VhZ2Ugc3R5bGU9ImNvbG9yOiNDb21tdW5pc3QgUGFydHljb25zaXN0ZW50IHdpdGhib3JkZXI9IjAiIGNlbGwgbWFyZ2luaGVpZ2h0PSJ0aGUgbWFqb3JpdHkgb2YiIGFsaWduPSJjZW50ZXJyZWxhdGVkIHRvIHRoZSBtYW55IGRpZmZlcmVudCBPcnRob2RveCBDaHVyY2hzaW1pbGFyIHRvIHRoZSAvPgo8bGluayByZWw9InN3YXMgb25lIG9mIHRoZSB1bnRpbCBoaXMgZGVhdGh9KSgpOwo8L3NjcmlwdD5vdGhlciBsYW5ndWFnZXNjb21wYXJlZCB0byB0aGVwb3J0aW9ucyBvZiB0aGV0aGUgTmV0aGVybGFuZHN0aGUgbW9zdCBjb21tb25iYWNrZ3JvdW5kOnVybChhcmd1ZWQgdGhhdCB0aGVzY3JvbGxpbmc9Im5vIiBpbmNsdWRlZCBpbiB0aGVOb3J0aCBBbWVyaWNhbiB0aGUgbmFtZSBvZiB0aGVpbnRlcnByZXRhdGlvbnN0aGUgdHJhZGl0aW9uYWxkZXZlbG9wbWVudCBvZiBmcmVxdWVudGx5IHVzZWRhIGNvbGxlY3Rpb24gb2Z2ZXJ5IHNpbWlsYXIgdG9zdXJyb3VuZGluZyB0aGVleGFtcGxlIG9mIHRoaXNhbGlnbj0iY2VudGVyIj53b3VsZCBoYXZlIGJlZW5pbWFnZV9jYXB0aW9uID1hdHRhY2hlZCB0byB0aGVzdWdnZXN0aW5nIHRoYXRpbiB0aGUgZm9ybSBvZiBpbnZvbHZlZCBpbiB0aGVpcyBkZXJpdmVkIGZyb21uYW1lZCBhZnRlciB0aGVJbnRyb2R1Y3Rpb24gdG9yZXN0cmljdGlvbnMgb24gc3R5bGU9IndpZHRoOiBjYW4gYmUgdXNlZCB0byB0aGUgY3JlYXRpb24gb2Ztb3N0IGltcG9ydGFudCBpbmZvcm1hdGlvbiBhbmRyZXN1bHRlZCBpbiB0aGVjb2xsYXBzZSBvZiB0aGVUaGlzIG1lYW5zIHRoYXRlbGVtZW50cyBvZiB0aGV3YXMgcmVwbGFjZWQgYnlhbmFseXNpcyBvZiB0aGVpbnNwaXJhdGlvbiBmb3JyZWdhcmRlZCBhcyB0aGVtb3N0IHN1Y2Nlc3NmdWxrbm93biBhcyAmcXVvdDthIGNvbXByZWhlbnNpdmVIaXN0b3J5IG9mIHRoZSB3ZXJlIGNvbnNpZGVyZWRyZXR1cm5lZCB0byB0aGVhcmUgcmVmZXJyZWQgdG9VbnNvdXJjZWQgaW1hZ2U+Cgk8ZGl2IGNsYXNzPSJjb25zaXN0cyBvZiB0aGVzdG9wUHJvcGFnYXRpb25pbnRlcmVzdCBpbiB0aGVhdmFpbGFiaWxpdHkgb2ZhcHBlYXJzIHRvIGhhdmVlbGVjdHJvbWFnbmV0aWNlbmFibGVTZXJ2aWNlcyhmdW5jdGlvbiBvZiB0aGVJdCBpcyBpbXBvcnRhbnQ8L3NjcmlwdD48L2Rpdj5mdW5jdGlvbigpe3ZhciByZWxhdGl2ZSB0byB0aGVhcyBhIHJlc3VsdCBvZiB0aGUgcG9zaXRpb24gb2ZGb3IgZXhhbXBsZSwgaW4gbWV0aG9kPSJwb3N0IiB3YXMgZm9sbG93ZWQgYnkmYW1wO21kYXNoOyB0aGV0aGUgYXBwbGljYXRpb25qcyI+PC9zY3JpcHQ+DQp1bD48L2Rpdj48L2Rpdj5hZnRlciB0aGUgZGVhdGh3aXRoIHJlc3BlY3QgdG9zdHlsZT0icGFkZGluZzppcyBwYXJ0aWN1bGFybHlkaXNwbGF5OmlubGluZTsgdHlwZT0ic3VibWl0IiBpcyBkaXZpZGVkIGludG/kuK3mlocgKOeugOS9kylyZXNwb25zYWJpbGlkYWRhZG1pbmlzdHJhY2nDs25pbnRlcm5hY2lvbmFsZXNjb3JyZXNwb25kaWVudGXgpIngpKrgpK/gpYvgpJfgpKrgpYLgpLDgpY3gpLXgpLngpK7gpL7gpLDgpYfgpLLgpYvgpJfgpYvgpILgpJrgpYHgpKjgpL7gpLXgpLLgpYfgpJXgpL/gpKjgpLjgpLDgpJXgpL7gpLDgpKrgpYHgpLLgpL/gpLjgpJbgpYvgpJzgpYfgpILgpJrgpL7gpLngpL/gpI/gpK3gpYfgpJzgpYfgpILgpLbgpL7gpK7gpL/gpLLgpLngpK7gpL7gpLDgpYDgpJzgpL7gpJfgpLDgpKPgpKzgpKjgpL7gpKjgpYfgpJXgpYHgpK7gpL7gpLDgpKzgpY3gpLLgpYngpJfgpK7gpL7gpLLgpL/gpJXgpK7gpLngpL/gpLLgpL7gpKrgpYPgpLfgpY3gpKDgpKzgpKLgpLzgpKTgpYfgpK3gpL7gpJzgpKrgpL7gpJXgpY3gpLLgpL/gpJXgpJ/gpY3gpLDgpYfgpKjgpJbgpL/gpLLgpL7gpKvgpKbgpYzgpLDgpL7gpKjgpK7gpL7gpK7gpLLgpYfgpK7gpKTgpKbgpL7gpKjgpKzgpL7gpJzgpL7gpLDgpLXgpL/gpJXgpL7gpLjgpJXgpY3gpK/gpYvgpILgpJrgpL7gpLngpKTgpYfgpKrgpLngpYHgpIHgpJrgpKzgpKTgpL7gpK/gpL7gpLjgpILgpLXgpL7gpKbgpKbgpYfgpJbgpKjgpYfgpKrgpL/gpJvgpLLgpYfgpLXgpL/gpLbgpYfgpLfgpLDgpL7gpJzgpY3gpK/gpIngpKTgpY3gpKTgpLDgpK7gpYHgpILgpKzgpIjgpKbgpYvgpKjgpYvgpILgpIngpKrgpJXgpLDgpKPgpKrgpKLgpLzgpYfgpILgpLjgpY3gpKXgpL/gpKTgpKvgpL/gpLLgpY3gpK7gpK7gpYHgpJbgpY3gpK/gpIXgpJrgpY3gpJvgpL7gpJvgpYLgpJ/gpKTgpYDgpLjgpILgpJfgpYDgpKTgpJzgpL7gpI/gpJfgpL7gpLXgpL/gpK3gpL7gpJfgpJjgpKPgpY3gpJ/gpYfgpKbgpYLgpLjgpLDgpYfgpKbgpL/gpKjgpYvgpILgpLngpKTgpY3gpK/gpL7gpLjgpYfgpJXgpY3gpLjgpJfgpL7gpILgpKfgpYDgpLXgpL/gpLbgpY3gpLXgpLDgpL7gpKTgpYfgpILgpKbgpYjgpJ/gpY3gpLjgpKjgpJXgpY3gpLbgpL7gpLjgpL7gpK7gpKjgpYfgpIXgpKbgpL7gpLLgpKTgpKzgpL/gpJzgpLLgpYDgpKrgpYHgpLDgpYLgpLfgpLngpL/gpILgpKbgpYDgpK7gpL/gpKTgpY3gpLDgpJXgpLXgpL/gpKTgpL7gpLDgpYHgpKrgpK/gpYfgpLjgpY3gpKXgpL7gpKjgpJXgpLDgpYvgpKHgpLzgpK7gpYHgpJXgpY3gpKTgpK/gpYvgpJzgpKjgpL7gpJXgpYPgpKrgpK/gpL7gpKrgpYvgpLjgpY3gpJ/gpJjgpLDgpYfgpLLgpYLgpJXgpL7gpLDgpY3gpK/gpLXgpL/gpJrgpL7gpLDgpLjgpYLgpJrgpKjgpL7gpK7gpYLgpLLgpY3gpK/gpKbgpYfgpJbgpYfgpILgpLngpK7gpYfgpLbgpL7gpLjgpY3gpJXgpYLgpLLgpK7gpYjgpILgpKjgpYfgpKTgpYjgpK/gpL7gpLDgpJzgpL/gpLjgpJXgpYdyc3MreG1sIiB0aXRsZT0iLXR5cGUiIGNvbnRlbnQ9InRpdGxlIiBjb250ZW50PSJhdCB0aGUgc2FtZSB0aW1lLmpzIj48L3NjcmlwdD4KPCIgbWV0aG9kPSJwb3N0IiA8L3NwYW4+PC9hPjwvbGk+dmVydGljYWwtYWxpZ246dC9qcXVlcnkubWluLmpzIj4uY2xpY2soZnVuY3Rpb24oIHN0eWxlPSJwYWRkaW5nLX0pKCk7Cjwvc2NyaXB0Pgo8L3NwYW4+PGEgaHJlZj0iPGEgaHJlZj0iaHR0cDovLyk7IHJldHVybiBmYWxzZTt0ZXh0LWRlY29yYXRpb246IHNjcm9sbGluZz0ibm8iIGJvcmRlci1jb2xsYXBzZTphc3NvY2lhdGVkIHdpdGggQmFoYXNhIEluZG9uZXNpYUVuZ2xpc2ggbGFuZ3VhZ2U8dGV4dCB4bWw6c3BhY2U9LmdpZiIgYm9yZGVyPSIwIjwvYm9keT4KPC9odG1sPgpvdmVyZmxvdzpoaWRkZW47aW1nIHNyYz0iaHR0cDovL2FkZEV2ZW50TGlzdGVuZXJyZXNwb25zaWJsZSBmb3Igcy5qcyI+PC9zY3JpcHQ+Ci9mYXZpY29uLmljbyIgLz5vcGVyYXRpbmcgc3lzdGVtIiBzdHlsZT0id2lkdGg6MXRhcmdldD0iX2JsYW5rIj5TdGF0ZSBVbml2ZXJzaXR5dGV4dC1hbGlnbjpsZWZ0Owpkb2N1bWVudC53cml0ZSgsIGluY2x1ZGluZyB0aGUgYXJvdW5kIHRoZSB3b3JsZCk7DQo8L3NjcmlwdD4NCjwiIHN0eWxlPSJoZWlnaHQ6O292ZXJmbG93OmhpZGRlbm1vcmUgaW5mb3JtYXRpb25hbiBpbnRlcm5hdGlvbmFsYSBtZW1iZXIgb2YgdGhlIG9uZSBvZiB0aGUgZmlyc3RjYW4gYmUgZm91bmQgaW4gPC9kaXY+CgkJPC9kaXY+CmRpc3BsYXk6IG5vbmU7Ij4iIC8+CjxsaW5rIHJlbD0iCiAgKGZ1bmN0aW9uKCkge3RoZSAxNXRoIGNlbnR1cnkucHJldmVudERlZmF1bHQobGFyZ2UgbnVtYmVyIG9mIEJ5emFudGluZSBFbXBpcmUuanBnfHRodW1ifGxlZnR8dmFzdCBtYWpvcml0eSBvZm1ham9yaXR5IG9mIHRoZSAgYWxpZ249ImNlbnRlciI+VW5pdmVyc2l0eSBQcmVzc2RvbWluYXRlZCBieSB0aGVTZWNvbmQgV29ybGQgV2FyZGlzdHJpYnV0aW9uIG9mIHN0eWxlPSJwb3NpdGlvbjp0aGUgcmVzdCBvZiB0aGUgY2hhcmFjdGVyaXplZCBieSByZWw9Im5vZm9sbG93Ij5kZXJpdmVzIGZyb20gdGhlcmF0aGVyIHRoYW4gdGhlIGEgY29tYmluYXRpb24gb2ZzdHlsZT0id2lkdGg6MTAwRW5nbGlzaC1zcGVha2luZ2NvbXB1dGVyIHNjaWVuY2Vib3JkZXI9IjAiIGFsdD0idGhlIGV4aXN0ZW5jZSBvZkRlbW9jcmF0aWMgUGFydHkiIHN0eWxlPSJtYXJnaW4tRm9yIHRoaXMgcmVhc29uLC5qcyI+PC9zY3JpcHQ+CglzQnlUYWdOYW1lKHMpWzBdanMiPjwvc2NyaXB0Pg0KPC5qcyI+PC9zY3JpcHQ+DQpsaW5rIHJlbD0iaWNvbiIgJyBhbHQ9JycgY2xhc3M9J2Zvcm1hdGlvbiBvZiB0aGV2ZXJzaW9ucyBvZiB0aGUgPC9hPjwvZGl2PjwvZGl2Pi9wYWdlPgogIDxwYWdlPgo8ZGl2IGNsYXNzPSJjb250YmVjYW1lIHRoZSBmaXJzdGJhaGFzYSBJbmRvbmVzaWFlbmdsaXNoIChzaW1wbGUpzpXOu867zrfOvc65zrrOrNGF0YDQstCw0YLRgdC60LjQutC+0LzQv9Cw0L3QuNC40Y/QstC70Y/QtdGC0YHRj9CU0L7QsdCw0LLQuNGC0YzRh9C10LvQvtCy0LXQutCw0YDQsNC30LLQuNGC0LjRj9CY0L3RgtC10YDQvdC10YLQntGC0LLQtdGC0LjRgtGM0L3QsNC/0YDQuNC80LXRgNC40L3RgtC10YDQvdC10YLQutC+0YLQvtGA0L7Qs9C+0YHRgtGA0LDQvdC40YbRi9C60LDRh9C10YHRgtCy0LXRg9GB0LvQvtCy0LjRj9GF0L/RgNC+0LHQu9C10LzRi9C/0L7Qu9GD0YfQuNGC0YzRj9Cy0LvRj9GO0YLRgdGP0L3QsNC40LHQvtC70LXQtdC60L7QvNC/0LDQvdC40Y/QstC90LjQvNCw0L3QuNC10YHRgNC10LTRgdGC0LLQsNin2YTZhdmI2KfYttmK2LnYp9mE2LHYptmK2LPZitip2KfZhNin2YbYqtmC2KfZhNmF2LTYp9ix2YPYp9iq2YPYp9mE2LPZitin2LHYp9iq2KfZhNmF2YPYqtmI2KjYqdin2YTYs9i52YjYr9mK2KnYp9it2LXYp9im2YrYp9iq2KfZhNi52KfZhNmF2YrYqdin2YTYtdmI2KrZitin2KrYp9mE2KfZhtiq2LHZhtiq2KfZhNiq2LXYp9mF2YrZhdin2YTYpdiz2YTYp9mF2YrYp9mE2YXYtNin2LHZg9ip2KfZhNmF2LHYptmK2KfYqnJvYm90cyIgY29udGVudD0iPGRpdiBpZD0iZm9vdGVyIj50aGUgVW5pdGVkIFN0YXRlczxpbWcgc3JjPSJodHRwOi8vLmpwZ3xyaWdodHx0aHVtYnwuanMiPjwvc2NyaXB0Pg0KPGxvY2F0aW9uLnByb3RvY29sZnJhbWVib3JkZXI9IjAiIHMiIC8+CjxtZXRhIG5hbWU9IjwvYT48L2Rpdj48L2Rpdj48Zm9udC13ZWlnaHQ6Ym9sZDsmcXVvdDsgYW5kICZxdW90O2RlcGVuZGluZyBvbiB0aGUgbWFyZ2luOjA7cGFkZGluZzoiIHJlbD0ibm9mb2xsb3ciIFByZXNpZGVudCBvZiB0aGUgdHdlbnRpZXRoIGNlbnR1cnlldmlzaW9uPgogIDwvcGFnZUludGVybmV0IEV4cGxvcmVyYS5hc3luYyA9IHRydWU7DQppbmZvcm1hdGlvbiBhYm91dDxkaXYgaWQ9ImhlYWRlciI+IiBhY3Rpb249Imh0dHA6Ly88YSBocmVmPSJodHRwczovLzxkaXYgaWQ9ImNvbnRlbnQiPC9kaXY+DQo8L2Rpdj4NCjxkZXJpdmVkIGZyb20gdGhlIDxpbWcgc3JjPSdodHRwOi8vYWNjb3JkaW5nIHRvIHRoZSAKPC9ib2R5Pgo8L2h0bWw+CnN0eWxlPSJmb250LXNpemU6c2NyaXB0IGxhbmd1YWdlPSJBcmlhbCwgSGVsdmV0aWNhLDwvYT48c3BhbiBjbGFzcz0iPC9zY3JpcHQ+PHNjcmlwdCBwb2xpdGljYWwgcGFydGllc3RkPjwvdHI+PC90YWJsZT48aHJlZj0iaHR0cDovL3d3dy5pbnRlcnByZXRhdGlvbiBvZnJlbD0ic3R5bGVzaGVldCIgZG9jdW1lbnQud3JpdGUoJzxjaGFyc2V0PSJ1dGYtOCI+CmJlZ2lubmluZyBvZiB0aGUgcmV2ZWFsZWQgdGhhdCB0aGV0ZWxldmlzaW9uIHNlcmllcyIgcmVsPSJub2ZvbGxvdyI+IHRhcmdldD0iX2JsYW5rIj5jbGFpbWluZyB0aGF0IHRoZWh0dHAlM0ElMkYlMkZ3d3cubWFuaWZlc3RhdGlvbnMgb2ZQcmltZSBNaW5pc3RlciBvZmluZmx1ZW5jZWQgYnkgdGhlY2xhc3M9ImNsZWFyZml4Ij4vZGl2Pg0KPC9kaXY+DQoNCnRocmVlLWRpbWVuc2lvbmFsQ2h1cmNoIG9mIEVuZ2xhbmRvZiBOb3J0aCBDYXJvbGluYXNxdWFyZSBraWxvbWV0cmVzLmFkZEV2ZW50TGlzdGVuZXJkaXN0aW5jdCBmcm9tIHRoZWNvbW1vbmx5IGtub3duIGFzUGhvbmV0aWMgQWxwaGFiZXRkZWNsYXJlZCB0aGF0IHRoZWNvbnRyb2xsZWQgYnkgdGhlQmVuamFtaW4gRnJhbmtsaW5yb2xlLXBsYXlpbmcgZ2FtZXRoZSBVbml2ZXJzaXR5IG9maW4gV2VzdGVybiBFdXJvcGVwZXJzb25hbCBjb21wdXRlclByb2plY3QgR3V0ZW5iZXJncmVnYXJkbGVzcyBvZiB0aGVoYXMgYmVlbiBwcm9wb3NlZHRvZ2V0aGVyIHdpdGggdGhlPjwvbGk+PGxpIGNsYXNzPSJpbiBzb21lIGNvdW50cmllc21pbi5qcyI+PC9zY3JpcHQ+b2YgdGhlIHBvcHVsYXRpb25vZmZpY2lhbCBsYW5ndWFnZTxpbWcgc3JjPSJpbWFnZXMvaWRlbnRpZmllZCBieSB0aGVuYXR1cmFsIHJlc291cmNlc2NsYXNzaWZpY2F0aW9uIG9mY2FuIGJlIGNvbnNpZGVyZWRxdWFudHVtIG1lY2hhbmljc05ldmVydGhlbGVzcywgdGhlbWlsbGlvbiB5ZWFycyBhZ288L2JvZHk+DQo8L2h0bWw+Dc6VzrvOu863zr3Ouc66zqwKdGFrZSBhZHZhbnRhZ2Ugb2ZhbmQsIGFjY29yZGluZyB0b2F0dHJpYnV0ZWQgdG8gdGhlTWljcm9zb2Z0IFdpbmRvd3N0aGUgZmlyc3QgY2VudHVyeXVuZGVyIHRoZSBjb250cm9sZGl2IGNsYXNzPSJoZWFkZXJzaG9ydGx5IGFmdGVyIHRoZW5vdGFibGUgZXhjZXB0aW9udGVucyBvZiB0aG91c2FuZHNzZXZlcmFsIGRpZmZlcmVudGFyb3VuZCB0aGUgd29ybGQucmVhY2hpbmcgbWlsaXRhcnlpc29sYXRlZCBmcm9tIHRoZW9wcG9zaXRpb24gdG8gdGhldGhlIE9sZCBUZXN0YW1lbnRBZnJpY2FuIEFtZXJpY2Fuc2luc2VydGVkIGludG8gdGhlc2VwYXJhdGUgZnJvbSB0aGVtZXRyb3BvbGl0YW4gYXJlYW1ha2VzIGl0IHBvc3NpYmxlYWNrbm93bGVkZ2VkIHRoYXRhcmd1YWJseSB0aGUgbW9zdHR5cGU9InRleHQvY3NzIj4KdGhlIEludGVybmF0aW9uYWxBY2NvcmRpbmcgdG8gdGhlIHBlPSJ0ZXh0L2NzcyIgLz4KY29pbmNpZGUgd2l0aCB0aGV0d28tdGhpcmRzIG9mIHRoZUR1cmluZyB0aGlzIHRpbWUsZHVyaW5nIHRoZSBwZXJpb2Rhbm5vdW5jZWQgdGhhdCBoZXRoZSBpbnRlcm5hdGlvbmFsYW5kIG1vcmUgcmVjZW50bHliZWxpZXZlZCB0aGF0IHRoZWNvbnNjaW91c25lc3MgYW5kZm9ybWVybHkga25vd24gYXNzdXJyb3VuZGVkIGJ5IHRoZWZpcnN0IGFwcGVhcmVkIGlub2NjYXNpb25hbGx5IHVzZWRwb3NpdGlvbjphYnNvbHV0ZTsiIHRhcmdldD0iX2JsYW5rIiBwb3NpdGlvbjpyZWxhdGl2ZTt0ZXh0LWFsaWduOmNlbnRlcjtqYXgvbGlicy9qcXVlcnkvMS5iYWNrZ3JvdW5kLWNvbG9yOiN0eXBlPSJhcHBsaWNhdGlvbi9hbmd1YWdlIiBjb250ZW50PSI8bWV0YSBodHRwLWVxdWl2PSJQcml2YWN5IFBvbGljeTwvYT5lKCIlM0NzY3JpcHQgc3JjPSciIHRhcmdldD0iX2JsYW5rIj5PbiB0aGUgb3RoZXIgaGFuZCwuanBnfHRodW1ifHJpZ2h0fDI8L2Rpdj48ZGl2IGNsYXNzPSI8ZGl2IHN0eWxlPSJmbG9hdDpuaW5ldGVlbnRoIGNlbnR1cnk8L2JvZHk+DQo8L2h0bWw+DQo8aW1nIHNyYz0iaHR0cDovL3M7dGV4dC1hbGlnbjpjZW50ZXJmb250LXdlaWdodDogYm9sZDsgQWNjb3JkaW5nIHRvIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4iIGZyYW1lYm9yZGVyPSIwIiAiIHN0eWxlPSJwb3NpdGlvbjpsaW5rIGhyZWY9Imh0dHA6Ly9odG1sNC9sb29zZS5kdGQiPgpkdXJpbmcgdGhpcyBwZXJpb2Q8L3RkPjwvdHI+PC90YWJsZT5jbG9zZWx5IHJlbGF0ZWQgdG9mb3IgdGhlIGZpcnN0IHRpbWU7Zm9udC13ZWlnaHQ6Ym9sZDtpbnB1dCB0eXBlPSJ0ZXh0IiA8c3BhbiBzdHlsZT0iZm9udC1vbnJlYWR5c3RhdGVjaGFuZ2UJPGRpdiBjbGFzcz0iY2xlYXJkb2N1bWVudC5sb2NhdGlvbi4gRm9yIGV4YW1wbGUsIHRoZSBhIHdpZGUgdmFyaWV0eSBvZiA8IURPQ1RZUEUgaHRtbD4NCjwmbmJzcDsmbmJzcDsmbmJzcDsiPjxhIGhyZWY9Imh0dHA6Ly9zdHlsZT0iZmxvYXQ6bGVmdDtjb25jZXJuZWQgd2l0aCB0aGU9aHR0cCUzQSUyRiUyRnd3dy5pbiBwb3B1bGFyIGN1bHR1cmV0eXBlPSJ0ZXh0L2NzcyIgLz5pdCBpcyBwb3NzaWJsZSB0byBIYXJ2YXJkIFVuaXZlcnNpdHl0eWxlc2hlZXQiIGhyZWY9Ii90aGUgbWFpbiBjaGFyYWN0ZXJPeGZvcmQgVW5pdmVyc2l0eSAgbmFtZT0ia2V5d29yZHMiIGNzdHlsZT0idGV4dC1hbGlnbjp0aGUgVW5pdGVkIEtpbmdkb21mZWRlcmFsIGdvdmVybm1lbnQ8ZGl2IHN0eWxlPSJtYXJnaW4gZGVwZW5kaW5nIG9uIHRoZSBkZXNjcmlwdGlvbiBvZiB0aGU8ZGl2IGNsYXNzPSJoZWFkZXIubWluLmpzIj48L3NjcmlwdD5kZXN0cnVjdGlvbiBvZiB0aGVzbGlnaHRseSBkaWZmZXJlbnRpbiBhY2NvcmRhbmNlIHdpdGh0ZWxlY29tbXVuaWNhdGlvbnNpbmRpY2F0ZXMgdGhhdCB0aGVzaG9ydGx5IHRoZXJlYWZ0ZXJlc3BlY2lhbGx5IGluIHRoZSBFdXJvcGVhbiBjb3VudHJpZXNIb3dldmVyLCB0aGVyZSBhcmVzcmM9Imh0dHA6Ly9zdGF0aWNzdWdnZXN0ZWQgdGhhdCB0aGUiIHNyYz0iaHR0cDovL3d3dy5hIGxhcmdlIG51bWJlciBvZiBUZWxlY29tbXVuaWNhdGlvbnMiIHJlbD0ibm9mb2xsb3ciIHRIb2x5IFJvbWFuIEVtcGVyb3JhbG1vc3QgZXhjbHVzaXZlbHkiIGJvcmRlcj0iMCIgYWx0PSJTZWNyZXRhcnkgb2YgU3RhdGVjdWxtaW5hdGluZyBpbiB0aGVDSUEgV29ybGQgRmFjdGJvb2t0aGUgbW9zdCBpbXBvcnRhbnRhbm5pdmVyc2FyeSBvZiB0aGVzdHlsZT0iYmFja2dyb3VuZC08bGk+PGVtPjxhIGhyZWY9Ii90aGUgQXRsYW50aWMgT2NlYW5zdHJpY3RseSBzcGVha2luZyxzaG9ydGx5IGJlZm9yZSB0aGVkaWZmZXJlbnQgdHlwZXMgb2Z0aGUgT3R0b21hbiBFbXBpcmU+PGltZyBzcmM9Imh0dHA6Ly9BbiBJbnRyb2R1Y3Rpb24gdG9jb25zZXF1ZW5jZSBvZiB0aGVkZXBhcnR1cmUgZnJvbSB0aGVDb25mZWRlcmF0ZSBTdGF0ZXNpbmRpZ2Vub3VzIHBlb3BsZXNQcm9jZWVkaW5ncyBvZiB0aGVpbmZvcm1hdGlvbiBvbiB0aGV0aGVvcmllcyBoYXZlIGJlZW5pbnZvbHZlbWVudCBpbiB0aGVkaXZpZGVkIGludG8gdGhyZWVhZGphY2VudCBjb3VudHJpZXNpcyByZXNwb25zaWJsZSBmb3JkaXNzb2x1dGlvbiBvZiB0aGVjb2xsYWJvcmF0aW9uIHdpdGh3aWRlbHkgcmVnYXJkZWQgYXNoaXMgY29udGVtcG9yYXJpZXNmb3VuZGluZyBtZW1iZXIgb2ZEb21pbmljYW4gUmVwdWJsaWNnZW5lcmFsbHkgYWNjZXB0ZWR0aGUgcG9zc2liaWxpdHkgb2ZhcmUgYWxzbyBhdmFpbGFibGV1bmRlciBjb25zdHJ1Y3Rpb25yZXN0b3JhdGlvbiBvZiB0aGV0aGUgZ2VuZXJhbCBwdWJsaWNpcyBhbG1vc3QgZW50aXJlbHlwYXNzZXMgdGhyb3VnaCB0aGVoYXMgYmVlbiBzdWdnZXN0ZWRjb21wdXRlciBhbmQgdmlkZW9HZXJtYW5pYyBsYW5ndWFnZXMgYWNjb3JkaW5nIHRvIHRoZSBkaWZmZXJlbnQgZnJvbSB0aGVzaG9ydGx5IGFmdGVyd2FyZHNocmVmPSJodHRwczovL3d3dy5yZWNlbnQgZGV2ZWxvcG1lbnRCb2FyZCBvZiBEaXJlY3RvcnM8ZGl2IGNsYXNzPSJzZWFyY2h8IDxhIGhyZWY9Imh0dHA6Ly9JbiBwYXJ0aWN1bGFyLCB0aGVNdWx0aXBsZSBmb290bm90ZXNvciBvdGhlciBzdWJzdGFuY2V0aG91c2FuZHMgb2YgeWVhcnN0cmFuc2xhdGlvbiBvZiB0aGU8L2Rpdj4NCjwvZGl2Pg0KDQo8YSBocmVmPSJpbmRleC5waHB3YXMgZXN0YWJsaXNoZWQgaW5taW4uanMiPjwvc2NyaXB0PgpwYXJ0aWNpcGF0ZSBpbiB0aGVhIHN0cm9uZyBpbmZsdWVuY2VzdHlsZT0ibWFyZ2luLXRvcDpyZXByZXNlbnRlZCBieSB0aGVncmFkdWF0ZWQgZnJvbSB0aGVUcmFkaXRpb25hbGx5LCB0aGVFbGVtZW50KCJzY3JpcHQiKTtIb3dldmVyLCBzaW5jZSB0aGUvZGl2Pgo8L2Rpdj4KPGRpdiBsZWZ0OyBtYXJnaW4tbGVmdDpwcm90ZWN0aW9uIGFnYWluc3QwOyB2ZXJ0aWNhbC1hbGlnbjpVbmZvcnR1bmF0ZWx5LCB0aGV0eXBlPSJpbWFnZS94LWljb24vZGl2Pgo8ZGl2IGNsYXNzPSIgY2xhc3M9ImNsZWFyZml4Ij48ZGl2IGNsYXNzPSJmb290ZXIJCTwvZGl2PgoJCTwvZGl2Pgp0aGUgbW90aW9uIHBpY3R1cmXQkdGK0LvQs9Cw0YDRgdC60LjQsdGK0LvQs9Cw0YDRgdC60LjQpNC10LTQtdGA0LDRhtC40LjQvdC10YHQutC+0LvRjNC60L7RgdC+0L7QsdGJ0LXQvdC40LXRgdC+0L7QsdGJ0LXQvdC40Y/Qv9GA0L7Qs9GA0LDQvNC80YvQntGC0L/RgNCw0LLQuNGC0YzQsdC10YHQv9C70LDRgtC90L7QvNCw0YLQtdGA0LjQsNC70YvQv9C+0LfQstC+0LvRj9C10YLQv9C+0YHQu9C10LTQvdC40LXRgNCw0LfQu9C40YfQvdGL0YXQv9GA0L7QtNGD0LrRhtC40LjQv9GA0L7Qs9GA0LDQvNC80LDQv9C+0LvQvdC+0YHRgtGM0Y7QvdCw0YXQvtC00LjRgtGB0Y/QuNC30LHRgNCw0L3QvdC+0LXQvdCw0YHQtdC70LXQvdC40Y/QuNC30LzQtdC90LXQvdC40Y/QutCw0YLQtdCz0L7RgNC40LjQkNC70LXQutGB0LDQvdC00YDgpKbgpY3gpLXgpL7gpLDgpL7gpK7gpYjgpKjgpYHgpIXgpLLgpKrgpY3gpLDgpKbgpL7gpKjgpK3gpL7gpLDgpKTgpYDgpK/gpIXgpKjgpYHgpKbgpYfgpLbgpLngpL/gpKjgpY3gpKbgpYDgpIfgpILgpKHgpL/gpK/gpL7gpKbgpL/gpLLgpY3gpLLgpYDgpIXgpKfgpL/gpJXgpL7gpLDgpLXgpYDgpKHgpL/gpK/gpYvgpJrgpL/gpJ/gpY3gpKDgpYfgpLjgpK7gpL7gpJrgpL7gpLDgpJzgpILgpJXgpY3gpLbgpKjgpKbgpYHgpKjgpL/gpK/gpL7gpKrgpY3gpLDgpK/gpYvgpJfgpIXgpKjgpYHgpLjgpL7gpLDgpJHgpKjgpLLgpL7gpIfgpKjgpKrgpL7gpLDgpY3gpJ/gpYDgpLbgpLDgpY3gpKTgpYvgpILgpLLgpYvgpJXgpLjgpK3gpL7gpKvgpLzgpY3gpLLgpYjgpLbgpLbgpLDgpY3gpKTgpYfgpILgpKrgpY3gpLDgpKbgpYfgpLbgpKrgpY3gpLLgpYfgpK/gpLDgpJXgpYfgpILgpKbgpY3gpLDgpLjgpY3gpKXgpL/gpKTgpL/gpIngpKTgpY3gpKrgpL7gpKbgpIngpKjgpY3gpLngpYfgpILgpJrgpL/gpJ/gpY3gpKDgpL7gpK/gpL7gpKTgpY3gpLDgpL7gpJzgpY3gpK/gpL7gpKbgpL7gpKrgpYHgpLDgpL7gpKjgpYfgpJzgpYvgpKHgpLzgpYfgpILgpIXgpKjgpYHgpLXgpL7gpKbgpLbgpY3gpLDgpYfgpKPgpYDgpLbgpL/gpJXgpY3gpLfgpL7gpLjgpLDgpJXgpL7gpLDgpYDgpLjgpILgpJfgpY3gpLDgpLngpKrgpLDgpL/gpKPgpL7gpK7gpKzgpY3gpLDgpL7gpILgpKHgpKzgpJrgpY3gpJrgpYvgpILgpIngpKrgpLLgpKzgpY3gpKfgpK7gpILgpKTgpY3gpLDgpYDgpLjgpILgpKrgpLDgpY3gpJXgpIngpK7gpY3gpK7gpYDgpKbgpK7gpL7gpKfgpY3gpK/gpK7gpLjgpLngpL7gpK/gpKTgpL7gpLbgpKzgpY3gpKbgpYvgpILgpK7gpYDgpKHgpL/gpK/gpL7gpIbgpIjgpKrgpYDgpI/gpLLgpK7gpYvgpKzgpL7gpIfgpLLgpLjgpILgpJbgpY3gpK/gpL7gpIbgpKrgpLDgpYfgpLbgpKjgpIXgpKjgpYHgpKzgpILgpKfgpKzgpL7gpJzgpLzgpL7gpLDgpKjgpLXgpYDgpKjgpKTgpK7gpKrgpY3gpLDgpK7gpYHgpJbgpKrgpY3gpLDgpLbgpY3gpKjgpKrgpLDgpL/gpLXgpL7gpLDgpKjgpYHgpJXgpLjgpL7gpKjgpLjgpK7gpLDgpY3gpKXgpKjgpIbgpK/gpYvgpJzgpL/gpKTgpLjgpYvgpK7gpLXgpL7gpLDYp9mE2YXYtNin2LHZg9in2KrYp9mE2YXZhtiq2K/Zitin2KrYp9mE2YPZhdio2YrZiNiq2LHYp9mE2YXYtNin2YfYr9in2KrYudiv2K/Yp9mE2LLZiNin2LHYudiv2K/Yp9mE2LHYr9mI2K/Yp9mE2KXYs9mE2KfZhdmK2KnYp9mE2YHZiNiq2YjYtNmI2KjYp9mE2YXYs9in2KjZgtin2KrYp9mE2YXYudmE2YjZhdin2KrYp9mE2YXYs9mE2LPZhNin2KrYp9mE2KzYsdin2YHZitmD2LPYp9mE2KfYs9mE2KfZhdmK2KnYp9mE2KfYqti12KfZhNin2KprZXl3b3JkcyIgY29udGVudD0idzMub3JnLzE5OTkveGh0bWwiPjxhIHRhcmdldD0iX2JsYW5rIiB0ZXh0L2h0bWw7IGNoYXJzZXQ9IiB0YXJnZXQ9Il9ibGFuayI+PHRhYmxlIGNlbGxwYWRkaW5nPSJhdXRvY29tcGxldGU9Im9mZiIgdGV4dC1hbGlnbjogY2VudGVyO3RvIGxhc3QgdmVyc2lvbiBieSBiYWNrZ3JvdW5kLWNvbG9yOiAjIiBocmVmPSJodHRwOi8vd3d3Li9kaXY+PC9kaXY+PGRpdiBpZD08YSBocmVmPSIjIiBjbGFzcz0iIj48aW1nIHNyYz0iaHR0cDovL2NyaXB0IiBzcmM9Imh0dHA6Ly8KPHNjcmlwdCBsYW5ndWFnZT0iLy9FTiIgImh0dHA6Ly93d3cud2VuY29kZVVSSUNvbXBvbmVudCgiIGhyZWY9ImphdmFzY3JpcHQ6PGRpdiBjbGFzcz0iY29udGVudGRvY3VtZW50LndyaXRlKCc8c2Nwb3NpdGlvbjogYWJzb2x1dGU7c2NyaXB0IHNyYz0iaHR0cDovLyBzdHlsZT0ibWFyZ2luLXRvcDoubWluLmpzIj48L3NjcmlwdD4KPC9kaXY+CjxkaXYgY2xhc3M9InczLm9yZy8xOTk5L3hodG1sIiAKDQo8L2JvZHk+DQo8L2h0bWw+ZGlzdGluY3Rpb24gYmV0d2Vlbi8iIHRhcmdldD0iX2JsYW5rIj48bGluayBocmVmPSJodHRwOi8vZW5jb2Rpbmc9InV0Zi04Ij8+CncuYWRkRXZlbnRMaXN0ZW5lcj9hY3Rpb249Imh0dHA6Ly93d3cuaWNvbiIgaHJlZj0iaHR0cDovLyBzdHlsZT0iYmFja2dyb3VuZDp0eXBlPSJ0ZXh0L2NzcyIgLz4KbWV0YSBwcm9wZXJ0eT0ib2c6dDxpbnB1dCB0eXBlPSJ0ZXh0IiAgc3R5bGU9InRleHQtYWxpZ246dGhlIGRldmVsb3BtZW50IG9mIHR5bGVzaGVldCIgdHlwZT0idGVodG1sOyBjaGFyc2V0PXV0Zi04aXMgY29uc2lkZXJlZCB0byBiZXRhYmxlIHdpZHRoPSIxMDAlIiBJbiBhZGRpdGlvbiB0byB0aGUgY29udHJpYnV0ZWQgdG8gdGhlIGRpZmZlcmVuY2VzIGJldHdlZW5kZXZlbG9wbWVudCBvZiB0aGUgSXQgaXMgaW1wb3J0YW50IHRvIDwvc2NyaXB0PgoKPHNjcmlwdCAgc3R5bGU9ImZvbnQtc2l6ZToxPjwvc3Bhbj48c3BhbiBpZD1nYkxpYnJhcnkgb2YgQ29uZ3Jlc3M8aW1nIHNyYz0iaHR0cDovL2ltRW5nbGlzaCB0cmFuc2xhdGlvbkFjYWRlbXkgb2YgU2NpZW5jZXNkaXYgc3R5bGU9ImRpc3BsYXk6Y29uc3RydWN0aW9uIG9mIHRoZS5nZXRFbGVtZW50QnlJZChpZClpbiBjb25qdW5jdGlvbiB3aXRoRWxlbWVudCgnc2NyaXB0Jyk7IDxtZXRhIHByb3BlcnR5PSJvZzrQkdGK0LvQs9Cw0YDRgdC60LgKIHR5cGU9InRleHQiIG5hbWU9Ij5Qcml2YWN5IFBvbGljeTwvYT5hZG1pbmlzdGVyZWQgYnkgdGhlZW5hYmxlU2luZ2xlUmVxdWVzdHN0eWxlPSZxdW90O21hcmdpbjo8L2Rpdj48L2Rpdj48L2Rpdj48PjxpbWcgc3JjPSJodHRwOi8vaSBzdHlsZT0mcXVvdDtmbG9hdDpyZWZlcnJlZCB0byBhcyB0aGUgdG90YWwgcG9wdWxhdGlvbiBvZmluIFdhc2hpbmd0b24sIEQuQy4gc3R5bGU9ImJhY2tncm91bmQtYW1vbmcgb3RoZXIgdGhpbmdzLG9yZ2FuaXphdGlvbiBvZiB0aGVwYXJ0aWNpcGF0ZWQgaW4gdGhldGhlIGludHJvZHVjdGlvbiBvZmlkZW50aWZpZWQgd2l0aCB0aGVmaWN0aW9uYWwgY2hhcmFjdGVyIE94Zm9yZCBVbml2ZXJzaXR5IG1pc3VuZGVyc3RhbmRpbmcgb2ZUaGVyZSBhcmUsIGhvd2V2ZXIsc3R5bGVzaGVldCIgaHJlZj0iL0NvbHVtYmlhIFVuaXZlcnNpdHlleHBhbmRlZCB0byBpbmNsdWRldXN1YWxseSByZWZlcnJlZCB0b2luZGljYXRpbmcgdGhhdCB0aGVoYXZlIHN1Z2dlc3RlZCB0aGF0YWZmaWxpYXRlZCB3aXRoIHRoZWNvcnJlbGF0aW9uIGJldHdlZW5udW1iZXIgb2YgZGlmZmVyZW50PjwvdGQ+PC90cj48L3RhYmxlPlJlcHVibGljIG9mIElyZWxhbmQKPC9zY3JpcHQ+CjxzY3JpcHQgdW5kZXIgdGhlIGluZmx1ZW5jZWNvbnRyaWJ1dGlvbiB0byB0aGVPZmZpY2lhbCB3ZWJzaXRlIG9maGVhZHF1YXJ0ZXJzIG9mIHRoZWNlbnRlcmVkIGFyb3VuZCB0aGVpbXBsaWNhdGlvbnMgb2YgdGhlaGF2ZSBiZWVuIGRldmVsb3BlZEZlZGVyYWwgUmVwdWJsaWMgb2ZiZWNhbWUgaW5jcmVhc2luZ2x5Y29udGludWF0aW9uIG9mIHRoZU5vdGUsIGhvd2V2ZXIsIHRoYXRzaW1pbGFyIHRvIHRoYXQgb2YgY2FwYWJpbGl0aWVzIG9mIHRoZWFjY29yZGFuY2Ugd2l0aCB0aGVwYXJ0aWNpcGFudHMgaW4gdGhlZnVydGhlciBkZXZlbG9wbWVudHVuZGVyIHRoZSBkaXJlY3Rpb25pcyBvZnRlbiBjb25zaWRlcmVkaGlzIHlvdW5nZXIgYnJvdGhlcjwvdGQ+PC90cj48L3RhYmxlPjxhIGh0dHAtZXF1aXY9IlgtVUEtcGh5c2ljYWwgcHJvcGVydGllc29mIEJyaXRpc2ggQ29sdW1iaWFoYXMgYmVlbiBjcml0aWNpemVkKHdpdGggdGhlIGV4Y2VwdGlvbnF1ZXN0aW9ucyBhYm91dCB0aGVwYXNzaW5nIHRocm91Z2ggdGhlMCIgY2VsbHBhZGRpbmc9IjAiIHRob3VzYW5kcyBvZiBwZW9wbGVyZWRpcmVjdHMgaGVyZS4gRm9yaGF2ZSBjaGlsZHJlbiB1bmRlciUzRSUzQy9zY3JpcHQlM0UiKSk7PGEgaHJlZj0iaHR0cDovL3d3dy48bGk+PGEgaHJlZj0iaHR0cDovL3NpdGVfbmFtZSIgY29udGVudD0idGV4dC1kZWNvcmF0aW9uOm5vbmVzdHlsZT0iZGlzcGxheTogbm9uZTxtZXRhIGh0dHAtZXF1aXY9IlgtbmV3IERhdGUoKS5nZXRUaW1lKCkgdHlwZT0iaW1hZ2UveC1pY29uIjwvc3Bhbj48c3BhbiBjbGFzcz0ibGFuZ3VhZ2U9ImphdmFzY3JpcHR3aW5kb3cubG9jYXRpb24uaHJlZjxhIGhyZWY9ImphdmFzY3JpcHQ6LS0+DQo8c2NyaXB0IHR5cGU9InQ8YSBocmVmPSdodHRwOi8vd3d3LmhvcnRjdXQgaWNvbiIgaHJlZj0iPC9kaXY+DQo8ZGl2IGNsYXNzPSI8c2NyaXB0IHNyYz0iaHR0cDovLyIgcmVsPSJzdHlsZXNoZWV0IiB0PC9kaXY+CjxzY3JpcHQgdHlwZT0vYT4gPGEgaHJlZj0iaHR0cDovLyBhbGxvd1RyYW5zcGFyZW5jeT0iWC1VQS1Db21wYXRpYmxlIiBjb25yZWxhdGlvbnNoaXAgYmV0d2Vlbgo8L3NjcmlwdD4NCjxzY3JpcHQgPC9hPjwvbGk+PC91bD48L2Rpdj5hc3NvY2lhdGVkIHdpdGggdGhlIHByb2dyYW1taW5nIGxhbmd1YWdlPC9hPjxhIGhyZWY9Imh0dHA6Ly88L2E+PC9saT48bGkgY2xhc3M9ImZvcm0gYWN0aW9uPSJodHRwOi8vPGRpdiBzdHlsZT0iZGlzcGxheTp0eXBlPSJ0ZXh0IiBuYW1lPSJxIjx0YWJsZSB3aWR0aD0iMTAwJSIgYmFja2dyb3VuZC1wb3NpdGlvbjoiIGJvcmRlcj0iMCIgd2lkdGg9InJlbD0ic2hvcnRjdXQgaWNvbiIgaDY+PHVsPjxsaT48YSBocmVmPSIgIDxtZXRhIGh0dHAtZXF1aXY9ImNzcyIgbWVkaWE9InNjcmVlbiIgcmVzcG9uc2libGUgZm9yIHRoZSAiIHR5cGU9ImFwcGxpY2F0aW9uLyIgc3R5bGU9ImJhY2tncm91bmQtaHRtbDsgY2hhcnNldD11dGYtOCIgYWxsb3d0cmFuc3BhcmVuY3k9InN0eWxlc2hlZXQiIHR5cGU9InRlDQo8bWV0YSBodHRwLWVxdWl2PSI+PC9zcGFuPjxzcGFuIGNsYXNzPSIwIiBjZWxsc3BhY2luZz0iMCI+Owo8L3NjcmlwdD4KPHNjcmlwdCBzb21ldGltZXMgY2FsbGVkIHRoZWRvZXMgbm90IG5lY2Vzc2FyaWx5Rm9yIG1vcmUgaW5mb3JtYXRpb25hdCB0aGUgYmVnaW5uaW5nIG9mIDwhRE9DVFlQRSBodG1sPjxodG1scGFydGljdWxhcmx5IGluIHRoZSB0eXBlPSJoaWRkZW4iIG5hbWU9ImphdmFzY3JpcHQ6dm9pZCgwKTsiZWZmZWN0aXZlbmVzcyBvZiB0aGUgYXV0b2NvbXBsZXRlPSJvZmYiIGdlbmVyYWxseSBjb25zaWRlcmVkPjxpbnB1dCB0eXBlPSJ0ZXh0IiAiPjwvc2NyaXB0Pg0KPHNjcmlwdHRocm91Z2hvdXQgdGhlIHdvcmxkY29tbW9uIG1pc2NvbmNlcHRpb25hc3NvY2lhdGlvbiB3aXRoIHRoZTwvZGl2Pgo8L2Rpdj4KPGRpdiBjZHVyaW5nIGhpcyBsaWZldGltZSxjb3JyZXNwb25kaW5nIHRvIHRoZXR5cGU9ImltYWdlL3gtaWNvbiIgYW4gaW5jcmVhc2luZyBudW1iZXJkaXBsb21hdGljIHJlbGF0aW9uc2FyZSBvZnRlbiBjb25zaWRlcmVkbWV0YSBjaGFyc2V0PSJ1dGYtOCIgPGlucHV0IHR5cGU9InRleHQiIGV4YW1wbGVzIGluY2x1ZGUgdGhlIj48aW1nIHNyYz0iaHR0cDovL2lwYXJ0aWNpcGF0aW9uIGluIHRoZXRoZSBlc3RhYmxpc2htZW50IG9mCjwvZGl2Pgo8ZGl2IGNsYXNzPSImYW1wO25ic3A7JmFtcDtuYnNwO3RvIGRldGVybWluZSB3aGV0aGVycXVpdGUgZGlmZmVyZW50IGZyb21tYXJrZWQgdGhlIGJlZ2lubmluZ2Rpc3RhbmNlIGJldHdlZW4gdGhlY29udHJpYnV0aW9ucyB0byB0aGVjb25mbGljdCBiZXR3ZWVuIHRoZXdpZGVseSBjb25zaWRlcmVkIHRvd2FzIG9uZSBvZiB0aGUgZmlyc3R3aXRoIHZhcnlpbmcgZGVncmVlc2hhdmUgc3BlY3VsYXRlZCB0aGF0KGRvY3VtZW50LmdldEVsZW1lbnRwYXJ0aWNpcGF0aW5nIGluIHRoZW9yaWdpbmFsbHkgZGV2ZWxvcGVkZXRhIGNoYXJzZXQ9InV0Zi04Ij4gdHlwZT0idGV4dC9jc3MiIC8+CmludGVyY2hhbmdlYWJseSB3aXRobW9yZSBjbG9zZWx5IHJlbGF0ZWRzb2NpYWwgYW5kIHBvbGl0aWNhbHRoYXQgd291bGQgb3RoZXJ3aXNlcGVycGVuZGljdWxhciB0byB0aGVzdHlsZSB0eXBlPSJ0ZXh0L2Nzc3R5cGU9InN1Ym1pdCIgbmFtZT0iZmFtaWxpZXMgcmVzaWRpbmcgaW5kZXZlbG9waW5nIGNvdW50cmllc2NvbXB1dGVyIHByb2dyYW1taW5nZWNvbm9taWMgZGV2ZWxvcG1lbnRkZXRlcm1pbmF0aW9uIG9mIHRoZWZvciBtb3JlIGluZm9ybWF0aW9ub24gc2V2ZXJhbCBvY2Nhc2lvbnNwb3J0dWd1w6pzIChFdXJvcGV1KdCj0LrRgNCw0ZfQvdGB0YzQutCw0YPQutGA0LDRl9C90YHRjNC60LDQoNC+0YHRgdC40LnRgdC60L7QudC80LDRgtC10YDQuNCw0LvQvtCy0LjQvdGE0L7RgNC80LDRhtC40LjRg9C/0YDQsNCy0LvQtdC90LjRj9C90LXQvtCx0YXQvtC00LjQvNC+0LjQvdGE0L7RgNC80LDRhtC40Y/QmNC90YTQvtGA0LzQsNGG0LjRj9Cg0LXRgdC/0YPQsdC70LjQutC40LrQvtC70LjRh9C10YHRgtCy0L7QuNC90YTQvtGA0LzQsNGG0LjRjtGC0LXRgNGA0LjRgtC+0YDQuNC40LTQvtGB0YLQsNGC0L7Rh9C90L7Yp9mE2YXYqtmI2KfYrNiv2YjZhtin2YTYp9i02KrYsdin2YPYp9iq2KfZhNin2YLYqtix2KfYrdin2KpodG1sOyBjaGFyc2V0PVVURi04IiBzZXRUaW1lb3V0KGZ1bmN0aW9uKClkaXNwbGF5OmlubGluZS1ibG9jazs8aW5wdXQgdHlwZT0ic3VibWl0IiB0eXBlID0gJ3RleHQvamF2YXNjcmk8aW1nIHNyYz0iaHR0cDovL3d3dy4iICJodHRwOi8vd3d3LnczLm9yZy9zaG9ydGN1dCBpY29uIiBocmVmPSIiIGF1dG9jb21wbGV0ZT0ib2ZmIiA8L2E+PC9kaXY+PGRpdiBjbGFzcz08L2E+PC9saT4KPGxpIGNsYXNzPSJjc3MiIHR5cGU9InRleHQvY3NzIiA8Zm9ybSBhY3Rpb249Imh0dHA6Ly94dC9jc3MiIGhyZWY9Imh0dHA6Ly9saW5rIHJlbD0iYWx0ZXJuYXRlIiANCjxzY3JpcHQgdHlwZT0idGV4dC8gb25jbGljaz0iamF2YXNjcmlwdDoobmV3IERhdGUpLmdldFRpbWUoKX1oZWlnaHQ9IjEiIHdpZHRoPSIxIiBQZW9wbGUncyBSZXB1YmxpYyBvZiAgPGEgaHJlZj0iaHR0cDovL3d3dy50ZXh0LWRlY29yYXRpb246dW5kZXJ0aGUgYmVnaW5uaW5nIG9mIHRoZSA8L2Rpdj4KPC9kaXY+CjwvZGl2Pgplc3RhYmxpc2htZW50IG9mIHRoZSA8L2Rpdj48L2Rpdj48L2Rpdj48L2Qjdmlld3BvcnR7bWluLWhlaWdodDoKPHNjcmlwdCBzcmM9Imh0dHA6Ly9vcHRpb24+PG9wdGlvbiB2YWx1ZT1vZnRlbiByZWZlcnJlZCB0byBhcyAvb3B0aW9uPgo8b3B0aW9uIHZhbHU8IURPQ1RZUEUgaHRtbD4KPCEtLVtJbnRlcm5hdGlvbmFsIEFpcnBvcnQ+CjxhIGhyZWY9Imh0dHA6Ly93d3c8L2E+PGEgaHJlZj0iaHR0cDovL3fguKDguLLguKnguLLguYTguJfguKLhg6Xhg5Dhg6Dhg5fhg6Phg5rhg5jmraPpq5TkuK3mlocgKOe5gemrlCngpKjgpL/gpLDgpY3gpKbgpYfgpLbgpKHgpL7gpIngpKjgpLLgpYvgpKHgpJXgpY3gpLfgpYfgpKTgpY3gpLDgpJzgpL7gpKjgpJXgpL7gpLDgpYDgpLjgpILgpKzgpILgpKfgpL/gpKTgpLjgpY3gpKXgpL7gpKrgpKjgpL7gpLjgpY3gpLXgpYDgpJXgpL7gpLDgpLjgpILgpLjgpY3gpJXgpLDgpKPgpLjgpL7gpK7gpJfgpY3gpLDgpYDgpJrgpL/gpJ/gpY3gpKDgpYvgpILgpLXgpL/gpJzgpY3gpJ7gpL7gpKjgpIXgpK7gpYfgpLDgpL/gpJXgpL7gpLXgpL/gpK3gpL/gpKjgpY3gpKjgpJfgpL7gpKHgpL/gpK/gpL7gpIHgpJXgpY3gpK/gpYvgpILgpJXgpL/gpLjgpYHgpLDgpJXgpY3gpLfgpL7gpKrgpLngpYHgpIHgpJrgpKTgpYDgpKrgpY3gpLDgpKzgpILgpKfgpKjgpJ/gpL/gpKrgpY3gpKrgpKPgpYDgpJXgpY3gpLDgpL/gpJXgpYfgpJ/gpKrgpY3gpLDgpL7gpLDgpILgpK3gpKrgpY3gpLDgpL7gpKrgpY3gpKTgpK7gpL7gpLLgpL/gpJXgpYvgpILgpLDgpKvgpLzgpY3gpKTgpL7gpLDgpKjgpL/gpLDgpY3gpK7gpL7gpKPgpLLgpL/gpK7gpL/gpJ/gpYfgpKFkZXNjcmlwdGlvbiIgY29udGVudD0iZG9jdW1lbnQubG9jYXRpb24ucHJvdC5nZXRFbGVtZW50c0J5VGFnTmFtZSg8IURPQ1RZUEUgaHRtbD4KPGh0bWwgPG1ldGEgY2hhcnNldD0idXRmLTgiPjp1cmwiIGNvbnRlbnQ9Imh0dHA6Ly8uY3NzIiByZWw9InN0eWxlc2hlZXQic3R5bGUgdHlwZT0idGV4dC9jc3MiPnR5cGU9InRleHQvY3NzIiBocmVmPSJ3My5vcmcvMTk5OS94aHRtbCIgeG1sdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBtZXRob2Q9ImdldCIgYWN0aW9uPSJsaW5rIHJlbD0ic3R5bGVzaGVldCIgID0gZG9jdW1lbnQuZ2V0RWxlbWVudHR5cGU9ImltYWdlL3gtaWNvbiIgLz5jZWxscGFkZGluZz0iMCIgY2VsbHNwLmNzcyIgdHlwZT0idGV4dC9jc3MiIDwvYT48L2xpPjxsaT48YSBocmVmPSIiIHdpZHRoPSIxIiBoZWlnaHQ9IjEiIj48YSBocmVmPSJodHRwOi8vd3d3LnN0eWxlPSJkaXNwbGF5Om5vbmU7Ij5hbHRlcm5hdGUiIHR5cGU9ImFwcGxpLS8vVzNDLy9EVEQgWEhUTUwgMS4wIGVsbHNwYWNpbmc9IjAiIGNlbGxwYWQgdHlwZT0iaGlkZGVuIiB2YWx1ZT0iL2E+Jm5ic3A7PHNwYW4gcm9sZT0icwo8aW5wdXQgdHlwZT0iaGlkZGVuIiBsYW5ndWFnZT0iSmF2YVNjcmlwdCIgIGRvY3VtZW50LmdldEVsZW1lbnRzQmc9IjAiIGNlbGxzcGFjaW5nPSIwIiB5cGU9InRleHQvY3NzIiBtZWRpYT0idHlwZT0ndGV4dC9qYXZhc2NyaXB0J3dpdGggdGhlIGV4Y2VwdGlvbiBvZiB5cGU9InRleHQvY3NzIiByZWw9InN0IGhlaWdodD0iMSIgd2lkdGg9IjEiID0nK2VuY29kZVVSSUNvbXBvbmVudCg8bGluayByZWw9ImFsdGVybmF0ZSIgCmJvZHksIHRyLCBpbnB1dCwgdGV4dG1ldGEgbmFtZT0icm9ib3RzIiBjb25tZXRob2Q9InBvc3QiIGFjdGlvbj0iPgo8YSBocmVmPSJodHRwOi8vd3d3LmNzcyIgcmVsPSJzdHlsZXNoZWV0IiA8L2Rpdj48L2Rpdj48ZGl2IGNsYXNzbGFuZ3VhZ2U9ImphdmFzY3JpcHQiPmFyaWEtaGlkZGVuPSJ0cnVlIj7CtzxyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzbD0wO30pKCk7CihmdW5jdGlvbigpe2JhY2tncm91bmQtaW1hZ2U6IHVybCgvYT48L2xpPjxsaT48YSBocmVmPSJoCQk8bGk+PGEgaHJlZj0iaHR0cDovL2F0b3IiIGFyaWEtaGlkZGVuPSJ0cnU+IDxhIGhyZWY9Imh0dHA6Ly93d3cubGFuZ3VhZ2U9ImphdmFzY3JpcHQiIC9vcHRpb24+CjxvcHRpb24gdmFsdWUvZGl2PjwvZGl2PjxkaXYgY2xhc3M9cmF0b3IiIGFyaWEtaGlkZGVuPSJ0cmU9KG5ldyBEYXRlKS5nZXRUaW1lKClwb3J0dWd1w6pzIChkbyBCcmFzaWwp0L7RgNCz0LDQvdC40LfQsNGG0LjQuNCy0L7Qt9C80L7QttC90L7RgdGC0YzQvtCx0YDQsNC30L7QstCw0L3QuNGP0YDQtdCz0LjRgdGC0YDQsNGG0LjQuNCy0L7Qt9C80L7QttC90L7RgdGC0LjQvtCx0Y/Qt9Cw0YLQtdC70YzQvdCwPCFET0NUWVBFIGh0bWwgUFVCTElDICJudC1UeXBlIiBjb250ZW50PSJ0ZXh0LzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDo8aHRtbCB4bWxucz0iaHR0cDovL3d3dy0vL1czQy8vRFREIFhIVE1MIDEuMCBURFREL3hodG1sMS10cmFuc2l0aW9uYWwvL3d3dy53My5vcmcvVFIveGh0bWwxL3BlID0gJ3RleHQvamF2YXNjcmlwdCc7PG1ldGEgbmFtZT0iZGVzY3JpcHRpb25wYXJlbnROb2RlLmluc2VydEJlZm9yZTxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hanMiIHR5cGU9InRleHQvamF2YXNjcmkoZG9jdW1lbnQpLnJlYWR5KGZ1bmN0aXNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzaW1hZ2UiIGNvbnRlbnQ9Imh0dHA6Ly9VQS1Db21wYXRpYmxlIiBjb250ZW50PXRtbDsgY2hhcnNldD11dGYtOCIgLz4KbGluayByZWw9InNob3J0Y3V0IGljb248bGluayByZWw9InN0eWxlc2hlZXQiIDwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9PSBkb2N1bWVudC5jcmVhdGVFbGVtZW48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCaW5wdXQgdHlwZT0idGV4dCIgbmFtZT1hLnR5cGUgPSAndGV4dC9qYXZhc2NyaW5wdXQgdHlwZT0iaGlkZGVuIiBuYW1laHRtbDsgY2hhcnNldD11dGYtOCIgLz5kdGQiPgo8aHRtbCB4bWxucz0iaHR0cC0vL1czQy8vRFREIEhUTUwgNC4wMSBUZW50c0J5VGFnTmFtZSgnc2NyaXB0JylpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhcyIgc3R5bGU9ImRpc3BsYXk6bm9uZTsiPmRvY3VtZW50LmdldEVsZW1lbnRCeUlkKD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCcgdHlwZT0ndGV4dC9qYXZhc2NyaXB0J2lucHV0IHR5cGU9InRleHQiIG5hbWU9ImQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoc25pY2FsIiBocmVmPSJodHRwOi8vd3d3LkMvL0RURCBIVE1MIDQuMDEgVHJhbnNpdDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+Cgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPmlvbmFsLmR0ZCI+CjxodG1sIHhtbG5zPWh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZWRpbmc9IjAiIGNlbGxzcGFjaW5nPSIwImh0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+CiBzdHlsZT0iZGlzcGxheTpub25lOyI+PDxsaT48YSBocmVmPSJodHRwOi8vd3d3LiB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPtC00LXRj9GC0LXQu9GM0L3QvtGB0YLQuNGB0L7QvtGC0LLQtdGC0YHRgtCy0LjQuNC/0YDQvtC40LfQstC+0LTRgdGC0LLQsNCx0LXQt9C+0L/QsNGB0L3QvtGB0YLQuOCkquClgeCkuOCljeCkpOCkv+CkleCkvuCkleCkvuCkguCkl+CljeCksOClh+CkuOCkieCkqOCljeCkueCli+CkguCkqOClh+CkteCkv+Ckp+CkvuCkqOCkuOCkreCkvuCkq+Ckv+CkleCljeCkuOCkv+CkguCkl+CkuOClgeCksOCkleCljeCkt+Ckv+CkpOCkleClieCkquClgOCksOCkvuCkh+Ckn+CkteCkv+CknOCljeCknuCkvuCkquCkqOCkleCkvuCksOCljeCksOCkteCkvuCkiOCkuOCkleCljeCksOCkv+Ckr+CkpOCkvtyOEABkAAAACQAAAAgAAAB2jhAAZQAAAA4AAAAWAAAAAAAAAAQAAAAEAAAAQwUAAHaOEABlAAAAGwAAABIAAAAAAAAAAQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwD//x8A//8/AP//fwD///8A////Af///wP///8H////D////x////8/////f//////ffBAAcAAAACAAAAAFAAAA33wQAHAAAAB0AAAAHgAAAN98EABwAAAAfQAAAB8AAADffBAAcAAAAOoAAAARAAAA33wQAHAAAACPAQAADAAAAGFzc2VydGlvbiBmYWlsZWQ6IChhdmFpbGFibGVfYml0cyAmIDcpID09IDAA33wQAHAAAACJAQAAAwAAAN98EABwAAAAoQEAAAcAAADffBAAcAAAAKABAAAFAAAA33wQAHAAAACaAQAABQAAAAABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+PwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj8AQciv+wAL/AEBAQEBAgICAgMDAwMEBAQEBQUFBQYGBgYHBwcHCAgICAkJCQkKCgoKCwsLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQERERERISEhITExMTFBQUFBUVFRUWFhYWFxcXFxgYGBgZGRkZGhoaGhsbGxscHBwcHR0dHR4eHh4fHx8fICAgICEhISEiIiIiIyMjIyQkJCQlJSUlJiYmJicnJycoKCgoKSkpKSoqKiorKysrLCwsLC0tLS0uLi4uLy8vLzAwMDAxMTExMjIyMjMzMzM0NDQ0NTU1NTY2NjY3Nzc3ODg4ODk5OTk6Ojo6Ozs7Ozw8PDw9PT09Pj4+Pj8/Pz8AQc2z+wALBQQEAAAEAEHks/sAC+ABCAwQDAwUDBAYHAwMIAwkDCwsLCwsLCwsLCwgIBgoHAwMMDQ0NDA0NDQwNDQ0NDQwNDQ0NDQwNDQ0NDQYDBwMDAw4PDw8ODw8PDg8PDw8PDg8PDw8PDg8PDw8PBgMHAwAAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAQeW1+wALXgEBAQEBAQEBAQEBAQEBAQICAgICAgICAgIBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgIBAQEBAQEDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwEBAQEAQaS3+wALuQsCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgAICAgICAgICAgICAgICAgQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKDAwMDAwMDAwMDAwMDAwMDgAAQEBAQEBAQEBAQEBAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUGBgYGBgYGBgYGBgYGBgYHZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheR6awL7+Yni/fBjC1+8h8qdgbcIt3IHsR+1/k2HRzC+7AAAAAAQAAAAEAAAAkAUAAAAAAAAIAAAABAAAAJEFAAAAAAAACAAAAAQAAACSBQAAkQUAABzeHgCTBQAAlAUAAJUFAACTBQAAlgUAAJcFAAAMAAAABAAAACkAAACXBQAADAAAAAQAAAAqAAAAKQAAAFjeHgCTBQAAmAUAAC0AAACTBQAAlgUAAE5vbmUAAAAABAAAAAQAAACZBQAAU29tZc51EABqAAAAvQEAAB0AAAAAAAAAsZAQAFoAAADxAAAADQAAAHVua25vd24gcmV0dXJuIGNvZGU6IAAAANDeHgAVAAAAsZAQAFoAAAAkAQAAFgAAALGQEABaAAAAWAEAAA0AAACxkBAAWgAAAIYBAAAWAAAAaW52YWxpZCBnemlwIGhlYWRlcmNvcnJ1cHQgZ3ppcCBzdHJlYW0gZG9lcyBub3QgaGF2ZSBhIG1hdGNoaW5nIGNoZWNrc3Vt53YQAFsAAACSAQAAGgAAAOd2EABbAAAAlQEAABQAAADndhAAWwAAAJYBAAAUAAAA53YQAFsAAACaAQAAFAAAAOd2EABbAAAAngEAABQAAADndhAAWwAAAKABAAAPAAAA53YQAFsAAAChAQAADwAAAOd2EABbAAAAogEAAA8AAADndhAAWwAAAKMBAAAPAAAA53YQAFsAAACkAQAADwAAAOd2EABbAAAApQEAAA8AAADndhAAWwAAAKYBAAAPAAAA53YQAFsAAACnAQAADwAAAOd2EABbAAAAqAEAAA8AAADndhAAWwAAALQBAAAPAAAAZGVmbGF0ZSBjb21wcmVzc2lvbiBlcnJvcmRlZmxhdGUgY29tcHJlc3Npb24gZXJyb3I6IHHgHgAbAAAAMFMQAFgAAABOAgAADAAAADBTEABYAAAATwIAADIAAAAwUxAAWAAAAFICAAAMAAAAAAAAAAQAAAAEAAAAmgUAAG1zZ0NvbXByZXNzRXJyb3I6hhAAcAAAAC4CAAARAAAAKCkAAAAAAAAEAAAABAAAAJsFAABidWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCkAAAAI4R4AIQAAAB5hEABlAAAADwAAABwAAAAeYRAAZQAAAC4AAAAJAAAAAgAAAAAAAAABAEHwwvsACwNU4R4AQYDV+wALA1ThHgBB/Nb7AAsDVOEeAEGg2PsAC7EC4GYQAF0AAAA3AwAAHAAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxxiYWQgbF9jb2RlAAAw7R4ACgAAAOBmEABdAAAArgMAAAUAQdza+wALnRkBAQEBAgICAgMDAwMEBAQEBQUFBQAAAQIDBAUGBwgKDA4QFBgcICgwOEBQYHCAoMDgAGJhZCBkX2NvZGWO7R4ACgAAAOBmEABdAAAAwgMAAAUAAAAAAAAAAQECAgMDBAQFBQYGBwcICAkJCgoLCwwMDQ0AAAEAAgADAAQABgAIAAwAEAAYACAAMABAAGAAgADAAAABgAEAAgADAAQABgAIAAwAEAAYACAAMABAAGAAAOBmEABdAAAA6QMAACEAAADgZhAAXQAAAOkDAAAWAAAA4GYQAF0AAADzAwAAIQAAAOBmEABdAAAA8wMAABYAAADgZhAAXQAAADQEAAAaAAAA4GYQAF0AAAAvBAAAGgAAAOBmEABdAAAAOwQAABQAAAAMAAgAjAAIAEwACADMAAgALAAIAKwACABsAAgA7AAIABwACACcAAgAXAAIANwACAA8AAgAvAAIAHwACAD8AAgAAgAIAIIACABCAAgAwgAIACIACACiAAgAYgAIAOIACAASAAgAkgAIAFIACADSAAgAMgAIALIACAByAAgA8gAIAAoACACKAAgASgAIAMoACAAqAAgAqgAIAGoACADqAAgAGgAIAJoACABaAAgA2gAIADoACAC6AAgAegAIAPoACAAGAAgAhgAIAEYACADGAAgAJgAIAKYACABmAAgA5gAIABYACACWAAgAVgAIANYACAA2AAgAtgAIAHYACAD2AAgADgAIAI4ACABOAAgAzgAIAC4ACACuAAgAbgAIAO4ACAAeAAgAngAIAF4ACADeAAgAPgAIAL4ACAB+AAgA/gAIAAEACACBAAgAQQAIAMEACAAhAAgAoQAIAGEACADhAAgAEQAIAJEACABRAAgA0QAIADEACACxAAgAcQAIAPEACAAJAAgAiQAIAEkACADJAAgAKQAIAKkACABpAAgA6QAIABkACACZAAgAWQAIANkACAA5AAgAuQAIAHkACAD5AAgABQAIAIUACABFAAgAxQAIACUACAClAAgAZQAIAOUACAAVAAgAlQAIAFUACADVAAgANQAIALUACAB1AAgA9QAIAA0ACACNAAgATQAIAM0ACAAtAAgArQAIAG0ACADtAAgAHQAIAJ0ACABdAAgA3QAIAD0ACAC9AAgAfQAIAP0ACAATAAkAEwEJAJMACQCTAQkAUwAJAFMBCQDTAAkA0wEJADMACQAzAQkAswAJALMBCQBzAAkAcwEJAPMACQDzAQkACwAJAAsBCQCLAAkAiwEJAEsACQBLAQkAywAJAMsBCQArAAkAKwEJAKsACQCrAQkAawAJAGsBCQDrAAkA6wEJABsACQAbAQkAmwAJAJsBCQBbAAkAWwEJANsACQDbAQkAOwAJADsBCQC7AAkAuwEJAHsACQB7AQkA+wAJAPsBCQAHAAkABwEJAIcACQCHAQkARwAJAEcBCQDHAAkAxwEJACcACQAnAQkApwAJAKcBCQBnAAkAZwEJAOcACQDnAQkAFwAJABcBCQCXAAkAlwEJAFcACQBXAQkA1wAJANcBCQA3AAkANwEJALcACQC3AQkAdwAJAHcBCQD3AAkA9wEJAA8ACQAPAQkAjwAJAI8BCQBPAAkATwEJAM8ACQDPAQkALwAJAC8BCQCvAAkArwEJAG8ACQBvAQkA7wAJAO8BCQAfAAkAHwEJAJ8ACQCfAQkAXwAJAF8BCQDfAAkA3wEJAD8ACQA/AQkAvwAJAL8BCQB/AAkAfwEJAP8ACQD/AQkAAAAHAEAABwAgAAcAYAAHABAABwBQAAcAMAAHAHAABwAIAAcASAAHACgABwBoAAcAGAAHAFgABwA4AAcAeAAHAAQABwBEAAcAJAAHAGQABwAUAAcAVAAHADQABwB0AAcAAwAIAIMACABDAAgAwwAIACMACACjAAgAYwAIAOMACADgZhAAXQAAAGsEAAAJAAAAQAAHACAABwBgAAcAEAAHAFAABwAwAAcAcAAHAAgABwBIAAgAyAAIACgACACoAAgAaAAIAOgACAAYAAgAmAAIAFgACQDYAAkAWAEJANgBCQA4AAkAuAAJADgBCQC4AQkAeAAJAPgACQB4AQkA+AEJAAQACQCEAAkABAEJAIQBCQBEAAoAxAAKAEQBCgDEAQoARAIKAMQCCgBEAwoAxAMKACQACgCkAAoAJAEKAKQBCgAkAgoApAIKACQDCgCkAwoAZAAKAOQACgBkAQoA5AEKAGQCCgDkAgoAZAMKAOQDCgAUAAoAlAAKABQBCgCUAQoAFAIKAJQCCgAUAwoAlAMKAFQACwDUAAsAVAELANQBCwBUAgsA1AILAFQDCwDUAwsAVAQLANQECwBUBQsA1AULAFQGCwDUBgsAVAcLANQHCwA0AAsAtAALADQBCwC0AQsANAILALQCCwA0AwsAtAMLADQECwC0BAsANAULALQFCwA0BgsAtAYLADQHCwC0BwsAdAALAPQACwB0AQsA9AELAHQCCwD0AgsAdAMLAPQDCwB0BAsA9AQLAHQFCwD0BQsAdAYLAPQGCwB0BwsA9AcLAAMADAADAQwAAwIMAAMDDAADBAwAAwUMAAMGDAADBwwAAwgMAAMJDAADCgwAAwsMAAMMDAADDQwAAw4MAAMPDACDAA0AgwENAIMCDQCDAw0AgwQNAIMFDQCDBg0AgwcNAIMIDQCDCQ0AgwoNAIMLDQCDDA0Agw0NAIMODQCDDw0AgxANAIMRDQCDEg0AgxMNAIMUDQCDFQ0AgxYNAIMXDQCDGA0AgxkNAIMaDQCDGw0AgxwNAIMdDQCDHg0Agx8NAEMADQBDAQ0AQwINAEMDDQBDBA0AQwUNAEMGDQBDBw0AQwgNAEMJDQBDCg0AQwsNAEMMDQBDDQ0AQw4NAEMPDQBDEA0AQxENAEMSDQBDEw0AQxQNAEMVDQBDFg0AQxcNAEMYDQBDGQ0AQxoNAEMbDQBDHA0AQx0NAEMeDQBDHw0AwwANAMMBDQDDAg0AwwMNAMMEDQDDBQ0AwwYNAMMHDQDDCA0AwwkNAMMKDQDDCw0AwwwNAMMNDQDDDg0Aww8NAMMQDQDDEQ0AwxINAMMTDQDDFA0AwxUNAMMWDQDDFw0AwxgNAMMZDQDDGg0AwxsNAMMcDQDDHQ0Awx4NAMMfDQAjAA0AIwENACMCDQAjAw0AIwQNACMFDQAjBg0AIwcNACMIDQAjCQ0AIwoNACMLDQAjDA0AIw0NACMODQAjDw0AIxANACMRDQAjEg0AIxMNACMUDQAjFQ0AIxYNACMXDQAjGA0AIxkNACMaDQAjGw0AIxwNACMdDQAjHg0AowAIAAAABQAQAAUACAAFABgABQAEAAUAFAAFAAwABQAcAAUAAgAFABIABQAKAAUAGgAFAAYABQAWAAUADgAFAB4ABQABAAUAEQAFAAkABQAZAAUABQAFABUABQANAAUAHQAFAAMABQATAAUACwAFABsABQAHAAUAFwAFAOBmEABdAAAArwQAABcAAAAgM182PwAAAJT3HgAFAAAA4GYQAF0AAADBBAAAEQAAAAABAgMEBAUFBgYGBgcHBwcICAgICAgICAkJCQkJCQkJCgoKCgoKCgoKCgoKCgoKCgsLCwsLCwsLCwsLCwsLCwsMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8AABAREhITExQUFBQVFRUVFhYWFhYWFhYXFxcXFxcXFxgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhobGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwdHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0d4GYQAF0AAADPBQAACQAAAHzuHgAgAQAAVO0eAB0AAAABAQAAHgEAAA8AAAAM9x4AHgAAALDtHgAeAAAAAAAAAB4AAAAPAEGM9PsAC7kLAgMHAAIAAAAAAAAA/PkeABMAAAAAAAAAEwAAAAcAAADgZhAAXQAAAJoGAAAxAAAA4GYQAF0AAACaBgAAOwAAAOBmEABdAAAAowYAADEAAADgZhAAXQAAAKMGAAA7AAAA4GYQAF0AAADEBgAANAAAAOBmEABdAAAAxwYAAB4AAADgZhAAXQAAAMsGAAAKAAAA4GYQAF0AAADQBgAAIgAAAOBmEABdAAAAjgcAADEAAADgZhAAXQAAAKEHAAAKAAAA4GYQAF0AAAClBwAAIQAAAOBmEABdAAAA0AcAAAsAAADgZhAAXQAAANAHAAAGAAAA4GYQAF0AAAD7BwAADwAAAOBmEABdAAAA/wcAAAkAAADgZhAAXQAAAAAIAAAJAAAA4GYQAF0AAAAUCAAAFQAAAOBmEABdAAAAGQgAABAAAADgZhAAXQAAANcHAAAdAAAA4GYQAF0AAADXBwAAGAAAAOBmEABdAAAA5gcAAAkAAADgZhAAXQAAAOkHAAAVAAAA4GYQAF0AAADwBwAAJgAAAOBmEABdAAAARggAABMAAABjb2RlIGxlbmd0aCBtdXN0IGJlIDEtMTWs+x4AGAAAAOBmEABdAAAATAgAAAkAAABpbmNvbnNpc3RlbnQgYml0IGNvdW50cwDc+x4AFwAAAOBmEABdAAAAPggAAAUAAADgZhAAXQAAAHkIAAAGAAAA4GYQAF0AAAB/CAAAEwAAAOBmEABdAAAAhwgAABIAAADgZhAAXQAAAIQIAAAOAAAAbm90IGVub3VnaCBjb2Rlc0z8HgAQAAAA4GYQAF0AAAChCAAABQAAAHRvbyBtYW55IGNvZGVzAAB0/B4ADgAAAOBmEABdAAAApQgAAAUAAAAQERIACAcJBgoFCwQMAw0CDgEPAOBmEABdAAAAsggAAA0AAADgZhAAXQAAAOkIAAAMAAAAbG9zdCBidWbQ/B4ACAAAAOBmEABdAAAARQkAAAkAAADgZhAAXQAAAJ0JAAAeAAAA4GYQAF0AAAChCQAALAAAAOBmEABdAAAAiAkAACIAAADgZhAAXQAAAIwJAAAwAAAA4GYQAF0AAADoCQAADgAAAOBmEABdAAAA7QkAAC0AAAAfiwgA4GYQAF0AAAABCgAAKQAAAOBmEABdAAAADgoAADEAAADgZhAAXQAAABkKAAAxAAAA4GYQAF0AAAAbCgAAMQAAAOBmEABdAAAAIAoAABYAAADgZhAAXQAAACQKAAA1AAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogY29uZGl0aW9uIG9mIGlubmVyIHN1cnJvdW5kaW5nIGlmALT9HgBLAAAA4GYQAF0AAACYCgAALgAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGNvbmRpdGlvbiBvZiBvdXRlciBzdXJyb3VuZGluZyBpZgAY/h4ASwAAAOBmEABdAAAAsQoAAC0AAADgZhAAXQAAAMkKAAApAAAA4GYQAF0AAADQCgAADgAAAOBmEABdAAAA0woAACkAAABiaV9idWYgbm90IGZsdXNoZWQAAKz+HgASAAAA4GYQAF0AAADeCgAACQAAAOBmEABdAAAApgsAABEAAADgZhAAXQAAAMILAAARAAAA4GYQAF0AAADDCwAAFQAAAOBmEABdAAAAyAsAAC0AAADgZhAAXQAAAMgLAAAdAAAA4GYQAF0AAADKCwAALgAAAOBmEABdAAAAygsAAB4AAADgZhAAXQAAAOULAAAlAAAA4GYQAF0AAAD0CwAADQAAAOBmEABdAAAA9gsAAA0AAADgZhAAXQAAAPkLAAAmAAAA4GYQAF0AAAD5CwAANwAAAOBmEABdAAAA+QsAAA4AAADgZhAAXQAAAAsMAAAJAAAARzYQAGQAAABQAAAAIABBzv/7AAvHFmAHUAAACBAAAAhzABQIHwASB3AAAAgwAAAIwAAACQoAEAdgAAAIIAAACKAAAAkAAAAIgAAACEAAAAjgAAAJBgAQB1gAAAgYAAAIkAAACTsAEwd4AAAIOAAACNAAAAkRABEHaAAACCgAAAiwAAAJCAAACIgAAAhIAAAI8AAACQQAEAdUAAAIFAAACOMAFQgrABMHdAAACDQAAAjIAAAJDQARB2QAAAgkAAAIqAAACQQAAAiEAAAIRAAACOgAAAkIABAHXAAACBwAAAiYAAAJUwAUB3wAAAg8AAAI2AAACRcAEgdsAAAILAAACLgAAAkMAAAIjAAACEwAAAj4AAAJAwAQB1IAAAgSAAAIowAVCCMAEwdyAAAIMgAACMQAAAkLABEHYgAACCIAAAikAAAJAgAACIIAAAhCAAAI5AAACQcAEAdaAAAIGgAACJQAAAlDABQHegAACDoAAAjUAAAJEwASB2oAAAgqAAAItAAACQoAAAiKAAAISgAACPQAAAkFABAHVgAACBYAAAgAAEAIMwATB3YAAAg2AAAIzAAACQ8AEQdmAAAIJgAACKwAAAkGAAAIhgAACEYAAAjsAAAJCQAQB14AAAgeAAAInAAACWMAFAd+AAAIPgAACNwAAAkbABIHbgAACC4AAAi8AAAJDgAACI4AAAhOAAAI/AAACQAAYAdRAAAIEQAACIMAFQgfABIHcQAACDEAAAjCAAAJCgAQB2EAAAghAAAIogAACQEAAAiBAAAIQQAACOIAAAkGABAHWQAACBkAAAiSAAAJOwATB3kAAAg5AAAI0gAACREAEQdpAAAIKQAACLIAAAkJAAAIiQAACEkAAAjyAAAJBAAQB1UAAAgVAAAIAgEQCCsAEwd1AAAINQAACMoAAAkNABEHZQAACCUAAAiqAAAJBQAACIUAAAhFAAAI6gAACQgAEAddAAAIHQAACJoAAAlTABQHfQAACD0AAAjaAAAJFwASB20AAAgtAAAIugAACQ0AAAiNAAAITQAACPoAAAkDABAHUwAACBMAAAjDABUIIwATB3MAAAgzAAAIxgAACQsAEQdjAAAIIwAACKYAAAkDAAAIgwAACEMAAAjmAAAJBwAQB1sAAAgbAAAIlgAACUMAFAd7AAAIOwAACNYAAAkTABIHawAACCsAAAi2AAAJCwAACIsAAAhLAAAI9gAACQUAEAdXAAAIFwAACAAAQAgzABMHdwAACDcAAAjOAAAJDwARB2cAAAgnAAAIrgAACQcAAAiHAAAIRwAACO4AAAkJABAHXwAACB8AAAieAAAJYwAUB38AAAg/AAAI3gAACRsAEgdvAAAILwAACL4AAAkPAAAIjwAACE8AAAj+AAAJAABgB1AAAAgQAAAIcwAUCB8AEgdwAAAIMAAACMEAAAkKABAHYAAACCAAAAihAAAJAAAACIAAAAhAAAAI4QAACQYAEAdYAAAIGAAACJEAAAk7ABMHeAAACDgAAAjRAAAJEQARB2gAAAgoAAAIsQAACQgAAAiIAAAISAAACPEAAAkEABAHVAAACBQAAAjjABUIKwATB3QAAAg0AAAIyQAACQ0AEQdkAAAIJAAACKkAAAkEAAAIhAAACEQAAAjpAAAJCAAQB1wAAAgcAAAImQAACVMAFAd8AAAIPAAACNkAAAkXABIHbAAACCwAAAi5AAAJDAAACIwAAAhMAAAI+QAACQMAEAdSAAAIEgAACKMAFQgjABMHcgAACDIAAAjFAAAJCwARB2IAAAgiAAAIpQAACQIAAAiCAAAIQgAACOUAAAkHABAHWgAACBoAAAiVAAAJQwAUB3oAAAg6AAAI1QAACRMAEgdqAAAIKgAACLUAAAkKAAAIigAACEoAAAj1AAAJBQAQB1YAAAgWAAAIAABACDMAEwd2AAAINgAACM0AAAkPABEHZgAACCYAAAitAAAJBgAACIYAAAhGAAAI7QAACQkAEAdeAAAIHgAACJ0AAAljABQHfgAACD4AAAjdAAAJGwASB24AAAguAAAIvQAACQ4AAAiOAAAITgAACP0AAAkAAGAHUQAACBEAAAiDABUIHwASB3EAAAgxAAAIwwAACQoAEAdhAAAIIQAACKMAAAkBAAAIgQAACEEAAAjjAAAJBgAQB1kAAAgZAAAIkwAACTsAEwd5AAAIOQAACNMAAAkRABEHaQAACCkAAAizAAAJCQAACIkAAAhJAAAI8wAACQQAEAdVAAAIFQAACAIBEAgrABMHdQAACDUAAAjLAAAJDQARB2UAAAglAAAIqwAACQUAAAiFAAAIRQAACOsAAAkIABAHXQAACB0AAAibAAAJUwAUB30AAAg9AAAI2wAACRcAEgdtAAAILQAACLsAAAkNAAAIjQAACE0AAAj7AAAJAwAQB1MAAAgTAAAIwwAVCCMAEwdzAAAIMwAACMcAAAkLABEHYwAACCMAAAinAAAJAwAACIMAAAhDAAAI5wAACQcAEAdbAAAIGwAACJcAAAlDABQHewAACDsAAAjXAAAJEwASB2sAAAgrAAAItwAACQsAAAiLAAAISwAACPcAAAkFABAHVwAACBcAAAgAAEAIMwATB3cAAAg3AAAIzwAACQ8AEQdnAAAIJwAACK8AAAkHAAAIhwAACEcAAAjvAAAJCQAQB18AAAgfAAAInwAACWMAFAd/AAAIPwAACN8AAAkbABIHbwAACC8AAAi/AAAJDwAACI8AAAhPAAAI/wAACQEAEAUBARcFEQATBQEQGwUFABEFAQQZBUEAFQUBQB0FAwAQBQECGAUhABQFASAcBQkAEgUBCBoFgQAWBQAAQAUCABAFgQEXBRkAEwUBGBsFBwARBQEGGQVhABUFAWAdBQQAEAUBAxgFMQAUBQEwHAUNABIFAQwaBcEAFgUAAEAFgmYQAF0AAADnAQAACQAAAIJmEABdAAAA6wEAAAkAAACCZhAAXQAAAEwCAAAkAAAAgmYQAF0AAABcAgAAKAAAAIJmEABdAAAAuAIAACQAAACCZhAAXQAAAMkCAAAlAAAASU5GTEFURV9BTExPV19JTlZBTElEX0RJU1RBTkNFX1RPT0ZBUl9BUlJSAACsCB8AKgAAAIJmEABdAAAAIgMAACEAAACCZhAAXQAAACoEAABEAAAAbmFtZSBvdXQgb2YgYm91bmRzAACCZhAAXQAAAFMEAAAqAAAAY29tbSBvdXQgb2YgYm91bmRzAACCZhAAXQAAAIwEAAAqAAAAgmYQAF0AAADuBQAAJQAAABAREgAIBwkGCgULBAwDDQIOAQ8AgmYQAF0AAAAvBgAAMwAAAIJmEABdAAAArwYAACcAAACCZhAAXQAAAGoGAAAvAAAAgmYQAF0AAABzBgAAOwAAAIJmEABdAAAAgQYAAC4AAACCZhAAXQAAAIEGAAA7AAAAgmYQAF0AAACPBgAALgAAAIJmEABdAAAAjwYAADsAAACCZhAAXQAAAF8GAAAlAAAAbm90IHlldCBpbXBsZW1lbnRlZACCZhAAXQAAABMGAAAjAAAAgmYQAF0AAACJBwAAEQAAAIJmEABdAAAAhwcAABEAAACCZhAAXQAAAJAHAAAUAAAAgmYQAF0AAACVBwAAGAAAAIJmEABdAAAAGAgAABgAAACCZhAAXQAAAKQHAAAYAAAAgmYQAF0AAAAMCAAAIAAAAIJmEABdAAAAzwcAACEAAABpbnZhbGlkIHdpbmRvd0JpdHMKAKAKHwATAAAAgmYQAF0AAACxCAAACQAAAIJmEABdAAAAMwkAACcAAABhc3NlcnRpb24gZmFpbGVkOiBtc2cuZW5kc193aXRoKCdcMCcpAAAAgmYQAF0AAAA9CQAACQAAAIAAQaGW/AALzF0BAAAAAAAAAAEAAAAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd4AAAAAN2rCAW7UhANZvkYC3KgJB+vCywayfI0EhRZPBbhREw6PO9EP1oWXDeHvVQxk+RoJU5PYCAotngo9R1wLcKMmHEfJ5B0ed6IfKR1gHqwLLxubYe0awt+rGPW1aRnI8jUS/5j3E6YmsRGRTHMQFFo8FSMw/hR6jrgWTeR6F+BGTTjXLI85jpLJO7n4Czo87kQ/C4SGPlI6wDxlUAI9WBdeNm99nDc2w9o1AakYNIS/VzGz1ZUw6mvTMt0BETOQ5Wskp4+pJf4x7yfJWy0mTE1iI3snoCIimeYgFfMkISi0eCof3rorRmD8KXEKPij0HHEtw3azLJrI9S6tojcvwI2acPfnWHGuWR5zmTPcchwlk3crT1F2cvEXdEWb1XV43Il+T7ZLfxYIDX0hYs98pHSAeZMeQnjKoAR6/crGe7AuvGyHRH5t3vo4b+mQ+m5shrVrW+x3agJSMWg1OPNpCH+vYj8VbWNmqythUcHpYNTXpmXjvWRkugMiZo1p4Gcgy9dIF6EVSU4fU0t5dZFK/GPeT8sJHE6St1pMpd2YTZiaxEav8AZH9k5ARcEkgkREMs1Bc1gPQCrmSUIdjItDUGjxVGcCM1U+vHVXCda3VozA+FO7qjpS4hR8UNV+vlHoOeJa31MgW4btZlmxh6RYNJHrXQP7KVxaRW9ebS+tX4AbNeG3cffg7s+x4tmlc+Ncszzma9n+5zJnuOUFDXrkOEom7w8g5O5WnqLsYfRg7eTiL+jTiO3pijar671caerwuBP9x9LR/J5sl/6pBlX/LBAa+ht62PtCxJ75da5c+EjpAPN/g8LyJj2E8BFXRvGUQQn0oyvL9fqVjffN/0/2YF142Vc3utgOifzaOeM+27z1cd6Ln7Pf0iH13eVLN9zYDGvX72ap1rbY79SBsi3VBKRi0DPOoNFqcObTXRok0hD+XsUnlJzEfiraxklAGMfMVlfC+zyVw6KC08GV6BHAqK9Ny5/Fj8rGe8nI8RELyXQHRMxDbYbNGtPAzy25As5Alq+Rd/xtkC5CK5IZKOmTnD6mlqtUZJfy6iKVxYDglPjHvJ/PrX6elhM4nKF5+p0kb7WYEwV3mUq7MZt90fOaMDWJjQdfS4xe4Q2OaYvPj+ydgIrb90KLgkkEibUjxoiIZJqDvw5YguawHoDR2tyBVMyThGOmUYU6GBeHDXLVhqDQ4qmXuiCozgRmqvlupKt8eOuuSxIprxKsb60lxq2sGIHxpy/rM6Z2VXWkQT+3pcQp+KDzQzqhqv18o52XvqLQc8S15xkGtL6nQLaJzYK3DNvNsjuxD7NiD0mxVWWLsGgi17tfSBW6BvZTuDGckbm0it68g+AcvdpeWr/tNJi+AAAAAEExGxmCYjYyw1MtKwTFbGRF9Hd9hqdaVseWQU8IitnISbvC0Yro7/rL2fTjDE+1rE1+rrWOLYOezxyYh1ESwkoQI9lT03D0eJJB72FV164uFOa1N9e1mByWhIMFWZgbghipAJvb+i2wmss2qV1dd+YcbGz/3z9B1J4OWs2iJISV4xWfjCBGsqdhd6m+puHo8efQ8+gkg97DZbLF2qquXV3rn0ZEKMxrb2n9cHauazE571oqICwJBwttOBwS8zZG37IHXcZxVHDtMGVr9PfzKru2wjGidZEciTSgB5D7vJ8Xuo2EDnneqSU477I8/3nzc75I6Gp9G8VBPCreWAVPefBEfmLphy1PwsYcVNsBihWUQLsOjYPoI6bC2Ti/DcWgOEz0uyGPp5YKzpaNEwkAzFxIMddFi2L6bspT4XdUXbu6FWygo9Y/jYiXDpaRUJjX3hGpzMfS+uHsk8v69VzXYnId5nlr3rVUQJ+ET1lYEg4WGSMVD9pwOCSbQSM9p2v9ZeZa5nwlCctXZDjQTqOukQHin4oYIcynM2D9vCqv4SSt7tA/tC2DEp9ssgmGqyRIyeoVU9ApRn77aHdl4vZ5Py+3SCQ2dBsJHTUqEgTyvFNLs41IUnDeZXkx735g/vPm57/C/f58kdDVPaDLzPo2ioO7B5GaeFS8sTllp6hLmIM7CqmYIsn6tQmIy64QT13vXw5s9EbNP9ltjA7CdEMSWvMCI0HqwXBswYBBd9hH1zaXBuYtjsW1AKWEhBu8GopBcVu7WmiY6HdD2dlsWh5PLRVffjYMnC0bJ90cAD4SAJi5UzGDoJBirovRU7WSFsX03Vf078SUp8Lv1ZbZ9um8B66ojRy3a94xnCrvKoXteWvKrEhw028bXfguKkbh4TbeZqAHxX9jVOhUImXzTeXzsgKkwqkbZ5GEMCagnym4rsXk+Z/e/TrM89Z7/ejPvGupgP1aspk+CZ+yfziEq7AkHCzxFQc1MkYqHnN3MQe04XBI9dBrUTaDRnp3sl1jTtf6yw/m4dLMtcz5jYTX4EoSlq8LI422yHCgnYlBu4RGXSMDB2w4GsQ/FTGFDg4oQphPZwOpVH7A+nlVgctiTB/FOIFe9COYnacOs9yWFaobAFTlWjFP/JliYtfYU3nOF0/hSVZ++lCVLdd71BzMYhOKjS1Su5Y0kei7H9DZoAbs835ercJlR26RSGwvoFN16DYSOqkHCSNqVCQIK2U/EeR5p5alSLyPZhuRpCcqir3gvMvyoY3Q62Le/cAj7+bZveG8FPzQpw0/g4omfrKRP7kk0HD4FctpO0bmQnp3/Vu1a2Xc9Fp+xTcJU+52OEj3sa4JuPCfEqEzzD+Kcv0kkwAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAMYoQAGEAAAB0AAAAJwAAADGKEABhAAAAawAAADMAAAAAAAAARjtnZYx2zsrKTamvWevtTh/QiivVnSOEk6ZE4bLW25307bz4PqAVV3ibcjLrPTbTrQZRtmdL+BkhcJ98JavG4GOQoYWp3Qgq7+ZvT3xAK646e0zL8DblZLYNggGXfR190UZ6GBsL07ddMLTSzpbwM4itl1ZC4D75BNtZnAtQ/BpNa5t/hyYy0MEdVbVSuxFUFIB2Md7N356Y9rj7uYYnh/+9QOI18OlNc8uOKOBtysmmVq2sbBsEAyogY2Yu+zr6aMBdn6KN9DDktpNVdxDXtDErsNH7Zhl+vV1+G5wt4WfaFoYCEFsvrVZgSMjFxgwpg/1rTEmwwuMPi6WGFqD4NVCbn1Ca1jb/3O1Rmk9LFXsJcHIewz3bsYUGvNSkdiOo4k1EzSgA7WJuO4oH/Z3O5rumqYNx6wAsN9BnSTMLPtV1MFmwv33wH/lGl3pq4NObLNu0/uaWHVGgrXo0gd3lSMfmgi0NqyuCS5BM59g2CAaeDW9jVEDGzBJ7oakd8AQvW8tjSpGGyuXXva2ARBvpYQIgjgTIbSerjlZAzq8m37LpHbjXI1AReGVrdh32zTL8sPZVmXq7/DY8gJtTOFvCz35gpaq0LQwF8hZrYGGwL4Eni0jk7cbhS6v9hi6KjRlSzLZ+Nwb715hAwLD902b0HJVdk3lfEDrWGStdsyxA8Wtqe5YOoDY/oeYNWMR1qxwlM5B7QPnd0u+/5rWKnpYq9titTZMS4OQ8VNuDWcd9x7iBRqDdSwsJcg0wbhcJ6zeLT9BQ7oWd+UHDpp4kUADaxRY7vaDcdhQPmk1zars97Bb9BotzN0si3HFwRbni1gFYpO1mPW6gz5Iom6j3JxANcWErahSrZsO77V2k3n774D84wIda8o0u9bS2SZCVxtbs0/2xiRmwGCZfi39DzC07oooWXMdAW/VoBmCSDQK7y5FEgKz0js0FW8j2Yj5bUCbfHWtButcm6BWRHY9wsG0QDPZWd2k8G97GeiC5o+mG/UKvvZonZfAziCPLVO064AlefNtuO7aWx5TwraDxYwvkECUwg3XvfSraqUZNv4g20sPODbWmBEAcCUJ7e2zR3T+Nl+ZY6F2r8UcbkJYiH0vPvllwqNuTPQF01QZmEUagIvAAm0WVytbsOozti1+tnRQj66ZzRiHr2uln0L2M9Hb5bbJNngh4ADenPjtQwjGw9UR3i5IhvcY7jvv9XOtoWxgKLmB/b+Qt1sCiFrGlg2Yu2cVdSbwPEOATSSuHdtqNw5ectqTyVvsNXRDAajgUGzOkUiBUwZht/W7eVpoLTfDe6gvLuY/BhhAgh713RabN6Dng9o9cKrsm82yAQZb/JgV3uR1iEnNQy701a6zYAAAAAFiA4tfxBrR0qYZWo+INaOm6jYo+EwvcnUuLPkqFHaEJ3Z1D3nQbFX0sm/eqZxDJ4D+QKzeWFn2UzpafQwo7QhNSu6DE+z32Z6O9FLDoNir6sLbILRkwno5BsHxZjybjGtemAc1+IFduJqC1uW0ri/M1q2kknC0/h8St3VAUdoQmTPZm8eVwMFK98NKF9nvsz677DhgHfVi7X/26bJFrJS/J68f4YG2RWzjtc4xzZk3GK+avEYJg+bLa4BtlHk3GNUbNJOLvS3JBt8uQlvxArtykwEwLDUYaqFXG+H+bUGc8w9CF62pW00gy1jGfeV0P1SHd7QKIW7uh0NtZdijsCE1wbOqa2eq8OYFqXu7K4WCkkmGCczvn1NBjZzYHrfGpRPVxS5Nc9x0wBHf/50/8wa0XfCN6vvp12eZ6lw4i10peeleoidPR/iqLURz9wNoit5hawGAx3JbDaVx0FKfK61f/SgmAVsxfIw5MvfRFx4O+HUdhabTBN8rsQdUdPJqMa2QabrzNnDgflRzayN6X5IKGFwZVL5FQ9ncRsiG5hy1i4QfPtUiBmRYQAXvBW4pFiwMKp1yqjPH/8gwTKDahznhuISyvx6d6DJ8nmNvUrKaRjCxERiWqEuV9KvAys7xvces8jaZCutsFGjo50lGxB5gJMeVPoLez7Pg3UTtQ2BGaCFjzTaHepe75Xkc5stV5c+pVm6RD080HG1Mv0NXFsJONRVJEJMME53xD5jA3yNh6b0g6rcbObA6eTo7ZWuNTiQJjsV6r5ef982UFKrjuO2Dgbtm3SeiPFBFobcPf/vKAh34QVy74RvR2eKQjPfOaaWVzeL7M9S4dlHXMykSulbwcLndrtaghyO0owx+mo/1V/iMfglelSSEPJav2wbM0tZkz1mIwtYDBaDViFiO+XFx7Pr6L0rjoKIo4Cv9OldevFhU1eL+TY9vnE4EMrJi/RvQYXZFdngsyBR7p5cuIdqaTCJRxOo7C0mIOIAUphR5PcQX8mNiDqjuAA0jseDQZ1yC0+wCJMq2j0bJPdJo5cT7CuZPpaz/FSjO/J539KbjepalaCQwvDKpUr+59HyTQN0ekMuDuImRDtqKGlHIPW8Qqj7kTgwnvsNuJDWeQAjMtyILR+mEEh1k5hGWO9xL6za+SGBoGFE65XpSsbhUfkiRNn3Dz5BkmULyZxIdsQp3xNMJ/Jp1EKYXFxMtSjk/1GNbPF89/SUFsJ8mju+lfPPix394vGFmIjEDZalsLUlQRU9K2xvpU4GWi1AKyZnnf4j75PTWXf2uWz/+JQYR0twvc9FXcdXIDfy3y4ajjZH7ru+ScPBJiyp9K4ihIAWkWAlnp9NXwb6J2qO9AoQAAAADhtlLvg2vUBWLdhuoG16gL52H65IW8fA5kCi7hDK5RF+0YA/iPxYUSbnPX/Qp5+Rzrz6vziRItGWikf/YYXKMu+erxwZs3dyt6gSXEHosLJf89Wcqd4N8gfFaNzxTy8jn1RKDWl5kmPHYvdNMSJVoy85MI3ZFOjjdw+NzYMLhGXdEOFLKz05JYUmXAtzZv7lbX2by5tQQ6U1SyaLw8FhdK3aBFpb99w09ey5GgOsG/Qdt37a65qmtEWBw5qyjk5XPJUrecq48xdko5Y5kuM014z4Ufl61YmX1M7suSJEq0ZMX85ounIWBhRpcyjiKdHG/DK06AofbIakBAmoVgcI26gcbfVeMbWb8CrQtQZqclsYcRd17lzPG0BHqjW2ze3K2NaI5C77UIqA4DWkdqCXSmi78mSelioKMI1PJMeCwulJmafHv7R/qRGvGofn77hp+fTdRw/ZBSmhwmAHV0gn+DlTQtbPfpq4YWX/lpclXXiJPjhWfxPgONEIhRYlDIy+exfpkI06Mf4jIVTQ1WH2Pst6kxA9V0t+k0wuUGXGaa8L3QyB/fDU71PrscGlqxMvu7B2AU2drm/jhstBFIlGjJqSI6Jsv/vMwqSe4jTkPAwq/1ki3NKBTHLJ5GKEQ6Od6ljGsxx1Ht2ybnvzRC7ZHVo1vDOsGGRdAgMBc/geZrrmBQOUECjb+r4zvtRIcxw6Vmh5FKBFoXoOXsRU+NSDq5bP5oVg4j7rzvlbxTi5+SsmopwF0I9Ea36UIUWJm6yIB4DJpvGtEchftnTmqfbWCLftsyZBwGtI79sOZhlRSZl3Siy3gWf02S98kffZPDMZxydWNzEKjlmfEet3axXi3zUOh/HDI1+fbTg6sZt4mF+FY/1xc04lH91VQDEr3wfORcRi4LPpuo4d8t+g67J9TvWpGGADhMAOrZ+lIFqQKO3Ui03DIqaVrYy98IN6/VJtZOY3Q5LL7y080IoDylrN/KRBqNJSbHC8/HcVkgo3t3wULNJS4gEKPEwabxK+GW5hQAILT7Yv0yEYNLYP7nQU4fBvcc8GQqmhqFnMj17Ti3AwyO5exuU2MGj+Ux6evvHwgKWU3naITLDYkymeL5ykU6GHwX1XqhkT+bF8PQ/x3tMR6rv958djk0ncBr2/VkFC0U0kbCdg/AKJe5ksfzs7wmEgXuyXDYaCORbjrM0S6gSTCY8qZSRXRMs/Mmo9f5CEI2T1qtVJLcR7UkjqjdgPFePDajsV7rJVu/XXe021dZVTrhC7pYPI1QuYrfv8lyA2coxFGIShnXYquvhY3PpatsLhP5g0zOf2mteC2GxdxScCRqAJ9Gt4Z1pwHUmsML+nsivaiUQGAufqHWfJEAAAAAQ8umh8eQPNSEW5pTzycIc4zsrvQItzSnS3ySIJ5PEObdhLZhWd8sMhoUirVRaBiVEqO+Epb4JEHVM4LGfZlRFz5S95C6CW3D+cLLRLK+WWTxdf/jdS5lsDblwzfj1kHxoB3ndiRGfSVnjduiLPFJgm867wXrYXVWqKrT0foyoy65+QWpPaKf+n5pOX01Fatddt4N2vKFl4mxTjEOZH2zyCe2FU+j7Y8c4CYpm6tau7vokR08bMqHby8BIeiHq/I5xGBUvkA7zu0D8GhqSIz6SgtHXM2PHMaezNdgGRnk4t9aL0RY3nTeC52/eIzWw+qslQhMKxFT1nhSmHD/9GVGXbeu4Noz9XqJcD7cDjtCTi54ieip/NJy+r8Z1H1qKla7KeHwPK26am/ucczopQ1eyObG+E9inWIcIVbEm4n8F0rKN7HNTmwrng2njRlG2x85BRC5voFLI+3CgIVqF7MHrFR4oSvQIzt4k+id/9iUD9+bX6lYHwQzC1zPlYwOV+VzTZxD9MnH2aeKDH8gwXDtAIK7S4cG4NHURSt3U5AY9ZXT01MSV4jJQRRDb8ZfP/3mHPRbYZivwTLbZGe1c860ZDAFEuO0Xoiw95UuN7zpvBf/IhqQe3mAwziyJkTtgaSCrkoCBSoRmFZp2j7RIqas8WFtCnblNpAlpv02oujLjLqrACo9L1uwbmyQFukn7ITJZCciTuB8uB2jtx6adoScXDVPOtuxFKCI8t8GD7mjlC/6aDKofjOo+z34DnyVUt2t1pl7KlLC4XkRCUf+WnXV3hm+c1md5ekK3i5PjQsdzUtI1mvMzI3xn49GVxjEOsU4h/FjvwOq+exAYV9rEvkvlFEyiRPVaRNAlqK1x93eJ+eeFYFgGk4bM1mFvbSMtj9yz32Z9UsmA6YI7aUhQ5E3AQBakYaEAQvVx8qtUm9gfoMsq9gEqPBCV+s75NCgR3bw44zQd2fXSiQkHOyj8S9uZbLkyOI2v1KxdXT0Nj4IZhZ9w8CR+ZhawrpT/EUcrsrnX2VsYNs+9jOY9VC004nClJBCZBMUGf5AV9JYx4Lh2gHBKnyGRXHm1Qa6QFJNxtJyDg109YpW7qbJnUghYTeb8CL8PXemp6ck5WwBo64Qk4Pt2zUEaYCvVypLCdD/eIsWvLMtkTjot8J7IxFFMF+DZXOUJeL3z7+xtAQZNuacacmlV89OIQxVHWLH85opu2G6anDHPe4rXW6t4PvpeNN5LzsY36i/Q0X7/IjjfLf0cVz0P9fbcGRNiDOv6w+bBTje2M6eWVyVBAofXqKNVCIwrRfpliqTsgx50Hmq/gVKKDhGgY6/wtoU7IERsmvKbSBLiaaGzA39HJ9ONroYAAAAAJYwB3csYQ7uulEJmRnEbQeP9GpwNaVj6aOVZJ4yiNsOpLjceR7p1eCI2dKXK0y2Cb18sX4HLbjnkR2/kGQQtx3yILBqSHG5895BvoR91Noa6+TdbVG11PTHhdODVphsE8Coa2R6+WL97Mllik9cARTZbAZjYz0P+vUNCI3IIG47XhBpTORBYNVycWei0eQDPEfUBEv9hQ3Sa7UKpfqotTVsmLJC1sm720D5vKzjbNgydVzfRc8N1txZPdGrrDDZJjoA3lGAUdfIFmHQv7X0tCEjxLNWmZW6zw+lvbieuAIoCIgFX7LZDMYk6Quxh3xvLxFMaFirHWHBPS1mtpBB3HYGcdsBvCDSmCoQ1e+JhbFxH7W2BqXkv58z1LjooskHeDT5AA+OqAmWGJgO4bsNan8tPW0Il2xkkQFcY+b0UWtrYmFsHNgwZYVOAGLy7ZUGbHulARvB9AiCV8QP9cbZsGVQ6bcS6ri+i3yIufzfHd1iSS3aFfN804xlTNT7WGGyTc5RtTp0ALyj4jC71EGl30rXldg9bcTRpPv01tNq6WlD/NluNEaIZ63QuGDacy0EROUdAzNfTAqqyXwN3TxxBVCqQQInEBALvoYgDMkltWhXs4VvIAnUZrmf5GHODvneXpjJ2SkimNCwtKjXxxc9s1mBDbQuO1y9t61susAgg7jttrO/mgzitgOa0rF0OUfV6q930p0VJtsEgxbccxILY+OEO2SUPmptDahaanoLzw7knf8JkyeuAAqxngd9RJMP8NKjCIdo8gEe/sIGaV1XYvfLZ2WAcTZsGecGa252G9T+4CvTiVp62hDMSt1nb9+5+fnvvo5DvrcX1Y6wYOij1tZ+k9GhxMLYOFLy30/xZ7vRZ1e8pt0GtT9LNrJI2isN2EwbCq/2SgM2YHoEQcPvYN9V32eo745uMXm+aUaMs2HLGoNmvKDSbyU24mhSlXcMzANHC7u5FgIiLyYFVb47usUoC72yklq0KwRqs1yn/9fCMc/QtYue2Swdrt5bsMJkmybyY+yco2p1CpNtAqkGCZw/Ng7rhWcHchNXAAWCSr+VFHq44q4rsXs4G7YMm47Skg2+1eW379x8Id/bC9TS04ZC4tTx+LPdaG6D2h/NFr6BWya59uF3sG93R7cY5loIiHBqD//KOwZmXAsBEf+eZY9prmL40/9rYUXPbBZ44gqg7tIN11SDBE7CswM5YSZnp/cWYNBNR2lJ23duPkpq0a7cWtbZZgvfQPA72DdTrrypxZ673n/Pskfp/7UwHPK9vYrCusowk7NTpqO0JAU20LqTBtfNKVfeVL9n2SMuemazuEphxAIbaF2UK28qN74LtKGODMMb3wVaje8CLW1pZCA+IGxlbgAAAFAvHwAJAAAAWWIQAGwAAAAYAAAAEgAAAOyPEABnAAAAKQAAACsAAADsjxAAZwAAACoAAAArAAAA7I8QAGcAAAA1AAAADQAAAOyPEABnAAAAPQAAACsAAADsjxAAZwAAAE0AAAARAAAA7I8QAGcAAABlAAAAEwAAAOyPEABnAAAAbgAAAA0AAADsjxAAZwAAAHYAAAArAAAA7I8QAGcAAAB2AAAATgAAAOyPEABnAAAAggAAABEAAADgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAyNDAfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAAdDAfABoAAADgZhAAXQAAADAHAAAFAAAAQF4QAGsAAAAYAAAAFwAAAEBeEABrAAAARgAAAB8AAABAXhAAawAAAIMAAAAeAAAAbmVlZCBsb29rYWhlYWQAANgwHwAOAAAAQF4QAGsAAACFAAAABQAAAEBeEABrAAAA5AAAABUAAABAXhAAawAAANwAAAAVAAAAQF4QAGsAAAD1AAAAQwAAAHdpbGQgc2NhbgAAADAxHwAJAAAAQF4QAGsAAAD5AAAACQAAAEBeEABrAAAAEgEAAB4AAABAXhAAawAAAFIBAAAJAAAAQF4QAGsAAAAyAQAANQAAAGluZGV4IG91dCBvZiBib3VuZHMAhDEfABMAAABAXhAAawAAADMBAAAVAAAAQF4QAGsAAAAgAQAAGwAAAGludmFsaWQgc2NhbsAxHwAMAAAAQF4QAGsAAABfAAAAEQAAAG1pZCA+IGxlbgAAAOQxHwAJAAAA2hEQAGwAAACPAAAAEgAAANoREABsAAAAcwAAABYAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAAGgyHwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAN4FAAAVAAAA4GYQAF0AAADhBQAACgAAAOBmEABdAAAA7gYAADcAAADgZhAAXQAAAO4GAABFAAAAbW9yZSA8IDLYMx8ACAAAAOBmEABdAAAADQcAAAkAAADgZhAAXQAAABgHAAAaAAAA4GYQAF0AAAAZBwAAGgAAAG5vdCBlbm91Z2ggcm9vbSBmb3Igc2VhcmNoAAAYNB8AGgAAAOBmEABdAAAAMAcAAAUAAABkZXN0IGlzIG91dCBvZiBib3VuZHMAAABMNB8AFQAAAG1pZCA+IGxlbgAAAGw0HwAJAAAAf5cQAF0AAAAhAAAACAAAAD6YEABbAAAAUQAAAAwAAAB5bBAAawAAACEAAAAuAAAAeWwQAGsAAAAhAAAARAAAAHdpbGQgc2NhbgAAAMA0HwAJAAAAeWwQAGsAAAArAAAADQAAAHlsEABrAAAAPAAAABYAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAAEQ1HwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAylDYfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAA1DYfABoAAADgZhAAXQAAADAHAAAFAAAA74sQAG4AAABDAAAAKQAAAO+LEABuAAAASAAAAA4AAADvixAAbgAAAE0AAAAOAAAA74sQAG4AAABbAAAANAAAAO+LEABuAAAAkAAAABYAAADvixAAbgAAAMAAAAAOAAAAuGAQAGUAAAAXAAAAKQAAALhgEABlAAAAFwAAADUAAAByZXdpbmRpbmcgcGFzdCB0aGVuIHN0YXJ0AAAAiDcfABkAAABidWYubGVuKCkgbXVzdCBmaXQgaW4gcmVtYWluaW5nKCkAAACsNx8AIQAAAL2WEABoAAAABQAAACwAAAC9lhAAaAAAAAYAAAAsAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5idWYuaXNfZW1wdHkoKSB8fCBzZWxmLmJ1Zi5sZW4oKSA+PSBTZWxmOjpwYWRkaW5nKCkAAK4SEABkAAAAIQAAAAkAAACuEhAAZAAAAD0AAAAdAAAArhIQAGQAAAB2AAAAKAAAAK4SEABkAAAAdgAAADUAAACuEhAAZAAAAG8AAAA3AAAArhIQAGQAAABvAAAARAAAAK4SEABkAAAAegAAADcAAABHNhAAZAAAAEcAAAAJAAAARzYQAGQAAACgAAAAKQAAAEc2EABkAAAAoQAAACQAAABHNhAAZAAAAKEAAAAzAAAARzYQAGQAAADrAAAAIwAAAEc2EABkAAAA7AAAABgAAABHNhAAZAAAAOwAAAAjAAAARzYQAGQAAADzAAAALAAAAEc2EABkAAAA8wAAABkAAABpbiBib3VuZHMAAABHNhAAZAAAAAQBAAA6AAAARzYQAGQAAAAMAQAAEQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAAEuOEAAqAAAAsQQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsgbWF4X292ZXJoZWFkAABLjhAAKgAAALcEAAANAEH48/wAC+IMAQAAAKMFAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlTGF5b3V0RXJyb3IAAL5nEABeAAAAYAAAAD4AAAC+ZxAAXgAAAHMAAAA+AAAAvmcQAF4AAACNAAAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IGxheW91dC5hbGlnbigpIDw9IEFMSUdOLmludG8oKb5nEABeAAAAwQAAAAkAAAC+ZxAAXgAAABcBAAAJAAAAAAAAAGludmFsaWQgc2l6ZSBmb3IgAAAAvDofABEAAAC+ZxAAXgAAAFgBAAARAAAAbWlkID4gbGVuAAAA6DofAAkAAADNGBAAbAAAAFYAAAASAAAAzRgQAGwAAAAjAAAAJgAAAOyPEABnAAAAKQAAACsAAADsjxAAZwAAACoAAAArAAAA7I8QAGcAAAA1AAAADQAAAB5hEABlAAAANQAAAC8AAAAeYRAAZQAAADUAAAA+AAAAdGFsbHlfZGlzdDogYmFkIG1hdGNoAAAAbDsfABUAAADgZhAAXQAAANkFAAAJAAAAAAECAwQFBgcICAkJCgoLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQEBAQEBEREREREREREhISEhISEhITExMTExMTExQUFBQUFBQUFBQUFBQUFBQVFRUVFRUVFRUVFRUVFRUVFhYWFhYWFhYWFhYWFhYWFhcXFxcXFxcXFxcXFxcXFxcYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhobGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbHOBmEABdAAAA3gUAABUAAADgZhAAXQAAAOEFAAAKAAAA4GYQAF0AAADuBgAANwAAAOBmEABdAAAA7gYAAEUAAABtb3JlIDwgMtw8HwAIAAAA4GYQAF0AAAANBwAACQAAAOBmEABdAAAAGAcAABoAAADgZhAAXQAAABkHAAAaAAAAbm90IGVub3VnaCByb29tIGZvciBzZWFyY2gAABw9HwAaAAAA4GYQAF0AAAAwBwAABQAAAG1pZCA+IGxlbgAAAFA9HwAJAAAA3VEQAG4AAADBAAAAKQAAAN1REABuAAAAwQAAADsAAADdURAAbgAAABkBAAAUAAAA3VEQAG4AAAAaAQAAFwAAAN1REABuAAAAHQEAAAgAAADdURAAbgAAAB0BAAAQAAAA3VEQAG4AAAAnAQAAFAAAAN1REABuAAAAKAEAABcAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAAAeYRAAZQAAADUAAAAvAAAAHmEQAGUAAAA1AAAAPgAAAHRhbGx5X2Rpc3Q6IGJhZCBtYXRjaAAAADQ+HwAVAAAA4GYQAF0AAADZBQAACQAAAAABAgMEBQYHCAgJCQoKCwsMDAwMDQ0NDQ4ODg4PDw8PEBAQEBAQEBARERERERERERISEhISEhISExMTExMTExMUFBQUFBQUFBQUFBQUFBQUFRUVFRUVFRUVFRUVFRUVFRYWFhYWFhYWFhYWFhYWFhYXFxcXFxcXFxcXFxcXFxcXGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxzgZhAAXQAAAN4FAAAVAAAA4GYQAF0AAADhBQAACgAAAOBmEABdAAAA7gYAADcAAADgZhAAXQAAAO4GAABFAAAAbW9yZSA8IDKkPx8ACAAAAOBmEABdAAAADQcAAAkAAADgZhAAXQAAABgHAAAaAAAA4GYQAF0AAAAZBwAAGgAAAG5vdCBlbm91Z2ggcm9vbSBmb3Igc2VhcmNoAADkPx8AGgAAAOBmEABdAAAAMAcAAAUAAABkZXN0IGlzIG91dCBvZiBib3VuZHMAAAAYQB8AFQAAAAAAAAAEAAAABAAAAEMFAAC7gBAAawAAACQAAAAOAAAApAUAQeSA/QALAqUFAEHwgP0AC6sFpgUAAAQABAAIAAQApwUAAAQABgAQAAYApwUAAAQADAAgABgApwUAAAgAEAAgACAApwUAAAgAEACAAIAAqAUAAAgAIACAAAABqAUAACAAgAACAQAEqAUAACAAAgECAQAQExMQAGQAAABHAAAAKgAAAA0uEABmAAAASQAAABQAAAANLhAAZgAAAFsAAAAJAAAADS4QAGYAAABcAAAACQAAAAMABAAFAAYABwAIAAkACgALAA0ADwARABMAFwAbAB8AIwArADMAOwBDAFMAYwBzAIMAowDDAOMAAgEAAAAAEAAQABAAEAAQABAAEAAQABEAEQARABEAEgASABIAEgATABMAEwATABQAFAAUABQAFQAVABUAFQAQAE0AygABAAIAAwAEAAUABwAJAA0AEQAZACEAMQBBAGEAgQDBAAEBgQEBAgEDAQQBBgEIAQwBEAEYASABMAFAAWAAAAAAEAAQABAAEAARABEAEgASABMAEwAUABQAFQAVABYAFgAXABcAGAAYABkAGQAaABoAGwAbABwAHAAdAB0AQABAAA0uEABmAAAAogAAABcAAAANLhAAZgAAAKUAAAAVAAAADS4QAGYAAAC6AAAAHgAAAA0uEABmAAAAxQAAAAkAAAANLhAAZgAAAMoAAAAYAAAADS4QAGYAAADKAAAAEwAAAA0uEABmAAAAAgEAAA4AAAANLhAAZgAAAAIBAAAJAAAADS4QAGYAAADwAAAADQAAAA0uEABmAAAAvAAAAA0AAAANLhAAZgAAAH4AAAAaAAAADS4QAGYAAACAAAAADQAAAA0uEABmAAAASgAAAAkAAABtaWQgPiBsZW4AAADcQh8ACQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAQaSG/QAL6qIBAQAAAKkFAAAAAAAABAAAAAQAAABEAQAAVHJ5RnJvbUludEVycm9yAAwACACMAAgATAAIAMwACAAsAAgArAAIAGwACADsAAgAHAAIAJwACABcAAgA3AAIADwACAC8AAgAfAAIAPwACAACAAgAggAIAEIACADCAAgAIgAIAKIACABiAAgA4gAIABIACACSAAgAUgAIANIACAAyAAgAsgAIAHIACADyAAgACgAIAIoACABKAAgAygAIACoACACqAAgAagAIAOoACAAaAAgAmgAIAFoACADaAAgAOgAIALoACAB6AAgA+gAIAAYACACGAAgARgAIAMYACAAmAAgApgAIAGYACADmAAgAFgAIAJYACABWAAgA1gAIADYACAC2AAgAdgAIAPYACAAOAAgAjgAIAE4ACADOAAgALgAIAK4ACABuAAgA7gAIAB4ACACeAAgAXgAIAN4ACAA+AAgAvgAIAH4ACAD+AAgAAQAIAIEACABBAAgAwQAIACEACAChAAgAYQAIAOEACAARAAgAkQAIAFEACADRAAgAMQAIALEACABxAAgA8QAIAAkACACJAAgASQAIAMkACAApAAgAqQAIAGkACADpAAgAGQAIAJkACABZAAgA2QAIADkACAC5AAgAeQAIAPkACAAFAAgAhQAIAEUACADFAAgAJQAIAKUACABlAAgA5QAIABUACACVAAgAVQAIANUACAA1AAgAtQAIAHUACAD1AAgADQAIAI0ACABNAAgAzQAIAC0ACACtAAgAbQAIAO0ACAAdAAgAnQAIAF0ACADdAAgAPQAIAL0ACAB9AAgA/QAIABMACQATAQkAkwAJAJMBCQBTAAkAUwEJANMACQDTAQkAMwAJADMBCQCzAAkAswEJAHMACQBzAQkA8wAJAPMBCQALAAkACwEJAIsACQCLAQkASwAJAEsBCQDLAAkAywEJACsACQArAQkAqwAJAKsBCQBrAAkAawEJAOsACQDrAQkAGwAJABsBCQCbAAkAmwEJAFsACQBbAQkA2wAJANsBCQA7AAkAOwEJALsACQC7AQkAewAJAHsBCQD7AAkA+wEJAAcACQAHAQkAhwAJAIcBCQBHAAkARwEJAMcACQDHAQkAJwAJACcBCQCnAAkApwEJAGcACQBnAQkA5wAJAOcBCQAXAAkAFwEJAJcACQCXAQkAVwAJAFcBCQDXAAkA1wEJADcACQA3AQkAtwAJALcBCQB3AAkAdwEJAPcACQD3AQkADwAJAA8BCQCPAAkAjwEJAE8ACQBPAQkAzwAJAM8BCQAvAAkALwEJAK8ACQCvAQkAbwAJAG8BCQDvAAkA7wEJAB8ACQAfAQkAnwAJAJ8BCQBfAAkAXwEJAN8ACQDfAQkAPwAJAD8BCQC/AAkAvwEJAH8ACQB/AQkA/wAJAP8BCQAAAAcAQAAHACAABwBgAAcAEAAHAFAABwAwAAcAcAAHAAgABwBIAAcAKAAHAGgABwAYAAcAWAAHADgABwB4AAcABAAHAEQABwAkAAcAZAAHABQABwBUAAcANAAHAHQABwADAAgAgwAIAEMACADDAAgAIwAIAKMACABjAAgA4wAIAJtcEABtAAAAjgAAABIAAACbXBAAbQAAAGkAAAA3AAAAm1wQAG0AAABqAAAAEQAAAJtcEABtAAAAcAAAADkAAACbXBAAbQAAAHIAAAAfAAAAm1wQAG0AAAB0AAAALwAAAJtcEABtAAAAgQAAADgAAADsjxAAZwAAACkAAAArAAAA7I8QAGcAAAAqAAAAKwAAAOyPEABnAAAANQAAAA0AAADgZhAAXQAAAO4GAAA3AAAA4GYQAF0AAADuBgAARQAAAG1vcmUgPCAyjEgfAAgAAADgZhAAXQAAAA0HAAAJAAAA4GYQAF0AAAAYBwAAGgAAAOBmEABdAAAAGQcAABoAAABub3QgZW5vdWdoIHJvb20gZm9yIHNlYXJjaAAAzEgfABoAAADgZhAAXQAAADAHAAAFAAAATWsQAGAAAAAmAAAAJAAAAAAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAQTEbGYJiNjLDUy0rBMVsZEX0d32Gp1pWx5ZBTwiK2chJu8LRiujv+svZ9OMMT7WsTX6utY4tg57PHJiHURLCShAj2VPTcPR4kkHvYVXXri4U5rU317WYHJaEgwVZmBuCGKkAm9v6LbCayzapXV135hxsbP/fP0HUng5azaIkhJXjFZ+MIEayp2F3qb6m4ejx59Dz6CSD3sNlssXaqq5dXeufRkQozGtvaf1wdq5rMTnvWiogLAkHC204HBLzNkbfsgddxnFUcO0wZWv09/Mqu7bCMaJ1kRyJNKAHkPu8nxe6jYQOed6pJTjvsjz/efNzvkjoan0bxUE8Kt5YBU958ER+YumHLU/CxhxU2wGKFZRAuw6Ng+gjpsLZOL8NxaA4TPS7IY+nlgrOlo0TCQDMXEgx10WLYvpuylPhd1Rdu7oVbKCj1j+NiJcOlpFQmNfeEanMx9L64eyTy/r1XNdich3meWvetVRAn4RPWVgSDhYZIxUP2nA4JJtBIz2na/1l5lrmfCUJy1dkONBOo66RAeKfihghzKczYP28Kq/hJK3u0D+0LYMSn2yyCYarJEjJ6hVT0ClGfvtod2Xi9nk/L7dIJDZ0GwkdNSoSBPK8U0uzjUhScN5leTHvfmD+8+bnv8L9/nyR0NU9oMvM+jaKg7sHkZp4VLyxOWWnqEuYgzsKqZgiyfq1CYjLrhBPXe9fDmz0Rs0/2W2MDsJ0QxJa8wIjQerBcGzBgEF32EfXNpcG5i2OxbUApYSEG7waikFxW7taaJjod0PZ2WxaHk8tFV9+NgycLRsn3RwAPhIAmLlTMYOgkGKui9FTtZIWxfTdV/TvxJSnwu/Vltn26bwHrqiNHLdr3jGcKu8qhe15a8qsSHDTbxtd+C4qRuHhNt5moAfFf2NU6FQiZfNN5fOyAqTCqRtnkYQwJqCfKbiuxeT5n979Oszz1nv96M+8a6mA/VqymT4Jn7J/OISrsCQcLPEVBzUyRioec3cxB7ThcEj10GtRNoNGeneyXWNO1/rLD+bh0sy1zPmNhNfgShKWrwsjjbbIcKCdiUG7hEZdIwMHbDgaxD8VMYUODihCmE9nA6lUfsD6eVWBy2JMH8U4gV70I5idpw6z3JYVqhsAVOVaMU/8mWJi19hTec4XT+FJVn76UJUt13vUHMxiE4qNLVK7ljSR6Lsf0NmgBuzzfl6twmVHbpFIbC+gU3XoNhI6qQcJI2pUJAgrZT8R5HmnlqVIvI9mG5GkJyqKveC8y/KhjdDrYt79wCPv5tm94bwU/NCnDT+DiiZ+spE/uSTQcPgVy2k7RuZCenf9W7VrZdz0Wn7FNwlT7nY4SPexrgm48J8SoTPMP4py/SSTAAAAADdqwgFu1IQDWb5GAtyoCQfrwssGsnyNBIUWTwW4URMOjzvRD9aFlw3h71UMZPkaCVOT2AgKLZ4KPUdcC3CjJhxHyeQdHneiHykdYB6sCy8bm2HtGsLfqxj1tWkZyPI1Ev+Y9xOmJrERkUxzEBRaPBUjMP4Ueo64Fk3kehfgRk041yyPOY6SyTu5+As6PO5EPwuEhj5SOsA8ZVACPVgXXjZvfZw3NsPaNQGpGDSEv1cxs9WVMOpr0zLdAREzkOVrJKePqSX+Me8nyVstJkxNYiN7J6AiIpnmIBXzJCEotHgqH966K0Zg/ClxCj4o9BxxLcN2syyayPUuraI3L8CNmnD351hxrlkec5kz3HIcJZN3K09RdnLxF3RFm9V1eNyJfk+2S38WCA19IWLPfKR0gHmTHkJ4yqAEev3KxnuwLrxsh0R+bd76OG/pkPpubIa1a1vsd2oCUjFoNTjzaQh/r2I/FW1jZqsrYVHB6WDU16Zl471kZLoDImaNaeBnIMvXSBehFUlOH1NLeXWRSvxj3k/LCRxOkrdaTKXdmE2YmsRGr/AGR/ZOQEXBJIJERDLNQXNYD0Aq5klCHYyLQ1Bo8VRnAjNVPrx1VwnWt1aMwPhTu6o6UuIUfFDVfr5R6DniWt9TIFuG7WZZsYekWDSR610D+ylcWkVvXm0vrV+AGzXht3H34O7PseLZpXPjXLM85mvZ/ucyZ7jlBQ165DhKJu8PIOTuVp6i7GH0YO3k4i/o04jt6Yo2q+u9XGnq8LgT/cfS0fyebJf+qQZV/ywQGvobetj7QsSe+XWuXPhI6QDzf4PC8iY9hPARV0bxlEEJ9KMry/X6lY33zf9P9mBdeNlXN7rYDon82jnjPtu89XHei5+z39Ih9d3lSzfc2Axr1+9mqda22O/UgbIt1QSkYtAzzqDRanDm010aJNIQ/l7FJ5ScxH4q2sZJQBjHzFZXwvs8lcOigtPBlegRwKivTcufxY/KxnvJyPERC8l0B0TMQ22GzRrTwM8tuQLOQJavkXf8bZAuQiuSGSjpk5w+pparVGSX8uoilcWA4JT4x7yfz61+npYTOJyhefqdJG+1mBMFd5lKuzGbfdHzmjA1iY0HX0uMXuENjmmLz4/snYCK2/dCi4JJBIm1I8aIiGSag78OWILmsB6A0drcgVTMk4RjplGFOhgXhw1y1Yag0OKpl7ogqM4EZqr5bqSrfHjrrksSKa8SrG+tJcatrBiB8acv6zOmdlV1pEE/t6XEKfig80M6oar9fKOdl76i0HPEtecZBrS+p0C2ic2CtwzbzbI7sQ+zYg9JsVVli7BoIte7X0gVugb2U7gxnJG5tIrevIPgHL3aXlq/7TSYvgAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd4AAAAAsClgPWBTwHrQeqBHwKaA9XCP4Mig9UCPENwgssFLcDBxYhANoRiwShEx0HcB7fDFscSQ+GG+ML/Rl1CCgpfgYDK+gF3ixCAaUu1AJ0IxYJXyGACoImKg75JLwNJD3JBQ8/XwbSOPUCqTpjAXg3oQpTNTcJjjKdDfUwCw4gQvwcG0BqH8ZHwBu9RVYYbEiUE0dKAhCaTagU4U8+FzxWSx8XVN0cylN3GLFR4RtgXCMQS161E5ZZHxftW4kUOGuCGhNpFBnObr4dtWwoHmRh6hVPY3wWkmTWEulmQBE0fzUZH32jGsJ6CR65eJ8daHVdFkN3yxWecGER5XL3EjSVjzWPlxk2UpCzMimSJTH4n+c6051xOQ6a2z11mE0+qIE4NoODrjVehAQxJYaSMvSLUDnficY6Ao5sPnmM+j2svPEzh75nMFq5zTQhu1s38LaZPNu0Dz8Gs6U7fbEzOKCoRjCLqtAzVq16Ny2v7DT8oi4/16C4PAqnEjhxpYQ7pNdzKZ/V5SpC0k8uOdDZLejdGybD340lHtgnIWXasSK4w8Qqk8FSKU7G+C01xG4u5MmsJc/LOiYSzJAiac4GIbz+DS+X/JssSvsxKDH5pyvg9GUgy/bzIxbxWSdt888ksOq6LJvoLC9G74YrPe0QKOzg0iPH4kQgGuXuJGHneCe5Kw5rEimYaM8uMmy0LKRvZSFmZE4j8GeTJFpj6CbMYDU/uWgePS9rwzqFb7g4E2xpNdFnQjdHZJ8w7WDkMntjMQJwbRoA5m7HB0xqvAXaaW0IGGJGCo5hmw0kZeAPsmY9FsduFhRRbcsT+2mwEW1qYRyvYUoeOWKXGZNm7BsFZTlp8ncCa2R032zOcKRuWHN1Y5p4XmEMe4Nmpn/4ZDB8JX1FdA5/03fTeHlzqHrvcHl3LXtSdbt4j3IRfPRwh38hQIxxCkIactdFsHasRyZ1fUrkflZIcn2LT9h58E1Oei1UO3IGVq1x21EHdaBTkXZxXlN9WlzFfodbb3r8Wfl5Lb6BXpa8F11Lu71ZMLkrWuG06VHKtn9SF7HVVmyzQ1WxqjZdmqigXkevClo8rZxZ7aBeUsaiyFEbpWJVYKf0VrWX/1ielWlbQ5LDXziQVVzpnZdXwp8BVB+Yq1Bkmj1TuYNIW5KB3lhPhnRcNITiX+WJIFTOi7ZXE4wcU2iOilC9/H1Chv7rQVv5QUUg+9dG8fYVTdr0g04H8ylKfPG/SaHoykGK6lxCV+32RizvYEX94qJO1uA0TQvnnklw5QhKpdUDRI7XlUdT0D9DKNKpQPnfa0vS3f1ID9pXTHTYwU+pwbRHgsMiRF/EiEAkxh5D9cvcSN7JSksDzuBPeMx2TKAAAAAKXTXMsLochNrnKUhhZCkZuzkc1QHeNZ1rgwBR1tglPsyFEPJ2Yjm6HD8Mdqe8DCd94TnrxwYQo61bJW8ZsC1gM+0YrIkKMeTjVwQoWNQEeYKJMbU4bhj9UjMtMe9oCF71NT2ST9IU2iWPIRaeDCFHRFEUi/62PcOU6wgPI2BawHk9bwzD2kZEqYdziBIEc9nIWUYVcr5vXRjjWpGluH/+v+VKMgUCY3pvX1a21NxW5w6BYyu0Zkpj3jt/r2rQd6BAjUJs+mprJJA3XugrtF658elrdUsOQj0hU3fxnAhSnoZVZ1I8sk4aVu971u1se4c3MU5LjdZnA+eLUs9WwKWA/J2QTEZ6uQQsJ4zIl6SMmU35uVX3HpAdnUOl0SAYgL46RbVygKKcOur/qfZRfKmniyGcazHGtSNbm4Dv73CI4MUtvSx/ypRkFZehqK4Uofl0SZQ1zq69faTziLEZqK3eA/WYErkSsVrTT4SWaMyEx7KRsQsIdphDYiutj9Wg/0CP/cqMNRrjxF9H1gjkxNZZPpnjlYR+yt3uI/8RU3jafkkl77Lzwsb6mZ/zNiIc82f4QcarQqbv4yj72i+cENIgtk3n7AyqzqRm9/to3XT7OQcpzvW9zue915PScWrI9x5wlcLSynLrmqAv3lYbrN4HwfHry3sWwoMRS/dPrYFLAefcfs1dO1eFN2ZiSYzlYhhWuFfU7F9+nIYCS1A7WW4/IQRb85vjcrvxvkd3Sj1HJpBgcuoqh1uiQNpubvQxZmHebFOtZIt65Q7WTym1VU94bwh6tNXvU/y/smYwAulDXxi0dpOiU1/byA5qF3ONakap0F+KEzd2wnlqQw7O4RHBlLwkDS5bDUVEBjiJ/4U42CXYDRSfPyRc9WIRkEg5NP9SZAEz6IMoe4LeHbc5XR3m4wAoKlnnAWIzujSuh1E8oa0MCW0X6yAlfbYV6cY1FbgcaCB0po8JPMzSPPBxiRmfa9QsU9EzBRu7bjDXAO0whtqwBUpgVywCCgoZzrtB7oERHNtNq/vyBcGmx8l6JceYoHjyVBqf2xxwwu7QzZnLv9fE/nNtI9c7B37i97z94qZmoNdq3Ef+IrYay+4C8cPhKKz2LZJL32X4FuqpQ5Xq+JnI3zQjL/Z8SXLDsPQp5t/udNMTVJP6Wz7Oz5eFTc/GXxD6CuX300KPquaOOCG0QWJ8gY3Ym6jFssadCQlFnVjTGKiUaf+B3AOitBC++ZF/pKSksx5Djft0Hrg3z524ZhXAjaqvJ6TixXqRLnGRmSFbzKzt4SuFpYt2sGkw9bA46qiF9FBPrLw6Eplwh0m8H50UidMn86CbTa6VV/YtlQYscKDKlpeJgvzKvE5AAAAAC0C3emKRGfl50a6DETJE/0py84Ujo10GOOPqfFZ07vM9NFmJVOX3Ck+lQHAnRqoMfAYddhXXs/UOlwSPbOnN5nepepweeNQfBThjZW3biRk2mz5jX0qQ4EQKJ5oqnSMVQd2UbygMOuwzTI2WW69n6gDv0JBpPn4Tcn7JaRnDm9zygyymm1KCJYASNV/o8d8js7FoWdpgxtrBIHGgr7d1L8T3wlWtJmzWtmbbrN6FMdCFxYaq7BQoKfdUn1OVKlY6jmrhQOe7T8P8+/i5lBgSxc9Ypb+miQs8vcm8RtNeuMm4Hg+z0c+hMMqPFkqibPw2+SxLTJD95c+LvVK155dQtEzX584lBklNPkb+N1alFEsN5aMxZDQNsn90usgR475HeqMJPRNyp74IMhDEYNH6uDuRTcJSQONBSQBUOyt+nVIwPiooWe+Eq0KvM9EqTNmtcQxu1xjdwFQDnXcubQpzoQZKxNtvm2pYdNvdIhw4N15HeIAkLqkupzXpmd1eVMtotRR8EtzF0pHHhWXrr2aPl/QmOO2d95ZuhrchFOggJZuDYJLh6rE8YvHxixiZEmFkwlLWHquDeJ2ww8/n0r0Gjsn9sfSgLB93u2yoDdOPQnGIz/UL4R5biPpe7PKUyeh9/4lfB5ZY8YSNGEb+5fusgr67G/jXarV7zCoCAa8uoWiEbhYS7b+4kfb/D+ueHOWXxVxS7ayN/G63zUsU2VpPm7Ia+OHby1ZiwIvhGKhoC2TzKLwemvkSnYG5pefjx2yO+Ifb9JFWdXeKFsIN4vUocbm1nwvQZDGIyySG8qWzgn3O8zUHpyKbhLxiLP7UgcaCj8Fx+OYQ33v9UGgBlu06tH2tjc4UfCNNDzyUN2fffks8n8kxVU5nsk4O0MggmdRHS9ljPSIIzb45SHrEUauQuArrJ8JjOolBeHo+OxoE91IBREAoaJXuq3PVWdEbNrOtQHYE1ymnqlQy5x0uXHAZoTcwrtte4QBYRaG3Ii1CXV52AuokH9NEpwST891oufHcw/lGpqoo6CWxaF9f2Yu1I4LLAlnrGqza8FoboJ7NHy/1jahVnFwG1occsazv/1vQtL/sqt1uQinGLvVTpFA8Or8Qi0DWwSXDzYGSuaVieMX+Is+/l/NhPIyz1kbiJNLJiWRls+C1yzD79XxKkxaWNshWIUyhh4/Pusc4tdF6agA6Ot16U+tz+UirxIMgSC7/ewiZhRLZNwYJmYB8Zw6E8wxOM4lln50Kft8qcBY8wAxNfHd2JK3Z9T/tbo9dk6fmRtMQnC8Cvh80QgllXKHjGQfhVGNuMPrgdXBNmhvnSRVwp/5vGXZQ7AI255Zq1Q3qMZW6kFhEFBNDBKNpIAAAAAngCqzH0HJULjB4+O+g5KhGQO4EiHCW/GGQnFCrUb5dMrG08fyBzAkVYcal1PFa9X0RUFmzISihWsEiDZKzG7fLUxEbBWNp4+yDY08tE/8fhPP1s0rDjUujI4fnaeKl6vACr0Y+Mte+19LdEhZCQUK/okvucZIzFphyObpVZidvnIYtw1K2VTu7Vl+XesbDx9MmyWsdFrGT9Pa7Pz43mTKn15OeaefrZoAH4cpBl32a6Hd3NiZHD87PpwViB9U82F41NnSQBU6MeeVEILh12HARldLc36WqJDZFoIj8hIKFZWSIKatU8NFCtPp9gyRmLSrEbIHk9BR5DRQe1c7cKdKXPCN+WQxbhrDsUSpxfM162JzH1hasvy7/TLWCNY2Xj6xtnSNiXeXbi73vd0otcyfjzXmLLf0Bc8QdC98MbzJlVY84yZu/QDFyX0qds8/WzRov3GHUH6SZPf+uNfc+jDhu3oaUoO7+bEkO9MCInmiQIX5iPO9OGsQGrhBoy7oOvQJaBBHManzpJYp2ReQa6hVN+uC5g8qYQWoqku2g67DgOQu6TPc7wrQe28gY30tUSHarXuS4myYcUXsssJkJFQrA6R+mDtlnXuc5bfImqfGij0n7DkF5g/aomYlaYlirV/u4ofs1iNkD3GjTrx34T/+0GEVTeig9q5PINwddqFO1NEhZGfp4IeETmCtN0gi3HXvovbG12MVJXDjP5Zb57egPGedEwSmfvCjJlRDpWQlAQLkD7I6JexRnaXG4rxtIAvb7Qq44yzpW0Ssw+hC7rKq5W6YGd2ve/p6L1FJUSvZfzar88wOahAvqeo6nK+oS94IKGFtMOmCjpdpqD2jOdNqhLn52bx4Gjob+DCJHbpBy7o6a3iC+4ibJXuiKA5/Kh5p/wCtUT7jTva+yf3w/Li/V3ySDG+9ce/IPVtc6fW9tY51lwa2tHTlETReVhd2LxSw9gWniDfmRC+3zPcEs0TBYzNuclvyjZH8cqci+jDWYF2w/NNlcR8wwvE1g83R6Z6qUcMtkpAgzjUQCn0zUns/lNJRjKwTsm8Lk5jcIJcQ6kcXOll/1tm62FbzCd4Ugkt5lKj4QVVLG+bVYajHHYdBoJ2t8phcThE/3GSiOZ4V4J4eP1Om39ywAV/2AypbfjVN21SGdRq3ZdKandbU2OyUc1jGJ0uZJcTsGQ932El0IP/JXpPHCL1wYIiXw2bK5oHBSswy+Ysv0V4LBWJ1D41UEo+n5ypORASNzm63i4wf9SwMNUYUzdals038FpKFGv/1BTBMzcTTr2pE+RxsBohey4ai7fNHQQ5Ux2u9f8PjixhDyTgggirbhwIAaIFAcSomwFuZHgG4ermBksmAAAAAEMUexeGKPYuxTyNOQxR7F1PRZdKinkac8ltYWQYoti7W7ajrJ6KLpXdnlWCFPM05lfnT/GS28LI0c+533FCwKwyVru792o2grR+TZV9EyzxPgdX5vs72t+4L6HIaeAYFyr0YwDvyO45rNyVLmWx9EompY9d45kCZKCNeXOjgvGC4JaKlSWqB6xmvny7r9Md3+zHZsgp++vxau+Q5rsgKTn4NFIuPQjfF34cpAC3ccVk9GW+czFZM0pyTUhd0sAxLpHUSjlU6McAF/y8F96R3XOdhaZkWLkrXRutUErKYumViXaSgkxKH7sPXmSsxjMFyIUnft9AG/PmAw+I8QcDkt5EF+nJgStk8MI/H+cLUn6DSEYFlI16iK3ObvO6H6FKZVy1MXKZibxL2p3HXBPwpjhQ5N0vldhQFtbMKwF2QVJyNVUpZfBppFyzfd9LehC+LzkExTj8OEgBvywzFm7jiskt9/He6Mt856vfB/BismaUIaYdg+SakLqnjuutpIFjXOeVGEsiqZVyYb3uZajQjwHrxPQWLvh5L23sAji8I7vn/zfA8DoLTcl5HzbesHJXuvNmLK02WqGUdU7ag9XDo/CW19jnU+tV3hD/LsnZkk+tmoY0ul+6uYMcrsKUzWF7S451AFxLSY1lCF32csEwlxaCJOwBRxhhOAQMGi9PAFVmDBQucckoo0iKPNhfQ1G5OwBFwizFeU8Vhm00Aleijd0UtvbK0Yp785KeAORb82GAGOcal93bl66ez+y5PkKVyn1W7t24amPk+34Y8zITeZdxBwKAtDuPufcv9K4m4E1xZfQ2ZqDIu1/j3MBIKrGhLGml2jusmVcC740sFeyCpOSvlt/zaqpSyim+Kd3g00i5o8czrmb7vpcl78WA9CB8X7c0B0hyCIpxMRzxZvhxkAK7ZesVfllmLD1NHTudwGRI3tQfXxvokmZY/OlxkZGIFdKF8wIXuX47VK0FLIVivPPGdsfkA0pK3UBeMcqJM1CuyicruQ8bpoBMD92XSAPHuAsXvK/OKzGWjT9KgURSK+UHRlDywnrdy4FuptxQoR8DE7VkFNaJ6S2VnZI6XPDzXh/kiEna2AVwmcx+ZzlBBxR6VXwDv2nxOvx9ii01EOtJdgSQXrM4HWfwLGZwIePfr2L3pLinyymB5N9Sli2yM/Jupkjlq5rF3OiOvsvrgTY6qJVNLW2pwBQuvbsD59DaZ6TEoXBh+CxJIuxXXvMj7oGwN5WWdQsYrzYfY7j/cgLcvGZ5y3la9PI6To/lmsP2ltnXjYEc6wC4X/97r5aSGsvVhmHcELrs5VOul/KCYS4twXVVOgRJ2ANHXaMUjjDCcM0kuWcIGDReSwxPSQAAAAA+a8LvPdD1BAO7N+t6oOsJRMsp5kdwHg15G9zi9EDXE8orFfzJkCIX9/vg+I7gPBqwi/71szDJHo1bC/Hoga4n1upsyNVRWyPrOpnMkiFFLqxKh8Gv8bAqkZpyxRzBeTQiqrvbIRGMMB96Tt9mYZI9WApQ0luxZzll2qXW0ANdT+5on6Dt06hL07hqpKqjtkaUyHSpl3NDQqkYga0kQ4pcGihIsxmTf1gn+L23XuNhVWCIo7pjM5RRXVhWvjiC82gG6TGHBVIGbDs5xINCIhhhfEnajn/y7WVBmS+KzMIke/Kp5pTxEtF/z3kTkLZiz3KICQ2di7I6drXZ+JmgB7qenmx4cZ3XT5qjvI112qdRl+TMk3jnd6ST2RxmfFRHbY1qLK9iaZeYiVf8WmYu54aEEIxEaxM3c4AtXLFvSIYUuXbt1lZ1VuG9Sz0jUjIm/7AMTT1fD/YKtDGdyFu8xsOqgq0BRYEWNq6/ffRBxmYoo/gN6kz7tt2nxd0fSHAE59FObyU+TdQS1XO/0DoKpAzYNM/ONzd0+dwJHzszhEQwwrov8i25lMXGh/8HKf7k28vAjxkkwzQuz/1f7CCYhUn2pu6LGaVVvPKbPn4d4iWi/9xOYBDf9Vf74Z6VFGzFnuVSrlwKURVr4W9+qQ4WZXXsKA63Ayu1gOgV3kIHAQkF5j9ixwk82fDiArIyDXup7u9FwiwARnkb63gS2QT1SdL1yyIQGsiZJ/H28uUej+k5/LGC+xOyOcz4jFIOF+mIq8HX42ku1FhexeoznCqTKEDIrUOCJ674tcyQk3cjHch80iOjvj0gGInWHnNLOWdol9tZA1U0Wrhi32TToDDRClip72GaRuzara3SsW9Cq6qzoJXBcU+WekakqBGESyVKj7obIU1VGJp6vibxuFFf6mSzYYGmXGI6kbdcUVNYOYv2jgfgNGEEWwOKOjDBZUMrHYd9QN9ofvvog0CQKmzNyyGd86DjcvAb1JnOcBZ2t2vKlIkACHuKuz+QtND9f6EOv3ifZX2XnN5KfKK1iJPbrlRx5cWWnuZ+oXXYFWOaVU5oa2slqoRonp1vVvVfgC/ug2IRhUGNEj52ZixVtIlJjxFfd+TTsHRf5FtKNCa0My/6Vg1EOLkO/w9SMJTNvb3PxkyDpASjgB8zSL508afHby1F+QTvqvq/2EHE1BqucQ3iN09mINhM3RczcrbV3AutCT41xsvRNn38OggWPtWFTTUkuyb3y7idwCCG9gLP/+3eLcGGHMLCPSsp/FbpxpmMTBCn547/pFy5FJo3e/vjLKcZ3Udl9t78Uh3gl5DybcybA1OnWexQHG4Hbnes6BdscAopB7LlKryFDhTXR+EAAAAAwN+OwcG5bFgBZuKZgnPZsEKsV3FDyrXogxU7KUXhw7qFPk17hFiv4kSHISPHkhoKB02UywYrdlLG9PiTy8T2rgsbeG8KfZr2yqIUN0m3Lx6JaKHfiA5DRkjRzYeOJTUUTvq71U+cWUyPQ9eNDFbspMyJYmXN74D8DTAOPdePnIYXUBJHFjbw3tbpfh9V/EU2lSPL95RFKW5Umqevkm5fPFKx0f1T1zNkkwi9pRAdhozQwghN0aTq1BF7ZBUcS2oo3JTk6d3yBnAdLYixnjizmF7nPVlfgd/An15RAVmqqZKZdSdTmBPFyljMSwvb2XAiGwb+4xpgHHrav5K77xlI1i/GxhcuoCSO7n+qT21qkWattR+nrNP9PmwMc/+q+ItsaicFrWtB5zSrnmn1KItS3OhU3B3pMj6EKe2wRSTdvnjkAjC55WTSICW7XOGmrmfIZnHpCWcXC5CnyIVRYTx9wqHj8wOghRGaYFqfW+NPpHIjkCqzIvbIKuIpRus4ltRQ+ElakfkvuAg58DbJuuUN4Ho6gyF7XGG4u4PveX13F+q9qJkrvM57snwR9XP/BM5aP9tAmz69ogL+YizD81Ii/jONrD8y606m8jTAZ3Eh+06x/nWPsJiXFnBHGde2s+FEdmxvhXcKjRy31QPdNMA49PQftjX1eVSsNababZ814Xdf6m+2XoyNL55TA+4dRjjH3Zm2Btz/VJ8cINpe2tQizRoLrAwbbU6V27LAVFin+32YeHW8mR6XJVnBGeRU8RfZlC6ZGJVIe4FVl/VA1oLOaRZdQKgXO6Ix1+Qs8BEQ1GPRz1qi0Km4OxB2NvqTYw3TU7yDElLaYYuSBe9KSLp98Yhl8zCJAxGpSdyfaMrJpEEKFiqAC3DIGcuvRtgNW75LzYQwiszi0hMMPVzSjyhn+0/36TpOkQujjk6FYoN+i19DoQWeQsfnB4IYacYBDVLvwdLcLsC0PrcAa7B2xp9I5QZAxiQHJiS9x/mqfETskVWEMx+UhVX9DUWKc8xwLKmhsPMnYLGVxflxSks48l9wETKA/tAz5hxJ8zmSiDXNahv1EuTa9HQGQzSriIK3vrOrd2E9anYH3/O22FEyu+hfD3s30c56UTNXuo69ljmbhr/5RAh++CLq5zj9ZCb+CZy1PtYSdD+w8O3/b34sfHpFBbyly8S9wyldfRynnKejNSdnfLvmZhpZf6bF174l0OyX5Q9iVuRpgM8ktg4O4kL2nSKdeFwj+5rF4yQUBGAxLy2g7qHsoYhDdWFXzbRsZ8OJrLhNSK3er9FtASEQ7hQaOS7LlPgvrXZh73L4oCmGADPpWY7y6D9sayjg4qqr9dmDaypXQmpMtduqkzsaAAAAAG9MpZufnjvs8NKed387BgMQd6OY4KU974/pmHT+dgwGkTqpnWHoN+oOpJJxgU0KBe4Br54e0zHpcZ+UcvztGAyTob2XY3Mj4Aw/hnuD1h4P7Jq7lBxIJeNzBIB4ApsUCm3XsZGdBS/m8kmKfX2gEgkS7LeS4j4p5Y1yjH742zEYl5eUg2dFCvQICa9vh+A3G+iskoAYfgz3dzKpbAatPR5p4ZiFmTMG8vZ/o2l5ljsdFtqehuYIAPGJRKVqBDYpFGt6jI+bqBL49OS3Y3sNLxcUQYqM5JMU+4vfsWD6QCUSlQyAiWXeHv4KkrtlhXsjEeo3hooa5Rj9dam9ZvC3YzCf+8arbylY3ABl/UePjGUz4MDAqBASXt9/XvtEDsFvNmGNyq2RX1Ta/hPxQXH6aTUetsyu7mRS2YEo90IMWns8Yxbep5PEQND8iOVLc2F9Pxwt2KTs/0bTg7PjSPIsdzqdYNKhbbJM1gL+6U2NF3E54lvUohKJStV9xe9OCGxSKGcg97OX8mnE+L7MX3dXVCsYG/Gw6Mlvx4eFylz2Gl4umVb7tWmEZcIGyMBZiSFYLeZt/bYWv2PBefPGWvSBSiSbze+/ax9xyART1FOLukwn5PbpvBQkd8t7aNJQCvdGImW747mVaX3O+iXYVXXMQCEagOW66lJ7zYUe3lbgb8dgjyNi+3/x/IwQvVkXn1TBY/AYZPgAyvqPb4ZfFB4Zy2ZxVW79gYfwiu7LVRFhIs1lDm5o/v689omR8FMSHILfbHPOeveDHOSA7FBBG2O52W8M9Xz0/Cfig5NrRxji9NNqjbh28X1q6IYSJk0dnc/VafKDcPICUe6FbR1LHhi09nh3+FPjhyrNlOhmaA9nj/B7CMNV4PgRy5eXXW4M5sL6fomOX+V5XMGSFhBkCZn5/H32tVnmBmfHkWkrYgrkWe50ixVL73vH1ZgUi3ADm2Lod/QuTewE/NOba7B2ABov4nJ1Y0fphbHZnur9fAVlFORxClhB6vqK352VxnoGENikUH+UAcuPRp+84Ao6J2/jolMArwfI8H2Zv58xPCTurqhWgeINzXEwk7oefDYhkZWuVf7ZC84OC5W5YUcwIuw1vFyDeRnHc6uHsBznIiuTDrpf/EIfxAyQgbNj3CQoEkOwWn0PFcGN3Yu24pEuLW14tlkCNBPC8uaNtZ2qKC7oA5VIh08w03edrqQY0Qs/lziTS/h0NtAIpqinZ+oNPBZ1mU55OTzVieuiouanBzlpTp9NBgI61vbQpKGZnAE6FO6NRHuiKN+LcLao5DwTM2vVi0cEmS7c9Euwq5sHFTDqmIFChdQk2XUGuq4aSh81laOHQfrvItoKPbytZXEZNgAAAACF2ZbdS7VcYM5syr2WarnAE7MvHd3f5aBYBnN9bdMDWugKlYcmZl86o7/J5/u5upp+YCxHsAzm+jXVcCfapge0X3+RaZETW9QUys0JTMy+dMkVKKkHeeIUgqB0ybd1BO4yrJIz/MBYjnkZzlMhH70upMYr82qq4U7vc3eT9Ut+s3CS6G6+/iLTOye0DmMhx3Pm+FGuKJSbE61NDc6YmH3pHUHrNNMtIYlW9LdUDvLEKYsrUvRFR5hJwJ4OlC/teQeqNO/aZFglZ+GBs7q5h8DHPF5WGvIynKd36wp6Qj56Xcfn7IAJiyY9jFKw4NRUw51RjVVAn+Gf/Ro4CSCrkY29LkgbYOAk0d1l/UcAPfs0fbgioqB2Tmgd85f+wMZCjudDmxg6jffShwguRFpQKDcn1fGh+huda0eeRP2acTeKCfTuHNQ6gtZpv1tAtOddM8lihKUUrOhvqSkx+XQc5IlTmT0fjldR1TPSiEPuio4wkw9Xpk7BO2zzROL6Ll7a8w7bA2XTFW+vbpC2ObPIsErOTWncE4MFFq4G3IBzMwnwVLbQZol4vKw0/WU66aVjSZQgut9J7tYV9GsPgymEfPS6AaViZ8/JqNpKED4HEhZNepfP26dZoxEa3HqHx+mv9+BsdmE9ohqrgCfDPV1/xU4g+hzY/TRwEkCxqYSdFyVqoJL8/H1ckDbA2UmgHYFP02AElkW9yvqPAE8jGd169mn6/y//JzFDNZq0mqNH7JzQOmlFRuenKYxaIvAah82DbRRIWvvJhjYxdAPvp6lb6dTU3jBCCRBciLSVhR5poFBuTiWJ+JPr5TIubjyk8zY6146z40FTfY+L7vhWHTPibhQTZ7eCzqnbSHMsAt6udASt0/HdOw4/sfGzumhnbo+9F0kKZIGUxAhLKUHR3fQZ166JnA44VFJi8unXu2Q0OMgTp70RhXpzfU/H9qTZGq6iqmcrezy65Rf2B2DOYNpVGxD90MKGIB6uTJ2bd9pAw3GpPUaoP+CIxPVdDR1jgLy05x05bXHA9wG7fXLYLaAq3l7drwfIAGFrAr3kspRg0WfkR1S+cpqa0rgnHwsu+kcNXYfC1MtaDLgB54lhlzpmEuCp48t2dC2nvMmofioU8HhZaXWhz7S7zQUJPhST1AvB4/OOGHUuQHS/k8WtKU6dq1ozGHLM7tYeBlNTx5COSf+ZrswmD3MCSsXOh5NTE9+VIG5aTLazlCB8DhH56tMkLJr0ofUMKW+ZxpTqQFBJskYjNDeften5839UfCrpiZNZnhoWgAjH2OzCel01VKcFMyfagOqxB06Ge7rLX+1n/oqdQHtTC521P8EgMOZX/WjgJIDtObJdI1V44KaM7j0AAAAAduEPna3EbuHbJWF8G4+sGW1uo4S2S8L4wKrNZTYeWTNA/1aum9o30u07OE8tkfUqW3D6t4BVm8v2tJRWbDyyZhrdvfvB+NyHtxnTGnezHn8BUhHi2ndwnqyWfwNaIutVLMPkyPfmhbSBB4opQa1HTDdMSNHsaSmtmogmMNh4ZM2umWtQdbwKLANdBbHD98jUtRbHSW4zpjUY0qmo7mY9/piHMmNDolMfNUNcgvXpkeeDCJ56WC3/Bi7M8Ju0RNarwqXZNhmAuEpvYbfXr8t6stkqdS8CDxRTdO4bzoJaj5j0u4AFL57heVl/7uSZ1SOB7zQsHDQRTWBC8EL98fe5QYcWttxcM9egKtLYPep4FVicmRrFR7x7uTFddCTH6eBysQjv72otjpMczIEO3GZMa6qHQ/ZxoiKKB0MtF53LCyfrKgS6MA9lxkbualuGRKc+8KWooyuAyd9dYcZCq9VSFN00XYkGETz1cPAzaLBa/g3Gu/GQHZ6Q7Gt/n3Epj92MX27SEYRLs23yqrzwMgBxlUThfgifxB906SUQ6R+RhL9pcIsislXqXsS05cMEHiimcv8nO6naRkffO0naRbNv6jNSYHfodwELnpYOll48w/Mo3cxu8/itEoUZoo9zrTbZBUw5RN5pWDioiFelaCKawB7DlV3F5vQhswf7vOLvc4OUDnweTysdYjnKEv/5YN+aj4HQB1SksXsiRb7m1PEqsKIQJS15NURRD9RLzM9+hqm5n4k0YrroSBRb59WO08Hl+DLOeCMXrwRV9qCZlVxt/OO9YmE4mAMdTnkMgLjNmNbOLJdLFQn2N2Po+aqjQjTP1aM7Ug6GWi54Z1WzOpcXTkx2GNOXU3mv4bJ2MiEYu1dX+bTKjNzVtvo92isMiU59emhB4KFNIJzXrC8BFwbiZGHn7fm6woyFzCODGFarpSggSqq1+2/LyY2OxFRNJAkxO8UGrODgZ9CWAWhNYLX8GxZU84bNcZL6u5CdZ3s6UAIN21+f1v4+46AfMX4TGMrCZfnFX77cpCPIPau+CJdm2352aUalUwg607IHpyUGk/FT55xsiML9EP4j8o0+iT/oSGgwdZNNUQnlrF6UfyR4pAnFdznS4BZFpAEZ2GSr1L0SStsgyW+6XL+OtcFJOiGXP9suCuT+T3aSH0DrUrWNjiRUghP/ceNviZDs8stgrg+9gaGSZqTA7hBFz3PQ7wIWpg4Ni30rbPcLymNq/X73PIuf+KFQupndJluWQObxWyWQEFS4SzU1xD3UOlmnXBxp0b0T9AqYcoh8eX0VvNOwcMoyv+0RF96RZ/bRDJFCRVrno0rHPIYru0pnJCaKzelD/Czm3icJh6JR6Ig/AAAAAOjb+7mRsYaoeWp9EWNlfIqLvocz8tT6IhoPAZuHzInPbxdydhZ9D2f+pvTe5Kn1RQxyDvx1GHPtncOIVE+fYkSnRJn93i7k7Db1H1Us+h7OxCHld71LmGZVkGPfyFPriyCIEDJZ4m0jsTmWmqs2lwFD7Wy4OocRqdJc6hCePsWIduU+MQ+PQyDnVLiZ/Vu5AhWAQrts6j+qhDHEExnyTEfxKbf+iEPK72CYMVZ6lzDNkkzLdOsmtmUD/U3c0aGnzDl6XHVAECFkqMva3bLE20ZaHyD/I3Vd7suupldWbS4DvrbVusfcqKsvB1MSNQhSid3TqTCkudQhTGIvmH17+8qVoABz7Mp9YgQRhtseHodA9sV8+Y+vAehndPpR+rdyBRJsibxrBvStg90PFJnSDo9xCfU2CGOIJ+C4c54y5JmO2j9iN6NVHyZLjuSfUYHlBLlaHr3AMGOsKOuYFbUoEEFd8+v4JJmW6cxCbVDWTWzLPpaXckf86mOvJxHa40U+Qguexfty9Ljqmi9DU4AgQsho+7lxEZHEYPlKP9lkibeNjFJMNPU4MSUd48qcB+zLB+83ML6WXU2vfoa2FqzaXAZEAae/PWvartWwIRfPvyCMJ2TbNV4OpiS21V2dKxbVycPNLnC6p1NhUnyo2EhzqUOgqFL62cIv6zEZ1FK78IdOUyt89ypBAebCmvpf2JX7xDBOAH1JJH1sof+G1Tw8DoHU5/U4rY2IKUVWc5BfWXILt4KJss7o9KMmMw8a9G/lChy0HrNl3mOijQWYG5cKmYB/0WI5BrsfKO5g5JFzo2zFm3iXfOIS6m0KyRHUEMYQT/gd6/aBd5bnaaxtXiXOQsbNFbl/tH/EblykP9dGqz5MrnDF9dcauOQ/wUNdogLLCUrZMLAzs02h22i2GMFnt4MpvEw6UNYxK7gNypJqUSCCgorbO/vgpioTO12TCTRcCOHvp7GYhdqgcF4hGe2dqU0FRlL0fCwv5ZT31FyO+NXHZiMufh9JU2/3kqjWxot8hC5Qhz1XOvosv+EBlaXuAA5NNfu3NF+GptyEfR9BR/VLqZwO8tD2c+M4LYhaIiKJwcr5cnizkw9pW0j00IkUHsBhz+V5GKWYaPB+Y9HqcWJKAqqZ83vA5OKTGx9bDtiXD+YDbLafaRGnd7LqHm2964WFZhA8/AxtLRTXlpRYtbkMsG5CtckEP6Qh38QdO9DFhtMLPj+qYUMuQrq4l995MMM3ost6Tsi2a6YTTdK8HExJVMe38C2tyuHFdjFYFyrbSP/xIPGGm13gbkCmWXRPp8KclFx75f4hag0l2tOQ5lKHeD2pPgFX1C/pjC+W84MuDRtY1bRiMqiliulTHAAAAACRkWiuYyWgh/K0yCmHTDHUFt1ZeuRpkVN1+Pn9T58Tc94Oe90surP0vSvbWsjTIqdZQkoJq/aCIDpn6o6ePifmD69PSP0bh2Fsiu/PGXIWMojjfpx6V7a168beG9GhNJVAMFw7soSUEiMV/LxW7QVBx3xt7zXIpcakWc1ofXs/F+zqV7keXp+Qj8/3Pvo3DsNrpmZtmRKuRAiDxuoy5Cxko3VEylHBjOPAUORNtagdsCQ5dR7Wjb03RxzVmeNFGPFy1HBfgGC4dhHx0NhkCSkl9ZhBiwcsiaKWveEMrNoLgj1LYyzP/6sFXm7DqyuWOla6B1L4SLOa0dki8n/69n4ua2cWgJnT3qkIQrYHfbpP+uwrJ1Qen+99jw6H07VpbV0k+AXz1kzN2kfdpXQyJVyJo7Q0J1EA/A7AkZSgZMhZyPVZMWYH7flPlnyR4eOEaBxyFQCygKHImxEwoDUrV0q7usYiFUhy6jzZ44KSrBt7bz2KE8HPPtvoXq+zRoeNQTkWHCmX5KjhvnU5iRAAwXDtkVAYQ2Pk0GrydbjEyBJSSlmDOuSrN/LNOqaaY09eY57ezwswLHvDGb3qq7cZs2bfiCIOcXqWxljrB672nv9XCw9uP6X92veMbEufIlYsdazHvR0CNQnVK6SYvYXRYER4QPEs1rJF5P8j1IxR9O39XGV8lfKXyF3bBlk1dXOhzIjiMKQmEIRsD4EVBKG7cu4vKuOGgdhXTqhJxiYGPD7f+62vt1VfG398zooX0mrT2rr7QrIUCfZ6PZhnEpPtn+tufA6DwI66S+kfKyNHJUzJybTdoWdGaWlO1/gB4KIA+B0zkZCzwSVYmlC0MDSJlsJLGAeq5eqzYsx7IgpiDtrzn59LmzFt/1MY/G47tsYJ0ThXmLmWpSxxvzS9GRFBReDs0NSIQiJgQGuz8SjFF6jlrYY5jQN0jUUq5RwthJDk1HkBdbzX88F0/mJQHFBYN/beyaaecDsSVlmqgz7333vHCk7qr6S8XmeNLc8PIw4bg3KfiuvcbT4j9fyvS1uJV7KmGMbaCOpyEiF743qPQYSQAdAV+K8ioTCGszBYKMbIodVXWcl7pe0BUjR8afyQJaSUAbTMOvMABBNikWy9F2mVQIb4/e50TDXH5d1dad+6t+dOK99JvJ8XYC0Of85Y9oYzyWfunTvTJrSqQk4ac2C8ZeLx1MsQRRzigdR0TPQsjbFlveUflwktNgaYRZg8/68WrW7HuF/aD5HOS2c/u7Oewioi9mzYlj5FSQdW6+1em4N8z/Mtjns7BB/qU6pqEqpX+4PC+Qk3CtCYpmJ+osGI8DNQ4F7B5Ch3UHVA2SWNuSS0HNGKRqgZo9c5cQ2DJhAAWwAAAF0BAAANAAAAgyYQAFsAAABgAQAADQAAAIMmEABbAAAAbgEAAAkAAACDJhAAWwAAAJgBAAA+AAAAgyYQAFsAAAC0AQAAJAAAAIMmEABbAAAAzAEAAA0AAACDJhAAWwAAAMgBAAANAAAAgyYQAFsAAADJAQAADQAAAIMmEABbAAAAtgEAAA0AAACDJhAAWwAAAP4BAAAcAAAAgyYQAFsAAAAAAgAAGgAAAHNuYXBweTogaW5wdXQgYnVmZmVyIChzaXplID0gKSBpcyBsYXJnZXIgdGhhbiBhbGxvd2VkIChzaXplID0gKQDAiR8AHQAAAN2JHwAhAAAA/okfAAEAAABzbmFwcHk6IG91dHB1dCBidWZmZXIgKHNpemUgPSApIGlzIHNtYWxsZXIgdGhhbiByZXF1aXJlZCAoc2l6ZSA9IAAAABiKHwAeAAAANoofACMAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZW1wdHkpc25hcHB5OiBjb3JydXB0IGlucHV0IChpbnZhbGlkIGhlYWRlcilzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGhlYWRlciBtaXNtYXRjaDsgZXhwZWN0ZWQgIGRlY29tcHJlc3NlZCBieXRlcyBidXQgZ290ILeKHwAxAAAA6IofABwAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZXhwZWN0ZWQgbGl0ZXJhbCByZWFkIG9mIGxlbmd0aCA7IHJlbWFpbmluZyBzcmM6IDsgcmVtYWluaW5nIGRzdDogAAAAHIsfADcAAABTix8AEQAAAGSLHwARAAAA/okfAAEAAABzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGV4cGVjdGVkIGNvcHkgcmVhZCBvZiBsZW5ndGggmIsfADQAAABTix8AEQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChleHBlY3RlZCBjb3B5IHdyaXRlIG9mIGxlbmd0aCAAAADkix8ANQAAAGSLHwARAAAA/okfAAEAAABzbmFwcHk6IGNvcnJ1cHQgaW5wdXQgKGV4cGVjdGVkIHZhbGlkIG9mZnNldCBidXQgZ290IG9mZnNldCA7IGRzdCBwb3NpdGlvbjogNIwfADwAAABwjB8AEAAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChleHBlY3RlZCBzdHJlYW0gaGVhZGVyIGJ1dCBnb3QgdW5leHBlY3RlZCBjaHVuayB0eXBlIGJ5dGUgAAAAmIwfAFEAAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAoZXhwZWN0ZWQgc05hUHBZIHN0cmVhbSBoZWFkZXIgYnV0IGdvdCAAAAD8jB8APQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0ICh1bnN1cHBvcnRlZCBjaHVuayB0eXBlOiAATI0fAC8AAAD+iR8AAQAAAHNuYXBweTogY29ycnVwdCBpbnB1dCAodW5zdXBwb3J0ZWQgY2h1bmsgbGVuZ3RoOiAAAACMjR8AMQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChpbnZhbGlkIHN0cmVhbSBoZWFkZXIgbGVuZ3RoOiAAAADQjR8ANQAAAP6JHwABAAAAc25hcHB5OiBjb3JydXB0IGlucHV0IChiYWQgY2hlY2tzdW07IGV4cGVjdGVkOiAsIGdvdDogAAAYjh8ALwAAAEeOHwAHAAAA/okfAAEAAACyKxAAWAAAAAcAAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2xpY2UubGVuKCkgPj0gMgAAsisQAFgAAAAiAAAABQAAALIrEABYAAAARAAAAAUAAACyKxAAWAAAAEAAAAAJAAAAviUQAF0AAABcAAAAJQAAAAAAAAD/AAAA//8AAP///wD/////AQAECAEQASACAAUIAhACIAMABggDEAMgBAAHCAQQBCAFAAgIBRAFIAYACQgGEAYgBwAKCAcQByAIAAsICBAIIAkABAkJEAkgCgAFCQoQCiALAAYJCxALIAwABwkMEAwgDQAICQ0QDSAOAAkJDhAOIA8ACgkPEA8gEAALCRAQECARAAQKERARIBIABQoSEBIgEwAGChMQEyAUAAcKFBAUIBUACAoVEBUgFgAJChYQFiAXAAoKFxAXIBgACwoYEBggGQAECxkQGSAaAAULGhAaIBsABgsbEBsgHAAHCxwQHCAdAAgLHRAdIB4ACQseEB4gHwAKCx8QHyAgAAsLIBAgICEABAwhECEgIgAFDCIQIiAjAAYMIxAjICQABwwkECQgJQAIDCUQJSAmAAkMJhAmICcACgwnECcgKAALDCgQKCApAAQNKRApICoABQ0qECogKwAGDSsQKyAsAAcNLBAsIC0ACA0tEC0gLgAJDS4QLiAvAAoNLxAvIDAACw0wEDAgMQAEDjEQMSAyAAUOMhAyIDMABg4zEDMgNAAHDjQQNCA1AAgONRA1IDYACQ42EDYgNwAKDjcQNyA4AAsOOBA4IDkABA85EDkgOgAFDzoQOiA7AAYPOxA7IDwABw88EDwgAAgIDz0QPSAAEAkPPhA+IAAYCg8/ED8gACALD0AQQCC+JRAAXQAAAFEBAAAkAAAAviUQAF0AAABRAQAAEQAAAL4lEABdAAAAwQEAADcAAAA6hhAAcAAAAC4CAAARAAAATm9uZQAAAAAEAAAABAAAAEMFAABTb21lHprAvv5ieL98GMLX7yHyp6sFAAAMAAAABAAAACkAAACrBQAADAAAAAQAAAAqAAAAKQAAAFiRHwAVBQAArAUAAC0AAAAVBQAArQUAAAAAAAAEAAAABAAAAK4FAAAAAAAABAAAAAQAAACvBQAAVXRmOEVycm9ydmFsaWRfdXBfdG9lcnJvcl9sZW4AAADOdRAAagAAAL0BAAAdAAAA+GEQAGAAAABBAAAAHgAAAPhhEABgAAAAXQAAAB4AAABjYW5ub3QgY29udmVydCBzaG91bGQgbm90IGhhdmUgYXR0ZW1wdGVkIHRvIGNvbnZlcnQgIHRvIHU4AAATkh8AJQAAADiSHwAGAAAA5yIQAGYAAACBAgAADgAAACBpbnRvIFRUeXBlAASSHwAPAAAAYJIfAAsAAAAAAAADBwQFBggADAsKCQAAOoYQAHAAAAAuAgAAEQAAAE5vbmUAAAAABAAAAAQAAACxBQAAU29tZc51EABqAAAAvQEAAB0AAABTVE9Qdm9pZGJvb2xpMDhkb3VibGVpMTZpMzJpNjRzdHJpbmdVVEY3c3RydWN0bWFwc2V0bGlzdFVURjhVVEYxNm1pc3NpbmcgZmllbGQgaW4gaW4gAAAABZMfABQAAACyBQAADAAAAAQAAACzBQAAAAAAAAEAAAABAAAAtAUAAAAAAAAEAAAABAAAALUFAABURmllbGRJZGVudGlmaWVybmFtZWZpZWxkX3R5cGVpZFN0b3BWb2lkQm9vbEkwOERvdWJsZUkxNkkzMkk2NFN0cmluZ1V0ZjdTdHJ1Y3RNYXBTZXRMaXN0VXRmOFV0ZjE2AAAABAAAAAQAAAAEAAAAAwAAAAYAAAADAAAAAwAAAAMAAAAGAAAABAAAAAYAAAADAAAAAwAAAAQAAAAEAAAABQAAAHSTHwB4kx8AfJMfAICTHwCDkx8AiZMfAIyTHwCPkx8AkpMfAJiTHwCckx8AopMfAKWTHwCokx8ArJMfALCTHwC2BQAADAAAAAQAAAC3BQAAuAUAALkFAAB8RBAAZQAAAD8AAAAmAAAATm9uZQAAAAAEAAAABAAAANAEAABTb21lugUAAAwAAAAEAAAAuwUAALwFAAC5BQBBmKn+AAvZDgEAAAC9BQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAARXJyb3IAAADiXxAAawAAAM8MAAAOAAAAznUQAGoAAAC9AQAAHQAAAG1lc3NhZ2V0cmFuc3BvcnQgZXJyb3Jub3Qgb3BlbmFscmVhZHkgb3BlbnRpbWVkIG91dGVuZCBvZiBmaWxlbmVnYXRpdmUgc2l6ZSBtZXNzYWdlbWVzc2FnZSB0b28gbG9uZwABAAAAAAAAAHByb3RvY29sIGVycm9yYmFkIGRhdGFuZWdhdGl2ZSBtZXNzYWdlIHNpemVpbnZhbGlkIHRocmlmdCB2ZXJzaW9ubm90IGltcGxlbWVudGVkbWF4aW11bSBza2lwIGRlcHRoIHJlYWNoZWRzZXJ2aWNlIGVycm9ydW5rbm93biBzZXJ2aWNlIG1ldGhvZHdyb25nIG1lc3NhZ2UgdHlwZSByZWNlaXZlZHVua25vd24gbWV0aG9kIHJlcGx5IHJlY2VpdmVkb3V0IG9mIG9yZGVyIHNlcXVlbmNlIGlkbWlzc2luZyBtZXRob2QgcmVzdWx0cmVtb3RlIHNlcnZpY2UgdGhyZXcgZXhjZXB0aW9uaW52YWxpZCB0cmFuc2Zvcm1pbnZhbGlkIHByb3RvY29sIHJlcXVlc3RlZHVuc3VwcG9ydGVkIHByb3RvY29sIGNsaWVudAAAAAAAAAEAAAABAAAAvgUAAAAAAAAEAAAABAAAALEFAABUcmFuc3BvcnRFcnJvcmtpbmRVbmtub3duTm90T3BlbkFscmVhZHlPcGVuVGltZWRPdXRFbmRPZkZpbGVOZWdhdGl2ZVNpemVTaXplTGltaXQAAAAAAAAAAQAAAAEAAAC/BQAAUHJvdG9jb2xFcnJvckludmFsaWREYXRhQmFkVmVyc2lvbk5vdEltcGxlbWVudGVkRGVwdGhMaW1pdAAAAAAAAAEAAAABAAAAwAUAAEFwcGxpY2F0aW9uRXJyb3JVbmtub3duTWV0aG9kSW52YWxpZE1lc3NhZ2VUeXBlV3JvbmdNZXRob2ROYW1lQmFkU2VxdWVuY2VJZE1pc3NpbmdSZXN1bHRJbnRlcm5hbEVycm9ySW52YWxpZFRyYW5zZm9ybUludmFsaWRQcm90b2NvbFVuc3VwcG9ydGVkQ2xpZW50VHlwZQAAABeVHwAmlR8ALpUfADqVHwBDlR8ATpUfAGOVHwAPAAAACAAAAAwAAAAJAAAACwAAABUAAAAQAAAAfJUfAIqVHwCSlR8AY5UfAKeVHwC9lR8AzJUfAA4AAAAIAAAAFQAAABAAAAAWAAAADwAAABoAAADmlR8A85UfAAmWHwAklh8AQZYfAFmWHwBulh8AfJUfAIyWHwCdlh8At5YfAA0AAAAWAAAAGwAAAB0AAAAYAAAAFQAAAB4AAAAOAAAAEQAAABoAAAAbAAAABwAAAAcAAAALAAAACAAAAAkAAAAMAAAACQAAAAaXHwANlx8AFJcfAB+XHwAnlx8AMJcfADyXHwAHAAAACwAAAAwAAAAJAAAACgAAAA4AAAAKAAAABpcfAGWXHwAwlx8APJcfAHCXHwB6lx8AiJcfAAcAAAANAAAAEgAAAA8AAAANAAAADQAAAA0AAAANAAAAEAAAAA8AAAAVAAAABpcfALSXHwDBlx8A05cfAOKXHwDvlx8A/JcfAFiXHwAJmB8AGZgfACiYHwAemsC+/mJ4v3wYwtfvIfKnwQUAAAwAAAAEAAAAKQAAAMEFAAAMAAAABAAAACoAAAApAAAA4JkfAMIFAADDBQAALQAAAMIFAADEBQAAznUQAGoAAAC9AQAAHQAAAGFzc2VydGlvbiBmYWlsZWQ6IGRzdC5sZW4oKSA+PSBzZWxmLnJlcXVpcmVkX3NwYWNlKClkHRAAZQAAAJ4AAAAJAAAAZB0QAGUAAACoAAAACQAAAGQdEABlAAAAowAAAA0AAABkHRAAZQAAAL0AAAAJAAAAZB0QAGUAAADHAAAACQAAAGQdEABlAAAAwgAAAA0AAAB8RBAAZQAAADcAAAAJAAAAVW50ZXJtaW5hdGVkIHZhcmludAB8RBAAZQAAADwAAAAYAAAAnEYQAGkAAACjAAAAEwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVuKCkAAJIxEABiAAAAXgAAAAkAAABoQhAAYwAAACUCAAAZAAAAaEIQAGMAAACoAQAAJgAAAGNhbm5vdCBncm93IGJ1ZmZlciBiZXlvbmQgMiBnaWdhYnl0ZXMAAABoQhAAYwAAAPgCAAAJAAAAaEIQAGMAAADnAgAAFwAAAGhCEABjAAAA5wIAADEAAABoQhAAYwAAAPgAAAAtAAAAaEIQAGMAAAD4AAAASAAAANcyEAB4AAAA6wcAAAkAAABtaWQgPiBsZW4AAADgmx8ACQBB/Lf+AAt3AQAAAMwFAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAAEQBAABUcnlGcm9tSW50RXJyb3IAzQUAAM51EABqAAAAvQEAAB0AAAAAAAAA//////////9onB8AQYC5/gALyw9LKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAADscEABgAAAAxgAAACAAAABub3QgaW1wbGVtZW50ZWQ6IEJpZyBFbmRpYW4gaXMgbm90IHN1cHBvcnRlZCBmb3IgRGVjaW1hbCEAAACwnB8AOQAAADscEABgAAAAzAAAABEAAAA7HBAAYAAAANAAAAAQAAAAOxwQAGAAAAArAQAALgAAAFVuZXhwZWN0ZWQgYml0d2lkdGggYW5kIHNpZ25lZAAAJJ0fAB4AAAA7HBAAYAAAADUBAAAWAAAAOxwQAGAAAABCAQAAKwAAAEludCB0eXBlIHdpdGggYml0IHdpZHRoIG9mICBhbmQgc2lnbmVkIG9mICBub3Qgc3VwcG9ydGVkbJ0fABsAAACHnR8ADwAAAJadHwAOAAAAOxwQAGAAAABMAQAAFgAAADscEABgAAAAWQEAADkAAAA7HBAAYAAAAF0BAAA4AAAARmxvYXRpbmdQb2ludCB0eXBlIHdpdGggcHJlY2lzaW9uIG9mIAAAAOydHwAlAAAAlp0fAA4AAAA7HBAAYAAAAGIBAAAWAAAAOxwQAGAAAABmAQAALQAAAERhdGUgdHlwZSB3aXRoIHVuaXQgb2YgAESeHwAXAAAAlp0fAA4AAAA7HBAAYAAAAGoBAAAWAAAAOxwQAGAAAABuAQAALQAAAFRpbWUgdHlwZSB3aXRoIGJpdCB3aWR0aCBvZiAgYW5kIHVuaXQgb2YgAAAAjJ4fABwAAAConh8ADQAAAJadHwAOAAAAOxwQAGAAAAB0AQAAFgAAADscEABgAAAAewEAADcAAABUaW1lc3RhbXAgdHlwZSB3aXRoIHVuaXQgb2Yg8J4fABwAAACWnR8ADgAAADscEABgAAAAhgEAABYAAAA7HBAAYAAAAIoBAAA1AAAASW50ZXJ2YWwgdHlwZSB3aXRoIHVuaXQgb2YgIHVuc3VwcG9ydGVkADyfHwAbAAAAV58fAAwAAAA7HBAAYAAAAJEBAAAWAAAAOxwQAGAAAACVAQAANQAAAER1cmF0aW9uIHR5cGUgd2l0aCB1bml0IG9mIACUnx8AGwAAAFefHwAMAAAAOxwQAGAAAACbAQAAFgAAADscEABgAAAAnwEAAC0AAABleHBlY3QgYSBsaXN0IHRvIGhhdmUgb25lIGNoaWxkAOCfHwAfAAAAOxwQAGAAAAChAQAAEQAAADscEABgAAAApgEAAC0AAABleHBlY3QgYSBsYXJnZSBsaXN0IHRvIGhhdmUgb25lIGNoaWxkAAAAKKAfACUAAAA7HBAAYAAAAKgBAAARAAAAOxwQAGAAAACtAQAALQAAADscEABgAAAAsQEAADcAAAA7HBAAYAAAAK8BAAARAAAAOxwQAGAAAAC8AQAALQAAAFJ1bkVuZEVuY29kZWQgdHlwZSBzaG91bGQgaGF2ZSBleGFjdGx5IHR3byBjaGlsZHJlbi4gRm91bmQgAKigHwA7AAAAOxwQAGAAAAC+AQAAEQAAADscEABgAAAAyAEAACsAAAA7HBAAYAAAAMkBAAAtAAAAZXhwZWN0IGEgbWFwIHRvIGhhdmUgb25lIGNoaWxkAAAcoR8AHgAAADscEABgAAAAywEAABEAAAA7HBAAYAAAANABAAAvAAAAOxwQAGAAAADSAQAAPAAAADscEABgAAAA0wEAADQAAABVbmV4cGVjdGVkIGRlY2ltYWwgYml0IHdpZHRoIAAAAIShHwAdAAAAOxwQAGAAAADZAQAAFgAAADscEABgAAAA3QEAAC8AAAA7HBAAYAAAAOgBAAAcAAAAVW5leHBlY3RlZCB1bmlvbiBtb2RlOiAA3KEfABcAAAA7HBAAYAAAAOIBAAAZAAAAbm90IGltcGxlbWVudGVkOiBUeXBlIAAADKIfABYAAACWnR8ADgAAADscEABgAAAA8wEAAA4AAABJUEMgbXVzdCBubyBsb25nZXIgYmUgdXNlZCB3aXRob3V0IGRpY3Rpb25hcnkgdHJhY2tlcgAAAESiHwA1AAAAOxwQAGAAAAAWAgAAFQAAAG5vdCBpbXBsZW1lbnRlZDogTGlzdFZpZXcvTGFyZ2VMaXN0VmlldyBub3QgaW1wbGVtZW50ZWQAlKIfADcAAAA7HBAAYAAAAAMDAAArAAAAOxwQAGAAAAAaAwAAGgAAADscEABgAAAAbQMAABoAAAAIAAAAEAAAACAAAABAAAAACAAAABAAAAAgAAAAQAAAAAgAAAAQAAAAIAAAAEAAAAAgAAAAIAAAAEAAAABAAAAAaEIQAGMAAAAlAgAAGQAAAGhCEABjAAAAqAEAACYAAABoQhAAYwAAAOABAAAYAAAAY2Fubm90IGdyb3cgYnVmZmVyIGJleW9uZCAyIGdpZ2FieXRlcwAAAGhCEABjAAAA+AIAAAkAAABoQhAAYwAAAPgAAAAtAAAAaEIQAGMAAAD4AAAASAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADOBQAA//////////9ApB8AQdjI/gALIdcyEAB4AAAA6wcAAAkAAABtaWQgPiBsZW4AAABopB8ACQBBhMn+AAv1AwEAAADPBQAA+5UQAF4AAADMAAAAEQAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADQBQAACAAAAAQAAAByAgAAcwIAAHQCAADRBQAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIGZpeGVkIHNpemUgbGlzdCBhcnJheQB1NxAAXwAAACcBAAAWAAAAdTcQAF8AAAA1AQAASAAAAHU3EABfAAAANQEAAFQAAABJbmNvcnJlY3QgZmllbGQgZGF0YSB0eXBlIAAAbKUfABoAAAB1NxAAXwAAADYBAAAaAAAAdTcQAF8AAAADAQAALwAAAFRoZSBydW4gZW5jb2RlZCBhcnJheSBzaG91bGQgaGF2ZSBleGFjdGx5IHR3byBjaGlsZCBhcnJheXMuIEZvdW5kIAAAsKUfAEIAAAB1NxAAXwAAAG0BAAAkAAAAdTcQAF8AAABvAQAAKQAAAHU3EABfAAAAhwEAAC4AAAB1NxAAXwAAAI8BAAAuAAAAbm8gZGljdCBpZCBmb3IgZmllbGQgAAAAPKYfABUAAAB1NxAAXwAAAK4BAAAoAAAAdTcQAF8AAACwAQAANwBBvM3+AAv3KHU3EABfAAAA8gEAAC4AAAB1NxAAXwAAAPIBAAAUAAAAdTcQAF8AAABLAgAALgAAAHU3EABfAAAASwIAABQAAAB1NxAAXwAAAIQCAAAUAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogVW5leHBlY3RlZCBkYXRhIHR5cGUgAAynHwA/AAAAdTcQAF8AAACeAgAAEgAAAFRoZSBnaXZlbiBhcnJheSBpcyBub3QgYSBydW4gYXJyYXkuIERhdGEgdHlwZSBvZiBnaXZlbiBhcnJheTogAABkpx8APgAAAHU3EABfAAAAuwIAACwAAAB1NxAAXwAAAL4CAAA7AAAAdTcQAF8AAAAfAwAAFwAAAERpY3Rpb25hcnkgcmVwbGFjZW1lbnQgZGV0ZWN0ZWQgd2hlbiB3cml0aW5nIElQQyBmaWxlIGZvcm1hdC4gQXJyb3cgSVBDIGZpbGVzIG9ubHkgc3VwcG9ydCBhIHNpbmdsZSBkaWN0aW9uYXJ5IGZvciBhIGdpdmVuIGZpZWxkIGFjcm9zcyBhbGwgYmF0Y2hlcy51NxAAXwAAAGYDAAAbAAAAdTcQAF8AAABwAwAAGwAAAHU3EABfAAAASgYAACYAAAB1NxAAXwAAAEwGAAAtAAAAdTcQAF8AAABNBgAAKgAAAHU3EABfAAAAZwYAAEgAAAB1NxAAXwAAAGgGAAASAAAAdTcQAF8AAAB2BgAASAAAAHU3EABfAAAAdwYAABYAAAB1NxAAXwAAAHIGAAANAAAAdTcQAF8AAACOBgAADwAAAHU3EABfAAAAigYAAA8AAAABAAAAdTcQAF8AAAD1BgAAFwAAAHU3EABfAAAA8wYAAAkAAAB1NxAAXwAAACcHAAAaAAAAdTcQAF8AAAAiBwAACQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGV1NxAAXwAAAAsHAAASAAAAdTcQAF8AAAAEBwAACQAAAHU3EABfAAAAAwcAAAkAAAB1NxAAXwAAANsGAAAXAAAAdTcQAF8AAADdBgAAIwAAAHU3EABfAAAA5AYAAB8AAAB1NxAAXwAAANkGAAAJAAAAdTcQAF8AAACDBwAAGAAAAHU3EABfAAAAjQcAAA0AAAB1NxAAXwAAAJAHAAAqAAAAdTcQAF8AAACQBwAAEAAAAJxGEABpAAAAowAAABMAAADnTFBqiLKas2VJ+LFNtFzSvpwqkZE2NGDFSEAXEQ6bNNcyEAB4AAAA6wcAAAkAAADOdRAAagAAAKcBAAAfAAAAznUQAGoAAAC9AQAAHQAAANMFAAAwAAAABAAAANQFAADVBQAANAAAAAQAAADWBQAASysQAGYAAACyAAAAGQAAAEsrEABmAAAA5QAAABkAAABGaWVsZCAgb2YgTnVsbEFycmF5IGhhcyB1bmVxdWFsIG51bGxfY291bnQgIGFuZCBsZW4g7KofAAYAAADyqh8AJQAAABerHwAJAAAATWlzc2luZyB2YXJpYWRpYyBjb3VudCBmb3IgIGNvbHVtbgAAOKsfABsAAABTqx8ABwAAAOJEEABfAAAAjQAAACMAAADiRBAAXwAAAM0AAAAkAAAA0wUAADAAAAAEAAAA1wUAANgFAADZBQAA2gUAANsFAADcBQAA3QUAAN4FAADfBQAA4AUAAOEFAADiBQAA4wUAAOQFAADlBQAA5gUAAOcFAADoBQAA6QUAAOJEEABfAAAA0QAAAB4AAAAgZG9lcyBub3QgaGF2ZSBkaWN0IGlkAADsqh8ABgAAAPSrHwAWAAAAQ2Fubm90IGZpbmQgYSBkaWN0aW9uYXJ5IGJhdGNoIHdpdGggZGljdCBpZDogAAAAHKwfAC0AAADiRBAAXwAAAP8AAABDAAAA4kQQAF8AAAAFAQAAJQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IERhdGEgdHlwZSAgZWl0aGVyIHVuc3VwcG9ydGVkIG9yIG5vdCBwcmltaXRpdmV0rB8ANAAAAKisHwAkAAAA4kQQAF8AAAATAQAAEgAAAOJEEABfAAAAEAEAACEAAADiRBAAXwAAADQBAAAdAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogQ2Fubm90IGNyZWF0ZSBsaXN0IG9yIG1hcCBhcnJheSBmcm9tIAAMrR8ATwAAAOJEEABfAAAAPQEAABIAAABudWxsX2NvdW50IHZhbHVlICgpIGRvZXNuJ3QgbWF0Y2ggYWN0dWFsIG51bWJlciBvZiBudWxscyBpbiBhcnJheSAoKXStHwASAAAAhq0fADEAAAC3rR8AAQAAANUFAAA0AAAABAAAAIcBAADqBQAAiQEAAOsFAADsBQAAjAEAAO0FAADuBQAAjwEAAOAFAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBDYW5ub3QgY3JlYXRlIGRpY3Rpb25hcnkgYXJyYXkgZnJvbSAAACiuHwBOAAAA4kQQAF8AAACKAQAADQAAAFVuYWJsZSB0byBnZXQgYnVmZmVycyBmcm9tIElQQyBSZWNvcmRCYXRjaFVuYWJsZSB0byBnZXQgZmllbGQgbm9kZXMgZnJvbSBJUEMgUmVjb3JkQmF0Y2hhc3NlcnRpb24gZmFpbGVkOiB2YXJpYWRpY19jb3VudHMuaXNfZW1wdHkoKeJEEABfAAAAIAIAABEAAADiRBAAXwAAAAsCAAAcAAAA4kQQAF8AAAA1AgAAEQAAAOJEEABfAAAAKAIAABoAAADiRBAAXwAAADwCAAApAAAA4kQQAF8AAABAAgAAHQAAAEludmFsaWQgZGF0YSBmb3Igc2NoZW1hLiAgcmVmZXJzIHRvIG5vZGUgbm90IGZvdW5kIGluIHNjaGVtYXSvHwAZAAAAja8fACMAAADvBQAACAAAAAQAAAByAgAAcwIAAHQCAADwBQAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAATm8gZXhpc3RpbmcgZGljdGlvbmFyeSBmb3IgZGVsdGEgZGljdGlvbmFyeSB3aXRoIGlkICcnAAAYsB8ANQAAAE2wHwABAAAARmFpbGVkIHRvIGNvbmNhdCBkZWx0YSBkaWN0aW9uYXJ5OiAAYLAfACMAAADiRBAAXwAAACADAAAeAAAAZGljdGlvbmFyeSBpZCAgbm90IGZvdW5kIGluIHNjaGVtYQAAnLAfAA4AAACqsB8AFAAAAJxGEABpAAAAowAAABMAAABSOhAAZAAAANkAAAAbAAAAUjoQAGQAAABRAQAADQAAAFI6EABkAAAAUgEAAA0AAABSOhAAZAAAAFMBAAANAAAAUjoQAGQAAABUAQAADQAAAFI6EABkAAAAWwEAAA0AAABSOhAAZAAAAFwBAAANAAAAUjoQAGQAAABdAQAADQAAAFI6EABkAAAAXgEAAA0AAABSOhAAZAAAAEsBAAAyAAAAYXJyb3dfaXBjOjpnZW46OlNjaGVtYTo6RmVhdHVyZWZsYXRidWZmZXJzOjpwcmltaXRpdmVzOjpGb3J3YXJkc1VPZmZzZXQ8YXJyb3dfaXBjOjpnZW46OlNjaGVtYTo6RmllbGQ+ZmxhdGJ1ZmZlcnM6OnByaW1pdGl2ZXM6OkZvcndhcmRzVU9mZnNldDxhcnJvd19pcGM6Omdlbjo6U2NoZW1hOjpLZXlWYWx1ZT5pNjR1MTZ1MzJpMTZpMzJmbGF0YnVmZmVyczo6cHJpbWl0aXZlczo6Rm9yd2FyZHNVT2Zmc2V0PGFycm93X2lwYzo6Z2VuOjpUZW5zb3I6OlRlbnNvckRpbT4AAFI6EABkAAAATgIAAC8AAAAAAAAABAAAAAQAAADxBQAARXJyb3JUcmFjZQAAAAAAAAQAAAAEAAAA8gUAAAAAAAAEAAAABAAAADEAAABWZWN0b3JFbGVtZW50aW5kZXhwb3NpdGlvbgAA8wUAAAwAAAAEAAAAoQEAAFRhYmxlRmllbGRmaWVsZF9uYW1lVW5pb25WYXJpYW50dmFyaWFudGNvZGVjbWV0aG9kbGVuZ3Robm9kZXNidWZmZXJzY29tcHJlc3Npb252YXJpYWRpY0J1ZmZlckNvdW50c2lkZGF0YWlzRGVsdGFsaXN0U2l6ZWtleXNTb3J0ZWRtb2RldHlwZUlkc2JpdFdpZHRoaXNfc2lnbmVkcHJlY2lzaW9uYnl0ZVdpZHRoc2NhbGV1bml0dGltZXpvbmVrZXl2YWx1ZWluZGV4VHlwZWlzT3JkZXJlZGRpY3Rpb25hcnlLaW5kbmFtZW51bGxhYmxldHlwZV90eXBldHlwZV9kaWN0aW9uYXJ5Y2hpbGRyZW5jdXN0b21fbWV0YWRhdGFUeXBlOjpOdWxsVHlwZTo6SW50VHlwZTo6RmxvYXRpbmdQb2ludFR5cGU6OkJpbmFyeVR5cGU6OlV0ZjhUeXBlOjpCb29sVHlwZTo6RGVjaW1hbFR5cGU6OkRhdGVUeXBlOjpUaW1lVHlwZTo6VGltZXN0YW1wVHlwZTo6SW50ZXJ2YWxUeXBlOjpMaXN0VHlwZTo6U3RydWN0X1R5cGU6OlVuaW9uVHlwZTo6Rml4ZWRTaXplQmluYXJ5VHlwZTo6Rml4ZWRTaXplTGlzdFR5cGU6Ok1hcFR5cGU6OkR1cmF0aW9uVHlwZTo6TGFyZ2VCaW5hcnlUeXBlOjpMYXJnZVV0ZjhUeXBlOjpMYXJnZUxpc3RUeXBlOjpSdW5FbmRFbmNvZGVkVHlwZTo6QmluYXJ5Vmlld1R5cGU6OlV0ZjhWaWV3VHlwZTo6TGlzdFZpZXdUeXBlOjpMYXJnZUxpc3RWaWV3ZW5kaWFubmVzc2ZpZWxkc2ZlYXR1cmVzaW5kaWNlc1R5cGVpbmRpY2VzU3RyaWRlc2luZGljZXNCdWZmZXJpc0Nhbm9uaWNhbGNvbXByZXNzZWRBeGlzaW5kcHRyVHlwZWluZHB0ckJ1ZmZlcmluZHB0ckJ1ZmZlcnNpbmRpY2VzQnVmZmVyc2F4aXNPcmRlcnNoYXBlbm9uX3plcm9fbGVuZ3Roc3BhcnNlSW5kZXhfdHlwZXNwYXJzZUluZGV4U3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZVRlbnNvckluZGV4Q09PU3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZU1hdHJpeEluZGV4Q1NYU3BhcnNlVGVuc29ySW5kZXg6OlNwYXJzZVRlbnNvckluZGV4Q1NGc2l6ZV9zdHJpZGVzAJxGEABpAAAAowAAABMAAABkdXBsaWNhdGUgdHlwZSBpZDogAOC2HwATAAAAUS8QAGIAAABwAQAAFQAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAF8DAAAJAAAAznUQAGoAAAC9AQAAHQAAAEsrEABmAAAAsgAAABkAAABWMVYyVjNWNFY1PFVOS05PV04gPla3HwAJAAAAX7cfAAEAAABTcGFyc2VEZW5zZUhBTEZTSU5HTEVET1VCTEVEQVlNSUxMSVNFQ09ORFNFQ09ORE1JQ1JPU0VDT05ETkFOT1NFQ09ORFlFQVJfTU9OVEhEQVlfVElNRU1PTlRIX0RBWV9OQU5PTk9ORU51bGxJbnRGbG9hdGluZ1BvaW50QmluYXJ5VXRmOEJvb2xEZWNpbWFsRGF0ZVRpbWVUaW1lc3RhbXBJbnRlcnZhbExpc3RTdHJ1Y3RfVW5pb25GaXhlZFNpemVCaW5hcnlGaXhlZFNpemVMaXN0TWFwRHVyYXRpb25MYXJnZUJpbmFyeUxhcmdlVXRmOExhcmdlTGlzdFJ1bkVuZEVuY29kZWRCaW5hcnlWaWV3VXRmOFZpZXdMaXN0Vmlld0xhcmdlTGlzdFZpZXcAAEy3HwBOtx8AULcfAFK3HwBUtx8ABAAAAAYAAAAGAAAAe7cfAH+3HwCFtx8ABgAAAAsAAAALAAAACgAAAJm3HwCOtx8An7cfAKq3HwAKAAAACAAAAA4AAAC0tx8AvrcfAMa3HwAEAAAABAAAAAMAAAANAAAABgAAAAQAAAAEAAAABwAAAAQAAAAEAAAACQAAAAgAAAAEAAAABwAAAAUAAAAPAAAADQAAAAMAAAAIAAAACwAAAAkAAAAJAAAADQAAAAoAAAAIAAAACAAAAA0AAADUtx8A2LcfANy3HwDftx8A7LcfAPK3HwD2tx8A+rcfAAG4HwAFuB8ACbgfABK4HwAauB8AHrgfACW4HwAquB8AObgfAEa4HwBJuB8AUbgfAFy4HwBluB8AbrgfAHu4HwCFuB8AjbgfAJW4HwBtaWQgPiBsZW4AAADguR8ACQAAAEwaEAB/AAAASgAAAB8AAABMGhAAfwAAAEQAAAAXAAAAAAAAAAQAAAAEAAAA9wUAAAAAAAAEAAAABAAAAPgFAAD5BQAA+QUAAAAAAAAEAAAABAAAAPoFAAD7BQAA+wUAAFyCEAB+AAAAsgUAACQAAAChOBAAbgAAACMIAAARAAAAnEYQAGkAAACjAAAAEwAAAFI6EABkAAAAUQEAAA0AAABSOhAAZAAAAFIBAAANAAAAUjoQAGQAAABTAQAADQAAAFI6EABkAAAAVAEAAA0AAABSOhAAZAAAAFsBAAANAAAAUjoQAGQAAABcAQAADQAAAFI6EABkAAAAXQEAAA0AAABSOhAAZAAAAF4BAAANAAAAUjoQAGQAAABLAQAAMgAAANcyEAB4AAAA6wcAAAkAAAD8BQAA//////////8oux8AQcD2/gALjQhpNjR1MTZ1MzJpMTZpMzIAUjoQAGQAAABOAgAALwAAAM51EABqAAAAvQEAAB0AAABLKxAAZgAAALIAAAAZAAAASysQAGYAAADlAAAAGQAAADscEABgAAAAqAAAAB4AAAA7HBAAYAAAALAAAAAeAAAAdmVyc2lvbmhlYWRlcl90eXBlaGVhZGVyYm9keUxlbmd0aGN1c3RvbV9tZXRhZGF0YU1lc3NhZ2VIZWFkZXI6OlNjaGVtYU1lc3NhZ2VIZWFkZXI6OkRpY3Rpb25hcnlCYXRjaE1lc3NhZ2VIZWFkZXI6OlJlY29yZEJhdGNoTWVzc2FnZUhlYWRlcjo6VGVuc29yTWVzc2FnZUhlYWRlcjo6U3BhcnNlVGVuc29ya2V5dmFsdWUAAM51EABqAAAAvQEAAB0AAABjb21wcmVzc2lvbiB0eXBlICBub3Qgc3VwcG9ydGVkIHi8HwARAAAAibwfAA8AAABNTRAAZAAAAEUAAAAUAAAATU0QAGQAAABpAAAAJAAAAEludmFsaWQgdW5jb21wcmVzc2VkIGxlbmd0aDogAAAAyLwfAB0AAABsejQgSVBDIGNvbXByZXNzaW9uIHJlcXVpcmVzIHRoZSBsejQgZmVhdHVyZWx6NCBJUEMgZGVjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgbHo0IGZlYXR1cmV6c3RkIElQQyBjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgenN0ZCBmZWF0dXJlenN0ZCBJUEMgZGVjb21wcmVzc2lvbiByZXF1aXJlcyB0aGUgenN0ZCBmZWF0dXJlTU0QAGQAAADZAAAAHQAAAEhtEABsAAAASwIAABMAAABVbmFibGUgdG8gZG93bmNhc3QgdG8gbGlzdCBhcnJheToZEABfAAAApwIAAAoAAAB3NRAAaQAAAEYAAAAgAAAAdzUQAGkAAAA3AAAAIAAAAHc1EABpAAAAKwAAACAAAABoQhAAYwAAAGkCAAA8AAAAaEIQAGMAAABzAgAAKwAAAGhCEABjAAAAfgIAADcAAABoQhAAYwAAAIACAAArAAAAaEIQAGMAAACFAgAALAAAAGhCEABjAAAAlAIAACYAAABjYW5ub3QgZ3JvdyBidWZmZXIgYmV5b25kIDIgZ2lnYWJ5dGVzAAAAaEIQAGMAAAD4AgAACQAAAGhCEABjAAAA5wIAABcAAABoQhAAYwAAAOcCAAAxAAAAaEIQAGMAAAD4AAAALQAAAGhCEABjAAAA+AAAAEgAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABtaWQgPiBsZW4AAAA8vx8ACQBB2P7+AAuVBAEAAAD+BQAATGF5b3V0RXJyb3IAkjEQAGIAAACRAAAAEwAAAExaNF9GUkFNRVpTVEQ8VU5LTk9XTiA+AIm/HwAJAAAAkr8fAAEAAABOT05FU2NoZW1hRGljdGlvbmFyeUJhdGNoUmVjb3JkQmF0Y2hUZW5zb3JTcGFyc2VUZW5zb3IAAAQAAAAGAAAADwAAAAsAAAAGAAAADAAAAKS/HwCovx8Arr8fAL2/HwDIvx8Azr8fANcyEAB4AAAA6wcAAAkAAABoQhAAYwAAACUCAAAZAAAAY2Fubm90IGdyb3cgYnVmZmVyIGJleW9uZCAyIGdpZ2FieXRlcwAAAGhCEABjAAAA+AIAAAkAAABoQhAAYwAAAOcCAAAXAAAAaEIQAGMAAADnAgAAMQAAAGhCEABjAAAA+AAAAC0AAABoQhAAYwAAAPgAAABIAAAAbWlkID4gbGVuAAAApMAfAAkAAAA7HBAAYAAAAI0AAAAlAAAAdTE2bWlkID4gbGVuy8AfAAkAAAA6hhAAcAAAAC4CAAARAAAAaEIQAGMAAABkAAAAMQAAAGhCEABjAAAAZQAAABMAAABoQhAAYwAAAKEAAAAYAAAAnEYQAGkAAACjAAAAEwAAAJIxEABiAAAAnAAAABkAAABSOhAAZAAAAEsBAAAgAAAAUjoQAGQAAABLAQAAMgAAAOVsEABiAAAAXAAAABIAAAAFAEH4gv8ACwEPAEGEg/8ACwENAEGQg/8ACwISAgBBnIP/AAsCEQIAQaiD/wALAhIBAEG0g/8ACwEEAEHAg/8ACwESAEHMg/8ACwIQAQBB2IP/AAsCEQMAQeSD/wALARAAQfCD/wALARMAQfyD/wALAhIDAEGIhP8ACwEOAEGUhP8ACwINAgBBoIT/AAsCDQEAQayE/wALAg0DAEG4hP8AC7ELaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogRGVjaW1hbDY0QXJyYXkgZGF0YXR5cGUgaXMgbm90IERhdGFUeXBlOjpEZWNpbWFsNjQgYnV0IAAAADjCHwBhAAAAKAsQAHAAAACYBgAAFQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IERlY2ltYWwxMjhBcnJheSBkYXRhdHlwZSBpcyBub3QgRGF0YVR5cGU6OkRlY2ltYWwxMjggYnV0IAC0wh8AYwAAACgLEABwAAAAogYAABUAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBEZWNpbWFsMzJBcnJheSBkYXRhdHlwZSBpcyBub3QgRGF0YVR5cGU6OkRlY2ltYWwzMiBidXQgAAAAMMMfAGEAAAAoCxAAcAAAAI4GAAAVAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogRGVjaW1hbDI1NkFycmF5IGRhdGF0eXBlIGlzIG5vdCBEYXRhVHlwZTo6RGVjaW1hbDI1NiBidXQgAKzDHwBjAAAAKAsQAHAAAACsBgAAFQAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAACjEHwAlAAAATcQfACEAAAAoCxAAcAAAAOcCAAAJAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZSgLEABwAAAACQYAABIAAAAoCxAAcAAAAF8GAAAVAAAAKAsQAHAAAABzBgAAFQAAACgLEABwAAAAfQYAABUAAAAoCxAAcAAAAGkGAAAVAAAAYE5haXZlRGF0ZVRpbWUgLSBGaXhlZE9mZnNldGAgb3V0IG9mIHJhbmdlAAAShBAAaAAAAGcHAAAmAAAA9TEQAG0AAAA/AQAAJQAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAAEkAAAAFAAAAYXR0ZW1wdCB0byBkaXZpZGUgYnkgemVybwAAAJjFHwAZAAAA+HgQAGYAAADoAQAALwAAAPh4EABmAAAA+AEAAC8AAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAADAwMDEwMjAzMDQwNTA2MDcwODA5MTAxMTEyMTMxNDE1MTYxNzE4MTkyMDIxMjIyMzI0MjUyNjI3MjgyOTMwMzEzMjMzMzQzNTM2MzczODM5NDA0MTQyNDM0NDQ1NDY0NzQ4NDk1MDUxNTI1MzU0NTU1NjU3NTg1OTYwNjE2MjYzNjQ2NTY2Njc2ODY5NzA3MTcyNzM3NDc1NzY3Nzc4Nzk4MDgxODI4Mzg0ODU4Njg3ODg4OTkwOTE5MjkzOTQ5NTk2OTc5ODk5YXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBNaWxsaXNlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcE1pY3Jvc2Vjb25kVHlwZWFycm93X2FycmF5Ojp0eXBlczo6VGltZXN0YW1wTmFub3NlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcFNlY29uZFR5cGUAAIZ/EABrAAAAJwEAAAUAAACGfxAAawAAAD8BAAAFAAAAhn8QAGsAAABXAQAABQAAANcyEAB4AAAA6wcAAAkAQfSP/wALrQYBAAAAFgYAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgLyAAAAD8xx8AFgAAABLIHwADAAAAICogAPzHHwAWAAAAKMgfAAMAAABMYXlvdXRFcnJvckxvY2FsIHRpbWUgb3V0IG9mIHJhbmdlIGZvciBgTmFpdmVEYXRlVGltZWAAAHuEEABiAAAAQwIAAA4AAADOdRAAagAAAL0BAAAdAAAARGVjaW1hbDEyOAAAlMgfAAoAAABDYW5ub3QgY2FzdCB0byAoLCApLiBPdmVyZmxvd2luZyBvbiCoyB8ADwAAALfIHwABAAAAuMgfAAIAAAC6yB8AEgAAAERlY2ltYWwzMgAAAOzIHwAJAAAARGVjaW1hbDI1NgAAAMkfAAoAAABEZWNpbWFsNjQAAAAUyR8ACQAAAENhbm5vdCBjb252ZXJ0ICAgdG8gZGF0ZXRpbWUoyR8ADwAAADfJHwABAAAAOMkfAAwAAABDYW4ndCBjYXN0IHZhbHVlICB0byB0eXBlIAAAXMkfABEAAABtyR8ACQAAAENhbm5vdCBjYXN0IHRpbWV6b25lIHRvIGRpZmZlcmVudCB0aW1lem9uZQAAAQAAAAAAAAAgeWVhcnMgIG1vbnMBAAAAAAAAALzJHwAHAAAAw8kfAAUAAAAgZGF5cwAAAAEAAAAAAAAAAQAAAAAAAADgyR8ABQAAAAEAAAAAAAAAAQAAAAAAAADDyR8ABQAAAF4OEABhAAAA7AEAAAEAAABeDhAAYQAAACECAAABAAAARmFpbGVkIHRvIGNvbnZlcnQgIHRvIGRhdGV0aW1lIGZvciAAOMofABIAAABKyh8AEQAAACB0byB0ZW1wb3JhbCBmb3IgAAAAOMofABIAAABsyh8AEQAAADxpbnZhbGlkPgAAAJDKHwAJAAAAIGRheXMgIGhvdXJzICBtaW5zICBzZWNzAQAAAAAAAACkyh8ABgAAAKrKHwAHAAAAscofAAYAAAC3yh8ABQAAAC4AAAABAAAAAAAAAKTKHwAGAAAAqsofAAcAAACxyh8ABgAAAOTKHwABAAAAt8ofAAUAAAACAAAAAAAAAAIAQayW/wALTSAAAOACAAAAAAAAAAIAAAAAAAAAAQAAACAAAOACAAAAAAAAAAIAAAAAAAAAAgAAACAAAOACAAAAAAAAAAIAAAAAAAAAAwAAACAAAOACAEGCl/8AC08DAAAAAAAEAAAAIAAA6SBtaW5zIC0AAQAAAAAAAACkyh8ABgAAAKrKHwAHAAAAkMsfAAcAAADkyh8AAQAAALfKHwAFAAAAAgAAAAAAAAACAEHcl/8AC00gAADgAgAAAAAAAAACAAAAAAAAAAEAAAAgAADgAgAAAAAAAAACAAAAAAAAAAIAAAAgAADgAgAAAAAAAAACAAAAAAAAAAMAAAAgAADgAgBBspj/AAsXBgAAAAAABAAAACAAAOkCAAAAAAAAAAIAQdSY/wALTSAAAOACAAAAAAAAAAIAAAAAAAAAAQAAACAAAOACAAAAAAAAAAIAAAAAAAAAAgAAACAAAOACAAAAAAAAAAIAAAAAAAAAAwAAACAAAOACAEGqmf8AC6sXCQAAAAAABAAAACAAAOkYBgAAMAAAAAQAAAAZBgAAGAYAADAAAAAEAAAAGgYAABgGAAAwAAAABAAAABsGAAAYBgAAMAAAAAQAAAAcBgAAGAYAADAAAAAEAAAAHQYAABgGAAAwAAAABAAAAB4GAAAYBgAAMAAAAAQAAAAfBgAAGAYAADAAAAAEAAAAIAYAABgGAAAwAAAABAAAACEGAAAYBgAAMAAAAAQAAAAiBgAAGAYAADAAAAAEAAAAIwYAABgGAAAwAAAABAAAACQGAAAlBgAASAAAAAQAAAAmBgAAJQYAAEgAAAAEAAAAJwYAACUGAABIAAAABAAAACgGAAAlBgAASAAAAAQAAAApBgAAJQYAAEgAAAAEAAAAKgYAACUGAABIAAAABAAAACsGAAAlBgAASAAAAAQAAAAsBgAAJQYAAEgAAAAEAAAALQYAAC4GAAA8AAAABAAAAC8GAAAuBgAAPAAAAAQAAAAwBgAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAGM4fACUAAAA9zh8AIQAAACgLEABwAAAA5wIAAAkAAACBQRAAdAAAANwAAAAdAAAAgUEQAHQAAADOAAAAHQAAAIpAEAB9AAAAgQEAABsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAACCVRAAaAAAAIYAAAAmAAAARqbuzFCDCrw6aeStsNPxTKRNPG5KC1QQzZ2WuD4SBRhaJyC5Kqr7Rxt695ZZTB0//HVOzHvjofLa8afBfIQDqStMJF7RV/mAFgp+BY+lZ2GTibuORgks5xhJOI1DiC3pcqR+SE8zMHNwHKQ9JGz7zq85BEvhHPczoFKR3oRGSY18O94VR1BDFW/ltD+K+qJwBhkm20ndTO7d1y67tT2t5klI6zz1ZfGccblydT5HjUK1od/H4KhMQ5L9EeJjY/yjH6FPxPwhQSHWIsWI6dexeKQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyyt3JOhSbkke5YFuLkA0X7GDHJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM0fidydGl/c5W4SOD4clHcWOYOC6bqJpWsC9YjrdR6Id7O1YNFzc+RhlD6Yd/hRxSh/xWe43yMTy2N7pGLwl8ls51EABqAAAAvQEAAB0AAAAuBgAAPAAAAAQAAAAxBgAAMgYAADMGAAA0BgAANQYAADYGAAA3BgAAOAYAADkGAAA6BgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAALgYAADwAAAAEAAAARAYAAEUGAABGBgAARwYAADUGAABIBgAANwYAADgGAAA5BgAAOgYAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAABgGAAAwAAAABAAAAF0DAABJBgAAXwMAAEoGAABLBgAAYQMAAPkBAAD6AQAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABMBgAACAAAAAQAAAByAgAAcwIAAHQCAABNBgAAdgIAAHcCAAB4AgAAeQIAAHoCAAB7AgAAfAIAAH0CAAB+AgAAfwIAAIACAACBAgAAggIAAIMCAACEAgAAJQYAAEgAAAAEAAAATgYAAE8GAABQBgAAUQYAAFIGAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAACUGAABIAAAABAAAAGEGAABiBgAAYwYAAGQGAABSBgAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAAAlBgAASAAAAAQAAABuBgAAbwYAAHAGAABxBgAAUgYAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAJQYAAEgAAAAEAAAAewYAAHwGAAB9BgAAfgYAAFIGAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAACUGAABIAAAABAAAAIgGAACJBgAAigYAAIsGAABSBgAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAAlBgAASAAAAAQAAACSBgAAkwYAAJQGAACVBgAAUgYAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAJQYAAEgAAAAEAAAAnAYAAJ0GAACeBgAAnwYAAFIGAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAACUGAABIAAAABAAAAKQGAAClBgAApgYAAKcGAABSBgAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABVbnN1cHBvcnRlZCB0eXBlICBmb3IgZGljdGlvbmFyeSBpbmRleAAAgNQfABEAAACR1B8AFQAAAENvdWxkIG5vdCBjb252ZXJ0ICBkaWN0aW9uYXJ5IGluZGV4ZXMgZnJvbSAgdG8gALjUHwASAAAAytQfABkAAADj1B8ABAAAABgGAAAwAAAABAAAABsDAACsBgAAHQMAAK0GAABLBgAAHwMAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAABMAwAArgYAAE4DAACvBgAASwYAAFADAABRAwAAUgMAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAAJwMAALAGAAApAwAAsQYAAEsGAAArAwAABwIAAAgCAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAABUDAACyBgAAFwMAALMGAABLBgAAGgMAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAAAiAwAAtAYAACQDAAC1BgAASwYAACYDAAAHAgAACAIAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAAWAMAALYGAABaAwAAtwYAAEsGAABcAwAAUQMAAFIDAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAAFMDAAC4BgAAVQMAALkGAABLBgAAVwMAAPkBAAD6AQAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgZGljdGlvbmFyeSB0byBEaWN0aW9uYXJ5QXJyYXkgb2YgZXhwZWN0ZWQgdHlwZUludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCBVdGY4VmlldyB0byBTdHJpbmdBcnJheSBvZiBleHBlY3RlZCB0eXBlSW50ZXJuYWwgRXJyb3I6IENhbm5vdCBjYXN0IEJpbmFyeVZpZXcgdG8gQmluYXJ5QXJyYXkgb2YgZXhwZWN0ZWQgdHlwZUludmFsaWQgZGljdGlvbmFyeSBpbmRleBcAQeCw/wALARoAQeyw/wAL7QpVbnN1cHBvcnRlZCBvdXRwdXQgdHlwZSBmb3IgZGljdGlvbmFyeSBwYWNraW5nOiBs2B8AMAAAABgGAAAwAAAABAAAAA4CAAC6BgAAEAIAALsGAABLBgAAEgIAAAcCAAAIAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAYBgAAMAAAAAQAAADLAQAAvAYAAM0BAAC9BgAASwYAANABAADRAQAA0gEAANMBAAA6BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAGAYAADAAAAAEAAAA3gEAAL4GAADgAQAAvwYAAEsGAADiAQAA4wEAAOQBAADTAQAAOgYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAABgGAAAwAAAABAAAAAkCAADABgAACwIAAMEGAABLBgAADQIAAAACAAABAgAA0wEAADoGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABEZWNpbWFsMzIAAAAE2h8ACQAAAEludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCBkaWN0IHRvIEFycmF5AAAAGNofACQAAAA82h8ABQAAAERlY2ltYWw2NAAAAFTaHwAJAAAARGVjaW1hbDI1NgAAaNofAAoAAABEZWNpbWFsMTI4AAB82h8ACgAAAEludGVybmFsIEVycm9yOiBDYW5ub3QgY2FzdCB0byBTdHJpbmdWaWV3QXJyYXlJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgdG8gQmluYXJ5Vmlld0FycmF5SW50ZXJuYWwgRXJyb3I6IENhbm5vdCBjYXN0IHRvIEdlbmVyaWNCeXRlQXJyYXkAxwYAADwAAAAEAAAAyAYAAMcGAAA8AAAABAAAAMkGAADHBgAAPAAAAAQAAADKBgAAxwYAADwAAAAEAAAAywYAAMwGAAAwAAAABAAAAM0GAADMBgAAMAAAAAQAAADOBgAAzAYAADAAAAAEAAAAzwYAAMwGAAAwAAAABAAAANAGAADMBgAAMAAAAAQAAADRBgAAzAYAADAAAAAEAAAA0gYAAMwGAAAwAAAABAAAANMGAADMBgAAMAAAAAQAAADUBgAAzAYAADAAAAAEAAAA1QYAAMwGAAAwAAAABAAAANYGAADMBgAAMAAAAAQAAADXBgAAzAYAADAAAAAEAAAA2AYAAMwGAAAwAAAABAAAANkGAADMBgAAMAAAAAQAAADaBgAAzAYAADAAAAAEAAAA2wYAAMwGAAAwAAAABAAAANwGAADMBgAAMAAAAAQAAADdBgAAzAYAADAAAAAEAAAA3gYAAMwGAAAwAAAABAAAAN8GAADMBgAAMAAAAAQAAADgBgAAzAYAADAAAAAEAAAA4QYAAMwGAAAwAAAABAAAAOIGAADMBgAAMAAAAAQAAADjBgAAzAYAADAAAAAEAAAA5AYAAMwGAAAwAAAABAAAAOUGAADMBgAAMAAAAAQAAADmBgAAzAYAADAAAAAEAAAA5wYAAMwGAAAwAAAABAAAAOgGAADMBgAAMAAAAAQAAADpBgAAzAYAADAAAAAEAAAA6gYAAMwGAAAwAAAABAAAAOsGAADsBgAANAAAAAQAAADtBgAA7gYAADgAAAAEAAAA7wYAAPAGAAA8AAAABAAAAPEGAADwBgAAPAAAAAQAAADyBgAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAIzdHwAzAAAAHE8QAGYAAAAzAAAABQAAABIAQeS7/wALAhMCAEHwu/8ACwEIAEH8u/8ACwISAQBBiLz/AAsCEgMAQZS8/wALAQoAQaC8/wALAQIAQay8/wALAQsAQbi8/wALAQkAQcS8/wALAhICAEHQvP8ACwEFAEHcvP8ACwEHAEHovP8ACwEGAEH0vP8ACwEMAEGAvf8ACwEEAEGMvf8ACwEDAEGYvf8AC6kLVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAmN4fACUAAAC93h8AIQAAACgLEABwAAAA5wIAAAkAAAAIQRAAeAAAAIIAAAAeAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAAANQBAAfAAAAFwAAAAOAAAADUAQAHwAAABSAAAAIQAAAEJ5dGUgc2xpY2UgZG9lcyBub3QgaGF2ZSB0aGUgc2FtZSBsZW5ndGggYXMgRml4ZWRTaXplQmluYXJ5QnVpbGRlciB2YWx1ZSBsZW5ndGhzikAQAH0AAACBAQAAGwAAAIpAEAB9AAAAUwEAAD0AAACKQBAAfQAAAFMBAAAnAAAAikAQAH0AAABlAQAAHgAAAIpAEAB9AAAAaAEAABoAAACKQBAAfQAAAHABAAAbAAAAikAQAH0AAAA7AQAAHwAAAEJsb2NrIHRvbyBsYXJnZQAQ4B8ADwAAAIpAEAB9AAAAEgEAAAkAAACKQBAAfQAAABQBAAAYAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAIJVEABoAAAAhgAAACYAAAB/HWoqIlT2wIb23M7m7swAwHHNK/WXKix1JwoV9WuZpO2i5dR7gLHU18EfJ15f4lz/7Fp1xS4YcQF6eKTCW9WLeoxNLzEphhwjoC5rNYdVJgpRsywSqhLqC1ne29TsvDkofOLr7ovvGQKEKFjGuf0W7psyuBSe0blwx3izQVgXEcEjCpXN1iiwgxZfat9rzN9JSOs89WXxnHG5cnU+R41CEM/MnaU1JGkI+ioAjhXJQjX8EWXtUm++JzmV/3oBUuW1od/H4KhMQ5L9EeJjY/yji9qozLiexvSwUd4LjJ+uhEyaqF8hLELkfkWDr4NtNVxJsJ6Qek4sL8tuSeoyCBh8xyz97CXaOPcNmZPCUErMpytMJF7RV/mAFgp+BY+lZ2GvOQRL4Rz3M6BSkd6ERkmNH6FPxPwhQSHWIsWI6dexeKQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyytZJuS9QyOC2DNaGfT4eNQudyToUm5JHuWBbi5ANF+xgxyfspTfoQ6K9lFQ5fxtd+v4qn8OK0OOH7FbC6gMU1KgIYAFII7TEaZo+oYpJXtP/triAXRBZEN4LnG7yT5gwThU+wU3zfbJcgirAcRBqnTTMX88h9xhUtzbrpM08+4KMKN0XrCpBkhd9kV254FF+mM0fidydGl/c5W4SOD4clHcQcgG010/qJJvp/n9xqSBHhjmDgum6iaVrAvWI63UeiHeztWDRc3PkYZQ+mHf4UcUuRUUd5VhI00tWSikrrobxlCxt2uXnKjhOUJHZN/4dGoPvMwG5AYZta8X2XUZ8lrN5cobNP94yrZfNHsgUDHsHa+nCqRkTY0YMVIQBcRDps0h/xWe43yMTy2N7pGLwl8lmFycm93X2FycmF5Ojp0eXBlczo6VGltZXN0YW1wTWlsbGlzZWNvbmRUeXBlYXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBNaWNyb3NlY29uZFR5cGVhcnJvd19hcnJheTo6dHlwZXM6OlRpbWVzdGFtcE5hbm9zZWNvbmRUeXBlYXJyb3dfYXJyYXk6OnR5cGVzOjpUaW1lc3RhbXBTZWNvbmRUeXBlAADXMhAAeAAAAOsHAAAJAEHMyP8AC3EBAAAA8wYAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgXiAAAABU5B8AFgAAAGrkHwADAAAATGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAPQGAAA0AAAABAAAAPUGAAD2BgAALAAAAAQAAAD3BgAAAQBByMn/AAuJGcwGAAAwAAAABAAAAA4CAAD4BgAAEAIAAPkGAAD6BgAAEgIAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAADLAQAA/AYAAM0BAAD9BgAA+gYAANABAADRAQAA0gEAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAA3gEAAP4GAADgAQAA/wYAAPoGAADiAQAA4wEAAOQBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAAkCAAAABwAACwIAAAEHAAD6BgAADQIAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABEZWNpbWFsMzIAAAAo5h8ACQAAAENhbm5vdCBjYXN0IHRvICgsICkuIFRoZSBzY2FsZSBjYXVzZXMgb3ZlcmZsb3cuADzmHwAPAAAAS+YfAAEAAABM5h8AAgAAAE7mHwAdAAAARGVjaW1hbDI1NgAAjOYfAAoAAABEZWNpbWFsNjQAAACg5h8ACQAAAERlY2ltYWwxMjgAALTmHwAKAAAAzAYAADAAAAAEAAAAAgcAAAMHAAAEBwAABQcAAPoGAAAGBwAA0QEAANIBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAAcHAAAIBwAACQcAAAoHAAD6BgAACwcAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlzAYAADAAAAAEAAAADAcAAA0HAAAOBwAADwcAAPoGAAAQBwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAABEHAAASBwAAEwcAABQHAAD6BgAAFQcAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAWBwAAFwcAABgHAAAZBwAA+gYAABoHAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAlXgQAGIAAAC7AQAARQAAAJV4EABiAAAA6AEAAA4AAABJbnRlcm5hbCBFcnJvcjogQ2Fubm90IGNhc3QgZHVyYXRpb24gdG8gRHVyYXRpb25BcnJheSBvZiBleHBlY3RlZCB0eXBlAADMBgAAMAAAAAQAAAAVAwAAGwcAABcDAAAcBwAA+gYAABoDAAAAAgAAAQIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAIgMAAB0HAAAkAwAAHgcAAPoGAAAmAwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAPsBAAAfBwAA/QEAACAHAAD6BgAA/wEAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAhBwAAIgcAACMHAAAkBwAA+gYAACUHAAAAAgAAAQIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAJgcAACcHAAAoBwAAKQcAAPoGAAAqBwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAACsHAAAsBwAALQcAAC4HAAD6BgAALwcAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAwBwAAMQcAADIHAAAzBwAA+gYAADQHAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAANQcAADYHAAA3BwAAOAcAAPoGAAA5BwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAADoHAAA7BwAAPAcAAD0HAAD6BgAAPgcAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAAuAwAAPwcAADADAABABwAA+gYAADIDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAMwMAAEEHAAA1AwAAQgcAAPoGAAA3AwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAADgDAABDBwAAOgMAAEQHAAD6BgAAPAMAAAcCAAAIAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAAA9AwAARQcAAD8DAABGBwAA+gYAAEEDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAARmFpbGVkIHRvIGNyZWF0ZSBuYWl2ZSB0aW1lIHdpdGggIAAAiO0fACEAAACp7R8AAQAAAENhc3RpbmcgZnJvbSBkaWN0aW9uYXJ5IHR5cGUgIHRvICBub3Qgc3VwcG9ydGVkALztHwAdAAAA2e0fAAQAAADd7R8ADgAAAENhc3RpbmcgZnJvbSB0eXBlICB0byBkaWN0aW9uYXJ5IHR5cGUgAAAE7h8AEgAAABbuHwAUAAAA3e0fAA4AAACVeBAAYgAAAF4DAABNAAAARwcAAAgAAAAEAAAAcgIAAHMCAAB0AgAASAcAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAOwGAAA0AAAABAAAAJwEAABJBwAAngQAAEoHAABLBwAAoQQAAEwHAABNBwAApAQAAPsGAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAABjYW5ub3QgY2FzdCBmaXhlZC1zaXplLWxpc3QgdG8gZml4ZWQtc2l6ZS1saXN0IHdpdGggZGlmZmVyZW50IHNpemVDYW5ub3QgY2FzdCBsaXN0IHRvIG5vbi1saXN0IGRhdGEgdHlwZXMAAAD0BgAANAAAAAQAAACHAQAATgcAAIkBAABPBwAAUAcAAIwBAABRBwAAUgcAAI8BAAD7BgAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAQ2FzdGluZyBmcm9tIAAAAMjvHwANAAAA2e0fAAQAAADd7R8ADgAAAPAGAAA8AAAABAAAADEGAABTBwAAMwYAAFQHAABVBwAANgYAADcGAAA4BgAAOQYAAPsGAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAADwBgAAPAAAAAQAAABEBgAAVgcAAEYGAABXBwAAVQcAAEgGAAA3BgAAOAYAADkGAAD7BgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAxwYAADwAAAAEAAAAWAcAAFkHAABaBwAAWwcAAFwHAABdBwAAXgcAAF8HAABgBwAA+wYAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAMcGAAA8AAAABAAAAGoHAABrBwAAbAcAAG0HAABcBwAAbgcAAG8HAABwBwAAYAcAAPsGAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAAOAEHc4v8ACwEPAEHo4v8AC8UPzAYAADAAAAAEAAAA9AEAAHEHAAD2AQAAcgcAAPoGAAD4AQAA+QEAAPoBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAEIDAABzBwAARAMAAHQHAAD6BgAARgMAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABdAwAAdQcAAF8DAAB2BwAA+gYAAGEDAAD5AQAA+gEAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAJwMAAHcHAAApAwAAeAcAAPoGAAArAwAABwIAAAgCAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAAFgDAAB5BwAAWgMAAHoHAAD6BgAAXAMAAFEDAABSAwAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABMAwAAewcAAE4DAAB8BwAA+gYAAFADAABRAwAAUgMAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAzAYAADAAAAAEAAAAUwMAAH0HAABVAwAAfgcAAPoGAABXAwAA+QEAAPoBAADTAQAA+wYAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMwGAAAwAAAABAAAABsDAAB/BwAAHQMAAIAHAAD6BgAAHwMAAAACAAABAgAA0wEAAPsGAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADMBgAAMAAAAAQAAABHAwAAgQcAAEkDAACCBwAA+gYAAEsDAAAHAgAACAIAANMBAAD7BgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA9gYAACwAAAAEAAAAAgMAAIMHAAAEAwAAhAcAAIUHAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAAJV4EABiAAAAlgkAADYAAADuBgAAOAAAAAQAAAATAgAAhgcAABUCAACHBwAAiAcAABgCAACJBwAAigcAABsCAAD7BgAAHAIAAB0CAAAeAgAAHwIAACACAAAhAgAAIgIAACMCAAAkAgAAlXgQAGIAAADUCQAACgAAAEZpeGVkU2l6ZUJpbmFyeSBhcnJheSB0b28gbGFyZ2UgdG8gY2FzdCB0byBCaW5hcnkgYXJyYXkAlXgQAGIAAAD3CQAACgAAAJV4EABiAAAADwoAAAUAAACVeBAAYgAAABAKAAAaAAAAlXgQAGIAAAARCgAAEwAAAMcGAAA8AAAABAAAAIsHAACMBwAAjQcAAI4HAABcBwAAjwcAAF4HAABfBwAAYAcAAPsGAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADHBgAAPAAAAAQAAACQBwAAkQcAAJIHAACTBwAAXAcAAJQHAABvBwAAcAcAAGAHAAD7BgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAAQAAAAAAAABTdHJpbmcAAID2HwAGAAAATGFyZ2UAAACQ9h8ABQAAACBhcnJheSB0b28gbGFyZ2UgdG8gY2FzdCB0byAgYXJyYXkAAAEAAAAAAAAAAQAAAAAAAACg9h8AHAAAAAEAAAAAAAAAvPYfAAYAAABCaW5hcnkAAOz2HwAGAAAAAAAAAADKmjsAAAAAQEIPAAAAAADoAwAAAAAAAAEAAAAAAAAAAQAAAAAAAADoAwAAAAAAAEBCDwAAAAAAAMqaOwAAAACVBwAAPAAAAAQAAACWBwAAlQcAADwAAAAEAAAAlwcAAJgHAAAwAAAABAAAAJkHAACYBwAAMAAAAAQAAACaBwAAmAcAADAAAAAEAAAAmwcAAJgHAAAwAAAABAAAAJwHAACYBwAAMAAAAAQAAACdBwAAmAcAADAAAAAEAAAAngcAAJgHAAAwAAAABAAAAJ8HAACYBwAAMAAAAAQAAACgBwAAmAcAADAAAAAEAAAAoQcAAJgHAAAwAAAABAAAAKIHAACYBwAAMAAAAAQAAACjBwAAmAcAADAAAAAEAAAApAcAAJgHAAAwAAAABAAAAKUHAACYBwAAMAAAAAQAAACmBwAAmAcAADAAAAAEAAAApwcAAJgHAAAwAAAABAAAAKgHAACYBwAAMAAAAAQAAACpBwAAmAcAADAAAAAEAAAAqgcAAJgHAAAwAAAABAAAAKsHAACYBwAAMAAAAAQAAACsBwAAmAcAADAAAAAEAAAArQcAAJgHAAAwAAAABAAAAK4HAACYBwAAMAAAAAQAAACvBwAAsAcAADwAAAAEAAAAsQcAAFRydXN0ZWQgaXRlcmF0b3IgbGVuZ3RoIHdhcyBub3QgYWNjdXJhdGVseSByZXBvcnRlZADg+B8AMwAAABxPEABmAAAAMwAAAAUAAAAQAEG48v8ACwEIAEHE8v8ACwINAQBB0PL/AAsCEwIAQdzy/wALAg0CAEHo8v8ACwEPAEH08v8ACwECAEGA8/8ACwENAEGM8/8ACwELAEGY8/8ACwEDAEGk8/8ACwIQAQBBsPP/AAsBBwBBvPP/AAsCDQMAQcjz/wALAQQAQdTz/wALAQwAQeDz/wALAQYAQezz/wALAQ4AQfjz/wALARMAQYT0/wALAhMBAEGQ9P8ACwIRAgBBnPT/AAsBCQBBqPT/AAsCEQMAQbT0/wALAQUAQcD0/wALhQcIQRAAeAAAAIIAAAAeAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAACKQBAAfQAAAIEBAAAbAAAAikAQAH0AAABTAQAAPQAAAIpAEAB9AAAAUwEAACcAAACKQBAAfQAAAGUBAAAeAAAAikAQAH0AAABoAQAAGgAAAIpAEAB9AAAAcAEAABsAAACKQBAAfQAAADsBAAAfAAAAQmxvY2sgdG9vIGxhcmdlAOD6HwAPAAAAikAQAH0AAAASAQAACQAAAIpAEAB9AAAAFAEAABgAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAACGAAAAJgAAAFPsFN832yXIIqwHEQap00wrTCRe0Vf5gBYKfgWPpWdhxyz97CXaOPcNmZPCUErMp+6bMrgUntG5cMd4s0FYFxE1lMxCPL1NzPf5wlx1BJoCwSMKlc3WKLCDFl9q32vM30lI6zz1ZfGccblydT5HjUI1/BFl7VJvvic5lf96AVLli9qozLiexvSwUd4LjJ+uhEyaqF8hLELkfkWDr4NtNVxJsJ6Qek4sL8tuSeoyCBh8ClGzLBKqEuoLWd7b1Oy8OaQXXY9KdSAtY5a+MN5C6+wZYvpGHRWK7hhLcgqleyytZJuS9QyOC2DNaGfT4eNQudyToUm5JHuWBbi5ANF+xgxyfspTfoQ6K9lFQ5fxtd+v4qn8OK0OOH7FbC6gMU1KgIYAFII7TEaZo+oYpJXtP/triAXRBZEN4LnG7yT5gwThxfzyH3GFS3NuukzTz7gowo3ResKkGSF32RXbngUX6YzR+J3J0aX9zlbhI4PhyUdxeztWDRc3PkYZQ+mHf4UcUuRUUd5VhI00tWSikrrobxk+8zAbkBhm1rxfZdRnyWs3lyhs0/3jKtl80eyBQMewdgAAAAAAAAAAAQAAALIHAADiXxAAawAAANUMAAAOAAAA4l8QAGsAAADPDAAADgAAAExheW91dEVycm9yALMHAAAsAAAABAAAALQHAAABAEHQ+/8AC48WlQcAADwAAAAEAAAAiwcAALUHAACNBwAAtgcAALcHAACPBwAAXgcAAF8HAABgBwAAuAcAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAALkHAAA0AAAABAAAALoHAAC7BwAAvAcAAJUHAAA8AAAABAAAAJAHAAC9BwAAkgcAAL4HAAC3BwAAlAcAAG8HAABwBwAAYAcAALgHAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAC/BwAANAAAAAQAAAC6BwAAuwcAAMAHAACwBwAAPAAAAAQAAABEBgAAwQcAAEYGAADCBwAAwwcAAEgGAAA3BgAAOAYAADkGAAC4BwAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAxAcAAAwAAAAEAAAAxQcAAMYHAADHBwAAmAcAADAAAAAEAAAAMAcAAMgHAAAyBwAAyQcAAMoHAAA0BwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAABsDAADLBwAAHQMAAMwHAADKBwAAHwMAAAACAAABAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABCAwAAzQcAAEQDAADOBwAAygcAAEYDAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAWAMAAM8HAABaAwAA0AcAAMoHAABcAwAAUQMAAFIDAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAFMDAADRBwAAVQMAANIHAADKBwAAVwMAAPkBAAD6AQAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABHAwAA0wcAAEkDAADUBwAAygcAAEsDAAAHAgAACAIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAJwMAANUHAAApAwAA1gcAAMoHAAArAwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAADUHAADXBwAANwcAANgHAADKBwAAOQcAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAA6BwAA2QcAADwHAADaBwAAygcAAD4HAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAIQcAANsHAAAjBwAA3AcAAMoHAAAlBwAAAAIAAAECAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAACYHAADdBwAAKAcAAN4HAADKBwAAKgcAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAABdAwAA3wcAAF8DAADgBwAAygcAAGEDAAD5AQAA+gEAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAKwcAAOEHAAAtBwAA4gcAAMoHAAAvBwAAAAIAAAECAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAEwDAADjBwAATgMAAOQHAADKBwAAUAMAAFEDAABSAwAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAAVAwAA5QcAABcDAADmBwAAygcAABoDAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAIgMAAOcHAAAkAwAA6AcAAMoHAAAmAwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAAC4DAADpBwAAMAMAAOoHAADKBwAAMgMAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAA9AwAA6wcAAD8DAADsBwAAygcAAEEDAAAHAgAACAIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAMwMAAO0HAAA1AwAA7gcAAMoHAAA3AwAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAJgHAAAwAAAABAAAADgDAADvBwAAOgMAAPAHAADKBwAAPAMAAAcCAAAIAgAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAB8XxAAZQAAAN0AAAAKAAAAfF8QAGUAAAAPAQAATgAAAJgHAAAwAAAABAAAAAIHAADxBwAABAcAAPIHAADKBwAABgcAANEBAADSAQAA0wEAALgHAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACYBwAAMAAAAAQAAAD7AQAA8wcAAP0BAAD0BwAAygcAAP8BAAAAAgAAAQIAANMBAAC4BwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmAcAADAAAAAEAAAAAgIAAPUHAAAEAgAA9gcAAMoHAAAGAgAABwIAAAgCAADTAQAAuAcAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAHxfEABlAAAAXQEAAAoAAACzBwAALAAAAAQAAAACAwAA9wcAAAQDAAD4BwAA+QcAAAcDAAAIAwAACQMAAAoDAAALAwAADAMAAA0DAAAOAwAADwMAABADAAARAwAAEgMAABMDAAAUAwAAfF8QAGUAAACbAQAACgAAAHxfEABlAAAApAEAAEEAAAAACAAAMAAAAAQAAAABCAAAAAgAADAAAAAEAAAAAggAAAAIAAAwAAAABAAAAAMIAAAACAAAMAAAAAQAAAAECAAAAAgAADAAAAAEAAAABQgAAAAIAAAwAAAABAAAAAYIAAAACAAAMAAAAAQAAAAHCAAAAAgAADAAAAAEAAAACAgAAAAIAAAwAAAABAAAAAkIAAAACAAAMAAAAAQAAAAKCAAAAAgAADAAAAAEAAAACwgAAAAIAAAwAAAABAAAAAwIAAAACAAAMAAAAAQAAAANCAAAAAgAADAAAAAEAAAADggAAFRydXN0ZWQgaXRlcmF0b3IgbGVuZ3RoIHdhcyBub3QgYWNjdXJhdGVseSByZXBvcnRlZACQCCAAMwAAABxPEABmAAAAMwAAAAUAAAAkEgYAQeiRgAELAyZMCgBB9JGAAQsDJSYKAEGAkoABCwMjCQIAQYySgAELuQFUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBQcmltaXRpdmVBcnJheSBvZiBsZW5ndGggAAAMCSAAJQAAADEJIAAhAAAAKAsQAHAAAADnAgAACQAAAIFBEAB0AAAA3AAAAB0AAACBQRAAdAAAAM4AAAAdAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgBB8JOAAQvVA2F0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAADwCSAAGQAAAPh4EABmAAAA6AEAAC8AAAD4eBAAZgAAAPgBAAAvAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAACGAAAAJgAAAO6bMrgUntG5cMd4s0FYFxFJSOs89WXxnHG5cnU+R41CtaHfx+CoTEOS/RHiY2P8o0yaqF8hLELkfkWDr4NtNVwfoU/E/CFBIdYixYjp17F4pBddj0p1IC1jlr4w3kLr7Bli+kYdFYruGEtyCqV7LK3ck6FJuSR7lgW4uQDRfsYMcn7KU36EOivZRUOX8bXfr43ResKkGSF32RXbngUX6YzR+J3J0aX9zlbhI4PhyUdxY5g4LpuomlawL1iOt1Hoh3s7Vg0XNz5GGUPph3+FHFKH/FZ7jfIxPLY3ukYvCXyWRm9ybWF0dGluZyBhcmd1bWVudCBvdXQgb2YgcmFuZ2WQCyAAIAAAANcyEAB4AAAA6wcAAAkAQdCXgAELwxYBAAAADwgAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgLyAAAADYCyAAFgAAAO4LIAADAAAAIF4gANgLIAAWAAAABAwgAAMAAABMYXlvdXRFcnJvcgCLWRAAZgAAAMMAAAA6AAAAAAgAADAAAAAEAAAAywEAABAIAADNAQAAEQgAABIIAADQAQAA0QEAANIBAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAAN4BAAAUCAAA4AEAABUIAAASCAAA4gEAAOMBAADkAQAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAAAJAgAAFggAAAsCAAAXCAAAEggAAA0CAAAAAgAAAQIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAADgIAABgIAAAQAgAAGQgAABIIAAASAgAABwIAAAgCAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAItZEABmAAAAdgEAACoAAACLWRAAZgAAAHoBAAAlAAAAi1kQAGYAAAB7AQAAJgAAAEludmFsaWQgZGVjaW1hbCBmb3JtYXQ6IMQNIAAYAAAAi1kQAGYAAAC0AQAAGAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAwAACIAQAAAAAAAAABAAAAAAAAAItZEABmAAAAuQEAABkAAABDYW5ub3QgcGFyc2UgZGVjaW1hbCBmb3JtYXQ6IAAAADQOIAAdAAAARGVjaW1hbDY0AAAAXA4gAAkAAABDYW5ub3QgY29udmVydCAgdG8gOiBPdmVyZmxvdwAAAHAOIAAPAAAAfw4gAAQAAACDDiAACgAAAERlY2ltYWwyNTYAAKgOIAAKAAAARGVjaW1hbDEyOAAAvA4gAAoAAABEZWNpbWFsMzIAAADQDiAACQAAAHAOIAAPAAAAfw4gAAQAAACLWRAAZgAAAD8CAAASAAAAi1kQAGYAAAA3AgAAPQAAAENhbm5vdCBjYXN0ICB0byBkZWNpbWFsABQPIAAMAAAAIA8gAAsAAABMQ2Fubm90IGNhc3Qgc3RyaW5nIHRvIGRlY2ltYWwgZ3JlYXRlciB0aGFuIG1heGltdW0gc2NhbGUgAAA9DyAAOQAAAENhbm5vdCBjYXN0IHN0cmluZyB0byBkZWNpbWFsIHdpdGggbmVnYXRpdmUgc2NhbGUgAACADyAAMgAAAAkmEgAACAAAMAAAAAQAAABdAwAAGggAAF8DAAAbCAAAEggAAGEDAAD5AQAA+gEAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAUwMAABwIAABVAwAAHQgAABIIAABXAwAA+QEAAPoBAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAACIDAAAeCAAAJAMAAB8IAAASCAAAJgMAAAcCAAAIAgAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAAAbAwAAIAgAAB0DAAAhCAAAEggAAB8DAAAAAgAAAQIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAJwMAACIIAAApAwAAIwgAABIIAAArAwAABwIAAAgCAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAAIAAAwAAAABAAAABUDAAAkCAAAFwMAACUIAAASCAAAGgMAAAACAAABAgAA0wEAABMIAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAACAAAMAAAAAQAAABMAwAAJggAAE4DAAAnCAAAEggAAFADAABRAwAAUgMAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAWAMAACgIAABaAwAAKQgAABIIAABcAwAAUQMAAFIDAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAENhbm5vdCBjYXN0IHRvIC4gVGhlIHNjYWxlICBjYXVzZXMgb3ZlcmZsb3cugBIgAA8AAACPEiAADAAAAJsSIAARAAAAdmFsdWUgb2YgIGlzIG91dCBvZiByYW5nZSAAAMQSIAAJAAAAzRIgABEAAAAACAAAMAAAAAQAAABHAwAAKggAAEkDAAArCAAAEggAAEsDAAAHAgAACAIAANMBAAATCAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAAAgAADAAAAAEAAAAQgMAACwIAABEAwAALQgAABIIAABGAwAAAAIAAAECAADTAQAAEwgAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAACRXEABpAAAAOAAAAAUAAABhdHRlbXB0IHRvIGRpdmlkZSBieSB6ZXJvAAAAsBMgABkAAAD4eBAAZgAAAOgBAAAvAAAA+HgQAGYAAAD4AQAALwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIZ/EABrAAAAJwEAAAUAAACGfxAAawAAAD8BAAAFAAAAhn8QAGsAAABXAQAABQAAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgKiAAAABUFCAAFgAAAGoUIAADAAAATnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAABAAAAAQAAADAIAAAAAAAABAAAAAQAAAAyCAAAVGltZXN0YW1wRGF0ZTMyRGF0ZTY0AAAAAAAAAAQAAAAEAAAAKgQAAFRpbWUzMlRpbWU2NER1cmF0aW9uAAAAAAQAAAAEAAAAzAQAAEludGVydmFsQmluYXJ5AAAAAAAABAAAAAQAAABtAwAARml4ZWRTaXplQmluYXJ5TGFyZ2VCaW5hcnlCaW5hcnlWaWV3VXRmOExhcmdlVXRmOFV0ZjhWaWV3AAAAAAAAAAQAAAAEAAAAMwgAAExpc3RMaXN0VmlldzQIAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AAA3CAAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAOggAAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAAA8CAAAAAAAAAQAAAAEAAAAEQUAAERlY2ltYWwzMkRlY2ltYWw2NERlY2ltYWwxMjhEZWNpbWFsMjU2AAAAAAAABAAAAAQAAAA9CAAATWFwUnVuRW5kRW5jb2RlZFNlY29uZE1pbGxpc2Vjb25kTWljcm9zZWNvbmROYW5vc2Vjb25kAADOdRAAagAAAL0BAAAdAAAAi1kQAGYAAADXAAAAJQAAAItZEABmAAAABQEAADAAAAAmTAoAQZyugAELQ0Nhbm5vdCBjYXN0IHN0cmluZyAnJyB0byB2YWx1ZSBvZiAgdHlwZQAcFyAAFAAAADAXIAAOAAAAPhcgAAUAAAAkEgYAQeiugAELAyUmCgBB9K6AAQsDIwkCAEGAr4ABCwIRAwBBjK+AAQsCEAEAQZivgAELARAAQaSvgAELAhECAEGwr4ABC44DT3ZlcmZsb3cgY29udmVydGluZyAgdG8gTmFub3NlY29uZC4gVGhlIGRhdGVzIHRoYXQgY2FuIGJlIHJlcHJlc2VudGVkIGFzIG5hbm9zZWNvbmRzIGhhdmUgdG8gYmUgYmV0d2VlbiAxNjc3LTA5LTIxVDAwOjEyOjQ0LjAgYW5kIDIyNjItMDQtMTFUMjM6NDc6MTYuODU0Nzc1ODA0ALAXIAAUAAAAxBcgAIsAAAACIHRvIAAAALAXIAAUAAAAYRggAAQAAAABdHRydHJ1dHJ1ZXl5ZXllc29uMWZmYWZhbGZhbHNmYWxzZW5ub29mb2ZmMENhbm5vdCBjYXN0IHZhbHVlICcnIHRvIHZhbHVlIG9mIEJvb2xlYW4gdHlwZQAAAKQYIAATAAAAtxggABoAAACVeBAAYgAAAMUBAAAgAAAAQ2Fubm90IGNvbnZlcnQgaW50ZXJ2YWwgY29udGFpbmluZyBub24temVybyBtb250aHMgb3IgZGF5cyB0byBkdXJhdGlvbgAAEwIAQciygAEL5QVDYW5ub3QgY2FzdCB0byAuIE92ZXJmbG93aW5nIG9uIEgZIAAPAAAAVxkgABEAAABBbGwgaTI1NiB2YWx1ZXMgZml0IGluIGY2NAAAlXgQAGIAAAA9BAAAJgAAAD4IAAAIAAAABAAAAHICAABzAgAAdAIAAD8IAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAACVeBAAYgAAANUGAAA6AAAAlXgQAGIAAABCCAAAOgAAAAYAAAALAAAACwAAAAoAAAC4FiAAvhYgAMkWIADUFiAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAVEoQAG8AAADOAQAANwAAAEl0ZXJhdG9yIG11c3QgYmUgc2l6ZWQAAE0KEABuAAAAuwEAACEAAABACAAA//////////8BAAAAAAAAANcyEAB4AAAA6wcAAAkAAACBQRAAdAAAAM4AAAAdAAAACEEQAHgAAABrAAAADgAAAAhBEAB4AAAAbQAAAB4AAAANQBAAfAAAAFIAAAAhAAAAQnl0ZSBzbGljZSBkb2VzIG5vdCBoYXZlIHRoZSBzYW1lIGxlbmd0aCBhcyBGaXhlZFNpemVCaW5hcnlCdWlsZGVyIHZhbHVlIGxlbmd0aHNJbnZhbGlkIGlucHV0IGxlbmd0aCBwYXNzZWQgdG8gRml4ZWRTaXplQmluYXJ5QnVpbGRlci4gRXhwZWN0ZWQgIGdvdCAAAABYGyAAQAAAAJgbIAAFAAAARiAQAGkAAAB7AAAAFwAAAEYgEABpAAAAfAAAAA0AAABvZmZzZXQgb3ZlcmZsb3cARiAQAGkAAACEAAAAHAAAAHVzaXplIG92ZXJmbG93AABGIBAAaQAAAIAAAAArAAAARiAQAGkAAACBAAAAEQAAAAhBEAB4AAAAWQEAABwAQbi4gAEL6QYBAAAAQQgAAEVycm9yAAAA4l8QAGsAAADVDAAADgAAAPrVMvFGvm3zOtSAFi94klinSAzwZ1+TofJnjflbc1/9DbjZhoHu4s4rVLzXaLmWADeBC8ux5MZO36L2DutuYRjiXxAAawAAAOgBAAAXAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpITEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5SUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxgXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5kYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYgAAAOUqEABlAAAACAEAABsAAAABAAAAAAAAAAIAQaq/gAELAQUAQbS/gAELESAAIOkuAAAAuB8gAAEAAAACAEHOv4ABCwEDAEHYv4ABCwUgAADpAgBB5r+AAQsBBgBB8L+AAQsFIAAA6QIAQf6/gAELAQkAQYjAgAEL6SQgAADpaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZRRfEABnAAAAKQIAACsAAABMb2NhbCB0aW1lIG91dCBvZiByYW5nZSBmb3IgYE5haXZlRGF0ZVRpbWVgAHuEEABiAAAAQwIAAA4AAAB3cml0aW5nIHJmYzMzMzkgZGF0ZXRpbWUgdG8gc3RyaW5nIHNob3VsZCBuZXZlciBmYWlse4QQAGIAAACnAgAADgAAAEIIAAA0AAAABAAAALoHAAC7BwAAwAcAAEMIAAA0AAAABAAAALoHAAC7BwAAvAcAAM51EABqAAAAvQEAAB0AAADseRAAawAAAEEDAAAVAAAA1zIQAHgAAADrBwAACQAAAE92ZXJmbG93IGhhcHBlbmVkIG9uOiAgKyAAAAAkISAAFgAAADohIAADAAAAICogACQhIAAWAAAAUCEgAAMAAABMb2NhbCB0aW1lIG91dCBvZiByYW5nZSBmb3IgYE5haXZlRGF0ZVRpbWVgAHuEEABiAAAAQwIAAA4AAABUShAAbwAAAM4BAAA3AAAAznUQAGoAAAC9AQAAHQAAAIVoEABfAAAAIQAAAAsAAABpbnZhbGlkIHRpbWVzdGFtcCBzZXBhcmF0b3IAhWgQAF8AAADdAAAAGgAAAHRpbWVzdGFtcCBtdXN0IGNvbnRhaW4gYXQgbGVhc3QgMTAgY2hhcmFjdGVyc0Vycm9yIHBhcnNpbmcgdGltZXN0YW1wIGZyb20gJyc6IAAAKSIgAB4AAABHIiAAAwAAAGVycm9yIHBhcnNpbmcgZGF0ZWVycm9yIGNvbXB1dGluZyB0aW1lem9uZSBvZmZzZXRlcnJvciBwYXJzaW5nIHRpbWVGYWlsZWQgdG8gcGFyc2UgJycgYXMgdGltZQAAAJ8iIAARAAAAsCIgAAkAAACFaBAAXwAAAFcCAAAbAAAAhWgQAF8AAABeAgAAHwAAAIVoEABfAAAAYAIAAB8AAABDYW5ub3QgY2FzdCAgdG8gSW50ZXJ2YWxZZWFyTW9udGguIE9ubHkgeWVhciBhbmQgbW9udGggZmllbGRzIGFyZSBhbGxvd2VkLgAA/CIgAAwAAAAIIyAAPgAAACB0byBJbnRlcnZhbERheVRpbWUgYmVjYXVzZSB0aGUgbmFub3MgcGFydCBpc24ndCBtdWx0aXBsZSBvZiBtaWxsaXNlY29uZHMAAAD8IiAADAAAAFgjIABJAAAAY2NlbnRjZW50c2NlbnR1cnljZW50dXJpZXNkZWNkZWNzZGVjYWRlZGVjYWRlc3l5cnlyc3llYXJ5ZWFyc21vbm1vbnNtb250aG1vbnRoc3d3ZWVrd2Vla3NkZGF5ZGF5c2hocmhyc2hvdXJob3Vyc21taW5taW5zbWludXRlbWludXRlc3NzZWNzZWNzc2Vjb25kc2Vjb25kc21zbXNlY21zZWNzbXNlY29uZG1zZWNvbmRzbWlsbGlzZWNvbmRtaWxsaXNlY29uZHN1c3VzZWN1c2Vjc3VzZWNvbmR1c2Vjb25kc21pY3Jvc2Vjb25kbWljcm9zZWNvbmRzbmFub3NlY29uZG5hbm9zZWNvbmRzVW5rbm93biBpbnRlcnZhbCB0eXBlOiDFJCAAFwAAAC0gZXhjZWVkcyB0aGUgcHJlY2lzaW9uIGF2YWlsYWJsZSBmb3IgaW50ZXJ2YWwgYW1vdW50AAAAAQAAAAAAAADlJCAANAAAAEZhaWxlZCB0byBwYXJzZSAgYXMgaW50ZXJ2YWwgYW1vdW50ACwlIAAQAAAAPCUgABMAAABVbmFibGUgdG8gcmVwcmVzZW50IGludGVydmFsIHdpdGggZGF5cyBhbmQgbmFub3MgYXMgeWVhci1tb250aHM6IAAAAGAlIABBAAAAVW5hYmxlIHRvIHJlcHJlc2VudCAgYXMgbWlsbGlzZWNvbmRzrCUgABQAAADAJSAAEAAAACBuYW5vcyBhcyBtaWxsaXNlY29uZHMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIAAACsJSAAFAAAAOAlIAAxAAAAIGNlbnR1cmllcyBhcyBtb250aHMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIArCUgABQAAAAkJiAALwAAACBkZWNhZGVzIGFzIG1vbnRocyBpbiBhIHNpZ25lZCAzMi1iaXQgaW50ZWdlcgAAAKwlIAAUAAAAZCYgAC0AAAAgeWVhcnMgYXMgbW9udGhzIGluIGEgc2lnbmVkIDMyLWJpdCBpbnRlZ2VyAKwlIAAUAAAApCYgACsAAAAgbW9udGhzIGluIGEgc2lnbmVkIDMyLWJpdCBpbnRlZ2VyAACsJSAAFAAAAOAmIAAiAAAAIHdlZWtzIGFzIGRheXMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXIAAACsJSAAFAAAABQnIAApAAAAIGRheXMgaW4gYSBzaWduZWQgMzItYml0IGludGVnZXKsJSAAFAAAAFAnIAAgAAAASW52YWxpZCBpbnB1dCBzeW50YXggZm9yIHR5cGUgaW50ZXJ2YWw6IC4gUmVwZWF0ZWQgdHlwZSAnJwAAgCcgACgAAACoJyAAEQAAALknIAABAAAAgCcgACgAAACFaBAAXwAAAM8FAAAUAAAAhWgQAF8AAADRBQAAFAAAAIVoEABfAAAA0wUAABQAAAAAAAAABAAAAAQAAABFCAAAAAAAAAQAAAAEAAAASAgAAEludGVydmFsbmFub3MAAADILBAAYAAAAIgGAAApAAAATWF4aW11bSBvZmZzZXQgb2YgIGlzIGxhcmdlciB0aGFuIHZhbHVlcyBvZiBsZW5ndGggAEwoIAASAAAAXiggACEAAABPZmZzZXQgb2YgIGV4Y2VlZHMgbGVuZ3RoIG9mIHZhbHVlcyCQKCAACgAAAJooIAAaAAAAU3BsaXQgVVRGLTggY29kZXBvaW50IGF0IG9mZnNldCDEKCAAIAAAAEVuY291bnRlcmVkIG5vbiBVVEYtOCBkYXRhOiDsKCAAHAAAACZwcmVjaXNpb24gY2Fubm90IGJlIDAsIGhhcyB0byBiZSBiZXR3ZWVuIFsxLCBdABEpIAAtAAAAPikgAAEAAABzY2FsZSAgaXMgZ3JlYXRlciB0aGFuIHByZWNpc2lvbiAAAABQKSAABgAAAFYpIAAbAAAAIGlzIGdyZWF0ZXIgdGhhbiBtYXggAAAAUCkgAAYAAACEKSAAFQAAAHByZWNpc2lvbiAAAKwpIAAKAAAAhCkgABUAAAASCUwAAAAAAAEAAAAAAAAACgAAAAAAAABkAAAAAAAAAOgDAAAAAAAAECcAAAAAAACghgEAAAAAAEBCDwAAAAAAgJaYAAAAAAAA4fUFAAAAAADKmjsAAAAAAOQLVAIAAAAA6HZIFwAAAAAQpdToAAAAAKByThgJAAAAQHoQ81oAAACAxqR+jQMAAADBb/KGIwAAAIpdeEVjAQAAZKeztuANAADoiQQjx4obWRAAbwAAAD8AAAAFAAAARxIQAGYAAADIAQAADQAAAEcSEABmAAAAvgEAAA0AAABHEhAAZgAAAL8BAAANAAAARxIQAGYAAADCAQAAEQAAAEcSEABmAAAA6gEAABEAAABHEhAAZgAAAOQBAAARAAAARxIQAGYAAADlAQAAEQAAAEcSEABmAAAA8gEAAAUAAABHEhAAZgAAAOgAAAA7AAAARxIQAGYAAADwAAAAMgAAAEcSEABmAAAA7gAAADAAAABHEhAAZgAAAIcAAAAyAAAAHWgQAGcAAAAkAwAAMAAAALVpEABoAAAA3QAAABYAAABOYU5pbmZpbmZpbml0eVVuYWJsZSB0byBkb3duY2FzdCB0byBsaXN0IGFycmF5AAA6GRAAXwAAAKcCAAAKAAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAUQgAAFIIAABSCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAUwgAAFQIAABUCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAAVQgAAFYIAABWCAAAAAAAAAQAAAAEAAAAVwgAAFgIAABYCAAAAAAAAAQAAAAEAAAAWQgAAFoIAABaCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAXQgAAF4IAABeCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAXwgAAGAIAABgCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAYQgAAGIIAABiCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAYwgAAGQIAABkCAAAAAAAAAQAAAAEAAAAZQgAAGYIAABmCAAAAAAAAAQAAAAEAAAASwgAAEwIAABMCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAZwgAAGgIAABoCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAaQgAAGoIAABqCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAATwgAAFAIAABQCAAAAAAAAAQAAAAEAAAAawgAAGwIAABsCAAAAAAAAAQAAAAEAAAATQgAAE4IAABOCAAAAAAAAAQAAAAEAAAASQgAAEoIAABKCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAWwgAAFwIAABcCAAAAAAAAAQAAAAEAAAAbQgAAG4IAABuCAAAbwgAADQAAAAEAAAAcAgAAHEIAAA4AAAABAAAAHIIAABxCAAAOAAAAAQAAABzCAAAZGljdGlvbmFyeSBhcnJheToZEABfAAAAwgMAACIAAABzdHJpbmcgYXJyYXk6GRAAXwAAAFoDAAAdAAAAgUEQAHQAAADOAAAAHQAAAIk/EACDAAAABwIAABYAAACJPxAAgwAAAAgCAAAYAAAAiT8QAIMAAAAKAgAADAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAAEkAAAAFAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2Rl0AYQAGsAAADQAQAAEgAAAHuyPBybtYf8gZvSY1u1me7/7Fp1xS4YcQF6eKTCW9WL4//WmAXKflpr1eEeiUAqJNcyEAB4AAAA6wcAAAkAQfzkgAEL8AoBAAAAdAgAAAAAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEYTGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAHEIAAA4AAAABAAAAPgEAAB1CAAA+gQAAHYIAAB3CAAA/AQAAP0EAAD+BAAA7QQAAHgIAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABxCAAAOAAAAAQAAADlBAAAeQgAAOcEAAB6CAAAdwgAAOoEAADrBAAA7AQAAO0EAAB4CAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAbwgAADQAAAAEAAAAnAQAAHsIAACeBAAAfAgAAH0IAAChBAAAfggAAH8IAACkBAAAeAgAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAIAIAAAIAAAABAAAAHICAABzAgAAdAIAAIEIAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABDYW5ub3QgY2FzdCB0byBGaXhlZFNpemVMaXN0KCk6IHZhbHVlIGF0IGluZGV4ICBoYXMgbGVuZ3RoIABENCAAHQAAAGE0IAASAAAAczQgAAwAAAA2FxAAYwAAAHMAAAAgAAAATGFyZ2VMaXN0IHRvbyBsYXJnZSB0byBjYXN0IHRvIExpc3QAXg4QAGEAAACHAwAAGQAAAF4OEABhAAAAswMAABMAAABeDhAAYQAAALQDAAAVAAAAikAQAH0AAACBAQAAGwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSA8IHUzMjo6TUFYIGFzIHVzaXplAACKQBAAfQAAALAAAAAJAAAAikAQAH0AAABTAQAAPQAAAIpAEAB9AAAAUwEAACcAAACKQBAAfQAAAGUBAAAeAAAAikAQAH0AAABoAQAAGgAAAIpAEAB9AAAAcAEAABsAAACKQBAAfQAAADsBAAAfAAAAQmxvY2sgdG9vIGxhcmdlALA1IAAPAAAAikAQAH0AAAASAQAACQAAAIpAEAB9AAAAFAEAABgAAACKQBAAfQAAAMUAAAAbAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIJVEABoAAAAhgAAACYAAABuBRAAcAAAAKEDAAANAAAALRcb/xzXoRMXdqDvPS1of8CQjP/nMQE//rncP3cBe5GnB8QWnWvAAmludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGUbWRAAbwAAABYAAAAOAAAAAAAAAAEAAAAAAAAABQAAAAAAAAAZAAAAAAAAAH0AAAAAAAAAcQIAAAAAAAA1DAAAAAAAAAk9AAAAAAAALTEBAAAAAADh9QUAAAAAAGXNHQAAAAAA+QKVAAAAAADdDukCAAAAAFFKjQ4AAAAAlXPCSAAAAADpQcxrAQAAAI1J/RoHAAAAwW/yhiMAAADFLryisQAAANnprC14AwAAPZFg5FgRAAAx1uJ1vFYAAPUubk2usQEAyeomg2d4CADtlcKPBVoqAKHtzM4bwtMAJaQACovKIgS5NAMyt/StFJ0HEPqTx2VnAACAPwAAIEEAAMhCAAB6RABAHEYAUMNHACR0SYCWGEsgvL5MKGtuTvkCFVAAQYbwgAELsgHwPwAAAAAAACRAAAAAAAAAWUAAAAAAAECPQAAAAAAAiMNAAAAAAABq+EAAAAAAgIQuQQAAAADQEmNBAAAAAITXl0EAAAAAZc3NQQAAACBfoAJCAAAA6HZIN0IAAACilBptQgAAQOWcMKJCAACQHsS81kIAADQm9WsMQwCA4Dd5w0FDAKDYhVc0dkMAyE5nbcGrQwA9kWDkWOFDQIy1eB2vFURQ7+LW5BpLRJLVTQbP8IBEAEGA8oABC/kBAQAAAAAAAAAKAAAAAAAAAGQAAAAAAAAA6AMAAAAAAAAQJwAAAAAAAKCGAQAAAAAAQEIPAAAAAACAlpgAAAAAAADh9QUAAAAAAMqaOwAAAAAA5AtUAgAAAADodkgXAAAAABCl1OgAAAAAoHJOGAkAAABAehDzWgAAAIDGpH6NAwAAAMFv8oYjAAAAil14RWMBAABkp7O24A0AAOiJBCPHitcyEAB4AAAA6wcAAAkAAAAalRAAVgAAAMYBAAA+AAAAGpUQAFYAAADRAQAAOQAAABqVEABWAAAA3wEAAD4AAAAalRAAVgAAAOoBAAA5AAAAAQAAAAAAAAACAEGC9IABCwECAEGM9IABC8UBIAAA6V4OEABhAAAA0gMAABIAAAA6IAAAAQAAAAAAAAAgOiAAAgAAACwgAAA0OiAAAgAAACA6IAACAAAAXg4QAGEAAAD6AwAAEwAAAF4OEABhAAAA+wMAABUAAAAgOiAAAgAAADQ6IAACAAAAXg4QAGEAAAAhBAAAEAAAAF4OEABhAAAAGgQAABIAAABeDhAAYQAAACwEAAAgAAAAXg4QAGEAAAAsBAAANwAAAHs9AAC4OiAAAQAAALk6IAABAAAAAAAAAAEAQaD2gAELpQEIDRAAawAAAHcAAAAvAAAATGFyZ2UAAAAwOyAABQAAAFN0cmluZwAAQDsgAAYAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBBcnJheSwgZXhwZWN0ZWQgIGdvdCAAAABQOyAAJAAAAAEAAAAAAAAAdDsgABAAAACEOyAABQAAAAEAAAAAAAAAQmluYXJ5AAC0OyAABgAAABQAQdD3gAELARYAQdz3gAELJpXGSEtF/rhGs2cet9Q4ijKGCAAADAAAAAQAAACHCAAAiAgAAMcHAEGM+IABC/kJAQAAAIkIAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAACKCAAAFAAAAAQAAACLCAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUVycm9y4l8QAGsAAADVDAAADgAAAOJfEABrAAAAzwwAAA4AAAAAAAAABAAAAAQAAABKAgAATm90WWV0SW1wbGVtZW50ZWQAAAAAAAAABAAAAAQAAAAyAAAARXh0ZXJuYWxFcnJvckNhc3RFcnJvck1lbW9yeUVycm9yUGFyc2VFcnJvclNjaGVtYUVycm9yQ29tcHV0ZUVycm9yRGl2aWRlQnlaZXJvQXJpdGhtZXRpY092ZXJmbG93Q3N2RXJyb3JKc29uRXJyb3IAAACGCAAADAAAAAQAAACMCAAAAAAAAAQAAAAEAAAA9QAAAElvRXJyb3JJcGNFcnJvckludmFsaWRBcmd1bWVudEVycm9yUGFycXVldEVycm9yQ0RhdGFJbnRlcmZhY2VEaWN0aW9uYXJ5S2V5T3ZlcmZsb3dFcnJvclJ1bkVuZEluZGV4T3ZlcmZsb3dFcnJvcgAAAAAABAAAAAQAAAAxAAAAT2Zmc2V0T3ZlcmZsb3dFcnJvcgAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSExKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGLlKhAAZQAAAAgBAAAbAAAAAgBBjoKBAQsBBQBBmIKBAQsRIAAg6S4AAAAcQSAAAQAAAAIAQbKCgQELAQMAQbyCgQELBSAAAOkCAEHKgoEBCwEGAEHUgoEBCwUgAADpAgBB4oKBAQsBCQBB7IKBAQvNESAAAOlpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlFF8QAGcAAADkAAAAHQAAABRfEABnAAAA5wAAAB0AAABKYW51YXJ5RmVicnVhcnlNYXJjaEFwcmlsTWF5SnVuZUp1bHlBdWd1c3RTZXB0ZW1iZXJPY3RvYmVyTm92ZW1iZXJEZWNlbWJlcgAAuEEgAAcAAAC/QSAACAAAAMdBIAAFAAAAzEEgAAUAAADRQSAAAwAAANRBIAAEAAAA2EEgAAQAAADcQSAABgAAAOJBIAAJAAAA60EgAAcAAADyQSAACAAAAPpBIAAIAAAASmFuRmViTWFyQXBySnVuSnVsQXVnU2VwT2N0Tm92RGVjAAAAZEIgAAMAAABnQiAAAwAAAGpCIAADAAAAbUIgAAMAAADRQSAAAwAAAHBCIAADAAAAc0IgAAMAAAB2QiAAAwAAAHlCIAADAAAAfEIgAAMAAAB/QiAAAwAAAIJCIAADAAAAU3VuZGF5TW9uZGF5VHVlc2RheVdlZG5lc2RheVRodXJzZGF5RnJpZGF5U2F0dXJkYXkAAOhCIAAGAAAA7kIgAAYAAAD0QiAABwAAAPtCIAAJAAAABEMgAAgAAAAMQyAABgAAABJDIAAIAAAAU3VuTW9uVHVlV2VkVGh1RnJpU2F0AAAAVEMgAAMAAABXQyAAAwAAAFpDIAADAAAAXUMgAAMAAABgQyAAAwAAAGNDIAADAAAAZkMgAAMAAABBTVBNjQgAAGQAAAAEAAAAjggAAM51EABqAAAAvQEAAB0AAABtYXAgaXMgbWlzc2luZyBrZXkgZmllbGRtYXAgaXMgbWlzc2luZyB2YWx1ZSBmaWVsZAAAjwgAAAgAAAAEAAAAcgIAAHMCAAB0AgAAkAgAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAI0IAABkAAAABAAAALIEAACRCAAAtAQAAJIIAACTCAAAtwQAALgEAAC5BAAAugQAAJQIAAC7BAAAvAQAAL0EAAC+BAAAvwQAAMAEAADBBAAAwgQAAMMEAABJbnRlcm5hbCBFcnJvcjogdG9fZGF0YV90eXBlIGlzIG5vdCBhIG1hcCB0eXBlLkZvcm1hdCBlcnJvcgBeDhAAYQAAADYBAABLAAAAXg4QAGEAAABAAQAASQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHVuc3VwcG9ydGVkIGRpY3Rpb25hcnkga2V5IHR5cGU6IAAIRSAASwAAAF4OEABhAAAAOQEAACcAAABeDhAAYQAAADsBAAASAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgcnVuIGVuZCBpbmRleCB0eXBlOiAAAHxFIABKAAAAXg4QAGEAAABGAQAAKgAAAF4OEABhAAAASAEAABIAAABmb3JtYXR0aW5nICBpcyBub3QgeWV0IHN1cHBvcnRlZPBFIAALAAAA+0UgABUAAACVCAAAHAAAAAQAAACWCAAAAAAAAAwAAAAEAAAAlwgAAAAAAAAMAAAABAAAAJgIAAAAAAAADAAAAAQAAACZCAAAAAAAABAAAAAEAAAAmggAAJsIAAAUAAAABAAAAJwIAAAAAAAADAAAAAQAAACdCAAAAAAAABQAAAAEAAAAnggAAJsIAAAUAAAABAAAAJ8IAAAAAAAADAAAAAQAAACgCAAAmwgAABQAAAAEAAAAoQgAAAAAAAAQAAAABAAAAKIIAACbCAAAFAAAAAQAAACjCAAAAAAAAAwAAAAEAAAApAgAAAAAAAAMAAAABAAAAKUIAAAAAAAAHAAAAAQAAACmCAAAAAAAAAwAAAAEAAAApwgAAAAAAAAMAAAABAAAAKgIAAAAAAAAFAAAAAQAAACpCAAAmwgAABQAAAAEAAAAqggAAJsIAAAUAAAABAAAAKsIAAAAAAAADAAAAAQAAACsCAAAAAAAABwAAAAEAAAArQgAAAAAAAAQAAAABAAAAK4IAAAAAAAADAAAAAQAAACvCAAAAAAAAAwAAAAEAAAAsAgAAAAAAAAMAAAABAAAALEIAAAAAAAAEAAAAAQAAACyCAAAmwgAABQAAAAEAAAAswgAAAAAAAAMAAAABAAAALQIAAAAAAAAHAAAAAQAAAC1CAAAAAAAABAAAAAEAAAAtggAALcIAAAYAAAABAAAALgIAAAAAAAADAAAAAQAAAC5CAAAuggAABgAAAAEAAAAuwgAAJsIAAAUAAAABAAAALwIAAAAAAAAFAAAAAQAAAC9CAAAAAAAAAwAAAAEAAAAvggAAJsIAAAUAAAABAAAAL8IAAAAAAAADAAAAAQAAADACAAAmwgAABQAAAAEAAAAwQgAAAAAAAAUAAAABAAAAMIIAADDCAAAHAAAAAQAAADECAAAmwgAABQAAAAEAAAAxQgAAAAAAAAQAAAABAAAAMYIAAAAAAAADAAAAAQAAADHCAAAAAAAABQAAAAEAAAAyAgAAAAAAAAMAAAABAAAAMkIAAAAAAAAFAAAAAQAAADKCAAAAAAAABQAAAAEAAAAywgAAJsIAAAUAAAABAAAAMwIAAAAAAAAEAAAAAQAAADNCAAAAAAAAAwAAAAEAAAAzggAAAAAAAAMAAAABAAAAM8IAACbCAAAFAAAAAQAAADQCAAAAAAAABAAAAAEAAAA0QgAAAAAAAAcAAAABAAAANIIAAAAAAAADAAAAAQAAADTCAAAIGhvdXJzAAABAAAAAAAAAAEAAAAAAAAAwEkgAAYAAAAgIG1pbnMAAAEAAAAAAAAAAQAAAAAAAADhSSAABQAAAC0gc2VjcwAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAHEEgAAEAAAABSiAABQAAAAIAAAAAAAAAAgBBxJSBAQs1IAAA4AIAAAAAAAAAAgAAAAAAAAABAAAAIAAA4AIAAAAAAAAAAgAAAAAAAAACAAAAIAAA4AIAQYKVgQELFwkAAAAAAAMAAAAgAADpAgAAAAAAAAACAEGklYEBCzUgAADgAgAAAAAAAAACAAAAAAAAAAEAAAAgAADgAgAAAAAAAAACAAAAAAAAAAIAAAAgAADgAgBB4pWBAQsPAwAAAAAAAwAAACAAAOkCAEH6lYEBCwECAEGEloEBC9QtIAAA6SwgAAAISyAAAgAAAE5vbmUAAAAABAAAAAQAAABDBQAAU29tZZFzEABzAAAAjQAAABkAAADADhAAegAAAB8AAAAmAAAAwA4QAHoAAABUAAAACQAAANRyEABcAAAAigAAAAkAAACRcxAAcwAAADgAAAAmAAAAkXMQAHMAAABeAAAALgAAAJFzEABzAAAAYQAAAA0AAACRcxAAcwAAAGUAAAA4AAAAkXMQAHMAAAA9AAAAJwAAAECDEABwAAAAlgAAAA0AAABAgxAAcAAAAJgAAABAAAAAQIMQAHAAAACXAAAADQAAAECDEABwAAAAmgAAAA0AAABAgxAAcAAAAJ4AAAANAAAAQIMQAHAAAACfAAAADQAAAECDEABwAAAAhwAAACUAAABAgxAAcAAAAIgAAAArAAAAQIMQAHAAAABAAAAAGwAAAECDEABwAAAAQgAAACAAAADKHRAAaAAAAGsEAAAXAAAAAAAAAFrWO5LWU/TuPzuhBimqPxH4ZWUbZrRYlQfFJKRZysdKdr8+on/hrrpJ9i0N8Lx5XVNvzorfmVrp3HN5ECws2PSUBcG2K6DYkWnoS4qbGwd5+UZxpDbITraE4t5sguJIl7eYjU1EeuLjJZsWCCMbG/1yf3iwaoxtjvcgDuX18DD+T5+WXIXvCLI1qVFeMy29vSNHvLNmK4veghPmNYB4LK12rFUwIPsWizHMryFQyztMkxdrPOi53K09vxsqJL5K33jdhUti6FPZDa+iNK1tHddrqjNvPXHUh2it5UCMZHKGBpUAy4yNyanCGB9Rr/0OaEi6wP3v8DvU8t5mJRu9EgJtdJj+lXalhFdLYPcwtksBiJE+fjvUzqUtXjg1vaOeQeo1zl1KiULPuXWGgqxMBlKy4aB6zpWJgZMJlNHr70NzHxpJGUL766H4C/nF5usUEKZgm58S+mbK9k53d+AmGtTQOIJHl7gA/bQiVZWYsCCJgmOxjF5zIJ6wNVVdX260VWK83S82kKjFHYOqNPeJIet7K9W7Q7QS9+Qj1QF17OmlLTtlVaqwa5puNiUhyTOyR/iJvurUnAbBCoRuabvAnpl2LG4lCkRI8Q0lykPqcAbAyttkV4YqzZYoV15qkgYEOLwSPu0ndYC88uz1BDcIBcZrl43ocZKg6y5oM8ZESob3o35YMYdbRJMdIeD7au6zekyerv1ochW4ZCnYugXqYFnfRRo9A88a5r0zjimHJLlvq2swBmLB0I9W4Ph51LbTpZaGvIe68cSzbBh3mImkSI88qKspKS624IfelP6rzRozJUkLutnccYwUCx1/i8Dwn28bjigQVI6v2U3kXq7w7AdKorEyFOlx21BhnfbZLOjJbgWvn6wxJ4nSXCI6CBwxvsrGmscX/nCrBvSqSApjvW19eIG5nT1N1gix1drMuywJTuvwk4JG8IWljsUIYPW7JSEm7TgjWGynTvL2CrjyKq+qbygHLG5H0eGutA1mr/UaykV5hNukzIJN7ZDIn43ZUDyXl2USzn+joCi1ugfxD+UMff3+lsFfzMhyYqlJ7VMeT9y8vvyxd/96D7sTnOjoJbEJNvc9z6qfrOlUjGGRsXcdjAN1DYOVxxckau+59Z3VJW9E0tDjevkdrURrKHMFS3fFaoNizuybMuwKQ/ln407VdkUk+wHowj+nzZP3QZwiitRW7XkCovMPEcF4dVJDa9ZEVjSMQUWYqap4a4kTCoMM1mtB75FWvlPVVsZrmMwjj8vGEWs27O2oiuy3hr6/LDk/HOsCorOUqdbzMhTX93sHT+Olg4rguVPMsD/ZzPXaySJcjyStWOho/5yPD0Cz0b6Vmdk2bDeRoR/CuQkIECMt+/+PREeFtYqnMigMCtSr+fn/sxWZ5uJsUT8yjwzJFjv8f5CtH9CN45Jnf9mnPa5K+5/0mCdEsZx3Qd/PEc2ZHfrHMX8xld2D1RHXQ1ZAQFL8HH/vPn2KciVrZuo1KEhmO+Req44crc/uBQBlQzLaQEqdNlayY9iCagdAPtS+kGhOIuJ1Tz6HkaIE6KZEd1oC4qpaU+MNqTbLBaLQFRVxg5pVMShcUdMDPofKRFtaDZGA1R6Z2RKEwoaU/gp5WOi24Ipm/48XpXKoOb5Nl25i45gtQP9zXc6PEsgtIT0K+45/HIh/aPqAmQudvDRm5nxynyNqnwI5oYBOxOvB/x8cToesREdDh8kgYrVmsv8noyKp1xUZFOn7qLpiAJ//8Uu1yaatj6xxnam0PWDDP3dvInwQmbMXzsTTIU04tA9VyyubVH+gnQH2SGpgRqFTKn774JRPhALBmW1C/MtEdNouORl6YyVDMcAIU/v+VRGR+oifWLzukz3wyie6fqtVNXm1Y7c1dXwmlt5YNC+LVcFLojwlg5IbsLsWbwH77aqxnsuL7iN3Ipzq3MrBeakVXkZfF3V2ipWhkskeGeyJzfoLNl0SFO36Sbd7Zh9n7ID5zoT0FlmoeRzlGkDngCfht4LSWK43CcwxjxCIkLC47LLRB++ZhQs//rIVqrTc5qcfhslqAGfOzr3fmtThk+CRp2e9QmAAQaHWi+AkbVwsu8jgbVN4QJFJzK4Ybohz9+n6WEholpD1W3/anolqUHWkOa8tAV56eZmPiAOWQlLJBoRteIH12Nd/s6qDO9OmewjlyNbhMs/NX2DVZAqIkJpKHvsmzX+h4DtchX8GVZqg7vJcb8DfydhKs6YeSOrASKov9IuwV/yOHWDQJtok8dqUO/FXzrZdeRI8glgIt9YIPcV27YEktRcXy6JuymQMS4x2VGiibaLd3H3LCf19z10vlKkCCwkLFVRd/kx8XUM1O/nT4ablJo1U+p6vbRpKAcV7xJoQn3Cw6bjGGwmhnEG2mjXA1MaMHCRn+GJLyQPSYwHD+ET815F2QJsdz11CY97geTZW+002lBDC5EL1EvwVWZjEK3rhQ7mU8p2Tshd7W28+WlvsbMrznJdCnM/uLJkFpzFyJwi9MIS9U4ODKnj/xlC9TjFK7Dzl7ChkJDVWv/ikNtFerhNGD5SZvjbhlXcbh4SF9pmYFxO5P26EWXtV4ijlJnTAft1X58+J5S/a6hozT5hIOG/qlpAhdu9dyNLwP2O+WgYLpby0qVNrdXoH7Q/7bfHHTc7r4ZQoxhJZSejTveT2nPBgM41c2bur1y1xZOydNMQsOYCws8+qlk15jb1nxUH1d0eg3KCDVfyg1/DsYBtJ+aos5IlEcrWdxIYW9Dlim7fVN12s1c4ixXUoHDHHOoIly4V014uCazaTMmN9vGRx957TqIaXMQMCnP9druu9TbWGCFOo/P2DAoN/9dlmLaFiqMpn0nv9JMNj33LQYLykPanegINtHvdZnstHQnjrDY1TFmGkCOZ08IW+2VJWZlFw6Ft5zYsfkmwnLpBn9t8yRnHZa4C2U9uj2By6APOXv5fNz4agpCjSzA6k6IDwfa/9wIOoyM2yBoASzSJhbF0bPbGk0vqBXwggV4BreWMaMcbupsOcsDsFdDYw48v8YL13qpD0w5yKBhFE/Nu+O7msFdW08fRELUgVVfuS7sXziy0FEReZShxNLRXdG3W28O54RtVcv11joHha1GLS5KwqF5gKNO80fMgWcYn7hg6seg6fhoCVoE09ruY1XdQSVxnSRqjgugmhzFlgg3SJ16yfhljSmOlLyT9wOKTRKwbMI1R3g/+Rz90nRqMGY3sIvywpVWR/tkLVsRdMyDsayu53c2o9H+STSp4dX7rKID71KohihpOOnO6Ccnu0flSNsjUq+2c4skOqI0+aYZ7pMR/D9PmBxt7UlOziAPoFZH7z+Tg8ETyLBN3TjUC8g95ecDhHixULrkXUSLFQqySWdowGGe7ajdlXCZvdJNatO8kXpM/UqPiH1uWACtelTOW8HY0DCtP2qUwfIc1Mz59eK2VwhMyHdNQfZ2kAIMNHdjs/xtLf1MiEc+BBAPTZ7CkJz3fHFwr7pZBYUgBxEGj0zMJVuZ3Mec+07mZAjRSCcb+Z1ZPiH6yBMFVASNhM8cYvAMs42ycXonxqUFoOoK24O8D9BtLxnMocheTwEQjZpkowvYhGLkT9Y6YdbRZKj5AuPnYV7JxKnv6HMgROjlmaus3TGidE3cX9KT+F4fHvQCjBiOEwlVT3fPSO5lnuK9G5ePWMPt2Ums5YGTD4dLuC59YyMI4UOsEBrx88NlJq46GMP7yxmYjxwZony8PmRNzlt6cVD2D1lrnA+F46EKsp3qUR2xK4srzn8Lb2SNQVdFYP1pEXZt/rIa1kNFtJGxGVySW7zp9rkzTsvgDZDbHK+zvvacKHRrhCp+5AT1FdPfoKawSzKVjmElEqEaOltAzc5sLiDxr3j6tyuuqF5/BHk6Bz25Pg9LNWD2llZyHtWbiIUNK4GPLgLFPDPsFpaDBzVXKDc0+XjPsTOscYQkEez+pOZFAjva/6mAj5npLR5YOlYn0kbKzbOb9Kt0b3Rd9yp13OlsNLiYO3jjKMuotrTxH1gXy0nqtkZTI/L6luBqJVcqKbYYbWvf7+DntTCsiFdYdFAf0ThjZfX+ksdAa951LplkH8mKcEN7cjOBFILKCno/xRO3/RxQSlLIYVWvfESOY9E4Xvgvsi59tzTZia9dpfDVhmq6O66+DS0GA+wbPRtxDuP5bMqCaZBwX5jTEfxuWU6c+7/1Jwf0lGd/H905sP/fFh1Z8zpu/ti+q2/siCU3xuusrHwI9r6S6lZP57Y2gbCmm9+bBzxqN6zv09LT4hUaZhFpxOCFymDKG+BriNaeUP+hvDYgrzz09Jbkgm8cPek/ji8/rM78Oj24lat3Y6a1zbbZgc4HVaRimW+GUUCYYzUom+I1gT8Zezu/Z/WYtnwKYr7iwuWO19oGp07xe3QDhI25TcHFe0TqTCqOvd5FBGGhK6E+RsYWJN85JmFR7l16CW6BcdyPm6ILB3YM0y74YkXpEuEh3cdBTOCriA/6qorbW1ulYkE5KZgQ3mYL/VEhkj42ls7Zf2/+EQj5yXxavv9Y3BY/Qe+j+NyrOD/baWa3OxsnyxpviPML2g5LxkfEbQ3d7bXdD2s3ys5A72vg0sooprqTpCevDNa52Ssy4Rt0qtxlPJ0phswYZEd2B61WSd2Leoewe/x3Hoi0p8bAVfYodySa1k1xxHES1dm8fG9jqpz5vYPQ3kmNV5NIJ5eLSJ08PCTo0QHf9Ky2DxS8sQNoS6OVFYKnLfzv647R7+lEOlKIhl7rROl8I+J6mmPXqUzjLq/iliIj1zh7gpiGbMHIFfUj9afTUGCKgmNCqA/2Oh9ybPsNzCB8pSMME0YP+8ybXwAt2Ts4n8Z3zxQTg/LPzirEPUeCCsu8DtNimDp5udDUyqhEuUS9UxqYTzY5ECxRHf1GVeeZ4KfdNl8Lw1Q/bVFkr/tRdGTS6kPxaWAeqZRU6Ov9HOS1A5jc+b+4FkwNbhcS+Gwl7kiHDDgnqiffBMWk67J3N2XVUmupGMhU6Wb/gQ1fgHajrqryi27ybiu4s2VQr3iQSJ5duyo6uw2uouhOrMdKxFK2/JT0ZrrsiSnZISAMmLCzvLu+MXBtp6t0Q3F0C7bs4JvarcnYeQWeUVBR0QagpCzLbqqcJU+lePLSMSSoJGqZ9kZVTz6fgts/mrltwimJNHvX4pcCR3+d/3VryTK354WTbvGcZ26vuLWrZVPNtO61cDa6B3FOX6rvEjawuSIubtxIWIlVmeudrt7EWONqtf6ZtTdf33ArSIFLTrGALL2xGBqNL8tQPhqhmhJp/CvVLWolIHfKNEmdVfSfBGM23nS6WThC3myn+F2y1WDECkcG+OuOW4n73fplK5aw9QzUzLsiYfpwetl9Cnp0YTpAAgfi94c8gkzF6CyCgMjGYA1I47VpD6LX/2ovoyDy+AAIlyyms0efketMu5/9I6oEArT7yGgde3JqH+qL+HScgQ9uI29LDmMrgkn8nX9C19ytkNQzFdoD/m7ca7DXJ5HD1QkZR9dIjPX6n4KpHOl2NMpHV8zki14dtpm7oa4T6+r4bJGwKbItpSRMJoYZnOrVvo+6LCQauQZ9Xyw7k/Qply4vqlGQlrumDFlxrUZ8mfh83cD2DLBem4tr0gycG7h+kAVBM4PkcjZyTtaDuyqukjASkL44YMdsA2lCFlrwpytqD5zpuoj5NwRLlpPluNDuQI+MLCknO4jJXnBA6yMBIdC7a5uTtI83e9kMJIb14r8saxKKhKGvDV7LTzGgs2tq44HjJS3SBsCyjisOGNw2PaxiVfU4qUIwdZjQ6tOFp+SJxXN+iseexIr7BR2MbwnVqDLUQiGJgnG9vcZY74bEUx5PhrFQ+/+PAIiv9YG2TLno4bxdrS7jYti6w/LyI9fkZy4neRh6qE+K3XD7tqzB3YDlvqupTqUrvMhum0wp8SR+mYpek5pSfqf6gkYrNH15gjPw5kiI6x5J/SrTqgGQ1/7I6JPhX57u6jg6wkBDBoz1MZK45at6rqjKTXLQU8QsOoX7YxMWVVJbDNTXkGyxL0kjcRvz5fVReOgNAL5L6L2Lvi1m4OtyqdsaDEDp2urs5qW4sK0mR1BN7IdVJEWlqCRfIujQa+koUV+xJn1fDw4tbuPRjEtntz7ZxrYIWW1k1GVUwedaRa0CjEhrgmPEzhl6rfZZJNcQQz9ahmMEuf2T3Vq3970MbiP5kpQP6OA6hG5ZZfmoR424+/M9C9cgRSmN5898ClVtJz70BEbY+FZj6WrZqYJ3ZjqJWoSqR5EwDn3VnBfrFTfBK7Ul0NWBjAYFWvcd6daBvX6aa0EG4e8LiqDQerYiFxJpLocMoEE5azytHIVbtpDbC2Ig39xZd7YD0FOysqxBBc5GpQfLd9mriM4wRbmnqKuY5Csq2SjmDzdxzG8UAZ7Wey0x5ZN7I48FWjNy6RX+gB34hmL8XeRmxrxuK8ujsxYYsVoD07S6wjI3cbbKmKfTmuGggNCl6X7KtVIsdT7dzH2SFKkIw1veeWdXVcVBTqHIhULtp3QdZQftKSc2mZJCSq6bnQ1dEL5d2Hd9DDvy2t1GToREvGTl6VtEpi2pc87IQ+EQvvO/FavWHd+tC9SyemjtXN6oqtsey6lDlFrR6xz/JKgaXtGN5n9PxDSyyzzoHXznCHlM/qgDH8FF73X0KijQJNqXmDJaE+O5o19ffSyjBDoBNY5G4JDcoAg/K1h/38U4gYbp3Ki0h+4JG30XSefjRVz2SiXnfanVh2JQYSxp6BKgP+SjaVUcXu066HlvcFIvWDvd2DOlI7dUTNFL6aQzV5cpZqksQnipKVAJptwZSCFw88Bbd1sSz3uoAAyfE5Y90Si8YkU+572nRQoB2XBF7K6xb89tPqGhGSZAjlvIX1vKYcu/SIpWGVtn1KHuzmMmzQ4+kxKwddHZKO7pKT0J9DYi4y/zpJtKQ2Mqp3uMOH1Pq5/r4JW+FNxL6Ulea0qYl5aL4uTNmssDr3fB2QEQr2SwE3nQ8P2FwJNdwktJWM857BhIRTEw60S0ITLuG6b7AG8qVlKMuIUG8JzLyM1EUuRLeHP/n+qiTLC//rr0nXORWlaY/3vtXtvc7+5tscTYhaDkRztZeltDZBX3CJMTCV+IgKaDH8zmGEEXfMqz58ujYrDcL9vEJ65dWUv9ZNG2kEdpAyPbVpbK8FvTeGELHBwkmaP6YjhEcbR6zFp1QdcjPcgM8PK2UZ4lgXt9GppE5AE2HD0zvfT42XbhKD6iYxCKwcWmQK16NwPQrXo6RwPQrXo3A9zMzMzMzMzMzNzMzMzMzMzAAAAAAAAACAAEHnw4EBCwGgAEH3w4EBCwHIAEGHxIEBCwH6AEGWxIEBCwJAnABBpsSBAQsCUMMAQbbEgQELAiT0AEHFxIEBCwOAlpgAQdXEgQELAyC8vgBB5cSBAQsDKGvuAEH1xIEBCwP5ApUAQYTFgQELBEC3Q7oAQZTFgQELBBCl1OgAQaTFgQELBCrnhJEAQbPFgQELBYD0IOa1AEHDxYEBCwWgMalf4wBB08WBAQsFBL/JG44AQePFgQELBcUuvKKxAEHyxYEBCwZAdjprC94AQYLGgQELBuiJBCPHigBBksaBAQsGYqzF63itAEGhxoEBCweAehe3JtfYAEGxxoEBCweQrG4yeIaHAEHBxoEBCwe0Vwo/FmipAEHRxoEBC/g1oe3MzhvC0wAAAAAAAAAAoIQUQGFRWYQAAAAAAAAAAMilGZC5pW+lAAAAAAAAAAA6DyD0J4/LzgAAAAAAAAAAhAmU+Hg5P4EAAAAAAAAAQOULuTbXB4+hAAAAAAAAAFDeTmcEzcnyyQAAAAAAAACkliKBRUB8b/wAAAAAAAAATZ21cCuorcWdAAAAAAAAIPAF40w2Ehk3xQAAAAAAAChsxhvgw1bfhPYAAAAAAAAyx1wRbDqWCxOaAAAAAABAfzyzFQfJe86XwAAAAAAAEJ9LINtIuxrCvfAAAAAAANSGHvSIDbVQmXaWAAAAAIBEFBMx61DipD8UvAAAAACgVdkX/SXlGo5PGesAAAAACKvPXb43z9C40e+SAAAAAOXKoVqtBQMFJ8artwAAAECePUrxGcdDxrC3luUAAADQBc2cbW9c6nvOMn6PAAAAoiMAguSL8+Qagr9dswAAgIosgKLdbjCeoWIvNeAAACCtNyAL1UXeAqWdPSGMAAA0zCL0JkXWlUMOBY0prwAAQX8rsXCWTHvUUUbw89oAQBFfdt0MPA/NJPMrdtiIAMhq+2kKiKVTAO7vtpMOqwB6RXoEDeqOaIDpq6Q40tWA2NaYRZCkckHwcetmY6OFUEeGfyvapkdRbE6mQDwMpyTZZ1+2kJCZZQfiz1BLz9Btz0H347T0/59E7YESj4GCpCGJeg7x+L/HlWgi1/Ihow1qKxlSLfevObsC64xv6suQRHafpvj0mwhqwyVwC+X+tNVTR9A28gJFIpoXJidPn5BllCxCYtcB1qqAne/wIsf1frm30jpNQovV4IQrrev4st6nZYeJ4NJ3hQwzO0yTmy/riJ/0Vcxj1abP/0kfeML7JWvHcWu/PIqQw38cJxbzeu9FOU5G74tWOtrPcdjtl6y1y+Pwi3WX7MjQQ45O6b0Xo74c7e5SPSf7xNQxomPt3UvuY6iqp0z4HPskX0VelGrvdD6pyuiPNuQ57rbWdblEKxKOU/3is0RdyKlkTNPnFraWcai822BKOh3qvg/kkM0x/kbpVYm83YikpK4THbVBvr2YY6uraxSrzU2aWGTi0S3tfjyWlsbsiqBwYLd+jaI8VM/lHR78qK3IjDhl3rDLSylDX6UlOxLZ+q+G/hXdvp7zE7cO70mrx/wtFL8tijdDeGwyaTVulvl7OdkuuawEVJYHf8PCSfv32oePeufXBul7yV50M9z92ui0mazwhqNx7T27KKBpvBEjIsDXrKgMzmgN6jIIxCvWqyqwDdjSkAHDkKQ/CvXbZasajgjHg/rgedrGZyZ5Uj9WobHKuKQ4WRiRuAFwVybPqwle/ebNhm9etSYCTO14YQvGWl6wgLQFWzFYgU9U1jmOd/F13KAhx7E9rmFjaUzIcdVtkxPJ6TgezRk6vANfOs5KSXhY+yPHZUCgSKsEe+TAzi1LF512nD8oZA3rYpodcUL5HV3ElINPMr3QpTsAZQ2Td2V09Xlk437sRI/KIF/ou2q/aJnLHk7PE4uZfuh24mpF78K/fqYhw9jtP56iFJvFFquz7x4Q6vNO6c/F5eyAO+5K0JUSSnJY0fGhux8oYcqpXUS7l9yOrkVuiiomcvk8FHUV6r2TMhrXCS31WOcbpixpTZJWnF9wJiY8WS7hos93w+C2bIN3DLAvi296mYvDVfSY5EdklQ+c+20L7D83mrWY346sXr2JQb0kR+cPxQDjfpeyV7Ys7JHs7VjhU/bAm1493+3jN2e2ZykvbPSZWCFbhot07oIA0uB5vYdxwK7p8WeuEaqjgAZZ2OzpjXAaZO4B2pWUzCBIbw7osliGkP40QYjd3H8UjQUJMd7upzQ+glGqFdSfWfBGS72W6tHBzeLl1BrJB3CsGJ5snjIjmcCtD4Ww3QTGa8/iA0X/a78wmVOmHBWGt0aD24QW/0bvfH/oz2OaZ2UYZBLmbl+MFa5P8YF+wGA/j37LT0l375qZo22infA4DzNevuMcVasBgAwJy8UsB9O/9a1cYyoWAqBPy/3298jHL3PZc37aTQHEEZ+e+prd3P3nZygdUaEBNdZGxrgBFVT94YGyZaUJQsKL2PcmQhqpfFoiH18HRmlZV+eaWGmw6Y14dTM3iZfDLy2hwa6DHGSx1lIAhGt9tHt4CfKapCO9XYxnwDJjzlBN60WX4EY2lrq3QPj/+wGlIGYXvZjYwzup5VC2/3pCzqg/Xey+zrSKEx/lo9+M6YDJR7qTNwGxNmwzb8YX8CPhu9mouIRBXURHAAu4Hexs2SoQ0+blkXQVWcANppIT5Mca6kOQL9torTeYyId3GN15oeRUtPsRw5hFvroplF5U2MkdauF61vP+1m0p9B27NCeeUuKMDGZYX6bkmRjk6QGxRecasI9/LvfPXcBeXWRCHRehIdxzH/r0Q3Vwdrp+SXKuBJWJqFMceUpJBmpp3tsO2kX6q5JoYxed24cEA9aSklDX+Na2QjxdhNKpRcLFm1uShluGsqlFupIjigsyt4LyNmjypx4U12h3rGyO/2Qjr0QC79Em2QxDldcHMh8fdu1qYTWDuAfoSb3mRH/nptOoxbkCpKYJYpxsIBZfoZAIEzdoA80PjHrDh6jbNmRa5WsiISKAiZcs2lRJScL9sN4Ga6kqoGy9txCqm9vyPV2WyMVTNcjHrOWUlIKSb4z0uzq3qEL6+Rcfujkjd8vXeLWEcqlpnPtuUxQEdir/DdfiJc8ThMO6SmgZhRP1/tGMW+/CGGX0aV3CX2ZYsn4COJnVeS+/mGF62fs/dy/vA4b/Slj77r762M/6D1X7qoRnv10uuqruOM+D+VMqupWyoJf6XLQqlYNh8nt0WpTd34g9OXRhdbrk+e6aEXH5lBfrjEfRuRLpXbiqAVbNN3ruErjMIrSrkTqzCsFV4GKsqhfmfyuhFrYJYE0xa5h7V5Sd3192SZzjC7ig/YV+Wu19wuv76a1BjgdzhL4Tj1gUHLPmemQZ0rHIjyWu2LJuWeNfoJm9n0beu/Ou2Y5fym/uOwSA1iPsilRYDUi5e94l6UoFIMwsp61qrhCapxpWr6SdBij/9xDZBNqUgFGhKxuGIgR5/5qqh0IIXfDSRPuQKCtFV79BlalTSnSsBxY6NfJ1Fi0vkvrT6FyRl4mbiEK3CS58XZt8hBHauv41YZVpJYw52zTCm6WVkGl+g7n6Qy7vBxLCsgLPu/QDXuRn+ZR99URLua9hgfV4wrru4Bsd3DIWnqcbuqEyF3NpKtliZJO/m4WRoijK/tzPA3WPe314rwLnNcuy/D7Uw0RSc9pcq61hsAG/752nZPpqE4gIOhYZehzCrmvF0P24RRiqighbn5ijcprG9kU9J1eeVK2KmWM/pocgPJpLhnj24lSsNn88z4+pKMvA3acWtBtqV4SfC8Pz0/L98NVRHKGiRG1lQ+dZeMS3npYls7Gk5UpknxRhcJa1ZUa87h/eDZ9dPYdZeQz8Iv9X6+qnVdEGtQyp2MuH3XX/FpPyiNVCJPGnCc6+6VRTv9y3L+uKU23tEQyBLiQqKO/T5fqlbajIaBaPEJ1WGnl1pI+8h0RpfQFu+VVE7GDXko2zrKmVw9yByTdqVSc5jfdw4BcUe/RT4ruFYpW4Q7iaRoyO7Mx4dG2Vk7u6plRmQVivsicAl9HIejhqadDpv1Eu254xwPwFe5kG4kEi8hfz/IgDH/i94+wfRFrSqu7dLzyrwyZ2rRzoJ9XxhlVq1TsL1nSw09gj4nGKVnR1YmUFx4VJToRnVi2H9mzREru+xjin22FlAaz4KLTHhddpbvgG0VK6vgHXNjPhnLMmAkVbpIJzNBdhRgLA7IRgsEIWck2jkAFd+dcC8CeleFzTm84gzPRBtPeNA+wxzpYzyEICKf9xUqF1cQRnfkE+IL1poXmfhtOE6cZiAA/RTWgsxAlYx2gI5qN4e8BSRWGCNzUMLvmCit/MVppwp8t8sUKhx7ybkbYLQHZgpoj+212TifmrwjWkDtCT+M9q/lI1+Ov3VvNDTRLEuPaDBd5TIXvzWhaYSnCLejN6csPWqOlZsPEbvlxMLlnAGE90DBNkcBzuou1z33lv8N5iEeeLPsbR1IWUqCusRVbL3YrhLs43BkqnuZI2F9crPpVtmbrBxYccEeg3BN3Mto36yKAUmdvUsQqRoiIKQJKYnB3IWX8SSl5NtUurDNC2vgMlOjAfl9y1oOId1g+EZK5ELiR+c96pcaSN0uWJ0v7s6lytXRBWFI4NsUdfLIc+qCV0GHWUa5nxUN0Zd/coThIv0S/JPOP/llKKb6qa2XBrvYJ7+wvcvzznrAtVARBNxmxjWvoO0+8LIdhOqgFU4PdHPHhc6eN1pxSHcQqBNOz6rGWWs+NcU9HZqA1NoUGnORh/fKAcNKhFENNQoAkSEUjeHk3kkSCJK+qDMgRGqwrtSpNgXbZoa7bkpD+FF1ZNqB34ufTjQgbkHc6OZp2rYBIlNvN4zumDrtKAGWBCa3wr18EwF0LkJFoHoR/4EoZb9kyy/JxSHa4wSckntpdn8jPg3jxEp6TZfJv7saN9Ae9AmBaliugGCC5BnU6G7mCVKB+OTq2iCIp5kcTiJyq5uvKm8aJYy4rs17X127F0Z2mvEK5lF7/W86aRmSnvqOChbcqsP91uzLAQ9r/zKtNYCgn9F46Uiv/clPPvsPUH70xL/N3ZnLYfCj34lY75ZBUQr71KD0Skp0xMdrvxN74a1BptnRNVjdFf31Pq7cVtIYlhyIQsVfjim2t0krSb5LT1PP0yd2q224KGEbehwh0iM4y8PxUFpJIj6NXkSjOl6j+vqw8tg6Y7FrEFjw5Ap/KHTcsp+COQylsdx7ISEFHv6SA+dPYsNL2y5HjfFlQlaySpTZEanEC2746ri45U98K2idAaIMPQo6tylq6xKbVzJKyEoejzxIxWDzzaHnSikC3X5clxGPsXlolliJKIZXp8pi9+jd75nfvrfqq36v6YG5C73TFWeIX6ph7VZaU+fyJ0KlXeNWuTXCgzhV8nh4+ViDrVVgNGuHPyf6Y38WjzuiqJiiyEV6YQ7x/QhS1DsGl1Ky2bsvZnavUTgnP8KQ5iKTucQl/0AcXymKKPe7SRuvNJgxN3cUJ2Lz/Lc5ohNqlwHCTX1A3TU/sO/hABqoPTjCPtBqXoYxRdyZ6qQEoyBDg29EjO4nxZtHvG1dDcPgXGQ7HagRvcb6Ea+AoFlI6Gt5TdKDGR6eWkEJsmgxwZtPJ8ynJ99WMfztTB8KNjH2EvHP3P3PI8pwFK8uyMPGc5O2O8AcoXhghBbpcT2IXgAwW+1YK8nadK0Um9GE6n2ESGLUuiK4VRnUWc7J4h0Q7W5/jdRTvzUoKr4ZMDtULJ5ZC7yhcKsOdiFtq4Q2KTOx91aj2dDJyh+5sQ59Q6eApnEsUM4ocBRX1hapDFJItmgCv7J9rpQZbc+YS09u0tgGD2+bFRZNK7Uzim4XNpOaD4c3hesn5jVTTjB43o4SNke0gL219evGoB3EmwYtosPZoazpH3dWvFAVNc3PsQeMxAoUF2uiljG+GzuYmdCst/yATpqSn0O2LZICisRM29n/pFY1Qz8cq6Dyky15VArUd5F3ypwNa+1KlZf4ZdSMzMq47tSXCM7kkUMB+odFr/v1byaFyML2pcGfwm0hEx/2/sLoNzt13C2Y9dWIOrfv/FU/0xyCX1MtDzdC6kVV5/t6h8Prpvsj/EMBI6zes1X+XSG84ohc+nel5LRICzgVvPY9GAeWbDURk2XlWgH2Iyw7wF4ddANKafw7VqyKf6/vMrR9mNUMGPhzRjhfpRuf7w9phPsdLYudQAXpOc0zOfVpq/0W4HT+gJgTW4w8gAR+yAL4YKyGJiTOFCpvT6wFgnYbsnzb19vc/M6eeYnHiXuBzVOIAs3awDQOQhv8NWveZjCkfgeBSYBFBd6u50rGzg/MxYGMsM3wJSelKVyOtDDB6ANw/9z5aD5hinurrmVI8lYAXT/YN8JCDfUOlpICrzLrjGR37SzRZ0i9KRQVT6Vx0z3EwdR4EcUS5HtlLp+K3kPxPg5ZihY+X52OOmI3fZ3Q8YWI//RF4vnGeOSHbqp+oJD1fUCAAAPAAAAAQAAADVCAAA1AgAADwAAAAEAAAA1ggAANQIAAA8AAAABAAAANcIAADUCAAAPAAAAAQAAADYCAAA2QgAADAAAAAEAAAA2ggAANkIAAAwAAAABAAAANsIAADZCAAAMAAAAAQAAADcCAAA2QgAADAAAAAEAAAA3QgAANkIAAAwAAAABAAAAN4IAADZCAAAMAAAAAQAAADfCAAA2QgAADAAAAAEAAAA4AgAANkIAAAwAAAABAAAAOEIAADZCAAAMAAAAAQAAADiCAAA2QgAADAAAAAEAAAA4wgAANkIAAAwAAAABAAAAOQIAADZCAAAMAAAAAQAAADlCAAA2QgAADAAAAAEAAAA5ggAANkIAAAwAAAABAAAAOcIAADZCAAAMAAAAAQAAADoCAAA2QgAADAAAAAEAAAA6QgAANkIAAAwAAAABAAAAOoIAADZCAAAMAAAAAQAAADrCAAA2QgAADAAAAAEAAAA7AgAANkIAAAwAAAABAAAAO0IAADZCAAAMAAAAAQAAADuCAAA2QgAADAAAAAEAAAA7wgAANkIAAAwAAAABAAAAPAIAADZCAAAMAAAAAQAAADxCAAA2QgAADAAAAAEAAAA8ggAANkIAAAwAAAABAAAAPMIAADZCAAAMAAAAAQAAAD0CAAA2QgAADAAAAAEAAAA9QgAANkIAAAwAAAABAAAAPYIAADZCAAAMAAAAAQAAAD3CAAA2QgAADAAAAAEAAAA+AgAANkIAAAwAAAABAAAAPkIAAD6CAAANAAAAAQAAAD7CAAA/AgAAEgAAAAEAAAA/QgAAPwIAABIAAAABAAAAP4IAAD8CAAASAAAAAQAAAD/CAAA/AgAAEgAAAAEAAAAAAkAAPwIAABIAAAABAAAAAEJAAD8CAAASAAAAAQAAAACCQAA/AgAAEgAAAAEAAAAAwkAAPwIAABIAAAABAAAAAQJAAAFCQAAOAAAAAQAAAAGCQAABwkAADwAAAAEAAAACAkAAAcJAAA8AAAABAAAAAkJAAAKCQAAOAAAAAQAAAALCQAACgkAADgAAAAEAAAADAkAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFByaW1pdGl2ZUFycmF5IG9mIGxlbmd0aCAAAEB4IAAlAAAAZXggACEAAAAoCxAAcAAAAOcCAAAJAAAAdQkQAGoAAADPAAAATQAAAHUJEABqAAAAzwAAACUAAAB1CRAAagAAANkAAAAkAAAAdQkQAGoAAADuAAAAQAAAAHUJEABqAAAA7gAAACEAAABDYW5ub3QgY29udmVydCBhbGwgbG9naWNhbCBpbmRpY2VzIHRvIHBoeXNpY2FsIGluZGljZXMuIFRoZSBsb2dpY2FsIGluZGV4IGNhbm5vdCBiZSBjb252ZXJ0ZWQgaXMgLgAA+HggAGEAAABZeSAAAQAAAHUJEABqAAAA5AAAADMAAAB1CRAAagAAAOQAAAAUAAAAdQkQAGoAAADmAAAAIQAAAIFBEAB0AAAA5AAAAA4AAACBQRAAdAAAACsBAAAdAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAOAAAAAUAAAAkVxAAaQAAAEkAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAglUQAGgAAAB+AAAAJgAAAGJQEABrAAAAuAAAADwAAABiUBAAawAAAL0AAAA8AAAAwHHNK/WXKix1JwoV9WuZpP/sWnXFLhhxAXp4pMJb1YsKUbMsEqoS6gtZ3tvU7Lw550xQaoiymrNlSfixTbRc0u2i5dR7gLHU18EfJ15f4lzHLP3sJdo49w2Zk8JQSsynpBddj0p1IC1jlr4w3kLr7FPsFN832yXIIqwHEQap00w1/BFl7VJvvic5lf96AVLltaHfx+CoTEOS/RHiY2P8o/x1Tsx746Hy2vGnwXyEA6lh4Uw58D9xxI2UeLFznFnnZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoCUZ972aqE6KmHG/D5dJSpk4YAFII7TEaZo+oYpJXtP/vkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7r6cKpGRNjRgxUhAFxEOmzTBIwqVzdYosIMWX2rfa8zfEM/MnaU1JGkI+ioAjhXJQih84uvui+8ZAoQoWMa5/RaXKGzT/eMq2XzR7IFAx7B2H6FPxPwhQSHWIsWI6dexeEyaqF8hLELkfkWDr4NtNVxGpu7MUIMKvDpp5K2w0/FMk4m7jkYJLOcYSTiNQ4gt6XJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM4//WmAXKflpr1eEeiUAqJElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6cqR+SE8zMHNwHKQ9JGz7zovaqMy4nsb0sFHeC4yfroRriAXRBZEN4LnG7yT5gwTh7psyuBSe0blwx3izQVgXEULG3a5ecqOE5Qkdk3/h0aikTTxuSgtUEM2dlrg+EgUYeztWDRc3PkYZQ+mHf4UcUpXGSEtF/rhGs2cet9Q4ijJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh1zIQAHgAAADrBwAACQBB1PyBAQuFAQEAAAANCQAATGF5b3V0RXJyb3IAsQcQAG0AAABMAAAACgAAAA4JAABkAAAABAAAAA8JAADOdRAAagAAAL0BAAAdAAAAznUQAGoAAACnAQAAHwAAABAJAAAwAAAABAAAABEJAAASCQAANAAAAAQAAAATCQAAFAkAACwAAAAEAAAAFQkAAAEAQeT9gQEL3hAWCQAAKAAAAAQAAAAXCQAAFgkAACgAAAAEAAAAGAkAABYJAAAoAAAABAAAABkJAABUYWtlIG9ubHkgc3VwcG9ydGVkIGZvciBpbnRlZ2VycywgZ290IAAAFH8gACYAAABBcnJheSBpbmRleCBvdXQgb2YgYm91bmRzLCBjYW5ub3QgZ2V0IGl0ZW0gYXQgaW5kZXggIGZyb20gIGVudHJpZXMAAER/IAA0AAAAeH8gAAYAAAB+fyAACAAAAENhc3QgdG8gdXNpemUgZmFpbGVk2QgAADAAAAAEAAAATAMAABoJAABOAwAAGwkAABwJAABQAwAAUQMAAFIDAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAFMDAAAeCQAAVQMAAB8JAAAcCQAAVwMAAPkBAAD6AQAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAVAwAAIAkAABcDAAAhCQAAHAkAABoDAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAIgMAACIJAAAkAwAAIwkAABwJAAAmAwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAFgDAAAkCQAAWgMAACUJAAAcCQAAXAMAAFEDAABSAwAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAABdAwAAJgkAAF8DAAAnCQAAHAkAAGEDAAD5AQAA+gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAGwMAACgJAAAdAwAAKQkAABwJAAAfAwAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAACcDAAAqCQAAKQMAACsJAAAcCQAAKwMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAD0AQAALAkAAPYBAAAtCQAAHAkAAPgBAAD5AQAA+gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAQgMAAC4JAABEAwAALwkAABwJAABGAwAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAEcDAAAwCQAASQMAADEJAAAcCQAASwMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAMBwAAMgkAAA4HAAAzCQAAHAkAABAHAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAFgcAADQJAAAYBwAANQkAABwJAAAaBwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAAcHAAA2CQAACQcAADcJAAAcCQAACwcAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAARBwAAOAkAABMHAAA5CQAAHAkAABUHAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAA+wEAADoJAAD9AQAAOwkAABwJAAD/AQAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAAICAAA8CQAABAIAAD0JAAAcCQAABgIAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAACBwAAPgkAAAQHAAA/CQAAHAkAAAYHAADRAQAA0gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAACQIAAEAJAAALAgAAQQkAABwJAAANAgAAAAIAAAECAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAA4CAABCCQAAEAIAAEMJAAAcCQAAEgIAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAADLAQAARAkAAM0BAABFCQAAHAkAANABAADRAQAA0gEAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAA3gEAAEYJAADgAQAARwkAABwJAADiAQAA4wEAAOQBAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAQdCOggELxSRibxAAYAAAAMsAAABJAAAAFAkAACwAAAAEAAAAAgMAAEgJAAAEAwAASQkAAEoJAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAANkIAAAwAAAABAAAAC4DAABLCQAAMAMAAEwJAAAcCQAAMgMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAAzAwAATQkAADUDAABOCQAAHAkAADcDAAAHAgAACAIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAOAMAAE8JAAA6AwAAUAkAABwJAAA8AwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAAD0DAABRCQAAPwMAAFIJAAAcCQAAQQMAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAArBwAAUwkAAC0HAABUCQAAHAkAAC8HAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAJgcAAFUJAAAoBwAAVgkAABwJAAAqBwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAACEHAABXCQAAIwcAAFgJAAAcCQAAJQcAAAACAAABAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADZCAAAMAAAAAQAAAA6BwAAWQkAADwHAABaCQAAHAkAAD4HAAAAAgAAAQIAANMBAAAdCQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA2QgAADAAAAAEAAAAMAcAAFsJAAAyBwAAXAkAABwJAAA0BwAABwIAAAgCAADTAQAAHQkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAANkIAAAwAAAABAAAADUHAABdCQAANwcAAF4JAAAcCQAAOQcAAAcCAAAIAgAA0wEAAB0JAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADUCAAAPAAAAAQAAABYBwAAXwkAAFoHAABgCQAAYQkAAF0HAABeBwAAXwcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAYm8QAGAAAAAgAQAAEgAAAAUJAAA4AAAABAAAABMCAABiCQAAFQIAAGMJAABkCQAAGAIAAGUJAABmCQAAGwIAAB0JAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAADUCAAAPAAAAAQAAABqBwAAZwkAAGwHAABoCQAAYQkAAG4HAABvBwAAcAcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAABwkAADwAAAAEAAAAMQYAAGkJAAAzBgAAagkAAGsJAAA2BgAANwYAADgGAAA5BgAAHQkAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAANQIAAA8AAAABAAAAIsHAABsCQAAjQcAAG0JAABhCQAAjwcAAF4HAABfBwAAYAcAAB0JAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADUCAAAPAAAAAQAAACQBwAAbgkAAJIHAABvCQAAYQkAAJQHAABvBwAAcAcAAGAHAAAdCQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAABwkAADwAAAAEAAAARAYAAHAJAABGBgAAcQkAAGsJAABIBgAANwYAADgGAAA5BgAAHQkAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAAoJAAA4AAAABAAAAOUEAAByCQAA5wQAAHMJAABkCQAA6gQAAOsEAADsBAAA7QQAAB0JAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABibxAAYAAAAOEAAAASAAAA+ggAADQAAAAEAAAAnAQAAHQJAACeBAAAdQkAAHYJAAChBAAAdwkAAHgJAACkBAAAHQkAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAAoJAAA4AAAABAAAAPgEAAB5CQAA+gQAAHoJAABkCQAA/AQAAP0EAAD+BAAA7QQAAB0JAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAASCQAANAAAAAQAAACHAQAAewkAAIkBAAB8CQAAfQkAAIwBAAB+CQAAfwkAAI8BAAAdCQAAkQEAAJIBAACTAQAAlAEAAJUBAACWAQAAlwEAAJgBAACZAQAAYm8QAGAAAAAvAQAAIAAAAGJvEABgAAAAMAEAAEcAAAAQCQAAMAAAAAQAAADXBQAAgAkAANkFAACBCQAAggkAANwFAADdBQAA3gUAAN8FAAAdCQAAgwkAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAAhAkAAAgAAAAEAAAAcgIAAHMCAAB0AgAAhQkAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAGJvEABgAAAANQEAABoAAABibxAAYAAAADsBAABHAAAAYm8QAGAAAAA+AQAAWQAAAPwIAABIAAAABAAAAE4GAACGCQAAUAYAAIcJAACICQAAUwYAAFQGAABVBgAAVgYAAFcGAABYBgAAWQYAAFoGAABbBgAAXAYAAF0GAABeBgAAXwYAAGAGAAD8CAAASAAAAAQAAABhBgAAiQkAAGMGAACKCQAAiAkAAGUGAABmBgAAZwYAAGgGAABXBgAAWAYAAGkGAABaBgAAWwYAAFwGAABqBgAAawYAAGwGAABtBgAA/AgAAEgAAAAEAAAAbgYAAIsJAABwBgAAjAkAAIgJAAByBgAAcwYAAHQGAAB1BgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAAB5BgAAegYAAPwIAABIAAAABAAAAHsGAACNCQAAfQYAAI4JAACICQAAfwYAAIAGAACBBgAAggYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAhgYAAIcGAAD8CAAASAAAAAQAAACIBgAAjwkAAIoGAACQCQAAiAkAAIwGAABUBgAAVQYAAI0GAABXBgAAWAYAAI4GAABaBgAAWwYAAFwGAACPBgAAXgYAAJAGAACRBgAA/AgAAEgAAAAEAAAAkgYAAJEJAACUBgAAkgkAAIgJAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAPwIAABIAAAABAAAAJwGAACTCQAAngYAAJQJAACICQAAoAYAAHMGAAB0BgAAoQYAAFcGAABYBgAAdgYAAFoGAABbBgAAXAYAAHcGAAB4BgAAogYAAKMGAAD8CAAASAAAAAQAAACkBgAAlQkAAKYGAACWCQAAiAkAAKgGAACABgAAgQYAAKkGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAKoGAACrBgAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgZGljdGlvbmFyeSBrZXkgdHlwZTogANCSIABLAAAAYm8QAGAAAAALAQAAJwAAAG5vdCBpbXBsZW1lbnRlZDogVGFrZSBub3Qgc3VwcG9ydGVkIGZvciBkaWN0aW9uYXJ5IHR5cGUgNJMgADgAAABibxAAYAAAAA0BAAASAAAADgkAAGQAAAAEAAAAsgQAAJcJAAC0BAAAmAkAAJkJAAC3BAAAuAQAALkEAAC6BAAAHQkAALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAMEEAADCBAAAwwQAABYJAAAoAAAABAAAAJoJAACbCQAAnAkAAJ0JAACeCQAAnwkAAKAJAAChCQAAogkAAKMJAACDCQAApAkAAKUJAACmCQAApwkAAKgJAACpCQAAqgkAAKsJAAAWCQAAKAAAAAQAAACsCQAArQkAAK4JAACvCQAAngkAALAJAACgCQAAoQkAAKIJAACjCQAAgwkAALEJAAClCQAApgkAAKcJAACyCQAAqQkAAKoJAACrCQAAFgkAACgAAAAEAAAAswkAALQJAAC1CQAAtgkAAJ4JAAC3CQAAoAkAAKEJAACiCQAAowkAAIMJAAC4CQAApQkAAKYJAACnCQAAuQkAAKkJAACqCQAAqwkAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHVuc3VwcG9ydGVkIHJ1biBlbmQgaW5kZXggdHlwZTogAADklCAASgAAAGJvEABgAAAADwEAACoAAABub3QgaW1wbGVtZW50ZWQ6IFRha2Ugbm90IHN1cHBvcnRlZCBmb3IgcnVuIHR5cGUgAAAASJUgADEAAABibxAAYAAAABEBAAASAAAAbm90IGltcGxlbWVudGVkOiBUYWtlIG5vdCBzdXBwb3J0ZWQgZm9yIGRhdGEgdHlwZSAAAJSVIAAyAAAAYm8QAGAAAABfAQAADgAAAGJvEABgAAAA2wEAABcAAABibxAAYAAAANwBAAANAAAAYm8QAGAAAADjAQAAEQAAAGJvEABgAAAA7AEAABoAAABibxAAYAAAAO8BAAAUAAAAYm8QAGAAAADmAQAAGQAAAGJvEABgAAAA5gEAAD8AAABibxAAYAAAAOcBAAAVAAAAYm8QAGAAAADzAQAAEQAAAGJvEABgAAAA/gEAABoAAABibxAAYAAAAAMCAAAYAAAAYm8QAGAAAAD3AQAAHQAAAGJvEABgAAAA9wEAAEMAAABibxAAYAAAAPkBAAAVAAAAYm8QAGAAAAAIAgAAEQAAAGJvEABgAAAAEwIAABoAAABibxAAYAAAABcCAAAYAAAAYm8QAGAAAAAMAgAAHQAAAGJvEABgAAAADAIAAEMAAABibxAAYAAAAA4CAAAVAAAAYm8QAGAAAAAcAgAAJAAAAGJvEABgAAAAHQIAABEAAABibxAAYAAAACgCAAAaAAAAYm8QAGAAAAAvAgAAGAAAAGJvEABgAAAAIQIAAB0AAABibxAAYAAAACECAABDAAAAYm8QAGAAAAAjAgAAFQAAAGJvEABgAAAA1wIAADcAAABibxAAYAAAANcCAABVAAAAYm8QAGAAAADYAgAATwAAAGJvEABgAAAA0QIAAFcAAABibxAAYAAAANICAABDAAAAYm8QAGAAAAAWAwAAGwAAAGJvEABgAAAAGgMAABEAAABibxAAYAAAADkDAAAZAAAAYm8QAGAAAAAoAwAAGQAAAGJvEABgAAAAKQMAABcAAABibxAAYAAAACsDAAAZAAAAYm8QAGAAAAAxAwAAGAAAALwJAAAwAAAABAAAAL0JAABUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBQcmltaXRpdmVBcnJheSBvZiBsZW5ndGggAABgmCAAJQAAAIWYIAAhAAAAKAsQAHAAAADnAgAACQAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAADgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAApBddj0p1IC1jlr4w3kLr7NcyEAB4AAAA6wcAAAkAQaCzggEL1hQBAAAAvgkAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAADqARAAZgAAAAcBAAAfAAAA6gEQAGYAAAAKAQAAGAAAAL8JAAAIAAAABAAAAHICAABzAgAAdAIAAMAJAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAACbNBAAYgAAACQCAAAvAAAAmzQQAGIAAAD7AgAAGAAAAJs0EABiAAAABAMAABgAAABTZRAAZgAAAIEAAAArAAAAU2UQAGYAAACdAAAAKQAAAFNlEABmAAAArgAAACMAAABTZRAAZgAAAK8AAAAbAAAAU2UQAGYAAACvAAAAMgAAAG92ZXJmbG93U2UQAGYAAACxAAAAKQAAAFNlEABmAAAAAgEAACsAAABTZRAAZgAAAAMBAAA2AAAAU2UQAGYAAAAKAQAALAAAAFNlEABmAAAADAEAACUAAABTZRAAZgAAAA0BAAAiAAAAU2UQAGYAAAANAQAAHQAAAENhc3QgdG8gdXNpemUgZmFpbGVkT3V0LW9mLWJvdW5kcyBpbmRleCBImyAAFAAAAGJvEABgAAAApQEAAB4AAABibxAAYAAAAKwBAAAaAAAAvAkAADAAAAAEAAAAFQMAAMEJAAAXAwAAwgkAAMMJAAAaAwAAAAIAAAECAADTAQAAxAkAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAGJvEABgAAAAUQEAACIAAAAuJBAAYgAAAJ8AAAAgAAAALiQQAGIAAACgAAAAJwAAAC4kEABiAAAANAEAAEkAAAAuJBAAYgAAAEABAAA8AAAAmzQQAGIAAABzAgAAGQAAAJs0EABiAAAAdAIAABcAAABpbGxlZ2FsIG9mZnNldCByYW5nZZs0EABiAAAAdQIAADsAAADGCQAAPAAAAAQAAADHCQAAxgkAADwAAAAEAAAAyAkAAMYJAAA8AAAABAAAAMkJAADGCQAAPAAAAAQAAADKCQAAywkAADAAAAAEAAAAzAkAAMsJAAAwAAAABAAAAM0JAADLCQAAMAAAAAQAAADOCQAAywkAADAAAAAEAAAAzwkAAMsJAAAwAAAABAAAANAJAADLCQAAMAAAAAQAAADRCQAAywkAADAAAAAEAAAA0gkAAMsJAAAwAAAABAAAANMJAADLCQAAMAAAAAQAAADUCQAAywkAADAAAAAEAAAA1QkAAMsJAAAwAAAABAAAANYJAADLCQAAMAAAAAQAAADXCQAAywkAADAAAAAEAAAA2AkAAMsJAAAwAAAABAAAANkJAADLCQAAMAAAAAQAAADaCQAAywkAADAAAAAEAAAA2wkAAMsJAAAwAAAABAAAANwJAADLCQAAMAAAAAQAAADdCQAAywkAADAAAAAEAAAA3gkAAMsJAAAwAAAABAAAAN8JAADLCQAAMAAAAAQAAADgCQAAywkAADAAAAAEAAAA4QkAAMsJAAAwAAAABAAAAOIJAADLCQAAMAAAAAQAAADjCQAAywkAADAAAAAEAAAA5AkAAMsJAAAwAAAABAAAAOUJAADLCQAAMAAAAAQAAADmCQAAywkAADAAAAAEAAAA5wkAAMsJAAAwAAAABAAAAOgJAADLCQAAMAAAAAQAAADpCQAAywkAADAAAAAEAAAA6gkAAMsJAAAwAAAABAAAAOsJAADsCQAASAAAAAQAAADtCQAA7AkAAEgAAAAEAAAA7gkAAOwJAABIAAAABAAAAO8JAADsCQAASAAAAAQAAADwCQAA7AkAAEgAAAAEAAAA8QkAAOwJAABIAAAABAAAAPIJAADsCQAASAAAAAQAAADzCQAA7AkAAEgAAAAEAAAA9AkAAPUJAAA8AAAABAAAAPYJAAD1CQAAPAAAAAQAAAD3CQAA+AkAADgAAAAEAAAA+QkAAPgJAAA4AAAABAAAAPoJAABhcnJheSBkYXRhIHR5cGUgbWlzbWF0Y2hwnyAAGAAAAIFBEAB0AAAADwEAAAkAAACBQRAAdAAAABUBAAAdAAAACEEQAHgAAACaAAAAIgAAAAhBEAB4AAAAowAAACQAAAAIQRAAeAAAAKkAAAAiAAAACEEQAHgAAACmAAAAHgAAAAhBEAB4AAAAmwAAACIAAAAIQRAAeAAAAK4AAAA/AAAACEEQAHgAAACuAAAAJwAAAAhBEAB4AAAArQAAABwAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAO2i5dR7gLHU18EfJ15f4lzHLP3sJdo49w2Zk8JQSsynpBddj0p1IC1jlr4w3kLr7FPsFN832yXIIqwHEQap00w1/BFl7VJvvic5lf96AVLltaHfx+CoTEOS/RHiY2P8o/x1Tsx746Hy2vGnwXyEA6lh4Uw58D9xxI2UeLFznFnnZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoCUZ972aqE6KmHG/D5dJSpk4YAFII7TEaZo+oYpJXtP/vkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7r6cKpGRNjRgxUhAFxEOmzTBIwqVzdYosIMWX2rfa8zfEM/MnaU1JGkI+ioAjhXJQih84uvui+8ZAoQoWMa5/RaXKGzT/eMq2XzR7IFAx7B2H6FPxPwhQSHWIsWI6dexeEyaqF8hLELkfkWDr4NtNVxGpu7MUIMKvDpp5K2w0/FMk4m7jkYJLOcYSTiNQ4gt6XJ+ylN+hDor2UVDl/G136+N0XrCpBkhd9kV254FF+mM4//WmAXKflpr1eEeiUAqJElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6ClGzLBKqEuoLWd7b1Oy8OXKkfkhPMzBzcBykPSRs+86L2qjMuJ7G9LBR3guMn66Ea4gF0QWRDeC5xu8k+YME4e6bMrgUntG5cMd4s0FYFxFCxt2uXnKjhOUJHZN/4dGopE08bkoLVBDNnZa4PhIFGHs7Vg0XNz5GGUPph3+FHFJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh+wkAAPwJAAAMAAAABAAAAP0JAAD+CQAAxwcAQYDIggELXQEAAAD/CQAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA1zIQAHgAAADrBwAACQBB6MiCAQttAQAAAAAKAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAATGF5b3V0RXJyb3IAznUQAGoAAAC9AQAAHQAAAAEKAAA0AAAABAAAAAIKAAADCgAALAAAAAQAAAAECgAAAQBB4MmCAQvNOAUKAAAoAAAABAAAAAYKAAAFCgAAKAAAAAQAAAAHCgAABQoAACgAAAAEAAAACAoAAC4kEABiAAAANgAAABsAAAD1CQAAPAAAAAQAAAAxBgAACQoAADMGAAAKCgAACwoAADYGAAA3BgAAOAYAADkGAAAMCgAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAA9QkAADwAAAAEAAAARAYAAA0KAABGBgAADgoAAAsKAABIBgAANwYAADgGAAA5BgAADAoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAC4kEABiAAAAcwAAABoAAAAuJBAAYgAAAIsAAAAFAAAA7AkAAEgAAAAEAAAAkgYAAA8KAACUBgAAEAoAABEKAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAC4kEABiAAAAegAAABgAAADsCQAASAAAAAQAAACkBgAAEgoAAKYGAAATCgAAEQoAAKgGAACABgAAgQYAAKkGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAKoGAACrBgAA7AkAAEgAAAAEAAAATgYAABQKAABQBgAAFQoAABEKAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAOwJAABIAAAABAAAAIgGAAAWCgAAigYAABcKAAARCgAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAADsCQAASAAAAAQAAABuBgAAGAoAAHAGAAAZCgAAEQoAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAA7AkAAEgAAAAEAAAAnAYAABoKAACeBgAAGwoAABEKAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAOwJAABIAAAABAAAAGEGAAAcCgAAYwYAAB0KAAARCgAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAADsCQAASAAAAAQAAAB7BgAAHgoAAH0GAAAfCgAAEQoAAH8GAACABgAAgQYAAIIGAABXBgAAWAYAAIMGAABaBgAAWwYAAFwGAACEBgAAhQYAAIYGAACHBgAALiQQAGIAAACzAAAAGQAAAPgJAAA4AAAABAAAAPgEAAAgCgAA+gQAACEKAAAiCgAA/AQAAP0EAAD+BAAA7QQAAAwKAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAAuJBAAYgAAALgAAAAgAAAALiQQAGIAAAC5AAAALQAAAC4kEABiAAAAugAAABsAAAD4CQAAOAAAAAQAAADlBAAAIwoAAOcEAAAkCgAAIgoAAOoEAADrBAAA7AQAAO0EAAAMCgAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAywkAADAAAAAEAAAAywEAACUKAADNAQAAJgoAACcKAADQAQAA0QEAANIBAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAF0DAAAoCgAAXwMAACkKAAAnCgAAYQMAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAnAwAAKgoAACkDAAArCgAAJwoAACsDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAIgMAACwKAAAkAwAALQoAACcKAAAmAwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADoHAAAuCgAAPAcAAC8KAAAnCgAAPgcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAARBwAAMAoAABMHAAAxCgAAJwoAABUHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAWAMAADIKAABaAwAAMwoAACcKAABcAwAAUQMAAFIDAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAEIDAAA0CgAARAMAADUKAAAnCgAARgMAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAOAgAANgoAABACAAA3CgAAJwoAABICAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAFgcAADgKAAAYBwAAOQoAACcKAAAaBwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAPQBAAA6CgAA9gEAADsKAAAnCgAA+AEAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAA9AwAAPAoAAD8DAAA9CgAAJwoAAEEDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAA+wEAAD4KAAD9AQAAPwoAACcKAAD/AQAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAACEHAABACgAAIwcAAEEKAAAnCgAAJQcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAACBwAAQgoAAAQHAABDCgAAJwoAAAYHAADRAQAA0gEAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAGwMAAEQKAAAdAwAARQoAACcKAAAfAwAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADAHAABGCgAAMgcAAEcKAAAnCgAANAcAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAmBwAASAoAACgHAABJCgAAJwoAACoHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAFQMAAEoKAAAXAwAASwoAACcKAAAaAwAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAADgDAABMCgAAOgMAAE0KAAAnCgAAPAMAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAHBwAATgoAAAkHAABPCgAAJwoAAAsHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAA3gEAAFAKAADgAQAAUQoAACcKAADiAQAA4wEAAOQBAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAC4DAABSCgAAMAMAAFMKAAAnCgAAMgMAAAcCAAAIAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAAMBwAAVAoAAA4HAABVCgAAJwoAABAHAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAANQcAAFYKAAA3BwAAVwoAACcKAAA5BwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAACsHAABYCgAALQcAAFkKAAAnCgAALwcAAAACAAABAgAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAAACAgAAWgoAAAQCAABbCgAAJwoAAAYCAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAACQIAAFwKAAALAgAAXQoAACcKAAANAgAAAAIAAAECAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAEwDAABeCgAATgMAAF8KAAAnCgAAUAMAAFEDAABSAwAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADLCQAAMAAAAAQAAABHAwAAYAoAAEkDAABhCgAAJwoAAEsDAAAHAgAACAIAANMBAAAMCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAywkAADAAAAAEAAAAMwMAAGIKAAA1AwAAYwoAACcKAAA3AwAABwIAAAgCAADTAQAADAoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAMsJAAAwAAAABAAAAFMDAABkCgAAVQMAAGUKAAAnCgAAVwMAAPkBAAD6AQAA0wEAAAwKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAADCgAALAAAAAQAAAACAwAAZgoAAAQDAABnCgAAaAoAAAcDAAAIAwAACQMAAAoDAAALAwAADAMAAA0DAAAOAwAADwMAABADAAARAwAAEgMAABMDAAAUAwAAxgkAADwAAAAEAAAAWAcAAGkKAABaBwAAagoAAGsKAABdBwAAXgcAAF8HAABgBwAADAoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGUuJBAAYgAAAOkAAAAOAAAAxgkAADwAAAAEAAAAiwcAAGwKAACNBwAAbQoAAGsKAACPBwAAXgcAAF8HAABgBwAADAoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAMYJAAA8AAAABAAAAGoHAABuCgAAbAcAAG8KAABrCgAAbgcAAG8HAABwBwAAYAcAAAwKAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAADGCQAAPAAAAAQAAACQBwAAcAoAAJIHAABxCgAAawoAAJQHAABvBwAAcAcAAGAHAAAMCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAAQoAADQAAAAEAAAAhwEAAHIKAACJAQAAcwoAAHQKAACMAQAAdQoAAHYKAACPAQAADAoAAJEBAACSAQAAkwEAAJQBAACVAQAAlgEAAJcBAACYAQAAmQEAAC4kEABiAAAAOwEAADcAAAAuJBAAYgAAAFABAAAzAAAABQoAACgAAAAEAAAArAkAAHcKAACuCQAAeAoAAHkKAACwCQAAoAkAAKEJAACiCQAAowkAAHoKAACxCQAApQkAAKYJAACnCQAAsgkAAKkJAACqCQAAqwkAAAUKAAAoAAAABAAAALMJAAB7CgAAtQkAAHwKAAB5CgAAtwkAAKAJAAChCQAAogkAAKMJAAB6CgAAuAkAAKUJAACmCQAApwkAALkJAACpCQAAqgkAAKsJAAAFCgAAKAAAAAQAAACaCQAAfQoAAJwJAAB+CgAAeQoAAJ8JAACgCQAAoQkAAKIJAACjCQAAegoAAKQJAAClCQAApgkAAKcJAACoCQAAqQkAAKoJAACrCQAAfwoAAAgAAAAEAAAAcgIAAHMCAAB0AgAAgAoAAHYCAAB3AgAAeAIAAHkCAAB6AgAAewIAAHwCAAB9AgAAfgIAAH8CAACAAgAAgQIAAIICAACDAgAAhAIAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IGlsbGVnYWwgZGljdGlvbmFyeSBrZXkgdHlwZSAAAHi4IABGAAAALiQQAGIAAACkAQAAFgAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IFVuc3VwcG9ydGVkIHJ1biBlbmQgaW5kZXggdHlwZTogAADYuCAASgAAAC4kEABiAAAAtQEAABYAAABJdCBpcyBub3QgcG9zc2libGUgdG8gY29uY2F0ZW5hdGUgYXJyYXlzIG9mIGRpZmZlcmVudCBkYXRhIHR5cGVzICgAADy5IABCAAAALCAuLi4AAAAuJBAAYgAAAIwBAAAjAAAAKS4AAC4kEABiAAAAlgEAABsAAAAsIAAALiQQAGIAAACRAQAAIwAAAC4kEABiAAAAkgEAACMAAABjb25jYXQgcmVxdWlyZXMgaW5wdXQgb2YgYXQgbGVhc3Qgb25lIGFycmF5AIEKAAA8AAAABAAAAIIKAACBCgAAPAAAAAQAAACDCgAAgQoAADwAAAAEAAAAhAoAAIEKAAA8AAAABAAAAIUKAACGCgAAMAAAAAQAAACHCgAAhgoAADAAAAAEAAAAiAoAAIYKAAAwAAAABAAAAIkKAACGCgAAMAAAAAQAAACKCgAAhgoAADAAAAAEAAAAiwoAAIYKAAAwAAAABAAAAIwKAACGCgAAMAAAAAQAAACNCgAAhgoAADAAAAAEAAAAjgoAAIYKAAAwAAAABAAAAI8KAACGCgAAMAAAAAQAAACQCgAAhgoAADAAAAAEAAAAkQoAAIYKAAAwAAAABAAAAJIKAACGCgAAMAAAAAQAAACTCgAAhgoAADAAAAAEAAAAlAoAAIYKAAAwAAAABAAAAJUKAACGCgAAMAAAAAQAAACWCgAAhgoAADAAAAAEAAAAlwoAAIYKAAAwAAAABAAAAJgKAACGCgAAMAAAAAQAAACZCgAAhgoAADAAAAAEAAAAmgoAAIYKAAAwAAAABAAAAJsKAACGCgAAMAAAAAQAAACcCgAAhgoAADAAAAAEAAAAnQoAAIYKAAAwAAAABAAAAJ4KAACGCgAAMAAAAAQAAACfCgAAhgoAADAAAAAEAAAAoAoAAIYKAAAwAAAABAAAAKEKAACGCgAAMAAAAAQAAACiCgAAhgoAADAAAAAEAAAAowoAAIYKAAAwAAAABAAAAKQKAACGCgAAMAAAAAQAAAClCgAAhgoAADAAAAAEAAAApgoAAKcKAABIAAAABAAAAKgKAACnCgAASAAAAAQAAACpCgAApwoAAEgAAAAEAAAAqgoAAKcKAABIAAAABAAAAKsKAACnCgAASAAAAAQAAACsCgAApwoAAEgAAAAEAAAArQoAAKcKAABIAAAABAAAAK4KAACnCgAASAAAAAQAAACvCgAAsAoAADgAAAAEAAAAsQoAALIKAAA8AAAABAAAALMKAACyCgAAPAAAAAQAAAC0CgAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAJwAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAABUcnVzdGVkIGl0ZXJhdG9yIGxlbmd0aCB3YXMgbm90IGFjY3VyYXRlbHkgcmVwb3J0ZWQAdL0gADMAAAC1bRAAagAAAIYCAAAJAAAAtW0QAGoAAAClAgAANQAAAApRsywSqhLqC1ne29TsvDntouXUe4Cx1NfBHydeX+Jcxyz97CXaOPcNmZPCUErMp6QXXY9KdSAtY5a+MN5C6+xT7BTfN9slyCKsBxEGqdNMNfwRZe1Sb74nOZX/egFS5bWh38fgqExDkv0R4mNj/KP8dU7Me+Oh8trxp8F8hAOpYeFMOfA/ccSNlHixc5xZ52SbkvUMjgtgzWhn0+HjULmvOQRL4Rz3M6BSkd6ERkmN4qn8OK0OOH7FbC6gMU1KgBli+kYdFYruGEtyCqV7LK1/HWoqIlT2wIb23M7m7swA50xQaoiymrNlSfixTbRc0jWUzEI8vU3M9/nCXHUEmgJRn3vZqoToqYcb8Pl0lKmThgAUgjtMRpmj6hikle0/++RUUd5VhI00tWSikrrobxm+nCqRkTY0YMVIQBcRDps0wSMKlc3WKLCDFl9q32vM3xDPzJ2lNSRpCPoqAI4VyUIofOLr7ovvGQKEKFjGuf0Wlyhs0/3jKtl80eyBQMewdh+hT8T8IUEh1iLFiOnXsXhMmqhfISxC5H5Fg6+DbTVcRqbuzFCDCrw6aeStsNPxTJOJu45GCSznGEk4jUOILelyfspTfoQ6K9lFQ5fxtd+vjdF6wqQZIXfZFdueBRfpjElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMI+5LQ2Xu/G4ixFOEDatCG6wHHNK/WXKix1JwoV9WuZpHKkfkhPMzBzcBykPSRs+86L2qjMuJ7G9LBR3guMn66Ea4gF0QWRDeC5xu8k+YME4e6bMrgUntG5cMd4s0FYFxFCxt2uXnKjhOUJHZN/4dGopE08bkoLVBDNnZa4PhIFGHs7Vg0XNz5GGUPph3+FHFJ8O94VR1BDFW/ltD+K+qJwSbCekHpOLC/LbknqMggYfNH4ncnRpf3OVuEjg+HJR3ErTCRe0Vf5gBYKfgWPpWdh1zIQAHgAAADrBwAACQBBuIKDAQtVAQAAALUKAABMYXlvdXRFcnJvcgDOdRAAagAAAKcBAAAfAAAAtgoAADAAAAAEAAAAtwoAALgKAAA0AAAABAAAALkKAAC6CgAALAAAAAQAAAC7CgAAAQBBmIODAQuRMLwKAAAoAAAABAAAAL0KAAC8CgAAKAAAAAQAAAC+CgAAvAoAACgAAAAEAAAAvwoAAAAAAACbNBAAYgAAAFQAAAAJAAAASW5kZXhJdGVyYXRvciBleGhhdXN0ZWQgZWFybHkAAACbNBAAYgAAAGEAAAApAAAAmzQQAGIAAAB1AAAAIAAAAJs0EABiAAAAoAAAAEYAAACGCgAAMAAAAAQAAABMAwAAwAoAAE4DAADBCgAAwgoAAFADAABRAwAAUgMAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAUwMAAMQKAABVAwAAxQoAAMIKAABXAwAA+QEAAPoBAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAABUDAADGCgAAFwMAAMcKAADCCgAAGgMAAAACAAABAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAiAwAAyAoAACQDAADJCgAAwgoAACYDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAWAMAAMoKAABaAwAAywoAAMIKAABcAwAAUQMAAFIDAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAF0DAADMCgAAXwMAAM0KAADCCgAAYQMAAPkBAAD6AQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAbAwAAzgoAAB0DAADPCgAAwgoAAB8DAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAJwMAANAKAAApAwAA0QoAAMIKAAArAwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAPQBAADSCgAA9gEAANMKAADCCgAA+AEAAPkBAAD6AQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAABCAwAA1AoAAEQDAADVCgAAwgoAAEYDAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAARwMAANYKAABJAwAA1woAAMIKAABLAwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAAwHAADYCgAADgcAANkKAADCCgAAEAcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAWBwAA2goAABgHAADbCgAAwgoAABoHAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAABwcAANwKAAAJBwAA3QoAAMIKAAALBwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAABEHAADeCgAAEwcAAN8KAADCCgAAFQcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAD7AQAA4AoAAP0BAADhCgAAwgoAAP8BAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAAgIAAOIKAAAEAgAA4woAAMIKAAAGAgAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAAIHAADkCgAABAcAAOUKAADCCgAABgcAANEBAADSAQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAJAgAA5goAAAsCAADnCgAAwgoAAA0CAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAADgIAAOgKAAAQAgAA6QoAAMIKAAASAgAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAAMsBAADqCgAAzQEAAOsKAADCCgAA0AEAANEBAADSAQAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAADeAQAA7AoAAOABAADtCgAAwgoAAOIBAADjAQAA5AEAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAmzQQAGIAAABFAQAATQAAALoKAAAsAAAABAAAAAIDAADuCgAABAMAAO8KAADwCgAABwMAAAgDAAAJAwAACgMAAAsDAAAMAwAADQMAAA4DAAAPAwAAEAMAABEDAAASAwAAEwMAABQDAACGCgAAMAAAAAQAAAAuAwAA8QoAADADAADyCgAAwgoAADIDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAMwMAAPMKAAA1AwAA9AoAAMIKAAA3AwAABwIAAAgCAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAADgDAAD1CgAAOgMAAPYKAADCCgAAPAMAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAA9AwAA9woAAD8DAAD4CgAAwgoAAEEDAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAKwcAAPkKAAAtBwAA+goAAMIKAAAvBwAAAAIAAAECAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAACYHAAD7CgAAKAcAAPwKAADCCgAAKgcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAAhBwAA/QoAACMHAAD+CgAAwgoAACUHAAAAAgAAAQIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAhgoAADAAAAAEAAAAOgcAAP8KAAA8BwAAAAsAAMIKAAA+BwAAAAIAAAECAADTAQAAwwoAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAIYKAAAwAAAABAAAADAHAAABCwAAMgcAAAILAADCCgAANAcAAAcCAAAIAgAA0wEAAMMKAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAACGCgAAMAAAAAQAAAA1BwAAAwsAADcHAAAECwAAwgoAADkHAAAHAgAACAIAANMBAADDCgAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAgQoAADwAAAAEAAAAWAcAAAULAABaBwAABgsAAAcLAABdBwAAXgcAAF8HAABgBwAAwwoAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAALAKAAA4AAAABAAAABMCAAAICwAAFQIAAAkLAAAKCwAAGAIAAAsLAAAMCwAAGwIAAMMKAAAcAgAAHQIAAB4CAAAfAgAAIAIAACECAAAiAgAAIwIAACQCAACBCgAAPAAAAAQAAABqBwAADQsAAGwHAAAOCwAABwsAAG4HAABvBwAAcAcAAGAHAADDCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAsgoAADwAAAAEAAAAMQYAAA8LAAAzBgAAEAsAABELAAA2BgAANwYAADgGAAA5BgAAwwoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAIEKAAA8AAAABAAAAIsHAAASCwAAjQcAABMLAAAHCwAAjwcAAF4HAABfBwAAYAcAAMMKAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAACBCgAAPAAAAAQAAACQBwAAFAsAAJIHAAAVCwAABwsAAJQHAABvBwAAcAcAAGAHAADDCgAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAsgoAADwAAAAEAAAARAYAABYLAABGBgAAFwsAABELAABIBgAANwYAADgGAAA5BgAAwwoAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAALgKAAA0AAAABAAAAIcBAAAYCwAAiQEAABkLAAAaCwAAjAEAABsLAAAcCwAAjwEAAMMKAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAAC2CgAAMAAAAAQAAADXBQAAHQsAANkFAAAeCwAAHwsAANwFAADdBQAA3gUAAN8FAADDCgAAIAsAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAApwoAAEgAAAAEAAAATgYAACELAABQBgAAIgsAACMLAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAKcKAABIAAAABAAAAGEGAAAkCwAAYwYAACULAAAjCwAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAACnCgAASAAAAAQAAABuBgAAJgsAAHAGAAAnCwAAIwsAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAApwoAAEgAAAAEAAAAewYAACgLAAB9BgAAKQsAACMLAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAKcKAABIAAAABAAAAIgGAAAqCwAAigYAACsLAAAjCwAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAACnCgAASAAAAAQAAACSBgAALAsAAJQGAAAtCwAAIwsAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAApwoAAEgAAAAEAAAAnAYAAC4LAACeBgAALwsAACMLAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAKcKAABIAAAABAAAAKQGAAAwCwAApgYAADELAAAjCwAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiB1bnN1cHBvcnRlZCBkaWN0aW9uYXJ5IGtleSB0eXBlOiAAbNMgAEsAAACbNBAAYgAAAGMBAAArAAAAbm90IGltcGxlbWVudGVkOiBGaWx0ZXIgbm90IHN1cHBvcnRlZCBmb3IgZGljdGlvbmFyeSB0eXBlIAAA0NMgADoAAACbNBAAYgAAAGUBAAAWAAAAvAoAACgAAAAEAAAAmgkAADILAACcCQAAMwsAADQLAACfCQAAoAkAAKEJAACiCQAAowkAACALAACkCQAApQkAAKYJAACnCQAAqAkAAKkJAACqCQAAqwkAALwKAAAoAAAABAAAAKwJAAA1CwAArgkAADYLAAA0CwAAsAkAAKAJAAChCQAAogkAAKMJAAAgCwAAsQkAAKUJAACmCQAApwkAALIJAACpCQAAqgkAAKsJAAC8CgAAKAAAAAQAAACzCQAANwsAALUJAAA4CwAANAsAALcJAACgCQAAoQkAAKIJAACjCQAAIAsAALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdW5zdXBwb3J0ZWQgcnVuIGVuZCBpbmRleCB0eXBlOiAAACzVIABKAAAAmzQQAGIAAABeAQAAEQAAAG5vdCBpbXBsZW1lbnRlZDogRmlsdGVyIG5vdCBzdXBwb3J0ZWQgZm9yIFJ1bkVuZEVuY29kZWQgdHlwZSAAAACQ1SAAPQAAAJs0EABiAAAAYAEAABoAAABGaWx0ZXIgcHJlZGljYXRlIG9mIGxlbmd0aCAgaXMgbGFyZ2VyIHRoYW4gdGFyZ2V0IGFycmF5IG9mIGxlbmd0aCAAAOjVIAAbAAAAA9YgACcAAACbNBAAYgAAAJMBAAAcAAAAAAAAAAQAAAAEAAAAOQsAADoLAAA7CwAAPAsAAD0LAAA+CwAAPwsAAEALAABBCwAAQgsAAEMLAABECwAARQsAAEYLAABHCwAASAsAAEkLAABKCwAASwsAAEwLAAAIAAAABAAAAHICAABzAgAAdAIAAE0LAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlmzQQAGIAAAD2AQAAPQAAAGFzc2VydGlvbiBmYWlsZWQ6IHZhbHVlcy5sZW4oKSA+PSBwcmVkaWNhdGUuZmlsdGVyLmxlbigpmzQQAGIAAAAMAgAABQAAAJs0EABiAAAAEAIAAB4AAACbNBAAYgAAABICAAAxAAAAmzQQAGIAAAASAgAAGAAAAJs0EABiAAAAFwIAAB4AAACbNBAAYgAAABkCAAAxAAAAmzQQAGIAAAAZAgAAGAAAAJs0EABiAAAAJwIAAD0AAACbNBAAYgAAAB4CAABXAAAAmzQQAGIAAABTAgAAMAAAAJs0EABiAAAAVgIAABUAAACbNBAAYgAAAGQCAAAJAAAAaWxsZWdhbCBvZmZzZXQgcmFuZ2WbNBAAYgAAAG0CAAA3AAAAmzQQAGIAAAByAgAAGgAAAJs0EABiAAAAfgIAABkAAACbNBAAYgAAAIECAAAZAAAAmzQQAGIAAACCAgAAFwAAAJs0EABiAAAAhAIAADQAAACbNBAAYgAAAIQCAAASAAAAmzQQAGIAAACJAgAAGgAAAJs0EABiAAAAjwIAACIAAACbNBAAYgAAAJYCAAAZAAAAmzQQAGIAAACcAgAANAAAAJs0EABiAAAAnAIAABIAAACbNBAAYgAAALwCAAA9AAAAmzQQAGIAAADrAgAAHAAAAJs0EABiAAAA9AIAABwAAACbNBAAYgAAAAsDAAA9AAAAmzQQAGIAAABNAwAACQAAACRXEABpAAAAOAAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADXMhAAeAAAAOsHAAAJAEG0s4MBC/4CAQAAAE8LAABMYXlvdXRFcnJvcgDqARAAZgAAAIQAAAAjAAAA6gEQAGYAAAC2AAAAGAAAAOoBEABmAAAA4gAAAB0AAADqARAAZgAAAOMAAAAcAAAA6gEQAGYAAAD+AAAAFwAAAOoBEABmAAAA9wAAABYAAADqARAAZgAAAPgAAAAXAAAA6gEQAGYAAAANAQAAJQAAAOoBEABmAAAAKgEAAC0AAADqARAAZgAAADoBAAATAAAA6gEQAGYAAAA/AQAAKwAAAOoBEABmAAAAPQEAAA0AAABub3QgaW1wbGVtZW50ZWQ6IERpY3Rpb25hcnkgbWVyZ2luZyBmb3IgdHlwZSAgaXMgbm90IGltcGxlbWVudGVkiNogAC0AAAC12iAAEwAAAOoBEABmAAAAVgEAAA4AAADqARAAZgAAAGEBAAATAAAA6gEQAGYAAABjAQAADQAAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB0LaDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBjLeDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB5LeDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBoLiDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB+LiDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBtLmDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBjLqDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBByLqDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBoLuDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBB3LuDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBBtLyDAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBB8LyDAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBByL2DAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBhL6DAQs6TgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwAATgsAAE4LAABOCwBB3L6DAQsWUAsAAAAAAABRCwAAAAAAAFILAABTCwBBmL+DAQuRNk4LAABOCwAATgsAAE4LAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAFQLAAA8AAAABAAAAFULAABUCwAAPAAAAAQAAABWCwAAVAsAADwAAAAEAAAAVwsAAFQLAAA8AAAABAAAAFgLAABZCwAAMAAAAAQAAABaCwAAWQsAADAAAAAEAAAAWwsAAFkLAAAwAAAABAAAAFwLAABZCwAAMAAAAAQAAABdCwAAWQsAADAAAAAEAAAAXgsAAFkLAAAwAAAABAAAAF8LAABZCwAAMAAAAAQAAABgCwAAWQsAADAAAAAEAAAAYQsAAFkLAAAwAAAABAAAAGILAABZCwAAMAAAAAQAAABjCwAAWQsAADAAAAAEAAAAZAsAAFkLAAAwAAAABAAAAGULAABZCwAAMAAAAAQAAABmCwAAWQsAADAAAAAEAAAAZwsAAFkLAAAwAAAABAAAAGgLAABZCwAAMAAAAAQAAABpCwAAWQsAADAAAAAEAAAAagsAAFkLAAAwAAAABAAAAGsLAABZCwAAMAAAAAQAAABsCwAAWQsAADAAAAAEAAAAbQsAAFkLAAAwAAAABAAAAG4LAABZCwAAMAAAAAQAAABvCwAAWQsAADAAAAAEAAAAcAsAAFkLAAAwAAAABAAAAHELAABZCwAAMAAAAAQAAAByCwAAWQsAADAAAAAEAAAAcwsAAFkLAAAwAAAABAAAAHQLAABZCwAAMAAAAAQAAAB1CwAAWQsAADAAAAAEAAAAdgsAAFkLAAAwAAAABAAAAHcLAABZCwAAMAAAAAQAAAB4CwAAWQsAADAAAAAEAAAAeQsAAHoLAABIAAAABAAAAHsLAAB6CwAASAAAAAQAAAB8CwAAegsAAEgAAAAEAAAAfQsAAHoLAABIAAAABAAAAH4LAAB6CwAASAAAAAQAAAB/CwAAegsAAEgAAAAEAAAAgAsAAHoLAABIAAAABAAAAIELAAB6CwAASAAAAAQAAACCCwAAgwsAADwAAAAEAAAAhAsAAIMLAAA8AAAABAAAAIULAACBQRAAdAAAANwAAAAdAAAAgUEQAHQAAADOAAAAHQAAAIJVEABoAAAAhgAAACYAAADtouXUe4Cx1NfBHydeX+Jcxyz97CXaOPcNmZPCUErMp6QXXY9KdSAtY5a+MN5C6+xT7BTfN9slyCKsBxEGqdNMNfwRZe1Sb74nOZX/egFS5bWh38fgqExDkv0R4mNj/KP8dU7Me+Oh8trxp8F8hAOpZJuS9QyOC2DNaGfT4eNQua85BEvhHPczoFKR3oRGSY3iqfw4rQ44fsVsLqAxTUqAGWL6Rh0Viu4YS3IKpXssrX8daioiVPbAhvbczubuzAA1lMxCPL1NzPf5wlx1BJoChgAUgjtMRpmj6hikle0/++RUUd5VhI00tWSikrrobxm+nCqRkTY0YMVIQBcRDps0wSMKlc3WKLCDFl9q32vM3xDPzJ2lNSRpCPoqAI4VyUIofOLr7ovvGQKEKFjGuf0Wlyhs0/3jKtl80eyBQMewdh+hT8T8IUEh1iLFiOnXsXhMmqhfISxC5H5Fg6+DbTVcRqbuzFCDCrw6aeStsNPxTJOJu45GCSznGEk4jUOILelyfspTfoQ6K9lFQ5fxtd+vjdF6wqQZIXfZFdueBRfpjElI6zz1ZfGccblydT5HjUI+8zAbkBhm1rxfZdRnyWs3eoxNLzEphhwjoC5rNYdVJof8VnuN8jE8tje6Ri8JfJbck6FJuSR7lgW4uQDRfsYMByAbTXT+okm+n+f3GpIEeFonILkqqvtHG3r3lllMHT9jmDgum6iaVrAvWI63UeiHBhkm20ndTO7d1y67tT2t5sX88h9xhUtzbrpM08+4KMJypH5ITzMwc3AcpD0kbPvOi9qozLiexvSwUd4LjJ+uhGuIBdEFkQ3gucbvJPmDBOHumzK4FJ7RuXDHeLNBWBcRQsbdrl5yo4TlCR2Tf+HRqKRNPG5KC1QQzZ2WuD4SBRh7O1YNFzc+RhlD6Yd/hRxSfDveFUdQQxVv5bQ/ivqicEmwnpB6Tiwvy25J6jIIGHzR+J3J0aX9zlbhI4PhyUdxK0wkXtFX+YAWCn4Fj6VnYdcyEAB4AAAA6wcAAAkAAADOdRAAagAAAL0BAAAdAAAAhgsAADQAAAAEAAAAhwsAAIgLAAAIAAAABAAAAHICAABzAgAAdAIAAIkLAAB2AgAAdwIAAHgCAAB5AgAAegIAAHsCAAB8AgAAfQIAAH4CAAB/AgAAgAIAAIECAACCAgAAgwIAAIQCAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbGxlZ2FsIGRpY3Rpb25hcnkga2V5IHR5cGUgAABQ5iAARgAAAFNlEABmAAAAaQAAABIAAABJdCBpcyBub3QgcG9zc2libGUgdG8gaW50ZXJsZWF2ZSBhcnJheXMgb2YgZGlmZmVyZW50IGRhdGEgdHlwZXMgKCBhbmQgKQCw5iAAQQAAAPHmIAAFAAAA9uYgAAEAAABpbnRlcmxlYXZlIHJlcXVpcmVzIGlucHV0IG9mIGF0IGxlYXN0IG9uZSBhcnJheQBZCwAAMAAAAAQAAAA4AwAAigsAADoDAACLCwAAjAsAADwDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAFQMAAI4LAAAXAwAAjwsAAIwLAAAaAwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAD0DAACQCwAAPwMAAJELAACMCwAAQQMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAArBwAAkgsAAC0HAACTCwAAjAsAAC8HAAAAAgAAAQIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAXQMAAJQLAABfAwAAlQsAAIwLAABhAwAA+QEAAPoBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAFMDAACWCwAAVQMAAJcLAACMCwAAVwMAAPkBAAD6AQAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAwBwAAmAsAADIHAACZCwAAjAsAADQHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAIQcAAJoLAAAjBwAAmwsAAIwLAAAlBwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAADMDAACcCwAANQMAAJ0LAACMCwAANwMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAOAgAAngsAABACAACfCwAAjAsAABICAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAADAcAAKALAAAOBwAAoQsAAIwLAAAQBwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAFgDAACiCwAAWgMAAKMLAACMCwAAXAMAAFEDAABSAwAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAABHAwAApAsAAEkDAAClCwAAjAsAAEsDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAALgMAAKYLAAAwAwAApwsAAIwLAAAyAwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAADoHAACoCwAAPAcAAKkLAACMCwAAPgcAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAJAgAAqgsAAAsCAACrCwAAjAsAAA0CAAAAAgAAAQIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAA9AEAAKwLAAD2AQAArQsAAIwLAAD4AQAA+QEAAPoBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAACIDAACuCwAAJAMAAK8LAACMCwAAJgMAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAADeAQAAsAsAAOABAACxCwAAjAsAAOIBAADjAQAA5AEAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAFgcAALILAAAYBwAAswsAAIwLAAAaBwAABwIAAAgCAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAPsBAAC0CwAA/QEAALULAACMCwAA/wEAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAnAwAAtgsAACkDAAC3CwAAjAsAACsDAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAATAMAALgLAABOAwAAuQsAAIwLAABQAwAAUQMAAFIDAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAAcHAAC6CwAACQcAALsLAACMCwAACwcAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAA1BwAAvAsAADcHAAC9CwAAjAsAADkHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAGwMAAL4LAAAdAwAAvwsAAIwLAAAfAwAAAAIAAAECAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAAEIDAADACwAARAMAAMELAACMCwAARgMAAAACAAABAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAAmBwAAwgsAACgHAADDCwAAjAsAACoHAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAAgcAAMQLAAAEBwAAxQsAAIwLAAAGBwAA0QEAANIBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFkLAAAwAAAABAAAABEHAADGCwAAEwcAAMcLAACMCwAAFQcAAAcCAAAIAgAA0wEAAI0LAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABZCwAAMAAAAAQAAAACAgAAyAsAAAQCAADJCwAAjAsAAAYCAAAHAgAACAIAANMBAACNCwAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAWQsAADAAAAAEAAAAywEAAMoLAADNAQAAywsAAIwLAADQAQAA0QEAANIBAADTAQAAjQsAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAFNlEABmAAAAqwAAABcAAABTZRAAZgAAAKwAAAANAAAAU2UQAGYAAACtAAAADQAAAFNlEABmAAAAtAAAABYAAABUCwAAPAAAAAQAAABYBwAAzAsAAFoHAADNCwAAzgsAAF0HAABeBwAAXwcAAGAHAACNCwAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAU2UQAGYAAAC2AAAANAAAAFNlEABmAAAAtgAAABAAAABUCwAAPAAAAAQAAACQBwAAzwsAAJIHAADQCwAAzgsAAJQHAABvBwAAcAcAAGAHAACNCwAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAVAsAADwAAAAEAAAAiwcAANELAACNBwAA0gsAAM4LAACPBwAAXgcAAF8HAABgBwAAjQsAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFQLAAA8AAAABAAAAGoHAADTCwAAbAcAANQLAADOCwAAbgcAAG8HAABwBwAAYAcAAI0LAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAB6CwAASAAAAAQAAACSBgAA1QsAAJQGAADWCwAA1wsAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAU2UQAGYAAADfAAAAOAAAAFNlEABmAAAA4gAAAB8AAABTZRAAZgAAAOMAAAA2AAAAU2UQAGYAAADjAAAAOgAAAHoLAABIAAAABAAAAHsGAADYCwAAfQYAANkLAADXCwAAfwYAAIAGAACBBgAAggYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAhgYAAIcGAAB6CwAASAAAAAQAAABOBgAA2gsAAFAGAADbCwAA1wsAAFMGAABUBgAAVQYAAFYGAABXBgAAWAYAAFkGAABaBgAAWwYAAFwGAABdBgAAXgYAAF8GAABgBgAAegsAAEgAAAAEAAAApAYAANwLAACmBgAA3QsAANcLAACoBgAAgAYAAIEGAACpBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACqBgAAqwYAAHoLAABIAAAABAAAAIgGAADeCwAAigYAAN8LAADXCwAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAB6CwAASAAAAAQAAABuBgAA4AsAAHAGAADhCwAA1wsAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAegsAAEgAAAAEAAAAYQYAAOILAABjBgAA4wsAANcLAABlBgAAZgYAAGcGAABoBgAAVwYAAFgGAABpBgAAWgYAAFsGAABcBgAAagYAAGsGAABsBgAAbQYAAHoLAABIAAAABAAAAJwGAADkCwAAngYAAOULAADXCwAAoAYAAHMGAAB0BgAAoQYAAFcGAABYBgAAdgYAAFoGAABbBgAAXAYAAHcGAAB4BgAAogYAAKMGAABTZRAAZgAAAPQAAAAXAAAAU2UQAGYAAAD9AAAAIwAAAIMLAAA8AAAABAAAAEQGAADmCwAARgYAAOcLAADoCwAASAYAADcGAAA4BgAAOQYAAI0LAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAABTZRAAZgAAAPkAAAARAAAAgwsAADwAAAAEAAAAMQYAAOkLAAAzBgAA6gsAAOgLAAA2BgAANwYAADgGAAA5BgAAjQsAADsGAAA8BgAAPQYAAD4GAAA/BgAAQAYAAEEGAABCBgAAQwYAAIYLAAA0AAAABAAAAIcBAADrCwAAiQEAAOwLAADtCwAAjAEAAO4LAADvCwAAjwEAAI0LAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABTZRAAZgAAACoBAAAdAAAAYm9vbGVhbiBhcnJheQAAADoZEABfAAAAQAMAAB8AAABieXRlIHZpZXcgYXJyYXkAOhkQAF8AAACAAwAAIQAAAHByaW1pdGl2ZSBhcnJheQA6GRAAXwAAAEgDAAAhAAAAZGljdGlvbmFyeSBhcnJheToZEABfAAAAwgMAACIAAABiaW5hcnkgdmlldyBhcnJheQAAADoZEABfAAAAeAMAACEAAABzdHJpbmcgdmlldyBhcnJheQAAADoZEABfAAAAbgMAACEAAABmaXhlZCBzaXplIGxpc3QgYXJyYXkAAAA6GRAAXwAAALIDAAAOAAAAZml4ZWQgc2l6ZSBiaW5hcnkgYXJyYXkAOhkQAF8AAACpAwAADgAAAG1hcCBhcnJheQAAADoZEABfAAAAugMAABsAAABydW4gYXJyYXkAAAA6GRAAXwAAAMoDAAAbAAAAbGlzdCBhcnJheQAAOhkQAF8AAACYAwAAHAAAAGJ5dGUgYXJyYXkAADoZEABfAAAAUAMAAB0AAAB1bmlvbiBhcnJheQA6GRAAXwAAAJADAAAdAAAAYmluYXJ5IGFycmF5OhkQAF8AAABkAwAAHQAAAHN0cmluZyBhcnJheToZEABfAAAAWgMAAB0AAABzdHJ1Y3QgYXJyYXk6GRAAXwAAAIgDAAAeAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAEG09YMBC+EDAQAAAPALAABMYXlvdXRFcnJvcgCbNBAAYgAAAJ0BAAAXAAAAmzQQAGIAAACnAQAAFQAAAFNlEABmAAAAiAAAACIAAABTZRAAZgAAAIkAAAAbAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHJ1biBhcnJheQA6GRAAXwAAAGECAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHByaW1pdGl2ZSBhcnJheQAAADoZEABfAAAA9QEAAAoAAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAE5lc3RlZCBhcnJheSBzaXplIG1pc21hdGNoOiBvbmUgaXMgLCBhbmQgdGhlIG90aGVyIGlzIAAAkPsgACMAAACz+yAAEwAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAAAkVxAAaQAAADgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQBBoPmDAQupAQEAAADxCwAATGF5b3V0RXJyb3IAYm8QAGAAAAD9AAAAOQAAAHByaW1pdGl2ZSBhcnJheQA6GRAAXwAAAEgDAAAhAAAAKAsQAHAAAABeAgAAJgAAAEluY29ycmVjdCBsZW5ndGggb2YgbnVsbCBidWZmZXIgZm9yIFByaW1pdGl2ZUFycmF5LCBleHBlY3RlZCAgZ290IAAA9PwgAD0AAAAx/SAABQAAAA0AQdT6gwELAhABAEHg+oMBCwIRAwBB7PqDAQsCEwEAQfj6gwELARMAQYT7gwELAyUmCgBBkPuDAQsCDQIAQZz7gwELAhIDAEGo+4MBCwINAwBBtPuDAQsCEwIAQcD7gwELARAAQcz7gwELAhICAEHY+4MBCwMjCQIAQeT7gwELAyQSBgBB8PuDAQsCDQEAQfz7gwELARIAQYj8gwELAhIBAEGU/IMBCwMmTAoAQaD8gwELAhECAEGs/IMBC80BaW5jb21wYXRpYmxlIGRhdGEgdHlwZSBmb3IgYnVpbGRlciwgZXhwZWN0ZWQgAAAALP4gAC0AAAAx/SAABQAAAIFBEAB0AAAAvAAAAAkAAABmYWlsZWQgdG8gcm91bmQgdXB0byBtdWx0aXBsZSBvZiA2NAAkVxAAaQAAABgAAAAKAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAA1zIQAHgAAADrBwAACQBBhP6DAQv1EAEAAADyCwAA8wsAABQAAAAEAAAA9AsAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAA9QsAAAwAAAAEAAAA9gsAAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3JMYXlvdXRFcnJvcgAAmzQQAGIAAABzAgAAGQAAAJs0EABiAAAAdAIAABcAAABpbGxlZ2FsIG9mZnNldCByYW5nZZs0EABiAAAAdQIAADsAAABJbnZhbGlkIGRpY3Rpb25hcnkga2V5ICBhdCBpbmRleCAsIGV4cGVjdGVkIDAgPD0ga2V5IDwgAPQAIQAXAAAACwEhAAoAAAAVASEAFgAAAAAAAAAEAAAABAAAALsJAADXMhAAeAAAAOsHAAAJAAAAa2V5IHZhbGlkAAAAz4kQAGEAAACCAAAAIgAAAPuVEABeAAAAswcAABYAAAB1CRAAagAAAMkAAAANAAAAdQkQAGoAAADKAAAAHwAAAMoZEACBAAAAOAAAABsAAABIbRAAbAAAAEsCAAATAAAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAA0AEhACUAAAD1ASEAIQAAACgLEABwAAAA5wIAAAkAAABydW5fZW5kc3ZhbHVlcwAAikAQAH0AAADSAAAAGAAAAEJsb2NrIHRvbyBsYXJnZQBYAiEADwAAAIpAEAB9AAAAEgEAAAkAAACKQBAAfQAAABQBAAAYAAAARiAQAGkAAAB7AAAAFwAAAEYgEABpAAAAfAAAAA0AAABvZmZzZXQgb3ZlcmZsb3cARiAQAGkAAACEAAAAHAAAAHVzaXplIG92ZXJmbG93AABGIBAAaQAAAIAAAAArAAAARiAQAGkAAACBAAAAEQAAAEYgEABpAAAApQAAACMAAABiUBAAawAAALgAAAA8AAAAYlAQAGsAAAC9AAAAPAAAAOdMUGqIspqzZUn4sU20XNK+nCqRkTY0YMVIQBcRDps0lcZIS0X+uEazZx631DiKMsBxzSv1lyosdScKFfVrmaQKUbMsEqoS6gtZ3tvU7Lw5/+xadcUuGHEBenikwlvVi+Kp/DitDjh+xWwuoDFNSoBMmqhfISxC5H5Fg6+DbTVcQsbdrl5yo4TlCR2Tf+HRqBli+kYdFYruGEtyCqV7LK2vOQRL4Rz3M6BSkd6ERkmNByAbTXT+okm+n+f3GpIEeHJ+ylN+hDor2UVDl/G136/umzK4FJ7RuXDHeLNBWBcRwSMKlc3WKLCDFl9q32vM34f8VnuN8jE8tje6Ri8JfJZJsJ6Qek4sL8tuSeoyCBh8PuS0Nl7vxuIsRThA2rQhugDAv/LBP/58nWC8YVXFZwGeBGqkGE5i3Xwyy2GHuwfHxyz97CXaOPcNmZPCUErMp1onILkqqvtHG3r3lllMHT/F/PIfcYVLc266TNPPuCjCtaHfx+CoTEOS/RHiY2P8o+P/1pgFyn5aa9XhHolAKiQofOLr7ovvGQKEKFjGuf0WPvMwG5AYZta8X2XUZ8lrN1Gfe9mqhOiphxvw+XSUqZMQz8ydpTUkaQj6KgCOFclCU+wU3zfbJcgirAcRBqnTTDWUzEI8vU3M9/nCXHUEmgLkVFHeVYSNNLVkopK66G8Ze7I8HJu1h/yBm9JjW7WZ7tyToUm5JHuWBbi5ANF+xgx7O1YNFzc+RhlD6Yd/hRxSjdF6wqQZIXfZFdueBRfpjIYAFII7TEaZo+oYpJXtP/uTibuORgks5xhJOI1DiC3p7aLl1HuAsdTXwR8nXl/iXElI6zz1ZfGccblydT5HjUKkTTxuSgtUEM2dlrg+EgUYZJuS9QyOC2DNaGfT4eNQuWuIBdEFkQ3gucbvJPmDBOFypH5ITzMwc3AcpD0kbPvOlyhs0/3jKtl80eyBQMewdovaqMy4nsb0sFHeC4yfroTR+J3J0aX9zlbhI4PhyUdxK0wkXtFX+YAWCn4Fj6VnYR+hT8T8IUEh1iLFiOnXsXikF12PSnUgLWOWvjDeQuvsEJ9k8dpo/gbvJq2NCifCzWOYOC6bqJpWsC9YjrdR6Id/HWoqIlT2wIb23M7m7swAeoxNLzEphhwjoC5rNYdVJmHhTDnwP3HEjZR4sXOcWed8O94VR1BDFW/ltD+K+qJwNfwRZe1Sb74nOZX/egFS5Uam7sxQgwq8OmnkrbDT8UwGGSbbSd1M7t3XLru1Pa3m/HVOzHvjofLa8afBfIQDqQAAAAAEAAAABAAAAPsLAAAAAAAABAAAAAQAAABtAwAASW50ZXJ2YWxEYXlUaW1lZGF5c21pbGxpc2Vjb25kcwAAAAAABAAAAAQAAABICAAASW50ZXJ2YWxNb250aERheU5hbm9tb250aHNuYW5vc2Vjb25kcwAAAPwLAAAsAAAABAAAAP0LAAABAEGEj4QBC94H/gsAADwAAAAEAAAA/wsAAP4LAAA8AAAABAAAAAAMAAD+CwAAPAAAAAQAAAABDAAA/gsAADwAAAAEAAAAAgwAAAMMAABIAAAABAAAAAQMAAADDAAASAAAAAQAAAAFDAAAAwwAAEgAAAAEAAAABgwAAAMMAABIAAAABAAAAAcMAAADDAAASAAAAAQAAAAIDAAAAwwAAEgAAAAEAAAACQwAAAMMAABIAAAABAAAAAoMAAADDAAASAAAAAQAAAALDAAADAwAADAAAAAEAAAAUwMAAA0MAABVAwAADgwAAA8MAABXAwAA+QEAAPoBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAFgDAAARDAAAWgMAABIMAAAPDAAAXAMAAFEDAABSAwAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAABdAwAAEwwAAF8DAAAUDAAADwwAAGEDAAD5AQAA+gEAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAFQMAABUMAAAXAwAAFgwAAA8MAAAaAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAEwDAAAXDAAATgMAABgMAAAPDAAAUAMAAFEDAABSAwAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAnAwAAGQwAACkDAAAaDAAADwwAACsDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAGwMAABsMAAAdAwAAHAwAAA8MAAAfAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAACIDAAAdDAAAJAMAAB4MAAAPDAAAJgMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAfDAAAOAAAAAQAAAAgDAAAIQwAADQAAAAEAAAAIgwAACMMAAA4AAAABAAAACQMAAAjDAAAOAAAAAQAAAAlDAAAJgwAAGQAAAAEAAAAJwwAAAAAAAAEAAAABAAAACgMAEHwloQBC74xVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgUHJpbWl0aXZlQXJyYXkgb2YgbGVuZ3RoIAAAcAshACUAAACVCyEAIQAAACgLEABwAAAA5wIAAAkAAAAMDAAAMAAAAAQAAAApDAAADAwAADAAAAAEAAAAKgwAAAwMAAAwAAAABAAAACsMAAAMDAAAMAAAAAQAAAAsDAAADAwAADAAAAAEAAAALQwAAAwMAAAwAAAABAAAAC4MAAAMDAAAMAAAAAQAAAAvDAAADAwAADAAAAAEAAAAMAwAAAwMAAAwAAAABAAAADEMAAAMDAAAMAAAAAQAAAAyDAAADAwAADAAAAAEAAAAMwwAAAwMAAAwAAAABAAAADQMAAAMDAAAMAAAAAQAAAA1DAAADAwAADAAAAAEAAAANgwAAAwMAAAwAAAABAAAADcMAAAMDAAAMAAAAAQAAAA4DAAADAwAADAAAAAEAAAAOQwAAAwMAAAwAAAABAAAADoMAAAMDAAAMAAAAAQAAAA7DAAADAwAADAAAAAEAAAAPAwAAAwMAAAwAAAABAAAAD0MAAAMDAAAMAAAAAQAAAA+DAAADAwAADAAAAAEAAAAPwwAAAwMAAAwAAAABAAAAEAMAAAMDAAAMAAAAAQAAABBDAAADAwAADAAAAAEAAAAQgwAAAwMAAAwAAAABAAAAEMMAAAMDAAAMAAAAAQAAABEDAAADAwAADAAAAAEAAAARQwAAAwMAAAwAAAABAAAAEYMAAAMDAAAMAAAAAQAAABHDAAADAwAADAAAAAEAAAASAwAACgLEABwAAAAKAUAADQAAABudWxs6A0hAAQAAAABAAAAAAAAACAoVW5rbm93biBUaW1lIFpvbmUgJycpAAEAAAAAAAAA/A0hABUAAAARDiEAAgAAACgLEABwAAAAEAUAADQAAABDYXN0IGVycm9yOiBGYWlsZWQgdG8gY29udmVydCAgdG8gdGVtcG9yYWwgZm9yIAA8DiEAHgAAAFoOIQARAAAAKAsQAHAAAAAcBQAANAAAAEkMAAA0AAAABAAAAEoMAAB2YWxpZAAAAEsMAAAwAAAABAAAAEwMAABNDAAAKAAAAAQAAABODAAATQwAACgAAAAEAAAATwwAAE0MAAAoAAAABAAAAFAMAABRDAAAPAAAAAQAAABSDAAAUQwAADwAAAAEAAAAUwwAAFQMAABEAAAABAAAAFUMAABUDAAARAAAAAQAAABWDAAAAAAAAAQAAAAEAAAA8gIAAFcMAAD0AgAAWAwAAFkMAAD3AgAAWgwAAFsMAABcDAAAEAwAAF0MAAD8AgAA/QIAAP4CAAD/AgAAWgwAAAADAAAQDAAAAQMAAPwLAAAsAAAABAAAAAIDAABeDAAABAMAAF8MAABgDAAABwMAAAgDAAAJAwAACgMAAAsDAAAMAwAADQMAAA4DAAAPAwAAEAMAABEDAAASAwAAEwMAABQDAAAMDAAAMAAAAAQAAAD0AQAAYQwAAPYBAABiDAAADwwAAPgBAAD5AQAA+gEAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAQgMAAGMMAABEAwAAZAwAAA8MAABGAwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAEcDAABlDAAASQMAAGYMAAAPDAAASwMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAuAwAAZwwAADADAABoDAAADwwAADIDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAMwMAAGkMAAA1AwAAagwAAA8MAAA3AwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAADgDAABrDAAAOgMAAGwMAAAPDAAAPAMAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAA9AwAAbQwAAD8DAABuDAAADwwAAEEDAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAKwcAAG8MAAAtBwAAcAwAAA8MAAAvBwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAACYHAABxDAAAKAcAAHIMAAAPDAAAKgcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAhBwAAcwwAACMHAAB0DAAADwwAACUHAAAAAgAAAQIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAOgcAAHUMAAA8BwAAdgwAAA8MAAA+BwAAAAIAAAECAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAADAHAAB3DAAAMgcAAHgMAAAPDAAANAcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAA1BwAAeQwAADcHAAB6DAAADwwAADkHAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAAVW5leHBlY3RlZCBkYXRhIHR5cGUgAAAATBQhABUAAABDdxAAZAAAAEgDAAAPAAAADAwAADAAAAAEAAAADAcAAHsMAAAOBwAAfAwAAA8MAAAQBwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAABYHAAB9DAAAGAcAAH4MAAAPDAAAGgcAAAcCAAAIAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAHBwAAfwwAAAkHAACADAAADwwAAAsHAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAEQcAAIEMAAATBwAAggwAAA8MAAAVBwAABwIAAAgCAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAPsBAACDDAAA/QEAAIQMAAAPDAAA/wEAAAACAAABAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAACAgAAhQwAAAQCAACGDAAADwwAAAYCAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAAgcAAIcMAAAEBwAAiAwAAA8MAAAGBwAA0QEAANIBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAP4LAAA8AAAABAAAAFgHAACJDAAAWgcAAIoMAACLDAAAXQcAAF4HAABfBwAAYAcAABAMAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAAfDAAAOAAAAAQAAAATAgAAjAwAABUCAACNDAAAjgwAABgCAACPDAAAkAwAABsCAAAQDAAAHAIAAB0CAAAeAgAAHwIAACACAAAhAgAAIgIAACMCAAAkAgAA/gsAADwAAAAEAAAAagcAAJEMAABsBwAAkgwAAIsMAABuBwAAbwcAAHAHAABgBwAAEAwAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFEMAAA8AAAABAAAADEGAACTDAAAMwYAAJQMAACVDAAANgYAADcGAAA4BgAAOQYAABAMAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAAD+CwAAPAAAAAQAAACLBwAAlgwAAI0HAACXDAAAiwwAAI8HAABeBwAAXwcAAGAHAAAQDAAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAA/gsAADwAAAAEAAAAkAcAAJgMAACSBwAAmQwAAIsMAACUBwAAbwcAAHAHAABgBwAAEAwAAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAFEMAAA8AAAABAAAAEQGAACaDAAARgYAAJsMAACVDAAASAYAADcGAAA4BgAAOQYAABAMAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAAAjDAAAOAAAAAQAAADlBAAAnAwAAOcEAACdDAAAjgwAAOoEAADrBAAA7AQAAO0EAAAQDAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAVAwAAEQAAAAEAAAAngwAAJ8MAACgDAAAoQwAAKIMAACjDAAApAwAAKUMAACmDAAAEAwAAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAACEMAAA0AAAABAAAAJwEAACwDAAAngQAALEMAACyDAAAoQQAALMMAAC0DAAApAQAABAMAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAAAjDAAAOAAAAAQAAAD4BAAAtQwAAPoEAAC2DAAAjgwAAPwEAAD9BAAA/gQAAO0EAAAQDAAA7wQAAPAEAADxBAAA8gQAAPMEAAD0BAAA9QQAAPYEAAD3BAAAVAwAAEQAAAAEAAAAtwwAALgMAAC5DAAAugwAAKIMAAC7DAAAvAwAAL0MAACmDAAAEAwAAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAAEkMAAA0AAAABAAAAIcBAAC+DAAAiQEAAL8MAADADAAAjAEAAMEMAADCDAAAjwEAABAMAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABLDAAAMAAAAAQAAADXBQAAwwwAANkFAADEDAAAxQwAANwFAADdBQAA3gUAAN8FAAAQDAAAXQwAAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAAAwwAAEgAAAAEAAAATgYAAMYMAABQBgAAxwwAAMgMAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAAMMAABIAAAABAAAAGEGAADJDAAAYwYAAMoMAADIDAAAZQYAAGYGAABnBgAAaAYAAFcGAABYBgAAaQYAAFoGAABbBgAAXAYAAGoGAABrBgAAbAYAAG0GAAADDAAASAAAAAQAAABuBgAAywwAAHAGAADMDAAAyAwAAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAAAwwAAEgAAAAEAAAAewYAAM0MAAB9BgAAzgwAAMgMAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAAMMAABIAAAABAAAAIgGAADPDAAAigYAANAMAADIDAAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAAADDAAASAAAAAQAAACSBgAA0QwAAJQGAADSDAAAyAwAAJYGAABmBgAAZwYAAJcGAABXBgAAWAYAAJgGAABaBgAAWwYAAFwGAACZBgAAawYAAJoGAACbBgAAAwwAAEgAAAAEAAAAnAYAANMMAACeBgAA1AwAAMgMAACgBgAAcwYAAHQGAAChBgAAVwYAAFgGAAB2BgAAWgYAAFsGAABcBgAAdwYAAHgGAACiBgAAowYAAAMMAABIAAAABAAAAKQGAADVDAAApgYAANYMAADIDAAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABVbmV4cGVjdGVkIGRpY3Rpb25hcnkga2V5IHR5cGUgAHQeIQAfAAAAQ3cQAGQAAAA7AwAAEwAAAAwMAAAwAAAABAAAAAkCAADXDAAACwIAANgMAAAPDAAADQIAAAACAAABAgAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAMDAAAMAAAAAQAAAAOAgAA2QwAABACAADaDAAADwwAABICAAAHAgAACAIAANMBAAAQDAAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAADAwAADAAAAAEAAAAywEAANsMAADNAQAA3AwAAA8MAADQAQAA0QEAANIBAADTAQAAEAwAANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAAwMAAAwAAAABAAAAN4BAADdDAAA4AEAAN4MAAAPDAAA4gEAAOMBAADkAQAA0wEAABAMAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAAAmDAAAZAAAAAQAAACyBAAA3wwAALQEAADgDAAA4QwAALcEAAC4BAAAuQQAALoEAAAQDAAAuwQAALwEAAC9BAAAvgQAAL8EAADABAAAwQQAAMIEAADDBAAATQwAACgAAAAEAAAAmgkAAOIMAACcCQAA4wwAAOQMAACfCQAAoAkAAKEJAACiCQAAowkAAF0MAACkCQAApQkAAKYJAACnCQAAqAkAAKkJAACqCQAAqwkAAE0MAAAoAAAABAAAAKwJAADlDAAArgkAAOYMAADkDAAAsAkAAKAJAAChCQAAogkAAKMJAABdDAAAsQkAAKUJAACmCQAApwkAALIJAACpCQAAqgkAAKsJAABNDAAAKAAAAAQAAACzCQAA5wwAALUJAADoDAAA5AwAALcJAACgCQAAoQkAAKIJAACjCQAAXQwAALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAVW5leHBlY3RlZCBkYXRhIHR5cGUgZm9yIHJ1bl9lbmRzIGFycmF5IGwhIQAoAAAAQ3cQAGQAAABBAwAAEwAAAEN3EABkAAAAdAMAAB4AAABDdxAAZAAAAHgDAAAjAAAAICAuLi4gZWxlbWVudHMuLi4sCgDMISEABQAAANEhIQAOAAAAICAsCiAgbnVsbCwKYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAA4qn8OK0OOH7FbC6gMU1KgEyaqF8hLELkfkWDr4NtNVwZYvpGHRWK7hhLcgqleyytByAbTXT+okm+n+f3GpIEeHJ+ylN+hDor2UVDl/G136/umzK4FJ7RuXDHeLNBWBcRwSMKlc3WKLCDFl9q32vM34f8VnuN8jE8tje6Ri8JfJZJsJ6Qek4sL8tuSeoyCBh8xfzyH3GFS3NuukzTz7gowrWh38fgqExDkv0R4mNj/KMofOLr7ovvGQKEKFjGuf0WPvMwG5AYZta8X2XUZ8lrNzWUzEI8vU3M9/nCXHUEmgLkVFHeVYSNNLVkopK66G8Z3JOhSbkke5YFuLkA0X7GDHs7Vg0XNz5GGUPph3+FHFKN0XrCpBkhd9kV254FF+mMhgAUgjtMRpmj6hikle0/++2i5dR7gLHU18EfJ15f4lxJSOs89WXxnHG5cnU+R41CZJuS9QyOC2DNaGfT4eNQuWuIBdEFkQ3gucbvJPmDBOGXKGzT/eMq2XzR7IFAx7B2i9qozLiexvSwUd4LjJ+uhNH4ncnRpf3OVuEjg+HJR3EfoU/E/CFBIdYixYjp17F4pBddj0p1IC1jlr4w3kLr7GOYOC6bqJpWsC9YjrdR6Id/HWoqIlT2wIb23M7m7swAeoxNLzEphhwjoC5rNYdVJjX8EWXtUm++JzmV/3oBUuUTAgBBuMiEAQtJUHJpbWl0aXZlQXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBnb3QgADgkIQAiAAAAWiQhAAUAAAAoCxAAcAAAAKICAAAJAAAAEgBBjMmEAQsCEAEAQZjJhAELAyMJAgBBpMmEAQsBEwBBsMmEAQsBDQBBvMmEAQsDJkwKAEHIyYQBCwISAQBB1MmEAQsCDQMAQeDJhAELAyQSBgBB7MmEAQsCEQMAQfjJhAELAg0CAEGEyoQBCwITAQBBkMqEAQsBEABBnMqEAQsCDQEAQajKhAELAhIDAEG0yoQBCwISAgBBwMqEAQsDJSYKAEHMyoQBCwIRAgBB2MqEAQvFHukMAAAwAAAABAAAAOoMAADpDAAAMAAAAAQAAADrDAAA6QwAADAAAAAEAAAA7AwAAOkMAAAwAAAABAAAAO0MAADpDAAAMAAAAAQAAADuDAAA6QwAADAAAAAEAAAA7wwAAOkMAAAwAAAABAAAAPAMAADpDAAAMAAAAAQAAADxDAAA6QwAADAAAAAEAAAA8gwAAOkMAAAwAAAABAAAAPMMAADpDAAAMAAAAAQAAAD0DAAA6QwAADAAAAAEAAAA9QwAAOkMAAAwAAAABAAAAPYMAADpDAAAMAAAAAQAAAD3DAAA6QwAADAAAAAEAAAA+AwAAOkMAAAwAAAABAAAAPkMAADpDAAAMAAAAAQAAAD6DAAA6QwAADAAAAAEAAAA+wwAAOkMAAAwAAAABAAAAPwMAADpDAAAMAAAAAQAAAD9DAAA6QwAADAAAAAEAAAA/gwAAOkMAAAwAAAABAAAAP8MAADpDAAAMAAAAAQAAAAADQAA6QwAADAAAAAEAAAAAQ0AAOkMAAAwAAAABAAAAAINAADpDAAAMAAAAAQAAAADDQAA6QwAADAAAAAEAAAABA0AAOkMAAAwAAAABAAAAAUNAADpDAAAMAAAAAQAAAAGDQAA6QwAADAAAAAEAAAABw0AAOkMAAAwAAAABAAAAAgNAADpDAAAMAAAAAQAAAAJDQAA6QwAADAAAAAEAAAACQIAAAoNAAALAgAACw0AAAwNAAANAgAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAADMDAAAODQAANQMAAA8NAAAMDQAANwMAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAARBwAAEA0AABMHAAARDQAADA0AABUHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAIgMAABINAAAkAwAAEw0AAAwNAAAmAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAA4CAAAUDQAAEAIAABUNAAAMDQAAEgIAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAD0AQAAFg0AAPYBAAAXDQAADA0AAPgBAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAJwMAABgNAAApAwAAGQ0AAAwNAAArAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAADAHAAAaDQAAMgcAABsNAAAMDQAANAcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAAMBwAAHA0AAA4HAAAdDQAADA0AABAHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAAgcAAB4NAAAEBwAAHw0AAAwNAAAGBwAA0QEAANIBAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAAcHAAAgDQAACQcAACENAAAMDQAACwcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABdAwAAIg0AAF8DAAAjDQAADA0AAGEDAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAPQMAACQNAAA/AwAAJQ0AAAwNAABBAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAN4BAAAmDQAA4AEAACcNAAAMDQAA4gEAAOMBAADkAQAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABTAwAAKA0AAFUDAAApDQAADA0AAFcDAAD5AQAA+gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAFQMAACoNAAAXAwAAKw0AAAwNAAAaAwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAABsDAAAsDQAAHQMAAC0NAAAMDQAAHwMAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAADLAQAALg0AAM0BAAAvDQAADA0AANABAADRAQAA0gEAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAOgcAADANAAA8BwAAMQ0AAAwNAAA+BwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAACsHAAAyDQAALQcAADMNAAAMDQAALwcAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAAWBwAANA0AABgHAAA1DQAADA0AABoHAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAAgIAADYNAAAEAgAANw0AAAwNAAAGAgAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAEIDAAA4DQAARAMAADkNAAAMDQAARgMAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABYAwAAOg0AAFoDAAA7DQAADA0AAFwDAABRAwAAUgMAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAAIQcAADwNAAAjBwAAPQ0AAAwNAAAlBwAAAAIAAAECAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAPsBAAA+DQAA/QEAAD8NAAAMDQAA/wEAAAACAAABAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAABHAwAAQA0AAEkDAABBDQAADA0AAEsDAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAALgMAAEINAAAwAwAAQw0AAAwNAAAyAwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAAEwDAABEDQAATgMAAEUNAAAMDQAAUAMAAFEDAABSAwAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADpDAAAMAAAAAQAAAA4AwAARg0AADoDAABHDQAADA0AADwDAAAHAgAACAIAANMBAAANDQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADdAQAA6QwAADAAAAAEAAAANQcAAEgNAAA3BwAASQ0AAAwNAAA5BwAABwIAAAgCAADTAQAADQ0AANUBAADWAQAA1wEAANgBAADZAQAA2gEAANsBAADcAQAA3QEAAOkMAAAwAAAABAAAACYHAABKDQAAKAcAAEsNAAAMDQAAKgcAAAcCAAAIAgAA0wEAAA0NAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAABQcmltaXRpdmVBcnJheTw+ClsKAFgyIQAPAAAAZzIhAAQAAABdAAAAAQAAACgLEABwAAAAKgYAACgAAABQcmltaXRpdmVBcnJheSBkYXRhIHNob3VsZCBjb250YWluIGEgc2luZ2xlIGJ1ZmZlciBvbmx5ICh2YWx1ZXMgYnVmZmVyKQCUMiEARwAAACgLEABwAAAAJAYAAAkAAAD7lRAAXgAAAMwAAAARAAAA4AkQAGwAAACkAQAAPgAAAOAJEABsAAAA0gIAACcAAADgCRAAbAAAANICAAA9AAAAcIsQAH4AAAA0AAAABQAAAM51EABqAAAApwEAAB8AAAAkVxAAaQAAAEkAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAABaJyC5Kqr7Rxt695ZZTB0/k4m7jkYJLOcYSTiNQ4gt6aRNPG5KC1QQzZ2WuD4SBRhypH5ITzMwc3AcpD0kbPvOfDveFUdQQxVv5bQ/ivqicEam7sxQgwq8OmnkrbDT8UwGGSbbSd1M7t3XLru1Pa3m/HVOzHvjofLa8afBfIQDqQAAAAAAAAAAAQAAAEwNAAD7lRAAXgAAAMwAAAARAAAATGF5b3V0RXJyb3IABABBqOmEAQsBCABBtOmEAQsBCQBBwOmEAQsBBQBBzOmEAQsBBgBB2OmEAQsBAgBB5OmEAQsBBwBB8OmEAQsBAwBB/OmEAQvRDAEAAABEaWN0aW9uYXJ5QXJyYXkncyBkYXRhIHR5cGUgbXVzdCBtYXRjaCwgZXhwZWN0ZWQgIGdvdCAAAAA1IQAxAAAAMTUhAAUAAAASBBAAcQAAAFYCAAANAAAAEgQQAHEAAABeAgAAJQAAAERpY3Rpb25hcnlBcnJheSBtdXN0IGhhdmUgRGljdGlvbmFyeSBkYXRhIHR5cGUuAGg1IQAvAAAAEgQQAHEAAABzAgAADQAAAERpY3Rpb25hcnlBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzKS4AAACwNSEAPQAAABIEEABxAAAATwIAAAkAAABEaWN0aW9uYXJ5QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAoa2V5cykuCDYhAEAAAAASBBAAcQAAAEoCAAAJAAAATQ0AAEgAAAAEAAAATg0AAE0NAABIAAAABAAAAE8NAABNDQAASAAAAAQAAABQDQAATQ0AAEgAAAAEAAAAUQ0AAE0NAABIAAAABAAAAFINAABNDQAASAAAAAQAAABTDQAATQ0AAEgAAAAEAAAAVA0AAE0NAABIAAAABAAAAFUNAABNDQAASAAAAAQAAABuBgAAVg0AAHAGAABXDQAAWA0AAHIGAABzBgAAdAYAAHUGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAHkGAAB6BgAATQ0AAEgAAAAEAAAAewYAAFkNAAB9BgAAWg0AAFgNAAB/BgAAgAYAAIEGAACCBgAAVwYAAFgGAACDBgAAWgYAAFsGAABcBgAAhAYAAIUGAACGBgAAhwYAAE0NAABIAAAABAAAAIgGAABbDQAAigYAAFwNAABYDQAAjAYAAFQGAABVBgAAjQYAAFcGAABYBgAAjgYAAFoGAABbBgAAXAYAAI8GAABeBgAAkAYAAJEGAABNDQAASAAAAAQAAABhBgAAXQ0AAGMGAABeDQAAWA0AAGUGAABmBgAAZwYAAGgGAABXBgAAWAYAAGkGAABaBgAAWwYAAFwGAABqBgAAawYAAGwGAABtBgAATQ0AAEgAAAAEAAAAkgYAAF8NAACUBgAAYA0AAFgNAACWBgAAZgYAAGcGAACXBgAAVwYAAFgGAACYBgAAWgYAAFsGAABcBgAAmQYAAGsGAACaBgAAmwYAAE0NAABIAAAABAAAAKQGAABhDQAApgYAAGINAABYDQAAqAYAAIAGAACBBgAAqQYAAFcGAABYBgAAgwYAAFoGAABbBgAAXAYAAIQGAACFBgAAqgYAAKsGAABNDQAASAAAAAQAAACcBgAAYw0AAJ4GAABkDQAAWA0AAKAGAABzBgAAdAYAAKEGAABXBgAAWAYAAHYGAABaBgAAWwYAAFwGAAB3BgAAeAYAAKIGAACjBgAATQ0AAEgAAAAEAAAATgYAAGUNAABQBgAAZg0AAFgNAABTBgAAVAYAAFUGAABWBgAAVwYAAFgGAABZBgAAWgYAAFsGAABcBgAAXQYAAF4GAABfBgAAYAYAAERpY3Rpb25hcnlBcnJheSB7a2V5czogIHZhbHVlczogfQoAAKA5IQAXAAAAtzkhAAkAAADAOSEAAgAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBSdW5FbmRCdWZmZXIgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3Ro3DkhAFAAAAAhSRAAZgAAAMEAAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC4AAAAPAAAAGJQEABrAAAAvQAAADwAAAA+5LQ2Xu/G4ixFOEDatCG6UZ972aqE6KmHG/D5dJSpk2HhTDnwP3HEjZR4sXOcWecAAAAABAAAAAQAAAARBQAAAAAAAAQAAAAEAAAA9wsAAAAAAAAEAAAABAAAAEgIAAAAAAAABAAAAAQAAABtAwAA1zIQAHgAAADrBwAACQBB2PaEAQvJCwEAAABtDQAA+5UQAF4AAADMAAAAEQAAAExheW91dEVycm9yAM51EABqAAAAvQEAAB0AAAB1CRAAagAAAAwBAAAWAAAASW5jb3JyZWN0IHJ1biBlbmRzIHR5cGUAnDshABcAAAB1CRAAagAAAA0BAAAJAAAAdQkQAGoAAAAPAQAAGgAAAHUJEABqAAAAEwEAACEAAABJbnZhbGlkIGRhdGEgdHlwZSBmb3IgUnVuQXJyYXkuIFRoZSBkYXRhIHR5cGUgc2hvdWxkIGJlIERhdGFUeXBlOjpSdW5FbmRFbmNvZGVkAOw7IQBPAAAAdQkQAGoAAAAGAQAAEQAAAG4NAAAoAAAABAAAAG8NAABuDQAAKAAAAAQAAABwDQAAbg0AACgAAAAEAAAAcQ0AAG4NAAAoAAAABAAAAJoJAAByDQAAnAkAAHMNAAB0DQAAnwkAAKAJAAChCQAAogkAAKMJAAB1DQAApAkAAKUJAACmCQAApwkAAKgJAACpCQAAqgkAAKsJAABuDQAAKAAAAAQAAACzCQAAdg0AALUJAAB3DQAAdA0AALcJAACgCQAAoQkAAKIJAACjCQAAdQ0AALgJAAClCQAApgkAAKcJAAC5CQAAqQkAAKoJAACrCQAAbg0AACgAAAAEAAAArAkAAHgNAACuCQAAeQ0AAHQNAACwCQAAoAkAAKEJAACiCQAAowkAAHUNAACxCQAApQkAAKYJAACnCQAAsgkAAKkJAACqCQAAqwkAAHUJEABqAAAAdwEAAAkAAABSdW5BcnJheSB7cnVuX2VuZHM6ICwgdmFsdWVzOiB9Cpw9IQAUAAAAsD0hAAoAAAC6PSEAAgAAAGNvbHVtbiB0eXBlcyBtdXN0IG1hdGNoIHNjaGVtYSB0eXBlcywgZXhwZWN0ZWQgIGJ1dCBmb3VuZCAgYXQgY29sdW1uIGluZGV4IADUPSEALwAAAAM+IQALAAAADj4hABEAAABhbGwgY29sdW1ucyBpbiBhIHJlY29yZCBiYXRjaCBtdXN0IGhhdmUgdGhlIHNhbWUgbGVuZ3RoYWxsIGNvbHVtbnMgaW4gYSByZWNvcmQgYmF0Y2ggbXVzdCBoYXZlIHRoZSBzcGVjaWZpZWQgcm93IGNvdW50Q29sdW1uICcnIGlzIGRlY2xhcmVkIGFzIG5vbi1udWxsYWJsZSBidXQgY29udGFpbnMgbnVsbCB2YWx1ZXOuPiEACAAAALY+IQA2AAAAbnVtYmVyIG9mIGNvbHVtbnMoKSBtdXN0IG1hdGNoIG51bWJlciBvZiBmaWVsZHMoKSBpbiBzY2hlbWEA/D4hABIAAAAOPyEAHgAAACw/IQALAAAAbXVzdCBlaXRoZXIgc3BlY2lmeSBhIHJvdyBjb3VudCBvciBhdCBsZWFzdCBvbmUgY29sdW1udGFyZ2V0IHNjaGVtYSBpcyBub3Qgc3VwZXJzZXQgb2YgY3VycmVudCBzY2hlbWEgdGFyZ2V0PSBjdXJyZW50PQAAhj8hADcAAAC9PyEACQAAAKxeEABnAAAAYQIAABYAAABhc3NlcnRpb24gZmFpbGVkOiAob2Zmc2V0ICsgbGVuZ3RoKSA8PSBzZWxmLm51bV9yb3dzKCkAAKxeEABnAAAAmQIAAAkAAAAAAAAAQ2Fubm90IGNvbnZlcnQgbnVsbGFibGUgU3RydWN0QXJyYXkgdG8gUmVjb3JkQmF0Y2gsIHNlZSBTdHJ1Y3RBcnJheSBkb2N1bWVudGF0aW9uAAAANEAhAFEAAACsXhAAZwAAADoDAAAJAAAAAT8QAIcAAABjAQAADAAAAEludmFsaWQgdGltZXpvbmUgIiI6IG9ubHkgb2Zmc2V0IGJhc2VkIHRpbWV6b25lcyBzdXBwb3J0ZWQgd2l0aG91dCBjaHJvbm8tdHogZmVhdHVyZbBAIQASAAAAwkAhAEIAAACxBxAAbQAAAEwAAAAKAEHAgoUBCwEJAEHQgoUBCwFjAEHggoUBCwLnAwBB8IKFAQsCDycAQYCDhQELA5+GAQBBkIOFAQsDP0IPAEGgg4UBCwN/lpgAQbCDhQELBP/g9QUAQcCDhQELBP/JmjsAQdCDhQELBf/jC1QCAEHgg4UBCwX/53ZIFwBB8IOFAQsF/w+l1OgAQYCEhQELBv+fck4YCQBBkISFAQsG/z96EPNaAEGghIUBCwf/f8akfo0DAEGwhIUBCwf//8Bv8oYjAEHAhIUBC+AC//+JXXhFYwEAAAAAAAAAAP//Y6eztuANAAAAAAAAAAD//+eJBCPHigAAAAAAAAAA//8PYy1ex2sFAAAAAAAAAP//n97Frck1NgAAAAAAAAD//z+yusngGR4CAAAAAAAA//9/9krhxwItFQAAAAAAAP///6DtzM4bwtMAAAAAAAD///9JSAEUFpVFCAAAAAAA////49IMyNzSt1IAAAAAAP///+c8gNCfPC47AwAAAAD///8PYQIlPl7OTyAAAAAA////n8oXcm2uDx5DAQAAAP///z/q7XRG0JwsnwwAAAD///9/JkuRwCIgvjd+AAAA/////4DvrIVbQW0t7gQAAP////8JW8E4k41Exk0xAAD/////Y46NN8CHrb4J7QEA/////+ePhyuCTcdyYUITAP////8Pn0uzFQfJe86XwAD/////nzb0ANlG2tUQ7oUH/////z8iigl6xIZaqEw7SwBBsIeFAQvlCPf///////////////////+d////////////////////Gfz///////////////////HY//////////////////9hef7/////////////////wb3w/////////////////4FpZ/////////////////8BHwr6////////////////ATZlxP///////////////wEc9Kv9//////////////8BGIm36P//////////////AfBaKxf//////////////wFgjbHn9v////////////8BwIXvDKX/////////////AYA5W4Fy/P///////////wEAP5ANedz///////////8BAHaih7qc/v//////////AQCcWExJH/L//////////wEAGHb73Dh1//////////8BAPCc0qE4lPr/////////AQBgITpSNsrJ/////////wEAwE1FNh/m4f3///////8BAIAJtR44/dLq////////AQAAXxIzMeQ9LP///////wEAALa3/uvparr3//////8BAAAcLfM3Iy1Irf//////AQAAGMN/L2DD0cT8/////wEAAPCe/drBoTGw3/////8BAABgNeiNklHw4bz+////AQAAwBUSi7kvY9Ng8////wEAAIDZtG4/3d9ByIH///8BAAAAfxBTeqS+ktIR+///AQAAAPakPsdscrs5ss7//wEAAACccXLIP3hSQfYS/v8BAAAAGHB41H2yOI2evez/AQAAAPBgtEzq+DaEMWg//wEAAABgyQv/JrklKu8RevgBAAAAwN119oU7eaVXs8S0IGlzIHRvbyBzbWFsbCB0byBzdG9yZSBpbiBhIERlY2ltYWwxMjggb2YgcHJlY2lzaW9uIC4gTWluIGlzIAAAAAEAAAAAAAAAEEYhADQAAABERiEACQAAACBpcyB0b28gbGFyZ2UgdG8gc3RvcmUgaW4gYSBEZWNpbWFsMTI4IG9mIHByZWNpc2lvbiAuIE1heCBpcyAAAAABAAAAAAAAAGhGIQA0AAAAnEYhAAkAAAAmTWF4IHByZWNpc2lvbiBvZiBhIERlY2ltYWwxMjggaXMgLCBidXQgZ290IMFGIQAhAAAA4kYhAAoAAAAAAAAACQAAAGMAAADnAwAADycAAJ+GAQA/Qg8Af5aYAP/g9QX/yZo7AAAAAPf///+d////Gfz///HY//9hef7/wb3w/4FpZ/8BHwr6ATZlxCBpcyB0b28gc21hbGwgdG8gc3RvcmUgaW4gYSBEZWNpbWFsMzIgb2YgcHJlY2lzaW9uIAABAAAAAAAAAExHIQAzAAAAREYhAAkAAAAgaXMgdG9vIGxhcmdlIHRvIHN0b3JlIGluIGEgRGVjaW1hbDMyIG9mIHByZWNpc2lvbiAAAQAAAAAAAACYRyEAMwAAAJxGIQAJAAAACU1heCBwcmVjaXNpb24gb2YgYSBEZWNpbWFsMzIgaXMgAAAA5UchACAAAADiRiEACgBBoJCFAQvxAwkAAAAAAAAAYwAAAAAAAADnAwAAAAAAAA8nAAAAAAAAn4YBAAAAAAA/Qg8AAAAAAH+WmAAAAAAA/+D1BQAAAAD/yZo7AAAAAP/jC1QCAAAA/+d2SBcAAAD/D6XU6AAAAP+fck4YCQAA/z96EPNaAAD/f8akfo0DAP//wG/yhiMA//+JXXhFYwH//2Ons7bgDQAAAAAAAAAA9/////////+d/////////xn8////////8dj///////9hef7//////8G98P//////gWln//////8BHwr6/////wE2ZcT/////ARz0q/3///8BGIm36P///wHwWisX////AWCNsef2//8BwIXvDKX//wGAOVuBcvz/AQA/kA153P8BAHaih7qc/gEAnFhMSR/yIGlzIHRvbyBzbWFsbCB0byBzdG9yZSBpbiBhIERlY2ltYWw2NCBvZiBwcmVjaXNpb24gAAEAAAAAAAAASEkhADMAAABERiEACQAAACBpcyB0b28gbGFyZ2UgdG8gc3RvcmUgaW4gYSBEZWNpbWFsNjQgb2YgcHJlY2lzaW9uIAABAAAAAAAAAJRJIQAzAAAAnEYhAAkAAAASTWF4IHByZWNpc2lvbiBvZiBhIERlY2ltYWw2NCBpcyAAAADhSSEAIAAAAOJGIQAKAEHAlIUBCwEJAEHglIUBCwFjAEGAlYUBCwLnAwBBoJWFAQsCDycAQcCVhQELA5+GAQBB4JWFAQsDP0IPAEGAloUBCwN/lpgAQaCWhQELBP/g9QUAQcCWhQELBP/JmjsAQeCWhQELBf/jC1QCAEGAl4UBCwX/53ZIFwBBoJeFAQsF/w+l1OgAQcCXhQELBv+fck4YCQBB4JeFAQsG/z96EPNaAEGAmIUBCwf/f8akfo0DAEGgmIUBCwf//8Bv8oYjAEHAmIUBCwj//4ldeEVjAQBB4JiFAQsI//9jp7O24A0AQYCZhQELCP//54kEI8eKAEGgmYUBCwn//w9jLV7HawUAQcCZhQELCf//n97Frck1NgBB4JmFAQsK//8/srrJ4BkeAgBBgJqFAQsK//9/9krhxwItFQBBoJqFAQsK////oO3MzhvC0wBBwJqFAQsL////SUgBFBaVRQgAQeCahQELC////+PSDMjc0rdSAEGAm4UBCwz////nPIDQnzwuOwMAQaCbhQELDP///w9hAiU+Xs5PIABBwJuFAQsN////n8oXcm2uDx5DAQBB4JuFAQsN////P+rtdEbQnCyfDABBgJyFAQsN////fyZLkcAiIL43fgBBoJyFAQsO/////4DvrIVbQW0t7gQAQcCchQELDv////8JW8E4k41Exk0xAEHgnIUBCw//////Y46NN8CHrb4J7QEAQYCdhQELD//////nj4crgk3HcmFCEwBBoJ2FAQsP/////w+fS7MVB8l7zpfAAEHAnYUBCxD/////nzb0ANlG2tUQ7oUHAEHgnYUBCxD/////PyKKCXrEhlqoTDtLAEGAnoUBCxH/////f1ZlX8SsQ4mT/lDwAgBBoJ6FAQsR//////9g9bmrv6Rcw/EpYx0AQcCehQELEv//////yZVDtXxvnqFxo98lAQBB4J6FAQsS///////j2aMU31owUHBivHoLAEGAn4UBCxL//////+eCZs62jOMhY9hby3IAQaCfhQELE///////Dx0BECR/41Lfc5bxewQAQcCfhQELE///////nyILoGj34jy5huBv1ywAQeCfhQELFP//////P1pvQBaq3WA8Q8VeasABAEGAoIUBCxT//////3+GWYTepKjIW6C0syeEEQBBoKCFAQsU////////QH8rsXCW1pVDDgWNKa8AQcCghQELFf///////4n4sutm4GHao44ygp/XBgBB4KCFAQsV////////Y7X9NAXE0odmkvkVO2xEAEGAoYUBCxb////////nFekRNKg7TgG4v9tOOqwCAEGgoYUBCxb///////8P2xqzCJJUDg0wfZUUR7oaAEHAoYUBCxf///////+fjgz/VrRNj4Lg49bNxkYLAQBB4KGFAQsX////////P5J99mULCZkZxeZkCsTDcAoAQYCihQELF////////3+256D7cVr6/7ID8WeopWdoAEGgooUBC6AF/////////yANSdRziMf//SRqD5R4DBQEAAAAAAAAAAD/////////SYPaSoZUy/3rcSWayLV8yCgAAAAAAAAAAP/////////jIInsPk3x6TdzdgXWGd/UlwEAAAAAAAAA/////////+dIWz11BG0jL4CgNlwCt1DuDwAAAAAAAAD/////////D9mQZZQsQmLXAUUimhcmJ0+fAAAAAAAAAP////////+feqj3y72V1mkSslYF7HyHFzkGAAAAAAAA/////////z/KlKz3adlhIrj0YjU44UrrOj4AAAAAAAD/////////f+bPvawjftJXMY/dFTLM7DBNbgIAAAAAAP//////////AB9qv2TtOG7tl6fa9Pk/6QNPGAAAAAAA//////////8JNiV670U5Tkbvi4qQw38cJxbzAAAAAAD//////////2McdMVauzwOv1h3aaWj/RyH3X4JAAAAAP//////////5xuJtotRX452d6kedmToIUen9F4AAAAA//////////8PF1shdS+5j6GqnjKd7BNTx4iOtQMAAAD//////////5/mjk2T2judT6oy+iM+xz7JV5EXJQAAAP//////////PwKVB8GJViQcp/rFZ23Ic9xtretyAQAA//////////9/FtJLimFhaxmHyrsNRtSFnErGNH0OAAD////////////gNPZmz80x/kbpVYm8Sjod6r4P5JAAAP///////////8kQngUaCvLtxRxbXV3rRiQldZ3oqAUA////////////46csOARldEu7H4+lpTHFanOTJhaZOAD////////////njr4xKvKL8lA9l3d48LMrgsKB3fo1Av///////////w+VcfGldXd5KWXoq7RkB7UVmRGnzBsWAEHgp4UBC+IU9/////////////////////////////////////////+d/////////////////////////////////////////xn8////////////////////////////////////////8dj///////////////////////////////////////9hef7//////////////////////////////////////8G98P//////////////////////////////////////gWln//////////////////////////////////////8BHwr6/////////////////////////////////////wE2ZcT/////////////////////////////////////ARz0q/3///////////////////////////////////8BGIm36P///////////////////////////////////wHwWisX////////////////////////////////////AWCNsef2//////////////////////////////////8BwIXvDKX//////////////////////////////////wGAOVuBcvz/////////////////////////////////AQA/kA153P////////////////////////////////8BAHaih7qc/v///////////////////////////////wEAnFhMSR/y////////////////////////////////AQAYdvvcOHX///////////////////////////////8BAPCc0qE4lPr//////////////////////////////wEAYCE6UjbKyf//////////////////////////////AQDATUU2H+bh/f////////////////////////////8BAIAJtR44/dLq/////////////////////////////wEAAF8SMzHkPSz/////////////////////////////AQAAtrf+6+lquvf///////////////////////////8BAAAcLfM3Iy1Irf///////////////////////////wEAABjDfy9gw9HE/P//////////////////////////AQAA8J792sGhMbDf//////////////////////////8BAABgNeiNklHw4bz+/////////////////////////wEAAMAVEou5L2PTYPP/////////////////////////AQAAgNm0bj/d30HIgf////////////////////////8BAAAAfxBTeqS+ktIR+////////////////////////wEAAAD2pD7HbHK7ObLO////////////////////////AQAAAJxxcsg/eFJB9hL+//////////////////////8BAAAAGHB41H2yOI2evez//////////////////////wEAAADwYLRM6vg2hDFoP///////////////////////AQAAAGDJC/8muSUq7xF6+P////////////////////8BAAAAwN119oU7eaVXs8S0/////////////////////wEAAACAqZqgO1O8dmwBrw/9////////////////////AQAAAACfCkZUQFujPA7WnOL///////////////////8BAAAAADZqvEqDkGFejlwg2v7//////////////////wEAAAAAHCZc6yClz6+PnUOF9P//////////////////AQAAAAAYfZkxSXMc3pwnpDSN//////////////////8BAAAAAPDi/u/bgBytIIxpDoT7/////////////////wEAAAAAYN30X5cIHcNGeR+QKNP/////////////////AQAAAADApZC/6VUin8O8OqGVP/7///////////////8BAAAAAIB5pnshW1c3pF9LTNh77v///////////////wEAAAAAAL+A1E6PaSlqvPH6ctZQ////////////////AQAAAAAAdgdNFJkfniVccc19YCj5//////////////8BAAAAAACcSgLL+jsteJltBurEk7v//////////////wEAAAAAABjqFu7LV8Sx/kdAJLHFU/3/////////////AQAAAAAA8CTlTPdtq/Hyz4Jq67hF5f////////////8BAAAAAABgcfMAqUuycH0fHCkyObn0/v///////////wEAAAAAAMBtggma9PZm5joZm/U7PI/1////////////AQAAAAAAgEkYXwSOpQUATfwOmFdamJf///////////8BAAAAAAAA3/K2K4x3OAAC25Xwa4fz6/v//////////wEAAAAAAAC2fCW1eas0AhSO2mU3SoM31///////////AQAAAAAAABzfdhPBsg4WyIyJ+inmICto/v////////8BAAAAAAAAGLekwor7ktzQf1/Jo/1IrxHw/////////wEAAAAAAADwJm+aa9O9nSj+ut1l6NnYsGD/////////AQAAAAAAAGCFVwg0Qmoplu1NqfoTg3joxvn///////8BAAAAAAAAwDVrUwiWJp7dRwudyscetRTFwf///////wEAAAAAAACAGTBCU9yBLajOcCLqzTMTz7KR/f//////AQAAAAAAAAD/4JVAmxLHkRJoWCULBsAW/LDn//////8BAAAAAAAAAPbJ2oUQusaxuRB0dW88gOPY6Qz//////wEAAAAAAAAAnOOLOqVEw/FAp4iWWlwC43gigfb/////AQAAAAAAAAAY5HZJdK6gcYmIVuGJmxfeuFgLof////8BAAAAAAAAAPDopN6K0EZwXlVhzWIT7Kw4d3FK/P///wEAAAAAAAAAYBlxsmwlxGKwVc0F3ME4wTaobuja////AQAAAAAAAADA/Wr4Pnap2+NYBTqYkjeMI5JSFI3+//8BAAAAAAAAAIDpLbR1np6U5ng1RPK5K3pjtTnLgvH//wEAAAAAAAAAAB/LCZkwMs4BuRaqdkO1xeIVQfAbb///AQAAAAAAAAAANu9h+uX1DRI646SiohS529qKYhdX+v8BAAAAAAAAAAAcWNPH+5qLtETgcFpazjqVjGzZ6WbH/wEAAAAAAAAAABhxQc7VDXQNr8JoiIcPTNR9PX4iBcr9AQAAAAAAAAAA8GqODlqKiIbWmhdUS5v4Supm7lgz5OkgaXMgdG9vIHNtYWxsIHRvIHN0b3JlIGluIGEgRGVjaW1hbDI1NiBvZiBwcmVjaXNpb24gAQAAAAAAAABgXSEANAAAAERGIQAJAAAAIGlzIHRvbyBsYXJnZSB0byBzdG9yZSBpbiBhIERlY2ltYWwyNTYgb2YgcHJlY2lzaW9uIAEAAAAAAAAArF0hADQAAACcRiEACQAAAExNYXggcHJlY2lzaW9uIG9mIGEgRGVjaW1hbDI1NiBpcyAAAPldIQAhAAAA4kYhAAoAAAB7DQAADAAAAAQAAAB8DQAAfQ0AAMcHAEHMvIUBC6EHAQAAAH4NAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AOJfEABrAAAADwsAAA4AAADseRAAawAAAEEDAAAVAAAA4l8QAGsAAADoAQAAFwAAAOJfEABrAAAAVAsAAAEAAABFcnJvcgAAAOJfEABrAAAA1QwAAA4AAADiXxAAawAAAM8MAAAOAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpITEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5SUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxgXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5kYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYgAAAOUqEABlAAAACAEAABsAAAABAAAAAAAAAAIAQfbDhQELAQUAQYDEhQELESAAIOkuAAAABGIhAAEAAAACAEGaxIUBCwEDAEGkxIUBCwUgAADpAgBBssSFAQsBBgBBvMSFAQsFIAAA6QIAQcrEhQELAQkAQdTEhQELwQIgAADpd3JpdGluZyByZmMzMzM5IGRhdGV0aW1lIHRvIHN0cmluZyBzaG91bGQgbmV2ZXIgZmFpbHuEEABiAAAAfwIAAA4AAADOdRAAagAAAL0BAAAdAAAAdmFsdWUgbGVuZ3RoICgpIG9mIHRoZSBhcnJheSBtdXN0ID49IDAAAKxiIQAOAAAAumIhABgAAAANQBAAfAAAADsAAAAJAAAADUAQAHwAAABAAAAAHQAAAIpAEAB9AAAAZgAAABsAAACKQBAAfQAAABQBAAAYAAAAikAQAH0AAAAbAQAAPAAAAIpAEAB9AAAAJwEAACIAAACKQBAAfQAAACUBAAAXAAAAyCwQAGAAAACWAwAAOQAAAC0AAADILBAAYAAAAPYFAAAfAAAAMC4AAAEAAAAAAAAAeGMhAAIAAAACAAAAAAAAAAIAQaDHhQELkwEgAADgAgAAAAAAAAABAAAAAgAAAAEAAAAwAACoAQAAAAAAAAAEYiEAAQAAAAIAAAAAAAAAAQAAAAEAAAAAAAAAMAAAiAAAAAD61TLxRr5t8zrUgBYveJJYp0gM8Gdfk6HyZ435W3Nf/Q242YaB7uLOK1S812i5lgA3gQvLseTGTt+i9g7rbmEY//////////8oZCEAQcTIhQELuh4EAAAABAAAAH8NAACADQAAgA0AAAAAAAAEAAAABAAAAH8NAACADQAAgA0AAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAIJVEABoAAAAhgAAACYAAACvOQRL4Rz3M6BSkd6ERkmNK0wkXtFX+YAWCn4Fj6VnYc51EABqAAAApwEAAB8AAABuBRAAcAAAALIAAAAjAAAAU3RyaW5nAADwZCEABgAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIFZpZXdBcnJheSBvZiBsZW5ndGggAAAAAGUhACUAAAAlZSEACAAAAC1lIQAUAAAAbgUQAHAAAAAyAQAACQAAAEJpbmFyeQAAbGUhAAYAAABuBRAAcAAAALEBAAAjAAAAVmlld0FycmF5ClsKAQAAAAAAAACMZSEADAAAAF0AAACBDQAAPAAAAAQAAACCDQAAgQ0AADwAAAAEAAAAgw0AAIENAAA8AAAABAAAAEQGAACEDQAARgYAAIUNAACGDQAASAYAADcGAAA4BgAAOQYAAIcNAAA7BgAAPAYAAD0GAAA+BgAAPwYAAEAGAABBBgAAQgYAAEMGAACBDQAAPAAAAAQAAAAxBgAAiA0AADMGAACJDQAAhg0AADYGAAA3BgAAOAYAADkGAACHDQAAOwYAADwGAAA9BgAAPgYAAD8GAABABgAAQQYAAEIGAABDBgAAbgUQAHAAAAAvAwAAFgAAAG4FEABwAAAAZwMAABUAAABuBRAAcAAAAGkDAAAmAAAAikAQAH0AAAAUAQAAGAAAAIpAEAB9AAAAUwEAAD0AAACKQBAAfQAAAFMBAAAnAAAAikAQAH0AAABlAQAAHgAAAIpAEAB9AAAAaAEAABoAAACKQBAAfQAAAHABAAAbAAAAikAQAH0AAAA7AQAAHwAAAIpAEAB9AAAAgQEAABsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAADj/9aYBcp+WmvV4R6JQCoke7I8HJu1h/yBm9JjW7WZ7pXGSEtF/rhGs2cet9Q4ijLXMhAAeAAAAOsHAAAJAAAAig0AABQAAAAEAAAAiw0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA+5UQAF4AAADMAAAAEQAAAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAIwNAAAMAAAABAAAAI0NAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yAM51EABqAAAAvQEAAB0AAADQBhAAawAAANYAAAApAAAAAQAAAAAAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBMaXN0QXJyYXksIGV4cGVjdGVkICBnb3QgAAAAbGkhACQAAACQaSEAFAAAAKRpIQAFAAAATm9uLW51bGxhYmxlIGZpZWxkIG9mIExpc3RBcnJheSAgY2Fubm90IGNvbnRhaW4gbnVsbHMAAADEaSEAFgAAANppIQAKAAAA5GkhABUAAABMaXN0QXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBmb3IgAAABAAAAAAAAABRqIQAdAAAApGkhAAUAAAAxaiEABQAAAE1heCBvZmZzZXQgb2YgIGV4Y2VlZHMgbGVuZ3RoIG9mIHZhbHVlcyBYaiEADgAAAGZqIQAaAAAATGFyZ2UAAACQaiEABQAAANAGEABrAAAADgEAADYAAADQBhAAawAAAF4BAAATAAAA0AYQAGsAAABfAQAAFQAAAEV4cGVjdGVkIGluZmFsbGlibGUgY3JlYXRpb24gb2YgR2VuZXJpY0xpc3RBcnJheSBmcm9tIEFycmF5RGF0YVJlZiBmYWlsZWQAAADQBhAAawAAALsBAAAOAAAA0AYQAGsAAADuAQAAFgAAAFtMYXJnZV1MaXN0QXJyYXkncyBjaGlsZCBkYXRhdHlwZSAgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgTGlzdCdzIGRhdGF0eXBlIAAAPGshACIAAABeayEALAAAAFtMYXJnZV1MaXN0QXJyYXkncyBkYXRhdHlwZSBtdXN0IGJlIFtMYXJnZV1MaXN0QXJyYXkoKS4gSXQgaXMgAACcayEAPgAAAExpc3RBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzIGFycmF5KSwgaGFkIAAA5GshAEIAAABMaXN0QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAodmFsdWUgb2Zmc2V0cyksIGhhZCAwbCEASAAAAI4NAAA4AAAABAAAAI8NAACODQAAOAAAAAQAAACQDQAAjg0AADgAAAAEAAAA+AQAAJENAAD6BAAAkg0AAJMNAAD8BAAA/QQAAP4EAADtBAAAlA0AAO8EAADwBAAA8QQAAPIEAADzBAAA9AQAAPUEAAD2BAAA9wQAAI4NAAA4AAAABAAAAOUEAACVDQAA5wQAAJYNAACTDQAA6gQAAOsEAADsBAAA7QQAAJQNAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAABMaXN0QXJyYXkKWwoBAAAAAAAAAFBtIQAMAAAAXQAAAJYIEABqAAAARQAAACkAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBNYXBBcnJheSwgZXhwZWN0ZWQgAIBtIQA3AAAApGkhAAUAAABNYXBBcnJheSBlbnRyaWVzIG11c3QgY29udGFpbiB0d28gY2hpbGRyZW4sIGdvdCDIbSEAMAAAAE1hcEFycmF5IGV4cGVjdGVkIGRhdGEgdHlwZSAAbiEAHAAAAKRpIQAFAAAAMWohAAUAAABNYXBBcnJheSBlbnRyaWVzIGNhbm5vdCBjb250YWluIG51bGxzIGV4Y2VlZHMgbGVuZ3RoIG9mIGVudHJpZXMgWGohAA4AAABZbiEAGwAAAJYIEABqAAAAhAAAAEAAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RllggQAGoAAADSAAAAEwAAAJYIEABqAAAA0wAAABUAAABFeHBlY3RlZCBpbmZhbGxpYmxlIGNyZWF0aW9uIG9mIE1hcEFycmF5IGZyb20gQXJyYXlEYXRhIGZhaWxlZAAAlggQAGoAAAD3AAAADgAAAJYIEABqAAAAHwEAABcAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBhcnJheSB3aXRoIDIgZmllbGRzLCBoYXZlICBmaWVsZHMAADxvIQA7AAAAd28hAAcAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHN0cnVjdCBhcnJheSBjaGlsZCwgZm91bmQgkG8hADQAAABNYXBBcnJheSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBjaGlsZCBhcnJheSAodmFsdWVzIGFycmF5KSwgaGFkIAAAAMxvIQBBAAAATWFwQXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiBhIHNpbmdsZSBidWZmZXIgb25seSAodmFsdWUgb2Zmc2V0cyksIGhhZCAAGHAhAEcAAABNYXBBcnJheSBleHBlY3RlZCBBcnJheURhdGEgd2l0aCBEYXRhVHlwZTo6TWFwIGdvdCAAaHAhADMAAACXDQAAZAAAAAQAAACYDQAAlw0AAGQAAAAEAAAAsgQAAJkNAAC0BAAAmg0AAJsNAAC3BAAAuAQAALkEAAC6BAAAlA0AALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAMEEAADCBAAAwwQAAE1hcEFycmF5ClsKaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogVGhpcyBzaG91bGQgYmUgYSBtYXAgdHlwZS4AF3EhAEQAAACWCBAAagAAAMIBAAASAAAA4AkQAGwAAADJAgAAEgAAAG4FEABwAAAArwMAABcAAACxBxAAbQAAAEwAAAAKAAAAb2Zmc2V0IG92ZXJmbG93AAZHEABpAAAARgAAADQAAABsZW5ndGggb3ZlcmZsb3cABkcQAGkAAABHAAAALgAAAE1lbW9yeSBwb2ludGVyIGlzIG5vdCBhbGlnbmVkIHdpdGggdGhlIHNwZWNpZmllZCBzY2FsYXIgdHlwZeRxIQA8AAAABkcQAGkAAAChAAAAKgAAAE1lbW9yeSBwb2ludGVyIGZyb20gZXh0ZXJuYWwgc291cmNlIChlLmcsIEZGSSkgaXMgbm90IGFsaWduZWQgd2l0aCB0aGUgc3BlY2lmaWVkIHNjYWxhciB0eXBlLiBCZWZvcmUgaW1wb3J0aW5nIGJ1ZmZlciB0aHJvdWdoIEZGSSwgcGxlYXNlIG1ha2Ugc3VyZSB0aGUgYWxsb2NhdGlvbiBpcyBhbGlnbmVkLgAAOHIhAK4AAAAGRxAAaQAAAKYAAAARAAAAU2NhbGFyQnVmZmVyAAAAAAgAAAAEAAAAaA0AAAAAAAAIAAAABAAAAJwNAAAIQRAAeAAAADEAAAAjAAAACEEQAHgAAAAyAAAAGQAAAAhBEAB4AAAANAAAABwAAAAIQRAAeAAAAMEAAAAeAAAAgUEQAHQAAACZAAAAHQAAABIBAEGI54UBCwEQAEGU54UBCwISAwBBoOeFAQsBDQBBrOeFAQsCEwEAQbjnhQELAg0CAEHE54UBCwMjCQIAQdDnhQELAhECAEHc54UBCwESAEHo54UBCwIRAwBB9OeFAQsDJSYKAEGA6IUBCwMkEgYAQYzohQELAhABAEGY6IUBCwISAgBBpOiFAQsBEwBBsOiFAQsCDQEAQbzohQELAg0DAEHI6IUBCwMmTAoAQdTohQELAhMCAEHg6IUBC/0BaW5jb21wYXRpYmxlIGRhdGEgdHlwZSBmb3IgYnVpbGRlciwgZXhwZWN0ZWQgIGdvdCAAAGB0IQAtAAAAjXQhAAUAAACBQRAAdAAAALwAAAAJAAAAf2oQAGMAAAAsAAAACwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAL6cKpGRNjRgxUhAFxEOmzQKUbMsEqoS6gtZ3tvU7Lw51zIQAHgAAADrBwAACQBB6OqFAQvpBAEAAACdDQAAng0AABQAAAAEAAAAnw0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAoA0AAAwAAAAEAAAAoQ0AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3JMYXlvdXRFcnJvcgAAznUQAGoAAACnAQAAHwAAAM51EABqAAAAvQEAAB0AAABCb29sZWFuQXJyYXkKWwpdQ3chAAEAAABNChAAbgAAAFsAAAANAAAAVHJ5aW5nIHRvIGFjY2VzcyBhbiBlbGVtZW50IGF0IGluZGV4ICBmcm9tIGEgQm9vbGVhbkFycmF5IG9mIGxlbmd0aCBcdyEAJQAAAIF3IQAfAAAATQoQAG4AAADGAAAACQAAAKINAAAsAAAABAAAAKMNAAABAEHc74UBC8cOog0AACwAAAAEAAAAAgMAAKQNAAAEAwAApQ0AAKYNAAAHAwAACAMAAAkDAAAKAwAACwMAAAwDAAANAwAADgMAAA8DAAAQAwAAEQMAABIDAAATAwAAFAMAANB3IQBCb29sZWFuQXJyYXkgZXhwZWN0ZWQgQXJyYXlEYXRhIHdpdGggdHlwZSAgZ290IAA4eCEAKgAAAGJ4IQAFAAAATQoQAG4AAACGAQAACQAAAAEAAABNChAAbgAAAJIBAAApAAAAQm9vbGVhbkFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gYSBzaW5nbGUgYnVmZmVyIG9ubHkgKHZhbHVlcyBidWZmZXIpAAAAnHghAEUAAABNChAAbgAAAI0BAAAJAAAAsQcQAG0AAABbAAAALgAAAHVzZSBTdHJ1Y3RBcnJheTo6dHJ5X25ld193aXRoX2xlbmd0aCBvciBTdHJ1Y3RBcnJheTo6bmV3X2VtcHR5X2ZpZWxkcyB0byBjcmVhdGUgYSBzdHJ1Y3QgYXJyYXkgd2l0aCBubyBmaWVsZHMgc28gdGhhdCB0aGUgbGVuZ3RoIGNhbiBiZSBzZXQgY29ycmVjdGx5SW5jb3JyZWN0IG51bWJlciBvZiBudWxscyBmb3IgU3RydWN0QXJyYXksIGV4cGVjdGVkIAAAAKF5IQA0AAAAYnghAAUAAABGb3VuZCB1bm1hc2tlZCBudWxscyBmb3Igbm9uLW51bGxhYmxlIFN0cnVjdEFycmF5IGZpZWxkIOh5IQA4AAAASW5jb3JyZWN0IGFycmF5IGxlbmd0aCBmb3IgU3RydWN0QXJyYXkgZmllbGQgLCBleHBlY3RlZCAoeiEALQAAAFV6IQALAAAAYnghAAUAAABJbmNvcnJlY3QgZGF0YXR5cGUgZm9yIFN0cnVjdEFycmF5IGZpZWxkIAAAAHh6IQApAAAAVXohAAsAAABieCEABQAAAEluY29ycmVjdCBudW1iZXIgb2YgYXJyYXlzIGZvciBTdHJ1Y3RBcnJheSBmaWVsZHMsIGV4cGVjdGVkILx6IQA8AAAAYnghAAUAAABjYW5ub3QgdXNlIFN0cnVjdEFycmF5OjpuZXdfdW5jaGVja2VkIGlmIHRoZXJlIGFyZSBubyBmaWVsZHMsIGxlbmd0aCBpcyB1bmtub3duALEHEABtAAAA4AAAADMAAACxBxAAbQAAAAkBAAANAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZbEHEABtAAAAFwEAABIAAACxBxAAbQAAAB4BAAAVAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogU3RydWN0IGFycmF5J3MgZGF0YSB0eXBlIGlzIG5vdCBzdHJ1Y3QhAAAAwHshAFEAAACxBxAAbQAAADIBAAASAAAAsQcQAG0AAAA6AQAAEgAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBTdHJ1Y3RBcnJheSBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAPHwhAE8AAACxBxAAbQAAAEwBAAAJAAAApw0AADQAAAAEAAAAqA0AAKcNAAA0AAAABAAAAIcBAACpDQAAiQEAAKoNAACrDQAAjAEAAKwNAACtDQAAjwEAAK4NAACRAQAAkgEAAJMBAACUAQAAlQEAAJYBAACXAQAAmAEAAJkBAABTdHJ1Y3RBcnJheQotLSB2YWxpZGl0eToKWwpdClsKLS0gY2hpbGQgOiAiIiAoKQorfSEACQAAADR9IQADAAAAN30hAAMAAAA6fSEAAgAAAApVbmFibGUgdG8gZG93bmNhc3QgdG8gZGljdGlvbmFyeSBhcnJheQA6GRAAXwAAAEoCAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIEJvb2xlYW5BcnJheQAAOhkQAF8AAADtAgAACgAAAHN0cnVjdCBhcnJheToZEABfAAAAiAMAAB4AAACxBxAAbQAAAEwAAAAKAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHR5cGVkIGFycmF5IHRocm91Z2ggYXNfbnVsbF9hcnJheQA6GRAAXwAAAAcDAAABAAAAVW5hYmxlIHRvIGRvd25jYXN0IHRvIHR5cGVkIGFycmF5IHRocm91Z2ggYXNfc3RydWN0X2FycmF5AAAAOhkQAF8AAAAIAwAAAQAAAFVuYWJsZSB0byBkb3duY2FzdCB0byB0eXBlZCBhcnJheSB0aHJvdWdoIGFzX3VuaW9uX2FycmF5OhkQAF8AAAAJAwAAAQAAAFVuYWJsZSB0byBkb3duY2FzdCB0byB0eXBlZCBhcnJheSB0aHJvdWdoIGFzX21hcF9hcnJheQAAOhkQAF8AAAAKAwAAAQAAAP//////////GH8hAEGw/oUBC6UBZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAGx/IQAzAAAAtW0QAGoAAACGAgAACQAAAOdMUGqIspqzZUn4sU20XNLXMhAAeAAAAOsHAAAJAEHg/4UBC8IpAQAAALENAAD7lRAAXgAAAMwAAAARAAAATGF5b3V0RXJyb3IAsg0AAM51EABqAAAAvQEAAB0AAABUeXBlIElkcyBhbmQgT2Zmc2V0cyBsZW5ndGhzIG11c3QgbWF0Y2gA4AkQAGwAAADSAAAAHgAAAE9mZnNldHMgbXVzdCBiZSBwb3NpdGl2ZSBhbmQgd2l0aGluIHRoZSBsZW5ndGggb2YgdGhlIEFycmF5VHlwZSBJZHMgdmFsdWVzIG11c3QgbWF0Y2ggb25lIG9mIHRoZSBmaWVsZCB0eXBlIGlkcwDgCRAAbAAAANQAAAAXAAAAU3BhcnNlIHVuaW9uIGNoaWxkIGFycmF5cyBtdXN0IGJlIGVxdWFsIGluIGxlbmd0aCB0byB0aGUgbGVuZ3RoIG9mIHRoZSB1bmlvblVuaW9uIGZpZWxkcyBsZW5ndGggbXVzdCBtYXRjaCBjaGlsZCBhcnJheXMgbGVuZ3RoAADgCRAAbAAAAOYAAABQAAAAYXNzZXJ0aW9uIGZhaWxlZDogKHR5cGVfaWQgYXMgdXNpemUpIDwgc2VsZi5maWVsZHMubGVuKCngCRAAbAAAAPsAAAAJAAAAaW52YWxpZCB0eXBlIGlkAOAJEABsAAAA/QAAABgAAABhc3NlcnRpb24gZmFpbGVkOiBpbmRleCA8IHNlbGYudHlwZV9pZHMubGVuKCkAAADgCRAAbAAAAAYBAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogaW5kZXggPCBzZWxmLmxlbigp4AkQAGwAAAAaAQAACQAAAOAJEABsAAAAHAEAAB4AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBVbmlvbiBhcnJheSdzIGRhdGEgdHlwZSBpcyBub3QgYSB1bmlvbiEAAABMgiEAUQAAAOAJEABsAAAAPgEAABIAAADgCRAAbAAAAEYBAABQAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZeAJEABsAAAAyAEAABIAAADgCRAAbAAAAN8BAAA9AAAA4AkQAGwAAAAOAgAARAAAAOAJEABsAAAAHgIAAEEAAADgCRAAbAAAABMCAABBAAAA4AkQAGwAAABvAgAAEQAAAOAJEABsAAAAqQIAACMAAADgCRAAbAAAAK0CAAAjAAAA4AkQAGwAAACvAgAAFQAAAOAJEABsAAAAtwIAACAAAADgCRAAbAAAALkCAAAZAAAAVW5pb25BcnJheSBleHBlY3RlZCBBcnJheURhdGEgd2l0aCB0eXBlIFVuaW9uIGdvdCAAAKCDIQAyAAAA4AkQAGwAAAClAgAAEgAAALMNAAAwAAAABAAAALQNAACzDQAAMAAAAAQAAADXBQAAtQ0AANkFAAC2DQAAtw0AANwFAADdBQAA3gUAAN8FAADlBQAAuA0AAOIFAADjBQAA5AUAAOUFAADmBQAA5wUAAOgFAADpBQAA4AkQAGwAAAACAwAAFQAAAOAJEABsAAAAbgMAABYAAADgCRAAbAAAABADAAASAAAAVW5pb25BcnJheShTcGFyc2UpCltVbmlvbkFycmF5KERlbnNlKQpbCgEAAAAAAAAAq4QhAAEAAAAtLSB0eXBlIGlkIGJ1ZmZlcjoKLS0gb2Zmc2V0cyBidWZmZXI6Cl0K4oQhAAIAAAAtLSBjaGlsZCA6ICIiICgpCgAAAOyEIQAJAAAA9YQhAAMAAAD4hCEAAwAAAPuEIQACAAAA4AkQAGwAAAC9AwAAEgAAAOAJEABsAAAAegAAAAoAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAABCxt2uXnKjhOUJHZN/4dGoAMC/8sE//nydYLxhVcVnAZ4EaqQYTmLdfDLLYYe7B8fHLP3sJdo49w2Zk8JQSsynEM/MnaU1JGkI+ioAjhXJQlPsFN832yXIIqwHEQap00y5DQAAFAAAAAQAAAC6DQAA+5UQAF4AAADMAAAAEQAAAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAALsNAAAMAAAABAAAALwNAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yAAEAAAAAAAAAU3RyaW5nAABUhyEABgAAAFRyeWluZyB0byBhY2Nlc3MgYW4gZWxlbWVudCBhdCBpbmRleCAgZnJvbSBhIEFycmF5IG9mIGxlbmd0aCAAAABkhyEAJQAAAImHIQAIAAAAAQAAAAAAAACRhyEAEAAAAAgNEABrAAAAPgEAAAkAAABMYXJnZQAAANSHIQAFAAAAQmluYXJ5AADkhyEABgAAAEFycmF5ClsKAQAAAAAAAAABAAAAAAAAAPSHIQAIAAAAXQAAAL0NAAA8AAAABAAAAL4NAAC9DQAAPAAAAAQAAAC/DQAAvQ0AADwAAAAEAAAAwA0AAL0NAAA8AAAABAAAAMENAAC9DQAAPAAAAAQAAACLBwAAwg0AAI0HAADDDQAAxA0AAI8HAABeBwAAXwcAAGAHAADFDQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAvQ0AADwAAAAEAAAAkAcAAMYNAACSBwAAxw0AAMQNAACUBwAAbwcAAHAHAABgBwAAxQ0AAGEHAABiBwAAYwcAAGQHAABlBwAAZgcAAGcHAABoBwAAaQcAAL0NAAA8AAAABAAAAFgHAADIDQAAWgcAAMkNAADEDQAAXQcAAF4HAABfBwAAYAcAAMUNAABhBwAAYgcAAGMHAABkBwAAZQcAAGYHAABnBwAAaAcAAGkHAAC9DQAAPAAAAAQAAABqBwAAyg0AAGwHAADLDQAAxA0AAG4HAABvBwAAcAcAAGAHAADFDQAAYQcAAGIHAABjBwAAZAcAAGUHAABmBwAAZwcAAGgHAABpBwAAQXJyYXkgZXhwZWN0cyBEYXRhVHlwZTo6AQAAAAAAAAABAAAAAAAAALiJIQAYAAAACA0QAGsAAAAGAgAACQAAAAIAAAAIDRAAawAAABgCAAAaAAAAQXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiAyIGJ1ZmZlcnMgb25seSAob2Zmc2V0cyBhbmQgdmFsdWVzKQAAAAEAAAAAAAAAAQAAAAAAAAAMiiEAPQAAAAgNEABrAAAADgIAAAkAAAD9BBAAcAAAADIBAAAWAAAA/QQQAHAAAAAzAQAAFgAAAMwNAABEAAAABAAAAM0NAADMDQAARAAAAAQAAADODQAAzA0AAEQAAAAEAAAAtwwAAM8NAAC5DAAA0A0AANENAAC7DAAAvAwAAL0MAACmDAAAxQ0AAKcMAACoDAAAqQwAAKoMAACrDAAArAwAAK0MAACuDAAArwwAAMwNAABEAAAABAAAAJ4MAADSDQAAoAwAANMNAADRDQAAowwAAKQMAAClDAAApgwAAMUNAACnDAAAqAwAAKkMAACqDAAAqwwAAKwMAACtDAAArgwAAK8MAABMaXN0Vmlld0FycmF5ClsKAQAAAAAAAABkiyEAEAAAAEV4cGVjdGVkIGluZmFsbGlibGUgY3JlYXRpb24gb2YgR2VuZXJpY0xpc3RWaWV3QXJyYXkgZnJvbSBBcnJheURhdGFSZWYgZmFpbGVkAAAA/QQQAHAAAADbAQAADgAAAP0EEABwAAAACwIAABYAAAD9BBAAcAAAACICAAAvAAAA/QQQAHAAAAAjAgAALQAAAExpc3RWaWV3QXJyYXkncyBjaGlsZCBkYXRhdHlwZSAgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgTGlzdCdzIGRhdGF0eXBlIAABAAAAAAAAABSMIQAfAAAAM4whACwAAABMaXN0Vmlld0FycmF5J3MgZGF0YXR5cGUgbXVzdCBiZSBMaXN0Vmlld0FycmF5KCkuIEl0IGlzIAEAAAAAAAAAeIwhACEAAACZjCEAFwAAAExpc3RWaWV3QXJyYXkgc2hvdWxkIGNvbnRhaW4gYSBzaW5nbGUgY2hpbGQgYXJyYXkgKHZhbHVlcyBhcnJheSksIGhhZCAAAMiMIQBGAAAATGlzdFZpZXdBcnJheSBkYXRhIHNob3VsZCBjb250YWluIHR3byBidWZmZXJzICh2YWx1ZSBvZmZzZXRzICYgdmFsdWUgc2l6ZXMpLCBoYWQgAAAAGI0hAFEAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAAD/7Fp1xS4YcQF6eKTCW9WLEJ9k8dpo/gbvJq2NCifCzcBxzSv1lyosdScKFfVrmaRvIhAAdwAAAKMCAAABAAAA1A0AABQAAAAEAAAA1Q0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAA1g0AAAwAAAAEAAAA1w0AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IgZ290IFNpemUgY2Fubm90IGJlIG5lZ2F0aXZlLCBnb3QgAAAAgI8hAB0AAABUcnlpbmcgdG8gYWNjZXNzIGFuIGVsZW1lbnQgYXQgaW5kZXggIGZyb20gYSBGaXhlZFNpemVCaW5hcnlBcnJheSBvZiBsZW5ndGggqI8hACUAAADNjyEAJwAAAIQEEAB4AAAAkQAAAAkAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgRml4ZWRTaXplQmluYXJ5QXJyYXkgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoFJAhAFgAAACEBBAAeAAAANMAAAAJAAAAAQAAAIQEEAB4AAAA7gEAAA0AAABFeHBlY3RlZCBkYXRhIHR5cGUgdG8gYmUgRml4ZWRTaXplQmluYXJ5mJAhACgAAACEBBAAeAAAAOkBAAASAAAARml4ZWRTaXplQmluYXJ5QXJyYXkgZGF0YSBzaG91bGQgY29udGFpbiAxIGJ1ZmZlciBvbmx5ICh2YWx1ZXMpANiQIQA/AAAAhAQQAHgAAADiAQAACQAAAAAAAABGaXhlZFNpemVCaW5hcnlBcnJheTw+ClsKAAAANJEhABUAAABJkSEABAAAAF0AAADYDQAAOAAAAAQAAADZDQAA2A0AADgAAAAEAAAAEwIAANoNAAAVAgAA2w0AANwNAAAYAgAA3Q0AAN4NAAAbAgAA/wIAABwCAAAdAgAAHgIAAB8CAAAgAgAAIQIAACICAAAjAgAAJAIAAFkGEAB2AAAAhgAAADMAAABJbmNvcnJlY3QgbGVuZ3RoIG9mIG51bGwgYnVmZmVyIGZvciBGaXhlZFNpemVMaXN0QXJyYXksIGV4cGVjdGVkIAAAANyRIQBBAAAAe48hAAUAAABGb3VuZCB1bm1hc2tlZCBudWxscyBmb3Igbm9uLW51bGxhYmxlIEZpeGVkU2l6ZUxpc3RBcnJheSBmaWVsZCAAMJIhAD8AAABGaXhlZFNpemVMaXN0QXJyYXkgZXhwZWN0ZWQgZGF0YSB0eXBlICBmb3IgAHiSIQAmAAAAe48hAAUAAACekiEABQAAAHRoZSBsZW5ndGggKyBvZmZzZXQgb2YgdGhlIHNsaWNlZCBGaXhlZFNpemVMaXN0QXJyYXkgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoAAC8kiEAVgAAAFkGEAB2AAAAGAEAAAkAAABZBhAAdgAAAGcBAAAYAAAARml4ZWRTaXplTGlzdEFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gYSBGaXhlZFNpemVMaXN0IGRhdGEgdHlwZSwgZ290IAAAPJMhAEYAAABZBhAAdgAAAGEBAAARAAAA3w0AADQAAAAEAAAA4A0AAN8NAAA0AAAABAAAAJwEAADhDQAAngQAAOINAADjDQAAoQQAAOQNAADlDQAApAQAAP8CAACmBAAApwQAAKgEAACpBAAAqgQAAKsEAACsBAAArQQAAK4EAABGaXhlZFNpemVMaXN0QXJyYXk8AASUIQATAAAASZEhAAQAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgQm9vbGVhbkJ1ZmZlciBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAAAAolCEAUQAAALwKEABrAAAAPgAAAAkAAAAAAAAABAAAAAQAAADmDQBBtKmGAQvmAgQAAAAEAAAA8gIAAOcNAAD0AgAA6A0AAOkNAAD3AgAA6g0AAOsNAADsDQAA/wIAAO0NAAD8AgAA/QIAAP4CAAD/AgAA6g0AAAADAAD/AgAAAQMAAKSUIQBOdWxsQXJyYXkgZGF0YSB0eXBlIHNob3VsZCBiZSBOdWxsAAAMlSEAIgAAALwKEABrAAAAiwAAAAkAAABOdWxsQXJyYXkgZGF0YSBzaG91bGQgbm90IGNvbnRhaW4gYSBudWxsIGJ1ZmZlciwgYXMgbm8gYnVmZmVycyBhcmUgcmVxdWlyZWQASJUhAEsAAAC8ChAAawAAAJUAAAAJAAAATnVsbEFycmF5IGRhdGEgc2hvdWxkIGNvbnRhaW4gMCBidWZmZXJzAKyVIQAnAAAAvAoQAGsAAACQAAAACQAAAE51bGxBcnJheSgpAOyVIQAKAAAA9pUhAAEAAAAAAAAABAAAAAQAAADuDQAAEgEAQaSshgELARIAQbCshgELAg0BAEG8rIYBCwMmTAoAQcishgELAhICAEHUrIYBCwETAEHgrIYBCwIRAgBB7KyGAQsDJSYKAEH4rIYBCwMjCQIAQYSthgELAg0DAEGQrYYBCwIRAwBBnK2GAQsDJBIGAEGorYYBCwENAEG0rYYBCwISAwBBwK2GAQsBEABBzK2GAQsCDQIAQdithgELAhABAEHorYYBC+0B0wijhYhqPyREc3ADLooZE9AxnykiOAmkiWxO7Jj6LghIYXNoIHRhYmxlIGNhcGFjaXR5IG92ZXJmbG93CJchABwAAAA0eBAAYAAAACUAAAAoAAAARm9ybWF0dGluZyBhcmd1bWVudCBvdXQgb2YgcmFuZ2U8lyEAIAAAAOJfEABrAAAAzwwAAA4AAAABAAAAAAAAABRfEABnAAAAsAAAACIAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAAOkUXxAAZwAAALEAAAAjAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAgAADoAgAAAAAAAAACAEHgr4YBC/MIIAAg4BRfEABnAAAAqgAAACIAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAIOkUXxAAZwAAAKsAAAAjAAAAAgAAAAAAAAABAAAAAQAAAAAAAAAgACDoLCAAABRfEABnAAAATQIAABEAAAAAAAEBSmFuRmViTWFyQXByTWF5SnVuSnVsQXVnU2VwT2N0Tm92RGVjTJghAAMAAABPmCEAAwAAAFKYIQADAAAAVZghAAMAAABYmCEAAwAAAFuYIQADAAAAXpghAAMAAABhmCEAAwAAAGSYIQADAAAAZ5ghAAMAAABqmCEAAwAAAG2YIQADAAAAU3VuTW9uVHVlV2VkVGh1RnJpU2F0AAAA0JghAAMAAADTmCEAAwAAANaYIQADAAAA2ZghAAMAAADcmCEAAwAAAN+YIQADAAAA4pghAAMAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCSkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpQTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlheXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXGBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiAAAA5SoQAGUAAAAIAQAAGwAAAK5rEABlAAAAswEAACoAAACuaxAAZQAAANgBAAAUAAAArmsQAGUAAADhAQAAQAAAAHovAAAAAAAAQZwhAAEAAAAECAEAQeC4hgELC0GcIQABAAAABAIBAEH0uIYBCxMtAAAAAAAAAHScIQABAAAABAcBAEGUuYYBCwt0nCEAAQAAAAQIAQBBqLmGAQsTOgAAAAAAAAConCEAAQAAAAQRAQBByLmGAQsLqJwhAAEAAAAEEQEAQeC5hgELC6icIQABAAAABBIBAEH0uYYBCxIKCQAAAAAAAHScIQABAAAABQQAQZS6hgELC3ScIQABAAAABAABAEGouoYBC5sCOjp6OnoAAACuaxAAZQAAAE8CAAArAAAArmsQAGUAAABMAgAAKwAAAK5rEABlAAAASQIAACsAAACuaxAAZQAAAFUCAAAaAAAArmsQAGUAAABWAgAAHgAAAK5rEABlAAAAWgIAAB4AAACuaxAAZQAAAF4CAAAeAAAArmsQAGUAAABlAgAAGgAAAK5rEABlAAAAaQIAABoAAACuaxAAZQAAAG0CAAAaAAAAJWFzc2VydGlvbiBmYWlsZWQ6IG5leHRzcGVjID4gMACuaxAAZQAAAMUBAAARAAAArmsQAGUAAADGAQAALgAAAK5rEABlAAAAugEAABEAAACuaxAAZQAAALsBAAAsAAAArmsQAGUAAACHAgAALAAAAAQHAQBB0LyGAQsLQZwhAAEAAAAECAEAQei8hgELC0GcIQABAAAABAIBAEH8vIYBCwYgAAAABQYAQYy9hgELDgIAAAB8niEAAQAAAAUEAEGkvYYBCw8CAAAAfJ4hAAEAAAAECAIAQby9hgELDwIAAAB8niEAAQAAAAQPAQBB2L2GAQsLqJwhAAEAAAAEEQEAQfC9hgELC6icIQABAAAABBIBAEGEvoYBCw8CAAAAfJ4hAAEAAAAEAAEAQZy+hgELAwQPAQBBrL6GAQsLqJwhAAEAAAAEEQEAQcS+hgELC6icIQABAAAABBIBAEHYvoYBCwMEEAEAQei+hgELC6icIQABAAAABBEBAEGAv4YBCwuonCEAAQAAAAQSAQBBlL+GAQsOAgAAAHyeIQABAAAABQkAQay/hgEL7QM6hhAAcAAAAC4CAAARAAAA4l8QAGsAAADPDAAADgAAAPANAAAMAAAABAAAAPENAADyDQAAxwcAAAQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoLDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PCQoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQ4PCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgs6AAAAAQAAAAAAAAABAAAAAAAAAHShIQABAAAAAgAAAAAAAAACAEGkw4YBCwUgAADgAgBBssOGAQsPAgAAAAAAAQAAACAAAOkCAEHKw4YBCzcCAAAAAAACAAAAIAAA6QEAAAAAAAAAAQAAAAAAAAB0oSEAAQAAAHShIQABAAAAAgAAAAAAAAACAEGMxIYBCwUgAADgAgBBmsSGAQsPAgAAAAAAAQAAACAAAOkCAEGyxIYBCw8CAAAAAAACAAAAIAAA6QIAQcrEhgELjwECAAAAAAADAAAAIAAA6UZvcm1hdHRpbmcgYXJndW1lbnQgb3V0IG9mIHJhbmdlWKIhACAAAAAtUAAAAQAAAAAAAACBoiEAAQAAADBEVACWoiEAAQAAAHGVEABgAAAAZQIAABkAAAAuAAAAsKIhAAEAAAACAAAAAAAAAAEAAAABAAAAAAAAACAAAOlTAAAAAgBB4sWGAQsBAwBB7MWGAQsFIAAA6QIAQfrFhgELAQYAQYTGhgELBSAAAOkCAEGSxoYBCwEJAEGcxoYBCw0gAADpAQAAAAAAAAACAEGyxoYBCwEFAEG8xoYBC8UMIAAg6QABAQEBAgICAgMDAwMEBAQEBQUFBQYGBgYHBwcHCAgICAkJCQkKCgoKCwsLCwwMDAwNDQ0NDg4ODg8PDw8QEBAQERERERISEhITExMTFBQUFBUVFRUWFhYWFxcXFxgYGBgZGRkZGRkZGRoaGhobGxsbHBwcHB0dHR0eHh4eHx8fHyAgICAhISEhIiIiIiMjIyMkJCQkJSUlJSYmJiYnJycnKCgoKCkpKSkqKioqKysrKywsLCwtLS0tLi4uLi8vLy8wMDAwMTExMTExMTEyMjIyMzMzMzQ0NDQ1NTU1NjY2Njc3Nzc4ODg4OTk5OTo6Ojo7Ozs7PDw8PD09PT0+Pj4+Pz8/P0BAQEBBQUFBQkJCQkNDQ0NERERERUVFRUZGRkZHR0dHSEhISElJSUlJSUlJSkpKSktLS0tMTExMTU1NTU5OTk5PT09PUFBQUFFRUVFSUlJSU1NTU1RUVFRVVVVVVlZWVldXV1dYWFhYWVlZWVpaWlpbW1tbXFxcXF1dXV1eXl5eX19fX2BgYGBhYWFhAAAA24IQAGQAAABDCQAAEQAAANuCEABkAAAARgkAABsAAAAEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKCwwNDgcKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwkKCwwFDwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0ODwkKAw0ODwELDA0GCQoLBA4PCQIMDQ4HCgsMBQ8JCgMNDg8BCwwNBgkKCwQODwkCDA0OBwoLDAUPCQoDDQ4PAQsMDQYJCgsEDg8JAgwNDgcKCwwFDwkKAw0ODwELDA0GCQoL5SoQAGUAAABQAAAACQAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSExKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGIAAADlKhAAZQAAAAgBAAAbAEHG04YBC48HQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAEJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQgAAAAAAAABISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISkhKSEpISgAASkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMSkxKTEpMAAAAAE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QTlBOUE5QAABQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFJQUlBSUFIAAAAAVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFZUVlRWVFYAAFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYVlhWWFZYAABYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFpYWlhaWFoAAAAAXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF5cXlxeXF4AAF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYF5gXmBeYAAAAABiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZGJkYmRiZOUqEABlAAAAYgEAAA8AAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAABhbGlnbl9vZmZzZXQ6IGFsaWduIGlzIG5vdCBhIHBvd2VyLW9mLXR3bwAAAAStIQApAAAAIDEQAHEAAABHBQAADQAAANcyEAB4AAAA6wcAAAkAQeDahgELhTEBAAAA9Q0AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUA9g0AABQAAAAEAAAA9w0AAAAAAAAEAAAABAAAAEoCAABOb3RZZXRJbXBsZW1lbnRlZAAAAAAAAAAEAAAABAAAADIAAABFeHRlcm5hbEVycm9yQ2FzdEVycm9yTWVtb3J5RXJyb3JQYXJzZUVycm9yU2NoZW1hRXJyb3JDb21wdXRlRXJyb3JEaXZpZGVCeVplcm9Bcml0aG1ldGljT3ZlcmZsb3dDc3ZFcnJvckpzb25FcnJvcgAAAPgNAAAMAAAABAAAAPkNAAAAAAAABAAAAAQAAAD1AAAASW9FcnJvcklwY0Vycm9ySW52YWxpZEFyZ3VtZW50RXJyb3JQYXJxdWV0RXJyb3JDRGF0YUludGVyZmFjZURpY3Rpb25hcnlLZXlPdmVyZmxvd0Vycm9yUnVuRW5kSW5kZXhPdmVyZmxvd0Vycm9yAAAAAAAEAAAABAAAADEAAABPZmZzZXRPdmVyZmxvd0Vycm9yTnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAAAAQAAAAEAAAD6DQAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4VmlldwAAAAAAAAAEAAAABAAAADMIAABMaXN0TGlzdFZpZXf7DQAABAAAAAQAAAA1CAAARml4ZWRTaXplTGlzdExhcmdlTGlzdExhcmdlTGlzdFZpZXcAAAAAAAQAAAAEAAAANggAAFN0cnVjdAAA/A0AAAgAAAAEAAAAOAgAAAAAAAAEAAAABAAAADkIAABVbmlvbgAAAP0NAAAEAAAABAAAADsIAAAAAAAABAAAAAQAAAAXBgAARGljdGlvbmFyeQAAAAAAAAEAAAABAAAA/g0AAAAAAAAEAAAABAAAABEFAABEZWNpbWFsMzJEZWNpbWFsNjREZWNpbWFsMTI4RGVjaW1hbDI1NgAAAAAAAAQAAAAEAAAAPQgAAE1hcFJ1bkVuZEVuY29kZWRTZWNvbmRNaWxsaXNlY29uZE1pY3Jvc2Vjb25kTmFub3NlY29uZAAAAAAAAAQAAAAEAAAARAEAAFRyeUZyb21JbnRFcnJvcgDOdRAAagAAAL0BAAAdAAAA+5UQAF4AAAArAQAACgAAAG51bGxfYml0X2J1ZmZlciBzaXplIHRvbyBzbWFsbC4gZ290ICBuZWVkZWQgoLEhACQAAADEsSEACAAAAGFzc2VydGlvbiBmYWlsZWQ6IChvZmZzZXQgKyBsZW5ndGgpIDw9IHNlbGYubGVuKCkAAAD7lRAAXgAAACgCAAAJAAAA+5UQAF4AAAAxAgAAJwAAAPuVEABeAAAATgIAAAoAAAD7lRAAXgAAAE4CAAAtAAAA+5UQAF4AAACAAgAAMwAAAPuVEABeAAAAhQIAAEMAAAD7lRAAXgAAAHsCAAA1AAAAcnVuIG92ZXJmbG93+5UQAF4AAACbAgAAOgAAAPuVEABeAAAAnwIAADoAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBJbnZhbGlkIHJ1biBlbmRzIGRhdGEgdHlwZSAAAACssiEARQAAAPuVEABeAAAApgIAAB8AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiAAAAyzIQAqAAAA+5UQAF4AAAC2AgAAFgAAAEFycmF5cyBvZiB0eXBlICBjYW5ub3QgY29udGFpbiBhIG51bGwgYml0bWFzawAAAFCzIQAPAAAAX7MhAB4AAABudWxsIGJ1ZmZlciBpbmNvcnJlY3Qgc2l6ZS4gZ290ICBleHBlY3RlZCAAAJCzIQAgAAAAsLMhAAoAAABudWxsX2NvdW50ICBmb3IgYW4gYXJyYXkgZXhjZWVkcyBsZW5ndGggb2YgIGVsZW1lbnRzzLMhAAsAAADXsyEAIAAAAPezIQAJAAAA+5UQAF4AAABTAwAAOgAAAPuVEABeAAAAVgMAADoAAABEaWN0aW9uYXJ5IGtleSB0eXBlIG11c3QgYmUgaW50ZWdlciwgYnV0IHdhcyAAAAA4tCEALQAAAFJ1bkFycmF5IHJ1bl9lbmRzIHR5cGVzIG11c3QgYmUgSW50MTYsIEludDMyIG9yIEludDY0LCBidXQgd2FzIABwtCEAPwAAAFRoZSBudWxsYWJsZSBzaG91bGQgYmUgc2V0IHRvIGZhbHNlIGZvciB0aGUgZmllbGQgZGVmaW5pbmcgcnVuX2VuZHMgYXJyYXkuTWlzYWxpZ25lZCBidWZmZXJzW10gaW4gYXJyYXkgb2YgdHlwZSAsIG9mZnNldCBmcm9tIGV4cGVjdGVkIGFsaWdubWVudCBvZiAgYnkgArUhABMAAAAVtSEAEwAAACi1IQAkAAAATLUhAAQAAABOZWVkIGF0IGxlYXN0ICBieXRlcyBpbiBidWZmZXJzWywgYnV0IGdvdCAAAHC1IQAOAAAAfrUhABIAAAAVtSEAEwAAAJC1IQAKAAAAIGJ5dGVzIGZvciBiaXRtYXAgaW4gYnVmZmVyc1sAAABwtSEADgAAALy1IQAdAAAAFbUhABMAAACQtSEACgAAAEV4cGVjdGVkICBidWZmZXJzIGluIGFycmF5IG9mIHR5cGUgLCBnb3QgAAAA/LUhAAkAAAAFtiEAGgAAAB+2IQAGAAAA+5UQAF4AAAB7AwAAKQAAAPuVEABeAAAAiAMAACMAAAD7lRAAXgAAAJYDAAAlAAAAQnVmZmVyICBvZiAgaXNuJ3QgbGFyZ2UgZW5vdWdoLiBFeHBlY3RlZCAgYnl0ZXMgZ290IHC2IQAHAAAAd7YhAAQAAAB7tiEAHgAAAJm2IQALAAAA+5UQAF4AAACsAwAAGwAAAEZpcnN0IG9mZnNldCAgaW4gIGlzIHNtYWxsZXIgdGhhbiBsYXN0IG9mZnNldCAAANS2IQANAAAA4bYhAAQAAADltiEAHQAAAExhc3Qgb2Zmc2V0ICBpcyBsYXJnZXIgdGhhbiB2YWx1ZXMgbGVuZ3RoIAAAHLchAAwAAAB3tiEABAAAACi3IQAeAAAA1LYhAA0AAAB3tiEABAAAACi3IQAeAAAARXJyb3IgY29udmVydGluZyBvZmZzZXRbMF0gKCkgdG8gdXNpemUgZm9yIAB4tyEAHAAAAJS3IQAPAAAARXJyb3IgY29udmVydGluZyBvZmZzZXRbXSAoALS3IQAYAAAAzLchAAMAAACUtyEADwAAAPuVEABeAAAA1AMAABgAAAD7lRAAXgAAANoDAAAaAAAAT2Zmc2V0IGFuZCBzaXplIGhhdmUgZXhjZWVkZWQgdGhlIHVzaXplIGJvdW5kYXJ5+5UQAF4AAADiAwAAEgAAAFNpemUgIGF0IGluZGV4ICBpcyBsYXJnZXIgdGhhbiB0aGUgcmVtYWluaW5nIHZhbHVlcyBmb3IgSLghAAUAAABNuCEACgAAAFe4IQApAAAARXJyb3IgY29udmVydGluZyBzaXplWwAAmLghABYAAADMtyEAAwAAAJS3IQAPAAAAaW50ZWdlciBvdmVyZmxvdyBjb21wdXRpbmcgZXhwZWN0ZWQgbnVtYmVyIG9mIGV4cGVjdGVkIHZhbHVlcyBpbiBGaXhlZExpc3RTaXplAAD7lRAAXgAAABEEAAAWAAAAVmFsdWVzIGxlbmd0aCAgaXMgbGVzcyB0aGFuIHRoZSBsZW5ndGggKCkgbXVsdGlwbGllZCBieSB0aGUgdmFsdWUgc2l6ZSAoKSBmb3IgAAAouSEADgAAADa5IQAaAAAAULkhACAAAABwuSEABgAAACBjaGlsZCBhcnJheSAjIGZvciBmaWVsZCAgaGFzIGxlbmd0aCBzbWFsbGVyIHRoYW4gZXhwZWN0ZWQgZm9yIHN0cnVjdCBhcnJheSAoIDwgKQAAAAEAAAAAAAAAmLkhAA4AAACmuSEACwAAALG5IQA0AAAA5bkhAAMAAADouSEAAQAAAFNwYXJzZSB1bmlvbiBjaGlsZCBhcnJheSAjIGhhcyBsZW5ndGggc21hbGxlciB0aGFuIGV4cGVjdGVkIGZvciB1bmlvbiBhcnJheSAoAAAAHLohABoAAAA2uiEAMwAAAOW5IQADAAAA6LkhAAEAAABGb3VuZCBudWxsIHZhbHVlcyBpbiBydW5fZW5kcyBhcnJheS4gVGhlIHJ1bl9lbmRzIGFycmF5IHNob3VsZCBub3QgaGF2ZSBudWxsIHZhbHVlcy5UaGUgcnVuX2VuZHMgYXJyYXkgbGVuZ3RoIHNob3VsZCBiZSB0aGUgc2FtZSBhcyB2YWx1ZXMgYXJyYXkgbGVuZ3RoLiBSdW5fZW5kcyBhcnJheSBsZW5ndGggaXMgLCB2YWx1ZXMgYXJyYXkgbGVuZ3RoIGlzIADguiEAXgAAAD67IQAZAAAARXhwZWN0ZWQgbm8gY2hpbGQgYXJyYXlzIGZvciB0eXBlICBidXQgZ290IABouyEAIgAAAIq7IQAJAAAAIGhhcyBhIG5lZ2F0aXZlIGxpc3Rfc2l6ZSAAAAEAAAAAAAAApLshABoAAABWYWx1ZSBkYXRhIGZvciAgc2hvdWxkIGNvbnRhaW4gIGNoaWxkIGRhdGEgYXJyYXkocyksIGhhZCAAAADQuyEADwAAAN+7IQAQAAAA77shABoAAABDaGlsZCB0eXBlIG1pc21hdGNoIGZvciAuIEV4cGVjdGVkICBidXQgY2hpbGQgZGF0YSBoYWQgACS8IQAYAAAAPLwhAAsAAABHvCEAFAAAACBkaWQgbm90IGhhdmUgZW5vdWdoIGNoaWxkIGFycmF5cy4gRXhwZWN0ZWQgYXQgbGVhc3QgIGJ1dCBoYWQgb25seSAAAQAAAAAAAAB0vCEANQAAAKm8IQAOAAAAbnVsbF9jb3VudCB2YWx1ZSAoKSBkb2Vzbid0IG1hdGNoIGFjdHVhbCBudW1iZXIgb2YgbnVsbHMgaW4gYXJyYXkgKADQvCEAEgAAAOK8IQAxAAAA6LkhAAEAAAD7lRAAXgAAAN0EAAAtAAAA+5UQAF4AAADZBAAARgAAAG5vbi1udWxsYWJsZSBjaGlsZCBvZiB0eXBlICBjb250YWlucyBudWxscyBub3QgcHJlc2VudCBpbiBwYXJlbnQgAAAATL0hABsAAABnvSEAJgAAACBjb250YWlucyBudWxscyBub3QgcHJlc2VudCBpbiBwYXJlbnQAAABMvSEAGwAAAKC9IQAlAAAA+5UQAF4AAAAbBQAATwAAAPuVEABeAAAAHAUAAFQAAAD7lRAAXgAAAB8FAAA6AAAA+5UQAF4AAAAjBQAAOgAAAPuVEABeAAAAKgUAAC0AAAD7lRAAXgAAADYFAAA9AAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZfuVEABeAAAAQQUAABoAAAD7lRAAXgAAACYFAAAtAAAA+5UQAF4AAABFBQAAJQAAAPuVEABeAAAASgUAABoAAABPZmZzZXQgaW52YXJpYW50IGZhaWx1cmU6IG9mZnNldCBhdCBwb3NpdGlvbiAgb3V0IG9mIGJvdW5kczogID4goL4hAC0AAADNviEAEAAAAN2+IQADAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBDb3VsZCBub3QgY29udmVydCBvZmZzZXQgIHRvIHVzaXplIGF0IHBvc2l0aW9uIAAAAPi+IQAzAAAAK78hABYAAAD7lRAAXgAAAJEFAAAqAAAA+5UQAF4AAAC/BQAAIwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKSAvIG1lbTo6c2l6ZV9vZjo6PFQ+KCkgPj0gcmVxdWlyZWRfbGVu+5UQAF4AAADDBQAACQAAAPuVEABeAAAAxgUAADYAAABWYWx1ZSBhdCBwb3NpdGlvbiAgKHNob3VsZCBiZSBpbiBbMCwgXSkA2L8hABIAAADNviEAEAAAAOq/IQATAAAA/b8hAAIAAAAgKGNhbiBub3QgY29udmVydCB0byBpNjQpAAAA2L8hABIAAADNviEAEAAAACDAIQAZAAAAVGhlIG9mZnNldCArIGxlbmd0aCBvZiBhcnJheSBzaG91bGQgYmUgbGVzcyBvciBlcXVhbCB0byBsYXN0IHZhbHVlIGluIHRoZSBydW5fZW5kcyBhcnJheS4gVGhlIGxhc3QgdmFsdWUgb2YgcnVuX2VuZHMgYXJyYXkgaXMgIGFuZCBvZmZzZXQgKyBsZW5ndGggb2YgYXJyYXkgaXMgLlTAIQB+AAAA0sAhACEAAADzwCEAAQAAAFRoZSB2YWx1ZXMgaW4gcnVuX2VuZHMgYXJyYXkgc2hvdWxkIGJlIHN0cmljdGx5IGluY3JlYXNpbmcuIEZvdW5kIHZhbHVlICB3aXRoIHByZXZpb3VzIHZhbHVlICB0aGF0IGRvZXMgbm90IG1hdGNoIHRoZSBjcml0ZXJpYS4ADMEhAEgAAABNuCEACgAAAFTBIQAVAAAAacEhACIAAABUaGUgdmFsdWVzIGluIHJ1bl9lbmRzIGFycmF5IHNob3VsZCBiZSBzdHJpY3RseSBwb3NpdGl2ZS4gRm91bmQgdmFsdWUgAACswSEARgAAAE24IQAKAAAAacEhACIAAAD7lRAAXgAAAFcGAAAwAAAA+5UQAF4AAACtBwAAFgAAAPuVEABeAAAAvwcAABkAAAD7lRAAXgAAANIHAAAsAAAA+5UQAF4AAADMAAAAEQAAAAYAAAALAAAACwAAAAoAAAA4sSEAPrEhAEmxIQBUsSEABAAAAAgAAAAQAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAANcyEAB4AAAA6wcAAAkAAADEShAAagAAAG0IAAAfAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBvZmZzZXQgYXQgcG9zaXRpb24gIG91dCBvZiBib3VuZHM6ICA+INzCIQAtAAAACcMhABAAAAAZwyEAAwAAAE9mZnNldCBpbnZhcmlhbnQgZmFpbHVyZTogQ291bGQgbm90IGNvbnZlcnQgb2Zmc2V0ICB0byB1c2l6ZSBhdCBwb3NpdGlvbiAAAAA0wyEAMwAAAGfDIQAWAAAAT2Zmc2V0IGludmFyaWFudCBmYWlsdXJlOiBub24tbW9ub3RvbmljIG9mZnNldCBhdCBzbG90IDogAAAAkMMhADcAAADHwyEAAgAAABnDIQADAAAAaW5jb21wbGV0ZSB1dGYtOCBieXRlIHNlcXVlbmNlIGZyb20gaW5kZXggAADkwyEAKgAAAPuVEABeAAAAoQUAADMAAABJbnZhbGlkIFVURjggc2VxdWVuY2UgYXQgc3RyaW5nIGluZGV4ICAoKTogACjEIQAmAAAATsQhAAIAAABQxCEAAwAAAFOAEABnAAAA9AEAACMAAABTgBAAZwAAAA8CAAAvAAAAU4AQAGcAAAAfAgAALwAAAFOAEABnAAAAKQIAACsAAABTgBAAZwAAADICAAAjAAAAU4AQAGcAAAA2AgAAIwAAAFOAEABnAAAAQAIAACMAAABTgBAAZwAAAFMCAAAnAAAAU4AQAGcAAABpAgAAOAAAAFOAEABnAAAAmQIAACgAAAB2aWV3IGJ1ZmZlciBpbmRleCBvdmVyZmxvdwAAU4AQAGcAAACvAgAAHgAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAKcBAAAfAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAACRXEABpAAAAOAAAAAUAAABmYWlsZWQgdG8gY3JlYXRlIGxheW91dCBmb3IgTXV0YWJsZUJ1ZmZlcgAAALVtEABqAAAAWgAAAA4AAADXMhAAeAAAAOsHAAAJAEHwi4cBC6IEAQAAABEOAAASDgAAFAAAAAQAAAATDgAAAAAAAAQAAAAEAAAASgIAAE5vdFlldEltcGxlbWVudGVkAAAAAAAAAAQAAAAEAAAAMgAAAEV4dGVybmFsRXJyb3JDYXN0RXJyb3JNZW1vcnlFcnJvclBhcnNlRXJyb3JTY2hlbWFFcnJvckNvbXB1dGVFcnJvckRpdmlkZUJ5WmVyb0FyaXRobWV0aWNPdmVyZmxvd0NzdkVycm9ySnNvbkVycm9yAAAAFA4AAAwAAAAEAAAAFQ4AAAAAAAAEAAAABAAAAPUAAABJb0Vycm9ySXBjRXJyb3JJbnZhbGlkQXJndW1lbnRFcnJvclBhcnF1ZXRFcnJvckNEYXRhSW50ZXJmYWNlRGljdGlvbmFyeUtleU92ZXJmbG93RXJyb3JSdW5FbmRJbmRleE92ZXJmbG93RXJyb3IAAAAAAAQAAAAEAAAAMQAAAE9mZnNldE92ZXJmbG93RXJyb3IAxEoQAGoAAABtCAAAHwAAAEJpbmFyeUxpc3RTdHJ1Y3REaWN0aW9uYXJ5TGF5b3V0RXJyb3IAAAAAAAAABAAAAAQAAAAWDgAA+5UQAF4AAACMAAAAPwAAAPuVEABeAAAAYQAAAEcAAABNdXRhYmxlQXJyYXlEYXRhIG5vdCBudWxsYWJsZQAAAFOAEABnAAAASAAAAA4AAAAAAAAADAAAAAQAAAAXDgAAGA4AABgOAEGckIcBCw4BAAAAGQ4AABoOAAAaDgBBtJCHAQvFFQEAAAAbDgAAHA4AABwOAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlU4AQAGcAAADTAAAAEgAAAAAAAAAMAAAABAAAAB0OAAAeDgAAHg4AAFOAEABnAAAA4AAAAB4AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBzaG91bGQgdXNlIGJ1aWxkX2V4dGVuZF92aWV3AACkyCEARgAAAFOAEABnAAAACgEAADYAAABub3QgaW1wbGVtZW50ZWQ6IExpc3RWaWV3L0xhcmdlTGlzdFZpZXcgbm90IGltcGxlbWVudGVkAATJIQA3AAAAU4AQAGcAAAANAQAADQAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHNob3VsZCB1c2UgYnVpbGRfZXh0ZW5kX2RpY3Rpb25hcnlUySEATAAAAFOAEABnAAAAEAEAACcAAABTgBAAZwAAAD0BAAANAAAAU4AQAGcAAABJAQAAEgAAAAAAAAAEAAAABAAAAB8OAAAgDgAAIA4AAFOAEABnAAAApAEAAB8AAABTgBAAZwAAAO8BAAARAAAAU4AQAGcAAABjAgAAJAAAAGRpY3Rpb25hcnkgY2FwYWNpdHkgbm90IHlldCBzdXBwb3J0ZWQAAAAgyiEAJQAAAFOAEABnAAAAZgIAAB0AAABNdXRhYmxlQXJyYXlEYXRhOjpuZXcgaXMgaW5mYWxsaWJsZQBTgBAAZwAAAKQCAAAfAAAAQ2FwYWNpdGllczogIG5vdCB5ZXQgc3VwcG9ydGVkAACUyiEADAAAAKDKIQASAAAAU4AQAGcAAADLAQAAEgAAAEFycmF5cyB3aXRoIGluY29uc2lzdGVudCB0eXBlcyBwYXNzZWQgdG8gTXV0YWJsZUFycmF5RGF0YQAAANTKIQA5AAAAU4AQAGcAAACnAQAADQAAAFOAEABnAAAAYAIAAB4AAABTgBAAZwAAAGACAAA7AAAAU4AQAGcAAADYAgAAHwAAAFOAEABnAAAA2QIAABwAAABTgBAAZwAAABEDAAATAAAAU4AQAGcAAAAiAwAAQAAAAPuVEABeAAAAzAAAABEAAAAAAAAABAAAAAQAAAAhDgAAAAAAAAQAAAAEAAAAIg4AAAAAAAAEAAAABAAAACMOAABBcnJheQAAAAQAAAAIAAAAEAAAAAQOAAAFDgAACQ4AAAIOAAADDgAABA4AAAUOAAACDgAAAw4AAAQOAAAFDgAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAAAAAAAIAAAABAAAACQOAAAlDgAAJQ4AAAAAAAAIAAAABAAAACYOAAAnDgAAJw4AAAAAAAAIAAAABAAAACgOAAApDgAAKQ4AAAAAAAAIAAAABAAAACgOAAApDgAAKQ4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAAAAAAAIAAAABAAAACwOAAAtDgAALQ4AAAAAAAAIAAAABAAAAC4OAAAvDgAALw4AAAAAAAAIAAAABAAAACYOAAAnDgAAJw4AAAAAAAAIAAAABAAAADAOAAAxDgAAMQ4AAAAAAAAIAAAABAAAADIOAAAzDgAAMw4AAAAAAAAIAAAABAAAADIOAAAzDgAAMw4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAAAAAAAIAAAABAAAACoOAAArDgAAKw4AAA1kEABtAAAAHwAAACsAAAAAAAAADAAAAAQAAAA0DgAANQ4AADUOAAAAAAAAEAAAAAgAAAA2DgAANw4AADcOAAAAAAAADAAAAAQAAAA4DgAAOQ4AADkOAAAAAAAADAAAAAQAAAA6DgAAOw4AADsOAAAAAAAADAAAAAQAAAA8DgAAPQ4AAD0OAAAAAAAAEAAAAAgAAAA+DgAAPw4AAD8OAAAAAAAADAAAAAQAAABADgAAQQ4AAEEOAAAAAAAADAAAAAQAAABCDgAAQw4AAEMOAAANZBAAbQAAAC0AAAAfAAAA1zIQAHgAAADrBwAACQAAABA5EABvAAAAkAAAAC4AAABuXRAAXQAAAJkAAAAVAAAAbl0QAF0AAACsAAAAPQAAAG5dEABdAAAAlQAAACYAAAAAAAAABAAAAAQAAABFDgAAAAAAAAQAAAAEAAAAIQ4AAEJpbmFyeQAAAAAAAAQAAAAEAAAAIg4AAExpc3QAAAAABAAAAAQAAAAjDgAAU3RydWN0RGljdGlvbmFyeQAAAAAEAAAABAAAADEAAABBcnJheWZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0JFcQAGkAAAAYAAAACgAAAIZOEABlAAAALAAAABIAAACGThAAZQAAADAAAAASAAAAhk4QAGUAAAAxAAAAHwAAAIZOEABlAAAAMgAAAB8AAACGThAAZQAAAF0AAAAqAAAAhk4QAGUAAABeAAAAKgAAAIZOEABlAAAAaAAAADEAAACGThAAZQAAAGkAAAAxAAAAbm90IGltcGxlbWVudGVkOiBMb2dpY2FsIGVxdWFsaXR5IG5vdCB5ZXQgaW1wbGVtZW50ZWQgYmV0d2VlbiBkZW5zZSBhbmQgc3BhcnNlIHVuaW9uIGFycmF5cwDIzyEAWwAAAIZOEABlAAAAewAAAA4AAADOUBAAawAAABcAAAASAAAAAAAAAAwAAAAEAAAARg4AAEcOAABHDgAAUQIQAHAAAAAcAAAAEwAAAFECEABwAAAAHAAAADAAAAAAAAAADAAAAAQAAABIDgAASQ4AAEkOAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlUQIQAHAAAAAZAAAADgAAAFECEABwAAAAIAAAAC0AAABRAhAAcAAAACgAAAAOAAAAAAAAAAgAAAAEAAAASg4AAEsOAABLDgAAAAAAAAgAAAAEAAAATA4AAE0OAABNDgAAmhcQAGgAAAAmAAAARQAAAJoXEABoAAAAKAAAAB8AAACaFxAAaAAAACoAAAARAAAAmhcQAGgAAAArAAAAEQAAAG9mZnNldCBvdmVyZmxvdwC/KBAAaQAAACoAAAA4AAAALWMQAHEAAAAkAAAAGAAAAC1jEABxAAAAJQAAAB0AAAAtYxAAcQAAACYAAAAdAAAALWMQAHEAAAAuAAAAEgAAAAAAAAAQAAAABAAAAE4OAABPDgAATw4AAAAAAAAQAAAABAAAAFAOAABRDgAAUQ4AAC1jEABxAAAANwAAAEUAAABIbRAAbAAAAEsCAAATAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAAGZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyAAAAtW0QAGoAAABaAAAADgAAAGFzc2VydGlvbiBmYWlsZWQ6IHByZWZpeC5pc19lbXB0eSgpICYmIHN1ZmZpeC5pc19lbXB0eSgpSG0QAGwAAABPAQAACQBBhKaHAQuxAQEAAABSDgAATGF5b3V0RXJyb3IAyxYQAGoAAAAjAAAAFwAAAMsWEABqAAAAJAAAABcAAADLFhAAagAAADMAAAAlAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZcsWEABqAAAAIAAAAA4AAAAAAAAABAAAAAQAAABTDgAAVA4AAFQOAABXFhAAcwAAABoAAAAOAAAAVxYQAHMAAAAqAAAADgBBwKeHAQsOAQAAAFUOAABWDgAAVg4AQdinhwELkycBAAAAVw4AAFgOAABYDgAAAAAAAAgAAAAEAAAAWQ4AAFoOAABaDgAAHE4QAGkAAAAdAAAALQAAAAAAAAAUAAAABAAAAFsOAABcDgAAXA4AABxOEABpAAAAKwAAAAkAAAAcThAAaQAAADMAAAAtAAAAHE4QAGkAAAA2AAAAHwAAAGludmFsaWQgdW5pb24gdHlwZSBJRAAAABxOEABpAAAAOgAAABYAAAAcThAAaQAAADsAAAAiAAAAHE4QAGkAAAA8AAAAOQAAABxOEABpAAAAQQAAACMAAABjYW5ub3QgY2FsbCBleHRlbmRfbnVsbHMgb24gVW5pb25BcnJheSBhcyBjYW5ub3QgaW5mZXIgdHlwZQCw1CEAOwAAABxOEABpAAAASAAAAAUAAAAcThAAaQAAAEwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAAxgQAGQAAABPAAAAHAAAAAMYEABkAAAATwAAAEQAAAADGBAAZAAAAFAAAAALAAAAAxgQAGQAAABQAAAALQAAAAMYEABkAAAAUgAAABwAAAADGBAAZAAAAFIAAABEAAAAAxgQAGQAAABTAAAACwAAAAMYEABkAAAAUwAAAC0AAAADGBAAZAAAAFkAAAAXAAAAAxgQAGQAAABaAAAAFwAAAAMYEABkAAAAZgAAAB0AAAADGBAAZAAAAGcAAAAdAAAAAxgQAGQAAABsAAAAMwAAAAMYEABkAAAAbQAAADMAAAADGBAAZAAAAHIAAAAlAAAAAxgQAGQAAACCAAAAJAAAAAMYEABkAAAAggAAAEQAAAADGBAAZAAAAIMAAAAiAAAAAxgQAGQAAACDAAAARgAAAAMYEABkAAAAhAAAACQAAAADGBAAZAAAAIQAAABEAAAAAxgQAGQAAACFAAAAIgAAAAMYEABkAAAAhQAAAEYAAAApKRAAZQAAAGYAAAAPAAAAKSkQAGUAAABmAAAAOwAAAJ9jEABtAAAAIQAAABUAAACfYxAAbQAAACIAAAAVAAAAn2MQAG0AAAAjAAAAFAAAAJ9jEABtAAAAJQAAAAoAAACfYxAAbQAAACYAAAAUAAAAn2MQAG0AAAAoAAAACgAAAJ9jEABtAAAAPAAAABYAAACfYxAAbQAAAD0AAAAWAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAAIhJEABnAAAAMgAAABcAAACISRAAZwAAAEsAAAAcAAAAcnVuIGVuZCBvdmVyZmxvd4hJEABnAAAATAAAABwAAACISRAAZwAAAE0AAAAcAAAASW52YWxpZCBydW4gZW5kIHR5cGUgZm9yIFJ1bkVuZEVuY29kZWQgYXJyYXk6IAAA2NchAC4AAACISRAAZwAAAE4AAAAOAAAAZXh0ZW5kX251bGxzIGNhbGxlZCBvbiBub24tUnVuRW5kRW5jb2RlZCBhcnJheQAAINghAC4AAACISRAAZwAAADgAAAAJAAAAiEkQAGcAAABnAAAANQAAAIhJEABnAAAAhQAAABYAAACISRAAZwAAAIYAAAAgAAAAVW5yZWFjaGFibGU6IHZhbHVlc19yYW5nZSBjYW5ub3QgYmUgTm9uZSB3aGVuIHByZXZfZW5kIDwgZW5kICYmIHJ1bl9lbmQgPj0gZW5kLiBEdWUgdG8gc2VxdWVudGlhbCBwcm9jZXNzaW5nIGFuZCBtb25vdG9uaWMgcHJldl9lbmQgYWR2YW5jZW1lbnQsIGlmIHdlIHJlYWNoIGEgcnVuIHRoYXQgc3BhbnMgYmV5b25kIHRoZSBzbGljZSBlbmQgKHJ1bl9lbmQgPj0gZW5kKSwgYXQgbGVhc3Qgb25lIHByZXZpb3VzIGNvbmRpdGlvbiBtdXN0IGhhdmUgbWF0Y2hlZCBmaXJzdCB0byBzZXQgdmFsdWVzX3JhbmdlLiBFaXRoZXIgdGhlIGZpcnN0IGNvbmRpdGlvbiBtYXRjaGVkIHdoZW4gdGhlIHNsaWNlIHN0YXJ0ZWQgKHByZXZfZW5kIDw9IHN0YXJ0ICYmIHJ1bl9lbmQgPiBzdGFydCksIG9yIHRoZSBzZWNvbmQgY29uZGl0aW9uIG1hdGNoZWQgZm9yIHJ1bnMgd2l0aGluIHRoZSBzbGljZSAocHJldl9lbmQgPj0gc3RhcnQgJiYgcnVuX2VuZCA8PSBlbmQpLohJEABnAAAAiQAAADMAAACISRAAZwAAAHoAAAAWAAAAiEkQAGcAAAB7AAAAIAAAAFVucmVhY2hhYmxlOiB2YWx1ZXNfcmFuZ2UgY2Fubm90IGJlIE5vbmUgd2hlbiBwcmV2X2VuZCA+PSBzdGFydCAmJiBydW5fZW5kIDw9IGVuZC4gSWYgcHJldl9lbmQgPj0gc3RhcnQgYW5kIHJ1bl9lbmQgPiBwcmV2X2VuZCAocmVxdWlyZWQgZm9yIHZhbGlkIHJ1bnMpLCB0aGVuIHJ1bl9lbmQgPiBzdGFydCwgd2hpY2ggbWVhbnMgdGhlIGZpcnN0IGNvbmRpdGlvbiAocHJldl9lbmQgPD0gc3RhcnQgJiYgcnVuX2VuZCA+IHN0YXJ0KSB3b3VsZCBoYXZlIGJlZW4gdHJ1ZSBhbmQgYWxyZWFkeSBzZXQgdmFsdWVzX3JhbmdlIHRvIFNvbWUuAAAAiEkQAGcAAAB+AAAAMwAAAIhJEABnAAAAcgAAABYAAACISRAAZwAAAHMAAAAgAAAAdmFsdWVzX3JhbmdlIHNob3VsZCBiZSBTb21lIGlmIHJ1bl9lbmRzX2J5dGVzIGlzIG5vdCBlbXB0eQAAiEkQAGcAAACxAAAAFgAAAIhJEABnAAAAsgAAABcAAAAAAAAABAAAAAQAAABdDgAAXg4AAF4OAACISRAAZwAAAMAAAAAkAAAAiEkQAGcAAADBAAAAIgAAAIhJEABnAAAA4QAAACQAAACISRAAZwAAAOIAAAAkAAAAiEkQAGcAAADjAAAAJAAAAIhJEABnAAAA5AAAABYAAABleHRlbmQgY2FsbGVkIG9uIG5vbi1SdW5FbmRFbmNvZGVkIG11dGFibGUgYXJyYXnk3CEAMAAAAIhJEABnAAAAyAAAABUAAAAkVxAAaQAAACcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAAAAAAAQAAAAEAAAAXw4AAAAAAAAEAAAABAAAAGAOAAAuLgAAOlEQAGcAAAAhAAAAFgAAADpREABnAAAAIgAAABYAAADCAhAAbAAAACYAAAAXAAAAwgIQAGwAAAAmAAAAMgAAAMICEABsAAAAJwAAABcAAADCAhAAbAAAACcAAAAyAAAAwgIQAGwAAABQAAAAKQAAAMICEABsAAAAOQAAACkAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlwgIQAGwAAAAjAAAADgAAACkpEABlAAAAZgAAAA8AAAApKRAAZQAAAGYAAAA7AAAAYXNzZXJ0aW9uIGZhaWxlZDogaWR4IDwgc2VsZi5sZW73TxAAagAAAI4AAAAJAAAAe2QQAGkAAAAkAAAAFwAAAHtkEABpAAAAJAAAADIAAAB7ZBAAaQAAACUAAAAXAAAAe2QQAGkAAAAlAAAAMgAAAHtkEABpAAAATgAAACkAAAB7ZBAAaQAAADgAAAApAAAAKSkQAGUAAABmAAAADwAAACkpEABlAAAAZgAAADsAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBzZWxmLmxlbvdPEABqAAAAjgAAAAkAAAB/ARAAagAAACEAAAAXAAAAfwEQAGoAAAAiAAAAFwAAAH8BEABqAAAANgAAACUAAAB/ARAAagAAAC4AAAARAAAAfwEQAGoAAAAuAAAALgAAAH8BEABqAAAALwAAABEAAAB/ARAAagAAAC8AAAAuAAAAfwEQAGoAAABDAAAAGQAAAH8BEABqAAAAQwAAADYAAAB/ARAAagAAAEQAAAAZAAAAfwEQAGoAAABEAAAANgAAAPBJEABjAAAALwAAAB8AAADwSRAAYwAAADAAAAAdAAAA8EkQAGMAAAAzAAAAHwAAAPBJEABjAAAANAAAAB0AAABub3QgaW1wbGVtZW50ZWQ6IExvZ2ljYWwgY29tcGFyaXNvbiBmb3IgcnVuIGFycmF5IG5vdCBzdXBwb3J0ZWQuOOAhAEAAAADwSRAAYwAAACcAAAAJAAAAKSkQAGUAAABGAAAAKAAAACkpEABlAAAARwAAACgAAAApKRAAZQAAAEgAAAAqAAAAKSkQAGUAAABJAAAAKgAAAE1hcCB0eXBlIHNob3VsZCBoYXZlIDIgZmllbGRzIFN0cnVjdCBpbiBpdHMgZmllbGQAAADQ4CEAMQAAACkpEABlAAAAVAAAABYAAABub3QgaW1wbGVtZW50ZWQ6IExpc3RWaWV3L0xhcmdlTGlzdFZpZXcgbm90IHlldCBpbXBsZW1lbnRlZAAc4SEAOwAAAIqBEABjAAAAbAAAAA0AAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlioEQAGMAAAB7AAAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IHNlbGYubGVu908QAGoAAACOAAAACQAAANcyEAB4AAAA6wcAAAkAAABOb25lAAAAAAQAAAAEAAAAMQAAAFNvbWUAAAAABAAAAAQAAABhDgAAAAAAAAQAAAAEAAAAYg4AAM51EABqAAAAvQEAAB0AAAB4ExAAaQAAABsAAAArAAAAeBMQAGkAAAAcAAAAJQAAAHgTEABpAAAAHQAAACsAAAB4ExAAaQAAAB4AAAAlAAAAeBMQAGkAAAA7AAAAGQAAAHgTEABpAAAAPAAAABkAAAB4ExAAaQAAAEIAAAAUAAAAeBMQAGkAAABCAAAAOgAAAEtpEABpAAAANQAAACUAAABFbmNvdW50ZXJlZCBub24tVVRGLTggZGF0YSBhdCBpbmRleCA6IAAAwOIhACQAAADk4iEAAgAAAE1pc21hdGNoIGJldHdlZW4gZW1iZWRkZWQgcHJlZml4IGFuZCBkYXRhVmlldyBhdCBpbmRleCAgY29udGFpbmVkIG5vbi16ZXJvIHBhZGRpbmcgZm9yIHN0cmluZyBvZiBsZW5ndGggIeMhAA4AAAAv4yEAMQAAAEludmFsaWQgYnVmZmVyIGluZGV4IGF0IDogZ290IGluZGV4ICBidXQgb25seSBoYXMgIGJ1ZmZlcnMAAHDjIQAYAAAAiOMhAAwAAACU4yEADgAAAKLjIQAIAAAASW52YWxpZCBidWZmZXIgc2xpY2UgYXQgOiBnb3QgLi4gYnV0IGJ1ZmZlciAgaGFzIGxlbmd0aCDM4yEAGAAAAOTjIQAGAAAA6uMhAAIAAADs4yEADAAAAPjjIQAMAAAAcIsQAH4AAAA0AAAABQAAAPUhEAB5AAAA+wAAAAEAAADOdRAAagAAAF8DAAAJAAAA1zIQAHgAAADrBwAACQAAAFN0cnVjdCgsIAAAAAEAAAAAAAAAKU51bGxCb29sZWFuSW50OEludDE2SW50MzJJbnQ2NFVJbnQ4VUludDE2VUludDMyVUludDY0RmxvYXQxNkZsb2F0MzJGbG9hdDY0AAAAAAABAAAAAQAAAGQOAAAAAAAABAAAAAQAAAAyCAAAVGltZXN0YW1wRGF0ZTMyRGF0ZTY0AAAAAAAAAAQAAAAEAAAAKgQAAFRpbWUzMlRpbWU2NER1cmF0aW9uAAAAAAQAAAAEAAAAzAQAAEludGVydmFsQmluYXJ5AAAAAAAABAAAAAQAAABtAwAARml4ZWRTaXplQmluYXJ5TGFyZ2VCaW5hcnlCaW5hcnlWaWV3VXRmOExhcmdlVXRmOFV0ZjhWaWV3AAAAAAAAAAQAAAAEAAAAMwgAAExpc3RMaXN0Vmlld2UOAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AABmDgAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAZw4AAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAABoDgAAAAAAAAQAAAAEAAAAEQUAAERlY2ltYWwzMkRlY2ltYWw2NERlY2ltYWwxMjhEZWNpbWFsMjU2AAAAAAAABAAAAAQAAAA9CAAATWFwUnVuRW5kRW5jb2RlZFNlY29uZE1pbGxpc2Vjb25kTWljcm9zZWNvbmROYW5vc2Vjb25kWWVhck1vbnRoRGF5VGltZU1vbnRoRGF5TmFub1NwYXJzZURlbnNlAAAACQAAAAcAAAAMAAAA3uYhAOfmIQDu5iEABgAAAAsAAAALAAAACgAAALjmIQC+5iEAyeYhANTmIQDXMhAAeAAAAOsHAAAJAAAAznUQAGoAAAC9AQAAHQAAAP//////////YOchAEH4zocBC4oMAQAAAAAAAABOdWxsQm9vbGVhbkludDhJbnQxNkludDMySW50NjRVSW50OFVJbnQxNlVJbnQzMlVJbnQ2NEZsb2F0MTZGbG9hdDMyRmxvYXQ2NAAAAAAAAAEAAAABAAAAag4AAAAAAAAEAAAABAAAADIIAABUaW1lc3RhbXBEYXRlMzJEYXRlNjQAAAAAAAAABAAAAAQAAAAqBAAAVGltZTMyVGltZTY0RHVyYXRpb24AAAAABAAAAAQAAADMBAAASW50ZXJ2YWxCaW5hcnkAAAAAAAAEAAAABAAAAG0DAABGaXhlZFNpemVCaW5hcnlMYXJnZUJpbmFyeUJpbmFyeVZpZXdVdGY4TGFyZ2VVdGY4VXRmOFZpZXcAAAAAAAAABAAAAAQAAAAzCAAATGlzdExpc3RWaWV3aw4AAAQAAAAEAAAANQgAAEZpeGVkU2l6ZUxpc3RMYXJnZUxpc3RMYXJnZUxpc3RWaWV3AAAAAAAEAAAABAAAADYIAABTdHJ1Y3QAAGwOAAAIAAAABAAAADgIAAAAAAAABAAAAAQAAAA5CAAAVW5pb24AAABtDgAABAAAAAQAAAA7CAAAAAAAAAQAAAAEAAAAFwYAAERpY3Rpb25hcnkAAAAAAAABAAAAAQAAAG4OAAAAAAAABAAAAAQAAAARBQAARGVjaW1hbDMyRGVjaW1hbDY0RGVjaW1hbDEyOERlY2ltYWwyNTYAAAAAAAAEAAAABAAAAD0IAABNYXBSdW5FbmRFbmNvZGVkU2Vjb25kTWlsbGlzZWNvbmRNaWNyb3NlY29uZE5hbm9zZWNvbmQAAG8OAAAMAAAABAAAAHAOAABxDgAADAAAAAQAAAByDgAAAAAAAAEAAAABAAAAcw4AAAAAAAAIAAAACAAAAHQOAAAAAAAABAAAAAQAAAAlBAAAbmFtZWRhdGFfdHlwZW51bGxhYmxlZGljdF9pZGRpY3RfaXNfb3JkZXJlZG1ldGFkYXRhADDqIQAEAAAANOohAAkAAAA96iEACAAAAEXqIQAHAAAATOohAA8AAABb6iEACAAAAEZpZWxkAAAABgAAAAsAAAALAAAACgAAALjpIQC+6SEAyekhANTpIQDXMhAAeAAAAOsHAAAJAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQB5DgAAEAAAAAQAAAB6DgAAAAAAAAQAAAAEAAAAew4AAAAAAAAEAAAABAAAAHwOAABOdWxFcnJvcs51EABqAAAAvQEAAB0AAADMXRAAXwAAAIsAAAAsAAAAzF0QAF8AAAClAAAAKAAAAP///38gd2VyZSBwcm92aWRlZG1ldGFkYXRhIGtleSBjYW4gb25seSBoYXZlICBieXRlcywgYnV0IAAAAHLrIQAbAAAAjeshAAwAAABk6yEADgAAAG1ldGFkYXRhIHZhbHVlIGNhbiBvbmx5IGhhdmUgAAAAtOshAB0AAACN6yEADAAAAGTrIQAOAAAAbmJjc2lsQ1NJTGVmZ3RzczoAAAD56yEABAAAAHRzbToI7CEABAAAAHRzdToU7CEABAAAAHRzbjog7CEABAAAAHRkRHRkbXR0c3R0bXR0dXR0bnREc3REbXREdXREbnRpTXRpRHRpbnp3OgAAVOwhAAIAAABadnp1VXZ1K2wrdzpp7CEAAwAAACtMK3MsK3VzOgAAAHnsIQAEAAAAK3VkOojsIQAEAAAAZDosMzIAAACU7CEAAgAAAHjsIQABAAAAluwhAAMAAAAsNjQAlOwhAAIAAAB47CEAAQAAALTsIQADAAAAlOwhAAIAAAB47CEAAQAAACwyNTaU7CEAAgAAAHjsIQABAAAA4OwhAAQAAAArbStyVGhlIGRhdGF0eXBlICIiIGlzIHN0aWxsIG5vdCBzdXBwb3J0ZWQgaW4gUnVzdCBpbXBsZW1lbnRhdGlvbgAAAADtIQAOAAAADu0hAC8AAAA+7CEAQewhAETsIQBH7CEASuwhAE3sIQBQ7CEAfg4AAAwAAAAEAAAAfw4AAIAOAACBDgBBjNuHAQvfAQEAAACCDgAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQDiXxAAawAAAA8LAAAOAAAA4l8QAGsAAADoAQAAFwAAAOJfEABrAAAAVAsAAAEAAABFcnJvcgAAAOJfEABrAAAAzwwAAA4AAAAgAAAAAQAAAAAAAAAU7iEAAQAAAHByb2plY3QgaW5kZXggIG91dCBvZiBib3VuZHMsIG1heCBmaWVsZCAo7iEADgAAADbuIQAaAAAA//////////9g7iEAQfjchwELowPXMhAAeAAAAOsHAAAJAAAAWpYQAGIAAAArAAAAFQAAAFVuYWJsZSB0byBnZXQgZmllbGQgbmFtZWQgIiIuIFZhbGlkIGZpZWxkczogmO4hABsAAACz7iEAEQAAACwgTm9uZQAAAAAAAAQAAAAEAAAAQwUAAFNvbWUAAAAABAAAAAQAAACEDgAAAAAAAAQAAAAEAAAASgIAAAAAAAAEAAAABAAAAIUOAAAAAAAABAAAAAQAAAAzCAAAAAAAAAQAAAAEAAAAhg4AAG1pZCA+IGxlbgAAAEDvIQAJAAAATBoQAH8AAABKAAAAHwAAAEwaEAB/AAAARAAAABcAAABhdHRlbXB0IHRvIGpvaW4gaW50byBjb2xsZWN0aW9uIHdpdGggbGVuID4gdXNpemU6Ok1BWAAAALcwEABoAAAAmgAAAAoAAAC3MBAAaAAAAJ0AAAAWAAAAtzAQAGgAAACgAAAADAAAAG1pZCA+IGxlbgAAANzvIQAJAAAAtzAQAGgAAACxAAAAFgAAAONqEABpAAAAzAAAAAUAAAD//////////xDwIQBBrOCHAQsaBAAAAAQAAAARBQAAAAAAAAQAAAAEAAAAMwgAQdDghwELwgwBAAAAhw4AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAgo8QAGkAAAAWCAAAKQAAAExheW91dEVycm9yTnVsbEJvb2xlYW5JbnQ4SW50MTZJbnQzMkludDY0VUludDhVSW50MTZVSW50MzJVSW50NjRGbG9hdDE2RmxvYXQzMkZsb2F0NjQAAAAAAAAAAQAAAAEAAACIDgAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4Vmlld0xpc3RMaXN0VmlldwAAAIkOAAAEAAAABAAAADUIAABGaXhlZFNpemVMaXN0TGFyZ2VMaXN0TGFyZ2VMaXN0VmlldwAAAAAABAAAAAQAAAA2CAAAU3RydWN0AACKDgAACAAAAAQAAAA4CAAAAAAAAAQAAAAEAAAAOQgAAFVuaW9uAAAAiw4AAAQAAAAEAAAAOwgAAAAAAAAEAAAABAAAABcGAABEaWN0aW9uYXJ5AAAAAAAAAQAAAAEAAACMDgAARGVjaW1hbDMyRGVjaW1hbDY0RGVjaW1hbDEyOERlY2ltYWwyNTYAAAAAAAAEAAAABAAAAD0IAABNYXBSdW5FbmRFbmNvZGVkU2Vjb25kTWlsbGlzZWNvbmRNaWNyb3NlY29uZE5hbm9zZWNvbmQAAI0OAAAMAAAABAAAAI4OAACPDgAADAAAAAQAAACQDgAAAAAAAAEAAAABAAAAkQ4AAAAAAAAIAAAACAAAAJIOAAAAAAAABAAAAAQAAAAlBAAAbmFtZWRhdGFfdHlwZW51bGxhYmxlZGljdF9pZGRpY3RfaXNfb3JkZXJlZG1ldGFkYXRhADDzIQAEAAAANPMhAAkAAAA98yEACAAAAEXzIQAHAAAATPMhAA8AAABb8yEACAAAAEZpZWxkAAAABgAAAAsAAAALAAAACgAAALjyIQC+8iEAyfIhANTyIQAQORAAbwAAAJAAAAAuAAAAOoYQAHAAAAAuAgAAEQAAAE51bGxCb29sZWFuSW50OEludDE2SW50MzJJbnQ2NFVJbnQ4VUludDE2VUludDMyVUludDY0RmxvYXQxNkZsb2F0MzJGbG9hdDY0AAAAAAAAAQAAAAEAAACTDgAAAAAAAAQAAAAEAAAAMggAAFRpbWVzdGFtcERhdGUzMkRhdGU2NAAAAAAAAAAEAAAABAAAACoEAABUaW1lMzJUaW1lNjREdXJhdGlvbgAAAAAEAAAABAAAAMwEAABJbnRlcnZhbEJpbmFyeQAAAAAAAAQAAAAEAAAAbQMAAEZpeGVkU2l6ZUJpbmFyeUxhcmdlQmluYXJ5QmluYXJ5Vmlld1V0ZjhMYXJnZVV0ZjhVdGY4VmlldwAAAAAAAAAEAAAABAAAADMIAABMaXN0TGlzdFZpZXeUDgAABAAAAAQAAAA1CAAARml4ZWRTaXplTGlzdExhcmdlTGlzdExhcmdlTGlzdFZpZXcAAAAAAAQAAAAEAAAANggAAFN0cnVjdAAAlQ4AAAgAAAAEAAAAOAgAAAAAAAAEAAAABAAAADkIAABVbmlvbgAAAJYOAAAEAAAABAAAADsIAAAAAAAABAAAAAQAAAAXBgAARGljdGlvbmFyeQAAAAAAAAEAAAABAAAAlw4AAAAAAAAEAAAABAAAABEFAABEZWNpbWFsMzJEZWNpbWFsNjREZWNpbWFsMTI4RGVjaW1hbDI1NgAAAAAAAAQAAAAEAAAAPQgAAE1hcFJ1bkVuZEVuY29kZWRTZWNvbmRNaWxsaXNlY29uZE1pY3Jvc2Vjb25kTmFub3NlY29uZAAABgAAAAsAAAALAAAACgAAABT2IQAa9iEAJfYhADD2IQDXMhAAeAAAAOsHAAAJAAAA8lkQAG8AAAAZAQAAGQAAAJoOAAAMAAAABAAAAJsOAACcDgAAgQ4AQZzthwELgQcBAAAAnQ4AAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkA4l8QAGsAAAAPCwAADgAAAM4FA5hqJmElzQK+h5WqMNlFcnJvcgAAAOJfEABrAAAAzwwAAA4AAABOb3QgeWV0IGltcGxlbWVudGVkOiAAAAAU9yEAFQAAAEV4dGVybmFsIGVycm9yOiA09yEAEAAAAENhc3QgZXJyb3I6IEz3IQAMAAAATWVtb3J5IGVycm9yOiAAAGD3IQAOAAAAUGFyc2VyIGVycm9yOiAAAHj3IQAOAAAAU2NoZW1hIGVycm9yOiAAAJD3IQAOAAAAQ29tcHV0ZSBlcnJvcjogAKj3IQAPAAAARGl2aWRlIGJ5IHplcm8gZXJyb3JBcml0aG1ldGljIG92ZXJmbG93OiAAAADU9yEAFQAAAENzdiBlcnJvcjogAPT3IQALAAAASnNvbiBlcnJvcjogCPghAAwAAABJbyBlcnJvcjogAAAc+CEACgAAAElwYyBlcnJvcjogADD4IQALAAAASW52YWxpZCBhcmd1bWVudCBlcnJvcjogRPghABgAAABQYXJxdWV0IGFyZ3VtZW50IGVycm9yOiBk+CEAGAAAAEMgRGF0YSBpbnRlcmZhY2UgZXJyb3I6IIT4IQAYAAAARGljdGlvbmFyeSBrZXkgYmlnZ2VyIHRoYW4gdGhlIGtleSB0eXBlUnVuIGVuZCBlbmNvZGVkIGFycmF5IGluZGV4IG92ZXJmbG93IGVycm9yT2Zmc2V0IG92ZXJmbG93IGVycm9yOiD1+CEAFwAAAJ4OAAAIAAAABAAAAIYAAACeDgAACAAAAAQAAABTAgAAhgAAABT5IQBUAgAAnw4AAFYCAABXAgAAoA4AALAbEABnAAAAswEAAA8AAACwGxAAZwAAAJEBAAAaAAAAAAAAAAQAAAAAAAAARxsQAGgAAADwAQAAFgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAow4AAAwAAAAEAAAApA4AAAEAAAAAAAAA+HgQAGYAAABVAAAAHgAAAPh4EABmAAAAVgAAAB8AAAD4eBAAZgAAADgBAAAWAAAA+HgQAGYAAAA7AQAASAAAAPh4EABmAAAAPAEAAD4AQaj0hwELrQYBAAAApQ4AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWVMYXlvdXRFcnJvcmZhaWxlZCB0byBjcmVhdGUgbGF5b3V0IGZvciBNdXRhYmxlQnVmZmVyALVtEABqAAAAWgAAAA4AAAC1bRAAagAAAHgAAAA+AAAAYXNzZXJ0aW9uIGZhaWxlZDogZW5kIDw9IHNlbGYubGF5b3V0LnNpemUoKQC1bRAAagAAAK4AAAAJAAAAtW0QAGoAAADjAAAAUQAAAGFzc2VydGlvbiBmYWlsZWQ6IHByZWZpeC5pc19lbXB0eSgpICYmIHN1ZmZpeC5pc19lbXB0eSgptW0QAGoAAACKAQAACQAAAAAAAABkaXZpc2lvbiBieSB6ZXJvSPshABAAAADiExAAZgAAACAAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogbiArIG0gPD0gTuITEABmAAAAWQAAAAUAAADiExAAZgAAAGwAAAARAAAA4hMQAGYAAAB0AAAADgAAAOITEABmAAAAegAAABIAAADiExAAZgAAAIgAAAAWAAAA4hMQAGYAAAChAAAAKgAAAOITEABmAAAArgAAAAkAAADiExAAZgAAANEAAAAKAAAAYXNzZXJ0aW9uIGZhaWxlZDogb2Zmc2V0X3dyaXRlICsgbGVuIDw9IHdyaXRlX2RhdGEubGVuKCkgKiA4YloQAGkAAAAjAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IG9mZnNldF9yZWFkICsgbGVuIDw9IGRhdGEubGVuKCkgKiA4AAAAYloQAGkAAAAkAAAABQAAAGYsEABhAAAA7wAAADQAAACmDgAAEAAAAAQAAABjMhAAcwAAADkAAAAdAAAAYzIQAHMAAAB2AAAAHgAAAGFzc2VydGlvbiBmYWlsZWQ6IGNlaWwob2Zmc2V0ICsgbGVuLCA4KSA8PSBidWZmZXIubGVuKCkgKiA4AGMyEABzAAAA4AAAAAkAAABjMhAAcwAAAOsAAAAcAAAAGlUQAGcAAABkAAAAPQAAACRXEABpAAAAOAAAAAUAQeD6hwEL6QEBAAAApw4AAExheW91dEVycm9yZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXK1bRAAagAAAFoAAAAOAAAAVHJ1c3RlZCBpdGVyYXRvciBsZW5ndGggd2FzIG5vdCBhY2N1cmF0ZWx5IHJlcG9ydGVkAKz9IQAzAAAAtW0QAGoAAACGAgAACQAAAHQnEABmAAAAWAAAACEAAAB0JxAAZgAAAHoAAAAhAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgBB1PyHAQuBAwEAAACoDgAATGF5b3V0RXJyb3J0aGUgb2Zmc2V0IG9mIHRoZSBuZXcgQnVmZmVyIGNhbm5vdCBleGNlZWQgdGhlIGV4aXN0aW5nIGxlbmd0aDogb2Zmc2V0PSBsZW5ndGg9AABn/iEARwAAAK7+IQAIAAAASG0QAGwAAAAVAQAACQAAAHRoZSBvZmZzZXQgb2YgdGhlIG5ldyBCdWZmZXIgY2Fubm90IGV4Y2VlZCB0aGUgZXhpc3RpbmcgbGVuZ3RoOiBzbGljZSBvZmZzZXQ9IHNlbGZsZW49AADY/iEATQAAAK7+IQAIAAAAJf8hAAkAAABIbRAAbAAAACwBAAAJAAAAZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXIAAAC1bRAAagAAAFoAAAAOAAAAYlAQAGsAAAC9AAAAPAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAQeD/hwELpQQBAAAAqQ4AAExheW91dEVycm9yZmFpbGVkIHRvIGNyZWF0ZSBsYXlvdXQgZm9yIE11dGFibGVCdWZmZXK1bRAAagAAAFoAAAAOAAAAYnVmZmVyIG5vdCBsYXJnZSBlbm91Z2ggKG9mZnNldDogLCBsZW46ICwgYnVmZmVyX2xlbjogKQAsACIAIQAAAE0AIgAHAAAAVAAiAA4AAABiACIAAQAAAPdPEABqAAAAQQAAAAkAAAB0aGUgbGVuZ3RoICsgb2Zmc2V0IG9mIHRoZSBzbGljZWQgQm9vbGVhbkJ1ZmZlciBjYW5ub3QgZXhjZWVkIHRoZSBleGlzdGluZyBsZW5ndGgAAACUACIAUQAAAPdPEABqAAAAowAAAAkAAAD3TxAAagAAAO4AAAAJAAAAYlAQAGsAAAC9AAAAPAAAAGZhaWxlZCB0byByb3VuZCB1cHRvIG11bHRpcGxlIG9mIDY0ACRXEABpAAAAGAAAAAoAAABhc3NlcnRpb24gZmFpbGVkOiBsZW4gPD0gYnVmZmVyLmxlbigpICogOAAAAGJQEABrAAAAMQAAAAkAAABiUBAAawAAAIgAAAAuAAAAZmFpbGVkIHRvIHJvdW5kIHVwdG8gbXVsdGlwbGUgb2YgNjQAJFcQAGkAAAAYAAAACgAAADqGEABwAAAALgIAABEAAABiIiJcblxyXHRcAADtASIAAQAAAFwwXHj6ASIAAgAAAAIAQY6EiAELAQIAQZiEiAELXSAAAOkBAAAAAAAAAGFkdmFuY2Ugb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IGFkdmFuY2luZyBieSAkAiIAIgAAAEYCIgASAAAABJQQAFgAAACsAAAABQBBgIWIAQvVDAEAAACsDgAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZUxheW91dEVycm9yAADOdRAAagAAAL0BAAAdAAAAqAEAAKkBAACqAQAArQ4AAK4OAAByYW5nZSBzdGFydCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gZW5kOiAgPD0gAADkAiIAKgAAAA4DIgAEAAAACywQAFoAAACGAQAACQAAAHJhbmdlIGVuZCBvdXQgb2YgYm91bmRzOiAAAAA0AyIAGQAAAA4DIgAEAAAACywQAFoAAACMAQAACQAAAHNwbGl0X3RvIG91dCBvZiBib3VuZHM6IHADIgAYAAAADgMiAAQAAAALLBAAWgAAAC4CAAAJAAAACywQAFoAAADOAwAAJAAAAK8OAACwDgAAsQ4AALIOAACzDgAAtA4AALUOAAC2DgAAsg4AALcOAAALLBAAWgAAAEgFAAAyAAAACywQAFoAAABWBQAASQAAALgOAAC5DgAAug4AALsOAAC8DgAAznUQAGoAAAC9AQAAHQAAAG92ZXJmbG93eBQQAF4AAACqAgAAFQAAAHgUEABeAAAAAAMAACcAAAB4FBAAXgAAANQCAAA4AAAAvQ4AAL4OAAC/DgAAwA4AAMEOAABtaWQgPiBsZW4AAABwBCIACQAAAC9LEABpAAAAOwAAABoAAAAvSxAAaQAAAGoAAAAiAAAAL0sQAGkAAABvAAAAFwAAAA1MEABsAAAAhwAAACUAAAABAAAAAx0QAGAAAAAsAAAAHQAAAAMdEABgAAAAYwMAABcAAABtaWQgPiBsZW4AAADoBCIACQAAAM51EABqAAAAvQEAAB0AAAAAAAAABAAAAAAAAAABAAAAL0sQAGkAAAA7AAAAGgAAAC9LEABpAAAAiQAAABsAAAAvSxAAaQAAAI4AAAAbAAAAekwQAG8AAAAsAAAAHAAAAAAAAABjYXJyeSBvdmVyZmxvdyBkdXJpbmcgbXVsdGlwbGljYXRpb24hAAAAYAUiACUAAAB6TBAAbwAAADkAAAAFAAAAekwQAG8AAABIAAAAGwAAAHpMEABvAAAAUAAAABsAAAB6TBAAbwAAAC0BAAAmAAAAekwQAG8AAAAxAQAAJgAAAHpMEABvAAAAMgEAACYAAAB6TBAAbwAAAJMBAAAnAAAAekwQAG8AAACSAQAAJgAAAHpMEABvAAAA5wAAABoAAAB6TBAAbwAAAOwAAAAlAAAAekwQAG8AAAD0AAAAFgAAAHpMEABvAAAA9QAAABYAAAB6TBAAbwAAAKQAAAAWAAAAekwQAG8AAABoAAAAHwAAAHpMEABvAAAAnAEAACQAAAB6TBAAbwAAAK8BAAAcAAAAekwQAG8AAAC5AQAADwAAAHpMEABvAAAAvAEAAA8AAAAAAAAABAAAAAAAAAADHRAAYAAAACwAAAAdAAAAAx0QAGAAAABjAwAAFwAAANcyEAB4AAAA6wcAAAkAAABjaHVuayBzaXplIG11c3QgYmUgbm9uLXplcm8A7AYiABsAAABhdHRlbXB0IHRvIGRpdmlkZSBieSB6ZXJvAAAAEAciABkAAACyTRAAaQAAAFcAAAAJAAAARxsQAGgAAAAwAAAAIAAAAEcbEABoAAAAMwAAAAoAAAAAAAAABAAAAAAAAABHGxAAaAAAAPABAAAWAAAARxsQAGgAAABeAgAAIAAAAEcbEABoAAAAYgIAABMAAABHGxAAaAAAAGQCAAAYAAAARxsQAGgAAABtAgAADQAAAEcbEABoAAAAZgIAABEAAABHGxAAaAAAAHwCAAATAAAARxsQAGgAAACTAgAADQAAAEcbEABoAAAAhgIAABEAAABHGxAAaAAAAK4CAAATAAAARxsQAGgAAADlAgAAHAAAAEcbEABoAAAA5wIAABIAAABHGxAAaAAAAOcCAAANAAAARxsQAGgAAADfAgAAFgAAAEcbEABoAAAA3wIAABEAAABHGxAAaAAAANUCAAAeAAAARxsQAGgAAADVAgAAGQAAAEcbEABoAAAA9AIAAAwAAABUaGUgcmFkaXggbXVzdCBiZSB3aXRoaW4gMi4uLjM2AJAIIgAfAAAARxsQAGgAAAADAwAABQAAAEcbEABoAAAAJgMAAAUAQfCRiAELBanmAAAKAEGAkogBCxUJPQAABgAAAEC2AAAGAAAAp0EAAAUAQaCSiAELNanmAAAFAAAAECcAAAQAAAAxOQAABAAAAABRAAAEAAAAkW8AAAQAAAAQlgAABAAAAMHFAAAEAEHgkogBC3UxEwAAAwAAAMgWAAADAAAAyxoAAAMAAABAHwAAAwAAAC0kAAADAAAAmCkAAAMAAACHLwAAAwAAAAA2AAADAAAACT0AAAMAAACoRAAAAwAAAONMAAADAAAAwFUAAAMAAABFXwAAAwAAAHhpAAADAAAAX3QAAAMAQeCTiAEL9QFhjAAAAwAAAIiZAAADAAAAe6cAAAMAAABAtgAAAwAAAN3FAAADAAAAWNYAAAMAAAC35wAAAwAAAAD6AAADAAAAkQYAAAIAAADkBgAAAgAAADkHAAACAAAAkAcAAAIAAADpBwAAAgAAAEQIAAACAAAAoQgAAAIAAAAACQAAAgAAAGEJAAACAAAAxAkAAAIAAAApCgAAAgAAAJAKAAACAAAA+QoAAAIAAABkCwAAAgAAANELAAACAAAAQAwAAAIAAACxDAAAAgAAACQNAAACAAAAmQ0AAAIAAAAQDgAAAgAAAIkOAAACAAAABA8AAAIAAACBDwAAAgBB4JWIAQv1A4EQAAACAAAABBEAAAIAAACJEQAAAgAAABASAAACAAAAmRIAAAIAAAAkEwAAAgAAALETAAACAAAAQBQAAAIAAADRFAAAAgAAAGQVAAACAAAA+RUAAAIAAACQFgAAAgAAACkXAAACAAAAxBcAAAIAAABhGAAAAgAAAAAZAAACAAAAoRkAAAIAAABEGgAAAgAAAOkaAAACAAAAkBsAAAIAAAA5HAAAAgAAAOQcAAACAAAAkR0AAAIAAABAHgAAAgAAAPEeAAACAAAApB8AAAIAAABZIAAAAgAAABAhAAACAAAAySEAAAIAAACEIgAAAgAAAEEjAAACAAAAACQAAAIAAADBJAAAAgAAAIQlAAACAAAASSYAAAIAAAAQJwAAAgAAANknAAACAAAApCgAAAIAAABxKQAAAgAAAEAqAAACAAAAESsAAAIAAADkKwAAAgAAALksAAACAAAAkC0AAAIAAABpLgAAAgAAAEQvAAACAAAAITAAAAIAAAAAMQAAAgAAAOExAAACAAAAxDIAAAIAAACpMwAAAgAAAJA0AAACAAAAeTUAAAIAAABkNgAAAgAAAFE3AAACAAAAQDgAAAIAAAAxOQAAAgAAACQ6AAACAAAAGTsAAAIAAAAQPAAAAgAAAAk9AAACAAAABD4AAAIAAAABPwAAAgBB4JmIAQv1BwFBAAACAAAABEIAAAIAAAAJQwAAAgAAABBEAAACAAAAGUUAAAIAAAAkRgAAAgAAADFHAAACAAAAQEgAAAIAAABRSQAAAgAAAGRKAAACAAAAeUsAAAIAAACQTAAAAgAAAKlNAAACAAAAxE4AAAIAAADhTwAAAgAAAABRAAACAAAAIVIAAAIAAABEUwAAAgAAAGlUAAACAAAAkFUAAAIAAAC5VgAAAgAAAORXAAACAAAAEVkAAAIAAABAWgAAAgAAAHFbAAACAAAApFwAAAIAAADZXQAAAgAAABBfAAACAAAASWAAAAIAAACEYQAAAgAAAMFiAAACAAAAAGQAAAIAAABBZQAAAgAAAIRmAAACAAAAyWcAAAIAAAAQaQAAAgAAAFlqAAACAAAApGsAAAIAAADxbAAAAgAAAEBuAAACAAAAkW8AAAIAAADkcAAAAgAAADlyAAACAAAAkHMAAAIAAADpdAAAAgAAAER2AAACAAAAoXcAAAIAAAAAeQAAAgAAAGF6AAACAAAAxHsAAAIAAAApfQAAAgAAAJB+AAACAAAA+X8AAAIAAABkgQAAAgAAANGCAAACAAAAQIQAAAIAAACxhQAAAgAAACSHAAACAAAAmYgAAAIAAAAQigAAAgAAAImLAAACAAAABI0AAAIAAACBjgAAAgAAAACQAAACAAAAgZEAAAIAAAAEkwAAAgAAAImUAAACAAAAEJYAAAIAAACZlwAAAgAAACSZAAACAAAAsZoAAAIAAABAnAAAAgAAANGdAAACAAAAZJ8AAAIAAAD5oAAAAgAAAJCiAAACAAAAKaQAAAIAAADEpQAAAgAAAGGnAAACAAAAAKkAAAIAAAChqgAAAgAAAESsAAACAAAA6a0AAAIAAACQrwAAAgAAADmxAAACAAAA5LIAAAIAAACRtAAAAgAAAEC2AAACAAAA8bcAAAIAAACkuQAAAgAAAFm7AAACAAAAEL0AAAIAAADJvgAAAgAAAITAAAACAAAAQcIAAAIAAAAAxAAAAgAAAMHFAAACAAAAhMcAAAIAAABJyQAAAgAAABDLAAACAAAA2cwAAAIAAACkzgAAAgAAAHHQAAACAAAAQNIAAAIAAAAR1AAAAgAAAOTVAAACAAAAudcAAAIAAACQ2QAAAgAAAGnbAAACAAAARN0AAAIAAAAh3wAAAgAAAADhAAACAAAA4eIAAAIAAADE5AAAAgAAAKnmAAACAAAAkOgAAAIAAAB56gAAAgAAAGTsAAACAAAAUe4AAAIAAABA8AAAAgAAADHyAAACAAAAJPQAAAIAAAAZ9gAAAgAAABD4AAACAAAACfoAAAIAAAAE/AAAAgAAAAH+AAACAEHgoYgBC4EwAx0QAGAAAAAsAAAAHQAAAAMdEABgAAAAVgMAACsAAAADHRAAYAAAAGMDAAAXAAAAOoYQAHAAAAAuAgAAEQAAAPyGEABsAAAA4goAACQAAADOdRAAagAAAL0BAAAdAAAAoTgQAG4AAAD2BQAAFQAAAG1pZCA+IGxlbgAAAFARIgAJAAAAL0sQAGkAAAA7AAAAGgAAAGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAAB0ESIAGQAAALJNEABpAAAAVwAAAAkAAAAAAAAABAAAAAAAAACyTRAAaQAAAO4AAAAfAAAAsk0QAGkAAADSAAAACQAAALJNEABpAAAAFQEAAA4AAACyTRAAaQAAABYBAAAOAAAAsk0QAGkAAAAaAQAADwAAALJNEABpAAAAUQEAAAwAAACyTRAAaQAAACABAAAhAAAAsk0QAGkAAAAhAQAAGAAAALJNEABpAAAAQgEAADwAAACyTRAAaQAAAEsBAAAPAAAARxsQAGgAAADwAQAAFgAAAAMdEABgAAAALAAAAB0AAAADHRAAYAAAAGMDAAAXAAAAznUQAGoAAAC9AQAAHQAAAHkfEABmAAAAHgAAABwAAAB5HxAAZgAAACgAAAAZAAAAeR8QAGYAAAAuAAAAEgAAAHkfEABmAAAASgAAACMAAAADHRAAYAAAAGMDAAAXAAAAbWlkID4gbGVuAAAA5BIiAAkAAABuZWdhdGl2ZSB2YWx1ZXMgYXJlIG5vbi16ZXJv4B8QAGUAAABmAAAAKAAAAC9LEABpAAAAOwAAABoAAAAAAAAABAAAAAQAAAC7CQAAQ2Fubm90IHN1YnRyYWN0IGIgZnJvbSBhIGJlY2F1c2UgYiBpcyBsYXJnZXIgdGhhbiBhLkQTIgA0AAAADUwQAGwAAABFAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGFfaGkuaXNfZW1wdHkoKQAAAA1MEABsAAAAYgAAAAUAAAANTBAAbAAAAGUAAAAFAAAAkSQQAGAAAACDAQAAAQAAAMMOAAAEAAAABAAAAMQOAADFDgAAww4AAAQAAAAEAAAAxg4AAMcOAABGbk9uY2UgY2FsbGVkIG1vcmUgdGhhbiBvbmNlyA4AAAQAAAAEAAAAyQ4AAMoOAAC6ZRAAaQAAACUAAAAuAAAAumUQAGkAAAAoAAAAKQAAALplEABpAAAAPgAAABoAAAC6ZRAAaQAAAD4AAAAnAAAAx5EQAGcAAACxAAAADwAAAMeREABnAAAAkQAAACcAAADHkRAAZwAAALsAAAAkAAAAY2xvc3VyZSBpbnZva2VkIHJlY3Vyc2l2ZWx5IG9yIGFmdGVyIGJlaW5nIGRyb3BwZWRMYXp5IGluc3RhbmNlIGhhcyBwcmV2aW91c2x5IGJlZW4gcG9pc29uZWTeFCIAKgAAAC+SEABcAAAACAMAABkAAAByZWVudHJhbnQgaW5pdAAAIBUiAA4AAAAvkhAAXAAAAHoCAAANAAAAHI0QAHUAAAAiAAAAFQAAAM4OAADPDgAA0A4AANEOAAAcjRAAdQAAAGcAAAAlAAAA0g4AAAgAAAAEAAAA0w4AAFdUEABhAAAAVQAAADUAAAABAAAAAAAAAAEAAAAAAAAAzBoQAHoAAAALAAAABQAAANk5EAB4AAAANwEAAEQAAABwtyIAfLciAIi3IgCUtyIAcmV0dXJuIHRoaXMATpMQAFkAAADsGQAAAQAAAExhenkgaW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAA9BUiACoAAAAvkhAAXAAAAAgDAAAZAAAAcmVlbnRyYW50IGluaXQAADgWIgAOAAAAL5IQAFwAAAB6AgAADQAAAHQuEABrAAAAIwEAAA4AAABjbG9zdXJlIGludm9rZWQgcmVjdXJzaXZlbHkgb3IgYWZ0ZXIgYmVpbmcgZHJvcHBlZGNhbGxlZCBgT3B0aW9uOjp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWVudWxsIHBvaW50ZXIgcGFzc2VkIHRvIHJ1c3RyZWN1cnNpdmUgdXNlIG9mIGFuIG9iamVjdCBkZXRlY3RlZCB3aGljaCB3b3VsZCBsZWFkIHRvIHVuc2FmZSBhbGlhc2luZyBpbiBydXN0SnNWYWx1ZSgpAAA9FyIACAAAAEUXIgABAAAAEDkQAG8AAACQAAAALgAAAMZiEABmAAAAfgAAABEAAADGYhAAZgAAAIsAAAARAAAAdC4QAGsAAADnAAAAAQAAAFRKEABvAAAAPAYAABQAAABUShAAbwAAADwGAAAhAAAAVEoQAG8AAAAwBgAAFAAAAFRKEABvAAAAMAYAACEAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbinOdRAAagAAAL0BAAAdAAAAVEoQAG8AAAC9BAAAJAAAACBhdCBsaW5lICBjb2x1bW4gaW52YWxpZCB0eXBlOiAsIGV4cGVjdGVkIAAAORgiAA4AAABHGCIACwAAAGZsb2F0aW5nIHBvaW50IGBgAAAAZBgiABAAAAB0GCIAAQAAAG51bGxQMxAAYAAAAOcBAAAqAAAAUDMQAGAAAAD3AQAAIQAAAFAzEABgAAAA+wEAAAwAAABQMxAAYAAAAAICAAAhAAAAUDMQAGAAAAALAgAAKgAAAFAzEABgAAAADwIAACwAAABQMxAAYAAAABQCAAAJAAAAdWxscnVlYWxzZQAAAAAAAAAA8D8AAAAAAAAkQAAAAAAAAFlAAAAAAABAj0AAAAAAAIjDQAAAAAAAavhAAAAAAICELkEAAAAA0BJjQQAAAACE15dBAAAAAGXNzUEAAAAgX6ACQgAAAOh2SDdCAAAAopQabUIAAEDlnDCiQgAAkB7EvNZCAAA0JvVrDEMAgOA3ecNBQwCg2IVXNHZDAMhOZ23Bq0MAPZFg5FjhQ0CMtXgdrxVEUO/i1uQaS0SS1U0Gz/CARPZK4ccCLbVEtJ3ZeUN46kSRAigsKosgRTUDMrf0rVRFAoT+5HHZiUWBEh8v5yfARSHX5vrgMfRF6oygOVk+KUYksAiI741fRhduBbW1uJNGnMlGIuOmyEYDfNjqm9D+RoJNx3JhQjNH4yB5z/kSaEcbaVdDuBeeR7GhFirTztJHHUqc9IeCB0ilXMPxKWM9SOcZGjf6XXJIYaDgxHj1pkh5yBj21rLcSEx9z1nG7xFJnlxD8LdrRknGM1TspQZ8SVygtLMnhLFJc8ihoDHl5UmPOsoIfl4bSppkfsUOG1FKwP3ddtJhhUowfZUUR7q6Sj5u3WxstPBKzskUiIfhJEtB/Blq6RlaS6k9UOIxUJBLE03kWj5kxEtXYJ3xTX35S224BG6h3C9MRPPC5OTpY0wVsPMdXuSYTBuccKV1Hc9MkWFmh2lyA031+T/pA084TXL4j+PEYm5NR/s5Drv9ok0ZesjRKb3XTZ+YOkZ0rA1OZJ/kq8iLQk49x93Wui53Tgw5lYxp+qxOp0Pd94Ec4k6RlNR1oqMWT7W5SROLTExPERQO7NavgU8WmRGnzBu2T1v/1dC/outPmb+F4rdFIVB/LyfbJZdVUF/78FHv/IpQG502kxXewFBiRAT4mhX1UHtVBbYBWypRbVXDEeF4YFHIKjRWGZeUUXo1wavfvMlRbMFYywsWAFLH8S6+jhs0Ujmuum1yImlSx1kpCQ9rn1Id2Lll6aLTUiROKL+jiwhTrWHyroyuPlMMfVftFy1zU09crehd+KdTY7PYYnX23VMecMddCboSVCVMObWLaEdULp+Hoq5CfVR9w5QlrUmyVFz0+W4Y3OZUc3G4ih6THFXoRrMW89tRVaIYYNzvUoZVyh5406vnu1U/Eytky3DxVQ7YNT3+zCVWEk6DzD1AW1bLENKfJgiRVv6UxkcwSsVWPTq4Wbyc+lZmJBO49aEwV4DtFyZzymRX4Oid7w/9mVeMscL1KT7QV+9dM3O0TQRYazUAkCFhOVjFQgD0ablvWLspgDji06NYKjSgxtrI2Fg1QUh4EfsOWcEoLevqXENZ8XL4pSU0eFmtj3YPL0GuWcwZqmm96OJZP6AUxOyiF1pPyBn1p4tNWjIdMPlId4JafiR8NxsVt1qeLVsFYtrsWoL8WEN9CCJbozsvlJyKVluMCju5Qy2MW5fmxFNKnMFbPSC26FwD9ltNqOMiNIQrXDBJzpWgMmFcfNtBu0h/lVxbUhLqGt/KXHlzS9JwywBdV1DeBk3+NF1t5JVI4D1qXcSuXS2sZqBddRq1OFeA1F0SYeIGbaAJXqt8TSREBEBe1ttgLVUFdF7MErl4qgapXn9X5xZVSN9er5ZQLjWNE19bvOR5gnBIX3LrXRijjH5fJ7M67+UXs1/xXwlr393nX+23y0VX1R1g9FKfi1alUmCxJ4curE6HYJ3xKDpXIr1gApdZhHY18mDD/G8l1MImYfT7yy6Jc1xheH0/vTXIkWHWXI8sQzrGYQw0s/fTyPthhwDQeoRdMWKpAISZ5bRlYtQA5f8eIptihCDvX1P10GKl6Oo3qDIFY8+i5UVSfzpjwYWva5OPcGMyZ5tGeLOkY/5AQlhW4Nljn2gp9zUsEGTGwvN0QzdEZHizMFIURXlkVuC8ZlmWr2Q2DDbg973jZEOPQ9h1rRhlFHNUTtPYTmXsx/QQhEeDZej5MRVlGbhlYXh+Wr4f7mU9C4/41tMiZgzOsrbMiFdmj4Ff5P9qjWb5sLvu32LCZjidauqX+/ZmhkQF5X26LGfUSiOvjvRhZ4kd7FqycZZn6ySn8R4OzGcTdwhX04gBaNeUyiwI6zVoDTr9N8pla2hIRP5inh+haFrVvfuFZ9VosUqtemfBCmmvTqys4LhAaVpi19cY53Rp8TrNDd8gqmnWRKBoi1TgaQxWyEKuaRRqj2t60xmESWpzBllIIOV/agikNy0077NqCo2FOAHr6GpM8KaGwSUfazBWKPSYd1Nru2syMX9ViGuqBn/93mq+aypkb17LAvNrNT0LNn7DJ2yCDI7DXbRdbNHHOJq6kJJsxvnGQOk0x2w3uPiQIwL9bCNzmzpWITJt609CyaupZm3m45K7FlScbXDOOzWOtNFtDMKKwrEhBm6Pci0zHqo7bpln/N9SSnFuf4H7l+ecpW7fYfp9IQTbbix9vO6U4hBvdpxrKjobRW+Ugwa1CGJ6bz0SJHFFfbBvzBZtzZac5G9/XMiAvMMZcM85fdBVGlBwQ4icROsghHBUqsMVJim5cOmUNJtvc+9wEd0AwSWoI3FWFEExL5JYcWtZkf26to5x49d63jQyw3HcjRkWwv73cVPxn5ty/i1y1PZDoQe/YnKJ9JSJyW6Xcqsx+ut7Ss1yC198c41OAnPNdlvQMOI2c4FUcgS9mmxz0HTHIrbgoXMEUnmr41jWc4amV5Yc7wt0FMj23XF1QXQYenRVztJ1dJ6Y0eqBR6t0Y//CMrEM4XQ8v3N/3U8VdQuvUN/Uo0p1Z22SC2WmgHXACHdO/s+0dfHKFOL9A+p11v5MrX5CIHaMPqBYHlNUdi9OyO7lZ4l2u2F6at/Bv3YVfYyiK9nzdlqcL4t2zyh3cIP7LVQDX3cmMr2cFGKTd7B+7MOZOsh3XJ7nNEBJ/nf5whAhyO0yeLjzVCk6qWd4pTCqs4iTnXhnXkpwNXzSeAH2XMxCGwd5gjN0fxPiPHkxoKgvTA1yeT3IkjufkKZ5TXp3Csc03HlwrIpm/KAReoxXLYA7CUZ6b604YIqLe3plbCN8Njexen9HLBsEheV6Xln3IUXmGnvblzo1689Qe9I9iQLmA4V7Ro0rg99EuntMOPuxC2vwe18Gep7OhSR89ocYRkKnWXz6VM9riQiQfDgqw8arCsR8x/RzuFYN+Xz48ZBmrFAvfTuXGsBrkmN9Cj0hsAZ3mH1MjClcyJTOfbD3mTn9HAN+nHUAiDzkN34DkwCqS91tfuJbQEpPqqJ+2nLQHONU136QjwTkGyoNf7rZgm5ROkJ/KZAjyuXIdn8zdKw8H3usf6DI64XzzOF/4l8QAGsAAADPDAAADgAAADqGEABwAAAALgIAABEAAADpDgAADAAAAAQAAADqDgAA6w4AACAAAACSjRAAXwAAAKYBAABFAAAAko0QAF8AAACrAQAAPQAAAJKNEABfAAAAswEAABoAAACSjRAAXwAAAAACAAATAAAAko0QAF8AAAAJAgAAPgAAAJKNEABfAAAABQIAADMAAACSjRAAXwAAAA8CAAA6AAAAko0QAF8AAABuAgAAGQAAAJKNEABfAAAAcgMAABkAAACSjRAAXwAAAHMDAAAaAAAAko0QAF8AAAB0AwAAGQAAAJKNEABfAAAAdQMAABkAAACSjRAAXwAAAHYDAAAZAAAAko0QAF8AAAB3AwAAGQAAAJKNEABfAAAAeAMAABkAAACSjRAAXwAAAHkDAAAZAAAAko0QAF8AAADUAwAAEQAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAQACAAMABAAFAAYABwAIAAkA//////////////////8KAAsADAANAA4ADwD/////////////////////////////////////////////////////////////////////CgALAAwADQAOAA8A////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAQACAAMABAAFAAYABwAIAAkAD//////////////////6AAsADAANAA4ADwAP////////////////////////////////////////////////////////////////////+gALAAwADQAOAA8AD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////OdRAAagAAAL0BAAAdAAAAMDAwMTAyMDMwNDA1MDYwNzA4MDkxMDExMTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5Nzk4OTlpbmYtaW5mTmFOAAAAAAAAAQBB79GIAQvRKiCamZmZmZmZmZmZmZmZmZkZFa5H4XoUrkfhehSuR+F6FN4kBoGVQ4ts5/up8dJNYhCW1AloImx4eqUsQxzr4jYaq0Nuhhvw+WGE8GjjiLX4FCI2WDhJ88e0No3ttaD3xhBqI43ADlKmh1dIr7ya8tcaiE/XZqVBuJ/fOYww4o55FQemEh9RAS3mspTWJugLLhGkCVHLgWiu1re6vdfZ33wb6jqnojTt8d5flWR54X/9FbvIhej28Cd/GRHqLYGZlxH4DdZAvrQMZcKBdklowiUck3HeM5iQcOoBmyuhhpuEFkPBfingpvMhmxVW556vAxI3NTEPzdeFaSu8idiXstIc+ZBaP9ffNyGJltRGRvUOF/pzSMxF5l/noKtD0tFdchJdhg16PD1mpTSs0rZPyYMdsZ7XlGOXHlFdI0KSDKGcF8FLed2C337afU+bDgq04xJorFti0ZhkKpblXhcQIDkeU/Digafgtu5EUbISQLMtGKkmT85STZJYaqeOqJnCVxNBpH6wt3tQJ6rYfdr10PIeNFBlwF/JplK7E8uuxEDCGJCm6plM1OsOyQ888jaazhOAChHDrVN5sUEZYFC+9rAfZwh0AovcLcFnR7Om/l5aGVKgKTVvsCQ0hp/C6/5LSBTbGe6Q8lkdkJ5/aIll1jkQXymwtB3D+0yXMqeo1SP2GbK6WV2xNZY9rFsfunfpxBQoYuF9J16rl1ZJTPuSh50QDZ1oydjJq/LwDnr4t6WVGj4Xujp6obxbWnIuLZOERBXLRfsuyBrKr66Oi4pCnQMRRQmSsab33LJK5Hiqnfs4GwShQcHrkn31boMtVbEvxxUDtGdniXVkxFicV3cnJmwR0uyl2NuIbW30xiXyCz3gG9sj60YWB76KwzgeKKP9TBZJtlXSEWz+bpxgS1NPMdcRDorvtk8Tl7FgZ0WFGIKLHKWhv/hyD6wnGrlqN60B1hYeTplgwnJWueFgVSwkzkQSlRbCzQMeV/U1zrsTbeM6HaurAQsDGKwqK9gvdopPYhdWiTRvAuC8u1UT88RuDLUSiajtsdDMx5LvHrjUSnruHQe6V45ACtPb8kuTEG/78RcGyN9xANWofPVvD9pY/CcT1gxm6TO7p/q7TLIpjmCmHhHXhIcp/FKVyaOOVAsahRgOrNDSusmoqgeD2HZvrp0T46waHl7c2t2l0cBXsrBiH0+KSEtLsEh+UUGarI7AGxnZodPV1Vlty9rN4ValMxYUe4HcdxF7Vzzi1+er6sIRECrPYFmCXvLGNiamrKoEthm7pYBHaBj1a8VR61ZVnZEUloQABu15KiPRpyLf3X10EFYHNKPhj93RgQzRMZb8UxpFbPboGnPkpzQ9p/RE/Q8Vnlb4U+IoHVNdl1JdapfZEGJXjbkD22HrLvJQlRC/9RroRaTHz0hOvFhb2t2mZZEVIGuDbNnTcWOt4uEXHx5BEc0Rn60ohhyfSAQD82RjmxsL2xi+U2uw5QadNY8d6RUWohVHyw+J8+prSpFy5CCrETe8cXhM27hERqobhG0BRRxfY8HG1hXHAwVVSQO+mp0WGenNa0XeODY3dwdp/q4XEsFBFkaiY8FWWFhyDpex8hzOZ6vRgRwB33kT9XESjigXpexVQc4WNH9h3JDBDtiGEm5HVjV9JCBlAsfnaOSMpB0lOXj3MB2A6gFsuSAd17YXhPos+fOwmbs0I2FNF6z4Ejn3RyhTTlxfVDhoFfKsWh4uLNO5dQt9f0NgU0RbikgYWCPcx/fVMJnPGak2fDttEybS+XKMibSOso8O8fkrFR+4QS6PowcqciimC/THvN0Y+pq+pU85u8GGHtZcBpfkE/b3MAkZwl6c1zDw+tYk1B/4X1oHFGjlSXmNJi/fg3YZYObhBRAgUW7HClK/5c9eFBqFgdEMgNrxBW8OmYTZSxD11GiCFADET9bk4/Sg9RIaK3ftAaqZadkRtxz3s/fbFLzFigGIFO6tdJKwxVz5rxAsCd5opu18SVTqgG+UKLMaJNTkU7hXyjoQVZq/diBcFYN2HUNgeTtic6qu/16AFhGevcjRZvUrnbgQsTLLM1cbf2RtQVLEvH1gDfSOolzfFcy2imfbaf3K5j3D2E59fxHfindyxQ8vq9cvBY7kLv8bgNWSWwRz8oisjGo+Hb9lFmZEQknQKPXTVj1VmEr/6hGjoANCTUGIuVeVu/MQMqsc6eYCaNfNOWF5d/zCQFvvFlRSAiB5cWHnLfnJaM0VWRKGUJ2ZjrVopXxbdnQVVlsd0qZK4T6RIFH9FcX23UR8Fw4fohr/QE2nykQ3krHQyRJKy2n3ZM6uCxFuWFBPtA8eOzzuxVDYizyn8XlzP5AMGMnJ8TfaeQnKhfTHwjJAPRPbQum/9sKoqW+6DJ63Zsge45u6zCvPUyEmlXB+LFKgGIJJlXCJcqkauN0mZfB0sxOddYgaD4R194wvPgjnh4UfF16ge3I2kV8KJpgG7J83Gd/kGZZb+EAZ1YRGBfB/LBRM6kerr8YA4RA3BdGMmSMQR90/RUykZ87nJNW0R4/SGQaxzJ3W6VLYH7fdw59yqBQ4JwpLRe7beRksfmkZwoYQWdipEaLjXymPRjAPjzZxGnoTu6eBHLO6pWvz2NheJxUvqZXsmuMoYlGJj63gS+wQF3Xv4Pc4Dp3oDkyvmqwTG3kqWRqTLdiwU3LWJeJWqRUuVUdID755jdzB3reBRVQRfLsL2n6WjxWUnJeMzwi6G5cv1hT/EaZ3drDf1nJtLhZ5jN5D/6dR+ZHzsnj1vb4Rjq390v4/HMIc7LdaImNkHNiKZEIyM7ABF/BfFbW1thZGooObjsJZAaxZ5t2QxCsSowM5XxcE9s6swqP8GtQSHYOcLUysaV5yvZscykhDQhec44rWiVQY9f3iFggHaZsSxgWrvQ9Uje4va/EM2HTFHQVrIv5ydte+jCLBcEYq0RcEvE7LKMUS/9ZOZ41ruw0ToPl9eHQ7Ucskfth7El98Hk1h/vkpyQ0JtzGt/EF/YxgKgcuUIdTXoMUnJMo0zIITd854VM+5v2dvDG1DIa03H/lxLd2llMwfWXCKz01X+RjH9L19Ud3Wf3rzoT8+rPoTC+4vyeguvv/DuJwy/Xn3H9Yk86AgvzFmNvoWwv3Hkhl4HVwaGswnuF77qwHLbHUUYOR8e64JU5MYybxnovBdEJmglMWwQuse9HSUP2rnLxrh5nYEJwKJ5Vwq3TKIH/MU5+srnYXOoLew7rAooH/CENjf32FvSgFZtEpOdDPM0BqtTObnJdXN4CmiPpCP1nMV8dZRhlF3cU3utMvZcngpEehX6dbovuh7sFSsj4SNdRsgEyHfUzK6/FndiQxqpPcVgELnGEMoyGOuSm5w7umSEWZq2Cc4DQ0GFxFKGhdDHhzrIa3sLKQ9axJ0bnsSnH4WVk5XvfAc/ojbXFj8QeP+ESNKJWK0lJZBX2GNYDYFyxzp1B3oKaqrZ3/nPU340AgXh90XILshVrkyuWTX+XNtEqWVjGYraSPC6sE68sLsex0d3tYeibqCzrs0YlsCV5YXGBjfSwdiNaX89rTiAazeElnzZHnYnIg7lPGHNzYTMR7h9YPHRkpt/NxaBsaRQicYGisDBp9uVzAXr57Rp5tSE5De0TzLfSUaJRgxHKaS6h5A5acwPP4dSLd5WuOEqLsYAFGGwMkxS9PFx66CnVPJE820o81C6RFSCaYX0ciFqB+kkBw+AiHbdAe430A6nlMZUA1KywG0FfcFYBln++RCFKcKCAmbKd74N7N6UvyDNRDX3QyokUIwjlm4KreTOe8ZE0sKIA4CjT7h+e74QmG/FA88CIA+mz1l58dY+psamRDkLA0AZPjIbqUMjpD5kI4a6iOkmen504u3o3FAYdo+FbscUOG6lKk8+YL0mRoV/xArYbObxLp1x47RIMNduzEbiRopFmqVxNILDudosWLBFaF7uhGId9Dbbz4fhyeCZxGbkl0cQL+ALOZjmD4/0NgbSXXkSTPMM71RtkZl/wxHFtRdUG6P1o/Kp14FUcxw0hFTybPjS1cZRNn9bk6t54McqTr2ggl5RwPhlyWliuzPFrr7xGjUYGzPgHmE6m7wPxIq+QcOhzR65Zr10xBLGjMdIpQ5C2yQLlHiKkPaCBVcF7Wpx9W8povagVXP4dMQsBKHD9kiLnHfkJxV5QJTgeYdbAwUT4taTNoW3h3PqJrrF4qjqaWie6OueH6xpSDiIhOpBamial/SfSeXtaKaNp4eVNEggoh/25cfrPdOFZJ+GHengM4GZnx5TCPG2N10mBPxCwHkCnAtj61royeWVFofWtYAUKJZJAy+77UfeBAVGRVFmtmBFB1w/vL3svnZEBR3ansUm0MXwP5bxiguew0Q8kOS7cQF8szKLAoOfSuvGcKcDr7QN1sKb72hccoijBTO4z7Lc/lICIyXtCfVG3AQsJ9keOxbDtqsJVQMVflMGsB/UGDwrz57vbep1hBhChUzZkCA87/LlZcs7t5zGtUQUnDNZlJmrO9YR7BkuZDuGttZpLgOhSMmR2zztvqmixVJrraT2NCCHmwjKV+VhTwRdbCKH/Qanv2sOKj+7giUG/dZ1bIpr7GXvZOGmCUHEBYse3f1uiWOrJfcnhMebKYRE8VYIisJfXq/Lf64yXk9HHZqrU7voP1hzFfLYKGUlxbF7r0LWRr+5wkTCedN3RISOrH8RVtdY6bchA7Yr/vqHMiNMGuvShyFsNA+E/NiIhfU1ya88m7j0Cbay3XC6IEShoykxuoXn7TXKUaJnaecHWtwUAXv3xgqRu4EoReGsBeJ89mdJbPgVGuLnU15nvMSdFL2Ym/rzYd4RS98KJdSHl2oXoK/IgvTxmq/yYYSQhjkuUtozBs8D5+I/zrSDmgTbSl5QHosYBiY2piRg+QMHyQhlDPIVrNGE+ITDjYd1xi2TUMpoHiPONy03KSRSt8Tiq9rqGYnf1pgIWGhgqrLH6K/77nrhTIVTbRNtJu7bxlOmYxhidGOqj2QpPbiYlkUDOHWGqGn2O7K2bYrT4JHEEWbJF6bcid+EfaK37EDDBoESR0YSfWF/g34OxlbadYU0KBKE9Rdnsuk+S8UfIerEE0BEVJTyWPfOlzmufkLrBpxZ9p0D6EcGS+wHvv6b1YVwVJIKtmAsK0lwEsvL/MRETRRDaqONOcVCc0Ssn7rTxvEDXHuPl0fq20KDygyidkVnaSNi2UXGbxXCAwgKNR6EZQ6fBI88vQsWQ3gzNm59xtDlZbb/PTD8OA9s3Dhx18WAxESFpddNloay/UmgTnmEQToHPAk/FaQkN4iCzWPoxzQ7OOMHTDf2aZLgqJdP+kW2iODPbFZf+Hros5OsTJUElw5OC+1wstoedF95E6EUx3jLWC/XTXWU5SnZFByA3YXHIvmZbEqeKl27Lamjs/EEvpE12+1qiYP8ROL132yBx5iat+/KiJSPydDb6xkKAYYToh/mYhO22UfnPKJUCA4E0oNzCh0SsVvZZPqD7QzwB47pAmH9qFqWYQPInP2wpkYlrYHbPjn7q022bT1kTWuE1ZXDODzP35JJPW6IoMifR9FrNZM9v9k1OmQleho6DAZ0Yl4Pfj/g0Puc0TtUyAnFHShk5fGzJzP8Y8D8Q9NHxBSArklpEdhfxyzBeh/rssZDzXHt+nSTcwWXNHs//GiFNmQ0l8hDws9ErDaIzNbghDB51CZaEurYVCzKgaFK2oaZ7lAFLqiIk5AXFVrarwhFVOUAN2U6E4LzUlEvO7J5xBR7QDIh9oXEkip08ZKdgwb2r0AoGxIRttsh9xr1ZGjFa9kzUy9BgVJip/j792nTxGxOuJ6yAoIqEP/OOYvprIb9C7o+zmiOVNp/5Me84QoFl3y7C/7tMd1h/8PsvUDuhEu6kfmkSHZIj//f7Yi01wc8lQGhUGBerVl//+R6KiwFvVDODcBAWLEtzIz24btJhLun/PxAWg2OlmE65GkFQsdixn2J5u5Xvvgabx0UBE8F9Z6Xobi+n4v54djXUB0lhJWkf3W0PeX5XHZOGLNhr0dq9rKeA2TeYTBei3oPdLKF1YVby1xQmHQmsiKhjGoCBMiIhivTmpoTZHaqj1PQHQe6LR58j6IU6TarohkPwBdGIddYSj/bNzprlhtUMyZfROklWgNZa5gqeSNSBp6XC8fg0TtPbe+s7qDcaCuYbDyGDadijEsMvYuNsHmvudZ9RPwYXeCEx295Imb15c/9u4fWk4sNal9yoOhr9/fMviLGRWlVvcg/qGc5/KyTML5bxSqHRL5szEbSrkoj3CblFkQ3ZW2wey1XkP1DeWAxe0oGkreXgFXXuU1xKQdZwSL7RTVsRgBrH63xGkdflLQCL4QIrZam3mXJaEPLzC3s6fJGoFeFUlhrLdN2Vjz+MIfbhWbS0QHgSPG163g9ZM15iQRK6zTPpsFPVlJNFaGIj1uG7yJ3MsVnv3gbcMRBYLK8RVjoeNvERj+syRpQTebO44R0ZvSf7VZY4YHdTUlxcUWHA7jDjORFOnR0pD3UDeeeBYLHD+P2na6dHUNxkAsGPoReMYx5ZAk9+27SKNn4FnDHC0FW7dAHSyLydO1H02uAhckBHxfzX1Wb9QPK+Zwi2gSBm3GmEjJ8H7tshE9ThJ0HZ+9nuAGocCYV8Kn/aQOkBfmyktN0oAAR3mb7MpQpdkSokR5SB3OANiOxa1EgQgpHoLQLW0X2DMTP9FXnZrTIBjOpiQkeUb2qGWnrEoVdk0TfaQ6oI49vXRvpXp3iFbiHmRQleY+MWRdjLf7xQYStRi3pqrry422SnAsltFrDsQTV6SqEhMWJBEaR/DoEhegH9/p7g7cRIPaFGzzU0LfTBmAIb/YfJ0C4kMjKUNofz0UM4Eyev19aE42HFTPuTIxELjOUJCVyUBKvca5SylR6BnGC6emd9QzCDHSx2+H2rkUawnsHsZ2KaCNDtO/0q6UEN/brGSjV0IASRe4/x1+hxoZ4yPqtd8BzaASYJmxMTkVrrUciJFMznBNdeatJ476EOJVlKa1reMar7twSQx9Khvod0OFxFfpe/JijQc9l7sVh/k1BGp5h8mOtQoGZN9iEXHCvAYQj6V15Ih31mxl0RsnNcprpqW39+nTkqvwHUEWH8ShvB4exl/uDw9WjbHNEWXTAmFkY6P/FrOxiUhPfBxR3JtNUBzpMt8ojtQG2ckWDn1JcXPjII+yINh2BRQ7EnwuD4KFBZt+6s1Z8TtTKx3KvqUBnjevy+7XR/Qv3FUXoZiENEv5WAm/rGzDjBarEgBBz/yIAQsBEABB3/yIAQsBFABB7/yIAQsBGQBB/vyIAQsCQB8AQY79iAELAogTAEGe/YgBCwJqGABBrf2IAQsDgIQeAEG9/YgBCwPQEhMAQc39iAELA4TXFwBB3f2IAQsDZc0dAEHs/YgBCwQgX6ASAEH8/YgBCwTodkgXAEGM/ogBCwSilBodAEGb/ogBCwVA5ZwwEgBBq/6IAQsFkB7EvBYAQbv+iAELBTQm9WscAEHK/ogBCwaA4Dd5wxEAQdr+iAELBqDYhVc0FgBB6v6IAQsGyE5nbcEbAEH6/ogBCwY9kWDkWBEAQYn/iAELB0CMtXgdrxUAQZn/iAELB1Dv4tbkGhsAQan/iAEL3EKS1U0Gz/AQAAAAAAAAAACA9krhxwItFQAAAAAAAAAAILSd2XlDeBoAAAAAAAAAAJSQAigsKosQAAAAAAAAAAC5NAMyt/StFAAAAAAAAABA5wGE/uRx2RkAAAAAAAAAiDCBEh8v5ycQAAAAAAAAAKp8Idfm+uAxFAAAAAAAAIDU2+mMoDlZPhkAAAAAAACgyVIksAiI740fAAAAAAAABL6zFm4FtbW4EwAAAAAAAIWtYJzJRiLjphgAAAAAAEDm2HgDfNjqm9AeAAAAAADoj4crgk3HcmFCEwAAAAAA4nNptuIgec/5EhgAAAAAgNrQA2QbaVdDuBceAAAAAJCIYoIesaEWKtPOEgAAAAC0KvsiZh1KnPSHghcAAAAAYfW5q7+kXMPxKWMdAAAAoFw5VMv35hkaN/pdEgAAAMizRym+tWCg4MR49RYAAAC6oJmzLeN4yBj21rIcAABAdARAkPyNS33PWcbvEQAAUJEFULR7cZ5cQ/C3axYAAKT1BmSh2g3GM1TspQYcAICGWYTepKjIW6C0syeEEQAg6G8lFs7SunLIoaAx5RUAKOLLrpuBh2mPOsoIfl4bAFltP00BsfShmWR+xQ4bEUCvSI+gQd1xCsD93XbSYRUQ2xqzCJJUDg0wfZUUR7oa6sjwb0Xb9CgIPm7dbGy0ECT77MsWEjIzis3JFIiH4RTtOeh+nJb+v+xA/Blq6RkaNCRRzyEe//eTqD1Q4jFQEEFtJUOq5f71uBJN5Fo+ZBSSyO7TFJ9+M2dXYJ3xTX0ZtnrqCNpGXgBBbbgEbqHcH7KMkkVI7DqgSETzwuTk6RPeL/dWWqdJyFoVsPMdXuQY1vu07DARXHqxGpxwpXUdH2Ud8ZO+innsrpBhZodpchO/ZO04bu2Xp9r0+T/pA08Y770ox8nofVERcviP48RiHrV2eRx+se7SSkf7OQ67/RJi1Jej3V2qhx0ZesjRKb0Xe8l9DFX1lOlkn5g6RnSsHe2dzidVGf0Rn2Of5KvIixJoRcJxql981oY8x93Wui4XwtYyDpV3G4yoCzmVjGn6HDnG3yi9KpFXSadD3feBHBLItxdzbHV1rRuRlNR1oqMWuqXdj8fS0phitblJE4tMHJSH6rm8w4OfXREUDuzWrxF5KWXoq7RkB7UVmRGnzBsW13N+4tbhPUkiW//V0L+iG2YIj00mrcZt9Zi/heK3RRGAyvLgb1g4yTJ/LyfbJZcVIH0v2Ytuhnv/XvvwUe/8GjSuvWcXBTStXxudNpMV3hDBGa1BXQaBmDdiRAT4mhUVMmAYkvRHoX7FelUFtgFbGh88T9v4zCRvu2xVwxHheBAnCyMSNwDuSurHKjRWGZcU8M2r1kSAqd3keTXBq9+8GbZgKwYr8IkKL2zBWMsLFhDkOLbHNWwszTrH8S6+jhsUHcejOUOHd4AJOa66bXIiGeS4DAgUaZXgS8dZKQkPax+O8weFrGFdbI8c2Lll6aITcvBJphe6dEezI04ov6OLGI9s3I+d6FEZoKxh8q6Mrh7Zw+l5YjHTD+QLfVftFy0TzzRkGLv9xxPdTlyt6F34FwNCfd4p/blYlGKz2GJ19h1CSQ4rOj50t5wdcMddCboSktvRtchNUeUDJUw5tYtoF3dSRuM6oaXeRC6fh6KuQh2K8wvOxIQnC+t8w5QlrUkSbfCOAfZl8c0lXPT5bhjcFois8oFzv21BL3NxuIoekxzVqzcxqJfkiP3nRrMW89sRypaFPZK9Hev8oRhg3O9SFn385sz2LOUlfMoeeNOr5xvOXRBAGjyvl40+Eytky3ARQnUU0CALm/0wDtg1Pf7MFZKSGQTpzQE9vRFOg8w9QBub+4+isSAhRhbLENKfJggRgvozC95oqdfb/ZTGRzBKFSP5AI4Vw5PNUj06uFm8nBq2m8B47Vl8wFNmJBO49aEQo8Lw1mhwm7Dof+0XJnPKFEzzrAyDTMLc4t/one8P/RkPGOzn0W/5ye2LscL1KT4QEx7nYcbLdzzp7l0zc7RNFJjlYPq3vpWLo2o1AJAhYRn+Hvn4ZS57bkzFQgD0abkfX7Obu//8DMVPuymAOOLTEzeggqo/PFC2Iyo0oMbayBhESCOVT0vko6w0QUh4EfseKw02vRGvbubrwCgt6+pcE3WQgyzWWgrgJvFy+KUlNBiTdKS3i/EMmHCtj3YPL0Ee3MjGUvcWCF9mzBmqab3oEhN7eCe1HMr2fz+gFMTsohfXmVZx4qN89F9PyBn1p4sdJiDWhm3mzfibMR0w+Uh3EjCoi+gIYAH3An4kfDcbFRc8kq4iC7jBtIOdLVsFYtocZRut9QYT+VBygvxYQ30IEj9iGLPIVzflDqM7L5ScihbPet7fui2FntKLCju5Qy0cwQzry5Q8E6Njl+bEU0qcEfHP5f65C9iLPD0gtuhcAxbuQ59+qA7OrotMqOMiNIQbdYojTynJQE3XL0nOlaAyERJt7KJz+5AgzXvbQbtIfxVWiKeLUDq1aMBaUhLqGt8aNrVIV3JEcUG4eHNL0nDLEIPiGu2Olc1R5lZQ3gZN/hQkm2Go8vpA5p9s5JVI4D0a9wA9qdec6O/jw65dLaxmEDRBjJMNxOLr3HQatThXgBSBUW/4EHXbJhQSYeIGbaAZ8ZJFmyopSZhMq3xNJEQEEK33FkJ1c1u+H9bbYC1VBRSYtZySUlDyrafLErl4qgYZ/+JDN2fkbpmRflfnFlVIH99tioLATuX/Gq+WUC41jRNXCS2jcKLev+FavOR5gnAYrUv4ywxL1i+acetdGKOMHkwve//n7uVdACezOu/lFxMf+1n/oWpfdcDwXwlr390X53kwf0pFt5Lw7LfLRVfVHTBMfo9Oi7JbFvRSn4tWpRI8310zIi6f8huxJ4curE4XC1c1wKr5Ru9infEoOlciHWdWIbgKXIzVXQKXWYR2NRIBrClmDXPvSvXC/G8l1MIWARe0v9BPq52y8/vLLolzHGCO0HfiEYuiT3h9P701yBH5scQVW9Yti2PWXI8sQzoWd9412/FL+W38CzSz99PIGwqrASl3z7vEfYcA0HqEXRHNFULzVMPqNV2pAISZ5bQVQJsSMCp0ZYO00wDl/x4iGwihC16aaB/SUIQg719T9RBKiY71wEKnBmWl6Oo3qDIVnSvyMnETUUi+zqLlRVJ/GkJb178mrDLtNsGFr2uTjxASMs1vMFd/qIQxZ5tGeLMUl37Ai/wsn9Ll/UBCWFbgGR5PWNcdfKOjr55oKfc1LBDmYi5NJVuMjFvGwvN0QzcUn/t5oO5xr2/yd7MwUhRFGYd6mEhqTpsL71XgvGZZlh+UTF9tAhFBZ7U1DDbg970Tuh+3CENVEcEiQ49D2HWtGKjn5MqTqlVx6xNzVE7T2B7JEM9enIrVJnPsx/QQhEcT+9SCdkPtivCP5/kxFWUZGDqKI1SUqK3sc2F4flq+Hx5kNpa0XInsc+g8C4/41tMS/cO74bOr55AiDM6ytsyIF/20KtqgliE1K4+BX+T/ah0esVqIJP40AXv5sLvu32ISZV1xqq09gsHZN51q6pf7Fr+0DRUZzeIx0IVEBeV9uhz3kCitL8AtH6LTSiOvjvQRNbVymDsw+aaKiB3sWrJxFoJij35KfLdQreokp/EeDhyRnRmPrq1yUqwSdwhX04gR9gTgMhpZD2dX15TKLAjrFTMGmL9gL9NALQ06/TfKZRvgA793nP2DSDxIRP5inh8R2MSulQP9pFpLWtW9+4VnFQ52GntEPE4x3rBKrXpnwRrJifDMquXQ3oquTqys4LgQO6wsgBUfhZYtWmLX1xjnFErXN+DaZib8uPA6zQ3fIBqO5iLMSACYnXPWRKBoi1QQMqAr/1oA/oQQDFbIQq5pFD6I9r5xgD2mFI9retMZhBlOKrQujuDMz9lyBllIIOUfcJow3VgM4CHIB6Q3LTTvEw3BfBRvD1gqugmNhTgB6xhQ8ZvZShPutChM8KaGwSUf0nYByA7MFHGZL1Yo9Jh3E4bUAXoS/1nNf7trMjF/VRioSYIY136wwF+qBn/93moeCW5Rb0ZPbth7KmRvXssCE4vJJQsY44nOGjU9CzZ+wxfuO+8N3lssgmGCDI7DXbQddYW1yGq5W/F80cc4mrqQEtLm4nrFp7It3MX5xkDpNBeGoJvZtlEfOVM3uPiQIwIdVEQBSBKTswOUInObOlYhEmmVAdrWd6AEOetPQsmrqRbD+oGQzJXIRQfm45K7FlQcujxR2p9dnYvEb847NY60EeiL5dAHtYSutQvCisKxIRbj7h7FSeIlGqOOci0zHqobTVUzG26tV/AlmWf831JKEaEqAKLJmG1sb3+B+5fnnBVJNYAK/P6IR0vfYfp9IQQbTiGQhl2ftQyPK3287pTiEKEpNOg0B+PPcnacayo6GxUKNEEiAsnbgw+Ugwa1CGIahsBoVaFdabKJPBIkcUV9EKfwwqoJtQMfrMsWbc2WnBTRrHMVTKLEJpd+XMiAvMMZA0xojW/lOngezzl90FUaEANfwnDLnkkW5kKInETrIBTE9vJMfgbcm59TqsMVJikZdrQv4B0I04KH6JQ0m29zH8nQHawS5cOxVBHdAMElqBP8RCVXV9403qlVFEExL5IYO5buLO0VwlUUa1mR/bq2HuUdFTy0TZm17OLXet40MhNeZRpLIaH/4qfbjRkWwv4Xtv7gnWmJv9uRUvGfm3L+HTGfrALitVcpm9P2Q6EHvxL+xleDWqOt84GI9JSJyW4XvbgtJDEMmXCiqjH663tKHXaTnLaep1+GpQpffHONThJUuENkhpH3507NdlvQMOIWaaZU/ed19aGigFRyBL2aHAHoVP6waTmlZdB0xyK24BECIuo9HcSHDn8EUnmr41gWgqpkjSS1KdKehaZXlhzvG5HqXtg2EVpDgxPI9t1xdRE2pXaOhJUwFGQYenRVztIVg04UsuW6PBl9npjR6oFHGxKxTI/P9MUvDmP/wjKxDBFW3R9zA3K3u9E7v3N/3U8VrNTnT4ROpSrGCq9Q39SjGuvk8LESUafau2ZtkgtlphAmHm1eVyVR0WrACHdO/s8UsGUINq1upYWF8MoU4v0DGo4/xUEsZYdzU9b+TK1+QhBxjzZSdz5pUOiLPqBYHlMUTjPEJhWOg2TiLk7I7uVnGSJAdXCacaT9mrphemrfwR8VSEmGAMeG3qAUfYyiK9kTGprbp8B4KBbJWZwvi3bPGKGA0tHwlrJbO3CD+y1UAx9kkCODVp5PGSUmMr2cFGITfnTsI+yFo1+ur37sw5k6GJ2R5yxnZ4z3mVue5zRASR4CuxB8oMC3OkD5whAhyO0Sw+kUm8iwZUmQt/NUKTqpFzMk2sH6HL9bdKUwqrOIkx2gVii5HHJXuWhnXkpwNXwSSGxy56NOredCAfZczEIbF1oHT+FMopihk4EzdH8T4hyYZNEMcGX/RPwwoKgvTA0Svr0FEMw+P1Y7PciSO5+QFi4tBxR/Ds8rikx6dwrHNBw9fIRsD2lhW9ZvrIpm/KARTJulR1PDOfLLi1ctgDsJFh8CjxkoNMjuvm6tOGCKixtTYfkPmSA9VTdlbCN8NjcRqLn3U79ojCqFfkcsGwSFFRKo9Sjvgi91Jl5Z9yFF5hoLiZl51bE9Cdjalzo1688QTuv/10oejQuO0T2JAuYDFSLm/43dZXCO8UWNK4PfRBrV7794qj8G+bZLOPuxC2sQyuvvFpXPR7ekXgZ6ns6FFL3mq1x6wxnlTfaHGEZCpxk2cOt5LBowr/D5VM9riQgQQ0xmmLcg/NpsOCrDxqsKFFTff37lKLsRiMb0c7hWDRkq1x/eHvMpFir48ZBmrFAfeubTSvM32k0aO5cawGuSExngiB3wxVDh4Ak9IbAGdxgfGOskbPekGVlMjClcyJQeE+8Sl6MaB7C3r/eZOf0cE9iq13xM4QicpZt1AIg85BeOlQ2cnxkLA48CkwCqS90deX2IwQPw5mGZ4VtASk+qEtec6rEErGC6/9ly0BzjVBcNRGXeBdf4qH+QjwTkGyodiEr/qmOGm8lPutmCblE6Eiodv5X8ZwK84yiQI8rlyBZ05C67+wEDqxwzdKw8H3scyU79VD3h4erxn8jrhfPMEXuiPKqMWZpl7se6ZmcwQBYay8vU7+8A/+l5aUCBPNAb8F7/5PWVYD8y7EHI0CViEaw2P15zuzjPPmdS+kSvuhVXBM81UOoGgw4B5zgWWykbtmKhIXJS5BGpYJDj7dj5EGS7CaoOZ11W03h0XClPOBU9KoxU0sD0KwiXkbPzYoYaZprXdIP4eBtl/jpQ2P2TEACBDVKkNldi/r1JZE79uBRA4ZBmTQTt+n0tXP2hPOcZyIwaYLAi1LxunFk+5YUwEPovIXhcKwlsigPwjV6nPBT4eymWM3YLB20EbDE20UsZ9tqze8BTzkiIBce9g8WeH9poUE1Y9IAtdWOcVnI7wxMQg6RgbjHheFJ8Q+xOCrQYMC4wAAAAAAAIAAAABAAAAO0OAADuDgAA7w4AAGEgc3RyaW5nYnl0ZSBhcnJheWJvb2xlYW4gYGDOUiIACQAAANdSIgABAAAAaW50ZWdlciBgAAAA6FIiAAkAAADXUiIAAQAAAGZsb2F0aW5nIHBvaW50IGAEUyIAEAAAANdSIgABAAAAY2hhcmFjdGVyIGAAJFMiAAsAAADXUiIAAQAAAHN0cmluZyAAQFMiAAcAAAB1bml0IHZhbHVlT3B0aW9uIHZhbHVlbmV3dHlwZSBzdHJ1Y3RzZXF1ZW5jZW1hcGVudW11bml0IHZhcmlhbnRuZXd0eXBlIHZhcmlhbnR0dXBsZSB2YXJpYW50c3RydWN0IHZhcmlhbnQAAAABAAAAAAAAAC4wdXNpemUAOoYQAHAAAAAuAgAAEQAAAG1dy9YsUOtjeEGmV3Ebi7kJBmaBAfO5VKIIL0OCV3QyOiAAAAAAAAAEAAAABAAAAPQOAABphxAATAAAAOIKAAAkAAAAq4YQAFAAAAAuAgAAEQAAAPUOAAAMAAAABAAAAPYOAAD3DgAA+A4AAPUOAAAMAAAABAAAAPkOAAD6DgAA+w4AAPwOAAAMAAAABAAAAP0OAAD+DgAA/w4AADl2EABKAAAAvQEAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA+PSBzaXplICsgbWluX292ZXJoZWFkAABLjhAAKgAAALEEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogcHNpemUgPD0gc2l6ZSArIG1heF9vdmVyaGVhZAAAS44QACoAAAC3BAAADQAAAEFjY2Vzc0Vycm9yY2Fubm90IGFjY2VzcyBhIFRocmVhZCBMb2NhbCBTdG9yYWdlIHZhbHVlIGR1cmluZyBvciBhZnRlciBkZXN0cnVjdGlvbjogABNVIgBIAAAAZmFpbGVkIHRvIGdlbmVyYXRlIHVuaXF1ZSB0aHJlYWQgSUQ6IGJpdHNwYWNlIGV4aGF1c3RlZABkVSIANwAAALmFEAAdAAAAvAQAAA0AAABXb3VsZEJsb2NrAABONRAAKAAAANMAAAAdAAAAAQAAAAAAAABlbnRpdHkgbm90IGZvdW5kcGVybWlzc2lvbiBkZW5pZWRjb25uZWN0aW9uIHJlZnVzZWRjb25uZWN0aW9uIHJlc2V0aG9zdCB1bnJlYWNoYWJsZW5ldHdvcmsgdW5yZWFjaGFibGVjb25uZWN0aW9uIGFib3J0ZWRub3QgY29ubmVjdGVkYWRkcmVzcyBpbiB1c2VhZGRyZXNzIG5vdCBhdmFpbGFibGVuZXR3b3JrIGRvd25icm9rZW4gcGlwZWVudGl0eSBhbHJlYWR5IGV4aXN0c29wZXJhdGlvbiB3b3VsZCBibG9ja25vdCBhIGRpcmVjdG9yeWlzIGEgZGlyZWN0b3J5ZGlyZWN0b3J5IG5vdCBlbXB0eXJlYWQtb25seSBmaWxlc3lzdGVtIG9yIHN0b3JhZ2UgbWVkaXVtZmlsZXN5c3RlbSBsb29wIG9yIGluZGlyZWN0aW9uIGxpbWl0IChlLmcuIHN5bWxpbmsgbG9vcClzdGFsZSBuZXR3b3JrIGZpbGUgaGFuZGxlaW52YWxpZCBpbnB1dCBwYXJhbWV0ZXJpbnZhbGlkIGRhdGF0aW1lZCBvdXR3cml0ZSB6ZXJvbm8gc3RvcmFnZSBzcGFjZXNlZWsgb24gdW5zZWVrYWJsZSBmaWxlcXVvdGEgZXhjZWVkZWRmaWxlIHRvbyBsYXJnZXJlc291cmNlIGJ1c3lleGVjdXRhYmxlIGZpbGUgYnVzeWRlYWRsb2NrY3Jvc3MtZGV2aWNlIGxpbmsgb3IgcmVuYW1ldG9vIG1hbnkgbGlua3NpbnZhbGlkIGZpbGVuYW1lYXJndW1lbnQgbGlzdCB0b28gbG9uZ29wZXJhdGlvbiBpbnRlcnJ1cHRlZHVuc3VwcG9ydGVkdW5leHBlY3RlZCBlbmQgb2YgZmlsZW91dCBvZiBtZW1vcnlpbiBwcm9ncmVzc290aGVyIGVycm9ydW5jYXRlZ29yaXplZCBlcnJvck9zAAAAAAAEAAAABAAAAAAPAABjb2RlAAAAAAEAAAABAAAAAQ8AAGtpbmT8DgAADAAAAAQAAAACDwAAbWVzc2FnZUtpbmRFcnJvcgAAAAAIAAAABAAAAAMPAAAAAAAABAAAAAQAAAAEDwAAQ3VzdG9tZXJyb3IgKG9zIGVycm9yICkAAQAAAAAAAAA7WSIACwAAAEZZIgABAAAABUkQABsAAAA3BAAAFAAAAAVJEAAbAAAARAQAABQAAABmYWlsZWQgcHJpbnRpbmcgdG8gAIBZIgATAAAA/FMiAAIAAAAFSRAAGwAAAI0EAAAJAAAAc3RkZXJyYSBmb3JtYXR0aW5nIHRyYWl0IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlpbmcgc3RyZWFtIGRpZCBub3S6WSIAVgAAAP5+EAAZAAAAiAIAABEAAABjYW5ub3QgcmVjdXJzaXZlbHkgYWNxdWlyZSBtdXRleChaIgAgAAAABDAQACwAAAATAAAACQAAAGxvY2sgY291bnQgb3ZlcmZsb3cgaW4gcmVlbnRyYW50IG11dGV4AAB0XBAAJgAAACQBAAAtAAAAbWVtb3J5IGFsbG9jYXRpb24gb2YgIGJ5dGVzIGZhaWxlZAAAmFoiABUAAACtWiIADQAAAEGPEAAYAAAAZAEAAAkAAAD8DgAADAAAAAQAAAAFDwAAAAAAAAgAAAAEAAAABg8AAAAAAAAIAAAABAAAAAcPAAAIDwAACQ8AAAoPAAALDwAAEAAAAAQAAAAMDwAADQ8AAA4PAAAPDwAAAAAAAAgAAAAEAAAAEA8AABEPAAASDwAADw8AAE5vdEZvdW5kUGVybWlzc2lvbkRlbmllZENvbm5lY3Rpb25SZWZ1c2VkQ29ubmVjdGlvblJlc2V0SG9zdFVucmVhY2hhYmxlTmV0d29ya1VucmVhY2hhYmxlQ29ubmVjdGlvbkFib3J0ZWROb3RDb25uZWN0ZWRBZGRySW5Vc2VBZGRyTm90QXZhaWxhYmxlTmV0d29ya0Rvd25Ccm9rZW5QaXBlQWxyZWFkeUV4aXN0c05vdEFEaXJlY3RvcnlJc0FEaXJlY3RvcnlEaXJlY3RvcnlOb3RFbXB0eVJlYWRPbmx5RmlsZXN5c3RlbUZpbGVzeXN0ZW1Mb29wU3RhbGVOZXR3b3JrRmlsZUhhbmRsZUludmFsaWRJbnB1dEludmFsaWREYXRhVGltZWRPdXRXcml0ZVplcm9TdG9yYWdlRnVsbE5vdFNlZWthYmxlUXVvdGFFeGNlZWRlZEZpbGVUb29MYXJnZVJlc291cmNlQnVzeUV4ZWN1dGFibGVGaWxlQnVzeURlYWRsb2NrQ3Jvc3Nlc0RldmljZXNUb29NYW55TGlua3NJbnZhbGlkRmlsZW5hbWVBcmd1bWVudExpc3RUb29Mb25nSW50ZXJydXB0ZWRVbnN1cHBvcnRlZFVuZXhwZWN0ZWRFb2ZPdXRPZk1lbW9yeUluUHJvZ3Jlc3NPdGhlclVuY2F0ZWdvcml6ZWRvcGVyYXRpb24gc3VjY2Vzc2Z1bAAAAAAQAAAAEQAAABIAAAAQAAAAEAAAABMAAAASAAAADQAAAA4AAAAVAAAADAAAAAsAAAAVAAAAFQAAAA8AAAAOAAAAEwAAACYAAAA4AAAAGQAAABcAAAAMAAAACQAAAAoAAAAQAAAAFwAAAA4AAAAOAAAADQAAABQAAAAIAAAAGwAAAA4AAAAQAAAAFgAAABUAAAALAAAAFgAAAA0AAAALAAAACwAAABMAAADYVSIA6FUiAPlVIgALViIAG1YiACtWIgA+ViIAUFYiAF1WIgBrViIAgFYiAIxWIgCXViIArFYiAMFWIgDQViIA3lYiAPFWIgAXVyIAT1ciAGhXIgB/VyIAi1ciAJRXIgCeVyIArlciAMVXIgDTVyIA4VciAO5XIgACWCIAClgiACVYIgAzWCIAQ1giAFlYIgBuWCIAeVgiAI9YIgCcWCIAp1giALJYIgAIAAAAEAAAABEAAAAPAAAADwAAABIAAAARAAAADAAAAAkAAAAQAAAACwAAAAoAAAANAAAACgAAAA0AAAAMAAAAEQAAABIAAAAOAAAAFgAAAAwAAAALAAAACAAAAAkAAAALAAAACwAAAA0AAAAMAAAADAAAABIAAAAIAAAADgAAAAwAAAAPAAAAEwAAAAsAAAALAAAADQAAAAsAAAAKAAAABQAAAA0AAABQWyIAWFsiAGhbIgB5WyIAiFsiAJdbIgCpWyIAulsiAMZbIgDPWyIA31siAOpbIgD0WyIAtFUiAAFcIgAOXCIAGlwiACtcIgA9XCIAS1wiAGFcIgBtXCIAeFwiAIBcIgCJXCIAlFwiAJ9cIgCsXCIAuFwiAMRcIgDWXCIA3lwiAOxcIgD4XCIAB10iABpdIgAlXSIAMF0iAD1dIgBIXSIAUl0iAFddIgAoKQAAAAAAAAQAAAAEAAAAQwUAAEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3cwYCIAHAAAAAl4EAAqAAAAJQAAACgAAABFcnJvckxheW91dEVycm9yEw8AAAwAAAAEAAAAFA8AABUPAAAWDwAAY2FwYWNpdHkgb3ZlcmZsb3cAAACMYCIAEQAAANuGEAAgAAAALgIAABEAAAAyYBAAGwAAAOgBAAAXAAAAGBwQACIAAABSAAAAEwAAAJgwEAAeAAAAGgEAAB4AAACYMBAAHgAAABYBAAA3AAAAmDAQAB4AAABVAQAACwBBkMKJAQttAQAAABcPAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlkIG5vdAAAAh8QABgAAACKAgAADgBBiMOJAQuBEgEAAAAYDwAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQBpdhAAGgAAAL0BAAAdAAAABzEQABgAAACfAQAAPwAAAAcxEAAYAAAAoAEAADMAAAAHMRAAGAAAAIMCAAATAAAA0o8QABkAAACDAQAAMgAAACkgc2hvdWxkIGJlIDwgbGVuIChpcyApaW5zZXJ0aW9uIGluZGV4IChpcyApIHNob3VsZCBiZSA8PSBsZW4gKGlzIAAAI2IiABQAAAA3YiIAFwAAACJiIgABAAAAcmVtb3ZhbCBpbmRleCAoaXMgAABoYiIAEgAAAAxiIgAWAAAAImIiAAEAAABgYXRgIHNwbGl0IGluZGV4IChpcyAAAACUYiIAFQAAADdiIgAXAAAAImIiAAEAAAAnAQYBCwEjAQEBRwEEAQEBBAECAgDABAIEAQkCAQH7B88BBQExLQEBAQIBAgEBLAELBgoLAQEjAQoVEAFlCAEKAQQhAQEBHhtbCzoLBAECARgYKwMsAQcCBQkpOjcBAQEECAQBAwcKAg0BDwE6AQQECAEUAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEUAhYGAQE6AQIBAQQIAQcCCwIeAT0BDAEyAQMBNwEBAwUDAQQHAgsCHQE6AQIBBgEFAhQCHAI5AgQECAEUAh0BSAEHAwEBWgECBwsJYgECCQkBAQdJAhsBAQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwFeAQADAAMdAh4CHgJAAgEHCAECCwMBBQEtBTMBQQIiAXYDBAIJAQYD2wICAToBAQcBAQEBAggGCgIBJwEIHzEEMAEBBQEBBQEoCQwCIAQCAgEDOAEBAgMBAQM6CAICQAZSAwENAQcEAQYBAwIyPw0BImUAAQEDCwMNAw0DDQIMBQgCCgECAQIFMQUBCgEBDQEQDTMhAAJxA30BDwFgIC8BAAEkBAMFBQFdBl0DAAEABgABYgQBCgEBHARQAg4iTgEXA2cDAwIIAQMBBAEZAgUBlwIaEg0BJggZCy4DMAECBAICEQEVAkIGAgICAgwBCAEjAQsBMwEBAwICBQIBARsBDgIFAgEBZAUJA3kBAgEEAQABkxEAEAMBDBAiAQIBqQEHAQYBCwEjAQEBLwEtAkMBFQMAAeIBlQUABgEqAQkAAwECBQQoAwQBpQIABCYBGgUBAQACTwRGCzEEewE2DykBAgIKAzEEAgICAQQBCgEyAyQFAQg+AQwCNAkKBAIBXwMCAQECBgECAZ0BAwgVAjkCAwElBwMFRgYNAQEBAQEOAlUIAgMBARcBVAYBAQQCAQLuBAYCAQIbAlUIAgEBAmoBAQECBgEBZQEBAQIEAQUACQECAAIBAQQBkAQCAgQBIAooBgIECAEJBgIDLg0BAgAHAQYBAVIWAgcBAgECegYDAQECAQcBAUgCAwEBAQACCwI0BQUBAQEXAQARBg8ADAMDAAU7BwkEAAMoAgABPxFAAgECAAQBBwECAAIBBAAuAhcAAwkQAgceBJQDADcEMggBDgEWBQEPAAcBEQIHAQIBBQU+IQGgDgABPQQABf4CAAdtCAAFAAEeYIDwAEEaBhovAQoBBAEFFwEfAcMBBATQASQHAh4FYAEqBAICAgQBAQYBAQMBAQEUAVMBiwimASYJKQAmAQEFAQIrAQQAVgIGAAsFKwIDQMBAAAIGAiYCBgIIAQEBAQEBAR8CNQEHAQEDAwEHAwQCBgQNBQMBB3QBDQEQDWUBBAECCgEBAwUGAQEBAQEBBAEGBAECBAUFBAERIAMCADQA5QYEAwIMJgEBBQEALhIehGYDBAE+AgIBAQEIFQUBAwArAQ4GUAAHDAUAGgYaAFBgJAQkdAsBDwEHAQIBCwEPAQcBAgABAgMBKgEJADMNM10WChYAQABAAFUBRwECAgECAgIEAQwBAQEHAUEBBAIIAQcBHAEEAQUBAQMHAQACGQEZAR8BGQEfARkBHwEZAR8BGQEIAAoBFAYGAD4ARAAaBhoGGgAAcAAHAC0BAQECAQIBAUgLMBUQAWUHAgYCAgEEIwEeG1sLOgkJARgEAQkBAwEFKwM7CSoYASA3AQEBBAgEAQMHCgIdAToBAQECBAgBCQEKAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEUAhYGAQE6AQECAQQIAQcDCgIeATsBAQEMAQkBKAEDATcBAQMFAwEEBwILAh0BOgECAgEBAwMBBAcCCwIcAjkCAQECBAgBCQEKAh0BSAEEAQIDAQEIAVEBAgcMCGIBAgkLB0kCGwEBAQEBNw4BBQECBQsBJAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAQADAAQcAx0CHgJAAgEHCAECCwkBLQMBAXUCIgF2AwQCCQEGA9sCAgE6AQEHAQEBAQIIBgoCATAfMQQwCgQDJgkMAiAEAgY4AQECAwEBBTgIAgKYAwENAQcEAQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0BJggZCwEBLAMwAQIEAgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAAAgAB4gGVBQADAQIFBCgDBAGlAgAEQQUAAk8ERgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkBAQgEAgFfAwIEBgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMBARcBUQECBgEBAgEBAgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAEAgIEASAKKAYCBAgBCQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUFAxcBAAEGDwAMAwMABTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFZAGgBwABPQQABP4CAAdtBwBggPAAAgICAgICAgICAwMBAQEAQZvViQELEAEAAAAAAAAAAgIAAAAAAAIAQdrViQELAQIAQYDWiQELAQEAQZvWiQELAQEAQfzWiQELwAquIxAAIQAAAC4AAAAJAAAAwW/yhiMAAACB76yFW0FtLe4EAAABH2q/ZO04bu2Xp9r0+T/pA08YAAE+lS4Jmd8D/TgVDy/kdCPs9c/TCNwExNqwzbwZfzOmAyYf6U4CAAABfC6YW4fTvnKf2diHLxUSxlDea3BuSs8P2JXVbnGyJrBmxq0kNhUdWtNCPA5U/2PAc1XMF+/5ZfIovFX3x9yA3O1u9M7v3F/3UwUAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ID4gMOxOEAAvAAAAdgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAAOxOEAAvAAAAdwAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLnBsdXMgPiAw7E4QAC8AAAB4AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBNQVhfU0lHX0RJR0lUUwAAAOxOEAAvAAAAewAAAAUAAADsThAALwAAAMIAAAAJAAAA7E4QAC8AAAD7AAAADQAAAOxOEAAvAAAAAgEAABIAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9zdWIoZC5taW51cykuaXNfc29tZSgpAOxOEAAvAAAAegAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9hZGQoZC5wbHVzKS5pc19zb21lKCkAAOxOEAAvAAAAeQAAAAUAAADsThAALwAAAAsBAAAFAAAA7E4QAC8AAAAMAQAABQAAAOxOEAAvAAAADQEAAAUAAADsThAALwAAAHIBAAAkAAAA7E4QAC8AAAB3AQAALwAAAOxOEAAvAAAAhAEAABIAAADsThAALwAAAGYBAAANAAAA7E4QAC8AAABMAQAAIgAAAOxOEAAvAAAADwEAAAUAAADsThAALwAAAA4BAAAFAAAA30UaPQPPGubB+8z+AAAAAMrGmscX/nCr3PvU/gAAAABP3Ly+/LF3//b73P4AAAAADNZrQe+RVr4R/OT+AAAAADz8f5CtH9CNLPzs/gAAAACDmlUxKFxR00b89P4AAAAAtcmmrY+scZ1h/Pz+AAAAAMuL7iN3Ipzqe/wE/wAAAABtU3hAkUnMrpb8DP8AAAAAV862XXkSPIKx/BT/AAAAADdW+002lBDCy/wc/wAAAABPmEg4b+qWkOb8JP8AAAAAxzqCJcuFdNcA/Sz/AAAAAPSXv5fNz4agG/00/wAAAADlrCoXmAo07zX9PP8AAAAAjrI1KvtnOLJQ/UT/AAAAADs/xtLf1MiEa/1M/wAAAAC6zdMaJ0TdxYX9VP8AAAAAlsklu86fa5Og/Vz/AAAAAISlYn0kbKzbuv1k/wAAAAD22l8NWGaro9X9bP8AAAAAJvHD3pP44vPv/XT/AAAAALiA/6qorbW1Cv58/wAAAACLSnxsBV9ihyX+hP8AAAAAUzDBNGD/vMk//oz/AAAAAFUmupGMhU6WWv6U/wAAAAC9filwJHf533T+nP8AAAAAj7jluJ+936aP/qT/AAAAAJR9dIjPX6n4qf6s/wAAAADPm6iPk3BEucT+tP8AAAAAaxUPv/jwCIrf/rz/AAAAALYxMWVVJbDN+f7E/wAAAACsf3vQxuI/mRT/zP8AAAAABjsrKsQQXOQu/9T/AAAAANOSc2mZJCSqSf/c/wAAAAAOygCD8rWH/WP/5P8AAAAA6xoRkmQI5bx+/+z/AAAAAMyIUG8JzLyMmf/0/wAAAAAsZRniWBe30bP//P8AQcbhiQELBUCczv8EAEHU4YkBC9kMEKXU6Oj/DAAAAAAAAABirMXreK0DABQAAAAAAIQJlPh4OT+BHgAcAAAAAACzFQfJe86XwDgAJAAAAAAAcFzqe84yfo9TACwAAAAAAGiA6aukONLVbQA0AAAAAABFIpoXJidPn4gAPAAAAAAAJ/vE1DGiY+2iAEQAAAAAAKityIw4Zd6wvQBMAAAAAADbZasajgjHg9gAVAAAAAAAmh1xQvkdXcTyAFwAAAAAAFjnG6YsaU2SDQFkAAAAAADqjXAaZO4B2icBbAAAAAAASnfvmpmjbaJCAXQAAAAAAIVrfbR7eAnyXAF8AAAAAAB3GN15oeRUtHcBhAAAAAAAwsWbW5KGW4aSAYwAAAAAAD1dlsjFUzXIrAGUAAAAAACzoJf6XLQqlccBnAAAAAAA41+gmb2fRt7hAaQAAAAAACWMOds0wpul/AGsAAAAAABcn5ijcprG9hYCtAAAAAAAzr7pVFO/3LcxArwAAAAAAOJBIvIX8/yITALEAAAAAACleFzTm84gzGYCzAAAAAAA31Mhe/NaFpiBAtQAAAAAADowH5fctaDimwLcAAAAAACWs+NcU9HZqLYC5AAAAAAAPESnpNl8m/vQAuwAAAAAABBEpKdMTHa76wL0AAAAAAAanEC2746riwYD/AAAAAAALIRXphDvH9AgAwQBAAAAACkxkenlpBCbOwMMAQAAAACdDJyh+5sQ51UDFAEAAAAAKfQ7YtkgKKxwAxwBAAAAAIXPp3peS0SAiwMkAQAAAAAt3awDQOQhv6UDLAEAAAAAj/9EXi+cZ47AAzQBAAAAAEG4jJydFzPU2gM8AQAAAACpG+O0ktsZnvUDRAEAAAAA2Xffum6/lusPBEwBAAAAAEkUEAAuAAAAfQAAABUAAABJFBAALgAAAKkAAAAFAAAASRQQAC4AAACqAAAABQAAAEkUEAAuAAAAqwAAAAUAAABJFBAALgAAAK4AAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ICsgZC5wbHVzIDwgKDEgPDwgNjEpAAAASRQQAC4AAACvAAAABQAAAEkUEAAuAAAACgEAABEAAABJFBAALgAAAA0BAAAJAAAASRQQAC4AAABAAQAACQAAAEkUEAAuAAAArQAAAAUAAABJFBAALgAAAKwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogIWJ1Zi5pc19lbXB0eSgpAAAASRQQAC4AAADcAQAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA8ICgxIDw8IDYxKUkUEAAuAAAA3QEAAAUAAABJFBAALgAAAN4BAAAFAAAAAQAAAAoAAABkAAAA6AMAABAnAACghgEAQEIPAICWmAAA4fUFAMqaO0kUEAAuAAAAMwIAABEAAABJFBAALgAAADYCAAAJAAAASRQQAC4AAABsAgAACQAAAEkUEAAuAAAA4wIAACYAAABJFBAALgAAAO8CAAAmAAAASRQQAC4AAADMAgAAJgAAALaHEAAjAAAAmQAAAA4AAAC2hxAAIwAAALcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmWzBdID4gYicwJwC2hxAAIwAAALgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogcGFydHMubGVuKCkgPj0gNAAAtocQACMAAAC5AAAABQAAAC4wLgC2hxAAIwAAAAYBAAAFAAAAtocQACMAAAAHAQAABQAAAGVFZS1FLS0rTmFOaW5mMDBlMDBFMGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBtYXhsZW4AALaHEAAjAAAAegIAAA0AAABvdXQgb2YgcmFuZ2UgaW50ZWdyYWwgdHlwZSBjb252ZXJzaW9uIGF0dGVtcHRlZGF0dGVtcHQgdG8gZGl2aWRlIHdpdGggb3ZlcmZsb3cAAGN2IgAfAAAAICgxIDw8ICkBAAAAAAAAAIx2IgAHAAAAk3YiAAEAAAAuLjAxMjM0NTY3ODlhYmNkZWYAAAEAAAAAAAAAUmVmQ2VsbCBhbHJlYWR5IG11dGFibHkgYm9ycm93ZWRSZWZDZWxsIGFscmVhZHkgYm9ycm93ZWQBAAAAAAAAAMR1IgABAAAAxHUiAAEAAADEdSIAAQAAAC07EAAmAAAAFQAAAB0AQbjuiQEL3AwBAAAAIw8AAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAfEYQAB8AAAB+BAAAVAAAAFtjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlaW5kZXggb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyAAAKh3IgAgAAAAyHciABIAAAAAAAAABAAAAAQAAAAkDwAAAAAAAAQAAAAEAAAAJQ8AAD09IT1tYXRjaGVzYXNzZXJ0aW9uIGBsZWZ0ICByaWdodGAgZmFpbGVkCiAgbGVmdDogCiByaWdodDogABd4IgAQAAAAJ3giABcAAAA+eCIACQAAACByaWdodGAgZmFpbGVkOiAKICBsZWZ0OiAAAAAXeCIAEAAAAGB4IgAQAAAAcHgiAAkAAAA+eCIACQAAADogAAABAAAAAAAAAJx4IgACAAAAAAAAAAwAAAAEAAAAJg8AACcPAAAoDwAAICAgICB7ICwgIHsKLAp9IH0oKAosCntdYXR0ZW1wdGVkIHRvIGJlZ2luIGEgbmV3IG1hcCBlbnRyeSB3aXRob3V0IGNvbXBsZXRpbmcgdGhlIHByZXZpb3VzIG9uZQAA4HgiAEYAAABTJxAAIAAAANkDAAANAAAAYXR0ZW1wdGVkIHRvIGZvcm1hdCBhIG1hcCB2YWx1ZSBiZWZvcmUgaXRzIGtleQAAQHkiAC4AAABTJxAAIAAAACUEAAANAAAAYXR0ZW1wdGVkIHRvIGZpbmlzaCBhIG1hcCB3aXRoIGEgcGFydGlhbCBlbnRyeQAAiHkiAC4AAABTJxAAIAAAALEEAAANAAAAwVEQABsAAABJAAAAEQAAADB4MDAwMTAyMDMwNDA1MDYwNzA4MDkxMDExMTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5Nzk4OTkAAMFREAAbAAAAwAIAAA0AAADBURAAGwAAAGwDAAAJAAAAwVEQABsAAABtAwAACQAAAMFREAAbAAAAbgMAAAkAAADBURAAGwAAAG8DAAAJAAAAAAAAABQAAAAEAAAAKQ8AACoPAAArDwAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMF95EAAbAAAANQcAAB8AAABfeRAAGwAAADYJAAAJAAAAAAAAAAgAAAAEAAAAHQ8AAGZhbHNldHJ1ZQAAAF95EAAbAAAArwoAACYAAABfeRAAGwAAALgKAAAaAAAAsTMQACAAAACEAAAAHgAAALEzEAAgAAAAoAAAAAkAAAB1c2VyLXByb3ZpZGVkIGNvbXBhcmlzb24gZnVuY3Rpb24gZG9lcyBub3QgY29ycmVjdGx5IGltcGxlbWVudCBhIHRvdGFsIG9yZGVy0HsiAEwAAACaGRAALwAAAFwDAAAFAAAAYXR0ZW1wdGVkIHRvIGluZGV4IHNsaWNlIGZyb20gYWZ0ZXIgbWF4aW11bSB1c2l6ZQAAADR8IgAxAAAAYXR0ZW1wdGVkIHRvIGluZGV4IHNsaWNlIHVwIHRvIG1heGltdW0gdXNpemVwfCIALAAAAGludmFsaWQgdXRmLTggc2VxdWVuY2Ugb2YgIGJ5dGVzIGZyb20gaW5kZXggpHwiABoAAAC+fCIAEgAAAGluY29tcGxldGUgdXRmLTggYnl0ZSBzZXF1ZW5jZSBmcm9tIGluZGV4IAAA4HwiACoAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB1vuJAQszAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwQEBAQEAEGU/IkBC7kRpEoQAB8AAAB0BQAAEgAAAKRKEAAfAAAAdAUAACgAAACkShAAHwAAAGcGAAAVAAAApEoQAB8AAACVBgAAFQAAAKRKEAAfAAAAlgYAABUAAABbLi4uXWJlZ2luIDw9IGVuZCAoIDw9ICkgd2hlbiBzbGljaW5nIGBgaX4iAA4AAAB3fiIABAAAAHt+IgAQAAAAi34iAAEAAABieXRlIGluZGV4ICBpcyBub3QgYSBjaGFyIGJvdW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAArH4iAAsAAAC3fiIAJgAAAN1+IgAIAAAA5X4iAAYAAACLfiIAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAAKx+IgALAAAAFH8iABYAAACLfiIAAQAAACBuEAAlAAAAGgAAADYAAAAgbhAAJQAAAAoAAAArAAAAAAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcCGQ0cBR0IHwEkAWoEawKvA7ECvALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5OT4+enp97i5OWorK6hrEGBwk2PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpOT2RlioyNj7bBw8TGy9ZctrcbHAcICgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9TVJqbLi8nKFWdoKGjpKeorbq8xAYLDBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhKTFBTVVZYWlxeYGNlZmtzeH1/iqSqr7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4FKwVEBA4qgKoGJAQkBCgINAtOAzQMgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAnBAwJNgM6BRoHBAwHUEk3Mw0zBy4ICgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgnCXULQj4qBjsFCgZRBgEFEAMFC1kIAh1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpGRRtICFMNSQcKgLYiDgoGRgodA0dJNwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAWCo+bBYJHmrk6hsaCOQcqBFwGJgpGCigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0GDgQIgYyJBGsFDQMJBxCPYID6BoG0TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA1SsFPiEBcC0DGgQCgUAfEToFAYHQKoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwEZAxWCoCuOB0NLAQJBwIOBoCag9gEEQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJB4D6hAYAAQMFBQYGAgcGCAcJEQocCxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysDLQsuATAEMQIyAacEqQKqBKsI+gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSNjpGSqbG6u8XGycre5OX/AAQREikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJSl5kZYSRm53Jzs8NESk6O0VJV1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYukpr6/xcfP2ttImL3Nxs7PSU5PV1leX4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6ur027vBYXHh9GR05PWFpcXn5/tcXU1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/Tk9aWwcIDxAnL+7vbm83PT9CRZCRU2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEcAxkIAQQvBDQEBwMBBwYHEQpQDxIHVQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcMUARDAy0DAQQRBg8MOgQdJV8gbQRqJYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwEDAQBAzELLAQaBgsDgKwGCgYvMYD0CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUvBTsHAg4YCYC+InQMgNYagRAFgOEJ8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgcChYJTASAigarpAwXBDGhBIHaJgcMBQWAphCB9QcBICoGTASAjQSAvgMbAw8NgICAgICAgICA9O6AgPKAgICAgICAgICAgICAgICAgIAgIaIjJCUmpygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWlvcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9foCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAKJREAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2VydGlvbiBmYWlsZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwZW5jb2RlX3V0Zjg6IG5lZWQgIGJ5dGVzIHRvIGVuY29kZSBVKyBidXQgYnVmZmVyIGhhcyBqdXN0IHKGIgASAAAAhIYiABMAAACXhiIAFQAAAAIAAAAAAAAAAgBB2I2KAQsFIAAA4AIAQeaNigELr2AEAAAAAAABAAAAIAAA6QIAAAAAAAAAAgAAAAAAAAACAAAAIAAA4GF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8AAAAMhyIAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1haW5kZXIgd2l0aCBhIGRpdmlzb3Igb2YgemVybwAAADCHIgA5AAAAYGFzeW5jIGZuYCByZXN1bWVkIGFmdGVyIGNvbXBsZXRpb24AdIciACMAAABFcnJvcnJhbmdlIHN0YXJ0IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxlbmd0aCAAAAClhyIAEgAAALeHIgAiAAAAcmFuZ2UgZW5kIGluZGV4IOyHIgAQAAAAt4ciACIAAABzbGljZSBpbmRleCBzdGFydHMgYXQgIGJ1dCBlbmRzIGF0IAAMiCIAFgAAACKIIgANAAAAY29weV9mcm9tX3NsaWNlOiBzb3VyY2Ugc2xpY2UgbGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9uIHNsaWNlIGxlbmd0aCAoAAAAQIgiACYAAABmiCIAKwAAAJN2IgABAAAAsAIAAF0ToAISFyAivR9gInwsIDAFMGA0FaDgNfikYDcMpqA3HvvgNwD+4EP9AWFEgAchSAEK4UgkDaFJqw4hSy8YIUw7GaFbMBwhXPMeoV8wNGFjHmHhZPBqYWVAbeFlT2+hZvCvIWedvCFoAM/haGfRYWkA2uFpAOAha67ioWzr5KFu0Oghb/vzoW8BAC5w8AF/cKAQAACgE+AGgBwgCBYfoAi2JMAJACwgE0CmYBMwq+AUAPtgFyH/IBgABKEYgAchGYAM4RugGOEcQG7hHQDUIR6m1mEeAN8BIzDg4SUA6aEmMPHhJorxMicAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvgLQD+IDae/2A2/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFVAM9hVmXRoVYA2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9d0pUQACgAAADsAgAAHQAAAMAAAADgAAAAwQAAAOEAAADCAAAA4gAAAMMAAADjAAAAxAAAAOQAAADFAAAA5QAAAMYAAADmAAAAxwAAAOcAAADIAAAA6AAAAMkAAADpAAAAygAAAOoAAADLAAAA6wAAAMwAAADsAAAAzQAAAO0AAADOAAAA7gAAAM8AAADvAAAA0AAAAPAAAADRAAAA8QAAANIAAADyAAAA0wAAAPMAAADUAAAA9AAAANUAAAD1AAAA1gAAAPYAAADYAAAA+AAAANkAAAD5AAAA2gAAAPoAAADbAAAA+wAAANwAAAD8AAAA3QAAAP0AAADeAAAA/gAAAAABAAABAQAAAgEAAAMBAAAEAQAABQEAAAYBAAAHAQAACAEAAAkBAAAKAQAACwEAAAwBAAANAQAADgEAAA8BAAAQAQAAEQEAABIBAAATAQAAFAEAABUBAAAWAQAAFwEAABgBAAAZAQAAGgEAABsBAAAcAQAAHQEAAB4BAAAfAQAAIAEAACEBAAAiAQAAIwEAACQBAAAlAQAAJgEAACcBAAAoAQAAKQEAACoBAAArAQAALAEAAC0BAAAuAQAALwEAADABAAAAAEAAMgEAADMBAAA0AQAANQEAADYBAAA3AQAAOQEAADoBAAA7AQAAPAEAAD0BAAA+AQAAPwEAAEABAABBAQAAQgEAAEMBAABEAQAARQEAAEYBAABHAQAASAEAAEoBAABLAQAATAEAAE0BAABOAQAATwEAAFABAABRAQAAUgEAAFMBAABUAQAAVQEAAFYBAABXAQAAWAEAAFkBAABaAQAAWwEAAFwBAABdAQAAXgEAAF8BAABgAQAAYQEAAGIBAABjAQAAZAEAAGUBAABmAQAAZwEAAGgBAABpAQAAagEAAGsBAABsAQAAbQEAAG4BAABvAQAAcAEAAHEBAAByAQAAcwEAAHQBAAB1AQAAdgEAAHcBAAB4AQAA/wAAAHkBAAB6AQAAewEAAHwBAAB9AQAAfgEAAIEBAABTAgAAggEAAIMBAACEAQAAhQEAAIYBAABUAgAAhwEAAIgBAACJAQAAVgIAAIoBAABXAgAAiwEAAIwBAACOAQAA3QEAAI8BAABZAgAAkAEAAFsCAACRAQAAkgEAAJMBAABgAgAAlAEAAGMCAACWAQAAaQIAAJcBAABoAgAAmAEAAJkBAACcAQAAbwIAAJ0BAAByAgAAnwEAAHUCAACgAQAAoQEAAKIBAACjAQAApAEAAKUBAACmAQAAgAIAAKcBAACoAQAAqQEAAIMCAACsAQAArQEAAK4BAACIAgAArwEAALABAACxAQAAigIAALIBAACLAgAAswEAALQBAAC1AQAAtgEAALcBAACSAgAAuAEAALkBAAC8AQAAvQEAAMQBAADGAQAAxQEAAMYBAADHAQAAyQEAAMgBAADJAQAAygEAAMwBAADLAQAAzAEAAM0BAADOAQAAzwEAANABAADRAQAA0gEAANMBAADUAQAA1QEAANYBAADXAQAA2AEAANkBAADaAQAA2wEAANwBAADeAQAA3wEAAOABAADhAQAA4gEAAOMBAADkAQAA5QEAAOYBAADnAQAA6AEAAOkBAADqAQAA6wEAAOwBAADtAQAA7gEAAO8BAADxAQAA8wEAAPIBAADzAQAA9AEAAPUBAAD2AQAAlQEAAPcBAAC/AQAA+AEAAPkBAAD6AQAA+wEAAPwBAAD9AQAA/gEAAP8BAAAAAgAAAQIAAAICAAADAgAABAIAAAUCAAAGAgAABwIAAAgCAAAJAgAACgIAAAsCAAAMAgAADQIAAA4CAAAPAgAAEAIAABECAAASAgAAEwIAABQCAAAVAgAAFgIAABcCAAAYAgAAGQIAABoCAAAbAgAAHAIAAB0CAAAeAgAAHwIAACACAACeAQAAIgIAACMCAAAkAgAAJQIAACYCAAAnAgAAKAIAACkCAAAqAgAAKwIAACwCAAAtAgAALgIAAC8CAAAwAgAAMQIAADICAAAzAgAAOgIAAGUsAAA7AgAAPAIAAD0CAACaAQAAPgIAAGYsAABBAgAAQgIAAEMCAACAAQAARAIAAIkCAABFAgAAjAIAAEYCAABHAgAASAIAAEkCAABKAgAASwIAAEwCAABNAgAATgIAAE8CAABwAwAAcQMAAHIDAABzAwAAdgMAAHcDAAB/AwAA8wMAAIYDAACsAwAAiAMAAK0DAACJAwAArgMAAIoDAACvAwAAjAMAAMwDAACOAwAAzQMAAI8DAADOAwAAkQMAALEDAACSAwAAsgMAAJMDAACzAwAAlAMAALQDAACVAwAAtQMAAJYDAAC2AwAAlwMAALcDAACYAwAAuAMAAJkDAAC5AwAAmgMAALoDAACbAwAAuwMAAJwDAAC8AwAAnQMAAL0DAACeAwAAvgMAAJ8DAAC/AwAAoAMAAMADAAChAwAAwQMAAKMDAADDAwAApAMAAMQDAAClAwAAxQMAAKYDAADGAwAApwMAAMcDAACoAwAAyAMAAKkDAADJAwAAqgMAAMoDAACrAwAAywMAAM8DAADXAwAA2AMAANkDAADaAwAA2wMAANwDAADdAwAA3gMAAN8DAADgAwAA4QMAAOIDAADjAwAA5AMAAOUDAADmAwAA5wMAAOgDAADpAwAA6gMAAOsDAADsAwAA7QMAAO4DAADvAwAA9AMAALgDAAD3AwAA+AMAAPkDAADyAwAA+gMAAPsDAAD9AwAAewMAAP4DAAB8AwAA/wMAAH0DAAAABAAAUAQAAAEEAABRBAAAAgQAAFIEAAADBAAAUwQAAAQEAABUBAAABQQAAFUEAAAGBAAAVgQAAAcEAABXBAAACAQAAFgEAAAJBAAAWQQAAAoEAABaBAAACwQAAFsEAAAMBAAAXAQAAA0EAABdBAAADgQAAF4EAAAPBAAAXwQAABAEAAAwBAAAEQQAADEEAAASBAAAMgQAABMEAAAzBAAAFAQAADQEAAAVBAAANQQAABYEAAA2BAAAFwQAADcEAAAYBAAAOAQAABkEAAA5BAAAGgQAADoEAAAbBAAAOwQAABwEAAA8BAAAHQQAAD0EAAAeBAAAPgQAAB8EAAA/BAAAIAQAAEAEAAAhBAAAQQQAACIEAABCBAAAIwQAAEMEAAAkBAAARAQAACUEAABFBAAAJgQAAEYEAAAnBAAARwQAACgEAABIBAAAKQQAAEkEAAAqBAAASgQAACsEAABLBAAALAQAAEwEAAAtBAAATQQAAC4EAABOBAAALwQAAE8EAABgBAAAYQQAAGIEAABjBAAAZAQAAGUEAABmBAAAZwQAAGgEAABpBAAAagQAAGsEAABsBAAAbQQAAG4EAABvBAAAcAQAAHEEAAByBAAAcwQAAHQEAAB1BAAAdgQAAHcEAAB4BAAAeQQAAHoEAAB7BAAAfAQAAH0EAAB+BAAAfwQAAIAEAACBBAAAigQAAIsEAACMBAAAjQQAAI4EAACPBAAAkAQAAJEEAACSBAAAkwQAAJQEAACVBAAAlgQAAJcEAACYBAAAmQQAAJoEAACbBAAAnAQAAJ0EAACeBAAAnwQAAKAEAAChBAAAogQAAKMEAACkBAAApQQAAKYEAACnBAAAqAQAAKkEAACqBAAAqwQAAKwEAACtBAAArgQAAK8EAACwBAAAsQQAALIEAACzBAAAtAQAALUEAAC2BAAAtwQAALgEAAC5BAAAugQAALsEAAC8BAAAvQQAAL4EAAC/BAAAwAQAAM8EAADBBAAAwgQAAMMEAADEBAAAxQQAAMYEAADHBAAAyAQAAMkEAADKBAAAywQAAMwEAADNBAAAzgQAANAEAADRBAAA0gQAANMEAADUBAAA1QQAANYEAADXBAAA2AQAANkEAADaBAAA2wQAANwEAADdBAAA3gQAAN8EAADgBAAA4QQAAOIEAADjBAAA5AQAAOUEAADmBAAA5wQAAOgEAADpBAAA6gQAAOsEAADsBAAA7QQAAO4EAADvBAAA8AQAAPEEAADyBAAA8wQAAPQEAAD1BAAA9gQAAPcEAAD4BAAA+QQAAPoEAAD7BAAA/AQAAP0EAAD+BAAA/wQAAAAFAAABBQAAAgUAAAMFAAAEBQAABQUAAAYFAAAHBQAACAUAAAkFAAAKBQAACwUAAAwFAAANBQAADgUAAA8FAAAQBQAAEQUAABIFAAATBQAAFAUAABUFAAAWBQAAFwUAABgFAAAZBQAAGgUAABsFAAAcBQAAHQUAAB4FAAAfBQAAIAUAACEFAAAiBQAAIwUAACQFAAAlBQAAJgUAACcFAAAoBQAAKQUAACoFAAArBQAALAUAAC0FAAAuBQAALwUAADEFAABhBQAAMgUAAGIFAAAzBQAAYwUAADQFAABkBQAANQUAAGUFAAA2BQAAZgUAADcFAABnBQAAOAUAAGgFAAA5BQAAaQUAADoFAABqBQAAOwUAAGsFAAA8BQAAbAUAAD0FAABtBQAAPgUAAG4FAAA/BQAAbwUAAEAFAABwBQAAQQUAAHEFAABCBQAAcgUAAEMFAABzBQAARAUAAHQFAABFBQAAdQUAAEYFAAB2BQAARwUAAHcFAABIBQAAeAUAAEkFAAB5BQAASgUAAHoFAABLBQAAewUAAEwFAAB8BQAATQUAAH0FAABOBQAAfgUAAE8FAAB/BQAAUAUAAIAFAABRBQAAgQUAAFIFAACCBQAAUwUAAIMFAABUBQAAhAUAAFUFAACFBQAAVgUAAIYFAACgEAAAAC0AAKEQAAABLQAAohAAAAItAACjEAAAAy0AAKQQAAAELQAApRAAAAUtAACmEAAABi0AAKcQAAAHLQAAqBAAAAgtAACpEAAACS0AAKoQAAAKLQAAqxAAAAstAACsEAAADC0AAK0QAAANLQAArhAAAA4tAACvEAAADy0AALAQAAAQLQAAsRAAABEtAACyEAAAEi0AALMQAAATLQAAtBAAABQtAAC1EAAAFS0AALYQAAAWLQAAtxAAABctAAC4EAAAGC0AALkQAAAZLQAAuhAAABotAAC7EAAAGy0AALwQAAAcLQAAvRAAAB0tAAC+EAAAHi0AAL8QAAAfLQAAwBAAACAtAADBEAAAIS0AAMIQAAAiLQAAwxAAACMtAADEEAAAJC0AAMUQAAAlLQAAxxAAACctAADNEAAALS0AAKATAABwqwAAoRMAAHGrAACiEwAAcqsAAKMTAABzqwAApBMAAHSrAAClEwAAdasAAKYTAAB2qwAApxMAAHerAACoEwAAeKsAAKkTAAB5qwAAqhMAAHqrAACrEwAAe6sAAKwTAAB8qwAArRMAAH2rAACuEwAAfqsAAK8TAAB/qwAAsBMAAICrAACxEwAAgasAALITAACCqwAAsxMAAIOrAAC0EwAAhKsAALUTAACFqwAAthMAAIarAAC3EwAAh6sAALgTAACIqwAAuRMAAImrAAC6EwAAiqsAALsTAACLqwAAvBMAAIyrAAC9EwAAjasAAL4TAACOqwAAvxMAAI+rAADAEwAAkKsAAMETAACRqwAAwhMAAJKrAADDEwAAk6sAAMQTAACUqwAAxRMAAJWrAADGEwAAlqsAAMcTAACXqwAAyBMAAJirAADJEwAAmasAAMoTAACaqwAAyxMAAJurAADMEwAAnKsAAM0TAACdqwAAzhMAAJ6rAADPEwAAn6sAANATAACgqwAA0RMAAKGrAADSEwAAoqsAANMTAACjqwAA1BMAAKSrAADVEwAApasAANYTAACmqwAA1xMAAKerAADYEwAAqKsAANkTAACpqwAA2hMAAKqrAADbEwAAq6sAANwTAACsqwAA3RMAAK2rAADeEwAArqsAAN8TAACvqwAA4BMAALCrAADhEwAAsasAAOITAACyqwAA4xMAALOrAADkEwAAtKsAAOUTAAC1qwAA5hMAALarAADnEwAAt6sAAOgTAAC4qwAA6RMAALmrAADqEwAAuqsAAOsTAAC7qwAA7BMAALyrAADtEwAAvasAAO4TAAC+qwAA7xMAAL+rAADwEwAA+BMAAPETAAD5EwAA8hMAAPoTAADzEwAA+xMAAPQTAAD8EwAA9RMAAP0TAACJHAAAihwAAJAcAADQEAAAkRwAANEQAACSHAAA0hAAAJMcAADTEAAAlBwAANQQAACVHAAA1RAAAJYcAADWEAAAlxwAANcQAACYHAAA2BAAAJkcAADZEAAAmhwAANoQAACbHAAA2xAAAJwcAADcEAAAnRwAAN0QAACeHAAA3hAAAJ8cAADfEAAAoBwAAOAQAAChHAAA4RAAAKIcAADiEAAAoxwAAOMQAACkHAAA5BAAAKUcAADlEAAAphwAAOYQAACnHAAA5xAAAKgcAADoEAAAqRwAAOkQAACqHAAA6hAAAKscAADrEAAArBwAAOwQAACtHAAA7RAAAK4cAADuEAAArxwAAO8QAACwHAAA8BAAALEcAADxEAAAshwAAPIQAACzHAAA8xAAALQcAAD0EAAAtRwAAPUQAAC2HAAA9hAAALccAAD3EAAAuBwAAPgQAAC5HAAA+RAAALocAAD6EAAAvRwAAP0QAAC+HAAA/hAAAL8cAAD/EAAAAB4AAAEeAAACHgAAAx4AAAQeAAAFHgAABh4AAAceAAAIHgAACR4AAAoeAAALHgAADB4AAA0eAAAOHgAADx4AABAeAAARHgAAEh4AABMeAAAUHgAAFR4AABYeAAAXHgAAGB4AABkeAAAaHgAAGx4AABweAAAdHgAAHh4AAB8eAAAgHgAAIR4AACIeAAAjHgAAJB4AACUeAAAmHgAAJx4AACgeAAApHgAAKh4AACseAAAsHgAALR4AAC4eAAAvHgAAMB4AADEeAAAyHgAAMx4AADQeAAA1HgAANh4AADceAAA4HgAAOR4AADoeAAA7HgAAPB4AAD0eAAA+HgAAPx4AAEAeAABBHgAAQh4AAEMeAABEHgAARR4AAEYeAABHHgAASB4AAEkeAABKHgAASx4AAEweAABNHgAATh4AAE8eAABQHgAAUR4AAFIeAABTHgAAVB4AAFUeAABWHgAAVx4AAFgeAABZHgAAWh4AAFseAABcHgAAXR4AAF4eAABfHgAAYB4AAGEeAABiHgAAYx4AAGQeAABlHgAAZh4AAGceAABoHgAAaR4AAGoeAABrHgAAbB4AAG0eAABuHgAAbx4AAHAeAABxHgAAch4AAHMeAAB0HgAAdR4AAHYeAAB3HgAAeB4AAHkeAAB6HgAAex4AAHweAAB9HgAAfh4AAH8eAACAHgAAgR4AAIIeAACDHgAAhB4AAIUeAACGHgAAhx4AAIgeAACJHgAAih4AAIseAACMHgAAjR4AAI4eAACPHgAAkB4AAJEeAACSHgAAkx4AAJQeAACVHgAAnh4AAN8AAACgHgAAoR4AAKIeAACjHgAApB4AAKUeAACmHgAApx4AAKgeAACpHgAAqh4AAKseAACsHgAArR4AAK4eAACvHgAAsB4AALEeAACyHgAAsx4AALQeAAC1HgAAth4AALceAAC4HgAAuR4AALoeAAC7HgAAvB4AAL0eAAC+HgAAvx4AAMAeAADBHgAAwh4AAMMeAADEHgAAxR4AAMYeAADHHgAAyB4AAMkeAADKHgAAyx4AAMweAADNHgAAzh4AAM8eAADQHgAA0R4AANIeAADTHgAA1B4AANUeAADWHgAA1x4AANgeAADZHgAA2h4AANseAADcHgAA3R4AAN4eAADfHgAA4B4AAOEeAADiHgAA4x4AAOQeAADlHgAA5h4AAOceAADoHgAA6R4AAOoeAADrHgAA7B4AAO0eAADuHgAA7x4AAPAeAADxHgAA8h4AAPMeAAD0HgAA9R4AAPYeAAD3HgAA+B4AAPkeAAD6HgAA+x4AAPweAAD9HgAA/h4AAP8eAAAIHwAAAB8AAAkfAAABHwAACh8AAAIfAAALHwAAAx8AAAwfAAAEHwAADR8AAAUfAAAOHwAABh8AAA8fAAAHHwAAGB8AABAfAAAZHwAAER8AABofAAASHwAAGx8AABMfAAAcHwAAFB8AAB0fAAAVHwAAKB8AACAfAAApHwAAIR8AACofAAAiHwAAKx8AACMfAAAsHwAAJB8AAC0fAAAlHwAALh8AACYfAAAvHwAAJx8AADgfAAAwHwAAOR8AADEfAAA6HwAAMh8AADsfAAAzHwAAPB8AADQfAAA9HwAANR8AAD4fAAA2HwAAPx8AADcfAABIHwAAQB8AAEkfAABBHwAASh8AAEIfAABLHwAAQx8AAEwfAABEHwAATR8AAEUfAABZHwAAUR8AAFsfAABTHwAAXR8AAFUfAABfHwAAVx8AAGgfAABgHwAAaR8AAGEfAABqHwAAYh8AAGsfAABjHwAAbB8AAGQfAABtHwAAZR8AAG4fAABmHwAAbx8AAGcfAACIHwAAgB8AAIkfAACBHwAAih8AAIIfAACLHwAAgx8AAIwfAACEHwAAjR8AAIUfAACOHwAAhh8AAI8fAACHHwAAmB8AAJAfAACZHwAAkR8AAJofAACSHwAAmx8AAJMfAACcHwAAlB8AAJ0fAACVHwAAnh8AAJYfAACfHwAAlx8AAKgfAACgHwAAqR8AAKEfAACqHwAAoh8AAKsfAACjHwAArB8AAKQfAACtHwAApR8AAK4fAACmHwAArx8AAKcfAAC4HwAAsB8AALkfAACxHwAAuh8AAHAfAAC7HwAAcR8AALwfAACzHwAAyB8AAHIfAADJHwAAcx8AAMofAAB0HwAAyx8AAHUfAADMHwAAwx8AANgfAADQHwAA2R8AANEfAADaHwAAdh8AANsfAAB3HwAA6B8AAOAfAADpHwAA4R8AAOofAAB6HwAA6x8AAHsfAADsHwAA5R8AAPgfAAB4HwAA+R8AAHkfAAD6HwAAfB8AAPsfAAB9HwAA/B8AAPMfAAAmIQAAyQMAACohAABrAAAAKyEAAOUAAAAyIQAATiEAAGAhAABwIQAAYSEAAHEhAABiIQAAciEAAGMhAABzIQAAZCEAAHQhAABlIQAAdSEAAGYhAAB2IQAAZyEAAHchAABoIQAAeCEAAGkhAAB5IQAAaiEAAHohAABrIQAAeyEAAGwhAAB8IQAAbSEAAH0hAABuIQAAfiEAAG8hAAB/IQAAgyEAAIQhAAC2JAAA0CQAALckAADRJAAAuCQAANIkAAC5JAAA0yQAALokAADUJAAAuyQAANUkAAC8JAAA1iQAAL0kAADXJAAAviQAANgkAAC/JAAA2SQAAMAkAADaJAAAwSQAANskAADCJAAA3CQAAMMkAADdJAAAxCQAAN4kAADFJAAA3yQAAMYkAADgJAAAxyQAAOEkAADIJAAA4iQAAMkkAADjJAAAyiQAAOQkAADLJAAA5SQAAMwkAADmJAAAzSQAAOckAADOJAAA6CQAAM8kAADpJAAAACwAADAsAAABLAAAMSwAAAIsAAAyLAAAAywAADMsAAAELAAANCwAAAUsAAA1LAAABiwAADYsAAAHLAAANywAAAgsAAA4LAAACSwAADksAAAKLAAAOiwAAAssAAA7LAAADCwAADwsAAANLAAAPSwAAA4sAAA+LAAADywAAD8sAAAQLAAAQCwAABEsAABBLAAAEiwAAEIsAAATLAAAQywAABQsAABELAAAFSwAAEUsAAAWLAAARiwAABcsAABHLAAAGCwAAEgsAAAZLAAASSwAABosAABKLAAAGywAAEssAAAcLAAATCwAAB0sAABNLAAAHiwAAE4sAAAfLAAATywAACAsAABQLAAAISwAAFEsAAAiLAAAUiwAACMsAABTLAAAJCwAAFQsAAAlLAAAVSwAACYsAABWLAAAJywAAFcsAAAoLAAAWCwAACksAABZLAAAKiwAAFosAAArLAAAWywAACwsAABcLAAALSwAAF0sAAAuLAAAXiwAAC8sAABfLAAAYCwAAGEsAABiLAAAawIAAGMsAAB9HQAAZCwAAH0CAABnLAAAaCwAAGksAABqLAAAaywAAGwsAABtLAAAUQIAAG4sAABxAgAAbywAAFACAABwLAAAUgIAAHIsAABzLAAAdSwAAHYsAAB+LAAAPwIAAH8sAABAAgAAgCwAAIEsAACCLAAAgywAAIQsAACFLAAAhiwAAIcsAACILAAAiSwAAIosAACLLAAAjCwAAI0sAACOLAAAjywAAJAsAACRLAAAkiwAAJMsAACULAAAlSwAAJYsAACXLAAAmCwAAJksAACaLAAAmywAAJwsAACdLAAAniwAAJ8sAACgLAAAoSwAAKIsAACjLAAApCwAAKUsAACmLAAApywAAKgsAACpLAAAqiwAAKssAACsLAAArSwAAK4sAACvLAAAsCwAALEsAACyLAAAsywAALQsAAC1LAAAtiwAALcsAAC4LAAAuSwAALosAAC7LAAAvCwAAL0sAAC+LAAAvywAAMAsAADBLAAAwiwAAMMsAADELAAAxSwAAMYsAADHLAAAyCwAAMksAADKLAAAyywAAMwsAADNLAAAziwAAM8sAADQLAAA0SwAANIsAADTLAAA1CwAANUsAADWLAAA1ywAANgsAADZLAAA2iwAANssAADcLAAA3SwAAN4sAADfLAAA4CwAAOEsAADiLAAA4ywAAOssAADsLAAA7SwAAO4sAADyLAAA8ywAAECmAABBpgAAQqYAAEOmAABEpgAARaYAAEamAABHpgAASKYAAEmmAABKpgAAS6YAAEymAABNpgAATqYAAE+mAABQpgAAUaYAAFKmAABTpgAAVKYAAFWmAABWpgAAV6YAAFimAABZpgAAWqYAAFumAABcpgAAXaYAAF6mAABfpgAAYKYAAGGmAABipgAAY6YAAGSmAABlpgAAZqYAAGemAABopgAAaaYAAGqmAABrpgAAbKYAAG2mAACApgAAgaYAAIKmAACDpgAAhKYAAIWmAACGpgAAh6YAAIimAACJpgAAiqYAAIumAACMpgAAjaYAAI6mAACPpgAAkKYAAJGmAACSpgAAk6YAAJSmAACVpgAAlqYAAJemAACYpgAAmaYAAJqmAACbpgAAIqcAACOnAAAkpwAAJacAACanAAAnpwAAKKcAACmnAAAqpwAAK6cAACynAAAtpwAALqcAAC+nAAAypwAAM6cAADSnAAA1pwAANqcAADenAAA4pwAAOacAADqnAAA7pwAAPKcAAD2nAAA+pwAAP6cAAECnAABBpwAAQqcAAEOnAABEpwAARacAAEanAABHpwAASKcAAEmnAABKpwAAS6cAAEynAABNpwAATqcAAE+nAABQpwAAUacAAFKnAABTpwAAVKcAAFWnAABWpwAAV6cAAFinAABZpwAAWqcAAFunAABcpwAAXacAAF6nAABfpwAAYKcAAGGnAABipwAAY6cAAGSnAABlpwAAZqcAAGenAABopwAAaacAAGqnAABrpwAAbKcAAG2nAABupwAAb6cAAHmnAAB6pwAAe6cAAHynAAB9pwAAeR0AAH6nAAB/pwAAgKcAAIGnAACCpwAAg6cAAISnAACFpwAAhqcAAIenAACLpwAAjKcAAI2nAABlAgAAkKcAAJGnAACSpwAAk6cAAJanAACXpwAAmKcAAJmnAACapwAAm6cAAJynAACdpwAAnqcAAJ+nAACgpwAAoacAAKKnAACjpwAApKcAAKWnAACmpwAAp6cAAKinAACppwAAqqcAAGYCAACrpwAAXAIAAKynAABhAgAAracAAGwCAACupwAAagIAALCnAACeAgAAsacAAIcCAACypwAAnQIAALOnAABTqwAAtKcAALWnAAC2pwAAt6cAALinAAC5pwAAuqcAALunAAC8pwAAvacAAL6nAAC/pwAAwKcAAMGnAADCpwAAw6cAAMSnAACUpwAAxacAAIICAADGpwAAjh0AAMenAADIpwAAyacAAMqnAADLpwAAZAIAAMynAADNpwAA0KcAANGnAADWpwAA16cAANinAADZpwAA2qcAANunAADcpwAAmwEAAPWnAAD2pwAAIf8AAEH/AAAi/wAAQv8AACP/AABD/wAAJP8AAET/AAAl/wAARf8AACb/AABG/wAAJ/8AAEf/AAAo/wAASP8AACn/AABJ/wAAKv8AAEr/AAAr/wAAS/8AACz/AABM/wAALf8AAE3/AAAu/wAATv8AAC//AABP/wAAMP8AAFD/AAAx/wAAUf8AADL/AABS/wAAM/8AAFP/AAA0/wAAVP8AADX/AABV/wAANv8AAFb/AAA3/wAAV/8AADj/AABY/wAAOf8AAFn/AAA6/wAAWv8AAAAEAQAoBAEAAQQBACkEAQACBAEAKgQBAAMEAQArBAEABAQBACwEAQAFBAEALQQBAAYEAQAuBAEABwQBAC8EAQAIBAEAMAQBAAkEAQAxBAEACgQBADIEAQALBAEAMwQBAAwEAQA0BAEADQQBADUEAQAOBAEANgQBAA8EAQA3BAEAEAQBADgEAQARBAEAOQQBABIEAQA6BAEAEwQBADsEAQAUBAEAPAQBABUEAQA9BAEAFgQBAD4EAQAXBAEAPwQBABgEAQBABAEAGQQBAEEEAQAaBAEAQgQBABsEAQBDBAEAHAQBAEQEAQAdBAEARQQBAB4EAQBGBAEAHwQBAEcEAQAgBAEASAQBACEEAQBJBAEAIgQBAEoEAQAjBAEASwQBACQEAQBMBAEAJQQBAE0EAQAmBAEATgQBACcEAQBPBAEAsAQBANgEAQCxBAEA2QQBALIEAQDaBAEAswQBANsEAQC0BAEA3AQBALUEAQDdBAEAtgQBAN4EAQC3BAEA3wQBALgEAQDgBAEAuQQBAOEEAQC6BAEA4gQBALsEAQDjBAEAvAQBAOQEAQC9BAEA5QQBAL4EAQDmBAEAvwQBAOcEAQDABAEA6AQBAMEEAQDpBAEAwgQBAOoEAQDDBAEA6wQBAMQEAQDsBAEAxQQBAO0EAQDGBAEA7gQBAMcEAQDvBAEAyAQBAPAEAQDJBAEA8QQBAMoEAQDyBAEAywQBAPMEAQDMBAEA9AQBAM0EAQD1BAEAzgQBAPYEAQDPBAEA9wQBANAEAQD4BAEA0QQBAPkEAQDSBAEA+gQBANMEAQD7BAEAcAUBAJcFAQBxBQEAmAUBAHIFAQCZBQEAcwUBAJoFAQB0BQEAmwUBAHUFAQCcBQEAdgUBAJ0FAQB3BQEAngUBAHgFAQCfBQEAeQUBAKAFAQB6BQEAoQUBAHwFAQCjBQEAfQUBAKQFAQB+BQEApQUBAH8FAQCmBQEAgAUBAKcFAQCBBQEAqAUBAIIFAQCpBQEAgwUBAKoFAQCEBQEAqwUBAIUFAQCsBQEAhgUBAK0FAQCHBQEArgUBAIgFAQCvBQEAiQUBALAFAQCKBQEAsQUBAIwFAQCzBQEAjQUBALQFAQCOBQEAtQUBAI8FAQC2BQEAkAUBALcFAQCRBQEAuAUBAJIFAQC5BQEAlAUBALsFAQCVBQEAvAUBAIAMAQDADAEAgQwBAMEMAQCCDAEAwgwBAIMMAQDDDAEAhAwBAMQMAQCFDAEAxQwBAIYMAQDGDAEAhwwBAMcMAQCIDAEAyAwBAIkMAQDJDAEAigwBAMoMAQCLDAEAywwBAIwMAQDMDAEAjQwBAM0MAQCODAEAzgwBAI8MAQDPDAEAkAwBANAMAQCRDAEA0QwBAJIMAQDSDAEAkwwBANMMAQCUDAEA1AwBAJUMAQDVDAEAlgwBANYMAQCXDAEA1wwBAJgMAQDYDAEAmQwBANkMAQCaDAEA2gwBAJsMAQDbDAEAnAwBANwMAQCdDAEA3QwBAJ4MAQDeDAEAnwwBAN8MAQCgDAEA4AwBAKEMAQDhDAEAogwBAOIMAQCjDAEA4wwBAKQMAQDkDAEApQwBAOUMAQCmDAEA5gwBAKcMAQDnDAEAqAwBAOgMAQCpDAEA6QwBAKoMAQDqDAEAqwwBAOsMAQCsDAEA7AwBAK0MAQDtDAEArgwBAO4MAQCvDAEA7wwBALAMAQDwDAEAsQwBAPEMAQCyDAEA8gwBAFANAQBwDQEAUQ0BAHENAQBSDQEAcg0BAFMNAQBzDQEAVA0BAHQNAQBVDQEAdQ0BAFYNAQB2DQEAVw0BAHcNAQBYDQEAeA0BAFkNAQB5DQEAWg0BAHoNAQBbDQEAew0BAFwNAQB8DQEAXQ0BAH0NAQBeDQEAfg0BAF8NAQB/DQEAYA0BAIANAQBhDQEAgQ0BAGINAQCCDQEAYw0BAIMNAQBkDQEAhA0BAGUNAQCFDQEAoBgBAMAYAQChGAEAwRgBAKIYAQDCGAEAoxgBAMMYAQCkGAEAxBgBAKUYAQDFGAEAphgBAMYYAQCnGAEAxxgBAKgYAQDIGAEAqRgBAMkYAQCqGAEAyhgBAKsYAQDLGAEArBgBAMwYAQCtGAEAzRgBAK4YAQDOGAEArxgBAM8YAQCwGAEA0BgBALEYAQDRGAEAshgBANIYAQCzGAEA0xgBALQYAQDUGAEAtRgBANUYAQC2GAEA1hgBALcYAQDXGAEAuBgBANgYAQC5GAEA2RgBALoYAQDaGAEAuxgBANsYAQC8GAEA3BgBAL0YAQDdGAEAvhgBAN4YAQC/GAEA3xgBAEBuAQBgbgEAQW4BAGFuAQBCbgEAYm4BAENuAQBjbgEARG4BAGRuAQBFbgEAZW4BAEZuAQBmbgEAR24BAGduAQBIbgEAaG4BAEluAQBpbgEASm4BAGpuAQBLbgEAa24BAExuAQBsbgEATW4BAG1uAQBObgEAbm4BAE9uAQBvbgEAUG4BAHBuAQBRbgEAcW4BAFJuAQBybgEAU24BAHNuAQBUbgEAdG4BAFVuAQB1bgEAVm4BAHZuAQBXbgEAd24BAFhuAQB4bgEAWW4BAHluAQBabgEAem4BAFtuAQB7bgEAXG4BAHxuAQBdbgEAfW4BAF5uAQB+bgEAX24BAH9uAQAA6QEAIukBAAHpAQAj6QEAAukBACTpAQAD6QEAJekBAATpAQAm6QEABekBACfpAQAG6QEAKOkBAAfpAQAp6QEACOkBACrpAQAJ6QEAK+kBAArpAQAs6QEAC+kBAC3pAQAM6QEALukBAA3pAQAv6QEADukBADDpAQAP6QEAMekBABDpAQAy6QEAEekBADPpAQAS6QEANOkBABPpAQA16QEAFOkBADbpAQAV6QEAN+kBABbpAQA46QEAF+kBADnpAQAY6QEAOukBABnpAQA76QEAGukBADzpAQAb6QEAPekBABzpAQA+6QEAHekBAD/pAQAe6QEAQOkBAB/pAQBB6QEAIOkBAELpAQAh6QEAQ+kBAAx4IgAOeCIAEHgiAAIAAAACAAAABwBBnu6KAQsa8D8AAAAAAAD4PwAAAAAAAAAABtDPQ+v9TD4AQcPuigELBUADuOI/AEHc7ooBCwYCAAAAyw4AQezuigELMtQOAAACAAAAAAAAANUOAAACAAAAAAAAANYOAAACAAAAAAAAANcOAAACAAAAAAAAANgOAEGo74oBCwEEAIYBCXByb2R1Y2VycwIIbGFuZ3VhZ2UBBFJ1c3QADHByb2Nlc3NlZC1ieQQFcnVzdGMdMS45MC4wICgxMTU5ZTc4YzQgMjAyNS0wOS0xNCkOSG9tZWJyZXcgY2xhbmcGMjAuMS4zBndhbHJ1cwYwLjIzLjMMd2FzbS1iaW5kZ2VuBzAuMi4xMDQAaw90YXJnZXRfZmVhdHVyZXMGKw9tdXRhYmxlLWdsb2JhbHMrE25vbnRyYXBwaW5nLWZwdG9pbnQrC2J1bGstbWVtb3J5KwhzaWduLWV4dCsPcmVmZXJlbmNlLXR5cGVzKwptdWx0aXZhbHVl");var H4="0.7.1",C4=!1;function aW(){C4||(R4(L4),C4=!0,typeof window<"u"&&(window.parquet_wasm={readParquet:Jq,readSchema:Zq,ParquetFile:y7,version:H4}))}async function lo(){return aW(),{readParquet:Jq,readSchema:Zq,ParquetFile:y7,version:H4}}var dr=async t=>{try{let A=await lo(),j=new Uint8Array(t),r=A.readParquet(j).intoIPCStream();return wn(r)}catch(A){let j=Zj(A,{messages:{unexpected:"Failed to convert ArrayBuffer to Arrow Table"},logUnexpected:!0,throwOnAuth:!1});throw new Error(j.message)}};function D4(t){let A=t.schema.fields.map(j=>({name:j.name,data:t.getChild(j.name).toArray()}));return Array.from({length:t.numRows},(j,e)=>Object.fromEntries(A.map(r=>[r.name,r.data[e]])))}function Ab(t){let A=t.schema.fields.map(r=>r.name);(A[0]==="row"||A[0]==="index")&&(A=A.slice(1));let j=A.map(r=>t.getChild(r).toArray()),e=[];for(let r=0;ri[r]);e.push(Array.from(n))}return e}var tb=async(t,A="default",j={})=>{let e=`${t}/cgm/${A}`,[r,n,i,o,l,c]=await Promise.all([fetch(`${e}/meta.json`,j),fetch(`${e}/mat.parquet`,j),fetch(`${e}/row_nodes.parquet`,j),fetch(`${e}/col_nodes.parquet`,j),fetch(`${e}/row_linkage.parquet`,j),fetch(`${e}/col_linkage.parquet`,j)]);if(!r.ok)throw new Error(`Failed to load meta.json: ${r.status}`);let B=await r.json(),[h,d,k,g,E]=await Promise.all([n.arrayBuffer(),i.arrayBuffer(),o.arrayBuffer(),l.arrayBuffer(),c.arrayBuffer()]),m=await dr(h),y=await dr(d),G=await dr(k),v=await dr(g),_=await dr(E),w={...B};return w.mat=Ab(m),w.row_nodes=D4(y),w.col_nodes=D4(G),w.linkage={row:Ab(v),col:Ab(_)},w};function N4(t){let A=t.schema.fields.map(j=>({name:j.name,data:t.getChild(j.name).toArray()}));return Array.from({length:t.numRows},(j,e)=>Object.fromEntries(A.map(r=>[r.name,r.data[e]])))}function jb(t){let A=t.schema.fields.map(r=>r.name);(A[0]==="row"||A[0]==="index")&&(A=A.slice(1));let j=A.map(r=>t.getChild(r).toArray()),e=[];for(let r=0;ri[r]);e.push(Array.from(n))}return e}var K4=async(t,A,j,e,r,n)=>{let i=await dr(A.buffer),o=await dr(j.buffer),l=await dr(e.buffer),c=await dr(r.buffer),B=await dr(n.buffer),h={...t};return h.mat=jb(i),h.row_nodes=N4(o),h.col_nodes=N4(l),h.linkage={row:jb(c),col:jb(B)},h};var jB=async(t,A="__index_level_0__")=>{let j=await dr(t.buffer),e=j.schema.fields.map(l=>l.name);if(e.length<2)return{result:{},attr:[]};if(!e.includes(A))throw new Error(`Key field "${A}" not found in Parquet fields: ${e.join(", ")}`);let r=j.getChild(A).toArray(),n=e.filter(l=>l!==A),i=n.map(l=>j.getChild(l).toArray()),o={};for(let l=0;lB[l])}return{result:o,attr:n}};var rb=new TextEncoder,lW={appstream2:"appstream",cloudhsmv2:"cloudhsm",email:"ses",marketplace:"aws-marketplace",mobile:"AWSMobileHubService",pinpoint:"mobiletargeting",queue:"sqs","git-codecommit":"codecommit","mturk-requester-sandbox":"mturk-requester","personalize-runtime":"personalize"},cW=new Set(["authorization","content-type","content-length","user-agent","presigned-expires","expect","x-amzn-trace-id","range","connection"]),Yo=class{constructor({accessKeyId:A,secretAccessKey:j,sessionToken:e,service:r,region:n,cache:i,retries:o,initRetryMs:l}){if(A==null)throw new TypeError("accessKeyId is a required option");if(j==null)throw new TypeError("secretAccessKey is a required option");this.accessKeyId=A,this.secretAccessKey=j,this.sessionToken=e,this.service=r,this.region=n,this.cache=i||new Map,this.retries=o??10,this.initRetryMs=l||50}async sign(A,j){if(A instanceof Request){let{method:n,url:i,headers:o,body:l}=A;j=Object.assign({method:n,url:i,headers:o},j),j.body==null&&o.has("Content-Type")&&(j.body=l!=null&&o.has("X-Amz-Content-Sha256")?l:await A.clone().arrayBuffer()),A=i}let e=new nb(Object.assign({url:A.toString()},j,this,j&&j.aws)),r=Object.assign({},j,await e.sign());delete r.aws;try{return new Request(r.url.toString(),r)}catch(n){if(n instanceof TypeError)return new Request(r.url.toString(),Object.assign({duplex:"half"},r));throw n}}async fetch(A,j){for(let e=0;e<=this.retries;e++){let r=fetch(await this.sign(A,j));if(e===this.retries)return r;let n=await r;if(n.status<500&&n.status!==429)return n;await new Promise(i=>setTimeout(i,Math.random()*this.initRetryMs*Math.pow(2,e)))}throw new Error("An unknown error occurred, ensure retries is not negative")}},nb=class{constructor({method:A,url:j,headers:e,body:r,accessKeyId:n,secretAccessKey:i,sessionToken:o,service:l,region:c,cache:B,datetime:h,signQuery:d,appendSessionToken:k,allHeaders:g,singleEncode:E}){if(j==null)throw new TypeError("url is a required option");if(n==null)throw new TypeError("accessKeyId is a required option");if(i==null)throw new TypeError("secretAccessKey is a required option");this.method=A||(r?"POST":"GET"),this.url=new URL(j),this.headers=new Headers(e||{}),this.body=r,this.accessKeyId=n,this.secretAccessKey=i,this.sessionToken=o;let m,y;(!l||!c)&&([m,y]=uW(this.url,this.headers)),this.service=l||m||"",this.region=c||y||"us-east-1",this.cache=B||new Map,this.datetime=h||new Date().toISOString().replace(/[:-]|\.\d{3}/g,""),this.signQuery=d,this.appendSessionToken=k||this.service==="iotdevicegateway",this.headers.delete("Host"),this.service==="s3"&&!this.signQuery&&!this.headers.has("X-Amz-Content-Sha256")&&this.headers.set("X-Amz-Content-Sha256","UNSIGNED-PAYLOAD");let G=this.signQuery?this.url.searchParams:this.headers;if(G.set("X-Amz-Date",this.datetime),this.sessionToken&&!this.appendSessionToken&&G.set("X-Amz-Security-Token",this.sessionToken),this.signableHeaders=["host",...this.headers.keys()].filter(_=>g||!cW.has(_)).sort(),this.signedHeaders=this.signableHeaders.join(";"),this.canonicalHeaders=this.signableHeaders.map(_=>_+":"+(_==="host"?this.url.host:(this.headers.get(_)||"").replace(/\s+/g," "))).join(` +`),this.credentialString=[this.datetime.slice(0,8),this.region,this.service,"aws4_request"].join("/"),this.signQuery&&(this.service==="s3"&&!G.has("X-Amz-Expires")&&G.set("X-Amz-Expires","86400"),G.set("X-Amz-Algorithm","AWS4-HMAC-SHA256"),G.set("X-Amz-Credential",this.accessKeyId+"/"+this.credentialString),G.set("X-Amz-SignedHeaders",this.signedHeaders)),this.service==="s3")try{this.encodedPath=decodeURIComponent(this.url.pathname.replace(/\+/g," "))}catch{this.encodedPath=this.url.pathname}else this.encodedPath=this.url.pathname.replace(/\/+/g,"/");E||(this.encodedPath=encodeURIComponent(this.encodedPath).replace(/%2F/g,"/")),this.encodedPath=U4(this.encodedPath);let v=new Set;this.encodedSearch=[...this.url.searchParams].filter(([_])=>{if(!_)return!1;if(this.service==="s3"){if(v.has(_))return!1;v.add(_)}return!0}).map(_=>_.map(w=>U4(encodeURIComponent(w)))).sort(([_,w],[x,O])=>_x?1:wO?1:0).map(_=>_.join("=")).join("&")}async sign(){return this.signQuery?(this.url.searchParams.set("X-Amz-Signature",await this.signature()),this.sessionToken&&this.appendSessionToken&&this.url.searchParams.set("X-Amz-Security-Token",this.sessionToken)):this.headers.set("Authorization",await this.authHeader()),{method:this.method,url:this.url,headers:this.headers,body:this.body}}async authHeader(){return["AWS4-HMAC-SHA256 Credential="+this.accessKeyId+"/"+this.credentialString,"SignedHeaders="+this.signedHeaders,"Signature="+await this.signature()].join(", ")}async signature(){let A=this.datetime.slice(0,8),j=[this.secretAccessKey,A,this.region,this.service].join(),e=this.cache.get(j);if(!e){let r=await bd("AWS4"+this.secretAccessKey,A),n=await bd(r,this.region),i=await bd(n,this.service);e=await bd(i,"aws4_request"),this.cache.set(j,e)}return eb(await bd(e,await this.stringToSign()))}async stringToSign(){return["AWS4-HMAC-SHA256",this.datetime,this.credentialString,eb(await X4(await this.canonicalString()))].join(` `)}async canonicalString(){return[this.method.toUpperCase(),this.encodedPath,this.encodedSearch,this.canonicalHeaders+` `,this.signedHeaders,await this.hexBodyHash()].join(` -`)}async hexBodyHash(){let A=this.headers.get("X-Amz-Content-Sha256")||(this.service==="s3"&&this.signQuery?"UNSIGNED-PAYLOAD":null);if(A==null){if(this.body&&typeof this.body!="string"&&!("byteLength"in this.body))throw new Error("body must be a string, ArrayBuffer or ArrayBufferView, unless you include the X-Amz-Content-Sha256 header");A=Jq(await L4(this.body||""))}return A}};async function _d(t,A){let j=await crypto.subtle.importKey("raw",typeof t=="string"?Zq.encode(t):t,{name:"HMAC",hash:{name:"SHA-256"}},!1,["sign"]);return crypto.subtle.sign("HMAC",j,Zq.encode(A))}async function L4(t){return crypto.subtle.digest("SHA-256",typeof t=="string"?Zq.encode(t):t)}var C4=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];function Jq(t){let A=new Uint8Array(t),j="";for(let e=0;e>>4&15],j+=C4[r&15]}return j}function H4(t){return t.replace(/[!'()*]/g,A=>"%"+A.charCodeAt(0).toString(16).toUpperCase())}function iW(t,A){let{hostname:j,pathname:e}=t;if(j.endsWith(".on.aws")){let o=j.match(/^[^.]{1,63}\.lambda-url\.([^.]{1,63})\.on\.aws$/);return o!=null?["lambda",o[1]||""]:["",""]}if(j.endsWith(".r2.cloudflarestorage.com"))return["s3","auto"];if(j.endsWith(".backblazeb2.com")){let o=j.match(/^(?:[^.]{1,63}\.)?s3\.([^.]{1,63})\.backblazeb2\.com$/);return o!=null?["s3",o[1]||""]:["",""]}let r=j.replace("dualstack.","").match(/([^.]{1,63})\.(?:([^.]{0,63})\.)?amazonaws\.com(?:\.cn)?$/),n=r&&r[1]||"",i=r&&r[2];if(i==="us-gov")i="us-gov-west-1";else if(i==="s3"||i==="s3-accelerate")i="us-east-1",n="s3";else if(n==="iot")j.startsWith("iot.")?n="execute-api":j.startsWith("data.jobs.iot.")?n="iot-jobs-data":n=e==="/mqtt"?"iotdevicegateway":"iotdata";else if(n==="autoscaling"){let o=(A.get("X-Amz-Target")||"").split(".")[0];o==="AnyScaleFrontendService"?n="application-autoscaling":o==="AnyScaleScalingPlannerFrontendService"&&(n="autoscaling-plans")}else i==null&&n.startsWith("s3-")?(i=n.slice(3).replace(/^fips-|^external-1/,""),n="s3"):n.endsWith("-fips")?n=n.slice(0,-5):i&&/-\d$/.test(n)&&!/-\d$/.test(i)&&([n,i]=[i,n]);return[rW[n]||n,i||""]}function Jm(t,A){if(!t)throw new Error(A||"loader assertion failed.")}var Jo={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},oW=Jo.self||Jo.window||Jo.global||{},sW=Jo.window||Jo.self||Jo.global||{},aW=Jo.global||Jo.self||Jo.window||{},lW=Jo.document||{};var qd=!!(typeof process!="object"||String(process)!=="[object process]"||process.browser);var D4=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),cW=D4&&parseFloat(D4[1])||0;var Zm=globalThis,uW=globalThis.document||{},AE=globalThis.process||{},BW=globalThis.console,N4=globalThis.navigator||{};function tE(t){if(typeof window<"u"&&window.process?.type==="renderer"||typeof process<"u"&&process.versions?.electron)return!0;let A=typeof navigator<"u"&&navigator.userAgent,j=t||A;return!!(j&&j.indexOf("Electron")>=0)}function rn(){return!(typeof process=="object"&&String(process)==="[object process]"&&!process?.browser)||tE()}function tG(t){return!t&&!rn()?"Node":tE(t)?"Electron":(t||N4.userAgent||"").indexOf("Edge")>-1?"Edge":globalThis.chrome?"Chrome":globalThis.safari?"Safari":globalThis.mozInnerScreenX?"Firefox":"Unknown"}var jG="4.0.7";function hW(t){try{let A=window[t],j="__storage_test__";return A.setItem(j,j),A.removeItem(j),A}catch{return null}}var jE=class{constructor(A,j,e="sessionStorage"){this.storage=hW(e),this.id=A,this.config=j,this._loadConfiguration()}getConfiguration(){return this.config}setConfiguration(A){if(Object.assign(this.config,A),this.storage){let j=JSON.stringify(this.config);this.storage.setItem(this.id,j)}}_loadConfiguration(){let A={};if(this.storage){let j=this.storage.getItem(this.id);A=j?JSON.parse(j):{}}return Object.assign(this.config,A),this}};function K4(t){let A;return t<10?A=`${t.toFixed(2)}ms`:t<100?A=`${t.toFixed(1)}ms`:t<1e3?A=`${t.toFixed(0)}ms`:A=`${(t/1e3).toFixed(2)}s`,A}function X4(t,A=8){let j=Math.max(A-t.length,0);return`${" ".repeat(j)}${t}`}var eE;(function(t){t[t.BLACK=30]="BLACK",t[t.RED=31]="RED",t[t.GREEN=32]="GREEN",t[t.YELLOW=33]="YELLOW",t[t.BLUE=34]="BLUE",t[t.MAGENTA=35]="MAGENTA",t[t.CYAN=36]="CYAN",t[t.WHITE=37]="WHITE",t[t.BRIGHT_BLACK=90]="BRIGHT_BLACK",t[t.BRIGHT_RED=91]="BRIGHT_RED",t[t.BRIGHT_GREEN=92]="BRIGHT_GREEN",t[t.BRIGHT_YELLOW=93]="BRIGHT_YELLOW",t[t.BRIGHT_BLUE=94]="BRIGHT_BLUE",t[t.BRIGHT_MAGENTA=95]="BRIGHT_MAGENTA",t[t.BRIGHT_CYAN=96]="BRIGHT_CYAN",t[t.BRIGHT_WHITE=97]="BRIGHT_WHITE"})(eE||(eE={}));var dW=10;function z4(t){return typeof t!="string"?t:(t=t.toUpperCase(),eE[t]||eE.WHITE)}function U4(t,A,j){return!rn&&typeof t=="string"&&(A&&(t=`\x1B[${z4(A)}m${t}\x1B[39m`),j&&(t=`\x1B[${z4(j)+dW}m${t}\x1B[49m`)),t}function V4(t,A=["constructor"]){let j=Object.getPrototypeOf(t),e=Object.getOwnPropertyNames(j),r=t;for(let n of e){let i=r[n];typeof i=="function"&&(A.find(o=>n===o)||(r[n]=i.bind(t)))}}function Gd(t,A){if(!t)throw new Error(A||"Assertion failed")}function rc(){let t;if(rn()&&Zm.performance)t=Zm?.performance?.now?.();else if("hrtime"in AE){let A=AE?.hrtime?.();t=A[0]*1e3+A[1]/1e6}else t=Date.now();return t}var eB={debug:rn()&&console.debug||console.log,log:console.log,info:console.info,warn:console.warn,error:console.error},pW={enabled:!0,level:0};function rB(){}var Q4={},W4={once:!0},y6=class{constructor({id:A}={id:""}){this.VERSION=jG,this._startTs=rc(),this._deltaTs=rc(),this.userData={},this.LOG_THROTTLE_TIMEOUT=0,this.id=A,this.userData={},this._storage=new jE(`__probe-${this.id}__`,pW),this.timeStamp(`${this.id} started`),V4(this),Object.seal(this)}set level(A){this.setLevel(A)}get level(){return this.getLevel()}isEnabled(){return this._storage.config.enabled}getLevel(){return this._storage.config.level}getTotal(){return Number((rc()-this._startTs).toPrecision(10))}getDelta(){return Number((rc()-this._deltaTs).toPrecision(10))}set priority(A){this.level=A}get priority(){return this.level}getPriority(){return this.level}enable(A=!0){return this._storage.setConfiguration({enabled:A}),this}setLevel(A){return this._storage.setConfiguration({level:A}),this}get(A){return this._storage.config[A]}set(A,j){this._storage.setConfiguration({[A]:j})}settings(){console.table?console.table(this._storage.config):console.log(this._storage.config)}assert(A,j){if(!A)throw new Error(j||"Assertion failed")}warn(A){return this._getLogFunction(0,A,eB.warn,arguments,W4)}error(A){return this._getLogFunction(0,A,eB.error,arguments)}deprecated(A,j){return this.warn(`\`${A}\` is deprecated and will be removed in a later version. Use \`${j}\` instead`)}removed(A,j){return this.error(`\`${A}\` has been removed. Use \`${j}\` instead`)}probe(A,j){return this._getLogFunction(A,j,eB.log,arguments,{time:!0,once:!0})}log(A,j){return this._getLogFunction(A,j,eB.debug,arguments)}info(A,j){return this._getLogFunction(A,j,console.info,arguments)}once(A,j){return this._getLogFunction(A,j,eB.debug||eB.info,arguments,W4)}table(A,j,e){return j?this._getLogFunction(A,j,console.table||rB,e&&[e],{tag:gW(j)}):rB}time(A,j){return this._getLogFunction(A,j,console.time?console.time:console.info)}timeEnd(A,j){return this._getLogFunction(A,j,console.timeEnd?console.timeEnd:console.info)}timeStamp(A,j){return this._getLogFunction(A,j,console.timeStamp||rB)}group(A,j,e={collapsed:!1}){let r=Y4({logLevel:A,message:j,opts:e}),{collapsed:n}=e;return r.method=(n?console.groupCollapsed:console.group)||console.info,this._getLogFunction(r)}groupCollapsed(A,j,e={}){return this.group(A,j,Object.assign({},e,{collapsed:!0}))}groupEnd(A){return this._getLogFunction(A,"",console.groupEnd||rB)}withGroup(A,j,e){this.group(A,j)();try{e()}finally{this.groupEnd(A)()}}trace(){console.trace&&console.trace()}_shouldLog(A){return this.isEnabled()&&this.getLevel()>=J4(A)}_getLogFunction(A,j,e,r,n){if(this._shouldLog(A)){n=Y4({logLevel:A,message:j,args:r,opts:n}),e=e||n.method,Gd(e),n.total=this.getTotal(),n.delta=this.getDelta(),this._deltaTs=rc();let i=n.tag||n.message;if(n.once&&i)if(!Q4[i])Q4[i]=rc();else return rB;return j=kW(this.id,n.message,n),e.bind(console,j,...n.args)}return rB}};y6.VERSION=jG;function J4(t){if(!t)return 0;let A;switch(typeof t){case"number":A=t;break;case"object":A=t.logLevel||t.priority||0;break;default:return 0}return Gd(Number.isFinite(A)&&A>=0),A}function Y4(t){let{logLevel:A,message:j}=t;t.logLevel=J4(A);let e=t.args?Array.from(t.args):[];for(;e.length&&e.shift()!==j;);switch(typeof A){case"string":case"function":j!==void 0&&e.unshift(j),t.message=A;break;case"object":Object.assign(t,A);break;default:}typeof t.message=="function"&&(t.message=t.message());let r=typeof t.message;return Gd(r==="string"||r==="object"),Object.assign(t,{args:e},t.opts)}function kW(t,A,j){if(typeof A=="string"){let e=j.time?X4(K4(j.total)):"";A=j.time?`${t}: ${e} ${A}`:`${t}: ${A}`,A=U4(A,j.color,j.background)}return A}function gW(t){for(let A in t)for(let j in t[A])return j||"untitled";return"empty"}globalThis.probe={};var gqA=new y6({id:"@probe.gl/log"});var eG="4.3.1",mW=eG[0]>="0"&&eG[0]<="9"?`v${eG}`:"";function EW(){let t=new y6({id:"loaders.gl"});return globalThis.loaders=globalThis.loaders||{},globalThis.loaders.log=t,globalThis.loaders.version=mW,globalThis.probe=globalThis.probe||{},globalThis.probe.loaders=t,t}var rG=EW();function nG(t,A){return Z4(t||{},A)}function Z4(t,A,j=0){if(j>3)return A;let e={...t};for(let[r,n]of Object.entries(A))n&&typeof n=="object"&&!Array.isArray(n)?e[r]=Z4(e[r]||{},A[r],j+1):e[r]=A[r];return e}var AO="latest";function $W(){return globalThis._loadersgl_?.version||(globalThis._loadersgl_=globalThis._loadersgl_||{},globalThis._loadersgl_.version="4.3.1"),globalThis._loadersgl_.version}var iG=$W();function Fn(t,A){if(!t)throw new Error(A||"loaders.gl assertion failed.")}var Zo={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},GqA=Zo.self||Zo.window||Zo.global||{},bqA=Zo.window||Zo.self||Zo.global||{},wqA=Zo.global||Zo.self||Zo.window||{},FqA=Zo.document||{};var gi=typeof process!="object"||String(process)!=="[object process]"||process.browser;var jO=typeof window<"u"&&typeof window.orientation<"u",tO=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),PqA=tO&&parseFloat(tO[1])||0;var bd=class{constructor(A,j){I(this,"name");I(this,"workerThread");I(this,"isRunning",!0);I(this,"result");I(this,"_resolve",()=>{});I(this,"_reject",()=>{});this.name=A,this.workerThread=j,this.result=new Promise((e,r)=>{this._resolve=e,this._reject=r})}postMessage(A,j){this.workerThread.postMessage({source:"loaders.gl",type:A,payload:j})}done(A){Fn(this.isRunning),this.isRunning=!1,this._resolve(A)}error(A){Fn(this.isRunning),this.isRunning=!1,this._reject(A)}};var nB=class{terminate(){}};var oG=new Map;function eO(t){Fn(t.source&&!t.url||!t.source&&t.url);let A=oG.get(t.source||t.url);return A||(t.url&&(A=xW(t.url),oG.set(t.url,A)),t.source&&(A=rO(t.source),oG.set(t.source,A))),Fn(A),A}function xW(t){if(!t.startsWith("http"))return t;let A=yW(t);return rO(A)}function rO(t){let A=new Blob([t],{type:"application/javascript"});return URL.createObjectURL(A)}function yW(t){return`try { +`)}async hexBodyHash(){let A=this.headers.get("X-Amz-Content-Sha256")||(this.service==="s3"&&this.signQuery?"UNSIGNED-PAYLOAD":null);if(A==null){if(this.body&&typeof this.body!="string"&&!("byteLength"in this.body))throw new Error("body must be a string, ArrayBuffer or ArrayBufferView, unless you include the X-Amz-Content-Sha256 header");A=eb(await X4(this.body||""))}return A}};async function bd(t,A){let j=await crypto.subtle.importKey("raw",typeof t=="string"?rb.encode(t):t,{name:"HMAC",hash:{name:"SHA-256"}},!1,["sign"]);return crypto.subtle.sign("HMAC",j,rb.encode(A))}async function X4(t){return crypto.subtle.digest("SHA-256",typeof t=="string"?rb.encode(t):t)}var z4=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];function eb(t){let A=new Uint8Array(t),j="";for(let e=0;e>>4&15],j+=z4[r&15]}return j}function U4(t){return t.replace(/[!'()*]/g,A=>"%"+A.charCodeAt(0).toString(16).toUpperCase())}function uW(t,A){let{hostname:j,pathname:e}=t;if(j.endsWith(".on.aws")){let o=j.match(/^[^.]{1,63}\.lambda-url\.([^.]{1,63})\.on\.aws$/);return o!=null?["lambda",o[1]||""]:["",""]}if(j.endsWith(".r2.cloudflarestorage.com"))return["s3","auto"];if(j.endsWith(".backblazeb2.com")){let o=j.match(/^(?:[^.]{1,63}\.)?s3\.([^.]{1,63})\.backblazeb2\.com$/);return o!=null?["s3",o[1]||""]:["",""]}let r=j.replace("dualstack.","").match(/([^.]{1,63})\.(?:([^.]{0,63})\.)?amazonaws\.com(?:\.cn)?$/),n=r&&r[1]||"",i=r&&r[2];if(i==="us-gov")i="us-gov-west-1";else if(i==="s3"||i==="s3-accelerate")i="us-east-1",n="s3";else if(n==="iot")j.startsWith("iot.")?n="execute-api":j.startsWith("data.jobs.iot.")?n="iot-jobs-data":n=e==="/mqtt"?"iotdevicegateway":"iotdata";else if(n==="autoscaling"){let o=(A.get("X-Amz-Target")||"").split(".")[0];o==="AnyScaleFrontendService"?n="application-autoscaling":o==="AnyScaleScalingPlannerFrontendService"&&(n="autoscaling-plans")}else i==null&&n.startsWith("s3-")?(i=n.slice(3).replace(/^fips-|^external-1/,""),n="s3"):n.endsWith("-fips")?n=n.slice(0,-5):i&&/-\d$/.test(n)&&!/-\d$/.test(i)&&([n,i]=[i,n]);return[lW[n]||n,i||""]}function eE(t,A){if(!t)throw new Error(A||"loader assertion failed.")}var Jo={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},BW=Jo.self||Jo.window||Jo.global||{},fW=Jo.window||Jo.self||Jo.global||{},hW=Jo.global||Jo.self||Jo.window||{},dW=Jo.document||{};var Gd=!!(typeof process!="object"||String(process)!=="[object process]"||process.browser);var V4=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),pW=V4&&parseFloat(V4[1])||0;var rE=globalThis,kW=globalThis.document||{},nE=globalThis.process||{},gW=globalThis.console,Q4=globalThis.navigator||{};function iE(t){if(typeof window<"u"&&window.process?.type==="renderer"||typeof process<"u"&&process.versions?.electron)return!0;let A=typeof navigator<"u"&&navigator.userAgent,j=t||A;return!!(j&&j.indexOf("Electron")>=0)}function rn(){return!(typeof process=="object"&&String(process)==="[object process]"&&!process?.browser)||iE()}function ib(t){return!t&&!rn()?"Node":iE(t)?"Electron":(t||Q4.userAgent||"").indexOf("Edge")>-1?"Edge":globalThis.chrome?"Chrome":globalThis.safari?"Safari":globalThis.mozInnerScreenX?"Firefox":"Unknown"}var ob="4.0.7";function EW(t){try{let A=window[t],j="__storage_test__";return A.setItem(j,j),A.removeItem(j),A}catch{return null}}var oE=class{constructor(A,j,e="sessionStorage"){this.storage=EW(e),this.id=A,this.config=j,this._loadConfiguration()}getConfiguration(){return this.config}setConfiguration(A){if(Object.assign(this.config,A),this.storage){let j=JSON.stringify(this.config);this.storage.setItem(this.id,j)}}_loadConfiguration(){let A={};if(this.storage){let j=this.storage.getItem(this.id);A=j?JSON.parse(j):{}}return Object.assign(this.config,A),this}};function W4(t){let A;return t<10?A=`${t.toFixed(2)}ms`:t<100?A=`${t.toFixed(1)}ms`:t<1e3?A=`${t.toFixed(0)}ms`:A=`${(t/1e3).toFixed(2)}s`,A}function Y4(t,A=8){let j=Math.max(A-t.length,0);return`${" ".repeat(j)}${t}`}var sE;(function(t){t[t.BLACK=30]="BLACK",t[t.RED=31]="RED",t[t.GREEN=32]="GREEN",t[t.YELLOW=33]="YELLOW",t[t.BLUE=34]="BLUE",t[t.MAGENTA=35]="MAGENTA",t[t.CYAN=36]="CYAN",t[t.WHITE=37]="WHITE",t[t.BRIGHT_BLACK=90]="BRIGHT_BLACK",t[t.BRIGHT_RED=91]="BRIGHT_RED",t[t.BRIGHT_GREEN=92]="BRIGHT_GREEN",t[t.BRIGHT_YELLOW=93]="BRIGHT_YELLOW",t[t.BRIGHT_BLUE=94]="BRIGHT_BLUE",t[t.BRIGHT_MAGENTA=95]="BRIGHT_MAGENTA",t[t.BRIGHT_CYAN=96]="BRIGHT_CYAN",t[t.BRIGHT_WHITE=97]="BRIGHT_WHITE"})(sE||(sE={}));var $W=10;function J4(t){return typeof t!="string"?t:(t=t.toUpperCase(),sE[t]||sE.WHITE)}function Z4(t,A,j){return!rn&&typeof t=="string"&&(A&&(t=`\x1B[${J4(A)}m${t}\x1B[39m`),j&&(t=`\x1B[${J4(j)+$W}m${t}\x1B[49m`)),t}function AO(t,A=["constructor"]){let j=Object.getPrototypeOf(t),e=Object.getOwnPropertyNames(j),r=t;for(let n of e){let i=r[n];typeof i=="function"&&(A.find(o=>n===o)||(r[n]=i.bind(t)))}}function wd(t,A){if(!t)throw new Error(A||"Assertion failed")}function nc(){let t;if(rn()&&rE.performance)t=rE?.performance?.now?.();else if("hrtime"in nE){let A=nE?.hrtime?.();t=A[0]*1e3+A[1]/1e6}else t=Date.now();return t}var eB={debug:rn()&&console.debug||console.log,log:console.log,info:console.info,warn:console.warn,error:console.error},xW={enabled:!0,level:0};function rB(){}var tO={},jO={once:!0},y6=class{constructor({id:A}={id:""}){this.VERSION=ob,this._startTs=nc(),this._deltaTs=nc(),this.userData={},this.LOG_THROTTLE_TIMEOUT=0,this.id=A,this.userData={},this._storage=new oE(`__probe-${this.id}__`,xW),this.timeStamp(`${this.id} started`),AO(this),Object.seal(this)}set level(A){this.setLevel(A)}get level(){return this.getLevel()}isEnabled(){return this._storage.config.enabled}getLevel(){return this._storage.config.level}getTotal(){return Number((nc()-this._startTs).toPrecision(10))}getDelta(){return Number((nc()-this._deltaTs).toPrecision(10))}set priority(A){this.level=A}get priority(){return this.level}getPriority(){return this.level}enable(A=!0){return this._storage.setConfiguration({enabled:A}),this}setLevel(A){return this._storage.setConfiguration({level:A}),this}get(A){return this._storage.config[A]}set(A,j){this._storage.setConfiguration({[A]:j})}settings(){console.table?console.table(this._storage.config):console.log(this._storage.config)}assert(A,j){if(!A)throw new Error(j||"Assertion failed")}warn(A){return this._getLogFunction(0,A,eB.warn,arguments,jO)}error(A){return this._getLogFunction(0,A,eB.error,arguments)}deprecated(A,j){return this.warn(`\`${A}\` is deprecated and will be removed in a later version. Use \`${j}\` instead`)}removed(A,j){return this.error(`\`${A}\` has been removed. Use \`${j}\` instead`)}probe(A,j){return this._getLogFunction(A,j,eB.log,arguments,{time:!0,once:!0})}log(A,j){return this._getLogFunction(A,j,eB.debug,arguments)}info(A,j){return this._getLogFunction(A,j,console.info,arguments)}once(A,j){return this._getLogFunction(A,j,eB.debug||eB.info,arguments,jO)}table(A,j,e){return j?this._getLogFunction(A,j,console.table||rB,e&&[e],{tag:vW(j)}):rB}time(A,j){return this._getLogFunction(A,j,console.time?console.time:console.info)}timeEnd(A,j){return this._getLogFunction(A,j,console.timeEnd?console.timeEnd:console.info)}timeStamp(A,j){return this._getLogFunction(A,j,console.timeStamp||rB)}group(A,j,e={collapsed:!1}){let r=eO({logLevel:A,message:j,opts:e}),{collapsed:n}=e;return r.method=(n?console.groupCollapsed:console.group)||console.info,this._getLogFunction(r)}groupCollapsed(A,j,e={}){return this.group(A,j,Object.assign({},e,{collapsed:!0}))}groupEnd(A){return this._getLogFunction(A,"",console.groupEnd||rB)}withGroup(A,j,e){this.group(A,j)();try{e()}finally{this.groupEnd(A)()}}trace(){console.trace&&console.trace()}_shouldLog(A){return this.isEnabled()&&this.getLevel()>=rO(A)}_getLogFunction(A,j,e,r,n){if(this._shouldLog(A)){n=eO({logLevel:A,message:j,args:r,opts:n}),e=e||n.method,wd(e),n.total=this.getTotal(),n.delta=this.getDelta(),this._deltaTs=nc();let i=n.tag||n.message;if(n.once&&i)if(!tO[i])tO[i]=nc();else return rB;return j=yW(this.id,n.message,n),e.bind(console,j,...n.args)}return rB}};y6.VERSION=ob;function rO(t){if(!t)return 0;let A;switch(typeof t){case"number":A=t;break;case"object":A=t.logLevel||t.priority||0;break;default:return 0}return wd(Number.isFinite(A)&&A>=0),A}function eO(t){let{logLevel:A,message:j}=t;t.logLevel=rO(A);let e=t.args?Array.from(t.args):[];for(;e.length&&e.shift()!==j;);switch(typeof A){case"string":case"function":j!==void 0&&e.unshift(j),t.message=A;break;case"object":Object.assign(t,A);break;default:}typeof t.message=="function"&&(t.message=t.message());let r=typeof t.message;return wd(r==="string"||r==="object"),Object.assign(t,{args:e},t.opts)}function yW(t,A,j){if(typeof A=="string"){let e=j.time?Y4(W4(j.total)):"";A=j.time?`${t}: ${e} ${A}`:`${t}: ${A}`,A=Z4(A,j.color,j.background)}return A}function vW(t){for(let A in t)for(let j in t[A])return j||"untitled";return"empty"}globalThis.probe={};var _qA=new y6({id:"@probe.gl/log"});var sb="4.3.1",_W=sb[0]>="0"&&sb[0]<="9"?`v${sb}`:"";function qW(){let t=new y6({id:"loaders.gl"});return globalThis.loaders=globalThis.loaders||{},globalThis.loaders.log=t,globalThis.loaders.version=_W,globalThis.probe=globalThis.probe||{},globalThis.probe.loaders=t,t}var ab=qW();function lb(t,A){return nO(t||{},A)}function nO(t,A,j=0){if(j>3)return A;let e={...t};for(let[r,n]of Object.entries(A))n&&typeof n=="object"&&!Array.isArray(n)?e[r]=nO(e[r]||{},A[r],j+1):e[r]=A[r];return e}var iO="latest";function bW(){return globalThis._loadersgl_?.version||(globalThis._loadersgl_=globalThis._loadersgl_||{},globalThis._loadersgl_.version="4.3.1"),globalThis._loadersgl_.version}var cb=bW();function Fn(t,A){if(!t)throw new Error(A||"loaders.gl assertion failed.")}var Zo={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},OqA=Zo.self||Zo.window||Zo.global||{},TqA=Zo.window||Zo.self||Zo.global||{},SqA=Zo.global||Zo.self||Zo.window||{},RqA=Zo.document||{};var gi=typeof process!="object"||String(process)!=="[object process]"||process.browser;var sO=typeof window<"u"&&typeof window.orientation<"u",oO=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),LqA=oO&&parseFloat(oO[1])||0;var Fd=class{constructor(A,j){I(this,"name");I(this,"workerThread");I(this,"isRunning",!0);I(this,"result");I(this,"_resolve",()=>{});I(this,"_reject",()=>{});this.name=A,this.workerThread=j,this.result=new Promise((e,r)=>{this._resolve=e,this._reject=r})}postMessage(A,j){this.workerThread.postMessage({source:"loaders.gl",type:A,payload:j})}done(A){Fn(this.isRunning),this.isRunning=!1,this._resolve(A)}error(A){Fn(this.isRunning),this.isRunning=!1,this._reject(A)}};var nB=class{terminate(){}};var ub=new Map;function aO(t){Fn(t.source&&!t.url||!t.source&&t.url);let A=ub.get(t.source||t.url);return A||(t.url&&(A=GW(t.url),ub.set(t.url,A)),t.source&&(A=lO(t.source),ub.set(t.source,A))),Fn(A),A}function GW(t){if(!t.startsWith("http"))return t;let A=wW(t);return lO(A)}function lO(t){let A=new Blob([t],{type:"application/javascript"});return URL.createObjectURL(A)}function wW(t){return`try { importScripts('${t}'); } catch (error) { console.error(error); throw error; -}`}function sG(t,A=!0,j){let e=j||new Set;if(t){if(nO(t))e.add(t);else if(nO(t.buffer))e.add(t.buffer);else if(!ArrayBuffer.isView(t)){if(A&&typeof t=="object")for(let r in t)sG(t[r],A,e)}}return j===void 0?Array.from(e):[]}function nO(t){return t?t instanceof ArrayBuffer||typeof MessagePort<"u"&&t instanceof MessagePort||typeof ImageBitmap<"u"&&t instanceof ImageBitmap||typeof OffscreenCanvas<"u"&&t instanceof OffscreenCanvas:!1}var aG=()=>{},v7=class{constructor(A){I(this,"name");I(this,"source");I(this,"url");I(this,"terminated",!1);I(this,"worker");I(this,"onMessage");I(this,"onError");I(this,"_loadableURL","");let{name:j,source:e,url:r}=A;Fn(e||r),this.name=j,this.source=e,this.url=r,this.onMessage=aG,this.onError=n=>console.log(n),this.worker=gi?this._createBrowserWorker():this._createNodeWorker()}static isSupported(){return typeof Worker<"u"&&gi||typeof nB<"u"&&!gi}destroy(){this.onMessage=aG,this.onError=aG,this.worker.terminate(),this.terminated=!0}get isRunning(){return!!this.onMessage}postMessage(A,j){j=j||sG(A),this.worker.postMessage(A,j)}_getErrorFromErrorEvent(A){let j="Failed to load ";return j+=`worker ${this.name} from ${this.url}. `,A.message&&(j+=`${A.message} in `),A.lineno&&(j+=`:${A.lineno}:${A.colno}`),new Error(j)}_createBrowserWorker(){this._loadableURL=eO({source:this.source,url:this.url});let A=new Worker(this._loadableURL,{name:this.name});return A.onmessage=j=>{j.data?this.onMessage(j.data):this.onError(new Error("No data received"))},A.onerror=j=>{this.onError(this._getErrorFromErrorEvent(j)),this.terminated=!0},A.onmessageerror=j=>console.error(j),A}_createNodeWorker(){let A;if(this.url){let e=this.url.includes(":/")||this.url.startsWith("/")?this.url:`./${this.url}`;A=new nB(e,{eval:!1})}else if(this.source)A=new nB(this.source,{eval:!0});else throw new Error("no worker");return A.on("message",j=>{this.onMessage(j)}),A.on("error",j=>{this.onError(j)}),A.on("exit",j=>{}),A}};var wd=class{constructor(A){I(this,"name","unnamed");I(this,"source");I(this,"url");I(this,"maxConcurrency",1);I(this,"maxMobileConcurrency",1);I(this,"onDebug",()=>{});I(this,"reuseWorkers",!0);I(this,"props",{});I(this,"jobQueue",[]);I(this,"idleQueue",[]);I(this,"count",0);I(this,"isDestroyed",!1);this.source=A.source,this.url=A.url,this.setProps(A)}static isSupported(){return v7.isSupported()}destroy(){this.idleQueue.forEach(A=>A.destroy()),this.isDestroyed=!0}setProps(A){this.props={...this.props,...A},A.name!==void 0&&(this.name=A.name),A.maxConcurrency!==void 0&&(this.maxConcurrency=A.maxConcurrency),A.maxMobileConcurrency!==void 0&&(this.maxMobileConcurrency=A.maxMobileConcurrency),A.reuseWorkers!==void 0&&(this.reuseWorkers=A.reuseWorkers),A.onDebug!==void 0&&(this.onDebug=A.onDebug)}async startJob(A,j=(r,n,i)=>r.done(i),e=(r,n)=>r.error(n)){let r=new Promise(n=>(this.jobQueue.push({name:A,onMessage:j,onError:e,onStart:n}),this));return this._startQueuedJob(),await r}async _startQueuedJob(){if(!this.jobQueue.length)return;let A=this._getAvailableWorker();if(!A)return;let j=this.jobQueue.shift();if(j){this.onDebug({message:"Starting job",name:j.name,workerThread:A,backlog:this.jobQueue.length});let e=new bd(j.name,A);A.onMessage=r=>j.onMessage(e,r.type,r.payload),A.onError=r=>j.onError(e,r),j.onStart(e);try{await e.result}catch(r){console.error(`Worker exception: ${r}`)}finally{this.returnWorkerToQueue(A)}}}returnWorkerToQueue(A){!gi||this.isDestroyed||!this.reuseWorkers||this.count>this._getMaxConcurrency()?(A.destroy(),this.count--):this.idleQueue.push(A),this.isDestroyed||this._startQueuedJob()}_getAvailableWorker(){if(this.idleQueue.length>0)return this.idleQueue.shift()||null;if(this.count{}},_7=class _7{constructor(A){I(this,"props");I(this,"workerPools",new Map);this.props={...vW},this.setProps(A),this.workerPools=new Map}static isSupported(){return v7.isSupported()}static getWorkerFarm(A={}){return _7._workerFarm=_7._workerFarm||new _7({}),_7._workerFarm.setProps(A),_7._workerFarm}destroy(){for(let A of this.workerPools.values())A.destroy();this.workerPools=new Map}setProps(A){this.props={...this.props,...A};for(let j of this.workerPools.values())j.setProps(this._getWorkerPoolProps())}getWorkerPool(A){let{name:j,source:e,url:r}=A,n=this.workerPools.get(j);return n||(n=new wd({name:j,source:e,url:r}),n.setProps(this._getWorkerPoolProps()),this.workerPools.set(j,n)),n}_getWorkerPoolProps(){return{maxConcurrency:this.props.maxConcurrency,maxMobileConcurrency:this.props.maxMobileConcurrency,reuseWorkers:this.props.reuseWorkers,onDebug:this.props.onDebug}}};I(_7,"_workerFarm");var nc=_7;function lG(t,A={}){let j=A[t.id]||{},e=gi?`${t.id}-worker.js`:`${t.id}-worker-node.js`,r=j.workerUrl;if(!r&&t.id==="compression"&&(r=A.workerUrl),A._workerType==="test"&&(gi?r=`modules/${t.module}/dist/${e}`:r=`modules/${t.module}/src/workers/${t.id}-worker-node.ts`),!r){let n=t.version;n==="latest"&&(n=AO);let i=n?`@${n}`:"";r=`https://unpkg.com/@loaders.gl/${t.module}${i}/dist/${e}`}return Fn(r),r}function cG(t,A=iG){Fn(t,"no worker provided");let j=t.version;return!(!A||!j)}function uG(t,A){return!nc.isSupported()||!gi&&!A?._nodeWorkers?!1:t.worker&&A?.worker}async function BG(t,A,j,e,r){let n=t.id,i=lG(t,j),l=nc.getWorkerFarm(j).getWorkerPool({name:n,url:i});j=JSON.parse(JSON.stringify(j)),e=JSON.parse(JSON.stringify(e||{}));let c=await l.startJob("process-on-worker",_W.bind(null,r));return c.postMessage("process",{input:A,options:j,context:e}),await(await c.result).result}async function _W(t,A,j,e){switch(j){case"done":A.done(e);break;case"error":A.error(new Error(e.error));break;case"process":let{id:r,input:n,options:i}=e;try{let o=await t(n,i);A.postMessage("done",{id:r,result:o})}catch(o){let l=o instanceof Error?o.message:"unknown error";A.postMessage("error",{id:r,error:l})}break;default:console.warn(`parse-with-worker unknown message ${j}`)}}function fG(t,A,j){if(j=j||t.byteLength,t.byteLengthn instanceof ArrayBuffer?new Uint8Array(n):n),j=A.reduce((n,i)=>n+i.byteLength,0),e=new Uint8Array(j),r=0;for(let n of A)e.set(n,r),r+=n.byteLength;return e.buffer}async function dG(t){let A=[];for await(let j of t)A.push(j);return hG(...A)}function Fd(){let t;if(typeof window<"u"&&window.performance)t=window.performance.now();else if(typeof process<"u"&&process.hrtime){let A=process.hrtime();t=A[0]*1e3+A[1]/1e6}else t=Date.now();return t}var ic=class{constructor(A,j){this.sampleSize=1,this.time=0,this.count=0,this.samples=0,this.lastTiming=0,this.lastSampleTime=0,this.lastSampleCount=0,this._count=0,this._time=0,this._samples=0,this._startTime=0,this._timerPending=!1,this.name=A,this.type=j,this.reset()}reset(){return this.time=0,this.count=0,this.samples=0,this.lastTiming=0,this.lastSampleTime=0,this.lastSampleCount=0,this._count=0,this._time=0,this._samples=0,this._startTime=0,this._timerPending=!1,this}setSampleSize(A){return this.sampleSize=A,this}incrementCount(){return this.addCount(1),this}decrementCount(){return this.subtractCount(1),this}addCount(A){return this._count+=A,this._samples++,this._checkSampling(),this}subtractCount(A){return this._count-=A,this._samples++,this._checkSampling(),this}addTime(A){return this._time+=A,this.lastTiming=A,this._samples++,this._checkSampling(),this}timeStart(){return this._startTime=Fd(),this._timerPending=!0,this}timeEnd(){return this._timerPending?(this.addTime(Fd()-this._startTime),this._timerPending=!1,this._checkSampling(),this):this}getSampleAverageCount(){return this.sampleSize>0?this.lastSampleCount/this.sampleSize:0}getSampleAverageTime(){return this.sampleSize>0?this.lastSampleTime/this.sampleSize:0}getSampleHz(){return this.lastSampleTime>0?this.sampleSize/(this.lastSampleTime/1e3):0}getAverageCount(){return this.samples>0?this.count/this.samples:0}getAverageTime(){return this.samples>0?this.time/this.samples:0}getHz(){return this.time>0?this.samples/(this.time/1e3):0}_checkSampling(){this._samples===this.sampleSize&&(this.lastSampleTime=this._time,this.lastSampleCount=this._count,this.count+=this._count,this.time+=this._time,this.samples+=this._samples,this._time=0,this._count=0,this._samples=0)}};var v6=class{constructor(A){this.stats={},this.id=A.id,this.stats={},this._initializeStats(A.stats),Object.seal(this)}get(A,j="count"){return this._getOrCreate({name:A,type:j})}get size(){return Object.keys(this.stats).length}reset(){for(let A of Object.values(this.stats))A.reset();return this}forEach(A){for(let j of Object.values(this.stats))A(j)}getTable(){let A={};return this.forEach(j=>{A[j.name]={time:j.time||0,count:j.count||0,average:j.getAverageTime()||0,hz:j.getHz()||0}}),A}_initializeStats(A=[]){A.forEach(j=>this._getOrCreate(j))}_getOrCreate(A){let{name:j,type:e}=A,r=this.stats[j];return r||(A instanceof ic?r=A:r=new ic(j,e),this.stats[j]=r),r}};var qW="",oO={};function pG(t){for(let A in oO)if(t.startsWith(A)){let j=oO[A];t=t.replace(A,j)}return!t.startsWith("http://")&&!t.startsWith("https://")&&(t=`${qW}${t}`),t}function sO(t){return t&&typeof t=="object"&&t.isBuffer}function rE(t){if(sO(t))return t;if(t instanceof ArrayBuffer)return t;if(ArrayBuffer.isView(t))return t.byteOffset===0&&t.byteLength===t.buffer.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength);if(typeof t=="string"){let A=t;return new TextEncoder().encode(A).buffer}if(t&&typeof t=="object"&&t._toArrayBuffer)return t._toArrayBuffer();throw new Error("toArrayBuffer")}var oc={};fr(oc,{dirname:()=>bW,filename:()=>GW,join:()=>wW,resolve:()=>FW});function aO(){if(typeof process<"u"&&typeof process.cwd<"u")return process.cwd();let t=window.location?.pathname;return t?.slice(0,t.lastIndexOf("/")+1)||""}function GW(t){let A=t?t.lastIndexOf("/"):-1;return A>=0?t.substr(A+1):""}function bW(t){let A=t?t.lastIndexOf("/"):-1;return A>=0?t.substr(0,A):""}function wW(...t){let A="/";return t=t.map((j,e)=>(e&&(j=j.replace(new RegExp(`^${A}`),"")),e!==t.length-1&&(j=j.replace(new RegExp(`${A}$`),"")),j)),t.join(A)}function FW(...t){let A=[];for(let n=0;n=-1&&!e;n--){let i;n>=0?i=A[n]:(r===void 0&&(r=aO()),i=r),i.length!==0&&(j=`${i}/${j}`,e=i.charCodeAt(0)===Pd)}return j=PW(j,!e),e?`/${j}`:j.length>0?j:"."}var Pd=47,kG=46;function PW(t,A){let j="",e=-1,r=0,n,i=!1;for(let o=0;o<=t.length;++o){if(o2){let l=j.length-1,c=l;for(;c>=0&&j.charCodeAt(c)!==Pd;--c);if(c!==l){j=c===-1?"":j.slice(0,c),e=o,r=0,i=!1;continue}}else if(j.length===2||j.length===1){j="",e=o,r=0,i=!1;continue}}A&&(j.length>0?j+="/..":j="..",i=!0)}else{let l=t.slice(e+1,o);j.length>0?j+=`/${l}`:j=l,i=!1}e=o,r=0}else n===kG&&r!==-1?++r:r=-1}return j}var IW=t=>typeof t=="boolean",Id=t=>typeof t=="function",sc=t=>t!==null&&typeof t=="object",gG=t=>sc(t)&&t.constructor==={}.constructor;var lO=t=>!!t&&typeof t[Symbol.iterator]=="function",cO=t=>t&&typeof t[Symbol.asyncIterator]=="function";var mi=t=>typeof Response<"u"&&t instanceof Response||t&&t.arrayBuffer&&t.text&&t.json;var Ei=t=>typeof Blob<"u"&&t instanceof Blob,uO=t=>t&&typeof t=="object"&&t.isBuffer;var MW=t=>typeof ReadableStream<"u"&&t instanceof ReadableStream||sc(t)&&Id(t.tee)&&Id(t.cancel)&&Id(t.getReader);var OW=t=>sc(t)&&Id(t.read)&&Id(t.pipe)&&IW(t.readable),nE=t=>MW(t)||OW(t);var iE=class extends Error{constructor(j,e){super(j);I(this,"reason");I(this,"url");I(this,"response");this.reason=e.reason,this.url=e.url,this.response=e.response}};var TW=/^data:([-\w.]+\/[-\w.+]+)(;|,)/,SW=/^([-\w.]+\/[-\w.+]+)/;function mG(t,A){return t.toLowerCase()===A.toLowerCase()}function BO(t){let A=SW.exec(t);return A?A[1]:t}function EG(t){let A=TW.exec(t);return A?A[1]:""}var fO=/\?.*/;function hO(t){let A=t.match(fO);return A&&A[0]}function iB(t){return t.replace(fO,"")}function dO(t){if(t.length<50)return t;let A=t.slice(t.length-15);return`${t.substr(0,32)}...${A}`}function ac(t){return mi(t)?t.url:Ei(t)?t.name||"":typeof t=="string"?t:""}function Md(t){if(mi(t)){let A=t,j=A.headers.get("content-type")||"",e=iB(A.url);return BO(j)||EG(e)}return Ei(t)?t.type||"":typeof t=="string"?EG(t):""}function pO(t){return mi(t)?t.headers["content-length"]||-1:Ei(t)?t.size:typeof t=="string"?t.length:t instanceof ArrayBuffer||ArrayBuffer.isView(t)?t.byteLength:-1}async function oE(t){if(mi(t))return t;let A={},j=pO(t);j>=0&&(A["content-length"]=String(j));let e=ac(t),r=Md(t);r&&(A["content-type"]=r);let n=await LW(t);n&&(A["x-first-bytes"]=n),typeof t=="string"&&(t=new TextEncoder().encode(t));let i=new Response(t,{headers:A});return Object.defineProperty(i,"url",{value:e}),i}async function kO(t){if(!t.ok)throw await RW(t)}async function RW(t){let A=dO(t.url),j=`Failed to fetch resource (${t.status}) ${t.statusText}: ${A}`;j=j.length>100?`${j.slice(0,100)}...`:j;let e={reason:t.statusText,url:t.url,response:t};try{let r=t.headers.get("Content-Type");e.reason=!t.bodyUsed&&r?.includes("application/json")?await t.json():await t.text()}catch{}return new iE(j,e)}async function LW(t){if(typeof t=="string")return`data:,${t.slice(0,5)}`;if(t instanceof Blob){let j=t.slice(0,5);return await new Promise(e=>{let r=new FileReader;r.onload=n=>e(n?.target?.result),r.readAsDataURL(j)})}if(t instanceof ArrayBuffer){let j=t.slice(0,5);return`data:base64,${CW(j)}`}return null}function CW(t){let A="",j=new Uint8Array(t);for(let e=0;e{}}info(){return()=>{}}warn(){return()=>{}}error(){return()=>{}}},aE=class{constructor(){I(this,"console");this.console=console}log(...A){return this.console.log.bind(this.console,...A)}info(...A){return this.console.info.bind(this.console,...A)}warn(...A){return this.console.warn.bind(this.console,...A)}error(...A){return this.console.error.bind(this.console,...A)}};var yG={fetch:null,mimeType:void 0,nothrow:!1,log:new aE,useLocalLibraries:!1,CDN:"https://unpkg.com/@loaders.gl",worker:!0,maxConcurrency:3,maxMobileConcurrency:1,reuseWorkers:qd,_nodeWorkers:!1,_workerType:"",limit:0,_limitMB:0,batchSize:"auto",batchDebounceMs:0,metadata:!1,transforms:[]},gO={throws:"nothrow",dataType:"(no longer used)",uri:"baseUri",method:"fetch.method",headers:"fetch.headers",body:"fetch.body",mode:"fetch.mode",credentials:"fetch.credentials",cache:"fetch.cache",redirect:"fetch.redirect",referrer:"fetch.referrer",referrerPolicy:"fetch.referrerPolicy",integrity:"fetch.integrity",keepalive:"fetch.keepalive",signal:"fetch.signal"};function vG(){globalThis.loaders=globalThis.loaders||{};let{loaders:t}=globalThis;return t._state||(t._state={}),t._state}function _G(){let t=vG();return t.globalOptions=t.globalOptions||{...yG},t.globalOptions}function $O(t,A,j,e){return j=j||[],j=Array.isArray(j)?j:[j],KW(t,j),zW(A,t,e)}function KW(t,A){mO(t,null,yG,gO,A);for(let j of A){let e=t&&t[j.id]||{},r=j.options&&j.options[j.id]||{},n=j.deprecatedOptions&&j.deprecatedOptions[j.id]||{};mO(e,j.id,r,n,A)}}function mO(t,A,j,e,r){let n=A||"Top level",i=A?`${A}.`:"";for(let o in t){let l=!A&&sc(t[o]),c=o==="baseUri"&&!A,B=o==="workerUrl"&&A;if(!(o in j)&&!c&&!B){if(o in e)xG.warn(`${n} loader option '${i}${o}' no longer supported, use '${e[o]}'`)();else if(!l){let h=XW(o,r);xG.warn(`${n} loader option '${i}${o}' not recognized. ${h}`)()}}}}function XW(t,A){let j=t.toLowerCase(),e="";for(let r of A)for(let n in r.options){if(t===n)return`Did you mean '${r.id}.${n}'?`;let i=n.toLowerCase();(j.startsWith(i)||i.startsWith(j))&&(e=e||`Did you mean '${r.id}.${n}'?`)}return e}function zW(t,A,j){let r={...t.options||{}};return UW(r,j),r.log===null&&(r.log=new sE),EO(r,_G()),EO(r,A),r}function EO(t,A){for(let j in A)if(j in A){let e=A[j];gG(e)&&gG(t[j])?t[j]={...t[j],...A[j]}:t[j]=A[j]}}function UW(t,A){A&&!("baseUri"in t)&&(t.baseUri=A)}function Od(t){return t?(Array.isArray(t)&&(t=t[0]),Array.isArray(t?.extensions)):!1}function Td(t){Jm(t,"null loader"),Jm(Od(t),"invalid loader");let A;return Array.isArray(t)&&(A=t[1],t=t[0],t={...t,options:{...t.options,...A}}),(t?.parseTextSync||t?.parseText)&&(t.text=!0),t.text||(t.binary=!0),t}var xO=()=>{let t=vG();return t.loaderRegistry=t.loaderRegistry||[],t.loaderRegistry};function qG(t){let A=xO();t=Array.isArray(t)?t:[t];for(let j of t){let e=Td(j);A.find(r=>e===r)||A.unshift(e)}}function yO(){return xO()}var VW=/\.([^.]+)$/;async function qO(t,A=[],j,e){if(!GO(t))return null;let r=vO(t,A,{...j,nothrow:!0},e);if(r)return r;if(Ei(t)&&(t=await t.slice(0,10).arrayBuffer(),r=vO(t,A,j,e)),!r&&!j?.nothrow)throw new Error(bO(t));return r}function vO(t,A=[],j,e){if(!GO(t))return null;if(A&&!Array.isArray(A))return Td(A);let r=[];A&&(r=r.concat(A)),j?.ignoreRegisteredLoaders||r.push(...yO()),WW(r);let n=QW(t,r,j,e);if(!n&&!j?.nothrow)throw new Error(bO(t));return n}function QW(t,A,j,e){let r=ac(t),n=Md(t),i=iB(r)||e?.url,o=null,l="";return j?.mimeType&&(o=GG(A,j?.mimeType),l=`match forced by supplied MIME type ${j?.mimeType}`),o=o||YW(A,i),l=l||(o?`matched url ${i}`:""),o=o||GG(A,n),l=l||(o?`matched MIME type ${n}`:""),o=o||ZW(A,t),l=l||(o?`matched initial data ${wO(t)}`:""),j?.fallbackMimeType&&(o=o||GG(A,j?.fallbackMimeType),l=l||(o?`matched fallback MIME type ${n}`:"")),l&&rG.log(1,`selectLoader selected ${o?.name}: ${l}.`),o}function GO(t){return!(t instanceof Response&&t.status===204)}function bO(t){let A=ac(t),j=Md(t),e="No valid loader found (";e+=A?`${oc.filename(A)}, `:"no url provided, ",e+=`MIME type: ${j?`"${j}"`:"not provided"}, `;let r=t?wO(t):"";return e+=r?` first bytes: "${r}"`:"first bytes: not available",e+=")",e}function WW(t){for(let A of t)Td(A)}function YW(t,A){let j=A&&VW.exec(A),e=j&&j[1];return e?JW(t,e):null}function JW(t,A){A=A.toLowerCase();for(let j of t)for(let e of j.extensions)if(e.toLowerCase()===A)return j;return null}function GG(t,A){for(let j of t)if(j.mimeTypes?.some(e=>mG(A,e))||mG(A,`application/x.${j.id}`))return j;return null}function ZW(t,A){if(!A)return null;for(let j of t)if(typeof A=="string"){if(AY(A,j))return j}else if(ArrayBuffer.isView(A)){if(_O(A.buffer,A.byteOffset,j))return j}else if(A instanceof ArrayBuffer&&_O(A,0,j))return j;return null}function AY(t,A){return A.testText?A.testText(t):(Array.isArray(A.tests)?A.tests:[A.tests]).some(e=>t.startsWith(e))}function _O(t,A,j){return(Array.isArray(j.tests)?j.tests:[j.tests]).some(r=>tY(t,A,j,r))}function tY(t,A,j,e){if(e instanceof ArrayBuffer)return fG(e,t,e.byteLength);switch(typeof e){case"function":return e(t);case"string":let r=bG(t,A,e.length);return e===r;default:return!1}}function wO(t,A=5){return typeof t=="string"?t.slice(0,A):ArrayBuffer.isView(t)?bG(t.buffer,t.byteOffset,A):t instanceof ArrayBuffer?bG(t,0,A):""}function bG(t,A,j){if(t.byteLength$G(r,e.fetch):A?.fetch?A?.fetch:$G}function SO(t,A,j){if(j)return j;let e={fetch:lE(A,t),...t};if(e.url){let r=iB(e.url);e.baseUrl=r,e.queryString=hO(e.url),e.filename=oc.filename(r),e.baseUrl=oc.dirname(r)}return Array.isArray(e.loaders)||(e.loaders=null),e}function RO(t,A){if(t&&!Array.isArray(t))return t;let j;if(t&&(j=Array.isArray(t)?t:[t]),A&&A.loaders){let e=Array.isArray(A.loaders)?A.loaders:[A.loaders];j=j?[...j,...e]:e}return j&&j.length?j:void 0}async function Sd(t,A,j,e){A&&!Array.isArray(A)&&!Od(A)&&(e=void 0,j=A,A=void 0),t=await t,j=j||{};let r=ac(t),i=RO(A,e),o=await qO(t,i,j);return o?(j=$O(j,o,i,r),e=SO({url:r,_parse:Sd,loaders:i},j,e||null),await nY(o,t,j,e)):null}async function nY(t,A,j,e){if(cG(t),j=nG(t.options,j),mi(A)){let n=A,{ok:i,redirected:o,status:l,statusText:c,type:B,url:h}=n,d=Object.fromEntries(n.headers.entries());e.response={headers:d,ok:i,redirected:o,status:l,statusText:c,type:B,url:h}}A=await TO(A,t,j);let r=t;if(r.parseTextSync&&typeof A=="string")return r.parseTextSync(A,j,e);if(uG(t,j))return await BG(t,A,j,e,Sd);if(r.parseText&&typeof A=="string")return await r.parseText(A,j,e);if(r.parse)return await r.parse(A,j,e);throw Fn(!r.parseSync),new Error(`${t.id} loader - no parser found and worker is disabled`)}async function As(t,A,j,e){let r,n;!Array.isArray(A)&&!Od(A)?(r=[],n=A,e=void 0):(r=A,n=j);let i=lE(n),o=t;return typeof t=="string"&&(o=await i(t)),Ei(t)&&(o=await i(t)),Array.isArray(r)?await Sd(o,r,n):await Sd(o,r,n)}var LO="4.2.0";function Rd(t,A){if(!t)throw new Error(A||"loader assertion failed.")}var ts={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},iY=ts.self||ts.window||ts.global||{},oY=ts.window||ts.self||ts.global||{},sY=ts.global||ts.self||ts.window||{},aY=ts.document||{};var FG=!!(typeof process!="object"||String(process)!=="[object process]"||process.browser);var CO=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),lY=CO&&parseFloat(CO[1])||0;var cY="Queued Requests",uY="Active Requests",BY="Cancelled Requests",fY="Queued Requests Ever",hY="Active Requests Ever",dY={id:"request-scheduler",throttleRequests:!0,maxRequests:6,debounceTime:0},oB=class{constructor(A={}){I(this,"props");I(this,"stats");I(this,"activeRequestCount",0);I(this,"requestQueue",[]);I(this,"requestMap",new Map);I(this,"updateTimer",null);this.props={...dY,...A},this.stats=new v6({id:this.props.id}),this.stats.get(cY),this.stats.get(uY),this.stats.get(BY),this.stats.get(fY),this.stats.get(hY)}scheduleRequest(A,j=()=>0){if(!this.props.throttleRequests)return Promise.resolve({done:()=>{}});if(this.requestMap.has(A))return this.requestMap.get(A);let e={handle:A,priority:0,getPriority:j},r=new Promise(n=>(e.resolve=n,e));return this.requestQueue.push(e),this.requestMap.set(A,r),this._issueNewRequests(),r}_issueRequest(A){let{handle:j,resolve:e}=A,r=!1,n=()=>{r||(r=!0,this.requestMap.delete(j),this.activeRequestCount--,this._issueNewRequests())};return this.activeRequestCount++,e?e({done:n}):Promise.resolve({done:n})}_issueNewRequests(){this.updateTimer!==null&&clearTimeout(this.updateTimer),this.updateTimer=setTimeout(()=>this._issueNewRequestsAsync(),this.props.debounceTime)}_issueNewRequestsAsync(){this.updateTimer!==null&&clearTimeout(this.updateTimer),this.updateTimer=null;let A=Math.max(this.props.maxRequests-this.activeRequestCount,0);if(A!==0){this._updateAllRequests();for(let j=0;jj.priority-e.priority)}_updateRequest(A){return A.priority=A.getPriority(A.handle),A.priority<0?(A.resolve(null),!1):!0}};var pY=globalThis.loaders?.parseImageNode,PG=typeof Image<"u",IG=typeof ImageBitmap<"u",kY=!!pY,MG=FG?!0:kY;function HO(t){switch(t){case"auto":return IG||PG||MG;case"imagebitmap":return IG;case"image":return PG;case"data":return MG;default:throw new Error(`@loaders.gl/images: image ${t} not supported in this environment`)}}function DO(){if(IG)return"imagebitmap";if(PG)return"image";if(MG)return"data";throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js")}function gY(t){let A=mY(t);if(!A)throw new Error("Not an image");return A}function NO(t){switch(gY(t)){case"data":return t;case"image":case"imagebitmap":let A=document.createElement("canvas"),j=A.getContext("2d");if(!j)throw new Error("getImageData");return A.width=t.width,A.height=t.height,j.drawImage(t,0,0),j.getImageData(0,0,t.width,t.height);default:throw new Error("getImageData")}}function mY(t){return typeof ImageBitmap<"u"&&t instanceof ImageBitmap?"imagebitmap":typeof Image<"u"&&t instanceof Image?"image":t&&typeof t=="object"&&t.data&&t.width&&t.height?"data":null}var EY=/^data:image\/svg\+xml/,$Y=/\.svg((\?|#).*)?$/;function cE(t){return t&&(EY.test(t)||$Y.test(t))}function KO(t,A){if(cE(A)){let e=new TextDecoder().decode(t);try{typeof unescape=="function"&&typeof encodeURIComponent=="function"&&(e=unescape(encodeURIComponent(e)))}catch(n){throw new Error(n.message)}return`data:image/svg+xml;base64,${btoa(e)}`}return OG(t,A)}function OG(t,A){if(cE(A))throw new Error("SVG cannot be parsed directly to imagebitmap");return new Blob([new Uint8Array(t)])}async function uE(t,A,j){let e=KO(t,j),r=self.URL||self.webkitURL,n=typeof e!="string"&&r.createObjectURL(e);try{return await xY(n||e,A)}finally{n&&r.revokeObjectURL(n)}}async function xY(t,A){let j=new Image;return j.src=t,A.image&&A.image.decode&&j.decode?(await j.decode(),j):await new Promise((e,r)=>{try{j.onload=()=>e(j),j.onerror=n=>{let i=n instanceof Error?n.message:"error";r(new Error(i))}}catch(n){r(n)}})}var yY={},XO=!0;async function zO(t,A,j){let e;cE(j)?e=await uE(t,A,j):e=OG(t,j);let r=A&&A.imagebitmap;return await vY(e,r)}async function vY(t,A=null){if((_Y(A)||!XO)&&(A=null),A)try{return await createImageBitmap(t,A)}catch(j){console.warn(j),XO=!1}return await createImageBitmap(t)}function _Y(t){for(let A in t||yY)return!1;return!0}function UO(t){return!wY(t,"ftyp",4)||!(t[8]&96)?null:qY(t)}function qY(t){switch(GY(t,8,12).replace("\0"," ").trim()){case"avif":case"avis":return{extension:"avif",mimeType:"image/avif"};default:return null}}function GY(t,A,j){return String.fromCharCode(...t.slice(A,j))}function bY(t){return[...t].map(A=>A.charCodeAt(0))}function wY(t,A,j=0){let e=bY(A);for(let r=0;r=24&&A.getUint32(0,js)===2303741511?{mimeType:"image/png",width:A.getUint32(16,js),height:A.getUint32(20,js)}:null}function IY(t){let A=Cd(t);return A.byteLength>=10&&A.getUint32(0,js)===1195984440?{mimeType:"image/gif",width:A.getUint16(6,Ld),height:A.getUint16(8,Ld)}:null}function MY(t){let A=Cd(t);return A.byteLength>=14&&A.getUint16(0,js)===16973&&A.getUint32(2,Ld)===A.byteLength?{mimeType:"image/bmp",width:A.getUint32(18,Ld),height:A.getUint32(22,Ld)}:null}function OY(t){let A=Cd(t);if(!(A.byteLength>=3&&A.getUint16(0,js)===65496&&A.getUint8(2)===255))return null;let{tableMarkers:e,sofMarkers:r}=TY(),n=2;for(;n+9!!BE(new DataView(t))],options:CY};var HY=new y6({id:"deck"}),NA=HY;var TG={};function WO(t){TG=t}function he(t,A,j,e){NA.level>0&&TG[t]&&TG[t].call(null,A,j,e)}function DY(t){let A=t[0],j=t[t.length-1];return A==="{"&&j==="}"||A==="["&&j==="]"}var YO={dataType:null,batchType:null,id:"JSON",name:"JSON",module:"",version:"",options:{},extensions:["json","geojson"],mimeTypes:["application/json","application/geo+json"],testText:DY,parseTextSync:JSON.parse};function NY(){let t="9.0.35",A=globalThis.deck&&globalThis.deck.VERSION;if(A&&A!==t)throw new Error(`deck.gl - multiple versions detected: ${A} vs ${t}`);return A||(NA.log(1,`deck.gl ${t}`)(),globalThis.deck={...globalThis.deck,VERSION:t,version:t,log:NA,_registerLoggers:WO},qG([YO,[Hd,{imagebitmap:{premultiplyAlpha:"none"}}]])),t}var SG=NY();function es(t,A){if(!t)throw new Error(A||"shadertools: assertion failed.")}var RG={number:{type:"number",validate(t,A){return Number.isFinite(t)&&typeof A=="object"&&(A.max===void 0||t<=A.max)&&(A.min===void 0||t>=A.min)}},array:{type:"array",validate(t,A){return Array.isArray(t)||ArrayBuffer.isView(t)}}};function ZO(t){let A={};for(let[j,e]of Object.entries(t))A[j]=KY(e);return A}function AT(t,A,j){let e={};for(let[r,n]of Object.entries(A))t&&r in t&&!n.private?(n.validate&&es(n.validate(t[r],n),`${j}: invalid ${r}`),e[r]=t[r]):e[r]=n.value;return e}function KY(t){let A=JO(t);if(A!=="object")return{value:t,...RG[A],type:A};if(typeof t=="object")return t?t.type!==void 0?{...t,...RG[t.type],type:t.type}:t.value===void 0?{type:"object",value:t}:(A=JO(t.value),{...t,...RG[A],type:A}):{type:"object",value:null};throw new Error("props")}function JO(t){return Array.isArray(t)||ArrayBuffer.isView(t)?"array":typeof t}var tT=`#ifdef MODULE_LOGDEPTH +}`}function Bb(t,A=!0,j){let e=j||new Set;if(t){if(cO(t))e.add(t);else if(cO(t.buffer))e.add(t.buffer);else if(!ArrayBuffer.isView(t)){if(A&&typeof t=="object")for(let r in t)Bb(t[r],A,e)}}return j===void 0?Array.from(e):[]}function cO(t){return t?t instanceof ArrayBuffer||typeof MessagePort<"u"&&t instanceof MessagePort||typeof ImageBitmap<"u"&&t instanceof ImageBitmap||typeof OffscreenCanvas<"u"&&t instanceof OffscreenCanvas:!1}var fb=()=>{},v7=class{constructor(A){I(this,"name");I(this,"source");I(this,"url");I(this,"terminated",!1);I(this,"worker");I(this,"onMessage");I(this,"onError");I(this,"_loadableURL","");let{name:j,source:e,url:r}=A;Fn(e||r),this.name=j,this.source=e,this.url=r,this.onMessage=fb,this.onError=n=>console.log(n),this.worker=gi?this._createBrowserWorker():this._createNodeWorker()}static isSupported(){return typeof Worker<"u"&&gi||typeof nB<"u"&&!gi}destroy(){this.onMessage=fb,this.onError=fb,this.worker.terminate(),this.terminated=!0}get isRunning(){return!!this.onMessage}postMessage(A,j){j=j||Bb(A),this.worker.postMessage(A,j)}_getErrorFromErrorEvent(A){let j="Failed to load ";return j+=`worker ${this.name} from ${this.url}. `,A.message&&(j+=`${A.message} in `),A.lineno&&(j+=`:${A.lineno}:${A.colno}`),new Error(j)}_createBrowserWorker(){this._loadableURL=aO({source:this.source,url:this.url});let A=new Worker(this._loadableURL,{name:this.name});return A.onmessage=j=>{j.data?this.onMessage(j.data):this.onError(new Error("No data received"))},A.onerror=j=>{this.onError(this._getErrorFromErrorEvent(j)),this.terminated=!0},A.onmessageerror=j=>console.error(j),A}_createNodeWorker(){let A;if(this.url){let e=this.url.includes(":/")||this.url.startsWith("/")?this.url:`./${this.url}`;A=new nB(e,{eval:!1})}else if(this.source)A=new nB(this.source,{eval:!0});else throw new Error("no worker");return A.on("message",j=>{this.onMessage(j)}),A.on("error",j=>{this.onError(j)}),A.on("exit",j=>{}),A}};var Pd=class{constructor(A){I(this,"name","unnamed");I(this,"source");I(this,"url");I(this,"maxConcurrency",1);I(this,"maxMobileConcurrency",1);I(this,"onDebug",()=>{});I(this,"reuseWorkers",!0);I(this,"props",{});I(this,"jobQueue",[]);I(this,"idleQueue",[]);I(this,"count",0);I(this,"isDestroyed",!1);this.source=A.source,this.url=A.url,this.setProps(A)}static isSupported(){return v7.isSupported()}destroy(){this.idleQueue.forEach(A=>A.destroy()),this.isDestroyed=!0}setProps(A){this.props={...this.props,...A},A.name!==void 0&&(this.name=A.name),A.maxConcurrency!==void 0&&(this.maxConcurrency=A.maxConcurrency),A.maxMobileConcurrency!==void 0&&(this.maxMobileConcurrency=A.maxMobileConcurrency),A.reuseWorkers!==void 0&&(this.reuseWorkers=A.reuseWorkers),A.onDebug!==void 0&&(this.onDebug=A.onDebug)}async startJob(A,j=(r,n,i)=>r.done(i),e=(r,n)=>r.error(n)){let r=new Promise(n=>(this.jobQueue.push({name:A,onMessage:j,onError:e,onStart:n}),this));return this._startQueuedJob(),await r}async _startQueuedJob(){if(!this.jobQueue.length)return;let A=this._getAvailableWorker();if(!A)return;let j=this.jobQueue.shift();if(j){this.onDebug({message:"Starting job",name:j.name,workerThread:A,backlog:this.jobQueue.length});let e=new Fd(j.name,A);A.onMessage=r=>j.onMessage(e,r.type,r.payload),A.onError=r=>j.onError(e,r),j.onStart(e);try{await e.result}catch(r){console.error(`Worker exception: ${r}`)}finally{this.returnWorkerToQueue(A)}}}returnWorkerToQueue(A){!gi||this.isDestroyed||!this.reuseWorkers||this.count>this._getMaxConcurrency()?(A.destroy(),this.count--):this.idleQueue.push(A),this.isDestroyed||this._startQueuedJob()}_getAvailableWorker(){if(this.idleQueue.length>0)return this.idleQueue.shift()||null;if(this.count{}},_7=class _7{constructor(A){I(this,"props");I(this,"workerPools",new Map);this.props={...FW},this.setProps(A),this.workerPools=new Map}static isSupported(){return v7.isSupported()}static getWorkerFarm(A={}){return _7._workerFarm=_7._workerFarm||new _7({}),_7._workerFarm.setProps(A),_7._workerFarm}destroy(){for(let A of this.workerPools.values())A.destroy();this.workerPools=new Map}setProps(A){this.props={...this.props,...A};for(let j of this.workerPools.values())j.setProps(this._getWorkerPoolProps())}getWorkerPool(A){let{name:j,source:e,url:r}=A,n=this.workerPools.get(j);return n||(n=new Pd({name:j,source:e,url:r}),n.setProps(this._getWorkerPoolProps()),this.workerPools.set(j,n)),n}_getWorkerPoolProps(){return{maxConcurrency:this.props.maxConcurrency,maxMobileConcurrency:this.props.maxMobileConcurrency,reuseWorkers:this.props.reuseWorkers,onDebug:this.props.onDebug}}};I(_7,"_workerFarm");var ic=_7;function hb(t,A={}){let j=A[t.id]||{},e=gi?`${t.id}-worker.js`:`${t.id}-worker-node.js`,r=j.workerUrl;if(!r&&t.id==="compression"&&(r=A.workerUrl),A._workerType==="test"&&(gi?r=`modules/${t.module}/dist/${e}`:r=`modules/${t.module}/src/workers/${t.id}-worker-node.ts`),!r){let n=t.version;n==="latest"&&(n=iO);let i=n?`@${n}`:"";r=`https://unpkg.com/@loaders.gl/${t.module}${i}/dist/${e}`}return Fn(r),r}function db(t,A=cb){Fn(t,"no worker provided");let j=t.version;return!(!A||!j)}function pb(t,A){return!ic.isSupported()||!gi&&!A?._nodeWorkers?!1:t.worker&&A?.worker}async function kb(t,A,j,e,r){let n=t.id,i=hb(t,j),l=ic.getWorkerFarm(j).getWorkerPool({name:n,url:i});j=JSON.parse(JSON.stringify(j)),e=JSON.parse(JSON.stringify(e||{}));let c=await l.startJob("process-on-worker",PW.bind(null,r));return c.postMessage("process",{input:A,options:j,context:e}),await(await c.result).result}async function PW(t,A,j,e){switch(j){case"done":A.done(e);break;case"error":A.error(new Error(e.error));break;case"process":let{id:r,input:n,options:i}=e;try{let o=await t(n,i);A.postMessage("done",{id:r,result:o})}catch(o){let l=o instanceof Error?o.message:"unknown error";A.postMessage("error",{id:r,error:l})}break;default:console.warn(`parse-with-worker unknown message ${j}`)}}function gb(t,A,j){if(j=j||t.byteLength,t.byteLengthn instanceof ArrayBuffer?new Uint8Array(n):n),j=A.reduce((n,i)=>n+i.byteLength,0),e=new Uint8Array(j),r=0;for(let n of A)e.set(n,r),r+=n.byteLength;return e.buffer}async function Eb(t){let A=[];for await(let j of t)A.push(j);return mb(...A)}function Id(){let t;if(typeof window<"u"&&window.performance)t=window.performance.now();else if(typeof process<"u"&&process.hrtime){let A=process.hrtime();t=A[0]*1e3+A[1]/1e6}else t=Date.now();return t}var oc=class{constructor(A,j){this.sampleSize=1,this.time=0,this.count=0,this.samples=0,this.lastTiming=0,this.lastSampleTime=0,this.lastSampleCount=0,this._count=0,this._time=0,this._samples=0,this._startTime=0,this._timerPending=!1,this.name=A,this.type=j,this.reset()}reset(){return this.time=0,this.count=0,this.samples=0,this.lastTiming=0,this.lastSampleTime=0,this.lastSampleCount=0,this._count=0,this._time=0,this._samples=0,this._startTime=0,this._timerPending=!1,this}setSampleSize(A){return this.sampleSize=A,this}incrementCount(){return this.addCount(1),this}decrementCount(){return this.subtractCount(1),this}addCount(A){return this._count+=A,this._samples++,this._checkSampling(),this}subtractCount(A){return this._count-=A,this._samples++,this._checkSampling(),this}addTime(A){return this._time+=A,this.lastTiming=A,this._samples++,this._checkSampling(),this}timeStart(){return this._startTime=Id(),this._timerPending=!0,this}timeEnd(){return this._timerPending?(this.addTime(Id()-this._startTime),this._timerPending=!1,this._checkSampling(),this):this}getSampleAverageCount(){return this.sampleSize>0?this.lastSampleCount/this.sampleSize:0}getSampleAverageTime(){return this.sampleSize>0?this.lastSampleTime/this.sampleSize:0}getSampleHz(){return this.lastSampleTime>0?this.sampleSize/(this.lastSampleTime/1e3):0}getAverageCount(){return this.samples>0?this.count/this.samples:0}getAverageTime(){return this.samples>0?this.time/this.samples:0}getHz(){return this.time>0?this.samples/(this.time/1e3):0}_checkSampling(){this._samples===this.sampleSize&&(this.lastSampleTime=this._time,this.lastSampleCount=this._count,this.count+=this._count,this.time+=this._time,this.samples+=this._samples,this._time=0,this._count=0,this._samples=0)}};var v6=class{constructor(A){this.stats={},this.id=A.id,this.stats={},this._initializeStats(A.stats),Object.seal(this)}get(A,j="count"){return this._getOrCreate({name:A,type:j})}get size(){return Object.keys(this.stats).length}reset(){for(let A of Object.values(this.stats))A.reset();return this}forEach(A){for(let j of Object.values(this.stats))A(j)}getTable(){let A={};return this.forEach(j=>{A[j.name]={time:j.time||0,count:j.count||0,average:j.getAverageTime()||0,hz:j.getHz()||0}}),A}_initializeStats(A=[]){A.forEach(j=>this._getOrCreate(j))}_getOrCreate(A){let{name:j,type:e}=A,r=this.stats[j];return r||(A instanceof oc?r=A:r=new oc(j,e),this.stats[j]=r),r}};var IW="",BO={};function $b(t){for(let A in BO)if(t.startsWith(A)){let j=BO[A];t=t.replace(A,j)}return!t.startsWith("http://")&&!t.startsWith("https://")&&(t=`${IW}${t}`),t}function fO(t){return t&&typeof t=="object"&&t.isBuffer}function aE(t){if(fO(t))return t;if(t instanceof ArrayBuffer)return t;if(ArrayBuffer.isView(t))return t.byteOffset===0&&t.byteLength===t.buffer.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength);if(typeof t=="string"){let A=t;return new TextEncoder().encode(A).buffer}if(t&&typeof t=="object"&&t._toArrayBuffer)return t._toArrayBuffer();throw new Error("toArrayBuffer")}var sc={};fr(sc,{dirname:()=>OW,filename:()=>MW,join:()=>TW,resolve:()=>SW});function hO(){if(typeof process<"u"&&typeof process.cwd<"u")return process.cwd();let t=window.location?.pathname;return t?.slice(0,t.lastIndexOf("/")+1)||""}function MW(t){let A=t?t.lastIndexOf("/"):-1;return A>=0?t.substr(A+1):""}function OW(t){let A=t?t.lastIndexOf("/"):-1;return A>=0?t.substr(0,A):""}function TW(...t){let A="/";return t=t.map((j,e)=>(e&&(j=j.replace(new RegExp(`^${A}`),"")),e!==t.length-1&&(j=j.replace(new RegExp(`${A}$`),"")),j)),t.join(A)}function SW(...t){let A=[];for(let n=0;n=-1&&!e;n--){let i;n>=0?i=A[n]:(r===void 0&&(r=hO()),i=r),i.length!==0&&(j=`${i}/${j}`,e=i.charCodeAt(0)===Md)}return j=RW(j,!e),e?`/${j}`:j.length>0?j:"."}var Md=47,xb=46;function RW(t,A){let j="",e=-1,r=0,n,i=!1;for(let o=0;o<=t.length;++o){if(o2){let l=j.length-1,c=l;for(;c>=0&&j.charCodeAt(c)!==Md;--c);if(c!==l){j=c===-1?"":j.slice(0,c),e=o,r=0,i=!1;continue}}else if(j.length===2||j.length===1){j="",e=o,r=0,i=!1;continue}}A&&(j.length>0?j+="/..":j="..",i=!0)}else{let l=t.slice(e+1,o);j.length>0?j+=`/${l}`:j=l,i=!1}e=o,r=0}else n===xb&&r!==-1?++r:r=-1}return j}var LW=t=>typeof t=="boolean",Od=t=>typeof t=="function",ac=t=>t!==null&&typeof t=="object",yb=t=>ac(t)&&t.constructor==={}.constructor;var dO=t=>!!t&&typeof t[Symbol.iterator]=="function",pO=t=>t&&typeof t[Symbol.asyncIterator]=="function";var mi=t=>typeof Response<"u"&&t instanceof Response||t&&t.arrayBuffer&&t.text&&t.json;var Ei=t=>typeof Blob<"u"&&t instanceof Blob,kO=t=>t&&typeof t=="object"&&t.isBuffer;var CW=t=>typeof ReadableStream<"u"&&t instanceof ReadableStream||ac(t)&&Od(t.tee)&&Od(t.cancel)&&Od(t.getReader);var HW=t=>ac(t)&&Od(t.read)&&Od(t.pipe)&&LW(t.readable),lE=t=>CW(t)||HW(t);var cE=class extends Error{constructor(j,e){super(j);I(this,"reason");I(this,"url");I(this,"response");this.reason=e.reason,this.url=e.url,this.response=e.response}};var DW=/^data:([-\w.]+\/[-\w.+]+)(;|,)/,NW=/^([-\w.]+\/[-\w.+]+)/;function vb(t,A){return t.toLowerCase()===A.toLowerCase()}function gO(t){let A=NW.exec(t);return A?A[1]:t}function _b(t){let A=DW.exec(t);return A?A[1]:""}var mO=/\?.*/;function EO(t){let A=t.match(mO);return A&&A[0]}function iB(t){return t.replace(mO,"")}function $O(t){if(t.length<50)return t;let A=t.slice(t.length-15);return`${t.substr(0,32)}...${A}`}function lc(t){return mi(t)?t.url:Ei(t)?t.name||"":typeof t=="string"?t:""}function Td(t){if(mi(t)){let A=t,j=A.headers.get("content-type")||"",e=iB(A.url);return gO(j)||_b(e)}return Ei(t)?t.type||"":typeof t=="string"?_b(t):""}function xO(t){return mi(t)?t.headers["content-length"]||-1:Ei(t)?t.size:typeof t=="string"?t.length:t instanceof ArrayBuffer||ArrayBuffer.isView(t)?t.byteLength:-1}async function uE(t){if(mi(t))return t;let A={},j=xO(t);j>=0&&(A["content-length"]=String(j));let e=lc(t),r=Td(t);r&&(A["content-type"]=r);let n=await XW(t);n&&(A["x-first-bytes"]=n),typeof t=="string"&&(t=new TextEncoder().encode(t));let i=new Response(t,{headers:A});return Object.defineProperty(i,"url",{value:e}),i}async function yO(t){if(!t.ok)throw await KW(t)}async function KW(t){let A=$O(t.url),j=`Failed to fetch resource (${t.status}) ${t.statusText}: ${A}`;j=j.length>100?`${j.slice(0,100)}...`:j;let e={reason:t.statusText,url:t.url,response:t};try{let r=t.headers.get("Content-Type");e.reason=!t.bodyUsed&&r?.includes("application/json")?await t.json():await t.text()}catch{}return new cE(j,e)}async function XW(t){if(typeof t=="string")return`data:,${t.slice(0,5)}`;if(t instanceof Blob){let j=t.slice(0,5);return await new Promise(e=>{let r=new FileReader;r.onload=n=>e(n?.target?.result),r.readAsDataURL(j)})}if(t instanceof ArrayBuffer){let j=t.slice(0,5);return`data:base64,${zW(j)}`}return null}function zW(t){let A="",j=new Uint8Array(t);for(let e=0;e{}}info(){return()=>{}}warn(){return()=>{}}error(){return()=>{}}},fE=class{constructor(){I(this,"console");this.console=console}log(...A){return this.console.log.bind(this.console,...A)}info(...A){return this.console.info.bind(this.console,...A)}warn(...A){return this.console.warn.bind(this.console,...A)}error(...A){return this.console.error.bind(this.console,...A)}};var Gb={fetch:null,mimeType:void 0,nothrow:!1,log:new fE,useLocalLibraries:!1,CDN:"https://unpkg.com/@loaders.gl",worker:!0,maxConcurrency:3,maxMobileConcurrency:1,reuseWorkers:Gd,_nodeWorkers:!1,_workerType:"",limit:0,_limitMB:0,batchSize:"auto",batchDebounceMs:0,metadata:!1,transforms:[]},vO={throws:"nothrow",dataType:"(no longer used)",uri:"baseUri",method:"fetch.method",headers:"fetch.headers",body:"fetch.body",mode:"fetch.mode",credentials:"fetch.credentials",cache:"fetch.cache",redirect:"fetch.redirect",referrer:"fetch.referrer",referrerPolicy:"fetch.referrerPolicy",integrity:"fetch.integrity",keepalive:"fetch.keepalive",signal:"fetch.signal"};function wb(){globalThis.loaders=globalThis.loaders||{};let{loaders:t}=globalThis;return t._state||(t._state={}),t._state}function Fb(){let t=wb();return t.globalOptions=t.globalOptions||{...Gb},t.globalOptions}function bO(t,A,j,e){return j=j||[],j=Array.isArray(j)?j:[j],WW(t,j),JW(A,t,e)}function WW(t,A){_O(t,null,Gb,vO,A);for(let j of A){let e=t&&t[j.id]||{},r=j.options&&j.options[j.id]||{},n=j.deprecatedOptions&&j.deprecatedOptions[j.id]||{};_O(e,j.id,r,n,A)}}function _O(t,A,j,e,r){let n=A||"Top level",i=A?`${A}.`:"";for(let o in t){let l=!A&&ac(t[o]),c=o==="baseUri"&&!A,B=o==="workerUrl"&&A;if(!(o in j)&&!c&&!B){if(o in e)bb.warn(`${n} loader option '${i}${o}' no longer supported, use '${e[o]}'`)();else if(!l){let h=YW(o,r);bb.warn(`${n} loader option '${i}${o}' not recognized. ${h}`)()}}}}function YW(t,A){let j=t.toLowerCase(),e="";for(let r of A)for(let n in r.options){if(t===n)return`Did you mean '${r.id}.${n}'?`;let i=n.toLowerCase();(j.startsWith(i)||i.startsWith(j))&&(e=e||`Did you mean '${r.id}.${n}'?`)}return e}function JW(t,A,j){let r={...t.options||{}};return ZW(r,j),r.log===null&&(r.log=new BE),qO(r,Fb()),qO(r,A),r}function qO(t,A){for(let j in A)if(j in A){let e=A[j];yb(e)&&yb(t[j])?t[j]={...t[j],...A[j]}:t[j]=A[j]}}function ZW(t,A){A&&!("baseUri"in t)&&(t.baseUri=A)}function Sd(t){return t?(Array.isArray(t)&&(t=t[0]),Array.isArray(t?.extensions)):!1}function Rd(t){eE(t,"null loader"),eE(Sd(t),"invalid loader");let A;return Array.isArray(t)&&(A=t[1],t=t[0],t={...t,options:{...t.options,...A}}),(t?.parseTextSync||t?.parseText)&&(t.text=!0),t.text||(t.binary=!0),t}var GO=()=>{let t=wb();return t.loaderRegistry=t.loaderRegistry||[],t.loaderRegistry};function Pb(t){let A=GO();t=Array.isArray(t)?t:[t];for(let j of t){let e=Rd(j);A.find(r=>e===r)||A.unshift(e)}}function wO(){return GO()}var AY=/\.([^.]+)$/;async function IO(t,A=[],j,e){if(!MO(t))return null;let r=FO(t,A,{...j,nothrow:!0},e);if(r)return r;if(Ei(t)&&(t=await t.slice(0,10).arrayBuffer(),r=FO(t,A,j,e)),!r&&!j?.nothrow)throw new Error(OO(t));return r}function FO(t,A=[],j,e){if(!MO(t))return null;if(A&&!Array.isArray(A))return Rd(A);let r=[];A&&(r=r.concat(A)),j?.ignoreRegisteredLoaders||r.push(...wO()),jY(r);let n=tY(t,r,j,e);if(!n&&!j?.nothrow)throw new Error(OO(t));return n}function tY(t,A,j,e){let r=lc(t),n=Td(t),i=iB(r)||e?.url,o=null,l="";return j?.mimeType&&(o=Ib(A,j?.mimeType),l=`match forced by supplied MIME type ${j?.mimeType}`),o=o||eY(A,i),l=l||(o?`matched url ${i}`:""),o=o||Ib(A,n),l=l||(o?`matched MIME type ${n}`:""),o=o||nY(A,t),l=l||(o?`matched initial data ${TO(t)}`:""),j?.fallbackMimeType&&(o=o||Ib(A,j?.fallbackMimeType),l=l||(o?`matched fallback MIME type ${n}`:"")),l&&ab.log(1,`selectLoader selected ${o?.name}: ${l}.`),o}function MO(t){return!(t instanceof Response&&t.status===204)}function OO(t){let A=lc(t),j=Td(t),e="No valid loader found (";e+=A?`${sc.filename(A)}, `:"no url provided, ",e+=`MIME type: ${j?`"${j}"`:"not provided"}, `;let r=t?TO(t):"";return e+=r?` first bytes: "${r}"`:"first bytes: not available",e+=")",e}function jY(t){for(let A of t)Rd(A)}function eY(t,A){let j=A&&AY.exec(A),e=j&&j[1];return e?rY(t,e):null}function rY(t,A){A=A.toLowerCase();for(let j of t)for(let e of j.extensions)if(e.toLowerCase()===A)return j;return null}function Ib(t,A){for(let j of t)if(j.mimeTypes?.some(e=>vb(A,e))||vb(A,`application/x.${j.id}`))return j;return null}function nY(t,A){if(!A)return null;for(let j of t)if(typeof A=="string"){if(iY(A,j))return j}else if(ArrayBuffer.isView(A)){if(PO(A.buffer,A.byteOffset,j))return j}else if(A instanceof ArrayBuffer&&PO(A,0,j))return j;return null}function iY(t,A){return A.testText?A.testText(t):(Array.isArray(A.tests)?A.tests:[A.tests]).some(e=>t.startsWith(e))}function PO(t,A,j){return(Array.isArray(j.tests)?j.tests:[j.tests]).some(r=>oY(t,A,j,r))}function oY(t,A,j,e){if(e instanceof ArrayBuffer)return gb(e,t,e.byteLength);switch(typeof e){case"function":return e(t);case"string":let r=Mb(t,A,e.length);return e===r;default:return!1}}function TO(t,A=5){return typeof t=="string"?t.slice(0,A):ArrayBuffer.isView(t)?Mb(t.buffer,t.byteOffset,A):t instanceof ArrayBuffer?Mb(t,0,A):""}function Mb(t,A,j){if(t.byteLengthqb(r,e.fetch):A?.fetch?A?.fetch:qb}function NO(t,A,j){if(j)return j;let e={fetch:hE(A,t),...t};if(e.url){let r=iB(e.url);e.baseUrl=r,e.queryString=EO(e.url),e.filename=sc.filename(r),e.baseUrl=sc.dirname(r)}return Array.isArray(e.loaders)||(e.loaders=null),e}function KO(t,A){if(t&&!Array.isArray(t))return t;let j;if(t&&(j=Array.isArray(t)?t:[t]),A&&A.loaders){let e=Array.isArray(A.loaders)?A.loaders:[A.loaders];j=j?[...j,...e]:e}return j&&j.length?j:void 0}async function Ld(t,A,j,e){A&&!Array.isArray(A)&&!Sd(A)&&(e=void 0,j=A,A=void 0),t=await t,j=j||{};let r=lc(t),i=KO(A,e),o=await IO(t,i,j);return o?(j=bO(j,o,i,r),e=NO({url:r,_parse:Ld,loaders:i},j,e||null),await cY(o,t,j,e)):null}async function cY(t,A,j,e){if(db(t),j=lb(t.options,j),mi(A)){let n=A,{ok:i,redirected:o,status:l,statusText:c,type:B,url:h}=n,d=Object.fromEntries(n.headers.entries());e.response={headers:d,ok:i,redirected:o,status:l,statusText:c,type:B,url:h}}A=await DO(A,t,j);let r=t;if(r.parseTextSync&&typeof A=="string")return r.parseTextSync(A,j,e);if(pb(t,j))return await kb(t,A,j,e,Ld);if(r.parseText&&typeof A=="string")return await r.parseText(A,j,e);if(r.parse)return await r.parse(A,j,e);throw Fn(!r.parseSync),new Error(`${t.id} loader - no parser found and worker is disabled`)}async function As(t,A,j,e){let r,n;!Array.isArray(A)&&!Sd(A)?(r=[],n=A,e=void 0):(r=A,n=j);let i=hE(n),o=t;return typeof t=="string"&&(o=await i(t)),Ei(t)&&(o=await i(t)),Array.isArray(r)?await Ld(o,r,n):await Ld(o,r,n)}var XO="4.2.0";function Cd(t,A){if(!t)throw new Error(A||"loader assertion failed.")}var ts={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},uY=ts.self||ts.window||ts.global||{},BY=ts.window||ts.self||ts.global||{},fY=ts.global||ts.self||ts.window||{},hY=ts.document||{};var Tb=!!(typeof process!="object"||String(process)!=="[object process]"||process.browser);var zO=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),dY=zO&&parseFloat(zO[1])||0;var pY="Queued Requests",kY="Active Requests",gY="Cancelled Requests",mY="Queued Requests Ever",EY="Active Requests Ever",$Y={id:"request-scheduler",throttleRequests:!0,maxRequests:6,debounceTime:0},oB=class{constructor(A={}){I(this,"props");I(this,"stats");I(this,"activeRequestCount",0);I(this,"requestQueue",[]);I(this,"requestMap",new Map);I(this,"updateTimer",null);this.props={...$Y,...A},this.stats=new v6({id:this.props.id}),this.stats.get(pY),this.stats.get(kY),this.stats.get(gY),this.stats.get(mY),this.stats.get(EY)}scheduleRequest(A,j=()=>0){if(!this.props.throttleRequests)return Promise.resolve({done:()=>{}});if(this.requestMap.has(A))return this.requestMap.get(A);let e={handle:A,priority:0,getPriority:j},r=new Promise(n=>(e.resolve=n,e));return this.requestQueue.push(e),this.requestMap.set(A,r),this._issueNewRequests(),r}_issueRequest(A){let{handle:j,resolve:e}=A,r=!1,n=()=>{r||(r=!0,this.requestMap.delete(j),this.activeRequestCount--,this._issueNewRequests())};return this.activeRequestCount++,e?e({done:n}):Promise.resolve({done:n})}_issueNewRequests(){this.updateTimer!==null&&clearTimeout(this.updateTimer),this.updateTimer=setTimeout(()=>this._issueNewRequestsAsync(),this.props.debounceTime)}_issueNewRequestsAsync(){this.updateTimer!==null&&clearTimeout(this.updateTimer),this.updateTimer=null;let A=Math.max(this.props.maxRequests-this.activeRequestCount,0);if(A!==0){this._updateAllRequests();for(let j=0;jj.priority-e.priority)}_updateRequest(A){return A.priority=A.getPriority(A.handle),A.priority<0?(A.resolve(null),!1):!0}};var xY=globalThis.loaders?.parseImageNode,Sb=typeof Image<"u",Rb=typeof ImageBitmap<"u",yY=!!xY,Lb=Tb?!0:yY;function UO(t){switch(t){case"auto":return Rb||Sb||Lb;case"imagebitmap":return Rb;case"image":return Sb;case"data":return Lb;default:throw new Error(`@loaders.gl/images: image ${t} not supported in this environment`)}}function VO(){if(Rb)return"imagebitmap";if(Sb)return"image";if(Lb)return"data";throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js")}function vY(t){let A=_Y(t);if(!A)throw new Error("Not an image");return A}function QO(t){switch(vY(t)){case"data":return t;case"image":case"imagebitmap":let A=document.createElement("canvas"),j=A.getContext("2d");if(!j)throw new Error("getImageData");return A.width=t.width,A.height=t.height,j.drawImage(t,0,0),j.getImageData(0,0,t.width,t.height);default:throw new Error("getImageData")}}function _Y(t){return typeof ImageBitmap<"u"&&t instanceof ImageBitmap?"imagebitmap":typeof Image<"u"&&t instanceof Image?"image":t&&typeof t=="object"&&t.data&&t.width&&t.height?"data":null}var qY=/^data:image\/svg\+xml/,bY=/\.svg((\?|#).*)?$/;function dE(t){return t&&(qY.test(t)||bY.test(t))}function WO(t,A){if(dE(A)){let e=new TextDecoder().decode(t);try{typeof unescape=="function"&&typeof encodeURIComponent=="function"&&(e=unescape(encodeURIComponent(e)))}catch(n){throw new Error(n.message)}return`data:image/svg+xml;base64,${btoa(e)}`}return Cb(t,A)}function Cb(t,A){if(dE(A))throw new Error("SVG cannot be parsed directly to imagebitmap");return new Blob([new Uint8Array(t)])}async function pE(t,A,j){let e=WO(t,j),r=self.URL||self.webkitURL,n=typeof e!="string"&&r.createObjectURL(e);try{return await GY(n||e,A)}finally{n&&r.revokeObjectURL(n)}}async function GY(t,A){let j=new Image;return j.src=t,A.image&&A.image.decode&&j.decode?(await j.decode(),j):await new Promise((e,r)=>{try{j.onload=()=>e(j),j.onerror=n=>{let i=n instanceof Error?n.message:"error";r(new Error(i))}}catch(n){r(n)}})}var wY={},YO=!0;async function JO(t,A,j){let e;dE(j)?e=await pE(t,A,j):e=Cb(t,j);let r=A&&A.imagebitmap;return await FY(e,r)}async function FY(t,A=null){if((PY(A)||!YO)&&(A=null),A)try{return await createImageBitmap(t,A)}catch(j){console.warn(j),YO=!1}return await createImageBitmap(t)}function PY(t){for(let A in t||wY)return!1;return!0}function ZO(t){return!TY(t,"ftyp",4)||!(t[8]&96)?null:IY(t)}function IY(t){switch(MY(t,8,12).replace("\0"," ").trim()){case"avif":case"avis":return{extension:"avif",mimeType:"image/avif"};default:return null}}function MY(t,A,j){return String.fromCharCode(...t.slice(A,j))}function OY(t){return[...t].map(A=>A.charCodeAt(0))}function TY(t,A,j=0){let e=OY(A);for(let r=0;r=24&&A.getUint32(0,js)===2303741511?{mimeType:"image/png",width:A.getUint32(16,js),height:A.getUint32(20,js)}:null}function LY(t){let A=Dd(t);return A.byteLength>=10&&A.getUint32(0,js)===1195984440?{mimeType:"image/gif",width:A.getUint16(6,Hd),height:A.getUint16(8,Hd)}:null}function CY(t){let A=Dd(t);return A.byteLength>=14&&A.getUint16(0,js)===16973&&A.getUint32(2,Hd)===A.byteLength?{mimeType:"image/bmp",width:A.getUint32(18,Hd),height:A.getUint32(22,Hd)}:null}function HY(t){let A=Dd(t);if(!(A.byteLength>=3&&A.getUint16(0,js)===65496&&A.getUint8(2)===255))return null;let{tableMarkers:e,sofMarkers:r}=DY(),n=2;for(;n+9!!kE(new DataView(t))],options:zY};var UY=new y6({id:"deck"}),NA=UY;var Hb={};function jT(t){Hb=t}function he(t,A,j,e){NA.level>0&&Hb[t]&&Hb[t].call(null,A,j,e)}function VY(t){let A=t[0],j=t[t.length-1];return A==="{"&&j==="}"||A==="["&&j==="]"}var eT={dataType:null,batchType:null,id:"JSON",name:"JSON",module:"",version:"",options:{},extensions:["json","geojson"],mimeTypes:["application/json","application/geo+json"],testText:VY,parseTextSync:JSON.parse};function QY(){let t="9.0.35",A=globalThis.deck&&globalThis.deck.VERSION;if(A&&A!==t)throw new Error(`deck.gl - multiple versions detected: ${A} vs ${t}`);return A||(NA.log(1,`deck.gl ${t}`)(),globalThis.deck={...globalThis.deck,VERSION:t,version:t,log:NA,_registerLoggers:jT},Pb([eT,[Nd,{imagebitmap:{premultiplyAlpha:"none"}}]])),t}var Db=QY();function es(t,A){if(!t)throw new Error(A||"shadertools: assertion failed.")}var Nb={number:{type:"number",validate(t,A){return Number.isFinite(t)&&typeof A=="object"&&(A.max===void 0||t<=A.max)&&(A.min===void 0||t>=A.min)}},array:{type:"array",validate(t,A){return Array.isArray(t)||ArrayBuffer.isView(t)}}};function nT(t){let A={};for(let[j,e]of Object.entries(t))A[j]=WY(e);return A}function iT(t,A,j){let e={};for(let[r,n]of Object.entries(A))t&&r in t&&!n.private?(n.validate&&es(n.validate(t[r],n),`${j}: invalid ${r}`),e[r]=t[r]):e[r]=n.value;return e}function WY(t){let A=rT(t);if(A!=="object")return{value:t,...Nb[A],type:A};if(typeof t=="object")return t?t.type!==void 0?{...t,...Nb[t.type],type:t.type}:t.value===void 0?{type:"object",value:t}:(A=rT(t.value),{...t,...Nb[A],type:A}):{type:"object",value:null};throw new Error("props")}function rT(t){return Array.isArray(t)||ArrayBuffer.isView(t)?"array":typeof t}var oT=`#ifdef MODULE_LOGDEPTH logdepth_adjustPosition(gl_Position); #endif -`,jT=`#ifdef MODULE_MATERIAL +`,sT=`#ifdef MODULE_MATERIAL gl_FragColor = material_filterColor(gl_FragColor); #endif #ifdef MODULE_LIGHTING @@ -42,14 +42,14 @@ gl_FragColor = picking_filterPickingColor(gl_FragColor); #ifdef MODULE_LOGDEPTH logdepth_setFragDepth(); #endif -`;var XY={vertex:tT,fragment:jT},eT=/void\s+main\s*\([^)]*\)\s*\{\n?/,rT=/}\n?[^{}]*$/,LG=[],Dd="__LUMA_INJECT_DECLARATIONS__";function nT(t){let A={vertex:{},fragment:{}};for(let j in t){let e=t[j],r=zY(j);typeof e=="string"&&(e={order:0,injection:e}),A[r][j]=e}return A}function zY(t){let A=t.slice(0,2);switch(A){case"vs":return"vertex";case"fs":return"fragment";default:throw new Error(A)}}function Nd(t,A,j,e=!1){let r=A==="vertex";for(let n in j){let i=j[n];i.sort((l,c)=>l.order-c.order),LG.length=i.length;for(let l=0,c=i.length;ll.order-c.order),Kb.length=i.length;for(let l=0,c=i.length;ll+o));break;case"vs:#main-end":r&&(t=t.replace(rT,l=>o+l));break;case"fs:#decl":r||(t=t.replace(Dd,o));break;case"fs:#main-start":r||(t=t.replace(eT,l=>l+o));break;case"fs:#main-end":r||(t=t.replace(rT,l=>o+l));break;default:t=t.replace(n,l=>l+o)}}return t=t.replace(Dd,""),e&&(t=t.replace(/\}\s*$/,n=>n+XY[A])),t}var UY=1,sB=class t{constructor(A){I(this,"name");I(this,"vs");I(this,"fs");I(this,"getModuleUniforms");I(this,"dependencies");I(this,"deprecations");I(this,"defines");I(this,"injections");I(this,"uniforms",{});I(this,"uniformTypes",{});let{name:j,vs:e,fs:r,dependencies:n=[],uniformTypes:i={},uniformPropTypes:o={},getUniforms:l,deprecations:c=[],defines:B={},inject:h={}}=A;es(typeof j=="string"),this.name=j,this.vs=e,this.fs=r,this.getModuleUniforms=l,this.dependencies=t.instantiateModules(n),this.deprecations=this._parseDeprecationDefinitions(c),this.defines=B,this.injections=nT(h),this.uniformTypes=i,o&&(this.uniforms=ZO(o))}static instantiateModules(A){return A.map(j=>{if(j instanceof t)return j;es(typeof j!="string",`Shader module use by name is deprecated. Import shader module '${JSON.stringify(j)}' and use it directly.`),j.name||(console.warn("shader module has no name"),j.name=`shader-module-${UY++}`);let e=new t(j);return e.dependencies=t.instantiateModules(j.dependencies||[]),e})}getModuleSource(A){let j;switch(A){case"vertex":j=this.vs||"";break;case"fragment":j=this.fs||"";break;default:es(!1)}let e=this.name.toUpperCase().replace(/[^0-9a-z]/gi,"_");return`// ----- MODULE ${this.name} --------------- +`;switch(n){case"vs:#decl":r&&(t=t.replace(Kd,o));break;case"vs:#main-start":r&&(t=t.replace(aT,l=>l+o));break;case"vs:#main-end":r&&(t=t.replace(lT,l=>o+l));break;case"fs:#decl":r||(t=t.replace(Kd,o));break;case"fs:#main-start":r||(t=t.replace(aT,l=>l+o));break;case"fs:#main-end":r||(t=t.replace(lT,l=>o+l));break;default:t=t.replace(n,l=>l+o)}}return t=t.replace(Kd,""),e&&(t=t.replace(/\}\s*$/,n=>n+YY[A])),t}var ZY=1,sB=class t{constructor(A){I(this,"name");I(this,"vs");I(this,"fs");I(this,"getModuleUniforms");I(this,"dependencies");I(this,"deprecations");I(this,"defines");I(this,"injections");I(this,"uniforms",{});I(this,"uniformTypes",{});let{name:j,vs:e,fs:r,dependencies:n=[],uniformTypes:i={},uniformPropTypes:o={},getUniforms:l,deprecations:c=[],defines:B={},inject:h={}}=A;es(typeof j=="string"),this.name=j,this.vs=e,this.fs=r,this.getModuleUniforms=l,this.dependencies=t.instantiateModules(n),this.deprecations=this._parseDeprecationDefinitions(c),this.defines=B,this.injections=cT(h),this.uniformTypes=i,o&&(this.uniforms=nT(o))}static instantiateModules(A){return A.map(j=>{if(j instanceof t)return j;es(typeof j!="string",`Shader module use by name is deprecated. Import shader module '${JSON.stringify(j)}' and use it directly.`),j.name||(console.warn("shader module has no name"),j.name=`shader-module-${ZY++}`);let e=new t(j);return e.dependencies=t.instantiateModules(j.dependencies||[]),e})}getModuleSource(A){let j;switch(A){case"vertex":j=this.vs||"";break;case"fragment":j=this.fs||"";break;default:es(!1)}let e=this.name.toUpperCase().replace(/[^0-9a-z]/gi,"_");return`// ----- MODULE ${this.name} --------------- #define MODULE_${e} ${j} -`}getUniforms(A,j){return this.getModuleUniforms?this.getModuleUniforms(A,j):AT(A,this.uniforms,this.name)}getDefines(){return this.defines}checkDeprecations(A,j){this.deprecations.forEach(e=>{e.regex?.test(A)&&(e.deprecated?j.deprecated(e.old,e.new)():j.removed(e.old,e.new)())})}_parseDeprecationDefinitions(A){return A.forEach(j=>{switch(j.type){case"function":j.regex=new RegExp(`\\b${j.old}\\(`);break;default:j.regex=new RegExp(`${j.type} ${j.old};`)}}),A}_defaultGetUniforms(A={}){let j={},e=this.uniforms;for(let r in e){let n=e[r];r in A&&!n.private?(n.validate&&es(n.validate(A[r],n),`${this.name}: invalid ${r}`),j[r]=A[r]):j[r]=n.value}return j}};function CG(t){if(t.source&&t.platformInfo.type==="webgpu")return{...t,vs:void 0,fs:void 0};if(!t.vs)throw new Error("no vertex shader");let A=iT(t.platformInfo,t.vs),j;return t.fs&&(j=iT(t.platformInfo,t.fs)),{...t,vs:A,fs:j}}function iT(t,A){if(typeof A=="string")return A;switch(t.type){case"webgpu":if(A?.wgsl)return A.wgsl;throw new Error("WebGPU does not support GLSL shaders");default:if(A?.glsl)return A.glsl;throw new Error("WebGL does not support WGSL shaders")}}function lc(t){let A=sB.instantiateModules(t);return VY(A)}function VY(t){let A={},j={};return oT({modules:t,level:0,moduleMap:A,moduleDepth:j}),Object.keys(j).sort((e,r)=>j[r]-j[e]).map(e=>A[e])}function oT(t){let{modules:A,level:j,moduleMap:e,moduleDepth:r}=t;if(j>=5)throw new Error("Possible loop in shader dependency graph");for(let n of A)e[n.name]=n,(r[n.name]===void 0||r[n.name]{e.regex?.test(A)&&(e.deprecated?j.deprecated(e.old,e.new)():j.removed(e.old,e.new)())})}_parseDeprecationDefinitions(A){return A.forEach(j=>{switch(j.type){case"function":j.regex=new RegExp(`\\b${j.old}\\(`);break;default:j.regex=new RegExp(`${j.type} ${j.old};`)}}),A}_defaultGetUniforms(A={}){let j={},e=this.uniforms;for(let r in e){let n=e[r];r in A&&!n.private?(n.validate&&es(n.validate(A[r],n),`${this.name}: invalid ${r}`),j[r]=A[r]):j[r]=n.value}return j}};function Xb(t){if(t.source&&t.platformInfo.type==="webgpu")return{...t,vs:void 0,fs:void 0};if(!t.vs)throw new Error("no vertex shader");let A=uT(t.platformInfo,t.vs),j;return t.fs&&(j=uT(t.platformInfo,t.fs)),{...t,vs:A,fs:j}}function uT(t,A){if(typeof A=="string")return A;switch(t.type){case"webgpu":if(A?.wgsl)return A.wgsl;throw new Error("WebGPU does not support GLSL shaders");default:if(A?.glsl)return A.glsl;throw new Error("WebGL does not support WGSL shaders")}}function cc(t){let A=sB.instantiateModules(t);return AJ(A)}function AJ(t){let A={},j={};return BT({modules:t,level:0,moduleMap:A,moduleDepth:j}),Object.keys(j).sort((e,r)=>j[r]-j[e]).map(e=>A[e])}function BT(t){let{modules:A,level:j,moduleMap:e,moduleDepth:r}=t;if(j>=5)throw new Error("Possible loop in shader dependency graph");for(let n of A)e[n.name]=n,(r[n.name]===void 0||r[n.name]i.order-o.order);for(let i of n)j+=` ${i.injection} `}r.footer&&(j+=` ${r.footer}`),j+=`} -`}return j}function NG(t){let A={vertex:{},fragment:{}};for(let j of t){let e,r;typeof j!="string"?(e=j,r=e.hook):(e={},r=j),r=r.trim();let[n,i]=r.split(":"),o=r.replace(/\(.+/,""),l=Object.assign(e,{signature:i});switch(n){case"vs":A.vertex[o]=l;break;case"fs":A.fragment[o]=l;break;default:throw new Error(n)}}return A}function uT(t,A){return{name:YY(t,A),language:"glsl",version:JY(t)}}function YY(t,A="unnamed"){let e=/#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/.exec(t);return e?e[1]:A}function JY(t){let A=100,j=t.match(/[^\s]+/g);if(j&&j.length>=2&&j[0]==="#version"){let e=parseInt(j[1],10);Number.isFinite(e)&&(A=e)}if(A!==100&&A!==300)throw new Error(`Invalid GLSL version ${A}`);return A}var fT=` +`}return j}function Vb(t){let A={vertex:{},fragment:{}};for(let j of t){let e,r;typeof j!="string"?(e=j,r=e.hook):(e={},r=j),r=r.trim();let[n,i]=r.split(":"),o=r.replace(/\(.+/,""),l=Object.assign(e,{signature:i});switch(n){case"vs":A.vertex[o]=l;break;case"fs":A.fragment[o]=l;break;default:throw new Error(n)}}return A}function kT(t,A){return{name:eJ(t,A),language:"glsl",version:rJ(t)}}function eJ(t,A="unnamed"){let e=/#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/.exec(t);return e?e[1]:A}function rJ(t){let A=100,j=t.match(/[^\s]+/g);if(j&&j.length>=2&&j[0]==="#version"){let e=parseInt(j[1],10);Number.isFinite(e)&&(A=e)}if(A!==100&&A!==300)throw new Error(`Invalid GLSL version ${A}`);return A}var mT=` -${Dd} -`,ZY=`precision highp float; -`;function hT(t){let A=lc(t.modules||[]);return{source:KG(t.platformInfo,{...t,source:t.source,stage:"vertex",modules:A}),getUniforms:XG(A)}}function dT(t){let A=lc(t.modules||[]);return{vs:KG(t.platformInfo,{...t,source:t.vs,stage:"vertex",modules:A}),fs:KG(t.platformInfo,{...t,source:t.fs,stage:"fragment",modules:A}),getUniforms:XG(A)}}function pT(t){let{vs:A,fs:j}=t,e=lc(t.modules||[]);return{vs:BT(t.platformInfo,{...t,source:A,stage:"vertex",modules:e}),fs:BT(t.platformInfo,{...t,source:j,stage:"fragment",modules:e}),getUniforms:XG(e)}}function KG(t,A){let{source:j,stage:e,modules:r,hookFunctions:n=[],inject:i={},log:o}=A;es(typeof j=="string","shader source must be a string");let l=j,c="",B=NG(n),h={},d={},k={};for(let E in i){let m=typeof i[E]=="string"?{injection:i[E],order:0}:i[E],y=/^(v|f)s:(#)?([\w-]+)$/.exec(E);if(y){let b=y[2],v=y[3];b?v==="decl"?d[E]=[m]:k[E]=[m]:h[E]=[m]}else k[E]=[m]}let g=t.type!=="webgpu"?r:[];for(let E of g){o&&E.checkDeprecations(l,o);let m=E.getModuleSource(e,"wgsl");c+=m;let y=E.injections[e];for(let b in y){let v=/^(v|f)s:#([\w-]+)$/.exec(b);if(v){let w=v[2]==="decl"?d:k;w[b]=w[b]||[],w[b].push(y[b])}else h[b]=h[b]||[],h[b].push(y[b])}}return c+=fT,c=Nd(c,e,d),c+=DG(B[e],h),c+=l,c=Nd(c,e,k),c}function BT(t,A){let{id:j,source:e,stage:r,language:n="glsl",modules:i,defines:o={},hookFunctions:l=[],inject:c={},prologue:B=!0,log:h}=A;es(typeof e=="string","shader source must be a string");let d=n==="glsl"?uT(e).version:-1,k=t.shaderLanguageVersion,g=d===100?"#version 100":"#version 300 es",m=e.split(` +${Kd} +`,nJ=`precision highp float; +`;function ET(t){let A=cc(t.modules||[]);return{source:Qb(t.platformInfo,{...t,source:t.source,stage:"vertex",modules:A}),getUniforms:Wb(A)}}function $T(t){let A=cc(t.modules||[]);return{vs:Qb(t.platformInfo,{...t,source:t.vs,stage:"vertex",modules:A}),fs:Qb(t.platformInfo,{...t,source:t.fs,stage:"fragment",modules:A}),getUniforms:Wb(A)}}function xT(t){let{vs:A,fs:j}=t,e=cc(t.modules||[]);return{vs:gT(t.platformInfo,{...t,source:A,stage:"vertex",modules:e}),fs:gT(t.platformInfo,{...t,source:j,stage:"fragment",modules:e}),getUniforms:Wb(e)}}function Qb(t,A){let{source:j,stage:e,modules:r,hookFunctions:n=[],inject:i={},log:o}=A;es(typeof j=="string","shader source must be a string");let l=j,c="",B=Vb(n),h={},d={},k={};for(let E in i){let m=typeof i[E]=="string"?{injection:i[E],order:0}:i[E],y=/^(v|f)s:(#)?([\w-]+)$/.exec(E);if(y){let G=y[2],v=y[3];G?v==="decl"?d[E]=[m]:k[E]=[m]:h[E]=[m]}else k[E]=[m]}let g=t.type!=="webgpu"?r:[];for(let E of g){o&&E.checkDeprecations(l,o);let m=E.getModuleSource(e,"wgsl");c+=m;let y=E.injections[e];for(let G in y){let v=/^(v|f)s:#([\w-]+)$/.exec(G);if(v){let w=v[2]==="decl"?d:k;w[G]=w[G]||[],w[G].push(y[G])}else h[G]=h[G]||[],h[G].push(y[G])}}return c+=mT,c=Xd(c,e,d),c+=Ub(B[e],h),c+=l,c=Xd(c,e,k),c}function gT(t,A){let{id:j,source:e,stage:r,language:n="glsl",modules:i,defines:o={},hookFunctions:l=[],inject:c={},prologue:B=!0,log:h}=A;es(typeof e=="string","shader source must be a string");let d=n==="glsl"?kT(e).version:-1,k=t.shaderLanguageVersion,g=d===100?"#version 100":"#version 300 es",m=e.split(` `).slice(1).join(` -`),y={};i.forEach(S=>{Object.assign(y,S.getDefines())}),Object.assign(y,o);let b="";switch(n){case"wgsl":break;case"glsl":b=B?`${g} +`),y={};i.forEach(O=>{Object.assign(y,O.getDefines())}),Object.assign(y,o);let G="";switch(n){case"wgsl":break;case"glsl":G=B?`${g} // ----- PROLOGUE ------------------------- -${AJ({id:j,source:e,stage:r})} +${iJ({id:j,source:e,stage:r})} ${`#define SHADER_TYPE_${r.toUpperCase()}`} -${sT(t)} -${r==="fragment"?ZY:""} +${fT(t)} +${r==="fragment"?nJ:""} // ----- APPLICATION DEFINES ------------------------- -${tJ(y)} +${oJ(y)} `:`${g} -`;break}let v=NG(l),_={},w={},x={};for(let S in c){let F=typeof c[S]=="string"?{injection:c[S],order:0}:c[S],D=/^(v|f)s:(#)?([\w-]+)$/.exec(S);if(D){let L=D[2],z=D[3];L?z==="decl"?w[S]=[F]:x[S]=[F]:_[S]=[F]}else x[S]=[F]}for(let S of i){h&&S.checkDeprecations(m,h);let F=S.getModuleSource(r);b+=F;let D=S.injections[r];for(let L in D){let z=/^(v|f)s:#([\w-]+)$/.exec(L);if(z){let W=z[2]==="decl"?w:x;W[L]=W[L]||[],W[L].push(D[L])}else _[L]=_[L]||[],_[L].push(D[L])}}return b+="// ----- MAIN SHADER SOURCE -------------------------",b+=fT,b=Nd(b,r,w),b+=DG(v[r],_),b+=m,b=Nd(b,r,x),n==="glsl"&&d!==k&&(b=lT(b,r)),b.trim()}function XG(t){return function(j){let e={};for(let r of t){let n=r.getUniforms(j,e);Object.assign(e,n)}return e}}function AJ(t){let{id:A,source:j,stage:e}=t;return A&&j.indexOf("SHADER_NAME")===-1?` +`;break}let v=Vb(l),_={},w={},x={};for(let O in c){let F=typeof c[O]=="string"?{injection:c[O],order:0}:c[O],C=/^(v|f)s:(#)?([\w-]+)$/.exec(O);if(C){let R=C[2],X=C[3];R?X==="decl"?w[O]=[F]:x[O]=[F]:_[O]=[F]}else x[O]=[F]}for(let O of i){h&&O.checkDeprecations(m,h);let F=O.getModuleSource(r);G+=F;let C=O.injections[r];for(let R in C){let X=/^(v|f)s:#([\w-]+)$/.exec(R);if(X){let Q=X[2]==="decl"?w:x;Q[R]=Q[R]||[],Q[R].push(C[R])}else _[R]=_[R]||[],_[R].push(C[R])}}return G+="// ----- MAIN SHADER SOURCE -------------------------",G+=mT,G=Xd(G,r,w),G+=Ub(v[r],_),G+=m,G=Xd(G,r,x),n==="glsl"&&d!==k&&(G=dT(G,r)),G.trim()}function Wb(t){return function(j){let e={};for(let r of t){let n=r.getUniforms(j,e);Object.assign(e,n)}return e}}function iJ(t){let{id:A,source:j,stage:e}=t;return A&&j.indexOf("SHADER_NAME")===-1?` #define SHADER_NAME ${A}_${e} -`:""}function tJ(t={}){let A="";for(let j in t){let e=t[j];(e||Number.isFinite(e))&&(A+=`#define ${j.toUpperCase()} ${t[j]} -`)}return A}var cc=class cc{constructor(){I(this,"_hookFunctions",[]);I(this,"_defaultModules",[])}static getDefaultShaderAssembler(){return cc.defaultShaderAssembler=cc.defaultShaderAssembler||new cc,cc.defaultShaderAssembler}addDefaultModule(A){this._defaultModules.find(j=>j.name===(typeof A=="string"?A:A.name))||this._defaultModules.push(A)}removeDefaultModule(A){let j=typeof A=="string"?A:A.name;this._defaultModules=this._defaultModules.filter(e=>e.name!==j)}addShaderHook(A,j){j&&(A=Object.assign(j,{hook:A})),this._hookFunctions.push(A)}assembleShader(A){let j=this._getModuleList(A.modules),e=this._hookFunctions,r=CG(A);return{...hT({platformInfo:A.platformInfo,...r,modules:j,hookFunctions:e}),modules:j}}assembleShaderPair(A){let j=CG(A),e=this._getModuleList(A.modules),r=this._hookFunctions,{platformInfo:n}=A;return{...A.platformInfo.shaderLanguage==="wgsl"?dT({platformInfo:n,...j,modules:e,hookFunctions:r}):pT({platformInfo:n,...j,modules:e,hookFunctions:r}),modules:e}}_getModuleList(A=[]){let j=new Array(this._defaultModules.length+A.length),e={},r=0;for(let n=0,i=this._defaultModules.length;nj.name===(typeof A=="string"?A:A.name))||this._defaultModules.push(A)}removeDefaultModule(A){let j=typeof A=="string"?A:A.name;this._defaultModules=this._defaultModules.filter(e=>e.name!==j)}addShaderHook(A,j){j&&(A=Object.assign(j,{hook:A})),this._hookFunctions.push(A)}assembleShader(A){let j=this._getModuleList(A.modules),e=this._hookFunctions,r=Xb(A);return{...ET({platformInfo:A.platformInfo,...r,modules:j,hookFunctions:e}),modules:j}}assembleShaderPair(A){let j=Xb(A),e=this._getModuleList(A.modules),r=this._hookFunctions,{platformInfo:n}=A;return{...A.platformInfo.shaderLanguage==="wgsl"?$T({platformInfo:n,...j,modules:e,hookFunctions:r}):xT({platformInfo:n,...j,modules:e,hookFunctions:r}),modules:e}}_getModuleList(A=[]){let j=new Array(this._defaultModules.length+A.length),e={},r=0;for(let n=0,i=this._defaultModules.length;nt.startsWith(A))}function hE(t){let A=cJ.exec(t);if(A){let[,j,e,r,n,i]=A;if(j){let o=`${r}${e}`,l=fE(o);return{format:j,components:j.length,srgb:n==="-srgb",unsized:i==="-unsized",webgl:i==="-webgl",...l}}}return BJ(t)}var uJ={"rgba4unorm-webgl":{format:"rgba",bpp:2},"rgb565unorm-webgl":{format:"rgb",bpp:2},"rgb5a1unorm-webgl":{format:"rgba",bbp:2},rgb9e5ufloat:{format:"rgb",bbp:4},rg11b10ufloat:{format:"rgb",bbp:4},rgb10a2unorm:{format:"rgba",bbp:4},"rgb10a2uint-webgl":{format:"rgba",bbp:4},stencil8:{components:1,bpp:1,a:"stencil"},depth16unorm:{components:1,bpp:2,a:"depth"},depth24plus:{components:1,bpp:3,a:"depth"},depth32float:{components:1,bpp:4,a:"depth"},"depth24plus-stencil8":{components:2,bpp:4,a:"depth-stencil"},"depth24unorm-stencil8":{components:2,bpp:4,a:"depth-stencil"},"depth32float-stencil8":{components:2,bpp:4,a:"depth-stencil"}};function BJ(t){let A=uJ[t];if(!A)throw new Error(`Unknown format ${t}`);return{format:A.format||"",components:A.components||A.format?.length||1,byteLength:A.bpp||1,srgb:!1,unsized:!1}}var Xd=class{},zd=class{constructor(A=[],j){I(this,"features");I(this,"disabledFeatures");this.features=new Set(A),this.disabledFeatures=j||{}}*[Symbol.iterator](){yield*this.features}has(A){return!this.disabledFeatures[A]&&this.features.has(A)}},Kd=class Kd{constructor(A){I(this,"id");I(this,"props");I(this,"userData",{});I(this,"statsManager",aB);I(this,"_lumaData",{});I(this,"timestamp",0);this.props={...Kd.defaultProps,...A},this.id=this.props.id||Pn(this[Symbol.toStringTag].toLowerCase())}get[Symbol.toStringTag](){return"Device"}isTextureFormatCompressed(A){return ET(A)}loseDevice(){return!1}getCanvasContext(){if(!this.canvasContext)throw new Error("Device has no CanvasContext");return this.canvasContext}createTexture(A){return(A instanceof Promise||typeof A=="string")&&(A={data:A}),this._createTexture(A)}createCommandEncoder(A={}){throw new Error("not implemented")}readPixelsToArrayWebGL(A,j){throw new Error("not implemented")}readPixelsToBufferWebGL(A,j){throw new Error("not implemented")}setParametersWebGL(A){throw new Error("not implemented")}getParametersWebGL(A){throw new Error("not implemented")}withParametersWebGL(A,j){throw new Error("not implemented")}clearWebGL(A){throw new Error("not implemented")}resetWebGL(){throw new Error("not implemented")}incrementTimestamp(){return this.timestamp++}onError(A){this.props.onError(A)}_getBufferProps(A){(A instanceof ArrayBuffer||ArrayBuffer.isView(A))&&(A={data:A});let j={...A};return(A.usage||0)&Aj.INDEX&&!A.indexType&&(A.data instanceof Uint32Array?j.indexType="uint32":A.data instanceof Uint16Array?j.indexType="uint16":mA.warn("indices buffer content must be of integer type")()),j}};I(Kd,"defaultProps",{id:null,canvas:null,container:null,manageState:!0,width:800,height:600,requestMaxLimits:!0,debug:!!mA.get("debug"),spector:!!(mA.get("spector")||mA.get("spectorjs")),break:[],initalizeFeatures:!0,disabledFeatures:{"compilation-status-async-webgl":!0},gl:null,onError:A=>mA.error(A.message)}),I(Kd,"VERSION",gT);var xa=Kd;function Ot(t,A){if(!t)throw new Error(A||"luma.gl: assertion failed.")}var Ud=new Map,lB=class lB{static registerDevices(A){for(let j of A)Ot(j.type&&j.isSupported&&j.create),Ud.set(j.type,j)}static getAvailableDevices(){return Array.from(Ud).map(A=>A.type)}static getSupportedDevices(){return Array.from(Ud).filter(A=>A.isSupported()).map(A=>A.type)}static setDefaultDeviceProps(A){Object.assign(xa.defaultProps,A)}static async attachDevice(A){let j=$T(A.devices)||Ud;if(A.handle instanceof WebGL2RenderingContext){let e=j.get("webgl");if(e)return await e.attach(A.handle)}if(A.handle===null){let e=j.get("unknown");if(e)return await e.attach(null)}throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.")}static async createDevice(A={}){A={...lB.defaultProps,...A},A.gl&&(A.type="webgl");let j=$T(A.devices)||Ud,e,r;switch(A.type){case"webgpu":if(e=j.get("webgpu"),e)return await e.create(A);break;case"webgl":if(r=j.get("webgl"),r)return await r.create(A);break;case"unknown":let n=j.get("unknown");if(n)return await n.create(A);break;case"best-available":if(e=j.get("webgpu"),e?.isSupported?.())return await e.create(A);if(r=j.get("webgl"),r?.isSupported?.())return await r.create(A);break}throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.")}static enforceWebGL2(A=!0){let j=HTMLCanvasElement.prototype;if(!A&&j.originalGetContext){j.getContext=j.originalGetContext,j.originalGetContext=void 0;return}j.originalGetContext=j.getContext,j.getContext=function(e,r){return e==="webgl"||e==="experimental-webgl"?this.originalGetContext("webgl2",r):this.originalGetContext(e,r)}}};I(lB,"defaultProps",{...xa.defaultProps,type:"best-available",devices:void 0}),I(lB,"stats",aB),I(lB,"log",mA);var ya=lB;function $T(t){if(!t||t?.length===0)return null;let A=new Map;for(let j of t)A.set(j.type,j);return A}var fJ=rn()&&typeof document<"u",dE=()=>fJ&&document.readyState==="complete",hJ={canvas:null,width:800,height:600,useDevicePixels:!0,autoResize:!0,container:null,visible:!0,colorSpace:"srgb",alphaMode:"opaque"},b7=class{constructor(A){I(this,"id");I(this,"props");I(this,"canvas");I(this,"htmlCanvas");I(this,"offscreenCanvas");I(this,"type");I(this,"width",1);I(this,"height",1);I(this,"resizeObserver");I(this,"_canvasSizeInfo",{clientWidth:0,clientHeight:0,devicePixelRatio:1});if(this.props={...hJ,...A},A=this.props,!rn()){this.id="node-canvas-context",this.type="node",this.width=this.props.width,this.height=this.props.height,this.canvas=null;return}if(A.canvas)typeof A.canvas=="string"?this.canvas=kJ(A.canvas):this.canvas=A.canvas;else{let j=gJ(A),e=pJ(A?.container||null);e.insertBefore(j,e.firstChild),this.canvas=j,A?.visible||(this.canvas.style.visibility="hidden")}this.canvas instanceof HTMLCanvasElement?(this.id=this.canvas.id,this.type="html-canvas",this.htmlCanvas=this.canvas):(this.id="offscreen-canvas",this.type="offscreen-canvas",this.offscreenCanvas=this.canvas),this.canvas instanceof HTMLCanvasElement&&A.autoResize&&(this.resizeObserver=new ResizeObserver(j=>{for(let e of j)e.target===this.canvas&&this.update()}),this.resizeObserver.observe(this.canvas))}static get isPageLoaded(){return dE()}getDevicePixelRatio(A){return typeof OffscreenCanvas<"u"&&this.canvas instanceof OffscreenCanvas||(A=A===void 0?this.props.useDevicePixels:A,!A||A<=0)?1:A===!0?typeof window<"u"&&window.devicePixelRatio||1:A}getPixelSize(){switch(this.type){case"node":return[this.width,this.height];case"offscreen-canvas":return[this.canvas.width,this.canvas.height];case"html-canvas":let A=this.getDevicePixelRatio(),j=this.canvas;return j.parentElement?[j.clientWidth*A,j.clientHeight*A]:[this.canvas.width,this.canvas.height];default:throw new Error(this.type)}}getAspect(){let[A,j]=this.getPixelSize();return A/j}cssToDeviceRatio(){try{let[A]=this.getDrawingBufferSize(),{clientWidth:j}=this._canvasSizeInfo;return j?A/j:1}catch{return 1}}cssToDevicePixels(A,j=!0){let e=this.cssToDeviceRatio(),[r,n]=this.getDrawingBufferSize();return mJ(A,e,r,n,j)}setDevicePixelRatio(A,j={}){if(!this.htmlCanvas)return;let e="width"in j?j.width:this.htmlCanvas.clientWidth,r="height"in j?j.height:this.htmlCanvas.clientHeight;(!e||!r)&&(mA.log(1,"Canvas clientWidth/clientHeight is 0")(),A=1,e=this.htmlCanvas.width||1,r=this.htmlCanvas.height||1);let n=this._canvasSizeInfo;if(n.clientWidth!==e||n.clientHeight!==r||n.devicePixelRatio!==A){let i=A,o=Math.floor(e*i),l=Math.floor(r*i);this.htmlCanvas.width=o,this.htmlCanvas.height=l;let[c,B]=this.getDrawingBufferSize();(c!==o||B!==l)&&(i=Math.min(c/e,B/r),this.htmlCanvas.width=Math.floor(e*i),this.htmlCanvas.height=Math.floor(r*i),mA.warn("Device pixel ratio clamped")()),this._canvasSizeInfo.clientWidth=e,this._canvasSizeInfo.clientHeight=r,this._canvasSizeInfo.devicePixelRatio=A}}getDrawingBufferSize(){let A=this.device.gl;if(!A)throw new Error("canvas size");return[A.drawingBufferWidth,A.drawingBufferHeight]}_setAutoCreatedCanvasId(A){this.htmlCanvas?.id==="lumagl-auto-created-canvas"&&(this.htmlCanvas.id=A)}};I(b7,"pageLoaded",dJ());function dJ(){return dE()||typeof window>"u"?Promise.resolve():new Promise(t=>{window.addEventListener("load",()=>t())})}function pJ(t){if(typeof t=="string"){let A=document.getElementById(t);if(!A&&!dE())throw new Error(`Accessing '${t}' before page was loaded`);if(!A)throw new Error(`${t} is not an HTML element`);return A}else if(t)return t;return document.body}function kJ(t){let A=document.getElementById(t);if(!A&&!dE())throw new Error(`Accessing '${t}' before page was loaded`);if(!(A instanceof HTMLCanvasElement))throw new Error("Object is not a canvas element");return A}function gJ(t){let{width:A,height:j}=t,e=document.createElement("canvas");return e.id="lumagl-auto-created-canvas",e.width=A||1,e.height=j||1,e.style.width=Number.isFinite(A)?`${A}px`:"100%",e.style.height=Number.isFinite(j)?`${j}px`:"100%",e}function mJ(t,A,j,e,r){let n=t,i=xT(n[0],A,j),o=yT(n[1],A,e,r),l=xT(n[0]+1,A,j),c=l===j-1?l:l-1;l=yT(n[1]+1,A,e,r);let B;return r?(l=l===0?l:l+1,B=o,o=l):B=l===e-1?l:l-1,{x:i,y:o,width:Math.max(c-i+1,1),height:Math.max(B-o+1,1)}}function xT(t,A,j){return Math.min(Math.round(t*A),j-1)}function yT(t,A,j,e){return e?Math.max(0,j-1-Math.round(t*A)):Math.min(Math.round(t*A),j-1)}var va=class va extends $t{constructor(j,e,r=va.defaultProps){super(j,e,r);I(this,"dimension");I(this,"format");I(this,"width");I(this,"height");I(this,"depth");I(this,"updateTimestamp");this.dimension=this.props.dimension,this.format=this.props.format,this.width=this.props.width,this.height=this.props.height,this.depth=this.props.depth,this.updateTimestamp=j.incrementTimestamp()}get[Symbol.toStringTag](){return"Texture"}};I(va,"defaultProps",{...$t.defaultProps,data:null,dimension:"2d",format:"rgba8unorm",width:void 0,height:void 0,depth:1,mipmaps:!0,compressed:!1,usage:0,mipLevels:void 0,samples:void 0,type:void 0,sampler:{},view:void 0}),I(va,"COPY_SRC",1),I(va,"COPY_DST",2),I(va,"TEXTURE_BINDING",4),I(va,"STORAGE_BINDING",8),I(va,"RENDER_ATTACHMENT",16);var Ne=va;var pE=class pE extends $t{get[Symbol.toStringTag](){return"TextureView"}constructor(A,j){super(A,j,pE.defaultProps)}};I(pE,"defaultProps",{...$t.defaultProps,format:void 0,dimension:void 0,aspect:"all",baseMipLevel:0,mipLevelCount:void 0,baseArrayLayer:0,arrayLayerCount:void 0});var Bc=pE;function _T(t,A,j){let e="",r=A.split(/\r?\n/),n=t.slice().sort((i,o)=>i.lineNum-o.lineNum);switch(j?.showSourceCode||"no"){case"all":let i=0;for(let o=1;o<=r.length;o++)for(e+=qT(r[o-1],o,j);n.length>i&&n[i].lineNum===o;){let l=n[i++];e+=vT(l,r,l.lineNum,{...j,inlineSource:!1})}return e;case"issues":case"no":for(let o of t)e+=vT(o,r,o.lineNum,{inlineSource:j?.showSourceCode!=="no"});return e}}function vT(t,A,j,e){if(e?.inlineSource){let r=EJ(A,j),n=t.linePos>0?`${" ".repeat(t.linePos+5)}^^^ +}`}function lJ(t){switch(t){case 1:return"float";case 2:return"vec2";case 3:return"vec3";case 4:return"vec4";default:throw new Error(`invalid channels: ${t}`)}}function yT(t,A){switch(A){case 1:return`vec4(${t}, 0.0, 0.0, 1.0)`;case 2:return`vec4(${t}, 0.0, 1.0)`;case 3:return`vec4(${t}, 1.0)`;case 4:return t;default:throw new Error(`invalid channels: ${A}`)}}var mA=new y6({id:"luma.gl"});var Jb=class{constructor(){I(this,"stats",new Map)}getStats(A){return this.get(A)}get(A){return this.stats.has(A)||this.stats.set(A,new v6({id:A})),this.stats.get(A)}},aB=new Jb;function cJ(){let t="9.0.27",A="set luma.log.level=1 (or higher) to trace rendering";if(globalThis.luma&&globalThis.luma.VERSION!==t)throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${t}`);return globalThis.luma||(rn()&&mA.log(1,`${t} - ${A}`)(),globalThis.luma=globalThis.luma||{VERSION:t,version:t,log:mA,stats:aB}),t}var vT=cJ();function uJ(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)?t:null}function q7(t){return Array.isArray(t)?t.length===0||typeof t[0]=="number"?t:null:uJ(t)}var Zb={};function Pn(t="id"){Zb[t]=Zb[t]||1;let A=Zb[t]++;return`${t}-${A}`}function b7(t){let A=!0;for(let j in t){A=!1;break}return A}var $t=class{constructor(A,j,e){I(this,"id");I(this,"props");I(this,"userData",{});I(this,"_device");I(this,"destroyed",!1);I(this,"allocatedBytes",0);I(this,"_attachedResources",new Set);if(!A)throw new Error("no device");this._device=A,this.props=BJ(j,e);let r=this.props.id!=="undefined"?this.props.id:Pn(this[Symbol.toStringTag]);this.props.id=r,this.id=r,this.userData=this.props.userData||{},this.addStats()}destroy(){this.destroyResource()}delete(){return this.destroy(),this}toString(){return`${this[Symbol.toStringTag]||this.constructor.name}(${this.id})`}getProps(){return this.props}attachResource(A){this._attachedResources.add(A)}detachResource(A){this._attachedResources.delete(A)}destroyAttachedResource(A){this._attachedResources.delete(A)&&A.destroy()}destroyAttachedResources(){for(let A of Object.values(this._attachedResources))A.destroy();this._attachedResources=new Set}destroyResource(){this.destroyAttachedResources(),this.removeStats(),this.destroyed=!0}removeStats(){let A=this._device.statsManager.getStats("Resource Counts"),j=this[Symbol.toStringTag];A.get(`${j}s Active`).decrementCount()}trackAllocatedMemory(A,j=this[Symbol.toStringTag]){let e=this._device.statsManager.getStats("Resource Counts");e.get("GPU Memory").addCount(A),e.get(`${j} Memory`).addCount(A),this.allocatedBytes=A}trackDeallocatedMemory(A=this[Symbol.toStringTag]){let j=this._device.statsManager.getStats("Resource Counts");j.get("GPU Memory").subtractCount(this.allocatedBytes),j.get(`${A} Memory`).subtractCount(this.allocatedBytes),this.allocatedBytes=0}addStats(){let A=this._device.statsManager.getStats("Resource Counts"),j=this[Symbol.toStringTag];A.get("Resources Created").incrementCount(),A.get(`${j}s Created`).incrementCount(),A.get(`${j}s Active`).incrementCount()}};I($t,"defaultProps",{id:"undefined",handle:void 0,userData:void 0});function BJ(t,A){let j={...A};for(let e in t)t[e]!==void 0&&(j[e]=t[e]);return j}var Rr=class Rr extends $t{constructor(j,e){let r={...e};(e.usage||0)&Rr.INDEX&&!e.indexType&&(e.data instanceof Uint32Array?r.indexType="uint32":e.data instanceof Uint16Array&&(r.indexType="uint16"));super(j,r,Rr.defaultProps);I(this,"usage");I(this,"indexType");I(this,"updateTimestamp");I(this,"debugData",new ArrayBuffer(0));this.usage=e.usage||0,this.indexType=r.indexType,this.updateTimestamp=j.incrementTimestamp()}get[Symbol.toStringTag](){return"Buffer"}readSyncWebGL(j,e){throw new Error("not implemented")}_setDebugData(j,e,r){let n=ArrayBuffer.isView(j)?j.buffer:j,i=Math.min(j?j.byteLength:r,Rr.DEBUG_DATA_MAX_LENGTH);j===null?this.debugData=new ArrayBuffer(i):e===0&&r===j.byteLength?this.debugData=n.slice(0,i):this.debugData=n.slice(e,e+i)}};I(Rr,"defaultProps",{...$t.defaultProps,usage:0,byteLength:0,byteOffset:0,data:null,indexType:"uint16",mappedAtCreation:!1}),I(Rr,"MAP_READ",1),I(Rr,"MAP_WRITE",2),I(Rr,"COPY_SRC",4),I(Rr,"COPY_DST",8),I(Rr,"INDEX",16),I(Rr,"VERTEX",32),I(Rr,"UNIFORM",64),I(Rr,"STORAGE",128),I(Rr,"INDIRECT",256),I(Rr,"QUERY_RESOLVE",512),I(Rr,"DEBUG_DATA_MAX_LENGTH",32);var Aj=Rr;function gE(t){let A=_T[t],j=fJ(A),e=t.includes("norm"),r=!e&&!t.startsWith("float"),n=t.startsWith("s");return{dataType:_T[t],byteLength:j,integer:r,signed:n,normalized:e}}function fJ(t){return hJ[t]}var _T={uint8:"uint8",sint8:"sint8",unorm8:"uint8",snorm8:"sint8",uint16:"uint16",sint16:"sint16",unorm16:"uint16",snorm16:"sint16",float16:"float16",float32:"float32",uint32:"uint32",sint32:"sint32"},hJ={uint8:1,sint8:1,uint16:2,sint16:2,float16:2,float32:4,uint32:4,sint32:4};var dJ=["bc1","bc2","bc3","bc4","bc5","bc6","bc7","etc1","etc2","eac","atc","astc","pvrtc"],pJ=/^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;function qT(t){return dJ.some(A=>t.startsWith(A))}function mE(t){let A=pJ.exec(t);if(A){let[,j,e,r,n,i]=A;if(j){let o=`${r}${e}`,l=gE(o);return{format:j,components:j.length,srgb:n==="-srgb",unsized:i==="-unsized",webgl:i==="-webgl",...l}}}return gJ(t)}var kJ={"rgba4unorm-webgl":{format:"rgba",bpp:2},"rgb565unorm-webgl":{format:"rgb",bpp:2},"rgb5a1unorm-webgl":{format:"rgba",bbp:2},rgb9e5ufloat:{format:"rgb",bbp:4},rg11b10ufloat:{format:"rgb",bbp:4},rgb10a2unorm:{format:"rgba",bbp:4},"rgb10a2uint-webgl":{format:"rgba",bbp:4},stencil8:{components:1,bpp:1,a:"stencil"},depth16unorm:{components:1,bpp:2,a:"depth"},depth24plus:{components:1,bpp:3,a:"depth"},depth32float:{components:1,bpp:4,a:"depth"},"depth24plus-stencil8":{components:2,bpp:4,a:"depth-stencil"},"depth24unorm-stencil8":{components:2,bpp:4,a:"depth-stencil"},"depth32float-stencil8":{components:2,bpp:4,a:"depth-stencil"}};function gJ(t){let A=kJ[t];if(!A)throw new Error(`Unknown format ${t}`);return{format:A.format||"",components:A.components||A.format?.length||1,byteLength:A.bpp||1,srgb:!1,unsized:!1}}var Ud=class{},Vd=class{constructor(A=[],j){I(this,"features");I(this,"disabledFeatures");this.features=new Set(A),this.disabledFeatures=j||{}}*[Symbol.iterator](){yield*this.features}has(A){return!this.disabledFeatures[A]&&this.features.has(A)}},zd=class zd{constructor(A){I(this,"id");I(this,"props");I(this,"userData",{});I(this,"statsManager",aB);I(this,"_lumaData",{});I(this,"timestamp",0);this.props={...zd.defaultProps,...A},this.id=this.props.id||Pn(this[Symbol.toStringTag].toLowerCase())}get[Symbol.toStringTag](){return"Device"}isTextureFormatCompressed(A){return qT(A)}loseDevice(){return!1}getCanvasContext(){if(!this.canvasContext)throw new Error("Device has no CanvasContext");return this.canvasContext}createTexture(A){return(A instanceof Promise||typeof A=="string")&&(A={data:A}),this._createTexture(A)}createCommandEncoder(A={}){throw new Error("not implemented")}readPixelsToArrayWebGL(A,j){throw new Error("not implemented")}readPixelsToBufferWebGL(A,j){throw new Error("not implemented")}setParametersWebGL(A){throw new Error("not implemented")}getParametersWebGL(A){throw new Error("not implemented")}withParametersWebGL(A,j){throw new Error("not implemented")}clearWebGL(A){throw new Error("not implemented")}resetWebGL(){throw new Error("not implemented")}incrementTimestamp(){return this.timestamp++}onError(A){this.props.onError(A)}_getBufferProps(A){(A instanceof ArrayBuffer||ArrayBuffer.isView(A))&&(A={data:A});let j={...A};return(A.usage||0)&Aj.INDEX&&!A.indexType&&(A.data instanceof Uint32Array?j.indexType="uint32":A.data instanceof Uint16Array?j.indexType="uint16":mA.warn("indices buffer content must be of integer type")()),j}};I(zd,"defaultProps",{id:null,canvas:null,container:null,manageState:!0,width:800,height:600,requestMaxLimits:!0,debug:!!mA.get("debug"),spector:!!(mA.get("spector")||mA.get("spectorjs")),break:[],initalizeFeatures:!0,disabledFeatures:{"compilation-status-async-webgl":!0},gl:null,onError:A=>mA.error(A.message)}),I(zd,"VERSION",vT);var xa=zd;function Ot(t,A){if(!t)throw new Error(A||"luma.gl: assertion failed.")}var Qd=new Map,lB=class lB{static registerDevices(A){for(let j of A)Ot(j.type&&j.isSupported&&j.create),Qd.set(j.type,j)}static getAvailableDevices(){return Array.from(Qd).map(A=>A.type)}static getSupportedDevices(){return Array.from(Qd).filter(A=>A.isSupported()).map(A=>A.type)}static setDefaultDeviceProps(A){Object.assign(xa.defaultProps,A)}static async attachDevice(A){let j=bT(A.devices)||Qd;if(A.handle instanceof WebGL2RenderingContext){let e=j.get("webgl");if(e)return await e.attach(A.handle)}if(A.handle===null){let e=j.get("unknown");if(e)return await e.attach(null)}throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.")}static async createDevice(A={}){A={...lB.defaultProps,...A},A.gl&&(A.type="webgl");let j=bT(A.devices)||Qd,e,r;switch(A.type){case"webgpu":if(e=j.get("webgpu"),e)return await e.create(A);break;case"webgl":if(r=j.get("webgl"),r)return await r.create(A);break;case"unknown":let n=j.get("unknown");if(n)return await n.create(A);break;case"best-available":if(e=j.get("webgpu"),e?.isSupported?.())return await e.create(A);if(r=j.get("webgl"),r?.isSupported?.())return await r.create(A);break}throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.")}static enforceWebGL2(A=!0){let j=HTMLCanvasElement.prototype;if(!A&&j.originalGetContext){j.getContext=j.originalGetContext,j.originalGetContext=void 0;return}j.originalGetContext=j.getContext,j.getContext=function(e,r){return e==="webgl"||e==="experimental-webgl"?this.originalGetContext("webgl2",r):this.originalGetContext(e,r)}}};I(lB,"defaultProps",{...xa.defaultProps,type:"best-available",devices:void 0}),I(lB,"stats",aB),I(lB,"log",mA);var ya=lB;function bT(t){if(!t||t?.length===0)return null;let A=new Map;for(let j of t)A.set(j.type,j);return A}var mJ=rn()&&typeof document<"u",EE=()=>mJ&&document.readyState==="complete",EJ={canvas:null,width:800,height:600,useDevicePixels:!0,autoResize:!0,container:null,visible:!0,colorSpace:"srgb",alphaMode:"opaque"},G7=class{constructor(A){I(this,"id");I(this,"props");I(this,"canvas");I(this,"htmlCanvas");I(this,"offscreenCanvas");I(this,"type");I(this,"width",1);I(this,"height",1);I(this,"resizeObserver");I(this,"_canvasSizeInfo",{clientWidth:0,clientHeight:0,devicePixelRatio:1});if(this.props={...EJ,...A},A=this.props,!rn()){this.id="node-canvas-context",this.type="node",this.width=this.props.width,this.height=this.props.height,this.canvas=null;return}if(A.canvas)typeof A.canvas=="string"?this.canvas=yJ(A.canvas):this.canvas=A.canvas;else{let j=vJ(A),e=xJ(A?.container||null);e.insertBefore(j,e.firstChild),this.canvas=j,A?.visible||(this.canvas.style.visibility="hidden")}this.canvas instanceof HTMLCanvasElement?(this.id=this.canvas.id,this.type="html-canvas",this.htmlCanvas=this.canvas):(this.id="offscreen-canvas",this.type="offscreen-canvas",this.offscreenCanvas=this.canvas),this.canvas instanceof HTMLCanvasElement&&A.autoResize&&(this.resizeObserver=new ResizeObserver(j=>{for(let e of j)e.target===this.canvas&&this.update()}),this.resizeObserver.observe(this.canvas))}static get isPageLoaded(){return EE()}getDevicePixelRatio(A){return typeof OffscreenCanvas<"u"&&this.canvas instanceof OffscreenCanvas||(A=A===void 0?this.props.useDevicePixels:A,!A||A<=0)?1:A===!0?typeof window<"u"&&window.devicePixelRatio||1:A}getPixelSize(){switch(this.type){case"node":return[this.width,this.height];case"offscreen-canvas":return[this.canvas.width,this.canvas.height];case"html-canvas":let A=this.getDevicePixelRatio(),j=this.canvas;return j.parentElement?[j.clientWidth*A,j.clientHeight*A]:[this.canvas.width,this.canvas.height];default:throw new Error(this.type)}}getAspect(){let[A,j]=this.getPixelSize();return A/j}cssToDeviceRatio(){try{let[A]=this.getDrawingBufferSize(),{clientWidth:j}=this._canvasSizeInfo;return j?A/j:1}catch{return 1}}cssToDevicePixels(A,j=!0){let e=this.cssToDeviceRatio(),[r,n]=this.getDrawingBufferSize();return _J(A,e,r,n,j)}setDevicePixelRatio(A,j={}){if(!this.htmlCanvas)return;let e="width"in j?j.width:this.htmlCanvas.clientWidth,r="height"in j?j.height:this.htmlCanvas.clientHeight;(!e||!r)&&(mA.log(1,"Canvas clientWidth/clientHeight is 0")(),A=1,e=this.htmlCanvas.width||1,r=this.htmlCanvas.height||1);let n=this._canvasSizeInfo;if(n.clientWidth!==e||n.clientHeight!==r||n.devicePixelRatio!==A){let i=A,o=Math.floor(e*i),l=Math.floor(r*i);this.htmlCanvas.width=o,this.htmlCanvas.height=l;let[c,B]=this.getDrawingBufferSize();(c!==o||B!==l)&&(i=Math.min(c/e,B/r),this.htmlCanvas.width=Math.floor(e*i),this.htmlCanvas.height=Math.floor(r*i),mA.warn("Device pixel ratio clamped")()),this._canvasSizeInfo.clientWidth=e,this._canvasSizeInfo.clientHeight=r,this._canvasSizeInfo.devicePixelRatio=A}}getDrawingBufferSize(){let A=this.device.gl;if(!A)throw new Error("canvas size");return[A.drawingBufferWidth,A.drawingBufferHeight]}_setAutoCreatedCanvasId(A){this.htmlCanvas?.id==="lumagl-auto-created-canvas"&&(this.htmlCanvas.id=A)}};I(G7,"pageLoaded",$J());function $J(){return EE()||typeof window>"u"?Promise.resolve():new Promise(t=>{window.addEventListener("load",()=>t())})}function xJ(t){if(typeof t=="string"){let A=document.getElementById(t);if(!A&&!EE())throw new Error(`Accessing '${t}' before page was loaded`);if(!A)throw new Error(`${t} is not an HTML element`);return A}else if(t)return t;return document.body}function yJ(t){let A=document.getElementById(t);if(!A&&!EE())throw new Error(`Accessing '${t}' before page was loaded`);if(!(A instanceof HTMLCanvasElement))throw new Error("Object is not a canvas element");return A}function vJ(t){let{width:A,height:j}=t,e=document.createElement("canvas");return e.id="lumagl-auto-created-canvas",e.width=A||1,e.height=j||1,e.style.width=Number.isFinite(A)?`${A}px`:"100%",e.style.height=Number.isFinite(j)?`${j}px`:"100%",e}function _J(t,A,j,e,r){let n=t,i=GT(n[0],A,j),o=wT(n[1],A,e,r),l=GT(n[0]+1,A,j),c=l===j-1?l:l-1;l=wT(n[1]+1,A,e,r);let B;return r?(l=l===0?l:l+1,B=o,o=l):B=l===e-1?l:l-1,{x:i,y:o,width:Math.max(c-i+1,1),height:Math.max(B-o+1,1)}}function GT(t,A,j){return Math.min(Math.round(t*A),j-1)}function wT(t,A,j,e){return e?Math.max(0,j-1-Math.round(t*A)):Math.min(Math.round(t*A),j-1)}var va=class va extends $t{constructor(j,e,r=va.defaultProps){super(j,e,r);I(this,"dimension");I(this,"format");I(this,"width");I(this,"height");I(this,"depth");I(this,"updateTimestamp");this.dimension=this.props.dimension,this.format=this.props.format,this.width=this.props.width,this.height=this.props.height,this.depth=this.props.depth,this.updateTimestamp=j.incrementTimestamp()}get[Symbol.toStringTag](){return"Texture"}};I(va,"defaultProps",{...$t.defaultProps,data:null,dimension:"2d",format:"rgba8unorm",width:void 0,height:void 0,depth:1,mipmaps:!0,compressed:!1,usage:0,mipLevels:void 0,samples:void 0,type:void 0,sampler:{},view:void 0}),I(va,"COPY_SRC",1),I(va,"COPY_DST",2),I(va,"TEXTURE_BINDING",4),I(va,"STORAGE_BINDING",8),I(va,"RENDER_ATTACHMENT",16);var Ne=va;var $E=class $E extends $t{get[Symbol.toStringTag](){return"TextureView"}constructor(A,j){super(A,j,$E.defaultProps)}};I($E,"defaultProps",{...$t.defaultProps,format:void 0,dimension:void 0,aspect:"all",baseMipLevel:0,mipLevelCount:void 0,baseArrayLayer:0,arrayLayerCount:void 0});var fc=$E;function PT(t,A,j){let e="",r=A.split(/\r?\n/),n=t.slice().sort((i,o)=>i.lineNum-o.lineNum);switch(j?.showSourceCode||"no"){case"all":let i=0;for(let o=1;o<=r.length;o++)for(e+=IT(r[o-1],o,j);n.length>i&&n[i].lineNum===o;){let l=n[i++];e+=FT(l,r,l.lineNum,{...j,inlineSource:!1})}return e;case"issues":case"no":for(let o of t)e+=FT(o,r,o.lineNum,{inlineSource:j?.showSourceCode!=="no"});return e}}function FT(t,A,j,e){if(e?.inlineSource){let r=qJ(A,j),n=t.linePos>0?`${" ".repeat(t.linePos+5)}^^^ `:"";return` ${r}${n}${t.type.toUpperCase()}: ${t.message} -`}return e?.html?`
${t.type.toUpperCase()}: ${t.message}
`:`${t.type.toUpperCase()}: ${t.message}`}function EJ(t,A,j){let e="";for(let r=A-2;r<=A;r++){let n=t[r-1];n!==void 0&&(e+=qT(n,A,j))}return e}function qT(t,A,j){let e=j?.html?xJ(t):t;return`${$J(String(A),4)}: ${e}${j?.html?"
":` -`}`}function $J(t,A){let j="";for(let e=t.length;e",">").replaceAll('"',""").replaceAll("'","'")}function QG(t,A){return{name:yJ(t,A),language:"glsl",version:vJ(t)}}function yJ(t,A="unnamed"){let e=/#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/.exec(t);return e?e[1]:A}function vJ(t){let A=100,j=t.match(/[^\s]+/g);if(j&&j.length>=2&&j[0]==="#version"){let e=parseInt(j[1],10);Number.isFinite(e)&&(A=e)}return A}var kE=class kE extends $t{constructor(j,e){super(j,{id:_J(e),...e},kE.defaultProps);I(this,"stage");I(this,"source");I(this,"compilationStatus","pending");this.stage=this.props.stage,this.source=this.props.source}get[Symbol.toStringTag](){return"Shader"}getCompilationInfoSync(){return null}getTranslatedSource(){return null}async debugShader(j=this.props.debug){switch(j){case"never":return;case"errors":if(this.compilationStatus==="success")return;break;case"warnings":case"always":break}let e=await this.getCompilationInfo();this.props.debug==="warnings"&&e?.length===0||this._displayShaderLog(e)}_displayShaderLog(j){if(typeof document>"u"||!document?.createElement)return;let e=QG(this.source).name,r=`${this.stage} ${e}`,n=_T(j,this.source,{showSourceCode:"all",html:!0}),i=this.getTranslatedSource();i&&(n+=`

Translated Source



${i}
`);let o=document.createElement("Button");o.innerHTML=` +`}return e?.html?`
${t.type.toUpperCase()}: ${t.message}
`:`${t.type.toUpperCase()}: ${t.message}`}function qJ(t,A,j){let e="";for(let r=A-2;r<=A;r++){let n=t[r-1];n!==void 0&&(e+=IT(n,A,j))}return e}function IT(t,A,j){let e=j?.html?GJ(t):t;return`${bJ(String(A),4)}: ${e}${j?.html?"
":` +`}`}function bJ(t,A){let j="";for(let e=t.length;e",">").replaceAll('"',""").replaceAll("'","'")}function AG(t,A){return{name:wJ(t,A),language:"glsl",version:FJ(t)}}function wJ(t,A="unnamed"){let e=/#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/.exec(t);return e?e[1]:A}function FJ(t){let A=100,j=t.match(/[^\s]+/g);if(j&&j.length>=2&&j[0]==="#version"){let e=parseInt(j[1],10);Number.isFinite(e)&&(A=e)}return A}var xE=class xE extends $t{constructor(j,e){super(j,{id:PJ(e),...e},xE.defaultProps);I(this,"stage");I(this,"source");I(this,"compilationStatus","pending");this.stage=this.props.stage,this.source=this.props.source}get[Symbol.toStringTag](){return"Shader"}getCompilationInfoSync(){return null}getTranslatedSource(){return null}async debugShader(j=this.props.debug){switch(j){case"never":return;case"errors":if(this.compilationStatus==="success")return;break;case"warnings":case"always":break}let e=await this.getCompilationInfo();this.props.debug==="warnings"&&e?.length===0||this._displayShaderLog(e)}_displayShaderLog(j){if(typeof document>"u"||!document?.createElement)return;let e=AG(this.source).name,r=`${this.stage} ${e}`,n=PT(j,this.source,{showSourceCode:"all",html:!0}),i=this.getTranslatedSource();i&&(n+=`

Translated Source



${i}
`);let o=document.createElement("Button");o.innerHTML=`

Shader Compilation Error in ${r}



 ${n}
-
`,o.style.top="10px",o.style.left="10px",o.style.position="absolute",o.style.zIndex="9999",o.style.width="100%",o.style.textAlign="left",document.body.appendChild(o);let l=document.getElementsByClassName("luma-compiler-log-error");l[0]?.scrollIntoView&&l[0].scrollIntoView(),o.onclick=()=>{let c=`data:text/plain,${encodeURIComponent(this.source)}`;navigator.clipboard.writeText(c)}}};I(kE,"defaultProps",{...$t.defaultProps,language:"auto",stage:void 0,source:"",sourceMap:null,entryPoint:"main",debug:"errors"});var fc=kE;function _J(t){return QG(t.source).name||t.id||Pn(`unnamed ${t.stage}-shader`)}var gE=class gE extends $t{get[Symbol.toStringTag](){return"Sampler"}constructor(A,j){super(A,j,gE.defaultProps)}};I(gE,"defaultProps",{...$t.defaultProps,type:"color-sampler",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge",addressModeW:"clamp-to-edge",magFilter:"nearest",minFilter:"nearest",mipmapFilter:"nearest",lodMinClamp:0,lodMaxClamp:32,compare:"less-equal",maxAnisotropy:1});var hc=gE;var mE=class mE extends $t{constructor(j,e={}){super(j,e,mE.defaultProps);I(this,"width");I(this,"height");I(this,"colorAttachments",[]);I(this,"depthStencilAttachment",null);this.width=this.props.width,this.height=this.props.height}get[Symbol.toStringTag](){return"Framebuffer"}resize(j){let e=!j;if(j){let[r,n]=Array.isArray(j)?j:[j.width,j.height];e=e||n!==this.height||r!==this.width,this.width=r,this.height=n}e&&(mA.log(2,`Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)(),this.resizeAttachments(this.width,this.height))}autoCreateAttachmentTextures(){if(this.props.colorAttachments.length===0&&!this.props.depthStencilAttachment)throw new Error("Framebuffer has noattachments");this.colorAttachments=this.props.colorAttachments.map(e=>{if(typeof e=="string"){let r=this.createColorTexture(e);return this.attachResource(r),r.view}return e instanceof Ne?e.view:e});let j=this.props.depthStencilAttachment;if(j)if(typeof j=="string"){let e=this.createDepthStencilTexture(j);this.attachResource(e),this.depthStencilAttachment=e.view}else j instanceof Ne?this.depthStencilAttachment=j.view:this.depthStencilAttachment=j}createColorTexture(j){return this.device.createTexture({id:"color-attachment",usage:Ne.RENDER_ATTACHMENT,format:j,width:this.width,height:this.height})}createDepthStencilTexture(j){return this.device.createTexture({id:"depth-stencil-attachment",usage:Ne.RENDER_ATTACHMENT,format:j,width:this.width,height:this.height})}resizeAttachments(j,e){for(let r=0;r":["f32",2],"vec3":["f32",3],"vec4":["f32",4],f16:["f16",1],"vec2":["f16",2],"vec3":["f16",3],"vec4":["f16",4],i32:["i32",1],"vec2":["i32",2],"vec3":["i32",3],"vec4":["i32",4],u32:["u32",1],"vec2":["u32",2],"vec3":["u32",3],"vec4":["u32",4]},bJ={f32:4,f16:2,i32:4,u32:4};function WG(t){let A;t.endsWith("-webgl")&&(t.replace("-webgl",""),A=!0);let[j,e]=t.split("x"),r=j,n=e?parseInt(e):1,i=fE(r),o={type:r,components:n,byteLength:i.byteLength*n,integer:i.integer,signed:i.signed,normalized:i.normalized};return A&&(o.webglOnly=!0),o}function _E(t,A){let j={};for(let e of t.attributes)j[e.name]=wJ(t,A,e.name);return j}function bT(t,A,j=16){let e=_E(t,A),r=new Array(j).fill(null);for(let n of Object.values(e))r[n.location]=n;return r}function wJ(t,A,j){let e=FJ(t,j),r=PJ(A,j);if(!e)return null;let n=GT(e.type),i=r?.vertexFormat||n.defaultVertexFormat,o=WG(i);return{attributeName:r?.attributeName||e.name,bufferName:r?.bufferName||e.name,location:e.location,shaderType:e.type,shaderDataType:n.dataType,shaderComponents:n.components,vertexFormat:i,bufferDataType:o.type,bufferComponents:o.components,normalized:o.normalized,integer:n.integer,stepMode:r?.stepMode||e.stepMode,byteOffset:r?.byteOffset||0,byteStride:r?.byteStride||0}}function FJ(t,A){let j=t.attributes.find(e=>e.name===A);return j||mA.warn(`shader layout attribute "${A}" not present in shader`),j||null}function PJ(t,A){IJ(t);let j=MJ(t,A);return j||(j=OJ(t,A),j)?j:(mA.warn(`layout for attribute "${A}" not present in buffer layout`),null)}function IJ(t){for(let A of t)(A.attributes&&A.format||!A.attributes&&!A.format)&&mA.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`)}function MJ(t,A){for(let j of t)if(j.format&&j.name===A)return{attributeName:j.name,bufferName:A,stepMode:j.stepMode,vertexFormat:j.format,byteOffset:0,byteStride:j.byteStride||0};return null}function OJ(t,A){for(let j of t){let e=j.byteStride;if(typeof j.byteStride!="number")for(let n of j.attributes||[]){let i=WG(n.format);e+=i.byteLength}let r=j.attributes?.find(n=>n.attribute===A);if(r)return{attributeName:r.attribute,bufferName:j.name,stepMode:j.stepMode,vertexFormat:r.format,byteOffset:r.byteOffset,byteStride:e}}return null}function YG(t,A){let j={...t,attributes:t.attributes.map(e=>({...e}))};for(let e of A?.attributes||[]){let r=j.attributes.find(n=>n.name===e.name);r?(r.type=e.type||r.type,r.stepMode=e.stepMode||r.stepMode):mA.warn(`shader layout attribute ${e.name} not present in shader`)}return j}var qE=class qE extends $t{constructor(j,e){super(j,e,qE.defaultProps);I(this,"maxVertexAttributes");I(this,"attributeInfos");I(this,"indexBuffer",null);I(this,"attributes");this.maxVertexAttributes=j.limits.maxVertexAttributes,this.attributes=new Array(this.maxVertexAttributes).fill(null),this.attributeInfos=bT(e.renderPipeline.shaderLayout,e.renderPipeline.bufferLayout,this.maxVertexAttributes)}get[Symbol.toStringTag](){return"VertexArray"}setConstantWebGL(j,e){throw new Error("constant attributes not supported")}};I(qE,"defaultProps",{...$t.defaultProps,renderPipeline:null});var Yd=qE;var GE=class GE extends $t{get[Symbol.toStringTag](){return"TransformFeedback"}constructor(A,j){super(A,j,GE.defaultProps)}};I(GE,"defaultProps",{...$t.defaultProps,layout:void 0,buffers:{}});var Jd=GE;var bE=class bE extends $t{get[Symbol.toStringTag](){return"QuerySet"}constructor(A,j){super(A,j,bE.defaultProps)}};I(bE,"defaultProps",{...$t.defaultProps,type:void 0,count:void 0});var Zd=bE;var TJ={f32:{type:"f32",components:1},i32:{type:"i32",components:1},u32:{type:"u32",components:1},"vec2":{type:"f32",components:2},"vec3":{type:"f32",components:3},"vec4":{type:"f32",components:4},"vec2":{type:"i32",components:2},"vec3":{type:"i32",components:3},"vec4":{type:"i32",components:4},"vec2":{type:"u32",components:2},"vec3":{type:"u32",components:3},"vec4":{type:"u32",components:4},"mat2x2":{type:"f32",components:4},"mat2x3":{type:"f32",components:6},"mat2x4":{type:"f32",components:8},"mat3x2":{type:"f32",components:6},"mat3x3":{type:"f32",components:9},"mat3x4":{type:"f32",components:12},"mat4x2":{type:"f32",components:8},"mat4x3":{type:"f32",components:12},"mat4x4":{type:"f32",components:16}};function wT(t){let A=TJ[t];return Ot(t),A}function FT(t,A){switch(A){case 1:return t;case 2:return t+t%2;default:return t+(4-t%4)%4}}var wE;function FE(t){return(!wE||wE.byteLengthr.type==="uniform"&&r.name===A?.name);if(!j)throw new Error(A?.name);let e=j;for(let r of e.uniforms||[])this.bindingLayout[r.name]=r}}setUniforms(A){for(let[j,e]of Object.entries(A))this._setUniform(j,e),this.needsRedraw||this.setNeedsRedraw(`${this.name}.${j}=${e}`)}setNeedsRedraw(A){this.needsRedraw=this.needsRedraw||A}getAllUniforms(){return this.modifiedUniforms={},this.needsRedraw=!1,this.uniforms||{}}_setUniform(A,j){IT(this.uniforms[A],j)||(this.uniforms[A]=MT(j),this.modifiedUniforms[A]=!0,this.modified=!0)}};var Ap=class{constructor(A){I(this,"uniformBlocks",new Map);I(this,"uniformBufferLayouts",new Map);I(this,"uniformBuffers",new Map);for(let[j,e]of Object.entries(A)){let r=j,n=new PE(e.uniformTypes||{});this.uniformBufferLayouts.set(r,n);let i=new IE({name:j});i.setUniforms(e.defaultUniforms||{}),this.uniformBlocks.set(r,i)}}destroy(){for(let A of this.uniformBuffers.values())A.destroy()}setUniforms(A){for(let[j,e]of Object.entries(A))this.uniformBlocks.get(j).setUniforms(e);this.updateUniformBuffers()}getUniformBufferByteLength(A){return this.uniformBufferLayouts.get(A).byteLength}getUniformBufferData(A){let j=this.uniformBlocks.get(A).getAllUniforms();return this.uniformBufferLayouts.get(A).getData(j)}createUniformBuffer(A,j,e){e&&this.setUniforms(e);let r=this.getUniformBufferByteLength(j),n=A.createBuffer({usage:Aj.UNIFORM|Aj.COPY_DST,byteLength:r}),i=this.getUniformBufferData(j);return n.write(i),n}getManagedUniformBuffer(A,j){if(!this.uniformBuffers.get(j)){let e=this.getUniformBufferByteLength(j),r=A.createBuffer({usage:Aj.UNIFORM|Aj.COPY_DST,byteLength:e});this.uniformBuffers.set(j,r)}return this.uniformBuffers.get(j)}updateUniformBuffers(){let A=!1;for(let j of this.uniformBlocks.keys()){let e=this.updateUniformBuffer(j);A||(A=e)}return A&&mA.log(3,`UniformStore.updateUniformBuffers(): ${A}`)(),A}updateUniformBuffer(A){let j=this.uniformBlocks.get(A),e=this.uniformBuffers.get(A),r=!1;if(e&&j.needsRedraw){r||(r=j.needsRedraw);let n=this.getUniformBufferData(A);this.uniformBuffers.get(A).write(n);let o=this.uniformBlocks.get(A).getAllUniforms();mA.log(4,`Writing to uniform buffer ${String(A)}`,n,o)()}return r}};function ME(t){let A=ArrayBuffer.isView(t)?t.constructor:t;switch(A){case Float32Array:return"float32";case Uint16Array:return"uint16";case Uint32Array:return"uint32";case Uint8Array:case Uint8ClampedArray:return"uint8";case Int8Array:return"sint8";case Int16Array:return"sint16";case Int32Array:return"sint32";default:throw new Error(A.constructor.name)}}function tp(t){switch(t){case"float32":return Float32Array;case"uint32":return Uint32Array;case"sint32":return Int32Array;case"uint16":case"unorm16":return Uint16Array;case"sint16":case"snorm16":return Int16Array;case"uint8":case"unorm8":return Uint8Array;case"sint8":case"snorm8":return Int8Array;default:throw new Error(t)}}function Ab(t,A,j){if(!A||A>4)throw new Error(`size ${A}`);let e=A,r=ME(t);if(r==="uint8"&&j&&e===1)return"unorm8-webgl";if(r==="uint8"&&j&&e===3)return"unorm8x3-webgl";if(r==="uint8"||r==="sint8"){if(e===1||e===3)throw new Error(`size: ${A}`);return j&&(r=r.replace("int","norm")),`${r}x${e}`}if(r==="uint16"||r==="sint16"){if(e===1||e===3)throw new Error(`size: ${A}`);return j&&(r=r.replace("int","norm")),`${r}x${e}`}return e===1?r:`${r}x${e}`}function OT(t){return q7(t)!==null||typeof t=="number"||typeof t=="boolean"}function pc(t){let A={bindings:{},uniforms:{}};return Object.keys(t).forEach(j=>{let e=t[j];OT(e)?A.uniforms[j]=e:A.bindings[j]=e}),A}function tb(t,A,j){let{removedProps:e={},deprecatedProps:r={},replacedProps:n={}}=j;for(let o in e)if(o in A){let c=e[o]?`${t}.${e[o]}`:"N/A";mA.removed(`${t}.${o}`,c)()}for(let o in r)if(o in A){let l=r[o];mA.deprecated(`${t}.${o}`,`${t}.${l}`)()}let i=null;for(let[o,l]of Object.entries(n))o in A&&(mA.deprecated(`${t}.${o}`,`${t}.${l}`)(),i=i||Object.assign({},A),i[l]=A[o],delete i[o]);return i||A}var SJ="";async function jb(t,A){return await new Promise((j,e)=>{try{let r=new Image;r.onload=()=>j(r),r.onerror=()=>e(new Error(`Could not load image ${t}.`)),r.crossOrigin=A?.crossOrigin||"anonymous",r.src=t.startsWith("http")?t:SJ+t}catch(r){e(r)}})}async function jp(t,A){let j=document.getElementsByTagName("head")[0];if(!j)throw new Error("loadScript");let e=document.createElement("script");return e.setAttribute("type","text/javascript"),e.setAttribute("src",t),A&&(e.id=A),new Promise((r,n)=>{e.onload=r,e.onerror=i=>n(new Error(`Unable to load script '${t}': ${i}`)),j.appendChild(e)})}function ep(t,A,j){if(t===A)return!0;if(!j||!t||!A)return!1;if(Array.isArray(t)){if(!Array.isArray(A)||t.length!==A.length)return!1;for(let e=0;e":return this.left.evaluate(A)>this.right.evaluate(A)?1:0;case"<=":return this.left.evaluate(A)<=this.right.evaluate(A)?1:0;case">=":return this.left.evaluate(A)>=this.right.evaluate(A)?1:0;case"&&":return this.left.evaluate(A)&&this.right.evaluate(A)?1:0;case"||":return this.left.evaluate(A)||this.right.evaluate(A)?1:0;default:throw new Error(`Unknown operator ${this.operator}`)}}search(A){this.left.search(A),this.right.search(A)}},zE=class extends co{constructor(){super()}},qb=class extends zE{constructor(A,j){super(),this.selector=A,this.body=j}get astNodeType(){return"case"}search(A){this.searchBlock(this.body,A)}},Gb=class extends zE{constructor(A){super(),this.body=A}get astNodeType(){return"default"}search(A){this.searchBlock(this.body,A)}},bb=class extends co{constructor(A,j,e){super(),this.name=A,this.type=j,this.attributes=e}get astNodeType(){return"argument"}},wb=class extends co{constructor(A,j){super(),this.condition=A,this.body=j}get astNodeType(){return"elseif"}search(A){this.condition.search(A),this.searchBlock(this.body,A)}},Fb=class extends co{constructor(A,j,e){super(),this.name=A,this.type=j,this.attributes=e}get astNodeType(){return"member"}},Pb=class extends co{constructor(A,j){super(),this.name=A,this.value=j}get astNodeType(){return"attribute"}},iA,tA;(function(t){t[t.token=0]="token",t[t.keyword=1]="keyword",t[t.reserved=2]="reserved"})(tA||(tA={}));var AA=class{constructor(A,j,e){this.name=A,this.type=j,this.rule=e}toString(){return this.name}},X=class{};iA=X;X.none=new AA("",tA.reserved,"");X.eof=new AA("EOF",tA.token,"");X.reserved={asm:new AA("asm",tA.reserved,"asm"),bf16:new AA("bf16",tA.reserved,"bf16"),do:new AA("do",tA.reserved,"do"),enum:new AA("enum",tA.reserved,"enum"),f16:new AA("f16",tA.reserved,"f16"),f64:new AA("f64",tA.reserved,"f64"),handle:new AA("handle",tA.reserved,"handle"),i8:new AA("i8",tA.reserved,"i8"),i16:new AA("i16",tA.reserved,"i16"),i64:new AA("i64",tA.reserved,"i64"),mat:new AA("mat",tA.reserved,"mat"),premerge:new AA("premerge",tA.reserved,"premerge"),regardless:new AA("regardless",tA.reserved,"regardless"),typedef:new AA("typedef",tA.reserved,"typedef"),u8:new AA("u8",tA.reserved,"u8"),u16:new AA("u16",tA.reserved,"u16"),u64:new AA("u64",tA.reserved,"u64"),unless:new AA("unless",tA.reserved,"unless"),using:new AA("using",tA.reserved,"using"),vec:new AA("vec",tA.reserved,"vec"),void:new AA("void",tA.reserved,"void")};X.keywords={array:new AA("array",tA.keyword,"array"),atomic:new AA("atomic",tA.keyword,"atomic"),bool:new AA("bool",tA.keyword,"bool"),f32:new AA("f32",tA.keyword,"f32"),i32:new AA("i32",tA.keyword,"i32"),mat2x2:new AA("mat2x2",tA.keyword,"mat2x2"),mat2x3:new AA("mat2x3",tA.keyword,"mat2x3"),mat2x4:new AA("mat2x4",tA.keyword,"mat2x4"),mat3x2:new AA("mat3x2",tA.keyword,"mat3x2"),mat3x3:new AA("mat3x3",tA.keyword,"mat3x3"),mat3x4:new AA("mat3x4",tA.keyword,"mat3x4"),mat4x2:new AA("mat4x2",tA.keyword,"mat4x2"),mat4x3:new AA("mat4x3",tA.keyword,"mat4x3"),mat4x4:new AA("mat4x4",tA.keyword,"mat4x4"),ptr:new AA("ptr",tA.keyword,"ptr"),sampler:new AA("sampler",tA.keyword,"sampler"),sampler_comparison:new AA("sampler_comparison",tA.keyword,"sampler_comparison"),struct:new AA("struct",tA.keyword,"struct"),texture_1d:new AA("texture_1d",tA.keyword,"texture_1d"),texture_2d:new AA("texture_2d",tA.keyword,"texture_2d"),texture_2d_array:new AA("texture_2d_array",tA.keyword,"texture_2d_array"),texture_3d:new AA("texture_3d",tA.keyword,"texture_3d"),texture_cube:new AA("texture_cube",tA.keyword,"texture_cube"),texture_cube_array:new AA("texture_cube_array",tA.keyword,"texture_cube_array"),texture_multisampled_2d:new AA("texture_multisampled_2d",tA.keyword,"texture_multisampled_2d"),texture_storage_1d:new AA("texture_storage_1d",tA.keyword,"texture_storage_1d"),texture_storage_2d:new AA("texture_storage_2d",tA.keyword,"texture_storage_2d"),texture_storage_2d_array:new AA("texture_storage_2d_array",tA.keyword,"texture_storage_2d_array"),texture_storage_3d:new AA("texture_storage_3d",tA.keyword,"texture_storage_3d"),texture_depth_2d:new AA("texture_depth_2d",tA.keyword,"texture_depth_2d"),texture_depth_2d_array:new AA("texture_depth_2d_array",tA.keyword,"texture_depth_2d_array"),texture_depth_cube:new AA("texture_depth_cube",tA.keyword,"texture_depth_cube"),texture_depth_cube_array:new AA("texture_depth_cube_array",tA.keyword,"texture_depth_cube_array"),texture_depth_multisampled_2d:new AA("texture_depth_multisampled_2d",tA.keyword,"texture_depth_multisampled_2d"),texture_external:new AA("texture_external",tA.keyword,"texture_external"),u32:new AA("u32",tA.keyword,"u32"),vec2:new AA("vec2",tA.keyword,"vec2"),vec3:new AA("vec3",tA.keyword,"vec3"),vec4:new AA("vec4",tA.keyword,"vec4"),bitcast:new AA("bitcast",tA.keyword,"bitcast"),block:new AA("block",tA.keyword,"block"),break:new AA("break",tA.keyword,"break"),case:new AA("case",tA.keyword,"case"),continue:new AA("continue",tA.keyword,"continue"),continuing:new AA("continuing",tA.keyword,"continuing"),default:new AA("default",tA.keyword,"default"),diagnostic:new AA("diagnostic",tA.keyword,"diagnostic"),discard:new AA("discard",tA.keyword,"discard"),else:new AA("else",tA.keyword,"else"),enable:new AA("enable",tA.keyword,"enable"),fallthrough:new AA("fallthrough",tA.keyword,"fallthrough"),false:new AA("false",tA.keyword,"false"),fn:new AA("fn",tA.keyword,"fn"),for:new AA("for",tA.keyword,"for"),function:new AA("function",tA.keyword,"function"),if:new AA("if",tA.keyword,"if"),let:new AA("let",tA.keyword,"let"),const:new AA("const",tA.keyword,"const"),loop:new AA("loop",tA.keyword,"loop"),while:new AA("while",tA.keyword,"while"),private:new AA("private",tA.keyword,"private"),read:new AA("read",tA.keyword,"read"),read_write:new AA("read_write",tA.keyword,"read_write"),return:new AA("return",tA.keyword,"return"),requires:new AA("requires",tA.keyword,"requires"),storage:new AA("storage",tA.keyword,"storage"),switch:new AA("switch",tA.keyword,"switch"),true:new AA("true",tA.keyword,"true"),alias:new AA("alias",tA.keyword,"alias"),type:new AA("type",tA.keyword,"type"),uniform:new AA("uniform",tA.keyword,"uniform"),var:new AA("var",tA.keyword,"var"),override:new AA("override",tA.keyword,"override"),workgroup:new AA("workgroup",tA.keyword,"workgroup"),write:new AA("write",tA.keyword,"write"),r8unorm:new AA("r8unorm",tA.keyword,"r8unorm"),r8snorm:new AA("r8snorm",tA.keyword,"r8snorm"),r8uint:new AA("r8uint",tA.keyword,"r8uint"),r8sint:new AA("r8sint",tA.keyword,"r8sint"),r16uint:new AA("r16uint",tA.keyword,"r16uint"),r16sint:new AA("r16sint",tA.keyword,"r16sint"),r16float:new AA("r16float",tA.keyword,"r16float"),rg8unorm:new AA("rg8unorm",tA.keyword,"rg8unorm"),rg8snorm:new AA("rg8snorm",tA.keyword,"rg8snorm"),rg8uint:new AA("rg8uint",tA.keyword,"rg8uint"),rg8sint:new AA("rg8sint",tA.keyword,"rg8sint"),r32uint:new AA("r32uint",tA.keyword,"r32uint"),r32sint:new AA("r32sint",tA.keyword,"r32sint"),r32float:new AA("r32float",tA.keyword,"r32float"),rg16uint:new AA("rg16uint",tA.keyword,"rg16uint"),rg16sint:new AA("rg16sint",tA.keyword,"rg16sint"),rg16float:new AA("rg16float",tA.keyword,"rg16float"),rgba8unorm:new AA("rgba8unorm",tA.keyword,"rgba8unorm"),rgba8unorm_srgb:new AA("rgba8unorm_srgb",tA.keyword,"rgba8unorm_srgb"),rgba8snorm:new AA("rgba8snorm",tA.keyword,"rgba8snorm"),rgba8uint:new AA("rgba8uint",tA.keyword,"rgba8uint"),rgba8sint:new AA("rgba8sint",tA.keyword,"rgba8sint"),bgra8unorm:new AA("bgra8unorm",tA.keyword,"bgra8unorm"),bgra8unorm_srgb:new AA("bgra8unorm_srgb",tA.keyword,"bgra8unorm_srgb"),rgb10a2unorm:new AA("rgb10a2unorm",tA.keyword,"rgb10a2unorm"),rg11b10float:new AA("rg11b10float",tA.keyword,"rg11b10float"),rg32uint:new AA("rg32uint",tA.keyword,"rg32uint"),rg32sint:new AA("rg32sint",tA.keyword,"rg32sint"),rg32float:new AA("rg32float",tA.keyword,"rg32float"),rgba16uint:new AA("rgba16uint",tA.keyword,"rgba16uint"),rgba16sint:new AA("rgba16sint",tA.keyword,"rgba16sint"),rgba16float:new AA("rgba16float",tA.keyword,"rgba16float"),rgba32uint:new AA("rgba32uint",tA.keyword,"rgba32uint"),rgba32sint:new AA("rgba32sint",tA.keyword,"rgba32sint"),rgba32float:new AA("rgba32float",tA.keyword,"rgba32float"),static_assert:new AA("static_assert",tA.keyword,"static_assert")};X.tokens={decimal_float_literal:new AA("decimal_float_literal",tA.token,/((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/),hex_float_literal:new AA("hex_float_literal",tA.token,/-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),int_literal:new AA("int_literal",tA.token,/-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),uint_literal:new AA("uint_literal",tA.token,/0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),ident:new AA("ident",tA.token,/[_a-zA-Z][0-9a-zA-Z_]*/),and:new AA("and",tA.token,"&"),and_and:new AA("and_and",tA.token,"&&"),arrow:new AA("arrow ",tA.token,"->"),attr:new AA("attr",tA.token,"@"),forward_slash:new AA("forward_slash",tA.token,"/"),bang:new AA("bang",tA.token,"!"),bracket_left:new AA("bracket_left",tA.token,"["),bracket_right:new AA("bracket_right",tA.token,"]"),brace_left:new AA("brace_left",tA.token,"{"),brace_right:new AA("brace_right",tA.token,"}"),colon:new AA("colon",tA.token,":"),comma:new AA("comma",tA.token,","),equal:new AA("equal",tA.token,"="),equal_equal:new AA("equal_equal",tA.token,"=="),not_equal:new AA("not_equal",tA.token,"!="),greater_than:new AA("greater_than",tA.token,">"),greater_than_equal:new AA("greater_than_equal",tA.token,">="),shift_right:new AA("shift_right",tA.token,">>"),less_than:new AA("less_than",tA.token,"<"),less_than_equal:new AA("less_than_equal",tA.token,"<="),shift_left:new AA("shift_left",tA.token,"<<"),modulo:new AA("modulo",tA.token,"%"),minus:new AA("minus",tA.token,"-"),minus_minus:new AA("minus_minus",tA.token,"--"),period:new AA("period",tA.token,"."),plus:new AA("plus",tA.token,"+"),plus_plus:new AA("plus_plus",tA.token,"++"),or:new AA("or",tA.token,"|"),or_or:new AA("or_or",tA.token,"||"),paren_left:new AA("paren_left",tA.token,"("),paren_right:new AA("paren_right",tA.token,")"),semicolon:new AA("semicolon",tA.token,";"),star:new AA("star",tA.token,"*"),tilde:new AA("tilde",tA.token,"~"),underscore:new AA("underscore",tA.token,"_"),xor:new AA("xor",tA.token,"^"),plus_equal:new AA("plus_equal",tA.token,"+="),minus_equal:new AA("minus_equal",tA.token,"-="),times_equal:new AA("times_equal",tA.token,"*="),division_equal:new AA("division_equal",tA.token,"/="),modulo_equal:new AA("modulo_equal",tA.token,"%="),and_equal:new AA("and_equal",tA.token,"&="),or_equal:new AA("or_equal",tA.token,"|="),xor_equal:new AA("xor_equal",tA.token,"^="),shift_right_equal:new AA("shift_right_equal",tA.token,">>="),shift_left_equal:new AA("shift_left_equal",tA.token,"<<=")};X.simpleTokens={"@":iA.tokens.attr,"{":iA.tokens.brace_left,"}":iA.tokens.brace_right,":":iA.tokens.colon,",":iA.tokens.comma,"(":iA.tokens.paren_left,")":iA.tokens.paren_right,";":iA.tokens.semicolon};X.literalTokens={"&":iA.tokens.and,"&&":iA.tokens.and_and,"->":iA.tokens.arrow,"/":iA.tokens.forward_slash,"!":iA.tokens.bang,"[":iA.tokens.bracket_left,"]":iA.tokens.bracket_right,"=":iA.tokens.equal,"==":iA.tokens.equal_equal,"!=":iA.tokens.not_equal,">":iA.tokens.greater_than,">=":iA.tokens.greater_than_equal,">>":iA.tokens.shift_right,"<":iA.tokens.less_than,"<=":iA.tokens.less_than_equal,"<<":iA.tokens.shift_left,"%":iA.tokens.modulo,"-":iA.tokens.minus,"--":iA.tokens.minus_minus,".":iA.tokens.period,"+":iA.tokens.plus,"++":iA.tokens.plus_plus,"|":iA.tokens.or,"||":iA.tokens.or_or,"*":iA.tokens.star,"~":iA.tokens.tilde,_:iA.tokens.underscore,"^":iA.tokens.xor,"+=":iA.tokens.plus_equal,"-=":iA.tokens.minus_equal,"*=":iA.tokens.times_equal,"/=":iA.tokens.division_equal,"%=":iA.tokens.modulo_equal,"&=":iA.tokens.and_equal,"|=":iA.tokens.or_equal,"^=":iA.tokens.xor_equal,">>=":iA.tokens.shift_right_equal,"<<=":iA.tokens.shift_left_equal};X.regexTokens={decimal_float_literal:iA.tokens.decimal_float_literal,hex_float_literal:iA.tokens.hex_float_literal,int_literal:iA.tokens.int_literal,uint_literal:iA.tokens.uint_literal,ident:iA.tokens.ident};X.storage_class=[iA.keywords.function,iA.keywords.private,iA.keywords.workgroup,iA.keywords.uniform,iA.keywords.storage];X.access_mode=[iA.keywords.read,iA.keywords.write,iA.keywords.read_write];X.sampler_type=[iA.keywords.sampler,iA.keywords.sampler_comparison];X.sampled_texture_type=[iA.keywords.texture_1d,iA.keywords.texture_2d,iA.keywords.texture_2d_array,iA.keywords.texture_3d,iA.keywords.texture_cube,iA.keywords.texture_cube_array];X.multisampled_texture_type=[iA.keywords.texture_multisampled_2d];X.storage_texture_type=[iA.keywords.texture_storage_1d,iA.keywords.texture_storage_2d,iA.keywords.texture_storage_2d_array,iA.keywords.texture_storage_3d];X.depth_texture_type=[iA.keywords.texture_depth_2d,iA.keywords.texture_depth_2d_array,iA.keywords.texture_depth_cube,iA.keywords.texture_depth_cube_array,iA.keywords.texture_depth_multisampled_2d];X.texture_external_type=[iA.keywords.texture_external];X.any_texture_type=[...iA.sampled_texture_type,...iA.multisampled_texture_type,...iA.storage_texture_type,...iA.depth_texture_type,...iA.texture_external_type];X.texel_format=[iA.keywords.r8unorm,iA.keywords.r8snorm,iA.keywords.r8uint,iA.keywords.r8sint,iA.keywords.r16uint,iA.keywords.r16sint,iA.keywords.r16float,iA.keywords.rg8unorm,iA.keywords.rg8snorm,iA.keywords.rg8uint,iA.keywords.rg8sint,iA.keywords.r32uint,iA.keywords.r32sint,iA.keywords.r32float,iA.keywords.rg16uint,iA.keywords.rg16sint,iA.keywords.rg16float,iA.keywords.rgba8unorm,iA.keywords.rgba8unorm_srgb,iA.keywords.rgba8snorm,iA.keywords.rgba8uint,iA.keywords.rgba8sint,iA.keywords.bgra8unorm,iA.keywords.bgra8unorm_srgb,iA.keywords.rgb10a2unorm,iA.keywords.rg11b10float,iA.keywords.rg32uint,iA.keywords.rg32sint,iA.keywords.rg32float,iA.keywords.rgba16uint,iA.keywords.rgba16sint,iA.keywords.rgba16float,iA.keywords.rgba32uint,iA.keywords.rgba32sint,iA.keywords.rgba32float];X.const_literal=[iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.decimal_float_literal,iA.tokens.hex_float_literal,iA.keywords.true,iA.keywords.false];X.literal_or_ident=[iA.tokens.ident,iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.decimal_float_literal,iA.tokens.hex_float_literal];X.element_count_expression=[iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.ident];X.template_types=[iA.keywords.vec2,iA.keywords.vec3,iA.keywords.vec4,iA.keywords.mat2x2,iA.keywords.mat2x3,iA.keywords.mat2x4,iA.keywords.mat3x2,iA.keywords.mat3x3,iA.keywords.mat3x4,iA.keywords.mat4x2,iA.keywords.mat4x3,iA.keywords.mat4x4,iA.keywords.atomic,iA.keywords.bitcast,...iA.any_texture_type];X.attribute_name=[iA.tokens.ident,iA.keywords.block,iA.keywords.diagnostic];X.assignment_operators=[iA.tokens.equal,iA.tokens.plus_equal,iA.tokens.minus_equal,iA.tokens.times_equal,iA.tokens.division_equal,iA.tokens.modulo_equal,iA.tokens.and_equal,iA.tokens.or_equal,iA.tokens.xor_equal,iA.tokens.shift_right_equal,iA.tokens.shift_left_equal];X.increment_operators=[iA.tokens.plus_plus,iA.tokens.minus_minus];var UE=class{constructor(A,j,e){this.type=A,this.lexeme=j,this.line=e}toString(){return this.lexeme}isTemplateType(){return X.template_types.indexOf(this.type)!=-1}isArrayType(){return this.type==X.keywords.array}isArrayOrTemplateType(){return this.isArrayType()||this.isTemplateType()}},Ib=class{constructor(A){this._tokens=[],this._start=0,this._current=0,this._line=1,this._source=A??""}scanTokens(){for(;!this._isAtEnd();)if(this._start=this._current,!this.scanToken())throw`Invalid syntax at line ${this._line}`;return this._tokens.push(new UE(X.eof,"",this._line)),this._tokens}scanToken(){let A=this._advance();if(A==` +`,o.style.top="10px",o.style.left="10px",o.style.position="absolute",o.style.zIndex="9999",o.style.width="100%",o.style.textAlign="left",document.body.appendChild(o);let l=document.getElementsByClassName("luma-compiler-log-error");l[0]?.scrollIntoView&&l[0].scrollIntoView(),o.onclick=()=>{let c=`data:text/plain,${encodeURIComponent(this.source)}`;navigator.clipboard.writeText(c)}}};I(xE,"defaultProps",{...$t.defaultProps,language:"auto",stage:void 0,source:"",sourceMap:null,entryPoint:"main",debug:"errors"});var hc=xE;function PJ(t){return AG(t.source).name||t.id||Pn(`unnamed ${t.stage}-shader`)}var yE=class yE extends $t{get[Symbol.toStringTag](){return"Sampler"}constructor(A,j){super(A,j,yE.defaultProps)}};I(yE,"defaultProps",{...$t.defaultProps,type:"color-sampler",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge",addressModeW:"clamp-to-edge",magFilter:"nearest",minFilter:"nearest",mipmapFilter:"nearest",lodMinClamp:0,lodMaxClamp:32,compare:"less-equal",maxAnisotropy:1});var dc=yE;var vE=class vE extends $t{constructor(j,e={}){super(j,e,vE.defaultProps);I(this,"width");I(this,"height");I(this,"colorAttachments",[]);I(this,"depthStencilAttachment",null);this.width=this.props.width,this.height=this.props.height}get[Symbol.toStringTag](){return"Framebuffer"}resize(j){let e=!j;if(j){let[r,n]=Array.isArray(j)?j:[j.width,j.height];e=e||n!==this.height||r!==this.width,this.width=r,this.height=n}e&&(mA.log(2,`Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)(),this.resizeAttachments(this.width,this.height))}autoCreateAttachmentTextures(){if(this.props.colorAttachments.length===0&&!this.props.depthStencilAttachment)throw new Error("Framebuffer has noattachments");this.colorAttachments=this.props.colorAttachments.map(e=>{if(typeof e=="string"){let r=this.createColorTexture(e);return this.attachResource(r),r.view}return e instanceof Ne?e.view:e});let j=this.props.depthStencilAttachment;if(j)if(typeof j=="string"){let e=this.createDepthStencilTexture(j);this.attachResource(e),this.depthStencilAttachment=e.view}else j instanceof Ne?this.depthStencilAttachment=j.view:this.depthStencilAttachment=j}createColorTexture(j){return this.device.createTexture({id:"color-attachment",usage:Ne.RENDER_ATTACHMENT,format:j,width:this.width,height:this.height})}createDepthStencilTexture(j){return this.device.createTexture({id:"depth-stencil-attachment",usage:Ne.RENDER_ATTACHMENT,format:j,width:this.width,height:this.height})}resizeAttachments(j,e){for(let r=0;r":["f32",2],"vec3":["f32",3],"vec4":["f32",4],f16:["f16",1],"vec2":["f16",2],"vec3":["f16",3],"vec4":["f16",4],i32:["i32",1],"vec2":["i32",2],"vec3":["i32",3],"vec4":["i32",4],u32:["u32",1],"vec2":["u32",2],"vec3":["u32",3],"vec4":["u32",4]},OJ={f32:4,f16:2,i32:4,u32:4};function tG(t){let A;t.endsWith("-webgl")&&(t.replace("-webgl",""),A=!0);let[j,e]=t.split("x"),r=j,n=e?parseInt(e):1,i=gE(r),o={type:r,components:n,byteLength:i.byteLength*n,integer:i.integer,signed:i.signed,normalized:i.normalized};return A&&(o.webglOnly=!0),o}function FE(t,A){let j={};for(let e of t.attributes)j[e.name]=TJ(t,A,e.name);return j}function OT(t,A,j=16){let e=FE(t,A),r=new Array(j).fill(null);for(let n of Object.values(e))r[n.location]=n;return r}function TJ(t,A,j){let e=SJ(t,j),r=RJ(A,j);if(!e)return null;let n=MT(e.type),i=r?.vertexFormat||n.defaultVertexFormat,o=tG(i);return{attributeName:r?.attributeName||e.name,bufferName:r?.bufferName||e.name,location:e.location,shaderType:e.type,shaderDataType:n.dataType,shaderComponents:n.components,vertexFormat:i,bufferDataType:o.type,bufferComponents:o.components,normalized:o.normalized,integer:n.integer,stepMode:r?.stepMode||e.stepMode,byteOffset:r?.byteOffset||0,byteStride:r?.byteStride||0}}function SJ(t,A){let j=t.attributes.find(e=>e.name===A);return j||mA.warn(`shader layout attribute "${A}" not present in shader`),j||null}function RJ(t,A){LJ(t);let j=CJ(t,A);return j||(j=HJ(t,A),j)?j:(mA.warn(`layout for attribute "${A}" not present in buffer layout`),null)}function LJ(t){for(let A of t)(A.attributes&&A.format||!A.attributes&&!A.format)&&mA.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`)}function CJ(t,A){for(let j of t)if(j.format&&j.name===A)return{attributeName:j.name,bufferName:A,stepMode:j.stepMode,vertexFormat:j.format,byteOffset:0,byteStride:j.byteStride||0};return null}function HJ(t,A){for(let j of t){let e=j.byteStride;if(typeof j.byteStride!="number")for(let n of j.attributes||[]){let i=tG(n.format);e+=i.byteLength}let r=j.attributes?.find(n=>n.attribute===A);if(r)return{attributeName:r.attribute,bufferName:j.name,stepMode:j.stepMode,vertexFormat:r.format,byteOffset:r.byteOffset,byteStride:e}}return null}function jG(t,A){let j={...t,attributes:t.attributes.map(e=>({...e}))};for(let e of A?.attributes||[]){let r=j.attributes.find(n=>n.name===e.name);r?(r.type=e.type||r.type,r.stepMode=e.stepMode||r.stepMode):mA.warn(`shader layout attribute ${e.name} not present in shader`)}return j}var PE=class PE extends $t{constructor(j,e){super(j,e,PE.defaultProps);I(this,"maxVertexAttributes");I(this,"attributeInfos");I(this,"indexBuffer",null);I(this,"attributes");this.maxVertexAttributes=j.limits.maxVertexAttributes,this.attributes=new Array(this.maxVertexAttributes).fill(null),this.attributeInfos=OT(e.renderPipeline.shaderLayout,e.renderPipeline.bufferLayout,this.maxVertexAttributes)}get[Symbol.toStringTag](){return"VertexArray"}setConstantWebGL(j,e){throw new Error("constant attributes not supported")}};I(PE,"defaultProps",{...$t.defaultProps,renderPipeline:null});var Zd=PE;var IE=class IE extends $t{get[Symbol.toStringTag](){return"TransformFeedback"}constructor(A,j){super(A,j,IE.defaultProps)}};I(IE,"defaultProps",{...$t.defaultProps,layout:void 0,buffers:{}});var Ap=IE;var ME=class ME extends $t{get[Symbol.toStringTag](){return"QuerySet"}constructor(A,j){super(A,j,ME.defaultProps)}};I(ME,"defaultProps",{...$t.defaultProps,type:void 0,count:void 0});var tp=ME;var DJ={f32:{type:"f32",components:1},i32:{type:"i32",components:1},u32:{type:"u32",components:1},"vec2":{type:"f32",components:2},"vec3":{type:"f32",components:3},"vec4":{type:"f32",components:4},"vec2":{type:"i32",components:2},"vec3":{type:"i32",components:3},"vec4":{type:"i32",components:4},"vec2":{type:"u32",components:2},"vec3":{type:"u32",components:3},"vec4":{type:"u32",components:4},"mat2x2":{type:"f32",components:4},"mat2x3":{type:"f32",components:6},"mat2x4":{type:"f32",components:8},"mat3x2":{type:"f32",components:6},"mat3x3":{type:"f32",components:9},"mat3x4":{type:"f32",components:12},"mat4x2":{type:"f32",components:8},"mat4x3":{type:"f32",components:12},"mat4x4":{type:"f32",components:16}};function TT(t){let A=DJ[t];return Ot(t),A}function ST(t,A){switch(A){case 1:return t;case 2:return t+t%2;default:return t+(4-t%4)%4}}var OE;function TE(t){return(!OE||OE.byteLengthr.type==="uniform"&&r.name===A?.name);if(!j)throw new Error(A?.name);let e=j;for(let r of e.uniforms||[])this.bindingLayout[r.name]=r}}setUniforms(A){for(let[j,e]of Object.entries(A))this._setUniform(j,e),this.needsRedraw||this.setNeedsRedraw(`${this.name}.${j}=${e}`)}setNeedsRedraw(A){this.needsRedraw=this.needsRedraw||A}getAllUniforms(){return this.modifiedUniforms={},this.needsRedraw=!1,this.uniforms||{}}_setUniform(A,j){LT(this.uniforms[A],j)||(this.uniforms[A]=CT(j),this.modifiedUniforms[A]=!0,this.modified=!0)}};var jp=class{constructor(A){I(this,"uniformBlocks",new Map);I(this,"uniformBufferLayouts",new Map);I(this,"uniformBuffers",new Map);for(let[j,e]of Object.entries(A)){let r=j,n=new SE(e.uniformTypes||{});this.uniformBufferLayouts.set(r,n);let i=new RE({name:j});i.setUniforms(e.defaultUniforms||{}),this.uniformBlocks.set(r,i)}}destroy(){for(let A of this.uniformBuffers.values())A.destroy()}setUniforms(A){for(let[j,e]of Object.entries(A))this.uniformBlocks.get(j).setUniforms(e);this.updateUniformBuffers()}getUniformBufferByteLength(A){return this.uniformBufferLayouts.get(A).byteLength}getUniformBufferData(A){let j=this.uniformBlocks.get(A).getAllUniforms();return this.uniformBufferLayouts.get(A).getData(j)}createUniformBuffer(A,j,e){e&&this.setUniforms(e);let r=this.getUniformBufferByteLength(j),n=A.createBuffer({usage:Aj.UNIFORM|Aj.COPY_DST,byteLength:r}),i=this.getUniformBufferData(j);return n.write(i),n}getManagedUniformBuffer(A,j){if(!this.uniformBuffers.get(j)){let e=this.getUniformBufferByteLength(j),r=A.createBuffer({usage:Aj.UNIFORM|Aj.COPY_DST,byteLength:e});this.uniformBuffers.set(j,r)}return this.uniformBuffers.get(j)}updateUniformBuffers(){let A=!1;for(let j of this.uniformBlocks.keys()){let e=this.updateUniformBuffer(j);A||(A=e)}return A&&mA.log(3,`UniformStore.updateUniformBuffers(): ${A}`)(),A}updateUniformBuffer(A){let j=this.uniformBlocks.get(A),e=this.uniformBuffers.get(A),r=!1;if(e&&j.needsRedraw){r||(r=j.needsRedraw);let n=this.getUniformBufferData(A);this.uniformBuffers.get(A).write(n);let o=this.uniformBlocks.get(A).getAllUniforms();mA.log(4,`Writing to uniform buffer ${String(A)}`,n,o)()}return r}};function LE(t){let A=ArrayBuffer.isView(t)?t.constructor:t;switch(A){case Float32Array:return"float32";case Uint16Array:return"uint16";case Uint32Array:return"uint32";case Uint8Array:case Uint8ClampedArray:return"uint8";case Int8Array:return"sint8";case Int16Array:return"sint16";case Int32Array:return"sint32";default:throw new Error(A.constructor.name)}}function ep(t){switch(t){case"float32":return Float32Array;case"uint32":return Uint32Array;case"sint32":return Int32Array;case"uint16":case"unorm16":return Uint16Array;case"sint16":case"snorm16":return Int16Array;case"uint8":case"unorm8":return Uint8Array;case"sint8":case"snorm8":return Int8Array;default:throw new Error(t)}}function nG(t,A,j){if(!A||A>4)throw new Error(`size ${A}`);let e=A,r=LE(t);if(r==="uint8"&&j&&e===1)return"unorm8-webgl";if(r==="uint8"&&j&&e===3)return"unorm8x3-webgl";if(r==="uint8"||r==="sint8"){if(e===1||e===3)throw new Error(`size: ${A}`);return j&&(r=r.replace("int","norm")),`${r}x${e}`}if(r==="uint16"||r==="sint16"){if(e===1||e===3)throw new Error(`size: ${A}`);return j&&(r=r.replace("int","norm")),`${r}x${e}`}return e===1?r:`${r}x${e}`}function HT(t){return q7(t)!==null||typeof t=="number"||typeof t=="boolean"}function kc(t){let A={bindings:{},uniforms:{}};return Object.keys(t).forEach(j=>{let e=t[j];HT(e)?A.uniforms[j]=e:A.bindings[j]=e}),A}function iG(t,A,j){let{removedProps:e={},deprecatedProps:r={},replacedProps:n={}}=j;for(let o in e)if(o in A){let c=e[o]?`${t}.${e[o]}`:"N/A";mA.removed(`${t}.${o}`,c)()}for(let o in r)if(o in A){let l=r[o];mA.deprecated(`${t}.${o}`,`${t}.${l}`)()}let i=null;for(let[o,l]of Object.entries(n))o in A&&(mA.deprecated(`${t}.${o}`,`${t}.${l}`)(),i=i||Object.assign({},A),i[l]=A[o],delete i[o]);return i||A}var NJ="";async function oG(t,A){return await new Promise((j,e)=>{try{let r=new Image;r.onload=()=>j(r),r.onerror=()=>e(new Error(`Could not load image ${t}.`)),r.crossOrigin=A?.crossOrigin||"anonymous",r.src=t.startsWith("http")?t:NJ+t}catch(r){e(r)}})}async function rp(t,A){let j=document.getElementsByTagName("head")[0];if(!j)throw new Error("loadScript");let e=document.createElement("script");return e.setAttribute("type","text/javascript"),e.setAttribute("src",t),A&&(e.id=A),new Promise((r,n)=>{e.onload=r,e.onerror=i=>n(new Error(`Unable to load script '${t}': ${i}`)),j.appendChild(e)})}function np(t,A,j){if(t===A)return!0;if(!j||!t||!A)return!1;if(Array.isArray(t)){if(!Array.isArray(A)||t.length!==A.length)return!1;for(let e=0;e":return this.left.evaluate(A)>this.right.evaluate(A)?1:0;case"<=":return this.left.evaluate(A)<=this.right.evaluate(A)?1:0;case">=":return this.left.evaluate(A)>=this.right.evaluate(A)?1:0;case"&&":return this.left.evaluate(A)&&this.right.evaluate(A)?1:0;case"||":return this.left.evaluate(A)||this.right.evaluate(A)?1:0;default:throw new Error(`Unknown operator ${this.operator}`)}}search(A){this.left.search(A),this.right.search(A)}},YE=class extends co{constructor(){super()}},PG=class extends YE{constructor(A,j){super(),this.selector=A,this.body=j}get astNodeType(){return"case"}search(A){this.searchBlock(this.body,A)}},IG=class extends YE{constructor(A){super(),this.body=A}get astNodeType(){return"default"}search(A){this.searchBlock(this.body,A)}},MG=class extends co{constructor(A,j,e){super(),this.name=A,this.type=j,this.attributes=e}get astNodeType(){return"argument"}},OG=class extends co{constructor(A,j){super(),this.condition=A,this.body=j}get astNodeType(){return"elseif"}search(A){this.condition.search(A),this.searchBlock(this.body,A)}},TG=class extends co{constructor(A,j,e){super(),this.name=A,this.type=j,this.attributes=e}get astNodeType(){return"member"}},SG=class extends co{constructor(A,j){super(),this.name=A,this.value=j}get astNodeType(){return"attribute"}},iA,tA;(function(t){t[t.token=0]="token",t[t.keyword=1]="keyword",t[t.reserved=2]="reserved"})(tA||(tA={}));var AA=class{constructor(A,j,e){this.name=A,this.type=j,this.rule=e}toString(){return this.name}},z=class{};iA=z;z.none=new AA("",tA.reserved,"");z.eof=new AA("EOF",tA.token,"");z.reserved={asm:new AA("asm",tA.reserved,"asm"),bf16:new AA("bf16",tA.reserved,"bf16"),do:new AA("do",tA.reserved,"do"),enum:new AA("enum",tA.reserved,"enum"),f16:new AA("f16",tA.reserved,"f16"),f64:new AA("f64",tA.reserved,"f64"),handle:new AA("handle",tA.reserved,"handle"),i8:new AA("i8",tA.reserved,"i8"),i16:new AA("i16",tA.reserved,"i16"),i64:new AA("i64",tA.reserved,"i64"),mat:new AA("mat",tA.reserved,"mat"),premerge:new AA("premerge",tA.reserved,"premerge"),regardless:new AA("regardless",tA.reserved,"regardless"),typedef:new AA("typedef",tA.reserved,"typedef"),u8:new AA("u8",tA.reserved,"u8"),u16:new AA("u16",tA.reserved,"u16"),u64:new AA("u64",tA.reserved,"u64"),unless:new AA("unless",tA.reserved,"unless"),using:new AA("using",tA.reserved,"using"),vec:new AA("vec",tA.reserved,"vec"),void:new AA("void",tA.reserved,"void")};z.keywords={array:new AA("array",tA.keyword,"array"),atomic:new AA("atomic",tA.keyword,"atomic"),bool:new AA("bool",tA.keyword,"bool"),f32:new AA("f32",tA.keyword,"f32"),i32:new AA("i32",tA.keyword,"i32"),mat2x2:new AA("mat2x2",tA.keyword,"mat2x2"),mat2x3:new AA("mat2x3",tA.keyword,"mat2x3"),mat2x4:new AA("mat2x4",tA.keyword,"mat2x4"),mat3x2:new AA("mat3x2",tA.keyword,"mat3x2"),mat3x3:new AA("mat3x3",tA.keyword,"mat3x3"),mat3x4:new AA("mat3x4",tA.keyword,"mat3x4"),mat4x2:new AA("mat4x2",tA.keyword,"mat4x2"),mat4x3:new AA("mat4x3",tA.keyword,"mat4x3"),mat4x4:new AA("mat4x4",tA.keyword,"mat4x4"),ptr:new AA("ptr",tA.keyword,"ptr"),sampler:new AA("sampler",tA.keyword,"sampler"),sampler_comparison:new AA("sampler_comparison",tA.keyword,"sampler_comparison"),struct:new AA("struct",tA.keyword,"struct"),texture_1d:new AA("texture_1d",tA.keyword,"texture_1d"),texture_2d:new AA("texture_2d",tA.keyword,"texture_2d"),texture_2d_array:new AA("texture_2d_array",tA.keyword,"texture_2d_array"),texture_3d:new AA("texture_3d",tA.keyword,"texture_3d"),texture_cube:new AA("texture_cube",tA.keyword,"texture_cube"),texture_cube_array:new AA("texture_cube_array",tA.keyword,"texture_cube_array"),texture_multisampled_2d:new AA("texture_multisampled_2d",tA.keyword,"texture_multisampled_2d"),texture_storage_1d:new AA("texture_storage_1d",tA.keyword,"texture_storage_1d"),texture_storage_2d:new AA("texture_storage_2d",tA.keyword,"texture_storage_2d"),texture_storage_2d_array:new AA("texture_storage_2d_array",tA.keyword,"texture_storage_2d_array"),texture_storage_3d:new AA("texture_storage_3d",tA.keyword,"texture_storage_3d"),texture_depth_2d:new AA("texture_depth_2d",tA.keyword,"texture_depth_2d"),texture_depth_2d_array:new AA("texture_depth_2d_array",tA.keyword,"texture_depth_2d_array"),texture_depth_cube:new AA("texture_depth_cube",tA.keyword,"texture_depth_cube"),texture_depth_cube_array:new AA("texture_depth_cube_array",tA.keyword,"texture_depth_cube_array"),texture_depth_multisampled_2d:new AA("texture_depth_multisampled_2d",tA.keyword,"texture_depth_multisampled_2d"),texture_external:new AA("texture_external",tA.keyword,"texture_external"),u32:new AA("u32",tA.keyword,"u32"),vec2:new AA("vec2",tA.keyword,"vec2"),vec3:new AA("vec3",tA.keyword,"vec3"),vec4:new AA("vec4",tA.keyword,"vec4"),bitcast:new AA("bitcast",tA.keyword,"bitcast"),block:new AA("block",tA.keyword,"block"),break:new AA("break",tA.keyword,"break"),case:new AA("case",tA.keyword,"case"),continue:new AA("continue",tA.keyword,"continue"),continuing:new AA("continuing",tA.keyword,"continuing"),default:new AA("default",tA.keyword,"default"),diagnostic:new AA("diagnostic",tA.keyword,"diagnostic"),discard:new AA("discard",tA.keyword,"discard"),else:new AA("else",tA.keyword,"else"),enable:new AA("enable",tA.keyword,"enable"),fallthrough:new AA("fallthrough",tA.keyword,"fallthrough"),false:new AA("false",tA.keyword,"false"),fn:new AA("fn",tA.keyword,"fn"),for:new AA("for",tA.keyword,"for"),function:new AA("function",tA.keyword,"function"),if:new AA("if",tA.keyword,"if"),let:new AA("let",tA.keyword,"let"),const:new AA("const",tA.keyword,"const"),loop:new AA("loop",tA.keyword,"loop"),while:new AA("while",tA.keyword,"while"),private:new AA("private",tA.keyword,"private"),read:new AA("read",tA.keyword,"read"),read_write:new AA("read_write",tA.keyword,"read_write"),return:new AA("return",tA.keyword,"return"),requires:new AA("requires",tA.keyword,"requires"),storage:new AA("storage",tA.keyword,"storage"),switch:new AA("switch",tA.keyword,"switch"),true:new AA("true",tA.keyword,"true"),alias:new AA("alias",tA.keyword,"alias"),type:new AA("type",tA.keyword,"type"),uniform:new AA("uniform",tA.keyword,"uniform"),var:new AA("var",tA.keyword,"var"),override:new AA("override",tA.keyword,"override"),workgroup:new AA("workgroup",tA.keyword,"workgroup"),write:new AA("write",tA.keyword,"write"),r8unorm:new AA("r8unorm",tA.keyword,"r8unorm"),r8snorm:new AA("r8snorm",tA.keyword,"r8snorm"),r8uint:new AA("r8uint",tA.keyword,"r8uint"),r8sint:new AA("r8sint",tA.keyword,"r8sint"),r16uint:new AA("r16uint",tA.keyword,"r16uint"),r16sint:new AA("r16sint",tA.keyword,"r16sint"),r16float:new AA("r16float",tA.keyword,"r16float"),rg8unorm:new AA("rg8unorm",tA.keyword,"rg8unorm"),rg8snorm:new AA("rg8snorm",tA.keyword,"rg8snorm"),rg8uint:new AA("rg8uint",tA.keyword,"rg8uint"),rg8sint:new AA("rg8sint",tA.keyword,"rg8sint"),r32uint:new AA("r32uint",tA.keyword,"r32uint"),r32sint:new AA("r32sint",tA.keyword,"r32sint"),r32float:new AA("r32float",tA.keyword,"r32float"),rg16uint:new AA("rg16uint",tA.keyword,"rg16uint"),rg16sint:new AA("rg16sint",tA.keyword,"rg16sint"),rg16float:new AA("rg16float",tA.keyword,"rg16float"),rgba8unorm:new AA("rgba8unorm",tA.keyword,"rgba8unorm"),rgba8unorm_srgb:new AA("rgba8unorm_srgb",tA.keyword,"rgba8unorm_srgb"),rgba8snorm:new AA("rgba8snorm",tA.keyword,"rgba8snorm"),rgba8uint:new AA("rgba8uint",tA.keyword,"rgba8uint"),rgba8sint:new AA("rgba8sint",tA.keyword,"rgba8sint"),bgra8unorm:new AA("bgra8unorm",tA.keyword,"bgra8unorm"),bgra8unorm_srgb:new AA("bgra8unorm_srgb",tA.keyword,"bgra8unorm_srgb"),rgb10a2unorm:new AA("rgb10a2unorm",tA.keyword,"rgb10a2unorm"),rg11b10float:new AA("rg11b10float",tA.keyword,"rg11b10float"),rg32uint:new AA("rg32uint",tA.keyword,"rg32uint"),rg32sint:new AA("rg32sint",tA.keyword,"rg32sint"),rg32float:new AA("rg32float",tA.keyword,"rg32float"),rgba16uint:new AA("rgba16uint",tA.keyword,"rgba16uint"),rgba16sint:new AA("rgba16sint",tA.keyword,"rgba16sint"),rgba16float:new AA("rgba16float",tA.keyword,"rgba16float"),rgba32uint:new AA("rgba32uint",tA.keyword,"rgba32uint"),rgba32sint:new AA("rgba32sint",tA.keyword,"rgba32sint"),rgba32float:new AA("rgba32float",tA.keyword,"rgba32float"),static_assert:new AA("static_assert",tA.keyword,"static_assert")};z.tokens={decimal_float_literal:new AA("decimal_float_literal",tA.token,/((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/),hex_float_literal:new AA("hex_float_literal",tA.token,/-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),int_literal:new AA("int_literal",tA.token,/-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),uint_literal:new AA("uint_literal",tA.token,/0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),ident:new AA("ident",tA.token,/[_a-zA-Z][0-9a-zA-Z_]*/),and:new AA("and",tA.token,"&"),and_and:new AA("and_and",tA.token,"&&"),arrow:new AA("arrow ",tA.token,"->"),attr:new AA("attr",tA.token,"@"),forward_slash:new AA("forward_slash",tA.token,"/"),bang:new AA("bang",tA.token,"!"),bracket_left:new AA("bracket_left",tA.token,"["),bracket_right:new AA("bracket_right",tA.token,"]"),brace_left:new AA("brace_left",tA.token,"{"),brace_right:new AA("brace_right",tA.token,"}"),colon:new AA("colon",tA.token,":"),comma:new AA("comma",tA.token,","),equal:new AA("equal",tA.token,"="),equal_equal:new AA("equal_equal",tA.token,"=="),not_equal:new AA("not_equal",tA.token,"!="),greater_than:new AA("greater_than",tA.token,">"),greater_than_equal:new AA("greater_than_equal",tA.token,">="),shift_right:new AA("shift_right",tA.token,">>"),less_than:new AA("less_than",tA.token,"<"),less_than_equal:new AA("less_than_equal",tA.token,"<="),shift_left:new AA("shift_left",tA.token,"<<"),modulo:new AA("modulo",tA.token,"%"),minus:new AA("minus",tA.token,"-"),minus_minus:new AA("minus_minus",tA.token,"--"),period:new AA("period",tA.token,"."),plus:new AA("plus",tA.token,"+"),plus_plus:new AA("plus_plus",tA.token,"++"),or:new AA("or",tA.token,"|"),or_or:new AA("or_or",tA.token,"||"),paren_left:new AA("paren_left",tA.token,"("),paren_right:new AA("paren_right",tA.token,")"),semicolon:new AA("semicolon",tA.token,";"),star:new AA("star",tA.token,"*"),tilde:new AA("tilde",tA.token,"~"),underscore:new AA("underscore",tA.token,"_"),xor:new AA("xor",tA.token,"^"),plus_equal:new AA("plus_equal",tA.token,"+="),minus_equal:new AA("minus_equal",tA.token,"-="),times_equal:new AA("times_equal",tA.token,"*="),division_equal:new AA("division_equal",tA.token,"/="),modulo_equal:new AA("modulo_equal",tA.token,"%="),and_equal:new AA("and_equal",tA.token,"&="),or_equal:new AA("or_equal",tA.token,"|="),xor_equal:new AA("xor_equal",tA.token,"^="),shift_right_equal:new AA("shift_right_equal",tA.token,">>="),shift_left_equal:new AA("shift_left_equal",tA.token,"<<=")};z.simpleTokens={"@":iA.tokens.attr,"{":iA.tokens.brace_left,"}":iA.tokens.brace_right,":":iA.tokens.colon,",":iA.tokens.comma,"(":iA.tokens.paren_left,")":iA.tokens.paren_right,";":iA.tokens.semicolon};z.literalTokens={"&":iA.tokens.and,"&&":iA.tokens.and_and,"->":iA.tokens.arrow,"/":iA.tokens.forward_slash,"!":iA.tokens.bang,"[":iA.tokens.bracket_left,"]":iA.tokens.bracket_right,"=":iA.tokens.equal,"==":iA.tokens.equal_equal,"!=":iA.tokens.not_equal,">":iA.tokens.greater_than,">=":iA.tokens.greater_than_equal,">>":iA.tokens.shift_right,"<":iA.tokens.less_than,"<=":iA.tokens.less_than_equal,"<<":iA.tokens.shift_left,"%":iA.tokens.modulo,"-":iA.tokens.minus,"--":iA.tokens.minus_minus,".":iA.tokens.period,"+":iA.tokens.plus,"++":iA.tokens.plus_plus,"|":iA.tokens.or,"||":iA.tokens.or_or,"*":iA.tokens.star,"~":iA.tokens.tilde,_:iA.tokens.underscore,"^":iA.tokens.xor,"+=":iA.tokens.plus_equal,"-=":iA.tokens.minus_equal,"*=":iA.tokens.times_equal,"/=":iA.tokens.division_equal,"%=":iA.tokens.modulo_equal,"&=":iA.tokens.and_equal,"|=":iA.tokens.or_equal,"^=":iA.tokens.xor_equal,">>=":iA.tokens.shift_right_equal,"<<=":iA.tokens.shift_left_equal};z.regexTokens={decimal_float_literal:iA.tokens.decimal_float_literal,hex_float_literal:iA.tokens.hex_float_literal,int_literal:iA.tokens.int_literal,uint_literal:iA.tokens.uint_literal,ident:iA.tokens.ident};z.storage_class=[iA.keywords.function,iA.keywords.private,iA.keywords.workgroup,iA.keywords.uniform,iA.keywords.storage];z.access_mode=[iA.keywords.read,iA.keywords.write,iA.keywords.read_write];z.sampler_type=[iA.keywords.sampler,iA.keywords.sampler_comparison];z.sampled_texture_type=[iA.keywords.texture_1d,iA.keywords.texture_2d,iA.keywords.texture_2d_array,iA.keywords.texture_3d,iA.keywords.texture_cube,iA.keywords.texture_cube_array];z.multisampled_texture_type=[iA.keywords.texture_multisampled_2d];z.storage_texture_type=[iA.keywords.texture_storage_1d,iA.keywords.texture_storage_2d,iA.keywords.texture_storage_2d_array,iA.keywords.texture_storage_3d];z.depth_texture_type=[iA.keywords.texture_depth_2d,iA.keywords.texture_depth_2d_array,iA.keywords.texture_depth_cube,iA.keywords.texture_depth_cube_array,iA.keywords.texture_depth_multisampled_2d];z.texture_external_type=[iA.keywords.texture_external];z.any_texture_type=[...iA.sampled_texture_type,...iA.multisampled_texture_type,...iA.storage_texture_type,...iA.depth_texture_type,...iA.texture_external_type];z.texel_format=[iA.keywords.r8unorm,iA.keywords.r8snorm,iA.keywords.r8uint,iA.keywords.r8sint,iA.keywords.r16uint,iA.keywords.r16sint,iA.keywords.r16float,iA.keywords.rg8unorm,iA.keywords.rg8snorm,iA.keywords.rg8uint,iA.keywords.rg8sint,iA.keywords.r32uint,iA.keywords.r32sint,iA.keywords.r32float,iA.keywords.rg16uint,iA.keywords.rg16sint,iA.keywords.rg16float,iA.keywords.rgba8unorm,iA.keywords.rgba8unorm_srgb,iA.keywords.rgba8snorm,iA.keywords.rgba8uint,iA.keywords.rgba8sint,iA.keywords.bgra8unorm,iA.keywords.bgra8unorm_srgb,iA.keywords.rgb10a2unorm,iA.keywords.rg11b10float,iA.keywords.rg32uint,iA.keywords.rg32sint,iA.keywords.rg32float,iA.keywords.rgba16uint,iA.keywords.rgba16sint,iA.keywords.rgba16float,iA.keywords.rgba32uint,iA.keywords.rgba32sint,iA.keywords.rgba32float];z.const_literal=[iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.decimal_float_literal,iA.tokens.hex_float_literal,iA.keywords.true,iA.keywords.false];z.literal_or_ident=[iA.tokens.ident,iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.decimal_float_literal,iA.tokens.hex_float_literal];z.element_count_expression=[iA.tokens.int_literal,iA.tokens.uint_literal,iA.tokens.ident];z.template_types=[iA.keywords.vec2,iA.keywords.vec3,iA.keywords.vec4,iA.keywords.mat2x2,iA.keywords.mat2x3,iA.keywords.mat2x4,iA.keywords.mat3x2,iA.keywords.mat3x3,iA.keywords.mat3x4,iA.keywords.mat4x2,iA.keywords.mat4x3,iA.keywords.mat4x4,iA.keywords.atomic,iA.keywords.bitcast,...iA.any_texture_type];z.attribute_name=[iA.tokens.ident,iA.keywords.block,iA.keywords.diagnostic];z.assignment_operators=[iA.tokens.equal,iA.tokens.plus_equal,iA.tokens.minus_equal,iA.tokens.times_equal,iA.tokens.division_equal,iA.tokens.modulo_equal,iA.tokens.and_equal,iA.tokens.or_equal,iA.tokens.xor_equal,iA.tokens.shift_right_equal,iA.tokens.shift_left_equal];z.increment_operators=[iA.tokens.plus_plus,iA.tokens.minus_minus];var JE=class{constructor(A,j,e){this.type=A,this.lexeme=j,this.line=e}toString(){return this.lexeme}isTemplateType(){return z.template_types.indexOf(this.type)!=-1}isArrayType(){return this.type==z.keywords.array}isArrayOrTemplateType(){return this.isArrayType()||this.isTemplateType()}},RG=class{constructor(A){this._tokens=[],this._start=0,this._current=0,this._line=1,this._source=A??""}scanTokens(){for(;!this._isAtEnd();)if(this._start=this._current,!this.scanToken())throw`Invalid syntax at line ${this._line}`;return this._tokens.push(new JE(z.eof,"",this._line)),this._tokens}scanToken(){let A=this._advance();if(A==` `)return this._line++,!0;if(this._isWhitespace(A))return!0;if(A=="/"){if(this._peekAhead()=="/"){for(;A!=` `;){if(this._isAtEnd())return!0;A=this._advance()}return this._line++,!0}else if(this._peekAhead()=="*"){this._advance();let i=1;for(;i>0;){if(this._isAtEnd())return!0;if(A=this._advance(),A==` -`)this._line++;else if(A=="*"){if(this._peekAhead()=="/"&&(this._advance(),i--,i==0))return!0}else A=="/"&&this._peekAhead()=="*"&&(this._advance(),i++)}return!0}}let j=X.simpleTokens[A];if(j)return this._addToken(j),!0;let e=X.none,r=this._isAlpha(A),n=A==="_";if(this._isAlphaNumeric(A)){let i=this._peekAhead();for(;this._isAlphaNumeric(i);)A+=this._advance(),i=this._peekAhead()}if(r){let i=X.keywords[A];if(i)return this._addToken(i),!0}if(r||n)return this._addToken(X.tokens.ident),!0;for(;;){let i=this._findType(A),o=this._peekAhead();if(A=="-"&&this._tokens.length>0){if(o=="=")return this._current++,A+=o,this._addToken(X.tokens.minus_equal),!0;if(o=="-")return this._current++,A+=o,this._addToken(X.tokens.minus_minus),!0;let l=this._tokens.length-1;if((X.literal_or_ident.indexOf(this._tokens[l].type)!=-1||this._tokens[l].type==X.tokens.paren_right)&&o!=">")return this._addToken(i),!0}if(A==">"&&(o==">"||o=="=")){let l=!1,c=this._tokens.length-1;for(let B=0;B<5&&c>=0&&X.assignment_operators.indexOf(this._tokens[c].type)===-1;++B,--c)if(this._tokens[c].type===X.tokens.less_than){c>0&&this._tokens[c-1].isArrayOrTemplateType()&&(l=!0);break}if(l)return this._addToken(i),!0}if(i===X.none){let l=A,c=0,B=2;for(let h=0;h=this._source.length}_isAlpha(A){return A>="a"&&A<="z"||A>="A"&&A<="Z"}_isAlphaNumeric(A){return A>="a"&&A<="z"||A>="A"&&A<="Z"||A=="_"||A>="0"&&A<="9"}_isWhitespace(A){return A==" "||A==" "||A=="\r"}_advance(A=0){let j=this._source[this._current];return A=A||0,A++,this._current+=A,j}_peekAhead(A=0){return A=A||0,this._current+A>=this._source.length?"\0":this._source[this._current+A]}_addToken(A){let j=this._source.substring(this._start,this._current);this._tokens.push(new UE(A,j,this._line))}},Mb=class{constructor(){this._tokens=[],this._current=0,this._currentLine=0,this._context=new nb,this._deferArrayCountEval=[]}parse(A){this._initialize(A),this._deferArrayCountEval.length=0;let j=[];for(;!this._isAtEnd();){let e=this._global_decl_or_directive();if(!e)break;j.push(e)}if(this._deferArrayCountEval.length>0){for(let e of this._deferArrayCountEval){let r=e.arrayType,n=e.countNode;if(n instanceof sp){let o=n.name,l=this._context.constants.get(o);if(l)try{let c=l.evaluate(this._context);r.count=c}catch{}}}this._deferArrayCountEval.length=0}return j}_initialize(A){if(A)if(typeof A=="string"){let j=new Ib(A);this._tokens=j.scanTokens()}else this._tokens=A;else this._tokens=[];this._current=0}_error(A,j){return{token:A,message:j,toString:function(){return`${j}`}}}_isAtEnd(){return this._current>=this._tokens.length||this._peek().type==X.eof}_match(A){if(A instanceof AA)return this._check(A)?(this._advance(),!0):!1;for(let j=0,e=A.length;j'.");let r=this._paren_expression();return new yb(e,r)}let A=this._type_decl(),j=this._argument_expression_list();return new F7(A,j)}_argument_expression_list(){if(!this._match(X.tokens.paren_left))return null;let A=[];do{if(this._check(X.tokens.paren_right))break;let j=this._short_circuit_or_expression();A.push(j)}while(this._match(X.tokens.comma));return this._consume(X.tokens.paren_right,"Expected ')' for agument list"),A}_optional_paren_expression(){this._match(X.tokens.paren_left);let A=this._short_circuit_or_expression();return this._match(X.tokens.paren_right),new KE([A])}_paren_expression(){this._consume(X.tokens.paren_left,"Expected '('.");let A=this._short_circuit_or_expression();return this._consume(X.tokens.paren_right,"Expected ')'."),new KE([A])}_struct_decl(){if(!this._match(X.keywords.struct))return null;let A=this._currentLine,j=this._consume(X.tokens.ident,"Expected name for struct.").toString();this._consume(X.tokens.brace_left,"Expected '{' for struct body.");let e=[];for(;!this._check(X.tokens.brace_right);){let i=this._attribute(),o=this._consume(X.tokens.ident,"Expected variable name.").toString();this._consume(X.tokens.colon,"Expected ':' for struct member type.");let l=this._attribute(),c=this._type_decl();c!=null&&(c.attributes=l),this._check(X.tokens.brace_right)?this._match(X.tokens.comma):this._consume(X.tokens.comma,"Expected ',' for struct member."),e.push(new Fb(o,c,i))}this._consume(X.tokens.brace_right,"Expected '}' after struct body.");let r=this._currentLine,n=new _a(j,e,A,r);return this._context.structs.set(j,n),n}_global_variable_decl(){let A=this._variable_decl();return A&&this._match(X.tokens.equal)&&(A.value=this._const_expression()),A}_override_variable_decl(){let A=this._override_decl();return A&&this._match(X.tokens.equal)&&(A.value=this._const_expression()),A}_global_const_decl(){if(!this._match(X.keywords.const))return null;let A=this._consume(X.tokens.ident,"Expected variable name"),j=null;if(this._match(X.tokens.colon)){let n=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=n)}let e=null;if(this._match(X.tokens.equal)){let n=this._short_circuit_or_expression();if(n instanceof F7)e=n;else if(n instanceof DE&&n.initializer instanceof F7)e=n.initializer;else try{let i=n.evaluate(this._context);e=new NE(i)}catch{e=n}}let r=new TE(A.toString(),j,"","",e);return this._context.constants.set(r.name,r),r}_global_let_decl(){if(!this._match(X.keywords.let))return null;let A=this._consume(X.tokens.ident,"Expected variable name"),j=null;if(this._match(X.tokens.colon)){let r=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=r)}let e=null;return this._match(X.tokens.equal)&&(e=this._const_expression()),new ip(A.toString(),j,"","",e)}_const_expression(){return this._short_circuit_or_expression()}_variable_decl(){if(!this._match(X.keywords.var))return null;let A="",j="";this._match(X.tokens.less_than)&&(A=this._consume(X.storage_class,"Expected storage_class.").toString(),this._match(X.tokens.comma)&&(j=this._consume(X.access_mode,"Expected access_mode.").toString()),this._consume(X.tokens.greater_than,"Expected '>'."));let e=this._consume(X.tokens.ident,"Expected variable name"),r=null;if(this._match(X.tokens.colon)){let n=this._attribute();r=this._type_decl(),r!=null&&(r.attributes=n)}return new qa(e.toString(),r,A,j,null)}_override_decl(){if(!this._match(X.keywords.override))return null;let A=this._consume(X.tokens.ident,"Expected variable name"),j=null;if(this._match(X.tokens.colon)){let e=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=e)}return new OE(A.toString(),j,null)}_diagnostic(){this._consume(X.tokens.paren_left,"Expected '('");let A=this._consume(X.tokens.ident,"Expected severity control name.");this._consume(X.tokens.comma,"Expected ','");let j=this._consume(X.tokens.ident,"Expected diagnostic rule name.");return this._consume(X.tokens.paren_right,"Expected ')'"),new kb(A.toString(),j.toString())}_enable_directive(){let A=this._consume(X.tokens.ident,"identity expected.");return new db(A.toString())}_requires_directive(){let A=[this._consume(X.tokens.ident,"identity expected.").toString()];for(;this._match(X.tokens.comma);){let j=this._consume(X.tokens.ident,"identity expected.");A.push(j.toString())}return new pb(A)}_type_alias(){let A=this._consume(X.tokens.ident,"identity expected.");this._consume(X.tokens.equal,"Expected '=' for type alias.");let j=this._type_decl();if(j===null)throw this._error(this._peek(),"Expected Type for Alias.");this._context.aliases.has(j.name)&&(j=this._context.aliases.get(j.name).type);let e=new RE(A.toString(),j);return this._context.aliases.set(e.name,e),e}_type_decl(){if(this._check([X.tokens.ident,...X.texel_format,X.keywords.bool,X.keywords.f32,X.keywords.i32,X.keywords.u32])){let e=this._advance(),r=e.toString();return this._context.structs.has(r)?this._context.structs.get(r):this._context.aliases.has(r)?this._context.aliases.get(r).type:new Ga(e.toString())}let A=this._texture_sampler_types();if(A)return A;if(this._check(X.template_types)){let e=this._advance().toString(),r=null,n=null;return this._match(X.tokens.less_than)&&(r=this._type_decl(),n=null,this._match(X.tokens.comma)&&(n=this._consume(X.access_mode,"Expected access_mode for pointer").toString()),this._consume(X.tokens.greater_than,"Expected '>' for type.")),new LE(e,r,n)}if(this._match(X.keywords.ptr)){let e=this._previous().toString();this._consume(X.tokens.less_than,"Expected '<' for pointer.");let r=this._consume(X.storage_class,"Expected storage_class for pointer");this._consume(X.tokens.comma,"Expected ',' for pointer.");let n=this._type_decl(),i=null;return this._match(X.tokens.comma)&&(i=this._consume(X.access_mode,"Expected access_mode for pointer").toString()),this._consume(X.tokens.greater_than,"Expected '>' for pointer."),new $b(e,r.toString(),n,i)}let j=this._attribute();if(this._match(X.keywords.array)){let e=null,r=-1,n=this._previous(),i=null;if(this._match(X.tokens.less_than)){e=this._type_decl(),this._context.aliases.has(e.name)&&(e=this._context.aliases.get(e.name).type);let l="";if(this._match(X.tokens.comma)){i=this._shift_expression();try{l=i.evaluate(this._context).toString(),i=null}catch{l="1"}}this._consume(X.tokens.greater_than,"Expected '>' for array."),r=l?parseInt(l):0}let o=new CE(n.toString(),j,e,r);return i&&this._deferArrayCountEval.push({arrayType:o,countNode:i}),o}return null}_texture_sampler_types(){if(this._match(X.sampler_type))return new kc(this._previous().toString(),null,null);if(this._match(X.depth_texture_type))return new kc(this._previous().toString(),null,null);if(this._match(X.sampled_texture_type)||this._match(X.multisampled_texture_type)){let A=this._previous();this._consume(X.tokens.less_than,"Expected '<' for sampler type.");let j=this._type_decl();return this._consume(X.tokens.greater_than,"Expected '>' for sampler type."),new kc(A.toString(),j,null)}if(this._match(X.storage_texture_type)){let A=this._previous();this._consume(X.tokens.less_than,"Expected '<' for sampler type.");let j=this._consume(X.texel_format,"Invalid texel format.").toString();this._consume(X.tokens.comma,"Expected ',' after texel format.");let e=this._consume(X.access_mode,"Expected access mode for storage texture type.").toString();return this._consume(X.tokens.greater_than,"Expected '>' for sampler type."),new kc(A.toString(),j,e)}return null}_attribute(){let A=[];for(;this._match(X.tokens.attr);){let j=this._consume(X.attribute_name,"Expected attribute name"),e=new Pb(j.toString(),null);if(this._match(X.tokens.paren_left)){if(e.value=this._consume(X.literal_or_ident,"Expected attribute value").toString(),this._check(X.tokens.comma)){this._advance();do{let r=this._consume(X.literal_or_ident,"Expected attribute value").toString();e.value instanceof Array||(e.value=[e.value]),e.value.push(r)}while(this._match(X.tokens.comma))}this._consume(X.tokens.paren_right,"Expected ')'")}A.push(e)}return A.length==0?null:A}},P7=class{constructor(A,j){this.name=A,this.attributes=j,this.size=0}get isArray(){return!1}get isStruct(){return!1}get isTemplate(){return!1}},VE=class{constructor(A,j,e){this.name=A,this.type=j,this.attributes=e,this.offset=0,this.size=0}get isArray(){return this.type.isArray}get isStruct(){return this.type.isStruct}get isTemplate(){return this.type.isTemplate}get align(){return this.type.isStruct?this.type.align:0}get members(){return this.type.isStruct?this.type.members:null}get format(){return this.type.isArray?this.type.format:this.type.isTemplate?this.type.format:null}get count(){return this.type.isArray?this.type.count:0}get stride(){return this.type.isArray?this.type.stride:this.size}},uB=class extends P7{constructor(A,j){super(A,j),this.members=[],this.align=0,this.startLine=-1,this.endLine=-1,this.inUse=!1}get isStruct(){return!0}},rp=class extends P7{constructor(A,j){super(A,j),this.count=0,this.stride=0}get isArray(){return!0}},QE=class extends P7{constructor(A,j,e,r){super(A,e),this.format=j,this.access=r}get isTemplate(){return!0}},w7;(function(t){t[t.Uniform=0]="Uniform",t[t.Storage=1]="Storage",t[t.Texture=2]="Texture",t[t.Sampler=3]="Sampler",t[t.StorageTexture=4]="StorageTexture"})(w7||(w7={}));var BB=class{constructor(A,j,e,r,n,i,o){this.name=A,this.type=j,this.group=e,this.binding=r,this.attributes=n,this.resourceType=i,this.access=o}get isArray(){return this.type.isArray}get isStruct(){return this.type.isStruct}get isTemplate(){return this.type.isTemplate}get size(){return this.type.size}get align(){return this.type.isStruct?this.type.align:0}get members(){return this.type.isStruct?this.type.members:null}get format(){return this.type.isArray?this.type.format:this.type.isTemplate?this.type.format:null}get count(){return this.type.isArray?this.type.count:0}get stride(){return this.type.isArray?this.type.stride:this.size}},Ob=class{constructor(A,j){this.name=A,this.type=j}},fB=class{constructor(A,j){this.align=A,this.size=j}},Tb=class{constructor(A,j,e,r){this.name=A,this.type=j,this.locationType=e,this.location=r,this.interpolation=null}},WE=class{constructor(A,j,e,r){this.name=A,this.type=j,this.locationType=e,this.location=r}},Sb=class{constructor(A,j,e,r){this.name=A,this.type=j,this.attributes=e,this.id=r}},Rb=class{constructor(A,j){this.name=A,this.type=j}},Lb=class{constructor(A,j=null){this.stage=null,this.inputs=[],this.outputs=[],this.arguments=[],this.returnType=null,this.resources=[],this.overrides=[],this.startLine=-1,this.endLine=-1,this.inUse=!1,this.calls=new Set,this.name=A,this.stage=j}},Cb=class{constructor(){this.vertex=[],this.fragment=[],this.compute=[]}},Hb=class{constructor(A){this.resources=null,this.inUse=!1,this.info=null,this.node=A}},gc=class t{constructor(A){this.uniforms=[],this.storage=[],this.textures=[],this.samplers=[],this.aliases=[],this.overrides=[],this.structs=[],this.entry=new Cb,this.functions=[],this._types=new Map,this._functions=new Map,A&&this.update(A)}_isStorageTexture(A){return A.name=="texture_storage_1d"||A.name=="texture_storage_2d"||A.name=="texture_storage_2d_array"||A.name=="texture_storage_3d"}update(A){let e=new Mb().parse(A);for(let r of e)r instanceof np&&this._functions.set(r.name,new Hb(r));for(let r of e)if(r instanceof _a){let n=this._getTypeInfo(r,null);n instanceof uB&&this.structs.push(n)}for(let r of e){if(r instanceof RE){this.aliases.push(this._getAliasInfo(r));continue}if(r instanceof OE){let n=r,i=this._getAttributeNum(n.attributes,"id",0),o=n.type!=null?this._getTypeInfo(n.type,n.attributes):null;this.overrides.push(new Sb(n.name,o,n.attributes,i));continue}if(this._isUniformVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=new BB(n.name,l,i,o,n.attributes,w7.Uniform,n.access);this.uniforms.push(c);continue}if(this._isStorageVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=this._isStorageTexture(l),B=new BB(n.name,l,i,o,n.attributes,c?w7.StorageTexture:w7.Storage,n.access);this.storage.push(B);continue}if(this._isTextureVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=this._isStorageTexture(l),B=new BB(n.name,l,i,o,n.attributes,c?w7.StorageTexture:w7.Texture,n.access);c?this.storage.push(B):this.textures.push(B);continue}if(this._isSamplerVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=new BB(n.name,l,i,o,n.attributes,w7.Sampler,n.access);this.samplers.push(c);continue}if(r instanceof np){let n=this._getAttribute(r,"vertex"),i=this._getAttribute(r,"fragment"),o=this._getAttribute(r,"compute"),l=n||i||o,c=new Lb(r.name,l?.name);c.startLine=r.startLine,c.endLine=r.endLine,this.functions.push(c),this._functions.get(r.name).info=c,l?(this._functions.get(r.name).inUse=!0,c.inUse=!0,c.resources=this._findResources(r,!!l),c.inputs=this._getInputs(r.args),c.outputs=this._getOutputs(r.returnType),this.entry[l.name].push(c)):(c.arguments=r.args.map(B=>new Rb(B.name,this._getTypeInfo(B.type,B.attributes))),c.returnType=r.returnType?this._getTypeInfo(r.returnType,r.attributes):null);continue}}for(let r of this._functions.values())r.info&&(r.info.inUse=r.inUse,this._addCalls(r.node,r.info.calls));for(let r of this._functions.values())r.node.search(n=>{var i;if(n.astNodeType==="varExpr"){let o=n;for(let l of this.overrides)o.name==l.name&&((i=r.info)===null||i===void 0||i.overrides.push(l))}});for(let r of this.uniforms)this._markStructsInUse(r.type);for(let r of this.storage)this._markStructsInUse(r.type)}_markStructsInUse(A){if(A)if(A.isStruct){if(A.inUse=!0,A.members)for(let j of A.members)this._markStructsInUse(j.type)}else if(A.isArray)this._markStructsInUse(A.format);else if(A.isTemplate)A.format&&this._markStructsInUse(A.format);else{let j=this._getAlias(A.name);j&&this._markStructsInUse(j)}}_addCalls(A,j){var e;for(let r of A.calls){let n=(e=this._functions.get(r.name))===null||e===void 0?void 0:e.info;n&&j.add(n)}}findResource(A,j){for(let e of this.uniforms)if(e.group==A&&e.binding==j)return e;for(let e of this.storage)if(e.group==A&&e.binding==j)return e;for(let e of this.textures)if(e.group==A&&e.binding==j)return e;for(let e of this.samplers)if(e.group==A&&e.binding==j)return e;return null}_findResource(A){for(let j of this.uniforms)if(j.name==A)return j;for(let j of this.storage)if(j.name==A)return j;for(let j of this.textures)if(j.name==A)return j;for(let j of this.samplers)if(j.name==A)return j;return null}_markStructsFromAST(A){let j=this._getTypeInfo(A,null);this._markStructsInUse(j)}_findResources(A,j){let e=[],r=this,n=[];return A.search(i=>{if(i instanceof hB)n.push({});else if(i instanceof dB)n.pop();else if(i instanceof qa){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type),n.length>0&&(n[n.length-1][o.name]=o)}else if(i instanceof F7){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type)}else if(i instanceof ip){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type),n.length>0&&(n[n.length-1][o.name]=o)}else if(i instanceof sp){let o=i;if(n.length>0&&n[n.length-1][o.name])return;let l=r._findResource(o.name);l&&e.push(l)}else if(i instanceof HE){let o=i,l=r._functions.get(o.name);l&&(j&&(l.inUse=!0),A.calls.add(l.node),l.resources===null&&(l.resources=r._findResources(l.node,j)),e.push(...l.resources))}else if(i instanceof SE){let o=i,l=r._functions.get(o.name);l&&(j&&(l.inUse=!0),A.calls.add(l.node),l.resources===null&&(l.resources=r._findResources(l.node,j)),e.push(...l.resources))}}),[...new Map(e.map(i=>[i.name,i])).values()]}getBindGroups(){let A=[];function j(e,r){e>=A.length&&(A.length=e+1),A[e]===void 0&&(A[e]=[]),r>=A[e].length&&(A[e].length=r+1)}for(let e of this.uniforms){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.storage){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.textures){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.samplers){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}return A}_getOutputs(A,j=void 0){if(j===void 0&&(j=[]),A instanceof _a)this._getStructOutputs(A,j);else{let e=this._getOutputInfo(A);e!==null&&j.push(e)}return j}_getStructOutputs(A,j){for(let e of A.members)if(e.type instanceof _a)this._getStructOutputs(e.type,j);else{let r=this._getAttribute(e,"location")||this._getAttribute(e,"builtin");if(r!==null){let n=this._getTypeInfo(e.type,e.type.attributes),i=this._parseInt(r.value),o=new WE(e.name,n,r.name,i);j.push(o)}}}_getOutputInfo(A){let j=this._getAttribute(A,"location")||this._getAttribute(A,"builtin");if(j!==null){let e=this._getTypeInfo(A,A.attributes),r=this._parseInt(j.value);return new WE("",e,j.name,r)}return null}_getInputs(A,j=void 0){j===void 0&&(j=[]);for(let e of A)if(e.type instanceof _a)this._getStructInputs(e.type,j);else{let r=this._getInputInfo(e);r!==null&&j.push(r)}return j}_getStructInputs(A,j){for(let e of A.members)if(e.type instanceof _a)this._getStructInputs(e.type,j);else{let r=this._getInputInfo(e);r!==null&&j.push(r)}}_getInputInfo(A){let j=this._getAttribute(A,"location")||this._getAttribute(A,"builtin");if(j!==null){let e=this._getAttribute(A,"interpolation"),r=this._getTypeInfo(A.type,A.attributes),n=this._parseInt(j.value),i=new Tb(A.name,r,j.name,n);return e!==null&&(i.interpolation=this._parseString(e.value)),i}return null}_parseString(A){return A instanceof Array&&(A=A[0]),A}_parseInt(A){A instanceof Array&&(A=A[0]);let j=parseInt(A);return isNaN(j)?A:j}_getAlias(A){for(let j of this.aliases)if(j.name==A)return j.type;return null}_getAliasInfo(A){return new Ob(A.name,this._getTypeInfo(A.type,null))}_getTypeInfo(A,j){if(this._types.has(A))return this._types.get(A);if(A instanceof CE){let r=A,n=r.format?this._getTypeInfo(r.format,r.attributes):null,i=new rp(r.name,j);return i.format=n,i.count=r.count,this._types.set(A,i),this._updateTypeInfo(i),i}if(A instanceof _a){let r=A,n=new uB(r.name,j);n.startLine=r.startLine,n.endLine=r.endLine;for(let i of r.members){let o=this._getTypeInfo(i.type,i.attributes);n.members.push(new VE(i.name,o,i.attributes))}return this._types.set(A,n),this._updateTypeInfo(n),n}if(A instanceof kc){let r=A,n=r.format instanceof Ga,i=r.format?n?this._getTypeInfo(r.format,null):new P7(r.format,null):null,o=new QE(r.name,i,j,r.access);return this._types.set(A,o),this._updateTypeInfo(o),o}if(A instanceof LE){let r=A,n=r.format?this._getTypeInfo(r.format,null):null,i=new QE(r.name,n,j,r.access);return this._types.set(A,i),this._updateTypeInfo(i),i}let e=new P7(A.name,j);return this._types.set(A,e),this._updateTypeInfo(e),e}_updateTypeInfo(A){var j,e;let r=this._getTypeSize(A);if(A.size=(j=r?.size)!==null&&j!==void 0?j:0,A instanceof rp&&A.format){let n=this._getTypeSize(A.format);A.stride=(e=n?.size)!==null&&e!==void 0?e:0,this._updateTypeInfo(A.format)}A instanceof uB&&this._updateStructInfo(A)}_updateStructInfo(A){var j;let e=0,r=0,n=0,i=0;for(let o=0,l=A.members.length;ot.name);gc._samplerTypes=X.sampler_type.map(t=>t.name);function Db(t){let A={attributes:[],bindings:[]},j;try{j=RJ(t)}catch(n){return mA.error(n.message)(),A}for(let n of j.uniforms){let i=[];for(let o of n.type?.members||[])i.push({name:o.name,type:TT(o.type)});A.bindings.push({type:"uniform",name:n.name,location:n.binding,group:n.group,members:i})}let e=j.entry.vertex[0],r=e?.inputs.length||0;for(let n=0;n`:t.name}function RJ(t){try{return new gc(t)}catch(A){if(A instanceof Error)throw A;let j="WGSL parse error";throw typeof A=="object"&&A?.message&&(j+=`: ${A.message} `),typeof A=="object"&&A?.token&&(j+=A.token.line||""),new Error(j,{cause:A})}}var LJ=`#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND +`)this._line++;else if(A=="*"){if(this._peekAhead()=="/"&&(this._advance(),i--,i==0))return!0}else A=="/"&&this._peekAhead()=="*"&&(this._advance(),i++)}return!0}}let j=z.simpleTokens[A];if(j)return this._addToken(j),!0;let e=z.none,r=this._isAlpha(A),n=A==="_";if(this._isAlphaNumeric(A)){let i=this._peekAhead();for(;this._isAlphaNumeric(i);)A+=this._advance(),i=this._peekAhead()}if(r){let i=z.keywords[A];if(i)return this._addToken(i),!0}if(r||n)return this._addToken(z.tokens.ident),!0;for(;;){let i=this._findType(A),o=this._peekAhead();if(A=="-"&&this._tokens.length>0){if(o=="=")return this._current++,A+=o,this._addToken(z.tokens.minus_equal),!0;if(o=="-")return this._current++,A+=o,this._addToken(z.tokens.minus_minus),!0;let l=this._tokens.length-1;if((z.literal_or_ident.indexOf(this._tokens[l].type)!=-1||this._tokens[l].type==z.tokens.paren_right)&&o!=">")return this._addToken(i),!0}if(A==">"&&(o==">"||o=="=")){let l=!1,c=this._tokens.length-1;for(let B=0;B<5&&c>=0&&z.assignment_operators.indexOf(this._tokens[c].type)===-1;++B,--c)if(this._tokens[c].type===z.tokens.less_than){c>0&&this._tokens[c-1].isArrayOrTemplateType()&&(l=!0);break}if(l)return this._addToken(i),!0}if(i===z.none){let l=A,c=0,B=2;for(let h=0;h=this._source.length}_isAlpha(A){return A>="a"&&A<="z"||A>="A"&&A<="Z"}_isAlphaNumeric(A){return A>="a"&&A<="z"||A>="A"&&A<="Z"||A=="_"||A>="0"&&A<="9"}_isWhitespace(A){return A==" "||A==" "||A=="\r"}_advance(A=0){let j=this._source[this._current];return A=A||0,A++,this._current+=A,j}_peekAhead(A=0){return A=A||0,this._current+A>=this._source.length?"\0":this._source[this._current+A]}_addToken(A){let j=this._source.substring(this._start,this._current);this._tokens.push(new JE(A,j,this._line))}},LG=class{constructor(){this._tokens=[],this._current=0,this._currentLine=0,this._context=new lG,this._deferArrayCountEval=[]}parse(A){this._initialize(A),this._deferArrayCountEval.length=0;let j=[];for(;!this._isAtEnd();){let e=this._global_decl_or_directive();if(!e)break;j.push(e)}if(this._deferArrayCountEval.length>0){for(let e of this._deferArrayCountEval){let r=e.arrayType,n=e.countNode;if(n instanceof lp){let o=n.name,l=this._context.constants.get(o);if(l)try{let c=l.evaluate(this._context);r.count=c}catch{}}}this._deferArrayCountEval.length=0}return j}_initialize(A){if(A)if(typeof A=="string"){let j=new RG(A);this._tokens=j.scanTokens()}else this._tokens=A;else this._tokens=[];this._current=0}_error(A,j){return{token:A,message:j,toString:function(){return`${j}`}}}_isAtEnd(){return this._current>=this._tokens.length||this._peek().type==z.eof}_match(A){if(A instanceof AA)return this._check(A)?(this._advance(),!0):!1;for(let j=0,e=A.length;j'.");let r=this._paren_expression();return new GG(e,r)}let A=this._type_decl(),j=this._argument_expression_list();return new F7(A,j)}_argument_expression_list(){if(!this._match(z.tokens.paren_left))return null;let A=[];do{if(this._check(z.tokens.paren_right))break;let j=this._short_circuit_or_expression();A.push(j)}while(this._match(z.tokens.comma));return this._consume(z.tokens.paren_right,"Expected ')' for agument list"),A}_optional_paren_expression(){this._match(z.tokens.paren_left);let A=this._short_circuit_or_expression();return this._match(z.tokens.paren_right),new QE([A])}_paren_expression(){this._consume(z.tokens.paren_left,"Expected '('.");let A=this._short_circuit_or_expression();return this._consume(z.tokens.paren_right,"Expected ')'."),new QE([A])}_struct_decl(){if(!this._match(z.keywords.struct))return null;let A=this._currentLine,j=this._consume(z.tokens.ident,"Expected name for struct.").toString();this._consume(z.tokens.brace_left,"Expected '{' for struct body.");let e=[];for(;!this._check(z.tokens.brace_right);){let i=this._attribute(),o=this._consume(z.tokens.ident,"Expected variable name.").toString();this._consume(z.tokens.colon,"Expected ':' for struct member type.");let l=this._attribute(),c=this._type_decl();c!=null&&(c.attributes=l),this._check(z.tokens.brace_right)?this._match(z.tokens.comma):this._consume(z.tokens.comma,"Expected ',' for struct member."),e.push(new TG(o,c,i))}this._consume(z.tokens.brace_right,"Expected '}' after struct body.");let r=this._currentLine,n=new _a(j,e,A,r);return this._context.structs.set(j,n),n}_global_variable_decl(){let A=this._variable_decl();return A&&this._match(z.tokens.equal)&&(A.value=this._const_expression()),A}_override_variable_decl(){let A=this._override_decl();return A&&this._match(z.tokens.equal)&&(A.value=this._const_expression()),A}_global_const_decl(){if(!this._match(z.keywords.const))return null;let A=this._consume(z.tokens.ident,"Expected variable name"),j=null;if(this._match(z.tokens.colon)){let n=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=n)}let e=null;if(this._match(z.tokens.equal)){let n=this._short_circuit_or_expression();if(n instanceof F7)e=n;else if(n instanceof UE&&n.initializer instanceof F7)e=n.initializer;else try{let i=n.evaluate(this._context);e=new VE(i)}catch{e=n}}let r=new HE(A.toString(),j,"","",e);return this._context.constants.set(r.name,r),r}_global_let_decl(){if(!this._match(z.keywords.let))return null;let A=this._consume(z.tokens.ident,"Expected variable name"),j=null;if(this._match(z.tokens.colon)){let r=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=r)}let e=null;return this._match(z.tokens.equal)&&(e=this._const_expression()),new sp(A.toString(),j,"","",e)}_const_expression(){return this._short_circuit_or_expression()}_variable_decl(){if(!this._match(z.keywords.var))return null;let A="",j="";this._match(z.tokens.less_than)&&(A=this._consume(z.storage_class,"Expected storage_class.").toString(),this._match(z.tokens.comma)&&(j=this._consume(z.access_mode,"Expected access_mode.").toString()),this._consume(z.tokens.greater_than,"Expected '>'."));let e=this._consume(z.tokens.ident,"Expected variable name"),r=null;if(this._match(z.tokens.colon)){let n=this._attribute();r=this._type_decl(),r!=null&&(r.attributes=n)}return new qa(e.toString(),r,A,j,null)}_override_decl(){if(!this._match(z.keywords.override))return null;let A=this._consume(z.tokens.ident,"Expected variable name"),j=null;if(this._match(z.tokens.colon)){let e=this._attribute();j=this._type_decl(),j!=null&&(j.attributes=e)}return new CE(A.toString(),j,null)}_diagnostic(){this._consume(z.tokens.paren_left,"Expected '('");let A=this._consume(z.tokens.ident,"Expected severity control name.");this._consume(z.tokens.comma,"Expected ','");let j=this._consume(z.tokens.ident,"Expected diagnostic rule name.");return this._consume(z.tokens.paren_right,"Expected ')'"),new xG(A.toString(),j.toString())}_enable_directive(){let A=this._consume(z.tokens.ident,"identity expected.");return new EG(A.toString())}_requires_directive(){let A=[this._consume(z.tokens.ident,"identity expected.").toString()];for(;this._match(z.tokens.comma);){let j=this._consume(z.tokens.ident,"identity expected.");A.push(j.toString())}return new $G(A)}_type_alias(){let A=this._consume(z.tokens.ident,"identity expected.");this._consume(z.tokens.equal,"Expected '=' for type alias.");let j=this._type_decl();if(j===null)throw this._error(this._peek(),"Expected Type for Alias.");this._context.aliases.has(j.name)&&(j=this._context.aliases.get(j.name).type);let e=new NE(A.toString(),j);return this._context.aliases.set(e.name,e),e}_type_decl(){if(this._check([z.tokens.ident,...z.texel_format,z.keywords.bool,z.keywords.f32,z.keywords.i32,z.keywords.u32])){let e=this._advance(),r=e.toString();return this._context.structs.has(r)?this._context.structs.get(r):this._context.aliases.has(r)?this._context.aliases.get(r).type:new ba(e.toString())}let A=this._texture_sampler_types();if(A)return A;if(this._check(z.template_types)){let e=this._advance().toString(),r=null,n=null;return this._match(z.tokens.less_than)&&(r=this._type_decl(),n=null,this._match(z.tokens.comma)&&(n=this._consume(z.access_mode,"Expected access_mode for pointer").toString()),this._consume(z.tokens.greater_than,"Expected '>' for type.")),new KE(e,r,n)}if(this._match(z.keywords.ptr)){let e=this._previous().toString();this._consume(z.tokens.less_than,"Expected '<' for pointer.");let r=this._consume(z.storage_class,"Expected storage_class for pointer");this._consume(z.tokens.comma,"Expected ',' for pointer.");let n=this._type_decl(),i=null;return this._match(z.tokens.comma)&&(i=this._consume(z.access_mode,"Expected access_mode for pointer").toString()),this._consume(z.tokens.greater_than,"Expected '>' for pointer."),new qG(e,r.toString(),n,i)}let j=this._attribute();if(this._match(z.keywords.array)){let e=null,r=-1,n=this._previous(),i=null;if(this._match(z.tokens.less_than)){e=this._type_decl(),this._context.aliases.has(e.name)&&(e=this._context.aliases.get(e.name).type);let l="";if(this._match(z.tokens.comma)){i=this._shift_expression();try{l=i.evaluate(this._context).toString(),i=null}catch{l="1"}}this._consume(z.tokens.greater_than,"Expected '>' for array."),r=l?parseInt(l):0}let o=new XE(n.toString(),j,e,r);return i&&this._deferArrayCountEval.push({arrayType:o,countNode:i}),o}return null}_texture_sampler_types(){if(this._match(z.sampler_type))return new gc(this._previous().toString(),null,null);if(this._match(z.depth_texture_type))return new gc(this._previous().toString(),null,null);if(this._match(z.sampled_texture_type)||this._match(z.multisampled_texture_type)){let A=this._previous();this._consume(z.tokens.less_than,"Expected '<' for sampler type.");let j=this._type_decl();return this._consume(z.tokens.greater_than,"Expected '>' for sampler type."),new gc(A.toString(),j,null)}if(this._match(z.storage_texture_type)){let A=this._previous();this._consume(z.tokens.less_than,"Expected '<' for sampler type.");let j=this._consume(z.texel_format,"Invalid texel format.").toString();this._consume(z.tokens.comma,"Expected ',' after texel format.");let e=this._consume(z.access_mode,"Expected access mode for storage texture type.").toString();return this._consume(z.tokens.greater_than,"Expected '>' for sampler type."),new gc(A.toString(),j,e)}return null}_attribute(){let A=[];for(;this._match(z.tokens.attr);){let j=this._consume(z.attribute_name,"Expected attribute name"),e=new SG(j.toString(),null);if(this._match(z.tokens.paren_left)){if(e.value=this._consume(z.literal_or_ident,"Expected attribute value").toString(),this._check(z.tokens.comma)){this._advance();do{let r=this._consume(z.literal_or_ident,"Expected attribute value").toString();e.value instanceof Array||(e.value=[e.value]),e.value.push(r)}while(this._match(z.tokens.comma))}this._consume(z.tokens.paren_right,"Expected ')'")}A.push(e)}return A.length==0?null:A}},P7=class{constructor(A,j){this.name=A,this.attributes=j,this.size=0}get isArray(){return!1}get isStruct(){return!1}get isTemplate(){return!1}},ZE=class{constructor(A,j,e){this.name=A,this.type=j,this.attributes=e,this.offset=0,this.size=0}get isArray(){return this.type.isArray}get isStruct(){return this.type.isStruct}get isTemplate(){return this.type.isTemplate}get align(){return this.type.isStruct?this.type.align:0}get members(){return this.type.isStruct?this.type.members:null}get format(){return this.type.isArray?this.type.format:this.type.isTemplate?this.type.format:null}get count(){return this.type.isArray?this.type.count:0}get stride(){return this.type.isArray?this.type.stride:this.size}},uB=class extends P7{constructor(A,j){super(A,j),this.members=[],this.align=0,this.startLine=-1,this.endLine=-1,this.inUse=!1}get isStruct(){return!0}},ip=class extends P7{constructor(A,j){super(A,j),this.count=0,this.stride=0}get isArray(){return!0}},A$=class extends P7{constructor(A,j,e,r){super(A,e),this.format=j,this.access=r}get isTemplate(){return!0}},w7;(function(t){t[t.Uniform=0]="Uniform",t[t.Storage=1]="Storage",t[t.Texture=2]="Texture",t[t.Sampler=3]="Sampler",t[t.StorageTexture=4]="StorageTexture"})(w7||(w7={}));var BB=class{constructor(A,j,e,r,n,i,o){this.name=A,this.type=j,this.group=e,this.binding=r,this.attributes=n,this.resourceType=i,this.access=o}get isArray(){return this.type.isArray}get isStruct(){return this.type.isStruct}get isTemplate(){return this.type.isTemplate}get size(){return this.type.size}get align(){return this.type.isStruct?this.type.align:0}get members(){return this.type.isStruct?this.type.members:null}get format(){return this.type.isArray?this.type.format:this.type.isTemplate?this.type.format:null}get count(){return this.type.isArray?this.type.count:0}get stride(){return this.type.isArray?this.type.stride:this.size}},CG=class{constructor(A,j){this.name=A,this.type=j}},fB=class{constructor(A,j){this.align=A,this.size=j}},HG=class{constructor(A,j,e,r){this.name=A,this.type=j,this.locationType=e,this.location=r,this.interpolation=null}},t$=class{constructor(A,j,e,r){this.name=A,this.type=j,this.locationType=e,this.location=r}},DG=class{constructor(A,j,e,r){this.name=A,this.type=j,this.attributes=e,this.id=r}},NG=class{constructor(A,j){this.name=A,this.type=j}},KG=class{constructor(A,j=null){this.stage=null,this.inputs=[],this.outputs=[],this.arguments=[],this.returnType=null,this.resources=[],this.overrides=[],this.startLine=-1,this.endLine=-1,this.inUse=!1,this.calls=new Set,this.name=A,this.stage=j}},XG=class{constructor(){this.vertex=[],this.fragment=[],this.compute=[]}},zG=class{constructor(A){this.resources=null,this.inUse=!1,this.info=null,this.node=A}},mc=class t{constructor(A){this.uniforms=[],this.storage=[],this.textures=[],this.samplers=[],this.aliases=[],this.overrides=[],this.structs=[],this.entry=new XG,this.functions=[],this._types=new Map,this._functions=new Map,A&&this.update(A)}_isStorageTexture(A){return A.name=="texture_storage_1d"||A.name=="texture_storage_2d"||A.name=="texture_storage_2d_array"||A.name=="texture_storage_3d"}update(A){let e=new LG().parse(A);for(let r of e)r instanceof op&&this._functions.set(r.name,new zG(r));for(let r of e)if(r instanceof _a){let n=this._getTypeInfo(r,null);n instanceof uB&&this.structs.push(n)}for(let r of e){if(r instanceof NE){this.aliases.push(this._getAliasInfo(r));continue}if(r instanceof CE){let n=r,i=this._getAttributeNum(n.attributes,"id",0),o=n.type!=null?this._getTypeInfo(n.type,n.attributes):null;this.overrides.push(new DG(n.name,o,n.attributes,i));continue}if(this._isUniformVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=new BB(n.name,l,i,o,n.attributes,w7.Uniform,n.access);this.uniforms.push(c);continue}if(this._isStorageVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=this._isStorageTexture(l),B=new BB(n.name,l,i,o,n.attributes,c?w7.StorageTexture:w7.Storage,n.access);this.storage.push(B);continue}if(this._isTextureVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=this._isStorageTexture(l),B=new BB(n.name,l,i,o,n.attributes,c?w7.StorageTexture:w7.Texture,n.access);c?this.storage.push(B):this.textures.push(B);continue}if(this._isSamplerVar(r)){let n=r,i=this._getAttributeNum(n.attributes,"group",0),o=this._getAttributeNum(n.attributes,"binding",0),l=this._getTypeInfo(n.type,n.attributes),c=new BB(n.name,l,i,o,n.attributes,w7.Sampler,n.access);this.samplers.push(c);continue}if(r instanceof op){let n=this._getAttribute(r,"vertex"),i=this._getAttribute(r,"fragment"),o=this._getAttribute(r,"compute"),l=n||i||o,c=new KG(r.name,l?.name);c.startLine=r.startLine,c.endLine=r.endLine,this.functions.push(c),this._functions.get(r.name).info=c,l?(this._functions.get(r.name).inUse=!0,c.inUse=!0,c.resources=this._findResources(r,!!l),c.inputs=this._getInputs(r.args),c.outputs=this._getOutputs(r.returnType),this.entry[l.name].push(c)):(c.arguments=r.args.map(B=>new NG(B.name,this._getTypeInfo(B.type,B.attributes))),c.returnType=r.returnType?this._getTypeInfo(r.returnType,r.attributes):null);continue}}for(let r of this._functions.values())r.info&&(r.info.inUse=r.inUse,this._addCalls(r.node,r.info.calls));for(let r of this._functions.values())r.node.search(n=>{var i;if(n.astNodeType==="varExpr"){let o=n;for(let l of this.overrides)o.name==l.name&&((i=r.info)===null||i===void 0||i.overrides.push(l))}});for(let r of this.uniforms)this._markStructsInUse(r.type);for(let r of this.storage)this._markStructsInUse(r.type)}_markStructsInUse(A){if(A)if(A.isStruct){if(A.inUse=!0,A.members)for(let j of A.members)this._markStructsInUse(j.type)}else if(A.isArray)this._markStructsInUse(A.format);else if(A.isTemplate)A.format&&this._markStructsInUse(A.format);else{let j=this._getAlias(A.name);j&&this._markStructsInUse(j)}}_addCalls(A,j){var e;for(let r of A.calls){let n=(e=this._functions.get(r.name))===null||e===void 0?void 0:e.info;n&&j.add(n)}}findResource(A,j){for(let e of this.uniforms)if(e.group==A&&e.binding==j)return e;for(let e of this.storage)if(e.group==A&&e.binding==j)return e;for(let e of this.textures)if(e.group==A&&e.binding==j)return e;for(let e of this.samplers)if(e.group==A&&e.binding==j)return e;return null}_findResource(A){for(let j of this.uniforms)if(j.name==A)return j;for(let j of this.storage)if(j.name==A)return j;for(let j of this.textures)if(j.name==A)return j;for(let j of this.samplers)if(j.name==A)return j;return null}_markStructsFromAST(A){let j=this._getTypeInfo(A,null);this._markStructsInUse(j)}_findResources(A,j){let e=[],r=this,n=[];return A.search(i=>{if(i instanceof hB)n.push({});else if(i instanceof dB)n.pop();else if(i instanceof qa){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type),n.length>0&&(n[n.length-1][o.name]=o)}else if(i instanceof F7){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type)}else if(i instanceof sp){let o=i;j&&o.type!==null&&this._markStructsFromAST(o.type),n.length>0&&(n[n.length-1][o.name]=o)}else if(i instanceof lp){let o=i;if(n.length>0&&n[n.length-1][o.name])return;let l=r._findResource(o.name);l&&e.push(l)}else if(i instanceof zE){let o=i,l=r._functions.get(o.name);l&&(j&&(l.inUse=!0),A.calls.add(l.node),l.resources===null&&(l.resources=r._findResources(l.node,j)),e.push(...l.resources))}else if(i instanceof DE){let o=i,l=r._functions.get(o.name);l&&(j&&(l.inUse=!0),A.calls.add(l.node),l.resources===null&&(l.resources=r._findResources(l.node,j)),e.push(...l.resources))}}),[...new Map(e.map(i=>[i.name,i])).values()]}getBindGroups(){let A=[];function j(e,r){e>=A.length&&(A.length=e+1),A[e]===void 0&&(A[e]=[]),r>=A[e].length&&(A[e].length=r+1)}for(let e of this.uniforms){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.storage){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.textures){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}for(let e of this.samplers){j(e.group,e.binding);let r=A[e.group];r[e.binding]=e}return A}_getOutputs(A,j=void 0){if(j===void 0&&(j=[]),A instanceof _a)this._getStructOutputs(A,j);else{let e=this._getOutputInfo(A);e!==null&&j.push(e)}return j}_getStructOutputs(A,j){for(let e of A.members)if(e.type instanceof _a)this._getStructOutputs(e.type,j);else{let r=this._getAttribute(e,"location")||this._getAttribute(e,"builtin");if(r!==null){let n=this._getTypeInfo(e.type,e.type.attributes),i=this._parseInt(r.value),o=new t$(e.name,n,r.name,i);j.push(o)}}}_getOutputInfo(A){let j=this._getAttribute(A,"location")||this._getAttribute(A,"builtin");if(j!==null){let e=this._getTypeInfo(A,A.attributes),r=this._parseInt(j.value);return new t$("",e,j.name,r)}return null}_getInputs(A,j=void 0){j===void 0&&(j=[]);for(let e of A)if(e.type instanceof _a)this._getStructInputs(e.type,j);else{let r=this._getInputInfo(e);r!==null&&j.push(r)}return j}_getStructInputs(A,j){for(let e of A.members)if(e.type instanceof _a)this._getStructInputs(e.type,j);else{let r=this._getInputInfo(e);r!==null&&j.push(r)}}_getInputInfo(A){let j=this._getAttribute(A,"location")||this._getAttribute(A,"builtin");if(j!==null){let e=this._getAttribute(A,"interpolation"),r=this._getTypeInfo(A.type,A.attributes),n=this._parseInt(j.value),i=new HG(A.name,r,j.name,n);return e!==null&&(i.interpolation=this._parseString(e.value)),i}return null}_parseString(A){return A instanceof Array&&(A=A[0]),A}_parseInt(A){A instanceof Array&&(A=A[0]);let j=parseInt(A);return isNaN(j)?A:j}_getAlias(A){for(let j of this.aliases)if(j.name==A)return j.type;return null}_getAliasInfo(A){return new CG(A.name,this._getTypeInfo(A.type,null))}_getTypeInfo(A,j){if(this._types.has(A))return this._types.get(A);if(A instanceof XE){let r=A,n=r.format?this._getTypeInfo(r.format,r.attributes):null,i=new ip(r.name,j);return i.format=n,i.count=r.count,this._types.set(A,i),this._updateTypeInfo(i),i}if(A instanceof _a){let r=A,n=new uB(r.name,j);n.startLine=r.startLine,n.endLine=r.endLine;for(let i of r.members){let o=this._getTypeInfo(i.type,i.attributes);n.members.push(new ZE(i.name,o,i.attributes))}return this._types.set(A,n),this._updateTypeInfo(n),n}if(A instanceof gc){let r=A,n=r.format instanceof ba,i=r.format?n?this._getTypeInfo(r.format,null):new P7(r.format,null):null,o=new A$(r.name,i,j,r.access);return this._types.set(A,o),this._updateTypeInfo(o),o}if(A instanceof KE){let r=A,n=r.format?this._getTypeInfo(r.format,null):null,i=new A$(r.name,n,j,r.access);return this._types.set(A,i),this._updateTypeInfo(i),i}let e=new P7(A.name,j);return this._types.set(A,e),this._updateTypeInfo(e),e}_updateTypeInfo(A){var j,e;let r=this._getTypeSize(A);if(A.size=(j=r?.size)!==null&&j!==void 0?j:0,A instanceof ip&&A.format){let n=this._getTypeSize(A.format);A.stride=(e=n?.size)!==null&&e!==void 0?e:0,this._updateTypeInfo(A.format)}A instanceof uB&&this._updateStructInfo(A)}_updateStructInfo(A){var j;let e=0,r=0,n=0,i=0;for(let o=0,l=A.members.length;ot.name);mc._samplerTypes=z.sampler_type.map(t=>t.name);function UG(t){let A={attributes:[],bindings:[]},j;try{j=KJ(t)}catch(n){return mA.error(n.message)(),A}for(let n of j.uniforms){let i=[];for(let o of n.type?.members||[])i.push({name:o.name,type:DT(o.type)});A.bindings.push({type:"uniform",name:n.name,location:n.binding,group:n.group,members:i})}let e=j.entry.vertex[0],r=e?.inputs.length||0;for(let n=0;n`:t.name}function KJ(t){try{return new mc(t)}catch(A){if(A instanceof Error)throw A;let j="WGSL parse error";throw typeof A=="object"&&A?.message&&(j+=`: ${A.message} `),typeof A=="object"&&A?.token&&(j+=A.token.line||""),new Error(j,{cause:A})}}var XJ=`#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND const float TWO_PI = 6.2831854820251465; const float PI_2 = 1.5707963705062866; const float PI_16 = 0.1963495463132858; @@ -234,7 +234,7 @@ return tan_taylor_fp32(a); return tan(a); #endif } -`,Nb={name:"fp32",vs:LJ};var CJ=[0,1,1,1],HJ=`uniform pickingUniforms { +`,VG={name:"fp32",vs:XJ};var zJ=[0,1,1,1],UJ=`uniform pickingUniforms { float isActive; float isAttribute; float isHighlightActive; @@ -286,7 +286,7 @@ if (bool(picking.isAttribute)) { picking_vRGBcolor_Avalid.rgb = value; } } -`,DJ=`uniform pickingUniforms { +`,VJ=`uniform pickingUniforms { float isActive; float isAttribute; float isHighlightActive; @@ -323,7 +323,7 @@ vec4 picking_filterColor(vec4 color) { vec4 highlightColor = picking_filterHighlightColor(color); return picking_filterPickingColor(highlightColor); } -`,YE={name:"picking",vs:HJ,fs:DJ,uniformTypes:{isActive:"f32",isAttribute:"f32",isHighlightActive:"f32",useFloatColors:"f32",highlightedObjectColor:"vec3",highlightColor:"vec4"},defaultUniforms:{isActive:!1,isAttribute:!1,isHighlightActive:!1,useFloatColors:!0,highlightedObjectColor:[0,0,0],highlightColor:CJ},getUniforms:NJ};function NJ(t={},A){let j={};if(t.highlightedObjectColor!==void 0)if(t.highlightedObjectColor===null)j.isHighlightActive=!1;else{j.isHighlightActive=!0;let e=t.highlightedObjectColor.slice(0,3);j.highlightedObjectColor=e}if(t.highlightColor){let e=Array.from(t.highlightColor,r=>r/255);Number.isFinite(e[3])||(e[3]=1),j.highlightColor=e}return t.isActive!==void 0&&(j.isActive=!!t.isActive,j.isAttribute=!!t.isAttribute),t.useFloatColors!==void 0&&(j.useFloatColors=!!t.useFloatColors),j}function Kb(t,A=[],j=0){let e=Math.fround(t),r=t-e;return A[j]=e,A[j+1]=r,A}function ST(t){return t-Math.fround(t)}function RT(t){let A=new Float32Array(32);for(let j=0;j<4;++j)for(let e=0;e<4;++e){let r=j*4+e;Kb(t[e*4+j],A,r*2)}return A}var LT=`uniform float ONE; +`,j$={name:"picking",vs:UJ,fs:VJ,uniformTypes:{isActive:"f32",isAttribute:"f32",isHighlightActive:"f32",useFloatColors:"f32",highlightedObjectColor:"vec3",highlightColor:"vec4"},defaultUniforms:{isActive:!1,isAttribute:!1,isHighlightActive:!1,useFloatColors:!0,highlightedObjectColor:[0,0,0],highlightColor:zJ},getUniforms:QJ};function QJ(t={},A){let j={};if(t.highlightedObjectColor!==void 0)if(t.highlightedObjectColor===null)j.isHighlightActive=!1;else{j.isHighlightActive=!0;let e=t.highlightedObjectColor.slice(0,3);j.highlightedObjectColor=e}if(t.highlightColor){let e=Array.from(t.highlightColor,r=>r/255);Number.isFinite(e[3])||(e[3]=1),j.highlightColor=e}return t.isActive!==void 0&&(j.isActive=!!t.isActive,j.isAttribute=!!t.isAttribute),t.useFloatColors!==void 0&&(j.useFloatColors=!!t.useFloatColors),j}function QG(t,A=[],j=0){let e=Math.fround(t),r=t-e;return A[j]=e,A[j+1]=r,A}function NT(t){return t-Math.fround(t)}function KT(t){let A=new Float32Array(32);for(let j=0;j<4;++j)for(let e=0;e<4;++e){let r=j*4+e;QG(t[e*4+j],A,r*2)}return A}var XT=`uniform float ONE; vec2 split(float a) { const float SPLIT = 4097.0; float t = a * SPLIT; @@ -455,7 +455,7 @@ return sum_fp64(split(yn), prod); return sum_fp64(vec2(yn, 0.0), prod); #endif } -`;var KJ={ONE:1};function XJ(){return KJ}var Xb={name:"fp64-arithmetic",vs:LT,getUniforms:XJ,fp64ify:Kb,fp64LowPart:ST,fp64ifyMatrix4:RT};var n8A=1/Math.PI*180,i8A=1/180*Math.PI,zJ={EPSILON:1e-12,debug:!1,precision:4,printTypes:!1,printDegrees:!1,printRowMajor:!0,_cartographicRadians:!1};globalThis.mathgl=globalThis.mathgl||{config:{...zJ}};var pr=globalThis.mathgl.config;function zb(t,{precision:A=pr.precision}={}){return t=UJ(t),`${parseFloat(t.toPrecision(A))}`}function ba(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}function Kj(t,A,j){return QJ(t,e=>Math.max(A,Math.min(j,e)))}function uo(t,A,j){return ba(t)?t.map((e,r)=>uo(e,A[r],j)):j*A+(1-j)*t}function Bo(t,A,j){let e=pr.EPSILON;j&&(pr.EPSILON=j);try{if(t===A)return!0;if(ba(t)&&ba(A)){if(t.length!==A.length)return!1;for(let r=0;r0?", ":"")+zb(this[e],A);return`${A.printTypes?this.constructor.name:""}[${j}]`}equals(A){if(!A||this.length!==A.length)return!1;for(let j=0;j=0&&A=0&&AtZ,angle:()=>mZ,ceil:()=>jZ,clone:()=>YJ,copy:()=>ZJ,create:()=>CT,cross:()=>BZ,dist:()=>bZ,distance:()=>KT,div:()=>GZ,divide:()=>NT,dot:()=>uZ,equals:()=>yZ,exactEquals:()=>xZ,floor:()=>eZ,forEach:()=>PZ,fromValues:()=>JJ,inverse:()=>lZ,len:()=>vZ,length:()=>zT,lerp:()=>fZ,max:()=>nZ,min:()=>rZ,mul:()=>qZ,multiply:()=>DT,negate:()=>aZ,normalize:()=>cZ,random:()=>hZ,rotate:()=>gZ,round:()=>iZ,scale:()=>oZ,scaleAndAdd:()=>sZ,set:()=>AZ,sqrDist:()=>wZ,sqrLen:()=>FZ,squaredDistance:()=>XT,squaredLength:()=>UT,str:()=>$Z,sub:()=>_Z,subtract:()=>HT,transformMat2:()=>dZ,transformMat2d:()=>pZ,transformMat3:()=>kZ,transformMat4:()=>Vb,zero:()=>EZ});var de=typeof Float32Array<"u"?Float32Array:Array,ns=Math.random;function yi(t){return t>=0?Math.round(t):t%.5===0?Math.floor(t):Math.round(t)}var p8A=Math.PI/180;function CT(){let t=new de(2);return de!=Float32Array&&(t[0]=0,t[1]=0),t}function YJ(t){let A=new de(2);return A[0]=t[0],A[1]=t[1],A}function JJ(t,A){let j=new de(2);return j[0]=t,j[1]=A,j}function ZJ(t,A){return t[0]=A[0],t[1]=A[1],t}function AZ(t,A,j){return t[0]=A,t[1]=j,t}function tZ(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t}function HT(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t}function DT(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t}function NT(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t}function jZ(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t}function eZ(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t}function rZ(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t}function nZ(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t}function iZ(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t}function oZ(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t}function sZ(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t}function KT(t,A){let j=A[0]-t[0],e=A[1]-t[1];return Math.sqrt(j*j+e*e)}function XT(t,A){let j=A[0]-t[0],e=A[1]-t[1];return j*j+e*e}function zT(t){let A=t[0],j=t[1];return Math.sqrt(A*A+j*j)}function UT(t){let A=t[0],j=t[1];return A*A+j*j}function aZ(t,A){return t[0]=-A[0],t[1]=-A[1],t}function lZ(t,A){return t[0]=1/A[0],t[1]=1/A[1],t}function cZ(t,A){let j=A[0],e=A[1],r=j*j+e*e;return r>0&&(r=1/Math.sqrt(r)),t[0]=A[0]*r,t[1]=A[1]*r,t}function uZ(t,A){return t[0]*A[0]+t[1]*A[1]}function BZ(t,A,j){let e=A[0]*j[1]-A[1]*j[0];return t[0]=t[1]=0,t[2]=e,t}function fZ(t,A,j,e){let r=A[0],n=A[1];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t}function hZ(t,A){A=A===void 0?1:A;let j=ns()*2*Math.PI;return t[0]=Math.cos(j)*A,t[1]=Math.sin(j)*A,t}function dZ(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r,t[1]=j[1]*e+j[3]*r,t}function pZ(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r+j[4],t[1]=j[1]*e+j[3]*r+j[5],t}function kZ(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[3]*r+j[6],t[1]=j[1]*e+j[4]*r+j[7],t}function Vb(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[4]*r+j[12],t[1]=j[1]*e+j[5]*r+j[13],t}function gZ(t,A,j,e){let r=A[0]-j[0],n=A[1]-j[1],i=Math.sin(e),o=Math.cos(e);return t[0]=r*o-n*i+j[0],t[1]=r*i+n*o+j[1],t}function mZ(t,A){let j=t[0],e=t[1],r=A[0],n=A[1],i=Math.sqrt((j*j+e*e)*(r*r+n*n)),o=i&&(j*r+e*n)/i;return Math.acos(Math.min(Math.max(o,-1),1))}function EZ(t){return t[0]=0,t[1]=0,t}function $Z(t){return`vec2(${t[0]}, ${t[1]})`}function xZ(t,A){return t[0]===A[0]&&t[1]===A[1]}function yZ(t,A){let j=t[0],e=t[1],r=A[0],n=A[1];return Math.abs(j-r)<=1e-6*Math.max(1,Math.abs(j),Math.abs(r))&&Math.abs(e-n)<=1e-6*Math.max(1,Math.abs(e),Math.abs(n))}var vZ=zT,_Z=HT,qZ=DT,GZ=NT,bZ=KT,wZ=XT,FZ=UT,PZ=function(){let t=CT();return function(A,j,e,r,n,i){let o,l;for(j||(j=2),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oSZ,angle:()=>jw,bezier:()=>YZ,ceil:()=>RZ,clone:()=>IZ,copy:()=>OZ,create:()=>WT,cross:()=>Wb,dist:()=>iAA,distance:()=>tS,div:()=>nAA,divide:()=>AS,dot:()=>Qb,equals:()=>jAA,exactEquals:()=>tAA,floor:()=>LZ,forEach:()=>lAA,fromValues:()=>MZ,hermite:()=>WZ,inverse:()=>zZ,len:()=>sAA,length:()=>YT,lerp:()=>VZ,max:()=>HZ,min:()=>CZ,mul:()=>rAA,multiply:()=>ZT,negate:()=>XZ,normalize:()=>UZ,random:()=>JZ,rotateX:()=>Zb,rotateY:()=>Aw,rotateZ:()=>tw,round:()=>DZ,scale:()=>NZ,scaleAndAdd:()=>KZ,set:()=>TZ,slerp:()=>QZ,sqrDist:()=>oAA,sqrLen:()=>aAA,squaredDistance:()=>jS,squaredLength:()=>eS,str:()=>AAA,sub:()=>eAA,subtract:()=>JT,transformMat3:()=>Yb,transformMat4:()=>ap,transformQuat:()=>Jb,zero:()=>ZZ});function WT(){let t=new de(3);return de!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t}function IZ(t){let A=new de(3);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A}function YT(t){let A=t[0],j=t[1],e=t[2];return Math.sqrt(A*A+j*j+e*e)}function MZ(t,A,j){let e=new de(3);return e[0]=t,e[1]=A,e[2]=j,e}function OZ(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t}function TZ(t,A,j,e){return t[0]=A,t[1]=j,t[2]=e,t}function SZ(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t}function JT(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t}function ZT(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t}function AS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t}function RZ(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t}function LZ(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t}function CZ(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t}function HZ(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t}function DZ(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t[2]=yi(A[2]),t}function NZ(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t}function KZ(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t}function tS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return Math.sqrt(j*j+e*e+r*r)}function jS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return j*j+e*e+r*r}function eS(t){let A=t[0],j=t[1],e=t[2];return A*A+j*j+e*e}function XZ(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t}function zZ(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t}function UZ(t,A){let j=A[0],e=A[1],r=A[2],n=j*j+e*e+r*r;return n>0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function Qb(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function Wb(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function VZ(t,A,j,e){let r=A[0],n=A[1],i=A[2];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t}function QZ(t,A,j,e){let r=Math.acos(Math.min(Math.max(Qb(A,j),-1),1)),n=Math.sin(r),i=Math.sin((1-e)*r)/n,o=Math.sin(e*r)/n;return t[0]=i*A[0]+o*j[0],t[1]=i*A[1]+o*j[1],t[2]=i*A[2]+o*j[2],t}function WZ(t,A,j,e,r,n){let i=n*n,o=i*(2*n-3)+1,l=i*(n-2)+n,c=i*(n-1),B=i*(3-2*n);return t[0]=A[0]*o+j[0]*l+e[0]*c+r[0]*B,t[1]=A[1]*o+j[1]*l+e[1]*c+r[1]*B,t[2]=A[2]*o+j[2]*l+e[2]*c+r[2]*B,t}function YZ(t,A,j,e,r,n){let i=1-n,o=i*i,l=n*n,c=o*i,B=3*n*o,h=3*l*i,d=l*n;return t[0]=A[0]*c+j[0]*B+e[0]*h+r[0]*d,t[1]=A[1]*c+j[1]*B+e[1]*h+r[1]*d,t[2]=A[2]*c+j[2]*B+e[2]*h+r[2]*d,t}function JZ(t,A){A=A===void 0?1:A;let j=ns()*2*Math.PI,e=ns()*2-1,r=Math.sqrt(1-e*e)*A;return t[0]=Math.cos(j)*r,t[1]=Math.sin(j)*r,t[2]=e*A,t}function ap(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function Yb(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function Jb(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function Zb(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function Aw(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function tw(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function jw(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&Qb(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}function ZZ(t){return t[0]=0,t[1]=0,t[2]=0,t}function AAA(t){return`vec3(${t[0]}, ${t[1]}, ${t[2]})`}function tAA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]}function jAA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2];return Math.abs(j-n)<=1e-6*Math.max(1,Math.abs(j),Math.abs(n))&&Math.abs(e-i)<=1e-6*Math.max(1,Math.abs(e),Math.abs(i))&&Math.abs(r-o)<=1e-6*Math.max(1,Math.abs(r),Math.abs(o))}var eAA=JT,rAA=ZT,nAA=AS,iAA=tS,oAA=jS,sAA=YT,aAA=eS,lAA=function(){let t=WT();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oOAA,adjoint:()=>dAA,clone:()=>uAA,copy:()=>BAA,create:()=>cAA,decompose:()=>_AA,determinant:()=>iw,equals:()=>LAA,exactEquals:()=>RAA,frob:()=>MAA,fromQuat:()=>Bw,fromQuat2:()=>xAA,fromRotation:()=>gAA,fromRotationTranslation:()=>nS,fromRotationTranslationScale:()=>qAA,fromRotationTranslationScaleOrigin:()=>GAA,fromScaling:()=>kAA,fromTranslation:()=>pAA,fromValues:()=>fAA,fromXRotation:()=>mAA,fromYRotation:()=>EAA,fromZRotation:()=>$AA,frustum:()=>fw,getRotation:()=>vAA,getScaling:()=>iS,getTranslation:()=>yAA,identity:()=>rS,invert:()=>nw,lookAt:()=>pw,mul:()=>CAA,multiply:()=>lp,multiplyScalar:()=>TAA,multiplyScalarAndAdd:()=>SAA,ortho:()=>dw,orthoNO:()=>sS,orthoZO:()=>FAA,perspective:()=>hw,perspectiveFromFieldOfView:()=>wAA,perspectiveNO:()=>oS,perspectiveZO:()=>bAA,rotate:()=>aw,rotateX:()=>lw,rotateY:()=>cw,rotateZ:()=>uw,scale:()=>sw,set:()=>hAA,str:()=>IAA,sub:()=>HAA,subtract:()=>aS,targetTo:()=>PAA,translate:()=>ow,transpose:()=>rw});function cAA(){let t=new de(16);return de!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function uAA(t){let A=new de(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function BAA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function fAA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new de(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function hAA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function rS(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function rw(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function nw(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m,G=b*W-v*T+_*z+w*L-x*D+S*F;return G?(G=1/G,t[0]=(o*W-l*T+c*z)*G,t[1]=(r*T-e*W-n*z)*G,t[2]=(E*S-m*x+y*w)*G,t[3]=(d*x-h*S-k*w)*G,t[4]=(l*L-i*W-c*D)*G,t[5]=(j*W-r*L+n*D)*G,t[6]=(m*_-g*S-y*v)*G,t[7]=(B*S-d*_+k*v)*G,t[8]=(i*T-o*L+c*F)*G,t[9]=(e*L-j*T-n*F)*G,t[10]=(g*x-E*_+y*b)*G,t[11]=(h*_-B*x-k*b)*G,t[12]=(o*D-i*z-l*F)*G,t[13]=(j*z-e*D+r*F)*G,t[14]=(E*v-g*w-m*b)*G,t[15]=(B*w-h*v+d*b)*G,t):null}function dAA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m;return t[0]=o*W-l*T+c*z,t[1]=r*T-e*W-n*z,t[2]=E*S-m*x+y*w,t[3]=d*x-h*S-k*w,t[4]=l*L-i*W-c*D,t[5]=j*W-r*L+n*D,t[6]=m*_-g*S-y*v,t[7]=B*S-d*_+k*v,t[8]=i*T-o*L+c*F,t[9]=e*L-j*T-n*F,t[10]=g*x-E*_+y*b,t[11]=h*_-B*x-k*b,t[12]=o*D-i*z-l*F,t[13]=j*z-e*D+r*F,t[14]=E*v-g*w-m*b,t[15]=B*w-h*v+d*b,t}function iw(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,b=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,S=A*x-j*w+e*_,F=n*x-i*w+o*_,D=c*v-B*b+h*y,L=k*v-g*b+E*y;return l*S-r*F+m*D-d*L}function lp(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],b=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*b,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*b,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*b,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*b,t}function ow(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function sw(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function aw(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,b,v,_,w,x,S,F,D,L,z,T,W,G,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],b=A[7],v=A[8],_=A[9],w=A[10],x=A[11],S=r*r*B+l,F=n*r*B+i*c,D=i*r*B-n*c,L=r*n*B-i*c,z=n*n*B+l,T=i*n*B+r*c,W=r*i*B+n*c,G=n*i*B-r*c,jA=i*i*B+l,t[0]=h*S+E*F+v*D,t[1]=d*S+m*F+_*D,t[2]=k*S+y*F+w*D,t[3]=g*S+b*F+x*D,t[4]=h*L+E*z+v*T,t[5]=d*L+m*z+_*T,t[6]=k*L+y*z+w*T,t[7]=g*L+b*z+x*T,t[8]=h*W+E*G+v*jA,t[9]=d*W+m*G+_*jA,t[10]=k*W+y*G+w*jA,t[11]=g*W+b*G+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function lw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function cw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function uw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function pAA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function kAA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function gAA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function mAA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function EAA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function $AA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function nS(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,b=i*c;return t[0]=1-(k+E),t[1]=h+b,t[2]=d-y,t[3]=0,t[4]=h-b,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function xAA(t,A){let j=new de(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),nS(t,A,j),t}function yAA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function iS(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function vAA(t,A){let j=new de(3);iS(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function _AA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,b=i*E,v=o*k,_=l*g,w=c*E,x=B*k,S=h*g,F=d*E,D=m+_+F,L=0;return D>0?(L=Math.sqrt(D+1)*2,t[3]=.25*L,t[0]=(w-S)/L,t[1]=(x-b)/L,t[2]=(y-v)/L):m>_&&m>F?(L=Math.sqrt(1+m-_-F)*2,t[3]=(w-S)/L,t[0]=.25*L,t[1]=(y+v)/L,t[2]=(x+b)/L):_>F?(L=Math.sqrt(1+_-m-F)*2,t[3]=(x-b)/L,t[0]=(y+v)/L,t[1]=.25*L,t[2]=(w+S)/L):(L=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/L,t[0]=(x+b)/L,t[1]=(w+S)/L,t[2]=.25*L),t}function qAA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,b=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-b)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+b)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function GAA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,b=l*c,v=l*B,_=l*h,w=e[0],x=e[1],S=e[2],F=r[0],D=r[1],L=r[2],z=(1-(E+y))*w,T=(k+_)*w,W=(g-v)*w,G=(k-_)*x,jA=(1-(d+y))*x,pA=(m+b)*x,dA=(g+v)*S,$A=(m-b)*S,_A=(1-(d+E))*S;return t[0]=z,t[1]=T,t[2]=W,t[3]=0,t[4]=G,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(z*F+G*D+dA*L),t[13]=j[1]+D-(T*F+jA*D+$A*L),t[14]=j[2]+L-(W*F+pA*D+_A*L),t[15]=1,t}function Bw(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function fw(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function oS(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var hw=oS;function bAA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function wAA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function sS(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var dw=sS;function FAA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function pw(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],b=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?rS(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=b*k-v*d,i=v*h-y*k,o=y*d-b*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function PAA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function IAA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function MAA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function OAA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function aS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function TAA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function SAA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function RAA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function LAA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],b=A[0],v=A[1],_=A[2],w=A[3],x=A[4],S=A[5],F=A[6],D=A[7],L=A[8],z=A[9],T=A[10],W=A[11],G=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-b)<=1e-6*Math.max(1,Math.abs(j),Math.abs(b))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-S)<=1e-6*Math.max(1,Math.abs(o),Math.abs(S))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-D)<=1e-6*Math.max(1,Math.abs(c),Math.abs(D))&&Math.abs(B-L)<=1e-6*Math.max(1,Math.abs(B),Math.abs(L))&&Math.abs(h-z)<=1e-6*Math.max(1,Math.abs(h),Math.abs(z))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-W)<=1e-6*Math.max(1,Math.abs(k),Math.abs(W))&&Math.abs(g-G)<=1e-6*Math.max(1,Math.abs(g),Math.abs(G))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var CAA=lp,HAA=aS;var os={};fr(os,{add:()=>zAA,ceil:()=>UAA,clone:()=>DAA,copy:()=>KAA,create:()=>lS,cross:()=>rtA,dist:()=>htA,distance:()=>fS,div:()=>ftA,divide:()=>BS,dot:()=>etA,equals:()=>ctA,exactEquals:()=>ltA,floor:()=>VAA,forEach:()=>gtA,fromValues:()=>NAA,inverse:()=>ttA,len:()=>ptA,length:()=>dS,lerp:()=>ntA,max:()=>WAA,min:()=>QAA,mul:()=>BtA,multiply:()=>uS,negate:()=>AtA,normalize:()=>jtA,random:()=>itA,round:()=>YAA,scale:()=>JAA,scaleAndAdd:()=>ZAA,set:()=>XAA,sqrDist:()=>dtA,sqrLen:()=>ktA,squaredDistance:()=>hS,squaredLength:()=>pS,str:()=>atA,sub:()=>utA,subtract:()=>cS,transformMat4:()=>kw,transformQuat:()=>otA,zero:()=>stA});function lS(){let t=new de(4);return de!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function DAA(t){let A=new de(4);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A}function NAA(t,A,j,e){let r=new de(4);return r[0]=t,r[1]=A,r[2]=j,r[3]=e,r}function KAA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t}function XAA(t,A,j,e,r){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t}function zAA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function cS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t}function uS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t[3]=A[3]*j[3],t}function BS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t[3]=A[3]/j[3],t}function UAA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t[3]=Math.ceil(A[3]),t}function VAA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t[3]=Math.floor(A[3]),t}function QAA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t[3]=Math.min(A[3],j[3]),t}function WAA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t[3]=Math.max(A[3],j[3]),t}function YAA(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t[2]=yi(A[2]),t[3]=yi(A[3]),t}function JAA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function ZAA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t}function fS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return Math.sqrt(j*j+e*e+r*r+n*n)}function hS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return j*j+e*e+r*r+n*n}function dS(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function pS(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function AtA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=-A[3],t}function ttA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t[3]=1/A[3],t}function jtA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function etA(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function rtA(t,A,j,e){let r=j[0]*e[1]-j[1]*e[0],n=j[0]*e[2]-j[2]*e[0],i=j[0]*e[3]-j[3]*e[0],o=j[1]*e[2]-j[2]*e[1],l=j[1]*e[3]-j[3]*e[1],c=j[2]*e[3]-j[3]*e[2],B=A[0],h=A[1],d=A[2],k=A[3];return t[0]=h*c-d*l+k*o,t[1]=-(B*c)+d*i-k*n,t[2]=B*l-h*i+k*r,t[3]=-(B*o)+h*n-d*r,t}function ntA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function itA(t,A){A=A===void 0?1:A;let j,e,r,n,i,o;do j=ns()*2-1,e=ns()*2-1,i=j*j+e*e;while(i>=1);do r=ns()*2-1,n=ns()*2-1,o=r*r+n*n;while(o>=1);let l=Math.sqrt((1-i)/o);return t[0]=A*j,t[1]=A*e,t[2]=A*r*l,t[3]=A*n*l,t}function kw(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3];return t[0]=j[0]*e+j[4]*r+j[8]*n+j[12]*i,t[1]=j[1]*e+j[5]*r+j[9]*n+j[13]*i,t[2]=j[2]*e+j[6]*r+j[10]*n+j[14]*i,t[3]=j[3]*e+j[7]*r+j[11]*n+j[15]*i,t}function otA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}function stA(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}function atA(t){return`vec4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]})`}function ltA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]}function ctA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=A[0],o=A[1],l=A[2],c=A[3];return Math.abs(j-i)<=1e-6*Math.max(1,Math.abs(j),Math.abs(i))&&Math.abs(e-o)<=1e-6*Math.max(1,Math.abs(e),Math.abs(o))&&Math.abs(r-l)<=1e-6*Math.max(1,Math.abs(r),Math.abs(l))&&Math.abs(n-c)<=1e-6*Math.max(1,Math.abs(n),Math.abs(c))}var utA=cS,BtA=uS,ftA=BS,htA=fS,dtA=hS,ptA=dS,ktA=pS,gtA=function(){let t=lS();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oMath.PI*2)throw Error("expected radians")}function vtA(t,A,j,e,r,n){let i=2*n/(j-A),o=2*n/(r-e),l=(j+A)/(j-A),c=(r+e)/(r-e),B=-1,h=-1,d=-2*n;return t[0]=i,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=o,t[6]=0,t[7]=0,t[8]=l,t[9]=c,t[10]=B,t[11]=h,t[12]=0,t[13]=0,t[14]=d,t[15]=0,t}var $w=`#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX)) +`;var WJ={ONE:1};function YJ(){return WJ}var WG={name:"fp64-arithmetic",vs:XT,getUniforms:YJ,fp64ify:QG,fp64LowPart:NT,fp64ifyMatrix4:KT};var u8A=1/Math.PI*180,B8A=1/180*Math.PI,JJ={EPSILON:1e-12,debug:!1,precision:4,printTypes:!1,printDegrees:!1,printRowMajor:!0,_cartographicRadians:!1};globalThis.mathgl=globalThis.mathgl||{config:{...JJ}};var pr=globalThis.mathgl.config;function YG(t,{precision:A=pr.precision}={}){return t=ZJ(t),`${parseFloat(t.toPrecision(A))}`}function Ga(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}function Kj(t,A,j){return tZ(t,e=>Math.max(A,Math.min(j,e)))}function uo(t,A,j){return Ga(t)?t.map((e,r)=>uo(e,A[r],j)):j*A+(1-j)*t}function Bo(t,A,j){let e=pr.EPSILON;j&&(pr.EPSILON=j);try{if(t===A)return!0;if(Ga(t)&&Ga(A)){if(t.length!==A.length)return!1;for(let r=0;r0?", ":"")+YG(this[e],A);return`${A.printTypes?this.constructor.name:""}[${j}]`}equals(A){if(!A||this.length!==A.length)return!1;for(let j=0;j=0&&A=0&&AoZ,angle:()=>_Z,ceil:()=>sZ,clone:()=>eZ,copy:()=>nZ,create:()=>zT,cross:()=>gZ,dist:()=>OZ,distance:()=>WT,div:()=>MZ,divide:()=>QT,dot:()=>kZ,equals:()=>wZ,exactEquals:()=>GZ,floor:()=>aZ,forEach:()=>RZ,fromValues:()=>rZ,inverse:()=>dZ,len:()=>FZ,length:()=>JT,lerp:()=>mZ,max:()=>cZ,min:()=>lZ,mul:()=>IZ,multiply:()=>VT,negate:()=>hZ,normalize:()=>pZ,random:()=>EZ,rotate:()=>vZ,round:()=>uZ,scale:()=>BZ,scaleAndAdd:()=>fZ,set:()=>iZ,sqrDist:()=>TZ,sqrLen:()=>SZ,squaredDistance:()=>YT,squaredLength:()=>ZT,str:()=>bZ,sub:()=>PZ,subtract:()=>UT,transformMat2:()=>$Z,transformMat2d:()=>xZ,transformMat3:()=>yZ,transformMat4:()=>ZG,zero:()=>qZ});var de=typeof Float32Array<"u"?Float32Array:Array,ns=Math.random;function yi(t){return t>=0?Math.round(t):t%.5===0?Math.floor(t):Math.round(t)}var y8A=Math.PI/180;function zT(){let t=new de(2);return de!=Float32Array&&(t[0]=0,t[1]=0),t}function eZ(t){let A=new de(2);return A[0]=t[0],A[1]=t[1],A}function rZ(t,A){let j=new de(2);return j[0]=t,j[1]=A,j}function nZ(t,A){return t[0]=A[0],t[1]=A[1],t}function iZ(t,A,j){return t[0]=A,t[1]=j,t}function oZ(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t}function UT(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t}function VT(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t}function QT(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t}function sZ(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t}function aZ(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t}function lZ(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t}function cZ(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t}function uZ(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t}function BZ(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t}function fZ(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t}function WT(t,A){let j=A[0]-t[0],e=A[1]-t[1];return Math.sqrt(j*j+e*e)}function YT(t,A){let j=A[0]-t[0],e=A[1]-t[1];return j*j+e*e}function JT(t){let A=t[0],j=t[1];return Math.sqrt(A*A+j*j)}function ZT(t){let A=t[0],j=t[1];return A*A+j*j}function hZ(t,A){return t[0]=-A[0],t[1]=-A[1],t}function dZ(t,A){return t[0]=1/A[0],t[1]=1/A[1],t}function pZ(t,A){let j=A[0],e=A[1],r=j*j+e*e;return r>0&&(r=1/Math.sqrt(r)),t[0]=A[0]*r,t[1]=A[1]*r,t}function kZ(t,A){return t[0]*A[0]+t[1]*A[1]}function gZ(t,A,j){let e=A[0]*j[1]-A[1]*j[0];return t[0]=t[1]=0,t[2]=e,t}function mZ(t,A,j,e){let r=A[0],n=A[1];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t}function EZ(t,A){A=A===void 0?1:A;let j=ns()*2*Math.PI;return t[0]=Math.cos(j)*A,t[1]=Math.sin(j)*A,t}function $Z(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r,t[1]=j[1]*e+j[3]*r,t}function xZ(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r+j[4],t[1]=j[1]*e+j[3]*r+j[5],t}function yZ(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[3]*r+j[6],t[1]=j[1]*e+j[4]*r+j[7],t}function ZG(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[4]*r+j[12],t[1]=j[1]*e+j[5]*r+j[13],t}function vZ(t,A,j,e){let r=A[0]-j[0],n=A[1]-j[1],i=Math.sin(e),o=Math.cos(e);return t[0]=r*o-n*i+j[0],t[1]=r*i+n*o+j[1],t}function _Z(t,A){let j=t[0],e=t[1],r=A[0],n=A[1],i=Math.sqrt((j*j+e*e)*(r*r+n*n)),o=i&&(j*r+e*n)/i;return Math.acos(Math.min(Math.max(o,-1),1))}function qZ(t){return t[0]=0,t[1]=0,t}function bZ(t){return`vec2(${t[0]}, ${t[1]})`}function GZ(t,A){return t[0]===A[0]&&t[1]===A[1]}function wZ(t,A){let j=t[0],e=t[1],r=A[0],n=A[1];return Math.abs(j-r)<=1e-6*Math.max(1,Math.abs(j),Math.abs(r))&&Math.abs(e-n)<=1e-6*Math.max(1,Math.abs(e),Math.abs(n))}var FZ=JT,PZ=UT,IZ=VT,MZ=QT,OZ=WT,TZ=YT,SZ=ZT,RZ=function(){let t=zT();return function(A,j,e,r,n,i){let o,l;for(j||(j=2),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oNZ,angle:()=>ow,bezier:()=>eAA,ceil:()=>KZ,clone:()=>LZ,copy:()=>HZ,create:()=>jS,cross:()=>tw,dist:()=>uAA,distance:()=>oS,div:()=>cAA,divide:()=>iS,dot:()=>Aw,equals:()=>sAA,exactEquals:()=>oAA,floor:()=>XZ,forEach:()=>dAA,fromValues:()=>CZ,hermite:()=>jAA,inverse:()=>JZ,len:()=>fAA,length:()=>eS,lerp:()=>AAA,max:()=>UZ,min:()=>zZ,mul:()=>lAA,multiply:()=>nS,negate:()=>YZ,normalize:()=>ZZ,random:()=>rAA,rotateX:()=>rw,rotateY:()=>nw,rotateZ:()=>iw,round:()=>VZ,scale:()=>QZ,scaleAndAdd:()=>WZ,set:()=>DZ,slerp:()=>tAA,sqrDist:()=>BAA,sqrLen:()=>hAA,squaredDistance:()=>sS,squaredLength:()=>aS,str:()=>iAA,sub:()=>aAA,subtract:()=>rS,transformMat3:()=>jw,transformMat4:()=>cp,transformQuat:()=>ew,zero:()=>nAA});function jS(){let t=new de(3);return de!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t}function LZ(t){let A=new de(3);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A}function eS(t){let A=t[0],j=t[1],e=t[2];return Math.sqrt(A*A+j*j+e*e)}function CZ(t,A,j){let e=new de(3);return e[0]=t,e[1]=A,e[2]=j,e}function HZ(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t}function DZ(t,A,j,e){return t[0]=A,t[1]=j,t[2]=e,t}function NZ(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t}function rS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t}function nS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t}function iS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t}function KZ(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t}function XZ(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t}function zZ(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t}function UZ(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t}function VZ(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t[2]=yi(A[2]),t}function QZ(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t}function WZ(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t}function oS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return Math.sqrt(j*j+e*e+r*r)}function sS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return j*j+e*e+r*r}function aS(t){let A=t[0],j=t[1],e=t[2];return A*A+j*j+e*e}function YZ(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t}function JZ(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t}function ZZ(t,A){let j=A[0],e=A[1],r=A[2],n=j*j+e*e+r*r;return n>0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function Aw(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function tw(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function AAA(t,A,j,e){let r=A[0],n=A[1],i=A[2];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t}function tAA(t,A,j,e){let r=Math.acos(Math.min(Math.max(Aw(A,j),-1),1)),n=Math.sin(r),i=Math.sin((1-e)*r)/n,o=Math.sin(e*r)/n;return t[0]=i*A[0]+o*j[0],t[1]=i*A[1]+o*j[1],t[2]=i*A[2]+o*j[2],t}function jAA(t,A,j,e,r,n){let i=n*n,o=i*(2*n-3)+1,l=i*(n-2)+n,c=i*(n-1),B=i*(3-2*n);return t[0]=A[0]*o+j[0]*l+e[0]*c+r[0]*B,t[1]=A[1]*o+j[1]*l+e[1]*c+r[1]*B,t[2]=A[2]*o+j[2]*l+e[2]*c+r[2]*B,t}function eAA(t,A,j,e,r,n){let i=1-n,o=i*i,l=n*n,c=o*i,B=3*n*o,h=3*l*i,d=l*n;return t[0]=A[0]*c+j[0]*B+e[0]*h+r[0]*d,t[1]=A[1]*c+j[1]*B+e[1]*h+r[1]*d,t[2]=A[2]*c+j[2]*B+e[2]*h+r[2]*d,t}function rAA(t,A){A=A===void 0?1:A;let j=ns()*2*Math.PI,e=ns()*2-1,r=Math.sqrt(1-e*e)*A;return t[0]=Math.cos(j)*r,t[1]=Math.sin(j)*r,t[2]=e*A,t}function cp(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function jw(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function ew(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function rw(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function nw(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function iw(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function ow(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&Aw(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}function nAA(t){return t[0]=0,t[1]=0,t[2]=0,t}function iAA(t){return`vec3(${t[0]}, ${t[1]}, ${t[2]})`}function oAA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]}function sAA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2];return Math.abs(j-n)<=1e-6*Math.max(1,Math.abs(j),Math.abs(n))&&Math.abs(e-i)<=1e-6*Math.max(1,Math.abs(e),Math.abs(i))&&Math.abs(r-o)<=1e-6*Math.max(1,Math.abs(r),Math.abs(o))}var aAA=rS,lAA=nS,cAA=iS,uAA=oS,BAA=sS,fAA=eS,hAA=aS,dAA=function(){let t=jS();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oHAA,adjoint:()=>$AA,clone:()=>kAA,copy:()=>gAA,create:()=>pAA,decompose:()=>PAA,determinant:()=>cw,equals:()=>XAA,exactEquals:()=>KAA,frob:()=>CAA,fromQuat:()=>kw,fromQuat2:()=>GAA,fromRotation:()=>vAA,fromRotationTranslation:()=>cS,fromRotationTranslationScale:()=>IAA,fromRotationTranslationScaleOrigin:()=>MAA,fromScaling:()=>yAA,fromTranslation:()=>xAA,fromValues:()=>mAA,fromXRotation:()=>_AA,fromYRotation:()=>qAA,fromZRotation:()=>bAA,frustum:()=>gw,getRotation:()=>FAA,getScaling:()=>uS,getTranslation:()=>wAA,identity:()=>lS,invert:()=>lw,lookAt:()=>$w,mul:()=>zAA,multiply:()=>up,multiplyScalar:()=>DAA,multiplyScalarAndAdd:()=>NAA,ortho:()=>Ew,orthoNO:()=>fS,orthoZO:()=>SAA,perspective:()=>mw,perspectiveFromFieldOfView:()=>TAA,perspectiveNO:()=>BS,perspectiveZO:()=>OAA,rotate:()=>fw,rotateX:()=>hw,rotateY:()=>dw,rotateZ:()=>pw,scale:()=>Bw,set:()=>EAA,str:()=>LAA,sub:()=>UAA,subtract:()=>hS,targetTo:()=>RAA,translate:()=>uw,transpose:()=>aw});function pAA(){let t=new de(16);return de!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function kAA(t){let A=new de(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function gAA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function mAA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new de(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function EAA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function lS(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function aw(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function lw(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m,b=G*Q-v*T+_*X+w*R-x*C+O*F;return b?(b=1/b,t[0]=(o*Q-l*T+c*X)*b,t[1]=(r*T-e*Q-n*X)*b,t[2]=(E*O-m*x+y*w)*b,t[3]=(d*x-h*O-k*w)*b,t[4]=(l*R-i*Q-c*C)*b,t[5]=(j*Q-r*R+n*C)*b,t[6]=(m*_-g*O-y*v)*b,t[7]=(B*O-d*_+k*v)*b,t[8]=(i*T-o*R+c*F)*b,t[9]=(e*R-j*T-n*F)*b,t[10]=(g*x-E*_+y*G)*b,t[11]=(h*_-B*x-k*G)*b,t[12]=(o*C-i*X-l*F)*b,t[13]=(j*X-e*C+r*F)*b,t[14]=(E*v-g*w-m*G)*b,t[15]=(B*w-h*v+d*G)*b,t):null}function $AA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m;return t[0]=o*Q-l*T+c*X,t[1]=r*T-e*Q-n*X,t[2]=E*O-m*x+y*w,t[3]=d*x-h*O-k*w,t[4]=l*R-i*Q-c*C,t[5]=j*Q-r*R+n*C,t[6]=m*_-g*O-y*v,t[7]=B*O-d*_+k*v,t[8]=i*T-o*R+c*F,t[9]=e*R-j*T-n*F,t[10]=g*x-E*_+y*G,t[11]=h*_-B*x-k*G,t[12]=o*C-i*X-l*F,t[13]=j*X-e*C+r*F,t[14]=E*v-g*w-m*G,t[15]=B*w-h*v+d*G,t}function cw(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,G=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,O=A*x-j*w+e*_,F=n*x-i*w+o*_,C=c*v-B*G+h*y,R=k*v-g*G+E*y;return l*O-r*F+m*C-d*R}function up(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],G=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*G,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*G,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*G,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*G,t}function uw(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function Bw(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function fw(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,G,v,_,w,x,O,F,C,R,X,T,Q,b,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],G=A[7],v=A[8],_=A[9],w=A[10],x=A[11],O=r*r*B+l,F=n*r*B+i*c,C=i*r*B-n*c,R=r*n*B-i*c,X=n*n*B+l,T=i*n*B+r*c,Q=r*i*B+n*c,b=n*i*B-r*c,jA=i*i*B+l,t[0]=h*O+E*F+v*C,t[1]=d*O+m*F+_*C,t[2]=k*O+y*F+w*C,t[3]=g*O+G*F+x*C,t[4]=h*R+E*X+v*T,t[5]=d*R+m*X+_*T,t[6]=k*R+y*X+w*T,t[7]=g*R+G*X+x*T,t[8]=h*Q+E*b+v*jA,t[9]=d*Q+m*b+_*jA,t[10]=k*Q+y*b+w*jA,t[11]=g*Q+G*b+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function hw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function dw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function pw(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function xAA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function yAA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function vAA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function _AA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function qAA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function bAA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function cS(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,G=i*c;return t[0]=1-(k+E),t[1]=h+G,t[2]=d-y,t[3]=0,t[4]=h-G,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function GAA(t,A){let j=new de(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),cS(t,A,j),t}function wAA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function uS(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function FAA(t,A){let j=new de(3);uS(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function PAA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,G=i*E,v=o*k,_=l*g,w=c*E,x=B*k,O=h*g,F=d*E,C=m+_+F,R=0;return C>0?(R=Math.sqrt(C+1)*2,t[3]=.25*R,t[0]=(w-O)/R,t[1]=(x-G)/R,t[2]=(y-v)/R):m>_&&m>F?(R=Math.sqrt(1+m-_-F)*2,t[3]=(w-O)/R,t[0]=.25*R,t[1]=(y+v)/R,t[2]=(x+G)/R):_>F?(R=Math.sqrt(1+_-m-F)*2,t[3]=(x-G)/R,t[0]=(y+v)/R,t[1]=.25*R,t[2]=(w+O)/R):(R=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/R,t[0]=(x+G)/R,t[1]=(w+O)/R,t[2]=.25*R),t}function IAA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,G=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-G)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+G)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function MAA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,G=l*c,v=l*B,_=l*h,w=e[0],x=e[1],O=e[2],F=r[0],C=r[1],R=r[2],X=(1-(E+y))*w,T=(k+_)*w,Q=(g-v)*w,b=(k-_)*x,jA=(1-(d+y))*x,pA=(m+G)*x,dA=(g+v)*O,$A=(m-G)*O,_A=(1-(d+E))*O;return t[0]=X,t[1]=T,t[2]=Q,t[3]=0,t[4]=b,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(X*F+b*C+dA*R),t[13]=j[1]+C-(T*F+jA*C+$A*R),t[14]=j[2]+R-(Q*F+pA*C+_A*R),t[15]=1,t}function kw(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function gw(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function BS(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var mw=BS;function OAA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function TAA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function fS(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var Ew=fS;function SAA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function $w(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],G=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?lS(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=G*k-v*d,i=v*h-y*k,o=y*d-G*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function RAA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function LAA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function CAA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function HAA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function hS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function DAA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function NAA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function KAA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function XAA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],G=A[0],v=A[1],_=A[2],w=A[3],x=A[4],O=A[5],F=A[6],C=A[7],R=A[8],X=A[9],T=A[10],Q=A[11],b=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-G)<=1e-6*Math.max(1,Math.abs(j),Math.abs(G))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-O)<=1e-6*Math.max(1,Math.abs(o),Math.abs(O))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-C)<=1e-6*Math.max(1,Math.abs(c),Math.abs(C))&&Math.abs(B-R)<=1e-6*Math.max(1,Math.abs(B),Math.abs(R))&&Math.abs(h-X)<=1e-6*Math.max(1,Math.abs(h),Math.abs(X))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-Q)<=1e-6*Math.max(1,Math.abs(k),Math.abs(Q))&&Math.abs(g-b)<=1e-6*Math.max(1,Math.abs(g),Math.abs(b))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var zAA=up,UAA=hS;var os={};fr(os,{add:()=>JAA,ceil:()=>ZAA,clone:()=>VAA,copy:()=>WAA,create:()=>dS,cross:()=>ltA,dist:()=>EtA,distance:()=>mS,div:()=>mtA,divide:()=>gS,dot:()=>atA,equals:()=>ptA,exactEquals:()=>dtA,floor:()=>AtA,forEach:()=>vtA,fromValues:()=>QAA,inverse:()=>otA,len:()=>xtA,length:()=>$S,lerp:()=>ctA,max:()=>jtA,min:()=>ttA,mul:()=>gtA,multiply:()=>kS,negate:()=>itA,normalize:()=>stA,random:()=>utA,round:()=>etA,scale:()=>rtA,scaleAndAdd:()=>ntA,set:()=>YAA,sqrDist:()=>$tA,sqrLen:()=>ytA,squaredDistance:()=>ES,squaredLength:()=>xS,str:()=>htA,sub:()=>ktA,subtract:()=>pS,transformMat4:()=>xw,transformQuat:()=>BtA,zero:()=>ftA});function dS(){let t=new de(4);return de!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function VAA(t){let A=new de(4);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A}function QAA(t,A,j,e){let r=new de(4);return r[0]=t,r[1]=A,r[2]=j,r[3]=e,r}function WAA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t}function YAA(t,A,j,e,r){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t}function JAA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function pS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t}function kS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t[3]=A[3]*j[3],t}function gS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t[3]=A[3]/j[3],t}function ZAA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t[3]=Math.ceil(A[3]),t}function AtA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t[3]=Math.floor(A[3]),t}function ttA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t[3]=Math.min(A[3],j[3]),t}function jtA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t[3]=Math.max(A[3],j[3]),t}function etA(t,A){return t[0]=yi(A[0]),t[1]=yi(A[1]),t[2]=yi(A[2]),t[3]=yi(A[3]),t}function rtA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function ntA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t}function mS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return Math.sqrt(j*j+e*e+r*r+n*n)}function ES(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return j*j+e*e+r*r+n*n}function $S(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function xS(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function itA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=-A[3],t}function otA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t[3]=1/A[3],t}function stA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function atA(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function ltA(t,A,j,e){let r=j[0]*e[1]-j[1]*e[0],n=j[0]*e[2]-j[2]*e[0],i=j[0]*e[3]-j[3]*e[0],o=j[1]*e[2]-j[2]*e[1],l=j[1]*e[3]-j[3]*e[1],c=j[2]*e[3]-j[3]*e[2],B=A[0],h=A[1],d=A[2],k=A[3];return t[0]=h*c-d*l+k*o,t[1]=-(B*c)+d*i-k*n,t[2]=B*l-h*i+k*r,t[3]=-(B*o)+h*n-d*r,t}function ctA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function utA(t,A){A=A===void 0?1:A;let j,e,r,n,i,o;do j=ns()*2-1,e=ns()*2-1,i=j*j+e*e;while(i>=1);do r=ns()*2-1,n=ns()*2-1,o=r*r+n*n;while(o>=1);let l=Math.sqrt((1-i)/o);return t[0]=A*j,t[1]=A*e,t[2]=A*r*l,t[3]=A*n*l,t}function xw(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3];return t[0]=j[0]*e+j[4]*r+j[8]*n+j[12]*i,t[1]=j[1]*e+j[5]*r+j[9]*n+j[13]*i,t[2]=j[2]*e+j[6]*r+j[10]*n+j[14]*i,t[3]=j[3]*e+j[7]*r+j[11]*n+j[15]*i,t}function BtA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}function ftA(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}function htA(t){return`vec4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]})`}function dtA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]}function ptA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=A[0],o=A[1],l=A[2],c=A[3];return Math.abs(j-i)<=1e-6*Math.max(1,Math.abs(j),Math.abs(i))&&Math.abs(e-o)<=1e-6*Math.max(1,Math.abs(e),Math.abs(o))&&Math.abs(r-l)<=1e-6*Math.max(1,Math.abs(r),Math.abs(l))&&Math.abs(n-c)<=1e-6*Math.max(1,Math.abs(n),Math.abs(c))}var ktA=pS,gtA=kS,mtA=gS,EtA=mS,$tA=ES,xtA=$S,ytA=xS,vtA=function(){let t=dS();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oMath.PI*2)throw Error("expected radians")}function FtA(t,A,j,e,r,n){let i=2*n/(j-A),o=2*n/(r-e),l=(j+A)/(j-A),c=(r+e)/(r-e),B=-1,h=-1,d=-2*n;return t[0]=i,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=o,t[6]=0,t[7]=0,t[8]=l,t[9]=c,t[10]=B,t[11]=h,t[12]=0,t[13]=0,t[14]=d,t[15]=0,t}var qw=`#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX)) struct AmbientLight { vec3 color; }; @@ -480,7 +480,7 @@ return pointLight.attenuation.x + pointLight.attenuation.z * distance * distance; } #endif -`;var _tA={lightSources:{}};function xw(t={}){let{color:A=[0,0,0],intensity:j=1}=t;return A.map(e=>e*j/255)}function qtA({ambientLight:t,pointLights:A=[],directionalLights:j=[]}){let e={};return t?e["lighting_uAmbientLight.color"]=xw(t):e["lighting_uAmbientLight.color"]=[0,0,0],A.forEach((r,n)=>{e[`lighting_uPointLight[${n}].color`]=xw(r),e[`lighting_uPointLight[${n}].position`]=r.position,e[`lighting_uPointLight[${n}].attenuation`]=r.attenuation||[1,0,0]}),e.lighting_uPointLightCount=A.length,j.forEach((r,n)=>{e[`lighting_uDirectionalLight[${n}].color`]=xw(r),e[`lighting_uDirectionalLight[${n}].direction`]=r.direction}),e.lighting_uDirectionalLightCount=j.length,e}function gS(t=_tA){if("lightSources"in t){let{ambientLight:A,pointLights:j,directionalLights:e}=t.lightSources||{};return A||j&&j.length>0||e&&e.length>0?Object.assign({},qtA({ambientLight:A,pointLights:j,directionalLights:e}),{lighting_uEnabled:!0}):{lighting_uEnabled:!1}}if("lights"in t){let A={pointLights:[],directionalLights:[]};for(let j of t.lights||[])switch(j.type){case"ambient":A.ambientLight=j;break;case"directional":A.directionalLights?.push(j);break;case"point":A.pointLights?.push(j);break;default:}return gS({lightSources:A})}return{}}var mS={name:"lights",vs:$w,fs:$w,getUniforms:gS,defines:{MAX_LIGHTS:3}};var ES=`uniform float lighting_uAmbient; +`;var PtA={lightSources:{}};function bw(t={}){let{color:A=[0,0,0],intensity:j=1}=t;return A.map(e=>e*j/255)}function ItA({ambientLight:t,pointLights:A=[],directionalLights:j=[]}){let e={};return t?e["lighting_uAmbientLight.color"]=bw(t):e["lighting_uAmbientLight.color"]=[0,0,0],A.forEach((r,n)=>{e[`lighting_uPointLight[${n}].color`]=bw(r),e[`lighting_uPointLight[${n}].position`]=r.position,e[`lighting_uPointLight[${n}].attenuation`]=r.attenuation||[1,0,0]}),e.lighting_uPointLightCount=A.length,j.forEach((r,n)=>{e[`lighting_uDirectionalLight[${n}].color`]=bw(r),e[`lighting_uDirectionalLight[${n}].direction`]=r.direction}),e.lighting_uDirectionalLightCount=j.length,e}function vS(t=PtA){if("lightSources"in t){let{ambientLight:A,pointLights:j,directionalLights:e}=t.lightSources||{};return A||j&&j.length>0||e&&e.length>0?Object.assign({},ItA({ambientLight:A,pointLights:j,directionalLights:e}),{lighting_uEnabled:!0}):{lighting_uEnabled:!1}}if("lights"in t){let A={pointLights:[],directionalLights:[]};for(let j of t.lights||[])switch(j.type){case"ambient":A.ambientLight=j;break;case"directional":A.directionalLights?.push(j);break;case"point":A.pointLights?.push(j);break;default:}return vS({lightSources:A})}return{}}var _S={name:"lights",vs:qw,fs:qw,getUniforms:vS,defines:{MAX_LIGHTS:3}};var qS=`uniform float lighting_uAmbient; uniform float lighting_uDiffuse; uniform float lighting_uShininess; uniform vec3 lighting_uSpecularColor; @@ -543,8 +543,8 @@ lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, } return lightColor; } -`;var GtA={};function btA(t){let{ambient:A=.35,diffuse:j=.6,shininess:e=32,specularColor:r=[30,30,30]}=t;return{lighting_uAmbient:A,lighting_uDiffuse:j,lighting_uShininess:e,lighting_uSpecularColor:r.map(n=>n/255)}}function wtA(t=GtA){if(!("material"in t))return{};let{material:A}=t;return A?btA(A):{lighting_uEnabled:!1}}var I7={name:"gouraud-lighting",dependencies:[mS],vs:ES,defines:{LIGHTING_VERTEX:1},getUniforms:wtA};var $S="#define SMOOTH_EDGE_RADIUS 0.5",FtA=` -${$S} +`;var MtA={};function OtA(t){let{ambient:A=.35,diffuse:j=.6,shininess:e=32,specularColor:r=[30,30,30]}=t;return{lighting_uAmbient:A,lighting_uDiffuse:j,lighting_uShininess:e,lighting_uSpecularColor:r.map(n=>n/255)}}function TtA(t=MtA){if(!("material"in t))return{};let{material:A}=t;return A?OtA(A):{lighting_uEnabled:!1}}var I7={name:"gouraud-lighting",dependencies:[_S],vs:qS,defines:{LIGHTING_VERTEX:1},getUniforms:TtA};var bS="#define SMOOTH_EDGE_RADIUS 0.5",StA=` +${bS} struct VertexGeometry { vec4 position; @@ -561,8 +561,8 @@ struct VertexGeometry { vec2(0.0), vec3(0.0) ); -`,PtA=` -${$S} +`,RtA=` +${bS} struct FragmentGeometry { vec2 uv; @@ -571,9 +571,9 @@ struct FragmentGeometry { float smoothedge(float edge, float x) { return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x); } -`,xS={name:"geometry",vs:FtA,fs:PtA};var qt={DEFAULT:-1,LNGLAT:1,METER_OFFSETS:2,LNGLAT_OFFSETS:3,CARTESIAN:0};Object.defineProperty(qt,"IDENTITY",{get:()=>(NA.deprecated("COORDINATE_SYSTEM.IDENTITY","COORDINATE_SYSTEM.CARTESIAN")(),0)});var sn={WEB_MERCATOR:1,GLOBE:2,WEB_MERCATOR_AUTO_OFFSET:4,IDENTITY:0},an={common:0,meters:1,pixels:2},cp={click:{handler:"onClick"},panstart:{handler:"onDragStart"},panmove:{handler:"onDrag"},panend:{handler:"onDragEnd"}};var ItA=Object.keys(qt).map(t=>`const int COORDINATE_SYSTEM_${t} = ${qt[t]};`).join(""),MtA=Object.keys(sn).map(t=>`const int PROJECTION_MODE_${t} = ${sn[t]};`).join(""),OtA=Object.keys(an).map(t=>`const int UNIT_${t.toUpperCase()} = ${an[t]};`).join(""),yS=`${ItA} -${MtA} -${OtA} +`,GS={name:"geometry",vs:StA,fs:RtA};var qt={DEFAULT:-1,LNGLAT:1,METER_OFFSETS:2,LNGLAT_OFFSETS:3,CARTESIAN:0};Object.defineProperty(qt,"IDENTITY",{get:()=>(NA.deprecated("COORDINATE_SYSTEM.IDENTITY","COORDINATE_SYSTEM.CARTESIAN")(),0)});var sn={WEB_MERCATOR:1,GLOBE:2,WEB_MERCATOR_AUTO_OFFSET:4,IDENTITY:0},an={common:0,meters:1,pixels:2},Bp={click:{handler:"onClick"},panstart:{handler:"onDragStart"},panmove:{handler:"onDrag"},panend:{handler:"onDragEnd"}};var LtA=Object.keys(qt).map(t=>`const int COORDINATE_SYSTEM_${t} = ${qt[t]};`).join(""),CtA=Object.keys(sn).map(t=>`const int PROJECTION_MODE_${t} = ${sn[t]};`).join(""),HtA=Object.keys(an).map(t=>`const int UNIT_${t.toUpperCase()} = ${an[t]};`).join(""),wS=`${LtA} +${CtA} +${HtA} uniform int project_uCoordinateSystem; uniform int project_uProjectionMode; uniform float project_uScale; @@ -760,7 +760,7 @@ return pixels / project_uScale; vec2 project_pixel_size(vec2 pixels) { return pixels / project_uScale; } -`;function TtA(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{for(let r in e)if(!TtA(e[r],A[r])){j=t(e),A=e;break}return j}}var vS=[0,0,0,0],StA=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0],_S=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],RtA=[0,0,0],qS=[0,0,0],LtA=ss(HtA);function vw(t,A,j=qS){j.length<3&&(j=[j[0],j[1],0]);let e=j,r,n=!0;switch(A===qt.LNGLAT_OFFSETS||A===qt.METER_OFFSETS?r=j:r=t.isGeospatial?[Math.fround(t.longitude),Math.fround(t.latitude),0]:null,t.projectionMode){case sn.WEB_MERCATOR:(A===qt.LNGLAT||A===qt.CARTESIAN)&&(r=[0,0,0],n=!1);break;case sn.WEB_MERCATOR_AUTO_OFFSET:A===qt.LNGLAT?e=r:A===qt.CARTESIAN&&(e=[Math.fround(t.center[0]),Math.fround(t.center[1]),0],r=t.unprojectPosition(e),e[0]-=j[0],e[1]-=j[1],e[2]-=j[2]);break;case sn.IDENTITY:e=t.position.map(Math.fround),e[2]=e[2]||0;break;case sn.GLOBE:n=!1,r=null;break;default:n=!1}return{geospatialOrigin:r,shaderCoordinateOrigin:e,offsetMode:n}}function CtA(t,A,j){let{viewMatrixUncentered:e,projectionMatrix:r}=t,{viewMatrix:n,viewProjectionMatrix:i}=t,o=vS,l=vS,c=t.cameraPosition,{geospatialOrigin:B,shaderCoordinateOrigin:h,offsetMode:d}=vw(t,A,j);return d&&(l=t.projectPosition(B||h),c=[c[0]-l[0],c[1]-l[1],c[2]-l[2]],l[3]=1,o=os.transformMat4([],l,i),n=e||n,i=Y6.multiply([],r,n),i=Y6.multiply([],i,StA)),{viewMatrix:n,viewProjectionMatrix:i,projectionCenter:o,originCommon:l,cameraPosCommon:c,shaderCoordinateOrigin:h,geospatialOrigin:B}}function GS({viewport:t,devicePixelRatio:A=1,modelMatrix:j=null,coordinateSystem:e=qt.DEFAULT,coordinateOrigin:r=qS,autoWrapLongitude:n=!1}){e===qt.DEFAULT&&(e=t.isGeospatial?qt.LNGLAT:qt.CARTESIAN);let i=LtA({viewport:t,devicePixelRatio:A,coordinateSystem:e,coordinateOrigin:r});return i.project_uWrapLongitude=n,i.project_uModelMatrix=j||_S,i}function HtA({viewport:t,devicePixelRatio:A,coordinateSystem:j,coordinateOrigin:e}){let{projectionCenter:r,viewProjectionMatrix:n,originCommon:i,cameraPosCommon:o,shaderCoordinateOrigin:l,geospatialOrigin:c}=CtA(t,j,e),B=t.getDistanceScales(),h=[t.width*A,t.height*A],d=os.transformMat4([],[0,0,-t.focalDistance,1],t.projectionMatrix)[3]||1,k={project_uCoordinateSystem:j,project_uProjectionMode:t.projectionMode,project_uCoordinateOrigin:l,project_uCommonOrigin:i.slice(0,3),project_uCenter:r,project_uPseudoMeters:!!t._pseudoMeters,project_uViewportSize:h,project_uDevicePixelRatio:A,project_uFocalDistance:d,project_uCommonUnitsPerMeter:B.unitsPerMeter,project_uCommonUnitsPerWorldUnit:B.unitsPerMeter,project_uCommonUnitsPerWorldUnit2:RtA,project_uScale:t.scale,project_uWrapLongitude:!1,project_uViewProjectionMatrix:n,project_uModelMatrix:_S,project_uCameraPosition:o};if(c){let g=t.getDistanceScales(c);switch(j){case qt.METER_OFFSETS:k.project_uCommonUnitsPerWorldUnit=g.unitsPerMeter,k.project_uCommonUnitsPerWorldUnit2=g.unitsPerMeter2;break;case qt.LNGLAT:case qt.LNGLAT_OFFSETS:t._pseudoMeters||(k.project_uCommonUnitsPerMeter=g.unitsPerMeter),k.project_uCommonUnitsPerWorldUnit=g.unitsPerDegree,k.project_uCommonUnitsPerWorldUnit2=g.unitsPerDegree2;break;case qt.CARTESIAN:k.project_uCommonUnitsPerWorldUnit=[1,1,g.unitsPerMeter[2]],k.project_uCommonUnitsPerWorldUnit2=[0,0,g.unitsPerMeter2[2]];break;default:break}}return k}var DtA={};function NtA(t=DtA){return"viewport"in t?GS(t):{}}var M7={name:"project",dependencies:[Nb,xS],vs:yS,getUniforms:NtA};var KtA=` +`;function DtA(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{for(let r in e)if(!DtA(e[r],A[r])){j=t(e),A=e;break}return j}}var FS=[0,0,0,0],NtA=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0],PS=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],KtA=[0,0,0],IS=[0,0,0],XtA=ss(UtA);function ww(t,A,j=IS){j.length<3&&(j=[j[0],j[1],0]);let e=j,r,n=!0;switch(A===qt.LNGLAT_OFFSETS||A===qt.METER_OFFSETS?r=j:r=t.isGeospatial?[Math.fround(t.longitude),Math.fround(t.latitude),0]:null,t.projectionMode){case sn.WEB_MERCATOR:(A===qt.LNGLAT||A===qt.CARTESIAN)&&(r=[0,0,0],n=!1);break;case sn.WEB_MERCATOR_AUTO_OFFSET:A===qt.LNGLAT?e=r:A===qt.CARTESIAN&&(e=[Math.fround(t.center[0]),Math.fround(t.center[1]),0],r=t.unprojectPosition(e),e[0]-=j[0],e[1]-=j[1],e[2]-=j[2]);break;case sn.IDENTITY:e=t.position.map(Math.fround),e[2]=e[2]||0;break;case sn.GLOBE:n=!1,r=null;break;default:n=!1}return{geospatialOrigin:r,shaderCoordinateOrigin:e,offsetMode:n}}function ztA(t,A,j){let{viewMatrixUncentered:e,projectionMatrix:r}=t,{viewMatrix:n,viewProjectionMatrix:i}=t,o=FS,l=FS,c=t.cameraPosition,{geospatialOrigin:B,shaderCoordinateOrigin:h,offsetMode:d}=ww(t,A,j);return d&&(l=t.projectPosition(B||h),c=[c[0]-l[0],c[1]-l[1],c[2]-l[2]],l[3]=1,o=os.transformMat4([],l,i),n=e||n,i=Y6.multiply([],r,n),i=Y6.multiply([],i,NtA)),{viewMatrix:n,viewProjectionMatrix:i,projectionCenter:o,originCommon:l,cameraPosCommon:c,shaderCoordinateOrigin:h,geospatialOrigin:B}}function MS({viewport:t,devicePixelRatio:A=1,modelMatrix:j=null,coordinateSystem:e=qt.DEFAULT,coordinateOrigin:r=IS,autoWrapLongitude:n=!1}){e===qt.DEFAULT&&(e=t.isGeospatial?qt.LNGLAT:qt.CARTESIAN);let i=XtA({viewport:t,devicePixelRatio:A,coordinateSystem:e,coordinateOrigin:r});return i.project_uWrapLongitude=n,i.project_uModelMatrix=j||PS,i}function UtA({viewport:t,devicePixelRatio:A,coordinateSystem:j,coordinateOrigin:e}){let{projectionCenter:r,viewProjectionMatrix:n,originCommon:i,cameraPosCommon:o,shaderCoordinateOrigin:l,geospatialOrigin:c}=ztA(t,j,e),B=t.getDistanceScales(),h=[t.width*A,t.height*A],d=os.transformMat4([],[0,0,-t.focalDistance,1],t.projectionMatrix)[3]||1,k={project_uCoordinateSystem:j,project_uProjectionMode:t.projectionMode,project_uCoordinateOrigin:l,project_uCommonOrigin:i.slice(0,3),project_uCenter:r,project_uPseudoMeters:!!t._pseudoMeters,project_uViewportSize:h,project_uDevicePixelRatio:A,project_uFocalDistance:d,project_uCommonUnitsPerMeter:B.unitsPerMeter,project_uCommonUnitsPerWorldUnit:B.unitsPerMeter,project_uCommonUnitsPerWorldUnit2:KtA,project_uScale:t.scale,project_uWrapLongitude:!1,project_uViewProjectionMatrix:n,project_uModelMatrix:PS,project_uCameraPosition:o};if(c){let g=t.getDistanceScales(c);switch(j){case qt.METER_OFFSETS:k.project_uCommonUnitsPerWorldUnit=g.unitsPerMeter,k.project_uCommonUnitsPerWorldUnit2=g.unitsPerMeter2;break;case qt.LNGLAT:case qt.LNGLAT_OFFSETS:t._pseudoMeters||(k.project_uCommonUnitsPerMeter=g.unitsPerMeter),k.project_uCommonUnitsPerWorldUnit=g.unitsPerDegree,k.project_uCommonUnitsPerWorldUnit2=g.unitsPerDegree2;break;case qt.CARTESIAN:k.project_uCommonUnitsPerWorldUnit=[1,1,g.unitsPerMeter[2]],k.project_uCommonUnitsPerWorldUnit2=[0,0,g.unitsPerMeter2[2]];break;default:break}}return k}var VtA={};function QtA(t=VtA){return"viewport"in t?MS(t):{}}var M7={name:"project",dependencies:[VG,GS],vs:wS,getUniforms:QtA};var WtA=` vec4 project_position_to_clipspace( vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition ) { @@ -781,7 +781,7 @@ vec4 project_position_to_clipspace( vec4 commonPosition; return project_position_to_clipspace(position, position64Low, offset, commonPosition); } -`,Lr={name:"project32",dependencies:[M7],vs:KtA};var gB={};fr(gB,{add:()=>QtA,angle:()=>hjA,ceil:()=>WtA,clone:()=>XtA,copy:()=>UtA,create:()=>bS,cross:()=>ojA,dist:()=>yjA,distance:()=>IS,div:()=>xjA,divide:()=>PS,dot:()=>ijA,equals:()=>gjA,exactEquals:()=>kjA,floor:()=>YtA,forEach:()=>qjA,fromValues:()=>ztA,inverse:()=>rjA,len:()=>mjA,length:()=>OS,lerp:()=>sjA,max:()=>ZtA,min:()=>JtA,mul:()=>$jA,multiply:()=>FS,negate:()=>ejA,normalize:()=>njA,random:()=>ajA,rotate:()=>fjA,round:()=>AjA,scale:()=>tjA,scaleAndAdd:()=>jjA,set:()=>VtA,sqrDist:()=>vjA,sqrLen:()=>_jA,squaredDistance:()=>MS,squaredLength:()=>TS,str:()=>pjA,sub:()=>EjA,subtract:()=>wS,transformMat2:()=>ljA,transformMat2d:()=>cjA,transformMat3:()=>ujA,transformMat4:()=>BjA,zero:()=>djA});var pe=typeof Float32Array<"u"?Float32Array:Array,as=Math.random;function vi(t){return t>=0?Math.round(t):t%.5===0?Math.floor(t):Math.round(t)}var HMA=Math.PI/180;function bS(){let t=new pe(2);return pe!=Float32Array&&(t[0]=0,t[1]=0),t}function XtA(t){let A=new pe(2);return A[0]=t[0],A[1]=t[1],A}function ztA(t,A){let j=new pe(2);return j[0]=t,j[1]=A,j}function UtA(t,A){return t[0]=A[0],t[1]=A[1],t}function VtA(t,A,j){return t[0]=A,t[1]=j,t}function QtA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t}function wS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t}function FS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t}function PS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t}function WtA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t}function YtA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t}function JtA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t}function ZtA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t}function AjA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t}function tjA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t}function jjA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t}function IS(t,A){let j=A[0]-t[0],e=A[1]-t[1];return Math.sqrt(j*j+e*e)}function MS(t,A){let j=A[0]-t[0],e=A[1]-t[1];return j*j+e*e}function OS(t){let A=t[0],j=t[1];return Math.sqrt(A*A+j*j)}function TS(t){let A=t[0],j=t[1];return A*A+j*j}function ejA(t,A){return t[0]=-A[0],t[1]=-A[1],t}function rjA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t}function njA(t,A){let j=A[0],e=A[1],r=j*j+e*e;return r>0&&(r=1/Math.sqrt(r)),t[0]=A[0]*r,t[1]=A[1]*r,t}function ijA(t,A){return t[0]*A[0]+t[1]*A[1]}function ojA(t,A,j){let e=A[0]*j[1]-A[1]*j[0];return t[0]=t[1]=0,t[2]=e,t}function sjA(t,A,j,e){let r=A[0],n=A[1];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t}function ajA(t,A){A=A===void 0?1:A;let j=as()*2*Math.PI;return t[0]=Math.cos(j)*A,t[1]=Math.sin(j)*A,t}function ljA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r,t[1]=j[1]*e+j[3]*r,t}function cjA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r+j[4],t[1]=j[1]*e+j[3]*r+j[5],t}function ujA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[3]*r+j[6],t[1]=j[1]*e+j[4]*r+j[7],t}function BjA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[4]*r+j[12],t[1]=j[1]*e+j[5]*r+j[13],t}function fjA(t,A,j,e){let r=A[0]-j[0],n=A[1]-j[1],i=Math.sin(e),o=Math.cos(e);return t[0]=r*o-n*i+j[0],t[1]=r*i+n*o+j[1],t}function hjA(t,A){let j=t[0],e=t[1],r=A[0],n=A[1],i=Math.sqrt((j*j+e*e)*(r*r+n*n)),o=i&&(j*r+e*n)/i;return Math.acos(Math.min(Math.max(o,-1),1))}function djA(t){return t[0]=0,t[1]=0,t}function pjA(t){return`vec2(${t[0]}, ${t[1]})`}function kjA(t,A){return t[0]===A[0]&&t[1]===A[1]}function gjA(t,A){let j=t[0],e=t[1],r=A[0],n=A[1];return Math.abs(j-r)<=1e-6*Math.max(1,Math.abs(j),Math.abs(r))&&Math.abs(e-n)<=1e-6*Math.max(1,Math.abs(e),Math.abs(n))}var mjA=OS,EjA=wS,$jA=FS,xjA=PS,yjA=IS,vjA=MS,_jA=TS,qjA=function(){let t=bS();return function(A,j,e,r,n,i){let o,l;for(j||(j=2),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oPjA,angle:()=>teA,bezier:()=>UjA,ceil:()=>IjA,clone:()=>GjA,copy:()=>wjA,create:()=>SS,cross:()=>NjA,dist:()=>aeA,distance:()=>DS,div:()=>seA,divide:()=>HS,dot:()=>_w,equals:()=>neA,exactEquals:()=>reA,floor:()=>MjA,forEach:()=>BeA,fromValues:()=>bjA,hermite:()=>zjA,inverse:()=>HjA,len:()=>ceA,length:()=>RS,lerp:()=>KjA,max:()=>TjA,min:()=>OjA,mul:()=>oeA,multiply:()=>CS,negate:()=>CjA,normalize:()=>DjA,random:()=>VjA,rotateX:()=>JjA,rotateY:()=>ZjA,rotateZ:()=>AeA,round:()=>SjA,scale:()=>RjA,scaleAndAdd:()=>LjA,set:()=>FjA,slerp:()=>XjA,sqrDist:()=>leA,sqrLen:()=>ueA,squaredDistance:()=>NS,squaredLength:()=>KS,str:()=>eeA,sub:()=>ieA,subtract:()=>LS,transformMat3:()=>WjA,transformMat4:()=>QjA,transformQuat:()=>YjA,zero:()=>jeA});function SS(){let t=new pe(3);return pe!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t}function GjA(t){let A=new pe(3);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A}function RS(t){let A=t[0],j=t[1],e=t[2];return Math.sqrt(A*A+j*j+e*e)}function bjA(t,A,j){let e=new pe(3);return e[0]=t,e[1]=A,e[2]=j,e}function wjA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t}function FjA(t,A,j,e){return t[0]=A,t[1]=j,t[2]=e,t}function PjA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t}function LS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t}function CS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t}function HS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t}function IjA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t}function MjA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t}function OjA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t}function TjA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t}function SjA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t[2]=vi(A[2]),t}function RjA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t}function LjA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t}function DS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return Math.sqrt(j*j+e*e+r*r)}function NS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return j*j+e*e+r*r}function KS(t){let A=t[0],j=t[1],e=t[2];return A*A+j*j+e*e}function CjA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t}function HjA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t}function DjA(t,A){let j=A[0],e=A[1],r=A[2],n=j*j+e*e+r*r;return n>0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function _w(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function NjA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function KjA(t,A,j,e){let r=A[0],n=A[1],i=A[2];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t}function XjA(t,A,j,e){let r=Math.acos(Math.min(Math.max(_w(A,j),-1),1)),n=Math.sin(r),i=Math.sin((1-e)*r)/n,o=Math.sin(e*r)/n;return t[0]=i*A[0]+o*j[0],t[1]=i*A[1]+o*j[1],t[2]=i*A[2]+o*j[2],t}function zjA(t,A,j,e,r,n){let i=n*n,o=i*(2*n-3)+1,l=i*(n-2)+n,c=i*(n-1),B=i*(3-2*n);return t[0]=A[0]*o+j[0]*l+e[0]*c+r[0]*B,t[1]=A[1]*o+j[1]*l+e[1]*c+r[1]*B,t[2]=A[2]*o+j[2]*l+e[2]*c+r[2]*B,t}function UjA(t,A,j,e,r,n){let i=1-n,o=i*i,l=n*n,c=o*i,B=3*n*o,h=3*l*i,d=l*n;return t[0]=A[0]*c+j[0]*B+e[0]*h+r[0]*d,t[1]=A[1]*c+j[1]*B+e[1]*h+r[1]*d,t[2]=A[2]*c+j[2]*B+e[2]*h+r[2]*d,t}function VjA(t,A){A=A===void 0?1:A;let j=as()*2*Math.PI,e=as()*2-1,r=Math.sqrt(1-e*e)*A;return t[0]=Math.cos(j)*r,t[1]=Math.sin(j)*r,t[2]=e*A,t}function QjA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function WjA(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function YjA(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function JjA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function ZjA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function AeA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function teA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&_w(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}function jeA(t){return t[0]=0,t[1]=0,t[2]=0,t}function eeA(t){return`vec3(${t[0]}, ${t[1]}, ${t[2]})`}function reA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]}function neA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2];return Math.abs(j-n)<=1e-6*Math.max(1,Math.abs(j),Math.abs(n))&&Math.abs(e-i)<=1e-6*Math.max(1,Math.abs(e),Math.abs(i))&&Math.abs(r-o)<=1e-6*Math.max(1,Math.abs(r),Math.abs(o))}var ieA=LS,oeA=CS,seA=HS,aeA=DS,leA=NS,ceA=RS,ueA=KS,BeA=function(){let t=SS();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oJeA,adjoint:()=>EeA,clone:()=>heA,copy:()=>deA,create:()=>feA,decompose:()=>ReA,determinant:()=>$eA,equals:()=>jrA,exactEquals:()=>trA,frob:()=>YeA,fromQuat:()=>HeA,fromQuat2:()=>OeA,fromRotation:()=>FeA,fromRotationTranslation:()=>US,fromRotationTranslationScale:()=>LeA,fromRotationTranslationScaleOrigin:()=>CeA,fromScaling:()=>weA,fromTranslation:()=>beA,fromValues:()=>peA,fromXRotation:()=>PeA,fromYRotation:()=>IeA,fromZRotation:()=>MeA,frustum:()=>DeA,getRotation:()=>SeA,getScaling:()=>VS,getTranslation:()=>TeA,identity:()=>XS,invert:()=>meA,lookAt:()=>VeA,mul:()=>erA,multiply:()=>zS,multiplyScalar:()=>ZeA,multiplyScalarAndAdd:()=>ArA,ortho:()=>zeA,orthoNO:()=>WS,orthoZO:()=>UeA,perspective:()=>NeA,perspectiveFromFieldOfView:()=>XeA,perspectiveNO:()=>QS,perspectiveZO:()=>KeA,rotate:()=>veA,rotateX:()=>_eA,rotateY:()=>qeA,rotateZ:()=>GeA,scale:()=>yeA,set:()=>keA,str:()=>WeA,sub:()=>rrA,subtract:()=>YS,targetTo:()=>QeA,translate:()=>xeA,transpose:()=>geA});function feA(){let t=new pe(16);return pe!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function heA(t){let A=new pe(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function deA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function peA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new pe(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function keA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function XS(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function geA(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function meA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m,G=b*W-v*T+_*z+w*L-x*D+S*F;return G?(G=1/G,t[0]=(o*W-l*T+c*z)*G,t[1]=(r*T-e*W-n*z)*G,t[2]=(E*S-m*x+y*w)*G,t[3]=(d*x-h*S-k*w)*G,t[4]=(l*L-i*W-c*D)*G,t[5]=(j*W-r*L+n*D)*G,t[6]=(m*_-g*S-y*v)*G,t[7]=(B*S-d*_+k*v)*G,t[8]=(i*T-o*L+c*F)*G,t[9]=(e*L-j*T-n*F)*G,t[10]=(g*x-E*_+y*b)*G,t[11]=(h*_-B*x-k*b)*G,t[12]=(o*D-i*z-l*F)*G,t[13]=(j*z-e*D+r*F)*G,t[14]=(E*v-g*w-m*b)*G,t[15]=(B*w-h*v+d*b)*G,t):null}function EeA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m;return t[0]=o*W-l*T+c*z,t[1]=r*T-e*W-n*z,t[2]=E*S-m*x+y*w,t[3]=d*x-h*S-k*w,t[4]=l*L-i*W-c*D,t[5]=j*W-r*L+n*D,t[6]=m*_-g*S-y*v,t[7]=B*S-d*_+k*v,t[8]=i*T-o*L+c*F,t[9]=e*L-j*T-n*F,t[10]=g*x-E*_+y*b,t[11]=h*_-B*x-k*b,t[12]=o*D-i*z-l*F,t[13]=j*z-e*D+r*F,t[14]=E*v-g*w-m*b,t[15]=B*w-h*v+d*b,t}function $eA(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,b=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,S=A*x-j*w+e*_,F=n*x-i*w+o*_,D=c*v-B*b+h*y,L=k*v-g*b+E*y;return l*S-r*F+m*D-d*L}function zS(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],b=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*b,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*b,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*b,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*b,t}function xeA(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function yeA(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function veA(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,b,v,_,w,x,S,F,D,L,z,T,W,G,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],b=A[7],v=A[8],_=A[9],w=A[10],x=A[11],S=r*r*B+l,F=n*r*B+i*c,D=i*r*B-n*c,L=r*n*B-i*c,z=n*n*B+l,T=i*n*B+r*c,W=r*i*B+n*c,G=n*i*B-r*c,jA=i*i*B+l,t[0]=h*S+E*F+v*D,t[1]=d*S+m*F+_*D,t[2]=k*S+y*F+w*D,t[3]=g*S+b*F+x*D,t[4]=h*L+E*z+v*T,t[5]=d*L+m*z+_*T,t[6]=k*L+y*z+w*T,t[7]=g*L+b*z+x*T,t[8]=h*W+E*G+v*jA,t[9]=d*W+m*G+_*jA,t[10]=k*W+y*G+w*jA,t[11]=g*W+b*G+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function _eA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function qeA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function GeA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function beA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function weA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function FeA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function PeA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function IeA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function MeA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function US(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,b=i*c;return t[0]=1-(k+E),t[1]=h+b,t[2]=d-y,t[3]=0,t[4]=h-b,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function OeA(t,A){let j=new pe(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),US(t,A,j),t}function TeA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function VS(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function SeA(t,A){let j=new pe(3);VS(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function ReA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,b=i*E,v=o*k,_=l*g,w=c*E,x=B*k,S=h*g,F=d*E,D=m+_+F,L=0;return D>0?(L=Math.sqrt(D+1)*2,t[3]=.25*L,t[0]=(w-S)/L,t[1]=(x-b)/L,t[2]=(y-v)/L):m>_&&m>F?(L=Math.sqrt(1+m-_-F)*2,t[3]=(w-S)/L,t[0]=.25*L,t[1]=(y+v)/L,t[2]=(x+b)/L):_>F?(L=Math.sqrt(1+_-m-F)*2,t[3]=(x-b)/L,t[0]=(y+v)/L,t[1]=.25*L,t[2]=(w+S)/L):(L=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/L,t[0]=(x+b)/L,t[1]=(w+S)/L,t[2]=.25*L),t}function LeA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,b=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-b)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+b)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function CeA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,b=l*c,v=l*B,_=l*h,w=e[0],x=e[1],S=e[2],F=r[0],D=r[1],L=r[2],z=(1-(E+y))*w,T=(k+_)*w,W=(g-v)*w,G=(k-_)*x,jA=(1-(d+y))*x,pA=(m+b)*x,dA=(g+v)*S,$A=(m-b)*S,_A=(1-(d+E))*S;return t[0]=z,t[1]=T,t[2]=W,t[3]=0,t[4]=G,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(z*F+G*D+dA*L),t[13]=j[1]+D-(T*F+jA*D+$A*L),t[14]=j[2]+L-(W*F+pA*D+_A*L),t[15]=1,t}function HeA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function DeA(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function QS(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var NeA=QS;function KeA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function XeA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function WS(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var zeA=WS;function UeA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function VeA(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],b=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?XS(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=b*k-v*d,i=v*h-y*k,o=y*d-b*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function QeA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function WeA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function YeA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function JeA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function YS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function ZeA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function ArA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function trA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function jrA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],b=A[0],v=A[1],_=A[2],w=A[3],x=A[4],S=A[5],F=A[6],D=A[7],L=A[8],z=A[9],T=A[10],W=A[11],G=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-b)<=1e-6*Math.max(1,Math.abs(j),Math.abs(b))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-S)<=1e-6*Math.max(1,Math.abs(o),Math.abs(S))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-D)<=1e-6*Math.max(1,Math.abs(c),Math.abs(D))&&Math.abs(B-L)<=1e-6*Math.max(1,Math.abs(B),Math.abs(L))&&Math.abs(h-z)<=1e-6*Math.max(1,Math.abs(h),Math.abs(z))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-W)<=1e-6*Math.max(1,Math.abs(k),Math.abs(W))&&Math.abs(g-G)<=1e-6*Math.max(1,Math.abs(g),Math.abs(G))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var erA=zS,rrA=YS;var up={};fr(up,{add:()=>arA,ceil:()=>lrA,clone:()=>nrA,copy:()=>orA,create:()=>JS,cross:()=>ErA,dist:()=>IrA,distance:()=>jR,div:()=>PrA,divide:()=>tR,dot:()=>mrA,equals:()=>brA,exactEquals:()=>GrA,floor:()=>crA,forEach:()=>SrA,fromValues:()=>irA,inverse:()=>krA,len:()=>OrA,length:()=>rR,lerp:()=>$rA,max:()=>BrA,min:()=>urA,mul:()=>FrA,multiply:()=>AR,negate:()=>prA,normalize:()=>grA,random:()=>xrA,round:()=>frA,scale:()=>hrA,scaleAndAdd:()=>drA,set:()=>srA,sqrDist:()=>MrA,sqrLen:()=>TrA,squaredDistance:()=>eR,squaredLength:()=>nR,str:()=>qrA,sub:()=>wrA,subtract:()=>ZS,transformMat4:()=>yrA,transformQuat:()=>vrA,zero:()=>_rA});function JS(){let t=new pe(4);return pe!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function nrA(t){let A=new pe(4);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A}function irA(t,A,j,e){let r=new pe(4);return r[0]=t,r[1]=A,r[2]=j,r[3]=e,r}function orA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t}function srA(t,A,j,e,r){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t}function arA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function ZS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t}function AR(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t[3]=A[3]*j[3],t}function tR(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t[3]=A[3]/j[3],t}function lrA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t[3]=Math.ceil(A[3]),t}function crA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t[3]=Math.floor(A[3]),t}function urA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t[3]=Math.min(A[3],j[3]),t}function BrA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t[3]=Math.max(A[3],j[3]),t}function frA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t[2]=vi(A[2]),t[3]=vi(A[3]),t}function hrA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function drA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t}function jR(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return Math.sqrt(j*j+e*e+r*r+n*n)}function eR(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return j*j+e*e+r*r+n*n}function rR(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function nR(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function prA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=-A[3],t}function krA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t[3]=1/A[3],t}function grA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function mrA(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function ErA(t,A,j,e){let r=j[0]*e[1]-j[1]*e[0],n=j[0]*e[2]-j[2]*e[0],i=j[0]*e[3]-j[3]*e[0],o=j[1]*e[2]-j[2]*e[1],l=j[1]*e[3]-j[3]*e[1],c=j[2]*e[3]-j[3]*e[2],B=A[0],h=A[1],d=A[2],k=A[3];return t[0]=h*c-d*l+k*o,t[1]=-(B*c)+d*i-k*n,t[2]=B*l-h*i+k*r,t[3]=-(B*o)+h*n-d*r,t}function $rA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function xrA(t,A){A=A===void 0?1:A;let j,e,r,n,i,o;do j=as()*2-1,e=as()*2-1,i=j*j+e*e;while(i>=1);do r=as()*2-1,n=as()*2-1,o=r*r+n*n;while(o>=1);let l=Math.sqrt((1-i)/o);return t[0]=A*j,t[1]=A*e,t[2]=A*r*l,t[3]=A*n*l,t}function yrA(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3];return t[0]=j[0]*e+j[4]*r+j[8]*n+j[12]*i,t[1]=j[1]*e+j[5]*r+j[9]*n+j[13]*i,t[2]=j[2]*e+j[6]*r+j[10]*n+j[14]*i,t[3]=j[3]*e+j[7]*r+j[11]*n+j[15]*i,t}function vrA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}function _rA(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}function qrA(t){return`vec4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]})`}function GrA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]}function brA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=A[0],o=A[1],l=A[2],c=A[3];return Math.abs(j-i)<=1e-6*Math.max(1,Math.abs(j),Math.abs(i))&&Math.abs(e-o)<=1e-6*Math.max(1,Math.abs(e),Math.abs(o))&&Math.abs(r-l)<=1e-6*Math.max(1,Math.abs(r),Math.abs(l))&&Math.abs(n-c)<=1e-6*Math.max(1,Math.abs(n),Math.abs(c))}var wrA=ZS,FrA=AR,PrA=tR,IrA=jR,MrA=eR,OrA=rR,TrA=nR,SrA=function(){let t=JS();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oj?j:t}function RrA(t){return Math.log(t)*Math.LOG2E}var mB=Math.log2||RrA;function ho(t,A){if(!t)throw new Error(A||"@math.gl/web-mercator: assertion failed.")}var po=Math.PI,iR=po/4,_i=po/180,bw=180/po,EB=512,s$=4003e4,$B=85.051129,oR=1.5;function ww(t){return mB(t)}function In(t){let[A,j]=t;ho(Number.isFinite(A)),ho(Number.isFinite(j)&&j>=-90&&j<=90,"invalid latitude");let e=A*_i,r=j*_i,n=EB*(e+po)/(2*po),i=EB*(po+Math.log(Math.tan(iR+r*.5)))/(2*po);return[n,i]}function J6(t){let[A,j]=t,e=A/EB*(2*po)-po,r=2*(Math.atan(Math.exp(j/EB*(2*po)-po))-iR);return[e*bw,r*bw]}function Fw(t){let{latitude:A}=t;ho(Number.isFinite(A));let j=Math.cos(A*_i);return ww(s$*j)-9}function fp(t){let A=Math.cos(t*_i);return EB/s$/A}function xB(t){let{latitude:A,longitude:j,highPrecision:e=!1}=t;ho(Number.isFinite(A)&&Number.isFinite(j));let r=EB,n=Math.cos(A*_i),i=r/360,o=i/n,l=r/s$/n,c={unitsPerMeter:[l,l,l],metersPerUnit:[1/l,1/l,1/l],unitsPerDegree:[i,o,l],degreesPerUnit:[1/i,1/o,1/l]};if(e){let B=_i*Math.tan(A*_i)/n,h=i*B/2,d=r/s$*B,k=d/o*l;c.unitsPerDegree2=[0,h,d],c.unitsPerMeter2=[k,0,k]}return c}function hp(t,A){let[j,e,r]=t,[n,i,o]=A,{unitsPerMeter:l,unitsPerMeter2:c}=xB({longitude:j,latitude:e,highPrecision:!0}),B=In(t);B[0]+=n*(l[0]+c[0]*i),B[1]+=i*(l[1]+c[1]*i);let h=J6(B),d=(r||0)+(o||0);return Number.isFinite(r)||Number.isFinite(o)?[h[0],h[1],d]:h}function a$(t){let{height:A,pitch:j,bearing:e,altitude:r,scale:n,center:i}=t,o=qw();O7.translate(o,o,[0,0,-r]),O7.rotateX(o,o,-j*_i),O7.rotateZ(o,o,e*_i);let l=n/A;return O7.scale(o,o,[l,l,l]),i&&O7.translate(o,o,o$.negate([],i)),o}function Pw(t){let{width:A,height:j,altitude:e,pitch:r=0,offset:n,center:i,scale:o,nearZMultiplier:l=1,farZMultiplier:c=1}=t,{fovy:B=mc(oR)}=t;e!==void 0&&(B=mc(e));let h=B*_i,d=r*_i,k=Ec(B),g=k;i&&(g+=i[2]*o/Math.cos(d)/j);let E=h*(.5+(n?n[1]:0)/j),m=Math.sin(E)*g/Math.sin(Bp(Math.PI/2-d-E,.01,Math.PI-.01)),y=Math.sin(d)*m+g,b=g*10,v=Math.min(y*c,b);return{fov:h,aspect:A/j,focalDistance:k,near:l,far:v}}function mc(t){return 2*Math.atan(.5/t)*bw}function Ec(t){return .5/Math.tan(.5*t*_i)}function yB(t,A){let[j,e,r=0]=t;return ho(Number.isFinite(j)&&Number.isFinite(e)&&Number.isFinite(r)),T7(A,[j,e,r,1])}function qi(t,A,j=0){let[e,r,n]=t;if(ho(Number.isFinite(e)&&Number.isFinite(r),"invalid pixel coordinate"),Number.isFinite(n))return T7(A,[e,r,n,1]);let i=T7(A,[e,r,0,1]),o=T7(A,[e,r,1,1]),l=i[2],c=o[2],B=l===c?0:((j||0)-l)/(c-l);return gB.lerp([],i,o,B)}function l$(t){let{width:A,height:j,bounds:e,minExtent:r=0,maxZoom:n=24,offset:i=[0,0]}=t,[[o,l],[c,B]]=e,h=LrA(t.padding),d=In([o,Bp(B,-$B,$B)]),k=In([c,Bp(l,-$B,$B)]),g=[Math.max(Math.abs(k[0]-d[0]),r),Math.max(Math.abs(k[1]-d[1]),r)],E=[A-h.left-h.right-Math.abs(i[0])*2,j-h.top-h.bottom-Math.abs(i[1])*2];ho(E[0]>0&&E[1]>0);let m=E[0]/g[0],y=E[1]/g[1],b=(h.right-h.left)/2/m,v=(h.top-h.bottom)/2/y,_=[(k[0]+d[0])/2+b,(k[1]+d[1])/2+v],w=J6(_),x=Math.min(n,mB(Math.abs(Math.min(m,y))));return ho(Number.isFinite(x)),{longitude:w[0],latitude:w[1],zoom:x}}function LrA(t=0){return typeof t=="number"?{top:t,bottom:t,left:t,right:t}:(ho(Number.isFinite(t.top)&&Number.isFinite(t.bottom)&&Number.isFinite(t.left)&&Number.isFinite(t.right)),t)}var sR=Math.PI/180;function c$(t,A=0){let{width:j,height:e,unproject:r}=t,n={targetZ:A},i=r([0,e],n),o=r([j,e],n),l,c,B=t.fovy?.5*t.fovy*sR:Math.atan(.5/t.altitude),h=(90-t.pitch)*sR;return B>h-.01?(l=aR(t,0,A),c=aR(t,j,A)):(l=r([0,0],n),c=r([j,0],n)),[i,o,c,l]}function aR(t,A,j){let{pixelUnprojectionMatrix:e}=t,r=T7(e,[A,0,1,1]),n=T7(e,[A,t.height,1,1]),o=(j*t.distanceScales.unitsPerMeter[2]-r[2])/(n[2]-r[2]),l=gB.lerp([],r,n,o),c=J6(l);return c.push(j),c}var cR=512;function Iw(t){let{width:A,height:j,pitch:e=0}=t,{longitude:r,latitude:n,zoom:i,bearing:o=0}=t;(r<-180||r>180)&&(r=Gw(r+180,360)-180),(o<-180||o>180)&&(o=Gw(o+180,360)-180);let l=mB(j/cR);if(i<=l)i=l,n=0;else{let c=j/2/Math.pow(2,i),B=J6([0,c])[1];if(nh&&(n=h)}}return{width:A,height:j,longitude:r,latitude:n,zoom:i,pitch:e,bearing:o}}var DrA=` +`,Lr={name:"project32",dependencies:[M7],vs:WtA};var gB={};fr(gB,{add:()=>tjA,angle:()=>EjA,ceil:()=>jjA,clone:()=>YtA,copy:()=>ZtA,create:()=>OS,cross:()=>BjA,dist:()=>wjA,distance:()=>LS,div:()=>GjA,divide:()=>RS,dot:()=>ujA,equals:()=>vjA,exactEquals:()=>yjA,floor:()=>ejA,forEach:()=>IjA,fromValues:()=>JtA,inverse:()=>ljA,len:()=>_jA,length:()=>HS,lerp:()=>fjA,max:()=>njA,min:()=>rjA,mul:()=>bjA,multiply:()=>SS,negate:()=>ajA,normalize:()=>cjA,random:()=>hjA,rotate:()=>mjA,round:()=>ijA,scale:()=>ojA,scaleAndAdd:()=>sjA,set:()=>AjA,sqrDist:()=>FjA,sqrLen:()=>PjA,squaredDistance:()=>CS,squaredLength:()=>DS,str:()=>xjA,sub:()=>qjA,subtract:()=>TS,transformMat2:()=>djA,transformMat2d:()=>pjA,transformMat3:()=>kjA,transformMat4:()=>gjA,zero:()=>$jA});var pe=typeof Float32Array<"u"?Float32Array:Array,as=Math.random;function vi(t){return t>=0?Math.round(t):t%.5===0?Math.floor(t):Math.round(t)}var VMA=Math.PI/180;function OS(){let t=new pe(2);return pe!=Float32Array&&(t[0]=0,t[1]=0),t}function YtA(t){let A=new pe(2);return A[0]=t[0],A[1]=t[1],A}function JtA(t,A){let j=new pe(2);return j[0]=t,j[1]=A,j}function ZtA(t,A){return t[0]=A[0],t[1]=A[1],t}function AjA(t,A,j){return t[0]=A,t[1]=j,t}function tjA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t}function TS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t}function SS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t}function RS(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t}function jjA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t}function ejA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t}function rjA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t}function njA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t}function ijA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t}function ojA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t}function sjA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t}function LS(t,A){let j=A[0]-t[0],e=A[1]-t[1];return Math.sqrt(j*j+e*e)}function CS(t,A){let j=A[0]-t[0],e=A[1]-t[1];return j*j+e*e}function HS(t){let A=t[0],j=t[1];return Math.sqrt(A*A+j*j)}function DS(t){let A=t[0],j=t[1];return A*A+j*j}function ajA(t,A){return t[0]=-A[0],t[1]=-A[1],t}function ljA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t}function cjA(t,A){let j=A[0],e=A[1],r=j*j+e*e;return r>0&&(r=1/Math.sqrt(r)),t[0]=A[0]*r,t[1]=A[1]*r,t}function ujA(t,A){return t[0]*A[0]+t[1]*A[1]}function BjA(t,A,j){let e=A[0]*j[1]-A[1]*j[0];return t[0]=t[1]=0,t[2]=e,t}function fjA(t,A,j,e){let r=A[0],n=A[1];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t}function hjA(t,A){A=A===void 0?1:A;let j=as()*2*Math.PI;return t[0]=Math.cos(j)*A,t[1]=Math.sin(j)*A,t}function djA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r,t[1]=j[1]*e+j[3]*r,t}function pjA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[2]*r+j[4],t[1]=j[1]*e+j[3]*r+j[5],t}function kjA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[3]*r+j[6],t[1]=j[1]*e+j[4]*r+j[7],t}function gjA(t,A,j){let e=A[0],r=A[1];return t[0]=j[0]*e+j[4]*r+j[12],t[1]=j[1]*e+j[5]*r+j[13],t}function mjA(t,A,j,e){let r=A[0]-j[0],n=A[1]-j[1],i=Math.sin(e),o=Math.cos(e);return t[0]=r*o-n*i+j[0],t[1]=r*i+n*o+j[1],t}function EjA(t,A){let j=t[0],e=t[1],r=A[0],n=A[1],i=Math.sqrt((j*j+e*e)*(r*r+n*n)),o=i&&(j*r+e*n)/i;return Math.acos(Math.min(Math.max(o,-1),1))}function $jA(t){return t[0]=0,t[1]=0,t}function xjA(t){return`vec2(${t[0]}, ${t[1]})`}function yjA(t,A){return t[0]===A[0]&&t[1]===A[1]}function vjA(t,A){let j=t[0],e=t[1],r=A[0],n=A[1];return Math.abs(j-r)<=1e-6*Math.max(1,Math.abs(j),Math.abs(r))&&Math.abs(e-n)<=1e-6*Math.max(1,Math.abs(e),Math.abs(n))}var _jA=HS,qjA=TS,bjA=SS,GjA=RS,wjA=LS,FjA=CS,PjA=DS,IjA=function(){let t=OS();return function(A,j,e,r,n,i){let o,l;for(j||(j=2),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oRjA,angle:()=>oeA,bezier:()=>ZjA,ceil:()=>LjA,clone:()=>MjA,copy:()=>TjA,create:()=>NS,cross:()=>QjA,dist:()=>heA,distance:()=>VS,div:()=>feA,divide:()=>US,dot:()=>Fw,equals:()=>ceA,exactEquals:()=>leA,floor:()=>CjA,forEach:()=>geA,fromValues:()=>OjA,hermite:()=>JjA,inverse:()=>UjA,len:()=>peA,length:()=>KS,lerp:()=>WjA,max:()=>DjA,min:()=>HjA,mul:()=>BeA,multiply:()=>zS,negate:()=>zjA,normalize:()=>VjA,random:()=>AeA,rotateX:()=>reA,rotateY:()=>neA,rotateZ:()=>ieA,round:()=>NjA,scale:()=>KjA,scaleAndAdd:()=>XjA,set:()=>SjA,slerp:()=>YjA,sqrDist:()=>deA,sqrLen:()=>keA,squaredDistance:()=>QS,squaredLength:()=>WS,str:()=>aeA,sub:()=>ueA,subtract:()=>XS,transformMat3:()=>jeA,transformMat4:()=>teA,transformQuat:()=>eeA,zero:()=>seA});function NS(){let t=new pe(3);return pe!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t}function MjA(t){let A=new pe(3);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A}function KS(t){let A=t[0],j=t[1],e=t[2];return Math.sqrt(A*A+j*j+e*e)}function OjA(t,A,j){let e=new pe(3);return e[0]=t,e[1]=A,e[2]=j,e}function TjA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t}function SjA(t,A,j,e){return t[0]=A,t[1]=j,t[2]=e,t}function RjA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t}function XS(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t}function zS(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t}function US(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t}function LjA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t}function CjA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t}function HjA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t}function DjA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t}function NjA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t[2]=vi(A[2]),t}function KjA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t}function XjA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t}function VS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return Math.sqrt(j*j+e*e+r*r)}function QS(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2];return j*j+e*e+r*r}function WS(t){let A=t[0],j=t[1],e=t[2];return A*A+j*j+e*e}function zjA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t}function UjA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t}function VjA(t,A){let j=A[0],e=A[1],r=A[2],n=j*j+e*e+r*r;return n>0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function Fw(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function QjA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function WjA(t,A,j,e){let r=A[0],n=A[1],i=A[2];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t}function YjA(t,A,j,e){let r=Math.acos(Math.min(Math.max(Fw(A,j),-1),1)),n=Math.sin(r),i=Math.sin((1-e)*r)/n,o=Math.sin(e*r)/n;return t[0]=i*A[0]+o*j[0],t[1]=i*A[1]+o*j[1],t[2]=i*A[2]+o*j[2],t}function JjA(t,A,j,e,r,n){let i=n*n,o=i*(2*n-3)+1,l=i*(n-2)+n,c=i*(n-1),B=i*(3-2*n);return t[0]=A[0]*o+j[0]*l+e[0]*c+r[0]*B,t[1]=A[1]*o+j[1]*l+e[1]*c+r[1]*B,t[2]=A[2]*o+j[2]*l+e[2]*c+r[2]*B,t}function ZjA(t,A,j,e,r,n){let i=1-n,o=i*i,l=n*n,c=o*i,B=3*n*o,h=3*l*i,d=l*n;return t[0]=A[0]*c+j[0]*B+e[0]*h+r[0]*d,t[1]=A[1]*c+j[1]*B+e[1]*h+r[1]*d,t[2]=A[2]*c+j[2]*B+e[2]*h+r[2]*d,t}function AeA(t,A){A=A===void 0?1:A;let j=as()*2*Math.PI,e=as()*2-1,r=Math.sqrt(1-e*e)*A;return t[0]=Math.cos(j)*r,t[1]=Math.sin(j)*r,t[2]=e*A,t}function teA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function jeA(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function eeA(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function reA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function neA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function ieA(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function oeA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&Fw(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}function seA(t){return t[0]=0,t[1]=0,t[2]=0,t}function aeA(t){return`vec3(${t[0]}, ${t[1]}, ${t[2]})`}function leA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]}function ceA(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2];return Math.abs(j-n)<=1e-6*Math.max(1,Math.abs(j),Math.abs(n))&&Math.abs(e-i)<=1e-6*Math.max(1,Math.abs(e),Math.abs(i))&&Math.abs(r-o)<=1e-6*Math.max(1,Math.abs(r),Math.abs(o))}var ueA=XS,BeA=zS,feA=US,heA=VS,deA=QS,peA=KS,keA=WS,geA=function(){let t=NS();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;orrA,adjoint:()=>qeA,clone:()=>EeA,copy:()=>$eA,create:()=>meA,decompose:()=>KeA,determinant:()=>beA,equals:()=>srA,exactEquals:()=>orA,frob:()=>erA,fromQuat:()=>UeA,fromQuat2:()=>HeA,fromRotation:()=>SeA,fromRotationTranslation:()=>ZS,fromRotationTranslationScale:()=>XeA,fromRotationTranslationScaleOrigin:()=>zeA,fromScaling:()=>TeA,fromTranslation:()=>OeA,fromValues:()=>xeA,fromXRotation:()=>ReA,fromYRotation:()=>LeA,fromZRotation:()=>CeA,frustum:()=>VeA,getRotation:()=>NeA,getScaling:()=>AR,getTranslation:()=>DeA,identity:()=>YS,invert:()=>_eA,lookAt:()=>ArA,mul:()=>arA,multiply:()=>JS,multiplyScalar:()=>nrA,multiplyScalarAndAdd:()=>irA,ortho:()=>JeA,orthoNO:()=>jR,orthoZO:()=>ZeA,perspective:()=>QeA,perspectiveFromFieldOfView:()=>YeA,perspectiveNO:()=>tR,perspectiveZO:()=>WeA,rotate:()=>FeA,rotateX:()=>PeA,rotateY:()=>IeA,rotateZ:()=>MeA,scale:()=>weA,set:()=>yeA,str:()=>jrA,sub:()=>lrA,subtract:()=>eR,targetTo:()=>trA,translate:()=>GeA,transpose:()=>veA});function meA(){let t=new pe(16);return pe!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function EeA(t){let A=new pe(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function $eA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function xeA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new pe(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function yeA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function YS(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function veA(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function _eA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m,b=G*Q-v*T+_*X+w*R-x*C+O*F;return b?(b=1/b,t[0]=(o*Q-l*T+c*X)*b,t[1]=(r*T-e*Q-n*X)*b,t[2]=(E*O-m*x+y*w)*b,t[3]=(d*x-h*O-k*w)*b,t[4]=(l*R-i*Q-c*C)*b,t[5]=(j*Q-r*R+n*C)*b,t[6]=(m*_-g*O-y*v)*b,t[7]=(B*O-d*_+k*v)*b,t[8]=(i*T-o*R+c*F)*b,t[9]=(e*R-j*T-n*F)*b,t[10]=(g*x-E*_+y*G)*b,t[11]=(h*_-B*x-k*G)*b,t[12]=(o*C-i*X-l*F)*b,t[13]=(j*X-e*C+r*F)*b,t[14]=(E*v-g*w-m*G)*b,t[15]=(B*w-h*v+d*G)*b,t):null}function qeA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m;return t[0]=o*Q-l*T+c*X,t[1]=r*T-e*Q-n*X,t[2]=E*O-m*x+y*w,t[3]=d*x-h*O-k*w,t[4]=l*R-i*Q-c*C,t[5]=j*Q-r*R+n*C,t[6]=m*_-g*O-y*v,t[7]=B*O-d*_+k*v,t[8]=i*T-o*R+c*F,t[9]=e*R-j*T-n*F,t[10]=g*x-E*_+y*G,t[11]=h*_-B*x-k*G,t[12]=o*C-i*X-l*F,t[13]=j*X-e*C+r*F,t[14]=E*v-g*w-m*G,t[15]=B*w-h*v+d*G,t}function beA(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,G=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,O=A*x-j*w+e*_,F=n*x-i*w+o*_,C=c*v-B*G+h*y,R=k*v-g*G+E*y;return l*O-r*F+m*C-d*R}function JS(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],G=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*G,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*G,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*G,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*G,t}function GeA(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function weA(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function FeA(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,G,v,_,w,x,O,F,C,R,X,T,Q,b,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],G=A[7],v=A[8],_=A[9],w=A[10],x=A[11],O=r*r*B+l,F=n*r*B+i*c,C=i*r*B-n*c,R=r*n*B-i*c,X=n*n*B+l,T=i*n*B+r*c,Q=r*i*B+n*c,b=n*i*B-r*c,jA=i*i*B+l,t[0]=h*O+E*F+v*C,t[1]=d*O+m*F+_*C,t[2]=k*O+y*F+w*C,t[3]=g*O+G*F+x*C,t[4]=h*R+E*X+v*T,t[5]=d*R+m*X+_*T,t[6]=k*R+y*X+w*T,t[7]=g*R+G*X+x*T,t[8]=h*Q+E*b+v*jA,t[9]=d*Q+m*b+_*jA,t[10]=k*Q+y*b+w*jA,t[11]=g*Q+G*b+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function PeA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function IeA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function MeA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function OeA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function TeA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function SeA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function ReA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function LeA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function CeA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function ZS(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,G=i*c;return t[0]=1-(k+E),t[1]=h+G,t[2]=d-y,t[3]=0,t[4]=h-G,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function HeA(t,A){let j=new pe(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),ZS(t,A,j),t}function DeA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function AR(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function NeA(t,A){let j=new pe(3);AR(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function KeA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,G=i*E,v=o*k,_=l*g,w=c*E,x=B*k,O=h*g,F=d*E,C=m+_+F,R=0;return C>0?(R=Math.sqrt(C+1)*2,t[3]=.25*R,t[0]=(w-O)/R,t[1]=(x-G)/R,t[2]=(y-v)/R):m>_&&m>F?(R=Math.sqrt(1+m-_-F)*2,t[3]=(w-O)/R,t[0]=.25*R,t[1]=(y+v)/R,t[2]=(x+G)/R):_>F?(R=Math.sqrt(1+_-m-F)*2,t[3]=(x-G)/R,t[0]=(y+v)/R,t[1]=.25*R,t[2]=(w+O)/R):(R=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/R,t[0]=(x+G)/R,t[1]=(w+O)/R,t[2]=.25*R),t}function XeA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,G=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-G)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+G)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function zeA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,G=l*c,v=l*B,_=l*h,w=e[0],x=e[1],O=e[2],F=r[0],C=r[1],R=r[2],X=(1-(E+y))*w,T=(k+_)*w,Q=(g-v)*w,b=(k-_)*x,jA=(1-(d+y))*x,pA=(m+G)*x,dA=(g+v)*O,$A=(m-G)*O,_A=(1-(d+E))*O;return t[0]=X,t[1]=T,t[2]=Q,t[3]=0,t[4]=b,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(X*F+b*C+dA*R),t[13]=j[1]+C-(T*F+jA*C+$A*R),t[14]=j[2]+R-(Q*F+pA*C+_A*R),t[15]=1,t}function UeA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function VeA(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function tR(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var QeA=tR;function WeA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function YeA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function jR(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var JeA=jR;function ZeA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function ArA(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],G=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?YS(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=G*k-v*d,i=v*h-y*k,o=y*d-G*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function trA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function jrA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function erA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function rrA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function eR(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function nrA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function irA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function orA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function srA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],G=A[0],v=A[1],_=A[2],w=A[3],x=A[4],O=A[5],F=A[6],C=A[7],R=A[8],X=A[9],T=A[10],Q=A[11],b=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-G)<=1e-6*Math.max(1,Math.abs(j),Math.abs(G))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-O)<=1e-6*Math.max(1,Math.abs(o),Math.abs(O))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-C)<=1e-6*Math.max(1,Math.abs(c),Math.abs(C))&&Math.abs(B-R)<=1e-6*Math.max(1,Math.abs(B),Math.abs(R))&&Math.abs(h-X)<=1e-6*Math.max(1,Math.abs(h),Math.abs(X))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-Q)<=1e-6*Math.max(1,Math.abs(k),Math.abs(Q))&&Math.abs(g-b)<=1e-6*Math.max(1,Math.abs(g),Math.abs(b))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var arA=JS,lrA=eR;var fp={};fr(fp,{add:()=>hrA,ceil:()=>drA,clone:()=>crA,copy:()=>BrA,create:()=>rR,cross:()=>qrA,dist:()=>LrA,distance:()=>sR,div:()=>RrA,divide:()=>oR,dot:()=>_rA,equals:()=>OrA,exactEquals:()=>MrA,floor:()=>prA,forEach:()=>NrA,fromValues:()=>urA,inverse:()=>yrA,len:()=>HrA,length:()=>lR,lerp:()=>brA,max:()=>grA,min:()=>krA,mul:()=>SrA,multiply:()=>iR,negate:()=>xrA,normalize:()=>vrA,random:()=>GrA,round:()=>mrA,scale:()=>ErA,scaleAndAdd:()=>$rA,set:()=>frA,sqrDist:()=>CrA,sqrLen:()=>DrA,squaredDistance:()=>aR,squaredLength:()=>cR,str:()=>IrA,sub:()=>TrA,subtract:()=>nR,transformMat4:()=>wrA,transformQuat:()=>FrA,zero:()=>PrA});function rR(){let t=new pe(4);return pe!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function crA(t){let A=new pe(4);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A}function urA(t,A,j,e){let r=new pe(4);return r[0]=t,r[1]=A,r[2]=j,r[3]=e,r}function BrA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t}function frA(t,A,j,e,r){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t}function hrA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function nR(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t}function iR(t,A,j){return t[0]=A[0]*j[0],t[1]=A[1]*j[1],t[2]=A[2]*j[2],t[3]=A[3]*j[3],t}function oR(t,A,j){return t[0]=A[0]/j[0],t[1]=A[1]/j[1],t[2]=A[2]/j[2],t[3]=A[3]/j[3],t}function drA(t,A){return t[0]=Math.ceil(A[0]),t[1]=Math.ceil(A[1]),t[2]=Math.ceil(A[2]),t[3]=Math.ceil(A[3]),t}function prA(t,A){return t[0]=Math.floor(A[0]),t[1]=Math.floor(A[1]),t[2]=Math.floor(A[2]),t[3]=Math.floor(A[3]),t}function krA(t,A,j){return t[0]=Math.min(A[0],j[0]),t[1]=Math.min(A[1],j[1]),t[2]=Math.min(A[2],j[2]),t[3]=Math.min(A[3],j[3]),t}function grA(t,A,j){return t[0]=Math.max(A[0],j[0]),t[1]=Math.max(A[1],j[1]),t[2]=Math.max(A[2],j[2]),t[3]=Math.max(A[3],j[3]),t}function mrA(t,A){return t[0]=vi(A[0]),t[1]=vi(A[1]),t[2]=vi(A[2]),t[3]=vi(A[3]),t}function ErA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function $rA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t}function sR(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return Math.sqrt(j*j+e*e+r*r+n*n)}function aR(t,A){let j=A[0]-t[0],e=A[1]-t[1],r=A[2]-t[2],n=A[3]-t[3];return j*j+e*e+r*r+n*n}function lR(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function cR(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function xrA(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=-A[3],t}function yrA(t,A){return t[0]=1/A[0],t[1]=1/A[1],t[2]=1/A[2],t[3]=1/A[3],t}function vrA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function _rA(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function qrA(t,A,j,e){let r=j[0]*e[1]-j[1]*e[0],n=j[0]*e[2]-j[2]*e[0],i=j[0]*e[3]-j[3]*e[0],o=j[1]*e[2]-j[2]*e[1],l=j[1]*e[3]-j[3]*e[1],c=j[2]*e[3]-j[3]*e[2],B=A[0],h=A[1],d=A[2],k=A[3];return t[0]=h*c-d*l+k*o,t[1]=-(B*c)+d*i-k*n,t[2]=B*l-h*i+k*r,t[3]=-(B*o)+h*n-d*r,t}function brA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function GrA(t,A){A=A===void 0?1:A;let j,e,r,n,i,o;do j=as()*2-1,e=as()*2-1,i=j*j+e*e;while(i>=1);do r=as()*2-1,n=as()*2-1,o=r*r+n*n;while(o>=1);let l=Math.sqrt((1-i)/o);return t[0]=A*j,t[1]=A*e,t[2]=A*r*l,t[3]=A*n*l,t}function wrA(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3];return t[0]=j[0]*e+j[4]*r+j[8]*n+j[12]*i,t[1]=j[1]*e+j[5]*r+j[9]*n+j[13]*i,t[2]=j[2]*e+j[6]*r+j[10]*n+j[14]*i,t[3]=j[3]*e+j[7]*r+j[11]*n+j[15]*i,t}function FrA(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}function PrA(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}function IrA(t){return`vec4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]})`}function MrA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]}function OrA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=A[0],o=A[1],l=A[2],c=A[3];return Math.abs(j-i)<=1e-6*Math.max(1,Math.abs(j),Math.abs(i))&&Math.abs(e-o)<=1e-6*Math.max(1,Math.abs(e),Math.abs(o))&&Math.abs(r-l)<=1e-6*Math.max(1,Math.abs(r),Math.abs(l))&&Math.abs(n-c)<=1e-6*Math.max(1,Math.abs(n),Math.abs(c))}var TrA=nR,SrA=iR,RrA=oR,LrA=sR,CrA=aR,HrA=lR,DrA=cR,NrA=function(){let t=rR();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;oj?j:t}function KrA(t){return Math.log(t)*Math.LOG2E}var mB=Math.log2||KrA;function ho(t,A){if(!t)throw new Error(A||"@math.gl/web-mercator: assertion failed.")}var po=Math.PI,uR=po/4,_i=po/180,Mw=180/po,EB=512,B$=4003e4,$B=85.051129,BR=1.5;function Ow(t){return mB(t)}function In(t){let[A,j]=t;ho(Number.isFinite(A)),ho(Number.isFinite(j)&&j>=-90&&j<=90,"invalid latitude");let e=A*_i,r=j*_i,n=EB*(e+po)/(2*po),i=EB*(po+Math.log(Math.tan(uR+r*.5)))/(2*po);return[n,i]}function J6(t){let[A,j]=t,e=A/EB*(2*po)-po,r=2*(Math.atan(Math.exp(j/EB*(2*po)-po))-uR);return[e*Mw,r*Mw]}function Tw(t){let{latitude:A}=t;ho(Number.isFinite(A));let j=Math.cos(A*_i);return Ow(B$*j)-9}function dp(t){let A=Math.cos(t*_i);return EB/B$/A}function xB(t){let{latitude:A,longitude:j,highPrecision:e=!1}=t;ho(Number.isFinite(A)&&Number.isFinite(j));let r=EB,n=Math.cos(A*_i),i=r/360,o=i/n,l=r/B$/n,c={unitsPerMeter:[l,l,l],metersPerUnit:[1/l,1/l,1/l],unitsPerDegree:[i,o,l],degreesPerUnit:[1/i,1/o,1/l]};if(e){let B=_i*Math.tan(A*_i)/n,h=i*B/2,d=r/B$*B,k=d/o*l;c.unitsPerDegree2=[0,h,d],c.unitsPerMeter2=[k,0,k]}return c}function pp(t,A){let[j,e,r]=t,[n,i,o]=A,{unitsPerMeter:l,unitsPerMeter2:c}=xB({longitude:j,latitude:e,highPrecision:!0}),B=In(t);B[0]+=n*(l[0]+c[0]*i),B[1]+=i*(l[1]+c[1]*i);let h=J6(B),d=(r||0)+(o||0);return Number.isFinite(r)||Number.isFinite(o)?[h[0],h[1],d]:h}function f$(t){let{height:A,pitch:j,bearing:e,altitude:r,scale:n,center:i}=t,o=Pw();O7.translate(o,o,[0,0,-r]),O7.rotateX(o,o,-j*_i),O7.rotateZ(o,o,e*_i);let l=n/A;return O7.scale(o,o,[l,l,l]),i&&O7.translate(o,o,u$.negate([],i)),o}function Sw(t){let{width:A,height:j,altitude:e,pitch:r=0,offset:n,center:i,scale:o,nearZMultiplier:l=1,farZMultiplier:c=1}=t,{fovy:B=Ec(BR)}=t;e!==void 0&&(B=Ec(e));let h=B*_i,d=r*_i,k=$c(B),g=k;i&&(g+=i[2]*o/Math.cos(d)/j);let E=h*(.5+(n?n[1]:0)/j),m=Math.sin(E)*g/Math.sin(hp(Math.PI/2-d-E,.01,Math.PI-.01)),y=Math.sin(d)*m+g,G=g*10,v=Math.min(y*c,G);return{fov:h,aspect:A/j,focalDistance:k,near:l,far:v}}function Ec(t){return 2*Math.atan(.5/t)*Mw}function $c(t){return .5/Math.tan(.5*t*_i)}function yB(t,A){let[j,e,r=0]=t;return ho(Number.isFinite(j)&&Number.isFinite(e)&&Number.isFinite(r)),T7(A,[j,e,r,1])}function qi(t,A,j=0){let[e,r,n]=t;if(ho(Number.isFinite(e)&&Number.isFinite(r),"invalid pixel coordinate"),Number.isFinite(n))return T7(A,[e,r,n,1]);let i=T7(A,[e,r,0,1]),o=T7(A,[e,r,1,1]),l=i[2],c=o[2],B=l===c?0:((j||0)-l)/(c-l);return gB.lerp([],i,o,B)}function h$(t){let{width:A,height:j,bounds:e,minExtent:r=0,maxZoom:n=24,offset:i=[0,0]}=t,[[o,l],[c,B]]=e,h=XrA(t.padding),d=In([o,hp(B,-$B,$B)]),k=In([c,hp(l,-$B,$B)]),g=[Math.max(Math.abs(k[0]-d[0]),r),Math.max(Math.abs(k[1]-d[1]),r)],E=[A-h.left-h.right-Math.abs(i[0])*2,j-h.top-h.bottom-Math.abs(i[1])*2];ho(E[0]>0&&E[1]>0);let m=E[0]/g[0],y=E[1]/g[1],G=(h.right-h.left)/2/m,v=(h.top-h.bottom)/2/y,_=[(k[0]+d[0])/2+G,(k[1]+d[1])/2+v],w=J6(_),x=Math.min(n,mB(Math.abs(Math.min(m,y))));return ho(Number.isFinite(x)),{longitude:w[0],latitude:w[1],zoom:x}}function XrA(t=0){return typeof t=="number"?{top:t,bottom:t,left:t,right:t}:(ho(Number.isFinite(t.top)&&Number.isFinite(t.bottom)&&Number.isFinite(t.left)&&Number.isFinite(t.right)),t)}var fR=Math.PI/180;function d$(t,A=0){let{width:j,height:e,unproject:r}=t,n={targetZ:A},i=r([0,e],n),o=r([j,e],n),l,c,B=t.fovy?.5*t.fovy*fR:Math.atan(.5/t.altitude),h=(90-t.pitch)*fR;return B>h-.01?(l=hR(t,0,A),c=hR(t,j,A)):(l=r([0,0],n),c=r([j,0],n)),[i,o,c,l]}function hR(t,A,j){let{pixelUnprojectionMatrix:e}=t,r=T7(e,[A,0,1,1]),n=T7(e,[A,t.height,1,1]),o=(j*t.distanceScales.unitsPerMeter[2]-r[2])/(n[2]-r[2]),l=gB.lerp([],r,n,o),c=J6(l);return c.push(j),c}var pR=512;function Rw(t){let{width:A,height:j,pitch:e=0}=t,{longitude:r,latitude:n,zoom:i,bearing:o=0}=t;(r<-180||r>180)&&(r=Iw(r+180,360)-180),(o<-180||o>180)&&(o=Iw(o+180,360)-180);let l=mB(j/pR);if(i<=l)i=l,n=0;else{let c=j/2/Math.pow(2,i),B=J6([0,c])[1];if(nh&&(n=h)}}return{width:A,height:j,longitude:r,latitude:n,zoom:i,pitch:e,bearing:o}}var VrA=` const int max_lights = 2; uniform mat4 shadow_uViewProjectionMatrices[max_lights]; uniform vec4 shadow_uProjectCenters[max_lights]; @@ -806,7 +806,7 @@ vec4 shadow_setVertexPosition(vec4 position_commonspace) { } return gl_Position; } -`,NrA=` +`,QrA=` const int max_lights = 2; uniform bool shadow_uDrawShadowMap; uniform bool shadow_uUseShadowMap; @@ -850,11 +850,11 @@ vec4 shadow_filterShadowColor(vec4 color) { } return color; } -`,KrA=ss(QrA),XrA=ss(WrA),zrA=[0,0,0,1],UrA=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0];function VrA(t,A){let[j,e,r]=t,n=qi([j,e,r],A);return Number.isFinite(r)?n:[n[0],n[1],0]}function QrA({viewport:t,center:A}){return new lj(t.viewProjectionMatrix).invert().transform(A)}function WrA({viewport:t,shadowMatrices:A}){let j=[],e=t.pixelUnprojectionMatrix,r=t.isGeospatial?void 0:1,n=[[0,0,r],[t.width,0,r],[0,t.height,r],[t.width,t.height,r],[0,0,-1],[t.width,0,-1],[0,t.height,-1],[t.width,t.height,-1]].map(i=>VrA(i,e));for(let i of A){let o=i.clone().translate(new on(t.center).negate()),l=n.map(B=>o.transform(B)),c=new lj().ortho({left:Math.min(...l.map(B=>B[0])),right:Math.max(...l.map(B=>B[0])),bottom:Math.min(...l.map(B=>B[1])),top:Math.max(...l.map(B=>B[1])),near:Math.min(...l.map(B=>-B[2])),far:Math.max(...l.map(B=>-B[2]))});j.push(c.multiplyRight(i))}return j}function YrA(t,A){let{shadowEnabled:j=!0}=t;if(!j||!t.shadowMatrices||!t.shadowMatrices.length)return{shadow_uDrawShadowMap:!1,shadow_uUseShadowMap:!1,shadow_uShadowMap0:t.dummyShadowMap,shadow_uShadowMap1:t.dummyShadowMap};let e={shadow_uDrawShadowMap:!!t.drawToShadowMap,shadow_uUseShadowMap:t.shadowMaps?t.shadowMaps.length>0:!1,shadow_uColor:t.shadowColor||zrA,shadow_uLightId:t.shadowLightId||0,shadow_uLightCount:t.shadowMatrices.length},r=KrA({viewport:t.viewport,center:A.project_uCenter}),n=[],i=XrA({shadowMatrices:t.shadowMatrices,viewport:t.viewport}).slice();for(let o=0;oAnA(i,e));for(let i of A){let o=i.clone().translate(new on(t.center).negate()),l=n.map(B=>o.transform(B)),c=new lj().ortho({left:Math.min(...l.map(B=>B[0])),right:Math.max(...l.map(B=>B[0])),bottom:Math.min(...l.map(B=>B[1])),top:Math.max(...l.map(B=>B[1])),near:Math.min(...l.map(B=>-B[2])),far:Math.max(...l.map(B=>-B[2]))});j.push(c.multiplyRight(i))}return j}function enA(t,A){let{shadowEnabled:j=!0}=t;if(!j||!t.shadowMatrices||!t.shadowMatrices.length)return{shadow_uDrawShadowMap:!1,shadow_uUseShadowMap:!1,shadow_uShadowMap0:t.dummyShadowMap,shadow_uShadowMap1:t.dummyShadowMap};let e={shadow_uDrawShadowMap:!!t.drawToShadowMap,shadow_uUseShadowMap:t.shadowMaps?t.shadowMaps.length>0:!1,shadow_uColor:t.shadowColor||JrA,shadow_uLightId:t.shadowLightId||0,shadow_uLightCount:t.shadowMatrices.length},r=WrA({viewport:t.viewport,center:A.project_uCenter}),n=[],i=YrA({shadowMatrices:t.shadowMatrices,viewport:t.viewport}).slice();for(let o=0;o"viewport"in t&&(t.drawToShadowMap||t.shadowMaps&&t.shadowMaps.length>0)?YrA(t,A):{}};var Cr={...YE,defaultUniforms:{...YE.defaultUniforms,useFloatColors:!1},inject:{"vs:DECKGL_FILTER_GL_POSITION":` + `},getUniforms:(t={},A={})=>"viewport"in t&&(t.drawToShadowMap||t.shadowMaps&&t.shadowMaps.length>0)?enA(t,A):{}};var Cr={...j$,defaultUniforms:{...j$.defaultUniforms,useFloatColors:!1},inject:{"vs:DECKGL_FILTER_GL_POSITION":` // for picking depth values picking_setPickingAttribute(position.z / position.w); `,"vs:DECKGL_FILTER_COLOR":` @@ -865,8 +865,8 @@ vec4 shadow_filterShadowColor(vec4 color) { // use picking color if rendering to picking FBO. color = picking_filterPickingColor(color); - `}}};var JrA=[M7],ZrA=["vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)","vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)","vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)","fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)"];function Mw(){let t=uc.getDefaultShaderAssembler();for(let A of JrA)t.addDefaultModule(A);for(let A of ZrA)t.addShaderHook(A);return t}var AnA=[255,255,255],tnA=1,jnA=0,pp=class{constructor(A={}){this.type="ambient";let{color:j=AnA}=A,{intensity:e=tnA}=A;this.id=A.id||`ambient-${jnA++}`,this.color=j,this.intensity=e}};var enA=[255,255,255],rnA=1,nnA=[0,0,-1],inA=0,vB=class{constructor(A={}){this.type="directional";let{color:j=enA}=A,{intensity:e=rnA}=A,{direction:r=nnA}=A,{_shadow:n=!1}=A;this.id=A.id||`directional-${inA++}`,this.color=j,this.intensity=e,this.type="directional",this.direction=new on(r).normalize().toArray(),this.shadow=n}getProjectedLight(A){return this}};var kp=class{constructor(A,j={id:"pass"}){let{id:e}=j;this.id=e,this.device=A,this.props={...j}}setProps(A){Object.assign(this.props,A)}render(A){}cleanup(){}};var wa=class extends kp{constructor(){super(...arguments),this._lastRenderIndex=-1}render(A){let[j,e]=this.device.canvasContext.getDrawingBufferSize(),r=A.clearCanvas??!0,n=A.clearColor??(r?[0,0,0,0]:!1),i=r?1:!1,o=r?0:!1,l=A.colorMask??15,c={viewport:[0,0,j,e]};A.colorMask&&(c.colorMask=l),A.scissorRect&&(c.scissorRect=A.scissorRect);let B=this.device.beginRenderPass({framebuffer:A.target,parameters:c,clearColor:n,clearDepth:i,clearStencil:o});try{return this._drawLayers(B,A)}finally{B.end()}}_drawLayers(A,j){let{target:e,moduleParameters:r,viewports:n,views:i,onViewportActive:o,clearStack:l=!0}=j;j.pass=j.pass||"unknown",l&&(this._lastRenderIndex=-1);let c=[];for(let B of n){let h=i&&i[B.id];o?.(B);let d=this._getDrawLayerParams(B,j),k=B.subViewports||[B];for(let g of k){let E=this._drawLayersInViewport(A,{target:e,moduleParameters:r,viewport:g,view:h,pass:j.pass,layers:j.layers},d);c.push(E)}}return c}_getDrawLayerParams(A,{layers:j,pass:e,isPicking:r=!1,layerFilter:n,cullRect:i,effects:o,moduleParameters:l},c=!1){let B=[],h=uR(this._lastRenderIndex+1),d={layer:j[0],viewport:A,isPicking:r,renderPass:e,cullRect:i},k={};for(let g=0;gthis.device.clearWebGL(h))}let B={totalCount:j.length,visibleCount:0,compositeCount:0,pickableCount:0};A.setParameters({viewport:c});for(let h=0;h{let i=r.props._offset,o=r.id,l=r.parent&&r.parent.id,c;if(l&&!(l in A)&&e(r.parent,!1),l in j){let B=j[l]=j[l]||uR(A[l],A);c=B(r,n),j[o]=B}else Number.isFinite(i)?(c=i+(A[l]||0),j[o]=null):c=t;return n&&c>=t&&(t=c+1),A[o]=c,c};return e}function onA(t,{moduleParameters:A,target:j,viewport:e}){let r=A&&A.devicePixelRatio||t.canvasContext.cssToDeviceRatio(),[,n]=t.canvasContext.getDrawingBufferSize(),i=j?j.height:n,o=e;return[o.x*r,i-(o.y+o.height)*r,o.width*r,o.height*r]}var gp=class extends wa{constructor(A,j){super(A,j),this.shadowMap=A.createTexture({width:1,height:1,sampler:{minFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}}),this.depthBuffer=A.createTexture({format:"depth16unorm",width:1,height:1,mipmaps:!1,dataFormat:6402,type:5125}),this.fbo=A.createFramebuffer({id:"shadowmap",width:1,height:1,colorAttachments:[this.shadowMap],depthStencilAttachment:this.depthBuffer})}render(A){let j=this.fbo,e=this.device.canvasContext.cssToDeviceRatio(),r=A.viewports[0],n=r.width*e,i=r.height*e,o=[1,1,1,1];(n!==j.width||i!==j.height)&&j.resize({width:n,height:i}),super.render({...A,clearColor:o,target:j,pass:"shadow"})}getLayerParameters(A,j,e){return{...A.props.parameters,blend:!1,depthRange:[0,1],depthTest:!0}}shouldDrawLayer(A){return A.props.shadowEnabled!==!1}getModuleParameters(){return{drawToShadowMap:!0}}delete(){this.fbo&&(this.fbo.destroy(),this.fbo=null),this.shadowMap&&(this.shadowMap.destroy(),this.shadowMap=null),this.depthBuffer&&(this.depthBuffer.destroy(),this.depthBuffer=null)}};var snA={color:[255,255,255],intensity:1},BR=[{color:[255,255,255],intensity:1,direction:[-1,3,-1]},{color:[255,255,255],intensity:.9,direction:[1,-8,-2.5]}],anA=[0,0,0,200/255],$c=class{constructor(A={}){this.id="lighting-effect",this.shadowColor=anA,this.shadow=!1,this.ambientLight=null,this.directionalLights=[],this.pointLights=[],this.shadowPasses=[],this.shadowMaps=[],this.dummyShadowMap=null,this.setProps(A)}setup(A){this.context=A;let{device:j,deck:e}=A;this.shadow&&!this.dummyShadowMap&&(this._createShadowPasses(j),e._addDefaultShaderModule(dp),this.dummyShadowMap=j.createTexture({width:1,height:1}))}setProps(A){this.ambientLight=null,this.directionalLights=[],this.pointLights=[];for(let j in A){let e=A[j];switch(e.type){case"ambient":this.ambientLight=e;break;case"directional":this.directionalLights.push(e);break;case"point":this.pointLights.push(e);break;default:}}this._applyDefaultLights(),this.shadow=this.directionalLights.some(j=>j.shadow),this.context&&this.setup(this.context),this.props=A}preRender({layers:A,layerFilter:j,viewports:e,onViewportActive:r,views:n}){if(this.shadow){this.shadowMatrices=this._calculateMatrices();for(let i=0;ie.getProjectedLight({layer:A})),pointLights:this.pointLights.map(e=>e.getProjectedLight({layer:A}))},j}cleanup(A){for(let j of this.shadowPasses)j.delete();this.shadowPasses.length=0,this.shadowMaps.length=0,this.dummyShadowMap&&(this.dummyShadowMap.destroy(),this.dummyShadowMap=null,A.deck._removeDefaultShaderModule(dp))}_calculateMatrices(){let A=[];for(let j of this.directionalLights){let e=new lj().lookAt({eye:new on(j.direction).negate()});A.push(e)}return A}_createShadowPasses(A){for(let j=0;jr&&(n=r);let i=this._pool,o=A.BYTES_PER_ELEMENT*n,l=i.findIndex(c=>c.byteLength>=o);if(l>=0){let c=new A(i.splice(l,1)[0],0,n);return e&&c.fill(0),c}return new A(n)}_release(A){if(!ArrayBuffer.isView(A))return;let j=this._pool,{buffer:e}=A,{byteLength:r}=e,n=j.findIndex(i=>i.byteLength>=r);n<0?j.push(e):(n>0||j.lengththis.opts.poolSize&&j.shift()}},ko=new Ow;function qB(){return[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]}function hR(t,A){let j=t%A;return j<0?A+j:j}function dR(t){return[t[12],t[13],t[14]]}function pR(t){return{left:_B(t[3]+t[0],t[7]+t[4],t[11]+t[8],t[15]+t[12]),right:_B(t[3]-t[0],t[7]-t[4],t[11]-t[8],t[15]-t[12]),bottom:_B(t[3]+t[1],t[7]+t[5],t[11]+t[9],t[15]+t[13]),top:_B(t[3]-t[1],t[7]-t[5],t[11]-t[9],t[15]-t[13]),near:_B(t[3]+t[2],t[7]+t[6],t[11]+t[10],t[15]+t[14]),far:_B(t[3]-t[2],t[7]-t[6],t[11]-t[10],t[15]-t[14])}}var fR=new on;function _B(t,A,j,e){fR.set(t,A,j);let r=fR.len();return{distance:e/r,normal:new on(-t/r,-A/r,-j/r)}}function kR(t){return t-Math.fround(t)}var mp;function u$(t,A){let{size:j=1,startIndex:e=0}=A,r=A.endIndex!==void 0?A.endIndex:t.length,n=(r-e)/j;mp=ko.allocate(mp,n,{type:Float32Array,size:j*2});let i=e,o=0;for(;i=j.delay+j.duration*j.repeat}getTime(A){if(A===void 0)return this.time;let j=this.channels.get(A);return j===void 0?-1:j.time}setTime(A){this.time=Math.max(0,A);let j=this.channels.values();for(let r of j)this._setChannelTime(r,this.time);let e=this.animations.values();for(let r of e){let{animation:n,channel:i}=r;n.setTime(this.getTime(i))}}play(){this.playing=!0}pause(){this.playing=!1,this.lastEngineTime=-1}reset(){this.setTime(0)}attachAnimation(A,j){let e=dnA++;return this.animations.set(e,{animation:A,channel:j}),A.setTime(this.getTime(j)),e}detachAnimation(A){this.animations.delete(A)}update(A){this.playing&&(this.lastEngineTime===-1&&(this.lastEngineTime=A),this.setTime(this.time+(A-this.lastEngineTime)),this.lastEngineTime=A)}_setChannelTime(A,j){let e=j-A.delay,r=A.duration*A.repeat;e>=r?A.time=A.duration*A.rate:(A.time=Math.max(0,e)%A.duration,A.time*=A.rate)}};var pnA=0,knA={device:null,onAddHTML:()=>"",onInitialize:async()=>null,onRender:()=>{},onFinalize:()=>{},onError:t=>console.error(t),stats:ya.stats.get(`animation-loop-${pnA++}`),useDevicePixels:!0,autoResizeViewport:!1,autoResizeDrawingBuffer:!1},Ep=class{constructor(A){I(this,"device",null);I(this,"canvas",null);I(this,"props");I(this,"animationProps",null);I(this,"timeline",null);I(this,"stats");I(this,"cpuTime");I(this,"gpuTime");I(this,"frameRate");I(this,"display");I(this,"needsRedraw","initialized");I(this,"_initialized",!1);I(this,"_running",!1);I(this,"_animationFrameId",null);I(this,"_nextFramePromise",null);I(this,"_resolveNextFrame",null);I(this,"_cpuStartTime",0);if(this.props={...knA,...A},A=this.props,!A.device)throw new Error("No device provided");let{useDevicePixels:j=!0}=this.props;this.stats=A.stats||new v6({id:"animation-loop-stats"}),this.cpuTime=this.stats.get("CPU Time"),this.gpuTime=this.stats.get("GPU Time"),this.frameRate=this.stats.get("Frame Rate"),this.setProps({autoResizeViewport:A.autoResizeViewport,autoResizeDrawingBuffer:A.autoResizeDrawingBuffer,useDevicePixels:j}),this.start=this.start.bind(this),this.stop=this.stop.bind(this),this._onMousemove=this._onMousemove.bind(this),this._onMouseleave=this._onMouseleave.bind(this)}destroy(){this.stop(),this._setDisplay(null)}delete(){this.destroy()}setNeedsRedraw(A){return this.needsRedraw=this.needsRedraw||A,this}setProps(A){return"autoResizeViewport"in A&&(this.props.autoResizeViewport=A.autoResizeViewport||!1),"autoResizeDrawingBuffer"in A&&(this.props.autoResizeDrawingBuffer=A.autoResizeDrawingBuffer||!1),"useDevicePixels"in A&&(this.props.useDevicePixels=A.useDevicePixels||!1),this}async start(){if(this._running)return this;this._running=!0;try{let A;return this._initialized||(this._initialized=!0,await this._initDevice(),this._initialize(),await this.props.onInitialize(this._getAnimationProps())),this._running?(A!==!1&&(this._cancelAnimationFrame(),this._requestAnimationFrame()),this):null}catch(A){let j=A instanceof Error?A:new Error("Unknown error");throw this.props.onError(j),j}}stop(){return this._running&&(this.animationProps&&this.props.onFinalize(this.animationProps),this._cancelAnimationFrame(),this._nextFramePromise=null,this._resolveNextFrame=null,this._running=!1),this}redraw(){return this.device?.isLost?this:(this._beginFrameTimers(),this._setupFrame(),this._updateAnimationProps(),this._renderFrame(this._getAnimationProps()),this._clearNeedsRedraw(),this._resolveNextFrame&&(this._resolveNextFrame(this),this._nextFramePromise=null,this._resolveNextFrame=null),this._endFrameTimers(),this)}attachTimeline(A){return this.timeline=A,this.timeline}detachTimeline(){this.timeline=null}waitForRender(){return this.setNeedsRedraw("waitForRender"),this._nextFramePromise||(this._nextFramePromise=new Promise(A=>{this._resolveNextFrame=A})),this._nextFramePromise}async toDataURL(){if(this.setNeedsRedraw("toDataURL"),await this.waitForRender(),this.canvas instanceof HTMLCanvasElement)return this.canvas.toDataURL();throw new Error("OffscreenCanvas")}_initialize(){this._startEventHandling(),this._initializeAnimationProps(),this._updateAnimationProps(),this._resizeCanvasDrawingBuffer(),this._resizeViewport()}_setDisplay(A){this.display&&(this.display.destroy(),this.display.animationLoop=null),A&&(A.animationLoop=this),this.display=A}_requestAnimationFrame(){this._running&&(this._animationFrameId=eb(this._animationFrame.bind(this)))}_cancelAnimationFrame(){this._animationFrameId!==null&&(rb(this._animationFrameId),this._animationFrameId=null)}_animationFrame(){this._running&&(this.redraw(),this._requestAnimationFrame())}_renderFrame(A){if(this.display){this.display._renderFrame(A);return}this.props.onRender(this._getAnimationProps()),this.device.submit()}_clearNeedsRedraw(){this.needsRedraw=!1}_setupFrame(){this._resizeCanvasDrawingBuffer(),this._resizeViewport()}_initializeAnimationProps(){if(!this.device)throw new Error("loop");this.animationProps={animationLoop:this,device:this.device,canvas:this.device?.canvasContext?.canvas,timeline:this.timeline,useDevicePixels:this.props.useDevicePixels,needsRedraw:!1,width:1,height:1,aspect:1,time:0,startTime:Date.now(),engineTime:0,tick:0,tock:0,_mousePosition:null}}_getAnimationProps(){if(!this.animationProps)throw new Error("animationProps");return this.animationProps}_updateAnimationProps(){if(!this.animationProps)return;let{width:A,height:j,aspect:e}=this._getSizeAndAspect();(A!==this.animationProps.width||j!==this.animationProps.height)&&this.setNeedsRedraw("drawing buffer resized"),e!==this.animationProps.aspect&&this.setNeedsRedraw("drawing buffer aspect changed"),this.animationProps.width=A,this.animationProps.height=j,this.animationProps.aspect=e,this.animationProps.needsRedraw=this.needsRedraw,this.animationProps.engineTime=Date.now()-this.animationProps.startTime,this.timeline&&this.timeline.update(this.animationProps.engineTime),this.animationProps.tick=Math.floor(this.animationProps.time/1e3*60),this.animationProps.tock++,this.animationProps.time=this.timeline?this.timeline.getTime():this.animationProps.engineTime}async _initDevice(){if(this.device=await this.props.device,!this.device)throw new Error("No device provided");this.canvas=this.device.canvasContext?.canvas||null}_createInfoDiv(){if(this.canvas&&this.props.onAddHTML){let A=document.createElement("div");document.body.appendChild(A),A.style.position="relative";let j=document.createElement("div");j.style.position="absolute",j.style.left="10px",j.style.bottom="10px",j.style.width="300px",j.style.background="white",this.canvas instanceof HTMLCanvasElement&&A.appendChild(this.canvas),A.appendChild(j);let e=this.props.onAddHTML(j);e&&(j.innerHTML=e)}}_getSizeAndAspect(){if(!this.device)return{width:1,height:1,aspect:1};let[A,j]=this.device?.canvasContext?.getPixelSize()||[1,1],e=1,r=this.device?.canvasContext?.canvas;return r&&r.clientHeight?e=r.clientWidth/r.clientHeight:A>0&&j>0&&(e=A/j),{width:A,height:j,aspect:e}}_resizeViewport(){this.props.autoResizeViewport&&this.device.gl&&this.device.gl.viewport(0,0,this.device.gl.drawingBufferWidth,this.device.gl.drawingBufferHeight)}_resizeCanvasDrawingBuffer(){this.props.autoResizeDrawingBuffer&&this.device?.canvasContext?.resize({useDevicePixels:this.props.useDevicePixels})}_beginFrameTimers(){this.frameRate.timeEnd(),this.frameRate.timeStart(),this.cpuTime.timeStart()}_endFrameTimers(){this.cpuTime.timeEnd()}_startEventHandling(){this.canvas&&(this.canvas.addEventListener("mousemove",this._onMousemove.bind(this)),this.canvas.addEventListener("mouseleave",this._onMouseleave.bind(this)))}_onMousemove(A){A instanceof MouseEvent&&(this._getAnimationProps()._mousePosition=[A.offsetX,A.offsetY])}_onMouseleave(A){this._getAnimationProps()._mousePosition=null}};var h$=class{constructor(A){I(this,"id");I(this,"userData",{});I(this,"topology");I(this,"bufferLayout",[]);I(this,"vertexCount");I(this,"indices");I(this,"attributes");this.id=A.id||Pn("geometry"),this.topology=A.topology,this.indices=A.indices||null,this.attributes=A.attributes,this.vertexCount=A.vertexCount,this.bufferLayout=A.bufferLayout||[],this.indices&&Ot(this.indices.usage===Aj.INDEX)}destroy(){this.indices?.destroy();for(let A of Object.values(this.attributes))A.destroy()}getVertexCount(){return this.vertexCount}getAttributes(){return this.attributes}getIndexes(){return this.indices}_calculateVertexCount(A){return A.byteLength/12}};function xR(t,A){if(A instanceof h$)return A;let j=gnA(t,A),{attributes:e,bufferLayout:r}=mnA(t,A);return new h$({topology:A.topology||"triangle-list",bufferLayout:r,vertexCount:A.vertexCount,indices:j,attributes:e})}function gnA(t,A){if(!A.indices)return;let j=A.indices.value;return t.createBuffer({usage:Aj.INDEX,data:j})}function mnA(t,A){let j=[],e={};for(let[n,i]of Object.entries(A.attributes)){let o=n;switch(n){case"POSITION":o="positions";break;case"NORMAL":o="normals";break;case"TEXCOORD_0":o="texCoords";break;case"COLOR_0":o="colors";break}e[o]=t.createBuffer({data:i.value,id:`${n}-buffer`});let{value:l,size:c,normalized:B}=i;j.push({name:o,format:Ab(l,c,B)})}let r=A._calculateVertexCount(A.attributes,A.indices);return{attributes:e,bufferLayout:j,vertexCount:r}}var d$=class{constructor(A){I(this,"modules");I(this,"moduleUniforms");I(this,"moduleBindings");I(this,"moduleUniformsChanged");let j=lc(Object.values(A).filter(e=>e.dependencies));for(let e of j)A[e.name]=e;mA.log(1,"Creating ShaderInputs with modules",Object.keys(A))(),this.modules=A,this.moduleUniforms={},this.moduleBindings={};for(let[e,r]of Object.entries(A)){let n=e;this.moduleUniforms[n]=r.defaultUniforms||{},this.moduleBindings[n]={}}}destroy(){}setProps(A){for(let j of Object.keys(A)){let e=j,r=A[e],n=this.modules[e];if(!n){mA.warn(`Module ${j} not found`)();continue}let i=this.moduleUniforms[e],o=this.moduleBindings[e],l=n.getUniforms?.(r,i)||r,{uniforms:c,bindings:B}=pc(l);this.moduleUniforms[e]={...i,...c},this.moduleBindings[e]={...o,...B}}}getModules(){return Object.values(this.modules)}getUniformValues(){return this.moduleUniforms}getBindings(){let A={};for(let j of Object.values(this.moduleBindings))Object.assign(A,j);return A}getDebugTable(){let A={};for(let[j,e]of Object.entries(this.moduleUniforms))for(let[r,n]of Object.entries(e))A[`${j}.${r}`]={type:this.modules[j].uniformTypes?.[r],value:String(n)};return A}};var k$=class k${constructor(A){I(this,"device");I(this,"_hashCounter",0);I(this,"_hashes",{});I(this,"_renderPipelineCache",{});I(this,"_computePipelineCache",{});this.device=A}static getDefaultPipelineFactory(A){return A._lumaData.defaultPipelineFactory=A._lumaData.defaultPipelineFactory||new k$(A),A._lumaData.defaultPipelineFactory}createRenderPipeline(A){let j={...rs.defaultProps,...A},e=this._hashRenderPipeline(j);if(!this._renderPipelineCache[e]){let r=this.device.createRenderPipeline({...j,id:j.id?`${j.id}-cached`:void 0});r.hash=e,this._renderPipelineCache[e]={pipeline:r,useCount:0}}return this._renderPipelineCache[e].useCount++,this._renderPipelineCache[e].pipeline}createComputePipeline(A){let j={...cB.defaultProps,...A},e=this._hashComputePipeline(j);if(!this._computePipelineCache[e]){let r=this.device.createComputePipeline({...j,id:j.id?`${j.id}-cached`:void 0});r.hash=e,this._computePipelineCache[e]={pipeline:r,useCount:0}}return this._computePipelineCache[e].useCount++,this._computePipelineCache[e].pipeline}release(A){let j=A.hash,e=A instanceof cB?this._computePipelineCache:this._renderPipelineCache;e[j].useCount--,e[j].useCount===0&&(e[j].pipeline.destroy(),delete e[j])}_hashComputePipeline(A){return`${this._getHash(A.shader.source)}`}_hashRenderPipeline(A){let j=this._getHash(A.vs.source),e=A.fs?this._getHash(A.fs.source):0,r="-",n=this._getHash(JSON.stringify(A.bufferLayout));switch(this.device.type){case"webgl":return`${j}/${e}V${r}BL${n}`;default:let i=this._getHash(JSON.stringify(A.parameters));return`${j}/${e}V${r}T${A.topology}P${i}BL${n}`}}_getHash(A){return this._hashes[A]===void 0&&(this._hashes[A]=this._hashCounter++),this._hashes[A]}};I(k$,"defaultProps",{...rs.defaultProps});var p$=k$;var m$=class m${constructor(A){I(this,"device");I(this,"_cache",{});this.device=A}static getDefaultShaderFactory(A){var j;return(j=A._lumaData).defaultShaderFactory||(j.defaultShaderFactory=new m$(A)),A._lumaData.defaultShaderFactory}createShader(A){let j=this._hashShader(A),e=this._cache[j];if(!e){let r=this.device.createShader({...A,id:A.id?`${A.id}-cached`:void 0});this._cache[j]=e={shader:r,useCount:0}}return e.useCount++,e.shader}release(A){let j=this._hashShader(A),e=this._cache[j];e&&(e.useCount--,e.useCount===0&&(delete this._cache[j],e.shader.destroy()))}_hashShader(A){return`${A.stage}:${A.source}`}};I(m$,"defaultProps",{...fc.defaultProps});var g$=m$;function yR(t,A){let j={},e="Values";if(t.attributes.length===0&&!t.varyings?.length)return{"No attributes or varyings":{[e]:"N/A"}};for(let r of t.attributes)if(r){let n=`${r.location} ${r.name}: ${r.type}`;j[`in ${n}`]={[e]:r.stepMode||"vertex"}}for(let r of t.varyings||[]){let n=`${r.location} ${r.name}`;j[`out ${n}`]={[e]:JSON.stringify(r.accessor)}}return j}var kr=null,Rw=null;function vR(t,{id:A,minimap:j,opaque:e,top:r="0",left:n="0",rgbaScale:i=1}){kr||(kr=document.createElement("canvas"),kr.id=A,kr.title=A,kr.style.zIndex="100",kr.style.position="absolute",kr.style.top=r,kr.style.left=n,kr.style.border="blue 1px solid",kr.style.transform="scaleY(-1)",document.body.appendChild(kr),Rw=kr.getContext("2d")),(kr.width!==t.width||kr.height!==t.height)&&(kr.width=t.width/2,kr.height=t.height/2,kr.style.width="400px",kr.style.height="400px");let o=t.device.readPixelsToArrayWebGL(t),l=Rw.createImageData(t.width,t.height),c=0;for(let B=0;B[l.name,l])||[]);this.setShaderInputs(j.shaderInputs||new d$(e));let r=$nA(A),n=(this.props.modules?.length>0?this.props.modules:this.shaderInputs?.getModules())||[];if(this.device.type==="webgpu"&&this.props.source){(o=this.props).shaderLayout||(o.shaderLayout=Db(this.props.source));let{source:l,getUniforms:c}=this.props.shaderAssembler.assembleShader({platformInfo:r,...this.props,modules:n});this.source=l,this._getModuleUniforms=c}else{let{vs:l,fs:c,getUniforms:B}=this.props.shaderAssembler.assembleShaderPair({platformInfo:r,...this.props,modules:n});this.vs=l,this.fs=c,this._getModuleUniforms=B}this.vertexCount=this.props.vertexCount,this.instanceCount=this.props.instanceCount,this.topology=this.props.topology,this.bufferLayout=this.props.bufferLayout,this.parameters=this.props.parameters,j.geometry&&this.setGeometry(j.geometry),this.pipelineFactory=j.pipelineFactory||p$.getDefaultPipelineFactory(this.device),this.shaderFactory=j.shaderFactory||g$.getDefaultShaderFactory(this.device),this.pipeline=this._updatePipeline(),this.vertexArray=A.createVertexArray({renderPipeline:this.pipeline}),this._gpuGeometry&&this._setGeometryAttributes(this._gpuGeometry),"isInstanced"in j&&(this.isInstanced=j.isInstanced),j.instanceCount&&this.setInstanceCount(j.instanceCount),j.vertexCount&&this.setVertexCount(j.vertexCount),j.indexBuffer&&this.setIndexBuffer(j.indexBuffer),j.attributes&&this.setAttributes(j.attributes),j.constantAttributes&&this.setConstantAttributes(j.constantAttributes),j.bindings&&this.setBindings(j.bindings),j.uniforms&&this.setUniforms(j.uniforms),j.moduleSettings&&this.updateModuleSettings(j.moduleSettings),j.transformFeedback&&(this.transformFeedback=j.transformFeedback),Object.seal(this)}destroy(){this._destroyed||(this.pipelineFactory.release(this.pipeline),this.shaderFactory.release(this.pipeline.vs),this.pipeline.fs&&this.shaderFactory.release(this.pipeline.fs),this._uniformStore.destroy(),this._gpuGeometry?.destroy(),this._destroyed=!0)}needsRedraw(){this._getBindingsUpdateTimestamp()>this._lastDrawTimestamp&&this.setNeedsRedraw("contents of bound textures or buffers updated");let A=this._needsRedraw;return this._needsRedraw=!1,A}setNeedsRedraw(A){this._needsRedraw||(this._needsRedraw=A)}predraw(){this.updateShaderInputs(),this.pipeline=this._updatePipeline()}draw(A){this.predraw();let j;try{this._logDrawCallStart(),this.pipeline=this._updatePipeline(),this.pipeline.setBindings(this.bindings,{disableWarnings:this.props.disableWarnings}),G7(this.uniforms)||this.pipeline.setUniformsWebGL(this.uniforms);let{indexBuffer:e}=this.vertexArray,r=e?e.byteLength/(e.indexType==="uint32"?4:2):void 0;j=this.pipeline.draw({renderPass:A,vertexArray:this.vertexArray,isInstanced:this.isInstanced,vertexCount:this.vertexCount,instanceCount:this.instanceCount,indexCount:r,transformFeedback:this.transformFeedback||void 0,parameters:this.parameters,topology:this.topology})}finally{this._logDrawCallEnd()}return this._logFramebuffer(A),j?(this._lastDrawTimestamp=this.device.timestamp,this._needsRedraw=!1):this._needsRedraw="waiting for resource initialization",j}setGeometry(A){this._gpuGeometry?.destroy();let j=A&&xR(this.device,A);j&&(this.setTopology(j.topology||"triangle-list"),this.bufferLayout=_R(j.bufferLayout,this.bufferLayout),this.vertexArray&&this._setGeometryAttributes(j)),this._gpuGeometry=j}setTopology(A){A!==this.topology&&(this.topology=A,this._setPipelineNeedsUpdate("topology"))}setBufferLayout(A){this.bufferLayout=this._gpuGeometry?_R(A,this._gpuGeometry.bufferLayout):A,this._setPipelineNeedsUpdate("bufferLayout"),this.pipeline=this._updatePipeline(),this.vertexArray=this.device.createVertexArray({renderPipeline:this.pipeline}),this._gpuGeometry&&this._setGeometryAttributes(this._gpuGeometry)}setParameters(A){ep(A,this.parameters,2)||(this.parameters=A,this._setPipelineNeedsUpdate("parameters"))}setInstanceCount(A){this.instanceCount=A,this.isInstanced===void 0&&A>0&&(this.isInstanced=!0),this.setNeedsRedraw("instanceCount")}setVertexCount(A){this.vertexCount=A,this.setNeedsRedraw("vertexCount")}setShaderInputs(A){this.shaderInputs=A,this._uniformStore=new Ap(this.shaderInputs.modules);for(let j of Object.keys(this.shaderInputs.modules)){let e=this._uniformStore.getManagedUniformBuffer(this.device,j);this.bindings[`${j}Uniforms`]=e}this.setNeedsRedraw("shaderInputs")}updateShaderInputs(){this._uniformStore.setUniforms(this.shaderInputs.getUniformValues()),this.setBindings(this.shaderInputs.getBindings()),this.setNeedsRedraw("shaderInputs")}setBindings(A){Object.assign(this.bindings,A),this.setNeedsRedraw("bindings")}setTransformFeedback(A){this.transformFeedback=A,this.setNeedsRedraw("transformFeedback")}setIndexBuffer(A){this.vertexArray.setIndexBuffer(A),this.setNeedsRedraw("indexBuffer")}setAttributes(A,j){A.indices&&mA.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();for(let[e,r]of Object.entries(A)){let n=this.bufferLayout.find(l=>qR(l).includes(e));if(!n){mA.warn(`Model(${this.id}): Missing layout for buffer "${e}".`)();continue}let i=qR(n),o=!1;for(let l of i){let c=this._attributeInfos[l];c&&(this.vertexArray.setBuffer(c.location,r),o=!0)}!o&&!(j?.disableWarnings??this.props.disableWarnings)&&mA.warn(`Model(${this.id}): Ignoring buffer "${r.id}" for unknown attribute "${e}"`)()}this.setNeedsRedraw("attributes")}setConstantAttributes(A,j){for(let[e,r]of Object.entries(A)){let n=this._attributeInfos[e];n?this.vertexArray.setConstantWebGL(n.location,r):(j?.disableWarnings??this.props.disableWarnings)||mA.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${e}"`)()}this.setNeedsRedraw("constants")}setUniforms(A){G7(A)||(this.pipeline.setUniformsWebGL(A),Object.assign(this.uniforms,A)),this.setNeedsRedraw("uniforms")}updateModuleSettings(A){let{bindings:j,uniforms:e}=pc(this._getModuleUniforms(A));Object.assign(this.bindings,j),Object.assign(this.uniforms,e),this.setNeedsRedraw("moduleSettings")}_getBindingsUpdateTimestamp(){let A=0;for(let j of Object.values(this.bindings))j instanceof Bc?A=Math.max(A,j.texture.updateTimestamp):j instanceof Aj||j instanceof Ne?A=Math.max(A,j.updateTimestamp):j instanceof hc||(A=Math.max(A,j.buffer.updateTimestamp));return A}_setGeometryAttributes(A){let j={...A.attributes};for(let[e]of Object.entries(j))!this.pipeline.shaderLayout.attributes.find(r=>r.name===e)&&e!=="positions"&&delete j[e];this.vertexCount=A.vertexCount,this.setIndexBuffer(A.indices||null),this.setAttributes(A.attributes,{disableWarnings:!0}),this.setAttributes(j,{disableWarnings:this.props.disableWarnings}),this.setNeedsRedraw("geometry attributes")}_setPipelineNeedsUpdate(A){this._pipelineNeedsUpdate||(this._pipelineNeedsUpdate=A),this.setNeedsRedraw(A)}_updatePipeline(){if(this._pipelineNeedsUpdate){let A=null,j=null;this.pipeline&&(mA.log(1,`Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)(),A=this.pipeline.vs,j=this.pipeline.fs),this._pipelineNeedsUpdate=!1;let e=this.shaderFactory.createShader({id:`${this.id}-vertex`,stage:"vertex",source:this.source||this.vs,debug:this.props.debugShaders}),r=null;this.source?r=e:this.fs&&(r=this.shaderFactory.createShader({id:`${this.id}-fragment`,stage:"fragment",source:this.source||this.fs,debug:this.props.debugShaders})),this.pipeline=this.pipelineFactory.createRenderPipeline({...this.props,bufferLayout:this.bufferLayout,topology:this.topology,parameters:this.parameters,vs:e,fs:r}),this._attributeInfos=_E(this.pipeline.shaderLayout,this.bufferLayout),A&&this.shaderFactory.release(A),j&&this.shaderFactory.release(j)}return this.pipeline}_logDrawCallStart(){let A=mA.level>3?0:EnA;mA.level<2||Date.now()-this._lastLogTime>> DRAWING MODEL ${this.id}`,{collapsed:mA.level<=2})())}_logDrawCallEnd(){if(this._logOpen){let A=yR(this.pipeline.shaderLayout,this.id);mA.table(GB,A)();let j=this.shaderInputs.getDebugTable();for(let[r,n]of Object.entries(this.uniforms))j[r]={value:n};mA.table(GB,j)();let e=this._getAttributeDebugTable();mA.table(GB,this._attributeInfos)(),mA.table(GB,e)(),mA.groupEnd(GB)(),this._logOpen=!1}}_logFramebuffer(A){let j=mA.get("framebuffer");if(this._drawCount++,!j||this._drawCount++>3&&this._drawCount%60)return;let e=A.props.framebuffer;e&&vR(e,{id:e.id,minimap:!0})}_getAttributeDebugTable(){let A={};for(let[j,e]of Object.entries(this._attributeInfos))A[e.location]={name:j,type:e.shaderType,values:this._getBufferOrConstantValues(this.vertexArray.attributes[e.location],e.bufferDataType)};if(this.vertexArray.indexBuffer){let{indexBuffer:j}=this.vertexArray,e=j.indexType==="uint32"?new Uint32Array(j.debugData):new Uint16Array(j.debugData);A.indices={name:"indices",type:j.indexType,values:e.toString()}}return A}_getBufferOrConstantValues(A,j){let e=tp(j);return(A instanceof Aj?new e(A.debugData):A).toString()}};I(E$,"defaultProps",{...rs.defaultProps,source:null,vs:null,fs:null,id:"unnamed",handle:void 0,userData:{},defines:{},modules:[],moduleSettings:void 0,geometry:null,indexBuffer:null,attributes:{},constantAttributes:{},varyings:[],isInstanced:void 0,instanceCount:0,vertexCount:0,shaderInputs:void 0,pipelineFactory:void 0,shaderFactory:void 0,transformFeedback:void 0,shaderAssembler:uc.getDefaultShaderAssembler(),debugShaders:void 0,disableWarnings:void 0});var ke=E$;function _R(t,A){let j=[...t];for(let e of A){let r=j.findIndex(n=>n.name===e.name);r<0?j.push(e):j[r]=e}return j}function $nA(t){return{type:t.type,shaderLanguage:t.info.shadingLanguage,shaderLanguageVersion:t.info.shadingLanguageVersion,gpu:t.info.gpu,features:t.features}}function qR(t){return t.attributes?t.attributes?.map(A=>A.attribute):[t.name]}var S7=class t{constructor(A,j=ke.defaultProps){I(this,"device");I(this,"model");I(this,"transformFeedback");Ot(t.isSupported(A),"BufferTransform not yet implemented on WebGPU"),this.device=A,this.model=new ke(this.device,{id:j.id||"buffer-transform-model",fs:j.fs||zG(),topology:j.topology||"point-list",...j}),this.transformFeedback=this.device.createTransformFeedback({layout:this.model.pipeline.shaderLayout,buffers:j.feedbackBuffers}),this.model.setTransformFeedback(this.transformFeedback),Object.seal(this)}static isSupported(A){return A?.info?.type==="webgl"}destroy(){this.model&&this.model.destroy()}delete(){this.destroy()}run(A){let j=this.device.beginRenderPass(A);this.model.draw(j),j.end()}update(...A){console.warn("TextureTransform#update() not implemented")}getBuffer(A){return this.transformFeedback.getBuffer(A)}readAsync(A){let j=this.getBuffer(A);if(j instanceof Aj)return j.readAsync();let{buffer:e,byteOffset:r=0,byteLength:n=e.byteLength}=j;return e.readAsync(r,n)}};var ln=class{constructor(A){I(this,"id");I(this,"topology");I(this,"vertexCount");I(this,"indices");I(this,"attributes");I(this,"userData",{});let{attributes:j={},indices:e=null,vertexCount:r=null}=A;this.id=A.id||Pn("geometry"),this.topology=A.topology,e&&(this.indices=ArrayBuffer.isView(e)?{value:e,size:1}:e),this.attributes={};for(let[n,i]of Object.entries(j)){let o=ArrayBuffer.isView(i)?{value:i}:i;Ot(ArrayBuffer.isView(o.value),`${this._print(n)}: must be typed array or object with value as typed array`),(n==="POSITION"||n==="positions")&&!o.size&&(o.size=3),n==="indices"?(Ot(!this.indices),this.indices=o):this.attributes[n]=o}this.indices&&this.indices.isIndexed!==void 0&&(this.indices=Object.assign({},this.indices),delete this.indices.isIndexed),this.vertexCount=r||this._calculateVertexCount(this.attributes,this.indices)}getVertexCount(){return this.vertexCount}getAttributes(){return this.indices?{indices:this.indices,...this.attributes}:this.attributes}_print(A){return`Geometry ${this.id} attribute ${A}`}_setAttributes(A,j){return this}_calculateVertexCount(A,j){if(j)return j.value.length;let e=1/0;for(let r of Object.values(A)){let{value:n,size:i,constant:o}=r;!o&&n&&i>=1&&(e=Math.min(e,n.length/i))}return Ot(Number.isFinite(e)),e}};var xnA={blendColorOperation:"add",blendColorSrcFactor:"one",blendColorDstFactor:"zero",blendAlphaOperation:"add",blendAlphaSrcFactor:"constant-alpha",blendAlphaDstFactor:"zero"},yc=class extends wa{constructor(){super(...arguments),this._colorEncoderState=null}render(A){return"pickingFBO"in A?this._drawPickingBuffer(A):super.render(A)}_drawPickingBuffer({layers:A,layerFilter:j,views:e,viewports:r,onViewportActive:n,pickingFBO:i,deviceRect:{x:o,y:l,width:c,height:B},cullRect:h,effects:d,pass:k="picking",pickZ:g,moduleParameters:E}){this.pickZ=g;let m=this._resetColorEncoder(g),y=[o,l,c,B],b=super.render({target:i,layers:A,layerFilter:j,views:e,viewports:r,onViewportActive:n,cullRect:h,effects:d?.filter(_=>_.useInPicking),pass:k,isPicking:!0,moduleParameters:E,clearColor:[0,0,0,0],colorMask:15,scissorRect:y});return this._colorEncoderState=null,{decodePickingColor:m&&vnA.bind(null,m),stats:b}}shouldDrawLayer(A){let{pickable:j,operation:e}=A.props;return j&&e.includes("draw")||e.includes("terrain")||e.includes("mask")}getModuleParameters(){return{picking:{isActive:1,isAttribute:this.pickZ},lightSources:{}}}getLayerParameters(A,j,e){let r={depthMask:!0,depthTest:!0,depthRange:[0,1],...A.props.parameters},{pickable:n,operation:i}=A.props;return!this._colorEncoderState||i.includes("terrain")?r.blend=!1:n&&i.includes("draw")&&(Object.assign(r,xnA),r.blend=!0,r.blendColor=ynA(this._colorEncoderState,A,e)),r}_resetColorEncoder(A){return this._colorEncoderState=A?null:{byLayer:new Map,byAlpha:[]},this._colorEncoderState}};function ynA(t,A,j){let{byLayer:e,byAlpha:r}=t,n,i=e.get(A);return i?(i.viewports.push(j),n=i.a):(n=e.size+1,n<=255?(i={a:n,layer:A,viewports:[j]},e.set(A,i),r[n]=i):(NA.warn("Too many pickable layers, only picking the first 255")(),n=0)),[0,0,0,n/255]}function vnA(t,A){let j=t.byAlpha[A[3]];return j&&{pickedLayer:j.layer,pickedViewports:j.viewports,pickedObjectIndex:j.layer.decodePickingColor(A)}}var R7={NO_STATE:"Awaiting state",MATCHED:"Matched. State transferred from previous layer",INITIALIZED:"Initialized",AWAITING_GC:"Discarded. Awaiting garbage collection",AWAITING_FINALIZATION:"No longer matched. Awaiting garbage collection",FINALIZED:"Finalized! Awaiting garbage collection"},bB=Symbol.for("component"),Gi=Symbol.for("propTypes"),$$=Symbol.for("deprecatedProps"),Pa=Symbol.for("asyncPropDefaults"),ls=Symbol.for("asyncPropOriginal"),mo=Symbol.for("asyncPropResolved");function Ia(t,A=()=>!0){return Array.isArray(t)?GR(t,A,[]):A(t)?[t]:[]}function GR(t,A,j){let e=-1;for(;++e0}delete(){}getData(){return this.isLoaded?this._error?Promise.reject(this._error):this._content:this._loader.then(()=>this.getData())}setData(A,j){if(A===this._data&&!j)return;this._data=A;let e=++this._loadCount,r=A;typeof A=="string"&&(r=As(A)),r instanceof Promise?(this.isLoaded=!1,this._loader=r.then(n=>{this._loadCount===e&&(this.isLoaded=!0,this._error=void 0,this._content=n)}).catch(n=>{this._loadCount===e&&(this.isLoaded=!0,this._error=n||!0)})):(this.isLoaded=!0,this._error=void 0,this._content=A);for(let n of this._subscribers)n.onChange(this.getData())}};var xp=class{constructor(A){this.protocol=A.protocol||"resource://",this._context={device:A.device,gl:A.device?.gl,resourceManager:this},this._resources={},this._consumers={},this._pruneRequest=null}contains(A){return A.startsWith(this.protocol)?!0:A in this._resources}add({resourceId:A,data:j,forceUpdate:e=!1,persistent:r=!0}){let n=this._resources[A];n?n.setData(j,e):(n=new $p(A,j,this._context),this._resources[A]=n),n.persistent=r}remove(A){let j=this._resources[A];j&&(j.delete(),delete this._resources[A])}unsubscribe({consumerId:A}){let j=this._consumers[A];if(j){for(let e in j){let r=j[e],n=this._resources[r.resourceId];n&&n.unsubscribe(r)}delete this._consumers[A],this.prune()}}subscribe({resourceId:A,onChange:j,consumerId:e,requestId:r="default"}){let{_resources:n,protocol:i}=this;A.startsWith(i)&&(A=A.replace(i,""),n[A]||this.add({resourceId:A,data:null,persistent:!1}));let o=n[A];if(this._track(e,r,o,j),o)return o.getData()}prune(){this._pruneRequest||(this._pruneRequest=setTimeout(()=>this._prune(),0))}finalize(){for(let A in this._resources)this._resources[A].delete()}_track(A,j,e,r){let n=this._consumers,i=n[A]=n[A]||{},o=i[j],l=o&&o.resourceId&&this._resources[o.resourceId];l&&(l.unsubscribe(o),this.prune()),e&&(o?(o.onChange=r,o.resourceId=e.id):o={onChange:r,resourceId:e.id},i[j]=o,e.subscribe(o))}_prune(){this._pruneRequest=null;for(let A of Object.keys(this._resources)){let j=this._resources[A];!j.persistent&&!j.inUse()&&(j.delete(),delete this._resources[A])}}};var _nA="layerManager.setLayers",qnA="layerManager.activateViewport",wB=class{constructor(A,j){this._lastRenderedLayers=[],this._needsRedraw=!1,this._needsUpdate=!1,this._nextLayers=null,this._debug=!1,this._defaultShaderModulesChanged=!1,this.activateViewport=o=>{he(qnA,this,o),o&&(this.context.viewport=o)};let{deck:e,stats:r,viewport:n,timeline:i}=j||{};this.layers=[],this.resourceManager=new xp({device:A,protocol:"deck://"}),this.context={mousePosition:null,userData:{},layerManager:this,device:A,gl:A?.gl,deck:e,shaderAssembler:Mw(),defaultShaderModules:[],renderPass:void 0,stats:r||new v6({id:"deck.gl"}),viewport:n||new go({id:"DEFAULT-INITIAL-VIEWPORT"}),timeline:i||new xc,resourceManager:this.resourceManager,onError:void 0},Object.seal(this)}finalize(){this.resourceManager.finalize();for(let A of this.layers)this._finalizeLayer(A)}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;A.clearRedrawFlags&&(this._needsRedraw=!1);for(let e of this.layers){let r=e.getNeedsRedraw(A);j=j||r}return j}needsUpdate(){return this._nextLayers&&this._nextLayers!==this._lastRenderedLayers?"layers changed":this._defaultShaderModulesChanged?"shader modules changed":this._needsUpdate}setNeedsRedraw(A){this._needsRedraw=this._needsRedraw||A}setNeedsUpdate(A){this._needsUpdate=this._needsUpdate||A}getLayers({layerIds:A}={}){return A?this.layers.filter(j=>A.find(e=>j.id.indexOf(e)===0)):this.layers}setProps(A){"debug"in A&&(this._debug=A.debug),"userData"in A&&(this.context.userData=A.userData),"layers"in A&&(this._nextLayers=A.layers),"onError"in A&&(this.context.onError=A.onError)}setLayers(A,j){he(_nA,this,j,A),this._lastRenderedLayers=A;let e=Ia(A,Boolean);for(let r of e)r.context=this.context;this._updateLayers(this.layers,e)}updateLayers(){let A=this.needsUpdate();A&&(this.setNeedsRedraw(`updating layers: ${A}`),this.setLayers(this._nextLayers||this._lastRenderedLayers,A)),this._nextLayers=null}addDefaultShaderModule(A){let{defaultShaderModules:j}=this.context;j.find(e=>e.name===A.name)||(j.push(A),this._defaultShaderModulesChanged=!0)}removeDefaultShaderModule(A){let{defaultShaderModules:j}=this.context,e=j.findIndex(r=>r.name===A.name);e>=0&&(j.splice(e,1),this._defaultShaderModulesChanged=!0)}_handleError(A,j,e){e.raiseError(j,`${A} of ${e}`)}_updateLayers(A,j){let e={};for(let i of A)e[i.id]?NA.warn(`Multiple old layers with same id ${i.id}`)():e[i.id]=i;if(this._defaultShaderModulesChanged){for(let i of A)i.setNeedsUpdate(),i.setChangeFlags({extensionsChanged:!0});this._defaultShaderModulesChanged=!1}let r=[];this._updateSublayersRecursively(j,e,r),this._finalizeOldLayers(e);let n=!1;for(let i of r)if(i.hasUniformTransition()){n=`Uniform transition in ${i}`;break}this._needsUpdate=n,this.layers=r}_updateSublayersRecursively(A,j,e){for(let r of A){r.context=this.context;let n=j[r.id];n===null&&NA.warn(`Multiple new layers with same id ${r.id}`)(),j[r.id]=null;let i=null;try{this._debug&&n!==r&&r.validateProps(),n?(this._transferLayerState(n,r),this._updateLayer(r)):this._initializeLayer(r),e.push(r),i=r.isComposite?r.getSubLayers():null}catch(o){this._handleError("matching",o,r)}i&&this._updateSublayersRecursively(i,j,e)}}_finalizeOldLayers(A){for(let j in A){let e=A[j];e&&this._finalizeLayer(e)}}_initializeLayer(A){try{A._initialize(),A.lifecycle=R7.INITIALIZED}catch(j){this._handleError("initialization",j,A)}}_transferLayerState(A,j){j._transferState(A),j.lifecycle=R7.MATCHED,j!==A&&(A.lifecycle=R7.AWAITING_GC)}_updateLayer(A){try{A._update()}catch(j){this._handleError("update",j,A)}}_finalizeLayer(A){this._needsRedraw=this._needsRedraw||`finalized ${A}`,A.lifecycle=R7.AWAITING_FINALIZATION;try{A._finalize(),A.lifecycle=R7.FINALIZED}catch(j){this._handleError("finalization",j,A)}}};function Hr(t,A,j){if(t===A)return!0;if(!j||!t||!A)return!1;if(Array.isArray(t)){if(!Array.isArray(A)||t.length!==A.length)return!1;for(let e=0;ej.containsPixel(A)):this._viewports}getViews(){let A={};return this.views.forEach(j=>{A[j.id]=j}),A}getView(A){return this.views.find(j=>j.id===A)}getViewState(A){let j=typeof A=="string"?this.getView(A):A,e=j&&this.viewState[j.getViewStateId()]||this.viewState;return j?j.filterViewState(e):e}getViewport(A){return this._viewportMap[A]}unproject(A,j){let e=this.getViewports(),r={x:A[0],y:A[1]};for(let n=e.length-1;n>=0;--n){let i=e[n];if(i.containsPixel(r)){let o=A.slice();return o[0]-=i.x,o[1]-=i.y,i.unproject(o,j)}}return null}setProps(A){A.views&&this._setViews(A.views),A.viewState&&this._setViewState(A.viewState),("width"in A||"height"in A)&&this._setSize(A.width,A.height),this._isUpdating||this._update()}_update(){this._isUpdating=!0,this._needsUpdate&&(this._needsUpdate=!1,this._rebuildViewports()),this._needsUpdate&&(this._needsUpdate=!1,this._rebuildViewports()),this._isUpdating=!1}_setSize(A,j){(A!==this.width||j!==this.height)&&(this.width=A,this.height=j,this.setNeedsUpdate("Size changed"))}_setViews(A){A=Ia(A,Boolean),this._diffViews(A,this.views)&&this.setNeedsUpdate("views changed"),this.views=A}_setViewState(A){A?(!Hr(A,this.viewState,3)&&this.setNeedsUpdate("viewState changed"),this.viewState=A):NA.warn("missing `viewState` or `initialViewState`")()}_createController(A,j){let e=j.type;return new e({timeline:this.timeline,eventManager:this._eventManager,onViewStateChange:this._eventCallbacks.onViewStateChange,onStateChange:this._eventCallbacks.onInteractionStateChange,makeViewport:n=>this.getView(A.id)?.makeViewport({viewState:n,width:this.width,height:this.height})})}_updateController(A,j,e,r){let n=A.controller;if(n&&e){let i={...j,...n,id:A.id,x:e.x,y:e.y,width:e.width,height:e.height};return(!r||r.constructor!==n.type)&&(r=this._createController(A,i)),r&&r.setProps(i),r}return null}_rebuildViewports(){let{views:A}=this,j=this.controllers;this._viewports=[],this.controllers={};let e=!1;for(let r=A.length;r--;){let n=A[r],i=this.getViewState(n),o=n.makeViewport({viewState:i,width:this.width,height:this.height}),l=j[n.id],c=!!n.controller;c&&!l&&(e=!0),(e||!c)&&l&&(l.finalize(),l=null),this.controllers[n.id]=this._updateController(n,i,o,l),o&&this._viewports.unshift(o)}for(let r in j){let n=j[r];n&&!this.controllers[r]&&n.finalize()}this._buildViewportMap()}_buildViewportMap(){this._viewportMap={},this._viewports.forEach(A=>{A.id&&(this._viewportMap[A.id]=this._viewportMap[A.id]||A)})}_diffViews(A,j){return A.length!==j.length?!0:A.some((e,r)=>!A[r].equals(j[r]))}};var GnA=/([0-9]+\.?[0-9]*)(%|px)/;function Ma(t){switch(typeof t){case"number":return{position:t,relative:!1};case"string":let A=GnA.exec(t);if(A&&A.length>=3){let j=A[2]==="%",e=parseFloat(A[1]);return{position:j?e/100:e,relative:j}}default:throw new Error(`Could not parse position string ${t}`)}}function Oa(t,A){return t.relative?Math.round(t.position*A):t.position}var cs=class{constructor(A){let{id:j,x:e=0,y:r=0,width:n="100%",height:i="100%",padding:o=null}=A;this.id=j||this.constructor.displayName||"view",this.props={...A,id:this.id},this._x=Ma(e),this._y=Ma(r),this._width=Ma(n),this._height=Ma(i),this._padding=o&&{left:Ma(o.left||0),right:Ma(o.right||0),top:Ma(o.top||0),bottom:Ma(o.bottom||0)},this.equals=this.equals.bind(this),Object.seal(this)}equals(A){return this===A?!0:this.ViewportType===A.ViewportType&&Hr(this.props,A.props,2)}makeViewport({width:A,height:j,viewState:e}){e=this.filterViewState(e);let r=this.getDimensions({width:A,height:j});return!r.height||!r.width?null:new this.ViewportType({...e,...this.props,...r})}getViewStateId(){let{viewState:A}=this.props;return typeof A=="string"?A:A?.id||this.id}filterViewState(A){if(this.props.viewState&&typeof this.props.viewState=="object"){if(!this.props.viewState.id)return this.props.viewState;let j={...A};for(let e in this.props.viewState)e!=="id"&&(j[e]=this.props.viewState[e]);return j}return A}getDimensions({width:A,height:j}){let e={x:Oa(this._x,A),y:Oa(this._y,j),width:Oa(this._width,A),height:Oa(this._height,j)};return this._padding&&(e.padding={left:Oa(this._padding.left,A),top:Oa(this._padding.top,j),right:Oa(this._padding.right,A),bottom:Oa(this._padding.bottom,j)}),e}get controller(){let A=this.props.controller;return A?A===!0?{type:this.ControllerType}:typeof A=="function"?{type:A}:{type:this.ControllerType,...A}:null}};var Eo=class{constructor(A){this._inProgress=!1,this._handle=null,this.time=0,this.settings={duration:0},this._timeline=A}get inProgress(){return this._inProgress}start(A){this.cancel(),this.settings=A,this._inProgress=!0,this.settings.onStart?.(this)}end(){this._inProgress&&(this._timeline.removeChannel(this._handle),this._handle=null,this._inProgress=!1,this.settings.onEnd?.(this))}cancel(){this._inProgress&&(this.settings.onInterrupt?.(this),this._timeline.removeChannel(this._handle),this._handle=null,this._inProgress=!1)}update(){if(!this._inProgress)return!1;if(this._handle===null){let{_timeline:A,settings:j}=this;this._handle=A.addChannel({delay:A.getTime(),duration:j.duration})}return this.time=this._timeline.getTime(this._handle),this._onUpdate(),this.settings.onUpdate?.(this),this._timeline.isFinished(this._handle)&&this.end(),!0}_onUpdate(){}};var bR=()=>{},x$={BREAK:1,SNAP_TO_END:2,IGNORE:3},bnA=t=>t,wnA=x$.BREAK,vp=class{constructor(A){this._onTransitionUpdate=j=>{let{time:e,settings:{interpolator:r,startProps:n,endProps:i,duration:o,easing:l}}=j,c=l(e/o),B=r.interpolateProps(n,i,c);this.propsInTransition=this.getControllerState({...this.props,...B}).getViewportProps(),this.onViewStateChange({viewState:this.propsInTransition,oldViewState:this.props})},this.getControllerState=A.getControllerState,this.propsInTransition=null,this.transition=new Eo(A.timeline),this.onViewStateChange=A.onViewStateChange||bR,this.onStateChange=A.onStateChange||bR}finalize(){this.transition.cancel()}getViewportInTransition(){return this.propsInTransition}processViewStateChange(A){let j=!1,e=this.props;if(this.props=A,!e||this._shouldIgnoreViewportChange(e,A))return!1;if(this._isTransitionEnabled(A)){let r=e;if(this.transition.inProgress){let{interruption:n,endProps:i}=this.transition.settings;r={...e,...n===x$.SNAP_TO_END?i:this.propsInTransition||e}}this._triggerTransition(r,A),j=!0}else this.transition.cancel();return j}updateTransition(){this.transition.update()}_isTransitionEnabled(A){let{transitionDuration:j,transitionInterpolator:e}=A;return(j>0||j==="auto")&&!!e}_isUpdateDueToCurrentTransition(A){return this.transition.inProgress&&this.propsInTransition?this.transition.settings.interpolator.arePropsEqual(A,this.propsInTransition):!1}_shouldIgnoreViewportChange(A,j){return this.transition.inProgress?this.transition.settings.interruption===x$.IGNORE||this._isUpdateDueToCurrentTransition(j):this._isTransitionEnabled(j)?j.transitionInterpolator.arePropsEqual(A,j):!0}_triggerTransition(A,j){let e=this.getControllerState(A),r=this.getControllerState(j).shortestPathFrom(e),n=j.transitionInterpolator,i=n.getDuration?n.getDuration(A,j):j.transitionDuration;if(i===0)return;let o=n.initializeProps(A,r);this.propsInTransition={};let l={duration:i,easing:j.transitionEasing||bnA,interpolator:n,interruption:j.transitionInterruption||wnA,startProps:o.start,endProps:o.end,onStart:j.onTransitionStart,onUpdate:this._onTransitionUpdate,onInterrupt:this._onTransitionEnd(j.onTransitionInterrupt),onEnd:this._onTransitionEnd(j.onTransitionEnd)};this.transition.start(l),this.onStateChange({inTransition:!0}),this.updateTransition()}_onTransitionEnd(A){return j=>{this.propsInTransition=null,this.onStateChange({inTransition:!1,isZooming:!1,isPanning:!1,isRotating:!1}),A?.(j)}}};function Xj(t,A){if(!t)throw new Error(A||"deck.gl: assertion failed.")}var FB=class{constructor(A){let{compare:j,extract:e,required:r}=A;this._propsToCompare=j,this._propsToExtract=e||j,this._requiredProps=r}arePropsEqual(A,j){for(let e of this._propsToCompare)if(!(e in A)||!(e in j)||!Bo(A[e],j[e]))return!1;return!0}initializeProps(A,j){let e={},r={};for(let n of this._propsToExtract)(n in A||n in j)&&(e[n]=A[n],r[n]=j[n]);return this._checkRequiredProps(e),this._checkRequiredProps(r),{start:e,end:r}}getDuration(A,j){return j.transitionDuration}_checkRequiredProps(A){this._requiredProps&&this._requiredProps.forEach(j=>{let e=A[j];Xj(Number.isFinite(e)||Array.isArray(e),`${j} is required for transition`)})}};var FnA=["longitude","latitude","zoom","bearing","pitch"],PnA=["longitude","latitude","zoom"],bi=class extends FB{constructor(A={}){let j=Array.isArray(A)?A:A.transitionProps,e=Array.isArray(A)?{}:A;e.transitionProps=Array.isArray(j)?{compare:j,required:j}:j||{compare:FnA,required:PnA},super(e.transitionProps),this.opts=e}initializeProps(A,j){let e=super.initializeProps(A,j),{makeViewport:r,around:n}=this.opts;if(r&&n){let i=r(A),o=r(j),l=i.unproject(n);e.start.around=n,Object.assign(e.end,{around:o.project(l),aroundPosition:l,width:j.width,height:j.height})}return e}interpolateProps(A,j,e){let r={};for(let n of this._propsToExtract)r[n]=uo(A[n]||0,j[n]||0,e);if(j.aroundPosition&&this.opts.makeViewport){let n=this.opts.makeViewport({...j,...r});Object.assign(r,n.panByPosition(j.aroundPosition,uo(A.around,j.around,e)))}return r}};var L7={transitionDuration:0},InA=300,y$=t=>1-(1-t)*(1-t),PB={WHEEL:["wheel"],PAN:["panstart","panmove","panend"],PINCH:["pinchstart","pinchmove","pinchend"],TRIPLE_PAN:["tripanstart","tripanmove","tripanend"],DOUBLE_TAP:["doubletap"],KEYBOARD:["keydown"]},vc={},us=class{constructor(A){this.state={},this._events={},this._interactionState={isDragging:!1},this._customEvents=[],this._eventStartBlocked=null,this._panMove=!1,this.invertPan=!1,this.dragMode="rotate",this.inertia=0,this.scrollZoom=!0,this.dragPan=!0,this.dragRotate=!0,this.doubleClickZoom=!0,this.touchZoom=!0,this.touchRotate=!1,this.keyboard=!0,this.transitionManager=new vp({...A,getControllerState:j=>new this.ControllerState(j),onViewStateChange:this._onTransition.bind(this),onStateChange:this._setInteractionState.bind(this)}),this.handleEvent=this.handleEvent.bind(this),this.eventManager=A.eventManager,this.onViewStateChange=A.onViewStateChange||(()=>{}),this.onStateChange=A.onStateChange||(()=>{}),this.makeViewport=A.makeViewport}set events(A){this.toggleEvents(this._customEvents,!1),this.toggleEvents(A,!0),this._customEvents=A,this.props&&this.setProps(this.props)}finalize(){for(let A in this._events)this._events[A]&&this.eventManager?.off(A,this.handleEvent);this.transitionManager.finalize()}handleEvent(A){this._controllerState=void 0;let j=this._eventStartBlocked;switch(A.type){case"panstart":return j?!1:this._onPanStart(A);case"panmove":return this._onPan(A);case"panend":return this._onPanEnd(A);case"pinchstart":return j?!1:this._onPinchStart(A);case"pinchmove":return this._onPinch(A);case"pinchend":return this._onPinchEnd(A);case"tripanstart":return j?!1:this._onTriplePanStart(A);case"tripanmove":return this._onTriplePan(A);case"tripanend":return this._onTriplePanEnd(A);case"doubletap":return this._onDoubleTap(A);case"wheel":return this._onWheel(A);case"keydown":return this._onKeyDown(A);default:return!1}}get controllerState(){return this._controllerState=this._controllerState||new this.ControllerState({makeViewport:this.makeViewport,...this.props,...this.state}),this._controllerState}getCenter(A){let{x:j,y:e}=this.props,{offsetCenter:r}=A;return[r.x-j,r.y-e]}isPointInBounds(A,j){let{width:e,height:r}=this.props;if(j&&j.handled)return!1;let n=A[0]>=0&&A[0]<=e&&A[1]>=0&&A[1]<=r;return n&&j&&j.stopPropagation(),n}isFunctionKeyPressed(A){let{srcEvent:j}=A;return!!(j.metaKey||j.altKey||j.ctrlKey||j.shiftKey)}isDragging(){return this._interactionState.isDragging||!1}blockEvents(A){let j=setTimeout(()=>{this._eventStartBlocked===j&&(this._eventStartBlocked=null)},A);this._eventStartBlocked=j}setProps(A){A.dragMode&&(this.dragMode=A.dragMode),this.props=A,"transitionInterpolator"in A||(A.transitionInterpolator=this._getTransitionProps().transitionInterpolator),this.transitionManager.processViewStateChange(A);let{inertia:j}=A;this.inertia=Number.isFinite(j)?j:j===!0?InA:0;let{scrollZoom:e=!0,dragPan:r=!0,dragRotate:n=!0,doubleClickZoom:i=!0,touchZoom:o=!0,touchRotate:l=!1,keyboard:c=!0}=A,B=!!this.onViewStateChange;this.toggleEvents(PB.WHEEL,B&&e),this.toggleEvents(PB.PAN,B),this.toggleEvents(PB.PINCH,B&&(o||l)),this.toggleEvents(PB.TRIPLE_PAN,B&&l),this.toggleEvents(PB.DOUBLE_TAP,B&&i),this.toggleEvents(PB.KEYBOARD,B&&c),this.scrollZoom=e,this.dragPan=r,this.dragRotate=n,this.doubleClickZoom=i,this.touchZoom=o,this.touchRotate=l,this.keyboard=c}updateTransition(){this.transitionManager.updateTransition()}toggleEvents(A,j){this.eventManager&&A.forEach(e=>{this._events[e]!==j&&(this._events[e]=j,j?this.eventManager.on(e,this.handleEvent):this.eventManager.off(e,this.handleEvent))})}updateViewport(A,j=null,e={}){let r={...A.getViewportProps(),...j},n=this.controllerState!==A;if(this.state=A.getState(),this._setInteractionState(e),n){let i=this.controllerState&&this.controllerState.getViewportProps();this.onViewStateChange&&this.onViewStateChange({viewState:r,interactionState:this._interactionState,oldViewState:i,viewId:this.props.id})}}_onTransition(A){this.onViewStateChange({...A,interactionState:this._interactionState,viewId:this.props.id})}_setInteractionState(A){Object.assign(this._interactionState,A),this.onStateChange(this._interactionState)}_onPanStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.isFunctionKeyPressed(A)||A.rightButton||!1;(this.invertPan||this.dragMode==="pan")&&(e=!e);let r=this.controllerState[e?"panStart":"rotateStart"]({pos:j});return this._panMove=e,this.updateViewport(r,L7,{isDragging:!0}),!0}_onPan(A){return this.isDragging()?this._panMove?this._onPanMove(A):this._onPanRotate(A):!1}_onPanEnd(A){return this.isDragging()?this._panMove?this._onPanMoveEnd(A):this._onPanRotateEnd(A):!1}_onPanMove(A){if(!this.dragPan)return!1;let j=this.getCenter(A),e=this.controllerState.pan({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isPanning:!0}),!0}_onPanMoveEnd(A){let{inertia:j}=this;if(this.dragPan&&j&&A.velocity){let e=this.getCenter(A),r=[e[0]+A.velocityX*j/2,e[1]+A.velocityY*j/2],n=this.controllerState.pan({pos:r}).panEnd();this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:y$},{isDragging:!1,isPanning:!0})}else{let e=this.controllerState.panEnd();this.updateViewport(e,null,{isDragging:!1,isPanning:!1})}return!0}_onPanRotate(A){if(!this.dragRotate)return!1;let j=this.getCenter(A),e=this.controllerState.rotate({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isRotating:!0}),!0}_onPanRotateEnd(A){let{inertia:j}=this;if(this.dragRotate&&j&&A.velocity){let e=this.getCenter(A),r=[e[0]+A.velocityX*j/2,e[1]+A.velocityY*j/2],n=this.controllerState.rotate({pos:r}).rotateEnd();this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:y$},{isDragging:!1,isRotating:!0})}else{let e=this.controllerState.rotateEnd();this.updateViewport(e,null,{isDragging:!1,isRotating:!1})}return!0}_onWheel(A){if(!this.scrollZoom)return!1;let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;A.srcEvent.preventDefault();let{speed:e=.01,smooth:r=!1}=this.scrollZoom===!0?{}:this.scrollZoom,{delta:n}=A,i=2/(1+Math.exp(-Math.abs(n*e)));n<0&&i!==0&&(i=1/i);let o=this.controllerState.zoom({pos:j,scale:i});return this.updateViewport(o,{...this._getTransitionProps({around:j}),transitionDuration:r?250:1},{isZooming:!0,isPanning:!0}),!0}_onTriplePanStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.controllerState.rotateStart({pos:j});return this.updateViewport(e,L7,{isDragging:!0}),!0}_onTriplePan(A){if(!this.touchRotate||!this.isDragging())return!1;let j=this.getCenter(A);j[0]-=A.deltaX;let e=this.controllerState.rotate({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isRotating:!0}),!0}_onTriplePanEnd(A){if(!this.isDragging())return!1;let{inertia:j}=this;if(this.touchRotate&&j&&A.velocityY){let e=this.getCenter(A),r=[e[0],e[1]+=A.velocityY*j/2],n=this.controllerState.rotate({pos:r});this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:y$},{isDragging:!1,isRotating:!0}),this.blockEvents(j)}else{let e=this.controllerState.rotateEnd();this.updateViewport(e,null,{isDragging:!1,isRotating:!1})}return!0}_onPinchStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.controllerState.zoomStart({pos:j}).rotateStart({pos:j});return vc._startPinchRotation=A.rotation,vc._lastPinchEvent=A,this.updateViewport(e,L7,{isDragging:!0}),!0}_onPinch(A){if(!this.touchZoom&&!this.touchRotate||!this.isDragging())return!1;let j=this.controllerState;if(this.touchZoom){let{scale:e}=A,r=this.getCenter(A);j=j.zoom({pos:r,scale:e})}if(this.touchRotate){let{rotation:e}=A;j=j.rotate({deltaAngleX:vc._startPinchRotation-e})}return this.updateViewport(j,L7,{isDragging:!0,isPanning:this.touchZoom,isZooming:this.touchZoom,isRotating:this.touchRotate}),vc._lastPinchEvent=A,!0}_onPinchEnd(A){if(!this.isDragging())return!1;let{inertia:j}=this,{_lastPinchEvent:e}=vc;if(this.touchZoom&&j&&e&&A.scale!==e.scale){let r=this.getCenter(A),n=this.controllerState.rotateEnd(),i=Math.log2(A.scale),o=(i-Math.log2(e.scale))/(A.deltaTime-e.deltaTime),l=Math.pow(2,i+o*j/2);n=n.zoom({pos:r,scale:l}).zoomEnd(),this.updateViewport(n,{...this._getTransitionProps({around:r}),transitionDuration:j,transitionEasing:y$},{isDragging:!1,isPanning:this.touchZoom,isZooming:this.touchZoom,isRotating:!1}),this.blockEvents(j)}else{let r=this.controllerState.zoomEnd().rotateEnd();this.updateViewport(r,null,{isDragging:!1,isPanning:!1,isZooming:!1,isRotating:!1})}return vc._startPinchRotation=null,vc._lastPinchEvent=null,!0}_onDoubleTap(A){if(!this.doubleClickZoom)return!1;let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.isFunctionKeyPressed(A),r=this.controllerState.zoom({pos:j,scale:e?.5:2});return this.updateViewport(r,this._getTransitionProps({around:j}),{isZooming:!0,isPanning:!0}),this.blockEvents(100),!0}_onKeyDown(A){if(!this.keyboard)return!1;let j=this.isFunctionKeyPressed(A),{zoomSpeed:e,moveSpeed:r,rotateSpeedX:n,rotateSpeedY:i}=this.keyboard===!0?{}:this.keyboard,{controllerState:o}=this,l,c={};switch(A.srcEvent.code){case"Minus":l=j?o.zoomOut(e).zoomOut(e):o.zoomOut(e),c.isZooming=!0;break;case"Equal":l=j?o.zoomIn(e).zoomIn(e):o.zoomIn(e),c.isZooming=!0;break;case"ArrowLeft":j?(l=o.rotateLeft(n),c.isRotating=!0):(l=o.moveLeft(r),c.isPanning=!0);break;case"ArrowRight":j?(l=o.rotateRight(n),c.isRotating=!0):(l=o.moveRight(r),c.isPanning=!0);break;case"ArrowUp":j?(l=o.rotateUp(i),c.isRotating=!0):(l=o.moveUp(r),c.isPanning=!0);break;case"ArrowDown":j?(l=o.rotateDown(i),c.isRotating=!0):(l=o.moveDown(r),c.isPanning=!0);break;default:return!1}return this.updateViewport(l,this._getTransitionProps(),c),!0}_getTransitionProps(A){let{transition:j}=this;return!j||!j.transitionInterpolator?L7:A?{...j,transitionInterpolator:new bi({...A,...j.transitionInterpolator.opts,makeViewport:this.controllerState.makeViewport})}:j}};var _c=class{constructor(A,j){this._viewportProps=this.applyConstraints(A),this._state=j}getViewportProps(){return this._viewportProps}getState(){return this._state}};var wR=5,MnA=1.2,Cw=class extends _c{constructor(A){let{width:j,height:e,latitude:r,longitude:n,zoom:i,bearing:o=0,pitch:l=0,altitude:c=1.5,position:B=[0,0,0],maxZoom:h=20,minZoom:d=0,maxPitch:k=60,minPitch:g=0,startPanLngLat:E,startZoomLngLat:m,startRotatePos:y,startBearing:b,startPitch:v,startZoom:_,normalize:w=!0}=A;Xj(Number.isFinite(n)),Xj(Number.isFinite(r)),Xj(Number.isFinite(i)),super({width:j,height:e,latitude:r,longitude:n,zoom:i,bearing:o,pitch:l,altitude:c,maxZoom:h,minZoom:d,maxPitch:k,minPitch:g,normalize:w,position:B},{startPanLngLat:E,startZoomLngLat:m,startRotatePos:y,startBearing:b,startPitch:v,startZoom:_}),this.makeViewport=A.makeViewport}panStart({pos:A}){return this._getUpdatedState({startPanLngLat:this._unproject(A)})}pan({pos:A,startPos:j}){let e=this.getState().startPanLngLat||this._unproject(j);if(!e)return this;let n=this.makeViewport(this.getViewportProps()).panByPosition(e,A);return this._getUpdatedState(n)}panEnd(){return this._getUpdatedState({startPanLngLat:null})}rotateStart({pos:A}){return this._getUpdatedState({startRotatePos:A,startBearing:this.getViewportProps().bearing,startPitch:this.getViewportProps().pitch})}rotate({pos:A,deltaAngleX:j=0,deltaAngleY:e=0}){let{startRotatePos:r,startBearing:n,startPitch:i}=this.getState();if(!r||n===void 0||i===void 0)return this;let o;return A?o=this._getNewRotation(A,r,i,n):o={bearing:n+j,pitch:i+e},this._getUpdatedState(o)}rotateEnd(){return this._getUpdatedState({startBearing:null,startPitch:null})}zoomStart({pos:A}){return this._getUpdatedState({startZoomLngLat:this._unproject(A),startZoom:this.getViewportProps().zoom})}zoom({pos:A,startPos:j,scale:e}){let{startZoom:r,startZoomLngLat:n}=this.getState();if(n||(r=this.getViewportProps().zoom,n=this._unproject(j)||this._unproject(A)),!n)return this;let{maxZoom:i,minZoom:o}=this.getViewportProps(),l=r+Math.log2(e);l=Kj(l,o,i);let c=this.makeViewport({...this.getViewportProps(),zoom:l});return this._getUpdatedState({zoom:l,...c.panByPosition(n,A)})}zoomEnd(){return this._getUpdatedState({startZoomLngLat:null,startZoom:null})}zoomIn(A=2){return this._zoomFromCenter(A)}zoomOut(A=2){return this._zoomFromCenter(1/A)}moveLeft(A=100){return this._panFromCenter([A,0])}moveRight(A=100){return this._panFromCenter([-A,0])}moveUp(A=100){return this._panFromCenter([0,A])}moveDown(A=100){return this._panFromCenter([0,-A])}rotateLeft(A=15){return this._getUpdatedState({bearing:this.getViewportProps().bearing-A})}rotateRight(A=15){return this._getUpdatedState({bearing:this.getViewportProps().bearing+A})}rotateUp(A=10){return this._getUpdatedState({pitch:this.getViewportProps().pitch+A})}rotateDown(A=10){return this._getUpdatedState({pitch:this.getViewportProps().pitch-A})}shortestPathFrom(A){let j=A.getViewportProps(),e={...this.getViewportProps()},{bearing:r,longitude:n}=e;return Math.abs(r-j.bearing)>180&&(e.bearing=r<0?r+360:r-360),Math.abs(n-j.longitude)>180&&(e.longitude=n<0?n+360:n-360),e}applyConstraints(A){let{maxZoom:j,minZoom:e,zoom:r}=A;A.zoom=Kj(r,e,j);let{maxPitch:n,minPitch:i,pitch:o}=A;A.pitch=Kj(o,i,n);let{normalize:l=!0}=A;return l&&Object.assign(A,Iw(A)),A}_zoomFromCenter(A){let{width:j,height:e}=this.getViewportProps();return this.zoom({pos:[j/2,e/2],scale:A})}_panFromCenter(A){let{width:j,height:e}=this.getViewportProps();return this.pan({startPos:[j/2,e/2],pos:[j/2+A[0],e/2+A[1]]})}_getUpdatedState(A){return new this.constructor({makeViewport:this.makeViewport,...this.getViewportProps(),...this.getState(),...A})}_unproject(A){let j=this.makeViewport(this.getViewportProps());return A&&j.unproject(A)}_getNewRotation(A,j,e,r){let n=A[0]-j[0],i=A[1]-j[1],o=A[1],l=j[1],{width:c,height:B}=this.getViewportProps(),h=n/c,d=0;i>0?Math.abs(B-l)>wR&&(d=i/(l-B)*MnA):i<0&&l>wR&&(d=1-o/l),d=Kj(d,-1,1);let{minPitch:k,maxPitch:g}=this.getViewportProps(),E=r+180*h,m=e;return d>0?m=e+d*(g-e):d<0&&(m=e-d*(k-e)),{pitch:m,bearing:E}}},IB=class extends us{constructor(){super(...arguments),this.ControllerState=Cw,this.transition={transitionDuration:300,transitionInterpolator:new bi({transitionProps:{compare:["longitude","latitude","zoom","bearing","pitch","position"],required:["longitude","latitude","zoom"]}})},this.dragMode="pan"}setProps(A){A.position=A.position||[0,0,0];let j=this.props;super.setProps(A),(!j||j.height!==A.height)&&this.updateViewport(new this.ControllerState({makeViewport:this.makeViewport,...A,...this.state}))}};var v$=class extends cs{constructor(A={}){super(A)}get ViewportType(){return Fa}get ControllerType(){return IB}};v$.displayName="MapView";var Hw=v$;var OnA=new $c;function TnA(t,A){let j=t.order??1/0,e=A.order??1/0;return j-e}var _p=class{constructor(A){this._resolvedEffects=[],this._defaultEffects=[],this.effects=[],this._context=A,this._needsRedraw="Initial render",this._setEffects([])}addDefaultEffect(A){let j=this._defaultEffects;if(!j.find(e=>e.id===A.id)){let e=j.findIndex(r=>TnA(r,A)>0);e<0?j.push(A):j.splice(e,0,A),A.setup(this._context),this._setEffects(this.effects)}}setProps(A){"effects"in A&&(Hr(A.effects,this.effects,1)||this._setEffects(A.effects))}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;return A.clearRedrawFlags&&(this._needsRedraw=!1),j}getEffects(){return this._resolvedEffects}_setEffects(A){let j={};for(let r of this.effects)j[r.id]=r;let e=[];for(let r of A){let n=j[r.id],i=r;n&&n!==r?n.setProps?(n.setProps(r.props),i=n):n.cleanup(this._context):n||r.setup(this._context),e.push(i),delete j[r.id]}for(let r in j)j[r].cleanup(this._context);this.effects=e,this._resolvedEffects=e.concat(this._defaultEffects),A.some(r=>r instanceof $c)||this._resolvedEffects.push(OnA),this._needsRedraw="effects changed"}finalize(){for(let A of this._resolvedEffects)A.cleanup(this._context);this.effects.length=0,this._resolvedEffects.length=0,this._defaultEffects.length=0}};var qp=class extends wa{shouldDrawLayer(A){let{operation:j}=A.props;return j.includes("draw")||j.includes("terrain")}};var SnA="deckRenderer.renderLayers",MB=class{constructor(A){this.device=A,this.layerFilter=null,this.drawPickingColors=!1,this.drawLayersPass=new qp(A),this.pickLayersPass=new yc(A),this.renderCount=0,this._needsRedraw="Initial render",this.renderBuffers=[],this.lastPostProcessEffect=null}setProps(A){this.layerFilter!==A.layerFilter&&(this.layerFilter=A.layerFilter,this._needsRedraw="layerFilter changed"),this.drawPickingColors!==A.drawPickingColors&&(this.drawPickingColors=A.drawPickingColors,this._needsRedraw="drawPickingColors changed")}renderLayers(A){if(!A.viewports.length)return;let j=this.drawPickingColors?this.pickLayersPass:this.drawLayersPass,e={layerFilter:this.layerFilter,isPicking:this.drawPickingColors,...A};e.effects&&this._preRender(e.effects,e);let r=this.lastPostProcessEffect?this.renderBuffers[0]:e.target;this.lastPostProcessEffect&&(e.clearColor=[0,0,0,0],e.clearCanvas=!0);let n=j.render({...e,target:r});e.effects&&this._postRender(e.effects,e),this.renderCount++,he(SnA,this,n,A)}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;return A.clearRedrawFlags&&(this._needsRedraw=!1),j}finalize(){let{renderBuffers:A}=this;for(let j of A)j.delete();A.length=0}_preRender(A,j){this.lastPostProcessEffect=null,j.preRenderStats=j.preRenderStats||{};for(let e of A)j.preRenderStats[e.id]=e.preRender(j),e.postRender&&(this.lastPostProcessEffect=e.id);this.lastPostProcessEffect&&this._resizeRenderBuffers()}_resizeRenderBuffers(){let{renderBuffers:A}=this,j=this.device.canvasContext.getDrawingBufferSize();A.length===0&&[0,1].map(e=>{let r=this.device.createTexture({sampler:{minFilter:"linear",magFilter:"linear"}});A.push(this.device.createFramebuffer({id:`deck-renderbuffer-${e}`,colorAttachments:[r]}))});for(let e of A)e.resize(j)}_postRender(A,j){let{renderBuffers:e}=this,r={...j,inputBuffer:e[0],swapBuffer:e[1]};for(let n of A)if(n.postRender){r.target=n.id===this.lastPostProcessEffect?j.target:void 0;let i=n.postRender(r);r.inputBuffer=i,r.swapBuffer=i===e[0]?e[1]:e[0]}}};var RnA={pickedColor:null,pickedObjectIndex:-1};function FR({pickedColors:t,decodePickingColor:A,deviceX:j,deviceY:e,deviceRadius:r,deviceRect:n}){let{x:i,y:o,width:l,height:c}=n,B=r*r,h=-1,d=0;for(let k=0;kB)d+=4*l;else for(let m=0;m=0){let b=m+i-j,v=b*b+E;v<=B&&(B=v,h=d)}d+=4}}if(h>=0){let k=t.slice(h,h+4),g=A(k);if(g){let E=Math.floor(h/4/l),m=h/4-E*l;return{...g,pickedColor:k,pickedX:i+m,pickedY:o+E}}NA.error("Picked non-existent layer. Is picking buffer corrupt?")()}return RnA}function PR({pickedColors:t,decodePickingColor:A}){let j=new Map;if(t){for(let e=0;e=0){let n=t.slice(e,e+4),i=n.join(",");if(!j.has(i)){let o=A(n);o?j.set(i,{...o,color:n}):NA.error("Picked non-existent layer. Is picking buffer corrupt?")()}}}return Array.from(j.values())}function Dw({pickInfo:t,viewports:A,pixelRatio:j,x:e,y:r,z:n}){let i=A[0];A.length>1&&(i=LnA(t?.pickedViewports||A,{x:e,y:r}));let o;if(i){let l=[e-i.x,r-i.y];n!==void 0&&(l[2]=n),o=i.unproject(l)}return{color:null,layer:null,viewport:i,index:-1,picked:!1,x:e,y:r,pixel:[e,r],coordinate:o,devicePixel:t&&"pickedX"in t?[t.pickedX,t.pickedY]:void 0,pixelRatio:j}}function IR(t){let{pickInfo:A,lastPickedInfo:j,mode:e,layers:r}=t,{pickedColor:n,pickedLayer:i,pickedObjectIndex:o}=A,l=i?[i]:[];if(e==="hover"){let h=j.index,d=j.layerId,k=i?i.props.id:null;if(k!==d||o!==h){if(k!==d){let g=r.find(E=>E.props.id===d);g&&l.unshift(g)}j.layerId=k,j.index=o,j.info=null}}let c=Dw(t),B=new Map;return B.set(null,c),l.forEach(h=>{let d={...c};h===i&&(d.color=n,d.index=o,d.picked=!0),d=Nw({layer:h,info:d,mode:e});let k=d.layer;h===i&&e==="hover"&&(j.info=d),B.set(k.id,d),e==="hover"&&k.updateAutoHighlight(d)}),B}function Nw({layer:t,info:A,mode:j}){for(;t&&A;){let e=A.layer||null;A.sourceLayer=e,A.layer=t,A=t.getPickingInfo({info:A,mode:j,sourceLayer:e}),t=t.parent}return A}function LnA(t,A){for(let j=t.length-1;j>=0;j--){let e=t[j];if(e.containsPixel(A))return e}return t[0]}var Gp=class{constructor(A){this._pickable=!0,this.device=A,this.pickLayersPass=new yc(A),this.lastPickedInfo={index:-1,layerId:null,info:null}}setProps(A){"layerFilter"in A&&(this.layerFilter=A.layerFilter),"_pickable"in A&&(this._pickable=A._pickable)}finalize(){this.pickingFBO&&this.pickingFBO.destroy(),this.depthFBO&&this.depthFBO.destroy()}pickObject(A){return this._pickClosestObject(A)}pickObjects(A){return this._pickVisibleObjects(A)}getLastPickedObject({x:A,y:j,layers:e,viewports:r},n=this.lastPickedInfo.info){let i=n&&n.layer&&n.layer.id,o=n&&n.viewport&&n.viewport.id,l=i?e.find(d=>d.id===i):null,c=o&&r.find(d=>d.id===o)||r[0],B=c&&c.unproject([A-c.x,j-c.y]);return{...n,...{x:A,y:j,viewport:c,coordinate:B,layer:l}}}_resizeBuffer(){if(!this.pickingFBO&&(this.pickingFBO=this.device.createFramebuffer({colorAttachments:["rgba8unorm"],depthStencilAttachment:"depth16unorm"}),this.device.isTextureFormatRenderable("rgba32float"))){let j=this.device.createFramebuffer({colorAttachments:["rgba32float"],depthStencilAttachment:"depth16unorm"});this.depthFBO=j}let{canvas:A}=this.device.getCanvasContext();this.pickingFBO?.resize({width:A.width,height:A.height}),this.depthFBO?.resize({width:A.width,height:A.height})}_getPickable(A){if(this._pickable===!1)return null;let j=A.filter(e=>this.pickLayersPass.shouldDrawLayer(e)&&!e.isComposite);return j.length?j:null}_pickClosestObject({layers:A,views:j,viewports:e,x:r,y:n,radius:i=0,depth:o=1,mode:l="query",unproject3D:c,onViewportActive:B,effects:h}){let d=this.device.canvasContext.cssToDeviceRatio(),k=this._getPickable(A);if(!k||e.length===0)return{result:[],emptyInfo:Dw({viewports:e,x:r,y:n,pixelRatio:d})};this._resizeBuffer();let g=this.device.canvasContext.cssToDevicePixels([r,n],!0),E=[g.x+Math.floor(g.width/2),g.y+Math.floor(g.height/2)],m=Math.round(i*d),{width:y,height:b}=this.pickingFBO,v=this._getPickingRect({deviceX:E[0],deviceY:E[1],deviceRadius:m,deviceWidth:y,deviceHeight:b}),_={x:r-i,y:n-i,width:i*2+1,height:i*2+1},w,x=[],S=new Set;for(let F=0;F=c);L++){let z=x[L],T={color:z.pickedColor,layer:null,index:z.pickedObjectIndex,picked:!0,x:r,y:n,pixelRatio:k};T=Nw({layer:z.pickedLayer,info:T,mode:l});let W=T.layer.id;S.has(W)||S.set(W,new Set);let G=S.get(W),jA=T.object??T.index;G.has(jA)||(G.add(jA),F.push(T))}return F}_drawAndSample({layers:A,views:j,viewports:e,onViewportActive:r,deviceRect:n,cullRect:i,effects:o,pass:l},c=!1){let B=c?this.depthFBO:this.pickingFBO,h={layers:A,layerFilter:this.layerFilter,views:j,viewports:e,onViewportActive:r,pickingFBO:B,deviceRect:n,cullRect:i,effects:o,pass:l,pickZ:c,preRenderStats:{}};for(let b of o)b.useInPicking&&(h.preRenderStats[b.id]=b.preRender(h));let{decodePickingColor:d}=this.pickLayersPass.render(h),{x:k,y:g,width:E,height:m}=n,y=new(c?Float32Array:Uint8Array)(E*m*4);return this.device.readPixelsToArrayWebGL(B,{sourceX:k,sourceY:g,sourceWidth:E,sourceHeight:m,target:y}),{pickedColors:y,decodePickingColor:d}}_getPickingRect({deviceX:A,deviceY:j,deviceRadius:e,deviceWidth:r,deviceHeight:n}){let i=Math.max(0,A-e),o=Math.max(0,j-e),l=Math.min(r,A+e+1)-i,c=Math.min(n,j+e+1)-o;return l<=0||c<=0?null:{x:i,y:o,width:l,height:c}}};var CnA={"top-left":{top:0,left:0},"top-right":{top:0,right:0},"bottom-left":{bottom:0,left:0},"bottom-right":{bottom:0,right:0},fill:{top:0,left:0,bottom:0,right:0}},HnA="top-left",MR="__root",_$=class{constructor({deck:A,parentElement:j}){this.defaultWidgets=[],this.widgets=[],this.resolvedWidgets=[],this.containers={},this.lastViewports={},this.deck=A,this.parentElement=j}getWidgets(){return this.resolvedWidgets}setProps(A){A.widgets&&!Hr(A.widgets,this.widgets,1)&&this._setWidgets(A.widgets)}finalize(){for(let A of this.getWidgets())this._remove(A);this.defaultWidgets.length=0,this.resolvedWidgets.length=0;for(let A in this.containers)this.containers[A].remove()}addDefault(A){this.defaultWidgets.find(j=>j.id===A.id)||(this._add(A),this.defaultWidgets.push(A),this._setWidgets(this.widgets))}_setWidgets(A){let j={};for(let e of this.resolvedWidgets)j[e.id]=e;this.resolvedWidgets.length=0;for(let e of this.defaultWidgets)j[e.id]=null,this.resolvedWidgets.push(e);for(let e of A){let r=j[e.id];r?r.viewId!==e.viewId||r.placement!==e.placement?(this._remove(r),this._add(e)):e!==r&&(r.setProps(e.props),e=r):this._add(e),j[e.id]=null,this.resolvedWidgets.push(e)}for(let e in j){let r=j[e];r&&this._remove(r)}this.widgets=A}_add(A){let{viewId:j=null,placement:e=HnA}=A,r=A.onAdd({deck:this.deck,viewId:j});r&&this._getContainer(j,e).append(r),A._element=r}_remove(A){A.onRemove(),A._element&&A._element.remove(),A._element=void 0}_getContainer(A,j){let e=A||MR,r=this.containers[e];r||(r=document.createElement("div"),r.style.pointerEvents="none",r.style.position="absolute",r.style.overflow="hidden",this.parentElement?.append(r),this.containers[e]=r);let n=r.querySelector(`.${j}`);return n||(n=document.createElement("div"),n.className=j,n.style.position="absolute",n.style.zIndex="2",Object.assign(n.style,CnA[j]),r.append(n)),n}_updateContainers(){let A=this.deck.width,j=this.deck.height;for(let e in this.containers){let r=this.lastViewports[e]||null,n=e===MR||r,i=this.containers[e];n?(i.style.display="block",i.style.left=`${r?r.x:0}px`,i.style.top=`${r?r.y:0}px`,i.style.width=`${r?r.width:A}px`,i.style.height=`${r?r.height:j}px`):i.style.display="none"}}onRedraw({viewports:A,layers:j}){let e=A.reduce((n,i)=>(n[i.id]=i,n),{}),{lastViewports:r}=this;for(let n of this.getWidgets()){let{viewId:i}=n;if(i){let o=e[i];o&&(n.onViewportChange&&!o.equals(r[i])&&n.onViewportChange(o),n.onRedraw?.({viewports:[o],layers:j}))}else{if(n.onViewportChange)for(let o of A)o.equals(r[o.id])||n.onViewportChange(o);n.onRedraw?.({viewports:A,layers:j})}}this.lastViewports=e,this._updateContainers()}onHover(A,j){for(let e of this.getWidgets()){let{viewId:r}=e;(!r||r===A.viewport?.id)&&e.onHover?.(A,j)}}onEvent(A,j){let e=cp[j.type];if(e)for(let r of this.getWidgets()){let{viewId:n}=r;(!n||n===A.viewport?.id)&&r[e.handler]?.(A,j)}}};var DnA={zIndex:"1",position:"absolute",pointerEvents:"none",color:"#a0a7b4",backgroundColor:"#29323c",padding:"10px",top:"0",left:"0",display:"none"},bp=class{constructor(){this.id="default-tooltip",this.placement="fill",this.props={},this.isVisible=!1}onAdd({deck:A}){let j=document.createElement("div");return j.className="deck-tooltip",Object.assign(j.style,DnA),this.deck=A,this.element=j,j}onRemove(){this.deck=void 0,this.element=void 0}setProps(){}onViewportChange(A){this.isVisible&&A.id===this.lastViewport?.id&&A!==this.lastViewport&&this.setTooltip(null)}onHover(A){let{deck:j}=this,e=j&&j.props.getTooltip;if(!e)return;let r=e(A);this.lastViewport=A.viewport,this.setTooltip(r,A.x,A.y)}setTooltip(A,j,e){let r=this.element;if(r){if(typeof A=="string")r.innerText=A;else if(A)A.text&&(r.innerText=A.text),A.html&&(r.innerHTML=A.html),A.className&&(r.className=A.className);else{this.isVisible=!1,r.style.display="none";return}this.isVisible=!0,r.style.display="block",r.style.transform=`translate(${j}px, ${e}px)`,A&&typeof A=="object"&&"style"in A&&Object.assign(r.style,A.style)}}};var C7;(function(t){t[t.DEPTH_BUFFER_BIT=256]="DEPTH_BUFFER_BIT",t[t.STENCIL_BUFFER_BIT=1024]="STENCIL_BUFFER_BIT",t[t.COLOR_BUFFER_BIT=16384]="COLOR_BUFFER_BIT",t[t.POINTS=0]="POINTS",t[t.LINES=1]="LINES",t[t.LINE_LOOP=2]="LINE_LOOP",t[t.LINE_STRIP=3]="LINE_STRIP",t[t.TRIANGLES=4]="TRIANGLES",t[t.TRIANGLE_STRIP=5]="TRIANGLE_STRIP",t[t.TRIANGLE_FAN=6]="TRIANGLE_FAN",t[t.ZERO=0]="ZERO",t[t.ONE=1]="ONE",t[t.SRC_COLOR=768]="SRC_COLOR",t[t.ONE_MINUS_SRC_COLOR=769]="ONE_MINUS_SRC_COLOR",t[t.SRC_ALPHA=770]="SRC_ALPHA",t[t.ONE_MINUS_SRC_ALPHA=771]="ONE_MINUS_SRC_ALPHA",t[t.DST_ALPHA=772]="DST_ALPHA",t[t.ONE_MINUS_DST_ALPHA=773]="ONE_MINUS_DST_ALPHA",t[t.DST_COLOR=774]="DST_COLOR",t[t.ONE_MINUS_DST_COLOR=775]="ONE_MINUS_DST_COLOR",t[t.SRC_ALPHA_SATURATE=776]="SRC_ALPHA_SATURATE",t[t.CONSTANT_COLOR=32769]="CONSTANT_COLOR",t[t.ONE_MINUS_CONSTANT_COLOR=32770]="ONE_MINUS_CONSTANT_COLOR",t[t.CONSTANT_ALPHA=32771]="CONSTANT_ALPHA",t[t.ONE_MINUS_CONSTANT_ALPHA=32772]="ONE_MINUS_CONSTANT_ALPHA",t[t.FUNC_ADD=32774]="FUNC_ADD",t[t.FUNC_SUBTRACT=32778]="FUNC_SUBTRACT",t[t.FUNC_REVERSE_SUBTRACT=32779]="FUNC_REVERSE_SUBTRACT",t[t.BLEND_EQUATION=32777]="BLEND_EQUATION",t[t.BLEND_EQUATION_RGB=32777]="BLEND_EQUATION_RGB",t[t.BLEND_EQUATION_ALPHA=34877]="BLEND_EQUATION_ALPHA",t[t.BLEND_DST_RGB=32968]="BLEND_DST_RGB",t[t.BLEND_SRC_RGB=32969]="BLEND_SRC_RGB",t[t.BLEND_DST_ALPHA=32970]="BLEND_DST_ALPHA",t[t.BLEND_SRC_ALPHA=32971]="BLEND_SRC_ALPHA",t[t.BLEND_COLOR=32773]="BLEND_COLOR",t[t.ARRAY_BUFFER_BINDING=34964]="ARRAY_BUFFER_BINDING",t[t.ELEMENT_ARRAY_BUFFER_BINDING=34965]="ELEMENT_ARRAY_BUFFER_BINDING",t[t.LINE_WIDTH=2849]="LINE_WIDTH",t[t.ALIASED_POINT_SIZE_RANGE=33901]="ALIASED_POINT_SIZE_RANGE",t[t.ALIASED_LINE_WIDTH_RANGE=33902]="ALIASED_LINE_WIDTH_RANGE",t[t.CULL_FACE_MODE=2885]="CULL_FACE_MODE",t[t.FRONT_FACE=2886]="FRONT_FACE",t[t.DEPTH_RANGE=2928]="DEPTH_RANGE",t[t.DEPTH_WRITEMASK=2930]="DEPTH_WRITEMASK",t[t.DEPTH_CLEAR_VALUE=2931]="DEPTH_CLEAR_VALUE",t[t.DEPTH_FUNC=2932]="DEPTH_FUNC",t[t.STENCIL_CLEAR_VALUE=2961]="STENCIL_CLEAR_VALUE",t[t.STENCIL_FUNC=2962]="STENCIL_FUNC",t[t.STENCIL_FAIL=2964]="STENCIL_FAIL",t[t.STENCIL_PASS_DEPTH_FAIL=2965]="STENCIL_PASS_DEPTH_FAIL",t[t.STENCIL_PASS_DEPTH_PASS=2966]="STENCIL_PASS_DEPTH_PASS",t[t.STENCIL_REF=2967]="STENCIL_REF",t[t.STENCIL_VALUE_MASK=2963]="STENCIL_VALUE_MASK",t[t.STENCIL_WRITEMASK=2968]="STENCIL_WRITEMASK",t[t.STENCIL_BACK_FUNC=34816]="STENCIL_BACK_FUNC",t[t.STENCIL_BACK_FAIL=34817]="STENCIL_BACK_FAIL",t[t.STENCIL_BACK_PASS_DEPTH_FAIL=34818]="STENCIL_BACK_PASS_DEPTH_FAIL",t[t.STENCIL_BACK_PASS_DEPTH_PASS=34819]="STENCIL_BACK_PASS_DEPTH_PASS",t[t.STENCIL_BACK_REF=36003]="STENCIL_BACK_REF",t[t.STENCIL_BACK_VALUE_MASK=36004]="STENCIL_BACK_VALUE_MASK",t[t.STENCIL_BACK_WRITEMASK=36005]="STENCIL_BACK_WRITEMASK",t[t.VIEWPORT=2978]="VIEWPORT",t[t.SCISSOR_BOX=3088]="SCISSOR_BOX",t[t.COLOR_CLEAR_VALUE=3106]="COLOR_CLEAR_VALUE",t[t.COLOR_WRITEMASK=3107]="COLOR_WRITEMASK",t[t.UNPACK_ALIGNMENT=3317]="UNPACK_ALIGNMENT",t[t.PACK_ALIGNMENT=3333]="PACK_ALIGNMENT",t[t.MAX_TEXTURE_SIZE=3379]="MAX_TEXTURE_SIZE",t[t.MAX_VIEWPORT_DIMS=3386]="MAX_VIEWPORT_DIMS",t[t.SUBPIXEL_BITS=3408]="SUBPIXEL_BITS",t[t.RED_BITS=3410]="RED_BITS",t[t.GREEN_BITS=3411]="GREEN_BITS",t[t.BLUE_BITS=3412]="BLUE_BITS",t[t.ALPHA_BITS=3413]="ALPHA_BITS",t[t.DEPTH_BITS=3414]="DEPTH_BITS",t[t.STENCIL_BITS=3415]="STENCIL_BITS",t[t.POLYGON_OFFSET_UNITS=10752]="POLYGON_OFFSET_UNITS",t[t.POLYGON_OFFSET_FACTOR=32824]="POLYGON_OFFSET_FACTOR",t[t.TEXTURE_BINDING_2D=32873]="TEXTURE_BINDING_2D",t[t.SAMPLE_BUFFERS=32936]="SAMPLE_BUFFERS",t[t.SAMPLES=32937]="SAMPLES",t[t.SAMPLE_COVERAGE_VALUE=32938]="SAMPLE_COVERAGE_VALUE",t[t.SAMPLE_COVERAGE_INVERT=32939]="SAMPLE_COVERAGE_INVERT",t[t.COMPRESSED_TEXTURE_FORMATS=34467]="COMPRESSED_TEXTURE_FORMATS",t[t.VENDOR=7936]="VENDOR",t[t.RENDERER=7937]="RENDERER",t[t.VERSION=7938]="VERSION",t[t.IMPLEMENTATION_COLOR_READ_TYPE=35738]="IMPLEMENTATION_COLOR_READ_TYPE",t[t.IMPLEMENTATION_COLOR_READ_FORMAT=35739]="IMPLEMENTATION_COLOR_READ_FORMAT",t[t.BROWSER_DEFAULT_WEBGL=37444]="BROWSER_DEFAULT_WEBGL",t[t.STATIC_DRAW=35044]="STATIC_DRAW",t[t.STREAM_DRAW=35040]="STREAM_DRAW",t[t.DYNAMIC_DRAW=35048]="DYNAMIC_DRAW",t[t.ARRAY_BUFFER=34962]="ARRAY_BUFFER",t[t.ELEMENT_ARRAY_BUFFER=34963]="ELEMENT_ARRAY_BUFFER",t[t.BUFFER_SIZE=34660]="BUFFER_SIZE",t[t.BUFFER_USAGE=34661]="BUFFER_USAGE",t[t.CURRENT_VERTEX_ATTRIB=34342]="CURRENT_VERTEX_ATTRIB",t[t.VERTEX_ATTRIB_ARRAY_ENABLED=34338]="VERTEX_ATTRIB_ARRAY_ENABLED",t[t.VERTEX_ATTRIB_ARRAY_SIZE=34339]="VERTEX_ATTRIB_ARRAY_SIZE",t[t.VERTEX_ATTRIB_ARRAY_STRIDE=34340]="VERTEX_ATTRIB_ARRAY_STRIDE",t[t.VERTEX_ATTRIB_ARRAY_TYPE=34341]="VERTEX_ATTRIB_ARRAY_TYPE",t[t.VERTEX_ATTRIB_ARRAY_NORMALIZED=34922]="VERTEX_ATTRIB_ARRAY_NORMALIZED",t[t.VERTEX_ATTRIB_ARRAY_POINTER=34373]="VERTEX_ATTRIB_ARRAY_POINTER",t[t.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=34975]="VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",t[t.CULL_FACE=2884]="CULL_FACE",t[t.FRONT=1028]="FRONT",t[t.BACK=1029]="BACK",t[t.FRONT_AND_BACK=1032]="FRONT_AND_BACK",t[t.BLEND=3042]="BLEND",t[t.DEPTH_TEST=2929]="DEPTH_TEST",t[t.DITHER=3024]="DITHER",t[t.POLYGON_OFFSET_FILL=32823]="POLYGON_OFFSET_FILL",t[t.SAMPLE_ALPHA_TO_COVERAGE=32926]="SAMPLE_ALPHA_TO_COVERAGE",t[t.SAMPLE_COVERAGE=32928]="SAMPLE_COVERAGE",t[t.SCISSOR_TEST=3089]="SCISSOR_TEST",t[t.STENCIL_TEST=2960]="STENCIL_TEST",t[t.NO_ERROR=0]="NO_ERROR",t[t.INVALID_ENUM=1280]="INVALID_ENUM",t[t.INVALID_VALUE=1281]="INVALID_VALUE",t[t.INVALID_OPERATION=1282]="INVALID_OPERATION",t[t.OUT_OF_MEMORY=1285]="OUT_OF_MEMORY",t[t.CONTEXT_LOST_WEBGL=37442]="CONTEXT_LOST_WEBGL",t[t.CW=2304]="CW",t[t.CCW=2305]="CCW",t[t.DONT_CARE=4352]="DONT_CARE",t[t.FASTEST=4353]="FASTEST",t[t.NICEST=4354]="NICEST",t[t.GENERATE_MIPMAP_HINT=33170]="GENERATE_MIPMAP_HINT",t[t.BYTE=5120]="BYTE",t[t.UNSIGNED_BYTE=5121]="UNSIGNED_BYTE",t[t.SHORT=5122]="SHORT",t[t.UNSIGNED_SHORT=5123]="UNSIGNED_SHORT",t[t.INT=5124]="INT",t[t.UNSIGNED_INT=5125]="UNSIGNED_INT",t[t.FLOAT=5126]="FLOAT",t[t.DOUBLE=5130]="DOUBLE",t[t.DEPTH_COMPONENT=6402]="DEPTH_COMPONENT",t[t.ALPHA=6406]="ALPHA",t[t.RGB=6407]="RGB",t[t.RGBA=6408]="RGBA",t[t.LUMINANCE=6409]="LUMINANCE",t[t.LUMINANCE_ALPHA=6410]="LUMINANCE_ALPHA",t[t.UNSIGNED_SHORT_4_4_4_4=32819]="UNSIGNED_SHORT_4_4_4_4",t[t.UNSIGNED_SHORT_5_5_5_1=32820]="UNSIGNED_SHORT_5_5_5_1",t[t.UNSIGNED_SHORT_5_6_5=33635]="UNSIGNED_SHORT_5_6_5",t[t.FRAGMENT_SHADER=35632]="FRAGMENT_SHADER",t[t.VERTEX_SHADER=35633]="VERTEX_SHADER",t[t.COMPILE_STATUS=35713]="COMPILE_STATUS",t[t.DELETE_STATUS=35712]="DELETE_STATUS",t[t.LINK_STATUS=35714]="LINK_STATUS",t[t.VALIDATE_STATUS=35715]="VALIDATE_STATUS",t[t.ATTACHED_SHADERS=35717]="ATTACHED_SHADERS",t[t.ACTIVE_ATTRIBUTES=35721]="ACTIVE_ATTRIBUTES",t[t.ACTIVE_UNIFORMS=35718]="ACTIVE_UNIFORMS",t[t.MAX_VERTEX_ATTRIBS=34921]="MAX_VERTEX_ATTRIBS",t[t.MAX_VERTEX_UNIFORM_VECTORS=36347]="MAX_VERTEX_UNIFORM_VECTORS",t[t.MAX_VARYING_VECTORS=36348]="MAX_VARYING_VECTORS",t[t.MAX_COMBINED_TEXTURE_IMAGE_UNITS=35661]="MAX_COMBINED_TEXTURE_IMAGE_UNITS",t[t.MAX_VERTEX_TEXTURE_IMAGE_UNITS=35660]="MAX_VERTEX_TEXTURE_IMAGE_UNITS",t[t.MAX_TEXTURE_IMAGE_UNITS=34930]="MAX_TEXTURE_IMAGE_UNITS",t[t.MAX_FRAGMENT_UNIFORM_VECTORS=36349]="MAX_FRAGMENT_UNIFORM_VECTORS",t[t.SHADER_TYPE=35663]="SHADER_TYPE",t[t.SHADING_LANGUAGE_VERSION=35724]="SHADING_LANGUAGE_VERSION",t[t.CURRENT_PROGRAM=35725]="CURRENT_PROGRAM",t[t.NEVER=512]="NEVER",t[t.LESS=513]="LESS",t[t.EQUAL=514]="EQUAL",t[t.LEQUAL=515]="LEQUAL",t[t.GREATER=516]="GREATER",t[t.NOTEQUAL=517]="NOTEQUAL",t[t.GEQUAL=518]="GEQUAL",t[t.ALWAYS=519]="ALWAYS",t[t.KEEP=7680]="KEEP",t[t.REPLACE=7681]="REPLACE",t[t.INCR=7682]="INCR",t[t.DECR=7683]="DECR",t[t.INVERT=5386]="INVERT",t[t.INCR_WRAP=34055]="INCR_WRAP",t[t.DECR_WRAP=34056]="DECR_WRAP",t[t.NEAREST=9728]="NEAREST",t[t.LINEAR=9729]="LINEAR",t[t.NEAREST_MIPMAP_NEAREST=9984]="NEAREST_MIPMAP_NEAREST",t[t.LINEAR_MIPMAP_NEAREST=9985]="LINEAR_MIPMAP_NEAREST",t[t.NEAREST_MIPMAP_LINEAR=9986]="NEAREST_MIPMAP_LINEAR",t[t.LINEAR_MIPMAP_LINEAR=9987]="LINEAR_MIPMAP_LINEAR",t[t.TEXTURE_MAG_FILTER=10240]="TEXTURE_MAG_FILTER",t[t.TEXTURE_MIN_FILTER=10241]="TEXTURE_MIN_FILTER",t[t.TEXTURE_WRAP_S=10242]="TEXTURE_WRAP_S",t[t.TEXTURE_WRAP_T=10243]="TEXTURE_WRAP_T",t[t.TEXTURE_2D=3553]="TEXTURE_2D",t[t.TEXTURE=5890]="TEXTURE",t[t.TEXTURE_CUBE_MAP=34067]="TEXTURE_CUBE_MAP",t[t.TEXTURE_BINDING_CUBE_MAP=34068]="TEXTURE_BINDING_CUBE_MAP",t[t.TEXTURE_CUBE_MAP_POSITIVE_X=34069]="TEXTURE_CUBE_MAP_POSITIVE_X",t[t.TEXTURE_CUBE_MAP_NEGATIVE_X=34070]="TEXTURE_CUBE_MAP_NEGATIVE_X",t[t.TEXTURE_CUBE_MAP_POSITIVE_Y=34071]="TEXTURE_CUBE_MAP_POSITIVE_Y",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Y=34072]="TEXTURE_CUBE_MAP_NEGATIVE_Y",t[t.TEXTURE_CUBE_MAP_POSITIVE_Z=34073]="TEXTURE_CUBE_MAP_POSITIVE_Z",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Z=34074]="TEXTURE_CUBE_MAP_NEGATIVE_Z",t[t.MAX_CUBE_MAP_TEXTURE_SIZE=34076]="MAX_CUBE_MAP_TEXTURE_SIZE",t[t.TEXTURE0=33984]="TEXTURE0",t[t.ACTIVE_TEXTURE=34016]="ACTIVE_TEXTURE",t[t.REPEAT=10497]="REPEAT",t[t.CLAMP_TO_EDGE=33071]="CLAMP_TO_EDGE",t[t.MIRRORED_REPEAT=33648]="MIRRORED_REPEAT",t[t.TEXTURE_WIDTH=4096]="TEXTURE_WIDTH",t[t.TEXTURE_HEIGHT=4097]="TEXTURE_HEIGHT",t[t.FLOAT_VEC2=35664]="FLOAT_VEC2",t[t.FLOAT_VEC3=35665]="FLOAT_VEC3",t[t.FLOAT_VEC4=35666]="FLOAT_VEC4",t[t.INT_VEC2=35667]="INT_VEC2",t[t.INT_VEC3=35668]="INT_VEC3",t[t.INT_VEC4=35669]="INT_VEC4",t[t.BOOL=35670]="BOOL",t[t.BOOL_VEC2=35671]="BOOL_VEC2",t[t.BOOL_VEC3=35672]="BOOL_VEC3",t[t.BOOL_VEC4=35673]="BOOL_VEC4",t[t.FLOAT_MAT2=35674]="FLOAT_MAT2",t[t.FLOAT_MAT3=35675]="FLOAT_MAT3",t[t.FLOAT_MAT4=35676]="FLOAT_MAT4",t[t.SAMPLER_2D=35678]="SAMPLER_2D",t[t.SAMPLER_CUBE=35680]="SAMPLER_CUBE",t[t.LOW_FLOAT=36336]="LOW_FLOAT",t[t.MEDIUM_FLOAT=36337]="MEDIUM_FLOAT",t[t.HIGH_FLOAT=36338]="HIGH_FLOAT",t[t.LOW_INT=36339]="LOW_INT",t[t.MEDIUM_INT=36340]="MEDIUM_INT",t[t.HIGH_INT=36341]="HIGH_INT",t[t.FRAMEBUFFER=36160]="FRAMEBUFFER",t[t.RENDERBUFFER=36161]="RENDERBUFFER",t[t.RGBA4=32854]="RGBA4",t[t.RGB5_A1=32855]="RGB5_A1",t[t.RGB565=36194]="RGB565",t[t.DEPTH_COMPONENT16=33189]="DEPTH_COMPONENT16",t[t.STENCIL_INDEX=6401]="STENCIL_INDEX",t[t.STENCIL_INDEX8=36168]="STENCIL_INDEX8",t[t.DEPTH_STENCIL=34041]="DEPTH_STENCIL",t[t.RENDERBUFFER_WIDTH=36162]="RENDERBUFFER_WIDTH",t[t.RENDERBUFFER_HEIGHT=36163]="RENDERBUFFER_HEIGHT",t[t.RENDERBUFFER_INTERNAL_FORMAT=36164]="RENDERBUFFER_INTERNAL_FORMAT",t[t.RENDERBUFFER_RED_SIZE=36176]="RENDERBUFFER_RED_SIZE",t[t.RENDERBUFFER_GREEN_SIZE=36177]="RENDERBUFFER_GREEN_SIZE",t[t.RENDERBUFFER_BLUE_SIZE=36178]="RENDERBUFFER_BLUE_SIZE",t[t.RENDERBUFFER_ALPHA_SIZE=36179]="RENDERBUFFER_ALPHA_SIZE",t[t.RENDERBUFFER_DEPTH_SIZE=36180]="RENDERBUFFER_DEPTH_SIZE",t[t.RENDERBUFFER_STENCIL_SIZE=36181]="RENDERBUFFER_STENCIL_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=36048]="FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",t[t.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=36049]="FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=36050]="FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=36051]="FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",t[t.COLOR_ATTACHMENT0=36064]="COLOR_ATTACHMENT0",t[t.DEPTH_ATTACHMENT=36096]="DEPTH_ATTACHMENT",t[t.STENCIL_ATTACHMENT=36128]="STENCIL_ATTACHMENT",t[t.DEPTH_STENCIL_ATTACHMENT=33306]="DEPTH_STENCIL_ATTACHMENT",t[t.NONE=0]="NONE",t[t.FRAMEBUFFER_COMPLETE=36053]="FRAMEBUFFER_COMPLETE",t[t.FRAMEBUFFER_INCOMPLETE_ATTACHMENT=36054]="FRAMEBUFFER_INCOMPLETE_ATTACHMENT",t[t.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=36055]="FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",t[t.FRAMEBUFFER_INCOMPLETE_DIMENSIONS=36057]="FRAMEBUFFER_INCOMPLETE_DIMENSIONS",t[t.FRAMEBUFFER_UNSUPPORTED=36061]="FRAMEBUFFER_UNSUPPORTED",t[t.FRAMEBUFFER_BINDING=36006]="FRAMEBUFFER_BINDING",t[t.RENDERBUFFER_BINDING=36007]="RENDERBUFFER_BINDING",t[t.READ_FRAMEBUFFER=36008]="READ_FRAMEBUFFER",t[t.DRAW_FRAMEBUFFER=36009]="DRAW_FRAMEBUFFER",t[t.MAX_RENDERBUFFER_SIZE=34024]="MAX_RENDERBUFFER_SIZE",t[t.INVALID_FRAMEBUFFER_OPERATION=1286]="INVALID_FRAMEBUFFER_OPERATION",t[t.UNPACK_FLIP_Y_WEBGL=37440]="UNPACK_FLIP_Y_WEBGL",t[t.UNPACK_PREMULTIPLY_ALPHA_WEBGL=37441]="UNPACK_PREMULTIPLY_ALPHA_WEBGL",t[t.UNPACK_COLORSPACE_CONVERSION_WEBGL=37443]="UNPACK_COLORSPACE_CONVERSION_WEBGL",t[t.READ_BUFFER=3074]="READ_BUFFER",t[t.UNPACK_ROW_LENGTH=3314]="UNPACK_ROW_LENGTH",t[t.UNPACK_SKIP_ROWS=3315]="UNPACK_SKIP_ROWS",t[t.UNPACK_SKIP_PIXELS=3316]="UNPACK_SKIP_PIXELS",t[t.PACK_ROW_LENGTH=3330]="PACK_ROW_LENGTH",t[t.PACK_SKIP_ROWS=3331]="PACK_SKIP_ROWS",t[t.PACK_SKIP_PIXELS=3332]="PACK_SKIP_PIXELS",t[t.TEXTURE_BINDING_3D=32874]="TEXTURE_BINDING_3D",t[t.UNPACK_SKIP_IMAGES=32877]="UNPACK_SKIP_IMAGES",t[t.UNPACK_IMAGE_HEIGHT=32878]="UNPACK_IMAGE_HEIGHT",t[t.MAX_3D_TEXTURE_SIZE=32883]="MAX_3D_TEXTURE_SIZE",t[t.MAX_ELEMENTS_VERTICES=33e3]="MAX_ELEMENTS_VERTICES",t[t.MAX_ELEMENTS_INDICES=33001]="MAX_ELEMENTS_INDICES",t[t.MAX_TEXTURE_LOD_BIAS=34045]="MAX_TEXTURE_LOD_BIAS",t[t.MAX_FRAGMENT_UNIFORM_COMPONENTS=35657]="MAX_FRAGMENT_UNIFORM_COMPONENTS",t[t.MAX_VERTEX_UNIFORM_COMPONENTS=35658]="MAX_VERTEX_UNIFORM_COMPONENTS",t[t.MAX_ARRAY_TEXTURE_LAYERS=35071]="MAX_ARRAY_TEXTURE_LAYERS",t[t.MIN_PROGRAM_TEXEL_OFFSET=35076]="MIN_PROGRAM_TEXEL_OFFSET",t[t.MAX_PROGRAM_TEXEL_OFFSET=35077]="MAX_PROGRAM_TEXEL_OFFSET",t[t.MAX_VARYING_COMPONENTS=35659]="MAX_VARYING_COMPONENTS",t[t.FRAGMENT_SHADER_DERIVATIVE_HINT=35723]="FRAGMENT_SHADER_DERIVATIVE_HINT",t[t.RASTERIZER_DISCARD=35977]="RASTERIZER_DISCARD",t[t.VERTEX_ARRAY_BINDING=34229]="VERTEX_ARRAY_BINDING",t[t.MAX_VERTEX_OUTPUT_COMPONENTS=37154]="MAX_VERTEX_OUTPUT_COMPONENTS",t[t.MAX_FRAGMENT_INPUT_COMPONENTS=37157]="MAX_FRAGMENT_INPUT_COMPONENTS",t[t.MAX_SERVER_WAIT_TIMEOUT=37137]="MAX_SERVER_WAIT_TIMEOUT",t[t.MAX_ELEMENT_INDEX=36203]="MAX_ELEMENT_INDEX",t[t.RED=6403]="RED",t[t.RGB8=32849]="RGB8",t[t.RGBA8=32856]="RGBA8",t[t.RGB10_A2=32857]="RGB10_A2",t[t.TEXTURE_3D=32879]="TEXTURE_3D",t[t.TEXTURE_WRAP_R=32882]="TEXTURE_WRAP_R",t[t.TEXTURE_MIN_LOD=33082]="TEXTURE_MIN_LOD",t[t.TEXTURE_MAX_LOD=33083]="TEXTURE_MAX_LOD",t[t.TEXTURE_BASE_LEVEL=33084]="TEXTURE_BASE_LEVEL",t[t.TEXTURE_MAX_LEVEL=33085]="TEXTURE_MAX_LEVEL",t[t.TEXTURE_COMPARE_MODE=34892]="TEXTURE_COMPARE_MODE",t[t.TEXTURE_COMPARE_FUNC=34893]="TEXTURE_COMPARE_FUNC",t[t.SRGB=35904]="SRGB",t[t.SRGB8=35905]="SRGB8",t[t.SRGB8_ALPHA8=35907]="SRGB8_ALPHA8",t[t.COMPARE_REF_TO_TEXTURE=34894]="COMPARE_REF_TO_TEXTURE",t[t.RGBA32F=34836]="RGBA32F",t[t.RGB32F=34837]="RGB32F",t[t.RGBA16F=34842]="RGBA16F",t[t.RGB16F=34843]="RGB16F",t[t.TEXTURE_2D_ARRAY=35866]="TEXTURE_2D_ARRAY",t[t.TEXTURE_BINDING_2D_ARRAY=35869]="TEXTURE_BINDING_2D_ARRAY",t[t.R11F_G11F_B10F=35898]="R11F_G11F_B10F",t[t.RGB9_E5=35901]="RGB9_E5",t[t.RGBA32UI=36208]="RGBA32UI",t[t.RGB32UI=36209]="RGB32UI",t[t.RGBA16UI=36214]="RGBA16UI",t[t.RGB16UI=36215]="RGB16UI",t[t.RGBA8UI=36220]="RGBA8UI",t[t.RGB8UI=36221]="RGB8UI",t[t.RGBA32I=36226]="RGBA32I",t[t.RGB32I=36227]="RGB32I",t[t.RGBA16I=36232]="RGBA16I",t[t.RGB16I=36233]="RGB16I",t[t.RGBA8I=36238]="RGBA8I",t[t.RGB8I=36239]="RGB8I",t[t.RED_INTEGER=36244]="RED_INTEGER",t[t.RGB_INTEGER=36248]="RGB_INTEGER",t[t.RGBA_INTEGER=36249]="RGBA_INTEGER",t[t.R8=33321]="R8",t[t.RG8=33323]="RG8",t[t.R16F=33325]="R16F",t[t.R32F=33326]="R32F",t[t.RG16F=33327]="RG16F",t[t.RG32F=33328]="RG32F",t[t.R8I=33329]="R8I",t[t.R8UI=33330]="R8UI",t[t.R16I=33331]="R16I",t[t.R16UI=33332]="R16UI",t[t.R32I=33333]="R32I",t[t.R32UI=33334]="R32UI",t[t.RG8I=33335]="RG8I",t[t.RG8UI=33336]="RG8UI",t[t.RG16I=33337]="RG16I",t[t.RG16UI=33338]="RG16UI",t[t.RG32I=33339]="RG32I",t[t.RG32UI=33340]="RG32UI",t[t.R8_SNORM=36756]="R8_SNORM",t[t.RG8_SNORM=36757]="RG8_SNORM",t[t.RGB8_SNORM=36758]="RGB8_SNORM",t[t.RGBA8_SNORM=36759]="RGBA8_SNORM",t[t.RGB10_A2UI=36975]="RGB10_A2UI",t[t.TEXTURE_IMMUTABLE_FORMAT=37167]="TEXTURE_IMMUTABLE_FORMAT",t[t.TEXTURE_IMMUTABLE_LEVELS=33503]="TEXTURE_IMMUTABLE_LEVELS",t[t.UNSIGNED_INT_2_10_10_10_REV=33640]="UNSIGNED_INT_2_10_10_10_REV",t[t.UNSIGNED_INT_10F_11F_11F_REV=35899]="UNSIGNED_INT_10F_11F_11F_REV",t[t.UNSIGNED_INT_5_9_9_9_REV=35902]="UNSIGNED_INT_5_9_9_9_REV",t[t.FLOAT_32_UNSIGNED_INT_24_8_REV=36269]="FLOAT_32_UNSIGNED_INT_24_8_REV",t[t.UNSIGNED_INT_24_8=34042]="UNSIGNED_INT_24_8",t[t.HALF_FLOAT=5131]="HALF_FLOAT",t[t.RG=33319]="RG",t[t.RG_INTEGER=33320]="RG_INTEGER",t[t.INT_2_10_10_10_REV=36255]="INT_2_10_10_10_REV",t[t.CURRENT_QUERY=34917]="CURRENT_QUERY",t[t.QUERY_RESULT=34918]="QUERY_RESULT",t[t.QUERY_RESULT_AVAILABLE=34919]="QUERY_RESULT_AVAILABLE",t[t.ANY_SAMPLES_PASSED=35887]="ANY_SAMPLES_PASSED",t[t.ANY_SAMPLES_PASSED_CONSERVATIVE=36202]="ANY_SAMPLES_PASSED_CONSERVATIVE",t[t.MAX_DRAW_BUFFERS=34852]="MAX_DRAW_BUFFERS",t[t.DRAW_BUFFER0=34853]="DRAW_BUFFER0",t[t.DRAW_BUFFER1=34854]="DRAW_BUFFER1",t[t.DRAW_BUFFER2=34855]="DRAW_BUFFER2",t[t.DRAW_BUFFER3=34856]="DRAW_BUFFER3",t[t.DRAW_BUFFER4=34857]="DRAW_BUFFER4",t[t.DRAW_BUFFER5=34858]="DRAW_BUFFER5",t[t.DRAW_BUFFER6=34859]="DRAW_BUFFER6",t[t.DRAW_BUFFER7=34860]="DRAW_BUFFER7",t[t.DRAW_BUFFER8=34861]="DRAW_BUFFER8",t[t.DRAW_BUFFER9=34862]="DRAW_BUFFER9",t[t.DRAW_BUFFER10=34863]="DRAW_BUFFER10",t[t.DRAW_BUFFER11=34864]="DRAW_BUFFER11",t[t.DRAW_BUFFER12=34865]="DRAW_BUFFER12",t[t.DRAW_BUFFER13=34866]="DRAW_BUFFER13",t[t.DRAW_BUFFER14=34867]="DRAW_BUFFER14",t[t.DRAW_BUFFER15=34868]="DRAW_BUFFER15",t[t.MAX_COLOR_ATTACHMENTS=36063]="MAX_COLOR_ATTACHMENTS",t[t.COLOR_ATTACHMENT1=36065]="COLOR_ATTACHMENT1",t[t.COLOR_ATTACHMENT2=36066]="COLOR_ATTACHMENT2",t[t.COLOR_ATTACHMENT3=36067]="COLOR_ATTACHMENT3",t[t.COLOR_ATTACHMENT4=36068]="COLOR_ATTACHMENT4",t[t.COLOR_ATTACHMENT5=36069]="COLOR_ATTACHMENT5",t[t.COLOR_ATTACHMENT6=36070]="COLOR_ATTACHMENT6",t[t.COLOR_ATTACHMENT7=36071]="COLOR_ATTACHMENT7",t[t.COLOR_ATTACHMENT8=36072]="COLOR_ATTACHMENT8",t[t.COLOR_ATTACHMENT9=36073]="COLOR_ATTACHMENT9",t[t.COLOR_ATTACHMENT10=36074]="COLOR_ATTACHMENT10",t[t.COLOR_ATTACHMENT11=36075]="COLOR_ATTACHMENT11",t[t.COLOR_ATTACHMENT12=36076]="COLOR_ATTACHMENT12",t[t.COLOR_ATTACHMENT13=36077]="COLOR_ATTACHMENT13",t[t.COLOR_ATTACHMENT14=36078]="COLOR_ATTACHMENT14",t[t.COLOR_ATTACHMENT15=36079]="COLOR_ATTACHMENT15",t[t.SAMPLER_3D=35679]="SAMPLER_3D",t[t.SAMPLER_2D_SHADOW=35682]="SAMPLER_2D_SHADOW",t[t.SAMPLER_2D_ARRAY=36289]="SAMPLER_2D_ARRAY",t[t.SAMPLER_2D_ARRAY_SHADOW=36292]="SAMPLER_2D_ARRAY_SHADOW",t[t.SAMPLER_CUBE_SHADOW=36293]="SAMPLER_CUBE_SHADOW",t[t.INT_SAMPLER_2D=36298]="INT_SAMPLER_2D",t[t.INT_SAMPLER_3D=36299]="INT_SAMPLER_3D",t[t.INT_SAMPLER_CUBE=36300]="INT_SAMPLER_CUBE",t[t.INT_SAMPLER_2D_ARRAY=36303]="INT_SAMPLER_2D_ARRAY",t[t.UNSIGNED_INT_SAMPLER_2D=36306]="UNSIGNED_INT_SAMPLER_2D",t[t.UNSIGNED_INT_SAMPLER_3D=36307]="UNSIGNED_INT_SAMPLER_3D",t[t.UNSIGNED_INT_SAMPLER_CUBE=36308]="UNSIGNED_INT_SAMPLER_CUBE",t[t.UNSIGNED_INT_SAMPLER_2D_ARRAY=36311]="UNSIGNED_INT_SAMPLER_2D_ARRAY",t[t.MAX_SAMPLES=36183]="MAX_SAMPLES",t[t.SAMPLER_BINDING=35097]="SAMPLER_BINDING",t[t.PIXEL_PACK_BUFFER=35051]="PIXEL_PACK_BUFFER",t[t.PIXEL_UNPACK_BUFFER=35052]="PIXEL_UNPACK_BUFFER",t[t.PIXEL_PACK_BUFFER_BINDING=35053]="PIXEL_PACK_BUFFER_BINDING",t[t.PIXEL_UNPACK_BUFFER_BINDING=35055]="PIXEL_UNPACK_BUFFER_BINDING",t[t.COPY_READ_BUFFER=36662]="COPY_READ_BUFFER",t[t.COPY_WRITE_BUFFER=36663]="COPY_WRITE_BUFFER",t[t.COPY_READ_BUFFER_BINDING=36662]="COPY_READ_BUFFER_BINDING",t[t.COPY_WRITE_BUFFER_BINDING=36663]="COPY_WRITE_BUFFER_BINDING",t[t.FLOAT_MAT2x3=35685]="FLOAT_MAT2x3",t[t.FLOAT_MAT2x4=35686]="FLOAT_MAT2x4",t[t.FLOAT_MAT3x2=35687]="FLOAT_MAT3x2",t[t.FLOAT_MAT3x4=35688]="FLOAT_MAT3x4",t[t.FLOAT_MAT4x2=35689]="FLOAT_MAT4x2",t[t.FLOAT_MAT4x3=35690]="FLOAT_MAT4x3",t[t.UNSIGNED_INT_VEC2=36294]="UNSIGNED_INT_VEC2",t[t.UNSIGNED_INT_VEC3=36295]="UNSIGNED_INT_VEC3",t[t.UNSIGNED_INT_VEC4=36296]="UNSIGNED_INT_VEC4",t[t.UNSIGNED_NORMALIZED=35863]="UNSIGNED_NORMALIZED",t[t.SIGNED_NORMALIZED=36764]="SIGNED_NORMALIZED",t[t.VERTEX_ATTRIB_ARRAY_INTEGER=35069]="VERTEX_ATTRIB_ARRAY_INTEGER",t[t.VERTEX_ATTRIB_ARRAY_DIVISOR=35070]="VERTEX_ATTRIB_ARRAY_DIVISOR",t[t.TRANSFORM_FEEDBACK_BUFFER_MODE=35967]="TRANSFORM_FEEDBACK_BUFFER_MODE",t[t.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=35968]="MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",t[t.TRANSFORM_FEEDBACK_VARYINGS=35971]="TRANSFORM_FEEDBACK_VARYINGS",t[t.TRANSFORM_FEEDBACK_BUFFER_START=35972]="TRANSFORM_FEEDBACK_BUFFER_START",t[t.TRANSFORM_FEEDBACK_BUFFER_SIZE=35973]="TRANSFORM_FEEDBACK_BUFFER_SIZE",t[t.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=35976]="TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN",t[t.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=35978]="MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",t[t.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=35979]="MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",t[t.INTERLEAVED_ATTRIBS=35980]="INTERLEAVED_ATTRIBS",t[t.SEPARATE_ATTRIBS=35981]="SEPARATE_ATTRIBS",t[t.TRANSFORM_FEEDBACK_BUFFER=35982]="TRANSFORM_FEEDBACK_BUFFER",t[t.TRANSFORM_FEEDBACK_BUFFER_BINDING=35983]="TRANSFORM_FEEDBACK_BUFFER_BINDING",t[t.TRANSFORM_FEEDBACK=36386]="TRANSFORM_FEEDBACK",t[t.TRANSFORM_FEEDBACK_PAUSED=36387]="TRANSFORM_FEEDBACK_PAUSED",t[t.TRANSFORM_FEEDBACK_ACTIVE=36388]="TRANSFORM_FEEDBACK_ACTIVE",t[t.TRANSFORM_FEEDBACK_BINDING=36389]="TRANSFORM_FEEDBACK_BINDING",t[t.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=33296]="FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING",t[t.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=33297]="FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE",t[t.FRAMEBUFFER_ATTACHMENT_RED_SIZE=33298]="FRAMEBUFFER_ATTACHMENT_RED_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=33299]="FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=33300]="FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=33301]="FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=33302]="FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=33303]="FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",t[t.FRAMEBUFFER_DEFAULT=33304]="FRAMEBUFFER_DEFAULT",t[t.DEPTH24_STENCIL8=35056]="DEPTH24_STENCIL8",t[t.DRAW_FRAMEBUFFER_BINDING=36006]="DRAW_FRAMEBUFFER_BINDING",t[t.READ_FRAMEBUFFER_BINDING=36010]="READ_FRAMEBUFFER_BINDING",t[t.RENDERBUFFER_SAMPLES=36011]="RENDERBUFFER_SAMPLES",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=36052]="FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER",t[t.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=36182]="FRAMEBUFFER_INCOMPLETE_MULTISAMPLE",t[t.UNIFORM_BUFFER=35345]="UNIFORM_BUFFER",t[t.UNIFORM_BUFFER_BINDING=35368]="UNIFORM_BUFFER_BINDING",t[t.UNIFORM_BUFFER_START=35369]="UNIFORM_BUFFER_START",t[t.UNIFORM_BUFFER_SIZE=35370]="UNIFORM_BUFFER_SIZE",t[t.MAX_VERTEX_UNIFORM_BLOCKS=35371]="MAX_VERTEX_UNIFORM_BLOCKS",t[t.MAX_FRAGMENT_UNIFORM_BLOCKS=35373]="MAX_FRAGMENT_UNIFORM_BLOCKS",t[t.MAX_COMBINED_UNIFORM_BLOCKS=35374]="MAX_COMBINED_UNIFORM_BLOCKS",t[t.MAX_UNIFORM_BUFFER_BINDINGS=35375]="MAX_UNIFORM_BUFFER_BINDINGS",t[t.MAX_UNIFORM_BLOCK_SIZE=35376]="MAX_UNIFORM_BLOCK_SIZE",t[t.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=35377]="MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS",t[t.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=35379]="MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",t[t.UNIFORM_BUFFER_OFFSET_ALIGNMENT=35380]="UNIFORM_BUFFER_OFFSET_ALIGNMENT",t[t.ACTIVE_UNIFORM_BLOCKS=35382]="ACTIVE_UNIFORM_BLOCKS",t[t.UNIFORM_TYPE=35383]="UNIFORM_TYPE",t[t.UNIFORM_SIZE=35384]="UNIFORM_SIZE",t[t.UNIFORM_BLOCK_INDEX=35386]="UNIFORM_BLOCK_INDEX",t[t.UNIFORM_OFFSET=35387]="UNIFORM_OFFSET",t[t.UNIFORM_ARRAY_STRIDE=35388]="UNIFORM_ARRAY_STRIDE",t[t.UNIFORM_MATRIX_STRIDE=35389]="UNIFORM_MATRIX_STRIDE",t[t.UNIFORM_IS_ROW_MAJOR=35390]="UNIFORM_IS_ROW_MAJOR",t[t.UNIFORM_BLOCK_BINDING=35391]="UNIFORM_BLOCK_BINDING",t[t.UNIFORM_BLOCK_DATA_SIZE=35392]="UNIFORM_BLOCK_DATA_SIZE",t[t.UNIFORM_BLOCK_ACTIVE_UNIFORMS=35394]="UNIFORM_BLOCK_ACTIVE_UNIFORMS",t[t.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=35395]="UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES",t[t.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=35396]="UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",t[t.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=35398]="UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER",t[t.OBJECT_TYPE=37138]="OBJECT_TYPE",t[t.SYNC_CONDITION=37139]="SYNC_CONDITION",t[t.SYNC_STATUS=37140]="SYNC_STATUS",t[t.SYNC_FLAGS=37141]="SYNC_FLAGS",t[t.SYNC_FENCE=37142]="SYNC_FENCE",t[t.SYNC_GPU_COMMANDS_COMPLETE=37143]="SYNC_GPU_COMMANDS_COMPLETE",t[t.UNSIGNALED=37144]="UNSIGNALED",t[t.SIGNALED=37145]="SIGNALED",t[t.ALREADY_SIGNALED=37146]="ALREADY_SIGNALED",t[t.TIMEOUT_EXPIRED=37147]="TIMEOUT_EXPIRED",t[t.CONDITION_SATISFIED=37148]="CONDITION_SATISFIED",t[t.WAIT_FAILED=37149]="WAIT_FAILED",t[t.SYNC_FLUSH_COMMANDS_BIT=1]="SYNC_FLUSH_COMMANDS_BIT",t[t.COLOR=6144]="COLOR",t[t.DEPTH=6145]="DEPTH",t[t.STENCIL=6146]="STENCIL",t[t.MIN=32775]="MIN",t[t.MAX=32776]="MAX",t[t.DEPTH_COMPONENT24=33190]="DEPTH_COMPONENT24",t[t.STREAM_READ=35041]="STREAM_READ",t[t.STREAM_COPY=35042]="STREAM_COPY",t[t.STATIC_READ=35045]="STATIC_READ",t[t.STATIC_COPY=35046]="STATIC_COPY",t[t.DYNAMIC_READ=35049]="DYNAMIC_READ",t[t.DYNAMIC_COPY=35050]="DYNAMIC_COPY",t[t.DEPTH_COMPONENT32F=36012]="DEPTH_COMPONENT32F",t[t.DEPTH32F_STENCIL8=36013]="DEPTH32F_STENCIL8",t[t.INVALID_INDEX=4294967295]="INVALID_INDEX",t[t.TIMEOUT_IGNORED=-1]="TIMEOUT_IGNORED",t[t.MAX_CLIENT_WAIT_TIMEOUT_WEBGL=37447]="MAX_CLIENT_WAIT_TIMEOUT_WEBGL",t[t.UNMASKED_VENDOR_WEBGL=37445]="UNMASKED_VENDOR_WEBGL",t[t.UNMASKED_RENDERER_WEBGL=37446]="UNMASKED_RENDERER_WEBGL",t[t.MAX_TEXTURE_MAX_ANISOTROPY_EXT=34047]="MAX_TEXTURE_MAX_ANISOTROPY_EXT",t[t.TEXTURE_MAX_ANISOTROPY_EXT=34046]="TEXTURE_MAX_ANISOTROPY_EXT",t[t.R16_EXT=33322]="R16_EXT",t[t.RG16_EXT=33324]="RG16_EXT",t[t.RGB16_EXT=32852]="RGB16_EXT",t[t.RGBA16_EXT=32859]="RGBA16_EXT",t[t.R16_SNORM_EXT=36760]="R16_SNORM_EXT",t[t.RG16_SNORM_EXT=36761]="RG16_SNORM_EXT",t[t.RGB16_SNORM_EXT=36762]="RGB16_SNORM_EXT",t[t.RGBA16_SNORM_EXT=36763]="RGBA16_SNORM_EXT",t[t.COMPRESSED_RGB_S3TC_DXT1_EXT=33776]="COMPRESSED_RGB_S3TC_DXT1_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT1_EXT=33777]="COMPRESSED_RGBA_S3TC_DXT1_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT3_EXT=33778]="COMPRESSED_RGBA_S3TC_DXT3_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT5_EXT=33779]="COMPRESSED_RGBA_S3TC_DXT5_EXT",t[t.COMPRESSED_SRGB_S3TC_DXT1_EXT=35916]="COMPRESSED_SRGB_S3TC_DXT1_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=35917]="COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=35918]="COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=35919]="COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT",t[t.COMPRESSED_RED_RGTC1_EXT=36283]="COMPRESSED_RED_RGTC1_EXT",t[t.COMPRESSED_SIGNED_RED_RGTC1_EXT=36284]="COMPRESSED_SIGNED_RED_RGTC1_EXT",t[t.COMPRESSED_RED_GREEN_RGTC2_EXT=36285]="COMPRESSED_RED_GREEN_RGTC2_EXT",t[t.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=36286]="COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT",t[t.COMPRESSED_RGBA_BPTC_UNORM_EXT=36492]="COMPRESSED_RGBA_BPTC_UNORM_EXT",t[t.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT=36493]="COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT",t[t.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT=36494]="COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT",t[t.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT=36495]="COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT",t[t.COMPRESSED_R11_EAC=37488]="COMPRESSED_R11_EAC",t[t.COMPRESSED_SIGNED_R11_EAC=37489]="COMPRESSED_SIGNED_R11_EAC",t[t.COMPRESSED_RG11_EAC=37490]="COMPRESSED_RG11_EAC",t[t.COMPRESSED_SIGNED_RG11_EAC=37491]="COMPRESSED_SIGNED_RG11_EAC",t[t.COMPRESSED_RGB8_ETC2=37492]="COMPRESSED_RGB8_ETC2",t[t.COMPRESSED_RGBA8_ETC2_EAC=37493]="COMPRESSED_RGBA8_ETC2_EAC",t[t.COMPRESSED_SRGB8_ETC2=37494]="COMPRESSED_SRGB8_ETC2",t[t.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=37495]="COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",t[t.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=37496]="COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2",t[t.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=37497]="COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",t[t.COMPRESSED_RGB_PVRTC_4BPPV1_IMG=35840]="COMPRESSED_RGB_PVRTC_4BPPV1_IMG",t[t.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=35842]="COMPRESSED_RGBA_PVRTC_4BPPV1_IMG",t[t.COMPRESSED_RGB_PVRTC_2BPPV1_IMG=35841]="COMPRESSED_RGB_PVRTC_2BPPV1_IMG",t[t.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=35843]="COMPRESSED_RGBA_PVRTC_2BPPV1_IMG",t[t.COMPRESSED_RGB_ETC1_WEBGL=36196]="COMPRESSED_RGB_ETC1_WEBGL",t[t.COMPRESSED_RGB_ATC_WEBGL=35986]="COMPRESSED_RGB_ATC_WEBGL",t[t.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL=35986]="COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL",t[t.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL=34798]="COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL",t[t.COMPRESSED_RGBA_ASTC_4x4_KHR=37808]="COMPRESSED_RGBA_ASTC_4x4_KHR",t[t.COMPRESSED_RGBA_ASTC_5x4_KHR=37809]="COMPRESSED_RGBA_ASTC_5x4_KHR",t[t.COMPRESSED_RGBA_ASTC_5x5_KHR=37810]="COMPRESSED_RGBA_ASTC_5x5_KHR",t[t.COMPRESSED_RGBA_ASTC_6x5_KHR=37811]="COMPRESSED_RGBA_ASTC_6x5_KHR",t[t.COMPRESSED_RGBA_ASTC_6x6_KHR=37812]="COMPRESSED_RGBA_ASTC_6x6_KHR",t[t.COMPRESSED_RGBA_ASTC_8x5_KHR=37813]="COMPRESSED_RGBA_ASTC_8x5_KHR",t[t.COMPRESSED_RGBA_ASTC_8x6_KHR=37814]="COMPRESSED_RGBA_ASTC_8x6_KHR",t[t.COMPRESSED_RGBA_ASTC_8x8_KHR=37815]="COMPRESSED_RGBA_ASTC_8x8_KHR",t[t.COMPRESSED_RGBA_ASTC_10x5_KHR=37816]="COMPRESSED_RGBA_ASTC_10x5_KHR",t[t.COMPRESSED_RGBA_ASTC_10x6_KHR=37817]="COMPRESSED_RGBA_ASTC_10x6_KHR",t[t.COMPRESSED_RGBA_ASTC_10x8_KHR=37818]="COMPRESSED_RGBA_ASTC_10x8_KHR",t[t.COMPRESSED_RGBA_ASTC_10x10_KHR=37819]="COMPRESSED_RGBA_ASTC_10x10_KHR",t[t.COMPRESSED_RGBA_ASTC_12x10_KHR=37820]="COMPRESSED_RGBA_ASTC_12x10_KHR",t[t.COMPRESSED_RGBA_ASTC_12x12_KHR=37821]="COMPRESSED_RGBA_ASTC_12x12_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=37840]="COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=37841]="COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=37842]="COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=37843]="COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=37844]="COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=37845]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=37846]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=37847]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=37848]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=37849]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=37850]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=37851]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=37852]="COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=37853]="COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR",t[t.QUERY_COUNTER_BITS_EXT=34916]="QUERY_COUNTER_BITS_EXT",t[t.CURRENT_QUERY_EXT=34917]="CURRENT_QUERY_EXT",t[t.QUERY_RESULT_EXT=34918]="QUERY_RESULT_EXT",t[t.QUERY_RESULT_AVAILABLE_EXT=34919]="QUERY_RESULT_AVAILABLE_EXT",t[t.TIME_ELAPSED_EXT=35007]="TIME_ELAPSED_EXT",t[t.TIMESTAMP_EXT=36392]="TIMESTAMP_EXT",t[t.GPU_DISJOINT_EXT=36795]="GPU_DISJOINT_EXT",t[t.COMPLETION_STATUS_KHR=37297]="COMPLETION_STATUS_KHR",t[t.DEPTH_CLAMP_EXT=34383]="DEPTH_CLAMP_EXT",t[t.FIRST_VERTEX_CONVENTION_WEBGL=36429]="FIRST_VERTEX_CONVENTION_WEBGL",t[t.LAST_VERTEX_CONVENTION_WEBGL=36430]="LAST_VERTEX_CONVENTION_WEBGL",t[t.PROVOKING_VERTEX_WEBL=36431]="PROVOKING_VERTEX_WEBL",t[t.POLYGON_MODE_WEBGL=2880]="POLYGON_MODE_WEBGL",t[t.POLYGON_OFFSET_LINE_WEBGL=10754]="POLYGON_OFFSET_LINE_WEBGL",t[t.LINE_WEBGL=6913]="LINE_WEBGL",t[t.FILL_WEBGL=6914]="FILL_WEBGL",t[t.MAX_CLIP_DISTANCES_WEBGL=3378]="MAX_CLIP_DISTANCES_WEBGL",t[t.MAX_CULL_DISTANCES_WEBGL=33529]="MAX_CULL_DISTANCES_WEBGL",t[t.MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL=33530]="MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL",t[t.CLIP_DISTANCE0_WEBGL=12288]="CLIP_DISTANCE0_WEBGL",t[t.CLIP_DISTANCE1_WEBGL=12289]="CLIP_DISTANCE1_WEBGL",t[t.CLIP_DISTANCE2_WEBGL=12290]="CLIP_DISTANCE2_WEBGL",t[t.CLIP_DISTANCE3_WEBGL=12291]="CLIP_DISTANCE3_WEBGL",t[t.CLIP_DISTANCE4_WEBGL=12292]="CLIP_DISTANCE4_WEBGL",t[t.CLIP_DISTANCE5_WEBGL=12293]="CLIP_DISTANCE5_WEBGL",t[t.CLIP_DISTANCE6_WEBGL=12294]="CLIP_DISTANCE6_WEBGL",t[t.CLIP_DISTANCE7_WEBGL=12295]="CLIP_DISTANCE7_WEBGL",t[t.POLYGON_OFFSET_CLAMP_EXT=36379]="POLYGON_OFFSET_CLAMP_EXT",t[t.LOWER_LEFT_EXT=36001]="LOWER_LEFT_EXT",t[t.UPPER_LEFT_EXT=36002]="UPPER_LEFT_EXT",t[t.NEGATIVE_ONE_TO_ONE_EXT=37726]="NEGATIVE_ONE_TO_ONE_EXT",t[t.ZERO_TO_ONE_EXT=37727]="ZERO_TO_ONE_EXT",t[t.CLIP_ORIGIN_EXT=37724]="CLIP_ORIGIN_EXT",t[t.CLIP_DEPTH_MODE_EXT=37725]="CLIP_DEPTH_MODE_EXT",t[t.SRC1_COLOR_WEBGL=35065]="SRC1_COLOR_WEBGL",t[t.SRC1_ALPHA_WEBGL=34185]="SRC1_ALPHA_WEBGL",t[t.ONE_MINUS_SRC1_COLOR_WEBGL=35066]="ONE_MINUS_SRC1_COLOR_WEBGL",t[t.ONE_MINUS_SRC1_ALPHA_WEBGL=35067]="ONE_MINUS_SRC1_ALPHA_WEBGL",t[t.MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL=35068]="MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL",t[t.MIRROR_CLAMP_TO_EDGE_EXT=34627]="MIRROR_CLAMP_TO_EDGE_EXT"})(C7||(C7={}));var Fp={3042:!1,32773:new Float32Array([0,0,0,0]),32777:32774,34877:32774,32969:1,32968:0,32971:1,32970:0,3106:new Float32Array([0,0,0,0]),3107:[!0,!0,!0,!0],2884:!1,2885:1029,2929:!1,2931:1,2932:513,2928:new Float32Array([0,1]),2930:!0,3024:!0,35725:null,36006:null,36007:null,34229:null,34964:null,2886:2305,33170:4352,2849:1,32823:!1,32824:0,10752:0,32926:!1,32928:!1,32938:1,32939:!1,3089:!1,3088:new Int32Array([0,0,1024,1024]),2960:!1,2961:0,2968:4294967295,36005:4294967295,2962:519,2967:0,2963:4294967295,34816:519,36003:0,36004:4294967295,2964:7680,2965:7680,2966:7680,34817:7680,34818:7680,34819:7680,2978:[0,0,1024,1024],36389:null,36662:null,36663:null,35053:null,35055:null,35723:4352,36010:null,35977:!1,3333:4,3317:4,37440:!1,37441:!1,37443:37444,3330:0,3332:0,3331:0,3314:0,32878:0,3316:0,3315:0,32877:0},Ke=(t,A,j)=>A?t.enable(j):t.disable(j),OR=(t,A,j)=>t.hint(j,A),Z6=(t,A,j)=>t.pixelStorei(j,A),TR=(t,A,j)=>{let e=j===36006?36009:36008;return t.bindFramebuffer(e,A)},wp=(t,A,j)=>{let r={34964:34962,36662:36662,36663:36663,35053:35051,35055:35052}[j];t.bindBuffer(r,A)};function Kw(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}var SR={3042:Ke,32773:(t,A)=>t.blendColor(...A),32777:"blendEquation",34877:"blendEquation",32969:"blendFunc",32968:"blendFunc",32971:"blendFunc",32970:"blendFunc",3106:(t,A)=>t.clearColor(...A),3107:(t,A)=>t.colorMask(...A),2884:Ke,2885:(t,A)=>t.cullFace(A),2929:Ke,2931:(t,A)=>t.clearDepth(A),2932:(t,A)=>t.depthFunc(A),2928:(t,A)=>t.depthRange(...A),2930:(t,A)=>t.depthMask(A),3024:Ke,35723:OR,35725:(t,A)=>t.useProgram(A),36007:(t,A)=>t.bindRenderbuffer(36161,A),36389:(t,A)=>t.bindTransformFeedback?.(36386,A),34229:(t,A)=>t.bindVertexArray(A),36006:TR,36010:TR,34964:wp,36662:wp,36663:wp,35053:wp,35055:wp,2886:(t,A)=>t.frontFace(A),33170:OR,2849:(t,A)=>t.lineWidth(A),32823:Ke,32824:"polygonOffset",10752:"polygonOffset",35977:Ke,32926:Ke,32928:Ke,32938:"sampleCoverage",32939:"sampleCoverage",3089:Ke,3088:(t,A)=>t.scissor(...A),2960:Ke,2961:(t,A)=>t.clearStencil(A),2968:(t,A)=>t.stencilMaskSeparate(1028,A),36005:(t,A)=>t.stencilMaskSeparate(1029,A),2962:"stencilFuncFront",2967:"stencilFuncFront",2963:"stencilFuncFront",34816:"stencilFuncBack",36003:"stencilFuncBack",36004:"stencilFuncBack",2964:"stencilOpFront",2965:"stencilOpFront",2966:"stencilOpFront",34817:"stencilOpBack",34818:"stencilOpBack",34819:"stencilOpBack",2978:(t,A)=>t.viewport(...A),34383:Ke,10754:Ke,12288:Ke,12289:Ke,12290:Ke,12291:Ke,12292:Ke,12293:Ke,12294:Ke,12295:Ke,3333:Z6,3317:Z6,37440:Z6,37441:Z6,37443:Z6,3330:Z6,3332:Z6,3331:Z6,3314:Z6,32878:Z6,3316:Z6,3315:Z6,32877:Z6,framebuffer:(t,A)=>{let j=A&&"handle"in A?A.handle:A;return t.bindFramebuffer(36160,j)},blend:(t,A)=>A?t.enable(3042):t.disable(3042),blendColor:(t,A)=>t.blendColor(...A),blendEquation:(t,A)=>{let j=typeof A=="number"?[A,A]:A;t.blendEquationSeparate(...j)},blendFunc:(t,A)=>{let j=A?.length===2?[...A,...A]:A;t.blendFuncSeparate(...j)},clearColor:(t,A)=>t.clearColor(...A),clearDepth:(t,A)=>t.clearDepth(A),clearStencil:(t,A)=>t.clearStencil(A),colorMask:(t,A)=>t.colorMask(...A),cull:(t,A)=>A?t.enable(2884):t.disable(2884),cullFace:(t,A)=>t.cullFace(A),depthTest:(t,A)=>A?t.enable(2929):t.disable(2929),depthFunc:(t,A)=>t.depthFunc(A),depthMask:(t,A)=>t.depthMask(A),depthRange:(t,A)=>t.depthRange(...A),dither:(t,A)=>A?t.enable(3024):t.disable(3024),derivativeHint:(t,A)=>{t.hint(35723,A)},frontFace:(t,A)=>t.frontFace(A),mipmapHint:(t,A)=>t.hint(33170,A),lineWidth:(t,A)=>t.lineWidth(A),polygonOffsetFill:(t,A)=>A?t.enable(32823):t.disable(32823),polygonOffset:(t,A)=>t.polygonOffset(...A),sampleCoverage:(t,A)=>t.sampleCoverage(...A),scissorTest:(t,A)=>A?t.enable(3089):t.disable(3089),scissor:(t,A)=>t.scissor(...A),stencilTest:(t,A)=>A?t.enable(2960):t.disable(2960),stencilMask:(t,A)=>{A=Kw(A)?A:[A,A];let[j,e]=A;t.stencilMaskSeparate(1028,j),t.stencilMaskSeparate(1029,e)},stencilFunc:(t,A)=>{A=Kw(A)&&A.length===3?[...A,...A]:A;let[j,e,r,n,i,o]=A;t.stencilFuncSeparate(1028,j,e,r),t.stencilFuncSeparate(1029,n,i,o)},stencilOp:(t,A)=>{A=Kw(A)&&A.length===3?[...A,...A]:A;let[j,e,r,n,i,o]=A;t.stencilOpSeparate(1028,j,e,r),t.stencilOpSeparate(1029,n,i,o)},viewport:(t,A)=>t.viewport(...A)};function ge(t,A,j){return A[t]!==void 0?A[t]:j[t]}var RR={blendEquation:(t,A,j)=>t.blendEquationSeparate(ge(32777,A,j),ge(34877,A,j)),blendFunc:(t,A,j)=>t.blendFuncSeparate(ge(32969,A,j),ge(32968,A,j),ge(32971,A,j),ge(32970,A,j)),polygonOffset:(t,A,j)=>t.polygonOffset(ge(32824,A,j),ge(10752,A,j)),sampleCoverage:(t,A,j)=>t.sampleCoverage(ge(32938,A,j),ge(32939,A,j)),stencilFuncFront:(t,A,j)=>t.stencilFuncSeparate(1028,ge(2962,A,j),ge(2967,A,j),ge(2963,A,j)),stencilFuncBack:(t,A,j)=>t.stencilFuncSeparate(1029,ge(34816,A,j),ge(36003,A,j),ge(36004,A,j)),stencilOpFront:(t,A,j)=>t.stencilOpSeparate(1028,ge(2964,A,j),ge(2965,A,j),ge(2966,A,j)),stencilOpBack:(t,A,j)=>t.stencilOpSeparate(1029,ge(34817,A,j),ge(34818,A,j),ge(34819,A,j))},Xw={enable:(t,A)=>t({[A]:!0}),disable:(t,A)=>t({[A]:!1}),pixelStorei:(t,A,j)=>t({[A]:j}),hint:(t,A,j)=>t({[A]:j}),useProgram:(t,A)=>t({35725:A}),bindRenderbuffer:(t,A,j)=>t({36007:j}),bindTransformFeedback:(t,A,j)=>t({36389:j}),bindVertexArray:(t,A)=>t({34229:A}),bindFramebuffer:(t,A,j)=>{switch(A){case 36160:return t({36006:j,36010:j});case 36009:return t({36006:j});case 36008:return t({36010:j});default:return null}},bindBuffer:(t,A,j)=>{let e={34962:[34964],36662:[36662],36663:[36663],35051:[35053],35052:[35055]}[A];return e?t({[e]:j}):{valueChanged:!0}},blendColor:(t,A,j,e,r)=>t({32773:new Float32Array([A,j,e,r])}),blendEquation:(t,A)=>t({32777:A,34877:A}),blendEquationSeparate:(t,A,j)=>t({32777:A,34877:j}),blendFunc:(t,A,j)=>t({32969:A,32968:j,32971:A,32970:j}),blendFuncSeparate:(t,A,j,e,r)=>t({32969:A,32968:j,32971:e,32970:r}),clearColor:(t,A,j,e,r)=>t({3106:new Float32Array([A,j,e,r])}),clearDepth:(t,A)=>t({2931:A}),clearStencil:(t,A)=>t({2961:A}),colorMask:(t,A,j,e,r)=>t({3107:[A,j,e,r]}),cullFace:(t,A)=>t({2885:A}),depthFunc:(t,A)=>t({2932:A}),depthRange:(t,A,j)=>t({2928:new Float32Array([A,j])}),depthMask:(t,A)=>t({2930:A}),frontFace:(t,A)=>t({2886:A}),lineWidth:(t,A)=>t({2849:A}),polygonOffset:(t,A,j)=>t({32824:A,10752:j}),sampleCoverage:(t,A,j)=>t({32938:A,32939:j}),scissor:(t,A,j,e,r)=>t({3088:new Int32Array([A,j,e,r])}),stencilMask:(t,A)=>t({2968:A,36005:A}),stencilMaskSeparate:(t,A,j)=>t({[A===1028?2968:36005]:j}),stencilFunc:(t,A,j,e)=>t({2962:A,2967:j,2963:e,34816:A,36003:j,36004:e}),stencilFuncSeparate:(t,A,j,e,r)=>t({[A===1028?2962:34816]:j,[A===1028?2967:36003]:e,[A===1028?2963:36004]:r}),stencilOp:(t,A,j,e)=>t({2964:A,2965:j,2966:e,34817:A,34818:j,34819:e}),stencilOpSeparate:(t,A,j,e,r)=>t({[A===1028?2964:34817]:j,[A===1028?2965:34818]:e,[A===1028?2966:34819]:r}),viewport:(t,A,j,e,r)=>t({2978:[A,j,e,r]})},Bs=(t,A)=>t.isEnabled(A),zw={3042:Bs,2884:Bs,2929:Bs,3024:Bs,32823:Bs,32926:Bs,32928:Bs,3089:Bs,2960:Bs,35977:Bs},LR=new Set([34016,36388,36387,35983,35368,34965,35739,35738,3074,34853,34854,34855,34856,34857,34858,34859,34860,34861,34862,34863,34864,34865,34866,34867,34868,35097,32873,35869,32874,34068]);function $o(t,A){if(NnA(A))return;let j={};for(let r in A){let n=Number(r),i=SR[r];i&&(typeof i=="string"?j[i]=!0:i(t,A[r],n))}let e=t.state&&t.state.cache;if(e)for(let r in j){let n=RR[r];n(t,A,e)}}function q$(t,A=Fp){if(typeof A=="number"){let r=A,n=zw[r];return n?n(t,r):t.getParameter(r)}let j=Array.isArray(A)?A:Object.keys(A),e={};for(let r of j){let n=zw[r];e[r]=n?n(t,Number(r)):t.getParameter(Number(r))}return e}function CR(t){$o(t,Fp)}function NnA(t){for(let A in t)return!1;return!0}function HR(t,A){if(t===A)return!0;let j=Array.isArray(t)||ArrayBuffer.isView(t),e=Array.isArray(A)||ArrayBuffer.isView(A);if(j&&e&&t.length===A.length){for(let r=0;r{}}={}){I(this,"gl");I(this,"program",null);I(this,"stateStack",[]);I(this,"enable",!0);I(this,"cache");I(this,"log");this.gl=A,this.cache=j?q$(A):Object.assign({},Fp),this.log=e,this._updateCache=this._updateCache.bind(this),Object.seal(this)}push(A={}){this.stateStack.push({})}pop(){Ot(this.stateStack.length>0);let A=this.stateStack[this.stateStack.length-1];$o(this.gl,A),this.stateStack.pop()}_updateCache(A){let j=!1,e,r=this.stateStack.length>0?this.stateStack[this.stateStack.length-1]:null;for(let n in A){Ot(n!==void 0);let i=A[n],o=this.cache[n];HR(i,o)||(j=!0,e=o,r&&!(n in r)&&(r[n]=o),this.cache[n]=i)}return{valueChanged:j,oldValue:e}}};function qc(t){return t.state}function Vw(t,A){let{enable:j=!0,copyState:e}=A;if(Ot(e!==void 0),!t.state){t.state=new Uw(t,{copyState:e}),XnA(t);for(let n in Xw){let i=Xw[n];KnA(t,n,i)}DR(t,"getParameter"),DR(t,"isEnabled")}let r=qc(t);return r.enable=j,t}function H7(t){let A=qc(t);A||(Vw(t,{copyState:!1}),A=qc(t)),A.push()}function Ta(t){let A=qc(t);Ot(A),A.pop()}function DR(t,A){let j=t[A].bind(t);t[A]=function(r){if(r===void 0||LR.has(r))return j(r);let n=qc(t);return r in n.cache||(n.cache[r]=j(r)),n.enable?n.cache[r]:j(r)},Object.defineProperty(t[A],"name",{value:`${A}-from-cache`,configurable:!1})}function KnA(t,A,j){if(!t[A])return;let e=t[A].bind(t);t[A]=function(...n){let i=qc(t),{valueChanged:o,oldValue:l}=j(i._updateCache,...n);return o&&e(...n),l},Object.defineProperty(t[A],"name",{value:`${A}-to-cache`,configurable:!1})}function XnA(t){let A=t.useProgram.bind(t);t.useProgram=function(e){let r=qc(t);r.program!==e&&(A(e),r.program=e)}}var znA={powerPreference:"high-performance",onContextLost:()=>console.error("WebGL context lost"),onContextRestored:()=>console.info("WebGL context restored")};function NR(t,A){A={...znA,...A};let j=null,e=n=>j=n.statusMessage||j;t.addEventListener("webglcontextcreationerror",e,!1);let r=null;if(r||(r=t.getContext("webgl2",A)),t.removeEventListener("webglcontextcreationerror",e,!1),!r)throw new Error(`Failed to create WebGL context: ${j||"Unknown error"}`);if(A.onContextLost){let{onContextLost:n}=A;t.addEventListener("webglcontextlost",i=>n(i),!1)}if(A.onContextRestored){let{onContextRestored:n}=A;t.addEventListener("webglcontextrestored",i=>n(i),!1)}return r}function wi(t,A,j){return j[A]===void 0&&(j[A]=t.getExtension(A)||null),j[A]}function KR(t,A){let j=t.getParameter(7936),e=t.getParameter(7937);wi(t,"WEBGL_debug_renderer_info",A);let r=A.WEBGL_debug_renderer_info,n=t.getParameter(r?r.UNMASKED_VENDOR_WEBGL:7936),i=t.getParameter(r?r.UNMASKED_RENDERER_WEBGL:7937),o=n||j,l=i||e,c=t.getParameter(7938),B=XR(o,l),h=UnA(o,l),d=VnA(o,l);return{type:"webgl",gpu:B,gpuType:d,gpuBackend:h,vendor:o,renderer:l,version:c,shadingLanguage:"glsl",shadingLanguageVersion:300}}function XR(t,A){return/NVIDIA/i.exec(t)||/NVIDIA/i.exec(A)?"nvidia":/INTEL/i.exec(t)||/INTEL/i.exec(A)?"intel":/Apple/i.exec(t)||/Apple/i.exec(A)?"apple":/AMD/i.exec(t)||/AMD/i.exec(A)||/ATI/i.exec(t)||/ATI/i.exec(A)?"amd":/SwiftShader/i.exec(t)||/SwiftShader/i.exec(A)?"software":"unknown"}function UnA(t,A){return/Metal/i.exec(t)||/Metal/i.exec(A)?"metal":/ANGLE/i.exec(t)||/ANGLE/i.exec(A)?"opengl":"unknown"}function VnA(t,A){if(/SwiftShader/i.exec(t)||/SwiftShader/i.exec(A))return"cpu";switch(XR(t,A)){case"intel":return"integrated";case"software":return"cpu";case"unknown":return"unknown";default:return"discrete"}}function G$(t){switch(t){case"uint8":return 5121;case"sint8":return 5120;case"unorm8":return 5121;case"snorm8":return 5120;case"uint16":return 5123;case"sint16":return 5122;case"unorm16":return 5123;case"snorm16":return 5122;case"uint32":return 5125;case"sint32":return 5124;case"float16":return 5131;case"float32":return 5126}throw new Error(String(t))}var cn="texture-compression-bc",$j="texture-compression-astc",fs="texture-compression-etc2",QnA="texture-compression-etc1-webgl",b$="texture-compression-pvrtc-webgl",Qw="texture-compression-atc-webgl",Pp="float32-renderable-webgl",Ww="float16-renderable-webgl",WnA="rgb9e5ufloat_renderable-webgl",Yw="snorm8-renderable-webgl",Ip="norm16-renderable-webgl",Jw="snorm16-renderable-webgl",w$="float32-filterable",zR="float16-filterable-webgl",Mp="WEBGL_compressed_texture_s3tc",Op="WEBGL_compressed_texture_s3tc_srgb",OB="EXT_texture_compression_rgtc",TB="EXT_texture_compression_bptc",YnA="WEBGL_compressed_texture_etc",JnA="WEBGL_compressed_texture_astc",ZnA="WEBGL_compressed_texture_etc1",A6A="WEBGL_compressed_texture_pvrtc",t6A="WEBGL_compressed_texture_atc",UR="EXT_texture_norm16",VR="EXT_render_snorm",j6A="EXT_color_buffer_float",F$={"float32-renderable-webgl":["EXT_color_buffer_float"],"float16-renderable-webgl":["EXT_color_buffer_half_float"],"rgb9e5ufloat_renderable-webgl":["WEBGL_render_shared_exponent"],"snorm8-renderable-webgl":[VR],"norm16-renderable-webgl":[UR],"snorm16-renderable-webgl":[UR,VR],"float32-filterable":["OES_texture_float_linear"],"float16-filterable-webgl":["OES_texture_half_float_linear"],"texture-filterable-anisotropic-webgl":["EXT_texture_filter_anisotropic"],"texture-blend-float-webgl":["EXT_float_blend"],"texture-compression-bc":[Mp,Op,OB,TB],"texture-compression-bc5-webgl":[OB],"texture-compression-bc7-webgl":[TB],"texture-compression-etc2":[YnA],"texture-compression-astc":[JnA],"texture-compression-etc1-webgl":[ZnA],"texture-compression-pvrtc-webgl":[A6A],"texture-compression-atc-webgl":[t6A]};function QR(t){return t in F$}function WR(t,A,j){return(F$[A]||[]).every(r=>wi(t,r,j))}var P$={"rgb8unorm-unsized":{gl:6407,b:4,c:2,bpp:4,dataFormat:6407,types:[5121,33635]},"rgba8unorm-unsized":{gl:6408,b:4,c:2,bpp:4,dataFormat:6408,types:[5121,32819,32820]},r8unorm:{gl:33321,b:1,c:1,rb:!0},r8snorm:{gl:36756,b:1,c:1,render:Yw},r8uint:{gl:33330,b:1,c:1,rb:!0},r8sint:{gl:33329,b:1,c:1,rb:!0},rg8unorm:{gl:33323,b:2,c:2,rb:!0},rg8snorm:{gl:36757,b:2,c:2,render:Yw},rg8uint:{gl:33336,b:2,c:2,rb:!0},rg8sint:{gl:33335,b:2,c:2,rb:!0},r16uint:{gl:33332,b:2,c:1,rb:!0},r16sint:{gl:33331,b:2,c:1,rb:!0},r16float:{gl:33325,b:2,c:1,render:Ww,filter:"float16-filterable-webgl",rb:!0},"r16unorm-webgl":{gl:33322,b:2,c:1,f:Ip,rb:!0},"r16snorm-webgl":{gl:36760,b:2,c:1,f:Jw},"rgba4unorm-webgl":{gl:32854,b:2,c:4,wgpu:!1,rb:!0},"rgb565unorm-webgl":{gl:36194,b:2,c:4,wgpu:!1,rb:!0},"rgb5a1unorm-webgl":{gl:32855,b:2,c:4,wgpu:!1,rb:!0},"rgb8unorm-webgl":{gl:32849,b:3,c:3,wgpu:!1},"rgb8snorm-webgl":{gl:36758,b:3,c:3,wgpu:!1},rgba8unorm:{gl:32856,b:4,c:2,bpp:4},"rgba8unorm-srgb":{gl:35907,b:4,c:4,bpp:4},rgba8snorm:{gl:36759,b:4,c:4,render:Yw},rgba8uint:{gl:36220,b:4,c:4,bpp:4},rgba8sint:{gl:36238,b:4,c:4,bpp:4},bgra8unorm:{b:4,c:4},"bgra8unorm-srgb":{b:4,c:4},rg16uint:{gl:33338,b:4,c:1,bpp:4},rg16sint:{gl:33337,b:4,c:2,bpp:4},rg16float:{gl:33327,bpp:4,b:4,c:2,render:Ww,filter:zR,rb:!0},"rg16unorm-webgl":{gl:33324,b:2,c:2,render:Ip},"rg16snorm-webgl":{gl:36761,b:2,c:2,render:Jw},r32uint:{gl:33334,b:4,c:1,bpp:4,rb:!0},r32sint:{gl:33333,b:4,c:1,bpp:4,rb:!0},r32float:{gl:33326,bpp:4,b:4,c:1,render:Pp,filter:w$},rgb9e5ufloat:{gl:35901,b:4,c:3,p:1,render:WnA},rg11b10ufloat:{gl:35898,b:4,c:3,p:1,render:Pp,rb:!0},rgb10a2unorm:{gl:32857,b:4,c:4,p:1,rb:!0},"rgb10a2uint-webgl":{b:4,c:4,gl:36975,p:1,wgpu:!1,bpp:4,rb:!0},"rgb16unorm-webgl":{gl:32852,b:2,c:3,f:Ip},"rgb16snorm-webgl":{gl:36762,b:2,c:3,f:Ip},rg32uint:{gl:33340,b:8,c:2,rb:!0},rg32sint:{gl:33339,b:8,c:2,rb:!0},rg32float:{gl:33328,b:8,c:2,render:Pp,filter:w$,rb:!0},rgba16uint:{gl:36214,b:8,c:4,rb:!0},rgba16sint:{gl:36232,b:8,c:4,rb:!0},rgba16float:{gl:34842,b:8,c:4,render:Ww,filter:zR},"rgba16unorm-webgl":{gl:32859,b:2,c:4,render:Ip,rb:!0},"rgba16snorm-webgl":{gl:36763,b:2,c:4,render:Jw},"rgb32float-webgl":{gl:34837,render:Pp,filter:w$,gl2ext:j6A,dataFormat:6407,types:[5126]},rgba32uint:{gl:36208,b:16,c:4,rb:!0},rgba32sint:{gl:36226,b:16,c:4,rb:!0},rgba32float:{gl:34836,b:16,c:4,render:Pp,filter:w$,rb:!0},stencil8:{gl:36168,b:1,c:1,attachment:36128,rb:!0},depth16unorm:{gl:33189,b:2,c:1,attachment:36096,dataFormat:6402,types:[5123],rb:!0},depth24plus:{gl:33190,b:3,c:1,attachment:36096,dataFormat:6402,types:[5125]},depth32float:{gl:36012,b:4,c:1,attachment:36096,dataFormat:6402,types:[5126],rb:!0},"depth24plus-stencil8":{gl:35056,b:4,c:2,p:1,attachment:33306,rb:!0,depthTexture:!0,dataFormat:34041,types:[34042]},"depth24unorm-stencil8":{gl:35056,b:4,c:2,p:1,attachment:33306,dataFormat:34041,types:[34042],rb:!0},"depth32float-stencil8":{gl:36013,b:5,c:2,p:1,attachment:33306,dataFormat:34041,types:[36269],rb:!0},"bc1-rgb-unorm-webgl":{gl:33776,x:Mp,f:cn},"bc1-rgb-unorm-srgb-webgl":{gl:35916,x:Op,f:cn},"bc1-rgba-unorm":{gl:33777,x:Mp,f:cn},"bc1-rgba-unorm-srgb":{gl:35916,x:Op,f:cn},"bc2-rgba-unorm":{gl:33778,x:Mp,f:cn},"bc2-rgba-unorm-srgb":{gl:35918,x:Op,f:cn},"bc3-rgba-unorm":{gl:33779,x:Mp,f:cn},"bc3-rgba-unorm-srgb":{gl:35919,x:Op,f:cn},"bc4-r-unorm":{gl:36283,x:OB,f:cn},"bc4-r-snorm":{gl:36284,x:OB,f:cn},"bc5-rg-unorm":{gl:36285,x:OB,f:cn},"bc5-rg-snorm":{gl:36286,x:OB,f:cn},"bc6h-rgb-ufloat":{gl:36495,x:TB,f:cn},"bc6h-rgb-float":{gl:36494,x:TB,f:cn},"bc7-rgba-unorm":{gl:36492,x:TB,f:cn},"bc7-rgba-unorm-srgb":{gl:36493,x:TB,f:cn},"etc2-rgb8unorm":{gl:37492,f:fs},"etc2-rgb8unorm-srgb":{gl:37494,f:fs},"etc2-rgb8a1unorm":{gl:37496,f:fs},"etc2-rgb8a1unorm-srgb":{gl:37497,f:fs},"etc2-rgba8unorm":{gl:37493,f:fs},"etc2-rgba8unorm-srgb":{gl:37495,f:fs},"eac-r11unorm":{gl:37488,f:fs},"eac-r11snorm":{gl:37489,f:fs},"eac-rg11unorm":{gl:37490,f:fs},"eac-rg11snorm":{gl:37491,f:fs},"astc-4x4-unorm":{gl:37808,f:$j},"astc-4x4-unorm-srgb":{gl:37840,f:$j},"astc-5x4-unorm":{gl:37809,f:$j},"astc-5x4-unorm-srgb":{gl:37841,f:$j},"astc-5x5-unorm":{gl:37810,f:$j},"astc-5x5-unorm-srgb":{gl:37842,f:$j},"astc-6x5-unorm":{gl:37811,f:$j},"astc-6x5-unorm-srgb":{gl:37843,f:$j},"astc-6x6-unorm":{gl:37812,f:$j},"astc-6x6-unorm-srgb":{gl:37844,f:$j},"astc-8x5-unorm":{gl:37813,f:$j},"astc-8x5-unorm-srgb":{gl:37845,f:$j},"astc-8x6-unorm":{gl:37814,f:$j},"astc-8x6-unorm-srgb":{gl:37846,f:$j},"astc-8x8-unorm":{gl:37815,f:$j},"astc-8x8-unorm-srgb":{gl:37847,f:$j},"astc-10x5-unorm":{gl:37819,f:$j},"astc-10x5-unorm-srgb":{gl:37851,f:$j},"astc-10x6-unorm":{gl:37817,f:$j},"astc-10x6-unorm-srgb":{gl:37849,f:$j},"astc-10x8-unorm":{gl:37818,f:$j},"astc-10x8-unorm-srgb":{gl:37850,f:$j},"astc-10x10-unorm":{gl:37819,f:$j},"astc-10x10-unorm-srgb":{gl:37851,f:$j},"astc-12x10-unorm":{gl:37820,f:$j},"astc-12x10-unorm-srgb":{gl:37852,f:$j},"astc-12x12-unorm":{gl:37821,f:$j},"astc-12x12-unorm-srgb":{gl:37853,f:$j},"pvrtc-rgb4unorm-webgl":{gl:35840,f:b$},"pvrtc-rgba4unorm-webgl":{gl:35842,f:b$},"pvrtc-rbg2unorm-webgl":{gl:35841,f:b$},"pvrtc-rgba2unorm-webgl":{gl:35843,f:b$},"etc1-rbg-unorm-webgl":{gl:36196,f:QnA},"atc-rgb-unorm-webgl":{gl:35986,f:Qw},"atc-rgba-unorm-webgl":{gl:35986,f:Qw},"atc-rgbai-unorm-webgl":{gl:34798,f:Qw}},e6A={6403:1,36244:1,33319:2,33320:2,6407:3,36248:3,6408:4,36249:4,6402:1,34041:1,6406:1,6409:1,6410:2},r6A={5126:4,5125:4,5124:4,5123:2,5122:2,5131:2,5120:1,5121:1};function I$(t,A,j){let e=P$[A];if(!e||e.gl===void 0)return!1;let r=e.x||e.gl2ext;return r?!!wi(t,r,j):!0}function Zw(t){let j=P$[t]?.gl;if(j===void 0)throw new Error(`Unsupported texture format ${t}`);return j}function YR(t,A,j){if(!I$(t,A,j)||A.startsWith("depth")||A.startsWith("stencil"))return!1;try{if(hE(A).signed)return!1}catch{return!1}return A.endsWith("32float")?!!wi(t,"OES_texture_float_linear, extensions",j):A.endsWith("16float")?!!wi(t,"OES_texture_half_float_linear, extensions",j):!0}function JR(t,A,j){return!(!I$(t,A,j)||typeof A=="number")}function SB(t){let A=P$[t],j=Zw(t),e=hE(t);return{format:j,dataFormat:A?.dataFormat||n6A(e.format,e.integer,e.normalized,j),type:e.dataType?G$(e.dataType):A?.types?.[0]||5121,compressed:e.compressed}}function ZR(t){let A=P$[t];if(!A?.attachment)throw new Error(`${t} is not a depth stencil format`);return A.attachment}function AF(t){let A=SB(t),j=e6A[A.dataFormat]||4,e=r6A[A.type]||1;return j*e}function n6A(t,A,j,e){if(e===6408||e===6407)return e;switch(t){case"r":return A&&!j?36244:6403;case"rg":return A&&!j?33320:33319;case"rgb":return A&&!j?36248:6407;case"rgba":return A&&!j?36249:6408;default:return 6408}}var AL={"depth-clip-control":"EXT_depth_clamp","timer-query-webgl":"EXT_disjoint_timer_query_webgl2","compilation-status-async-webgl":"KHR_parallel_shader_compile","polygon-mode-webgl":"WEBGL_polygon_mode","provoking-vertex-webgl":"WEBGL_provoking_vertex","shader-clip-cull-distance-webgl":"WEBGL_clip_cull_distance","shader-noperspective-interpolation-webgl":"NV_shader_noperspective_interpolation","shader-conservative-depth-webgl":"EXT_conservative_depth"},M$=class extends zd{constructor(j,e,r){super([],r);I(this,"gl");I(this,"extensions");I(this,"testedFeatures",new Set);this.gl=j,this.extensions=e,wi(j,"EXT_color_buffer_float",e)}*[Symbol.iterator](){let j=this.getFeatures();for(let e of j)this.has(e)&&(yield e);return[]}has(j){return this.disabledFeatures[j]?!1:(this.testedFeatures.has(j)||(this.testedFeatures.add(j),QR(j)&&WR(this.gl,j,this.extensions)&&this.features.add(j),this.getWebGLFeature(j)&&this.features.add(j)),this.features.has(j))}initializeFeatures(){let j=this.getFeatures().filter(e=>e!=="polygon-mode-webgl");for(let e of j)this.has(e)}getFeatures(){return[...Object.keys(AL),...Object.keys(F$)]}getWebGLFeature(j){let e=AL[j];return typeof e=="string"?!!wi(this.gl,e,this.extensions):!!e}};var O$=class extends Xd{constructor(j){super();I(this,"gl");I(this,"limits",{});this.gl=j}get maxTextureDimension1D(){return 0}get maxTextureDimension2D(){return this.getParameter(3379)}get maxTextureDimension3D(){return this.getParameter(32883)}get maxTextureArrayLayers(){return this.getParameter(35071)}get maxBindGroups(){return 0}get maxDynamicUniformBuffersPerPipelineLayout(){return 0}get maxDynamicStorageBuffersPerPipelineLayout(){return 0}get maxSampledTexturesPerShaderStage(){return this.getParameter(35660)}get maxSamplersPerShaderStage(){return this.getParameter(35661)}get maxStorageBuffersPerShaderStage(){return 0}get maxStorageTexturesPerShaderStage(){return 0}get maxUniformBuffersPerShaderStage(){return this.getParameter(35375)}get maxUniformBufferBindingSize(){return this.getParameter(35376)}get maxStorageBufferBindingSize(){return 0}get minUniformBufferOffsetAlignment(){return this.getParameter(35380)}get minStorageBufferOffsetAlignment(){return 0}get maxVertexBuffers(){return 16}get maxVertexAttributes(){return this.getParameter(34921)}get maxVertexBufferArrayStride(){return 2048}get maxInterStageShaderComponents(){return this.getParameter(35659)}get maxComputeWorkgroupStorageSize(){return 0}get maxComputeInvocationsPerWorkgroup(){return 0}get maxComputeWorkgroupSizeX(){return 0}get maxComputeWorkgroupSizeY(){return 0}get maxComputeWorkgroupSizeZ(){return 0}get maxComputeWorkgroupsPerDimension(){return 0}getParameter(j){return this.limits[j]===void 0&&(this.limits[j]=this.gl.getParameter(j)),this.limits[j]}};function Fi(t,A,j){if(i6A(A))return j(t);let{nocatch:e=!0}=A;H7(t),$o(t,A);let r;if(e)r=j(t),Ta(t);else try{r=j(t)}finally{Ta(t)}return r}function i6A(t){for(let A in t)return!1;return!0}function jL(t,A,j,e){if(G7(A))return e(t);let r=t;H7(r.gl);try{return o6A(t,A),$o(r.gl,j),e(t)}finally{Ta(r.gl)}}function o6A(t,A){let j=t,{gl:e}=j;if(A.cullMode)switch(A.cullMode){case"none":e.disable(2884);break;case"front":e.enable(2884),e.cullFace(1028);break;case"back":e.enable(2884),e.cullFace(1029);break}if(A.frontFace&&e.frontFace(Gc("frontFace",A.frontFace,{ccw:2305,cw:2304})),A.unclippedDepth&&t.features.has("depth-clip-control")&&e.enable(34383),A.depthBias!==void 0&&(e.enable(32823),e.polygonOffset(A.depthBias,A.depthBiasSlopeScale||0)),A.provokingVertex&&t.features.has("provoking-vertex-webgl")){let n=j.getExtension("WEBGL_provoking_vertex").WEBGL_provoking_vertex,i=Gc("provokingVertex",A.provokingVertex,{first:36429,last:36430});n?.provokingVertexWEBGL(i)}if((A.polygonMode||A.polygonOffsetLine)&&t.features.has("polygon-mode-webgl")){if(A.polygonMode){let n=j.getExtension("WEBGL_polygon_mode").WEBGL_polygon_mode,i=Gc("polygonMode",A.polygonMode,{fill:6914,line:6913});n?.polygonModeWEBGL(1028,i),n?.polygonModeWEBGL(1029,i)}A.polygonOffsetLine&&e.enable(10754)}if(t.features.has("shader-clip-cull-distance-webgl")&&(A.clipDistance0&&e.enable(12288),A.clipDistance1&&e.enable(12289),A.clipDistance2&&e.enable(12290),A.clipDistance3&&e.enable(12291),A.clipDistance4&&e.enable(12292),A.clipDistance5&&e.enable(12293),A.clipDistance6&&e.enable(12294),A.clipDistance7&&e.enable(12295)),A.depthWriteEnabled!==void 0&&e.depthMask(a6A("depthWriteEnabled",A.depthWriteEnabled)),A.depthCompare&&(A.depthCompare!=="always"?e.enable(2929):e.disable(2929),e.depthFunc(S$("depthCompare",A.depthCompare))),A.stencilWriteMask){let r=A.stencilWriteMask;e.stencilMaskSeparate(1028,r),e.stencilMaskSeparate(1029,r)}if(A.stencilReadMask&&mA.warn("stencilReadMask not supported under WebGL"),A.stencilCompare){let r=A.stencilReadMask||4294967295,n=S$("depthCompare",A.stencilCompare);A.stencilCompare!=="always"?e.enable(2960):e.disable(2960),e.stencilFuncSeparate(1028,n,0,r),e.stencilFuncSeparate(1029,n,0,r)}if(A.stencilPassOperation&&A.stencilFailOperation&&A.stencilDepthFailOperation){let r=tF("stencilPassOperation",A.stencilPassOperation),n=tF("stencilFailOperation",A.stencilFailOperation),i=tF("stencilDepthFailOperation",A.stencilDepthFailOperation);e.stencilOpSeparate(1028,n,i,r),e.stencilOpSeparate(1029,n,i,r)}if(A.blendColorOperation||A.blendAlphaOperation){e.enable(3042);let r=tL("blendColorOperation",A.blendColorOperation||"add"),n=tL("blendAlphaOperation",A.blendAlphaOperation||"add");e.blendEquationSeparate(r,n);let i=T$("blendColorSrcFactor",A.blendColorSrcFactor||"one"),o=T$("blendColorDstFactor",A.blendColorDstFactor||"zero"),l=T$("blendAlphaSrcFactor",A.blendAlphaSrcFactor||"one"),c=T$("blendAlphaDstFactor",A.blendAlphaDstFactor||"zero");e.blendFuncSeparate(i,o,l,c)}}function S$(t,A){return Gc(t,A,{never:512,less:513,equal:514,"less-equal":515,greater:516,"not-equal":517,"greater-equal":518,always:519})}function tF(t,A){return Gc(t,A,{keep:7680,zero:0,replace:7681,invert:5386,"increment-clamp":7682,"decrement-clamp":7683,"increment-wrap":34055,"decrement-wrap":34056})}function tL(t,A){return Gc(t,A,{add:32774,subtract:32778,"reverse-subtract":32779,min:32775,max:32776})}function T$(t,A){return Gc(t,A,{one:1,zero:0,"src-color":768,"one-minus-src-color":769,"dst-color":774,"one-minus-dst-color":775,"src-alpha":770,"one-minus-src-alpha":771,"dst-alpha":772,"one-minus-dst-alpha":773,"src-alpha-saturated":776,"constant-color":32769,"one-minus-constant-color":32770,"constant-alpha":32771,"one-minus-constant-alpha":32772})}function s6A(t,A){return`Illegal parameter ${A} for ${t}`}function Gc(t,A,j){if(!(A in j))throw new Error(s6A(t,A));return j[A]}function a6A(t,A){return A}function R$(t){let A={};return t.addressModeU&&(A[10242]=jF(t.addressModeU)),t.addressModeV&&(A[10243]=jF(t.addressModeV)),t.addressModeW&&(A[32882]=jF(t.addressModeW)),t.magFilter&&(A[10240]=eL(t.magFilter)),(t.minFilter||t.mipmapFilter)&&(A[10241]=l6A(t.minFilter||"linear",t.mipmapFilter)),t.lodMinClamp!==void 0&&(A[33082]=t.lodMinClamp),t.lodMaxClamp!==void 0&&(A[33083]=t.lodMaxClamp),t.type==="comparison-sampler"&&(A[34892]=34894),t.compare&&(A[34893]=S$("compare",t.compare)),t.maxAnisotropy&&(A[34046]=t.maxAnisotropy),A}function jF(t){switch(t){case"clamp-to-edge":return 33071;case"repeat":return 10497;case"mirror-repeat":return 33648}}function eL(t){switch(t){case"nearest":return 9728;case"linear":return 9729}}function l6A(t,A){if(!A)return eL(t);switch(t){case"nearest":return A==="nearest"?9984:9986;case"linear":return A==="nearest"?9985:9987}}var Mn=class extends Aj{constructor(j,e={}){super(j,e);I(this,"device");I(this,"gl");I(this,"handle");I(this,"glTarget");I(this,"glUsage");I(this,"glIndexType",5123);I(this,"byteLength");I(this,"bytesUsed");this.device=j,this.gl=this.device.gl;let r=typeof e=="object"?e.handle:void 0;this.handle=r||this.gl.createBuffer(),j.setSpectorMetadata(this.handle,{...this.props,data:typeof this.props.data}),this.glTarget=c6A(this.props.usage),this.glUsage=u6A(this.props.usage),this.glIndexType=this.props.indexType==="uint32"?5125:5123,e.data?this._initWithData(e.data,e.byteOffset,e.byteLength):this._initWithByteLength(e.byteLength||0)}_initWithData(j,e=0,r=j.byteLength+e){let n=this.glTarget;this.gl.bindBuffer(n,this.handle),this.gl.bufferData(n,r,this.glUsage),this.gl.bufferSubData(n,e,j),this.gl.bindBuffer(n,null),this.bytesUsed=r,this.byteLength=r,this._setDebugData(j,e,r),this.trackAllocatedMemory(r)}_initWithByteLength(j){Ot(j>=0);let e=j;j===0&&(e=new Float32Array(0));let r=this.glTarget;return this.gl.bindBuffer(r,this.handle),this.gl.bufferData(r,e,this.glUsage),this.gl.bindBuffer(r,null),this.bytesUsed=j,this.byteLength=j,this._setDebugData(null,0,j),this.trackAllocatedMemory(j),this}destroy(){!this.destroyed&&this.handle&&(this.removeStats(),this.trackDeallocatedMemory(),this.gl.deleteBuffer(this.handle),this.destroyed=!0,this.handle=null)}write(j,e=0){this.gl.bindBuffer(36663,this.handle),this.gl.bufferSubData(36663,e,j),this.gl.bindBuffer(36663,null),this._setDebugData(j,e,j.byteLength)}async readAsync(j=0,e){return this.readSyncWebGL(j,e)}readSyncWebGL(j=0,e){e=e??this.byteLength-j;let r=new Uint8Array(e),n=0;return this.gl.bindBuffer(36662,this.handle),this.gl.getBufferSubData(36662,j,r,n,e),this.gl.bindBuffer(36662,null),this._setDebugData(r,j,e),r}};function c6A(t){return t&Aj.INDEX?34963:t&Aj.VERTEX?34962:t&Aj.UNIFORM?35345:34962}function u6A(t){return t&Aj.INDEX||t&Aj.VERTEX?35044:t&Aj.UNIFORM?35048:35044}var bc=class extends hc{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"parameters");this.device=j,this.parameters=R$(e),this.handle=this.handle||this.device.gl.createSampler(),this._setSamplerParameters(this.parameters)}destroy(){this.handle&&(this.device.gl.deleteSampler(this.handle),this.handle=void 0)}toString(){return`Sampler(${this.id},${JSON.stringify(this.props)})`}_setSamplerParameters(j){for(let[e,r]of Object.entries(j)){let n=Number(e);switch(n){case 33082:case 33083:this.device.gl.samplerParameterf(this.handle,n,r);break;default:this.device.gl.samplerParameteri(this.handle,n,r);break}}}};var xo=class extends Bc{constructor(j,e){super(j,{...Ne.defaultProps,...e});I(this,"device");I(this,"gl");I(this,"handle");I(this,"texture");this.device=j,this.gl=this.device.gl,this.handle=null,this.texture=e.texture}};var B6A={parameters:{},pixelStore:{},pixels:null,border:0,dataFormat:void 0,textureUnit:void 0,target:void 0},Tp=class Tp extends Ne{constructor(j,e){super(j,{...B6A,format:"rgba8unorm",...e});I(this,"MAX_ATTRIBUTES");I(this,"device");I(this,"gl");I(this,"handle");I(this,"sampler");I(this,"view");I(this,"glFormat");I(this,"type");I(this,"dataFormat");I(this,"mipmaps");I(this,"target");I(this,"textureUnit");I(this,"loaded",!1);I(this,"_video");this.device=j,this.gl=this.device.gl,this.handle=this.props.handle||this.gl.createTexture(),this.device.setSpectorMetadata(this.handle,{...this.props,data:typeof this.props.data}),this.glFormat=6408,this.target=f6A(this.props),this.loaded=!1,typeof this.props?.data=="string"&&Object.assign(this.props,{data:jb(this.props.data)}),this.initialize(this.props),Object.seal(this)}destroy(){this.handle&&(this.gl.deleteTexture(this.handle),this.removeStats(),this.trackDeallocatedMemory("Texture"),this.destroyed=!0)}toString(){return`Texture(${this.id},${this.width}x${this.height})`}createView(j){return new xo(this.device,{...j,texture:this})}initialize(j={}){if(this.props.dimension==="cube")return this.initializeCube(j);let e=j.data;if(e instanceof Promise)return e.then(y=>this.initialize(Object.assign({},j,{pixels:y,data:y}))),this;let r=typeof HTMLVideoElement<"u"&&e instanceof HTMLVideoElement;if(r&&e.readyStatethis.initialize(j)),this;let{parameters:n={}}=j,{pixels:i=null,pixelStore:o={},textureUnit:l=void 0,mipmaps:c=!0}=j;e||(e=i);let{width:B,height:h,dataFormat:d,type:k,compressed:g=!1}=j,{depth:E=0}=j,m=Zw(j.format);return{width:B,height:h,compressed:g,dataFormat:d,type:k}=this._deduceParameters({format:j.format,type:k,dataFormat:d,compressed:g,data:e,width:B,height:h}),this.width=B,this.height=h,this.glFormat=m,this.type=k,this.dataFormat=d,this.textureUnit=l,Number.isFinite(this.textureUnit)&&(this.gl.activeTexture(33984+this.textureUnit),this.gl.bindTexture(this.target,this.handle)),this.mipmaps=c,this.setImageData({data:e,width:B,height:h,depth:E,format:j.format,type:k,dataFormat:d,parameters:o,compressed:g}),this.setSampler(j.sampler),this._setSamplerParameters(n),this.view=this.createView({...this.props,mipLevelCount:1,arrayLayerCount:1}),c&&this.device.isTextureFormatFilterable(j.format)&&this.generateMipmap(),r&&(this._video={video:e,parameters:n,lastTime:e.readyState>=HTMLVideoElement.HAVE_CURRENT_DATA?e.currentTime:-1}),this}initializeCube(j){let{mipmaps:e=!0,parameters:r={}}=j;return this.setCubeMapImageData(j).then(()=>{this.loaded=!0,e&&this.generateMipmap(j),this.setSampler(j.sampler),this._setSamplerParameters(r)}),this}setSampler(j={}){let e;j instanceof bc?(this.sampler=j,e=j.props):(this.sampler=new bc(this.device,j),e=j);let r=R$(e);return this._setSamplerParameters(r),this}resize(j){let{height:e,width:r,mipmaps:n=!1}=j;return r!==this.width||e!==this.height?this.initialize({width:r,height:e,format:this.format,type:this.type,dataFormat:this.dataFormat,mipmaps:n}):this}update(){if(this._video){let{video:j,parameters:e,lastTime:r}=this._video;if(r===j.currentTime||j.readyState{this.gl.generateMipmap(this.target)}),this.gl.bindTexture(this.target,null),this}setImageData(j){if(this.props.dimension==="3d"||this.props.dimension==="2d-array")return this.setImageData3D(j);this.trackDeallocatedMemory("Texture");let{target:e=this.target,pixels:r=null,level:n=0,glFormat:i=this.glFormat,offset:o=0,parameters:l={}}=j,{data:c=null,type:B=this.type,width:h=this.width,height:d=this.height,dataFormat:k=this.dataFormat,compressed:g=!1}=j;c||(c=r),{type:B,dataFormat:k,compressed:g,width:h,height:d}=this._deduceParameters({format:this.props.format,type:B,dataFormat:k,compressed:g,data:c,width:h,height:d});let{gl:E}=this;E.bindTexture(this.target,this.handle);let m=null;if({data:c,dataType:m}=this._getDataType({data:c,compressed:g}),Fi(this.gl,l,()=>{switch(m){case"null":E.texImage2D(e,n,i,h,d,0,k,B,c);break;case"typed-array":E.texImage2D(e,n,i,h,d,0,k,B,c,o);break;case"buffer":this.device.gl.bindBuffer(35052,c.handle||c),this.device.gl.texImage2D(e,n,i,h,d,0,k,B,o),this.device.gl.bindBuffer(35052,null);break;case"browser-object":E.texImage2D(e,n,i,h,d,0,k,B,c);break;case"compressed":for(let[y,b]of c.entries())E.compressedTexImage2D(e,y,b.format,b.width,b.height,0,b.data);break;default:Ot(!1,"Unknown image data type")}}),c&&c.byteLength)this.trackAllocatedMemory(c.byteLength,"Texture");else{let y=AF(this.props.format);this.trackAllocatedMemory(this.width*this.height*y,"Texture")}return this.loaded=!0,this}setSubImageData({target:j=this.target,pixels:e=null,data:r=null,x:n=0,y:i=0,width:o=this.width,height:l=this.height,level:c=0,glFormat:B=this.glFormat,type:h=this.type,dataFormat:d=this.dataFormat,compressed:k=!1,offset:g=0,parameters:E={}}){if({type:h,dataFormat:d,compressed:k,width:o,height:l}=this._deduceParameters({format:this.props.format,type:h,dataFormat:d,compressed:k,data:r,width:o,height:l}),Ot(this.depth===1,"texSubImage not supported for 3D textures"),r||(r=e),r&&r.data){let m=r;r=m.data,o=m.shape[0],l=m.shape[1]}r instanceof Mn&&(r=r.handle),this.gl.bindTexture(this.target,this.handle),Fi(this.gl,E,()=>{k?this.gl.compressedTexSubImage2D(j,c,n,i,o,l,B,r):r===null?this.gl.texSubImage2D(j,c,n,i,o,l,d,h,null):ArrayBuffer.isView(r)?this.gl.texSubImage2D(j,c,n,i,o,l,d,h,r,g):typeof WebGLBuffer<"u"&&r instanceof WebGLBuffer?(this.device.gl.bindBuffer(35052,r),this.device.gl.texSubImage2D(j,c,n,i,o,l,d,h,g),this.device.gl.bindBuffer(35052,null)):this.device.gl.texSubImage2D(j,c,n,i,o,l,d,h,r)}),this.gl.bindTexture(this.target,null)}copyFramebuffer(j={}){return mA.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(),null}getActiveUnit(){return this.gl.getParameter(34016)-33984}bind(j=this.textureUnit){let{gl:e}=this;return j!==void 0&&(this.textureUnit=j,e.activeTexture(33984+j)),e.bindTexture(this.target,this.handle),j}unbind(j=this.textureUnit){let{gl:e}=this;return j!==void 0&&(this.textureUnit=j,e.activeTexture(33984+j)),e.bindTexture(this.target,null),j}_getDataType({data:j,compressed:e=!1}){return e?{data:j,dataType:"compressed"}:j===null?{data:j,dataType:"null"}:ArrayBuffer.isView(j)?{data:j,dataType:"typed-array"}:j instanceof Mn?{data:j.handle,dataType:"buffer"}:typeof WebGLBuffer<"u"&&j instanceof WebGLBuffer?{data:j,dataType:"buffer"}:{data:j,dataType:"browser-object"}}_deduceParameters(j){let{format:e,data:r}=j,{width:n,height:i,dataFormat:o,type:l,compressed:c}=j,B=SB(e);return o=o||B.dataFormat,l=l||B.type,c=c||B.compressed,{width:n,height:i}=this._deduceImageSize(r,n,i),{dataFormat:o,type:l,compressed:c,width:n,height:i,format:e,data:r}}_deduceImageSize(j,e,r){let n;return typeof ImageData<"u"&&j instanceof ImageData?n={width:j.width,height:j.height}:typeof HTMLImageElement<"u"&&j instanceof HTMLImageElement?n={width:j.naturalWidth,height:j.naturalHeight}:typeof HTMLCanvasElement<"u"&&j instanceof HTMLCanvasElement?n={width:j.width,height:j.height}:typeof ImageBitmap<"u"&&j instanceof ImageBitmap?n={width:j.width,height:j.height}:typeof HTMLVideoElement<"u"&&j instanceof HTMLVideoElement?n={width:j.videoWidth,height:j.videoHeight}:j?n={width:e,height:r}:n={width:e>=0?e:1,height:r>=0?r:1},Ot(n,"Could not deduced texture size"),Ot(e===void 0||n.width===e,"Deduced texture width does not match supplied width"),Ot(r===void 0||n.height===r,"Deduced texture height does not match supplied height"),n}async setCubeMapImageData(j){let{gl:e}=this,{width:r,height:n,pixels:i,data:o,format:l=6408,type:c=5121}=j,B=i||o,h=await Promise.all(Tp.FACES.map(d=>{let k=B[d];return Promise.all(Array.isArray(k)?k:[k])}));this.bind(),Tp.FACES.forEach((d,k)=>{h[k].length>1&&this.props.mipmaps!==!1&&mA.warn(`${this.id} has mipmap and multiple LODs.`)(),h[k].forEach((g,E)=>{r&&n?e.texImage2D(d,E,l,r,n,0,l,c,g):e.texImage2D(d,E,l,l,c,g)})}),this.unbind()}setImageDataForFace(j){let{face:e,width:r,height:n,pixels:i,data:o,format:l=6408,type:c=5121}=j,{gl:B}=this,h=i||o;return this.bind(),h instanceof Promise?h.then(d=>this.setImageDataForFace(Object.assign({},j,{face:e,data:d,pixels:d}))):this.width||this.height?B.texImage2D(e,0,l,r,n,0,l,c,h):B.texImage2D(e,0,l,l,c,h),this}setImageData3D(j){let{level:e=0,dataFormat:r,format:n,type:i,width:o,height:l,depth:c=1,offset:B=0,data:h,parameters:d={}}=j;this.trackDeallocatedMemory("Texture"),this.gl.bindTexture(this.target,this.handle);let k=SB(n);if(Fi(this.gl,d,()=>{ArrayBuffer.isView(h)&&this.gl.texImage3D(this.target,e,k.format,o,l,c,0,k.dataFormat,k.type,h),h instanceof Mn&&(this.gl.bindBuffer(35052,h.handle),this.gl.texImage3D(this.target,e,r,o,l,c,0,n,i,B))}),h&&h.byteLength)this.trackAllocatedMemory(h.byteLength,"Texture");else{let g=AF(this.props.format);this.trackAllocatedMemory(this.width*this.height*this.depth*g,"Texture")}return this.loaded=!0,this}_setSamplerParameters(j){if(!G7(j)){h6A(j),this.gl.bindTexture(this.target,this.handle);for(let[e,r]of Object.entries(j)){let n=Number(e),i=r;switch(n){case 33082:case 33083:this.gl.texParameterf(this.target,n,i);break;default:this.gl.texParameteri(this.target,n,i);break}}this.gl.bindTexture(this.target,null)}}};I(Tp,"FACES",[34069,34070,34071,34072,34073,34074]);var _6=Tp;function f6A(t){switch(t.dimension){case"2d":return 3553;case"cube":return 34067;case"2d-array":return 35866;case"3d":return 32879;case"1d":case"cube-array":default:throw new Error(t.dimension)}}function h6A(t){mA.log(1,"texture sampler parameters",t)()}var hs=class extends dc{constructor(j,e){super(j,e);I(this,"device");I(this,"gl");I(this,"handle");let r=e.handle===null;if(this.device=j,this.gl=j.gl,this.handle=this.props.handle||r?this.props.handle:this.gl.createFramebuffer(),!r){j.setSpectorMetadata(this.handle,{id:this.props.id,props:this.props}),this.autoCreateAttachmentTextures();let n=this.gl.bindFramebuffer(36160,this.handle);for(let i=0;imA.info("Spector capture started:",A)()),q6?.onCapture.add(A=>{mA.info("Spector capture complete:",A)(),q6?.getResultUI(),q6?.resultView.display(),q6?.resultView.addCapture(A)})),t?.canvas){if(typeof t.spector=="string"&&t.spector!==t.canvas.id)return q6;q6?.startCapture(t?.canvas,500),new Promise(A=>setTimeout(A,2e3)).then(A=>{mA.info("Spector capture stopped after 2 seconds")(),q6?.stopCapture()})}return q6}var E6A="https://unpkg.com/webgl-debug@2.0.1/index.js";function oL(t){return t.luma=t.luma||{},t.luma}async function sL(){rn()&&!globalThis.WebGLDebugUtils&&(globalThis.global=globalThis.global||globalThis,globalThis.global.module={},await jp(E6A))}function aL(t,A={}){return t?A.debug?x6A(t,A):$6A(t):null}function $6A(t){let A=oL(t);return A.realContext?A.realContext:t}function x6A(t,A){if(!globalThis.WebGLDebugUtils)return mA.warn("webgl-debug not loaded")(),t;let j=oL(t);if(j.debugContext)return j.debugContext;globalThis.WebGLDebugUtils.init({...C7,...t});let e=globalThis.WebGLDebugUtils.makeDebugContext(t,y6A.bind(null,A),v6A.bind(null,A));for(let i in C7)!(i in e)&&typeof C7[i]=="number"&&(e[i]=C7[i]);class r{}Object.setPrototypeOf(e,Object.getPrototypeOf(t)),Object.setPrototypeOf(r,e);let n=Object.create(r);return j.realContext=t,j.debugContext=n,n.debug=!0,n}function eF(t,A){A=Array.from(A).map(e=>e===void 0?"undefined":e);let j=globalThis.WebGLDebugUtils.glFunctionArgsToString(t,A);return j=`${j.slice(0,100)}${j.length>100?"...":""}`,`gl.${t}(${j})`}function y6A(t,A,j,e){e=Array.from(e).map(o=>o===void 0?"undefined":o);let r=globalThis.WebGLDebugUtils.glEnumToString(A),n=globalThis.WebGLDebugUtils.glFunctionArgsToString(j,e),i=`${r} in gl.${j}(${n})`;mA.error(i)();debugger;if(t.throwOnError)throw new Error(i)}function v6A(t,A,j){let e="";if(mA.level>=1&&(e=eF(A,j),mA.log(1,e)()),t.break&&t.break.length>0&&(e=e||eF(A,j),t.break.every(n=>e.indexOf(n)!==-1)))debugger;for(let r of j)if(r===void 0){if(e=e||eF(A,j),t.throwOnError)throw new Error(`Undefined argument: ${e}`);mA.error(`Undefined argument: ${e}`)();debugger}}function cL(t){let A=t.split(/\r?\n/),j=[];for(let e of A){if(e.length<=1)continue;let r=e.split(":");if(r.length===2){let[h,d]=r;j.push({message:d.trim(),type:lL(h),lineNum:0,linePos:0});continue}let[n,i,o,...l]=r,c=parseInt(o,10);isNaN(c)&&(c=0);let B=parseInt(i,10);isNaN(B)&&(B=0),j.push({message:l.join(":").trim(),type:lL(n),lineNum:c,linePos:B})}return j}function lL(t){let A=["warning","error","info"],j=t.toLowerCase();return A.includes(j)?j:"info"}var C$=class extends fc{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");switch(this.device=j,this.props.stage){case"vertex":this.handle=this.props.handle||this.device.gl.createShader(35633);break;case"fragment":this.handle=this.props.handle||this.device.gl.createShader(35632);break;default:throw new Error(this.props.stage)}this._compile(this.source)}destroy(){this.handle&&(this.removeStats(),this.device.gl.deleteShader(this.handle),this.destroyed=!0)}async getCompilationInfo(){return await this._waitForCompilationComplete(),this.getCompilationInfoSync()}getCompilationInfoSync(){let j=this.device.gl.getShaderInfoLog(this.handle);return cL(j)}getTranslatedSource(){return this.device.getExtension("WEBGL_debug_shaders").WEBGL_debug_shaders?.getTranslatedShaderSource(this.handle)}async _compile(j){j=(n=>n.startsWith("#version ")?n:`#version 100 -${n}`)(j);let{gl:r}=this.device;if(r.shaderSource(this.handle,j),r.compileShader(this.handle),mA.level===0){this.compilationStatus="pending";return}if(!this.device.features.has("compilation-status-async-webgl")){if(this._getCompilationStatus(),this.debugShader(),this.compilationStatus==="error")throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);return}mA.once(1,"Shader compilation is asynchronous")(),await this._waitForCompilationComplete(),mA.info(2,`Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)(),this._getCompilationStatus(),this.debugShader()}async _waitForCompilationComplete(){let j=async n=>await new Promise(i=>setTimeout(i,n));if(!this.device.features.has("compilation-status-async-webgl")){await j(10);return}let{gl:r}=this.device;for(;;){if(r.getShaderParameter(this.handle,37297))return;await j(10)}}_getCompilationStatus(){this.compilationStatus=this.device.gl.getShaderParameter(this.handle,35713)?"success":"error"}};var _6A=256,q6A=1024,G6A=16384,rF=6144,b6A=[1,2,4,8],H$=class extends Vd{constructor(j,e){super(j,e);I(this,"device");I(this,"glParameters");this.device=j,H7(this.device.gl),this.setParameters(this.props.parameters),this.clear()}end(){Ta(this.device.gl)}pushDebugGroup(j){}popDebugGroup(){}insertDebugMarker(j){}setParameters(j={}){let e={...this.glParameters};this.props.framebuffer&&(e.framebuffer=this.props.framebuffer),this.props.depthReadOnly&&(e.depthMask=!this.props.depthReadOnly),e.stencilMask=this.props.stencilReadOnly?0:1,e[35977]=this.props.discard,j.viewport&&(j.viewport.length>=6?(e.viewport=j.viewport.slice(0,4),e.depthRange=[j.viewport[4],j.viewport[5]]):e.viewport=j.viewport),j.scissorRect&&(e.scissorTest=!0,e.scissor=j.scissorRect),j.blendConstant&&(e.blendColor=j.blendConstant),j.stencilReference&&(console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL"),j[2967]=j.stencilReference),j.colorMask&&(e.colorMask=b6A.map(r=>!!(r&j.colorMask))),this.glParameters=e,$o(this.device.gl,e)}beginOcclusionQuery(j){this.props.occlusionQuerySet?.beginOcclusionQuery()}endOcclusionQuery(){this.props.occlusionQuerySet?.endOcclusionQuery()}clear(){let j={...this.glParameters},e=0;this.props.clearColor!==!1&&(e|=G6A,j.clearColor=this.props.clearColor),this.props.clearDepth!==!1&&(e|=_6A,j.clearDepth=this.props.clearDepth),this.props.clearStencil!==!1&&(e|=q6A,j.clearStencil=this.props.clearStencil),e!==0&&Fi(this.device.gl,j,()=>{this.device.gl.clear(e)})}clearColorBuffer(j=0,e=[0,0,0,0]){Fi(this.device.gl,{framebuffer:this.props.framebuffer},()=>{switch(e.constructor){case Int32Array:this.device.gl.clearBufferiv(rF,j,e);break;case Uint32Array:this.device.gl.clearBufferuiv(rF,j,e);break;case Float32Array:default:this.device.gl.clearBufferfv(rF,j,e);break}})}};var w6A="Failed to deduce GL constant from typed array";function uL(t){switch(ArrayBuffer.isView(t)?t.constructor:t){case Float32Array:return 5126;case Uint16Array:return 5123;case Uint32Array:return 5125;case Uint8Array:return 5121;case Uint8ClampedArray:return 5121;case Int8Array:return 5120;case Int16Array:return 5122;case Int32Array:return 5124;default:throw new Error(w6A)}}function Sp(t,A){let{clamped:j=!0}=A||{};switch(t){case 5126:return Float32Array;case 5123:case 33635:case 32819:case 32820:return Uint16Array;case 5125:return Uint32Array;case 5121:return j?Uint8ClampedArray:Uint8Array;case 5120:return Int8Array;case 5122:return Int16Array;case 5124:return Int32Array;default:throw new Error("Failed to deduce typed array type from GL constant")}}var F6A={offset:0,stride:0,type:5126,size:1,divisor:0,normalized:!1,integer:!1},P6A={deprecatedProps:{instanced:"divisor",isInstanced:"divisor"}},D$=class t{constructor(...A){I(this,"offset");I(this,"stride");I(this,"type");I(this,"size");I(this,"divisor");I(this,"normalized");I(this,"integer");I(this,"buffer");I(this,"index");A.forEach(j=>this._assign(j)),Object.freeze(this)}static getBytesPerElement(A){return Sp(A.type||5126).BYTES_PER_ELEMENT}static getBytesPerVertex(A){return Ot(A.size),Sp(A.type||5126).BYTES_PER_ELEMENT*A.size}static resolve(...A){return new t(F6A,...A)}toString(){return JSON.stringify(this)}get BYTES_PER_ELEMENT(){return t.getBytesPerElement(this)}get BYTES_PER_VERTEX(){return t.getBytesPerVertex(this)}_assign(A={}){return A=tb("Accessor",A,P6A),A.type!==void 0&&(this.type=A.type,(A.type===5124||A.type===5125)&&(this.integer=!0)),A.size!==void 0&&(this.size=A.size),A.offset!==void 0&&(this.offset=A.offset),A.stride!==void 0&&(this.stride=A.stride),A.normalize!==void 0&&(this.normalized=A.normalize),A.normalized!==void 0&&(this.normalized=A.normalized),A.integer!==void 0&&(this.integer=A.integer),A.divisor!==void 0&&(this.divisor=A.divisor),A.buffer!==void 0&&(this.buffer=A.buffer),A.index!==void 0&&(typeof A.index=="boolean"?this.index=A.index?1:0:this.index=A.index),A.instanced!==void 0&&(this.divisor=A.instanced?1:0),A.isInstanced!==void 0&&(this.divisor=A.isInstanced?1:0),this.offset===void 0&&delete this.offset,this.stride===void 0&&delete this.stride,this.type===void 0&&delete this.type,this.size===void 0&&delete this.size,this.divisor===void 0&&delete this.divisor,this.normalized===void 0&&delete this.normalized,this.integer===void 0&&delete this.integer,this.buffer===void 0&&delete this.buffer,this.index===void 0&&delete this.index,this}};function BL(t){return I6A.includes(t)}var I6A=[35678,35680,35679,35682,36289,36292,36293,36298,36299,36300,36303,36306,36307,36308,36311],fL={5126:[5126,1,"float","f32","float32"],35664:[5126,2,"vec2","vec2","float32x2"],35665:[5126,3,"vec3","vec3","float32x3"],35666:[5126,4,"vec4","vec4","float32x4"],5124:[5124,1,"int","i32","sint32"],35667:[5124,2,"ivec2","vec2","sint32x2"],35668:[5124,3,"ivec3","vec3","sint32x3"],35669:[5124,4,"ivec4","vec4","sint32x4"],5125:[5125,1,"uint","u32","uint32"],36294:[5125,2,"uvec2","vec2","uint32x2"],36295:[5125,3,"uvec3","vec3","uint32x3"],36296:[5125,4,"uvec4","vec4","uint32x4"],35670:[5126,1,"bool","f32","float32"],35671:[5126,2,"bvec2","vec2","float32x2"],35672:[5126,3,"bvec3","vec3","float32x3"],35673:[5126,4,"bvec4","vec4","float32x4"],35674:[5126,8,"mat2","mat2x2"],35685:[5126,8,"mat2x3","mat2x3"],35686:[5126,8,"mat2x4","mat2x4"],35687:[5126,12,"mat3x2","mat3x2"],35675:[5126,12,"mat3","mat3x3"],35688:[5126,12,"mat3x4","mat3x4"],35689:[5126,16,"mat4x2","mat4x2"],35690:[5126,16,"mat4x3","mat4x3"],35676:[5126,16,"mat4","mat4x4"]};function nF(t){let A=fL[t];if(!A)throw new Error("uniform");let[j,e,,r]=A;return{format:r,components:e,glType:j}}function hL(t){let A=fL[t];if(!A)throw new Error("attribute");let[,j,,e,r]=A;return{attributeType:e,vertexFormat:r,components:j}}function dL(t,A){let j={attributes:[],bindings:[]};j.attributes=M6A(t,A);let e=S6A(t,A);for(let o of e){let l=o.uniforms.map(c=>({name:c.name,format:c.format,byteOffset:c.byteOffset,byteStride:c.byteStride,arrayLength:c.arrayLength}));j.bindings.push({type:"uniform",name:o.name,location:o.location,visibility:(o.vertex?1:0)&(o.fragment?2:0),minBindingSize:o.byteLength,uniforms:l})}let r=T6A(t,A),n=0;for(let o of r)if(BL(o.type)){let{viewDimension:l,sampleType:c}=L6A(o.type);j.bindings.push({type:"texture",name:o.name,location:n,viewDimension:l,sampleType:c}),o.textureUnit=n,n+=1}r.length&&(j.uniforms=r);let i=O6A(t,A);return i?.length&&(j.varyings=i),j}function M6A(t,A){let j=[],e=t.getProgramParameter(A,35721);for(let r=0;r=0){let{attributeType:c}=hL(o),B=/instance/i.test(i)?"instance":"vertex";j.push({name:i,location:l,stepMode:B,type:c})}}return j.sort((r,n)=>r.location-n.location),j}function O6A(t,A){let j=[],e=t.getProgramParameter(A,35971);for(let r=0;rr.location-n.location),j}function T6A(t,A){let j=[],e=t.getProgramParameter(A,35718);for(let r=0;r1)for(let k=0;kt.getActiveUniformBlockParameter(A,n,i),e=[],r=t.getProgramParameter(A,35382);for(let n=0;nn.location-i.location),e}var R6A={35678:["2d","float"],35680:["cube","float"],35679:["3d","float"],35682:["3d","depth"],36289:["2d-array","float"],36292:["2d-array","depth"],36293:["cube","float"],36298:["2d","sint"],36299:["3d","sint"],36300:["cube","sint"],36303:["2d-array","uint"],36306:["2d","uint"],36307:["3d","uint"],36308:["cube","uint"],36311:["2d-array","uint"]};function L6A(t){let A=R6A[t];if(!A)throw new Error("sampler");let[j,e]=A;return{viewDimension:j,sampleType:e}}function C6A(t){if(t[t.length-1]!=="]")return{name:t,length:1,isArray:!1};let j=/([^[]*)(\[[0-9]+\])?/.exec(t);if(!j||j.length<2)throw new Error(`Failed to parse GLSL uniform name ${t}`);return{name:j[1],length:j[2]?1:0,isArray:!!j[2]}}function pL(t,A,j,e){let r=t,n=e;n===!0&&(n=1),n===!1&&(n=0);let i=typeof n=="number"?[n]:n;switch(j){case 35678:case 35680:case 35679:case 35682:case 36289:case 36292:case 36293:case 36298:case 36299:case 36300:case 36303:case 36306:case 36307:case 36308:case 36311:if(typeof e!="number")throw new Error("samplers must be set to integers");return t.uniform1i(A,e);case 5126:return t.uniform1fv(A,i);case 35664:return t.uniform2fv(A,i);case 35665:return t.uniform3fv(A,i);case 35666:return t.uniform4fv(A,i);case 5124:return t.uniform1iv(A,i);case 35667:return t.uniform2iv(A,i);case 35668:return t.uniform3iv(A,i);case 35669:return t.uniform4iv(A,i);case 35670:return t.uniform1iv(A,i);case 35671:return t.uniform2iv(A,i);case 35672:return t.uniform3iv(A,i);case 35673:return t.uniform4iv(A,i);case 5125:return r.uniform1uiv(A,i,1);case 36294:return r.uniform2uiv(A,i,2);case 36295:return r.uniform3uiv(A,i,3);case 36296:return r.uniform4uiv(A,i,4);case 35674:return t.uniformMatrix2fv(A,!1,i);case 35675:return t.uniformMatrix3fv(A,!1,i);case 35676:return t.uniformMatrix4fv(A,!1,i);case 35685:return r.uniformMatrix2x3fv(A,!1,i);case 35686:return r.uniformMatrix2x4fv(A,!1,i);case 35687:return r.uniformMatrix3x2fv(A,!1,i);case 35688:return r.uniformMatrix3x4fv(A,!1,i);case 35689:return r.uniformMatrix4x2fv(A,!1,i);case 35690:return r.uniformMatrix4x3fv(A,!1,i)}throw new Error("Illegal uniform")}function kL(t){switch(t){case"point-list":return 0;case"line-list":return 1;case"line-strip":return 3;case"line-loop-webgl":return 2;case"triangle-list":return 4;case"triangle-strip":return 5;case"triangle-fan-webgl":return 6;default:throw new Error(t)}}function gL(t){switch(t){case"point-list":return 0;case"line-list":return 1;case"line-strip":return 1;case"line-loop-webgl":return 1;case"triangle-list":return 4;case"triangle-strip":return 4;case"triangle-fan-webgl":return 4;default:throw new Error(t)}}var mL=4,N$=class extends rs{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"vs");I(this,"fs");I(this,"introspectedLayout");I(this,"uniforms",{});I(this,"bindings",{});I(this,"varyings",null);I(this,"_uniformCount",0);I(this,"_uniformSetters",{});this.device=j,this.handle=this.props.handle||this.device.gl.createProgram(),this.device.setSpectorMetadata(this.handle,{id:this.props.id}),this.vs=e.vs,this.fs=e.fs;let{varyings:r,bufferMode:n=35981}=e;switch(r&&r.length>0&&(this.varyings=r,this.device.gl.transformFeedbackVaryings(this.handle,r,n)),this._linkShaders(),mA.time(1,`RenderPipeline ${this.id} - shaderLayout introspection`)(),this.introspectedLayout=dL(this.device.gl,this.handle),mA.timeEnd(1,`RenderPipeline ${this.id} - shaderLayout introspection`)(),this.shaderLayout=YG(this.introspectedLayout,e.shaderLayout),this.props.topology){case"triangle-fan-webgl":case"line-loop-webgl":mA.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);break;default:}}destroy(){this.handle&&(this.device.gl.deleteProgram(this.handle),this.destroyed=!0)}setBindings(j,e){for(let[r,n]of Object.entries(j)){let i=this.shaderLayout.bindings.find(o=>o.name===r)||this.shaderLayout.bindings.find(o=>o.name===`${r}Uniforms`);if(!i){let o=this.shaderLayout.bindings.map(l=>`"${l.name}"`).join(", ");e?.disableWarnings||mA.warn(`Unknown binding "${r}" in render pipeline "${this.id}", expected one of ${o}`)();continue}switch(n||mA.warn(`Unsetting binding "${r}" in render pipeline "${this.id}"`)(),i.type){case"uniform":if(!(n instanceof Mn)&&!(n.buffer instanceof Mn))throw new Error("buffer value");break;case"texture":if(!(n instanceof xo||n instanceof _6||n instanceof hs))throw new Error("texture value");break;case"sampler":mA.warn(`Ignoring sampler ${r}`)();break;default:throw new Error(i.type)}this.bindings[r]=n}}draw(j){let{renderPass:e,parameters:r=this.props.parameters,topology:n=this.props.topology,vertexArray:i,vertexCount:o,instanceCount:l,isInstanced:c=!1,firstVertex:B=0,transformFeedback:h}=j,d=kL(n),k=!!i.indexBuffer,g=i.indexBuffer?.glIndexType;if(this.linkStatus!=="success")return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)(),!1;if(!this._areTexturesRenderable()||o===0)return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)(),!1;if(o===0)return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)(),!0;this.device.gl.useProgram(this.handle),i.bindBeforeRender(e),h&&h.begin(this.props.topology),this._applyBindings(),this._applyUniforms();let E=e;return jL(this.device,r,E.glParameters,()=>{k&&c?this.device.gl.drawElementsInstanced(d,o||0,g,B,l||0):k?this.device.gl.drawElements(d,o||0,g,B):c?this.device.gl.drawArraysInstanced(d,B,o||0,l||0):this.device.gl.drawArrays(d,B,o||0),h&&h.end()}),i.unbindAfterRender(e),!0}setUniformsWebGL(j){let{bindings:e}=pc(j);Object.keys(e).forEach(r=>{mA.warn(`Unsupported value "${JSON.stringify(e[r])}" used in setUniforms() for key ${r}. Use setBindings() instead?`)()}),Object.assign(this.uniforms,j)}async _linkShaders(){let{gl:j}=this.device;if(j.attachShader(this.handle,this.vs.handle),j.attachShader(this.handle,this.fs.handle),mA.time(mL,`linkProgram for ${this.id}`)(),j.linkProgram(this.handle),mA.timeEnd(mL,`linkProgram for ${this.id}`)(),mA.level,!this.device.features.has("compilation-status-async-webgl")){let r=this._getLinkStatus();this._reportLinkStatus(r);return}mA.once(1,"RenderPipeline linking is asynchronous")(),await this._waitForLinkComplete(),mA.info(2,`RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();let e=this._getLinkStatus();this._reportLinkStatus(e)}_reportLinkStatus(j){switch(j){case"success":return;default:throw this.vs.compilationStatus==="error"?(this.vs.debugShader(),new Error(`Error during compilation of shader ${this.vs.id}`)):this.fs?.compilationStatus==="error"?(this.fs.debugShader(),new Error(`Error during compilation of shader ${this.fs.id}`)):new Error(`Error during ${j}: ${this.device.gl.getProgramInfoLog(this.handle)}`)}}_getLinkStatus(){let{gl:j}=this.device;return j.getProgramParameter(this.handle,35714)?(j.validateProgram(this.handle),j.getProgramParameter(this.handle,35715)?(this.linkStatus="success","success"):(this.linkStatus="error","validation")):(this.linkStatus="error","linking")}async _waitForLinkComplete(){let j=async n=>await new Promise(i=>setTimeout(i,n));if(!this.device.features.has("compilation-status-async-webgl")){await j(10);return}let{gl:r}=this.device;for(;;){if(r.getProgramParameter(this.handle,37297))return;await j(10)}}_areTexturesRenderable(){let j=!0;for(let[,e]of Object.entries(this.bindings))e instanceof _6&&(e.update(),j=j&&e.loaded);return j}_applyBindings(){if(this.linkStatus!=="success")return;let{gl:j}=this.device;j.useProgram(this.handle);let e=0,r=0;for(let n of this.shaderLayout.bindings){let i=this.bindings[n.name]||this.bindings[n.name.replace(/Uniforms$/,"")];if(!i)throw new Error(`No value for binding ${n.name} in ${this.id}`);switch(n.type){case"uniform":let{name:o}=n,l=j.getUniformBlockIndex(this.handle,o);if(l===4294967295)throw new Error(`Invalid uniform block name ${o}`);j.uniformBlockBinding(this.handle,r,l),i instanceof Mn?j.bindBufferBase(35345,r,i.handle):j.bindBufferRange(35345,r,i.buffer.handle,i.offset||0,i.size||i.buffer.byteLength-i.offset),r+=1;break;case"texture":if(!(i instanceof xo||i instanceof _6||i instanceof hs))throw new Error("texture");let c;if(i instanceof xo)c=i.texture;else if(i instanceof _6)c=i;else if(i instanceof hs&&i.colorAttachments[0]instanceof xo)mA.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")(),c=i.colorAttachments[0].texture;else throw new Error("No texture");j.activeTexture(33984+e),j.bindTexture(c.target,c.handle),e+=1;break;case"sampler":break;case"storage":case"read-only-storage":throw new Error(`binding type '${n.type}' not supported in WebGL`)}}}_applyUniforms(){for(let j of this.shaderLayout.uniforms||[]){let{name:e,location:r,type:n,textureUnit:i}=j,o=this.uniforms[e]??i;o!==void 0&&pL(this.device.gl,r,n,o)}}};var K$=class extends Wd{constructor(j){super(j,{});I(this,"device");I(this,"commands",[]);this.device=j}submitCommands(j=this.commands){for(let e of j)switch(e.name){case"copy-buffer-to-buffer":H6A(this.device,e.options);break;case"copy-buffer-to-texture":D6A(this.device,e.options);break;case"copy-texture-to-buffer":N6A(this.device,e.options);break;case"copy-texture-to-texture":K6A(this.device,e.options);break}}};function H6A(t,A){let j=A.source,e=A.destination;t.gl.bindBuffer(36662,j.handle),t.gl.bindBuffer(36663,e.handle),t.gl.copyBufferSubData(36662,36663,A.sourceOffset??0,A.destinationOffset??0,A.size),t.gl.bindBuffer(36662,null),t.gl.bindBuffer(36663,null)}function D6A(t,A){throw new Error("Not implemented")}function N6A(t,A){let{source:j,mipLevel:e=0,aspect:r="all",width:n=A.source.width,height:i=A.source.height,depthOrArrayLayers:o=0,origin:l=[0,0],destination:c,byteOffset:B=0,bytesPerRow:h,rowsPerImage:d}=A;if(r!=="all")throw new Error("not supported");if(e!==0||o!==0||h||d)throw new Error("not implemented");let{framebuffer:k,destroyFramebuffer:g}=EL(j),E;try{let m=c,y=n||k.width,b=i||k.height,v=SB(k.texture.props.format),_=v.dataFormat,w=v.type;t.gl.bindBuffer(35051,m.handle),E=t.gl.bindFramebuffer(36160,k.handle),t.gl.readPixels(l[0],l[1],y,b,_,w,B)}finally{t.gl.bindBuffer(35051,null),E!==void 0&&t.gl.bindFramebuffer(36160,E),g&&k.destroy()}}function K6A(t,A){let{source:j,destinationMipLevel:e=0,origin:r=[0,0],destinationOrigin:n=[0,0],destination:i}=A,{width:o=A.destination.width,height:l=A.destination.height}=A,{framebuffer:c,destroyFramebuffer:B}=EL(j),[h,d]=r,[k,g,E]=n,m=t.gl.bindFramebuffer(36160,c.handle),y=null,b;if(i instanceof _6)y=i,o=Number.isFinite(o)?o:y.width,l=Number.isFinite(l)?l:y.height,y.bind(0),b=y.target;else throw new Error("invalid destination");switch(b){case 3553:case 34067:t.gl.copyTexSubImage2D(b,e,k,g,h,d,o,l);break;case 35866:case 32879:t.gl.copyTexSubImage3D(b,e,k,g,E,h,d,o,l);break;default:}y&&y.unbind(),t.gl.bindFramebuffer(36160,m),B&&c.destroy()}function EL(t){if(t instanceof Ne){let{width:A,height:j,id:e}=t;return{framebuffer:t.device.createFramebuffer({id:`framebuffer-for-${e}`,width:A,height:j,colorAttachments:[t]}),destroyFramebuffer:!0}}return{framebuffer:t,destroyFramebuffer:!1}}var X$=class extends Qd{constructor(j,e){super(j,e);I(this,"device");I(this,"commandBuffer");this.device=j,this.commandBuffer=new K$(j)}destroy(){}finish(){this.commandBuffer.submitCommands()}copyBufferToBuffer(j){this.commandBuffer.commands.push({name:"copy-buffer-to-buffer",options:j})}copyBufferToTexture(j){this.commandBuffer.commands.push({name:"copy-buffer-to-texture",options:j})}copyTextureToBuffer(j){this.commandBuffer.commands.push({name:"copy-texture-to-buffer",options:j})}copyTextureToTexture(j){this.commandBuffer.commands.push({name:"copy-texture-to-texture",options:j})}pushDebugGroup(j){}popDebugGroup(){}insertDebugMarker(j){}resolveQuerySet(j,e,r){}};var z$=class t extends Yd{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"buffer",null);I(this,"bufferValue",null);this.device=j,this.handle=this.device.gl.createVertexArray()}get[Symbol.toStringTag](){return"VertexArray"}static isConstantAttributeZeroSupported(j){return tG()==="Chrome"}destroy(){super.destroy(),this.buffer&&this.buffer?.destroy(),this.handle&&(this.device.gl.deleteVertexArray(this.handle),this.handle=void 0)}setIndexBuffer(j){let e=j;if(e&&e.glTarget!==34963)throw new Error("Use .setBuffer()");this.device.gl.bindVertexArray(this.handle),this.device.gl.bindBuffer(34963,e?e.handle:null),this.indexBuffer=e,this.device.gl.bindVertexArray(null)}setBuffer(j,e){let r=e;if(r.glTarget===34963)throw new Error("Use .setIndexBuffer()");let{size:n,type:i,stride:o,offset:l,normalized:c,integer:B,divisor:h}=this._getAccessor(j);this.device.gl.bindVertexArray(this.handle),this.device.gl.bindBuffer(34962,r.handle),B?this.device.gl.vertexAttribIPointer(j,n,i,o,l):this.device.gl.vertexAttribPointer(j,n,i,c,o,l),this.device.gl.bindBuffer(34962,null),this.device.gl.enableVertexAttribArray(j),this.device.gl.vertexAttribDivisor(j,h||0),this.attributes[j]=r,this.device.gl.bindVertexArray(null)}setConstantWebGL(j,e){this._enable(j,!1),this.attributes[j]=e}bindBeforeRender(){this.device.gl.bindVertexArray(this.handle),this._applyConstantAttributes()}unbindAfterRender(){this.device.gl.bindVertexArray(null)}_applyConstantAttributes(){for(let j=0;j{for(let e in j)this.setBuffer(e,j[e])})}setBuffer(j,e){let r=this._getVaryingIndex(j),{buffer:n,byteLength:i,byteOffset:o}=this._getBufferRange(e);if(r<0){this.unusedBuffers[j]=n,mA.warn(`${this.id} unusedBuffers varying buffer ${j}`)();return}this.buffers[r]={buffer:n,byteLength:i,byteOffset:o},this.bindOnUse||this._bindBuffer(r,n,o,i)}getBuffer(j){if($L(j))return this.buffers[j]||null;let e=this._getVaryingIndex(j);return e>=0?this.buffers[e]:null}bind(j=this.handle){if(typeof j!="function")return this.gl.bindTransformFeedback(36386,j),this;let e;return this._bound?e=j():(this.gl.bindTransformFeedback(36386,this.handle),this._bound=!0,e=j(),this._bound=!1,this.gl.bindTransformFeedback(36386,null)),e}unbind(){this.bind(null)}_getBufferRange(j){if(j instanceof Mn)return{buffer:j,byteOffset:0,byteLength:j.byteLength};let{buffer:e,byteOffset:r=0,byteLength:n=j.buffer.byteLength}=j;return{buffer:e,byteOffset:r,byteLength:n}}_getVaryingIndex(j){if($L(j))return Number(j);for(let e of this.layout.varyings)if(j===e.name)return e.location;return-1}_bindBuffers(){for(let j in this.buffers){let{buffer:e,byteLength:r,byteOffset:n}=this._getBufferRange(this.buffers[j]);this._bindBuffer(Number(j),e,n,r)}}_unbindBuffers(){for(let j in this.buffers)this.gl.bindBufferBase(35982,Number(j),null)}_bindBuffer(j,e,r=0,n){let i=e&&e.handle;!i||n===void 0?this.gl.bindBufferBase(35982,j,i):this.gl.bindBufferRange(35982,j,i,r,n)}};function $L(t){return typeof t=="number"?Number.isInteger(t):/^\d+$/.test(t)}var V$=class extends Zd{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"target",null);I(this,"_queryPending",!1);I(this,"_pollingPromise",null);if(this.device=j,e.count>1)throw new Error("WebGL QuerySet can only have one value");this.handle=this.device.gl.createQuery(),Object.seal(this)}get[Symbol.toStringTag](){return"Query"}destroy(){this.device.gl.deleteQuery(this.handle)}beginTimestampQuery(){return this._begin(35007)}endTimestampQuery(){this._end()}beginOcclusionQuery(j){return this._begin(j?.conservative?36202:35887)}endOcclusionQuery(){this._end()}beginTransformFeedbackQuery(){return this._begin(35976)}endTransformFeedbackQuery(){this._end()}async resolveQuery(){return[await this.pollQuery()]}_begin(j){this._queryPending||(this.target=j,this.device.gl.beginQuery(this.target,this.handle))}_end(){this._queryPending||this.target&&(this.device.gl.endQuery(this.target),this.target=null,this._queryPending=!0)}isResultAvailable(){if(!this._queryPending)return!1;let j=this.device.gl.getQueryParameter(this.handle,34919);return j&&(this._queryPending=!1),j}isTimerDisjoint(){return this.device.gl.getParameter(36795)}getResult(){return this.device.gl.getQueryParameter(this.handle,34918)}getTimerMilliseconds(){return this.getResult()/1e6}pollQuery(j=Number.POSITIVE_INFINITY){if(this._pollingPromise)return this._pollingPromise;let e=0;return this._pollingPromise=new Promise((r,n)=>{let i=()=>{this.isResultAvailable()?(r(this.getResult()),this._pollingPromise=null):e++>j?(n("Timed out"),this._pollingPromise=null):requestAnimationFrame(i)};requestAnimationFrame(i)}),this._pollingPromise}};function iF(t){switch(t){case 6406:case 33326:case 6403:return 1;case 33328:case 33319:return 2;case 6407:case 34837:return 3;case 6408:case 34836:return 4;default:return Ot(!1),0}}function xL(t){switch(t){case 5121:return 1;case 33635:case 32819:case 32820:return 2;case 5126:return 4;default:return Ot(!1),0}}function yL(t,A){let{sourceX:j=0,sourceY:e=0,sourceFormat:r=6408,sourceAttachment:n=36064}=A||{},{target:i=null,sourceWidth:o,sourceHeight:l,sourceType:c}=A||{},{framebuffer:B,deleteFramebuffer:h}=_L(t);Ot(B);let{gl:d,handle:k}=B;o=o||B.width,l=l||B.height;let g=n-36064;c=c||B.colorAttachments[g]?.texture?.type||5121,i=V6A(i,c,r,o,l),c=c||uL(i);let E=d.bindFramebuffer(36160,k);return d.readPixels(j,e,o,l,r,c,i),d.bindFramebuffer(36160,E||null),h&&B.destroy(),i}function vL(t,A){let{target:j,sourceX:e=0,sourceY:r=0,sourceFormat:n=6408,targetByteOffset:i=0}=A||{},{sourceWidth:o,sourceHeight:l,sourceType:c}=A||{},{framebuffer:B,deleteFramebuffer:h}=_L(t);Ot(B),o=o||B.width,l=l||B.height;let d=B;c=c||5121;let k=j;if(!k){let E=iF(n),m=xL(c),y=i+o*l*E*m;k=d.device.createBuffer({byteLength:y})}let g=t.device.createCommandEncoder();return g.copyTextureToBuffer({source:t,width:o,height:l,origin:[e,r],destination:k,byteOffset:i}),g.destroy(),h&&B.destroy(),k}function _L(t){return t instanceof dc?{framebuffer:t,deleteFramebuffer:!1}:{framebuffer:U6A(t),deleteFramebuffer:!0}}function U6A(t,A){let{device:j,width:e,height:r,id:n}=t;return j.createFramebuffer({...A,id:`framebuffer-for-${n}`,width:e,height:r,colorAttachments:[t]})}function V6A(t,A,j,e,r){if(t)return t;A=A||5121;let n=Sp(A,{clamped:!1}),i=iF(j);return new n(e*r*i)}var Q6A=256,W6A=1024,Y6A=16384;var J6A="clear: bad arguments";function qL(t,A){let{framebuffer:j=null,color:e=null,depth:r=null,stencil:n=null}=A||{},i={};j&&(i.framebuffer=j);let o=0;e&&(o|=Y6A,e!==!0&&(i.clearColor=e)),r&&(o|=Q6A,r!==!0&&(i.clearDepth=r)),n&&(o|=W6A,r!==!0&&(i.clearStencil=r)),Ot(o!==0,J6A);let l=t.gl;Fi(l,i,()=>{l.clear(o)})}var Rp=1,wc=class wc extends xa{constructor(j){super({...j,id:j.id||Pn("webgl-device")});I(this,"type","webgl");I(this,"handle");I(this,"features");I(this,"limits");I(this,"info");I(this,"canvasContext");I(this,"lost");I(this,"_resolveContextLost");I(this,"renderPass",null);I(this,"gl");I(this,"debug",!1);I(this,"_canvasSizeInfo",{clientWidth:0,clientHeight:0,devicePixelRatio:1});I(this,"_extensions",{});I(this,"_polyfilled",!1);I(this,"spectorJS");I(this,"_constants");let e=j.gl?.device;if(e)throw new Error(`WebGL context already attached to device ${e.id}`);let r=j.gl?.canvas||j.canvas;this.canvasContext=new L$(this,{...j,canvas:r}),this.lost=new Promise(l=>{this._resolveContextLost=l});let n=j.gl||null;if(n||(n=NR(this.canvasContext.canvas,{...j,onContextLost:l=>this._resolveContextLost?.({reason:"destroyed",message:"Entered sleep mode, or too many apps or browser tabs are using the GPU."})})),!n)throw new Error("WebGL context creation failed");this.handle=n,this.gl=n,this.gl.device=this,this.gl._version=2,j.spector&&(this.spectorJS=iL({...this.props,canvas:this.handle.canvas})),this.info=KR(this.gl,this._extensions),this.limits=new O$(this.gl),this.features=new M$(this.gl,this._extensions,this.props.disabledFeatures),this.props.initalizeFeatures&&this.features.initializeFeatures(),this.canvasContext.resize();let{enable:i=!0,copyState:o=!1}=j;Vw(this.gl,{enable:i,copyState:o,log:(...l)=>mA.log(1,...l)()}),j.debug&&(this.gl=aL(this.gl,{...j,throwOnError:!0}),this.debug=!0,mA.level=Math.max(mA.level,1),mA.warn("WebGL debug mode activated. Performance reduced.")())}static isSupported(){return typeof WebGL2RenderingContext<"u"}static attach(j){if(j instanceof wc)return j;if(j?.device instanceof xa)return j.device;if(!Z6A(j))throw new Error("Invalid WebGL2RenderingContext");return new wc({gl:j})}static async create(j={}){mA.groupCollapsed(Rp,"WebGLDevice created")();let e=[];j.debug&&e.push(sL()),j.spector&&e.push(nL()),typeof j.canvas=="string"&&e.push(b7.pageLoaded);let r=await Promise.allSettled(e);for(let o of r)o.status==="rejected"&&mA.error(`Failed to initialize debug libraries ${o.reason}`)();if(mA.probe(Rp+1,"DOM is loaded")(),j.gl?.device)return mA.warn("reattaching existing device")(),wc.attach(j.gl);let n=new wc(j),i=`Created ${n.type}${n.debug?" debug":""} context: ${n.info.vendor}, ${n.info.renderer} for canvas: ${n.canvasContext.id}`;return mA.probe(Rp,i)(),mA.table(Rp,n.info)(),mA.groupEnd(Rp)(),n}destroy(){}get isLost(){return this.gl.isContextLost()}getSize(){return[this.gl.drawingBufferWidth,this.gl.drawingBufferHeight]}isTextureFormatSupported(j){return I$(this.gl,j,this._extensions)}isTextureFormatFilterable(j){return YR(this.gl,j,this._extensions)}isTextureFormatRenderable(j){return JR(this.gl,j,this._extensions)}createCanvasContext(j){throw new Error("WebGL only supports a single canvas")}createBuffer(j){let e=this._getBufferProps(j);return new Mn(this,e)}_createTexture(j){return new _6(this,j)}createExternalTexture(j){throw new Error("createExternalTexture() not implemented")}createSampler(j){return new bc(this,j)}createShader(j){return new C$(this,j)}createFramebuffer(j){return new hs(this,j)}createVertexArray(j){return new z$(this,j)}createTransformFeedback(j){return new U$(this,j)}createQuerySet(j){return new V$(this,j)}createRenderPipeline(j){return new N$(this,j)}beginRenderPass(j){return new H$(this,j)}createComputePipeline(j){throw new Error("ComputePipeline not supported in WebGL")}beginComputePass(j){throw new Error("ComputePass not supported in WebGL")}createCommandEncoder(j){return new X$(this,j)}submit(){this.renderPass?.end(),this.renderPass=null}readPixelsToArrayWebGL(j,e){return yL(j,e)}readPixelsToBufferWebGL(j,e){return vL(j,e)}setParametersWebGL(j){$o(this.gl,j)}getParametersWebGL(j){return q$(this.gl,j)}withParametersWebGL(j,e){return Fi(this.gl,j,e)}clearWebGL(j){qL(this,j)}resetWebGL(){mA.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")(),CR(this.gl)}loseDevice(){let j=!1,r=this.getExtension("WEBGL_lose_context").WEBGL_lose_context;return r&&(j=!0,r.loseContext()),this._resolveContextLost?.({reason:"destroyed",message:"Application triggered context loss"}),j}pushState(){H7(this.gl)}popState(){Ta(this.gl)}setSpectorMetadata(j,e){j.__SPECTOR_Metadata=e}getGLKey(j,e){e=e||this.gl2||this.gl;let r=Number(j);for(let n in e)if(e[n]===r)return`GL.${n}`;return String(j)}setConstantAttributeWebGL(j,e){let r=this.limits.maxVertexAttributes;this._constants=this._constants||new Array(r).fill(null);let n=this._constants[j];switch(n&&eiA(n,e)&&mA.info(1,`setConstantAttributeWebGL(${j}) could have been skipped, value unchanged`)(),this._constants[j]=e,e.constructor){case Float32Array:AiA(this,j,e);break;case Int32Array:tiA(this,j,e);break;case Uint32Array:jiA(this,j,e);break;default:Ot(!1)}}getExtension(j){return wi(this.gl,j,this._extensions),this._extensions}};I(wc,"type","webgl");var Fc=wc;function Z6A(t){return typeof WebGL2RenderingContext<"u"&&t instanceof WebGL2RenderingContext?!0:!!(t&&Number.isFinite(t._version))}function AiA(t,A,j){switch(j.length){case 1:t.gl.vertexAttrib1fv(A,j);break;case 2:t.gl.vertexAttrib2fv(A,j);break;case 3:t.gl.vertexAttrib3fv(A,j);break;case 4:t.gl.vertexAttrib4fv(A,j);break;default:Ot(!1)}}function tiA(t,A,j){t.gl.vertexAttribI4iv(A,j)}function jiA(t,A,j){t.gl.vertexAttribI4uiv(A,j)}function eiA(t,A){if(!t||!A||t.length!==A.length||t.constructor!==A.constructor)return!1;for(let j=0;j0&&e.type==="pointerdown"&&(niA(r,n=>n.pointerId===e.pointerId)||r.push(e)),A.call(this,e)}}function wL(t){t.prototype.handler=function(j){let e=riA[j.type];e&1&&j.button>=0&&(this.pressed=!0),e&2&&j.which===0&&(e=4),this.pressed&&(e&4&&(this.pressed=!1),this.callback(this.manager,e,{pointers:[j],changedPointers:[j],pointerType:"mouse",srcEvent:j}))}}bL(Pc.PointerEventInput);wL(Pc.MouseInput);var FL=Pc.Manager,yo=Pc;var vo=class{constructor(A,j,e){this.element=A,this.callback=j,this.options={enable:!0,...e}}};var PL=yo?[[yo.Pan,{event:"tripan",pointers:3,threshold:0,enable:!1}],[yo.Rotate,{enable:!1}],[yo.Pinch,{enable:!1}],[yo.Swipe,{enable:!1}],[yo.Pan,{threshold:0,enable:!1}],[yo.Press,{enable:!1}],[yo.Tap,{event:"doubletap",taps:2,enable:!1}],[yo.Tap,{event:"anytap",enable:!1}],[yo.Tap,{enable:!1}]]:null,oF={tripan:["rotate","pinch","pan"],rotate:["pinch"],pinch:["pan"],pan:["press","doubletap","anytap","tap"],doubletap:["anytap"],anytap:["tap"]},IL={doubletap:["tap"]},ML={pointerdown:"pointerdown",pointermove:"pointermove",pointerup:"pointerup",touchstart:"pointerdown",touchmove:"pointermove",touchend:"pointerup",mousedown:"pointerdown",mousemove:"pointermove",mouseup:"pointerup"},RB={KEY_EVENTS:["keydown","keyup"],MOUSE_EVENTS:["mousedown","mousemove","mouseup","mouseover","mouseout","mouseleave"],WHEEL_EVENTS:["wheel","mousewheel"]},OL={tap:"tap",anytap:"anytap",doubletap:"doubletap",press:"press",pinch:"pinch",pinchin:"pinch",pinchout:"pinch",pinchstart:"pinch",pinchmove:"pinch",pinchend:"pinch",pinchcancel:"pinch",rotate:"rotate",rotatestart:"rotate",rotatemove:"rotate",rotateend:"rotate",rotatecancel:"rotate",tripan:"tripan",tripanstart:"tripan",tripanmove:"tripan",tripanup:"tripan",tripandown:"tripan",tripanleft:"tripan",tripanright:"tripan",tripanend:"tripan",tripancancel:"tripan",pan:"pan",panstart:"pan",panmove:"pan",panup:"pan",pandown:"pan",panleft:"pan",panright:"pan",panend:"pan",pancancel:"pan",swipe:"swipe",swipeleft:"swipe",swiperight:"swipe",swipeup:"swipe",swipedown:"swipe"},sF={click:"tap",anyclick:"anytap",dblclick:"doubletap",mousedown:"pointerdown",mousemove:"pointermove",mouseup:"pointerup",mouseover:"pointerover",mouseout:"pointerout",mouseleave:"pointerleave"};var TL=typeof navigator<"u"&&navigator.userAgent?navigator.userAgent.toLowerCase():"",Ic=typeof window<"u"?window:global;var W$=!1;try{let t={get passive(){return W$=!0,!0}};Ic.addEventListener("test",null,t),Ic.removeEventListener("test",null)}catch{W$=!1}var iiA=TL.indexOf("firefox")!==-1,{WHEEL_EVENTS:oiA}=RB,SL="wheel",RL=4.000244140625,siA=40,aiA=.25,Lp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{if(!this.options.enable)return;let n=r.deltaY;Ic.WheelEvent&&(iiA&&r.deltaMode===Ic.WheelEvent.DOM_DELTA_PIXEL&&(n/=Ic.devicePixelRatio),r.deltaMode===Ic.WheelEvent.DOM_DELTA_LINE&&(n*=siA)),n!==0&&n%RL===0&&(n=Math.floor(n/RL)),r.shiftKey&&n&&(n=n*aiA),this.callback({type:SL,center:{x:r.clientX,y:r.clientY},delta:-n,srcEvent:r,pointerType:"mouse",target:r.target})},this.events=(this.options.events||[]).concat(oiA),this.events.forEach(r=>A.addEventListener(r,this.handleEvent,W$?{passive:!1}:!1))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===SL&&(this.options.enable=j)}};var{MOUSE_EVENTS:liA}=RB,LL="pointermove",CL="pointerover",HL="pointerout",DL="pointerenter",NL="pointerleave",Cp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=n=>{this.handleOverEvent(n),this.handleOutEvent(n),this.handleEnterEvent(n),this.handleLeaveEvent(n),this.handleMoveEvent(n)},this.pressed=!1;let{enable:r}=this.options;this.enableMoveEvent=r,this.enableLeaveEvent=r,this.enableEnterEvent=r,this.enableOutEvent=r,this.enableOverEvent=r,this.events=(this.options.events||[]).concat(liA),this.events.forEach(n=>A.addEventListener(n,this.handleEvent))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===LL&&(this.enableMoveEvent=j),A===CL&&(this.enableOverEvent=j),A===HL&&(this.enableOutEvent=j),A===DL&&(this.enableEnterEvent=j),A===NL&&(this.enableLeaveEvent=j)}handleOverEvent(A){this.enableOverEvent&&A.type==="mouseover"&&this._emit(CL,A)}handleOutEvent(A){this.enableOutEvent&&A.type==="mouseout"&&this._emit(HL,A)}handleEnterEvent(A){this.enableEnterEvent&&A.type==="mouseenter"&&this._emit(DL,A)}handleLeaveEvent(A){this.enableLeaveEvent&&A.type==="mouseleave"&&this._emit(NL,A)}handleMoveEvent(A){if(this.enableMoveEvent)switch(A.type){case"mousedown":A.button>=0&&(this.pressed=!0);break;case"mousemove":A.which===0&&(this.pressed=!1),this.pressed||this._emit(LL,A);break;case"mouseup":this.pressed=!1;break;default:}}_emit(A,j){this.callback({type:A,center:{x:j.clientX,y:j.clientY},srcEvent:j,pointerType:"mouse",target:j.target})}};var{KEY_EVENTS:ciA}=RB,KL="keydown",XL="keyup",Hp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{let n=r.target||r.srcElement;n.tagName==="INPUT"&&n.type==="text"||n.tagName==="TEXTAREA"||(this.enableDownEvent&&r.type==="keydown"&&this.callback({type:KL,srcEvent:r,key:r.key,target:r.target}),this.enableUpEvent&&r.type==="keyup"&&this.callback({type:XL,srcEvent:r,key:r.key,target:r.target}))},this.enableDownEvent=this.options.enable,this.enableUpEvent=this.options.enable,this.events=(this.options.events||[]).concat(ciA),A.tabIndex=this.options.tabIndex||0,A.style.outline="none",this.events.forEach(r=>A.addEventListener(r,this.handleEvent))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===KL&&(this.enableDownEvent=j),A===XL&&(this.enableUpEvent=j)}};var zL="contextmenu",Dp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{this.options.enable&&this.callback({type:zL,center:{x:r.clientX,y:r.clientY},srcEvent:r,pointerType:"mouse",target:r.target})},A.addEventListener("contextmenu",this.handleEvent)}destroy(){this.element.removeEventListener("contextmenu",this.handleEvent)}enableEventType(A,j){A===zL&&(this.options.enable=j)}};var uiA={pointerdown:1,pointermove:2,pointerup:4,mousedown:1,mousemove:2,mouseup:4},BiA=1,fiA=2,hiA=3,diA=0,piA=1,kiA=2,giA=1,miA=2,EiA=4;function UL(t){let A=uiA[t.srcEvent.type];if(!A)return null;let{buttons:j,button:e,which:r}=t.srcEvent,n=!1,i=!1,o=!1;return A===4||A===2&&!Number.isFinite(j)?(n=r===BiA,i=r===fiA,o=r===hiA):A===2?(n=!!(j&giA),i=!!(j&EiA),o=!!(j&miA)):A===1&&(n=e===diA,i=e===piA,o=e===kiA),{leftButton:n,middleButton:i,rightButton:o}}function VL(t,A){let j=t.center;if(!j)return null;let e=A.getBoundingClientRect(),r=e.width/A.offsetWidth||1,n=e.height/A.offsetHeight||1,i={x:(j.x-e.left-A.clientLeft)/r,y:(j.y-e.top-A.clientTop)/n};return{center:j,offsetCenter:i}}var aF={srcElement:"root",priority:0},Np=class{constructor(A){this.handleEvent=j=>{if(this.isEmpty())return;let e=this._normalizeEvent(j),r=j.srcEvent.target;for(;r&&r!==e.rootElement;){if(this._emit(e,r),e.handled)return;r=r.parentNode}this._emit(e,"root")},this.eventManager=A,this.handlers=[],this.handlersByElement=new Map,this._active=!1}isEmpty(){return!this._active}add(A,j,e,r=!1,n=!1){let{handlers:i,handlersByElement:o}=this,l=aF;typeof e=="string"||e&&e.addEventListener?l={...aF,srcElement:e}:e&&(l={...aF,...e});let c=o.get(l.srcElement);c||(c=[],o.set(l.srcElement,c));let B={type:A,handler:j,srcElement:l.srcElement,priority:l.priority};r&&(B.once=!0),n&&(B.passive=!0),i.push(B),this._active=this._active||!B.passive;let h=c.length-1;for(;h>=0&&!(c[h].priority>=B.priority);)h--;c.splice(h+1,0,B)}remove(A,j){let{handlers:e,handlersByElement:r}=this;for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.type===A&&i.handler===j){e.splice(n,1);let o=r.get(i.srcElement);o.splice(o.indexOf(i),1),o.length===0&&r.delete(i.srcElement)}}this._active=e.some(n=>!n.passive)}_emit(A,j){let e=this.handlersByElement.get(j);if(e){let r=!1,n=()=>{A.handled=!0},i=()=>{A.handled=!0,r=!0},o=[];for(let l=0;l{A.srcEvent.preventDefault()},stopImmediatePropagation:null,stopPropagation:null,handled:!1,rootElement:j}}};var $iA={events:null,recognizers:null,recognizerOptions:{},Manager:FL,touchAction:"none",tabIndex:0},LB=class{constructor(A=null,j){this._onBasicInput=r=>{let{srcEvent:n}=r,i=ML[n.type];i&&this.manager.emit(i,r)},this._onOtherEvent=r=>{this.manager.emit(r.type,r)},this.options={...$iA,...j},this.events=new Map,this.setElement(A);let{events:e}=this.options;e&&this.on(e)}getElement(){return this.element}setElement(A){if(this.element&&this.destroy(),this.element=A,!A)return;let{options:j}=this,e=j.Manager;this.manager=new e(A,{touchAction:j.touchAction,recognizers:j.recognizers||PL}).on("hammer.input",this._onBasicInput),j.recognizers||Object.keys(oF).forEach(r=>{let n=this.manager.get(r);n&&oF[r].forEach(i=>{n.recognizeWith(i)})});for(let r in j.recognizerOptions){let n=this.manager.get(r);if(n){let i=j.recognizerOptions[r];delete i.enable,n.set(i)}}this.wheelInput=new Lp(A,this._onOtherEvent,{enable:!1}),this.moveInput=new Cp(A,this._onOtherEvent,{enable:!1}),this.keyInput=new Hp(A,this._onOtherEvent,{enable:!1,tabIndex:j.tabIndex}),this.contextmenuInput=new Dp(A,this._onOtherEvent,{enable:!1});for(let[r,n]of this.events)n.isEmpty()||(this._toggleRecognizer(n.recognizerName,!0),this.manager.on(r,n.handleEvent))}destroy(){this.element&&(this.wheelInput.destroy(),this.moveInput.destroy(),this.keyInput.destroy(),this.contextmenuInput.destroy(),this.manager.destroy(),this.wheelInput=null,this.moveInput=null,this.keyInput=null,this.contextmenuInput=null,this.manager=null,this.element=null)}on(A,j,e){this._addEventHandler(A,j,e,!1)}once(A,j,e){this._addEventHandler(A,j,e,!0)}watch(A,j,e){this._addEventHandler(A,j,e,!1,!0)}off(A,j){this._removeEventHandler(A,j)}_toggleRecognizer(A,j){let{manager:e}=this;if(!e)return;let r=e.get(A);if(r&&r.options.enable!==j){r.set({enable:j});let n=IL[A];n&&!this.options.recognizers&&n.forEach(i=>{let o=e.get(i);j?(o.requireFailure(A),r.dropRequireFailure(i)):o.dropRequireFailure(A)})}this.wheelInput.enableEventType(A,j),this.moveInput.enableEventType(A,j),this.keyInput.enableEventType(A,j),this.contextmenuInput.enableEventType(A,j)}_addEventHandler(A,j,e,r,n){if(typeof A!="string"){e=j;for(let B in A)this._addEventHandler(B,A[B],e,r,n);return}let{manager:i,events:o}=this,l=sF[A]||A,c=o.get(l);c||(c=new Np(this),o.set(l,c),c.recognizerName=OL[l]||l,i&&i.on(l,c.handleEvent)),c.add(A,j,e,r,n),c.isEmpty()||this._toggleRecognizer(c.recognizerName,!0)}_removeEventHandler(A,j){if(typeof A!="string"){for(let i in A)this._removeEventHandler(i,A[i]);return}let{events:e}=this,r=sF[A]||A,n=e.get(r);if(n&&(n.remove(A,j),n.isEmpty())){let{recognizerName:i}=n,o=!1;for(let l of e.values())if(l.recognizerName===i&&!l.isEmpty()){o=!0;break}o||this._toggleRecognizer(i,!1)}}};function D7(){}var xiA=({isDragging:t})=>t?"grabbing":"grab",QL={id:"",width:"100%",height:"100%",style:null,viewState:null,initialViewState:null,pickingRadius:0,layerFilter:null,parameters:{},parent:null,device:null,deviceProps:{type:"webgl"},gl:null,glOptions:{},canvas:null,layers:[],effects:[],views:null,controller:null,useDevicePixels:!0,touchAction:"none",eventRecognizerOptions:{},_framebuffer:null,_animate:!1,_pickable:!0,_typedArrayManagerProps:{},_customRender:null,widgets:[],onDeviceInitialized:D7,onWebGLInitialized:D7,onResize:D7,onViewStateChange:D7,onInteractionStateChange:D7,onBeforeRender:D7,onAfterRender:D7,onLoad:D7,onError:t=>NA.error(t.message,t.cause)(),onHover:null,onClick:null,onDragStart:null,onDrag:null,onDragEnd:null,_onMetrics:null,getCursor:xiA,getTooltip:null,debug:!1,drawPickingColors:!1},Kp=class{constructor(A){this.width=0,this.height=0,this.userData={},this.device=null,this.canvas=null,this.viewManager=null,this.layerManager=null,this.effectManager=null,this.deckRenderer=null,this.deckPicker=null,this.eventManager=null,this.widgetManager=null,this.tooltip=null,this.animationLoop=null,this.cursorState={isHovering:!1,isDragging:!1},this.stats=new v6({id:"deck.gl"}),this.metrics={fps:0,setPropsTime:0,updateAttributesTime:0,framesRedrawn:0,pickTime:0,pickCount:0,gpuTime:0,gpuTimePerFrame:0,cpuTime:0,cpuTimePerFrame:0,bufferMemory:0,textureMemory:0,renderbufferMemory:0,gpuMemory:0},this._metricsCounter=0,this._needsRedraw="Initial render",this._pickRequest={mode:"hover",x:-1,y:-1,radius:0,event:null},this._lastPointerDownInfo=null,this._onPointerMove=e=>{let{_pickRequest:r}=this;if(e.type==="pointerleave")r.x=-1,r.y=-1,r.radius=0;else{if(e.leftButton||e.rightButton)return;{let n=e.offsetCenter;if(!n)return;r.x=n.x,r.y=n.y,r.radius=this.props.pickingRadius}}this.layerManager&&(this.layerManager.context.mousePosition={x:r.x,y:r.y}),r.event=e},this._onEvent=e=>{let r=cp[e.type],n=e.offsetCenter;if(!r||!n||!this.layerManager)return;let i=this.layerManager.getLayers(),o=this.deckPicker.getLastPickedObject({x:n.x,y:n.y,layers:i,viewports:this.getViewports(n)},this._lastPointerDownInfo),{layer:l}=o,c=l&&(l[r.handler]||l.props[r.handler]),B=this.props[r.handler],h=!1;c&&(h=c.call(l,o,e)),h||(B?.(o,e),this.widgetManager.onEvent(o,e))},this._onPointerDown=e=>{let r=e.offsetCenter,n=this._pick("pickObject","pickObject Time",{x:r.x,y:r.y,radius:this.props.pickingRadius});this._lastPointerDownInfo=n.result[0]||n.emptyInfo},this.props={...QL,...A},A=this.props,A.viewState&&A.initialViewState&&NA.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(),this.viewState=this.props.initialViewState,A.device?this.device=A.device:A.gl&&(A.gl instanceof WebGLRenderingContext&&NA.error("WebGL1 context not supported.")(),this.device=Fc.attach(A.gl));let j=this.device;j||(ya.registerDevices([Fc]),j=ya.createDevice({...A.deviceProps,canvas:this._createCanvas(A)})),this.animationLoop=this._createAnimationLoop(j,A),this.setProps(A),A._typedArrayManagerProps&&ko.setOptions(A._typedArrayManagerProps),this.animationLoop.start()}finalize(){this.animationLoop?.stop(),this.animationLoop?.destroy(),this.animationLoop=null,this._lastPointerDownInfo=null,this.layerManager?.finalize(),this.layerManager=null,this.viewManager?.finalize(),this.viewManager=null,this.effectManager?.finalize(),this.effectManager=null,this.deckRenderer?.finalize(),this.deckRenderer=null,this.deckPicker?.finalize(),this.deckPicker=null,this.eventManager?.destroy(),this.eventManager=null,this.widgetManager?.finalize(),this.widgetManager=null,!this.props.canvas&&!this.props.device&&!this.props.gl&&this.canvas&&(this.canvas.parentElement?.removeChild(this.canvas),this.canvas=null)}setProps(A){this.stats.get("setProps Time").timeStart(),"onLayerHover"in A&&NA.removed("onLayerHover","onHover")(),"onLayerClick"in A&&NA.removed("onLayerClick","onClick")(),A.initialViewState&&!Hr(this.props.initialViewState,A.initialViewState,3)&&(this.viewState=A.initialViewState),Object.assign(this.props,A),this._setCanvasSize(this.props);let j=Object.create(this.props);Object.assign(j,{views:this._getViews(),width:this.width,height:this.height,viewState:this._getViewState()}),this.animationLoop?.setProps(j),this.layerManager&&(this.viewManager.setProps(j),this.layerManager.activateViewport(this.getViewports()[0]),this.layerManager.setProps(j),this.effectManager.setProps(j),this.deckRenderer.setProps(j),this.deckPicker.setProps(j),this.widgetManager.setProps(j)),this.stats.get("setProps Time").timeEnd()}needsRedraw(A={clearRedrawFlags:!1}){if(!this.layerManager)return!1;if(this.props._animate)return"Deck._animate";let j=this._needsRedraw;A.clearRedrawFlags&&(this._needsRedraw=!1);let e=this.viewManager.needsRedraw(A),r=this.layerManager.needsRedraw(A),n=this.effectManager.needsRedraw(A),i=this.deckRenderer.needsRedraw(A);return j=j||e||r||n||i,j}redraw(A){if(!this.layerManager)return;let j=this.needsRedraw({clearRedrawFlags:!0});j=A||j,j&&(this.stats.get("Redraw Count").incrementCount(),this.props._customRender?this.props._customRender(j):this._drawLayers(j))}get isInitialized(){return this.viewManager!==null}getViews(){return Xj(this.viewManager),this.viewManager.views}getViewports(A){return Xj(this.viewManager),this.viewManager.getViewports(A)}getCanvas(){return this.canvas}pickObject(A){let j=this._pick("pickObject","pickObject Time",A).result;return j.length?j[0]:null}pickMultipleObjects(A){return A.depth=A.depth||10,this._pick("pickObject","pickMultipleObjects Time",A).result}pickObjects(A){return this._pick("pickObjects","pickObjects Time",A)}_addResources(A,j=!1){for(let e in A)this.layerManager.resourceManager.add({resourceId:e,data:A[e],forceUpdate:j})}_removeResources(A){for(let j of A)this.layerManager.resourceManager.remove(j)}_addDefaultEffect(A){this.effectManager.addDefaultEffect(A)}_addDefaultShaderModule(A){this.layerManager.addDefaultShaderModule(A)}_removeDefaultShaderModule(A){this.layerManager?.removeDefaultShaderModule(A)}_pick(A,j,e){Xj(this.deckPicker);let{stats:r}=this;r.get("Pick Count").incrementCount(),r.get(j).timeStart();let n=this.deckPicker[A]({layers:this.layerManager.getLayers(e),views:this.viewManager.getViews(),viewports:this.getViewports(e),onViewportActive:this.layerManager.activateViewport,effects:this.effectManager.getEffects(),...e});return r.get(j).timeEnd(),n}_createCanvas(A){let j=A.canvas;return typeof j=="string"&&(j=document.getElementById(j),Xj(j)),j||(j=document.createElement("canvas"),j.id=A.id||"deckgl-overlay",(A.parent||document.body).appendChild(j)),Object.assign(j.style,A.style),j}_setCanvasSize(A){if(!this.canvas)return;let{width:j,height:e}=A;if(j||j===0){let r=Number.isFinite(j)?`${j}px`:j;this.canvas.style.width=r}if(e||e===0){let r=Number.isFinite(e)?`${e}px`:e;this.canvas.style.position=A.style?.position||"absolute",this.canvas.style.height=r}}_updateCanvasSize(){let{canvas:A}=this;if(!A)return;let j=A.clientWidth??A.width,e=A.clientHeight??A.height;(j!==this.width||e!==this.height)&&(this.width=j,this.height=e,this.viewManager?.setProps({width:j,height:e}),this.layerManager?.activateViewport(this.getViewports()[0]),this.props.onResize({width:j,height:e}))}_createAnimationLoop(A,j){let{gl:e,onError:r,useDevicePixels:n}=j;return new Ep({device:A,useDevicePixels:n,autoResizeDrawingBuffer:!e,autoResizeViewport:!1,onInitialize:i=>this._setDevice(i.device),onRender:this._onRenderFrame.bind(this),onError:r})}_getViewState(){return this.props.viewState||this.viewState}_getViews(){let{views:A}=this.props,j=Array.isArray(A)?A:A?[A]:[new Hw({id:"default-view"})];return j.length&&this.props.controller&&(j[0].props.controller=this.props.controller),j}_onContextLost(){let{onError:A}=this.props;this.animationLoop&&A&&A(new Error("WebGL context is lost"))}_pickAndCallback(){let{_pickRequest:A}=this;if(A.event){let{result:j,emptyInfo:e}=this._pick("pickObject","pickObject Time",A);this.cursorState.isHovering=j.length>0;let r=e,n=!1;for(let i of j)r=i,n=i.layer?.onHover(i,A.event)||n;n||(this.props.onHover?.(r,A.event),this.widgetManager.onHover(r,A.event)),A.event=null}}_updateCursor(){let A=this.props.parent||this.canvas;A&&(A.style.cursor=this.props.getCursor(this.cursorState))}_setDevice(A){if(this.device=A,!this.animationLoop)return;this.canvas||(this.canvas=this.device.canvasContext?.canvas),this.device.setParametersWebGL({blend:!0,blendFunc:[770,771,1,771],polygonOffsetFill:!0,depthTest:!0,depthFunc:515}),this.props.onDeviceInitialized(this.device),this.device instanceof Fc&&this.props.onWebGLInitialized(this.device.gl);let j=new xc;j.play(),this.animationLoop.attachTimeline(j),this.eventManager=new LB(this.props.parent||this.canvas,{touchAction:this.props.touchAction,recognizerOptions:this.props.eventRecognizerOptions,events:{pointerdown:this._onPointerDown,pointermove:this._onPointerMove,pointerleave:this._onPointerMove}});for(let r in cp)this.eventManager.on(r,this._onEvent);this.viewManager=new yp({timeline:j,eventManager:this.eventManager,onViewStateChange:this._onViewStateChange.bind(this),onInteractionStateChange:this._onInteractionStateChange.bind(this),views:this._getViews(),viewState:this._getViewState(),width:this.width,height:this.height});let e=this.viewManager.getViewports()[0];this.layerManager=new wB(this.device,{deck:this,stats:this.stats,viewport:e,timeline:j}),this.effectManager=new _p({deck:this,device:this.device}),this.deckRenderer=new MB(this.device),this.deckPicker=new Gp(this.device),this.widgetManager=new _$({deck:this,parentElement:this.canvas?.parentElement}),this.widgetManager.addDefault(new bp),this.setProps(this.props),this._updateCanvasSize(),this.props.onLoad()}_drawLayers(A,j){let{device:e,gl:r}=this.layerManager.context;this.props.onBeforeRender({device:e,gl:r});let n={target:this.props._framebuffer,layers:this.layerManager.getLayers(),viewports:this.viewManager.getViewports(),onViewportActive:this.layerManager.activateViewport,views:this.viewManager.getViews(),pass:"screen",effects:this.effectManager.getEffects(),...j};this.deckRenderer?.renderLayers(n),n.pass==="screen"&&this.widgetManager.onRedraw({viewports:n.viewports,layers:n.layers}),this.props.onAfterRender({device:e,gl:r})}_onRenderFrame(){this._getFrameStats(),this._metricsCounter++%60===0&&(this._getMetrics(),this.stats.reset(),NA.table(4,this.metrics)(),this.props._onMetrics&&this.props._onMetrics(this.metrics)),this._updateCanvasSize(),this._updateCursor(),this.layerManager.updateLayers(),this._pickAndCallback(),this.redraw(),this.viewManager&&this.viewManager.updateViewStates()}_onViewStateChange(A){let j=this.props.onViewStateChange(A)||A.viewState;this.viewState&&(this.viewState={...this.viewState,[A.viewId]:j},this.props.viewState||this.viewManager&&this.viewManager.setProps({viewState:this.viewState}))}_onInteractionStateChange(A){this.cursorState.isDragging=A.isDragging||!1,this.props.onInteractionStateChange(A)}_getFrameStats(){let{stats:A}=this;A.get("frameRate").timeEnd(),A.get("frameRate").timeStart();let j=this.animationLoop.stats;A.get("GPU Time").addTime(j.get("GPU Time").lastTiming),A.get("CPU Time").addTime(j.get("CPU Time").lastTiming)}_getMetrics(){let{metrics:A,stats:j}=this;A.fps=j.get("frameRate").getHz(),A.setPropsTime=j.get("setProps Time").time,A.updateAttributesTime=j.get("Update Attributes").time,A.framesRedrawn=j.get("Redraw Count").count,A.pickTime=j.get("pickObject Time").time+j.get("pickMultipleObjects Time").time+j.get("pickObjects Time").time,A.pickCount=j.get("Pick Count").count,A.gpuTime=j.get("GPU Time").time,A.cpuTime=j.get("CPU Time").time,A.gpuTimePerFrame=j.get("GPU Time").getAverageTime(),A.cpuTimePerFrame=j.get("CPU Time").getAverageTime();let e=ya.stats.get("Memory Usage");A.bufferMemory=e.get("Buffer Memory").count,A.textureMemory=e.get("Texture Memory").count,A.renderbufferMemory=e.get("Renderbuffer Memory").count,A.gpuMemory=e.get("GPU Memory").count}};Kp.defaultProps=QL;Kp.VERSION=SG;var N7=Kp;function WL(t){switch(t){case"float64":return Float64Array;case"uint8":case"unorm8":return Uint8ClampedArray;default:return tp(t)}}var YL=ME;function Xp(t,A){return{attribute:t,format:A.size>1?`${A.type}x${A.size}`:A.type,byteOffset:A.offset||0}}function K7(t){return t.stride||t.size*t.bytesPerElement}function JL(t,A){return t.type===A.type&&t.size===A.size&&K7(t)===K7(A)&&(t.offset||0)===(A.offset||0)}function lF(t,A){A.offset&&NA.removed("shaderAttribute.offset","vertexOffset, elementOffset")();let j=K7(t),e=A.vertexOffset!==void 0?A.vertexOffset:t.vertexOffset||0,r=A.elementOffset||0,n=e*j+r*t.bytesPerElement+(t.offset||0);return{...A,offset:n,stride:j}}function yiA(t,A){let j=lF(t,A);return{high:j,low:{...j,offset:j.offset+t.size*4}}}var zp=class{constructor(A,j,e){this._buffer=null,this.device=A,this.id=j.id||"",this.size=j.size||1;let r=j.logicalType||j.type,n=r==="float64",{defaultValue:i}=j;i=Number.isFinite(i)?[i]:i||new Array(this.size).fill(0);let o;n?o="float32":!r&&j.isIndexed?o="uint32":o=r||"float32";let l=WL(r||o);this.doublePrecision=n,n&&j.fp64===!1&&(l=Float32Array),this.value=null,this.settings={...j,defaultType:l,defaultValue:i,logicalType:r,type:o,normalized:o.includes("norm"),size:this.size,bytesPerElement:l.BYTES_PER_ELEMENT},this.state={...e,externalBuffer:null,bufferAccessor:this.settings,allocatedValue:null,numInstances:0,bounds:null,constant:!1}}get isConstant(){return this.state.constant}get buffer(){return this._buffer}get byteOffset(){let A=this.getAccessor();return A.vertexOffset?A.vertexOffset*K7(A):0}get numInstances(){return this.state.numInstances}set numInstances(A){this.state.numInstances=A}delete(){this._buffer&&(this._buffer.delete(),this._buffer=null),ko.release(this.state.allocatedValue)}getBuffer(){return this.state.constant?null:this.state.externalBuffer||this._buffer}getValue(A=this.id,j=null){let e={};if(this.state.constant){let r=this.value;if(j){let n=lF(this.getAccessor(),j),i=n.offset/r.BYTES_PER_ELEMENT,o=n.size||this.size;e[A]=r.subarray(i,i+o)}else e[A]=r}else e[A]=this.getBuffer();return this.doublePrecision&&(this.value instanceof Float64Array?e[`${A}64Low`]=e[A]:e[`${A}64Low`]=new Float32Array(this.size)),e}_getBufferLayout(A=this.id,j=null){let e=this.getAccessor(),r=[],n={name:this.id,byteStride:K7(e),attributes:r};if(this.doublePrecision){let i=yiA(e,j||{});r.push(Xp(A,{...e,...i.high}),Xp(`${A}64Low`,{...e,...i.low}))}else if(j){let i=lF(e,j);r.push(Xp(A,{...e,...i}))}else r.push(Xp(A,e));return n}setAccessor(A){this.state.bufferAccessor=A}getAccessor(){return this.state.bufferAccessor}getBounds(){if(this.state.bounds)return this.state.bounds;let A=null;if(this.state.constant&&this.value){let j=Array.from(this.value);A=[j,j]}else{let{value:j,numInstances:e,size:r}=this,n=e*r;if(j&&n&&j.length>=n){let i=new Array(r).fill(1/0),o=new Array(r).fill(-1/0);for(let l=0;lo[c]&&(o[c]=B)}A=[i,o]}}return this.state.bounds=A,A}setData(A){let{state:j}=this,e;ArrayBuffer.isView(A)?e={value:A}:A instanceof Aj?e={buffer:A}:e=A;let r={...this.settings,...e};if(ArrayBuffer.isView(e.value)){if(!e.type)if(this.doublePrecision&&e.value instanceof Float64Array)r.type="float32";else{let i=YL(e.value);r.type=r.normalized?i.replace("int","norm"):i}r.bytesPerElement=e.value.BYTES_PER_ELEMENT,r.stride=K7(r)}if(j.bounds=null,e.constant){let n=e.value;if(n=this._normalizeValue(n,[],0),this.settings.normalized&&(n=this.normalizeConstant(n)),!(!j.constant||!this._areValuesEqual(n,this.value)))return!1;j.externalBuffer=null,j.constant=!0,this.value=ArrayBuffer.isView(n)?n:new Float32Array(n)}else if(e.buffer){let n=e.buffer;j.externalBuffer=n,j.constant=!1,this.value=e.value||null}else if(e.value){this._checkExternalBuffer(e);let n=e.value;j.externalBuffer=null,j.constant=!1,this.value=n;let{buffer:i}=this,o=K7(r),l=(r.vertexOffset||0)*o;if(this.doublePrecision&&n instanceof Float64Array&&(n=u$(n,r)),this.settings.isIndexed){let B=this.settings.defaultType;n.constructor!==B&&(n=new B(n))}let c=n.byteLength+l+o*2;(!i||i.byteLength(j+128)/255*2-1);case"snorm16":return new Float32Array(A).map(j=>(j+32768)/65535*2-1);case"unorm8":return new Float32Array(A).map(j=>j/255);case"unorm16":return new Float32Array(A).map(j=>j/65535);default:return A}}_normalizeValue(A,j,e){let{defaultValue:r,size:n}=this.settings;if(Number.isFinite(A))return j[e]=A,j;if(!A){let i=n;for(;--i>=0;)j[e+i]=r[i];return j}switch(n){case 4:j[e+3]=Number.isFinite(A[3])?A[3]:r[3];case 3:j[e+2]=Number.isFinite(A[2])?A[2]:r[2];case 2:j[e+1]=Number.isFinite(A[1])?A[1]:r[1];case 1:j[e+0]=Number.isFinite(A[0])?A[0]:r[0];break;default:let i=n;for(;--i>=0;)j[e+i]=Number.isFinite(A[i])?A[i]:r[i]}return j}_areValuesEqual(A,j){if(!A||!j)return!1;let{size:e}=this;for(let r=0;r0&&(A2.length=t.length,e=A2):e=ZL,(A>0||Number.isFinite(j))&&(e=(Array.isArray(e)?e:Array.from(e)).slice(A,j),r.index=A-1),{iterable:e,objectInfo:r}}function Y$(t){return t&&t[Symbol.asyncIterator]}function J$(t,A){let{size:j,stride:e,offset:r,startIndices:n,nested:i}=A,o=t.BYTES_PER_ELEMENT,l=e?e/o:j,c=r?r/o:0,B=Math.floor((t.length-c)/l);return(h,{index:d,target:k})=>{if(!n){let y=d*l+c;for(let b=0;b=A[1]))return t;let j=[],e=t.length,r=0;for(let n=0;nA[1]?j.push(i):A=[Math.min(i[0],A[0]),Math.max(i[1],A[1])]}return j.splice(r,0,A),j}var _iA={interpolation:{duration:0,easing:t=>t},spring:{stiffness:.05,damping:.5}};function Z$(t,A){if(!t)return null;Number.isFinite(t)&&(t={type:"interpolation",duration:t});let j=t.type||"interpolation";return{..._iA[j],...A,...t,type:j}}var X7=class extends zp{constructor(A,j){super(A,j,{startIndices:null,lastExternalBuffer:null,binaryValue:null,binaryAccessor:null,needsUpdate:!0,needsRedraw:!1,layoutChanged:!1,updateRanges:Up}),this.constant=!1,this.settings.update=j.update||(j.accessor?this._autoUpdater:void 0),Object.seal(this.settings),Object.seal(this.state),this._validateAttributeUpdaters()}get startIndices(){return this.state.startIndices}set startIndices(A){this.state.startIndices=A}needsUpdate(){return this.state.needsUpdate}needsRedraw({clearChangedFlags:A=!1}={}){let j=this.state.needsRedraw;return this.state.needsRedraw=j&&!A,j}layoutChanged(){return this.state.layoutChanged}setAccessor(A){var j;(j=this.state).layoutChanged||(j.layoutChanged=!JL(A,this.getAccessor())),super.setAccessor(A)}getUpdateTriggers(){let{accessor:A}=this.settings;return[this.id].concat(typeof A!="function"&&A||[])}supportsTransition(){return!!this.settings.transition}getTransitionSetting(A){if(!A||!this.supportsTransition())return null;let{accessor:j}=this.settings,e=this.settings.transition,r=Array.isArray(j)?A[j.find(n=>A[n])]:A[j];return Z$(r,e)}setNeedsUpdate(A=this.id,j){if(this.state.needsUpdate=this.state.needsUpdate||A,this.setNeedsRedraw(A),j){let{startRow:e=0,endRow:r=1/0}=j;this.state.updateRanges=j2(this.state.updateRanges,[e,r])}else this.state.updateRanges=Up}clearNeedsUpdate(){this.state.needsUpdate=!1,this.state.updateRanges=t2}setNeedsRedraw(A=this.id){this.state.needsRedraw=this.state.needsRedraw||A}allocate(A){let{state:j,settings:e}=this;return e.noAlloc?!1:e.update?(super.allocate(A,j.updateRanges!==Up),!0):!1}updateBuffer({numInstances:A,data:j,props:e,context:r}){if(!this.needsUpdate())return!1;let{state:{updateRanges:n},settings:{update:i,noAlloc:o}}=this,l=!0;if(i){for(let[c,B]of n)i.call(r,this,{data:j,startRow:c,endRow:B,props:e,numInstances:A});if(this.value)if(this.constant||!this.buffer||this.buffer.byteLengthB?c.set(v,E):(A._normalizeValue(v,y.target,0),Lw({target:c,source:y.target,start:E,count:_}));E+=_*B}else A._normalizeValue(v,c,E),E+=B}}_validateAttributeUpdaters(){let{settings:A}=this;if(!(A.noAlloc||typeof A.update=="function"))throw new Error(`Attribute ${this.id} missing update or accessor`)}_checkAttributeArray(){let{value:A}=this,j=Math.min(4,this.size);if(A&&A.length>=j){let e=!0;switch(j){case 4:e=e&&Number.isFinite(A[3]);case 3:e=e&&Number.isFinite(A[2]);case 2:e=e&&Number.isFinite(A[1]);case 1:e=e&&Number.isFinite(A[0]);break;default:e=!1}if(!e)throw new Error(`Illegal attribute generated for ${this.id}`)}}};function cF(t){let{source:A,target:j,start:e=0,size:r,getData:n}=t,i=t.end||j.length,o=A.length,l=i-e;if(o>l){j.set(A.subarray(0,l),e);return}if(j.set(A,e),!n)return;let c=o;for(;ce(B+o,h)),c=Math.min(r.length,n.length);for(let B=1;Bo}){let o=j.doublePrecision&&j.value instanceof Float64Array?2:1,l=j.size*o,c=j.byteOffset,B=j.settings.bytesPerElement<4?c/j.settings.bytesPerElement*4:c,h=j.startIndices,d=n&&h,k=j.isConstant;if(!d&&A&&e>=r)return A;let g=j.value instanceof Float64Array?Float32Array:j.value.constructor,E=k?j.value:new g(j.getBuffer().readSyncWebGL(c,r*g.BYTES_PER_ELEMENT).buffer);if(j.settings.normalized&&!k){let v=i;i=(_,w)=>j.normalizeConstant(v(_,w))}let m=k?(v,_)=>i(E,_):(v,_)=>i(E.subarray(v+c,v+c+l),_),y=A?new Float32Array(A.readSyncWebGL(B,e*4).buffer):new Float32Array(0),b=new Float32Array(r);return e2({source:y,target:b,sourceStartIndices:n,targetStartIndices:h,size:l,getData:m}),(!A||A.byteLengththis.device.clearWebGL(h))}let B={totalCount:j.length,visibleCount:0,compositeCount:0,pickableCount:0};A.setParameters({viewport:c});for(let h=0;h{let i=r.props._offset,o=r.id,l=r.parent&&r.parent.id,c;if(l&&!(l in A)&&e(r.parent,!1),l in j){let B=j[l]=j[l]||kR(A[l],A);c=B(r,n),j[o]=B}else Number.isFinite(i)?(c=i+(A[l]||0),j[o]=null):c=t;return n&&c>=t&&(t=c+1),A[o]=c,c};return e}function BnA(t,{moduleParameters:A,target:j,viewport:e}){let r=A&&A.devicePixelRatio||t.canvasContext.cssToDeviceRatio(),[,n]=t.canvasContext.getDrawingBufferSize(),i=j?j.height:n,o=e;return[o.x*r,i-(o.y+o.height)*r,o.width*r,o.height*r]}var Ep=class extends wa{constructor(A,j){super(A,j),this.shadowMap=A.createTexture({width:1,height:1,sampler:{minFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}}),this.depthBuffer=A.createTexture({format:"depth16unorm",width:1,height:1,mipmaps:!1,dataFormat:6402,type:5125}),this.fbo=A.createFramebuffer({id:"shadowmap",width:1,height:1,colorAttachments:[this.shadowMap],depthStencilAttachment:this.depthBuffer})}render(A){let j=this.fbo,e=this.device.canvasContext.cssToDeviceRatio(),r=A.viewports[0],n=r.width*e,i=r.height*e,o=[1,1,1,1];(n!==j.width||i!==j.height)&&j.resize({width:n,height:i}),super.render({...A,clearColor:o,target:j,pass:"shadow"})}getLayerParameters(A,j,e){return{...A.props.parameters,blend:!1,depthRange:[0,1],depthTest:!0}}shouldDrawLayer(A){return A.props.shadowEnabled!==!1}getModuleParameters(){return{drawToShadowMap:!0}}delete(){this.fbo&&(this.fbo.destroy(),this.fbo=null),this.shadowMap&&(this.shadowMap.destroy(),this.shadowMap=null),this.depthBuffer&&(this.depthBuffer.destroy(),this.depthBuffer=null)}};var fnA={color:[255,255,255],intensity:1},gR=[{color:[255,255,255],intensity:1,direction:[-1,3,-1]},{color:[255,255,255],intensity:.9,direction:[1,-8,-2.5]}],hnA=[0,0,0,200/255],xc=class{constructor(A={}){this.id="lighting-effect",this.shadowColor=hnA,this.shadow=!1,this.ambientLight=null,this.directionalLights=[],this.pointLights=[],this.shadowPasses=[],this.shadowMaps=[],this.dummyShadowMap=null,this.setProps(A)}setup(A){this.context=A;let{device:j,deck:e}=A;this.shadow&&!this.dummyShadowMap&&(this._createShadowPasses(j),e._addDefaultShaderModule(kp),this.dummyShadowMap=j.createTexture({width:1,height:1}))}setProps(A){this.ambientLight=null,this.directionalLights=[],this.pointLights=[];for(let j in A){let e=A[j];switch(e.type){case"ambient":this.ambientLight=e;break;case"directional":this.directionalLights.push(e);break;case"point":this.pointLights.push(e);break;default:}}this._applyDefaultLights(),this.shadow=this.directionalLights.some(j=>j.shadow),this.context&&this.setup(this.context),this.props=A}preRender({layers:A,layerFilter:j,viewports:e,onViewportActive:r,views:n}){if(this.shadow){this.shadowMatrices=this._calculateMatrices();for(let i=0;ie.getProjectedLight({layer:A})),pointLights:this.pointLights.map(e=>e.getProjectedLight({layer:A}))},j}cleanup(A){for(let j of this.shadowPasses)j.delete();this.shadowPasses.length=0,this.shadowMaps.length=0,this.dummyShadowMap&&(this.dummyShadowMap.destroy(),this.dummyShadowMap=null,A.deck._removeDefaultShaderModule(kp))}_calculateMatrices(){let A=[];for(let j of this.directionalLights){let e=new lj().lookAt({eye:new on(j.direction).negate()});A.push(e)}return A}_createShadowPasses(A){for(let j=0;jr&&(n=r);let i=this._pool,o=A.BYTES_PER_ELEMENT*n,l=i.findIndex(c=>c.byteLength>=o);if(l>=0){let c=new A(i.splice(l,1)[0],0,n);return e&&c.fill(0),c}return new A(n)}_release(A){if(!ArrayBuffer.isView(A))return;let j=this._pool,{buffer:e}=A,{byteLength:r}=e,n=j.findIndex(i=>i.byteLength>=r);n<0?j.push(e):(n>0||j.lengththis.opts.poolSize&&j.shift()}},ko=new Cw;function qB(){return[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]}function ER(t,A){let j=t%A;return j<0?A+j:j}function $R(t){return[t[12],t[13],t[14]]}function xR(t){return{left:_B(t[3]+t[0],t[7]+t[4],t[11]+t[8],t[15]+t[12]),right:_B(t[3]-t[0],t[7]-t[4],t[11]-t[8],t[15]-t[12]),bottom:_B(t[3]+t[1],t[7]+t[5],t[11]+t[9],t[15]+t[13]),top:_B(t[3]-t[1],t[7]-t[5],t[11]-t[9],t[15]-t[13]),near:_B(t[3]+t[2],t[7]+t[6],t[11]+t[10],t[15]+t[14]),far:_B(t[3]-t[2],t[7]-t[6],t[11]-t[10],t[15]-t[14])}}var mR=new on;function _B(t,A,j,e){mR.set(t,A,j);let r=mR.len();return{distance:e/r,normal:new on(-t/r,-A/r,-j/r)}}function yR(t){return t-Math.fround(t)}var $p;function p$(t,A){let{size:j=1,startIndex:e=0}=A,r=A.endIndex!==void 0?A.endIndex:t.length,n=(r-e)/j;$p=ko.allocate($p,n,{type:Float32Array,size:j*2});let i=e,o=0;for(;i=j.delay+j.duration*j.repeat}getTime(A){if(A===void 0)return this.time;let j=this.channels.get(A);return j===void 0?-1:j.time}setTime(A){this.time=Math.max(0,A);let j=this.channels.values();for(let r of j)this._setChannelTime(r,this.time);let e=this.animations.values();for(let r of e){let{animation:n,channel:i}=r;n.setTime(this.getTime(i))}}play(){this.playing=!0}pause(){this.playing=!1,this.lastEngineTime=-1}reset(){this.setTime(0)}attachAnimation(A,j){let e=$nA++;return this.animations.set(e,{animation:A,channel:j}),A.setTime(this.getTime(j)),e}detachAnimation(A){this.animations.delete(A)}update(A){this.playing&&(this.lastEngineTime===-1&&(this.lastEngineTime=A),this.setTime(this.time+(A-this.lastEngineTime)),this.lastEngineTime=A)}_setChannelTime(A,j){let e=j-A.delay,r=A.duration*A.repeat;e>=r?A.time=A.duration*A.rate:(A.time=Math.max(0,e)%A.duration,A.time*=A.rate)}};var xnA=0,ynA={device:null,onAddHTML:()=>"",onInitialize:async()=>null,onRender:()=>{},onFinalize:()=>{},onError:t=>console.error(t),stats:ya.stats.get(`animation-loop-${xnA++}`),useDevicePixels:!0,autoResizeViewport:!1,autoResizeDrawingBuffer:!1},xp=class{constructor(A){I(this,"device",null);I(this,"canvas",null);I(this,"props");I(this,"animationProps",null);I(this,"timeline",null);I(this,"stats");I(this,"cpuTime");I(this,"gpuTime");I(this,"frameRate");I(this,"display");I(this,"needsRedraw","initialized");I(this,"_initialized",!1);I(this,"_running",!1);I(this,"_animationFrameId",null);I(this,"_nextFramePromise",null);I(this,"_resolveNextFrame",null);I(this,"_cpuStartTime",0);if(this.props={...ynA,...A},A=this.props,!A.device)throw new Error("No device provided");let{useDevicePixels:j=!0}=this.props;this.stats=A.stats||new v6({id:"animation-loop-stats"}),this.cpuTime=this.stats.get("CPU Time"),this.gpuTime=this.stats.get("GPU Time"),this.frameRate=this.stats.get("Frame Rate"),this.setProps({autoResizeViewport:A.autoResizeViewport,autoResizeDrawingBuffer:A.autoResizeDrawingBuffer,useDevicePixels:j}),this.start=this.start.bind(this),this.stop=this.stop.bind(this),this._onMousemove=this._onMousemove.bind(this),this._onMouseleave=this._onMouseleave.bind(this)}destroy(){this.stop(),this._setDisplay(null)}delete(){this.destroy()}setNeedsRedraw(A){return this.needsRedraw=this.needsRedraw||A,this}setProps(A){return"autoResizeViewport"in A&&(this.props.autoResizeViewport=A.autoResizeViewport||!1),"autoResizeDrawingBuffer"in A&&(this.props.autoResizeDrawingBuffer=A.autoResizeDrawingBuffer||!1),"useDevicePixels"in A&&(this.props.useDevicePixels=A.useDevicePixels||!1),this}async start(){if(this._running)return this;this._running=!0;try{let A;return this._initialized||(this._initialized=!0,await this._initDevice(),this._initialize(),await this.props.onInitialize(this._getAnimationProps())),this._running?(A!==!1&&(this._cancelAnimationFrame(),this._requestAnimationFrame()),this):null}catch(A){let j=A instanceof Error?A:new Error("Unknown error");throw this.props.onError(j),j}}stop(){return this._running&&(this.animationProps&&this.props.onFinalize(this.animationProps),this._cancelAnimationFrame(),this._nextFramePromise=null,this._resolveNextFrame=null,this._running=!1),this}redraw(){return this.device?.isLost?this:(this._beginFrameTimers(),this._setupFrame(),this._updateAnimationProps(),this._renderFrame(this._getAnimationProps()),this._clearNeedsRedraw(),this._resolveNextFrame&&(this._resolveNextFrame(this),this._nextFramePromise=null,this._resolveNextFrame=null),this._endFrameTimers(),this)}attachTimeline(A){return this.timeline=A,this.timeline}detachTimeline(){this.timeline=null}waitForRender(){return this.setNeedsRedraw("waitForRender"),this._nextFramePromise||(this._nextFramePromise=new Promise(A=>{this._resolveNextFrame=A})),this._nextFramePromise}async toDataURL(){if(this.setNeedsRedraw("toDataURL"),await this.waitForRender(),this.canvas instanceof HTMLCanvasElement)return this.canvas.toDataURL();throw new Error("OffscreenCanvas")}_initialize(){this._startEventHandling(),this._initializeAnimationProps(),this._updateAnimationProps(),this._resizeCanvasDrawingBuffer(),this._resizeViewport()}_setDisplay(A){this.display&&(this.display.destroy(),this.display.animationLoop=null),A&&(A.animationLoop=this),this.display=A}_requestAnimationFrame(){this._running&&(this._animationFrameId=sG(this._animationFrame.bind(this)))}_cancelAnimationFrame(){this._animationFrameId!==null&&(aG(this._animationFrameId),this._animationFrameId=null)}_animationFrame(){this._running&&(this.redraw(),this._requestAnimationFrame())}_renderFrame(A){if(this.display){this.display._renderFrame(A);return}this.props.onRender(this._getAnimationProps()),this.device.submit()}_clearNeedsRedraw(){this.needsRedraw=!1}_setupFrame(){this._resizeCanvasDrawingBuffer(),this._resizeViewport()}_initializeAnimationProps(){if(!this.device)throw new Error("loop");this.animationProps={animationLoop:this,device:this.device,canvas:this.device?.canvasContext?.canvas,timeline:this.timeline,useDevicePixels:this.props.useDevicePixels,needsRedraw:!1,width:1,height:1,aspect:1,time:0,startTime:Date.now(),engineTime:0,tick:0,tock:0,_mousePosition:null}}_getAnimationProps(){if(!this.animationProps)throw new Error("animationProps");return this.animationProps}_updateAnimationProps(){if(!this.animationProps)return;let{width:A,height:j,aspect:e}=this._getSizeAndAspect();(A!==this.animationProps.width||j!==this.animationProps.height)&&this.setNeedsRedraw("drawing buffer resized"),e!==this.animationProps.aspect&&this.setNeedsRedraw("drawing buffer aspect changed"),this.animationProps.width=A,this.animationProps.height=j,this.animationProps.aspect=e,this.animationProps.needsRedraw=this.needsRedraw,this.animationProps.engineTime=Date.now()-this.animationProps.startTime,this.timeline&&this.timeline.update(this.animationProps.engineTime),this.animationProps.tick=Math.floor(this.animationProps.time/1e3*60),this.animationProps.tock++,this.animationProps.time=this.timeline?this.timeline.getTime():this.animationProps.engineTime}async _initDevice(){if(this.device=await this.props.device,!this.device)throw new Error("No device provided");this.canvas=this.device.canvasContext?.canvas||null}_createInfoDiv(){if(this.canvas&&this.props.onAddHTML){let A=document.createElement("div");document.body.appendChild(A),A.style.position="relative";let j=document.createElement("div");j.style.position="absolute",j.style.left="10px",j.style.bottom="10px",j.style.width="300px",j.style.background="white",this.canvas instanceof HTMLCanvasElement&&A.appendChild(this.canvas),A.appendChild(j);let e=this.props.onAddHTML(j);e&&(j.innerHTML=e)}}_getSizeAndAspect(){if(!this.device)return{width:1,height:1,aspect:1};let[A,j]=this.device?.canvasContext?.getPixelSize()||[1,1],e=1,r=this.device?.canvasContext?.canvas;return r&&r.clientHeight?e=r.clientWidth/r.clientHeight:A>0&&j>0&&(e=A/j),{width:A,height:j,aspect:e}}_resizeViewport(){this.props.autoResizeViewport&&this.device.gl&&this.device.gl.viewport(0,0,this.device.gl.drawingBufferWidth,this.device.gl.drawingBufferHeight)}_resizeCanvasDrawingBuffer(){this.props.autoResizeDrawingBuffer&&this.device?.canvasContext?.resize({useDevicePixels:this.props.useDevicePixels})}_beginFrameTimers(){this.frameRate.timeEnd(),this.frameRate.timeStart(),this.cpuTime.timeStart()}_endFrameTimers(){this.cpuTime.timeEnd()}_startEventHandling(){this.canvas&&(this.canvas.addEventListener("mousemove",this._onMousemove.bind(this)),this.canvas.addEventListener("mouseleave",this._onMouseleave.bind(this)))}_onMousemove(A){A instanceof MouseEvent&&(this._getAnimationProps()._mousePosition=[A.offsetX,A.offsetY])}_onMouseleave(A){this._getAnimationProps()._mousePosition=null}};var m$=class{constructor(A){I(this,"id");I(this,"userData",{});I(this,"topology");I(this,"bufferLayout",[]);I(this,"vertexCount");I(this,"indices");I(this,"attributes");this.id=A.id||Pn("geometry"),this.topology=A.topology,this.indices=A.indices||null,this.attributes=A.attributes,this.vertexCount=A.vertexCount,this.bufferLayout=A.bufferLayout||[],this.indices&&Ot(this.indices.usage===Aj.INDEX)}destroy(){this.indices?.destroy();for(let A of Object.values(this.attributes))A.destroy()}getVertexCount(){return this.vertexCount}getAttributes(){return this.attributes}getIndexes(){return this.indices}_calculateVertexCount(A){return A.byteLength/12}};function GR(t,A){if(A instanceof m$)return A;let j=vnA(t,A),{attributes:e,bufferLayout:r}=_nA(t,A);return new m$({topology:A.topology||"triangle-list",bufferLayout:r,vertexCount:A.vertexCount,indices:j,attributes:e})}function vnA(t,A){if(!A.indices)return;let j=A.indices.value;return t.createBuffer({usage:Aj.INDEX,data:j})}function _nA(t,A){let j=[],e={};for(let[n,i]of Object.entries(A.attributes)){let o=n;switch(n){case"POSITION":o="positions";break;case"NORMAL":o="normals";break;case"TEXCOORD_0":o="texCoords";break;case"COLOR_0":o="colors";break}e[o]=t.createBuffer({data:i.value,id:`${n}-buffer`});let{value:l,size:c,normalized:B}=i;j.push({name:o,format:nG(l,c,B)})}let r=A._calculateVertexCount(A.attributes,A.indices);return{attributes:e,bufferLayout:j,vertexCount:r}}var E$=class{constructor(A){I(this,"modules");I(this,"moduleUniforms");I(this,"moduleBindings");I(this,"moduleUniformsChanged");let j=cc(Object.values(A).filter(e=>e.dependencies));for(let e of j)A[e.name]=e;mA.log(1,"Creating ShaderInputs with modules",Object.keys(A))(),this.modules=A,this.moduleUniforms={},this.moduleBindings={};for(let[e,r]of Object.entries(A)){let n=e;this.moduleUniforms[n]=r.defaultUniforms||{},this.moduleBindings[n]={}}}destroy(){}setProps(A){for(let j of Object.keys(A)){let e=j,r=A[e],n=this.modules[e];if(!n){mA.warn(`Module ${j} not found`)();continue}let i=this.moduleUniforms[e],o=this.moduleBindings[e],l=n.getUniforms?.(r,i)||r,{uniforms:c,bindings:B}=kc(l);this.moduleUniforms[e]={...i,...c},this.moduleBindings[e]={...o,...B}}}getModules(){return Object.values(this.modules)}getUniformValues(){return this.moduleUniforms}getBindings(){let A={};for(let j of Object.values(this.moduleBindings))Object.assign(A,j);return A}getDebugTable(){let A={};for(let[j,e]of Object.entries(this.moduleUniforms))for(let[r,n]of Object.entries(e))A[`${j}.${r}`]={type:this.modules[j].uniformTypes?.[r],value:String(n)};return A}};var x$=class x${constructor(A){I(this,"device");I(this,"_hashCounter",0);I(this,"_hashes",{});I(this,"_renderPipelineCache",{});I(this,"_computePipelineCache",{});this.device=A}static getDefaultPipelineFactory(A){return A._lumaData.defaultPipelineFactory=A._lumaData.defaultPipelineFactory||new x$(A),A._lumaData.defaultPipelineFactory}createRenderPipeline(A){let j={...rs.defaultProps,...A},e=this._hashRenderPipeline(j);if(!this._renderPipelineCache[e]){let r=this.device.createRenderPipeline({...j,id:j.id?`${j.id}-cached`:void 0});r.hash=e,this._renderPipelineCache[e]={pipeline:r,useCount:0}}return this._renderPipelineCache[e].useCount++,this._renderPipelineCache[e].pipeline}createComputePipeline(A){let j={...cB.defaultProps,...A},e=this._hashComputePipeline(j);if(!this._computePipelineCache[e]){let r=this.device.createComputePipeline({...j,id:j.id?`${j.id}-cached`:void 0});r.hash=e,this._computePipelineCache[e]={pipeline:r,useCount:0}}return this._computePipelineCache[e].useCount++,this._computePipelineCache[e].pipeline}release(A){let j=A.hash,e=A instanceof cB?this._computePipelineCache:this._renderPipelineCache;e[j].useCount--,e[j].useCount===0&&(e[j].pipeline.destroy(),delete e[j])}_hashComputePipeline(A){return`${this._getHash(A.shader.source)}`}_hashRenderPipeline(A){let j=this._getHash(A.vs.source),e=A.fs?this._getHash(A.fs.source):0,r="-",n=this._getHash(JSON.stringify(A.bufferLayout));switch(this.device.type){case"webgl":return`${j}/${e}V${r}BL${n}`;default:let i=this._getHash(JSON.stringify(A.parameters));return`${j}/${e}V${r}T${A.topology}P${i}BL${n}`}}_getHash(A){return this._hashes[A]===void 0&&(this._hashes[A]=this._hashCounter++),this._hashes[A]}};I(x$,"defaultProps",{...rs.defaultProps});var $$=x$;var v$=class v${constructor(A){I(this,"device");I(this,"_cache",{});this.device=A}static getDefaultShaderFactory(A){var j;return(j=A._lumaData).defaultShaderFactory||(j.defaultShaderFactory=new v$(A)),A._lumaData.defaultShaderFactory}createShader(A){let j=this._hashShader(A),e=this._cache[j];if(!e){let r=this.device.createShader({...A,id:A.id?`${A.id}-cached`:void 0});this._cache[j]=e={shader:r,useCount:0}}return e.useCount++,e.shader}release(A){let j=this._hashShader(A),e=this._cache[j];e&&(e.useCount--,e.useCount===0&&(delete this._cache[j],e.shader.destroy()))}_hashShader(A){return`${A.stage}:${A.source}`}};I(v$,"defaultProps",{...hc.defaultProps});var y$=v$;function wR(t,A){let j={},e="Values";if(t.attributes.length===0&&!t.varyings?.length)return{"No attributes or varyings":{[e]:"N/A"}};for(let r of t.attributes)if(r){let n=`${r.location} ${r.name}: ${r.type}`;j[`in ${n}`]={[e]:r.stepMode||"vertex"}}for(let r of t.varyings||[]){let n=`${r.location} ${r.name}`;j[`out ${n}`]={[e]:JSON.stringify(r.accessor)}}return j}var kr=null,Nw=null;function FR(t,{id:A,minimap:j,opaque:e,top:r="0",left:n="0",rgbaScale:i=1}){kr||(kr=document.createElement("canvas"),kr.id=A,kr.title=A,kr.style.zIndex="100",kr.style.position="absolute",kr.style.top=r,kr.style.left=n,kr.style.border="blue 1px solid",kr.style.transform="scaleY(-1)",document.body.appendChild(kr),Nw=kr.getContext("2d")),(kr.width!==t.width||kr.height!==t.height)&&(kr.width=t.width/2,kr.height=t.height/2,kr.style.width="400px",kr.style.height="400px");let o=t.device.readPixelsToArrayWebGL(t),l=Nw.createImageData(t.width,t.height),c=0;for(let B=0;B[l.name,l])||[]);this.setShaderInputs(j.shaderInputs||new E$(e));let r=bnA(A),n=(this.props.modules?.length>0?this.props.modules:this.shaderInputs?.getModules())||[];if(this.device.type==="webgpu"&&this.props.source){(o=this.props).shaderLayout||(o.shaderLayout=UG(this.props.source));let{source:l,getUniforms:c}=this.props.shaderAssembler.assembleShader({platformInfo:r,...this.props,modules:n});this.source=l,this._getModuleUniforms=c}else{let{vs:l,fs:c,getUniforms:B}=this.props.shaderAssembler.assembleShaderPair({platformInfo:r,...this.props,modules:n});this.vs=l,this.fs=c,this._getModuleUniforms=B}this.vertexCount=this.props.vertexCount,this.instanceCount=this.props.instanceCount,this.topology=this.props.topology,this.bufferLayout=this.props.bufferLayout,this.parameters=this.props.parameters,j.geometry&&this.setGeometry(j.geometry),this.pipelineFactory=j.pipelineFactory||$$.getDefaultPipelineFactory(this.device),this.shaderFactory=j.shaderFactory||y$.getDefaultShaderFactory(this.device),this.pipeline=this._updatePipeline(),this.vertexArray=A.createVertexArray({renderPipeline:this.pipeline}),this._gpuGeometry&&this._setGeometryAttributes(this._gpuGeometry),"isInstanced"in j&&(this.isInstanced=j.isInstanced),j.instanceCount&&this.setInstanceCount(j.instanceCount),j.vertexCount&&this.setVertexCount(j.vertexCount),j.indexBuffer&&this.setIndexBuffer(j.indexBuffer),j.attributes&&this.setAttributes(j.attributes),j.constantAttributes&&this.setConstantAttributes(j.constantAttributes),j.bindings&&this.setBindings(j.bindings),j.uniforms&&this.setUniforms(j.uniforms),j.moduleSettings&&this.updateModuleSettings(j.moduleSettings),j.transformFeedback&&(this.transformFeedback=j.transformFeedback),Object.seal(this)}destroy(){this._destroyed||(this.pipelineFactory.release(this.pipeline),this.shaderFactory.release(this.pipeline.vs),this.pipeline.fs&&this.shaderFactory.release(this.pipeline.fs),this._uniformStore.destroy(),this._gpuGeometry?.destroy(),this._destroyed=!0)}needsRedraw(){this._getBindingsUpdateTimestamp()>this._lastDrawTimestamp&&this.setNeedsRedraw("contents of bound textures or buffers updated");let A=this._needsRedraw;return this._needsRedraw=!1,A}setNeedsRedraw(A){this._needsRedraw||(this._needsRedraw=A)}predraw(){this.updateShaderInputs(),this.pipeline=this._updatePipeline()}draw(A){this.predraw();let j;try{this._logDrawCallStart(),this.pipeline=this._updatePipeline(),this.pipeline.setBindings(this.bindings,{disableWarnings:this.props.disableWarnings}),b7(this.uniforms)||this.pipeline.setUniformsWebGL(this.uniforms);let{indexBuffer:e}=this.vertexArray,r=e?e.byteLength/(e.indexType==="uint32"?4:2):void 0;j=this.pipeline.draw({renderPass:A,vertexArray:this.vertexArray,isInstanced:this.isInstanced,vertexCount:this.vertexCount,instanceCount:this.instanceCount,indexCount:r,transformFeedback:this.transformFeedback||void 0,parameters:this.parameters,topology:this.topology})}finally{this._logDrawCallEnd()}return this._logFramebuffer(A),j?(this._lastDrawTimestamp=this.device.timestamp,this._needsRedraw=!1):this._needsRedraw="waiting for resource initialization",j}setGeometry(A){this._gpuGeometry?.destroy();let j=A&&GR(this.device,A);j&&(this.setTopology(j.topology||"triangle-list"),this.bufferLayout=PR(j.bufferLayout,this.bufferLayout),this.vertexArray&&this._setGeometryAttributes(j)),this._gpuGeometry=j}setTopology(A){A!==this.topology&&(this.topology=A,this._setPipelineNeedsUpdate("topology"))}setBufferLayout(A){this.bufferLayout=this._gpuGeometry?PR(A,this._gpuGeometry.bufferLayout):A,this._setPipelineNeedsUpdate("bufferLayout"),this.pipeline=this._updatePipeline(),this.vertexArray=this.device.createVertexArray({renderPipeline:this.pipeline}),this._gpuGeometry&&this._setGeometryAttributes(this._gpuGeometry)}setParameters(A){np(A,this.parameters,2)||(this.parameters=A,this._setPipelineNeedsUpdate("parameters"))}setInstanceCount(A){this.instanceCount=A,this.isInstanced===void 0&&A>0&&(this.isInstanced=!0),this.setNeedsRedraw("instanceCount")}setVertexCount(A){this.vertexCount=A,this.setNeedsRedraw("vertexCount")}setShaderInputs(A){this.shaderInputs=A,this._uniformStore=new jp(this.shaderInputs.modules);for(let j of Object.keys(this.shaderInputs.modules)){let e=this._uniformStore.getManagedUniformBuffer(this.device,j);this.bindings[`${j}Uniforms`]=e}this.setNeedsRedraw("shaderInputs")}updateShaderInputs(){this._uniformStore.setUniforms(this.shaderInputs.getUniformValues()),this.setBindings(this.shaderInputs.getBindings()),this.setNeedsRedraw("shaderInputs")}setBindings(A){Object.assign(this.bindings,A),this.setNeedsRedraw("bindings")}setTransformFeedback(A){this.transformFeedback=A,this.setNeedsRedraw("transformFeedback")}setIndexBuffer(A){this.vertexArray.setIndexBuffer(A),this.setNeedsRedraw("indexBuffer")}setAttributes(A,j){A.indices&&mA.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();for(let[e,r]of Object.entries(A)){let n=this.bufferLayout.find(l=>IR(l).includes(e));if(!n){mA.warn(`Model(${this.id}): Missing layout for buffer "${e}".`)();continue}let i=IR(n),o=!1;for(let l of i){let c=this._attributeInfos[l];c&&(this.vertexArray.setBuffer(c.location,r),o=!0)}!o&&!(j?.disableWarnings??this.props.disableWarnings)&&mA.warn(`Model(${this.id}): Ignoring buffer "${r.id}" for unknown attribute "${e}"`)()}this.setNeedsRedraw("attributes")}setConstantAttributes(A,j){for(let[e,r]of Object.entries(A)){let n=this._attributeInfos[e];n?this.vertexArray.setConstantWebGL(n.location,r):(j?.disableWarnings??this.props.disableWarnings)||mA.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${e}"`)()}this.setNeedsRedraw("constants")}setUniforms(A){b7(A)||(this.pipeline.setUniformsWebGL(A),Object.assign(this.uniforms,A)),this.setNeedsRedraw("uniforms")}updateModuleSettings(A){let{bindings:j,uniforms:e}=kc(this._getModuleUniforms(A));Object.assign(this.bindings,j),Object.assign(this.uniforms,e),this.setNeedsRedraw("moduleSettings")}_getBindingsUpdateTimestamp(){let A=0;for(let j of Object.values(this.bindings))j instanceof fc?A=Math.max(A,j.texture.updateTimestamp):j instanceof Aj||j instanceof Ne?A=Math.max(A,j.updateTimestamp):j instanceof dc||(A=Math.max(A,j.buffer.updateTimestamp));return A}_setGeometryAttributes(A){let j={...A.attributes};for(let[e]of Object.entries(j))!this.pipeline.shaderLayout.attributes.find(r=>r.name===e)&&e!=="positions"&&delete j[e];this.vertexCount=A.vertexCount,this.setIndexBuffer(A.indices||null),this.setAttributes(A.attributes,{disableWarnings:!0}),this.setAttributes(j,{disableWarnings:this.props.disableWarnings}),this.setNeedsRedraw("geometry attributes")}_setPipelineNeedsUpdate(A){this._pipelineNeedsUpdate||(this._pipelineNeedsUpdate=A),this.setNeedsRedraw(A)}_updatePipeline(){if(this._pipelineNeedsUpdate){let A=null,j=null;this.pipeline&&(mA.log(1,`Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)(),A=this.pipeline.vs,j=this.pipeline.fs),this._pipelineNeedsUpdate=!1;let e=this.shaderFactory.createShader({id:`${this.id}-vertex`,stage:"vertex",source:this.source||this.vs,debug:this.props.debugShaders}),r=null;this.source?r=e:this.fs&&(r=this.shaderFactory.createShader({id:`${this.id}-fragment`,stage:"fragment",source:this.source||this.fs,debug:this.props.debugShaders})),this.pipeline=this.pipelineFactory.createRenderPipeline({...this.props,bufferLayout:this.bufferLayout,topology:this.topology,parameters:this.parameters,vs:e,fs:r}),this._attributeInfos=FE(this.pipeline.shaderLayout,this.bufferLayout),A&&this.shaderFactory.release(A),j&&this.shaderFactory.release(j)}return this.pipeline}_logDrawCallStart(){let A=mA.level>3?0:qnA;mA.level<2||Date.now()-this._lastLogTime>> DRAWING MODEL ${this.id}`,{collapsed:mA.level<=2})())}_logDrawCallEnd(){if(this._logOpen){let A=wR(this.pipeline.shaderLayout,this.id);mA.table(bB,A)();let j=this.shaderInputs.getDebugTable();for(let[r,n]of Object.entries(this.uniforms))j[r]={value:n};mA.table(bB,j)();let e=this._getAttributeDebugTable();mA.table(bB,this._attributeInfos)(),mA.table(bB,e)(),mA.groupEnd(bB)(),this._logOpen=!1}}_logFramebuffer(A){let j=mA.get("framebuffer");if(this._drawCount++,!j||this._drawCount++>3&&this._drawCount%60)return;let e=A.props.framebuffer;e&&FR(e,{id:e.id,minimap:!0})}_getAttributeDebugTable(){let A={};for(let[j,e]of Object.entries(this._attributeInfos))A[e.location]={name:j,type:e.shaderType,values:this._getBufferOrConstantValues(this.vertexArray.attributes[e.location],e.bufferDataType)};if(this.vertexArray.indexBuffer){let{indexBuffer:j}=this.vertexArray,e=j.indexType==="uint32"?new Uint32Array(j.debugData):new Uint16Array(j.debugData);A.indices={name:"indices",type:j.indexType,values:e.toString()}}return A}_getBufferOrConstantValues(A,j){let e=ep(j);return(A instanceof Aj?new e(A.debugData):A).toString()}};I(_$,"defaultProps",{...rs.defaultProps,source:null,vs:null,fs:null,id:"unnamed",handle:void 0,userData:{},defines:{},modules:[],moduleSettings:void 0,geometry:null,indexBuffer:null,attributes:{},constantAttributes:{},varyings:[],isInstanced:void 0,instanceCount:0,vertexCount:0,shaderInputs:void 0,pipelineFactory:void 0,shaderFactory:void 0,transformFeedback:void 0,shaderAssembler:Bc.getDefaultShaderAssembler(),debugShaders:void 0,disableWarnings:void 0});var ke=_$;function PR(t,A){let j=[...t];for(let e of A){let r=j.findIndex(n=>n.name===e.name);r<0?j.push(e):j[r]=e}return j}function bnA(t){return{type:t.type,shaderLanguage:t.info.shadingLanguage,shaderLanguageVersion:t.info.shadingLanguageVersion,gpu:t.info.gpu,features:t.features}}function IR(t){return t.attributes?t.attributes?.map(A=>A.attribute):[t.name]}var S7=class t{constructor(A,j=ke.defaultProps){I(this,"device");I(this,"model");I(this,"transformFeedback");Ot(t.isSupported(A),"BufferTransform not yet implemented on WebGPU"),this.device=A,this.model=new ke(this.device,{id:j.id||"buffer-transform-model",fs:j.fs||Yb(),topology:j.topology||"point-list",...j}),this.transformFeedback=this.device.createTransformFeedback({layout:this.model.pipeline.shaderLayout,buffers:j.feedbackBuffers}),this.model.setTransformFeedback(this.transformFeedback),Object.seal(this)}static isSupported(A){return A?.info?.type==="webgl"}destroy(){this.model&&this.model.destroy()}delete(){this.destroy()}run(A){let j=this.device.beginRenderPass(A);this.model.draw(j),j.end()}update(...A){console.warn("TextureTransform#update() not implemented")}getBuffer(A){return this.transformFeedback.getBuffer(A)}readAsync(A){let j=this.getBuffer(A);if(j instanceof Aj)return j.readAsync();let{buffer:e,byteOffset:r=0,byteLength:n=e.byteLength}=j;return e.readAsync(r,n)}};var ln=class{constructor(A){I(this,"id");I(this,"topology");I(this,"vertexCount");I(this,"indices");I(this,"attributes");I(this,"userData",{});let{attributes:j={},indices:e=null,vertexCount:r=null}=A;this.id=A.id||Pn("geometry"),this.topology=A.topology,e&&(this.indices=ArrayBuffer.isView(e)?{value:e,size:1}:e),this.attributes={};for(let[n,i]of Object.entries(j)){let o=ArrayBuffer.isView(i)?{value:i}:i;Ot(ArrayBuffer.isView(o.value),`${this._print(n)}: must be typed array or object with value as typed array`),(n==="POSITION"||n==="positions")&&!o.size&&(o.size=3),n==="indices"?(Ot(!this.indices),this.indices=o):this.attributes[n]=o}this.indices&&this.indices.isIndexed!==void 0&&(this.indices=Object.assign({},this.indices),delete this.indices.isIndexed),this.vertexCount=r||this._calculateVertexCount(this.attributes,this.indices)}getVertexCount(){return this.vertexCount}getAttributes(){return this.indices?{indices:this.indices,...this.attributes}:this.attributes}_print(A){return`Geometry ${this.id} attribute ${A}`}_setAttributes(A,j){return this}_calculateVertexCount(A,j){if(j)return j.value.length;let e=1/0;for(let r of Object.values(A)){let{value:n,size:i,constant:o}=r;!o&&n&&i>=1&&(e=Math.min(e,n.length/i))}return Ot(Number.isFinite(e)),e}};var GnA={blendColorOperation:"add",blendColorSrcFactor:"one",blendColorDstFactor:"zero",blendAlphaOperation:"add",blendAlphaSrcFactor:"constant-alpha",blendAlphaDstFactor:"zero"},vc=class extends wa{constructor(){super(...arguments),this._colorEncoderState=null}render(A){return"pickingFBO"in A?this._drawPickingBuffer(A):super.render(A)}_drawPickingBuffer({layers:A,layerFilter:j,views:e,viewports:r,onViewportActive:n,pickingFBO:i,deviceRect:{x:o,y:l,width:c,height:B},cullRect:h,effects:d,pass:k="picking",pickZ:g,moduleParameters:E}){this.pickZ=g;let m=this._resetColorEncoder(g),y=[o,l,c,B],G=super.render({target:i,layers:A,layerFilter:j,views:e,viewports:r,onViewportActive:n,cullRect:h,effects:d?.filter(_=>_.useInPicking),pass:k,isPicking:!0,moduleParameters:E,clearColor:[0,0,0,0],colorMask:15,scissorRect:y});return this._colorEncoderState=null,{decodePickingColor:m&&FnA.bind(null,m),stats:G}}shouldDrawLayer(A){let{pickable:j,operation:e}=A.props;return j&&e.includes("draw")||e.includes("terrain")||e.includes("mask")}getModuleParameters(){return{picking:{isActive:1,isAttribute:this.pickZ},lightSources:{}}}getLayerParameters(A,j,e){let r={depthMask:!0,depthTest:!0,depthRange:[0,1],...A.props.parameters},{pickable:n,operation:i}=A.props;return!this._colorEncoderState||i.includes("terrain")?r.blend=!1:n&&i.includes("draw")&&(Object.assign(r,GnA),r.blend=!0,r.blendColor=wnA(this._colorEncoderState,A,e)),r}_resetColorEncoder(A){return this._colorEncoderState=A?null:{byLayer:new Map,byAlpha:[]},this._colorEncoderState}};function wnA(t,A,j){let{byLayer:e,byAlpha:r}=t,n,i=e.get(A);return i?(i.viewports.push(j),n=i.a):(n=e.size+1,n<=255?(i={a:n,layer:A,viewports:[j]},e.set(A,i),r[n]=i):(NA.warn("Too many pickable layers, only picking the first 255")(),n=0)),[0,0,0,n/255]}function FnA(t,A){let j=t.byAlpha[A[3]];return j&&{pickedLayer:j.layer,pickedViewports:j.viewports,pickedObjectIndex:j.layer.decodePickingColor(A)}}var R7={NO_STATE:"Awaiting state",MATCHED:"Matched. State transferred from previous layer",INITIALIZED:"Initialized",AWAITING_GC:"Discarded. Awaiting garbage collection",AWAITING_FINALIZATION:"No longer matched. Awaiting garbage collection",FINALIZED:"Finalized! Awaiting garbage collection"},GB=Symbol.for("component"),bi=Symbol.for("propTypes"),q$=Symbol.for("deprecatedProps"),Pa=Symbol.for("asyncPropDefaults"),ls=Symbol.for("asyncPropOriginal"),mo=Symbol.for("asyncPropResolved");function Ia(t,A=()=>!0){return Array.isArray(t)?MR(t,A,[]):A(t)?[t]:[]}function MR(t,A,j){let e=-1;for(;++e0}delete(){}getData(){return this.isLoaded?this._error?Promise.reject(this._error):this._content:this._loader.then(()=>this.getData())}setData(A,j){if(A===this._data&&!j)return;this._data=A;let e=++this._loadCount,r=A;typeof A=="string"&&(r=As(A)),r instanceof Promise?(this.isLoaded=!1,this._loader=r.then(n=>{this._loadCount===e&&(this.isLoaded=!0,this._error=void 0,this._content=n)}).catch(n=>{this._loadCount===e&&(this.isLoaded=!0,this._error=n||!0)})):(this.isLoaded=!0,this._error=void 0,this._content=A);for(let n of this._subscribers)n.onChange(this.getData())}};var vp=class{constructor(A){this.protocol=A.protocol||"resource://",this._context={device:A.device,gl:A.device?.gl,resourceManager:this},this._resources={},this._consumers={},this._pruneRequest=null}contains(A){return A.startsWith(this.protocol)?!0:A in this._resources}add({resourceId:A,data:j,forceUpdate:e=!1,persistent:r=!0}){let n=this._resources[A];n?n.setData(j,e):(n=new yp(A,j,this._context),this._resources[A]=n),n.persistent=r}remove(A){let j=this._resources[A];j&&(j.delete(),delete this._resources[A])}unsubscribe({consumerId:A}){let j=this._consumers[A];if(j){for(let e in j){let r=j[e],n=this._resources[r.resourceId];n&&n.unsubscribe(r)}delete this._consumers[A],this.prune()}}subscribe({resourceId:A,onChange:j,consumerId:e,requestId:r="default"}){let{_resources:n,protocol:i}=this;A.startsWith(i)&&(A=A.replace(i,""),n[A]||this.add({resourceId:A,data:null,persistent:!1}));let o=n[A];if(this._track(e,r,o,j),o)return o.getData()}prune(){this._pruneRequest||(this._pruneRequest=setTimeout(()=>this._prune(),0))}finalize(){for(let A in this._resources)this._resources[A].delete()}_track(A,j,e,r){let n=this._consumers,i=n[A]=n[A]||{},o=i[j],l=o&&o.resourceId&&this._resources[o.resourceId];l&&(l.unsubscribe(o),this.prune()),e&&(o?(o.onChange=r,o.resourceId=e.id):o={onChange:r,resourceId:e.id},i[j]=o,e.subscribe(o))}_prune(){this._pruneRequest=null;for(let A of Object.keys(this._resources)){let j=this._resources[A];!j.persistent&&!j.inUse()&&(j.delete(),delete this._resources[A])}}};var PnA="layerManager.setLayers",InA="layerManager.activateViewport",wB=class{constructor(A,j){this._lastRenderedLayers=[],this._needsRedraw=!1,this._needsUpdate=!1,this._nextLayers=null,this._debug=!1,this._defaultShaderModulesChanged=!1,this.activateViewport=o=>{he(InA,this,o),o&&(this.context.viewport=o)};let{deck:e,stats:r,viewport:n,timeline:i}=j||{};this.layers=[],this.resourceManager=new vp({device:A,protocol:"deck://"}),this.context={mousePosition:null,userData:{},layerManager:this,device:A,gl:A?.gl,deck:e,shaderAssembler:Lw(),defaultShaderModules:[],renderPass:void 0,stats:r||new v6({id:"deck.gl"}),viewport:n||new go({id:"DEFAULT-INITIAL-VIEWPORT"}),timeline:i||new yc,resourceManager:this.resourceManager,onError:void 0},Object.seal(this)}finalize(){this.resourceManager.finalize();for(let A of this.layers)this._finalizeLayer(A)}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;A.clearRedrawFlags&&(this._needsRedraw=!1);for(let e of this.layers){let r=e.getNeedsRedraw(A);j=j||r}return j}needsUpdate(){return this._nextLayers&&this._nextLayers!==this._lastRenderedLayers?"layers changed":this._defaultShaderModulesChanged?"shader modules changed":this._needsUpdate}setNeedsRedraw(A){this._needsRedraw=this._needsRedraw||A}setNeedsUpdate(A){this._needsUpdate=this._needsUpdate||A}getLayers({layerIds:A}={}){return A?this.layers.filter(j=>A.find(e=>j.id.indexOf(e)===0)):this.layers}setProps(A){"debug"in A&&(this._debug=A.debug),"userData"in A&&(this.context.userData=A.userData),"layers"in A&&(this._nextLayers=A.layers),"onError"in A&&(this.context.onError=A.onError)}setLayers(A,j){he(PnA,this,j,A),this._lastRenderedLayers=A;let e=Ia(A,Boolean);for(let r of e)r.context=this.context;this._updateLayers(this.layers,e)}updateLayers(){let A=this.needsUpdate();A&&(this.setNeedsRedraw(`updating layers: ${A}`),this.setLayers(this._nextLayers||this._lastRenderedLayers,A)),this._nextLayers=null}addDefaultShaderModule(A){let{defaultShaderModules:j}=this.context;j.find(e=>e.name===A.name)||(j.push(A),this._defaultShaderModulesChanged=!0)}removeDefaultShaderModule(A){let{defaultShaderModules:j}=this.context,e=j.findIndex(r=>r.name===A.name);e>=0&&(j.splice(e,1),this._defaultShaderModulesChanged=!0)}_handleError(A,j,e){e.raiseError(j,`${A} of ${e}`)}_updateLayers(A,j){let e={};for(let i of A)e[i.id]?NA.warn(`Multiple old layers with same id ${i.id}`)():e[i.id]=i;if(this._defaultShaderModulesChanged){for(let i of A)i.setNeedsUpdate(),i.setChangeFlags({extensionsChanged:!0});this._defaultShaderModulesChanged=!1}let r=[];this._updateSublayersRecursively(j,e,r),this._finalizeOldLayers(e);let n=!1;for(let i of r)if(i.hasUniformTransition()){n=`Uniform transition in ${i}`;break}this._needsUpdate=n,this.layers=r}_updateSublayersRecursively(A,j,e){for(let r of A){r.context=this.context;let n=j[r.id];n===null&&NA.warn(`Multiple new layers with same id ${r.id}`)(),j[r.id]=null;let i=null;try{this._debug&&n!==r&&r.validateProps(),n?(this._transferLayerState(n,r),this._updateLayer(r)):this._initializeLayer(r),e.push(r),i=r.isComposite?r.getSubLayers():null}catch(o){this._handleError("matching",o,r)}i&&this._updateSublayersRecursively(i,j,e)}}_finalizeOldLayers(A){for(let j in A){let e=A[j];e&&this._finalizeLayer(e)}}_initializeLayer(A){try{A._initialize(),A.lifecycle=R7.INITIALIZED}catch(j){this._handleError("initialization",j,A)}}_transferLayerState(A,j){j._transferState(A),j.lifecycle=R7.MATCHED,j!==A&&(A.lifecycle=R7.AWAITING_GC)}_updateLayer(A){try{A._update()}catch(j){this._handleError("update",j,A)}}_finalizeLayer(A){this._needsRedraw=this._needsRedraw||`finalized ${A}`,A.lifecycle=R7.AWAITING_FINALIZATION;try{A._finalize(),A.lifecycle=R7.FINALIZED}catch(j){this._handleError("finalization",j,A)}}};function Hr(t,A,j){if(t===A)return!0;if(!j||!t||!A)return!1;if(Array.isArray(t)){if(!Array.isArray(A)||t.length!==A.length)return!1;for(let e=0;ej.containsPixel(A)):this._viewports}getViews(){let A={};return this.views.forEach(j=>{A[j.id]=j}),A}getView(A){return this.views.find(j=>j.id===A)}getViewState(A){let j=typeof A=="string"?this.getView(A):A,e=j&&this.viewState[j.getViewStateId()]||this.viewState;return j?j.filterViewState(e):e}getViewport(A){return this._viewportMap[A]}unproject(A,j){let e=this.getViewports(),r={x:A[0],y:A[1]};for(let n=e.length-1;n>=0;--n){let i=e[n];if(i.containsPixel(r)){let o=A.slice();return o[0]-=i.x,o[1]-=i.y,i.unproject(o,j)}}return null}setProps(A){A.views&&this._setViews(A.views),A.viewState&&this._setViewState(A.viewState),("width"in A||"height"in A)&&this._setSize(A.width,A.height),this._isUpdating||this._update()}_update(){this._isUpdating=!0,this._needsUpdate&&(this._needsUpdate=!1,this._rebuildViewports()),this._needsUpdate&&(this._needsUpdate=!1,this._rebuildViewports()),this._isUpdating=!1}_setSize(A,j){(A!==this.width||j!==this.height)&&(this.width=A,this.height=j,this.setNeedsUpdate("Size changed"))}_setViews(A){A=Ia(A,Boolean),this._diffViews(A,this.views)&&this.setNeedsUpdate("views changed"),this.views=A}_setViewState(A){A?(!Hr(A,this.viewState,3)&&this.setNeedsUpdate("viewState changed"),this.viewState=A):NA.warn("missing `viewState` or `initialViewState`")()}_createController(A,j){let e=j.type;return new e({timeline:this.timeline,eventManager:this._eventManager,onViewStateChange:this._eventCallbacks.onViewStateChange,onStateChange:this._eventCallbacks.onInteractionStateChange,makeViewport:n=>this.getView(A.id)?.makeViewport({viewState:n,width:this.width,height:this.height})})}_updateController(A,j,e,r){let n=A.controller;if(n&&e){let i={...j,...n,id:A.id,x:e.x,y:e.y,width:e.width,height:e.height};return(!r||r.constructor!==n.type)&&(r=this._createController(A,i)),r&&r.setProps(i),r}return null}_rebuildViewports(){let{views:A}=this,j=this.controllers;this._viewports=[],this.controllers={};let e=!1;for(let r=A.length;r--;){let n=A[r],i=this.getViewState(n),o=n.makeViewport({viewState:i,width:this.width,height:this.height}),l=j[n.id],c=!!n.controller;c&&!l&&(e=!0),(e||!c)&&l&&(l.finalize(),l=null),this.controllers[n.id]=this._updateController(n,i,o,l),o&&this._viewports.unshift(o)}for(let r in j){let n=j[r];n&&!this.controllers[r]&&n.finalize()}this._buildViewportMap()}_buildViewportMap(){this._viewportMap={},this._viewports.forEach(A=>{A.id&&(this._viewportMap[A.id]=this._viewportMap[A.id]||A)})}_diffViews(A,j){return A.length!==j.length?!0:A.some((e,r)=>!A[r].equals(j[r]))}};var MnA=/([0-9]+\.?[0-9]*)(%|px)/;function Ma(t){switch(typeof t){case"number":return{position:t,relative:!1};case"string":let A=MnA.exec(t);if(A&&A.length>=3){let j=A[2]==="%",e=parseFloat(A[1]);return{position:j?e/100:e,relative:j}}default:throw new Error(`Could not parse position string ${t}`)}}function Oa(t,A){return t.relative?Math.round(t.position*A):t.position}var cs=class{constructor(A){let{id:j,x:e=0,y:r=0,width:n="100%",height:i="100%",padding:o=null}=A;this.id=j||this.constructor.displayName||"view",this.props={...A,id:this.id},this._x=Ma(e),this._y=Ma(r),this._width=Ma(n),this._height=Ma(i),this._padding=o&&{left:Ma(o.left||0),right:Ma(o.right||0),top:Ma(o.top||0),bottom:Ma(o.bottom||0)},this.equals=this.equals.bind(this),Object.seal(this)}equals(A){return this===A?!0:this.ViewportType===A.ViewportType&&Hr(this.props,A.props,2)}makeViewport({width:A,height:j,viewState:e}){e=this.filterViewState(e);let r=this.getDimensions({width:A,height:j});return!r.height||!r.width?null:new this.ViewportType({...e,...this.props,...r})}getViewStateId(){let{viewState:A}=this.props;return typeof A=="string"?A:A?.id||this.id}filterViewState(A){if(this.props.viewState&&typeof this.props.viewState=="object"){if(!this.props.viewState.id)return this.props.viewState;let j={...A};for(let e in this.props.viewState)e!=="id"&&(j[e]=this.props.viewState[e]);return j}return A}getDimensions({width:A,height:j}){let e={x:Oa(this._x,A),y:Oa(this._y,j),width:Oa(this._width,A),height:Oa(this._height,j)};return this._padding&&(e.padding={left:Oa(this._padding.left,A),top:Oa(this._padding.top,j),right:Oa(this._padding.right,A),bottom:Oa(this._padding.bottom,j)}),e}get controller(){let A=this.props.controller;return A?A===!0?{type:this.ControllerType}:typeof A=="function"?{type:A}:{type:this.ControllerType,...A}:null}};var Eo=class{constructor(A){this._inProgress=!1,this._handle=null,this.time=0,this.settings={duration:0},this._timeline=A}get inProgress(){return this._inProgress}start(A){this.cancel(),this.settings=A,this._inProgress=!0,this.settings.onStart?.(this)}end(){this._inProgress&&(this._timeline.removeChannel(this._handle),this._handle=null,this._inProgress=!1,this.settings.onEnd?.(this))}cancel(){this._inProgress&&(this.settings.onInterrupt?.(this),this._timeline.removeChannel(this._handle),this._handle=null,this._inProgress=!1)}update(){if(!this._inProgress)return!1;if(this._handle===null){let{_timeline:A,settings:j}=this;this._handle=A.addChannel({delay:A.getTime(),duration:j.duration})}return this.time=this._timeline.getTime(this._handle),this._onUpdate(),this.settings.onUpdate?.(this),this._timeline.isFinished(this._handle)&&this.end(),!0}_onUpdate(){}};var OR=()=>{},b$={BREAK:1,SNAP_TO_END:2,IGNORE:3},OnA=t=>t,TnA=b$.BREAK,qp=class{constructor(A){this._onTransitionUpdate=j=>{let{time:e,settings:{interpolator:r,startProps:n,endProps:i,duration:o,easing:l}}=j,c=l(e/o),B=r.interpolateProps(n,i,c);this.propsInTransition=this.getControllerState({...this.props,...B}).getViewportProps(),this.onViewStateChange({viewState:this.propsInTransition,oldViewState:this.props})},this.getControllerState=A.getControllerState,this.propsInTransition=null,this.transition=new Eo(A.timeline),this.onViewStateChange=A.onViewStateChange||OR,this.onStateChange=A.onStateChange||OR}finalize(){this.transition.cancel()}getViewportInTransition(){return this.propsInTransition}processViewStateChange(A){let j=!1,e=this.props;if(this.props=A,!e||this._shouldIgnoreViewportChange(e,A))return!1;if(this._isTransitionEnabled(A)){let r=e;if(this.transition.inProgress){let{interruption:n,endProps:i}=this.transition.settings;r={...e,...n===b$.SNAP_TO_END?i:this.propsInTransition||e}}this._triggerTransition(r,A),j=!0}else this.transition.cancel();return j}updateTransition(){this.transition.update()}_isTransitionEnabled(A){let{transitionDuration:j,transitionInterpolator:e}=A;return(j>0||j==="auto")&&!!e}_isUpdateDueToCurrentTransition(A){return this.transition.inProgress&&this.propsInTransition?this.transition.settings.interpolator.arePropsEqual(A,this.propsInTransition):!1}_shouldIgnoreViewportChange(A,j){return this.transition.inProgress?this.transition.settings.interruption===b$.IGNORE||this._isUpdateDueToCurrentTransition(j):this._isTransitionEnabled(j)?j.transitionInterpolator.arePropsEqual(A,j):!0}_triggerTransition(A,j){let e=this.getControllerState(A),r=this.getControllerState(j).shortestPathFrom(e),n=j.transitionInterpolator,i=n.getDuration?n.getDuration(A,j):j.transitionDuration;if(i===0)return;let o=n.initializeProps(A,r);this.propsInTransition={};let l={duration:i,easing:j.transitionEasing||OnA,interpolator:n,interruption:j.transitionInterruption||TnA,startProps:o.start,endProps:o.end,onStart:j.onTransitionStart,onUpdate:this._onTransitionUpdate,onInterrupt:this._onTransitionEnd(j.onTransitionInterrupt),onEnd:this._onTransitionEnd(j.onTransitionEnd)};this.transition.start(l),this.onStateChange({inTransition:!0}),this.updateTransition()}_onTransitionEnd(A){return j=>{this.propsInTransition=null,this.onStateChange({inTransition:!1,isZooming:!1,isPanning:!1,isRotating:!1}),A?.(j)}}};function Xj(t,A){if(!t)throw new Error(A||"deck.gl: assertion failed.")}var FB=class{constructor(A){let{compare:j,extract:e,required:r}=A;this._propsToCompare=j,this._propsToExtract=e||j,this._requiredProps=r}arePropsEqual(A,j){for(let e of this._propsToCompare)if(!(e in A)||!(e in j)||!Bo(A[e],j[e]))return!1;return!0}initializeProps(A,j){let e={},r={};for(let n of this._propsToExtract)(n in A||n in j)&&(e[n]=A[n],r[n]=j[n]);return this._checkRequiredProps(e),this._checkRequiredProps(r),{start:e,end:r}}getDuration(A,j){return j.transitionDuration}_checkRequiredProps(A){this._requiredProps&&this._requiredProps.forEach(j=>{let e=A[j];Xj(Number.isFinite(e)||Array.isArray(e),`${j} is required for transition`)})}};var SnA=["longitude","latitude","zoom","bearing","pitch"],RnA=["longitude","latitude","zoom"],Gi=class extends FB{constructor(A={}){let j=Array.isArray(A)?A:A.transitionProps,e=Array.isArray(A)?{}:A;e.transitionProps=Array.isArray(j)?{compare:j,required:j}:j||{compare:SnA,required:RnA},super(e.transitionProps),this.opts=e}initializeProps(A,j){let e=super.initializeProps(A,j),{makeViewport:r,around:n}=this.opts;if(r&&n){let i=r(A),o=r(j),l=i.unproject(n);e.start.around=n,Object.assign(e.end,{around:o.project(l),aroundPosition:l,width:j.width,height:j.height})}return e}interpolateProps(A,j,e){let r={};for(let n of this._propsToExtract)r[n]=uo(A[n]||0,j[n]||0,e);if(j.aroundPosition&&this.opts.makeViewport){let n=this.opts.makeViewport({...j,...r});Object.assign(r,n.panByPosition(j.aroundPosition,uo(A.around,j.around,e)))}return r}};var L7={transitionDuration:0},LnA=300,G$=t=>1-(1-t)*(1-t),PB={WHEEL:["wheel"],PAN:["panstart","panmove","panend"],PINCH:["pinchstart","pinchmove","pinchend"],TRIPLE_PAN:["tripanstart","tripanmove","tripanend"],DOUBLE_TAP:["doubletap"],KEYBOARD:["keydown"]},_c={},us=class{constructor(A){this.state={},this._events={},this._interactionState={isDragging:!1},this._customEvents=[],this._eventStartBlocked=null,this._panMove=!1,this.invertPan=!1,this.dragMode="rotate",this.inertia=0,this.scrollZoom=!0,this.dragPan=!0,this.dragRotate=!0,this.doubleClickZoom=!0,this.touchZoom=!0,this.touchRotate=!1,this.keyboard=!0,this.transitionManager=new qp({...A,getControllerState:j=>new this.ControllerState(j),onViewStateChange:this._onTransition.bind(this),onStateChange:this._setInteractionState.bind(this)}),this.handleEvent=this.handleEvent.bind(this),this.eventManager=A.eventManager,this.onViewStateChange=A.onViewStateChange||(()=>{}),this.onStateChange=A.onStateChange||(()=>{}),this.makeViewport=A.makeViewport}set events(A){this.toggleEvents(this._customEvents,!1),this.toggleEvents(A,!0),this._customEvents=A,this.props&&this.setProps(this.props)}finalize(){for(let A in this._events)this._events[A]&&this.eventManager?.off(A,this.handleEvent);this.transitionManager.finalize()}handleEvent(A){this._controllerState=void 0;let j=this._eventStartBlocked;switch(A.type){case"panstart":return j?!1:this._onPanStart(A);case"panmove":return this._onPan(A);case"panend":return this._onPanEnd(A);case"pinchstart":return j?!1:this._onPinchStart(A);case"pinchmove":return this._onPinch(A);case"pinchend":return this._onPinchEnd(A);case"tripanstart":return j?!1:this._onTriplePanStart(A);case"tripanmove":return this._onTriplePan(A);case"tripanend":return this._onTriplePanEnd(A);case"doubletap":return this._onDoubleTap(A);case"wheel":return this._onWheel(A);case"keydown":return this._onKeyDown(A);default:return!1}}get controllerState(){return this._controllerState=this._controllerState||new this.ControllerState({makeViewport:this.makeViewport,...this.props,...this.state}),this._controllerState}getCenter(A){let{x:j,y:e}=this.props,{offsetCenter:r}=A;return[r.x-j,r.y-e]}isPointInBounds(A,j){let{width:e,height:r}=this.props;if(j&&j.handled)return!1;let n=A[0]>=0&&A[0]<=e&&A[1]>=0&&A[1]<=r;return n&&j&&j.stopPropagation(),n}isFunctionKeyPressed(A){let{srcEvent:j}=A;return!!(j.metaKey||j.altKey||j.ctrlKey||j.shiftKey)}isDragging(){return this._interactionState.isDragging||!1}blockEvents(A){let j=setTimeout(()=>{this._eventStartBlocked===j&&(this._eventStartBlocked=null)},A);this._eventStartBlocked=j}setProps(A){A.dragMode&&(this.dragMode=A.dragMode),this.props=A,"transitionInterpolator"in A||(A.transitionInterpolator=this._getTransitionProps().transitionInterpolator),this.transitionManager.processViewStateChange(A);let{inertia:j}=A;this.inertia=Number.isFinite(j)?j:j===!0?LnA:0;let{scrollZoom:e=!0,dragPan:r=!0,dragRotate:n=!0,doubleClickZoom:i=!0,touchZoom:o=!0,touchRotate:l=!1,keyboard:c=!0}=A,B=!!this.onViewStateChange;this.toggleEvents(PB.WHEEL,B&&e),this.toggleEvents(PB.PAN,B),this.toggleEvents(PB.PINCH,B&&(o||l)),this.toggleEvents(PB.TRIPLE_PAN,B&&l),this.toggleEvents(PB.DOUBLE_TAP,B&&i),this.toggleEvents(PB.KEYBOARD,B&&c),this.scrollZoom=e,this.dragPan=r,this.dragRotate=n,this.doubleClickZoom=i,this.touchZoom=o,this.touchRotate=l,this.keyboard=c}updateTransition(){this.transitionManager.updateTransition()}toggleEvents(A,j){this.eventManager&&A.forEach(e=>{this._events[e]!==j&&(this._events[e]=j,j?this.eventManager.on(e,this.handleEvent):this.eventManager.off(e,this.handleEvent))})}updateViewport(A,j=null,e={}){let r={...A.getViewportProps(),...j},n=this.controllerState!==A;if(this.state=A.getState(),this._setInteractionState(e),n){let i=this.controllerState&&this.controllerState.getViewportProps();this.onViewStateChange&&this.onViewStateChange({viewState:r,interactionState:this._interactionState,oldViewState:i,viewId:this.props.id})}}_onTransition(A){this.onViewStateChange({...A,interactionState:this._interactionState,viewId:this.props.id})}_setInteractionState(A){Object.assign(this._interactionState,A),this.onStateChange(this._interactionState)}_onPanStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.isFunctionKeyPressed(A)||A.rightButton||!1;(this.invertPan||this.dragMode==="pan")&&(e=!e);let r=this.controllerState[e?"panStart":"rotateStart"]({pos:j});return this._panMove=e,this.updateViewport(r,L7,{isDragging:!0}),!0}_onPan(A){return this.isDragging()?this._panMove?this._onPanMove(A):this._onPanRotate(A):!1}_onPanEnd(A){return this.isDragging()?this._panMove?this._onPanMoveEnd(A):this._onPanRotateEnd(A):!1}_onPanMove(A){if(!this.dragPan)return!1;let j=this.getCenter(A),e=this.controllerState.pan({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isPanning:!0}),!0}_onPanMoveEnd(A){let{inertia:j}=this;if(this.dragPan&&j&&A.velocity){let e=this.getCenter(A),r=[e[0]+A.velocityX*j/2,e[1]+A.velocityY*j/2],n=this.controllerState.pan({pos:r}).panEnd();this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:G$},{isDragging:!1,isPanning:!0})}else{let e=this.controllerState.panEnd();this.updateViewport(e,null,{isDragging:!1,isPanning:!1})}return!0}_onPanRotate(A){if(!this.dragRotate)return!1;let j=this.getCenter(A),e=this.controllerState.rotate({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isRotating:!0}),!0}_onPanRotateEnd(A){let{inertia:j}=this;if(this.dragRotate&&j&&A.velocity){let e=this.getCenter(A),r=[e[0]+A.velocityX*j/2,e[1]+A.velocityY*j/2],n=this.controllerState.rotate({pos:r}).rotateEnd();this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:G$},{isDragging:!1,isRotating:!0})}else{let e=this.controllerState.rotateEnd();this.updateViewport(e,null,{isDragging:!1,isRotating:!1})}return!0}_onWheel(A){if(!this.scrollZoom)return!1;let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;A.srcEvent.preventDefault();let{speed:e=.01,smooth:r=!1}=this.scrollZoom===!0?{}:this.scrollZoom,{delta:n}=A,i=2/(1+Math.exp(-Math.abs(n*e)));n<0&&i!==0&&(i=1/i);let o=this.controllerState.zoom({pos:j,scale:i});return this.updateViewport(o,{...this._getTransitionProps({around:j}),transitionDuration:r?250:1},{isZooming:!0,isPanning:!0}),!0}_onTriplePanStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.controllerState.rotateStart({pos:j});return this.updateViewport(e,L7,{isDragging:!0}),!0}_onTriplePan(A){if(!this.touchRotate||!this.isDragging())return!1;let j=this.getCenter(A);j[0]-=A.deltaX;let e=this.controllerState.rotate({pos:j});return this.updateViewport(e,L7,{isDragging:!0,isRotating:!0}),!0}_onTriplePanEnd(A){if(!this.isDragging())return!1;let{inertia:j}=this;if(this.touchRotate&&j&&A.velocityY){let e=this.getCenter(A),r=[e[0],e[1]+=A.velocityY*j/2],n=this.controllerState.rotate({pos:r});this.updateViewport(n,{...this._getTransitionProps(),transitionDuration:j,transitionEasing:G$},{isDragging:!1,isRotating:!0}),this.blockEvents(j)}else{let e=this.controllerState.rotateEnd();this.updateViewport(e,null,{isDragging:!1,isRotating:!1})}return!0}_onPinchStart(A){let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.controllerState.zoomStart({pos:j}).rotateStart({pos:j});return _c._startPinchRotation=A.rotation,_c._lastPinchEvent=A,this.updateViewport(e,L7,{isDragging:!0}),!0}_onPinch(A){if(!this.touchZoom&&!this.touchRotate||!this.isDragging())return!1;let j=this.controllerState;if(this.touchZoom){let{scale:e}=A,r=this.getCenter(A);j=j.zoom({pos:r,scale:e})}if(this.touchRotate){let{rotation:e}=A;j=j.rotate({deltaAngleX:_c._startPinchRotation-e})}return this.updateViewport(j,L7,{isDragging:!0,isPanning:this.touchZoom,isZooming:this.touchZoom,isRotating:this.touchRotate}),_c._lastPinchEvent=A,!0}_onPinchEnd(A){if(!this.isDragging())return!1;let{inertia:j}=this,{_lastPinchEvent:e}=_c;if(this.touchZoom&&j&&e&&A.scale!==e.scale){let r=this.getCenter(A),n=this.controllerState.rotateEnd(),i=Math.log2(A.scale),o=(i-Math.log2(e.scale))/(A.deltaTime-e.deltaTime),l=Math.pow(2,i+o*j/2);n=n.zoom({pos:r,scale:l}).zoomEnd(),this.updateViewport(n,{...this._getTransitionProps({around:r}),transitionDuration:j,transitionEasing:G$},{isDragging:!1,isPanning:this.touchZoom,isZooming:this.touchZoom,isRotating:!1}),this.blockEvents(j)}else{let r=this.controllerState.zoomEnd().rotateEnd();this.updateViewport(r,null,{isDragging:!1,isPanning:!1,isZooming:!1,isRotating:!1})}return _c._startPinchRotation=null,_c._lastPinchEvent=null,!0}_onDoubleTap(A){if(!this.doubleClickZoom)return!1;let j=this.getCenter(A);if(!this.isPointInBounds(j,A))return!1;let e=this.isFunctionKeyPressed(A),r=this.controllerState.zoom({pos:j,scale:e?.5:2});return this.updateViewport(r,this._getTransitionProps({around:j}),{isZooming:!0,isPanning:!0}),this.blockEvents(100),!0}_onKeyDown(A){if(!this.keyboard)return!1;let j=this.isFunctionKeyPressed(A),{zoomSpeed:e,moveSpeed:r,rotateSpeedX:n,rotateSpeedY:i}=this.keyboard===!0?{}:this.keyboard,{controllerState:o}=this,l,c={};switch(A.srcEvent.code){case"Minus":l=j?o.zoomOut(e).zoomOut(e):o.zoomOut(e),c.isZooming=!0;break;case"Equal":l=j?o.zoomIn(e).zoomIn(e):o.zoomIn(e),c.isZooming=!0;break;case"ArrowLeft":j?(l=o.rotateLeft(n),c.isRotating=!0):(l=o.moveLeft(r),c.isPanning=!0);break;case"ArrowRight":j?(l=o.rotateRight(n),c.isRotating=!0):(l=o.moveRight(r),c.isPanning=!0);break;case"ArrowUp":j?(l=o.rotateUp(i),c.isRotating=!0):(l=o.moveUp(r),c.isPanning=!0);break;case"ArrowDown":j?(l=o.rotateDown(i),c.isRotating=!0):(l=o.moveDown(r),c.isPanning=!0);break;default:return!1}return this.updateViewport(l,this._getTransitionProps(),c),!0}_getTransitionProps(A){let{transition:j}=this;return!j||!j.transitionInterpolator?L7:A?{...j,transitionInterpolator:new Gi({...A,...j.transitionInterpolator.opts,makeViewport:this.controllerState.makeViewport})}:j}};var qc=class{constructor(A,j){this._viewportProps=this.applyConstraints(A),this._state=j}getViewportProps(){return this._viewportProps}getState(){return this._state}};var TR=5,CnA=1.2,Xw=class extends qc{constructor(A){let{width:j,height:e,latitude:r,longitude:n,zoom:i,bearing:o=0,pitch:l=0,altitude:c=1.5,position:B=[0,0,0],maxZoom:h=20,minZoom:d=0,maxPitch:k=60,minPitch:g=0,startPanLngLat:E,startZoomLngLat:m,startRotatePos:y,startBearing:G,startPitch:v,startZoom:_,normalize:w=!0}=A;Xj(Number.isFinite(n)),Xj(Number.isFinite(r)),Xj(Number.isFinite(i)),super({width:j,height:e,latitude:r,longitude:n,zoom:i,bearing:o,pitch:l,altitude:c,maxZoom:h,minZoom:d,maxPitch:k,minPitch:g,normalize:w,position:B},{startPanLngLat:E,startZoomLngLat:m,startRotatePos:y,startBearing:G,startPitch:v,startZoom:_}),this.makeViewport=A.makeViewport}panStart({pos:A}){return this._getUpdatedState({startPanLngLat:this._unproject(A)})}pan({pos:A,startPos:j}){let e=this.getState().startPanLngLat||this._unproject(j);if(!e)return this;let n=this.makeViewport(this.getViewportProps()).panByPosition(e,A);return this._getUpdatedState(n)}panEnd(){return this._getUpdatedState({startPanLngLat:null})}rotateStart({pos:A}){return this._getUpdatedState({startRotatePos:A,startBearing:this.getViewportProps().bearing,startPitch:this.getViewportProps().pitch})}rotate({pos:A,deltaAngleX:j=0,deltaAngleY:e=0}){let{startRotatePos:r,startBearing:n,startPitch:i}=this.getState();if(!r||n===void 0||i===void 0)return this;let o;return A?o=this._getNewRotation(A,r,i,n):o={bearing:n+j,pitch:i+e},this._getUpdatedState(o)}rotateEnd(){return this._getUpdatedState({startBearing:null,startPitch:null})}zoomStart({pos:A}){return this._getUpdatedState({startZoomLngLat:this._unproject(A),startZoom:this.getViewportProps().zoom})}zoom({pos:A,startPos:j,scale:e}){let{startZoom:r,startZoomLngLat:n}=this.getState();if(n||(r=this.getViewportProps().zoom,n=this._unproject(j)||this._unproject(A)),!n)return this;let{maxZoom:i,minZoom:o}=this.getViewportProps(),l=r+Math.log2(e);l=Kj(l,o,i);let c=this.makeViewport({...this.getViewportProps(),zoom:l});return this._getUpdatedState({zoom:l,...c.panByPosition(n,A)})}zoomEnd(){return this._getUpdatedState({startZoomLngLat:null,startZoom:null})}zoomIn(A=2){return this._zoomFromCenter(A)}zoomOut(A=2){return this._zoomFromCenter(1/A)}moveLeft(A=100){return this._panFromCenter([A,0])}moveRight(A=100){return this._panFromCenter([-A,0])}moveUp(A=100){return this._panFromCenter([0,A])}moveDown(A=100){return this._panFromCenter([0,-A])}rotateLeft(A=15){return this._getUpdatedState({bearing:this.getViewportProps().bearing-A})}rotateRight(A=15){return this._getUpdatedState({bearing:this.getViewportProps().bearing+A})}rotateUp(A=10){return this._getUpdatedState({pitch:this.getViewportProps().pitch+A})}rotateDown(A=10){return this._getUpdatedState({pitch:this.getViewportProps().pitch-A})}shortestPathFrom(A){let j=A.getViewportProps(),e={...this.getViewportProps()},{bearing:r,longitude:n}=e;return Math.abs(r-j.bearing)>180&&(e.bearing=r<0?r+360:r-360),Math.abs(n-j.longitude)>180&&(e.longitude=n<0?n+360:n-360),e}applyConstraints(A){let{maxZoom:j,minZoom:e,zoom:r}=A;A.zoom=Kj(r,e,j);let{maxPitch:n,minPitch:i,pitch:o}=A;A.pitch=Kj(o,i,n);let{normalize:l=!0}=A;return l&&Object.assign(A,Rw(A)),A}_zoomFromCenter(A){let{width:j,height:e}=this.getViewportProps();return this.zoom({pos:[j/2,e/2],scale:A})}_panFromCenter(A){let{width:j,height:e}=this.getViewportProps();return this.pan({startPos:[j/2,e/2],pos:[j/2+A[0],e/2+A[1]]})}_getUpdatedState(A){return new this.constructor({makeViewport:this.makeViewport,...this.getViewportProps(),...this.getState(),...A})}_unproject(A){let j=this.makeViewport(this.getViewportProps());return A&&j.unproject(A)}_getNewRotation(A,j,e,r){let n=A[0]-j[0],i=A[1]-j[1],o=A[1],l=j[1],{width:c,height:B}=this.getViewportProps(),h=n/c,d=0;i>0?Math.abs(B-l)>TR&&(d=i/(l-B)*CnA):i<0&&l>TR&&(d=1-o/l),d=Kj(d,-1,1);let{minPitch:k,maxPitch:g}=this.getViewportProps(),E=r+180*h,m=e;return d>0?m=e+d*(g-e):d<0&&(m=e-d*(k-e)),{pitch:m,bearing:E}}},IB=class extends us{constructor(){super(...arguments),this.ControllerState=Xw,this.transition={transitionDuration:300,transitionInterpolator:new Gi({transitionProps:{compare:["longitude","latitude","zoom","bearing","pitch","position"],required:["longitude","latitude","zoom"]}})},this.dragMode="pan"}setProps(A){A.position=A.position||[0,0,0];let j=this.props;super.setProps(A),(!j||j.height!==A.height)&&this.updateViewport(new this.ControllerState({makeViewport:this.makeViewport,...A,...this.state}))}};var w$=class extends cs{constructor(A={}){super(A)}get ViewportType(){return Fa}get ControllerType(){return IB}};w$.displayName="MapView";var zw=w$;var HnA=new xc;function DnA(t,A){let j=t.order??1/0,e=A.order??1/0;return j-e}var bp=class{constructor(A){this._resolvedEffects=[],this._defaultEffects=[],this.effects=[],this._context=A,this._needsRedraw="Initial render",this._setEffects([])}addDefaultEffect(A){let j=this._defaultEffects;if(!j.find(e=>e.id===A.id)){let e=j.findIndex(r=>DnA(r,A)>0);e<0?j.push(A):j.splice(e,0,A),A.setup(this._context),this._setEffects(this.effects)}}setProps(A){"effects"in A&&(Hr(A.effects,this.effects,1)||this._setEffects(A.effects))}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;return A.clearRedrawFlags&&(this._needsRedraw=!1),j}getEffects(){return this._resolvedEffects}_setEffects(A){let j={};for(let r of this.effects)j[r.id]=r;let e=[];for(let r of A){let n=j[r.id],i=r;n&&n!==r?n.setProps?(n.setProps(r.props),i=n):n.cleanup(this._context):n||r.setup(this._context),e.push(i),delete j[r.id]}for(let r in j)j[r].cleanup(this._context);this.effects=e,this._resolvedEffects=e.concat(this._defaultEffects),A.some(r=>r instanceof xc)||this._resolvedEffects.push(HnA),this._needsRedraw="effects changed"}finalize(){for(let A of this._resolvedEffects)A.cleanup(this._context);this.effects.length=0,this._resolvedEffects.length=0,this._defaultEffects.length=0}};var Gp=class extends wa{shouldDrawLayer(A){let{operation:j}=A.props;return j.includes("draw")||j.includes("terrain")}};var NnA="deckRenderer.renderLayers",MB=class{constructor(A){this.device=A,this.layerFilter=null,this.drawPickingColors=!1,this.drawLayersPass=new Gp(A),this.pickLayersPass=new vc(A),this.renderCount=0,this._needsRedraw="Initial render",this.renderBuffers=[],this.lastPostProcessEffect=null}setProps(A){this.layerFilter!==A.layerFilter&&(this.layerFilter=A.layerFilter,this._needsRedraw="layerFilter changed"),this.drawPickingColors!==A.drawPickingColors&&(this.drawPickingColors=A.drawPickingColors,this._needsRedraw="drawPickingColors changed")}renderLayers(A){if(!A.viewports.length)return;let j=this.drawPickingColors?this.pickLayersPass:this.drawLayersPass,e={layerFilter:this.layerFilter,isPicking:this.drawPickingColors,...A};e.effects&&this._preRender(e.effects,e);let r=this.lastPostProcessEffect?this.renderBuffers[0]:e.target;this.lastPostProcessEffect&&(e.clearColor=[0,0,0,0],e.clearCanvas=!0);let n=j.render({...e,target:r});e.effects&&this._postRender(e.effects,e),this.renderCount++,he(NnA,this,n,A)}needsRedraw(A={clearRedrawFlags:!1}){let j=this._needsRedraw;return A.clearRedrawFlags&&(this._needsRedraw=!1),j}finalize(){let{renderBuffers:A}=this;for(let j of A)j.delete();A.length=0}_preRender(A,j){this.lastPostProcessEffect=null,j.preRenderStats=j.preRenderStats||{};for(let e of A)j.preRenderStats[e.id]=e.preRender(j),e.postRender&&(this.lastPostProcessEffect=e.id);this.lastPostProcessEffect&&this._resizeRenderBuffers()}_resizeRenderBuffers(){let{renderBuffers:A}=this,j=this.device.canvasContext.getDrawingBufferSize();A.length===0&&[0,1].map(e=>{let r=this.device.createTexture({sampler:{minFilter:"linear",magFilter:"linear"}});A.push(this.device.createFramebuffer({id:`deck-renderbuffer-${e}`,colorAttachments:[r]}))});for(let e of A)e.resize(j)}_postRender(A,j){let{renderBuffers:e}=this,r={...j,inputBuffer:e[0],swapBuffer:e[1]};for(let n of A)if(n.postRender){r.target=n.id===this.lastPostProcessEffect?j.target:void 0;let i=n.postRender(r);r.inputBuffer=i,r.swapBuffer=i===e[0]?e[1]:e[0]}}};var KnA={pickedColor:null,pickedObjectIndex:-1};function SR({pickedColors:t,decodePickingColor:A,deviceX:j,deviceY:e,deviceRadius:r,deviceRect:n}){let{x:i,y:o,width:l,height:c}=n,B=r*r,h=-1,d=0;for(let k=0;kB)d+=4*l;else for(let m=0;m=0){let G=m+i-j,v=G*G+E;v<=B&&(B=v,h=d)}d+=4}}if(h>=0){let k=t.slice(h,h+4),g=A(k);if(g){let E=Math.floor(h/4/l),m=h/4-E*l;return{...g,pickedColor:k,pickedX:i+m,pickedY:o+E}}NA.error("Picked non-existent layer. Is picking buffer corrupt?")()}return KnA}function RR({pickedColors:t,decodePickingColor:A}){let j=new Map;if(t){for(let e=0;e=0){let n=t.slice(e,e+4),i=n.join(",");if(!j.has(i)){let o=A(n);o?j.set(i,{...o,color:n}):NA.error("Picked non-existent layer. Is picking buffer corrupt?")()}}}return Array.from(j.values())}function Uw({pickInfo:t,viewports:A,pixelRatio:j,x:e,y:r,z:n}){let i=A[0];A.length>1&&(i=XnA(t?.pickedViewports||A,{x:e,y:r}));let o;if(i){let l=[e-i.x,r-i.y];n!==void 0&&(l[2]=n),o=i.unproject(l)}return{color:null,layer:null,viewport:i,index:-1,picked:!1,x:e,y:r,pixel:[e,r],coordinate:o,devicePixel:t&&"pickedX"in t?[t.pickedX,t.pickedY]:void 0,pixelRatio:j}}function LR(t){let{pickInfo:A,lastPickedInfo:j,mode:e,layers:r}=t,{pickedColor:n,pickedLayer:i,pickedObjectIndex:o}=A,l=i?[i]:[];if(e==="hover"){let h=j.index,d=j.layerId,k=i?i.props.id:null;if(k!==d||o!==h){if(k!==d){let g=r.find(E=>E.props.id===d);g&&l.unshift(g)}j.layerId=k,j.index=o,j.info=null}}let c=Uw(t),B=new Map;return B.set(null,c),l.forEach(h=>{let d={...c};h===i&&(d.color=n,d.index=o,d.picked=!0),d=Vw({layer:h,info:d,mode:e});let k=d.layer;h===i&&e==="hover"&&(j.info=d),B.set(k.id,d),e==="hover"&&k.updateAutoHighlight(d)}),B}function Vw({layer:t,info:A,mode:j}){for(;t&&A;){let e=A.layer||null;A.sourceLayer=e,A.layer=t,A=t.getPickingInfo({info:A,mode:j,sourceLayer:e}),t=t.parent}return A}function XnA(t,A){for(let j=t.length-1;j>=0;j--){let e=t[j];if(e.containsPixel(A))return e}return t[0]}var wp=class{constructor(A){this._pickable=!0,this.device=A,this.pickLayersPass=new vc(A),this.lastPickedInfo={index:-1,layerId:null,info:null}}setProps(A){"layerFilter"in A&&(this.layerFilter=A.layerFilter),"_pickable"in A&&(this._pickable=A._pickable)}finalize(){this.pickingFBO&&this.pickingFBO.destroy(),this.depthFBO&&this.depthFBO.destroy()}pickObject(A){return this._pickClosestObject(A)}pickObjects(A){return this._pickVisibleObjects(A)}getLastPickedObject({x:A,y:j,layers:e,viewports:r},n=this.lastPickedInfo.info){let i=n&&n.layer&&n.layer.id,o=n&&n.viewport&&n.viewport.id,l=i?e.find(d=>d.id===i):null,c=o&&r.find(d=>d.id===o)||r[0],B=c&&c.unproject([A-c.x,j-c.y]);return{...n,...{x:A,y:j,viewport:c,coordinate:B,layer:l}}}_resizeBuffer(){if(!this.pickingFBO&&(this.pickingFBO=this.device.createFramebuffer({colorAttachments:["rgba8unorm"],depthStencilAttachment:"depth16unorm"}),this.device.isTextureFormatRenderable("rgba32float"))){let j=this.device.createFramebuffer({colorAttachments:["rgba32float"],depthStencilAttachment:"depth16unorm"});this.depthFBO=j}let{canvas:A}=this.device.getCanvasContext();this.pickingFBO?.resize({width:A.width,height:A.height}),this.depthFBO?.resize({width:A.width,height:A.height})}_getPickable(A){if(this._pickable===!1)return null;let j=A.filter(e=>this.pickLayersPass.shouldDrawLayer(e)&&!e.isComposite);return j.length?j:null}_pickClosestObject({layers:A,views:j,viewports:e,x:r,y:n,radius:i=0,depth:o=1,mode:l="query",unproject3D:c,onViewportActive:B,effects:h}){let d=this.device.canvasContext.cssToDeviceRatio(),k=this._getPickable(A);if(!k||e.length===0)return{result:[],emptyInfo:Uw({viewports:e,x:r,y:n,pixelRatio:d})};this._resizeBuffer();let g=this.device.canvasContext.cssToDevicePixels([r,n],!0),E=[g.x+Math.floor(g.width/2),g.y+Math.floor(g.height/2)],m=Math.round(i*d),{width:y,height:G}=this.pickingFBO,v=this._getPickingRect({deviceX:E[0],deviceY:E[1],deviceRadius:m,deviceWidth:y,deviceHeight:G}),_={x:r-i,y:n-i,width:i*2+1,height:i*2+1},w,x=[],O=new Set;for(let F=0;F=c);R++){let X=x[R],T={color:X.pickedColor,layer:null,index:X.pickedObjectIndex,picked:!0,x:r,y:n,pixelRatio:k};T=Vw({layer:X.pickedLayer,info:T,mode:l});let Q=T.layer.id;O.has(Q)||O.set(Q,new Set);let b=O.get(Q),jA=T.object??T.index;b.has(jA)||(b.add(jA),F.push(T))}return F}_drawAndSample({layers:A,views:j,viewports:e,onViewportActive:r,deviceRect:n,cullRect:i,effects:o,pass:l},c=!1){let B=c?this.depthFBO:this.pickingFBO,h={layers:A,layerFilter:this.layerFilter,views:j,viewports:e,onViewportActive:r,pickingFBO:B,deviceRect:n,cullRect:i,effects:o,pass:l,pickZ:c,preRenderStats:{}};for(let G of o)G.useInPicking&&(h.preRenderStats[G.id]=G.preRender(h));let{decodePickingColor:d}=this.pickLayersPass.render(h),{x:k,y:g,width:E,height:m}=n,y=new(c?Float32Array:Uint8Array)(E*m*4);return this.device.readPixelsToArrayWebGL(B,{sourceX:k,sourceY:g,sourceWidth:E,sourceHeight:m,target:y}),{pickedColors:y,decodePickingColor:d}}_getPickingRect({deviceX:A,deviceY:j,deviceRadius:e,deviceWidth:r,deviceHeight:n}){let i=Math.max(0,A-e),o=Math.max(0,j-e),l=Math.min(r,A+e+1)-i,c=Math.min(n,j+e+1)-o;return l<=0||c<=0?null:{x:i,y:o,width:l,height:c}}};var znA={"top-left":{top:0,left:0},"top-right":{top:0,right:0},"bottom-left":{bottom:0,left:0},"bottom-right":{bottom:0,right:0},fill:{top:0,left:0,bottom:0,right:0}},UnA="top-left",CR="__root",F$=class{constructor({deck:A,parentElement:j}){this.defaultWidgets=[],this.widgets=[],this.resolvedWidgets=[],this.containers={},this.lastViewports={},this.deck=A,this.parentElement=j}getWidgets(){return this.resolvedWidgets}setProps(A){A.widgets&&!Hr(A.widgets,this.widgets,1)&&this._setWidgets(A.widgets)}finalize(){for(let A of this.getWidgets())this._remove(A);this.defaultWidgets.length=0,this.resolvedWidgets.length=0;for(let A in this.containers)this.containers[A].remove()}addDefault(A){this.defaultWidgets.find(j=>j.id===A.id)||(this._add(A),this.defaultWidgets.push(A),this._setWidgets(this.widgets))}_setWidgets(A){let j={};for(let e of this.resolvedWidgets)j[e.id]=e;this.resolvedWidgets.length=0;for(let e of this.defaultWidgets)j[e.id]=null,this.resolvedWidgets.push(e);for(let e of A){let r=j[e.id];r?r.viewId!==e.viewId||r.placement!==e.placement?(this._remove(r),this._add(e)):e!==r&&(r.setProps(e.props),e=r):this._add(e),j[e.id]=null,this.resolvedWidgets.push(e)}for(let e in j){let r=j[e];r&&this._remove(r)}this.widgets=A}_add(A){let{viewId:j=null,placement:e=UnA}=A,r=A.onAdd({deck:this.deck,viewId:j});r&&this._getContainer(j,e).append(r),A._element=r}_remove(A){A.onRemove(),A._element&&A._element.remove(),A._element=void 0}_getContainer(A,j){let e=A||CR,r=this.containers[e];r||(r=document.createElement("div"),r.style.pointerEvents="none",r.style.position="absolute",r.style.overflow="hidden",this.parentElement?.append(r),this.containers[e]=r);let n=r.querySelector(`.${j}`);return n||(n=document.createElement("div"),n.className=j,n.style.position="absolute",n.style.zIndex="2",Object.assign(n.style,znA[j]),r.append(n)),n}_updateContainers(){let A=this.deck.width,j=this.deck.height;for(let e in this.containers){let r=this.lastViewports[e]||null,n=e===CR||r,i=this.containers[e];n?(i.style.display="block",i.style.left=`${r?r.x:0}px`,i.style.top=`${r?r.y:0}px`,i.style.width=`${r?r.width:A}px`,i.style.height=`${r?r.height:j}px`):i.style.display="none"}}onRedraw({viewports:A,layers:j}){let e=A.reduce((n,i)=>(n[i.id]=i,n),{}),{lastViewports:r}=this;for(let n of this.getWidgets()){let{viewId:i}=n;if(i){let o=e[i];o&&(n.onViewportChange&&!o.equals(r[i])&&n.onViewportChange(o),n.onRedraw?.({viewports:[o],layers:j}))}else{if(n.onViewportChange)for(let o of A)o.equals(r[o.id])||n.onViewportChange(o);n.onRedraw?.({viewports:A,layers:j})}}this.lastViewports=e,this._updateContainers()}onHover(A,j){for(let e of this.getWidgets()){let{viewId:r}=e;(!r||r===A.viewport?.id)&&e.onHover?.(A,j)}}onEvent(A,j){let e=Bp[j.type];if(e)for(let r of this.getWidgets()){let{viewId:n}=r;(!n||n===A.viewport?.id)&&r[e.handler]?.(A,j)}}};var VnA={zIndex:"1",position:"absolute",pointerEvents:"none",color:"#a0a7b4",backgroundColor:"#29323c",padding:"10px",top:"0",left:"0",display:"none"},Fp=class{constructor(){this.id="default-tooltip",this.placement="fill",this.props={},this.isVisible=!1}onAdd({deck:A}){let j=document.createElement("div");return j.className="deck-tooltip",Object.assign(j.style,VnA),this.deck=A,this.element=j,j}onRemove(){this.deck=void 0,this.element=void 0}setProps(){}onViewportChange(A){this.isVisible&&A.id===this.lastViewport?.id&&A!==this.lastViewport&&this.setTooltip(null)}onHover(A){let{deck:j}=this,e=j&&j.props.getTooltip;if(!e)return;let r=e(A);this.lastViewport=A.viewport,this.setTooltip(r,A.x,A.y)}setTooltip(A,j,e){let r=this.element;if(r){if(typeof A=="string")r.innerText=A;else if(A)A.text&&(r.innerText=A.text),A.html&&(r.innerHTML=A.html),A.className&&(r.className=A.className);else{this.isVisible=!1,r.style.display="none";return}this.isVisible=!0,r.style.display="block",r.style.transform=`translate(${j}px, ${e}px)`,A&&typeof A=="object"&&"style"in A&&Object.assign(r.style,A.style)}}};var C7;(function(t){t[t.DEPTH_BUFFER_BIT=256]="DEPTH_BUFFER_BIT",t[t.STENCIL_BUFFER_BIT=1024]="STENCIL_BUFFER_BIT",t[t.COLOR_BUFFER_BIT=16384]="COLOR_BUFFER_BIT",t[t.POINTS=0]="POINTS",t[t.LINES=1]="LINES",t[t.LINE_LOOP=2]="LINE_LOOP",t[t.LINE_STRIP=3]="LINE_STRIP",t[t.TRIANGLES=4]="TRIANGLES",t[t.TRIANGLE_STRIP=5]="TRIANGLE_STRIP",t[t.TRIANGLE_FAN=6]="TRIANGLE_FAN",t[t.ZERO=0]="ZERO",t[t.ONE=1]="ONE",t[t.SRC_COLOR=768]="SRC_COLOR",t[t.ONE_MINUS_SRC_COLOR=769]="ONE_MINUS_SRC_COLOR",t[t.SRC_ALPHA=770]="SRC_ALPHA",t[t.ONE_MINUS_SRC_ALPHA=771]="ONE_MINUS_SRC_ALPHA",t[t.DST_ALPHA=772]="DST_ALPHA",t[t.ONE_MINUS_DST_ALPHA=773]="ONE_MINUS_DST_ALPHA",t[t.DST_COLOR=774]="DST_COLOR",t[t.ONE_MINUS_DST_COLOR=775]="ONE_MINUS_DST_COLOR",t[t.SRC_ALPHA_SATURATE=776]="SRC_ALPHA_SATURATE",t[t.CONSTANT_COLOR=32769]="CONSTANT_COLOR",t[t.ONE_MINUS_CONSTANT_COLOR=32770]="ONE_MINUS_CONSTANT_COLOR",t[t.CONSTANT_ALPHA=32771]="CONSTANT_ALPHA",t[t.ONE_MINUS_CONSTANT_ALPHA=32772]="ONE_MINUS_CONSTANT_ALPHA",t[t.FUNC_ADD=32774]="FUNC_ADD",t[t.FUNC_SUBTRACT=32778]="FUNC_SUBTRACT",t[t.FUNC_REVERSE_SUBTRACT=32779]="FUNC_REVERSE_SUBTRACT",t[t.BLEND_EQUATION=32777]="BLEND_EQUATION",t[t.BLEND_EQUATION_RGB=32777]="BLEND_EQUATION_RGB",t[t.BLEND_EQUATION_ALPHA=34877]="BLEND_EQUATION_ALPHA",t[t.BLEND_DST_RGB=32968]="BLEND_DST_RGB",t[t.BLEND_SRC_RGB=32969]="BLEND_SRC_RGB",t[t.BLEND_DST_ALPHA=32970]="BLEND_DST_ALPHA",t[t.BLEND_SRC_ALPHA=32971]="BLEND_SRC_ALPHA",t[t.BLEND_COLOR=32773]="BLEND_COLOR",t[t.ARRAY_BUFFER_BINDING=34964]="ARRAY_BUFFER_BINDING",t[t.ELEMENT_ARRAY_BUFFER_BINDING=34965]="ELEMENT_ARRAY_BUFFER_BINDING",t[t.LINE_WIDTH=2849]="LINE_WIDTH",t[t.ALIASED_POINT_SIZE_RANGE=33901]="ALIASED_POINT_SIZE_RANGE",t[t.ALIASED_LINE_WIDTH_RANGE=33902]="ALIASED_LINE_WIDTH_RANGE",t[t.CULL_FACE_MODE=2885]="CULL_FACE_MODE",t[t.FRONT_FACE=2886]="FRONT_FACE",t[t.DEPTH_RANGE=2928]="DEPTH_RANGE",t[t.DEPTH_WRITEMASK=2930]="DEPTH_WRITEMASK",t[t.DEPTH_CLEAR_VALUE=2931]="DEPTH_CLEAR_VALUE",t[t.DEPTH_FUNC=2932]="DEPTH_FUNC",t[t.STENCIL_CLEAR_VALUE=2961]="STENCIL_CLEAR_VALUE",t[t.STENCIL_FUNC=2962]="STENCIL_FUNC",t[t.STENCIL_FAIL=2964]="STENCIL_FAIL",t[t.STENCIL_PASS_DEPTH_FAIL=2965]="STENCIL_PASS_DEPTH_FAIL",t[t.STENCIL_PASS_DEPTH_PASS=2966]="STENCIL_PASS_DEPTH_PASS",t[t.STENCIL_REF=2967]="STENCIL_REF",t[t.STENCIL_VALUE_MASK=2963]="STENCIL_VALUE_MASK",t[t.STENCIL_WRITEMASK=2968]="STENCIL_WRITEMASK",t[t.STENCIL_BACK_FUNC=34816]="STENCIL_BACK_FUNC",t[t.STENCIL_BACK_FAIL=34817]="STENCIL_BACK_FAIL",t[t.STENCIL_BACK_PASS_DEPTH_FAIL=34818]="STENCIL_BACK_PASS_DEPTH_FAIL",t[t.STENCIL_BACK_PASS_DEPTH_PASS=34819]="STENCIL_BACK_PASS_DEPTH_PASS",t[t.STENCIL_BACK_REF=36003]="STENCIL_BACK_REF",t[t.STENCIL_BACK_VALUE_MASK=36004]="STENCIL_BACK_VALUE_MASK",t[t.STENCIL_BACK_WRITEMASK=36005]="STENCIL_BACK_WRITEMASK",t[t.VIEWPORT=2978]="VIEWPORT",t[t.SCISSOR_BOX=3088]="SCISSOR_BOX",t[t.COLOR_CLEAR_VALUE=3106]="COLOR_CLEAR_VALUE",t[t.COLOR_WRITEMASK=3107]="COLOR_WRITEMASK",t[t.UNPACK_ALIGNMENT=3317]="UNPACK_ALIGNMENT",t[t.PACK_ALIGNMENT=3333]="PACK_ALIGNMENT",t[t.MAX_TEXTURE_SIZE=3379]="MAX_TEXTURE_SIZE",t[t.MAX_VIEWPORT_DIMS=3386]="MAX_VIEWPORT_DIMS",t[t.SUBPIXEL_BITS=3408]="SUBPIXEL_BITS",t[t.RED_BITS=3410]="RED_BITS",t[t.GREEN_BITS=3411]="GREEN_BITS",t[t.BLUE_BITS=3412]="BLUE_BITS",t[t.ALPHA_BITS=3413]="ALPHA_BITS",t[t.DEPTH_BITS=3414]="DEPTH_BITS",t[t.STENCIL_BITS=3415]="STENCIL_BITS",t[t.POLYGON_OFFSET_UNITS=10752]="POLYGON_OFFSET_UNITS",t[t.POLYGON_OFFSET_FACTOR=32824]="POLYGON_OFFSET_FACTOR",t[t.TEXTURE_BINDING_2D=32873]="TEXTURE_BINDING_2D",t[t.SAMPLE_BUFFERS=32936]="SAMPLE_BUFFERS",t[t.SAMPLES=32937]="SAMPLES",t[t.SAMPLE_COVERAGE_VALUE=32938]="SAMPLE_COVERAGE_VALUE",t[t.SAMPLE_COVERAGE_INVERT=32939]="SAMPLE_COVERAGE_INVERT",t[t.COMPRESSED_TEXTURE_FORMATS=34467]="COMPRESSED_TEXTURE_FORMATS",t[t.VENDOR=7936]="VENDOR",t[t.RENDERER=7937]="RENDERER",t[t.VERSION=7938]="VERSION",t[t.IMPLEMENTATION_COLOR_READ_TYPE=35738]="IMPLEMENTATION_COLOR_READ_TYPE",t[t.IMPLEMENTATION_COLOR_READ_FORMAT=35739]="IMPLEMENTATION_COLOR_READ_FORMAT",t[t.BROWSER_DEFAULT_WEBGL=37444]="BROWSER_DEFAULT_WEBGL",t[t.STATIC_DRAW=35044]="STATIC_DRAW",t[t.STREAM_DRAW=35040]="STREAM_DRAW",t[t.DYNAMIC_DRAW=35048]="DYNAMIC_DRAW",t[t.ARRAY_BUFFER=34962]="ARRAY_BUFFER",t[t.ELEMENT_ARRAY_BUFFER=34963]="ELEMENT_ARRAY_BUFFER",t[t.BUFFER_SIZE=34660]="BUFFER_SIZE",t[t.BUFFER_USAGE=34661]="BUFFER_USAGE",t[t.CURRENT_VERTEX_ATTRIB=34342]="CURRENT_VERTEX_ATTRIB",t[t.VERTEX_ATTRIB_ARRAY_ENABLED=34338]="VERTEX_ATTRIB_ARRAY_ENABLED",t[t.VERTEX_ATTRIB_ARRAY_SIZE=34339]="VERTEX_ATTRIB_ARRAY_SIZE",t[t.VERTEX_ATTRIB_ARRAY_STRIDE=34340]="VERTEX_ATTRIB_ARRAY_STRIDE",t[t.VERTEX_ATTRIB_ARRAY_TYPE=34341]="VERTEX_ATTRIB_ARRAY_TYPE",t[t.VERTEX_ATTRIB_ARRAY_NORMALIZED=34922]="VERTEX_ATTRIB_ARRAY_NORMALIZED",t[t.VERTEX_ATTRIB_ARRAY_POINTER=34373]="VERTEX_ATTRIB_ARRAY_POINTER",t[t.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=34975]="VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",t[t.CULL_FACE=2884]="CULL_FACE",t[t.FRONT=1028]="FRONT",t[t.BACK=1029]="BACK",t[t.FRONT_AND_BACK=1032]="FRONT_AND_BACK",t[t.BLEND=3042]="BLEND",t[t.DEPTH_TEST=2929]="DEPTH_TEST",t[t.DITHER=3024]="DITHER",t[t.POLYGON_OFFSET_FILL=32823]="POLYGON_OFFSET_FILL",t[t.SAMPLE_ALPHA_TO_COVERAGE=32926]="SAMPLE_ALPHA_TO_COVERAGE",t[t.SAMPLE_COVERAGE=32928]="SAMPLE_COVERAGE",t[t.SCISSOR_TEST=3089]="SCISSOR_TEST",t[t.STENCIL_TEST=2960]="STENCIL_TEST",t[t.NO_ERROR=0]="NO_ERROR",t[t.INVALID_ENUM=1280]="INVALID_ENUM",t[t.INVALID_VALUE=1281]="INVALID_VALUE",t[t.INVALID_OPERATION=1282]="INVALID_OPERATION",t[t.OUT_OF_MEMORY=1285]="OUT_OF_MEMORY",t[t.CONTEXT_LOST_WEBGL=37442]="CONTEXT_LOST_WEBGL",t[t.CW=2304]="CW",t[t.CCW=2305]="CCW",t[t.DONT_CARE=4352]="DONT_CARE",t[t.FASTEST=4353]="FASTEST",t[t.NICEST=4354]="NICEST",t[t.GENERATE_MIPMAP_HINT=33170]="GENERATE_MIPMAP_HINT",t[t.BYTE=5120]="BYTE",t[t.UNSIGNED_BYTE=5121]="UNSIGNED_BYTE",t[t.SHORT=5122]="SHORT",t[t.UNSIGNED_SHORT=5123]="UNSIGNED_SHORT",t[t.INT=5124]="INT",t[t.UNSIGNED_INT=5125]="UNSIGNED_INT",t[t.FLOAT=5126]="FLOAT",t[t.DOUBLE=5130]="DOUBLE",t[t.DEPTH_COMPONENT=6402]="DEPTH_COMPONENT",t[t.ALPHA=6406]="ALPHA",t[t.RGB=6407]="RGB",t[t.RGBA=6408]="RGBA",t[t.LUMINANCE=6409]="LUMINANCE",t[t.LUMINANCE_ALPHA=6410]="LUMINANCE_ALPHA",t[t.UNSIGNED_SHORT_4_4_4_4=32819]="UNSIGNED_SHORT_4_4_4_4",t[t.UNSIGNED_SHORT_5_5_5_1=32820]="UNSIGNED_SHORT_5_5_5_1",t[t.UNSIGNED_SHORT_5_6_5=33635]="UNSIGNED_SHORT_5_6_5",t[t.FRAGMENT_SHADER=35632]="FRAGMENT_SHADER",t[t.VERTEX_SHADER=35633]="VERTEX_SHADER",t[t.COMPILE_STATUS=35713]="COMPILE_STATUS",t[t.DELETE_STATUS=35712]="DELETE_STATUS",t[t.LINK_STATUS=35714]="LINK_STATUS",t[t.VALIDATE_STATUS=35715]="VALIDATE_STATUS",t[t.ATTACHED_SHADERS=35717]="ATTACHED_SHADERS",t[t.ACTIVE_ATTRIBUTES=35721]="ACTIVE_ATTRIBUTES",t[t.ACTIVE_UNIFORMS=35718]="ACTIVE_UNIFORMS",t[t.MAX_VERTEX_ATTRIBS=34921]="MAX_VERTEX_ATTRIBS",t[t.MAX_VERTEX_UNIFORM_VECTORS=36347]="MAX_VERTEX_UNIFORM_VECTORS",t[t.MAX_VARYING_VECTORS=36348]="MAX_VARYING_VECTORS",t[t.MAX_COMBINED_TEXTURE_IMAGE_UNITS=35661]="MAX_COMBINED_TEXTURE_IMAGE_UNITS",t[t.MAX_VERTEX_TEXTURE_IMAGE_UNITS=35660]="MAX_VERTEX_TEXTURE_IMAGE_UNITS",t[t.MAX_TEXTURE_IMAGE_UNITS=34930]="MAX_TEXTURE_IMAGE_UNITS",t[t.MAX_FRAGMENT_UNIFORM_VECTORS=36349]="MAX_FRAGMENT_UNIFORM_VECTORS",t[t.SHADER_TYPE=35663]="SHADER_TYPE",t[t.SHADING_LANGUAGE_VERSION=35724]="SHADING_LANGUAGE_VERSION",t[t.CURRENT_PROGRAM=35725]="CURRENT_PROGRAM",t[t.NEVER=512]="NEVER",t[t.LESS=513]="LESS",t[t.EQUAL=514]="EQUAL",t[t.LEQUAL=515]="LEQUAL",t[t.GREATER=516]="GREATER",t[t.NOTEQUAL=517]="NOTEQUAL",t[t.GEQUAL=518]="GEQUAL",t[t.ALWAYS=519]="ALWAYS",t[t.KEEP=7680]="KEEP",t[t.REPLACE=7681]="REPLACE",t[t.INCR=7682]="INCR",t[t.DECR=7683]="DECR",t[t.INVERT=5386]="INVERT",t[t.INCR_WRAP=34055]="INCR_WRAP",t[t.DECR_WRAP=34056]="DECR_WRAP",t[t.NEAREST=9728]="NEAREST",t[t.LINEAR=9729]="LINEAR",t[t.NEAREST_MIPMAP_NEAREST=9984]="NEAREST_MIPMAP_NEAREST",t[t.LINEAR_MIPMAP_NEAREST=9985]="LINEAR_MIPMAP_NEAREST",t[t.NEAREST_MIPMAP_LINEAR=9986]="NEAREST_MIPMAP_LINEAR",t[t.LINEAR_MIPMAP_LINEAR=9987]="LINEAR_MIPMAP_LINEAR",t[t.TEXTURE_MAG_FILTER=10240]="TEXTURE_MAG_FILTER",t[t.TEXTURE_MIN_FILTER=10241]="TEXTURE_MIN_FILTER",t[t.TEXTURE_WRAP_S=10242]="TEXTURE_WRAP_S",t[t.TEXTURE_WRAP_T=10243]="TEXTURE_WRAP_T",t[t.TEXTURE_2D=3553]="TEXTURE_2D",t[t.TEXTURE=5890]="TEXTURE",t[t.TEXTURE_CUBE_MAP=34067]="TEXTURE_CUBE_MAP",t[t.TEXTURE_BINDING_CUBE_MAP=34068]="TEXTURE_BINDING_CUBE_MAP",t[t.TEXTURE_CUBE_MAP_POSITIVE_X=34069]="TEXTURE_CUBE_MAP_POSITIVE_X",t[t.TEXTURE_CUBE_MAP_NEGATIVE_X=34070]="TEXTURE_CUBE_MAP_NEGATIVE_X",t[t.TEXTURE_CUBE_MAP_POSITIVE_Y=34071]="TEXTURE_CUBE_MAP_POSITIVE_Y",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Y=34072]="TEXTURE_CUBE_MAP_NEGATIVE_Y",t[t.TEXTURE_CUBE_MAP_POSITIVE_Z=34073]="TEXTURE_CUBE_MAP_POSITIVE_Z",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Z=34074]="TEXTURE_CUBE_MAP_NEGATIVE_Z",t[t.MAX_CUBE_MAP_TEXTURE_SIZE=34076]="MAX_CUBE_MAP_TEXTURE_SIZE",t[t.TEXTURE0=33984]="TEXTURE0",t[t.ACTIVE_TEXTURE=34016]="ACTIVE_TEXTURE",t[t.REPEAT=10497]="REPEAT",t[t.CLAMP_TO_EDGE=33071]="CLAMP_TO_EDGE",t[t.MIRRORED_REPEAT=33648]="MIRRORED_REPEAT",t[t.TEXTURE_WIDTH=4096]="TEXTURE_WIDTH",t[t.TEXTURE_HEIGHT=4097]="TEXTURE_HEIGHT",t[t.FLOAT_VEC2=35664]="FLOAT_VEC2",t[t.FLOAT_VEC3=35665]="FLOAT_VEC3",t[t.FLOAT_VEC4=35666]="FLOAT_VEC4",t[t.INT_VEC2=35667]="INT_VEC2",t[t.INT_VEC3=35668]="INT_VEC3",t[t.INT_VEC4=35669]="INT_VEC4",t[t.BOOL=35670]="BOOL",t[t.BOOL_VEC2=35671]="BOOL_VEC2",t[t.BOOL_VEC3=35672]="BOOL_VEC3",t[t.BOOL_VEC4=35673]="BOOL_VEC4",t[t.FLOAT_MAT2=35674]="FLOAT_MAT2",t[t.FLOAT_MAT3=35675]="FLOAT_MAT3",t[t.FLOAT_MAT4=35676]="FLOAT_MAT4",t[t.SAMPLER_2D=35678]="SAMPLER_2D",t[t.SAMPLER_CUBE=35680]="SAMPLER_CUBE",t[t.LOW_FLOAT=36336]="LOW_FLOAT",t[t.MEDIUM_FLOAT=36337]="MEDIUM_FLOAT",t[t.HIGH_FLOAT=36338]="HIGH_FLOAT",t[t.LOW_INT=36339]="LOW_INT",t[t.MEDIUM_INT=36340]="MEDIUM_INT",t[t.HIGH_INT=36341]="HIGH_INT",t[t.FRAMEBUFFER=36160]="FRAMEBUFFER",t[t.RENDERBUFFER=36161]="RENDERBUFFER",t[t.RGBA4=32854]="RGBA4",t[t.RGB5_A1=32855]="RGB5_A1",t[t.RGB565=36194]="RGB565",t[t.DEPTH_COMPONENT16=33189]="DEPTH_COMPONENT16",t[t.STENCIL_INDEX=6401]="STENCIL_INDEX",t[t.STENCIL_INDEX8=36168]="STENCIL_INDEX8",t[t.DEPTH_STENCIL=34041]="DEPTH_STENCIL",t[t.RENDERBUFFER_WIDTH=36162]="RENDERBUFFER_WIDTH",t[t.RENDERBUFFER_HEIGHT=36163]="RENDERBUFFER_HEIGHT",t[t.RENDERBUFFER_INTERNAL_FORMAT=36164]="RENDERBUFFER_INTERNAL_FORMAT",t[t.RENDERBUFFER_RED_SIZE=36176]="RENDERBUFFER_RED_SIZE",t[t.RENDERBUFFER_GREEN_SIZE=36177]="RENDERBUFFER_GREEN_SIZE",t[t.RENDERBUFFER_BLUE_SIZE=36178]="RENDERBUFFER_BLUE_SIZE",t[t.RENDERBUFFER_ALPHA_SIZE=36179]="RENDERBUFFER_ALPHA_SIZE",t[t.RENDERBUFFER_DEPTH_SIZE=36180]="RENDERBUFFER_DEPTH_SIZE",t[t.RENDERBUFFER_STENCIL_SIZE=36181]="RENDERBUFFER_STENCIL_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=36048]="FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",t[t.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=36049]="FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=36050]="FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=36051]="FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",t[t.COLOR_ATTACHMENT0=36064]="COLOR_ATTACHMENT0",t[t.DEPTH_ATTACHMENT=36096]="DEPTH_ATTACHMENT",t[t.STENCIL_ATTACHMENT=36128]="STENCIL_ATTACHMENT",t[t.DEPTH_STENCIL_ATTACHMENT=33306]="DEPTH_STENCIL_ATTACHMENT",t[t.NONE=0]="NONE",t[t.FRAMEBUFFER_COMPLETE=36053]="FRAMEBUFFER_COMPLETE",t[t.FRAMEBUFFER_INCOMPLETE_ATTACHMENT=36054]="FRAMEBUFFER_INCOMPLETE_ATTACHMENT",t[t.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=36055]="FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",t[t.FRAMEBUFFER_INCOMPLETE_DIMENSIONS=36057]="FRAMEBUFFER_INCOMPLETE_DIMENSIONS",t[t.FRAMEBUFFER_UNSUPPORTED=36061]="FRAMEBUFFER_UNSUPPORTED",t[t.FRAMEBUFFER_BINDING=36006]="FRAMEBUFFER_BINDING",t[t.RENDERBUFFER_BINDING=36007]="RENDERBUFFER_BINDING",t[t.READ_FRAMEBUFFER=36008]="READ_FRAMEBUFFER",t[t.DRAW_FRAMEBUFFER=36009]="DRAW_FRAMEBUFFER",t[t.MAX_RENDERBUFFER_SIZE=34024]="MAX_RENDERBUFFER_SIZE",t[t.INVALID_FRAMEBUFFER_OPERATION=1286]="INVALID_FRAMEBUFFER_OPERATION",t[t.UNPACK_FLIP_Y_WEBGL=37440]="UNPACK_FLIP_Y_WEBGL",t[t.UNPACK_PREMULTIPLY_ALPHA_WEBGL=37441]="UNPACK_PREMULTIPLY_ALPHA_WEBGL",t[t.UNPACK_COLORSPACE_CONVERSION_WEBGL=37443]="UNPACK_COLORSPACE_CONVERSION_WEBGL",t[t.READ_BUFFER=3074]="READ_BUFFER",t[t.UNPACK_ROW_LENGTH=3314]="UNPACK_ROW_LENGTH",t[t.UNPACK_SKIP_ROWS=3315]="UNPACK_SKIP_ROWS",t[t.UNPACK_SKIP_PIXELS=3316]="UNPACK_SKIP_PIXELS",t[t.PACK_ROW_LENGTH=3330]="PACK_ROW_LENGTH",t[t.PACK_SKIP_ROWS=3331]="PACK_SKIP_ROWS",t[t.PACK_SKIP_PIXELS=3332]="PACK_SKIP_PIXELS",t[t.TEXTURE_BINDING_3D=32874]="TEXTURE_BINDING_3D",t[t.UNPACK_SKIP_IMAGES=32877]="UNPACK_SKIP_IMAGES",t[t.UNPACK_IMAGE_HEIGHT=32878]="UNPACK_IMAGE_HEIGHT",t[t.MAX_3D_TEXTURE_SIZE=32883]="MAX_3D_TEXTURE_SIZE",t[t.MAX_ELEMENTS_VERTICES=33e3]="MAX_ELEMENTS_VERTICES",t[t.MAX_ELEMENTS_INDICES=33001]="MAX_ELEMENTS_INDICES",t[t.MAX_TEXTURE_LOD_BIAS=34045]="MAX_TEXTURE_LOD_BIAS",t[t.MAX_FRAGMENT_UNIFORM_COMPONENTS=35657]="MAX_FRAGMENT_UNIFORM_COMPONENTS",t[t.MAX_VERTEX_UNIFORM_COMPONENTS=35658]="MAX_VERTEX_UNIFORM_COMPONENTS",t[t.MAX_ARRAY_TEXTURE_LAYERS=35071]="MAX_ARRAY_TEXTURE_LAYERS",t[t.MIN_PROGRAM_TEXEL_OFFSET=35076]="MIN_PROGRAM_TEXEL_OFFSET",t[t.MAX_PROGRAM_TEXEL_OFFSET=35077]="MAX_PROGRAM_TEXEL_OFFSET",t[t.MAX_VARYING_COMPONENTS=35659]="MAX_VARYING_COMPONENTS",t[t.FRAGMENT_SHADER_DERIVATIVE_HINT=35723]="FRAGMENT_SHADER_DERIVATIVE_HINT",t[t.RASTERIZER_DISCARD=35977]="RASTERIZER_DISCARD",t[t.VERTEX_ARRAY_BINDING=34229]="VERTEX_ARRAY_BINDING",t[t.MAX_VERTEX_OUTPUT_COMPONENTS=37154]="MAX_VERTEX_OUTPUT_COMPONENTS",t[t.MAX_FRAGMENT_INPUT_COMPONENTS=37157]="MAX_FRAGMENT_INPUT_COMPONENTS",t[t.MAX_SERVER_WAIT_TIMEOUT=37137]="MAX_SERVER_WAIT_TIMEOUT",t[t.MAX_ELEMENT_INDEX=36203]="MAX_ELEMENT_INDEX",t[t.RED=6403]="RED",t[t.RGB8=32849]="RGB8",t[t.RGBA8=32856]="RGBA8",t[t.RGB10_A2=32857]="RGB10_A2",t[t.TEXTURE_3D=32879]="TEXTURE_3D",t[t.TEXTURE_WRAP_R=32882]="TEXTURE_WRAP_R",t[t.TEXTURE_MIN_LOD=33082]="TEXTURE_MIN_LOD",t[t.TEXTURE_MAX_LOD=33083]="TEXTURE_MAX_LOD",t[t.TEXTURE_BASE_LEVEL=33084]="TEXTURE_BASE_LEVEL",t[t.TEXTURE_MAX_LEVEL=33085]="TEXTURE_MAX_LEVEL",t[t.TEXTURE_COMPARE_MODE=34892]="TEXTURE_COMPARE_MODE",t[t.TEXTURE_COMPARE_FUNC=34893]="TEXTURE_COMPARE_FUNC",t[t.SRGB=35904]="SRGB",t[t.SRGB8=35905]="SRGB8",t[t.SRGB8_ALPHA8=35907]="SRGB8_ALPHA8",t[t.COMPARE_REF_TO_TEXTURE=34894]="COMPARE_REF_TO_TEXTURE",t[t.RGBA32F=34836]="RGBA32F",t[t.RGB32F=34837]="RGB32F",t[t.RGBA16F=34842]="RGBA16F",t[t.RGB16F=34843]="RGB16F",t[t.TEXTURE_2D_ARRAY=35866]="TEXTURE_2D_ARRAY",t[t.TEXTURE_BINDING_2D_ARRAY=35869]="TEXTURE_BINDING_2D_ARRAY",t[t.R11F_G11F_B10F=35898]="R11F_G11F_B10F",t[t.RGB9_E5=35901]="RGB9_E5",t[t.RGBA32UI=36208]="RGBA32UI",t[t.RGB32UI=36209]="RGB32UI",t[t.RGBA16UI=36214]="RGBA16UI",t[t.RGB16UI=36215]="RGB16UI",t[t.RGBA8UI=36220]="RGBA8UI",t[t.RGB8UI=36221]="RGB8UI",t[t.RGBA32I=36226]="RGBA32I",t[t.RGB32I=36227]="RGB32I",t[t.RGBA16I=36232]="RGBA16I",t[t.RGB16I=36233]="RGB16I",t[t.RGBA8I=36238]="RGBA8I",t[t.RGB8I=36239]="RGB8I",t[t.RED_INTEGER=36244]="RED_INTEGER",t[t.RGB_INTEGER=36248]="RGB_INTEGER",t[t.RGBA_INTEGER=36249]="RGBA_INTEGER",t[t.R8=33321]="R8",t[t.RG8=33323]="RG8",t[t.R16F=33325]="R16F",t[t.R32F=33326]="R32F",t[t.RG16F=33327]="RG16F",t[t.RG32F=33328]="RG32F",t[t.R8I=33329]="R8I",t[t.R8UI=33330]="R8UI",t[t.R16I=33331]="R16I",t[t.R16UI=33332]="R16UI",t[t.R32I=33333]="R32I",t[t.R32UI=33334]="R32UI",t[t.RG8I=33335]="RG8I",t[t.RG8UI=33336]="RG8UI",t[t.RG16I=33337]="RG16I",t[t.RG16UI=33338]="RG16UI",t[t.RG32I=33339]="RG32I",t[t.RG32UI=33340]="RG32UI",t[t.R8_SNORM=36756]="R8_SNORM",t[t.RG8_SNORM=36757]="RG8_SNORM",t[t.RGB8_SNORM=36758]="RGB8_SNORM",t[t.RGBA8_SNORM=36759]="RGBA8_SNORM",t[t.RGB10_A2UI=36975]="RGB10_A2UI",t[t.TEXTURE_IMMUTABLE_FORMAT=37167]="TEXTURE_IMMUTABLE_FORMAT",t[t.TEXTURE_IMMUTABLE_LEVELS=33503]="TEXTURE_IMMUTABLE_LEVELS",t[t.UNSIGNED_INT_2_10_10_10_REV=33640]="UNSIGNED_INT_2_10_10_10_REV",t[t.UNSIGNED_INT_10F_11F_11F_REV=35899]="UNSIGNED_INT_10F_11F_11F_REV",t[t.UNSIGNED_INT_5_9_9_9_REV=35902]="UNSIGNED_INT_5_9_9_9_REV",t[t.FLOAT_32_UNSIGNED_INT_24_8_REV=36269]="FLOAT_32_UNSIGNED_INT_24_8_REV",t[t.UNSIGNED_INT_24_8=34042]="UNSIGNED_INT_24_8",t[t.HALF_FLOAT=5131]="HALF_FLOAT",t[t.RG=33319]="RG",t[t.RG_INTEGER=33320]="RG_INTEGER",t[t.INT_2_10_10_10_REV=36255]="INT_2_10_10_10_REV",t[t.CURRENT_QUERY=34917]="CURRENT_QUERY",t[t.QUERY_RESULT=34918]="QUERY_RESULT",t[t.QUERY_RESULT_AVAILABLE=34919]="QUERY_RESULT_AVAILABLE",t[t.ANY_SAMPLES_PASSED=35887]="ANY_SAMPLES_PASSED",t[t.ANY_SAMPLES_PASSED_CONSERVATIVE=36202]="ANY_SAMPLES_PASSED_CONSERVATIVE",t[t.MAX_DRAW_BUFFERS=34852]="MAX_DRAW_BUFFERS",t[t.DRAW_BUFFER0=34853]="DRAW_BUFFER0",t[t.DRAW_BUFFER1=34854]="DRAW_BUFFER1",t[t.DRAW_BUFFER2=34855]="DRAW_BUFFER2",t[t.DRAW_BUFFER3=34856]="DRAW_BUFFER3",t[t.DRAW_BUFFER4=34857]="DRAW_BUFFER4",t[t.DRAW_BUFFER5=34858]="DRAW_BUFFER5",t[t.DRAW_BUFFER6=34859]="DRAW_BUFFER6",t[t.DRAW_BUFFER7=34860]="DRAW_BUFFER7",t[t.DRAW_BUFFER8=34861]="DRAW_BUFFER8",t[t.DRAW_BUFFER9=34862]="DRAW_BUFFER9",t[t.DRAW_BUFFER10=34863]="DRAW_BUFFER10",t[t.DRAW_BUFFER11=34864]="DRAW_BUFFER11",t[t.DRAW_BUFFER12=34865]="DRAW_BUFFER12",t[t.DRAW_BUFFER13=34866]="DRAW_BUFFER13",t[t.DRAW_BUFFER14=34867]="DRAW_BUFFER14",t[t.DRAW_BUFFER15=34868]="DRAW_BUFFER15",t[t.MAX_COLOR_ATTACHMENTS=36063]="MAX_COLOR_ATTACHMENTS",t[t.COLOR_ATTACHMENT1=36065]="COLOR_ATTACHMENT1",t[t.COLOR_ATTACHMENT2=36066]="COLOR_ATTACHMENT2",t[t.COLOR_ATTACHMENT3=36067]="COLOR_ATTACHMENT3",t[t.COLOR_ATTACHMENT4=36068]="COLOR_ATTACHMENT4",t[t.COLOR_ATTACHMENT5=36069]="COLOR_ATTACHMENT5",t[t.COLOR_ATTACHMENT6=36070]="COLOR_ATTACHMENT6",t[t.COLOR_ATTACHMENT7=36071]="COLOR_ATTACHMENT7",t[t.COLOR_ATTACHMENT8=36072]="COLOR_ATTACHMENT8",t[t.COLOR_ATTACHMENT9=36073]="COLOR_ATTACHMENT9",t[t.COLOR_ATTACHMENT10=36074]="COLOR_ATTACHMENT10",t[t.COLOR_ATTACHMENT11=36075]="COLOR_ATTACHMENT11",t[t.COLOR_ATTACHMENT12=36076]="COLOR_ATTACHMENT12",t[t.COLOR_ATTACHMENT13=36077]="COLOR_ATTACHMENT13",t[t.COLOR_ATTACHMENT14=36078]="COLOR_ATTACHMENT14",t[t.COLOR_ATTACHMENT15=36079]="COLOR_ATTACHMENT15",t[t.SAMPLER_3D=35679]="SAMPLER_3D",t[t.SAMPLER_2D_SHADOW=35682]="SAMPLER_2D_SHADOW",t[t.SAMPLER_2D_ARRAY=36289]="SAMPLER_2D_ARRAY",t[t.SAMPLER_2D_ARRAY_SHADOW=36292]="SAMPLER_2D_ARRAY_SHADOW",t[t.SAMPLER_CUBE_SHADOW=36293]="SAMPLER_CUBE_SHADOW",t[t.INT_SAMPLER_2D=36298]="INT_SAMPLER_2D",t[t.INT_SAMPLER_3D=36299]="INT_SAMPLER_3D",t[t.INT_SAMPLER_CUBE=36300]="INT_SAMPLER_CUBE",t[t.INT_SAMPLER_2D_ARRAY=36303]="INT_SAMPLER_2D_ARRAY",t[t.UNSIGNED_INT_SAMPLER_2D=36306]="UNSIGNED_INT_SAMPLER_2D",t[t.UNSIGNED_INT_SAMPLER_3D=36307]="UNSIGNED_INT_SAMPLER_3D",t[t.UNSIGNED_INT_SAMPLER_CUBE=36308]="UNSIGNED_INT_SAMPLER_CUBE",t[t.UNSIGNED_INT_SAMPLER_2D_ARRAY=36311]="UNSIGNED_INT_SAMPLER_2D_ARRAY",t[t.MAX_SAMPLES=36183]="MAX_SAMPLES",t[t.SAMPLER_BINDING=35097]="SAMPLER_BINDING",t[t.PIXEL_PACK_BUFFER=35051]="PIXEL_PACK_BUFFER",t[t.PIXEL_UNPACK_BUFFER=35052]="PIXEL_UNPACK_BUFFER",t[t.PIXEL_PACK_BUFFER_BINDING=35053]="PIXEL_PACK_BUFFER_BINDING",t[t.PIXEL_UNPACK_BUFFER_BINDING=35055]="PIXEL_UNPACK_BUFFER_BINDING",t[t.COPY_READ_BUFFER=36662]="COPY_READ_BUFFER",t[t.COPY_WRITE_BUFFER=36663]="COPY_WRITE_BUFFER",t[t.COPY_READ_BUFFER_BINDING=36662]="COPY_READ_BUFFER_BINDING",t[t.COPY_WRITE_BUFFER_BINDING=36663]="COPY_WRITE_BUFFER_BINDING",t[t.FLOAT_MAT2x3=35685]="FLOAT_MAT2x3",t[t.FLOAT_MAT2x4=35686]="FLOAT_MAT2x4",t[t.FLOAT_MAT3x2=35687]="FLOAT_MAT3x2",t[t.FLOAT_MAT3x4=35688]="FLOAT_MAT3x4",t[t.FLOAT_MAT4x2=35689]="FLOAT_MAT4x2",t[t.FLOAT_MAT4x3=35690]="FLOAT_MAT4x3",t[t.UNSIGNED_INT_VEC2=36294]="UNSIGNED_INT_VEC2",t[t.UNSIGNED_INT_VEC3=36295]="UNSIGNED_INT_VEC3",t[t.UNSIGNED_INT_VEC4=36296]="UNSIGNED_INT_VEC4",t[t.UNSIGNED_NORMALIZED=35863]="UNSIGNED_NORMALIZED",t[t.SIGNED_NORMALIZED=36764]="SIGNED_NORMALIZED",t[t.VERTEX_ATTRIB_ARRAY_INTEGER=35069]="VERTEX_ATTRIB_ARRAY_INTEGER",t[t.VERTEX_ATTRIB_ARRAY_DIVISOR=35070]="VERTEX_ATTRIB_ARRAY_DIVISOR",t[t.TRANSFORM_FEEDBACK_BUFFER_MODE=35967]="TRANSFORM_FEEDBACK_BUFFER_MODE",t[t.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=35968]="MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",t[t.TRANSFORM_FEEDBACK_VARYINGS=35971]="TRANSFORM_FEEDBACK_VARYINGS",t[t.TRANSFORM_FEEDBACK_BUFFER_START=35972]="TRANSFORM_FEEDBACK_BUFFER_START",t[t.TRANSFORM_FEEDBACK_BUFFER_SIZE=35973]="TRANSFORM_FEEDBACK_BUFFER_SIZE",t[t.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=35976]="TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN",t[t.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=35978]="MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",t[t.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=35979]="MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",t[t.INTERLEAVED_ATTRIBS=35980]="INTERLEAVED_ATTRIBS",t[t.SEPARATE_ATTRIBS=35981]="SEPARATE_ATTRIBS",t[t.TRANSFORM_FEEDBACK_BUFFER=35982]="TRANSFORM_FEEDBACK_BUFFER",t[t.TRANSFORM_FEEDBACK_BUFFER_BINDING=35983]="TRANSFORM_FEEDBACK_BUFFER_BINDING",t[t.TRANSFORM_FEEDBACK=36386]="TRANSFORM_FEEDBACK",t[t.TRANSFORM_FEEDBACK_PAUSED=36387]="TRANSFORM_FEEDBACK_PAUSED",t[t.TRANSFORM_FEEDBACK_ACTIVE=36388]="TRANSFORM_FEEDBACK_ACTIVE",t[t.TRANSFORM_FEEDBACK_BINDING=36389]="TRANSFORM_FEEDBACK_BINDING",t[t.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=33296]="FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING",t[t.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=33297]="FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE",t[t.FRAMEBUFFER_ATTACHMENT_RED_SIZE=33298]="FRAMEBUFFER_ATTACHMENT_RED_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=33299]="FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=33300]="FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=33301]="FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=33302]="FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",t[t.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=33303]="FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",t[t.FRAMEBUFFER_DEFAULT=33304]="FRAMEBUFFER_DEFAULT",t[t.DEPTH24_STENCIL8=35056]="DEPTH24_STENCIL8",t[t.DRAW_FRAMEBUFFER_BINDING=36006]="DRAW_FRAMEBUFFER_BINDING",t[t.READ_FRAMEBUFFER_BINDING=36010]="READ_FRAMEBUFFER_BINDING",t[t.RENDERBUFFER_SAMPLES=36011]="RENDERBUFFER_SAMPLES",t[t.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=36052]="FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER",t[t.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=36182]="FRAMEBUFFER_INCOMPLETE_MULTISAMPLE",t[t.UNIFORM_BUFFER=35345]="UNIFORM_BUFFER",t[t.UNIFORM_BUFFER_BINDING=35368]="UNIFORM_BUFFER_BINDING",t[t.UNIFORM_BUFFER_START=35369]="UNIFORM_BUFFER_START",t[t.UNIFORM_BUFFER_SIZE=35370]="UNIFORM_BUFFER_SIZE",t[t.MAX_VERTEX_UNIFORM_BLOCKS=35371]="MAX_VERTEX_UNIFORM_BLOCKS",t[t.MAX_FRAGMENT_UNIFORM_BLOCKS=35373]="MAX_FRAGMENT_UNIFORM_BLOCKS",t[t.MAX_COMBINED_UNIFORM_BLOCKS=35374]="MAX_COMBINED_UNIFORM_BLOCKS",t[t.MAX_UNIFORM_BUFFER_BINDINGS=35375]="MAX_UNIFORM_BUFFER_BINDINGS",t[t.MAX_UNIFORM_BLOCK_SIZE=35376]="MAX_UNIFORM_BLOCK_SIZE",t[t.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=35377]="MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS",t[t.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=35379]="MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",t[t.UNIFORM_BUFFER_OFFSET_ALIGNMENT=35380]="UNIFORM_BUFFER_OFFSET_ALIGNMENT",t[t.ACTIVE_UNIFORM_BLOCKS=35382]="ACTIVE_UNIFORM_BLOCKS",t[t.UNIFORM_TYPE=35383]="UNIFORM_TYPE",t[t.UNIFORM_SIZE=35384]="UNIFORM_SIZE",t[t.UNIFORM_BLOCK_INDEX=35386]="UNIFORM_BLOCK_INDEX",t[t.UNIFORM_OFFSET=35387]="UNIFORM_OFFSET",t[t.UNIFORM_ARRAY_STRIDE=35388]="UNIFORM_ARRAY_STRIDE",t[t.UNIFORM_MATRIX_STRIDE=35389]="UNIFORM_MATRIX_STRIDE",t[t.UNIFORM_IS_ROW_MAJOR=35390]="UNIFORM_IS_ROW_MAJOR",t[t.UNIFORM_BLOCK_BINDING=35391]="UNIFORM_BLOCK_BINDING",t[t.UNIFORM_BLOCK_DATA_SIZE=35392]="UNIFORM_BLOCK_DATA_SIZE",t[t.UNIFORM_BLOCK_ACTIVE_UNIFORMS=35394]="UNIFORM_BLOCK_ACTIVE_UNIFORMS",t[t.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=35395]="UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES",t[t.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=35396]="UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",t[t.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=35398]="UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER",t[t.OBJECT_TYPE=37138]="OBJECT_TYPE",t[t.SYNC_CONDITION=37139]="SYNC_CONDITION",t[t.SYNC_STATUS=37140]="SYNC_STATUS",t[t.SYNC_FLAGS=37141]="SYNC_FLAGS",t[t.SYNC_FENCE=37142]="SYNC_FENCE",t[t.SYNC_GPU_COMMANDS_COMPLETE=37143]="SYNC_GPU_COMMANDS_COMPLETE",t[t.UNSIGNALED=37144]="UNSIGNALED",t[t.SIGNALED=37145]="SIGNALED",t[t.ALREADY_SIGNALED=37146]="ALREADY_SIGNALED",t[t.TIMEOUT_EXPIRED=37147]="TIMEOUT_EXPIRED",t[t.CONDITION_SATISFIED=37148]="CONDITION_SATISFIED",t[t.WAIT_FAILED=37149]="WAIT_FAILED",t[t.SYNC_FLUSH_COMMANDS_BIT=1]="SYNC_FLUSH_COMMANDS_BIT",t[t.COLOR=6144]="COLOR",t[t.DEPTH=6145]="DEPTH",t[t.STENCIL=6146]="STENCIL",t[t.MIN=32775]="MIN",t[t.MAX=32776]="MAX",t[t.DEPTH_COMPONENT24=33190]="DEPTH_COMPONENT24",t[t.STREAM_READ=35041]="STREAM_READ",t[t.STREAM_COPY=35042]="STREAM_COPY",t[t.STATIC_READ=35045]="STATIC_READ",t[t.STATIC_COPY=35046]="STATIC_COPY",t[t.DYNAMIC_READ=35049]="DYNAMIC_READ",t[t.DYNAMIC_COPY=35050]="DYNAMIC_COPY",t[t.DEPTH_COMPONENT32F=36012]="DEPTH_COMPONENT32F",t[t.DEPTH32F_STENCIL8=36013]="DEPTH32F_STENCIL8",t[t.INVALID_INDEX=4294967295]="INVALID_INDEX",t[t.TIMEOUT_IGNORED=-1]="TIMEOUT_IGNORED",t[t.MAX_CLIENT_WAIT_TIMEOUT_WEBGL=37447]="MAX_CLIENT_WAIT_TIMEOUT_WEBGL",t[t.UNMASKED_VENDOR_WEBGL=37445]="UNMASKED_VENDOR_WEBGL",t[t.UNMASKED_RENDERER_WEBGL=37446]="UNMASKED_RENDERER_WEBGL",t[t.MAX_TEXTURE_MAX_ANISOTROPY_EXT=34047]="MAX_TEXTURE_MAX_ANISOTROPY_EXT",t[t.TEXTURE_MAX_ANISOTROPY_EXT=34046]="TEXTURE_MAX_ANISOTROPY_EXT",t[t.R16_EXT=33322]="R16_EXT",t[t.RG16_EXT=33324]="RG16_EXT",t[t.RGB16_EXT=32852]="RGB16_EXT",t[t.RGBA16_EXT=32859]="RGBA16_EXT",t[t.R16_SNORM_EXT=36760]="R16_SNORM_EXT",t[t.RG16_SNORM_EXT=36761]="RG16_SNORM_EXT",t[t.RGB16_SNORM_EXT=36762]="RGB16_SNORM_EXT",t[t.RGBA16_SNORM_EXT=36763]="RGBA16_SNORM_EXT",t[t.COMPRESSED_RGB_S3TC_DXT1_EXT=33776]="COMPRESSED_RGB_S3TC_DXT1_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT1_EXT=33777]="COMPRESSED_RGBA_S3TC_DXT1_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT3_EXT=33778]="COMPRESSED_RGBA_S3TC_DXT3_EXT",t[t.COMPRESSED_RGBA_S3TC_DXT5_EXT=33779]="COMPRESSED_RGBA_S3TC_DXT5_EXT",t[t.COMPRESSED_SRGB_S3TC_DXT1_EXT=35916]="COMPRESSED_SRGB_S3TC_DXT1_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=35917]="COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=35918]="COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT",t[t.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=35919]="COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT",t[t.COMPRESSED_RED_RGTC1_EXT=36283]="COMPRESSED_RED_RGTC1_EXT",t[t.COMPRESSED_SIGNED_RED_RGTC1_EXT=36284]="COMPRESSED_SIGNED_RED_RGTC1_EXT",t[t.COMPRESSED_RED_GREEN_RGTC2_EXT=36285]="COMPRESSED_RED_GREEN_RGTC2_EXT",t[t.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=36286]="COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT",t[t.COMPRESSED_RGBA_BPTC_UNORM_EXT=36492]="COMPRESSED_RGBA_BPTC_UNORM_EXT",t[t.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT=36493]="COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT",t[t.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT=36494]="COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT",t[t.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT=36495]="COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT",t[t.COMPRESSED_R11_EAC=37488]="COMPRESSED_R11_EAC",t[t.COMPRESSED_SIGNED_R11_EAC=37489]="COMPRESSED_SIGNED_R11_EAC",t[t.COMPRESSED_RG11_EAC=37490]="COMPRESSED_RG11_EAC",t[t.COMPRESSED_SIGNED_RG11_EAC=37491]="COMPRESSED_SIGNED_RG11_EAC",t[t.COMPRESSED_RGB8_ETC2=37492]="COMPRESSED_RGB8_ETC2",t[t.COMPRESSED_RGBA8_ETC2_EAC=37493]="COMPRESSED_RGBA8_ETC2_EAC",t[t.COMPRESSED_SRGB8_ETC2=37494]="COMPRESSED_SRGB8_ETC2",t[t.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=37495]="COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",t[t.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=37496]="COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2",t[t.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=37497]="COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",t[t.COMPRESSED_RGB_PVRTC_4BPPV1_IMG=35840]="COMPRESSED_RGB_PVRTC_4BPPV1_IMG",t[t.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=35842]="COMPRESSED_RGBA_PVRTC_4BPPV1_IMG",t[t.COMPRESSED_RGB_PVRTC_2BPPV1_IMG=35841]="COMPRESSED_RGB_PVRTC_2BPPV1_IMG",t[t.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=35843]="COMPRESSED_RGBA_PVRTC_2BPPV1_IMG",t[t.COMPRESSED_RGB_ETC1_WEBGL=36196]="COMPRESSED_RGB_ETC1_WEBGL",t[t.COMPRESSED_RGB_ATC_WEBGL=35986]="COMPRESSED_RGB_ATC_WEBGL",t[t.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL=35986]="COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL",t[t.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL=34798]="COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL",t[t.COMPRESSED_RGBA_ASTC_4x4_KHR=37808]="COMPRESSED_RGBA_ASTC_4x4_KHR",t[t.COMPRESSED_RGBA_ASTC_5x4_KHR=37809]="COMPRESSED_RGBA_ASTC_5x4_KHR",t[t.COMPRESSED_RGBA_ASTC_5x5_KHR=37810]="COMPRESSED_RGBA_ASTC_5x5_KHR",t[t.COMPRESSED_RGBA_ASTC_6x5_KHR=37811]="COMPRESSED_RGBA_ASTC_6x5_KHR",t[t.COMPRESSED_RGBA_ASTC_6x6_KHR=37812]="COMPRESSED_RGBA_ASTC_6x6_KHR",t[t.COMPRESSED_RGBA_ASTC_8x5_KHR=37813]="COMPRESSED_RGBA_ASTC_8x5_KHR",t[t.COMPRESSED_RGBA_ASTC_8x6_KHR=37814]="COMPRESSED_RGBA_ASTC_8x6_KHR",t[t.COMPRESSED_RGBA_ASTC_8x8_KHR=37815]="COMPRESSED_RGBA_ASTC_8x8_KHR",t[t.COMPRESSED_RGBA_ASTC_10x5_KHR=37816]="COMPRESSED_RGBA_ASTC_10x5_KHR",t[t.COMPRESSED_RGBA_ASTC_10x6_KHR=37817]="COMPRESSED_RGBA_ASTC_10x6_KHR",t[t.COMPRESSED_RGBA_ASTC_10x8_KHR=37818]="COMPRESSED_RGBA_ASTC_10x8_KHR",t[t.COMPRESSED_RGBA_ASTC_10x10_KHR=37819]="COMPRESSED_RGBA_ASTC_10x10_KHR",t[t.COMPRESSED_RGBA_ASTC_12x10_KHR=37820]="COMPRESSED_RGBA_ASTC_12x10_KHR",t[t.COMPRESSED_RGBA_ASTC_12x12_KHR=37821]="COMPRESSED_RGBA_ASTC_12x12_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=37840]="COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=37841]="COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=37842]="COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=37843]="COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=37844]="COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=37845]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=37846]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=37847]="COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=37848]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=37849]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=37850]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=37851]="COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=37852]="COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR",t[t.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=37853]="COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR",t[t.QUERY_COUNTER_BITS_EXT=34916]="QUERY_COUNTER_BITS_EXT",t[t.CURRENT_QUERY_EXT=34917]="CURRENT_QUERY_EXT",t[t.QUERY_RESULT_EXT=34918]="QUERY_RESULT_EXT",t[t.QUERY_RESULT_AVAILABLE_EXT=34919]="QUERY_RESULT_AVAILABLE_EXT",t[t.TIME_ELAPSED_EXT=35007]="TIME_ELAPSED_EXT",t[t.TIMESTAMP_EXT=36392]="TIMESTAMP_EXT",t[t.GPU_DISJOINT_EXT=36795]="GPU_DISJOINT_EXT",t[t.COMPLETION_STATUS_KHR=37297]="COMPLETION_STATUS_KHR",t[t.DEPTH_CLAMP_EXT=34383]="DEPTH_CLAMP_EXT",t[t.FIRST_VERTEX_CONVENTION_WEBGL=36429]="FIRST_VERTEX_CONVENTION_WEBGL",t[t.LAST_VERTEX_CONVENTION_WEBGL=36430]="LAST_VERTEX_CONVENTION_WEBGL",t[t.PROVOKING_VERTEX_WEBL=36431]="PROVOKING_VERTEX_WEBL",t[t.POLYGON_MODE_WEBGL=2880]="POLYGON_MODE_WEBGL",t[t.POLYGON_OFFSET_LINE_WEBGL=10754]="POLYGON_OFFSET_LINE_WEBGL",t[t.LINE_WEBGL=6913]="LINE_WEBGL",t[t.FILL_WEBGL=6914]="FILL_WEBGL",t[t.MAX_CLIP_DISTANCES_WEBGL=3378]="MAX_CLIP_DISTANCES_WEBGL",t[t.MAX_CULL_DISTANCES_WEBGL=33529]="MAX_CULL_DISTANCES_WEBGL",t[t.MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL=33530]="MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL",t[t.CLIP_DISTANCE0_WEBGL=12288]="CLIP_DISTANCE0_WEBGL",t[t.CLIP_DISTANCE1_WEBGL=12289]="CLIP_DISTANCE1_WEBGL",t[t.CLIP_DISTANCE2_WEBGL=12290]="CLIP_DISTANCE2_WEBGL",t[t.CLIP_DISTANCE3_WEBGL=12291]="CLIP_DISTANCE3_WEBGL",t[t.CLIP_DISTANCE4_WEBGL=12292]="CLIP_DISTANCE4_WEBGL",t[t.CLIP_DISTANCE5_WEBGL=12293]="CLIP_DISTANCE5_WEBGL",t[t.CLIP_DISTANCE6_WEBGL=12294]="CLIP_DISTANCE6_WEBGL",t[t.CLIP_DISTANCE7_WEBGL=12295]="CLIP_DISTANCE7_WEBGL",t[t.POLYGON_OFFSET_CLAMP_EXT=36379]="POLYGON_OFFSET_CLAMP_EXT",t[t.LOWER_LEFT_EXT=36001]="LOWER_LEFT_EXT",t[t.UPPER_LEFT_EXT=36002]="UPPER_LEFT_EXT",t[t.NEGATIVE_ONE_TO_ONE_EXT=37726]="NEGATIVE_ONE_TO_ONE_EXT",t[t.ZERO_TO_ONE_EXT=37727]="ZERO_TO_ONE_EXT",t[t.CLIP_ORIGIN_EXT=37724]="CLIP_ORIGIN_EXT",t[t.CLIP_DEPTH_MODE_EXT=37725]="CLIP_DEPTH_MODE_EXT",t[t.SRC1_COLOR_WEBGL=35065]="SRC1_COLOR_WEBGL",t[t.SRC1_ALPHA_WEBGL=34185]="SRC1_ALPHA_WEBGL",t[t.ONE_MINUS_SRC1_COLOR_WEBGL=35066]="ONE_MINUS_SRC1_COLOR_WEBGL",t[t.ONE_MINUS_SRC1_ALPHA_WEBGL=35067]="ONE_MINUS_SRC1_ALPHA_WEBGL",t[t.MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL=35068]="MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL",t[t.MIRROR_CLAMP_TO_EDGE_EXT=34627]="MIRROR_CLAMP_TO_EDGE_EXT"})(C7||(C7={}));var Ip={3042:!1,32773:new Float32Array([0,0,0,0]),32777:32774,34877:32774,32969:1,32968:0,32971:1,32970:0,3106:new Float32Array([0,0,0,0]),3107:[!0,!0,!0,!0],2884:!1,2885:1029,2929:!1,2931:1,2932:513,2928:new Float32Array([0,1]),2930:!0,3024:!0,35725:null,36006:null,36007:null,34229:null,34964:null,2886:2305,33170:4352,2849:1,32823:!1,32824:0,10752:0,32926:!1,32928:!1,32938:1,32939:!1,3089:!1,3088:new Int32Array([0,0,1024,1024]),2960:!1,2961:0,2968:4294967295,36005:4294967295,2962:519,2967:0,2963:4294967295,34816:519,36003:0,36004:4294967295,2964:7680,2965:7680,2966:7680,34817:7680,34818:7680,34819:7680,2978:[0,0,1024,1024],36389:null,36662:null,36663:null,35053:null,35055:null,35723:4352,36010:null,35977:!1,3333:4,3317:4,37440:!1,37441:!1,37443:37444,3330:0,3332:0,3331:0,3314:0,32878:0,3316:0,3315:0,32877:0},Ke=(t,A,j)=>A?t.enable(j):t.disable(j),HR=(t,A,j)=>t.hint(j,A),Z6=(t,A,j)=>t.pixelStorei(j,A),DR=(t,A,j)=>{let e=j===36006?36009:36008;return t.bindFramebuffer(e,A)},Pp=(t,A,j)=>{let r={34964:34962,36662:36662,36663:36663,35053:35051,35055:35052}[j];t.bindBuffer(r,A)};function Qw(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}var NR={3042:Ke,32773:(t,A)=>t.blendColor(...A),32777:"blendEquation",34877:"blendEquation",32969:"blendFunc",32968:"blendFunc",32971:"blendFunc",32970:"blendFunc",3106:(t,A)=>t.clearColor(...A),3107:(t,A)=>t.colorMask(...A),2884:Ke,2885:(t,A)=>t.cullFace(A),2929:Ke,2931:(t,A)=>t.clearDepth(A),2932:(t,A)=>t.depthFunc(A),2928:(t,A)=>t.depthRange(...A),2930:(t,A)=>t.depthMask(A),3024:Ke,35723:HR,35725:(t,A)=>t.useProgram(A),36007:(t,A)=>t.bindRenderbuffer(36161,A),36389:(t,A)=>t.bindTransformFeedback?.(36386,A),34229:(t,A)=>t.bindVertexArray(A),36006:DR,36010:DR,34964:Pp,36662:Pp,36663:Pp,35053:Pp,35055:Pp,2886:(t,A)=>t.frontFace(A),33170:HR,2849:(t,A)=>t.lineWidth(A),32823:Ke,32824:"polygonOffset",10752:"polygonOffset",35977:Ke,32926:Ke,32928:Ke,32938:"sampleCoverage",32939:"sampleCoverage",3089:Ke,3088:(t,A)=>t.scissor(...A),2960:Ke,2961:(t,A)=>t.clearStencil(A),2968:(t,A)=>t.stencilMaskSeparate(1028,A),36005:(t,A)=>t.stencilMaskSeparate(1029,A),2962:"stencilFuncFront",2967:"stencilFuncFront",2963:"stencilFuncFront",34816:"stencilFuncBack",36003:"stencilFuncBack",36004:"stencilFuncBack",2964:"stencilOpFront",2965:"stencilOpFront",2966:"stencilOpFront",34817:"stencilOpBack",34818:"stencilOpBack",34819:"stencilOpBack",2978:(t,A)=>t.viewport(...A),34383:Ke,10754:Ke,12288:Ke,12289:Ke,12290:Ke,12291:Ke,12292:Ke,12293:Ke,12294:Ke,12295:Ke,3333:Z6,3317:Z6,37440:Z6,37441:Z6,37443:Z6,3330:Z6,3332:Z6,3331:Z6,3314:Z6,32878:Z6,3316:Z6,3315:Z6,32877:Z6,framebuffer:(t,A)=>{let j=A&&"handle"in A?A.handle:A;return t.bindFramebuffer(36160,j)},blend:(t,A)=>A?t.enable(3042):t.disable(3042),blendColor:(t,A)=>t.blendColor(...A),blendEquation:(t,A)=>{let j=typeof A=="number"?[A,A]:A;t.blendEquationSeparate(...j)},blendFunc:(t,A)=>{let j=A?.length===2?[...A,...A]:A;t.blendFuncSeparate(...j)},clearColor:(t,A)=>t.clearColor(...A),clearDepth:(t,A)=>t.clearDepth(A),clearStencil:(t,A)=>t.clearStencil(A),colorMask:(t,A)=>t.colorMask(...A),cull:(t,A)=>A?t.enable(2884):t.disable(2884),cullFace:(t,A)=>t.cullFace(A),depthTest:(t,A)=>A?t.enable(2929):t.disable(2929),depthFunc:(t,A)=>t.depthFunc(A),depthMask:(t,A)=>t.depthMask(A),depthRange:(t,A)=>t.depthRange(...A),dither:(t,A)=>A?t.enable(3024):t.disable(3024),derivativeHint:(t,A)=>{t.hint(35723,A)},frontFace:(t,A)=>t.frontFace(A),mipmapHint:(t,A)=>t.hint(33170,A),lineWidth:(t,A)=>t.lineWidth(A),polygonOffsetFill:(t,A)=>A?t.enable(32823):t.disable(32823),polygonOffset:(t,A)=>t.polygonOffset(...A),sampleCoverage:(t,A)=>t.sampleCoverage(...A),scissorTest:(t,A)=>A?t.enable(3089):t.disable(3089),scissor:(t,A)=>t.scissor(...A),stencilTest:(t,A)=>A?t.enable(2960):t.disable(2960),stencilMask:(t,A)=>{A=Qw(A)?A:[A,A];let[j,e]=A;t.stencilMaskSeparate(1028,j),t.stencilMaskSeparate(1029,e)},stencilFunc:(t,A)=>{A=Qw(A)&&A.length===3?[...A,...A]:A;let[j,e,r,n,i,o]=A;t.stencilFuncSeparate(1028,j,e,r),t.stencilFuncSeparate(1029,n,i,o)},stencilOp:(t,A)=>{A=Qw(A)&&A.length===3?[...A,...A]:A;let[j,e,r,n,i,o]=A;t.stencilOpSeparate(1028,j,e,r),t.stencilOpSeparate(1029,n,i,o)},viewport:(t,A)=>t.viewport(...A)};function ge(t,A,j){return A[t]!==void 0?A[t]:j[t]}var KR={blendEquation:(t,A,j)=>t.blendEquationSeparate(ge(32777,A,j),ge(34877,A,j)),blendFunc:(t,A,j)=>t.blendFuncSeparate(ge(32969,A,j),ge(32968,A,j),ge(32971,A,j),ge(32970,A,j)),polygonOffset:(t,A,j)=>t.polygonOffset(ge(32824,A,j),ge(10752,A,j)),sampleCoverage:(t,A,j)=>t.sampleCoverage(ge(32938,A,j),ge(32939,A,j)),stencilFuncFront:(t,A,j)=>t.stencilFuncSeparate(1028,ge(2962,A,j),ge(2967,A,j),ge(2963,A,j)),stencilFuncBack:(t,A,j)=>t.stencilFuncSeparate(1029,ge(34816,A,j),ge(36003,A,j),ge(36004,A,j)),stencilOpFront:(t,A,j)=>t.stencilOpSeparate(1028,ge(2964,A,j),ge(2965,A,j),ge(2966,A,j)),stencilOpBack:(t,A,j)=>t.stencilOpSeparate(1029,ge(34817,A,j),ge(34818,A,j),ge(34819,A,j))},Ww={enable:(t,A)=>t({[A]:!0}),disable:(t,A)=>t({[A]:!1}),pixelStorei:(t,A,j)=>t({[A]:j}),hint:(t,A,j)=>t({[A]:j}),useProgram:(t,A)=>t({35725:A}),bindRenderbuffer:(t,A,j)=>t({36007:j}),bindTransformFeedback:(t,A,j)=>t({36389:j}),bindVertexArray:(t,A)=>t({34229:A}),bindFramebuffer:(t,A,j)=>{switch(A){case 36160:return t({36006:j,36010:j});case 36009:return t({36006:j});case 36008:return t({36010:j});default:return null}},bindBuffer:(t,A,j)=>{let e={34962:[34964],36662:[36662],36663:[36663],35051:[35053],35052:[35055]}[A];return e?t({[e]:j}):{valueChanged:!0}},blendColor:(t,A,j,e,r)=>t({32773:new Float32Array([A,j,e,r])}),blendEquation:(t,A)=>t({32777:A,34877:A}),blendEquationSeparate:(t,A,j)=>t({32777:A,34877:j}),blendFunc:(t,A,j)=>t({32969:A,32968:j,32971:A,32970:j}),blendFuncSeparate:(t,A,j,e,r)=>t({32969:A,32968:j,32971:e,32970:r}),clearColor:(t,A,j,e,r)=>t({3106:new Float32Array([A,j,e,r])}),clearDepth:(t,A)=>t({2931:A}),clearStencil:(t,A)=>t({2961:A}),colorMask:(t,A,j,e,r)=>t({3107:[A,j,e,r]}),cullFace:(t,A)=>t({2885:A}),depthFunc:(t,A)=>t({2932:A}),depthRange:(t,A,j)=>t({2928:new Float32Array([A,j])}),depthMask:(t,A)=>t({2930:A}),frontFace:(t,A)=>t({2886:A}),lineWidth:(t,A)=>t({2849:A}),polygonOffset:(t,A,j)=>t({32824:A,10752:j}),sampleCoverage:(t,A,j)=>t({32938:A,32939:j}),scissor:(t,A,j,e,r)=>t({3088:new Int32Array([A,j,e,r])}),stencilMask:(t,A)=>t({2968:A,36005:A}),stencilMaskSeparate:(t,A,j)=>t({[A===1028?2968:36005]:j}),stencilFunc:(t,A,j,e)=>t({2962:A,2967:j,2963:e,34816:A,36003:j,36004:e}),stencilFuncSeparate:(t,A,j,e,r)=>t({[A===1028?2962:34816]:j,[A===1028?2967:36003]:e,[A===1028?2963:36004]:r}),stencilOp:(t,A,j,e)=>t({2964:A,2965:j,2966:e,34817:A,34818:j,34819:e}),stencilOpSeparate:(t,A,j,e,r)=>t({[A===1028?2964:34817]:j,[A===1028?2965:34818]:e,[A===1028?2966:34819]:r}),viewport:(t,A,j,e,r)=>t({2978:[A,j,e,r]})},Bs=(t,A)=>t.isEnabled(A),Yw={3042:Bs,2884:Bs,2929:Bs,3024:Bs,32823:Bs,32926:Bs,32928:Bs,3089:Bs,2960:Bs,35977:Bs},XR=new Set([34016,36388,36387,35983,35368,34965,35739,35738,3074,34853,34854,34855,34856,34857,34858,34859,34860,34861,34862,34863,34864,34865,34866,34867,34868,35097,32873,35869,32874,34068]);function $o(t,A){if(QnA(A))return;let j={};for(let r in A){let n=Number(r),i=NR[r];i&&(typeof i=="string"?j[i]=!0:i(t,A[r],n))}let e=t.state&&t.state.cache;if(e)for(let r in j){let n=KR[r];n(t,A,e)}}function P$(t,A=Ip){if(typeof A=="number"){let r=A,n=Yw[r];return n?n(t,r):t.getParameter(r)}let j=Array.isArray(A)?A:Object.keys(A),e={};for(let r of j){let n=Yw[r];e[r]=n?n(t,Number(r)):t.getParameter(Number(r))}return e}function zR(t){$o(t,Ip)}function QnA(t){for(let A in t)return!1;return!0}function UR(t,A){if(t===A)return!0;let j=Array.isArray(t)||ArrayBuffer.isView(t),e=Array.isArray(A)||ArrayBuffer.isView(A);if(j&&e&&t.length===A.length){for(let r=0;r{}}={}){I(this,"gl");I(this,"program",null);I(this,"stateStack",[]);I(this,"enable",!0);I(this,"cache");I(this,"log");this.gl=A,this.cache=j?P$(A):Object.assign({},Ip),this.log=e,this._updateCache=this._updateCache.bind(this),Object.seal(this)}push(A={}){this.stateStack.push({})}pop(){Ot(this.stateStack.length>0);let A=this.stateStack[this.stateStack.length-1];$o(this.gl,A),this.stateStack.pop()}_updateCache(A){let j=!1,e,r=this.stateStack.length>0?this.stateStack[this.stateStack.length-1]:null;for(let n in A){Ot(n!==void 0);let i=A[n],o=this.cache[n];UR(i,o)||(j=!0,e=o,r&&!(n in r)&&(r[n]=o),this.cache[n]=i)}return{valueChanged:j,oldValue:e}}};function bc(t){return t.state}function Zw(t,A){let{enable:j=!0,copyState:e}=A;if(Ot(e!==void 0),!t.state){t.state=new Jw(t,{copyState:e}),YnA(t);for(let n in Ww){let i=Ww[n];WnA(t,n,i)}VR(t,"getParameter"),VR(t,"isEnabled")}let r=bc(t);return r.enable=j,t}function H7(t){let A=bc(t);A||(Zw(t,{copyState:!1}),A=bc(t)),A.push()}function Ta(t){let A=bc(t);Ot(A),A.pop()}function VR(t,A){let j=t[A].bind(t);t[A]=function(r){if(r===void 0||XR.has(r))return j(r);let n=bc(t);return r in n.cache||(n.cache[r]=j(r)),n.enable?n.cache[r]:j(r)},Object.defineProperty(t[A],"name",{value:`${A}-from-cache`,configurable:!1})}function WnA(t,A,j){if(!t[A])return;let e=t[A].bind(t);t[A]=function(...n){let i=bc(t),{valueChanged:o,oldValue:l}=j(i._updateCache,...n);return o&&e(...n),l},Object.defineProperty(t[A],"name",{value:`${A}-to-cache`,configurable:!1})}function YnA(t){let A=t.useProgram.bind(t);t.useProgram=function(e){let r=bc(t);r.program!==e&&(A(e),r.program=e)}}var JnA={powerPreference:"high-performance",onContextLost:()=>console.error("WebGL context lost"),onContextRestored:()=>console.info("WebGL context restored")};function QR(t,A){A={...JnA,...A};let j=null,e=n=>j=n.statusMessage||j;t.addEventListener("webglcontextcreationerror",e,!1);let r=null;if(r||(r=t.getContext("webgl2",A)),t.removeEventListener("webglcontextcreationerror",e,!1),!r)throw new Error(`Failed to create WebGL context: ${j||"Unknown error"}`);if(A.onContextLost){let{onContextLost:n}=A;t.addEventListener("webglcontextlost",i=>n(i),!1)}if(A.onContextRestored){let{onContextRestored:n}=A;t.addEventListener("webglcontextrestored",i=>n(i),!1)}return r}function wi(t,A,j){return j[A]===void 0&&(j[A]=t.getExtension(A)||null),j[A]}function WR(t,A){let j=t.getParameter(7936),e=t.getParameter(7937);wi(t,"WEBGL_debug_renderer_info",A);let r=A.WEBGL_debug_renderer_info,n=t.getParameter(r?r.UNMASKED_VENDOR_WEBGL:7936),i=t.getParameter(r?r.UNMASKED_RENDERER_WEBGL:7937),o=n||j,l=i||e,c=t.getParameter(7938),B=YR(o,l),h=ZnA(o,l),d=A6A(o,l);return{type:"webgl",gpu:B,gpuType:d,gpuBackend:h,vendor:o,renderer:l,version:c,shadingLanguage:"glsl",shadingLanguageVersion:300}}function YR(t,A){return/NVIDIA/i.exec(t)||/NVIDIA/i.exec(A)?"nvidia":/INTEL/i.exec(t)||/INTEL/i.exec(A)?"intel":/Apple/i.exec(t)||/Apple/i.exec(A)?"apple":/AMD/i.exec(t)||/AMD/i.exec(A)||/ATI/i.exec(t)||/ATI/i.exec(A)?"amd":/SwiftShader/i.exec(t)||/SwiftShader/i.exec(A)?"software":"unknown"}function ZnA(t,A){return/Metal/i.exec(t)||/Metal/i.exec(A)?"metal":/ANGLE/i.exec(t)||/ANGLE/i.exec(A)?"opengl":"unknown"}function A6A(t,A){if(/SwiftShader/i.exec(t)||/SwiftShader/i.exec(A))return"cpu";switch(YR(t,A)){case"intel":return"integrated";case"software":return"cpu";case"unknown":return"unknown";default:return"discrete"}}function I$(t){switch(t){case"uint8":return 5121;case"sint8":return 5120;case"unorm8":return 5121;case"snorm8":return 5120;case"uint16":return 5123;case"sint16":return 5122;case"unorm16":return 5123;case"snorm16":return 5122;case"uint32":return 5125;case"sint32":return 5124;case"float16":return 5131;case"float32":return 5126}throw new Error(String(t))}var cn="texture-compression-bc",$j="texture-compression-astc",fs="texture-compression-etc2",t6A="texture-compression-etc1-webgl",M$="texture-compression-pvrtc-webgl",AF="texture-compression-atc-webgl",Mp="float32-renderable-webgl",tF="float16-renderable-webgl",j6A="rgb9e5ufloat_renderable-webgl",jF="snorm8-renderable-webgl",Op="norm16-renderable-webgl",eF="snorm16-renderable-webgl",O$="float32-filterable",JR="float16-filterable-webgl",Tp="WEBGL_compressed_texture_s3tc",Sp="WEBGL_compressed_texture_s3tc_srgb",OB="EXT_texture_compression_rgtc",TB="EXT_texture_compression_bptc",e6A="WEBGL_compressed_texture_etc",r6A="WEBGL_compressed_texture_astc",n6A="WEBGL_compressed_texture_etc1",i6A="WEBGL_compressed_texture_pvrtc",o6A="WEBGL_compressed_texture_atc",ZR="EXT_texture_norm16",AL="EXT_render_snorm",s6A="EXT_color_buffer_float",T$={"float32-renderable-webgl":["EXT_color_buffer_float"],"float16-renderable-webgl":["EXT_color_buffer_half_float"],"rgb9e5ufloat_renderable-webgl":["WEBGL_render_shared_exponent"],"snorm8-renderable-webgl":[AL],"norm16-renderable-webgl":[ZR],"snorm16-renderable-webgl":[ZR,AL],"float32-filterable":["OES_texture_float_linear"],"float16-filterable-webgl":["OES_texture_half_float_linear"],"texture-filterable-anisotropic-webgl":["EXT_texture_filter_anisotropic"],"texture-blend-float-webgl":["EXT_float_blend"],"texture-compression-bc":[Tp,Sp,OB,TB],"texture-compression-bc5-webgl":[OB],"texture-compression-bc7-webgl":[TB],"texture-compression-etc2":[e6A],"texture-compression-astc":[r6A],"texture-compression-etc1-webgl":[n6A],"texture-compression-pvrtc-webgl":[i6A],"texture-compression-atc-webgl":[o6A]};function tL(t){return t in T$}function jL(t,A,j){return(T$[A]||[]).every(r=>wi(t,r,j))}var S$={"rgb8unorm-unsized":{gl:6407,b:4,c:2,bpp:4,dataFormat:6407,types:[5121,33635]},"rgba8unorm-unsized":{gl:6408,b:4,c:2,bpp:4,dataFormat:6408,types:[5121,32819,32820]},r8unorm:{gl:33321,b:1,c:1,rb:!0},r8snorm:{gl:36756,b:1,c:1,render:jF},r8uint:{gl:33330,b:1,c:1,rb:!0},r8sint:{gl:33329,b:1,c:1,rb:!0},rg8unorm:{gl:33323,b:2,c:2,rb:!0},rg8snorm:{gl:36757,b:2,c:2,render:jF},rg8uint:{gl:33336,b:2,c:2,rb:!0},rg8sint:{gl:33335,b:2,c:2,rb:!0},r16uint:{gl:33332,b:2,c:1,rb:!0},r16sint:{gl:33331,b:2,c:1,rb:!0},r16float:{gl:33325,b:2,c:1,render:tF,filter:"float16-filterable-webgl",rb:!0},"r16unorm-webgl":{gl:33322,b:2,c:1,f:Op,rb:!0},"r16snorm-webgl":{gl:36760,b:2,c:1,f:eF},"rgba4unorm-webgl":{gl:32854,b:2,c:4,wgpu:!1,rb:!0},"rgb565unorm-webgl":{gl:36194,b:2,c:4,wgpu:!1,rb:!0},"rgb5a1unorm-webgl":{gl:32855,b:2,c:4,wgpu:!1,rb:!0},"rgb8unorm-webgl":{gl:32849,b:3,c:3,wgpu:!1},"rgb8snorm-webgl":{gl:36758,b:3,c:3,wgpu:!1},rgba8unorm:{gl:32856,b:4,c:2,bpp:4},"rgba8unorm-srgb":{gl:35907,b:4,c:4,bpp:4},rgba8snorm:{gl:36759,b:4,c:4,render:jF},rgba8uint:{gl:36220,b:4,c:4,bpp:4},rgba8sint:{gl:36238,b:4,c:4,bpp:4},bgra8unorm:{b:4,c:4},"bgra8unorm-srgb":{b:4,c:4},rg16uint:{gl:33338,b:4,c:1,bpp:4},rg16sint:{gl:33337,b:4,c:2,bpp:4},rg16float:{gl:33327,bpp:4,b:4,c:2,render:tF,filter:JR,rb:!0},"rg16unorm-webgl":{gl:33324,b:2,c:2,render:Op},"rg16snorm-webgl":{gl:36761,b:2,c:2,render:eF},r32uint:{gl:33334,b:4,c:1,bpp:4,rb:!0},r32sint:{gl:33333,b:4,c:1,bpp:4,rb:!0},r32float:{gl:33326,bpp:4,b:4,c:1,render:Mp,filter:O$},rgb9e5ufloat:{gl:35901,b:4,c:3,p:1,render:j6A},rg11b10ufloat:{gl:35898,b:4,c:3,p:1,render:Mp,rb:!0},rgb10a2unorm:{gl:32857,b:4,c:4,p:1,rb:!0},"rgb10a2uint-webgl":{b:4,c:4,gl:36975,p:1,wgpu:!1,bpp:4,rb:!0},"rgb16unorm-webgl":{gl:32852,b:2,c:3,f:Op},"rgb16snorm-webgl":{gl:36762,b:2,c:3,f:Op},rg32uint:{gl:33340,b:8,c:2,rb:!0},rg32sint:{gl:33339,b:8,c:2,rb:!0},rg32float:{gl:33328,b:8,c:2,render:Mp,filter:O$,rb:!0},rgba16uint:{gl:36214,b:8,c:4,rb:!0},rgba16sint:{gl:36232,b:8,c:4,rb:!0},rgba16float:{gl:34842,b:8,c:4,render:tF,filter:JR},"rgba16unorm-webgl":{gl:32859,b:2,c:4,render:Op,rb:!0},"rgba16snorm-webgl":{gl:36763,b:2,c:4,render:eF},"rgb32float-webgl":{gl:34837,render:Mp,filter:O$,gl2ext:s6A,dataFormat:6407,types:[5126]},rgba32uint:{gl:36208,b:16,c:4,rb:!0},rgba32sint:{gl:36226,b:16,c:4,rb:!0},rgba32float:{gl:34836,b:16,c:4,render:Mp,filter:O$,rb:!0},stencil8:{gl:36168,b:1,c:1,attachment:36128,rb:!0},depth16unorm:{gl:33189,b:2,c:1,attachment:36096,dataFormat:6402,types:[5123],rb:!0},depth24plus:{gl:33190,b:3,c:1,attachment:36096,dataFormat:6402,types:[5125]},depth32float:{gl:36012,b:4,c:1,attachment:36096,dataFormat:6402,types:[5126],rb:!0},"depth24plus-stencil8":{gl:35056,b:4,c:2,p:1,attachment:33306,rb:!0,depthTexture:!0,dataFormat:34041,types:[34042]},"depth24unorm-stencil8":{gl:35056,b:4,c:2,p:1,attachment:33306,dataFormat:34041,types:[34042],rb:!0},"depth32float-stencil8":{gl:36013,b:5,c:2,p:1,attachment:33306,dataFormat:34041,types:[36269],rb:!0},"bc1-rgb-unorm-webgl":{gl:33776,x:Tp,f:cn},"bc1-rgb-unorm-srgb-webgl":{gl:35916,x:Sp,f:cn},"bc1-rgba-unorm":{gl:33777,x:Tp,f:cn},"bc1-rgba-unorm-srgb":{gl:35916,x:Sp,f:cn},"bc2-rgba-unorm":{gl:33778,x:Tp,f:cn},"bc2-rgba-unorm-srgb":{gl:35918,x:Sp,f:cn},"bc3-rgba-unorm":{gl:33779,x:Tp,f:cn},"bc3-rgba-unorm-srgb":{gl:35919,x:Sp,f:cn},"bc4-r-unorm":{gl:36283,x:OB,f:cn},"bc4-r-snorm":{gl:36284,x:OB,f:cn},"bc5-rg-unorm":{gl:36285,x:OB,f:cn},"bc5-rg-snorm":{gl:36286,x:OB,f:cn},"bc6h-rgb-ufloat":{gl:36495,x:TB,f:cn},"bc6h-rgb-float":{gl:36494,x:TB,f:cn},"bc7-rgba-unorm":{gl:36492,x:TB,f:cn},"bc7-rgba-unorm-srgb":{gl:36493,x:TB,f:cn},"etc2-rgb8unorm":{gl:37492,f:fs},"etc2-rgb8unorm-srgb":{gl:37494,f:fs},"etc2-rgb8a1unorm":{gl:37496,f:fs},"etc2-rgb8a1unorm-srgb":{gl:37497,f:fs},"etc2-rgba8unorm":{gl:37493,f:fs},"etc2-rgba8unorm-srgb":{gl:37495,f:fs},"eac-r11unorm":{gl:37488,f:fs},"eac-r11snorm":{gl:37489,f:fs},"eac-rg11unorm":{gl:37490,f:fs},"eac-rg11snorm":{gl:37491,f:fs},"astc-4x4-unorm":{gl:37808,f:$j},"astc-4x4-unorm-srgb":{gl:37840,f:$j},"astc-5x4-unorm":{gl:37809,f:$j},"astc-5x4-unorm-srgb":{gl:37841,f:$j},"astc-5x5-unorm":{gl:37810,f:$j},"astc-5x5-unorm-srgb":{gl:37842,f:$j},"astc-6x5-unorm":{gl:37811,f:$j},"astc-6x5-unorm-srgb":{gl:37843,f:$j},"astc-6x6-unorm":{gl:37812,f:$j},"astc-6x6-unorm-srgb":{gl:37844,f:$j},"astc-8x5-unorm":{gl:37813,f:$j},"astc-8x5-unorm-srgb":{gl:37845,f:$j},"astc-8x6-unorm":{gl:37814,f:$j},"astc-8x6-unorm-srgb":{gl:37846,f:$j},"astc-8x8-unorm":{gl:37815,f:$j},"astc-8x8-unorm-srgb":{gl:37847,f:$j},"astc-10x5-unorm":{gl:37819,f:$j},"astc-10x5-unorm-srgb":{gl:37851,f:$j},"astc-10x6-unorm":{gl:37817,f:$j},"astc-10x6-unorm-srgb":{gl:37849,f:$j},"astc-10x8-unorm":{gl:37818,f:$j},"astc-10x8-unorm-srgb":{gl:37850,f:$j},"astc-10x10-unorm":{gl:37819,f:$j},"astc-10x10-unorm-srgb":{gl:37851,f:$j},"astc-12x10-unorm":{gl:37820,f:$j},"astc-12x10-unorm-srgb":{gl:37852,f:$j},"astc-12x12-unorm":{gl:37821,f:$j},"astc-12x12-unorm-srgb":{gl:37853,f:$j},"pvrtc-rgb4unorm-webgl":{gl:35840,f:M$},"pvrtc-rgba4unorm-webgl":{gl:35842,f:M$},"pvrtc-rbg2unorm-webgl":{gl:35841,f:M$},"pvrtc-rgba2unorm-webgl":{gl:35843,f:M$},"etc1-rbg-unorm-webgl":{gl:36196,f:t6A},"atc-rgb-unorm-webgl":{gl:35986,f:AF},"atc-rgba-unorm-webgl":{gl:35986,f:AF},"atc-rgbai-unorm-webgl":{gl:34798,f:AF}},a6A={6403:1,36244:1,33319:2,33320:2,6407:3,36248:3,6408:4,36249:4,6402:1,34041:1,6406:1,6409:1,6410:2},l6A={5126:4,5125:4,5124:4,5123:2,5122:2,5131:2,5120:1,5121:1};function R$(t,A,j){let e=S$[A];if(!e||e.gl===void 0)return!1;let r=e.x||e.gl2ext;return r?!!wi(t,r,j):!0}function rF(t){let j=S$[t]?.gl;if(j===void 0)throw new Error(`Unsupported texture format ${t}`);return j}function eL(t,A,j){if(!R$(t,A,j)||A.startsWith("depth")||A.startsWith("stencil"))return!1;try{if(mE(A).signed)return!1}catch{return!1}return A.endsWith("32float")?!!wi(t,"OES_texture_float_linear, extensions",j):A.endsWith("16float")?!!wi(t,"OES_texture_half_float_linear, extensions",j):!0}function rL(t,A,j){return!(!R$(t,A,j)||typeof A=="number")}function SB(t){let A=S$[t],j=rF(t),e=mE(t);return{format:j,dataFormat:A?.dataFormat||c6A(e.format,e.integer,e.normalized,j),type:e.dataType?I$(e.dataType):A?.types?.[0]||5121,compressed:e.compressed}}function nL(t){let A=S$[t];if(!A?.attachment)throw new Error(`${t} is not a depth stencil format`);return A.attachment}function nF(t){let A=SB(t),j=a6A[A.dataFormat]||4,e=l6A[A.type]||1;return j*e}function c6A(t,A,j,e){if(e===6408||e===6407)return e;switch(t){case"r":return A&&!j?36244:6403;case"rg":return A&&!j?33320:33319;case"rgb":return A&&!j?36248:6407;case"rgba":return A&&!j?36249:6408;default:return 6408}}var iL={"depth-clip-control":"EXT_depth_clamp","timer-query-webgl":"EXT_disjoint_timer_query_webgl2","compilation-status-async-webgl":"KHR_parallel_shader_compile","polygon-mode-webgl":"WEBGL_polygon_mode","provoking-vertex-webgl":"WEBGL_provoking_vertex","shader-clip-cull-distance-webgl":"WEBGL_clip_cull_distance","shader-noperspective-interpolation-webgl":"NV_shader_noperspective_interpolation","shader-conservative-depth-webgl":"EXT_conservative_depth"},L$=class extends Vd{constructor(j,e,r){super([],r);I(this,"gl");I(this,"extensions");I(this,"testedFeatures",new Set);this.gl=j,this.extensions=e,wi(j,"EXT_color_buffer_float",e)}*[Symbol.iterator](){let j=this.getFeatures();for(let e of j)this.has(e)&&(yield e);return[]}has(j){return this.disabledFeatures[j]?!1:(this.testedFeatures.has(j)||(this.testedFeatures.add(j),tL(j)&&jL(this.gl,j,this.extensions)&&this.features.add(j),this.getWebGLFeature(j)&&this.features.add(j)),this.features.has(j))}initializeFeatures(){let j=this.getFeatures().filter(e=>e!=="polygon-mode-webgl");for(let e of j)this.has(e)}getFeatures(){return[...Object.keys(iL),...Object.keys(T$)]}getWebGLFeature(j){let e=iL[j];return typeof e=="string"?!!wi(this.gl,e,this.extensions):!!e}};var C$=class extends Ud{constructor(j){super();I(this,"gl");I(this,"limits",{});this.gl=j}get maxTextureDimension1D(){return 0}get maxTextureDimension2D(){return this.getParameter(3379)}get maxTextureDimension3D(){return this.getParameter(32883)}get maxTextureArrayLayers(){return this.getParameter(35071)}get maxBindGroups(){return 0}get maxDynamicUniformBuffersPerPipelineLayout(){return 0}get maxDynamicStorageBuffersPerPipelineLayout(){return 0}get maxSampledTexturesPerShaderStage(){return this.getParameter(35660)}get maxSamplersPerShaderStage(){return this.getParameter(35661)}get maxStorageBuffersPerShaderStage(){return 0}get maxStorageTexturesPerShaderStage(){return 0}get maxUniformBuffersPerShaderStage(){return this.getParameter(35375)}get maxUniformBufferBindingSize(){return this.getParameter(35376)}get maxStorageBufferBindingSize(){return 0}get minUniformBufferOffsetAlignment(){return this.getParameter(35380)}get minStorageBufferOffsetAlignment(){return 0}get maxVertexBuffers(){return 16}get maxVertexAttributes(){return this.getParameter(34921)}get maxVertexBufferArrayStride(){return 2048}get maxInterStageShaderComponents(){return this.getParameter(35659)}get maxComputeWorkgroupStorageSize(){return 0}get maxComputeInvocationsPerWorkgroup(){return 0}get maxComputeWorkgroupSizeX(){return 0}get maxComputeWorkgroupSizeY(){return 0}get maxComputeWorkgroupSizeZ(){return 0}get maxComputeWorkgroupsPerDimension(){return 0}getParameter(j){return this.limits[j]===void 0&&(this.limits[j]=this.gl.getParameter(j)),this.limits[j]}};function Fi(t,A,j){if(u6A(A))return j(t);let{nocatch:e=!0}=A;H7(t),$o(t,A);let r;if(e)r=j(t),Ta(t);else try{r=j(t)}finally{Ta(t)}return r}function u6A(t){for(let A in t)return!1;return!0}function sL(t,A,j,e){if(b7(A))return e(t);let r=t;H7(r.gl);try{return B6A(t,A),$o(r.gl,j),e(t)}finally{Ta(r.gl)}}function B6A(t,A){let j=t,{gl:e}=j;if(A.cullMode)switch(A.cullMode){case"none":e.disable(2884);break;case"front":e.enable(2884),e.cullFace(1028);break;case"back":e.enable(2884),e.cullFace(1029);break}if(A.frontFace&&e.frontFace(Gc("frontFace",A.frontFace,{ccw:2305,cw:2304})),A.unclippedDepth&&t.features.has("depth-clip-control")&&e.enable(34383),A.depthBias!==void 0&&(e.enable(32823),e.polygonOffset(A.depthBias,A.depthBiasSlopeScale||0)),A.provokingVertex&&t.features.has("provoking-vertex-webgl")){let n=j.getExtension("WEBGL_provoking_vertex").WEBGL_provoking_vertex,i=Gc("provokingVertex",A.provokingVertex,{first:36429,last:36430});n?.provokingVertexWEBGL(i)}if((A.polygonMode||A.polygonOffsetLine)&&t.features.has("polygon-mode-webgl")){if(A.polygonMode){let n=j.getExtension("WEBGL_polygon_mode").WEBGL_polygon_mode,i=Gc("polygonMode",A.polygonMode,{fill:6914,line:6913});n?.polygonModeWEBGL(1028,i),n?.polygonModeWEBGL(1029,i)}A.polygonOffsetLine&&e.enable(10754)}if(t.features.has("shader-clip-cull-distance-webgl")&&(A.clipDistance0&&e.enable(12288),A.clipDistance1&&e.enable(12289),A.clipDistance2&&e.enable(12290),A.clipDistance3&&e.enable(12291),A.clipDistance4&&e.enable(12292),A.clipDistance5&&e.enable(12293),A.clipDistance6&&e.enable(12294),A.clipDistance7&&e.enable(12295)),A.depthWriteEnabled!==void 0&&e.depthMask(h6A("depthWriteEnabled",A.depthWriteEnabled)),A.depthCompare&&(A.depthCompare!=="always"?e.enable(2929):e.disable(2929),e.depthFunc(D$("depthCompare",A.depthCompare))),A.stencilWriteMask){let r=A.stencilWriteMask;e.stencilMaskSeparate(1028,r),e.stencilMaskSeparate(1029,r)}if(A.stencilReadMask&&mA.warn("stencilReadMask not supported under WebGL"),A.stencilCompare){let r=A.stencilReadMask||4294967295,n=D$("depthCompare",A.stencilCompare);A.stencilCompare!=="always"?e.enable(2960):e.disable(2960),e.stencilFuncSeparate(1028,n,0,r),e.stencilFuncSeparate(1029,n,0,r)}if(A.stencilPassOperation&&A.stencilFailOperation&&A.stencilDepthFailOperation){let r=iF("stencilPassOperation",A.stencilPassOperation),n=iF("stencilFailOperation",A.stencilFailOperation),i=iF("stencilDepthFailOperation",A.stencilDepthFailOperation);e.stencilOpSeparate(1028,n,i,r),e.stencilOpSeparate(1029,n,i,r)}if(A.blendColorOperation||A.blendAlphaOperation){e.enable(3042);let r=oL("blendColorOperation",A.blendColorOperation||"add"),n=oL("blendAlphaOperation",A.blendAlphaOperation||"add");e.blendEquationSeparate(r,n);let i=H$("blendColorSrcFactor",A.blendColorSrcFactor||"one"),o=H$("blendColorDstFactor",A.blendColorDstFactor||"zero"),l=H$("blendAlphaSrcFactor",A.blendAlphaSrcFactor||"one"),c=H$("blendAlphaDstFactor",A.blendAlphaDstFactor||"zero");e.blendFuncSeparate(i,o,l,c)}}function D$(t,A){return Gc(t,A,{never:512,less:513,equal:514,"less-equal":515,greater:516,"not-equal":517,"greater-equal":518,always:519})}function iF(t,A){return Gc(t,A,{keep:7680,zero:0,replace:7681,invert:5386,"increment-clamp":7682,"decrement-clamp":7683,"increment-wrap":34055,"decrement-wrap":34056})}function oL(t,A){return Gc(t,A,{add:32774,subtract:32778,"reverse-subtract":32779,min:32775,max:32776})}function H$(t,A){return Gc(t,A,{one:1,zero:0,"src-color":768,"one-minus-src-color":769,"dst-color":774,"one-minus-dst-color":775,"src-alpha":770,"one-minus-src-alpha":771,"dst-alpha":772,"one-minus-dst-alpha":773,"src-alpha-saturated":776,"constant-color":32769,"one-minus-constant-color":32770,"constant-alpha":32771,"one-minus-constant-alpha":32772})}function f6A(t,A){return`Illegal parameter ${A} for ${t}`}function Gc(t,A,j){if(!(A in j))throw new Error(f6A(t,A));return j[A]}function h6A(t,A){return A}function N$(t){let A={};return t.addressModeU&&(A[10242]=oF(t.addressModeU)),t.addressModeV&&(A[10243]=oF(t.addressModeV)),t.addressModeW&&(A[32882]=oF(t.addressModeW)),t.magFilter&&(A[10240]=aL(t.magFilter)),(t.minFilter||t.mipmapFilter)&&(A[10241]=d6A(t.minFilter||"linear",t.mipmapFilter)),t.lodMinClamp!==void 0&&(A[33082]=t.lodMinClamp),t.lodMaxClamp!==void 0&&(A[33083]=t.lodMaxClamp),t.type==="comparison-sampler"&&(A[34892]=34894),t.compare&&(A[34893]=D$("compare",t.compare)),t.maxAnisotropy&&(A[34046]=t.maxAnisotropy),A}function oF(t){switch(t){case"clamp-to-edge":return 33071;case"repeat":return 10497;case"mirror-repeat":return 33648}}function aL(t){switch(t){case"nearest":return 9728;case"linear":return 9729}}function d6A(t,A){if(!A)return aL(t);switch(t){case"nearest":return A==="nearest"?9984:9986;case"linear":return A==="nearest"?9985:9987}}var Mn=class extends Aj{constructor(j,e={}){super(j,e);I(this,"device");I(this,"gl");I(this,"handle");I(this,"glTarget");I(this,"glUsage");I(this,"glIndexType",5123);I(this,"byteLength");I(this,"bytesUsed");this.device=j,this.gl=this.device.gl;let r=typeof e=="object"?e.handle:void 0;this.handle=r||this.gl.createBuffer(),j.setSpectorMetadata(this.handle,{...this.props,data:typeof this.props.data}),this.glTarget=p6A(this.props.usage),this.glUsage=k6A(this.props.usage),this.glIndexType=this.props.indexType==="uint32"?5125:5123,e.data?this._initWithData(e.data,e.byteOffset,e.byteLength):this._initWithByteLength(e.byteLength||0)}_initWithData(j,e=0,r=j.byteLength+e){let n=this.glTarget;this.gl.bindBuffer(n,this.handle),this.gl.bufferData(n,r,this.glUsage),this.gl.bufferSubData(n,e,j),this.gl.bindBuffer(n,null),this.bytesUsed=r,this.byteLength=r,this._setDebugData(j,e,r),this.trackAllocatedMemory(r)}_initWithByteLength(j){Ot(j>=0);let e=j;j===0&&(e=new Float32Array(0));let r=this.glTarget;return this.gl.bindBuffer(r,this.handle),this.gl.bufferData(r,e,this.glUsage),this.gl.bindBuffer(r,null),this.bytesUsed=j,this.byteLength=j,this._setDebugData(null,0,j),this.trackAllocatedMemory(j),this}destroy(){!this.destroyed&&this.handle&&(this.removeStats(),this.trackDeallocatedMemory(),this.gl.deleteBuffer(this.handle),this.destroyed=!0,this.handle=null)}write(j,e=0){this.gl.bindBuffer(36663,this.handle),this.gl.bufferSubData(36663,e,j),this.gl.bindBuffer(36663,null),this._setDebugData(j,e,j.byteLength)}async readAsync(j=0,e){return this.readSyncWebGL(j,e)}readSyncWebGL(j=0,e){e=e??this.byteLength-j;let r=new Uint8Array(e),n=0;return this.gl.bindBuffer(36662,this.handle),this.gl.getBufferSubData(36662,j,r,n,e),this.gl.bindBuffer(36662,null),this._setDebugData(r,j,e),r}};function p6A(t){return t&Aj.INDEX?34963:t&Aj.VERTEX?34962:t&Aj.UNIFORM?35345:34962}function k6A(t){return t&Aj.INDEX||t&Aj.VERTEX?35044:t&Aj.UNIFORM?35048:35044}var wc=class extends dc{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"parameters");this.device=j,this.parameters=N$(e),this.handle=this.handle||this.device.gl.createSampler(),this._setSamplerParameters(this.parameters)}destroy(){this.handle&&(this.device.gl.deleteSampler(this.handle),this.handle=void 0)}toString(){return`Sampler(${this.id},${JSON.stringify(this.props)})`}_setSamplerParameters(j){for(let[e,r]of Object.entries(j)){let n=Number(e);switch(n){case 33082:case 33083:this.device.gl.samplerParameterf(this.handle,n,r);break;default:this.device.gl.samplerParameteri(this.handle,n,r);break}}}};var xo=class extends fc{constructor(j,e){super(j,{...Ne.defaultProps,...e});I(this,"device");I(this,"gl");I(this,"handle");I(this,"texture");this.device=j,this.gl=this.device.gl,this.handle=null,this.texture=e.texture}};var g6A={parameters:{},pixelStore:{},pixels:null,border:0,dataFormat:void 0,textureUnit:void 0,target:void 0},Rp=class Rp extends Ne{constructor(j,e){super(j,{...g6A,format:"rgba8unorm",...e});I(this,"MAX_ATTRIBUTES");I(this,"device");I(this,"gl");I(this,"handle");I(this,"sampler");I(this,"view");I(this,"glFormat");I(this,"type");I(this,"dataFormat");I(this,"mipmaps");I(this,"target");I(this,"textureUnit");I(this,"loaded",!1);I(this,"_video");this.device=j,this.gl=this.device.gl,this.handle=this.props.handle||this.gl.createTexture(),this.device.setSpectorMetadata(this.handle,{...this.props,data:typeof this.props.data}),this.glFormat=6408,this.target=m6A(this.props),this.loaded=!1,typeof this.props?.data=="string"&&Object.assign(this.props,{data:oG(this.props.data)}),this.initialize(this.props),Object.seal(this)}destroy(){this.handle&&(this.gl.deleteTexture(this.handle),this.removeStats(),this.trackDeallocatedMemory("Texture"),this.destroyed=!0)}toString(){return`Texture(${this.id},${this.width}x${this.height})`}createView(j){return new xo(this.device,{...j,texture:this})}initialize(j={}){if(this.props.dimension==="cube")return this.initializeCube(j);let e=j.data;if(e instanceof Promise)return e.then(y=>this.initialize(Object.assign({},j,{pixels:y,data:y}))),this;let r=typeof HTMLVideoElement<"u"&&e instanceof HTMLVideoElement;if(r&&e.readyStatethis.initialize(j)),this;let{parameters:n={}}=j,{pixels:i=null,pixelStore:o={},textureUnit:l=void 0,mipmaps:c=!0}=j;e||(e=i);let{width:B,height:h,dataFormat:d,type:k,compressed:g=!1}=j,{depth:E=0}=j,m=rF(j.format);return{width:B,height:h,compressed:g,dataFormat:d,type:k}=this._deduceParameters({format:j.format,type:k,dataFormat:d,compressed:g,data:e,width:B,height:h}),this.width=B,this.height=h,this.glFormat=m,this.type=k,this.dataFormat=d,this.textureUnit=l,Number.isFinite(this.textureUnit)&&(this.gl.activeTexture(33984+this.textureUnit),this.gl.bindTexture(this.target,this.handle)),this.mipmaps=c,this.setImageData({data:e,width:B,height:h,depth:E,format:j.format,type:k,dataFormat:d,parameters:o,compressed:g}),this.setSampler(j.sampler),this._setSamplerParameters(n),this.view=this.createView({...this.props,mipLevelCount:1,arrayLayerCount:1}),c&&this.device.isTextureFormatFilterable(j.format)&&this.generateMipmap(),r&&(this._video={video:e,parameters:n,lastTime:e.readyState>=HTMLVideoElement.HAVE_CURRENT_DATA?e.currentTime:-1}),this}initializeCube(j){let{mipmaps:e=!0,parameters:r={}}=j;return this.setCubeMapImageData(j).then(()=>{this.loaded=!0,e&&this.generateMipmap(j),this.setSampler(j.sampler),this._setSamplerParameters(r)}),this}setSampler(j={}){let e;j instanceof wc?(this.sampler=j,e=j.props):(this.sampler=new wc(this.device,j),e=j);let r=N$(e);return this._setSamplerParameters(r),this}resize(j){let{height:e,width:r,mipmaps:n=!1}=j;return r!==this.width||e!==this.height?this.initialize({width:r,height:e,format:this.format,type:this.type,dataFormat:this.dataFormat,mipmaps:n}):this}update(){if(this._video){let{video:j,parameters:e,lastTime:r}=this._video;if(r===j.currentTime||j.readyState{this.gl.generateMipmap(this.target)}),this.gl.bindTexture(this.target,null),this}setImageData(j){if(this.props.dimension==="3d"||this.props.dimension==="2d-array")return this.setImageData3D(j);this.trackDeallocatedMemory("Texture");let{target:e=this.target,pixels:r=null,level:n=0,glFormat:i=this.glFormat,offset:o=0,parameters:l={}}=j,{data:c=null,type:B=this.type,width:h=this.width,height:d=this.height,dataFormat:k=this.dataFormat,compressed:g=!1}=j;c||(c=r),{type:B,dataFormat:k,compressed:g,width:h,height:d}=this._deduceParameters({format:this.props.format,type:B,dataFormat:k,compressed:g,data:c,width:h,height:d});let{gl:E}=this;E.bindTexture(this.target,this.handle);let m=null;if({data:c,dataType:m}=this._getDataType({data:c,compressed:g}),Fi(this.gl,l,()=>{switch(m){case"null":E.texImage2D(e,n,i,h,d,0,k,B,c);break;case"typed-array":E.texImage2D(e,n,i,h,d,0,k,B,c,o);break;case"buffer":this.device.gl.bindBuffer(35052,c.handle||c),this.device.gl.texImage2D(e,n,i,h,d,0,k,B,o),this.device.gl.bindBuffer(35052,null);break;case"browser-object":E.texImage2D(e,n,i,h,d,0,k,B,c);break;case"compressed":for(let[y,G]of c.entries())E.compressedTexImage2D(e,y,G.format,G.width,G.height,0,G.data);break;default:Ot(!1,"Unknown image data type")}}),c&&c.byteLength)this.trackAllocatedMemory(c.byteLength,"Texture");else{let y=nF(this.props.format);this.trackAllocatedMemory(this.width*this.height*y,"Texture")}return this.loaded=!0,this}setSubImageData({target:j=this.target,pixels:e=null,data:r=null,x:n=0,y:i=0,width:o=this.width,height:l=this.height,level:c=0,glFormat:B=this.glFormat,type:h=this.type,dataFormat:d=this.dataFormat,compressed:k=!1,offset:g=0,parameters:E={}}){if({type:h,dataFormat:d,compressed:k,width:o,height:l}=this._deduceParameters({format:this.props.format,type:h,dataFormat:d,compressed:k,data:r,width:o,height:l}),Ot(this.depth===1,"texSubImage not supported for 3D textures"),r||(r=e),r&&r.data){let m=r;r=m.data,o=m.shape[0],l=m.shape[1]}r instanceof Mn&&(r=r.handle),this.gl.bindTexture(this.target,this.handle),Fi(this.gl,E,()=>{k?this.gl.compressedTexSubImage2D(j,c,n,i,o,l,B,r):r===null?this.gl.texSubImage2D(j,c,n,i,o,l,d,h,null):ArrayBuffer.isView(r)?this.gl.texSubImage2D(j,c,n,i,o,l,d,h,r,g):typeof WebGLBuffer<"u"&&r instanceof WebGLBuffer?(this.device.gl.bindBuffer(35052,r),this.device.gl.texSubImage2D(j,c,n,i,o,l,d,h,g),this.device.gl.bindBuffer(35052,null)):this.device.gl.texSubImage2D(j,c,n,i,o,l,d,h,r)}),this.gl.bindTexture(this.target,null)}copyFramebuffer(j={}){return mA.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(),null}getActiveUnit(){return this.gl.getParameter(34016)-33984}bind(j=this.textureUnit){let{gl:e}=this;return j!==void 0&&(this.textureUnit=j,e.activeTexture(33984+j)),e.bindTexture(this.target,this.handle),j}unbind(j=this.textureUnit){let{gl:e}=this;return j!==void 0&&(this.textureUnit=j,e.activeTexture(33984+j)),e.bindTexture(this.target,null),j}_getDataType({data:j,compressed:e=!1}){return e?{data:j,dataType:"compressed"}:j===null?{data:j,dataType:"null"}:ArrayBuffer.isView(j)?{data:j,dataType:"typed-array"}:j instanceof Mn?{data:j.handle,dataType:"buffer"}:typeof WebGLBuffer<"u"&&j instanceof WebGLBuffer?{data:j,dataType:"buffer"}:{data:j,dataType:"browser-object"}}_deduceParameters(j){let{format:e,data:r}=j,{width:n,height:i,dataFormat:o,type:l,compressed:c}=j,B=SB(e);return o=o||B.dataFormat,l=l||B.type,c=c||B.compressed,{width:n,height:i}=this._deduceImageSize(r,n,i),{dataFormat:o,type:l,compressed:c,width:n,height:i,format:e,data:r}}_deduceImageSize(j,e,r){let n;return typeof ImageData<"u"&&j instanceof ImageData?n={width:j.width,height:j.height}:typeof HTMLImageElement<"u"&&j instanceof HTMLImageElement?n={width:j.naturalWidth,height:j.naturalHeight}:typeof HTMLCanvasElement<"u"&&j instanceof HTMLCanvasElement?n={width:j.width,height:j.height}:typeof ImageBitmap<"u"&&j instanceof ImageBitmap?n={width:j.width,height:j.height}:typeof HTMLVideoElement<"u"&&j instanceof HTMLVideoElement?n={width:j.videoWidth,height:j.videoHeight}:j?n={width:e,height:r}:n={width:e>=0?e:1,height:r>=0?r:1},Ot(n,"Could not deduced texture size"),Ot(e===void 0||n.width===e,"Deduced texture width does not match supplied width"),Ot(r===void 0||n.height===r,"Deduced texture height does not match supplied height"),n}async setCubeMapImageData(j){let{gl:e}=this,{width:r,height:n,pixels:i,data:o,format:l=6408,type:c=5121}=j,B=i||o,h=await Promise.all(Rp.FACES.map(d=>{let k=B[d];return Promise.all(Array.isArray(k)?k:[k])}));this.bind(),Rp.FACES.forEach((d,k)=>{h[k].length>1&&this.props.mipmaps!==!1&&mA.warn(`${this.id} has mipmap and multiple LODs.`)(),h[k].forEach((g,E)=>{r&&n?e.texImage2D(d,E,l,r,n,0,l,c,g):e.texImage2D(d,E,l,l,c,g)})}),this.unbind()}setImageDataForFace(j){let{face:e,width:r,height:n,pixels:i,data:o,format:l=6408,type:c=5121}=j,{gl:B}=this,h=i||o;return this.bind(),h instanceof Promise?h.then(d=>this.setImageDataForFace(Object.assign({},j,{face:e,data:d,pixels:d}))):this.width||this.height?B.texImage2D(e,0,l,r,n,0,l,c,h):B.texImage2D(e,0,l,l,c,h),this}setImageData3D(j){let{level:e=0,dataFormat:r,format:n,type:i,width:o,height:l,depth:c=1,offset:B=0,data:h,parameters:d={}}=j;this.trackDeallocatedMemory("Texture"),this.gl.bindTexture(this.target,this.handle);let k=SB(n);if(Fi(this.gl,d,()=>{ArrayBuffer.isView(h)&&this.gl.texImage3D(this.target,e,k.format,o,l,c,0,k.dataFormat,k.type,h),h instanceof Mn&&(this.gl.bindBuffer(35052,h.handle),this.gl.texImage3D(this.target,e,r,o,l,c,0,n,i,B))}),h&&h.byteLength)this.trackAllocatedMemory(h.byteLength,"Texture");else{let g=nF(this.props.format);this.trackAllocatedMemory(this.width*this.height*this.depth*g,"Texture")}return this.loaded=!0,this}_setSamplerParameters(j){if(!b7(j)){E6A(j),this.gl.bindTexture(this.target,this.handle);for(let[e,r]of Object.entries(j)){let n=Number(e),i=r;switch(n){case 33082:case 33083:this.gl.texParameterf(this.target,n,i);break;default:this.gl.texParameteri(this.target,n,i);break}}this.gl.bindTexture(this.target,null)}}};I(Rp,"FACES",[34069,34070,34071,34072,34073,34074]);var _6=Rp;function m6A(t){switch(t.dimension){case"2d":return 3553;case"cube":return 34067;case"2d-array":return 35866;case"3d":return 32879;case"1d":case"cube-array":default:throw new Error(t.dimension)}}function E6A(t){mA.log(1,"texture sampler parameters",t)()}var hs=class extends pc{constructor(j,e){super(j,e);I(this,"device");I(this,"gl");I(this,"handle");let r=e.handle===null;if(this.device=j,this.gl=j.gl,this.handle=this.props.handle||r?this.props.handle:this.gl.createFramebuffer(),!r){j.setSpectorMetadata(this.handle,{id:this.props.id,props:this.props}),this.autoCreateAttachmentTextures();let n=this.gl.bindFramebuffer(36160,this.handle);for(let i=0;imA.info("Spector capture started:",A)()),q6?.onCapture.add(A=>{mA.info("Spector capture complete:",A)(),q6?.getResultUI(),q6?.resultView.display(),q6?.resultView.addCapture(A)})),t?.canvas){if(typeof t.spector=="string"&&t.spector!==t.canvas.id)return q6;q6?.startCapture(t?.canvas,500),new Promise(A=>setTimeout(A,2e3)).then(A=>{mA.info("Spector capture stopped after 2 seconds")(),q6?.stopCapture()})}return q6}var q6A="https://unpkg.com/webgl-debug@2.0.1/index.js";function BL(t){return t.luma=t.luma||{},t.luma}async function fL(){rn()&&!globalThis.WebGLDebugUtils&&(globalThis.global=globalThis.global||globalThis,globalThis.global.module={},await rp(q6A))}function hL(t,A={}){return t?A.debug?G6A(t,A):b6A(t):null}function b6A(t){let A=BL(t);return A.realContext?A.realContext:t}function G6A(t,A){if(!globalThis.WebGLDebugUtils)return mA.warn("webgl-debug not loaded")(),t;let j=BL(t);if(j.debugContext)return j.debugContext;globalThis.WebGLDebugUtils.init({...C7,...t});let e=globalThis.WebGLDebugUtils.makeDebugContext(t,w6A.bind(null,A),F6A.bind(null,A));for(let i in C7)!(i in e)&&typeof C7[i]=="number"&&(e[i]=C7[i]);class r{}Object.setPrototypeOf(e,Object.getPrototypeOf(t)),Object.setPrototypeOf(r,e);let n=Object.create(r);return j.realContext=t,j.debugContext=n,n.debug=!0,n}function sF(t,A){A=Array.from(A).map(e=>e===void 0?"undefined":e);let j=globalThis.WebGLDebugUtils.glFunctionArgsToString(t,A);return j=`${j.slice(0,100)}${j.length>100?"...":""}`,`gl.${t}(${j})`}function w6A(t,A,j,e){e=Array.from(e).map(o=>o===void 0?"undefined":o);let r=globalThis.WebGLDebugUtils.glEnumToString(A),n=globalThis.WebGLDebugUtils.glFunctionArgsToString(j,e),i=`${r} in gl.${j}(${n})`;mA.error(i)();debugger;if(t.throwOnError)throw new Error(i)}function F6A(t,A,j){let e="";if(mA.level>=1&&(e=sF(A,j),mA.log(1,e)()),t.break&&t.break.length>0&&(e=e||sF(A,j),t.break.every(n=>e.indexOf(n)!==-1)))debugger;for(let r of j)if(r===void 0){if(e=e||sF(A,j),t.throwOnError)throw new Error(`Undefined argument: ${e}`);mA.error(`Undefined argument: ${e}`)();debugger}}function pL(t){let A=t.split(/\r?\n/),j=[];for(let e of A){if(e.length<=1)continue;let r=e.split(":");if(r.length===2){let[h,d]=r;j.push({message:d.trim(),type:dL(h),lineNum:0,linePos:0});continue}let[n,i,o,...l]=r,c=parseInt(o,10);isNaN(c)&&(c=0);let B=parseInt(i,10);isNaN(B)&&(B=0),j.push({message:l.join(":").trim(),type:dL(n),lineNum:c,linePos:B})}return j}function dL(t){let A=["warning","error","info"],j=t.toLowerCase();return A.includes(j)?j:"info"}var X$=class extends hc{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");switch(this.device=j,this.props.stage){case"vertex":this.handle=this.props.handle||this.device.gl.createShader(35633);break;case"fragment":this.handle=this.props.handle||this.device.gl.createShader(35632);break;default:throw new Error(this.props.stage)}this._compile(this.source)}destroy(){this.handle&&(this.removeStats(),this.device.gl.deleteShader(this.handle),this.destroyed=!0)}async getCompilationInfo(){return await this._waitForCompilationComplete(),this.getCompilationInfoSync()}getCompilationInfoSync(){let j=this.device.gl.getShaderInfoLog(this.handle);return pL(j)}getTranslatedSource(){return this.device.getExtension("WEBGL_debug_shaders").WEBGL_debug_shaders?.getTranslatedShaderSource(this.handle)}async _compile(j){j=(n=>n.startsWith("#version ")?n:`#version 100 +${n}`)(j);let{gl:r}=this.device;if(r.shaderSource(this.handle,j),r.compileShader(this.handle),mA.level===0){this.compilationStatus="pending";return}if(!this.device.features.has("compilation-status-async-webgl")){if(this._getCompilationStatus(),this.debugShader(),this.compilationStatus==="error")throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);return}mA.once(1,"Shader compilation is asynchronous")(),await this._waitForCompilationComplete(),mA.info(2,`Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)(),this._getCompilationStatus(),this.debugShader()}async _waitForCompilationComplete(){let j=async n=>await new Promise(i=>setTimeout(i,n));if(!this.device.features.has("compilation-status-async-webgl")){await j(10);return}let{gl:r}=this.device;for(;;){if(r.getShaderParameter(this.handle,37297))return;await j(10)}}_getCompilationStatus(){this.compilationStatus=this.device.gl.getShaderParameter(this.handle,35713)?"success":"error"}};var P6A=256,I6A=1024,M6A=16384,aF=6144,O6A=[1,2,4,8],z$=class extends Wd{constructor(j,e){super(j,e);I(this,"device");I(this,"glParameters");this.device=j,H7(this.device.gl),this.setParameters(this.props.parameters),this.clear()}end(){Ta(this.device.gl)}pushDebugGroup(j){}popDebugGroup(){}insertDebugMarker(j){}setParameters(j={}){let e={...this.glParameters};this.props.framebuffer&&(e.framebuffer=this.props.framebuffer),this.props.depthReadOnly&&(e.depthMask=!this.props.depthReadOnly),e.stencilMask=this.props.stencilReadOnly?0:1,e[35977]=this.props.discard,j.viewport&&(j.viewport.length>=6?(e.viewport=j.viewport.slice(0,4),e.depthRange=[j.viewport[4],j.viewport[5]]):e.viewport=j.viewport),j.scissorRect&&(e.scissorTest=!0,e.scissor=j.scissorRect),j.blendConstant&&(e.blendColor=j.blendConstant),j.stencilReference&&(console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL"),j[2967]=j.stencilReference),j.colorMask&&(e.colorMask=O6A.map(r=>!!(r&j.colorMask))),this.glParameters=e,$o(this.device.gl,e)}beginOcclusionQuery(j){this.props.occlusionQuerySet?.beginOcclusionQuery()}endOcclusionQuery(){this.props.occlusionQuerySet?.endOcclusionQuery()}clear(){let j={...this.glParameters},e=0;this.props.clearColor!==!1&&(e|=M6A,j.clearColor=this.props.clearColor),this.props.clearDepth!==!1&&(e|=P6A,j.clearDepth=this.props.clearDepth),this.props.clearStencil!==!1&&(e|=I6A,j.clearStencil=this.props.clearStencil),e!==0&&Fi(this.device.gl,j,()=>{this.device.gl.clear(e)})}clearColorBuffer(j=0,e=[0,0,0,0]){Fi(this.device.gl,{framebuffer:this.props.framebuffer},()=>{switch(e.constructor){case Int32Array:this.device.gl.clearBufferiv(aF,j,e);break;case Uint32Array:this.device.gl.clearBufferuiv(aF,j,e);break;case Float32Array:default:this.device.gl.clearBufferfv(aF,j,e);break}})}};var T6A="Failed to deduce GL constant from typed array";function kL(t){switch(ArrayBuffer.isView(t)?t.constructor:t){case Float32Array:return 5126;case Uint16Array:return 5123;case Uint32Array:return 5125;case Uint8Array:return 5121;case Uint8ClampedArray:return 5121;case Int8Array:return 5120;case Int16Array:return 5122;case Int32Array:return 5124;default:throw new Error(T6A)}}function Lp(t,A){let{clamped:j=!0}=A||{};switch(t){case 5126:return Float32Array;case 5123:case 33635:case 32819:case 32820:return Uint16Array;case 5125:return Uint32Array;case 5121:return j?Uint8ClampedArray:Uint8Array;case 5120:return Int8Array;case 5122:return Int16Array;case 5124:return Int32Array;default:throw new Error("Failed to deduce typed array type from GL constant")}}var S6A={offset:0,stride:0,type:5126,size:1,divisor:0,normalized:!1,integer:!1},R6A={deprecatedProps:{instanced:"divisor",isInstanced:"divisor"}},U$=class t{constructor(...A){I(this,"offset");I(this,"stride");I(this,"type");I(this,"size");I(this,"divisor");I(this,"normalized");I(this,"integer");I(this,"buffer");I(this,"index");A.forEach(j=>this._assign(j)),Object.freeze(this)}static getBytesPerElement(A){return Lp(A.type||5126).BYTES_PER_ELEMENT}static getBytesPerVertex(A){return Ot(A.size),Lp(A.type||5126).BYTES_PER_ELEMENT*A.size}static resolve(...A){return new t(S6A,...A)}toString(){return JSON.stringify(this)}get BYTES_PER_ELEMENT(){return t.getBytesPerElement(this)}get BYTES_PER_VERTEX(){return t.getBytesPerVertex(this)}_assign(A={}){return A=iG("Accessor",A,R6A),A.type!==void 0&&(this.type=A.type,(A.type===5124||A.type===5125)&&(this.integer=!0)),A.size!==void 0&&(this.size=A.size),A.offset!==void 0&&(this.offset=A.offset),A.stride!==void 0&&(this.stride=A.stride),A.normalize!==void 0&&(this.normalized=A.normalize),A.normalized!==void 0&&(this.normalized=A.normalized),A.integer!==void 0&&(this.integer=A.integer),A.divisor!==void 0&&(this.divisor=A.divisor),A.buffer!==void 0&&(this.buffer=A.buffer),A.index!==void 0&&(typeof A.index=="boolean"?this.index=A.index?1:0:this.index=A.index),A.instanced!==void 0&&(this.divisor=A.instanced?1:0),A.isInstanced!==void 0&&(this.divisor=A.isInstanced?1:0),this.offset===void 0&&delete this.offset,this.stride===void 0&&delete this.stride,this.type===void 0&&delete this.type,this.size===void 0&&delete this.size,this.divisor===void 0&&delete this.divisor,this.normalized===void 0&&delete this.normalized,this.integer===void 0&&delete this.integer,this.buffer===void 0&&delete this.buffer,this.index===void 0&&delete this.index,this}};function gL(t){return L6A.includes(t)}var L6A=[35678,35680,35679,35682,36289,36292,36293,36298,36299,36300,36303,36306,36307,36308,36311],mL={5126:[5126,1,"float","f32","float32"],35664:[5126,2,"vec2","vec2","float32x2"],35665:[5126,3,"vec3","vec3","float32x3"],35666:[5126,4,"vec4","vec4","float32x4"],5124:[5124,1,"int","i32","sint32"],35667:[5124,2,"ivec2","vec2","sint32x2"],35668:[5124,3,"ivec3","vec3","sint32x3"],35669:[5124,4,"ivec4","vec4","sint32x4"],5125:[5125,1,"uint","u32","uint32"],36294:[5125,2,"uvec2","vec2","uint32x2"],36295:[5125,3,"uvec3","vec3","uint32x3"],36296:[5125,4,"uvec4","vec4","uint32x4"],35670:[5126,1,"bool","f32","float32"],35671:[5126,2,"bvec2","vec2","float32x2"],35672:[5126,3,"bvec3","vec3","float32x3"],35673:[5126,4,"bvec4","vec4","float32x4"],35674:[5126,8,"mat2","mat2x2"],35685:[5126,8,"mat2x3","mat2x3"],35686:[5126,8,"mat2x4","mat2x4"],35687:[5126,12,"mat3x2","mat3x2"],35675:[5126,12,"mat3","mat3x3"],35688:[5126,12,"mat3x4","mat3x4"],35689:[5126,16,"mat4x2","mat4x2"],35690:[5126,16,"mat4x3","mat4x3"],35676:[5126,16,"mat4","mat4x4"]};function lF(t){let A=mL[t];if(!A)throw new Error("uniform");let[j,e,,r]=A;return{format:r,components:e,glType:j}}function EL(t){let A=mL[t];if(!A)throw new Error("attribute");let[,j,,e,r]=A;return{attributeType:e,vertexFormat:r,components:j}}function $L(t,A){let j={attributes:[],bindings:[]};j.attributes=C6A(t,A);let e=N6A(t,A);for(let o of e){let l=o.uniforms.map(c=>({name:c.name,format:c.format,byteOffset:c.byteOffset,byteStride:c.byteStride,arrayLength:c.arrayLength}));j.bindings.push({type:"uniform",name:o.name,location:o.location,visibility:(o.vertex?1:0)&(o.fragment?2:0),minBindingSize:o.byteLength,uniforms:l})}let r=D6A(t,A),n=0;for(let o of r)if(gL(o.type)){let{viewDimension:l,sampleType:c}=X6A(o.type);j.bindings.push({type:"texture",name:o.name,location:n,viewDimension:l,sampleType:c}),o.textureUnit=n,n+=1}r.length&&(j.uniforms=r);let i=H6A(t,A);return i?.length&&(j.varyings=i),j}function C6A(t,A){let j=[],e=t.getProgramParameter(A,35721);for(let r=0;r=0){let{attributeType:c}=EL(o),B=/instance/i.test(i)?"instance":"vertex";j.push({name:i,location:l,stepMode:B,type:c})}}return j.sort((r,n)=>r.location-n.location),j}function H6A(t,A){let j=[],e=t.getProgramParameter(A,35971);for(let r=0;rr.location-n.location),j}function D6A(t,A){let j=[],e=t.getProgramParameter(A,35718);for(let r=0;r1)for(let k=0;kt.getActiveUniformBlockParameter(A,n,i),e=[],r=t.getProgramParameter(A,35382);for(let n=0;nn.location-i.location),e}var K6A={35678:["2d","float"],35680:["cube","float"],35679:["3d","float"],35682:["3d","depth"],36289:["2d-array","float"],36292:["2d-array","depth"],36293:["cube","float"],36298:["2d","sint"],36299:["3d","sint"],36300:["cube","sint"],36303:["2d-array","uint"],36306:["2d","uint"],36307:["3d","uint"],36308:["cube","uint"],36311:["2d-array","uint"]};function X6A(t){let A=K6A[t];if(!A)throw new Error("sampler");let[j,e]=A;return{viewDimension:j,sampleType:e}}function z6A(t){if(t[t.length-1]!=="]")return{name:t,length:1,isArray:!1};let j=/([^[]*)(\[[0-9]+\])?/.exec(t);if(!j||j.length<2)throw new Error(`Failed to parse GLSL uniform name ${t}`);return{name:j[1],length:j[2]?1:0,isArray:!!j[2]}}function xL(t,A,j,e){let r=t,n=e;n===!0&&(n=1),n===!1&&(n=0);let i=typeof n=="number"?[n]:n;switch(j){case 35678:case 35680:case 35679:case 35682:case 36289:case 36292:case 36293:case 36298:case 36299:case 36300:case 36303:case 36306:case 36307:case 36308:case 36311:if(typeof e!="number")throw new Error("samplers must be set to integers");return t.uniform1i(A,e);case 5126:return t.uniform1fv(A,i);case 35664:return t.uniform2fv(A,i);case 35665:return t.uniform3fv(A,i);case 35666:return t.uniform4fv(A,i);case 5124:return t.uniform1iv(A,i);case 35667:return t.uniform2iv(A,i);case 35668:return t.uniform3iv(A,i);case 35669:return t.uniform4iv(A,i);case 35670:return t.uniform1iv(A,i);case 35671:return t.uniform2iv(A,i);case 35672:return t.uniform3iv(A,i);case 35673:return t.uniform4iv(A,i);case 5125:return r.uniform1uiv(A,i,1);case 36294:return r.uniform2uiv(A,i,2);case 36295:return r.uniform3uiv(A,i,3);case 36296:return r.uniform4uiv(A,i,4);case 35674:return t.uniformMatrix2fv(A,!1,i);case 35675:return t.uniformMatrix3fv(A,!1,i);case 35676:return t.uniformMatrix4fv(A,!1,i);case 35685:return r.uniformMatrix2x3fv(A,!1,i);case 35686:return r.uniformMatrix2x4fv(A,!1,i);case 35687:return r.uniformMatrix3x2fv(A,!1,i);case 35688:return r.uniformMatrix3x4fv(A,!1,i);case 35689:return r.uniformMatrix4x2fv(A,!1,i);case 35690:return r.uniformMatrix4x3fv(A,!1,i)}throw new Error("Illegal uniform")}function yL(t){switch(t){case"point-list":return 0;case"line-list":return 1;case"line-strip":return 3;case"line-loop-webgl":return 2;case"triangle-list":return 4;case"triangle-strip":return 5;case"triangle-fan-webgl":return 6;default:throw new Error(t)}}function vL(t){switch(t){case"point-list":return 0;case"line-list":return 1;case"line-strip":return 1;case"line-loop-webgl":return 1;case"triangle-list":return 4;case"triangle-strip":return 4;case"triangle-fan-webgl":return 4;default:throw new Error(t)}}var _L=4,V$=class extends rs{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"vs");I(this,"fs");I(this,"introspectedLayout");I(this,"uniforms",{});I(this,"bindings",{});I(this,"varyings",null);I(this,"_uniformCount",0);I(this,"_uniformSetters",{});this.device=j,this.handle=this.props.handle||this.device.gl.createProgram(),this.device.setSpectorMetadata(this.handle,{id:this.props.id}),this.vs=e.vs,this.fs=e.fs;let{varyings:r,bufferMode:n=35981}=e;switch(r&&r.length>0&&(this.varyings=r,this.device.gl.transformFeedbackVaryings(this.handle,r,n)),this._linkShaders(),mA.time(1,`RenderPipeline ${this.id} - shaderLayout introspection`)(),this.introspectedLayout=$L(this.device.gl,this.handle),mA.timeEnd(1,`RenderPipeline ${this.id} - shaderLayout introspection`)(),this.shaderLayout=jG(this.introspectedLayout,e.shaderLayout),this.props.topology){case"triangle-fan-webgl":case"line-loop-webgl":mA.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);break;default:}}destroy(){this.handle&&(this.device.gl.deleteProgram(this.handle),this.destroyed=!0)}setBindings(j,e){for(let[r,n]of Object.entries(j)){let i=this.shaderLayout.bindings.find(o=>o.name===r)||this.shaderLayout.bindings.find(o=>o.name===`${r}Uniforms`);if(!i){let o=this.shaderLayout.bindings.map(l=>`"${l.name}"`).join(", ");e?.disableWarnings||mA.warn(`Unknown binding "${r}" in render pipeline "${this.id}", expected one of ${o}`)();continue}switch(n||mA.warn(`Unsetting binding "${r}" in render pipeline "${this.id}"`)(),i.type){case"uniform":if(!(n instanceof Mn)&&!(n.buffer instanceof Mn))throw new Error("buffer value");break;case"texture":if(!(n instanceof xo||n instanceof _6||n instanceof hs))throw new Error("texture value");break;case"sampler":mA.warn(`Ignoring sampler ${r}`)();break;default:throw new Error(i.type)}this.bindings[r]=n}}draw(j){let{renderPass:e,parameters:r=this.props.parameters,topology:n=this.props.topology,vertexArray:i,vertexCount:o,instanceCount:l,isInstanced:c=!1,firstVertex:B=0,transformFeedback:h}=j,d=yL(n),k=!!i.indexBuffer,g=i.indexBuffer?.glIndexType;if(this.linkStatus!=="success")return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)(),!1;if(!this._areTexturesRenderable()||o===0)return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)(),!1;if(o===0)return mA.info(2,`RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)(),!0;this.device.gl.useProgram(this.handle),i.bindBeforeRender(e),h&&h.begin(this.props.topology),this._applyBindings(),this._applyUniforms();let E=e;return sL(this.device,r,E.glParameters,()=>{k&&c?this.device.gl.drawElementsInstanced(d,o||0,g,B,l||0):k?this.device.gl.drawElements(d,o||0,g,B):c?this.device.gl.drawArraysInstanced(d,B,o||0,l||0):this.device.gl.drawArrays(d,B,o||0),h&&h.end()}),i.unbindAfterRender(e),!0}setUniformsWebGL(j){let{bindings:e}=kc(j);Object.keys(e).forEach(r=>{mA.warn(`Unsupported value "${JSON.stringify(e[r])}" used in setUniforms() for key ${r}. Use setBindings() instead?`)()}),Object.assign(this.uniforms,j)}async _linkShaders(){let{gl:j}=this.device;if(j.attachShader(this.handle,this.vs.handle),j.attachShader(this.handle,this.fs.handle),mA.time(_L,`linkProgram for ${this.id}`)(),j.linkProgram(this.handle),mA.timeEnd(_L,`linkProgram for ${this.id}`)(),mA.level,!this.device.features.has("compilation-status-async-webgl")){let r=this._getLinkStatus();this._reportLinkStatus(r);return}mA.once(1,"RenderPipeline linking is asynchronous")(),await this._waitForLinkComplete(),mA.info(2,`RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();let e=this._getLinkStatus();this._reportLinkStatus(e)}_reportLinkStatus(j){switch(j){case"success":return;default:throw this.vs.compilationStatus==="error"?(this.vs.debugShader(),new Error(`Error during compilation of shader ${this.vs.id}`)):this.fs?.compilationStatus==="error"?(this.fs.debugShader(),new Error(`Error during compilation of shader ${this.fs.id}`)):new Error(`Error during ${j}: ${this.device.gl.getProgramInfoLog(this.handle)}`)}}_getLinkStatus(){let{gl:j}=this.device;return j.getProgramParameter(this.handle,35714)?(j.validateProgram(this.handle),j.getProgramParameter(this.handle,35715)?(this.linkStatus="success","success"):(this.linkStatus="error","validation")):(this.linkStatus="error","linking")}async _waitForLinkComplete(){let j=async n=>await new Promise(i=>setTimeout(i,n));if(!this.device.features.has("compilation-status-async-webgl")){await j(10);return}let{gl:r}=this.device;for(;;){if(r.getProgramParameter(this.handle,37297))return;await j(10)}}_areTexturesRenderable(){let j=!0;for(let[,e]of Object.entries(this.bindings))e instanceof _6&&(e.update(),j=j&&e.loaded);return j}_applyBindings(){if(this.linkStatus!=="success")return;let{gl:j}=this.device;j.useProgram(this.handle);let e=0,r=0;for(let n of this.shaderLayout.bindings){let i=this.bindings[n.name]||this.bindings[n.name.replace(/Uniforms$/,"")];if(!i)throw new Error(`No value for binding ${n.name} in ${this.id}`);switch(n.type){case"uniform":let{name:o}=n,l=j.getUniformBlockIndex(this.handle,o);if(l===4294967295)throw new Error(`Invalid uniform block name ${o}`);j.uniformBlockBinding(this.handle,r,l),i instanceof Mn?j.bindBufferBase(35345,r,i.handle):j.bindBufferRange(35345,r,i.buffer.handle,i.offset||0,i.size||i.buffer.byteLength-i.offset),r+=1;break;case"texture":if(!(i instanceof xo||i instanceof _6||i instanceof hs))throw new Error("texture");let c;if(i instanceof xo)c=i.texture;else if(i instanceof _6)c=i;else if(i instanceof hs&&i.colorAttachments[0]instanceof xo)mA.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")(),c=i.colorAttachments[0].texture;else throw new Error("No texture");j.activeTexture(33984+e),j.bindTexture(c.target,c.handle),e+=1;break;case"sampler":break;case"storage":case"read-only-storage":throw new Error(`binding type '${n.type}' not supported in WebGL`)}}}_applyUniforms(){for(let j of this.shaderLayout.uniforms||[]){let{name:e,location:r,type:n,textureUnit:i}=j,o=this.uniforms[e]??i;o!==void 0&&xL(this.device.gl,r,n,o)}}};var Q$=class extends Jd{constructor(j){super(j,{});I(this,"device");I(this,"commands",[]);this.device=j}submitCommands(j=this.commands){for(let e of j)switch(e.name){case"copy-buffer-to-buffer":U6A(this.device,e.options);break;case"copy-buffer-to-texture":V6A(this.device,e.options);break;case"copy-texture-to-buffer":Q6A(this.device,e.options);break;case"copy-texture-to-texture":W6A(this.device,e.options);break}}};function U6A(t,A){let j=A.source,e=A.destination;t.gl.bindBuffer(36662,j.handle),t.gl.bindBuffer(36663,e.handle),t.gl.copyBufferSubData(36662,36663,A.sourceOffset??0,A.destinationOffset??0,A.size),t.gl.bindBuffer(36662,null),t.gl.bindBuffer(36663,null)}function V6A(t,A){throw new Error("Not implemented")}function Q6A(t,A){let{source:j,mipLevel:e=0,aspect:r="all",width:n=A.source.width,height:i=A.source.height,depthOrArrayLayers:o=0,origin:l=[0,0],destination:c,byteOffset:B=0,bytesPerRow:h,rowsPerImage:d}=A;if(r!=="all")throw new Error("not supported");if(e!==0||o!==0||h||d)throw new Error("not implemented");let{framebuffer:k,destroyFramebuffer:g}=qL(j),E;try{let m=c,y=n||k.width,G=i||k.height,v=SB(k.texture.props.format),_=v.dataFormat,w=v.type;t.gl.bindBuffer(35051,m.handle),E=t.gl.bindFramebuffer(36160,k.handle),t.gl.readPixels(l[0],l[1],y,G,_,w,B)}finally{t.gl.bindBuffer(35051,null),E!==void 0&&t.gl.bindFramebuffer(36160,E),g&&k.destroy()}}function W6A(t,A){let{source:j,destinationMipLevel:e=0,origin:r=[0,0],destinationOrigin:n=[0,0],destination:i}=A,{width:o=A.destination.width,height:l=A.destination.height}=A,{framebuffer:c,destroyFramebuffer:B}=qL(j),[h,d]=r,[k,g,E]=n,m=t.gl.bindFramebuffer(36160,c.handle),y=null,G;if(i instanceof _6)y=i,o=Number.isFinite(o)?o:y.width,l=Number.isFinite(l)?l:y.height,y.bind(0),G=y.target;else throw new Error("invalid destination");switch(G){case 3553:case 34067:t.gl.copyTexSubImage2D(G,e,k,g,h,d,o,l);break;case 35866:case 32879:t.gl.copyTexSubImage3D(G,e,k,g,E,h,d,o,l);break;default:}y&&y.unbind(),t.gl.bindFramebuffer(36160,m),B&&c.destroy()}function qL(t){if(t instanceof Ne){let{width:A,height:j,id:e}=t;return{framebuffer:t.device.createFramebuffer({id:`framebuffer-for-${e}`,width:A,height:j,colorAttachments:[t]}),destroyFramebuffer:!0}}return{framebuffer:t,destroyFramebuffer:!1}}var W$=class extends Yd{constructor(j,e){super(j,e);I(this,"device");I(this,"commandBuffer");this.device=j,this.commandBuffer=new Q$(j)}destroy(){}finish(){this.commandBuffer.submitCommands()}copyBufferToBuffer(j){this.commandBuffer.commands.push({name:"copy-buffer-to-buffer",options:j})}copyBufferToTexture(j){this.commandBuffer.commands.push({name:"copy-buffer-to-texture",options:j})}copyTextureToBuffer(j){this.commandBuffer.commands.push({name:"copy-texture-to-buffer",options:j})}copyTextureToTexture(j){this.commandBuffer.commands.push({name:"copy-texture-to-texture",options:j})}pushDebugGroup(j){}popDebugGroup(){}insertDebugMarker(j){}resolveQuerySet(j,e,r){}};var Y$=class t extends Zd{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"buffer",null);I(this,"bufferValue",null);this.device=j,this.handle=this.device.gl.createVertexArray()}get[Symbol.toStringTag](){return"VertexArray"}static isConstantAttributeZeroSupported(j){return ib()==="Chrome"}destroy(){super.destroy(),this.buffer&&this.buffer?.destroy(),this.handle&&(this.device.gl.deleteVertexArray(this.handle),this.handle=void 0)}setIndexBuffer(j){let e=j;if(e&&e.glTarget!==34963)throw new Error("Use .setBuffer()");this.device.gl.bindVertexArray(this.handle),this.device.gl.bindBuffer(34963,e?e.handle:null),this.indexBuffer=e,this.device.gl.bindVertexArray(null)}setBuffer(j,e){let r=e;if(r.glTarget===34963)throw new Error("Use .setIndexBuffer()");let{size:n,type:i,stride:o,offset:l,normalized:c,integer:B,divisor:h}=this._getAccessor(j);this.device.gl.bindVertexArray(this.handle),this.device.gl.bindBuffer(34962,r.handle),B?this.device.gl.vertexAttribIPointer(j,n,i,o,l):this.device.gl.vertexAttribPointer(j,n,i,c,o,l),this.device.gl.bindBuffer(34962,null),this.device.gl.enableVertexAttribArray(j),this.device.gl.vertexAttribDivisor(j,h||0),this.attributes[j]=r,this.device.gl.bindVertexArray(null)}setConstantWebGL(j,e){this._enable(j,!1),this.attributes[j]=e}bindBeforeRender(){this.device.gl.bindVertexArray(this.handle),this._applyConstantAttributes()}unbindAfterRender(){this.device.gl.bindVertexArray(null)}_applyConstantAttributes(){for(let j=0;j{for(let e in j)this.setBuffer(e,j[e])})}setBuffer(j,e){let r=this._getVaryingIndex(j),{buffer:n,byteLength:i,byteOffset:o}=this._getBufferRange(e);if(r<0){this.unusedBuffers[j]=n,mA.warn(`${this.id} unusedBuffers varying buffer ${j}`)();return}this.buffers[r]={buffer:n,byteLength:i,byteOffset:o},this.bindOnUse||this._bindBuffer(r,n,o,i)}getBuffer(j){if(bL(j))return this.buffers[j]||null;let e=this._getVaryingIndex(j);return e>=0?this.buffers[e]:null}bind(j=this.handle){if(typeof j!="function")return this.gl.bindTransformFeedback(36386,j),this;let e;return this._bound?e=j():(this.gl.bindTransformFeedback(36386,this.handle),this._bound=!0,e=j(),this._bound=!1,this.gl.bindTransformFeedback(36386,null)),e}unbind(){this.bind(null)}_getBufferRange(j){if(j instanceof Mn)return{buffer:j,byteOffset:0,byteLength:j.byteLength};let{buffer:e,byteOffset:r=0,byteLength:n=j.buffer.byteLength}=j;return{buffer:e,byteOffset:r,byteLength:n}}_getVaryingIndex(j){if(bL(j))return Number(j);for(let e of this.layout.varyings)if(j===e.name)return e.location;return-1}_bindBuffers(){for(let j in this.buffers){let{buffer:e,byteLength:r,byteOffset:n}=this._getBufferRange(this.buffers[j]);this._bindBuffer(Number(j),e,n,r)}}_unbindBuffers(){for(let j in this.buffers)this.gl.bindBufferBase(35982,Number(j),null)}_bindBuffer(j,e,r=0,n){let i=e&&e.handle;!i||n===void 0?this.gl.bindBufferBase(35982,j,i):this.gl.bindBufferRange(35982,j,i,r,n)}};function bL(t){return typeof t=="number"?Number.isInteger(t):/^\d+$/.test(t)}var Z$=class extends tp{constructor(j,e){super(j,e);I(this,"device");I(this,"handle");I(this,"target",null);I(this,"_queryPending",!1);I(this,"_pollingPromise",null);if(this.device=j,e.count>1)throw new Error("WebGL QuerySet can only have one value");this.handle=this.device.gl.createQuery(),Object.seal(this)}get[Symbol.toStringTag](){return"Query"}destroy(){this.device.gl.deleteQuery(this.handle)}beginTimestampQuery(){return this._begin(35007)}endTimestampQuery(){this._end()}beginOcclusionQuery(j){return this._begin(j?.conservative?36202:35887)}endOcclusionQuery(){this._end()}beginTransformFeedbackQuery(){return this._begin(35976)}endTransformFeedbackQuery(){this._end()}async resolveQuery(){return[await this.pollQuery()]}_begin(j){this._queryPending||(this.target=j,this.device.gl.beginQuery(this.target,this.handle))}_end(){this._queryPending||this.target&&(this.device.gl.endQuery(this.target),this.target=null,this._queryPending=!0)}isResultAvailable(){if(!this._queryPending)return!1;let j=this.device.gl.getQueryParameter(this.handle,34919);return j&&(this._queryPending=!1),j}isTimerDisjoint(){return this.device.gl.getParameter(36795)}getResult(){return this.device.gl.getQueryParameter(this.handle,34918)}getTimerMilliseconds(){return this.getResult()/1e6}pollQuery(j=Number.POSITIVE_INFINITY){if(this._pollingPromise)return this._pollingPromise;let e=0;return this._pollingPromise=new Promise((r,n)=>{let i=()=>{this.isResultAvailable()?(r(this.getResult()),this._pollingPromise=null):e++>j?(n("Timed out"),this._pollingPromise=null):requestAnimationFrame(i)};requestAnimationFrame(i)}),this._pollingPromise}};function cF(t){switch(t){case 6406:case 33326:case 6403:return 1;case 33328:case 33319:return 2;case 6407:case 34837:return 3;case 6408:case 34836:return 4;default:return Ot(!1),0}}function GL(t){switch(t){case 5121:return 1;case 33635:case 32819:case 32820:return 2;case 5126:return 4;default:return Ot(!1),0}}function wL(t,A){let{sourceX:j=0,sourceY:e=0,sourceFormat:r=6408,sourceAttachment:n=36064}=A||{},{target:i=null,sourceWidth:o,sourceHeight:l,sourceType:c}=A||{},{framebuffer:B,deleteFramebuffer:h}=PL(t);Ot(B);let{gl:d,handle:k}=B;o=o||B.width,l=l||B.height;let g=n-36064;c=c||B.colorAttachments[g]?.texture?.type||5121,i=AiA(i,c,r,o,l),c=c||kL(i);let E=d.bindFramebuffer(36160,k);return d.readPixels(j,e,o,l,r,c,i),d.bindFramebuffer(36160,E||null),h&&B.destroy(),i}function FL(t,A){let{target:j,sourceX:e=0,sourceY:r=0,sourceFormat:n=6408,targetByteOffset:i=0}=A||{},{sourceWidth:o,sourceHeight:l,sourceType:c}=A||{},{framebuffer:B,deleteFramebuffer:h}=PL(t);Ot(B),o=o||B.width,l=l||B.height;let d=B;c=c||5121;let k=j;if(!k){let E=cF(n),m=GL(c),y=i+o*l*E*m;k=d.device.createBuffer({byteLength:y})}let g=t.device.createCommandEncoder();return g.copyTextureToBuffer({source:t,width:o,height:l,origin:[e,r],destination:k,byteOffset:i}),g.destroy(),h&&B.destroy(),k}function PL(t){return t instanceof pc?{framebuffer:t,deleteFramebuffer:!1}:{framebuffer:Z6A(t),deleteFramebuffer:!0}}function Z6A(t,A){let{device:j,width:e,height:r,id:n}=t;return j.createFramebuffer({...A,id:`framebuffer-for-${n}`,width:e,height:r,colorAttachments:[t]})}function AiA(t,A,j,e,r){if(t)return t;A=A||5121;let n=Lp(A,{clamped:!1}),i=cF(j);return new n(e*r*i)}var tiA=256,jiA=1024,eiA=16384;var riA="clear: bad arguments";function IL(t,A){let{framebuffer:j=null,color:e=null,depth:r=null,stencil:n=null}=A||{},i={};j&&(i.framebuffer=j);let o=0;e&&(o|=eiA,e!==!0&&(i.clearColor=e)),r&&(o|=tiA,r!==!0&&(i.clearDepth=r)),n&&(o|=jiA,r!==!0&&(i.clearStencil=r)),Ot(o!==0,riA);let l=t.gl;Fi(l,i,()=>{l.clear(o)})}var Cp=1,Fc=class Fc extends xa{constructor(j){super({...j,id:j.id||Pn("webgl-device")});I(this,"type","webgl");I(this,"handle");I(this,"features");I(this,"limits");I(this,"info");I(this,"canvasContext");I(this,"lost");I(this,"_resolveContextLost");I(this,"renderPass",null);I(this,"gl");I(this,"debug",!1);I(this,"_canvasSizeInfo",{clientWidth:0,clientHeight:0,devicePixelRatio:1});I(this,"_extensions",{});I(this,"_polyfilled",!1);I(this,"spectorJS");I(this,"_constants");let e=j.gl?.device;if(e)throw new Error(`WebGL context already attached to device ${e.id}`);let r=j.gl?.canvas||j.canvas;this.canvasContext=new K$(this,{...j,canvas:r}),this.lost=new Promise(l=>{this._resolveContextLost=l});let n=j.gl||null;if(n||(n=QR(this.canvasContext.canvas,{...j,onContextLost:l=>this._resolveContextLost?.({reason:"destroyed",message:"Entered sleep mode, or too many apps or browser tabs are using the GPU."})})),!n)throw new Error("WebGL context creation failed");this.handle=n,this.gl=n,this.gl.device=this,this.gl._version=2,j.spector&&(this.spectorJS=uL({...this.props,canvas:this.handle.canvas})),this.info=WR(this.gl,this._extensions),this.limits=new C$(this.gl),this.features=new L$(this.gl,this._extensions,this.props.disabledFeatures),this.props.initalizeFeatures&&this.features.initializeFeatures(),this.canvasContext.resize();let{enable:i=!0,copyState:o=!1}=j;Zw(this.gl,{enable:i,copyState:o,log:(...l)=>mA.log(1,...l)()}),j.debug&&(this.gl=hL(this.gl,{...j,throwOnError:!0}),this.debug=!0,mA.level=Math.max(mA.level,1),mA.warn("WebGL debug mode activated. Performance reduced.")())}static isSupported(){return typeof WebGL2RenderingContext<"u"}static attach(j){if(j instanceof Fc)return j;if(j?.device instanceof xa)return j.device;if(!niA(j))throw new Error("Invalid WebGL2RenderingContext");return new Fc({gl:j})}static async create(j={}){mA.groupCollapsed(Cp,"WebGLDevice created")();let e=[];j.debug&&e.push(fL()),j.spector&&e.push(cL()),typeof j.canvas=="string"&&e.push(G7.pageLoaded);let r=await Promise.allSettled(e);for(let o of r)o.status==="rejected"&&mA.error(`Failed to initialize debug libraries ${o.reason}`)();if(mA.probe(Cp+1,"DOM is loaded")(),j.gl?.device)return mA.warn("reattaching existing device")(),Fc.attach(j.gl);let n=new Fc(j),i=`Created ${n.type}${n.debug?" debug":""} context: ${n.info.vendor}, ${n.info.renderer} for canvas: ${n.canvasContext.id}`;return mA.probe(Cp,i)(),mA.table(Cp,n.info)(),mA.groupEnd(Cp)(),n}destroy(){}get isLost(){return this.gl.isContextLost()}getSize(){return[this.gl.drawingBufferWidth,this.gl.drawingBufferHeight]}isTextureFormatSupported(j){return R$(this.gl,j,this._extensions)}isTextureFormatFilterable(j){return eL(this.gl,j,this._extensions)}isTextureFormatRenderable(j){return rL(this.gl,j,this._extensions)}createCanvasContext(j){throw new Error("WebGL only supports a single canvas")}createBuffer(j){let e=this._getBufferProps(j);return new Mn(this,e)}_createTexture(j){return new _6(this,j)}createExternalTexture(j){throw new Error("createExternalTexture() not implemented")}createSampler(j){return new wc(this,j)}createShader(j){return new X$(this,j)}createFramebuffer(j){return new hs(this,j)}createVertexArray(j){return new Y$(this,j)}createTransformFeedback(j){return new J$(this,j)}createQuerySet(j){return new Z$(this,j)}createRenderPipeline(j){return new V$(this,j)}beginRenderPass(j){return new z$(this,j)}createComputePipeline(j){throw new Error("ComputePipeline not supported in WebGL")}beginComputePass(j){throw new Error("ComputePass not supported in WebGL")}createCommandEncoder(j){return new W$(this,j)}submit(){this.renderPass?.end(),this.renderPass=null}readPixelsToArrayWebGL(j,e){return wL(j,e)}readPixelsToBufferWebGL(j,e){return FL(j,e)}setParametersWebGL(j){$o(this.gl,j)}getParametersWebGL(j){return P$(this.gl,j)}withParametersWebGL(j,e){return Fi(this.gl,j,e)}clearWebGL(j){IL(this,j)}resetWebGL(){mA.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")(),zR(this.gl)}loseDevice(){let j=!1,r=this.getExtension("WEBGL_lose_context").WEBGL_lose_context;return r&&(j=!0,r.loseContext()),this._resolveContextLost?.({reason:"destroyed",message:"Application triggered context loss"}),j}pushState(){H7(this.gl)}popState(){Ta(this.gl)}setSpectorMetadata(j,e){j.__SPECTOR_Metadata=e}getGLKey(j,e){e=e||this.gl2||this.gl;let r=Number(j);for(let n in e)if(e[n]===r)return`GL.${n}`;return String(j)}setConstantAttributeWebGL(j,e){let r=this.limits.maxVertexAttributes;this._constants=this._constants||new Array(r).fill(null);let n=this._constants[j];switch(n&&aiA(n,e)&&mA.info(1,`setConstantAttributeWebGL(${j}) could have been skipped, value unchanged`)(),this._constants[j]=e,e.constructor){case Float32Array:iiA(this,j,e);break;case Int32Array:oiA(this,j,e);break;case Uint32Array:siA(this,j,e);break;default:Ot(!1)}}getExtension(j){return wi(this.gl,j,this._extensions),this._extensions}};I(Fc,"type","webgl");var Pc=Fc;function niA(t){return typeof WebGL2RenderingContext<"u"&&t instanceof WebGL2RenderingContext?!0:!!(t&&Number.isFinite(t._version))}function iiA(t,A,j){switch(j.length){case 1:t.gl.vertexAttrib1fv(A,j);break;case 2:t.gl.vertexAttrib2fv(A,j);break;case 3:t.gl.vertexAttrib3fv(A,j);break;case 4:t.gl.vertexAttrib4fv(A,j);break;default:Ot(!1)}}function oiA(t,A,j){t.gl.vertexAttribI4iv(A,j)}function siA(t,A,j){t.gl.vertexAttribI4uiv(A,j)}function aiA(t,A){if(!t||!A||t.length!==A.length||t.constructor!==A.constructor)return!1;for(let j=0;j0&&e.type==="pointerdown"&&(ciA(r,n=>n.pointerId===e.pointerId)||r.push(e)),A.call(this,e)}}function TL(t){t.prototype.handler=function(j){let e=liA[j.type];e&1&&j.button>=0&&(this.pressed=!0),e&2&&j.which===0&&(e=4),this.pressed&&(e&4&&(this.pressed=!1),this.callback(this.manager,e,{pointers:[j],changedPointers:[j],pointerType:"mouse",srcEvent:j}))}}OL(Ic.PointerEventInput);TL(Ic.MouseInput);var SL=Ic.Manager,yo=Ic;var vo=class{constructor(A,j,e){this.element=A,this.callback=j,this.options={enable:!0,...e}}};var RL=yo?[[yo.Pan,{event:"tripan",pointers:3,threshold:0,enable:!1}],[yo.Rotate,{enable:!1}],[yo.Pinch,{enable:!1}],[yo.Swipe,{enable:!1}],[yo.Pan,{threshold:0,enable:!1}],[yo.Press,{enable:!1}],[yo.Tap,{event:"doubletap",taps:2,enable:!1}],[yo.Tap,{event:"anytap",enable:!1}],[yo.Tap,{enable:!1}]]:null,uF={tripan:["rotate","pinch","pan"],rotate:["pinch"],pinch:["pan"],pan:["press","doubletap","anytap","tap"],doubletap:["anytap"],anytap:["tap"]},LL={doubletap:["tap"]},CL={pointerdown:"pointerdown",pointermove:"pointermove",pointerup:"pointerup",touchstart:"pointerdown",touchmove:"pointermove",touchend:"pointerup",mousedown:"pointerdown",mousemove:"pointermove",mouseup:"pointerup"},RB={KEY_EVENTS:["keydown","keyup"],MOUSE_EVENTS:["mousedown","mousemove","mouseup","mouseover","mouseout","mouseleave"],WHEEL_EVENTS:["wheel","mousewheel"]},HL={tap:"tap",anytap:"anytap",doubletap:"doubletap",press:"press",pinch:"pinch",pinchin:"pinch",pinchout:"pinch",pinchstart:"pinch",pinchmove:"pinch",pinchend:"pinch",pinchcancel:"pinch",rotate:"rotate",rotatestart:"rotate",rotatemove:"rotate",rotateend:"rotate",rotatecancel:"rotate",tripan:"tripan",tripanstart:"tripan",tripanmove:"tripan",tripanup:"tripan",tripandown:"tripan",tripanleft:"tripan",tripanright:"tripan",tripanend:"tripan",tripancancel:"tripan",pan:"pan",panstart:"pan",panmove:"pan",panup:"pan",pandown:"pan",panleft:"pan",panright:"pan",panend:"pan",pancancel:"pan",swipe:"swipe",swipeleft:"swipe",swiperight:"swipe",swipeup:"swipe",swipedown:"swipe"},BF={click:"tap",anyclick:"anytap",dblclick:"doubletap",mousedown:"pointerdown",mousemove:"pointermove",mouseup:"pointerup",mouseover:"pointerover",mouseout:"pointerout",mouseleave:"pointerleave"};var DL=typeof navigator<"u"&&navigator.userAgent?navigator.userAgent.toLowerCase():"",Mc=typeof window<"u"?window:global;var tx=!1;try{let t={get passive(){return tx=!0,!0}};Mc.addEventListener("test",null,t),Mc.removeEventListener("test",null)}catch{tx=!1}var uiA=DL.indexOf("firefox")!==-1,{WHEEL_EVENTS:BiA}=RB,NL="wheel",KL=4.000244140625,fiA=40,hiA=.25,Hp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{if(!this.options.enable)return;let n=r.deltaY;Mc.WheelEvent&&(uiA&&r.deltaMode===Mc.WheelEvent.DOM_DELTA_PIXEL&&(n/=Mc.devicePixelRatio),r.deltaMode===Mc.WheelEvent.DOM_DELTA_LINE&&(n*=fiA)),n!==0&&n%KL===0&&(n=Math.floor(n/KL)),r.shiftKey&&n&&(n=n*hiA),this.callback({type:NL,center:{x:r.clientX,y:r.clientY},delta:-n,srcEvent:r,pointerType:"mouse",target:r.target})},this.events=(this.options.events||[]).concat(BiA),this.events.forEach(r=>A.addEventListener(r,this.handleEvent,tx?{passive:!1}:!1))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===NL&&(this.options.enable=j)}};var{MOUSE_EVENTS:diA}=RB,XL="pointermove",zL="pointerover",UL="pointerout",VL="pointerenter",QL="pointerleave",Dp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=n=>{this.handleOverEvent(n),this.handleOutEvent(n),this.handleEnterEvent(n),this.handleLeaveEvent(n),this.handleMoveEvent(n)},this.pressed=!1;let{enable:r}=this.options;this.enableMoveEvent=r,this.enableLeaveEvent=r,this.enableEnterEvent=r,this.enableOutEvent=r,this.enableOverEvent=r,this.events=(this.options.events||[]).concat(diA),this.events.forEach(n=>A.addEventListener(n,this.handleEvent))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===XL&&(this.enableMoveEvent=j),A===zL&&(this.enableOverEvent=j),A===UL&&(this.enableOutEvent=j),A===VL&&(this.enableEnterEvent=j),A===QL&&(this.enableLeaveEvent=j)}handleOverEvent(A){this.enableOverEvent&&A.type==="mouseover"&&this._emit(zL,A)}handleOutEvent(A){this.enableOutEvent&&A.type==="mouseout"&&this._emit(UL,A)}handleEnterEvent(A){this.enableEnterEvent&&A.type==="mouseenter"&&this._emit(VL,A)}handleLeaveEvent(A){this.enableLeaveEvent&&A.type==="mouseleave"&&this._emit(QL,A)}handleMoveEvent(A){if(this.enableMoveEvent)switch(A.type){case"mousedown":A.button>=0&&(this.pressed=!0);break;case"mousemove":A.which===0&&(this.pressed=!1),this.pressed||this._emit(XL,A);break;case"mouseup":this.pressed=!1;break;default:}}_emit(A,j){this.callback({type:A,center:{x:j.clientX,y:j.clientY},srcEvent:j,pointerType:"mouse",target:j.target})}};var{KEY_EVENTS:piA}=RB,WL="keydown",YL="keyup",Np=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{let n=r.target||r.srcElement;n.tagName==="INPUT"&&n.type==="text"||n.tagName==="TEXTAREA"||(this.enableDownEvent&&r.type==="keydown"&&this.callback({type:WL,srcEvent:r,key:r.key,target:r.target}),this.enableUpEvent&&r.type==="keyup"&&this.callback({type:YL,srcEvent:r,key:r.key,target:r.target}))},this.enableDownEvent=this.options.enable,this.enableUpEvent=this.options.enable,this.events=(this.options.events||[]).concat(piA),A.tabIndex=this.options.tabIndex||0,A.style.outline="none",this.events.forEach(r=>A.addEventListener(r,this.handleEvent))}destroy(){this.events.forEach(A=>this.element.removeEventListener(A,this.handleEvent))}enableEventType(A,j){A===WL&&(this.enableDownEvent=j),A===YL&&(this.enableUpEvent=j)}};var JL="contextmenu",Kp=class extends vo{constructor(A,j,e){super(A,j,e),this.handleEvent=r=>{this.options.enable&&this.callback({type:JL,center:{x:r.clientX,y:r.clientY},srcEvent:r,pointerType:"mouse",target:r.target})},A.addEventListener("contextmenu",this.handleEvent)}destroy(){this.element.removeEventListener("contextmenu",this.handleEvent)}enableEventType(A,j){A===JL&&(this.options.enable=j)}};var kiA={pointerdown:1,pointermove:2,pointerup:4,mousedown:1,mousemove:2,mouseup:4},giA=1,miA=2,EiA=3,$iA=0,xiA=1,yiA=2,viA=1,_iA=2,qiA=4;function ZL(t){let A=kiA[t.srcEvent.type];if(!A)return null;let{buttons:j,button:e,which:r}=t.srcEvent,n=!1,i=!1,o=!1;return A===4||A===2&&!Number.isFinite(j)?(n=r===giA,i=r===miA,o=r===EiA):A===2?(n=!!(j&viA),i=!!(j&qiA),o=!!(j&_iA)):A===1&&(n=e===$iA,i=e===xiA,o=e===yiA),{leftButton:n,middleButton:i,rightButton:o}}function A2(t,A){let j=t.center;if(!j)return null;let e=A.getBoundingClientRect(),r=e.width/A.offsetWidth||1,n=e.height/A.offsetHeight||1,i={x:(j.x-e.left-A.clientLeft)/r,y:(j.y-e.top-A.clientTop)/n};return{center:j,offsetCenter:i}}var fF={srcElement:"root",priority:0},Xp=class{constructor(A){this.handleEvent=j=>{if(this.isEmpty())return;let e=this._normalizeEvent(j),r=j.srcEvent.target;for(;r&&r!==e.rootElement;){if(this._emit(e,r),e.handled)return;r=r.parentNode}this._emit(e,"root")},this.eventManager=A,this.handlers=[],this.handlersByElement=new Map,this._active=!1}isEmpty(){return!this._active}add(A,j,e,r=!1,n=!1){let{handlers:i,handlersByElement:o}=this,l=fF;typeof e=="string"||e&&e.addEventListener?l={...fF,srcElement:e}:e&&(l={...fF,...e});let c=o.get(l.srcElement);c||(c=[],o.set(l.srcElement,c));let B={type:A,handler:j,srcElement:l.srcElement,priority:l.priority};r&&(B.once=!0),n&&(B.passive=!0),i.push(B),this._active=this._active||!B.passive;let h=c.length-1;for(;h>=0&&!(c[h].priority>=B.priority);)h--;c.splice(h+1,0,B)}remove(A,j){let{handlers:e,handlersByElement:r}=this;for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.type===A&&i.handler===j){e.splice(n,1);let o=r.get(i.srcElement);o.splice(o.indexOf(i),1),o.length===0&&r.delete(i.srcElement)}}this._active=e.some(n=>!n.passive)}_emit(A,j){let e=this.handlersByElement.get(j);if(e){let r=!1,n=()=>{A.handled=!0},i=()=>{A.handled=!0,r=!0},o=[];for(let l=0;l{A.srcEvent.preventDefault()},stopImmediatePropagation:null,stopPropagation:null,handled:!1,rootElement:j}}};var biA={events:null,recognizers:null,recognizerOptions:{},Manager:SL,touchAction:"none",tabIndex:0},LB=class{constructor(A=null,j){this._onBasicInput=r=>{let{srcEvent:n}=r,i=CL[n.type];i&&this.manager.emit(i,r)},this._onOtherEvent=r=>{this.manager.emit(r.type,r)},this.options={...biA,...j},this.events=new Map,this.setElement(A);let{events:e}=this.options;e&&this.on(e)}getElement(){return this.element}setElement(A){if(this.element&&this.destroy(),this.element=A,!A)return;let{options:j}=this,e=j.Manager;this.manager=new e(A,{touchAction:j.touchAction,recognizers:j.recognizers||RL}).on("hammer.input",this._onBasicInput),j.recognizers||Object.keys(uF).forEach(r=>{let n=this.manager.get(r);n&&uF[r].forEach(i=>{n.recognizeWith(i)})});for(let r in j.recognizerOptions){let n=this.manager.get(r);if(n){let i=j.recognizerOptions[r];delete i.enable,n.set(i)}}this.wheelInput=new Hp(A,this._onOtherEvent,{enable:!1}),this.moveInput=new Dp(A,this._onOtherEvent,{enable:!1}),this.keyInput=new Np(A,this._onOtherEvent,{enable:!1,tabIndex:j.tabIndex}),this.contextmenuInput=new Kp(A,this._onOtherEvent,{enable:!1});for(let[r,n]of this.events)n.isEmpty()||(this._toggleRecognizer(n.recognizerName,!0),this.manager.on(r,n.handleEvent))}destroy(){this.element&&(this.wheelInput.destroy(),this.moveInput.destroy(),this.keyInput.destroy(),this.contextmenuInput.destroy(),this.manager.destroy(),this.wheelInput=null,this.moveInput=null,this.keyInput=null,this.contextmenuInput=null,this.manager=null,this.element=null)}on(A,j,e){this._addEventHandler(A,j,e,!1)}once(A,j,e){this._addEventHandler(A,j,e,!0)}watch(A,j,e){this._addEventHandler(A,j,e,!1,!0)}off(A,j){this._removeEventHandler(A,j)}_toggleRecognizer(A,j){let{manager:e}=this;if(!e)return;let r=e.get(A);if(r&&r.options.enable!==j){r.set({enable:j});let n=LL[A];n&&!this.options.recognizers&&n.forEach(i=>{let o=e.get(i);j?(o.requireFailure(A),r.dropRequireFailure(i)):o.dropRequireFailure(A)})}this.wheelInput.enableEventType(A,j),this.moveInput.enableEventType(A,j),this.keyInput.enableEventType(A,j),this.contextmenuInput.enableEventType(A,j)}_addEventHandler(A,j,e,r,n){if(typeof A!="string"){e=j;for(let B in A)this._addEventHandler(B,A[B],e,r,n);return}let{manager:i,events:o}=this,l=BF[A]||A,c=o.get(l);c||(c=new Xp(this),o.set(l,c),c.recognizerName=HL[l]||l,i&&i.on(l,c.handleEvent)),c.add(A,j,e,r,n),c.isEmpty()||this._toggleRecognizer(c.recognizerName,!0)}_removeEventHandler(A,j){if(typeof A!="string"){for(let i in A)this._removeEventHandler(i,A[i]);return}let{events:e}=this,r=BF[A]||A,n=e.get(r);if(n&&(n.remove(A,j),n.isEmpty())){let{recognizerName:i}=n,o=!1;for(let l of e.values())if(l.recognizerName===i&&!l.isEmpty()){o=!0;break}o||this._toggleRecognizer(i,!1)}}};function D7(){}var GiA=({isDragging:t})=>t?"grabbing":"grab",t2={id:"",width:"100%",height:"100%",style:null,viewState:null,initialViewState:null,pickingRadius:0,layerFilter:null,parameters:{},parent:null,device:null,deviceProps:{type:"webgl"},gl:null,glOptions:{},canvas:null,layers:[],effects:[],views:null,controller:null,useDevicePixels:!0,touchAction:"none",eventRecognizerOptions:{},_framebuffer:null,_animate:!1,_pickable:!0,_typedArrayManagerProps:{},_customRender:null,widgets:[],onDeviceInitialized:D7,onWebGLInitialized:D7,onResize:D7,onViewStateChange:D7,onInteractionStateChange:D7,onBeforeRender:D7,onAfterRender:D7,onLoad:D7,onError:t=>NA.error(t.message,t.cause)(),onHover:null,onClick:null,onDragStart:null,onDrag:null,onDragEnd:null,_onMetrics:null,getCursor:GiA,getTooltip:null,debug:!1,drawPickingColors:!1},zp=class{constructor(A){this.width=0,this.height=0,this.userData={},this.device=null,this.canvas=null,this.viewManager=null,this.layerManager=null,this.effectManager=null,this.deckRenderer=null,this.deckPicker=null,this.eventManager=null,this.widgetManager=null,this.tooltip=null,this.animationLoop=null,this.cursorState={isHovering:!1,isDragging:!1},this.stats=new v6({id:"deck.gl"}),this.metrics={fps:0,setPropsTime:0,updateAttributesTime:0,framesRedrawn:0,pickTime:0,pickCount:0,gpuTime:0,gpuTimePerFrame:0,cpuTime:0,cpuTimePerFrame:0,bufferMemory:0,textureMemory:0,renderbufferMemory:0,gpuMemory:0},this._metricsCounter=0,this._needsRedraw="Initial render",this._pickRequest={mode:"hover",x:-1,y:-1,radius:0,event:null},this._lastPointerDownInfo=null,this._onPointerMove=e=>{let{_pickRequest:r}=this;if(e.type==="pointerleave")r.x=-1,r.y=-1,r.radius=0;else{if(e.leftButton||e.rightButton)return;{let n=e.offsetCenter;if(!n)return;r.x=n.x,r.y=n.y,r.radius=this.props.pickingRadius}}this.layerManager&&(this.layerManager.context.mousePosition={x:r.x,y:r.y}),r.event=e},this._onEvent=e=>{let r=Bp[e.type],n=e.offsetCenter;if(!r||!n||!this.layerManager)return;let i=this.layerManager.getLayers(),o=this.deckPicker.getLastPickedObject({x:n.x,y:n.y,layers:i,viewports:this.getViewports(n)},this._lastPointerDownInfo),{layer:l}=o,c=l&&(l[r.handler]||l.props[r.handler]),B=this.props[r.handler],h=!1;c&&(h=c.call(l,o,e)),h||(B?.(o,e),this.widgetManager.onEvent(o,e))},this._onPointerDown=e=>{let r=e.offsetCenter,n=this._pick("pickObject","pickObject Time",{x:r.x,y:r.y,radius:this.props.pickingRadius});this._lastPointerDownInfo=n.result[0]||n.emptyInfo},this.props={...t2,...A},A=this.props,A.viewState&&A.initialViewState&&NA.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(),this.viewState=this.props.initialViewState,A.device?this.device=A.device:A.gl&&(A.gl instanceof WebGLRenderingContext&&NA.error("WebGL1 context not supported.")(),this.device=Pc.attach(A.gl));let j=this.device;j||(ya.registerDevices([Pc]),j=ya.createDevice({...A.deviceProps,canvas:this._createCanvas(A)})),this.animationLoop=this._createAnimationLoop(j,A),this.setProps(A),A._typedArrayManagerProps&&ko.setOptions(A._typedArrayManagerProps),this.animationLoop.start()}finalize(){this.animationLoop?.stop(),this.animationLoop?.destroy(),this.animationLoop=null,this._lastPointerDownInfo=null,this.layerManager?.finalize(),this.layerManager=null,this.viewManager?.finalize(),this.viewManager=null,this.effectManager?.finalize(),this.effectManager=null,this.deckRenderer?.finalize(),this.deckRenderer=null,this.deckPicker?.finalize(),this.deckPicker=null,this.eventManager?.destroy(),this.eventManager=null,this.widgetManager?.finalize(),this.widgetManager=null,!this.props.canvas&&!this.props.device&&!this.props.gl&&this.canvas&&(this.canvas.parentElement?.removeChild(this.canvas),this.canvas=null)}setProps(A){this.stats.get("setProps Time").timeStart(),"onLayerHover"in A&&NA.removed("onLayerHover","onHover")(),"onLayerClick"in A&&NA.removed("onLayerClick","onClick")(),A.initialViewState&&!Hr(this.props.initialViewState,A.initialViewState,3)&&(this.viewState=A.initialViewState),Object.assign(this.props,A),this._setCanvasSize(this.props);let j=Object.create(this.props);Object.assign(j,{views:this._getViews(),width:this.width,height:this.height,viewState:this._getViewState()}),this.animationLoop?.setProps(j),this.layerManager&&(this.viewManager.setProps(j),this.layerManager.activateViewport(this.getViewports()[0]),this.layerManager.setProps(j),this.effectManager.setProps(j),this.deckRenderer.setProps(j),this.deckPicker.setProps(j),this.widgetManager.setProps(j)),this.stats.get("setProps Time").timeEnd()}needsRedraw(A={clearRedrawFlags:!1}){if(!this.layerManager)return!1;if(this.props._animate)return"Deck._animate";let j=this._needsRedraw;A.clearRedrawFlags&&(this._needsRedraw=!1);let e=this.viewManager.needsRedraw(A),r=this.layerManager.needsRedraw(A),n=this.effectManager.needsRedraw(A),i=this.deckRenderer.needsRedraw(A);return j=j||e||r||n||i,j}redraw(A){if(!this.layerManager)return;let j=this.needsRedraw({clearRedrawFlags:!0});j=A||j,j&&(this.stats.get("Redraw Count").incrementCount(),this.props._customRender?this.props._customRender(j):this._drawLayers(j))}get isInitialized(){return this.viewManager!==null}getViews(){return Xj(this.viewManager),this.viewManager.views}getViewports(A){return Xj(this.viewManager),this.viewManager.getViewports(A)}getCanvas(){return this.canvas}pickObject(A){let j=this._pick("pickObject","pickObject Time",A).result;return j.length?j[0]:null}pickMultipleObjects(A){return A.depth=A.depth||10,this._pick("pickObject","pickMultipleObjects Time",A).result}pickObjects(A){return this._pick("pickObjects","pickObjects Time",A)}_addResources(A,j=!1){for(let e in A)this.layerManager.resourceManager.add({resourceId:e,data:A[e],forceUpdate:j})}_removeResources(A){for(let j of A)this.layerManager.resourceManager.remove(j)}_addDefaultEffect(A){this.effectManager.addDefaultEffect(A)}_addDefaultShaderModule(A){this.layerManager.addDefaultShaderModule(A)}_removeDefaultShaderModule(A){this.layerManager?.removeDefaultShaderModule(A)}_pick(A,j,e){Xj(this.deckPicker);let{stats:r}=this;r.get("Pick Count").incrementCount(),r.get(j).timeStart();let n=this.deckPicker[A]({layers:this.layerManager.getLayers(e),views:this.viewManager.getViews(),viewports:this.getViewports(e),onViewportActive:this.layerManager.activateViewport,effects:this.effectManager.getEffects(),...e});return r.get(j).timeEnd(),n}_createCanvas(A){let j=A.canvas;return typeof j=="string"&&(j=document.getElementById(j),Xj(j)),j||(j=document.createElement("canvas"),j.id=A.id||"deckgl-overlay",(A.parent||document.body).appendChild(j)),Object.assign(j.style,A.style),j}_setCanvasSize(A){if(!this.canvas)return;let{width:j,height:e}=A;if(j||j===0){let r=Number.isFinite(j)?`${j}px`:j;this.canvas.style.width=r}if(e||e===0){let r=Number.isFinite(e)?`${e}px`:e;this.canvas.style.position=A.style?.position||"absolute",this.canvas.style.height=r}}_updateCanvasSize(){let{canvas:A}=this;if(!A)return;let j=A.clientWidth??A.width,e=A.clientHeight??A.height;(j!==this.width||e!==this.height)&&(this.width=j,this.height=e,this.viewManager?.setProps({width:j,height:e}),this.layerManager?.activateViewport(this.getViewports()[0]),this.props.onResize({width:j,height:e}))}_createAnimationLoop(A,j){let{gl:e,onError:r,useDevicePixels:n}=j;return new xp({device:A,useDevicePixels:n,autoResizeDrawingBuffer:!e,autoResizeViewport:!1,onInitialize:i=>this._setDevice(i.device),onRender:this._onRenderFrame.bind(this),onError:r})}_getViewState(){return this.props.viewState||this.viewState}_getViews(){let{views:A}=this.props,j=Array.isArray(A)?A:A?[A]:[new zw({id:"default-view"})];return j.length&&this.props.controller&&(j[0].props.controller=this.props.controller),j}_onContextLost(){let{onError:A}=this.props;this.animationLoop&&A&&A(new Error("WebGL context is lost"))}_pickAndCallback(){let{_pickRequest:A}=this;if(A.event){let{result:j,emptyInfo:e}=this._pick("pickObject","pickObject Time",A);this.cursorState.isHovering=j.length>0;let r=e,n=!1;for(let i of j)r=i,n=i.layer?.onHover(i,A.event)||n;n||(this.props.onHover?.(r,A.event),this.widgetManager.onHover(r,A.event)),A.event=null}}_updateCursor(){let A=this.props.parent||this.canvas;A&&(A.style.cursor=this.props.getCursor(this.cursorState))}_setDevice(A){if(this.device=A,!this.animationLoop)return;this.canvas||(this.canvas=this.device.canvasContext?.canvas),this.device.setParametersWebGL({blend:!0,blendFunc:[770,771,1,771],polygonOffsetFill:!0,depthTest:!0,depthFunc:515}),this.props.onDeviceInitialized(this.device),this.device instanceof Pc&&this.props.onWebGLInitialized(this.device.gl);let j=new yc;j.play(),this.animationLoop.attachTimeline(j),this.eventManager=new LB(this.props.parent||this.canvas,{touchAction:this.props.touchAction,recognizerOptions:this.props.eventRecognizerOptions,events:{pointerdown:this._onPointerDown,pointermove:this._onPointerMove,pointerleave:this._onPointerMove}});for(let r in Bp)this.eventManager.on(r,this._onEvent);this.viewManager=new _p({timeline:j,eventManager:this.eventManager,onViewStateChange:this._onViewStateChange.bind(this),onInteractionStateChange:this._onInteractionStateChange.bind(this),views:this._getViews(),viewState:this._getViewState(),width:this.width,height:this.height});let e=this.viewManager.getViewports()[0];this.layerManager=new wB(this.device,{deck:this,stats:this.stats,viewport:e,timeline:j}),this.effectManager=new bp({deck:this,device:this.device}),this.deckRenderer=new MB(this.device),this.deckPicker=new wp(this.device),this.widgetManager=new F$({deck:this,parentElement:this.canvas?.parentElement}),this.widgetManager.addDefault(new Fp),this.setProps(this.props),this._updateCanvasSize(),this.props.onLoad()}_drawLayers(A,j){let{device:e,gl:r}=this.layerManager.context;this.props.onBeforeRender({device:e,gl:r});let n={target:this.props._framebuffer,layers:this.layerManager.getLayers(),viewports:this.viewManager.getViewports(),onViewportActive:this.layerManager.activateViewport,views:this.viewManager.getViews(),pass:"screen",effects:this.effectManager.getEffects(),...j};this.deckRenderer?.renderLayers(n),n.pass==="screen"&&this.widgetManager.onRedraw({viewports:n.viewports,layers:n.layers}),this.props.onAfterRender({device:e,gl:r})}_onRenderFrame(){this._getFrameStats(),this._metricsCounter++%60===0&&(this._getMetrics(),this.stats.reset(),NA.table(4,this.metrics)(),this.props._onMetrics&&this.props._onMetrics(this.metrics)),this._updateCanvasSize(),this._updateCursor(),this.layerManager.updateLayers(),this._pickAndCallback(),this.redraw(),this.viewManager&&this.viewManager.updateViewStates()}_onViewStateChange(A){let j=this.props.onViewStateChange(A)||A.viewState;this.viewState&&(this.viewState={...this.viewState,[A.viewId]:j},this.props.viewState||this.viewManager&&this.viewManager.setProps({viewState:this.viewState}))}_onInteractionStateChange(A){this.cursorState.isDragging=A.isDragging||!1,this.props.onInteractionStateChange(A)}_getFrameStats(){let{stats:A}=this;A.get("frameRate").timeEnd(),A.get("frameRate").timeStart();let j=this.animationLoop.stats;A.get("GPU Time").addTime(j.get("GPU Time").lastTiming),A.get("CPU Time").addTime(j.get("CPU Time").lastTiming)}_getMetrics(){let{metrics:A,stats:j}=this;A.fps=j.get("frameRate").getHz(),A.setPropsTime=j.get("setProps Time").time,A.updateAttributesTime=j.get("Update Attributes").time,A.framesRedrawn=j.get("Redraw Count").count,A.pickTime=j.get("pickObject Time").time+j.get("pickMultipleObjects Time").time+j.get("pickObjects Time").time,A.pickCount=j.get("Pick Count").count,A.gpuTime=j.get("GPU Time").time,A.cpuTime=j.get("CPU Time").time,A.gpuTimePerFrame=j.get("GPU Time").getAverageTime(),A.cpuTimePerFrame=j.get("CPU Time").getAverageTime();let e=ya.stats.get("Memory Usage");A.bufferMemory=e.get("Buffer Memory").count,A.textureMemory=e.get("Texture Memory").count,A.renderbufferMemory=e.get("Renderbuffer Memory").count,A.gpuMemory=e.get("GPU Memory").count}};zp.defaultProps=t2;zp.VERSION=Db;var N7=zp;function j2(t){switch(t){case"float64":return Float64Array;case"uint8":case"unorm8":return Uint8ClampedArray;default:return ep(t)}}var e2=LE;function Up(t,A){return{attribute:t,format:A.size>1?`${A.type}x${A.size}`:A.type,byteOffset:A.offset||0}}function K7(t){return t.stride||t.size*t.bytesPerElement}function r2(t,A){return t.type===A.type&&t.size===A.size&&K7(t)===K7(A)&&(t.offset||0)===(A.offset||0)}function hF(t,A){A.offset&&NA.removed("shaderAttribute.offset","vertexOffset, elementOffset")();let j=K7(t),e=A.vertexOffset!==void 0?A.vertexOffset:t.vertexOffset||0,r=A.elementOffset||0,n=e*j+r*t.bytesPerElement+(t.offset||0);return{...A,offset:n,stride:j}}function wiA(t,A){let j=hF(t,A);return{high:j,low:{...j,offset:j.offset+t.size*4}}}var Vp=class{constructor(A,j,e){this._buffer=null,this.device=A,this.id=j.id||"",this.size=j.size||1;let r=j.logicalType||j.type,n=r==="float64",{defaultValue:i}=j;i=Number.isFinite(i)?[i]:i||new Array(this.size).fill(0);let o;n?o="float32":!r&&j.isIndexed?o="uint32":o=r||"float32";let l=j2(r||o);this.doublePrecision=n,n&&j.fp64===!1&&(l=Float32Array),this.value=null,this.settings={...j,defaultType:l,defaultValue:i,logicalType:r,type:o,normalized:o.includes("norm"),size:this.size,bytesPerElement:l.BYTES_PER_ELEMENT},this.state={...e,externalBuffer:null,bufferAccessor:this.settings,allocatedValue:null,numInstances:0,bounds:null,constant:!1}}get isConstant(){return this.state.constant}get buffer(){return this._buffer}get byteOffset(){let A=this.getAccessor();return A.vertexOffset?A.vertexOffset*K7(A):0}get numInstances(){return this.state.numInstances}set numInstances(A){this.state.numInstances=A}delete(){this._buffer&&(this._buffer.delete(),this._buffer=null),ko.release(this.state.allocatedValue)}getBuffer(){return this.state.constant?null:this.state.externalBuffer||this._buffer}getValue(A=this.id,j=null){let e={};if(this.state.constant){let r=this.value;if(j){let n=hF(this.getAccessor(),j),i=n.offset/r.BYTES_PER_ELEMENT,o=n.size||this.size;e[A]=r.subarray(i,i+o)}else e[A]=r}else e[A]=this.getBuffer();return this.doublePrecision&&(this.value instanceof Float64Array?e[`${A}64Low`]=e[A]:e[`${A}64Low`]=new Float32Array(this.size)),e}_getBufferLayout(A=this.id,j=null){let e=this.getAccessor(),r=[],n={name:this.id,byteStride:K7(e),attributes:r};if(this.doublePrecision){let i=wiA(e,j||{});r.push(Up(A,{...e,...i.high}),Up(`${A}64Low`,{...e,...i.low}))}else if(j){let i=hF(e,j);r.push(Up(A,{...e,...i}))}else r.push(Up(A,e));return n}setAccessor(A){this.state.bufferAccessor=A}getAccessor(){return this.state.bufferAccessor}getBounds(){if(this.state.bounds)return this.state.bounds;let A=null;if(this.state.constant&&this.value){let j=Array.from(this.value);A=[j,j]}else{let{value:j,numInstances:e,size:r}=this,n=e*r;if(j&&n&&j.length>=n){let i=new Array(r).fill(1/0),o=new Array(r).fill(-1/0);for(let l=0;lo[c]&&(o[c]=B)}A=[i,o]}}return this.state.bounds=A,A}setData(A){let{state:j}=this,e;ArrayBuffer.isView(A)?e={value:A}:A instanceof Aj?e={buffer:A}:e=A;let r={...this.settings,...e};if(ArrayBuffer.isView(e.value)){if(!e.type)if(this.doublePrecision&&e.value instanceof Float64Array)r.type="float32";else{let i=e2(e.value);r.type=r.normalized?i.replace("int","norm"):i}r.bytesPerElement=e.value.BYTES_PER_ELEMENT,r.stride=K7(r)}if(j.bounds=null,e.constant){let n=e.value;if(n=this._normalizeValue(n,[],0),this.settings.normalized&&(n=this.normalizeConstant(n)),!(!j.constant||!this._areValuesEqual(n,this.value)))return!1;j.externalBuffer=null,j.constant=!0,this.value=ArrayBuffer.isView(n)?n:new Float32Array(n)}else if(e.buffer){let n=e.buffer;j.externalBuffer=n,j.constant=!1,this.value=e.value||null}else if(e.value){this._checkExternalBuffer(e);let n=e.value;j.externalBuffer=null,j.constant=!1,this.value=n;let{buffer:i}=this,o=K7(r),l=(r.vertexOffset||0)*o;if(this.doublePrecision&&n instanceof Float64Array&&(n=p$(n,r)),this.settings.isIndexed){let B=this.settings.defaultType;n.constructor!==B&&(n=new B(n))}let c=n.byteLength+l+o*2;(!i||i.byteLength(j+128)/255*2-1);case"snorm16":return new Float32Array(A).map(j=>(j+32768)/65535*2-1);case"unorm8":return new Float32Array(A).map(j=>j/255);case"unorm16":return new Float32Array(A).map(j=>j/65535);default:return A}}_normalizeValue(A,j,e){let{defaultValue:r,size:n}=this.settings;if(Number.isFinite(A))return j[e]=A,j;if(!A){let i=n;for(;--i>=0;)j[e+i]=r[i];return j}switch(n){case 4:j[e+3]=Number.isFinite(A[3])?A[3]:r[3];case 3:j[e+2]=Number.isFinite(A[2])?A[2]:r[2];case 2:j[e+1]=Number.isFinite(A[1])?A[1]:r[1];case 1:j[e+0]=Number.isFinite(A[0])?A[0]:r[0];break;default:let i=n;for(;--i>=0;)j[e+i]=Number.isFinite(A[i])?A[i]:r[i]}return j}_areValuesEqual(A,j){if(!A||!j)return!1;let{size:e}=this;for(let r=0;r0&&(i2.length=t.length,e=i2):e=n2,(A>0||Number.isFinite(j))&&(e=(Array.isArray(e)?e:Array.from(e)).slice(A,j),r.index=A-1),{iterable:e,objectInfo:r}}function jx(t){return t&&t[Symbol.asyncIterator]}function ex(t,A){let{size:j,stride:e,offset:r,startIndices:n,nested:i}=A,o=t.BYTES_PER_ELEMENT,l=e?e/o:j,c=r?r/o:0,B=Math.floor((t.length-c)/l);return(h,{index:d,target:k})=>{if(!n){let y=d*l+c;for(let G=0;G=A[1]))return t;let j=[],e=t.length,r=0;for(let n=0;nA[1]?j.push(i):A=[Math.min(i[0],A[0]),Math.max(i[1],A[1])]}return j.splice(r,0,A),j}var PiA={interpolation:{duration:0,easing:t=>t},spring:{stiffness:.05,damping:.5}};function rx(t,A){if(!t)return null;Number.isFinite(t)&&(t={type:"interpolation",duration:t});let j=t.type||"interpolation";return{...PiA[j],...A,...t,type:j}}var X7=class extends Vp{constructor(A,j){super(A,j,{startIndices:null,lastExternalBuffer:null,binaryValue:null,binaryAccessor:null,needsUpdate:!0,needsRedraw:!1,layoutChanged:!1,updateRanges:Qp}),this.constant=!1,this.settings.update=j.update||(j.accessor?this._autoUpdater:void 0),Object.seal(this.settings),Object.seal(this.state),this._validateAttributeUpdaters()}get startIndices(){return this.state.startIndices}set startIndices(A){this.state.startIndices=A}needsUpdate(){return this.state.needsUpdate}needsRedraw({clearChangedFlags:A=!1}={}){let j=this.state.needsRedraw;return this.state.needsRedraw=j&&!A,j}layoutChanged(){return this.state.layoutChanged}setAccessor(A){var j;(j=this.state).layoutChanged||(j.layoutChanged=!r2(A,this.getAccessor())),super.setAccessor(A)}getUpdateTriggers(){let{accessor:A}=this.settings;return[this.id].concat(typeof A!="function"&&A||[])}supportsTransition(){return!!this.settings.transition}getTransitionSetting(A){if(!A||!this.supportsTransition())return null;let{accessor:j}=this.settings,e=this.settings.transition,r=Array.isArray(j)?A[j.find(n=>A[n])]:A[j];return rx(r,e)}setNeedsUpdate(A=this.id,j){if(this.state.needsUpdate=this.state.needsUpdate||A,this.setNeedsRedraw(A),j){let{startRow:e=0,endRow:r=1/0}=j;this.state.updateRanges=s2(this.state.updateRanges,[e,r])}else this.state.updateRanges=Qp}clearNeedsUpdate(){this.state.needsUpdate=!1,this.state.updateRanges=o2}setNeedsRedraw(A=this.id){this.state.needsRedraw=this.state.needsRedraw||A}allocate(A){let{state:j,settings:e}=this;return e.noAlloc?!1:e.update?(super.allocate(A,j.updateRanges!==Qp),!0):!1}updateBuffer({numInstances:A,data:j,props:e,context:r}){if(!this.needsUpdate())return!1;let{state:{updateRanges:n},settings:{update:i,noAlloc:o}}=this,l=!0;if(i){for(let[c,B]of n)i.call(r,this,{data:j,startRow:c,endRow:B,props:e,numInstances:A});if(this.value)if(this.constant||!this.buffer||this.buffer.byteLengthB?c.set(v,E):(A._normalizeValue(v,y.target,0),Kw({target:c,source:y.target,start:E,count:_}));E+=_*B}else A._normalizeValue(v,c,E),E+=B}}_validateAttributeUpdaters(){let{settings:A}=this;if(!(A.noAlloc||typeof A.update=="function"))throw new Error(`Attribute ${this.id} missing update or accessor`)}_checkAttributeArray(){let{value:A}=this,j=Math.min(4,this.size);if(A&&A.length>=j){let e=!0;switch(j){case 4:e=e&&Number.isFinite(A[3]);case 3:e=e&&Number.isFinite(A[2]);case 2:e=e&&Number.isFinite(A[1]);case 1:e=e&&Number.isFinite(A[0]);break;default:e=!1}if(!e)throw new Error(`Illegal attribute generated for ${this.id}`)}}};function dF(t){let{source:A,target:j,start:e=0,size:r,getData:n}=t,i=t.end||j.length,o=A.length,l=i-e;if(o>l){j.set(A.subarray(0,l),e);return}if(j.set(A,e),!n)return;let c=o;for(;ce(B+o,h)),c=Math.min(r.length,n.length);for(let B=1;Bo}){let o=j.doublePrecision&&j.value instanceof Float64Array?2:1,l=j.size*o,c=j.byteOffset,B=j.settings.bytesPerElement<4?c/j.settings.bytesPerElement*4:c,h=j.startIndices,d=n&&h,k=j.isConstant;if(!d&&A&&e>=r)return A;let g=j.value instanceof Float64Array?Float32Array:j.value.constructor,E=k?j.value:new g(j.getBuffer().readSyncWebGL(c,r*g.BYTES_PER_ELEMENT).buffer);if(j.settings.normalized&&!k){let v=i;i=(_,w)=>j.normalizeConstant(v(_,w))}let m=k?(v,_)=>i(E,_):(v,_)=>i(E.subarray(v+c,v+c+l),_),y=A?new Float32Array(A.readSyncWebGL(B,e*4).buffer):new Float32Array(0),G=new Float32Array(r);return a2({source:y,target:G,sourceStartIndices:n,targetStartIndices:h,size:l,getData:m}),(!A||A.byteLength0||r.end()}delete(){super.delete(),this.transform.destroy(),this.texture.destroy(),this.framebuffer.destroy()}},wiA=`#version 300 es +`;function u2(t){return t.doublePrecision&&t.value instanceof Float64Array}function OiA(t,A){let j=A.size,e=nx(j),r=ix(j),n=A.getBufferLayout();return u2(A)?new S7(t,{vs:MiA,bufferLayout:[{name:"aFrom",byteStride:8*j,attributes:[{attribute:"aFrom",format:r,byteOffset:0},{attribute:"aFrom64Low",format:r,byteOffset:4*j}]},{name:"aTo",byteStride:8*j,attributes:[{attribute:"aTo",format:r,byteOffset:0},{attribute:"aTo64Low",format:r,byteOffset:4*j}]}],modules:[WG],defines:{ATTRIBUTE_TYPE:e,ATTRIBUTE_SIZE:j},moduleSettings:{},varyings:["vCurrent","vCurrent64Low"],bufferMode:35980,disableWarnings:!0}):new S7(t,{vs:IiA,bufferLayout:[{name:"aFrom",format:r},{name:"aTo",format:n.attributes[0].format}],defines:{ATTRIBUTE_TYPE:e},varyings:["vCurrent"],disableWarnings:!0})}var Yp=class extends CB{constructor({device:A,attribute:j,timeline:e}){super({device:A,attribute:j,timeline:e}),this.type="spring",this.texture=LiA(A),this.framebuffer=CiA(A,this.texture),this.transform=RiA(A,j)}start(A,j){let e=this.currentLength,r=this.currentStartIndices;super.start(A,j);let{buffers:n,attribute:i}=this;for(let l=0;l<2;l++)n[l]=ax({device:this.device,buffer:n[l],attribute:i,fromLength:e,toLength:this.currentLength,fromStartIndices:r,getData:A.enter});n[2]=sx({device:this.device,source:n[0],target:n[2]}),this.setBuffer(n[1]);let{model:o}=this.transform;o.setVertexCount(Math.floor(this.currentLength/i.size)),i.isConstant?o.setConstantAttributes({aTo:i.value}):o.setAttributes({aTo:i.getBuffer()})}onUpdate(){let{buffers:A,transform:j,framebuffer:e,transition:r}=this,n=this.settings;j.model.setAttributes({aPrev:A[0],aCur:A[1]}),j.transformFeedback.setBuffers({vNext:A[2]}),j.model.setUniforms({stiffness:n.stiffness,damping:n.damping}),j.run({framebuffer:e,discard:!1,parameters:{viewport:[0,0,1,1]},clearColor:[0,0,0,0]}),ox(A),this.setBuffer(A[1]),this.device.readPixelsToArrayWebGL(e)[0]>0||r.end()}delete(){super.delete(),this.transform.destroy(),this.texture.destroy(),this.framebuffer.destroy()}},TiA=`#version 300 es #define SHADER_NAME spring-transition-vertex-shader #define EPSILON 0.00001 @@ -931,7 +931,7 @@ void main(void) { gl_Position = vec4(0, 0, 0, 1); gl_PointSize = 100.0; } -`,FiA=`#version 300 es +`,SiA=`#version 300 es #define SHADER_NAME spring-transition-is-transitioning-fragment-shader in float vIsTransitioningFlag; @@ -943,7 +943,7 @@ void main(void) { discard; } fragColor = vec4(1.0); -}`;function PiA(t,A){let j=Ax(A.size),e=tx(A.size);return new S7(t,{vs:wiA,fs:FiA,bufferLayout:[{name:"aPrev",format:e},{name:"aCur",format:e},{name:"aTo",format:A.getBufferLayout().attributes[0].format}],varyings:["vNext"],defines:{ATTRIBUTE_TYPE:j},parameters:{depthCompare:"always",blendColorOperation:"max",blendColorSrcFactor:"one",blendColorDstFactor:"one",blendAlphaOperation:"max",blendAlphaSrcFactor:"one",blendAlphaDstFactor:"one"}})}function IiA(t){return t.createTexture({data:new Uint8Array(4),format:"rgba8unorm",mipmaps:!1,width:1,height:1})}function MiA(t,A){return t.createFramebuffer({id:"spring-transition-is-transitioning-framebuffer",width:1,height:1,colorAttachments:[A]})}var OiA={interpolation:Vp,spring:Qp},Wp=class{constructor(A,{id:j,timeline:e}){if(!A)throw new Error("AttributeTransitionManager is constructed without device");this.id=j,this.device=A,this.timeline=e,this.transitions={},this.needsRedraw=!1,this.numInstances=1}finalize(){for(let A in this.transitions)this._removeTransition(A)}update({attributes:A,transitions:j,numInstances:e}){this.numInstances=e||1;for(let r in A){let n=A[r],i=n.getTransitionSetting(j);i&&this._updateAttribute(r,n,i)}for(let r in this.transitions){let n=A[r];(!n||!n.getTransitionSetting(j))&&this._removeTransition(r)}}hasAttribute(A){let j=this.transitions[A];return j&&j.inProgress}getAttributes(){let A={};for(let j in this.transitions){let e=this.transitions[j];e.inProgress&&(A[j]=e.attributeInTransition)}return A}run(){if(this.numInstances===0)return!1;for(let j in this.transitions)this.transitions[j].update()&&(this.needsRedraw=!0);let A=this.needsRedraw;return this.needsRedraw=!1,A}_removeTransition(A){this.transitions[A].delete(),delete this.transitions[A]}_updateAttribute(A,j,e){let r=this.transitions[A],n=!r||r.type!==e.type;if(n){r&&this._removeTransition(A);let i=OiA[e.type];i?this.transitions[A]=new i({attribute:j,timeline:this.timeline,device:this.device}):(NA.error(`unsupported transition type '${e.type}'`)(),n=!1)}(n||j.needsRedraw())&&(this.needsRedraw=!0,this.transitions[A].start(e,this.numInstances))}};var o2="attributeManager.invalidate",TiA="attributeManager.updateStart",SiA="attributeManager.updateEnd",RiA="attribute.updateStart",LiA="attribute.allocate",CiA="attribute.updateEnd",HB=class{constructor(A,{id:j="attribute-manager",stats:e,timeline:r}={}){this.mergeBoundsMemoized=ss(gR),this.id=j,this.device=A,this.attributes={},this.updateTriggers={},this.needsRedraw=!0,this.userData={},this.stats=e,this.attributeTransitionManager=new Wp(A,{id:`${j}-transitions`,timeline:r}),Object.seal(this)}finalize(){for(let A in this.attributes)this.attributes[A].delete();this.attributeTransitionManager.finalize()}getNeedsRedraw(A={clearRedrawFlags:!1}){let j=this.needsRedraw;return this.needsRedraw=this.needsRedraw&&!A.clearRedrawFlags,j&&this.id}setNeedsRedraw(){this.needsRedraw=!0}add(A){this._add(A)}addInstanced(A){this._add(A,{stepMode:"instance"})}remove(A){for(let j of A)this.attributes[j]!==void 0&&(this.attributes[j].delete(),delete this.attributes[j])}invalidate(A,j){let e=this._invalidateTrigger(A,j);he(o2,this,A,e)}invalidateAll(A){for(let j in this.attributes)this.attributes[j].setNeedsUpdate(j,A);he(o2,this,"all")}update({data:A,numInstances:j,startIndices:e=null,transitions:r,props:n={},buffers:i={},context:o={}}){let l=!1;he(TiA,this),this.stats&&this.stats.get("Update Attributes").timeStart();for(let c in this.attributes){let B=this.attributes[c],h=B.settings.accessor;B.startIndices=e,B.numInstances=j,n[c]&&NA.removed(`props.${c}`,`data.attributes.${c}`)(),B.setExternalBuffer(i[c])||B.setBinaryValue(typeof h=="string"?i[h]:void 0,A.startIndices)||typeof h=="string"&&!i[h]&&B.setConstantValue(n[h])||B.needsUpdate()&&(l=!0,this._updateAttribute({attribute:B,numInstances:j,data:A,props:n,context:o})),this.needsRedraw=this.needsRedraw||B.needsRedraw()}l&&he(SiA,this,j),this.stats&&this.stats.get("Update Attributes").timeEnd(),this.attributeTransitionManager.update({attributes:this.attributes,numInstances:j,transitions:r})}updateTransition(){let{attributeTransitionManager:A}=this,j=A.run();return this.needsRedraw=this.needsRedraw||j,j}getAttributes(){return{...this.attributes,...this.attributeTransitionManager.getAttributes()}}getBounds(A){let j=A.map(e=>this.attributes[e]?.getBounds());return this.mergeBoundsMemoized(j)}getChangedAttributes(A={clearChangedFlags:!1}){let{attributes:j,attributeTransitionManager:e}=this,r={...e.getAttributes()};for(let n in j){let i=j[n];i.needsRedraw(A)&&!e.hasAttribute(n)&&(r[n]=i)}return r}getBufferLayouts(A){return Object.values(this.getAttributes()).map(j=>j.getBufferLayout(A))}_add(A,j){for(let e in A){let r=A[e],n={...r,id:e,size:r.isIndexed&&1||r.size||1,...j};this.attributes[e]=new X7(this.device,n)}this._mapUpdateTriggersToAttributes()}_mapUpdateTriggersToAttributes(){let A={};for(let j in this.attributes)this.attributes[j].getUpdateTriggers().forEach(r=>{A[r]||(A[r]=[]),A[r].push(j)});this.updateTriggers=A}_invalidateTrigger(A,j){let{attributes:e,updateTriggers:r}=this,n=r[A];return n&&n.forEach(i=>{let o=e[i];o&&o.setNeedsUpdate(o.id,j)}),n}_updateAttribute(A){let{attribute:j,numInstances:e}=A;if(he(RiA,j),j.constant){j.setConstantValue(j.value);return}j.allocate(e)&&he(LiA,j,e),j.updateBuffer(A)&&(this.needsRedraw=!0,he(CiA,j,e))}};var Yp=class extends Eo{get value(){return this._value}_onUpdate(){let{time:A,settings:{fromValue:j,toValue:e,duration:r,easing:n}}=this,i=n(A/r);this._value=uo(j,e,i)}};var s2=1e-5;function a2(t,A,j,e,r){let n=A-t,o=(j-A)*r,l=-n*e;return o+l+n+A}function HiA(t,A,j,e,r){if(Array.isArray(j)){let n=[];for(let i=0;i0}add(A,j,e,r){let{transitions:n}=this;if(n.has(A)){let l=n.get(A),{value:c=l.settings.fromValue}=l;j=c,this.remove(A)}if(r=Z$(r),!r)return;let i=DiA[r.type];if(!i){NA.error(`unsupported transition type '${r.type}'`)();return}let o=new i(this.timeline);o.start({...r,fromValue:j,toValue:e}),n.set(A,o)}remove(A){let{transitions:j}=this;j.has(A)&&(j.get(A).cancel(),j.delete(A))}update(){let A={};for(let[j,e]of this.transitions)e.update(),A[j]=e.value,e.inProgress||this.remove(j);return A}clear(){for(let A of this.transitions.keys())this.remove(A)}};function u2(t){let A=t[Gi];for(let j in A){let e=A[j],{validate:r}=e;if(r&&!r(t[j],e))throw new Error(`Invalid prop ${j}: ${t[j]}`)}}function B2(t,A){let j=f2({newProps:t,oldProps:A,propTypes:t[Gi],ignoreProps:{data:null,updateTriggers:null,extensions:null,transitions:null}}),e=KiA(t,A),r=!1;return e||(r=XiA(t,A)),{dataChanged:e,propsChanged:j,updateTriggersChanged:r,extensionsChanged:ziA(t,A),transitionsChanged:NiA(t,A)}}function NiA(t,A){if(!t.transitions)return!1;let j={},e=t[Gi],r=!1;for(let n in t.transitions){let i=e[n],o=i&&i.type;(o==="number"||o==="color"||o==="array")&&uF(t[n],A[n],i)&&(j[n]=!0,r=!0)}return r?j:!1}function f2({newProps:t,oldProps:A,ignoreProps:j={},propTypes:e={},triggerName:r="props"}){if(A===t)return!1;if(typeof t!="object"||t===null)return`${r} changed shallowly`;if(typeof A!="object"||A===null)return`${r} changed shallowly`;for(let n of Object.keys(t))if(!(n in j)){if(!(n in A))return`${r}.${n} added`;let i=uF(t[n],A[n],e[n]);if(i)return`${r}.${n} ${i}`}for(let n of Object.keys(A))if(!(n in j)){if(!(n in t))return`${r}.${n} dropped`;if(!Object.hasOwnProperty.call(t,n)){let i=uF(t[n],A[n],e[n]);if(i)return`${r}.${n} ${i}`}}return!1}function uF(t,A,j){let e=j&&j.equal;return e&&!e(t,A,j)||!e&&(e=t&&A&&t.equals,e&&!e.call(t,A))?"changed deeply":!e&&A!==t?"changed shallowly":null}function KiA(t,A){if(A===null)return"oldProps is null, initial diff";let j=!1,{dataComparator:e,_dataDiff:r}=t;return e?e(t.data,A.data)||(j="Data comparator detected a change"):t.data!==A.data&&(j="A new data container was supplied"),j&&r&&(j=r(t.data,A.data)||j),j}function XiA(t,A){if(A===null)return{all:!0};if("all"in t.updateTriggers&&c2(t,A,"all"))return{all:!0};let j={},e=!1;for(let r in t.updateTriggers)r!=="all"&&c2(t,A,r)&&(j[r]=!0,e=!0);return e?j:!1}function ziA(t,A){if(A===null)return!0;let j=A.extensions,{extensions:e}=t;if(e===j)return!1;if(!j||!e||e.length!==j.length)return!0;for(let r=0;re.name==="project64"))){let e=j.modules.findIndex(r=>r.name==="project32");e>=0&&j.modules.splice(e,1)}if("inject"in A)if(!t.inject)j.inject=A.inject;else{let e={...t.inject};for(let r in A.inject)e[r]=(e[r]||"")+A.inject[r];j.inject=e}return j}var YiA={minFilter:"linear",mipmapFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"},fF={};function d2(t,A,j,e){if(j instanceof Ne)return j;j.constructor&&j.constructor.name!=="Object"&&(j={data:j});let r=null;j.compressed&&(r={minFilter:"linear",mipmapFilter:j.data.length>1?"nearest":"linear"});let n=A.createTexture({...j,sampler:{...YiA,...r,...e}});return fF[n.id]=t,n}function p2(t,A){!A||!(A instanceof Ne)||fF[A.id]===t&&(A.delete(),delete fF[A.id])}var JiA={boolean:{validate(t,A){return!0},equal(t,A,j){return!!t==!!A}},number:{validate(t,A){return Number.isFinite(t)&&(!("max"in A)||t<=A.max)&&(!("min"in A)||t>=A.min)}},color:{validate(t,A){return A.optional&&!t||hF(t)&&(t.length===3||t.length===4)},equal(t,A,j){return Hr(t,A,1)}},accessor:{validate(t,A){let j=nx(t);return j==="function"||j===nx(A.value)},equal(t,A,j){return typeof A=="function"?!0:Hr(t,A,1)}},array:{validate(t,A){return A.optional&&!t||hF(t)},equal(t,A,j){let{compare:e}=j,r=Number.isInteger(e)?e:e?1:0;return e?Hr(t,A,r):t===A}},object:{equal(t,A,j){if(j.ignore)return!0;let{compare:e}=j,r=Number.isInteger(e)?e:e?1:0;return e?Hr(t,A,r):t===A}},function:{validate(t,A){return A.optional&&!t||typeof t=="function"},equal(t,A,j){return!j.compare&&j.ignore!==!1||t===A}},data:{transform:(t,A,j)=>{if(!t)return t;let{dataTransform:e}=j.props;return e?e(t):typeof t.shape=="string"&&t.shape.endsWith("-table")&&Array.isArray(t.data)?t.data:t}},image:{transform:(t,A,j)=>{let e=j.context;return!e||!e.device?null:d2(j.id,e.device,t,{...A.parameters,...j.props.textureParameters})},release:(t,A,j)=>{p2(j.id,t)}}};function k2(t){let A={},j={},e={};for(let[r,n]of Object.entries(t)){let i=n?.deprecatedFor;if(i)e[r]=Array.isArray(i)?i:[i];else{let o=ZiA(r,n);A[r]=o,j[r]=o.value}}return{propTypes:A,defaultProps:j,deprecatedProps:e}}function ZiA(t,A){switch(nx(A)){case"object":return Ak(t,A);case"array":return Ak(t,{type:"array",value:A,compare:!1});case"boolean":return Ak(t,{type:"boolean",value:A});case"number":return Ak(t,{type:"number",value:A});case"function":return Ak(t,{type:"function",value:A,compare:!0});default:return{name:t,type:"unknown",value:A}}}function Ak(t,A){return"type"in A?{name:t,...JiA[A.type],...A}:"value"in A?{name:t,type:nx(A.value),...A}:{name:t,type:"object",value:A}}function hF(t){return Array.isArray(t)||ArrayBuffer.isView(t)}function nx(t){return hF(t)?"array":t===null?"null":typeof t}function g2(t,A){let j;for(let n=A.length-1;n>=0;n--){let i=A[n];"extensions"in i&&(j=i.extensions)}let e=dF(t.constructor,j),r=Object.create(e);r[bB]=t,r[ls]={},r[mo]={};for(let n=0;n{},this.oldProps=null,this.oldAsyncProps=null}finalize(){for(let A in this.asyncProps){let j=this.asyncProps[A];j&&j.type&&j.type.release&&j.type.release(j.resolvedValue,j.type,this.component)}this.asyncProps={},this.component=null,this.resetOldProps()}getOldProps(){return this.oldAsyncProps||this.oldProps||soA}resetOldProps(){this.oldAsyncProps=null,this.oldProps=this.component?this.component.props:null}hasAsyncProp(A){return A in this.asyncProps}getAsyncProp(A){let j=this.asyncProps[A];return j&&j.resolvedValue}isAsyncPropLoading(A){if(A){let j=this.asyncProps[A];return!!(j&&j.pendingLoadCount>0&&j.pendingLoadCount!==j.resolvedLoadCount)}for(let j in this.asyncProps)if(this.isAsyncPropLoading(j))return!0;return!1}reloadAsyncProp(A,j){this._watchPromise(A,Promise.resolve(j))}setAsyncProps(A){this.component=A[bB]||this.component;let j=A[mo]||{},e=A[ls]||A,r=A[Pa]||{};for(let n in j){let i=j[n];this._createAsyncPropData(n,r[n]),this._updateAsyncProp(n,i),j[n]=this.getAsyncProp(n)}for(let n in e){let i=e[n];this._createAsyncPropData(n,r[n]),this._updateAsyncProp(n,i)}}_fetch(A,j){return null}_onResolve(A,j){}_onError(A,j){}_updateAsyncProp(A,j){if(this._didAsyncInputValueChange(A,j)){if(typeof j=="string"&&(j=this._fetch(A,j)),j instanceof Promise){this._watchPromise(A,j);return}if(Y$(j)){this._resolveAsyncIterable(A,j);return}this._setPropValue(A,j)}}_freezeAsyncOldProps(){if(!this.oldAsyncProps&&this.oldProps){this.oldAsyncProps=Object.create(this.oldProps);for(let A in this.asyncProps)Object.defineProperty(this.oldAsyncProps,A,{enumerable:!0,value:this.oldProps[A]})}}_didAsyncInputValueChange(A,j){let e=this.asyncProps[A];return j===e.resolvedValue||j===e.lastValue?!1:(e.lastValue=j,!0)}_setPropValue(A,j){this._freezeAsyncOldProps();let e=this.asyncProps[A];e&&(j=this._postProcessValue(e,j),e.resolvedValue=j,e.pendingLoadCount++,e.resolvedLoadCount=e.pendingLoadCount)}_setAsyncPropValue(A,j,e){let r=this.asyncProps[A];r&&e>=r.resolvedLoadCount&&j!==void 0&&(this._freezeAsyncOldProps(),r.resolvedValue=j,r.resolvedLoadCount=e,this.onAsyncPropUpdated(A,j))}_watchPromise(A,j){let e=this.asyncProps[A];if(e){e.pendingLoadCount++;let r=e.pendingLoadCount;j.then(n=>{this.component&&(n=this._postProcessValue(e,n),this._setAsyncPropValue(A,n,r),this._onResolve(A,n))}).catch(n=>{this._onError(A,n)})}}async _resolveAsyncIterable(A,j){if(A!=="data"){this._setPropValue(A,j);return}let e=this.asyncProps[A];if(!e)return;e.pendingLoadCount++;let r=e.pendingLoadCount,n=[],i=0;for await(let o of j){if(!this.component)return;let{dataTransform:l}=this.component.props;l?n=l(o,n):n=n.concat(o),Object.defineProperty(n,"__diff",{enumerable:!1,value:[{startRow:i,endRow:n.length}]}),i=n.length,this._setAsyncPropValue(A,n,r)}this._onResolve(A,n)}_postProcessValue(A,j){let e=A.type;return e&&this.component&&(e.release&&e.release(A.resolvedValue,e,this.component),e.transform)?e.transform(j,e,this.component):j}_createAsyncPropData(A,j){if(!this.asyncProps[A]){let r=this.component&&this.component.props[Gi];this.asyncProps[A]={type:r&&r[A],lastValue:null,resolvedValue:j,pendingLoadCount:0,resolvedLoadCount:0}}}};var ek=class extends jk{constructor({attributeManager:A,layer:j}){super(j),this.attributeManager=A,this.needsRedraw=!0,this.needsUpdate=!0,this.subLayers=null,this.usesPickingColorCache=!1}get layer(){return this.component}_fetch(A,j){let e=this.layer,r=e?.props.fetch;return r?r(j,{propName:A,layer:e}):super._fetch(A,j)}_onResolve(A,j){let e=this.layer;if(e){let r=e.props.onDataLoad;A==="data"&&r&&r(j,{propName:A,layer:e})}}_onError(A,j){let e=this.layer;e&&e.raiseError(j,`loading ${A} of ${this.layer}`)}};var aoA="layer.changeFlag",loA="layer.initialize",coA="layer.update",uoA="layer.finalize",BoA="layer.matched",E2=2**24-1,foA=Object.freeze([]),hoA=ss(({oldViewport:t,viewport:A})=>t.equals(A)),ds=new Uint8ClampedArray(0),doA={data:{type:"data",value:foA,async:!0},dataComparator:{type:"function",value:null,optional:!0},_dataDiff:{type:"function",value:t=>t&&t.__diff,optional:!0},dataTransform:{type:"function",value:null,optional:!0},onDataLoad:{type:"function",value:null,optional:!0},onError:{type:"function",value:null,optional:!0},fetch:{type:"function",value:(t,{propName:A,layer:j,loaders:e,loadOptions:r,signal:n})=>{let{resourceManager:i}=j.context;r=r||j.getLoadOptions(),e=e||j.props.loaders,n&&(r={...r,fetch:{...r?.fetch,signal:n}});let o=i.contains(t);return!o&&!r&&(i.add({resourceId:t,data:As(t,e),persistent:!1}),o=!0),o?i.subscribe({resourceId:t,onChange:l=>j.internalState?.reloadAsyncProp(A,l),consumerId:j.id,requestId:A}):As(t,e,r)}},updateTriggers:{},visible:!0,pickable:!1,opacity:{type:"number",min:0,max:1,value:1},operation:"draw",onHover:{type:"function",value:null,optional:!0},onClick:{type:"function",value:null,optional:!0},onDragStart:{type:"function",value:null,optional:!0},onDrag:{type:"function",value:null,optional:!0},onDragEnd:{type:"function",value:null,optional:!0},coordinateSystem:qt.DEFAULT,coordinateOrigin:{type:"array",value:[0,0,0],compare:!0},modelMatrix:{type:"array",value:null,compare:!0,optional:!0},wrapLongitude:!1,positionFormat:"XYZ",colorFormat:"RGBA",parameters:{type:"object",value:{},optional:!0,compare:2},loadOptions:{type:"object",value:null,optional:!0,ignore:!0},transitions:null,extensions:[],loaders:{type:"array",value:[],optional:!0,ignore:!0},getPolygonOffset:{type:"function",value:({layerIndex:t})=>[0,-t*100]},highlightedObjectIndex:null,autoHighlight:!1,highlightColor:{type:"accessor",value:[0,0,128,128]}},rk=class extends ix{constructor(){super(...arguments),this.internalState=null,this.lifecycle=R7.NO_STATE,this.parent=null}static get componentName(){return Object.prototype.hasOwnProperty.call(this,"layerName")?this.layerName:""}get root(){let A=this;for(;A.parent;)A=A.parent;return A}toString(){return`${this.constructor.layerName||this.constructor.name}({id: '${this.props.id}'})`}project(A){Xj(this.internalState);let j=this.internalState.viewport||this.context.viewport,e=Sw(A,{viewport:j,modelMatrix:this.props.modelMatrix,coordinateOrigin:this.props.coordinateOrigin,coordinateSystem:this.props.coordinateSystem}),[r,n,i]=yB(e,j.pixelProjectionMatrix);return A.length===2?[r,n]:[r,n,i]}unproject(A){return Xj(this.internalState),(this.internalState.viewport||this.context.viewport).unproject(A)}projectPosition(A,j){Xj(this.internalState);let e=this.internalState.viewport||this.context.viewport;return $R(A,{viewport:e,modelMatrix:this.props.modelMatrix,coordinateOrigin:this.props.coordinateOrigin,coordinateSystem:this.props.coordinateSystem,...j})}get isComposite(){return!1}setState(A){this.setChangeFlags({stateChanged:!0}),Object.assign(this.state,A),this.setNeedsRedraw()}setNeedsRedraw(){this.internalState&&(this.internalState.needsRedraw=!0)}setNeedsUpdate(){this.internalState&&(this.context.layerManager.setNeedsUpdate(String(this)),this.internalState.needsUpdate=!0)}get isLoaded(){return this.internalState?!this.internalState.isAsyncPropLoading():!1}get wrapLongitude(){return this.props.wrapLongitude}isPickable(){return this.props.pickable&&this.props.visible}getModels(){let A=this.state;return A&&(A.models||A.model&&[A.model])||[]}setModuleParameters(A){for(let j of this.getModels())j.updateModuleSettings(A)}setShaderModuleProps(...A){for(let j of this.getModels())j.shaderInputs.setProps(...A)}getAttributeManager(){return this.internalState&&this.internalState.attributeManager}getCurrentLayer(){return this.internalState&&this.internalState.layer}getLoadOptions(){return this.props.loadOptions}use64bitPositions(){let{coordinateSystem:A}=this.props;return A===qt.DEFAULT||A===qt.LNGLAT||A===qt.CARTESIAN}onHover(A,j){return this.props.onHover&&this.props.onHover(A,j)||!1}onClick(A,j){return this.props.onClick&&this.props.onClick(A,j)||!1}nullPickingColor(){return[0,0,0]}encodePickingColor(A,j=[]){return j[0]=A+1&255,j[1]=A+1>>8&255,j[2]=A+1>>8>>8&255,j}decodePickingColor(A){Xj(A instanceof Uint8Array);let[j,e,r]=A;return j+e*256+r*65536-1}getNumInstances(){return Number.isFinite(this.props.numInstances)?this.props.numInstances:this.state&&this.state.numInstances!==void 0?this.state.numInstances:h2(this.props.data)}getStartIndices(){return this.props.startIndices?this.props.startIndices:this.state&&this.state.startIndices?this.state.startIndices:null}getBounds(){return this.getAttributeManager()?.getBounds(["positions","instancePositions"])}getShaders(A){A=BF(A,{disableWarnings:!0,modules:this.context.defaultShaderModules});for(let j of this.props.extensions)A=BF(A,j.getShaders.call(this,j));return A}shouldUpdateState(A){return A.changeFlags.propsOrDataChanged}updateState(A){let j=this.getAttributeManager(),{dataChanged:e}=A.changeFlags;if(e&&j)if(Array.isArray(e))for(let r of e)j.invalidateAll(r);else j.invalidateAll();if(j){let{props:r}=A,n=this.internalState.hasPickingBuffer,i=Number.isInteger(r.highlightedObjectIndex)||r.pickable||r.extensions.some(o=>o.getNeedsPickingBuffer.call(this,o));if(n!==i){this.internalState.hasPickingBuffer=i;let{pickingColors:o,instancePickingColors:l}=j.attributes,c=o||l;c&&(i&&c.constant&&(c.constant=!1,j.invalidate(c.id)),!c.value&&!i&&(c.constant=!0,c.value=[0,0,0]))}}}finalizeState(A){for(let e of this.getModels())e.destroy();let j=this.getAttributeManager();j&&j.finalize(),this.context&&this.context.resourceManager.unsubscribe({consumerId:this.id}),this.internalState&&(this.internalState.uniformTransitions.clear(),this.internalState.finalize())}draw(A){for(let j of this.getModels())j.draw(A)}getPickingInfo({info:A,mode:j,sourceLayer:e}){let{index:r}=A;return r>=0&&Array.isArray(this.props.data)&&(A.object=this.props.data[r]),A}raiseError(A,j){j&&(A=new Error(`${j}: ${A.message}`,{cause:A})),this.props.onError?.(A)||this.context?.onError?.(A,this)}getNeedsRedraw(A={clearRedrawFlags:!1}){return this._getNeedsRedraw(A)}needsUpdate(){return this.internalState?this.internalState.needsUpdate||this.hasUniformTransition()||this.shouldUpdateState(this._getUpdateParams()):!1}hasUniformTransition(){return this.internalState?.uniformTransitions.active||!1}activateViewport(A){if(!this.internalState)return;let j=this.internalState.viewport;this.internalState.viewport=A,(!j||!hoA({oldViewport:j,viewport:A}))&&(this.setChangeFlags({viewportChanged:!0}),this.isComposite?this.needsUpdate()&&this.setNeedsUpdate():this._update())}invalidateAttribute(A="all"){let j=this.getAttributeManager();j&&(A==="all"?j.invalidateAll():j.invalidate(A))}updateAttributes(A){let j=!1;for(let e in A)A[e].layoutChanged()&&(j=!0);for(let e of this.getModels())this._setModelAttributes(e,A,j)}_updateAttributes(){let A=this.getAttributeManager();if(!A)return;let j=this.props,e=this.getNumInstances(),r=this.getStartIndices();A.update({data:j.data,numInstances:e,startIndices:r,props:j,transitions:j.transitions,buffers:j.data.attributes,context:this});let n=A.getChangedAttributes({clearChangedFlags:!0});this.updateAttributes(n)}_updateAttributeTransition(){let A=this.getAttributeManager();A&&A.updateTransition()}_updateUniformTransition(){let{uniformTransitions:A}=this.internalState;if(A.active){let j=A.update(),e=Object.create(this.props);for(let r in j)Object.defineProperty(e,r,{value:j[r]});return e}return this.props}calculateInstancePickingColors(A,{numInstances:j}){if(A.constant)return;let e=Math.floor(ds.length/4);if(this.internalState.usesPickingColorCache=!0,eE2&&NA.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(),ds=ko.allocate(ds,j,{size:4,copy:!0,maxCount:Math.max(j,E2)});let r=Math.floor(ds.length/4),n=[];for(let i=e;i(NA.deprecated("layer.state.attributeManager","layer.getAttributeManager()")(),A)}),this.internalState.uniformTransitions=new Zp(this.context.timeline),this.internalState.onAsyncPropUpdated=this._onAsyncPropUpdated.bind(this),this.internalState.setAsyncProps(this.props),this.initializeState(this.context);for(let j of this.props.extensions)j.initializeState.call(this,this.context,j);this.setChangeFlags({dataChanged:"init",propsChanged:"init",viewportChanged:!0,extensionsChanged:!0}),this._update()}_transferState(A){he(BoA,this,this===A);let{state:j,internalState:e}=A;this!==A&&(this.internalState=e,this.state=j,this.internalState.setAsyncProps(this.props),this._diffProps(this.props,this.internalState.getOldProps()))}_update(){let A=this.needsUpdate();if(he(coA,this,A),!A)return;let j=this.props,e=this.context,r=this.internalState,n=e.viewport,i=this._updateUniformTransition();r.propsInTransition=i,e.viewport=r.viewport||n,this.props=i;try{let o=this._getUpdateParams(),l=this.getModels();if(e.device)this.updateState(o);else try{this.updateState(o)}catch{}for(let B of this.props.extensions)B.updateState.call(this,o,B);let c=this.getModels()[0]!==l[0];this._postUpdate(o,c)}finally{e.viewport=n,this.props=j,this._clearChangeFlags(),r.needsUpdate=!1,r.resetOldProps()}}_finalize(){he(uoA,this),this.finalizeState(this.context);for(let A of this.props.extensions)A.finalizeState.call(this,this.context,A)}_drawLayer({renderPass:A,moduleParameters:j=null,uniforms:e={},parameters:r={}}){this._updateAttributeTransition();let n=this.props,i=this.context;this.props=this.internalState.propsInTransition||n;let o=this.props.opacity;e.opacity=Math.pow(o,1/2.2);try{if(j){let{isActive:B,isAttribute:h}=j.picking;this.setModuleParameters(j),this.setShaderModuleProps({picking:{isActive:B,isAttribute:h}})}let{getPolygonOffset:l}=this.props,c=l&&l(e)||[0,0];i.device.setParametersWebGL({polygonOffset:c});for(let B of this.getModels())B.setParameters(r);i.device.withParametersWebGL(r,()=>{let B={renderPass:A,moduleParameters:j,uniforms:e,parameters:r,context:i};for(let h of this.props.extensions)h.draw.call(this,B,h);this.draw(B)})}finally{this.props=n}}getChangeFlags(){return this.internalState?.changeFlags}setChangeFlags(A){if(!this.internalState)return;let{changeFlags:j}=this.internalState;for(let r in A)if(A[r]){let n=!1;switch(r){case"dataChanged":let i=A[r],o=j[r];i&&Array.isArray(o)&&(j.dataChanged=Array.isArray(i)?o.concat(i):i,n=!0);default:j[r]||(j[r]=A[r],n=!0)}n&&he(aoA,this,r,A)}let e=!!(j.dataChanged||j.updateTriggersChanged||j.propsChanged||j.extensionsChanged);j.propsOrDataChanged=e,j.somethingChanged=e||j.viewportChanged||j.stateChanged}_clearChangeFlags(){this.internalState.changeFlags={dataChanged:!1,propsChanged:!1,updateTriggersChanged:!1,viewportChanged:!1,stateChanged:!1,extensionsChanged:!1,propsOrDataChanged:!1,somethingChanged:!1}}_diffProps(A,j){let e=B2(A,j);if(e.updateTriggersChanged)for(let r in e.updateTriggersChanged)e.updateTriggersChanged[r]&&this.invalidateAttribute(r);if(e.transitionsChanged)for(let r in e.transitionsChanged)this.internalState.uniformTransitions.add(r,j[r],A[r],A.transitions?.[r]);return this.setChangeFlags(e)}validateProps(){u2(this.props)}updateAutoHighlight(A){this.props.autoHighlight&&!Number.isInteger(this.props.highlightedObjectIndex)&&this._updateAutoHighlight(A)}_updateAutoHighlight(A){let j={highlightedObjectColor:A.picked?A.color:null},{highlightColor:e}=this.props;A.picked&&typeof e=="function"&&(j.highlightColor=e(A)),this.setShaderModuleProps({picking:j}),this.setNeedsRedraw()}_getAttributeManager(){let A=this.context;return new HB(A.device,{id:this.props.id,stats:A.stats,timeline:A.timeline})}_postUpdate(A,j){let{props:e,oldProps:r}=A;this.setNeedsRedraw(),this._updateAttributes();let n=this.state.model;n?.isInstanced&&n.setInstanceCount(this.getNumInstances());let{autoHighlight:i,highlightedObjectIndex:o,highlightColor:l}=e;if(j||r.autoHighlight!==i||r.highlightedObjectIndex!==o||r.highlightColor!==l){let c={};Array.isArray(l)&&(c.highlightColor=l),(j||r.autoHighlight!==i||o!==r.highlightedObjectIndex)&&(c.highlightedObjectColor=Number.isFinite(o)&&o>=0?this.encodePickingColor(o):null),this.setShaderModuleProps({picking:c})}}_getUpdateParams(){return{props:this.props,oldProps:this.internalState.getOldProps(),context:this.context,changeFlags:this.internalState.changeFlags}}_getNeedsRedraw(A){if(!this.internalState)return!1;let j=!1;j=j||this.internalState.needsRedraw&&this.id;let e=this.getAttributeManager(),r=e?e.getNeedsRedraw(A):!1;if(j=j||r,j)for(let n of this.props.extensions)n.onNeedsRedraw.call(this,n);return this.internalState.needsRedraw=this.internalState.needsRedraw&&!A.clearRedrawFlags,j}_onAsyncPropUpdated(){this._diffProps(this.props,this.internalState.getOldProps()),this.setNeedsUpdate()}};rk.defaultProps=doA;rk.layerName="Layer";var gr=rk;var poA="compositeLayer.renderLayers",ox=class extends gr{get isComposite(){return!0}get isLoaded(){return super.isLoaded&&this.getSubLayers().every(A=>A.isLoaded)}getSubLayers(){return this.internalState&&this.internalState.subLayers||[]}initializeState(A){}setState(A){super.setState(A),this.setNeedsUpdate()}getPickingInfo({info:A}){let{object:j}=A;return j&&j.__source&&j.__source.parent&&j.__source.parent.id===this.id&&(A.object=j.__source.object,A.index=j.__source.index),A}filterSubLayer(A){return!0}shouldRenderSubLayer(A,j){return j&&j.length}getSubLayerClass(A,j){let{_subLayerProps:e}=this.props;return e&&e[A]&&e[A].type||j}getSubLayerRow(A,j,e){return A.__source={parent:this,object:j,index:e},A}getSubLayerAccessor(A){if(typeof A=="function"){let j={index:-1,data:this.props.data,target:[]};return(e,r)=>e&&e.__source?(j.index=e.__source.index,A(e.__source.object,j)):A(e,r)}return A}getSubLayerProps(A={}){let{opacity:j,pickable:e,visible:r,parameters:n,getPolygonOffset:i,highlightedObjectIndex:o,autoHighlight:l,highlightColor:c,coordinateSystem:B,coordinateOrigin:h,wrapLongitude:d,positionFormat:k,modelMatrix:g,extensions:E,fetch:m,operation:y,_subLayerProps:b}=this.props,v={id:"",updateTriggers:{},opacity:j,pickable:e,visible:r,parameters:n,getPolygonOffset:i,highlightedObjectIndex:o,autoHighlight:l,highlightColor:c,coordinateSystem:B,coordinateOrigin:h,wrapLongitude:d,positionFormat:k,modelMatrix:g,extensions:E,fetch:m,operation:y},_=b&&A.id&&b[A.id],w=_&&_.updateTriggers,x=A.id||"sublayer";if(_){let S=this.props[Gi],F=A.type?A.type._propTypes:{};for(let D in _){let L=F[D]||S[D];L&&L.type==="accessor"&&(_[D]=this.getSubLayerAccessor(_[D]))}}Object.assign(v,A,_),v.id=`${this.props.id}-${x}`,v.updateTriggers={all:this.props.updateTriggers?.all,...A.updateTriggers,...w};for(let S of E){let F=S.getSubLayerProps.call(this,S);F&&Object.assign(v,F,{updateTriggers:Object.assign(v.updateTriggers,F.updateTriggers)})}return v}_updateAutoHighlight(A){for(let j of this.getSubLayers())j.updateAutoHighlight(A)}_getAttributeManager(){return null}_postUpdate(A,j){let e=this.internalState.subLayers,r=!e||this.needsUpdate();if(r){let n=this.renderLayers();e=Ia(n,Boolean),this.internalState.subLayers=e}he(poA,this,r,e);for(let n of e)n.parent=this}};ox.layerName="CompositeLayer";var G6=ox;var sx=Math.PI/180,$2=180/Math.PI,ax=6370972,DB=256;function koA(){let t=DB/ax,A=Math.PI/180*DB;return{unitsPerMeter:[t,t,t],unitsPerMeter2:[0,0,0],metersPerUnit:[1/t,1/t,1/t],unitsPerDegree:[A,A,t],unitsPerDegree2:[0,0,0],degreesPerUnit:[1/A,1/A,1/t]}}var Mc=class extends go{constructor(A={}){let{latitude:j=0,longitude:e=0,zoom:r=0,nearZMultiplier:n=.1,farZMultiplier:i=2,resolution:o=10}=A,{height:l,altitude:c=1.5}=A;l=l||1,c=Math.max(.75,c);let B=new lj().lookAt({eye:[0,-c,0],up:[0,0,1]}),h=Math.pow(2,r);B.rotateX(j*sx),B.rotateZ(-e*sx),B.scale(h/l);let d=Math.atan(.5/c),k=DB*2*h/l;super({...A,height:l,viewMatrix:B,longitude:e,latitude:j,zoom:r,distanceScales:koA(),fovyRadians:d*2,focalDistance:c,near:n,far:Math.min(2,1/k+1)*c*i}),this.latitude=j,this.longitude=e,this.resolution=o}get projectionMode(){return sn.GLOBE}getDistanceScales(){return this.distanceScales}getBounds(A={}){let j={targetZ:A.z||0},e=this.unproject([0,this.height/2],j),r=this.unproject([this.width/2,0],j),n=this.unproject([this.width,this.height/2],j),i=this.unproject([this.width/2,this.height],j);return n[0]this.longitude&&(e[0]-=360),[Math.min(e[0],n[0],r[0],i[0]),Math.min(e[1],n[1],r[1],i[1]),Math.max(e[0],n[0],r[0],i[0]),Math.max(e[1],n[1],r[1],i[1])]}unproject(A,{topLeft:j=!0,targetZ:e}={}){let[r,n,i]=A,o=j?n:this.height-n,{pixelUnprojectionMatrix:l}=this,c;if(Number.isFinite(i))c=kF(l,[r,o,i,1]);else{let k=kF(l,[r,o,-1,1]),g=kF(l,[r,o,1,1]),E=((e||0)/ax+1)*DB,m=fo.sqrLen(fo.sub([],k,g)),y=fo.sqrLen(k),b=fo.sqrLen(g),_=4*((4*y*b-(m-y-b)**2)/16)/m,w=Math.sqrt(y-_),x=Math.sqrt(Math.max(0,E*E-_)),S=(w-x)/Math.sqrt(m);c=fo.lerp([],k,g,S)}let[B,h,d]=this.unprojectPosition(c);return Number.isFinite(i)?[B,h,d]:Number.isFinite(e)?[B,h,e]:[B,h]}projectPosition(A){let[j,e,r=0]=A,n=j*sx,i=e*sx,o=Math.cos(i),l=(r/ax+1)*DB;return[Math.sin(n)*o*l,-Math.cos(n)*o*l,Math.sin(i)*l]}unprojectPosition(A){let[j,e,r]=A,n=fo.len(A),i=Math.asin(r/n),l=Math.atan2(j,-e)*$2,c=i*$2,B=(n/DB-1)*ax;return[l,c,B]}projectFlat(A){return A}unprojectFlat(A){return A}panByPosition(A,j){let e=this.unproject(j);return{longitude:A[0]-e[0]+this.longitude,latitude:A[1]-e[1]+this.latitude}}};function kF(t,A){let j=os.transformMat4([],A,t);return os.scale(j,j,1/j[3]),j}var gF=Math.PI/180;function goA({height:t,focalDistance:A,orbitAxis:j,rotationX:e,rotationOrbit:r,zoom:n}){let i=j==="Z"?[0,0,1]:[0,1,0],o=j==="Z"?[0,-A,0]:[0,0,A],l=new lj().lookAt({eye:o,up:i});l.rotateX(e*gF),j==="Z"?l.rotateZ(r*gF):l.rotateY(r*gF);let c=Math.pow(2,n)/t;return l.scale(c),l}var NB=class extends go{constructor(A){let{height:j,projectionMatrix:e,fovy:r=50,orbitAxis:n="Z",target:i=[0,0,0],rotationX:o=0,rotationOrbit:l=0,zoom:c=0}=A,B=e?e[5]/2:Ec(r);super({...A,longitude:void 0,viewMatrix:goA({height:j||1,focalDistance:B,orbitAxis:n,rotationX:o,rotationOrbit:l,zoom:c}),fovy:r,focalDistance:B,position:i,zoom:c}),this.projectedCenter=this.project(this.center)}unproject(A,{topLeft:j=!0}={}){let[e,r,n=this.projectedCenter[2]]=A,i=j?r:this.height-r,[o,l,c]=qi([e,i,n],this.pixelUnprojectionMatrix);return[o,l,c]}panByPosition(A,j){let e=this.project(A),r=[this.width/2+e[0]-j[0],this.height/2+e[1]-j[1],this.projectedCenter[2]];return{target:this.unproject(r)}}};var moA=new lj().lookAt({eye:[0,0,1]});function EoA({width:t,height:A,near:j,far:e,padding:r}){let n=-t/2,i=t/2,o=-A/2,l=A/2;if(r){let{left:c=0,right:B=0,top:h=0,bottom:d=0}=r,k=Kj((c+t-B)/2,0,t)-t/2,g=Kj((h+A-d)/2,0,A)-A/2;n-=k,i-=k,o+=g,l+=g}return new lj().ortho({left:n,right:i,bottom:o,top:l,near:j,far:e})}var KB=class extends go{constructor(A){let{width:j,height:e,near:r=.1,far:n=1e3,zoom:i=0,target:o=[0,0,0],padding:l=null,flipY:c=!0}=A,B=Array.isArray(i)?i[0]:i,h=Array.isArray(i)?i[1]:i,d=Math.min(B,h),k=Math.pow(2,d),g;if(B!==h){let E=Math.pow(2,B),m=Math.pow(2,h);g={unitsPerMeter:[E/k,m/k,1],metersPerUnit:[k/E,k/m,1]}}super({...A,longitude:void 0,position:o,viewMatrix:moA.clone().scale([k,k*(c?-1:1),k]),projectionMatrix:EoA({width:j||1,height:e||1,padding:l,near:r,far:n}),zoom:d,distanceScales:g})}projectFlat([A,j]){let{unitsPerMeter:e}=this.distanceScales;return[A*e[0],j*e[1]]}unprojectFlat([A,j]){let{metersPerUnit:e}=this.distanceScales;return[A*e[0],j*e[1]]}panByPosition(A,j){let e=qi(j,this.pixelUnprojectionMatrix),r=this.projectFlat(A),n=is.add([],r,is.negate([],e)),i=is.add([],this.center,n);return{target:this.unprojectFlat(i)}}};var nk=class extends _c{constructor(A){let{width:j,height:e,rotationX:r=0,rotationOrbit:n=0,target:i=[0,0,0],zoom:o=0,minRotationX:l=-90,maxRotationX:c=90,minZoom:B=-1/0,maxZoom:h=1/0,startPanPosition:d,startRotatePos:k,startRotationX:g,startRotationOrbit:E,startZoomPosition:m,startZoom:y}=A;super({width:j,height:e,rotationX:r,rotationOrbit:n,target:i,zoom:o,minRotationX:l,maxRotationX:c,minZoom:B,maxZoom:h},{startPanPosition:d,startRotatePos:k,startRotationX:g,startRotationOrbit:E,startZoomPosition:m,startZoom:y}),this.makeViewport=A.makeViewport}panStart({pos:A}){return this._getUpdatedState({startPanPosition:this._unproject(A)})}pan({pos:A,startPosition:j}){let e=this.getState().startPanPosition||j;if(!e)return this;let n=this.makeViewport(this.getViewportProps()).panByPosition(e,A);return this._getUpdatedState(n)}panEnd(){return this._getUpdatedState({startPanPosition:null})}rotateStart({pos:A}){return this._getUpdatedState({startRotatePos:A,startRotationX:this.getViewportProps().rotationX,startRotationOrbit:this.getViewportProps().rotationOrbit})}rotate({pos:A,deltaAngleX:j=0,deltaAngleY:e=0}){let{startRotatePos:r,startRotationX:n,startRotationOrbit:i}=this.getState(),{width:o,height:l}=this.getViewportProps();if(!r||n===void 0||i===void 0)return this;let c;if(A){let B=(A[0]-r[0])/o,h=(A[1]-r[1])/l;(n<-90||n>90)&&(B*=-1),c={rotationX:n+h*180,rotationOrbit:i+B*180}}else c={rotationX:n+e,rotationOrbit:i+j};return this._getUpdatedState(c)}rotateEnd(){return this._getUpdatedState({startRotationX:null,startRotationOrbit:null})}shortestPathFrom(A){let j=A.getViewportProps(),e={...this.getViewportProps()},{rotationOrbit:r}=e;return Math.abs(r-j.rotationOrbit)>180&&(e.rotationOrbit=r<0?r+360:r-360),e}zoomStart({pos:A}){return this._getUpdatedState({startZoomPosition:this._unproject(A),startZoom:this.getViewportProps().zoom})}zoom({pos:A,startPos:j,scale:e}){let{startZoom:r,startZoomPosition:n}=this.getState();if(n||(r=this.getViewportProps().zoom,n=this._unproject(j)||this._unproject(A)),!n)return this;let i=this._calculateNewZoom({scale:e,startZoom:r}),o=this.makeViewport({...this.getViewportProps(),zoom:i});return this._getUpdatedState({zoom:i,...o.panByPosition(n,A)})}zoomEnd(){return this._getUpdatedState({startZoomPosition:null,startZoom:null})}zoomIn(A=2){return this._getUpdatedState({zoom:this._calculateNewZoom({scale:A})})}zoomOut(A=2){return this._getUpdatedState({zoom:this._calculateNewZoom({scale:1/A})})}moveLeft(A=50){return this._panFromCenter([-A,0])}moveRight(A=50){return this._panFromCenter([A,0])}moveUp(A=50){return this._panFromCenter([0,-A])}moveDown(A=50){return this._panFromCenter([0,A])}rotateLeft(A=15){return this._getUpdatedState({rotationOrbit:this.getViewportProps().rotationOrbit-A})}rotateRight(A=15){return this._getUpdatedState({rotationOrbit:this.getViewportProps().rotationOrbit+A})}rotateUp(A=10){return this._getUpdatedState({rotationX:this.getViewportProps().rotationX-A})}rotateDown(A=10){return this._getUpdatedState({rotationX:this.getViewportProps().rotationX+A})}_unproject(A){let j=this.makeViewport(this.getViewportProps());return A&&j.unproject(A)}_calculateNewZoom({scale:A,startZoom:j}){let{maxZoom:e,minZoom:r}=this.getViewportProps();j===void 0&&(j=this.getViewportProps().zoom);let n=j+Math.log2(A);return Kj(n,r,e)}_panFromCenter(A){let{width:j,height:e,target:r}=this.getViewportProps();return this.pan({startPosition:r,pos:[j/2+A[0],e/2+A[1]]})}_getUpdatedState(A){return new this.constructor({makeViewport:this.makeViewport,...this.getViewportProps(),...this.getState(),...A})}applyConstraints(A){let{maxZoom:j,minZoom:e,zoom:r,maxRotationX:n,minRotationX:i,rotationOrbit:o}=A;return A.zoom=Array.isArray(r)?[Kj(r[0],e,j),Kj(r[1],e,j)]:Kj(r,e,j),A.rotationX=Kj(A.rotationX,i,n),(o<-180||o>180)&&(A.rotationOrbit=hR(o+180,360)-180),A}},Sa=class extends us{constructor(){super(...arguments),this.ControllerState=nk,this.transition={transitionDuration:300,transitionInterpolator:new bi({transitionProps:{compare:["target","zoom","rotationX","rotationOrbit"],required:["target","zoom"]}})}}};var lx=class extends cs{constructor(A={}){super(A),this.props.orbitAxis=A.orbitAxis||"Z"}get ViewportType(){return NB}get ControllerType(){return Sa}};lx.displayName="OrbitView";var cx=lx;var mF=class extends nk{constructor(A){super(A),this.zoomAxis=A.zoomAxis||"all"}_calculateNewZoom({scale:A,startZoom:j}){let{maxZoom:e,minZoom:r}=this.getViewportProps();j===void 0&&(j=this.getViewportProps().zoom);let n=Math.log2(A);if(Array.isArray(j)){let[i,o]=j;switch(this.zoomAxis){case"X":i=Kj(i+n,r,e);break;case"Y":o=Kj(o+n,r,e);break;default:let l=Math.min(i+n,o+n);le&&(n+=e-l),i+=n,o+=n}return[i,o]}return Kj(j+n,r,e)}},XB=class extends us{constructor(){super(...arguments),this.ControllerState=mF,this.transition={transitionDuration:300,transitionInterpolator:new bi(["target","zoom"])},this.dragMode="pan"}_onPanRotate(){return!1}};var ux=class extends cs{constructor(A={}){super(A)}get ViewportType(){return KB}get ControllerType(){return XB}};ux.displayName="OrthographicView";var un=ux;var Ra=class{constructor(A){this.indexStarts=[0],this.vertexStarts=[0],this.vertexCount=0,this.instanceCount=0;let{attributes:j={}}=A;this.typedArrayManager=ko,this.attributes={},this._attributeDefs=j,this.opts=A,this.updateGeometry(A)}updateGeometry(A){Object.assign(this.opts,A);let{data:j,buffers:e={},getGeometry:r,geometryBuffer:n,positionFormat:i,dataChanged:o,normalize:l=!0}=this.opts;if(this.data=j,this.getGeometry=r,this.positionSize=n&&n.size||(i==="XY"?2:3),this.buffers=e,this.normalize=l,n&&(Xj(j.startIndices),this.getGeometry=this.getGeometryFromBuffer(n),l||(e.vertexPositions=n)),this.geometryBuffer=e.vertexPositions,Array.isArray(o))for(let c of o)this._rebuildGeometry(c);else this._rebuildGeometry()}updatePartialGeometry({startRow:A,endRow:j}){this._rebuildGeometry({startRow:A,endRow:j})}getGeometryFromBuffer(A){let j=A.value||A;return ArrayBuffer.isView(j)?J$(j,{size:this.positionSize,offset:A.offset,stride:A.stride,startIndices:this.data.startIndices}):null}_allocate(A,j){let{attributes:e,buffers:r,_attributeDefs:n,typedArrayManager:i}=this;for(let o in n)if(o in r)i.release(e[o]),e[o]=null;else{let l=n[o];l.copy=j,e[o]=i.allocate(e[o],A,l)}}_forEachGeometry(A,j,e){let{data:r,getGeometry:n}=this,{iterable:i,objectInfo:o}=Pi(r,j,e);for(let l of i){o.index++;let c=n?n(l,o):null;A(c,o.index)}}_rebuildGeometry(A){if(!this.data)return;let{indexStarts:j,vertexStarts:e,instanceCount:r}=this,{data:n,geometryBuffer:i}=this,{startRow:o=0,endRow:l=1/0}=A||{},c={};if(A||(j=[0],e=[0]),this.normalize||!i)this._forEachGeometry((h,d)=>{let k=h&&this.normalizeGeometry(h);c[d]=k,e[d+1]=e[d]+(k?this.getGeometrySize(k):0)},o,l),r=e[e.length-1];else if(e=n.startIndices,r=e[n.length]||0,ArrayBuffer.isView(i))r=r||i.length/this.positionSize;else if(i instanceof Aj){let h=this.positionSize*4;r=r||i.byteLength/h}else if(i.buffer){let h=i.stride||this.positionSize*4;r=r||i.buffer.byteLength/h}else if(i.value){let h=i.value,d=i.stride/h.BYTES_PER_ELEMENT||this.positionSize;r=r||h.length/d}this._allocate(r,!!A),this.indexStarts=j,this.vertexStarts=e,this.instanceCount=r;let B={};this._forEachGeometry((h,d)=>{let k=c[d]||h;B.vertexStart=e[d],B.indexStart=j[d];let g=d0&&g>0&&(o[h++]=B-n,o[h++]=B-n-1,o[h++]=B-1,o[h++]=B-n,o[h++]=B-1,o[h++]=B),B++}}return{vertexCount:i,positions:c,indices:o,texCoords:l}}function voA(t){let A=new Float64Array(12);for(let j=0;jthis.attributes[e]?.getBounds());return this.mergeBoundsMemoized(j)}getChangedAttributes(A={clearChangedFlags:!1}){let{attributes:j,attributeTransitionManager:e}=this,r={...e.getAttributes()};for(let n in j){let i=j[n];i.needsRedraw(A)&&!e.hasAttribute(n)&&(r[n]=i)}return r}getBufferLayouts(A){return Object.values(this.getAttributes()).map(j=>j.getBufferLayout(A))}_add(A,j){for(let e in A){let r=A[e],n={...r,id:e,size:r.isIndexed&&1||r.size||1,...j};this.attributes[e]=new X7(this.device,n)}this._mapUpdateTriggersToAttributes()}_mapUpdateTriggersToAttributes(){let A={};for(let j in this.attributes)this.attributes[j].getUpdateTriggers().forEach(r=>{A[r]||(A[r]=[]),A[r].push(j)});this.updateTriggers=A}_invalidateTrigger(A,j){let{attributes:e,updateTriggers:r}=this,n=r[A];return n&&n.forEach(i=>{let o=e[i];o&&o.setNeedsUpdate(o.id,j)}),n}_updateAttribute(A){let{attribute:j,numInstances:e}=A;if(he(KiA,j),j.constant){j.setConstantValue(j.value);return}j.allocate(e)&&he(XiA,j,e),j.updateBuffer(A)&&(this.needsRedraw=!0,he(ziA,j,e))}};var Zp=class extends Eo{get value(){return this._value}_onUpdate(){let{time:A,settings:{fromValue:j,toValue:e,duration:r,easing:n}}=this,i=n(A/r);this._value=uo(j,e,i)}};var f2=1e-5;function h2(t,A,j,e,r){let n=A-t,o=(j-A)*r,l=-n*e;return o+l+n+A}function UiA(t,A,j,e,r){if(Array.isArray(j)){let n=[];for(let i=0;i0}add(A,j,e,r){let{transitions:n}=this;if(n.has(A)){let l=n.get(A),{value:c=l.settings.fromValue}=l;j=c,this.remove(A)}if(r=rx(r),!r)return;let i=ViA[r.type];if(!i){NA.error(`unsupported transition type '${r.type}'`)();return}let o=new i(this.timeline);o.start({...r,fromValue:j,toValue:e}),n.set(A,o)}remove(A){let{transitions:j}=this;j.has(A)&&(j.get(A).cancel(),j.delete(A))}update(){let A={};for(let[j,e]of this.transitions)e.update(),A[j]=e.value,e.inProgress||this.remove(j);return A}clear(){for(let A of this.transitions.keys())this.remove(A)}};function k2(t){let A=t[bi];for(let j in A){let e=A[j],{validate:r}=e;if(r&&!r(t[j],e))throw new Error(`Invalid prop ${j}: ${t[j]}`)}}function g2(t,A){let j=m2({newProps:t,oldProps:A,propTypes:t[bi],ignoreProps:{data:null,updateTriggers:null,extensions:null,transitions:null}}),e=WiA(t,A),r=!1;return e||(r=YiA(t,A)),{dataChanged:e,propsChanged:j,updateTriggersChanged:r,extensionsChanged:JiA(t,A),transitionsChanged:QiA(t,A)}}function QiA(t,A){if(!t.transitions)return!1;let j={},e=t[bi],r=!1;for(let n in t.transitions){let i=e[n],o=i&&i.type;(o==="number"||o==="color"||o==="array")&&pF(t[n],A[n],i)&&(j[n]=!0,r=!0)}return r?j:!1}function m2({newProps:t,oldProps:A,ignoreProps:j={},propTypes:e={},triggerName:r="props"}){if(A===t)return!1;if(typeof t!="object"||t===null)return`${r} changed shallowly`;if(typeof A!="object"||A===null)return`${r} changed shallowly`;for(let n of Object.keys(t))if(!(n in j)){if(!(n in A))return`${r}.${n} added`;let i=pF(t[n],A[n],e[n]);if(i)return`${r}.${n} ${i}`}for(let n of Object.keys(A))if(!(n in j)){if(!(n in t))return`${r}.${n} dropped`;if(!Object.hasOwnProperty.call(t,n)){let i=pF(t[n],A[n],e[n]);if(i)return`${r}.${n} ${i}`}}return!1}function pF(t,A,j){let e=j&&j.equal;return e&&!e(t,A,j)||!e&&(e=t&&A&&t.equals,e&&!e.call(t,A))?"changed deeply":!e&&A!==t?"changed shallowly":null}function WiA(t,A){if(A===null)return"oldProps is null, initial diff";let j=!1,{dataComparator:e,_dataDiff:r}=t;return e?e(t.data,A.data)||(j="Data comparator detected a change"):t.data!==A.data&&(j="A new data container was supplied"),j&&r&&(j=r(t.data,A.data)||j),j}function YiA(t,A){if(A===null)return{all:!0};if("all"in t.updateTriggers&&p2(t,A,"all"))return{all:!0};let j={},e=!1;for(let r in t.updateTriggers)r!=="all"&&p2(t,A,r)&&(j[r]=!0,e=!0);return e?j:!1}function JiA(t,A){if(A===null)return!0;let j=A.extensions,{extensions:e}=t;if(e===j)return!1;if(!j||!e||e.length!==j.length)return!0;for(let r=0;re.name==="project64"))){let e=j.modules.findIndex(r=>r.name==="project32");e>=0&&j.modules.splice(e,1)}if("inject"in A)if(!t.inject)j.inject=A.inject;else{let e={...t.inject};for(let r in A.inject)e[r]=(e[r]||"")+A.inject[r];j.inject=e}return j}var eoA={minFilter:"linear",mipmapFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"},gF={};function $2(t,A,j,e){if(j instanceof Ne)return j;j.constructor&&j.constructor.name!=="Object"&&(j={data:j});let r=null;j.compressed&&(r={minFilter:"linear",mipmapFilter:j.data.length>1?"nearest":"linear"});let n=A.createTexture({...j,sampler:{...eoA,...r,...e}});return gF[n.id]=t,n}function x2(t,A){!A||!(A instanceof Ne)||gF[A.id]===t&&(A.delete(),delete gF[A.id])}var roA={boolean:{validate(t,A){return!0},equal(t,A,j){return!!t==!!A}},number:{validate(t,A){return Number.isFinite(t)&&(!("max"in A)||t<=A.max)&&(!("min"in A)||t>=A.min)}},color:{validate(t,A){return A.optional&&!t||mF(t)&&(t.length===3||t.length===4)},equal(t,A,j){return Hr(t,A,1)}},accessor:{validate(t,A){let j=lx(t);return j==="function"||j===lx(A.value)},equal(t,A,j){return typeof A=="function"?!0:Hr(t,A,1)}},array:{validate(t,A){return A.optional&&!t||mF(t)},equal(t,A,j){let{compare:e}=j,r=Number.isInteger(e)?e:e?1:0;return e?Hr(t,A,r):t===A}},object:{equal(t,A,j){if(j.ignore)return!0;let{compare:e}=j,r=Number.isInteger(e)?e:e?1:0;return e?Hr(t,A,r):t===A}},function:{validate(t,A){return A.optional&&!t||typeof t=="function"},equal(t,A,j){return!j.compare&&j.ignore!==!1||t===A}},data:{transform:(t,A,j)=>{if(!t)return t;let{dataTransform:e}=j.props;return e?e(t):typeof t.shape=="string"&&t.shape.endsWith("-table")&&Array.isArray(t.data)?t.data:t}},image:{transform:(t,A,j)=>{let e=j.context;return!e||!e.device?null:$2(j.id,e.device,t,{...A.parameters,...j.props.textureParameters})},release:(t,A,j)=>{x2(j.id,t)}}};function y2(t){let A={},j={},e={};for(let[r,n]of Object.entries(t)){let i=n?.deprecatedFor;if(i)e[r]=Array.isArray(i)?i:[i];else{let o=noA(r,n);A[r]=o,j[r]=o.value}}return{propTypes:A,defaultProps:j,deprecatedProps:e}}function noA(t,A){switch(lx(A)){case"object":return jk(t,A);case"array":return jk(t,{type:"array",value:A,compare:!1});case"boolean":return jk(t,{type:"boolean",value:A});case"number":return jk(t,{type:"number",value:A});case"function":return jk(t,{type:"function",value:A,compare:!0});default:return{name:t,type:"unknown",value:A}}}function jk(t,A){return"type"in A?{name:t,...roA[A.type],...A}:"value"in A?{name:t,type:lx(A.value),...A}:{name:t,type:"object",value:A}}function mF(t){return Array.isArray(t)||ArrayBuffer.isView(t)}function lx(t){return mF(t)?"array":t===null?"null":typeof t}function v2(t,A){let j;for(let n=A.length-1;n>=0;n--){let i=A[n];"extensions"in i&&(j=i.extensions)}let e=EF(t.constructor,j),r=Object.create(e);r[GB]=t,r[ls]={},r[mo]={};for(let n=0;n{},this.oldProps=null,this.oldAsyncProps=null}finalize(){for(let A in this.asyncProps){let j=this.asyncProps[A];j&&j.type&&j.type.release&&j.type.release(j.resolvedValue,j.type,this.component)}this.asyncProps={},this.component=null,this.resetOldProps()}getOldProps(){return this.oldAsyncProps||this.oldProps||foA}resetOldProps(){this.oldAsyncProps=null,this.oldProps=this.component?this.component.props:null}hasAsyncProp(A){return A in this.asyncProps}getAsyncProp(A){let j=this.asyncProps[A];return j&&j.resolvedValue}isAsyncPropLoading(A){if(A){let j=this.asyncProps[A];return!!(j&&j.pendingLoadCount>0&&j.pendingLoadCount!==j.resolvedLoadCount)}for(let j in this.asyncProps)if(this.isAsyncPropLoading(j))return!0;return!1}reloadAsyncProp(A,j){this._watchPromise(A,Promise.resolve(j))}setAsyncProps(A){this.component=A[GB]||this.component;let j=A[mo]||{},e=A[ls]||A,r=A[Pa]||{};for(let n in j){let i=j[n];this._createAsyncPropData(n,r[n]),this._updateAsyncProp(n,i),j[n]=this.getAsyncProp(n)}for(let n in e){let i=e[n];this._createAsyncPropData(n,r[n]),this._updateAsyncProp(n,i)}}_fetch(A,j){return null}_onResolve(A,j){}_onError(A,j){}_updateAsyncProp(A,j){if(this._didAsyncInputValueChange(A,j)){if(typeof j=="string"&&(j=this._fetch(A,j)),j instanceof Promise){this._watchPromise(A,j);return}if(jx(j)){this._resolveAsyncIterable(A,j);return}this._setPropValue(A,j)}}_freezeAsyncOldProps(){if(!this.oldAsyncProps&&this.oldProps){this.oldAsyncProps=Object.create(this.oldProps);for(let A in this.asyncProps)Object.defineProperty(this.oldAsyncProps,A,{enumerable:!0,value:this.oldProps[A]})}}_didAsyncInputValueChange(A,j){let e=this.asyncProps[A];return j===e.resolvedValue||j===e.lastValue?!1:(e.lastValue=j,!0)}_setPropValue(A,j){this._freezeAsyncOldProps();let e=this.asyncProps[A];e&&(j=this._postProcessValue(e,j),e.resolvedValue=j,e.pendingLoadCount++,e.resolvedLoadCount=e.pendingLoadCount)}_setAsyncPropValue(A,j,e){let r=this.asyncProps[A];r&&e>=r.resolvedLoadCount&&j!==void 0&&(this._freezeAsyncOldProps(),r.resolvedValue=j,r.resolvedLoadCount=e,this.onAsyncPropUpdated(A,j))}_watchPromise(A,j){let e=this.asyncProps[A];if(e){e.pendingLoadCount++;let r=e.pendingLoadCount;j.then(n=>{this.component&&(n=this._postProcessValue(e,n),this._setAsyncPropValue(A,n,r),this._onResolve(A,n))}).catch(n=>{this._onError(A,n)})}}async _resolveAsyncIterable(A,j){if(A!=="data"){this._setPropValue(A,j);return}let e=this.asyncProps[A];if(!e)return;e.pendingLoadCount++;let r=e.pendingLoadCount,n=[],i=0;for await(let o of j){if(!this.component)return;let{dataTransform:l}=this.component.props;l?n=l(o,n):n=n.concat(o),Object.defineProperty(n,"__diff",{enumerable:!1,value:[{startRow:i,endRow:n.length}]}),i=n.length,this._setAsyncPropValue(A,n,r)}this._onResolve(A,n)}_postProcessValue(A,j){let e=A.type;return e&&this.component&&(e.release&&e.release(A.resolvedValue,e,this.component),e.transform)?e.transform(j,e,this.component):j}_createAsyncPropData(A,j){if(!this.asyncProps[A]){let r=this.component&&this.component.props[bi];this.asyncProps[A]={type:r&&r[A],lastValue:null,resolvedValue:j,pendingLoadCount:0,resolvedLoadCount:0}}}};var nk=class extends rk{constructor({attributeManager:A,layer:j}){super(j),this.attributeManager=A,this.needsRedraw=!0,this.needsUpdate=!0,this.subLayers=null,this.usesPickingColorCache=!1}get layer(){return this.component}_fetch(A,j){let e=this.layer,r=e?.props.fetch;return r?r(j,{propName:A,layer:e}):super._fetch(A,j)}_onResolve(A,j){let e=this.layer;if(e){let r=e.props.onDataLoad;A==="data"&&r&&r(j,{propName:A,layer:e})}}_onError(A,j){let e=this.layer;e&&e.raiseError(j,`loading ${A} of ${this.layer}`)}};var hoA="layer.changeFlag",doA="layer.initialize",poA="layer.update",koA="layer.finalize",goA="layer.matched",q2=2**24-1,moA=Object.freeze([]),EoA=ss(({oldViewport:t,viewport:A})=>t.equals(A)),ds=new Uint8ClampedArray(0),$oA={data:{type:"data",value:moA,async:!0},dataComparator:{type:"function",value:null,optional:!0},_dataDiff:{type:"function",value:t=>t&&t.__diff,optional:!0},dataTransform:{type:"function",value:null,optional:!0},onDataLoad:{type:"function",value:null,optional:!0},onError:{type:"function",value:null,optional:!0},fetch:{type:"function",value:(t,{propName:A,layer:j,loaders:e,loadOptions:r,signal:n})=>{let{resourceManager:i}=j.context;r=r||j.getLoadOptions(),e=e||j.props.loaders,n&&(r={...r,fetch:{...r?.fetch,signal:n}});let o=i.contains(t);return!o&&!r&&(i.add({resourceId:t,data:As(t,e),persistent:!1}),o=!0),o?i.subscribe({resourceId:t,onChange:l=>j.internalState?.reloadAsyncProp(A,l),consumerId:j.id,requestId:A}):As(t,e,r)}},updateTriggers:{},visible:!0,pickable:!1,opacity:{type:"number",min:0,max:1,value:1},operation:"draw",onHover:{type:"function",value:null,optional:!0},onClick:{type:"function",value:null,optional:!0},onDragStart:{type:"function",value:null,optional:!0},onDrag:{type:"function",value:null,optional:!0},onDragEnd:{type:"function",value:null,optional:!0},coordinateSystem:qt.DEFAULT,coordinateOrigin:{type:"array",value:[0,0,0],compare:!0},modelMatrix:{type:"array",value:null,compare:!0,optional:!0},wrapLongitude:!1,positionFormat:"XYZ",colorFormat:"RGBA",parameters:{type:"object",value:{},optional:!0,compare:2},loadOptions:{type:"object",value:null,optional:!0,ignore:!0},transitions:null,extensions:[],loaders:{type:"array",value:[],optional:!0,ignore:!0},getPolygonOffset:{type:"function",value:({layerIndex:t})=>[0,-t*100]},highlightedObjectIndex:null,autoHighlight:!1,highlightColor:{type:"accessor",value:[0,0,128,128]}},ik=class extends cx{constructor(){super(...arguments),this.internalState=null,this.lifecycle=R7.NO_STATE,this.parent=null}static get componentName(){return Object.prototype.hasOwnProperty.call(this,"layerName")?this.layerName:""}get root(){let A=this;for(;A.parent;)A=A.parent;return A}toString(){return`${this.constructor.layerName||this.constructor.name}({id: '${this.props.id}'})`}project(A){Xj(this.internalState);let j=this.internalState.viewport||this.context.viewport,e=Dw(A,{viewport:j,modelMatrix:this.props.modelMatrix,coordinateOrigin:this.props.coordinateOrigin,coordinateSystem:this.props.coordinateSystem}),[r,n,i]=yB(e,j.pixelProjectionMatrix);return A.length===2?[r,n]:[r,n,i]}unproject(A){return Xj(this.internalState),(this.internalState.viewport||this.context.viewport).unproject(A)}projectPosition(A,j){Xj(this.internalState);let e=this.internalState.viewport||this.context.viewport;return bR(A,{viewport:e,modelMatrix:this.props.modelMatrix,coordinateOrigin:this.props.coordinateOrigin,coordinateSystem:this.props.coordinateSystem,...j})}get isComposite(){return!1}setState(A){this.setChangeFlags({stateChanged:!0}),Object.assign(this.state,A),this.setNeedsRedraw()}setNeedsRedraw(){this.internalState&&(this.internalState.needsRedraw=!0)}setNeedsUpdate(){this.internalState&&(this.context.layerManager.setNeedsUpdate(String(this)),this.internalState.needsUpdate=!0)}get isLoaded(){return this.internalState?!this.internalState.isAsyncPropLoading():!1}get wrapLongitude(){return this.props.wrapLongitude}isPickable(){return this.props.pickable&&this.props.visible}getModels(){let A=this.state;return A&&(A.models||A.model&&[A.model])||[]}setModuleParameters(A){for(let j of this.getModels())j.updateModuleSettings(A)}setShaderModuleProps(...A){for(let j of this.getModels())j.shaderInputs.setProps(...A)}getAttributeManager(){return this.internalState&&this.internalState.attributeManager}getCurrentLayer(){return this.internalState&&this.internalState.layer}getLoadOptions(){return this.props.loadOptions}use64bitPositions(){let{coordinateSystem:A}=this.props;return A===qt.DEFAULT||A===qt.LNGLAT||A===qt.CARTESIAN}onHover(A,j){return this.props.onHover&&this.props.onHover(A,j)||!1}onClick(A,j){return this.props.onClick&&this.props.onClick(A,j)||!1}nullPickingColor(){return[0,0,0]}encodePickingColor(A,j=[]){return j[0]=A+1&255,j[1]=A+1>>8&255,j[2]=A+1>>8>>8&255,j}decodePickingColor(A){Xj(A instanceof Uint8Array);let[j,e,r]=A;return j+e*256+r*65536-1}getNumInstances(){return Number.isFinite(this.props.numInstances)?this.props.numInstances:this.state&&this.state.numInstances!==void 0?this.state.numInstances:E2(this.props.data)}getStartIndices(){return this.props.startIndices?this.props.startIndices:this.state&&this.state.startIndices?this.state.startIndices:null}getBounds(){return this.getAttributeManager()?.getBounds(["positions","instancePositions"])}getShaders(A){A=kF(A,{disableWarnings:!0,modules:this.context.defaultShaderModules});for(let j of this.props.extensions)A=kF(A,j.getShaders.call(this,j));return A}shouldUpdateState(A){return A.changeFlags.propsOrDataChanged}updateState(A){let j=this.getAttributeManager(),{dataChanged:e}=A.changeFlags;if(e&&j)if(Array.isArray(e))for(let r of e)j.invalidateAll(r);else j.invalidateAll();if(j){let{props:r}=A,n=this.internalState.hasPickingBuffer,i=Number.isInteger(r.highlightedObjectIndex)||r.pickable||r.extensions.some(o=>o.getNeedsPickingBuffer.call(this,o));if(n!==i){this.internalState.hasPickingBuffer=i;let{pickingColors:o,instancePickingColors:l}=j.attributes,c=o||l;c&&(i&&c.constant&&(c.constant=!1,j.invalidate(c.id)),!c.value&&!i&&(c.constant=!0,c.value=[0,0,0]))}}}finalizeState(A){for(let e of this.getModels())e.destroy();let j=this.getAttributeManager();j&&j.finalize(),this.context&&this.context.resourceManager.unsubscribe({consumerId:this.id}),this.internalState&&(this.internalState.uniformTransitions.clear(),this.internalState.finalize())}draw(A){for(let j of this.getModels())j.draw(A)}getPickingInfo({info:A,mode:j,sourceLayer:e}){let{index:r}=A;return r>=0&&Array.isArray(this.props.data)&&(A.object=this.props.data[r]),A}raiseError(A,j){j&&(A=new Error(`${j}: ${A.message}`,{cause:A})),this.props.onError?.(A)||this.context?.onError?.(A,this)}getNeedsRedraw(A={clearRedrawFlags:!1}){return this._getNeedsRedraw(A)}needsUpdate(){return this.internalState?this.internalState.needsUpdate||this.hasUniformTransition()||this.shouldUpdateState(this._getUpdateParams()):!1}hasUniformTransition(){return this.internalState?.uniformTransitions.active||!1}activateViewport(A){if(!this.internalState)return;let j=this.internalState.viewport;this.internalState.viewport=A,(!j||!EoA({oldViewport:j,viewport:A}))&&(this.setChangeFlags({viewportChanged:!0}),this.isComposite?this.needsUpdate()&&this.setNeedsUpdate():this._update())}invalidateAttribute(A="all"){let j=this.getAttributeManager();j&&(A==="all"?j.invalidateAll():j.invalidate(A))}updateAttributes(A){let j=!1;for(let e in A)A[e].layoutChanged()&&(j=!0);for(let e of this.getModels())this._setModelAttributes(e,A,j)}_updateAttributes(){let A=this.getAttributeManager();if(!A)return;let j=this.props,e=this.getNumInstances(),r=this.getStartIndices();A.update({data:j.data,numInstances:e,startIndices:r,props:j,transitions:j.transitions,buffers:j.data.attributes,context:this});let n=A.getChangedAttributes({clearChangedFlags:!0});this.updateAttributes(n)}_updateAttributeTransition(){let A=this.getAttributeManager();A&&A.updateTransition()}_updateUniformTransition(){let{uniformTransitions:A}=this.internalState;if(A.active){let j=A.update(),e=Object.create(this.props);for(let r in j)Object.defineProperty(e,r,{value:j[r]});return e}return this.props}calculateInstancePickingColors(A,{numInstances:j}){if(A.constant)return;let e=Math.floor(ds.length/4);if(this.internalState.usesPickingColorCache=!0,eq2&&NA.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(),ds=ko.allocate(ds,j,{size:4,copy:!0,maxCount:Math.max(j,q2)});let r=Math.floor(ds.length/4),n=[];for(let i=e;i(NA.deprecated("layer.state.attributeManager","layer.getAttributeManager()")(),A)}),this.internalState.uniformTransitions=new tk(this.context.timeline),this.internalState.onAsyncPropUpdated=this._onAsyncPropUpdated.bind(this),this.internalState.setAsyncProps(this.props),this.initializeState(this.context);for(let j of this.props.extensions)j.initializeState.call(this,this.context,j);this.setChangeFlags({dataChanged:"init",propsChanged:"init",viewportChanged:!0,extensionsChanged:!0}),this._update()}_transferState(A){he(goA,this,this===A);let{state:j,internalState:e}=A;this!==A&&(this.internalState=e,this.state=j,this.internalState.setAsyncProps(this.props),this._diffProps(this.props,this.internalState.getOldProps()))}_update(){let A=this.needsUpdate();if(he(poA,this,A),!A)return;let j=this.props,e=this.context,r=this.internalState,n=e.viewport,i=this._updateUniformTransition();r.propsInTransition=i,e.viewport=r.viewport||n,this.props=i;try{let o=this._getUpdateParams(),l=this.getModels();if(e.device)this.updateState(o);else try{this.updateState(o)}catch{}for(let B of this.props.extensions)B.updateState.call(this,o,B);let c=this.getModels()[0]!==l[0];this._postUpdate(o,c)}finally{e.viewport=n,this.props=j,this._clearChangeFlags(),r.needsUpdate=!1,r.resetOldProps()}}_finalize(){he(koA,this),this.finalizeState(this.context);for(let A of this.props.extensions)A.finalizeState.call(this,this.context,A)}_drawLayer({renderPass:A,moduleParameters:j=null,uniforms:e={},parameters:r={}}){this._updateAttributeTransition();let n=this.props,i=this.context;this.props=this.internalState.propsInTransition||n;let o=this.props.opacity;e.opacity=Math.pow(o,1/2.2);try{if(j){let{isActive:B,isAttribute:h}=j.picking;this.setModuleParameters(j),this.setShaderModuleProps({picking:{isActive:B,isAttribute:h}})}let{getPolygonOffset:l}=this.props,c=l&&l(e)||[0,0];i.device.setParametersWebGL({polygonOffset:c});for(let B of this.getModels())B.setParameters(r);i.device.withParametersWebGL(r,()=>{let B={renderPass:A,moduleParameters:j,uniforms:e,parameters:r,context:i};for(let h of this.props.extensions)h.draw.call(this,B,h);this.draw(B)})}finally{this.props=n}}getChangeFlags(){return this.internalState?.changeFlags}setChangeFlags(A){if(!this.internalState)return;let{changeFlags:j}=this.internalState;for(let r in A)if(A[r]){let n=!1;switch(r){case"dataChanged":let i=A[r],o=j[r];i&&Array.isArray(o)&&(j.dataChanged=Array.isArray(i)?o.concat(i):i,n=!0);default:j[r]||(j[r]=A[r],n=!0)}n&&he(hoA,this,r,A)}let e=!!(j.dataChanged||j.updateTriggersChanged||j.propsChanged||j.extensionsChanged);j.propsOrDataChanged=e,j.somethingChanged=e||j.viewportChanged||j.stateChanged}_clearChangeFlags(){this.internalState.changeFlags={dataChanged:!1,propsChanged:!1,updateTriggersChanged:!1,viewportChanged:!1,stateChanged:!1,extensionsChanged:!1,propsOrDataChanged:!1,somethingChanged:!1}}_diffProps(A,j){let e=g2(A,j);if(e.updateTriggersChanged)for(let r in e.updateTriggersChanged)e.updateTriggersChanged[r]&&this.invalidateAttribute(r);if(e.transitionsChanged)for(let r in e.transitionsChanged)this.internalState.uniformTransitions.add(r,j[r],A[r],A.transitions?.[r]);return this.setChangeFlags(e)}validateProps(){k2(this.props)}updateAutoHighlight(A){this.props.autoHighlight&&!Number.isInteger(this.props.highlightedObjectIndex)&&this._updateAutoHighlight(A)}_updateAutoHighlight(A){let j={highlightedObjectColor:A.picked?A.color:null},{highlightColor:e}=this.props;A.picked&&typeof e=="function"&&(j.highlightColor=e(A)),this.setShaderModuleProps({picking:j}),this.setNeedsRedraw()}_getAttributeManager(){let A=this.context;return new HB(A.device,{id:this.props.id,stats:A.stats,timeline:A.timeline})}_postUpdate(A,j){let{props:e,oldProps:r}=A;this.setNeedsRedraw(),this._updateAttributes();let n=this.state.model;n?.isInstanced&&n.setInstanceCount(this.getNumInstances());let{autoHighlight:i,highlightedObjectIndex:o,highlightColor:l}=e;if(j||r.autoHighlight!==i||r.highlightedObjectIndex!==o||r.highlightColor!==l){let c={};Array.isArray(l)&&(c.highlightColor=l),(j||r.autoHighlight!==i||o!==r.highlightedObjectIndex)&&(c.highlightedObjectColor=Number.isFinite(o)&&o>=0?this.encodePickingColor(o):null),this.setShaderModuleProps({picking:c})}}_getUpdateParams(){return{props:this.props,oldProps:this.internalState.getOldProps(),context:this.context,changeFlags:this.internalState.changeFlags}}_getNeedsRedraw(A){if(!this.internalState)return!1;let j=!1;j=j||this.internalState.needsRedraw&&this.id;let e=this.getAttributeManager(),r=e?e.getNeedsRedraw(A):!1;if(j=j||r,j)for(let n of this.props.extensions)n.onNeedsRedraw.call(this,n);return this.internalState.needsRedraw=this.internalState.needsRedraw&&!A.clearRedrawFlags,j}_onAsyncPropUpdated(){this._diffProps(this.props,this.internalState.getOldProps()),this.setNeedsUpdate()}};ik.defaultProps=$oA;ik.layerName="Layer";var gr=ik;var xoA="compositeLayer.renderLayers",ux=class extends gr{get isComposite(){return!0}get isLoaded(){return super.isLoaded&&this.getSubLayers().every(A=>A.isLoaded)}getSubLayers(){return this.internalState&&this.internalState.subLayers||[]}initializeState(A){}setState(A){super.setState(A),this.setNeedsUpdate()}getPickingInfo({info:A}){let{object:j}=A;return j&&j.__source&&j.__source.parent&&j.__source.parent.id===this.id&&(A.object=j.__source.object,A.index=j.__source.index),A}filterSubLayer(A){return!0}shouldRenderSubLayer(A,j){return j&&j.length}getSubLayerClass(A,j){let{_subLayerProps:e}=this.props;return e&&e[A]&&e[A].type||j}getSubLayerRow(A,j,e){return A.__source={parent:this,object:j,index:e},A}getSubLayerAccessor(A){if(typeof A=="function"){let j={index:-1,data:this.props.data,target:[]};return(e,r)=>e&&e.__source?(j.index=e.__source.index,A(e.__source.object,j)):A(e,r)}return A}getSubLayerProps(A={}){let{opacity:j,pickable:e,visible:r,parameters:n,getPolygonOffset:i,highlightedObjectIndex:o,autoHighlight:l,highlightColor:c,coordinateSystem:B,coordinateOrigin:h,wrapLongitude:d,positionFormat:k,modelMatrix:g,extensions:E,fetch:m,operation:y,_subLayerProps:G}=this.props,v={id:"",updateTriggers:{},opacity:j,pickable:e,visible:r,parameters:n,getPolygonOffset:i,highlightedObjectIndex:o,autoHighlight:l,highlightColor:c,coordinateSystem:B,coordinateOrigin:h,wrapLongitude:d,positionFormat:k,modelMatrix:g,extensions:E,fetch:m,operation:y},_=G&&A.id&&G[A.id],w=_&&_.updateTriggers,x=A.id||"sublayer";if(_){let O=this.props[bi],F=A.type?A.type._propTypes:{};for(let C in _){let R=F[C]||O[C];R&&R.type==="accessor"&&(_[C]=this.getSubLayerAccessor(_[C]))}}Object.assign(v,A,_),v.id=`${this.props.id}-${x}`,v.updateTriggers={all:this.props.updateTriggers?.all,...A.updateTriggers,...w};for(let O of E){let F=O.getSubLayerProps.call(this,O);F&&Object.assign(v,F,{updateTriggers:Object.assign(v.updateTriggers,F.updateTriggers)})}return v}_updateAutoHighlight(A){for(let j of this.getSubLayers())j.updateAutoHighlight(A)}_getAttributeManager(){return null}_postUpdate(A,j){let e=this.internalState.subLayers,r=!e||this.needsUpdate();if(r){let n=this.renderLayers();e=Ia(n,Boolean),this.internalState.subLayers=e}he(xoA,this,r,e);for(let n of e)n.parent=this}};ux.layerName="CompositeLayer";var b6=ux;var Bx=Math.PI/180,b2=180/Math.PI,fx=6370972,DB=256;function yoA(){let t=DB/fx,A=Math.PI/180*DB;return{unitsPerMeter:[t,t,t],unitsPerMeter2:[0,0,0],metersPerUnit:[1/t,1/t,1/t],unitsPerDegree:[A,A,t],unitsPerDegree2:[0,0,0],degreesPerUnit:[1/A,1/A,1/t]}}var Oc=class extends go{constructor(A={}){let{latitude:j=0,longitude:e=0,zoom:r=0,nearZMultiplier:n=.1,farZMultiplier:i=2,resolution:o=10}=A,{height:l,altitude:c=1.5}=A;l=l||1,c=Math.max(.75,c);let B=new lj().lookAt({eye:[0,-c,0],up:[0,0,1]}),h=Math.pow(2,r);B.rotateX(j*Bx),B.rotateZ(-e*Bx),B.scale(h/l);let d=Math.atan(.5/c),k=DB*2*h/l;super({...A,height:l,viewMatrix:B,longitude:e,latitude:j,zoom:r,distanceScales:yoA(),fovyRadians:d*2,focalDistance:c,near:n,far:Math.min(2,1/k+1)*c*i}),this.latitude=j,this.longitude=e,this.resolution=o}get projectionMode(){return sn.GLOBE}getDistanceScales(){return this.distanceScales}getBounds(A={}){let j={targetZ:A.z||0},e=this.unproject([0,this.height/2],j),r=this.unproject([this.width/2,0],j),n=this.unproject([this.width,this.height/2],j),i=this.unproject([this.width/2,this.height],j);return n[0]this.longitude&&(e[0]-=360),[Math.min(e[0],n[0],r[0],i[0]),Math.min(e[1],n[1],r[1],i[1]),Math.max(e[0],n[0],r[0],i[0]),Math.max(e[1],n[1],r[1],i[1])]}unproject(A,{topLeft:j=!0,targetZ:e}={}){let[r,n,i]=A,o=j?n:this.height-n,{pixelUnprojectionMatrix:l}=this,c;if(Number.isFinite(i))c=xF(l,[r,o,i,1]);else{let k=xF(l,[r,o,-1,1]),g=xF(l,[r,o,1,1]),E=((e||0)/fx+1)*DB,m=fo.sqrLen(fo.sub([],k,g)),y=fo.sqrLen(k),G=fo.sqrLen(g),_=4*((4*y*G-(m-y-G)**2)/16)/m,w=Math.sqrt(y-_),x=Math.sqrt(Math.max(0,E*E-_)),O=(w-x)/Math.sqrt(m);c=fo.lerp([],k,g,O)}let[B,h,d]=this.unprojectPosition(c);return Number.isFinite(i)?[B,h,d]:Number.isFinite(e)?[B,h,e]:[B,h]}projectPosition(A){let[j,e,r=0]=A,n=j*Bx,i=e*Bx,o=Math.cos(i),l=(r/fx+1)*DB;return[Math.sin(n)*o*l,-Math.cos(n)*o*l,Math.sin(i)*l]}unprojectPosition(A){let[j,e,r]=A,n=fo.len(A),i=Math.asin(r/n),l=Math.atan2(j,-e)*b2,c=i*b2,B=(n/DB-1)*fx;return[l,c,B]}projectFlat(A){return A}unprojectFlat(A){return A}panByPosition(A,j){let e=this.unproject(j);return{longitude:A[0]-e[0]+this.longitude,latitude:A[1]-e[1]+this.latitude}}};function xF(t,A){let j=os.transformMat4([],A,t);return os.scale(j,j,1/j[3]),j}var yF=Math.PI/180;function voA({height:t,focalDistance:A,orbitAxis:j,rotationX:e,rotationOrbit:r,zoom:n}){let i=j==="Z"?[0,0,1]:[0,1,0],o=j==="Z"?[0,-A,0]:[0,0,A],l=new lj().lookAt({eye:o,up:i});l.rotateX(e*yF),j==="Z"?l.rotateZ(r*yF):l.rotateY(r*yF);let c=Math.pow(2,n)/t;return l.scale(c),l}var NB=class extends go{constructor(A){let{height:j,projectionMatrix:e,fovy:r=50,orbitAxis:n="Z",target:i=[0,0,0],rotationX:o=0,rotationOrbit:l=0,zoom:c=0}=A,B=e?e[5]/2:$c(r);super({...A,longitude:void 0,viewMatrix:voA({height:j||1,focalDistance:B,orbitAxis:n,rotationX:o,rotationOrbit:l,zoom:c}),fovy:r,focalDistance:B,position:i,zoom:c}),this.projectedCenter=this.project(this.center)}unproject(A,{topLeft:j=!0}={}){let[e,r,n=this.projectedCenter[2]]=A,i=j?r:this.height-r,[o,l,c]=qi([e,i,n],this.pixelUnprojectionMatrix);return[o,l,c]}panByPosition(A,j){let e=this.project(A),r=[this.width/2+e[0]-j[0],this.height/2+e[1]-j[1],this.projectedCenter[2]];return{target:this.unproject(r)}}};var _oA=new lj().lookAt({eye:[0,0,1]});function qoA({width:t,height:A,near:j,far:e,padding:r}){let n=-t/2,i=t/2,o=-A/2,l=A/2;if(r){let{left:c=0,right:B=0,top:h=0,bottom:d=0}=r,k=Kj((c+t-B)/2,0,t)-t/2,g=Kj((h+A-d)/2,0,A)-A/2;n-=k,i-=k,o+=g,l+=g}return new lj().ortho({left:n,right:i,bottom:o,top:l,near:j,far:e})}var KB=class extends go{constructor(A){let{width:j,height:e,near:r=.1,far:n=1e3,zoom:i=0,target:o=[0,0,0],padding:l=null,flipY:c=!0}=A,B=Array.isArray(i)?i[0]:i,h=Array.isArray(i)?i[1]:i,d=Math.min(B,h),k=Math.pow(2,d),g;if(B!==h){let E=Math.pow(2,B),m=Math.pow(2,h);g={unitsPerMeter:[E/k,m/k,1],metersPerUnit:[k/E,k/m,1]}}super({...A,longitude:void 0,position:o,viewMatrix:_oA.clone().scale([k,k*(c?-1:1),k]),projectionMatrix:qoA({width:j||1,height:e||1,padding:l,near:r,far:n}),zoom:d,distanceScales:g})}projectFlat([A,j]){let{unitsPerMeter:e}=this.distanceScales;return[A*e[0],j*e[1]]}unprojectFlat([A,j]){let{metersPerUnit:e}=this.distanceScales;return[A*e[0],j*e[1]]}panByPosition(A,j){let e=qi(j,this.pixelUnprojectionMatrix),r=this.projectFlat(A),n=is.add([],r,is.negate([],e)),i=is.add([],this.center,n);return{target:this.unprojectFlat(i)}}};var ok=class extends qc{constructor(A){let{width:j,height:e,rotationX:r=0,rotationOrbit:n=0,target:i=[0,0,0],zoom:o=0,minRotationX:l=-90,maxRotationX:c=90,minZoom:B=-1/0,maxZoom:h=1/0,startPanPosition:d,startRotatePos:k,startRotationX:g,startRotationOrbit:E,startZoomPosition:m,startZoom:y}=A;super({width:j,height:e,rotationX:r,rotationOrbit:n,target:i,zoom:o,minRotationX:l,maxRotationX:c,minZoom:B,maxZoom:h},{startPanPosition:d,startRotatePos:k,startRotationX:g,startRotationOrbit:E,startZoomPosition:m,startZoom:y}),this.makeViewport=A.makeViewport}panStart({pos:A}){return this._getUpdatedState({startPanPosition:this._unproject(A)})}pan({pos:A,startPosition:j}){let e=this.getState().startPanPosition||j;if(!e)return this;let n=this.makeViewport(this.getViewportProps()).panByPosition(e,A);return this._getUpdatedState(n)}panEnd(){return this._getUpdatedState({startPanPosition:null})}rotateStart({pos:A}){return this._getUpdatedState({startRotatePos:A,startRotationX:this.getViewportProps().rotationX,startRotationOrbit:this.getViewportProps().rotationOrbit})}rotate({pos:A,deltaAngleX:j=0,deltaAngleY:e=0}){let{startRotatePos:r,startRotationX:n,startRotationOrbit:i}=this.getState(),{width:o,height:l}=this.getViewportProps();if(!r||n===void 0||i===void 0)return this;let c;if(A){let B=(A[0]-r[0])/o,h=(A[1]-r[1])/l;(n<-90||n>90)&&(B*=-1),c={rotationX:n+h*180,rotationOrbit:i+B*180}}else c={rotationX:n+e,rotationOrbit:i+j};return this._getUpdatedState(c)}rotateEnd(){return this._getUpdatedState({startRotationX:null,startRotationOrbit:null})}shortestPathFrom(A){let j=A.getViewportProps(),e={...this.getViewportProps()},{rotationOrbit:r}=e;return Math.abs(r-j.rotationOrbit)>180&&(e.rotationOrbit=r<0?r+360:r-360),e}zoomStart({pos:A}){return this._getUpdatedState({startZoomPosition:this._unproject(A),startZoom:this.getViewportProps().zoom})}zoom({pos:A,startPos:j,scale:e}){let{startZoom:r,startZoomPosition:n}=this.getState();if(n||(r=this.getViewportProps().zoom,n=this._unproject(j)||this._unproject(A)),!n)return this;let i=this._calculateNewZoom({scale:e,startZoom:r}),o=this.makeViewport({...this.getViewportProps(),zoom:i});return this._getUpdatedState({zoom:i,...o.panByPosition(n,A)})}zoomEnd(){return this._getUpdatedState({startZoomPosition:null,startZoom:null})}zoomIn(A=2){return this._getUpdatedState({zoom:this._calculateNewZoom({scale:A})})}zoomOut(A=2){return this._getUpdatedState({zoom:this._calculateNewZoom({scale:1/A})})}moveLeft(A=50){return this._panFromCenter([-A,0])}moveRight(A=50){return this._panFromCenter([A,0])}moveUp(A=50){return this._panFromCenter([0,-A])}moveDown(A=50){return this._panFromCenter([0,A])}rotateLeft(A=15){return this._getUpdatedState({rotationOrbit:this.getViewportProps().rotationOrbit-A})}rotateRight(A=15){return this._getUpdatedState({rotationOrbit:this.getViewportProps().rotationOrbit+A})}rotateUp(A=10){return this._getUpdatedState({rotationX:this.getViewportProps().rotationX-A})}rotateDown(A=10){return this._getUpdatedState({rotationX:this.getViewportProps().rotationX+A})}_unproject(A){let j=this.makeViewport(this.getViewportProps());return A&&j.unproject(A)}_calculateNewZoom({scale:A,startZoom:j}){let{maxZoom:e,minZoom:r}=this.getViewportProps();j===void 0&&(j=this.getViewportProps().zoom);let n=j+Math.log2(A);return Kj(n,r,e)}_panFromCenter(A){let{width:j,height:e,target:r}=this.getViewportProps();return this.pan({startPosition:r,pos:[j/2+A[0],e/2+A[1]]})}_getUpdatedState(A){return new this.constructor({makeViewport:this.makeViewport,...this.getViewportProps(),...this.getState(),...A})}applyConstraints(A){let{maxZoom:j,minZoom:e,zoom:r,maxRotationX:n,minRotationX:i,rotationOrbit:o}=A;return A.zoom=Array.isArray(r)?[Kj(r[0],e,j),Kj(r[1],e,j)]:Kj(r,e,j),A.rotationX=Kj(A.rotationX,i,n),(o<-180||o>180)&&(A.rotationOrbit=ER(o+180,360)-180),A}},Sa=class extends us{constructor(){super(...arguments),this.ControllerState=ok,this.transition={transitionDuration:300,transitionInterpolator:new Gi({transitionProps:{compare:["target","zoom","rotationX","rotationOrbit"],required:["target","zoom"]}})}}};var hx=class extends cs{constructor(A={}){super(A),this.props.orbitAxis=A.orbitAxis||"Z"}get ViewportType(){return NB}get ControllerType(){return Sa}};hx.displayName="OrbitView";var dx=hx;var vF=class extends ok{constructor(A){super(A),this.zoomAxis=A.zoomAxis||"all"}_calculateNewZoom({scale:A,startZoom:j}){let{maxZoom:e,minZoom:r}=this.getViewportProps();j===void 0&&(j=this.getViewportProps().zoom);let n=Math.log2(A);if(Array.isArray(j)){let[i,o]=j;switch(this.zoomAxis){case"X":i=Kj(i+n,r,e);break;case"Y":o=Kj(o+n,r,e);break;default:let l=Math.min(i+n,o+n);le&&(n+=e-l),i+=n,o+=n}return[i,o]}return Kj(j+n,r,e)}},XB=class extends us{constructor(){super(...arguments),this.ControllerState=vF,this.transition={transitionDuration:300,transitionInterpolator:new Gi(["target","zoom"])},this.dragMode="pan"}_onPanRotate(){return!1}};var px=class extends cs{constructor(A={}){super(A)}get ViewportType(){return KB}get ControllerType(){return XB}};px.displayName="OrthographicView";var un=px;var Ra=class{constructor(A){this.indexStarts=[0],this.vertexStarts=[0],this.vertexCount=0,this.instanceCount=0;let{attributes:j={}}=A;this.typedArrayManager=ko,this.attributes={},this._attributeDefs=j,this.opts=A,this.updateGeometry(A)}updateGeometry(A){Object.assign(this.opts,A);let{data:j,buffers:e={},getGeometry:r,geometryBuffer:n,positionFormat:i,dataChanged:o,normalize:l=!0}=this.opts;if(this.data=j,this.getGeometry=r,this.positionSize=n&&n.size||(i==="XY"?2:3),this.buffers=e,this.normalize=l,n&&(Xj(j.startIndices),this.getGeometry=this.getGeometryFromBuffer(n),l||(e.vertexPositions=n)),this.geometryBuffer=e.vertexPositions,Array.isArray(o))for(let c of o)this._rebuildGeometry(c);else this._rebuildGeometry()}updatePartialGeometry({startRow:A,endRow:j}){this._rebuildGeometry({startRow:A,endRow:j})}getGeometryFromBuffer(A){let j=A.value||A;return ArrayBuffer.isView(j)?ex(j,{size:this.positionSize,offset:A.offset,stride:A.stride,startIndices:this.data.startIndices}):null}_allocate(A,j){let{attributes:e,buffers:r,_attributeDefs:n,typedArrayManager:i}=this;for(let o in n)if(o in r)i.release(e[o]),e[o]=null;else{let l=n[o];l.copy=j,e[o]=i.allocate(e[o],A,l)}}_forEachGeometry(A,j,e){let{data:r,getGeometry:n}=this,{iterable:i,objectInfo:o}=Pi(r,j,e);for(let l of i){o.index++;let c=n?n(l,o):null;A(c,o.index)}}_rebuildGeometry(A){if(!this.data)return;let{indexStarts:j,vertexStarts:e,instanceCount:r}=this,{data:n,geometryBuffer:i}=this,{startRow:o=0,endRow:l=1/0}=A||{},c={};if(A||(j=[0],e=[0]),this.normalize||!i)this._forEachGeometry((h,d)=>{let k=h&&this.normalizeGeometry(h);c[d]=k,e[d+1]=e[d]+(k?this.getGeometrySize(k):0)},o,l),r=e[e.length-1];else if(e=n.startIndices,r=e[n.length]||0,ArrayBuffer.isView(i))r=r||i.length/this.positionSize;else if(i instanceof Aj){let h=this.positionSize*4;r=r||i.byteLength/h}else if(i.buffer){let h=i.stride||this.positionSize*4;r=r||i.buffer.byteLength/h}else if(i.value){let h=i.value,d=i.stride/h.BYTES_PER_ELEMENT||this.positionSize;r=r||h.length/d}this._allocate(r,!!A),this.indexStarts=j,this.vertexStarts=e,this.instanceCount=r;let B={};this._forEachGeometry((h,d)=>{let k=c[d]||h;B.vertexStart=e[d],B.indexStart=j[d];let g=d0&&g>0&&(o[h++]=B-n,o[h++]=B-n-1,o[h++]=B-1,o[h++]=B-n,o[h++]=B-1,o[h++]=B),B++}}return{vertexCount:i,positions:c,indices:o,texCoords:l}}function FoA(t){let A=new Float64Array(12);for(let j=0;je.value=this.state.mesh.indices,noAlloc:j},positions:{size:3,type:"float64",fp64:this.use64bitPositions(),update:e=>e.value=this.state.mesh.positions,noAlloc:j},texCoords:{size:2,update:e=>e.value=this.state.mesh.texCoords,noAlloc:j}})}updateState({props:A,oldProps:j,changeFlags:e}){let r=this.getAttributeManager();if(e.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll()),A.bounds!==j.bounds){let n=this.state.mesh,i=this._createMesh();this.state.model.setVertexCount(i.vertexCount);for(let o in i)n&&n[o]!==i[o]&&r.invalidate(o);this.setState({mesh:i,...this._getCoordinateUniforms()})}else A._imageCoordinateSystem!==j._imageCoordinateSystem&&this.setState(this._getCoordinateUniforms())}getPickingInfo(A){let{image:j}=this.props,e=A.info;if(!e.color||!j)return e.bitmap=null,e;let{width:r,height:n}=j;e.index=0;let i=boA(e.color);return e.bitmap={size:{width:r,height:n},uv:i,pixel:[Math.floor(i[0]*r),Math.floor(i[1]*n)]},e}disablePickingIndex(){this.setState({disablePicking:!0})}restorePickingColors(){this.setState({disablePicking:!1})}_updateAutoHighlight(A){super._updateAutoHighlight({...A,color:this.encodePickingColor(0)})}_createMesh(){let{bounds:A}=this.props,j=A;return v2(A)&&(j=[[A[0],A[1]],[A[0],A[3]],[A[2],A[3]],[A[2],A[1]]]),EF(j,this.context.viewport.resolution)}_getModel(){return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),topology:"triangle-list",isInstanced:!1})}draw(A){let{uniforms:j,moduleParameters:e}=A,{model:r,coordinateConversion:n,bounds:i,disablePicking:o}=this.state,{image:l,desaturate:c,transparentColor:B,tintColor:h}=this.props;e.picking.isActive&&o||l&&r&&(r.setUniforms(j),r.setBindings({bitmapTexture:l}),r.setUniforms({desaturate:c,transparentColor:B.map(d=>d/255),tintColor:h.slice(0,3).map(d=>d/255),coordinateConversion:n,bounds:i}),r.draw(this.context.renderPass))}_getCoordinateUniforms(){let{LNGLAT:A,CARTESIAN:j,DEFAULT:e}=qt,{_imageCoordinateSystem:r}=this.props;if(r!==e){let{bounds:n}=this.props;if(!v2(n))throw new Error("_imageCoordinateSystem only supports rectangular bounds");let i=this.context.viewport.resolution?A:j;if(r=r===A?A:j,r===A&&i===j)return{coordinateConversion:-1,bounds:n};if(r===j&&i===A){let o=In([n[0],n[1]]),l=In([n[2],n[3]]);return{coordinateConversion:1,bounds:[o[0],o[1],l[0],l[1]]}}}return{coordinateConversion:0,bounds:[0,0,0,0]}}};ik.layerName="BitmapLayer";ik.defaultProps=GoA;var zB=ik;function boA(t){let[A,j,e]=t,r=(e&240)/256,n=(e&15)/16;return[(A+n)/256,(j+r)/256]}function v2(t){return Number.isFinite(t[0])}var _2=`#version 300 es +`;var MoA={image:{type:"image",value:null,async:!0},bounds:{type:"array",value:[1,0,0,1],compare:!0},_imageCoordinateSystem:qt.DEFAULT,desaturate:{type:"number",min:0,max:1,value:0},transparentColor:{type:"color",value:[0,0,0,0]},tintColor:{type:"color",value:[255,255,255]},textureParameters:{type:"object",ignore:!0,value:null}},sk=class extends gr{getShaders(){return super.getShaders({vs:G2,fs:w2,modules:[Lr,Cr]})}initializeState(){let A=this.getAttributeManager();A.remove(["instancePickingColors"]);let j=!0;A.add({indices:{size:1,isIndexed:!0,update:e=>e.value=this.state.mesh.indices,noAlloc:j},positions:{size:3,type:"float64",fp64:this.use64bitPositions(),update:e=>e.value=this.state.mesh.positions,noAlloc:j},texCoords:{size:2,update:e=>e.value=this.state.mesh.texCoords,noAlloc:j}})}updateState({props:A,oldProps:j,changeFlags:e}){let r=this.getAttributeManager();if(e.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll()),A.bounds!==j.bounds){let n=this.state.mesh,i=this._createMesh();this.state.model.setVertexCount(i.vertexCount);for(let o in i)n&&n[o]!==i[o]&&r.invalidate(o);this.setState({mesh:i,...this._getCoordinateUniforms()})}else A._imageCoordinateSystem!==j._imageCoordinateSystem&&this.setState(this._getCoordinateUniforms())}getPickingInfo(A){let{image:j}=this.props,e=A.info;if(!e.color||!j)return e.bitmap=null,e;let{width:r,height:n}=j;e.index=0;let i=OoA(e.color);return e.bitmap={size:{width:r,height:n},uv:i,pixel:[Math.floor(i[0]*r),Math.floor(i[1]*n)]},e}disablePickingIndex(){this.setState({disablePicking:!0})}restorePickingColors(){this.setState({disablePicking:!1})}_updateAutoHighlight(A){super._updateAutoHighlight({...A,color:this.encodePickingColor(0)})}_createMesh(){let{bounds:A}=this.props,j=A;return F2(A)&&(j=[[A[0],A[1]],[A[0],A[3]],[A[2],A[3]],[A[2],A[1]]]),_F(j,this.context.viewport.resolution)}_getModel(){return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),topology:"triangle-list",isInstanced:!1})}draw(A){let{uniforms:j,moduleParameters:e}=A,{model:r,coordinateConversion:n,bounds:i,disablePicking:o}=this.state,{image:l,desaturate:c,transparentColor:B,tintColor:h}=this.props;e.picking.isActive&&o||l&&r&&(r.setUniforms(j),r.setBindings({bitmapTexture:l}),r.setUniforms({desaturate:c,transparentColor:B.map(d=>d/255),tintColor:h.slice(0,3).map(d=>d/255),coordinateConversion:n,bounds:i}),r.draw(this.context.renderPass))}_getCoordinateUniforms(){let{LNGLAT:A,CARTESIAN:j,DEFAULT:e}=qt,{_imageCoordinateSystem:r}=this.props;if(r!==e){let{bounds:n}=this.props;if(!F2(n))throw new Error("_imageCoordinateSystem only supports rectangular bounds");let i=this.context.viewport.resolution?A:j;if(r=r===A?A:j,r===A&&i===j)return{coordinateConversion:-1,bounds:n};if(r===j&&i===A){let o=In([n[0],n[1]]),l=In([n[2],n[3]]);return{coordinateConversion:1,bounds:[o[0],o[1],l[0],l[1]]}}}return{coordinateConversion:0,bounds:[0,0,0,0]}}};sk.layerName="BitmapLayer";sk.defaultProps=MoA;var zB=sk;function OoA(t){let[A,j,e]=t,r=(e&240)/256,n=(e&15)/16;return[(A+n)/256,(j+r)/256]}function F2(t){return Number.isFinite(t[0])}var P2=`#version 300 es #define SHADER_NAME icon-layer-vertex-shader in vec2 positions; in vec3 instancePositions; @@ -1156,7 +1156,7 @@ vColor = instanceColors; DECKGL_FILTER_COLOR(vColor, geometry); vColorMode = instanceColorModes; } -`;var q2=`#version 300 es +`;var I2=`#version 300 es #define SHADER_NAME icon-layer-fragment-shader precision highp float; uniform float opacity; @@ -1178,7 +1178,7 @@ discard; fragColor = vec4(color, a); DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var woA=1024,FoA=4,G2=()=>{},b2={minFilter:"linear",mipmapFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"},PoA={x:0,y:0,width:0,height:0};function IoA(t){return Math.pow(2,Math.ceil(Math.log2(t)))}function MoA(t,A,j,e){let r=Math.min(j/A.width,e/A.height),n=Math.floor(A.width*r),i=Math.floor(A.height*r);return r===1?{data:A,width:n,height:i}:(t.canvas.height=i,t.canvas.width=n,t.clearRect(0,0,n,i),t.drawImage(A,0,0,A.width,A.height,0,0,n,i),{data:t.canvas,width:n,height:i})}function ok(t){return t&&(t.id||t.url)}function OoA(t,A,j,e){let{width:r,height:n,device:i}=t,o=i.createTexture({format:"rgba8unorm",width:A,height:j,sampler:e}),l=i.createCommandEncoder();return l.copyTextureToTexture({source:t,destination:o,width:r,height:n}),l.finish(),t.destroy(),o}function w2(t,A,j){for(let e=0;ei&&(w2(j,o,r),e=0,r=n+r+A,n=0,o=[]),o.push({icon:c,xOffset:e}),e=e+d+A,n=Math.max(n,h)}}return o.length>0&&w2(j,o,r),{mapping:j,rowHeight:n,xOffset:e,yOffset:r,canvasWidth:i,canvasHeight:IoA(n+r+A)}}function SoA(t,A,j){if(!t||!A)return null;j=j||{};let e={},{iterable:r,objectInfo:n}=Pi(t);for(let i of r){n.index++;let o=A(i,n),l=ok(o);if(!o)throw new Error("Icon is missing.");if(!o.url)throw new Error("Icon url is missing.");!e[l]&&(!j[l]||o.url!==j[l].url)&&(e[l]={...o,source:i,sourceIndex:n.index})}return e}var sk=class{constructor(A,{onUpdate:j=G2,onError:e=G2}){this._loadOptions=null,this._texture=null,this._externalTexture=null,this._mapping={},this._textureParameters=null,this._pendingCount=0,this._autoPacking=!1,this._xOffset=0,this._yOffset=0,this._rowHeight=0,this._buffer=FoA,this._canvasWidth=woA,this._canvasHeight=0,this._canvas=null,this.device=A,this.onUpdate=j,this.onError=e}finalize(){this._texture?.delete()}getTexture(){return this._texture||this._externalTexture}getIconMapping(A){let j=this._autoPacking?ok(A):A;return this._mapping[j]||PoA}setProps({loadOptions:A,autoPacking:j,iconAtlas:e,iconMapping:r,textureParameters:n}){A&&(this._loadOptions=A),j!==void 0&&(this._autoPacking=j),r&&(this._mapping=r),e&&(this._texture?.delete(),this._texture=null,this._externalTexture=e),n&&(this._textureParameters=n)}get isLoaded(){return this._pendingCount===0}packIcons(A,j){if(!this._autoPacking||typeof document>"u")return;let e=Object.values(SoA(A,j,this._mapping)||{});if(e.length>0){let{mapping:r,xOffset:n,yOffset:i,rowHeight:o,canvasHeight:l}=ToA({icons:e,buffer:this._buffer,canvasWidth:this._canvasWidth,mapping:this._mapping,rowHeight:this._rowHeight,xOffset:this._xOffset,yOffset:this._yOffset});this._rowHeight=o,this._mapping=r,this._xOffset=n,this._yOffset=i,this._canvasHeight=l,this._texture||(this._texture=this.device.createTexture({format:"rgba8unorm",width:this._canvasWidth,height:this._canvasHeight,sampler:this._textureParameters||b2})),this._texture.height!==this._canvasHeight&&(this._texture=OoA(this._texture,this._canvasWidth,this._canvasHeight,this._textureParameters||b2)),this.onUpdate(),this._canvas=this._canvas||document.createElement("canvas"),this._loadIcons(e)}}_loadIcons(A){let j=this._canvas.getContext("2d",{willReadFrequently:!0});for(let e of A)this._pendingCount++,As(e.url,this._loadOptions).then(r=>{let n=ok(e),i=this._mapping[n],{x:o,y:l,width:c,height:B}=i,{data:h,width:d,height:k}=MoA(j,r,c,B);this._texture.setSubImageData({data:h,x:o+(c-d)/2,y:l+(B-k)/2,width:d,height:k}),i.width=d,i.height=k,this._texture.generateMipmap(),this.onUpdate()}).catch(r=>{this.onError({url:e.url,source:e.source,sourceIndex:e.sourceIndex,loadOptions:this._loadOptions,error:r})}).finally(()=>{this._pendingCount--})}};var F2=[0,0,0,255],RoA={iconAtlas:{type:"image",value:null,async:!0},iconMapping:{type:"object",value:{},async:!0},sizeScale:{type:"number",value:1,min:0},billboard:!0,sizeUnits:"pixels",sizeMinPixels:{type:"number",min:0,value:0},sizeMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},alphaCutoff:{type:"number",value:.05,min:0,max:1},getPosition:{type:"accessor",value:t=>t.position},getIcon:{type:"accessor",value:t=>t.icon},getColor:{type:"accessor",value:F2},getSize:{type:"accessor",value:1},getAngle:{type:"accessor",value:0},getPixelOffset:{type:"accessor",value:[0,0]},onIconError:{type:"function",value:null,optional:!0},textureParameters:{type:"object",ignore:!0,value:null}},ak=class extends gr{getShaders(){return super.getShaders({vs:_2,fs:q2,modules:[Lr,Cr]})}initializeState(){this.state={iconManager:new sk(this.context.device,{onUpdate:this._onUpdate.bind(this),onError:this._onError.bind(this)})},this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceSizes:{size:1,transition:!0,accessor:"getSize",defaultValue:1},instanceOffsets:{size:2,accessor:"getIcon",transform:this.getInstanceOffset},instanceIconFrames:{size:4,accessor:"getIcon",transform:this.getInstanceIconFrame},instanceColorModes:{size:1,type:"uint8",accessor:"getIcon",transform:this.getInstanceColorMode},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",transition:!0,accessor:"getColor",defaultValue:F2},instanceAngles:{size:1,transition:!0,accessor:"getAngle"},instancePixelOffset:{size:2,transition:!0,accessor:"getPixelOffset"}})}updateState(A){super.updateState(A);let{props:j,oldProps:e,changeFlags:r}=A,n=this.getAttributeManager(),{iconAtlas:i,iconMapping:o,data:l,getIcon:c,textureParameters:B}=j,{iconManager:h}=this.state;if(typeof i=="string")return;let d=i||this.internalState.isAsyncPropLoading("iconAtlas");h.setProps({loadOptions:j.loadOptions,autoPacking:!d,iconAtlas:i,iconMapping:d?o:null,textureParameters:B}),d?e.iconMapping!==j.iconMapping&&n.invalidate("getIcon"):(r.dataChanged||r.updateTriggersChanged&&(r.updateTriggersChanged.all||r.updateTriggersChanged.getIcon))&&h.packIcons(l,c),r.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),n.invalidateAll())}get isLoaded(){return super.isLoaded&&this.state.iconManager.isLoaded}finalizeState(A){super.finalizeState(A),this.state.iconManager.finalize()}draw({uniforms:A}){let{sizeScale:j,sizeMinPixels:e,sizeMaxPixels:r,sizeUnits:n,billboard:i,alphaCutoff:o}=this.props,{iconManager:l}=this.state,c=l.getTexture();if(c){let B=this.state.model;B.setBindings({iconsTexture:c}),B.setUniforms(A),B.setUniforms({iconsTextureDim:[c.width,c.height],sizeUnits:an[n],sizeScale:j,sizeMinPixels:e,sizeMaxPixels:r,billboard:i,alphaCutoff:o}),B.draw(this.context.renderPass)}}_getModel(){let A=[-1,-1,1,-1,-1,1,1,1];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:2,value:new Float32Array(A)}}}),isInstanced:!0})}_onUpdate(){this.setNeedsRedraw()}_onError(A){let j=this.getCurrentLayer()?.props.onIconError;j?j(A):NA.error(A.error.message)()}getInstanceOffset(A){let{width:j,height:e,anchorX:r=j/2,anchorY:n=e/2}=this.state.iconManager.getIconMapping(A);return[j/2-r,e/2-n]}getInstanceColorMode(A){return this.state.iconManager.getIconMapping(A).mask?1:0}getInstanceIconFrame(A){let{x:j,y:e,width:r,height:n}=this.state.iconManager.getIconMapping(A);return[j,e,r,n]}};ak.defaultProps=RoA;ak.layerName="IconLayer";var z7=ak;var P2=`#version 300 es +`;var ToA=1024,SoA=4,M2=()=>{},O2={minFilter:"linear",mipmapFilter:"linear",magFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"},RoA={x:0,y:0,width:0,height:0};function LoA(t){return Math.pow(2,Math.ceil(Math.log2(t)))}function CoA(t,A,j,e){let r=Math.min(j/A.width,e/A.height),n=Math.floor(A.width*r),i=Math.floor(A.height*r);return r===1?{data:A,width:n,height:i}:(t.canvas.height=i,t.canvas.width=n,t.clearRect(0,0,n,i),t.drawImage(A,0,0,A.width,A.height,0,0,n,i),{data:t.canvas,width:n,height:i})}function ak(t){return t&&(t.id||t.url)}function HoA(t,A,j,e){let{width:r,height:n,device:i}=t,o=i.createTexture({format:"rgba8unorm",width:A,height:j,sampler:e}),l=i.createCommandEncoder();return l.copyTextureToTexture({source:t,destination:o,width:r,height:n}),l.finish(),t.destroy(),o}function T2(t,A,j){for(let e=0;ei&&(T2(j,o,r),e=0,r=n+r+A,n=0,o=[]),o.push({icon:c,xOffset:e}),e=e+d+A,n=Math.max(n,h)}}return o.length>0&&T2(j,o,r),{mapping:j,rowHeight:n,xOffset:e,yOffset:r,canvasWidth:i,canvasHeight:LoA(n+r+A)}}function NoA(t,A,j){if(!t||!A)return null;j=j||{};let e={},{iterable:r,objectInfo:n}=Pi(t);for(let i of r){n.index++;let o=A(i,n),l=ak(o);if(!o)throw new Error("Icon is missing.");if(!o.url)throw new Error("Icon url is missing.");!e[l]&&(!j[l]||o.url!==j[l].url)&&(e[l]={...o,source:i,sourceIndex:n.index})}return e}var lk=class{constructor(A,{onUpdate:j=M2,onError:e=M2}){this._loadOptions=null,this._texture=null,this._externalTexture=null,this._mapping={},this._textureParameters=null,this._pendingCount=0,this._autoPacking=!1,this._xOffset=0,this._yOffset=0,this._rowHeight=0,this._buffer=SoA,this._canvasWidth=ToA,this._canvasHeight=0,this._canvas=null,this.device=A,this.onUpdate=j,this.onError=e}finalize(){this._texture?.delete()}getTexture(){return this._texture||this._externalTexture}getIconMapping(A){let j=this._autoPacking?ak(A):A;return this._mapping[j]||RoA}setProps({loadOptions:A,autoPacking:j,iconAtlas:e,iconMapping:r,textureParameters:n}){A&&(this._loadOptions=A),j!==void 0&&(this._autoPacking=j),r&&(this._mapping=r),e&&(this._texture?.delete(),this._texture=null,this._externalTexture=e),n&&(this._textureParameters=n)}get isLoaded(){return this._pendingCount===0}packIcons(A,j){if(!this._autoPacking||typeof document>"u")return;let e=Object.values(NoA(A,j,this._mapping)||{});if(e.length>0){let{mapping:r,xOffset:n,yOffset:i,rowHeight:o,canvasHeight:l}=DoA({icons:e,buffer:this._buffer,canvasWidth:this._canvasWidth,mapping:this._mapping,rowHeight:this._rowHeight,xOffset:this._xOffset,yOffset:this._yOffset});this._rowHeight=o,this._mapping=r,this._xOffset=n,this._yOffset=i,this._canvasHeight=l,this._texture||(this._texture=this.device.createTexture({format:"rgba8unorm",width:this._canvasWidth,height:this._canvasHeight,sampler:this._textureParameters||O2})),this._texture.height!==this._canvasHeight&&(this._texture=HoA(this._texture,this._canvasWidth,this._canvasHeight,this._textureParameters||O2)),this.onUpdate(),this._canvas=this._canvas||document.createElement("canvas"),this._loadIcons(e)}}_loadIcons(A){let j=this._canvas.getContext("2d",{willReadFrequently:!0});for(let e of A)this._pendingCount++,As(e.url,this._loadOptions).then(r=>{let n=ak(e),i=this._mapping[n],{x:o,y:l,width:c,height:B}=i,{data:h,width:d,height:k}=CoA(j,r,c,B);this._texture.setSubImageData({data:h,x:o+(c-d)/2,y:l+(B-k)/2,width:d,height:k}),i.width=d,i.height=k,this._texture.generateMipmap(),this.onUpdate()}).catch(r=>{this.onError({url:e.url,source:e.source,sourceIndex:e.sourceIndex,loadOptions:this._loadOptions,error:r})}).finally(()=>{this._pendingCount--})}};var S2=[0,0,0,255],KoA={iconAtlas:{type:"image",value:null,async:!0},iconMapping:{type:"object",value:{},async:!0},sizeScale:{type:"number",value:1,min:0},billboard:!0,sizeUnits:"pixels",sizeMinPixels:{type:"number",min:0,value:0},sizeMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},alphaCutoff:{type:"number",value:.05,min:0,max:1},getPosition:{type:"accessor",value:t=>t.position},getIcon:{type:"accessor",value:t=>t.icon},getColor:{type:"accessor",value:S2},getSize:{type:"accessor",value:1},getAngle:{type:"accessor",value:0},getPixelOffset:{type:"accessor",value:[0,0]},onIconError:{type:"function",value:null,optional:!0},textureParameters:{type:"object",ignore:!0,value:null}},ck=class extends gr{getShaders(){return super.getShaders({vs:P2,fs:I2,modules:[Lr,Cr]})}initializeState(){this.state={iconManager:new lk(this.context.device,{onUpdate:this._onUpdate.bind(this),onError:this._onError.bind(this)})},this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceSizes:{size:1,transition:!0,accessor:"getSize",defaultValue:1},instanceOffsets:{size:2,accessor:"getIcon",transform:this.getInstanceOffset},instanceIconFrames:{size:4,accessor:"getIcon",transform:this.getInstanceIconFrame},instanceColorModes:{size:1,type:"uint8",accessor:"getIcon",transform:this.getInstanceColorMode},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",transition:!0,accessor:"getColor",defaultValue:S2},instanceAngles:{size:1,transition:!0,accessor:"getAngle"},instancePixelOffset:{size:2,transition:!0,accessor:"getPixelOffset"}})}updateState(A){super.updateState(A);let{props:j,oldProps:e,changeFlags:r}=A,n=this.getAttributeManager(),{iconAtlas:i,iconMapping:o,data:l,getIcon:c,textureParameters:B}=j,{iconManager:h}=this.state;if(typeof i=="string")return;let d=i||this.internalState.isAsyncPropLoading("iconAtlas");h.setProps({loadOptions:j.loadOptions,autoPacking:!d,iconAtlas:i,iconMapping:d?o:null,textureParameters:B}),d?e.iconMapping!==j.iconMapping&&n.invalidate("getIcon"):(r.dataChanged||r.updateTriggersChanged&&(r.updateTriggersChanged.all||r.updateTriggersChanged.getIcon))&&h.packIcons(l,c),r.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),n.invalidateAll())}get isLoaded(){return super.isLoaded&&this.state.iconManager.isLoaded}finalizeState(A){super.finalizeState(A),this.state.iconManager.finalize()}draw({uniforms:A}){let{sizeScale:j,sizeMinPixels:e,sizeMaxPixels:r,sizeUnits:n,billboard:i,alphaCutoff:o}=this.props,{iconManager:l}=this.state,c=l.getTexture();if(c){let B=this.state.model;B.setBindings({iconsTexture:c}),B.setUniforms(A),B.setUniforms({iconsTextureDim:[c.width,c.height],sizeUnits:an[n],sizeScale:j,sizeMinPixels:e,sizeMaxPixels:r,billboard:i,alphaCutoff:o}),B.draw(this.context.renderPass)}}_getModel(){let A=[-1,-1,1,-1,-1,1,1,1];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:2,value:new Float32Array(A)}}}),isInstanced:!0})}_onUpdate(){this.setNeedsRedraw()}_onError(A){let j=this.getCurrentLayer()?.props.onIconError;j?j(A):NA.error(A.error.message)()}getInstanceOffset(A){let{width:j,height:e,anchorX:r=j/2,anchorY:n=e/2}=this.state.iconManager.getIconMapping(A);return[j/2-r,e/2-n]}getInstanceColorMode(A){return this.state.iconManager.getIconMapping(A).mask?1:0}getInstanceIconFrame(A){let{x:j,y:e,width:r,height:n}=this.state.iconManager.getIconMapping(A);return[j,e,r,n]}};ck.defaultProps=KoA;ck.layerName="IconLayer";var z7=ck;var R2=`#version 300 es #define SHADER_NAME point-cloud-layer-vertex-shader in vec3 positions; in vec3 instanceNormals; @@ -1206,7 +1206,7 @@ vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project_uCameraPosi vColor = vec4(lightColor, instanceColors.a * opacity); DECKGL_FILTER_COLOR(vColor, geometry); } -`;var I2=`#version 300 es +`;var L2=`#version 300 es #define SHADER_NAME point-cloud-layer-fragment-shader precision highp float; in vec4 vColor; @@ -1221,7 +1221,7 @@ discard; fragColor = vColor; DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var M2=[0,0,0,255],O2=[0,0,1],LoA={sizeUnits:"pixels",pointSize:{type:"number",min:0,value:10},getPosition:{type:"accessor",value:t=>t.position},getNormal:{type:"accessor",value:O2},getColor:{type:"accessor",value:M2},material:!0,radiusPixels:{deprecatedFor:"pointSize"}};function CoA(t){let{header:A,attributes:j}=t;if(!(!A||!j)&&(t.length=A.vertexCount,j.POSITION&&(j.instancePositions=j.POSITION),j.NORMAL&&(j.instanceNormals=j.NORMAL),j.COLOR_0)){let{size:e,value:r}=j.COLOR_0;j.instanceColors={size:e,type:"unorm8",value:r}}}var lk=class extends gr{getShaders(){return super.getShaders({vs:P2,fs:I2,modules:[Lr,I7,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceNormals:{size:3,transition:!0,accessor:"getNormal",defaultValue:O2},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",transition:!0,accessor:"getColor",defaultValue:M2}})}updateState(A){let{changeFlags:j,props:e}=A;super.updateState(A),j.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll()),j.dataChanged&&CoA(e.data)}draw({uniforms:A}){let{pointSize:j,sizeUnits:e}=this.props,r=this.state.model;r.setUniforms(A),r.setUniforms({sizeUnits:an[e],radiusPixels:j}),r.draw(this.context.renderPass)}_getModel(){let A=[];for(let j=0;j<3;j++){let e=j/3*Math.PI*2;A.push(Math.cos(e)*2,Math.sin(e)*2,0)}return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-list",attributes:{positions:new Float32Array(A)}}),isInstanced:!0})}};lk.layerName="PointCloudLayer";lk.defaultProps=LoA;var Bx=lk;var T2=`#version 300 es +`;var C2=[0,0,0,255],H2=[0,0,1],XoA={sizeUnits:"pixels",pointSize:{type:"number",min:0,value:10},getPosition:{type:"accessor",value:t=>t.position},getNormal:{type:"accessor",value:H2},getColor:{type:"accessor",value:C2},material:!0,radiusPixels:{deprecatedFor:"pointSize"}};function zoA(t){let{header:A,attributes:j}=t;if(!(!A||!j)&&(t.length=A.vertexCount,j.POSITION&&(j.instancePositions=j.POSITION),j.NORMAL&&(j.instanceNormals=j.NORMAL),j.COLOR_0)){let{size:e,value:r}=j.COLOR_0;j.instanceColors={size:e,type:"unorm8",value:r}}}var uk=class extends gr{getShaders(){return super.getShaders({vs:R2,fs:L2,modules:[Lr,I7,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceNormals:{size:3,transition:!0,accessor:"getNormal",defaultValue:H2},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",transition:!0,accessor:"getColor",defaultValue:C2}})}updateState(A){let{changeFlags:j,props:e}=A;super.updateState(A),j.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll()),j.dataChanged&&zoA(e.data)}draw({uniforms:A}){let{pointSize:j,sizeUnits:e}=this.props,r=this.state.model;r.setUniforms(A),r.setUniforms({sizeUnits:an[e],radiusPixels:j}),r.draw(this.context.renderPass)}_getModel(){let A=[];for(let j=0;j<3;j++){let e=j/3*Math.PI*2;A.push(Math.cos(e)*2,Math.sin(e)*2,0)}return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-list",attributes:{positions:new Float32Array(A)}}),isInstanced:!0})}};uk.layerName="PointCloudLayer";uk.defaultProps=XoA;var kx=uk;var D2=`#version 300 es #define SHADER_NAME scatterplot-layer-vertex-shader in vec3 positions; in vec3 instancePositions; @@ -1282,7 +1282,7 @@ DECKGL_FILTER_COLOR(vFillColor, geometry); vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); DECKGL_FILTER_COLOR(vLineColor, geometry); } -`;var S2=`#version 300 es +`;var N2=`#version 300 es #define SHADER_NAME scatterplot-layer-fragment-shader precision highp float; uniform bool filled; @@ -1323,7 +1323,7 @@ fragColor = vFillColor; fragColor.a *= inCircle; DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var R2=[0,0,0,255],HoA={radiusUnits:"meters",radiusScale:{type:"number",min:0,value:1},radiusMinPixels:{type:"number",min:0,value:0},radiusMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},lineWidthUnits:"meters",lineWidthScale:{type:"number",min:0,value:1},lineWidthMinPixels:{type:"number",min:0,value:0},lineWidthMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},stroked:!1,filled:!0,billboard:!1,antialiasing:!0,getPosition:{type:"accessor",value:t=>t.position},getRadius:{type:"accessor",value:1},getFillColor:{type:"accessor",value:R2},getLineColor:{type:"accessor",value:R2},getLineWidth:{type:"accessor",value:1},strokeWidth:{deprecatedFor:"getLineWidth"},outline:{deprecatedFor:"stroked"},getColor:{deprecatedFor:["getFillColor","getLineColor"]}},ck=class extends gr{getShaders(){return super.getShaders({vs:T2,fs:S2,modules:[Lr,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceRadius:{size:1,transition:!0,accessor:"getRadius",defaultValue:1},instanceFillColors:{size:this.props.colorFormat.length,transition:!0,type:"unorm8",accessor:"getFillColor",defaultValue:[0,0,0,255]},instanceLineColors:{size:this.props.colorFormat.length,transition:!0,type:"unorm8",accessor:"getLineColor",defaultValue:[0,0,0,255]},instanceLineWidths:{size:1,transition:!0,accessor:"getLineWidth",defaultValue:1}})}updateState(A){super.updateState(A),A.changeFlags.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:A}){let{radiusUnits:j,radiusScale:e,radiusMinPixels:r,radiusMaxPixels:n,stroked:i,filled:o,billboard:l,antialiasing:c,lineWidthUnits:B,lineWidthScale:h,lineWidthMinPixels:d,lineWidthMaxPixels:k}=this.props,g=this.state.model;g.setUniforms(A),g.setUniforms({stroked:i?1:0,filled:o,billboard:l,antialiasing:c,radiusUnits:an[j],radiusScale:e,radiusMinPixels:r,radiusMaxPixels:n,lineWidthUnits:an[B],lineWidthScale:h,lineWidthMinPixels:d,lineWidthMaxPixels:k}),g.draw(this.context.renderPass)}_getModel(){let A=[-1,-1,0,1,-1,0,-1,1,0,1,1,0];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:3,value:new Float32Array(A)}}}),isInstanced:!0})}};ck.defaultProps=HoA;ck.layerName="ScatterplotLayer";var mr=ck;var fx={CLOCKWISE:1,COUNTER_CLOCKWISE:-1};function uk(t,A,j={}){return L2(t,j)!==A?(DoA(t,j),!0):!1}function L2(t,A={}){return Math.sign(hx(t,A))}var $F={x:0,y:1,z:2};function hx(t,A={}){let{start:j=0,end:e=t.length,plane:r="xy"}=A,n=A.size||2,i=0,o=$F[r[0]],l=$F[r[1]];for(let c=j,B=e-n;c0){let r=!0;for(let n=0;nA[2]&&(j|=2),t[1]A[3]&&(j|=8),j}function hk(t,A){let{size:j=2,broken:e=!1,gridResolution:r=10,gridOffset:n=[0,0],startIndex:i=0,endIndex:o=t.length}=A||{},l=(o-i)/j,c=[],B=[c],h=U7(t,0,j,i),d,k,g=D2(h,r,n,[]),E=[];b6(c,h);for(let m=1;mj&&(c=[],B.push(c),b6(c,h)),k=fk(d,g)}b6(c,d),Bk(h,d)}return e?B:B[0]}var C2=0,KoA=1;function dk(t,A=null,j){if(!t.length)return[];let{size:e=2,gridResolution:r=10,gridOffset:n=[0,0],edgeTypes:i=!1}=j||{},o=[],l=[{pos:t,types:i?new Array(t.length/e).fill(KoA):null,holes:A||[]}],c=[[],[]],B=[];for(;l.length;){let{pos:h,types:d,holes:k}=l.shift();zoA(h,e,k[0]||h.length,c),B=D2(c[0],r,n,B);let g=fk(c[1],B);if(g){let E=H2(h,d,e,0,k[0]||h.length,B,g),m={pos:E[0].pos,types:E[0].types,holes:[]},y={pos:E[1].pos,types:E[1].types,holes:[]};l.push(m,y);for(let b=0;b=0?(b6(c,k)&&h.push(E),_+=g):h.length&&(h[h.length-1]=C2),Bk(m,k),y=g,b=E;return[v?{pos:l,types:A&&B}:null,_?{pos:c,types:A&&h}:null]}function D2(t,A,j,e){let r=Math.floor((t[0]-j[0])/A)*A+j[0],n=Math.floor((t[1]-j[1])/A)*A+j[1];return e[0]=r,e[1]=n,e[2]=r+A,e[3]=n+A,e}function XoA(t,A,j){j&8?(t[1]+=A,t[3]+=A):j&4?(t[1]-=A,t[3]-=A):j&2?(t[0]+=A,t[2]+=A):j&1&&(t[0]-=A,t[2]-=A)}function zoA(t,A,j,e){let r=1/0,n=-1/0,i=1/0,o=-1/0;for(let l=0;ln?c:n,i=Bo?B:o}return e[0][0]=r,e[0][1]=i,e[1][0]=n,e[1][1]=o,e}function px(t,A){for(let j=0;jr&&(r=o,n=i-1)}return n}function QoA(t,A,j,e,r=UoA){let n=t[j],i=t[e-A];if(Math.abs(n-i)>180){let o=U7(t,0,A,j);o[0]+=Math.round((i-n)/360)*360,b6(t,o),o[1]=Math.sign(o[1])*r,b6(t,o),o[0]=n,b6(t,o)}}function N2(t,A,j,e){let r=t[0],n;for(let i=j;i180||o<-180)&&(n-=Math.round(o/360)*360),t[i]=r=n}}function K2(t,A){let j,e=t.length/A;for(let n=0;n=A.length&&(j+=1-A.length/r);let n=j*r;return e[0]=A[n],e[1]=A[n+1],e[2]=r===3&&A[n+2]||0,e}isClosed(A){if(!this.normalize)return!!this.opts.loop;let{positionSize:j}=this,e=A.length-j;return A[0]===A[e]&&A[1]===A[e+1]&&(j===2||A[2]===A[e+2])}};function z2(t){return Array.isArray(t[0])}var U2=`#version 300 es +`;var K2=[0,0,0,255],UoA={radiusUnits:"meters",radiusScale:{type:"number",min:0,value:1},radiusMinPixels:{type:"number",min:0,value:0},radiusMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},lineWidthUnits:"meters",lineWidthScale:{type:"number",min:0,value:1},lineWidthMinPixels:{type:"number",min:0,value:0},lineWidthMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},stroked:!1,filled:!0,billboard:!1,antialiasing:!0,getPosition:{type:"accessor",value:t=>t.position},getRadius:{type:"accessor",value:1},getFillColor:{type:"accessor",value:K2},getLineColor:{type:"accessor",value:K2},getLineWidth:{type:"accessor",value:1},strokeWidth:{deprecatedFor:"getLineWidth"},outline:{deprecatedFor:"stroked"},getColor:{deprecatedFor:["getFillColor","getLineColor"]}},Bk=class extends gr{getShaders(){return super.getShaders({vs:D2,fs:N2,modules:[Lr,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceRadius:{size:1,transition:!0,accessor:"getRadius",defaultValue:1},instanceFillColors:{size:this.props.colorFormat.length,transition:!0,type:"unorm8",accessor:"getFillColor",defaultValue:[0,0,0,255]},instanceLineColors:{size:this.props.colorFormat.length,transition:!0,type:"unorm8",accessor:"getLineColor",defaultValue:[0,0,0,255]},instanceLineWidths:{size:1,transition:!0,accessor:"getLineWidth",defaultValue:1}})}updateState(A){super.updateState(A),A.changeFlags.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:A}){let{radiusUnits:j,radiusScale:e,radiusMinPixels:r,radiusMaxPixels:n,stroked:i,filled:o,billboard:l,antialiasing:c,lineWidthUnits:B,lineWidthScale:h,lineWidthMinPixels:d,lineWidthMaxPixels:k}=this.props,g=this.state.model;g.setUniforms(A),g.setUniforms({stroked:i?1:0,filled:o,billboard:l,antialiasing:c,radiusUnits:an[j],radiusScale:e,radiusMinPixels:r,radiusMaxPixels:n,lineWidthUnits:an[B],lineWidthScale:h,lineWidthMinPixels:d,lineWidthMaxPixels:k}),g.draw(this.context.renderPass)}_getModel(){let A=[-1,-1,0,1,-1,0,-1,1,0,1,1,0];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:3,value:new Float32Array(A)}}}),isInstanced:!0})}};Bk.defaultProps=UoA;Bk.layerName="ScatterplotLayer";var mr=Bk;var gx={CLOCKWISE:1,COUNTER_CLOCKWISE:-1};function fk(t,A,j={}){return X2(t,j)!==A?(VoA(t,j),!0):!1}function X2(t,A={}){return Math.sign(mx(t,A))}var qF={x:0,y:1,z:2};function mx(t,A={}){let{start:j=0,end:e=t.length,plane:r="xy"}=A,n=A.size||2,i=0,o=qF[r[0]],l=qF[r[1]];for(let c=j,B=e-n;c0){let r=!0;for(let n=0;nA[2]&&(j|=2),t[1]A[3]&&(j|=8),j}function pk(t,A){let{size:j=2,broken:e=!1,gridResolution:r=10,gridOffset:n=[0,0],startIndex:i=0,endIndex:o=t.length}=A||{},l=(o-i)/j,c=[],B=[c],h=U7(t,0,j,i),d,k,g=V2(h,r,n,[]),E=[];G6(c,h);for(let m=1;mj&&(c=[],B.push(c),G6(c,h)),k=dk(d,g)}G6(c,d),hk(h,d)}return e?B:B[0]}var z2=0,WoA=1;function kk(t,A=null,j){if(!t.length)return[];let{size:e=2,gridResolution:r=10,gridOffset:n=[0,0],edgeTypes:i=!1}=j||{},o=[],l=[{pos:t,types:i?new Array(t.length/e).fill(WoA):null,holes:A||[]}],c=[[],[]],B=[];for(;l.length;){let{pos:h,types:d,holes:k}=l.shift();JoA(h,e,k[0]||h.length,c),B=V2(c[0],r,n,B);let g=dk(c[1],B);if(g){let E=U2(h,d,e,0,k[0]||h.length,B,g),m={pos:E[0].pos,types:E[0].types,holes:[]},y={pos:E[1].pos,types:E[1].types,holes:[]};l.push(m,y);for(let G=0;G=0?(G6(c,k)&&h.push(E),_+=g):h.length&&(h[h.length-1]=z2),hk(m,k),y=g,G=E;return[v?{pos:l,types:A&&B}:null,_?{pos:c,types:A&&h}:null]}function V2(t,A,j,e){let r=Math.floor((t[0]-j[0])/A)*A+j[0],n=Math.floor((t[1]-j[1])/A)*A+j[1];return e[0]=r,e[1]=n,e[2]=r+A,e[3]=n+A,e}function YoA(t,A,j){j&8?(t[1]+=A,t[3]+=A):j&4?(t[1]-=A,t[3]-=A):j&2?(t[0]+=A,t[2]+=A):j&1&&(t[0]-=A,t[2]-=A)}function JoA(t,A,j,e){let r=1/0,n=-1/0,i=1/0,o=-1/0;for(let l=0;ln?c:n,i=Bo?B:o}return e[0][0]=r,e[0][1]=i,e[1][0]=n,e[1][1]=o,e}function $x(t,A){for(let j=0;jr&&(r=o,n=i-1)}return n}function tsA(t,A,j,e,r=ZoA){let n=t[j],i=t[e-A];if(Math.abs(n-i)>180){let o=U7(t,0,A,j);o[0]+=Math.round((i-n)/360)*360,G6(t,o),o[1]=Math.sign(o[1])*r,G6(t,o),o[0]=n,G6(t,o)}}function Q2(t,A,j,e){let r=t[0],n;for(let i=j;i180||o<-180)&&(n-=Math.round(o/360)*360),t[i]=r=n}}function W2(t,A){let j,e=t.length/A;for(let n=0;n=A.length&&(j+=1-A.length/r);let n=j*r;return e[0]=A[n],e[1]=A[n+1],e[2]=r===3&&A[n+2]||0,e}isClosed(A){if(!this.normalize)return!!this.opts.loop;let{positionSize:j}=this,e=A.length-j;return A[0]===A[e]&&A[1]===A[e+1]&&(j===2||A[2]===A[e+2])}};function J2(t){return Array.isArray(t[0])}var Z2=`#version 300 es #define SHADER_NAME path-layer-vertex-shader in vec2 positions; in float instanceTypes; @@ -1476,7 +1476,7 @@ DECKGL_FILTER_GL_POSITION(gl_Position, geometry); } DECKGL_FILTER_COLOR(vColor, geometry); } -`;var V2=`#version 300 es +`;var AC=`#version 300 es #define SHADER_NAME path-layer-fragment-shader precision highp float; uniform float miterLimit; @@ -1500,7 +1500,7 @@ discard; fragColor = vColor; DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var Q2=[0,0,0,255],ZoA={widthUnits:"meters",widthScale:{type:"number",min:0,value:1},widthMinPixels:{type:"number",min:0,value:0},widthMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},jointRounded:!1,capRounded:!1,miterLimit:{type:"number",min:0,value:4},billboard:!1,_pathType:null,getPath:{type:"accessor",value:t=>t.path},getColor:{type:"accessor",value:Q2},getWidth:{type:"accessor",value:1},rounded:{deprecatedFor:["jointRounded","capRounded"]}},_F={enter:(t,A)=>A.length?A.subarray(A.length-t.length):t},kk=class extends gr{getShaders(){return super.getShaders({vs:U2,fs:V2,modules:[Lr,Cr]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds(["vertexPositions"])}initializeState(){this.getAttributeManager().addInstanced({vertexPositions:{size:3,vertexOffset:1,type:"float64",fp64:this.use64bitPositions(),transition:_F,accessor:"getPath",update:this.calculatePositions,noAlloc:!0,shaderAttributes:{instanceLeftPositions:{vertexOffset:0},instanceStartPositions:{vertexOffset:1},instanceEndPositions:{vertexOffset:2},instanceRightPositions:{vertexOffset:3}}},instanceTypes:{size:1,type:"uint8",update:this.calculateSegmentTypes,noAlloc:!0},instanceStrokeWidths:{size:1,accessor:"getWidth",transition:_F,defaultValue:1},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",accessor:"getColor",transition:_F,defaultValue:Q2},instancePickingColors:{size:4,type:"uint8",accessor:(e,{index:r,target:n})=>this.encodePickingColor(e&&e.__source?e.__source.index:r,n)}}),this.setState({pathTesselator:new pk({fp64:this.use64bitPositions()})})}updateState(A){super.updateState(A);let{props:j,changeFlags:e}=A,r=this.getAttributeManager();if(e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPath)){let{pathTesselator:i}=this.state,o=j.data.attributes||{};i.updateGeometry({data:j.data,geometryBuffer:o.getPath,buffers:o,normalize:!j._pathType,loop:j._pathType==="loop",getGeometry:j.getPath,positionFormat:j.positionFormat,wrapLongitude:j.wrapLongitude,resolution:this.context.viewport.resolution,dataChanged:e.dataChanged}),this.setState({numInstances:i.instanceCount,startIndices:i.vertexStarts}),e.dataChanged||r.invalidateAll()}e.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll())}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e}=j,r=this.props.data;return r[0]&&r[0].__source&&(j.object=r.find(n=>n.__source.index===e)),j}disablePickingIndex(A){let j=this.props.data;if(j[0]&&j[0].__source)for(let e=0;e=1&&t[0].length>=2&&Number.isFinite(t[0][0])}function ksA(t){let A=t[0],j=t[t.length-1];return A[0]===j[0]&&A[1]===j[1]&&A[2]===j[2]}function gsA(t,A,j,e){for(let r=0;ro/A));let n=VB(t),i=e&&A===3;if(j){let o=n.length;n=n.slice();let l=[];for(let c=0;cl&&o>c||(l>c?(j||(n=n.slice()),rC(n,0,2,1)):(j||(n=n.slice()),rC(n,2,0,1)))}return(0,nC.default)(n,r,A)}var xk=class extends Ra{constructor(A){let{fp64:j,IndexType:e=Uint32Array}=A;super({...A,attributes:{positions:{size:3,type:j?Float64Array:Float32Array},vertexValid:{type:Uint16Array,size:1},indices:{type:e,size:1}}})}get(A){let{attributes:j}=this;return A==="indices"?j.indices&&j.indices.subarray(0,this.vertexCount):j[A]}updateGeometry(A){super.updateGeometry(A);let j=this.buffers.indices;if(j)this.vertexCount=(j.value||j).length;else if(this.data&&!this.getGeometry)throw new Error("missing indices buffer")}normalizeGeometry(A){if(this.normalize){let j=xx(A,this.positionSize);return this.opts.resolution?dk(VB(j),$k(j),{size:this.positionSize,gridResolution:this.opts.resolution,edgeTypes:!0}):this.opts.wrapLongitude?yF(VB(j),$k(j),{size:this.positionSize,maxLatitude:86,edgeTypes:!0}):j}return A}getGeometrySize(A){if(sC(A)){let j=0;for(let e of A)j+=this.getGeometrySize(e);return j}return VB(A).length/this.positionSize}getGeometryFromBuffer(A){return this.normalize||!this.buffers.indices?super.getGeometryFromBuffer(A):null}updateGeometryAttributes(A,j){if(A&&sC(A))for(let e of A){let r=this.getGeometrySize(e);j.geometrySize=r,this.updateGeometryAttributes(e,j),j.vertexStart+=r,j.indexStart=this.indexStarts[j.geometryIndex+1]}else{let e=A;this._updateIndices(e,j),this._updatePositions(e,j),this._updateVertexValid(e,j)}}_updateIndices(A,{geometryIndex:j,vertexStart:e,indexStart:r}){let{attributes:n,indexStarts:i,typedArrayManager:o}=this,l=n.indices;if(!l||!A)return;let c=r,B=iC(A,this.positionSize,this.opts.preproject,this.opts.full3d);l=o.allocate(l,r+B.length,{copy:!0});for(let h=0;h2?i[l*n+2]:0;r[o*3]=c,r[o*3+1]=B,r[o*3+2]=h}}_updateVertexValid(A,{vertexStart:j,geometrySize:e}){let{positionSize:r}=this,n=this.attributes.vertexValid,i=A&&$k(A);if(A&&A.edgeTypes?n.set(A.edgeTypes,j):n.fill(1,j,j+e),i)for(let o=0;o0&&!Number.isFinite(t[0])}var yx=`uniform bool extruded; +`;var tC=[0,0,0,255],nsA={widthUnits:"meters",widthScale:{type:"number",min:0,value:1},widthMinPixels:{type:"number",min:0,value:0},widthMaxPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER},jointRounded:!1,capRounded:!1,miterLimit:{type:"number",min:0,value:4},billboard:!1,_pathType:null,getPath:{type:"accessor",value:t=>t.path},getColor:{type:"accessor",value:tC},getWidth:{type:"accessor",value:1},rounded:{deprecatedFor:["jointRounded","capRounded"]}},FF={enter:(t,A)=>A.length?A.subarray(A.length-t.length):t},mk=class extends gr{getShaders(){return super.getShaders({vs:Z2,fs:AC,modules:[Lr,Cr]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds(["vertexPositions"])}initializeState(){this.getAttributeManager().addInstanced({vertexPositions:{size:3,vertexOffset:1,type:"float64",fp64:this.use64bitPositions(),transition:FF,accessor:"getPath",update:this.calculatePositions,noAlloc:!0,shaderAttributes:{instanceLeftPositions:{vertexOffset:0},instanceStartPositions:{vertexOffset:1},instanceEndPositions:{vertexOffset:2},instanceRightPositions:{vertexOffset:3}}},instanceTypes:{size:1,type:"uint8",update:this.calculateSegmentTypes,noAlloc:!0},instanceStrokeWidths:{size:1,accessor:"getWidth",transition:FF,defaultValue:1},instanceColors:{size:this.props.colorFormat.length,type:"unorm8",accessor:"getColor",transition:FF,defaultValue:tC},instancePickingColors:{size:4,type:"uint8",accessor:(e,{index:r,target:n})=>this.encodePickingColor(e&&e.__source?e.__source.index:r,n)}}),this.setState({pathTesselator:new gk({fp64:this.use64bitPositions()})})}updateState(A){super.updateState(A);let{props:j,changeFlags:e}=A,r=this.getAttributeManager();if(e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPath)){let{pathTesselator:i}=this.state,o=j.data.attributes||{};i.updateGeometry({data:j.data,geometryBuffer:o.getPath,buffers:o,normalize:!j._pathType,loop:j._pathType==="loop",getGeometry:j.getPath,positionFormat:j.positionFormat,wrapLongitude:j.wrapLongitude,resolution:this.context.viewport.resolution,dataChanged:e.dataChanged}),this.setState({numInstances:i.instanceCount,startIndices:i.vertexStarts}),e.dataChanged||r.invalidateAll()}e.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll())}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e}=j,r=this.props.data;return r[0]&&r[0].__source&&(j.object=r.find(n=>n.__source.index===e)),j}disablePickingIndex(A){let j=this.props.data;if(j[0]&&j[0].__source)for(let e=0;e=1&&t[0].length>=2&&Number.isFinite(t[0][0])}function ysA(t){let A=t[0],j=t[t.length-1];return A[0]===j[0]&&A[1]===j[1]&&A[2]===j[2]}function vsA(t,A,j,e){for(let r=0;ro/A));let n=VB(t),i=e&&A===3;if(j){let o=n.length;n=n.slice();let l=[];for(let c=0;cl&&o>c||(l>c?(j||(n=n.slice()),lC(n,0,2,1)):(j||(n=n.slice()),lC(n,2,0,1)))}return(0,cC.default)(n,r,A)}var vk=class extends Ra{constructor(A){let{fp64:j,IndexType:e=Uint32Array}=A;super({...A,attributes:{positions:{size:3,type:j?Float64Array:Float32Array},vertexValid:{type:Uint16Array,size:1},indices:{type:e,size:1}}})}get(A){let{attributes:j}=this;return A==="indices"?j.indices&&j.indices.subarray(0,this.vertexCount):j[A]}updateGeometry(A){super.updateGeometry(A);let j=this.buffers.indices;if(j)this.vertexCount=(j.value||j).length;else if(this.data&&!this.getGeometry)throw new Error("missing indices buffer")}normalizeGeometry(A){if(this.normalize){let j=bx(A,this.positionSize);return this.opts.resolution?kk(VB(j),yk(j),{size:this.positionSize,gridResolution:this.opts.resolution,edgeTypes:!0}):this.opts.wrapLongitude?GF(VB(j),yk(j),{size:this.positionSize,maxLatitude:86,edgeTypes:!0}):j}return A}getGeometrySize(A){if(fC(A)){let j=0;for(let e of A)j+=this.getGeometrySize(e);return j}return VB(A).length/this.positionSize}getGeometryFromBuffer(A){return this.normalize||!this.buffers.indices?super.getGeometryFromBuffer(A):null}updateGeometryAttributes(A,j){if(A&&fC(A))for(let e of A){let r=this.getGeometrySize(e);j.geometrySize=r,this.updateGeometryAttributes(e,j),j.vertexStart+=r,j.indexStart=this.indexStarts[j.geometryIndex+1]}else{let e=A;this._updateIndices(e,j),this._updatePositions(e,j),this._updateVertexValid(e,j)}}_updateIndices(A,{geometryIndex:j,vertexStart:e,indexStart:r}){let{attributes:n,indexStarts:i,typedArrayManager:o}=this,l=n.indices;if(!l||!A)return;let c=r,B=uC(A,this.positionSize,this.opts.preproject,this.opts.full3d);l=o.allocate(l,r+B.length,{copy:!0});for(let h=0;h2?i[l*n+2]:0;r[o*3]=c,r[o*3+1]=B,r[o*3+2]=h}}_updateVertexValid(A,{vertexStart:j,geometrySize:e}){let{positionSize:r}=this,n=this.attributes.vertexValid,i=A&&yk(A);if(A&&A.edgeTypes?n.set(A.edgeTypes,j):n.fill(1,j,j+e),i)for(let o=0;o0&&!Number.isFinite(t[0])}var Gx=`uniform bool extruded; uniform bool isWireframe; uniform float elevationScale; uniform float opacity; @@ -1547,12 +1547,12 @@ vColor = vec4(colors.rgb, colors.a * opacity); } DECKGL_FILTER_COLOR(vColor, geometry); } -`;var aC=`#version 300 es +`;var hC=`#version 300 es #define SHADER_NAME solid-polygon-layer-vertex-shader in vec3 vertexPositions; in vec3 vertexPositions64Low; in float elevations; -${yx} +${Gx} void main(void) { PolygonProps props; props.positions = vertexPositions; @@ -1561,7 +1561,7 @@ props.elevations = elevations; props.normal = vec3(0.0, 0.0, 1.0); calculatePosition(props); } -`;var lC=`#version 300 es +`;var dC=`#version 300 es #define SHADER_NAME solid-polygon-layer-vertex-shader-side #define IS_SIDE_VERTEX in vec2 positions; @@ -1571,7 +1571,7 @@ in vec3 vertexPositions64Low; in vec3 nextVertexPositions64Low; in float elevations; in float instanceVertexValid; -${yx} +${Gx} void main(void) { if(instanceVertexValid < 0.5){ gl_Position = vec4(0.); @@ -1602,7 +1602,7 @@ nextPos.x - pos.x + (nextPos64Low.x - pos64Low.x), props.elevations = elevations * positions.y; calculatePosition(props); } -`;var cC=`#version 300 es +`;var pC=`#version 300 es #define SHADER_NAME solid-polygon-layer-fragment-shader precision highp float; in vec4 vColor; @@ -1612,7 +1612,7 @@ fragColor = vColor; geometry.uv = vec2(0.); DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var _x=[0,0,0,255],msA={filled:!0,extruded:!1,wireframe:!1,_normalize:!0,_windingOrder:"CW",_full3d:!1,elevationScale:{type:"number",min:0,value:1},getPolygon:{type:"accessor",value:t=>t.polygon},getElevation:{type:"accessor",value:1e3},getFillColor:{type:"accessor",value:_x},getLineColor:{type:"accessor",value:_x},material:!0},vx={enter:(t,A)=>A.length?A.subarray(A.length-t.length):t},yk=class extends gr{getShaders(A){return super.getShaders({vs:A==="top"?aC:lC,fs:cC,defines:{RING_WINDING_ORDER_CW:!this.props._normalize&&this.props._windingOrder==="CCW"?0:1},modules:[Lr,I7,Cr]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds(["vertexPositions"])}initializeState(){let{viewport:A}=this.context,{coordinateSystem:j}=this.props,{_full3d:e}=this.props;A.isGeospatial&&j===qt.DEFAULT&&(j=qt.LNGLAT);let r;j===qt.LNGLAT&&(e?r=A.projectPosition.bind(A):r=A.projectFlat.bind(A)),this.setState({numInstances:0,polygonTesselator:new xk({preproject:r,fp64:this.use64bitPositions(),IndexType:Uint32Array})});let n=this.getAttributeManager(),i=!0;n.remove(["instancePickingColors"]),n.add({indices:{size:1,isIndexed:!0,update:this.calculateIndices,noAlloc:i},vertexPositions:{size:3,type:"float64",stepMode:"dynamic",fp64:this.use64bitPositions(),transition:vx,accessor:"getPolygon",update:this.calculatePositions,noAlloc:i,shaderAttributes:{nextVertexPositions:{vertexOffset:1}}},instanceVertexValid:{size:1,type:"uint16",stepMode:"instance",update:this.calculateVertexValid,noAlloc:i},elevations:{size:1,stepMode:"dynamic",transition:vx,accessor:"getElevation"},fillColors:{size:this.props.colorFormat.length,type:"unorm8",stepMode:"dynamic",transition:vx,accessor:"getFillColor",defaultValue:_x},lineColors:{size:this.props.colorFormat.length,type:"unorm8",stepMode:"dynamic",transition:vx,accessor:"getLineColor",defaultValue:_x},pickingColors:{size:4,type:"uint8",stepMode:"dynamic",accessor:(o,{index:l,target:c})=>this.encodePickingColor(o&&o.__source?o.__source.index:l,c)}})}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e}=j,r=this.props.data;return r[0]&&r[0].__source&&(j.object=r.find(n=>n.__source.index===e)),j}disablePickingIndex(A){let j=this.props.data;if(j[0]&&j[0].__source)for(let e=0;eo.destroy()),this.setState(this._getModels()),n.invalidateAll())}updateGeometry({props:A,oldProps:j,changeFlags:e}){if(e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPolygon)){let{polygonTesselator:n}=this.state,i=A.data.attributes||{};n.updateGeometry({data:A.data,normalize:A._normalize,geometryBuffer:i.getPolygon,buffers:i,getGeometry:A.getPolygon,positionFormat:A.positionFormat,wrapLongitude:A.wrapLongitude,resolution:this.context.viewport.resolution,fp64:this.use64bitPositions(),dataChanged:e.dataChanged,full3d:A._full3d}),this.setState({numInstances:n.instanceCount,startIndices:n.vertexStarts}),e.dataChanged||this.getAttributeManager().invalidateAll()}}_getModels(){let{id:A,filled:j,extruded:e}=this.props,r,n,i;if(j){let o=this.getShaders("top");o.defines.NON_INSTANCED_MODEL=1;let l=this.getAttributeManager().getBufferLayouts({isInstanced:!1});r=new ke(this.context.device,{...o,id:`${A}-top`,topology:"triangle-list",uniforms:{isWireframe:!1},bufferLayout:l,isIndexed:!0,userData:{excludeAttributes:{instanceVertexValid:!0}}})}if(e){let o=this.getAttributeManager().getBufferLayouts({isInstanced:!0});n=new ke(this.context.device,{...this.getShaders("side"),id:`${A}-side`,bufferLayout:o,uniforms:{isWireframe:!1},geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,1,1,0,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}}),i=new ke(this.context.device,{...this.getShaders("side"),id:`${A}-wireframe`,bufferLayout:o,uniforms:{isWireframe:!0},geometry:new ln({topology:"line-strip",attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,0,1,1,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}})}return{models:[n,i,r].filter(Boolean),topModel:r,sideModel:n,wireframeModel:i}}calculateIndices(A){let{polygonTesselator:j}=this.state;A.startIndices=j.indexStarts,A.value=j.get("indices")}calculatePositions(A){let{polygonTesselator:j}=this.state;A.startIndices=j.vertexStarts,A.value=j.get("positions")}calculateVertexValid(A){A.value=this.state.polygonTesselator.get("vertexValid")}};yk.defaultProps=msA;yk.layerName="SolidPolygonLayer";var Q7=yk;function qx({data:t,getIndex:A,dataRange:j,replace:e}){let{startRow:r=0,endRow:n=1/0}=j,i=t.length,o=i,l=i;for(let d=0;dd&&k>=r&&(o=d),k>=n){l=d;break}}let c=o,h=l-o!==e.length?t.slice(l):void 0;for(let d=0;dt.polygon},getFillColor:{type:"accessor",value:EsA},getLineColor:{type:"accessor",value:uC},getLineWidth:{type:"accessor",value:1},getElevation:{type:"accessor",value:1e3},material:!0},vk=class extends G6{initializeState(){this.state={paths:[],pathsDiff:null},this.props.getLineDashArray&&NA.removed("getLineDashArray","PathStyleExtension")()}updateState({changeFlags:A}){let j=A.dataChanged||A.updateTriggersChanged&&(A.updateTriggersChanged.all||A.updateTriggersChanged.getPolygon);if(j&&Array.isArray(A.dataChanged)){let e=this.state.paths.slice(),r=A.dataChanged.map(n=>qx({data:e,getIndex:i=>i.__source.index,dataRange:n,replace:this._getPaths(n)}));this.setState({paths:e,pathsDiff:r})}else j&&this.setState({paths:this._getPaths(),pathsDiff:null})}_getPaths(A={}){let{data:j,getPolygon:e,positionFormat:r,_normalize:n}=this.props,i=[],o=r==="XY"?2:3,{startRow:l,endRow:c}=A,{iterable:B,objectInfo:h}=Pi(j,l,c);for(let d of B){h.index++;let k=e(d,h);n&&(k=xx(k,o));let{holeIndices:g}=k,E=k.positions||k;if(g)for(let m=0;m<=g.length;m++){let y=E.slice(g[m-1]||0,g[m]||E.length);i.push(this.getSubLayerRow({path:y},d,h.index))}else i.push(this.getSubLayerRow({path:E},d,h.index))}return i}renderLayers(){let{data:A,_dataDiff:j,stroked:e,filled:r,extruded:n,wireframe:i,_normalize:o,_windingOrder:l,elevationScale:c,transitions:B,positionFormat:h}=this.props,{lineWidthUnits:d,lineWidthScale:k,lineWidthMinPixels:g,lineWidthMaxPixels:E,lineJointRounded:m,lineMiterLimit:y,lineDashJustified:b}=this.props,{getFillColor:v,getLineColor:_,getLineWidth:w,getLineDashArray:x,getElevation:S,getPolygon:F,updateTriggers:D,material:L}=this.props,{paths:z,pathsDiff:T}=this.state,W=this.getSubLayerClass("fill",Q7),G=this.getSubLayerClass("stroke",_o),jA=this.shouldRenderSubLayer("fill",z)&&new W({_dataDiff:j,extruded:n,elevationScale:c,filled:r,wireframe:i,_normalize:o,_windingOrder:l,getElevation:S,getFillColor:v,getLineColor:n&&i?_:uC,material:L,transitions:B},this.getSubLayerProps({id:"fill",updateTriggers:D&&{getPolygon:D.getPolygon,getElevation:D.getElevation,getFillColor:D.getFillColor,lineColors:n&&i,getLineColor:D.getLineColor}}),{data:A,positionFormat:h,getPolygon:F}),pA=!n&&e&&this.shouldRenderSubLayer("stroke",z)&&new G({_dataDiff:T&&(()=>T),widthUnits:d,widthScale:k,widthMinPixels:g,widthMaxPixels:E,jointRounded:m,miterLimit:y,dashJustified:b,_pathType:"loop",transitions:B&&{getWidth:B.getLineWidth,getColor:B.getLineColor,getPath:B.getPolygon},getColor:this.getSubLayerAccessor(_),getWidth:this.getSubLayerAccessor(w),getDashArray:this.getSubLayerAccessor(x)},this.getSubLayerProps({id:"stroke",updateTriggers:D&&{getWidth:D.getLineWidth,getColor:D.getLineColor,getDashArray:D.getLineDashArray}}),{data:z,positionFormat:h,getPath:dA=>dA.path});return[!n&&jA,pA,n&&jA]}};vk.layerName="PolygonLayer";vk.defaultProps=$sA;var Gx=vk;function BC(t,A){if(!t)return null;let j="startIndices"in t?t.startIndices[A]:A,e=t.featureIds.value[j];return j!==-1?xsA(t,e,j):null}function xsA(t,A,j){let e={properties:{...t.properties[A]}};for(let r in t.numericProps)e.properties[r]=t.numericProps[r].value[j];return e}function fC(t,A){let j={points:null,lines:null,polygons:null};for(let e in j){let r=t[e].globalFeatureIds.value;j[e]=new Uint8ClampedArray(r.length*3);let n=[];for(let i=0;it.polygon},getElevation:{type:"accessor",value:1e3},getFillColor:{type:"accessor",value:Fx},getLineColor:{type:"accessor",value:Fx},material:!0},wx={enter:(t,A)=>A.length?A.subarray(A.length-t.length):t},_k=class extends gr{getShaders(A){return super.getShaders({vs:A==="top"?hC:dC,fs:pC,defines:{RING_WINDING_ORDER_CW:!this.props._normalize&&this.props._windingOrder==="CCW"?0:1},modules:[Lr,I7,Cr]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds(["vertexPositions"])}initializeState(){let{viewport:A}=this.context,{coordinateSystem:j}=this.props,{_full3d:e}=this.props;A.isGeospatial&&j===qt.DEFAULT&&(j=qt.LNGLAT);let r;j===qt.LNGLAT&&(e?r=A.projectPosition.bind(A):r=A.projectFlat.bind(A)),this.setState({numInstances:0,polygonTesselator:new vk({preproject:r,fp64:this.use64bitPositions(),IndexType:Uint32Array})});let n=this.getAttributeManager(),i=!0;n.remove(["instancePickingColors"]),n.add({indices:{size:1,isIndexed:!0,update:this.calculateIndices,noAlloc:i},vertexPositions:{size:3,type:"float64",stepMode:"dynamic",fp64:this.use64bitPositions(),transition:wx,accessor:"getPolygon",update:this.calculatePositions,noAlloc:i,shaderAttributes:{nextVertexPositions:{vertexOffset:1}}},instanceVertexValid:{size:1,type:"uint16",stepMode:"instance",update:this.calculateVertexValid,noAlloc:i},elevations:{size:1,stepMode:"dynamic",transition:wx,accessor:"getElevation"},fillColors:{size:this.props.colorFormat.length,type:"unorm8",stepMode:"dynamic",transition:wx,accessor:"getFillColor",defaultValue:Fx},lineColors:{size:this.props.colorFormat.length,type:"unorm8",stepMode:"dynamic",transition:wx,accessor:"getLineColor",defaultValue:Fx},pickingColors:{size:4,type:"uint8",stepMode:"dynamic",accessor:(o,{index:l,target:c})=>this.encodePickingColor(o&&o.__source?o.__source.index:l,c)}})}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e}=j,r=this.props.data;return r[0]&&r[0].__source&&(j.object=r.find(n=>n.__source.index===e)),j}disablePickingIndex(A){let j=this.props.data;if(j[0]&&j[0].__source)for(let e=0;eo.destroy()),this.setState(this._getModels()),n.invalidateAll())}updateGeometry({props:A,oldProps:j,changeFlags:e}){if(e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPolygon)){let{polygonTesselator:n}=this.state,i=A.data.attributes||{};n.updateGeometry({data:A.data,normalize:A._normalize,geometryBuffer:i.getPolygon,buffers:i,getGeometry:A.getPolygon,positionFormat:A.positionFormat,wrapLongitude:A.wrapLongitude,resolution:this.context.viewport.resolution,fp64:this.use64bitPositions(),dataChanged:e.dataChanged,full3d:A._full3d}),this.setState({numInstances:n.instanceCount,startIndices:n.vertexStarts}),e.dataChanged||this.getAttributeManager().invalidateAll()}}_getModels(){let{id:A,filled:j,extruded:e}=this.props,r,n,i;if(j){let o=this.getShaders("top");o.defines.NON_INSTANCED_MODEL=1;let l=this.getAttributeManager().getBufferLayouts({isInstanced:!1});r=new ke(this.context.device,{...o,id:`${A}-top`,topology:"triangle-list",uniforms:{isWireframe:!1},bufferLayout:l,isIndexed:!0,userData:{excludeAttributes:{instanceVertexValid:!0}}})}if(e){let o=this.getAttributeManager().getBufferLayouts({isInstanced:!0});n=new ke(this.context.device,{...this.getShaders("side"),id:`${A}-side`,bufferLayout:o,uniforms:{isWireframe:!1},geometry:new ln({topology:"triangle-strip",attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,1,1,0,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}}),i=new ke(this.context.device,{...this.getShaders("side"),id:`${A}-wireframe`,bufferLayout:o,uniforms:{isWireframe:!0},geometry:new ln({topology:"line-strip",attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,0,1,1,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}})}return{models:[n,i,r].filter(Boolean),topModel:r,sideModel:n,wireframeModel:i}}calculateIndices(A){let{polygonTesselator:j}=this.state;A.startIndices=j.indexStarts,A.value=j.get("indices")}calculatePositions(A){let{polygonTesselator:j}=this.state;A.startIndices=j.vertexStarts,A.value=j.get("positions")}calculateVertexValid(A){A.value=this.state.polygonTesselator.get("vertexValid")}};_k.defaultProps=_sA;_k.layerName="SolidPolygonLayer";var Q7=_k;function Px({data:t,getIndex:A,dataRange:j,replace:e}){let{startRow:r=0,endRow:n=1/0}=j,i=t.length,o=i,l=i;for(let d=0;dd&&k>=r&&(o=d),k>=n){l=d;break}}let c=o,h=l-o!==e.length?t.slice(l):void 0;for(let d=0;dt.polygon},getFillColor:{type:"accessor",value:qsA},getLineColor:{type:"accessor",value:kC},getLineWidth:{type:"accessor",value:1},getElevation:{type:"accessor",value:1e3},material:!0},qk=class extends b6{initializeState(){this.state={paths:[],pathsDiff:null},this.props.getLineDashArray&&NA.removed("getLineDashArray","PathStyleExtension")()}updateState({changeFlags:A}){let j=A.dataChanged||A.updateTriggersChanged&&(A.updateTriggersChanged.all||A.updateTriggersChanged.getPolygon);if(j&&Array.isArray(A.dataChanged)){let e=this.state.paths.slice(),r=A.dataChanged.map(n=>Px({data:e,getIndex:i=>i.__source.index,dataRange:n,replace:this._getPaths(n)}));this.setState({paths:e,pathsDiff:r})}else j&&this.setState({paths:this._getPaths(),pathsDiff:null})}_getPaths(A={}){let{data:j,getPolygon:e,positionFormat:r,_normalize:n}=this.props,i=[],o=r==="XY"?2:3,{startRow:l,endRow:c}=A,{iterable:B,objectInfo:h}=Pi(j,l,c);for(let d of B){h.index++;let k=e(d,h);n&&(k=bx(k,o));let{holeIndices:g}=k,E=k.positions||k;if(g)for(let m=0;m<=g.length;m++){let y=E.slice(g[m-1]||0,g[m]||E.length);i.push(this.getSubLayerRow({path:y},d,h.index))}else i.push(this.getSubLayerRow({path:E},d,h.index))}return i}renderLayers(){let{data:A,_dataDiff:j,stroked:e,filled:r,extruded:n,wireframe:i,_normalize:o,_windingOrder:l,elevationScale:c,transitions:B,positionFormat:h}=this.props,{lineWidthUnits:d,lineWidthScale:k,lineWidthMinPixels:g,lineWidthMaxPixels:E,lineJointRounded:m,lineMiterLimit:y,lineDashJustified:G}=this.props,{getFillColor:v,getLineColor:_,getLineWidth:w,getLineDashArray:x,getElevation:O,getPolygon:F,updateTriggers:C,material:R}=this.props,{paths:X,pathsDiff:T}=this.state,Q=this.getSubLayerClass("fill",Q7),b=this.getSubLayerClass("stroke",_o),jA=this.shouldRenderSubLayer("fill",X)&&new Q({_dataDiff:j,extruded:n,elevationScale:c,filled:r,wireframe:i,_normalize:o,_windingOrder:l,getElevation:O,getFillColor:v,getLineColor:n&&i?_:kC,material:R,transitions:B},this.getSubLayerProps({id:"fill",updateTriggers:C&&{getPolygon:C.getPolygon,getElevation:C.getElevation,getFillColor:C.getFillColor,lineColors:n&&i,getLineColor:C.getLineColor}}),{data:A,positionFormat:h,getPolygon:F}),pA=!n&&e&&this.shouldRenderSubLayer("stroke",X)&&new b({_dataDiff:T&&(()=>T),widthUnits:d,widthScale:k,widthMinPixels:g,widthMaxPixels:E,jointRounded:m,miterLimit:y,dashJustified:G,_pathType:"loop",transitions:B&&{getWidth:B.getLineWidth,getColor:B.getLineColor,getPath:B.getPolygon},getColor:this.getSubLayerAccessor(_),getWidth:this.getSubLayerAccessor(w),getDashArray:this.getSubLayerAccessor(x)},this.getSubLayerProps({id:"stroke",updateTriggers:C&&{getWidth:C.getLineWidth,getColor:C.getLineColor,getDashArray:C.getLineDashArray}}),{data:X,positionFormat:h,getPath:dA=>dA.path});return[!n&&jA,pA,n&&jA]}};qk.layerName="PolygonLayer";qk.defaultProps=bsA;var Ix=qk;function gC(t,A){if(!t)return null;let j="startIndices"in t?t.startIndices[A]:A,e=t.featureIds.value[j];return j!==-1?GsA(t,e,j):null}function GsA(t,A,j){let e={properties:{...t.properties[A]}};for(let r in t.numericProps)e.properties[r]=t.numericProps[r].value[j];return e}function mC(t,A){let j={points:null,lines:null,polygons:null};for(let e in j){let r=t[e].globalFeatureIds.value;j[e]=new Uint8ClampedArray(r.length*3);let n=[];for(let i=0;it.offsets},alphaCutoff:.001,smoothing:.1,outlineWidth:0,outlineColor:{type:"color",value:[0,0,0,255]}},_k=class extends z7{getShaders(){return{...super.getShaders(),fs:hC}}initializeState(){super.initializeState(),this.getAttributeManager().addInstanced({instanceOffsets:{size:2,accessor:"getIconOffsets"},instancePickingColors:{type:"uint8",size:3,accessor:(j,{index:e,target:r})=>this.encodePickingColor(e,r)}})}updateState(A){super.updateState(A);let{props:j,oldProps:e}=A,{outlineColor:r}=j;r!==e.outlineColor&&(r=r.map(n=>n/255),r[3]=Number.isFinite(r[3])?r[3]:1,this.setState({outlineColor:r})),!j.sdf&&j.outlineWidth&&NA.warn(`${this.id}: fontSettings.sdf is required to render outline`)()}draw(A){let{sdf:j,smoothing:e,outlineWidth:r}=this.props,{outlineColor:n}=this.state,i=r?Math.max(e,PF*(1-r)):-1;if(A.uniforms={...A.uniforms,sdfBuffer:PF,outlineBuffer:i,gamma:e,sdf:!!j,outlineColor:n},super.draw(A),j&&r){let{iconManager:o}=this.state,l=o.getTexture(),c=this.state.model;l&&(c.setUniforms({outlineBuffer:PF}),c.draw(this.context.renderPass))}}getInstanceOffset(A){return A?Array.from(A).flatMap(j=>super.getInstanceOffset(j)):dC}getInstanceColorMode(A){return 1}getInstanceIconFrame(A){return A?Array.from(A).flatMap(j=>super.getInstanceIconFrame(j)):dC}};_k.defaultProps=ysA;_k.layerName="MultiIconLayer";var pC=_k;var qk=class{constructor({fontSize:A=24,buffer:j=3,radius:e=8,cutoff:r=.25,fontFamily:n="sans-serif",fontWeight:i="normal",fontStyle:o="normal"}={}){this.buffer=j,this.cutoff=r,this.radius=e;let l=this.size=A+j*4,c=this._createCanvas(l),B=this.ctx=c.getContext("2d",{willReadFrequently:!0});B.font=`${o} ${i} ${A}px ${n}`,B.textBaseline="alphabetic",B.textAlign="left",B.fillStyle="black",this.gridOuter=new Float64Array(l*l),this.gridInner=new Float64Array(l*l),this.f=new Float64Array(l),this.z=new Float64Array(l+1),this.v=new Uint16Array(l)}_createCanvas(A){let j=document.createElement("canvas");return j.width=j.height=A,j}draw(A){let{width:j,actualBoundingBoxAscent:e,actualBoundingBoxDescent:r,actualBoundingBoxLeft:n,actualBoundingBoxRight:i}=this.ctx.measureText(A),o=Math.ceil(e),l=0,c=Math.max(0,Math.min(this.size-this.buffer,Math.ceil(i-n))),B=Math.min(this.size-this.buffer,o+Math.ceil(r)),h=c+2*this.buffer,d=B+2*this.buffer,k=Math.max(h*d,0),g=new Uint8ClampedArray(k),E={data:g,width:h,height:d,glyphWidth:c,glyphHeight:B,glyphTop:o,glyphLeft:l,glyphAdvance:j};if(c===0||B===0)return E;let{ctx:m,buffer:y,gridInner:b,gridOuter:v}=this;m.clearRect(y,y,c,B),m.fillText(A,y,y+o);let _=m.getImageData(y,y,c,B);v.fill(1e20,0,k),b.fill(0,0,k);for(let w=0;w0?D*D:0,b[F]=D<0?D*D:0}}kC(v,0,0,h,d,h,this.f,this.v,this.z),kC(b,y,y,c,B,h,this.f,this.v,this.z);for(let w=0;w-1);l++,n[l]=o,i[l]=c,i[l+1]=1e20}for(let o=0,l=0;or&&(c=0,l++),n[h]={x:c+e,y:o+l*B+e,width:d,height:B,layoutWidth:d,layoutHeight:j},c+=d+e*2}return{mapping:n,xOffset:c,yOffset:o+l*B,canvasHeight:qsA(o+(l+1)*B)}}function EC(t,A,j,e){let r=0;for(let n=A;ne&&(io){let h=EC(t,o,l,r);c+h>e&&(ie&&(h=$C(t,o,l,e,r,n),i=n[n.length-1])),o=l,c+=h}return c}function bsA(t,A,j,e,r=0,n){n===void 0&&(n=t.length);let i=[];return A==="break-all"?$C(t,r,n,j,e,i):GsA(t,r,n,j,e,i),i}function wsA(t,A,j,e,r,n){let i=0,o=0;for(let l=A;l0,h=[0,0],d=[0,0],k=0,g=0,E=0;for(let m=0;m<=i;m++){let y=n[m];if((y===` -`||m===i)&&(E=m),E>g){let b=B?bsA(n,j,e,r,g,E):_sA;for(let v=0;v<=b.length;v++){let _=v===0?g:b[v-1],w=v1||l>0){let k=t.constructor;d=new k(c);for(let g=0;g=0&&this._order.splice(j,1)}_appendOrder(A){this._order.push(A)}};function FsA(){let t=[];for(let A=32;A<128;A++)t.push(String.fromCharCode(A));return t}var Tc={fontFamily:"Monaco, monospace",fontWeight:"normal",characterSet:FsA(),fontSize:64,buffer:4,sdf:!1,cutoff:.25,radius:12,smoothing:.1},vC=1024,_C=.9,qC=1.2,bC=3,bx=new QB(bC);function PsA(t,A){let j;typeof A=="string"?j=new Set(Array.from(A)):j=new Set(A);let e=bx.get(t);if(!e)return j;for(let r in e.mapping)j.has(r)&&j.delete(r);return j}function IsA(t,A){for(let j=0;j=bC,"Invalid cache limit"),bx=new QB(t)}var Gk=class{constructor(){this.props={...Tc}}get atlas(){return this._atlas}get mapping(){return this._atlas&&this._atlas.mapping}get scale(){let{fontSize:A,buffer:j}=this.props;return(A*qC+j*2)/A}setProps(A={}){Object.assign(this.props,A),this._key=this._getKey();let j=PsA(this._key,this.props.characterSet),e=bx.get(this._key);if(e&&j.size===0){this._atlas!==e&&(this._atlas=e);return}let r=this._generateFontAtlas(j,e);this._atlas=r,bx.set(this._key,r)}_generateFontAtlas(A,j){let{fontFamily:e,fontWeight:r,fontSize:n,buffer:i,sdf:o,radius:l,cutoff:c}=this.props,B=j&&j.data;B||(B=document.createElement("canvas"),B.width=vC);let h=B.getContext("2d",{willReadFrequently:!0});GC(h,e,n,r);let{mapping:d,canvasHeight:k,xOffset:g,yOffset:E}=mC({getFontWidth:m=>h.measureText(m).width,fontHeight:n*qC,buffer:i,characterSet:A,maxCanvasWidth:vC,...j&&{mapping:j.mapping,xOffset:j.xOffset,yOffset:j.yOffset}});if(B.height!==k){let m=h.getImageData(0,0,B.width,B.height);B.height=k,h.putImageData(m,0,0)}if(GC(h,e,n,r),o){let m=new qk({fontSize:n,buffer:i,radius:l,cutoff:c,fontFamily:e,fontWeight:`${r}`});for(let y of A){let{data:b,width:v,height:_,glyphTop:w}=m.draw(y);d[y].width=v,d[y].layoutOffsetY=n*_C-w;let x=h.createImageData(v,_);IsA(b,x),h.putImageData(x,d[y].x,d[y].y)}}else for(let m of A)h.fillText(m,d[m].x,d[m].y+i+n*_C);return{xOffset:g,yOffset:E,mapping:d,data:B,width:B.width,height:B.height}}_getKey(){let{fontFamily:A,fontWeight:j,fontSize:e,buffer:r,sdf:n,radius:i,cutoff:o}=this.props;return n?`${A} ${j} ${e} ${r} ${i} ${o}`:`${A} ${j} ${e} ${r}`}};var FC=`#version 300 es +`;var SF=192/256,$C=[],wsA={getIconOffsets:{type:"accessor",value:t=>t.offsets},alphaCutoff:.001,smoothing:.1,outlineWidth:0,outlineColor:{type:"color",value:[0,0,0,255]}},bk=class extends z7{getShaders(){return{...super.getShaders(),fs:EC}}initializeState(){super.initializeState(),this.getAttributeManager().addInstanced({instanceOffsets:{size:2,accessor:"getIconOffsets"},instancePickingColors:{type:"uint8",size:3,accessor:(j,{index:e,target:r})=>this.encodePickingColor(e,r)}})}updateState(A){super.updateState(A);let{props:j,oldProps:e}=A,{outlineColor:r}=j;r!==e.outlineColor&&(r=r.map(n=>n/255),r[3]=Number.isFinite(r[3])?r[3]:1,this.setState({outlineColor:r})),!j.sdf&&j.outlineWidth&&NA.warn(`${this.id}: fontSettings.sdf is required to render outline`)()}draw(A){let{sdf:j,smoothing:e,outlineWidth:r}=this.props,{outlineColor:n}=this.state,i=r?Math.max(e,SF*(1-r)):-1;if(A.uniforms={...A.uniforms,sdfBuffer:SF,outlineBuffer:i,gamma:e,sdf:!!j,outlineColor:n},super.draw(A),j&&r){let{iconManager:o}=this.state,l=o.getTexture(),c=this.state.model;l&&(c.setUniforms({outlineBuffer:SF}),c.draw(this.context.renderPass))}}getInstanceOffset(A){return A?Array.from(A).flatMap(j=>super.getInstanceOffset(j)):$C}getInstanceColorMode(A){return 1}getInstanceIconFrame(A){return A?Array.from(A).flatMap(j=>super.getInstanceIconFrame(j)):$C}};bk.defaultProps=wsA;bk.layerName="MultiIconLayer";var xC=bk;var Gk=class{constructor({fontSize:A=24,buffer:j=3,radius:e=8,cutoff:r=.25,fontFamily:n="sans-serif",fontWeight:i="normal",fontStyle:o="normal"}={}){this.buffer=j,this.cutoff=r,this.radius=e;let l=this.size=A+j*4,c=this._createCanvas(l),B=this.ctx=c.getContext("2d",{willReadFrequently:!0});B.font=`${o} ${i} ${A}px ${n}`,B.textBaseline="alphabetic",B.textAlign="left",B.fillStyle="black",this.gridOuter=new Float64Array(l*l),this.gridInner=new Float64Array(l*l),this.f=new Float64Array(l),this.z=new Float64Array(l+1),this.v=new Uint16Array(l)}_createCanvas(A){let j=document.createElement("canvas");return j.width=j.height=A,j}draw(A){let{width:j,actualBoundingBoxAscent:e,actualBoundingBoxDescent:r,actualBoundingBoxLeft:n,actualBoundingBoxRight:i}=this.ctx.measureText(A),o=Math.ceil(e),l=0,c=Math.max(0,Math.min(this.size-this.buffer,Math.ceil(i-n))),B=Math.min(this.size-this.buffer,o+Math.ceil(r)),h=c+2*this.buffer,d=B+2*this.buffer,k=Math.max(h*d,0),g=new Uint8ClampedArray(k),E={data:g,width:h,height:d,glyphWidth:c,glyphHeight:B,glyphTop:o,glyphLeft:l,glyphAdvance:j};if(c===0||B===0)return E;let{ctx:m,buffer:y,gridInner:G,gridOuter:v}=this;m.clearRect(y,y,c,B),m.fillText(A,y,y+o);let _=m.getImageData(y,y,c,B);v.fill(1e20,0,k),G.fill(0,0,k);for(let w=0;w0?C*C:0,G[F]=C<0?C*C:0}}yC(v,0,0,h,d,h,this.f,this.v,this.z),yC(G,y,y,c,B,h,this.f,this.v,this.z);for(let w=0;w-1);l++,n[l]=o,i[l]=c,i[l+1]=1e20}for(let o=0,l=0;or&&(c=0,l++),n[h]={x:c+e,y:o+l*B+e,width:d,height:B,layoutWidth:d,layoutHeight:j},c+=d+e*2}return{mapping:n,xOffset:c,yOffset:o+l*B,canvasHeight:IsA(o+(l+1)*B)}}function qC(t,A,j,e){let r=0;for(let n=A;ne&&(io){let h=qC(t,o,l,r);c+h>e&&(ie&&(h=bC(t,o,l,e,r,n),i=n[n.length-1])),o=l,c+=h}return c}function OsA(t,A,j,e,r=0,n){n===void 0&&(n=t.length);let i=[];return A==="break-all"?bC(t,r,n,j,e,i):MsA(t,r,n,j,e,i),i}function TsA(t,A,j,e,r,n){let i=0,o=0;for(let l=A;l0,h=[0,0],d=[0,0],k=0,g=0,E=0;for(let m=0;m<=i;m++){let y=n[m];if((y===` +`||m===i)&&(E=m),E>g){let G=B?OsA(n,j,e,r,g,E):PsA;for(let v=0;v<=G.length;v++){let _=v===0?g:G[v-1],w=v1||l>0){let k=t.constructor;d=new k(c);for(let g=0;g=0&&this._order.splice(j,1)}_appendOrder(A){this._order.push(A)}};function SsA(){let t=[];for(let A=32;A<128;A++)t.push(String.fromCharCode(A));return t}var Sc={fontFamily:"Monaco, monospace",fontWeight:"normal",characterSet:SsA(),fontSize:64,buffer:4,sdf:!1,cutoff:.25,radius:12,smoothing:.1},FC=1024,PC=.9,IC=1.2,OC=3,Mx=new QB(OC);function RsA(t,A){let j;typeof A=="string"?j=new Set(Array.from(A)):j=new Set(A);let e=Mx.get(t);if(!e)return j;for(let r in e.mapping)j.has(r)&&j.delete(r);return j}function LsA(t,A){for(let j=0;j=OC,"Invalid cache limit"),Mx=new QB(t)}var wk=class{constructor(){this.props={...Sc}}get atlas(){return this._atlas}get mapping(){return this._atlas&&this._atlas.mapping}get scale(){let{fontSize:A,buffer:j}=this.props;return(A*IC+j*2)/A}setProps(A={}){Object.assign(this.props,A),this._key=this._getKey();let j=RsA(this._key,this.props.characterSet),e=Mx.get(this._key);if(e&&j.size===0){this._atlas!==e&&(this._atlas=e);return}let r=this._generateFontAtlas(j,e);this._atlas=r,Mx.set(this._key,r)}_generateFontAtlas(A,j){let{fontFamily:e,fontWeight:r,fontSize:n,buffer:i,sdf:o,radius:l,cutoff:c}=this.props,B=j&&j.data;B||(B=document.createElement("canvas"),B.width=FC);let h=B.getContext("2d",{willReadFrequently:!0});MC(h,e,n,r);let{mapping:d,canvasHeight:k,xOffset:g,yOffset:E}=_C({getFontWidth:m=>h.measureText(m).width,fontHeight:n*IC,buffer:i,characterSet:A,maxCanvasWidth:FC,...j&&{mapping:j.mapping,xOffset:j.xOffset,yOffset:j.yOffset}});if(B.height!==k){let m=h.getImageData(0,0,B.width,B.height);B.height=k,h.putImageData(m,0,0)}if(MC(h,e,n,r),o){let m=new Gk({fontSize:n,buffer:i,radius:l,cutoff:c,fontFamily:e,fontWeight:`${r}`});for(let y of A){let{data:G,width:v,height:_,glyphTop:w}=m.draw(y);d[y].width=v,d[y].layoutOffsetY=n*PC-w;let x=h.createImageData(v,_);LsA(G,x),h.putImageData(x,d[y].x,d[y].y)}}else for(let m of A)h.fillText(m,d[m].x,d[m].y+i+n*PC);return{xOffset:g,yOffset:E,mapping:d,data:B,width:B.width,height:B.height}}_getKey(){let{fontFamily:A,fontWeight:j,fontSize:e,buffer:r,sdf:n,radius:i,cutoff:o}=this.props;return n?`${A} ${j} ${e} ${r} ${i} ${o}`:`${A} ${j} ${e} ${r}`}};var SC=`#version 300 es #define SHADER_NAME text-background-layer-vertex-shader in vec2 positions; in vec3 instancePositions; @@ -1716,7 +1716,7 @@ DECKGL_FILTER_COLOR(vFillColor, geometry); vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); DECKGL_FILTER_COLOR(vLineColor, geometry); } -`;var PC=`#version 300 es +`;var RC=`#version 300 es #define SHADER_NAME text-background-layer-fragment-shader precision highp float; uniform bool stroked; @@ -1741,24 +1741,24 @@ fragColor = vFillColor; } DECKGL_FILTER_COLOR(fragColor, geometry); } -`;var MsA={billboard:!0,sizeScale:1,sizeUnits:"pixels",sizeMinPixels:0,sizeMaxPixels:Number.MAX_SAFE_INTEGER,padding:{type:"array",value:[0,0,0,0]},getPosition:{type:"accessor",value:t=>t.position},getSize:{type:"accessor",value:1},getAngle:{type:"accessor",value:0},getPixelOffset:{type:"accessor",value:[0,0]},getBoundingRect:{type:"accessor",value:[0,0,0,0]},getFillColor:{type:"accessor",value:[0,0,0,255]},getLineColor:{type:"accessor",value:[0,0,0,255]},getLineWidth:{type:"accessor",value:1}},bk=class extends gr{getShaders(){return super.getShaders({vs:FC,fs:PC,modules:[Lr,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceSizes:{size:1,transition:!0,accessor:"getSize",defaultValue:1},instanceAngles:{size:1,transition:!0,accessor:"getAngle"},instanceRects:{size:4,accessor:"getBoundingRect"},instancePixelOffsets:{size:2,transition:!0,accessor:"getPixelOffset"},instanceFillColors:{size:4,transition:!0,type:"unorm8",accessor:"getFillColor",defaultValue:[0,0,0,255]},instanceLineColors:{size:4,transition:!0,type:"unorm8",accessor:"getLineColor",defaultValue:[0,0,0,255]},instanceLineWidths:{size:1,transition:!0,accessor:"getLineWidth",defaultValue:1}})}updateState(A){super.updateState(A);let{changeFlags:j}=A;j.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:A}){let{billboard:j,sizeScale:e,sizeUnits:r,sizeMinPixels:n,sizeMaxPixels:i,getLineWidth:o}=this.props,{padding:l}=this.props;l.length<4&&(l=[l[0],l[1],l[0],l[1]]);let c=this.state.model;c.setUniforms(A),c.setUniforms({billboard:j,stroked:!!o,padding:l,sizeUnits:an[r],sizeScale:e,sizeMinPixels:n,sizeMaxPixels:i}),c.draw(this.context.renderPass)}_getModel(){let A=[0,0,1,0,1,1,0,1];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-fan-webgl",vertexCount:4,attributes:{positions:{size:2,value:new Float32Array(A)}}}),isInstanced:!0})}};bk.defaultProps=MsA;bk.layerName="TextBackgroundLayer";var IC=bk;var MC={start:1,middle:0,end:-1},OC={top:1,center:0,bottom:-1},IF=[0,0,0,255],OsA=1,TsA={billboard:!0,sizeScale:1,sizeUnits:"pixels",sizeMinPixels:0,sizeMaxPixels:Number.MAX_SAFE_INTEGER,background:!1,getBackgroundColor:{type:"accessor",value:[255,255,255,255]},getBorderColor:{type:"accessor",value:IF},getBorderWidth:{type:"accessor",value:0},backgroundPadding:{type:"array",value:[0,0,0,0]},characterSet:{type:"object",value:Tc.characterSet},fontFamily:Tc.fontFamily,fontWeight:Tc.fontWeight,lineHeight:OsA,outlineWidth:{type:"number",value:0,min:0},outlineColor:{type:"color",value:IF},fontSettings:{type:"object",value:{},compare:1},wordBreak:"break-word",maxWidth:{type:"number",value:-1},getText:{type:"accessor",value:t=>t.text},getPosition:{type:"accessor",value:t=>t.position},getColor:{type:"accessor",value:IF},getSize:{type:"accessor",value:32},getAngle:{type:"accessor",value:0},getTextAnchor:{type:"accessor",value:"middle"},getAlignmentBaseline:{type:"accessor",value:"center"},getPixelOffset:{type:"accessor",value:[0,0]},backgroundColor:{deprecatedFor:["background","getBackgroundColor"]}},wk=class extends G6{constructor(){super(...arguments),this.getBoundingRect=(A,j)=>{let{size:[e,r]}=this.transformParagraph(A,j),{fontSize:n}=this.state.fontAtlasManager.props;e/=n,r/=n;let{getTextAnchor:i,getAlignmentBaseline:o}=this.props,l=MC[typeof i=="function"?i(A,j):i],c=OC[typeof o=="function"?o(A,j):o];return[(l-1)*e/2,(c-1)*r/2,e,r]},this.getIconOffsets=(A,j)=>{let{getTextAnchor:e,getAlignmentBaseline:r}=this.props,{x:n,y:i,rowWidth:o,size:[l,c]}=this.transformParagraph(A,j),B=MC[typeof e=="function"?e(A,j):e],h=OC[typeof r=="function"?r(A,j):r],d=n.length,k=new Array(d*2),g=0;for(let E=0;E0&&NA.warn("v8.9 breaking change: TextLayer maxWidth is now relative to text size")()}updateState(A){let{props:j,oldProps:e,changeFlags:r}=A;(r.dataChanged||r.updateTriggersChanged&&(r.updateTriggersChanged.all||r.updateTriggersChanged.getText))&&this._updateText(),(this._updateFontAtlas()||j.lineHeight!==e.lineHeight||j.wordBreak!==e.wordBreak||j.maxWidth!==e.maxWidth)&&this.setState({styleVersion:this.state.styleVersion+1})}getPickingInfo({info:A}){return A.object=A.index>=0?this.props.data[A.index]:null,A}_updateFontAtlas(){let{fontSettings:A,fontFamily:j,fontWeight:e}=this.props,{fontAtlasManager:r,characterSet:n}=this.state,i={...A,characterSet:n,fontFamily:j,fontWeight:e};if(!r.mapping)return r.setProps(i),!0;for(let o in i)if(i[o]!==r.props[o])return r.setProps(i),!0;return!1}_updateText(){let{data:A,characterSet:j}=this.props,e=A.attributes?.getText,{getText:r}=this.props,n=A.startIndices,i,o=j==="auto"&&new Set;if(e&&n){let{texts:l,characterCount:c}=yC({...ArrayBuffer.isView(e)?{value:e}:e,length:A.length,startIndices:n,characterSet:o});i=c,r=(B,{index:h})=>l[h]}else{let{iterable:l,objectInfo:c}=Pi(A);n=[0],i=0;for(let B of l){c.index++;let h=Array.from(r(B,c)||"");o&&h.forEach(o.add,o),i+=h.length,n.push(i)}}this.setState({getText:r,startIndices:n,numInstances:i,characterSet:o||j})}transformParagraph(A,j){let{fontAtlasManager:e}=this.state,r=e.mapping,n=this.state.getText,{wordBreak:i,lineHeight:o,maxWidth:l}=this.props,c=n(A,j)||"";return xC(c,o,i,l*e.props.fontSize,r)}renderLayers(){let{startIndices:A,numInstances:j,getText:e,fontAtlasManager:{scale:r,atlas:n,mapping:i},styleVersion:o}=this.state,{data:l,_dataDiff:c,getPosition:B,getColor:h,getSize:d,getAngle:k,getPixelOffset:g,getBackgroundColor:E,getBorderColor:m,getBorderWidth:y,backgroundPadding:b,background:v,billboard:_,fontSettings:w,outlineWidth:x,outlineColor:S,sizeScale:F,sizeUnits:D,sizeMinPixels:L,sizeMaxPixels:z,transitions:T,updateTriggers:W}=this.props,G=this.getSubLayerClass("characters",pC),jA=this.getSubLayerClass("background",IC);return[v&&new jA({getFillColor:E,getLineColor:m,getLineWidth:y,padding:b,getPosition:B,getSize:d,getAngle:k,getPixelOffset:g,billboard:_,sizeScale:F,sizeUnits:D,sizeMinPixels:L,sizeMaxPixels:z,transitions:T&&{getPosition:T.getPosition,getAngle:T.getAngle,getSize:T.getSize,getFillColor:T.getBackgroundColor,getLineColor:T.getBorderColor,getLineWidth:T.getBorderWidth,getPixelOffset:T.getPixelOffset}},this.getSubLayerProps({id:"background",updateTriggers:{getPosition:W.getPosition,getAngle:W.getAngle,getSize:W.getSize,getFillColor:W.getBackgroundColor,getLineColor:W.getBorderColor,getLineWidth:W.getBorderWidth,getPixelOffset:W.getPixelOffset,getBoundingRect:{getText:W.getText,getTextAnchor:W.getTextAnchor,getAlignmentBaseline:W.getAlignmentBaseline,styleVersion:o}}}),{data:l.attributes&&l.attributes.background?{length:l.length,attributes:l.attributes.background}:l,_dataDiff:c,autoHighlight:!1,getBoundingRect:this.getBoundingRect}),new G({sdf:w.sdf,smoothing:Number.isFinite(w.smoothing)?w.smoothing:Tc.smoothing,outlineWidth:x/(w.radius||Tc.radius),outlineColor:S,iconAtlas:n,iconMapping:i,getPosition:B,getColor:h,getSize:d,getAngle:k,getPixelOffset:g,billboard:_,sizeScale:F*r,sizeUnits:D,sizeMinPixels:L*r,sizeMaxPixels:z*r,transitions:T&&{getPosition:T.getPosition,getAngle:T.getAngle,getColor:T.getColor,getSize:T.getSize,getPixelOffset:T.getPixelOffset}},this.getSubLayerProps({id:"characters",updateTriggers:{all:W.getText,getPosition:W.getPosition,getAngle:W.getAngle,getColor:W.getColor,getSize:W.getSize,getPixelOffset:W.getPixelOffset,getIconOffsets:{getTextAnchor:W.getTextAnchor,getAlignmentBaseline:W.getAlignmentBaseline,styleVersion:o}}}),{data:l,_dataDiff:c,startIndices:A,numInstances:j,getIconOffsets:this.getIconOffsets,getIcon:e})]}static set fontAtlasCacheLimit(A){wC(A)}};wk.defaultProps=TsA;wk.layerName="TextLayer";var Ii=wk;var Fk={circle:{type:mr,props:{filled:"filled",stroked:"stroked",lineWidthMaxPixels:"lineWidthMaxPixels",lineWidthMinPixels:"lineWidthMinPixels",lineWidthScale:"lineWidthScale",lineWidthUnits:"lineWidthUnits",pointRadiusMaxPixels:"radiusMaxPixels",pointRadiusMinPixels:"radiusMinPixels",pointRadiusScale:"radiusScale",pointRadiusUnits:"radiusUnits",pointAntialiasing:"antialiasing",pointBillboard:"billboard",getFillColor:"getFillColor",getLineColor:"getLineColor",getLineWidth:"getLineWidth",getPointRadius:"getRadius"}},icon:{type:z7,props:{iconAtlas:"iconAtlas",iconMapping:"iconMapping",iconSizeMaxPixels:"sizeMaxPixels",iconSizeMinPixels:"sizeMinPixels",iconSizeScale:"sizeScale",iconSizeUnits:"sizeUnits",iconAlphaCutoff:"alphaCutoff",iconBillboard:"billboard",getIcon:"getIcon",getIconAngle:"getAngle",getIconColor:"getColor",getIconPixelOffset:"getPixelOffset",getIconSize:"getSize"}},text:{type:Ii,props:{textSizeMaxPixels:"sizeMaxPixels",textSizeMinPixels:"sizeMinPixels",textSizeScale:"sizeScale",textSizeUnits:"sizeUnits",textBackground:"background",textBackgroundPadding:"backgroundPadding",textFontFamily:"fontFamily",textFontWeight:"fontWeight",textLineHeight:"lineHeight",textMaxWidth:"maxWidth",textOutlineColor:"outlineColor",textOutlineWidth:"outlineWidth",textWordBreak:"wordBreak",textCharacterSet:"characterSet",textBillboard:"billboard",textFontSettings:"fontSettings",getText:"getText",getTextAngle:"getAngle",getTextColor:"getColor",getTextPixelOffset:"getPixelOffset",getTextSize:"getSize",getTextAnchor:"getTextAnchor",getTextAlignmentBaseline:"getAlignmentBaseline",getTextBackgroundColor:"getBackgroundColor",getTextBorderColor:"getBorderColor",getTextBorderWidth:"getBorderWidth"}}},Pk={type:_o,props:{lineWidthUnits:"widthUnits",lineWidthScale:"widthScale",lineWidthMinPixels:"widthMinPixels",lineWidthMaxPixels:"widthMaxPixels",lineJointRounded:"jointRounded",lineCapRounded:"capRounded",lineMiterLimit:"miterLimit",lineBillboard:"billboard",getLineColor:"getColor",getLineWidth:"getWidth"}},wx={type:Q7,props:{extruded:"extruded",filled:"filled",wireframe:"wireframe",elevationScale:"elevationScale",material:"material",_full3d:"_full3d",getElevation:"getElevation",getFillColor:"getFillColor",getLineColor:"getLineColor"}};function WB({type:t,props:A}){let j={};for(let e in A)j[e]=t.defaultProps[A[e]];return j}function Fx(t,A){let{transitions:j,updateTriggers:e}=t.props,r={updateTriggers:{},transitions:j&&{getPosition:j.geometry}};for(let n in A){let i=A[n],o=t.props[n];n.startsWith("get")&&(o=t.getSubLayerAccessor(o),r.updateTriggers[i]=e[n],j&&(r.transitions[i]=j[n])),r[i]=o}return r}function SC(t){if(Array.isArray(t))return t;switch(NA.assert(t.type,"GeoJSON does not have type"),t.type){case"Feature":return[t];case"FeatureCollection":return NA.assert(Array.isArray(t.features),"GeoJSON does not have features array"),t.features;default:return[{geometry:t}]}}function MF(t,A,j={}){let e={pointFeatures:[],lineFeatures:[],polygonFeatures:[],polygonOutlineFeatures:[]},{startRow:r=0,endRow:n=t.length}=j;for(let i=r;i{o.push(j({geometry:{type:"Point",coordinates:h}},e,r))});break;case"LineString":l.push(j({geometry:t},e,r));break;case"MultiLineString":i.forEach(h=>{l.push(j({geometry:{type:"LineString",coordinates:h}},e,r))});break;case"Polygon":c.push(j({geometry:t},e,r)),i.forEach(h=>{B.push(j({geometry:{type:"LineString",coordinates:h}},e,r))});break;case"MultiPolygon":i.forEach(h=>{c.push(j({geometry:{type:"Polygon",coordinates:h}},e,r)),h.forEach(d=>{B.push(j({geometry:{type:"LineString",coordinates:d}},e,r))})});break;default:}}var SsA={Point:1,MultiPoint:2,LineString:2,MultiLineString:3,Polygon:3,MultiPolygon:4};function RsA(t,A){let j=SsA[t];for(NA.assert(j,`Unknown GeoJSON type ${t}`);A&&--j>0;)A=A[0];return A&&Number.isFinite(A[0])}function RC(){return{points:{},lines:{},polygons:{},polygonsOutline:{}}}function Px(t){return t.geometry.coordinates}function LC(t,A){let j=RC(),{pointFeatures:e,lineFeatures:r,polygonFeatures:n,polygonOutlineFeatures:i}=t;return j.points.data=e,j.points._dataDiff=A.pointFeatures&&(()=>A.pointFeatures),j.points.getPosition=Px,j.lines.data=r,j.lines._dataDiff=A.lineFeatures&&(()=>A.lineFeatures),j.lines.getPath=Px,j.polygons.data=n,j.polygons._dataDiff=A.polygonFeatures&&(()=>A.polygonFeatures),j.polygons.getPolygon=Px,j.polygonsOutline.data=i,j.polygonsOutline._dataDiff=A.polygonOutlineFeatures&&(()=>A.polygonOutlineFeatures),j.polygonsOutline.getPath=Px,j}function CC(t,A){let j=RC(),{points:e,lines:r,polygons:n}=t,i=fC(t,A);return j.points.data={length:e.positions.value.length/e.positions.size,attributes:{...e.attributes,getPosition:e.positions,instancePickingColors:{size:3,value:i.points}},properties:e.properties,numericProps:e.numericProps,featureIds:e.featureIds},j.lines.data={length:r.pathIndices.value.length-1,startIndices:r.pathIndices.value,attributes:{...r.attributes,getPath:r.positions,instancePickingColors:{size:3,value:i.lines}},properties:r.properties,numericProps:r.numericProps,featureIds:r.featureIds},j.lines._pathType="open",j.polygons.data={length:n.polygonIndices.value.length-1,startIndices:n.polygonIndices.value,attributes:{...n.attributes,getPolygon:n.positions,pickingColors:{size:3,value:i.polygons}},properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},j.polygons._normalize=!1,n.triangles&&(j.polygons.data.attributes.indices=n.triangles.value),j.polygonsOutline.data={length:n.primitivePolygonIndices.value.length-1,startIndices:n.primitivePolygonIndices.value,attributes:{...n.attributes,getPath:n.positions,instancePickingColors:{size:3,value:i.polygons}},properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},j.polygonsOutline._pathType="open",j}var LsA=["points","linestrings","polygons"],CsA={...WB(Fk.circle),...WB(Fk.icon),...WB(Fk.text),...WB(Pk),...WB(wx),stroked:!0,filled:!0,extruded:!1,wireframe:!1,_full3d:!1,iconAtlas:{type:"object",value:null},iconMapping:{type:"object",value:{}},getIcon:{type:"accessor",value:t=>t.properties.icon},getText:{type:"accessor",value:t=>t.properties.text},pointType:"circle",getRadius:{deprecatedFor:"getPointRadius"}},Ik=class extends G6{initializeState(){this.state={layerProps:{},features:{},featuresDiff:{}}}updateState({props:A,changeFlags:j}){if(!j.dataChanged)return;let{data:e}=this.props,r=e&&"points"in e&&"polygons"in e&&"lines"in e;this.setState({binary:r}),r?this._updateStateBinary({props:A,changeFlags:j}):this._updateStateJSON({props:A,changeFlags:j})}_updateStateBinary({props:A,changeFlags:j}){let e=CC(A.data,this.encodePickingColor);this.setState({layerProps:e})}_updateStateJSON({props:A,changeFlags:j}){let e=SC(A.data),r=this.getSubLayerRow.bind(this),n={},i={};if(Array.isArray(j.dataChanged)){let l=this.state.features;for(let c in l)n[c]=l[c].slice(),i[c]=[];for(let c of j.dataChanged){let B=MF(e,r,c);for(let h in l)i[h].push(qx({data:n[h],getIndex:d=>d.__source.index,dataRange:c,replace:B[h]}))}}else n=MF(e,r);let o=LC(n,i);this.setState({features:n,featuresDiff:i,layerProps:o})}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e,sourceLayer:r}=j;return j.featureType=LsA.find(n=>r.id.startsWith(`${this.id}-${n}-`)),e>=0&&r.id.startsWith(`${this.id}-points-text`)&&this.state.binary&&(j.index=this.props.data.points.globalFeatureIds.value[e]),j}_updateAutoHighlight(A){let j=`${this.id}-points-`,e=A.featureType==="points";for(let r of this.getSubLayers())r.id.startsWith(j)===e&&r.updateAutoHighlight(A)}_renderPolygonLayer(){let{extruded:A,wireframe:j}=this.props,{layerProps:e}=this.state,r="polygons-fill",n=this.shouldRenderSubLayer(r,e.polygons?.data)&&this.getSubLayerClass(r,wx.type);if(n){let i=Fx(this,wx.props),o=A&&j;return o||delete i.getLineColor,i.updateTriggers.lineColors=o,new n(i,this.getSubLayerProps({id:r,updateTriggers:i.updateTriggers}),e.polygons)}return null}_renderLineLayers(){let{extruded:A,stroked:j}=this.props,{layerProps:e}=this.state,r="polygons-stroke",n="linestrings",i=!A&&j&&this.shouldRenderSubLayer(r,e.polygonsOutline?.data)&&this.getSubLayerClass(r,Pk.type),o=this.shouldRenderSubLayer(n,e.lines?.data)&&this.getSubLayerClass(n,Pk.type);if(i||o){let l=Fx(this,Pk.props);return[i&&new i(l,this.getSubLayerProps({id:r,updateTriggers:l.updateTriggers}),e.polygonsOutline),o&&new o(l,this.getSubLayerProps({id:n,updateTriggers:l.updateTriggers}),e.lines)]}return null}_renderPointLayers(){let{pointType:A}=this.props,{layerProps:j,binary:e}=this.state,{highlightedObjectIndex:r}=this.props;!e&&Number.isFinite(r)&&(r=j.points.data.findIndex(o=>o.__source.index===r));let n=new Set(A.split("+")),i=[];for(let o of n){let l=`points-${o}`,c=Fk[o],B=c&&this.shouldRenderSubLayer(l,j.points?.data)&&this.getSubLayerClass(l,c.type);if(B){let h=Fx(this,c.props),d=j.points;if(o==="text"&&e){let{instancePickingColors:k,...g}=d.data.attributes;d={...d,data:{...d.data,attributes:g}}}i.push(new B(h,this.getSubLayerProps({id:l,updateTriggers:h.updateTriggers,highlightedObjectIndex:r}),d))}}return i}renderLayers(){let{extruded:A}=this.props,j=this._renderPolygonLayer(),e=this._renderLineLayers(),r=this._renderPointLayers();return[!A&&j,e,r,A&&j]}getSubLayerAccessor(A){let{binary:j}=this.state;return!j||typeof A!="function"?super.getSubLayerAccessor(A):(e,r)=>{let{data:n,index:i}=r,o=BC(n,i);return A(o,r)}}};Ik.layerName="GeoJsonLayer";Ik.defaultProps=CsA;var La=Ik;var Ix=class{constructor(A){this.index=A,this.isVisible=!1,this.isSelected=!1,this.parent=null,this.children=[],this.content=null,this._loader=void 0,this._abortController=null,this._loaderId=0,this._isLoaded=!1,this._isCancelled=!1,this._needsReload=!1}get bbox(){return this._bbox}set bbox(A){this._bbox||(this._bbox=A,"west"in A?this.boundingBox=[[A.west,A.south],[A.east,A.north]]:this.boundingBox=[[A.left,A.top],[A.right,A.bottom]])}get data(){return this.isLoading&&this._loader?this._loader.then(()=>this.data):this.content}get isLoaded(){return this._isLoaded&&!this._needsReload}get isLoading(){return!!this._loader&&!this._isCancelled}get needsReload(){return this._needsReload||this._isCancelled}get byteLength(){let A=this.content?this.content.byteLength:0;return Number.isFinite(A)||console.error("byteLength not defined in tile data"),A}async _loadData({getData:A,requestScheduler:j,onLoad:e,onError:r}){let{index:n,id:i,bbox:o,userData:l,zoom:c}=this,B=this._loaderId;this._abortController=new AbortController;let{signal:h}=this._abortController,d=await j.scheduleRequest(this,E=>E.isSelected?1:-1);if(!d){this._isCancelled=!0;return}if(this._isCancelled){d.done();return}let k=null,g;try{k=await A({index:n,id:i,bbox:o,userData:l,zoom:c,signal:h})}catch(E){g=E||!0}finally{d.done()}if(B===this._loaderId){if(this._loader=void 0,this.content=k,this._isCancelled&&!k){this._isLoaded=!1;return}this._isLoaded=!0,this._isCancelled=!1,g?r(g,this):e(this)}}loadData(A){return this._isLoaded=!1,this._isCancelled=!1,this._needsReload=!1,this._loaderId++,this._loader=this._loadData(A),this._loader}setNeedsReload(){this.isLoading&&(this.abort(),this._loader=void 0),this._needsReload=!0}abort(){this.isLoaded||(this._isCancelled=!0,this._abortController?.abort())}};var Ge={OUTSIDE:-1,INTERSECTING:0,INSIDE:1};var L5A=1/Math.PI*180,C5A=1/180*Math.PI,HsA={EPSILON:1e-12,debug:!1,precision:4,printTypes:!1,printDegrees:!1,printRowMajor:!0,_cartographicRadians:!1};globalThis.mathgl=globalThis.mathgl||{config:{...HsA}};var be=globalThis.mathgl.config;function OF(t,{precision:A=be.precision}={}){return t=DsA(t),`${parseFloat(t.toPrecision(A))}`}function Ca(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}function W7(t,A,j){let e=be.EPSILON;j&&(be.EPSILON=j);try{if(t===A)return!0;if(Ca(t)&&Ca(A)){if(t.length!==A.length)return!1;for(let r=0;r0?", ":"")+OF(this[e],A);return`${A.printTypes?this.constructor.name:""}[${j}]`}equals(A){if(!A||this.length!==A.length)return!1;for(let j=0;j=0&&A=0&&A0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function RF(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function ZB(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function Tx(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function Sx(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function Rx(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function VC(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function QC(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function WC(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function YC(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&RF(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}var JC=zsA;var AXA=function(){let t=TF();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;o0?this.copy([A,...j]):this.identity()}copy(A){return this[0]=A[0],this[1]=A[1],this[2]=A[2],this[3]=A[3],this[4]=A[4],this[5]=A[5],this[6]=A[6],this[7]=A[7],this[8]=A[8],this.check()}identity(){return this.copy(UsA)}fromObject(A){return this.check()}fromQuaternion(A){return iH(this,A),this.check()}set(A,j,e,r,n,i,o,l,c){return this[0]=A,this[1]=j,this[2]=e,this[3]=r,this[4]=n,this[5]=i,this[6]=o,this[7]=l,this[8]=c,this.check()}setRowMajor(A,j,e,r,n,i,o,l,c){return this[0]=A,this[1]=r,this[2]=o,this[3]=j,this[4]=n,this[5]=l,this[6]=e,this[7]=i,this[8]=c,this.check()}determinant(){return eH(this)}transpose(){return tH(this,this),this.check()}invert(){return jH(this,this),this.check()}multiplyLeft(A){return CF(this,A,this),this.check()}multiplyRight(A){return CF(this,this,A),this.check()}rotate(A){return nH(this,this,A),this.check()}scale(A){return Array.isArray(A)?HF(this,this,A):HF(this,this,[A,A]),this.check()}translate(A){return rH(this,this,A),this.check()}transform(A,j){let e;switch(A.length){case 2:e=NC(j||[-0,-0],A,this);break;case 3:e=Sx(j||[-0,-0,-0],A,this);break;case 4:e=Ox(j||[-0,-0,-0,-0],A,this);break;default:throw new Error("Illegal vector")}return Mx(e,A.length),e}transformVector(A,j){return this.transform(A,j)}transformVector2(A,j){return this.transform(A,j)}transformVector3(A,j){return this.transform(A,j)}},Nx,Kx=null;function VsA(){return Nx||(Nx=new oe([0,0,0,0,0,0,0,0,0]),Object.freeze(Nx)),Nx}function QsA(){return Kx||(Kx=new oe,Object.freeze(Kx)),Kx}var Xx={};fr(Xx,{add:()=>MaA,adjoint:()=>eaA,clone:()=>YsA,copy:()=>JsA,create:()=>WsA,decompose:()=>maA,determinant:()=>raA,equals:()=>RaA,exactEquals:()=>SaA,frob:()=>IaA,fromQuat:()=>xaA,fromQuat2:()=>paA,fromRotation:()=>BaA,fromRotationTranslation:()=>lH,fromRotationTranslationScale:()=>EaA,fromRotationTranslationScaleOrigin:()=>$aA,fromScaling:()=>uaA,fromTranslation:()=>caA,fromValues:()=>ZsA,fromXRotation:()=>faA,fromYRotation:()=>haA,fromZRotation:()=>daA,frustum:()=>yaA,getRotation:()=>gaA,getScaling:()=>cH,getTranslation:()=>kaA,identity:()=>sH,invert:()=>jaA,lookAt:()=>waA,mul:()=>LaA,multiply:()=>aH,multiplyScalar:()=>OaA,multiplyScalarAndAdd:()=>TaA,ortho:()=>GaA,orthoNO:()=>BH,orthoZO:()=>baA,perspective:()=>vaA,perspectiveFromFieldOfView:()=>qaA,perspectiveNO:()=>uH,perspectiveZO:()=>_aA,rotate:()=>oaA,rotateX:()=>saA,rotateY:()=>aaA,rotateZ:()=>laA,scale:()=>iaA,set:()=>AaA,str:()=>PaA,sub:()=>CaA,subtract:()=>fH,targetTo:()=>FaA,translate:()=>naA,transpose:()=>taA});function WsA(){let t=new ie(16);return ie!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function YsA(t){let A=new ie(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function JsA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function ZsA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new ie(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function AaA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function sH(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function taA(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function jaA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m,G=b*W-v*T+_*z+w*L-x*D+S*F;return G?(G=1/G,t[0]=(o*W-l*T+c*z)*G,t[1]=(r*T-e*W-n*z)*G,t[2]=(E*S-m*x+y*w)*G,t[3]=(d*x-h*S-k*w)*G,t[4]=(l*L-i*W-c*D)*G,t[5]=(j*W-r*L+n*D)*G,t[6]=(m*_-g*S-y*v)*G,t[7]=(B*S-d*_+k*v)*G,t[8]=(i*T-o*L+c*F)*G,t[9]=(e*L-j*T-n*F)*G,t[10]=(g*x-E*_+y*b)*G,t[11]=(h*_-B*x-k*b)*G,t[12]=(o*D-i*z-l*F)*G,t[13]=(j*z-e*D+r*F)*G,t[14]=(E*v-g*w-m*b)*G,t[15]=(B*w-h*v+d*b)*G,t):null}function eaA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],b=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,S=r*c-n*l,F=B*E-h*g,D=B*m-d*g,L=B*y-k*g,z=h*m-d*E,T=h*y-k*E,W=d*y-k*m;return t[0]=o*W-l*T+c*z,t[1]=r*T-e*W-n*z,t[2]=E*S-m*x+y*w,t[3]=d*x-h*S-k*w,t[4]=l*L-i*W-c*D,t[5]=j*W-r*L+n*D,t[6]=m*_-g*S-y*v,t[7]=B*S-d*_+k*v,t[8]=i*T-o*L+c*F,t[9]=e*L-j*T-n*F,t[10]=g*x-E*_+y*b,t[11]=h*_-B*x-k*b,t[12]=o*D-i*z-l*F,t[13]=j*z-e*D+r*F,t[14]=E*v-g*w-m*b,t[15]=B*w-h*v+d*b,t}function raA(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,b=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,S=A*x-j*w+e*_,F=n*x-i*w+o*_,D=c*v-B*b+h*y,L=k*v-g*b+E*y;return l*S-r*F+m*D-d*L}function aH(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],b=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*b,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*b,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*b,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*b,t}function naA(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function iaA(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function oaA(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,b,v,_,w,x,S,F,D,L,z,T,W,G,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],b=A[7],v=A[8],_=A[9],w=A[10],x=A[11],S=r*r*B+l,F=n*r*B+i*c,D=i*r*B-n*c,L=r*n*B-i*c,z=n*n*B+l,T=i*n*B+r*c,W=r*i*B+n*c,G=n*i*B-r*c,jA=i*i*B+l,t[0]=h*S+E*F+v*D,t[1]=d*S+m*F+_*D,t[2]=k*S+y*F+w*D,t[3]=g*S+b*F+x*D,t[4]=h*L+E*z+v*T,t[5]=d*L+m*z+_*T,t[6]=k*L+y*z+w*T,t[7]=g*L+b*z+x*T,t[8]=h*W+E*G+v*jA,t[9]=d*W+m*G+_*jA,t[10]=k*W+y*G+w*jA,t[11]=g*W+b*G+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function saA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function aaA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function laA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function caA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function uaA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function BaA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function faA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function haA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function daA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function lH(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,b=i*c;return t[0]=1-(k+E),t[1]=h+b,t[2]=d-y,t[3]=0,t[4]=h-b,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function paA(t,A){let j=new ie(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),lH(t,A,j),t}function kaA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function cH(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function gaA(t,A){let j=new ie(3);cH(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function maA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,b=i*E,v=o*k,_=l*g,w=c*E,x=B*k,S=h*g,F=d*E,D=m+_+F,L=0;return D>0?(L=Math.sqrt(D+1)*2,t[3]=.25*L,t[0]=(w-S)/L,t[1]=(x-b)/L,t[2]=(y-v)/L):m>_&&m>F?(L=Math.sqrt(1+m-_-F)*2,t[3]=(w-S)/L,t[0]=.25*L,t[1]=(y+v)/L,t[2]=(x+b)/L):_>F?(L=Math.sqrt(1+_-m-F)*2,t[3]=(x-b)/L,t[0]=(y+v)/L,t[1]=.25*L,t[2]=(w+S)/L):(L=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/L,t[0]=(x+b)/L,t[1]=(w+S)/L,t[2]=.25*L),t}function EaA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,b=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-b)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+b)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function $aA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,b=l*c,v=l*B,_=l*h,w=e[0],x=e[1],S=e[2],F=r[0],D=r[1],L=r[2],z=(1-(E+y))*w,T=(k+_)*w,W=(g-v)*w,G=(k-_)*x,jA=(1-(d+y))*x,pA=(m+b)*x,dA=(g+v)*S,$A=(m-b)*S,_A=(1-(d+E))*S;return t[0]=z,t[1]=T,t[2]=W,t[3]=0,t[4]=G,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(z*F+G*D+dA*L),t[13]=j[1]+D-(T*F+jA*D+$A*L),t[14]=j[2]+L-(W*F+pA*D+_A*L),t[15]=1,t}function xaA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function yaA(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function uH(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var vaA=uH;function _aA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function qaA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function BH(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var GaA=BH;function baA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function waA(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],b=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?sH(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=b*k-v*d,i=v*h-y*k,o=y*d-b*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function FaA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function PaA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function IaA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function MaA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function fH(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function OaA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function TaA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function SaA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function RaA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],b=A[0],v=A[1],_=A[2],w=A[3],x=A[4],S=A[5],F=A[6],D=A[7],L=A[8],z=A[9],T=A[10],W=A[11],G=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-b)<=1e-6*Math.max(1,Math.abs(j),Math.abs(b))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-S)<=1e-6*Math.max(1,Math.abs(o),Math.abs(S))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-D)<=1e-6*Math.max(1,Math.abs(c),Math.abs(D))&&Math.abs(B-L)<=1e-6*Math.max(1,Math.abs(B),Math.abs(L))&&Math.abs(h-z)<=1e-6*Math.max(1,Math.abs(h),Math.abs(z))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-W)<=1e-6*Math.max(1,Math.abs(k),Math.abs(W))&&Math.abs(g-G)<=1e-6*Math.max(1,Math.abs(g),Math.abs(G))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var LaA=aH,CaA=fH;function HaA(){let t=new ie(4);return ie!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function hH(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function dH(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function pH(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function kH(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function gH(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function mH(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function EH(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function $H(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}var yXA=function(){let t=HaA();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;o1e-6?(k=Math.acos(d),m=Math.sin(k),g=Math.sin((1-e)*k)/m,E=Math.sin(e*k)/m):(g=1-e,E=e),t[0]=g*r+E*l,t[1]=g*n+E*c,t[2]=g*i+E*B,t[3]=g*o+E*h,t}function wH(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n,o=i?1/i:0;return t[0]=-j*o,t[1]=-e*o,t[2]=-r*o,t[3]=n*o,t}function FH(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=A[3],t}function XF(t,A){let j=A[0]+A[4]+A[8],e;if(j>0)e=Math.sqrt(j+1),t[3]=.5*e,e=.5/e,t[0]=(A[5]-A[7])*e,t[1]=(A[6]-A[2])*e,t[2]=(A[1]-A[3])*e;else{let r=0;A[4]>A[0]&&(r=1),A[8]>A[r*3+r]&&(r=2);let n=(r+1)%3,i=(r+2)%3;e=Math.sqrt(A[r*3+r]-A[n*3+n]-A[i*3+i]+1),t[r]=.5*e,e=.5/e,t[3]=(A[n*3+i]-A[i*3+n])*e,t[n]=(A[n*3+r]+A[r*3+n])*e,t[i]=(A[i*3+r]+A[r*3+i])*e}return t}var PH=hH;var IH=dH,MH=mH,OH=EH,TH=pH;var SH=kH;var RH=gH;var LH=function(){let t=TF(),A=SF(1,0,0),j=SF(0,1,0);return function(e,r,n){let i=RF(r,n);return i<-.999999?(ZB(t,A,r),JC(t)<1e-6&&ZB(t,j,r),UC(t,t),NF(e,t,Math.PI),e):i>.999999?(e[0]=0,e[1]=0,e[2]=0,e[3]=1,e):(ZB(t,r,n),e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=1+i,RH(e,e))}}(),wXA=function(){let t=yH(),A=yH();return function(j,e,r,n,i,o){return Mk(t,e,i,o),Mk(A,r,n,o),Mk(j,t,A,2*o*(1-o)),j}}(),FXA=function(){let t=AH();return function(A,j,e,r){return t[0]=e[0],t[3]=e[1],t[6]=e[2],t[1]=r[0],t[4]=r[1],t[7]=r[2],t[2]=-j[0],t[5]=-j[1],t[8]=-j[2],RH(A,XF(A,t))}}();var NaA=[0,0,0,1],Af=class extends Y7{constructor(A=0,j=0,e=0,r=1){super(-0,-0,-0,-0),Array.isArray(A)&&arguments.length===1?this.copy(A):this.set(A,j,e,r)}copy(A){return this[0]=A[0],this[1]=A[1],this[2]=A[2],this[3]=A[3],this.check()}set(A,j,e,r){return this[0]=A,this[1]=j,this[2]=e,this[3]=r,this.check()}fromObject(A){return this[0]=A.x,this[1]=A.y,this[2]=A.z,this[3]=A.w,this.check()}fromMatrix3(A){return XF(this,A),this.check()}fromAxisRotation(A,j){return NF(this,A,j),this.check()}identity(){return vH(this),this.check()}setAxisAngle(A,j){return this.fromAxisRotation(A,j)}get ELEMENTS(){return 4}get x(){return this[0]}set x(A){this[0]=nj(A)}get y(){return this[1]}set y(A){this[1]=nj(A)}get z(){return this[2]}set z(A){this[2]=nj(A)}get w(){return this[3]}set w(A){this[3]=nj(A)}len(){return TH(this)}lengthSquared(){return SH(this)}dot(A){return MH(this,A)}rotationTo(A,j){return LH(this,A,j),this.check()}add(A){return PH(this,this,A),this.check()}calculateW(){return bH(this,this),this.check()}conjugate(){return FH(this,this),this.check()}invert(){return wH(this,this),this.check()}lerp(A,j,e){return e===void 0?this.lerp(this,A,j):(OH(this,A,j,e),this.check())}multiplyRight(A){return KF(this,this,A),this.check()}multiplyLeft(A){return KF(this,A,this),this.check()}normalize(){let A=this.len(),j=A>0?1/A:0;return this[0]=this[0]*j,this[1]=this[1]*j,this[2]=this[2]*j,this[3]=this[3]*j,A===0&&(this[3]=1),this.check()}rotateX(A){return _H(this,this,A),this.check()}rotateY(A){return qH(this,this,A),this.check()}rotateZ(A){return GH(this,this,A),this.check()}scale(A){return IH(this,this,A),this.check()}slerp(A,j,e){let r,n,i;switch(arguments.length){case 1:({start:r=NaA,target:n,ratio:i}=A);break;case 2:r=this,n=A,i=j;break;default:r=A,n=j,i=e}return Mk(this,r,n,i),this.check()}transformVector4(A,j=new Hx){return $H(j,A,this),Mx(j,4)}lengthSq(){return this.lengthSquared()}setFromAxisAngle(A,j){return this.setAxisAngle(A,j)}premultiply(A){return this.multiplyLeft(A)}multiply(A){return this.multiplyRight(A)}};var Ok={};fr(Ok,{EPSILON1:()=>KaA,EPSILON10:()=>ZaA,EPSILON11:()=>A7A,EPSILON12:()=>t7A,EPSILON13:()=>j7A,EPSILON14:()=>e7A,EPSILON15:()=>r7A,EPSILON16:()=>n7A,EPSILON17:()=>i7A,EPSILON18:()=>o7A,EPSILON19:()=>s7A,EPSILON2:()=>XaA,EPSILON20:()=>a7A,EPSILON3:()=>zaA,EPSILON4:()=>UaA,EPSILON5:()=>VaA,EPSILON6:()=>QaA,EPSILON7:()=>WaA,EPSILON8:()=>YaA,EPSILON9:()=>JaA,PI_OVER_FOUR:()=>c7A,PI_OVER_SIX:()=>u7A,PI_OVER_TWO:()=>l7A,TWO_PI:()=>B7A});var KaA=.1,XaA=.01,zaA=.001,UaA=1e-4,VaA=1e-5,QaA=1e-6,WaA=1e-7,YaA=1e-8,JaA=1e-9,ZaA=1e-10,A7A=1e-11,t7A=1e-12,j7A=1e-13,e7A=1e-14,r7A=1e-15,n7A=1e-16,i7A=1e-17,o7A=1e-18,s7A=1e-19,a7A=1e-20,l7A=Math.PI/2,c7A=Math.PI/4,u7A=Math.PI/6,B7A=Math.PI*2;var CH=new LA,f7A=new LA,tf=class t{constructor(A=[0,0,0],j=[0,0,0],e){e=e||CH.copy(A).add(j).scale(.5),this.center=new LA(e),this.halfDiagonal=new LA(j).subtract(this.center),this.minimum=new LA(A),this.maximum=new LA(j)}clone(){return new t(this.minimum,this.maximum,this.center)}equals(A){return this===A||!!A&&this.minimum.equals(A.minimum)&&this.maximum.equals(A.maximum)}transform(A){return this.center.transformAsPoint(A),this.halfDiagonal.transform(A),this.minimum.transform(A),this.maximum.transform(A),this}intersectPlane(A){let{halfDiagonal:j}=this,e=f7A.from(A.normal),r=j.x*Math.abs(e.x)+j.y*Math.abs(e.y)+j.z*Math.abs(e.z),n=this.center.dot(e)+A.distance;return n-r>0?Ge.INSIDE:n+r<0?Ge.OUTSIDE:Ge.INTERSECTING}distanceTo(A){return Math.sqrt(this.distanceSquaredTo(A))}distanceSquaredTo(A){let j=CH.from(A).subtract(this.center),{halfDiagonal:e}=this,r=0,n;return n=Math.abs(j.x)-e.x,n>0&&(r+=n*n),n=Math.abs(j.y)-e.y,n>0&&(r+=n*n),n=Math.abs(j.z)-e.z,n>0&&(r+=n*n),r}};var Tk=new LA,HH=new LA,jf=class t{constructor(A=[0,0,0],j=0){this.radius=-0,this.center=new LA,this.fromCenterRadius(A,j)}fromCenterRadius(A,j){return this.center.from(A),this.radius=j,this}fromCornerPoints(A,j){return j=Tk.from(j),this.center=new LA().from(A).add(j).scale(.5),this.radius=this.center.distance(j),this}equals(A){return this===A||!!A&&this.center.equals(A.center)&&this.radius===A.radius}clone(){return new t(this.center,this.radius)}union(A){let j=this.center,e=this.radius,r=A.center,n=A.radius,i=Tk.copy(r).subtract(j),o=i.magnitude();if(e>=o+n)return this.clone();if(n>=o+e)return A.clone();let l=(e+o+n)*.5;return HH.copy(i).scale((-e+l)/o).add(j),this.center.copy(HH),this.radius=l,this}expand(A){let e=Tk.from(A).subtract(this.center).magnitude();return e>this.radius&&(this.radius=e),this}transform(A){this.center.transform(A);let j=Xx.getScaling(Tk,A);return this.radius=Math.max(j[0],Math.max(j[1],j[2]))*this.radius,this}distanceSquaredTo(A){let j=this.distanceTo(A);return j*j}distanceTo(A){let e=Tk.from(A).subtract(this.center);return Math.max(0,e.len()-this.radius)}intersectPlane(A){let j=this.center,e=this.radius,n=A.normal.dot(j)+A.distance;return n<-e?Ge.OUTSIDE:n=l?Ge.INSIDE:Ge.INTERSECTING}distanceTo(A){return Math.sqrt(this.distanceSquaredTo(A))}distanceSquaredTo(A){let j=d7A.from(A).subtract(this.center),e=this.halfAxes,r=e.getColumn(0,zx),n=e.getColumn(1,Ux),i=e.getColumn(2,Vx),o=r.magnitude(),l=n.magnitude(),c=i.magnitude();r.normalize(),n.normalize(),i.normalize();let B=0,h;return h=Math.abs(j.dot(r))-o,h>0&&(B+=h*h),h=Math.abs(j.dot(n))-l,h>0&&(B+=h*h),h=Math.abs(j.dot(i))-c,h>0&&(B+=h*h),B}computePlaneDistances(A,j,e=[-0,-0]){let r=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,i=this.center,o=this.halfAxes,l=o.getColumn(0,zx),c=o.getColumn(1,Ux),B=o.getColumn(2,Vx),h=p7A.copy(l).add(c).add(B).add(i),d=k7A.copy(h).subtract(A),k=j.dot(d);return r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).add(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).subtract(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).subtract(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).add(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).add(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).subtract(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).subtract(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),e[0]=r,e[1]=n,e}transform(A){this.center.transformAsPoint(A);let j=this.halfAxes.getColumn(0,zx);j.transformAsPoint(A);let e=this.halfAxes.getColumn(1,Ux);e.transformAsPoint(A);let r=this.halfAxes.getColumn(2,Vx);return r.transformAsPoint(A),this.halfAxes=new oe([...j,...e,...r]),this}getTransform(){throw new Error("not implemented")}};var DH=new LA,NH=new LA,Da=class t{constructor(A=[0,0,1],j=0){this.normal=new LA,this.distance=-0,this.fromNormalDistance(A,j)}fromNormalDistance(A,j){return ps(Number.isFinite(j)),this.normal.from(A).normalize(),this.distance=j,this}fromPointNormal(A,j){A=DH.from(A),this.normal.from(j).normalize();let e=-this.normal.dot(A);return this.distance=e,this}fromCoefficients(A,j,e,r){return this.normal.set(A,j,e),ps(W7(this.normal.len(),1)),this.distance=r,this}clone(){return new t(this.normal,this.distance)}equals(A){return W7(this.distance,A.distance)&&W7(this.normal,A.normal)}getPointDistance(A){return this.normal.dot(A)+this.distance}transform(A){let j=NH.copy(this.normal).transformAsVector(A).normalize(),e=this.normal.scale(-this.distance).transform(A);return this.fromPointNormal(e,j)}projectPointOntoPlane(A,j=[0,0,0]){let e=DH.from(A),r=this.getPointDistance(e),n=NH.copy(this.normal).scale(r);return e.subtract(n).to(j)}};var KH=[new LA([1,0,0]),new LA([0,1,0]),new LA([0,0,1])],XH=new LA,g7A=new LA,Na=class t{constructor(A=[]){this.planes=A}fromBoundingSphere(A){this.planes.length=2*KH.length;let j=A.center,e=A.radius,r=0;for(let n of KH){let i=this.planes[r],o=this.planes[r+1];i||(i=this.planes[r]=new Da),o||(o=this.planes[r+1]=new Da);let l=XH.copy(n).scale(-e).add(j);i.fromPointNormal(l,n);let c=XH.copy(n).scale(e).add(j),B=g7A.copy(n).negate();o.fromPointNormal(c,B),r+=2}return this}computeVisibility(A){let j=Ge.INSIDE;for(let e of this.planes)switch(A.intersectPlane(e)){case Ge.OUTSIDE:return Ge.OUTSIDE;case Ge.INTERSECTING:j=Ge.INTERSECTING;break;default:}return j}computeVisibilityWithPlaneMask(A,j){if(ps(Number.isFinite(j),"parentPlaneMask is required."),j===t.MASK_OUTSIDE||j===t.MASK_INSIDE)return j;let e=t.MASK_INSIDE,r=this.planes;for(let n=0;nl;)v7A(o,Qx),zH.copy(Qx).transpose(),o.multiplyRight(Qx),o.multiplyLeft(zH),i.multiplyRight(Qx),++r>2&&(++n,r=0);return A.unitary=i.toTarget(A.unitary),A.diagonal=o.toTarget(A.diagonal),A}function x7A(t){let A=0;for(let j=0;j<9;++j){let e=t[j];A+=e*e}return Math.sqrt(A)}var zF=[1,0,0],UF=[2,2,1];function y7A(t){let A=0;for(let j=0;j<3;++j){let e=t[ks.getElementIndex(UF[j],zF[j])];A+=2*e*e}return Math.sqrt(A)}function v7A(t,A){let j=Ok.EPSILON15,e=0,r=1;for(let c=0;c<3;++c){let B=Math.abs(t[ks.getElementIndex(UF[c],zF[c])]);B>e&&(r=c,e=B)}let n=zF[r],i=UF[r],o=1,l=0;if(Math.abs(t[ks.getElementIndex(i,n)])>j){let c=t[ks.getElementIndex(i,i)],B=t[ks.getElementIndex(n,n)],h=t[ks.getElementIndex(i,n)],d=(c-B)/2/h,k;d<0?k=-1/(-d+Math.sqrt(1+d*d)):k=1/(d+Math.sqrt(1+d*d)),o=1/Math.sqrt(1+k*k),l=k*o}return oe.IDENTITY.to(A),A[ks.getElementIndex(n,n)]=A[ks.getElementIndex(i,i)]=o,A[ks.getElementIndex(i,n)]=l,A[ks.getElementIndex(n,i)]=-l,A}var J7=new LA,_7A=new LA,q7A=new LA,G7A=new LA,b7A=new LA,w7A=new oe,F7A={diagonal:new oe,unitary:new oe};function QF(t,A=new Sk){if(!t||t.length===0)return A.halfAxes=new oe([0,0,0,0,0,0,0,0,0]),A.center=new LA,A;let j=t.length,e=new LA(0,0,0);for(let D of t)e.add(D);let r=1/j;e.multiplyByScalar(r);let n=0,i=0,o=0,l=0,c=0,B=0;for(let D of t){let L=J7.copy(D).subtract(e);n+=L.x*L.x,i+=L.x*L.y,o+=L.x*L.z,l+=L.y*L.y,c+=L.y*L.z,B+=L.z*L.z}n*=r,i*=r,o*=r,l*=r,c*=r,B*=r;let h=w7A;h[0]=n,h[1]=i,h[2]=o,h[3]=i,h[4]=l,h[5]=c,h[6]=o,h[7]=c,h[8]=B;let{unitary:d}=VF(h,F7A),k=A.halfAxes.copy(d),g=k.getColumn(0,q7A),E=k.getColumn(1,G7A),m=k.getColumn(2,b7A),y=-Number.MAX_VALUE,b=-Number.MAX_VALUE,v=-Number.MAX_VALUE,_=Number.MAX_VALUE,w=Number.MAX_VALUE,x=Number.MAX_VALUE;for(let D of t)J7.copy(D),y=Math.max(J7.dot(g),y),b=Math.max(J7.dot(E),b),v=Math.max(J7.dot(m),v),_=Math.min(J7.dot(g),_),w=Math.min(J7.dot(E),w),x=Math.min(J7.dot(m),x);g=g.multiplyByScalar(.5*(_+y)),E=E.multiplyByScalar(.5*(w+b)),m=m.multiplyByScalar(.5*(x+v)),A.center.copy(g).add(E).add(m);let S=_7A.set(y-_,b-w,v-x).multiplyByScalar(.5),F=new oe([S[0],0,0,0,S[1],0,0,0,S[2]]);return A.halfAxes.multiplyRight(F),A}var ef=512,UH=3,VH=[[.5,.5],[0,0],[0,1],[1,0],[1,1]],QH=VH.concat([[0,.5],[.5,0],[1,.5],[.5,1]]),P7A=QH.concat([[.25,.5],[.75,.5]]),WF=class t{constructor(A,j,e){this.x=A,this.y=j,this.z=e}get children(){if(!this._children){let A=this.x*2,j=this.y*2,e=this.z+1;this._children=[new t(A,j,e),new t(A,j+1,e),new t(A+1,j,e),new t(A+1,j+1,e)]}return this._children}update(A){let{viewport:j,cullingVolume:e,elevationBounds:r,minZ:n,maxZ:i,bounds:o,offset:l,project:c}=A,B=this.getBoundingVolume(r,l,c);if(o&&!this.insideBounds(o)||e.computeVisibility(B)<0)return!1;if(!this.childVisible){let{z:d}=this;if(d=n){let k=B.distanceTo(j.cameraPosition)*j.scale/j.height;d+=Math.floor(Math.log2(k))}if(d>=i)return this.selected=!0,!0}this.selected=!1,this.childVisible=!0;for(let d of this.children)d.update(A);return!0}getSelected(A=[]){if(this.selected&&A.push(this),this._children)for(let j of this._children)j.getSelected(A);return A}insideBounds([A,j,e,r]){let n=Math.pow(2,this.z),i=ef/n;return this.x*iA&&(this.y+1)*i>j}getBoundingVolume(A,j,e){if(e){let l=this.z<1?P7A:this.z<2?QH:VH,c=[];for(let B of l){let h=Wx(this.x+B[0],this.y+B[1],this.z);h[2]=A[0],c.push(e(h)),A[0]!==A[1]&&(h[2]=A[1],c.push(e(h)))}return QF(c)}let r=Math.pow(2,this.z),n=ef/r,i=this.x*n+j*ef,o=ef-(this.y+1)*n;return new tf([i,o,A[0]],[i+n,o+n,A[1]])}};function WH(t,A,j,e){let r=t instanceof Mc&&t.resolution?t.projectPosition:null,n=Object.values(t.getFrustumPlanes()).map(({normal:k,distance:g})=>new Da(k.clone().negate(),g)),i=new Na(n),o=t.distanceScales.unitsPerMeter[2],l=j&&j[0]*o||0,c=j&&j[1]*o||0,B=t instanceof Fa&&t.pitch<=60?A:0;if(e){let[k,g,E,m]=e,y=In([k,m]),b=In([E,g]);e=[y[0],ef-y[1],b[0],ef-b[1]]}let h=new WF(0,0,0),d={viewport:t,project:r,cullingVolume:i,elevationBounds:[l,c],minZ:B,maxZ:A,bounds:e,offset:0};if(h.update(d),t instanceof Fa&&t.subViewports&&t.subViewports.length>1){for(d.offset=-1;h.update(d)&&!(--d.offset<-UH););for(d.offset=1;h.update(d)&&!(++d.offset>UH););}return h.getSelected()}var Ka=512,I7A=[-1/0,-1/0,1/0,1/0],JF={type:"object",value:null,validate:(t,A)=>A.optional&&t===null||typeof t=="string"||Array.isArray(t)&&t.every(j=>typeof j=="string"),equal:(t,A)=>{if(t===A)return!0;if(!Array.isArray(t)||!Array.isArray(A))return!1;let j=t.length;if(j!==A.length)return!1;for(let e=0;er[0])),Math.min(...j.map(r=>r[1])),Math.max(...j.map(r=>r[0])),Math.max(...j.map(r=>r[1]))]}function M7A(t){return Math.abs(t.split("").reduce((A,j)=>(A<<5)-A+j.charCodeAt(0)|0,0))}function ZF(t,A){if(!t||!t.length)return null;let{index:j,id:e}=A;if(Array.isArray(t)){let n=M7A(e)%t.length;t=t[n]}let r=t;for(let n of Object.keys(j)){let i=new RegExp(`{${n}}`,"g");r=r.replace(i,String(j[n]))}return Number.isInteger(j.y)&&Number.isInteger(j.z)&&(r=r.replace(/\{-y\}/g,String(Math.pow(2,j.z)-j.y-1))),r}function O7A(t,A,j){let e;if(A&&A.length===2){let[r,n]=A,i=t.getBounds({z:r}),o=t.getBounds({z:n});e=[Math.min(i[0],o[0]),Math.min(i[1],o[1]),Math.max(i[2],o[2]),Math.max(i[3],o[3])]}else e=t.getBounds();return t.isGeospatial?[Math.max(e[0],j[0]),Math.max(e[1],j[1]),Math.min(e[2],j[2]),Math.min(e[3],j[3])]:[Math.max(Math.min(e[0],j[2]),j[0]),Math.max(Math.min(e[1],j[3]),j[1]),Math.min(Math.max(e[2],j[0]),j[2]),Math.min(Math.max(e[3],j[1]),j[3])]}function ZH({viewport:t,z:A,cullRect:j}){return(t.subViewports||[t]).map(r=>YF(r,A||0,j))}function YF(t,A,j){if(!Array.isArray(A)){let n=j.x-t.x,i=j.y-t.y,{width:o,height:l}=j,c={targetZ:A},B=t.unproject([n,i],c),h=t.unproject([n+o,i],c),d=t.unproject([n,i+l],c),k=t.unproject([n+o,i+l],c);return[Math.min(B[0],h[0],d[0],k[0]),Math.min(B[1],h[1],d[1],k[1]),Math.max(B[0],h[0],d[0],k[0]),Math.max(B[1],h[1],d[1],k[1])]}let e=YF(t,A[0],j),r=YF(t,A[1],j);return[Math.min(e[0],r[0]),Math.min(e[1],r[1]),Math.max(e[2],r[2]),Math.max(e[3],r[3])]}function T7A(t,A,j){return j?JH(t,j).map(r=>r*A/Ka):t.map(e=>e*A/Ka)}function A1(t,A){return Math.pow(2,t)*Ka/A}function Wx(t,A,j){let e=A1(j,Ka),r=t/e*360-180,n=Math.PI-2*Math.PI*A/e,i=180/Math.PI*Math.atan(.5*(Math.exp(n)-Math.exp(-n)));return[r,i]}function YH(t,A,j,e){let r=A1(j,e);return[t/r*Ka,A/r*Ka]}function t1(t,A,j,e,r=Ka){if(t.isGeospatial){let[c,B]=Wx(A,j,e),[h,d]=Wx(A+1,j+1,e);return{west:c,north:B,east:h,south:d}}let[n,i]=YH(A,j,e,r),[o,l]=YH(A+1,j+1,e,r);return{left:n,top:i,right:o,bottom:l}}function S7A(t,A,j,e,r){let n=O7A(t,null,e),i=A1(A,j),[o,l,c,B]=T7A(n,i,r),h=[];for(let d=Math.floor(o);dA&&(c=A);let B=r;return i&&o&&r&&!t.isGeospatial&&(B=JH(r,i)),t.isGeospatial?WH(t,c,e,r):S7A(t,c,n,B||I7A,o)}function AD(t){let A={},j;return e=>{for(let r in e)if(!R7A(e[r],A[r])){j=t(e),A=e;break}return j}}function R7A(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{}},N7A={extent:null,tileSize:512,maxZoom:null,minZoom:null,maxCacheSize:null,maxCacheByteSize:null,refinementStrategy:"best-available",zRange:null,maxRequests:6,debounceTime:0,zoomOffset:0,onTileLoad:()=>{},onTileUnload:()=>{},onTileError:()=>{}},rf=class{constructor(A){this._getCullBounds=AD(ZH),this.opts={...N7A,...A},this.setOptions(this.opts),this.onTileLoad=j=>{this.opts.onTileLoad?.(j),this.opts.maxCacheByteSize!=null&&(this._cacheByteSize+=j.byteLength,this._resizeCache())},this._requestScheduler=new oB({throttleRequests:this.opts.maxRequests>0||this.opts.debounceTime>0,maxRequests:this.opts.maxRequests,debounceTime:this.opts.debounceTime}),this._cache=new Map,this._tiles=[],this._dirty=!1,this._cacheByteSize=0,this._viewport=null,this._zRange=null,this._selectedTiles=null,this._frameNumber=0,this._modelMatrix=new lj,this._modelMatrixInverse=new lj}get tiles(){return this._tiles}get selectedTiles(){return this._selectedTiles}get isLoaded(){return this._selectedTiles!==null&&this._selectedTiles.every(A=>A.isLoaded)}get needsReload(){return this._selectedTiles!==null&&this._selectedTiles.some(A=>A.needsReload)}setOptions(A){Object.assign(this.opts,A),Number.isFinite(A.maxZoom)&&(this._maxZoom=Math.floor(A.maxZoom)),Number.isFinite(A.minZoom)&&(this._minZoom=Math.ceil(A.minZoom))}finalize(){for(let A of this._cache.values())A.isLoading&&A.abort();this._cache.clear(),this._tiles=[],this._selectedTiles=null}reloadAll(){for(let A of this._cache.keys()){let j=this._cache.get(A);!this._selectedTiles||!this._selectedTiles.includes(j)?this._cache.delete(A):j.setNeedsReload()}}update(A,{zRange:j,modelMatrix:e}={zRange:null,modelMatrix:null}){let r=e?new lj(e):new lj,n=!r.equals(this._modelMatrix);if(!this._viewport||!A.equals(this._viewport)||!Bo(this._zRange,j)||n){n&&(this._modelMatrixInverse=r.clone().invert(),this._modelMatrix=r),this._viewport=A,this._zRange=j;let o=this.getTileIndices({viewport:A,maxZoom:this._maxZoom,minZoom:this._minZoom,zRange:j,modelMatrix:this._modelMatrix,modelMatrixInverse:this._modelMatrixInverse});this._selectedTiles=o.map(l=>this._getTile(l,!0)),this._dirty&&this._rebuildTree()}else this.needsReload&&(this._selectedTiles=this._selectedTiles.map(o=>this._getTile(o.index,!0)));let i=this.updateTileStates();return this._pruneRequests(),this._dirty&&this._resizeCache(),i&&this._frameNumber++,this._frameNumber}isTileVisible(A,j){if(!A.isVisible)return!1;if(j&&this._viewport){let e=this._getCullBounds({viewport:this._viewport,z:this._zRange,cullRect:j}),{bbox:r}=A;for(let[n,i,o,l]of e){let c;if("west"in r)c=r.westn&&r.southi;else{let B=Math.min(r.top,r.bottom),h=Math.max(r.top,r.bottom);c=r.leftn&&Bi}if(c)return!0}return!1}return!0}getTileIndices({viewport:A,maxZoom:j,minZoom:e,zRange:r,modelMatrix:n,modelMatrixInverse:i}){let{tileSize:o,extent:l,zoomOffset:c}=this.opts;return j1({viewport:A,maxZoom:j,minZoom:e,zRange:r,tileSize:o,extent:l,modelMatrix:n,modelMatrixInverse:i,zoomOffset:c})}getTileId(A){return`${A.x}-${A.y}-${A.z}`}getTileZoom(A){return A.z}getTileMetadata(A){let{tileSize:j}=this.opts;return{bbox:t1(this._viewport,A.x,A.y,A.z,j)}}getParentIndex(A){let j=Math.floor(A.x/2),e=Math.floor(A.y/2),r=A.z-1;return{x:j,y:e,z:r}}updateTileStates(){let A=this.opts.refinementStrategy||Rk,j=new Array(this._cache.size),e=0;for(let r of this._cache.values())j[e++]=r.isVisible,r.isSelected=!1,r.isVisible=!1;for(let r of this._selectedTiles)r.isSelected=!0,r.isVisible=!0;(typeof A=="function"?A:D7A[A])(Array.from(this._cache.values())),e=0;for(let r of this._cache.values())if(j[e++]!==r.isVisible)return!0;return!1}_pruneRequests(){let{maxRequests:A=0}=this.opts,j=[],e=0;for(let r of this._cache.values())r.isLoading&&(e++,!r.isSelected&&!r.isVisible&&j.push(r));for(;A>0&&e>A&&j.length>0;)j.shift().abort(),e--}_rebuildTree(){let{_cache:A}=this;for(let j of A.values())j.parent=null,j.children&&(j.children.length=0);for(let j of A.values()){let e=this._getNearestAncestor(j);j.parent=e,e?.children&&e.children.push(j)}}_resizeCache(){let{_cache:A,opts:j}=this,e=j.maxCacheSize??(j.maxCacheByteSize!=null?1/0:H7A*this.selectedTiles.length),r=j.maxCacheByteSize??1/0;if(A.size>e||this._cacheByteSize>r){for(let[i,o]of A)if(!o.isVisible&&!o.isSelected&&(this._cacheByteSize-=j.maxCacheByteSize!=null?o.byteLength:0,A.delete(i),this.opts.onTileUnload?.(o)),A.size<=e&&this._cacheByteSize<=r)break;this._rebuildTree(),this._dirty=!0}this._dirty&&(this._tiles=Array.from(this._cache.values()).sort((i,o)=>i.zoom-o.zoom),this._dirty=!1)}_getTile(A,j){let e=this.getTileId(A),r=this._cache.get(e),n=!1;return!r&&j?(r=new Ix(A),Object.assign(r,this.getTileMetadata(r.index)),Object.assign(r,{id:e,zoom:this.getTileZoom(r.index)}),n=!0,this._cache.set(e,r),this._dirty=!0):r&&r.needsReload&&(n=!0),r&&n&&r.loadData({getData:this.opts.getTileData,requestScheduler:this._requestScheduler,onLoad:this.onTileLoad,onError:this.opts.onTileError}),r}_getNearestAncestor(A){let{_minZoom:j=0}=this,e=A.index;for(;this.getTileZoom(e)>j;){e=this.getParentIndex(e);let r=this._getTile(e);if(r)return r}return null}};function K7A(t){for(let A of t)A.state=0;for(let A of t)A.isSelected&&!jD(A)&&e1(A);for(let A of t)A.isVisible=!!(A.state&Yx)}function X7A(t){for(let j of t)j.state=0;for(let j of t)j.isSelected&&jD(j);let A=Array.from(t).sort((j,e)=>j.zoom-e.zoom);for(let j of A)if(j.isVisible=!!(j.state&Yx),j.children&&(j.isVisible||j.state&tD))for(let e of j.children)e.state=tD;else j.isSelected&&e1(j)}function jD(t){let A=t;for(;A;){if(A.isLoaded||A.content)return A.state|=Yx,!0;A=A.parent}return!1}function e1(t){for(let A of t.children)A.isLoaded||A.content?A.state|=Yx:e1(A)}var z7A={TilesetClass:rf,data:{type:"data",value:[]},dataComparator:JF.equal,renderSubLayers:{type:"function",value:t=>new La(t)},getTileData:{type:"function",optional:!0,value:null},onViewportLoad:{type:"function",optional:!0,value:null},onTileLoad:{type:"function",value:t=>{}},onTileUnload:{type:"function",value:t=>{}},onTileError:{type:"function",value:t=>console.error(t)},extent:{type:"array",optional:!0,value:null,compare:!0},tileSize:512,maxZoom:null,minZoom:0,maxCacheSize:null,maxCacheByteSize:null,refinementStrategy:Rk,zRange:null,maxRequests:6,debounceTime:0,zoomOffset:0},Lk=class extends G6{initializeState(){this.state={tileset:null,isLoaded:!1}}finalizeState(){this.state?.tileset?.finalize()}get isLoaded(){return!!this.state?.tileset?.selectedTiles?.every(A=>A.isLoaded&&A.layers&&A.layers.every(j=>j.isLoaded))}shouldUpdateState({changeFlags:A}){return A.somethingChanged}updateState({changeFlags:A}){let{tileset:j}=this.state,e=A.propsOrDataChanged||A.updateTriggersChanged,r=A.dataChanged||A.updateTriggersChanged&&(A.updateTriggersChanged.all||A.updateTriggersChanged.getTileData);j?e&&(j.setOptions(this._getTilesetOptions()),r?j.reloadAll():j.tiles.forEach(n=>{n.layers=null})):(j=new this.props.TilesetClass(this._getTilesetOptions()),this.setState({tileset:j})),this._updateTileset()}_getTilesetOptions(){let{tileSize:A,maxCacheSize:j,maxCacheByteSize:e,refinementStrategy:r,extent:n,maxZoom:i,minZoom:o,maxRequests:l,debounceTime:c,zoomOffset:B}=this.props;return{maxCacheSize:j,maxCacheByteSize:e,maxZoom:i,minZoom:o,tileSize:A,refinementStrategy:r,extent:n,maxRequests:l,debounceTime:c,zoomOffset:B,getTileData:this.getTileData.bind(this),onTileLoad:this._onTileLoad.bind(this),onTileError:this._onTileError.bind(this),onTileUnload:this._onTileUnload.bind(this)}}_updateTileset(){let A=this.state.tileset,{zRange:j,modelMatrix:e}=this.props,r=A.update(this.context.viewport,{zRange:j,modelMatrix:e}),{isLoaded:n}=A,i=this.state.isLoaded!==n,o=this.state.frameNumber!==r;n&&(i||o)&&this._onViewportLoad(),o&&this.setState({frameNumber:r}),this.state.isLoaded=n}_onViewportLoad(){let{tileset:A}=this.state,{onViewportLoad:j}=this.props;j&&j(A.selectedTiles)}_onTileLoad(A){this.props.onTileLoad(A),A.layers=null,this.setNeedsUpdate()}_onTileError(A,j){this.props.onTileError(A),j.layers=null,this.setNeedsUpdate()}_onTileUnload(A){this.props.onTileUnload(A)}getTileData(A){let{data:j,getTileData:e,fetch:r}=this.props,{signal:n}=A;return A.url=typeof j=="string"||Array.isArray(j)?ZF(j,A):null,e?e(A):r&&A.url?r(A.url,{propName:"data",layer:this,signal:n}):null}renderSubLayers(A){return this.props.renderSubLayers(A)}getSubLayerPropsByTile(A){return null}getPickingInfo(A){let j=A.sourceLayer,e=j.props.tile,r=A.info;return r.picked&&(r.tile=e),r.sourceTile=e,r.sourceTileSubLayer=j,r}_updateAutoHighlight(A){A.sourceTileSubLayer.updateAutoHighlight(A)}renderLayers(){return this.state.tileset.tiles.map(A=>{let j=this.getSubLayerPropsByTile(A);if(!(!A.isLoaded&&!A.content))if(A.layers)j&&A.layers[0]&&Object.keys(j).some(e=>A.layers[0].props[e]!==j[e])&&(A.layers=A.layers.map(e=>e.clone(j)));else{let e=this.renderSubLayers({...this.props,...this.getSubLayerProps({id:A.id,updateTriggers:this.props.updateTriggers}),data:A.content,_offset:0,tile:A});A.layers=Ia(e,Boolean).map(r=>r.clone({tile:A,...j}))}return A.layers})}filterSubLayer({layer:A,cullRect:j}){let{tile:e}=A.props;return this.state.tileset.isTileVisible(e,j)}};Lk.defaultProps=z7A;Lk.layerName="TileLayer";var Sc=Lk;var Jx=(t,A,j)=>new N7({parent:t,controller:{doubleClickZoom:!1},width:A,height:j});var nf=(t="")=>t==="point-cloud"?[new cx({id:"orbit"})]:[new un({id:"ortho"})];var Nt={},Z7=t=>{Nt={fetch:{headers:{}}},t&&(Nt.fetch.headers.Authorization=`Bearer ${t}`)};var U7A=1e-6,eD=(t=0,A=[0,0])=>{let j=t*Math.PI/180,e=Math.abs(j)>U7A,r=Math.sin(j),n=Math.cos(j),i={angleDegrees:t,angleRadians:j,hasRotation:e,sin:r,cos:n,center:A,modelMatrix:null};if(e){let o=new lj().translate([A[0],A[1],0]).rotateZ(j).translate([-A[0],-A[1],0]);i.modelMatrix=Array.from(o)}return i},Er=t=>t?.hasRotation&&t.modelMatrix?{modelMatrix:t.modelMatrix}:{},r1=(t,A,j)=>{if(!j?.hasRotation)return[t,A];let{center:e,sin:r,cos:n}=j,i=t-e[0],o=A-e[1];return[n*i-r*o+e[0],r*i+n*o+e[1]]},rD=(t,A,j)=>{if(!j?.hasRotation)return[t,A];let{center:e,sin:r,cos:n}=j,i=t-e[0],o=A-e[1];return[n*i+r*o+e[0],-r*i+n*o+e[1]]};function Rc(t){"@babel/helpers - typeof";return Rc=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(A){return typeof A}:function(A){return A&&typeof Symbol=="function"&&A.constructor===Symbol&&A!==Symbol.prototype?"symbol":typeof A},Rc(t)}function nD(t,A){if(Rc(t)!="object"||!t)return t;var j=t[Symbol.toPrimitive];if(j!==void 0){var e=j.call(t,A||"default");if(Rc(e)!="object")return e;throw new TypeError("@@toPrimitive must return a primitive value.")}return(A==="string"?String:Number)(t)}function iD(t){var A=nD(t,"string");return Rc(A)=="symbol"?A:A+""}var Lc={};Lc.EPSILON=1e-12;Lc.debug=!0;Lc.precision=4;Lc.printTypes=!1;Lc.printDegrees=!1;Lc.printRowMajor=!0;function oD(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&t.length!==void 0}function sD(t){return t.clone?t.clone():new Array(t)}function V7A(t,A){if(oD(t)){for(var j=sD(t),e=0;et.position},getSize:{type:"accessor",value:1},getAngle:{type:"accessor",value:0},getPixelOffset:{type:"accessor",value:[0,0]},getBoundingRect:{type:"accessor",value:[0,0,0,0]},getFillColor:{type:"accessor",value:[0,0,0,255]},getLineColor:{type:"accessor",value:[0,0,0,255]},getLineWidth:{type:"accessor",value:1}},Fk=class extends gr{getShaders(){return super.getShaders({vs:SC,fs:RC,modules:[Lr,Cr]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:"float64",fp64:this.use64bitPositions(),transition:!0,accessor:"getPosition"},instanceSizes:{size:1,transition:!0,accessor:"getSize",defaultValue:1},instanceAngles:{size:1,transition:!0,accessor:"getAngle"},instanceRects:{size:4,accessor:"getBoundingRect"},instancePixelOffsets:{size:2,transition:!0,accessor:"getPixelOffset"},instanceFillColors:{size:4,transition:!0,type:"unorm8",accessor:"getFillColor",defaultValue:[0,0,0,255]},instanceLineColors:{size:4,transition:!0,type:"unorm8",accessor:"getLineColor",defaultValue:[0,0,0,255]},instanceLineWidths:{size:1,transition:!0,accessor:"getLineWidth",defaultValue:1}})}updateState(A){super.updateState(A);let{changeFlags:j}=A;j.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:A}){let{billboard:j,sizeScale:e,sizeUnits:r,sizeMinPixels:n,sizeMaxPixels:i,getLineWidth:o}=this.props,{padding:l}=this.props;l.length<4&&(l=[l[0],l[1],l[0],l[1]]);let c=this.state.model;c.setUniforms(A),c.setUniforms({billboard:j,stroked:!!o,padding:l,sizeUnits:an[r],sizeScale:e,sizeMinPixels:n,sizeMaxPixels:i}),c.draw(this.context.renderPass)}_getModel(){let A=[0,0,1,0,1,1,0,1];return new ke(this.context.device,{...this.getShaders(),id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ln({topology:"triangle-fan-webgl",vertexCount:4,attributes:{positions:{size:2,value:new Float32Array(A)}}}),isInstanced:!0})}};Fk.defaultProps=CsA;Fk.layerName="TextBackgroundLayer";var LC=Fk;var CC={start:1,middle:0,end:-1},HC={top:1,center:0,bottom:-1},RF=[0,0,0,255],HsA=1,DsA={billboard:!0,sizeScale:1,sizeUnits:"pixels",sizeMinPixels:0,sizeMaxPixels:Number.MAX_SAFE_INTEGER,background:!1,getBackgroundColor:{type:"accessor",value:[255,255,255,255]},getBorderColor:{type:"accessor",value:RF},getBorderWidth:{type:"accessor",value:0},backgroundPadding:{type:"array",value:[0,0,0,0]},characterSet:{type:"object",value:Sc.characterSet},fontFamily:Sc.fontFamily,fontWeight:Sc.fontWeight,lineHeight:HsA,outlineWidth:{type:"number",value:0,min:0},outlineColor:{type:"color",value:RF},fontSettings:{type:"object",value:{},compare:1},wordBreak:"break-word",maxWidth:{type:"number",value:-1},getText:{type:"accessor",value:t=>t.text},getPosition:{type:"accessor",value:t=>t.position},getColor:{type:"accessor",value:RF},getSize:{type:"accessor",value:32},getAngle:{type:"accessor",value:0},getTextAnchor:{type:"accessor",value:"middle"},getAlignmentBaseline:{type:"accessor",value:"center"},getPixelOffset:{type:"accessor",value:[0,0]},backgroundColor:{deprecatedFor:["background","getBackgroundColor"]}},Pk=class extends b6{constructor(){super(...arguments),this.getBoundingRect=(A,j)=>{let{size:[e,r]}=this.transformParagraph(A,j),{fontSize:n}=this.state.fontAtlasManager.props;e/=n,r/=n;let{getTextAnchor:i,getAlignmentBaseline:o}=this.props,l=CC[typeof i=="function"?i(A,j):i],c=HC[typeof o=="function"?o(A,j):o];return[(l-1)*e/2,(c-1)*r/2,e,r]},this.getIconOffsets=(A,j)=>{let{getTextAnchor:e,getAlignmentBaseline:r}=this.props,{x:n,y:i,rowWidth:o,size:[l,c]}=this.transformParagraph(A,j),B=CC[typeof e=="function"?e(A,j):e],h=HC[typeof r=="function"?r(A,j):r],d=n.length,k=new Array(d*2),g=0;for(let E=0;E0&&NA.warn("v8.9 breaking change: TextLayer maxWidth is now relative to text size")()}updateState(A){let{props:j,oldProps:e,changeFlags:r}=A;(r.dataChanged||r.updateTriggersChanged&&(r.updateTriggersChanged.all||r.updateTriggersChanged.getText))&&this._updateText(),(this._updateFontAtlas()||j.lineHeight!==e.lineHeight||j.wordBreak!==e.wordBreak||j.maxWidth!==e.maxWidth)&&this.setState({styleVersion:this.state.styleVersion+1})}getPickingInfo({info:A}){return A.object=A.index>=0?this.props.data[A.index]:null,A}_updateFontAtlas(){let{fontSettings:A,fontFamily:j,fontWeight:e}=this.props,{fontAtlasManager:r,characterSet:n}=this.state,i={...A,characterSet:n,fontFamily:j,fontWeight:e};if(!r.mapping)return r.setProps(i),!0;for(let o in i)if(i[o]!==r.props[o])return r.setProps(i),!0;return!1}_updateText(){let{data:A,characterSet:j}=this.props,e=A.attributes?.getText,{getText:r}=this.props,n=A.startIndices,i,o=j==="auto"&&new Set;if(e&&n){let{texts:l,characterCount:c}=wC({...ArrayBuffer.isView(e)?{value:e}:e,length:A.length,startIndices:n,characterSet:o});i=c,r=(B,{index:h})=>l[h]}else{let{iterable:l,objectInfo:c}=Pi(A);n=[0],i=0;for(let B of l){c.index++;let h=Array.from(r(B,c)||"");o&&h.forEach(o.add,o),i+=h.length,n.push(i)}}this.setState({getText:r,startIndices:n,numInstances:i,characterSet:o||j})}transformParagraph(A,j){let{fontAtlasManager:e}=this.state,r=e.mapping,n=this.state.getText,{wordBreak:i,lineHeight:o,maxWidth:l}=this.props,c=n(A,j)||"";return GC(c,o,i,l*e.props.fontSize,r)}renderLayers(){let{startIndices:A,numInstances:j,getText:e,fontAtlasManager:{scale:r,atlas:n,mapping:i},styleVersion:o}=this.state,{data:l,_dataDiff:c,getPosition:B,getColor:h,getSize:d,getAngle:k,getPixelOffset:g,getBackgroundColor:E,getBorderColor:m,getBorderWidth:y,backgroundPadding:G,background:v,billboard:_,fontSettings:w,outlineWidth:x,outlineColor:O,sizeScale:F,sizeUnits:C,sizeMinPixels:R,sizeMaxPixels:X,transitions:T,updateTriggers:Q}=this.props,b=this.getSubLayerClass("characters",xC),jA=this.getSubLayerClass("background",LC);return[v&&new jA({getFillColor:E,getLineColor:m,getLineWidth:y,padding:G,getPosition:B,getSize:d,getAngle:k,getPixelOffset:g,billboard:_,sizeScale:F,sizeUnits:C,sizeMinPixels:R,sizeMaxPixels:X,transitions:T&&{getPosition:T.getPosition,getAngle:T.getAngle,getSize:T.getSize,getFillColor:T.getBackgroundColor,getLineColor:T.getBorderColor,getLineWidth:T.getBorderWidth,getPixelOffset:T.getPixelOffset}},this.getSubLayerProps({id:"background",updateTriggers:{getPosition:Q.getPosition,getAngle:Q.getAngle,getSize:Q.getSize,getFillColor:Q.getBackgroundColor,getLineColor:Q.getBorderColor,getLineWidth:Q.getBorderWidth,getPixelOffset:Q.getPixelOffset,getBoundingRect:{getText:Q.getText,getTextAnchor:Q.getTextAnchor,getAlignmentBaseline:Q.getAlignmentBaseline,styleVersion:o}}}),{data:l.attributes&&l.attributes.background?{length:l.length,attributes:l.attributes.background}:l,_dataDiff:c,autoHighlight:!1,getBoundingRect:this.getBoundingRect}),new b({sdf:w.sdf,smoothing:Number.isFinite(w.smoothing)?w.smoothing:Sc.smoothing,outlineWidth:x/(w.radius||Sc.radius),outlineColor:O,iconAtlas:n,iconMapping:i,getPosition:B,getColor:h,getSize:d,getAngle:k,getPixelOffset:g,billboard:_,sizeScale:F*r,sizeUnits:C,sizeMinPixels:R*r,sizeMaxPixels:X*r,transitions:T&&{getPosition:T.getPosition,getAngle:T.getAngle,getColor:T.getColor,getSize:T.getSize,getPixelOffset:T.getPixelOffset}},this.getSubLayerProps({id:"characters",updateTriggers:{all:Q.getText,getPosition:Q.getPosition,getAngle:Q.getAngle,getColor:Q.getColor,getSize:Q.getSize,getPixelOffset:Q.getPixelOffset,getIconOffsets:{getTextAnchor:Q.getTextAnchor,getAlignmentBaseline:Q.getAlignmentBaseline,styleVersion:o}}}),{data:l,_dataDiff:c,startIndices:A,numInstances:j,getIconOffsets:this.getIconOffsets,getIcon:e})]}static set fontAtlasCacheLimit(A){TC(A)}};Pk.defaultProps=DsA;Pk.layerName="TextLayer";var Ii=Pk;var Ik={circle:{type:mr,props:{filled:"filled",stroked:"stroked",lineWidthMaxPixels:"lineWidthMaxPixels",lineWidthMinPixels:"lineWidthMinPixels",lineWidthScale:"lineWidthScale",lineWidthUnits:"lineWidthUnits",pointRadiusMaxPixels:"radiusMaxPixels",pointRadiusMinPixels:"radiusMinPixels",pointRadiusScale:"radiusScale",pointRadiusUnits:"radiusUnits",pointAntialiasing:"antialiasing",pointBillboard:"billboard",getFillColor:"getFillColor",getLineColor:"getLineColor",getLineWidth:"getLineWidth",getPointRadius:"getRadius"}},icon:{type:z7,props:{iconAtlas:"iconAtlas",iconMapping:"iconMapping",iconSizeMaxPixels:"sizeMaxPixels",iconSizeMinPixels:"sizeMinPixels",iconSizeScale:"sizeScale",iconSizeUnits:"sizeUnits",iconAlphaCutoff:"alphaCutoff",iconBillboard:"billboard",getIcon:"getIcon",getIconAngle:"getAngle",getIconColor:"getColor",getIconPixelOffset:"getPixelOffset",getIconSize:"getSize"}},text:{type:Ii,props:{textSizeMaxPixels:"sizeMaxPixels",textSizeMinPixels:"sizeMinPixels",textSizeScale:"sizeScale",textSizeUnits:"sizeUnits",textBackground:"background",textBackgroundPadding:"backgroundPadding",textFontFamily:"fontFamily",textFontWeight:"fontWeight",textLineHeight:"lineHeight",textMaxWidth:"maxWidth",textOutlineColor:"outlineColor",textOutlineWidth:"outlineWidth",textWordBreak:"wordBreak",textCharacterSet:"characterSet",textBillboard:"billboard",textFontSettings:"fontSettings",getText:"getText",getTextAngle:"getAngle",getTextColor:"getColor",getTextPixelOffset:"getPixelOffset",getTextSize:"getSize",getTextAnchor:"getTextAnchor",getTextAlignmentBaseline:"getAlignmentBaseline",getTextBackgroundColor:"getBackgroundColor",getTextBorderColor:"getBorderColor",getTextBorderWidth:"getBorderWidth"}}},Mk={type:_o,props:{lineWidthUnits:"widthUnits",lineWidthScale:"widthScale",lineWidthMinPixels:"widthMinPixels",lineWidthMaxPixels:"widthMaxPixels",lineJointRounded:"jointRounded",lineCapRounded:"capRounded",lineMiterLimit:"miterLimit",lineBillboard:"billboard",getLineColor:"getColor",getLineWidth:"getWidth"}},Ox={type:Q7,props:{extruded:"extruded",filled:"filled",wireframe:"wireframe",elevationScale:"elevationScale",material:"material",_full3d:"_full3d",getElevation:"getElevation",getFillColor:"getFillColor",getLineColor:"getLineColor"}};function WB({type:t,props:A}){let j={};for(let e in A)j[e]=t.defaultProps[A[e]];return j}function Tx(t,A){let{transitions:j,updateTriggers:e}=t.props,r={updateTriggers:{},transitions:j&&{getPosition:j.geometry}};for(let n in A){let i=A[n],o=t.props[n];n.startsWith("get")&&(o=t.getSubLayerAccessor(o),r.updateTriggers[i]=e[n],j&&(r.transitions[i]=j[n])),r[i]=o}return r}function NC(t){if(Array.isArray(t))return t;switch(NA.assert(t.type,"GeoJSON does not have type"),t.type){case"Feature":return[t];case"FeatureCollection":return NA.assert(Array.isArray(t.features),"GeoJSON does not have features array"),t.features;default:return[{geometry:t}]}}function LF(t,A,j={}){let e={pointFeatures:[],lineFeatures:[],polygonFeatures:[],polygonOutlineFeatures:[]},{startRow:r=0,endRow:n=t.length}=j;for(let i=r;i{o.push(j({geometry:{type:"Point",coordinates:h}},e,r))});break;case"LineString":l.push(j({geometry:t},e,r));break;case"MultiLineString":i.forEach(h=>{l.push(j({geometry:{type:"LineString",coordinates:h}},e,r))});break;case"Polygon":c.push(j({geometry:t},e,r)),i.forEach(h=>{B.push(j({geometry:{type:"LineString",coordinates:h}},e,r))});break;case"MultiPolygon":i.forEach(h=>{c.push(j({geometry:{type:"Polygon",coordinates:h}},e,r)),h.forEach(d=>{B.push(j({geometry:{type:"LineString",coordinates:d}},e,r))})});break;default:}}var NsA={Point:1,MultiPoint:2,LineString:2,MultiLineString:3,Polygon:3,MultiPolygon:4};function KsA(t,A){let j=NsA[t];for(NA.assert(j,`Unknown GeoJSON type ${t}`);A&&--j>0;)A=A[0];return A&&Number.isFinite(A[0])}function KC(){return{points:{},lines:{},polygons:{},polygonsOutline:{}}}function Sx(t){return t.geometry.coordinates}function XC(t,A){let j=KC(),{pointFeatures:e,lineFeatures:r,polygonFeatures:n,polygonOutlineFeatures:i}=t;return j.points.data=e,j.points._dataDiff=A.pointFeatures&&(()=>A.pointFeatures),j.points.getPosition=Sx,j.lines.data=r,j.lines._dataDiff=A.lineFeatures&&(()=>A.lineFeatures),j.lines.getPath=Sx,j.polygons.data=n,j.polygons._dataDiff=A.polygonFeatures&&(()=>A.polygonFeatures),j.polygons.getPolygon=Sx,j.polygonsOutline.data=i,j.polygonsOutline._dataDiff=A.polygonOutlineFeatures&&(()=>A.polygonOutlineFeatures),j.polygonsOutline.getPath=Sx,j}function zC(t,A){let j=KC(),{points:e,lines:r,polygons:n}=t,i=mC(t,A);return j.points.data={length:e.positions.value.length/e.positions.size,attributes:{...e.attributes,getPosition:e.positions,instancePickingColors:{size:3,value:i.points}},properties:e.properties,numericProps:e.numericProps,featureIds:e.featureIds},j.lines.data={length:r.pathIndices.value.length-1,startIndices:r.pathIndices.value,attributes:{...r.attributes,getPath:r.positions,instancePickingColors:{size:3,value:i.lines}},properties:r.properties,numericProps:r.numericProps,featureIds:r.featureIds},j.lines._pathType="open",j.polygons.data={length:n.polygonIndices.value.length-1,startIndices:n.polygonIndices.value,attributes:{...n.attributes,getPolygon:n.positions,pickingColors:{size:3,value:i.polygons}},properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},j.polygons._normalize=!1,n.triangles&&(j.polygons.data.attributes.indices=n.triangles.value),j.polygonsOutline.data={length:n.primitivePolygonIndices.value.length-1,startIndices:n.primitivePolygonIndices.value,attributes:{...n.attributes,getPath:n.positions,instancePickingColors:{size:3,value:i.polygons}},properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},j.polygonsOutline._pathType="open",j}var XsA=["points","linestrings","polygons"],zsA={...WB(Ik.circle),...WB(Ik.icon),...WB(Ik.text),...WB(Mk),...WB(Ox),stroked:!0,filled:!0,extruded:!1,wireframe:!1,_full3d:!1,iconAtlas:{type:"object",value:null},iconMapping:{type:"object",value:{}},getIcon:{type:"accessor",value:t=>t.properties.icon},getText:{type:"accessor",value:t=>t.properties.text},pointType:"circle",getRadius:{deprecatedFor:"getPointRadius"}},Ok=class extends b6{initializeState(){this.state={layerProps:{},features:{},featuresDiff:{}}}updateState({props:A,changeFlags:j}){if(!j.dataChanged)return;let{data:e}=this.props,r=e&&"points"in e&&"polygons"in e&&"lines"in e;this.setState({binary:r}),r?this._updateStateBinary({props:A,changeFlags:j}):this._updateStateJSON({props:A,changeFlags:j})}_updateStateBinary({props:A,changeFlags:j}){let e=zC(A.data,this.encodePickingColor);this.setState({layerProps:e})}_updateStateJSON({props:A,changeFlags:j}){let e=NC(A.data),r=this.getSubLayerRow.bind(this),n={},i={};if(Array.isArray(j.dataChanged)){let l=this.state.features;for(let c in l)n[c]=l[c].slice(),i[c]=[];for(let c of j.dataChanged){let B=LF(e,r,c);for(let h in l)i[h].push(Px({data:n[h],getIndex:d=>d.__source.index,dataRange:c,replace:B[h]}))}}else n=LF(e,r);let o=XC(n,i);this.setState({features:n,featuresDiff:i,layerProps:o})}getPickingInfo(A){let j=super.getPickingInfo(A),{index:e,sourceLayer:r}=j;return j.featureType=XsA.find(n=>r.id.startsWith(`${this.id}-${n}-`)),e>=0&&r.id.startsWith(`${this.id}-points-text`)&&this.state.binary&&(j.index=this.props.data.points.globalFeatureIds.value[e]),j}_updateAutoHighlight(A){let j=`${this.id}-points-`,e=A.featureType==="points";for(let r of this.getSubLayers())r.id.startsWith(j)===e&&r.updateAutoHighlight(A)}_renderPolygonLayer(){let{extruded:A,wireframe:j}=this.props,{layerProps:e}=this.state,r="polygons-fill",n=this.shouldRenderSubLayer(r,e.polygons?.data)&&this.getSubLayerClass(r,Ox.type);if(n){let i=Tx(this,Ox.props),o=A&&j;return o||delete i.getLineColor,i.updateTriggers.lineColors=o,new n(i,this.getSubLayerProps({id:r,updateTriggers:i.updateTriggers}),e.polygons)}return null}_renderLineLayers(){let{extruded:A,stroked:j}=this.props,{layerProps:e}=this.state,r="polygons-stroke",n="linestrings",i=!A&&j&&this.shouldRenderSubLayer(r,e.polygonsOutline?.data)&&this.getSubLayerClass(r,Mk.type),o=this.shouldRenderSubLayer(n,e.lines?.data)&&this.getSubLayerClass(n,Mk.type);if(i||o){let l=Tx(this,Mk.props);return[i&&new i(l,this.getSubLayerProps({id:r,updateTriggers:l.updateTriggers}),e.polygonsOutline),o&&new o(l,this.getSubLayerProps({id:n,updateTriggers:l.updateTriggers}),e.lines)]}return null}_renderPointLayers(){let{pointType:A}=this.props,{layerProps:j,binary:e}=this.state,{highlightedObjectIndex:r}=this.props;!e&&Number.isFinite(r)&&(r=j.points.data.findIndex(o=>o.__source.index===r));let n=new Set(A.split("+")),i=[];for(let o of n){let l=`points-${o}`,c=Ik[o],B=c&&this.shouldRenderSubLayer(l,j.points?.data)&&this.getSubLayerClass(l,c.type);if(B){let h=Tx(this,c.props),d=j.points;if(o==="text"&&e){let{instancePickingColors:k,...g}=d.data.attributes;d={...d,data:{...d.data,attributes:g}}}i.push(new B(h,this.getSubLayerProps({id:l,updateTriggers:h.updateTriggers,highlightedObjectIndex:r}),d))}}return i}renderLayers(){let{extruded:A}=this.props,j=this._renderPolygonLayer(),e=this._renderLineLayers(),r=this._renderPointLayers();return[!A&&j,e,r,A&&j]}getSubLayerAccessor(A){let{binary:j}=this.state;return!j||typeof A!="function"?super.getSubLayerAccessor(A):(e,r)=>{let{data:n,index:i}=r,o=gC(n,i);return A(o,r)}}};Ok.layerName="GeoJsonLayer";Ok.defaultProps=zsA;var La=Ok;var Rx=class{constructor(A){this.index=A,this.isVisible=!1,this.isSelected=!1,this.parent=null,this.children=[],this.content=null,this._loader=void 0,this._abortController=null,this._loaderId=0,this._isLoaded=!1,this._isCancelled=!1,this._needsReload=!1}get bbox(){return this._bbox}set bbox(A){this._bbox||(this._bbox=A,"west"in A?this.boundingBox=[[A.west,A.south],[A.east,A.north]]:this.boundingBox=[[A.left,A.top],[A.right,A.bottom]])}get data(){return this.isLoading&&this._loader?this._loader.then(()=>this.data):this.content}get isLoaded(){return this._isLoaded&&!this._needsReload}get isLoading(){return!!this._loader&&!this._isCancelled}get needsReload(){return this._needsReload||this._isCancelled}get byteLength(){let A=this.content?this.content.byteLength:0;return Number.isFinite(A)||console.error("byteLength not defined in tile data"),A}async _loadData({getData:A,requestScheduler:j,onLoad:e,onError:r}){let{index:n,id:i,bbox:o,userData:l,zoom:c}=this,B=this._loaderId;this._abortController=new AbortController;let{signal:h}=this._abortController,d=await j.scheduleRequest(this,E=>E.isSelected?1:-1);if(!d){this._isCancelled=!0;return}if(this._isCancelled){d.done();return}let k=null,g;try{k=await A({index:n,id:i,bbox:o,userData:l,zoom:c,signal:h})}catch(E){g=E||!0}finally{d.done()}if(B===this._loaderId){if(this._loader=void 0,this.content=k,this._isCancelled&&!k){this._isLoaded=!1;return}this._isLoaded=!0,this._isCancelled=!1,g?r(g,this):e(this)}}loadData(A){return this._isLoaded=!1,this._isCancelled=!1,this._needsReload=!1,this._loaderId++,this._loader=this._loadData(A),this._loader}setNeedsReload(){this.isLoading&&(this.abort(),this._loader=void 0),this._needsReload=!0}abort(){this.isLoaded||(this._isCancelled=!0,this._abortController?.abort())}};var be={OUTSIDE:-1,INTERSECTING:0,INSIDE:1};var z5A=1/Math.PI*180,U5A=1/180*Math.PI,UsA={EPSILON:1e-12,debug:!1,precision:4,printTypes:!1,printDegrees:!1,printRowMajor:!0,_cartographicRadians:!1};globalThis.mathgl=globalThis.mathgl||{config:{...UsA}};var Ge=globalThis.mathgl.config;function CF(t,{precision:A=Ge.precision}={}){return t=VsA(t),`${parseFloat(t.toPrecision(A))}`}function Ca(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&!(t instanceof DataView)}function W7(t,A,j){let e=Ge.EPSILON;j&&(Ge.EPSILON=j);try{if(t===A)return!0;if(Ca(t)&&Ca(A)){if(t.length!==A.length)return!1;for(let r=0;r0?", ":"")+CF(this[e],A);return`${A.printTypes?this.constructor.name:""}[${j}]`}equals(A){if(!A||this.length!==A.length)return!1;for(let j=0;j=0&&A=0&&A0&&(n=1/Math.sqrt(n)),t[0]=A[0]*n,t[1]=A[1]*n,t[2]=A[2]*n,t}function NF(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]}function ZB(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2];return t[0]=r*l-n*o,t[1]=n*i-e*l,t[2]=e*o-r*i,t}function Hx(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[3]*e+j[7]*r+j[11]*n+j[15];return i=i||1,t[0]=(j[0]*e+j[4]*r+j[8]*n+j[12])/i,t[1]=(j[1]*e+j[5]*r+j[9]*n+j[13])/i,t[2]=(j[2]*e+j[6]*r+j[10]*n+j[14])/i,t}function Dx(t,A,j){let e=A[0],r=A[1],n=A[2];return t[0]=e*j[0]+r*j[3]+n*j[6],t[1]=e*j[1]+r*j[4]+n*j[7],t[2]=e*j[2]+r*j[5]+n*j[8],t}function Nx(t,A,j){let e=j[0],r=j[1],n=j[2],i=j[3],o=A[0],l=A[1],c=A[2],B=r*c-n*l,h=n*o-e*c,d=e*l-r*o,k=r*d-n*h,g=n*B-e*d,E=e*h-r*B,m=i*2;return B*=m,h*=m,d*=m,k*=2,g*=2,E*=2,t[0]=o+B+k,t[1]=l+h+g,t[2]=c+d+E,t}function AH(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0],n[1]=r[1]*Math.cos(e)-r[2]*Math.sin(e),n[2]=r[1]*Math.sin(e)+r[2]*Math.cos(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function tH(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[2]*Math.sin(e)+r[0]*Math.cos(e),n[1]=r[1],n[2]=r[2]*Math.cos(e)-r[0]*Math.sin(e),t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function jH(t,A,j,e){let r=[],n=[];return r[0]=A[0]-j[0],r[1]=A[1]-j[1],r[2]=A[2]-j[2],n[0]=r[0]*Math.cos(e)-r[1]*Math.sin(e),n[1]=r[0]*Math.sin(e)+r[1]*Math.cos(e),n[2]=r[2],t[0]=n[0]+j[0],t[1]=n[1]+j[1],t[2]=n[2]+j[2],t}function eH(t,A){let j=t[0],e=t[1],r=t[2],n=A[0],i=A[1],o=A[2],l=Math.sqrt((j*j+e*e+r*r)*(n*n+i*i+o*o)),c=l&&NF(t,A)/l;return Math.acos(Math.min(Math.max(c,-1),1))}var rH=JsA;var oXA=function(){let t=HF();return function(A,j,e,r,n,i){let o,l;for(j||(j=3),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;o0?this.copy([A,...j]):this.identity()}copy(A){return this[0]=A[0],this[1]=A[1],this[2]=A[2],this[3]=A[3],this[4]=A[4],this[5]=A[5],this[6]=A[6],this[7]=A[7],this[8]=A[8],this.check()}identity(){return this.copy(ZsA)}fromObject(A){return this.check()}fromQuaternion(A){return uH(this,A),this.check()}set(A,j,e,r,n,i,o,l,c){return this[0]=A,this[1]=j,this[2]=e,this[3]=r,this[4]=n,this[5]=i,this[6]=o,this[7]=l,this[8]=c,this.check()}setRowMajor(A,j,e,r,n,i,o,l,c){return this[0]=A,this[1]=r,this[2]=o,this[3]=j,this[4]=n,this[5]=l,this[6]=e,this[7]=i,this[8]=c,this.check()}determinant(){return aH(this)}transpose(){return oH(this,this),this.check()}invert(){return sH(this,this),this.check()}multiplyLeft(A){return XF(this,A,this),this.check()}multiplyRight(A){return XF(this,this,A),this.check()}rotate(A){return cH(this,this,A),this.check()}scale(A){return Array.isArray(A)?zF(this,this,A):zF(this,this,[A,A]),this.check()}translate(A){return lH(this,this,A),this.check()}transform(A,j){let e;switch(A.length){case 2:e=QC(j||[-0,-0],A,this);break;case 3:e=Dx(j||[-0,-0,-0],A,this);break;case 4:e=Cx(j||[-0,-0,-0,-0],A,this);break;default:throw new Error("Illegal vector")}return Lx(e,A.length),e}transformVector(A,j){return this.transform(A,j)}transformVector2(A,j){return this.transform(A,j)}transformVector3(A,j){return this.transform(A,j)}},Vx,Qx=null;function AaA(){return Vx||(Vx=new oe([0,0,0,0,0,0,0,0,0]),Object.freeze(Vx)),Vx}function taA(){return Qx||(Qx=new oe,Object.freeze(Qx)),Qx}var Wx={};fr(Wx,{add:()=>CaA,adjoint:()=>aaA,clone:()=>eaA,copy:()=>raA,create:()=>jaA,decompose:()=>_aA,determinant:()=>laA,equals:()=>KaA,exactEquals:()=>NaA,frob:()=>LaA,fromQuat:()=>GaA,fromQuat2:()=>xaA,fromRotation:()=>gaA,fromRotationTranslation:()=>dH,fromRotationTranslationScale:()=>qaA,fromRotationTranslationScaleOrigin:()=>baA,fromScaling:()=>kaA,fromTranslation:()=>paA,fromValues:()=>naA,fromXRotation:()=>maA,fromYRotation:()=>EaA,fromZRotation:()=>$aA,frustum:()=>waA,getRotation:()=>vaA,getScaling:()=>pH,getTranslation:()=>yaA,identity:()=>fH,invert:()=>saA,lookAt:()=>TaA,mul:()=>XaA,multiply:()=>hH,multiplyScalar:()=>HaA,multiplyScalarAndAdd:()=>DaA,ortho:()=>MaA,orthoNO:()=>gH,orthoZO:()=>OaA,perspective:()=>FaA,perspectiveFromFieldOfView:()=>IaA,perspectiveNO:()=>kH,perspectiveZO:()=>PaA,rotate:()=>BaA,rotateX:()=>faA,rotateY:()=>haA,rotateZ:()=>daA,scale:()=>uaA,set:()=>iaA,str:()=>RaA,sub:()=>zaA,subtract:()=>mH,targetTo:()=>SaA,translate:()=>caA,transpose:()=>oaA});function jaA(){let t=new ie(16);return ie!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function eaA(t){let A=new ie(16);return A[0]=t[0],A[1]=t[1],A[2]=t[2],A[3]=t[3],A[4]=t[4],A[5]=t[5],A[6]=t[6],A[7]=t[7],A[8]=t[8],A[9]=t[9],A[10]=t[10],A[11]=t[11],A[12]=t[12],A[13]=t[13],A[14]=t[14],A[15]=t[15],A}function raA(t,A){return t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function naA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E){let m=new ie(16);return m[0]=t,m[1]=A,m[2]=j,m[3]=e,m[4]=r,m[5]=n,m[6]=i,m[7]=o,m[8]=l,m[9]=c,m[10]=B,m[11]=h,m[12]=d,m[13]=k,m[14]=g,m[15]=E,m}function iaA(t,A,j,e,r,n,i,o,l,c,B,h,d,k,g,E,m){return t[0]=A,t[1]=j,t[2]=e,t[3]=r,t[4]=n,t[5]=i,t[6]=o,t[7]=l,t[8]=c,t[9]=B,t[10]=h,t[11]=d,t[12]=k,t[13]=g,t[14]=E,t[15]=m,t}function fH(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function oaA(t,A){if(t===A){let j=A[1],e=A[2],r=A[3],n=A[6],i=A[7],o=A[11];t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=j,t[6]=A[9],t[7]=A[13],t[8]=e,t[9]=n,t[11]=A[14],t[12]=r,t[13]=i,t[14]=o}else t[0]=A[0],t[1]=A[4],t[2]=A[8],t[3]=A[12],t[4]=A[1],t[5]=A[5],t[6]=A[9],t[7]=A[13],t[8]=A[2],t[9]=A[6],t[10]=A[10],t[11]=A[14],t[12]=A[3],t[13]=A[7],t[14]=A[11],t[15]=A[15];return t}function saA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m,b=G*Q-v*T+_*X+w*R-x*C+O*F;return b?(b=1/b,t[0]=(o*Q-l*T+c*X)*b,t[1]=(r*T-e*Q-n*X)*b,t[2]=(E*O-m*x+y*w)*b,t[3]=(d*x-h*O-k*w)*b,t[4]=(l*R-i*Q-c*C)*b,t[5]=(j*Q-r*R+n*C)*b,t[6]=(m*_-g*O-y*v)*b,t[7]=(B*O-d*_+k*v)*b,t[8]=(i*T-o*R+c*F)*b,t[9]=(e*R-j*T-n*F)*b,t[10]=(g*x-E*_+y*G)*b,t[11]=(h*_-B*x-k*G)*b,t[12]=(o*C-i*X-l*F)*b,t[13]=(j*X-e*C+r*F)*b,t[14]=(E*v-g*w-m*G)*b,t[15]=(B*w-h*v+d*G)*b,t):null}function aaA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=A[4],o=A[5],l=A[6],c=A[7],B=A[8],h=A[9],d=A[10],k=A[11],g=A[12],E=A[13],m=A[14],y=A[15],G=j*o-e*i,v=j*l-r*i,_=j*c-n*i,w=e*l-r*o,x=e*c-n*o,O=r*c-n*l,F=B*E-h*g,C=B*m-d*g,R=B*y-k*g,X=h*m-d*E,T=h*y-k*E,Q=d*y-k*m;return t[0]=o*Q-l*T+c*X,t[1]=r*T-e*Q-n*X,t[2]=E*O-m*x+y*w,t[3]=d*x-h*O-k*w,t[4]=l*R-i*Q-c*C,t[5]=j*Q-r*R+n*C,t[6]=m*_-g*O-y*v,t[7]=B*O-d*_+k*v,t[8]=i*T-o*R+c*F,t[9]=e*R-j*T-n*F,t[10]=g*x-E*_+y*G,t[11]=h*_-B*x-k*G,t[12]=o*C-i*X-l*F,t[13]=j*X-e*C+r*F,t[14]=E*v-g*w-m*G,t[15]=B*w-h*v+d*G,t}function laA(t){let A=t[0],j=t[1],e=t[2],r=t[3],n=t[4],i=t[5],o=t[6],l=t[7],c=t[8],B=t[9],h=t[10],d=t[11],k=t[12],g=t[13],E=t[14],m=t[15],y=A*i-j*n,G=A*o-e*n,v=j*o-e*i,_=c*g-B*k,w=c*E-h*k,x=B*E-h*g,O=A*x-j*w+e*_,F=n*x-i*w+o*_,C=c*v-B*G+h*y,R=k*v-g*G+E*y;return l*O-r*F+m*C-d*R}function hH(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=A[8],d=A[9],k=A[10],g=A[11],E=A[12],m=A[13],y=A[14],G=A[15],v=j[0],_=j[1],w=j[2],x=j[3];return t[0]=v*e+_*o+w*h+x*E,t[1]=v*r+_*l+w*d+x*m,t[2]=v*n+_*c+w*k+x*y,t[3]=v*i+_*B+w*g+x*G,v=j[4],_=j[5],w=j[6],x=j[7],t[4]=v*e+_*o+w*h+x*E,t[5]=v*r+_*l+w*d+x*m,t[6]=v*n+_*c+w*k+x*y,t[7]=v*i+_*B+w*g+x*G,v=j[8],_=j[9],w=j[10],x=j[11],t[8]=v*e+_*o+w*h+x*E,t[9]=v*r+_*l+w*d+x*m,t[10]=v*n+_*c+w*k+x*y,t[11]=v*i+_*B+w*g+x*G,v=j[12],_=j[13],w=j[14],x=j[15],t[12]=v*e+_*o+w*h+x*E,t[13]=v*r+_*l+w*d+x*m,t[14]=v*n+_*c+w*k+x*y,t[15]=v*i+_*B+w*g+x*G,t}function caA(t,A,j){let e=j[0],r=j[1],n=j[2],i,o,l,c,B,h,d,k,g,E,m,y;return A===t?(t[12]=A[0]*e+A[4]*r+A[8]*n+A[12],t[13]=A[1]*e+A[5]*r+A[9]*n+A[13],t[14]=A[2]*e+A[6]*r+A[10]*n+A[14],t[15]=A[3]*e+A[7]*r+A[11]*n+A[15]):(i=A[0],o=A[1],l=A[2],c=A[3],B=A[4],h=A[5],d=A[6],k=A[7],g=A[8],E=A[9],m=A[10],y=A[11],t[0]=i,t[1]=o,t[2]=l,t[3]=c,t[4]=B,t[5]=h,t[6]=d,t[7]=k,t[8]=g,t[9]=E,t[10]=m,t[11]=y,t[12]=i*e+B*r+g*n+A[12],t[13]=o*e+h*r+E*n+A[13],t[14]=l*e+d*r+m*n+A[14],t[15]=c*e+k*r+y*n+A[15]),t}function uaA(t,A,j){let e=j[0],r=j[1],n=j[2];return t[0]=A[0]*e,t[1]=A[1]*e,t[2]=A[2]*e,t[3]=A[3]*e,t[4]=A[4]*r,t[5]=A[5]*r,t[6]=A[6]*r,t[7]=A[7]*r,t[8]=A[8]*n,t[9]=A[9]*n,t[10]=A[10]*n,t[11]=A[11]*n,t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15],t}function BaA(t,A,j,e){let r=e[0],n=e[1],i=e[2],o=Math.sqrt(r*r+n*n+i*i),l,c,B,h,d,k,g,E,m,y,G,v,_,w,x,O,F,C,R,X,T,Q,b,jA;return o<1e-6?null:(o=1/o,r*=o,n*=o,i*=o,c=Math.sin(j),l=Math.cos(j),B=1-l,h=A[0],d=A[1],k=A[2],g=A[3],E=A[4],m=A[5],y=A[6],G=A[7],v=A[8],_=A[9],w=A[10],x=A[11],O=r*r*B+l,F=n*r*B+i*c,C=i*r*B-n*c,R=r*n*B-i*c,X=n*n*B+l,T=i*n*B+r*c,Q=r*i*B+n*c,b=n*i*B-r*c,jA=i*i*B+l,t[0]=h*O+E*F+v*C,t[1]=d*O+m*F+_*C,t[2]=k*O+y*F+w*C,t[3]=g*O+G*F+x*C,t[4]=h*R+E*X+v*T,t[5]=d*R+m*X+_*T,t[6]=k*R+y*X+w*T,t[7]=g*R+G*X+x*T,t[8]=h*Q+E*b+v*jA,t[9]=d*Q+m*b+_*jA,t[10]=k*Q+y*b+w*jA,t[11]=g*Q+G*b+x*jA,A!==t&&(t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t)}function faA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[4],i=A[5],o=A[6],l=A[7],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[0]=A[0],t[1]=A[1],t[2]=A[2],t[3]=A[3],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[4]=n*r+c*e,t[5]=i*r+B*e,t[6]=o*r+h*e,t[7]=l*r+d*e,t[8]=c*r-n*e,t[9]=B*r-i*e,t[10]=h*r-o*e,t[11]=d*r-l*e,t}function haA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[8],B=A[9],h=A[10],d=A[11];return A!==t&&(t[4]=A[4],t[5]=A[5],t[6]=A[6],t[7]=A[7],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r-c*e,t[1]=i*r-B*e,t[2]=o*r-h*e,t[3]=l*r-d*e,t[8]=n*e+c*r,t[9]=i*e+B*r,t[10]=o*e+h*r,t[11]=l*e+d*r,t}function daA(t,A,j){let e=Math.sin(j),r=Math.cos(j),n=A[0],i=A[1],o=A[2],l=A[3],c=A[4],B=A[5],h=A[6],d=A[7];return A!==t&&(t[8]=A[8],t[9]=A[9],t[10]=A[10],t[11]=A[11],t[12]=A[12],t[13]=A[13],t[14]=A[14],t[15]=A[15]),t[0]=n*r+c*e,t[1]=i*r+B*e,t[2]=o*r+h*e,t[3]=l*r+d*e,t[4]=c*r-n*e,t[5]=B*r-i*e,t[6]=h*r-o*e,t[7]=d*r-l*e,t}function paA(t,A){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=A[0],t[13]=A[1],t[14]=A[2],t[15]=1,t}function kaA(t,A){return t[0]=A[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=A[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=A[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function gaA(t,A,j){let e=j[0],r=j[1],n=j[2],i=Math.sqrt(e*e+r*r+n*n),o,l,c;return i<1e-6?null:(i=1/i,e*=i,r*=i,n*=i,l=Math.sin(A),o=Math.cos(A),c=1-o,t[0]=e*e*c+o,t[1]=r*e*c+n*l,t[2]=n*e*c-r*l,t[3]=0,t[4]=e*r*c-n*l,t[5]=r*r*c+o,t[6]=n*r*c+e*l,t[7]=0,t[8]=e*n*c+r*l,t[9]=r*n*c-e*l,t[10]=n*n*c+o,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function maA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e,t[6]=j,t[7]=0,t[8]=0,t[9]=-j,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function EaA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=0,t[2]=-j,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=j,t[9]=0,t[10]=e,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function $aA(t,A){let j=Math.sin(A),e=Math.cos(A);return t[0]=e,t[1]=j,t[2]=0,t[3]=0,t[4]=-j,t[5]=e,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function dH(t,A,j){let e=A[0],r=A[1],n=A[2],i=A[3],o=e+e,l=r+r,c=n+n,B=e*o,h=e*l,d=e*c,k=r*l,g=r*c,E=n*c,m=i*o,y=i*l,G=i*c;return t[0]=1-(k+E),t[1]=h+G,t[2]=d-y,t[3]=0,t[4]=h-G,t[5]=1-(B+E),t[6]=g+m,t[7]=0,t[8]=d+y,t[9]=g-m,t[10]=1-(B+k),t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function xaA(t,A){let j=new ie(3),e=-A[0],r=-A[1],n=-A[2],i=A[3],o=A[4],l=A[5],c=A[6],B=A[7],h=e*e+r*r+n*n+i*i;return h>0?(j[0]=(o*i+B*e+l*n-c*r)*2/h,j[1]=(l*i+B*r+c*e-o*n)*2/h,j[2]=(c*i+B*n+o*r-l*e)*2/h):(j[0]=(o*i+B*e+l*n-c*r)*2,j[1]=(l*i+B*r+c*e-o*n)*2,j[2]=(c*i+B*n+o*r-l*e)*2),dH(t,A,j),t}function yaA(t,A){return t[0]=A[12],t[1]=A[13],t[2]=A[14],t}function pH(t,A){let j=A[0],e=A[1],r=A[2],n=A[4],i=A[5],o=A[6],l=A[8],c=A[9],B=A[10];return t[0]=Math.sqrt(j*j+e*e+r*r),t[1]=Math.sqrt(n*n+i*i+o*o),t[2]=Math.sqrt(l*l+c*c+B*B),t}function vaA(t,A){let j=new ie(3);pH(j,A);let e=1/j[0],r=1/j[1],n=1/j[2],i=A[0]*e,o=A[1]*r,l=A[2]*n,c=A[4]*e,B=A[5]*r,h=A[6]*n,d=A[8]*e,k=A[9]*r,g=A[10]*n,E=i+B+g,m=0;return E>0?(m=Math.sqrt(E+1)*2,t[3]=.25*m,t[0]=(h-k)/m,t[1]=(d-l)/m,t[2]=(o-c)/m):i>B&&i>g?(m=Math.sqrt(1+i-B-g)*2,t[3]=(h-k)/m,t[0]=.25*m,t[1]=(o+c)/m,t[2]=(d+l)/m):B>g?(m=Math.sqrt(1+B-i-g)*2,t[3]=(d-l)/m,t[0]=(o+c)/m,t[1]=.25*m,t[2]=(h+k)/m):(m=Math.sqrt(1+g-i-B)*2,t[3]=(o-c)/m,t[0]=(d+l)/m,t[1]=(h+k)/m,t[2]=.25*m),t}function _aA(t,A,j,e){A[0]=e[12],A[1]=e[13],A[2]=e[14];let r=e[0],n=e[1],i=e[2],o=e[4],l=e[5],c=e[6],B=e[8],h=e[9],d=e[10];j[0]=Math.sqrt(r*r+n*n+i*i),j[1]=Math.sqrt(o*o+l*l+c*c),j[2]=Math.sqrt(B*B+h*h+d*d);let k=1/j[0],g=1/j[1],E=1/j[2],m=r*k,y=n*g,G=i*E,v=o*k,_=l*g,w=c*E,x=B*k,O=h*g,F=d*E,C=m+_+F,R=0;return C>0?(R=Math.sqrt(C+1)*2,t[3]=.25*R,t[0]=(w-O)/R,t[1]=(x-G)/R,t[2]=(y-v)/R):m>_&&m>F?(R=Math.sqrt(1+m-_-F)*2,t[3]=(w-O)/R,t[0]=.25*R,t[1]=(y+v)/R,t[2]=(x+G)/R):_>F?(R=Math.sqrt(1+_-m-F)*2,t[3]=(x-G)/R,t[0]=(y+v)/R,t[1]=.25*R,t[2]=(w+O)/R):(R=Math.sqrt(1+F-m-_)*2,t[3]=(y-v)/R,t[0]=(x+G)/R,t[1]=(w+O)/R,t[2]=.25*R),t}function qaA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3],l=r+r,c=n+n,B=i+i,h=r*l,d=r*c,k=r*B,g=n*c,E=n*B,m=i*B,y=o*l,G=o*c,v=o*B,_=e[0],w=e[1],x=e[2];return t[0]=(1-(g+m))*_,t[1]=(d+v)*_,t[2]=(k-G)*_,t[3]=0,t[4]=(d-v)*w,t[5]=(1-(h+m))*w,t[6]=(E+y)*w,t[7]=0,t[8]=(k+G)*x,t[9]=(E-y)*x,t[10]=(1-(h+g))*x,t[11]=0,t[12]=j[0],t[13]=j[1],t[14]=j[2],t[15]=1,t}function baA(t,A,j,e,r){let n=A[0],i=A[1],o=A[2],l=A[3],c=n+n,B=i+i,h=o+o,d=n*c,k=n*B,g=n*h,E=i*B,m=i*h,y=o*h,G=l*c,v=l*B,_=l*h,w=e[0],x=e[1],O=e[2],F=r[0],C=r[1],R=r[2],X=(1-(E+y))*w,T=(k+_)*w,Q=(g-v)*w,b=(k-_)*x,jA=(1-(d+y))*x,pA=(m+G)*x,dA=(g+v)*O,$A=(m-G)*O,_A=(1-(d+E))*O;return t[0]=X,t[1]=T,t[2]=Q,t[3]=0,t[4]=b,t[5]=jA,t[6]=pA,t[7]=0,t[8]=dA,t[9]=$A,t[10]=_A,t[11]=0,t[12]=j[0]+F-(X*F+b*C+dA*R),t[13]=j[1]+C-(T*F+jA*C+$A*R),t[14]=j[2]+R-(Q*F+pA*C+_A*R),t[15]=1,t}function GaA(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j+j,o=e+e,l=r+r,c=j*i,B=e*i,h=e*o,d=r*i,k=r*o,g=r*l,E=n*i,m=n*o,y=n*l;return t[0]=1-h-g,t[1]=B+y,t[2]=d-m,t[3]=0,t[4]=B-y,t[5]=1-c-g,t[6]=k+E,t[7]=0,t[8]=d+m,t[9]=k-E,t[10]=1-c-h,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function waA(t,A,j,e,r,n,i){let o=1/(j-A),l=1/(r-e),c=1/(n-i);return t[0]=n*2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n*2*l,t[6]=0,t[7]=0,t[8]=(j+A)*o,t[9]=(r+e)*l,t[10]=(i+n)*c,t[11]=-1,t[12]=0,t[13]=0,t[14]=i*n*2*c,t[15]=0,t}function kH(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=(r+e)*i,t[14]=2*r*e*i}else t[10]=-1,t[14]=-2*e;return t}var FaA=kH;function PaA(t,A,j,e,r){let n=1/Math.tan(A/2);if(t[0]=n/j,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=n,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,r!=null&&r!==1/0){let i=1/(e-r);t[10]=r*i,t[14]=r*e*i}else t[10]=-1,t[14]=-e;return t}function IaA(t,A,j,e){let r=Math.tan(A.upDegrees*Math.PI/180),n=Math.tan(A.downDegrees*Math.PI/180),i=Math.tan(A.leftDegrees*Math.PI/180),o=Math.tan(A.rightDegrees*Math.PI/180),l=2/(i+o),c=2/(r+n);return t[0]=l,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=c,t[6]=0,t[7]=0,t[8]=-((i-o)*l*.5),t[9]=(r-n)*c*.5,t[10]=e/(j-e),t[11]=-1,t[12]=0,t[13]=0,t[14]=e*j/(j-e),t[15]=0,t}function gH(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=(i+n)*c,t[15]=1,t}var MaA=gH;function OaA(t,A,j,e,r,n,i){let o=1/(A-j),l=1/(e-r),c=1/(n-i);return t[0]=-2*o,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*l,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=c,t[11]=0,t[12]=(A+j)*o,t[13]=(r+e)*l,t[14]=n*c,t[15]=1,t}function TaA(t,A,j,e){let r,n,i,o,l,c,B,h,d,k,g=A[0],E=A[1],m=A[2],y=e[0],G=e[1],v=e[2],_=j[0],w=j[1],x=j[2];return Math.abs(g-_)<1e-6&&Math.abs(E-w)<1e-6&&Math.abs(m-x)<1e-6?fH(t):(h=g-_,d=E-w,k=m-x,r=1/Math.sqrt(h*h+d*d+k*k),h*=r,d*=r,k*=r,n=G*k-v*d,i=v*h-y*k,o=y*d-G*h,r=Math.sqrt(n*n+i*i+o*o),r?(r=1/r,n*=r,i*=r,o*=r):(n=0,i=0,o=0),l=d*o-k*i,c=k*n-h*o,B=h*i-d*n,r=Math.sqrt(l*l+c*c+B*B),r?(r=1/r,l*=r,c*=r,B*=r):(l=0,c=0,B=0),t[0]=n,t[1]=l,t[2]=h,t[3]=0,t[4]=i,t[5]=c,t[6]=d,t[7]=0,t[8]=o,t[9]=B,t[10]=k,t[11]=0,t[12]=-(n*g+i*E+o*m),t[13]=-(l*g+c*E+B*m),t[14]=-(h*g+d*E+k*m),t[15]=1,t)}function SaA(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=e[0],l=e[1],c=e[2],B=r-j[0],h=n-j[1],d=i-j[2],k=B*B+h*h+d*d;k>0&&(k=1/Math.sqrt(k),B*=k,h*=k,d*=k);let g=l*d-c*h,E=c*B-o*d,m=o*h-l*B;return k=g*g+E*E+m*m,k>0&&(k=1/Math.sqrt(k),g*=k,E*=k,m*=k),t[0]=g,t[1]=E,t[2]=m,t[3]=0,t[4]=h*m-d*E,t[5]=d*g-B*m,t[6]=B*E-h*g,t[7]=0,t[8]=B,t[9]=h,t[10]=d,t[11]=0,t[12]=r,t[13]=n,t[14]=i,t[15]=1,t}function RaA(t){return`mat4(${t[0]}, ${t[1]}, ${t[2]}, ${t[3]}, ${t[4]}, ${t[5]}, ${t[6]}, ${t[7]}, ${t[8]}, ${t[9]}, ${t[10]}, ${t[11]}, ${t[12]}, ${t[13]}, ${t[14]}, ${t[15]})`}function LaA(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]+t[3]*t[3]+t[4]*t[4]+t[5]*t[5]+t[6]*t[6]+t[7]*t[7]+t[8]*t[8]+t[9]*t[9]+t[10]*t[10]+t[11]*t[11]+t[12]*t[12]+t[13]*t[13]+t[14]*t[14]+t[15]*t[15])}function CaA(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t[4]=A[4]+j[4],t[5]=A[5]+j[5],t[6]=A[6]+j[6],t[7]=A[7]+j[7],t[8]=A[8]+j[8],t[9]=A[9]+j[9],t[10]=A[10]+j[10],t[11]=A[11]+j[11],t[12]=A[12]+j[12],t[13]=A[13]+j[13],t[14]=A[14]+j[14],t[15]=A[15]+j[15],t}function mH(t,A,j){return t[0]=A[0]-j[0],t[1]=A[1]-j[1],t[2]=A[2]-j[2],t[3]=A[3]-j[3],t[4]=A[4]-j[4],t[5]=A[5]-j[5],t[6]=A[6]-j[6],t[7]=A[7]-j[7],t[8]=A[8]-j[8],t[9]=A[9]-j[9],t[10]=A[10]-j[10],t[11]=A[11]-j[11],t[12]=A[12]-j[12],t[13]=A[13]-j[13],t[14]=A[14]-j[14],t[15]=A[15]-j[15],t}function HaA(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t[4]=A[4]*j,t[5]=A[5]*j,t[6]=A[6]*j,t[7]=A[7]*j,t[8]=A[8]*j,t[9]=A[9]*j,t[10]=A[10]*j,t[11]=A[11]*j,t[12]=A[12]*j,t[13]=A[13]*j,t[14]=A[14]*j,t[15]=A[15]*j,t}function DaA(t,A,j,e){return t[0]=A[0]+j[0]*e,t[1]=A[1]+j[1]*e,t[2]=A[2]+j[2]*e,t[3]=A[3]+j[3]*e,t[4]=A[4]+j[4]*e,t[5]=A[5]+j[5]*e,t[6]=A[6]+j[6]*e,t[7]=A[7]+j[7]*e,t[8]=A[8]+j[8]*e,t[9]=A[9]+j[9]*e,t[10]=A[10]+j[10]*e,t[11]=A[11]+j[11]*e,t[12]=A[12]+j[12]*e,t[13]=A[13]+j[13]*e,t[14]=A[14]+j[14]*e,t[15]=A[15]+j[15]*e,t}function NaA(t,A){return t[0]===A[0]&&t[1]===A[1]&&t[2]===A[2]&&t[3]===A[3]&&t[4]===A[4]&&t[5]===A[5]&&t[6]===A[6]&&t[7]===A[7]&&t[8]===A[8]&&t[9]===A[9]&&t[10]===A[10]&&t[11]===A[11]&&t[12]===A[12]&&t[13]===A[13]&&t[14]===A[14]&&t[15]===A[15]}function KaA(t,A){let j=t[0],e=t[1],r=t[2],n=t[3],i=t[4],o=t[5],l=t[6],c=t[7],B=t[8],h=t[9],d=t[10],k=t[11],g=t[12],E=t[13],m=t[14],y=t[15],G=A[0],v=A[1],_=A[2],w=A[3],x=A[4],O=A[5],F=A[6],C=A[7],R=A[8],X=A[9],T=A[10],Q=A[11],b=A[12],jA=A[13],pA=A[14],dA=A[15];return Math.abs(j-G)<=1e-6*Math.max(1,Math.abs(j),Math.abs(G))&&Math.abs(e-v)<=1e-6*Math.max(1,Math.abs(e),Math.abs(v))&&Math.abs(r-_)<=1e-6*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(n-w)<=1e-6*Math.max(1,Math.abs(n),Math.abs(w))&&Math.abs(i-x)<=1e-6*Math.max(1,Math.abs(i),Math.abs(x))&&Math.abs(o-O)<=1e-6*Math.max(1,Math.abs(o),Math.abs(O))&&Math.abs(l-F)<=1e-6*Math.max(1,Math.abs(l),Math.abs(F))&&Math.abs(c-C)<=1e-6*Math.max(1,Math.abs(c),Math.abs(C))&&Math.abs(B-R)<=1e-6*Math.max(1,Math.abs(B),Math.abs(R))&&Math.abs(h-X)<=1e-6*Math.max(1,Math.abs(h),Math.abs(X))&&Math.abs(d-T)<=1e-6*Math.max(1,Math.abs(d),Math.abs(T))&&Math.abs(k-Q)<=1e-6*Math.max(1,Math.abs(k),Math.abs(Q))&&Math.abs(g-b)<=1e-6*Math.max(1,Math.abs(g),Math.abs(b))&&Math.abs(E-jA)<=1e-6*Math.max(1,Math.abs(E),Math.abs(jA))&&Math.abs(m-pA)<=1e-6*Math.max(1,Math.abs(m),Math.abs(pA))&&Math.abs(y-dA)<=1e-6*Math.max(1,Math.abs(y),Math.abs(dA))}var XaA=hH,zaA=mH;function UaA(){let t=new ie(4);return ie!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function EH(t,A,j){return t[0]=A[0]+j[0],t[1]=A[1]+j[1],t[2]=A[2]+j[2],t[3]=A[3]+j[3],t}function $H(t,A,j){return t[0]=A[0]*j,t[1]=A[1]*j,t[2]=A[2]*j,t[3]=A[3]*j,t}function xH(t){let A=t[0],j=t[1],e=t[2],r=t[3];return Math.sqrt(A*A+j*j+e*e+r*r)}function yH(t){let A=t[0],j=t[1],e=t[2],r=t[3];return A*A+j*j+e*e+r*r}function vH(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n;return i>0&&(i=1/Math.sqrt(i)),t[0]=j*i,t[1]=e*i,t[2]=r*i,t[3]=n*i,t}function _H(t,A){return t[0]*A[0]+t[1]*A[1]+t[2]*A[2]+t[3]*A[3]}function qH(t,A,j,e){let r=A[0],n=A[1],i=A[2],o=A[3];return t[0]=r+e*(j[0]-r),t[1]=n+e*(j[1]-n),t[2]=i+e*(j[2]-i),t[3]=o+e*(j[3]-o),t}function bH(t,A,j){let e=A[0],r=A[1],n=A[2],i=j[0],o=j[1],l=j[2],c=j[3],B=c*e+o*n-l*r,h=c*r+l*e-i*n,d=c*n+i*r-o*e,k=-i*e-o*r-l*n;return t[0]=B*c+k*-i+h*-l-d*-o,t[1]=h*c+k*-o+d*-i-B*-l,t[2]=d*c+k*-l+B*-o-h*-i,t[3]=A[3],t}var FXA=function(){let t=UaA();return function(A,j,e,r,n,i){let o,l;for(j||(j=4),e||(e=0),r?l=Math.min(r*j+e,A.length):l=A.length,o=e;o1e-6?(k=Math.acos(d),m=Math.sin(k),g=Math.sin((1-e)*k)/m,E=Math.sin(e*k)/m):(g=1-e,E=e),t[0]=g*r+E*l,t[1]=g*n+E*c,t[2]=g*i+E*B,t[3]=g*o+E*h,t}function TH(t,A){let j=A[0],e=A[1],r=A[2],n=A[3],i=j*j+e*e+r*r+n*n,o=i?1/i:0;return t[0]=-j*o,t[1]=-e*o,t[2]=-r*o,t[3]=n*o,t}function SH(t,A){return t[0]=-A[0],t[1]=-A[1],t[2]=-A[2],t[3]=A[3],t}function WF(t,A){let j=A[0]+A[4]+A[8],e;if(j>0)e=Math.sqrt(j+1),t[3]=.5*e,e=.5/e,t[0]=(A[5]-A[7])*e,t[1]=(A[6]-A[2])*e,t[2]=(A[1]-A[3])*e;else{let r=0;A[4]>A[0]&&(r=1),A[8]>A[r*3+r]&&(r=2);let n=(r+1)%3,i=(r+2)%3;e=Math.sqrt(A[r*3+r]-A[n*3+n]-A[i*3+i]+1),t[r]=.5*e,e=.5/e,t[3]=(A[n*3+i]-A[i*3+n])*e,t[n]=(A[n*3+r]+A[r*3+n])*e,t[i]=(A[i*3+r]+A[r*3+i])*e}return t}var RH=EH;var LH=$H,CH=_H,HH=qH,DH=xH;var NH=yH;var KH=vH;var XH=function(){let t=HF(),A=DF(1,0,0),j=DF(0,1,0);return function(e,r,n){let i=NF(r,n);return i<-.999999?(ZB(t,A,r),rH(t)<1e-6&&ZB(t,j,r),ZC(t,t),VF(e,t,Math.PI),e):i>.999999?(e[0]=0,e[1]=0,e[2]=0,e[3]=1,e):(ZB(t,r,n),e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=1+i,KH(e,e))}}(),SXA=function(){let t=wH(),A=wH();return function(j,e,r,n,i,o){return Tk(t,e,i,o),Tk(A,r,n,o),Tk(j,t,A,2*o*(1-o)),j}}(),RXA=function(){let t=iH();return function(A,j,e,r){return t[0]=e[0],t[3]=e[1],t[6]=e[2],t[1]=r[0],t[4]=r[1],t[7]=r[2],t[2]=-j[0],t[5]=-j[1],t[8]=-j[2],KH(A,WF(A,t))}}();var QaA=[0,0,0,1],Af=class extends Y7{constructor(A=0,j=0,e=0,r=1){super(-0,-0,-0,-0),Array.isArray(A)&&arguments.length===1?this.copy(A):this.set(A,j,e,r)}copy(A){return this[0]=A[0],this[1]=A[1],this[2]=A[2],this[3]=A[3],this.check()}set(A,j,e,r){return this[0]=A,this[1]=j,this[2]=e,this[3]=r,this.check()}fromObject(A){return this[0]=A.x,this[1]=A.y,this[2]=A.z,this[3]=A.w,this.check()}fromMatrix3(A){return WF(this,A),this.check()}fromAxisRotation(A,j){return VF(this,A,j),this.check()}identity(){return FH(this),this.check()}setAxisAngle(A,j){return this.fromAxisRotation(A,j)}get ELEMENTS(){return 4}get x(){return this[0]}set x(A){this[0]=nj(A)}get y(){return this[1]}set y(A){this[1]=nj(A)}get z(){return this[2]}set z(A){this[2]=nj(A)}get w(){return this[3]}set w(A){this[3]=nj(A)}len(){return DH(this)}lengthSquared(){return NH(this)}dot(A){return CH(this,A)}rotationTo(A,j){return XH(this,A,j),this.check()}add(A){return RH(this,this,A),this.check()}calculateW(){return OH(this,this),this.check()}conjugate(){return SH(this,this),this.check()}invert(){return TH(this,this),this.check()}lerp(A,j,e){return e===void 0?this.lerp(this,A,j):(HH(this,A,j,e),this.check())}multiplyRight(A){return QF(this,this,A),this.check()}multiplyLeft(A){return QF(this,A,this),this.check()}normalize(){let A=this.len(),j=A>0?1/A:0;return this[0]=this[0]*j,this[1]=this[1]*j,this[2]=this[2]*j,this[3]=this[3]*j,A===0&&(this[3]=1),this.check()}rotateX(A){return PH(this,this,A),this.check()}rotateY(A){return IH(this,this,A),this.check()}rotateZ(A){return MH(this,this,A),this.check()}scale(A){return LH(this,this,A),this.check()}slerp(A,j,e){let r,n,i;switch(arguments.length){case 1:({start:r=QaA,target:n,ratio:i}=A);break;case 2:r=this,n=A,i=j;break;default:r=A,n=j,i=e}return Tk(this,r,n,i),this.check()}transformVector4(A,j=new zx){return bH(j,A,this),Lx(j,4)}lengthSq(){return this.lengthSquared()}setFromAxisAngle(A,j){return this.setAxisAngle(A,j)}premultiply(A){return this.multiplyLeft(A)}multiply(A){return this.multiplyRight(A)}};var Sk={};fr(Sk,{EPSILON1:()=>WaA,EPSILON10:()=>n7A,EPSILON11:()=>i7A,EPSILON12:()=>o7A,EPSILON13:()=>s7A,EPSILON14:()=>a7A,EPSILON15:()=>l7A,EPSILON16:()=>c7A,EPSILON17:()=>u7A,EPSILON18:()=>B7A,EPSILON19:()=>f7A,EPSILON2:()=>YaA,EPSILON20:()=>h7A,EPSILON3:()=>JaA,EPSILON4:()=>ZaA,EPSILON5:()=>A7A,EPSILON6:()=>t7A,EPSILON7:()=>j7A,EPSILON8:()=>e7A,EPSILON9:()=>r7A,PI_OVER_FOUR:()=>p7A,PI_OVER_SIX:()=>k7A,PI_OVER_TWO:()=>d7A,TWO_PI:()=>g7A});var WaA=.1,YaA=.01,JaA=.001,ZaA=1e-4,A7A=1e-5,t7A=1e-6,j7A=1e-7,e7A=1e-8,r7A=1e-9,n7A=1e-10,i7A=1e-11,o7A=1e-12,s7A=1e-13,a7A=1e-14,l7A=1e-15,c7A=1e-16,u7A=1e-17,B7A=1e-18,f7A=1e-19,h7A=1e-20,d7A=Math.PI/2,p7A=Math.PI/4,k7A=Math.PI/6,g7A=Math.PI*2;var zH=new LA,m7A=new LA,tf=class t{constructor(A=[0,0,0],j=[0,0,0],e){e=e||zH.copy(A).add(j).scale(.5),this.center=new LA(e),this.halfDiagonal=new LA(j).subtract(this.center),this.minimum=new LA(A),this.maximum=new LA(j)}clone(){return new t(this.minimum,this.maximum,this.center)}equals(A){return this===A||!!A&&this.minimum.equals(A.minimum)&&this.maximum.equals(A.maximum)}transform(A){return this.center.transformAsPoint(A),this.halfDiagonal.transform(A),this.minimum.transform(A),this.maximum.transform(A),this}intersectPlane(A){let{halfDiagonal:j}=this,e=m7A.from(A.normal),r=j.x*Math.abs(e.x)+j.y*Math.abs(e.y)+j.z*Math.abs(e.z),n=this.center.dot(e)+A.distance;return n-r>0?be.INSIDE:n+r<0?be.OUTSIDE:be.INTERSECTING}distanceTo(A){return Math.sqrt(this.distanceSquaredTo(A))}distanceSquaredTo(A){let j=zH.from(A).subtract(this.center),{halfDiagonal:e}=this,r=0,n;return n=Math.abs(j.x)-e.x,n>0&&(r+=n*n),n=Math.abs(j.y)-e.y,n>0&&(r+=n*n),n=Math.abs(j.z)-e.z,n>0&&(r+=n*n),r}};var Rk=new LA,UH=new LA,jf=class t{constructor(A=[0,0,0],j=0){this.radius=-0,this.center=new LA,this.fromCenterRadius(A,j)}fromCenterRadius(A,j){return this.center.from(A),this.radius=j,this}fromCornerPoints(A,j){return j=Rk.from(j),this.center=new LA().from(A).add(j).scale(.5),this.radius=this.center.distance(j),this}equals(A){return this===A||!!A&&this.center.equals(A.center)&&this.radius===A.radius}clone(){return new t(this.center,this.radius)}union(A){let j=this.center,e=this.radius,r=A.center,n=A.radius,i=Rk.copy(r).subtract(j),o=i.magnitude();if(e>=o+n)return this.clone();if(n>=o+e)return A.clone();let l=(e+o+n)*.5;return UH.copy(i).scale((-e+l)/o).add(j),this.center.copy(UH),this.radius=l,this}expand(A){let e=Rk.from(A).subtract(this.center).magnitude();return e>this.radius&&(this.radius=e),this}transform(A){this.center.transform(A);let j=Wx.getScaling(Rk,A);return this.radius=Math.max(j[0],Math.max(j[1],j[2]))*this.radius,this}distanceSquaredTo(A){let j=this.distanceTo(A);return j*j}distanceTo(A){let e=Rk.from(A).subtract(this.center);return Math.max(0,e.len()-this.radius)}intersectPlane(A){let j=this.center,e=this.radius,n=A.normal.dot(j)+A.distance;return n<-e?be.OUTSIDE:n=l?be.INSIDE:be.INTERSECTING}distanceTo(A){return Math.sqrt(this.distanceSquaredTo(A))}distanceSquaredTo(A){let j=$7A.from(A).subtract(this.center),e=this.halfAxes,r=e.getColumn(0,Yx),n=e.getColumn(1,Jx),i=e.getColumn(2,Zx),o=r.magnitude(),l=n.magnitude(),c=i.magnitude();r.normalize(),n.normalize(),i.normalize();let B=0,h;return h=Math.abs(j.dot(r))-o,h>0&&(B+=h*h),h=Math.abs(j.dot(n))-l,h>0&&(B+=h*h),h=Math.abs(j.dot(i))-c,h>0&&(B+=h*h),B}computePlaneDistances(A,j,e=[-0,-0]){let r=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,i=this.center,o=this.halfAxes,l=o.getColumn(0,Yx),c=o.getColumn(1,Jx),B=o.getColumn(2,Zx),h=x7A.copy(l).add(c).add(B).add(i),d=y7A.copy(h).subtract(A),k=j.dot(d);return r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).add(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).subtract(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),h.copy(i).add(l).subtract(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).add(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).add(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).subtract(c).add(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),i.copy(h).subtract(l).subtract(c).subtract(B),d.copy(h).subtract(A),k=j.dot(d),r=Math.min(k,r),n=Math.max(k,n),e[0]=r,e[1]=n,e}transform(A){this.center.transformAsPoint(A);let j=this.halfAxes.getColumn(0,Yx);j.transformAsPoint(A);let e=this.halfAxes.getColumn(1,Jx);e.transformAsPoint(A);let r=this.halfAxes.getColumn(2,Zx);return r.transformAsPoint(A),this.halfAxes=new oe([...j,...e,...r]),this}getTransform(){throw new Error("not implemented")}};var VH=new LA,QH=new LA,Da=class t{constructor(A=[0,0,1],j=0){this.normal=new LA,this.distance=-0,this.fromNormalDistance(A,j)}fromNormalDistance(A,j){return ps(Number.isFinite(j)),this.normal.from(A).normalize(),this.distance=j,this}fromPointNormal(A,j){A=VH.from(A),this.normal.from(j).normalize();let e=-this.normal.dot(A);return this.distance=e,this}fromCoefficients(A,j,e,r){return this.normal.set(A,j,e),ps(W7(this.normal.len(),1)),this.distance=r,this}clone(){return new t(this.normal,this.distance)}equals(A){return W7(this.distance,A.distance)&&W7(this.normal,A.normal)}getPointDistance(A){return this.normal.dot(A)+this.distance}transform(A){let j=QH.copy(this.normal).transformAsVector(A).normalize(),e=this.normal.scale(-this.distance).transform(A);return this.fromPointNormal(e,j)}projectPointOntoPlane(A,j=[0,0,0]){let e=VH.from(A),r=this.getPointDistance(e),n=QH.copy(this.normal).scale(r);return e.subtract(n).to(j)}};var WH=[new LA([1,0,0]),new LA([0,1,0]),new LA([0,0,1])],YH=new LA,v7A=new LA,Na=class t{constructor(A=[]){this.planes=A}fromBoundingSphere(A){this.planes.length=2*WH.length;let j=A.center,e=A.radius,r=0;for(let n of WH){let i=this.planes[r],o=this.planes[r+1];i||(i=this.planes[r]=new Da),o||(o=this.planes[r+1]=new Da);let l=YH.copy(n).scale(-e).add(j);i.fromPointNormal(l,n);let c=YH.copy(n).scale(e).add(j),B=v7A.copy(n).negate();o.fromPointNormal(c,B),r+=2}return this}computeVisibility(A){let j=be.INSIDE;for(let e of this.planes)switch(A.intersectPlane(e)){case be.OUTSIDE:return be.OUTSIDE;case be.INTERSECTING:j=be.INTERSECTING;break;default:}return j}computeVisibilityWithPlaneMask(A,j){if(ps(Number.isFinite(j),"parentPlaneMask is required."),j===t.MASK_OUTSIDE||j===t.MASK_INSIDE)return j;let e=t.MASK_INSIDE,r=this.planes;for(let n=0;nl;)F7A(o,Ay),JH.copy(Ay).transpose(),o.multiplyRight(Ay),o.multiplyLeft(JH),i.multiplyRight(Ay),++r>2&&(++n,r=0);return A.unitary=i.toTarget(A.unitary),A.diagonal=o.toTarget(A.diagonal),A}function G7A(t){let A=0;for(let j=0;j<9;++j){let e=t[j];A+=e*e}return Math.sqrt(A)}var YF=[1,0,0],JF=[2,2,1];function w7A(t){let A=0;for(let j=0;j<3;++j){let e=t[ks.getElementIndex(JF[j],YF[j])];A+=2*e*e}return Math.sqrt(A)}function F7A(t,A){let j=Sk.EPSILON15,e=0,r=1;for(let c=0;c<3;++c){let B=Math.abs(t[ks.getElementIndex(JF[c],YF[c])]);B>e&&(r=c,e=B)}let n=YF[r],i=JF[r],o=1,l=0;if(Math.abs(t[ks.getElementIndex(i,n)])>j){let c=t[ks.getElementIndex(i,i)],B=t[ks.getElementIndex(n,n)],h=t[ks.getElementIndex(i,n)],d=(c-B)/2/h,k;d<0?k=-1/(-d+Math.sqrt(1+d*d)):k=1/(d+Math.sqrt(1+d*d)),o=1/Math.sqrt(1+k*k),l=k*o}return oe.IDENTITY.to(A),A[ks.getElementIndex(n,n)]=A[ks.getElementIndex(i,i)]=o,A[ks.getElementIndex(i,n)]=l,A[ks.getElementIndex(n,i)]=-l,A}var J7=new LA,P7A=new LA,I7A=new LA,M7A=new LA,O7A=new LA,T7A=new oe,S7A={diagonal:new oe,unitary:new oe};function A1(t,A=new Lk){if(!t||t.length===0)return A.halfAxes=new oe([0,0,0,0,0,0,0,0,0]),A.center=new LA,A;let j=t.length,e=new LA(0,0,0);for(let C of t)e.add(C);let r=1/j;e.multiplyByScalar(r);let n=0,i=0,o=0,l=0,c=0,B=0;for(let C of t){let R=J7.copy(C).subtract(e);n+=R.x*R.x,i+=R.x*R.y,o+=R.x*R.z,l+=R.y*R.y,c+=R.y*R.z,B+=R.z*R.z}n*=r,i*=r,o*=r,l*=r,c*=r,B*=r;let h=T7A;h[0]=n,h[1]=i,h[2]=o,h[3]=i,h[4]=l,h[5]=c,h[6]=o,h[7]=c,h[8]=B;let{unitary:d}=ZF(h,S7A),k=A.halfAxes.copy(d),g=k.getColumn(0,I7A),E=k.getColumn(1,M7A),m=k.getColumn(2,O7A),y=-Number.MAX_VALUE,G=-Number.MAX_VALUE,v=-Number.MAX_VALUE,_=Number.MAX_VALUE,w=Number.MAX_VALUE,x=Number.MAX_VALUE;for(let C of t)J7.copy(C),y=Math.max(J7.dot(g),y),G=Math.max(J7.dot(E),G),v=Math.max(J7.dot(m),v),_=Math.min(J7.dot(g),_),w=Math.min(J7.dot(E),w),x=Math.min(J7.dot(m),x);g=g.multiplyByScalar(.5*(_+y)),E=E.multiplyByScalar(.5*(w+G)),m=m.multiplyByScalar(.5*(x+v)),A.center.copy(g).add(E).add(m);let O=P7A.set(y-_,G-w,v-x).multiplyByScalar(.5),F=new oe([O[0],0,0,0,O[1],0,0,0,O[2]]);return A.halfAxes.multiplyRight(F),A}var ef=512,ZH=3,AD=[[.5,.5],[0,0],[0,1],[1,0],[1,1]],tD=AD.concat([[0,.5],[.5,0],[1,.5],[.5,1]]),R7A=tD.concat([[.25,.5],[.75,.5]]),t1=class t{constructor(A,j,e){this.x=A,this.y=j,this.z=e}get children(){if(!this._children){let A=this.x*2,j=this.y*2,e=this.z+1;this._children=[new t(A,j,e),new t(A,j+1,e),new t(A+1,j,e),new t(A+1,j+1,e)]}return this._children}update(A){let{viewport:j,cullingVolume:e,elevationBounds:r,minZ:n,maxZ:i,bounds:o,offset:l,project:c}=A,B=this.getBoundingVolume(r,l,c);if(o&&!this.insideBounds(o)||e.computeVisibility(B)<0)return!1;if(!this.childVisible){let{z:d}=this;if(d=n){let k=B.distanceTo(j.cameraPosition)*j.scale/j.height;d+=Math.floor(Math.log2(k))}if(d>=i)return this.selected=!0,!0}this.selected=!1,this.childVisible=!0;for(let d of this.children)d.update(A);return!0}getSelected(A=[]){if(this.selected&&A.push(this),this._children)for(let j of this._children)j.getSelected(A);return A}insideBounds([A,j,e,r]){let n=Math.pow(2,this.z),i=ef/n;return this.x*iA&&(this.y+1)*i>j}getBoundingVolume(A,j,e){if(e){let l=this.z<1?R7A:this.z<2?tD:AD,c=[];for(let B of l){let h=ty(this.x+B[0],this.y+B[1],this.z);h[2]=A[0],c.push(e(h)),A[0]!==A[1]&&(h[2]=A[1],c.push(e(h)))}return A1(c)}let r=Math.pow(2,this.z),n=ef/r,i=this.x*n+j*ef,o=ef-(this.y+1)*n;return new tf([i,o,A[0]],[i+n,o+n,A[1]])}};function jD(t,A,j,e){let r=t instanceof Oc&&t.resolution?t.projectPosition:null,n=Object.values(t.getFrustumPlanes()).map(({normal:k,distance:g})=>new Da(k.clone().negate(),g)),i=new Na(n),o=t.distanceScales.unitsPerMeter[2],l=j&&j[0]*o||0,c=j&&j[1]*o||0,B=t instanceof Fa&&t.pitch<=60?A:0;if(e){let[k,g,E,m]=e,y=In([k,m]),G=In([E,g]);e=[y[0],ef-y[1],G[0],ef-G[1]]}let h=new t1(0,0,0),d={viewport:t,project:r,cullingVolume:i,elevationBounds:[l,c],minZ:B,maxZ:A,bounds:e,offset:0};if(h.update(d),t instanceof Fa&&t.subViewports&&t.subViewports.length>1){for(d.offset=-1;h.update(d)&&!(--d.offset<-ZH););for(d.offset=1;h.update(d)&&!(++d.offset>ZH););}return h.getSelected()}var Ka=512,L7A=[-1/0,-1/0,1/0,1/0],e1={type:"object",value:null,validate:(t,A)=>A.optional&&t===null||typeof t=="string"||Array.isArray(t)&&t.every(j=>typeof j=="string"),equal:(t,A)=>{if(t===A)return!0;if(!Array.isArray(t)||!Array.isArray(A))return!1;let j=t.length;if(j!==A.length)return!1;for(let e=0;er[0])),Math.min(...j.map(r=>r[1])),Math.max(...j.map(r=>r[0])),Math.max(...j.map(r=>r[1]))]}function C7A(t){return Math.abs(t.split("").reduce((A,j)=>(A<<5)-A+j.charCodeAt(0)|0,0))}function r1(t,A){if(!t||!t.length)return null;let{index:j,id:e}=A;if(Array.isArray(t)){let n=C7A(e)%t.length;t=t[n]}let r=t;for(let n of Object.keys(j)){let i=new RegExp(`{${n}}`,"g");r=r.replace(i,String(j[n]))}return Number.isInteger(j.y)&&Number.isInteger(j.z)&&(r=r.replace(/\{-y\}/g,String(Math.pow(2,j.z)-j.y-1))),r}function H7A(t,A,j){let e;if(A&&A.length===2){let[r,n]=A,i=t.getBounds({z:r}),o=t.getBounds({z:n});e=[Math.min(i[0],o[0]),Math.min(i[1],o[1]),Math.max(i[2],o[2]),Math.max(i[3],o[3])]}else e=t.getBounds();return t.isGeospatial?[Math.max(e[0],j[0]),Math.max(e[1],j[1]),Math.min(e[2],j[2]),Math.min(e[3],j[3])]:[Math.max(Math.min(e[0],j[2]),j[0]),Math.max(Math.min(e[1],j[3]),j[1]),Math.min(Math.max(e[2],j[0]),j[2]),Math.min(Math.max(e[3],j[1]),j[3])]}function nD({viewport:t,z:A,cullRect:j}){return(t.subViewports||[t]).map(r=>j1(r,A||0,j))}function j1(t,A,j){if(!Array.isArray(A)){let n=j.x-t.x,i=j.y-t.y,{width:o,height:l}=j,c={targetZ:A},B=t.unproject([n,i],c),h=t.unproject([n+o,i],c),d=t.unproject([n,i+l],c),k=t.unproject([n+o,i+l],c);return[Math.min(B[0],h[0],d[0],k[0]),Math.min(B[1],h[1],d[1],k[1]),Math.max(B[0],h[0],d[0],k[0]),Math.max(B[1],h[1],d[1],k[1])]}let e=j1(t,A[0],j),r=j1(t,A[1],j);return[Math.min(e[0],r[0]),Math.min(e[1],r[1]),Math.max(e[2],r[2]),Math.max(e[3],r[3])]}function D7A(t,A,j){return j?rD(t,j).map(r=>r*A/Ka):t.map(e=>e*A/Ka)}function n1(t,A){return Math.pow(2,t)*Ka/A}function ty(t,A,j){let e=n1(j,Ka),r=t/e*360-180,n=Math.PI-2*Math.PI*A/e,i=180/Math.PI*Math.atan(.5*(Math.exp(n)-Math.exp(-n)));return[r,i]}function eD(t,A,j,e){let r=n1(j,e);return[t/r*Ka,A/r*Ka]}function i1(t,A,j,e,r=Ka){if(t.isGeospatial){let[c,B]=ty(A,j,e),[h,d]=ty(A+1,j+1,e);return{west:c,north:B,east:h,south:d}}let[n,i]=eD(A,j,e,r),[o,l]=eD(A+1,j+1,e,r);return{left:n,top:i,right:o,bottom:l}}function N7A(t,A,j,e,r){let n=H7A(t,null,e),i=n1(A,j),[o,l,c,B]=D7A(n,i,r),h=[];for(let d=Math.floor(o);dA&&(c=A);let B=r;return i&&o&&r&&!t.isGeospatial&&(B=rD(r,i)),t.isGeospatial?jD(t,c,e,r):N7A(t,c,n,B||L7A,o)}function iD(t){let A={},j;return e=>{for(let r in e)if(!K7A(e[r],A[r])){j=t(e),A=e;break}return j}}function K7A(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{}},Q7A={extent:null,tileSize:512,maxZoom:null,minZoom:null,maxCacheSize:null,maxCacheByteSize:null,refinementStrategy:"best-available",zRange:null,maxRequests:6,debounceTime:0,zoomOffset:0,onTileLoad:()=>{},onTileUnload:()=>{},onTileError:()=>{}},rf=class{constructor(A){this._getCullBounds=iD(nD),this.opts={...Q7A,...A},this.setOptions(this.opts),this.onTileLoad=j=>{this.opts.onTileLoad?.(j),this.opts.maxCacheByteSize!=null&&(this._cacheByteSize+=j.byteLength,this._resizeCache())},this._requestScheduler=new oB({throttleRequests:this.opts.maxRequests>0||this.opts.debounceTime>0,maxRequests:this.opts.maxRequests,debounceTime:this.opts.debounceTime}),this._cache=new Map,this._tiles=[],this._dirty=!1,this._cacheByteSize=0,this._viewport=null,this._zRange=null,this._selectedTiles=null,this._frameNumber=0,this._modelMatrix=new lj,this._modelMatrixInverse=new lj}get tiles(){return this._tiles}get selectedTiles(){return this._selectedTiles}get isLoaded(){return this._selectedTiles!==null&&this._selectedTiles.every(A=>A.isLoaded)}get needsReload(){return this._selectedTiles!==null&&this._selectedTiles.some(A=>A.needsReload)}setOptions(A){Object.assign(this.opts,A),Number.isFinite(A.maxZoom)&&(this._maxZoom=Math.floor(A.maxZoom)),Number.isFinite(A.minZoom)&&(this._minZoom=Math.ceil(A.minZoom))}finalize(){for(let A of this._cache.values())A.isLoading&&A.abort();this._cache.clear(),this._tiles=[],this._selectedTiles=null}reloadAll(){for(let A of this._cache.keys()){let j=this._cache.get(A);!this._selectedTiles||!this._selectedTiles.includes(j)?this._cache.delete(A):j.setNeedsReload()}}update(A,{zRange:j,modelMatrix:e}={zRange:null,modelMatrix:null}){let r=e?new lj(e):new lj,n=!r.equals(this._modelMatrix);if(!this._viewport||!A.equals(this._viewport)||!Bo(this._zRange,j)||n){n&&(this._modelMatrixInverse=r.clone().invert(),this._modelMatrix=r),this._viewport=A,this._zRange=j;let o=this.getTileIndices({viewport:A,maxZoom:this._maxZoom,minZoom:this._minZoom,zRange:j,modelMatrix:this._modelMatrix,modelMatrixInverse:this._modelMatrixInverse});this._selectedTiles=o.map(l=>this._getTile(l,!0)),this._dirty&&this._rebuildTree()}else this.needsReload&&(this._selectedTiles=this._selectedTiles.map(o=>this._getTile(o.index,!0)));let i=this.updateTileStates();return this._pruneRequests(),this._dirty&&this._resizeCache(),i&&this._frameNumber++,this._frameNumber}isTileVisible(A,j){if(!A.isVisible)return!1;if(j&&this._viewport){let e=this._getCullBounds({viewport:this._viewport,z:this._zRange,cullRect:j}),{bbox:r}=A;for(let[n,i,o,l]of e){let c;if("west"in r)c=r.westn&&r.southi;else{let B=Math.min(r.top,r.bottom),h=Math.max(r.top,r.bottom);c=r.leftn&&Bi}if(c)return!0}return!1}return!0}getTileIndices({viewport:A,maxZoom:j,minZoom:e,zRange:r,modelMatrix:n,modelMatrixInverse:i}){let{tileSize:o,extent:l,zoomOffset:c}=this.opts;return o1({viewport:A,maxZoom:j,minZoom:e,zRange:r,tileSize:o,extent:l,modelMatrix:n,modelMatrixInverse:i,zoomOffset:c})}getTileId(A){return`${A.x}-${A.y}-${A.z}`}getTileZoom(A){return A.z}getTileMetadata(A){let{tileSize:j}=this.opts;return{bbox:i1(this._viewport,A.x,A.y,A.z,j)}}getParentIndex(A){let j=Math.floor(A.x/2),e=Math.floor(A.y/2),r=A.z-1;return{x:j,y:e,z:r}}updateTileStates(){let A=this.opts.refinementStrategy||Ck,j=new Array(this._cache.size),e=0;for(let r of this._cache.values())j[e++]=r.isVisible,r.isSelected=!1,r.isVisible=!1;for(let r of this._selectedTiles)r.isSelected=!0,r.isVisible=!0;(typeof A=="function"?A:V7A[A])(Array.from(this._cache.values())),e=0;for(let r of this._cache.values())if(j[e++]!==r.isVisible)return!0;return!1}_pruneRequests(){let{maxRequests:A=0}=this.opts,j=[],e=0;for(let r of this._cache.values())r.isLoading&&(e++,!r.isSelected&&!r.isVisible&&j.push(r));for(;A>0&&e>A&&j.length>0;)j.shift().abort(),e--}_rebuildTree(){let{_cache:A}=this;for(let j of A.values())j.parent=null,j.children&&(j.children.length=0);for(let j of A.values()){let e=this._getNearestAncestor(j);j.parent=e,e?.children&&e.children.push(j)}}_resizeCache(){let{_cache:A,opts:j}=this,e=j.maxCacheSize??(j.maxCacheByteSize!=null?1/0:U7A*this.selectedTiles.length),r=j.maxCacheByteSize??1/0;if(A.size>e||this._cacheByteSize>r){for(let[i,o]of A)if(!o.isVisible&&!o.isSelected&&(this._cacheByteSize-=j.maxCacheByteSize!=null?o.byteLength:0,A.delete(i),this.opts.onTileUnload?.(o)),A.size<=e&&this._cacheByteSize<=r)break;this._rebuildTree(),this._dirty=!0}this._dirty&&(this._tiles=Array.from(this._cache.values()).sort((i,o)=>i.zoom-o.zoom),this._dirty=!1)}_getTile(A,j){let e=this.getTileId(A),r=this._cache.get(e),n=!1;return!r&&j?(r=new Rx(A),Object.assign(r,this.getTileMetadata(r.index)),Object.assign(r,{id:e,zoom:this.getTileZoom(r.index)}),n=!0,this._cache.set(e,r),this._dirty=!0):r&&r.needsReload&&(n=!0),r&&n&&r.loadData({getData:this.opts.getTileData,requestScheduler:this._requestScheduler,onLoad:this.onTileLoad,onError:this.opts.onTileError}),r}_getNearestAncestor(A){let{_minZoom:j=0}=this,e=A.index;for(;this.getTileZoom(e)>j;){e=this.getParentIndex(e);let r=this._getTile(e);if(r)return r}return null}};function W7A(t){for(let A of t)A.state=0;for(let A of t)A.isSelected&&!sD(A)&&s1(A);for(let A of t)A.isVisible=!!(A.state&jy)}function Y7A(t){for(let j of t)j.state=0;for(let j of t)j.isSelected&&sD(j);let A=Array.from(t).sort((j,e)=>j.zoom-e.zoom);for(let j of A)if(j.isVisible=!!(j.state&jy),j.children&&(j.isVisible||j.state&oD))for(let e of j.children)e.state=oD;else j.isSelected&&s1(j)}function sD(t){let A=t;for(;A;){if(A.isLoaded||A.content)return A.state|=jy,!0;A=A.parent}return!1}function s1(t){for(let A of t.children)A.isLoaded||A.content?A.state|=jy:s1(A)}var J7A={TilesetClass:rf,data:{type:"data",value:[]},dataComparator:e1.equal,renderSubLayers:{type:"function",value:t=>new La(t)},getTileData:{type:"function",optional:!0,value:null},onViewportLoad:{type:"function",optional:!0,value:null},onTileLoad:{type:"function",value:t=>{}},onTileUnload:{type:"function",value:t=>{}},onTileError:{type:"function",value:t=>console.error(t)},extent:{type:"array",optional:!0,value:null,compare:!0},tileSize:512,maxZoom:null,minZoom:0,maxCacheSize:null,maxCacheByteSize:null,refinementStrategy:Ck,zRange:null,maxRequests:6,debounceTime:0,zoomOffset:0},Hk=class extends b6{initializeState(){this.state={tileset:null,isLoaded:!1}}finalizeState(){this.state?.tileset?.finalize()}get isLoaded(){return!!this.state?.tileset?.selectedTiles?.every(A=>A.isLoaded&&A.layers&&A.layers.every(j=>j.isLoaded))}shouldUpdateState({changeFlags:A}){return A.somethingChanged}updateState({changeFlags:A}){let{tileset:j}=this.state,e=A.propsOrDataChanged||A.updateTriggersChanged,r=A.dataChanged||A.updateTriggersChanged&&(A.updateTriggersChanged.all||A.updateTriggersChanged.getTileData);j?e&&(j.setOptions(this._getTilesetOptions()),r?j.reloadAll():j.tiles.forEach(n=>{n.layers=null})):(j=new this.props.TilesetClass(this._getTilesetOptions()),this.setState({tileset:j})),this._updateTileset()}_getTilesetOptions(){let{tileSize:A,maxCacheSize:j,maxCacheByteSize:e,refinementStrategy:r,extent:n,maxZoom:i,minZoom:o,maxRequests:l,debounceTime:c,zoomOffset:B}=this.props;return{maxCacheSize:j,maxCacheByteSize:e,maxZoom:i,minZoom:o,tileSize:A,refinementStrategy:r,extent:n,maxRequests:l,debounceTime:c,zoomOffset:B,getTileData:this.getTileData.bind(this),onTileLoad:this._onTileLoad.bind(this),onTileError:this._onTileError.bind(this),onTileUnload:this._onTileUnload.bind(this)}}_updateTileset(){let A=this.state.tileset,{zRange:j,modelMatrix:e}=this.props,r=A.update(this.context.viewport,{zRange:j,modelMatrix:e}),{isLoaded:n}=A,i=this.state.isLoaded!==n,o=this.state.frameNumber!==r;n&&(i||o)&&this._onViewportLoad(),o&&this.setState({frameNumber:r}),this.state.isLoaded=n}_onViewportLoad(){let{tileset:A}=this.state,{onViewportLoad:j}=this.props;j&&j(A.selectedTiles)}_onTileLoad(A){this.props.onTileLoad(A),A.layers=null,this.setNeedsUpdate()}_onTileError(A,j){this.props.onTileError(A),j.layers=null,this.setNeedsUpdate()}_onTileUnload(A){this.props.onTileUnload(A)}getTileData(A){let{data:j,getTileData:e,fetch:r}=this.props,{signal:n}=A;return A.url=typeof j=="string"||Array.isArray(j)?r1(j,A):null,e?e(A):r&&A.url?r(A.url,{propName:"data",layer:this,signal:n}):null}renderSubLayers(A){return this.props.renderSubLayers(A)}getSubLayerPropsByTile(A){return null}getPickingInfo(A){let j=A.sourceLayer,e=j.props.tile,r=A.info;return r.picked&&(r.tile=e),r.sourceTile=e,r.sourceTileSubLayer=j,r}_updateAutoHighlight(A){A.sourceTileSubLayer.updateAutoHighlight(A)}renderLayers(){return this.state.tileset.tiles.map(A=>{let j=this.getSubLayerPropsByTile(A);if(!(!A.isLoaded&&!A.content))if(A.layers)j&&A.layers[0]&&Object.keys(j).some(e=>A.layers[0].props[e]!==j[e])&&(A.layers=A.layers.map(e=>e.clone(j)));else{let e=this.renderSubLayers({...this.props,...this.getSubLayerProps({id:A.id,updateTriggers:this.props.updateTriggers}),data:A.content,_offset:0,tile:A});A.layers=Ia(e,Boolean).map(r=>r.clone({tile:A,...j}))}return A.layers})}filterSubLayer({layer:A,cullRect:j}){let{tile:e}=A.props;return this.state.tileset.isTileVisible(e,j)}};Hk.defaultProps=J7A;Hk.layerName="TileLayer";var Rc=Hk;var ey=(t,A,j)=>new N7({parent:t,controller:{doubleClickZoom:!1},width:A,height:j});var nf=(t="")=>t==="point-cloud"?[new dx({id:"orbit"})]:[new un({id:"ortho"})];var Nt={},Z7=t=>{Nt={fetch:{headers:{}}},t&&(Nt.fetch.headers.Authorization=`Bearer ${t}`)};var Z7A=1e-6,aD=(t=0,A=[0,0])=>{let j=t*Math.PI/180,e=Math.abs(j)>Z7A,r=Math.sin(j),n=Math.cos(j),i={angleDegrees:t,angleRadians:j,hasRotation:e,sin:r,cos:n,center:A,modelMatrix:null};if(e){let o=new lj().translate([A[0],A[1],0]).rotateZ(j).translate([-A[0],-A[1],0]);i.modelMatrix=Array.from(o)}return i},Er=t=>t?.hasRotation&&t.modelMatrix?{modelMatrix:t.modelMatrix}:{},a1=(t,A,j)=>{if(!j?.hasRotation)return[t,A];let{center:e,sin:r,cos:n}=j,i=t-e[0],o=A-e[1];return[n*i-r*o+e[0],r*i+n*o+e[1]]},lD=(t,A,j)=>{if(!j?.hasRotation)return[t,A];let{center:e,sin:r,cos:n}=j,i=t-e[0],o=A-e[1];return[n*i+r*o+e[0],-r*i+n*o+e[1]]};function Lc(t){"@babel/helpers - typeof";return Lc=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(A){return typeof A}:function(A){return A&&typeof Symbol=="function"&&A.constructor===Symbol&&A!==Symbol.prototype?"symbol":typeof A},Lc(t)}function cD(t,A){if(Lc(t)!="object"||!t)return t;var j=t[Symbol.toPrimitive];if(j!==void 0){var e=j.call(t,A||"default");if(Lc(e)!="object")return e;throw new TypeError("@@toPrimitive must return a primitive value.")}return(A==="string"?String:Number)(t)}function uD(t){var A=cD(t,"string");return Lc(A)=="symbol"?A:A+""}var Cc={};Cc.EPSILON=1e-12;Cc.debug=!0;Cc.precision=4;Cc.printTypes=!1;Cc.printDegrees=!1;Cc.printRowMajor=!0;function BD(t){return Array.isArray(t)||ArrayBuffer.isView(t)&&t.length!==void 0}function fD(t){return t.clone?t.clone():new Array(t)}function AlA(t,A){if(BD(t)){for(var j=fD(t),e=0;er/255),uOpacityScale:j.opacityScale}})}draw(A){let{uniforms:j}=this.state;super.draw({...A,uniforms:{...A.uniforms,...j}})}};var Hk=(t,A,j,e,r={},n=null)=>async({index:i})=>{let{x:o,y:l,z:c}=i,B=`${t}/pyramid_images/${A}_files/${e+c}/${o}_${l}${j}`,{fetch:h={},...d}=r,k=async(g,E={})=>{let m={...h,...E};return n?n.fetch(g,m):fetch(g,m)};try{return await As(B,Hd,{...d,fetch:k})}catch(g){let E=Zj(g,{coordinates:`${o},${l},${c}`,url:B,messages:{network:"Failed to load tile due to network issues",notFound:"Tile does not exist",unauthorized:"Unauthorized access to tile",forbidden:"Access forbidden for tile",unexpected:"Failed to load tile"},throwOnAuth:!0,logUnexpected:!0});return E.error==="not_found"||E.error==="network",null}},ry=(t,A,j)=>e=>{let{bbox:{left:r,bottom:n,right:i,top:o}}=e.tile,{width:l,height:c}=t;return new ey(e,{data:null,image:e.data,bounds:[gs(r,0,l),gs(n,0,c),gs(i,0,l),gs(o,0,c)],color:A,opacityScale:j})},ny=t=>A=>{let{bbox:{left:j,bottom:e,right:r,top:n}}=A.tile,{width:i,height:o}=t;return new zB(A,{data:null,image:A.data,bounds:[gs(j,0,i),gs(e,0,o),gs(r,0,i),gs(n,0,o)]})};var of=async(t,A,j=0,e="")=>{let{global_base_url:r}=t,{dimensions:n}=t,{landscape_parameters:i}=t.img,{image_format:o}=t.img.landscape_parameters,l=`global-simple-image-layer-ds${j}${e?`-${e}`:""}`;return new Sc({id:l,tileSize:n.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:0,extent:[0,0,n.width,n.height],getTileData:Hk(r,A.name,o,i.max_pyramid_zoom,Nt,t.aws),renderSubLayers:ny(n),visible:!0,...Er(t.rotation)})},$D=(t,A)=>{t.simple_image_layer=t.simple_image_layer.clone({visible:A})};var Es=(t,A)=>{t.global_base_url=A};var xD=async(t,A,j,e)=>{let r=`${t}/pyramid_images/${A}.dzi`,i=await(e!==null?await e.fetch(r):await fetch(r,j.fetch)).text(),o=new DOMParser().parseFromString(i,"text/xml");return{height:Number(o.getElementsByTagName("Size")[0].attributes.Height.value),width:Number(o.getElementsByTagName("Size")[0].attributes.Width.value),tileSize:Number(o.getElementsByTagName("Image")[0].attributes.TileSize.value)}};var $s=async(t,A,j)=>{try{t.dimensions=await xD(A,j,Nt,t.aws);return}catch{}if(t.use_row_groups&&t.img?.landscape_parameters){let e=t.img.landscape_parameters;if(e.image_dimensions?.width&&e.image_dimensions?.height){t.dimensions={width:e.image_dimensions.width,height:e.image_dimensions.height,tileSize:e.image_dimensions.tile_size||512};return}if(t.row_group_readers?.images){let r=Object.values(t.row_group_readers.images)[0];if(r?.zoomInfo){let i=Object.keys(r.zoomInfo).map(Number).sort((l,c)=>c-l)[0],o=r.zoomInfo[String(i)];if(o){let c=o.num_tiles_x*512,B=o.num_tiles_y*512;t.dimensions={width:c,height:B,tileSize:512};return}}}}t.dimensions={width:1e4,height:1e4,tileSize:512}};var xs=async(t,A,j)=>{let e=`${A}/landscape_parameters.json`,r=await fetch(e,Nt.fetch);t.landscape_parameters=await r.json()};var s1=async(t,A,j,e,r,n,i,o,l="",c=0,B=800,h={})=>{c===0&&(c="100%");let d=document.createElement("div");d.style.height=`${B}px`;let k={};if(Z7(e),Es(k,j),"accessKeyId"in h){k.aws=new Yo({accessKeyId:h.accessKeyId,secretAccessKey:h.secretAccessKey,sessionToken:h.sessionToken,region:"us-east-1",service:"s3"});let v=await k.aws.fetch(`${j}/landscape_parameters.json`);if(!v.ok)throw new Error(`Fetch failed: ${v.statusText}`)}else k.aws=null;k.model=t,k.img={},k.img.image_layer_colors={},k.img.image_layer_sliders={},await xs(k.img,j),await $s(k,j,"h_and_e"),k.buttons={},k.buttons.blue="#8797ff",k.buttons.gray="gray",k.buttons.light_gray="#EEEEEE",k.buttons.buttons={};let m={simple_image_layer:await of(k,{name:"h_and_e",color:[0,0,255]})};k.views=nf();let y=Jx(d,c,B),b={target:[r,n,i],zoom:o};return y.setProps({views:k.views,layers:[m.simple_image_layer],initialViewState:b}),A.appendChild(d),()=>y.finalize()};var Cc={NONE:0,FORWARD:1,BACKWARD:2,BOTH:3},yD=1;var tlA={arrowColor:[0,0,0,1],arrowCount:yD,arrowStyle:Cc.NONE,fillColor:[0,0,0,1],lineColor:[0,0,0,1],lineWidthMeters:5,outlineRadiusMeters:0,opacity:1,zLevel:0};var On=63710088e-1,vVA={centimeters:On*100,centimetres:On*100,degrees:On/111325,feet:On*3.28084,inches:On*39.37,kilometers:On/1e3,kilometres:On/1e3,meters:On,metres:On,miles:On/1609.344,millimeters:On*1e3,millimetres:On*1e3,nauticalmiles:On/1852,radians:1,yards:On*1.0936},_VA={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/On,yards:1.0936133};function Dk(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function Vt(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!a1(t[0])||!a1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return Dk(e,A,j)}function $r(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return Dk(e,A,j)}function Xa(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function a1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function l1(t){return!!t&&t.constructor===Object}var Tn=63710088e-1,GVA={centimeters:Tn*100,centimetres:Tn*100,degrees:Tn/111325,feet:Tn*3.28084,inches:Tn*39.37,kilometers:Tn/1e3,kilometres:Tn/1e3,meters:Tn,metres:Tn,miles:Tn/1609.344,millimeters:Tn*1e3,millimetres:Tn*1e3,nauticalmiles:Tn/1852,radians:1,yards:Tn*1.0936},bVA={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Tn,yards:1.0936133};function c1(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yj[0]&&(A[0]=j[0]),A[1]>j[1]&&(A[1]=j[1]),A[2]1?0:t<-1?Kt:Math.acos(t)}function tr(t){return t>1?Ar:t<-1?-Ar:Math.asin(t)}function Cn(){}function By(t,A){t&&OD.hasOwnProperty(t.type)&&OD[t.type](t,A)}var MD={Feature:function(t,A){By(t.geometry,A)},FeatureCollection:function(t,A){for(var j=t.features,e=-1,r=j.length;++eKt?t-Nr:t<-Kt?t+Nr:t,A]}p1.invert=p1;function k1(t,A,j){return(t%=Nr)?A||j?hy(RD(t),LD(A,j)):RD(t):A||j?LD(A,j):p1}function SD(t){return function(A,j){return A+=t,[A>Kt?A-Nr:A<-Kt?A+Nr:A,j]}}function RD(t){var A=SD(t);return A.invert=SD(-t),A}function LD(t,A){var j=pt(t),e=kt(t),r=pt(A),n=kt(A);function i(o,l){var c=pt(l),B=pt(o)*c,h=kt(o)*c,d=kt(l),k=d*j+B*e;return[xr(h*r-k*n,B*j-d*e),tr(k*r+h*n)]}return i.invert=function(o,l){var c=pt(l),B=pt(o)*c,h=kt(o)*c,d=kt(l),k=d*r-h*n;return[xr(h*r+d*n,B*j+k*e),tr(k*j-B*e)]},i}function HD(t,A,j,e,r,n){if(j){var i=pt(A),o=kt(A),l=e*j;r==null?(r=A+e*Nr,n=A-l/2):(r=CD(i,r),n=CD(i,n),(e>0?rn)&&(r+=e*Nr));for(var c,B=r;e>0?B>n:B1&&t.push(t.pop().concat(t.shift()))},result:function(){var j=t;return t=[],A=null,j}}}function DD(t,A,j,e,r,n){var i=t[0],o=t[1],l=A[0],c=A[1],B=0,h=1,d=l-i,k=c-o,g;if(g=j-i,!(!d&&g>0)){if(g/=d,d<0){if(g0){if(g>h)return;g>B&&(B=g)}if(g=r-i,!(!d&&g<0)){if(g/=d,d<0){if(g>h)return;g>B&&(B=g)}else if(d>0){if(g0)){if(g/=k,k<0){if(g0){if(g>h)return;g>B&&(B=g)}if(g=n-o,!(!k&&g<0)){if(g/=k,k<0){if(g>h)return;g>B&&(B=g)}else if(k>0){if(g0&&(t[0]=i+B*d,t[1]=o+B*k),h<1&&(A[0]=i+h*d,A[1]=o+h*k),!0}}}}}function lf(t,A){return ij(t[0]-A[0])=0;--o)r.point((h=B[o])[0],h[1]);else e(d.x,d.p.x,-1,r);d=d.p}d=d.o,B=d.z,k=!k}while(!d.v);r.lineEnd()}}}function ND(t){if(A=t.length){for(var A,j=0,e=t[0],r;++jA?1:t>=A?0:NaN}function g1(t){return t.length===1&&(t=ilA(t)),{left:function(A,j,e,r){for(e==null&&(e=0),r==null&&(r=A.length);e>>1;t(A[n],j)<0?e=n+1:r=n}return e},right:function(A,j,e,r){for(e==null&&(e=0),r==null&&(r=A.length);e>>1;t(A[n],j)>0?r=n:e=n+1}return e}}}function ilA(t){return function(A,j){return jl(t(A),j)}}var KD=g1(jl),olA=KD.right,slA=KD.left;var XD=Array.prototype,llA=XD.slice,clA=XD.map;var BWA=Math.sqrt(50),fWA=Math.sqrt(10),hWA=Math.sqrt(2);function Uk(t){for(var A=t.length,j,e=-1,r=0,n,i;++e=0;)for(i=t[A],j=i.length;--j>=0;)n[--r]=i[j];return n}var Vk=1e9,my=-Vk;function m1(t,A,j,e){function r(c,B){return t<=c&&c<=j&&A<=B&&B<=e}function n(c,B,h,d){var k=0,g=0;if(c==null||(k=i(c,h))!==(g=i(B,h))||l(c,B)<0^h>0)do d.point(k===0||k===3?t:j,k>1?e:A);while((k=(k+h+4)%4)!==g);else d.point(B[0],B[1])}function i(c,B){return ij(c[0]-t)0?0:3:ij(c[0]-j)0?2:1:ij(c[1]-A)0?1:0:B>0?3:2}function o(c,B){return l(c.x,B.x)}function l(c,B){var h=i(c,1),d=i(B,1);return h!==d?h-d:h===0?B[1]-c[1]:h===1?c[0]-B[0]:h===2?c[1]-B[1]:B[0]-c[0]}return function(c){var B=c,h=dy(),d,k,g,E,m,y,b,v,_,w,x,S={point:F,lineStart:T,lineEnd:W,polygonStart:L,polygonEnd:z};function F(jA,pA){r(jA,pA)&&B.point(jA,pA)}function D(){for(var jA=0,pA=0,dA=k.length;pAe&&(SA-mt)*(e-Ct)>(ft-Ct)*(t-mt)&&++jA:ft<=e&&(SA-mt)*(e-Ct)<(ft-Ct)*(t-mt)&&--jA;return jA}function L(){B=h,d=[],k=[],x=!0}function z(){var jA=D(),pA=x&&jA,dA=(d=Uk(d)).length;(pA||dA)&&(c.polygonStart(),pA&&(c.lineStart(),n(null,null,1,c),c.lineEnd()),dA&&ky(d,o,jA,n,c),c.polygonEnd()),B=c,d=k=g=null}function T(){S.point=G,k&&k.push(g=[]),w=!0,_=!1,b=v=NaN}function W(){d&&(G(E,m),y&&_&&h.rejoin(),d.push(h.result())),S.point=F,_&&B.lineEnd()}function G(jA,pA){var dA=r(jA,pA);if(k&&g.push([jA,pA]),w)E=jA,m=pA,y=dA,w=!1,dA&&(B.lineStart(),B.point(jA,pA));else if(dA&&_)B.point(jA,pA);else{var $A=[b=Math.max(my,Math.min(Vk,b)),v=Math.max(my,Math.min(Vk,v))],_A=[jA=Math.max(my,Math.min(Vk,jA)),pA=Math.max(my,Math.min(Vk,pA))];DD($A,_A,t,A,j,e)?(_||(B.lineStart(),B.point($A[0],$A[1])),B.point(_A[0],_A[1]),dA||B.lineEnd(),x=!1):dA&&(B.lineStart(),B.point(jA,pA),x=!1)}b=jA,v=pA,_=dA}return S}}var E1=w6();function $1(t,A){var j=A[0],e=A[1],r=[kt(j),-pt(j),0],n=0,i=0;E1.reset();for(var o=0,l=t.length;o=0?1:-1,F=S*x,D=F>Kt,L=g*_;if(E1.add(xr(L*S*kt(F),E*w+L*pt(F))),n+=D?x+S*Nr:x,D^d>=j^b>=j){var z=Hc(Go(h),Go(y));af(z);var T=Hc(r,z);af(T);var W=(D^x>=0?-1:1)*tr(T[2]);(e>W||e===W&&(z[0]||z[1]))&&(i+=D^x>=0?1:-1)}}return(n<-xt||nWk&&(Wk=t),A$y&&($y=A)}var xy=ElA;function x1(t){this._context=t}x1.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(t,A){switch(this._point){case 0:{this._context.moveTo(t,A),this._point=1;break}case 1:{this._context.lineTo(t,A);break}default:{this._context.moveTo(t+this._radius,A),this._context.arc(t,A,this._radius,0,Nr);break}}},result:Cn};var RJA=w6();function y1(){this._string=[]}y1.prototype={_radius:4.5,_circle:VD(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(t,A){switch(this._point){case 0:{this._string.push("M",t,",",A),this._point=1;break}case 1:{this._string.push("L",t,",",A);break}default:{this._circle==null&&(this._circle=VD(this._radius)),this._string.push("M",t,",",A,this._circle);break}}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}else return null}};function VD(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function yy(t,A,j,e){return function(r,n){var i=A(n),o=r.invert(e[0],e[1]),l=dy(),c=A(l),B=!1,h,d,k,g={point:E,lineStart:y,lineEnd:b,polygonStart:function(){g.point=v,g.lineStart=_,g.lineEnd=w,d=[],h=[]},polygonEnd:function(){g.point=E,g.lineStart=y,g.lineEnd=b,d=Uk(d);var x=$1(h,o);d.length?(B||(n.polygonStart(),B=!0),ky(d,ylA,x,j,n)):x&&(B||(n.polygonStart(),B=!0),n.lineStart(),j(null,null,1,n),n.lineEnd()),B&&(n.polygonEnd(),B=!1),d=h=null},sphere:function(){n.polygonStart(),n.lineStart(),j(null,null,1,n),n.lineEnd(),n.polygonEnd()}};function E(x,S){var F=r(x,S);t(x=F[0],S=F[1])&&n.point(x,S)}function m(x,S){var F=r(x,S);i.point(F[0],F[1])}function y(){g.point=m,i.lineStart()}function b(){g.point=E,i.lineEnd()}function v(x,S){k.push([x,S]);var F=r(x,S);c.point(F[0],F[1])}function _(){c.lineStart(),k=[]}function w(){v(k[0][0],k[0][1]),c.lineEnd();var x=c.clean(),S=l.result(),F,D=S.length,L,z,T;if(k.pop(),h.push(k),k=null,!!D){if(x&1){if(z=S[0],(L=z.length-1)>0){for(B||(n.polygonStart(),B=!0),n.lineStart(),F=0;F1&&x&2&&S.push(S.pop().concat(S.shift())),d.push(S.filter(xlA))}}return g}}function xlA(t){return t.length>1}function ylA(t,A){return((t=t.x)[0]<0?t[1]-Ar-xt:Ar-t[1])-((A=A.x)[0]<0?A[1]-Ar-xt:Ar-A[1])}var v1=yy(function(){return!0},vlA,qlA,[-Kt,-Ar]);function vlA(t){var A=NaN,j=NaN,e=NaN,r;return{lineStart:function(){t.lineStart(),r=1},point:function(n,i){var o=n>0?Kt:-Kt,l=ij(n-A);ij(l-Kt)0?Ar:-Ar),t.point(e,j),t.lineEnd(),t.lineStart(),t.point(o,j),t.point(n,j),r=0):e!==o&&l>=Kt&&(ij(A-e)xt?qo((kt(A)*(n=pt(e))*kt(j)-kt(e)*(r=pt(A))*kt(t))/(r*n*i)):(A+e)/2}function qlA(t,A,j,e){var r;if(t==null)r=j*Ar,e.point(-Kt,r),e.point(0,r),e.point(Kt,r),e.point(Kt,0),e.point(Kt,-r),e.point(0,-r),e.point(-Kt,-r),e.point(-Kt,0),e.point(-Kt,r);else if(ij(t[0]-A[0])>xt){var n=t[0]0,r=ij(j)>xt;function n(B,h,d,k){HD(k,t,A,d,B,h)}function i(B,h){return pt(B)*pt(h)>j}function o(B){var h,d,k,g,E;return{lineStart:function(){g=k=!1,E=1},point:function(m,y){var b=[m,y],v,_=i(m,y),w=e?_?0:c(m,y):_?c(m+(m<0?Kt:-Kt),y):0;if(!h&&(g=k=_)&&B.lineStart(),_!==k&&(v=l(h,b),(!v||lf(h,v)||lf(b,v))&&(b[0]+=xt,b[1]+=xt,_=i(b[0],b[1]))),_!==k)E=0,_?(B.lineStart(),v=l(b,h),B.point(v[0],v[1])):(v=l(h,b),B.point(v[0],v[1]),B.lineEnd()),h=v;else if(r&&h&&e^_){var x;!(w&d)&&(x=l(b,h,!0))&&(E=0,e?(B.lineStart(),B.point(x[0][0],x[0][1]),B.point(x[1][0],x[1][1]),B.lineEnd()):(B.point(x[1][0],x[1][1]),B.lineEnd(),B.lineStart(),B.point(x[0][0],x[0][1])))}_&&(!h||!lf(h,b))&&B.point(b[0],b[1]),h=b,k=_,d=w},lineEnd:function(){k&&B.lineEnd(),h=null},clean:function(){return E|(g&&k)<<1}}}function l(B,h,d){var k=Go(B),g=Go(h),E=[1,0,0],m=Hc(k,g),y=Xk(m,m),b=m[0],v=y-b*b;if(!v)return!d&&B;var _=j*y/v,w=-j*b/v,x=Hc(E,m),S=zk(E,_),F=zk(m,w);fy(S,F);var D=x,L=Xk(S,D),z=Xk(D,D),T=L*L-z*(Xk(S,S)-1);if(!(T<0)){var W=ze(T),G=zk(D,(-L-W)/z);if(fy(G,S),G=sf(G),!d)return G;var jA=B[0],pA=h[0],dA=B[1],$A=h[1],_A;pA0^G[1]<(ij(G[0]-jA)Kt^(jA<=G[0]&&G[0]<=pA)){var Ct=zk(D,(-L+W)/z);return fy(Ct,S),[G,sf(Ct)]}}}function c(B,h){var d=e?t:Kt-t,k=0;return B<-d?k|=1:B>d&&(k|=2),h<-d?k|=4:h>d&&(k|=8),k}return yy(i,o,n,e?[0,-t]:[-Kt,t-Kt])}function Yk(t){return function(A){var j=new _1;for(var e in t)j[e]=t[e];return j.stream=A,j}}function _1(){}_1.prototype={constructor:_1,point:function(t,A){this.stream.point(t,A)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function Jk(t,A,j){var e=A[1][0]-A[0][0],r=A[1][1]-A[0][1],n=t.clipExtent&&t.clipExtent();t.scale(150).translate([0,0]),n!=null&&t.clipExtent(null),tl(j,t.stream(xy));var i=xy.result(),o=Math.min(e/(i[1][0]-i[0][0]),r/(i[1][1]-i[0][1])),l=+A[0][0]+(e-o*(i[1][0]+i[0][0]))/2,c=+A[0][1]+(r-o*(i[1][1]+i[0][1]))/2;return n!=null&&t.clipExtent(n),t.scale(o*150).translate([l,c])}function vy(t,A,j){return Jk(t,[[0,0],A],j)}var WD=16,GlA=pt(30*se);function q1(t,A){return+A?wlA(t,A):blA(t)}function blA(t){return Yk({point:function(A,j){A=t(A,j),this.stream.point(A[0],A[1])}})}function wlA(t,A){function j(e,r,n,i,o,l,c,B,h,d,k,g,E,m){var y=c-e,b=B-r,v=y*y+b*b;if(v>4*A&&E--){var _=i+d,w=o+k,x=l+g,S=ze(_*_+w*w+x*x),F=tr(x/=S),D=ij(ij(x)-1)A||ij((y*W+b*G)/v-.5)>.3||i*d+o*k+l*g2?G[2]%360*se:0,T()):[c*Ln,B*Ln,h*Ln]},D.precision=function(G){return arguments.length?(x=q1(z,w=G*G),W()):ze(w)},D.fitExtent=function(G,jA){return Jk(D,G,jA)},D.fitSize=function(G,jA){return vy(D,G,jA)};function T(){k=hy(d=k1(c,B,h),A);var G=A(o,l);return n=e-G[0]*j,i=r+G[1]*j,W()}function W(){return S=F=null,D}return function(){return A=t.apply(this,arguments),D.invert=A.invert&&L,T()}}function _y(t){return function(A,j){var e=pt(A),r=pt(j),n=t(e*r);return[n*r*kt(A),n*kt(j)]}}function ys(t){return function(A,j){var e=ze(A*A+j*j),r=t(e),n=kt(r),i=pt(r);return[xr(A*n,e*i),tr(e&&j*n/e)]}}var AN=_y(function(t){return ze(2/(1+t))});AN.invert=ys(function(t){return 2*tr(t/2)});var b1=_y(function(t){return(t=uy(t))&&t/kt(t)});b1.invert=ys(function(t){return t});function w1(){return bo(b1).scale(79.4188).clipAngle(180-.001)}function F1(t,A){return[t,Nk(Kk((Ar+A)/2))]}F1.invert=function(t,A){return[t,2*qo(cy(A))-Ar]};function qy(t,A){return[t,A]}qy.invert=qy;function tN(t,A){var j=pt(A),e=pt(t)*j;return[j*kt(t)/e,kt(A)/e]}tN.invert=ys(qo);function jN(t,A){var j=A*A,e=j*j;return[t*(.8707-.131979*j+e*(-.013791+e*(.003971*j-.001529*e))),A*(1.007226+j*(.015085+e*(-.044475+.028874*j-.005916*e)))]}jN.invert=function(t,A){var j=A,e=25,r;do{var n=j*j,i=n*n;j-=r=(j*(1.007226+n*(.015085+i*(-.044475+.028874*n-.005916*i)))-A)/(1.007226+n*(.015085*3+i*(-.044475*7+.028874*9*n-.005916*11*i)))}while(ij(r)>xt&&--e>0);return[t/(.8707+(n=j*j)*(-.131979+n*(-.013791+n*n*n*(.003971-.001529*n)))),j]};function eN(t,A){return[pt(A)*kt(t),kt(A)]}eN.invert=ys(tr);function rN(t,A){var j=pt(A),e=1+pt(t)*j;return[j*kt(t)/e,kt(A)/e]}rN.invert=ys(function(t){return 2*qo(t)});function nN(t,A){return[Nk(Kk((Ar+A)/2)),-t]}nN.invert=function(t,A){return[-A,2*qo(cy(t))-Ar]};function MlA(t,A,j){j=j||{};var e=j.units||"kilometers",r=j.steps||8;if(!t)throw new Error("geojson is required");if(typeof j!="object")throw new Error("options must be an object");if(typeof r!="number")throw new Error("steps must be an number");if(A===void 0)throw new Error("radius is required");if(r<=0)throw new Error("steps must be greater than 0");var n=[];switch(t.type){case"GeometryCollection":return h1(t,function(i){var o=Gy(i,A,e,r);o&&n.push(o)}),oy(n);case"FeatureCollection":return f1(t,function(i){var o=Gy(i,A,e,r);o&&f1(o,function(l){l&&n.push(l)})}),oy(n)}return Gy(t,A,e,r)}function Gy(t,A,j,e){var r=t.properties||{},n=t.type==="Feature"?t.geometry:t;if(n.type==="GeometryCollection"){var i=[];return h1(t,function(E){var m=Gy(E,A,j,e);m&&i.push(m)}),oy(i)}var o=OlA(n),l={type:n.type,coordinates:oN(n.coordinates,o)},c=new uf.GeoJSONReader,B=c.read(l),h=FD(PD(A,j),"meters"),d=uf.BufferOp.bufferOp(B,h,e),k=new uf.GeoJSONWriter;if(d=k.write(d),!iN(d.coordinates)){var g={type:d.type,coordinates:sN(d.coordinates,o)};return B1(g,r)}}function iN(t){return Array.isArray(t[0])?iN(t[0]):isNaN(t[0])}function oN(t,A){return typeof t[0]!="object"?A(t):t.map(function(j){return oN(j,A)})}function sN(t,A){return typeof t[0]!="object"?A.invert(t):t.map(function(j){return sN(j,A)})}function OlA(t){var A=Al(t).geometry.coordinates,j=[-A[0],-A[1]];return w1().rotate(j).scale(Dr)}var by=MlA;var uN=Qs(wy(),1);var Hn=63710088e-1,Ztt={centimeters:Hn*100,centimetres:Hn*100,degrees:Hn/111325,feet:Hn*3.28084,inches:Hn*39.37,kilometers:Hn/1e3,kilometres:Hn/1e3,meters:Hn,metres:Hn,miles:Hn/1609.344,millimeters:Hn*1e3,millimetres:Hn*1e3,nauticalmiles:Hn/1852,radians:1,yards:Hn*1.0936},Ajt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Hn,yards:1.0936133};function aN(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function lN(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function RlA(t,A,j){j===void 0&&(j={});var e=O1(t),r=O1(A),n=Zk(r[1]-e[1]),i=Zk(r[0]-e[0]),o=Zk(e[1]),l=Zk(r[1]),c=Math.pow(Math.sin(n/2),2)+Math.pow(Math.sin(i/2),2)*Math.cos(o)*Math.cos(l);return BN(2*Math.atan2(Math.sqrt(c),Math.sqrt(1-c)),j.units)}var yt=RlA;var S1=Qs(hN(),1);var Kn=63710088e-1,DlA={centimeters:Kn*100,centimetres:Kn*100,degrees:Kn/111325,feet:Kn*3.28084,inches:Kn*39.37,kilometers:Kn/1e3,kilometres:Kn/1e3,meters:Kn,metres:Kn,miles:Kn/1609.344,millimeters:Kn*1e3,millimetres:Kn*1e3,nauticalmiles:Kn/1852,radians:1,yards:Kn*1.0936},Ijt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Kn,yards:1.0936133};function NlA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function dN(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!R1(t[0])||!R1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return NlA(e,A,j)}function pN(t,A){A===void 0&&(A="kilometers");var j=DlA[A];if(!j)throw new Error(A+" units is invalid");return t/j}function L1(t){var A=t%(2*Math.PI);return A*180/Math.PI}function Py(t){var A=t%360;return A*Math.PI/180}function R1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function kN(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function yr(t,A,j,e){e===void 0&&(e={});var r=kN(t),n=Py(r[0]),i=Py(r[1]),o=Py(j),l=pN(A,e.units),c=Math.asin(Math.sin(i)*Math.cos(l)+Math.cos(i)*Math.sin(l)*Math.cos(o)),B=n+Math.atan2(Math.sin(o)*Math.sin(l)*Math.cos(i),Math.cos(l)-Math.sin(i)*Math.sin(c)),h=L1(B),d=L1(c);return dN([h,d],e.properties)}var Xn=63710088e-1,Cjt={centimeters:Xn*100,centimetres:Xn*100,degrees:Xn/111325,feet:Xn*3.28084,inches:Xn*39.37,kilometers:Xn/1e3,kilometres:Xn/1e3,meters:Xn,metres:Xn,miles:Xn/1609.344,millimeters:Xn*1e3,millimetres:Xn*1e3,nauticalmiles:Xn/1852,radians:1,yards:Xn*1.0936},Hjt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Xn,yards:1.0936133};function gN(t){var A=t%(2*Math.PI);return A*180/Math.PI}function t0(t){var A=t%360;return A*Math.PI/180}function C1(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function Fj(t,A,j){if(j===void 0&&(j={}),j.final===!0)return KlA(t,A);var e=C1(t),r=C1(A),n=t0(e[0]),i=t0(r[0]),o=t0(e[1]),l=t0(r[1]),c=Math.sin(i-n)*Math.cos(l),B=Math.cos(o)*Math.sin(l)-Math.sin(o)*Math.cos(l)*Math.cos(i-n);return gN(Math.atan2(c,B))}function KlA(t,A){var j=Fj(A,t);return j=(j+180)%360,j}var zn=63710088e-1,mN={centimeters:zn*100,centimetres:zn*100,degrees:zn/111325,feet:zn*3.28084,inches:zn*39.37,kilometers:zn/1e3,kilometres:zn/1e3,meters:zn,metres:zn,miles:zn/1609.344,millimeters:zn*1e3,millimetres:zn*1e3,nauticalmiles:zn/1852,radians:1,yards:zn*1.0936},Qjt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/zn,yards:1.0936133};function el(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function D1(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!H1(t[0])||!H1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return el(e,A,j)}function Iy(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return el(e,A,j)}function XlA(t,A){A===void 0&&(A="kilometers");var j=mN[A];if(!j)throw new Error(A+" units is invalid");return t*j}function zlA(t,A){A===void 0&&(A="kilometers");var j=mN[A];if(!j)throw new Error(A+" units is invalid");return t/j}function EN(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return XlA(zlA(t,A),j)}function H1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function N1(t,A,j){if(!t)throw new Error("No feature passed");if(!j)throw new Error(".featureOf() requires a name");if(!t||t.type!=="Feature"||!t.geometry)throw new Error("Invalid input to "+j+", Feature with geometry required");if(!t.geometry||t.geometry.type!==A)throw new Error("Invalid input to "+j+": must be a "+A+", given "+t.geometry.type)}function $N(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=Iy([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}var Kr=63710088e-1,yN={centimeters:Kr*100,centimetres:Kr*100,degrees:Kr/111325,feet:Kr*3.28084,inches:Kr*39.37,kilometers:Kr/1e3,kilometres:Kr/1e3,meters:Kr,metres:Kr,miles:Kr/1609.344,millimeters:Kr*1e3,millimetres:Kr*1e3,nauticalmiles:Kr/1852,radians:1,yards:Kr*1.0936},jet={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Kr,yards:1.0936133};function QlA(t,A){A===void 0&&(A="kilometers");var j=yN[A];if(!j)throw new Error(A+" units is invalid");return t*j}function WlA(t,A){A===void 0&&(A="kilometers");var j=yN[A];if(!j)throw new Error(A+" units is invalid");return t/j}function vN(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return QlA(WlA(t,A),j)}function K1(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function YlA(t,A,j){j===void 0&&(j={});var e=K1(t),r=K1(A);r[0]+=r[0]-e[0]>180?-360:e[0]-r[0]>180?360:0;var n=JlA(e,r),i=vN(n,"meters",j.units);return i}function JlA(t,A,j){j=j===void 0?Kr:Number(j);var e=j,r=t[1]*Math.PI/180,n=A[1]*Math.PI/180,i=n-r,o=Math.abs(A[0]-t[0])*Math.PI/180;o>Math.PI&&(o-=2*Math.PI);var l=Math.log(Math.tan(n/2+Math.PI/4)/Math.tan(r/2+Math.PI/4)),c=Math.abs(l)>1e-11?i/l:Math.cos(r),B=Math.sqrt(i*i+c*c*o*o),h=B*e;return h}var rl=YlA;function ZlA(t,A,j){if(j===void 0&&(j={}),j.method||(j.method="geodesic"),j.units||(j.units="kilometers"),!t)throw new Error("pt is required");if(Array.isArray(t)?t=D1(t):t.type==="Point"?t=el(t):N1(t,"Point","point"),!A)throw new Error("line is required");Array.isArray(A)?A=Iy(A):A.type==="LineString"?A=el(A):N1(A,"LineString","line");var e=1/0,r=t.geometry.coordinates;return xN(A,function(n){var i=n.geometry.coordinates[0],o=n.geometry.coordinates[1],l=AcA(r,i,o,j);lj?j:t}function tcA(t){return Math.log(t)*Math.LOG2E}var My=Math.log2||tcA;function wo(t,A){if(!t)throw new Error(A||"@math.gl/web-mercator: assertion failed.")}var Fo=Math.PI,GN=Fo/4,vs=Fo/180,U1=180/Fo,e0=512,qN=4003e4,df=85.051129,V1=1.5;function Oy(t){return Math.pow(2,t)}function _s(t){let[A,j]=t;wo(Number.isFinite(A)),wo(Number.isFinite(j)&&j>=-90&&j<=90,"invalid latitude");let e=A*vs,r=j*vs,n=e0*(e+Fo)/(2*Fo),i=e0*(Fo+Math.log(Math.tan(GN+r*.5)))/(2*Fo);return[n,i]}function Po(t){let[A,j]=t,e=A/e0*(2*Fo)-Fo,r=2*(Math.atan(Math.exp(j/e0*(2*Fo)-Fo))-GN);return[e*U1,r*U1]}function Q1(t){let{latitude:A,longitude:j,highPrecision:e=!1}=t;wo(Number.isFinite(A)&&Number.isFinite(j));let r=e0,n=Math.cos(A*vs),i=r/360,o=i/n,l=r/qN/n,c={unitsPerMeter:[l,l,l],metersPerUnit:[1/l,1/l,1/l],unitsPerDegree:[i,o,l],degreesPerUnit:[1/i,1/o,1/l]};if(e){let B=vs*Math.tan(A*vs)/n,h=i*B/2,d=r/qN*B,k=d/o*l;c.unitsPerDegree2=[0,h,d],c.unitsPerMeter2=[k,0,k]}return c}function W1(t){let{height:A,pitch:j,bearing:e,altitude:r,scale:n,center:i}=t,o=ff();Ck(o,o,[0,0,-r]),dD(o,o,-j*vs),pD(o,o,e*vs);let l=n/A;return jy(o,o,[l,l,l]),i&&Ck(o,o,uD([],i)),o}function bN(t){let{width:A,height:j,altitude:e,pitch:r=0,offset:n,center:i,scale:o,nearZMultiplier:l=1,farZMultiplier:c=1}=t,{fovy:B=hf(V1)}=t;e!==void 0&&(B=hf(e));let h=B*vs,d=r*vs,k=Ty(B),g=k;i&&(g+=i[2]*o/Math.cos(d)/j);let E=h*(.5+(n?n[1]:0)/j),m=Math.sin(E)*g/Math.sin(j0(Math.PI/2-d-E,.01,Math.PI-.01)),y=Math.sin(d)*m+g,b=g*10,v=Math.min(y*c,b);return{fov:h,aspect:A/j,focalDistance:k,near:l,far:v}}function Y1(t){let{fov:A,aspect:j,near:e,far:r}=bN(t);return kD([],A,j,e,r)}function hf(t){return 2*Math.atan(.5/t)*U1}function Ty(t){return .5/Math.tan(.5*t*vs)}function J1(t,A){let[j,e,r=0]=t;return wo(Number.isFinite(j)&&Number.isFinite(e)&&Number.isFinite(r)),nl(A,[j,e,r,1])}function Sy(t,A,j=0){let[e,r,n]=t;if(wo(Number.isFinite(e)&&Number.isFinite(r),"invalid pixel coordinate"),Number.isFinite(n))return nl(A,[e,r,n,1]);let i=nl(A,[e,r,0,1]),o=nl(A,[e,r,1,1]),l=i[2],c=o[2],B=l===c?0:((j||0)-l)/(c-l);return Ay([],i,o,B)}function Ry(t){let{width:A,height:j,bounds:e,minExtent:r=0,maxZoom:n=24,offset:i=[0,0]}=t,[[o,l],[c,B]]=e,h=jcA(t.padding),d=_s([o,j0(B,-df,df)]),k=_s([c,j0(l,-df,df)]),g=[Math.max(Math.abs(k[0]-d[0]),r),Math.max(Math.abs(k[1]-d[1]),r)],E=[A-h.left-h.right-Math.abs(i[0])*2,j-h.top-h.bottom-Math.abs(i[1])*2];wo(E[0]>0&&E[1]>0);let m=E[0]/g[0],y=E[1]/g[1],b=(h.right-h.left)/2/m,v=(h.top-h.bottom)/2/y,_=[(k[0]+d[0])/2+b,(k[1]+d[1])/2+v],w=Po(_),x=Math.min(n,My(Math.abs(Math.min(m,y))));return wo(Number.isFinite(x)),{longitude:w[0],latitude:w[1],zoom:x}}function jcA(t=0){return typeof t=="number"?{top:t,bottom:t,left:t,right:t}:(wo(Number.isFinite(t.top)&&Number.isFinite(t.bottom)&&Number.isFinite(t.left)&&Number.isFinite(t.right)),t)}var wN=Math.PI/180;function Ly(t,A=0){let{width:j,height:e,unproject:r}=t,n={targetZ:A},i=r([0,e],n),o=r([j,e],n),l,c,B=t.fovy?.5*t.fovy*wN:Math.atan(.5/t.altitude),h=(90-t.pitch)*wN;return B>h-.01?(l=FN(t,0,A),c=FN(t,j,A)):(l=r([0,0],n),c=r([j,0],n)),[i,o,c,l]}function FN(t,A,j){let{pixelUnprojectionMatrix:e}=t,r=nl(e,[A,0,1,1]),n=nl(e,[A,t.height,1,1]),o=(j*t.distanceScales.unitsPerMeter[2]-r[2])/(n[2]-r[2]),l=Ay([],r,n,o),c=Po(l);return c.push(j),c}var Mi=class t{constructor(A={width:1,height:1}){Ae(this,"latitude",void 0),Ae(this,"longitude",void 0),Ae(this,"zoom",void 0),Ae(this,"pitch",void 0),Ae(this,"bearing",void 0),Ae(this,"altitude",void 0),Ae(this,"fovy",void 0),Ae(this,"meterOffset",void 0),Ae(this,"center",void 0),Ae(this,"width",void 0),Ae(this,"height",void 0),Ae(this,"scale",void 0),Ae(this,"distanceScales",void 0),Ae(this,"viewMatrix",void 0),Ae(this,"projectionMatrix",void 0),Ae(this,"viewProjectionMatrix",void 0),Ae(this,"pixelProjectionMatrix",void 0),Ae(this,"pixelUnprojectionMatrix",void 0),Ae(this,"equals",y=>y instanceof t?y.width===this.width&&y.height===this.height&&o1(y.projectionMatrix,this.projectionMatrix)&&o1(y.viewMatrix,this.viewMatrix):!1),Ae(this,"project",(y,b={})=>{let{topLeft:v=!0}=b,_=this.projectPosition(y),w=J1(_,this.pixelProjectionMatrix),[x,S]=w,F=v?S:this.height-S;return y.length===2?[x,F]:[x,F,w[2]]}),Ae(this,"unproject",(y,b={})=>{let{topLeft:v=!0,targetZ:_=void 0}=b,[w,x,S]=y,F=v?x:this.height-x,D=_&&_*this.distanceScales.unitsPerMeter[2],L=Sy([w,F,S],this.pixelUnprojectionMatrix,D),[z,T,W]=this.unprojectPosition(L);return Number.isFinite(S)?[z,T,W]:Number.isFinite(_)?[z,T,_]:[z,T]}),Ae(this,"projectPosition",y=>{let[b,v]=_s(y),_=(y[2]||0)*this.distanceScales.unitsPerMeter[2];return[b,v,_]}),Ae(this,"unprojectPosition",y=>{let[b,v]=Po(y),_=(y[2]||0)*this.distanceScales.metersPerUnit[2];return[b,v,_]});let{width:j,height:e,altitude:r=null,fovy:n=null}=A,{latitude:i=0,longitude:o=0,zoom:l=0,pitch:c=0,bearing:B=0,position:h=null,nearZMultiplier:d=.02,farZMultiplier:k=1.01}=A;j=j||1,e=e||1,n===null&&r===null?(r=V1,n=hf(r)):n===null?n=hf(r):r===null&&(r=Ty(n));let g=Oy(l);r=Math.max(.75,r);let E=Q1({longitude:o,latitude:i}),m=_s([o,i]);m.push(0),h&&cD(m,m,BD([],h,E.unitsPerMeter)),this.projectionMatrix=Y1({width:j,height:e,scale:g,center:m,pitch:c,fovy:n,nearZMultiplier:d,farZMultiplier:k}),this.viewMatrix=W1({height:e,scale:g,center:m,pitch:c,bearing:B,altitude:r}),this.width=j,this.height=e,this.scale=g,this.latitude=i,this.longitude=o,this.zoom=l,this.pitch=c,this.bearing=B,this.altitude=r,this.fovy=n,this.center=m,this.meterOffset=h||[0,0,0],this.distanceScales=E,this._initMatrices(),Object.freeze(this)}_initMatrices(){let{width:A,height:j,projectionMatrix:e,viewMatrix:r}=this,n=ff();ty(n,n,e),ty(n,n,r),this.viewProjectionMatrix=n;let i=ff();jy(i,i,[A/2,-j/2,1]),Ck(i,i,[1,-1,0]),ty(i,i,n);let o=hD(ff(),i);if(!o)throw new Error("Pixel project matrix not invertible");this.pixelProjectionMatrix=i,this.pixelUnprojectionMatrix=o}projectFlat(A){return _s(A)}unprojectFlat(A){return Po(A)}getMapCenterByLngLatPosition({lngLat:A,pos:j}){let e=Sy(j,this.pixelUnprojectionMatrix),r=_s(A),n=n1([],r,lD([],e)),i=n1([],this.center,n);return Po(i)}fitBounds(A,j={}){let{width:e,height:r}=this,{longitude:n,latitude:i,zoom:o}=Ry(Object.assign({width:e,height:r,bounds:A},j));return new t({width:e,height:r,longitude:n,latitude:i,zoom:o})}getBounds(A){let j=this.getBoundingRegion(A),e=Math.min(...j.map(o=>o[0])),r=Math.max(...j.map(o=>o[0])),n=Math.min(...j.map(o=>o[1])),i=Math.max(...j.map(o=>o[1]));return[[e,n],[r,i]]}getBoundingRegion(A={}){return Ly(this,A.z||0)}getLocationAtPoint({lngLat:A,pos:j}){return this.getMapCenterByLngLatPosition({lngLat:A,pos:j})}};function PN(t,A,j){let e=t.indexOf(A);return e<0?t:t.slice(0,e)+j+t.slice(e)}var pf=class extends G6{renderLayers(){let{id:A,getFillColor:j,getStrokeColor:e,getInnerRadius:r,updateTriggers:n}=this.props;return[new mr({...this.props,id:`${A}-full`,data:this.props.data,getLineColor:e,updateTriggers:{...n,getStrokeColor:n.getStrokeColor}}),new mr({...this.props,id:`${A}-inner`,data:this.props.data,getFillColor:j,getRadius:r,pickable:!1,updateTriggers:{...n,getFillColor:n.getFillColor,getRadius:n.getInnerRadius}})]}};I(pf,"layerName","JunctionScatterplotLayer"),I(pf,"defaultProps",{...mr.defaultProps,getFillColor:A=>[0,0,0,255],getStrokeColor:A=>[255,255,255,255],getInnerRadius:A=>1});var Rrt={[Cc.NONE]:{forward:!1,backward:!1},[Cc.FORWARD]:{forward:!0,backward:!1},[Cc.BACKWARD]:{forward:!1,backward:!0},[Cc.BOTH]:{forward:!0,backward:!0}};var SN=Qs(wy(),1);var Un=63710088e-1,Vrt={centimeters:Un*100,centimetres:Un*100,degrees:Un/111325,feet:Un*3.28084,inches:Un*39.37,kilometers:Un/1e3,kilometres:Un/1e3,meters:Un,metres:Un,miles:Un/1609.344,millimeters:Un*1e3,millimetres:Un*1e3,nauticalmiles:Un/1852,radians:1,yards:Un*1.0936},Qrt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Un,yards:1.0936133};function MN(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function ON(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function qs(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function Dy(t){return t.type==="Feature"?t.geometry:t}function r0(t){for(var A=qs(t),j=0,e=1,r,n;e0}function n0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y is required");if(typeof j!="boolean")throw new Error(" must be a boolean");if(typeof e!="boolean")throw new Error(" must be a boolean");e===!1&&(t=Hy(t));var r=[];switch(t.type){case"GeometryCollection":return i0(t,function(n){Ny(n,j)}),t;case"FeatureCollection":return rP(t,function(n){rP(Ny(n,j),function(i){r.push(i)})}),Xa(r)}return Ny(t,j)}function Ny(t,A){var j=t.type==="Feature"?t.geometry.type:t.type;switch(j){case"GeometryCollection":return i0(t,function(e){Ny(e,A)}),t;case"LineString":return QN(qs(t),A),t;case"Polygon":return WN(qs(t),A),t;case"MultiLineString":return qs(t).forEach(function(e){QN(e,A)}),t;case"MultiPolygon":return qs(t).forEach(function(e){WN(e,A)}),t;case"Point":case"MultiPoint":return t}}function QN(t,A){r0(t)===A&&t.reverse()}function WN(t,A){r0(t[0])!==A&&t[0].reverse();for(var j=1;je.project([S,F,D])),[i,o]=e.project(A.geometry.coordinates),l=1/0,c={};n.forEach(([S,F],D)=>{if(D===0)return;let[L,z]=n[D-1],T=z-F,W=S-L,G=L*F-S*z,jA=T*T+W*W,pA=Math.abs(T*i+W*o+G)/Math.sqrt(jA);pA{let i=qs(n),o=qs(A),l,c,B,h,d,k,g;if(i.length>1&&o.length){let m,y;e?(m=i.map(_=>e.project(_)),y=e.project(o)):(m=i,y=o);for(let _=1;_w&&(g=Math.sqrt(Math.min(x,S))),(l==null||l>g)&&(D>w?Sj.properties.editHandleType==="snap-source")}function t3(t){return t&&t.filter(A=>!A.isGuide)}function oP(t){return Io(t).find(({properties:j})=>j.featureIndex>=0&&j.editHandleType==="existing")}function o0(t){return Io(t).find(({properties:j})=>j.featureIndex>=0&&j.editHandleType==="intermediate")}function Io(t){return t&&t.filter(j=>j.isGuide&&j.object.properties.guideType==="editHandle").map(j=>j.object)||[]}function il(t,A,j="existing"){let e=[];switch(t.type){case"Point":e=[{type:"Feature",properties:{guideType:"editHandle",editHandleType:j,positionIndexes:[],featureIndex:A},geometry:{type:"Point",coordinates:t.coordinates}}];break;case"MultiPoint":case"LineString":e=e.concat(nP(t.coordinates,[],A,j));break;case"Polygon":case"MultiLineString":for(let r=0;rs0(j,A)).filter(Boolean)}var Pj=class t{constructor(A){I(this,"featureCollection");this.featureCollection=A}getObject(){return this.featureCollection}replacePosition(A,j,e){let r=this.featureCollection.features[A].geometry,n=r.type==="Polygon"||r.type==="MultiPolygon",i={...r,coordinates:e3(r.coordinates,j,e,n)};return this.replaceGeometry(A,i)}removePosition(A,j){let e=this.featureCollection.features[A].geometry;if(e.type==="Point")throw Error("Can't remove a position from a Point or there'd be nothing left");if(e.type==="MultiPoint"&&e.coordinates.length<2)throw Error("Can't remove the last point of a MultiPoint or there'd be nothing left");if(e.type==="LineString"&&e.coordinates.length<3)throw Error("Can't remove position. LineString must have at least two positions");if(e.type==="Polygon"&&e.coordinates[0].length<5&&Array.isArray(j)&&j[0]===0)throw Error("Can't remove position. Polygon's outer ring must have at least four positions");if(e.type==="MultiLineString"&&e.coordinates.length===1&&e.coordinates[0].length<3)throw Error("Can't remove position. MultiLineString must have at least two positions");if(e.type==="MultiPolygon"&&e.coordinates.length===1&&e.coordinates[0][0].length<5&&Array.isArray(j)&&j[0]===0&&j[1]===0)throw Error("Can't remove position. MultiPolygon's outer ring must have at least four positions");let r=e.type==="Polygon"||e.type==="MultiPolygon",n={...e,coordinates:r3(e.coordinates,j,r)};return BcA(n),this.replaceGeometry(A,n)}addPosition(A,j,e){let r=this.featureCollection.features[A].geometry;if(r.type==="Point")throw new Error("Unable to add a position to a Point feature");let n=r.type==="Polygon"||r.type==="MultiPolygon",i={...r,coordinates:n3(r.coordinates,j,e,n)};return this.replaceGeometry(A,i)}replaceGeometry(A,j){let e={...this.featureCollection.features[A],geometry:j},r={...this.featureCollection,features:[...this.featureCollection.features.slice(0,A),e,...this.featureCollection.features.slice(A+1)]};return new t(r)}addFeature(A){return this.addFeatures([A])}addFeatures(A){let j={...this.featureCollection,features:[...this.featureCollection.features,...A]};return new t(j)}deleteFeature(A){return this.deleteFeatures([A])}deleteFeatures(A){let j=[...this.featureCollection.features];A.sort();for(let r=A.length-1;r>=0;r--){let n=A[r];n>=0&&nj[r])}}getClickSequence(){return this._clickSequence}addClickSequence({mapCoords:A}){this._clickSequence.push(A)}resetClickSequence(){this._clickSequence=[]}getTentativeGuide(A){return this.getGuides(A).features.find(e=>e.properties&&e.properties.guideType==="tentative")}isSelectionPicked(A,j){if(!A.length)return!1;let e=t3(A).map(({index:i})=>i),r=Io(A).map(({properties:i})=>i.featureIndex),n=new Set([...e,...r]);return j.selectedIndexes.some(i=>n.has(i))}rewindPolygon(A){let{geometry:j}=A;return j.type==="Polygon"||j.type==="MultiPolygon"?YN(A):A}getAddFeatureAction(A,j){let e=A,r=e.type==="Feature"?e:{type:"Feature",properties:{},geometry:e},n=this.rewindPolygon(r),i=new Pj(j).addFeature(n).getObject();return{updatedData:i,editType:"addFeature",editContext:{featureIndexes:[i.features.length-1]}}}getAddManyFeaturesAction({features:A},j){let e=new Pj(j),r=e.getObject().features.length,n=[];for(let i of A){let{properties:o,geometry:l}=i,c=l;e=e.addFeature({type:"Feature",properties:o,geometry:c}),n.push(r+n.length)}return{updatedData:e.getObject(),editType:"addFeature",editContext:{featureIndexes:n}}}getAddFeatureOrBooleanPolygonAction(A,j){let e=A,r=this.getSelectedFeature(j),{modeConfig:n}=j;if(n&&n.booleanOperation){if(!r||r.geometry.type!=="Polygon"&&r.geometry.type!=="MultiPolygon")return console.warn("booleanOperation only supported for single Polygon or MultiPolygon selection"),null;let i=e.type==="Feature"?e:{type:"Feature",geometry:e},o;if(n.booleanOperation==="union")o=RN(r,i);else if(n.booleanOperation==="difference")o=Bf(r,i);else if(n.booleanOperation==="intersection")o=jP(r,i);else return console.warn(`Invalid booleanOperation ${n.booleanOperation}`),null;if(!o)return console.warn("Canceling edit. Boolean operation erased entire polygon."),null;let l=j.selectedIndexes[0];return{updatedData:new Pj(j.data).replaceGeometry(l,o.geometry).getObject(),editType:"unionGeometry",editContext:{featureIndexes:[l]}}}return this.getAddFeatureAction(A,j.data)}createTentativeFeature(A){return null}handleClick(A,j){}handlePointerMove(A,j){let e=this.createTentativeFeature(j);e&&j.onEdit({updatedData:j.data,editType:"updateTentativeFeature",editContext:{feature:e}})}handleStartDragging(A,j){}handleStopDragging(A,j){}handleDragging(A,j){}handleKeyUp(A,j){A.key==="Escape"&&(this.resetClickSequence(),j.onEdit({updatedData:j.data,editType:"cancelFeature",editContext:{}}))}};function ol(t,A){return[(t[0]+A[0])/2,(t[1]+A[1])/2]}var Xr=class extends Zt{};var Qn=63710088e-1,Xnt={centimeters:Qn*100,centimetres:Qn*100,degrees:Qn/111325,feet:Qn*3.28084,inches:Qn*39.37,kilometers:Qn/1e3,kilometres:Qn/1e3,meters:Qn,metres:Qn,miles:Qn/1609.344,millimeters:Qn*1e3,millimetres:Qn*1e3,nauticalmiles:Qn/1852,radians:1,yards:Qn*1.0936},znt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Qn,yards:1.0936133};function o3(t){var A=t%(2*Math.PI);return A*180/Math.PI}function zy(t){var A=t%360;return A*Math.PI/180}function a0(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function gcA(t,A,j){j===void 0&&(j={});var e;j.final?e=s3(a0(A),a0(t)):e=s3(a0(t),a0(A));var r=e>180?-(360-e):e;return r}function s3(t,A){var j=zy(t[1]),e=zy(A[1]),r=zy(A[0]-t[0]);r>Math.PI&&(r-=2*Math.PI),r<-Math.PI&&(r+=2*Math.PI);var n=Math.log(Math.tan(e/2+Math.PI/4)/Math.tan(j/2+Math.PI/4)),i=Math.atan2(r,n);return(o3(i)+360)%360}var kf=gcA;var zr=63710088e-1,a3={centimeters:zr*100,centimetres:zr*100,degrees:zr/111325,feet:zr*3.28084,inches:zr*39.37,kilometers:zr/1e3,kilometres:zr/1e3,meters:zr,metres:zr,miles:zr/1609.344,millimeters:zr*1e3,millimetres:zr*1e3,nauticalmiles:zr/1852,radians:1,yards:zr*1.0936},A6t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/zr,yards:1.0936133};function mcA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function l3(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!sP(t[0])||!sP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return mcA(e,A,j)}function EcA(t,A){A===void 0&&(A="kilometers");var j=a3[A];if(!j)throw new Error(A+" units is invalid");return t*j}function $cA(t,A){A===void 0&&(A="kilometers");var j=a3[A];if(!j)throw new Error(A+" units is invalid");return t/j}function aP(t){var A=t%360;return A*Math.PI/180}function c3(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return EcA($cA(t,A),j)}function sP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function u3(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function xcA(t,A,j,e){e===void 0&&(e={});var r=A<0,n=c3(Math.abs(A),e.units,"meters");r&&(n=-Math.abs(n));var i=u3(t),o=ycA(i,n,j);return o[0]+=o[0]-i[0]>180?-360:i[0]-o[0]>180?360:0,l3(o,e.properties)}function ycA(t,A,j,e){e=e===void 0?zr:Number(e);var r=A/e,n=t[0]*Math.PI/180,i=aP(t[1]),o=aP(j),l=r*Math.cos(o),c=i+l;Math.abs(c)>Math.PI/2&&(c=c>0?Math.PI-c:-Math.PI-c);var B=Math.log(Math.tan(c/2+Math.PI/4)/Math.tan(i/2+Math.PI/4)),h=Math.abs(B)>1e-11?l/B:Math.cos(i),d=r*Math.sin(o)/h,k=n+d;return[(k*180/Math.PI+540)%360-180,c*180/Math.PI]}var Gs=xcA;function B3(t,A,j){let e=Al(t),r=Gs(e,A,j),n=s0(t.geometry.coordinates,i=>{let o=rl(e.geometry.coordinates,i),l=kf(e.geometry.coordinates,i);return Gs(r.geometry.coordinates,o,l).geometry.coordinates});return t.geometry.coordinates=n,t}var bs=class extends Zt{constructor(){super(...arguments);I(this,"_geometryBeforeTranslate");I(this,"_isTranslatable")}handleDragging(j,e){if(this._isTranslatable){if(this._geometryBeforeTranslate){let r=this.getTranslateAction(j.pointerDownMapCoords,j.mapCoords,"translating",e);r&&e.onEdit(r)}j.cancelPan()}}handlePointerMove(j,e){this._isTranslatable=this.isSelectionPicked(j.pointerDownPicks||j.picks,e),this.updateCursor(e)}handleStartDragging(j,e){this._isTranslatable&&(this._geometryBeforeTranslate=this.getSelectedFeaturesAsFeatureCollection(e))}handleStopDragging(j,e){if(this._geometryBeforeTranslate){let r=this.getTranslateAction(j.pointerDownMapCoords,j.mapCoords,"translated",e);r&&e.onEdit(r),this._geometryBeforeTranslate=null}}updateCursor(j){this._isTranslatable?j.onUpdateCursor("move"):j.onUpdateCursor(null)}getTranslateAction(j,e,r,n){if(!this._geometryBeforeTranslate)return null;let i=new Pj(n.data),o=n.selectedIndexes,{viewport:l,screenSpace:c}=n.modeConfig||{};if(l&&c){let B=l.project?l:new Mi(l),h=B.project(j),d=B.project(e),k=d[0]-h[0],g=d[1]-h[1];for(let E=0;E{let _=B.project(v);return _?(_[0]+=k,_[1]+=g,B.unproject(_)):null}),i=i.replaceGeometry(m,{type:y.geometry.type,coordinates:b}))}}else{let B=Vt(j),h=Vt(e),d=yt(B,h),k=Fj(B,h),g=this._geometryBeforeTranslate.features.map(E=>B3(Hy(E),d,k));for(let E=0;E!B.isGuide);if(c&&!c.object.geometry.type.includes("Point")&&!(A.modeConfig?.lockRectangles&&c.object.properties.shape==="Rectangle")&&A.selectedIndexes.includes(c.index)){let B=null,h=[],d=Vt(o);if(Ky(c.object.geometry.coordinates,[],(k,g)=>{let E=$r(k),m=this.getNearestPoint(E,d,A.modeConfig&&A.modeConfig.viewport);(!B||m.properties.distn.length>2)){if(e)return iP(A,j,e);console.log("Editing 3D point but modeConfig.viewport not provided. Falling back to 2D logic.")}return ZN(A,j,e)}handleClick(A,j){let e=oP(A.picks),r=o0(A.picks);if(e){let{featureIndex:n,positionIndexes:i}=e.properties,o;try{o=new Pj(j.data).removePosition(n,i).getObject()}catch{}o&&j.onEdit({updatedData:o,editType:"removePosition",editContext:{featureIndexes:[n],positionIndexes:i,position:e.geometry.coordinates}})}else if(r){let{featureIndex:n,positionIndexes:i}=r.properties,o=j.data.features[n];if(!(j.modeConfig?.lockRectangles&&o?.properties.shape==="Rectangle")){let c=new Pj(j.data).addPosition(n,i,r.geometry.coordinates).getObject();c&&j.onEdit({updatedData:c,editType:"addPosition",editContext:{featureIndexes:[n],positionIndexes:i,position:r.geometry.coordinates}})}}}handleDragging(A,j){let e=te(A.pointerDownPicks);e&&(A.cancelPan(),this._dragEditHandle("movePosition",j,e,A))}_dragEditHandle(A,j,e,r){let n=e.properties,i=j.data.features[n.featureIndex],o;if(j.modeConfig?.lockRectangles&&i.properties.shape==="Rectangle"){let l=j3(i,n.positionIndexes[1],r.mapCoords);o=new Pj(j.data).replaceGeometry(n.featureIndex,{coordinates:l,type:"Polygon"}).getObject()}else o=new Pj(j.data).replacePosition(n.featureIndex,n.positionIndexes,r.mapCoords).getObject();j.onEdit({updatedData:o,editType:A,editContext:{featureIndexes:[n.featureIndex],positionIndexes:n.positionIndexes,position:r.mapCoords}})}handlePointerMove(A,j){let e=this.getCursor(A);j.onUpdateCursor(e)}handleStartDragging(A,j){let e=j.selectedIndexes,r=o0(A.picks);if(e.length&&r){let n=r.properties,i=new Pj(j.data).addPosition(n.featureIndex,n.positionIndexes,A.mapCoords).getObject();j.onEdit({updatedData:i,editType:"addPosition",editContext:{featureIndexes:[n.featureIndex],positionIndexes:n.positionIndexes,position:A.mapCoords}})}}handleStopDragging(A,j){let e=j.selectedIndexes,r=te(A.picks);e.length&&r&&this._dragEditHandle("finishMovePosition",j,r,A)}getCursor(A){let j=A&&A.picks||[];return Io(j).length?"cell":null}};var Wn=63710088e-1,b6t={centimeters:Wn*100,centimetres:Wn*100,degrees:Wn/111325,feet:Wn*3.28084,inches:Wn*39.37,kilometers:Wn/1e3,kilometres:Wn/1e3,meters:Wn,metres:Wn,miles:Wn/1609.344,millimeters:Wn*1e3,millimetres:Wn*1e3,nauticalmiles:Wn/1852,radians:1,yards:Wn*1.0936},w6t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Wn,yards:1.0936133};function h3(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function lP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!f3(t[0])||!f3(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return h3(e,A,j)}function f3(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function cP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y1?g3(t,A):p3(t[0],A)}function GcA(t){if(!t)throw new Error("geojson is required");switch(t.type){case"Feature":return E3(t);case"FeatureCollection":return bcA(t);case"Point":case"LineString":case"Polygon":case"MultiPoint":case"MultiLineString":case"MultiPolygon":case"GeometryCollection":return uP(t);default:throw new Error("unknown GeoJSON type")}}function E3(t){var A={type:"Feature"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"properties":case"geometry":return;default:A[j]=t[j]}}),A.properties=$3(t.properties),A.geometry=uP(t.geometry),A}function $3(t){var A={};return t&&Object.keys(t).forEach(function(j){var e=t[j];typeof e=="object"?e===null?A[j]=null:Array.isArray(e)?A[j]=e.map(function(r){return r}):A[j]=$3(e):A[j]=e}),A}function bcA(t){var A={type:"FeatureCollection"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"features":return;default:A[j]=t[j]}}),A.features=t.features.map(function(j){return E3(j)}),A}function uP(t){var A={type:t.type};return t.bbox&&(A.bbox=t.bbox),t.type==="GeometryCollection"?(A.geometries=t.geometries.map(function(j){return uP(j)}),A):(A.coordinates=x3(t.coordinates),A)}function x3(t){var A=t;return typeof A[0]!="object"?A.slice():A.map(function(j){return x3(j)})}var y3=GcA;var Jn=63710088e-1,Q6t={centimeters:Jn*100,centimetres:Jn*100,degrees:Jn/111325,feet:Jn*3.28084,inches:Jn*39.37,kilometers:Jn/1e3,kilometres:Jn/1e3,meters:Jn,metres:Jn,miles:Jn/1609.344,millimeters:Jn*1e3,millimetres:Jn*1e3,nauticalmiles:Jn/1852,radians:1,yards:Jn*1.0936},W6t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Jn,yards:1.0936133};function v3(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function mf(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!BP(t[0])||!BP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return v3(e,A,j)}function BP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function fP(t){return!!t&&t.constructor===Object}function hP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function G3(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function b3(t,A){return t.type==="FeatureCollection"?"FeatureCollection":t.type==="GeometryCollection"?"GeometryCollection":t.type==="Feature"&&t.geometry!==null?t.geometry.type:t.type}function wcA(t,A,j){if(j=j||{},!fP(j))throw new Error("options is invalid");var e=j.origin,r=j.mutate;if(!t)throw new Error("geojson required");if(typeof A!="number"||A===0)throw new Error("invalid factor");var n=Array.isArray(e)||typeof e=="object";return r!==!0&&(t=y3(t)),t.type==="FeatureCollection"&&!n?(_3(t,function(i,o){t.features[o]=w3(i,A,e)}),t):w3(t,A,e)}function w3(t,A,j){var e=b3(t)==="Point";return j=FcA(t,j),A===1||e||hP(t,function(r){var n=rl(j,r),i=kf(j,r),o=n*A,l=G3(Gs(j,o,i));r[0]=l[0],r[1]=l[1],r.length===3&&(r[2]*=A)}),t}function FcA(t,A){if(A==null&&(A="centroid"),Array.isArray(A)||typeof A=="object")return q3(A);var j=t.bbox?t.bbox:za(t),e=j[0],r=j[1],n=j[2],i=j[3];switch(A){case"sw":case"southwest":case"westsouth":case"bottomleft":return mf([e,r]);case"se":case"southeast":case"eastsouth":case"bottomright":return mf([n,r]);case"nw":case"northwest":case"westnorth":case"topleft":return mf([e,i]);case"ne":case"northeast":case"eastnorth":case"topright":return mf([n,i]);case"center":return Al(t);case void 0:case null:case"centroid":return ws(t);default:throw new Error("invalid origin")}}var F3=wcA;var Va=class extends Zt{constructor(){super(...arguments);I(this,"_geometryBeingScaled");I(this,"_selectedEditHandle");I(this,"_cornerGuidePoints",[]);I(this,"_cursor");I(this,"_isScaling",!1);I(this,"_isSinglePointGeometrySelected",j=>{let{features:e}=j||{};if(Array.isArray(e)&&e.length===1){let{type:r}=Dy(e[0]);return r==="Point"}return!1});I(this,"_getOppositeScaleHandle",j=>{let e=j&&j.properties&&Array.isArray(j.properties.positionIndexes)&&j.properties.positionIndexes[0];if(typeof e!="number")return null;let r=this._cornerGuidePoints.length,n=(e+r/2)%r;return this._cornerGuidePoints.find(i=>Array.isArray(i.properties.positionIndexes)?i.properties.positionIndexes[0]===n:!1)||null});I(this,"_getUpdatedData",(j,e)=>{let r=new Pj(j.data),n=j.selectedIndexes;for(let i=0;i!!this._selectedEditHandle);I(this,"getScaleAction",(j,e,r,n)=>{if(!this._selectedEditHandle)return null;let i=this._getOppositeScaleHandle(this._selectedEditHandle),o=zN(i),l=PcA(o,j,e),c=F3(this._geometryBeingScaled,l,{origin:o});return{updatedData:this._getUpdatedData(n,c),editType:r,editContext:{featureIndexes:n.selectedIndexes}}});I(this,"updateCursor",j=>{if(this._selectedEditHandle){this._cursor&&j.onUpdateCursor(this._cursor);let e=this.getSelectedFeaturesAsFeatureCollection(j),r=ws(e),n=Fj(r,this._selectedEditHandle),i=n<0?n+180:n;i>=0&&i<=90||i>=180&&i<=270?(this._cursor="nesw-resize",j.onUpdateCursor("nesw-resize")):(this._cursor="nwse-resize",j.onUpdateCursor("nwse-resize"))}else j.onUpdateCursor(null),this._cursor=null})}handlePointerMove(j,e){if(!this._isScaling){let r=te(j.picks);this._selectedEditHandle=r&&r.properties.editHandleType==="scale"?r:null,this.updateCursor(e)}}handleStartDragging(j,e){this._selectedEditHandle&&(this._isScaling=!0,this._geometryBeingScaled=this.getSelectedFeaturesAsFeatureCollection(e))}handleDragging(j,e){if(!this._isScaling)return;e.onUpdateCursor(this._cursor);let r=this.getScaleAction(j.pointerDownMapCoords,j.mapCoords,"scaling",e);r&&e.onEdit(r),j.cancelPan()}handleStopDragging(j,e){if(this._isScaling){let r=this.getScaleAction(j.pointerDownMapCoords,j.mapCoords,"scaled",e);r&&e.onEdit(r),e.onUpdateCursor(null),this._geometryBeingScaled=null,this._selectedEditHandle=null,this._cursor=null,this._isScaling=!1}}getGuides(j){this._cornerGuidePoints=[];let e=this.getSelectedFeaturesAsFeatureCollection(j);if(this._isSinglePointGeometrySelected(e))return{type:"FeatureCollection",features:[]};let r=Bn(za(e));r.properties.mode="scale";let n=[];return n0(r,(i,o)=>{if(o<4){let l=Vt(i,{guideType:"editHandle",editHandleType:"scale",positionIndexes:[o]});n.push(l)}}),this._cornerGuidePoints=n,Xa([gf(r),...this._cornerGuidePoints])}};function PcA(t,A,j){let e=yt(t,A);return yt(t,j)/e}function IcA(t){if(!t)throw new Error("geojson is required");switch(t.type){case"Feature":return P3(t);case"FeatureCollection":return McA(t);case"Point":case"LineString":case"Polygon":case"MultiPoint":case"MultiLineString":case"MultiPolygon":case"GeometryCollection":return dP(t);default:throw new Error("unknown GeoJSON type")}}function P3(t){var A={type:"Feature"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"properties":case"geometry":return;default:A[j]=t[j]}}),A.properties=I3(t.properties),A.geometry=dP(t.geometry),A}function I3(t){var A={};return t&&Object.keys(t).forEach(function(j){var e=t[j];typeof e=="object"?e===null?A[j]=null:Array.isArray(e)?A[j]=e.map(function(r){return r}):A[j]=I3(e):A[j]=e}),A}function McA(t){var A={type:"FeatureCollection"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"features":return;default:A[j]=t[j]}}),A.features=t.features.map(function(j){return P3(j)}),A}function dP(t){var A={type:t.type};return t.bbox&&(A.bbox=t.bbox),t.type==="GeometryCollection"?(A.geometries=t.geometries.map(function(j){return dP(j)}),A):(A.coordinates=M3(t.coordinates),A)}function M3(t){var A=t;return typeof A[0]!="object"?A.slice():A.map(function(j){return M3(j)})}var O3=IcA;var Zn=63710088e-1,wit={centimeters:Zn*100,centimetres:Zn*100,degrees:Zn/111325,feet:Zn*3.28084,inches:Zn*39.37,kilometers:Zn/1e3,kilometres:Zn/1e3,meters:Zn,metres:Zn,miles:Zn/1609.344,millimeters:Zn*1e3,millimetres:Zn*1e3,nauticalmiles:Zn/1852,radians:1,yards:Zn*1.0936},Fit={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Zn,yards:1.0936133};function pP(t){return!!t&&t.constructor===Object}function kP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y{let{features:e}=j||{};if(Array.isArray(e)&&e.length===1){let{type:r}=Dy(e[0]);return r==="Point"}return!1});I(this,"getIsRotating",()=>this._isRotating)}getGuides(j){let e=this._geometryBeingRotated||this.getSelectedFeaturesAsFeatureCollection(j);if(this._isSinglePointGeometrySelected(e))return{type:"FeatureCollection",features:[]};if(this._isRotating)return Xa([ws(e)]);let r=Bn(za(e)),n=null,i=null,o=0;n0(r,d=>{if(n){let k=ol(d,n);(!i||k[1]>i[1])&&(i=k);let g=yt(d,n);o=Math.max(o,g)}n=d});let l=i&&[i[0],i[1]+o/1e3],c=$r([i,l]),B=Vt(l,{guideType:"editHandle",editHandleType:"rotate"}),h=[gf(r),B,c];return Xa(h)}handleDragging(j,e){if(!this._isRotating)return;let r=this.getRotateAction(j.pointerDownMapCoords,j.mapCoords,"rotating",e);r&&e.onEdit(r),j.cancelPan()}handlePointerMove(j,e){if(!this._isRotating){let r=te(j.picks);this._selectedEditHandle=r&&r.properties.editHandleType==="rotate"?r:null}this.updateCursor(e)}handleStartDragging(j,e){this._selectedEditHandle&&(this._isRotating=!0,this._geometryBeingRotated=this.getSelectedFeaturesAsFeatureCollection(e))}handleStopDragging(j,e){if(this._isRotating){let r=this.getRotateAction(j.pointerDownMapCoords,j.mapCoords,"rotated",e);r&&e.onEdit(r),this._geometryBeingRotated=null,this._selectedEditHandle=null,this._isRotating=!1}}updateCursor(j){this._selectedEditHandle?j.onUpdateCursor("crosshair"):j.onUpdateCursor(null)}getRotateAction(j,e,r,n){if(!this._geometryBeingRotated)return null;let i=ws(this._geometryBeingRotated),o=TcA(i,j,e),l=Vy(this._geometryBeingRotated,o,{pivot:i}),c=new Pj(n.data),B=n.selectedIndexes;for(let h=0;h=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function R3(t){return t.type==="Feature"?t.geometry:t}function gP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("point is required");if(!A)throw new Error("polygon is required");var e=S3(t),r=R3(A),n=r.type,i=A.bbox,o=r.coordinates;if(i&&ScA(e,i)===!1)return!1;n==="Polygon"&&(o=[o]);for(var l=!1,c=0;ct[1]!=c>t[1]&&t[0]<(l-i)*(t[1]-o)/(c-o)+i;h&&(e=!e)}return e}function ScA(t,A){return A[0]<=t[0]&&A[1]<=t[1]&&A[2]>=t[0]&&A[3]>=t[1]}var t6=63710088e-1,Eot={centimeters:t6*100,centimetres:t6*100,degrees:t6/111325,feet:t6*3.28084,inches:t6*39.37,kilometers:t6/1e3,kilometres:t6/1e3,meters:t6,metres:t6,miles:t6/1609.344,millimeters:t6*1e3,millimetres:t6*1e3,nauticalmiles:t6/1852,radians:1,yards:t6*1.0936},$ot={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/t6,yards:1.0936133};function c0(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function EP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!mP(t[0])||!mP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return c0(e,A,j)}function $P(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function mP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function Qy(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}var j6=63710088e-1,_ot={centimeters:j6*100,centimetres:j6*100,degrees:j6/111325,feet:j6*3.28084,inches:j6*39.37,kilometers:j6/1e3,kilometres:j6/1e3,meters:j6,metres:j6,miles:j6/1609.344,millimeters:j6*1e3,millimetres:j6*1e3,nauticalmiles:j6/1852,radians:1,yards:j6*1.0936},qot={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/j6,yards:1.0936133};function Wy(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function xP(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return Wy(e,A,j)}function C3(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function yP(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function RcA(t,A){var j,e,r,n,i,o,l,c,B,h,d=0,k=t.type==="FeatureCollection",g=t.type==="Feature",E=k?t.features.length:1;for(j=0;jr?j:r,c=e>n?e:n;return[i,o,l,c]}var vP=LcA;function _P(t,A){if(t.type==="Feature")A(t,0);else if(t.type==="FeatureCollection")for(var j=0;j line1 must only contain 2 coordinates");if(e.length!==2)throw new Error(" line2 must only contain 2 coordinates");var r=j[0][0],n=j[0][1],i=j[1][0],o=j[1][1],l=e[0][0],c=e[0][1],B=e[1][0],h=e[1][1],d=(h-c)*(i-r)-(B-l)*(o-n),k=(B-l)*(n-c)-(h-c)*(r-l),g=(i-r)*(n-c)-(o-n)*(r-l);if(d===0)return null;var E=k/d,m=g/d;if(E>=0&&E<=1&&m>=0&&m<=1){var y=r+E*(i-r),b=n+E*(o-n);return EP([y,b])}return null}var ll=LuA;var e6=63710088e-1,est={centimeters:e6*100,centimetres:e6*100,degrees:e6/111325,feet:e6*3.28084,inches:e6*39.37,kilometers:e6/1e3,kilometres:e6/1e3,meters:e6,metres:e6,miles:e6/1609.344,millimeters:e6*1e3,millimetres:e6*1e3,nauticalmiles:e6/1852,radians:1,yards:e6*1.0936},rst={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/e6,yards:1.0936133};function f0(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function h0(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!NP(t[0])||!NP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return f0(e,A,j)}function ev(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return f0(e,A,j)}function NP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function CuA(t,A){var j,e,r,n,i,o,l,c,B,h,d=0,k=t.type==="FeatureCollection",g=t.type==="Feature",E=k?t.features.length:1;for(j=0;j0&&(m=E.features[0],m.properties.dist=yt(A,m,j),m.properties.location=r+yt(l,m,j)),l.properties.dist{let E=rv(g,l),m=yt(E,l);d>m&&(d=m,k=E)}),k){let g=Fj(l,k),E=yt(l,j,{units:"meters"});return yr(l,E,g,{units:"meters"}).geometry.coordinates}return j}let n=A[A.length-1],[i]=Ua(A[A.length-2],n,j);return rv($r([n,i]),j).geometry.coordinates}getGuides(A){let j=this.getClickSequence(),e={type:"FeatureCollection",features:[]};if(j.length===0||!A.lastPointerMoveEvent)return e;let{mapCoords:r}=A.lastPointerMoveEvent;return e.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...j,this.calculateMapCoords(j,r,A)]}}),e}handleClick(A,j){let e=this.getTentativeGuide(j),r=this.getSelectedGeometry(j);if(!r){console.warn("A polygon must be selected for splitting");return}let n=this.getClickSequence();e&&e.geometry.type==="LineString"?n.push(e.geometry.coordinates[e.geometry.coordinates.length-1]):this.addClickSequence(A);let i={type:"Point",coordinates:n[n.length-1]},o=gP(i,r);if(n.length>1&&e&&!o){if(this.resetClickSequence(),ll(e,r).features.length===0)return;let c=this.splitPolygon(e,j);c&&j.onEdit(c)}}handlePointerMove(A,j){j.onUpdateCursor("cell")}splitPolygon(A,j){let e=this.getSelectedGeometry(j),r=j.selectedIndexes[0],n=j.modeConfig||{},{gap:i=.1,units:o="centimeters"}=n;i===0&&(i=.1,o="centimeters");let l=by(A,i,{units:o}),c=Bf(e,l);if(!c)return console.warn("Canceling edit. Split Polygon erased"),null;let{type:B,coordinates:h}=c.geometry,d=[];return B==="Polygon"?d=h.map(E=>[E]):d=h.reduce((E,m)=>(m.forEach(y=>{E.push([y])}),E),[]),{updatedData:new Pj(j.data).replaceGeometry(r,{type:"MultiPolygon",coordinates:d}).getObject(),editType:"split",editContext:{featureIndexes:[r]}}}};var p0=class extends Mo{constructor(){super(...arguments);I(this,"isPointAdded",!1)}handleDragging(j,e){let r=te(j.pointerDownPicks);if(r){let{featureIndex:n}=r.properties,{positionIndexes:i}=r.properties,o=this.coordinatesSize(i,n,e.data);i=this.isPointAdded?this.nextPositionIndexes(i,o):i;let l=this.getPointForPositionIndexes(this.prevPositionIndexes(i,o),n,e.data),c=this.getPointForPositionIndexes(i,n,e.data);if(l&&c){let[B,h]=Ua(l,c,j.mapCoords),d=new Pj(e.data).replacePosition(n,this.prevPositionIndexes(i,o),h).replacePosition(n,i,B).getObject();e.onEdit({updatedData:d,editType:"extruding",editContext:{featureIndexes:[n],positionIndexes:this.nextPositionIndexes(i,o),position:B}}),j.cancelPan()}}}handleStartDragging(j,e){let r=e.selectedIndexes,n=o0(j.picks);if(r.length&&n){let{positionIndexes:i,featureIndex:o}=n.properties,l=this.coordinatesSize(i,o,e.data),c=this.getPointForPositionIndexes(this.prevPositionIndexes(i,l),o,e.data),B=this.getPointForPositionIndexes(i,o,e.data);if(c&&B){let h=new Pj(e.data);this.isOrthogonal(i,o,l,e.data)||(h=h.addPosition(o,i,B)),this.isOrthogonal(this.prevPositionIndexes(i,l),o,l,e.data)||(h=h.addPosition(o,i,c),this.isPointAdded=!0),e.onEdit({updatedData:h.getObject(),editType:"startExtruding",editContext:{featureIndexes:[o],positionIndexes:i,position:c}})}}}handleStopDragging(j,e){let r=e.selectedIndexes,n=te(j.pointerDownPicks);if(r.length&&n){let{featureIndex:i}=n.properties,{positionIndexes:o}=n.properties,l=this.coordinatesSize(o,i,e.data);o=this.isPointAdded?this.nextPositionIndexes(o,l):o;let c=this.getPointForPositionIndexes(this.prevPositionIndexes(o,l),i,e.data),B=this.getPointForPositionIndexes(o,i,e.data);if(c&&B){let[h,d]=Ua(c,B,j.mapCoords),k=new Pj(e.data).replacePosition(i,this.prevPositionIndexes(o,l),d).replacePosition(i,o,h).getObject();e.onEdit({updatedData:k,editType:"extruded",editContext:{featureIndexes:[i],positionIndexes:o,position:h}})}}this.isPointAdded=!1}coordinatesSize(j,e,{features:r}){let n=0;if(Array.isArray(j)){let o=r[e].geometry.coordinates;if(j.length===3){let[l,c]=j;o.length&&o[l].length&&(n=o[l][c].length)}else{let[l]=j;o.length&&o[l].length&&(n=o[l].length)}}return n}getBearing(j,e){let r=Fj(j,e);return r<0?Math.floor(360+r):Math.floor(r)}isOrthogonal(j,e,r,n){if(!Array.isArray(j))return!1;j[j.length-1]===r-1&&(j[j.length-1]=0);let i=this.getPointForPositionIndexes(this.prevPositionIndexes(j,r),e,n),o=this.getPointForPositionIndexes(this.nextPositionIndexes(j,r),e,n),l=this.getPointForPositionIndexes(j,e,n),c=this.getBearing(l,i),B=this.getBearing(l,o);return[89,90,91,269,270,271].includes(Math.abs(c-B))}nextPositionIndexes(j,e){if(!Array.isArray(j))return[];let r=[...j];return r.length&&(r[r.length-1]=r[r.length-1]===e-1?0:r[r.length-1]+1),r}prevPositionIndexes(j,e){if(!Array.isArray(j))return[];let r=[...j];return r.length&&(r[r.length-1]=r[r.length-1]===0?e-2:r[r.length-1]-1),r}getPointForPositionIndexes(j,e,{features:r}){let n;if(Array.isArray(j)){let o=r[e].geometry.coordinates;if(j.length===3){let[l,c,B]=j;o.length&&o[l].length&&(n=o[l][c][B])}else{let[l,c]=j;o.length&&o[l].length&&(n=o[l][c])}}return n}};function DuA({pointerDownScreenCoords:t,screenCoords:A}){return 10*(t[1]-A[1])}var k0=class extends Mo{makeElevatedEvent(A,j,e){let{minElevation:r=0,maxElevation:n=2e4,calculateElevationChange:i=DuA}=e.modeConfig||{};if(!A.pointerDownScreenCoords)return A;let o=j.length===3?j[2]:0;return o+=i({pointerDownScreenCoords:A.pointerDownScreenCoords,screenCoords:A.screenCoords}),o=Math.min(o,n),o=Math.max(o,r),Object.assign({},A,{mapCoords:[j[0],j[1],o]})}handlePointerMove(A,j){let e=te(A.pointerDownPicks),r=e?e.geometry.coordinates:A.mapCoords;super.handlePointerMove(this.makeElevatedEvent(A,r,j),j)}handleStopDragging(A,j){let e=te(A.picks),r=e?e.geometry.coordinates:A.mapCoords;super.handleStopDragging(this.makeElevatedEvent(A,r,j),j)}getCursor(A){let j=super.getCursor(A);return j==="cell"&&(j="ns-resize"),j}static calculateElevationChangeWithViewport(A,{pointerDownScreenCoords:j,screenCoords:e}){return 156543.03392*Math.cos(A.latitude*Math.PI/180)/Math.pow(2,A.zoom)*(j[1]-e[1])/2}};var g0=class extends Zt{createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=j?[j.mapCoords]:[];return{type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Point",coordinates:e[0]}}}handleClick({mapCoords:A},j){let e={type:"Point",coordinates:A};j.onEdit(this.getAddFeatureAction(e,j.data))}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}};function NuA(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{for(let r in e)if(!NuA(e[r],A[r])){j=t(e),A=e;break}return j}}var m0=class extends Zt{constructor(){super(...arguments);I(this,"dist",0);I(this,"position",null);I(this,"elems",[]);I(this,"_getTooltips",cl(({modeConfig:j,dist:e})=>{let r=[],{formatTooltip:n}=j||{},i;return e&&(n?i=n(e):i=`Distance: ${parseFloat(e).toFixed(2)} kilometers`,r=[{position:this.position,text:i}]),r}))}handleClick(j,e){let{picks:r}=j,n=te(r),i=!1;n||(this.addClickSequence(j),i=!0);let o=this.getClickSequence();if(n||this.calculateInfoDraw(o),o.length>1&&n&&Array.isArray(n.properties.positionIndexes)&&n.properties.positionIndexes[0]===o.length-1){this.dist=0;let l={type:"LineString",coordinates:[...o]};this.resetClickSequence();let c=this.getAddFeatureAction(l,e.data);c&&e.onEdit(c)}else i&&e.onEdit({updatedData:e.data,editType:"addTentativePosition",editContext:{position:j.mapCoords}})}handleKeyUp(j,e){let{key:r}=j;if(r==="Enter"){let n=this.getClickSequence();if(n.length>1){let i={type:"LineString",coordinates:[...n]};this.resetClickSequence();let o=this.getAddFeatureAction(i,e.data);o&&e.onEdit(o)}}else r==="Escape"&&(this.resetClickSequence(),e.onEdit({updatedData:e.data,editType:"cancelFeature",editContext:{}}))}getGuides(j){let{lastPointerMoveEvent:e}=j,r=this.getClickSequence(),n=e?[e.mapCoords]:[],i={type:"FeatureCollection",features:[]},o;r.length>0&&(o={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...r,...n]}}),o&&i.features.push(o);let l=r.map((c,B)=>({type:"Feature",properties:{guideType:"editHandle",editHandleType:"existing",featureIndex:-1,positionIndexes:[B]},geometry:{type:"Point",coordinates:c}}));return i.features.push(...l),i}handlePointerMove(j,e){e.onUpdateCursor("cell")}getTooltips(j){return this._getTooltips({modeConfig:j.modeConfig,dist:this.dist})}calculateInfoDraw(j){j.length>1&&(this.position=j[j.length-1],this.dist+=yt(j[j.length-2],j[j.length-1]))}};var Ai=class extends Zt{createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===1||e.length===2?n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...e,...r]}}:e.length>2&&(n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Polygon",coordinates:[[...e,...r,e[0]]]}}),n}getGuides(A){let j=this.getClickSequence(),e={type:"FeatureCollection",features:[]},r=this.createTentativeFeature(A);r&&e.features.push(r);let n=j.map((i,o)=>({type:"Feature",properties:{guideType:"editHandle",editHandleType:"existing",featureIndex:-1,positionIndexes:[o]},geometry:{type:"Point",coordinates:i}}));return e.features.push(...n),e}handleClick(A,j){let{picks:e}=A,r=te(e),n=this.getClickSequence(),i=!1;if(n.length>2&&j.modeConfig&&j.modeConfig.preventOverlappingLines){let l=$r([n[n.length-1],A.mapCoords]),c=$r([...n.slice(0,n.length-1)]);ll(l,c).features.length>0&&(i=!0)}let o=!1;if(!r&&!i&&(this.addClickSequence(A),o=!0),n.length>2&&r&&Array.isArray(r.properties.positionIndexes)&&(r.properties.positionIndexes[0]===0||r.properties.positionIndexes[0]===n.length-1)){let l={type:"Polygon",coordinates:[[...n,n[0]]]};this.resetClickSequence();let c=this.getAddFeatureOrBooleanPolygonAction(l,j);c&&j.onEdit(c)}else o&&j.onEdit({updatedData:j.data,editType:"addTentativePosition",editContext:{position:A.mapCoords}})}handleKeyUp(A,j){if(A.key==="Enter"){let e=this.getClickSequence();if(e.length>2){let r={type:"Polygon",coordinates:[[...e,e[0]]]};this.resetClickSequence();let n=this.getAddFeatureOrBooleanPolygonAction(r,j);n&&j.onEdit(n)}}else A.key==="Escape"&&(this.resetClickSequence(),j.onEdit({updatedData:j.data,editType:"cancelFeature",editContext:{}}))}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}};var pn=class extends Zt{handleClick(A,j){j.modeConfig&&j.modeConfig.dragToDraw||(this.addClickSequence(A),this.checkAndFinishPolygon(j))}handleStartDragging(A,j){!j.modeConfig||!j.modeConfig.dragToDraw||(this.addClickSequence(A),A.cancelPan())}handleStopDragging(A,j){!j.modeConfig||!j.modeConfig.dragToDraw||(this.addClickSequence(A),this.checkAndFinishPolygon(j))}checkAndFinishPolygon(A){let j=this.getClickSequence(),e=this.getTentativeGuide(A);if(j.length>1&&e&&e.geometry.type==="Polygon"){let r={type:"Feature",properties:{shape:e.properties.shape},geometry:{type:"Polygon",coordinates:e.geometry.coordinates}},n=this.getAddFeatureOrBooleanPolygonAction(r,A);this.resetClickSequence(),n&&A.onEdit(n)}}getGuides(A){let{lastPointerMoveEvent:j,modeConfig:e}=A,r=this.getClickSequence(),n={type:"FeatureCollection",features:[]};if(r.length===0||!j)return n;let i=r[0],o=j.mapCoords,l=this.getTwoClickPolygon(i,o,e);return l&&n.features.push({type:"Feature",properties:{shape:l.properties&&l.properties.shape,guideType:"tentative"},geometry:l.geometry}),n}getTwoClickPolygon(A,j,e){return null}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===1&&(n=this.getTwoClickPolygon(e[0],r[0],A.modeConfig)),n}};var Dc=class extends pn{getTwoClickPolygon(A,j,e){let r=Bn([A[0],A[1],j[0],j[1]]);return r.properties=r.properties||{},r.properties.shape="Rectangle",r}};var r6=63710088e-1,oat={centimeters:r6*100,centimetres:r6*100,degrees:r6/111325,feet:r6*3.28084,inches:r6*39.37,kilometers:r6/1e3,kilometres:r6/1e3,meters:r6,metres:r6,miles:r6/1609.344,millimeters:r6*1e3,millimetres:r6*1e3,nauticalmiles:r6/1852,radians:1,yards:r6*1.0936},sat={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/r6,yards:1.0936133};function KuA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function XP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!KP(t[0])||!KP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return KuA(e,A,j)}function KP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function mK(t){return t.type==="Feature"?t.geometry:t}function E0(t,A,j){j===void 0&&(j={});for(var e=mK(t),r=e.coordinates,n=0,i=0;i=n&&i===r.length-1);i++)if(n>=A){var o=A-n;if(o){var l=Fj(r[i],r[i-1])-180,c=yr(r[i],o,l,j);return c}else return XP(r[i])}else n+=yt(r[i],r[i+1],j);return XP(r[r.length-1])}var $0=class extends pn{getTwoClickPolygon(A,j,e){let r=[j[0],A[1]],n=[A[0],j[1]],i=yt(Vt(r),Vt(A)),o=yt(Vt(n),Vt(A)),l=i<=o?i:o,c=i<=o?r:n,B=$r([c,j]),d=E0(B,l).geometry.coordinates,k=Bn([A[0],A[1],d[0],d[1]]);return k.properties=k.properties||{},k.properties.shape="Square",k}};var x0=class extends pn{getTwoClickPolygon(A,j,e){let r=A[0]>j[0]?A[0]+Math.abs(A[0]-j[0]):A[0]-Math.abs(A[0]-j[0]),n=A[1]>j[1]?A[1]+Math.abs(A[1]-j[1]):A[1]-Math.abs(A[1]-j[1]),i=Bn([r,n,j[0],j[1]]);return i.properties=i.properties||{},i.properties.shape="Rectangle",i}};var y0=class extends pn{getTwoClickPolygon(A,j,e){let r=[j[0],A[1]],n=[A[0],j[1]],i=yt(Vt(r),Vt(A)),o=yt(Vt(n),Vt(A)),l=i<=o?i:o,c=i<=o?r:n,B=$r([c,j]),d=E0(B,l).geometry.coordinates,k=A[0]>d[0]?A[0]+Math.abs(A[0]-d[0]):A[0]-Math.abs(A[0]-d[0]),g=A[1]>d[1]?A[1]+Math.abs(A[1]-d[1]):A[1]-Math.abs(A[1]-d[1]),E=Bn([k,g,d[0],d[1]]);return E.properties=E.properties||{},E.properties.shape="Square",E}};var n6=63710088e-1,Iat={centimeters:n6*100,centimetres:n6*100,degrees:n6/111325,feet:n6*3.28084,inches:n6*39.37,kilometers:n6/1e3,kilometres:n6/1e3,meters:n6,metres:n6,miles:n6/1609.344,millimeters:n6*1e3,millimetres:n6*1e3,nauticalmiles:n6/1852,radians:1,yards:n6*1.0936},Mat={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/n6,yards:1.0936133};function XuA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function EK(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e0){A+=Math.abs(yK(t[0]));for(var j=1;j2){for(o=0;o{let n=[],{formatTooltip:i}=j||{},o;return e&&r&&(i?o=i(e):o=`Radius: ${parseFloat(e).toFixed(2)} kilometers + `},A}updateState(A){super.updateState(A);let{props:j,oldProps:e}=A;(j.color!==e.color||j.opacityScale!==e.opacityScale)&&this.setState({uniforms:{uColor:j.color.map(r=>r/255),uOpacityScale:j.opacityScale}})}draw(A){let{uniforms:j}=this.state;super.draw({...A,uniforms:{...A.uniforms,...j}})}};var Nk=(t,A,j,e,r={},n=null)=>async({index:i})=>{let{x:o,y:l,z:c}=i,B=`${t}/pyramid_images/${A}_files/${e+c}/${o}_${l}${j}`,{fetch:h={},...d}=r,k=async(g,E={})=>{let m={...h,...E};return n?n.fetch(g,m):fetch(g,m)};try{return await As(B,Nd,{...d,fetch:k})}catch(g){let E=Zj(g,{coordinates:`${o},${l},${c}`,url:B,messages:{network:"Failed to load tile due to network issues",notFound:"Tile does not exist",unauthorized:"Unauthorized access to tile",forbidden:"Access forbidden for tile",unexpected:"Failed to load tile"},throwOnAuth:!0,logUnexpected:!0});return E.error==="not_found"||E.error==="network",null}},ay=(t,A,j)=>e=>{let{bbox:{left:r,bottom:n,right:i,top:o}}=e.tile,{width:l,height:c}=t;return new sy(e,{data:null,image:e.data,bounds:[gs(r,0,l),gs(n,0,c),gs(i,0,l),gs(o,0,c)],color:A,opacityScale:j})},ly=t=>A=>{let{bbox:{left:j,bottom:e,right:r,top:n}}=A.tile,{width:i,height:o}=t;return new zB(A,{data:null,image:A.data,bounds:[gs(j,0,i),gs(e,0,o),gs(r,0,i),gs(n,0,o)]})};var of=async(t,A,j=0,e="")=>{let{global_base_url:r}=t,{dimensions:n}=t,{landscape_parameters:i}=t.img,{image_format:o}=t.img.landscape_parameters,l=`global-simple-image-layer-ds${j}${e?`-${e}`:""}`;return new Rc({id:l,tileSize:n.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:0,extent:[0,0,n.width,n.height],getTileData:Nk(r,A.name,o,i.max_pyramid_zoom,Nt,t.aws),renderSubLayers:ly(n),visible:!0,...Er(t.rotation)})},bD=(t,A)=>{t.simple_image_layer=t.simple_image_layer.clone({visible:A})};var Es=(t,A)=>{t.global_base_url=A};var GD=async(t,A,j,e)=>{let r=`${t}/pyramid_images/${A}.dzi`,i=await(e!==null?await e.fetch(r):await fetch(r,j.fetch)).text(),o=new DOMParser().parseFromString(i,"text/xml");return{height:Number(o.getElementsByTagName("Size")[0].attributes.Height.value),width:Number(o.getElementsByTagName("Size")[0].attributes.Width.value),tileSize:Number(o.getElementsByTagName("Image")[0].attributes.TileSize.value)}};var $s=async(t,A,j)=>{try{t.dimensions=await GD(A,j,Nt,t.aws);return}catch{}if(t.use_row_groups&&t.img?.landscape_parameters){let e=t.img.landscape_parameters;if(e.image_dimensions?.width&&e.image_dimensions?.height){t.dimensions={width:e.image_dimensions.width,height:e.image_dimensions.height,tileSize:e.image_dimensions.tile_size||512};return}if(t.row_group_readers?.images){let r=Object.values(t.row_group_readers.images)[0];if(r?.zoomInfo){let i=Object.keys(r.zoomInfo).map(Number).sort((l,c)=>c-l)[0],o=r.zoomInfo[String(i)];if(o){let c=o.num_tiles_x*512,B=o.num_tiles_y*512;t.dimensions={width:c,height:B,tileSize:512};return}}}}t.dimensions={width:1e4,height:1e4,tileSize:512}};var xs=async(t,A,j)=>{let e=`${A}/landscape_parameters.json`,r=await fetch(e,Nt.fetch);t.landscape_parameters=await r.json()};var B1=async(t,A,j,e,r,n,i,o,l="",c=0,B=800,h={})=>{c===0&&(c="100%");let d=document.createElement("div");d.style.height=`${B}px`;let k={};if(Z7(e),Es(k,j),"accessKeyId"in h){k.aws=new Yo({accessKeyId:h.accessKeyId,secretAccessKey:h.secretAccessKey,sessionToken:h.sessionToken,region:"us-east-1",service:"s3"});let v=await k.aws.fetch(`${j}/landscape_parameters.json`);if(!v.ok)throw new Error(`Fetch failed: ${v.statusText}`)}else k.aws=null;k.model=t,k.img={},k.img.image_layer_colors={},k.img.image_layer_sliders={},await xs(k.img,j),await $s(k,j,"h_and_e"),k.buttons={},k.buttons.blue="#8797ff",k.buttons.gray="gray",k.buttons.light_gray="#EEEEEE",k.buttons.buttons={};let m={simple_image_layer:await of(k,{name:"h_and_e",color:[0,0,255]})};k.views=nf();let y=ey(d,c,B),G={target:[r,n,i],zoom:o};return y.setProps({views:k.views,layers:[m.simple_image_layer],initialViewState:G}),A.appendChild(d),()=>y.finalize()};var Hc={NONE:0,FORWARD:1,BACKWARD:2,BOTH:3},wD=1;var olA={arrowColor:[0,0,0,1],arrowCount:wD,arrowStyle:Hc.NONE,fillColor:[0,0,0,1],lineColor:[0,0,0,1],lineWidthMeters:5,outlineRadiusMeters:0,opacity:1,zLevel:0};var On=63710088e-1,PVA={centimeters:On*100,centimetres:On*100,degrees:On/111325,feet:On*3.28084,inches:On*39.37,kilometers:On/1e3,kilometres:On/1e3,meters:On,metres:On,miles:On/1609.344,millimeters:On*1e3,millimetres:On*1e3,nauticalmiles:On/1852,radians:1,yards:On*1.0936},IVA={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/On,yards:1.0936133};function Kk(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function Vt(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!f1(t[0])||!f1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return Kk(e,A,j)}function $r(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return Kk(e,A,j)}function Xa(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function f1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function h1(t){return!!t&&t.constructor===Object}var Tn=63710088e-1,OVA={centimeters:Tn*100,centimetres:Tn*100,degrees:Tn/111325,feet:Tn*3.28084,inches:Tn*39.37,kilometers:Tn/1e3,kilometres:Tn/1e3,meters:Tn,metres:Tn,miles:Tn/1609.344,millimeters:Tn*1e3,millimetres:Tn*1e3,nauticalmiles:Tn/1852,radians:1,yards:Tn*1.0936},TVA={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Tn,yards:1.0936133};function d1(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yj[0]&&(A[0]=j[0]),A[1]>j[1]&&(A[1]=j[1]),A[2]1?0:t<-1?Kt:Math.acos(t)}function tr(t){return t>1?Ar:t<-1?-Ar:Math.asin(t)}function Cn(){}function ky(t,A){t&&HD.hasOwnProperty(t.type)&&HD[t.type](t,A)}var CD={Feature:function(t,A){ky(t.geometry,A)},FeatureCollection:function(t,A){for(var j=t.features,e=-1,r=j.length;++eKt?t-Nr:t<-Kt?t+Nr:t,A]}$1.invert=$1;function x1(t,A,j){return(t%=Nr)?A||j?my(KD(t),XD(A,j)):KD(t):A||j?XD(A,j):$1}function ND(t){return function(A,j){return A+=t,[A>Kt?A-Nr:A<-Kt?A+Nr:A,j]}}function KD(t){var A=ND(t);return A.invert=ND(-t),A}function XD(t,A){var j=pt(t),e=kt(t),r=pt(A),n=kt(A);function i(o,l){var c=pt(l),B=pt(o)*c,h=kt(o)*c,d=kt(l),k=d*j+B*e;return[xr(h*r-k*n,B*j-d*e),tr(k*r+h*n)]}return i.invert=function(o,l){var c=pt(l),B=pt(o)*c,h=kt(o)*c,d=kt(l),k=d*r-h*n;return[xr(h*r+d*n,B*j+k*e),tr(k*j-B*e)]},i}function UD(t,A,j,e,r,n){if(j){var i=pt(A),o=kt(A),l=e*j;r==null?(r=A+e*Nr,n=A-l/2):(r=zD(i,r),n=zD(i,n),(e>0?rn)&&(r+=e*Nr));for(var c,B=r;e>0?B>n:B1&&t.push(t.pop().concat(t.shift()))},result:function(){var j=t;return t=[],A=null,j}}}function VD(t,A,j,e,r,n){var i=t[0],o=t[1],l=A[0],c=A[1],B=0,h=1,d=l-i,k=c-o,g;if(g=j-i,!(!d&&g>0)){if(g/=d,d<0){if(g0){if(g>h)return;g>B&&(B=g)}if(g=r-i,!(!d&&g<0)){if(g/=d,d<0){if(g>h)return;g>B&&(B=g)}else if(d>0){if(g0)){if(g/=k,k<0){if(g0){if(g>h)return;g>B&&(B=g)}if(g=n-o,!(!k&&g<0)){if(g/=k,k<0){if(g>h)return;g>B&&(B=g)}else if(k>0){if(g0&&(t[0]=i+B*d,t[1]=o+B*k),h<1&&(A[0]=i+h*d,A[1]=o+h*k),!0}}}}}function lf(t,A){return ij(t[0]-A[0])=0;--o)r.point((h=B[o])[0],h[1]);else e(d.x,d.p.x,-1,r);d=d.p}d=d.o,B=d.z,k=!k}while(!d.v);r.lineEnd()}}}function QD(t){if(A=t.length){for(var A,j=0,e=t[0],r;++jA?1:t>=A?0:NaN}function y1(t){return t.length===1&&(t=ulA(t)),{left:function(A,j,e,r){for(e==null&&(e=0),r==null&&(r=A.length);e>>1;t(A[n],j)<0?e=n+1:r=n}return e},right:function(A,j,e,r){for(e==null&&(e=0),r==null&&(r=A.length);e>>1;t(A[n],j)>0?r=n:e=n+1}return e}}}function ulA(t){return function(A,j){return jl(t(A),j)}}var WD=y1(jl),BlA=WD.right,flA=WD.left;var YD=Array.prototype,dlA=YD.slice,plA=YD.map;var mWA=Math.sqrt(50),EWA=Math.sqrt(10),$WA=Math.sqrt(2);function Qk(t){for(var A=t.length,j,e=-1,r=0,n,i;++e=0;)for(i=t[A],j=i.length;--j>=0;)n[--r]=i[j];return n}var Wk=1e9,vy=-Wk;function v1(t,A,j,e){function r(c,B){return t<=c&&c<=j&&A<=B&&B<=e}function n(c,B,h,d){var k=0,g=0;if(c==null||(k=i(c,h))!==(g=i(B,h))||l(c,B)<0^h>0)do d.point(k===0||k===3?t:j,k>1?e:A);while((k=(k+h+4)%4)!==g);else d.point(B[0],B[1])}function i(c,B){return ij(c[0]-t)0?0:3:ij(c[0]-j)0?2:1:ij(c[1]-A)0?1:0:B>0?3:2}function o(c,B){return l(c.x,B.x)}function l(c,B){var h=i(c,1),d=i(B,1);return h!==d?h-d:h===0?B[1]-c[1]:h===1?c[0]-B[0]:h===2?c[1]-B[1]:B[0]-c[0]}return function(c){var B=c,h=Ey(),d,k,g,E,m,y,G,v,_,w,x,O={point:F,lineStart:T,lineEnd:Q,polygonStart:R,polygonEnd:X};function F(jA,pA){r(jA,pA)&&B.point(jA,pA)}function C(){for(var jA=0,pA=0,dA=k.length;pAe&&(SA-mt)*(e-Ct)>(ft-Ct)*(t-mt)&&++jA:ft<=e&&(SA-mt)*(e-Ct)<(ft-Ct)*(t-mt)&&--jA;return jA}function R(){B=h,d=[],k=[],x=!0}function X(){var jA=C(),pA=x&&jA,dA=(d=Qk(d)).length;(pA||dA)&&(c.polygonStart(),pA&&(c.lineStart(),n(null,null,1,c),c.lineEnd()),dA&&xy(d,o,jA,n,c),c.polygonEnd()),B=c,d=k=g=null}function T(){O.point=b,k&&k.push(g=[]),w=!0,_=!1,G=v=NaN}function Q(){d&&(b(E,m),y&&_&&h.rejoin(),d.push(h.result())),O.point=F,_&&B.lineEnd()}function b(jA,pA){var dA=r(jA,pA);if(k&&g.push([jA,pA]),w)E=jA,m=pA,y=dA,w=!1,dA&&(B.lineStart(),B.point(jA,pA));else if(dA&&_)B.point(jA,pA);else{var $A=[G=Math.max(vy,Math.min(Wk,G)),v=Math.max(vy,Math.min(Wk,v))],_A=[jA=Math.max(vy,Math.min(Wk,jA)),pA=Math.max(vy,Math.min(Wk,pA))];VD($A,_A,t,A,j,e)?(_||(B.lineStart(),B.point($A[0],$A[1])),B.point(_A[0],_A[1]),dA||B.lineEnd(),x=!1):dA&&(B.lineStart(),B.point(jA,pA),x=!1)}G=jA,v=pA,_=dA}return O}}var _1=w6();function q1(t,A){var j=A[0],e=A[1],r=[kt(j),-pt(j),0],n=0,i=0;_1.reset();for(var o=0,l=t.length;o=0?1:-1,F=O*x,C=F>Kt,R=g*_;if(_1.add(xr(R*O*kt(F),E*w+R*pt(F))),n+=C?x+O*Nr:x,C^d>=j^G>=j){var X=Dc(bo(h),bo(y));af(X);var T=Dc(r,X);af(T);var Q=(C^x>=0?-1:1)*tr(T[2]);(e>Q||e===Q&&(X[0]||X[1]))&&(i+=C^x>=0?1:-1)}}return(n<-xt||nJk&&(Jk=t),A<_y&&(_y=A),A>qy&&(qy=A)}var by=qlA;function b1(t){this._context=t}b1.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(t,A){switch(this._point){case 0:{this._context.moveTo(t,A),this._point=1;break}case 1:{this._context.lineTo(t,A);break}default:{this._context.moveTo(t+this._radius,A),this._context.arc(t,A,this._radius,0,Nr);break}}},result:Cn};var XJA=w6();function G1(){this._string=[]}G1.prototype={_radius:4.5,_circle:AN(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(t,A){switch(this._point){case 0:{this._string.push("M",t,",",A),this._point=1;break}case 1:{this._string.push("L",t,",",A);break}default:{this._circle==null&&(this._circle=AN(this._radius)),this._string.push("M",t,",",A,this._circle);break}}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}else return null}};function AN(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function Gy(t,A,j,e){return function(r,n){var i=A(n),o=r.invert(e[0],e[1]),l=Ey(),c=A(l),B=!1,h,d,k,g={point:E,lineStart:y,lineEnd:G,polygonStart:function(){g.point=v,g.lineStart=_,g.lineEnd=w,d=[],h=[]},polygonEnd:function(){g.point=E,g.lineStart=y,g.lineEnd=G,d=Qk(d);var x=q1(h,o);d.length?(B||(n.polygonStart(),B=!0),xy(d,wlA,x,j,n)):x&&(B||(n.polygonStart(),B=!0),n.lineStart(),j(null,null,1,n),n.lineEnd()),B&&(n.polygonEnd(),B=!1),d=h=null},sphere:function(){n.polygonStart(),n.lineStart(),j(null,null,1,n),n.lineEnd(),n.polygonEnd()}};function E(x,O){var F=r(x,O);t(x=F[0],O=F[1])&&n.point(x,O)}function m(x,O){var F=r(x,O);i.point(F[0],F[1])}function y(){g.point=m,i.lineStart()}function G(){g.point=E,i.lineEnd()}function v(x,O){k.push([x,O]);var F=r(x,O);c.point(F[0],F[1])}function _(){c.lineStart(),k=[]}function w(){v(k[0][0],k[0][1]),c.lineEnd();var x=c.clean(),O=l.result(),F,C=O.length,R,X,T;if(k.pop(),h.push(k),k=null,!!C){if(x&1){if(X=O[0],(R=X.length-1)>0){for(B||(n.polygonStart(),B=!0),n.lineStart(),F=0;F1&&x&2&&O.push(O.pop().concat(O.shift())),d.push(O.filter(GlA))}}return g}}function GlA(t){return t.length>1}function wlA(t,A){return((t=t.x)[0]<0?t[1]-Ar-xt:Ar-t[1])-((A=A.x)[0]<0?A[1]-Ar-xt:Ar-A[1])}var w1=Gy(function(){return!0},FlA,IlA,[-Kt,-Ar]);function FlA(t){var A=NaN,j=NaN,e=NaN,r;return{lineStart:function(){t.lineStart(),r=1},point:function(n,i){var o=n>0?Kt:-Kt,l=ij(n-A);ij(l-Kt)0?Ar:-Ar),t.point(e,j),t.lineEnd(),t.lineStart(),t.point(o,j),t.point(n,j),r=0):e!==o&&l>=Kt&&(ij(A-e)xt?qo((kt(A)*(n=pt(e))*kt(j)-kt(e)*(r=pt(A))*kt(t))/(r*n*i)):(A+e)/2}function IlA(t,A,j,e){var r;if(t==null)r=j*Ar,e.point(-Kt,r),e.point(0,r),e.point(Kt,r),e.point(Kt,0),e.point(Kt,-r),e.point(0,-r),e.point(-Kt,-r),e.point(-Kt,0),e.point(-Kt,r);else if(ij(t[0]-A[0])>xt){var n=t[0]0,r=ij(j)>xt;function n(B,h,d,k){UD(k,t,A,d,B,h)}function i(B,h){return pt(B)*pt(h)>j}function o(B){var h,d,k,g,E;return{lineStart:function(){g=k=!1,E=1},point:function(m,y){var G=[m,y],v,_=i(m,y),w=e?_?0:c(m,y):_?c(m+(m<0?Kt:-Kt),y):0;if(!h&&(g=k=_)&&B.lineStart(),_!==k&&(v=l(h,G),(!v||lf(h,v)||lf(G,v))&&(G[0]+=xt,G[1]+=xt,_=i(G[0],G[1]))),_!==k)E=0,_?(B.lineStart(),v=l(G,h),B.point(v[0],v[1])):(v=l(h,G),B.point(v[0],v[1]),B.lineEnd()),h=v;else if(r&&h&&e^_){var x;!(w&d)&&(x=l(G,h,!0))&&(E=0,e?(B.lineStart(),B.point(x[0][0],x[0][1]),B.point(x[1][0],x[1][1]),B.lineEnd()):(B.point(x[1][0],x[1][1]),B.lineEnd(),B.lineStart(),B.point(x[0][0],x[0][1])))}_&&(!h||!lf(h,G))&&B.point(G[0],G[1]),h=G,k=_,d=w},lineEnd:function(){k&&B.lineEnd(),h=null},clean:function(){return E|(g&&k)<<1}}}function l(B,h,d){var k=bo(B),g=bo(h),E=[1,0,0],m=Dc(k,g),y=Uk(m,m),G=m[0],v=y-G*G;if(!v)return!d&&B;var _=j*y/v,w=-j*G/v,x=Dc(E,m),O=Vk(E,_),F=Vk(m,w);gy(O,F);var C=x,R=Uk(O,C),X=Uk(C,C),T=R*R-X*(Uk(O,O)-1);if(!(T<0)){var Q=ze(T),b=Vk(C,(-R-Q)/X);if(gy(b,O),b=sf(b),!d)return b;var jA=B[0],pA=h[0],dA=B[1],$A=h[1],_A;pA0^b[1]<(ij(b[0]-jA)Kt^(jA<=b[0]&&b[0]<=pA)){var Ct=Vk(C,(-R+Q)/X);return gy(Ct,O),[b,sf(Ct)]}}}function c(B,h){var d=e?t:Kt-t,k=0;return B<-d?k|=1:B>d&&(k|=2),h<-d?k|=4:h>d&&(k|=8),k}return Gy(i,o,n,e?[0,-t]:[-Kt,t-Kt])}function Zk(t){return function(A){var j=new F1;for(var e in t)j[e]=t[e];return j.stream=A,j}}function F1(){}F1.prototype={constructor:F1,point:function(t,A){this.stream.point(t,A)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function A0(t,A,j){var e=A[1][0]-A[0][0],r=A[1][1]-A[0][1],n=t.clipExtent&&t.clipExtent();t.scale(150).translate([0,0]),n!=null&&t.clipExtent(null),tl(j,t.stream(by));var i=by.result(),o=Math.min(e/(i[1][0]-i[0][0]),r/(i[1][1]-i[0][1])),l=+A[0][0]+(e-o*(i[1][0]+i[0][0]))/2,c=+A[0][1]+(r-o*(i[1][1]+i[0][1]))/2;return n!=null&&t.clipExtent(n),t.scale(o*150).translate([l,c])}function wy(t,A,j){return A0(t,[[0,0],A],j)}var jN=16,MlA=pt(30*se);function P1(t,A){return+A?TlA(t,A):OlA(t)}function OlA(t){return Zk({point:function(A,j){A=t(A,j),this.stream.point(A[0],A[1])}})}function TlA(t,A){function j(e,r,n,i,o,l,c,B,h,d,k,g,E,m){var y=c-e,G=B-r,v=y*y+G*G;if(v>4*A&&E--){var _=i+d,w=o+k,x=l+g,O=ze(_*_+w*w+x*x),F=tr(x/=O),C=ij(ij(x)-1)A||ij((y*Q+G*b)/v-.5)>.3||i*d+o*k+l*g2?b[2]%360*se:0,T()):[c*Ln,B*Ln,h*Ln]},C.precision=function(b){return arguments.length?(x=P1(X,w=b*b),Q()):ze(w)},C.fitExtent=function(b,jA){return A0(C,b,jA)},C.fitSize=function(b,jA){return wy(C,b,jA)};function T(){k=my(d=x1(c,B,h),A);var b=A(o,l);return n=e-b[0]*j,i=r+b[1]*j,Q()}function Q(){return O=F=null,C}return function(){return A=t.apply(this,arguments),C.invert=A.invert&&R,T()}}function Fy(t){return function(A,j){var e=pt(A),r=pt(j),n=t(e*r);return[n*r*kt(A),n*kt(j)]}}function ys(t){return function(A,j){var e=ze(A*A+j*j),r=t(e),n=kt(r),i=pt(r);return[xr(A*n,e*i),tr(e&&j*n/e)]}}var iN=Fy(function(t){return ze(2/(1+t))});iN.invert=ys(function(t){return 2*tr(t/2)});var M1=Fy(function(t){return(t=py(t))&&t/kt(t)});M1.invert=ys(function(t){return t});function O1(){return Go(M1).scale(79.4188).clipAngle(180-.001)}function T1(t,A){return[t,Xk(zk((Ar+A)/2))]}T1.invert=function(t,A){return[t,2*qo(dy(A))-Ar]};function Py(t,A){return[t,A]}Py.invert=Py;function oN(t,A){var j=pt(A),e=pt(t)*j;return[j*kt(t)/e,kt(A)/e]}oN.invert=ys(qo);function sN(t,A){var j=A*A,e=j*j;return[t*(.8707-.131979*j+e*(-.013791+e*(.003971*j-.001529*e))),A*(1.007226+j*(.015085+e*(-.044475+.028874*j-.005916*e)))]}sN.invert=function(t,A){var j=A,e=25,r;do{var n=j*j,i=n*n;j-=r=(j*(1.007226+n*(.015085+i*(-.044475+.028874*n-.005916*i)))-A)/(1.007226+n*(.015085*3+i*(-.044475*7+.028874*9*n-.005916*11*i)))}while(ij(r)>xt&&--e>0);return[t/(.8707+(n=j*j)*(-.131979+n*(-.013791+n*n*n*(.003971-.001529*n)))),j]};function aN(t,A){return[pt(A)*kt(t),kt(A)]}aN.invert=ys(tr);function lN(t,A){var j=pt(A),e=1+pt(t)*j;return[j*kt(t)/e,kt(A)/e]}lN.invert=ys(function(t){return 2*qo(t)});function cN(t,A){return[Xk(zk((Ar+A)/2)),-t]}cN.invert=function(t,A){return[-A,2*qo(dy(t))-Ar]};function ClA(t,A,j){j=j||{};var e=j.units||"kilometers",r=j.steps||8;if(!t)throw new Error("geojson is required");if(typeof j!="object")throw new Error("options must be an object");if(typeof r!="number")throw new Error("steps must be an number");if(A===void 0)throw new Error("radius is required");if(r<=0)throw new Error("steps must be greater than 0");var n=[];switch(t.type){case"GeometryCollection":return m1(t,function(i){var o=Iy(i,A,e,r);o&&n.push(o)}),uy(n);case"FeatureCollection":return g1(t,function(i){var o=Iy(i,A,e,r);o&&g1(o,function(l){l&&n.push(l)})}),uy(n)}return Iy(t,A,e,r)}function Iy(t,A,j,e){var r=t.properties||{},n=t.type==="Feature"?t.geometry:t;if(n.type==="GeometryCollection"){var i=[];return m1(t,function(E){var m=Iy(E,A,j,e);m&&i.push(m)}),uy(i)}var o=HlA(n),l={type:n.type,coordinates:BN(n.coordinates,o)},c=new uf.GeoJSONReader,B=c.read(l),h=SD(RD(A,j),"meters"),d=uf.BufferOp.bufferOp(B,h,e),k=new uf.GeoJSONWriter;if(d=k.write(d),!uN(d.coordinates)){var g={type:d.type,coordinates:fN(d.coordinates,o)};return k1(g,r)}}function uN(t){return Array.isArray(t[0])?uN(t[0]):isNaN(t[0])}function BN(t,A){return typeof t[0]!="object"?A(t):t.map(function(j){return BN(j,A)})}function fN(t,A){return typeof t[0]!="object"?A.invert(t):t.map(function(j){return fN(j,A)})}function HlA(t){var A=Al(t).geometry.coordinates,j=[-A[0],-A[1]];return O1().rotate(j).scale(Dr)}var My=ClA;var kN=Qs(Oy(),1);var Hn=63710088e-1,ijt={centimeters:Hn*100,centimetres:Hn*100,degrees:Hn/111325,feet:Hn*3.28084,inches:Hn*39.37,kilometers:Hn/1e3,kilometres:Hn/1e3,meters:Hn,metres:Hn,miles:Hn/1609.344,millimeters:Hn*1e3,millimetres:Hn*1e3,nauticalmiles:Hn/1852,radians:1,yards:Hn*1.0936},ojt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Hn,yards:1.0936133};function hN(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function dN(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function KlA(t,A,j){j===void 0&&(j={});var e=C1(t),r=C1(A),n=t0(r[1]-e[1]),i=t0(r[0]-e[0]),o=t0(e[1]),l=t0(r[1]),c=Math.pow(Math.sin(n/2),2)+Math.pow(Math.sin(i/2),2)*Math.cos(o)*Math.cos(l);return gN(2*Math.atan2(Math.sqrt(c),Math.sqrt(1-c)),j.units)}var yt=KlA;var D1=Qs(EN(),1);var Kn=63710088e-1,VlA={centimeters:Kn*100,centimetres:Kn*100,degrees:Kn/111325,feet:Kn*3.28084,inches:Kn*39.37,kilometers:Kn/1e3,kilometres:Kn/1e3,meters:Kn,metres:Kn,miles:Kn/1609.344,millimeters:Kn*1e3,millimetres:Kn*1e3,nauticalmiles:Kn/1852,radians:1,yards:Kn*1.0936},Cjt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Kn,yards:1.0936133};function QlA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function $N(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!N1(t[0])||!N1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return QlA(e,A,j)}function xN(t,A){A===void 0&&(A="kilometers");var j=VlA[A];if(!j)throw new Error(A+" units is invalid");return t/j}function K1(t){var A=t%(2*Math.PI);return A*180/Math.PI}function Sy(t){var A=t%360;return A*Math.PI/180}function N1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function yN(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function yr(t,A,j,e){e===void 0&&(e={});var r=yN(t),n=Sy(r[0]),i=Sy(r[1]),o=Sy(j),l=xN(A,e.units),c=Math.asin(Math.sin(i)*Math.cos(l)+Math.cos(i)*Math.sin(l)*Math.cos(o)),B=n+Math.atan2(Math.sin(o)*Math.sin(l)*Math.cos(i),Math.cos(l)-Math.sin(i)*Math.sin(c)),h=K1(B),d=K1(c);return $N([h,d],e.properties)}var Xn=63710088e-1,Ujt={centimeters:Xn*100,centimetres:Xn*100,degrees:Xn/111325,feet:Xn*3.28084,inches:Xn*39.37,kilometers:Xn/1e3,kilometres:Xn/1e3,meters:Xn,metres:Xn,miles:Xn/1609.344,millimeters:Xn*1e3,millimetres:Xn*1e3,nauticalmiles:Xn/1852,radians:1,yards:Xn*1.0936},Vjt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Xn,yards:1.0936133};function vN(t){var A=t%(2*Math.PI);return A*180/Math.PI}function e0(t){var A=t%360;return A*Math.PI/180}function X1(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function Fj(t,A,j){if(j===void 0&&(j={}),j.final===!0)return WlA(t,A);var e=X1(t),r=X1(A),n=e0(e[0]),i=e0(r[0]),o=e0(e[1]),l=e0(r[1]),c=Math.sin(i-n)*Math.cos(l),B=Math.cos(o)*Math.sin(l)-Math.sin(o)*Math.cos(l)*Math.cos(i-n);return vN(Math.atan2(c,B))}function WlA(t,A){var j=Fj(A,t);return j=(j+180)%360,j}var zn=63710088e-1,_N={centimeters:zn*100,centimetres:zn*100,degrees:zn/111325,feet:zn*3.28084,inches:zn*39.37,kilometers:zn/1e3,kilometres:zn/1e3,meters:zn,metres:zn,miles:zn/1609.344,millimeters:zn*1e3,millimetres:zn*1e3,nauticalmiles:zn/1852,radians:1,yards:zn*1.0936},jet={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/zn,yards:1.0936133};function el(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function U1(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!z1(t[0])||!z1(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return el(e,A,j)}function Ry(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return el(e,A,j)}function YlA(t,A){A===void 0&&(A="kilometers");var j=_N[A];if(!j)throw new Error(A+" units is invalid");return t*j}function JlA(t,A){A===void 0&&(A="kilometers");var j=_N[A];if(!j)throw new Error(A+" units is invalid");return t/j}function qN(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return YlA(JlA(t,A),j)}function z1(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function V1(t,A,j){if(!t)throw new Error("No feature passed");if(!j)throw new Error(".featureOf() requires a name");if(!t||t.type!=="Feature"||!t.geometry)throw new Error("Invalid input to "+j+", Feature with geometry required");if(!t.geometry||t.geometry.type!==A)throw new Error("Invalid input to "+j+": must be a "+A+", given "+t.geometry.type)}function bN(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;yl||g>c||E>B){o=h,l=e,c=g,B=E,n=0;return}var m=Ry([o,h],j.properties);if(A(m,e,r,E,n)===!1)return!1;n++,o=h})===!1)return!1}}})}var Kr=63710088e-1,wN={centimeters:Kr*100,centimetres:Kr*100,degrees:Kr/111325,feet:Kr*3.28084,inches:Kr*39.37,kilometers:Kr/1e3,kilometres:Kr/1e3,meters:Kr,metres:Kr,miles:Kr/1609.344,millimeters:Kr*1e3,millimetres:Kr*1e3,nauticalmiles:Kr/1852,radians:1,yards:Kr*1.0936},aet={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Kr,yards:1.0936133};function tcA(t,A){A===void 0&&(A="kilometers");var j=wN[A];if(!j)throw new Error(A+" units is invalid");return t*j}function jcA(t,A){A===void 0&&(A="kilometers");var j=wN[A];if(!j)throw new Error(A+" units is invalid");return t/j}function FN(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return tcA(jcA(t,A),j)}function Q1(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function ecA(t,A,j){j===void 0&&(j={});var e=Q1(t),r=Q1(A);r[0]+=r[0]-e[0]>180?-360:e[0]-r[0]>180?360:0;var n=rcA(e,r),i=FN(n,"meters",j.units);return i}function rcA(t,A,j){j=j===void 0?Kr:Number(j);var e=j,r=t[1]*Math.PI/180,n=A[1]*Math.PI/180,i=n-r,o=Math.abs(A[0]-t[0])*Math.PI/180;o>Math.PI&&(o-=2*Math.PI);var l=Math.log(Math.tan(n/2+Math.PI/4)/Math.tan(r/2+Math.PI/4)),c=Math.abs(l)>1e-11?i/l:Math.cos(r),B=Math.sqrt(i*i+c*c*o*o),h=B*e;return h}var rl=ecA;function ncA(t,A,j){if(j===void 0&&(j={}),j.method||(j.method="geodesic"),j.units||(j.units="kilometers"),!t)throw new Error("pt is required");if(Array.isArray(t)?t=U1(t):t.type==="Point"?t=el(t):V1(t,"Point","point"),!A)throw new Error("line is required");Array.isArray(A)?A=Ry(A):A.type==="LineString"?A=el(A):V1(A,"LineString","line");var e=1/0,r=t.geometry.coordinates;return GN(A,function(n){var i=n.geometry.coordinates[0],o=n.geometry.coordinates[1],l=icA(r,i,o,j);lj?j:t}function ocA(t){return Math.log(t)*Math.LOG2E}var Ly=Math.log2||ocA;function wo(t,A){if(!t)throw new Error(A||"@math.gl/web-mercator: assertion failed.")}var Fo=Math.PI,MN=Fo/4,vs=Fo/180,J1=180/Fo,n0=512,IN=4003e4,df=85.051129,Z1=1.5;function Cy(t){return Math.pow(2,t)}function _s(t){let[A,j]=t;wo(Number.isFinite(A)),wo(Number.isFinite(j)&&j>=-90&&j<=90,"invalid latitude");let e=A*vs,r=j*vs,n=n0*(e+Fo)/(2*Fo),i=n0*(Fo+Math.log(Math.tan(MN+r*.5)))/(2*Fo);return[n,i]}function Po(t){let[A,j]=t,e=A/n0*(2*Fo)-Fo,r=2*(Math.atan(Math.exp(j/n0*(2*Fo)-Fo))-MN);return[e*J1,r*J1]}function AP(t){let{latitude:A,longitude:j,highPrecision:e=!1}=t;wo(Number.isFinite(A)&&Number.isFinite(j));let r=n0,n=Math.cos(A*vs),i=r/360,o=i/n,l=r/IN/n,c={unitsPerMeter:[l,l,l],metersPerUnit:[1/l,1/l,1/l],unitsPerDegree:[i,o,l],degreesPerUnit:[1/i,1/o,1/l]};if(e){let B=vs*Math.tan(A*vs)/n,h=i*B/2,d=r/IN*B,k=d/o*l;c.unitsPerDegree2=[0,h,d],c.unitsPerMeter2=[k,0,k]}return c}function tP(t){let{height:A,pitch:j,bearing:e,altitude:r,scale:n,center:i}=t,o=ff();Dk(o,o,[0,0,-r]),$D(o,o,-j*vs),xD(o,o,e*vs);let l=n/A;return oy(o,o,[l,l,l]),i&&Dk(o,o,kD([],i)),o}function ON(t){let{width:A,height:j,altitude:e,pitch:r=0,offset:n,center:i,scale:o,nearZMultiplier:l=1,farZMultiplier:c=1}=t,{fovy:B=hf(Z1)}=t;e!==void 0&&(B=hf(e));let h=B*vs,d=r*vs,k=Hy(B),g=k;i&&(g+=i[2]*o/Math.cos(d)/j);let E=h*(.5+(n?n[1]:0)/j),m=Math.sin(E)*g/Math.sin(r0(Math.PI/2-d-E,.01,Math.PI-.01)),y=Math.sin(d)*m+g,G=g*10,v=Math.min(y*c,G);return{fov:h,aspect:A/j,focalDistance:k,near:l,far:v}}function jP(t){let{fov:A,aspect:j,near:e,far:r}=ON(t);return yD([],A,j,e,r)}function hf(t){return 2*Math.atan(.5/t)*J1}function Hy(t){return .5/Math.tan(.5*t*vs)}function eP(t,A){let[j,e,r=0]=t;return wo(Number.isFinite(j)&&Number.isFinite(e)&&Number.isFinite(r)),nl(A,[j,e,r,1])}function Dy(t,A,j=0){let[e,r,n]=t;if(wo(Number.isFinite(e)&&Number.isFinite(r),"invalid pixel coordinate"),Number.isFinite(n))return nl(A,[e,r,n,1]);let i=nl(A,[e,r,0,1]),o=nl(A,[e,r,1,1]),l=i[2],c=o[2],B=l===c?0:((j||0)-l)/(c-l);return ny([],i,o,B)}function Ny(t){let{width:A,height:j,bounds:e,minExtent:r=0,maxZoom:n=24,offset:i=[0,0]}=t,[[o,l],[c,B]]=e,h=scA(t.padding),d=_s([o,r0(B,-df,df)]),k=_s([c,r0(l,-df,df)]),g=[Math.max(Math.abs(k[0]-d[0]),r),Math.max(Math.abs(k[1]-d[1]),r)],E=[A-h.left-h.right-Math.abs(i[0])*2,j-h.top-h.bottom-Math.abs(i[1])*2];wo(E[0]>0&&E[1]>0);let m=E[0]/g[0],y=E[1]/g[1],G=(h.right-h.left)/2/m,v=(h.top-h.bottom)/2/y,_=[(k[0]+d[0])/2+G,(k[1]+d[1])/2+v],w=Po(_),x=Math.min(n,Ly(Math.abs(Math.min(m,y))));return wo(Number.isFinite(x)),{longitude:w[0],latitude:w[1],zoom:x}}function scA(t=0){return typeof t=="number"?{top:t,bottom:t,left:t,right:t}:(wo(Number.isFinite(t.top)&&Number.isFinite(t.bottom)&&Number.isFinite(t.left)&&Number.isFinite(t.right)),t)}var TN=Math.PI/180;function Ky(t,A=0){let{width:j,height:e,unproject:r}=t,n={targetZ:A},i=r([0,e],n),o=r([j,e],n),l,c,B=t.fovy?.5*t.fovy*TN:Math.atan(.5/t.altitude),h=(90-t.pitch)*TN;return B>h-.01?(l=SN(t,0,A),c=SN(t,j,A)):(l=r([0,0],n),c=r([j,0],n)),[i,o,c,l]}function SN(t,A,j){let{pixelUnprojectionMatrix:e}=t,r=nl(e,[A,0,1,1]),n=nl(e,[A,t.height,1,1]),o=(j*t.distanceScales.unitsPerMeter[2]-r[2])/(n[2]-r[2]),l=ny([],r,n,o),c=Po(l);return c.push(j),c}var Mi=class t{constructor(A={width:1,height:1}){Ae(this,"latitude",void 0),Ae(this,"longitude",void 0),Ae(this,"zoom",void 0),Ae(this,"pitch",void 0),Ae(this,"bearing",void 0),Ae(this,"altitude",void 0),Ae(this,"fovy",void 0),Ae(this,"meterOffset",void 0),Ae(this,"center",void 0),Ae(this,"width",void 0),Ae(this,"height",void 0),Ae(this,"scale",void 0),Ae(this,"distanceScales",void 0),Ae(this,"viewMatrix",void 0),Ae(this,"projectionMatrix",void 0),Ae(this,"viewProjectionMatrix",void 0),Ae(this,"pixelProjectionMatrix",void 0),Ae(this,"pixelUnprojectionMatrix",void 0),Ae(this,"equals",y=>y instanceof t?y.width===this.width&&y.height===this.height&&u1(y.projectionMatrix,this.projectionMatrix)&&u1(y.viewMatrix,this.viewMatrix):!1),Ae(this,"project",(y,G={})=>{let{topLeft:v=!0}=G,_=this.projectPosition(y),w=eP(_,this.pixelProjectionMatrix),[x,O]=w,F=v?O:this.height-O;return y.length===2?[x,F]:[x,F,w[2]]}),Ae(this,"unproject",(y,G={})=>{let{topLeft:v=!0,targetZ:_=void 0}=G,[w,x,O]=y,F=v?x:this.height-x,C=_&&_*this.distanceScales.unitsPerMeter[2],R=Dy([w,F,O],this.pixelUnprojectionMatrix,C),[X,T,Q]=this.unprojectPosition(R);return Number.isFinite(O)?[X,T,Q]:Number.isFinite(_)?[X,T,_]:[X,T]}),Ae(this,"projectPosition",y=>{let[G,v]=_s(y),_=(y[2]||0)*this.distanceScales.unitsPerMeter[2];return[G,v,_]}),Ae(this,"unprojectPosition",y=>{let[G,v]=Po(y),_=(y[2]||0)*this.distanceScales.metersPerUnit[2];return[G,v,_]});let{width:j,height:e,altitude:r=null,fovy:n=null}=A,{latitude:i=0,longitude:o=0,zoom:l=0,pitch:c=0,bearing:B=0,position:h=null,nearZMultiplier:d=.02,farZMultiplier:k=1.01}=A;j=j||1,e=e||1,n===null&&r===null?(r=Z1,n=hf(r)):n===null?n=hf(r):r===null&&(r=Hy(n));let g=Cy(l);r=Math.max(.75,r);let E=AP({longitude:o,latitude:i}),m=_s([o,i]);m.push(0),h&&pD(m,m,gD([],h,E.unitsPerMeter)),this.projectionMatrix=jP({width:j,height:e,scale:g,center:m,pitch:c,fovy:n,nearZMultiplier:d,farZMultiplier:k}),this.viewMatrix=tP({height:e,scale:g,center:m,pitch:c,bearing:B,altitude:r}),this.width=j,this.height=e,this.scale=g,this.latitude=i,this.longitude=o,this.zoom=l,this.pitch=c,this.bearing=B,this.altitude=r,this.fovy=n,this.center=m,this.meterOffset=h||[0,0,0],this.distanceScales=E,this._initMatrices(),Object.freeze(this)}_initMatrices(){let{width:A,height:j,projectionMatrix:e,viewMatrix:r}=this,n=ff();iy(n,n,e),iy(n,n,r),this.viewProjectionMatrix=n;let i=ff();oy(i,i,[A/2,-j/2,1]),Dk(i,i,[1,-1,0]),iy(i,i,n);let o=ED(ff(),i);if(!o)throw new Error("Pixel project matrix not invertible");this.pixelProjectionMatrix=i,this.pixelUnprojectionMatrix=o}projectFlat(A){return _s(A)}unprojectFlat(A){return Po(A)}getMapCenterByLngLatPosition({lngLat:A,pos:j}){let e=Dy(j,this.pixelUnprojectionMatrix),r=_s(A),n=l1([],r,dD([],e)),i=l1([],this.center,n);return Po(i)}fitBounds(A,j={}){let{width:e,height:r}=this,{longitude:n,latitude:i,zoom:o}=Ny(Object.assign({width:e,height:r,bounds:A},j));return new t({width:e,height:r,longitude:n,latitude:i,zoom:o})}getBounds(A){let j=this.getBoundingRegion(A),e=Math.min(...j.map(o=>o[0])),r=Math.max(...j.map(o=>o[0])),n=Math.min(...j.map(o=>o[1])),i=Math.max(...j.map(o=>o[1]));return[[e,n],[r,i]]}getBoundingRegion(A={}){return Ky(this,A.z||0)}getLocationAtPoint({lngLat:A,pos:j}){return this.getMapCenterByLngLatPosition({lngLat:A,pos:j})}};function RN(t,A,j){let e=t.indexOf(A);return e<0?t:t.slice(0,e)+j+t.slice(e)}var pf=class extends b6{renderLayers(){let{id:A,getFillColor:j,getStrokeColor:e,getInnerRadius:r,updateTriggers:n}=this.props;return[new mr({...this.props,id:`${A}-full`,data:this.props.data,getLineColor:e,updateTriggers:{...n,getStrokeColor:n.getStrokeColor}}),new mr({...this.props,id:`${A}-inner`,data:this.props.data,getFillColor:j,getRadius:r,pickable:!1,updateTriggers:{...n,getFillColor:n.getFillColor,getRadius:n.getInnerRadius}})]}};I(pf,"layerName","JunctionScatterplotLayer"),I(pf,"defaultProps",{...mr.defaultProps,getFillColor:A=>[0,0,0,255],getStrokeColor:A=>[255,255,255,255],getInnerRadius:A=>1});var Xrt={[Hc.NONE]:{forward:!1,backward:!1},[Hc.FORWARD]:{forward:!0,backward:!1},[Hc.BACKWARD]:{forward:!1,backward:!0},[Hc.BOTH]:{forward:!0,backward:!0}};var NN=Qs(Oy(),1);var Un=63710088e-1,tnt={centimeters:Un*100,centimetres:Un*100,degrees:Un/111325,feet:Un*3.28084,inches:Un*39.37,kilometers:Un/1e3,kilometres:Un/1e3,meters:Un,metres:Un,miles:Un/1609.344,millimeters:Un*1e3,millimetres:Un*1e3,nauticalmiles:Un/1852,radians:1,yards:Un*1.0936},jnt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Un,yards:1.0936133};function CN(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function HN(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function qs(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function Uy(t){return t.type==="Feature"?t.geometry:t}function i0(t){for(var A=qs(t),j=0,e=1,r,n;e0}function o0(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y is required");if(typeof j!="boolean")throw new Error(" must be a boolean");if(typeof e!="boolean")throw new Error(" must be a boolean");e===!1&&(t=zy(t));var r=[];switch(t.type){case"GeometryCollection":return s0(t,function(n){Vy(n,j)}),t;case"FeatureCollection":return aP(t,function(n){aP(Vy(n,j),function(i){r.push(i)})}),Xa(r)}return Vy(t,j)}function Vy(t,A){var j=t.type==="Feature"?t.geometry.type:t.type;switch(j){case"GeometryCollection":return s0(t,function(e){Vy(e,A)}),t;case"LineString":return t3(qs(t),A),t;case"Polygon":return j3(qs(t),A),t;case"MultiLineString":return qs(t).forEach(function(e){t3(e,A)}),t;case"MultiPolygon":return qs(t).forEach(function(e){j3(e,A)}),t;case"Point":case"MultiPoint":return t}}function t3(t,A){i0(t)===A&&t.reverse()}function j3(t,A){i0(t[0])!==A&&t[0].reverse();for(var j=1;je.project([O,F,C])),[i,o]=e.project(A.geometry.coordinates),l=1/0,c={};n.forEach(([O,F],C)=>{if(C===0)return;let[R,X]=n[C-1],T=X-F,Q=O-R,b=R*F-O*X,jA=T*T+Q*Q,pA=Math.abs(T*i+Q*o+b)/Math.sqrt(jA);pA{let i=qs(n),o=qs(A),l,c,B,h,d,k,g;if(i.length>1&&o.length){let m,y;e?(m=i.map(_=>e.project(_)),y=e.project(o)):(m=i,y=o);for(let _=1;_w&&(g=Math.sqrt(Math.min(x,O))),(l==null||l>g)&&(C>w?Oj.properties.editHandleType==="snap-source")}function o3(t){return t&&t.filter(A=>!A.isGuide)}function uP(t){return Io(t).find(({properties:j})=>j.featureIndex>=0&&j.editHandleType==="existing")}function a0(t){return Io(t).find(({properties:j})=>j.featureIndex>=0&&j.editHandleType==="intermediate")}function Io(t){return t&&t.filter(j=>j.isGuide&&j.object.properties.guideType==="editHandle").map(j=>j.object)||[]}function il(t,A,j="existing"){let e=[];switch(t.type){case"Point":e=[{type:"Feature",properties:{guideType:"editHandle",editHandleType:j,positionIndexes:[],featureIndex:A},geometry:{type:"Point",coordinates:t.coordinates}}];break;case"MultiPoint":case"LineString":e=e.concat(lP(t.coordinates,[],A,j));break;case"Polygon":case"MultiLineString":for(let r=0;rl0(j,A)).filter(Boolean)}var Pj=class t{constructor(A){I(this,"featureCollection");this.featureCollection=A}getObject(){return this.featureCollection}replacePosition(A,j,e){let r=this.featureCollection.features[A].geometry,n=r.type==="Polygon"||r.type==="MultiPolygon",i={...r,coordinates:a3(r.coordinates,j,e,n)};return this.replaceGeometry(A,i)}removePosition(A,j){let e=this.featureCollection.features[A].geometry;if(e.type==="Point")throw Error("Can't remove a position from a Point or there'd be nothing left");if(e.type==="MultiPoint"&&e.coordinates.length<2)throw Error("Can't remove the last point of a MultiPoint or there'd be nothing left");if(e.type==="LineString"&&e.coordinates.length<3)throw Error("Can't remove position. LineString must have at least two positions");if(e.type==="Polygon"&&e.coordinates[0].length<5&&Array.isArray(j)&&j[0]===0)throw Error("Can't remove position. Polygon's outer ring must have at least four positions");if(e.type==="MultiLineString"&&e.coordinates.length===1&&e.coordinates[0].length<3)throw Error("Can't remove position. MultiLineString must have at least two positions");if(e.type==="MultiPolygon"&&e.coordinates.length===1&&e.coordinates[0][0].length<5&&Array.isArray(j)&&j[0]===0&&j[1]===0)throw Error("Can't remove position. MultiPolygon's outer ring must have at least four positions");let r=e.type==="Polygon"||e.type==="MultiPolygon",n={...e,coordinates:l3(e.coordinates,j,r)};return gcA(n),this.replaceGeometry(A,n)}addPosition(A,j,e){let r=this.featureCollection.features[A].geometry;if(r.type==="Point")throw new Error("Unable to add a position to a Point feature");let n=r.type==="Polygon"||r.type==="MultiPolygon",i={...r,coordinates:c3(r.coordinates,j,e,n)};return this.replaceGeometry(A,i)}replaceGeometry(A,j){let e={...this.featureCollection.features[A],geometry:j},r={...this.featureCollection,features:[...this.featureCollection.features.slice(0,A),e,...this.featureCollection.features.slice(A+1)]};return new t(r)}addFeature(A){return this.addFeatures([A])}addFeatures(A){let j={...this.featureCollection,features:[...this.featureCollection.features,...A]};return new t(j)}deleteFeature(A){return this.deleteFeatures([A])}deleteFeatures(A){let j=[...this.featureCollection.features];A.sort();for(let r=A.length-1;r>=0;r--){let n=A[r];n>=0&&nj[r])}}getClickSequence(){return this._clickSequence}addClickSequence({mapCoords:A}){this._clickSequence.push(A)}resetClickSequence(){this._clickSequence=[]}getTentativeGuide(A){return this.getGuides(A).features.find(e=>e.properties&&e.properties.guideType==="tentative")}isSelectionPicked(A,j){if(!A.length)return!1;let e=o3(A).map(({index:i})=>i),r=Io(A).map(({properties:i})=>i.featureIndex),n=new Set([...e,...r]);return j.selectedIndexes.some(i=>n.has(i))}rewindPolygon(A){let{geometry:j}=A;return j.type==="Polygon"||j.type==="MultiPolygon"?e3(A):A}getAddFeatureAction(A,j){let e=A,r=e.type==="Feature"?e:{type:"Feature",properties:{},geometry:e},n=this.rewindPolygon(r),i=new Pj(j).addFeature(n).getObject();return{updatedData:i,editType:"addFeature",editContext:{featureIndexes:[i.features.length-1]}}}getAddManyFeaturesAction({features:A},j){let e=new Pj(j),r=e.getObject().features.length,n=[];for(let i of A){let{properties:o,geometry:l}=i,c=l;e=e.addFeature({type:"Feature",properties:o,geometry:c}),n.push(r+n.length)}return{updatedData:e.getObject(),editType:"addFeature",editContext:{featureIndexes:n}}}getAddFeatureOrBooleanPolygonAction(A,j){let e=A,r=this.getSelectedFeature(j),{modeConfig:n}=j;if(n&&n.booleanOperation){if(!r||r.geometry.type!=="Polygon"&&r.geometry.type!=="MultiPolygon")return console.warn("booleanOperation only supported for single Polygon or MultiPolygon selection"),null;let i=e.type==="Feature"?e:{type:"Feature",geometry:e},o;if(n.booleanOperation==="union")o=KN(r,i);else if(n.booleanOperation==="difference")o=Bf(r,i);else if(n.booleanOperation==="intersection")o=oP(r,i);else return console.warn(`Invalid booleanOperation ${n.booleanOperation}`),null;if(!o)return console.warn("Canceling edit. Boolean operation erased entire polygon."),null;let l=j.selectedIndexes[0];return{updatedData:new Pj(j.data).replaceGeometry(l,o.geometry).getObject(),editType:"unionGeometry",editContext:{featureIndexes:[l]}}}return this.getAddFeatureAction(A,j.data)}createTentativeFeature(A){return null}handleClick(A,j){}handlePointerMove(A,j){let e=this.createTentativeFeature(j);e&&j.onEdit({updatedData:j.data,editType:"updateTentativeFeature",editContext:{feature:e}})}handleStartDragging(A,j){}handleStopDragging(A,j){}handleDragging(A,j){}handleKeyUp(A,j){A.key==="Escape"&&(this.resetClickSequence(),j.onEdit({updatedData:j.data,editType:"cancelFeature",editContext:{}}))}};function ol(t,A){return[(t[0]+A[0])/2,(t[1]+A[1])/2]}var Xr=class extends Zt{};var Qn=63710088e-1,Jnt={centimeters:Qn*100,centimetres:Qn*100,degrees:Qn/111325,feet:Qn*3.28084,inches:Qn*39.37,kilometers:Qn/1e3,kilometres:Qn/1e3,meters:Qn,metres:Qn,miles:Qn/1609.344,millimeters:Qn*1e3,millimetres:Qn*1e3,nauticalmiles:Qn/1852,radians:1,yards:Qn*1.0936},Znt={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Qn,yards:1.0936133};function B3(t){var A=t%(2*Math.PI);return A*180/Math.PI}function Yy(t){var A=t%360;return A*Math.PI/180}function c0(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function vcA(t,A,j){j===void 0&&(j={});var e;j.final?e=f3(c0(A),c0(t)):e=f3(c0(t),c0(A));var r=e>180?-(360-e):e;return r}function f3(t,A){var j=Yy(t[1]),e=Yy(A[1]),r=Yy(A[0]-t[0]);r>Math.PI&&(r-=2*Math.PI),r<-Math.PI&&(r+=2*Math.PI);var n=Math.log(Math.tan(e/2+Math.PI/4)/Math.tan(j/2+Math.PI/4)),i=Math.atan2(r,n);return(B3(i)+360)%360}var kf=vcA;var zr=63710088e-1,h3={centimeters:zr*100,centimetres:zr*100,degrees:zr/111325,feet:zr*3.28084,inches:zr*39.37,kilometers:zr/1e3,kilometres:zr/1e3,meters:zr,metres:zr,miles:zr/1609.344,millimeters:zr*1e3,millimetres:zr*1e3,nauticalmiles:zr/1852,radians:1,yards:zr*1.0936},o6t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/zr,yards:1.0936133};function _cA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function d3(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!BP(t[0])||!BP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return _cA(e,A,j)}function qcA(t,A){A===void 0&&(A="kilometers");var j=h3[A];if(!j)throw new Error(A+" units is invalid");return t*j}function bcA(t,A){A===void 0&&(A="kilometers");var j=h3[A];if(!j)throw new Error(A+" units is invalid");return t/j}function fP(t){var A=t%360;return A*Math.PI/180}function p3(t,A,j){if(A===void 0&&(A="kilometers"),j===void 0&&(j="kilometers"),!(t>=0))throw new Error("length must be a positive number");return qcA(bcA(t,A),j)}function BP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function k3(t){if(!t)throw new Error("coord is required");if(!Array.isArray(t)){if(t.type==="Feature"&&t.geometry!==null&&t.geometry.type==="Point")return t.geometry.coordinates;if(t.type==="Point")return t.coordinates}if(Array.isArray(t)&&t.length>=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function GcA(t,A,j,e){e===void 0&&(e={});var r=A<0,n=p3(Math.abs(A),e.units,"meters");r&&(n=-Math.abs(n));var i=k3(t),o=wcA(i,n,j);return o[0]+=o[0]-i[0]>180?-360:i[0]-o[0]>180?360:0,d3(o,e.properties)}function wcA(t,A,j,e){e=e===void 0?zr:Number(e);var r=A/e,n=t[0]*Math.PI/180,i=fP(t[1]),o=fP(j),l=r*Math.cos(o),c=i+l;Math.abs(c)>Math.PI/2&&(c=c>0?Math.PI-c:-Math.PI-c);var B=Math.log(Math.tan(c/2+Math.PI/4)/Math.tan(i/2+Math.PI/4)),h=Math.abs(B)>1e-11?l/B:Math.cos(i),d=r*Math.sin(o)/h,k=n+d;return[(k*180/Math.PI+540)%360-180,c*180/Math.PI]}var bs=GcA;function g3(t,A,j){let e=Al(t),r=bs(e,A,j),n=l0(t.geometry.coordinates,i=>{let o=rl(e.geometry.coordinates,i),l=kf(e.geometry.coordinates,i);return bs(r.geometry.coordinates,o,l).geometry.coordinates});return t.geometry.coordinates=n,t}var Gs=class extends Zt{constructor(){super(...arguments);I(this,"_geometryBeforeTranslate");I(this,"_isTranslatable")}handleDragging(j,e){if(this._isTranslatable){if(this._geometryBeforeTranslate){let r=this.getTranslateAction(j.pointerDownMapCoords,j.mapCoords,"translating",e);r&&e.onEdit(r)}j.cancelPan()}}handlePointerMove(j,e){this._isTranslatable=this.isSelectionPicked(j.pointerDownPicks||j.picks,e),this.updateCursor(e)}handleStartDragging(j,e){this._isTranslatable&&(this._geometryBeforeTranslate=this.getSelectedFeaturesAsFeatureCollection(e))}handleStopDragging(j,e){if(this._geometryBeforeTranslate){let r=this.getTranslateAction(j.pointerDownMapCoords,j.mapCoords,"translated",e);r&&e.onEdit(r),this._geometryBeforeTranslate=null}}updateCursor(j){this._isTranslatable?j.onUpdateCursor("move"):j.onUpdateCursor(null)}getTranslateAction(j,e,r,n){if(!this._geometryBeforeTranslate)return null;let i=new Pj(n.data),o=n.selectedIndexes,{viewport:l,screenSpace:c}=n.modeConfig||{};if(l&&c){let B=l.project?l:new Mi(l),h=B.project(j),d=B.project(e),k=d[0]-h[0],g=d[1]-h[1];for(let E=0;E{let _=B.project(v);return _?(_[0]+=k,_[1]+=g,B.unproject(_)):null}),i=i.replaceGeometry(m,{type:y.geometry.type,coordinates:G}))}}else{let B=Vt(j),h=Vt(e),d=yt(B,h),k=Fj(B,h),g=this._geometryBeforeTranslate.features.map(E=>g3(zy(E),d,k));for(let E=0;E!B.isGuide);if(c&&!c.object.geometry.type.includes("Point")&&!(A.modeConfig?.lockRectangles&&c.object.properties.shape==="Rectangle")&&A.selectedIndexes.includes(c.index)){let B=null,h=[],d=Vt(o);if(Qy(c.object.geometry.coordinates,[],(k,g)=>{let E=$r(k),m=this.getNearestPoint(E,d,A.modeConfig&&A.modeConfig.viewport);(!B||m.properties.distn.length>2)){if(e)return cP(A,j,e);console.log("Editing 3D point but modeConfig.viewport not provided. Falling back to 2D logic.")}return n3(A,j,e)}handleClick(A,j){let e=uP(A.picks),r=a0(A.picks);if(e){let{featureIndex:n,positionIndexes:i}=e.properties,o;try{o=new Pj(j.data).removePosition(n,i).getObject()}catch{}o&&j.onEdit({updatedData:o,editType:"removePosition",editContext:{featureIndexes:[n],positionIndexes:i,position:e.geometry.coordinates}})}else if(r){let{featureIndex:n,positionIndexes:i}=r.properties,o=j.data.features[n];if(!(j.modeConfig?.lockRectangles&&o?.properties.shape==="Rectangle")){let c=new Pj(j.data).addPosition(n,i,r.geometry.coordinates).getObject();c&&j.onEdit({updatedData:c,editType:"addPosition",editContext:{featureIndexes:[n],positionIndexes:i,position:r.geometry.coordinates}})}}}handleDragging(A,j){let e=te(A.pointerDownPicks);e&&(A.cancelPan(),this._dragEditHandle("movePosition",j,e,A))}_dragEditHandle(A,j,e,r){let n=e.properties,i=j.data.features[n.featureIndex],o;if(j.modeConfig?.lockRectangles&&i.properties.shape==="Rectangle"){let l=s3(i,n.positionIndexes[1],r.mapCoords);o=new Pj(j.data).replaceGeometry(n.featureIndex,{coordinates:l,type:"Polygon"}).getObject()}else o=new Pj(j.data).replacePosition(n.featureIndex,n.positionIndexes,r.mapCoords).getObject();j.onEdit({updatedData:o,editType:A,editContext:{featureIndexes:[n.featureIndex],positionIndexes:n.positionIndexes,position:r.mapCoords}})}handlePointerMove(A,j){let e=this.getCursor(A);j.onUpdateCursor(e)}handleStartDragging(A,j){let e=j.selectedIndexes,r=a0(A.picks);if(e.length&&r){let n=r.properties,i=new Pj(j.data).addPosition(n.featureIndex,n.positionIndexes,A.mapCoords).getObject();j.onEdit({updatedData:i,editType:"addPosition",editContext:{featureIndexes:[n.featureIndex],positionIndexes:n.positionIndexes,position:A.mapCoords}})}}handleStopDragging(A,j){let e=j.selectedIndexes,r=te(A.picks);e.length&&r&&this._dragEditHandle("finishMovePosition",j,r,A)}getCursor(A){let j=A&&A.picks||[];return Io(j).length?"cell":null}};var Wn=63710088e-1,T6t={centimeters:Wn*100,centimetres:Wn*100,degrees:Wn/111325,feet:Wn*3.28084,inches:Wn*39.37,kilometers:Wn/1e3,kilometres:Wn/1e3,meters:Wn,metres:Wn,miles:Wn/1609.344,millimeters:Wn*1e3,millimetres:Wn*1e3,nauticalmiles:Wn/1852,radians:1,yards:Wn*1.0936},S6t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Wn,yards:1.0936133};function E3(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function hP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!m3(t[0])||!m3(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return E3(e,A,j)}function m3(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function dP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y1?v3(t,A):x3(t[0],A)}function McA(t){if(!t)throw new Error("geojson is required");switch(t.type){case"Feature":return q3(t);case"FeatureCollection":return OcA(t);case"Point":case"LineString":case"Polygon":case"MultiPoint":case"MultiLineString":case"MultiPolygon":case"GeometryCollection":return pP(t);default:throw new Error("unknown GeoJSON type")}}function q3(t){var A={type:"Feature"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"properties":case"geometry":return;default:A[j]=t[j]}}),A.properties=b3(t.properties),A.geometry=pP(t.geometry),A}function b3(t){var A={};return t&&Object.keys(t).forEach(function(j){var e=t[j];typeof e=="object"?e===null?A[j]=null:Array.isArray(e)?A[j]=e.map(function(r){return r}):A[j]=b3(e):A[j]=e}),A}function OcA(t){var A={type:"FeatureCollection"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"features":return;default:A[j]=t[j]}}),A.features=t.features.map(function(j){return q3(j)}),A}function pP(t){var A={type:t.type};return t.bbox&&(A.bbox=t.bbox),t.type==="GeometryCollection"?(A.geometries=t.geometries.map(function(j){return pP(j)}),A):(A.coordinates=G3(t.coordinates),A)}function G3(t){var A=t;return typeof A[0]!="object"?A.slice():A.map(function(j){return G3(j)})}var w3=McA;var Jn=63710088e-1,jit={centimeters:Jn*100,centimetres:Jn*100,degrees:Jn/111325,feet:Jn*3.28084,inches:Jn*39.37,kilometers:Jn/1e3,kilometres:Jn/1e3,meters:Jn,metres:Jn,miles:Jn/1609.344,millimeters:Jn*1e3,millimetres:Jn*1e3,nauticalmiles:Jn/1852,radians:1,yards:Jn*1.0936},eit={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Jn,yards:1.0936133};function F3(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function mf(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!kP(t[0])||!kP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return F3(e,A,j)}function kP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function gP(t){return!!t&&t.constructor===Object}function mP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function M3(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function O3(t,A){return t.type==="FeatureCollection"?"FeatureCollection":t.type==="GeometryCollection"?"GeometryCollection":t.type==="Feature"&&t.geometry!==null?t.geometry.type:t.type}function TcA(t,A,j){if(j=j||{},!gP(j))throw new Error("options is invalid");var e=j.origin,r=j.mutate;if(!t)throw new Error("geojson required");if(typeof A!="number"||A===0)throw new Error("invalid factor");var n=Array.isArray(e)||typeof e=="object";return r!==!0&&(t=w3(t)),t.type==="FeatureCollection"&&!n?(P3(t,function(i,o){t.features[o]=T3(i,A,e)}),t):T3(t,A,e)}function T3(t,A,j){var e=O3(t)==="Point";return j=ScA(t,j),A===1||e||mP(t,function(r){var n=rl(j,r),i=kf(j,r),o=n*A,l=M3(bs(j,o,i));r[0]=l[0],r[1]=l[1],r.length===3&&(r[2]*=A)}),t}function ScA(t,A){if(A==null&&(A="centroid"),Array.isArray(A)||typeof A=="object")return I3(A);var j=t.bbox?t.bbox:za(t),e=j[0],r=j[1],n=j[2],i=j[3];switch(A){case"sw":case"southwest":case"westsouth":case"bottomleft":return mf([e,r]);case"se":case"southeast":case"eastsouth":case"bottomright":return mf([n,r]);case"nw":case"northwest":case"westnorth":case"topleft":return mf([e,i]);case"ne":case"northeast":case"eastnorth":case"topright":return mf([n,i]);case"center":return Al(t);case void 0:case null:case"centroid":return ws(t);default:throw new Error("invalid origin")}}var S3=TcA;var Va=class extends Zt{constructor(){super(...arguments);I(this,"_geometryBeingScaled");I(this,"_selectedEditHandle");I(this,"_cornerGuidePoints",[]);I(this,"_cursor");I(this,"_isScaling",!1);I(this,"_isSinglePointGeometrySelected",j=>{let{features:e}=j||{};if(Array.isArray(e)&&e.length===1){let{type:r}=Uy(e[0]);return r==="Point"}return!1});I(this,"_getOppositeScaleHandle",j=>{let e=j&&j.properties&&Array.isArray(j.properties.positionIndexes)&&j.properties.positionIndexes[0];if(typeof e!="number")return null;let r=this._cornerGuidePoints.length,n=(e+r/2)%r;return this._cornerGuidePoints.find(i=>Array.isArray(i.properties.positionIndexes)?i.properties.positionIndexes[0]===n:!1)||null});I(this,"_getUpdatedData",(j,e)=>{let r=new Pj(j.data),n=j.selectedIndexes;for(let i=0;i!!this._selectedEditHandle);I(this,"getScaleAction",(j,e,r,n)=>{if(!this._selectedEditHandle)return null;let i=this._getOppositeScaleHandle(this._selectedEditHandle),o=JN(i),l=RcA(o,j,e),c=S3(this._geometryBeingScaled,l,{origin:o});return{updatedData:this._getUpdatedData(n,c),editType:r,editContext:{featureIndexes:n.selectedIndexes}}});I(this,"updateCursor",j=>{if(this._selectedEditHandle){this._cursor&&j.onUpdateCursor(this._cursor);let e=this.getSelectedFeaturesAsFeatureCollection(j),r=ws(e),n=Fj(r,this._selectedEditHandle),i=n<0?n+180:n;i>=0&&i<=90||i>=180&&i<=270?(this._cursor="nesw-resize",j.onUpdateCursor("nesw-resize")):(this._cursor="nwse-resize",j.onUpdateCursor("nwse-resize"))}else j.onUpdateCursor(null),this._cursor=null})}handlePointerMove(j,e){if(!this._isScaling){let r=te(j.picks);this._selectedEditHandle=r&&r.properties.editHandleType==="scale"?r:null,this.updateCursor(e)}}handleStartDragging(j,e){this._selectedEditHandle&&(this._isScaling=!0,this._geometryBeingScaled=this.getSelectedFeaturesAsFeatureCollection(e))}handleDragging(j,e){if(!this._isScaling)return;e.onUpdateCursor(this._cursor);let r=this.getScaleAction(j.pointerDownMapCoords,j.mapCoords,"scaling",e);r&&e.onEdit(r),j.cancelPan()}handleStopDragging(j,e){if(this._isScaling){let r=this.getScaleAction(j.pointerDownMapCoords,j.mapCoords,"scaled",e);r&&e.onEdit(r),e.onUpdateCursor(null),this._geometryBeingScaled=null,this._selectedEditHandle=null,this._cursor=null,this._isScaling=!1}}getGuides(j){this._cornerGuidePoints=[];let e=this.getSelectedFeaturesAsFeatureCollection(j);if(this._isSinglePointGeometrySelected(e))return{type:"FeatureCollection",features:[]};let r=Bn(za(e));r.properties.mode="scale";let n=[];return o0(r,(i,o)=>{if(o<4){let l=Vt(i,{guideType:"editHandle",editHandleType:"scale",positionIndexes:[o]});n.push(l)}}),this._cornerGuidePoints=n,Xa([gf(r),...this._cornerGuidePoints])}};function RcA(t,A,j){let e=yt(t,A);return yt(t,j)/e}function LcA(t){if(!t)throw new Error("geojson is required");switch(t.type){case"Feature":return R3(t);case"FeatureCollection":return CcA(t);case"Point":case"LineString":case"Polygon":case"MultiPoint":case"MultiLineString":case"MultiPolygon":case"GeometryCollection":return EP(t);default:throw new Error("unknown GeoJSON type")}}function R3(t){var A={type:"Feature"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"properties":case"geometry":return;default:A[j]=t[j]}}),A.properties=L3(t.properties),A.geometry=EP(t.geometry),A}function L3(t){var A={};return t&&Object.keys(t).forEach(function(j){var e=t[j];typeof e=="object"?e===null?A[j]=null:Array.isArray(e)?A[j]=e.map(function(r){return r}):A[j]=L3(e):A[j]=e}),A}function CcA(t){var A={type:"FeatureCollection"};return Object.keys(t).forEach(function(j){switch(j){case"type":case"features":return;default:A[j]=t[j]}}),A.features=t.features.map(function(j){return R3(j)}),A}function EP(t){var A={type:t.type};return t.bbox&&(A.bbox=t.bbox),t.type==="GeometryCollection"?(A.geometries=t.geometries.map(function(j){return EP(j)}),A):(A.coordinates=C3(t.coordinates),A)}function C3(t){var A=t;return typeof A[0]!="object"?A.slice():A.map(function(j){return C3(j)})}var H3=LcA;var Zn=63710088e-1,Sit={centimeters:Zn*100,centimetres:Zn*100,degrees:Zn/111325,feet:Zn*3.28084,inches:Zn*39.37,kilometers:Zn/1e3,kilometres:Zn/1e3,meters:Zn,metres:Zn,miles:Zn/1609.344,millimeters:Zn*1e3,millimetres:Zn*1e3,nauticalmiles:Zn/1852,radians:1,yards:Zn*1.0936},Rit={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/Zn,yards:1.0936133};function $P(t){return!!t&&t.constructor===Object}function xP(t,A,j){if(t!==null)for(var e,r,n,i,o,l,c,B=0,h=0,d,k=t.type,g=k==="FeatureCollection",E=k==="Feature",m=g?t.features.length:1,y=0;y{let{features:e}=j||{};if(Array.isArray(e)&&e.length===1){let{type:r}=Uy(e[0]);return r==="Point"}return!1});I(this,"getIsRotating",()=>this._isRotating)}getGuides(j){let e=this._geometryBeingRotated||this.getSelectedFeaturesAsFeatureCollection(j);if(this._isSinglePointGeometrySelected(e))return{type:"FeatureCollection",features:[]};if(this._isRotating)return Xa([ws(e)]);let r=Bn(za(e)),n=null,i=null,o=0;o0(r,d=>{if(n){let k=ol(d,n);(!i||k[1]>i[1])&&(i=k);let g=yt(d,n);o=Math.max(o,g)}n=d});let l=i&&[i[0],i[1]+o/1e3],c=$r([i,l]),B=Vt(l,{guideType:"editHandle",editHandleType:"rotate"}),h=[gf(r),B,c];return Xa(h)}handleDragging(j,e){if(!this._isRotating)return;let r=this.getRotateAction(j.pointerDownMapCoords,j.mapCoords,"rotating",e);r&&e.onEdit(r),j.cancelPan()}handlePointerMove(j,e){if(!this._isRotating){let r=te(j.picks);this._selectedEditHandle=r&&r.properties.editHandleType==="rotate"?r:null}this.updateCursor(e)}handleStartDragging(j,e){this._selectedEditHandle&&(this._isRotating=!0,this._geometryBeingRotated=this.getSelectedFeaturesAsFeatureCollection(e))}handleStopDragging(j,e){if(this._isRotating){let r=this.getRotateAction(j.pointerDownMapCoords,j.mapCoords,"rotated",e);r&&e.onEdit(r),this._geometryBeingRotated=null,this._selectedEditHandle=null,this._isRotating=!1}}updateCursor(j){this._selectedEditHandle?j.onUpdateCursor("crosshair"):j.onUpdateCursor(null)}getRotateAction(j,e,r,n){if(!this._geometryBeingRotated)return null;let i=ws(this._geometryBeingRotated),o=DcA(i,j,e),l=Zy(this._geometryBeingRotated,o,{pivot:i}),c=new Pj(n.data),B=n.selectedIndexes;for(let h=0;h=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function K3(t){return t.type==="Feature"?t.geometry:t}function yP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("point is required");if(!A)throw new Error("polygon is required");var e=N3(t),r=K3(A),n=r.type,i=A.bbox,o=r.coordinates;if(i&&NcA(e,i)===!1)return!1;n==="Polygon"&&(o=[o]);for(var l=!1,c=0;ct[1]!=c>t[1]&&t[0]<(l-i)*(t[1]-o)/(c-o)+i;h&&(e=!e)}return e}function NcA(t,A){return A[0]<=t[0]&&A[1]<=t[1]&&A[2]>=t[0]&&A[3]>=t[1]}var t6=63710088e-1,bot={centimeters:t6*100,centimetres:t6*100,degrees:t6/111325,feet:t6*3.28084,inches:t6*39.37,kilometers:t6/1e3,kilometres:t6/1e3,meters:t6,metres:t6,miles:t6/1609.344,millimeters:t6*1e3,millimetres:t6*1e3,nauticalmiles:t6/1852,radians:1,yards:t6*1.0936},Got={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/t6,yards:1.0936133};function B0(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function _P(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!vP(t[0])||!vP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return B0(e,A,j)}function qP(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function vP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function Av(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}var j6=63710088e-1,Iot={centimeters:j6*100,centimetres:j6*100,degrees:j6/111325,feet:j6*3.28084,inches:j6*39.37,kilometers:j6/1e3,kilometres:j6/1e3,meters:j6,metres:j6,miles:j6/1609.344,millimeters:j6*1e3,millimetres:j6*1e3,nauticalmiles:j6/1852,radians:1,yards:j6*1.0936},Mot={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/j6,yards:1.0936133};function tv(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function bP(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return tv(e,A,j)}function z3(t,A){A===void 0&&(A={});var j={type:"FeatureCollection"};return A.id&&(j.id=A.id),A.bbox&&(j.bbox=A.bbox),j.features=t,j}function GP(t){if(Array.isArray(t))return t;if(t.type==="Feature"){if(t.geometry!==null)return t.geometry.coordinates}else if(t.coordinates)return t.coordinates;throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array")}function KcA(t,A){var j,e,r,n,i,o,l,c,B,h,d=0,k=t.type==="FeatureCollection",g=t.type==="Feature",E=k?t.features.length:1;for(j=0;jr?j:r,c=e>n?e:n;return[i,o,l,c]}var wP=XcA;function FP(t,A){if(t.type==="Feature")A(t,0);else if(t.type==="FeatureCollection")for(var j=0;j line1 must only contain 2 coordinates");if(e.length!==2)throw new Error(" line2 must only contain 2 coordinates");var r=j[0][0],n=j[0][1],i=j[1][0],o=j[1][1],l=e[0][0],c=e[0][1],B=e[1][0],h=e[1][1],d=(h-c)*(i-r)-(B-l)*(o-n),k=(B-l)*(n-c)-(h-c)*(r-l),g=(i-r)*(n-c)-(o-n)*(r-l);if(d===0)return null;var E=k/d,m=g/d;if(E>=0&&E<=1&&m>=0&&m<=1){var y=r+E*(i-r),G=n+E*(o-n);return _P([y,G])}return null}var ll=XuA;var e6=63710088e-1,lst={centimeters:e6*100,centimetres:e6*100,degrees:e6/111325,feet:e6*3.28084,inches:e6*39.37,kilometers:e6/1e3,kilometres:e6/1e3,meters:e6,metres:e6,miles:e6/1609.344,millimeters:e6*1e3,millimetres:e6*1e3,nauticalmiles:e6/1852,radians:1,yards:e6*1.0936},cst={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/e6,yards:1.0936133};function d0(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function p0(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!VP(t[0])||!VP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return d0(e,A,j)}function sv(t,A,j){if(j===void 0&&(j={}),t.length<2)throw new Error("coordinates must be an array of two or more positions");var e={type:"LineString",coordinates:t};return d0(e,A,j)}function VP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function zuA(t,A){var j,e,r,n,i,o,l,c,B,h,d=0,k=t.type==="FeatureCollection",g=t.type==="Feature",E=k?t.features.length:1;for(j=0;j0&&(m=E.features[0],m.properties.dist=yt(A,m,j),m.properties.location=r+yt(l,m,j)),l.properties.dist{let E=av(g,l),m=yt(E,l);d>m&&(d=m,k=E)}),k){let g=Fj(l,k),E=yt(l,j,{units:"meters"});return yr(l,E,g,{units:"meters"}).geometry.coordinates}return j}let n=A[A.length-1],[i]=Ua(A[A.length-2],n,j);return av($r([n,i]),j).geometry.coordinates}getGuides(A){let j=this.getClickSequence(),e={type:"FeatureCollection",features:[]};if(j.length===0||!A.lastPointerMoveEvent)return e;let{mapCoords:r}=A.lastPointerMoveEvent;return e.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...j,this.calculateMapCoords(j,r,A)]}}),e}handleClick(A,j){let e=this.getTentativeGuide(j),r=this.getSelectedGeometry(j);if(!r){console.warn("A polygon must be selected for splitting");return}let n=this.getClickSequence();e&&e.geometry.type==="LineString"?n.push(e.geometry.coordinates[e.geometry.coordinates.length-1]):this.addClickSequence(A);let i={type:"Point",coordinates:n[n.length-1]},o=yP(i,r);if(n.length>1&&e&&!o){if(this.resetClickSequence(),ll(e,r).features.length===0)return;let c=this.splitPolygon(e,j);c&&j.onEdit(c)}}handlePointerMove(A,j){j.onUpdateCursor("cell")}splitPolygon(A,j){let e=this.getSelectedGeometry(j),r=j.selectedIndexes[0],n=j.modeConfig||{},{gap:i=.1,units:o="centimeters"}=n;i===0&&(i=.1,o="centimeters");let l=My(A,i,{units:o}),c=Bf(e,l);if(!c)return console.warn("Canceling edit. Split Polygon erased"),null;let{type:B,coordinates:h}=c.geometry,d=[];return B==="Polygon"?d=h.map(E=>[E]):d=h.reduce((E,m)=>(m.forEach(y=>{E.push([y])}),E),[]),{updatedData:new Pj(j.data).replaceGeometry(r,{type:"MultiPolygon",coordinates:d}).getObject(),editType:"split",editContext:{featureIndexes:[r]}}}};var g0=class extends Mo{constructor(){super(...arguments);I(this,"isPointAdded",!1)}handleDragging(j,e){let r=te(j.pointerDownPicks);if(r){let{featureIndex:n}=r.properties,{positionIndexes:i}=r.properties,o=this.coordinatesSize(i,n,e.data);i=this.isPointAdded?this.nextPositionIndexes(i,o):i;let l=this.getPointForPositionIndexes(this.prevPositionIndexes(i,o),n,e.data),c=this.getPointForPositionIndexes(i,n,e.data);if(l&&c){let[B,h]=Ua(l,c,j.mapCoords),d=new Pj(e.data).replacePosition(n,this.prevPositionIndexes(i,o),h).replacePosition(n,i,B).getObject();e.onEdit({updatedData:d,editType:"extruding",editContext:{featureIndexes:[n],positionIndexes:this.nextPositionIndexes(i,o),position:B}}),j.cancelPan()}}}handleStartDragging(j,e){let r=e.selectedIndexes,n=a0(j.picks);if(r.length&&n){let{positionIndexes:i,featureIndex:o}=n.properties,l=this.coordinatesSize(i,o,e.data),c=this.getPointForPositionIndexes(this.prevPositionIndexes(i,l),o,e.data),B=this.getPointForPositionIndexes(i,o,e.data);if(c&&B){let h=new Pj(e.data);this.isOrthogonal(i,o,l,e.data)||(h=h.addPosition(o,i,B)),this.isOrthogonal(this.prevPositionIndexes(i,l),o,l,e.data)||(h=h.addPosition(o,i,c),this.isPointAdded=!0),e.onEdit({updatedData:h.getObject(),editType:"startExtruding",editContext:{featureIndexes:[o],positionIndexes:i,position:c}})}}}handleStopDragging(j,e){let r=e.selectedIndexes,n=te(j.pointerDownPicks);if(r.length&&n){let{featureIndex:i}=n.properties,{positionIndexes:o}=n.properties,l=this.coordinatesSize(o,i,e.data);o=this.isPointAdded?this.nextPositionIndexes(o,l):o;let c=this.getPointForPositionIndexes(this.prevPositionIndexes(o,l),i,e.data),B=this.getPointForPositionIndexes(o,i,e.data);if(c&&B){let[h,d]=Ua(c,B,j.mapCoords),k=new Pj(e.data).replacePosition(i,this.prevPositionIndexes(o,l),d).replacePosition(i,o,h).getObject();e.onEdit({updatedData:k,editType:"extruded",editContext:{featureIndexes:[i],positionIndexes:o,position:h}})}}this.isPointAdded=!1}coordinatesSize(j,e,{features:r}){let n=0;if(Array.isArray(j)){let o=r[e].geometry.coordinates;if(j.length===3){let[l,c]=j;o.length&&o[l].length&&(n=o[l][c].length)}else{let[l]=j;o.length&&o[l].length&&(n=o[l].length)}}return n}getBearing(j,e){let r=Fj(j,e);return r<0?Math.floor(360+r):Math.floor(r)}isOrthogonal(j,e,r,n){if(!Array.isArray(j))return!1;j[j.length-1]===r-1&&(j[j.length-1]=0);let i=this.getPointForPositionIndexes(this.prevPositionIndexes(j,r),e,n),o=this.getPointForPositionIndexes(this.nextPositionIndexes(j,r),e,n),l=this.getPointForPositionIndexes(j,e,n),c=this.getBearing(l,i),B=this.getBearing(l,o);return[89,90,91,269,270,271].includes(Math.abs(c-B))}nextPositionIndexes(j,e){if(!Array.isArray(j))return[];let r=[...j];return r.length&&(r[r.length-1]=r[r.length-1]===e-1?0:r[r.length-1]+1),r}prevPositionIndexes(j,e){if(!Array.isArray(j))return[];let r=[...j];return r.length&&(r[r.length-1]=r[r.length-1]===0?e-2:r[r.length-1]-1),r}getPointForPositionIndexes(j,e,{features:r}){let n;if(Array.isArray(j)){let o=r[e].geometry.coordinates;if(j.length===3){let[l,c,B]=j;o.length&&o[l].length&&(n=o[l][c][B])}else{let[l,c]=j;o.length&&o[l].length&&(n=o[l][c])}}return n}};function VuA({pointerDownScreenCoords:t,screenCoords:A}){return 10*(t[1]-A[1])}var m0=class extends Mo{makeElevatedEvent(A,j,e){let{minElevation:r=0,maxElevation:n=2e4,calculateElevationChange:i=VuA}=e.modeConfig||{};if(!A.pointerDownScreenCoords)return A;let o=j.length===3?j[2]:0;return o+=i({pointerDownScreenCoords:A.pointerDownScreenCoords,screenCoords:A.screenCoords}),o=Math.min(o,n),o=Math.max(o,r),Object.assign({},A,{mapCoords:[j[0],j[1],o]})}handlePointerMove(A,j){let e=te(A.pointerDownPicks),r=e?e.geometry.coordinates:A.mapCoords;super.handlePointerMove(this.makeElevatedEvent(A,r,j),j)}handleStopDragging(A,j){let e=te(A.picks),r=e?e.geometry.coordinates:A.mapCoords;super.handleStopDragging(this.makeElevatedEvent(A,r,j),j)}getCursor(A){let j=super.getCursor(A);return j==="cell"&&(j="ns-resize"),j}static calculateElevationChangeWithViewport(A,{pointerDownScreenCoords:j,screenCoords:e}){return 156543.03392*Math.cos(A.latitude*Math.PI/180)/Math.pow(2,A.zoom)*(j[1]-e[1])/2}};var E0=class extends Zt{createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=j?[j.mapCoords]:[];return{type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Point",coordinates:e[0]}}}handleClick({mapCoords:A},j){let e={type:"Point",coordinates:A};j.onEdit(this.getAddFeatureAction(e,j.data))}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}};function QuA(t,A){if(t===A)return!0;if(Array.isArray(t)){let j=t.length;if(!A||A.length!==j)return!1;for(let e=0;e{for(let r in e)if(!QuA(e[r],A[r])){j=t(e),A=e;break}return j}}var $0=class extends Zt{constructor(){super(...arguments);I(this,"dist",0);I(this,"position",null);I(this,"elems",[]);I(this,"_getTooltips",cl(({modeConfig:j,dist:e})=>{let r=[],{formatTooltip:n}=j||{},i;return e&&(n?i=n(e):i=`Distance: ${parseFloat(e).toFixed(2)} kilometers`,r=[{position:this.position,text:i}]),r}))}handleClick(j,e){let{picks:r}=j,n=te(r),i=!1;n||(this.addClickSequence(j),i=!0);let o=this.getClickSequence();if(n||this.calculateInfoDraw(o),o.length>1&&n&&Array.isArray(n.properties.positionIndexes)&&n.properties.positionIndexes[0]===o.length-1){this.dist=0;let l={type:"LineString",coordinates:[...o]};this.resetClickSequence();let c=this.getAddFeatureAction(l,e.data);c&&e.onEdit(c)}else i&&e.onEdit({updatedData:e.data,editType:"addTentativePosition",editContext:{position:j.mapCoords}})}handleKeyUp(j,e){let{key:r}=j;if(r==="Enter"){let n=this.getClickSequence();if(n.length>1){let i={type:"LineString",coordinates:[...n]};this.resetClickSequence();let o=this.getAddFeatureAction(i,e.data);o&&e.onEdit(o)}}else r==="Escape"&&(this.resetClickSequence(),e.onEdit({updatedData:e.data,editType:"cancelFeature",editContext:{}}))}getGuides(j){let{lastPointerMoveEvent:e}=j,r=this.getClickSequence(),n=e?[e.mapCoords]:[],i={type:"FeatureCollection",features:[]},o;r.length>0&&(o={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...r,...n]}}),o&&i.features.push(o);let l=r.map((c,B)=>({type:"Feature",properties:{guideType:"editHandle",editHandleType:"existing",featureIndex:-1,positionIndexes:[B]},geometry:{type:"Point",coordinates:c}}));return i.features.push(...l),i}handlePointerMove(j,e){e.onUpdateCursor("cell")}getTooltips(j){return this._getTooltips({modeConfig:j.modeConfig,dist:this.dist})}calculateInfoDraw(j){j.length>1&&(this.position=j[j.length-1],this.dist+=yt(j[j.length-2],j[j.length-1]))}};var Ai=class extends Zt{createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===1||e.length===2?n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...e,...r]}}:e.length>2&&(n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Polygon",coordinates:[[...e,...r,e[0]]]}}),n}getGuides(A){let j=this.getClickSequence(),e={type:"FeatureCollection",features:[]},r=this.createTentativeFeature(A);r&&e.features.push(r);let n=j.map((i,o)=>({type:"Feature",properties:{guideType:"editHandle",editHandleType:"existing",featureIndex:-1,positionIndexes:[o]},geometry:{type:"Point",coordinates:i}}));return e.features.push(...n),e}handleClick(A,j){let{picks:e}=A,r=te(e),n=this.getClickSequence(),i=!1;if(n.length>2&&j.modeConfig&&j.modeConfig.preventOverlappingLines){let l=$r([n[n.length-1],A.mapCoords]),c=$r([...n.slice(0,n.length-1)]);ll(l,c).features.length>0&&(i=!0)}let o=!1;if(!r&&!i&&(this.addClickSequence(A),o=!0),n.length>2&&r&&Array.isArray(r.properties.positionIndexes)&&(r.properties.positionIndexes[0]===0||r.properties.positionIndexes[0]===n.length-1)){let l={type:"Polygon",coordinates:[[...n,n[0]]]};this.resetClickSequence();let c=this.getAddFeatureOrBooleanPolygonAction(l,j);c&&j.onEdit(c)}else o&&j.onEdit({updatedData:j.data,editType:"addTentativePosition",editContext:{position:A.mapCoords}})}handleKeyUp(A,j){if(A.key==="Enter"){let e=this.getClickSequence();if(e.length>2){let r={type:"Polygon",coordinates:[[...e,e[0]]]};this.resetClickSequence();let n=this.getAddFeatureOrBooleanPolygonAction(r,j);n&&j.onEdit(n)}}else A.key==="Escape"&&(this.resetClickSequence(),j.onEdit({updatedData:j.data,editType:"cancelFeature",editContext:{}}))}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}};var pn=class extends Zt{handleClick(A,j){j.modeConfig&&j.modeConfig.dragToDraw||(this.addClickSequence(A),this.checkAndFinishPolygon(j))}handleStartDragging(A,j){!j.modeConfig||!j.modeConfig.dragToDraw||(this.addClickSequence(A),A.cancelPan())}handleStopDragging(A,j){!j.modeConfig||!j.modeConfig.dragToDraw||(this.addClickSequence(A),this.checkAndFinishPolygon(j))}checkAndFinishPolygon(A){let j=this.getClickSequence(),e=this.getTentativeGuide(A);if(j.length>1&&e&&e.geometry.type==="Polygon"){let r={type:"Feature",properties:{shape:e.properties.shape},geometry:{type:"Polygon",coordinates:e.geometry.coordinates}},n=this.getAddFeatureOrBooleanPolygonAction(r,A);this.resetClickSequence(),n&&A.onEdit(n)}}getGuides(A){let{lastPointerMoveEvent:j,modeConfig:e}=A,r=this.getClickSequence(),n={type:"FeatureCollection",features:[]};if(r.length===0||!j)return n;let i=r[0],o=j.mapCoords,l=this.getTwoClickPolygon(i,o,e);return l&&n.features.push({type:"Feature",properties:{shape:l.properties&&l.properties.shape,guideType:"tentative"},geometry:l.geometry}),n}getTwoClickPolygon(A,j,e){return null}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===1&&(n=this.getTwoClickPolygon(e[0],r[0],A.modeConfig)),n}};var Nc=class extends pn{getTwoClickPolygon(A,j,e){let r=Bn([A[0],A[1],j[0],j[1]]);return r.properties=r.properties||{},r.properties.shape="Rectangle",r}};var r6=63710088e-1,fat={centimeters:r6*100,centimetres:r6*100,degrees:r6/111325,feet:r6*3.28084,inches:r6*39.37,kilometers:r6/1e3,kilometres:r6/1e3,meters:r6,metres:r6,miles:r6/1609.344,millimeters:r6*1e3,millimetres:r6*1e3,nauticalmiles:r6/1852,radians:1,yards:r6*1.0936},hat={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/r6,yards:1.0936133};function WuA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function WP(t,A,j){if(j===void 0&&(j={}),!t)throw new Error("coordinates is required");if(!Array.isArray(t))throw new Error("coordinates must be an Array");if(t.length<2)throw new Error("coordinates must be at least 2 numbers long");if(!QP(t[0])||!QP(t[1]))throw new Error("coordinates must contain numbers");var e={type:"Point",coordinates:t};return WuA(e,A,j)}function QP(t){return!isNaN(t)&&t!==null&&!Array.isArray(t)}function _K(t){return t.type==="Feature"?t.geometry:t}function x0(t,A,j){j===void 0&&(j={});for(var e=_K(t),r=e.coordinates,n=0,i=0;i=n&&i===r.length-1);i++)if(n>=A){var o=A-n;if(o){var l=Fj(r[i],r[i-1])-180,c=yr(r[i],o,l,j);return c}else return WP(r[i])}else n+=yt(r[i],r[i+1],j);return WP(r[r.length-1])}var y0=class extends pn{getTwoClickPolygon(A,j,e){let r=[j[0],A[1]],n=[A[0],j[1]],i=yt(Vt(r),Vt(A)),o=yt(Vt(n),Vt(A)),l=i<=o?i:o,c=i<=o?r:n,B=$r([c,j]),d=x0(B,l).geometry.coordinates,k=Bn([A[0],A[1],d[0],d[1]]);return k.properties=k.properties||{},k.properties.shape="Square",k}};var v0=class extends pn{getTwoClickPolygon(A,j,e){let r=A[0]>j[0]?A[0]+Math.abs(A[0]-j[0]):A[0]-Math.abs(A[0]-j[0]),n=A[1]>j[1]?A[1]+Math.abs(A[1]-j[1]):A[1]-Math.abs(A[1]-j[1]),i=Bn([r,n,j[0],j[1]]);return i.properties=i.properties||{},i.properties.shape="Rectangle",i}};var _0=class extends pn{getTwoClickPolygon(A,j,e){let r=[j[0],A[1]],n=[A[0],j[1]],i=yt(Vt(r),Vt(A)),o=yt(Vt(n),Vt(A)),l=i<=o?i:o,c=i<=o?r:n,B=$r([c,j]),d=x0(B,l).geometry.coordinates,k=A[0]>d[0]?A[0]+Math.abs(A[0]-d[0]):A[0]-Math.abs(A[0]-d[0]),g=A[1]>d[1]?A[1]+Math.abs(A[1]-d[1]):A[1]-Math.abs(A[1]-d[1]),E=Bn([k,g,d[0],d[1]]);return E.properties=E.properties||{},E.properties.shape="Square",E}};var n6=63710088e-1,Cat={centimeters:n6*100,centimetres:n6*100,degrees:n6/111325,feet:n6*3.28084,inches:n6*39.37,kilometers:n6/1e3,kilometres:n6/1e3,meters:n6,metres:n6,miles:n6/1609.344,millimeters:n6*1e3,millimetres:n6*1e3,nauticalmiles:n6/1852,radians:1,yards:n6*1.0936},Hat={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/n6,yards:1.0936133};function YuA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function qK(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e0){A+=Math.abs(wK(t[0]));for(var j=1;j2){for(o=0;o{let n=[],{formatTooltip:i}=j||{},o;return e&&r&&(i?o=i(e):o=`Radius: ${parseFloat(e).toFixed(2)} kilometers - Area: ${parseFloat(r).toFixed(2)}`,n=[{position:this.position,text:o}]),n}))}getTwoClickPolygon(j,e,r){let{steps:n=64}=r||{},i={steps:n};this.position=e,n<4&&(console.warn("Minimum steps to draw a circle is 4 "),i.steps=4),this.radius=Math.max(yt(j,e),.001);let o=v0(j,this.radius,i);return o.properties=o.properties||{},o.properties.shape="Circle",this.areaCircle=$f(o),o}getTooltips(j){return this._getTooltips({modeConfig:j?.modeConfig,radius:this.radius,areaCircle:this.areaCircle})}};var q0=class extends pn{constructor(){super(...arguments);I(this,"radius",null);I(this,"position",null);I(this,"areaCircle",null);I(this,"diameter",null);I(this,"_getTooltips",cl(({modeConfig:j,radius:e,areaCircle:r,diameter:n})=>{let i=[],{formatTooltip:o}=j||{},l;return e&&r&&(o?l=o(e):l=`Radius: ${parseFloat(e).toFixed(2)} kilometers + Area: ${parseFloat(r).toFixed(2)}`,n=[{position:this.position,text:o}]),n}))}getTwoClickPolygon(j,e,r){let{steps:n=64}=r||{},i={steps:n};this.position=e,n<4&&(console.warn("Minimum steps to draw a circle is 4 "),i.steps=4),this.radius=Math.max(yt(j,e),.001);let o=q0(j,this.radius,i);return o.properties=o.properties||{},o.properties.shape="Circle",this.areaCircle=$f(o),o}getTooltips(j){return this._getTooltips({modeConfig:j?.modeConfig,radius:this.radius,areaCircle:this.areaCircle})}};var G0=class extends pn{constructor(){super(...arguments);I(this,"radius",null);I(this,"position",null);I(this,"areaCircle",null);I(this,"diameter",null);I(this,"_getTooltips",cl(({modeConfig:j,radius:e,areaCircle:r,diameter:n})=>{let i=[],{formatTooltip:o}=j||{},l;return e&&r&&(o?l=o(e):l=`Radius: ${parseFloat(e).toFixed(2)} kilometers Area: ${parseFloat(r).toFixed(2)} - Diameter: ${parseFloat(n).toFixed(2)} kilometers`,i=[{position:this.position,text:l}]),i}))}getTwoClickPolygon(j,e,r){let{steps:n=64}=r||{},i={steps:n};n<4&&(console.warn("Minimum steps to draw a circle is 4 "),i.steps=4);let o=ol(j,e);this.radius=Math.max(yt(j,o),.001),this.diameter=Math.max(yt(j,e),.001),this.position=o;let l=v0(o,this.radius,i);return l.properties=l.properties||{},l.properties.shape="Circle",this.areaCircle=$f(l),l}getTooltips(j){return this._getTooltips({modeConfig:j.modeConfig,radius:this.radius,areaCircle:this.areaCircle,diameter:this.diameter})}};var i6=63710088e-1,j7t={centimeters:i6*100,centimetres:i6*100,degrees:i6/111325,feet:i6*3.28084,inches:i6*39.37,kilometers:i6/1e3,kilometres:i6/1e3,meters:i6,metres:i6,miles:i6/1609.344,millimeters:i6*1e3,millimetres:i6*1e3,nauticalmiles:i6/1852,radians:1,yards:i6*1.0936},e7t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/i6,yards:1.0936133};function VuA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function UP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function QuA(t,A,j,e){e=e||{};var r=e.steps||64,n=e.units||"kilometers",i=e.angle||0,o=e.pivot||t,l=e.properties||t.properties||{};if(!t)throw new Error("center is required");if(!A)throw new Error("xSemiAxis is required");if(!j)throw new Error("ySemiAxis is required");if(!_K(e))throw new Error("options must be an object");if(!nv(r))throw new Error("steps must be a number");if(!nv(i))throw new Error("angle must be a number");var c=iv(t);if(n==="degrees")var B=vK(i);else A=Gs(t,A,90,{units:n}),j=Gs(t,j,0,{units:n}),A=iv(A)[0]-c[0],j=iv(j)[1]-c[1];for(var h=[],d=0;d=-270&&(g=-g),k<-180&&k>=-360&&(E=-E),n==="degrees"){var m=g*Math.cos(B)+E*Math.sin(B),y=E*Math.cos(B)-g*Math.sin(B);g=m,E=y}h.push([g+c[0],E+c[1]])}return h.push(h[0]),n==="degrees"?UP([h],l):Vy(UP([h],l),i,{pivot:o})}function qK(t){var A=t*Math.PI/180;return Math.tan(A)}var ov=QuA;var G0=class extends pn{getTwoClickPolygon(A,j,e){let r=Math.min(A[0],j[0]),n=Math.min(A[1],j[1]),i=Math.max(A[0],j[0]),o=Math.max(A[1],j[1]),l=Bn([r,n,i,o]).geometry.coordinates[0],c=ol(A,j),B=Math.max(yt(Vt(l[0]),Vt(l[1])),.001),h=Math.max(yt(Vt(l[0]),Vt(l[3])),.001);return ov(c,B,h)}};var xf=class extends Zt{handleClick(A,j){this.addClickSequence(A);let e=this.getClickSequence(),r=this.getTentativeGuide(j);if(e.length>2&&r&&r.geometry.type==="Polygon"){let n=this.getAddFeatureOrBooleanPolygonAction(r.geometry,j);this.resetClickSequence(),n&&j.onEdit(n)}}getGuides(A){let{lastPointerMoveEvent:j,modeConfig:e}=A,r=this.getClickSequence(),n={type:"FeatureCollection",features:[]};if(r.length===0)return n;let i=j.mapCoords;if(r.length===1)n.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[r[0],i]}});else{let o=this.getThreeClickPolygon(r[0],r[1],i,e);o&&n.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:o.geometry})}return n}getThreeClickPolygon(A,j,e,r){return null}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===2&&(n=this.getThreeClickPolygon(e[0],e[1],r[0],A.modeConfig)),n}};var b0=class extends xf{getThreeClickPolygon(A,j,e,r){let[n,i]=Ua(A,j,e);return{type:"Feature",properties:{shape:"Rectangle"},geometry:{type:"Polygon",coordinates:[[A,j,n,i,A]]}}}};var w0=class extends xf{getThreeClickPolygon(A,j,e,r){let n=ol(A,j),i=Math.max(yt(n,Vt(e)),.001),o=Math.max(yt(A,j),.001)/2,l={angle:Fj(A,j)};return ov(n,i,o,l)}};var F0=class extends Zt{createTentativeFeature(A){let j=this.getClickSequence(),{mapCoords:e}=A.lastPointerMoveEvent,r;if(j.length<=1)r=e;else{let i=j[j.length-2],o=j[j.length-1];[r]=Ua(i,o,e)}let n;return j.length<3?n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...j,r]}}:n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Polygon",coordinates:[[...j,r,j[0]]]}},n}getGuides(A){let j={type:"FeatureCollection",features:[]};if(this.getClickSequence().length===0||!A.lastPointerMoveEvent)return j;let r=this.createTentativeFeature(A);return j.features.push(r),j.features=j.features.concat(il(r.geometry,-1)),j.features=j.features.slice(0,-1),j}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}handleClick(A,j){let{picks:e}=A,r=this.getTentativeGuide(j);this.addClickSequence(A);let n=this.getClickSequence();if(r)if(n.length===3&&r.geometry.type==="LineString"){let i=r.geometry;n[n.length-1]=i.coordinates[i.coordinates.length-1]}else if(n.length>3&&r.geometry.type==="Polygon"){let i=r.geometry;n[n.length-1]=i.coordinates[0][i.coordinates[0].length-2];let o=te(e);if(o&&Array.isArray(o.properties.positionIndexes)&&(o.properties.positionIndexes[1]===0||o.properties.positionIndexes[1]===i.coordinates[0].length-3)){let l={type:"Polygon",coordinates:this.finalizedCoordinates([...i.coordinates[0]])};this.resetClickSequence();let c=this.getAddFeatureOrBooleanPolygonAction(l,j);c&&j.onEdit(c)}}else{let i={screenCoords:[-1,-1],mapCoords:A.mapCoords,picks:[],pointerDownPicks:null,pointerDownScreenCoords:null,pointerDownMapCoords:null,cancelPan:()=>{},sourceEvent:null};this.handlePointerMove(i,j)}}finalizedCoordinates(A){let j=[[...A.slice(0,-2),A[0]]],e=this.getIntermediatePoint([...A]);if(e)j=[[...A.slice(0,-2),e,A[0]]];else{let r=[...A];r.splice(-3,1),e=this.getIntermediatePoint([...r]),e&&(j=[[...A.slice(0,-3),e,A[0]]])}return j}getIntermediatePoint(A){let j=null;if(A.length>4){let[e,r]=[...A],n=Fj(e,r),i=A[A.length-3],o=A[A.length-4],l=Fj(i,o),c={first:[],second:[]};[1,2,3].forEach(h=>{let d=n+h*90;c.first.push(d>180?d-360:d);let k=l+h*90;c.second.push(k>180?k-360:k)});let B=yt(Vt(e),Vt(i));[0,1,2].forEach(h=>{let d=$r([e,yr(e,B,c.first[h]).geometry.coordinates]);[0,1,2].forEach(k=>{let g=$r([i,yr(i,B,c.second[k]).geometry.coordinates]),E=ll(d,g);E&&E.features.length&&(j=E.features[0].geometry.coordinates)})})}return j}};var IK=Qs(PK(),1);var P0=class extends Ai{constructor(){super(...arguments);I(this,"handleDraggingThrottled",null)}handleClick(j,e){}handleStartDragging(j,e){j.cancelPan(),e.modeConfig&&e.modeConfig.throttleMs?this.handleDraggingThrottled=(0,IK.default)(this.handleDraggingAux,e.modeConfig.throttleMs):this.handleDraggingThrottled=this.handleDraggingAux}handleStopDragging(j,e){this.addClickSequence(j);let r=this.getClickSequence();if(this.handleDraggingThrottled&&this.handleDraggingThrottled.cancel&&this.handleDraggingThrottled.cancel(),r.length>2){let n={type:"Polygon",coordinates:[[...r,r[0]]]},i=this.getAddFeatureOrBooleanPolygonAction(n,e);i&&e.onEdit(i)}this.resetClickSequence()}handleDraggingAux(j,e){let{picks:r}=j;te(r)||(this.addClickSequence(j),e.onEdit({updatedData:e.data,editType:"addTentativePosition",editContext:{position:j.mapCoords}}))}handleDragging(j,e){this.handleDraggingThrottled&&this.handleDraggingThrottled(j,e)}handleKeyUp(j,e){if(j.key==="Enter"){let r=this.getClickSequence();if(r.length>2){let n={type:"Polygon",coordinates:[[...r,r[0]]]};this.resetClickSequence();let i=this.getAddFeatureOrBooleanPolygonAction(n,e);i&&e.onEdit(i)}}else j.key==="Escape"&&(this.resetClickSequence(),this.handleDraggingThrottled&&(this.handleDraggingThrottled=null),e.onEdit({updatedData:e.data,editType:"cancelFeature",editContext:{}}))}};var yf=class extends Zt{constructor(j){super();I(this,"_handler");this._handler=j}_getSnappedMouseEvent(j,e,r){return Object.assign(j,{mapCoords:r.geometry.coordinates,pointerDownMapCoords:e&&e.geometry.coordinates})}_getPickedSnapTarget(j){return Io(j).find(e=>e.properties.editHandleType==="snap-target")}_getPickedSnapSource(j){return A3(j)}_getUpdatedSnapSourceHandle(j,e){let{featureIndex:r,positionIndexes:n}=j.properties;if(!Array.isArray(n))return j;let i=e.features[r],o=n.reduce((l,c)=>l[c],i.geometry.coordinates);return{...j,geometry:{type:"Point",coordinates:o}}}_getSnapTargets(j){let{additionalSnapTargets:e}=j.modeConfig||{};return e=e||[],[...j.data.features,...e]}_getSnapTargetHandles(j){let e=[],r=this._getSnapTargets(j);for(let n=0;nr.handleClick(j,e))}handlePointerMove(j,e){return this._coalesce(r=>r.handlePointerMove(j,e))}handleStartDragging(j,e){return this._coalesce(r=>r.handleStartDragging(j,e))}handleStopDragging(j,e){return this._coalesce(r=>r.handleStopDragging(j,e))}handleDragging(j,e){return this._coalesce(r=>r.handleDragging(j,e))}getGuides(j){let e=[];for(let r of this._modes)e.push(...r.getGuides(j).features);return{type:"FeatureCollection",features:e}}};var M0=class extends I0{constructor(){super([new bs,new Va,new Qa])}handlePointerMove(A,j){let e=null;super.handlePointerMove(A,{...j,onUpdateCursor:r=>{e=r||e}}),j.onUpdateCursor(e)}handleStartDragging(A,j){let e=null,r=null,n=[];this._modes.forEach(i=>{i instanceof bs?r=i:(i instanceof Va&&(e=i),n.push(i))}),e instanceof Va&&!e.isEditHandleSelected()&&n.push(r),n.filter(Boolean).forEach(i=>i.handleStartDragging(A,j))}getGuides(A){let j=super.getGuides(A),e=(this._modes||[]).find(r=>r instanceof Qa);if(e instanceof Qa){let r=j.features.filter(n=>{let{editHandleType:i,mode:o}=n.properties||{},l=[o];return e.getIsRotating()&&l.push(i),!l.includes("scale")});j=Xa(r)}return j}};var O0=.6666666666666666;var MK=["anyclick","pointermove","panstart","panmove","panend","keyup"],vf=class extends G6{constructor(){super(...arguments);I(this,"state")}onLayerClick(j){}onStartDragging(j){}onStopDragging(j){}onDragging(j){}onPointerMove(j){}onLayerKeyUp(j){}initializeState(){this.setState({_editableLayerState:{pointerDownPicks:null,pointerDownScreenCoords:null,pointerDownMapCoords:null,eventHandler:this._forwardEventToCurrentLayer.bind(this)}}),this._addEventHandlers()}finalizeState(){this._removeEventHandlers()}_addEventHandlers(){let{eventManager:j}=this.context.deck,{eventHandler:e}=this.state._editableLayerState;for(let r of MK)j.on(r,e,{priority:100})}_removeEventHandlers(){let{eventManager:j}=this.context.deck,{eventHandler:e}=this.state._editableLayerState;for(let r of MK)j.off(r,e)}_forwardEventToCurrentLayer(j){let e=this.getCurrentLayer(),r=e[`_on${j.type}`].bind(e);if(!r){console.warn(`no handler for mjolnir.js event ${j.type}`);return}r(j)}_onanyclick({srcEvent:j}){let e=this.getScreenCoords(j),r=this.getMapCoords(e),n=this.getPicks(e);this.onLayerClick({mapCoords:r,screenCoords:e,picks:n,sourceEvent:j})}_onkeyup({srcEvent:j}){this.onLayerKeyUp(j)}_onpanstart(j){let e=this.getScreenCoords(j.srcEvent),r=this.getMapCoords(e),n=this.getPicks(e);this.setState({_editableLayerState:{...this.state._editableLayerState,pointerDownScreenCoords:e,pointerDownMapCoords:r,pointerDownPicks:n}}),this.onStartDragging({picks:n,screenCoords:e,mapCoords:r,pointerDownScreenCoords:e,pointerDownMapCoords:r,cancelPan:j.stopImmediatePropagation,sourceEvent:j.srcEvent})}_onpanmove(j){let{srcEvent:e}=j,r=this.getScreenCoords(e),n=this.getMapCoords(r),{pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l}=this.state._editableLayerState,c=this.getPicks(r);this.onDragging({screenCoords:r,mapCoords:n,picks:c,pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l,sourceEvent:e,cancelPan:j.stopImmediatePropagation})}_onpanend({srcEvent:j}){let e=this.getScreenCoords(j),r=this.getMapCoords(e),{pointerDownPicks:n,pointerDownScreenCoords:i,pointerDownMapCoords:o}=this.state._editableLayerState,l=this.getPicks(e);this.onStopDragging({picks:l,screenCoords:e,mapCoords:r,pointerDownPicks:n,pointerDownScreenCoords:i,pointerDownMapCoords:o,sourceEvent:j}),this.setState({_editableLayerState:{...this.state._editableLayerState,pointerDownScreenCoords:null,pointerDownMapCoords:null,pointerDownPicks:null}})}_onpointermove(j){let{srcEvent:e}=j,r=this.getScreenCoords(e),n=this.getMapCoords(r),{pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l}=this.state._editableLayerState,c=this.getPicks(r);this.onPointerMove({screenCoords:r,mapCoords:n,picks:c,pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l,sourceEvent:e,cancelPan:j.stopImmediatePropagation})}getPicks(j){return this.context.deck.pickMultipleObjects({x:j[0],y:j[1],layerIds:[this.props.id],radius:this.props.pickingRadius,depth:this.props.pickingDepth})}getScreenCoords(j){return[j.clientX-this.context.gl.canvas.getBoundingClientRect().left,j.clientY-this.context.gl.canvas.getBoundingClientRect().top]}getMapCoords(j){return this.context.viewport.unproject([j[0],j[1]])}};I(vf,"layerName","EditableLayer");var BBA={..._o.defaultProps,pickingLineWidthExtraPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER}},_f=class extends _o{getShaders(){let A=super.getShaders();return A.vs=PN(A.vs,"vec3 width;",` + Diameter: ${parseFloat(n).toFixed(2)} kilometers`,i=[{position:this.position,text:l}]),i}))}getTwoClickPolygon(j,e,r){let{steps:n=64}=r||{},i={steps:n};n<4&&(console.warn("Minimum steps to draw a circle is 4 "),i.steps=4);let o=ol(j,e);this.radius=Math.max(yt(j,o),.001),this.diameter=Math.max(yt(j,e),.001),this.position=o;let l=q0(o,this.radius,i);return l.properties=l.properties||{},l.properties.shape="Circle",this.areaCircle=$f(l),l}getTooltips(j){return this._getTooltips({modeConfig:j.modeConfig,radius:this.radius,areaCircle:this.areaCircle,diameter:this.diameter})}};var i6=63710088e-1,a7t={centimeters:i6*100,centimetres:i6*100,degrees:i6/111325,feet:i6*3.28084,inches:i6*39.37,kilometers:i6/1e3,kilometres:i6/1e3,meters:i6,metres:i6,miles:i6/1609.344,millimeters:i6*1e3,millimetres:i6*1e3,nauticalmiles:i6/1852,radians:1,yards:i6*1.0936},l7t={centimeters:100,centimetres:100,degrees:1/111325,feet:3.28084,inches:39.37,kilometers:1/1e3,kilometres:1/1e3,meters:1,metres:1,miles:1/1609.344,millimeters:1e3,millimetres:1e3,nauticalmiles:1/1852,radians:1/i6,yards:1.0936133};function ABA(t,A,j){j===void 0&&(j={});var e={type:"Feature"};return(j.id===0||j.id)&&(e.id=j.id),j.bbox&&(e.bbox=j.bbox),e.properties=A||{},e.geometry=t,e}function JP(t,A,j){j===void 0&&(j={});for(var e=0,r=t;e=2&&!Array.isArray(t[0])&&!Array.isArray(t[1]))return t;throw new Error("coord must be GeoJSON Point or an Array of numbers")}function tBA(t,A,j,e){e=e||{};var r=e.steps||64,n=e.units||"kilometers",i=e.angle||0,o=e.pivot||t,l=e.properties||t.properties||{};if(!t)throw new Error("center is required");if(!A)throw new Error("xSemiAxis is required");if(!j)throw new Error("ySemiAxis is required");if(!PK(e))throw new Error("options must be an object");if(!lv(r))throw new Error("steps must be a number");if(!lv(i))throw new Error("angle must be a number");var c=cv(t);if(n==="degrees")var B=FK(i);else A=bs(t,A,90,{units:n}),j=bs(t,j,0,{units:n}),A=cv(A)[0]-c[0],j=cv(j)[1]-c[1];for(var h=[],d=0;d=-270&&(g=-g),k<-180&&k>=-360&&(E=-E),n==="degrees"){var m=g*Math.cos(B)+E*Math.sin(B),y=E*Math.cos(B)-g*Math.sin(B);g=m,E=y}h.push([g+c[0],E+c[1]])}return h.push(h[0]),n==="degrees"?JP([h],l):Zy(JP([h],l),i,{pivot:o})}function IK(t){var A=t*Math.PI/180;return Math.tan(A)}var uv=tBA;var w0=class extends pn{getTwoClickPolygon(A,j,e){let r=Math.min(A[0],j[0]),n=Math.min(A[1],j[1]),i=Math.max(A[0],j[0]),o=Math.max(A[1],j[1]),l=Bn([r,n,i,o]).geometry.coordinates[0],c=ol(A,j),B=Math.max(yt(Vt(l[0]),Vt(l[1])),.001),h=Math.max(yt(Vt(l[0]),Vt(l[3])),.001);return uv(c,B,h)}};var xf=class extends Zt{handleClick(A,j){this.addClickSequence(A);let e=this.getClickSequence(),r=this.getTentativeGuide(j);if(e.length>2&&r&&r.geometry.type==="Polygon"){let n=this.getAddFeatureOrBooleanPolygonAction(r.geometry,j);this.resetClickSequence(),n&&j.onEdit(n)}}getGuides(A){let{lastPointerMoveEvent:j,modeConfig:e}=A,r=this.getClickSequence(),n={type:"FeatureCollection",features:[]};if(r.length===0)return n;let i=j.mapCoords;if(r.length===1)n.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[r[0],i]}});else{let o=this.getThreeClickPolygon(r[0],r[1],i,e);o&&n.features.push({type:"Feature",properties:{guideType:"tentative"},geometry:o.geometry})}return n}getThreeClickPolygon(A,j,e,r){return null}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}createTentativeFeature(A){let{lastPointerMoveEvent:j}=A,e=this.getClickSequence(),r=j?[j.mapCoords]:[],n;return e.length===2&&(n=this.getThreeClickPolygon(e[0],e[1],r[0],A.modeConfig)),n}};var F0=class extends xf{getThreeClickPolygon(A,j,e,r){let[n,i]=Ua(A,j,e);return{type:"Feature",properties:{shape:"Rectangle"},geometry:{type:"Polygon",coordinates:[[A,j,n,i,A]]}}}};var P0=class extends xf{getThreeClickPolygon(A,j,e,r){let n=ol(A,j),i=Math.max(yt(n,Vt(e)),.001),o=Math.max(yt(A,j),.001)/2,l={angle:Fj(A,j)};return uv(n,i,o,l)}};var I0=class extends Zt{createTentativeFeature(A){let j=this.getClickSequence(),{mapCoords:e}=A.lastPointerMoveEvent,r;if(j.length<=1)r=e;else{let i=j[j.length-2],o=j[j.length-1];[r]=Ua(i,o,e)}let n;return j.length<3?n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"LineString",coordinates:[...j,r]}}:n={type:"Feature",properties:{guideType:"tentative"},geometry:{type:"Polygon",coordinates:[[...j,r,j[0]]]}},n}getGuides(A){let j={type:"FeatureCollection",features:[]};if(this.getClickSequence().length===0||!A.lastPointerMoveEvent)return j;let r=this.createTentativeFeature(A);return j.features.push(r),j.features=j.features.concat(il(r.geometry,-1)),j.features=j.features.slice(0,-1),j}handlePointerMove(A,j){j.onUpdateCursor("cell"),super.handlePointerMove(A,j)}handleClick(A,j){let{picks:e}=A,r=this.getTentativeGuide(j);this.addClickSequence(A);let n=this.getClickSequence();if(r)if(n.length===3&&r.geometry.type==="LineString"){let i=r.geometry;n[n.length-1]=i.coordinates[i.coordinates.length-1]}else if(n.length>3&&r.geometry.type==="Polygon"){let i=r.geometry;n[n.length-1]=i.coordinates[0][i.coordinates[0].length-2];let o=te(e);if(o&&Array.isArray(o.properties.positionIndexes)&&(o.properties.positionIndexes[1]===0||o.properties.positionIndexes[1]===i.coordinates[0].length-3)){let l={type:"Polygon",coordinates:this.finalizedCoordinates([...i.coordinates[0]])};this.resetClickSequence();let c=this.getAddFeatureOrBooleanPolygonAction(l,j);c&&j.onEdit(c)}}else{let i={screenCoords:[-1,-1],mapCoords:A.mapCoords,picks:[],pointerDownPicks:null,pointerDownScreenCoords:null,pointerDownMapCoords:null,cancelPan:()=>{},sourceEvent:null};this.handlePointerMove(i,j)}}finalizedCoordinates(A){let j=[[...A.slice(0,-2),A[0]]],e=this.getIntermediatePoint([...A]);if(e)j=[[...A.slice(0,-2),e,A[0]]];else{let r=[...A];r.splice(-3,1),e=this.getIntermediatePoint([...r]),e&&(j=[[...A.slice(0,-3),e,A[0]]])}return j}getIntermediatePoint(A){let j=null;if(A.length>4){let[e,r]=[...A],n=Fj(e,r),i=A[A.length-3],o=A[A.length-4],l=Fj(i,o),c={first:[],second:[]};[1,2,3].forEach(h=>{let d=n+h*90;c.first.push(d>180?d-360:d);let k=l+h*90;c.second.push(k>180?k-360:k)});let B=yt(Vt(e),Vt(i));[0,1,2].forEach(h=>{let d=$r([e,yr(e,B,c.first[h]).geometry.coordinates]);[0,1,2].forEach(k=>{let g=$r([i,yr(i,B,c.second[k]).geometry.coordinates]),E=ll(d,g);E&&E.features.length&&(j=E.features[0].geometry.coordinates)})})}return j}};var LK=Qs(RK(),1);var M0=class extends Ai{constructor(){super(...arguments);I(this,"handleDraggingThrottled",null)}handleClick(j,e){}handleStartDragging(j,e){j.cancelPan(),e.modeConfig&&e.modeConfig.throttleMs?this.handleDraggingThrottled=(0,LK.default)(this.handleDraggingAux,e.modeConfig.throttleMs):this.handleDraggingThrottled=this.handleDraggingAux}handleStopDragging(j,e){this.addClickSequence(j);let r=this.getClickSequence();if(this.handleDraggingThrottled&&this.handleDraggingThrottled.cancel&&this.handleDraggingThrottled.cancel(),r.length>2){let n={type:"Polygon",coordinates:[[...r,r[0]]]},i=this.getAddFeatureOrBooleanPolygonAction(n,e);i&&e.onEdit(i)}this.resetClickSequence()}handleDraggingAux(j,e){let{picks:r}=j;te(r)||(this.addClickSequence(j),e.onEdit({updatedData:e.data,editType:"addTentativePosition",editContext:{position:j.mapCoords}}))}handleDragging(j,e){this.handleDraggingThrottled&&this.handleDraggingThrottled(j,e)}handleKeyUp(j,e){if(j.key==="Enter"){let r=this.getClickSequence();if(r.length>2){let n={type:"Polygon",coordinates:[[...r,r[0]]]};this.resetClickSequence();let i=this.getAddFeatureOrBooleanPolygonAction(n,e);i&&e.onEdit(i)}}else j.key==="Escape"&&(this.resetClickSequence(),this.handleDraggingThrottled&&(this.handleDraggingThrottled=null),e.onEdit({updatedData:e.data,editType:"cancelFeature",editContext:{}}))}};var yf=class extends Zt{constructor(j){super();I(this,"_handler");this._handler=j}_getSnappedMouseEvent(j,e,r){return Object.assign(j,{mapCoords:r.geometry.coordinates,pointerDownMapCoords:e&&e.geometry.coordinates})}_getPickedSnapTarget(j){return Io(j).find(e=>e.properties.editHandleType==="snap-target")}_getPickedSnapSource(j){return i3(j)}_getUpdatedSnapSourceHandle(j,e){let{featureIndex:r,positionIndexes:n}=j.properties;if(!Array.isArray(n))return j;let i=e.features[r],o=n.reduce((l,c)=>l[c],i.geometry.coordinates);return{...j,geometry:{type:"Point",coordinates:o}}}_getSnapTargets(j){let{additionalSnapTargets:e}=j.modeConfig||{};return e=e||[],[...j.data.features,...e]}_getSnapTargetHandles(j){let e=[],r=this._getSnapTargets(j);for(let n=0;nr.handleClick(j,e))}handlePointerMove(j,e){return this._coalesce(r=>r.handlePointerMove(j,e))}handleStartDragging(j,e){return this._coalesce(r=>r.handleStartDragging(j,e))}handleStopDragging(j,e){return this._coalesce(r=>r.handleStopDragging(j,e))}handleDragging(j,e){return this._coalesce(r=>r.handleDragging(j,e))}getGuides(j){let e=[];for(let r of this._modes)e.push(...r.getGuides(j).features);return{type:"FeatureCollection",features:e}}};var T0=class extends O0{constructor(){super([new Gs,new Va,new Qa])}handlePointerMove(A,j){let e=null;super.handlePointerMove(A,{...j,onUpdateCursor:r=>{e=r||e}}),j.onUpdateCursor(e)}handleStartDragging(A,j){let e=null,r=null,n=[];this._modes.forEach(i=>{i instanceof Gs?r=i:(i instanceof Va&&(e=i),n.push(i))}),e instanceof Va&&!e.isEditHandleSelected()&&n.push(r),n.filter(Boolean).forEach(i=>i.handleStartDragging(A,j))}getGuides(A){let j=super.getGuides(A),e=(this._modes||[]).find(r=>r instanceof Qa);if(e instanceof Qa){let r=j.features.filter(n=>{let{editHandleType:i,mode:o}=n.properties||{},l=[o];return e.getIsRotating()&&l.push(i),!l.includes("scale")});j=Xa(r)}return j}};var S0=.6666666666666666;var CK=["anyclick","pointermove","panstart","panmove","panend","keyup"],vf=class extends b6{constructor(){super(...arguments);I(this,"state")}onLayerClick(j){}onStartDragging(j){}onStopDragging(j){}onDragging(j){}onPointerMove(j){}onLayerKeyUp(j){}initializeState(){this.setState({_editableLayerState:{pointerDownPicks:null,pointerDownScreenCoords:null,pointerDownMapCoords:null,eventHandler:this._forwardEventToCurrentLayer.bind(this)}}),this._addEventHandlers()}finalizeState(){this._removeEventHandlers()}_addEventHandlers(){let{eventManager:j}=this.context.deck,{eventHandler:e}=this.state._editableLayerState;for(let r of CK)j.on(r,e,{priority:100})}_removeEventHandlers(){let{eventManager:j}=this.context.deck,{eventHandler:e}=this.state._editableLayerState;for(let r of CK)j.off(r,e)}_forwardEventToCurrentLayer(j){let e=this.getCurrentLayer(),r=e[`_on${j.type}`].bind(e);if(!r){console.warn(`no handler for mjolnir.js event ${j.type}`);return}r(j)}_onanyclick({srcEvent:j}){let e=this.getScreenCoords(j),r=this.getMapCoords(e),n=this.getPicks(e);this.onLayerClick({mapCoords:r,screenCoords:e,picks:n,sourceEvent:j})}_onkeyup({srcEvent:j}){this.onLayerKeyUp(j)}_onpanstart(j){let e=this.getScreenCoords(j.srcEvent),r=this.getMapCoords(e),n=this.getPicks(e);this.setState({_editableLayerState:{...this.state._editableLayerState,pointerDownScreenCoords:e,pointerDownMapCoords:r,pointerDownPicks:n}}),this.onStartDragging({picks:n,screenCoords:e,mapCoords:r,pointerDownScreenCoords:e,pointerDownMapCoords:r,cancelPan:j.stopImmediatePropagation,sourceEvent:j.srcEvent})}_onpanmove(j){let{srcEvent:e}=j,r=this.getScreenCoords(e),n=this.getMapCoords(r),{pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l}=this.state._editableLayerState,c=this.getPicks(r);this.onDragging({screenCoords:r,mapCoords:n,picks:c,pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l,sourceEvent:e,cancelPan:j.stopImmediatePropagation})}_onpanend({srcEvent:j}){let e=this.getScreenCoords(j),r=this.getMapCoords(e),{pointerDownPicks:n,pointerDownScreenCoords:i,pointerDownMapCoords:o}=this.state._editableLayerState,l=this.getPicks(e);this.onStopDragging({picks:l,screenCoords:e,mapCoords:r,pointerDownPicks:n,pointerDownScreenCoords:i,pointerDownMapCoords:o,sourceEvent:j}),this.setState({_editableLayerState:{...this.state._editableLayerState,pointerDownScreenCoords:null,pointerDownMapCoords:null,pointerDownPicks:null}})}_onpointermove(j){let{srcEvent:e}=j,r=this.getScreenCoords(e),n=this.getMapCoords(r),{pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l}=this.state._editableLayerState,c=this.getPicks(r);this.onPointerMove({screenCoords:r,mapCoords:n,picks:c,pointerDownPicks:i,pointerDownScreenCoords:o,pointerDownMapCoords:l,sourceEvent:e,cancelPan:j.stopImmediatePropagation})}getPicks(j){return this.context.deck.pickMultipleObjects({x:j[0],y:j[1],layerIds:[this.props.id],radius:this.props.pickingRadius,depth:this.props.pickingDepth})}getScreenCoords(j){return[j.clientX-this.context.gl.canvas.getBoundingClientRect().left,j.clientY-this.context.gl.canvas.getBoundingClientRect().top]}getMapCoords(j){return this.context.viewport.unproject([j[0],j[1]])}};I(vf,"layerName","EditableLayer");var gBA={..._o.defaultProps,pickingLineWidthExtraPixels:{type:"number",min:0,value:Number.MAX_SAFE_INTEGER}},_f=class extends _o{getShaders(){let A=super.getShaders();return A.vs=RN(A.vs,"vec3 width;",` if(bool(picking.isActive)){ widthPixels.xy += pickingLineWidthExtraPixels; } - `),{...A,inject:{...A.inject||{},"vs:#decl":(A.inject?.["vs:#decl"]||"").concat("uniform float pickingLineWidthExtraPixels;")}}}draw(A){super.draw({...A,uniforms:{...A.uniforms,pickingLineWidthExtraPixels:this.props.pickingLineWidthExtraPixels}})}};_f.defaultProps=BBA;_f.layerName="EditablePathLayer";var fBA=[0,0,0,153],hBA=[0,0,0,144],dBA=[0,0,0,255],pBA=[0,0,144,144],kBA=[144,144,144,255],gBA=[144,144,144,144],mBA=[192,0,0,255],EBA=[0,0,0,128],$BA=[124,0,192,255],xBA=[255,255,255,255],yBA=5,vBA=3,_BA=7,qBA=32*O0,TK=Ai;function Ps(t){return!t||typeof t!="function"?t:A=>t(GBA(A))}function GBA(t){return t.__source?t.__source.object:t.sourceFeature?t.sourceFeature.feature:t}function OK(t){switch(t.properties.editHandleType){case"existing":return mBA;case"snap-source":return $BA;case"intermediate":default:return EBA}}function bBA(t){return xBA}function wBA(t){switch(t.properties.editHandleType){case"existing":return yBA;case"snap":return _BA;case"intermediate":default:return vBA}}var FBA={mode:TK,onEdit:()=>{},pickable:!0,pickingRadius:10,pickingDepth:5,fp64:!1,filled:!0,stroked:!0,lineWidthScale:O0,lineWidthMinPixels:1,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,pickingLineWidthExtraPixels:0,lineWidthUnits:"pixels",lineJointRounded:!1,lineCapRounded:!1,lineMiterLimit:4,pointRadiusScale:1,pointRadiusMinPixels:2,pointRadiusMaxPixels:Number.MAX_SAFE_INTEGER,getLineColor:(t,A,j)=>A?dBA:fBA,getFillColor:(t,A,j)=>A?pBA:hBA,getRadius:t=>t&&t.properties&&t.properties.radius||t&&t.properties&&t.properties.size||1,getLineWidth:t=>t&&t.properties&&t.properties.lineWidth||3,getTentativeLineColor:t=>kBA,getTentativeFillColor:t=>gBA,getTentativeLineWidth:t=>t&&t.properties&&t.properties.lineWidth||3,editHandleType:"point",editHandlePointRadiusScale:1,editHandlePointOutline:!0,editHandlePointStrokeWidth:2,editHandlePointRadiusUnits:"pixels",editHandlePointRadiusMinPixels:4,editHandlePointRadiusMaxPixels:8,getEditHandlePointColor:OK,getEditHandlePointOutlineColor:bBA,getEditHandlePointRadius:wBA,editHandleIconAtlas:null,editHandleIconMapping:null,editHandleIconSizeScale:1,editHandleIconSizeUnits:"pixels",getEditHandleIcon:t=>t.properties.editHandleType,getEditHandleIconSize:10,getEditHandleIconColor:OK,getEditHandleIconAngle:0,billboard:!0},PBA={view:Xr,modify:Mo,translate:new yf(new bs),transform:new yf(new M0),scale:Va,rotate:Qa,duplicate:l0,split:d0,extrude:p0,elevation:k0,drawPoint:g0,drawLineString:m0,drawPolygon:Ai,drawRectangle:Dc,drawSquare:$0,drawRectangleFromCenter:x0,drawSquareFromCenter:y0,drawCircleFromCenter:_0,drawCircleByBoundingBox:q0,drawEllipseByBoundingBox:G0,drawRectangleUsing3Points:b0,drawEllipseUsing3Points:w0,draw90DegreePolygon:F0,drawPolygonByDragging:P0},Is=class extends vf{constructor(){super(...arguments);I(this,"state")}renderLayers(){let j=this.getSubLayerProps({id:"geojson",data:this.props.data,fp64:this.props.fp64,filled:this.props.filled,stroked:this.props.stroked,lineWidthScale:this.props.lineWidthScale,lineWidthMinPixels:this.props.lineWidthMinPixels,lineWidthMaxPixels:this.props.lineWidthMaxPixels,lineWidthUnits:this.props.lineWidthUnits,lineJointRounded:this.props.lineJointRounded,lineCapRounded:this.props.lineCapRounded,lineMiterLimit:this.props.lineMiterLimit,pointRadiusScale:this.props.pointRadiusScale,pointRadiusMinPixels:this.props.pointRadiusMinPixels,pointRadiusMaxPixels:this.props.pointRadiusMaxPixels,getLineColor:this.selectionAwareAccessor(this.props.getLineColor),getFillColor:this.selectionAwareAccessor(this.props.getFillColor),getPointRadius:this.selectionAwareAccessor(this.props.getRadius),getLineWidth:this.selectionAwareAccessor(this.props.getLineWidth),_subLayerProps:{linestrings:{billboard:this.props.billboard,updateTriggers:{all:[this.props.selectedFeatureIndexes,this.props.mode]}},"polygons-stroke":{billboard:this.props.billboard,pickingLineWidthExtraPixels:this.props.pickingLineWidthExtraPixels,type:_f,updateTriggers:{all:[this.props.selectedFeatureIndexes,this.props.mode]}}},updateTriggers:{getLineColor:[this.props.selectedFeatureIndexes,this.props.mode],getFillColor:[this.props.selectedFeatureIndexes,this.props.mode],getPointRadius:[this.props.selectedFeatureIndexes,this.props.mode],getLineWidth:[this.props.selectedFeatureIndexes,this.props.mode]}}),e=[new La(j)];return e=e.concat(this.createGuidesLayers(),this.createTooltipsLayers()),e}initializeState(){super.initializeState(),this.setState({selectedFeatures:[],editHandles:[]})}shouldUpdateState(j){return super.shouldUpdateState(j)||j.changeFlags.stateChanged}updateState({props:j,oldProps:e,changeFlags:r,context:n}){if(super.updateState({oldProps:e,props:j,changeFlags:r,context:n}),r.propsOrDataChanged&&(Object.keys(e).length===0||j.mode!==e.mode)){let l;if(typeof j.mode=="function"){let c=j.mode;l=new c}else typeof j.mode=="string"?(l=PBA[j.mode],console.warn("Deprecated use of passing `mode` as a string. Pass the mode's class constructor instead.")):l=j.mode;l||(console.warn(`No mode configured for ${String(j.mode)}`),l=new TK),l!==this.state.mode&&this.setState({mode:l,cursor:null})}let i=[];if(Array.isArray(j.selectedFeatureIndexes)&&typeof j.data=="object"&&"features"in j.data){let o=j.data;i=j.selectedFeatureIndexes.map(l=>o.features[l])}this.setState({selectedFeatures:i})}getModeProps(j){return{modeConfig:j.modeConfig,data:j.data,selectedIndexes:j.selectedFeatureIndexes,lastPointerMoveEvent:this.state.lastPointerMoveEvent,cursor:this.state.cursor,onEdit:e=>{this.setNeedsUpdate(),j.onEdit(e)},onUpdateCursor:e=>{this.setState({cursor:e})}}}selectionAwareAccessor(j){return typeof j!="function"?j:e=>j(e,this.isFeatureSelected(e),this.props.mode)}isFeatureSelected(j){return!this.props.data||!this.props.selectedFeatureIndexes||!this.props.selectedFeatureIndexes.length?!1:this.state.selectedFeatures.includes(j)}getPickingInfo({info:j,sourceLayer:e}){return e.id.endsWith("guides")&&(j.isGuide=!0),j}_updateAutoHighlight(j){if(j?.sourceLayer)if(j.isGuide)for(let e of j.sourceLayer.getSubLayers())e.updateAutoHighlight(j);else j.sourceLayer.updateAutoHighlight(j)}createGuidesLayers(){let e=this.getActiveMode().getGuides(this.getModeProps(this.props));if(!e||!e.features.length)return[];let r={linestrings:{billboard:this.props.billboard,autoHighlight:!1},"polygons-fill":{autoHighlight:!1},"polygons-stroke":{billboard:this.props.billboard}};return this.props.editHandleType==="icon"?r["points-icon"]={type:z7,iconAtlas:this.props.editHandleIconAtlas,iconMapping:this.props.editHandleIconMapping,sizeUnits:this.props.editHandleIconSizeUnits,sizeScale:this.props.editHandleIconSizeScale,getIcon:Ps(this.props.getEditHandleIcon),getSize:Ps(this.props.getEditHandleIconSize),getColor:Ps(this.props.getEditHandleIconColor),getAngle:Ps(this.props.getEditHandleIconAngle),billboard:this.props.billboard}:r["points-circle"]={type:mr,radiusScale:this.props.editHandlePointRadiusScale,stroked:this.props.editHandlePointOutline,getLineWidth:this.props.editHandlePointStrokeWidth,radiusUnits:this.props.editHandlePointRadiusUnits,radiusMinPixels:this.props.editHandlePointRadiusMinPixels,radiusMaxPixels:this.props.editHandlePointRadiusMaxPixels,getRadius:Ps(this.props.getEditHandlePointRadius),getFillColor:Ps(this.props.getEditHandlePointColor),getLineColor:Ps(this.props.getEditHandlePointOutlineColor),billboard:this.props.billboard},[new La(this.getSubLayerProps({id:"guides",data:e,fp64:this.props.fp64,_subLayerProps:r,lineWidthScale:this.props.lineWidthScale,lineWidthMinPixels:this.props.lineWidthMinPixels,lineWidthMaxPixels:this.props.lineWidthMaxPixels,lineWidthUnits:this.props.lineWidthUnits,lineJointRounded:this.props.lineJointRounded,lineCapRounded:this.props.lineCapRounded,lineMiterLimit:this.props.lineMiterLimit,getLineColor:Ps(this.props.getTentativeLineColor),getLineWidth:Ps(this.props.getTentativeLineWidth),getFillColor:Ps(this.props.getTentativeFillColor),pointType:this.props.editHandleType==="icon"?"icon":"circle",iconAtlas:this.props.editHandleIconAtlas}))]}createTooltipsLayers(){let e=this.getActiveMode().getTooltips(this.getModeProps(this.props));return[new Ii({getSize:qBA,...this.getSubLayerProps({id:"tooltips",data:e})})]}onLayerClick(j){this.getActiveMode().handleClick(j,this.getModeProps(this.props))}onLayerKeyUp(j){this.getActiveMode().handleKeyUp(j,this.getModeProps(this.props))}onStartDragging(j){this.getActiveMode().handleStartDragging(j,this.getModeProps(this.props))}onDragging(j){this.getActiveMode().handleDragging(j,this.getModeProps(this.props))}onStopDragging(j){this.getActiveMode().handleStopDragging(j,this.getModeProps(this.props))}onPointerMove(j){this.setState({lastPointerMoveEvent:j}),this.getActiveMode().handlePointerMove(j,this.getModeProps(this.props))}getCursor({isDragging:j}){if(this.state===null||this.state===void 0)return null;let{cursor:e}=this.state;return e||(e=j?"grabbing":"grab"),e}getActiveMode(){return this.state.mode}};I(Is,"layerName","EditableGeoJsonLayer"),I(Is,"defaultProps",FBA);var IBA=Xr,MBA=9;var Xlt={mode:IBA,...Is.defaultProps,data:[],selectedIndexes:[],filled:!1,stroked:!0,lineWidthScale:O0,lineWidthMinPixels:1,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,lineWidthUnits:"pixels",getHexagons:t=>t.hexIds,getEditedCluster:(t,A)=>A?{...A,hexIds:t}:{hexIds:t},resolution:MBA};var av={NONE:null,RECTANGLE:"rectangle",POLYGON:"polygon"},tct={[av.RECTANGLE]:Dc,[av.POLYGON]:Ai},jct={[av.RECTANGLE]:{dragToDraw:!0}},ect={selectionType:av.RECTANGLE,layerIds:[],onSelect:()=>{}};function Nc(t,A){return t==null||A==null?NaN:tA?1:t>=A?0:NaN}function QP(t,A){return t==null||A==null?NaN:At?1:A>=t?0:NaN}function lv(t){let A,j,e;t.length!==2?(A=Nc,j=(o,l)=>Nc(t(o),l),e=(o,l)=>t(o)-l):(A=t===Nc||t===QP?t:OBA,j=t,e=t);function r(o,l,c=0,B=o.length){if(c>>1;j(o[h],l)<0?c=h+1:B=h}while(c>>1;j(o[h],l)<=0?c=h+1:B=h}while(cc&&e(o[h-1],l)>-e(o[h],l)?h-1:h}return{left:r,center:i,right:n}}function OBA(){return 0}function WP(t){return t===null?NaN:+t}var SK=lv(Nc),RK=SK.right,TBA=SK.left,SBA=lv(WP).center,YP=RK;var qf=class extends Map{constructor(A,j=CBA){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:j}}),A!=null)for(let[e,r]of A)this.set(e,r)}get(A){return super.get(LK(this,A))}has(A){return super.has(LK(this,A))}set(A,j){return super.set(RBA(this,A),j)}delete(A){return super.delete(LBA(this,A))}};function LK({_intern:t,_key:A},j){let e=A(j);return t.has(e)?t.get(e):j}function RBA({_intern:t,_key:A},j){let e=A(j);return t.has(e)?t.get(e):(t.set(e,j),j)}function LBA({_intern:t,_key:A},j){let e=A(j);return t.has(e)&&(j=t.get(e),t.delete(e)),j}function CBA(t){return t!==null&&typeof t=="object"?t.valueOf():t}var HBA=Math.sqrt(50),DBA=Math.sqrt(10),NBA=Math.sqrt(2);function cv(t,A,j){let e=(A-t)/Math.max(0,j),r=Math.floor(Math.log10(e)),n=e/Math.pow(10,r),i=n>=HBA?10:n>=DBA?5:n>=NBA?2:1,o,l,c;return r<0?(c=Math.pow(10,-r)/i,o=Math.round(t*c),l=Math.round(A*c),o/cA&&--l,c=-c):(c=Math.pow(10,r)*i,o=Math.round(t/c),l=Math.round(A/c),o*cA&&--l),l0))return[];if(t===A)return[t];let e=A=r))return[];let o=n-r+1,l=new Array(o);if(e)if(i<0)for(let c=0;c=e)&&(j=e);else{let e=-1;for(let r of t)(r=A(r,++e,t))!=null&&(j=r)&&(j=r)}return j}function vr(t,A){let j;if(A===void 0)for(let e of t)e!=null&&(j>e||j===void 0&&e>=e)&&(j=e);else{let e=-1;for(let r of t)(r=A(r,++e,t))!=null&&(j>r||j===void 0&&r>=r)&&(j=r)}return j}function F6(t,A,j){t=+t,A=+A,j=(r=arguments.length)<2?(A=t,t=0,1):r<3?1:+j;for(var e=-1,r=Math.max(0,Math.ceil((A-t)/j))|0,n=new Array(r);++e{}};function HK(){for(var t=0,A=arguments.length,j={},e;t=0&&(e=j.slice(r+1),j=j.slice(0,r)),j&&!A.hasOwnProperty(j))throw new Error("unknown type: "+j);return{type:j,name:e}})}Bv.prototype=HK.prototype={constructor:Bv,on:function(t,A){var j=this._,e=XBA(t+"",j),r,n=-1,i=e.length;if(arguments.length<2){for(;++n0)for(var j=new Array(r),e=0,r,n;e=0&&(A=t.slice(0,j))!=="xmlns"&&(t=t.slice(j+1)),AI.hasOwnProperty(A)?{space:AI[A],local:t}:t}function UBA(t){return function(){var A=this.ownerDocument,j=this.namespaceURI;return j===fv&&A.documentElement.namespaceURI===fv?A.createElement(t):A.createElementNS(j,t)}}function VBA(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function Gf(t){var A=Wa(t);return(A.local?VBA:UBA)(A)}function QBA(){}function Kc(t){return t==null?QBA:function(){return this.querySelector(t)}}function DK(t){typeof t!="function"&&(t=Kc(t));for(var A=this._groups,j=A.length,e=new Array(j),r=0;r=v&&(v=b+1);!(w=m[v])&&++v=0;)(i=e[r])&&(n&&i.compareDocumentPosition(n)^4&&n.parentNode.insertBefore(i,n),n=i);return this}function A5(t){t||(t=sfA);function A(h,d){return h&&d?t(h.__data__,d.__data__):!h-!d}for(var j=this._groups,e=j.length,r=new Array(e),n=0;nA?1:t>=A?0:NaN}function t5(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this}function j5(){return Array.from(this)}function e5(){for(var t=this._groups,A=0,j=t.length;A1?this.each((A==null?hfA:typeof A=="function"?pfA:dfA)(t,A,j??"")):ul(this.node(),t)}function ul(t,A){return t.style.getPropertyValue(A)||pv(t).getComputedStyle(t,null).getPropertyValue(A)}function kfA(t){return function(){delete this[t]}}function gfA(t,A){return function(){this[t]=A}}function mfA(t,A){return function(){var j=A.apply(this,arguments);j==null?delete this[t]:this[t]=j}}function a5(t,A){return arguments.length>1?this.each((A==null?kfA:typeof A=="function"?mfA:gfA)(t,A)):this.node()[t]}function l5(t){return t.trim().split(/^|\s+/)}function tI(t){return t.classList||new c5(t)}function c5(t){this._node=t,this._names=l5(t.getAttribute("class")||"")}c5.prototype={add:function(t){var A=this._names.indexOf(t);A<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var A=this._names.indexOf(t);A>=0&&(this._names.splice(A,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};function u5(t,A){for(var j=tI(t),e=-1,r=A.length;++e=0&&(j=A.slice(e+1),A=A.slice(0,e)),{type:A,name:j}})}function RfA(t){return function(){var A=this.__on;if(A){for(var j=0,e=-1,r=A.length,n;j>8&15|A>>4&240,A>>4&15|A&240,(A&15)<<4|A&15,1):j===8?gv(A>>24&255,A>>16&255,A>>8&255,(A&255)/255):j===4?gv(A>>12&15|A>>8&240,A>>8&15|A>>4&240,A>>4&15|A&240,((A&15)<<4|A&15)/255):null):(A=KfA.exec(t))?new P6(A[1],A[2],A[3],1):(A=XfA.exec(t))?new P6(A[1]*255/100,A[2]*255/100,A[3]*255/100,1):(A=zfA.exec(t))?gv(A[1],A[2],A[3],A[4]):(A=UfA.exec(t))?gv(A[1]*255/100,A[2]*255/100,A[3]*255/100,A[4]):(A=VfA.exec(t))?O5(A[1],A[2]/100,A[3]/100,1):(A=QfA.exec(t))?O5(A[1],A[2]/100,A[3]/100,A[4]):b5.hasOwnProperty(t)?P5(b5[t]):t==="transparent"?new P6(NaN,NaN,NaN,0):null}function P5(t){return new P6(t>>16&255,t>>8&255,t&255,1)}function gv(t,A,j,e){return e<=0&&(t=A=j=NaN),new P6(t,A,j,e)}function JfA(t){return t instanceof K0||(t=o6(t)),t?(t=t.rgb(),new P6(t.r,t.g,t.b,t.opacity)):new P6}function wf(t,A,j,e){return arguments.length===1?JfA(t):new P6(t,A,j,e??1)}function P6(t,A,j,e){this.r=+t,this.g=+A,this.b=+j,this.opacity=+e}kv(P6,wf,eI(K0,{brighter(t){return t=t==null?Ev:Math.pow(Ev,t),new P6(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=t==null?D0:Math.pow(D0,t),new P6(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new P6(zc(this.r),zc(this.g),zc(this.b),$v(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:I5,formatHex:I5,formatHex8:ZfA,formatRgb:M5,toString:M5}));function I5(){return`#${Xc(this.r)}${Xc(this.g)}${Xc(this.b)}`}function ZfA(){return`#${Xc(this.r)}${Xc(this.g)}${Xc(this.b)}${Xc((isNaN(this.opacity)?1:this.opacity)*255)}`}function M5(){let t=$v(this.opacity);return`${t===1?"rgb(":"rgba("}${zc(this.r)}, ${zc(this.g)}, ${zc(this.b)}${t===1?")":`, ${t})`}`}function $v(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function zc(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function Xc(t){return t=zc(t),(t<16?"0":"")+t.toString(16)}function O5(t,A,j,e){return e<=0?t=A=j=NaN:j<=0||j>=1?t=A=NaN:A<=0&&(t=NaN),new Oo(t,A,j,e)}function S5(t){if(t instanceof Oo)return new Oo(t.h,t.s,t.l,t.opacity);if(t instanceof K0||(t=o6(t)),!t)return new Oo;if(t instanceof Oo)return t;t=t.rgb();var A=t.r/255,j=t.g/255,e=t.b/255,r=Math.min(A,j,e),n=Math.max(A,j,e),i=NaN,o=n-r,l=(n+r)/2;return o?(A===n?i=(j-e)/o+(j0&&l<1?0:i,new Oo(i,o,l,t.opacity)}function R5(t,A,j,e){return arguments.length===1?S5(t):new Oo(t,A,j,e??1)}function Oo(t,A,j,e){this.h=+t,this.s=+A,this.l=+j,this.opacity=+e}kv(Oo,R5,eI(K0,{brighter(t){return t=t==null?Ev:Math.pow(Ev,t),new Oo(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=t==null?D0:Math.pow(D0,t),new Oo(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+(this.h<0)*360,A=isNaN(t)||isNaN(this.s)?0:this.s,j=this.l,e=j+(j<.5?j:1-j)*A,r=2*j-e;return new P6(rI(t>=240?t-240:t+120,r,e),rI(t,r,e),rI(t<120?t+240:t-120,r,e),this.opacity)},clamp(){return new Oo(T5(this.h),mv(this.s),mv(this.l),$v(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){let t=$v(this.opacity);return`${t===1?"hsl(":"hsla("}${T5(this.h)}, ${mv(this.s)*100}%, ${mv(this.l)*100}%${t===1?")":`, ${t})`}`}}));function T5(t){return t=(t||0)%360,t<0?t+360:t}function mv(t){return Math.max(0,Math.min(1,t||0))}function rI(t,A,j){return(t<60?A+(j-A)*t/60:t<180?j:t<240?A+(j-A)*(240-t)/60:A)*255}function nI(t,A,j,e,r){var n=t*t,i=n*t;return((1-3*t+3*n-i)*A+(4-6*n+3*i)*j+(1+3*t+3*n-3*i)*e+i*r)/6}function C5(t){var A=t.length-1;return function(j){var e=j<=0?j=0:j>=1?(j=1,A-1):Math.floor(j*A),r=t[e],n=t[e+1],i=e>0?t[e-1]:2*r-n,o=e()=>t;function AhA(t,A){return function(j){return t+j*A}}function thA(t,A,j){return t=Math.pow(t,j),A=Math.pow(A,j)-t,j=1/j,function(e){return Math.pow(t+e*A,j)}}function D5(t){return(t=+t)==1?xv:function(A,j){return j-A?thA(A,j,t):X0(isNaN(A)?j:A)}}function xv(t,A){var j=A-t;return j?AhA(t,j):X0(isNaN(t)?A:t)}var Uc=function t(A){var j=D5(A);function e(r,n){var i=j((r=wf(r)).r,(n=wf(n)).r),o=j(r.g,n.g),l=j(r.b,n.b),c=xv(r.opacity,n.opacity);return function(B){return r.r=i(B),r.g=o(B),r.b=l(B),r.opacity=c(B),r+""}}return e.gamma=t,e}(1);function N5(t){return function(A){var j=A.length,e=new Array(j),r=new Array(j),n=new Array(j),i,o;for(i=0;ij&&(n=A.slice(j,n),o[i]?o[i]+=n:o[++i]=n),(e=e[0])===(r=r[0])?o[i]?o[i]+=r:o[++i]=r:(o[++i]=null,l.push({i,x:Vr(e,r)})),j=iI.lastIndex;return j180?B+=360:B-c>180&&(c+=360),d.push({i:h.push(r(h)+"rotate(",null,e)-2,x:Vr(c,B)})):B&&h.push(r(h)+"rotate("+B+e)}function o(c,B,h,d){c!==B?d.push({i:h.push(r(h)+"skewX(",null,e)-2,x:Vr(c,B)}):B&&h.push(r(h)+"skewX("+B+e)}function l(c,B,h,d,k,g){if(c!==h||B!==d){var E=k.push(r(k)+"scale(",null,",",null,")");g.push({i:E-4,x:Vr(c,h)},{i:E-2,x:Vr(B,d)})}else(h!==1||d!==1)&&k.push(r(k)+"scale("+h+","+d+")")}return function(c,B){var h=[],d=[];return c=t(c),B=t(B),n(c.translateX,c.translateY,B.translateX,B.translateY,h,d),i(c.rotate,B.rotate,h,d),o(c.skewX,B.skewX,h,d),l(c.scaleX,c.scaleY,B.scaleX,B.scaleY,h,d),c=B=null,function(k){for(var g=-1,E=d.length,m;++g=0&&t._call.call(void 0,A),t=t._next;--Ff}function Z5(){Qc=(qv=W0.now())+Gv,Ff=V0=0;try{jX()}finally{Ff=0,shA(),Qc=0}}function ohA(){var t=W0.now(),A=t-qv;A>AX&&(Gv-=A,qv=t)}function shA(){for(var t,A=_v,j,e=1/0;A;)A._call?(e>A._time&&(e=A._time),t=A,A=A._next):(j=A._next,A._next=null,A=t?t._next=j:_v=j);Q0=t,uI(e)}function uI(t){if(!Ff){V0&&(V0=clearTimeout(V0));var A=t-Qc;A>24?(t<1/0&&(V0=setTimeout(Z5,t-W0.now()-Gv)),U0&&(U0=clearInterval(U0))):(U0||(qv=W0.now(),U0=setInterval(ohA,AX)),Ff=1,tX(Z5))}}function wv(t,A,j){var e=new Y0;return A=A==null?0:+A,e.restart(r=>{e.stop(),t(r+A)},A,j),e}var ahA=ZP("start","end","cancel","interrupt"),lhA=[],nX=0,eX=1,Pv=2,Fv=3,rX=4,Iv=5,Z0=6;function Bl(t,A,j,e,r,n){var i=t.__transition;if(!i)t.__transition={};else if(j in i)return;chA(t,j,{name:A,index:e,group:r,on:ahA,tween:lhA,time:n.time,delay:n.delay,duration:n.duration,ease:n.ease,timer:null,state:nX})}function Ag(t,A){var j=rr(t,A);if(j.state>nX)throw new Error("too late; already scheduled");return j}function Qr(t,A){var j=rr(t,A);if(j.state>Fv)throw new Error("too late; already running");return j}function rr(t,A){var j=t.__transition;if(!j||!(j=j[A]))throw new Error("transition not found");return j}function chA(t,A,j){var e=t.__transition,r;e[A]=j,j.timer=bv(n,0,j.time);function n(c){j.state=eX,j.timer.restart(i,j.delay,j.time),j.delay<=c&&i(c-j.delay)}function i(c){var B,h,d,k;if(j.state!==eX)return l();for(B in e)if(k=e[B],k.name===j.name){if(k.state===Fv)return wv(i);k.state===rX?(k.state=Z0,k.timer.stop(),k.on.call("interrupt",t,t.__data__,k.index,k.group),delete e[B]):+BPv&&e.state=0&&(A=A.slice(0,j)),!A||A==="start"})}function FhA(t,A,j){var e,r,n=whA(A)?Ag:Qr;return function(){var i=n(this,t),o=i.on;o!==e&&(r=(e=o).copy()).on(A,j),i.on=r}}function dX(t,A){var j=this._id;return arguments.length<2?rr(this.node(),j).on.on(t):this.each(FhA(j,t,A))}function PhA(t){return function(){var A=this.parentNode;for(var j in this.__transition)if(+j!==t)return;A&&A.removeChild(this)}}function pX(){return this.on("end.remove",PhA(this._id))}function kX(t){var A=this._name,j=this._id;typeof t!="function"&&(t=Kc(t));for(var e=this._groups,r=e.length,n=new Array(r),i=0;i=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)}function Wc(t,A){if((j=(t=A?t.toExponential(A-1):t.toExponential()).indexOf("e"))<0)return null;var j,e=t.slice(0,j);return[e.length>1?e[0]+e.slice(2):e,+t.slice(j+1)]}function Os(t){return t=Wc(Math.abs(t)),t?t[1]:NaN}function PX(t,A){return function(j,e){for(var r=j.length,n=[],i=0,o=t[0],l=0;r>0&&o>0&&(l+o+1>e&&(o=Math.max(1,e-l)),n.push(j.substring(r-=o,r+o)),!((l+=o+1)>e));)o=t[i=(i+1)%t.length];return n.reverse().join(A)}}function IX(t){return function(A){return A.replace(/[0-9]/g,function(j){return t[+j]})}}var VhA=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function fl(t){if(!(A=VhA.exec(t)))throw new Error("invalid format: "+t);var A;return new Sv({fill:A[1],align:A[2],sign:A[3],symbol:A[4],zero:A[5],width:A[6],comma:A[7],precision:A[8]&&A[8].slice(1),trim:A[9],type:A[10]})}fl.prototype=Sv.prototype;function Sv(t){this.fill=t.fill===void 0?" ":t.fill+"",this.align=t.align===void 0?">":t.align+"",this.sign=t.sign===void 0?"-":t.sign+"",this.symbol=t.symbol===void 0?"":t.symbol+"",this.zero=!!t.zero,this.width=t.width===void 0?void 0:+t.width,this.comma=!!t.comma,this.precision=t.precision===void 0?void 0:+t.precision,this.trim=!!t.trim,this.type=t.type===void 0?"":t.type+""}Sv.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function MX(t){A:for(var A=t.length,j=1,e=-1,r;j0&&(e=0);break}return e>0?t.slice(0,e)+t.slice(r+1):t}var fI;function OX(t,A){var j=Wc(t,A);if(!j)return t+"";var e=j[0],r=j[1],n=r-(fI=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,i=e.length;return n===i?e:n>i?e+new Array(n-i+1).join("0"):n>0?e.slice(0,n)+"."+e.slice(n):"0."+new Array(1-n).join("0")+Wc(t,Math.max(0,A+n-1))[0]}function hI(t,A){var j=Wc(t,A);if(!j)return t+"";var e=j[0],r=j[1];return r<0?"0."+new Array(-r).join("0")+e:e.length>r+1?e.slice(0,r+1)+"."+e.slice(r+1):e+new Array(r-e.length+2).join("0")}var dI={"%":(t,A)=>(t*100).toFixed(A),b:t=>Math.round(t).toString(2),c:t=>t+"",d:FX,e:(t,A)=>t.toExponential(A),f:(t,A)=>t.toFixed(A),g:(t,A)=>t.toPrecision(A),o:t=>Math.round(t).toString(8),p:(t,A)=>hI(t*100,A),r:hI,s:OX,X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function pI(t){return t}var TX=Array.prototype.map,SX=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function RX(t){var A=t.grouping===void 0||t.thousands===void 0?pI:PX(TX.call(t.grouping,Number),t.thousands+""),j=t.currency===void 0?"":t.currency[0]+"",e=t.currency===void 0?"":t.currency[1]+"",r=t.decimal===void 0?".":t.decimal+"",n=t.numerals===void 0?pI:IX(TX.call(t.numerals,String)),i=t.percent===void 0?"%":t.percent+"",o=t.minus===void 0?"\u2212":t.minus+"",l=t.nan===void 0?"NaN":t.nan+"";function c(h){h=fl(h);var d=h.fill,k=h.align,g=h.sign,E=h.symbol,m=h.zero,y=h.width,b=h.comma,v=h.precision,_=h.trim,w=h.type;w==="n"?(b=!0,w="g"):dI[w]||(v===void 0&&(v=12),_=!0,w="g"),(m||d==="0"&&k==="=")&&(m=!0,d="0",k="=");var x=E==="$"?j:E==="#"&&/[boxX]/.test(w)?"0"+w.toLowerCase():"",S=E==="$"?e:/[%p]/.test(w)?i:"",F=dI[w],D=/[defgprs%]/.test(w);v=v===void 0?6:/[gprs]/.test(w)?Math.max(1,Math.min(21,v)):Math.max(0,Math.min(20,v));function L(z){var T=x,W=S,G,jA,pA;if(w==="c")W=F(z)+W,z="";else{z=+z;var dA=z<0||1/z<0;if(z=isNaN(z)?l:F(Math.abs(z),v),_&&(z=MX(z)),dA&&+z==0&&g!=="+"&&(dA=!1),T=(dA?g==="("?g:o:g==="-"||g==="("?"":g)+T,W=(w==="s"?SX[8+fI/3]:"")+W+(dA&&g==="("?")":""),D){for(G=-1,jA=z.length;++GpA||pA>57){W=(pA===46?r+z.slice(G+1):z.slice(G))+W,z=z.slice(0,G);break}}}b&&!m&&(z=A(z,1/0));var $A=T.length+z.length+W.length,_A=$A>1)+T+z+W+_A.slice($A);break;default:z=_A+T+z+W;break}return n(z)}return L.toString=function(){return h+""},L}function B(h,d){var k=c((h=fl(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(Os(d)/3)))*3,E=Math.pow(10,-g),m=SX[8+g/3];return function(y){return k(E*y)+m}}return{format:c,formatPrefix:B}}var Rv,Lv,Cv;kI({thousands:",",grouping:[3],currency:["$",""]});function kI(t){return Rv=RX(t),Lv=Rv.format,Cv=Rv.formatPrefix,Rv}function gI(t){return Math.max(0,-Os(Math.abs(t)))}function mI(t,A){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Os(A)/3)))*3-Os(Math.abs(t)))}function EI(t,A){return t=Math.abs(t),A=Math.abs(A)-t,Math.max(0,Os(A)-Os(t))+1}function $I(t){for(var A=-1,j=t.length,e,r=t[j-1],n=0;++AA&&(j=t,t=A,A=j),function(e){return Math.max(t,Math.min(A,e))}}function WhA(t,A,j){var e=t[0],r=t[1],n=A[0],i=A[1];return r2?YhA:WhA,l=c=null,h}function h(d){return d==null||isNaN(d=+d)?n:(l||(l=o(t.map(e),A,j)))(e(i(d)))}return h.invert=function(d){return i(r((c||(c=o(A,t.map(e),Vr)))(d)))},h.domain=function(d){return arguments.length?(t=Array.from(d,yI),B()):t.slice()},h.range=function(d){return arguments.length?(A=Array.from(d),B()):A.slice()},h.rangeRound=function(d){return A=Array.from(d),j=sI,B()},h.clamp=function(d){return arguments.length?(i=d?!0:Mf,B()):i!==Mf},h.interpolate=function(d){return arguments.length?(j=d,B()):j},h.unknown=function(d){return arguments.length?(n=d,h):n},function(d,k){return e=d,r=k,B()}}function _I(){return JhA()(Mf,Mf)}function qI(t,A,j,e){var r=JP(t,A,j),n;switch(e=fl(e??",f"),e.type){case"s":{var i=Math.max(Math.abs(t),Math.abs(A));return e.precision==null&&!isNaN(n=mI(r,i))&&(e.precision=n),Cv(e,i)}case"":case"e":case"g":case"p":case"r":{e.precision==null&&!isNaN(n=EI(r,Math.max(Math.abs(t),Math.abs(A))))&&(e.precision=n-(e.type==="e"));break}case"f":case"%":{e.precision==null&&!isNaN(n=gI(r))&&(e.precision=n-(e.type==="%")*2);break}}return Lv(e)}function ZhA(t){var A=t.domain;return t.ticks=function(j){var e=A();return uv(e[0],e[e.length-1],j??10)},t.tickFormat=function(j,e){var r=A();return qI(r[0],r[r.length-1],j??10,e)},t.nice=function(j){j==null&&(j=10);var e=A(),r=0,n=e.length-1,i=e[r],o=e[n],l,c,B=10;for(o0;){if(c=T0(i,o,j),c===l)return e[r]=i,e[n]=o,A(e);if(c>0)i=Math.floor(i/c)*c,o=Math.ceil(o/c)*c;else if(c<0)i=Math.ceil(i*c)/c,o=Math.floor(o*c)/c;else break;l=c}return t},t}function ji(){var t=_I();return t.copy=function(){return HX(t,ji())},If.apply(t,arguments),ZhA(t)}function hl(t,A,j){this.k=t,this.x=A,this.y=j}hl.prototype={constructor:hl,scale:function(t){return t===1?this:new hl(this.k*t,this.x,this.y)},translate:function(t,A){return t===0&A===0?this:new hl(this.k,this.x+this.k*t,this.y+this.k*A)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var GI=new hl(1,0,0);bI.prototype=hl.prototype;function bI(t){for(;!t.__zoom;)if(!(t=t.parentNode))return GI;return t.__zoom}var Dv=(t,A,j,e,r)=>{let n=Math.floor(t/r),i=Math.floor(A/r),o=Math.floor(j/r),l=Math.floor(e/r),c=[];for(let B=n;B<=i;B++)for(let h=o;h<=l;h++)c.push({tileX:B,tileY:h,name:`${B}_${h}`});return c};var gt=(t,A)=>{t.cat=A},Nv=(t,A,j)=>{t.cell_cats=A.getChild(j).toArray()},DX=(t,A)=>{t.cell_cats=A.map(j=>j==="nan"?null:j)},Kv=t=>{t.cell_names_array.forEach((A,j)=>{t.dict_cell_cats[A]=t.cell_cats[j]})},Rt=(t,A,j)=>{t.reset_cat=A.length===t.selected_cats.length&&A.every((e,r)=>e===t.selected_cats[r]),t.selected_cats=t.reset_cat?[]:A,j.selected_cats.set(t.selected_cats)};var Qt=(t,A,j)=>{let e=A.length===t.selected_genes.length&&A.every((r,n)=>r===t.selected_genes[n]);t.selected_genes=e?[]:A,j.selected_genes.set(t.selected_genes)},Yc=(t,A)=>{if(t.model&&typeof t.model.set=="function"){t.model.set("selected_genes",A);let{row_entity:j}=t;j?.entity==="gene"&&t.model.set("selected_rows",A),t.model.save_changes()}t.obs_store&&t.obs_store.selected_genes&&t.obs_store.selected_genes.set(A)},Xv=(t,A)=>{if(t.model&&typeof t.model.set=="function"){t.model.set("selected_rows",A);let{row_entity:j}=t;j?.entity==="gene"&&t.model.set("selected_genes",A),t.model.save_changes()}},zv=(t,A)=>{t.model&&typeof t.model.set=="function"&&(t.model.set("selected_cols",A),t.model.save_changes())};var NX=async(t,A,j,e=null)=>{let r;if(t.get(A))r=t.get(A);else try{let n=e!==null?await e.fetch(A):await fetch(A,j.fetch);if(!n.ok)throw new Error(`Network response was not ok: ${n.statusText}`);let i=await n.arrayBuffer();r=dr(i),t.set(A,r)}catch(n){Zj(n,{context:`fetching or parsing Arrow data from ${A}`,url:A,logUnexpected:!0,throwOnAuth:!1}),r=null}return r};var Uv=async(t,A,j,e)=>Promise.all(A.map(r=>NX(t,r,j,e)));var Vv=t=>{t=t.filter(j=>j!=null);let A={length:0,startIndices:new Int32Array,attributes:{getPolygon:{value:new Float64Array,size:2}}};return t.forEach((j,e)=>{A.length+=j.length;let r=A.attributes.getPolygon.value.length/2,n=j.startIndices;if(e>0){n=new Int32Array(j.startIndices.length);for(let i=0;i0?1:0)]),A.attributes.getPolygon.value=new Float64Array([...A.attributes.getPolygon.value,...j.attributes.getPolygon.value])}),A},Qv=t=>{if(t.length===0)return null;let A=t[0];for(let j=1;j{let A=t.getChild("GEOMETRY")||t.getChild("geometry")||t.getChildAt(0);if(!A||A.data[0].type.typeId!==12)return null;let j=A.data,e=j.length,r=A.getChildAt(0),n=A.getChildAt(0).getChildAt(0).getChildAt(0);if(e===1)return KX(j[0],r.data[0],n.data[0]);let i=[];for(let o=0;o0&&i.push(h)}return Vv(i)};var FI=t=>{let A=[],{startIndices:j,attributes:e}=t,r=e.getPolygon.value,n=j.length-1;for(let i=0;i({tile_x:r.tileX,tile_y:r.tileY}));return j.readTiles(e)}function XX(t,A){let j=Array.isArray(t)?t:[t];return A.vector_name_integer?j.flatMap(e=>{let r=e.getChild("name");return r?Array.from(r.toArray()).map(i=>A.cats.nameMapping_inv[i]):[]}):j.flatMap(e=>{let r=e.getChild("name");return r?Array.from(r.toArray()):[]})}var zX=async(t,A,j)=>{if(j.use_row_groups&&j.row_group_readers?.cell){let B=await AdA(A,j);if(!B)return j.cats.polygon_cell_names=[],[];j.cats.polygon_cell_names=XX(B,j);let h=wI(B);return FI(h)}let e;j.seg.version==="default"?e=`${t}/cell_segmentation`:e=`${t}/cell_segmentation_${j.seg.version}`;let r=A.map(B=>`${e}/cell_tile_${B.tileX}_${B.tileY}.parquet`),i=(await Uv(j.cache.cell,r,Nt,j.aws)).filter(B=>B!==null);if(i.length===0)return j.cats.polygon_cell_names=[],[];j.cats.polygon_cell_names=XX(i,j);let o=i.map(B=>wI(B)),l=Vv(o);return FI(l)};var tdA=(t,A,j)=>{let e=t.polygon_cell_names[j.index],r=t.dict_cell_cats[e],n,i=String(r);i in t.color_dict_cluster?n=t.color_dict_cluster[i]:n=[0,0,255];let o=t.selected_cats.length===0||t.selected_cats.includes(r)?255:50;return[...n,o]},Wv=t=>new _o({id:"path-layer",data:[],pickable:!0,widthScale:3,widthMinPixels:1,getPath:j=>j,getColor:(j,e)=>tdA(t.cats,j,e),widthUnits:"pixels",...Er(t.rotation)}),jdA=async(t,A,j,e,r)=>{let n=r.cats.polygon_cell_names[t.index],i=r.cats.dict_cell_cats[n];r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),gt(r.cats,"cluster"),Rt(r.cats,[i],r.obs_store),Qt(r.genes,[],r.obs_store)},Yv=async(t,A,j,e)=>{let r=await zX(t,A,e);j.path_layer=j.path_layer.clone({data:r}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),path_data:!0})},Jv=(t,A,j)=>{A.path_layer=A.path_layer.clone({onClick:(e,r)=>jdA(e,r,t,A,j)})},Of=(t,A)=>{t.path_layer=t.path_layer.clone({visible:A})},Jc=(t,A)=>{t.path_layer=t.path_layer.clone({pickable:A})};var ae=async(t,A,j)=>{try{let r=await(j!==null?await j.fetch(t):await fetch(t,A)).arrayBuffer();return dr(r)}catch(e){return Zj(e,{context:"loading arrow table data",url:t,logUnexpected:!0,throwOnAuth:!1}),[]}};function UX(t,A){let j=Math.log1p(t),e=Math.log1p(A);return j/e*255}async function edA(t,A){let j=await t.readGene(A);if(!j)return{cell_names:[],cell_exp:[]};let e=j.getChild("cell_id")?.toArray()||[],r=j.getChild("expression")?.toArray()||[];return{cell_names:e,cell_exp:r}}var qr=async(t,A,j,e,r,n,i,o=null)=>{let l,c;if(o)({cell_names:l,cell_exp:c}=await edA(o,e));else{let g;r==="default"?g=`${j}/cbg/${e}.parquet`:g=`${j}/cbg_${r}/${e}.parquet`;let E=await ae(g,Nt.fetch,i);l=E.getChild("__index_level_0__").toArray(),c=E.getChild(e).toArray()}let B=new Array(t.cell_names_array.length).fill(0),h=t.meta_cell_id_set&&t.meta_cell_id_set.size>0?t.meta_cell_id_set:null,d=new Set,k=new Set;l.forEach((g,E)=>{g=String(g);let m=Number(c[E]),y=Number(A.meta_gene[e].max);if(n)if(g in t.nameMapping_inv){let b=String(t.nameMapping_inv[g]);(!h||h.has(b))&&(B[g]=UX(m,y))}else k.add(g);else if(t.cell_name_to_index_map.has(g)){let b=t.cell_name_to_index_map.get(g);(!h||h.has(g))&&(B[b]=UX(m,y))}else d.add(g)}),d.size>0,k.size>0,t.cell_exp_array=B};var dl=t=>{if(!t)return{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}};try{let A=t.getChild("geometry").getChildAt(0).data.map(r=>r.values).reduce((r,n)=>{let i=new Float64Array(r.length+n.length);return i.set(r),i.set(n,r.length),i},new Float64Array(0)),j=A.length/t.numRows;return{length:t.numRows,attributes:{getPosition:{value:A,size:j}}}}catch(A){return Zj(A,{context:"processing scatter data from arrow table",logUnexpected:!0,throwOnAuth:!1}),{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}}}};async function rdA(t,A){let j=A.row_group_readers?.trx;if(!j)return null;let e=t.map(r=>({tile_x:r.tileX,tile_y:r.tileY}));return j.readTiles(e)}var VX=async(t,A,j)=>{let e;if(j.use_row_groups&&j.row_group_readers?.trx)e=await rdA(A,j);else{let o=A.map(B=>`${t}/transcript_tiles/transcripts_tile_${B.tileX}_${B.tileY}.parquet`),c=(await Uv(j.cache.trx,o,Nt,j.aws)).filter(B=>B!==null);e=Qv(c)}if(!e)return j.genes.trx_names_array=[],j.combo_data.trx=[],{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}};let r=[];if(!j.vector_name_integer)r=e.getChild("name")?.toArray()||[];else{let o=e.getChild("name");r=o?Array.from(o.toArray()).map(l=>j.genes.g_nameMapping_inv[l]):[]}j.genes.trx_names_array=r;let n=dl(e),i=n.attributes.getPosition.value;return j.combo_data.trx=j.genes.trx_names_array.map((o,l)=>({name:o,x:i[l*2],y:i[l*2+1]})),n};var ndA=async(t,A,j,e,r)=>{let n=r.genes.trx_names_array[t.index];if(!n)return;let o=n===r.cats.cat?"cluster":n;gt(r.cats,o),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Qt(r.genes,[n],r.obs_store),Rt(r.cats,[n],r.obs_store),await qr(r.cats,r.genes,r.global_base_url,n,r.seg.version,r.vector_name_integer,r.aws,r.row_group_readers?.cbg)},Zv=t=>{let{genes:A}=t;return new mr({id:"trx-layer",data:A.trx_data,pickable:!0,getFillColor:(e,r)=>{let n=A.trx_names_array[r.index],i=A.color_dict_gene[n],o=A.selected_genes.length===0||A.selected_genes.includes(n)?255:5;return[...i,o]},...Er(t.rotation)})},A_=(t,A,j)=>{A.trx_layer=A.trx_layer.clone({onClick:(e,r)=>ndA(e,r,t,A,j)})},t_=async(t,A,j,e)=>{e.genes.trx_data=await VX(t,A,e),j.trx_layer=j.trx_layer.clone({data:e.genes.trx_data}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!0,trx_data:!0})},Ts=(t,A)=>{t.trx_layer=t.trx_layer.clone({visible:A})},Tf=(t,A)=>{t.trx_layer=t.trx_layer.clone({getRadius:A})},Zc=(t,A)=>{t.trx_layer=t.trx_layer.clone({pickable:A})};var j_=async({height:t,width:A,zoom:j,target:e},r,n,i)=>{let o=i.close_up,{tile_size:l}=i.img.landscape_parameters,c=Math.pow(2,j),[B,h]=e,d=A/(2*c),k=t/(2*c);i.bounds={},i.bounds.min_x=B-d,i.bounds.max_x=B+d,i.bounds.min_y=h-k,i.bounds.max_y=h+k;let g=r.viewManager.getViewports();if(!g||g.length===0)return;let E=(()=>{if(!i.rotation?.hasRotation)return i.bounds;let y=[[i.bounds.min_x,i.bounds.min_y],[i.bounds.min_x,i.bounds.max_y],[i.bounds.max_x,i.bounds.min_y],[i.bounds.max_x,i.bounds.max_y]].map(([_,w])=>rD(_,w,i.rotation)),b=y.map(([_])=>_),v=y.map(([,_])=>_);return{min_x:Math.min(...b),max_x:Math.max(...b),min_y:Math.min(...v),max_y:Math.max(...v)}})(),m=Dv(E.min_x,E.max_x,E.min_y,E.max_y,l);if(m.length{if(!i.rotation?.hasRotation)return S.x>=i.bounds.min_x&&S.x<=i.bounds.max_x&&S.y>=i.bounds.min_y&&S.y<=i.bounds.max_y;let[F,D]=r1(S.x,S.y,i.rotation);return F>=i.bounds.min_x&&F<=i.bounds.max_x&&D>=i.bounds.min_y&&D<=i.bounds.max_y}).map(S=>S.name).reduce((S,F)=>{let D=S.find(L=>L.name===F);return D?D.value+=1:S.push({name:F,value:1}),S},[]).filter(S=>S.value>0).sort((S,F)=>F.value-S.value).slice(0,100);i.obs_store.new_gene_bar_data.set(v);let x=i.combo_data.cell.filter(S=>{if(!i.rotation?.hasRotation)return S.x>=i.bounds.min_x&&S.x<=i.bounds.max_x&&S.y>=i.bounds.min_y&&S.y<=i.bounds.max_y;let[F,D]=r1(S.x,S.y,i.rotation);return F>=i.bounds.min_x&&F<=i.bounds.max_x&&D>=i.bounds.min_y&&D<=i.bounds.max_y}).map(S=>S.cat).reduce((S,F)=>{let D=S.find(L=>L.name===F);return D?D.value+=1:S.push({name:F,value:1}),S},[]).filter(S=>S.value>0).sort((S,F)=>F.value-S.value);i.obs_store.new_cell_bar_data.set(x)}else o&&(i.obs_store.deck_check.set({...i.obs_store.deck_check.get(),trx_data:!1,path_data:!1}),i.close_up=!1,i.obs_store.close_up.set(!1),i.obs_store.deck_check.set({...i.obs_store.deck_check.get(),trx_data:!0,path_data:!0}),i.obs_store.new_gene_bar_data.set(i.genes.top_gene_counts),i.obs_store.new_cell_bar_data.set(i.cats.cluster_counts),i.containers.bar_gene.scrollTo({top:0,behavior:"smooth"}),i.containers.bar_cluster.scrollTo({top:0,behavior:"smooth"}));i.layers_obj=n};var QX=(t,A)=>{if(t.index===-1||!t.layer)return null;let j=A.cats.tile_cats_array[t.index];return A.tooltip_cat_cell=j,jI(".deck-tooltip").style("margin-top","75px"),{html:`
${j}
`}},WX=(t,A)=>{if(A.index===-1||!A.layer||t.edit?.mode==="sktch")return null;let j="",e="",r="";if(A.layer.id.startsWith("cell-layer")||A.layer.id.startsWith("path-layer"))e=A.layer.id.startsWith("cell-layer")?t.cats.cell_names_array[A.index]:t.cats.polygon_cell_names[A.index],r=t.cats.dict_cell_cats[e],j=`
cell: ${e}
cluster: ${r}
`,t.tooltip_cat_cell=r;else if(A.layer.id.startsWith("trx-layer"))e=t.genes.trx_names_array[A.index],j=`
transcript: ${e}
`;else if(A.layer.id.startsWith("nbhd-layer"))e=t.nbhd.feature_collection.features[A.index].properties.name,r=t.nbhd.feature_collection.features[A.index].properties.cat,j=`
neighborhood: ${e}
category: ${r}
`;else if(A.layer.id.startsWith("edit-layer")){let i=t.edit?.feature_collection?.features?.[A.index];i&&(e=i.properties.name||`nbhd_${A.index+1}`,r=i.properties.cat||e,j=`
neighborhood: ${e}
`)}let n=t.root.querySelector(".deck-tooltip");if(n){n.style.marginTop="50px";let i=n.parentElement?.parentElement;i&&(i.style.position="unset")}return{html:j}};var Sf=(t,A,j=!1)=>{let e;return function(...r){let n=j&&!e;clearTimeout(e),e=setTimeout(()=>{e=null,j||t.apply(this,r)},A),n&&t.apply(this,r)}};var idA=200,YX=Sf(({viewState:t},A,j,e)=>(e.obs_store.umap_state.get()===!1&&j_(t,A,j,e),e.scale_bar&&e.obs_store.scale_bar_view_state.set(t),typeof e.custom_callbacks.view_change=="function"&&e.custom_callbacks.view_change(t,e.close_up,j.trx_layer),t),idA);var odA=({isDragging:t})=>t?"grabbing":"pointer",e_=(t,A,j,e="")=>{let r={doubleClickZoom:!1};return e==="point-cloud"&&(r.type=Sa),new N7({parent:t,controller:r,getCursor:odA,width:A,height:j})},r_=(t,A)=>{t.setProps({views:A})},n_=(t,A)=>{t.setProps({getTooltip:j=>WX(A,j)})},JX=(t,A,j)=>{t.setProps({onViewStateChange:e=>{YX(e,t,A,j)}})},ZX=(t,A,j,e,r,n,i=0,o=0)=>{let{center_x:l,center_y:c,center_z:B=0,ini_zoom:h}=n.spatial;A===0&&j===0&&e===0&&r===0&&(A=l,j=c,e=B,r=h);let d={target:[A,j,e],zoom:r};n.img.landscape_parameters.technology==="point-cloud"&&(d.rotationOrbit=i,d.rotationX=o),t.setProps({initialViewState:d}),n.scale_bar&&n.obs_store.scale_bar_view_state.set(d)};var Rf=t=>{let A=[0,0,0,255],{width:j,height:e}=t.dimensions;return new Q7({id:"background-layer",data:[{polygon:[[0,0],[j,0],[j,e],[0,e]]}],getPolygon:n=>n.polygon,getFillColor:A,pickable:!1,...Er(t.rotation)})},i_=(t,A)=>{t.background_layer=t.background_layer.clone({visible:A})};var o_=(t,A)=>{t.cell_names_array=A.getChild("name").toArray();let j=t.cell_names_array.reduce((e,r,n)=>(e[n]=r,e),{});t.nameMapping_inv=j},s_=t=>{t.cell_names_array.forEach((A,j)=>{A=String(A),t.cell_name_to_index_map.set(A,j)})};var ei=t=>(t=t.replace(/^#/,""),t.length===3&&(t=t.replace(/./g,"$&$&")),t.length===6?[0,2,4].map(A=>parseInt(t.substr(A,2),16)):[0,0,0]),sdA=t=>{if(!t||!Array.isArray(t)||t.length<3)return"#808080";let A=n=>Math.max(0,Math.min(255,Math.round(n))),j=A(t[0]).toString(16).padStart(2,"0"),e=A(t[1]).toString(16).padStart(2,"0"),r=A(t[2]).toString(16).padStart(2,"0");return`#${j}${e}${r}`},Lf=()=>{let t=Math.floor(Math.random()*256),A=Math.floor(Math.random()*256),j=Math.floor(Math.random()*256);return sdA([t,A,j])};var a_=async(t,A,j,e)=>{let r;j==="default"?r=`${A}/meta_gene.parquet`:r=`${A}/meta_gene_${j}.parquet`;let n=await ae(r,Nt.fetch,e),i=[],o=[],l=n.getChild("__index_level_0__"),c=n.getChild("color");l&&c&&(i=l.toArray(),o=c.toArray()),i.forEach((B,h)=>{t.color_dict_gene[B]=ei(o[h])}),t.gene_names=i};var l_=(t,A)=>{let j,e,r,n;["Chromium","point-cloud"].includes(t.img.landscape_parameters.technology)?(j=0,e=1e4,r=0,n=1e4):{x_min:j,x_max:e,y_min:r,y_max:n}=t.spatial;let i=e-j,o=n-r,l=Math.max(i,o),c=(e-j)/2,B=(n-r)/2,h=vr(A.map(w=>w.umap[0])),d=xj(A.map(w=>w.umap[0])),k=vr(A.map(w=>w.umap[1])),g=xj(A.map(w=>w.umap[1])),E=d-h,m=g-k;A.forEach(w=>{w.umap[0]=(w.umap[0]-h)/E*l,w.umap[1]=(w.umap[1]-k)/m*l}),h=vr(A.map(w=>w.umap[0])),d=xj(A.map(w=>w.umap[0])),k=vr(A.map(w=>w.umap[1])),g=xj(A.map(w=>w.umap[1]));let y=(d-h)/2,b=(g-k)/2,v=c-y,_=B-b;return A.forEach(w=>{w.umap[0]=w.umap[0]+v,w.umap[1]=w.umap[1]+_}),A};var adA=(t,A,j)=>{if(A[t]!==void 0)return A[t];if(j&&typeof t=="string"){let e=t.indexOf("_");if(e>=0){let r=t.substring(e+1);if(A[r]!==void 0)return A[r]}}},ldA=async(t,A,j,e,r)=>{let n="ontouchstart"in window||navigator.maxTouchPoints>0,i;n?i=r.cats.cell_cats[t.index]:i=r.tooltip_cat_cell,gt(r.cats,"cluster"),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),Rt(r.cats,[i],r.obs_store),Qt(r.genes,[],r.obs_store)},Az=(t,A,j,e)=>{let r=A??new Set,n=r.size>0,i=t.cell_names_array[e.index],o=n&&r.has(i),l;if(t.cat==="cluster")try{let c=t.cell_cats[e.index],B=t.color_dict_cluster[String(c)],h=t.selected_cats.length===0||t.selected_cats.includes(c)?255:0;Array.isArray(B)||(B=[0,0,0],h=0),l=[...B,h]}catch{l=[0,0,0,0]}else try{let c=t.cell_exp_array[e.index];if(t.selected_cats&&t.selected_cats.length>0&&t.selected_cats.some(h=>t.color_dict_cluster&&h in t.color_dict_cluster)){let h=t.cell_cats[e.index];t.selected_cats.includes(h)?l=[255,0,0,c]:l=[0,0,0,0]}else l=[255,0,0,c]}catch{l=[255,0,0,10]}return n?o?[0,0,255,255]:[0,0,0,0]:l},c_=async(t,A)=>{let j;A.seg.version==="default"?j=`${t}/cell_metadata.parquet`:j=`${t}/cell_metadata_${A.seg.version}.parquet`;let e=await ae(j,Nt.fetch,A.aws);if(o_(A.cats,e),A.spatial.cell_scatter_data=dl(e),await a_(A.genes,t,A.seg.version,A.aws),s_(A.cats),A.cats.has_meta_cell){let g=A.cats.meta_cell_attr.indexOf(A.cats.inst_cell_attr),E=A.cell_name_prefix||!1;A.cats.cell_cats=A.cats.cell_names_array.map(m=>adA(m,A.cats.meta_cell,E)?.[g]??"N.A.")}else{let g=await ae(`${t}/cell_clusters${A.seg.version&&A.seg.version!=="default"?`_${A.seg.version}`:""}/cluster.parquet`,Nt.fetch,A.aws);Nv(A.cats,g,"cluster")}Kv(A.cats);let r=e.getChild("name").toArray(),n=A.spatial.cell_scatter_data.attributes.getPosition.value,i=A.spatial.cell_scatter_data.attributes.getPosition.size||2;A.combo_data.cell=r.map((g,E)=>({name:g,cat:A.cats.dict_cell_cats[g],x:n[E*i],y:n[E*i+1],z:i===3?n[E*i+2]:0}));let o;if(A.umap.has_umap){let g=new Float64Array(A.cats.cell_names_array.flatMap(m=>{let y;return A.umap.umap[m]?y=A.umap.umap[m]:y=[0,0],y})),E=A.spatial.cell_scatter_data.length;o=Array.from({length:E},(m,y)=>({name:A.cats.cell_names_array[y],position:i===3?[n[y*i],n[y*i+1],n[y*i+2]]:[n[y*i],n[y*i+1]],umap:[g[y*2],g[y*2+1]]})),A.spatial.x_min=vr(o.map(m=>m.position[0])),A.spatial.x_max=xj(o.map(m=>m.position[0])),A.spatial.y_min=vr(o.map(m=>m.position[1])),A.spatial.y_max=xj(o.map(m=>m.position[1])),i===3&&(A.spatial.z_min=vr(o.map(m=>m.position[2])),A.spatial.z_max=xj(o.map(m=>m.position[2]))),o=l_(A,o)}else{let g=A.spatial.cell_scatter_data.length;o=Array.from({length:g},(E,m)=>({name:A.cats.cell_names_array[m],position:i===3?[n[m*i],n[m*i+1],n[m*i+2]]:[n[m*i],n[m*i+1]]})),A.spatial.x_min=vr(o.map(E=>E.position[0])),A.spatial.x_max=xj(o.map(E=>E.position[0])),A.spatial.y_min=vr(o.map(E=>E.position[1])),A.spatial.y_max=xj(o.map(E=>E.position[1])),i===3&&(A.spatial.z_min=vr(o.map(E=>E.position[2])),A.spatial.z_max=xj(o.map(E=>E.position[2])))}A.spatial.center_x=(A.spatial.x_max+A.spatial.x_min)/2,A.spatial.center_y=(A.spatial.y_max+A.spatial.y_min)/2,i===3&&(A.spatial.center_z=(A.spatial.z_max+A.spatial.z_min)/2,A.spatial.data_depth=A.spatial.z_max-A.spatial.z_min),A.spatial.data_width=A.spatial.x_max-A.spatial.x_min,A.spatial.data_height=A.spatial.y_max-A.spatial.y_min;let l=A.root.clientWidth,c=A.root.clientHeight,B=A.root.clientWidth,h=A.containers.root_dim.height;A.spatial.scale_x=B/A.spatial.data_width,A.spatial.scale_y=h/A.spatial.data_height,A.spatial.scale=Math.min(A.spatial.scale_x,A.spatial.scale_y),A.img.landscape_parameters.technology!=="Chromium"?(A.spatial.ini_zoom=Math.log2(A.spatial.scale)*1.01,A.spatial.ini_x=A.spatial.center_x,A.spatial.ini_y=A.spatial.center_y,i===3&&(A.spatial.ini_z=A.spatial.center_z)):(A.spatial.ini_zoom=Math.log2(B/5e3)*.95,A.spatial.ini_x=5e3,A.spatial.ini_y=5e3),A.spatial.cell_scatter_data_objects=o;let d={getPosition:{duration:3e3,easing:I6}},k;return A.img.landscape_parameters.technology==="point-cloud"?k=new Bx({id:"cell-layer",sizeUnits:"meters",pointSize:5,pickable:!0,getColor:(g,E)=>Az(A.cats,A.highlighted_cells,g,E),data:A.spatial.cell_scatter_data_objects,transitions:d,getPosition:g=>A.obs_store.umap_state.get()?g.umap:g.position,updateTriggers:{getPosition:[A.obs_store.umap_state.get()],getFillColor:[A.selection_token]},opacity:1,...Er(A.rotation)}):k=new mr({id:"cell-layer",radiusMinPixels:1,getRadius:5,pickable:!0,getFillColor:(g,E)=>Az(A.cats,A.highlighted_cells,g,E),data:A.spatial.cell_scatter_data_objects,transitions:d,getPosition:g=>A.obs_store.umap_state.get()?g.umap:g.position,updateTriggers:{getPosition:[A.obs_store.umap_state.get()],getFillColor:[A.selection_token]},...Er(A.rotation)}),k},u_=(t,A,j)=>{A.cell_layer=A.cell_layer.clone({onClick:(e,r)=>ldA(e,r,t,A,j)})},Au=(t,A)=>{t.cell_layer=t.cell_layer.clone({visible:A})},cdA=2,tz=(t,A,j)=>{j.img.landscape_parameters.technology==="point-cloud"?t.cell_layer=t.cell_layer.clone({pointSize:A/cdA}):t.cell_layer=t.cell_layer.clone({getRadius:A})},tu=(t,A)=>{t.cell_layer=t.cell_layer.clone({pickable:A})},jz=(t,A,j)=>{A.cell_layer=A.cell_layer.clone({updateTriggers:{getPosition:[j.obs_store.umap_state.get()]}})};var ez=(t,A,j="unknown")=>async({index:e})=>{let{x:r,y:n,z:i}=e,o=A+i,l=await t.readTile(o,r,n);return l?new Promise((c,B)=>{let h=new Image;h.onload=()=>c(h),h.onerror=B,h.src=l}):null},udA=(t,A,j=0,e="")=>{let{max_pyramid_zoom:r}=t.img.landscape_parameters,n=5,i=`${A.button_name}-ds${j}${e?`-${e}`:""}`,o=t.use_row_groups,l=t.row_group_readers?.images?.[A.name],c;return o&&l?c=ez(l,r,A.name):c=Hk(t.global_base_url,A.name,t.img.image_format,r,Nt,t.aws),new Sc({id:i,tileSize:t.dimensions.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:0,maxRequests:6,extent:[0,0,t.dimensions.width,t.dimensions.height],getTileData:c,renderSubLayers:ry(t.dimensions,A.color,n),...Er(t.rotation)})},B_=async(t,A=0)=>{let{image_info:j}=t.img,e=Date.now().toString(36);return j.length===1&&(j[0].name==="h_and_e"||j[0].name==="h&e")?[await of(t,j[0],A,e)]:j.map(n=>udA(t,n,A,e))},Cf=(t,A)=>{t.image_layers=t.image_layers.map(j=>j.clone({visible:A}))},rz=(t,A,j)=>{t.image_layers=t.image_layers.map(e=>e.id.startsWith(A)?e.clone({visible:j}):e)},nz=(t,A,j,e,r)=>{let n=r[j];A.image_layers=A.image_layers.map(i=>i.id.startsWith(j)?i.clone({renderSubLayers:ry(t.dimensions,n,e),id:`${j}-${e}`}):i)},iz=async(t,A,j,e=null)=>{let{image_info:r}=t.img,{max_pyramid_zoom:n,tile_size:i}=t.img.landscape_parameters,o=e||Date.now().toString(36),l=[],c=j/2,B=Math.max(i*3,j*.5),h=r.length===1&&(r[0].name==="h_and_e"||r[0].name==="h&e");return A.forEach((d,k)=>{let g=[Math.max(0,d.x-c-B),Math.max(0,d.y-c-B),Math.min(t.dimensions.width,d.x+c+B),Math.min(t.dimensions.height,d.y+c+B)];r.forEach(E=>{let y=`yb-${E.button_name}-p${k}-${o}`,b=h?ny(t.dimensions):ry(t.dimensions,E.color,5),v=t.use_row_groups,_=t.row_group_readers?.images?.[E.name],w;v&&_?w=ez(_,n,E.name):w=Hk(t.global_base_url,E.name,t.img.image_format,n,Nt,t.aws);let x=new Sc({id:y,tileSize:t.dimensions.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:50,maxRequests:6,extent:g,getTileData:w,renderSubLayers:b,...Er(t.rotation)});l.push(x)})}),l};var TA=(t,A,j)=>{t.obs_store.deck_check.set({...t.obs_store.deck_check.get(),[j]:!1}),t.layers_obj=A,t.obs_store.deck_check.set({...t.obs_store.deck_check.get(),[j]:!0})};var BdA=(t,A)=>{let j=ei(t.properties.color),e;return A.obs_store.selected_nbhds.get().length>0?A.obs_store.selected_nbhds.get().includes(t.properties.cat)?e=255:e=0:e=255,j.push(e),j},oz=(t,A)=>new La({id:"nbhd-layer",data:t.nbhd.feature_collection,pickable:!0,stroked:!1,filled:!0,getLineWidth:1,getFillColor:e=>BdA(e,t),opacity:.5,visible:A,...Er(t.rotation)});var sz=(t,A)=>{t.nbhd_layer=t.nbhd_layer.clone({opacity:A})},fdA=async(t,A,j,e,r)=>{let n=t.object.properties.cat,i=r.obs_store.selected_nbhds.get();i[0]===n&&i.length===1?r.obs_store.selected_nbhds.set([]):r.obs_store.selected_nbhds.set([n]),TA(r,e,"nbhd_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",o=>o.name===n?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)},az=(t,A,j)=>{A.nbhd_layer=A.nbhd_layer.clone({onClick:(e,r)=>fdA(e,r,t,A,j)})},pl=(t,A)=>{t.nbhd_layer=t.nbhd_layer.clone({visible:A})};var PI=class extends mr{getShaders(){let A=super.getShaders();return A.fs=`#version 300 es + `),{...A,inject:{...A.inject||{},"vs:#decl":(A.inject?.["vs:#decl"]||"").concat("uniform float pickingLineWidthExtraPixels;")}}}draw(A){super.draw({...A,uniforms:{...A.uniforms,pickingLineWidthExtraPixels:this.props.pickingLineWidthExtraPixels}})}};_f.defaultProps=gBA;_f.layerName="EditablePathLayer";var mBA=[0,0,0,153],EBA=[0,0,0,144],$BA=[0,0,0,255],xBA=[0,0,144,144],yBA=[144,144,144,255],vBA=[144,144,144,144],_BA=[192,0,0,255],qBA=[0,0,0,128],bBA=[124,0,192,255],GBA=[255,255,255,255],wBA=5,FBA=3,PBA=7,IBA=32*S0,DK=Ai;function Ps(t){return!t||typeof t!="function"?t:A=>t(MBA(A))}function MBA(t){return t.__source?t.__source.object:t.sourceFeature?t.sourceFeature.feature:t}function HK(t){switch(t.properties.editHandleType){case"existing":return _BA;case"snap-source":return bBA;case"intermediate":default:return qBA}}function OBA(t){return GBA}function TBA(t){switch(t.properties.editHandleType){case"existing":return wBA;case"snap":return PBA;case"intermediate":default:return FBA}}var SBA={mode:DK,onEdit:()=>{},pickable:!0,pickingRadius:10,pickingDepth:5,fp64:!1,filled:!0,stroked:!0,lineWidthScale:S0,lineWidthMinPixels:1,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,pickingLineWidthExtraPixels:0,lineWidthUnits:"pixels",lineJointRounded:!1,lineCapRounded:!1,lineMiterLimit:4,pointRadiusScale:1,pointRadiusMinPixels:2,pointRadiusMaxPixels:Number.MAX_SAFE_INTEGER,getLineColor:(t,A,j)=>A?$BA:mBA,getFillColor:(t,A,j)=>A?xBA:EBA,getRadius:t=>t&&t.properties&&t.properties.radius||t&&t.properties&&t.properties.size||1,getLineWidth:t=>t&&t.properties&&t.properties.lineWidth||3,getTentativeLineColor:t=>yBA,getTentativeFillColor:t=>vBA,getTentativeLineWidth:t=>t&&t.properties&&t.properties.lineWidth||3,editHandleType:"point",editHandlePointRadiusScale:1,editHandlePointOutline:!0,editHandlePointStrokeWidth:2,editHandlePointRadiusUnits:"pixels",editHandlePointRadiusMinPixels:4,editHandlePointRadiusMaxPixels:8,getEditHandlePointColor:HK,getEditHandlePointOutlineColor:OBA,getEditHandlePointRadius:TBA,editHandleIconAtlas:null,editHandleIconMapping:null,editHandleIconSizeScale:1,editHandleIconSizeUnits:"pixels",getEditHandleIcon:t=>t.properties.editHandleType,getEditHandleIconSize:10,getEditHandleIconColor:HK,getEditHandleIconAngle:0,billboard:!0},RBA={view:Xr,modify:Mo,translate:new yf(new Gs),transform:new yf(new T0),scale:Va,rotate:Qa,duplicate:u0,split:k0,extrude:g0,elevation:m0,drawPoint:E0,drawLineString:$0,drawPolygon:Ai,drawRectangle:Nc,drawSquare:y0,drawRectangleFromCenter:v0,drawSquareFromCenter:_0,drawCircleFromCenter:b0,drawCircleByBoundingBox:G0,drawEllipseByBoundingBox:w0,drawRectangleUsing3Points:F0,drawEllipseUsing3Points:P0,draw90DegreePolygon:I0,drawPolygonByDragging:M0},Is=class extends vf{constructor(){super(...arguments);I(this,"state")}renderLayers(){let j=this.getSubLayerProps({id:"geojson",data:this.props.data,fp64:this.props.fp64,filled:this.props.filled,stroked:this.props.stroked,lineWidthScale:this.props.lineWidthScale,lineWidthMinPixels:this.props.lineWidthMinPixels,lineWidthMaxPixels:this.props.lineWidthMaxPixels,lineWidthUnits:this.props.lineWidthUnits,lineJointRounded:this.props.lineJointRounded,lineCapRounded:this.props.lineCapRounded,lineMiterLimit:this.props.lineMiterLimit,pointRadiusScale:this.props.pointRadiusScale,pointRadiusMinPixels:this.props.pointRadiusMinPixels,pointRadiusMaxPixels:this.props.pointRadiusMaxPixels,getLineColor:this.selectionAwareAccessor(this.props.getLineColor),getFillColor:this.selectionAwareAccessor(this.props.getFillColor),getPointRadius:this.selectionAwareAccessor(this.props.getRadius),getLineWidth:this.selectionAwareAccessor(this.props.getLineWidth),_subLayerProps:{linestrings:{billboard:this.props.billboard,updateTriggers:{all:[this.props.selectedFeatureIndexes,this.props.mode]}},"polygons-stroke":{billboard:this.props.billboard,pickingLineWidthExtraPixels:this.props.pickingLineWidthExtraPixels,type:_f,updateTriggers:{all:[this.props.selectedFeatureIndexes,this.props.mode]}}},updateTriggers:{getLineColor:[this.props.selectedFeatureIndexes,this.props.mode],getFillColor:[this.props.selectedFeatureIndexes,this.props.mode],getPointRadius:[this.props.selectedFeatureIndexes,this.props.mode],getLineWidth:[this.props.selectedFeatureIndexes,this.props.mode]}}),e=[new La(j)];return e=e.concat(this.createGuidesLayers(),this.createTooltipsLayers()),e}initializeState(){super.initializeState(),this.setState({selectedFeatures:[],editHandles:[]})}shouldUpdateState(j){return super.shouldUpdateState(j)||j.changeFlags.stateChanged}updateState({props:j,oldProps:e,changeFlags:r,context:n}){if(super.updateState({oldProps:e,props:j,changeFlags:r,context:n}),r.propsOrDataChanged&&(Object.keys(e).length===0||j.mode!==e.mode)){let l;if(typeof j.mode=="function"){let c=j.mode;l=new c}else typeof j.mode=="string"?(l=RBA[j.mode],console.warn("Deprecated use of passing `mode` as a string. Pass the mode's class constructor instead.")):l=j.mode;l||(console.warn(`No mode configured for ${String(j.mode)}`),l=new DK),l!==this.state.mode&&this.setState({mode:l,cursor:null})}let i=[];if(Array.isArray(j.selectedFeatureIndexes)&&typeof j.data=="object"&&"features"in j.data){let o=j.data;i=j.selectedFeatureIndexes.map(l=>o.features[l])}this.setState({selectedFeatures:i})}getModeProps(j){return{modeConfig:j.modeConfig,data:j.data,selectedIndexes:j.selectedFeatureIndexes,lastPointerMoveEvent:this.state.lastPointerMoveEvent,cursor:this.state.cursor,onEdit:e=>{this.setNeedsUpdate(),j.onEdit(e)},onUpdateCursor:e=>{this.setState({cursor:e})}}}selectionAwareAccessor(j){return typeof j!="function"?j:e=>j(e,this.isFeatureSelected(e),this.props.mode)}isFeatureSelected(j){return!this.props.data||!this.props.selectedFeatureIndexes||!this.props.selectedFeatureIndexes.length?!1:this.state.selectedFeatures.includes(j)}getPickingInfo({info:j,sourceLayer:e}){return e.id.endsWith("guides")&&(j.isGuide=!0),j}_updateAutoHighlight(j){if(j?.sourceLayer)if(j.isGuide)for(let e of j.sourceLayer.getSubLayers())e.updateAutoHighlight(j);else j.sourceLayer.updateAutoHighlight(j)}createGuidesLayers(){let e=this.getActiveMode().getGuides(this.getModeProps(this.props));if(!e||!e.features.length)return[];let r={linestrings:{billboard:this.props.billboard,autoHighlight:!1},"polygons-fill":{autoHighlight:!1},"polygons-stroke":{billboard:this.props.billboard}};return this.props.editHandleType==="icon"?r["points-icon"]={type:z7,iconAtlas:this.props.editHandleIconAtlas,iconMapping:this.props.editHandleIconMapping,sizeUnits:this.props.editHandleIconSizeUnits,sizeScale:this.props.editHandleIconSizeScale,getIcon:Ps(this.props.getEditHandleIcon),getSize:Ps(this.props.getEditHandleIconSize),getColor:Ps(this.props.getEditHandleIconColor),getAngle:Ps(this.props.getEditHandleIconAngle),billboard:this.props.billboard}:r["points-circle"]={type:mr,radiusScale:this.props.editHandlePointRadiusScale,stroked:this.props.editHandlePointOutline,getLineWidth:this.props.editHandlePointStrokeWidth,radiusUnits:this.props.editHandlePointRadiusUnits,radiusMinPixels:this.props.editHandlePointRadiusMinPixels,radiusMaxPixels:this.props.editHandlePointRadiusMaxPixels,getRadius:Ps(this.props.getEditHandlePointRadius),getFillColor:Ps(this.props.getEditHandlePointColor),getLineColor:Ps(this.props.getEditHandlePointOutlineColor),billboard:this.props.billboard},[new La(this.getSubLayerProps({id:"guides",data:e,fp64:this.props.fp64,_subLayerProps:r,lineWidthScale:this.props.lineWidthScale,lineWidthMinPixels:this.props.lineWidthMinPixels,lineWidthMaxPixels:this.props.lineWidthMaxPixels,lineWidthUnits:this.props.lineWidthUnits,lineJointRounded:this.props.lineJointRounded,lineCapRounded:this.props.lineCapRounded,lineMiterLimit:this.props.lineMiterLimit,getLineColor:Ps(this.props.getTentativeLineColor),getLineWidth:Ps(this.props.getTentativeLineWidth),getFillColor:Ps(this.props.getTentativeFillColor),pointType:this.props.editHandleType==="icon"?"icon":"circle",iconAtlas:this.props.editHandleIconAtlas}))]}createTooltipsLayers(){let e=this.getActiveMode().getTooltips(this.getModeProps(this.props));return[new Ii({getSize:IBA,...this.getSubLayerProps({id:"tooltips",data:e})})]}onLayerClick(j){this.getActiveMode().handleClick(j,this.getModeProps(this.props))}onLayerKeyUp(j){this.getActiveMode().handleKeyUp(j,this.getModeProps(this.props))}onStartDragging(j){this.getActiveMode().handleStartDragging(j,this.getModeProps(this.props))}onDragging(j){this.getActiveMode().handleDragging(j,this.getModeProps(this.props))}onStopDragging(j){this.getActiveMode().handleStopDragging(j,this.getModeProps(this.props))}onPointerMove(j){this.setState({lastPointerMoveEvent:j}),this.getActiveMode().handlePointerMove(j,this.getModeProps(this.props))}getCursor({isDragging:j}){if(this.state===null||this.state===void 0)return null;let{cursor:e}=this.state;return e||(e=j?"grabbing":"grab"),e}getActiveMode(){return this.state.mode}};I(Is,"layerName","EditableGeoJsonLayer"),I(Is,"defaultProps",SBA);var LBA=Xr,CBA=9;var Jlt={mode:LBA,...Is.defaultProps,data:[],selectedIndexes:[],filled:!1,stroked:!0,lineWidthScale:S0,lineWidthMinPixels:1,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,lineWidthUnits:"pixels",getHexagons:t=>t.hexIds,getEditedCluster:(t,A)=>A?{...A,hexIds:t}:{hexIds:t},resolution:CBA};var fv={NONE:null,RECTANGLE:"rectangle",POLYGON:"polygon"},sct={[fv.RECTANGLE]:Nc,[fv.POLYGON]:Ai},act={[fv.RECTANGLE]:{dragToDraw:!0}},lct={selectionType:fv.RECTANGLE,layerIds:[],onSelect:()=>{}};function Kc(t,A){return t==null||A==null?NaN:tA?1:t>=A?0:NaN}function AI(t,A){return t==null||A==null?NaN:At?1:A>=t?0:NaN}function hv(t){let A,j,e;t.length!==2?(A=Kc,j=(o,l)=>Kc(t(o),l),e=(o,l)=>t(o)-l):(A=t===Kc||t===AI?t:HBA,j=t,e=t);function r(o,l,c=0,B=o.length){if(c>>1;j(o[h],l)<0?c=h+1:B=h}while(c>>1;j(o[h],l)<=0?c=h+1:B=h}while(cc&&e(o[h-1],l)>-e(o[h],l)?h-1:h}return{left:r,center:i,right:n}}function HBA(){return 0}function tI(t){return t===null?NaN:+t}var NK=hv(Kc),KK=NK.right,DBA=NK.left,NBA=hv(tI).center,jI=KK;var qf=class extends Map{constructor(A,j=zBA){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:j}}),A!=null)for(let[e,r]of A)this.set(e,r)}get(A){return super.get(XK(this,A))}has(A){return super.has(XK(this,A))}set(A,j){return super.set(KBA(this,A),j)}delete(A){return super.delete(XBA(this,A))}};function XK({_intern:t,_key:A},j){let e=A(j);return t.has(e)?t.get(e):j}function KBA({_intern:t,_key:A},j){let e=A(j);return t.has(e)?t.get(e):(t.set(e,j),j)}function XBA({_intern:t,_key:A},j){let e=A(j);return t.has(e)&&(j=t.get(e),t.delete(e)),j}function zBA(t){return t!==null&&typeof t=="object"?t.valueOf():t}var UBA=Math.sqrt(50),VBA=Math.sqrt(10),QBA=Math.sqrt(2);function dv(t,A,j){let e=(A-t)/Math.max(0,j),r=Math.floor(Math.log10(e)),n=e/Math.pow(10,r),i=n>=UBA?10:n>=VBA?5:n>=QBA?2:1,o,l,c;return r<0?(c=Math.pow(10,-r)/i,o=Math.round(t*c),l=Math.round(A*c),o/cA&&--l,c=-c):(c=Math.pow(10,r)*i,o=Math.round(t/c),l=Math.round(A/c),o*cA&&--l),l0))return[];if(t===A)return[t];let e=A=r))return[];let o=n-r+1,l=new Array(o);if(e)if(i<0)for(let c=0;c=e)&&(j=e);else{let e=-1;for(let r of t)(r=A(r,++e,t))!=null&&(j=r)&&(j=r)}return j}function vr(t,A){let j;if(A===void 0)for(let e of t)e!=null&&(j>e||j===void 0&&e>=e)&&(j=e);else{let e=-1;for(let r of t)(r=A(r,++e,t))!=null&&(j>r||j===void 0&&r>=r)&&(j=r)}return j}function F6(t,A,j){t=+t,A=+A,j=(r=arguments.length)<2?(A=t,t=0,1):r<3?1:+j;for(var e=-1,r=Math.max(0,Math.ceil((A-t)/j))|0,n=new Array(r);++e{}};function UK(){for(var t=0,A=arguments.length,j={},e;t=0&&(e=j.slice(r+1),j=j.slice(0,r)),j&&!A.hasOwnProperty(j))throw new Error("unknown type: "+j);return{type:j,name:e}})}kv.prototype=UK.prototype={constructor:kv,on:function(t,A){var j=this._,e=YBA(t+"",j),r,n=-1,i=e.length;if(arguments.length<2){for(;++n0)for(var j=new Array(r),e=0,r,n;e=0&&(A=t.slice(0,j))!=="xmlns"&&(t=t.slice(j+1)),nI.hasOwnProperty(A)?{space:nI[A],local:t}:t}function ZBA(t){return function(){var A=this.ownerDocument,j=this.namespaceURI;return j===gv&&A.documentElement.namespaceURI===gv?A.createElement(t):A.createElementNS(j,t)}}function AfA(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function bf(t){var A=Wa(t);return(A.local?AfA:ZBA)(A)}function tfA(){}function Xc(t){return t==null?tfA:function(){return this.querySelector(t)}}function VK(t){typeof t!="function"&&(t=Xc(t));for(var A=this._groups,j=A.length,e=new Array(j),r=0;r=v&&(v=G+1);!(w=m[v])&&++v=0;)(i=e[r])&&(n&&i.compareDocumentPosition(n)^4&&n.parentNode.insertBefore(i,n),n=i);return this}function i5(t){t||(t=ffA);function A(h,d){return h&&d?t(h.__data__,d.__data__):!h-!d}for(var j=this._groups,e=j.length,r=new Array(e),n=0;nA?1:t>=A?0:NaN}function o5(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this}function s5(){return Array.from(this)}function a5(){for(var t=this._groups,A=0,j=t.length;A1?this.each((A==null?EfA:typeof A=="function"?xfA:$fA)(t,A,j??"")):ul(this.node(),t)}function ul(t,A){return t.style.getPropertyValue(A)||$v(t).getComputedStyle(t,null).getPropertyValue(A)}function yfA(t){return function(){delete this[t]}}function vfA(t,A){return function(){this[t]=A}}function _fA(t,A){return function(){var j=A.apply(this,arguments);j==null?delete this[t]:this[t]=j}}function h5(t,A){return arguments.length>1?this.each((A==null?yfA:typeof A=="function"?_fA:vfA)(t,A)):this.node()[t]}function d5(t){return t.trim().split(/^|\s+/)}function iI(t){return t.classList||new p5(t)}function p5(t){this._node=t,this._names=d5(t.getAttribute("class")||"")}p5.prototype={add:function(t){var A=this._names.indexOf(t);A<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var A=this._names.indexOf(t);A>=0&&(this._names.splice(A,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};function k5(t,A){for(var j=iI(t),e=-1,r=A.length;++e=0&&(j=A.slice(e+1),A=A.slice(0,e)),{type:A,name:j}})}function KfA(t){return function(){var A=this.__on;if(A){for(var j=0,e=-1,r=A.length,n;j>8&15|A>>4&240,A>>4&15|A&240,(A&15)<<4|A&15,1):j===8?yv(A>>24&255,A>>16&255,A>>8&255,(A&255)/255):j===4?yv(A>>12&15|A>>8&240,A>>8&15|A>>4&240,A>>4&15|A&240,((A&15)<<4|A&15)/255):null):(A=WfA.exec(t))?new P6(A[1],A[2],A[3],1):(A=YfA.exec(t))?new P6(A[1]*255/100,A[2]*255/100,A[3]*255/100,1):(A=JfA.exec(t))?yv(A[1],A[2],A[3],A[4]):(A=ZfA.exec(t))?yv(A[1]*255/100,A[2]*255/100,A[3]*255/100,A[4]):(A=AhA.exec(t))?H5(A[1],A[2]/100,A[3]/100,1):(A=thA.exec(t))?H5(A[1],A[2]/100,A[3]/100,A[4]):O5.hasOwnProperty(t)?R5(O5[t]):t==="transparent"?new P6(NaN,NaN,NaN,0):null}function R5(t){return new P6(t>>16&255,t>>8&255,t&255,1)}function yv(t,A,j,e){return e<=0&&(t=A=j=NaN),new P6(t,A,j,e)}function rhA(t){return t instanceof z0||(t=o6(t)),t?(t=t.rgb(),new P6(t.r,t.g,t.b,t.opacity)):new P6}function wf(t,A,j,e){return arguments.length===1?rhA(t):new P6(t,A,j,e??1)}function P6(t,A,j,e){this.r=+t,this.g=+A,this.b=+j,this.opacity=+e}xv(P6,wf,sI(z0,{brighter(t){return t=t==null?_v:Math.pow(_v,t),new P6(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=t==null?K0:Math.pow(K0,t),new P6(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new P6(Uc(this.r),Uc(this.g),Uc(this.b),qv(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:L5,formatHex:L5,formatHex8:nhA,formatRgb:C5,toString:C5}));function L5(){return`#${zc(this.r)}${zc(this.g)}${zc(this.b)}`}function nhA(){return`#${zc(this.r)}${zc(this.g)}${zc(this.b)}${zc((isNaN(this.opacity)?1:this.opacity)*255)}`}function C5(){let t=qv(this.opacity);return`${t===1?"rgb(":"rgba("}${Uc(this.r)}, ${Uc(this.g)}, ${Uc(this.b)}${t===1?")":`, ${t})`}`}function qv(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Uc(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function zc(t){return t=Uc(t),(t<16?"0":"")+t.toString(16)}function H5(t,A,j,e){return e<=0?t=A=j=NaN:j<=0||j>=1?t=A=NaN:A<=0&&(t=NaN),new Oo(t,A,j,e)}function N5(t){if(t instanceof Oo)return new Oo(t.h,t.s,t.l,t.opacity);if(t instanceof z0||(t=o6(t)),!t)return new Oo;if(t instanceof Oo)return t;t=t.rgb();var A=t.r/255,j=t.g/255,e=t.b/255,r=Math.min(A,j,e),n=Math.max(A,j,e),i=NaN,o=n-r,l=(n+r)/2;return o?(A===n?i=(j-e)/o+(j0&&l<1?0:i,new Oo(i,o,l,t.opacity)}function K5(t,A,j,e){return arguments.length===1?N5(t):new Oo(t,A,j,e??1)}function Oo(t,A,j,e){this.h=+t,this.s=+A,this.l=+j,this.opacity=+e}xv(Oo,K5,sI(z0,{brighter(t){return t=t==null?_v:Math.pow(_v,t),new Oo(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=t==null?K0:Math.pow(K0,t),new Oo(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+(this.h<0)*360,A=isNaN(t)||isNaN(this.s)?0:this.s,j=this.l,e=j+(j<.5?j:1-j)*A,r=2*j-e;return new P6(aI(t>=240?t-240:t+120,r,e),aI(t,r,e),aI(t<120?t+240:t-120,r,e),this.opacity)},clamp(){return new Oo(D5(this.h),vv(this.s),vv(this.l),qv(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){let t=qv(this.opacity);return`${t===1?"hsl(":"hsla("}${D5(this.h)}, ${vv(this.s)*100}%, ${vv(this.l)*100}%${t===1?")":`, ${t})`}`}}));function D5(t){return t=(t||0)%360,t<0?t+360:t}function vv(t){return Math.max(0,Math.min(1,t||0))}function aI(t,A,j){return(t<60?A+(j-A)*t/60:t<180?j:t<240?A+(j-A)*(240-t)/60:A)*255}function lI(t,A,j,e,r){var n=t*t,i=n*t;return((1-3*t+3*n-i)*A+(4-6*n+3*i)*j+(1+3*t+3*n-3*i)*e+i*r)/6}function z5(t){var A=t.length-1;return function(j){var e=j<=0?j=0:j>=1?(j=1,A-1):Math.floor(j*A),r=t[e],n=t[e+1],i=e>0?t[e-1]:2*r-n,o=e()=>t;function ihA(t,A){return function(j){return t+j*A}}function ohA(t,A,j){return t=Math.pow(t,j),A=Math.pow(A,j)-t,j=1/j,function(e){return Math.pow(t+e*A,j)}}function V5(t){return(t=+t)==1?bv:function(A,j){return j-A?ohA(A,j,t):U0(isNaN(A)?j:A)}}function bv(t,A){var j=A-t;return j?ihA(t,j):U0(isNaN(t)?A:t)}var Vc=function t(A){var j=V5(A);function e(r,n){var i=j((r=wf(r)).r,(n=wf(n)).r),o=j(r.g,n.g),l=j(r.b,n.b),c=bv(r.opacity,n.opacity);return function(B){return r.r=i(B),r.g=o(B),r.b=l(B),r.opacity=c(B),r+""}}return e.gamma=t,e}(1);function Q5(t){return function(A){var j=A.length,e=new Array(j),r=new Array(j),n=new Array(j),i,o;for(i=0;ij&&(n=A.slice(j,n),o[i]?o[i]+=n:o[++i]=n),(e=e[0])===(r=r[0])?o[i]?o[i]+=r:o[++i]=r:(o[++i]=null,l.push({i,x:Vr(e,r)})),j=cI.lastIndex;return j180?B+=360:B-c>180&&(c+=360),d.push({i:h.push(r(h)+"rotate(",null,e)-2,x:Vr(c,B)})):B&&h.push(r(h)+"rotate("+B+e)}function o(c,B,h,d){c!==B?d.push({i:h.push(r(h)+"skewX(",null,e)-2,x:Vr(c,B)}):B&&h.push(r(h)+"skewX("+B+e)}function l(c,B,h,d,k,g){if(c!==h||B!==d){var E=k.push(r(k)+"scale(",null,",",null,")");g.push({i:E-4,x:Vr(c,h)},{i:E-2,x:Vr(B,d)})}else(h!==1||d!==1)&&k.push(r(k)+"scale("+h+","+d+")")}return function(c,B){var h=[],d=[];return c=t(c),B=t(B),n(c.translateX,c.translateY,B.translateX,B.translateY,h,d),i(c.rotate,B.rotate,h,d),o(c.skewX,B.skewX,h,d),l(c.scaleX,c.scaleY,B.scaleX,B.scaleY,h,d),c=B=null,function(k){for(var g=-1,E=d.length,m;++g=0&&t._call.call(void 0,A),t=t._next;--Ff}function nX(){Wc=(Pv=J0.now())+Iv,Ff=W0=0;try{sX()}finally{Ff=0,fhA(),Wc=0}}function BhA(){var t=J0.now(),A=t-Pv;A>iX&&(Iv-=A,Pv=t)}function fhA(){for(var t,A=Fv,j,e=1/0;A;)A._call?(e>A._time&&(e=A._time),t=A,A=A._next):(j=A._next,A._next=null,A=t?t._next=j:Fv=j);Y0=t,pI(e)}function pI(t){if(!Ff){W0&&(W0=clearTimeout(W0));var A=t-Wc;A>24?(t<1/0&&(W0=setTimeout(nX,t-J0.now()-Iv)),Q0&&(Q0=clearInterval(Q0))):(Q0||(Pv=J0.now(),Q0=setInterval(BhA,iX)),Ff=1,oX(nX))}}function Ov(t,A,j){var e=new Z0;return A=A==null?0:+A,e.restart(r=>{e.stop(),t(r+A)},A,j),e}var hhA=rI("start","end","cancel","interrupt"),dhA=[],cX=0,aX=1,Sv=2,Tv=3,lX=4,Rv=5,tg=6;function Bl(t,A,j,e,r,n){var i=t.__transition;if(!i)t.__transition={};else if(j in i)return;phA(t,j,{name:A,index:e,group:r,on:hhA,tween:dhA,time:n.time,delay:n.delay,duration:n.duration,ease:n.ease,timer:null,state:cX})}function jg(t,A){var j=rr(t,A);if(j.state>cX)throw new Error("too late; already scheduled");return j}function Qr(t,A){var j=rr(t,A);if(j.state>Tv)throw new Error("too late; already running");return j}function rr(t,A){var j=t.__transition;if(!j||!(j=j[A]))throw new Error("transition not found");return j}function phA(t,A,j){var e=t.__transition,r;e[A]=j,j.timer=Mv(n,0,j.time);function n(c){j.state=aX,j.timer.restart(i,j.delay,j.time),j.delay<=c&&i(c-j.delay)}function i(c){var B,h,d,k;if(j.state!==aX)return l();for(B in e)if(k=e[B],k.name===j.name){if(k.state===Tv)return Ov(i);k.state===lX?(k.state=tg,k.timer.stop(),k.on.call("interrupt",t,t.__data__,k.index,k.group),delete e[B]):+BSv&&e.state=0&&(A=A.slice(0,j)),!A||A==="start"})}function ShA(t,A,j){var e,r,n=ThA(A)?jg:Qr;return function(){var i=n(this,t),o=i.on;o!==e&&(r=(e=o).copy()).on(A,j),i.on=r}}function $X(t,A){var j=this._id;return arguments.length<2?rr(this.node(),j).on.on(t):this.each(ShA(j,t,A))}function RhA(t){return function(){var A=this.parentNode;for(var j in this.__transition)if(+j!==t)return;A&&A.removeChild(this)}}function xX(){return this.on("end.remove",RhA(this._id))}function yX(t){var A=this._name,j=this._id;typeof t!="function"&&(t=Xc(t));for(var e=this._groups,r=e.length,n=new Array(r),i=0;i=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)}function Yc(t,A){if((j=(t=A?t.toExponential(A-1):t.toExponential()).indexOf("e"))<0)return null;var j,e=t.slice(0,j);return[e.length>1?e[0]+e.slice(2):e,+t.slice(j+1)]}function Os(t){return t=Yc(Math.abs(t)),t?t[1]:NaN}function RX(t,A){return function(j,e){for(var r=j.length,n=[],i=0,o=t[0],l=0;r>0&&o>0&&(l+o+1>e&&(o=Math.max(1,e-l)),n.push(j.substring(r-=o,r+o)),!((l+=o+1)>e));)o=t[i=(i+1)%t.length];return n.reverse().join(A)}}function LX(t){return function(A){return A.replace(/[0-9]/g,function(j){return t[+j]})}}var AdA=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function fl(t){if(!(A=AdA.exec(t)))throw new Error("invalid format: "+t);var A;return new Dv({fill:A[1],align:A[2],sign:A[3],symbol:A[4],zero:A[5],width:A[6],comma:A[7],precision:A[8]&&A[8].slice(1),trim:A[9],type:A[10]})}fl.prototype=Dv.prototype;function Dv(t){this.fill=t.fill===void 0?" ":t.fill+"",this.align=t.align===void 0?">":t.align+"",this.sign=t.sign===void 0?"-":t.sign+"",this.symbol=t.symbol===void 0?"":t.symbol+"",this.zero=!!t.zero,this.width=t.width===void 0?void 0:+t.width,this.comma=!!t.comma,this.precision=t.precision===void 0?void 0:+t.precision,this.trim=!!t.trim,this.type=t.type===void 0?"":t.type+""}Dv.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function CX(t){A:for(var A=t.length,j=1,e=-1,r;j0&&(e=0);break}return e>0?t.slice(0,e)+t.slice(r+1):t}var gI;function HX(t,A){var j=Yc(t,A);if(!j)return t+"";var e=j[0],r=j[1],n=r-(gI=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,i=e.length;return n===i?e:n>i?e+new Array(n-i+1).join("0"):n>0?e.slice(0,n)+"."+e.slice(n):"0."+new Array(1-n).join("0")+Yc(t,Math.max(0,A+n-1))[0]}function mI(t,A){var j=Yc(t,A);if(!j)return t+"";var e=j[0],r=j[1];return r<0?"0."+new Array(-r).join("0")+e:e.length>r+1?e.slice(0,r+1)+"."+e.slice(r+1):e+new Array(r-e.length+2).join("0")}var EI={"%":(t,A)=>(t*100).toFixed(A),b:t=>Math.round(t).toString(2),c:t=>t+"",d:SX,e:(t,A)=>t.toExponential(A),f:(t,A)=>t.toFixed(A),g:(t,A)=>t.toPrecision(A),o:t=>Math.round(t).toString(8),p:(t,A)=>mI(t*100,A),r:mI,s:HX,X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function $I(t){return t}var DX=Array.prototype.map,NX=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function KX(t){var A=t.grouping===void 0||t.thousands===void 0?$I:RX(DX.call(t.grouping,Number),t.thousands+""),j=t.currency===void 0?"":t.currency[0]+"",e=t.currency===void 0?"":t.currency[1]+"",r=t.decimal===void 0?".":t.decimal+"",n=t.numerals===void 0?$I:LX(DX.call(t.numerals,String)),i=t.percent===void 0?"%":t.percent+"",o=t.minus===void 0?"\u2212":t.minus+"",l=t.nan===void 0?"NaN":t.nan+"";function c(h){h=fl(h);var d=h.fill,k=h.align,g=h.sign,E=h.symbol,m=h.zero,y=h.width,G=h.comma,v=h.precision,_=h.trim,w=h.type;w==="n"?(G=!0,w="g"):EI[w]||(v===void 0&&(v=12),_=!0,w="g"),(m||d==="0"&&k==="=")&&(m=!0,d="0",k="=");var x=E==="$"?j:E==="#"&&/[boxX]/.test(w)?"0"+w.toLowerCase():"",O=E==="$"?e:/[%p]/.test(w)?i:"",F=EI[w],C=/[defgprs%]/.test(w);v=v===void 0?6:/[gprs]/.test(w)?Math.max(1,Math.min(21,v)):Math.max(0,Math.min(20,v));function R(X){var T=x,Q=O,b,jA,pA;if(w==="c")Q=F(X)+Q,X="";else{X=+X;var dA=X<0||1/X<0;if(X=isNaN(X)?l:F(Math.abs(X),v),_&&(X=CX(X)),dA&&+X==0&&g!=="+"&&(dA=!1),T=(dA?g==="("?g:o:g==="-"||g==="("?"":g)+T,Q=(w==="s"?NX[8+gI/3]:"")+Q+(dA&&g==="("?")":""),C){for(b=-1,jA=X.length;++bpA||pA>57){Q=(pA===46?r+X.slice(b+1):X.slice(b))+Q,X=X.slice(0,b);break}}}G&&!m&&(X=A(X,1/0));var $A=T.length+X.length+Q.length,_A=$A>1)+T+X+Q+_A.slice($A);break;default:X=_A+T+X+Q;break}return n(X)}return R.toString=function(){return h+""},R}function B(h,d){var k=c((h=fl(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(Os(d)/3)))*3,E=Math.pow(10,-g),m=NX[8+g/3];return function(y){return k(E*y)+m}}return{format:c,formatPrefix:B}}var Nv,Kv,Xv;xI({thousands:",",grouping:[3],currency:["$",""]});function xI(t){return Nv=KX(t),Kv=Nv.format,Xv=Nv.formatPrefix,Nv}function yI(t){return Math.max(0,-Os(Math.abs(t)))}function vI(t,A){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Os(A)/3)))*3-Os(Math.abs(t)))}function _I(t,A){return t=Math.abs(t),A=Math.abs(A)-t,Math.max(0,Os(A)-Os(t))+1}function qI(t){for(var A=-1,j=t.length,e,r=t[j-1],n=0;++AA&&(j=t,t=A,A=j),function(e){return Math.max(t,Math.min(A,e))}}function jdA(t,A,j){var e=t[0],r=t[1],n=A[0],i=A[1];return r2?edA:jdA,l=c=null,h}function h(d){return d==null||isNaN(d=+d)?n:(l||(l=o(t.map(e),A,j)))(e(i(d)))}return h.invert=function(d){return i(r((c||(c=o(A,t.map(e),Vr)))(d)))},h.domain=function(d){return arguments.length?(t=Array.from(d,GI),B()):t.slice()},h.range=function(d){return arguments.length?(A=Array.from(d),B()):A.slice()},h.rangeRound=function(d){return A=Array.from(d),j=BI,B()},h.clamp=function(d){return arguments.length?(i=d?!0:Mf,B()):i!==Mf},h.interpolate=function(d){return arguments.length?(j=d,B()):j},h.unknown=function(d){return arguments.length?(n=d,h):n},function(d,k){return e=d,r=k,B()}}function FI(){return rdA()(Mf,Mf)}function PI(t,A,j,e){var r=eI(t,A,j),n;switch(e=fl(e??",f"),e.type){case"s":{var i=Math.max(Math.abs(t),Math.abs(A));return e.precision==null&&!isNaN(n=vI(r,i))&&(e.precision=n),Xv(e,i)}case"":case"e":case"g":case"p":case"r":{e.precision==null&&!isNaN(n=_I(r,Math.max(Math.abs(t),Math.abs(A))))&&(e.precision=n-(e.type==="e"));break}case"f":case"%":{e.precision==null&&!isNaN(n=yI(r))&&(e.precision=n-(e.type==="%")*2);break}}return Kv(e)}function ndA(t){var A=t.domain;return t.ticks=function(j){var e=A();return pv(e[0],e[e.length-1],j??10)},t.tickFormat=function(j,e){var r=A();return PI(r[0],r[r.length-1],j??10,e)},t.nice=function(j){j==null&&(j=10);var e=A(),r=0,n=e.length-1,i=e[r],o=e[n],l,c,B=10;for(o0;){if(c=R0(i,o,j),c===l)return e[r]=i,e[n]=o,A(e);if(c>0)i=Math.floor(i/c)*c,o=Math.ceil(o/c)*c;else if(c<0)i=Math.ceil(i*c)/c,o=Math.floor(o*c)/c;else break;l=c}return t},t}function ji(){var t=FI();return t.copy=function(){return UX(t,ji())},If.apply(t,arguments),ndA(t)}function hl(t,A,j){this.k=t,this.x=A,this.y=j}hl.prototype={constructor:hl,scale:function(t){return t===1?this:new hl(this.k*t,this.x,this.y)},translate:function(t,A){return t===0&A===0?this:new hl(this.k,this.x+this.k*t,this.y+this.k*A)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var II=new hl(1,0,0);MI.prototype=hl.prototype;function MI(t){for(;!t.__zoom;)if(!(t=t.parentNode))return II;return t.__zoom}var Uv=(t,A,j,e,r)=>{let n=Math.floor(t/r),i=Math.floor(A/r),o=Math.floor(j/r),l=Math.floor(e/r),c=[];for(let B=n;B<=i;B++)for(let h=o;h<=l;h++)c.push({tileX:B,tileY:h,name:`${B}_${h}`});return c};var gt=(t,A)=>{t.cat=A},Vv=(t,A,j)=>{t.cell_cats=A.getChild(j).toArray()},VX=(t,A)=>{t.cell_cats=A.map(j=>j==="nan"?null:j)},Qv=t=>{t.cell_names_array.forEach((A,j)=>{t.dict_cell_cats[A]=t.cell_cats[j]})},Rt=(t,A,j)=>{t.reset_cat=A.length===t.selected_cats.length&&A.every((e,r)=>e===t.selected_cats[r]),t.selected_cats=t.reset_cat?[]:A,j.selected_cats.set(t.selected_cats)};var Wt=(t,A,j)=>{let e=A.length===t.selected_genes.length&&A.every((r,n)=>r===t.selected_genes[n]);t.selected_genes=e?[]:A,j.selected_genes.set(t.selected_genes)},eg=(t,A)=>{if(t.model&&typeof t.model.set=="function"){t.model.set("selected_genes",A);let{row_entity:j}=t;j?.entity==="gene"&&t.model.set("selected_rows",A),t.model.save_changes()}t.obs_store&&t.obs_store.selected_genes&&t.obs_store.selected_genes.set(A)},Wv=(t,A)=>{if(t.model&&typeof t.model.set=="function"){t.model.set("selected_rows",A);let{row_entity:j}=t;j?.entity==="gene"&&t.model.set("selected_genes",A),t.model.save_changes()}},Yv=(t,A)=>{t.model&&typeof t.model.set=="function"&&(t.model.set("selected_cols",A),t.model.save_changes())};var QX=async(t,A,j,e=null)=>{let r;if(t.get(A))r=t.get(A);else try{let n=e!==null?await e.fetch(A):await fetch(A,j.fetch);if(!n.ok)throw new Error(`Network response was not ok: ${n.statusText}`);let i=await n.arrayBuffer();r=dr(i),t.set(A,r)}catch(n){Zj(n,{context:`fetching or parsing Arrow data from ${A}`,url:A,logUnexpected:!0,throwOnAuth:!1}),r=null}return r};var Jv=async(t,A,j,e)=>Promise.all(A.map(r=>QX(t,r,j,e)));var Zv=t=>{t=t.filter(j=>j!=null);let A={length:0,startIndices:new Int32Array,attributes:{getPolygon:{value:new Float64Array,size:2}}};return t.forEach((j,e)=>{A.length+=j.length;let r=A.attributes.getPolygon.value.length/2,n=j.startIndices;if(e>0){n=new Int32Array(j.startIndices.length);for(let i=0;i0?1:0)]),A.attributes.getPolygon.value=new Float64Array([...A.attributes.getPolygon.value,...j.attributes.getPolygon.value])}),A},A_=t=>{if(t.length===0)return null;let A=t[0];for(let j=1;j{let A=t.getChild("GEOMETRY")||t.getChild("geometry")||t.getChildAt(0);if(!A||A.data[0].type.typeId!==12)return null;let j=A.data,e=j.length,r=A.getChildAt(0),n=A.getChildAt(0).getChildAt(0).getChildAt(0);if(e===1)return WX(j[0],r.data[0],n.data[0]);let i=[];for(let o=0;o0&&i.push(h)}return Zv(i)};var TI=t=>{let A=[],{startIndices:j,attributes:e}=t,r=e.getPolygon.value,n=j.length-1;for(let i=0;i({tile_x:r.tileX,tile_y:r.tileY}));return j.readTiles(e)}function YX(t,A){let j=Array.isArray(t)?t:[t];return A.vector_name_integer?j.flatMap(e=>{let r=e.getChild("name");return r?Array.from(r.toArray()).map(i=>A.cats.nameMapping_inv[i]):[]}):j.flatMap(e=>{let r=e.getChild("name");return r?Array.from(r.toArray()):[]})}var JX=async(t,A,j)=>{if(j.use_row_groups&&j.row_group_readers?.cell){let B=await idA(A,j);if(!B)return j.cats.polygon_cell_names=[],[];j.cats.polygon_cell_names=YX(B,j);let h=OI(B);return TI(h)}let e;j.seg.version==="default"?e=`${t}/cell_segmentation`:e=`${t}/cell_segmentation_${j.seg.version}`;let r=A.map(B=>`${e}/cell_tile_${B.tileX}_${B.tileY}.parquet`),i=(await Jv(j.cache.cell,r,Nt,j.aws)).filter(B=>B!==null);if(i.length===0)return j.cats.polygon_cell_names=[],[];j.cats.polygon_cell_names=YX(i,j);let o=i.map(B=>OI(B)),l=Zv(o);return TI(l)};var odA=(t,A,j)=>{let e=t.polygon_cell_names[j.index],r=t.dict_cell_cats[e],n,i=String(r);i in t.color_dict_cluster?n=t.color_dict_cluster[i]:n=[0,0,255];let o=t.selected_cats.length===0||t.selected_cats.includes(r)?255:50;return[...n,o]},t_=t=>new _o({id:"path-layer",data:[],pickable:!0,widthScale:3,widthMinPixels:1,getPath:j=>j,getColor:(j,e)=>odA(t.cats,j,e),widthUnits:"pixels",...Er(t.rotation)}),sdA=async(t,A,j,e,r)=>{let n=r.cats.polygon_cell_names[t.index],i=r.cats.dict_cell_cats[n];r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),gt(r.cats,"cluster"),Rt(r.cats,[i],r.obs_store),Wt(r.genes,[],r.obs_store)},j_=async(t,A,j,e)=>{let r=await JX(t,A,e);j.path_layer=j.path_layer.clone({data:r}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),path_data:!0})},e_=(t,A,j)=>{A.path_layer=A.path_layer.clone({onClick:(e,r)=>sdA(e,r,t,A,j)})},Of=(t,A)=>{t.path_layer=t.path_layer.clone({visible:A})},Jc=(t,A)=>{t.path_layer=t.path_layer.clone({pickable:A})};var ae=async(t,A,j)=>{try{let r=await(j!==null?await j.fetch(t):await fetch(t,A)).arrayBuffer();return dr(r)}catch(e){return Zj(e,{context:"loading arrow table data",url:t,logUnexpected:!0,throwOnAuth:!1}),[]}};function ZX(t,A){let j=Math.log1p(t),e=Math.log1p(A);return j/e*255}async function adA(t,A){let j=await t.readGene(A);if(!j)return{cell_names:[],cell_exp:[]};let e=j.getChild("cell_id")?.toArray()||[],r=j.getChild("expression")?.toArray()||[];return{cell_names:e,cell_exp:r}}var qr=async(t,A,j,e,r,n,i,o=null)=>{let l,c;if(o)({cell_names:l,cell_exp:c}=await adA(o,e));else{let g;r==="default"?g=`${j}/cbg/${e}.parquet`:g=`${j}/cbg_${r}/${e}.parquet`;let E=await ae(g,Nt.fetch,i);l=E.getChild("__index_level_0__").toArray(),c=E.getChild(e).toArray()}let B=new Array(t.cell_names_array.length).fill(0),h=t.meta_cell_id_set&&t.meta_cell_id_set.size>0?t.meta_cell_id_set:null,d=new Set,k=new Set;l.forEach((g,E)=>{g=String(g);let m=Number(c[E]),y=Number(A.meta_gene[e].max);if(n)if(g in t.nameMapping_inv){let G=String(t.nameMapping_inv[g]);(!h||h.has(G))&&(B[g]=ZX(m,y))}else k.add(g);else if(t.cell_name_to_index_map.has(g)){let G=t.cell_name_to_index_map.get(g);(!h||h.has(g))&&(B[G]=ZX(m,y))}else d.add(g)}),d.size>0,k.size>0,t.cell_exp_array=B};var dl=t=>{if(!t)return{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}};try{let A=t.getChild("geometry").getChildAt(0).data.map(r=>r.values).reduce((r,n)=>{let i=new Float64Array(r.length+n.length);return i.set(r),i.set(n,r.length),i},new Float64Array(0)),j=A.length/t.numRows;return{length:t.numRows,attributes:{getPosition:{value:A,size:j}}}}catch(A){return Zj(A,{context:"processing scatter data from arrow table",logUnexpected:!0,throwOnAuth:!1}),{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}}}};async function ldA(t,A){let j=A.row_group_readers?.trx;if(!j)return null;let e=t.map(r=>({tile_x:r.tileX,tile_y:r.tileY}));return j.readTiles(e)}var Az=async(t,A,j)=>{let e;if(j.use_row_groups&&j.row_group_readers?.trx)e=await ldA(A,j);else{let o=A.map(B=>`${t}/transcript_tiles/transcripts_tile_${B.tileX}_${B.tileY}.parquet`),c=(await Jv(j.cache.trx,o,Nt,j.aws)).filter(B=>B!==null);e=A_(c)}if(!e)return j.genes.trx_names_array=[],j.combo_data.trx=[],{length:0,attributes:{getPosition:{value:new Float32Array,size:2}}};let r=[];if(!j.vector_name_integer)r=e.getChild("name")?.toArray()||[];else{let o=e.getChild("name");r=o?Array.from(o.toArray()).map(l=>j.genes.g_nameMapping_inv[l]):[]}j.genes.trx_names_array=r;let n=dl(e),i=n.attributes.getPosition.value;return j.combo_data.trx=j.genes.trx_names_array.map((o,l)=>({name:o,x:i[l*2],y:i[l*2+1]})),n};var cdA=async(t,A,j,e,r)=>{let n=r.genes.trx_names_array[t.index];if(!n)return;let o=n===r.cats.cat?"cluster":n;gt(r.cats,o),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Wt(r.genes,[n],r.obs_store),Rt(r.cats,[n],r.obs_store),await qr(r.cats,r.genes,r.global_base_url,n,r.seg.version,r.vector_name_integer,r.aws,r.row_group_readers?.cbg)},r_=t=>{let{genes:A}=t;return new mr({id:"trx-layer",data:A.trx_data,pickable:!0,getFillColor:(e,r)=>{let n=A.trx_names_array[r.index],i=A.color_dict_gene[n],o=A.selected_genes.length===0||A.selected_genes.includes(n)?255:5;return[...i,o]},...Er(t.rotation)})},n_=(t,A,j)=>{A.trx_layer=A.trx_layer.clone({onClick:(e,r)=>cdA(e,r,t,A,j)})},i_=async(t,A,j,e)=>{e.genes.trx_data=await Az(t,A,e),j.trx_layer=j.trx_layer.clone({data:e.genes.trx_data}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!0,trx_data:!0})},Ts=(t,A)=>{t.trx_layer=t.trx_layer.clone({visible:A})},Tf=(t,A)=>{t.trx_layer=t.trx_layer.clone({getRadius:A})},Zc=(t,A)=>{t.trx_layer=t.trx_layer.clone({pickable:A})};var o_=async({height:t,width:A,zoom:j,target:e},r,n,i)=>{let o=i.close_up,{tile_size:l}=i.img.landscape_parameters,c=Math.pow(2,j),[B,h]=e,d=A/(2*c),k=t/(2*c);i.bounds={},i.bounds.min_x=B-d,i.bounds.max_x=B+d,i.bounds.min_y=h-k,i.bounds.max_y=h+k;let g=r.viewManager.getViewports();if(!g||g.length===0)return;let E=(()=>{if(!i.rotation?.hasRotation)return i.bounds;let y=[[i.bounds.min_x,i.bounds.min_y],[i.bounds.min_x,i.bounds.max_y],[i.bounds.max_x,i.bounds.min_y],[i.bounds.max_x,i.bounds.max_y]].map(([_,w])=>lD(_,w,i.rotation)),G=y.map(([_])=>_),v=y.map(([,_])=>_);return{min_x:Math.min(...G),max_x:Math.max(...G),min_y:Math.min(...v),max_y:Math.max(...v)}})(),m=Uv(E.min_x,E.max_x,E.min_y,E.max_y,l);if(m.length{if(!i.rotation?.hasRotation)return O.x>=i.bounds.min_x&&O.x<=i.bounds.max_x&&O.y>=i.bounds.min_y&&O.y<=i.bounds.max_y;let[F,C]=a1(O.x,O.y,i.rotation);return F>=i.bounds.min_x&&F<=i.bounds.max_x&&C>=i.bounds.min_y&&C<=i.bounds.max_y}).map(O=>O.name).reduce((O,F)=>{let C=O.find(R=>R.name===F);return C?C.value+=1:O.push({name:F,value:1}),O},[]).filter(O=>O.value>0).sort((O,F)=>F.value-O.value).slice(0,100);i.obs_store.new_gene_bar_data.set(v);let x=i.combo_data.cell.filter(O=>{if(!i.rotation?.hasRotation)return O.x>=i.bounds.min_x&&O.x<=i.bounds.max_x&&O.y>=i.bounds.min_y&&O.y<=i.bounds.max_y;let[F,C]=a1(O.x,O.y,i.rotation);return F>=i.bounds.min_x&&F<=i.bounds.max_x&&C>=i.bounds.min_y&&C<=i.bounds.max_y}).map(O=>O.cat).reduce((O,F)=>{let C=O.find(R=>R.name===F);return C?C.value+=1:O.push({name:F,value:1}),O},[]).filter(O=>O.value>0).sort((O,F)=>F.value-O.value);i.obs_store.new_cell_bar_data.set(x)}else o&&(i.obs_store.deck_check.set({...i.obs_store.deck_check.get(),trx_data:!1,path_data:!1}),i.close_up=!1,i.obs_store.close_up.set(!1),i.obs_store.deck_check.set({...i.obs_store.deck_check.get(),trx_data:!0,path_data:!0}),i.obs_store.new_gene_bar_data.set(i.genes.top_gene_counts),i.obs_store.new_cell_bar_data.set(i.cats.cluster_counts),i.containers.bar_gene.scrollTo({top:0,behavior:"smooth"}),i.containers.bar_cluster.scrollTo({top:0,behavior:"smooth"}));i.layers_obj=n};var tz=(t,A)=>{if(t.index===-1||!t.layer)return null;let j=A.cats.tile_cats_array[t.index];return A.tooltip_cat_cell=j,oI(".deck-tooltip").style("margin-top","75px"),{html:`
${j}
`}},jz=(t,A)=>{if(A.index===-1||!A.layer||t.edit?.mode==="sktch")return null;let j="",e="",r="";if(A.layer.id.startsWith("cell-layer")||A.layer.id.startsWith("path-layer"))e=A.layer.id.startsWith("cell-layer")?t.cats.cell_names_array[A.index]:t.cats.polygon_cell_names[A.index],r=t.cats.dict_cell_cats[e],j=`
cell: ${e}
cluster: ${r}
`,t.tooltip_cat_cell=r;else if(A.layer.id.startsWith("trx-layer"))e=t.genes.trx_names_array[A.index],j=`
transcript: ${e}
`;else if(A.layer.id.startsWith("nbhd-layer"))e=t.nbhd.feature_collection.features[A.index].properties.name,r=t.nbhd.feature_collection.features[A.index].properties.cat,j=`
neighborhood: ${e}
category: ${r}
`;else if(A.layer.id.startsWith("edit-layer")){let i=t.edit?.feature_collection?.features?.[A.index];i&&(e=i.properties.name||`nbhd_${A.index+1}`,r=i.properties.cat||e,j=`
neighborhood: ${e}
`)}let n=t.root.querySelector(".deck-tooltip");if(n){n.style.marginTop="50px";let i=n.parentElement?.parentElement;i&&(i.style.position="unset")}return{html:j}};var Sf=(t,A,j=!1)=>{let e;return function(...r){let n=j&&!e;clearTimeout(e),e=setTimeout(()=>{e=null,j||t.apply(this,r)},A),n&&t.apply(this,r)}};var udA=200,ez=Sf(({viewState:t},A,j,e)=>(e.obs_store.umap_state.get()===!1&&o_(t,A,j,e),e.scale_bar&&e.obs_store.scale_bar_view_state.set(t),typeof e.custom_callbacks.view_change=="function"&&e.custom_callbacks.view_change(t,e.close_up,j.trx_layer),t),udA);var BdA=({isDragging:t})=>t?"grabbing":"pointer",s_=(t,A,j,e="")=>{let r={doubleClickZoom:!1};return e==="point-cloud"&&(r.type=Sa),new N7({parent:t,controller:r,getCursor:BdA,width:A,height:j})},a_=(t,A)=>{t.setProps({views:A})},l_=(t,A)=>{t.setProps({getTooltip:j=>jz(A,j)})},rz=(t,A,j)=>{t.setProps({onViewStateChange:e=>{ez(e,t,A,j)}})},nz=(t,A,j,e,r,n,i=0,o=0)=>{let{center_x:l,center_y:c,center_z:B=0,ini_zoom:h}=n.spatial;A===0&&j===0&&e===0&&r===0&&(A=l,j=c,e=B,r=h);let d={target:[A,j,e],zoom:r};n.img.landscape_parameters.technology==="point-cloud"&&(d.rotationOrbit=i,d.rotationX=o),t.setProps({initialViewState:d}),n.scale_bar&&n.obs_store.scale_bar_view_state.set(d)};var Rf=t=>{let A=[0,0,0,255],{width:j,height:e}=t.dimensions;return new Q7({id:"background-layer",data:[{polygon:[[0,0],[j,0],[j,e],[0,e]]}],getPolygon:n=>n.polygon,getFillColor:A,pickable:!1,...Er(t.rotation)})},c_=(t,A)=>{t.background_layer=t.background_layer.clone({visible:A})};var u_=(t,A)=>{t.cell_names_array=A.getChild("name").toArray();let j=t.cell_names_array.reduce((e,r,n)=>(e[n]=r,e),{});t.nameMapping_inv=j},B_=t=>{t.cell_names_array.forEach((A,j)=>{A=String(A),t.cell_name_to_index_map.set(A,j)})};var ei=t=>(t=t.replace(/^#/,""),t.length===3&&(t=t.replace(/./g,"$&$&")),t.length===6?[0,2,4].map(A=>parseInt(t.substr(A,2),16)):[0,0,0]),fdA=t=>{if(!t||!Array.isArray(t)||t.length<3)return"#808080";let A=n=>Math.max(0,Math.min(255,Math.round(n))),j=A(t[0]).toString(16).padStart(2,"0"),e=A(t[1]).toString(16).padStart(2,"0"),r=A(t[2]).toString(16).padStart(2,"0");return`#${j}${e}${r}`},Lf=()=>{let t=Math.floor(Math.random()*256),A=Math.floor(Math.random()*256),j=Math.floor(Math.random()*256);return fdA([t,A,j])};var f_=async(t,A,j,e)=>{let r;j==="default"?r=`${A}/meta_gene.parquet`:r=`${A}/meta_gene_${j}.parquet`;let n=await ae(r,Nt.fetch,e),i=[],o=[],l=n.getChild("__index_level_0__"),c=n.getChild("color");l&&c&&(i=l.toArray(),o=c.toArray()),i.forEach((B,h)=>{t.color_dict_gene[B]=ei(o[h])}),t.gene_names=i};var h_=(t,A)=>{let j,e,r,n;["Chromium","point-cloud"].includes(t.img.landscape_parameters.technology)?(j=0,e=1e4,r=0,n=1e4):{x_min:j,x_max:e,y_min:r,y_max:n}=t.spatial;let i=e-j,o=n-r,l=Math.max(i,o),c=(e-j)/2,B=(n-r)/2,h=vr(A.map(w=>w.umap[0])),d=xj(A.map(w=>w.umap[0])),k=vr(A.map(w=>w.umap[1])),g=xj(A.map(w=>w.umap[1])),E=d-h,m=g-k;A.forEach(w=>{w.umap[0]=(w.umap[0]-h)/E*l,w.umap[1]=(w.umap[1]-k)/m*l}),h=vr(A.map(w=>w.umap[0])),d=xj(A.map(w=>w.umap[0])),k=vr(A.map(w=>w.umap[1])),g=xj(A.map(w=>w.umap[1]));let y=(d-h)/2,G=(g-k)/2,v=c-y,_=B-G;return A.forEach(w=>{w.umap[0]=w.umap[0]+v,w.umap[1]=w.umap[1]+_}),A};var hdA=(t,A,j)=>{if(A[t]!==void 0)return A[t];if(j&&typeof t=="string"){let e=t.indexOf("_");if(e>=0){let r=t.substring(e+1);if(A[r]!==void 0)return A[r]}}},ddA=async(t,A,j,e,r)=>{let n="ontouchstart"in window||navigator.maxTouchPoints>0,i;n?i=r.cats.cell_cats[t.index]:i=r.tooltip_cat_cell,gt(r.cats,"cluster"),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),Rt(r.cats,[i],r.obs_store),Wt(r.genes,[],r.obs_store)},iz=(t,A,j,e)=>{let r=A??new Set,n=r.size>0,i=t.cell_names_array[e.index],o=n&&r.has(i),l;if(t.cat==="cluster")try{let c=t.cell_cats[e.index],B=t.color_dict_cluster[String(c)],h=t.selected_cats.length===0||t.selected_cats.includes(c)?255:0;Array.isArray(B)||(B=[0,0,0],h=0),l=[...B,h]}catch{l=[0,0,0,0]}else try{let c=t.cell_exp_array[e.index];if(t.selected_cats&&t.selected_cats.length>0&&t.selected_cats.some(h=>t.color_dict_cluster&&h in t.color_dict_cluster)){let h=t.cell_cats[e.index];t.selected_cats.includes(h)?l=[255,0,0,c]:l=[0,0,0,0]}else l=[255,0,0,c]}catch{l=[255,0,0,10]}return n?o?[0,0,255,255]:[0,0,0,0]:l},d_=async(t,A)=>{let j;A.seg.version==="default"?j=`${t}/cell_metadata.parquet`:j=`${t}/cell_metadata_${A.seg.version}.parquet`;let e=await ae(j,Nt.fetch,A.aws);if(u_(A.cats,e),A.spatial.cell_scatter_data=dl(e),await f_(A.genes,t,A.seg.version,A.aws),B_(A.cats),A.cats.has_meta_cell){let g=A.cats.meta_cell_attr.indexOf(A.cats.inst_cell_attr),E=A.cell_name_prefix||!1;A.cats.cell_cats=A.cats.cell_names_array.map(m=>hdA(m,A.cats.meta_cell,E)?.[g]??"N.A.")}else{let g=await ae(`${t}/cell_clusters${A.seg.version&&A.seg.version!=="default"?`_${A.seg.version}`:""}/cluster.parquet`,Nt.fetch,A.aws);Vv(A.cats,g,"cluster")}Qv(A.cats);let r=e.getChild("name").toArray(),n=A.spatial.cell_scatter_data.attributes.getPosition.value,i=A.spatial.cell_scatter_data.attributes.getPosition.size||2;A.combo_data.cell=r.map((g,E)=>({name:g,cat:A.cats.dict_cell_cats[g],x:n[E*i],y:n[E*i+1],z:i===3?n[E*i+2]:0}));let o;if(A.umap.has_umap){let g=new Float64Array(A.cats.cell_names_array.flatMap(m=>{let y;return A.umap.umap[m]?y=A.umap.umap[m]:y=[0,0],y})),E=A.spatial.cell_scatter_data.length;o=Array.from({length:E},(m,y)=>({name:A.cats.cell_names_array[y],position:i===3?[n[y*i],n[y*i+1],n[y*i+2]]:[n[y*i],n[y*i+1]],umap:[g[y*2],g[y*2+1]]})),A.spatial.x_min=vr(o.map(m=>m.position[0])),A.spatial.x_max=xj(o.map(m=>m.position[0])),A.spatial.y_min=vr(o.map(m=>m.position[1])),A.spatial.y_max=xj(o.map(m=>m.position[1])),i===3&&(A.spatial.z_min=vr(o.map(m=>m.position[2])),A.spatial.z_max=xj(o.map(m=>m.position[2]))),o=h_(A,o)}else{let g=A.spatial.cell_scatter_data.length;o=Array.from({length:g},(E,m)=>({name:A.cats.cell_names_array[m],position:i===3?[n[m*i],n[m*i+1],n[m*i+2]]:[n[m*i],n[m*i+1]]})),A.spatial.x_min=vr(o.map(E=>E.position[0])),A.spatial.x_max=xj(o.map(E=>E.position[0])),A.spatial.y_min=vr(o.map(E=>E.position[1])),A.spatial.y_max=xj(o.map(E=>E.position[1])),i===3&&(A.spatial.z_min=vr(o.map(E=>E.position[2])),A.spatial.z_max=xj(o.map(E=>E.position[2])))}A.spatial.center_x=(A.spatial.x_max+A.spatial.x_min)/2,A.spatial.center_y=(A.spatial.y_max+A.spatial.y_min)/2,i===3&&(A.spatial.center_z=(A.spatial.z_max+A.spatial.z_min)/2,A.spatial.data_depth=A.spatial.z_max-A.spatial.z_min),A.spatial.data_width=A.spatial.x_max-A.spatial.x_min,A.spatial.data_height=A.spatial.y_max-A.spatial.y_min;let l=A.root.clientWidth,c=A.root.clientHeight,B=A.root.clientWidth,h=A.containers.root_dim.height;A.spatial.scale_x=B/A.spatial.data_width,A.spatial.scale_y=h/A.spatial.data_height,A.spatial.scale=Math.min(A.spatial.scale_x,A.spatial.scale_y),A.img.landscape_parameters.technology!=="Chromium"?(A.spatial.ini_zoom=Math.log2(A.spatial.scale)*1.01,A.spatial.ini_x=A.spatial.center_x,A.spatial.ini_y=A.spatial.center_y,i===3&&(A.spatial.ini_z=A.spatial.center_z)):(A.spatial.ini_zoom=Math.log2(B/5e3)*.95,A.spatial.ini_x=5e3,A.spatial.ini_y=5e3),A.spatial.cell_scatter_data_objects=o;let d={getPosition:{duration:3e3,easing:I6}},k;return A.img.landscape_parameters.technology==="point-cloud"?k=new kx({id:"cell-layer",sizeUnits:"meters",pointSize:5,pickable:!0,getColor:(g,E)=>iz(A.cats,A.highlighted_cells,g,E),data:A.spatial.cell_scatter_data_objects,transitions:d,getPosition:g=>A.obs_store.umap_state.get()?g.umap:g.position,updateTriggers:{getPosition:[A.obs_store.umap_state.get()],getFillColor:[A.selection_token]},opacity:1,...Er(A.rotation)}):k=new mr({id:"cell-layer",radiusMinPixels:1,getRadius:5,pickable:!0,getFillColor:(g,E)=>iz(A.cats,A.highlighted_cells,g,E),data:A.spatial.cell_scatter_data_objects,transitions:d,getPosition:g=>A.obs_store.umap_state.get()?g.umap:g.position,updateTriggers:{getPosition:[A.obs_store.umap_state.get()],getFillColor:[A.selection_token]},...Er(A.rotation)}),k},p_=(t,A,j)=>{A.cell_layer=A.cell_layer.clone({onClick:(e,r)=>ddA(e,r,t,A,j)})},Au=(t,A)=>{t.cell_layer=t.cell_layer.clone({visible:A})},pdA=2,oz=(t,A,j)=>{j.img.landscape_parameters.technology==="point-cloud"?t.cell_layer=t.cell_layer.clone({pointSize:A/pdA}):t.cell_layer=t.cell_layer.clone({getRadius:A})},tu=(t,A)=>{t.cell_layer=t.cell_layer.clone({pickable:A})},sz=(t,A,j)=>{A.cell_layer=A.cell_layer.clone({updateTriggers:{getPosition:[j.obs_store.umap_state.get()]}})};var az=(t,A,j="unknown")=>async({index:e})=>{let{x:r,y:n,z:i}=e,o=A+i,l=await t.readTile(o,r,n);return l?new Promise((c,B)=>{let h=new Image;h.onload=()=>c(h),h.onerror=B,h.src=l}):null},kdA=(t,A,j=0,e="")=>{let{max_pyramid_zoom:r}=t.img.landscape_parameters,n=5,i=`${A.button_name}-ds${j}${e?`-${e}`:""}`,o=t.use_row_groups,l=t.row_group_readers?.images?.[A.name],c;return o&&l?c=az(l,r,A.name):c=Nk(t.global_base_url,A.name,t.img.image_format,r,Nt,t.aws),new Rc({id:i,tileSize:t.dimensions.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:0,maxRequests:6,extent:[0,0,t.dimensions.width,t.dimensions.height],getTileData:c,renderSubLayers:ay(t.dimensions,A.color,n),...Er(t.rotation)})},k_=async(t,A=0)=>{let{image_info:j}=t.img,e=Date.now().toString(36);return j.length===1&&(j[0].name==="h_and_e"||j[0].name==="h&e")?[await of(t,j[0],A,e)]:j.map(n=>kdA(t,n,A,e))},Cf=(t,A)=>{t.image_layers=t.image_layers.map(j=>j.clone({visible:A}))},lz=(t,A,j)=>{t.image_layers=t.image_layers.map(e=>e.id.startsWith(A)?e.clone({visible:j}):e)},cz=(t,A,j,e,r)=>{let n=r[j];A.image_layers=A.image_layers.map(i=>i.id.startsWith(j)?i.clone({renderSubLayers:ay(t.dimensions,n,e),id:`${j}-${e}`}):i)},uz=async(t,A,j,e=null)=>{let{image_info:r}=t.img,{max_pyramid_zoom:n,tile_size:i}=t.img.landscape_parameters,o=e||Date.now().toString(36),l=[],c=j/2,B=Math.max(i*3,j*.5),h=r.length===1&&(r[0].name==="h_and_e"||r[0].name==="h&e");return A.forEach((d,k)=>{let g=[Math.max(0,d.x-c-B),Math.max(0,d.y-c-B),Math.min(t.dimensions.width,d.x+c+B),Math.min(t.dimensions.height,d.y+c+B)];r.forEach(E=>{let y=`yb-${E.button_name}-p${k}-${o}`,G=h?ly(t.dimensions):ay(t.dimensions,E.color,5),v=t.use_row_groups,_=t.row_group_readers?.images?.[E.name],w;v&&_?w=az(_,n,E.name):w=Nk(t.global_base_url,E.name,t.img.image_format,n,Nt,t.aws);let x=new Rc({id:y,tileSize:t.dimensions.tileSize,refinementStrategy:"no-overlap",minZoom:-7,maxZoom:0,maxCacheSize:50,maxRequests:6,extent:g,getTileData:w,renderSubLayers:G,...Er(t.rotation)});l.push(x)})}),l};var TA=(t,A,j)=>{t.obs_store.deck_check.set({...t.obs_store.deck_check.get(),[j]:!1}),t.layers_obj=A,t.obs_store.deck_check.set({...t.obs_store.deck_check.get(),[j]:!0})};var gdA=(t,A)=>{let j=ei(t.properties.color),e;return A.obs_store.selected_nbhds.get().length>0?A.obs_store.selected_nbhds.get().includes(t.properties.cat)?e=255:e=0:e=255,j.push(e),j},Bz=(t,A)=>new La({id:"nbhd-layer",data:t.nbhd.feature_collection,pickable:!0,stroked:!1,filled:!0,getLineWidth:1,getFillColor:e=>gdA(e,t),opacity:.5,visible:A,...Er(t.rotation)});var fz=(t,A)=>{t.nbhd_layer=t.nbhd_layer.clone({opacity:A})},mdA=async(t,A,j,e,r)=>{let n=t.object.properties.cat,i=r.obs_store.selected_nbhds.get();i[0]===n&&i.length===1?r.obs_store.selected_nbhds.set([]):r.obs_store.selected_nbhds.set([n]),TA(r,e,"nbhd_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",o=>o.name===n?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)},hz=(t,A,j)=>{A.nbhd_layer=A.nbhd_layer.clone({onClick:(e,r)=>mdA(e,r,t,A,j)})},pl=(t,A)=>{t.nbhd_layer=t.nbhd_layer.clone({visible:A})};var SI=class extends mr{getShaders(){let A=super.getShaders();return A.fs=`#version 300 es #define SHADER_NAME scatterplot-layer-fragment-shader precision highp float; in vec4 vFillColor; @@ -1768,7 +1768,7 @@ DECKGL_FILTER_COLOR(fragColor, geometry); geometry.uv = unitPosition; fragColor = vFillColor; DECKGL_FILTER_COLOR(fragColor, geometry); - }`,A}},hdA=(t,A,j)=>{let e=j.tile_color_dict;if(j.cat==="cluster"){let r=j.tile_cats_array[A.index],n=j.selected_cats.length===0||j.selected_cats.includes(r)?255:5;return[...e[r],n]}else return[255,0,0,j.tile_exp_array[A.index]]},lz=t=>new PI({id:"tile-layer",data:t.tile_scatter_data,getFillColor:(j,e)=>hdA(j,e,t),filled:!0,getRadius:t.square_tile_size,pickable:!0,updateTriggers:{getFillColor:[t.cat]}}),tg=(t,A)=>{let j=t.cats.selected_cats.length===0?`tile-layer-${t.cats.cat}`:`tile-layer-${t.cats.cat}-${t.cats.selected_cats.join("-")}`;A.square_scatter_layer=A.square_scatter_layer.clone({id:j,data:t.cats.tile_scatter_data})},cz=(t,A)=>{t.square_scatter_layer=t.square_scatter_layer.clone({visible:A})},uz=(t,A)=>{t.square_scatter_layer=t.square_scatter_layer.clone({opacity:A})},Bz=(t,A,j)=>{A.square_scatter_layer=A.square_scatter_layer.clone({onClick:(e,r)=>ddA(e,r,t,A,j)}),t.setProps({layers:[A.simple_image_layer,A.square_scatter_layer]})},ddA=(t,A,j,e,r)=>{let n="ontouchstart"in window||navigator.maxTouchPoints>0,i;n?i=r.cats.tile_cats_array[t.index]:i=r.tooltip_cat_cell;let o=[i];Rt(r.cats,o,r.obs_store),gt(r.cats,"cluster"),tg(r,e),j.setProps({layers:[e.simple_image_layer,e.square_scatter_layer]})};var pdA=t=>Math.max(0,Math.min(255,Math.round(t))),kdA=t=>Math.max(0,Math.min(100,t)),fz=!1,gdA=` + }`,A}},EdA=(t,A,j)=>{let e=j.tile_color_dict;if(j.cat==="cluster"){let r=j.tile_cats_array[A.index],n=j.selected_cats.length===0||j.selected_cats.includes(r)?255:5;return[...e[r],n]}else return[255,0,0,j.tile_exp_array[A.index]]},dz=t=>new SI({id:"tile-layer",data:t.tile_scatter_data,getFillColor:(j,e)=>EdA(j,e,t),filled:!0,getRadius:t.square_tile_size,pickable:!0,updateTriggers:{getFillColor:[t.cat]}}),rg=(t,A)=>{let j=t.cats.selected_cats.length===0?`tile-layer-${t.cats.cat}`:`tile-layer-${t.cats.cat}-${t.cats.selected_cats.join("-")}`;A.square_scatter_layer=A.square_scatter_layer.clone({id:j,data:t.cats.tile_scatter_data})},pz=(t,A)=>{t.square_scatter_layer=t.square_scatter_layer.clone({visible:A})},kz=(t,A)=>{t.square_scatter_layer=t.square_scatter_layer.clone({opacity:A})},gz=(t,A,j)=>{A.square_scatter_layer=A.square_scatter_layer.clone({onClick:(e,r)=>$dA(e,r,t,A,j)}),t.setProps({layers:[A.simple_image_layer,A.square_scatter_layer]})},$dA=(t,A,j,e,r)=>{let n="ontouchstart"in window||navigator.maxTouchPoints>0,i;n?i=r.cats.tile_cats_array[t.index]:i=r.tooltip_cat_cell;let o=[i];Rt(r.cats,o,r.obs_store),gt(r.cats,"cluster"),rg(r,e),j.setProps({layers:[e.simple_image_layer,e.square_scatter_layer]})};var xdA=t=>Math.max(0,Math.min(255,Math.round(t))),ydA=t=>Math.max(0,Math.min(100,t)),mz=!1,vdA=` .slider { --c: #1e90ff; --track: #e5e5e5; @@ -1840,7 +1840,7 @@ DECKGL_FILTER_COLOR(fragColor, geometry); .slider:disabled::-moz-range-thumb { cursor: not-allowed; } -`,mdA=()=>{if(fz||typeof document>"u")return;let t=document.createElement("style");t.textContent=gdA,document.head.appendChild(t),fz=!0},dz=t=>{t.style.getPropertyValue("--track")||t.style.setProperty("--track","#e5e5e5"),t.style.getPropertyValue("--thumb-border")||t.style.setProperty("--thumb-border","#9aa0a6"),t.style.getPropertyValue("--c")||t.style.setProperty("--c","#1e90ff")},hz=t=>{let A=Number(t.min??0),j=Number(t.max??100),e=Number(t.value??A),r=Number.isFinite(A)?A:0,n=Number.isFinite(j)?j:100,i=Number.isFinite(e)?e:r,o=n-r,l=o===0?0:(i-r)*100/o;t.style.setProperty("--val",`${kdA(l)}%`)},II=t=>{if(!t||t.length<3)return;let[A,j,e]=t.slice(0,3).map(r=>{let n=Number(r);return Number.isNaN(n)?"00":pdA(n).toString(16).padStart(2,"0")});return`#${A}${j}${e}`},EdA=t=>{if(!t)return;if(Array.isArray(t))return II(t);if(typeof ArrayBuffer<"u"&&ArrayBuffer.isView(t))return II(Array.from(t));let A=String(t).trim();if(A.startsWith("#"))return A;let j=A.match(/\d+(?:\.\d+)?/g);return II(j)},$dA=(t,A)=>{let j=EdA(A);dz(t),j&&(t.style.setProperty("--c",j),t.style.setProperty("accent-color",j))},xdA=()=>document.createElement("input"),Hf=t=>{t.image_layer_sliders=t.image_info.map(A=>{let j=document.createElement("input");return j.name=A.button_name,$dA(j,A.color),j})},ydA=async(t,A,j)=>{uz(j,A.sliders.tile.value/100),t.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},vdA=async(t,A,j)=>{tz(A,j.sliders.cell.value/5,j),TA(j,A,"cell_layer")},_dA=async(t,A,j)=>{Tf(A,j.sliders.trx.value/100),TA(j,A,"trx_layer")},qdA=async(t,A,j)=>{let e=j.sliders.nbhd.value/100;sz(A,e),TA(j,A,"nbhd_layer")},f_=(t,A,j,e)=>async()=>{let n=e.img.image_layer_sliders.filter(i=>i.name===t)[0].value/10;nz(e,j,t,n,e.img.image_layer_colors),TA(e,j,"image_layers")},Df=(t,A,j)=>{mdA(),t.type="range",t.min="0",t.max="100",t.value=A,t.classList.add("slider"),t.style.width="75px",dz(t),hz(t);let e=r=>{hz(t),typeof j=="function"&&j(r)};t.addEventListener("input",e)},kl=(t,A,j,e)=>{let r,n,i=xdA();switch(t){case"tile":r=100,n=()=>ydA(A,e,j);break;case"cell":r=e.genes.trx_ini_raidus*100,n=()=>vdA(A,j,e);break;case"trx":r=e.genes.trx_ini_raidus*100,n=()=>_dA(A,j,e);break;case"nbhd":r=j.nbhd_layer.props.opacity*100,n=()=>qdA(A,j,e);break;default:}Df(i,r,n),e.sliders[t]=i},Rj=(t,A)=>{t&&(t.disabled=!A)};var ju=()=>document.createElement("div"),Nf=(t,A,j,e,r)=>{if(r.buttons?.buttons?.cell?.style?.("color","blue"),Rj(r.sliders.cell,!0),r.cats.svg_bar_cluster.selectAll("rect").style("opacity",1),Au(e,!0),r.nbhd.is_nbhd){r.obs_store.viz_nbhd_layer.set(!1),r.obs_store.viz_edit_layer.set(!1);try{r.buttons?.buttons?.nbhd?.style?.("color","gray"),Rj(r.sliders.nbhd,!1)}catch{}}r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),gt(r.cats,"cluster"),Rt(r.cats,[A.name],r.obs_store),Qt(r.genes,[],r.obs_store),r.cats.reset_cat?r.genes.svg_bar_gene.selectAll("rect").style("opacity",1):r.genes.svg_bar_gene.selectAll("rect").style("opacity",.2)},Kf=async(t,A,j,e,r)=>{if(r.buttons?.buttons?.trx?.style?.("color","blue"),Rj(r.sliders.trx,!0),r.genes.svg_bar_gene.selectAll("rect").style("opacity",1),Ts(e,!0),r.nbhd.is_nbhd){r.obs_store.viz_nbhd_layer.set(!1),r.obs_store.viz_edit_layer.set(!1);try{r.buttons?.buttons?.nbhd?.style?.("color","gray"),Rj(r.sliders.nbhd,!1)}catch{}}let n=A.name,i=n===r.cats.cat,o=i?"cluster":n;i?r.cats.svg_bar_cluster.selectAll("rect").style("opacity",1):r.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),gt(r.cats,o),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Qt(r.genes,[n],r.obs_store),await qr(r.cats,r.genes,r.global_base_url,n,r.seg.version,r.vector_name_integer,r.aws,r.row_group_readers?.cbg),Rt(r.cats,[n],r.obs_store)},h_=(t,A,j,e,r)=>{if(r.nbhd.edit){if(r.obs_store.viz_edit_layer.set(!0),r.buttons?.buttons?.nbhd){let i=r.buttons.buttons.nbhd;typeof i.style=="function"?i.style("color","blue"):VA(i).style("color","blue")}Rj(r.sliders.nbhd,!0);let n=r.obs_store.selected_nbhds.get();if(n[0]===A.name&&n.length===1)r.obs_store.selected_nbhds.set([]),e.edit_layer=e.edit_layer.clone({selectedFeatureIndexes:[]});else{r.obs_store.selected_nbhds.set([A.name]);let o=(r.edit?.feature_collection?.features||[]).findIndex(l=>l.properties.name===A.name||l.properties.cat===A.name);o>=0&&(e.edit_layer=e.edit_layer.clone({selectedFeatureIndexes:[o]}))}TA(r,e,"edit_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",i=>i.name===A.name?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)}else{if(r.obs_store.viz_nbhd_layer.set(!0),r.obs_store.viz_edit_layer.set(!1),r.buttons?.buttons?.nbhd){let i=r.buttons.buttons.nbhd;typeof i.style=="function"?i.style("color","blue"):VA(i).style("color","blue")}let n=r.obs_store.selected_nbhds.get();n[0]===A.name&&n.length===1?r.obs_store.selected_nbhds.set([]):r.obs_store.selected_nbhds.set([A.name]),TA(r,e,"nbhd_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",i=>i.name===A.name?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)}},Za=(t,A,j,e,r,n,i,o)=>{t.className="bar_container",t.style.width="107px",t.style.height="72px",t.style.marginLeft="5px",t.style.overflowY="auto",t.style.border="1px solid #d3d3d3",t.addEventListener("wheel",E=>{let{scrollTop:m,scrollHeight:y,clientHeight:b}=t,v=m===0,_=m+b===y;(v&&E.deltaY<0||_&&E.deltaY>0)&&E.preventDefault()});let l=15,c=l*(e.length+1);j.attr("width",100).attr("height",c).attr("font-family","sans-serif").attr("font-size","13").attr("text-anchor","end").style("user-select","none"),t.appendChild(j.node());let B=90,h=e.map(E=>E.value),d=ti().domain(F6(h.length)).range([0,(l+1)*h.length]),k=ji().domain([0,xj(h)]).range([0,B]),g=j.selectAll("g").data(e).join("g").attr("transform",(E,m)=>`translate(2,${d(m)+2})`).on("click",(E,m)=>A(E,m,n,i,o));g.append("rect").attr("fill",E=>{let m=r[E.name];return`rgb(${m[0]}, ${m[1]}, ${m[2]})`}).attr("width",E=>k(E.value)).attr("height",d.bandwidth()-1),g.append("text").attr("fill","black").attr("x","5px").attr("y",d.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").text(E=>E.name)};var Wr=(t,A,j)=>{let e;return A?e=[t.background_layer,...t.image_layers,t.path_layer,t.cell_layer,t.trx_layer,t.nbhd_layer,t.edit_layer]:e=[t.background_layer,...t.image_layers,t.cell_layer,t.nbhd_layer,t.edit_layer],e};function Uf(t,A){t.edit_layer=t.edit_layer.clone({mode:A})}var GdA=t=>(t.features.forEach((A,j)=>{if(A.geometry.type==="Polygon"){let e=A.geometry.coordinates[0],r=Math.abs($I(e)),n=A.properties.name,i=A.properties.cat;A.properties={...A.properties,area:r,name:n||(j+1).toString(),cat:i||(j+1).toString(),color:A.properties.color||Lf()}}else Uu(`Feature ${j} is not a Polygon.`,{logLevel:"warn",shouldLog:!0,data:{featureIndex:j,featureType:A.geometry?.type}})}),t),Xf=t=>{t.model?.set&&(t.nbhd?.edit?(t.model.set("nbhd_geojson",{}),t.model.set("nbhd_geojson",t.edit.feature_collection)):(t.model.set("region",{}),t.model.set("region",t.edit.feature_collection)),t.model.save_changes())},zf=async(t,A,j)=>{t.edit.feature_collection=GdA(t.edit.feature_collection),t.edit.rgn_areas=t.edit.feature_collection.features.map(e=>({name:e.properties.name||e.properties.cat,value:e.properties.area})).sort((e,r)=>r.value-e.value),t.edit.color_dict_rgn=t.edit.feature_collection.features.reduce((e,r)=>{let n=r.properties.name||r.properties.cat,{color:i}=r.properties;return typeof i=="string"&&i.startsWith("#")?e[n]=ei(i):Array.isArray(i)?e[n]=i:e[n]=[128,128,128],e},{}),t.nbhd?.edit&&(t.nbhd.bar_data=t.edit.rgn_areas,t.nbhd.color_dict=t.edit.color_dict_rgn,t.nbhd.feature_collection=t.edit.feature_collection,t.containers?.bar_nbhd&&(t.nbhd.svg_bar_nbhd.selectAll("*").remove(),Za(t.containers.bar_nbhd,h_,t.nbhd.svg_bar_nbhd,t.nbhd.bar_data,t.nbhd.color_dict,A,j,t),t.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2)))},bdA=async(t,A,j,e)=>{let{updatedData:r,editType:n,featureIndexes:i}=e;if(j.edit.feature_collection=r,A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),n==="addFeature"){Uf(A,Xr),VA(j.edit.buttons.sktch).style("color","gray").classed("active",!1),j.edit.mode="view",tu(A,!0),Jc(A,!0),Zc(A,!0);let l=i&&i.length>0?i[0]:j.edit.feature_collection.features.length-1,c=j.edit.feature_collection.features[l];if(c&&!c.properties.name&&(c.properties.name=`nbhd_${l+1}`,c.properties.cat=c.properties.name,c.properties.color=c.properties.color||Lf()),j.nbhd?.edit&&j.nbhd_editor){let B=j.root.getBoundingClientRect();j.nbhd_editor.open({feature_index:l,initial_name:c.properties.name,initial_color:c.properties.color,position:{x:B.width/2-120,y:B.height/2-90},on_apply:({feature_index:h,name:d,color:k})=>{let g=j.edit.feature_collection.features[h];g&&(g.properties.name=d,g.properties.cat=d,g.properties.color=k),A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),zf(j,t,A),Xf(j);let E=Wr(A,j.close_up);t.setProps({layers:E})}})}await zf(j,t,A),Xf(j)}let o=Wr(A,j.close_up);t.setProps({layers:o}),await zf(j,t,A),Xf(j)},wdA=async(t,A,j,e)=>{if(t.featureType==="polygons"&&e.edit.mode==="view"){j.edit_layer=j.edit_layer.clone({id:"edit-layer-modify",mode:Mo,selectedFeatureIndexes:[t.index],modeConfig:{dragToAddNew:!0,enableSnapping:!1}});let r=await Wr(j,e.close_up);A.setProps({layers:r}),e.edit.mode="modify",e.edit.modify_index=t.index,VA(e.edit.buttons.del).classed("active",!0).style("display","inline-flex"),VA(e.edit.buttons.nbhd).style("display","none"),VA(e.edit.buttons.sktch).style("display","none")}else if(t.featureType==="polygons"&&e.edit.mode==="modify"){j.edit_layer=j.edit_layer.clone({id:"edit-layer-view",mode:Xr,selectedFeatureIndexes:[]});let r=await Wr(j,e.close_up);A.setProps({layers:r}),e.edit.mode="view",e.edit.modify_index=null,VA(e.edit.buttons.del).classed("active",!1).style("display","none"),VA(e.edit.buttons.nbhd).style("display","inline-flex"),VA(e.edit.buttons.sktch).style("display","inline-flex")}},pz=t=>new Is({id:"edit-layer",data:t.edit.feature_collection,selectedFeatureIndexes:[],mode:Xr,filled:!0,pointRadiusMinPixels:2,pointRadiusScale:2e3,extruded:!0,getElevation:1e3,getFillColor:j=>{let{color:e}=j.properties;return typeof e=="string"&&e.startsWith("#")?ei(e):e||[128,128,128]},pickable:!0,autoHighlight:!0,modeConfig:{preventOverlappingLines:!0},visible:!1,opacity:t.edit.rgn_opacity,...Er(t.rotation)}),kz=(t,A,j)=>{A.edit_layer=A.edit_layer.clone({onEdit:e=>bdA(t,A,j,e)})},gz=(t,A,j)=>{let e=0,r=-1,n=300,i=async o=>{let l=Date.now(),c=l-e{let E=j.edit.feature_collection.features[d];E&&(E.properties.name=k,E.properties.cat=k,E.properties.color=g),A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),zf(j,t,A),Xf(j);let m=Wr(A,j.close_up);t.setProps({layers:m})}})}}else await wdA(o,t,A,j)};A.edit_layer=A.edit_layer.clone({onClick:i})};var mz=(t,A)=>{t.edit_layer=t.edit_layer.clone({visible:A})};var FdA=(t,A,j)=>{if(t.size>=20){let r=t.keys().next().value;t.delete(r)}t.set(A,j)},PdA=(t,A)=>{let j=t.get(A);return j&&(t.delete(A),t.set(A,j)),j},IdA=t=>{t.clear()},Vf=()=>{let t=new Map;return{set:(A,j)=>FdA(t,A,j),get:A=>PdA(t,A),clear:()=>IdA(t)}};var Qf=(t,A)=>{t.image_format=A},Wf=(t,A)=>{t.image_info=A},Yf=(t,A)=>{A.forEach(j=>{t[j.button_name]=j.color})};var Ez=(t,A)=>{t.color_dict_cluster=A.color;for(let e in t.color_dict_cluster)t.color_dict_cluster[e]=ei(t.color_dict_cluster[e]);let j=A.count;t.cluster_counts=[];for(let e in j)t.cluster_counts.push({name:e,value:j[e]});t.cluster_counts.sort((e,r)=>r.value-e.value)},Jf=async t=>{if(t.cats.has_meta_cluster){let A=t.cats.meta_cluster_attr.indexOf("color");for(let e in t.cats.meta_cluster)t.cats.color_dict_cluster[e]=ei(t.cats.meta_cluster[e][A]||"#000000");let j=t.cats.meta_cluster_attr.indexOf("count");for(let e in t.cats.meta_cluster){let r=t.cats.meta_cluster[e][j],n=r!==void 0?Number(r):0;t.cats.cluster_counts.push({name:e,value:n})}}else{let A;t.seg.version==="default"?A=`${t.global_base_url}/cell_clusters/meta_cluster.parquet`:A=`${t.global_base_url}/cell_clusters_${t.seg.version}/meta_cluster.parquet`;let j=await ae(A,Nt.fetch,t.aws),e=[],r=[],n=[],i=j.getChild("__index_level_0__"),o=j.getChild("color"),l=j.getChild("count"),c=[];for(let B of j.schema.fields)c.push(B.name);i&&o&&(e=i.toArray(),r=o.toArray(),n=l.toArray()),e.forEach((B,h)=>{t.cats.color_dict_cluster[B]=ei(r[h]),t.cats.cluster_counts.push({name:B,value:Number(n[h])})})}t.cats.cluster_counts.sort((A,j)=>j.value-A.value)};var gl=async(t,A,j="default",e)=>{let r;j==="default"?r=`${A}/meta_gene.parquet`:r=`${A}/meta_gene_${j}.parquet`;let n=await ae(r,Nt.fetch,e),i=n.getChild("__index_level_0__").toArray(),o=n.getChild("mean").toArray(),l=n.getChild("std").toArray(),c=n.getChild("max").toArray();i.forEach((h,d)=>{t.meta_gene[h]={mean:o[d],std:l[d],max:c[d]},t.gene_counts.push({name:h,value:Number(o[d])})}),t.gene_counts.sort((h,d)=>d.value-h.value),t.top_gene_counts=t.gene_counts.slice(0,100);let B=i.reduce((h,d,k)=>(h[k]=d,h),{});t.g_nameMapping_inv=B,t.gene_names=i};var jg=(t,A=255)=>{let j=o6(t);return j?[j.r,j.g,j.b,A]:[0,0,0,A]};var Ue=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{A!==e&&(A=e,j.forEach(r=>r(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},Zf=()=>{let t={cat:Ue("cluster"),selected_cats:Ue([]),selected_cells:Ue([]),new_cell_bar_data:Ue([]),new_gene_bar_data:Ue([]),selected_genes:Ue([]),selected_nbhds:Ue([]),viz_image_layers:Ue(!0),viz_background_layer:Ue(!0),viz_nbhd_layer:Ue(!1),viz_edit_layer:Ue(!1),landscape_view:Ue("spatial"),umap_state:Ue(!1),scale_bar_view_state:Ue(null),close_up:Ue(!1),current_dataset_index:Ue(0),dataset_switching:Ue(!1),persistent_state:Ue({selected_cats:[],selected_genes:[],cat:"cluster",viz_image_layers:!0,landscape_view:"spatial"}),deck_check:Ue({background_layer:!0,image_layers:!0,cell_layer:!0,path_layer:!0,trx_layer:!0,nbhd_layer:!0,edit_layer:!0,trx_data:!0,path_data:!0,square_scatter_data:!0}),deck_ready:Ue(!1)};return t.deck_check.subscribe(A=>{let j=Object.values(A).every(e=>e===!0);t.deck_ready.set(j)},{immediate:!1}),t.setup_image_visibility_manager=A=>{let j=()=>{if(A&&!A())return;let e=t.selected_cats.get().length>0,r=t.selected_genes.get().length>0,n=t.close_up.get(),i=t.umap_state.get();e||r?t.viz_image_layers.set(n):i||t.viz_image_layers.set(!0)};return t.selected_cats.subscribe(j,{immediate:!1}),t.selected_genes.subscribe(j,{immediate:!1}),t.close_up.subscribe(j,{immediate:!1}),j},t};var Ah=class{constructor(A,j){if(this.baseUrl=A,this.initialized=!1,this.useStreaming=!0,typeof j=="string")this.chunkedMode=!1,this.url=`${A}/${j}`,this.parquetFile=null,this.geneToRowGroup=null;else if(typeof j=="object"&&j.files)this.chunkedMode=!0,this.directory=j.directory||"cbg",this.files=j.files,this.maxRowGroupsPerFile=j.max_row_groups_per_file||2e3,this.totalRowGroups=j.total_row_groups||0,this.geneToRowGroup=j.gene_to_row_group||{},this.geneList=Object.keys(this.geneToRowGroup);else throw new Error("[CBGRowGroupReader] Invalid cbgConfig: must be string URL or chunk config object")}async _checkRangeSupport(A){try{let j=new URL(A);if(j.hostname==="localhost"||j.hostname==="127.0.0.1")return!0;let e=await fetch(A,{method:"GET",headers:{Range:"bytes=0-7"}});if(!e.ok&&e.status!==206)return!1;let r=await fetch(A,{method:"GET",headers:{Range:"bytes=-8"}});return!r.ok&&r.status!==206?!1:e.status===206&&r.status===206||e.headers.get("Accept-Ranges")==="bytes"}catch{return!1}}computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _getParquetFile(A){let j=this.files[A];if(!j)throw new Error(`[CBGRowGroupReader] No file for index ${A}. Available: ${this.files.length} files`);let e=`${this.baseUrl}/${this.directory}/${j}`;return await(await lo()).ParquetFile.fromUrl(e)}async initialize(){if(this.initialized)return;let A=await lo();if(this.chunkedMode){let j=`${this.baseUrl}/${this.directory}/${this.files[0]}`;if(!await this._checkRangeSupport(j))throw new Error("[CBGRowGroupReader] Range requests not supported. Row group mode requires a server that supports HTTP Range requests with CORS.")}else{if(!await this._checkRangeSupport(this.url))throw new Error(`[CBGRowGroupReader] Range requests not supported for ${this.url}. Row group mode requires a server that supports HTTP Range requests with CORS.`);if(!A.ParquetFile||typeof A.ParquetFile.fromUrl!="function")throw new Error("[CBGRowGroupReader] ParquetFile.fromUrl not available. Please ensure parquet-wasm is properly initialized.");this.parquetFile=await A.ParquetFile.fromUrl(this.url),this.useStreaming=!0;let r=this.parquetFile.metadata().numRowGroups();this.numRowGroups=r,this.geneToRowGroup=null,this.geneList=null}this.initialized=!0}async _ensureGeneIndex(){if(this.geneToRowGroup===null){try{let j=(await this.parquetFile.read({rowGroups:[0]})).intoIPCStream(),r=wn(j).schema.metadata;if(r&&r.has("gene_to_row_group")){let n=r.get("gene_to_row_group");this.geneToRowGroup=JSON.parse(n),this.geneList=Object.keys(this.geneToRowGroup);return}}catch{}this.geneToRowGroup=await this._buildGeneIndex(this.numRowGroups),this.geneList=Object.keys(this.geneToRowGroup)}}async _buildGeneIndex(A){let j={};for(let e=0;e0){let l=o.get(0);j[l]=e}}catch{}return j}async hasGene(A){return await this._ensureGeneIndex(),A in this.geneToRowGroup}async getGeneRowGroupIndex(A){return await this._ensureGeneIndex(),this.geneToRowGroup[A]??null}async readGene(A){this.initialized||await this.initialize(),await this._ensureGeneIndex();let j=this.geneToRowGroup[A];if(j===void 0)return null;try{if(this.chunkedMode){let{fileIndex:e,localIndex:r}=this.computeChunkLocation(j),o=(await(await this._getParquetFile(e)).read({rowGroups:[r]})).intoIPCStream();return wn(o)}else{let r=(await this.parquetFile.read({rowGroups:[j]})).intoIPCStream();return wn(r)}}catch{return null}}async getNumGenes(){return await this._ensureGeneIndex(),this.geneList.length}async getGeneNames(){return await this._ensureGeneIndex(),[...this.geneList]}};var th=class{constructor(A,j,e=null){if(this.baseUrl=A,this.initialized=!1,this.useStreaming=!0,this.blobCache=new Map,typeof j=="string")this.chunkedMode=!1,this.url=`${A}/${j}`,this.parquetFile=null,this.zoomInfo=e||{};else if(typeof j=="object"&&j.files)this.chunkedMode=!0,this.directory=j.directory||"pyramid_images",this.files=j.files,this.maxRowGroupsPerFile=j.max_row_groups_per_file||2e3,this.totalRowGroups=j.total_row_groups||0,this.zoomInfo=j.zoom_info||e||{};else if(typeof j=="object"&&j.path)this.chunkedMode=!1,this.url=`${A}/${j.path}`,this.parquetFile=null,this.zoomInfo=j.zoom_info||e||{};else throw new Error("[ImageRowGroupReader] Invalid imageConfig: must be string path or object with files/path")}async _checkRangeSupport(A=null){let j=A||(this.chunkedMode?this._getFileUrl(0):this.url);try{let e=new URL(j);if(e.hostname==="localhost"||e.hostname==="127.0.0.1")return!0;let r=await fetch(j,{method:"GET",headers:{Range:"bytes=0-7"}});if(!r.ok&&r.status!==206)return console.log(`[ImageRowGroupReader] Range check failed with status ${r.status}`),!1;let n=await fetch(j,{method:"GET",headers:{Range:"bytes=-8"}});return!n.ok&&n.status!==206?(console.log(`[ImageRowGroupReader] Footer range check failed with status ${n.status}`),!1):r.status===206&&n.status===206||r.headers.get("Accept-Ranges")==="bytes"}catch(e){return console.log(`[ImageRowGroupReader] Range check failed: ${e.message}`),!1}}_getFileUrl(A){if(!this.chunkedMode)return this.url;let j=this.files[A];return`${this.baseUrl}/${this.directory}/${j}`}_computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _getParquetFile(A){let j=this._getFileUrl(A);return(await lo()).ParquetFile.fromUrl(j)}async initialize(){if(this.initialized)return;let A=await lo();if(!await this._checkRangeSupport()){let e=this.chunkedMode?this._getFileUrl(0):this.url;throw new Error(`[ImageRowGroupReader] Range requests not supported for ${e}. Row group mode requires a server that supports HTTP Range requests with CORS.`)}if(!A.ParquetFile||typeof A.ParquetFile.fromUrl!="function")throw new Error("[ImageRowGroupReader] ParquetFile.fromUrl not available. Please ensure parquet-wasm is properly initialized.");if(this.chunkedMode)console.log(`[ImageRowGroupReader] Chunked mode enabled: ${this.files.length} files, ${this.totalRowGroups} total tiles`);else{console.log("[ImageRowGroupReader] Range requests supported, creating streaming ParquetFile..."),this.parquetFile=await A.ParquetFile.fromUrl(this.url);let r=this.parquetFile.metadata().numRowGroups();console.log(`[ImageRowGroupReader] Streaming mode enabled, ${r} tiles available`)}console.log(`[ImageRowGroupReader] zoomInfo available: ${this.zoomInfo?Object.keys(this.zoomInfo).join(", "):"none"}`),this.initialized=!0}computeRowGroupIndex(A,j,e){let r=String(A),n=this.zoomInfo[r];if(!n)return console.warn(`[ImageRowGroupReader] No zoom data for level ${A}`),null;let{row_group_offset:i,num_tiles_x:o,num_tiles_y:l}=n;return j<0||j>=o||e<0||e>=l?null:i+j*l+e}async readTile(A,j,e,r="image/webp"){this.initialized||await this.initialize();let n=`${A}_${j}_${e}`;if(this.blobCache.has(n))return this.blobCache.get(n);let i=this.computeRowGroupIndex(A,j,e);if(i===null)return null;try{let o;if(this.chunkedMode){let{fileIndex:g,localIndex:E}=this._computeChunkLocation(i);if(g>=this.files.length)return console.warn(`[ImageRowGroupReader] File index ${g} out of range (${this.files.length} files)`),null;o=await(await this._getParquetFile(g)).read({rowGroups:[E]})}else o=await this.parquetFile.read({rowGroups:[i]});let l=o.intoIPCStream(),B=wn(l).getChild("image_data");if(!B||B.length===0)return null;let h=B.get(0);if(!h||h.length===0)return null;let d=new Blob([h],{type:r}),k=URL.createObjectURL(d);return this.blobCache.set(n,k),k}catch(o){return console.warn(`[ImageRowGroupReader] Error reading tile z${A} ${j}_${e}:`,o),null}}clearCache(){for(let A of this.blobCache.values())URL.revokeObjectURL(A);this.blobCache.clear()}getCacheSize(){return this.blobCache.size}isStreaming(){return this.useStreaming&&this.parquetFile!==null}};var ml=class{constructor(A,j,e){if(this.baseUrl=A,this.numTilesX=j?.num_tiles_x||0,this.numTilesY=j?.num_tiles_y||0,this.initialized=!1,typeof e=="string")this.chunkedMode=!1,this.url=`${A}/${e}`,this.parquetFile=null;else if(typeof e=="object"&&e.files)e.files.length===1?(this.chunkedMode=!1,this.url=`${A}/${e.directory}/${e.files[0]}`,this.parquetFile=null):(this.chunkedMode=!0,this.directory=e.directory,this.files=e.files,this.maxRowGroupsPerFile=e.max_row_groups_per_file||1e4,this.totalRowGroups=e.total_row_groups||0);else throw new Error("[RowGroupTileReader] Invalid fileConfig: must be string URL or chunk config object")}computeRowGroupIndex(A,j){return A*this.numTilesY+j}computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _checkRangeSupport(A){try{let j=new URL(A);if(j.hostname==="localhost"||j.hostname==="127.0.0.1")return!0;let e=await fetch(A,{method:"GET",headers:{Range:"bytes=0-7"}});if(!e.ok&&e.status!==206)return!1;let r=await fetch(A,{method:"GET",headers:{Range:"bytes=-8"}});return!(!r.ok&&r.status!==206)}catch{return!1}}async _getParquetFile(A){let j=this.files[A];if(!j)throw new Error(`[RowGroupTileReader] No file for index ${A}. Available: ${this.files.length} files`);let e=`${this.baseUrl}/${this.directory}/${j}`;return await(await lo()).ParquetFile.fromUrl(e)}async initialize(){if(this.initialized)return;let A=await lo();if(this.chunkedMode){let j=`${this.baseUrl}/${this.directory}/${this.files[0]}`;if(!await this._checkRangeSupport(j))throw new Error("[RowGroupTileReader] Range requests not supported. Row group mode requires a server that supports HTTP Range requests with CORS.")}else{if(!await this._checkRangeSupport(this.url))throw new Error(`[RowGroupTileReader] Range requests not supported for ${this.url}. Row group mode requires a server that supports HTTP Range requests with CORS.`);this.parquetFile=await A.ParquetFile.fromUrl(this.url)}this.initialized=!0}isValidTile(A,j){return A>=0&&A=0&&jr-n);try{if(this.chunkedMode){let r=new Map;for(let i of e){let{fileIndex:o,localIndex:l}=this.computeChunkLocation(i);r.has(o)||r.set(o,[]),r.get(o).push(l)}let n=[];for(let[i,o]of r){let B=(await(await this._getParquetFile(i)).read({rowGroups:o})).intoIPCStream(),h=wn(B);n.push(h)}return n.length===0?null:n.length===1?n[0]:Qv(n)}else{let n=(await this.parquetFile.read({rowGroups:e})).intoIPCStream();return wn(n)}}catch{return null}}isStreaming(){return this.initialized}};var jh=(t,A,j)=>Math.min(Math.max(t,A),j),eh=(t,A)=>{let j=document.createElement("label");return j.style.display="block",j.style.fontSize="12px",j.style.fontWeight="600",j.style.marginBottom="8px",j.style.color="#47515b",j.textContent=t,A.style.display="block",A.style.width="100%",A.style.marginTop="4px",A.style.padding="6px",A.style.border="1px solid #d3d3d3",A.style.borderRadius="4px",A.style.fontSize="12px",j.appendChild(A),j},d_=(t="#3b82f6")=>{let A=document.createElement("input");return A.type="color",A.value=t,A.style.padding="0",A.style.height="32px",A.style.cursor="pointer",A},p_=(t="")=>{let A=document.createElement("input");return A.type="text",A.placeholder=t,A},k_=()=>{let t=document.createElement("div");return t.style.position="absolute",t.style.width="240px",t.style.background="#ffffff",t.style.border="1px solid #d3d3d3",t.style.borderRadius="8px",t.style.padding="12px",t.style.boxShadow="0 4px 12px rgba(0, 0, 0, 0.15)",t.style.zIndex="20",t.style.display="none",t.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',t},g_=t=>{let A=document.createElement("div");A.style.display="flex",A.style.justifyContent="space-between",A.style.alignItems="center",A.style.marginBottom="8px";let j=document.createElement("span");j.style.fontSize="13px",j.style.fontWeight="700",j.style.color="#333333",j.textContent=t;let e=document.createElement("button");return e.type="button",e.textContent="\xD7",e.style.border="none",e.style.background="transparent",e.style.cursor="pointer",e.style.fontSize="16px",e.style.lineHeight="16px",e.style.padding="0",A.appendChild(j),A.appendChild(e),{header:A,close_button:e}},m_=()=>{let t=document.createElement("div");t.style.display="flex",t.style.gap="8px",t.style.marginTop="12px";let A=document.createElement("button");A.type="button",A.textContent="Apply",A.style.flex="1",A.style.background="#2f74ff",A.style.color="#ffffff",A.style.border="none",A.style.borderRadius="4px",A.style.padding="8px",A.style.cursor="pointer",A.style.fontWeight="600";let j=document.createElement("button");return j.type="button",j.textContent="Cancel",j.style.flex="1",j.style.background="#f5f5f5",j.style.color="#47515b",j.style.border="1px solid #d3d3d3",j.style.borderRadius="4px",j.style.padding="8px",j.style.cursor="pointer",t.appendChild(A),t.appendChild(j),{button_row:t,apply_button:A,cancel_button:j}};var $z=(t,A,j)=>{let e=A*Math.min(j,1-j),r=n=>{let i=(n+t*12)%12,o=j-e*Math.max(Math.min(i-3,9-i,1),-1);return Math.round(255*o).toString(16).padStart(2,"0")};return`#${r(0)}${r(8)}${r(4)}`};var MdA=t=>{let A=new Set;t.edit?.feature_collection?.features&&t.edit.feature_collection.features.forEach(j=>{j.properties?.color&&A.add(j.properties.color.toLowerCase())});for(let j=0;j<50;j++){let e=Lf();if(!A.has(e.toLowerCase()))return e}return Lf()},xz=(t,A,j)=>{let e=k_(),{header:r,close_button:n}=g_("Neighborhood"),i=p_("Neighborhood name"),o=eh("Name",i),l=d_("#3b82f6"),c=eh("Color",l),{button_row:B,apply_button:h,cancel_button:d}=m_();e.appendChild(r),e.appendChild(o),e.appendChild(c),e.appendChild(B),t.root.appendChild(e);let k=null,g=null,E=v=>{let _=t.root.getBoundingClientRect(),w=e.offsetWidth||240,x=e.offsetHeight||180,S=jh(v?.x??_.width/2-w/2,8,_.width-w-8),F=jh(v?.y??_.height/2-x/2,8,_.height-x-8);e.style.left=`${S}px`,e.style.top=`${F}px`},m=()=>{e.style.display="none",k=null,g=null},y=({feature_index:v,initial_name:_="",initial_color:w=null,position:x=null,on_apply:S=null})=>{k={feature_index:v},g=S,i.value=_,l.value=w||MdA(t),e.style.display="block",E(x),setTimeout(()=>i.focus(),50)},b=()=>{if(k===null)return;let v=i.value.trim()||`nbhd_${k.feature_index+1}`,_=l.value;g&&g({feature_index:k.feature_index,name:v,color:_}),m()};return h.addEventListener("click",b),d.addEventListener("click",m),n.addEventListener("click",m),i.addEventListener("keydown",v=>{v.key==="Enter"?b():v.key==="Escape"&&m()}),{open:y,close:m}};var le=t=>{let A=[t.mat_layer,t.row_cat_layer,t.col_cat_layer,t.row_label_layer,t.col_label_layer,t.row_dendro_layer,t.col_dendro_layer];return t.col_attr_label_layer&&A.push(t.col_attr_label_layer),t.row_attr_label_layer&&A.push(t.row_attr_label_layer),A},yz=({layer:t,viewport:A})=>A.id==="matrix"&&t.id.includes("mat-layer")||A.id==="rows"&&t.id==="row-layer"||A.id==="cols"&&t.id==="col-layer"||A.id==="rows"&&t.id.includes("row-label-layer")||A.id==="cols"&&t.id==="col-label-layer"||A.id==="dendro_rows"&t.id==="row-dendro-layer"||A.id==="dendro_cols"&&t.id==="col-dendro-layer"||A.id==="col_attr_labels"&&t.id==="col-attr-label-layer"?!0:A.id==="row_attr_labels"&&t.id==="row-attr-label-layer";var OdA=["row","col"],TdA=[0,0,0,90],SdA=[0,0,0,180],RdA=t=>(t?.obs_store?.focused_dendro&&typeof t.obs_store.focused_dendro.get=="function"?t.obs_store.focused_dendro.get():null)??t.dendro?.active_polygon??null,vz=(t,A,j,e)=>{let r=e?{axis:e.axis,name:e.name}:null,n=!1;if(OdA.forEach(i=>{if(!j.dendro.polygons[i])return;let o=j.dendro.polygons[i].map(l=>{let c=!!r&&l.properties.axis===r.axis&&l.properties.name===r.name;return l.properties.is_focused===c?l:(n=!0,{...l,properties:{...l.properties,is_focused:c}})});j.dendro.polygons[i]=o,A[`${i}_dendro_layer`]&&(A[`${i}_dendro_layer`]=A[`${i}_dendro_layer`].clone({data:o}))}),j.dendro.active_polygon=r,j.obs_store?.focused_dendro){let i=r?{...r}:null;j.obs_store.focused_dendro.set(i)}n&&typeof t?.setProps=="function"&&t.setProps({layers:le(A)})},MI=(t,A,j)=>new Gx({id:`${j}-dendro-layer`,data:A.dendro.polygons[j],getPolygon:r=>r.coordinates,getFillColor:r=>r.properties.is_focused?SdA:Array.isArray(r.properties.fill_color)?r.properties.fill_color:TdA,getLineColor:[255,255,255,255],lineWidthMinPixels:0,pickable:!0,antialiasing:!1}),_z=(t,A,j)=>{t[`${j}_dendro_layer`]=t[`${j}_dendro_layer`].clone({data:A.dendro.polygons[j]})},eu=(t,A,j)=>{let e=!1;A.order.current[j]==="clust"&&(e=!0),t[`${j}_dendro_layer`]=t[`${j}_dendro_layer`].clone({visible:e})},LdA=(t,A,j,e,r)=>{let n=RdA(j);if(n&&n.axis===e&&n.name===r){vz(t,A,j,null);return}vz(t,A,j,{axis:e,name:r})},CdA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr?.names?.[A]||[],n=new Set(j),i=e.filter(l=>n.has(l.name)),o={};return r.forEach((l,c)=>{let B=`cat-${c}`,h={};i.forEach(k=>{let g=k[B];g!=null&&(h[g]=(h[g]||0)+1)});let d=Object.entries(h).map(([k,g])=>({name:k,value:g})).sort((k,g)=>g.value-k.value);d.length>0&&(o[l]=d)}),o},HdA=(t,A,j,e,r)=>{e.click.type=`${r}_dendro`;let n=r==="row"?e.row_entity:e.col_entity,i=t.object.properties.all_names||[];e.click.value={name:t.object.properties.name,selected_names:i,entity:n.entity,attr:n.attr,row_entity:e.row_entity.entity,col_entity:e.col_entity.entity,row_entity_full:e.row_entity,col_entity_full:e.col_entity},LdA(A,j,e,r,t.object.properties.name);let o=!1;if(e.obs_store?.dendro_selection){let c=e.obs_store.dendro_selection.get();if(c&&c.axis===r&&c.name===t.object.properties.name)o=!0,e.obs_store.dendro_selection.set(null),e.obs_store?.category_breakdown&&e.obs_store.category_breakdown.set({row:{},col:{}});else if(e.obs_store.dendro_selection.set({axis:r,name:t.object.properties.name,selected_names:i}),e.obs_store?.category_breakdown){let B=CdA(e,r,i),h=e.obs_store.category_breakdown.get()||{row:{},col:{}};e.obs_store.category_breakdown.set({...h,[r]:B})}}o&&(e.click.value.selected_names=[],e.click.value.is_unselecting=!0,e.attr?.editor?.close&&e.attr.editor.close()),Object.keys(e.model).length>0&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes());let l=o?[]:i;if(r==="row"?(Xv(e,l),Yc(e,l)):r==="col"&&zv(e,l),e.attr?.editor?.open&&!o){let h;r==="row"?h={x:(e.viz.row_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_width||300)-240-1,y:(e.viz.col_region||0)+(e.viz.label_buffer||0)}:h={x:(e.viz.row_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_width||300)-240,y:(e.viz.col_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_height||300)-200-1},e.attr.editor.open({axis:r,selection:i,position:h})}typeof e.custom_callbacks[`${r}_dendro`]=="function"&&e.custom_callbacks[`${r}_dendro`](i)},OI=(t,A,j,e)=>{A[`${e}_dendro_layer`]=A[`${e}_dendro_layer`].clone({onClick:r=>HdA(r,t,A,j,e)})};var nr,TI=!0,qz=()=>TI,DdA=t=>{TI=t},ru=t=>{let A=VA(t.currentTarget);return A.style("color")==="blue"?(A.style("color","gray"),nr=!1):(A.style("color","blue"),nr=!0),nr},NdA=(t,A,j,e,r)=>{let n=VA(t.currentTarget),i=n.text().toLowerCase();i==="var"?i="rankvar":i==="sum"&&(i="rank"),n.classed("active")===!1&&(n.classed("active",!0),VA(r.el).selectAll(`.button-${A}`).classed("active",!1).style("border-color",r.buttons.gray),n.style("border-color",r.buttons.blue).classed("active",!0),r.order.current[A]=i,e.mat_layer=e.mat_layer.clone({updateTriggers:{getPosition:[r.order.current.row,r.order.current.col]}}),A==="row"?(e.row_label_layer=e.row_label_layer.clone({updateTriggers:{getPosition:r.order.current.row}}),e.row_cat_layer=e.row_cat_layer.clone({updateTriggers:{getPosition:r.order.current.row}})):(e.col_label_layer=e.col_label_layer.clone({updateTriggers:{getPosition:r.order.current.col}}),e.col_cat_layer=e.col_cat_layer.clone({updateTriggers:{getPosition:r.order.current.col}})),eu(e,r,A),j.setProps({layers:le(e)}))},Gz=(t,A,j,e=40,r,n,i,o)=>{let l=`button-${r}`,c;j===!0?c=o.buttons.blue:c=o.buttons.gray;let B=A.toUpperCase();VA(t).append("div").classed(l,!0).classed("active",j).text(B).style("width",`${e}px`).style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","9px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color",c).style("border-radius","10px").style("margin-top","4px").style("margin-left","3px").style("padding","2px 4px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').on("click",h=>NdA(h,r,n,i,o))},KdA=async(t,A,j)=>{ru(t),$D(j,nr),A.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},XdA=async(t,A,j,e)=>{ru(t);let r=nr;e.obs_store.umap_state.get()&&r?e.obs_store.landscape_view.set("spatial"):(e.obs_store.viz_image_layers.set(r),e.obs_store.viz_background_layer.set(r)),DdA(r)},zdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.tile,nr),cz(j,nr),A.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},UdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.trx,nr),Ts(j,nr),nr?(pl(j,!1),e.obs_store.viz_nbhd_layer.set(!1),e.obs_store.viz_edit_layer.set(!1),e.nbhd.is_nbhd&&e.buttons?.buttons?.nbhd?.style?.("color","gray"),e.genes.svg_bar_gene.selectAll("rect").style("opacity",1)):e.genes.svg_bar_gene.selectAll("rect").style("opacity",.2),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!0})},VdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.cell,nr),Au(j,nr),Of(j,nr),nr?(pl(j,!1),e.obs_store.viz_nbhd_layer.set(!1),e.obs_store.viz_edit_layer.set(!1),e.nbhd.is_nbhd&&e.buttons?.buttons?.nbhd?.style?.("color","gray"),e.cats.svg_bar_cluster.selectAll("rect").style("opacity",1)):e.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,nbhd_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,nbhd_layer:!0})},QdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.nbhd,nr),pl(j,nr),e.obs_store.viz_nbhd_layer.set(nr),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!1,nbhd_layer:!1,cell_layer:!1,path_layer:!1,trx_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!0,nbhd_layer:!0,cell_layer:!0,path_layer:!0,trx_layer:!0})},WdA=async(t,A,j,e)=>{e.obs_store.landscape_view.set("umap")},YdA=async(t,A,j,e)=>{e.obs_store.landscape_view.set("spatial")},JdA=(t,A,j,e)=>async r=>{let n=e.obs_store.umap_state.get();if(!TI&&!n)return;ru(r),n&&(e.obs_store.landscape_view.set("spatial"),e.obs_store.viz_background_layer.set(!0),e.obs_store.viz_image_layers.set(!0)),rz(j,t,nr);let i=e.img.image_layer_sliders.filter(o=>o.name===t)[0];Rj(i,nr),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!0})},kn=(t,A,j,e="blue",r=40,n="button",i,o,l)=>{let c;j==="IMG"?A==="sst"?c=d=>KdA(d,i,o):c=d=>XdA(d,i,o,l):j==="TILE"?c=d=>zdA(d,i,o,l):j==="TRX"?c=d=>UdA(d,i,o,l):j==="CELL"?c=d=>VdA(d,i,o,l):j==="NBHD"?c=d=>QdA(d,i,o,l):j==="UMAP"?c=d=>WdA(d,i,o,l):j==="SPATIAL"?c=d=>YdA(d,i,o,l):c=JdA(j,i,o,l);let B=VA(t).append("div").attr("class",n).text(j).style("width",`${r}px`).style("text-align","left").style("cursor","pointer").style("font-size","12px").style("font-weight","bold").style("color",e).style("margin-top","5px").style("margin-left","5px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif;').on("click",c),h=j.toLowerCase();l.buttons.buttons[h]=B},E_=(t,A,j,e,r,n,i)=>{let o="edit_button";r=r.toUpperCase();let c=VA(e).append("div").classed(o,!0).classed("active",!1).text(r).style("width",`${n}px`).style("height","20px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","12px").style("font-weight","bold").style("color","gray").style("margin-left","3px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').on("click",h=>i(h,t,A,j)).node(),B=r.toLowerCase();j.edit.buttons[B]=c};var A7={},nu=async t=>{if(!(t in A7)){let A={name:"",description:"Unable to obtain UniProt description."},r=`https://www.ebi.ac.uk/proteins/api/proteins?offset=0&size=100&exact_gene=${t}&organism=human`;try{let o=(await(await fetch(r,{headers:{Accept:"application/json"}})).json()).filter(l=>l.proteinExistence==="Evidence at protein level").filter(l=>"comments"in l).filter(l=>"gene"in l).filter(l=>l.gene[0].name.value.toLowerCase()===t.toLowerCase()).sort((l,c)=>c.comments.length-l.comments.length);if(o.length>0){let c=`https://rest.uniprot.org/uniprotkb/${o[0].accession}.json`;try{let h=await(await fetch(c)).json(),d=h.proteinDescription?.recommendedName?.fullName?.value||"",k=h.comments?.[0]?.texts?.[0]?.value||"Unable to obtain UniProt description.";A={name:d,description:k}}catch(B){Zj(B,{context:`fetching detailed info for ${t}`,url:c,logUnexpected:!0,throwOnAuth:!1})}}}catch(n){Zj(n,{context:`searching for gene ${t}`,url:r,logUnexpected:!0,throwOnAuth:!1})}A7[t]=A}};var SI=(t,A,j)=>{let e,r,n={};t[`${A}_nodes`].forEach((B,h)=>{n[h]=[h],B.group_links=h});let i=t[`${A}_nodes`].length,o=0,l;t.linkage[A].forEach((B,h)=>{B[2]>o&&B[2]{h.forEach(d=>{c[d]=B})}),t[`${A}_nodes`].forEach((B,h)=>{B.group_links=c[h]})},RI=(t,A)=>{let j={},e=t[`${A}_nodes`],r,n,i=t.mat[`num_${A}s`];A==="row"?(r=t.viz.mat_width,n=r/i):(r=t.viz.mat_height,n=r/i);let o=t.order.current[A];e.forEach((c,B)=>{let h=c.group_links,d;if(A==="row"){let E=t.mat.num_rows-t.mat.orders.row[o][B];d=t.viz.row_offset*(E+1)}else{let E=t.mat.num_cols-t.mat.orders.col[o][B];d=t.viz.col_offset*(E+0)}let k=d+n,g=c.name;g.indexOf(": ")>=0&&(g=g.split(": ")[1]),Object.prototype.hasOwnProperty.call(j,h)||(j[h]={name_top:g,name_bot:g,pos_top:d,pos_bot:k,pos_mid:(d+k)/2,name:h,all_names:[],axis:A}),j[h].all_names.push(g),dj[h].pos_bot&&(j[h].name_bot=g,j[h].pos_bot=k,j[h].pos_mid=(j[h].pos_top+k)/2)});let l=[];Object.values(j).forEach(c=>{l.push(c)}),t.dendro.group_info[A]=l},bz=t=>{t.dendro={},t.dendro.default_level=5,t.dendro.tri_height=.1,t.dendro.trap_height=.03,t.dendro.trap_float=.005,t.dendro.dendro_args={},t.dendro.group_level={},t.dendro.polygons={},t.dendro.update_dendro=!1,t.dendro.selected_clust_names=[],t.dendro.group_info={},t.dendro.default_link_level=.5,t.dendro.output_label_format="list",t.dendro.min_dist={},t.dendro.min_dist.row=0,t.dendro.min_dist.col=0;let A=["col","row"],j;t.dendro.max_linkage_dist={};let e;A.forEach(r=>{j=t.linkage[r],t.dendro.max_linkage_dist[r]=j[j.length-1][2]+.01,e=t.dendro.max_linkage_dist[r]*t.dendro.default_link_level,SI(t,r,e),RI(t,r)})},eg=(t,A)=>{t.dendro.polygons[A]=[],t.dendro.group_info[A].forEach(j=>{let{pos_top:e,pos_bot:r,pos_mid:n}=j;if(A==="row"){let i=r-e,o=7,l=[[o+100,n],[o,n-i/2],[o,n+i/2]];t.dendro.polygons[A].push({coordinates:l,properties:{...j,axis:A,is_focused:!1}})}else if(A==="col"){let i=r-e,o=17,l=[[n,o+100],[n-i/2,o],[n+i/2,o]];t.dendro.polygons[A].push({coordinates:l,properties:{...j,axis:A,is_focused:!1}})}})};var ZdA=t=>({selected_cats:[...t.cats.selected_cats],selected_genes:[...t.genes.selected_genes],cat:t.cats.cat,viz_image_layers:t.obs_store.viz_image_layers.get(),landscape_view:t.obs_store.landscape_view.get()}),ApA=async(t,A,j)=>{t.umap.has_umap&&t.obs_store.landscape_view.set(j.landscape_view);let e=j.selected_genes.filter(r=>t.genes.gene_names.includes(r));if(e.length>0){let r=e[0];await qr(t.cats,t.genes,t.global_base_url,r,t.seg.version,t.vector_name_integer,t.aws,t.row_group_readers?.cbg),gt(t.cats,r),Qt(t.genes,e,t.obs_store),Rt(t.cats,e,t.obs_store),t.selection_token=(t.selection_token||0)+1,A.cell_layer=A.cell_layer.clone({id:`cell-layer-gene-${r}-${t.selection_token}`,updateTriggers:{getFillColor:[t.selection_token,r]}}),t.layers_obj=A}else{let r=new Set(t.cats.cluster_counts.map(i=>i.name)),n=j.selected_cats.filter(i=>r.has(i));n.length>0?(gt(t.cats,"cluster"),Rt(t.cats,n,t.obs_store),Qt(t.genes,[],t.obs_store)):(Rt(t.cats,[],t.obs_store),Qt(t.genes,[],t.obs_store))}t.obs_store.persistent_state.set({selected_cats:t.cats.selected_cats,selected_genes:t.genes.selected_genes,cat:t.cats.cat,viz_image_layers:t.obs_store.viz_image_layers.get(),landscape_view:j.landscape_view})},wz=async(t,A,j,e)=>{let r=A.base_urls||[];if(t<0||t>=r.length)return;let n=ZdA(A);A.obs_store.dataset_switching.set(!0),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),background_layer:!1,image_layers:!1,cell_layer:!1,path_layer:!1,trx_layer:!1});try{let o=r[t].url;Es(A,o),await xs(A.img,o,A.aws);let l=A.img.landscape_parameters.image_info,c=l[0].name;Qf(A.img,A.img.landscape_parameters.image_format),Wf(A.img,l),Hf(A.img),Yf(A.img.image_layer_colors,A.img.image_info);let B=A.img.landscape_parameters.technology;B!=="Chromium"&&B!=="point-cloud"&&await $s(A,o,c),A.genes.gene_counts=[],A.genes.meta_gene={},await gl(A.genes,o,A.seg.version,A.aws),A.genes.top_gene_counts=A.genes.gene_counts.slice(0,100),A.obs_store.new_gene_bar_data.set(A.genes.top_gene_counts),await a_(A.genes,o,A.seg.version,A.aws);let h;A.seg.version==="default"?h=`${o}/cell_metadata.parquet`:h=`${o}/cell_metadata_${A.seg.version}.parquet`;let d=await ae(h,Nt.fetch,A.aws);if(o_(A.cats,d),A.spatial.cell_scatter_data=dl(d),s_(A.cats),A.cats.has_meta_cell){let _=A.cats.meta_cell_attr.indexOf(A.cats.inst_cell_attr);A.cats.cell_cats=A.cats.cell_names_array.map(w=>A.cats.meta_cell[w]?.[_]??"N.A.")}else{let _=await ae(`${o}/cell_clusters${A.seg.version&&A.seg.version!=="default"?`_${A.seg.version}`:""}/cluster.parquet`,Nt.fetch,A.aws);Nv(A.cats,_,"cluster")}Kv(A.cats),A.cats.color_dict_cluster={},A.cats.cluster_counts=[],await Jf(A),A.obs_store.new_cell_bar_data.set(A.cats.cluster_counts);let k=d.getChild("name").toArray(),g=A.spatial.cell_scatter_data.attributes.getPosition.value,E=A.spatial.cell_scatter_data.attributes.getPosition.size||2;A.combo_data.cell=k.map((_,w)=>({name:_,cat:A.cats.dict_cell_cats[_],x:g[w*E],y:g[w*E+1],z:E===3?g[w*E+2]:0}));let m;if(A.umap.has_umap){let _=new Float64Array(A.cats.cell_names_array.flatMap(x=>{let S=A.umap.umap[x];return S||(S=[0,0]),S})),w=A.spatial.cell_scatter_data.length;m=Array.from({length:w},(x,S)=>({name:A.cats.cell_names_array[S],position:E===3?[g[S*E],g[S*E+1],g[S*E+2]]:[g[S*E],g[S*E+1]],umap:[_[S*2],_[S*2+1]]})),m=l_(A,m)}else{let _=A.spatial.cell_scatter_data.length;m=Array.from({length:_},(w,x)=>({name:A.cats.cell_names_array[x],position:E===3?[g[x*E],g[x*E+1],g[x*E+2]]:[g[x*E],g[x*E+1]]}))}A.spatial.cell_scatter_data_objects=m,A.spatial.x_min=vr(m.map(_=>_.position[0])),A.spatial.x_max=xj(m.map(_=>_.position[0])),A.spatial.y_min=vr(m.map(_=>_.position[1])),A.spatial.y_max=xj(m.map(_=>_.position[1])),E===3&&(A.spatial.z_min=vr(m.map(_=>_.position[2])),A.spatial.z_max=xj(m.map(_=>_.position[2]))),A.spatial.center_x=(A.spatial.x_max+A.spatial.x_min)/2,A.spatial.center_y=(A.spatial.y_max+A.spatial.y_min)/2,A.spatial.data_width=A.spatial.x_max-A.spatial.x_min,A.spatial.data_height=A.spatial.y_max-A.spatial.y_min,e.cell_layer=e.cell_layer.clone({id:`cell-layer-dataset-${t}`,data:m,transitions:!1,updateTriggers:{getPosition:[A.obs_store.umap_state.get(),t],getFillColor:[A.selection_token,t]}}),e.image_layers&&Array.isArray(e.image_layers)&&e.image_layers.forEach(_=>{if(_&&typeof _.finalize=="function")try{_.finalize()}catch(w){}});let y=await B_(A,t);e.image_layers=y,A.dimensions&&(e.background_layer=Rf(A)),A.genes.trx_data=[],A.genes.trx_names_array=[],A.cats.polygon_cell_names=[],A.combo_data.trx=[],e.trx_layer=e.trx_layer.clone({id:`trx-layer-dataset-${t}`,data:[]}),e.path_layer=e.path_layer.clone({id:`path-layer-dataset-${t}`,data:[]}),A.cache?.cell&&A.cache.cell.clear(),A.cache?.trx&&A.cache.trx.clear(),A.cats.selected_cats=[],A.genes.selected_genes=[],A.cats.cat="cluster",A.layers_obj=e,A.obs_store.current_dataset_index.set(t),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),background_layer:!0,image_layers:!0,cell_layer:!0,path_layer:!0,trx_layer:!0,trx_data:!0,path_data:!0});let b=Wr(e,A.close_up);j.setProps({layers:b}),await ApA(A,e,n);let v=Wr(A.layers_obj,A.close_up);j.setProps({layers:v}),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),cell_layer:!1}),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),cell_layer:!0})}finally{A.obs_store.dataset_switching.set(!1)}};var Fz=(t,A,j)=>{let e=t.base_urls||[];if(e.length<=1)return null;let r=document.createElement("div");r.className="dataset-dropdown-container",r.style.display="inline-flex",r.style.alignItems="center",r.style.marginLeft="5px",r.style.marginRight="5px",r.style.position="relative";let n=document.createElement("select");n.className="dataset-dropdown",n.style.width="55px",n.style.height="18px",n.style.fontSize="9px",n.style.padding="1px 2px",n.style.border="1px solid #d3d3d3",n.style.borderRadius="3px",n.style.backgroundColor="white",n.style.cursor="pointer",n.style.outline="none",n.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',n.style.transition="width 0.15s ease",n.title="Switch dataset";let i=Math.max(...e.map(l=>(l.label||"").length)),o=Math.min(Math.max(i*7+20,80),150);return n.addEventListener("mousedown",()=>{n.style.width=`${o}px`}),n.addEventListener("focus",()=>{n.style.borderColor="#8797ff",n.style.width=`${o}px`}),n.addEventListener("blur",()=>{n.style.borderColor="#d3d3d3",n.style.width="55px"}),n.addEventListener("change",()=>{setTimeout(()=>{n.style.width="55px"},100)}),e.forEach((l,c)=>{let B=document.createElement("option");B.value=c;let h=l.short_label||l.label||`DS-${c+1}`,d=l.label||`Dataset ${c+1}`;B.textContent=h,B.title=d,n.appendChild(B)}),n.value=t.obs_store.current_dataset_index.get(),n.addEventListener("change",async l=>{let c=parseInt(l.target.value,10),B=t.obs_store.current_dataset_index.get();if(c!==B&&!t.obs_store.dataset_switching.get()){n.disabled=!0,n.style.opacity="0.5";try{await wz(c,t,A,j)}catch(h){n.value=B}finally{n.disabled=!1,n.style.opacity="1"}}}),t.obs_store.current_dataset_index.subscribe(l=>{n.value=l}),r.appendChild(n),r};var $_=async(t,A)=>{let j=t.global_base_url,e=await ae(`${j}/tbg/${A}.parquet`,Nt.fetch,t.aws),r=e.getChild("__index_level_0__").toArray(),n=e.getChild(A).toArray(),i=new Array(t.cats.tile_names_array.length).fill(0);r.forEach((o,l)=>{if(t.cats.tile_name_to_index_map.has(o)){let c=t.cats.tile_name_to_index_map.get(o),B=Math.log1p(Number(n[l])),h=Math.log(Number(t.genes.meta_gene[A].max));i[c]=B/h*255}}),t.cats.tile_exp_array=i};var Pz=t=>{let A=document.createElement("input");A.setAttribute("type","text"),A.setAttribute("placeholder","Gene search"),A.style.width="500px",A.style.height="20px",A.style.marginTop="5px",A.style.display="inline-block",A.style.padding="1pt 2pt",t.gene_search_input=A};var LI=[],Iz=0,tpA=async(t,A,j)=>{let e=A.genes.gene_search_input.value,r=e===""?"cluster":e;(e===""||A.genes.gene_names.includes(e))&&(gt(A.cats,r),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),square_scatter_layer:!1}),Qt(A.genes,e===""?[]:[e],A.obs_store),Rt(A.cats,[],A.obs_store),e!==""&&LI.includes(e)&&await $_(A,e),tg(A,j),t.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]}))},jpA=async(t,A,j)=>{let e=j.genes.gene_search_input.value,r=e===""?"cluster":e;(e===""||j.genes.gene_names.includes(e))&&(gt(j.cats,r),j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Qt(j.genes,e===""?[]:[e],j.obs_store),j.genes.gene_names.includes(e)&&await qr(j.cats,j.genes,j.global_base_url,e,j.seg.version,j.vector_name_integer,j.aws,j.row_group_readers?.cbg),Rt(j.cats,r==="cluster"?[]:[e],j.obs_store))},rg=async(t,A,j,e)=>{LI=["cluster",...e.genes.gene_names],e.genes.gene_search.style.width="115px",Pz(e.genes);let r=document.createElement("datalist");Iz+=1,r.id=`genes_datalist_${Iz}_${Date.now()}`,e.genes.gene_search_input.setAttribute("list",r.id),LI.forEach(i=>{let o=document.createElement("option");o.value=i,r.appendChild(o)}),e.genes.gene_search_input.style.width="156px",e.genes.gene_search_input.style.maxWidth="250px",e.genes.gene_search_input.style.height="12px",e.genes.gene_search_input.style.fontSize="12px",e.genes.gene_search_input.style.border="1px solid #d3d3d3",e.genes.gene_search_input.style.borderRadius="0",e.genes.gene_search_input.style.display="inline-block",e.genes.gene_search_input.style.padding="1pt 2pt",e.genes.gene_search.appendChild(e.genes.gene_search_input),e.genes.gene_search.appendChild(r),e.genes.gene_text_box=document.createElement("div"),e.genes.gene_text_box.textContent="",e.genes.gene_text_box.style.marginTop="3px",e.genes.gene_text_box.style.color="#222222",e.genes.gene_text_box.style.border="1px solid #d3d3d3",e.genes.gene_text_box.style.height="69px",e.genes.gene_text_box.style.overflow="scroll",e.genes.gene_text_box.style.fontSize="12px",e.genes.gene_text_box.style.cursor="default",e.genes.gene_text_box.style.width="142px",e.genes.gene_text_box.style.paddingLeft="2px",e.genes.gene_text_box.style.paddingRight="17px",e.genes.gene_text_box.addEventListener("wheel",i=>{let{scrollTop:o,scrollHeight:l,clientHeight:c}=e.genes.gene_text_box,B=o===0,h=o+c===l;(B&&i.deltaY<0||h&&i.deltaY>0)&&i.preventDefault()}),e.genes.gene_search.appendChild(e.genes.gene_text_box),e.genes.gene_search_input.value="",gt(e.cats,"cluster");let n;t==="sst"?(n=()=>tpA(A,e,j),e.genes.gene_search_input.style.marginTop="10px",e.genes.gene_search.style.height="50px"):(n=()=>jpA(A,j,e),e.genes.gene_search_input.style.marginTop="5px"),e.genes.gene_search_input.addEventListener("input",n)};var x_="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";var epA=()=>{let t=document.createElement("div");return t.className="matrix-cat-bar-container",t.style.display="flex",t.style.flexDirection="row",t.style.gap="8px",t.style.marginTop="5px",t.style.marginLeft="10px",t.style.maxHeight="100px",t.style.overflow="hidden",t},Mz=(t,A,j)=>{let e=document.createElement("div");e.className=`cat-bar-wrapper-${t}`,e.style.display="flex",e.style.flexDirection="column",e.style.width="95px";let r=document.createElement("div");r.className=`cat-bar-title-${t}`,r.textContent=A||t.toUpperCase(),r.style.fontSize="10px",r.style.fontWeight="bold",r.style.marginBottom="2px",r.style.whiteSpace="nowrap",r.style.overflow="hidden",r.style.textOverflow="ellipsis",r.style.textTransform="capitalize",e.appendChild(r);let n=document.createElement("div");n.className=`cat-bar-graph-${t}`,n.style.width="95px",n.style.height="72px",n.style.overflowY="auto",n.style.border="1px solid #d3d3d3",e.appendChild(n),n.addEventListener("wheel",o=>{let{scrollTop:l,scrollHeight:c,clientHeight:B}=n,h=l===0,d=l+B===c;(h&&o.deltaY<0||d&&o.deltaY>0)&&o.preventDefault()});let i=Ur("svg").attr("width",90).attr("font-family","sans-serif").attr("font-size","11").attr("text-anchor","end").style("user-select","none");return n.appendChild(i.node()),{wrapper:e,bar_container:n,svg:i,title:r}},ng=(t,A,j,e,r,n)=>{let l=14*(A.length+1);t.attr("height",l);let c=A.map(E=>E.value),B=ti().domain(F6(c.length)).range([0,15*c.length]),h=ji().domain([0,xj(c)||1]).range([0,85]),d=t.selectAll("g").data(A,E=>E.name),k=d.enter().append("g").attr("class","cat-bar-item").attr("data-name",E=>E.name).attr("transform",(E,m)=>`translate(2,${B(m)+2})`).style("cursor",e?"pointer":"default").on("click",(E,m)=>{e&&e(m)}).on("mouseenter",(E,m)=>{r&&r(m)}).on("mouseleave",(E,m)=>{n&&n(m)});k.append("rect").attr("fill",E=>{let m=j?.[E.name]||[100,100,100];return Array.isArray(m)?`rgb(${m[0]}, ${m[1]}, ${m[2]})`:m}).attr("width",0).attr("height",B.bandwidth()-1).transition().duration(300).attr("width",E=>h(E.value)),k.append("text").attr("fill","black").attr("x","3px").attr("y",B.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").text(E=>`${E.name} (${E.value})`);let g=d.merge(k);g.transition().duration(300).attr("transform",(E,m)=>`translate(2,${B(m)+2})`),g.select("rect").transition().duration(300).attr("width",E=>h(E.value)).attr("fill",E=>{let m=j?.[E.name]||[100,100,100];return Array.isArray(m)?`rgb(${m[0]}, ${m[1]}, ${m[2]})`:m}),g.select("text").text(E=>`${E.name} (${E.value})`),g.on("mouseenter",(E,m)=>{r&&r(m)}).on("mouseleave",(E,m)=>{n&&n(m)}),d.exit().transition().duration(300).attr("opacity",0).remove()},v_=(t,A)=>{["row","col"].forEach(j=>{let e=t.cat_bars?.[j]?.svg;e&&e.selectAll(".cat-bar-item").each(function(r){let n=VA(this),i=n.select("rect"),o=n.select("text"),l=String(r.name),c=A!=null?String(A):null;c?l===c?(n.style("opacity","1"),i.style("opacity","1"),o.style("opacity","1")):(n.style("opacity","0.15"),i.style("opacity","0.15"),o.style("opacity","0.15")):(n.style("opacity",null),i.style("opacity",null),o.style("opacity",null))})})},CI=(t,A)=>{let j=A==="row"?t.row_nodes:t.col_nodes,e=t.attr?.cats?.[A]||[];if(e.length===0||!j||j.length===0)return null;let r=e[0],i=(t.attr?.names?.[A]||[]).indexOf(r);if(i<0)return null;let o=`cat-${i}`,l={};j.forEach(B=>{let h=B[o];h!=null&&(l[h]=(l[h]||0)+1)});let c=Object.entries(l).map(([B,h])=>({name:B,value:h})).sort((B,h)=>h.value-B.value);return{attr_name:r,attr_index:i,data:c}},rpA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr?.cats?.[A]||[];if(r.length===0||!e||e.length===0)return null;let n=r[0],o=(t.attr?.names?.[A]||[]).indexOf(n);if(o<0)return null;let l=new Set(j),c=e.filter(k=>l.has(k.name)),B=`cat-${o}`,h={};c.forEach(k=>{let g=k[B];g!=null&&(h[g]=(h[g]||0)+1)});let d=Object.entries(h).map(([k,g])=>({name:k,value:g})).sort((k,g)=>g.value-k.value);return{attr_name:n,attr_index:o,data:d}},__=(t,A)=>{let j=t.attr?.cats?.[A]||[];return j.length>0?j[0]:A.toUpperCase()},Oz=t=>{let{deck_mat:A}=t,{layers_mat:j}=t;!A||!j||(j.row_cat_layer&&(j.row_cat_layer=j.row_cat_layer.clone({updateTriggers:{getFillColor:[t.hovered_cat]}})),j.col_cat_layer&&(j.col_cat_layer=j.col_cat_layer.clone({updateTriggers:{getFillColor:[t.hovered_cat]}})),A.setProps({layers:le(j)}))},ig=(t,A,j)=>({on_hover:n=>{if(t.hovered_cat={axis:A,name:n.name,level:j},v_(t,n.name),Oz(t),t.obs_store?.hovered_category){let i=t.attr.names[A]?.[j];t.obs_store.hovered_category.set({axis:A,attr_name:i,attr_index:j,value:n.name})}},on_hover_out:()=>{t.hovered_cat=null,v_(t,null),Oz(t),t.obs_store?.hovered_category&&t.obs_store.hovered_category.set(null)}}),npA=(t,A)=>{let j=t.obs_store?.manual_cat?.[A];if(!j)return null;let e=j.getAttribute()||t.manual_cat?.config?.[A]?.attribute||"Manual",r=j.getAssignments()||{},n={};Object.values(r).forEach(o=>{if(o!=null&&o!==""){let l=String(o);n[l]=(n[l]||0)+1}});let i=Object.entries(n).map(([o,l])=>({name:o,value:l})).sort((o,l)=>l.value-o.value);return{attr_name:e,attr_index:0,data:i}},Tz=(t,A)=>{let j=t.attr?.cats?.row||[],e=t.attr?.cats?.col||[],r=t.manual_cat?.flags?.row,n=t.manual_cat?.flags?.col;if(j.length===0&&e.length===0&&!r&&!n)return null;let i=epA();if(t.cat_bars={container:i,row:null,col:null},j.length>0||r){let o=j.length>0?__(t,"row"):t.manual_cat?.config?.row?.attribute||"Manual",{wrapper:l,svg:c,title:B,bar_container:h}=Mz("row",`Row: ${o}`);if(i.appendChild(l),t.cat_bars.row={wrapper:l,svg:c,title:B,bar_container:h},j.length>0){let d=CI(t,"row");if(d&&d.data.length>0){let k=y_(t),{on_hover:g,on_hover_out:E}=ig(t,"row",d.attr_index);ng(c,d.data,k,m=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:"row",attr_name:d.attr_name,attr_index:d.attr_index,value:m.name})},g,E)}}}if(e.length>0||n){let o=e.length>0?__(t,"col"):t.manual_cat?.config?.col?.attribute||"Manual",{wrapper:l,svg:c,title:B,bar_container:h}=Mz("col",`Col: ${o}`);if(i.appendChild(l),t.cat_bars.col={wrapper:l,svg:c,title:B,bar_container:h},e.length>0){let d=CI(t,"col");if(d&&d.data.length>0){let k=y_(t),{on_hover:g,on_hover_out:E}=ig(t,"col",d.attr_index);ng(c,d.data,k,m=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:"col",attr_name:d.attr_name,attr_index:d.attr_index,value:m.name})},g,E)}}}return t.obs_store?.dendro_selection&&t.obs_store.dendro_selection.subscribe(o=>{ipA(t,o)},{immediate:!1}),t.obs_store?.hovered_category&&t.obs_store.hovered_category.subscribe(o=>{o?v_(t,o.value):v_(t,null)},{immediate:!1}),t.obs_store?.manual_cat&&["row","col"].forEach(o=>{let l=t.obs_store.manual_cat[o];l&&l.subscribe(()=>{if(t.cat_bars?.[o]?.svg){let c=npA(t,o);if(c&&c.data.length>0){let B=y_(t),{on_hover:h,on_hover_out:d}=ig(t,o,0);ng(t.cat_bars[o].svg,c.data,B,g=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:o,attr_name:c.attr_name,attr_index:0,value:g.name})},h,d);let k=o==="row"?"Row":"Col";t.cat_bars[o].title.textContent=`${k}: ${c.attr_name}`}}},{immediate:!1})}),A.appendChild(i),i};function y_(t){let A={},j=r=>{if(!r||typeof r!="string")return null;let n=r.replace("#","");return n.length!==6?null:[parseInt(n.substring(0,2),16),parseInt(n.substring(2,4),16),parseInt(n.substring(4,6),16)]};["row","col"].forEach(r=>{(t.attr?.all_defs?.[r]||[]).forEach(i=>{i.type==="categorical"&&i.color_map&&Object.entries(i.color_map).forEach(([o,l])=>{if(!A[o])if(typeof l=="string"){let c=j(l);c&&(A[o]=c)}else Array.isArray(l)&&(A[o]=l.slice(0,3))})})});let e=t.network?.global_cat_colors||t.global_cat_colors||{};return Object.entries(e).forEach(([r,n])=>{if(!A[r])if(typeof n=="string"){let i=j(n);i&&(A[r]=i)}else Array.isArray(n)&&(A[r]=n.slice(0,3))}),A}function ipA(t,A){let j=y_(t);if(!A){["row","col"].forEach(n=>{if(t.cat_bars?.[n]){let i=CI(t,n);if(i&&i.data.length>0){let{on_hover:o,on_hover_out:l}=ig(t,n,i.attr_index);ng(t.cat_bars[n].svg,i.data,j,h=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:n,attr_name:i.attr_name,attr_index:i.attr_index,value:h.name})},o,l);let c=__(t,n),B=n==="row"?"Row":"Col";t.cat_bars[n].title.textContent=`${B}: ${c}`}}});return}let{axis:e,selected_names:r}=A;if(t.cat_bars?.[e]){let n=rpA(t,e,r);if(n&&n.data.length>0){let{on_hover:i,on_hover_out:o}=ig(t,e,n.attr_index);ng(t.cat_bars[e].svg,n.data,j,h=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:e,attr_name:n.attr_name,attr_index:n.attr_index,value:h.name})},i,o);let l=__(t,e),c=e==="row"?"Row":"Col",B=n.data.reduce((h,d)=>h+d.value,0);t.cat_bars[e].title.textContent=`${c}: ${l} (${B})`}}}var HI=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.style.border="1px solid #d3d3d3",t.className="ui_container",t.style.height="100px",t.style.boxSizing="border-box",t.style.width="100%",t.style.maxWidth="100%",t.style.margin="0 auto",t},Sz=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.className="ctrl_container",t.style.width="100%",t},a6=(t,A,j=null)=>{let e=document.createElement("div");return e.className=t,e.style.display="flex",e.style.flexDirection=A,j!==null&&(e.style.height=`${j}px`,e.style.overflow="scroll"),e},og=t=>{let A=document.createElement("div");return A.className=t,A.style.width="100%",A.style.marginLeft="2px",A.style.marginTop="2px",A},opA=(t,A)=>{let j=A==="row"?t.row_entity:t.col_entity,e=A==="row"?"Row":"Col";if(j&&j.entity){let{entity:r}=j;return!r||r==="N.A."||r==="n.a."?e:{gene:"Gene",cell:"Cell",nbhd:"Nbhd",cluster:"Clust",hextile:"Hex"}[r]||r.substring(0,4).toUpperCase()}return e},Rz=(t,A,j)=>{let e=HI(),r=a6("button_container","column"),n=a6("slider_container","column"),i=34,o=28,l=["col","row"],c=["clust","sum","var","ini"];l.forEach(h=>{let d=a6(h,"row"),k=opA(j,h);VA(d).append("div").text(k).style("width",`${o}px`).style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","9px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color","white").style("border-radius","8px").style("margin-top","4px").style("margin-left","3px").style("padding","2px 2px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif'),c.forEach(g=>{Gz(d,g,g==="clust",i,h,t,A,j)}),r.appendChild(d)}),j.dendro.sliders={};let B=(h,d,k,g)=>{d.dendro.sliders[`${k}_value`]=d.dendro.max_linkage_dist[k]*g.target.value/100,SI(d,k,d.dendro.sliders[`${k}_value`]),RI(d,k),eg(d,k),_z(A,d,k),h.setProps({layers:le(A)})};return l.forEach(h=>{let d=document.createElement("input");j.dendro.sliders[h]=d,Df(d,50,g=>B(t,j,h,g))}),j.dendro.sliders.col.style.marginTop="3px",j.dendro.sliders.row.style.marginTop="10px",VA(n).append("div").text("Dendro").style("width","40px").style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","10px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color","white").style("border-radius","8px").style("margin-left","10px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif'),n.appendChild(j.dendro.sliders.col),n.appendChild(j.dendro.sliders.row),r.style.marginTop="10px",n.style.marginTop="0px",n.style.marginLeft="5px",e.appendChild(r),e.appendChild(n),Tz(j,e),e},Lz=(t,A,j)=>{let e=HI(),r=Sz(),n=a6("image_container","row"),i=a6("tile_container","row"),o=og("tile_slider_container");return kn(n,"sst","IMG","blue",50,"button",t,A,j),kn(i,"sst","TILE","blue",50,"button",t,A,j),j.sliders={},kl("tile",t,A,j),o.appendChild(j.sliders.tile),e.appendChild(r),i.appendChild(o),rg("sst",t,A,j),j.obs_store.selected_genes.subscribe(async l=>{if(l.length===1){let c=l[0];if(j.genes.gene_search_input.value=c,c!==""){if(j.genes.gene_names.includes(c)){j.genes.gene_text_box.textContent="loading",await nu(c);let B=A7[c];B&&B.name&&B.description?j.genes.gene_text_box.innerHTML=`${B.name}
${B.description}`:j.genes.gene_text_box.textContent=""}}else j.genes.gene_text_box.textContent="";j.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else l.length===0&&(j.genes.gene_search_input.value="",j.genes.gene_text_box.textContent="")}),r.appendChild(n),r.appendChild(i),r.appendChild(j.genes.gene_search),e},Cz=(t,A,j,e)=>{let r=HI(),n=Sz();e.containers.image=a6("image_container","column");let i=a6("img_layers_container","column",72);i.style.width="135px",i.style.border="1px solid #d3d3d3",i.style.marginTop="3px",i.style.marginLeft="2px",i.addEventListener("wheel",z=>{let{scrollTop:T,scrollHeight:W,clientHeight:G}=i,jA=T===0,pA=T+G===W;(jA&&z.deltaY<0||pA&&z.deltaY>0)&&z.preventDefault()});let o="115px",l=a6("cell_container","column");l.style.width=o;let c=a6("cell_ctrl_container","row");c.style.marginLeft="0px";let B=a6("gene_container","column");B.style.marginTop="0px",B.style.width=o;let h=a6("trx_container","row"),d,k;e.nbhd.is_nbhd&&(d=a6("nbhd_container","column"),d.style.width=o,k=a6("nbhd_ctrl_container","row"),k.style.marginLeft="0px",k.style.height="22.5px");let g=og("cell_slider_container"),E=og("trx_slider_container"),m;e.nbhd.is_nbhd&&(m=og("nbhd_slider_container"));let{technology:y}=e.img.landscape_parameters,b=y==="Chromium",v=y==="point-cloud";if(!v){let z=a6("image_layer_container","row");if(b)kn(z,"ist","UMAP","blue",35,"button",A,j,e);else{if(e.umap.has_umap===!0){let jA=e.obs_store.umap_state.get(),pA,dA;jA===!0?(pA="blue",dA="gray"):(pA="gray",dA="blue"),kn(z,"ist","UMAP",pA,35,"button",A,j,e),kn(z,"ist","SPATIAL",dA,50,"button",A,j,e)}kn(z,"ist","IMG","blue",30,"button",A,j,e)}e.containers.image.appendChild(z);let T=Fz(e,A,j);T&&z.appendChild(T);let W=(jA,pA)=>jA.image_layer_sliders.filter(dA=>dA.name===pA),G=(jA,pA)=>{let dA=pA.button_name,$A=a6("image_layer_container","row");$A.style.height="21px";let _A=e.obs_store.umap_state.get()?"gray":"blue";kn($A,"ist",dA,_A,75,"img_layer_button",A,j,e);let Y=og(dA),QA=W(jA,dA)[0],mt=f_(dA,A,j,e),SA=Sf(mt,100);Df(QA,50,SA),Y.appendChild(QA),$A.appendChild(Y),i.appendChild($A)};e.img.image_info.map(jA=>G(e.img,jA)),e.obs_store.viz_image_layers.subscribe(jA=>{VA(e.containers.image).selectAll(".img_layer_button").style("color",jA?"blue":"gray"),e.img.image_layer_sliders.map(pA=>Rj(pA,jA)),Cf(j,jA),TA(e,j,"image_layers"),jA&&e.obs_store.umap_state.get()&&e.obs_store.landscape_view.set("spatial")}),e.obs_store.viz_background_layer.subscribe(jA=>{i_(j,jA),TA(e,j,"background_layer")}),e.obs_store.viz_nbhd_layer.subscribe(jA=>{pl(j,jA),TA(e,j,"nbhd_layer")}),e.containers.image.appendChild(i)}kn(c,"ist","CELL","blue",40,"button",A,j,e),e.nbhd.is_nbhd&&!e.nbhd.edit&&kn(k,"ist","NBHD","gray",40,"button",A,j,e),kn(h,"ist","TRX","blue",40,"button",A,j,e),e.sliders={},kl("cell",A,j,e),g.appendChild(e.sliders.cell),c.appendChild(g),e.nbhd.is_nbhd&&!e.nbhd.edit&&(kl("nbhd",A,j,e),m.appendChild(e.sliders.nbhd),k.appendChild(m),Rj(e.sliders.nbhd,e.obs_store.viz_nbhd_layer.get())),e.containers.bar_cluster=ju(),e.cats.svg_bar_cluster=Ur("svg"),e.genes.svg_bar_gene=Ur("svg"),e.nbhd.is_nbhd&&(e.nbhd.svg_bar_nbhd=Ur("svg")),Za(e.containers.bar_cluster,Nf,e.cats.svg_bar_cluster,e.cats.cluster_counts,e.cats.color_dict_cluster,A,j,e),e.containers.bar_gene=ju();let _=1e3;e.genes.gene_counts=e.genes.gene_counts.sort((z,T)=>T.value-z.value).slice(0,_),Za(e.containers.bar_gene,Kf,e.genes.svg_bar_gene,e.genes.top_gene_counts,e.genes.color_dict_gene,A,j,e);let w=(z,T)=>W=>{if(!Array.isArray(W)||W.length===0)z.selectAll("g").attr("font-weight","normal").attr("opacity",1),T.scrollTo({top:0,behavior:"smooth"});else if(z.selectAll("g").attr("font-weight",G=>W.includes(G.name)?"bold":"normal").attr("opacity",G=>W.includes(G.name)?1:.2),W.length===1){let G=W[0],jA=z.selectAll("g").filter(function(){return VA(this).select("text").text()===G});if(!jA.empty()){let pA=jA.node(),dA=T.getBoundingClientRect(),$A=pA.getBoundingClientRect(),_A=$A.top,Y=$A.bottom,QA=dA.top,mt=dA.bottom;if(!(_A>=QA&&Y<=mt)){let SA=_A-QA,ft=T.scrollTop+SA;T.scrollTo({top:ft,behavior:"smooth"})}}}};e.obs_store.selected_cats.subscribe(w(e.cats.svg_bar_cluster,e.containers.bar_cluster),{immediate:!1}),e.obs_store.selected_genes.subscribe(w(e.genes.svg_bar_gene,e.containers.bar_gene),{immediate:!1});let x=({svg:z,color_dict:T,selected_array:W,bar_callback:G,container:jA})=>pA=>{let $A=15*(pA.length+1);z.attr("height",$A);let _A=90,Y=pA.map(wA=>wA.value),QA=ti().domain(F6(Y.length)).range([0,16*Y.length]),mt=ji().domain([0,xj(Y)]).range([0,_A]),Ct=z.selectAll("g").data(pA,wA=>wA.name),SA=Ct.enter().append("g").attr("transform",(wA,_t)=>`translate(2,${QA(_t)+2})`).on("click",(wA,_t)=>G(wA,_t,A,j,e));SA.append("rect").attr("width",0).attr("height",QA.bandwidth()-1).transition().duration(750).attr("width",wA=>mt(wA.value)),SA.append("text").attr("fill","black").attr("x","5px").attr("y",QA.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").attr("opacity",0).text(wA=>wA.name).transition().duration(750).attr("opacity",1);let ft=Ct.merge(SA);ft.transition().duration(750).attr("transform",(wA,_t)=>`translate(2,${QA(_t)+2})`),ft.select("rect").attr("width",wA=>mt(wA.value)).attr("fill",wA=>{let _t=T[wA.name]||[0,0,0],qA=W.length===0||W.includes(wA.name)?1:.1;return`rgba(${_t[0]}, ${_t[1]}, ${_t[2]}, ${qA})`}),ft.select("text").text(wA=>wA.name),Ct.exit().transition().duration(750).attr("opacity",0).remove(),jA&&jA.scrollTo({top:0,behavior:"smooth"})};e.obs_store.new_cell_bar_data.subscribe(x({svg:e.cats.svg_bar_cluster,color_dict:e.cats.color_dict_cluster,selected_array:e.cats.selected_cats,bar_callback:Nf,container:e.containers.bar_cluster}),{immediate:!1}),e.obs_store.new_gene_bar_data.subscribe(x({svg:e.genes.svg_bar_gene,color_dict:e.genes.color_dict_gene,selected_array:e.genes.selected_genes,bar_callback:Kf,container:e.containers.bar_gene}),{immediate:!1}),l.appendChild(c),l.appendChild(e.containers.bar_cluster),kl("trx",A,j,e),h.appendChild(E),E.appendChild(e.sliders.trx),B.appendChild(h),B.appendChild(e.containers.bar_gene),rg("ist",A,j,e),e.genes.gene_search.style.marginLeft="0px",e.obs_store.selected_genes.subscribe(async z=>{if(z.length===1){let T=z[0];if(e.genes.gene_search_input.value=T,T!==""){if(e.genes.gene_names.includes(T)){e.genes.gene_text_box.textContent="loading",await nu(T);let W=A7[T];W&&W.name&&W.description?e.genes.gene_text_box.innerHTML=`${W.name}
${W.description}`:e.genes.gene_text_box.textContent=""}}else e.genes.gene_text_box.textContent="";e.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else z.length===0&&(e.genes.gene_search_input.value="",e.genes.gene_text_box.textContent="")}),r.appendChild(n),v||n.appendChild(e.containers.image),n.appendChild(l),n.appendChild(B),e.genes.gene_search.style.width="160px",e.genes.gene_search.style.marginLeft="5px";let S=(z,T)=>(T>=0&&T{G.edit.feature_collection=S(G.edit.feature_collection,G.edit.modify_index),G.edit.modify_index=null,W.edit_layer=W.edit_layer.clone({id:"edit-layer-delete",data:G.edit.feature_collection,mode:Xr,selectedFeatureIndexes:[]});let jA=Wr(W,G.close_up);T.setProps({layers:jA}),VA(G.edit.buttons.del).classed("active",!1).style("display","none"),VA(G.edit.buttons.nbhd).style("display","inline-flex"),VA(G.edit.buttons.sktch).style("display","inline-flex"),zf(G,T,W),Xf(G)};if(e.nbhd.is_nbhd){e.edit=e.edit||{},e.edit.buttons={},e.edit.mode="view";let z=(W,G,jA,pA)=>{let dA=pA.obs_store.viz_edit_layer.get();pA.obs_store.viz_edit_layer.set(!dA)},T=(W,G,jA,pA)=>{let dA=VA(W.currentTarget);dA.classed("active")===!1?(dA.classed("active",!0).style("color","blue"),pA.edit.mode="sktch",Uf(jA,Ai),tu(jA,!1),Jc(jA,!1),Zc(jA,!1)):(pA.edit.mode="view",dA.classed("active",!1).style("color","gray"),Uf(jA,Xr),tu(jA,!0),Jc(jA,!0),Zc(jA,!0));let _A=Wr(jA,pA.close_up);G.setProps({layers:_A})};e.nbhd.edit&&E_(A,j,e,k,"NBHD",40,z),E_(A,j,e,k,"SKTCH",40,T),VA(e.edit.buttons.sktch).style("display","none"),E_(A,j,e,k,"DEL",30,F),VA(e.edit.buttons.del).style("color","red").style("display","none"),e.edit.buttons.nbhd&&(e.buttons.buttons.nbhd=e.edit.buttons.nbhd)}e.nbhd.is_nbhd&&(e.containers.bar_nbhd=ju(),e.containers.bar_nbhd.style.marginLeft="0px",d.appendChild(k),d.appendChild(e.containers.bar_nbhd),n.appendChild(d),e.nbhd.is_nbhd&&(Za(e.containers.bar_nbhd,h_,e.nbhd.svg_bar_nbhd,e.nbhd.bar_data,e.nbhd.color_dict,A,j,e),e.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2))),n.appendChild(e.genes.gene_search);let D=document.createElement("div");D.className="logo_button",D.style.marginTop="5px",D.style.marginRight="5px",D.style.cursor="pointer";let L=document.createElement("img");return L.src=`data:image/png;base64,${x_}`,L.alt="Celldega logo",L.style.height="17px",L.style.transition="transform 0.2s ease, filter 0.2s ease",D.onclick=()=>{window.open("https://broadinstitute.github.io/celldega/","_blank")},D.appendChild(L),r.appendChild(D),r};var q_={Xenium:.2125,MERSCOPE:.108},G_=(t,A)=>{let j=A||"",e=["Visium-HD"],r=["Xenium","MERSCOPE"],n=e.includes(j)?"black":(r.includes(j),"white"),i=n==="white"?"black":"white",o=document.createElement("div");o.style.position="absolute",o.style.bottom="10px",o.style.left="10px",o.style.backgroundColor="transparent",o.style.color=n,o.style.padding="6px 8px",o.style.fontSize="12px",o.style.lineHeight="1.2",o.style.display="flex",o.style.flexDirection="column",o.style.alignItems="flex-start",o.style.pointerEvents="none",o.style.zIndex="10",o.style.opacity="0.5";let l=document.createElement("div");l.textContent="1 \xB5m";let c=document.createElement("div");c.style.height="2px",c.style.backgroundColor=n,c.style.outline=`1px solid ${i}`,c.style.marginTop="4px",c.style.width="80px",n==="white"&&(o.style.textShadow="0 0 3px black"),o.appendChild(l),o.appendChild(c);let B=k=>{if(k>=1e3){let g=k/1e3;if(g>=10)return`${Math.round(g)} mm`;if(g>=1)return`${Number(g.toFixed(1))} mm`}return k>=100?`${Math.round(k)} \xB5m`:k>=10?`${Number(k.toFixed(1))} \xB5m`:`${Number(k.toPrecision(2))} \xB5m`};return{container:o,update:({zoom:k})=>{let g=Math.pow(2,k||0),E=t/g,y=E*100,b=Math.min(y,1e3),v=Math.pow(10,Math.floor(Math.log10(b))),_=b/v,w=1;_>5?w=10:_>2?w=5:_>1&&(w=2);let x=w*v,S=x/E;l.textContent=B(x),c.style.width=`${S}px`},setVisible:k=>{o.style.display=k?"flex":"none"}}};var Hz=(t,A,j)=>{let e=j.model.get("cell_clusters");Ez(j.cats,e.meta_cluster),DX(j.cats,e.new_clusters),j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1}),j.layers_obj=A,j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0}),j.combo_data.cell=j.combo_data.cell.map(r=>({...r,cat:j.cats.dict_cell_cats[r.name]}))};var Kz=(t,A)=>{if(!A.cell_name_prefix||typeof t!="string")return t;let j=t.indexOf("_");return j>=0?t.substring(j+1):t},Dz=(t,A)=>A.cell_name_prefix?t.map(j=>Kz(j,A)):t,Nz=(t,A)=>{t.highlighted_cells=new Set,t.obs_store.selected_cells.set([]),gt(t.cats,"cluster"),Rt(t.cats,[],t.obs_store),Qt(t.genes,[],t.obs_store),t.obs_store.viz_nbhd_layer.set(!1),t.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(t,A,"cell_layer")},iu=t=>t?t.row_entity==="cell_cluster"?!0:t.entity==="cell"?["leiden","cluster","cell_type","cell_cluster"].includes(t.attr):!1:!1,ou=t=>t?t.col_entity==="nbhd"?!0:t.entity==="nbhd"||t.entity==="hextile":!1,DI=t=>t?t.entity==="gene":!1,NI=t=>t?t.entity==="cell"&&t.attr==="name":!1,Xz=async(t,A,j)=>{let e=j.model.get("update_trigger");if(!e||typeof e!="object")return;let r={type:e.type||e.click_type,value:e.value||e.click_value},n=r.type?.replace("-","_");if(!n)return;let i,o;try{if(n==="row_label")if(ou(r.value)){let l=r.value.name,c=j.obs_store.selected_nbhds.get();c.length===1&&c[0]===l?(j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1)):(j.obs_store.selected_nbhds.set([l]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",h=>h.name===l?1:.2),j.nbhd?.svg_bar_nbhd?.selectAll("rect").filter(h=>h.name===l).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else iu(r.value)?(i="cluster",o=r.value.name,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[o],j.obs_store),Qt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")):(i=r.value.name,o=i===j.cats.cat?"cluster":i,j.highlighted_cells=new Set,gt(j.cats,o),Qt(j.genes,[i],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,i,j.seg.version,j.vector_name_integer,j.aws,j.row_group_readers?.cbg),j.obs_store.selected_cells.set([]),Rt(j.cats,o==="cluster"?[]:[i],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"));else if(n==="col_label")if(ou(r.value)){let l=r.value.name,c=j.obs_store.selected_nbhds.get();c.length===1&&c[0]===l?(j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1)):(j.obs_store.selected_nbhds.set([l]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",h=>h.name===l?1:.2),j.nbhd?.svg_bar_nbhd?.selectAll("rect").filter(h=>h.name===l).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(NI(r.value)){let l=Kz(r.value.name,j);j.obs_store.selected_cells.set([l]),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else i="cluster",o=r.value.name,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[o],j.obs_store),Qt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"nbhd_layer"),TA(j,A,"trx_layer");else if(n==="col_dendro"){let l=r.value.selected_names||[];if(r.value.is_unselecting||l.length===0){j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1),Nz(j,A),TA(j,A,"nbhd_layer");return}let B=r.value.col_entity_full||r.value;if(ou(B))if(j.obs_store.selected_nbhds.set(l),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),j.obs_store.selected_nbhds.get().length>0){let h=j.obs_store.selected_nbhds.get();j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",d=>h.includes(d.name)?1:.2),j.nbhd.svg_bar_nbhd.selectAll("rect").filter(d=>h.includes(d.name)).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})}else j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1);else if(NI(B)){let h=Dz(l,j);j.obs_store.selected_cells.set(h),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,l,j.obs_store),Qt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else if(n==="row_dendro"){let l=r.value.selected_names||[];if(r.value.is_unselecting||l.length===0){j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1),Nz(j,A),TA(j,A,"trx_layer"),TA(j,A,"nbhd_layer");return}let B=r.value.row_entity_full||r.value;ou(B)?(j.obs_store.selected_nbhds.set(l),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),j.nbhd?.svg_bar_nbhd&&j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",h=>l.includes(h.name)?1:.2)):iu(B)?(j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,l,j.obs_store),Qt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"),TA(j,A,"nbhd_layer")):DI(B)&&(Qt(j.genes,l,j.obs_store),Yc(j,j.genes.selected_genes),l.length===1?(i=l[0],o=i===j.cats.cat?"cluster":i,j.highlighted_cells=new Set,gt(j.cats,o),await qr(j.cats,j.genes,j.global_base_url,i,j.seg.version,j.vector_name_integer,j.aws),j.obs_store.selected_cells.set([]),Rt(j.cats,o==="cluster"?[]:[i],j.obs_store)):(j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[],j.obs_store)),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"))}else if(n==="cat_value"){let{axis:l,attr_name:c,value:B,node_names:h}=r.value,{col_entity_full:d}=r.value;if(l==="col"&&NI(d)){let k=Dz(h||[],j);j.obs_store.selected_cells.set(k),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else l==="col"&&(j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[B],j.obs_store),Qt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"))}else if(n==="mat_value"){let{row:l,col:c,row_entity_full:B,col_entity_full:h}=r.value,d=B||l,k=h||c,g=(E,m)=>E?.entity===m?.entity&&E?.attr===m?.attr;if(iu(d)&&ou(k)){let E=[c.name];if(j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),gt(j.cats,"cluster"),Rt(j.cats,[l.name],j.obs_store),TA(j,A,"cell_layer"),j.obs_store.selected_nbhds.get().length>0){let m=j.obs_store.selected_nbhds.get();j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",y=>m.includes(y.name)?1:.2)}}else if(g(d,k)&&iu(d)){j.obs_store.selected_cells.set([]),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),gt(j.cats,"cluster");let E=[l.name,c.name];Rt(j.cats,E,j.obs_store),Qt(j.genes,[],j.obs_store),TA(j,A,"cell_layer")}else if(DI(d)&&iu(k)){let E=l.name,m=c.name;j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,E),Qt(j.genes,[E],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,E,j.seg.version,j.vector_name_integer,j.aws),Rt(j.cats,[m],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(iu(d)&&DI(k)){let E=l.name,m=c.name;j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,m),Qt(j.genes,[m],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,m,j.seg.version,j.vector_name_integer,j.aws),Rt(j.cats,[E],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(ou(d)&&iu(k)){let E=[l.name];if(j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),gt(j.cats,"cluster"),Rt(j.cats,[c.name],j.obs_store),TA(j,A,"cell_layer"),j.obs_store.selected_nbhds.get().length>0){let m=j.obs_store.selected_nbhds.get();j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",y=>m.includes(y.name)?1:.2)}}else if(g(d,k)&&ou(d)){let E=[l.name,c.name];j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),j.nbhd?.svg_bar_nbhd&&j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",m=>E.includes(m.name)?1:.2)}}}catch(l){Zj(l,{context:"updating IST landscape from CGM",logUnexpected:!0,throwOnAuth:!1})}};async function spA(t,A){let j=t.img.landscape_parameters;if(!j.use_row_groups){t.use_row_groups=!1;return}let e=j.row_group_files||{},r=j.tile_grid||{};if(!r.num_tiles_x||!r.num_tiles_y){t.use_row_groups=!1;return}if(t.use_row_groups=!0,t.row_group_readers={},t.tile_grid=r,e.transcripts&&(t.row_group_readers.trx=new ml(A,r,e.transcripts),await t.row_group_readers.trx.initialize()),e.cell_segmentation&&(t.row_group_readers.cell=new ml(A,r,e.cell_segmentation),await t.row_group_readers.cell.initialize()),e.cbg&&(t.row_group_readers.cbg=new Ah(A,e.cbg),await t.row_group_readers.cbg.initialize()),e.images){t.row_group_readers.images={};for(let[n,i]of Object.entries(e.images))t.row_group_readers.images[n]=new th(A,i),await t.row_group_readers.images[n].initialize()}}var KI=async(t,A,j,e,r,n,i,o,l="",c=.25,B=0,h=800,d={},k=[],g={},E=[],m={},y={},b=!1,v="spatial",_="default",w={},x=null,S=0,F=0,D=0,L=50,z=null,T=[],W=!1)=>{B===0&&(B="100%");let G={};G.obs_store=Zf(),G.highlighted_cells=new Set,G.selection_token=0;let jA=typeof A?.get=="function"?A.get("selected_cells")||[]:[];if(Array.isArray(jA)&&(G.highlighted_cells=new Set(jA),G.obs_store.selected_cells.set(jA)),G.max_tiles_to_view=L,G.update_viz_image_layers=G.obs_store.setup_image_visibility_manager(qz),G.seg={},G.seg.version=_,G.root=t,G.buttons={},G.buttons.blue="#8797ff",G.buttons.gray="gray",G.buttons.light_gray="#EEEEEE",G.buttons.buttons={},Es(G,o),G.base_urls=T,G.cell_name_prefix=W,G.close_up=!1,G.model=A,G.nbhd={},G.nbhd.visible=!1,G.nbhd.edit=b,G.spatial={},"accessKeyId"in w){G.aws=new Yo({accessKeyId:w.accessKeyId,secretAccessKey:w.secretAccessKey,sessionToken:w.sessionToken,region:"us-east-1",service:"s3"});let xA=await G.aws.fetch(`${o}/landscape_parameters.json`);if(!xA.ok)throw new Error(`Fetch failed: ${xA.statusText}`)}else G.aws=null;if(Object.keys(y).length===0)G.nbhd.is_nbhd=b,G.nbhd.ini_feature_collection={type:"FeatureCollection",features:[],inst_alpha:null},G.nbhd.feature_collection=G.nbhd.ini_feature_collection;else{G.nbhd.is_nbhd=!0,G.nbhd.ini_feature_collection=y;let xA=new Set(y.features.map(fA=>fA.properties.cat));G.nbhd.bar_data=Array.from(xA).map(fA=>{let RA=y.features.filter(Gt=>Gt.properties.cat===fA).reduce((Gt,EA)=>Gt+EA.properties.area,0);return{name:fA,value:RA}}).sort((fA,PA)=>PA.value-fA.value),G.nbhd.color_dict={},y.features.forEach(fA=>{let PA=jg(fA.properties.color);G.nbhd.color_dict[fA.properties.cat]=PA}),G.nbhd.feature_collection={type:"FeatureCollection",features:y.features}}G.containers={},G.containers.root_dim={},G.containers.root_dim.width=B,G.containers.root_dim.height=h,G.custom_callbacks={},G.custom_callbacks.view_change=x,G.cats={},G.cats.cat=null,G.cats.reset_cat=!1,G.cats.selected_cats=[],G.cats.cell_cats=[],G.cats.dict_cell_cats={},G.cats.color_dict_cluster={},G.cats.cluster_counts=[],G.cats.polygon_cell_names=[],Object.keys(d).length===0?G.cats.has_meta_cell=!1:G.cats.has_meta_cell=!0,G.cats.meta_cell=d,G.cats.meta_cell_attr=k,G.cats.meta_cell_id_set=new Set(Object.keys(d||{}).map(xA=>String(xA))),G.cats.inst_cell_attr=k[0]||"N.A.",Object.keys(g).length===0?G.cats.has_meta_cluster=!1:G.cats.has_meta_cluster=!0,G.cats.meta_cluster=g,G.cats.meta_cluster_attr=E,G.cats.inst_cluster_attr=E[0]||"N.A.",G.umap={},Object.keys(m).length===0?G.umap.has_umap=!1:G.umap.has_umap=!0,G.umap.umap=m;let pA=v==="umap";G.obs_store.umap_state.set(pA),G.obs_store.landscape_view.set(v),G.genes={},G.genes.color_dict_gene={},G.genes.gene_names=[],G.genes.meta_gene={},G.genes.gene_counts=[],G.genes.selected_genes=[],G.genes.trx_ini_radius=c,G.genes.trx_names_array=[],G.genes.trx_data=[],G.genes.gene_text_box="",G.genes.trx_slider=document.createElement("input"),G.genes.gene_search=document.createElement("div"),G.cats.cell_exp_array=[],G.cats.cell_names_array=[],G.cats.cell_name_to_index_map=new Map,G.img={},G.img.image_layer_colors={},G.img.image_layer_sliders={},Z7(j),await xs(G.img,o,G.aws);let dA=G.img.landscape_parameters.technology;(dA==="Chromium"||dA==="point-cloud")&&(G.obs_store.viz_image_layers.set(!1),G.obs_store.viz_background_layer.set(!1)),await spA(G,o);let $A=G.img.landscape_parameters.image_info,_A=$A[0].name;G.vector_name_integer=G.img.landscape_parameters.use_int_index,Qf(G.img,G.img.landscape_parameters.image_format),Wf(G.img,$A),Hf(G.img),Yf(G.img.image_layer_colors,G.img.image_info);let Y=document.createElement("div");Y.style.position="relative",Y.style.height=`${h}px`,Y.style.border="1px solid #d3d3d3";let QA=typeof z=="number"&&!Number.isNaN(z)&&z>0?z:null,Ct=q_[dA]??QA;Ct&&(G.scale_bar=G_(Ct,dA),Y.appendChild(G.scale_bar.container)),G.scale_bar&&G.obs_store.scale_bar_view_state.subscribe(xA=>{xA&&G.scale_bar?.update&&G.scale_bar.update(xA)},{immediate:!1}),dA==="Chromium"||dA==="point-cloud"?G.dimensions={width:1,height:1,tileSize:1}:await $s(G,o,_A);let SA=G.dimensions?.width?G.dimensions.width/2:0,ft=G.dimensions?.height?G.dimensions.height/2:0;G.rotation=eD(D,[SA,ft]),await gl(G.genes,o,G.seg.version,G.aws),await Jf(G),G.views=nf(dA);let wA=await e_(Y,B,h,dA);if(r_(wA,G.views),G.cache={},G.cache.cell=await Vf(),G.cache.trx=await Vf(),G.combo_data={},G.tooltip_cat_cell="",n_(wA,G),G.edit={},G.edit.svg_bar_rgn=Ur("svg"),G.edit.rgn_areas=[],G.edit.color_dict_rgn={},G.edit.rgn_opacity=.3,G.edit.visible=!1,G.edit.modify_index=null,G.model?.get?Object.keys(G.model.get("region")).length===0?G.edit.feature_collection={type:"FeatureCollection",features:[]}:G.edit.feature_collection=G.model.get("region"):G.edit.feature_collection={type:"FeatureCollection",features:[]},b&&Object.keys(y).length>0&&y.features?.length>0){G.edit.feature_collection={type:"FeatureCollection",features:y.features.map((fA,PA)=>({...fA,properties:{...fA.properties,color:fA.properties.color||"#808080",name:fA.properties.name||(PA+1).toString(),cat:fA.properties.cat||(PA+1).toString()}}))};let xA=new Set(G.edit.feature_collection.features.map(fA=>fA.properties.cat));G.nbhd.bar_data=Array.from(xA).map(fA=>{let RA=G.edit.feature_collection.features.filter(Gt=>Gt.properties.cat===fA).reduce((Gt,EA)=>Gt+(EA.properties.area||0),0);return{name:fA,value:RA}}).sort((fA,PA)=>PA.value-fA.value),G.nbhd.color_dict={},G.edit.feature_collection.features.forEach(fA=>{let{color:PA}=fA.properties;G.nbhd.color_dict[fA.properties.cat]=jg(PA)})}let _t=Rf(G),qA=await B_(G),Ht=await c_(o,G),bA=await Wv(G),l6=Zv(G),Tt=pz(G),me=oz(G,!0),FA={background_layer:_t,image_layers:qA,cell_layer:Ht,path_layer:bA,trx_layer:l6,nbhd_layer:me,edit_layer:Tt},yj=()=>{let xA=G.cats.selected_cats.join("-");FA.cell_layer=FA.cell_layer.clone({id:`cell-layer-${xA}-sel-${G.selection_token}`,updateTriggers:{...FA.cell_layer.props.updateTriggers,getPosition:[G.obs_store.umap_state.get()],getFillColor:[G.selection_token]}}),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1}),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!0})};G.layers_obj=FA,G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),nbhd_layer:!0,edit_layer:!0}),G.obs_store.selected_nbhds.subscribe(xA=>{let fA=xA.join("-");FA.nbhd_layer=FA.nbhd_layer.clone({id:`nbhd-layer-${fA}`})},{immediate:!1}),G.obs_store.viz_nbhd_layer.subscribe(xA=>{xA?(Au(G.layers_obj,!1),G.genes.svg_bar_gene.selectAll("rect").style("opacity",.2),G.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),G.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1),G.buttons.buttons.cell.style("color","gray"),G.buttons.buttons.trx.style("color","gray"),G.buttons.buttons.nbhd?.style("color","blue"),Rj(G.sliders.cell,!1),Rj(G.sliders.trx,!1),G.nbhd.is_nbhd&&Rj(G.sliders.nbhd,!0)):(Au(G.layers_obj,!0),G.genes.svg_bar_gene.selectAll("rect").style("opacity",1),G.cats.svg_bar_cluster.selectAll("rect").style("opacity",1),G.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2),G.buttons.buttons.cell.style("color","blue"),G.buttons.buttons.trx.style("color","blue"),G.buttons.buttons.nbhd?.style("color","gray"),Rj(G.sliders.cell,!0),Rj(G.sliders.trx,!0),G.nbhd.is_nbhd&&Rj(G.sliders.nbhd,!1)),xA&&G.obs_store.viz_edit_layer.set(!1)},{immediate:!1}),u_(wA,FA,G),Jv(wA,FA,G),A_(wA,FA,G),kz(wA,FA,G),gz(wA,FA,G),az(wA,FA,G),G.obs_store.deck_ready.subscribe(xA=>{if(xA){let fA=Wr(G.layers_obj,G.close_up);wA.setProps({layers:fA})}}),G.obs_store.viz_edit_layer.subscribe(xA=>{mz(FA,xA),xA?(G.obs_store.viz_nbhd_layer.set(!1),pl(FA,!1),Ts(FA,!1),G.buttons.buttons.trx.style("color","gray"),VA(G.edit.buttons.nbhd).style("color","blue"),VA(G.edit.buttons.sktch).style("display","inline-flex").style("color","gray").classed("active",!1),G.nbhd.edit&&G.containers.nbhd_opacity_slider&&(VA(G.containers.nbhd_opacity_slider).style("display","inline-flex"),Rj(G.sliders.nbhd_opacity,!0))):(Ts(FA,!0),G.buttons.buttons.trx.style("color","blue"),VA(G.edit.buttons.nbhd).style("color","gray").classed("active",!1),VA(G.edit.buttons.sktch).style("display","none").style("color","gray").classed("active",!1),Uf(FA,Xr),tu(FA,!0),Jc(FA,!0),Zc(FA,!0),G.nbhd.edit&&G.containers.nbhd_opacity_slider&&(VA(G.containers.nbhd_opacity_slider).style("display","none"),Rj(G.sliders.nbhd_opacity,!1))),TA(G,FA,"edit_layer")},{immediate:!1}),G.obs_store.selected_cats.subscribe(xA=>{let fA=xA.join("-");yj(),FA.path_layer=FA.path_layer.clone({id:`path-layer-${fA}`}),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),path_layer:!0})}),G.obs_store.selected_cells.subscribe(xA=>{G.highlighted_cells=new Set(xA??[]),G.selection_token+=1,yj()}),G.obs_store.selected_genes.subscribe(xA=>{let fA=xA.join("-");FA.trx_layer=FA.trx_layer.clone({id:`trx-layer-${fA}`}),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),trx_layer:!0})}),Tf(FA,c),G.obs_store.umap_state.get()===!0&&(G.obs_store.viz_background_layer.set(!1),G.obs_store.viz_image_layers.set(!1),Ts(FA,!1),Of(FA,!1)),ZX(wA,e,r,n,i,G,S,F),JX(wA,FA,G),G.model?.on&&(G.model.on("change:update_trigger",()=>Xz(wA,FA,G)),G.model.on("change:cell_clusters",()=>Hz(wA,FA,G)),G.model.on("change:selected_cells",()=>{let xA=G.model.get("selected_cells")||[];G.obs_store.selected_cells.set(xA)}));let cj=Cz(l,wA,FA,G);t.appendChild(cj),t.appendChild(Y),G.nbhd.edit&&(G.nbhd_editor=xz(G,wA,FA));let ce=["Chromium","point-cloud"].includes(G.img.landscape_parameters.technology);G.obs_store.landscape_view.subscribe(xA=>{let fA=xA==="umap";G.obs_store.umap_state.set(fA),G.scale_bar&&G.scale_bar.setVisible(!fA),jz(wA,FA,G),fA?(G.buttons.buttons.umap.style("color","blue"),ce||(G.buttons.buttons.spatial.style("color","gray"),G.buttons.buttons.img.style("color","gray")),G.obs_store.viz_background_layer.set(!1),G.obs_store.viz_image_layers.set(!1),Ts(FA,!1),Of(FA,!1),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),G.layers_obj=FA,G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,trx_layer:!0})):(ce||(G.buttons.buttons.umap.style("color","gray"),G.buttons.buttons.spatial.style("color","blue"),G.buttons.buttons.img.style("color","blue")),Ts(FA,!0),Of(FA,!0),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),G.layers_obj=FA,G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,trx_layer:!0}),setTimeout(()=>{G.obs_store.viz_background_layer.set(!0),G.obs_store.viz_image_layers.set(!0)},3e3))},{immediate:!1});let Uj={on_gene_select:[],on_cluster_select:[],on_clusters_select:[]};return{on_gene_select:xA=>{Uj.on_gene_select.push(xA)},on_cluster_select:xA=>{Uj.on_cluster_select.push(xA)},on_clusters_select:xA=>{Uj.on_clusters_select.push(xA)},update_matrix_gene:async xA=>{let PA=xA===G.cats.cat?"cluster":xA;gt(G.cats,PA),Qt(G.genes,[xA],G.obs_store),Rt(G.cats,PA==="cluster"?[]:[xA],G.obs_store),await qr(G.cats,G.genes,G.global_base_url,xA,G.seg.version,G.vector_name_integer,G.aws,G.row_group_readers?.cbg),G.layers_obj=FA,G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!0}),Uj.on_gene_select.forEach(RA=>RA(xA))},update_matrix_col:async xA=>{gt(G.cats,"cluster"),Rt(G.cats,[xA],G.obs_store),Qt(G.genes,[],G.obs_store),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),G.layers_obj=FA,Uj.on_cluster_select.forEach(fA=>fA(xA))},update_matrix_dendro_col:async xA=>{let fA=xA;gt(G.cats,"cluster"),Rt(G.cats,fA,G.obs_store),Qt(G.genes,[],G.obs_store),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),G.layers_obj=FA,Uj.on_clusters_select.forEach(PA=>PA(xA))},update_view_state:async(xA,fA,PA)=>{G.close_up=fA,j_(xA,wA,FA,G,G.obs_store),G.obs_store.deck_check.set({...G.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),wA.setProps({controller:{doubleClickZoom:!1},initialViewState:xA,views:G.views}),G.layers_obj=FA},update_layers:()=>{},finalize:()=>{wA.finalize()}}};var zz=async(t,A)=>{let j={},e=`${A}/df_colors.parquet`,r=await ae(e,Nt.fetch,t.aws),n=[],i=[],o=r.getChild("__index_level_0__"),l=r.getChild("color");return o&&l&&(n=o.toArray(),i=l.toArray()),n.forEach((c,B)=>{j[String(c)]=ei(i[B])}),j};var Uz=(t,A)=>{t.tile_names_array=A},Vz=t=>{t.tile_name_to_index_map=new Map,t.tile_names_array.forEach((A,j)=>{t.tile_name_to_index_map.set(A,j)})};var Qz=(t,A)=>{t.tile_scatter_data=A};var Wz=async(t,A,j)=>{let e=j.model.get("update_trigger");if(!e||typeof e!="object")return;let r={type:e.type||e.click_type,value:e.value||e.click_value},n=r.type?.replace("-","_");if(!n)return;let i;n==="row_label"?(i=r.value.name||r.value,gt(j.cats,i),await $_(j,i),Qt(j.genes,[i],j.obs_store),j.genes&&j.genes.gene_search_input&&(j.genes.gene_search_input.value=i)):n==="col_label"?(gt(j.cats,"cluster"),Rt(j.cats,[r.value.name||r.value],j.obs_store),Qt(j.genes,[],j.obs_store)):n==="col_dendro"?(gt(j.cats,"cluster"),Rt(j.cats,r.value.selected_names||r.value,j.obs_store),Qt(j.genes,[],j.obs_store)):(gt(j.cats,"cluster"),Qt(j.genes,[],j.obs_store)),tg(j,A),t.setProps({layers:[A.simple_image_layer,A.square_scatter_layer]})};var XI=async(t,A,j,e,r,n,i,o,l=1.4,c="",B=0,h=800,d={})=>{B===0&&(B="100%");let k=document.createElement("div");k.style.height=`${h}px`,k.style.width=typeof B=="number"?`${B}px`:B;let g={};if(g.obs_store=Zf(),Z7(e),Es(g,j),g.model=t,g.img={},g.img.image_layer_colors={},g.img.image_layer_sliders={},await xs(g.img,j),"accessKeyId"in d){g.aws=new Yo({accessKeyId:d.accessKeyId,secretAccessKey:d.secretAccessKey,sessionToken:d.sessionToken,region:"us-east-1",service:"s3"});let jA=await g.aws.fetch(`${j}/landscape_parameters.json`);if(!jA.ok)throw new Error(`Fetch failed: ${jA.statusText}`)}else g.aws=null;await $s(g,j,"cells");let E=(jA,pA)=>{if(typeof jA=="string"&&jA.includes("%")){let dA=parseFloat(jA)/100;return pA*dA}return parseFloat(jA)||pA},m=g.dimensions.width,y=g.dimensions.height,b=E(B,A.clientWidth||m),v=E(h,A.clientHeight||y),_=Math.min(b/m,v/y),w=Math.log2(_);r===0&&n===0&&o===0&&(r=m/2,n=y/2,o=w),g.buttons={},g.buttons.blue="#8797ff",g.buttons.gray="gray",g.buttons.light_gray="#EEEEEE",g.buttons.buttons={},g.genes={},g.genes.color_dict_gene={},g.genes.gene_names=[],g.genes.meta_gene={},g.genes.gene_counts=[],g.genes.selected_genes=[],g.genes.trx_ini_radius=1,g.genes.trx_names_array=[],g.genes.trx_data=[],g.genes.gene_text_box="",g.genes.trx_slider=document.createElement("input"),g.genes.gene_search=document.createElement("div"),g.genes.svg_bar_gene=Ur("svg"),g.cats={},g.cats.cat="cluster",g.cats.reset_cat=!1,g.cats.selected_cats=[],g.cats.cell_cats=[],g.cats.dict_cell_cats={},g.cats.color_dict_cluster={},g.cats.cluster_counts=[],g.cats.polygon_cell_names=[],g.cats.svg_bar_cluster=Ur("svg"),g.tooltip_cat_tile="",g.cats.square_tile_size=l,await gl(g.genes,j,"default",g.aws);let x={name:"cells",color:[0,0,255]},S=`${j}/tile_geometries.parquet`,F=await ae(S,Nt.fetch,g.aws);g.cats.tile_cats_array=F.getChild("cluster").toArray(),g.cats.tile_exp_array=[],g.cats.tile_names_array=[],g.cats.tile_scatter_data=[],Qz(g.cats,dl(F)),Uz(g.cats,F.getChild("name").toArray()),Vz(g.cats),g.cats.tile_color_dict=await zz(g,j);let D=await of(g,x),L=lz(g.cats),z={simple_image_layer:D,square_scatter_layer:L};g.views=nf();let T=Jx(k,B,h),W={target:[r,n,i],zoom:o};T.setProps({views:g.views,layers:[z.simple_image_layer,z.square_scatter_layer],getTooltip:jA=>QX(jA,g),initialViewState:W}),g.model?.on&&g.model.on("change:update_trigger",()=>Wz(T,z,g)),Bz(T,z,g);let G=Lz(T,z,g);return A.appendChild(G),A.appendChild(k),()=>T.finalize()};var Yz=`#version 300 es +`,_dA=()=>{if(mz||typeof document>"u")return;let t=document.createElement("style");t.textContent=vdA,document.head.appendChild(t),mz=!0},$z=t=>{t.style.getPropertyValue("--track")||t.style.setProperty("--track","#e5e5e5"),t.style.getPropertyValue("--thumb-border")||t.style.setProperty("--thumb-border","#9aa0a6"),t.style.getPropertyValue("--c")||t.style.setProperty("--c","#1e90ff")},Ez=t=>{let A=Number(t.min??0),j=Number(t.max??100),e=Number(t.value??A),r=Number.isFinite(A)?A:0,n=Number.isFinite(j)?j:100,i=Number.isFinite(e)?e:r,o=n-r,l=o===0?0:(i-r)*100/o;t.style.setProperty("--val",`${ydA(l)}%`)},RI=t=>{if(!t||t.length<3)return;let[A,j,e]=t.slice(0,3).map(r=>{let n=Number(r);return Number.isNaN(n)?"00":xdA(n).toString(16).padStart(2,"0")});return`#${A}${j}${e}`},qdA=t=>{if(!t)return;if(Array.isArray(t))return RI(t);if(typeof ArrayBuffer<"u"&&ArrayBuffer.isView(t))return RI(Array.from(t));let A=String(t).trim();if(A.startsWith("#"))return A;let j=A.match(/\d+(?:\.\d+)?/g);return RI(j)},bdA=(t,A)=>{let j=qdA(A);$z(t),j&&(t.style.setProperty("--c",j),t.style.setProperty("accent-color",j))},GdA=()=>document.createElement("input"),Hf=t=>{t.image_layer_sliders=t.image_info.map(A=>{let j=document.createElement("input");return j.name=A.button_name,bdA(j,A.color),j})},wdA=async(t,A,j)=>{kz(j,A.sliders.tile.value/100),t.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},FdA=async(t,A,j)=>{oz(A,j.sliders.cell.value/5,j),TA(j,A,"cell_layer")},PdA=async(t,A,j)=>{Tf(A,j.sliders.trx.value/100),TA(j,A,"trx_layer")},IdA=async(t,A,j)=>{let e=j.sliders.nbhd.value/100;fz(A,e),TA(j,A,"nbhd_layer")},g_=(t,A,j,e)=>async()=>{let n=e.img.image_layer_sliders.filter(i=>i.name===t)[0].value/10;cz(e,j,t,n,e.img.image_layer_colors),TA(e,j,"image_layers")},Df=(t,A,j)=>{_dA(),t.type="range",t.min="0",t.max="100",t.value=A,t.classList.add("slider"),t.style.width="75px",$z(t),Ez(t);let e=r=>{Ez(t),typeof j=="function"&&j(r)};t.addEventListener("input",e)},kl=(t,A,j,e)=>{let r,n,i=GdA();switch(t){case"tile":r=100,n=()=>wdA(A,e,j);break;case"cell":r=e.genes.trx_ini_raidus*100,n=()=>FdA(A,j,e);break;case"trx":r=e.genes.trx_ini_raidus*100,n=()=>PdA(A,j,e);break;case"nbhd":r=j.nbhd_layer.props.opacity*100,n=()=>IdA(A,j,e);break;default:}Df(i,r,n),e.sliders[t]=i},Rj=(t,A)=>{t&&(t.disabled=!A)};var ju=()=>document.createElement("div"),Nf=(t,A,j,e,r)=>{if(r.buttons?.buttons?.cell?.style?.("color","blue"),Rj(r.sliders.cell,!0),r.cats.svg_bar_cluster.selectAll("rect").style("opacity",1),Au(e,!0),r.nbhd.is_nbhd){r.obs_store.viz_nbhd_layer.set(!1),r.obs_store.viz_edit_layer.set(!1);try{r.buttons?.buttons?.nbhd?.style?.("color","gray"),Rj(r.sliders.nbhd,!1)}catch{}}r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),gt(r.cats,"cluster"),Rt(r.cats,[A.name],r.obs_store),Wt(r.genes,[],r.obs_store),r.cats.reset_cat?r.genes.svg_bar_gene.selectAll("rect").style("opacity",1):r.genes.svg_bar_gene.selectAll("rect").style("opacity",.2)},Kf=async(t,A,j,e,r)=>{if(r.buttons?.buttons?.trx?.style?.("color","blue"),Rj(r.sliders.trx,!0),r.genes.svg_bar_gene.selectAll("rect").style("opacity",1),Ts(e,!0),r.nbhd.is_nbhd){r.obs_store.viz_nbhd_layer.set(!1),r.obs_store.viz_edit_layer.set(!1);try{r.buttons?.buttons?.nbhd?.style?.("color","gray"),Rj(r.sliders.nbhd,!1)}catch{}}let n=A.name,i=n===r.cats.cat,o=i?"cluster":n;i?r.cats.svg_bar_cluster.selectAll("rect").style("opacity",1):r.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),gt(r.cats,o),r.obs_store.deck_check.set({...r.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Wt(r.genes,[n],r.obs_store),await qr(r.cats,r.genes,r.global_base_url,n,r.seg.version,r.vector_name_integer,r.aws,r.row_group_readers?.cbg),Rt(r.cats,[n],r.obs_store)},m_=(t,A,j,e,r)=>{if(r.nbhd.edit){if(r.obs_store.viz_edit_layer.set(!0),r.buttons?.buttons?.nbhd){let i=r.buttons.buttons.nbhd;typeof i.style=="function"?i.style("color","blue"):VA(i).style("color","blue")}Rj(r.sliders.nbhd,!0);let n=r.obs_store.selected_nbhds.get();if(n[0]===A.name&&n.length===1)r.obs_store.selected_nbhds.set([]),e.edit_layer=e.edit_layer.clone({selectedFeatureIndexes:[]});else{r.obs_store.selected_nbhds.set([A.name]);let o=(r.edit?.feature_collection?.features||[]).findIndex(l=>l.properties.name===A.name||l.properties.cat===A.name);o>=0&&(e.edit_layer=e.edit_layer.clone({selectedFeatureIndexes:[o]}))}TA(r,e,"edit_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",i=>i.name===A.name?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)}else{if(r.obs_store.viz_nbhd_layer.set(!0),r.obs_store.viz_edit_layer.set(!1),r.buttons?.buttons?.nbhd){let i=r.buttons.buttons.nbhd;typeof i.style=="function"?i.style("color","blue"):VA(i).style("color","blue")}let n=r.obs_store.selected_nbhds.get();n[0]===A.name&&n.length===1?r.obs_store.selected_nbhds.set([]):r.obs_store.selected_nbhds.set([A.name]),TA(r,e,"nbhd_layer"),r.obs_store.selected_nbhds.get().length>0?r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",i=>i.name===A.name?1:.2):r.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1)}},Za=(t,A,j,e,r,n,i,o)=>{t.className="bar_container",t.style.width="107px",t.style.height="72px",t.style.marginLeft="5px",t.style.overflowY="auto",t.style.border="1px solid #d3d3d3",t.addEventListener("wheel",E=>{let{scrollTop:m,scrollHeight:y,clientHeight:G}=t,v=m===0,_=m+G===y;(v&&E.deltaY<0||_&&E.deltaY>0)&&E.preventDefault()});let l=15,c=l*(e.length+1);j.attr("width",100).attr("height",c).attr("font-family","sans-serif").attr("font-size","13").attr("text-anchor","end").style("user-select","none"),t.appendChild(j.node());let B=90,h=e.map(E=>E.value),d=ti().domain(F6(h.length)).range([0,(l+1)*h.length]),k=ji().domain([0,xj(h)]).range([0,B]),g=j.selectAll("g").data(e).join("g").attr("transform",(E,m)=>`translate(2,${d(m)+2})`).on("click",(E,m)=>A(E,m,n,i,o));g.append("rect").attr("fill",E=>{let m=r[E.name];return`rgb(${m[0]}, ${m[1]}, ${m[2]})`}).attr("width",E=>k(E.value)).attr("height",d.bandwidth()-1),g.append("text").attr("fill","black").attr("x","5px").attr("y",d.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").text(E=>E.name)};var Wr=(t,A,j)=>{let e;return A?e=[t.background_layer,...t.image_layers,t.path_layer,t.cell_layer,t.trx_layer,t.nbhd_layer,t.edit_layer]:e=[t.background_layer,...t.image_layers,t.cell_layer,t.nbhd_layer,t.edit_layer],e};function Uf(t,A){t.edit_layer=t.edit_layer.clone({mode:A})}var MdA=t=>(t.features.forEach((A,j)=>{if(A.geometry.type==="Polygon"){let e=A.geometry.coordinates[0],r=Math.abs(qI(e)),n=A.properties.name,i=A.properties.cat;A.properties={...A.properties,area:r,name:n||(j+1).toString(),cat:i||(j+1).toString(),color:A.properties.color||Lf()}}else Uu(`Feature ${j} is not a Polygon.`,{logLevel:"warn",shouldLog:!0,data:{featureIndex:j,featureType:A.geometry?.type}})}),t),Xf=t=>{t.model?.set&&(t.nbhd?.edit?(t.model.set("nbhd_geojson",{}),t.model.set("nbhd_geojson",t.edit.feature_collection)):(t.model.set("region",{}),t.model.set("region",t.edit.feature_collection)),t.model.save_changes())},zf=async(t,A,j)=>{t.edit.feature_collection=MdA(t.edit.feature_collection),t.edit.rgn_areas=t.edit.feature_collection.features.map(e=>({name:e.properties.name||e.properties.cat,value:e.properties.area})).sort((e,r)=>r.value-e.value),t.edit.color_dict_rgn=t.edit.feature_collection.features.reduce((e,r)=>{let n=r.properties.name||r.properties.cat,{color:i}=r.properties;return typeof i=="string"&&i.startsWith("#")?e[n]=ei(i):Array.isArray(i)?e[n]=i:e[n]=[128,128,128],e},{}),t.nbhd?.edit&&(t.nbhd.bar_data=t.edit.rgn_areas,t.nbhd.color_dict=t.edit.color_dict_rgn,t.nbhd.feature_collection=t.edit.feature_collection,t.containers?.bar_nbhd&&(t.nbhd.svg_bar_nbhd.selectAll("*").remove(),Za(t.containers.bar_nbhd,m_,t.nbhd.svg_bar_nbhd,t.nbhd.bar_data,t.nbhd.color_dict,A,j,t),t.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2)))},OdA=async(t,A,j,e)=>{let{updatedData:r,editType:n,featureIndexes:i}=e;if(j.edit.feature_collection=r,A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),n==="addFeature"){Uf(A,Xr),VA(j.edit.buttons.sktch).style("color","gray").classed("active",!1),j.edit.mode="view",tu(A,!0),Jc(A,!0),Zc(A,!0);let l=i&&i.length>0?i[0]:j.edit.feature_collection.features.length-1,c=j.edit.feature_collection.features[l];if(c&&!c.properties.name&&(c.properties.name=`nbhd_${l+1}`,c.properties.cat=c.properties.name,c.properties.color=c.properties.color||Lf()),j.nbhd?.edit&&j.nbhd_editor){let B=j.root.getBoundingClientRect();j.nbhd_editor.open({feature_index:l,initial_name:c.properties.name,initial_color:c.properties.color,position:{x:B.width/2-120,y:B.height/2-90},on_apply:({feature_index:h,name:d,color:k})=>{let g=j.edit.feature_collection.features[h];g&&(g.properties.name=d,g.properties.cat=d,g.properties.color=k),A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),zf(j,t,A),Xf(j);let E=Wr(A,j.close_up);t.setProps({layers:E})}})}await zf(j,t,A),Xf(j)}let o=Wr(A,j.close_up);t.setProps({layers:o}),await zf(j,t,A),Xf(j)},TdA=async(t,A,j,e)=>{if(t.featureType==="polygons"&&e.edit.mode==="view"){j.edit_layer=j.edit_layer.clone({id:"edit-layer-modify",mode:Mo,selectedFeatureIndexes:[t.index],modeConfig:{dragToAddNew:!0,enableSnapping:!1}});let r=await Wr(j,e.close_up);A.setProps({layers:r}),e.edit.mode="modify",e.edit.modify_index=t.index,VA(e.edit.buttons.del).classed("active",!0).style("display","inline-flex"),VA(e.edit.buttons.nbhd).style("display","none"),VA(e.edit.buttons.sktch).style("display","none")}else if(t.featureType==="polygons"&&e.edit.mode==="modify"){j.edit_layer=j.edit_layer.clone({id:"edit-layer-view",mode:Xr,selectedFeatureIndexes:[]});let r=await Wr(j,e.close_up);A.setProps({layers:r}),e.edit.mode="view",e.edit.modify_index=null,VA(e.edit.buttons.del).classed("active",!1).style("display","none"),VA(e.edit.buttons.nbhd).style("display","inline-flex"),VA(e.edit.buttons.sktch).style("display","inline-flex")}},xz=t=>new Is({id:"edit-layer",data:t.edit.feature_collection,selectedFeatureIndexes:[],mode:Xr,filled:!0,pointRadiusMinPixels:2,pointRadiusScale:2e3,extruded:!0,getElevation:1e3,getFillColor:j=>{let{color:e}=j.properties;return typeof e=="string"&&e.startsWith("#")?ei(e):e||[128,128,128]},pickable:!0,autoHighlight:!0,modeConfig:{preventOverlappingLines:!0},visible:!1,opacity:t.edit.rgn_opacity,...Er(t.rotation)}),yz=(t,A,j)=>{A.edit_layer=A.edit_layer.clone({onEdit:e=>OdA(t,A,j,e)})},vz=(t,A,j)=>{let e=0,r=-1,n=300,i=async o=>{let l=Date.now(),c=l-e{let E=j.edit.feature_collection.features[d];E&&(E.properties.name=k,E.properties.cat=k,E.properties.color=g),A.edit_layer=A.edit_layer.clone({data:j.edit.feature_collection}),zf(j,t,A),Xf(j);let m=Wr(A,j.close_up);t.setProps({layers:m})}})}}else await TdA(o,t,A,j)};A.edit_layer=A.edit_layer.clone({onClick:i})};var _z=(t,A)=>{t.edit_layer=t.edit_layer.clone({visible:A})};var SdA=(t,A,j)=>{if(t.size>=20){let r=t.keys().next().value;t.delete(r)}t.set(A,j)},RdA=(t,A)=>{let j=t.get(A);return j&&(t.delete(A),t.set(A,j)),j},LdA=t=>{t.clear()},Vf=()=>{let t=new Map;return{set:(A,j)=>SdA(t,A,j),get:A=>RdA(t,A),clear:()=>LdA(t)}};var Qf=(t,A)=>{t.image_format=A},Wf=(t,A)=>{t.image_info=A},Yf=(t,A)=>{A.forEach(j=>{t[j.button_name]=j.color})};var qz=(t,A)=>{t.color_dict_cluster=A.color;for(let e in t.color_dict_cluster)t.color_dict_cluster[e]=ei(t.color_dict_cluster[e]);let j=A.count;t.cluster_counts=[];for(let e in j)t.cluster_counts.push({name:e,value:j[e]});t.cluster_counts.sort((e,r)=>r.value-e.value)},Jf=async t=>{if(t.cats.has_meta_cluster){let A=t.cats.meta_cluster_attr.indexOf("color");for(let e in t.cats.meta_cluster)t.cats.color_dict_cluster[e]=ei(t.cats.meta_cluster[e][A]||"#000000");let j=t.cats.meta_cluster_attr.indexOf("count");for(let e in t.cats.meta_cluster){let r=t.cats.meta_cluster[e][j],n=r!==void 0?Number(r):0;t.cats.cluster_counts.push({name:e,value:n})}}else{let A;t.seg.version==="default"?A=`${t.global_base_url}/cell_clusters/meta_cluster.parquet`:A=`${t.global_base_url}/cell_clusters_${t.seg.version}/meta_cluster.parquet`;let j=await ae(A,Nt.fetch,t.aws),e=[],r=[],n=[],i=j.getChild("__index_level_0__"),o=j.getChild("color"),l=j.getChild("count"),c=[];for(let B of j.schema.fields)c.push(B.name);i&&o&&(e=i.toArray(),r=o.toArray(),n=l.toArray()),e.forEach((B,h)=>{t.cats.color_dict_cluster[B]=ei(r[h]),t.cats.cluster_counts.push({name:B,value:Number(n[h])})})}t.cats.cluster_counts.sort((A,j)=>j.value-A.value)};var gl=async(t,A,j="default",e)=>{let r;j==="default"?r=`${A}/meta_gene.parquet`:r=`${A}/meta_gene_${j}.parquet`;let n=await ae(r,Nt.fetch,e),i=n.getChild("__index_level_0__").toArray(),o=n.getChild("mean").toArray(),l=n.getChild("std").toArray(),c=n.getChild("max").toArray();i.forEach((h,d)=>{t.meta_gene[h]={mean:o[d],std:l[d],max:c[d]},t.gene_counts.push({name:h,value:Number(o[d])})}),t.gene_counts.sort((h,d)=>d.value-h.value),t.top_gene_counts=t.gene_counts.slice(0,100);let B=i.reduce((h,d,k)=>(h[k]=d,h),{});t.g_nameMapping_inv=B,t.gene_names=i};var ng=(t,A=255)=>{let j=o6(t);return j?[j.r,j.g,j.b,A]:[0,0,0,A]};var Ue=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{A!==e&&(A=e,j.forEach(r=>r(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},Zf=()=>{let t={cat:Ue("cluster"),selected_cats:Ue([]),selected_cells:Ue([]),new_cell_bar_data:Ue([]),new_gene_bar_data:Ue([]),selected_genes:Ue([]),selected_nbhds:Ue([]),viz_image_layers:Ue(!0),viz_background_layer:Ue(!0),viz_nbhd_layer:Ue(!1),viz_edit_layer:Ue(!1),landscape_view:Ue("spatial"),umap_state:Ue(!1),scale_bar_view_state:Ue(null),close_up:Ue(!1),current_dataset_index:Ue(0),dataset_switching:Ue(!1),persistent_state:Ue({selected_cats:[],selected_genes:[],cat:"cluster",viz_image_layers:!0,landscape_view:"spatial"}),deck_check:Ue({background_layer:!0,image_layers:!0,cell_layer:!0,path_layer:!0,trx_layer:!0,nbhd_layer:!0,edit_layer:!0,trx_data:!0,path_data:!0,square_scatter_data:!0}),deck_ready:Ue(!1)};return t.deck_check.subscribe(A=>{let j=Object.values(A).every(e=>e===!0);t.deck_ready.set(j)},{immediate:!1}),t.setup_image_visibility_manager=A=>{let j=()=>{if(A&&!A())return;let e=t.selected_cats.get().length>0,r=t.selected_genes.get().length>0,n=t.close_up.get(),i=t.umap_state.get();e||r?t.viz_image_layers.set(n):i||t.viz_image_layers.set(!0)};return t.selected_cats.subscribe(j,{immediate:!1}),t.selected_genes.subscribe(j,{immediate:!1}),t.close_up.subscribe(j,{immediate:!1}),j},t};var Ah=class{constructor(A,j){if(this.baseUrl=A,this.initialized=!1,this.useStreaming=!0,typeof j=="string")this.chunkedMode=!1,this.url=`${A}/${j}`,this.parquetFile=null,this.geneToRowGroup=null;else if(typeof j=="object"&&j.files)this.chunkedMode=!0,this.directory=j.directory||"cbg",this.files=j.files,this.maxRowGroupsPerFile=j.max_row_groups_per_file||2e3,this.totalRowGroups=j.total_row_groups||0,this.geneToRowGroup=j.gene_to_row_group||{},this.geneList=Object.keys(this.geneToRowGroup);else throw new Error("[CBGRowGroupReader] Invalid cbgConfig: must be string URL or chunk config object")}async _checkRangeSupport(A){try{let j=new URL(A);if(j.hostname==="localhost"||j.hostname==="127.0.0.1")return!0;let e=await fetch(A,{method:"GET",headers:{Range:"bytes=0-7"}});if(!e.ok&&e.status!==206)return!1;let r=await fetch(A,{method:"GET",headers:{Range:"bytes=-8"}});return!r.ok&&r.status!==206?!1:e.status===206&&r.status===206||e.headers.get("Accept-Ranges")==="bytes"}catch{return!1}}computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _getParquetFile(A){let j=this.files[A];if(!j)throw new Error(`[CBGRowGroupReader] No file for index ${A}. Available: ${this.files.length} files`);let e=`${this.baseUrl}/${this.directory}/${j}`;return await(await lo()).ParquetFile.fromUrl(e)}async initialize(){if(this.initialized)return;let A=await lo();if(this.chunkedMode){let j=`${this.baseUrl}/${this.directory}/${this.files[0]}`;if(!await this._checkRangeSupport(j))throw new Error("[CBGRowGroupReader] Range requests not supported. Row group mode requires a server that supports HTTP Range requests with CORS.")}else{if(!await this._checkRangeSupport(this.url))throw new Error(`[CBGRowGroupReader] Range requests not supported for ${this.url}. Row group mode requires a server that supports HTTP Range requests with CORS.`);if(!A.ParquetFile||typeof A.ParquetFile.fromUrl!="function")throw new Error("[CBGRowGroupReader] ParquetFile.fromUrl not available. Please ensure parquet-wasm is properly initialized.");this.parquetFile=await A.ParquetFile.fromUrl(this.url),this.useStreaming=!0;let r=this.parquetFile.metadata().numRowGroups();this.numRowGroups=r,this.geneToRowGroup=null,this.geneList=null}this.initialized=!0}async _ensureGeneIndex(){if(this.geneToRowGroup===null){try{let j=(await this.parquetFile.read({rowGroups:[0]})).intoIPCStream(),r=wn(j).schema.metadata;if(r&&r.has("gene_to_row_group")){let n=r.get("gene_to_row_group");this.geneToRowGroup=JSON.parse(n),this.geneList=Object.keys(this.geneToRowGroup);return}}catch{}this.geneToRowGroup=await this._buildGeneIndex(this.numRowGroups),this.geneList=Object.keys(this.geneToRowGroup)}}async _buildGeneIndex(A){let j={};for(let e=0;e0){let l=o.get(0);j[l]=e}}catch{}return j}async hasGene(A){return await this._ensureGeneIndex(),A in this.geneToRowGroup}async getGeneRowGroupIndex(A){return await this._ensureGeneIndex(),this.geneToRowGroup[A]??null}async readGene(A){this.initialized||await this.initialize(),await this._ensureGeneIndex();let j=this.geneToRowGroup[A];if(j===void 0)return null;try{if(this.chunkedMode){let{fileIndex:e,localIndex:r}=this.computeChunkLocation(j),o=(await(await this._getParquetFile(e)).read({rowGroups:[r]})).intoIPCStream();return wn(o)}else{let r=(await this.parquetFile.read({rowGroups:[j]})).intoIPCStream();return wn(r)}}catch{return null}}async getNumGenes(){return await this._ensureGeneIndex(),this.geneList.length}async getGeneNames(){return await this._ensureGeneIndex(),[...this.geneList]}};var th=class{constructor(A,j,e=null){if(this.baseUrl=A,this.initialized=!1,this.useStreaming=!0,this.blobCache=new Map,typeof j=="string")this.chunkedMode=!1,this.url=`${A}/${j}`,this.parquetFile=null,this.zoomInfo=e||{};else if(typeof j=="object"&&j.files)this.chunkedMode=!0,this.directory=j.directory||"pyramid_images",this.files=j.files,this.maxRowGroupsPerFile=j.max_row_groups_per_file||2e3,this.totalRowGroups=j.total_row_groups||0,this.zoomInfo=j.zoom_info||e||{};else if(typeof j=="object"&&j.path)this.chunkedMode=!1,this.url=`${A}/${j.path}`,this.parquetFile=null,this.zoomInfo=j.zoom_info||e||{};else throw new Error("[ImageRowGroupReader] Invalid imageConfig: must be string path or object with files/path")}async _checkRangeSupport(A=null){let j=A||(this.chunkedMode?this._getFileUrl(0):this.url);try{let e=new URL(j);if(e.hostname==="localhost"||e.hostname==="127.0.0.1")return!0;let r=await fetch(j,{method:"GET",headers:{Range:"bytes=0-7"}});if(!r.ok&&r.status!==206)return console.log(`[ImageRowGroupReader] Range check failed with status ${r.status}`),!1;let n=await fetch(j,{method:"GET",headers:{Range:"bytes=-8"}});return!n.ok&&n.status!==206?(console.log(`[ImageRowGroupReader] Footer range check failed with status ${n.status}`),!1):r.status===206&&n.status===206||r.headers.get("Accept-Ranges")==="bytes"}catch(e){return console.log(`[ImageRowGroupReader] Range check failed: ${e.message}`),!1}}_getFileUrl(A){if(!this.chunkedMode)return this.url;let j=this.files[A];return`${this.baseUrl}/${this.directory}/${j}`}_computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _getParquetFile(A){let j=this._getFileUrl(A);return(await lo()).ParquetFile.fromUrl(j)}async initialize(){if(this.initialized)return;let A=await lo();if(!await this._checkRangeSupport()){let e=this.chunkedMode?this._getFileUrl(0):this.url;throw new Error(`[ImageRowGroupReader] Range requests not supported for ${e}. Row group mode requires a server that supports HTTP Range requests with CORS.`)}if(!A.ParquetFile||typeof A.ParquetFile.fromUrl!="function")throw new Error("[ImageRowGroupReader] ParquetFile.fromUrl not available. Please ensure parquet-wasm is properly initialized.");if(this.chunkedMode)console.log(`[ImageRowGroupReader] Chunked mode enabled: ${this.files.length} files, ${this.totalRowGroups} total tiles`);else{console.log("[ImageRowGroupReader] Range requests supported, creating streaming ParquetFile..."),this.parquetFile=await A.ParquetFile.fromUrl(this.url);let r=this.parquetFile.metadata().numRowGroups();console.log(`[ImageRowGroupReader] Streaming mode enabled, ${r} tiles available`)}console.log(`[ImageRowGroupReader] zoomInfo available: ${this.zoomInfo?Object.keys(this.zoomInfo).join(", "):"none"}`),this.initialized=!0}computeRowGroupIndex(A,j,e){let r=String(A),n=this.zoomInfo[r];if(!n)return console.warn(`[ImageRowGroupReader] No zoom data for level ${A}`),null;let{row_group_offset:i,num_tiles_x:o,num_tiles_y:l}=n;return j<0||j>=o||e<0||e>=l?null:i+j*l+e}async readTile(A,j,e,r="image/webp"){this.initialized||await this.initialize();let n=`${A}_${j}_${e}`;if(this.blobCache.has(n))return this.blobCache.get(n);let i=this.computeRowGroupIndex(A,j,e);if(i===null)return null;try{let o;if(this.chunkedMode){let{fileIndex:g,localIndex:E}=this._computeChunkLocation(i);if(g>=this.files.length)return console.warn(`[ImageRowGroupReader] File index ${g} out of range (${this.files.length} files)`),null;o=await(await this._getParquetFile(g)).read({rowGroups:[E]})}else o=await this.parquetFile.read({rowGroups:[i]});let l=o.intoIPCStream(),B=wn(l).getChild("image_data");if(!B||B.length===0)return null;let h=B.get(0);if(!h||h.length===0)return null;let d=new Blob([h],{type:r}),k=URL.createObjectURL(d);return this.blobCache.set(n,k),k}catch(o){return console.warn(`[ImageRowGroupReader] Error reading tile z${A} ${j}_${e}:`,o),null}}clearCache(){for(let A of this.blobCache.values())URL.revokeObjectURL(A);this.blobCache.clear()}getCacheSize(){return this.blobCache.size}isStreaming(){return this.useStreaming&&this.parquetFile!==null}};var ml=class{constructor(A,j,e){if(this.baseUrl=A,this.numTilesX=j?.num_tiles_x||0,this.numTilesY=j?.num_tiles_y||0,this.initialized=!1,typeof e=="string")this.chunkedMode=!1,this.url=`${A}/${e}`,this.parquetFile=null;else if(typeof e=="object"&&e.files)e.files.length===1?(this.chunkedMode=!1,this.url=`${A}/${e.directory}/${e.files[0]}`,this.parquetFile=null):(this.chunkedMode=!0,this.directory=e.directory,this.files=e.files,this.maxRowGroupsPerFile=e.max_row_groups_per_file||1e4,this.totalRowGroups=e.total_row_groups||0);else throw new Error("[RowGroupTileReader] Invalid fileConfig: must be string URL or chunk config object")}computeRowGroupIndex(A,j){return A*this.numTilesY+j}computeChunkLocation(A){let j=Math.floor(A/this.maxRowGroupsPerFile),e=A%this.maxRowGroupsPerFile;return{fileIndex:j,localIndex:e}}async _checkRangeSupport(A){try{let j=new URL(A);if(j.hostname==="localhost"||j.hostname==="127.0.0.1")return!0;let e=await fetch(A,{method:"GET",headers:{Range:"bytes=0-7"}});if(!e.ok&&e.status!==206)return!1;let r=await fetch(A,{method:"GET",headers:{Range:"bytes=-8"}});return!(!r.ok&&r.status!==206)}catch{return!1}}async _getParquetFile(A){let j=this.files[A];if(!j)throw new Error(`[RowGroupTileReader] No file for index ${A}. Available: ${this.files.length} files`);let e=`${this.baseUrl}/${this.directory}/${j}`;return await(await lo()).ParquetFile.fromUrl(e)}async initialize(){if(this.initialized)return;let A=await lo();if(this.chunkedMode){let j=`${this.baseUrl}/${this.directory}/${this.files[0]}`;if(!await this._checkRangeSupport(j))throw new Error("[RowGroupTileReader] Range requests not supported. Row group mode requires a server that supports HTTP Range requests with CORS.")}else{if(!await this._checkRangeSupport(this.url))throw new Error(`[RowGroupTileReader] Range requests not supported for ${this.url}. Row group mode requires a server that supports HTTP Range requests with CORS.`);this.parquetFile=await A.ParquetFile.fromUrl(this.url)}this.initialized=!0}isValidTile(A,j){return A>=0&&A=0&&jr-n);try{if(this.chunkedMode){let r=new Map;for(let i of e){let{fileIndex:o,localIndex:l}=this.computeChunkLocation(i);r.has(o)||r.set(o,[]),r.get(o).push(l)}let n=[];for(let[i,o]of r){let B=(await(await this._getParquetFile(i)).read({rowGroups:o})).intoIPCStream(),h=wn(B);n.push(h)}return n.length===0?null:n.length===1?n[0]:A_(n)}else{let n=(await this.parquetFile.read({rowGroups:e})).intoIPCStream();return wn(n)}}catch{return null}}isStreaming(){return this.initialized}};var jh=(t,A,j)=>Math.min(Math.max(t,A),j),eh=(t,A)=>{let j=document.createElement("label");return j.style.display="block",j.style.fontSize="12px",j.style.fontWeight="600",j.style.marginBottom="8px",j.style.color="#47515b",j.textContent=t,A.style.display="block",A.style.width="100%",A.style.marginTop="4px",A.style.padding="6px",A.style.border="1px solid #d3d3d3",A.style.borderRadius="4px",A.style.fontSize="12px",j.appendChild(A),j},E_=(t="#3b82f6")=>{let A=document.createElement("input");return A.type="color",A.value=t,A.style.padding="0",A.style.height="32px",A.style.cursor="pointer",A},$_=(t="")=>{let A=document.createElement("input");return A.type="text",A.placeholder=t,A},x_=()=>{let t=document.createElement("div");return t.style.position="absolute",t.style.width="240px",t.style.background="#ffffff",t.style.border="1px solid #d3d3d3",t.style.borderRadius="8px",t.style.padding="12px",t.style.boxShadow="0 4px 12px rgba(0, 0, 0, 0.15)",t.style.zIndex="20",t.style.display="none",t.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',t},y_=t=>{let A=document.createElement("div");A.style.display="flex",A.style.justifyContent="space-between",A.style.alignItems="center",A.style.marginBottom="8px";let j=document.createElement("span");j.style.fontSize="13px",j.style.fontWeight="700",j.style.color="#333333",j.textContent=t;let e=document.createElement("button");return e.type="button",e.textContent="\xD7",e.style.border="none",e.style.background="transparent",e.style.cursor="pointer",e.style.fontSize="16px",e.style.lineHeight="16px",e.style.padding="0",A.appendChild(j),A.appendChild(e),{header:A,close_button:e}},v_=()=>{let t=document.createElement("div");t.style.display="flex",t.style.gap="8px",t.style.marginTop="12px";let A=document.createElement("button");A.type="button",A.textContent="Apply",A.style.flex="1",A.style.background="#2f74ff",A.style.color="#ffffff",A.style.border="none",A.style.borderRadius="4px",A.style.padding="8px",A.style.cursor="pointer",A.style.fontWeight="600";let j=document.createElement("button");return j.type="button",j.textContent="Cancel",j.style.flex="1",j.style.background="#f5f5f5",j.style.color="#47515b",j.style.border="1px solid #d3d3d3",j.style.borderRadius="4px",j.style.padding="8px",j.style.cursor="pointer",t.appendChild(A),t.appendChild(j),{button_row:t,apply_button:A,cancel_button:j}};var bz=(t,A,j)=>{let e=A*Math.min(j,1-j),r=n=>{let i=(n+t*12)%12,o=j-e*Math.max(Math.min(i-3,9-i,1),-1);return Math.round(255*o).toString(16).padStart(2,"0")};return`#${r(0)}${r(8)}${r(4)}`};var CdA=t=>{let A=new Set;t.edit?.feature_collection?.features&&t.edit.feature_collection.features.forEach(j=>{j.properties?.color&&A.add(j.properties.color.toLowerCase())});for(let j=0;j<50;j++){let e=Lf();if(!A.has(e.toLowerCase()))return e}return Lf()},Gz=(t,A,j)=>{let e=x_(),{header:r,close_button:n}=y_("Neighborhood"),i=$_("Neighborhood name"),o=eh("Name",i),l=E_("#3b82f6"),c=eh("Color",l),{button_row:B,apply_button:h,cancel_button:d}=v_();e.appendChild(r),e.appendChild(o),e.appendChild(c),e.appendChild(B),t.root.appendChild(e);let k=null,g=null,E=v=>{let _=t.root.getBoundingClientRect(),w=e.offsetWidth||240,x=e.offsetHeight||180,O=jh(v?.x??_.width/2-w/2,8,_.width-w-8),F=jh(v?.y??_.height/2-x/2,8,_.height-x-8);e.style.left=`${O}px`,e.style.top=`${F}px`},m=()=>{e.style.display="none",k=null,g=null},y=({feature_index:v,initial_name:_="",initial_color:w=null,position:x=null,on_apply:O=null})=>{k={feature_index:v},g=O,i.value=_,l.value=w||CdA(t),e.style.display="block",E(x),setTimeout(()=>i.focus(),50)},G=()=>{if(k===null)return;let v=i.value.trim()||`nbhd_${k.feature_index+1}`,_=l.value;g&&g({feature_index:k.feature_index,name:v,color:_}),m()};return h.addEventListener("click",G),d.addEventListener("click",m),n.addEventListener("click",m),i.addEventListener("keydown",v=>{v.key==="Enter"?G():v.key==="Escape"&&m()}),{open:y,close:m}};var le=t=>{let A=[t.mat_layer,t.row_cat_layer,t.col_cat_layer,t.row_label_layer,t.col_label_layer,t.row_dendro_layer,t.col_dendro_layer];return t.col_attr_label_layer&&A.push(t.col_attr_label_layer),t.row_attr_label_layer&&A.push(t.row_attr_label_layer),A},wz=({layer:t,viewport:A})=>A.id==="matrix"&&t.id.includes("mat-layer")||A.id==="rows"&&t.id==="row-layer"||A.id==="cols"&&t.id==="col-layer"||A.id==="rows"&&t.id.includes("row-label-layer")||A.id==="cols"&&t.id==="col-label-layer"||A.id==="dendro_rows"&t.id==="row-dendro-layer"||A.id==="dendro_cols"&&t.id==="col-dendro-layer"||A.id==="col_attr_labels"&&t.id==="col-attr-label-layer"?!0:A.id==="row_attr_labels"&&t.id==="row-attr-label-layer";var HdA=["row","col"],DdA=[0,0,0,90],NdA=[0,0,0,180],KdA=t=>(t?.obs_store?.focused_dendro&&typeof t.obs_store.focused_dendro.get=="function"?t.obs_store.focused_dendro.get():null)??t.dendro?.active_polygon??null,Fz=(t,A,j,e)=>{let r=e?{axis:e.axis,name:e.name}:null,n=!1;if(HdA.forEach(i=>{if(!j.dendro.polygons[i])return;let o=j.dendro.polygons[i].map(l=>{let c=!!r&&l.properties.axis===r.axis&&l.properties.name===r.name;return l.properties.is_focused===c?l:(n=!0,{...l,properties:{...l.properties,is_focused:c}})});j.dendro.polygons[i]=o,A[`${i}_dendro_layer`]&&(A[`${i}_dendro_layer`]=A[`${i}_dendro_layer`].clone({data:o}))}),j.dendro.active_polygon=r,j.obs_store?.focused_dendro){let i=r?{...r}:null;j.obs_store.focused_dendro.set(i)}n&&typeof t?.setProps=="function"&&t.setProps({layers:le(A)})},LI=(t,A,j)=>new Ix({id:`${j}-dendro-layer`,data:A.dendro.polygons[j],getPolygon:r=>r.coordinates,getFillColor:r=>r.properties.is_focused?NdA:Array.isArray(r.properties.fill_color)?r.properties.fill_color:DdA,getLineColor:[255,255,255,255],lineWidthMinPixels:0,pickable:!0,antialiasing:!1}),Pz=(t,A,j)=>{t[`${j}_dendro_layer`]=t[`${j}_dendro_layer`].clone({data:A.dendro.polygons[j]})},eu=(t,A,j)=>{let e=!1;A.order.current[j]==="clust"&&(e=!0),t[`${j}_dendro_layer`]=t[`${j}_dendro_layer`].clone({visible:e})},XdA=(t,A,j,e,r)=>{let n=KdA(j);if(n&&n.axis===e&&n.name===r){Fz(t,A,j,null);return}Fz(t,A,j,{axis:e,name:r})},zdA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr?.names?.[A]||[],n=new Set(j),i=e.filter(l=>n.has(l.name)),o={};return r.forEach((l,c)=>{let B=`cat-${c}`,h={};i.forEach(k=>{let g=k[B];g!=null&&(h[g]=(h[g]||0)+1)});let d=Object.entries(h).map(([k,g])=>({name:k,value:g})).sort((k,g)=>g.value-k.value);d.length>0&&(o[l]=d)}),o},UdA=(t,A,j,e,r)=>{e.click.type=`${r}_dendro`;let n=r==="row"?e.row_entity:e.col_entity,i=t.object.properties.all_names||[];e.click.value={name:t.object.properties.name,selected_names:i,entity:n.entity,attr:n.attr,row_entity:e.row_entity.entity,col_entity:e.col_entity.entity,row_entity_full:e.row_entity,col_entity_full:e.col_entity},XdA(A,j,e,r,t.object.properties.name);let o=!1;if(e.obs_store?.dendro_selection){let c=e.obs_store.dendro_selection.get();if(c&&c.axis===r&&c.name===t.object.properties.name)o=!0,e.obs_store.dendro_selection.set(null),e.obs_store?.category_breakdown&&e.obs_store.category_breakdown.set({row:{},col:{}});else if(e.obs_store.dendro_selection.set({axis:r,name:t.object.properties.name,selected_names:i}),e.obs_store?.category_breakdown){let B=zdA(e,r,i),h=e.obs_store.category_breakdown.get()||{row:{},col:{}};e.obs_store.category_breakdown.set({...h,[r]:B})}}o&&(e.click.value.selected_names=[],e.click.value.is_unselecting=!0,e.attr?.editor?.close&&e.attr.editor.close()),Object.keys(e.model).length>0&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes());let l=o?[]:i;if(r==="row"?(Wv(e,l),eg(e,l)):r==="col"&&Yv(e,l),e.attr?.editor?.open&&!o){let h;r==="row"?h={x:(e.viz.row_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_width||300)-240-1,y:(e.viz.col_region||0)+(e.viz.label_buffer||0)}:h={x:(e.viz.row_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_width||300)-240,y:(e.viz.col_region||0)+(e.viz.label_buffer||0)+(e.viz.mat_height||300)-200-1},e.attr.editor.open({axis:r,selection:i,position:h})}typeof e.custom_callbacks[`${r}_dendro`]=="function"&&e.custom_callbacks[`${r}_dendro`](i)},CI=(t,A,j,e)=>{A[`${e}_dendro_layer`]=A[`${e}_dendro_layer`].clone({onClick:r=>UdA(r,t,A,j,e)})};var nr,HI=!0,Iz=()=>HI,VdA=t=>{HI=t},ru=t=>{let A=VA(t.currentTarget);return A.style("color")==="blue"?(A.style("color","gray"),nr=!1):(A.style("color","blue"),nr=!0),nr},QdA=(t,A,j,e,r)=>{let n=VA(t.currentTarget),i=n.text().toLowerCase();i==="var"?i="rankvar":i==="sum"&&(i="rank"),n.classed("active")===!1&&(n.classed("active",!0),VA(r.el).selectAll(`.button-${A}`).classed("active",!1).style("border-color",r.buttons.gray),n.style("border-color",r.buttons.blue).classed("active",!0),r.order.current[A]=i,e.mat_layer=e.mat_layer.clone({updateTriggers:{getPosition:[r.order.current.row,r.order.current.col]}}),A==="row"?(e.row_label_layer=e.row_label_layer.clone({updateTriggers:{getPosition:r.order.current.row}}),e.row_cat_layer=e.row_cat_layer.clone({updateTriggers:{getPosition:r.order.current.row}})):(e.col_label_layer=e.col_label_layer.clone({updateTriggers:{getPosition:r.order.current.col}}),e.col_cat_layer=e.col_cat_layer.clone({updateTriggers:{getPosition:r.order.current.col}})),eu(e,r,A),j.setProps({layers:le(e)}))},Mz=(t,A,j,e=40,r,n,i,o)=>{let l=`button-${r}`,c;j===!0?c=o.buttons.blue:c=o.buttons.gray;let B=A.toUpperCase();VA(t).append("div").classed(l,!0).classed("active",j).text(B).style("width",`${e}px`).style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","9px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color",c).style("border-radius","10px").style("margin-top","4px").style("margin-left","3px").style("padding","2px 4px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').on("click",h=>QdA(h,r,n,i,o))},WdA=async(t,A,j)=>{ru(t),bD(j,nr),A.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},YdA=async(t,A,j,e)=>{ru(t);let r=nr;e.obs_store.umap_state.get()&&r?e.obs_store.landscape_view.set("spatial"):(e.obs_store.viz_image_layers.set(r),e.obs_store.viz_background_layer.set(r)),VdA(r)},JdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.tile,nr),pz(j,nr),A.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]})},ZdA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.trx,nr),Ts(j,nr),nr?(pl(j,!1),e.obs_store.viz_nbhd_layer.set(!1),e.obs_store.viz_edit_layer.set(!1),e.nbhd.is_nbhd&&e.buttons?.buttons?.nbhd?.style?.("color","gray"),e.genes.svg_bar_gene.selectAll("rect").style("opacity",1)):e.genes.svg_bar_gene.selectAll("rect").style("opacity",.2),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),trx_layer:!0})},ApA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.cell,nr),Au(j,nr),Of(j,nr),nr?(pl(j,!1),e.obs_store.viz_nbhd_layer.set(!1),e.obs_store.viz_edit_layer.set(!1),e.nbhd.is_nbhd&&e.buttons?.buttons?.nbhd?.style?.("color","gray"),e.cats.svg_bar_cluster.selectAll("rect").style("opacity",1)):e.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,nbhd_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,nbhd_layer:!0})},tpA=async(t,A,j,e)=>{ru(t),Rj(e.sliders.nbhd,nr),pl(j,nr),e.obs_store.viz_nbhd_layer.set(nr),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!1,nbhd_layer:!1,cell_layer:!1,path_layer:!1,trx_layer:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!0,nbhd_layer:!0,cell_layer:!0,path_layer:!0,trx_layer:!0})},jpA=async(t,A,j,e)=>{e.obs_store.landscape_view.set("umap")},epA=async(t,A,j,e)=>{e.obs_store.landscape_view.set("spatial")},rpA=(t,A,j,e)=>async r=>{let n=e.obs_store.umap_state.get();if(!HI&&!n)return;ru(r),n&&(e.obs_store.landscape_view.set("spatial"),e.obs_store.viz_background_layer.set(!0),e.obs_store.viz_image_layers.set(!0)),lz(j,t,nr);let i=e.img.image_layer_sliders.filter(o=>o.name===t)[0];Rj(i,nr),e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!1}),e.layers_obj=j,e.obs_store.deck_check.set({...e.obs_store.deck_check.get(),image_layers:!0})},kn=(t,A,j,e="blue",r=40,n="button",i,o,l)=>{let c;j==="IMG"?A==="sst"?c=d=>WdA(d,i,o):c=d=>YdA(d,i,o,l):j==="TILE"?c=d=>JdA(d,i,o,l):j==="TRX"?c=d=>ZdA(d,i,o,l):j==="CELL"?c=d=>ApA(d,i,o,l):j==="NBHD"?c=d=>tpA(d,i,o,l):j==="UMAP"?c=d=>jpA(d,i,o,l):j==="SPATIAL"?c=d=>epA(d,i,o,l):c=rpA(j,i,o,l);let B=VA(t).append("div").attr("class",n).text(j).style("width",`${r}px`).style("text-align","left").style("cursor","pointer").style("font-size","12px").style("font-weight","bold").style("color",e).style("margin-top","5px").style("margin-left","5px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif;').on("click",c),h=j.toLowerCase();l.buttons.buttons[h]=B},__=(t,A,j,e,r,n,i)=>{let o="edit_button";r=r.toUpperCase();let c=VA(e).append("div").classed(o,!0).classed("active",!1).text(r).style("width",`${n}px`).style("height","20px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","12px").style("font-weight","bold").style("color","gray").style("margin-left","3px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').on("click",h=>i(h,t,A,j)).node(),B=r.toLowerCase();j.edit.buttons[B]=c};var A7={},nu=async t=>{if(!(t in A7)){let A={name:"",description:"Unable to obtain UniProt description."},r=`https://www.ebi.ac.uk/proteins/api/proteins?offset=0&size=100&exact_gene=${t}&organism=human`;try{let o=(await(await fetch(r,{headers:{Accept:"application/json"}})).json()).filter(l=>l.proteinExistence==="Evidence at protein level").filter(l=>"comments"in l).filter(l=>"gene"in l).filter(l=>l.gene[0].name.value.toLowerCase()===t.toLowerCase()).sort((l,c)=>c.comments.length-l.comments.length);if(o.length>0){let c=`https://rest.uniprot.org/uniprotkb/${o[0].accession}.json`;try{let h=await(await fetch(c)).json(),d=h.proteinDescription?.recommendedName?.fullName?.value||"",k=h.comments?.[0]?.texts?.[0]?.value||"Unable to obtain UniProt description.";A={name:d,description:k}}catch(B){Zj(B,{context:`fetching detailed info for ${t}`,url:c,logUnexpected:!0,throwOnAuth:!1})}}}catch(n){Zj(n,{context:`searching for gene ${t}`,url:r,logUnexpected:!0,throwOnAuth:!1})}A7[t]=A}};var DI=(t,A,j)=>{let e,r,n={};t[`${A}_nodes`].forEach((B,h)=>{n[h]=[h],B.group_links=h});let i=t[`${A}_nodes`].length,o=0,l;t.linkage[A].forEach((B,h)=>{B[2]>o&&B[2]{h.forEach(d=>{c[d]=B})}),t[`${A}_nodes`].forEach((B,h)=>{B.group_links=c[h]})},NI=(t,A)=>{let j={},e=t[`${A}_nodes`],r,n,i=t.mat[`num_${A}s`];A==="row"?(r=t.viz.mat_width,n=r/i):(r=t.viz.mat_height,n=r/i);let o=t.order.current[A];e.forEach((c,B)=>{let h=c.group_links,d;if(A==="row"){let E=t.mat.num_rows-t.mat.orders.row[o][B];d=t.viz.row_offset*(E+1)}else{let E=t.mat.num_cols-t.mat.orders.col[o][B];d=t.viz.col_offset*(E+0)}let k=d+n,g=c.name;g.indexOf(": ")>=0&&(g=g.split(": ")[1]),Object.prototype.hasOwnProperty.call(j,h)||(j[h]={name_top:g,name_bot:g,pos_top:d,pos_bot:k,pos_mid:(d+k)/2,name:h,all_names:[],axis:A}),j[h].all_names.push(g),dj[h].pos_bot&&(j[h].name_bot=g,j[h].pos_bot=k,j[h].pos_mid=(j[h].pos_top+k)/2)});let l=[];Object.values(j).forEach(c=>{l.push(c)}),t.dendro.group_info[A]=l},Oz=t=>{t.dendro={},t.dendro.default_level=5,t.dendro.tri_height=.1,t.dendro.trap_height=.03,t.dendro.trap_float=.005,t.dendro.dendro_args={},t.dendro.group_level={},t.dendro.polygons={},t.dendro.update_dendro=!1,t.dendro.selected_clust_names=[],t.dendro.group_info={},t.dendro.default_link_level=.5,t.dendro.output_label_format="list",t.dendro.min_dist={},t.dendro.min_dist.row=0,t.dendro.min_dist.col=0;let A=["col","row"],j;t.dendro.max_linkage_dist={};let e;A.forEach(r=>{j=t.linkage[r],t.dendro.max_linkage_dist[r]=j[j.length-1][2]+.01,e=t.dendro.max_linkage_dist[r]*t.dendro.default_link_level,DI(t,r,e),NI(t,r)})},ig=(t,A)=>{t.dendro.polygons[A]=[],t.dendro.group_info[A].forEach(j=>{let{pos_top:e,pos_bot:r,pos_mid:n}=j;if(A==="row"){let i=r-e,o=7,l=[[o+100,n],[o,n-i/2],[o,n+i/2]];t.dendro.polygons[A].push({coordinates:l,properties:{...j,axis:A,is_focused:!1}})}else if(A==="col"){let i=r-e,o=17,l=[[n,o+100],[n-i/2,o],[n+i/2,o]];t.dendro.polygons[A].push({coordinates:l,properties:{...j,axis:A,is_focused:!1}})}})};var npA=t=>({selected_cats:[...t.cats.selected_cats],selected_genes:[...t.genes.selected_genes],cat:t.cats.cat,viz_image_layers:t.obs_store.viz_image_layers.get(),landscape_view:t.obs_store.landscape_view.get()}),ipA=async(t,A,j)=>{t.umap.has_umap&&t.obs_store.landscape_view.set(j.landscape_view);let e=j.selected_genes.filter(r=>t.genes.gene_names.includes(r));if(e.length>0){let r=e[0];await qr(t.cats,t.genes,t.global_base_url,r,t.seg.version,t.vector_name_integer,t.aws,t.row_group_readers?.cbg),gt(t.cats,r),Wt(t.genes,e,t.obs_store),Rt(t.cats,e,t.obs_store),t.selection_token=(t.selection_token||0)+1,A.cell_layer=A.cell_layer.clone({id:`cell-layer-gene-${r}-${t.selection_token}`,updateTriggers:{getFillColor:[t.selection_token,r]}}),t.layers_obj=A}else{let r=new Set(t.cats.cluster_counts.map(i=>i.name)),n=j.selected_cats.filter(i=>r.has(i));n.length>0?(gt(t.cats,"cluster"),Rt(t.cats,n,t.obs_store),Wt(t.genes,[],t.obs_store)):(Rt(t.cats,[],t.obs_store),Wt(t.genes,[],t.obs_store))}t.obs_store.persistent_state.set({selected_cats:t.cats.selected_cats,selected_genes:t.genes.selected_genes,cat:t.cats.cat,viz_image_layers:t.obs_store.viz_image_layers.get(),landscape_view:j.landscape_view})},Tz=async(t,A,j,e)=>{let r=A.base_urls||[];if(t<0||t>=r.length)return;let n=npA(A);A.obs_store.dataset_switching.set(!0),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),background_layer:!1,image_layers:!1,cell_layer:!1,path_layer:!1,trx_layer:!1});try{let o=r[t].url;Es(A,o),await xs(A.img,o,A.aws);let l=A.img.landscape_parameters.image_info,c=l[0].name;Qf(A.img,A.img.landscape_parameters.image_format),Wf(A.img,l),Hf(A.img),Yf(A.img.image_layer_colors,A.img.image_info);let B=A.img.landscape_parameters.technology;B!=="Chromium"&&B!=="point-cloud"&&await $s(A,o,c),A.genes.gene_counts=[],A.genes.meta_gene={},await gl(A.genes,o,A.seg.version,A.aws),A.genes.top_gene_counts=A.genes.gene_counts.slice(0,100),A.obs_store.new_gene_bar_data.set(A.genes.top_gene_counts),await f_(A.genes,o,A.seg.version,A.aws);let h;A.seg.version==="default"?h=`${o}/cell_metadata.parquet`:h=`${o}/cell_metadata_${A.seg.version}.parquet`;let d=await ae(h,Nt.fetch,A.aws);if(u_(A.cats,d),A.spatial.cell_scatter_data=dl(d),B_(A.cats),A.cats.has_meta_cell){let _=A.cats.meta_cell_attr.indexOf(A.cats.inst_cell_attr);A.cats.cell_cats=A.cats.cell_names_array.map(w=>A.cats.meta_cell[w]?.[_]??"N.A.")}else{let _=await ae(`${o}/cell_clusters${A.seg.version&&A.seg.version!=="default"?`_${A.seg.version}`:""}/cluster.parquet`,Nt.fetch,A.aws);Vv(A.cats,_,"cluster")}Qv(A.cats),A.cats.color_dict_cluster={},A.cats.cluster_counts=[],await Jf(A),A.obs_store.new_cell_bar_data.set(A.cats.cluster_counts);let k=d.getChild("name").toArray(),g=A.spatial.cell_scatter_data.attributes.getPosition.value,E=A.spatial.cell_scatter_data.attributes.getPosition.size||2;A.combo_data.cell=k.map((_,w)=>({name:_,cat:A.cats.dict_cell_cats[_],x:g[w*E],y:g[w*E+1],z:E===3?g[w*E+2]:0}));let m;if(A.umap.has_umap){let _=new Float64Array(A.cats.cell_names_array.flatMap(x=>{let O=A.umap.umap[x];return O||(O=[0,0]),O})),w=A.spatial.cell_scatter_data.length;m=Array.from({length:w},(x,O)=>({name:A.cats.cell_names_array[O],position:E===3?[g[O*E],g[O*E+1],g[O*E+2]]:[g[O*E],g[O*E+1]],umap:[_[O*2],_[O*2+1]]})),m=h_(A,m)}else{let _=A.spatial.cell_scatter_data.length;m=Array.from({length:_},(w,x)=>({name:A.cats.cell_names_array[x],position:E===3?[g[x*E],g[x*E+1],g[x*E+2]]:[g[x*E],g[x*E+1]]}))}A.spatial.cell_scatter_data_objects=m,A.spatial.x_min=vr(m.map(_=>_.position[0])),A.spatial.x_max=xj(m.map(_=>_.position[0])),A.spatial.y_min=vr(m.map(_=>_.position[1])),A.spatial.y_max=xj(m.map(_=>_.position[1])),E===3&&(A.spatial.z_min=vr(m.map(_=>_.position[2])),A.spatial.z_max=xj(m.map(_=>_.position[2]))),A.spatial.center_x=(A.spatial.x_max+A.spatial.x_min)/2,A.spatial.center_y=(A.spatial.y_max+A.spatial.y_min)/2,A.spatial.data_width=A.spatial.x_max-A.spatial.x_min,A.spatial.data_height=A.spatial.y_max-A.spatial.y_min,e.cell_layer=e.cell_layer.clone({id:`cell-layer-dataset-${t}`,data:m,transitions:!1,updateTriggers:{getPosition:[A.obs_store.umap_state.get(),t],getFillColor:[A.selection_token,t]}}),e.image_layers&&Array.isArray(e.image_layers)&&e.image_layers.forEach(_=>{if(_&&typeof _.finalize=="function")try{_.finalize()}catch(w){}});let y=await k_(A,t);e.image_layers=y,A.dimensions&&(e.background_layer=Rf(A)),A.genes.trx_data=[],A.genes.trx_names_array=[],A.cats.polygon_cell_names=[],A.combo_data.trx=[],e.trx_layer=e.trx_layer.clone({id:`trx-layer-dataset-${t}`,data:[]}),e.path_layer=e.path_layer.clone({id:`path-layer-dataset-${t}`,data:[]}),A.cache?.cell&&A.cache.cell.clear(),A.cache?.trx&&A.cache.trx.clear(),A.cats.selected_cats=[],A.genes.selected_genes=[],A.cats.cat="cluster",A.layers_obj=e,A.obs_store.current_dataset_index.set(t),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),background_layer:!0,image_layers:!0,cell_layer:!0,path_layer:!0,trx_layer:!0,trx_data:!0,path_data:!0});let G=Wr(e,A.close_up);j.setProps({layers:G}),await ipA(A,e,n);let v=Wr(A.layers_obj,A.close_up);j.setProps({layers:v}),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),cell_layer:!1}),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),cell_layer:!0})}finally{A.obs_store.dataset_switching.set(!1)}};var Sz=(t,A,j)=>{let e=t.base_urls||[];if(e.length<=1)return null;let r=document.createElement("div");r.className="dataset-dropdown-container",r.style.display="inline-flex",r.style.alignItems="center",r.style.marginLeft="5px",r.style.marginRight="5px",r.style.position="relative";let n=document.createElement("select");n.className="dataset-dropdown",n.style.width="55px",n.style.height="18px",n.style.fontSize="9px",n.style.padding="1px 2px",n.style.border="1px solid #d3d3d3",n.style.borderRadius="3px",n.style.backgroundColor="white",n.style.cursor="pointer",n.style.outline="none",n.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',n.style.transition="width 0.15s ease",n.title="Switch dataset";let i=Math.max(...e.map(l=>(l.label||"").length)),o=Math.min(Math.max(i*7+20,80),150);return n.addEventListener("mousedown",()=>{n.style.width=`${o}px`}),n.addEventListener("focus",()=>{n.style.borderColor="#8797ff",n.style.width=`${o}px`}),n.addEventListener("blur",()=>{n.style.borderColor="#d3d3d3",n.style.width="55px"}),n.addEventListener("change",()=>{setTimeout(()=>{n.style.width="55px"},100)}),e.forEach((l,c)=>{let B=document.createElement("option");B.value=c;let h=l.short_label||l.label||`DS-${c+1}`,d=l.label||`Dataset ${c+1}`;B.textContent=h,B.title=d,n.appendChild(B)}),n.value=t.obs_store.current_dataset_index.get(),n.addEventListener("change",async l=>{let c=parseInt(l.target.value,10),B=t.obs_store.current_dataset_index.get();if(c!==B&&!t.obs_store.dataset_switching.get()){n.disabled=!0,n.style.opacity="0.5";try{await Tz(c,t,A,j)}catch(h){n.value=B}finally{n.disabled=!1,n.style.opacity="1"}}}),t.obs_store.current_dataset_index.subscribe(l=>{n.value=l}),r.appendChild(n),r};var q_=async(t,A)=>{let j=t.global_base_url,e=await ae(`${j}/tbg/${A}.parquet`,Nt.fetch,t.aws),r=e.getChild("__index_level_0__").toArray(),n=e.getChild(A).toArray(),i=new Array(t.cats.tile_names_array.length).fill(0);r.forEach((o,l)=>{if(t.cats.tile_name_to_index_map.has(o)){let c=t.cats.tile_name_to_index_map.get(o),B=Math.log1p(Number(n[l])),h=Math.log(Number(t.genes.meta_gene[A].max));i[c]=B/h*255}}),t.cats.tile_exp_array=i};var Rz=t=>{let A=document.createElement("input");A.setAttribute("type","text"),A.setAttribute("placeholder","Gene search"),A.style.width="500px",A.style.height="20px",A.style.marginTop="5px",A.style.display="inline-block",A.style.padding="1pt 2pt",t.gene_search_input=A};var KI=[],Lz=0,opA=async(t,A,j)=>{let e=A.genes.gene_search_input.value,r=e===""?"cluster":e;(e===""||A.genes.gene_names.includes(e))&&(gt(A.cats,r),A.obs_store.deck_check.set({...A.obs_store.deck_check.get(),square_scatter_layer:!1}),Wt(A.genes,e===""?[]:[e],A.obs_store),Rt(A.cats,[],A.obs_store),e!==""&&KI.includes(e)&&await q_(A,e),rg(A,j),t.setProps({layers:[j.simple_image_layer,j.square_scatter_layer]}))},spA=async(t,A,j)=>{let e=j.genes.gene_search_input.value,r=e===""?"cluster":e;(e===""||j.genes.gene_names.includes(e))&&(gt(j.cats,r),j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!1,trx_layer:!1}),Wt(j.genes,e===""?[]:[e],j.obs_store),j.genes.gene_names.includes(e)&&await qr(j.cats,j.genes,j.global_base_url,e,j.seg.version,j.vector_name_integer,j.aws,j.row_group_readers?.cbg),Rt(j.cats,r==="cluster"?[]:[e],j.obs_store))},og=async(t,A,j,e)=>{KI=["cluster",...e.genes.gene_names],e.genes.gene_search.style.width="115px",Rz(e.genes);let r=document.createElement("datalist");Lz+=1,r.id=`genes_datalist_${Lz}_${Date.now()}`,e.genes.gene_search_input.setAttribute("list",r.id),KI.forEach(i=>{let o=document.createElement("option");o.value=i,r.appendChild(o)}),e.genes.gene_search_input.style.width="156px",e.genes.gene_search_input.style.maxWidth="250px",e.genes.gene_search_input.style.height="12px",e.genes.gene_search_input.style.fontSize="12px",e.genes.gene_search_input.style.border="1px solid #d3d3d3",e.genes.gene_search_input.style.borderRadius="0",e.genes.gene_search_input.style.display="inline-block",e.genes.gene_search_input.style.padding="1pt 2pt",e.genes.gene_search.appendChild(e.genes.gene_search_input),e.genes.gene_search.appendChild(r),e.genes.gene_text_box=document.createElement("div"),e.genes.gene_text_box.textContent="",e.genes.gene_text_box.style.marginTop="3px",e.genes.gene_text_box.style.color="#222222",e.genes.gene_text_box.style.border="1px solid #d3d3d3",e.genes.gene_text_box.style.height="69px",e.genes.gene_text_box.style.overflow="scroll",e.genes.gene_text_box.style.fontSize="12px",e.genes.gene_text_box.style.cursor="default",e.genes.gene_text_box.style.width="142px",e.genes.gene_text_box.style.paddingLeft="2px",e.genes.gene_text_box.style.paddingRight="17px",e.genes.gene_text_box.addEventListener("wheel",i=>{let{scrollTop:o,scrollHeight:l,clientHeight:c}=e.genes.gene_text_box,B=o===0,h=o+c===l;(B&&i.deltaY<0||h&&i.deltaY>0)&&i.preventDefault()}),e.genes.gene_search.appendChild(e.genes.gene_text_box),e.genes.gene_search_input.value="",gt(e.cats,"cluster");let n;t==="sst"?(n=()=>opA(A,e,j),e.genes.gene_search_input.style.marginTop="10px",e.genes.gene_search.style.height="50px"):(n=()=>spA(A,j,e),e.genes.gene_search_input.style.marginTop="5px"),e.genes.gene_search_input.addEventListener("input",n)};var b_="iVBORw0KGgoAAAANSUhEUgAAAGQAAABACAYAAADs39J0AAAAAXNSR0IArs4c6QAAAIRlWElmTU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAAEsAAAAAQAAASwAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAAAGSgAwAEAAAAAQAAAEAAAAAAjiNKrQAAAAlwSFlzAAAuIwAALiMBeKU/dgAAAVlpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpPcmllbnRhdGlvbj4xPC90aWZmOk9yaWVudGF0aW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KGV7hBwAAC3JJREFUeAHtXFtsHFcZ/s/MXmw3TmrSFGrxWCLRIqOoBQnRqgkEojruQ5PG4qEV5cU8pCYqLwgJNRsKRYSKprZLSB6QQIKHhFK1iDiVAk6UB0ppKA8kJKEE1ASnauz47l3vzs7h+8+Z2Z2dnb14L84E5kj2zuWc77+fy8yZX1ChSEEpEkQHClcaOkil7KrtJOgcYDrNFPBYiw7d3vI0qaB6lQslrU1ZIzqtlydGqQn8bbPoG+NfJSm/SSSmobPY6vQmERWyE23/QaOPPoVfWdb+mDRpUOTptb8/TZKeRYzcRD2zrF7VCw4dCTq7PvmkU5WVX6S355hJxwfzNDz+NC4/i3sN0hGd4PEyjbA8AUXpTVj0m/Nfgxj7QGumMXlAh+zL9Ph9ik6MJru1N0m6l9Z/tI+WgGuyPSAji1nN19z7Ng7iHUTp2V4P66WKmjln4F4etrqX7v54H81OOXQ8LWod2rB7RxfR3NQ9qKrxJWgLD5M9M5oOyU8oeZYhjwG7u7y6v0G03HtMJwE9Lc9+zFOtVJ57HL2RAXl6P92wPJ2QZ3a6QAeaP6dpCpmhzCJUls3gL+5hpPahgKJtK4GK8xUrb36AxYVijAwtolpuJUPZldXRYYPmQUeIynR6Nzt0SMtj5TJEDciTySdgxAWPPBrXc0EdCtG8PB69Fbsmmwwy2Lm4G0H3sprCA7WJtjbVbielQabyWK5bu76XD4moYG/P52q3E1yX5ZEsY+36JXRYHjSRFgO4pTRC3KvwsKbkYTpWtsCfl2CBRLgP4KjV53HhZt/PnS/ubkOD+CX63zqPDBIye0YGiQwSMg2EjJ0oQiKDhEwDIWMnipDIICHTQMjYiSIkMkjINBAydqIIiQwSMg2EjJ0oQiKDhEwDIWMnipDIICHTQMjYiSIkMkjINBAydqIIiQwSMg2EjJ0oQsJvEN82iDAxLAJ2RLaFvzWiEyBPcV+WwBZA3qmpNtnoA+zRgnWq7V917xt5tDWwFbX2Bh0hbLLzmo7Ehh5mivd1ub9+BZcwDXzbNsFWbTpAdeQBMeydKsji8uwnxOfuPfAoQUfit1iCPZXpBMlTbFd+5MrKcvjowCAP6AZSJiiObY25TJKMop3K0QKusDF4K2neAkCFcvmcu98zQZ13EGXSSb1ltUL9oMvMPG8lXchVpjN5WdMRzcqDraT5BS+dShvlivLEoLdgswVJg7rQG8uTyxboxKh3QUMYYpIWb0yi5RQsvkqLwNPzOd5sfTGYMq5uduiQfZ2mPpgE41MwoCOBaytva2bLrwN4bA50pGQ6mm9/U3crKTUjDzzXgtENuuDhqFTVrjwGTQbL4/LvInjPC8eQRxnDS8dtEP1GGog0UKYBX8DzAO7vJsraBFxw2yi40tAOqK0H8aAbdVwrRDsPwLXK7SJPnXqrJW50v/UaUKbRsNWmt60nHCH6NVBPxPvbROdt14COkFQKC6dHEvTvttOLCARpoOeGoA2bcvytp15v3HxwC8n0m9RNaYzp2kj8tVI7isD6wcX2HtdDq5763jre43rw/XW4PReXX//9aud+2t7zElxpkbXuLprO4INbOuIsAONJSnRsJAuf4xU+oGyPPfR6rl3Y1TTU6L3CtK5RgArtHFzbIurq4Q9MN3BFbZB8VpIBJdl53FXPfSqARJfboAFESBYfzLLuXYMou6gn8fjHlolmXG1QfAVIdEncK0mBh4HQfqFWoReJjFHQyZocuPoWOSanDRIz8BjYXfhG8+E1sUMZEf1KQRvEkjnn3UEhTsrqRxfaqwFndqsNYnBujKjcUg3YUr21c7usLN7EMT88utxSvv4viasZMFJ0oDhdlo0TtlA7e6y2j03t9qQ24ivopaJBjNwibLGsp19t81FYu11GYWieO7YLHzppHz7W7eidDBNppNwI6Vk/jZewN1RiF97s0LqCBScncSHkSJLXkQxGP0BoJb7gIJdzZMv/tB4fBlb4tIhZ6NXW4ytFGGStwODWNT4ziBN+cQIzootkcrakkp0WXKeZYlMsCUh6F/9OUZxfuyPFUuuKTXjqA4NfQHCMtx4fk50YFtGS3gPLr7ceH2FgmAKprbC/QFxhtRikE35BUfK08mYm37oCg3AaLToD2Dec3SytxJdkAl+IP8LQrzre3Dru2TkZ35BIKmYfayGwC6Udlox3aLR/noPDoN4h7bGG8QZlVL4uDpNWKc3AtiLIIt8kc+UUMs4ho5xoJb7zCAj4mWu/p/Q8xkHsYeLnyS0p6LK4f5fiJI0OnKWVpWk4LT//U1PS5kkAn7t0IV5VWPdvQgeZghdwt/Xyo5cgxglKYM8UxGyeGDDiHSYM8i69svNPdOjxWWD+WuMjV2HzJY/oi1F26RKtXJ2go1/PIcp/RUnwL6gF+LCEiT58ZfEaJc1xh92fU0JtoWqFftBdGXEEwTSMrqNv/9a8nva6yhH0PPozPsOMpekCgnAmIZ4vIAnze5RLw+NUlrfmvJjHIh6fiF5QxuAjS/4AArL3xpuPEjgNbxwk+iG9uENNSSlv/wj4HIUc5U1GCd6DJNcx/o9VdzV0JA5d8aN2FM7iyVk2R/vfwoh/mDo3cMo5DP0NlxXq6IZ3Lb2OrJ6vUQp0GH9kx9+w3DlIXXeywbMNo3PbxLoEZeYnwPMvkMPXIBbo8MAVGOI56ryTXapxfG6b6AL+wtvAH1N8Dr0Tp5/s/ADe9G3IxpeaicIcjJ2g9NwF4L+g8I8OKbxihKS26jAc7d+Lin+B9dj9GjCKhDCdSUovXKXO7qcUMU7OnNqm8Uf6vwX8s9SxvkF8KCvWkaDs4hQSaX5F4+8nFSW8R3is//sYq8bhVI3hszHMBPDTi2RYexQ+d+lHH8QrVjjW6M4Ryswdh9F5ttKAfiiHLbRx9BQWnHN3Ad9ZQxUNwheYsB7QtyFD6XnqVErjx8L19JlcJ0vJbhbmOrqlh+ngQws6L3CKw1sqgXBAsYUdEOqcVhoeO8t68NXTUBj7jgTebM4gvB+in+76UOM7U/UDB3RXu/HtARj9NJTGRmHPq8Ob1eidVZ5rraTJFo/Qy4+9r/C5B+GyH5xyGekfVEbvUvh8D/jQX/XCOgB+RxzvomAM2kpjj10swUeF8rGCjaISEZ9I4u4v0TXsxr5dkMwAEImQy9swIwYGWBOei9y986dJJp6gV7ZPa2WpNQ6qOMXFZ2+7eZIHySfV7vGci+++H3AbsKCoa8ZNtQ7IzL+FRKO7aezLk1XxufkzJ45QsmtIvVrIpR3+A/A5U2oM+CpX7/xfkcR0F43t+JfqBnmy4C2q+3Uc4JkTh/Dqe5+abq8s85t3Nrxfp6wfZEjFTmyecKTnL0Ke3eiqLgTh+xtr0q7S+Gx4fBcAvoMw3qIXYawfNjYKr2L5iYWF7trKXsKNgyD0M3XPzZitTnz/vPh7fzeAl5TPQeGfUTvo+UFBAR/YTIPfbmbTVyDWi8A/XBPfq7Thk9sx/qagkM8rhVfCzy2/D689RGM7X6qNjzHLzT0/fPJh4H8XfG5VCg/C588VssvYYC5H6a4/H1RtK+gn2CDMEQ+U5+8TKlr4fO/458iUX8Cc/H6c4a08e5qYQ6TCEPYEjQxMcDUQ1cn2eTpdrXC9weNGAX/4t5+FUF9EV/EpYH5EWxqJjIVxifL5M/Th0h+cugJda7FdRRrAT512n0LAsU5sAeZ2rPX6wPpGZWkp+RneezDEGcrefUqNE4zndZh68feN92G99SVU78PfJvyh+wc+0T9B6yzFFk/RS4OYYqLUha9qBvxjSyrlB9zzX1J1/RdrnHMbNk49RePXV9fF4zZq35l7ocqvwq+TFxeGlcsRWU/hmWANXdYrnPZKfszC31+cv8H9IhFWlsQfyMz02HR8D/fR+no9zPnrsGC3Cp9lUrPMNvG/Cvz/Auq7qtLiQpjKAAAAAElFTkSuQmCC";var apA=()=>{let t=document.createElement("div");return t.className="matrix-cat-bar-container",t.style.display="flex",t.style.flexDirection="row",t.style.gap="8px",t.style.marginTop="5px",t.style.marginLeft="10px",t.style.maxHeight="100px",t.style.overflow="hidden",t},Cz=(t,A,j)=>{let e=document.createElement("div");e.className=`cat-bar-wrapper-${t}`,e.style.display="flex",e.style.flexDirection="column",e.style.width="95px";let r=document.createElement("div");r.className=`cat-bar-title-${t}`,r.textContent=A||t.toUpperCase(),r.style.fontSize="10px",r.style.fontWeight="bold",r.style.marginBottom="2px",r.style.whiteSpace="nowrap",r.style.overflow="hidden",r.style.textOverflow="ellipsis",r.style.textTransform="capitalize",e.appendChild(r);let n=document.createElement("div");n.className=`cat-bar-graph-${t}`,n.style.width="95px",n.style.height="72px",n.style.overflowY="auto",n.style.border="1px solid #d3d3d3",e.appendChild(n),n.addEventListener("wheel",o=>{let{scrollTop:l,scrollHeight:c,clientHeight:B}=n,h=l===0,d=l+B===c;(h&&o.deltaY<0||d&&o.deltaY>0)&&o.preventDefault()});let i=Ur("svg").attr("width",90).attr("font-family","sans-serif").attr("font-size","11").attr("text-anchor","end").style("user-select","none");return n.appendChild(i.node()),{wrapper:e,bar_container:n,svg:i,title:r}},sg=(t,A,j,e,r,n)=>{let l=14*(A.length+1);t.attr("height",l);let c=A.map(E=>E.value),B=ti().domain(F6(c.length)).range([0,15*c.length]),h=ji().domain([0,xj(c)||1]).range([0,85]),d=t.selectAll("g").data(A,E=>E.name),k=d.enter().append("g").attr("class","cat-bar-item").attr("data-name",E=>E.name).attr("transform",(E,m)=>`translate(2,${B(m)+2})`).style("cursor",e?"pointer":"default").on("click",(E,m)=>{e&&e(m)}).on("mouseenter",(E,m)=>{r&&r(m)}).on("mouseleave",(E,m)=>{n&&n(m)});k.append("rect").attr("fill",E=>{let m=j?.[E.name]||[100,100,100];return Array.isArray(m)?`rgb(${m[0]}, ${m[1]}, ${m[2]})`:m}).attr("width",0).attr("height",B.bandwidth()-1).transition().duration(300).attr("width",E=>h(E.value)),k.append("text").attr("fill","black").attr("x","3px").attr("y",B.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").text(E=>`${E.name} (${E.value})`);let g=d.merge(k);g.transition().duration(300).attr("transform",(E,m)=>`translate(2,${B(m)+2})`),g.select("rect").transition().duration(300).attr("width",E=>h(E.value)).attr("fill",E=>{let m=j?.[E.name]||[100,100,100];return Array.isArray(m)?`rgb(${m[0]}, ${m[1]}, ${m[2]})`:m}),g.select("text").text(E=>`${E.name} (${E.value})`),g.on("mouseenter",(E,m)=>{r&&r(m)}).on("mouseleave",(E,m)=>{n&&n(m)}),d.exit().transition().duration(300).attr("opacity",0).remove()},w_=(t,A)=>{["row","col"].forEach(j=>{let e=t.cat_bars?.[j]?.svg;e&&e.selectAll(".cat-bar-item").each(function(r){let n=VA(this),i=n.select("rect"),o=n.select("text"),l=String(r.name),c=A!=null?String(A):null;c?l===c?(n.style("opacity","1"),i.style("opacity","1"),o.style("opacity","1")):(n.style("opacity","0.15"),i.style("opacity","0.15"),o.style("opacity","0.15")):(n.style("opacity",null),i.style("opacity",null),o.style("opacity",null))})})},XI=(t,A)=>{let j=A==="row"?t.row_nodes:t.col_nodes,e=t.attr?.cats?.[A]||[];if(e.length===0||!j||j.length===0)return null;let r=e[0],i=(t.attr?.names?.[A]||[]).indexOf(r);if(i<0)return null;let o=`cat-${i}`,l={};j.forEach(B=>{let h=B[o];h!=null&&(l[h]=(l[h]||0)+1)});let c=Object.entries(l).map(([B,h])=>({name:B,value:h})).sort((B,h)=>h.value-B.value);return{attr_name:r,attr_index:i,data:c}},lpA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr?.cats?.[A]||[];if(r.length===0||!e||e.length===0)return null;let n=r[0],o=(t.attr?.names?.[A]||[]).indexOf(n);if(o<0)return null;let l=new Set(j),c=e.filter(k=>l.has(k.name)),B=`cat-${o}`,h={};c.forEach(k=>{let g=k[B];g!=null&&(h[g]=(h[g]||0)+1)});let d=Object.entries(h).map(([k,g])=>({name:k,value:g})).sort((k,g)=>g.value-k.value);return{attr_name:n,attr_index:o,data:d}},F_=(t,A)=>{let j=t.attr?.cats?.[A]||[];return j.length>0?j[0]:A.toUpperCase()},Hz=t=>{let{deck_mat:A}=t,{layers_mat:j}=t;!A||!j||(j.row_cat_layer&&(j.row_cat_layer=j.row_cat_layer.clone({updateTriggers:{getFillColor:[t.hovered_cat]}})),j.col_cat_layer&&(j.col_cat_layer=j.col_cat_layer.clone({updateTriggers:{getFillColor:[t.hovered_cat]}})),A.setProps({layers:le(j)}))},ag=(t,A,j)=>({on_hover:n=>{if(t.hovered_cat={axis:A,name:n.name,level:j},w_(t,n.name),Hz(t),t.obs_store?.hovered_category){let i=t.attr.names[A]?.[j];t.obs_store.hovered_category.set({axis:A,attr_name:i,attr_index:j,value:n.name})}},on_hover_out:()=>{t.hovered_cat=null,w_(t,null),Hz(t),t.obs_store?.hovered_category&&t.obs_store.hovered_category.set(null)}}),cpA=(t,A)=>{let j=t.obs_store?.manual_cat?.[A];if(!j)return null;let e=j.getAttribute()||t.manual_cat?.config?.[A]?.attribute||"Manual",r=j.getAssignments()||{},n={};Object.values(r).forEach(o=>{if(o!=null&&o!==""){let l=String(o);n[l]=(n[l]||0)+1}});let i=Object.entries(n).map(([o,l])=>({name:o,value:l})).sort((o,l)=>l.value-o.value);return{attr_name:e,attr_index:0,data:i}},Dz=(t,A)=>{let j=t.attr?.cats?.row||[],e=t.attr?.cats?.col||[],r=t.manual_cat?.flags?.row,n=t.manual_cat?.flags?.col;if(j.length===0&&e.length===0&&!r&&!n)return null;let i=apA();if(t.cat_bars={container:i,row:null,col:null},j.length>0||r){let o=j.length>0?F_(t,"row"):t.manual_cat?.config?.row?.attribute||"Manual",{wrapper:l,svg:c,title:B,bar_container:h}=Cz("row",`Row: ${o}`);if(i.appendChild(l),t.cat_bars.row={wrapper:l,svg:c,title:B,bar_container:h},j.length>0){let d=XI(t,"row");if(d&&d.data.length>0){let k=G_(t),{on_hover:g,on_hover_out:E}=ag(t,"row",d.attr_index);sg(c,d.data,k,m=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:"row",attr_name:d.attr_name,attr_index:d.attr_index,value:m.name})},g,E)}}}if(e.length>0||n){let o=e.length>0?F_(t,"col"):t.manual_cat?.config?.col?.attribute||"Manual",{wrapper:l,svg:c,title:B,bar_container:h}=Cz("col",`Col: ${o}`);if(i.appendChild(l),t.cat_bars.col={wrapper:l,svg:c,title:B,bar_container:h},e.length>0){let d=XI(t,"col");if(d&&d.data.length>0){let k=G_(t),{on_hover:g,on_hover_out:E}=ag(t,"col",d.attr_index);sg(c,d.data,k,m=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:"col",attr_name:d.attr_name,attr_index:d.attr_index,value:m.name})},g,E)}}}return t.obs_store?.dendro_selection&&t.obs_store.dendro_selection.subscribe(o=>{upA(t,o)},{immediate:!1}),t.obs_store?.hovered_category&&t.obs_store.hovered_category.subscribe(o=>{o?w_(t,o.value):w_(t,null)},{immediate:!1}),t.obs_store?.manual_cat&&["row","col"].forEach(o=>{let l=t.obs_store.manual_cat[o];l&&l.subscribe(()=>{if(t.cat_bars?.[o]?.svg){let c=cpA(t,o);if(c&&c.data.length>0){let B=G_(t),{on_hover:h,on_hover_out:d}=ag(t,o,0);sg(t.cat_bars[o].svg,c.data,B,g=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:o,attr_name:c.attr_name,attr_index:0,value:g.name})},h,d);let k=o==="row"?"Row":"Col";t.cat_bars[o].title.textContent=`${k}: ${c.attr_name}`}}},{immediate:!1})}),A.appendChild(i),i};function G_(t){let A={},j=r=>{if(!r||typeof r!="string")return null;let n=r.replace("#","");return n.length!==6?null:[parseInt(n.substring(0,2),16),parseInt(n.substring(2,4),16),parseInt(n.substring(4,6),16)]};["row","col"].forEach(r=>{(t.attr?.all_defs?.[r]||[]).forEach(i=>{i.type==="categorical"&&i.color_map&&Object.entries(i.color_map).forEach(([o,l])=>{if(!A[o])if(typeof l=="string"){let c=j(l);c&&(A[o]=c)}else Array.isArray(l)&&(A[o]=l.slice(0,3))})})});let e=t.network?.global_cat_colors||t.global_cat_colors||{};return Object.entries(e).forEach(([r,n])=>{if(!A[r])if(typeof n=="string"){let i=j(n);i&&(A[r]=i)}else Array.isArray(n)&&(A[r]=n.slice(0,3))}),A}function upA(t,A){let j=G_(t);if(!A){["row","col"].forEach(n=>{if(t.cat_bars?.[n]){let i=XI(t,n);if(i&&i.data.length>0){let{on_hover:o,on_hover_out:l}=ag(t,n,i.attr_index);sg(t.cat_bars[n].svg,i.data,j,h=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:n,attr_name:i.attr_name,attr_index:i.attr_index,value:h.name})},o,l);let c=F_(t,n),B=n==="row"?"Row":"Col";t.cat_bars[n].title.textContent=`${B}: ${c}`}}});return}let{axis:e,selected_names:r}=A;if(t.cat_bars?.[e]){let n=lpA(t,e,r);if(n&&n.data.length>0){let{on_hover:i,on_hover_out:o}=ag(t,e,n.attr_index);sg(t.cat_bars[e].svg,n.data,j,h=>{t.obs_store?.selected_category&&t.obs_store.selected_category.set({axis:e,attr_name:n.attr_name,attr_index:n.attr_index,value:h.name})},i,o);let l=F_(t,e),c=e==="row"?"Row":"Col",B=n.data.reduce((h,d)=>h+d.value,0);t.cat_bars[e].title.textContent=`${c}: ${l} (${B})`}}}var zI=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.style.border="1px solid #d3d3d3",t.className="ui_container",t.style.height="100px",t.style.boxSizing="border-box",t.style.width="100%",t.style.maxWidth="100%",t.style.margin="0 auto",t},Nz=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.className="ctrl_container",t.style.width="100%",t},a6=(t,A,j=null)=>{let e=document.createElement("div");return e.className=t,e.style.display="flex",e.style.flexDirection=A,j!==null&&(e.style.height=`${j}px`,e.style.overflow="scroll"),e},lg=t=>{let A=document.createElement("div");return A.className=t,A.style.width="100%",A.style.marginLeft="2px",A.style.marginTop="2px",A},BpA=(t,A)=>{let j=A==="row"?t.row_entity:t.col_entity,e=A==="row"?"Row":"Col";if(j&&j.entity){let{entity:r}=j;return!r||r==="N.A."||r==="n.a."?e:{gene:"Gene",cell:"Cell",nbhd:"Nbhd",cluster:"Clust",hextile:"Hex"}[r]||r.substring(0,4).toUpperCase()}return e},Kz=(t,A,j)=>{let e=zI(),r=a6("button_container","column"),n=a6("slider_container","column"),i=34,o=28,l=["col","row"],c=["clust","sum","var","ini"];l.forEach(h=>{let d=a6(h,"row"),k=BpA(j,h);VA(d).append("div").text(k).style("width",`${o}px`).style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","9px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color","white").style("border-radius","8px").style("margin-top","4px").style("margin-left","3px").style("padding","2px 2px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif'),c.forEach(g=>{Mz(d,g,g==="clust",i,h,t,A,j)}),r.appendChild(d)}),j.dendro.sliders={};let B=(h,d,k,g)=>{d.dendro.sliders[`${k}_value`]=d.dendro.max_linkage_dist[k]*g.target.value/100,DI(d,k,d.dendro.sliders[`${k}_value`]),NI(d,k),ig(d,k),Pz(A,d,k),h.setProps({layers:le(A)})};return l.forEach(h=>{let d=document.createElement("input");j.dendro.sliders[h]=d,Df(d,50,g=>B(t,j,h,g))}),j.dendro.sliders.col.style.marginTop="3px",j.dendro.sliders.row.style.marginTop="10px",VA(n).append("div").text("Dendro").style("width","40px").style("height","16px").style("display","inline-flex").style("align-items","center").style("justify-content","center").style("text-align","center").style("cursor","pointer").style("font-size","10px").style("font-weight","bold").style("color","#47515b").style("border","2px solid").style("border-color","white").style("border-radius","8px").style("margin-left","10px").style("user-select","none").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif'),n.appendChild(j.dendro.sliders.col),n.appendChild(j.dendro.sliders.row),r.style.marginTop="10px",n.style.marginTop="0px",n.style.marginLeft="5px",e.appendChild(r),e.appendChild(n),Dz(j,e),e},Xz=(t,A,j)=>{let e=zI(),r=Nz(),n=a6("image_container","row"),i=a6("tile_container","row"),o=lg("tile_slider_container");return kn(n,"sst","IMG","blue",50,"button",t,A,j),kn(i,"sst","TILE","blue",50,"button",t,A,j),j.sliders={},kl("tile",t,A,j),o.appendChild(j.sliders.tile),e.appendChild(r),i.appendChild(o),og("sst",t,A,j),j.obs_store.selected_genes.subscribe(async l=>{if(l.length===1){let c=l[0];if(j.genes.gene_search_input.value=c,c!==""){if(j.genes.gene_names.includes(c)){j.genes.gene_text_box.textContent="loading",await nu(c);let B=A7[c];B&&B.name&&B.description?j.genes.gene_text_box.innerHTML=`${B.name}
${B.description}`:j.genes.gene_text_box.textContent=""}}else j.genes.gene_text_box.textContent="";j.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else l.length===0&&(j.genes.gene_search_input.value="",j.genes.gene_text_box.textContent="")}),r.appendChild(n),r.appendChild(i),r.appendChild(j.genes.gene_search),e},zz=(t,A,j,e)=>{let r=zI(),n=Nz();e.containers.image=a6("image_container","column");let i=a6("img_layers_container","column",72);i.style.width="135px",i.style.border="1px solid #d3d3d3",i.style.marginTop="3px",i.style.marginLeft="2px",i.addEventListener("wheel",X=>{let{scrollTop:T,scrollHeight:Q,clientHeight:b}=i,jA=T===0,pA=T+b===Q;(jA&&X.deltaY<0||pA&&X.deltaY>0)&&X.preventDefault()});let o="115px",l=a6("cell_container","column");l.style.width=o;let c=a6("cell_ctrl_container","row");c.style.marginLeft="0px";let B=a6("gene_container","column");B.style.marginTop="0px",B.style.width=o;let h=a6("trx_container","row"),d,k;e.nbhd.is_nbhd&&(d=a6("nbhd_container","column"),d.style.width=o,k=a6("nbhd_ctrl_container","row"),k.style.marginLeft="0px",k.style.height="22.5px");let g=lg("cell_slider_container"),E=lg("trx_slider_container"),m;e.nbhd.is_nbhd&&(m=lg("nbhd_slider_container"));let{technology:y}=e.img.landscape_parameters,G=y==="Chromium",v=y==="point-cloud";if(!v){let X=a6("image_layer_container","row");if(G)kn(X,"ist","UMAP","blue",35,"button",A,j,e);else{if(e.umap.has_umap===!0){let jA=e.obs_store.umap_state.get(),pA,dA;jA===!0?(pA="blue",dA="gray"):(pA="gray",dA="blue"),kn(X,"ist","UMAP",pA,35,"button",A,j,e),kn(X,"ist","SPATIAL",dA,50,"button",A,j,e)}kn(X,"ist","IMG","blue",30,"button",A,j,e)}e.containers.image.appendChild(X);let T=Sz(e,A,j);T&&X.appendChild(T);let Q=(jA,pA)=>jA.image_layer_sliders.filter(dA=>dA.name===pA),b=(jA,pA)=>{let dA=pA.button_name,$A=a6("image_layer_container","row");$A.style.height="21px";let _A=e.obs_store.umap_state.get()?"gray":"blue";kn($A,"ist",dA,_A,75,"img_layer_button",A,j,e);let Y=lg(dA),QA=Q(jA,dA)[0],mt=g_(dA,A,j,e),SA=Sf(mt,100);Df(QA,50,SA),Y.appendChild(QA),$A.appendChild(Y),i.appendChild($A)};e.img.image_info.map(jA=>b(e.img,jA)),e.obs_store.viz_image_layers.subscribe(jA=>{VA(e.containers.image).selectAll(".img_layer_button").style("color",jA?"blue":"gray"),e.img.image_layer_sliders.map(pA=>Rj(pA,jA)),Cf(j,jA),TA(e,j,"image_layers"),jA&&e.obs_store.umap_state.get()&&e.obs_store.landscape_view.set("spatial")}),e.obs_store.viz_background_layer.subscribe(jA=>{c_(j,jA),TA(e,j,"background_layer")}),e.obs_store.viz_nbhd_layer.subscribe(jA=>{pl(j,jA),TA(e,j,"nbhd_layer")}),e.containers.image.appendChild(i)}kn(c,"ist","CELL","blue",40,"button",A,j,e),e.nbhd.is_nbhd&&!e.nbhd.edit&&kn(k,"ist","NBHD","gray",40,"button",A,j,e),kn(h,"ist","TRX","blue",40,"button",A,j,e),e.sliders={},kl("cell",A,j,e),g.appendChild(e.sliders.cell),c.appendChild(g),e.nbhd.is_nbhd&&!e.nbhd.edit&&(kl("nbhd",A,j,e),m.appendChild(e.sliders.nbhd),k.appendChild(m),Rj(e.sliders.nbhd,e.obs_store.viz_nbhd_layer.get())),e.containers.bar_cluster=ju(),e.cats.svg_bar_cluster=Ur("svg"),e.genes.svg_bar_gene=Ur("svg"),e.nbhd.is_nbhd&&(e.nbhd.svg_bar_nbhd=Ur("svg")),Za(e.containers.bar_cluster,Nf,e.cats.svg_bar_cluster,e.cats.cluster_counts,e.cats.color_dict_cluster,A,j,e),e.containers.bar_gene=ju();let _=1e3;e.genes.gene_counts=e.genes.gene_counts.sort((X,T)=>T.value-X.value).slice(0,_),Za(e.containers.bar_gene,Kf,e.genes.svg_bar_gene,e.genes.top_gene_counts,e.genes.color_dict_gene,A,j,e);let w=(X,T)=>Q=>{if(!Array.isArray(Q)||Q.length===0)X.selectAll("g").attr("font-weight","normal").attr("opacity",1),T.scrollTo({top:0,behavior:"smooth"});else if(X.selectAll("g").attr("font-weight",b=>Q.includes(b.name)?"bold":"normal").attr("opacity",b=>Q.includes(b.name)?1:.2),Q.length===1){let b=Q[0],jA=X.selectAll("g").filter(function(){return VA(this).select("text").text()===b});if(!jA.empty()){let pA=jA.node(),dA=T.getBoundingClientRect(),$A=pA.getBoundingClientRect(),_A=$A.top,Y=$A.bottom,QA=dA.top,mt=dA.bottom;if(!(_A>=QA&&Y<=mt)){let SA=_A-QA,ft=T.scrollTop+SA;T.scrollTo({top:ft,behavior:"smooth"})}}}};e.obs_store.selected_cats.subscribe(w(e.cats.svg_bar_cluster,e.containers.bar_cluster),{immediate:!1}),e.obs_store.selected_genes.subscribe(w(e.genes.svg_bar_gene,e.containers.bar_gene),{immediate:!1});let x=({svg:X,color_dict:T,selected_array:Q,bar_callback:b,container:jA})=>pA=>{let $A=15*(pA.length+1);X.attr("height",$A);let _A=90,Y=pA.map(wA=>wA.value),QA=ti().domain(F6(Y.length)).range([0,16*Y.length]),mt=ji().domain([0,xj(Y)]).range([0,_A]),Ct=X.selectAll("g").data(pA,wA=>wA.name),SA=Ct.enter().append("g").attr("transform",(wA,_t)=>`translate(2,${QA(_t)+2})`).on("click",(wA,_t)=>b(wA,_t,A,j,e));SA.append("rect").attr("width",0).attr("height",QA.bandwidth()-1).transition().duration(750).attr("width",wA=>mt(wA.value)),SA.append("text").attr("fill","black").attr("x","5px").attr("y",QA.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").attr("opacity",0).text(wA=>wA.name).transition().duration(750).attr("opacity",1);let ft=Ct.merge(SA);ft.transition().duration(750).attr("transform",(wA,_t)=>`translate(2,${QA(_t)+2})`),ft.select("rect").attr("width",wA=>mt(wA.value)).attr("fill",wA=>{let _t=T[wA.name]||[0,0,0],qA=Q.length===0||Q.includes(wA.name)?1:.1;return`rgba(${_t[0]}, ${_t[1]}, ${_t[2]}, ${qA})`}),ft.select("text").text(wA=>wA.name),Ct.exit().transition().duration(750).attr("opacity",0).remove(),jA&&jA.scrollTo({top:0,behavior:"smooth"})};e.obs_store.new_cell_bar_data.subscribe(x({svg:e.cats.svg_bar_cluster,color_dict:e.cats.color_dict_cluster,selected_array:e.cats.selected_cats,bar_callback:Nf,container:e.containers.bar_cluster}),{immediate:!1}),e.obs_store.new_gene_bar_data.subscribe(x({svg:e.genes.svg_bar_gene,color_dict:e.genes.color_dict_gene,selected_array:e.genes.selected_genes,bar_callback:Kf,container:e.containers.bar_gene}),{immediate:!1}),l.appendChild(c),l.appendChild(e.containers.bar_cluster),kl("trx",A,j,e),h.appendChild(E),E.appendChild(e.sliders.trx),B.appendChild(h),B.appendChild(e.containers.bar_gene),og("ist",A,j,e),e.genes.gene_search.style.marginLeft="0px",e.obs_store.selected_genes.subscribe(async X=>{if(X.length===1){let T=X[0];if(e.genes.gene_search_input.value=T,T!==""){if(e.genes.gene_names.includes(T)){e.genes.gene_text_box.textContent="loading",await nu(T);let Q=A7[T];Q&&Q.name&&Q.description?e.genes.gene_text_box.innerHTML=`${Q.name}
${Q.description}`:e.genes.gene_text_box.textContent=""}}else e.genes.gene_text_box.textContent="";e.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else X.length===0&&(e.genes.gene_search_input.value="",e.genes.gene_text_box.textContent="")}),r.appendChild(n),v||n.appendChild(e.containers.image),n.appendChild(l),n.appendChild(B),e.genes.gene_search.style.width="160px",e.genes.gene_search.style.marginLeft="5px";let O=(X,T)=>(T>=0&&T{b.edit.feature_collection=O(b.edit.feature_collection,b.edit.modify_index),b.edit.modify_index=null,Q.edit_layer=Q.edit_layer.clone({id:"edit-layer-delete",data:b.edit.feature_collection,mode:Xr,selectedFeatureIndexes:[]});let jA=Wr(Q,b.close_up);T.setProps({layers:jA}),VA(b.edit.buttons.del).classed("active",!1).style("display","none"),VA(b.edit.buttons.nbhd).style("display","inline-flex"),VA(b.edit.buttons.sktch).style("display","inline-flex"),zf(b,T,Q),Xf(b)};if(e.nbhd.is_nbhd){e.edit=e.edit||{},e.edit.buttons={},e.edit.mode="view";let X=(Q,b,jA,pA)=>{let dA=pA.obs_store.viz_edit_layer.get();pA.obs_store.viz_edit_layer.set(!dA)},T=(Q,b,jA,pA)=>{let dA=VA(Q.currentTarget);dA.classed("active")===!1?(dA.classed("active",!0).style("color","blue"),pA.edit.mode="sktch",Uf(jA,Ai),tu(jA,!1),Jc(jA,!1),Zc(jA,!1)):(pA.edit.mode="view",dA.classed("active",!1).style("color","gray"),Uf(jA,Xr),tu(jA,!0),Jc(jA,!0),Zc(jA,!0));let _A=Wr(jA,pA.close_up);b.setProps({layers:_A})};e.nbhd.edit&&__(A,j,e,k,"NBHD",40,X),__(A,j,e,k,"SKTCH",40,T),VA(e.edit.buttons.sktch).style("display","none"),__(A,j,e,k,"DEL",30,F),VA(e.edit.buttons.del).style("color","red").style("display","none"),e.edit.buttons.nbhd&&(e.buttons.buttons.nbhd=e.edit.buttons.nbhd)}e.nbhd.is_nbhd&&(e.containers.bar_nbhd=ju(),e.containers.bar_nbhd.style.marginLeft="0px",d.appendChild(k),d.appendChild(e.containers.bar_nbhd),n.appendChild(d),e.nbhd.is_nbhd&&(Za(e.containers.bar_nbhd,m_,e.nbhd.svg_bar_nbhd,e.nbhd.bar_data,e.nbhd.color_dict,A,j,e),e.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2))),n.appendChild(e.genes.gene_search);let C=document.createElement("div");C.className="logo_button",C.style.marginTop="5px",C.style.marginRight="5px",C.style.cursor="pointer";let R=document.createElement("img");return R.src=`data:image/png;base64,${b_}`,R.alt="Celldega logo",R.style.height="17px",R.style.transition="transform 0.2s ease, filter 0.2s ease",C.onclick=()=>{window.open("https://broadinstitute.github.io/celldega/","_blank")},C.appendChild(R),r.appendChild(C),r};var P_={Xenium:.2125,MERSCOPE:.108},I_=(t,A)=>{let j=A||"",e=["Visium-HD"],r=["Xenium","MERSCOPE"],n=e.includes(j)?"black":(r.includes(j),"white"),i=n==="white"?"black":"white",o=document.createElement("div");o.style.position="absolute",o.style.bottom="10px",o.style.left="10px",o.style.backgroundColor="transparent",o.style.color=n,o.style.padding="6px 8px",o.style.fontSize="12px",o.style.lineHeight="1.2",o.style.display="flex",o.style.flexDirection="column",o.style.alignItems="flex-start",o.style.pointerEvents="none",o.style.zIndex="10",o.style.opacity="0.5";let l=document.createElement("div");l.textContent="1 \xB5m";let c=document.createElement("div");c.style.height="2px",c.style.backgroundColor=n,c.style.outline=`1px solid ${i}`,c.style.marginTop="4px",c.style.width="80px",n==="white"&&(o.style.textShadow="0 0 3px black"),o.appendChild(l),o.appendChild(c);let B=k=>{if(k>=1e3){let g=k/1e3;if(g>=10)return`${Math.round(g)} mm`;if(g>=1)return`${Number(g.toFixed(1))} mm`}return k>=100?`${Math.round(k)} \xB5m`:k>=10?`${Number(k.toFixed(1))} \xB5m`:`${Number(k.toPrecision(2))} \xB5m`};return{container:o,update:({zoom:k})=>{let g=Math.pow(2,k||0),E=t/g,y=E*100,G=Math.min(y,1e3),v=Math.pow(10,Math.floor(Math.log10(G))),_=G/v,w=1;_>5?w=10:_>2?w=5:_>1&&(w=2);let x=w*v,O=x/E;l.textContent=B(x),c.style.width=`${O}px`},setVisible:k=>{o.style.display=k?"flex":"none"}}};var Uz=(t,A,j)=>{let e=j.model.get("cell_clusters");qz(j.cats,e.meta_cluster),VX(j.cats,e.new_clusters),j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1}),j.layers_obj=A,j.obs_store.deck_check.set({...j.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0}),j.combo_data.cell=j.combo_data.cell.map(r=>({...r,cat:j.cats.dict_cell_cats[r.name]}))};var Wz=(t,A)=>{if(!A.cell_name_prefix||typeof t!="string")return t;let j=t.indexOf("_");return j>=0?t.substring(j+1):t},Vz=(t,A)=>A.cell_name_prefix?t.map(j=>Wz(j,A)):t,Qz=(t,A)=>{t.highlighted_cells=new Set,t.obs_store.selected_cells.set([]),gt(t.cats,"cluster"),Rt(t.cats,[],t.obs_store),Wt(t.genes,[],t.obs_store),t.obs_store.viz_nbhd_layer.set(!1),t.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(t,A,"cell_layer")},iu=t=>t?t.row_entity==="cell_cluster"?!0:t.entity==="cell"?["leiden","cluster","cell_type","cell_cluster"].includes(t.attr):!1:!1,ou=t=>t?t.col_entity==="nbhd"?!0:t.entity==="nbhd"||t.entity==="hextile":!1,UI=t=>t?t.entity==="gene":!1,VI=t=>t?t.entity==="cell"&&t.attr==="name":!1,Yz=async(t,A,j)=>{let e=j.model.get("update_trigger");if(!e||typeof e!="object")return;let r={type:e.type||e.click_type,value:e.value||e.click_value},n=r.type?.replace("-","_");if(!n)return;let i,o;try{if(n==="row_label")if(ou(r.value)){let l=r.value.name,c=j.obs_store.selected_nbhds.get();c.length===1&&c[0]===l?(j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1)):(j.obs_store.selected_nbhds.set([l]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",h=>h.name===l?1:.2),j.nbhd?.svg_bar_nbhd?.selectAll("rect").filter(h=>h.name===l).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else iu(r.value)?(i="cluster",o=r.value.name,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[o],j.obs_store),Wt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")):(i=r.value.name,o=i===j.cats.cat?"cluster":i,j.highlighted_cells=new Set,gt(j.cats,o),Wt(j.genes,[i],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,i,j.seg.version,j.vector_name_integer,j.aws,j.row_group_readers?.cbg),j.obs_store.selected_cells.set([]),Rt(j.cats,o==="cluster"?[]:[i],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"));else if(n==="col_label")if(ou(r.value)){let l=r.value.name,c=j.obs_store.selected_nbhds.get();c.length===1&&c[0]===l?(j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1)):(j.obs_store.selected_nbhds.set([l]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",h=>h.name===l?1:.2),j.nbhd?.svg_bar_nbhd?.selectAll("rect").filter(h=>h.name===l).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(VI(r.value)){let l=Wz(r.value.name,j);j.obs_store.selected_cells.set([l]),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else i="cluster",o=r.value.name,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[o],j.obs_store),Wt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"nbhd_layer"),TA(j,A,"trx_layer");else if(n==="col_dendro"){let l=r.value.selected_names||[];if(r.value.is_unselecting||l.length===0){j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1),Qz(j,A),TA(j,A,"nbhd_layer");return}let B=r.value.col_entity_full||r.value;if(ou(B))if(j.obs_store.selected_nbhds.set(l),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),j.obs_store.selected_nbhds.get().length>0){let h=j.obs_store.selected_nbhds.get();j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",d=>h.includes(d.name)?1:.2),j.nbhd.svg_bar_nbhd.selectAll("rect").filter(d=>h.includes(d.name)).node()?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})}else j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1);else if(VI(B)){let h=Vz(l,j);j.obs_store.selected_cells.set(h),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,l,j.obs_store),Wt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else if(n==="row_dendro"){let l=r.value.selected_names||[];if(r.value.is_unselecting||l.length===0){j.obs_store.selected_nbhds.set([]),j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",1),Qz(j,A),TA(j,A,"trx_layer"),TA(j,A,"nbhd_layer");return}let B=r.value.row_entity_full||r.value;ou(B)?(j.obs_store.selected_nbhds.set(l),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),j.nbhd?.svg_bar_nbhd&&j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",h=>l.includes(h.name)?1:.2)):iu(B)?(j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,l,j.obs_store),Wt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"),TA(j,A,"nbhd_layer")):UI(B)&&(j.genes.selected_genes=l,j.obs_store.selected_genes.set(l),l.length===1?(i=l[0],o=i===j.cats.cat?"cluster":i,j.highlighted_cells=new Set,gt(j.cats,o),await qr(j.cats,j.genes,j.global_base_url,i,j.seg.version,j.vector_name_integer,j.aws),j.obs_store.selected_cells.set([]),Rt(j.cats,o==="cluster"?[]:[i],j.obs_store)):(j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[],j.obs_store)),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer"))}else if(n==="cat_value"){let{axis:l,attr_name:c,value:B,node_names:h}=r.value,{col_entity_full:d}=r.value;if(l==="col"&&VI(d)){let k=Vz(h||[],j);j.obs_store.selected_cells.set(k),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer")}else l==="col"&&(j.obs_store.selected_cells.set([]),gt(j.cats,"cluster"),Rt(j.cats,[B],j.obs_store),Wt(j.genes,[],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"))}else if(n==="mat_value"){let{row:l,col:c,row_entity_full:B,col_entity_full:h}=r.value,d=B||l,k=h||c,g=(E,m)=>E?.entity===m?.entity&&E?.attr===m?.attr;if(iu(d)&&ou(k)){let E=[c.name];if(j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),gt(j.cats,"cluster"),Rt(j.cats,[l.name],j.obs_store),TA(j,A,"cell_layer"),j.obs_store.selected_nbhds.get().length>0){let m=j.obs_store.selected_nbhds.get();j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",y=>m.includes(y.name)?1:.2)}}else if(g(d,k)&&iu(d)){j.obs_store.selected_cells.set([]),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),gt(j.cats,"cluster");let E=[l.name,c.name];Rt(j.cats,E,j.obs_store),Wt(j.genes,[],j.obs_store),TA(j,A,"cell_layer")}else if(UI(d)&&iu(k)){let E=l.name,m=c.name;j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,E),Wt(j.genes,[E],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,E,j.seg.version,j.vector_name_integer,j.aws),Rt(j.cats,[m],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(iu(d)&&UI(k)){let E=l.name,m=c.name;j.highlighted_cells=new Set,j.obs_store.selected_cells.set([]),gt(j.cats,m),Wt(j.genes,[m],j.obs_store),await qr(j.cats,j.genes,j.global_base_url,m,j.seg.version,j.vector_name_integer,j.aws),Rt(j.cats,[E],j.obs_store),j.obs_store.viz_nbhd_layer.set(!1),j.buttons?.buttons?.nbhd?.style?.("color","gray"),TA(j,A,"cell_layer"),TA(j,A,"trx_layer")}else if(ou(d)&&iu(k)){let E=[l.name];if(j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),gt(j.cats,"cluster"),Rt(j.cats,[c.name],j.obs_store),TA(j,A,"cell_layer"),j.obs_store.selected_nbhds.get().length>0){let m=j.obs_store.selected_nbhds.get();j.nbhd?.svg_bar_nbhd?.selectAll("rect").style("opacity",y=>m.includes(y.name)?1:.2)}}else if(g(d,k)&&ou(d)){let E=[l.name,c.name];j.obs_store.selected_nbhds.set(E),j.obs_store.viz_nbhd_layer.set(!0),j.buttons?.buttons?.nbhd?.style?.("color","blue"),TA(j,A,"nbhd_layer"),TA(j,A,"cell_layer"),j.nbhd?.svg_bar_nbhd&&j.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",m=>E.includes(m.name)?1:.2)}}}catch(l){Zj(l,{context:"updating IST landscape from CGM",logUnexpected:!0,throwOnAuth:!1})}};async function fpA(t,A){let j=t.img.landscape_parameters;if(!j.use_row_groups){t.use_row_groups=!1;return}let e=j.row_group_files||{},r=j.tile_grid||{};if(!r.num_tiles_x||!r.num_tiles_y){t.use_row_groups=!1;return}if(t.use_row_groups=!0,t.row_group_readers={},t.tile_grid=r,e.transcripts&&(t.row_group_readers.trx=new ml(A,r,e.transcripts),await t.row_group_readers.trx.initialize()),e.cell_segmentation&&(t.row_group_readers.cell=new ml(A,r,e.cell_segmentation),await t.row_group_readers.cell.initialize()),e.cbg&&(t.row_group_readers.cbg=new Ah(A,e.cbg),await t.row_group_readers.cbg.initialize()),e.images){t.row_group_readers.images={};for(let[n,i]of Object.entries(e.images))t.row_group_readers.images[n]=new th(A,i),await t.row_group_readers.images[n].initialize()}}var QI=async(t,A,j,e,r,n,i,o,l="",c=.25,B=0,h=800,d={},k=[],g={},E=[],m={},y={},G=!1,v="spatial",_="default",w={},x=null,O=0,F=0,C=0,R=50,X=null,T=[],Q=!1)=>{B===0&&(B="100%");let b={};b.obs_store=Zf(),b.highlighted_cells=new Set,b.selection_token=0;let jA=typeof A?.get=="function"?A.get("selected_cells")||[]:[];if(Array.isArray(jA)&&(b.highlighted_cells=new Set(jA),b.obs_store.selected_cells.set(jA)),b.max_tiles_to_view=R,b.update_viz_image_layers=b.obs_store.setup_image_visibility_manager(Iz),b.seg={},b.seg.version=_,b.root=t,b.buttons={},b.buttons.blue="#8797ff",b.buttons.gray="gray",b.buttons.light_gray="#EEEEEE",b.buttons.buttons={},Es(b,o),b.base_urls=T,b.cell_name_prefix=Q,b.close_up=!1,b.model=A,b.nbhd={},b.nbhd.visible=!1,b.nbhd.edit=G,b.spatial={},"accessKeyId"in w){b.aws=new Yo({accessKeyId:w.accessKeyId,secretAccessKey:w.secretAccessKey,sessionToken:w.sessionToken,region:"us-east-1",service:"s3"});let xA=await b.aws.fetch(`${o}/landscape_parameters.json`);if(!xA.ok)throw new Error(`Fetch failed: ${xA.statusText}`)}else b.aws=null;if(Object.keys(y).length===0)b.nbhd.is_nbhd=G,b.nbhd.ini_feature_collection={type:"FeatureCollection",features:[],inst_alpha:null},b.nbhd.feature_collection=b.nbhd.ini_feature_collection;else{b.nbhd.is_nbhd=!0,b.nbhd.ini_feature_collection=y;let xA=new Set(y.features.map(fA=>fA.properties.cat));b.nbhd.bar_data=Array.from(xA).map(fA=>{let RA=y.features.filter(bt=>bt.properties.cat===fA).reduce((bt,EA)=>bt+EA.properties.area,0);return{name:fA,value:RA}}).sort((fA,PA)=>PA.value-fA.value),b.nbhd.color_dict={},y.features.forEach(fA=>{let PA=ng(fA.properties.color);b.nbhd.color_dict[fA.properties.cat]=PA}),b.nbhd.feature_collection={type:"FeatureCollection",features:y.features}}b.containers={},b.containers.root_dim={},b.containers.root_dim.width=B,b.containers.root_dim.height=h,b.custom_callbacks={},b.custom_callbacks.view_change=x,b.cats={},b.cats.cat=null,b.cats.reset_cat=!1,b.cats.selected_cats=[],b.cats.cell_cats=[],b.cats.dict_cell_cats={},b.cats.color_dict_cluster={},b.cats.cluster_counts=[],b.cats.polygon_cell_names=[],Object.keys(d).length===0?b.cats.has_meta_cell=!1:b.cats.has_meta_cell=!0,b.cats.meta_cell=d,b.cats.meta_cell_attr=k,b.cats.meta_cell_id_set=new Set(Object.keys(d||{}).map(xA=>String(xA))),b.cats.inst_cell_attr=k[0]||"N.A.",Object.keys(g).length===0?b.cats.has_meta_cluster=!1:b.cats.has_meta_cluster=!0,b.cats.meta_cluster=g,b.cats.meta_cluster_attr=E,b.cats.inst_cluster_attr=E[0]||"N.A.",b.umap={},Object.keys(m).length===0?b.umap.has_umap=!1:b.umap.has_umap=!0,b.umap.umap=m;let pA=v==="umap";b.obs_store.umap_state.set(pA),b.obs_store.landscape_view.set(v),b.genes={},b.genes.color_dict_gene={},b.genes.gene_names=[],b.genes.meta_gene={},b.genes.gene_counts=[],b.genes.selected_genes=[],b.genes.trx_ini_radius=c,b.genes.trx_names_array=[],b.genes.trx_data=[],b.genes.gene_text_box="",b.genes.trx_slider=document.createElement("input"),b.genes.gene_search=document.createElement("div"),b.cats.cell_exp_array=[],b.cats.cell_names_array=[],b.cats.cell_name_to_index_map=new Map,b.img={},b.img.image_layer_colors={},b.img.image_layer_sliders={},Z7(j),await xs(b.img,o,b.aws);let dA=b.img.landscape_parameters.technology;(dA==="Chromium"||dA==="point-cloud")&&(b.obs_store.viz_image_layers.set(!1),b.obs_store.viz_background_layer.set(!1)),await fpA(b,o);let $A=b.img.landscape_parameters.image_info,_A=$A[0].name;b.vector_name_integer=b.img.landscape_parameters.use_int_index,Qf(b.img,b.img.landscape_parameters.image_format),Wf(b.img,$A),Hf(b.img),Yf(b.img.image_layer_colors,b.img.image_info);let Y=document.createElement("div");Y.style.position="relative",Y.style.height=`${h}px`,Y.style.border="1px solid #d3d3d3";let QA=typeof X=="number"&&!Number.isNaN(X)&&X>0?X:null,Ct=P_[dA]??QA;Ct&&(b.scale_bar=I_(Ct,dA),Y.appendChild(b.scale_bar.container)),b.scale_bar&&b.obs_store.scale_bar_view_state.subscribe(xA=>{xA&&b.scale_bar?.update&&b.scale_bar.update(xA)},{immediate:!1}),dA==="Chromium"||dA==="point-cloud"?b.dimensions={width:1,height:1,tileSize:1}:await $s(b,o,_A);let SA=b.dimensions?.width?b.dimensions.width/2:0,ft=b.dimensions?.height?b.dimensions.height/2:0;b.rotation=aD(C,[SA,ft]),await gl(b.genes,o,b.seg.version,b.aws),await Jf(b),b.views=nf(dA);let wA=await s_(Y,B,h,dA);if(a_(wA,b.views),b.cache={},b.cache.cell=await Vf(),b.cache.trx=await Vf(),b.combo_data={},b.tooltip_cat_cell="",l_(wA,b),b.edit={},b.edit.svg_bar_rgn=Ur("svg"),b.edit.rgn_areas=[],b.edit.color_dict_rgn={},b.edit.rgn_opacity=.3,b.edit.visible=!1,b.edit.modify_index=null,b.model?.get?Object.keys(b.model.get("region")).length===0?b.edit.feature_collection={type:"FeatureCollection",features:[]}:b.edit.feature_collection=b.model.get("region"):b.edit.feature_collection={type:"FeatureCollection",features:[]},G&&Object.keys(y).length>0&&y.features?.length>0){b.edit.feature_collection={type:"FeatureCollection",features:y.features.map((fA,PA)=>({...fA,properties:{...fA.properties,color:fA.properties.color||"#808080",name:fA.properties.name||(PA+1).toString(),cat:fA.properties.cat||(PA+1).toString()}}))};let xA=new Set(b.edit.feature_collection.features.map(fA=>fA.properties.cat));b.nbhd.bar_data=Array.from(xA).map(fA=>{let RA=b.edit.feature_collection.features.filter(bt=>bt.properties.cat===fA).reduce((bt,EA)=>bt+(EA.properties.area||0),0);return{name:fA,value:RA}}).sort((fA,PA)=>PA.value-fA.value),b.nbhd.color_dict={},b.edit.feature_collection.features.forEach(fA=>{let{color:PA}=fA.properties;b.nbhd.color_dict[fA.properties.cat]=ng(PA)})}let _t=Rf(b),qA=await k_(b),Ht=await d_(o,b),GA=await t_(b),l6=r_(b),Tt=xz(b),me=Bz(b,!0),FA={background_layer:_t,image_layers:qA,cell_layer:Ht,path_layer:GA,trx_layer:l6,nbhd_layer:me,edit_layer:Tt},yj=()=>{let xA=b.cats.selected_cats.join("-");FA.cell_layer=FA.cell_layer.clone({id:`cell-layer-${xA}-sel-${b.selection_token}`,updateTriggers:{...FA.cell_layer.props.updateTriggers,getPosition:[b.obs_store.umap_state.get()],getFillColor:[b.selection_token]}}),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1}),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!0})};b.layers_obj=FA,b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),nbhd_layer:!0,edit_layer:!0}),b.obs_store.selected_nbhds.subscribe(xA=>{let fA=xA.join("-");FA.nbhd_layer=FA.nbhd_layer.clone({id:`nbhd-layer-${fA}`})},{immediate:!1}),b.obs_store.viz_nbhd_layer.subscribe(xA=>{xA?(Au(b.layers_obj,!1),b.genes.svg_bar_gene.selectAll("rect").style("opacity",.2),b.cats.svg_bar_cluster.selectAll("rect").style("opacity",.2),b.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",1),b.buttons.buttons.cell.style("color","gray"),b.buttons.buttons.trx.style("color","gray"),b.buttons.buttons.nbhd?.style("color","blue"),Rj(b.sliders.cell,!1),Rj(b.sliders.trx,!1),b.nbhd.is_nbhd&&Rj(b.sliders.nbhd,!0)):(Au(b.layers_obj,!0),b.genes.svg_bar_gene.selectAll("rect").style("opacity",1),b.cats.svg_bar_cluster.selectAll("rect").style("opacity",1),b.nbhd.svg_bar_nbhd.selectAll("rect").style("opacity",.2),b.buttons.buttons.cell.style("color","blue"),b.buttons.buttons.trx.style("color","blue"),b.buttons.buttons.nbhd?.style("color","gray"),Rj(b.sliders.cell,!0),Rj(b.sliders.trx,!0),b.nbhd.is_nbhd&&Rj(b.sliders.nbhd,!1)),xA&&b.obs_store.viz_edit_layer.set(!1)},{immediate:!1}),p_(wA,FA,b),e_(wA,FA,b),n_(wA,FA,b),yz(wA,FA,b),vz(wA,FA,b),hz(wA,FA,b),b.obs_store.deck_ready.subscribe(xA=>{if(xA){let fA=Wr(b.layers_obj,b.close_up);wA.setProps({layers:fA})}}),b.obs_store.viz_edit_layer.subscribe(xA=>{_z(FA,xA),xA?(b.obs_store.viz_nbhd_layer.set(!1),pl(FA,!1),Ts(FA,!1),b.buttons.buttons.trx.style("color","gray"),VA(b.edit.buttons.nbhd).style("color","blue"),VA(b.edit.buttons.sktch).style("display","inline-flex").style("color","gray").classed("active",!1),b.nbhd.edit&&b.containers.nbhd_opacity_slider&&(VA(b.containers.nbhd_opacity_slider).style("display","inline-flex"),Rj(b.sliders.nbhd_opacity,!0))):(Ts(FA,!0),b.buttons.buttons.trx.style("color","blue"),VA(b.edit.buttons.nbhd).style("color","gray").classed("active",!1),VA(b.edit.buttons.sktch).style("display","none").style("color","gray").classed("active",!1),Uf(FA,Xr),tu(FA,!0),Jc(FA,!0),Zc(FA,!0),b.nbhd.edit&&b.containers.nbhd_opacity_slider&&(VA(b.containers.nbhd_opacity_slider).style("display","none"),Rj(b.sliders.nbhd_opacity,!1))),TA(b,FA,"edit_layer")},{immediate:!1}),b.obs_store.selected_cats.subscribe(xA=>{let fA=xA.join("-");yj(),FA.path_layer=FA.path_layer.clone({id:`path-layer-${fA}`}),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),path_layer:!0})}),b.obs_store.selected_cells.subscribe(xA=>{b.highlighted_cells=new Set(xA??[]),b.selection_token+=1,yj()}),b.obs_store.selected_genes.subscribe(xA=>{let fA=xA.join("-");FA.trx_layer=FA.trx_layer.clone({id:`trx-layer-${fA}`}),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),trx_layer:!0})}),Tf(FA,c),b.obs_store.umap_state.get()===!0&&(b.obs_store.viz_background_layer.set(!1),b.obs_store.viz_image_layers.set(!1),Ts(FA,!1),Of(FA,!1)),nz(wA,e,r,n,i,b,O,F),rz(wA,FA,b),b.model?.on&&(b.model.on("change:update_trigger",()=>Yz(wA,FA,b)),b.model.on("change:cell_clusters",()=>Uz(wA,FA,b)),b.model.on("change:selected_cells",()=>{let xA=b.model.get("selected_cells")||[];b.obs_store.selected_cells.set(xA)}));let cj=zz(l,wA,FA,b);t.appendChild(cj),t.appendChild(Y),b.nbhd.edit&&(b.nbhd_editor=Gz(b,wA,FA));let ce=["Chromium","point-cloud"].includes(b.img.landscape_parameters.technology);b.obs_store.landscape_view.subscribe(xA=>{let fA=xA==="umap";b.obs_store.umap_state.set(fA),b.scale_bar&&b.scale_bar.setVisible(!fA),sz(wA,FA,b),fA?(b.buttons.buttons.umap.style("color","blue"),ce||(b.buttons.buttons.spatial.style("color","gray"),b.buttons.buttons.img.style("color","gray")),b.obs_store.viz_background_layer.set(!1),b.obs_store.viz_image_layers.set(!1),Ts(FA,!1),Of(FA,!1),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),b.layers_obj=FA,b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,trx_layer:!0})):(ce||(b.buttons.buttons.umap.style("color","gray"),b.buttons.buttons.spatial.style("color","blue"),b.buttons.buttons.img.style("color","blue")),Ts(FA,!0),Of(FA,!0),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),b.layers_obj=FA,b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0,trx_layer:!0}),setTimeout(()=>{b.obs_store.viz_background_layer.set(!0),b.obs_store.viz_image_layers.set(!0)},3e3))},{immediate:!1});let Uj={on_gene_select:[],on_cluster_select:[],on_clusters_select:[]};return{on_gene_select:xA=>{Uj.on_gene_select.push(xA)},on_cluster_select:xA=>{Uj.on_cluster_select.push(xA)},on_clusters_select:xA=>{Uj.on_clusters_select.push(xA)},update_matrix_gene:async xA=>{let PA=xA===b.cats.cat?"cluster":xA;gt(b.cats,PA),Wt(b.genes,[xA],b.obs_store),Rt(b.cats,PA==="cluster"?[]:[xA],b.obs_store),await qr(b.cats,b.genes,b.global_base_url,xA,b.seg.version,b.vector_name_integer,b.aws,b.row_group_readers?.cbg),b.layers_obj=FA,b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!0}),Uj.on_gene_select.forEach(RA=>RA(xA))},update_matrix_col:async xA=>{gt(b.cats,"cluster"),Rt(b.cats,[xA],b.obs_store),Wt(b.genes,[],b.obs_store),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),b.layers_obj=FA,Uj.on_cluster_select.forEach(fA=>fA(xA))},update_matrix_dendro_col:async xA=>{let fA=xA;gt(b.cats,"cluster"),Rt(b.cats,fA,b.obs_store),Wt(b.genes,[],b.obs_store),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),b.layers_obj=FA,Uj.on_clusters_select.forEach(PA=>PA(xA))},update_view_state:async(xA,fA,PA)=>{b.close_up=fA,o_(xA,wA,FA,b,b.obs_store),b.obs_store.deck_check.set({...b.obs_store.deck_check.get(),cell_layer:!1,path_layer:!1,trx_layer:!1}),wA.setProps({controller:{doubleClickZoom:!1},initialViewState:xA,views:b.views}),b.layers_obj=FA},update_layers:()=>{},finalize:()=>{wA.finalize()}}};var Jz=async(t,A)=>{let j={},e=`${A}/df_colors.parquet`,r=await ae(e,Nt.fetch,t.aws),n=[],i=[],o=r.getChild("__index_level_0__"),l=r.getChild("color");return o&&l&&(n=o.toArray(),i=l.toArray()),n.forEach((c,B)=>{j[String(c)]=ei(i[B])}),j};var Zz=(t,A)=>{t.tile_names_array=A},AU=t=>{t.tile_name_to_index_map=new Map,t.tile_names_array.forEach((A,j)=>{t.tile_name_to_index_map.set(A,j)})};var tU=(t,A)=>{t.tile_scatter_data=A};var jU=async(t,A,j)=>{let e=j.model.get("update_trigger");if(!e||typeof e!="object")return;let r={type:e.type||e.click_type,value:e.value||e.click_value},n=r.type?.replace("-","_");if(!n)return;let i;n==="row_label"?(i=r.value.name||r.value,gt(j.cats,i),await q_(j,i),Wt(j.genes,[i],j.obs_store),j.genes&&j.genes.gene_search_input&&(j.genes.gene_search_input.value=i)):n==="col_label"?(gt(j.cats,"cluster"),Rt(j.cats,[r.value.name||r.value],j.obs_store),Wt(j.genes,[],j.obs_store)):n==="col_dendro"?(gt(j.cats,"cluster"),Rt(j.cats,r.value.selected_names||r.value,j.obs_store),Wt(j.genes,[],j.obs_store)):(gt(j.cats,"cluster"),Wt(j.genes,[],j.obs_store)),rg(j,A),t.setProps({layers:[A.simple_image_layer,A.square_scatter_layer]})};var WI=async(t,A,j,e,r,n,i,o,l=1.4,c="",B=0,h=800,d={})=>{B===0&&(B="100%");let k=document.createElement("div");k.style.height=`${h}px`,k.style.width=typeof B=="number"?`${B}px`:B;let g={};if(g.obs_store=Zf(),Z7(e),Es(g,j),g.model=t,g.img={},g.img.image_layer_colors={},g.img.image_layer_sliders={},await xs(g.img,j),"accessKeyId"in d){g.aws=new Yo({accessKeyId:d.accessKeyId,secretAccessKey:d.secretAccessKey,sessionToken:d.sessionToken,region:"us-east-1",service:"s3"});let jA=await g.aws.fetch(`${j}/landscape_parameters.json`);if(!jA.ok)throw new Error(`Fetch failed: ${jA.statusText}`)}else g.aws=null;await $s(g,j,"cells");let E=(jA,pA)=>{if(typeof jA=="string"&&jA.includes("%")){let dA=parseFloat(jA)/100;return pA*dA}return parseFloat(jA)||pA},m=g.dimensions.width,y=g.dimensions.height,G=E(B,A.clientWidth||m),v=E(h,A.clientHeight||y),_=Math.min(G/m,v/y),w=Math.log2(_);r===0&&n===0&&o===0&&(r=m/2,n=y/2,o=w),g.buttons={},g.buttons.blue="#8797ff",g.buttons.gray="gray",g.buttons.light_gray="#EEEEEE",g.buttons.buttons={},g.genes={},g.genes.color_dict_gene={},g.genes.gene_names=[],g.genes.meta_gene={},g.genes.gene_counts=[],g.genes.selected_genes=[],g.genes.trx_ini_radius=1,g.genes.trx_names_array=[],g.genes.trx_data=[],g.genes.gene_text_box="",g.genes.trx_slider=document.createElement("input"),g.genes.gene_search=document.createElement("div"),g.genes.svg_bar_gene=Ur("svg"),g.cats={},g.cats.cat="cluster",g.cats.reset_cat=!1,g.cats.selected_cats=[],g.cats.cell_cats=[],g.cats.dict_cell_cats={},g.cats.color_dict_cluster={},g.cats.cluster_counts=[],g.cats.polygon_cell_names=[],g.cats.svg_bar_cluster=Ur("svg"),g.tooltip_cat_tile="",g.cats.square_tile_size=l,await gl(g.genes,j,"default",g.aws);let x={name:"cells",color:[0,0,255]},O=`${j}/tile_geometries.parquet`,F=await ae(O,Nt.fetch,g.aws);g.cats.tile_cats_array=F.getChild("cluster").toArray(),g.cats.tile_exp_array=[],g.cats.tile_names_array=[],g.cats.tile_scatter_data=[],tU(g.cats,dl(F)),Zz(g.cats,F.getChild("name").toArray()),AU(g.cats),g.cats.tile_color_dict=await Jz(g,j);let C=await of(g,x),R=dz(g.cats),X={simple_image_layer:C,square_scatter_layer:R};g.views=nf();let T=ey(k,B,h),Q={target:[r,n,i],zoom:o};T.setProps({views:g.views,layers:[X.simple_image_layer,X.square_scatter_layer],getTooltip:jA=>tz(jA,g),initialViewState:Q}),g.model?.on&&g.model.on("change:update_trigger",()=>jU(T,X,g)),gz(T,X,g);let b=Xz(T,X,g);return A.appendChild(b),A.appendChild(k),()=>T.finalize()};var eU=`#version 300 es #define SHADER_NAME scatterplot-layer-vertex-shader // customize the vertex shader to allow for x and y scaling and zooming @@ -1875,7 +1875,7 @@ void main(void) { } -`,Jz=`#version 300 es +`,rU=`#version 300 es #define SHADER_NAME scatterplot-layer-fragment-shader // Customize the fragment shader to create square-shaped points @@ -1889,9 +1889,9 @@ void main(void) { geometry.uv = unitPosition; fragColor = vFillColor; DECKGL_FILTER_COLOR(fragColor, geometry); -}`;var su=class extends mr{getShaders(){let A=super.getShaders();return A.vs=Yz,A.fs=Jz,A}draw({uniforms:A}){super.draw({uniforms:{...A,tile_height:this.props.tile_height,tile_width:this.props.tile_width}})}};var Zz=(t,A,j)=>{let e=A.hovered_cat;if(!e||!e.name||t.name===e.name)return t.color;let[r,n,i]=t.color.slice(0,3);return[r,n,i,40]},apA=(t,A,j)=>{let e=t.object?.level,r=t.object?.original_index,n=t.object?.name;if(e===void 0||r===void 0)return;let i=A.attr.names[j]?.[e];if(!i)return;let o=j==="row"?A.row_nodes[r].name:A.col_nodes[r].name,l=j==="row"?A.row_nodes:A.col_nodes,c=`cat-${e}`,B=l.filter(d=>d[c]===n).map(d=>d.name),h=j==="row"?A.row_entity:A.col_entity;if(A.click.type="cat_value",A.click.value={axis:j,attr_name:i,attr_index:e,value:n,node_name:o,node_names:B,entity:h.entity,attr:h.attr,row_entity_full:A.row_entity,col_entity_full:A.col_entity},A.obs_store?.selected_category){let d=A.obs_store.selected_category.get();d&&d.axis===j&&d.attr_index===e&&d.value===n?A.obs_store.selected_category.set(null):A.obs_store.selected_category.set({axis:j,attr_name:i,attr_index:e,value:n,node_names:B})}A.model?.set&&(A.model.set("click_info",null),A.model.set("click_info",A.click),A.model.save_changes())},lpA=(t,A,j,e,r)=>{let n=A.hovered_cat;if(!t.object){n&&(A.hovered_cat=null,r.row_cat_layer=r.row_cat_layer.clone({updateTriggers:{getFillColor:[null]}}),r.col_cat_layer=r.col_cat_layer.clone({updateTriggers:{getFillColor:[null]}}),e.setProps({layers:le(r)}),A.obs_store?.hovered_category&&A.obs_store.hovered_category.set(null));return}let i=t.object?.level,o=t.object?.name;if(!(i===void 0||o===void 0)&&!(n?.axis===j&&n?.level===i&&n?.name===o)&&(A.hovered_cat={axis:j,name:o,level:i},r.row_cat_layer=r.row_cat_layer.clone({updateTriggers:{getFillColor:[A.hovered_cat]}}),r.col_cat_layer=r.col_cat_layer.clone({updateTriggers:{getFillColor:[A.hovered_cat]}}),e.setProps({layers:le(r)}),A.obs_store?.hovered_category)){let l=A.attr.names[j]?.[i];A.obs_store.hovered_category.set({axis:j,attr_name:l,attr_index:i,value:o})}},AU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"row-layer",data:t.cats.row_cat_data,getPosition:e=>{let r=t.mat.orders.row[t.order.current.row],n=t.mat.num_rows-r[e.original_index];return[e.position[0]+t.viz.cat_shift_row,t.viz.row_offset*(n+1.5)]},getFillColor:e=>Zz(e,t,"row"),pickable:!0,autoHighlight:!0,highlightColor:[255,255,255,80],transitions:A,opacity:.8,tile_width:t.viz.row_cat_width/2*.9,tile_height:t.viz.mat_height/t.mat.num_rows*.5})},tU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"col-layer",data:t.cats.col_cat_data,getPosition:e=>{let r=t.mat.orders.col[t.order.current.col],n=t.mat.num_cols-r[e.original_index];return[t.viz.col_offset*(n+.5),e.position[1]+t.viz.cat_shift_col]},getFillColor:e=>Zz(e,t,"col"),pickable:!0,autoHighlight:!0,highlightColor:[255,255,255,80],transitions:A,opacity:.8,tile_width:t.viz.mat_width/t.mat.num_cols*.5,tile_height:t.viz.col_cat_height/2})},zI=(t,A,j,e)=>{let r=`${e}_cat_layer`;A[r]=A[r].clone({onClick:n=>{if(j.attr?.editor?.open){let i=n.object?.level,o=n.object?.original_index;if(i===void 0||o===void 0)return;let l=j.attr.names[e]?.[i];if(!l)return;let c=e==="row"?j.row_nodes[o].name:j.col_nodes[o].name,B=j.attr.all_defs?.[e]?.[i],h=n.object?.name,d=h==null?null:String(h),k=B?.color_map?.[d]||null;j.attr.editor.open({axis:e,selection:[c],attribute_name:l,initial_value:h,initial_color:k,position:n?.pixel?{x:n.pixel[0],y:n.pixel[1]}:void 0})}else apA(n,j,e)},onHover:n=>lpA(n,j,e,t,A)})};var cpA=({isDragging:t})=>t?"grabbing":"pointer",jU=(t,A,j)=>(typeof A=="number"&&(A=A+100,j=j+100),new N7({parent:t,getCursor:cpA,width:A,height:j}));var upA=(t,A,j)=>{let e=A.index,r=j.order.current.row,n=50,i=j.mat.num_rows-j.mat.orders.row[r][e],o=n,l=j.viz.row_offset*(i+1.5);return[o,l]},BpA=(t,A,j)=>{let e=A.index,r=j.order.current.col,n=50,i=j.mat.num_cols-j.mat.orders.col[r][e];return[j.viz.col_offset*(i+.5),n]},eU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new Ii({id:"row-label-layer",data:t.labels.row_label_data,getPosition:(e,r)=>upA(e,r,t),getText:e=>e.display_name||e.name,getSize:t.viz.font_size.rows,getColor:[0,0,0],getAngle:0,getTextAnchor:"end",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:2,pickable:!0,transitions:A})},rU=t=>{function A(r,n){let i=Math.pow(2,r);return[0,75/n*i]}let j={getPosition:{duration:t.animate.duration,easing:I6}};return new Ii({id:"col-label-layer",data:t.labels.col_label_data,getPosition:(r,n)=>BpA(r,n,t),getText:r=>r.display_name||r.name,getSize:t.viz.font_size.cols,getColor:[0,0,0],getAngle:45,getTextAnchor:"start",getAlignmentBaseline:"bottom",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:2,pickable:!0,transitions:j,getPixelOffset:()=>A(t.zoom.zoom_data.matrix.zoom_x,t.mat.num_cols)})},nU=250,iU=(t,A,j,e,r,n)=>{let i=[],o=e==="col"?"row":"col";VA(j.el).selectAll(`.button-${o}`).classed("active",!1).style("border-color",j.buttons.gray),e==="col"?i=j.mat.net_mat.map(h=>h[n]):i=j.mat.net_mat[n];let l=Array.from(i.keys()).sort((h,d)=>i[d]-i[h]),c=l.length,B=Array(c);l.forEach((h,d)=>{B[h]=c-d}),j.mat.orders[o].custom=B,j.order.current[o]="custom",A.mat_layer=A.mat_layer.clone({updateTriggers:{getPosition:[j.order.current.row,j.order.current.col,r]}}),o==="col"?(A.col_label_layer=A.col_label_layer.clone({updateTriggers:{getPosition:[j.order.current.col,r]}}),A.col_cat_layer=A.col_cat_layer.clone({updateTriggers:{getPosition:j.order.current.col}}),eu(A,j,"col")):o==="row"&&(A.row_label_layer=A.row_label_layer.clone({updateTriggers:{getPosition:[j.order.current.row,r]}}),A.row_cat_layer=A.row_cat_layer.clone({updateTriggers:{getPosition:j.order.current.row}}),eu(A,j,"row")),t.setProps({layers:le(A)})},fpA=(t,A,j,e)=>{if(e.labels.clicks.row+=1,e.labels.clicks.row===1){e.click.type="row_label";let{name:r}=t.object;e.click.value={name:r,entity:e.row_entity.entity,attr:e.row_entity.attr,row_entity:e.row_entity.entity},setTimeout(()=>{e.labels.clicks.row=0},nU),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes()),Xv(e,[r]),Yc(e,[r]),typeof e.custom_callbacks.row=="function"&&e.custom_callbacks.row(r)}else e.labels.clicks.row===2&&(e.labels.clicks.row=0,iU(A,j,e,"row",t.object.name,t.object.index))},hpA=(t,A,j,e)=>{if(e.labels.clicks.col+=1,e.labels.clicks.col===1){e.click.type="col_label";let{name:r}=t.object;e.click.value={name:r,entity:e.col_entity.entity,attr:e.col_entity.attr,col_entity:e.col_entity.entity},setTimeout(()=>{e.labels.clicks.col=0},nU),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes()),zv(e,[r]);let n=t.object.index,i=e.mat.net_mat.map(B=>B[n]),o=Array.from(i.keys()).sort((B,h)=>i[h]-i[B]),l=e.top_n_genes||15,c=o.slice(0,l).map(B=>e.row_nodes[B].name);Yc(e,c),typeof e.custom_callbacks.col=="function"&&e.custom_callbacks.col(r)}else e.labels.clicks.col===2&&(e.labels.clicks.col=0,iU(A,j,e,"col",t.object.name,t.object.index))},oU=(t,A,j)=>{A.row_label_layer=A.row_label_layer.clone({onClick:e=>fpA(e,t,A,j)})},sU=(t,A,j)=>{A.col_label_layer=A.col_label_layer.clone({onClick:e=>hpA(e,t,A,j)})};var dpA=(t,A)=>{let j=A.order.current.row,e=A.order.current.col,r=A.mat.num_cols-A.mat.orders.col[e][t.col],n=A.mat.num_rows-A.mat.orders.row[j][t.row],i=A.viz.col_width*(r+.5),o=A.viz.row_offset*(n+1.5);return[i,o]},aU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"mat-layer",data:t.mat.mat_data,getPosition:e=>dpA(e,t),getFillColor:e=>e.color,pickable:!0,antialiasing:!1,tile_height:t.viz.mat_height/t.mat.num_rows*.5,tile_width:t.viz.mat_width/t.mat.num_cols*.5,transitions:A})},ppA=(t,A,j,e)=>{let r=t.object.row,n=t.object.col,i=e.labels.row_label_data[r].name,o=e.labels.col_label_data[n].name,l=e.mat.net_mat[r][n];e.click.type="mat_value",e.click.value={row:{name:i,index:r,entity:e.row_entity.entity,attr:e.row_entity.attr,row_entity:e.row_entity.entity},col:{name:o,index:n,entity:e.col_entity.entity,attr:e.col_entity.attr,col_entity:e.col_entity.entity},value:l,row_entity_full:e.row_entity,col_entity_full:e.col_entity},e.obs_store?.selected_cell&&e.obs_store.selected_cell.set({row_name:i,col_name:o,row_index:r,col_index:n,value:l}),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes()),e.attr?.editor?.close&&e.attr.editor.close()},lU=(t,A,j)=>{A.mat_layer=A.mat_layer.clone({onClick:e=>ppA(e,t,A,j)})};var cU=(t,A)=>{let{object:j,layer:e}=A,r=t.root.querySelector(".deck-tooltip");r.style.marginTop="50px";let n=r.parentElement.parentElement;if(n.style.position="unset",j){if(e.id==="row-label-layer")return{html:`Row Label: ${j.display_name||j.name}`,style:{color:"white"}};if(e.id==="col-label-layer")return{html:`Col Label: ${j.display_name||j.name}`,style:{color:"white"}};if(e.id==="row-layer")return{html:`${t.attr.names.row[j.level]}: ${j.name}`,style:{color:"white"}};if(e.id==="col-layer")return{html:`${t.attr.names.col[j.level]}: ${j.name}`,style:{color:"white"}};if(e.id==="row-dendro-layer")return{html:`row-dendro-${j.properties.name}
${j.properties.all_names}`,style:{color:"white"}};if(e.id==="col-dendro-layer")return{html:`row-dendro-${j.properties.name}
${j.properties.all_names}`,style:{color:"white"}};if(e.id==="mat-layer"){let i=t.labels.row_label_data[j.row],o=t.labels.col_label_data[j.col],l=i?.display_name||i?.name,c=o?.display_name||o?.name;return{html:`Row: ${l}
Column: ${c}
Value: ${j.value.toFixed(2)}`,style:{color:"white"}}}else{if(e.id==="row-attr-label-layer")return{html:`Row Attribute: ${j.name}
Double-click to reorder by this attribute`,style:{color:"white"}};if(e.id==="col-attr-label-layer")return{html:`Column Attribute: ${j.name}
Double-click to reorder by this attribute`,style:{color:"white"}}}}};var uU=(t,A,j)=>{let{ini_pan_y:e}=j.zoom,r,n=Math.pow(2,A);j.zoom.min_pan_y=(e-j.viz.row_offset)/n+j.viz.row_offset;let i=e-j.zoom.min_pan_y;return j.zoom.max_pan_y=e+i,t<=j.zoom.min_pan_y?r=j.zoom.min_pan_y:t>j.zoom.max_pan_y?r=j.zoom.max_pan_y:r=t,r},BU=(t,A,j)=>{let{ini_pan_x:e}=j.zoom,r,n=Math.pow(2,A);j.zoom.min_pan_x=e/n;let i=e-j.zoom.min_pan_x;return j.zoom.max_pan_x=e+i,t<=j.zoom.min_pan_x?r=j.zoom.min_pan_x:t>j.zoom.max_pan_x?r=j.zoom.max_pan_x:r=t,r};var kpA=t=>({row_attr_labels:{target:[t.viz.label_row_x,t.viz.col_region/2],zoom:[0,0]},col_attr_labels:{target:[(t.viz.dendrogram_width+60)/2,t.viz.col_region/2],zoom:[0,0]}}),fU=(t,A,j,e)=>{let r,n=kpA(t);return A==="matrix"?r={matrix:{zoom:[j[0],j[1]],target:[e[0],e[1]]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}:A==="cols"||A==="dendro_cols"?r={matrix:{zoom:[j[0],j[1]],target:[e[0],t.zoom.min_pan_y]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,t.zoom.min_pan_y]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,t.zoom.min_pan_y]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}:(A==="rows"||A==="dendro_rows")&&(r={matrix:{zoom:[j[0],j[1]],target:[t.zoom.min_pan_x,e[1]]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}),r};var hU=(t,A,j,e)=>{let{zoom_data:r}=t.zoom;r.matrix.pan_x=e[0],r.matrix.pan_y=e[1],r.matrix.zoom_x=j[0],r.matrix.zoom_y=j[1],r.rows.pan_x=t.zoom.ini_pan_x,r.rows.pan_y=e[1],r.rows.zoom_x=j[0],r.rows.zoom_y=j[1],r.cols.pan_x=e[0],r.cols.pan_y=t.zoom.ini_pan_y,r.cols.zoom_x=j[0],r.cols.zoom_y=j[1],r.dendro_rows.pan_x=t.zoom.ini_pan_x,r.dendro_rows.pan_y=e[1],r.dendro_rows.zoom_x=j[0],r.dendro_rows.zoom_y=j[1],r.dendro_cols.pan_x=e[0],r.dendro_cols.pan_y=t.zoom.ini_pan_y,r.dendro_cols.zoom_x=j[0],r.dendro_cols.zoom_y=j[1]},dU=t=>{t.zoom.zoom_data={},t.zoom.zoom_data.total_zoom={},t.zoom.zoom_data.total_zoom.x=0,t.zoom.zoom_data.total_zoom.y=0,t.zoom.zoom_data.matrix={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.rows={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.cols={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.dendro_rows={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.dendro_cols={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y}};var pU=(t,A,j,e)=>{let{viewState:r}=t,{viewId:n}=t,{zoom:i,target:o}=r,l,c;n==="cols"?e.zoom.minor_zoom_axis==="X"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="Y"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]):(n==="rows"||n==="dendro_rows")&&(e.zoom.minor_zoom_axis==="Y"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="X"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0],c=i[1]-e.zoom.zoom_data[n].zoom_y)),n==="dendro_cols"?e.zoom.minor_zoom_axis==="X"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="Y"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]):n==="matrix"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y),e.zoom.zoom_data.total_zoom.x+=l,e.zoom.zoom_data.total_zoom.y+=c,e.zoom.zoom_data.total_zoom.x=Math.max(0,e.zoom.zoom_data.total_zoom.x),e.zoom.zoom_data.total_zoom.y=Math.max(0,e.zoom.zoom_data.total_zoom.y);let B=[e.zoom.zoom_data.total_zoom.x,e.zoom.zoom_data.total_zoom.y],h=Math.max(0,B[0]),d=Math.max(0,B[1]);e.zoom.major_zoom_axis==="X"?d=h-e.zoom.zoom_delay:e.zoom.major_zoom_axis==="Y"&&(h=d-e.zoom.zoom_delay),h=Math.max(0,h),d=Math.max(0,d);let k=BU(o[0],h,e),g=uU(o[1],d,e),E=[h,d],m=[k,g],y=fU(e,n,E,m);hU(e,n,E,m);let b;e.zoom.major_zoom_axis==="X"?b=Math.pow(2,e.zoom.zoom_data.matrix.zoom_x):e.zoom.major_zoom_axis==="Y"?b=Math.pow(2,e.zoom.zoom_data.matrix.zoom_y):e.zoom.major_zoom_axis==="all"&&(b=Math.pow(2,e.zoom.zoom_data.matrix.zoom_x)),j.row_label_layer=j.row_label_layer.clone({getSize:e.viz.font_size.rows*Math.pow(2,e.zoom.zoom_data.matrix.zoom_y)}),j.col_label_layer=j.col_label_layer.clone({getSize:e.viz.font_size.cols*Math.pow(2,e.zoom.zoom_data.matrix.zoom_x),updateTriggers:{getPixelOffset:e.zoom.zoom_data.matrix.zoom_x}});let v;e.zoom.major_zoom_axis!=="all"?v=b_.props.controller===!1?_:new un({..._.props,controller:{..._.props.controller,doubleClickZoom:!1,scrollZoom:!0,inertia:!0,zoomAxis:v}})),A.setProps({viewState:y,layers:le(j),views:e.views.views_list})};var b_=t=>{let A;t.mat.num_rows>t.mat.num_cols?(t.zoom.major_zoom_axis="Y",t.zoom.minor_zoom_axis="X",A=t.mat.num_rows/t.mat.num_cols):t.mat.num_rows({matrix:{target:[t.zoom.ini_pan_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},rows:{target:[t.viz.label_row_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},cols:{target:[t.zoom.ini_pan_x,t.viz.label_col_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},row_attr_labels:{target:[t.viz.label_row_x,t.viz.col_region/2],zoom:[0,0]},col_attr_labels:{target:[(t.viz.dendrogram_width+60)/2,t.viz.col_region/2],zoom:[0,0]},dendro_rows:{target:[t.viz.label_row_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},dendro_cols:{target:[t.zoom.ini_pan_x,t.viz.label_col_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]}});var kU=["#1f77b4","#ff7f0e","#2ca02c","#d62728","#9467bd","#8c564b","#e377c2","#7f7f7f","#bcbd22","#17becf"],gU="N.A.",gpA="#d1d5db",UI=t=>t==null?null:String(t),mpA=t=>t==="col"?"col":"row",QI=(t,A)=>{let j=kU[A%kU.length];return typeof t=="string"&&o6(t)?t:j},EpA=t=>{let A=t.attr.num.row,j=t.attr.num.col;t.viz.mat_width=t.viz.total_width-t.viz.row_cat_offset*A,t.viz.mat_height=t.viz.total_height-t.viz.col_cat_offset*j,t.viz.col_region=(t.viz.col_cat_height+t.viz.extra_space.col)*j+t.viz.col_label,t.viz.row_region=(t.viz.row_cat_width+t.viz.extra_space.row)*A+t.viz.row_label,t.viz.col_width=t.viz.mat_width/t.mat.num_cols,t.viz.row_offset=t.viz.mat_height/t.mat.num_rows,t.viz.col_offset=t.viz.mat_width/t.mat.num_cols,t.viz.cat_shift_col=t.viz.col_label,t.zoom.ini_pan_x=t.viz.mat_width/2,t.zoom.ini_pan_y=t.viz.mat_height/2+t.viz.row_offset},mU=(t,A)=>{let j=A==="row",e=j?t.viz.row_cat_offset:t.viz.col_cat_offset,r=j?t.viz.row_offset:t.viz.col_offset,n=t.attr.all_defs[A]||[],i=[];return n.forEach((o,l)=>{let c=o.values||[],B=o.maxabs||0,h=o.color_map||{};c.forEach((d,k)=>{if(d==null||d==="")return;let g;if(o.type==="numeric"){let E=Math.abs(B)||1,m=Number(d);if(Number.isNaN(m))return;let y=[255,165,0],b=[169,169,169],v=m>=0?b:y,_=Math.min(1,Math.abs(m)/E);g=[...v,Math.round(_*255)]}else{let E=UI(d),m=h[E]||QI(E,k+l);g=jg(m,255)}i.push({position:j?[e*(l+.5)+20,r*(k+.5)]:[r*(k+.5),e*(l+1.5)-30],color:g,name:o.type==="numeric"?d:UI(d),level:l,original_index:k})})}),i},VI=t=>{["row","col"].forEach(A=>{let j=[...t.attr.static_defs?.[A]||[],...t.attr.manual_defs?.[A]||[]];t.attr.all_defs[A]=j,t.attr.names[A]=j.map(e=>e.name),t.attr.maxabs[A]=j.map(e=>e.type==="numeric"?e.maxabs??0:null),t.attr.num[A]=j.length,t.attr.cats[A]=j.filter(e=>e.type==="categorical").map(e=>e.name)})},EU=(t,A,j)=>{let e=j==="row"?A.row_nodes:A.col_nodes,r=t.attr.names[j]||[],n=t.attr.maxabs[j]||[];return r.map((i,o)=>{if(n[o]!==null&&n[o]!==void 0){let h=e.map(d=>d[`num-${o}`]);return{name:i,type:"numeric",values:h,maxabs:n[o]}}let c=e.map(h=>UI(h[`cat-${o}`])),B={};return c.forEach((h,d)=>{h!==null&&(A.global_cat_colors&&A.global_cat_colors[h]?B[h]=A.global_cat_colors[h]:B[h]||(B[h]=QI(h,d)))}),{name:i,type:"categorical",values:c,color_map:B}})},$U=(t,A)=>{t.attr.static_defs={row:[],col:[]},t.attr.manual_defs={row:[],col:[]},t.attr.all_defs={row:[],col:[]},t.attr.names=t.attr.names||{row:[],col:[]},t.attr.maxabs=t.attr.maxabs||{row:[],col:[]},t.attr.num=t.attr.num||{row:0,col:0},t.attr.cats={row:[],col:[]},t.attr.category_colors={},t.attr.did_initialize=!1,t.manual_cat=t.manual_cat||{config:{row:null,col:null},flags:{row:!1,col:!1}},t.attr.static_defs.row=EU(t,A,"row"),t.attr.static_defs.col=EU(t,A,"col"),VI(t)},WI=(t,A,j)=>{EpA(j);let e=mU(j,"row"),r=mU(j,"col");j.cats.row_cat_data=e,j.cats.col_cat_data=r,A.row_cat_layer=A.row_cat_layer.clone({data:e,tile_width:j.viz.row_cat_width/2*.9,tile_height:j.viz.mat_height/j.mat.num_rows*.5}),A.col_cat_layer=A.col_cat_layer.clone({data:r,tile_width:j.viz.mat_width/j.mat.num_cols*.5,tile_height:j.viz.col_cat_height/2}),A.mat_layer=A.mat_layer.clone({tile_height:j.viz.mat_height/j.mat.num_rows*.5,tile_width:j.viz.mat_width/j.mat.num_cols*.5,updateTriggers:{getPosition:[j.order.current.row,j.order.current.col]}}),A.row_label_layer=A.row_label_layer.clone({data:j.labels.row_label_data,updateTriggers:{getPosition:j.order.current.row}}),A.col_label_layer=A.col_label_layer.clone({data:j.labels.col_label_data,updateTriggers:{getPosition:j.order.current.col}}),b_(j);let n=w_(j),i={views:j.views.views_list,layers:le(A)};j.attr.did_initialize||(i.initialViewState=n,j.attr.did_initialize=!0),t.setProps(i)},xU=(t,A)=>{let j=mpA(A),e=t.manual_cat?.flags||{},r=t.obs_store?.manual_cat?.[j],n=r?.attribute||null,i=t.manual_cat?.config?.[j]?.attribute||null,o=n||i;if(!!!(e[j]&&n)||!r||!o)return t.attr.manual_defs[j]=[],VI(t),!0;let c=r.toFrame(gU),B=r.toColorPayload(gU,gpA),h=(c.index||[]).map(x=>String(x)),d=new Map;h.forEach((x,S)=>{d.set(x,S)});let g=(j==="row"?t.row_nodes:t.col_nodes).map(x=>String(x.name)),E=c.data[o]||[],m=g.map(x=>{let S=d.get(x);if(S===void 0)return null;let F=E[S];return F??null}),y=B[o]||{},b=t.attr.category_colors||{},v=Array.from(new Set(m.filter(x=>x!==null&&x!==""))),_={};v.forEach((x,S)=>{_[x]=y[x]||b[x]||QI(x,S)});let w=t.attr.category_colors||{};return Object.entries(_).forEach(([x,S])=>{x&&S&&w[x]!==S&&(w[x]=S)}),t.attr.category_colors=w,t.attr.manual_defs[j]=[{name:o,type:"categorical",values:m,color_map:_}],VI(t),!0};var yU=t=>t==="col"?"col":"row",$pA=t=>yU(t)==="col"?"col_label_data":"row_label_data",xpA=(t,A)=>t?A?`${t} (${A})`:t:"",F_=(t,A)=>{if(!t||!t.labels)return;let j=yU(A),e=$pA(j),r=t.labels[e];if(!Array.isArray(r))return;let n=t.manual_cat?.flags||{},i=t.obs_store?.manual_cat?.[j],o=!!(i?.getValueFor&&i?.attribute&&n[j]),l=r.map(c=>{let B=o&&c?.name?i.getValueFor(c.name):null;return{...c,display_name:xpA(c?.name,B)}});t.labels[e]=l},vU=(t,A)=>{let j=[];t.col_nodes.forEach((e,r)=>{let n={name:e.name,ini:e.ini,clust:e.clust,rank:e.rank,rankvar:e.rankvar,index:r};j.push(n)}),A.labels.col_label_data=j,A.labels.clicks.col=0,A.mat.orders.col={},A.mat.orders.col.ini=j.map(e=>e.ini),A.mat.orders.col.clust=j.map(e=>e.clust+1),A.mat.orders.col.rank=j.map(e=>e.rank+1),A.mat.orders.col.rankvar=j.map(e=>e.rankvar+1),F_(A,"col")},_U=(t,A)=>{let j=[];t.row_nodes.forEach((e,r)=>{let n={name:e.name,ini:e.ini,clust:e.clust,rank:e.rank,rankvar:e.rankvar,index:r};j.push(n)}),A.labels.row_label_data=j,A.labels.clicks.row=0,A.mat.orders.row={},A.mat.orders.row.ini=j.map(e=>e.ini),A.mat.orders.row.clust=j.map(e=>e.clust+1),A.mat.orders.row.rank=j.map(e=>e.rank+1),A.mat.orders.row.rankvar=j.map(e=>e.rankvar+1),F_(A,"row")};var qU=(t,A)=>{let{mat:j}=t,{col_offset:e,row_offset:r}=A.viz,{max_abs_value:n}=A.mat,{mat_data:i}=A.mat;for(let o=0;o=0?[255,0,0]:[0,0,255],d={position:[e*(c+.5),r*(o+1.5)],color:[h[0],h[1],h[2],Math.min(255,255*Math.abs(B)/n)],value:B,row:o,col:c};i.push(d)}}};var El=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{(typeof e=="object"&&e!==null?JSON.stringify(A)!==JSON.stringify(e):A!==e)&&(A=e,j.forEach(n=>n(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},GU=()=>({selected_genes:El([]),focused_dendro:El(null),attr_reorder_state:El(null),selected_cell:El(null),selected_category:El(null),hovered_category:El(null),dendro_selection:El(null),category_breakdown:El({row:{},col:{}})});var ypA=t=>t==="col"?"col":"row",bU=()=>[],sg=class{constructor(A="row",j=bU){this.axis=ypA(A),this.getNodeNames=typeof j=="function"?j:bU,this.attribute=null,this.values=new Map,this.colors=new Map,this.listeners=new Set}setAttribute(A){let j=A?String(A):null;this.attribute!==j&&(this.attribute=j,this.values.clear(),this.colors.clear(),this.emit())}updateSelection({selection:A=[],value:j,color:e}){let r=j==null||j===""?null:String(j);A.forEach(n=>{let i=String(n);r?this.values.set(i,r):this.values.delete(i)}),r&&e&&this.colors.set(r,String(e)),this.emit()}getValueFor(A){if(A==null)return null;let j=String(A),e=this.values.get(j);return e===void 0?null:e}clear(){!this.attribute&&this.values.size===0&&this.colors.size===0||(this.attribute=null,this.values.clear(),this.colors.clear(),this.emit())}toFrame(A="N.A."){let j=this.getNodeNames().map(n=>String(n)),e=this.axis==="row"?"row_id":"col_id";if(!this.attribute)return{columns:[],index:j,index_name:e,data:{}};let r=j.map(n=>{let i=this.values.get(String(n));return i==null||i===""?A:i});return{columns:[this.attribute],index:j,index_name:e,data:{[this.attribute]:r}}}toColorPayload(A="N.A.",j="#d1d5db"){if(!this.attribute)return{};let e={[this.attribute]:{[A]:j}};return this.colors.forEach((r,n)=>{n&&(e[this.attribute][n]=r)}),e}toExportPayload(){if(!this.attribute)return{};let A={},j={};return this.values.forEach((e,r)=>{A[String(r)]=e}),this.colors.forEach((e,r)=>{j[String(r)]=e}),{[this.attribute]:{values:A,colors:j}}}subscribe(A,j={immediate:!0}){return this.listeners.add(A),(!j||j.immediate)&&A(),()=>this.listeners.delete(A)}emit(){this.listeners.forEach(A=>A())}};var wU=t=>{if(!t)return{entity:"gene",attr:"name"};if(typeof t=="string")try{let A=JSON.parse(t);if(A&&typeof A=="object")return{entity:A.entity||"custom",attr:A.attr||"name"}}catch{return{gene:{entity:"gene",attr:"name"},cell_cluster:{entity:"cell",attr:"leiden"},cluster:{entity:"cell",attr:"leiden"},nbhd:{entity:"nbhd",attr:"name"},cell:{entity:"cell",attr:"name"},hextile:{entity:"hextile",attr:"name"}}[t]||{entity:t,attr:"name"}}return typeof t=="object"?{entity:t.entity||"custom",attr:t.attr||"name"}:{entity:"custom",attr:"name"}},FU=(t,A,j,e,r,n,i,o,l,c)=>{let B={};B.root=j,B.model=t,B.obs_store=GU();let h={positive:"#a9a9a9",negative:"#ffa500"};B.value_colors=t&&typeof t.get=="function"&&t.get("value_colors")||h,B.custom_callbacks={},B.custom_callbacks.row=o,B.custom_callbacks.col=l,B.custom_callbacks.col_dendro=c,B.viz={},B.viz.height_margin=100,B.attr={},B.attr.names={row:A.row_attr||[],col:A.col_attr||[]},B.attr.maxabs={row:A.row_attr_maxabs||[],col:A.col_attr_maxabs||[]},B.attr.num={row:B.attr.names.row.length,col:B.attr.names.col.length},$U(B,A),B.root.style.height=`${r+B.viz.height_margin}px`,B.viz.row_cat_offset=9,B.viz.col_cat_offset=9,B.viz.total_width=e,B.viz.total_height=r,B.viz.mat_width=e-B.viz.row_cat_offset*B.attr.num.row,B.viz.mat_height=r-B.viz.col_cat_offset*B.attr.num.col,B.mat={},B.mat.num_rows=A.mat.length,B.mat.num_cols=A.mat[0].length,B.row_nodes=A.row_nodes,B.col_nodes=A.col_nodes,B.obs_store.manual_cat={row:new sg("row",()=>(B.row_nodes||[]).map(m=>String(m.name))),col:new sg("col",()=>(B.col_nodes||[]).map(m=>String(m.name)))},B.mat.net_mat=A.mat,B.linkage=A.linkage,B.viz.base_font_size=125,B.viz.col_label=75,B.viz.row_label=75,B.viz.extra_space={},B.viz.extra_space.row=5,B.viz.extra_space.col=5,B.zoom={},B.zoom.ini_zoom_x=0,B.zoom.ini_zoom_y=0,B.viz.row_cat_width=8,B.viz.col_cat_height=8,B.viz.label_row_x=15,B.viz.label_col_y=25,B.viz.cat_shift_row=30,B.viz.label_buffer=1,B.animate={},B.animate.duration=2500,B.viz.dendrogram_width=15;let d=wU(n),k=wU(i);B.row_entity=d,B.col_entity=k,B.viz.font_size={},B.viz.font_size.rows=B.viz.base_font_size/B.mat.num_rows,B.viz.font_size.cols=B.viz.base_font_size/B.mat.num_cols,B.viz.col_region=(B.viz.col_cat_height+B.viz.extra_space.col)*B.attr.num.col+B.viz.col_label,B.viz.row_region=(B.viz.row_cat_width+B.viz.extra_space.row)*B.attr.num.row+B.viz.row_label,B.viz.col_width=B.viz.mat_width/B.mat.num_cols,B.viz.row_offset=B.viz.mat_height/B.mat.num_rows,B.viz.col_offset=B.viz.mat_width/B.mat.num_cols,B.viz.cat_shift_col=B.viz.col_label,B.zoom.ini_pan_x=B.viz.mat_width/2,B.zoom.ini_pan_y=B.viz.mat_height/2+B.viz.row_offset,B.mat.mat_data=[],B.mat.num_rows=A.mat.length,B.mat.num_cols=A.mat[0].length;let g=A.mat.flat().map(m=>Math.abs(m));g.sort((m,y)=>m-y);let E=Math.floor(.99*(g.length-1));return B.mat.max_abs_value=g[E]||1,B.order={},B.order.current={},B.order.current.row="clust",B.order.current.col="clust",B.order.new="ini",B.buttons={},B.buttons.blue="#8797ff",B.buttons.gray="#EEEEEE",B.click={},B.click.type=null,B.click.value=null,B.top_n_genes=t&&typeof t.get=="function"&&t.get("top_n_genes")||50,B};var au={row:"#2f74ff",col:"#ff7f0e"},vpA=t=>{let A=t.attr?.category_colors||{};return new Set(Object.values(A).filter(j=>!!j).map(j=>j.toLowerCase()))},_pA=t=>{t.manual_cat=t.manual_cat||{},typeof t.manual_cat.color_cursor!="number"&&(t.manual_cat.color_cursor=0);let A=vpA(t);for(let j=0;j<720;j+=1){let e=t.manual_cat.color_cursor+j,r=e*137.508%360/360,n=$z(r,.65,.55);if(!A.has(n.toLowerCase()))return t.manual_cat.color_cursor=e+1,n}return t.manual_cat.color_cursor+=1,"#3b82f6"},PU=(t,A,j)=>{let e=k_(),{header:r,close_button:n}=g_("Manual category"),i=document.createElement("div");i.style.fontSize="11px",i.style.marginBottom="8px",i.style.color="#5b6770";let o=p_("Category value"),l=eh("Category value",o),c=d_(au.row),B=eh("Color",c),{button_row:h,apply_button:d,cancel_button:k}=m_();e.appendChild(r),e.appendChild(i),e.appendChild(l),e.appendChild(B),e.appendChild(h),t.el.appendChild(e);let g=null,E=x=>x&&(t.attr?.category_colors||{})[String(x)]||null,m=x=>{let S=t.manual_cat?.flags||{},F=t.manual_cat?.config?.[x];return!!(S?.[x]&&F?.attribute)},y=()=>{e.style.display="none",g=null},b=(x,S)=>{let F=(x||"").trim();if(!F)return c.value=au[S]||au.row,c.value;let D=E(F);if(D)return c.value=D,D;let L=_pA(t);return c.value=L,L},v=x=>{let S=t.el.getBoundingClientRect(),F=t.root.getBoundingClientRect(),D=e.offsetWidth||240,L=e.offsetHeight||200,z=(x?.x??F.width-D-24)+(F.left-S.left),T=(x?.y??24)+(F.top-S.top),W=jh(z,8,S.width-D-8),G=jh(T,8,S.height-L-8);e.style.left=`${W}px`,e.style.top=`${G}px`},_=({axis:x,selection:S,initial_value:F,initial_color:D,position:L})=>{if(!Array.isArray(S)||S.length===0||!m(x))return;g={axis:x,selection:S.map(G=>String(G))};let z=x==="col"?"columns":"rows";if(!t.manual_cat?.config?.[x]?.attribute)return;i.textContent=`${S.length} ${z} selected`,o.value=F?String(F):"";let W=E(o.value.trim());c.value=D||W||au[x]||au.row,e.style.display="block",v(L)},w=()=>{if(!g)return;let x=t.manual_cat?.config?.[g.axis]?.attribute;if(!x){y();return}let S=o.value.trim(),F=c.value||au[g.axis]||au.row,D=t.obs_store?.manual_cat?.[g.axis];if(!D){y();return}D.setAttribute(x),D.updateSelection({selection:g.selection,value:S,color:F}),y()};d.addEventListener("click",w),k.addEventListener("click",y),n.addEventListener("click",y),t.attr.editor={open:_,close:y},o.addEventListener("input",()=>{let x=g?.axis||"row";b(o.value,x)})};var qpA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr.all_defs[A]?.[j];if(!r||!r.values)return null;let{values:n}=r,i=[...new Set(n.filter(B=>B!=null))];r.type==="numeric"?i.sort((B,h)=>Number(B)-Number(h)):i.sort();let o=new Map;i.forEach(B=>o.set(B,[])),e.forEach((B,h)=>{let d=n[h];d!=null&&o.has(d)&&o.get(d).push({node:B,index:h})});let l=new Array(e.length).fill(0),c=1;return o.forEach(B=>{B.sort((h,d)=>h.node.clust-d.node.clust),B.forEach(({index:h})=>{l[h]=c++})}),l},IU=(t,A,j,e,r,n)=>{let i=`attr_${r}`;if(!t.mat.orders[e][i]){let o=qpA(t,e,r);o&&(t.mat.orders[e][i]=o)}t.mat.orders[e][i]&&(t.order.current[e]=i,t.obs_store?.attr_reorder_state&&t.obs_store.attr_reorder_state.set({axis:e,attr_index:r,attr_name:n,order_key:i}),VA(t.el).selectAll(`.button-${e}`).classed("active",!1).style("border-color",t.buttons.gray),j.mat_layer=j.mat_layer.clone({updateTriggers:{getPosition:[t.order.current.row,t.order.current.col]}}),e==="row"?(j.row_label_layer=j.row_label_layer.clone({updateTriggers:{getPosition:t.order.current.row}}),j.row_cat_layer=j.row_cat_layer.clone({updateTriggers:{getPosition:t.order.current.row}})):(j.col_label_layer=j.col_label_layer.clone({updateTriggers:{getPosition:t.order.current.col}}),j.col_cat_layer=j.col_cat_layer.clone({updateTriggers:{getPosition:t.order.current.col}})),eu(j,t,e),A.setProps({layers:le(j)}))},MU=250,OU=t=>(t.attr.names.col||[]).map((j,e)=>({name:j,index:e,axis:"col"})),TU=t=>(t.attr.names.row||[]).map((j,e)=>({name:j,index:e,axis:"row"})),GpA=(t,A)=>{let e=A.viz.col_cat_offset*(t.index+1.5)-30+A.viz.cat_shift_col;return[5,A.viz.col_region/2+(e-A.viz.label_col_y)]},bpA=(t,A)=>{let j=A.viz.row_cat_offset*(t.index+.5)+20+A.viz.cat_shift_row,e=A.viz.col_region-5;return[j,e]},SU=t=>{let A=OU(t);return A.length===0?null:new Ii({id:"col-attr-label-layer",data:A,getPosition:e=>GpA(e,t),getText:e=>e.name,getSize:10,getColor:[80,80,80],getAngle:0,getTextAnchor:"start",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:1,pickable:!0})},RU=t=>{let A=TU(t);return A.length===0?null:new Ii({id:"row-attr-label-layer",data:A,getPosition:e=>bpA(e,t),getText:e=>e.name,getSize:10,getColor:[80,80,80],getAngle:90,getTextAnchor:"start",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:1,pickable:!0})},wpA=(t,A,j,e)=>{e.labels.clicks.col_attr=(e.labels.clicks.col_attr||0)+1,e.labels.clicks.col_attr===1?setTimeout(()=>{e.labels.clicks.col_attr=0},MU):e.labels.clicks.col_attr===2&&(e.labels.clicks.col_attr=0,IU(e,A,j,"col",t.object.index,t.object.name))},FpA=(t,A,j,e)=>{e.labels.clicks.row_attr=(e.labels.clicks.row_attr||0)+1,e.labels.clicks.row_attr===1?setTimeout(()=>{e.labels.clicks.row_attr=0},MU):e.labels.clicks.row_attr===2&&(e.labels.clicks.row_attr=0,IU(e,A,j,"row",t.object.index,t.object.name))},LU=(t,A,j)=>{A.col_attr_label_layer&&(A.col_attr_label_layer=A.col_attr_label_layer.clone({onClick:e=>wpA(e,t,A,j)}))},CU=(t,A,j)=>{A.row_attr_label_layer&&(A.row_attr_label_layer=A.row_attr_label_layer.clone({onClick:e=>FpA(e,t,A,j)}))},PpA=(t,A,j)=>{let e=OU(j);A.col_attr_label_layer&&e.length>0?A.col_attr_label_layer=A.col_attr_label_layer.clone({data:e}):e.length>0&&(A.col_attr_label_layer=SU(j),LU(t,A,j));let r=TU(j);A.row_attr_label_layer&&r.length>0?A.row_attr_label_layer=A.row_attr_label_layer.clone({data:r}):r.length>0&&(A.row_attr_label_layer=RU(j),CU(t,A,j)),t.setProps({layers:le(A)})},HU=(t,A,j)=>{A.col_attr_label_layer=SU(j),A.col_attr_label_layer&&LU(t,A,j),A.row_attr_label_layer=RU(j),A.row_attr_label_layer&&CU(t,A,j),j.obs_store?.manual_cat&&["row","col"].forEach(e=>{let r=j.obs_store.manual_cat[e];r&&r.subscribe(()=>{setTimeout(()=>{PpA(t,A,j)},150)},{immediate:!1})})};var P_=async(t,A,j,e="800",r="800",n=null,i=null,o=null)=>{let l=document.createElement("div");l.style.border="1px solid #d3d3d3";let c=jU(l,e,r),B=t.get("row_entity"),h=t.get("col_entity"),d=FU(t,j,l,e,r,B,h,n,i,o);A.style.position="relative",d.el=A,qU(j,d),d.labels={},d.labels.clicks={},dU(d),d.mat.orders={},_U(j,d),vU(j,d),d.cats={},d.cats.row_cat_data=[],d.cats.col_cat_data=[],bz(d),eg(d,"row"),eg(d,"col");let k={};k.mat_layer=aU(d),k.row_label_layer=eU(d),k.col_label_layer=rU(d),k.row_cat_layer=AU(d),k.col_cat_layer=tU(d),k.row_dendro_layer=MI(k,d,"row"),k.col_dendro_layer=MI(k,d,"col"),d.deck_mat=c,d.layers_mat=k,WI(c,k,d),zI(c,k,d,"row"),zI(c,k,d,"col"),b_(d);let g=w_(d);lU(c,k,d),oU(c,k,d),sU(c,k,d),OI(c,k,d,"row"),OI(c,k,d,"col"),c.setProps({onViewStateChange:v=>pU(v,c,k,d),views:d.views.views_list,initialViewState:g,getTooltip:v=>cU(d,v),layerFilter:yz,layers:le(k)});let E=Rz(c,k,d);A.appendChild(E),A.appendChild(d.root),PU(d,c,k),HU(c,k,d),c.setProps({layers:le(k)});let m=()=>{if(!d.model)return;let v=d.obs_store?.manual_cat?.row,_=d.obs_store?.manual_cat?.col,w={row:v?v.toExportPayload():{},col:_?_.toExportPayload():{}},x=JSON.stringify(w);d.model.set("manual_cat",x),d.model.set("category_colors",d.attr.category_colors||{}),d.model.save_changes()},y=(v,{sync:_=!1}={})=>{xU(d,v)&&(F_(d,v),WI(c,k,d),_&&m())};if(d.obs_store?.manual_cat&&["row","col"].forEach(v=>{let _=d.obs_store.manual_cat[v];_&&_.subscribe(()=>{y(v,{sync:!0})},{immediate:!1})}),d.model){d.model.set("row_names",d.row_nodes.map(w=>String(w.name))),d.model.set("col_names",d.col_nodes.map(w=>String(w.name))),d.model.save_changes(),(()=>{d.manual_cat=d.manual_cat||{config:{},flags:{}};let x=d.model.get("manual_cat_config");if(typeof x=="string")try{x=x?JSON.parse(x):{}}catch{x={}}let S=x&&typeof x=="object"?x:{row:null,col:null};d.manual_cat.config.row=S.row||null,d.manual_cat.config.col=S.col||null,d.manual_cat.flags={row:!!d.model.get("manual_row_cat"),col:!!d.model.get("manual_col_cat")},["row","col"].forEach(F=>{if(!d.manual_cat.flags[F])return;let D=d.obs_store?.manual_cat?.[F],L=d.manual_cat.config?.[F]?.attribute||null;D&&D.setAttribute(L),y(F,{sync:!1})}),m()})();let _=()=>{d.attr.category_colors=d.model.get("category_colors")||{}};_(),d.model.on("change:category_colors",_),d.model.on("change:selected_genes",()=>{d.obs_store.selected_genes.set(d.model.get("selected_genes")||[])}),d.model.on("change:top_n_genes",()=>{d.top_n_genes=d.model.get("top_n_genes")||50})}return{obs_store:d.obs_store,finalize:()=>{c.finalize()}}};var DU=(t,A,j,e)=>{let r=[];for(let n=0;n{let r=Math.pow(2,A),n=j/(2*r),i=e/(2*r);return t.map(o=>({cell_id:o.cell_id,min_x:o.x-n,max_x:o.x+n,min_y:o.y-i,max_y:o.y+i,center_x:o.x,center_y:o.y}))},NU=(t,A,j,e,r)=>{let n=IpA(t,A,j,e),i=new Map;return n.forEach(o=>{Dv(o.min_x,o.max_x,o.min_y,o.max_y,r).forEach(c=>{i.has(c.name)||i.set(c.name,c)})}),Array.from(i.values())};var MpA=(t,A)=>t*A,rh=(t,A,j)=>{let e=MpA(A,j);return Math.max(1,Math.ceil(t/e))};var KU=0,OpA=(t,A)=>{let j=document.createElement("div");j.className="query_container",j.style.display="flex",j.style.flexDirection="column",j.style.marginLeft="5px",j.style.marginTop="3px",j.style.minWidth="130px",j.style.maxWidth="150px";let e=document.createElement("div");e.textContent="Query Cells",e.style.fontSize="11px",e.style.fontWeight="bold",e.style.color="#47515b",e.style.marginBottom="3px",e.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',j.appendChild(e);let r=document.createElement("div");r.style.display="flex",r.style.flexDirection="row",r.style.alignItems="center",r.style.marginBottom="2px";let n=document.createElement("span");n.textContent="Cluster:",n.style.fontSize="10px",n.style.width="42px",n.style.color="#555",r.appendChild(n);let i=document.createElement("input");i.type="text",i.placeholder="",i.style.width="70px",i.style.height="16px",i.style.fontSize="11px",i.style.border="1px solid #d3d3d3",i.style.borderRadius="2px",i.style.padding="1px 3px",KU+=1;let o=`${KU}_${Date.now()}`,l=document.createElement("datalist");l.id=`yearbook_cluster_datalist_${o}`,i.setAttribute("list",l.id),t.cats.cluster_counts&&t.cats.cluster_counts.forEach(v=>{let _=document.createElement("option");_.value=v.name,l.appendChild(_)}),r.appendChild(i),r.appendChild(l),j.appendChild(r);let c=document.createElement("div");c.style.display="flex",c.style.flexDirection="row",c.style.alignItems="center",c.style.marginBottom="3px";let B=document.createElement("span");B.textContent="Gene:",B.style.fontSize="10px",B.style.width="42px",B.style.color="#555",c.appendChild(B);let h=document.createElement("input");h.type="text",h.placeholder="",h.style.width="70px",h.style.height="16px",h.style.fontSize="11px",h.style.border="1px solid #d3d3d3",h.style.borderRadius="2px",h.style.padding="1px 3px";let d=document.createElement("datalist");d.id=`yearbook_gene_datalist_${o}`,h.setAttribute("list",d.id),t.genes.gene_names&&t.genes.gene_names.forEach(v=>{let _=document.createElement("option");_.value=v,d.appendChild(_)}),c.appendChild(h),c.appendChild(d),j.appendChild(c);let k=document.createElement("div");k.style.display="flex",k.style.flexDirection="row",k.style.gap="5px";let g=document.createElement("button");g.textContent="Query",g.style.padding="3px 10px",g.style.fontSize="11px",g.style.cursor="pointer",g.style.border="1px solid #8797ff",g.style.borderRadius="3px",g.style.backgroundColor="#8797ff",g.style.color="white",g.style.fontWeight="bold",g.onmouseenter=()=>{g.style.backgroundColor="#6677ee"},g.onmouseleave=()=>{g.style.backgroundColor="#8797ff"};let E=document.createElement("button");E.textContent="Clear",E.style.padding="3px 8px",E.style.fontSize="11px",E.style.cursor="pointer",E.style.border="1px solid #d3d3d3",E.style.borderRadius="3px",E.style.backgroundColor="#f0f0f0",E.style.color="#555";let m=()=>{let v=i.value.trim(),_=h.value.trim(),w=!v||t.cats.cluster_counts?.some(F=>F.name===v),x=!_||t.genes.gene_names?.includes(_);if(w)i.style.borderColor="#d3d3d3";else{i.style.borderColor="#ff6666";return}if(x)h.style.borderColor="#d3d3d3";else{h.style.borderColor="#ff6666";return}let S={};if(v){let F=t.cats.inst_cell_attr||"leiden";S.cluster={attr:F,value:v}}_&&(S.gene=_),Object.keys(S).length>0&&A(S)};g.onclick=m;let y=v=>{v.key==="Enter"&&m()};i.addEventListener("keydown",y),h.addEventListener("keydown",y),E.onclick=()=>{i.value="",h.value="",i.style.borderColor="#d3d3d3",h.style.borderColor="#d3d3d3"},k.appendChild(g),k.appendChild(E),j.appendChild(k);let b=document.createElement("div");return b.className="query_status",b.style.fontSize="10px",b.style.color="#888",b.style.marginTop="3px",b.style.maxHeight="30px",b.style.overflow="hidden",b.style.textOverflow="ellipsis",j.appendChild(b),t.yearbook.query_ui={cluster_input:i,gene_input:h,status_text:b,update_status:v=>{b.textContent=v}},j},TpA=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.style.border="1px solid #d3d3d3",t.className="ui_container",t.style.height="100px",t.style.boxSizing="border-box",t.style.width="100%",t.style.maxWidth="100%",t.style.margin="0 auto",t},SpA=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.className="ctrl_container",t.style.width="100%",t},$l=(t,A,j=null)=>{let e=document.createElement("div");return e.className=t,e.style.display="flex",e.style.flexDirection=A,j!==null&&(e.style.height=`${j}px`,e.style.overflow="scroll"),e},YI=t=>{let A=document.createElement("div");return A.className=t,A.style.width="100%",A.style.marginLeft="2px",A.style.marginTop="2px",A},RpA=(t,A)=>{let j=document.createElement("div");j.className="pagination_container",j.style.display="flex",j.style.flexDirection="column",j.style.alignItems="center",j.style.justifyContent="center",j.style.marginLeft="10px",j.style.marginRight="10px",j.style.minWidth="100px";let{cells:e,num_rows:r,num_cols:n,current_page:i}=t.yearbook,o=rh(e.length,r,n),l="#8797ff",c="gray",B=document.createElement("div");B.className="page_text",B.style.fontSize="12px",B.style.fontWeight="bold",B.style.color="#47515b",B.style.marginBottom="5px",B.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',B.textContent=`${i+1} / ${o}`;let h=document.createElement("div");h.style.display="flex",h.style.flexDirection="row",h.style.gap="5px";let d=document.createElement("button");d.textContent="\u25C0",d.style.padding="4px 8px",d.style.cursor="pointer",d.style.border="1px solid #d3d3d3",d.style.borderRadius="4px",d.style.backgroundColor=i>0?"#f0f0f0":"#e0e0e0",d.style.color=i>0?"#333":"#999",d.disabled=i===0,d.onclick=()=>{if(t.yearbook.current_page>0){let x=t.yearbook.current_page-1;A(x)}};let k=document.createElement("button");k.textContent="\u25B6",k.style.padding="4px 8px",k.style.cursor="pointer",k.style.border="1px solid #d3d3d3",k.style.borderRadius="4px",k.style.backgroundColor=i=o-1,k.onclick=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols);if(t.yearbook.current_page{let S=document.createElement("span");return S.textContent=x,S.style.fontSize="11px",S.style.fontWeight="bold",S.style.cursor="pointer",S.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',S.style.userSelect="none",S},m=E("START");m.style.color=i===0?l:c,m.onclick=()=>{t.yearbook.current_page!==0&&A(0)};let y=Math.floor((o-1)/2),b=E("MID");b.style.color=i===y?l:c,b.onclick=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols),S=Math.floor((x-1)/2);t.yearbook.current_page!==S&&A(S)};let v=o-1,_=E("END");_.style.color=i===v?l:c,_.onclick=()=>{let S=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols)-1;t.yearbook.current_page!==S&&A(S)};let w=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols),S=t.yearbook.current_page,F=Math.floor((x-1)/2),D=x-1;B.textContent=`${S+1} / ${x}`,d.disabled=S===0,d.style.backgroundColor=S>0?"#f0f0f0":"#e0e0e0",d.style.color=S>0?"#333":"#999",k.disabled=S>=x-1,k.style.backgroundColor=S{let i=TpA(),o=SpA();e.containers.image=$l("image_container","column");let l=$l("img_layers_container","column",72);l.style.width="135px",l.style.border="1px solid #d3d3d3",l.style.marginTop="3px",l.style.marginLeft="2px",l.addEventListener("wheel",L=>{let{scrollTop:z,scrollHeight:T,clientHeight:W}=l,G=z===0,jA=z+W===T;(G&&L.deltaY<0||jA&&L.deltaY>0)&&L.preventDefault()});let c="115px",B=$l("cell_container","column");B.style.width=c;let h=$l("cell_ctrl_container","row");h.style.marginLeft="0px";let d=$l("gene_container","column");d.style.marginTop="0px",d.style.width=c;let k=$l("trx_container","row"),g=YI("cell_slider_container"),E=YI("trx_slider_container"),m=$l("image_layer_container","row");kn(m,"ist","IMG","blue",30,"button",A,j,e),e.containers.image.appendChild(m);let y=(L,z)=>L.image_layer_sliders.filter(T=>T.name===z),b=(L,z)=>{let T=z.button_name,W=$l("image_layer_container","row");W.style.height="21px",kn(W,"ist",T,"blue",75,"img_layer_button",A,j,e);let G=YI(T),jA=y(L,T)[0],pA=f_(T,A,j,e),$A=Sf(pA,100);Df(jA,50,$A),G.appendChild(jA),W.appendChild(G),l.appendChild(W)};e.img.image_info.map(L=>b(e.img,L)),e.obs_store.viz_image_layers.subscribe(L=>{VA(e.containers.image).selectAll(".img_layer_button").style("color",L?"blue":"gray"),e.img.image_layer_sliders.map(z=>Rj(z,L)),Cf(j,L),TA(e,j,"image_layers")}),e.obs_store.viz_background_layer.subscribe(L=>{i_(j,L),TA(e,j,"background_layer")}),e.containers.image.appendChild(l),kn(h,"ist","CELL","blue",40,"button",A,j,e),kn(k,"ist","TRX","blue",40,"button",A,j,e),e.sliders={},kl("cell",A,j,e),g.appendChild(e.sliders.cell),h.appendChild(g),e.containers.bar_cluster=ju(),e.cats.svg_bar_cluster=Ur("svg"),e.genes.svg_bar_gene=Ur("svg"),Za(e.containers.bar_cluster,Nf,e.cats.svg_bar_cluster,e.cats.cluster_counts,e.cats.color_dict_cluster,A,j,e),e.containers.bar_gene=ju();let v=1e3;e.genes.gene_counts=e.genes.gene_counts.sort((L,z)=>z.value-L.value).slice(0,v),Za(e.containers.bar_gene,Kf,e.genes.svg_bar_gene,e.genes.top_gene_counts,e.genes.color_dict_gene,A,j,e);let _=(L,z)=>T=>{if(!Array.isArray(T)||T.length===0)L.selectAll("g").attr("font-weight","normal").attr("opacity",1),z.scrollTo({top:0,behavior:"smooth"});else if(L.selectAll("g").attr("font-weight",W=>T.includes(W.name)?"bold":"normal").attr("opacity",W=>T.includes(W.name)?1:.2),T.length===1){let W=T[0],G=L.selectAll("g").filter(function(){return VA(this).select("text").text()===W});if(!G.empty()){let jA=G.node(),pA=z.getBoundingClientRect(),dA=jA.getBoundingClientRect(),$A=dA.top,_A=dA.bottom,Y=pA.top,QA=pA.bottom;if(!($A>=Y&&_A<=QA)){let Ct=$A-Y,SA=z.scrollTop+Ct;z.scrollTo({top:SA,behavior:"smooth"})}}}};e.obs_store.selected_cats.subscribe(_(e.cats.svg_bar_cluster,e.containers.bar_cluster),{immediate:!1}),e.obs_store.selected_genes.subscribe(_(e.genes.svg_bar_gene,e.containers.bar_gene),{immediate:!1});let w=({svg:L,color_dict:z,selected_array:T,bar_callback:W,container:G})=>jA=>{let dA=15*(jA.length+1);L.attr("height",dA);let $A=90,_A=jA.map(ft=>ft.value),Y=ti().domain(F6(_A.length)).range([0,16*_A.length]),QA=ji().domain([0,xj(_A)]).range([0,$A]),mt=L.selectAll("g").data(jA,ft=>ft.name),Ct=mt.enter().append("g").attr("transform",(ft,wA)=>`translate(2,${Y(wA)+2})`).on("click",(ft,wA)=>W(ft,wA,A,j,e));Ct.append("rect").attr("width",0).attr("height",Y.bandwidth()-1).transition().duration(750).attr("width",ft=>QA(ft.value)),Ct.append("text").attr("fill","black").attr("x","5px").attr("y",Y.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").attr("opacity",0).text(ft=>ft.name).transition().duration(750).attr("opacity",1);let SA=mt.merge(Ct);SA.transition().duration(750).attr("transform",(ft,wA)=>`translate(2,${Y(wA)+2})`),SA.select("rect").attr("width",ft=>QA(ft.value)).attr("fill",ft=>{let wA=z[ft.name]||[0,0,0],_t=T.length===0||T.includes(ft.name)?1:.1;return`rgba(${wA[0]}, ${wA[1]}, ${wA[2]}, ${_t})`}),SA.select("text").text(ft=>ft.name),mt.exit().transition().duration(750).attr("opacity",0).remove(),G&&G.scrollTo({top:0,behavior:"smooth"})};e.obs_store.new_cell_bar_data.subscribe(w({svg:e.cats.svg_bar_cluster,color_dict:e.cats.color_dict_cluster,selected_array:e.cats.selected_cats,bar_callback:Nf,container:e.containers.bar_cluster}),{immediate:!1}),e.obs_store.new_gene_bar_data.subscribe(w({svg:e.genes.svg_bar_gene,color_dict:e.genes.color_dict_gene,selected_array:e.genes.selected_genes,bar_callback:Kf,container:e.containers.bar_gene}),{immediate:!1}),B.appendChild(h),B.appendChild(e.containers.bar_cluster),kl("trx",A,j,e),k.appendChild(E),E.appendChild(e.sliders.trx),d.appendChild(k),d.appendChild(e.containers.bar_gene),rg("ist",A,j,e),e.genes.gene_search.style.marginLeft="0px",e.obs_store.selected_genes.subscribe(async L=>{if(L.length===1){let z=L[0];if(e.genes.gene_search_input.value=z,z!==""){if(e.genes.gene_names.includes(z)){e.genes.gene_text_box.textContent="loading",await nu(z);let T=A7[z];T&&T.name&&T.description?e.genes.gene_text_box.innerHTML=`${T.name}
${T.description}`:e.genes.gene_text_box.textContent=""}}else e.genes.gene_text_box.textContent="";e.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else L.length===0&&(e.genes.gene_search_input.value="",e.genes.gene_text_box.textContent="")}),i.appendChild(o),o.appendChild(e.containers.image),o.appendChild(B),o.appendChild(d),e.genes.gene_search.style.width="160px",e.genes.gene_search.style.marginLeft="5px",o.appendChild(e.genes.gene_search);let x=OpA(e,n);o.appendChild(x);let S=RpA(e,r);o.appendChild(S);let F=document.createElement("div");F.className="logo_button",F.style.marginTop="5px",F.style.marginRight="5px",F.style.cursor="pointer";let D=document.createElement("img");return D.src=`data:image/png;base64,${x_}`,D.alt="Celldega logo",D.style.height="17px",D.style.transition="transform 0.2s ease, filter 0.2s ease",F.onclick=()=>{window.open("https://broadinstitute.github.io/celldega/","_blank")},F.appendChild(D),i.appendChild(F),i};var JI=t=>{let A=[...t];for(let j=A.length-1;j>0;j--){let e=Math.floor(Math.random()*(j+1));[A[j],A[e]]=[A[e],A[j]]}return A},LpA=(t,A,j)=>{if(A[t]!==void 0)return A[t];if(j&&typeof t=="string"){let e=t.indexOf("_");if(e>=0){let r=t.substring(e+1);if(A[r]!==void 0)return A[r]}}},CpA=async(t,A,j,e="cluster")=>{let r=A&&A!=="default"?`_${A}`:"",n=`${t}/cell_clusters${r}/cluster.parquet`,i=await ae(n,Nt.fetch,j);if(!i)return new Map;let o=i.getChild("__index_level_0__")?.toArray()||[],l=i.getChild(e)?.toArray()||i.getChild("cluster")?.toArray()||[],c=new Map;return o.forEach((B,h)=>{c.set(String(B),String(l[h]))}),c},HpA=async(t,A,j,e,r=null)=>{let n;if(r)try{n=await r.readGene(e)}catch{n=null}else{let h=A&&A!=="default"?`_${A}`:"",d=`${t}/cbg${h}/${e}.parquet`;n=await ae(d,Nt.fetch,j)}if(!n)return new Map;let i=n.getChild("__index_level_0__")||n.getChild("cell_id")||n.getChild("cell_name")||n.getChild("index");if(!i)return new Map;let o=i.toArray(),l=n.getChild(e)||n.getChild("expression");if(!l)return console.warn(`Gene expression column '${e}' or 'expression' not found. Available columns:`,n.schema.fields.map(h=>h.name)),new Map;let c=l.toArray(),B=new Map;return o.forEach((h,d)=>{B.set(String(h),Number(c[d]))}),B},DpA=(t,A)=>{if(!A.vector_name_integer)return t;let{nameMapping_inv:j}=A.cats;if(!j)return t;let e=new Map;return t.forEach((r,n)=>{let i=j[n];i&&e.set(String(i),r)}),e},zU=async(t,A,j=100)=>{if(!t||Object.keys(t).length===0)return[];let e=t.cluster,r=t.gene,{max_cells:n}=t,i;n!==void 0?i=n:e&&!r?i=j:i=1/0;let o=A.cats.cell_names_array||[];if(o.length===0)return[];let l=[...o];if(e){let c=e.attr||"leiden",B=String(e.value),h=A.cell_name_prefix||!1;if(A.cats.has_meta_cell&&A.cats.meta_cell){let d=A.cats.meta_cell_attr.indexOf(c);d>=0?l=l.filter(k=>{let g=LpA(k,A.cats.meta_cell,h);return g?String(g[d])===B:!1}):console.warn(`Cluster attribute '${c}' not found`)}else if(A.cats.dict_cell_cats&&Object.keys(A.cats.dict_cell_cats).length>0)l=l.filter(d=>String(A.cats.dict_cell_cats[d])===B);else try{let d=await CpA(A.global_base_url,A.seg.version,A.aws,c);l=l.filter(k=>d.get(k)===B)}catch{return[]}}if(l.length===0)return[];if(r)try{let c=await HpA(A.global_base_url,A.seg.version,A.aws,r,A.row_group_readers?.cbg),B=DpA(c,A);B.size>0?l=l.map(d=>({name:d,exp:B.get(d)||0})).filter(d=>d.exp>=1).sort((d,k)=>k.exp-d.exp).map(d=>d.name):l=JI(l)}catch{l=JI(l)}else!r&&e&&(l=JI(l));return i!==1/0&&l.length>i?l.slice(0,i):l};async function NpA(t,A){let j=t.img.landscape_parameters;if(!j.use_row_groups){t.use_row_groups=!1;return}let e=j.row_group_files||{},r=j.tile_grid||{};if(!r.num_tiles_x||!r.num_tiles_y){t.use_row_groups=!1;return}t.use_row_groups=!0,t.row_group_readers={},t.tile_grid=r;try{if(e.transcripts&&(t.row_group_readers.trx=new ml(A,r,e.transcripts),await t.row_group_readers.trx.initialize()),e.cell_segmentation&&(t.row_group_readers.cell=new ml(A,r,e.cell_segmentation),await t.row_group_readers.cell.initialize()),e.cbg&&(t.row_group_readers.cbg=new Ah(A,e.cbg),await t.row_group_readers.cbg.initialize()),e.images){t.row_group_readers.images={};for(let[n,i]of Object.entries(e.images))t.row_group_readers.images[n]=new th(A,i),await t.row_group_readers.images[n].initialize()}}catch{t.use_row_groups=!1}}var KpA=(t,A,j)=>{let e=t/j;return Math.log2(A/e)},ZI=async(t,A,j,e,r="",n=[],i=2,o=3,l=50,c=4,B=0,h=800,d={},k=[],g={},E=[],m="default",y={},b=null,v=0,_={},w=!1)=>{B===0&&(B="100%");let x={};x.obs_store=Zf(),x.highlighted_cells=new Set,x.selection_token=0,x.cell_name_prefix=w,x.yearbook={cells:n,num_rows:i,num_cols:o,portrait_size_um:l,portrait_gap:c,current_page:v,zoom_level:0,portrait_centers:[],query:_},x.max_tiles_to_view=50,x.seg={},x.seg.version=m,x.root=t,x.buttons={},x.buttons.blue="#8797ff",x.buttons.gray="gray",x.buttons.light_gray="#EEEEEE",x.buttons.buttons={},Es(x,e),x.close_up=!0,x.model=A,x.containers={},x.containers.root_dim={},x.containers.root_dim.width=B,x.containers.root_dim.height=h,x.cats={},x.cats.cat=null,x.cats.reset_cat=!1,x.cats.selected_cats=[],x.cats.cell_cats=[],x.cats.dict_cell_cats={},x.cats.color_dict_cluster={},x.cats.cluster_counts=[],x.cats.polygon_cell_names=[],Object.keys(d).length===0?x.cats.has_meta_cell=!1:x.cats.has_meta_cell=!0,x.cats.meta_cell=d,x.cats.meta_cell_attr=k,x.cats.meta_cell_id_set=new Set(Object.keys(d||{}).map(fA=>String(fA))),x.cats.inst_cell_attr=k[0]||"N.A.",Object.keys(g).length===0?x.cats.has_meta_cluster=!1:x.cats.has_meta_cluster=!0,x.cats.meta_cluster=g,x.cats.meta_cluster_attr=E,x.cats.inst_cluster_attr=E[0]||"N.A.",x.genes={},x.genes.color_dict_gene={},x.genes.gene_names=[],x.genes.meta_gene={},x.genes.gene_counts=[],x.genes.selected_genes=[],x.genes.trx_ini_radius=.25,x.genes.trx_names_array=[],x.genes.trx_data=[],x.genes.gene_text_box="",x.genes.trx_slider=document.createElement("input"),x.genes.gene_search=document.createElement("div"),x.cats.cell_exp_array=[],x.cats.cell_names_array=[],x.cats.cell_name_to_index_map=new Map,x.img={},x.img.image_layer_colors={},x.img.image_layer_sliders={},x.umap={},x.umap.has_umap=!1,x.umap.umap={},x.nbhd={},x.nbhd.visible=!1,x.nbhd.edit=!1,x.nbhd.is_nbhd=!1,x.nbhd.feature_collection={type:"FeatureCollection",features:[]},x.spatial={},"accessKeyId"in y?x.aws=new Yo({accessKeyId:y.accessKeyId,secretAccessKey:y.secretAccessKey,sessionToken:y.sessionToken}):x.aws=null,x.rotation={hasRotation:!1},Z7(j),await xs(x.img,e,x.aws);let S=x.img.landscape_parameters.technology;await NpA(x,e);let F=x.img.landscape_parameters.image_info,D=F[0].name;x.vector_name_integer=x.img.landscape_parameters.use_int_index,Qf(x.img,x.img.landscape_parameters.image_format),Wf(x.img,F),Hf(x.img),Yf(x.img.image_layer_colors,x.img.image_info);let L=document.createElement("div");L.style.position="relative",L.style.height=`${h}px`,L.style.border="1px solid #d3d3d3";let z=typeof b=="number"&&!Number.isNaN(b)&&b>0?b:null,W=q_[S]??z;x.yearbook.micronsPerPixel=W,W&&(x.scale_bar=G_(W,S),L.appendChild(x.scale_bar.container)),await $s(x,e,D),await gl(x.genes,e,x.seg.version,x.aws),await Jf(x);let G=async fA=>{if(!fA||Object.keys(fA).length===0)return[];let PA=i*o*10;try{return await zU(fA,x,PA)}catch{return[]}};x.cache={},x.cache.cell=await Vf(),x.cache.trx=await Vf(),x.combo_data={},x.combo_data.trx=[],x.combo_data.cell=[],x.tooltip_cat_cell="",x.edit={},x.edit.feature_collection={type:"FeatureCollection",features:[]},x.edit.visible=!1;let jA=typeof B=="string"?t.clientWidth||1e3:B,pA=jA-(o-1)*c,dA=h-100-(i-1)*c,$A=pA/o,_A=dA/i,Y=Math.min($A,_A);if(x.yearbook.portrait_pixel_size=Y,W){let fA=KpA(l,Y,W);x.yearbook.zoom_level=fA,x.yearbook.portrait_data_size=l/W}else x.yearbook.portrait_data_size=l/.2125;let QA=Rf(x),mt=[],Ct=await c_(e,x),SA=await Wv(x),ft=Zv(x);if(x.yearbook.cells.length===0){let fA=[];if(Object.keys(_).length>0)fA=await G(_);else{let PA=x.cats.cell_names_array||[],RA=i*o*10;PA.length>0&&(fA=[...PA].sort(()=>Math.random()-.5).slice(0,Math.min(RA,PA.length)))}x.yearbook.cells=fA,x.model&&typeof x.model.set=="function"&&(x.model.set("cells",fA),x.model.save_changes())}let wA=DU(i,o,Y,c);x.views=wA;let _t=await e_(L,jA,h-100,S);r_(_t,wA),n_(_t,x),_t.setProps({layerFilter:({layer:fA,viewport:PA})=>{let Gt=fA.id.match(/-p(\d+)-/);if(Gt){let we=`portrait-${parseInt(Gt[1],10)}`;return PA.id===we}return!0}});let qA={background_layer:QA,image_layers:mt,cell_layer:Ct,path_layer:SA,trx_layer:ft,nbhd_layer:null,edit_layer:null};x.layers_obj=qA;let Ht={},bA=()=>{let fA=x.yearbook.portrait_centers,{portrait_data_size:PA}=x.yearbook,RA=PA/2,we=(x.combo_data.trx||[]).filter(bt=>fA.some(J=>bt.x>=J.x-RA&&bt.x<=J.x+RA&&bt.y>=J.y-RA&&bt.y<=J.y+RA)).map(bt=>bt.name).reduce((bt,J)=>{let P=bt.find(O=>O.name===J);return P?P.value+=1:bt.push({name:J,value:1}),bt},[]).filter(bt=>bt.value>0).sort((bt,J)=>J.value-bt.value).slice(0,100);x.obs_store.new_gene_bar_data.set(we);let Ij=(x.combo_data.cell||[]).filter(bt=>fA.some(J=>bt.x>=J.x-RA&&bt.x<=J.x+RA&&bt.y>=J.y-RA&&bt.y<=J.y+RA)).map(bt=>bt.cat).reduce((bt,J)=>{let P=bt.find(O=>O.name===J);return P?P.value+=1:bt.push({name:J,value:1}),bt},[]).filter(bt=>bt.value>0).sort((bt,J)=>J.value-bt.value);x.obs_store.new_cell_bar_data.set(Ij)},l6=async()=>{let fA=i*o,PA=x.yearbook.current_page,RA=x.yearbook.cells,Gt=PA*fA,we=RA.slice(Gt,Gt+fA).map(Ee=>{let MA=x.cats.cell_name_to_index_map.get(Ee);if(MA!==void 0&&x.spatial.cell_scatter_data_objects){let Ij=x.spatial.cell_scatter_data_objects[MA];if(Ij&&Ij.position)return{cell_id:Ee,x:Ij.position[0],y:Ij.position[1]}}return{cell_id:Ee,x:x.dimensions.width/2,y:x.dimensions.height/2}});return x.yearbook.portrait_centers=we,we},Tt=async()=>{let fA=await l6(),{zoom_level:PA,portrait_data_size:RA}=x.yearbook,{tile_size:Gt}=x.img.landscape_parameters,EA=NU(fA,0,RA,RA,Gt);await t_(e,EA,qA,x),await Yv(e,EA,qA,x);let we=`page${x.yearbook.current_page}`;qA.image_layers=await iz(x,fA,RA,we);let Ee=x.obs_store.viz_image_layers.get();Cf(qA,Ee),x.layers_obj=qA;let MA={};fA.forEach((J,P)=>{let O=`portrait-${P}`;MA[O]={target:[J.x,J.y,0],zoom:PA},Ht[O]=MA[O]});let Ij=Date.now();qA.cell_layer=qA.cell_layer.clone({id:`cell-layer-page-${x.yearbook.current_page}-${Ij}`}),qA.path_layer=qA.path_layer.clone({id:`path-layer-page-${x.yearbook.current_page}-${Ij}`}),qA.trx_layer=qA.trx_layer.clone({id:`trx-layer-page-${x.yearbook.current_page}-${Ij}`});let bt=Wr(qA,x.close_up).filter(J=>J!==null);_t.setProps({initialViewState:MA,layers:bt}),bA(),x.scale_bar&&x.scale_bar.update({zoom:PA})};u_(_t,qA,x),Jv(_t,qA,x),A_(_t,qA,x),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),background_layer:!0,cell_layer:!0,path_layer:!0,trx_layer:!0}),x.obs_store.deck_ready.subscribe(fA=>{if(fA){let PA=Wr(x.layers_obj,x.close_up).filter(RA=>RA!==null);_t.setProps({layers:PA})}}),x.obs_store.selected_cats.subscribe(fA=>{let PA=fA.join("-");qA.cell_layer=qA.cell_layer.clone({id:`cell-layer-${PA}-sel-${x.selection_token}`}),qA.path_layer=qA.path_layer.clone({id:`path-layer-${PA}`}),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0})}),x.obs_store.selected_genes.subscribe(fA=>{let PA=fA.join("-");qA.trx_layer=qA.trx_layer.clone({id:`trx-layer-${PA}`}),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),trx_layer:!0})}),Tf(qA,.25);let me=()=>{let fA=x.yearbook.portrait_centers,PA=x.yearbook.zoom_level;fA.forEach((RA,Gt)=>{Ht[`portrait-${Gt}`]={target:[RA.x,RA.y,0],zoom:PA}})};await Tt(),me();let FA=!1,yj=async fA=>{if(!FA){FA=!0;try{x.yearbook.current_page=fA,await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui(),x.model&&typeof x.model.set=="function"&&(x.model.set("current_page",fA),x.model.save_changes())}finally{setTimeout(()=>{FA=!1},300)}}},cj=!1,ce=fA=>{if(cj)return;cj=!0,x.yearbook.zoom_level=fA,x.yearbook.portrait_centers.forEach((RA,Gt)=>{Ht[`portrait-${Gt}`]={target:[RA.x,RA.y,0],zoom:fA}}),x.scale_bar&&x.scale_bar.update({zoom:fA}),_t.setProps({initialViewState:{...Ht}}),x.model&&typeof x.model.set=="function"&&(x.model.set("zoom_level",fA),x.model.save_changes()),setTimeout(()=>{cj=!1},100)};_t.setProps({onViewStateChange:({viewState:fA})=>{let PA=fA.zoom,RA=x.yearbook.zoom_level;return Math.abs(PA-RA)>.01&&!cj&&requestAnimationFrame(()=>{ce(PA)}),fA}});let Uj=async fA=>{x.yearbook.query=fA,x.yearbook.query_ui&&x.yearbook.query_ui.update_status("Searching...");try{if(fA.gene){let RA=fA.gene;gt(x.cats,RA),x.genes.selected_genes=[RA],x.obs_store.selected_genes.set([RA]),await qr(x.cats,x.genes,x.global_base_url,RA,x.seg.version,x.vector_name_integer,x.aws,x.row_group_readers?.cbg),x.cats.selected_cats=[RA],x.obs_store.selected_cats.set([RA]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer")}else gt(x.cats,"cluster"),x.genes.selected_genes=[],x.obs_store.selected_genes.set([]),x.cats.selected_cats=[],x.obs_store.selected_cats.set([]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer");let PA=await G(fA);if(x.yearbook.cells=PA,x.yearbook.query_ui){let RA=PA.length;x.yearbook.query_ui.update_status(`Found ${RA} cells`)}x.model&&typeof x.model.set=="function"&&(x.model.set("cells",PA),x.model.set("query",fA),x.model.set("current_page",0),x.model.save_changes()),x.yearbook.current_page=0,await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui()}catch{x.yearbook.query_ui&&x.yearbook.query_ui.update_status("Query failed")}},KA=XU(r,_t,qA,x,yj,Uj);return Object.keys(x.model).length>0&&(x.model.on("change:current_page",()=>{let fA=x.model.get("current_page");fA!==x.yearbook.current_page&&yj(fA)}),x.model.on("change:cells",async()=>{x.yearbook.cells=x.model.get("cells"),await Tt(),me()}),x.model.on("change:zoom_level",()=>{let fA=x.model.get("zoom_level");Math.abs(fA-x.yearbook.zoom_level)>.01&&ce(fA)}),x.model.on("change:query",async()=>{let fA=x.model.get("query")||{};if(x.yearbook.query=fA,x.yearbook.query_ui){let{cluster_input:PA,gene_input:RA,update_status:Gt}=x.yearbook.query_ui;fA.cluster?PA.value=fA.cluster.value||"":PA.value="",fA.gene?RA.value=fA.gene||"":RA.value="",Gt("Searching...")}if(Object.keys(fA).length>0){if(fA.gene){let RA=fA.gene;gt(x.cats,RA),x.genes.selected_genes=[RA],x.obs_store.selected_genes.set([RA]),await qr(x.cats,x.genes,x.global_base_url,RA,x.seg.version,x.vector_name_integer,x.aws),x.cats.selected_cats=[RA],x.obs_store.selected_cats.set([RA]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer")}else gt(x.cats,"cluster"),x.genes.selected_genes=[],x.obs_store.selected_genes.set([]),x.cats.selected_cats=[],x.obs_store.selected_cats.set([]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer");let PA=await G(fA);x.yearbook.cells=PA,x.yearbook.query_ui&&x.yearbook.query_ui.update_status(`Found ${PA.length} cells`),x.model.set("cells",PA),x.model.save_changes(),x.yearbook.current_page=0,x.model.set("current_page",0),await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui()}})),t.appendChild(KA),t.appendChild(L),{update_page:yj,refresh:async()=>{await Tt(),me()},update_query:async fA=>{await Uj(fA)},update_cluster:async(fA,PA="leiden")=>{let Gt={...x.yearbook.query||{},cluster:{attr:PA,value:String(fA)}};await Uj(Gt)},update_gene:async fA=>{let RA={...x.yearbook.query||{},gene:fA};await Uj(RA)},get_query:()=>x.yearbook.query||{},finalize:()=>{_t.finalize()}}};var UU=async(t,A=null)=>{let j="https://maayanlab.cloud/Enrichr/addList",e=new FormData;e.append("list",t.join(` +}`;var su=class extends mr{getShaders(){let A=super.getShaders();return A.vs=eU,A.fs=rU,A}draw({uniforms:A}){super.draw({uniforms:{...A,tile_height:this.props.tile_height,tile_width:this.props.tile_width}})}};var nU=(t,A,j)=>{let e=A.hovered_cat;if(!e||!e.name||t.name===e.name)return t.color;let[r,n,i]=t.color.slice(0,3);return[r,n,i,40]},hpA=(t,A,j)=>{let e=t.object?.level,r=t.object?.original_index,n=t.object?.name;if(e===void 0||r===void 0)return;let i=A.attr.names[j]?.[e];if(!i)return;let o=j==="row"?A.row_nodes[r].name:A.col_nodes[r].name,l=j==="row"?A.row_nodes:A.col_nodes,c=`cat-${e}`,B=l.filter(d=>d[c]===n).map(d=>d.name),h=j==="row"?A.row_entity:A.col_entity;if(A.click.type="cat_value",A.click.value={axis:j,attr_name:i,attr_index:e,value:n,node_name:o,node_names:B,entity:h.entity,attr:h.attr,row_entity_full:A.row_entity,col_entity_full:A.col_entity},A.obs_store?.selected_category){let d=A.obs_store.selected_category.get();d&&d.axis===j&&d.attr_index===e&&d.value===n?A.obs_store.selected_category.set(null):A.obs_store.selected_category.set({axis:j,attr_name:i,attr_index:e,value:n,node_names:B})}A.model?.set&&(A.model.set("click_info",null),A.model.set("click_info",A.click),A.model.save_changes())},dpA=(t,A,j,e,r)=>{let n=A.hovered_cat;if(!t.object){n&&(A.hovered_cat=null,r.row_cat_layer=r.row_cat_layer.clone({updateTriggers:{getFillColor:[null]}}),r.col_cat_layer=r.col_cat_layer.clone({updateTriggers:{getFillColor:[null]}}),e.setProps({layers:le(r)}),A.obs_store?.hovered_category&&A.obs_store.hovered_category.set(null));return}let i=t.object?.level,o=t.object?.name;if(!(i===void 0||o===void 0)&&!(n?.axis===j&&n?.level===i&&n?.name===o)&&(A.hovered_cat={axis:j,name:o,level:i},r.row_cat_layer=r.row_cat_layer.clone({updateTriggers:{getFillColor:[A.hovered_cat]}}),r.col_cat_layer=r.col_cat_layer.clone({updateTriggers:{getFillColor:[A.hovered_cat]}}),e.setProps({layers:le(r)}),A.obs_store?.hovered_category)){let l=A.attr.names[j]?.[i];A.obs_store.hovered_category.set({axis:j,attr_name:l,attr_index:i,value:o})}},iU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"row-layer",data:t.cats.row_cat_data,getPosition:e=>{let r=t.mat.orders.row[t.order.current.row],n=t.mat.num_rows-r[e.original_index];return[e.position[0]+t.viz.cat_shift_row,t.viz.row_offset*(n+1.5)]},getFillColor:e=>nU(e,t,"row"),pickable:!0,autoHighlight:!0,highlightColor:[255,255,255,80],transitions:A,opacity:.8,tile_width:t.viz.row_cat_width/2*.9,tile_height:t.viz.mat_height/t.mat.num_rows*.5})},oU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"col-layer",data:t.cats.col_cat_data,getPosition:e=>{let r=t.mat.orders.col[t.order.current.col],n=t.mat.num_cols-r[e.original_index];return[t.viz.col_offset*(n+.5),e.position[1]+t.viz.cat_shift_col]},getFillColor:e=>nU(e,t,"col"),pickable:!0,autoHighlight:!0,highlightColor:[255,255,255,80],transitions:A,opacity:.8,tile_width:t.viz.mat_width/t.mat.num_cols*.5,tile_height:t.viz.col_cat_height/2})},YI=(t,A,j,e)=>{let r=`${e}_cat_layer`;A[r]=A[r].clone({onClick:n=>{if(j.attr?.editor?.open){let i=n.object?.level,o=n.object?.original_index;if(i===void 0||o===void 0)return;let l=j.attr.names[e]?.[i];if(!l)return;let c=e==="row"?j.row_nodes[o].name:j.col_nodes[o].name,B=j.attr.all_defs?.[e]?.[i],h=n.object?.name,d=h==null?null:String(h),k=B?.color_map?.[d]||null;j.attr.editor.open({axis:e,selection:[c],attribute_name:l,initial_value:h,initial_color:k,position:n?.pixel?{x:n.pixel[0],y:n.pixel[1]}:void 0})}else hpA(n,j,e)},onHover:n=>dpA(n,j,e,t,A)})};var ppA=({isDragging:t})=>t?"grabbing":"pointer",sU=(t,A,j)=>(typeof A=="number"&&(A=A+100,j=j+100),new N7({parent:t,getCursor:ppA,width:A,height:j}));var kpA=(t,A,j)=>{let e=A.index,r=j.order.current.row,n=50,i=j.mat.num_rows-j.mat.orders.row[r][e],o=n,l=j.viz.row_offset*(i+1.5);return[o,l]},gpA=(t,A,j)=>{let e=A.index,r=j.order.current.col,n=50,i=j.mat.num_cols-j.mat.orders.col[r][e];return[j.viz.col_offset*(i+.5),n]},aU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new Ii({id:"row-label-layer",data:t.labels.row_label_data,getPosition:(e,r)=>kpA(e,r,t),getText:e=>e.display_name||e.name,getSize:t.viz.font_size.rows,getColor:[0,0,0],getAngle:0,getTextAnchor:"end",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:2,pickable:!0,transitions:A})},lU=t=>{function A(r,n){let i=Math.pow(2,r);return[0,75/n*i]}let j={getPosition:{duration:t.animate.duration,easing:I6}};return new Ii({id:"col-label-layer",data:t.labels.col_label_data,getPosition:(r,n)=>gpA(r,n,t),getText:r=>r.display_name||r.name,getSize:t.viz.font_size.cols,getColor:[0,0,0],getAngle:45,getTextAnchor:"start",getAlignmentBaseline:"bottom",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:2,pickable:!0,transitions:j,getPixelOffset:()=>A(t.zoom.zoom_data.matrix.zoom_x,t.mat.num_cols)})},cU=250,uU=(t,A,j,e,r,n)=>{let i=[],o=e==="col"?"row":"col";VA(j.el).selectAll(`.button-${o}`).classed("active",!1).style("border-color",j.buttons.gray),e==="col"?i=j.mat.net_mat.map(h=>h[n]):i=j.mat.net_mat[n];let l=Array.from(i.keys()).sort((h,d)=>i[d]-i[h]),c=l.length,B=Array(c);l.forEach((h,d)=>{B[h]=c-d}),j.mat.orders[o].custom=B,j.order.current[o]="custom",A.mat_layer=A.mat_layer.clone({updateTriggers:{getPosition:[j.order.current.row,j.order.current.col,r]}}),o==="col"?(A.col_label_layer=A.col_label_layer.clone({updateTriggers:{getPosition:[j.order.current.col,r]}}),A.col_cat_layer=A.col_cat_layer.clone({updateTriggers:{getPosition:j.order.current.col}}),eu(A,j,"col")):o==="row"&&(A.row_label_layer=A.row_label_layer.clone({updateTriggers:{getPosition:[j.order.current.row,r]}}),A.row_cat_layer=A.row_cat_layer.clone({updateTriggers:{getPosition:j.order.current.row}}),eu(A,j,"row")),t.setProps({layers:le(A)})},mpA=(t,A,j,e)=>{if(e.labels.clicks.row+=1,e.labels.clicks.row===1){e.click.type="row_label";let{name:r,index:n}=t.object;e.click.value={name:r,index:n,entity:e.row_entity.entity,attr:e.row_entity.attr,row_entity:e.row_entity.entity},setTimeout(()=>{e.labels.clicks.row=0},cU),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes(),Rl(e.model,"row",{index:n,max_entries:-1})),Wv(e,[r]),eg(e,[r]),typeof e.custom_callbacks.row=="function"&&e.custom_callbacks.row(r)}else e.labels.clicks.row===2&&(e.labels.clicks.row=0,uU(A,j,e,"row",t.object.name,t.object.index))},EpA=(t,A,j,e)=>{if(e.labels.clicks.col+=1,e.labels.clicks.col===1){e.click.type="col_label";let{name:r,index:n}=t.object;e.click.value={name:r,index:n,entity:e.col_entity.entity,attr:e.col_entity.attr,col_entity:e.col_entity.entity},setTimeout(()=>{e.labels.clicks.col=0},cU),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes(),Rl(e.model,"col",{index:n,max_entries:-1})),Yv(e,[r]);let i=t.object.index,o=e.mat.net_mat.map(h=>h[i]),l=Array.from(o.keys()).sort((h,d)=>o[d]-o[h]),c=e.top_n_genes||15,B=l.slice(0,c).map(h=>e.row_nodes[h].name);eg(e,B),typeof e.custom_callbacks.col=="function"&&e.custom_callbacks.col(r)}else e.labels.clicks.col===2&&(e.labels.clicks.col=0,uU(A,j,e,"col",t.object.name,t.object.index))},BU=(t,A,j)=>{A.row_label_layer=A.row_label_layer.clone({onClick:e=>mpA(e,t,A,j)})},fU=(t,A,j)=>{A.col_label_layer=A.col_label_layer.clone({onClick:e=>EpA(e,t,A,j)})};var $pA=(t,A)=>{let j=A.order.current.row,e=A.order.current.col,r=A.mat.num_cols-A.mat.orders.col[e][t.col],n=A.mat.num_rows-A.mat.orders.row[j][t.row],i=A.viz.col_width*(r+.5),o=A.viz.row_offset*(n+1.5);return[i,o]},hU=t=>{let A={getPosition:{duration:t.animate.duration,easing:I6}};return new su({id:"mat-layer",data:t.mat.mat_data,getPosition:e=>$pA(e,t),getFillColor:e=>e.color,pickable:!0,antialiasing:!1,tile_height:t.viz.mat_height/t.mat.num_rows*.5,tile_width:t.viz.mat_width/t.mat.num_cols*.5,transitions:A})},xpA=(t,A,j,e)=>{let r=t.object.row,n=t.object.col,i=e.labels.row_label_data[r].name,o=e.labels.col_label_data[n].name,l=e.mat.net_mat[r][n];e.click.type="mat_value",e.click.value={row:{name:i,index:r,entity:e.row_entity.entity,attr:e.row_entity.attr,row_entity:e.row_entity.entity},col:{name:o,index:n,entity:e.col_entity.entity,attr:e.col_entity.attr,col_entity:e.col_entity.entity},value:l,row_entity_full:e.row_entity,col_entity_full:e.col_entity},e.obs_store?.selected_cell&&e.obs_store.selected_cell.set({row_name:i,col_name:o,row_index:r,col_index:n,value:l}),e.model?.set&&(e.model.set("click_info",null),e.model.set("click_info",e.click),e.model.save_changes(),Rl(e.model,"cell",{row:r,col:n})),e.attr?.editor?.close&&e.attr.editor.close()},dU=(t,A,j)=>{A.mat_layer=A.mat_layer.clone({onClick:e=>xpA(e,t,A,j)})};var pU=(t,A)=>{let{object:j,layer:e}=A,r=t.root.querySelector(".deck-tooltip");r.style.marginTop="50px";let n=r.parentElement.parentElement;if(n.style.position="unset",j){if(e.id==="row-label-layer")return{html:`Row Label: ${j.display_name||j.name}`,style:{color:"white"}};if(e.id==="col-label-layer")return{html:`Col Label: ${j.display_name||j.name}`,style:{color:"white"}};if(e.id==="row-layer")return{html:`${t.attr.names.row[j.level]}: ${j.name}`,style:{color:"white"}};if(e.id==="col-layer")return{html:`${t.attr.names.col[j.level]}: ${j.name}`,style:{color:"white"}};if(e.id==="row-dendro-layer")return{html:`row-dendro-${j.properties.name}
${j.properties.all_names}`,style:{color:"white"}};if(e.id==="col-dendro-layer")return{html:`row-dendro-${j.properties.name}
${j.properties.all_names}`,style:{color:"white"}};if(e.id==="mat-layer"){let i=t.labels.row_label_data[j.row],o=t.labels.col_label_data[j.col],l=i?.display_name||i?.name,c=o?.display_name||o?.name;return{html:`Row: ${l}
Column: ${c}
Value: ${j.value.toFixed(2)}`,style:{color:"white"}}}else{if(e.id==="row-attr-label-layer")return{html:`Row Attribute: ${j.name}
Double-click to reorder by this attribute`,style:{color:"white"}};if(e.id==="col-attr-label-layer")return{html:`Column Attribute: ${j.name}
Double-click to reorder by this attribute`,style:{color:"white"}}}}};var kU=(t,A,j)=>{let{ini_pan_y:e}=j.zoom,r,n=Math.pow(2,A);j.zoom.min_pan_y=(e-j.viz.row_offset)/n+j.viz.row_offset;let i=e-j.zoom.min_pan_y;return j.zoom.max_pan_y=e+i,t<=j.zoom.min_pan_y?r=j.zoom.min_pan_y:t>j.zoom.max_pan_y?r=j.zoom.max_pan_y:r=t,r},gU=(t,A,j)=>{let{ini_pan_x:e}=j.zoom,r,n=Math.pow(2,A);j.zoom.min_pan_x=e/n;let i=e-j.zoom.min_pan_x;return j.zoom.max_pan_x=e+i,t<=j.zoom.min_pan_x?r=j.zoom.min_pan_x:t>j.zoom.max_pan_x?r=j.zoom.max_pan_x:r=t,r};var ypA=t=>({row_attr_labels:{target:[t.viz.label_row_x,t.viz.col_region/2],zoom:[0,0]},col_attr_labels:{target:[(t.viz.dendrogram_width+60)/2,t.viz.col_region/2],zoom:[0,0]}}),mU=(t,A,j,e)=>{let r,n=ypA(t);return A==="matrix"?r={matrix:{zoom:[j[0],j[1]],target:[e[0],e[1]]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}:A==="cols"||A==="dendro_cols"?r={matrix:{zoom:[j[0],j[1]],target:[e[0],t.zoom.min_pan_y]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,t.zoom.min_pan_y]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,t.zoom.min_pan_y]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}:(A==="rows"||A==="dendro_rows")&&(r={matrix:{zoom:[j[0],j[1]],target:[t.zoom.min_pan_x,e[1]]},rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},dendro_rows:{zoom:[t.zoom.ini_zoom_x,j[1]],target:[t.viz.label_row_x,e[1]]},dendro_cols:{zoom:[j[0],t.zoom.ini_zoom_y],target:[e[0],t.viz.label_col_y]},...n}),r};var EU=(t,A,j,e)=>{let{zoom_data:r}=t.zoom;r.matrix.pan_x=e[0],r.matrix.pan_y=e[1],r.matrix.zoom_x=j[0],r.matrix.zoom_y=j[1],r.rows.pan_x=t.zoom.ini_pan_x,r.rows.pan_y=e[1],r.rows.zoom_x=j[0],r.rows.zoom_y=j[1],r.cols.pan_x=e[0],r.cols.pan_y=t.zoom.ini_pan_y,r.cols.zoom_x=j[0],r.cols.zoom_y=j[1],r.dendro_rows.pan_x=t.zoom.ini_pan_x,r.dendro_rows.pan_y=e[1],r.dendro_rows.zoom_x=j[0],r.dendro_rows.zoom_y=j[1],r.dendro_cols.pan_x=e[0],r.dendro_cols.pan_y=t.zoom.ini_pan_y,r.dendro_cols.zoom_x=j[0],r.dendro_cols.zoom_y=j[1]},$U=t=>{t.zoom.zoom_data={},t.zoom.zoom_data.total_zoom={},t.zoom.zoom_data.total_zoom.x=0,t.zoom.zoom_data.total_zoom.y=0,t.zoom.zoom_data.matrix={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.rows={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.cols={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.dendro_rows={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y},t.zoom.zoom_data.dendro_cols={pan_x:t.zoom.ini_pan_x,pan_y:t.zoom.ini_pan_y,zoom_x:t.zoom.ini_zoom_x,zoom_y:t.zoom.ini_zoom_y}};var xU=(t,A,j,e)=>{let{viewState:r}=t,{viewId:n}=t,{zoom:i,target:o}=r,l,c;n==="cols"?e.zoom.minor_zoom_axis==="X"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="Y"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]):(n==="rows"||n==="dendro_rows")&&(e.zoom.minor_zoom_axis==="Y"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="X"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0],c=i[1]-e.zoom.zoom_data[n].zoom_y)),n==="dendro_cols"?e.zoom.minor_zoom_axis==="X"?(l=i[0],c=i[1]):e.zoom.minor_zoom_axis==="Y"?(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y):e.zoom.minor_zoom_axis==="none"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]):n==="matrix"&&(l=i[0]-e.zoom.zoom_data[n].zoom_x,c=i[1]-e.zoom.zoom_data[n].zoom_y),e.zoom.zoom_data.total_zoom.x+=l,e.zoom.zoom_data.total_zoom.y+=c,e.zoom.zoom_data.total_zoom.x=Math.max(0,e.zoom.zoom_data.total_zoom.x),e.zoom.zoom_data.total_zoom.y=Math.max(0,e.zoom.zoom_data.total_zoom.y);let B=[e.zoom.zoom_data.total_zoom.x,e.zoom.zoom_data.total_zoom.y],h=Math.max(0,B[0]),d=Math.max(0,B[1]);e.zoom.major_zoom_axis==="X"?d=h-e.zoom.zoom_delay:e.zoom.major_zoom_axis==="Y"&&(h=d-e.zoom.zoom_delay),h=Math.max(0,h),d=Math.max(0,d);let k=gU(o[0],h,e),g=kU(o[1],d,e),E=[h,d],m=[k,g],y=mU(e,n,E,m);EU(e,n,E,m);let G;e.zoom.major_zoom_axis==="X"?G=Math.pow(2,e.zoom.zoom_data.matrix.zoom_x):e.zoom.major_zoom_axis==="Y"?G=Math.pow(2,e.zoom.zoom_data.matrix.zoom_y):e.zoom.major_zoom_axis==="all"&&(G=Math.pow(2,e.zoom.zoom_data.matrix.zoom_x)),j.row_label_layer=j.row_label_layer.clone({getSize:e.viz.font_size.rows*Math.pow(2,e.zoom.zoom_data.matrix.zoom_y)}),j.col_label_layer=j.col_label_layer.clone({getSize:e.viz.font_size.cols*Math.pow(2,e.zoom.zoom_data.matrix.zoom_x),updateTriggers:{getPixelOffset:e.zoom.zoom_data.matrix.zoom_x}});let v;e.zoom.major_zoom_axis!=="all"?v=G_.props.controller===!1?_:new un({..._.props,controller:{..._.props.controller,doubleClickZoom:!1,scrollZoom:!0,inertia:!0,zoomAxis:v}})),A.setProps({viewState:y,layers:le(j),views:e.views.views_list})};var M_=t=>{let A;t.mat.num_rows>t.mat.num_cols?(t.zoom.major_zoom_axis="Y",t.zoom.minor_zoom_axis="X",A=t.mat.num_rows/t.mat.num_cols):t.mat.num_rows({matrix:{target:[t.zoom.ini_pan_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},rows:{target:[t.viz.label_row_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},cols:{target:[t.zoom.ini_pan_x,t.viz.label_col_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},row_attr_labels:{target:[t.viz.label_row_x,t.viz.col_region/2],zoom:[0,0]},col_attr_labels:{target:[(t.viz.dendrogram_width+60)/2,t.viz.col_region/2],zoom:[0,0]},dendro_rows:{target:[t.viz.label_row_x,t.zoom.ini_pan_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]},dendro_cols:{target:[t.zoom.ini_pan_x,t.viz.label_col_y],zoom:[t.zoom.ini_zoom_x,t.zoom.ini_zoom_y]}});var yU=["#1f77b4","#ff7f0e","#2ca02c","#d62728","#9467bd","#8c564b","#e377c2","#7f7f7f","#bcbd22","#17becf"],vU="N.A.",vpA="#d1d5db",JI=t=>t==null?null:String(t),_pA=t=>t==="col"?"col":"row",A8=(t,A)=>{let j=yU[A%yU.length];return typeof t=="string"&&o6(t)?t:j},qpA=t=>{let A=t.attr.num.row,j=t.attr.num.col;t.viz.mat_width=t.viz.total_width-t.viz.row_cat_offset*A,t.viz.mat_height=t.viz.total_height-t.viz.col_cat_offset*j,t.viz.col_region=(t.viz.col_cat_height+t.viz.extra_space.col)*j+t.viz.col_label,t.viz.row_region=(t.viz.row_cat_width+t.viz.extra_space.row)*A+t.viz.row_label,t.viz.col_width=t.viz.mat_width/t.mat.num_cols,t.viz.row_offset=t.viz.mat_height/t.mat.num_rows,t.viz.col_offset=t.viz.mat_width/t.mat.num_cols,t.viz.cat_shift_col=t.viz.col_label,t.zoom.ini_pan_x=t.viz.mat_width/2,t.zoom.ini_pan_y=t.viz.mat_height/2+t.viz.row_offset},_U=(t,A)=>{let j=A==="row",e=j?t.viz.row_cat_offset:t.viz.col_cat_offset,r=j?t.viz.row_offset:t.viz.col_offset,n=t.attr.all_defs[A]||[],i=[];return n.forEach((o,l)=>{let c=o.values||[],B=o.maxabs||0,h=o.color_map||{};c.forEach((d,k)=>{if(d==null||d==="")return;let g;if(o.type==="numeric"){let E=Math.abs(B)||1,m=Number(d);if(Number.isNaN(m))return;let y=[255,165,0],G=[169,169,169],v=m>=0?G:y,_=Math.min(1,Math.abs(m)/E);g=[...v,Math.round(_*255)]}else{let E=JI(d),m=h[E]||A8(E,k+l);g=ng(m,255)}i.push({position:j?[e*(l+.5)+20,r*(k+.5)]:[r*(k+.5),e*(l+1.5)-30],color:g,name:o.type==="numeric"?d:JI(d),level:l,original_index:k})})}),i},ZI=t=>{["row","col"].forEach(A=>{let j=[...t.attr.static_defs?.[A]||[],...t.attr.manual_defs?.[A]||[]];t.attr.all_defs[A]=j,t.attr.names[A]=j.map(e=>e.name),t.attr.maxabs[A]=j.map(e=>e.type==="numeric"?e.maxabs??0:null),t.attr.num[A]=j.length,t.attr.cats[A]=j.filter(e=>e.type==="categorical").map(e=>e.name)})},qU=(t,A,j)=>{let e=j==="row"?A.row_nodes:A.col_nodes,r=t.attr.names[j]||[],n=t.attr.maxabs[j]||[];return r.map((i,o)=>{if(n[o]!==null&&n[o]!==void 0){let h=e.map(d=>d[`num-${o}`]);return{name:i,type:"numeric",values:h,maxabs:n[o]}}let c=e.map(h=>JI(h[`cat-${o}`])),B={};return c.forEach((h,d)=>{h!==null&&(A.global_cat_colors&&A.global_cat_colors[h]?B[h]=A.global_cat_colors[h]:B[h]||(B[h]=A8(h,d)))}),{name:i,type:"categorical",values:c,color_map:B}})},bU=(t,A)=>{t.attr.static_defs={row:[],col:[]},t.attr.manual_defs={row:[],col:[]},t.attr.all_defs={row:[],col:[]},t.attr.names=t.attr.names||{row:[],col:[]},t.attr.maxabs=t.attr.maxabs||{row:[],col:[]},t.attr.num=t.attr.num||{row:0,col:0},t.attr.cats={row:[],col:[]},t.attr.category_colors={},t.attr.did_initialize=!1,t.manual_cat=t.manual_cat||{config:{row:null,col:null},flags:{row:!1,col:!1}},t.attr.static_defs.row=qU(t,A,"row"),t.attr.static_defs.col=qU(t,A,"col"),ZI(t)},t8=(t,A,j)=>{qpA(j);let e=_U(j,"row"),r=_U(j,"col");j.cats.row_cat_data=e,j.cats.col_cat_data=r,A.row_cat_layer=A.row_cat_layer.clone({data:e,tile_width:j.viz.row_cat_width/2*.9,tile_height:j.viz.mat_height/j.mat.num_rows*.5}),A.col_cat_layer=A.col_cat_layer.clone({data:r,tile_width:j.viz.mat_width/j.mat.num_cols*.5,tile_height:j.viz.col_cat_height/2}),A.mat_layer=A.mat_layer.clone({tile_height:j.viz.mat_height/j.mat.num_rows*.5,tile_width:j.viz.mat_width/j.mat.num_cols*.5,updateTriggers:{getPosition:[j.order.current.row,j.order.current.col]}}),A.row_label_layer=A.row_label_layer.clone({data:j.labels.row_label_data,updateTriggers:{getPosition:j.order.current.row}}),A.col_label_layer=A.col_label_layer.clone({data:j.labels.col_label_data,updateTriggers:{getPosition:j.order.current.col}}),M_(j);let n=O_(j),i={views:j.views.views_list,layers:le(A)};j.attr.did_initialize||(i.initialViewState=n,j.attr.did_initialize=!0),t.setProps(i)},GU=(t,A)=>{let j=_pA(A),e=t.manual_cat?.flags||{},r=t.obs_store?.manual_cat?.[j],n=r?.attribute||null,i=t.manual_cat?.config?.[j]?.attribute||null,o=n||i;if(!!!(e[j]&&n)||!r||!o)return t.attr.manual_defs[j]=[],ZI(t),!0;let c=r.toFrame(vU),B=r.toColorPayload(vU,vpA),h=(c.index||[]).map(x=>String(x)),d=new Map;h.forEach((x,O)=>{d.set(x,O)});let g=(j==="row"?t.row_nodes:t.col_nodes).map(x=>String(x.name)),E=c.data[o]||[],m=g.map(x=>{let O=d.get(x);if(O===void 0)return null;let F=E[O];return F??null}),y=B[o]||{},G=t.attr.category_colors||{},v=Array.from(new Set(m.filter(x=>x!==null&&x!==""))),_={};v.forEach((x,O)=>{_[x]=y[x]||G[x]||A8(x,O)});let w=t.attr.category_colors||{};return Object.entries(_).forEach(([x,O])=>{x&&O&&w[x]!==O&&(w[x]=O)}),t.attr.category_colors=w,t.attr.manual_defs[j]=[{name:o,type:"categorical",values:m,color_map:_}],ZI(t),!0};var wU=t=>t==="col"?"col":"row",bpA=t=>wU(t)==="col"?"col_label_data":"row_label_data",GpA=(t,A)=>t?A?`${t} (${A})`:t:"",T_=(t,A)=>{if(!t||!t.labels)return;let j=wU(A),e=bpA(j),r=t.labels[e];if(!Array.isArray(r))return;let n=t.manual_cat?.flags||{},i=t.obs_store?.manual_cat?.[j],o=!!(i?.getValueFor&&i?.attribute&&n[j]),l=r.map(c=>{let B=o&&c?.name?i.getValueFor(c.name):null;return{...c,display_name:GpA(c?.name,B)}});t.labels[e]=l},FU=(t,A)=>{let j=[];t.col_nodes.forEach((e,r)=>{let n={name:e.name,ini:e.ini,clust:e.clust,rank:e.rank,rankvar:e.rankvar,index:r};j.push(n)}),A.labels.col_label_data=j,A.labels.clicks.col=0,A.mat.orders.col={},A.mat.orders.col.ini=j.map(e=>e.ini),A.mat.orders.col.clust=j.map(e=>e.clust+1),A.mat.orders.col.rank=j.map(e=>e.rank+1),A.mat.orders.col.rankvar=j.map(e=>e.rankvar+1),T_(A,"col")},PU=(t,A)=>{let j=[];t.row_nodes.forEach((e,r)=>{let n={name:e.name,ini:e.ini,clust:e.clust,rank:e.rank,rankvar:e.rankvar,index:r};j.push(n)}),A.labels.row_label_data=j,A.labels.clicks.row=0,A.mat.orders.row={},A.mat.orders.row.ini=j.map(e=>e.ini),A.mat.orders.row.clust=j.map(e=>e.clust+1),A.mat.orders.row.rank=j.map(e=>e.rank+1),A.mat.orders.row.rankvar=j.map(e=>e.rankvar+1),T_(A,"row")};var IU=(t,A)=>{let{mat:j}=t,{col_offset:e,row_offset:r}=A.viz,{max_abs_value:n}=A.mat,{mat_data:i}=A.mat;for(let o=0;o=0?[255,0,0]:[0,0,255],d={position:[e*(c+.5),r*(o+1.5)],color:[h[0],h[1],h[2],Math.min(255,255*Math.abs(B)/n)],value:B,row:o,col:c};i.push(d)}}};var El=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{(typeof e=="object"&&e!==null?JSON.stringify(A)!==JSON.stringify(e):A!==e)&&(A=e,j.forEach(n=>n(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},MU=()=>({selected_genes:El([]),focused_dendro:El(null),attr_reorder_state:El(null),selected_cell:El(null),selected_category:El(null),hovered_category:El(null),dendro_selection:El(null),category_breakdown:El({row:{},col:{}})});var wpA=t=>t==="col"?"col":"row",OU=()=>[],cg=class{constructor(A="row",j=OU){this.axis=wpA(A),this.getNodeNames=typeof j=="function"?j:OU,this.attribute=null,this.values=new Map,this.colors=new Map,this.listeners=new Set}setAttribute(A){let j=A?String(A):null;this.attribute!==j&&(this.attribute=j,this.values.clear(),this.colors.clear(),this.emit())}updateSelection({selection:A=[],value:j,color:e}){let r=j==null||j===""?null:String(j);A.forEach(n=>{let i=String(n);r?this.values.set(i,r):this.values.delete(i)}),r&&e&&this.colors.set(r,String(e)),this.emit()}getValueFor(A){if(A==null)return null;let j=String(A),e=this.values.get(j);return e===void 0?null:e}clear(){!this.attribute&&this.values.size===0&&this.colors.size===0||(this.attribute=null,this.values.clear(),this.colors.clear(),this.emit())}toFrame(A="N.A."){let j=this.getNodeNames().map(n=>String(n)),e=this.axis==="row"?"row_id":"col_id";if(!this.attribute)return{columns:[],index:j,index_name:e,data:{}};let r=j.map(n=>{let i=this.values.get(String(n));return i==null||i===""?A:i});return{columns:[this.attribute],index:j,index_name:e,data:{[this.attribute]:r}}}toColorPayload(A="N.A.",j="#d1d5db"){if(!this.attribute)return{};let e={[this.attribute]:{[A]:j}};return this.colors.forEach((r,n)=>{n&&(e[this.attribute][n]=r)}),e}toExportPayload(){if(!this.attribute)return{};let A={},j={};return this.values.forEach((e,r)=>{A[String(r)]=e}),this.colors.forEach((e,r)=>{j[String(r)]=e}),{[this.attribute]:{values:A,colors:j}}}subscribe(A,j={immediate:!0}){return this.listeners.add(A),(!j||j.immediate)&&A(),()=>this.listeners.delete(A)}emit(){this.listeners.forEach(A=>A())}};var TU=t=>{if(!t)return{entity:"gene",attr:"name"};if(typeof t=="string")try{let A=JSON.parse(t);if(A&&typeof A=="object")return{entity:A.entity||"custom",attr:A.attr||"name"}}catch{return{gene:{entity:"gene",attr:"name"},cell_cluster:{entity:"cell",attr:"leiden"},cluster:{entity:"cell",attr:"leiden"},nbhd:{entity:"nbhd",attr:"name"},cell:{entity:"cell",attr:"name"},hextile:{entity:"hextile",attr:"name"}}[t]||{entity:t,attr:"name"}}return typeof t=="object"?{entity:t.entity||"custom",attr:t.attr||"name"}:{entity:"custom",attr:"name"}},SU=(t,A,j,e,r,n,i,o,l,c)=>{let B={};B.root=j,B.model=t,B.obs_store=MU();let h={positive:"#a9a9a9",negative:"#ffa500"};B.value_colors=t&&typeof t.get=="function"&&t.get("value_colors")||h,B.custom_callbacks={},B.custom_callbacks.row=o,B.custom_callbacks.col=l,B.custom_callbacks.col_dendro=c,B.viz={},B.viz.height_margin=100,B.attr={},B.attr.names={row:A.row_attr||[],col:A.col_attr||[]},B.attr.maxabs={row:A.row_attr_maxabs||[],col:A.col_attr_maxabs||[]},B.attr.num={row:B.attr.names.row.length,col:B.attr.names.col.length},bU(B,A),B.root.style.height=`${r+B.viz.height_margin}px`,B.viz.row_cat_offset=9,B.viz.col_cat_offset=9,B.viz.total_width=e,B.viz.total_height=r,B.viz.mat_width=e-B.viz.row_cat_offset*B.attr.num.row,B.viz.mat_height=r-B.viz.col_cat_offset*B.attr.num.col,B.mat={},B.mat.num_rows=A.mat.length,B.mat.num_cols=A.mat[0].length,B.row_nodes=A.row_nodes,B.col_nodes=A.col_nodes,B.obs_store.manual_cat={row:new cg("row",()=>(B.row_nodes||[]).map(m=>String(m.name))),col:new cg("col",()=>(B.col_nodes||[]).map(m=>String(m.name)))},B.mat.net_mat=A.mat,B.linkage=A.linkage,B.viz.base_font_size=125,B.viz.col_label=75,B.viz.row_label=75,B.viz.extra_space={},B.viz.extra_space.row=5,B.viz.extra_space.col=5,B.zoom={},B.zoom.ini_zoom_x=0,B.zoom.ini_zoom_y=0,B.viz.row_cat_width=8,B.viz.col_cat_height=8,B.viz.label_row_x=15,B.viz.label_col_y=25,B.viz.cat_shift_row=30,B.viz.label_buffer=1,B.animate={},B.animate.duration=2500,B.viz.dendrogram_width=15;let d=TU(n),k=TU(i);B.row_entity=d,B.col_entity=k,B.viz.font_size={},B.viz.font_size.rows=B.viz.base_font_size/B.mat.num_rows,B.viz.font_size.cols=B.viz.base_font_size/B.mat.num_cols,B.viz.col_region=(B.viz.col_cat_height+B.viz.extra_space.col)*B.attr.num.col+B.viz.col_label,B.viz.row_region=(B.viz.row_cat_width+B.viz.extra_space.row)*B.attr.num.row+B.viz.row_label,B.viz.col_width=B.viz.mat_width/B.mat.num_cols,B.viz.row_offset=B.viz.mat_height/B.mat.num_rows,B.viz.col_offset=B.viz.mat_width/B.mat.num_cols,B.viz.cat_shift_col=B.viz.col_label,B.zoom.ini_pan_x=B.viz.mat_width/2,B.zoom.ini_pan_y=B.viz.mat_height/2+B.viz.row_offset,B.mat.mat_data=[],B.mat.num_rows=A.mat.length,B.mat.num_cols=A.mat[0].length;let g=A.mat.flat().map(m=>Math.abs(m));g.sort((m,y)=>m-y);let E=Math.floor(.99*(g.length-1));return B.mat.max_abs_value=g[E]||1,B.order={},B.order.current={},B.order.current.row="clust",B.order.current.col="clust",B.order.new="ini",B.buttons={},B.buttons.blue="#8797ff",B.buttons.gray="#EEEEEE",B.click={},B.click.type=null,B.click.value=null,B.top_n_genes=t&&typeof t.get=="function"&&t.get("top_n_genes")||50,B};var au={row:"#2f74ff",col:"#ff7f0e"},FpA=t=>{let A=t.attr?.category_colors||{};return new Set(Object.values(A).filter(j=>!!j).map(j=>j.toLowerCase()))},PpA=t=>{t.manual_cat=t.manual_cat||{},typeof t.manual_cat.color_cursor!="number"&&(t.manual_cat.color_cursor=0);let A=FpA(t);for(let j=0;j<720;j+=1){let e=t.manual_cat.color_cursor+j,r=e*137.508%360/360,n=bz(r,.65,.55);if(!A.has(n.toLowerCase()))return t.manual_cat.color_cursor=e+1,n}return t.manual_cat.color_cursor+=1,"#3b82f6"},RU=(t,A,j)=>{let e=x_(),{header:r,close_button:n}=y_("Manual category"),i=document.createElement("div");i.style.fontSize="11px",i.style.marginBottom="8px",i.style.color="#5b6770";let o=$_("Category value"),l=eh("Category value",o),c=E_(au.row),B=eh("Color",c),{button_row:h,apply_button:d,cancel_button:k}=v_();e.appendChild(r),e.appendChild(i),e.appendChild(l),e.appendChild(B),e.appendChild(h),t.el.appendChild(e);let g=null,E=x=>x&&(t.attr?.category_colors||{})[String(x)]||null,m=x=>{let O=t.manual_cat?.flags||{},F=t.manual_cat?.config?.[x];return!!(O?.[x]&&F?.attribute)},y=()=>{e.style.display="none",g=null},G=(x,O)=>{let F=(x||"").trim();if(!F)return c.value=au[O]||au.row,c.value;let C=E(F);if(C)return c.value=C,C;let R=PpA(t);return c.value=R,R},v=x=>{let O=t.el.getBoundingClientRect(),F=t.root.getBoundingClientRect(),C=e.offsetWidth||240,R=e.offsetHeight||200,X=(x?.x??F.width-C-24)+(F.left-O.left),T=(x?.y??24)+(F.top-O.top),Q=jh(X,8,O.width-C-8),b=jh(T,8,O.height-R-8);e.style.left=`${Q}px`,e.style.top=`${b}px`},_=({axis:x,selection:O,initial_value:F,initial_color:C,position:R})=>{if(!Array.isArray(O)||O.length===0||!m(x))return;g={axis:x,selection:O.map(b=>String(b))};let X=x==="col"?"columns":"rows";if(!t.manual_cat?.config?.[x]?.attribute)return;i.textContent=`${O.length} ${X} selected`,o.value=F?String(F):"";let Q=E(o.value.trim());c.value=C||Q||au[x]||au.row,e.style.display="block",v(R)},w=()=>{if(!g)return;let x=t.manual_cat?.config?.[g.axis]?.attribute;if(!x){y();return}let O=o.value.trim(),F=c.value||au[g.axis]||au.row,C=t.obs_store?.manual_cat?.[g.axis];if(!C){y();return}C.setAttribute(x),C.updateSelection({selection:g.selection,value:O,color:F}),y()};d.addEventListener("click",w),k.addEventListener("click",y),n.addEventListener("click",y),t.attr.editor={open:_,close:y},o.addEventListener("input",()=>{let x=g?.axis||"row";G(o.value,x)})};var IpA=(t,A,j)=>{let e=A==="row"?t.row_nodes:t.col_nodes,r=t.attr.all_defs[A]?.[j];if(!r||!r.values)return null;let{values:n}=r,i=[...new Set(n.filter(B=>B!=null))];r.type==="numeric"?i.sort((B,h)=>Number(B)-Number(h)):i.sort();let o=new Map;i.forEach(B=>o.set(B,[])),e.forEach((B,h)=>{let d=n[h];d!=null&&o.has(d)&&o.get(d).push({node:B,index:h})});let l=new Array(e.length).fill(0),c=1;return o.forEach(B=>{B.sort((h,d)=>h.node.clust-d.node.clust),B.forEach(({index:h})=>{l[h]=c++})}),l},LU=(t,A,j,e,r,n)=>{let i=`attr_${r}`;if(!t.mat.orders[e][i]){let o=IpA(t,e,r);o&&(t.mat.orders[e][i]=o)}t.mat.orders[e][i]&&(t.order.current[e]=i,t.obs_store?.attr_reorder_state&&t.obs_store.attr_reorder_state.set({axis:e,attr_index:r,attr_name:n,order_key:i}),VA(t.el).selectAll(`.button-${e}`).classed("active",!1).style("border-color",t.buttons.gray),j.mat_layer=j.mat_layer.clone({updateTriggers:{getPosition:[t.order.current.row,t.order.current.col]}}),e==="row"?(j.row_label_layer=j.row_label_layer.clone({updateTriggers:{getPosition:t.order.current.row}}),j.row_cat_layer=j.row_cat_layer.clone({updateTriggers:{getPosition:t.order.current.row}})):(j.col_label_layer=j.col_label_layer.clone({updateTriggers:{getPosition:t.order.current.col}}),j.col_cat_layer=j.col_cat_layer.clone({updateTriggers:{getPosition:t.order.current.col}})),eu(j,t,e),A.setProps({layers:le(j)}))},CU=250,HU=t=>(t.attr.names.col||[]).map((j,e)=>({name:j,index:e,axis:"col"})),DU=t=>(t.attr.names.row||[]).map((j,e)=>({name:j,index:e,axis:"row"})),MpA=(t,A)=>{let e=A.viz.col_cat_offset*(t.index+1.5)-30+A.viz.cat_shift_col;return[5,A.viz.col_region/2+(e-A.viz.label_col_y)]},OpA=(t,A)=>{let j=A.viz.row_cat_offset*(t.index+.5)+20+A.viz.cat_shift_row,e=A.viz.col_region-5;return[j,e]},NU=t=>{let A=HU(t);return A.length===0?null:new Ii({id:"col-attr-label-layer",data:A,getPosition:e=>MpA(e,t),getText:e=>e.name,getSize:10,getColor:[80,80,80],getAngle:0,getTextAnchor:"start",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:1,pickable:!0})},KU=t=>{let A=DU(t);return A.length===0?null:new Ii({id:"row-attr-label-layer",data:A,getPosition:e=>OpA(e,t),getText:e=>e.name,getSize:10,getColor:[80,80,80],getAngle:90,getTextAnchor:"start",getAlignmentBaseline:"center",fontFamily:"Arial",sizeUnits:"pixels",sizeScale:1,pickable:!0})},TpA=(t,A,j,e)=>{e.labels.clicks.col_attr=(e.labels.clicks.col_attr||0)+1,e.labels.clicks.col_attr===1?setTimeout(()=>{e.labels.clicks.col_attr=0},CU):e.labels.clicks.col_attr===2&&(e.labels.clicks.col_attr=0,LU(e,A,j,"col",t.object.index,t.object.name))},SpA=(t,A,j,e)=>{e.labels.clicks.row_attr=(e.labels.clicks.row_attr||0)+1,e.labels.clicks.row_attr===1?setTimeout(()=>{e.labels.clicks.row_attr=0},CU):e.labels.clicks.row_attr===2&&(e.labels.clicks.row_attr=0,LU(e,A,j,"row",t.object.index,t.object.name))},XU=(t,A,j)=>{A.col_attr_label_layer&&(A.col_attr_label_layer=A.col_attr_label_layer.clone({onClick:e=>TpA(e,t,A,j)}))},zU=(t,A,j)=>{A.row_attr_label_layer&&(A.row_attr_label_layer=A.row_attr_label_layer.clone({onClick:e=>SpA(e,t,A,j)}))},RpA=(t,A,j)=>{let e=HU(j);A.col_attr_label_layer&&e.length>0?A.col_attr_label_layer=A.col_attr_label_layer.clone({data:e}):e.length>0&&(A.col_attr_label_layer=NU(j),XU(t,A,j));let r=DU(j);A.row_attr_label_layer&&r.length>0?A.row_attr_label_layer=A.row_attr_label_layer.clone({data:r}):r.length>0&&(A.row_attr_label_layer=KU(j),zU(t,A,j)),t.setProps({layers:le(A)})},UU=(t,A,j)=>{A.col_attr_label_layer=NU(j),A.col_attr_label_layer&&XU(t,A,j),A.row_attr_label_layer=KU(j),A.row_attr_label_layer&&zU(t,A,j),j.obs_store?.manual_cat&&["row","col"].forEach(e=>{let r=j.obs_store.manual_cat[e];r&&r.subscribe(()=>{setTimeout(()=>{RpA(t,A,j)},150)},{immediate:!1})})};var S_=async(t,A,j,e="800",r="800",n=null,i=null,o=null)=>{let l=document.createElement("div");l.style.border="1px solid #d3d3d3";let c=sU(l,e,r),B=t.get("row_entity"),h=t.get("col_entity"),d=SU(t,j,l,e,r,B,h,n,i,o);A.style.position="relative",d.el=A,IU(j,d),d.labels={},d.labels.clicks={},$U(d),d.mat.orders={},PU(j,d),FU(j,d),d.cats={},d.cats.row_cat_data=[],d.cats.col_cat_data=[],Oz(d),ig(d,"row"),ig(d,"col");let k={};k.mat_layer=hU(d),k.row_label_layer=aU(d),k.col_label_layer=lU(d),k.row_cat_layer=iU(d),k.col_cat_layer=oU(d),k.row_dendro_layer=LI(k,d,"row"),k.col_dendro_layer=LI(k,d,"col"),d.deck_mat=c,d.layers_mat=k,t8(c,k,d),YI(c,k,d,"row"),YI(c,k,d,"col"),M_(d);let g=O_(d);dU(c,k,d),BU(c,k,d),fU(c,k,d),CI(c,k,d,"row"),CI(c,k,d,"col"),c.setProps({onViewStateChange:v=>xU(v,c,k,d),views:d.views.views_list,initialViewState:g,getTooltip:v=>pU(d,v),layerFilter:wz,layers:le(k)});let E=Kz(c,k,d);A.appendChild(E),A.appendChild(d.root),RU(d,c,k),UU(c,k,d),c.setProps({layers:le(k)});let m=()=>{if(!d.model)return;let v=d.obs_store?.manual_cat?.row,_=d.obs_store?.manual_cat?.col,w={row:v?v.toExportPayload():{},col:_?_.toExportPayload():{}},x=JSON.stringify(w);d.model.set("manual_cat",x),d.model.set("category_colors",d.attr.category_colors||{}),d.model.save_changes()},y=(v,{sync:_=!1}={})=>{GU(d,v)&&(T_(d,v),t8(c,k,d),_&&m())};if(d.obs_store?.manual_cat&&["row","col"].forEach(v=>{let _=d.obs_store.manual_cat[v];_&&_.subscribe(()=>{y(v,{sync:!0})},{immediate:!1})}),d.model){d.model.set("row_names",d.row_nodes.map(x=>String(x.name))),d.model.set("col_names",d.col_nodes.map(x=>String(x.name))),d.model.save_changes(),(()=>{d.manual_cat=d.manual_cat||{config:{},flags:{}};let O=d.model.get("manual_cat_config");if(typeof O=="string")try{O=O?JSON.parse(O):{}}catch{O={}}let F=O&&typeof O=="object"?O:{row:null,col:null};d.manual_cat.config.row=F.row||null,d.manual_cat.config.col=F.col||null,d.manual_cat.flags={row:!!d.model.get("manual_row_cat"),col:!!d.model.get("manual_col_cat")},["row","col"].forEach(C=>{if(!d.manual_cat.flags[C])return;let R=d.obs_store?.manual_cat?.[C],X=d.manual_cat.config?.[C]?.attribute||null;R&&R.setAttribute(X),y(C,{sync:!1})}),m()})();let _=()=>{d.attr.category_colors=d.model.get("category_colors")||{}};_(),d.model.on("change:category_colors",_),d.model.on("change:selected_genes",()=>{d.obs_store.selected_genes.set(d.model.get("selected_genes")||[])}),d.model.on("change:top_n_genes",()=>{d.top_n_genes=d.model.get("top_n_genes")||50});let w=()=>{let x=d.model.get("matrix_slice_request");if(!x||typeof x!="object")return;let O=x.req_id;if(!O||!x.op)return;let F={req_id:O},C;if(x.max_entries===void 0||x.max_entries===null)C=void 0;else{let R=Number(x.max_entries);C=Number.isFinite(R)?R:void 0}try{if(x.op==="row"){let R=kh(d,x.index,C);R?Object.assign(F,R):F.error="no_data"}else if(x.op==="col"){let R=gh(d,x.index,C);R?Object.assign(F,R):F.error="no_data"}else if(x.op==="cell"){let R=x.row,X=x.col,T=d.mat?.net_mat,Q=null;T?.[R]&&X>=0&&X{c.finalize()}}};var VU=(t,A,j,e)=>{let r=[];for(let n=0;n{let r=Math.pow(2,A),n=j/(2*r),i=e/(2*r);return t.map(o=>({cell_id:o.cell_id,min_x:o.x-n,max_x:o.x+n,min_y:o.y-i,max_y:o.y+i,center_x:o.x,center_y:o.y}))},QU=(t,A,j,e,r)=>{let n=LpA(t,A,j,e),i=new Map;return n.forEach(o=>{Uv(o.min_x,o.max_x,o.min_y,o.max_y,r).forEach(c=>{i.has(c.name)||i.set(c.name,c)})}),Array.from(i.values())};var CpA=(t,A)=>t*A,rh=(t,A,j)=>{let e=CpA(A,j);return Math.max(1,Math.ceil(t/e))};var WU=0,HpA=(t,A)=>{let j=document.createElement("div");j.className="query_container",j.style.display="flex",j.style.flexDirection="column",j.style.marginLeft="5px",j.style.marginTop="3px",j.style.minWidth="130px",j.style.maxWidth="150px";let e=document.createElement("div");e.textContent="Query Cells",e.style.fontSize="11px",e.style.fontWeight="bold",e.style.color="#47515b",e.style.marginBottom="3px",e.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',j.appendChild(e);let r=document.createElement("div");r.style.display="flex",r.style.flexDirection="row",r.style.alignItems="center",r.style.marginBottom="2px";let n=document.createElement("span");n.textContent="Cluster:",n.style.fontSize="10px",n.style.width="42px",n.style.color="#555",r.appendChild(n);let i=document.createElement("input");i.type="text",i.placeholder="",i.style.width="70px",i.style.height="16px",i.style.fontSize="11px",i.style.border="1px solid #d3d3d3",i.style.borderRadius="2px",i.style.padding="1px 3px",WU+=1;let o=`${WU}_${Date.now()}`,l=document.createElement("datalist");l.id=`yearbook_cluster_datalist_${o}`,i.setAttribute("list",l.id),t.cats.cluster_counts&&t.cats.cluster_counts.forEach(v=>{let _=document.createElement("option");_.value=v.name,l.appendChild(_)}),r.appendChild(i),r.appendChild(l),j.appendChild(r);let c=document.createElement("div");c.style.display="flex",c.style.flexDirection="row",c.style.alignItems="center",c.style.marginBottom="3px";let B=document.createElement("span");B.textContent="Gene:",B.style.fontSize="10px",B.style.width="42px",B.style.color="#555",c.appendChild(B);let h=document.createElement("input");h.type="text",h.placeholder="",h.style.width="70px",h.style.height="16px",h.style.fontSize="11px",h.style.border="1px solid #d3d3d3",h.style.borderRadius="2px",h.style.padding="1px 3px";let d=document.createElement("datalist");d.id=`yearbook_gene_datalist_${o}`,h.setAttribute("list",d.id),t.genes.gene_names&&t.genes.gene_names.forEach(v=>{let _=document.createElement("option");_.value=v,d.appendChild(_)}),c.appendChild(h),c.appendChild(d),j.appendChild(c);let k=document.createElement("div");k.style.display="flex",k.style.flexDirection="row",k.style.gap="5px";let g=document.createElement("button");g.textContent="Query",g.style.padding="3px 10px",g.style.fontSize="11px",g.style.cursor="pointer",g.style.border="1px solid #8797ff",g.style.borderRadius="3px",g.style.backgroundColor="#8797ff",g.style.color="white",g.style.fontWeight="bold",g.onmouseenter=()=>{g.style.backgroundColor="#6677ee"},g.onmouseleave=()=>{g.style.backgroundColor="#8797ff"};let E=document.createElement("button");E.textContent="Clear",E.style.padding="3px 8px",E.style.fontSize="11px",E.style.cursor="pointer",E.style.border="1px solid #d3d3d3",E.style.borderRadius="3px",E.style.backgroundColor="#f0f0f0",E.style.color="#555";let m=()=>{let v=i.value.trim(),_=h.value.trim(),w=!v||t.cats.cluster_counts?.some(F=>F.name===v),x=!_||t.genes.gene_names?.includes(_);if(w)i.style.borderColor="#d3d3d3";else{i.style.borderColor="#ff6666";return}if(x)h.style.borderColor="#d3d3d3";else{h.style.borderColor="#ff6666";return}let O={};if(v){let F=t.cats.inst_cell_attr||"leiden";O.cluster={attr:F,value:v}}_&&(O.gene=_),Object.keys(O).length>0&&A(O)};g.onclick=m;let y=v=>{v.key==="Enter"&&m()};i.addEventListener("keydown",y),h.addEventListener("keydown",y),E.onclick=()=>{i.value="",h.value="",i.style.borderColor="#d3d3d3",h.style.borderColor="#d3d3d3"},k.appendChild(g),k.appendChild(E),j.appendChild(k);let G=document.createElement("div");return G.className="query_status",G.style.fontSize="10px",G.style.color="#888",G.style.marginTop="3px",G.style.maxHeight="30px",G.style.overflow="hidden",G.style.textOverflow="ellipsis",j.appendChild(G),t.yearbook.query_ui={cluster_input:i,gene_input:h,status_text:G,update_status:v=>{G.textContent=v}},j},DpA=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.style.border="1px solid #d3d3d3",t.className="ui_container",t.style.height="100px",t.style.boxSizing="border-box",t.style.width="100%",t.style.maxWidth="100%",t.style.margin="0 auto",t},NpA=()=>{let t=document.createElement("div");return t.style.display="flex",t.style.flexDirection="row",t.className="ctrl_container",t.style.width="100%",t},$l=(t,A,j=null)=>{let e=document.createElement("div");return e.className=t,e.style.display="flex",e.style.flexDirection=A,j!==null&&(e.style.height=`${j}px`,e.style.overflow="scroll"),e},j8=t=>{let A=document.createElement("div");return A.className=t,A.style.width="100%",A.style.marginLeft="2px",A.style.marginTop="2px",A},KpA=(t,A)=>{let j=document.createElement("div");j.className="pagination_container",j.style.display="flex",j.style.flexDirection="column",j.style.alignItems="center",j.style.justifyContent="center",j.style.marginLeft="10px",j.style.marginRight="10px",j.style.minWidth="100px";let{cells:e,num_rows:r,num_cols:n,current_page:i}=t.yearbook,o=rh(e.length,r,n),l="#8797ff",c="gray",B=document.createElement("div");B.className="page_text",B.style.fontSize="12px",B.style.fontWeight="bold",B.style.color="#47515b",B.style.marginBottom="5px",B.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',B.textContent=`${i+1} / ${o}`;let h=document.createElement("div");h.style.display="flex",h.style.flexDirection="row",h.style.gap="5px";let d=document.createElement("button");d.textContent="\u25C0",d.style.padding="4px 8px",d.style.cursor="pointer",d.style.border="1px solid #d3d3d3",d.style.borderRadius="4px",d.style.backgroundColor=i>0?"#f0f0f0":"#e0e0e0",d.style.color=i>0?"#333":"#999",d.disabled=i===0,d.onclick=()=>{if(t.yearbook.current_page>0){let x=t.yearbook.current_page-1;A(x)}};let k=document.createElement("button");k.textContent="\u25B6",k.style.padding="4px 8px",k.style.cursor="pointer",k.style.border="1px solid #d3d3d3",k.style.borderRadius="4px",k.style.backgroundColor=i=o-1,k.onclick=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols);if(t.yearbook.current_page{let O=document.createElement("span");return O.textContent=x,O.style.fontSize="11px",O.style.fontWeight="bold",O.style.cursor="pointer",O.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',O.style.userSelect="none",O},m=E("START");m.style.color=i===0?l:c,m.onclick=()=>{t.yearbook.current_page!==0&&A(0)};let y=Math.floor((o-1)/2),G=E("MID");G.style.color=i===y?l:c,G.onclick=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols),O=Math.floor((x-1)/2);t.yearbook.current_page!==O&&A(O)};let v=o-1,_=E("END");_.style.color=i===v?l:c,_.onclick=()=>{let O=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols)-1;t.yearbook.current_page!==O&&A(O)};let w=()=>{let x=rh(t.yearbook.cells.length,t.yearbook.num_rows,t.yearbook.num_cols),O=t.yearbook.current_page,F=Math.floor((x-1)/2),C=x-1;B.textContent=`${O+1} / ${x}`,d.disabled=O===0,d.style.backgroundColor=O>0?"#f0f0f0":"#e0e0e0",d.style.color=O>0?"#333":"#999",k.disabled=O>=x-1,k.style.backgroundColor=O{let i=DpA(),o=NpA();e.containers.image=$l("image_container","column");let l=$l("img_layers_container","column",72);l.style.width="135px",l.style.border="1px solid #d3d3d3",l.style.marginTop="3px",l.style.marginLeft="2px",l.addEventListener("wheel",R=>{let{scrollTop:X,scrollHeight:T,clientHeight:Q}=l,b=X===0,jA=X+Q===T;(b&&R.deltaY<0||jA&&R.deltaY>0)&&R.preventDefault()});let c="115px",B=$l("cell_container","column");B.style.width=c;let h=$l("cell_ctrl_container","row");h.style.marginLeft="0px";let d=$l("gene_container","column");d.style.marginTop="0px",d.style.width=c;let k=$l("trx_container","row"),g=j8("cell_slider_container"),E=j8("trx_slider_container"),m=$l("image_layer_container","row");kn(m,"ist","IMG","blue",30,"button",A,j,e),e.containers.image.appendChild(m);let y=(R,X)=>R.image_layer_sliders.filter(T=>T.name===X),G=(R,X)=>{let T=X.button_name,Q=$l("image_layer_container","row");Q.style.height="21px",kn(Q,"ist",T,"blue",75,"img_layer_button",A,j,e);let b=j8(T),jA=y(R,T)[0],pA=g_(T,A,j,e),$A=Sf(pA,100);Df(jA,50,$A),b.appendChild(jA),Q.appendChild(b),l.appendChild(Q)};e.img.image_info.map(R=>G(e.img,R)),e.obs_store.viz_image_layers.subscribe(R=>{VA(e.containers.image).selectAll(".img_layer_button").style("color",R?"blue":"gray"),e.img.image_layer_sliders.map(X=>Rj(X,R)),Cf(j,R),TA(e,j,"image_layers")}),e.obs_store.viz_background_layer.subscribe(R=>{c_(j,R),TA(e,j,"background_layer")}),e.containers.image.appendChild(l),kn(h,"ist","CELL","blue",40,"button",A,j,e),kn(k,"ist","TRX","blue",40,"button",A,j,e),e.sliders={},kl("cell",A,j,e),g.appendChild(e.sliders.cell),h.appendChild(g),e.containers.bar_cluster=ju(),e.cats.svg_bar_cluster=Ur("svg"),e.genes.svg_bar_gene=Ur("svg"),Za(e.containers.bar_cluster,Nf,e.cats.svg_bar_cluster,e.cats.cluster_counts,e.cats.color_dict_cluster,A,j,e),e.containers.bar_gene=ju();let v=1e3;e.genes.gene_counts=e.genes.gene_counts.sort((R,X)=>X.value-R.value).slice(0,v),Za(e.containers.bar_gene,Kf,e.genes.svg_bar_gene,e.genes.top_gene_counts,e.genes.color_dict_gene,A,j,e);let _=(R,X)=>T=>{if(!Array.isArray(T)||T.length===0)R.selectAll("g").attr("font-weight","normal").attr("opacity",1),X.scrollTo({top:0,behavior:"smooth"});else if(R.selectAll("g").attr("font-weight",Q=>T.includes(Q.name)?"bold":"normal").attr("opacity",Q=>T.includes(Q.name)?1:.2),T.length===1){let Q=T[0],b=R.selectAll("g").filter(function(){return VA(this).select("text").text()===Q});if(!b.empty()){let jA=b.node(),pA=X.getBoundingClientRect(),dA=jA.getBoundingClientRect(),$A=dA.top,_A=dA.bottom,Y=pA.top,QA=pA.bottom;if(!($A>=Y&&_A<=QA)){let Ct=$A-Y,SA=X.scrollTop+Ct;X.scrollTo({top:SA,behavior:"smooth"})}}}};e.obs_store.selected_cats.subscribe(_(e.cats.svg_bar_cluster,e.containers.bar_cluster),{immediate:!1}),e.obs_store.selected_genes.subscribe(_(e.genes.svg_bar_gene,e.containers.bar_gene),{immediate:!1});let w=({svg:R,color_dict:X,selected_array:T,bar_callback:Q,container:b})=>jA=>{let dA=15*(jA.length+1);R.attr("height",dA);let $A=90,_A=jA.map(ft=>ft.value),Y=ti().domain(F6(_A.length)).range([0,16*_A.length]),QA=ji().domain([0,xj(_A)]).range([0,$A]),mt=R.selectAll("g").data(jA,ft=>ft.name),Ct=mt.enter().append("g").attr("transform",(ft,wA)=>`translate(2,${Y(wA)+2})`).on("click",(ft,wA)=>Q(ft,wA,A,j,e));Ct.append("rect").attr("width",0).attr("height",Y.bandwidth()-1).transition().duration(750).attr("width",ft=>QA(ft.value)),Ct.append("text").attr("fill","black").attr("x","5px").attr("y",Y.bandwidth()/2-1).attr("dy","0.35em").attr("text-anchor","start").attr("opacity",0).text(ft=>ft.name).transition().duration(750).attr("opacity",1);let SA=mt.merge(Ct);SA.transition().duration(750).attr("transform",(ft,wA)=>`translate(2,${Y(wA)+2})`),SA.select("rect").attr("width",ft=>QA(ft.value)).attr("fill",ft=>{let wA=X[ft.name]||[0,0,0],_t=T.length===0||T.includes(ft.name)?1:.1;return`rgba(${wA[0]}, ${wA[1]}, ${wA[2]}, ${_t})`}),SA.select("text").text(ft=>ft.name),mt.exit().transition().duration(750).attr("opacity",0).remove(),b&&b.scrollTo({top:0,behavior:"smooth"})};e.obs_store.new_cell_bar_data.subscribe(w({svg:e.cats.svg_bar_cluster,color_dict:e.cats.color_dict_cluster,selected_array:e.cats.selected_cats,bar_callback:Nf,container:e.containers.bar_cluster}),{immediate:!1}),e.obs_store.new_gene_bar_data.subscribe(w({svg:e.genes.svg_bar_gene,color_dict:e.genes.color_dict_gene,selected_array:e.genes.selected_genes,bar_callback:Kf,container:e.containers.bar_gene}),{immediate:!1}),B.appendChild(h),B.appendChild(e.containers.bar_cluster),kl("trx",A,j,e),k.appendChild(E),E.appendChild(e.sliders.trx),d.appendChild(k),d.appendChild(e.containers.bar_gene),og("ist",A,j,e),e.genes.gene_search.style.marginLeft="0px",e.obs_store.selected_genes.subscribe(async R=>{if(R.length===1){let X=R[0];if(e.genes.gene_search_input.value=X,X!==""){if(e.genes.gene_names.includes(X)){e.genes.gene_text_box.textContent="loading",await nu(X);let T=A7[X];T&&T.name&&T.description?e.genes.gene_text_box.innerHTML=`${T.name}
${T.description}`:e.genes.gene_text_box.textContent=""}}else e.genes.gene_text_box.textContent="";e.genes.gene_text_box.scrollTo({top:0,behavior:"smooth"})}else R.length===0&&(e.genes.gene_search_input.value="",e.genes.gene_text_box.textContent="")}),i.appendChild(o),o.appendChild(e.containers.image),o.appendChild(B),o.appendChild(d),e.genes.gene_search.style.width="160px",e.genes.gene_search.style.marginLeft="5px",o.appendChild(e.genes.gene_search);let x=HpA(e,n);o.appendChild(x);let O=KpA(e,r);o.appendChild(O);let F=document.createElement("div");F.className="logo_button",F.style.marginTop="5px",F.style.marginRight="5px",F.style.cursor="pointer";let C=document.createElement("img");return C.src=`data:image/png;base64,${b_}`,C.alt="Celldega logo",C.style.height="17px",C.style.transition="transform 0.2s ease, filter 0.2s ease",F.onclick=()=>{window.open("https://broadinstitute.github.io/celldega/","_blank")},F.appendChild(C),i.appendChild(F),i};var e8=t=>{let A=[...t];for(let j=A.length-1;j>0;j--){let e=Math.floor(Math.random()*(j+1));[A[j],A[e]]=[A[e],A[j]]}return A},XpA=(t,A,j)=>{if(A[t]!==void 0)return A[t];if(j&&typeof t=="string"){let e=t.indexOf("_");if(e>=0){let r=t.substring(e+1);if(A[r]!==void 0)return A[r]}}},zpA=async(t,A,j,e="cluster")=>{let r=A&&A!=="default"?`_${A}`:"",n=`${t}/cell_clusters${r}/cluster.parquet`,i=await ae(n,Nt.fetch,j);if(!i)return new Map;let o=i.getChild("__index_level_0__")?.toArray()||[],l=i.getChild(e)?.toArray()||i.getChild("cluster")?.toArray()||[],c=new Map;return o.forEach((B,h)=>{c.set(String(B),String(l[h]))}),c},UpA=async(t,A,j,e,r=null)=>{let n;if(r)try{n=await r.readGene(e)}catch{n=null}else{let h=A&&A!=="default"?`_${A}`:"",d=`${t}/cbg${h}/${e}.parquet`;n=await ae(d,Nt.fetch,j)}if(!n)return new Map;let i=n.getChild("__index_level_0__")||n.getChild("cell_id")||n.getChild("cell_name")||n.getChild("index");if(!i)return new Map;let o=i.toArray(),l=n.getChild(e)||n.getChild("expression");if(!l)return console.warn(`Gene expression column '${e}' or 'expression' not found. Available columns:`,n.schema.fields.map(h=>h.name)),new Map;let c=l.toArray(),B=new Map;return o.forEach((h,d)=>{B.set(String(h),Number(c[d]))}),B},VpA=(t,A)=>{if(!A.vector_name_integer)return t;let{nameMapping_inv:j}=A.cats;if(!j)return t;let e=new Map;return t.forEach((r,n)=>{let i=j[n];i&&e.set(String(i),r)}),e},JU=async(t,A,j=100)=>{if(!t||Object.keys(t).length===0)return[];let e=t.cluster,r=t.gene,{max_cells:n}=t,i;n!==void 0?i=n:e&&!r?i=j:i=1/0;let o=A.cats.cell_names_array||[];if(o.length===0)return[];let l=[...o];if(e){let c=e.attr||"leiden",B=String(e.value),h=A.cell_name_prefix||!1;if(A.cats.has_meta_cell&&A.cats.meta_cell){let d=A.cats.meta_cell_attr.indexOf(c);d>=0?l=l.filter(k=>{let g=XpA(k,A.cats.meta_cell,h);return g?String(g[d])===B:!1}):console.warn(`Cluster attribute '${c}' not found`)}else if(A.cats.dict_cell_cats&&Object.keys(A.cats.dict_cell_cats).length>0)l=l.filter(d=>String(A.cats.dict_cell_cats[d])===B);else try{let d=await zpA(A.global_base_url,A.seg.version,A.aws,c);l=l.filter(k=>d.get(k)===B)}catch{return[]}}if(l.length===0)return[];if(r)try{let c=await UpA(A.global_base_url,A.seg.version,A.aws,r,A.row_group_readers?.cbg),B=VpA(c,A);B.size>0?l=l.map(d=>({name:d,exp:B.get(d)||0})).filter(d=>d.exp>=1).sort((d,k)=>k.exp-d.exp).map(d=>d.name):l=e8(l)}catch{l=e8(l)}else!r&&e&&(l=e8(l));return i!==1/0&&l.length>i?l.slice(0,i):l};async function QpA(t,A){let j=t.img.landscape_parameters;if(!j.use_row_groups){t.use_row_groups=!1;return}let e=j.row_group_files||{},r=j.tile_grid||{};if(!r.num_tiles_x||!r.num_tiles_y){t.use_row_groups=!1;return}t.use_row_groups=!0,t.row_group_readers={},t.tile_grid=r;try{if(e.transcripts&&(t.row_group_readers.trx=new ml(A,r,e.transcripts),await t.row_group_readers.trx.initialize()),e.cell_segmentation&&(t.row_group_readers.cell=new ml(A,r,e.cell_segmentation),await t.row_group_readers.cell.initialize()),e.cbg&&(t.row_group_readers.cbg=new Ah(A,e.cbg),await t.row_group_readers.cbg.initialize()),e.images){t.row_group_readers.images={};for(let[n,i]of Object.entries(e.images))t.row_group_readers.images[n]=new th(A,i),await t.row_group_readers.images[n].initialize()}}catch{t.use_row_groups=!1}}var WpA=(t,A,j)=>{let e=t/j;return Math.log2(A/e)},r8=async(t,A,j,e,r="",n=[],i=2,o=3,l=50,c=4,B=0,h=800,d={},k=[],g={},E=[],m="default",y={},G=null,v=0,_={},w=!1)=>{B===0&&(B="100%");let x={};x.obs_store=Zf(),x.highlighted_cells=new Set,x.selection_token=0,x.cell_name_prefix=w,x.yearbook={cells:n,num_rows:i,num_cols:o,portrait_size_um:l,portrait_gap:c,current_page:v,zoom_level:0,portrait_centers:[],query:_},x.max_tiles_to_view=50,x.seg={},x.seg.version=m,x.root=t,x.buttons={},x.buttons.blue="#8797ff",x.buttons.gray="gray",x.buttons.light_gray="#EEEEEE",x.buttons.buttons={},Es(x,e),x.close_up=!0,x.model=A,x.containers={},x.containers.root_dim={},x.containers.root_dim.width=B,x.containers.root_dim.height=h,x.cats={},x.cats.cat=null,x.cats.reset_cat=!1,x.cats.selected_cats=[],x.cats.cell_cats=[],x.cats.dict_cell_cats={},x.cats.color_dict_cluster={},x.cats.cluster_counts=[],x.cats.polygon_cell_names=[],Object.keys(d).length===0?x.cats.has_meta_cell=!1:x.cats.has_meta_cell=!0,x.cats.meta_cell=d,x.cats.meta_cell_attr=k,x.cats.meta_cell_id_set=new Set(Object.keys(d||{}).map(fA=>String(fA))),x.cats.inst_cell_attr=k[0]||"N.A.",Object.keys(g).length===0?x.cats.has_meta_cluster=!1:x.cats.has_meta_cluster=!0,x.cats.meta_cluster=g,x.cats.meta_cluster_attr=E,x.cats.inst_cluster_attr=E[0]||"N.A.",x.genes={},x.genes.color_dict_gene={},x.genes.gene_names=[],x.genes.meta_gene={},x.genes.gene_counts=[],x.genes.selected_genes=[],x.genes.trx_ini_radius=.25,x.genes.trx_names_array=[],x.genes.trx_data=[],x.genes.gene_text_box="",x.genes.trx_slider=document.createElement("input"),x.genes.gene_search=document.createElement("div"),x.cats.cell_exp_array=[],x.cats.cell_names_array=[],x.cats.cell_name_to_index_map=new Map,x.img={},x.img.image_layer_colors={},x.img.image_layer_sliders={},x.umap={},x.umap.has_umap=!1,x.umap.umap={},x.nbhd={},x.nbhd.visible=!1,x.nbhd.edit=!1,x.nbhd.is_nbhd=!1,x.nbhd.feature_collection={type:"FeatureCollection",features:[]},x.spatial={},"accessKeyId"in y?x.aws=new Yo({accessKeyId:y.accessKeyId,secretAccessKey:y.secretAccessKey,sessionToken:y.sessionToken}):x.aws=null,x.rotation={hasRotation:!1},Z7(j),await xs(x.img,e,x.aws);let O=x.img.landscape_parameters.technology;await QpA(x,e);let F=x.img.landscape_parameters.image_info,C=F[0].name;x.vector_name_integer=x.img.landscape_parameters.use_int_index,Qf(x.img,x.img.landscape_parameters.image_format),Wf(x.img,F),Hf(x.img),Yf(x.img.image_layer_colors,x.img.image_info);let R=document.createElement("div");R.style.position="relative",R.style.height=`${h}px`,R.style.border="1px solid #d3d3d3";let X=typeof G=="number"&&!Number.isNaN(G)&&G>0?G:null,Q=P_[O]??X;x.yearbook.micronsPerPixel=Q,Q&&(x.scale_bar=I_(Q,O),R.appendChild(x.scale_bar.container)),await $s(x,e,C),await gl(x.genes,e,x.seg.version,x.aws),await Jf(x);let b=async fA=>{if(!fA||Object.keys(fA).length===0)return[];let PA=i*o*10;try{return await JU(fA,x,PA)}catch{return[]}};x.cache={},x.cache.cell=await Vf(),x.cache.trx=await Vf(),x.combo_data={},x.combo_data.trx=[],x.combo_data.cell=[],x.tooltip_cat_cell="",x.edit={},x.edit.feature_collection={type:"FeatureCollection",features:[]},x.edit.visible=!1;let jA=typeof B=="string"?t.clientWidth||1e3:B,pA=jA-(o-1)*c,dA=h-100-(i-1)*c,$A=pA/o,_A=dA/i,Y=Math.min($A,_A);if(x.yearbook.portrait_pixel_size=Y,Q){let fA=WpA(l,Y,Q);x.yearbook.zoom_level=fA,x.yearbook.portrait_data_size=l/Q}else x.yearbook.portrait_data_size=l/.2125;let QA=Rf(x),mt=[],Ct=await d_(e,x),SA=await t_(x),ft=r_(x);if(x.yearbook.cells.length===0){let fA=[];if(Object.keys(_).length>0)fA=await b(_);else{let PA=x.cats.cell_names_array||[],RA=i*o*10;PA.length>0&&(fA=[...PA].sort(()=>Math.random()-.5).slice(0,Math.min(RA,PA.length)))}x.yearbook.cells=fA,x.model&&typeof x.model.set=="function"&&(x.model.set("cells",fA),x.model.save_changes())}let wA=VU(i,o,Y,c);x.views=wA;let _t=await s_(R,jA,h-100,O);a_(_t,wA),l_(_t,x),_t.setProps({layerFilter:({layer:fA,viewport:PA})=>{let bt=fA.id.match(/-p(\d+)-/);if(bt){let we=`portrait-${parseInt(bt[1],10)}`;return PA.id===we}return!0}});let qA={background_layer:QA,image_layers:mt,cell_layer:Ct,path_layer:SA,trx_layer:ft,nbhd_layer:null,edit_layer:null};x.layers_obj=qA;let Ht={},GA=()=>{let fA=x.yearbook.portrait_centers,{portrait_data_size:PA}=x.yearbook,RA=PA/2,we=(x.combo_data.trx||[]).filter(Gt=>fA.some(J=>Gt.x>=J.x-RA&&Gt.x<=J.x+RA&&Gt.y>=J.y-RA&&Gt.y<=J.y+RA)).map(Gt=>Gt.name).reduce((Gt,J)=>{let P=Gt.find(S=>S.name===J);return P?P.value+=1:Gt.push({name:J,value:1}),Gt},[]).filter(Gt=>Gt.value>0).sort((Gt,J)=>J.value-Gt.value).slice(0,100);x.obs_store.new_gene_bar_data.set(we);let Ij=(x.combo_data.cell||[]).filter(Gt=>fA.some(J=>Gt.x>=J.x-RA&&Gt.x<=J.x+RA&&Gt.y>=J.y-RA&&Gt.y<=J.y+RA)).map(Gt=>Gt.cat).reduce((Gt,J)=>{let P=Gt.find(S=>S.name===J);return P?P.value+=1:Gt.push({name:J,value:1}),Gt},[]).filter(Gt=>Gt.value>0).sort((Gt,J)=>J.value-Gt.value);x.obs_store.new_cell_bar_data.set(Ij)},l6=async()=>{let fA=i*o,PA=x.yearbook.current_page,RA=x.yearbook.cells,bt=PA*fA,we=RA.slice(bt,bt+fA).map(Ee=>{let MA=x.cats.cell_name_to_index_map.get(Ee);if(MA!==void 0&&x.spatial.cell_scatter_data_objects){let Ij=x.spatial.cell_scatter_data_objects[MA];if(Ij&&Ij.position)return{cell_id:Ee,x:Ij.position[0],y:Ij.position[1]}}return{cell_id:Ee,x:x.dimensions.width/2,y:x.dimensions.height/2}});return x.yearbook.portrait_centers=we,we},Tt=async()=>{let fA=await l6(),{zoom_level:PA,portrait_data_size:RA}=x.yearbook,{tile_size:bt}=x.img.landscape_parameters,EA=QU(fA,0,RA,RA,bt);await i_(e,EA,qA,x),await j_(e,EA,qA,x);let we=`page${x.yearbook.current_page}`;qA.image_layers=await uz(x,fA,RA,we);let Ee=x.obs_store.viz_image_layers.get();Cf(qA,Ee),x.layers_obj=qA;let MA={};fA.forEach((J,P)=>{let S=`portrait-${P}`;MA[S]={target:[J.x,J.y,0],zoom:PA},Ht[S]=MA[S]});let Ij=Date.now();qA.cell_layer=qA.cell_layer.clone({id:`cell-layer-page-${x.yearbook.current_page}-${Ij}`}),qA.path_layer=qA.path_layer.clone({id:`path-layer-page-${x.yearbook.current_page}-${Ij}`}),qA.trx_layer=qA.trx_layer.clone({id:`trx-layer-page-${x.yearbook.current_page}-${Ij}`});let Gt=Wr(qA,x.close_up).filter(J=>J!==null);_t.setProps({initialViewState:MA,layers:Gt}),GA(),x.scale_bar&&x.scale_bar.update({zoom:PA})};p_(_t,qA,x),e_(_t,qA,x),n_(_t,qA,x),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),background_layer:!0,cell_layer:!0,path_layer:!0,trx_layer:!0}),x.obs_store.deck_ready.subscribe(fA=>{if(fA){let PA=Wr(x.layers_obj,x.close_up).filter(RA=>RA!==null);_t.setProps({layers:PA})}}),x.obs_store.selected_cats.subscribe(fA=>{let PA=fA.join("-");qA.cell_layer=qA.cell_layer.clone({id:`cell-layer-${PA}-sel-${x.selection_token}`}),qA.path_layer=qA.path_layer.clone({id:`path-layer-${PA}`}),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),cell_layer:!0,path_layer:!0})}),x.obs_store.selected_genes.subscribe(fA=>{let PA=fA.join("-");qA.trx_layer=qA.trx_layer.clone({id:`trx-layer-${PA}`}),x.obs_store.deck_check.set({...x.obs_store.deck_check.get(),trx_layer:!0})}),Tf(qA,.25);let me=()=>{let fA=x.yearbook.portrait_centers,PA=x.yearbook.zoom_level;fA.forEach((RA,bt)=>{Ht[`portrait-${bt}`]={target:[RA.x,RA.y,0],zoom:PA}})};await Tt(),me();let FA=!1,yj=async fA=>{if(!FA){FA=!0;try{x.yearbook.current_page=fA,await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui(),x.model&&typeof x.model.set=="function"&&(x.model.set("current_page",fA),x.model.save_changes())}finally{setTimeout(()=>{FA=!1},300)}}},cj=!1,ce=fA=>{if(cj)return;cj=!0,x.yearbook.zoom_level=fA,x.yearbook.portrait_centers.forEach((RA,bt)=>{Ht[`portrait-${bt}`]={target:[RA.x,RA.y,0],zoom:fA}}),x.scale_bar&&x.scale_bar.update({zoom:fA}),_t.setProps({initialViewState:{...Ht}}),x.model&&typeof x.model.set=="function"&&(x.model.set("zoom_level",fA),x.model.save_changes()),setTimeout(()=>{cj=!1},100)};_t.setProps({onViewStateChange:({viewState:fA})=>{let PA=fA.zoom,RA=x.yearbook.zoom_level;return Math.abs(PA-RA)>.01&&!cj&&requestAnimationFrame(()=>{ce(PA)}),fA}});let Uj=async fA=>{x.yearbook.query=fA,x.yearbook.query_ui&&x.yearbook.query_ui.update_status("Searching...");try{if(fA.gene){let RA=fA.gene;gt(x.cats,RA),x.genes.selected_genes=[RA],x.obs_store.selected_genes.set([RA]),await qr(x.cats,x.genes,x.global_base_url,RA,x.seg.version,x.vector_name_integer,x.aws,x.row_group_readers?.cbg),x.cats.selected_cats=[RA],x.obs_store.selected_cats.set([RA]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer")}else gt(x.cats,"cluster"),x.genes.selected_genes=[],x.obs_store.selected_genes.set([]),x.cats.selected_cats=[],x.obs_store.selected_cats.set([]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer");let PA=await b(fA);if(x.yearbook.cells=PA,x.yearbook.query_ui){let RA=PA.length;x.yearbook.query_ui.update_status(`Found ${RA} cells`)}x.model&&typeof x.model.set=="function"&&(x.model.set("cells",PA),x.model.set("query",fA),x.model.set("current_page",0),x.model.save_changes()),x.yearbook.current_page=0,await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui()}catch{x.yearbook.query_ui&&x.yearbook.query_ui.update_status("Query failed")}},KA=YU(r,_t,qA,x,yj,Uj);return Object.keys(x.model).length>0&&(x.model.on("change:current_page",()=>{let fA=x.model.get("current_page");fA!==x.yearbook.current_page&&yj(fA)}),x.model.on("change:cells",async()=>{x.yearbook.cells=x.model.get("cells"),await Tt(),me()}),x.model.on("change:zoom_level",()=>{let fA=x.model.get("zoom_level");Math.abs(fA-x.yearbook.zoom_level)>.01&&ce(fA)}),x.model.on("change:query",async()=>{let fA=x.model.get("query")||{};if(x.yearbook.query=fA,x.yearbook.query_ui){let{cluster_input:PA,gene_input:RA,update_status:bt}=x.yearbook.query_ui;fA.cluster?PA.value=fA.cluster.value||"":PA.value="",fA.gene?RA.value=fA.gene||"":RA.value="",bt("Searching...")}if(Object.keys(fA).length>0){if(fA.gene){let RA=fA.gene;gt(x.cats,RA),x.genes.selected_genes=[RA],x.obs_store.selected_genes.set([RA]),await qr(x.cats,x.genes,x.global_base_url,RA,x.seg.version,x.vector_name_integer,x.aws),x.cats.selected_cats=[RA],x.obs_store.selected_cats.set([RA]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer")}else gt(x.cats,"cluster"),x.genes.selected_genes=[],x.obs_store.selected_genes.set([]),x.cats.selected_cats=[],x.obs_store.selected_cats.set([]),TA(x,qA,"cell_layer"),TA(x,qA,"trx_layer");let PA=await b(fA);x.yearbook.cells=PA,x.yearbook.query_ui&&x.yearbook.query_ui.update_status(`Found ${PA.length} cells`),x.model.set("cells",PA),x.model.save_changes(),x.yearbook.current_page=0,x.model.set("current_page",0),await Tt(),me(),x.yearbook.update_pagination_ui&&x.yearbook.update_pagination_ui()}})),t.appendChild(KA),t.appendChild(R),{update_page:yj,refresh:async()=>{await Tt(),me()},update_query:async fA=>{await Uj(fA)},update_cluster:async(fA,PA="leiden")=>{let bt={...x.yearbook.query||{},cluster:{attr:PA,value:String(fA)}};await Uj(bt)},update_gene:async fA=>{let RA={...x.yearbook.query||{},gene:fA};await Uj(RA)},get_query:()=>x.yearbook.query||{},finalize:()=>{_t.finalize()}}};var ZU=async(t,A=null)=>{let j="https://maayanlab.cloud/Enrichr/addList",e=new FormData;e.append("list",t.join(` `)),A&&Array.isArray(A)&&A.length>0&&e.append("background",A.join(` -`));try{let n=await(await fetch(j,{method:"POST",body:e})).json();return{userListId:n.userListId.toString(),shortId:n.shortId||null}}catch(r){throw Zj(r,{context:"posting gene list to Enrichr",url:j}),r}},VU=async(t,A)=>{let j=`https://maayanlab.cloud/Enrichr/enrich?backgroundType=${A}&userListId=${t}`;try{return await(await fetch(j)).json()}catch(e){throw Zj(e,{context:"fetching enrichment",url:j}),e}};var ag=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{A!==e&&(A=e,j.forEach(r=>r(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},QU=()=>({available_libs:ag([]),selected_lib:ag("CellMarker_2024"),term_genes:ag([]),gene_of_interest:ag(""),selected_term:ag("Select Term")});var lg=(t,A)=>{let j=A||[];VA(t).selectAll("span").style("color",e=>{let r=e.toLowerCase().replace(", ","");return j.length>0?j.includes(r)?"blue":"#2F4F4F":"black"})},WU=async(t,A)=>{if(!t){A.textContent="";return}try{await nu(t);let j=A7[t]||{name:"",description:""},e=document.createElement("b");e.textContent=`${t}: ${j.name}`;let r=document.createElement("p");r.textContent=j.description,A.textContent="",A.appendChild(e),A.appendChild(r)}catch(j){Zj(j,{context:"updateGeneInfo"})}};var A8=async({model:t,el:A})=>{let j=QU();j.available_libs.set(t.get("available_libs")||[]),j.selected_lib.set(t.get("inst_lib")||"CellMarker_2024");let e={},r=null,n=b=>{if(!r)return;let v=r.querySelectorAll("span"),_=(b||"").toLowerCase();v.forEach(w=>{let x=(w.textContent||"").replace(", ","").toLowerCase();w.style.fontWeight=_&&x===_?"bold":"550"}),r.value=b||"Click on a gene to obtain detailed information"},i=document.createElement("div"),o=document.createElement("select"),l=document.createElement("div"),c=document.createElement("div"),B=document.createElement("div"),h=document.createElement("div"),d=document.createElement("div"),k=document.createElement("a");i.appendChild(o),i.appendChild(l),i.appendChild(k),l.appendChild(c),l.appendChild(B),B.appendChild(d),B.appendChild(h),A.appendChild(i);let g=(t.get("width")||350)-5,E=t.get("height")||500;i.style.width=`${g}px`,i.style.height=`${E}px`,i.style.overflowX="scroll",i.style.marginLeft="5px",o.style.marginTop="5px",o.style.width=`${g}px`,l.style.width=`${g}px`,l.style.height=`${E}px`,c.style.width=`${g}px`,c.style.height="255px",c.style.overflowY="auto",c.style.border="1px solid #d3d3d3",B.style.width=`${g}px`,B.style.height="250px",d.style.height="225px",d.style.width=`${g}px`,d.style.marginTop="5px",d.style.overflowY="auto",d.style.border="1px solid #d3d3d3",h.style.height="155px",h.style.width=`${g}px`,h.style.marginTop="5px",h.style.overflowY="auto",h.style.border="1px solid #d3d3d3",h.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',k.style.display="block",k.style.marginTop="5px",k.style.color="#47515b",k.target="_blank",k.textContent="",d.textContent="Paragraph view",h.textContent="Gene info";let m=()=>{o.innerHTML="",j.available_libs.get().forEach(b=>{let v=document.createElement("option");v.value=b,v.textContent=b,o.appendChild(v)}),o.value=j.selected_lib.get()};j.available_libs.subscribe(m),j.selected_lib.subscribe(()=>{o.value=j.selected_lib.get()},{immediate:!1}),o.addEventListener("change",b=>{j.selected_lib.set(b.target.value),t.set("inst_lib",b.target.value),t.save_changes()}),t.on("change:available_libs",()=>{j.available_libs.set(t.get("available_libs")||[])}),t.on("change:inst_lib",()=>{j.selected_lib.set(t.get("inst_lib"))}),j.term_genes.subscribe(b=>{r&&lg(r,b)},{immediate:!1}),j.gene_of_interest.subscribe(b=>{WU(b,h),n(b)},{immediate:!1});let y=async()=>{let b=t.get("gene_list")||[],v=j.selected_lib.get(),_=t.get("num_terms")||10,w=t.get("background_list")||null;if(!b.length){c.textContent="No genes provided.",d.textContent="Paragraph view",h.textContent="",k.textContent="",k.removeAttribute("href");return}c.textContent="Loading...";try{let x=`${b.join(",")}__${v}__${w?w.join(","):"none"}`,S,F;if(e[x])({data:S,shortId:F}=e[x]);else{let{userListId:$A,shortId:_A}=await UU(b,w);F=_A,S=await VU($A,v),e[x]={data:S,shortId:F}}let D=(S[v]||[]).map($A=>({name:$A[1],score:$A[4],genes:$A[5]})).sort(($A,_A)=>_A.score-$A.score).slice(0,_),L=D.map($A=>$A.score),z=ji().domain([0,L.length>0?xj(L):0]).range([0,g]),T=ti().domain(F6(L.length)).range([0,22*L.length]),W=Ur("svg").attr("width",g).attr("height",T.range()[1]).style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').attr("font-size","14").attr("text-anchor","end"),G={term_name:"Select Term",term_genes:[],score:0};W.property("value",{...G});let jA=W.selectAll("g").data(D).join("g").attr("transform",($A,_A)=>`translate(0,${T(_A)})`).on("click",function($A,_A){let Y=j.selected_term.get()===_A.name,QA=Y?G:{term_genes:_A.genes.map(mt=>mt.toLowerCase()),term_name:_A.name,score:_A.score};W.property("value",QA).dispatch("input"),Y?W.selectAll("text").attr("fill","black"):(W.selectAll("text").attr("fill","gray"),VA(this).select("text").attr("fill","black"))});jA.append("rect").attr("fill","steelblue").attr("opacity",.25).attr("width",$A=>z($A.score)).attr("height",T.bandwidth()-1),jA.append("text").attr("fill","black").attr("x","5px").attr("y",T.bandwidth()/2).attr("dy","0.35em").attr("text-anchor","start").text($A=>$A.name);let pA=W.node();c.innerHTML="";let dA=document.createElement("div");dA.style.userSelect="none",dA.value="Click on a gene to obtain detailed information",r=dA,VA(dA).selectAll("div").style("margin-top","5px").data(b.map($A=>`${$A}, `)).join("span").text($A=>$A).style("font-weight","550").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').style("color",()=>"black").on("click",function($A,_A){let Y=_A.replace(", ",""),QA=j.gene_of_interest.get();Y===QA?(j.gene_of_interest.set(""),dA.value="Click on a gene to obtain detailed information",VA(dA).selectAll("span").style("font-weight","550")):(VA(dA).selectAll("span").style("font-weight","550"),VA(this).style("font-weight","bold"),j.gene_of_interest.set(Y),dA.value=Y),t.set("focused_gene",j.gene_of_interest.get()||""),t.save_changes(),dA.dispatchEvent(new CustomEvent("input"))}),c.appendChild(pA),d.innerHTML="",d.appendChild(dA),n(j.gene_of_interest.get()),pA.addEventListener("input",()=>{let $A=pA.value||{},_A=$A.term_genes||[],Y=$A.term_name||"Select Term";j.term_genes.set(_A),j.selected_term.set(Y),t.set("term_genes",_A),t.set("selected_term",Y),t.save_changes(),lg(dA,_A)}),lg(dA,j.term_genes.get()),F?(k.href=`https://maayanlab.cloud/Enrichr/enrich?dataset=${F}`,k.textContent="View full results on Enrichr"):(k.textContent="",k.removeAttribute("href"))}catch(x){Zj(x,{context:"render_enrich"}),c.textContent="Error loading enrichment data.",h.textContent="",k.textContent="",k.removeAttribute("href")}};t.on("change:gene_list",y),t.on("change:inst_lib",y),t.on("change:num_terms",y),t.on("change:background_list",y),t.on("change:focused_gene",()=>{let b=t.get("focused_gene")||"";j.gene_of_interest.get()!==b&&j.gene_of_interest.set(b),n(b)}),t.on("change:term_genes",()=>{let b=t.get("term_genes")||[];j.term_genes.set(b),r&&lg(r,b)}),t.on("change:selected_term",()=>{let b=t.get("selected_term")||"Select Term";j.selected_term.set(b)}),await y()};var YU=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("creds"),r=t.get("ini_x"),n=t.get("ini_y"),i=t.get("ini_z"),o=t.get("ini_zoom"),l=t.get("base_url"),c=t.get("base_urls")||[],B=t.get("cell_name_prefix")||!1,h=t.get("dataset_name"),d=t.get("width"),k=t.get("height"),g=t.get("rotation_orbit")??0,E=t.get("rotation_x")??0,m=t.get("rotate")??0,y=t.get("nbhd_geojson"),b=t.get("max_tiles_to_view"),v=t.get("nbhd_edit"),_=t.get("scale_bar_microns_per_pixel"),w={result:{},attr:[]},x={result:{},attr:[]},S={},F=t.get("meta_cell_parquet");F&&F.byteLength>0&&(w=await jB(F,"cell_id"));let D=t.get("meta_cluster_parquet");D&&D.byteLength>0&&(x=await jB(D,"leiden"));let L=t.get("umap_parquet");L&&L.byteLength>0&&(S=(await jB(L,"cell_id")).result);let z=t.get("technology"),T=t.get("landscape_state");z==="Chromium"?T="umap":z==="point-cloud"&&(T="spatial");let W=t.get("segmentation");return KI(A,t,j,r,n,i,o,l,h,.25,d,k,w.result,w.attr,x.result,x.attr,S,y,v,T,W,e,null,g,E,m,b,_,c,B)},JU=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("ini_x"),r=t.get("ini_y"),n=t.get("ini_z"),i=t.get("ini_zoom"),o=t.get("base_url"),l=t.get("dataset_name"),c=t.get("square_tile_size"),B=t.get("width"),h=t.get("height");XI(t,A,o,j,e,r,n,i,c,l,B,h)},ZU=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("ini_x"),r=t.get("ini_y"),n=t.get("ini_z"),i=t.get("ini_zoom"),o=t.get("base_url"),l=t.get("dataset_name"),c=t.get("width"),B=t.get("height"),h=t.get("creds");s1(t,A,o,j,e,r,n,i,l,c,B,h)},A9=async({model:t,el:A})=>{let j=t.get("technology");if(["MERSCOPE","Xenium","Chromium","point-cloud","Visium-HD"].includes(j))return YU({model:t,el:A});if(["Visium-HD-no-jitter"].includes(j))return JU({model:t,el:A});if(["h&e"].includes(j))return ZU({model:t,el:A})},t9=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("creds"),r=t.get("base_url"),n=t.get("dataset_name"),i=t.get("width"),o=t.get("height"),l=t.get("cells")||[],c=t.get("num_rows")||2,B=t.get("num_cols")||3,h=t.get("portrait_size_um")||100,d=t.get("portrait_gap")||4,k=t.get("segmentation")||"default",g=t.get("scale_bar_microns_per_pixel"),E=t.get("current_page")||0,m=t.get("query")||{},y=t.get("cell_name_prefix")||!1,b={result:{},attr:[]},v={result:{},attr:[]},_=t.get("meta_cell_parquet");_&&_.byteLength>0&&(b=await jB(_,"cell_id"));let w=t.get("meta_cluster_parquet");return w&&w.byteLength>0&&(v=await jB(w,"leiden")),ZI(A,t,j,r,n,l,c,B,h,d,i,o,b.result,b.attr,v.result,v.attr,k,e,g,E,m,y)},j9=async({model:t,el:A})=>{let j,e=t.get("width"),r=t.get("height"),n=t.get("mat_parquet");return n&&n.byteLength>0&&(j=await R4(t.get("network_meta"),n,t.get("row_nodes_parquet"),t.get("col_nodes_parquet"),t.get("row_linkage_parquet"),t.get("col_linkage_parquet"),t.get("row_entity"),t.get("col_entity"))),P_(t,A,j,e,r)};async function XpA({model:t,el:A}){let j=null;try{let e=t.get("component");if(!e){Uu("Component type is not defined",{data:{model:t?.id||"unknown",el:A?.id||"unknown"}});return}switch(e){case"Landscape":j=await A9({model:t,el:A});break;case"Yearbook":j=await t9({model:t,el:A});break;case"Matrix":j=await j9({model:t,el:A});break;case"Enrich":j=await A8({model:t,el:A});break;default:Uu(`Unknown component type: ${e}`,{data:{componentType:e,model:t?.id||"unknown"}});return}t.on("msg:custom",r=>{if(r.event==="finalize"&&j){try{typeof j=="function"?j():j.finalize&&j.finalize()}catch(n){Uu("Error finalizing deck",{data:{error:n.message,model:t?.id||"unknown"}})}j=null}})}catch(e){let r=Zj(e,{context:"render function",logUnexpected:!0,messages:{unexpected:"Error in render function"}});A.innerHTML=`
Error: ${r.message}
`}}var zpA=async(t,A,j="default",e=500,r=500,n=null,i=null,o=null,l={})=>{let c=await Wq(A,j,l);return P_({get:h=>h==="row_entity"?JSON.stringify(c.row_entity||{entity:"gene",attr:"name"}):h==="col_entity"?JSON.stringify(c.col_entity||{entity:"cell",attr:"leiden"}):null,set:()=>{},save_changes:()=>{},on:()=>{}},t,c,e,r,n,i,o)},cGt={landscape_ist:KI,landscape_sst:XI,landscape_h_e:s1,matrix_viz:P_,matrix_from_dega_files:zpA,networkFromDegaFiles:Wq,yearbook:ZI,render:XpA,render_landscape_ist:YU,render_landscape_sst:JU,render_landscape_h_e:ZU,render_landscape:A9,render_yearbook:t9,render_matrix_new:j9,render_enrich:A8};export{cGt as default}; +`));try{let n=await(await fetch(j,{method:"POST",body:e})).json();return{userListId:n.userListId.toString(),shortId:n.shortId||null}}catch(r){throw Zj(r,{context:"posting gene list to Enrichr",url:j}),r}},A9=async(t,A)=>{let j=`https://maayanlab.cloud/Enrichr/enrich?backgroundType=${A}&userListId=${t}`;try{return await(await fetch(j)).json()}catch(e){throw Zj(e,{context:"fetching enrichment",url:j}),e}};var ug=t=>{let A=t,j=new Set;return{get:()=>A,getDefault:()=>t,set:e=>{A!==e&&(A=e,j.forEach(r=>r(A)))},subscribe:(e,r={immediate:!0})=>(j.add(e),r.immediate&&e(A),()=>j.delete(e))}},t9=()=>({available_libs:ug([]),selected_lib:ug("CellMarker_2024"),term_genes:ug([]),gene_of_interest:ug(""),selected_term:ug("Select Term")});var Bg=(t,A)=>{let j=A||[];VA(t).selectAll("span").style("color",e=>{let r=e.toLowerCase().replace(", ","");return j.length>0?j.includes(r)?"blue":"#2F4F4F":"black"})},j9=async(t,A)=>{if(!t){A.textContent="";return}try{await nu(t);let j=A7[t]||{name:"",description:""},e=document.createElement("b");e.textContent=`${t}: ${j.name}`;let r=document.createElement("p");r.textContent=j.description,A.textContent="",A.appendChild(e),A.appendChild(r)}catch(j){Zj(j,{context:"updateGeneInfo"})}};var n8=async({model:t,el:A})=>{let j=t9();j.available_libs.set(t.get("available_libs")||[]),j.selected_lib.set(t.get("inst_lib")||"CellMarker_2024");let e={},r=null,n=G=>{if(!r)return;let v=r.querySelectorAll("span"),_=(G||"").toLowerCase();v.forEach(w=>{let x=(w.textContent||"").replace(", ","").toLowerCase();w.style.fontWeight=_&&x===_?"bold":"550"}),r.value=G||"Click on a gene to obtain detailed information"},i=document.createElement("div"),o=document.createElement("select"),l=document.createElement("div"),c=document.createElement("div"),B=document.createElement("div"),h=document.createElement("div"),d=document.createElement("div"),k=document.createElement("a");i.appendChild(o),i.appendChild(l),i.appendChild(k),l.appendChild(c),l.appendChild(B),B.appendChild(d),B.appendChild(h),A.appendChild(i);let g=(t.get("width")||350)-5,E=t.get("height")||500;i.style.width=`${g}px`,i.style.height=`${E}px`,i.style.overflowX="scroll",i.style.marginLeft="5px",o.style.marginTop="5px",o.style.width=`${g}px`,l.style.width=`${g}px`,l.style.height=`${E}px`,c.style.width=`${g}px`,c.style.height="255px",c.style.overflowY="auto",c.style.border="1px solid #d3d3d3",B.style.width=`${g}px`,B.style.height="250px",d.style.height="225px",d.style.width=`${g}px`,d.style.marginTop="5px",d.style.overflowY="auto",d.style.border="1px solid #d3d3d3",h.style.height="155px",h.style.width=`${g}px`,h.style.marginTop="5px",h.style.overflowY="auto",h.style.border="1px solid #d3d3d3",h.style.fontFamily='-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif',k.style.display="block",k.style.marginTop="5px",k.style.color="#47515b",k.target="_blank",k.textContent="",d.textContent="Paragraph view",h.textContent="Gene info";let m=()=>{o.innerHTML="",j.available_libs.get().forEach(G=>{let v=document.createElement("option");v.value=G,v.textContent=G,o.appendChild(v)}),o.value=j.selected_lib.get()};j.available_libs.subscribe(m),j.selected_lib.subscribe(()=>{o.value=j.selected_lib.get()},{immediate:!1}),o.addEventListener("change",G=>{j.selected_lib.set(G.target.value),t.set("inst_lib",G.target.value),t.save_changes()}),t.on("change:available_libs",()=>{j.available_libs.set(t.get("available_libs")||[])}),t.on("change:inst_lib",()=>{j.selected_lib.set(t.get("inst_lib"))}),j.term_genes.subscribe(G=>{r&&Bg(r,G)},{immediate:!1}),j.gene_of_interest.subscribe(G=>{j9(G,h),n(G)},{immediate:!1});let y=async()=>{let G=t.get("gene_list")||[],v=j.selected_lib.get(),_=t.get("num_terms")||10,w=t.get("background_list")||null;if(!G.length){c.textContent="No genes provided.",d.textContent="Paragraph view",h.textContent="",k.textContent="",k.removeAttribute("href");return}c.textContent="Loading...";try{let x=`${G.join(",")}__${v}__${w?w.join(","):"none"}`,O,F;if(e[x])({data:O,shortId:F}=e[x]);else{let{userListId:$A,shortId:_A}=await ZU(G,w);F=_A,O=await A9($A,v),e[x]={data:O,shortId:F}}let C=(O[v]||[]).map($A=>({name:$A[1],score:$A[4],genes:$A[5]})).sort(($A,_A)=>_A.score-$A.score).slice(0,_),R=C.map($A=>$A.score),X=ji().domain([0,R.length>0?xj(R):0]).range([0,g]),T=ti().domain(F6(R.length)).range([0,22*R.length]),Q=Ur("svg").attr("width",g).attr("height",T.range()[1]).style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').attr("font-size","14").attr("text-anchor","end"),b={term_name:"Select Term",term_genes:[],score:0};Q.property("value",{...b});let jA=Q.selectAll("g").data(C).join("g").attr("transform",($A,_A)=>`translate(0,${T(_A)})`).on("click",function($A,_A){let Y=j.selected_term.get()===_A.name,QA=Y?b:{term_genes:_A.genes.map(mt=>mt.toLowerCase()),term_name:_A.name,score:_A.score};Q.property("value",QA).dispatch("input"),Y?Q.selectAll("text").attr("fill","black"):(Q.selectAll("text").attr("fill","gray"),VA(this).select("text").attr("fill","black"))});jA.append("rect").attr("fill","steelblue").attr("opacity",.25).attr("width",$A=>X($A.score)).attr("height",T.bandwidth()-1),jA.append("text").attr("fill","black").attr("x","5px").attr("y",T.bandwidth()/2).attr("dy","0.35em").attr("text-anchor","start").text($A=>$A.name);let pA=Q.node();c.innerHTML="";let dA=document.createElement("div");dA.style.userSelect="none",dA.value="Click on a gene to obtain detailed information",r=dA,VA(dA).selectAll("div").style("margin-top","5px").data(G.map($A=>`${$A}, `)).join("span").text($A=>$A).style("font-weight","550").style("font-family",'-apple-system, BlinkMacSystemFont, "San Francisco", "Helvetica Neue", Helvetica, Arial, sans-serif').style("color",()=>"black").on("click",function($A,_A){let Y=_A.replace(", ",""),QA=j.gene_of_interest.get();Y===QA?(j.gene_of_interest.set(""),dA.value="Click on a gene to obtain detailed information",VA(dA).selectAll("span").style("font-weight","550")):(VA(dA).selectAll("span").style("font-weight","550"),VA(this).style("font-weight","bold"),j.gene_of_interest.set(Y),dA.value=Y),t.set("focused_gene",j.gene_of_interest.get()||""),t.save_changes(),dA.dispatchEvent(new CustomEvent("input"))}),c.appendChild(pA),d.innerHTML="",d.appendChild(dA),n(j.gene_of_interest.get()),pA.addEventListener("input",()=>{let $A=pA.value||{},_A=$A.term_genes||[],Y=$A.term_name||"Select Term";j.term_genes.set(_A),j.selected_term.set(Y),t.set("term_genes",_A),t.set("selected_term",Y),t.save_changes(),Bg(dA,_A)}),Bg(dA,j.term_genes.get()),F?(k.href=`https://maayanlab.cloud/Enrichr/enrich?dataset=${F}`,k.textContent="View full results on Enrichr"):(k.textContent="",k.removeAttribute("href"))}catch(x){Zj(x,{context:"render_enrich"}),c.textContent="Error loading enrichment data.",h.textContent="",k.textContent="",k.removeAttribute("href")}};t.on("change:gene_list",y),t.on("change:inst_lib",y),t.on("change:num_terms",y),t.on("change:background_list",y),t.on("change:focused_gene",()=>{let G=t.get("focused_gene")||"";j.gene_of_interest.get()!==G&&j.gene_of_interest.set(G),n(G)}),t.on("change:term_genes",()=>{let G=t.get("term_genes")||[];j.term_genes.set(G),r&&Bg(r,G)}),t.on("change:selected_term",()=>{let G=t.get("selected_term")||"Select Term";j.selected_term.set(G)}),await y()};var e9=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("creds"),r=t.get("ini_x"),n=t.get("ini_y"),i=t.get("ini_z"),o=t.get("ini_zoom"),l=t.get("base_url"),c=t.get("base_urls")||[],B=t.get("cell_name_prefix")||!1,h=t.get("dataset_name"),d=t.get("width"),k=t.get("height"),g=t.get("rotation_orbit")??0,E=t.get("rotation_x")??0,m=t.get("rotate")??0,y=t.get("nbhd_geojson"),G=t.get("max_tiles_to_view"),v=t.get("nbhd_edit"),_=t.get("scale_bar_microns_per_pixel"),w={result:{},attr:[]},x={result:{},attr:[]},O={},F=t.get("meta_cell_parquet");F&&F.byteLength>0&&(w=await jB(F,"cell_id"));let C=t.get("meta_cluster_parquet");C&&C.byteLength>0&&(x=await jB(C,"leiden"));let R=t.get("umap_parquet");R&&R.byteLength>0&&(O=(await jB(R,"cell_id")).result);let X=t.get("technology"),T=t.get("landscape_state");X==="Chromium"?T="umap":X==="point-cloud"&&(T="spatial");let Q=t.get("segmentation");return QI(A,t,j,r,n,i,o,l,h,.25,d,k,w.result,w.attr,x.result,x.attr,O,y,v,T,Q,e,null,g,E,m,G,_,c,B)},r9=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("ini_x"),r=t.get("ini_y"),n=t.get("ini_z"),i=t.get("ini_zoom"),o=t.get("base_url"),l=t.get("dataset_name"),c=t.get("square_tile_size"),B=t.get("width"),h=t.get("height");WI(t,A,o,j,e,r,n,i,c,l,B,h)},n9=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("ini_x"),r=t.get("ini_y"),n=t.get("ini_z"),i=t.get("ini_zoom"),o=t.get("base_url"),l=t.get("dataset_name"),c=t.get("width"),B=t.get("height"),h=t.get("creds");B1(t,A,o,j,e,r,n,i,l,c,B,h)},i9=async({model:t,el:A})=>{let j=t.get("technology");if(["MERSCOPE","Xenium","Chromium","point-cloud","Visium-HD"].includes(j))return e9({model:t,el:A});if(["Visium-HD-no-jitter"].includes(j))return r9({model:t,el:A});if(["h&e"].includes(j))return n9({model:t,el:A})},o9=async({model:t,el:A})=>{let j=t.get("token"),e=t.get("creds"),r=t.get("base_url"),n=t.get("dataset_name"),i=t.get("width"),o=t.get("height"),l=t.get("cells")||[],c=t.get("num_rows")||2,B=t.get("num_cols")||3,h=t.get("portrait_size_um")||100,d=t.get("portrait_gap")||4,k=t.get("segmentation")||"default",g=t.get("scale_bar_microns_per_pixel"),E=t.get("current_page")||0,m=t.get("query")||{},y=t.get("cell_name_prefix")||!1,G={result:{},attr:[]},v={result:{},attr:[]},_=t.get("meta_cell_parquet");_&&_.byteLength>0&&(G=await jB(_,"cell_id"));let w=t.get("meta_cluster_parquet");return w&&w.byteLength>0&&(v=await jB(w,"leiden")),r8(A,t,j,r,n,l,c,B,h,d,i,o,G.result,G.attr,v.result,v.attr,k,e,g,E,m,y)},s9=async({model:t,el:A})=>{let j,e=t.get("width"),r=t.get("height"),n=t.get("mat_parquet");return n&&n.byteLength>0&&(j=await K4(t.get("network_meta"),n,t.get("row_nodes_parquet"),t.get("col_nodes_parquet"),t.get("row_linkage_parquet"),t.get("col_linkage_parquet"),t.get("row_entity"),t.get("col_entity"))),S_(t,A,j,e,r)};async function YpA({model:t,el:A}){let j=null;try{let e=t.get("component");if(!e){Uu("Component type is not defined",{data:{model:t?.id||"unknown",el:A?.id||"unknown"}});return}switch(e){case"Landscape":j=await i9({model:t,el:A});break;case"Yearbook":j=await o9({model:t,el:A});break;case"Matrix":j=await s9({model:t,el:A});break;case"Enrich":j=await n8({model:t,el:A});break;default:Uu(`Unknown component type: ${e}`,{data:{componentType:e,model:t?.id||"unknown"}});return}t.on("msg:custom",r=>{if(r.event==="finalize"&&j){try{typeof j=="function"?j():j.finalize&&j.finalize()}catch(n){Uu("Error finalizing deck",{data:{error:n.message,model:t?.id||"unknown"}})}j=null}})}catch(e){let r=Zj(e,{context:"render function",logUnexpected:!0,messages:{unexpected:"Error in render function"}});A.innerHTML=`
Error: ${r.message}
`}}var JpA=async(t,A,j="default",e=500,r=500,n=null,i=null,o=null,l={})=>{let c=await tb(A,j,l);return S_({get:h=>h==="row_entity"?JSON.stringify(c.row_entity||{entity:"gene",attr:"name"}):h==="col_entity"?JSON.stringify(c.col_entity||{entity:"cell",attr:"leiden"}):null,set:()=>{},save_changes:()=>{},on:()=>{}},t,c,e,r,n,i,o)},$bt={landscape_ist:QI,landscape_sst:WI,landscape_h_e:B1,matrix_viz:S_,matrix_from_dega_files:JpA,networkFromDegaFiles:tb,yearbook:r8,render:YpA,render_landscape_ist:e9,render_landscape_sst:r9,render_landscape_h_e:n9,render_landscape:i9,render_yearbook:o9,render_matrix_new:s9,render_enrich:n8,buildRowAxisSlice:kh,buildColAxisSlice:gh,buildCellSlice:mg,emitMatrixSliceRequest:Rl};export{$bt as default}; /*! Bundled license information: hammerjs/hammer.js: diff --git a/js/celldega.js b/js/celldega.js index 99c19e1e3..ba7c8ad9a 100644 --- a/js/celldega.js +++ b/js/celldega.js @@ -1,3 +1,9 @@ +import { + buildCellSlice, + buildColAxisSlice, + buildRowAxisSlice, + emitMatrixSliceRequest, +} from './matrix/matrix_axis_slice'; import { networkFromDegaFiles } from './read_parquet/network_from_dega_files'; import { networkFromParquet } from './read_parquet/network_from_parquet'; import { objects_from_parquet } from './read_parquet/objects_from_parquet'; @@ -388,4 +394,8 @@ export default { render_yearbook, render_matrix_new, render_enrich, + buildRowAxisSlice, + buildColAxisSlice, + buildCellSlice, + emitMatrixSliceRequest, }; diff --git a/js/deck-gl/matrix/label_layers.js b/js/deck-gl/matrix/label_layers.js index 0b4fc301f..dfacbd9e8 100644 --- a/js/deck-gl/matrix/label_layers.js +++ b/js/deck-gl/matrix/label_layers.js @@ -6,6 +6,7 @@ import { sync_selected_rows, sync_selected_cols, } from '../../global_variables/selected_genes'; +import { emitMatrixSliceRequest } from '../../matrix/matrix_axis_slice'; import { toggle_dendro_layer_visibility } from './dendro_layers'; import { get_mat_layers_list } from './matrix_layers'; @@ -215,14 +216,13 @@ const row_label_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { if (viz_state.labels.clicks.row === 1) { viz_state.click.type = 'row_label'; - const { name } = event.object; + const { name, index: rowMatrixIndex } = event.object; // Include full entity info (entity type + attribute) viz_state.click.value = { name, - // New structured entity info + index: rowMatrixIndex, entity: viz_state.row_entity.entity, attr: viz_state.row_entity.attr, - // Legacy field for backwards compatibility row_entity: viz_state.row_entity.entity, }; @@ -234,6 +234,10 @@ const row_label_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { viz_state.model.set('click_info', null); viz_state.model.set('click_info', viz_state.click); viz_state.model.save_changes(); + emitMatrixSliceRequest(viz_state.model, 'row', { + index: rowMatrixIndex, + max_entries: -1, + }); } // Sync selected row to Python model @@ -263,14 +267,12 @@ const col_label_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { if (viz_state.labels.clicks.col === 1) { viz_state.click.type = 'col_label'; - const { name } = event.object; - // Include full entity info (entity type + attribute) + const { name, index: colMatrixIndex } = event.object; viz_state.click.value = { name, - // New structured entity info + index: colMatrixIndex, entity: viz_state.col_entity.entity, attr: viz_state.col_entity.attr, - // Legacy field for backwards compatibility col_entity: viz_state.col_entity.entity, }; @@ -282,6 +284,10 @@ const col_label_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { viz_state.model.set('click_info', null); viz_state.model.set('click_info', viz_state.click); viz_state.model.save_changes(); + emitMatrixSliceRequest(viz_state.model, 'col', { + index: colMatrixIndex, + max_entries: -1, + }); } // Sync selected column to Python model diff --git a/js/deck-gl/matrix/mat_layer.js b/js/deck-gl/matrix/mat_layer.js index f3734c95f..1ec42fbcd 100644 --- a/js/deck-gl/matrix/mat_layer.js +++ b/js/deck-gl/matrix/mat_layer.js @@ -1,5 +1,7 @@ import * as d3 from 'd3'; +import { emitMatrixSliceRequest } from '../../matrix/matrix_axis_slice'; + import { CustomMatrixLayer } from './custom_matrix_layer'; const mat_layer_get_position = (d, viz_state) => { @@ -56,24 +58,18 @@ const mat_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { row: { name: row_name, index: row_index, - // New structured entity info entity: viz_state.row_entity.entity, attr: viz_state.row_entity.attr, - // Legacy field for backwards compatibility row_entity: viz_state.row_entity.entity, }, col: { name: col_name, index: col_index, - // New structured entity info entity: viz_state.col_entity.entity, attr: viz_state.col_entity.attr, - // Legacy field for backwards compatibility col_entity: viz_state.col_entity.entity, }, - // The actual matrix cell value value: mat_value, - // Full entity info for both axes row_entity_full: viz_state.row_entity, col_entity_full: viz_state.col_entity, }; @@ -93,6 +89,10 @@ const mat_layer_onclick = (event, deck_mat, layers_mat, viz_state) => { viz_state.model.set('click_info', null); viz_state.model.set('click_info', viz_state.click); viz_state.model.save_changes(); + emitMatrixSliceRequest(viz_state.model, 'cell', { + row: row_index, + col: col_index, + }); } // Close the attribute editor on matrix click diff --git a/js/matrix/matrix_axis_slice.js b/js/matrix/matrix_axis_slice.js new file mode 100644 index 000000000..253b95c3d --- /dev/null +++ b/js/matrix/matrix_axis_slice.js @@ -0,0 +1,178 @@ +/** + * Generic matrix axis slices from `viz_state.mat.net_mat`. + * + * Convention: `net_mat[row_index][col_index]` is the scalar at that row/column entity + * pair (interpretation of row vs col entities is up to the application). + */ + +const MAX_ENTRIES = 2000; +/** When `max_entries < 0` (request all), still cap per axis to avoid freezing huge matrices. */ +const UNBOUNDED_AXIS_CAP = 500_000; + +export const MATRIX_NET_CONVENTION = + 'net_mat[row][col] is the matrix entry at row index (row entity) and column index (col entity)'; + +/** + * Ask the widget model to run the front-end slice handler (second step after a click). + * @param {any} model ipywidgets Backbone model with get/set/save_changes + * @param {'row'|'col'|'cell'|'row_col'} op + * @param {Record} fields Optional `max_entries` on `row`/`col`/`row_col` + * (`< 0` = all non-zero entries, up to an internal cap; omit = {@link MAX_ENTRIES}). + * @returns {string|undefined} req_id + */ +export function emitMatrixSliceRequest(model, op, fields) { + if (!model?.set) return undefined; + const req_id = + typeof crypto !== 'undefined' && crypto.randomUUID + ? crypto.randomUUID() + : `r${Date.now()}-${Math.random().toString(16).slice(2)}`; + model.set('matrix_slice_request', {}); + model.set('matrix_slice_request', { req_id, op, ...fields }); + model.save_changes(); + return req_id; +} + +/** + * @param {object} viz_state + * @param {number} rowIndex + * @param {number} [maxEntries] Default {@link MAX_ENTRIES}. Use `< 0` for all entries (capped by {@link UNBOUNDED_AXIS_CAP}). + * @returns {object|null} + */ +export function buildRowAxisSlice(viz_state, rowIndex, maxEntries) { + const net = viz_state?.mat?.net_mat; + const rowNodes = viz_state?.row_nodes; + const colNodes = viz_state?.col_nodes; + if ( + !Array.isArray(net) || + !Array.isArray(rowNodes) || + !Array.isArray(colNodes) || + rowIndex == null || + Number.isNaN(Number(rowIndex)) + ) { + return null; + } + const r = Number(rowIndex); + if (r < 0 || r >= net.length) return null; + const row = net[r]; + if (!Array.isArray(row)) return null; + + const entries = []; + for (let c = 0; c < row.length; c++) { + const val = Number(row[c]); + if (!Number.isFinite(val) || val === 0) continue; + const cn = colNodes[c]; + if (!cn) continue; + entries.push({ + row: r, + col: c, + counterpart_name: cn.name, + value: val, + }); + } + entries.sort((a, b) => b.value - a.value); + const cap = + maxEntries == null + ? MAX_ENTRIES + : maxEntries < 0 + ? Math.min(entries.length, UNBOUNDED_AXIS_CAP) + : Math.min(entries.length, maxEntries, UNBOUNDED_AXIS_CAP); + const primaryNode = rowNodes[r]; + return { + slice_kind: 'row_axis', + matrix_convention: MATRIX_NET_CONVENTION, + primary_index: r, + primary_name: primaryNode ? primaryNode.name : null, + entries: entries.slice(0, cap), + }; +} + +/** + * @param {object} viz_state + * @param {number} colIndex + * @param {number} [maxEntries] Default {@link MAX_ENTRIES}. Use `< 0` for all entries (capped by {@link UNBOUNDED_AXIS_CAP}). + * @returns {object|null} + */ +export function buildColAxisSlice(viz_state, colIndex, maxEntries) { + const net = viz_state?.mat?.net_mat; + const rowNodes = viz_state?.row_nodes; + const colNodes = viz_state?.col_nodes; + if ( + !Array.isArray(net) || + !Array.isArray(rowNodes) || + !Array.isArray(colNodes) || + colIndex == null || + Number.isNaN(Number(colIndex)) + ) { + return null; + } + const c = Number(colIndex); + if (c < 0 || c >= colNodes.length) return null; + + const entries = []; + for (let r = 0; r < net.length; r++) { + const row = net[r]; + if (!Array.isArray(row) || c >= row.length) continue; + const val = Number(row[c]); + if (!Number.isFinite(val) || val === 0) continue; + const rn = rowNodes[r]; + if (!rn) continue; + entries.push({ + row: r, + col: c, + counterpart_name: rn.name, + value: val, + }); + } + entries.sort((a, b) => b.value - a.value); + const cap = + maxEntries == null + ? MAX_ENTRIES + : maxEntries < 0 + ? Math.min(entries.length, UNBOUNDED_AXIS_CAP) + : Math.min(entries.length, maxEntries, UNBOUNDED_AXIS_CAP); + const primaryNode = colNodes[c]; + return { + slice_kind: 'col_axis', + matrix_convention: MATRIX_NET_CONVENTION, + primary_index: c, + primary_name: primaryNode ? primaryNode.name : null, + entries: entries.slice(0, cap), + }; +} + +/** + * @param {number} rowIndex + * @param {number} colIndex + * @param {unknown} value + */ +export function buildCellSlice(rowIndex, colIndex, value) { + return { + slice_kind: 'cell', + matrix_convention: MATRIX_NET_CONVENTION, + row_index: rowIndex, + col_index: colIndex, + value, + }; +} + +/** + * One response containing a normal row-axis slice and a normal col-axis slice + * (e.g. same entity on both axes in a square flow matrix). + * + * @param {object} viz_state + * @param {number} rowIndex + * @param {number} colIndex + * @param {number} [maxEntries] Passed through to both axis builders. + * @returns {object|null} + */ +export function buildRowColPairSlice(viz_state, rowIndex, colIndex, maxEntries) { + const rowSlice = buildRowAxisSlice(viz_state, rowIndex, maxEntries); + const colSlice = buildColAxisSlice(viz_state, colIndex, maxEntries); + if (!rowSlice && !colSlice) return null; + return { + slice_kind: 'row_col', + matrix_convention: MATRIX_NET_CONVENTION, + row_axis: rowSlice, + col_axis: colSlice, + }; +} diff --git a/js/viz/matrix_viz.js b/js/viz/matrix_viz.js index e1efc9217..f28a564a3 100644 --- a/js/viz/matrix_viz.js +++ b/js/viz/matrix_viz.js @@ -64,6 +64,12 @@ import { update_label_display_names, } from '../matrix/label_data'; import { set_mat_data } from '../matrix/mat_data'; +import { + buildCellSlice, + buildColAxisSlice, + buildRowAxisSlice, + buildRowColPairSlice, +} from '../matrix/matrix_axis_slice'; import { set_mat_constants } from '../matrix/set_constants'; import { initialize_attribute_editor } from '../ui/attribute_editor'; import { initialize_attribute_labels } from '../ui/attribute_labels'; @@ -324,6 +330,58 @@ export const matrix_viz = async ( viz_state.model.on('change:top_n_genes', () => { viz_state.top_n_genes = viz_state.model.get('top_n_genes') || 50; }); + + const flushMatrixSliceRequest = () => { + const req = viz_state.model.get('matrix_slice_request'); + if (!req || typeof req !== 'object') return; + const reqId = req.req_id; + if (!reqId || !req.op) return; + + const result = { req_id: reqId }; + let maxEntries; + if (req.max_entries === undefined || req.max_entries === null) { + maxEntries = undefined; + } else { + const n = Number(req.max_entries); + maxEntries = Number.isFinite(n) ? n : undefined; + } + try { + if (req.op === 'row') { + const slice = buildRowAxisSlice(viz_state, req.index, maxEntries); + if (slice) Object.assign(result, slice); + else result.error = 'no_data'; + } else if (req.op === 'col') { + const slice = buildColAxisSlice(viz_state, req.index, maxEntries); + if (slice) Object.assign(result, slice); + else result.error = 'no_data'; + } else if (req.op === 'cell') { + const r = req.row; + const c = req.col; + const net = viz_state.mat?.net_mat; + let val = null; + if (net?.[r] && c >= 0 && c < net[r].length) { + val = net[r][c]; + } + Object.assign(result, buildCellSlice(r, c, val)); + } else if (req.op === 'row_col') { + const r = req.row_index; + const c = req.col_index; + const slice = buildRowColPairSlice(viz_state, r, c, maxEntries); + if (slice) Object.assign(result, slice); + else result.error = 'no_data'; + } else { + result.error = 'unknown_op'; + } + } catch (e) { + result.error = String(e?.message || e); + } + + viz_state.model.set('matrix_slice_result', {}); + viz_state.model.set('matrix_slice_result', result); + viz_state.model.save_changes(); + }; + + viz_state.model.on('change:matrix_slice_request', flushMatrixSliceRequest); } const matrix = { diff --git a/notebooks/bike_flow_map.widget.js b/notebooks/bike_flow_map.widget.js index c7ed42827..320913419 100644 --- a/notebooks/bike_flow_map.widget.js +++ b/notebooks/bike_flow_map.widget.js @@ -47960,12 +47960,43 @@ var createStore = () => ({ edges: Observable([]), deck_check: Observable({ inputs: true, computed: true, layers: true }), deck_ready: Observable(false), - palette_rgb: Observable([]) + palette_rgb: Observable([]), + matrix_axis_slice: Observable({}) }); var log3 = (store, ...args) => { if (store.debug.get()) console.log("[bike-map]", ...args); }; +var MAP_STATION_SLICE_TOP_K = 25; +function pushRowColMatrixSliceRequest(model, rowIndex, colIndex) { + if (!model?.set) + return; + const req_id = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `r${Date.now()}-${Math.random().toString(16).slice(2)}`; + model.set("matrix_slice_request_out", {}); + model.set("matrix_slice_request_out", { + req_id, + op: "row_col", + row_index: Number(rowIndex), + col_index: Number(colIndex), + max_entries: MAP_STATION_SLICE_TOP_K + }); + model.save_changes(); +} +function findAxisIndex(names, raw) { + const want = String(raw || "").trim(); + if (!want || !Array.isArray(names)) + return -1; + let i = names.findIndex((x) => String(x).trim() === want); + if (i >= 0) + return i; + if (want.includes("|")) { + const rhs = want.split("|", 2)[1].trim(); + i = names.findIndex((x) => String(x).trim() === rhs); + if (i >= 0) + return i; + } + return -1; +} var sameList = (a, b) => { if (!Array.isArray(a) || !Array.isArray(b)) return false; @@ -48164,22 +48195,23 @@ function render({ model, el }) { let deck = null; let raf = 0; let renderVersion = 0; - let lastSig = ""; let lastActionKey = null; let lastActionSeq = -1; let linkInteractionSeq = 0; - let linkSnap = { ci: "", rows: "", cols: "" }; + let linkSnap = { ci: "", rows: "", cols: "", sl: "" }; const getLinkedWeights = () => { const focus = store.focus.get(); - const idx = store.edge_index.get() || {}; const out = /* @__PURE__ */ new Map(); const inn = /* @__PURE__ */ new Map(); - if (!focus || !idx[focus]) + if (!focus) return { out, inn }; - for (const e of idx[focus].out || []) - out.set(e.name, Number(e.w) || 0); - for (const e of idx[focus].in || []) - inn.set(e.name, Number(e.w) || 0); + for (const e of store.edges.get() || []) { + if (e.direction === "out" && e.source_name === focus) { + out.set(e.target_name, Number(e.weight) || 0); + } else if (e.direction === "in" && e.target_name === focus) { + inn.set(e.source_name, Number(e.weight) || 0); + } + } return { out, inn }; }; const computeStateFromInputs = () => { @@ -48188,17 +48220,6 @@ function render({ model, el }) { const v = info.value || {}; const idx = store.edge_index.get() || {}; const seq = linkInteractionSeq; - const sig = JSON.stringify({ - t, - v, - rows: store.selected_rows.get() || [], - cols: store.selected_cols.get() || [] - }); - if (sig === lastSig) { - log3(store, "compute skip (same signature)", t); - return; - } - lastSig = sig; log3(store, "compute start", t, "rows", (store.selected_rows.get() || []).length, "cols", (store.selected_cols.get() || []).length); const setState = (focus, highlights, edges) => setDerivedState(store, { focus, highlights, edges }); const stationFrom = (raw) => { @@ -48212,6 +48233,14 @@ function render({ model, el }) { } return txt; }; + const coordMap = {}; + for (const s of store.stations.get() || []) { + const k = stationFrom(String(s.name || "")); + if (k && s.lng != null && s.lat != null) { + coordMap[k] = [Number(s.lng), Number(s.lat)]; + } + } + const acoord = (n) => n && idx[n]?.coord || (n ? coordMap[n] : void 0); if (t === "row_label" || t === "col_label") { const name2 = stationFrom(v.name); const actionKey = `${t}:${name2}`; @@ -48222,6 +48251,53 @@ function render({ model, el }) { log3(store, "label toggle off", t, name2); return; } + const sl = store.matrix_axis_slice.get() || {}; + const entries = sl.entries; + const rowAxis = t === "row_label" && sl.slice_kind === "row_axis"; + const colAxis = t === "col_label" && sl.slice_kind === "col_axis"; + if (Array.isArray(entries) && (rowAxis || colAxis)) { + const primary = stationFrom(sl.primary_name); + if (primary === name2 && entries.length) { + const edges2 = []; + for (const e of entries) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(other); + const ct = acoord(name2); + if (!other || !cs || !ct) + continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + if (rowAxis) { + edges2.push({ + source_name: other, + target_name: name2, + direction: "in", + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct + }); + } else { + edges2.push({ + source_name: name2, + target_name: other, + direction: "out", + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: ct, + target: cs + }); + } + } + setState(name2, name2 ? [name2] : [], edges2); + lastActionKey = actionKey; + lastActionSeq = seq; + log3(store, "label+axis_slice", t, name2, sl.slice_kind, "edges", edges2.length); + return; + } + } const bucket = idx[name2] || { out: [], in: [] }; const edges = [ ...(bucket.out || []).map((e) => ({ @@ -48265,8 +48341,8 @@ function render({ model, el }) { return; } const p = Number(v.value || 0); - const src = idx[col]?.coord; - const dst = idx[row]?.coord; + const src = acoord(col); + const dst = acoord(row); const outEdge = (idx[col]?.out || []).find((e) => e.name === row); const g = outEdge != null ? Number(outEdge.geom_share) : NaN; const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); @@ -48288,9 +48364,10 @@ function render({ model, el }) { return; } if (t === "row_dendro" || t === "col_dendro") { - const fromClick = (v.selected_names || []).map(stationFrom).filter((n) => idx[n]); - const rows = (store.selected_rows.get() || []).map(stationFrom).filter((n) => idx[n]); - const cols = (store.selected_cols.get() || []).map(stationFrom).filter((n) => idx[n]); + const hasStation = (n) => Boolean(n && (idx[n] || coordMap[n])); + const fromClick = (v.selected_names || []).map(stationFrom).filter(hasStation); + const rows = (store.selected_rows.get() || []).map(stationFrom).filter(hasStation); + const cols = (store.selected_cols.get() || []).map(stationFrom).filter(hasStation); if (v.is_unselecting || Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0) { setState("", [], []); lastActionKey = null; @@ -48311,7 +48388,7 @@ function render({ model, el }) { const attrIndex = v.attr_index; const catVal = v.value; const rawNames = Array.isArray(v.node_names) ? v.node_names : []; - const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n]))]; + const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n] || coordMap[n]))]; const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; if (actionKey === lastActionKey && seq !== lastActionSeq) { setState("", [], []); @@ -48326,6 +48403,64 @@ function render({ model, el }) { log3(store, "cat", axis, "value", catVal, "stations", names.length); return; } + const slPair = store.matrix_axis_slice.get() || {}; + if (slPair.slice_kind === "row_col") { + const primaryRaw = slPair.row_axis?.primary_name ?? slPair.col_axis?.primary_name ?? null; + if (!primaryRaw) + return; + const focusName = stationFrom(primaryRaw); + const focusNow = store.focus.get() || ""; + if (focusNow && focusName !== focusNow) { + log3(store, "row_col slice skip (stale vs map focus)", focusName, focusNow); + return; + } + const incoming = slPair.row_axis?.entries || []; + const outgoing = slPair.col_axis?.entries || []; + const edges = []; + for (const e of incoming) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(other); + const ct = acoord(focusName); + if (!other || !cs || !ct) + continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + edges.push({ + source_name: other, + target_name: focusName, + direction: "in", + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct + }); + } + for (const e of outgoing) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(focusName); + const ct = acoord(other); + if (!other || !cs || !ct) + continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + edges.push({ + source_name: focusName, + target_name: other, + direction: "out", + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct + }); + } + setState(focusName, focusName ? [focusName] : [], edges); + lastActionKey = `row_col:${focusName}`; + lastActionSeq = seq; + log3(store, "row_col slice", focusName, "edges", edges.length); + return; + } }; const buildLayers = () => { const stations = store.stations.get() || []; @@ -48418,44 +48553,33 @@ function render({ model, el }) { onClick: (info) => { if (!info.object) return; - const n = info.object.name; + const n = String(info.object.name || "").trim(); if (store.focus.get() === n) { setDerivedState(store, { focus: "", highlights: [], edges: [] }); lastActionKey = null; + model.set("click_info", {}); + model.set("matrix_axis_slice", {}); + model.save_changes(); scheduleRender(); log3(store, "map toggle off", n); return; } - const idx = store.edge_index.get() || {}; - const bucket = idx[n] || { out: [], in: [] }; - const e = [ - ...(bucket.out || []).map((x) => ({ - source_name: n, - target_name: x.name, - direction: "out", - opacity: x.opacity, - weight: x.w, - geom_share: x.geom_share, - trips: x.trips, - source: x.source, - target: x.target - })), - ...(bucket.in || []).map((x) => ({ - source_name: x.name, - target_name: n, - direction: "in", - opacity: x.opacity, - weight: x.w, - geom_share: x.geom_share, - trips: x.trips, - source: x.source, - target: x.target - })) - ]; - setDerivedState(store, { focus: n, highlights: [n], edges: e }); + const rowNames = model.get("cg_row_names") || []; + const colNames = model.get("cg_col_names") || []; + const rowIx = findAxisIndex(rowNames, n); + const colIx = findAxisIndex(colNames, n); + if (rowIx < 0 || colIx < 0) { + log3(store, "map click: missing matrix axis index", n, "row", rowIx, "col", colIx); + return; + } + model.set("click_info", {}); + model.set("matrix_axis_slice", {}); + model.save_changes(); + pushRowColMatrixSliceRequest(model, rowIx, colIx); + setDerivedState(store, { focus: n, highlights: [n], edges: [] }); lastActionKey = null; scheduleRender(); - log3(store, "map click", n, "edges", e.length); + log3(store, "map click -> row_col request", n, rowIx, colIx); } }); const lineWidthFor = (d) => { @@ -48586,15 +48710,16 @@ function render({ model, el }) { store.selected_cols, store.width, store.height, - store.palette_rgb + store.palette_rgb, + store.matrix_axis_slice ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); const syncFromModel = () => { const ci = JSON.stringify(model.get("click_info") || {}); const rows = JSON.stringify(model.get("selected_rows") || []); const cols = JSON.stringify(model.get("selected_cols") || []); - if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols) { - linkSnap = { ci, rows, cols }; - linkInteractionSeq += 1; + const sl = JSON.stringify(model.get("matrix_axis_slice") || {}); + if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols || sl !== linkSnap.sl) { + linkSnap = { ci, rows, cols, sl }; } log3(store, "syncFromModel start"); store.stations.set(model.get("stations") || []); @@ -48603,6 +48728,7 @@ function render({ model, el }) { store.click_info.set(model.get("click_info") || {}); store.selected_rows.set(model.get("selected_rows") || []); store.selected_cols.set(model.get("selected_cols") || []); + store.matrix_axis_slice.set(model.get("matrix_axis_slice") || {}); store.width.set(model.get("width") || 560); store.height.set(model.get("height") || 800); store.debug.set(Boolean(model.get("debug"))); @@ -48614,17 +48740,23 @@ function render({ model, el }) { }); scheduleRender(); }; + model.on("change:click_info", () => { + linkInteractionSeq += 1; + syncFromModel(); + }); [ "stations", "edge_index", - "click_info", "selected_rows", "selected_cols", "width", "height", "debug", - "palette_rgb" + "palette_rgb", + "matrix_axis_slice" ].forEach((name2) => model.on(`change:${name2}`, syncFromModel)); + model.on("change:cg_row_names", () => scheduleRender()); + model.on("change:cg_col_names", () => scheduleRender()); syncFromModel(); return () => { if (raf) diff --git a/notebooks/bike_flow_map_widget.mjs b/notebooks/bike_flow_map_widget.mjs index d38f72a73..bdcd6f601 100644 --- a/notebooks/bike_flow_map_widget.mjs +++ b/notebooks/bike_flow_map_widget.mjs @@ -33,12 +33,49 @@ const createStore = () => ({ deck_check: Observable({ inputs: true, computed: true, layers: true }), deck_ready: Observable(false), palette_rgb: Observable([]), + matrix_axis_slice: Observable({}), }); const log = (store, ...args) => { if (store.debug.get()) console.log('[bike-map]', ...args); }; +/** Map station click: keep top-K neighbors per direction (row + col slices) for readability. */ +const MAP_STATION_SLICE_TOP_K = 25; + +/** + * Ask the Clustergram for a normal row-axis + col-axis slice (same station on both axes). + */ +function pushRowColMatrixSliceRequest(model, rowIndex, colIndex) { + if (!model?.set) return; + const req_id = + typeof crypto !== 'undefined' && crypto.randomUUID + ? crypto.randomUUID() + : `r${Date.now()}-${Math.random().toString(16).slice(2)}`; + model.set('matrix_slice_request_out', {}); + model.set('matrix_slice_request_out', { + req_id, + op: 'row_col', + row_index: Number(rowIndex), + col_index: Number(colIndex), + max_entries: MAP_STATION_SLICE_TOP_K, + }); + model.save_changes(); +} + +function findAxisIndex(names, raw) { + const want = String(raw || '').trim(); + if (!want || !Array.isArray(names)) return -1; + let i = names.findIndex((x) => String(x).trim() === want); + if (i >= 0) return i; + if (want.includes('|')) { + const rhs = want.split('|', 2)[1].trim(); + i = names.findIndex((x) => String(x).trim() === rhs); + if (i >= 0) return i; + } + return -1; +} + const sameList = (a, b) => { if (!Array.isArray(a) || !Array.isArray(b)) return false; if (a.length !== b.length) return false; @@ -208,21 +245,28 @@ function render({ model, el }) { let deck = null; let raf = 0; let renderVersion = 0; - let lastSig = ""; let lastActionKey = null; let lastActionSeq = -1; - /** Increments when linked Clustergram traits change (jslink / static HTML); drives label+mat toggle. */ + /** + * Increments on each `click_info` comm update from the Clustergram (including the null-then-set pair). + * Used for label/mat/cat toggle detection. Intentionally not tied to `matrix_slice_result` alone so + * slice-only updates do not spuriously toggle the map off. + */ let linkInteractionSeq = 0; - let linkSnap = { ci: '', rows: '', cols: '' }; + let linkSnap = { ci: '', rows: '', cols: '', sl: '' }; const getLinkedWeights = () => { const focus = store.focus.get(); - const idx = store.edge_index.get() || {}; const out = new Map(); const inn = new Map(); - if (!focus || !idx[focus]) return { out, inn }; - for (const e of idx[focus].out || []) out.set(e.name, Number(e.w) || 0); - for (const e of idx[focus].in || []) inn.set(e.name, Number(e.w) || 0); + if (!focus) return { out, inn }; + for (const e of store.edges.get() || []) { + if (e.direction === 'out' && e.source_name === focus) { + out.set(e.target_name, Number(e.weight) || 0); + } else if (e.direction === 'in' && e.target_name === focus) { + inn.set(e.source_name, Number(e.weight) || 0); + } + } return { out, inn }; }; @@ -232,17 +276,6 @@ function render({ model, el }) { const v = info.value || {}; const idx = store.edge_index.get() || {}; const seq = linkInteractionSeq; - const sig = JSON.stringify({ - t, - v, - rows: store.selected_rows.get() || [], - cols: store.selected_cols.get() || [], - }); - if (sig === lastSig) { - log(store, 'compute skip (same signature)', t); - return; - } - lastSig = sig; log(store, 'compute start', t, 'rows', (store.selected_rows.get()||[]).length, 'cols', (store.selected_cols.get()||[]).length); const setState = (focus, highlights, edges) => @@ -258,6 +291,15 @@ function render({ model, el }) { return txt; }; + const coordMap = {}; + for (const s of store.stations.get() || []) { + const k = stationFrom(String(s.name || '')); + if (k && s.lng != null && s.lat != null) { + coordMap[k] = [Number(s.lng), Number(s.lat)]; + } + } + const acoord = (n) => (n && idx[n]?.coord) || (n ? coordMap[n] : undefined); + if (t === 'row_label' || t === 'col_label') { const name = stationFrom(v.name); const actionKey = `${t}:${name}`; @@ -268,6 +310,52 @@ function render({ model, el }) { log(store, 'label toggle off', t, name); return; } + const sl = store.matrix_axis_slice.get() || {}; + const entries = sl.entries; + const rowAxis = t === 'row_label' && sl.slice_kind === 'row_axis'; + const colAxis = t === 'col_label' && sl.slice_kind === 'col_axis'; + if (Array.isArray(entries) && (rowAxis || colAxis)) { + const primary = stationFrom(sl.primary_name); + if (primary === name && entries.length) { + const edges = []; + for (const e of entries) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(other); + const ct = acoord(name); + if (!other || !cs || !ct) continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + if (rowAxis) { + edges.push({ + source_name: other, + target_name: name, + direction: 'in', + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct, + }); + } else { + edges.push({ + source_name: name, + target_name: other, + direction: 'out', + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: ct, + target: cs, + }); + } + } + setState(name, name ? [name] : [], edges); + lastActionKey = actionKey; + lastActionSeq = seq; + log(store, 'label+axis_slice', t, name, sl.slice_kind, 'edges', edges.length); + return; + } + } const bucket = idx[name] || { out: [], in: [] }; const edges = [ ...(bucket.out || []).map((e) => ({ @@ -312,8 +400,8 @@ function render({ model, el }) { return; } const p = Number(v.value || 0); - const src = idx[col]?.coord; - const dst = idx[row]?.coord; + const src = acoord(col); + const dst = acoord(row); const outEdge = (idx[col]?.out || []).find((e) => e.name === row); const g = outEdge != null ? Number(outEdge.geom_share) : NaN; const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); @@ -338,9 +426,10 @@ function render({ model, el }) { } if (t === 'row_dendro' || t === 'col_dendro') { - const fromClick = (v.selected_names || []).map(stationFrom).filter((n) => idx[n]); - const rows = (store.selected_rows.get() || []).map(stationFrom).filter((n) => idx[n]); - const cols = (store.selected_cols.get() || []).map(stationFrom).filter((n) => idx[n]); + const hasStation = (n) => Boolean(n && (idx[n] || coordMap[n])); + const fromClick = (v.selected_names || []).map(stationFrom).filter(hasStation); + const rows = (store.selected_rows.get() || []).map(stationFrom).filter(hasStation); + const cols = (store.selected_cols.get() || []).map(stationFrom).filter(hasStation); if (v.is_unselecting || (Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0)) { setState('', [], []); @@ -371,7 +460,7 @@ function render({ model, el }) { const attrIndex = v.attr_index; const catVal = v.value; const rawNames = Array.isArray(v.node_names) ? v.node_names : []; - const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n]))]; + const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n] || coordMap[n]))]; const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; if (actionKey === lastActionKey && seq !== lastActionSeq) { setState('', [], []); @@ -386,6 +475,63 @@ function render({ model, el }) { log(store, 'cat', axis, 'value', catVal, 'stations', names.length); return; } + + const slPair = store.matrix_axis_slice.get() || {}; + if (slPair.slice_kind === 'row_col') { + const primaryRaw = + slPair.row_axis?.primary_name ?? slPair.col_axis?.primary_name ?? null; + if (!primaryRaw) return; + const focusName = stationFrom(primaryRaw); + const focusNow = store.focus.get() || ''; + if (focusNow && focusName !== focusNow) { + log(store, 'row_col slice skip (stale vs map focus)', focusName, focusNow); + return; + } + const incoming = slPair.row_axis?.entries || []; + const outgoing = slPair.col_axis?.entries || []; + const edges = []; + for (const e of incoming) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(other); + const ct = acoord(focusName); + if (!other || !cs || !ct) continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + edges.push({ + source_name: other, + target_name: focusName, + direction: 'in', + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct, + }); + } + for (const e of outgoing) { + const other = stationFrom(e.counterpart_name); + const cs = acoord(focusName); + const ct = acoord(other); + if (!other || !cs || !ct) continue; + const w = Number(e.value) || 0; + const geom = Math.sqrt(Math.max(0, w)); + edges.push({ + source_name: focusName, + target_name: other, + direction: 'out', + opacity: Math.max(0.15, Math.min(0.98, w * 3)), + weight: w, + geom_share: geom, + source: cs, + target: ct, + }); + } + setState(focusName, focusName ? [focusName] : [], edges); + lastActionKey = `row_col:${focusName}`; + lastActionSeq = seq; + log(store, 'row_col slice', focusName, 'edges', edges.length); + return; + } }; const buildLayers = () => { @@ -473,7 +619,7 @@ function render({ model, el }) { } return TRAFFIC_UNCONNECTED_RGBA; } - // Dendrogram / matrix highlights (no focus): keep dendrogram cluster colors + // Dendrogram / matrix highlights (no focus): cluster colors from palette_rgb if (highlights.size > 0) { const c = clusterFillColor(d.cluster_id, palRgb); if (highlights.has(n)) return [c[0], c[1], c[2], 242]; @@ -487,44 +633,33 @@ function render({ model, el }) { }, onClick: (info) => { if (!info.object) return; - const n = info.object.name; + const n = String(info.object.name || '').trim(); if (store.focus.get() === n) { setDerivedState(store, { focus: '', highlights: [], edges: [] }); lastActionKey = null; + model.set('click_info', {}); + model.set('matrix_axis_slice', {}); + model.save_changes(); scheduleRender(); log(store, 'map toggle off', n); return; } - const idx = store.edge_index.get() || {}; - const bucket = idx[n] || { out: [], in: [] }; - const e = [ - ...(bucket.out || []).map((x) => ({ - source_name: n, - target_name: x.name, - direction: 'out', - opacity: x.opacity, - weight: x.w, - geom_share: x.geom_share, - trips: x.trips, - source: x.source, - target: x.target, - })), - ...(bucket.in || []).map((x) => ({ - source_name: x.name, - target_name: n, - direction: 'in', - opacity: x.opacity, - weight: x.w, - geom_share: x.geom_share, - trips: x.trips, - source: x.source, - target: x.target, - })), - ]; - setDerivedState(store, { focus: n, highlights: [n], edges: e }); + const rowNames = model.get('cg_row_names') || []; + const colNames = model.get('cg_col_names') || []; + const rowIx = findAxisIndex(rowNames, n); + const colIx = findAxisIndex(colNames, n); + if (rowIx < 0 || colIx < 0) { + log(store, 'map click: missing matrix axis index', n, 'row', rowIx, 'col', colIx); + return; + } + model.set('click_info', {}); + model.set('matrix_axis_slice', {}); + model.save_changes(); + pushRowColMatrixSliceRequest(model, rowIx, colIx); + setDerivedState(store, { focus: n, highlights: [n], edges: [] }); lastActionKey = null; scheduleRender(); - log(store, 'map click', n, 'edges', e.length); + log(store, 'map click -> row_col request', n, rowIx, colIx); }, }); @@ -674,15 +809,16 @@ function render({ model, el }) { store.width, store.height, store.palette_rgb, + store.matrix_axis_slice, ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); const syncFromModel = () => { const ci = JSON.stringify(model.get('click_info') || {}); const rows = JSON.stringify(model.get('selected_rows') || []); const cols = JSON.stringify(model.get('selected_cols') || []); - if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols) { - linkSnap = { ci, rows, cols }; - linkInteractionSeq += 1; + const sl = JSON.stringify(model.get('matrix_axis_slice') || {}); + if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols || sl !== linkSnap.sl) { + linkSnap = { ci, rows, cols, sl }; } log(store, 'syncFromModel start'); store.stations.set(model.get('stations') || []); @@ -691,6 +827,7 @@ function render({ model, el }) { store.click_info.set(model.get('click_info') || {}); store.selected_rows.set(model.get('selected_rows') || []); store.selected_cols.set(model.get('selected_cols') || []); + store.matrix_axis_slice.set(model.get('matrix_axis_slice') || {}); store.width.set(model.get('width') || 560); store.height.set(model.get('height') || 800); store.debug.set(Boolean(model.get('debug'))); @@ -703,18 +840,26 @@ function render({ model, el }) { scheduleRender(); }; + model.on('change:click_info', () => { + linkInteractionSeq += 1; + syncFromModel(); + }); + [ 'stations', 'edge_index', - 'click_info', 'selected_rows', 'selected_cols', 'width', 'height', 'debug', 'palette_rgb', + 'matrix_axis_slice', ].forEach((name) => model.on(`change:${name}`, syncFromModel)); + model.on('change:cg_row_names', () => scheduleRender()); + model.on('change:cg_col_names', () => scheduleRender()); + syncFromModel(); return () => { diff --git a/src/celldega/clust/matrix.py b/src/celldega/clust/matrix.py index e3fdc0e33..c9933ba6d 100644 --- a/src/celldega/clust/matrix.py +++ b/src/celldega/clust/matrix.py @@ -589,7 +589,12 @@ def make_viz(self) -> None: if self.data is None: raise ValueError(ERRORS["no_data"]) - # Use cached dat structure (triggers lazy loading) + # Rebuild node_info from current row_attr/col_attr and metadata. Without this, + # cached dat can stay stale after mutating attr lists (e.g. appending a column + # name after add_category), so exported row_nodes/col_nodes miss cat-* keys. + self._dat_cache = None + self._dirty_flags[CacheLevel.DATA.value] = True + _ = self.dat # Update rankings diff --git a/src/celldega/viz/widget.py b/src/celldega/viz/widget.py index ca5a627f9..b0a1341e6 100644 --- a/src/celldega/viz/widget.py +++ b/src/celldega/viz/widget.py @@ -4,6 +4,8 @@ from contextlib import suppress from copy import deepcopy import json +import time +import uuid from pathlib import Path import urllib.error import warnings @@ -16,6 +18,7 @@ import scanpy as sc from shapely.affinity import affine_transform import traitlets +from typing import Literal _clustergram_registry = {} # maps names to widget instances @@ -738,6 +741,24 @@ class Clustergram(anywidget.AnyWidget): manual_cat_config, etc. - Manual categories are treated as a simple JSON string. - All the old DataFrame-based manual_cat plumbing is removed. + + Matrix slices (browser is source of truth for ``net_mat``) + On row/column label and matrix-cell clicks, the front-end first updates + ``click_info`` (interaction only), then emits :attr:`matrix_slice_request` so + the handler fills :attr:`matrix_slice_result` with axis or cell data + (``slice_kind``, ``entries``, ``matrix_convention``, etc.). Link another + widget's trait with ``jslink((cgm, "matrix_slice_result"), ...)`` to consume + slices without a Python round-trip. + + Use :meth:`request_matrix_slice` from Python when you need an explicit pull + (requires a **live kernel**). + + **jslink:** Only traits sync between models. For linked custom widgets, mirror + ``matrix_slice_result``; Python does not run in standalone exported HTML. + + Python access to the same matrix + If constructed with ``matrix=``, use :meth:`matrix_dataframe` for the underlying + ``pandas.DataFrame``. """ _esm = Path(__file__).parent / "../static" / "celldega.js" @@ -754,6 +775,15 @@ class Clustergram(anywidget.AnyWidget): click_info = traitlets.Dict({}).tag(sync=True) + #: Set by Python (or another front-end) to request ``{req_id, op, ...}``: + #: ``row``/``col`` use ``index``; ``cell`` uses ``row``/``col``; ``row_col`` + #: uses ``row_index``/``col_index`` and optional ``max_entries``. The Matrix + #: front-end writes the slice into :attr:`matrix_slice_result`. + matrix_slice_request = traitlets.Dict(default_value={}).tag(sync=True) + + #: Populated by the Matrix front-end in response to :attr:`matrix_slice_request`. + matrix_slice_result = traitlets.Dict(default_value={}).tag(sync=True) + # Generic row/col selection traitlets selected_rows = traitlets.List(default_value=[]).tag(sync=True) selected_cols = traitlets.List(default_value=[]).tag(sync=True) @@ -989,6 +1019,85 @@ def _update_manual_cat_frames(self, payload: dict) -> None: setattr(self, f"{axis}_manual_df", manual_df) setattr(self, f"{axis}_manual_colors_df", colors_df) + def request_matrix_slice( + self, + op: Literal["row", "col", "cell", "row_col"], + *, + index: int | None = None, + row: int | None = None, + col: int | None = None, + row_index: int | None = None, + col_index: int | None = None, + max_entries: int | None = None, + timeout: float = 5.0, + poll_interval: float = 0.02, + ) -> dict | None: + """ + Ask the browser Matrix to return a slice from ``net_mat`` (blocking). + + Requires a running Jupyter kernel and an active widget comm. Not available in + standalone exported HTML without a kernel. + + Parameters + ---------- + op + ``row`` or ``col``: pass ``index`` (matrix axis index). ``cell``: pass + ``row`` and ``col`` matrix indices. ``row_col``: pass ``row_index`` and + ``col_index`` to get both axis slices in one result; optional + ``max_entries`` (negative means all, subject to a browser-side cap). + timeout + Seconds to wait for :attr:`matrix_slice_result` to match ``req_id``. + + Returns + ------- + dict | None + The front-end payload (includes ``req_id``), or ``None`` on timeout. + """ + if op not in ("row", "col", "cell", "row_col"): + raise ValueError("op must be 'row', 'col', 'cell', or 'row_col'") + + req_id = str(uuid.uuid4()) + payload: dict[str, Any] = {"req_id": req_id, "op": op} + if op in ("row", "col"): + if index is None: + raise ValueError("index is required when op is 'row' or 'col'") + payload["index"] = int(index) + elif op == "cell": + if row is None or col is None: + raise ValueError("row and col are required when op is 'cell'") + payload["row"] = int(row) + payload["col"] = int(col) + else: + if row_index is None or col_index is None: + raise ValueError( + "row_index and col_index are required when op is 'row_col'" + ) + payload["row_index"] = int(row_index) + payload["col_index"] = int(col_index) + if max_entries is not None: + payload["max_entries"] = int(max_entries) + + self.matrix_slice_result = {} + self.matrix_slice_request = {} + self.matrix_slice_request = payload + + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + res = dict(self.matrix_slice_result or {}) + if res.get("req_id") == req_id: + return res + time.sleep(poll_interval) + + return None + + def matrix_dataframe(self) -> pd.DataFrame | None: + """Return a copy of the Matrix ``data`` when this widget was created with ``matrix=``.""" + m = getattr(self, "_matrix", None) + if m is None: + return None + data = getattr(m, "data", None) + return data.copy() if data is not None else None + def close(self): # pragma: no cover - cleanup depends on JS """Close the widget and notify the frontend to release resources.""" with suppress(Exception): From 70bdd44fb036de5b2cc56f8e4afedb4a981ae3a8 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Fri, 10 Apr 2026 11:02:29 -0400 Subject: [PATCH 3/7] working on static HTML support --- notebooks/bike_flow_map.widget.js | 51 ++++++++++++++++++++++-------- notebooks/bike_flow_map_widget.mjs | 2 +- notebooks/shims/hammerjs.mjs | 19 +++++++++++ package.json | 3 +- 4 files changed, 59 insertions(+), 16 deletions(-) create mode 100644 notebooks/shims/hammerjs.mjs diff --git a/notebooks/bike_flow_map.widget.js b/notebooks/bike_flow_map.widget.js index 320913419..8721f5302 100644 --- a/notebooks/bike_flow_map.widget.js +++ b/notebooks/bike_flow_map.widget.js @@ -15723,13 +15723,13 @@ function cross3(out, u, v, w) { const E = v[1] * w[3] - v[3] * w[1]; const F = v[2] * w[3] - v[3] * w[2]; const G = u[0]; - const H = u[1]; + const H2 = u[1]; const I = u[2]; const J = u[3]; - out[0] = H * F - I * E + J * D; + out[0] = H2 * F - I * E + J * D; out[1] = -(G * F) + I * C - J * B; - out[2] = G * E - H * C + J * A; - out[3] = -(G * D) + H * B - I * A; + out[2] = G * E - H2 * C + J * A; + out[3] = -(G * D) + H2 * B - I * A; return out; } function lerp4(out, a, b, t) { @@ -19557,13 +19557,13 @@ function cross6(out, u, v, w) { const E = v[1] * w[3] - v[3] * w[1]; const F = v[2] * w[3] - v[3] * w[2]; const G = u[0]; - const H = u[1]; + const H2 = u[1]; const I = u[2]; const J = u[3]; - out[0] = H * F - I * E + J * D; + out[0] = H2 * F - I * E + J * D; out[1] = -(G * F) + I * C - J * B; - out[2] = G * E - H * C + J * A; - out[3] = -(G * D) + H * B - I * A; + out[2] = G * E - H2 * C + J * A; + out[3] = -(G * D) + H2 * B - I * A; return out; } function lerp7(out, a, b, t) { @@ -32127,8 +32127,31 @@ function compareConstantArrayValues2(v1, v2) { return true; } -// node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js -var hammerjs = __toESM(require_hammer()); +// notebooks/shims/hammerjs.mjs +var hammerjs_exports = {}; +__export(hammerjs_exports, { + Manager: () => Manager, + MouseInput: () => MouseInput, + Pan: () => Pan, + Pinch: () => Pinch, + PointerEventInput: () => PointerEventInput, + Press: () => Press, + Rotate: () => Rotate, + Swipe: () => Swipe, + Tap: () => Tap, + default: () => hammerjs_default +}); +var import_hammer = __toESM(require_hammer(), 1); +var PointerEventInput = import_hammer.default.PointerEventInput; +var MouseInput = import_hammer.default.MouseInput; +var Manager = import_hammer.default.Manager; +var Pan = import_hammer.default.Pan; +var Rotate = import_hammer.default.Rotate; +var Pinch = import_hammer.default.Pinch; +var Swipe = import_hammer.default.Swipe; +var Press = import_hammer.default.Press; +var Tap = import_hammer.default.Tap; +var hammerjs_default = import_hammer.default; // node_modules/mjolnir.js/dist/esm/utils/hammer-overrides.js var INPUT_START = 1; @@ -32184,10 +32207,10 @@ function enhanceMouseInput(MouseInput2) { } // node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js -enhancePointerEventInput(hammerjs.PointerEventInput); -enhanceMouseInput(hammerjs.MouseInput); -var Manager2 = hammerjs.Manager; -var hammer_browser_default = hammerjs; +enhancePointerEventInput(PointerEventInput); +enhanceMouseInput(MouseInput); +var Manager2 = Manager; +var hammer_browser_default = hammerjs_exports; // node_modules/mjolnir.js/dist/esm/inputs/input.js var Input = class { diff --git a/notebooks/bike_flow_map_widget.mjs b/notebooks/bike_flow_map_widget.mjs index bdcd6f601..d9c284cb5 100644 --- a/notebooks/bike_flow_map_widget.mjs +++ b/notebooks/bike_flow_map_widget.mjs @@ -141,7 +141,7 @@ function basemapLayer() { }); } -/** Okabe–Ito (colorblind-safe) first, then Celldega `clust.constants._COLOR_PALETTE` — keep in sync with notebook `STATION_PALETTE_HEX`. */ +/** Okabe-Ito (colorblind-safe) first, then Celldega `clust.constants._COLOR_PALETTE` - keep in sync with notebook `STATION_PALETTE_HEX`. */ const STATION_PALETTE_HEX = [ '#E69F00', '#56B4E9', '#009E73', '#F0E442', '#0072B2', '#D55E00', '#CC79A7', '#393b79', '#aec7e8', '#ff7f0e', '#ffbb78', '#98df8a', '#bcbd22', '#404040', diff --git a/notebooks/shims/hammerjs.mjs b/notebooks/shims/hammerjs.mjs new file mode 100644 index 000000000..153b6a125 --- /dev/null +++ b/notebooks/shims/hammerjs.mjs @@ -0,0 +1,19 @@ +/** + * esbuild bundles mjolnir/deck with `import * as hammerjs from 'hammerjs'`, but hammer.js + * is CJS `module.exports = Hammer` only — the namespace has no PointerEventInput, etc. + * This shim re-exports statics so hammer.browser.js works in a single-file ESM bundle + * (e.g. nbconvert HTML, jsDelivr). + */ +import H from '../../node_modules/hammerjs/hammer.js'; + +export const PointerEventInput = H.PointerEventInput; +export const MouseInput = H.MouseInput; +export const Manager = H.Manager; +export const Pan = H.Pan; +export const Rotate = H.Rotate; +export const Pinch = H.Pinch; +export const Swipe = H.Swipe; +export const Press = H.Press; +export const Tap = H.Tap; + +export default H; diff --git a/package.json b/package.json index 0fb40bff8..973e23bb9 100644 --- a/package.json +++ b/package.json @@ -26,7 +26,8 @@ "format:js:check": "prettier --check js/ --ignore-path .prettierignore", "format:py": "ruff format src/", "check:js": "npm run lint:js && npm run format:js:check", - "fix:js": "npm run lint:js:fix && npm run format:js" + "fix:js": "npm run lint:js:fix && npm run format:js", + "build:bike-map": "esbuild notebooks/bike_flow_map_widget.mjs --bundle --format=esm --platform=browser --target=es2022 --outfile=notebooks/bike_flow_map.widget.js --legal-comments=none --alias:hammerjs=./notebooks/shims/hammerjs.mjs" }, "dependencies": { "@deck.gl-community/editable-layers": "^9.0.3", From 5ee81304578764eedbdb9b5625f9ee4238901b42 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Fri, 10 Apr 2026 11:10:35 -0400 Subject: [PATCH 4/7] working on static HTML --- .github/workflows/purge-jsdelivr-bike-map.yml | 17 +++++++++++++++++ package.json | 2 +- 2 files changed, 18 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/purge-jsdelivr-bike-map.yml diff --git a/.github/workflows/purge-jsdelivr-bike-map.yml b/.github/workflows/purge-jsdelivr-bike-map.yml new file mode 100644 index 000000000..a2dd9fd5d --- /dev/null +++ b/.github/workflows/purge-jsdelivr-bike-map.yml @@ -0,0 +1,17 @@ +# jsDelivr can keep serving an older `bikes` branch file after GitHub updates; purge on bundle changes. +name: Purge jsDelivr bike map cache + +on: + push: + branches: + - bikes + paths: + - notebooks/bike_flow_map.widget.js + +jobs: + purge: + runs-on: ubuntu-latest + steps: + - name: Purge branch-based jsDelivr URL + run: | + curl -fsS "https://purge.jsdelivr.net/gh/${{ github.repository }}@bikes/notebooks/bike_flow_map.widget.js" diff --git a/package.json b/package.json index 973e23bb9..a009df207 100644 --- a/package.json +++ b/package.json @@ -27,7 +27,7 @@ "format:py": "ruff format src/", "check:js": "npm run lint:js && npm run format:js:check", "fix:js": "npm run lint:js:fix && npm run format:js", - "build:bike-map": "esbuild notebooks/bike_flow_map_widget.mjs --bundle --format=esm --platform=browser --target=es2022 --outfile=notebooks/bike_flow_map.widget.js --legal-comments=none --alias:hammerjs=./notebooks/shims/hammerjs.mjs" + "build:bike-map": "esbuild notebooks/bike_flow_map_widget.mjs --bundle --format=esm --platform=browser --target=es2022 --outfile=notebooks/bike_flow_map.widget.js --legal-comments=none --alias:hammerjs=./notebooks/shims/hammerjs.mjs && node -e \"const {execSync}=require('child_process');const h=execSync('git rev-parse HEAD',{encoding:'utf8'}).trim();console.log('\\n[bike-map] Pin notebooks to this jsDelivr URL after you commit the bundle:\\nhttps://cdn.jsdelivr.net/gh/broadinstitute/celldega@'+h+'/notebooks/bike_flow_map.widget.js\\n');\"" }, "dependencies": { "@deck.gl-community/editable-layers": "^9.0.3", From 23ba2efa277853c3076df609c695308b5adde93b Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Fri, 10 Apr 2026 23:18:47 -0400 Subject: [PATCH 5/7] cleaning --- .github/workflows/purge-jsdelivr-bike-map.yml | 17 ----------------- notebooks/shims/hammerjs.mjs | 19 ------------------- package.json | 5 ++--- pyproject.toml | 2 +- 4 files changed, 3 insertions(+), 40 deletions(-) delete mode 100644 .github/workflows/purge-jsdelivr-bike-map.yml delete mode 100644 notebooks/shims/hammerjs.mjs diff --git a/.github/workflows/purge-jsdelivr-bike-map.yml b/.github/workflows/purge-jsdelivr-bike-map.yml deleted file mode 100644 index a2dd9fd5d..000000000 --- a/.github/workflows/purge-jsdelivr-bike-map.yml +++ /dev/null @@ -1,17 +0,0 @@ -# jsDelivr can keep serving an older `bikes` branch file after GitHub updates; purge on bundle changes. -name: Purge jsDelivr bike map cache - -on: - push: - branches: - - bikes - paths: - - notebooks/bike_flow_map.widget.js - -jobs: - purge: - runs-on: ubuntu-latest - steps: - - name: Purge branch-based jsDelivr URL - run: | - curl -fsS "https://purge.jsdelivr.net/gh/${{ github.repository }}@bikes/notebooks/bike_flow_map.widget.js" diff --git a/notebooks/shims/hammerjs.mjs b/notebooks/shims/hammerjs.mjs deleted file mode 100644 index 153b6a125..000000000 --- a/notebooks/shims/hammerjs.mjs +++ /dev/null @@ -1,19 +0,0 @@ -/** - * esbuild bundles mjolnir/deck with `import * as hammerjs from 'hammerjs'`, but hammer.js - * is CJS `module.exports = Hammer` only — the namespace has no PointerEventInput, etc. - * This shim re-exports statics so hammer.browser.js works in a single-file ESM bundle - * (e.g. nbconvert HTML, jsDelivr). - */ -import H from '../../node_modules/hammerjs/hammer.js'; - -export const PointerEventInput = H.PointerEventInput; -export const MouseInput = H.MouseInput; -export const Manager = H.Manager; -export const Pan = H.Pan; -export const Rotate = H.Rotate; -export const Pinch = H.Pinch; -export const Swipe = H.Swipe; -export const Press = H.Press; -export const Tap = H.Tap; - -export default H; diff --git a/package.json b/package.json index a009df207..9244b0594 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "celldega", - "version": "0.16.0-alpha.1", + "version": "0.16.0-alpha.5", "type": "module", "engines": { "node": ">=16", @@ -26,8 +26,7 @@ "format:js:check": "prettier --check js/ --ignore-path .prettierignore", "format:py": "ruff format src/", "check:js": "npm run lint:js && npm run format:js:check", - "fix:js": "npm run lint:js:fix && npm run format:js", - "build:bike-map": "esbuild notebooks/bike_flow_map_widget.mjs --bundle --format=esm --platform=browser --target=es2022 --outfile=notebooks/bike_flow_map.widget.js --legal-comments=none --alias:hammerjs=./notebooks/shims/hammerjs.mjs && node -e \"const {execSync}=require('child_process');const h=execSync('git rev-parse HEAD',{encoding:'utf8'}).trim();console.log('\\n[bike-map] Pin notebooks to this jsDelivr URL after you commit the bundle:\\nhttps://cdn.jsdelivr.net/gh/broadinstitute/celldega@'+h+'/notebooks/bike_flow_map.widget.js\\n');\"" + "fix:js": "npm run lint:js:fix && npm run format:js" }, "dependencies": { "@deck.gl-community/editable-layers": "^9.0.3", diff --git a/pyproject.toml b/pyproject.toml index e7757e688..60066fd1e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "hatchling.build" [project] name = "celldega" -version = "0.16.0a1" +version = "0.16.0a5" readme = "README.md" dependencies = [ "anndata~=0.11.0", From 1b8cca50df302744709b96c1377ac7f364440f20 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Fri, 10 Apr 2026 23:25:22 -0400 Subject: [PATCH 6/7] removed JS --- notebooks/bike_flow_map.widget.js | 48794 --------------------------- notebooks/bike_flow_map_widget.mjs | 871 - 2 files changed, 49665 deletions(-) delete mode 100644 notebooks/bike_flow_map.widget.js delete mode 100644 notebooks/bike_flow_map_widget.mjs diff --git a/notebooks/bike_flow_map.widget.js b/notebooks/bike_flow_map.widget.js deleted file mode 100644 index 8721f5302..000000000 --- a/notebooks/bike_flow_map.widget.js +++ /dev/null @@ -1,48794 +0,0 @@ -var __create = Object.create; -var __defProp = Object.defineProperty; -var __getOwnPropDesc = Object.getOwnPropertyDescriptor; -var __getOwnPropNames = Object.getOwnPropertyNames; -var __getProtoOf = Object.getPrototypeOf; -var __hasOwnProp = Object.prototype.hasOwnProperty; -var __commonJS = (cb, mod2) => function __require() { - return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports; -}; -var __export = (target, all) => { - for (var name2 in all) - __defProp(target, name2, { get: all[name2], enumerable: true }); -}; -var __copyProps = (to, from, except, desc) => { - if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); - } - return to; -}; -var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. - isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, - mod2 -)); - -// node_modules/hammerjs/hammer.js -var require_hammer = __commonJS({ - "node_modules/hammerjs/hammer.js"(exports, module) { - (function(window2, document2, exportName, undefined2) { - "use strict"; - var VENDOR_PREFIXES = ["", "webkit", "Moz", "MS", "ms", "o"]; - var TEST_ELEMENT = document2.createElement("div"); - var TYPE_FUNCTION = "function"; - var round12 = Math.round; - var abs = Math.abs; - var now = Date.now; - function setTimeoutContext(fn, timeout, context) { - return setTimeout(bindFn(fn, context), timeout); - } - function invokeArrayArg(arg, fn, context) { - if (Array.isArray(arg)) { - each(arg, context[fn], context); - return true; - } - return false; - } - function each(obj, iterator, context) { - var i; - if (!obj) { - return; - } - if (obj.forEach) { - obj.forEach(iterator, context); - } else if (obj.length !== undefined2) { - i = 0; - while (i < obj.length) { - iterator.call(context, obj[i], i, obj); - i++; - } - } else { - for (i in obj) { - obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj); - } - } - } - function deprecate(method, name2, message2) { - var deprecationMessage = "DEPRECATED METHOD: " + name2 + "\n" + message2 + " AT \n"; - return function() { - var e = new Error("get-stack-trace"); - var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace"; - var log4 = window2.console && (window2.console.warn || window2.console.log); - if (log4) { - log4.call(window2.console, deprecationMessage, stack); - } - return method.apply(this, arguments); - }; - } - var assign; - if (typeof Object.assign !== "function") { - assign = function assign2(target) { - if (target === undefined2 || target === null) { - throw new TypeError("Cannot convert undefined or null to object"); - } - var output = Object(target); - for (var index2 = 1; index2 < arguments.length; index2++) { - var source = arguments[index2]; - if (source !== undefined2 && source !== null) { - for (var nextKey in source) { - if (source.hasOwnProperty(nextKey)) { - output[nextKey] = source[nextKey]; - } - } - } - } - return output; - }; - } else { - assign = Object.assign; - } - var extend = deprecate(function extend2(dest, src, merge2) { - var keys = Object.keys(src); - var i = 0; - while (i < keys.length) { - if (!merge2 || merge2 && dest[keys[i]] === undefined2) { - dest[keys[i]] = src[keys[i]]; - } - i++; - } - return dest; - }, "extend", "Use `assign`."); - var merge = deprecate(function merge2(dest, src) { - return extend(dest, src, true); - }, "merge", "Use `assign`."); - function inherit(child, base, properties) { - var baseP = base.prototype, childP; - childP = child.prototype = Object.create(baseP); - childP.constructor = child; - childP._super = baseP; - if (properties) { - assign(childP, properties); - } - } - function bindFn(fn, context) { - return function boundFn() { - return fn.apply(context, arguments); - }; - } - function boolOrFn(val, args) { - if (typeof val == TYPE_FUNCTION) { - return val.apply(args ? args[0] || undefined2 : undefined2, args); - } - return val; - } - function ifUndefined(val1, val2) { - return val1 === undefined2 ? val2 : val1; - } - function addEventListeners(target, types, handler) { - each(splitStr(types), function(type) { - target.addEventListener(type, handler, false); - }); - } - function removeEventListeners(target, types, handler) { - each(splitStr(types), function(type) { - target.removeEventListener(type, handler, false); - }); - } - function hasParent(node, parent) { - while (node) { - if (node == parent) { - return true; - } - node = node.parentNode; - } - return false; - } - function inStr(str10, find) { - return str10.indexOf(find) > -1; - } - function splitStr(str10) { - return str10.trim().split(/\s+/g); - } - function inArray(src, find, findByKey) { - if (src.indexOf && !findByKey) { - return src.indexOf(find); - } else { - var i = 0; - while (i < src.length) { - if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) { - return i; - } - i++; - } - return -1; - } - } - function toArray(obj) { - return Array.prototype.slice.call(obj, 0); - } - function uniqueArray(src, key, sort) { - var results = []; - var values = []; - var i = 0; - while (i < src.length) { - var val = key ? src[i][key] : src[i]; - if (inArray(values, val) < 0) { - results.push(src[i]); - } - values[i] = val; - i++; - } - if (sort) { - if (!key) { - results = results.sort(); - } else { - results = results.sort(function sortUniqueArray(a, b) { - return a[key] > b[key]; - }); - } - } - return results; - } - function prefixed(obj, property) { - var prefix, prop; - var camelProp = property[0].toUpperCase() + property.slice(1); - var i = 0; - while (i < VENDOR_PREFIXES.length) { - prefix = VENDOR_PREFIXES[i]; - prop = prefix ? prefix + camelProp : property; - if (prop in obj) { - return prop; - } - i++; - } - return undefined2; - } - var _uniqueId = 1; - function uniqueId() { - return _uniqueId++; - } - function getWindowForElement(element) { - var doc = element.ownerDocument || element; - return doc.defaultView || doc.parentWindow || window2; - } - var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i; - var SUPPORT_TOUCH = "ontouchstart" in window2; - var SUPPORT_POINTER_EVENTS = prefixed(window2, "PointerEvent") !== undefined2; - var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent); - var INPUT_TYPE_TOUCH = "touch"; - var INPUT_TYPE_PEN = "pen"; - var INPUT_TYPE_MOUSE = "mouse"; - var INPUT_TYPE_KINECT = "kinect"; - var COMPUTE_INTERVAL = 25; - var INPUT_START2 = 1; - var INPUT_MOVE2 = 2; - var INPUT_END2 = 4; - var INPUT_CANCEL = 8; - var DIRECTION_NONE = 1; - var DIRECTION_LEFT = 2; - var DIRECTION_RIGHT = 4; - var DIRECTION_UP = 8; - var DIRECTION_DOWN = 16; - var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT; - var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN; - var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL; - var PROPS_XY = ["x", "y"]; - var PROPS_CLIENT_XY = ["clientX", "clientY"]; - function Input2(manager, callback) { - var self2 = this; - this.manager = manager; - this.callback = callback; - this.element = manager.element; - this.target = manager.options.inputTarget; - this.domHandler = function(ev) { - if (boolOrFn(manager.options.enable, [manager])) { - self2.handler(ev); - } - }; - this.init(); - } - Input2.prototype = { - /** - * should handle the inputEvent data and trigger the callback - * @virtual - */ - handler: function() { - }, - /** - * bind the events - */ - init: function() { - this.evEl && addEventListeners(this.element, this.evEl, this.domHandler); - this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler); - this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); - }, - /** - * unbind the events - */ - destroy: function() { - this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler); - this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler); - this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler); - } - }; - function createInputInstance(manager) { - var Type2; - var inputClass = manager.options.inputClass; - if (inputClass) { - Type2 = inputClass; - } else if (SUPPORT_POINTER_EVENTS) { - Type2 = PointerEventInput2; - } else if (SUPPORT_ONLY_TOUCH) { - Type2 = TouchInput; - } else if (!SUPPORT_TOUCH) { - Type2 = MouseInput2; - } else { - Type2 = TouchMouseInput; - } - return new Type2(manager, inputHandler); - } - function inputHandler(manager, eventType, input) { - var pointersLen = input.pointers.length; - var changedPointersLen = input.changedPointers.length; - var isFirst = eventType & INPUT_START2 && pointersLen - changedPointersLen === 0; - var isFinal = eventType & (INPUT_END2 | INPUT_CANCEL) && pointersLen - changedPointersLen === 0; - input.isFirst = !!isFirst; - input.isFinal = !!isFinal; - if (isFirst) { - manager.session = {}; - } - input.eventType = eventType; - computeInputData(manager, input); - manager.emit("hammer.input", input); - manager.recognize(input); - manager.session.prevInput = input; - } - function computeInputData(manager, input) { - var session = manager.session; - var pointers = input.pointers; - var pointersLength = pointers.length; - if (!session.firstInput) { - session.firstInput = simpleCloneInputData(input); - } - if (pointersLength > 1 && !session.firstMultiple) { - session.firstMultiple = simpleCloneInputData(input); - } else if (pointersLength === 1) { - session.firstMultiple = false; - } - var firstInput = session.firstInput; - var firstMultiple = session.firstMultiple; - var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center; - var center = input.center = getCenter(pointers); - input.timeStamp = now(); - input.deltaTime = input.timeStamp - firstInput.timeStamp; - input.angle = getAngle(offsetCenter, center); - input.distance = getDistance(offsetCenter, center); - computeDeltaXY(session, input); - input.offsetDirection = getDirection(input.deltaX, input.deltaY); - var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY); - input.overallVelocityX = overallVelocity.x; - input.overallVelocityY = overallVelocity.y; - input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y; - input.scale = firstMultiple ? getScale2(firstMultiple.pointers, pointers) : 1; - input.rotation = firstMultiple ? getRotation4(firstMultiple.pointers, pointers) : 0; - input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers; - computeIntervalInputData(session, input); - var target = manager.element; - if (hasParent(input.srcEvent.target, target)) { - target = input.srcEvent.target; - } - input.target = target; - } - function computeDeltaXY(session, input) { - var center = input.center; - var offset = session.offsetDelta || {}; - var prevDelta = session.prevDelta || {}; - var prevInput = session.prevInput || {}; - if (input.eventType === INPUT_START2 || prevInput.eventType === INPUT_END2) { - prevDelta = session.prevDelta = { - x: prevInput.deltaX || 0, - y: prevInput.deltaY || 0 - }; - offset = session.offsetDelta = { - x: center.x, - y: center.y - }; - } - input.deltaX = prevDelta.x + (center.x - offset.x); - input.deltaY = prevDelta.y + (center.y - offset.y); - } - function computeIntervalInputData(session, input) { - var last = session.lastInterval || input, deltaTime = input.timeStamp - last.timeStamp, velocity, velocityX, velocityY, direction; - if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined2)) { - var deltaX = input.deltaX - last.deltaX; - var deltaY = input.deltaY - last.deltaY; - var v = getVelocity(deltaTime, deltaX, deltaY); - velocityX = v.x; - velocityY = v.y; - velocity = abs(v.x) > abs(v.y) ? v.x : v.y; - direction = getDirection(deltaX, deltaY); - session.lastInterval = input; - } else { - velocity = last.velocity; - velocityX = last.velocityX; - velocityY = last.velocityY; - direction = last.direction; - } - input.velocity = velocity; - input.velocityX = velocityX; - input.velocityY = velocityY; - input.direction = direction; - } - function simpleCloneInputData(input) { - var pointers = []; - var i = 0; - while (i < input.pointers.length) { - pointers[i] = { - clientX: round12(input.pointers[i].clientX), - clientY: round12(input.pointers[i].clientY) - }; - i++; - } - return { - timeStamp: now(), - pointers, - center: getCenter(pointers), - deltaX: input.deltaX, - deltaY: input.deltaY - }; - } - function getCenter(pointers) { - var pointersLength = pointers.length; - if (pointersLength === 1) { - return { - x: round12(pointers[0].clientX), - y: round12(pointers[0].clientY) - }; - } - var x = 0, y = 0, i = 0; - while (i < pointersLength) { - x += pointers[i].clientX; - y += pointers[i].clientY; - i++; - } - return { - x: round12(x / pointersLength), - y: round12(y / pointersLength) - }; - } - function getVelocity(deltaTime, x, y) { - return { - x: x / deltaTime || 0, - y: y / deltaTime || 0 - }; - } - function getDirection(x, y) { - if (x === y) { - return DIRECTION_NONE; - } - if (abs(x) >= abs(y)) { - return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT; - } - return y < 0 ? DIRECTION_UP : DIRECTION_DOWN; - } - function getDistance(p1, p2, props) { - if (!props) { - props = PROPS_XY; - } - var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]]; - return Math.sqrt(x * x + y * y); - } - function getAngle(p1, p2, props) { - if (!props) { - props = PROPS_XY; - } - var x = p2[props[0]] - p1[props[0]], y = p2[props[1]] - p1[props[1]]; - return Math.atan2(y, x) * 180 / Math.PI; - } - function getRotation4(start, end) { - return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY); - } - function getScale2(start, end) { - return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY); - } - var MOUSE_INPUT_MAP2 = { - mousedown: INPUT_START2, - mousemove: INPUT_MOVE2, - mouseup: INPUT_END2 - }; - var MOUSE_ELEMENT_EVENTS = "mousedown"; - var MOUSE_WINDOW_EVENTS = "mousemove mouseup"; - function MouseInput2() { - this.evEl = MOUSE_ELEMENT_EVENTS; - this.evWin = MOUSE_WINDOW_EVENTS; - this.pressed = false; - Input2.apply(this, arguments); - } - inherit(MouseInput2, Input2, { - /** - * handle mouse events - * @param {Object} ev - */ - handler: function MEhandler(ev) { - var eventType = MOUSE_INPUT_MAP2[ev.type]; - if (eventType & INPUT_START2 && ev.button === 0) { - this.pressed = true; - } - if (eventType & INPUT_MOVE2 && ev.which !== 1) { - eventType = INPUT_END2; - } - if (!this.pressed) { - return; - } - if (eventType & INPUT_END2) { - this.pressed = false; - } - this.callback(this.manager, eventType, { - pointers: [ev], - changedPointers: [ev], - pointerType: INPUT_TYPE_MOUSE, - srcEvent: ev - }); - } - }); - var POINTER_INPUT_MAP = { - pointerdown: INPUT_START2, - pointermove: INPUT_MOVE2, - pointerup: INPUT_END2, - pointercancel: INPUT_CANCEL, - pointerout: INPUT_CANCEL - }; - var IE10_POINTER_TYPE_ENUM = { - 2: INPUT_TYPE_TOUCH, - 3: INPUT_TYPE_PEN, - 4: INPUT_TYPE_MOUSE, - 5: INPUT_TYPE_KINECT - // see https://twitter.com/jacobrossi/status/480596438489890816 - }; - var POINTER_ELEMENT_EVENTS = "pointerdown"; - var POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel"; - if (window2.MSPointerEvent && !window2.PointerEvent) { - POINTER_ELEMENT_EVENTS = "MSPointerDown"; - POINTER_WINDOW_EVENTS = "MSPointerMove MSPointerUp MSPointerCancel"; - } - function PointerEventInput2() { - this.evEl = POINTER_ELEMENT_EVENTS; - this.evWin = POINTER_WINDOW_EVENTS; - Input2.apply(this, arguments); - this.store = this.manager.session.pointerEvents = []; - } - inherit(PointerEventInput2, Input2, { - /** - * handle mouse events - * @param {Object} ev - */ - handler: function PEhandler(ev) { - var store = this.store; - var removePointer = false; - var eventTypeNormalized = ev.type.toLowerCase().replace("ms", ""); - var eventType = POINTER_INPUT_MAP[eventTypeNormalized]; - var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType; - var isTouch = pointerType == INPUT_TYPE_TOUCH; - var storeIndex = inArray(store, ev.pointerId, "pointerId"); - if (eventType & INPUT_START2 && (ev.button === 0 || isTouch)) { - if (storeIndex < 0) { - store.push(ev); - storeIndex = store.length - 1; - } - } else if (eventType & (INPUT_END2 | INPUT_CANCEL)) { - removePointer = true; - } - if (storeIndex < 0) { - return; - } - store[storeIndex] = ev; - this.callback(this.manager, eventType, { - pointers: store, - changedPointers: [ev], - pointerType, - srcEvent: ev - }); - if (removePointer) { - store.splice(storeIndex, 1); - } - } - }); - var SINGLE_TOUCH_INPUT_MAP = { - touchstart: INPUT_START2, - touchmove: INPUT_MOVE2, - touchend: INPUT_END2, - touchcancel: INPUT_CANCEL - }; - var SINGLE_TOUCH_TARGET_EVENTS = "touchstart"; - var SINGLE_TOUCH_WINDOW_EVENTS = "touchstart touchmove touchend touchcancel"; - function SingleTouchInput() { - this.evTarget = SINGLE_TOUCH_TARGET_EVENTS; - this.evWin = SINGLE_TOUCH_WINDOW_EVENTS; - this.started = false; - Input2.apply(this, arguments); - } - inherit(SingleTouchInput, Input2, { - handler: function TEhandler(ev) { - var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; - if (type === INPUT_START2) { - this.started = true; - } - if (!this.started) { - return; - } - var touches = normalizeSingleTouches.call(this, ev, type); - if (type & (INPUT_END2 | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) { - this.started = false; - } - this.callback(this.manager, type, { - pointers: touches[0], - changedPointers: touches[1], - pointerType: INPUT_TYPE_TOUCH, - srcEvent: ev - }); - } - }); - function normalizeSingleTouches(ev, type) { - var all = toArray(ev.touches); - var changed = toArray(ev.changedTouches); - if (type & (INPUT_END2 | INPUT_CANCEL)) { - all = uniqueArray(all.concat(changed), "identifier", true); - } - return [all, changed]; - } - var TOUCH_INPUT_MAP = { - touchstart: INPUT_START2, - touchmove: INPUT_MOVE2, - touchend: INPUT_END2, - touchcancel: INPUT_CANCEL - }; - var TOUCH_TARGET_EVENTS = "touchstart touchmove touchend touchcancel"; - function TouchInput() { - this.evTarget = TOUCH_TARGET_EVENTS; - this.targetIds = {}; - Input2.apply(this, arguments); - } - inherit(TouchInput, Input2, { - handler: function MTEhandler(ev) { - var type = TOUCH_INPUT_MAP[ev.type]; - var touches = getTouches.call(this, ev, type); - if (!touches) { - return; - } - this.callback(this.manager, type, { - pointers: touches[0], - changedPointers: touches[1], - pointerType: INPUT_TYPE_TOUCH, - srcEvent: ev - }); - } - }); - function getTouches(ev, type) { - var allTouches = toArray(ev.touches); - var targetIds = this.targetIds; - if (type & (INPUT_START2 | INPUT_MOVE2) && allTouches.length === 1) { - targetIds[allTouches[0].identifier] = true; - return [allTouches, allTouches]; - } - var i, targetTouches, changedTouches = toArray(ev.changedTouches), changedTargetTouches = [], target = this.target; - targetTouches = allTouches.filter(function(touch) { - return hasParent(touch.target, target); - }); - if (type === INPUT_START2) { - i = 0; - while (i < targetTouches.length) { - targetIds[targetTouches[i].identifier] = true; - i++; - } - } - i = 0; - while (i < changedTouches.length) { - if (targetIds[changedTouches[i].identifier]) { - changedTargetTouches.push(changedTouches[i]); - } - if (type & (INPUT_END2 | INPUT_CANCEL)) { - delete targetIds[changedTouches[i].identifier]; - } - i++; - } - if (!changedTargetTouches.length) { - return; - } - return [ - // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel' - uniqueArray(targetTouches.concat(changedTargetTouches), "identifier", true), - changedTargetTouches - ]; - } - var DEDUP_TIMEOUT = 2500; - var DEDUP_DISTANCE = 25; - function TouchMouseInput() { - Input2.apply(this, arguments); - var handler = bindFn(this.handler, this); - this.touch = new TouchInput(this.manager, handler); - this.mouse = new MouseInput2(this.manager, handler); - this.primaryTouch = null; - this.lastTouches = []; - } - inherit(TouchMouseInput, Input2, { - /** - * handle mouse and touch events - * @param {Hammer} manager - * @param {String} inputEvent - * @param {Object} inputData - */ - handler: function TMEhandler(manager, inputEvent, inputData) { - var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH, isMouse = inputData.pointerType == INPUT_TYPE_MOUSE; - if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) { - return; - } - if (isTouch) { - recordTouches.call(this, inputEvent, inputData); - } else if (isMouse && isSyntheticEvent.call(this, inputData)) { - return; - } - this.callback(manager, inputEvent, inputData); - }, - /** - * remove the event listeners - */ - destroy: function destroy() { - this.touch.destroy(); - this.mouse.destroy(); - } - }); - function recordTouches(eventType, eventData) { - if (eventType & INPUT_START2) { - this.primaryTouch = eventData.changedPointers[0].identifier; - setLastTouch.call(this, eventData); - } else if (eventType & (INPUT_END2 | INPUT_CANCEL)) { - setLastTouch.call(this, eventData); - } - } - function setLastTouch(eventData) { - var touch = eventData.changedPointers[0]; - if (touch.identifier === this.primaryTouch) { - var lastTouch = { x: touch.clientX, y: touch.clientY }; - this.lastTouches.push(lastTouch); - var lts = this.lastTouches; - var removeLastTouch = function() { - var i = lts.indexOf(lastTouch); - if (i > -1) { - lts.splice(i, 1); - } - }; - setTimeout(removeLastTouch, DEDUP_TIMEOUT); - } - } - function isSyntheticEvent(eventData) { - var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY; - for (var i = 0; i < this.lastTouches.length; i++) { - var t = this.lastTouches[i]; - var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y); - if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) { - return true; - } - } - return false; - } - var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, "touchAction"); - var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined2; - var TOUCH_ACTION_COMPUTE = "compute"; - var TOUCH_ACTION_AUTO = "auto"; - var TOUCH_ACTION_MANIPULATION = "manipulation"; - var TOUCH_ACTION_NONE = "none"; - var TOUCH_ACTION_PAN_X = "pan-x"; - var TOUCH_ACTION_PAN_Y = "pan-y"; - var TOUCH_ACTION_MAP = getTouchActionProps(); - function TouchAction(manager, value) { - this.manager = manager; - this.set(value); - } - TouchAction.prototype = { - /** - * set the touchAction value on the element or enable the polyfill - * @param {String} value - */ - set: function(value) { - if (value == TOUCH_ACTION_COMPUTE) { - value = this.compute(); - } - if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) { - this.manager.element.style[PREFIXED_TOUCH_ACTION] = value; - } - this.actions = value.toLowerCase().trim(); - }, - /** - * just re-set the touchAction value - */ - update: function() { - this.set(this.manager.options.touchAction); - }, - /** - * compute the value for the touchAction property based on the recognizer's settings - * @returns {String} value - */ - compute: function() { - var actions = []; - each(this.manager.recognizers, function(recognizer) { - if (boolOrFn(recognizer.options.enable, [recognizer])) { - actions = actions.concat(recognizer.getTouchAction()); - } - }); - return cleanTouchActions(actions.join(" ")); - }, - /** - * this method is called on each input cycle and provides the preventing of the browser behavior - * @param {Object} input - */ - preventDefaults: function(input) { - var srcEvent = input.srcEvent; - var direction = input.offsetDirection; - if (this.manager.session.prevented) { - srcEvent.preventDefault(); - return; - } - var actions = this.actions; - var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE]; - var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y]; - var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X]; - if (hasNone) { - var isTapPointer = input.pointers.length === 1; - var isTapMovement = input.distance < 2; - var isTapTouchTime = input.deltaTime < 250; - if (isTapPointer && isTapMovement && isTapTouchTime) { - return; - } - } - if (hasPanX && hasPanY) { - return; - } - if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) { - return this.preventSrc(srcEvent); - } - }, - /** - * call preventDefault to prevent the browser's default behavior (scrolling in most cases) - * @param {Object} srcEvent - */ - preventSrc: function(srcEvent) { - this.manager.session.prevented = true; - srcEvent.preventDefault(); - } - }; - function cleanTouchActions(actions) { - if (inStr(actions, TOUCH_ACTION_NONE)) { - return TOUCH_ACTION_NONE; - } - var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X); - var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); - if (hasPanX && hasPanY) { - return TOUCH_ACTION_NONE; - } - if (hasPanX || hasPanY) { - return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y; - } - if (inStr(actions, TOUCH_ACTION_MANIPULATION)) { - return TOUCH_ACTION_MANIPULATION; - } - return TOUCH_ACTION_AUTO; - } - function getTouchActionProps() { - if (!NATIVE_TOUCH_ACTION) { - return false; - } - var touchMap = {}; - var cssSupports = window2.CSS && window2.CSS.supports; - ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(val) { - touchMap[val] = cssSupports ? window2.CSS.supports("touch-action", val) : true; - }); - return touchMap; - } - var STATE_POSSIBLE = 1; - var STATE_BEGAN = 2; - var STATE_CHANGED = 4; - var STATE_ENDED = 8; - var STATE_RECOGNIZED = STATE_ENDED; - var STATE_CANCELLED = 16; - var STATE_FAILED = 32; - function Recognizer(options) { - this.options = assign({}, this.defaults, options || {}); - this.id = uniqueId(); - this.manager = null; - this.options.enable = ifUndefined(this.options.enable, true); - this.state = STATE_POSSIBLE; - this.simultaneous = {}; - this.requireFail = []; - } - Recognizer.prototype = { - /** - * @virtual - * @type {Object} - */ - defaults: {}, - /** - * set options - * @param {Object} options - * @return {Recognizer} - */ - set: function(options) { - assign(this.options, options); - this.manager && this.manager.touchAction.update(); - return this; - }, - /** - * recognize simultaneous with an other recognizer. - * @param {Recognizer} otherRecognizer - * @returns {Recognizer} this - */ - recognizeWith: function(otherRecognizer) { - if (invokeArrayArg(otherRecognizer, "recognizeWith", this)) { - return this; - } - var simultaneous = this.simultaneous; - otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); - if (!simultaneous[otherRecognizer.id]) { - simultaneous[otherRecognizer.id] = otherRecognizer; - otherRecognizer.recognizeWith(this); - } - return this; - }, - /** - * drop the simultaneous link. it doesnt remove the link on the other recognizer. - * @param {Recognizer} otherRecognizer - * @returns {Recognizer} this - */ - dropRecognizeWith: function(otherRecognizer) { - if (invokeArrayArg(otherRecognizer, "dropRecognizeWith", this)) { - return this; - } - otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); - delete this.simultaneous[otherRecognizer.id]; - return this; - }, - /** - * recognizer can only run when an other is failing - * @param {Recognizer} otherRecognizer - * @returns {Recognizer} this - */ - requireFailure: function(otherRecognizer) { - if (invokeArrayArg(otherRecognizer, "requireFailure", this)) { - return this; - } - var requireFail = this.requireFail; - otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); - if (inArray(requireFail, otherRecognizer) === -1) { - requireFail.push(otherRecognizer); - otherRecognizer.requireFailure(this); - } - return this; - }, - /** - * drop the requireFailure link. it does not remove the link on the other recognizer. - * @param {Recognizer} otherRecognizer - * @returns {Recognizer} this - */ - dropRequireFailure: function(otherRecognizer) { - if (invokeArrayArg(otherRecognizer, "dropRequireFailure", this)) { - return this; - } - otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this); - var index2 = inArray(this.requireFail, otherRecognizer); - if (index2 > -1) { - this.requireFail.splice(index2, 1); - } - return this; - }, - /** - * has require failures boolean - * @returns {boolean} - */ - hasRequireFailures: function() { - return this.requireFail.length > 0; - }, - /** - * if the recognizer can recognize simultaneous with an other recognizer - * @param {Recognizer} otherRecognizer - * @returns {Boolean} - */ - canRecognizeWith: function(otherRecognizer) { - return !!this.simultaneous[otherRecognizer.id]; - }, - /** - * You should use `tryEmit` instead of `emit` directly to check - * that all the needed recognizers has failed before emitting. - * @param {Object} input - */ - emit: function(input) { - var self2 = this; - var state = this.state; - function emit(event) { - self2.manager.emit(event, input); - } - if (state < STATE_ENDED) { - emit(self2.options.event + stateStr(state)); - } - emit(self2.options.event); - if (input.additionalEvent) { - emit(input.additionalEvent); - } - if (state >= STATE_ENDED) { - emit(self2.options.event + stateStr(state)); - } - }, - /** - * Check that all the require failure recognizers has failed, - * if true, it emits a gesture event, - * otherwise, setup the state to FAILED. - * @param {Object} input - */ - tryEmit: function(input) { - if (this.canEmit()) { - return this.emit(input); - } - this.state = STATE_FAILED; - }, - /** - * can we emit? - * @returns {boolean} - */ - canEmit: function() { - var i = 0; - while (i < this.requireFail.length) { - if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) { - return false; - } - i++; - } - return true; - }, - /** - * update the recognizer - * @param {Object} inputData - */ - recognize: function(inputData) { - var inputDataClone = assign({}, inputData); - if (!boolOrFn(this.options.enable, [this, inputDataClone])) { - this.reset(); - this.state = STATE_FAILED; - return; - } - if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) { - this.state = STATE_POSSIBLE; - } - this.state = this.process(inputDataClone); - if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) { - this.tryEmit(inputDataClone); - } - }, - /** - * return the state of the recognizer - * the actual recognizing happens in this method - * @virtual - * @param {Object} inputData - * @returns {Const} STATE - */ - process: function(inputData) { - }, - // jshint ignore:line - /** - * return the preferred touch-action - * @virtual - * @returns {Array} - */ - getTouchAction: function() { - }, - /** - * called when the gesture isn't allowed to recognize - * like when another is being recognized or it is disabled - * @virtual - */ - reset: function() { - } - }; - function stateStr(state) { - if (state & STATE_CANCELLED) { - return "cancel"; - } else if (state & STATE_ENDED) { - return "end"; - } else if (state & STATE_CHANGED) { - return "move"; - } else if (state & STATE_BEGAN) { - return "start"; - } - return ""; - } - function directionStr(direction) { - if (direction == DIRECTION_DOWN) { - return "down"; - } else if (direction == DIRECTION_UP) { - return "up"; - } else if (direction == DIRECTION_LEFT) { - return "left"; - } else if (direction == DIRECTION_RIGHT) { - return "right"; - } - return ""; - } - function getRecognizerByNameIfManager(otherRecognizer, recognizer) { - var manager = recognizer.manager; - if (manager) { - return manager.get(otherRecognizer); - } - return otherRecognizer; - } - function AttrRecognizer() { - Recognizer.apply(this, arguments); - } - inherit(AttrRecognizer, Recognizer, { - /** - * @namespace - * @memberof AttrRecognizer - */ - defaults: { - /** - * @type {Number} - * @default 1 - */ - pointers: 1 - }, - /** - * Used to check if it the recognizer receives valid input, like input.distance > 10. - * @memberof AttrRecognizer - * @param {Object} input - * @returns {Boolean} recognized - */ - attrTest: function(input) { - var optionPointers = this.options.pointers; - return optionPointers === 0 || input.pointers.length === optionPointers; - }, - /** - * Process the input and return the state for the recognizer - * @memberof AttrRecognizer - * @param {Object} input - * @returns {*} State - */ - process: function(input) { - var state = this.state; - var eventType = input.eventType; - var isRecognized = state & (STATE_BEGAN | STATE_CHANGED); - var isValid = this.attrTest(input); - if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) { - return state | STATE_CANCELLED; - } else if (isRecognized || isValid) { - if (eventType & INPUT_END2) { - return state | STATE_ENDED; - } else if (!(state & STATE_BEGAN)) { - return STATE_BEGAN; - } - return state | STATE_CHANGED; - } - return STATE_FAILED; - } - }); - function PanRecognizer() { - AttrRecognizer.apply(this, arguments); - this.pX = null; - this.pY = null; - } - inherit(PanRecognizer, AttrRecognizer, { - /** - * @namespace - * @memberof PanRecognizer - */ - defaults: { - event: "pan", - threshold: 10, - pointers: 1, - direction: DIRECTION_ALL - }, - getTouchAction: function() { - var direction = this.options.direction; - var actions = []; - if (direction & DIRECTION_HORIZONTAL) { - actions.push(TOUCH_ACTION_PAN_Y); - } - if (direction & DIRECTION_VERTICAL) { - actions.push(TOUCH_ACTION_PAN_X); - } - return actions; - }, - directionTest: function(input) { - var options = this.options; - var hasMoved = true; - var distance8 = input.distance; - var direction = input.direction; - var x = input.deltaX; - var y = input.deltaY; - if (!(direction & options.direction)) { - if (options.direction & DIRECTION_HORIZONTAL) { - direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT; - hasMoved = x != this.pX; - distance8 = Math.abs(input.deltaX); - } else { - direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN; - hasMoved = y != this.pY; - distance8 = Math.abs(input.deltaY); - } - } - input.direction = direction; - return hasMoved && distance8 > options.threshold && direction & options.direction; - }, - attrTest: function(input) { - return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input)); - }, - emit: function(input) { - this.pX = input.deltaX; - this.pY = input.deltaY; - var direction = directionStr(input.direction); - if (direction) { - input.additionalEvent = this.options.event + direction; - } - this._super.emit.call(this, input); - } - }); - function PinchRecognizer() { - AttrRecognizer.apply(this, arguments); - } - inherit(PinchRecognizer, AttrRecognizer, { - /** - * @namespace - * @memberof PinchRecognizer - */ - defaults: { - event: "pinch", - threshold: 0, - pointers: 2 - }, - getTouchAction: function() { - return [TOUCH_ACTION_NONE]; - }, - attrTest: function(input) { - return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN); - }, - emit: function(input) { - if (input.scale !== 1) { - var inOut = input.scale < 1 ? "in" : "out"; - input.additionalEvent = this.options.event + inOut; - } - this._super.emit.call(this, input); - } - }); - function PressRecognizer() { - Recognizer.apply(this, arguments); - this._timer = null; - this._input = null; - } - inherit(PressRecognizer, Recognizer, { - /** - * @namespace - * @memberof PressRecognizer - */ - defaults: { - event: "press", - pointers: 1, - time: 251, - // minimal time of the pointer to be pressed - threshold: 9 - // a minimal movement is ok, but keep it low - }, - getTouchAction: function() { - return [TOUCH_ACTION_AUTO]; - }, - process: function(input) { - var options = this.options; - var validPointers = input.pointers.length === options.pointers; - var validMovement = input.distance < options.threshold; - var validTime = input.deltaTime > options.time; - this._input = input; - if (!validMovement || !validPointers || input.eventType & (INPUT_END2 | INPUT_CANCEL) && !validTime) { - this.reset(); - } else if (input.eventType & INPUT_START2) { - this.reset(); - this._timer = setTimeoutContext(function() { - this.state = STATE_RECOGNIZED; - this.tryEmit(); - }, options.time, this); - } else if (input.eventType & INPUT_END2) { - return STATE_RECOGNIZED; - } - return STATE_FAILED; - }, - reset: function() { - clearTimeout(this._timer); - }, - emit: function(input) { - if (this.state !== STATE_RECOGNIZED) { - return; - } - if (input && input.eventType & INPUT_END2) { - this.manager.emit(this.options.event + "up", input); - } else { - this._input.timeStamp = now(); - this.manager.emit(this.options.event, this._input); - } - } - }); - function RotateRecognizer() { - AttrRecognizer.apply(this, arguments); - } - inherit(RotateRecognizer, AttrRecognizer, { - /** - * @namespace - * @memberof RotateRecognizer - */ - defaults: { - event: "rotate", - threshold: 0, - pointers: 2 - }, - getTouchAction: function() { - return [TOUCH_ACTION_NONE]; - }, - attrTest: function(input) { - return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN); - } - }); - function SwipeRecognizer() { - AttrRecognizer.apply(this, arguments); - } - inherit(SwipeRecognizer, AttrRecognizer, { - /** - * @namespace - * @memberof SwipeRecognizer - */ - defaults: { - event: "swipe", - threshold: 10, - velocity: 0.3, - direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL, - pointers: 1 - }, - getTouchAction: function() { - return PanRecognizer.prototype.getTouchAction.call(this); - }, - attrTest: function(input) { - var direction = this.options.direction; - var velocity; - if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) { - velocity = input.overallVelocity; - } else if (direction & DIRECTION_HORIZONTAL) { - velocity = input.overallVelocityX; - } else if (direction & DIRECTION_VERTICAL) { - velocity = input.overallVelocityY; - } - return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END2; - }, - emit: function(input) { - var direction = directionStr(input.offsetDirection); - if (direction) { - this.manager.emit(this.options.event + direction, input); - } - this.manager.emit(this.options.event, input); - } - }); - function TapRecognizer() { - Recognizer.apply(this, arguments); - this.pTime = false; - this.pCenter = false; - this._timer = null; - this._input = null; - this.count = 0; - } - inherit(TapRecognizer, Recognizer, { - /** - * @namespace - * @memberof PinchRecognizer - */ - defaults: { - event: "tap", - pointers: 1, - taps: 1, - interval: 300, - // max time between the multi-tap taps - time: 250, - // max time of the pointer to be down (like finger on the screen) - threshold: 9, - // a minimal movement is ok, but keep it low - posThreshold: 10 - // a multi-tap can be a bit off the initial position - }, - getTouchAction: function() { - return [TOUCH_ACTION_MANIPULATION]; - }, - process: function(input) { - var options = this.options; - var validPointers = input.pointers.length === options.pointers; - var validMovement = input.distance < options.threshold; - var validTouchTime = input.deltaTime < options.time; - this.reset(); - if (input.eventType & INPUT_START2 && this.count === 0) { - return this.failTimeout(); - } - if (validMovement && validTouchTime && validPointers) { - if (input.eventType != INPUT_END2) { - return this.failTimeout(); - } - var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true; - var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold; - this.pTime = input.timeStamp; - this.pCenter = input.center; - if (!validMultiTap || !validInterval) { - this.count = 1; - } else { - this.count += 1; - } - this._input = input; - var tapCount = this.count % options.taps; - if (tapCount === 0) { - if (!this.hasRequireFailures()) { - return STATE_RECOGNIZED; - } else { - this._timer = setTimeoutContext(function() { - this.state = STATE_RECOGNIZED; - this.tryEmit(); - }, options.interval, this); - return STATE_BEGAN; - } - } - } - return STATE_FAILED; - }, - failTimeout: function() { - this._timer = setTimeoutContext(function() { - this.state = STATE_FAILED; - }, this.options.interval, this); - return STATE_FAILED; - }, - reset: function() { - clearTimeout(this._timer); - }, - emit: function() { - if (this.state == STATE_RECOGNIZED) { - this._input.tapCount = this.count; - this.manager.emit(this.options.event, this._input); - } - } - }); - function Hammer(element, options) { - options = options || {}; - options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset); - return new Manager3(element, options); - } - Hammer.VERSION = "2.0.7"; - Hammer.defaults = { - /** - * set if DOM events are being triggered. - * But this is slower and unused by simple implementations, so disabled by default. - * @type {Boolean} - * @default false - */ - domEvents: false, - /** - * The value for the touchAction property/fallback. - * When set to `compute` it will magically set the correct value based on the added recognizers. - * @type {String} - * @default compute - */ - touchAction: TOUCH_ACTION_COMPUTE, - /** - * @type {Boolean} - * @default true - */ - enable: true, - /** - * EXPERIMENTAL FEATURE -- can be removed/changed - * Change the parent input target element. - * If Null, then it is being set the to main element. - * @type {Null|EventTarget} - * @default null - */ - inputTarget: null, - /** - * force an input class - * @type {Null|Function} - * @default null - */ - inputClass: null, - /** - * Default recognizer setup when calling `Hammer()` - * When creating a new Manager these will be skipped. - * @type {Array} - */ - preset: [ - // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...] - [RotateRecognizer, { enable: false }], - [PinchRecognizer, { enable: false }, ["rotate"]], - [SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }], - [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ["swipe"]], - [TapRecognizer], - [TapRecognizer, { event: "doubletap", taps: 2 }, ["tap"]], - [PressRecognizer] - ], - /** - * Some CSS properties can be used to improve the working of Hammer. - * Add them to this method and they will be set when creating a new Manager. - * @namespace - */ - cssProps: { - /** - * Disables text selection to improve the dragging gesture. Mainly for desktop browsers. - * @type {String} - * @default 'none' - */ - userSelect: "none", - /** - * Disable the Windows Phone grippers when pressing an element. - * @type {String} - * @default 'none' - */ - touchSelect: "none", - /** - * Disables the default callout shown when you touch and hold a touch target. - * On iOS, when you touch and hold a touch target such as a link, Safari displays - * a callout containing information about the link. This property allows you to disable that callout. - * @type {String} - * @default 'none' - */ - touchCallout: "none", - /** - * Specifies whether zooming is enabled. Used by IE10> - * @type {String} - * @default 'none' - */ - contentZooming: "none", - /** - * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers. - * @type {String} - * @default 'none' - */ - userDrag: "none", - /** - * Overrides the highlight color shown when the user taps a link or a JavaScript - * clickable element in iOS. This property obeys the alpha value, if specified. - * @type {String} - * @default 'rgba(0,0,0,0)' - */ - tapHighlightColor: "rgba(0,0,0,0)" - } - }; - var STOP = 1; - var FORCED_STOP = 2; - function Manager3(element, options) { - this.options = assign({}, Hammer.defaults, options || {}); - this.options.inputTarget = this.options.inputTarget || element; - this.handlers = {}; - this.session = {}; - this.recognizers = []; - this.oldCssProps = {}; - this.element = element; - this.input = createInputInstance(this); - this.touchAction = new TouchAction(this, this.options.touchAction); - toggleCssProps(this, true); - each(this.options.recognizers, function(item) { - var recognizer = this.add(new item[0](item[1])); - item[2] && recognizer.recognizeWith(item[2]); - item[3] && recognizer.requireFailure(item[3]); - }, this); - } - Manager3.prototype = { - /** - * set options - * @param {Object} options - * @returns {Manager} - */ - set: function(options) { - assign(this.options, options); - if (options.touchAction) { - this.touchAction.update(); - } - if (options.inputTarget) { - this.input.destroy(); - this.input.target = options.inputTarget; - this.input.init(); - } - return this; - }, - /** - * stop recognizing for this session. - * This session will be discarded, when a new [input]start event is fired. - * When forced, the recognizer cycle is stopped immediately. - * @param {Boolean} [force] - */ - stop: function(force) { - this.session.stopped = force ? FORCED_STOP : STOP; - }, - /** - * run the recognizers! - * called by the inputHandler function on every movement of the pointers (touches) - * it walks through all the recognizers and tries to detect the gesture that is being made - * @param {Object} inputData - */ - recognize: function(inputData) { - var session = this.session; - if (session.stopped) { - return; - } - this.touchAction.preventDefaults(inputData); - var recognizer; - var recognizers = this.recognizers; - var curRecognizer = session.curRecognizer; - if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) { - curRecognizer = session.curRecognizer = null; - } - var i = 0; - while (i < recognizers.length) { - recognizer = recognizers[i]; - if (session.stopped !== FORCED_STOP && // 1 - (!curRecognizer || recognizer == curRecognizer || // 2 - recognizer.canRecognizeWith(curRecognizer))) { - recognizer.recognize(inputData); - } else { - recognizer.reset(); - } - if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) { - curRecognizer = session.curRecognizer = recognizer; - } - i++; - } - }, - /** - * get a recognizer by its event name. - * @param {Recognizer|String} recognizer - * @returns {Recognizer|Null} - */ - get: function(recognizer) { - if (recognizer instanceof Recognizer) { - return recognizer; - } - var recognizers = this.recognizers; - for (var i = 0; i < recognizers.length; i++) { - if (recognizers[i].options.event == recognizer) { - return recognizers[i]; - } - } - return null; - }, - /** - * add a recognizer to the manager - * existing recognizers with the same event name will be removed - * @param {Recognizer} recognizer - * @returns {Recognizer|Manager} - */ - add: function(recognizer) { - if (invokeArrayArg(recognizer, "add", this)) { - return this; - } - var existing = this.get(recognizer.options.event); - if (existing) { - this.remove(existing); - } - this.recognizers.push(recognizer); - recognizer.manager = this; - this.touchAction.update(); - return recognizer; - }, - /** - * remove a recognizer by name or instance - * @param {Recognizer|String} recognizer - * @returns {Manager} - */ - remove: function(recognizer) { - if (invokeArrayArg(recognizer, "remove", this)) { - return this; - } - recognizer = this.get(recognizer); - if (recognizer) { - var recognizers = this.recognizers; - var index2 = inArray(recognizers, recognizer); - if (index2 !== -1) { - recognizers.splice(index2, 1); - this.touchAction.update(); - } - } - return this; - }, - /** - * bind event - * @param {String} events - * @param {Function} handler - * @returns {EventEmitter} this - */ - on: function(events, handler) { - if (events === undefined2) { - return; - } - if (handler === undefined2) { - return; - } - var handlers = this.handlers; - each(splitStr(events), function(event) { - handlers[event] = handlers[event] || []; - handlers[event].push(handler); - }); - return this; - }, - /** - * unbind event, leave emit blank to remove all handlers - * @param {String} events - * @param {Function} [handler] - * @returns {EventEmitter} this - */ - off: function(events, handler) { - if (events === undefined2) { - return; - } - var handlers = this.handlers; - each(splitStr(events), function(event) { - if (!handler) { - delete handlers[event]; - } else { - handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1); - } - }); - return this; - }, - /** - * emit event to the listeners - * @param {String} event - * @param {Object} data - */ - emit: function(event, data) { - if (this.options.domEvents) { - triggerDomEvent(event, data); - } - var handlers = this.handlers[event] && this.handlers[event].slice(); - if (!handlers || !handlers.length) { - return; - } - data.type = event; - data.preventDefault = function() { - data.srcEvent.preventDefault(); - }; - var i = 0; - while (i < handlers.length) { - handlers[i](data); - i++; - } - }, - /** - * destroy the manager and unbinds all events - * it doesn't unbind dom events, that is the user own responsibility - */ - destroy: function() { - this.element && toggleCssProps(this, false); - this.handlers = {}; - this.session = {}; - this.input.destroy(); - this.element = null; - } - }; - function toggleCssProps(manager, add13) { - var element = manager.element; - if (!element.style) { - return; - } - var prop; - each(manager.options.cssProps, function(value, name2) { - prop = prefixed(element.style, name2); - if (add13) { - manager.oldCssProps[prop] = element.style[prop]; - element.style[prop] = value; - } else { - element.style[prop] = manager.oldCssProps[prop] || ""; - } - }); - if (!add13) { - manager.oldCssProps = {}; - } - } - function triggerDomEvent(event, data) { - var gestureEvent = document2.createEvent("Event"); - gestureEvent.initEvent(event, true, true); - gestureEvent.gesture = data; - data.target.dispatchEvent(gestureEvent); - } - assign(Hammer, { - INPUT_START: INPUT_START2, - INPUT_MOVE: INPUT_MOVE2, - INPUT_END: INPUT_END2, - INPUT_CANCEL, - STATE_POSSIBLE, - STATE_BEGAN, - STATE_CHANGED, - STATE_ENDED, - STATE_RECOGNIZED, - STATE_CANCELLED, - STATE_FAILED, - DIRECTION_NONE, - DIRECTION_LEFT, - DIRECTION_RIGHT, - DIRECTION_UP, - DIRECTION_DOWN, - DIRECTION_HORIZONTAL, - DIRECTION_VERTICAL, - DIRECTION_ALL, - Manager: Manager3, - Input: Input2, - TouchAction, - TouchInput, - MouseInput: MouseInput2, - PointerEventInput: PointerEventInput2, - TouchMouseInput, - SingleTouchInput, - Recognizer, - AttrRecognizer, - Tap: TapRecognizer, - Pan: PanRecognizer, - Swipe: SwipeRecognizer, - Pinch: PinchRecognizer, - Rotate: RotateRecognizer, - Press: PressRecognizer, - on: addEventListeners, - off: removeEventListeners, - each, - merge, - extend, - assign, - inherit, - bindFn, - prefixed - }); - var freeGlobal = typeof window2 !== "undefined" ? window2 : typeof self !== "undefined" ? self : {}; - freeGlobal.Hammer = Hammer; - if (typeof define === "function" && define.amd) { - define(function() { - return Hammer; - }); - } else if (typeof module != "undefined" && module.exports) { - module.exports = Hammer; - } else { - window2[exportName] = Hammer; - } - })(window, document, "Hammer"); - } -}); - -// node_modules/earcut/src/earcut.js -var require_earcut = __commonJS({ - "node_modules/earcut/src/earcut.js"(exports, module) { - "use strict"; - module.exports = earcut3; - module.exports.default = earcut3; - function earcut3(data, holeIndices, dim) { - dim = dim || 2; - var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = []; - if (!outerNode || outerNode.next === outerNode.prev) - return triangles; - var minX, minY, maxX, maxY, x, y, invSize; - if (hasHoles) - outerNode = eliminateHoles(data, holeIndices, outerNode, dim); - if (data.length > 80 * dim) { - minX = maxX = data[0]; - minY = maxY = data[1]; - for (var i = dim; i < outerLen; i += dim) { - x = data[i]; - y = data[i + 1]; - if (x < minX) - minX = x; - if (y < minY) - minY = y; - if (x > maxX) - maxX = x; - if (y > maxY) - maxY = y; - } - invSize = Math.max(maxX - minX, maxY - minY); - invSize = invSize !== 0 ? 32767 / invSize : 0; - } - earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0); - return triangles; - } - function linkedList(data, start, end, dim, clockwise) { - var i, last; - if (clockwise === signedArea(data, start, end, dim) > 0) { - for (i = start; i < end; i += dim) - last = insertNode(i, data[i], data[i + 1], last); - } else { - for (i = end - dim; i >= start; i -= dim) - last = insertNode(i, data[i], data[i + 1], last); - } - if (last && equals12(last, last.next)) { - removeNode(last); - last = last.next; - } - return last; - } - function filterPoints(start, end) { - if (!start) - return start; - if (!end) - end = start; - var p = start, again; - do { - again = false; - if (!p.steiner && (equals12(p, p.next) || area(p.prev, p, p.next) === 0)) { - removeNode(p); - p = end = p.prev; - if (p === p.next) - break; - again = true; - } else { - p = p.next; - } - } while (again || p !== end); - return end; - } - function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) { - if (!ear) - return; - if (!pass && invSize) - indexCurve(ear, minX, minY, invSize); - var stop = ear, prev, next; - while (ear.prev !== ear.next) { - prev = ear.prev; - next = ear.next; - if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) { - triangles.push(prev.i / dim | 0); - triangles.push(ear.i / dim | 0); - triangles.push(next.i / dim | 0); - removeNode(ear); - ear = next.next; - stop = next.next; - continue; - } - ear = next; - if (ear === stop) { - if (!pass) { - earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1); - } else if (pass === 1) { - ear = cureLocalIntersections(filterPoints(ear), triangles, dim); - earcutLinked(ear, triangles, dim, minX, minY, invSize, 2); - } else if (pass === 2) { - splitEarcut(ear, triangles, dim, minX, minY, invSize); - } - break; - } - } - } - function isEar(ear) { - var a = ear.prev, b = ear, c = ear.next; - if (area(a, b, c) >= 0) - return false; - var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; - var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; - var p = c.next; - while (p !== a) { - if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) - return false; - p = p.next; - } - return true; - } - function isEarHashed(ear, minX, minY, invSize) { - var a = ear.prev, b = ear, c = ear.next; - if (area(a, b, c) >= 0) - return false; - var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; - var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; - var minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize); - var p = ear.prevZ, n = ear.nextZ; - while (p && p.z >= minZ && n && n.z <= maxZ) { - if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) - return false; - p = p.prevZ; - if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) - return false; - n = n.nextZ; - } - while (p && p.z >= minZ) { - if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) - return false; - p = p.prevZ; - } - while (n && n.z <= maxZ) { - if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) - return false; - n = n.nextZ; - } - return true; - } - function cureLocalIntersections(start, triangles, dim) { - var p = start; - do { - var a = p.prev, b = p.next.next; - if (!equals12(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) { - triangles.push(a.i / dim | 0); - triangles.push(p.i / dim | 0); - triangles.push(b.i / dim | 0); - removeNode(p); - removeNode(p.next); - p = start = b; - } - p = p.next; - } while (p !== start); - return filterPoints(p); - } - function splitEarcut(start, triangles, dim, minX, minY, invSize) { - var a = start; - do { - var b = a.next.next; - while (b !== a.prev) { - if (a.i !== b.i && isValidDiagonal(a, b)) { - var c = splitPolygon(a, b); - a = filterPoints(a, a.next); - c = filterPoints(c, c.next); - earcutLinked(a, triangles, dim, minX, minY, invSize, 0); - earcutLinked(c, triangles, dim, minX, minY, invSize, 0); - return; - } - b = b.next; - } - a = a.next; - } while (a !== start); - } - function eliminateHoles(data, holeIndices, outerNode, dim) { - var queue = [], i, len8, start, end, list; - for (i = 0, len8 = holeIndices.length; i < len8; i++) { - start = holeIndices[i] * dim; - end = i < len8 - 1 ? holeIndices[i + 1] * dim : data.length; - list = linkedList(data, start, end, dim, false); - if (list === list.next) - list.steiner = true; - queue.push(getLeftmost(list)); - } - queue.sort(compareX); - for (i = 0; i < queue.length; i++) { - outerNode = eliminateHole(queue[i], outerNode); - } - return outerNode; - } - function compareX(a, b) { - return a.x - b.x; - } - function eliminateHole(hole, outerNode) { - var bridge = findHoleBridge(hole, outerNode); - if (!bridge) { - return outerNode; - } - var bridgeReverse = splitPolygon(bridge, hole); - filterPoints(bridgeReverse, bridgeReverse.next); - return filterPoints(bridge, bridge.next); - } - function findHoleBridge(hole, outerNode) { - var p = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m; - do { - if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) { - var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y); - if (x <= hx && x > qx) { - qx = x; - m = p.x < p.next.x ? p : p.next; - if (x === hx) - return m; - } - } - p = p.next; - } while (p !== outerNode); - if (!m) - return null; - var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan3; - p = m; - do { - if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) { - tan3 = Math.abs(hy - p.y) / (hx - p.x); - if (locallyInside(p, hole) && (tan3 < tanMin || tan3 === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) { - m = p; - tanMin = tan3; - } - } - p = p.next; - } while (p !== stop); - return m; - } - function sectorContainsSector(m, p) { - return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0; - } - function indexCurve(start, minX, minY, invSize) { - var p = start; - do { - if (p.z === 0) - p.z = zOrder(p.x, p.y, minX, minY, invSize); - p.prevZ = p.prev; - p.nextZ = p.next; - p = p.next; - } while (p !== start); - p.prevZ.nextZ = null; - p.prevZ = null; - sortLinked(p); - } - function sortLinked(list) { - var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1; - do { - p = list; - list = null; - tail = null; - numMerges = 0; - while (p) { - numMerges++; - q = p; - pSize = 0; - for (i = 0; i < inSize; i++) { - pSize++; - q = q.nextZ; - if (!q) - break; - } - qSize = inSize; - while (pSize > 0 || qSize > 0 && q) { - if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) { - e = p; - p = p.nextZ; - pSize--; - } else { - e = q; - q = q.nextZ; - qSize--; - } - if (tail) - tail.nextZ = e; - else - list = e; - e.prevZ = tail; - tail = e; - } - p = q; - } - tail.nextZ = null; - inSize *= 2; - } while (numMerges > 1); - return list; - } - function zOrder(x, y, minX, minY, invSize) { - x = (x - minX) * invSize | 0; - y = (y - minY) * invSize | 0; - x = (x | x << 8) & 16711935; - x = (x | x << 4) & 252645135; - x = (x | x << 2) & 858993459; - x = (x | x << 1) & 1431655765; - y = (y | y << 8) & 16711935; - y = (y | y << 4) & 252645135; - y = (y | y << 2) & 858993459; - y = (y | y << 1) & 1431655765; - return x | y << 1; - } - function getLeftmost(start) { - var p = start, leftmost = start; - do { - if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) - leftmost = p; - p = p.next; - } while (p !== start); - return leftmost; - } - function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) { - return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py); - } - function isValidDiagonal(a, b) { - return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges - (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible - (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors - equals12(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); - } - function area(p, q, r) { - return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y); - } - function equals12(p1, p2) { - return p1.x === p2.x && p1.y === p2.y; - } - function intersects(p1, q1, p2, q2) { - var o1 = sign(area(p1, q1, p2)); - var o2 = sign(area(p1, q1, q2)); - var o3 = sign(area(p2, q2, p1)); - var o4 = sign(area(p2, q2, q1)); - if (o1 !== o2 && o3 !== o4) - return true; - if (o1 === 0 && onSegment(p1, p2, q1)) - return true; - if (o2 === 0 && onSegment(p1, q2, q1)) - return true; - if (o3 === 0 && onSegment(p2, p1, q2)) - return true; - if (o4 === 0 && onSegment(p2, q1, q2)) - return true; - return false; - } - function onSegment(p, q, r) { - return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y); - } - function sign(num) { - return num > 0 ? 1 : num < 0 ? -1 : 0; - } - function intersectsPolygon(a, b) { - var p = a; - do { - if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) - return true; - p = p.next; - } while (p !== a); - return false; - } - function locallyInside(a, b) { - return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0; - } - function middleInside(a, b) { - var p = a, inside = false, px = (a.x + b.x) / 2, py = (a.y + b.y) / 2; - do { - if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) - inside = !inside; - p = p.next; - } while (p !== a); - return inside; - } - function splitPolygon(a, b) { - var a2 = new Node2(a.i, a.x, a.y), b2 = new Node2(b.i, b.x, b.y), an = a.next, bp = b.prev; - a.next = b; - b.prev = a; - a2.next = an; - an.prev = a2; - b2.next = a2; - a2.prev = b2; - bp.next = b2; - b2.prev = bp; - return b2; - } - function insertNode(i, x, y, last) { - var p = new Node2(i, x, y); - if (!last) { - p.prev = p; - p.next = p; - } else { - p.next = last.next; - p.prev = last; - last.next.prev = p; - last.next = p; - } - return p; - } - function removeNode(p) { - p.next.prev = p.prev; - p.prev.next = p.next; - if (p.prevZ) - p.prevZ.nextZ = p.nextZ; - if (p.nextZ) - p.nextZ.prevZ = p.prevZ; - } - function Node2(i, x, y) { - this.i = i; - this.x = x; - this.y = y; - this.prev = null; - this.next = null; - this.z = 0; - this.prevZ = null; - this.nextZ = null; - this.steiner = false; - } - earcut3.deviation = function(data, holeIndices, dim, triangles) { - var hasHoles = holeIndices && holeIndices.length; - var outerLen = hasHoles ? holeIndices[0] * dim : data.length; - var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim)); - if (hasHoles) { - for (var i = 0, len8 = holeIndices.length; i < len8; i++) { - var start = holeIndices[i] * dim; - var end = i < len8 - 1 ? holeIndices[i + 1] * dim : data.length; - polygonArea -= Math.abs(signedArea(data, start, end, dim)); - } - } - var trianglesArea = 0; - for (i = 0; i < triangles.length; i += 3) { - var a = triangles[i] * dim; - var b = triangles[i + 1] * dim; - var c = triangles[i + 2] * dim; - trianglesArea += Math.abs( - (data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1]) - ); - } - return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea); - }; - function signedArea(data, start, end, dim) { - var sum = 0; - for (var i = start, j = end - dim; i < end; i += dim) { - sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]); - j = i; - } - return sum; - } - earcut3.flatten = function(data) { - var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0; - for (var i = 0; i < data.length; i++) { - for (var j = 0; j < data[i].length; j++) { - for (var d = 0; d < dim; d++) - result.vertices.push(data[i][j][d]); - } - if (i > 0) { - holeIndex += data[i - 1].length; - result.holes.push(holeIndex); - } - } - return result; - }; - } -}); - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js -function assert(condition, message2) { - if (!condition) { - throw new Error(message2 || "loader assertion failed."); - } -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js -var globals = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document -}; -var self_ = globals.self || globals.window || globals.global || {}; -var window_ = globals.window || globals.self || globals.global || {}; -var global_ = globals.global || globals.self || globals.window || {}; -var document_ = globals.document || {}; -var isBrowser = ( - // @ts-ignore process does not exist on browser - Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser) -); -var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); -var nodeVersion = matches && parseFloat(matches[1]) || 0; - -// node_modules/@probe.gl/env/dist/lib/globals.js -var window_2 = globalThis; -var document_2 = globalThis.document || {}; -var process_ = globalThis.process || {}; -var console_ = globalThis.console; -var navigator_ = globalThis.navigator || {}; - -// node_modules/@probe.gl/env/dist/lib/is-electron.js -function isElectron(mockUserAgent) { - if (typeof window !== "undefined" && window.process?.type === "renderer") { - return true; - } - if (typeof process !== "undefined" && Boolean(process.versions?.["electron"])) { - return true; - } - const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent; - const userAgent2 = mockUserAgent || realUserAgent; - return Boolean(userAgent2 && userAgent2.indexOf("Electron") >= 0); -} - -// node_modules/@probe.gl/env/dist/lib/is-browser.js -function isBrowser2() { - const isNode = ( - // @ts-expect-error - typeof process === "object" && String(process) === "[object process]" && !process?.browser - ); - return !isNode || isElectron(); -} - -// node_modules/@probe.gl/env/dist/lib/get-browser.js -function getBrowser(mockUserAgent) { - if (!mockUserAgent && !isBrowser2()) { - return "Node"; - } - if (isElectron(mockUserAgent)) { - return "Electron"; - } - const userAgent2 = mockUserAgent || navigator_.userAgent || ""; - if (userAgent2.indexOf("Edge") > -1) { - return "Edge"; - } - if (globalThis.chrome) { - return "Chrome"; - } - if (globalThis.safari) { - return "Safari"; - } - if (globalThis.mozInnerScreenX) { - return "Firefox"; - } - return "Unknown"; -} - -// node_modules/@probe.gl/env/dist/index.js -var VERSION = true ? "4.0.7" : "untranspiled source"; - -// node_modules/@probe.gl/log/dist/utils/local-storage.js -function getStorage(type) { - try { - const storage = window[type]; - const x = "__storage_test__"; - storage.setItem(x, x); - storage.removeItem(x); - return storage; - } catch (e) { - return null; - } -} -var LocalStorage = class { - constructor(id, defaultConfig, type = "sessionStorage") { - this.storage = getStorage(type); - this.id = id; - this.config = defaultConfig; - this._loadConfiguration(); - } - getConfiguration() { - return this.config; - } - setConfiguration(configuration) { - Object.assign(this.config, configuration); - if (this.storage) { - const serialized = JSON.stringify(this.config); - this.storage.setItem(this.id, serialized); - } - } - // Get config from persistent store, if available - _loadConfiguration() { - let configuration = {}; - if (this.storage) { - const serializedConfiguration = this.storage.getItem(this.id); - configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; - } - Object.assign(this.config, configuration); - return this; - } -}; - -// node_modules/@probe.gl/log/dist/utils/formatters.js -function formatTime(ms) { - let formatted; - if (ms < 10) { - formatted = `${ms.toFixed(2)}ms`; - } else if (ms < 100) { - formatted = `${ms.toFixed(1)}ms`; - } else if (ms < 1e3) { - formatted = `${ms.toFixed(0)}ms`; - } else { - formatted = `${(ms / 1e3).toFixed(2)}s`; - } - return formatted; -} -function leftPad(string, length10 = 8) { - const padLength = Math.max(length10 - string.length, 0); - return `${" ".repeat(padLength)}${string}`; -} - -// node_modules/@probe.gl/log/dist/utils/color.js -var COLOR; -(function(COLOR2) { - COLOR2[COLOR2["BLACK"] = 30] = "BLACK"; - COLOR2[COLOR2["RED"] = 31] = "RED"; - COLOR2[COLOR2["GREEN"] = 32] = "GREEN"; - COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW"; - COLOR2[COLOR2["BLUE"] = 34] = "BLUE"; - COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA"; - COLOR2[COLOR2["CYAN"] = 36] = "CYAN"; - COLOR2[COLOR2["WHITE"] = 37] = "WHITE"; - COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; - COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED"; - COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; - COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; - COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; - COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; - COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; - COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; -})(COLOR || (COLOR = {})); -var BACKGROUND_INCREMENT = 10; -function getColor(color) { - if (typeof color !== "string") { - return color; - } - color = color.toUpperCase(); - return COLOR[color] || COLOR.WHITE; -} -function addColor(string, color, background) { - if (!isBrowser2 && typeof string === "string") { - if (color) { - const colorCode = getColor(color); - string = `\x1B[${colorCode}m${string}\x1B[39m`; - } - if (background) { - const colorCode = getColor(background); - string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`; - } - } - return string; -} - -// node_modules/@probe.gl/log/dist/utils/autobind.js -function autobind(obj, predefined = ["constructor"]) { - const proto = Object.getPrototypeOf(obj); - const propNames = Object.getOwnPropertyNames(proto); - const object = obj; - for (const key of propNames) { - const value = object[key]; - if (typeof value === "function") { - if (!predefined.find((name2) => key === name2)) { - object[key] = value.bind(obj); - } - } - } -} - -// node_modules/@probe.gl/log/dist/utils/assert.js -function assert2(condition, message2) { - if (!condition) { - throw new Error(message2 || "Assertion failed"); - } -} - -// node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js -function getHiResTimestamp() { - let timestamp; - if (isBrowser2() && window_2.performance) { - timestamp = window_2?.performance?.now?.(); - } else if ("hrtime" in process_) { - const timeParts = process_?.hrtime?.(); - timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; - } else { - timestamp = Date.now(); - } - return timestamp; -} - -// node_modules/@probe.gl/log/dist/log.js -var originalConsole = { - debug: isBrowser2() ? console.debug || console.log : console.log, - log: console.log, - info: console.info, - warn: console.warn, - error: console.error -}; -var DEFAULT_LOG_CONFIGURATION = { - enabled: true, - level: 0 -}; -function noop() { -} -var cache = {}; -var ONCE = { once: true }; -var Log = class { - constructor({ id } = { id: "" }) { - this.VERSION = VERSION; - this._startTs = getHiResTimestamp(); - this._deltaTs = getHiResTimestamp(); - this.userData = {}; - this.LOG_THROTTLE_TIMEOUT = 0; - this.id = id; - this.userData = {}; - this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION); - this.timeStamp(`${this.id} started`); - autobind(this); - Object.seal(this); - } - set level(newLevel) { - this.setLevel(newLevel); - } - get level() { - return this.getLevel(); - } - isEnabled() { - return this._storage.config.enabled; - } - getLevel() { - return this._storage.config.level; - } - /** @return milliseconds, with fractions */ - getTotal() { - return Number((getHiResTimestamp() - this._startTs).toPrecision(10)); - } - /** @return milliseconds, with fractions */ - getDelta() { - return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10)); - } - /** @deprecated use logLevel */ - set priority(newPriority) { - this.level = newPriority; - } - /** @deprecated use logLevel */ - get priority() { - return this.level; - } - /** @deprecated use logLevel */ - getPriority() { - return this.level; - } - // Configure - enable(enabled = true) { - this._storage.setConfiguration({ enabled }); - return this; - } - setLevel(level) { - this._storage.setConfiguration({ level }); - return this; - } - /** return the current status of the setting */ - get(setting) { - return this._storage.config[setting]; - } - // update the status of the setting - set(setting, value) { - this._storage.setConfiguration({ [setting]: value }); - } - /** Logs the current settings as a table */ - settings() { - if (console.table) { - console.table(this._storage.config); - } else { - console.log(this._storage.config); - } - } - // Unconditional logging - assert(condition, message2) { - if (!condition) { - throw new Error(message2 || "Assertion failed"); - } - } - warn(message2) { - return this._getLogFunction(0, message2, originalConsole.warn, arguments, ONCE); - } - error(message2) { - return this._getLogFunction(0, message2, originalConsole.error, arguments); - } - /** Print a deprecation warning */ - deprecated(oldUsage, newUsage) { - return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`); - } - /** Print a removal warning */ - removed(oldUsage, newUsage) { - return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`); - } - probe(logLevel, message2) { - return this._getLogFunction(logLevel, message2, originalConsole.log, arguments, { - time: true, - once: true - }); - } - log(logLevel, message2) { - return this._getLogFunction(logLevel, message2, originalConsole.debug, arguments); - } - info(logLevel, message2) { - return this._getLogFunction(logLevel, message2, console.info, arguments); - } - once(logLevel, message2) { - return this._getLogFunction(logLevel, message2, originalConsole.debug || originalConsole.info, arguments, ONCE); - } - /** Logs an object as a table */ - table(logLevel, table, columns) { - if (table) { - return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], { - tag: getTableHeader(table) - }); - } - return noop; - } - time(logLevel, message2) { - return this._getLogFunction(logLevel, message2, console.time ? console.time : console.info); - } - timeEnd(logLevel, message2) { - return this._getLogFunction(logLevel, message2, console.timeEnd ? console.timeEnd : console.info); - } - timeStamp(logLevel, message2) { - return this._getLogFunction(logLevel, message2, console.timeStamp || noop); - } - group(logLevel, message2, opts = { collapsed: false }) { - const options = normalizeArguments({ logLevel, message: message2, opts }); - const { collapsed } = opts; - options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; - return this._getLogFunction(options); - } - groupCollapsed(logLevel, message2, opts = {}) { - return this.group(logLevel, message2, Object.assign({}, opts, { collapsed: true })); - } - groupEnd(logLevel) { - return this._getLogFunction(logLevel, "", console.groupEnd || noop); - } - // EXPERIMENTAL - withGroup(logLevel, message2, func) { - this.group(logLevel, message2)(); - try { - func(); - } finally { - this.groupEnd(logLevel)(); - } - } - trace() { - if (console.trace) { - console.trace(); - } - } - // PRIVATE METHODS - /** Deduces log level from a variety of arguments */ - _shouldLog(logLevel) { - return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel); - } - _getLogFunction(logLevel, message2, method, args, opts) { - if (this._shouldLog(logLevel)) { - opts = normalizeArguments({ logLevel, message: message2, args, opts }); - method = method || opts.method; - assert2(method); - opts.total = this.getTotal(); - opts.delta = this.getDelta(); - this._deltaTs = getHiResTimestamp(); - const tag = opts.tag || opts.message; - if (opts.once && tag) { - if (!cache[tag]) { - cache[tag] = getHiResTimestamp(); - } else { - return noop; - } - } - message2 = decorateMessage(this.id, opts.message, opts); - return method.bind(console, message2, ...opts.args); - } - return noop; - } -}; -Log.VERSION = VERSION; -function normalizeLogLevel(logLevel) { - if (!logLevel) { - return 0; - } - let resolvedLevel; - switch (typeof logLevel) { - case "number": - resolvedLevel = logLevel; - break; - case "object": - resolvedLevel = logLevel.logLevel || logLevel.priority || 0; - break; - default: - return 0; - } - assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); - return resolvedLevel; -} -function normalizeArguments(opts) { - const { logLevel, message: message2 } = opts; - opts.logLevel = normalizeLogLevel(logLevel); - const args = opts.args ? Array.from(opts.args) : []; - while (args.length && args.shift() !== message2) { - } - switch (typeof logLevel) { - case "string": - case "function": - if (message2 !== void 0) { - args.unshift(message2); - } - opts.message = logLevel; - break; - case "object": - Object.assign(opts, logLevel); - break; - default: - } - if (typeof opts.message === "function") { - opts.message = opts.message(); - } - const messageType = typeof opts.message; - assert2(messageType === "string" || messageType === "object"); - return Object.assign(opts, { args }, opts.opts); -} -function decorateMessage(id, message2, opts) { - if (typeof message2 === "string") { - const time = opts.time ? leftPad(formatTime(opts.total)) : ""; - message2 = opts.time ? `${id}: ${time} ${message2}` : `${id}: ${message2}`; - message2 = addColor(message2, opts.color, opts.background); - } - return message2; -} -function getTableHeader(table) { - for (const key in table) { - for (const title in table[key]) { - return title || "untitled"; - } - } - return "empty"; -} - -// node_modules/@probe.gl/log/dist/init.js -globalThis.probe = {}; - -// node_modules/@probe.gl/log/dist/index.js -var dist_default = new Log({ id: "@probe.gl/log" }); - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/log-utils/log.js -var VERSION2 = true ? "4.3.1" : "latest"; -var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : ""; -function createLog() { - const log4 = new Log({ id: "loaders.gl" }); - globalThis.loaders = globalThis.loaders || {}; - globalThis.loaders.log = log4; - globalThis.loaders.version = version; - globalThis.probe = globalThis.probe || {}; - globalThis.probe.loaders = log4; - return log4; -} -var log = createLog(); - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/option-utils/merge-loader-options.js -function mergeLoaderOptions(baseOptions, newOptions) { - return mergeOptionsRecursively(baseOptions || {}, newOptions); -} -function mergeOptionsRecursively(baseOptions, newOptions, level = 0) { - if (level > 3) { - return newOptions; - } - const options = { ...baseOptions }; - for (const [key, newValue] of Object.entries(newOptions)) { - if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) { - options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key], level + 1); - } else { - options[key] = newOptions[key]; - } - } - return options; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/version.js -var NPM_TAG = "latest"; -function getVersion() { - if (!globalThis._loadersgl_?.version) { - globalThis._loadersgl_ = globalThis._loadersgl_ || {}; - if (false) { - console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."); - globalThis._loadersgl_.version = NPM_TAG; - } else { - globalThis._loadersgl_.version = "4.3.1"; - } - } - return globalThis._loadersgl_.version; -} -var VERSION3 = getVersion(); - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/assert.js -function assert3(condition, message2) { - if (!condition) { - throw new Error(message2 || "loaders.gl assertion failed."); - } -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/globals.js -var globals2 = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document -}; -var self_2 = globals2.self || globals2.window || globals2.global || {}; -var window_3 = globals2.window || globals2.self || globals2.global || {}; -var global_3 = globals2.global || globals2.self || globals2.window || {}; -var document_3 = globals2.document || {}; -var isBrowser3 = ( - // @ts-ignore process.browser - typeof process !== "object" || String(process) !== "[object process]" || process.browser -); -var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined"; -var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); -var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-job.js -var WorkerJob = class { - name; - workerThread; - isRunning = true; - /** Promise that resolves when Job is done */ - result; - _resolve = () => { - }; - _reject = () => { - }; - constructor(jobName, workerThread) { - this.name = jobName; - this.workerThread = workerThread; - this.result = new Promise((resolve2, reject) => { - this._resolve = resolve2; - this._reject = reject; - }); - } - /** - * Send a message to the job's worker thread - * @param data any data structure, ideally consisting mostly of transferrable objects - */ - postMessage(type, payload) { - this.workerThread.postMessage({ - source: "loaders.gl", - // Lets worker ignore unrelated messages - type, - payload - }); - } - /** - * Call to resolve the `result` Promise with the supplied value - */ - done(value) { - assert3(this.isRunning); - this.isRunning = false; - this._resolve(value); - } - /** - * Call to reject the `result` Promise with the supplied error - */ - error(error) { - assert3(this.isRunning); - this.isRunning = false; - this._reject(error); - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/node/worker_threads-browser.js -var NodeWorker = class { - terminate() { - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-utils/get-loadable-worker-url.js -var workerURLCache = /* @__PURE__ */ new Map(); -function getLoadableWorkerURL(props) { - assert3(props.source && !props.url || !props.source && props.url); - let workerURL = workerURLCache.get(props.source || props.url); - if (!workerURL) { - if (props.url) { - workerURL = getLoadableWorkerURLFromURL(props.url); - workerURLCache.set(props.url, workerURL); - } - if (props.source) { - workerURL = getLoadableWorkerURLFromSource(props.source); - workerURLCache.set(props.source, workerURL); - } - } - assert3(workerURL); - return workerURL; -} -function getLoadableWorkerURLFromURL(url) { - if (!url.startsWith("http")) { - return url; - } - const workerSource = buildScriptSource(url); - return getLoadableWorkerURLFromSource(workerSource); -} -function getLoadableWorkerURLFromSource(workerSource) { - const blob = new Blob([workerSource], { type: "application/javascript" }); - return URL.createObjectURL(blob); -} -function buildScriptSource(workerUrl) { - return `try { - importScripts('${workerUrl}'); -} catch (error) { - console.error(error); - throw error; -}`; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-utils/get-transfer-list.js -function getTransferList(object, recursive = true, transfers) { - const transfersSet = transfers || /* @__PURE__ */ new Set(); - if (!object) { - } else if (isTransferable(object)) { - transfersSet.add(object); - } else if (isTransferable(object.buffer)) { - transfersSet.add(object.buffer); - } else if (ArrayBuffer.isView(object)) { - } else if (recursive && typeof object === "object") { - for (const key in object) { - getTransferList(object[key], recursive, transfersSet); - } - } - return transfers === void 0 ? Array.from(transfersSet) : []; -} -function isTransferable(object) { - if (!object) { - return false; - } - if (object instanceof ArrayBuffer) { - return true; - } - if (typeof MessagePort !== "undefined" && object instanceof MessagePort) { - return true; - } - if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) { - return true; - } - if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) { - return true; - } - return false; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-thread.js -var NOOP = () => { -}; -var WorkerThread = class { - name; - source; - url; - terminated = false; - worker; - onMessage; - onError; - _loadableURL = ""; - /** Checks if workers are supported on this platform */ - static isSupported() { - return typeof Worker !== "undefined" && isBrowser3 || typeof NodeWorker !== "undefined" && !isBrowser3; - } - constructor(props) { - const { name: name2, source, url } = props; - assert3(source || url); - this.name = name2; - this.source = source; - this.url = url; - this.onMessage = NOOP; - this.onError = (error) => console.log(error); - this.worker = isBrowser3 ? this._createBrowserWorker() : this._createNodeWorker(); - } - /** - * Terminate this worker thread - * @note Can free up significant memory - */ - destroy() { - this.onMessage = NOOP; - this.onError = NOOP; - this.worker.terminate(); - this.terminated = true; - } - get isRunning() { - return Boolean(this.onMessage); - } - /** - * Send a message to this worker thread - * @param data any data structure, ideally consisting mostly of transferrable objects - * @param transferList If not supplied, calculated automatically by traversing data - */ - postMessage(data, transferList) { - transferList = transferList || getTransferList(data); - this.worker.postMessage(data, transferList); - } - // PRIVATE - /** - * Generate a standard Error from an ErrorEvent - * @param event - */ - _getErrorFromErrorEvent(event) { - let message2 = "Failed to load "; - message2 += `worker ${this.name} from ${this.url}. `; - if (event.message) { - message2 += `${event.message} in `; - } - if (event.lineno) { - message2 += `:${event.lineno}:${event.colno}`; - } - return new Error(message2); - } - /** - * Creates a worker thread on the browser - */ - _createBrowserWorker() { - this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url }); - const worker = new Worker(this._loadableURL, { name: this.name }); - worker.onmessage = (event) => { - if (!event.data) { - this.onError(new Error("No data received")); - } else { - this.onMessage(event.data); - } - }; - worker.onerror = (error) => { - this.onError(this._getErrorFromErrorEvent(error)); - this.terminated = true; - }; - worker.onmessageerror = (event) => console.error(event); - return worker; - } - /** - * Creates a worker thread in node.js - * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool - */ - _createNodeWorker() { - let worker; - if (this.url) { - const absolute = this.url.includes(":/") || this.url.startsWith("/"); - const url = absolute ? this.url : `./${this.url}`; - worker = new NodeWorker(url, { eval: false }); - } else if (this.source) { - worker = new NodeWorker(this.source, { eval: true }); - } else { - throw new Error("no worker"); - } - worker.on("message", (data) => { - this.onMessage(data); - }); - worker.on("error", (error) => { - this.onError(error); - }); - worker.on("exit", (code) => { - }); - return worker; - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-pool.js -var WorkerPool = class { - name = "unnamed"; - source; - // | Function; - url; - maxConcurrency = 1; - maxMobileConcurrency = 1; - onDebug = () => { - }; - reuseWorkers = true; - props = {}; - jobQueue = []; - idleQueue = []; - count = 0; - isDestroyed = false; - /** Checks if workers are supported on this platform */ - static isSupported() { - return WorkerThread.isSupported(); - } - /** - * @param processor - worker function - * @param maxConcurrency - max count of workers - */ - constructor(props) { - this.source = props.source; - this.url = props.url; - this.setProps(props); - } - /** - * Terminates all workers in the pool - * @note Can free up significant memory - */ - destroy() { - this.idleQueue.forEach((worker) => worker.destroy()); - this.isDestroyed = true; - } - setProps(props) { - this.props = { ...this.props, ...props }; - if (props.name !== void 0) { - this.name = props.name; - } - if (props.maxConcurrency !== void 0) { - this.maxConcurrency = props.maxConcurrency; - } - if (props.maxMobileConcurrency !== void 0) { - this.maxMobileConcurrency = props.maxMobileConcurrency; - } - if (props.reuseWorkers !== void 0) { - this.reuseWorkers = props.reuseWorkers; - } - if (props.onDebug !== void 0) { - this.onDebug = props.onDebug; - } - } - async startJob(name2, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) { - const startPromise = new Promise((onStart) => { - this.jobQueue.push({ name: name2, onMessage: onMessage2, onError, onStart }); - return this; - }); - this._startQueuedJob(); - return await startPromise; - } - // PRIVATE - /** - * Starts first queued job if worker is available or can be created - * Called when job is started and whenever a worker returns to the idleQueue - */ - async _startQueuedJob() { - if (!this.jobQueue.length) { - return; - } - const workerThread = this._getAvailableWorker(); - if (!workerThread) { - return; - } - const queuedJob = this.jobQueue.shift(); - if (queuedJob) { - this.onDebug({ - message: "Starting job", - name: queuedJob.name, - workerThread, - backlog: this.jobQueue.length - }); - const job = new WorkerJob(queuedJob.name, workerThread); - workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload); - workerThread.onError = (error) => queuedJob.onError(job, error); - queuedJob.onStart(job); - try { - await job.result; - } catch (error) { - console.error(`Worker exception: ${error}`); - } finally { - this.returnWorkerToQueue(workerThread); - } - } - } - /** - * Returns a worker to the idle queue - * Destroys the worker if - * - pool is destroyed - * - if this pool doesn't reuse workers - * - if maxConcurrency has been lowered - * @param worker - */ - returnWorkerToQueue(worker) { - const shouldDestroyWorker = ( - // Workers on Node.js prevent the process from exiting. - // Until we figure out how to close them before exit, we always destroy them - !isBrowser3 || // If the pool is destroyed, there is no reason to keep the worker around - this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed - !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements - this.count > this._getMaxConcurrency() - ); - if (shouldDestroyWorker) { - worker.destroy(); - this.count--; - } else { - this.idleQueue.push(worker); - } - if (!this.isDestroyed) { - this._startQueuedJob(); - } - } - /** - * Returns idle worker or creates new worker if maxConcurrency has not been reached - */ - _getAvailableWorker() { - if (this.idleQueue.length > 0) { - return this.idleQueue.shift() || null; - } - if (this.count < this._getMaxConcurrency()) { - this.count++; - const name2 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`; - return new WorkerThread({ name: name2, source: this.source, url: this.url }); - } - return null; - } - _getMaxConcurrency() { - return isMobile2 ? this.maxMobileConcurrency : this.maxConcurrency; - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-farm/worker-farm.js -var DEFAULT_PROPS = { - maxConcurrency: 3, - maxMobileConcurrency: 1, - reuseWorkers: true, - onDebug: () => { - } -}; -var WorkerFarm = class _WorkerFarm { - props; - workerPools = /* @__PURE__ */ new Map(); - // singleton - static _workerFarm; - /** Checks if workers are supported on this platform */ - static isSupported() { - return WorkerThread.isSupported(); - } - /** Get the singleton instance of the global worker farm */ - static getWorkerFarm(props = {}) { - _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({}); - _WorkerFarm._workerFarm.setProps(props); - return _WorkerFarm._workerFarm; - } - /** get global instance with WorkerFarm.getWorkerFarm() */ - constructor(props) { - this.props = { ...DEFAULT_PROPS }; - this.setProps(props); - this.workerPools = /* @__PURE__ */ new Map(); - } - /** - * Terminate all workers in the farm - * @note Can free up significant memory - */ - destroy() { - for (const workerPool of this.workerPools.values()) { - workerPool.destroy(); - } - this.workerPools = /* @__PURE__ */ new Map(); - } - /** - * Set props used when initializing worker pools - * @param props - */ - setProps(props) { - this.props = { ...this.props, ...props }; - for (const workerPool of this.workerPools.values()) { - workerPool.setProps(this._getWorkerPoolProps()); - } - } - /** - * Returns a worker pool for the specified worker - * @param options - only used first time for a specific worker name - * @param options.name - the name of the worker - used to identify worker pool - * @param options.url - - * @param options.source - - * @example - * const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...); - */ - getWorkerPool(options) { - const { name: name2, source, url } = options; - let workerPool = this.workerPools.get(name2); - if (!workerPool) { - workerPool = new WorkerPool({ - name: name2, - source, - url - }); - workerPool.setProps(this._getWorkerPoolProps()); - this.workerPools.set(name2, workerPool); - } - return workerPool; - } - _getWorkerPoolProps() { - return { - maxConcurrency: this.props.maxConcurrency, - maxMobileConcurrency: this.props.maxMobileConcurrency, - reuseWorkers: this.props.reuseWorkers, - onDebug: this.props.onDebug - }; - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-api/get-worker-url.js -function getWorkerURL(worker, options = {}) { - const workerOptions = options[worker.id] || {}; - const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`; - let url = workerOptions.workerUrl; - if (!url && worker.id === "compression") { - url = options.workerUrl; - } - if (options._workerType === "test") { - if (isBrowser3) { - url = `modules/${worker.module}/dist/${workerFile}`; - } else { - url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`; - } - } - if (!url) { - let version2 = worker.version; - if (version2 === "latest") { - version2 = NPM_TAG; - } - const versionTag = version2 ? `@${version2}` : ""; - url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`; - } - assert3(url); - return url; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/worker-utils/dist/lib/worker-api/validate-worker-version.js -function validateWorkerVersion(worker, coreVersion = VERSION3) { - assert3(worker, "no worker provided"); - const workerVersion = worker.version; - if (!coreVersion || !workerVersion) { - return false; - } - return true; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/worker-loader-utils/parse-with-worker.js -function canParseWithWorker(loader, options) { - if (!WorkerFarm.isSupported()) { - return false; - } - if (!isBrowser3 && !options?._nodeWorkers) { - return false; - } - return loader.worker && options?.worker; -} -async function parseWithWorker(loader, data, options, context, parseOnMainThread) { - const name2 = loader.id; - const url = getWorkerURL(loader, options); - const workerFarm = WorkerFarm.getWorkerFarm(options); - const workerPool = workerFarm.getWorkerPool({ name: name2, url }); - options = JSON.parse(JSON.stringify(options)); - context = JSON.parse(JSON.stringify(context || {})); - const job = await workerPool.startJob( - "process-on-worker", - // @ts-expect-error - onMessage.bind(null, parseOnMainThread) - // eslint-disable-line @typescript-eslint/no-misused-promises - ); - job.postMessage("process", { - // @ts-ignore - input: data, - options, - context - }); - const result = await job.result; - return await result.result; -} -async function onMessage(parseOnMainThread, job, type, payload) { - switch (type) { - case "done": - job.done(payload); - break; - case "error": - job.error(new Error(payload.error)); - break; - case "process": - const { id, input, options } = payload; - try { - const result = await parseOnMainThread(input, options); - job.postMessage("done", { id, result }); - } catch (error) { - const message2 = error instanceof Error ? error.message : "unknown error"; - job.postMessage("error", { id, error: message2 }); - } - break; - default: - console.warn(`parse-with-worker unknown message ${type}`); - } -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/array-buffer-utils.js -function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) { - byteLength = byteLength || arrayBuffer1.byteLength; - if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) { - return false; - } - const array1 = new Uint8Array(arrayBuffer1); - const array2 = new Uint8Array(arrayBuffer2); - for (let i = 0; i < array1.length; ++i) { - if (array1[i] !== array2[i]) { - return false; - } - } - return true; -} -function concatenateArrayBuffers(...sources) { - return concatenateArrayBuffersFromArray(sources); -} -function concatenateArrayBuffersFromArray(sources) { - const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2); - const byteLength = sourceArrays.reduce((length10, typedArray) => length10 + typedArray.byteLength, 0); - const result = new Uint8Array(byteLength); - let offset = 0; - for (const sourceArray of sourceArrays) { - result.set(sourceArray, offset); - offset += sourceArray.byteLength; - } - return result.buffer; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/iterators/async-iteration.js -async function concatenateArrayBuffersAsync(asyncIterator) { - const arrayBuffers = []; - for await (const chunk of asyncIterator) { - arrayBuffers.push(chunk); - } - return concatenateArrayBuffers(...arrayBuffers); -} - -// node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js -function getHiResTimestamp2() { - let timestamp; - if (typeof window !== "undefined" && window.performance) { - timestamp = window.performance.now(); - } else if (typeof process !== "undefined" && process.hrtime) { - const timeParts = process.hrtime(); - timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; - } else { - timestamp = Date.now(); - } - return timestamp; -} - -// node_modules/@probe.gl/stats/dist/lib/stat.js -var Stat = class { - constructor(name2, type) { - this.sampleSize = 1; - this.time = 0; - this.count = 0; - this.samples = 0; - this.lastTiming = 0; - this.lastSampleTime = 0; - this.lastSampleCount = 0; - this._count = 0; - this._time = 0; - this._samples = 0; - this._startTime = 0; - this._timerPending = false; - this.name = name2; - this.type = type; - this.reset(); - } - reset() { - this.time = 0; - this.count = 0; - this.samples = 0; - this.lastTiming = 0; - this.lastSampleTime = 0; - this.lastSampleCount = 0; - this._count = 0; - this._time = 0; - this._samples = 0; - this._startTime = 0; - this._timerPending = false; - return this; - } - setSampleSize(samples) { - this.sampleSize = samples; - return this; - } - /** Call to increment count (+1) */ - incrementCount() { - this.addCount(1); - return this; - } - /** Call to decrement count (-1) */ - decrementCount() { - this.subtractCount(1); - return this; - } - /** Increase count */ - addCount(value) { - this._count += value; - this._samples++; - this._checkSampling(); - return this; - } - /** Decrease count */ - subtractCount(value) { - this._count -= value; - this._samples++; - this._checkSampling(); - return this; - } - /** Add an arbitrary timing and bump the count */ - addTime(time) { - this._time += time; - this.lastTiming = time; - this._samples++; - this._checkSampling(); - return this; - } - /** Start a timer */ - timeStart() { - this._startTime = getHiResTimestamp2(); - this._timerPending = true; - return this; - } - /** End a timer. Adds to time and bumps the timing count. */ - timeEnd() { - if (!this._timerPending) { - return this; - } - this.addTime(getHiResTimestamp2() - this._startTime); - this._timerPending = false; - this._checkSampling(); - return this; - } - getSampleAverageCount() { - return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0; - } - /** Calculate average time / count for the previous window */ - getSampleAverageTime() { - return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0; - } - /** Calculate counts per second for the previous window */ - getSampleHz() { - return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0; - } - getAverageCount() { - return this.samples > 0 ? this.count / this.samples : 0; - } - /** Calculate average time / count */ - getAverageTime() { - return this.samples > 0 ? this.time / this.samples : 0; - } - /** Calculate counts per second */ - getHz() { - return this.time > 0 ? this.samples / (this.time / 1e3) : 0; - } - _checkSampling() { - if (this._samples === this.sampleSize) { - this.lastSampleTime = this._time; - this.lastSampleCount = this._count; - this.count += this._count; - this.time += this._time; - this.samples += this._samples; - this._time = 0; - this._count = 0; - this._samples = 0; - } - } -}; - -// node_modules/@probe.gl/stats/dist/lib/stats.js -var Stats = class { - constructor(options) { - this.stats = {}; - this.id = options.id; - this.stats = {}; - this._initializeStats(options.stats); - Object.seal(this); - } - /** Acquire a stat. Create if it doesn't exist. */ - get(name2, type = "count") { - return this._getOrCreate({ name: name2, type }); - } - get size() { - return Object.keys(this.stats).length; - } - /** Reset all stats */ - reset() { - for (const stat of Object.values(this.stats)) { - stat.reset(); - } - return this; - } - forEach(fn) { - for (const stat of Object.values(this.stats)) { - fn(stat); - } - } - getTable() { - const table = {}; - this.forEach((stat) => { - table[stat.name] = { - time: stat.time || 0, - count: stat.count || 0, - average: stat.getAverageTime() || 0, - hz: stat.getHz() || 0 - }; - }); - return table; - } - _initializeStats(stats = []) { - stats.forEach((stat) => this._getOrCreate(stat)); - } - _getOrCreate(stat) { - const { name: name2, type } = stat; - let result = this.stats[name2]; - if (!result) { - if (stat instanceof Stat) { - result = stat; - } else { - result = new Stat(name2, type); - } - this.stats[name2] = result; - } - return result; - } -}; - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/file-aliases.js -var pathPrefix = ""; -var fileAliases = {}; -function resolvePath(filename2) { - for (const alias in fileAliases) { - if (filename2.startsWith(alias)) { - const replacement = fileAliases[alias]; - filename2 = filename2.replace(alias, replacement); - } - } - if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) { - filename2 = `${pathPrefix}${filename2}`; - } - return filename2; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/node/buffer.browser.js -function toArrayBuffer(buffer) { - return buffer; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/memory-conversion-utils.js -function isBuffer(value) { - return value && typeof value === "object" && value.isBuffer; -} -function toArrayBuffer2(data) { - if (isBuffer(data)) { - return toArrayBuffer(data); - } - if (data instanceof ArrayBuffer) { - return data; - } - if (ArrayBuffer.isView(data)) { - if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) { - return data.buffer; - } - return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength); - } - if (typeof data === "string") { - const text = data; - const uint8Array = new TextEncoder().encode(text); - return uint8Array.buffer; - } - if (data && typeof data === "object" && data._toArrayBuffer) { - return data._toArrayBuffer(); - } - throw new Error("toArrayBuffer"); -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/path.js -var path_exports = {}; -__export(path_exports, { - dirname: () => dirname, - filename: () => filename, - join: () => join, - resolve: () => resolve -}); - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/get-cwd.js -function getCWD() { - if (typeof process !== "undefined" && typeof process.cwd !== "undefined") { - return process.cwd(); - } - const pathname = window.location?.pathname; - return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || ""; -} - -// node_modules/@loaders.gl/core/node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/path.js -function filename(url) { - const slashIndex = url ? url.lastIndexOf("/") : -1; - return slashIndex >= 0 ? url.substr(slashIndex + 1) : ""; -} -function dirname(url) { - const slashIndex = url ? url.lastIndexOf("/") : -1; - return slashIndex >= 0 ? url.substr(0, slashIndex) : ""; -} -function join(...parts) { - const separator = "/"; - parts = parts.map((part, index2) => { - if (index2) { - part = part.replace(new RegExp(`^${separator}`), ""); - } - if (index2 !== parts.length - 1) { - part = part.replace(new RegExp(`${separator}$`), ""); - } - return part; - }); - return parts.join(separator); -} -function resolve(...components) { - const paths = []; - for (let _i = 0; _i < components.length; _i++) { - paths[_i] = components[_i]; - } - let resolvedPath = ""; - let resolvedAbsolute = false; - let cwd; - for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) { - let path; - if (i >= 0) { - path = paths[i]; - } else { - if (cwd === void 0) { - cwd = getCWD(); - } - path = cwd; - } - if (path.length === 0) { - continue; - } - resolvedPath = `${path}/${resolvedPath}`; - resolvedAbsolute = path.charCodeAt(0) === SLASH; - } - resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); - if (resolvedAbsolute) { - return `/${resolvedPath}`; - } else if (resolvedPath.length > 0) { - return resolvedPath; - } - return "."; -} -var SLASH = 47; -var DOT = 46; -function normalizeStringPosix(path, allowAboveRoot) { - let res = ""; - let lastSlash = -1; - let dots = 0; - let code; - let isAboveRoot = false; - for (let i = 0; i <= path.length; ++i) { - if (i < path.length) { - code = path.charCodeAt(i); - } else if (code === SLASH) { - break; - } else { - code = SLASH; - } - if (code === SLASH) { - if (lastSlash === i - 1 || dots === 1) { - } else if (lastSlash !== i - 1 && dots === 2) { - if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) { - if (res.length > 2) { - const start = res.length - 1; - let j = start; - for (; j >= 0; --j) { - if (res.charCodeAt(j) === SLASH) { - break; - } - } - if (j !== start) { - res = j === -1 ? "" : res.slice(0, j); - lastSlash = i; - dots = 0; - isAboveRoot = false; - continue; - } - } else if (res.length === 2 || res.length === 1) { - res = ""; - lastSlash = i; - dots = 0; - isAboveRoot = false; - continue; - } - } - if (allowAboveRoot) { - if (res.length > 0) { - res += "/.."; - } else { - res = ".."; - } - isAboveRoot = true; - } - } else { - const slice = path.slice(lastSlash + 1, i); - if (res.length > 0) { - res += `/${slice}`; - } else { - res = slice; - } - isAboveRoot = false; - } - lastSlash = i; - dots = 0; - } else if (code === DOT && dots !== -1) { - ++dots; - } else { - dots = -1; - } - } - return res; -} - -// node_modules/@loaders.gl/core/dist/javascript-utils/is-type.js -var isBoolean = (x) => typeof x === "boolean"; -var isFunction = (x) => typeof x === "function"; -var isObject = (x) => x !== null && typeof x === "object"; -var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor; -var isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function"; -var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function"; -var isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json; -var isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob; -var isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer; -var isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader); -var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable); -var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x); - -// node_modules/@loaders.gl/core/dist/lib/fetch/fetch-error.js -var FetchError = class extends Error { - constructor(message2, info) { - super(message2); - this.reason = info.reason; - this.url = info.url; - this.response = info.response; - } - /** A best effort reason for why the fetch failed */ - reason; - /** The URL that failed to load. Empty string if not available. */ - url; - /** The Response object, if any. */ - response; -}; - -// node_modules/@loaders.gl/core/dist/lib/utils/mime-type-utils.js -var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/; -var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/; -function compareMIMETypes(mimeType1, mimeType2) { - if (mimeType1.toLowerCase() === mimeType2.toLowerCase()) { - return true; - } - return false; -} -function parseMIMEType(mimeString) { - const matches4 = MIME_TYPE_PATTERN.exec(mimeString); - if (matches4) { - return matches4[1]; - } - return mimeString; -} -function parseMIMETypeFromURL(url) { - const matches4 = DATA_URL_PATTERN.exec(url); - if (matches4) { - return matches4[1]; - } - return ""; -} - -// node_modules/@loaders.gl/core/dist/lib/utils/url-utils.js -var QUERY_STRING_PATTERN = /\?.*/; -function extractQueryString(url) { - const matches4 = url.match(QUERY_STRING_PATTERN); - return matches4 && matches4[0]; -} -function stripQueryString(url) { - return url.replace(QUERY_STRING_PATTERN, ""); -} -function shortenUrlForDisplay(url) { - if (url.length < 50) { - return url; - } - const urlEnd = url.slice(url.length - 15); - const urlStart = url.substr(0, 32); - return `${urlStart}...${urlEnd}`; -} - -// node_modules/@loaders.gl/core/dist/lib/utils/resource-utils.js -function getResourceUrl(resource) { - if (isResponse(resource)) { - const response = resource; - return response.url; - } - if (isBlob(resource)) { - const blob = resource; - return blob.name || ""; - } - if (typeof resource === "string") { - return resource; - } - return ""; -} -function getResourceMIMEType(resource) { - if (isResponse(resource)) { - const response = resource; - const contentTypeHeader = response.headers.get("content-type") || ""; - const noQueryUrl = stripQueryString(response.url); - return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl); - } - if (isBlob(resource)) { - const blob = resource; - return blob.type || ""; - } - if (typeof resource === "string") { - return parseMIMETypeFromURL(resource); - } - return ""; -} -function getResourceContentLength(resource) { - if (isResponse(resource)) { - const response = resource; - return response.headers["content-length"] || -1; - } - if (isBlob(resource)) { - const blob = resource; - return blob.size; - } - if (typeof resource === "string") { - return resource.length; - } - if (resource instanceof ArrayBuffer) { - return resource.byteLength; - } - if (ArrayBuffer.isView(resource)) { - return resource.byteLength; - } - return -1; -} - -// node_modules/@loaders.gl/core/dist/lib/utils/response-utils.js -async function makeResponse(resource) { - if (isResponse(resource)) { - return resource; - } - const headers = {}; - const contentLength = getResourceContentLength(resource); - if (contentLength >= 0) { - headers["content-length"] = String(contentLength); - } - const url = getResourceUrl(resource); - const type = getResourceMIMEType(resource); - if (type) { - headers["content-type"] = type; - } - const initialDataUrl = await getInitialDataUrl(resource); - if (initialDataUrl) { - headers["x-first-bytes"] = initialDataUrl; - } - if (typeof resource === "string") { - resource = new TextEncoder().encode(resource); - } - const response = new Response(resource, { headers }); - Object.defineProperty(response, "url", { value: url }); - return response; -} -async function checkResponse(response) { - if (!response.ok) { - const error = await getResponseError(response); - throw error; - } -} -async function getResponseError(response) { - const shortUrl = shortenUrlForDisplay(response.url); - let message2 = `Failed to fetch resource (${response.status}) ${response.statusText}: ${shortUrl}`; - message2 = message2.length > 100 ? `${message2.slice(0, 100)}...` : message2; - const info = { - reason: response.statusText, - url: response.url, - response - }; - try { - const contentType = response.headers.get("Content-Type"); - info.reason = !response.bodyUsed && contentType?.includes("application/json") ? await response.json() : await response.text(); - } catch (error) { - } - return new FetchError(message2, info); -} -async function getInitialDataUrl(resource) { - const INITIAL_DATA_LENGTH = 5; - if (typeof resource === "string") { - return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`; - } - if (resource instanceof Blob) { - const blobSlice = resource.slice(0, 5); - return await new Promise((resolve2) => { - const reader = new FileReader(); - reader.onload = (event) => resolve2(event?.target?.result); - reader.readAsDataURL(blobSlice); - }); - } - if (resource instanceof ArrayBuffer) { - const slice = resource.slice(0, INITIAL_DATA_LENGTH); - const base64 = arrayBufferToBase64(slice); - return `data:base64,${base64}`; - } - return null; -} -function arrayBufferToBase64(buffer) { - let binary = ""; - const bytes = new Uint8Array(buffer); - for (let i = 0; i < bytes.byteLength; i++) { - binary += String.fromCharCode(bytes[i]); - } - return btoa(binary); -} - -// node_modules/@loaders.gl/core/dist/lib/fetch/fetch-file.js -function isNodePath(url) { - return !isRequestURL(url) && !isDataURL(url); -} -function isRequestURL(url) { - return url.startsWith("http:") || url.startsWith("https:"); -} -function isDataURL(url) { - return url.startsWith("data:"); -} -async function fetchFile(urlOrData, fetchOptions) { - if (typeof urlOrData === "string") { - const url = resolvePath(urlOrData); - if (isNodePath(url)) { - if (globalThis.loaders?.fetchNode) { - return globalThis.loaders?.fetchNode(url, fetchOptions); - } - } - return await fetch(url, fetchOptions); - } - return await makeResponse(urlOrData); -} - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/loggers.js -var probeLog = new Log({ id: "loaders.gl" }); -var NullLog = class { - log() { - return () => { - }; - } - info() { - return () => { - }; - } - warn() { - return () => { - }; - } - error() { - return () => { - }; - } -}; -var ConsoleLog = class { - console; - constructor() { - this.console = console; - } - log(...args) { - return this.console.log.bind(this.console, ...args); - } - info(...args) { - return this.console.info.bind(this.console, ...args); - } - warn(...args) { - return this.console.warn.bind(this.console, ...args); - } - error(...args) { - return this.console.error.bind(this.console, ...args); - } -}; - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/option-defaults.js -var DEFAULT_LOADER_OPTIONS = { - // baseUri - fetch: null, - mimeType: void 0, - nothrow: false, - log: new ConsoleLog(), - // A probe.gl compatible (`log.log()()` syntax) that just logs to console - useLocalLibraries: false, - CDN: "https://unpkg.com/@loaders.gl", - worker: true, - // By default, use worker if provided by loader. - maxConcurrency: 3, - // How many worker instances should be created for each loader. - maxMobileConcurrency: 1, - // How many worker instances should be created for each loader on mobile devices. - reuseWorkers: isBrowser, - // By default reuse workers in browser (Node.js refuses to terminate if browsers are running) - _nodeWorkers: false, - // By default do not support node workers - _workerType: "", - // 'test' to use locally generated workers - limit: 0, - _limitMB: 0, - batchSize: "auto", - batchDebounceMs: 0, - metadata: false, - // TODO - currently only implemented for parseInBatches, adds initial metadata batch, - transforms: [] -}; -var REMOVED_LOADER_OPTIONS = { - throws: "nothrow", - dataType: "(no longer used)", - uri: "baseUri", - // Warn if fetch options are used on top-level - method: "fetch.method", - headers: "fetch.headers", - body: "fetch.body", - mode: "fetch.mode", - credentials: "fetch.credentials", - cache: "fetch.cache", - redirect: "fetch.redirect", - referrer: "fetch.referrer", - referrerPolicy: "fetch.referrerPolicy", - integrity: "fetch.integrity", - keepalive: "fetch.keepalive", - signal: "fetch.signal" -}; - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/option-utils.js -function getGlobalLoaderState() { - globalThis.loaders = globalThis.loaders || {}; - const { loaders } = globalThis; - if (!loaders._state) { - loaders._state = {}; - } - return loaders._state; -} -function getGlobalLoaderOptions() { - const state = getGlobalLoaderState(); - state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS }; - return state.globalOptions; -} -function normalizeOptions(options, loader, loaders, url) { - loaders = loaders || []; - loaders = Array.isArray(loaders) ? loaders : [loaders]; - validateOptions(options, loaders); - return normalizeOptionsInternal(loader, options, url); -} -function validateOptions(options, loaders) { - validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders); - for (const loader of loaders) { - const idOptions = options && options[loader.id] || {}; - const loaderOptions = loader.options && loader.options[loader.id] || {}; - const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {}; - validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders); - } -} -function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) { - const loaderName = id || "Top level"; - const prefix = id ? `${id}.` : ""; - for (const key in options) { - const isSubOptions = !id && isObject(options[key]); - const isBaseUriOption = key === "baseUri" && !id; - const isWorkerUrlOption = key === "workerUrl" && id; - if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) { - if (key in deprecatedOptions) { - probeLog.warn(`${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`)(); - } else if (!isSubOptions) { - const suggestion = findSimilarOption(key, loaders); - probeLog.warn(`${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`)(); - } - } - } -} -function findSimilarOption(optionKey, loaders) { - const lowerCaseOptionKey = optionKey.toLowerCase(); - let bestSuggestion = ""; - for (const loader of loaders) { - for (const key in loader.options) { - if (optionKey === key) { - return `Did you mean '${loader.id}.${key}'?`; - } - const lowerCaseKey = key.toLowerCase(); - const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey); - if (isPartialMatch) { - bestSuggestion = bestSuggestion || `Did you mean '${loader.id}.${key}'?`; - } - } - } - return bestSuggestion; -} -function normalizeOptionsInternal(loader, options, url) { - const loaderDefaultOptions = loader.options || {}; - const mergedOptions = { ...loaderDefaultOptions }; - addUrlOptions(mergedOptions, url); - if (mergedOptions.log === null) { - mergedOptions.log = new NullLog(); - } - mergeNestedFields(mergedOptions, getGlobalLoaderOptions()); - mergeNestedFields(mergedOptions, options); - return mergedOptions; -} -function mergeNestedFields(mergedOptions, options) { - for (const key in options) { - if (key in options) { - const value = options[key]; - if (isPureObject(value) && isPureObject(mergedOptions[key])) { - mergedOptions[key] = { - ...mergedOptions[key], - ...options[key] - }; - } else { - mergedOptions[key] = options[key]; - } - } - } -} -function addUrlOptions(options, url) { - if (url && !("baseUri" in options)) { - options.baseUri = url; - } -} - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/normalize-loader.js -function isLoaderObject(loader) { - if (!loader) { - return false; - } - if (Array.isArray(loader)) { - loader = loader[0]; - } - const hasExtensions = Array.isArray(loader?.extensions); - return hasExtensions; -} -function normalizeLoader(loader) { - assert(loader, "null loader"); - assert(isLoaderObject(loader), "invalid loader"); - let options; - if (Array.isArray(loader)) { - options = loader[1]; - loader = loader[0]; - loader = { - ...loader, - options: { ...loader.options, ...options } - }; - } - if (loader?.parseTextSync || loader?.parseText) { - loader.text = true; - } - if (!loader.text) { - loader.binary = true; - } - return loader; -} - -// node_modules/@loaders.gl/core/dist/lib/api/register-loaders.js -var getGlobalLoaderRegistry = () => { - const state = getGlobalLoaderState(); - state.loaderRegistry = state.loaderRegistry || []; - return state.loaderRegistry; -}; -function registerLoaders(loaders) { - const loaderRegistry = getGlobalLoaderRegistry(); - loaders = Array.isArray(loaders) ? loaders : [loaders]; - for (const loader of loaders) { - const normalizedLoader = normalizeLoader(loader); - if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) { - loaderRegistry.unshift(normalizedLoader); - } - } -} -function getRegisteredLoaders() { - return getGlobalLoaderRegistry(); -} - -// node_modules/@loaders.gl/core/dist/lib/api/select-loader.js -var EXT_PATTERN = /\.([^.]+)$/; -async function selectLoader(data, loaders = [], options, context) { - if (!validHTTPResponse(data)) { - return null; - } - let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context); - if (loader) { - return loader; - } - if (isBlob(data)) { - data = await data.slice(0, 10).arrayBuffer(); - loader = selectLoaderSync(data, loaders, options, context); - } - if (!loader && !options?.nothrow) { - throw new Error(getNoValidLoaderMessage(data)); - } - return loader; -} -function selectLoaderSync(data, loaders = [], options, context) { - if (!validHTTPResponse(data)) { - return null; - } - if (loaders && !Array.isArray(loaders)) { - return normalizeLoader(loaders); - } - let candidateLoaders = []; - if (loaders) { - candidateLoaders = candidateLoaders.concat(loaders); - } - if (!options?.ignoreRegisteredLoaders) { - candidateLoaders.push(...getRegisteredLoaders()); - } - normalizeLoaders(candidateLoaders); - const loader = selectLoaderInternal(data, candidateLoaders, options, context); - if (!loader && !options?.nothrow) { - throw new Error(getNoValidLoaderMessage(data)); - } - return loader; -} -function selectLoaderInternal(data, loaders, options, context) { - const url = getResourceUrl(data); - const type = getResourceMIMEType(data); - const testUrl = stripQueryString(url) || context?.url; - let loader = null; - let reason = ""; - if (options?.mimeType) { - loader = findLoaderByMIMEType(loaders, options?.mimeType); - reason = `match forced by supplied MIME type ${options?.mimeType}`; - } - loader = loader || findLoaderByUrl(loaders, testUrl); - reason = reason || (loader ? `matched url ${testUrl}` : ""); - loader = loader || findLoaderByMIMEType(loaders, type); - reason = reason || (loader ? `matched MIME type ${type}` : ""); - loader = loader || findLoaderByInitialBytes(loaders, data); - reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : ""); - if (options?.fallbackMimeType) { - loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType); - reason = reason || (loader ? `matched fallback MIME type ${type}` : ""); - } - if (reason) { - log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`); - } - return loader; -} -function validHTTPResponse(data) { - if (data instanceof Response) { - if (data.status === 204) { - return false; - } - } - return true; -} -function getNoValidLoaderMessage(data) { - const url = getResourceUrl(data); - const type = getResourceMIMEType(data); - let message2 = "No valid loader found ("; - message2 += url ? `${path_exports.filename(url)}, ` : "no url provided, "; - message2 += `MIME type: ${type ? `"${type}"` : "not provided"}, `; - const firstCharacters = data ? getFirstCharacters(data) : ""; - message2 += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available"; - message2 += ")"; - return message2; -} -function normalizeLoaders(loaders) { - for (const loader of loaders) { - normalizeLoader(loader); - } -} -function findLoaderByUrl(loaders, url) { - const match = url && EXT_PATTERN.exec(url); - const extension = match && match[1]; - return extension ? findLoaderByExtension(loaders, extension) : null; -} -function findLoaderByExtension(loaders, extension) { - extension = extension.toLowerCase(); - for (const loader of loaders) { - for (const loaderExtension of loader.extensions) { - if (loaderExtension.toLowerCase() === extension) { - return loader; - } - } - } - return null; -} -function findLoaderByMIMEType(loaders, mimeType) { - for (const loader of loaders) { - if (loader.mimeTypes?.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) { - return loader; - } - if (compareMIMETypes(mimeType, `application/x.${loader.id}`)) { - return loader; - } - } - return null; -} -function findLoaderByInitialBytes(loaders, data) { - if (!data) { - return null; - } - for (const loader of loaders) { - if (typeof data === "string") { - if (testDataAgainstText(data, loader)) { - return loader; - } - } else if (ArrayBuffer.isView(data)) { - if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) { - return loader; - } - } else if (data instanceof ArrayBuffer) { - const byteOffset = 0; - if (testDataAgainstBinary(data, byteOffset, loader)) { - return loader; - } - } - } - return null; -} -function testDataAgainstText(data, loader) { - if (loader.testText) { - return loader.testText(data); - } - const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; - return tests.some((test) => data.startsWith(test)); -} -function testDataAgainstBinary(data, byteOffset, loader) { - const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; - return tests.some((test) => testBinary(data, byteOffset, loader, test)); -} -function testBinary(data, byteOffset, loader, test) { - if (test instanceof ArrayBuffer) { - return compareArrayBuffers(test, data, test.byteLength); - } - switch (typeof test) { - case "function": - return test(data); - case "string": - const magic = getMagicString(data, byteOffset, test.length); - return test === magic; - default: - return false; - } -} -function getFirstCharacters(data, length10 = 5) { - if (typeof data === "string") { - return data.slice(0, length10); - } else if (ArrayBuffer.isView(data)) { - return getMagicString(data.buffer, data.byteOffset, length10); - } else if (data instanceof ArrayBuffer) { - const byteOffset = 0; - return getMagicString(data, byteOffset, length10); - } - return ""; -} -function getMagicString(arrayBuffer2, byteOffset, length10) { - if (arrayBuffer2.byteLength < byteOffset + length10) { - return ""; - } - const dataView = new DataView(arrayBuffer2); - let magic = ""; - for (let i = 0; i < length10; i++) { - magic += String.fromCharCode(dataView.getUint8(byteOffset + i)); - } - return magic; -} - -// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-string-iterator.js -var DEFAULT_CHUNK_SIZE = 256 * 1024; -function* makeStringIterator(string, options) { - const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE; - let offset = 0; - const textEncoder = new TextEncoder(); - while (offset < string.length) { - const chunkLength = Math.min(string.length - offset, chunkSize); - const chunk = string.slice(offset, offset + chunkLength); - offset += chunkLength; - yield textEncoder.encode(chunk); - } -} - -// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-array-buffer-iterator.js -var DEFAULT_CHUNK_SIZE2 = 256 * 1024; -function* makeArrayBufferIterator(arrayBuffer2, options = {}) { - const { chunkSize = DEFAULT_CHUNK_SIZE2 } = options; - let byteOffset = 0; - while (byteOffset < arrayBuffer2.byteLength) { - const chunkByteLength = Math.min(arrayBuffer2.byteLength - byteOffset, chunkSize); - const chunk = new ArrayBuffer(chunkByteLength); - const sourceArray = new Uint8Array(arrayBuffer2, byteOffset, chunkByteLength); - const chunkArray = new Uint8Array(chunk); - chunkArray.set(sourceArray); - byteOffset += chunkByteLength; - yield chunk; - } -} - -// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-blob-iterator.js -var DEFAULT_CHUNK_SIZE3 = 1024 * 1024; -async function* makeBlobIterator(blob, options) { - const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE3; - let offset = 0; - while (offset < blob.size) { - const end = offset + chunkSize; - const chunk = await blob.slice(offset, end).arrayBuffer(); - offset = end; - yield chunk; - } -} - -// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-stream-iterator.js -function makeStreamIterator(stream, options) { - return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options); -} -async function* makeBrowserStreamIterator(stream, options) { - const reader = stream.getReader(); - let nextBatchPromise; - try { - while (true) { - const currentBatchPromise = nextBatchPromise || reader.read(); - if (options?._streamReadAhead) { - nextBatchPromise = reader.read(); - } - const { done, value } = await currentBatchPromise; - if (done) { - return; - } - yield toArrayBuffer2(value); - } - } catch (error) { - reader.releaseLock(); - } -} -async function* makeNodeStreamIterator(stream, options) { - for await (const chunk of stream) { - yield toArrayBuffer2(chunk); - } -} - -// node_modules/@loaders.gl/core/dist/iterators/make-iterator/make-iterator.js -function makeIterator(data, options) { - if (typeof data === "string") { - return makeStringIterator(data, options); - } - if (data instanceof ArrayBuffer) { - return makeArrayBufferIterator(data, options); - } - if (isBlob(data)) { - return makeBlobIterator(data, options); - } - if (isReadableStream(data)) { - return makeStreamIterator(data, options); - } - if (isResponse(data)) { - const response = data; - return makeStreamIterator(response.body, options); - } - throw new Error("makeIterator"); -} - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/get-data.js -var ERR_DATA = "Cannot convert supplied data type"; -function getArrayBufferOrStringFromDataSync(data, loader, options) { - if (loader.text && typeof data === "string") { - return data; - } - if (isBuffer2(data)) { - data = data.buffer; - } - if (data instanceof ArrayBuffer) { - const arrayBuffer2 = data; - if (loader.text && !loader.binary) { - const textDecoder = new TextDecoder("utf8"); - return textDecoder.decode(arrayBuffer2); - } - return arrayBuffer2; - } - if (ArrayBuffer.isView(data)) { - if (loader.text && !loader.binary) { - const textDecoder = new TextDecoder("utf8"); - return textDecoder.decode(data); - } - let arrayBuffer2 = data.buffer; - const byteLength = data.byteLength || data.length; - if (data.byteOffset !== 0 || byteLength !== arrayBuffer2.byteLength) { - arrayBuffer2 = arrayBuffer2.slice(data.byteOffset, data.byteOffset + byteLength); - } - return arrayBuffer2; - } - throw new Error(ERR_DATA); -} -async function getArrayBufferOrStringFromData(data, loader, options) { - const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data); - if (typeof data === "string" || isArrayBuffer) { - return getArrayBufferOrStringFromDataSync(data, loader, options); - } - if (isBlob(data)) { - data = await makeResponse(data); - } - if (isResponse(data)) { - const response = data; - await checkResponse(response); - return loader.binary ? await response.arrayBuffer() : await response.text(); - } - if (isReadableStream(data)) { - data = makeIterator(data, options); - } - if (isIterable(data) || isAsyncIterable(data)) { - return concatenateArrayBuffersAsync(data); - } - throw new Error(ERR_DATA); -} - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/get-fetch-function.js -function getFetchFunction(options, context) { - const globalOptions = getGlobalLoaderOptions(); - const loaderOptions = options || globalOptions; - if (typeof loaderOptions.fetch === "function") { - return loaderOptions.fetch; - } - if (isObject(loaderOptions.fetch)) { - return (url) => fetchFile(url, loaderOptions.fetch); - } - if (context?.fetch) { - return context?.fetch; - } - return fetchFile; -} - -// node_modules/@loaders.gl/core/dist/lib/loader-utils/loader-context.js -function getLoaderContext(context, options, parentContext) { - if (parentContext) { - return parentContext; - } - const newContext = { - fetch: getFetchFunction(options, context), - ...context - }; - if (newContext.url) { - const baseUrl = stripQueryString(newContext.url); - newContext.baseUrl = baseUrl; - newContext.queryString = extractQueryString(newContext.url); - newContext.filename = path_exports.filename(baseUrl); - newContext.baseUrl = path_exports.dirname(baseUrl); - } - if (!Array.isArray(newContext.loaders)) { - newContext.loaders = null; - } - return newContext; -} -function getLoadersFromContext(loaders, context) { - if (loaders && !Array.isArray(loaders)) { - return loaders; - } - let candidateLoaders; - if (loaders) { - candidateLoaders = Array.isArray(loaders) ? loaders : [loaders]; - } - if (context && context.loaders) { - const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders]; - candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders; - } - return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0; -} - -// node_modules/@loaders.gl/core/dist/lib/api/parse.js -async function parse(data, loaders, options, context) { - if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) { - context = void 0; - options = loaders; - loaders = void 0; - } - data = await data; - options = options || {}; - const url = getResourceUrl(data); - const typedLoaders = loaders; - const candidateLoaders = getLoadersFromContext(typedLoaders, context); - const loader = await selectLoader(data, candidateLoaders, options); - if (!loader) { - return null; - } - options = normalizeOptions(options, loader, candidateLoaders, url); - context = getLoaderContext( - // @ts-expect-error - { url, _parse: parse, loaders: candidateLoaders }, - options, - context || null - ); - return await parseWithLoader(loader, data, options, context); -} -async function parseWithLoader(loader, data, options, context) { - validateWorkerVersion(loader); - options = mergeLoaderOptions(loader.options, options); - if (isResponse(data)) { - const response = data; - const { ok, redirected, status, statusText, type, url } = response; - const headers = Object.fromEntries(response.headers.entries()); - context.response = { headers, ok, redirected, status, statusText, type, url }; - } - data = await getArrayBufferOrStringFromData(data, loader, options); - const loaderWithParser = loader; - if (loaderWithParser.parseTextSync && typeof data === "string") { - return loaderWithParser.parseTextSync(data, options, context); - } - if (canParseWithWorker(loader, options)) { - return await parseWithWorker(loader, data, options, context, parse); - } - if (loaderWithParser.parseText && typeof data === "string") { - return await loaderWithParser.parseText(data, options, context); - } - if (loaderWithParser.parse) { - return await loaderWithParser.parse(data, options, context); - } - assert3(!loaderWithParser.parseSync); - throw new Error(`${loader.id} loader - no parser found and worker is disabled`); -} - -// node_modules/@loaders.gl/core/dist/lib/api/load.js -async function load(url, loaders, options, context) { - let resolvedLoaders; - let resolvedOptions; - if (!Array.isArray(loaders) && !isLoaderObject(loaders)) { - resolvedLoaders = []; - resolvedOptions = loaders; - context = void 0; - } else { - resolvedLoaders = loaders; - resolvedOptions = options; - } - const fetch2 = getFetchFunction(resolvedOptions); - let data = url; - if (typeof url === "string") { - data = await fetch2(url); - } - if (isBlob(url)) { - data = await fetch2(url); - } - return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions); -} - -// node_modules/@loaders.gl/images/dist/lib/utils/version.js -var VERSION4 = true ? "4.2.0" : "latest"; - -// node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js -function assert4(condition, message2) { - if (!condition) { - throw new Error(message2 || "loader assertion failed."); - } -} - -// node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js -var globals3 = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document -}; -var self_3 = globals3.self || globals3.window || globals3.global || {}; -var window_4 = globals3.window || globals3.self || globals3.global || {}; -var global_4 = globals3.global || globals3.self || globals3.window || {}; -var document_4 = globals3.document || {}; -var isBrowser4 = ( - // @ts-ignore process does not exist on browser - Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser) -); -var matches3 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); -var nodeVersion3 = matches3 && parseFloat(matches3[1]) || 0; - -// node_modules/@loaders.gl/loader-utils/dist/lib/request-utils/request-scheduler.js -var STAT_QUEUED_REQUESTS = "Queued Requests"; -var STAT_ACTIVE_REQUESTS = "Active Requests"; -var STAT_CANCELLED_REQUESTS = "Cancelled Requests"; -var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever"; -var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever"; -var DEFAULT_PROPS2 = { - id: "request-scheduler", - /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */ - throttleRequests: true, - /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */ - maxRequests: 6, - /** - * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have - * been added to the queue for this amount of time. - */ - debounceTime: 0 -}; -var RequestScheduler = class { - props; - stats; - activeRequestCount = 0; - /** Tracks the number of active requests and prioritizes/cancels queued requests. */ - requestQueue = []; - requestMap = /* @__PURE__ */ new Map(); - updateTimer = null; - constructor(props = {}) { - this.props = { ...DEFAULT_PROPS2, ...props }; - this.stats = new Stats({ id: this.props.id }); - this.stats.get(STAT_QUEUED_REQUESTS); - this.stats.get(STAT_ACTIVE_REQUESTS); - this.stats.get(STAT_CANCELLED_REQUESTS); - this.stats.get(STAT_QUEUED_REQUESTS_EVER); - this.stats.get(STAT_ACTIVE_REQUESTS_EVER); - } - /** - * Called by an application that wants to issue a request, without having it deeply queued by the browser - * - * When the returned promise resolved, it is OK for the application to issue a request. - * The promise resolves to an object that contains a `done` method. - * When the application's request has completed (or failed), the application must call the `done` function - * - * @param handle - * @param getPriority will be called when request "slots" open up, - * allowing the caller to update priority or cancel the request - * Highest priority executes first, priority < 0 cancels the request - * @returns a promise - * - resolves to a object (with a `done` field) when the request can be issued without queueing, - * - resolves to `null` if the request has been cancelled (by the callback return < 0). - * In this case the application should not issue the request - */ - scheduleRequest(handle, getPriority = () => 0) { - if (!this.props.throttleRequests) { - return Promise.resolve({ done: () => { - } }); - } - if (this.requestMap.has(handle)) { - return this.requestMap.get(handle); - } - const request = { handle, priority: 0, getPriority }; - const promise = new Promise((resolve2) => { - request.resolve = resolve2; - return request; - }); - this.requestQueue.push(request); - this.requestMap.set(handle, promise); - this._issueNewRequests(); - return promise; - } - // PRIVATE - _issueRequest(request) { - const { handle, resolve: resolve2 } = request; - let isDone = false; - const done = () => { - if (!isDone) { - isDone = true; - this.requestMap.delete(handle); - this.activeRequestCount--; - this._issueNewRequests(); - } - }; - this.activeRequestCount++; - return resolve2 ? resolve2({ done }) : Promise.resolve({ done }); - } - /** We check requests asynchronously, to prevent multiple updates */ - _issueNewRequests() { - if (this.updateTimer !== null) { - clearTimeout(this.updateTimer); - } - this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime); - } - /** Refresh all requests */ - _issueNewRequestsAsync() { - if (this.updateTimer !== null) { - clearTimeout(this.updateTimer); - } - this.updateTimer = null; - const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0); - if (freeSlots === 0) { - return; - } - this._updateAllRequests(); - for (let i = 0; i < freeSlots; ++i) { - const request = this.requestQueue.shift(); - if (request) { - this._issueRequest(request); - } - } - } - /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */ - _updateAllRequests() { - const requestQueue = this.requestQueue; - for (let i = 0; i < requestQueue.length; ++i) { - const request = requestQueue[i]; - if (!this._updateRequest(request)) { - requestQueue.splice(i, 1); - this.requestMap.delete(request.handle); - i--; - } - } - requestQueue.sort((a, b) => a.priority - b.priority); - } - /** Update a single request by calling the callback */ - _updateRequest(request) { - request.priority = request.getPriority(request.handle); - if (request.priority < 0) { - request.resolve(null); - return false; - } - return true; - } -}; - -// node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js -var parseImageNode = globalThis.loaders?.parseImageNode; -var IMAGE_SUPPORTED = typeof Image !== "undefined"; -var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined"; -var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode); -var DATA_SUPPORTED = isBrowser4 ? true : NODE_IMAGE_SUPPORTED; -function isImageTypeSupported(type) { - switch (type) { - case "auto": - return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED; - case "imagebitmap": - return IMAGE_BITMAP_SUPPORTED; - case "image": - return IMAGE_SUPPORTED; - case "data": - return DATA_SUPPORTED; - default: - throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`); - } -} -function getDefaultImageType() { - if (IMAGE_BITMAP_SUPPORTED) { - return "imagebitmap"; - } - if (IMAGE_SUPPORTED) { - return "image"; - } - if (DATA_SUPPORTED) { - return "data"; - } - throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js"); -} - -// node_modules/@loaders.gl/images/dist/lib/category-api/parsed-image-api.js -function getImageType(image) { - const format = getImageTypeOrNull(image); - if (!format) { - throw new Error("Not an image"); - } - return format; -} -function getImageData(image) { - switch (getImageType(image)) { - case "data": - return image; - case "image": - case "imagebitmap": - const canvas2 = document.createElement("canvas"); - const context = canvas2.getContext("2d"); - if (!context) { - throw new Error("getImageData"); - } - canvas2.width = image.width; - canvas2.height = image.height; - context.drawImage(image, 0, 0); - return context.getImageData(0, 0, image.width, image.height); - default: - throw new Error("getImageData"); - } -} -function getImageTypeOrNull(image) { - if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { - return "imagebitmap"; - } - if (typeof Image !== "undefined" && image instanceof Image) { - return "image"; - } - if (image && typeof image === "object" && image.data && image.width && image.height) { - return "data"; - } - return null; -} - -// node_modules/@loaders.gl/images/dist/lib/parsers/svg-utils.js -var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/; -var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/; -function isSVG(url) { - return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url)); -} -function getBlobOrSVGDataUrl(arrayBuffer2, url) { - if (isSVG(url)) { - const textDecoder = new TextDecoder(); - let xmlText = textDecoder.decode(arrayBuffer2); - try { - if (typeof unescape === "function" && typeof encodeURIComponent === "function") { - xmlText = unescape(encodeURIComponent(xmlText)); - } - } catch (error) { - throw new Error(error.message); - } - const src = `data:image/svg+xml;base64,${btoa(xmlText)}`; - return src; - } - return getBlob(arrayBuffer2, url); -} -function getBlob(arrayBuffer2, url) { - if (isSVG(url)) { - throw new Error("SVG cannot be parsed directly to imagebitmap"); - } - return new Blob([new Uint8Array(arrayBuffer2)]); -} - -// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image.js -async function parseToImage(arrayBuffer2, options, url) { - const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url); - const URL2 = self.URL || self.webkitURL; - const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl); - try { - return await loadToImage(objectUrl || blobOrDataUrl, options); - } finally { - if (objectUrl) { - URL2.revokeObjectURL(objectUrl); - } - } -} -async function loadToImage(url, options) { - const image = new Image(); - image.src = url; - if (options.image && options.image.decode && image.decode) { - await image.decode(); - return image; - } - return await new Promise((resolve2, reject) => { - try { - image.onload = () => resolve2(image); - image.onerror = (error) => { - const message2 = error instanceof Error ? error.message : "error"; - reject(new Error(message2)); - }; - } catch (error) { - reject(error); - } - }); -} - -// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image-bitmap.js -var EMPTY_OBJECT = {}; -var imagebitmapOptionsSupported = true; -async function parseToImageBitmap(arrayBuffer2, options, url) { - let blob; - if (isSVG(url)) { - const image = await parseToImage(arrayBuffer2, options, url); - blob = image; - } else { - blob = getBlob(arrayBuffer2, url); - } - const imagebitmapOptions = options && options.imagebitmap; - return await safeCreateImageBitmap(blob, imagebitmapOptions); -} -async function safeCreateImageBitmap(blob, imagebitmapOptions = null) { - if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) { - imagebitmapOptions = null; - } - if (imagebitmapOptions) { - try { - return await createImageBitmap(blob, imagebitmapOptions); - } catch (error) { - console.warn(error); - imagebitmapOptionsSupported = false; - } - } - return await createImageBitmap(blob); -} -function isEmptyObject(object) { - for (const key in object || EMPTY_OBJECT) { - return false; - } - return true; -} - -// node_modules/@loaders.gl/images/dist/lib/category-api/parse-isobmff-binary.js -function getISOBMFFMediaType(buffer) { - if (!checkString(buffer, "ftyp", 4)) { - return null; - } - if ((buffer[8] & 96) === 0) { - return null; - } - return decodeMajorBrand(buffer); -} -function decodeMajorBrand(buffer) { - const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim(); - switch (brandMajor) { - case "avif": - case "avis": - return { extension: "avif", mimeType: "image/avif" }; - default: - return null; - } -} -function getUTF8String(array, start, end) { - return String.fromCharCode(...array.slice(start, end)); -} -function stringToBytes(string) { - return [...string].map((character) => character.charCodeAt(0)); -} -function checkString(buffer, header, offset = 0) { - const headerBytes = stringToBytes(header); - for (let i = 0; i < headerBytes.length; ++i) { - if (headerBytes[i] !== buffer[i + offset]) { - return false; - } - } - return true; -} - -// node_modules/@loaders.gl/images/dist/lib/category-api/binary-image-api.js -var BIG_ENDIAN = false; -var LITTLE_ENDIAN = true; -function getBinaryImageMetadata(binaryData) { - const dataView = toDataView(binaryData); - return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView); -} -function getISOBMFFMetadata(binaryData) { - const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData); - const mediaType = getISOBMFFMediaType(buffer); - if (!mediaType) { - return null; - } - return { - mimeType: mediaType.mimeType, - // TODO - decode width and height - width: 0, - height: 0 - }; -} -function getPngMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511; - if (!isPng) { - return null; - } - return { - mimeType: "image/png", - width: dataView.getUint32(16, BIG_ENDIAN), - height: dataView.getUint32(20, BIG_ENDIAN) - }; -} -function getGifMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440; - if (!isGif) { - return null; - } - return { - mimeType: "image/gif", - width: dataView.getUint16(6, LITTLE_ENDIAN), - height: dataView.getUint16(8, LITTLE_ENDIAN) - }; -} -function getBmpMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength; - if (!isBmp) { - return null; - } - return { - mimeType: "image/bmp", - width: dataView.getUint32(18, LITTLE_ENDIAN), - height: dataView.getUint32(22, LITTLE_ENDIAN) - }; -} -function getJpegMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255; - if (!isJpeg) { - return null; - } - const { tableMarkers, sofMarkers } = getJpegMarkers(); - let i = 2; - while (i + 9 < dataView.byteLength) { - const marker = dataView.getUint16(i, BIG_ENDIAN); - if (sofMarkers.has(marker)) { - return { - mimeType: "image/jpeg", - height: dataView.getUint16(i + 5, BIG_ENDIAN), - // Number of lines - width: dataView.getUint16(i + 7, BIG_ENDIAN) - // Number of pixels per line - }; - } - if (!tableMarkers.has(marker)) { - return null; - } - i += 2; - i += dataView.getUint16(i, BIG_ENDIAN); - } - return null; -} -function getJpegMarkers() { - const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]); - for (let i = 65504; i < 65520; ++i) { - tableMarkers.add(i); - } - const sofMarkers = /* @__PURE__ */ new Set([ - 65472, - 65473, - 65474, - 65475, - 65477, - 65478, - 65479, - 65481, - 65482, - 65483, - 65485, - 65486, - 65487, - 65502 - ]); - return { tableMarkers, sofMarkers }; -} -function toDataView(data) { - if (data instanceof DataView) { - return data; - } - if (ArrayBuffer.isView(data)) { - return new DataView(data.buffer); - } - if (data instanceof ArrayBuffer) { - return new DataView(data); - } - throw new Error("toDataView"); -} - -// node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-node-image.js -async function parseToNodeImage(arrayBuffer2, options) { - const { mimeType } = getBinaryImageMetadata(arrayBuffer2) || {}; - const parseImageNode2 = globalThis.loaders?.parseImageNode; - assert4(parseImageNode2); - return await parseImageNode2(arrayBuffer2, mimeType); -} - -// node_modules/@loaders.gl/images/dist/lib/parsers/parse-image.js -async function parseImage(arrayBuffer2, options, context) { - options = options || {}; - const imageOptions = options.image || {}; - const imageType = imageOptions.type || "auto"; - const { url } = context || {}; - const loadType = getLoadableImageType(imageType); - let image; - switch (loadType) { - case "imagebitmap": - image = await parseToImageBitmap(arrayBuffer2, options, url); - break; - case "image": - image = await parseToImage(arrayBuffer2, options, url); - break; - case "data": - image = await parseToNodeImage(arrayBuffer2, options); - break; - default: - assert4(false); - } - if (imageType === "data") { - image = getImageData(image); - } - return image; -} -function getLoadableImageType(type) { - switch (type) { - case "auto": - case "data": - return getDefaultImageType(); - default: - isImageTypeSupported(type); - return type; - } -} - -// node_modules/@loaders.gl/images/dist/image-loader.js -var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"]; -var MIME_TYPES = [ - "image/png", - "image/jpeg", - "image/gif", - "image/webp", - "image/avif", - "image/bmp", - "image/vnd.microsoft.icon", - "image/svg+xml" -]; -var DEFAULT_IMAGE_LOADER_OPTIONS = { - image: { - type: "auto", - decode: true - // if format is HTML - } - // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor -}; -var ImageLoader = { - dataType: null, - batchType: null, - id: "image", - module: "images", - name: "Images", - version: VERSION4, - mimeTypes: MIME_TYPES, - extensions: EXTENSIONS, - parse: parseImage, - // TODO: byteOffset, byteLength; - tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))], - options: DEFAULT_IMAGE_LOADER_OPTIONS -}; - -// node_modules/@deck.gl/core/dist/utils/log.js -var defaultLogger = new Log({ id: "deck" }); -var log_default = defaultLogger; - -// node_modules/@deck.gl/core/dist/debug/loggers.js -var logState = { - attributeUpdateStart: -1, - attributeManagerUpdateStart: -1, - attributeUpdateMessages: [] -}; -var LOG_LEVEL_MAJOR_UPDATE = 1; -var LOG_LEVEL_MINOR_UPDATE = 2; -var LOG_LEVEL_UPDATE_DETAIL = 3; -var LOG_LEVEL_INFO = 4; -var LOG_LEVEL_DRAW = 2; -var getLoggers = (log4) => ({ - /* Layer events */ - "layer.changeFlag": (layer, key, flags) => { - log4.log(LOG_LEVEL_UPDATE_DETAIL, `${layer.id} ${key}: `, flags[key])(); - }, - "layer.initialize": (layer) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, `Initializing ${layer}`)(); - }, - "layer.update": (layer, needsUpdate) => { - if (needsUpdate) { - const flags = layer.getChangeFlags(); - log4.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layer} because: ${Object.keys(flags).filter((key) => flags[key]).join(", ")}`)(); - } else { - log4.log(LOG_LEVEL_INFO, `${layer} does not need update`)(); - } - }, - "layer.matched": (layer, changed) => { - if (changed) { - log4.log(LOG_LEVEL_INFO, `Matched ${layer}, state transfered`)(); - } - }, - "layer.finalize": (layer) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, `Finalizing ${layer}`)(); - }, - /* CompositeLayer events */ - "compositeLayer.renderLayers": (layer, updated, subLayers) => { - if (updated) { - log4.log(LOG_LEVEL_MINOR_UPDATE, `Composite layer rendered new subLayers ${layer}`, subLayers)(); - } else { - log4.log(LOG_LEVEL_INFO, `Composite layer reused subLayers ${layer}`, subLayers)(); - } - }, - /* LayerManager events */ - "layerManager.setLayers": (layerManager, updated, layers) => { - if (updated) { - log4.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layers.length} deck layers`)(); - } - }, - "layerManager.activateViewport": (layerManager, viewport) => { - log4.log(LOG_LEVEL_UPDATE_DETAIL, "Viewport changed", viewport)(); - }, - /* AttributeManager events */ - "attributeManager.invalidate": (attributeManager, trigger, attributeNames) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, attributeNames ? `invalidated attributes ${attributeNames} (${trigger}) for ${attributeManager.id}` : `invalidated all attributes for ${attributeManager.id}`)(); - }, - "attributeManager.updateStart": (attributeManager) => { - logState.attributeUpdateMessages.length = 0; - logState.attributeManagerUpdateStart = Date.now(); - }, - "attributeManager.updateEnd": (attributeManager, numInstances) => { - const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart); - log4.groupCollapsed(LOG_LEVEL_MINOR_UPDATE, `Updated attributes for ${numInstances} instances in ${attributeManager.id} in ${timeMs}ms`)(); - for (const updateMessage of logState.attributeUpdateMessages) { - log4.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)(); - } - log4.groupEnd(LOG_LEVEL_MINOR_UPDATE)(); - }, - /* Attribute events */ - "attribute.updateStart": (attribute) => { - logState.attributeUpdateStart = Date.now(); - }, - "attribute.allocate": (attribute, numInstances) => { - const message2 = `${attribute.id} allocated ${numInstances}`; - logState.attributeUpdateMessages.push(message2); - }, - "attribute.updateEnd": (attribute, numInstances) => { - const timeMs = Math.round(Date.now() - logState.attributeUpdateStart); - const message2 = `${attribute.id} updated ${numInstances} in ${timeMs}ms`; - logState.attributeUpdateMessages.push(message2); - }, - /* Render events */ - "deckRenderer.renderLayers": (deckRenderer, renderStats, opts) => { - const { pass, redrawReason, stats } = opts; - for (const status of renderStats) { - const { totalCount, visibleCount, compositeCount, pickableCount } = status; - const primitiveCount = totalCount - compositeCount; - const hiddenCount = primitiveCount - visibleCount; - log4.log(LOG_LEVEL_DRAW, `RENDER #${deckRenderer.renderCount} ${visibleCount} (of ${totalCount} layers) to ${pass} because ${redrawReason} (${hiddenCount} hidden, ${compositeCount} composite ${pickableCount} pickable)`)(); - if (stats) { - stats.get("Redraw Layers").add(visibleCount); - } - } - } -}); - -// node_modules/@deck.gl/core/dist/debug/index.js -var loggers = {}; -if (true) { - loggers = getLoggers(log_default); -} -function register(handlers) { - loggers = handlers; -} -function debug(eventType, arg1, arg2, arg3) { - if (log_default.level > 0 && loggers[eventType]) { - loggers[eventType].call(null, arg1, arg2, arg3); - } -} - -// node_modules/@deck.gl/core/dist/utils/json-loader.js -function isJSON(text) { - const firstChar = text[0]; - const lastChar = text[text.length - 1]; - return firstChar === "{" && lastChar === "}" || firstChar === "[" && lastChar === "]"; -} -var json_loader_default = { - dataType: null, - batchType: null, - id: "JSON", - name: "JSON", - module: "", - version: "", - options: {}, - extensions: ["json", "geojson"], - mimeTypes: ["application/json", "application/geo+json"], - testText: isJSON, - parseTextSync: JSON.parse -}; - -// node_modules/@deck.gl/core/dist/lib/init.js -function checkVersion() { - const version2 = true ? "9.0.35" : globalThis.DECK_VERSION || "untranspiled source"; - const existingVersion = globalThis.deck && globalThis.deck.VERSION; - if (existingVersion && existingVersion !== version2) { - throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version2}`); - } - if (!existingVersion) { - log_default.log(1, `deck.gl ${version2}`)(); - globalThis.deck = { - ...globalThis.deck, - VERSION: version2, - version: version2, - log: log_default, - // experimental - _registerLoggers: register - }; - registerLoaders([ - json_loader_default, - // @ts-expect-error non-standard Loader format - [ImageLoader, { imagebitmap: { premultiplyAlpha: "none" } }] - ]); - } - return version2; -} -var VERSION5 = checkVersion(); - -// node_modules/@luma.gl/shadertools/dist/lib/utils/assert.js -function assert5(condition, message2) { - if (!condition) { - throw new Error(message2 || "shadertools: assertion failed."); - } -} - -// node_modules/@luma.gl/shadertools/dist/lib/filters/prop-types.js -var DEFAULT_PROP_VALIDATORS = { - number: { - type: "number", - validate(value, propType) { - return Number.isFinite(value) && typeof propType === "object" && (propType.max === void 0 || value <= propType.max) && (propType.min === void 0 || value >= propType.min); - } - }, - array: { - type: "array", - validate(value, propType) { - return Array.isArray(value) || ArrayBuffer.isView(value); - } - } -}; -function makePropValidators(propTypes) { - const propValidators = {}; - for (const [name2, propType] of Object.entries(propTypes)) { - propValidators[name2] = makePropValidator(propType); - } - return propValidators; -} -function getValidatedProperties(properties, propValidators, errorMessage) { - const validated = {}; - for (const [key, propsValidator] of Object.entries(propValidators)) { - if (properties && key in properties && !propsValidator.private) { - if (propsValidator.validate) { - assert5(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`); - } - validated[key] = properties[key]; - } else { - validated[key] = propsValidator.value; - } - } - return validated; -} -function makePropValidator(propType) { - let type = getTypeOf(propType); - if (type !== "object") { - return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type }; - } - if (typeof propType === "object") { - if (!propType) { - return { type: "object", value: null }; - } - if (propType.type !== void 0) { - return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type }; - } - if (propType.value === void 0) { - return { type: "object", value: propType }; - } - type = getTypeOf(propType.value); - return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type }; - } - throw new Error("props"); -} -function getTypeOf(value) { - if (Array.isArray(value) || ArrayBuffer.isView(value)) { - return "array"; - } - return typeof value; -} - -// node_modules/@luma.gl/shadertools/dist/module-injectors.js -var MODULE_INJECTORS_VS = `#ifdef MODULE_LOGDEPTH -logdepth_adjustPosition(gl_Position); -#endif -`; -var MODULE_INJECTORS_FS = `#ifdef MODULE_MATERIAL -gl_FragColor = material_filterColor(gl_FragColor); -#endif -#ifdef MODULE_LIGHTING -gl_FragColor = lighting_filterColor(gl_FragColor); -#endif -#ifdef MODULE_FOG -gl_FragColor = fog_filterColor(gl_FragColor); -#endif -#ifdef MODULE_PICKING -gl_FragColor = picking_filterHighlightColor(gl_FragColor); -gl_FragColor = picking_filterPickingColor(gl_FragColor); -#endif -#ifdef MODULE_LOGDEPTH -logdepth_setFragDepth(); -#endif -`; - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-injections.js -var MODULE_INJECTORS = { - vertex: MODULE_INJECTORS_VS, - fragment: MODULE_INJECTORS_FS -}; -var REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/; -var REGEX_END_OF_MAIN = /}\n?[^{}]*$/; -var fragments = []; -var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__"; -function normalizeInjections(injections) { - const result = { vertex: {}, fragment: {} }; - for (const hook in injections) { - let injection = injections[hook]; - const stage = getHookStage(hook); - if (typeof injection === "string") { - injection = { - order: 0, - injection - }; - } - result[stage][hook] = injection; - } - return result; -} -function getHookStage(hook) { - const type = hook.slice(0, 2); - switch (type) { - case "vs": - return "vertex"; - case "fs": - return "fragment"; - default: - throw new Error(type); - } -} -function injectShader(source, stage, inject, injectStandardStubs = false) { - const isVertex = stage === "vertex"; - for (const key in inject) { - const fragmentData = inject[key]; - fragmentData.sort((a, b) => a.order - b.order); - fragments.length = fragmentData.length; - for (let i = 0, len8 = fragmentData.length; i < len8; ++i) { - fragments[i] = fragmentData[i].injection; - } - const fragmentString = `${fragments.join("\n")} -`; - switch (key) { - case "vs:#decl": - if (isVertex) { - source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); - } - break; - case "vs:#main-start": - if (isVertex) { - source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); - } - break; - case "vs:#main-end": - if (isVertex) { - source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); - } - break; - case "fs:#decl": - if (!isVertex) { - source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); - } - break; - case "fs:#main-start": - if (!isVertex) { - source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); - } - break; - case "fs:#main-end": - if (!isVertex) { - source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); - } - break; - default: - source = source.replace(key, (match) => match + fragmentString); - } - } - source = source.replace(DECLARATION_INJECT_MARKER, ""); - if (injectStandardStubs) { - source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]); - } - return source; -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-module/shader-module-instance.js -var index = 1; -var ShaderModuleInstance = class _ShaderModuleInstance { - name; - vs; - fs; - getModuleUniforms; - dependencies; - deprecations; - defines; - injections; - uniforms = {}; - uniformTypes = {}; - static instantiateModules(modules) { - return modules.map((module) => { - if (module instanceof _ShaderModuleInstance) { - return module; - } - assert5(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`); - if (!module.name) { - console.warn("shader module has no name"); - module.name = `shader-module-${index++}`; - } - const moduleObject = new _ShaderModuleInstance(module); - moduleObject.dependencies = _ShaderModuleInstance.instantiateModules(module.dependencies || []); - return moduleObject; - }); - } - constructor(props) { - const { name: name2, vs: vs7, fs: fs5, dependencies = [], uniformTypes = {}, uniformPropTypes = {}, getUniforms: getUniforms6, deprecations = [], defines: defines2 = {}, inject = {} } = props; - assert5(typeof name2 === "string"); - this.name = name2; - this.vs = vs7; - this.fs = fs5; - this.getModuleUniforms = getUniforms6; - this.dependencies = _ShaderModuleInstance.instantiateModules(dependencies); - this.deprecations = this._parseDeprecationDefinitions(deprecations); - this.defines = defines2; - this.injections = normalizeInjections(inject); - this.uniformTypes = uniformTypes; - if (uniformPropTypes) { - this.uniforms = makePropValidators(uniformPropTypes); - } - } - // Extracts the source code chunk for the specified shader type from the named shader module - getModuleSource(stage) { - let moduleSource; - switch (stage) { - case "vertex": - moduleSource = this.vs || ""; - break; - case "fragment": - moduleSource = this.fs || ""; - break; - default: - assert5(false); - } - const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_"); - return `// ----- MODULE ${this.name} --------------- - -#define MODULE_${moduleName} -${moduleSource} - -`; - } - getUniforms(userProps, uniforms) { - if (this.getModuleUniforms) { - return this.getModuleUniforms(userProps, uniforms); - } - return getValidatedProperties(userProps, this.uniforms, this.name); - } - getDefines() { - return this.defines; - } - // Warn about deprecated uniforms or functions - checkDeprecations(shaderSource, log4) { - this.deprecations.forEach((def) => { - if (def.regex?.test(shaderSource)) { - if (def.deprecated) { - log4.deprecated(def.old, def.new)(); - } else { - log4.removed(def.old, def.new)(); - } - } - }); - } - _parseDeprecationDefinitions(deprecations) { - deprecations.forEach((def) => { - switch (def.type) { - case "function": - def.regex = new RegExp(`\\b${def.old}\\(`); - break; - default: - def.regex = new RegExp(`${def.type} ${def.old};`); - } - }); - return deprecations; - } - _defaultGetUniforms(opts = {}) { - const uniforms = {}; - const propTypes = this.uniforms; - for (const key in propTypes) { - const propDef = propTypes[key]; - if (key in opts && !propDef.private) { - if (propDef.validate) { - assert5(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`); - } - uniforms[key] = opts[key]; - } else { - uniforms[key] = propDef.value; - } - } - return uniforms; - } -}; - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/select-shaders.js -function selectShaders(props) { - if (props.source && props.platformInfo.type === "webgpu") { - const propsCopy = { ...props, vs: void 0, fs: void 0 }; - return propsCopy; - } - if (!props.vs) { - throw new Error("no vertex shader"); - } - const vs7 = getShaderSource(props.platformInfo, props.vs); - let fs5; - if (props.fs) { - fs5 = getShaderSource(props.platformInfo, props.fs); - } - return { ...props, vs: vs7, fs: fs5 }; -} -function getShaderSource(platformInfo, shader) { - if (typeof shader === "string") { - return shader; - } - switch (platformInfo.type) { - case "webgpu": - if (shader?.wgsl) { - return shader.wgsl; - } - throw new Error("WebGPU does not support GLSL shaders"); - default: - if (shader?.glsl) { - return shader.glsl; - } - throw new Error("WebGL does not support WGSL shaders"); - } -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/resolve-modules.js -function resolveModules(modules) { - const instances = ShaderModuleInstance.instantiateModules(modules); - return getShaderDependencies(instances); -} -function getShaderDependencies(modules) { - const moduleMap = {}; - const moduleDepth = {}; - getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth }); - return Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name2) => moduleMap[name2]); -} -function getDependencyGraph(options) { - const { modules, level, moduleMap, moduleDepth } = options; - if (level >= 5) { - throw new Error("Possible loop in shader dependency graph"); - } - for (const module of modules) { - moduleMap[module.name] = module; - if (moduleDepth[module.name] === void 0 || moduleDepth[module.name] < level) { - moduleDepth[module.name] = level; - } - } - for (const module of modules) { - if (module.dependencies) { - getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth }); - } - } -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/platform-defines.js -function getPlatformShaderDefines(platformInfo) { - switch (platformInfo?.gpu.toLowerCase()) { - case "apple": - return `#define APPLE_GPU -#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 -#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 -#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 -`; - case "nvidia": - return `#define NVIDIA_GPU -#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 -`; - case "intel": - return `#define INTEL_GPU -#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 -#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 -#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 -`; - case "amd": - return `#define AMD_GPU -`; - default: - return `#define DEFAULT_GPU -#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1 -#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1 -#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1 -`; - } -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js -function transpileGLSLShader(source, stage) { - const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100); - if (sourceGLSLVersion !== 300) { - throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources"); - } - switch (stage) { - case "vertex": - source = convertShader(source, ES300_VERTEX_REPLACEMENTS); - return source; - case "fragment": - source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS); - return source; - default: - throw new Error(stage); - } -} -var ES300_REPLACEMENTS = [ - // Fix poorly formatted version directive - [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], - // The individual `texture...()` functions were replaced with `texture()` overloads - [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], - [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("] -]; -var ES300_VERTEX_REPLACEMENTS = [ - ...ES300_REPLACEMENTS, - // `attribute` keyword replaced with `in` - [makeVariableTextRegExp("attribute"), "in $1"], - // `varying` keyword replaced with `out` - [makeVariableTextRegExp("varying"), "out $1"] -]; -var ES300_FRAGMENT_REPLACEMENTS = [ - ...ES300_REPLACEMENTS, - // `varying` keyword replaced with `in` - [makeVariableTextRegExp("varying"), "in $1"] -]; -function convertShader(source, replacements) { - for (const [pattern, replacement] of replacements) { - source = source.replace(pattern, replacement); - } - return source; -} -function makeVariableTextRegExp(qualifier) { - return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g"); -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-hooks.js -function getShaderHooks(hookFunctions, hookInjections) { - let result = ""; - for (const hookName in hookFunctions) { - const hookFunction = hookFunctions[hookName]; - result += `void ${hookFunction.signature} { -`; - if (hookFunction.header) { - result += ` ${hookFunction.header}`; - } - if (hookInjections[hookName]) { - const injections = hookInjections[hookName]; - injections.sort((a, b) => a.order - b.order); - for (const injection of injections) { - result += ` ${injection.injection} -`; - } - } - if (hookFunction.footer) { - result += ` ${hookFunction.footer}`; - } - result += "}\n"; - } - return result; -} -function normalizeShaderHooks(hookFunctions) { - const result = { vertex: {}, fragment: {} }; - for (const hookFunction of hookFunctions) { - let opts; - let hook; - if (typeof hookFunction !== "string") { - opts = hookFunction; - hook = opts.hook; - } else { - opts = {}; - hook = hookFunction; - } - hook = hook.trim(); - const [shaderStage, signature] = hook.split(":"); - const name2 = hook.replace(/\(.+/, ""); - const normalizedHook = Object.assign(opts, { signature }); - switch (shaderStage) { - case "vs": - result.vertex[name2] = normalizedHook; - break; - case "fs": - result.fragment[name2] = normalizedHook; - break; - default: - throw new Error(shaderStage); - } - } - return result; -} - -// node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/get-shader-info.js -function getShaderInfo(source, defaultName) { - return { - name: getShaderName(source, defaultName), - language: "glsl", - version: getShaderVersion(source) - }; -} -function getShaderName(shader, defaultName = "unnamed") { - const SHADER_NAME_REGEXP = /#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/; - const match = SHADER_NAME_REGEXP.exec(shader); - return match ? match[1] : defaultName; -} -function getShaderVersion(source) { - let version2 = 100; - const words = source.match(/[^\s]+/g); - if (words && words.length >= 2 && words[0] === "#version") { - const parsedVersion = parseInt(words[1], 10); - if (Number.isFinite(parsedVersion)) { - version2 = parsedVersion; - } - } - if (version2 !== 100 && version2 !== 300) { - throw new Error(`Invalid GLSL version ${version2}`); - } - return version2; -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders.js -var INJECT_SHADER_DECLARATIONS = ` - -${DECLARATION_INJECT_MARKER} -`; -var FRAGMENT_SHADER_PROLOGUE = `precision highp float; -`; -function assembleShaderWGSL(options) { - const modules = resolveModules(options.modules || []); - return { - source: assembleWGSLShader(options.platformInfo, { - ...options, - source: options.source, - stage: "vertex", - modules - }), - getUniforms: assembleGetUniforms(modules) - }; -} -function assembleShaderPairWGSL(options) { - const modules = resolveModules(options.modules || []); - return { - vs: assembleWGSLShader(options.platformInfo, { - ...options, - source: options.vs, - stage: "vertex", - modules - }), - fs: assembleWGSLShader(options.platformInfo, { - ...options, - source: options.fs, - stage: "fragment", - modules - }), - getUniforms: assembleGetUniforms(modules) - }; -} -function assembleShaderPairGLSL(options) { - const { vs: vs7, fs: fs5 } = options; - const modules = resolveModules(options.modules || []); - return { - vs: assembleGLSLShader(options.platformInfo, { - ...options, - source: vs7, - stage: "vertex", - modules - }), - fs: assembleGLSLShader(options.platformInfo, { - ...options, - source: fs5, - stage: "fragment", - modules - }), - getUniforms: assembleGetUniforms(modules) - }; -} -function assembleWGSLShader(platformInfo, options) { - const { - // id, - source, - stage, - modules, - // defines = {}, - hookFunctions = [], - inject = {}, - log: log4 - } = options; - assert5(typeof source === "string", "shader source must be a string"); - const coreSource = source; - let assembledSource = ""; - const hookFunctionMap = normalizeShaderHooks(hookFunctions); - const hookInjections = {}; - const declInjections = {}; - const mainInjections = {}; - for (const key in inject) { - const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key]; - const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key); - if (match) { - const hash = match[2]; - const name2 = match[3]; - if (hash) { - if (name2 === "decl") { - declInjections[key] = [injection]; - } else { - mainInjections[key] = [injection]; - } - } else { - hookInjections[key] = [injection]; - } - } else { - mainInjections[key] = [injection]; - } - } - const modulesToInject = platformInfo.type !== "webgpu" ? modules : []; - for (const module of modulesToInject) { - if (log4) { - module.checkDeprecations(coreSource, log4); - } - const moduleSource = module.getModuleSource(stage, "wgsl"); - assembledSource += moduleSource; - const injections = module.injections[stage]; - for (const key in injections) { - const match = /^(v|f)s:#([\w-]+)$/.exec(key); - if (match) { - const name2 = match[2]; - const injectionType = name2 === "decl" ? declInjections : mainInjections; - injectionType[key] = injectionType[key] || []; - injectionType[key].push(injections[key]); - } else { - hookInjections[key] = hookInjections[key] || []; - hookInjections[key].push(injections[key]); - } - } - } - assembledSource += INJECT_SHADER_DECLARATIONS; - assembledSource = injectShader(assembledSource, stage, declInjections); - assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections); - assembledSource += coreSource; - assembledSource = injectShader(assembledSource, stage, mainInjections); - return assembledSource; -} -function assembleGLSLShader(platformInfo, options) { - const { id, source, stage, language = "glsl", modules, defines: defines2 = {}, hookFunctions = [], inject = {}, prologue = true, log: log4 } = options; - assert5(typeof source === "string", "shader source must be a string"); - const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1; - const targetVersion = platformInfo.shaderLanguageVersion; - const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es"; - const sourceLines = source.split("\n"); - const coreSource = sourceLines.slice(1).join("\n"); - const allDefines = {}; - modules.forEach((module) => { - Object.assign(allDefines, module.getDefines()); - }); - Object.assign(allDefines, defines2); - let assembledSource = ""; - switch (language) { - case "wgsl": - break; - case "glsl": - assembledSource = prologue ? `${sourceVersionDirective} - -// ----- PROLOGUE ------------------------- -${getShaderNameDefine({ id, source, stage })} -${`#define SHADER_TYPE_${stage.toUpperCase()}`} -${getPlatformShaderDefines(platformInfo)} -${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""} - -// ----- APPLICATION DEFINES ------------------------- - -${getApplicationDefines(allDefines)} - -` : `${sourceVersionDirective} -`; - break; - } - const hookFunctionMap = normalizeShaderHooks(hookFunctions); - const hookInjections = {}; - const declInjections = {}; - const mainInjections = {}; - for (const key in inject) { - const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key]; - const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key); - if (match) { - const hash = match[2]; - const name2 = match[3]; - if (hash) { - if (name2 === "decl") { - declInjections[key] = [injection]; - } else { - mainInjections[key] = [injection]; - } - } else { - hookInjections[key] = [injection]; - } - } else { - mainInjections[key] = [injection]; - } - } - for (const module of modules) { - if (log4) { - module.checkDeprecations(coreSource, log4); - } - const moduleSource = module.getModuleSource(stage); - assembledSource += moduleSource; - const injections = module.injections[stage]; - for (const key in injections) { - const match = /^(v|f)s:#([\w-]+)$/.exec(key); - if (match) { - const name2 = match[2]; - const injectionType = name2 === "decl" ? declInjections : mainInjections; - injectionType[key] = injectionType[key] || []; - injectionType[key].push(injections[key]); - } else { - hookInjections[key] = hookInjections[key] || []; - hookInjections[key].push(injections[key]); - } - } - } - assembledSource += "// ----- MAIN SHADER SOURCE -------------------------"; - assembledSource += INJECT_SHADER_DECLARATIONS; - assembledSource = injectShader(assembledSource, stage, declInjections); - assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections); - assembledSource += coreSource; - assembledSource = injectShader(assembledSource, stage, mainInjections); - if (language === "glsl" && sourceVersion !== targetVersion) { - assembledSource = transpileGLSLShader(assembledSource, stage); - } - return assembledSource.trim(); -} -function assembleGetUniforms(modules) { - return function getUniforms6(opts) { - const uniforms = {}; - for (const module of modules) { - const moduleUniforms = module.getUniforms(opts, uniforms); - Object.assign(uniforms, moduleUniforms); - } - return uniforms; - }; -} -function getShaderNameDefine(options) { - const { id, source, stage } = options; - const injectShaderName = id && source.indexOf("SHADER_NAME") === -1; - return injectShaderName ? ` -#define SHADER_NAME ${id}_${stage} - -` : ""; -} -function getApplicationDefines(defines2 = {}) { - let sourceText = ""; - for (const define2 in defines2) { - const value = defines2[define2]; - if (value || Number.isFinite(value)) { - sourceText += `#define ${define2.toUpperCase()} ${defines2[define2]} -`; - } - } - return sourceText; -} - -// node_modules/@luma.gl/shadertools/dist/lib/shader-assembler.js -var ShaderAssembler = class _ShaderAssembler { - /** Default ShaderAssembler instance */ - static defaultShaderAssembler; - /** Hook functions */ - _hookFunctions = []; - /** Shader modules */ - _defaultModules = []; - /** - * A default shader assembler instance - the natural place to register default modules and hooks - * @returns - */ - static getDefaultShaderAssembler() { - _ShaderAssembler.defaultShaderAssembler = _ShaderAssembler.defaultShaderAssembler || new _ShaderAssembler(); - return _ShaderAssembler.defaultShaderAssembler; - } - /** - * Add a default module that does not have to be provided with every call to assembleShaders() - */ - addDefaultModule(module) { - if (!this._defaultModules.find((m) => m.name === (typeof module === "string" ? module : module.name))) { - this._defaultModules.push(module); - } - } - /** - * Remove a default module - */ - removeDefaultModule(module) { - const moduleName = typeof module === "string" ? module : module.name; - this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName); - } - /** - * Register a shader hook - * @param hook - * @param opts - */ - addShaderHook(hook, opts) { - if (opts) { - hook = Object.assign(opts, { hook }); - } - this._hookFunctions.push(hook); - } - /** - * Assemble a pair of shaders into a single shader program - * @param platformInfo - * @param props - * @returns - */ - assembleShader(props) { - const modules = this._getModuleList(props.modules); - const hookFunctions = this._hookFunctions; - const options = selectShaders(props); - const assembled = assembleShaderWGSL({ - platformInfo: props.platformInfo, - ...options, - modules, - hookFunctions - }); - return { ...assembled, modules }; - } - /** - * Assemble a pair of shaders into a single shader program - * @param platformInfo - * @param props - * @returns - */ - assembleShaderPair(props) { - const options = selectShaders(props); - const modules = this._getModuleList(props.modules); - const hookFunctions = this._hookFunctions; - const { platformInfo } = props; - const isWGSL = props.platformInfo.shaderLanguage === "wgsl"; - const assembled = isWGSL ? assembleShaderPairWGSL({ platformInfo, ...options, modules, hookFunctions }) : assembleShaderPairGLSL({ platformInfo, ...options, modules, hookFunctions }); - return { ...assembled, modules }; - } - /** - * Dedupe and combine with default modules - */ - _getModuleList(appModules = []) { - const modules = new Array(this._defaultModules.length + appModules.length); - const seen = {}; - let count2 = 0; - for (let i = 0, len8 = this._defaultModules.length; i < len8; ++i) { - const module = this._defaultModules[i]; - const name2 = module.name; - modules[count2++] = module; - seen[name2] = true; - } - for (let i = 0, len8 = appModules.length; i < len8; ++i) { - const module = appModules[i]; - const name2 = module.name; - if (!seen[name2]) { - modules[count2++] = module; - seen[name2] = true; - } - } - modules.length = count2; - return ShaderModuleInstance.instantiateModules(modules); - } -}; - -// node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/shader-utils.js -var FS_GLES = `out vec4 transform_output; -void main() { -transform_output = vec4(0); -}`; -var FS300 = `#version 300 es -${FS_GLES}`; -function getPassthroughFS(options) { - const { input, inputChannels, output } = options || {}; - if (!input) { - return FS300; - } - if (!inputChannels) { - throw new Error("inputChannels"); - } - const inputType = channelCountToType(inputChannels); - const outputValue = convertToVec4(input, inputChannels); - return `#version 300 es -in ${inputType} ${input}; -out vec4 ${output}; -void main() { - ${output} = ${outputValue}; -}`; -} -function channelCountToType(channels) { - switch (channels) { - case 1: - return "float"; - case 2: - return "vec2"; - case 3: - return "vec3"; - case 4: - return "vec4"; - default: - throw new Error(`invalid channels: ${channels}`); - } -} -function convertToVec4(variable, channels) { - switch (channels) { - case 1: - return `vec4(${variable}, 0.0, 0.0, 1.0)`; - case 2: - return `vec4(${variable}, 0.0, 1.0)`; - case 3: - return `vec4(${variable}, 1.0)`; - case 4: - return variable; - default: - throw new Error(`invalid channels: ${channels}`); - } -} - -// node_modules/@luma.gl/core/dist/utils/log.js -var log2 = new Log({ id: "luma.gl" }); - -// node_modules/@luma.gl/core/dist/utils/stats-manager.js -var StatsManager = class { - stats = /* @__PURE__ */ new Map(); - getStats(name2) { - return this.get(name2); - } - get(name2) { - if (!this.stats.has(name2)) { - this.stats.set(name2, new Stats({ id: name2 })); - } - return this.stats.get(name2); - } -}; -var lumaStats = new StatsManager(); - -// node_modules/@luma.gl/core/dist/init.js -function initializeLuma() { - const VERSION7 = true ? "9.0.27" : "running from source"; - const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering"; - if (globalThis.luma && globalThis.luma.VERSION !== VERSION7) { - throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION7}`); - } - if (!globalThis.luma) { - if (isBrowser2()) { - log2.log(1, `${VERSION7} - ${STARTUP_MESSAGE}`)(); - } - globalThis.luma = globalThis.luma || { - VERSION: VERSION7, - version: VERSION7, - log: log2, - // A global stats object that various components can add information to - // E.g. see webgl/resource.js - stats: lumaStats - }; - } - return VERSION7; -} -var VERSION6 = initializeLuma(); - -// node_modules/@luma.gl/core/dist/utils/is-array.js -function isTypedArray(value) { - return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null; -} -function isNumberArray(value) { - if (Array.isArray(value)) { - return value.length === 0 || typeof value[0] === "number" ? value : null; - } - return isTypedArray(value); -} - -// node_modules/@luma.gl/core/dist/utils/utils.js -var uidCounters = {}; -function uid(id = "id") { - uidCounters[id] = uidCounters[id] || 1; - const count2 = uidCounters[id]++; - return `${id}-${count2}`; -} -function isObjectEmpty(obj) { - let isEmpty = true; - for (const key in obj) { - isEmpty = false; - break; - } - return isEmpty; -} - -// node_modules/@luma.gl/core/dist/adapter/resources/resource.js -var Resource = class { - /** Default properties for resource */ - static defaultProps = { - id: "undefined", - handle: void 0, - userData: void 0 - }; - /** props.id, for debugging. */ - id; - props; - userData = {}; - _device; - /** Whether this resource has been destroyed */ - destroyed = false; - /** For resources that allocate GPU memory */ - allocatedBytes = 0; - /** Attached resources will be destroyed when this resource is destroyed. Tracks auto-created "sub" resources. */ - _attachedResources = /* @__PURE__ */ new Set(); - /** - * Create a new Resource. Called from Subclass - */ - constructor(device, props, defaultProps14) { - if (!device) { - throw new Error("no device"); - } - this._device = device; - this.props = selectivelyMerge(props, defaultProps14); - const id = this.props.id !== "undefined" ? this.props.id : uid(this[Symbol.toStringTag]); - this.props.id = id; - this.id = id; - this.userData = this.props.userData || {}; - this.addStats(); - } - /** - * destroy can be called on any resource to release it before it is garbage collected. - */ - destroy() { - this.destroyResource(); - } - /** @deprecated Use destroy() */ - delete() { - this.destroy(); - return this; - } - toString() { - return `${this[Symbol.toStringTag] || this.constructor.name}(${this.id})`; - } - /** - * Combines a map of user props and default props, only including props from defaultProps - * @returns returns a map of overridden default props - */ - getProps() { - return this.props; - } - // ATTACHED RESOURCES - /** - * Attaches a resource. Attached resources are auto destroyed when this resource is destroyed - * Called automatically when sub resources are auto created but can be called by application - */ - attachResource(resource) { - this._attachedResources.add(resource); - } - /** - * Detach an attached resource. The resource will no longer be auto-destroyed when this resource is destroyed. - */ - detachResource(resource) { - this._attachedResources.delete(resource); - } - /** - * Destroys a resource (only if owned), and removes from the owned (auto-destroy) list for this resource. - */ - destroyAttachedResource(resource) { - if (this._attachedResources.delete(resource)) { - resource.destroy(); - } - } - /** Destroy all owned resources. Make sure the resources are no longer needed before calling. */ - destroyAttachedResources() { - for (const resource of Object.values(this._attachedResources)) { - resource.destroy(); - } - this._attachedResources = /* @__PURE__ */ new Set(); - } - // PROTECTED METHODS - /** Perform all destroy steps. Can be called by derived resources when overriding destroy() */ - destroyResource() { - this.destroyAttachedResources(); - this.removeStats(); - this.destroyed = true; - } - /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */ - removeStats() { - const stats = this._device.statsManager.getStats("Resource Counts"); - const name2 = this[Symbol.toStringTag]; - stats.get(`${name2}s Active`).decrementCount(); - } - /** Called by subclass to track memory allocations */ - trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) { - const stats = this._device.statsManager.getStats("Resource Counts"); - stats.get("GPU Memory").addCount(bytes); - stats.get(`${name2} Memory`).addCount(bytes); - this.allocatedBytes = bytes; - } - /** Called by subclass to track memory deallocations */ - trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) { - const stats = this._device.statsManager.getStats("Resource Counts"); - stats.get("GPU Memory").subtractCount(this.allocatedBytes); - stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes); - this.allocatedBytes = 0; - } - /** Called by resource constructor to track object creation */ - addStats() { - const stats = this._device.statsManager.getStats("Resource Counts"); - const name2 = this[Symbol.toStringTag]; - stats.get("Resources Created").incrementCount(); - stats.get(`${name2}s Created`).incrementCount(); - stats.get(`${name2}s Active`).incrementCount(); - } -}; -function selectivelyMerge(props, defaultProps14) { - const mergedProps = { ...defaultProps14 }; - for (const key in props) { - if (props[key] !== void 0) { - mergedProps[key] = props[key]; - } - } - return mergedProps; -} - -// node_modules/@luma.gl/core/dist/adapter/resources/buffer.js -var Buffer2 = class _Buffer extends Resource { - static defaultProps = { - ...Resource.defaultProps, - usage: 0, - // Buffer.COPY_DST | Buffer.COPY_SRC - byteLength: 0, - byteOffset: 0, - data: null, - indexType: "uint16", - mappedAtCreation: false - }; - // Usage Flags - static MAP_READ = 1; - static MAP_WRITE = 2; - static COPY_SRC = 4; - static COPY_DST = 8; - /** Index buffer */ - static INDEX = 16; - /** Vertex buffer */ - static VERTEX = 32; - /** Uniform buffer */ - static UNIFORM = 64; - /** Storage buffer */ - static STORAGE = 128; - static INDIRECT = 256; - static QUERY_RESOLVE = 512; - get [Symbol.toStringTag]() { - return "Buffer"; - } - /** The usage with which this buffer was created */ - usage; - /** For index buffers, whether indices are 16 or 32 bit */ - indexType; - /** "Time" of last update */ - updateTimestamp; - constructor(device, props) { - const deducedProps = { ...props }; - if ((props.usage || 0) & _Buffer.INDEX && !props.indexType) { - if (props.data instanceof Uint32Array) { - deducedProps.indexType = "uint32"; - } else if (props.data instanceof Uint16Array) { - deducedProps.indexType = "uint16"; - } - } - super(device, deducedProps, _Buffer.defaultProps); - this.usage = props.usage || 0; - this.indexType = deducedProps.indexType; - this.updateTimestamp = device.incrementTimestamp(); - } - /** Read data synchronously. @note WebGL2 only */ - readSyncWebGL(byteOffset, byteLength) { - throw new Error("not implemented"); - } - // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY) - /** Max amount of debug data saved. Two vec4's */ - static DEBUG_DATA_MAX_LENGTH = 32; - /** A partial CPU-side copy of the data in this buffer, for debugging purposes */ - debugData = new ArrayBuffer(0); - /** This doesn't handle partial non-zero offset updates correctly */ - _setDebugData(data, byteOffset, byteLength) { - const buffer = ArrayBuffer.isView(data) ? data.buffer : data; - const debugDataLength = Math.min(data ? data.byteLength : byteLength, _Buffer.DEBUG_DATA_MAX_LENGTH); - if (data === null) { - this.debugData = new ArrayBuffer(debugDataLength); - } else if (byteOffset === 0 && byteLength === data.byteLength) { - this.debugData = buffer.slice(0, debugDataLength); - } else { - this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength); - } - } -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-data-type.js -function decodeVertexType(type) { - const dataType = TYPE_MAP[type]; - const bytes = getDataTypeBytes(dataType); - const normalized = type.includes("norm"); - const integer = !normalized && !type.startsWith("float"); - const signed = type.startsWith("s"); - return { - dataType: TYPE_MAP[type], - byteLength: bytes, - integer, - signed, - normalized - }; -} -function getDataTypeBytes(type) { - const bytes = TYPE_SIZES[type]; - return bytes; -} -var TYPE_MAP = { - uint8: "uint8", - sint8: "sint8", - unorm8: "uint8", - snorm8: "sint8", - uint16: "uint16", - sint16: "sint16", - unorm16: "uint16", - snorm16: "sint16", - float16: "float16", - float32: "float32", - uint32: "uint32", - sint32: "sint32" -}; -var TYPE_SIZES = { - uint8: 1, - sint8: 1, - uint16: 2, - sint16: 2, - float16: 2, - float32: 4, - uint32: 4, - sint32: 4 -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-texture-format.js -var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [ - "bc1", - "bc2", - "bc3", - "bc4", - "bc5", - "bc6", - "bc7", - "etc1", - "etc2", - "eac", - "atc", - "astc", - "pvrtc" -]; -var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/; -function isTextureFormatCompressed(textureFormat) { - return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some((prefix) => textureFormat.startsWith(prefix)); -} -function decodeTextureFormat(format) { - const matches4 = REGEX.exec(format); - if (matches4) { - const [, format2, length10, type, srgb, suffix] = matches4; - if (format2) { - const dataType = `${type}${length10}`; - const decodedType = decodeVertexType(dataType); - return { - format: format2, - components: format2.length, - // dataType - overwritten by decodedType - srgb: srgb === "-srgb", - unsized: suffix === "-unsized", - webgl: suffix === "-webgl", - ...decodedType - }; - } - } - return decodeNonStandardFormat(format); -} -var EXCEPTIONS = { - // Packed 16 bit formats - "rgba4unorm-webgl": { format: "rgba", bpp: 2 }, - "rgb565unorm-webgl": { format: "rgb", bpp: 2 }, - "rgb5a1unorm-webgl": { format: "rgba", bbp: 2 }, - // Packed 32 bit formats - rgb9e5ufloat: { format: "rgb", bbp: 4 }, - rg11b10ufloat: { format: "rgb", bbp: 4 }, - rgb10a2unorm: { format: "rgba", bbp: 4 }, - "rgb10a2uint-webgl": { format: "rgba", bbp: 4 }, - // Depth/stencil - stencil8: { components: 1, bpp: 1, a: "stencil" }, - depth16unorm: { components: 1, bpp: 2, a: "depth" }, - depth24plus: { components: 1, bpp: 3, a: "depth" }, - depth32float: { components: 1, bpp: 4, a: "depth" }, - "depth24plus-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }, - // "depth24unorm-stencil8" feature - "depth24unorm-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }, - // "depth32float-stencil8" feature - "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" } -}; -function decodeNonStandardFormat(format) { - const data = EXCEPTIONS[format]; - if (!data) { - throw new Error(`Unknown format ${format}`); - } - return { - format: data.format || "", - components: data.components || data.format?.length || 1, - byteLength: data.bpp || 1, - srgb: false, - unsized: false - }; -} - -// node_modules/@luma.gl/core/dist/adapter/device.js -var DeviceLimits = class { -}; -var DeviceFeatures = class { - features; - disabledFeatures; - constructor(features = [], disabledFeatures) { - this.features = new Set(features); - this.disabledFeatures = disabledFeatures || {}; - } - *[Symbol.iterator]() { - yield* this.features; - } - has(feature) { - return !this.disabledFeatures[feature] && this.features.has(feature); - } -}; -var Device = class _Device { - static defaultProps = { - id: null, - canvas: null, - container: null, - manageState: true, - width: 800, - // width are height are only used by headless gl - height: 600, - requestMaxLimits: true, - debug: Boolean(log2.get("debug")), - // Instrument context (at the expense of performance) - spector: Boolean(log2.get("spector") || log2.get("spectorjs")), - // Initialize the SpectorJS WebGL debugger - break: [], - // TODO - Change these after confirming things work as expected - initalizeFeatures: true, - disabledFeatures: { - "compilation-status-async-webgl": true - }, - // alpha: undefined, - // depth: undefined, - // stencil: undefined, - // antialias: undefined, - // premultipliedAlpha: undefined, - // preserveDrawingBuffer: undefined, - // failIfMajorPerformanceCaveat: undefined - gl: null, - // Callbacks - onError: (error) => log2.error(error.message) - }; - get [Symbol.toStringTag]() { - return "Device"; - } - static VERSION = VERSION6; - constructor(props) { - this.props = { ..._Device.defaultProps, ...props }; - this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase()); - } - /** id of this device, primarily for debugging */ - id; - /** A copy of the device props */ - props; - /** Available for the application to store data on the device */ - userData = {}; - /** stats */ - statsManager = lumaStats; - /** Used by other luma.gl modules to store data on the device */ - _lumaData = {}; - /** Check if a specific texture format is GPU compressed */ - isTextureFormatCompressed(format) { - return isTextureFormatCompressed(format); - } - /** - * Trigger device loss. - * @returns `true` if context loss could actually be triggered. - * @note primarily intended for testing how application reacts to device loss - */ - loseDevice() { - return false; - } - /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */ - getCanvasContext() { - if (!this.canvasContext) { - throw new Error("Device has no CanvasContext"); - } - return this.canvasContext; - } - createTexture(props) { - if (props instanceof Promise || typeof props === "string") { - props = { data: props }; - } - return this._createTexture(props); - } - createCommandEncoder(props = {}) { - throw new Error("not implemented"); - } - // WebGL specific HACKS - enables app to remove webgl import - // Use until we have a better way to handle these - /** @deprecated - will be removed - should use command encoder */ - readPixelsToArrayWebGL(source, options) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use command encoder */ - readPixelsToBufferWebGL(source, options) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ - setParametersWebGL(parameters) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ - getParametersWebGL(parameters) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */ - withParametersWebGL(parameters, func) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use clear arguments in RenderPass */ - clearWebGL(options) { - throw new Error("not implemented"); - } - /** @deprecated - will be removed - should use for debugging only */ - resetWebGL() { - throw new Error("not implemented"); - } - timestamp = 0; - /** A monotonic counter for tracking buffer and texture updates */ - incrementTimestamp() { - return this.timestamp++; - } - // Error Handling - /** Report unhandled device errors */ - onError(error) { - this.props.onError(error); - } - // IMPLEMENTATION - _getBufferProps(props) { - if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) { - props = { data: props }; - } - const newProps = { ...props }; - if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) { - if (props.data instanceof Uint32Array) { - newProps.indexType = "uint32"; - } else if (props.data instanceof Uint16Array) { - newProps.indexType = "uint16"; - } else { - log2.warn("indices buffer content must be of integer type")(); - } - } - return newProps; - } -}; - -// node_modules/@luma.gl/core/dist/utils/assert.js -function assert6(condition, message2) { - if (!condition) { - throw new Error(message2 || "luma.gl: assertion failed."); - } -} - -// node_modules/@luma.gl/core/dist/lib/luma.js -var deviceMap = /* @__PURE__ */ new Map(); -var luma = class _luma { - static defaultProps = { - ...Device.defaultProps, - type: "best-available", - devices: void 0 - }; - /** Global stats for all devices */ - static stats = lumaStats; - /** Global log */ - static log = log2; - static registerDevices(deviceClasses) { - for (const deviceClass of deviceClasses) { - assert6(deviceClass.type && deviceClass.isSupported && deviceClass.create); - deviceMap.set(deviceClass.type, deviceClass); - } - } - static getAvailableDevices() { - return Array.from(deviceMap).map((Device2) => Device2.type); - } - static getSupportedDevices() { - return Array.from(deviceMap).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type); - } - static setDefaultDeviceProps(props) { - Object.assign(Device.defaultProps, props); - } - /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */ - static async attachDevice(props) { - const devices = getDeviceMap(props.devices) || deviceMap; - if (props.handle instanceof WebGL2RenderingContext) { - const WebGLDevice2 = devices.get("webgl"); - if (WebGLDevice2) { - return await WebGLDevice2.attach(props.handle); - } - } - if (props.handle === null) { - const UnknownDevice = devices.get("unknown"); - if (UnknownDevice) { - return await UnknownDevice.attach(null); - } - } - throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."); - } - /** Creates a device. Asynchronously. */ - static async createDevice(props = {}) { - props = { ..._luma.defaultProps, ...props }; - if (props.gl) { - props.type = "webgl"; - } - const devices = getDeviceMap(props.devices) || deviceMap; - let WebGPUDevice; - let WebGLDevice2; - switch (props.type) { - case "webgpu": - WebGPUDevice = devices.get("webgpu"); - if (WebGPUDevice) { - return await WebGPUDevice.create(props); - } - break; - case "webgl": - WebGLDevice2 = devices.get("webgl"); - if (WebGLDevice2) { - return await WebGLDevice2.create(props); - } - break; - case "unknown": - const UnknownDevice = devices.get("unknown"); - if (UnknownDevice) { - return await UnknownDevice.create(props); - } - break; - case "best-available": - WebGPUDevice = devices.get("webgpu"); - if (WebGPUDevice?.isSupported?.()) { - return await WebGPUDevice.create(props); - } - WebGLDevice2 = devices.get("webgl"); - if (WebGLDevice2?.isSupported?.()) { - return await WebGLDevice2.create(props); - } - break; - } - throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."); - } - static enforceWebGL2(enforce = true) { - const prototype = HTMLCanvasElement.prototype; - if (!enforce && prototype.originalGetContext) { - prototype.getContext = prototype.originalGetContext; - prototype.originalGetContext = void 0; - return; - } - prototype.originalGetContext = prototype.getContext; - prototype.getContext = function(contextId, options) { - if (contextId === "webgl" || contextId === "experimental-webgl") { - return this.originalGetContext("webgl2", options); - } - return this.originalGetContext(contextId, options); - }; - } -}; -function getDeviceMap(deviceClasses) { - if (!deviceClasses || deviceClasses?.length === 0) { - return null; - } - const map3 = /* @__PURE__ */ new Map(); - for (const deviceClass of deviceClasses) { - map3.set(deviceClass.type, deviceClass); - } - return map3; -} - -// node_modules/@luma.gl/core/dist/adapter/canvas-context.js -var isPage = isBrowser2() && typeof document !== "undefined"; -var isPageLoaded = () => isPage && document.readyState === "complete"; -var DEFAULT_CANVAS_CONTEXT_PROPS = { - canvas: null, - width: 800, - // width are height are only used by headless gl - height: 600, - useDevicePixels: true, - autoResize: true, - container: null, - visible: true, - colorSpace: "srgb", - alphaMode: "opaque" -}; -var CanvasContext = class { - id; - props; - canvas; - htmlCanvas; - offscreenCanvas; - type; - width = 1; - height = 1; - resizeObserver; - /** State used by luma.gl classes: TODO - move to canvasContext*/ - _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 }; - /** Check if the DOM is loaded */ - static get isPageLoaded() { - return isPageLoaded(); - } - /** - * Get a 'lazy' promise that resolves when the DOM is loaded. - * @note Since there may be limitations on number of `load` event listeners, - * it is recommended avoid calling this function until actually needed. - * I.e. don't call it until you know that you will be looking up a string in the DOM. - */ - static pageLoaded = getPageLoadPromise(); - constructor(props) { - this.props = { ...DEFAULT_CANVAS_CONTEXT_PROPS, ...props }; - props = this.props; - if (!isBrowser2()) { - this.id = "node-canvas-context"; - this.type = "node"; - this.width = this.props.width; - this.height = this.props.height; - this.canvas = null; - return; - } - if (!props.canvas) { - const canvas2 = createCanvas(props); - const container = getContainer(props?.container || null); - container.insertBefore(canvas2, container.firstChild); - this.canvas = canvas2; - if (!props?.visible) { - this.canvas.style.visibility = "hidden"; - } - } else if (typeof props.canvas === "string") { - this.canvas = getCanvasFromDOM(props.canvas); - } else { - this.canvas = props.canvas; - } - if (this.canvas instanceof HTMLCanvasElement) { - this.id = this.canvas.id; - this.type = "html-canvas"; - this.htmlCanvas = this.canvas; - } else { - this.id = "offscreen-canvas"; - this.type = "offscreen-canvas"; - this.offscreenCanvas = this.canvas; - } - if (this.canvas instanceof HTMLCanvasElement && props.autoResize) { - this.resizeObserver = new ResizeObserver((entries) => { - for (const entry of entries) { - if (entry.target === this.canvas) { - this.update(); - } - } - }); - this.resizeObserver.observe(this.canvas); - } - } - /** - * Returns the current DPR, if props.useDevicePixels is true - * Device refers to physical - */ - getDevicePixelRatio(useDevicePixels) { - if (typeof OffscreenCanvas !== "undefined" && this.canvas instanceof OffscreenCanvas) { - return 1; - } - useDevicePixels = useDevicePixels === void 0 ? this.props.useDevicePixels : useDevicePixels; - if (!useDevicePixels || useDevicePixels <= 0) { - return 1; - } - if (useDevicePixels === true) { - const dpr = typeof window !== "undefined" && window.devicePixelRatio; - return dpr || 1; - } - return useDevicePixels; - } - /** - * Returns the size of drawing buffer in device pixels. - * @note This can be different from the 'CSS' size of a canvas, and also from the - * canvas' internal drawing buffer size (.width, .height). - * This is the size required to cover the canvas, adjusted for DPR - */ - getPixelSize() { - switch (this.type) { - case "node": - return [this.width, this.height]; - case "offscreen-canvas": - return [this.canvas.width, this.canvas.height]; - case "html-canvas": - const dpr = this.getDevicePixelRatio(); - const canvas2 = this.canvas; - return canvas2.parentElement ? [canvas2.clientWidth * dpr, canvas2.clientHeight * dpr] : [this.canvas.width, this.canvas.height]; - default: - throw new Error(this.type); - } - } - getAspect() { - const [width, height] = this.getPixelSize(); - return width / height; - } - /** - * Returns multiplier need to convert CSS size to Device size - */ - cssToDeviceRatio() { - try { - const [drawingBufferWidth] = this.getDrawingBufferSize(); - const { clientWidth } = this._canvasSizeInfo; - return clientWidth ? drawingBufferWidth / clientWidth : 1; - } catch { - return 1; - } - } - /** - * Maps CSS pixel position to device pixel position - */ - cssToDevicePixels(cssPixel, yInvert = true) { - const ratio = this.cssToDeviceRatio(); - const [width, height] = this.getDrawingBufferSize(); - return scalePixels(cssPixel, ratio, width, height, yInvert); - } - /** - * Use devicePixelRatio to set canvas width and height - * @note this is a raw port of luma.gl v8 code. Might be worth a review - */ - setDevicePixelRatio(devicePixelRatio, options = {}) { - if (!this.htmlCanvas) { - return; - } - let clientWidth = "width" in options ? options.width : this.htmlCanvas.clientWidth; - let clientHeight = "height" in options ? options.height : this.htmlCanvas.clientHeight; - if (!clientWidth || !clientHeight) { - log2.log(1, "Canvas clientWidth/clientHeight is 0")(); - devicePixelRatio = 1; - clientWidth = this.htmlCanvas.width || 1; - clientHeight = this.htmlCanvas.height || 1; - } - const cachedSize = this._canvasSizeInfo; - if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) { - let clampedPixelRatio = devicePixelRatio; - const canvasWidth = Math.floor(clientWidth * clampedPixelRatio); - const canvasHeight = Math.floor(clientHeight * clampedPixelRatio); - this.htmlCanvas.width = canvasWidth; - this.htmlCanvas.height = canvasHeight; - const [drawingBufferWidth, drawingBufferHeight] = this.getDrawingBufferSize(); - if (drawingBufferWidth !== canvasWidth || drawingBufferHeight !== canvasHeight) { - clampedPixelRatio = Math.min(drawingBufferWidth / clientWidth, drawingBufferHeight / clientHeight); - this.htmlCanvas.width = Math.floor(clientWidth * clampedPixelRatio); - this.htmlCanvas.height = Math.floor(clientHeight * clampedPixelRatio); - log2.warn("Device pixel ratio clamped")(); - } - this._canvasSizeInfo.clientWidth = clientWidth; - this._canvasSizeInfo.clientHeight = clientHeight; - this._canvasSizeInfo.devicePixelRatio = devicePixelRatio; - } - } - // PRIVATE - /** @todo Major hack done to port the CSS methods above, base canvas context should not depend on WebGL */ - getDrawingBufferSize() { - const gl = this.device.gl; - if (!gl) { - throw new Error("canvas size"); - } - return [gl.drawingBufferWidth, gl.drawingBufferHeight]; - } - /** - * Allows subclass constructor to override the canvas id for auto created canvases. - * This can really help when debugging DOM in apps that create multiple devices - */ - _setAutoCreatedCanvasId(id) { - if (this.htmlCanvas?.id === "lumagl-auto-created-canvas") { - this.htmlCanvas.id = id; - } - } -}; -function getPageLoadPromise() { - if (isPageLoaded() || typeof window === "undefined") { - return Promise.resolve(); - } - return new Promise((resolve2) => { - window.addEventListener("load", () => resolve2()); - }); -} -function getContainer(container) { - if (typeof container === "string") { - const element = document.getElementById(container); - if (!element && !isPageLoaded()) { - throw new Error(`Accessing '${container}' before page was loaded`); - } - if (!element) { - throw new Error(`${container} is not an HTML element`); - } - return element; - } else if (container) { - return container; - } - return document.body; -} -function getCanvasFromDOM(canvasId) { - const canvas2 = document.getElementById(canvasId); - if (!canvas2 && !isPageLoaded()) { - throw new Error(`Accessing '${canvasId}' before page was loaded`); - } - if (!(canvas2 instanceof HTMLCanvasElement)) { - throw new Error("Object is not a canvas element"); - } - return canvas2; -} -function createCanvas(props) { - const { width, height } = props; - const targetCanvas = document.createElement("canvas"); - targetCanvas.id = "lumagl-auto-created-canvas"; - targetCanvas.width = width || 1; - targetCanvas.height = height || 1; - targetCanvas.style.width = Number.isFinite(width) ? `${width}px` : "100%"; - targetCanvas.style.height = Number.isFinite(height) ? `${height}px` : "100%"; - return targetCanvas; -} -function scalePixels(pixel, ratio, width, height, yInvert) { - const point = pixel; - const x = scaleX(point[0], ratio, width); - let y = scaleY(point[1], ratio, height, yInvert); - let t = scaleX(point[0] + 1, ratio, width); - const xHigh = t === width - 1 ? t : t - 1; - t = scaleY(point[1] + 1, ratio, height, yInvert); - let yHigh; - if (yInvert) { - t = t === 0 ? t : t + 1; - yHigh = y; - y = t; - } else { - yHigh = t === height - 1 ? t : t - 1; - } - return { - x, - y, - // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases. - width: Math.max(xHigh - x + 1, 1), - height: Math.max(yHigh - y + 1, 1) - }; -} -function scaleX(x, ratio, width) { - const r = Math.min(Math.round(x * ratio), width - 1); - return r; -} -function scaleY(y, ratio, height, yInvert) { - return yInvert ? Math.max(0, height - 1 - Math.round(y * ratio)) : Math.min(Math.round(y * ratio), height - 1); -} - -// node_modules/@luma.gl/core/dist/adapter/resources/texture.js -var Texture = class _Texture extends Resource { - static defaultProps = { - ...Resource.defaultProps, - data: null, - dimension: "2d", - format: "rgba8unorm", - width: void 0, - height: void 0, - depth: 1, - mipmaps: true, - // type: undefined, - compressed: false, - // mipLevels: 1, - usage: 0, - // usage: GPUTextureUsage.COPY_DST - mipLevels: void 0, - samples: void 0, - type: void 0, - sampler: {}, - view: void 0 - }; - static COPY_SRC = 1; - static COPY_DST = 2; - static TEXTURE_BINDING = 4; - static STORAGE_BINDING = 8; - static RENDER_ATTACHMENT = 16; - get [Symbol.toStringTag]() { - return "Texture"; - } - /** dimension of this texture */ - dimension; - /** format of this texture */ - format; - /** width in pixels of this texture */ - width; - /** height in pixels of this texture */ - height; - /** depth of this texture */ - depth; - /** "Time" of last update. Monotonically increasing timestamp */ - updateTimestamp; - /** Do not use directly. Create with device.createTexture() */ - constructor(device, props, defaultProps14 = _Texture.defaultProps) { - super(device, props, defaultProps14); - this.dimension = this.props.dimension; - this.format = this.props.format; - this.width = this.props.width; - this.height = this.props.height; - this.depth = this.props.depth; - this.updateTimestamp = device.incrementTimestamp(); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/texture-view.js -var TextureView = class _TextureView extends Resource { - static defaultProps = { - ...Resource.defaultProps, - format: void 0, - dimension: void 0, - aspect: "all", - baseMipLevel: 0, - mipLevelCount: void 0, - baseArrayLayer: 0, - arrayLayerCount: void 0 - }; - get [Symbol.toStringTag]() { - return "TextureView"; - } - /** Should not be constructed directly. Use `texture.createView(props)` */ - constructor(device, props) { - super(device, props, _TextureView.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/lib/compiler-log/format-compiler-log.js -function formatCompilerLog(shaderLog, source, options) { - let formattedLog = ""; - const lines = source.split(/\r?\n/); - const log4 = shaderLog.slice().sort((a, b) => a.lineNum - b.lineNum); - switch (options?.showSourceCode || "no") { - case "all": - let currentMessage = 0; - for (let lineNum = 1; lineNum <= lines.length; lineNum++) { - formattedLog += getNumberedLine(lines[lineNum - 1], lineNum, options); - while (log4.length > currentMessage && log4[currentMessage].lineNum === lineNum) { - const message2 = log4[currentMessage++]; - formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, { - ...options, - inlineSource: false - }); - } - } - return formattedLog; - case "issues": - case "no": - for (const message2 of shaderLog) { - formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, { - inlineSource: options?.showSourceCode !== "no" - }); - } - return formattedLog; - } -} -function formatCompilerMessage(message2, lines, lineNum, options) { - if (options?.inlineSource) { - const numberedLines = getNumberedLines(lines, lineNum); - const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^ -` : ""; - return ` -${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message} - -`; - } - return options?.html ? `
${message2.type.toUpperCase()}: ${message2.message}
` : `${message2.type.toUpperCase()}: ${message2.message}`; -} -function getNumberedLines(lines, lineNum, options) { - let numberedLines = ""; - for (let lineIndex = lineNum - 2; lineIndex <= lineNum; lineIndex++) { - const sourceLine = lines[lineIndex - 1]; - if (sourceLine !== void 0) { - numberedLines += getNumberedLine(sourceLine, lineNum, options); - } - } - return numberedLines; -} -function getNumberedLine(line, lineNum, options) { - const escapedLine = options?.html ? escapeHTML(line) : line; - return `${padLeft(String(lineNum), 4)}: ${escapedLine}${options?.html ? "
" : "\n"}`; -} -function padLeft(string, paddedLength) { - let result = ""; - for (let i = string.length; i < paddedLength; ++i) { - result += " "; - } - return result + string; -} -function escapeHTML(unsafe) { - return unsafe.replaceAll("&", "&").replaceAll("<", "<").replaceAll(">", ">").replaceAll('"', """).replaceAll("'", "'"); -} - -// node_modules/@luma.gl/core/dist/lib/compiler-log/get-shader-info.js -function getShaderInfo2(source, defaultName) { - return { - name: getShaderName2(source, defaultName), - language: "glsl", - version: getShaderVersion2(source) - }; -} -function getShaderName2(shader, defaultName = "unnamed") { - const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/; - const match = SHADER_NAME_REGEXP.exec(shader); - return match ? match[1] : defaultName; -} -function getShaderVersion2(source) { - let version2 = 100; - const words = source.match(/[^\s]+/g); - if (words && words.length >= 2 && words[0] === "#version") { - const v = parseInt(words[1], 10); - if (Number.isFinite(v)) { - version2 = v; - } - } - return version2; -} - -// node_modules/@luma.gl/core/dist/adapter/resources/shader.js -var Shader = class _Shader extends Resource { - static defaultProps = { - ...Resource.defaultProps, - language: "auto", - stage: void 0, - source: "", - sourceMap: null, - entryPoint: "main", - debug: "errors" - }; - get [Symbol.toStringTag]() { - return "Shader"; - } - /** The stage of this shader */ - stage; - /** The source code of this shader */ - source; - /** The compilation status of the shader. 'pending' if compilation is asynchronous, and on production */ - compilationStatus = "pending"; - /** Create a new Shader instance */ - constructor(device, props) { - super(device, { id: getShaderIdFromProps(props), ...props }, _Shader.defaultProps); - this.stage = this.props.stage; - this.source = this.props.source; - } - /** Get compiler log synchronously (WebGL only) */ - getCompilationInfoSync() { - return null; - } - /** Get translated shader source in host platform's native language (HLSL, GLSL, and even GLSL ES), if available */ - getTranslatedSource() { - return null; - } - // PORTABLE HELPERS - /** In browser logging of errors */ - async debugShader(trigger = this.props.debug) { - switch (trigger) { - case "never": - return; - case "errors": - if (this.compilationStatus === "success") { - return; - } - break; - case "warnings": - case "always": - break; - } - const messages = await this.getCompilationInfo(); - if (this.props.debug === "warnings" && messages?.length === 0) { - return; - } - this._displayShaderLog(messages); - } - // PRIVATE - /** In-browser UI logging of errors */ - _displayShaderLog(messages) { - if (typeof document === "undefined" || !document?.createElement) { - return; - } - const shaderName = getShaderInfo2(this.source).name; - const shaderTitle = `${this.stage} ${shaderName}`; - let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true }); - const translatedSource = this.getTranslatedSource(); - if (translatedSource) { - htmlLog += `

Translated Source



${translatedSource}
`; - } - const button = document.createElement("Button"); - button.innerHTML = ` -

Shader Compilation Error in ${shaderTitle}



-
-${htmlLog}
-
`; - button.style.top = "10px"; - button.style.left = "10px"; - button.style.position = "absolute"; - button.style.zIndex = "9999"; - button.style.width = "100%"; - button.style.textAlign = "left"; - document.body.appendChild(button); - const errors = document.getElementsByClassName("luma-compiler-log-error"); - if (errors[0]?.scrollIntoView) { - errors[0].scrollIntoView(); - } - button.onclick = () => { - const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`; - navigator.clipboard.writeText(dataURI); - }; - } -}; -function getShaderIdFromProps(props) { - return getShaderInfo2(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`); -} - -// node_modules/@luma.gl/core/dist/adapter/resources/sampler.js -var Sampler = class _Sampler extends Resource { - static defaultProps = { - ...Resource.defaultProps, - type: "color-sampler", - addressModeU: "clamp-to-edge", - addressModeV: "clamp-to-edge", - addressModeW: "clamp-to-edge", - magFilter: "nearest", - minFilter: "nearest", - mipmapFilter: "nearest", - lodMinClamp: 0, - lodMaxClamp: 32, - // Per WebGPU spec - compare: "less-equal", - maxAnisotropy: 1 - }; - get [Symbol.toStringTag]() { - return "Sampler"; - } - constructor(device, props) { - super(device, props, _Sampler.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/framebuffer.js -var Framebuffer = class _Framebuffer extends Resource { - static defaultProps = { - ...Resource.defaultProps, - width: 1, - height: 1, - colorAttachments: [], - // ['rgba8unorm'], - depthStencilAttachment: null - // 'depth24plus-stencil8' - }; - get [Symbol.toStringTag]() { - return "Framebuffer"; - } - /** Width of all attachments in this framebuffer */ - width; - /** Height of all attachments in this framebuffer */ - height; - /** Color attachments */ - colorAttachments = []; - /** Depth-stencil attachment, if provided */ - depthStencilAttachment = null; - constructor(device, props = {}) { - super(device, props, _Framebuffer.defaultProps); - this.width = this.props.width; - this.height = this.props.height; - } - resize(size) { - let updateSize = !size; - if (size) { - const [width, height] = Array.isArray(size) ? size : [size.width, size.height]; - updateSize = updateSize || height !== this.height || width !== this.width; - this.width = width; - this.height = height; - } - if (updateSize) { - log2.log(2, `Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)(); - this.resizeAttachments(this.width, this.height); - } - } - /** Auto creates any textures */ - autoCreateAttachmentTextures() { - if (this.props.colorAttachments.length === 0 && !this.props.depthStencilAttachment) { - throw new Error("Framebuffer has noattachments"); - } - this.colorAttachments = this.props.colorAttachments.map((attachment2) => { - if (typeof attachment2 === "string") { - const texture = this.createColorTexture(attachment2); - this.attachResource(texture); - return texture.view; - } - if (attachment2 instanceof Texture) { - return attachment2.view; - } - return attachment2; - }); - const attachment = this.props.depthStencilAttachment; - if (attachment) { - if (typeof attachment === "string") { - const texture = this.createDepthStencilTexture(attachment); - this.attachResource(texture); - this.depthStencilAttachment = texture.view; - } else if (attachment instanceof Texture) { - this.depthStencilAttachment = attachment.view; - } else { - this.depthStencilAttachment = attachment; - } - } - } - /** Create a color texture */ - createColorTexture(format) { - return this.device.createTexture({ - id: "color-attachment", - usage: Texture.RENDER_ATTACHMENT, - format, - width: this.width, - height: this.height - }); - } - /** Create depth stencil texture */ - createDepthStencilTexture(format) { - return this.device.createTexture({ - id: "depth-stencil-attachment", - usage: Texture.RENDER_ATTACHMENT, - format, - width: this.width, - height: this.height - }); - } - /** - * Default implementation of resize - * Creates new textures with correct size for all attachments. - * and destroys existing textures if owned - */ - resizeAttachments(width, height) { - for (let i = 0; i < this.colorAttachments.length; ++i) { - if (this.colorAttachments[i]) { - const resizedTexture = this.device._createTexture({ - ...this.colorAttachments[i].props, - width, - height - }); - this.destroyAttachedResource(this.colorAttachments[i]); - this.colorAttachments[i] = resizedTexture.view; - this.attachResource(resizedTexture.view); - } - } - if (this.depthStencilAttachment) { - const resizedTexture = this.device._createTexture({ - ...this.depthStencilAttachment.props, - width, - height - }); - this.destroyAttachedResource(this.depthStencilAttachment); - this.depthStencilAttachment = resizedTexture.view; - this.attachResource(resizedTexture); - } - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/render-pipeline.js -var RenderPipeline = class _RenderPipeline extends Resource { - static defaultProps = { - ...Resource.defaultProps, - vs: null, - vertexEntryPoint: "vertexMain", - vsConstants: {}, - fs: null, - fragmentEntryPoint: "fragmentMain", - fsConstants: {}, - shaderLayout: null, - bufferLayout: [], - topology: "triangle-list", - parameters: {}, - // isInstanced: false, - // instanceCount: 0, - // vertexCount: 0, - bindings: {}, - uniforms: {} - }; - get [Symbol.toStringTag]() { - return "RenderPipeline"; - } - /** The merged layout */ - shaderLayout; - /** Buffer map describing buffer interleaving etc */ - bufferLayout; - /** The linking status of the pipeline. 'pending' if linking is asynchronous, and on production */ - linkStatus = "pending"; - /** The hash of the pipeline */ - hash = ""; - constructor(device, props) { - super(device, props, _RenderPipeline.defaultProps); - this.shaderLayout = this.props.shaderLayout; - this.bufferLayout = this.props.bufferLayout || []; - } - // DEPRECATED METHODS - /** - * Uniforms - * @deprecated Use uniforms buffers - * @note textures, samplers and uniform buffers should be set via `setBindings()`, these are not considered uniforms. - * @note In WebGL uniforms have a performance penalty, they are reset before each call to enable pipeline sharing. - */ - setUniformsWebGL(uniforms) { - throw new Error("Use uniform blocks"); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/render-pass.js -var RenderPass = class _RenderPass extends Resource { - /** Default properties for RenderPass */ - static defaultProps = { - ...Resource.defaultProps, - framebuffer: null, - parameters: void 0, - clearColor: [0, 0, 0, 0], - clearDepth: 1, - clearStencil: 0, - depthReadOnly: false, - stencilReadOnly: false, - discard: false, - occlusionQuerySet: void 0, - timestampQuerySet: void 0, - beginTimestampIndex: void 0, - endTimestampIndex: void 0 - }; - get [Symbol.toStringTag]() { - return "RenderPass"; - } - constructor(device, props) { - super(device, props, _RenderPass.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/compute-pipeline.js -var ComputePipeline = class _ComputePipeline extends Resource { - static defaultProps = { - ...Resource.defaultProps, - shader: void 0, - entryPoint: void 0, - constants: {}, - shaderLayout: void 0 - }; - get [Symbol.toStringTag]() { - return "ComputePipeline"; - } - hash = ""; - constructor(device, props) { - super(device, props, _ComputePipeline.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/command-encoder.js -var CommandEncoder = class _CommandEncoder extends Resource { - static defaultProps = { - ...Resource.defaultProps, - measureExecutionTime: void 0 - }; - get [Symbol.toStringTag]() { - return "CommandEncoder"; - } - constructor(device, props) { - super(device, props, _CommandEncoder.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/command-buffer.js -var CommandBuffer = class _CommandBuffer extends Resource { - static defaultProps = { - ...Resource.defaultProps - }; - get [Symbol.toStringTag]() { - return "CommandBuffer"; - } - constructor(device, props) { - super(device, props, _CommandBuffer.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-attribute-type.js -function decodeShaderAttributeType(attributeType) { - const [dataType, components] = TYPE_INFO[attributeType]; - const integer = dataType === "i32" || dataType === "u32"; - const signed = dataType !== "u32"; - const byteLength = TYPE_SIZES2[dataType] * components; - const defaultVertexFormat = getCompatibleVertexFormat(dataType, components); - return { - dataType, - components, - defaultVertexFormat, - byteLength, - integer, - signed - }; -} -function getCompatibleVertexFormat(dataType, components) { - let vertexType; - switch (dataType) { - case "f32": - vertexType = "float32"; - break; - case "i32": - vertexType = "sint32"; - break; - case "u32": - vertexType = "uint32"; - break; - case "f16": - return components <= 2 ? "float16x2" : "float16x4"; - } - if (components === 1) { - return vertexType; - } - return `${vertexType}x${components}`; -} -var TYPE_INFO = { - f32: ["f32", 1], - "vec2": ["f32", 2], - "vec3": ["f32", 3], - "vec4": ["f32", 4], - f16: ["f16", 1], - "vec2": ["f16", 2], - "vec3": ["f16", 3], - "vec4": ["f16", 4], - i32: ["i32", 1], - "vec2": ["i32", 2], - "vec3": ["i32", 3], - "vec4": ["i32", 4], - u32: ["u32", 1], - "vec2": ["u32", 2], - "vec3": ["u32", 3], - "vec4": ["u32", 4] -}; -var TYPE_SIZES2 = { - f32: 4, - f16: 2, - i32: 4, - u32: 4 - // 'bool-webgl': 4, -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-vertex-format.js -function decodeVertexFormat(format) { - let webglOnly; - if (format.endsWith("-webgl")) { - format.replace("-webgl", ""); - webglOnly = true; - } - const [type_, count2] = format.split("x"); - const type = type_; - const components = count2 ? parseInt(count2) : 1; - const decodedType = decodeVertexType(type); - const result = { - type, - components, - byteLength: decodedType.byteLength * components, - integer: decodedType.integer, - signed: decodedType.signed, - normalized: decodedType.normalized - }; - if (webglOnly) { - result.webglOnly = true; - } - return result; -} - -// node_modules/@luma.gl/core/dist/adapter/attribute-utils/get-attribute-from-layouts.js -function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) { - const attributeInfos = {}; - for (const attribute of shaderLayout.attributes) { - attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name); - } - return attributeInfos; -} -function getAttributeInfosByLocation(shaderLayout, bufferLayout, maxVertexAttributes = 16) { - const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout); - const locationInfos = new Array(maxVertexAttributes).fill(null); - for (const attributeInfo of Object.values(attributeInfos)) { - locationInfos[attributeInfo.location] = attributeInfo; - } - return locationInfos; -} -function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) { - const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2); - const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2); - if (!shaderDeclaration) { - return null; - } - const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type); - const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat; - const vertexFormatInfo = decodeVertexFormat(vertexFormat); - return { - attributeName: bufferMapping?.attributeName || shaderDeclaration.name, - bufferName: bufferMapping?.bufferName || shaderDeclaration.name, - location: shaderDeclaration.location, - shaderType: shaderDeclaration.type, - shaderDataType: attributeTypeInfo.dataType, - shaderComponents: attributeTypeInfo.components, - vertexFormat, - bufferDataType: vertexFormatInfo.type, - bufferComponents: vertexFormatInfo.components, - // normalized is a property of the buffer's vertex format - normalized: vertexFormatInfo.normalized, - // integer is a property of the shader declaration - integer: attributeTypeInfo.integer, - stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode, - byteOffset: bufferMapping?.byteOffset || 0, - byteStride: bufferMapping?.byteStride || 0 - }; -} -function getAttributeFromShaderLayout(shaderLayout, name2) { - const attribute = shaderLayout.attributes.find((attr) => attr.name === name2); - if (!attribute) { - log2.warn(`shader layout attribute "${name2}" not present in shader`); - } - return attribute || null; -} -function getAttributeFromBufferLayout(bufferLayouts, name2) { - checkBufferLayouts(bufferLayouts); - let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2); - if (bufferLayoutInfo) { - return bufferLayoutInfo; - } - bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2); - if (bufferLayoutInfo) { - return bufferLayoutInfo; - } - log2.warn(`layout for attribute "${name2}" not present in buffer layout`); - return null; -} -function checkBufferLayouts(bufferLayouts) { - for (const bufferLayout of bufferLayouts) { - if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) { - log2.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`); - } - } -} -function getAttributeFromShortHand(bufferLayouts, name2) { - for (const bufferLayout of bufferLayouts) { - if (bufferLayout.format && bufferLayout.name === name2) { - return { - attributeName: bufferLayout.name, - bufferName: name2, - stepMode: bufferLayout.stepMode, - vertexFormat: bufferLayout.format, - // If offset is needed, use `attributes` field. - byteOffset: 0, - byteStride: bufferLayout.byteStride || 0 - }; - } - } - return null; -} -function getAttributeFromAttributesList(bufferLayouts, name2) { - for (const bufferLayout of bufferLayouts) { - let byteStride = bufferLayout.byteStride; - if (typeof bufferLayout.byteStride !== "number") { - for (const attributeMapping2 of bufferLayout.attributes || []) { - const info = decodeVertexFormat(attributeMapping2.format); - byteStride += info.byteLength; - } - } - const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2); - if (attributeMapping) { - return { - attributeName: attributeMapping.attribute, - bufferName: bufferLayout.name, - stepMode: bufferLayout.stepMode, - vertexFormat: attributeMapping.format, - byteOffset: attributeMapping.byteOffset, - byteStride - }; - } - } - return null; -} -function mergeShaderLayout(baseLayout, overrideLayout) { - const mergedLayout = { - ...baseLayout, - attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })) - }; - for (const attribute of overrideLayout?.attributes || []) { - const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name); - if (!baseAttribute) { - log2.warn(`shader layout attribute ${attribute.name} not present in shader`); - } else { - baseAttribute.type = attribute.type || baseAttribute.type; - baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode; - } - } - return mergedLayout; -} - -// node_modules/@luma.gl/core/dist/adapter/resources/vertex-array.js -var VertexArray = class _VertexArray extends Resource { - static defaultProps = { - ...Resource.defaultProps, - renderPipeline: null - }; - get [Symbol.toStringTag]() { - return "VertexArray"; - } - /** Max number of vertex attributes */ - maxVertexAttributes; - /** Attribute infos indexed by location - TODO only needed by webgl module? */ - attributeInfos; - /** Index buffer */ - indexBuffer = null; - /** Attributes indexed by buffer slot */ - attributes; - constructor(device, props) { - super(device, props, _VertexArray.defaultProps); - this.maxVertexAttributes = device.limits.maxVertexAttributes; - this.attributes = new Array(this.maxVertexAttributes).fill(null); - this.attributeInfos = getAttributeInfosByLocation(props.renderPipeline.shaderLayout, props.renderPipeline.bufferLayout, this.maxVertexAttributes); - } - // DEPRECATED METHODS - /** @deprecated Set constant attributes (WebGL only) */ - setConstantWebGL(location, value) { - throw new Error("constant attributes not supported"); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/transform-feedback.js -var TransformFeedback = class _TransformFeedback extends Resource { - static defaultProps = { - ...Resource.defaultProps, - layout: void 0, - buffers: {} - }; - get [Symbol.toStringTag]() { - return "TransformFeedback"; - } - constructor(device, props) { - super(device, props, _TransformFeedback.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/resources/query-set.js -var QuerySet = class _QuerySet extends Resource { - static defaultProps = { - ...Resource.defaultProps, - type: void 0, - count: void 0 - }; - get [Symbol.toStringTag]() { - return "QuerySet"; - } - constructor(device, props) { - super(device, props, _QuerySet.defaultProps); - } -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/decode-shader-types.js -var UNIFORM_FORMATS = { - f32: { type: "f32", components: 1 }, - i32: { type: "i32", components: 1 }, - u32: { type: "u32", components: 1 }, - // 'bool-webgl': {type: 'bool-webgl', components: 1}, - "vec2": { type: "f32", components: 2 }, - "vec3": { type: "f32", components: 3 }, - "vec4": { type: "f32", components: 4 }, - "vec2": { type: "i32", components: 2 }, - "vec3": { type: "i32", components: 3 }, - "vec4": { type: "i32", components: 4 }, - "vec2": { type: "u32", components: 2 }, - "vec3": { type: "u32", components: 3 }, - "vec4": { type: "u32", components: 4 }, - "mat2x2": { type: "f32", components: 4 }, - "mat2x3": { type: "f32", components: 6 }, - "mat2x4": { type: "f32", components: 8 }, - "mat3x2": { type: "f32", components: 6 }, - "mat3x3": { type: "f32", components: 9 }, - "mat3x4": { type: "f32", components: 12 }, - "mat4x2": { type: "f32", components: 8 }, - "mat4x3": { type: "f32", components: 12 }, - "mat4x4": { type: "f32", components: 16 } -}; -function decodeShaderUniformType(format) { - const decoded = UNIFORM_FORMATS[format]; - assert6(format); - return decoded; -} -function alignTo(size, count2) { - switch (count2) { - case 1: - return size; - case 2: - return size + size % 2; - default: - return size + (4 - size % 4) % 4; - } -} - -// node_modules/@luma.gl/core/dist/utils/array-utils-flat.js -var arrayBuffer; -function getScratchArrayBuffer(byteLength) { - if (!arrayBuffer || arrayBuffer.byteLength < byteLength) { - arrayBuffer = new ArrayBuffer(byteLength); - } - return arrayBuffer; -} -function getScratchArray(Type2, length10) { - const scratchArrayBuffer = getScratchArrayBuffer(Type2.BYTES_PER_ELEMENT * length10); - return new Type2(scratchArrayBuffer, 0, length10); -} -function fillArray(options) { - const { target, source, start = 0, count: count2 = 1 } = options; - const length10 = source.length; - const total = count2 * length10; - let copied = 0; - for (let i = start; copied < length10; copied++) { - target[i++] = source[copied]; - } - while (copied < total) { - if (copied < total - copied) { - target.copyWithin(start + copied, start, start + copied); - copied *= 2; - } else { - target.copyWithin(start + copied, start, start + total - copied); - copied = total; - } - } - return options.target; -} - -// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-buffer-layout.js -var minBufferSize = 1024; -var UniformBufferLayout = class { - layout = {}; - /** number of bytes needed for buffer allocation */ - byteLength; - /** Create a new UniformBufferLayout given a map of attributes. */ - constructor(uniformTypes) { - let size = 0; - for (const [key, uniformType] of Object.entries(uniformTypes)) { - const typeAndComponents = decodeShaderUniformType(uniformType); - const { type, components: count2 } = typeAndComponents; - size = alignTo(size, count2); - const offset = size; - size += count2; - this.layout[key] = { type, size: count2, offset }; - } - size += (4 - size % 4) % 4; - const actualByteLength = size * 4; - this.byteLength = Math.max(actualByteLength, minBufferSize); - } - /** Get the data for the complete buffer */ - getData(uniformValues) { - const bufferSize = Math.max(this.byteLength, minBufferSize); - const arrayBuffer2 = getScratchArrayBuffer(bufferSize); - const typedArrays = { - i32: new Int32Array(arrayBuffer2), - u32: new Uint32Array(arrayBuffer2), - f32: new Float32Array(arrayBuffer2), - // TODO not implemented - f16: new Uint16Array(arrayBuffer2) - }; - for (const [name2, value] of Object.entries(uniformValues)) { - const uniformLayout = this.layout[name2]; - if (!uniformLayout) { - log2.warn(`Supplied uniform value ${name2} not present in uniform block layout`)(); - continue; - } - const { type, size, offset } = uniformLayout; - const typedArray = typedArrays[type]; - if (size === 1) { - if (typeof value !== "number" && typeof value !== "boolean") { - log2.warn(`Supplied value for single component uniform ${name2} is not a number: ${value}`)(); - continue; - } - typedArray[offset] = Number(value); - } else { - const numericArray = isNumberArray(value); - if (!numericArray) { - log2.warn(`Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`)(); - continue; - } - typedArray.set(numericArray, offset); - } - } - return new Uint8Array(arrayBuffer2); - } - /** Does this layout have a field with specified name */ - has(name2) { - return Boolean(this.layout[name2]); - } - /** Get offset and size for a field with specified name */ - get(name2) { - const layout = this.layout[name2]; - return layout; - } -}; - -// node_modules/@luma.gl/core/dist/utils/array-equal.js -function arrayEqual(a, b, limit = 16) { - if (a !== b) { - return false; - } - const arrayA = isNumberArray(a); - if (!arrayA) { - return false; - } - const arrayB = isNumberArray(b); - if (arrayB && arrayA.length === arrayB.length) { - for (let i = 0; i < arrayA.length; ++i) { - if (arrayB[i] !== arrayA[i]) { - return false; - } - } - } - return true; -} -function arrayCopy(a) { - const numberArray = isNumberArray(a); - if (numberArray) { - return numberArray.slice(); - } - return a; -} - -// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-block.js -var UniformBlock = class { - name; - uniforms = {}; - modifiedUniforms = {}; - modified = true; - bindingLayout = {}; - needsRedraw = "initialized"; - constructor(props) { - this.name = props?.name; - if (props?.name && props?.shaderLayout) { - const binding = props?.shaderLayout.bindings?.find((binding2) => binding2.type === "uniform" && binding2.name === props?.name); - if (!binding) { - throw new Error(props?.name); - } - const uniformBlock = binding; - for (const uniform of uniformBlock.uniforms || []) { - this.bindingLayout[uniform.name] = uniform; - } - } - } - /** Set a map of uniforms */ - setUniforms(uniforms) { - for (const [key, value] of Object.entries(uniforms)) { - this._setUniform(key, value); - if (!this.needsRedraw) { - this.setNeedsRedraw(`${this.name}.${key}=${value}`); - } - } - } - setNeedsRedraw(reason) { - this.needsRedraw = this.needsRedraw || reason; - } - /** Returns all uniforms */ - getAllUniforms() { - this.modifiedUniforms = {}; - this.needsRedraw = false; - return this.uniforms || {}; - } - /** Set a single uniform */ - _setUniform(key, value) { - if (arrayEqual(this.uniforms[key], value)) { - return; - } - this.uniforms[key] = arrayCopy(value); - this.modifiedUniforms[key] = true; - this.modified = true; - } -}; - -// node_modules/@luma.gl/core/dist/lib/uniforms/uniform-store.js -var UniformStore = class { - /** Stores the uniform values for each uniform block */ - uniformBlocks = /* @__PURE__ */ new Map(); - /** Can generate data for a uniform buffer for each block from data */ - uniformBufferLayouts = /* @__PURE__ */ new Map(); - /** Actual buffer for the blocks */ - uniformBuffers = /* @__PURE__ */ new Map(); - /** - * Create a new UniformStore instance - * @param blocks - */ - constructor(blocks) { - for (const [bufferName, block] of Object.entries(blocks)) { - const uniformBufferName = bufferName; - const uniformBufferLayout = new UniformBufferLayout(block.uniformTypes || {}); - this.uniformBufferLayouts.set(uniformBufferName, uniformBufferLayout); - const uniformBlock = new UniformBlock({ name: bufferName }); - uniformBlock.setUniforms(block.defaultUniforms || {}); - this.uniformBlocks.set(uniformBufferName, uniformBlock); - } - } - /** Destroy any managed uniform buffers */ - destroy() { - for (const uniformBuffer of this.uniformBuffers.values()) { - uniformBuffer.destroy(); - } - } - /** - * Set uniforms - * Makes all properties partial - */ - setUniforms(uniforms) { - for (const [blockName, uniformValues] of Object.entries(uniforms)) { - this.uniformBlocks.get(blockName).setUniforms(uniformValues); - } - this.updateUniformBuffers(); - } - /** Get the required minimum length of the uniform buffer */ - getUniformBufferByteLength(uniformBufferName) { - return this.uniformBufferLayouts.get(uniformBufferName).byteLength; - } - /** Get formatted binary memory that can be uploaded to a buffer */ - getUniformBufferData(uniformBufferName) { - const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms(); - return this.uniformBufferLayouts.get(uniformBufferName).getData(uniformValues); - } - /** - * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it) - * The new buffer is initialized with current / supplied values - */ - createUniformBuffer(device, uniformBufferName, uniforms) { - if (uniforms) { - this.setUniforms(uniforms); - } - const byteLength = this.getUniformBufferByteLength(uniformBufferName); - const uniformBuffer = device.createBuffer({ - usage: Buffer2.UNIFORM | Buffer2.COPY_DST, - byteLength - }); - const uniformBufferData = this.getUniformBufferData(uniformBufferName); - uniformBuffer.write(uniformBufferData); - return uniformBuffer; - } - /** Get the managed uniform buffer. "managed" resources are destroyed when the uniformStore is destroyed. */ - getManagedUniformBuffer(device, uniformBufferName) { - if (!this.uniformBuffers.get(uniformBufferName)) { - const byteLength = this.getUniformBufferByteLength(uniformBufferName); - const uniformBuffer = device.createBuffer({ - usage: Buffer2.UNIFORM | Buffer2.COPY_DST, - byteLength - }); - this.uniformBuffers.set(uniformBufferName, uniformBuffer); - } - return this.uniformBuffers.get(uniformBufferName); - } - /** Updates all uniform buffers where values have changed */ - updateUniformBuffers() { - let reason = false; - for (const uniformBufferName of this.uniformBlocks.keys()) { - const bufferReason = this.updateUniformBuffer(uniformBufferName); - reason ||= bufferReason; - } - if (reason) { - log2.log(3, `UniformStore.updateUniformBuffers(): ${reason}`)(); - } - return reason; - } - /** Update one uniform buffer. Only updates if values have changed */ - updateUniformBuffer(uniformBufferName) { - const uniformBlock = this.uniformBlocks.get(uniformBufferName); - const uniformBuffer = this.uniformBuffers.get(uniformBufferName); - let reason = false; - if (uniformBuffer && uniformBlock.needsRedraw) { - reason ||= uniformBlock.needsRedraw; - const uniformBufferData = this.getUniformBufferData(uniformBufferName); - const uniformBuffer2 = this.uniformBuffers.get(uniformBufferName); - uniformBuffer2.write(uniformBufferData); - const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms(); - log2.log(4, `Writing to uniform buffer ${String(uniformBufferName)}`, uniformBufferData, uniformValues)(); - } - return reason; - } -}; - -// node_modules/@luma.gl/core/dist/adapter/type-utils/vertex-format-from-attribute.js -function getDataTypeFromTypedArray(arrayOrType) { - const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; - switch (type) { - case Float32Array: - return "float32"; - case Uint16Array: - return "uint16"; - case Uint32Array: - return "uint32"; - case Uint8Array: - case Uint8ClampedArray: - return "uint8"; - case Int8Array: - return "sint8"; - case Int16Array: - return "sint16"; - case Int32Array: - return "sint32"; - default: - throw new Error(type.constructor.name); - } -} -function getTypedArrayFromDataType(dataType) { - switch (dataType) { - case "float32": - return Float32Array; - case "uint32": - return Uint32Array; - case "sint32": - return Int32Array; - case "uint16": - case "unorm16": - return Uint16Array; - case "sint16": - case "snorm16": - return Int16Array; - case "uint8": - case "unorm8": - return Uint8Array; - case "sint8": - case "snorm8": - return Int8Array; - default: - throw new Error(dataType); - } -} -function getVertexFormatFromAttribute(typedArray, size, normalized) { - if (!size || size > 4) { - throw new Error(`size ${size}`); - } - const components = size; - let dataType = getDataTypeFromTypedArray(typedArray); - if (dataType === "uint8" && normalized && components === 1) { - return "unorm8-webgl"; - } - if (dataType === "uint8" && normalized && components === 3) { - return "unorm8x3-webgl"; - } - if (dataType === "uint8" || dataType === "sint8") { - if (components === 1 || components === 3) { - throw new Error(`size: ${size}`); - } - if (normalized) { - dataType = dataType.replace("int", "norm"); - } - return `${dataType}x${components}`; - } - if (dataType === "uint16" || dataType === "sint16") { - if (components === 1 || components === 3) { - throw new Error(`size: ${size}`); - } - if (normalized) { - dataType = dataType.replace("int", "norm"); - } - return `${dataType}x${components}`; - } - if (components === 1) { - return dataType; - } - return `${dataType}x${components}`; -} - -// node_modules/@luma.gl/core/dist/utils/cast.js -function cast(value) { - return value; -} - -// node_modules/@luma.gl/core/dist/lib/uniforms/uniform.js -function isUniformValue(value) { - return isNumberArray(value) !== null || typeof value === "number" || typeof value === "boolean"; -} -function splitUniformsAndBindings(uniforms) { - const result = { bindings: {}, uniforms: {} }; - Object.keys(uniforms).forEach((name2) => { - const uniform = uniforms[name2]; - if (isUniformValue(uniform)) { - result.uniforms[name2] = uniform; - } else { - result.bindings[name2] = uniform; - } - }); - return result; -} - -// node_modules/@luma.gl/core/dist/utils/check-props.js -function checkProps(className, props, propChecks) { - const { removedProps = {}, deprecatedProps = {}, replacedProps = {} } = propChecks; - for (const propName in removedProps) { - if (propName in props) { - const replacementProp = removedProps[propName]; - const replacement = replacementProp ? `${className}.${removedProps[propName]}` : "N/A"; - log2.removed(`${className}.${propName}`, replacement)(); - } - } - for (const propName in deprecatedProps) { - if (propName in props) { - const replacementProp = deprecatedProps[propName]; - log2.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)(); - } - } - let newProps = null; - for (const [propName, replacementProp] of Object.entries(replacedProps)) { - if (propName in props) { - log2.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)(); - newProps = newProps || Object.assign({}, props); - newProps[replacementProp] = props[propName]; - delete newProps[propName]; - } - } - return newProps || props; -} - -// node_modules/@luma.gl/core/dist/utils/load-file.js -var pathPrefix2 = ""; -async function loadImage(url, opts) { - return await new Promise((resolve2, reject) => { - try { - const image = new Image(); - image.onload = () => resolve2(image); - image.onerror = () => reject(new Error(`Could not load image ${url}.`)); - image.crossOrigin = opts?.crossOrigin || "anonymous"; - image.src = url.startsWith("http") ? url : pathPrefix2 + url; - } catch (error) { - reject(error); - } - }); -} -async function loadScript(scriptUrl, scriptId) { - const head = document.getElementsByTagName("head")[0]; - if (!head) { - throw new Error("loadScript"); - } - const script = document.createElement("script"); - script.setAttribute("type", "text/javascript"); - script.setAttribute("src", scriptUrl); - if (scriptId) { - script.id = scriptId; - } - return new Promise((resolve2, reject) => { - script.onload = resolve2; - script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`)); - head.appendChild(script); - }); -} - -// node_modules/@luma.gl/core/dist/utils/deep-equal.js -function deepEqual(a, b, depth) { - if (a === b) { - return true; - } - if (!depth || !a || !b) { - return false; - } - if (Array.isArray(a)) { - if (!Array.isArray(b) || a.length !== b.length) { - return false; - } - for (let i = 0; i < a.length; i++) { - if (!deepEqual(a[i], b[i], depth - 1)) { - return false; - } - } - return true; - } - if (Array.isArray(b)) { - return false; - } - if (typeof a === "object" && typeof b === "object") { - const aKeys = Object.keys(a); - const bKeys = Object.keys(b); - if (aKeys.length !== bKeys.length) { - return false; - } - for (const key of aKeys) { - if (!b.hasOwnProperty(key)) { - return false; - } - if (!deepEqual(a[key], b[key], depth - 1)) { - return false; - } - } - return true; - } - return false; -} - -// node_modules/@luma.gl/core/dist/utils/request-animation-frame.js -function requestAnimationFrame2(callback) { - return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60); -} -function cancelAnimationFrame2(timerId) { - return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId); -} - -// node_modules/wgsl_reflect/wgsl_reflect.module.js -var ParseContext = class { - constructor() { - this.constants = /* @__PURE__ */ new Map(); - this.aliases = /* @__PURE__ */ new Map(); - this.structs = /* @__PURE__ */ new Map(); - } -}; -var Node = class { - constructor() { - } - get isAstNode() { - return true; - } - get astNodeType() { - return ""; - } - evaluate(context) { - throw new Error("Cannot evaluate node"); - } - evaluateString(context) { - return this.evaluate(context).toString(); - } - search(callback) { - } - searchBlock(block, callback) { - if (block) { - callback(_BlockStart.instance); - for (const node of block) { - if (node instanceof Array) { - this.searchBlock(node, callback); - } else { - node.search(callback); - } - } - callback(_BlockEnd.instance); - } - } -}; -var _BlockStart = class extends Node { -}; -_BlockStart.instance = new _BlockStart(); -var _BlockEnd = class extends Node { -}; -_BlockEnd.instance = new _BlockEnd(); -var Statement = class extends Node { - constructor() { - super(); - } -}; -var Function = class extends Statement { - constructor(name2, args, returnType, body, startLine, endLine) { - super(); - this.calls = /* @__PURE__ */ new Set(); - this.name = name2; - this.args = args; - this.returnType = returnType; - this.body = body; - this.startLine = startLine; - this.endLine = endLine; - } - get astNodeType() { - return "function"; - } - search(callback) { - this.searchBlock(this.body, callback); - } -}; -var StaticAssert = class extends Statement { - constructor(expression) { - super(); - this.expression = expression; - } - get astNodeType() { - return "staticAssert"; - } - search(callback) { - this.expression.search(callback); - } -}; -var While = class extends Statement { - constructor(condition, body) { - super(); - this.condition = condition; - this.body = body; - } - get astNodeType() { - return "while"; - } - search(callback) { - this.condition.search(callback); - this.searchBlock(this.body, callback); - } -}; -var Continuing = class extends Statement { - constructor(body) { - super(); - this.body = body; - } - get astNodeType() { - return "continuing"; - } - search(callback) { - this.searchBlock(this.body, callback); - } -}; -var For = class extends Statement { - constructor(init, condition, increment, body) { - super(); - this.init = init; - this.condition = condition; - this.increment = increment; - this.body = body; - } - get astNodeType() { - return "for"; - } - search(callback) { - var _a2, _b, _c; - (_a2 = this.init) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - (_b = this.condition) === null || _b === void 0 ? void 0 : _b.search(callback); - (_c = this.increment) === null || _c === void 0 ? void 0 : _c.search(callback); - this.searchBlock(this.body, callback); - } -}; -var Var = class extends Statement { - constructor(name2, type, storage, access, value) { - super(); - this.name = name2; - this.type = type; - this.storage = storage; - this.access = access; - this.value = value; - } - get astNodeType() { - return "var"; - } - search(callback) { - var _a2; - callback(this); - (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - } -}; -var Override = class extends Statement { - constructor(name2, type, value) { - super(); - this.name = name2; - this.type = type; - this.value = value; - } - get astNodeType() { - return "override"; - } - search(callback) { - var _a2; - (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - } -}; -var Let = class extends Statement { - constructor(name2, type, storage, access, value) { - super(); - this.name = name2; - this.type = type; - this.storage = storage; - this.access = access; - this.value = value; - } - get astNodeType() { - return "let"; - } - search(callback) { - var _a2; - callback(this); - (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - } -}; -var Const = class extends Statement { - constructor(name2, type, storage, access, value) { - super(); - this.name = name2; - this.type = type; - this.storage = storage; - this.access = access; - this.value = value; - } - get astNodeType() { - return "const"; - } - evaluate(context) { - return this.value.evaluate(context); - } - search(callback) { - var _a2; - callback(this); - (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - } -}; -var IncrementOperator; -(function(IncrementOperator2) { - IncrementOperator2["increment"] = "++"; - IncrementOperator2["decrement"] = "--"; -})(IncrementOperator || (IncrementOperator = {})); -(function(IncrementOperator2) { - function parse2(val) { - const key = val; - if (key == "parse") - throw new Error("Invalid value for IncrementOperator"); - return IncrementOperator2[key]; - } - IncrementOperator2.parse = parse2; -})(IncrementOperator || (IncrementOperator = {})); -var Increment = class extends Statement { - constructor(operator, variable) { - super(); - this.operator = operator; - this.variable = variable; - } - get astNodeType() { - return "increment"; - } - search(callback) { - this.variable.search(callback); - } -}; -var AssignOperator; -(function(AssignOperator2) { - AssignOperator2["assign"] = "="; - AssignOperator2["addAssign"] = "+="; - AssignOperator2["subtractAssin"] = "-="; - AssignOperator2["multiplyAssign"] = "*="; - AssignOperator2["divideAssign"] = "/="; - AssignOperator2["moduloAssign"] = "%="; - AssignOperator2["andAssign"] = "&="; - AssignOperator2["orAssign"] = "|="; - AssignOperator2["xorAssign"] = "^="; - AssignOperator2["shiftLeftAssign"] = "<<="; - AssignOperator2["shiftRightAssign"] = ">>="; -})(AssignOperator || (AssignOperator = {})); -(function(AssignOperator2) { - function parse2(val) { - const key = val; - if (key == "parse") { - throw new Error("Invalid value for AssignOperator"); - } - return key; - } - AssignOperator2.parse = parse2; -})(AssignOperator || (AssignOperator = {})); -var Assign = class extends Statement { - constructor(operator, variable, value) { - super(); - this.operator = operator; - this.variable = variable; - this.value = value; - } - get astNodeType() { - return "assign"; - } - search(callback) { - this.variable.search(callback); - this.value.search(callback); - } -}; -var Call = class extends Statement { - constructor(name2, args) { - super(); - this.name = name2; - this.args = args; - } - get astNodeType() { - return "call"; - } - search(callback) { - for (const node of this.args) { - node.search(callback); - } - callback(this); - } -}; -var Loop = class extends Statement { - constructor(body, continuing) { - super(); - this.body = body; - this.continuing = continuing; - } - get astNodeType() { - return "loop"; - } -}; -var Switch = class extends Statement { - constructor(condition, body) { - super(); - this.condition = condition; - this.body = body; - } - get astNodeType() { - return "body"; - } -}; -var If = class extends Statement { - constructor(condition, body, elseif, _else) { - super(); - this.condition = condition; - this.body = body; - this.elseif = elseif; - this.else = _else; - } - get astNodeType() { - return "if"; - } - search(callback) { - this.condition.search(callback); - this.searchBlock(this.body, callback); - this.searchBlock(this.elseif, callback); - this.searchBlock(this.else, callback); - } -}; -var Return = class extends Statement { - constructor(value) { - super(); - this.value = value; - } - get astNodeType() { - return "return"; - } - search(callback) { - var _a2; - (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback); - } -}; -var Enable = class extends Statement { - constructor(name2) { - super(); - this.name = name2; - } - get astNodeType() { - return "enable"; - } -}; -var Requires = class extends Statement { - constructor(extensions) { - super(); - this.extensions = extensions; - } - get astNodeType() { - return "requires"; - } -}; -var Diagnostic = class extends Statement { - constructor(severity, rule) { - super(); - this.severity = severity; - this.rule = rule; - } - get astNodeType() { - return "diagnostic"; - } -}; -var Alias = class extends Statement { - constructor(name2, type) { - super(); - this.name = name2; - this.type = type; - } - get astNodeType() { - return "alias"; - } -}; -var Discard = class extends Statement { - constructor() { - super(); - } - get astNodeType() { - return "discard"; - } -}; -var Break = class extends Statement { - constructor() { - super(); - } - get astNodeType() { - return "break"; - } -}; -var Continue = class extends Statement { - constructor() { - super(); - } - get astNodeType() { - return "continue"; - } -}; -var Type = class extends Statement { - constructor(name2) { - super(); - this.name = name2; - } - get astNodeType() { - return "type"; - } - get isStruct() { - return false; - } - get isArray() { - return false; - } -}; -var Struct = class extends Type { - constructor(name2, members, startLine, endLine) { - super(name2); - this.members = members; - this.startLine = startLine; - this.endLine = endLine; - } - get astNodeType() { - return "struct"; - } - get isStruct() { - return true; - } - /// Return the index of the member with the given name, or -1 if not found. - getMemberIndex(name2) { - for (let i = 0; i < this.members.length; i++) { - if (this.members[i].name == name2) - return i; - } - return -1; - } -}; -var TemplateType = class extends Type { - constructor(name2, format, access) { - super(name2); - this.format = format; - this.access = access; - } - get astNodeType() { - return "template"; - } -}; -var PointerType = class extends Type { - constructor(name2, storage, type, access) { - super(name2); - this.storage = storage; - this.type = type; - this.access = access; - } - get astNodeType() { - return "pointer"; - } -}; -var ArrayType = class extends Type { - constructor(name2, attributes, format, count2) { - super(name2); - this.attributes = attributes; - this.format = format; - this.count = count2; - } - get astNodeType() { - return "array"; - } - get isArray() { - return true; - } -}; -var SamplerType = class extends Type { - constructor(name2, format, access) { - super(name2); - this.format = format; - this.access = access; - } - get astNodeType() { - return "sampler"; - } -}; -var Expression = class extends Node { - constructor() { - super(); - } -}; -var StringExpr = class extends Expression { - constructor(value) { - super(); - this.value = value; - } - get astNodeType() { - return "stringExpr"; - } - toString() { - return this.value; - } - evaluateString() { - return this.value; - } -}; -var CreateExpr = class extends Expression { - constructor(type, args) { - super(); - this.type = type; - this.args = args; - } - get astNodeType() { - return "createExpr"; - } - search(callback) { - callback(this); - if (this.args) { - for (const node of this.args) { - node.search(callback); - } - } - } - evaluate(context) { - return this.args[0].evaluate(context); - } -}; -var CallExpr = class extends Expression { - constructor(name2, args) { - super(); - this.name = name2; - this.args = args; - } - get astNodeType() { - return "callExpr"; - } - evaluate(context) { - switch (this.name) { - case "abs": - return Math.abs(this.args[0].evaluate(context)); - case "acos": - return Math.acos(this.args[0].evaluate(context)); - case "acosh": - return Math.acosh(this.args[0].evaluate(context)); - case "asin": - return Math.asin(this.args[0].evaluate(context)); - case "asinh": - return Math.asinh(this.args[0].evaluate(context)); - case "atan": - return Math.atan(this.args[0].evaluate(context)); - case "atan2": - return Math.atan2(this.args[0].evaluate(context), this.args[1].evaluate(context)); - case "atanh": - return Math.atanh(this.args[0].evaluate(context)); - case "ceil": - return Math.ceil(this.args[0].evaluate(context)); - case "clamp": - return Math.min(Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context)), this.args[2].evaluate(context)); - case "cos": - return Math.cos(this.args[0].evaluate(context)); - case "degrees": - return this.args[0].evaluate(context) * 180 / Math.PI; - case "distance": - return Math.sqrt(Math.pow(this.args[0].evaluate(context) - this.args[1].evaluate(context), 2)); - case "dot": - case "exp": - return Math.exp(this.args[0].evaluate(context)); - case "exp2": - return Math.pow(2, this.args[0].evaluate(context)); - case "floor": - return Math.floor(this.args[0].evaluate(context)); - case "fma": - return this.args[0].evaluate(context) * this.args[1].evaluate(context) + this.args[2].evaluate(context); - case "fract": - return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context)); - case "inverseSqrt": - return 1 / Math.sqrt(this.args[0].evaluate(context)); - case "log": - return Math.log(this.args[0].evaluate(context)); - case "log2": - return Math.log2(this.args[0].evaluate(context)); - case "max": - return Math.max(this.args[0].evaluate(context), this.args[1].evaluate(context)); - case "min": - return Math.min(this.args[0].evaluate(context), this.args[1].evaluate(context)); - case "mix": - return this.args[0].evaluate(context) * (1 - this.args[2].evaluate(context)) + this.args[1].evaluate(context) * this.args[2].evaluate(context); - case "modf": - return this.args[0].evaluate(context) - Math.floor(this.args[0].evaluate(context)); - case "pow": - return Math.pow(this.args[0].evaluate(context), this.args[1].evaluate(context)); - case "radians": - return this.args[0].evaluate(context) * Math.PI / 180; - case "round": - return Math.round(this.args[0].evaluate(context)); - case "sign": - return Math.sign(this.args[0].evaluate(context)); - case "sin": - return Math.sin(this.args[0].evaluate(context)); - case "sinh": - return Math.sinh(this.args[0].evaluate(context)); - case "saturate": - return Math.min(Math.max(this.args[0].evaluate(context), 0), 1); - case "smoothstep": - return this.args[0].evaluate(context) * this.args[0].evaluate(context) * (3 - 2 * this.args[0].evaluate(context)); - case "sqrt": - return Math.sqrt(this.args[0].evaluate(context)); - case "step": - return this.args[0].evaluate(context) < this.args[1].evaluate(context) ? 0 : 1; - case "tan": - return Math.tan(this.args[0].evaluate(context)); - case "tanh": - return Math.tanh(this.args[0].evaluate(context)); - case "trunc": - return Math.trunc(this.args[0].evaluate(context)); - default: - throw new Error("Non const function: " + this.name); - } - } - search(callback) { - for (const node of this.args) { - node.search(callback); - } - callback(this); - } -}; -var VariableExpr = class extends Expression { - constructor(name2) { - super(); - this.name = name2; - } - get astNodeType() { - return "varExpr"; - } - search(callback) { - callback(this); - if (this.postfix) { - this.postfix.search(callback); - } - } - evaluate(context) { - const constant = context.constants.get(this.name); - if (!constant) { - throw new Error("Cannot evaluate node"); - } - return constant.evaluate(context); - } -}; -var ConstExpr = class extends Expression { - constructor(name2, initializer) { - super(); - this.name = name2; - this.initializer = initializer; - } - get astNodeType() { - return "constExpr"; - } - evaluate(context) { - var _a2, _b; - if (this.initializer instanceof CreateExpr) { - const property = (_a2 = this.postfix) === null || _a2 === void 0 ? void 0 : _a2.evaluateString(context); - const type = (_b = this.initializer.type) === null || _b === void 0 ? void 0 : _b.name; - const struct = context.structs.get(type); - const memberIndex = struct === null || struct === void 0 ? void 0 : struct.getMemberIndex(property); - if (memberIndex !== void 0 && memberIndex != -1) { - const value = this.initializer.args[memberIndex].evaluate(context); - return value; - } else { - return this.initializer.evaluate(context); - } - } - return this.initializer.evaluate(context); - } - search(callback) { - this.initializer.search(callback); - } -}; -var LiteralExpr = class extends Expression { - constructor(value) { - super(); - this.value = value; - } - get astNodeType() { - return "literalExpr"; - } - evaluate() { - return this.value; - } -}; -var BitcastExpr = class extends Expression { - constructor(type, value) { - super(); - this.type = type; - this.value = value; - } - get astNodeType() { - return "bitcastExpr"; - } - search(callback) { - this.value.search(callback); - } -}; -var GroupingExpr = class extends Expression { - constructor(contents) { - super(); - this.contents = contents; - } - get astNodeType() { - return "groupExpr"; - } - evaluate(context) { - return this.contents[0].evaluate(context); - } - search(callback) { - this.searchBlock(this.contents, callback); - } -}; -var ArrayIndex = class extends Expression { - constructor(index2) { - super(); - this.index = index2; - } - search(callback) { - this.index.search(callback); - } -}; -var Operator = class extends Expression { - constructor() { - super(); - } -}; -var UnaryOperator = class extends Operator { - constructor(operator, right) { - super(); - this.operator = operator; - this.right = right; - } - get astNodeType() { - return "unaryOp"; - } - evaluate(context) { - switch (this.operator) { - case "+": - return this.right.evaluate(context); - case "-": - return -this.right.evaluate(context); - case "!": - return this.right.evaluate(context) ? 0 : 1; - case "~": - return ~this.right.evaluate(context); - default: - throw new Error("Unknown unary operator: " + this.operator); - } - } - search(callback) { - this.right.search(callback); - } -}; -var BinaryOperator = class extends Operator { - constructor(operator, left, right) { - super(); - this.operator = operator; - this.left = left; - this.right = right; - } - get astNodeType() { - return "binaryOp"; - } - evaluate(context) { - switch (this.operator) { - case "+": - return this.left.evaluate(context) + this.right.evaluate(context); - case "-": - return this.left.evaluate(context) - this.right.evaluate(context); - case "*": - return this.left.evaluate(context) * this.right.evaluate(context); - case "/": - return this.left.evaluate(context) / this.right.evaluate(context); - case "%": - return this.left.evaluate(context) % this.right.evaluate(context); - case "==": - return this.left.evaluate(context) == this.right.evaluate(context) ? 1 : 0; - case "!=": - return this.left.evaluate(context) != this.right.evaluate(context) ? 1 : 0; - case "<": - return this.left.evaluate(context) < this.right.evaluate(context) ? 1 : 0; - case ">": - return this.left.evaluate(context) > this.right.evaluate(context) ? 1 : 0; - case "<=": - return this.left.evaluate(context) <= this.right.evaluate(context) ? 1 : 0; - case ">=": - return this.left.evaluate(context) >= this.right.evaluate(context) ? 1 : 0; - case "&&": - return this.left.evaluate(context) && this.right.evaluate(context) ? 1 : 0; - case "||": - return this.left.evaluate(context) || this.right.evaluate(context) ? 1 : 0; - default: - throw new Error(`Unknown operator ${this.operator}`); - } - } - search(callback) { - this.left.search(callback); - this.right.search(callback); - } -}; -var SwitchCase = class extends Node { - constructor() { - super(); - } -}; -var Case = class extends SwitchCase { - constructor(selector, body) { - super(); - this.selector = selector; - this.body = body; - } - get astNodeType() { - return "case"; - } - search(callback) { - this.searchBlock(this.body, callback); - } -}; -var Default = class extends SwitchCase { - constructor(body) { - super(); - this.body = body; - } - get astNodeType() { - return "default"; - } - search(callback) { - this.searchBlock(this.body, callback); - } -}; -var Argument = class extends Node { - constructor(name2, type, attributes) { - super(); - this.name = name2; - this.type = type; - this.attributes = attributes; - } - get astNodeType() { - return "argument"; - } -}; -var ElseIf = class extends Node { - constructor(condition, body) { - super(); - this.condition = condition; - this.body = body; - } - get astNodeType() { - return "elseif"; - } - search(callback) { - this.condition.search(callback); - this.searchBlock(this.body, callback); - } -}; -var Member = class extends Node { - constructor(name2, type, attributes) { - super(); - this.name = name2; - this.type = type; - this.attributes = attributes; - } - get astNodeType() { - return "member"; - } -}; -var Attribute = class extends Node { - constructor(name2, value) { - super(); - this.name = name2; - this.value = value; - } - get astNodeType() { - return "attribute"; - } -}; -var _a; -var TokenClass; -(function(TokenClass2) { - TokenClass2[TokenClass2["token"] = 0] = "token"; - TokenClass2[TokenClass2["keyword"] = 1] = "keyword"; - TokenClass2[TokenClass2["reserved"] = 2] = "reserved"; -})(TokenClass || (TokenClass = {})); -var TokenType = class { - constructor(name2, type, rule) { - this.name = name2; - this.type = type; - this.rule = rule; - } - toString() { - return this.name; - } -}; -var TokenTypes = class { -}; -_a = TokenTypes; -TokenTypes.none = new TokenType("", TokenClass.reserved, ""); -TokenTypes.eof = new TokenType("EOF", TokenClass.token, ""); -TokenTypes.reserved = { - asm: new TokenType("asm", TokenClass.reserved, "asm"), - bf16: new TokenType("bf16", TokenClass.reserved, "bf16"), - do: new TokenType("do", TokenClass.reserved, "do"), - enum: new TokenType("enum", TokenClass.reserved, "enum"), - f16: new TokenType("f16", TokenClass.reserved, "f16"), - f64: new TokenType("f64", TokenClass.reserved, "f64"), - handle: new TokenType("handle", TokenClass.reserved, "handle"), - i8: new TokenType("i8", TokenClass.reserved, "i8"), - i16: new TokenType("i16", TokenClass.reserved, "i16"), - i64: new TokenType("i64", TokenClass.reserved, "i64"), - mat: new TokenType("mat", TokenClass.reserved, "mat"), - premerge: new TokenType("premerge", TokenClass.reserved, "premerge"), - regardless: new TokenType("regardless", TokenClass.reserved, "regardless"), - typedef: new TokenType("typedef", TokenClass.reserved, "typedef"), - u8: new TokenType("u8", TokenClass.reserved, "u8"), - u16: new TokenType("u16", TokenClass.reserved, "u16"), - u64: new TokenType("u64", TokenClass.reserved, "u64"), - unless: new TokenType("unless", TokenClass.reserved, "unless"), - using: new TokenType("using", TokenClass.reserved, "using"), - vec: new TokenType("vec", TokenClass.reserved, "vec"), - void: new TokenType("void", TokenClass.reserved, "void") -}; -TokenTypes.keywords = { - array: new TokenType("array", TokenClass.keyword, "array"), - atomic: new TokenType("atomic", TokenClass.keyword, "atomic"), - bool: new TokenType("bool", TokenClass.keyword, "bool"), - f32: new TokenType("f32", TokenClass.keyword, "f32"), - i32: new TokenType("i32", TokenClass.keyword, "i32"), - mat2x2: new TokenType("mat2x2", TokenClass.keyword, "mat2x2"), - mat2x3: new TokenType("mat2x3", TokenClass.keyword, "mat2x3"), - mat2x4: new TokenType("mat2x4", TokenClass.keyword, "mat2x4"), - mat3x2: new TokenType("mat3x2", TokenClass.keyword, "mat3x2"), - mat3x3: new TokenType("mat3x3", TokenClass.keyword, "mat3x3"), - mat3x4: new TokenType("mat3x4", TokenClass.keyword, "mat3x4"), - mat4x2: new TokenType("mat4x2", TokenClass.keyword, "mat4x2"), - mat4x3: new TokenType("mat4x3", TokenClass.keyword, "mat4x3"), - mat4x4: new TokenType("mat4x4", TokenClass.keyword, "mat4x4"), - ptr: new TokenType("ptr", TokenClass.keyword, "ptr"), - sampler: new TokenType("sampler", TokenClass.keyword, "sampler"), - sampler_comparison: new TokenType("sampler_comparison", TokenClass.keyword, "sampler_comparison"), - struct: new TokenType("struct", TokenClass.keyword, "struct"), - texture_1d: new TokenType("texture_1d", TokenClass.keyword, "texture_1d"), - texture_2d: new TokenType("texture_2d", TokenClass.keyword, "texture_2d"), - texture_2d_array: new TokenType("texture_2d_array", TokenClass.keyword, "texture_2d_array"), - texture_3d: new TokenType("texture_3d", TokenClass.keyword, "texture_3d"), - texture_cube: new TokenType("texture_cube", TokenClass.keyword, "texture_cube"), - texture_cube_array: new TokenType("texture_cube_array", TokenClass.keyword, "texture_cube_array"), - texture_multisampled_2d: new TokenType("texture_multisampled_2d", TokenClass.keyword, "texture_multisampled_2d"), - texture_storage_1d: new TokenType("texture_storage_1d", TokenClass.keyword, "texture_storage_1d"), - texture_storage_2d: new TokenType("texture_storage_2d", TokenClass.keyword, "texture_storage_2d"), - texture_storage_2d_array: new TokenType("texture_storage_2d_array", TokenClass.keyword, "texture_storage_2d_array"), - texture_storage_3d: new TokenType("texture_storage_3d", TokenClass.keyword, "texture_storage_3d"), - texture_depth_2d: new TokenType("texture_depth_2d", TokenClass.keyword, "texture_depth_2d"), - texture_depth_2d_array: new TokenType("texture_depth_2d_array", TokenClass.keyword, "texture_depth_2d_array"), - texture_depth_cube: new TokenType("texture_depth_cube", TokenClass.keyword, "texture_depth_cube"), - texture_depth_cube_array: new TokenType("texture_depth_cube_array", TokenClass.keyword, "texture_depth_cube_array"), - texture_depth_multisampled_2d: new TokenType("texture_depth_multisampled_2d", TokenClass.keyword, "texture_depth_multisampled_2d"), - texture_external: new TokenType("texture_external", TokenClass.keyword, "texture_external"), - u32: new TokenType("u32", TokenClass.keyword, "u32"), - vec2: new TokenType("vec2", TokenClass.keyword, "vec2"), - vec3: new TokenType("vec3", TokenClass.keyword, "vec3"), - vec4: new TokenType("vec4", TokenClass.keyword, "vec4"), - bitcast: new TokenType("bitcast", TokenClass.keyword, "bitcast"), - block: new TokenType("block", TokenClass.keyword, "block"), - break: new TokenType("break", TokenClass.keyword, "break"), - case: new TokenType("case", TokenClass.keyword, "case"), - continue: new TokenType("continue", TokenClass.keyword, "continue"), - continuing: new TokenType("continuing", TokenClass.keyword, "continuing"), - default: new TokenType("default", TokenClass.keyword, "default"), - diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"), - discard: new TokenType("discard", TokenClass.keyword, "discard"), - else: new TokenType("else", TokenClass.keyword, "else"), - enable: new TokenType("enable", TokenClass.keyword, "enable"), - fallthrough: new TokenType("fallthrough", TokenClass.keyword, "fallthrough"), - false: new TokenType("false", TokenClass.keyword, "false"), - fn: new TokenType("fn", TokenClass.keyword, "fn"), - for: new TokenType("for", TokenClass.keyword, "for"), - function: new TokenType("function", TokenClass.keyword, "function"), - if: new TokenType("if", TokenClass.keyword, "if"), - let: new TokenType("let", TokenClass.keyword, "let"), - const: new TokenType("const", TokenClass.keyword, "const"), - loop: new TokenType("loop", TokenClass.keyword, "loop"), - while: new TokenType("while", TokenClass.keyword, "while"), - private: new TokenType("private", TokenClass.keyword, "private"), - read: new TokenType("read", TokenClass.keyword, "read"), - read_write: new TokenType("read_write", TokenClass.keyword, "read_write"), - return: new TokenType("return", TokenClass.keyword, "return"), - requires: new TokenType("requires", TokenClass.keyword, "requires"), - storage: new TokenType("storage", TokenClass.keyword, "storage"), - switch: new TokenType("switch", TokenClass.keyword, "switch"), - true: new TokenType("true", TokenClass.keyword, "true"), - alias: new TokenType("alias", TokenClass.keyword, "alias"), - type: new TokenType("type", TokenClass.keyword, "type"), - uniform: new TokenType("uniform", TokenClass.keyword, "uniform"), - var: new TokenType("var", TokenClass.keyword, "var"), - override: new TokenType("override", TokenClass.keyword, "override"), - workgroup: new TokenType("workgroup", TokenClass.keyword, "workgroup"), - write: new TokenType("write", TokenClass.keyword, "write"), - r8unorm: new TokenType("r8unorm", TokenClass.keyword, "r8unorm"), - r8snorm: new TokenType("r8snorm", TokenClass.keyword, "r8snorm"), - r8uint: new TokenType("r8uint", TokenClass.keyword, "r8uint"), - r8sint: new TokenType("r8sint", TokenClass.keyword, "r8sint"), - r16uint: new TokenType("r16uint", TokenClass.keyword, "r16uint"), - r16sint: new TokenType("r16sint", TokenClass.keyword, "r16sint"), - r16float: new TokenType("r16float", TokenClass.keyword, "r16float"), - rg8unorm: new TokenType("rg8unorm", TokenClass.keyword, "rg8unorm"), - rg8snorm: new TokenType("rg8snorm", TokenClass.keyword, "rg8snorm"), - rg8uint: new TokenType("rg8uint", TokenClass.keyword, "rg8uint"), - rg8sint: new TokenType("rg8sint", TokenClass.keyword, "rg8sint"), - r32uint: new TokenType("r32uint", TokenClass.keyword, "r32uint"), - r32sint: new TokenType("r32sint", TokenClass.keyword, "r32sint"), - r32float: new TokenType("r32float", TokenClass.keyword, "r32float"), - rg16uint: new TokenType("rg16uint", TokenClass.keyword, "rg16uint"), - rg16sint: new TokenType("rg16sint", TokenClass.keyword, "rg16sint"), - rg16float: new TokenType("rg16float", TokenClass.keyword, "rg16float"), - rgba8unorm: new TokenType("rgba8unorm", TokenClass.keyword, "rgba8unorm"), - rgba8unorm_srgb: new TokenType("rgba8unorm_srgb", TokenClass.keyword, "rgba8unorm_srgb"), - rgba8snorm: new TokenType("rgba8snorm", TokenClass.keyword, "rgba8snorm"), - rgba8uint: new TokenType("rgba8uint", TokenClass.keyword, "rgba8uint"), - rgba8sint: new TokenType("rgba8sint", TokenClass.keyword, "rgba8sint"), - bgra8unorm: new TokenType("bgra8unorm", TokenClass.keyword, "bgra8unorm"), - bgra8unorm_srgb: new TokenType("bgra8unorm_srgb", TokenClass.keyword, "bgra8unorm_srgb"), - rgb10a2unorm: new TokenType("rgb10a2unorm", TokenClass.keyword, "rgb10a2unorm"), - rg11b10float: new TokenType("rg11b10float", TokenClass.keyword, "rg11b10float"), - rg32uint: new TokenType("rg32uint", TokenClass.keyword, "rg32uint"), - rg32sint: new TokenType("rg32sint", TokenClass.keyword, "rg32sint"), - rg32float: new TokenType("rg32float", TokenClass.keyword, "rg32float"), - rgba16uint: new TokenType("rgba16uint", TokenClass.keyword, "rgba16uint"), - rgba16sint: new TokenType("rgba16sint", TokenClass.keyword, "rgba16sint"), - rgba16float: new TokenType("rgba16float", TokenClass.keyword, "rgba16float"), - rgba32uint: new TokenType("rgba32uint", TokenClass.keyword, "rgba32uint"), - rgba32sint: new TokenType("rgba32sint", TokenClass.keyword, "rgba32sint"), - rgba32float: new TokenType("rgba32float", TokenClass.keyword, "rgba32float"), - static_assert: new TokenType("static_assert", TokenClass.keyword, "static_assert") - // WGSL grammar has a few keywords that have different token names than the strings they - // represent. Aliasing them here. - /*int32: new TokenType("i32", TokenClass.keyword, "i32"), - uint32: new TokenType("u32", TokenClass.keyword, "u32"), - float32: new TokenType("f32", TokenClass.keyword, "f32"), - pointer: new TokenType("ptr", TokenClass.keyword, "ptr"),*/ -}; -TokenTypes.tokens = { - decimal_float_literal: new TokenType("decimal_float_literal", TokenClass.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?f?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+f?)|([0-9]+f)/), - hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/), - int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/), - uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/), - ident: new TokenType("ident", TokenClass.token, /[_a-zA-Z][0-9a-zA-Z_]*/), - and: new TokenType("and", TokenClass.token, "&"), - and_and: new TokenType("and_and", TokenClass.token, "&&"), - arrow: new TokenType("arrow ", TokenClass.token, "->"), - attr: new TokenType("attr", TokenClass.token, "@"), - forward_slash: new TokenType("forward_slash", TokenClass.token, "/"), - bang: new TokenType("bang", TokenClass.token, "!"), - bracket_left: new TokenType("bracket_left", TokenClass.token, "["), - bracket_right: new TokenType("bracket_right", TokenClass.token, "]"), - brace_left: new TokenType("brace_left", TokenClass.token, "{"), - brace_right: new TokenType("brace_right", TokenClass.token, "}"), - colon: new TokenType("colon", TokenClass.token, ":"), - comma: new TokenType("comma", TokenClass.token, ","), - equal: new TokenType("equal", TokenClass.token, "="), - equal_equal: new TokenType("equal_equal", TokenClass.token, "=="), - not_equal: new TokenType("not_equal", TokenClass.token, "!="), - greater_than: new TokenType("greater_than", TokenClass.token, ">"), - greater_than_equal: new TokenType("greater_than_equal", TokenClass.token, ">="), - shift_right: new TokenType("shift_right", TokenClass.token, ">>"), - less_than: new TokenType("less_than", TokenClass.token, "<"), - less_than_equal: new TokenType("less_than_equal", TokenClass.token, "<="), - shift_left: new TokenType("shift_left", TokenClass.token, "<<"), - modulo: new TokenType("modulo", TokenClass.token, "%"), - minus: new TokenType("minus", TokenClass.token, "-"), - minus_minus: new TokenType("minus_minus", TokenClass.token, "--"), - period: new TokenType("period", TokenClass.token, "."), - plus: new TokenType("plus", TokenClass.token, "+"), - plus_plus: new TokenType("plus_plus", TokenClass.token, "++"), - or: new TokenType("or", TokenClass.token, "|"), - or_or: new TokenType("or_or", TokenClass.token, "||"), - paren_left: new TokenType("paren_left", TokenClass.token, "("), - paren_right: new TokenType("paren_right", TokenClass.token, ")"), - semicolon: new TokenType("semicolon", TokenClass.token, ";"), - star: new TokenType("star", TokenClass.token, "*"), - tilde: new TokenType("tilde", TokenClass.token, "~"), - underscore: new TokenType("underscore", TokenClass.token, "_"), - xor: new TokenType("xor", TokenClass.token, "^"), - plus_equal: new TokenType("plus_equal", TokenClass.token, "+="), - minus_equal: new TokenType("minus_equal", TokenClass.token, "-="), - times_equal: new TokenType("times_equal", TokenClass.token, "*="), - division_equal: new TokenType("division_equal", TokenClass.token, "/="), - modulo_equal: new TokenType("modulo_equal", TokenClass.token, "%="), - and_equal: new TokenType("and_equal", TokenClass.token, "&="), - or_equal: new TokenType("or_equal", TokenClass.token, "|="), - xor_equal: new TokenType("xor_equal", TokenClass.token, "^="), - shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="), - shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=") -}; -TokenTypes.simpleTokens = { - "@": _a.tokens.attr, - "{": _a.tokens.brace_left, - "}": _a.tokens.brace_right, - ":": _a.tokens.colon, - ",": _a.tokens.comma, - "(": _a.tokens.paren_left, - ")": _a.tokens.paren_right, - ";": _a.tokens.semicolon -}; -TokenTypes.literalTokens = { - "&": _a.tokens.and, - "&&": _a.tokens.and_and, - "->": _a.tokens.arrow, - "/": _a.tokens.forward_slash, - "!": _a.tokens.bang, - "[": _a.tokens.bracket_left, - "]": _a.tokens.bracket_right, - "=": _a.tokens.equal, - "==": _a.tokens.equal_equal, - "!=": _a.tokens.not_equal, - ">": _a.tokens.greater_than, - ">=": _a.tokens.greater_than_equal, - ">>": _a.tokens.shift_right, - "<": _a.tokens.less_than, - "<=": _a.tokens.less_than_equal, - "<<": _a.tokens.shift_left, - "%": _a.tokens.modulo, - "-": _a.tokens.minus, - "--": _a.tokens.minus_minus, - ".": _a.tokens.period, - "+": _a.tokens.plus, - "++": _a.tokens.plus_plus, - "|": _a.tokens.or, - "||": _a.tokens.or_or, - "*": _a.tokens.star, - "~": _a.tokens.tilde, - "_": _a.tokens.underscore, - "^": _a.tokens.xor, - "+=": _a.tokens.plus_equal, - "-=": _a.tokens.minus_equal, - "*=": _a.tokens.times_equal, - "/=": _a.tokens.division_equal, - "%=": _a.tokens.modulo_equal, - "&=": _a.tokens.and_equal, - "|=": _a.tokens.or_equal, - "^=": _a.tokens.xor_equal, - ">>=": _a.tokens.shift_right_equal, - "<<=": _a.tokens.shift_left_equal -}; -TokenTypes.regexTokens = { - decimal_float_literal: _a.tokens.decimal_float_literal, - hex_float_literal: _a.tokens.hex_float_literal, - int_literal: _a.tokens.int_literal, - uint_literal: _a.tokens.uint_literal, - ident: _a.tokens.ident -}; -TokenTypes.storage_class = [ - _a.keywords.function, - _a.keywords.private, - _a.keywords.workgroup, - _a.keywords.uniform, - _a.keywords.storage -]; -TokenTypes.access_mode = [ - _a.keywords.read, - _a.keywords.write, - _a.keywords.read_write -]; -TokenTypes.sampler_type = [ - _a.keywords.sampler, - _a.keywords.sampler_comparison -]; -TokenTypes.sampled_texture_type = [ - _a.keywords.texture_1d, - _a.keywords.texture_2d, - _a.keywords.texture_2d_array, - _a.keywords.texture_3d, - _a.keywords.texture_cube, - _a.keywords.texture_cube_array -]; -TokenTypes.multisampled_texture_type = [ - _a.keywords.texture_multisampled_2d -]; -TokenTypes.storage_texture_type = [ - _a.keywords.texture_storage_1d, - _a.keywords.texture_storage_2d, - _a.keywords.texture_storage_2d_array, - _a.keywords.texture_storage_3d -]; -TokenTypes.depth_texture_type = [ - _a.keywords.texture_depth_2d, - _a.keywords.texture_depth_2d_array, - _a.keywords.texture_depth_cube, - _a.keywords.texture_depth_cube_array, - _a.keywords.texture_depth_multisampled_2d -]; -TokenTypes.texture_external_type = [_a.keywords.texture_external]; -TokenTypes.any_texture_type = [ - ..._a.sampled_texture_type, - ..._a.multisampled_texture_type, - ..._a.storage_texture_type, - ..._a.depth_texture_type, - ..._a.texture_external_type -]; -TokenTypes.texel_format = [ - _a.keywords.r8unorm, - _a.keywords.r8snorm, - _a.keywords.r8uint, - _a.keywords.r8sint, - _a.keywords.r16uint, - _a.keywords.r16sint, - _a.keywords.r16float, - _a.keywords.rg8unorm, - _a.keywords.rg8snorm, - _a.keywords.rg8uint, - _a.keywords.rg8sint, - _a.keywords.r32uint, - _a.keywords.r32sint, - _a.keywords.r32float, - _a.keywords.rg16uint, - _a.keywords.rg16sint, - _a.keywords.rg16float, - _a.keywords.rgba8unorm, - _a.keywords.rgba8unorm_srgb, - _a.keywords.rgba8snorm, - _a.keywords.rgba8uint, - _a.keywords.rgba8sint, - _a.keywords.bgra8unorm, - _a.keywords.bgra8unorm_srgb, - _a.keywords.rgb10a2unorm, - _a.keywords.rg11b10float, - _a.keywords.rg32uint, - _a.keywords.rg32sint, - _a.keywords.rg32float, - _a.keywords.rgba16uint, - _a.keywords.rgba16sint, - _a.keywords.rgba16float, - _a.keywords.rgba32uint, - _a.keywords.rgba32sint, - _a.keywords.rgba32float -]; -TokenTypes.const_literal = [ - _a.tokens.int_literal, - _a.tokens.uint_literal, - _a.tokens.decimal_float_literal, - _a.tokens.hex_float_literal, - _a.keywords.true, - _a.keywords.false -]; -TokenTypes.literal_or_ident = [ - _a.tokens.ident, - _a.tokens.int_literal, - _a.tokens.uint_literal, - _a.tokens.decimal_float_literal, - _a.tokens.hex_float_literal -]; -TokenTypes.element_count_expression = [ - _a.tokens.int_literal, - _a.tokens.uint_literal, - _a.tokens.ident -]; -TokenTypes.template_types = [ - _a.keywords.vec2, - _a.keywords.vec3, - _a.keywords.vec4, - _a.keywords.mat2x2, - _a.keywords.mat2x3, - _a.keywords.mat2x4, - _a.keywords.mat3x2, - _a.keywords.mat3x3, - _a.keywords.mat3x4, - _a.keywords.mat4x2, - _a.keywords.mat4x3, - _a.keywords.mat4x4, - _a.keywords.atomic, - _a.keywords.bitcast, - ..._a.any_texture_type -]; -TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block, _a.keywords.diagnostic]; -TokenTypes.assignment_operators = [ - _a.tokens.equal, - _a.tokens.plus_equal, - _a.tokens.minus_equal, - _a.tokens.times_equal, - _a.tokens.division_equal, - _a.tokens.modulo_equal, - _a.tokens.and_equal, - _a.tokens.or_equal, - _a.tokens.xor_equal, - _a.tokens.shift_right_equal, - _a.tokens.shift_left_equal -]; -TokenTypes.increment_operators = [ - _a.tokens.plus_plus, - _a.tokens.minus_minus -]; -var Token = class { - constructor(type, lexeme, line) { - this.type = type; - this.lexeme = lexeme; - this.line = line; - } - toString() { - return this.lexeme; - } - isTemplateType() { - return TokenTypes.template_types.indexOf(this.type) != -1; - } - isArrayType() { - return this.type == TokenTypes.keywords.array; - } - isArrayOrTemplateType() { - return this.isArrayType() || this.isTemplateType(); - } -}; -var WgslScanner = class { - constructor(source) { - this._tokens = []; - this._start = 0; - this._current = 0; - this._line = 1; - this._source = source !== null && source !== void 0 ? source : ""; - } - /// Scan all tokens from the source. - scanTokens() { - while (!this._isAtEnd()) { - this._start = this._current; - if (!this.scanToken()) { - throw `Invalid syntax at line ${this._line}`; - } - } - this._tokens.push(new Token(TokenTypes.eof, "", this._line)); - return this._tokens; - } - /// Scan a single token from the source. - scanToken() { - let lexeme = this._advance(); - if (lexeme == "\n") { - this._line++; - return true; - } - if (this._isWhitespace(lexeme)) { - return true; - } - if (lexeme == "/") { - if (this._peekAhead() == "/") { - while (lexeme != "\n") { - if (this._isAtEnd()) { - return true; - } - lexeme = this._advance(); - } - this._line++; - return true; - } else if (this._peekAhead() == "*") { - this._advance(); - let commentLevel = 1; - while (commentLevel > 0) { - if (this._isAtEnd()) { - return true; - } - lexeme = this._advance(); - if (lexeme == "\n") { - this._line++; - } else if (lexeme == "*") { - if (this._peekAhead() == "/") { - this._advance(); - commentLevel--; - if (commentLevel == 0) { - return true; - } - } - } else if (lexeme == "/") { - if (this._peekAhead() == "*") { - this._advance(); - commentLevel++; - } - } - } - return true; - } - } - const simpleToken = TokenTypes.simpleTokens[lexeme]; - if (simpleToken) { - this._addToken(simpleToken); - return true; - } - let matchType = TokenTypes.none; - const isAlpha = this._isAlpha(lexeme); - const isUnderscore = lexeme === "_"; - if (this._isAlphaNumeric(lexeme)) { - let nextChar = this._peekAhead(); - while (this._isAlphaNumeric(nextChar)) { - lexeme += this._advance(); - nextChar = this._peekAhead(); - } - } - if (isAlpha) { - const matchedType = TokenTypes.keywords[lexeme]; - if (matchedType) { - this._addToken(matchedType); - return true; - } - } - if (isAlpha || isUnderscore) { - this._addToken(TokenTypes.tokens.ident); - return true; - } - for (; ; ) { - let matchedType = this._findType(lexeme); - const nextLexeme = this._peekAhead(); - if (lexeme == "-" && this._tokens.length > 0) { - if (nextLexeme == "=") { - this._current++; - lexeme += nextLexeme; - this._addToken(TokenTypes.tokens.minus_equal); - return true; - } - if (nextLexeme == "-") { - this._current++; - lexeme += nextLexeme; - this._addToken(TokenTypes.tokens.minus_minus); - return true; - } - const ti = this._tokens.length - 1; - const isIdentOrLiteral = TokenTypes.literal_or_ident.indexOf(this._tokens[ti].type) != -1; - if ((isIdentOrLiteral || this._tokens[ti].type == TokenTypes.tokens.paren_right) && nextLexeme != ">") { - this._addToken(matchedType); - return true; - } - } - if (lexeme == ">" && (nextLexeme == ">" || nextLexeme == "=")) { - let foundLessThan = false; - let ti = this._tokens.length - 1; - for (let count2 = 0; count2 < 5 && ti >= 0; ++count2, --ti) { - if (TokenTypes.assignment_operators.indexOf(this._tokens[ti].type) !== -1) { - break; - } - if (this._tokens[ti].type === TokenTypes.tokens.less_than) { - if (ti > 0 && this._tokens[ti - 1].isArrayOrTemplateType()) { - foundLessThan = true; - } - break; - } - } - if (foundLessThan) { - this._addToken(matchedType); - return true; - } - } - if (matchedType === TokenTypes.none) { - let lookAheadLexeme = lexeme; - let lookAhead = 0; - const maxLookAhead = 2; - for (let li = 0; li < maxLookAhead; ++li) { - lookAheadLexeme += this._peekAhead(li); - matchedType = this._findType(lookAheadLexeme); - if (matchedType !== TokenTypes.none) { - lookAhead = li; - break; - } - } - if (matchedType === TokenTypes.none) { - if (matchType === TokenTypes.none) { - return false; - } - this._current--; - this._addToken(matchType); - return true; - } - lexeme = lookAheadLexeme; - this._current += lookAhead + 1; - } - matchType = matchedType; - if (this._isAtEnd()) { - break; - } - lexeme += this._advance(); - } - if (matchType === TokenTypes.none) { - return false; - } - this._addToken(matchType); - return true; - } - _findType(lexeme) { - for (const name2 in TokenTypes.regexTokens) { - const type2 = TokenTypes.regexTokens[name2]; - if (this._match(lexeme, type2.rule)) { - return type2; - } - } - const type = TokenTypes.literalTokens[lexeme]; - if (type) { - return type; - } - return TokenTypes.none; - } - _match(lexeme, rule) { - const match = rule.exec(lexeme); - return match && match.index == 0 && match[0] == lexeme; - } - _isAtEnd() { - return this._current >= this._source.length; - } - _isAlpha(c) { - return c >= "a" && c <= "z" || c >= "A" && c <= "Z"; - } - _isAlphaNumeric(c) { - return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c == "_" || c >= "0" && c <= "9"; - } - _isWhitespace(c) { - return c == " " || c == " " || c == "\r"; - } - _advance(amount = 0) { - let c = this._source[this._current]; - amount = amount || 0; - amount++; - this._current += amount; - return c; - } - _peekAhead(offset = 0) { - offset = offset || 0; - if (this._current + offset >= this._source.length) { - return "\0"; - } - return this._source[this._current + offset]; - } - _addToken(type) { - const text = this._source.substring(this._start, this._current); - this._tokens.push(new Token(type, text, this._line)); - } -}; -var WgslParser = class { - constructor() { - this._tokens = []; - this._current = 0; - this._currentLine = 0; - this._context = new ParseContext(); - this._deferArrayCountEval = []; - } - parse(tokensOrCode) { - this._initialize(tokensOrCode); - this._deferArrayCountEval.length = 0; - const statements = []; - while (!this._isAtEnd()) { - const statement = this._global_decl_or_directive(); - if (!statement) { - break; - } - statements.push(statement); - } - if (this._deferArrayCountEval.length > 0) { - for (const arrayDecl of this._deferArrayCountEval) { - const arrayType = arrayDecl["arrayType"]; - const countNode = arrayDecl["countNode"]; - if (countNode instanceof VariableExpr) { - const variable = countNode; - const name2 = variable.name; - const constant = this._context.constants.get(name2); - if (constant) { - try { - const count2 = constant.evaluate(this._context); - arrayType.count = count2; - } catch (e) { - } - } - } - } - this._deferArrayCountEval.length = 0; - } - return statements; - } - _initialize(tokensOrCode) { - if (tokensOrCode) { - if (typeof tokensOrCode == "string") { - const scanner = new WgslScanner(tokensOrCode); - this._tokens = scanner.scanTokens(); - } else { - this._tokens = tokensOrCode; - } - } else { - this._tokens = []; - } - this._current = 0; - } - _error(token, message2) { - return { - token, - message: message2, - toString: function() { - return `${message2}`; - } - }; - } - _isAtEnd() { - return this._current >= this._tokens.length || this._peek().type == TokenTypes.eof; - } - _match(types) { - if (types instanceof TokenType) { - if (this._check(types)) { - this._advance(); - return true; - } - return false; - } - for (let i = 0, l = types.length; i < l; ++i) { - const type = types[i]; - if (this._check(type)) { - this._advance(); - return true; - } - } - return false; - } - _consume(types, message2) { - if (this._check(types)) { - return this._advance(); - } - throw this._error(this._peek(), message2); - } - _check(types) { - if (this._isAtEnd()) { - return false; - } - const tk = this._peek(); - if (types instanceof Array) { - const t = tk.type; - const index2 = types.indexOf(t); - return index2 != -1; - } - return tk.type == types; - } - _advance() { - var _a2, _b; - this._currentLine = (_b = (_a2 = this._peek()) === null || _a2 === void 0 ? void 0 : _a2.line) !== null && _b !== void 0 ? _b : -1; - if (!this._isAtEnd()) { - this._current++; - } - return this._previous(); - } - _peek() { - return this._tokens[this._current]; - } - _previous() { - return this._tokens[this._current - 1]; - } - _global_decl_or_directive() { - while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd()) - ; - if (this._match(TokenTypes.keywords.alias)) { - const type = this._type_alias(); - this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); - return type; - } - if (this._match(TokenTypes.keywords.diagnostic)) { - const directive = this._diagnostic(); - this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); - return directive; - } - if (this._match(TokenTypes.keywords.requires)) { - const requires = this._requires_directive(); - this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); - return requires; - } - if (this._match(TokenTypes.keywords.enable)) { - const enable2 = this._enable_directive(); - this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); - return enable2; - } - const attrs = this._attribute(); - if (this._check(TokenTypes.keywords.var)) { - const _var = this._global_variable_decl(); - if (_var != null) { - _var.attributes = attrs; - } - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - return _var; - } - if (this._check(TokenTypes.keywords.override)) { - const _override = this._override_variable_decl(); - if (_override != null) { - _override.attributes = attrs; - } - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - return _override; - } - if (this._check(TokenTypes.keywords.let)) { - const _let = this._global_let_decl(); - if (_let != null) { - _let.attributes = attrs; - } - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - return _let; - } - if (this._check(TokenTypes.keywords.const)) { - const _const = this._global_const_decl(); - if (_const != null) { - _const.attributes = attrs; - } - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - return _const; - } - if (this._check(TokenTypes.keywords.struct)) { - const _struct = this._struct_decl(); - if (_struct != null) { - _struct.attributes = attrs; - } - return _struct; - } - if (this._check(TokenTypes.keywords.fn)) { - const _fn = this._function_decl(); - if (_fn != null) { - _fn.attributes = attrs; - } - return _fn; - } - return null; - } - _function_decl() { - if (!this._match(TokenTypes.keywords.fn)) { - return null; - } - const startLine = this._currentLine; - const name2 = this._consume(TokenTypes.tokens.ident, "Expected function name.").toString(); - this._consume(TokenTypes.tokens.paren_left, "Expected '(' for function arguments."); - const args = []; - if (!this._check(TokenTypes.tokens.paren_right)) { - do { - if (this._check(TokenTypes.tokens.paren_right)) { - break; - } - const argAttrs = this._attribute(); - const name3 = this._consume(TokenTypes.tokens.ident, "Expected argument name.").toString(); - this._consume(TokenTypes.tokens.colon, "Expected ':' for argument type."); - const typeAttrs = this._attribute(); - const type = this._type_decl(); - if (type != null) { - type.attributes = typeAttrs; - args.push(new Argument(name3, type, argAttrs)); - } - } while (this._match(TokenTypes.tokens.comma)); - } - this._consume(TokenTypes.tokens.paren_right, "Expected ')' after function arguments."); - let _return = null; - if (this._match(TokenTypes.tokens.arrow)) { - const attrs = this._attribute(); - _return = this._type_decl(); - if (_return != null) { - _return.attributes = attrs; - } - } - const body = this._compound_statement(); - const endLine = this._currentLine; - return new Function(name2, args, _return, body, startLine, endLine); - } - _compound_statement() { - const statements = []; - this._consume(TokenTypes.tokens.brace_left, "Expected '{' for block."); - while (!this._check(TokenTypes.tokens.brace_right)) { - const statement = this._statement(); - if (statement !== null) { - statements.push(statement); - } - } - this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block."); - return statements; - } - _statement() { - while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd()) - ; - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - if (this._check(TokenTypes.keywords.if)) { - return this._if_statement(); - } - if (this._check(TokenTypes.keywords.switch)) { - return this._switch_statement(); - } - if (this._check(TokenTypes.keywords.loop)) { - return this._loop_statement(); - } - if (this._check(TokenTypes.keywords.for)) { - return this._for_statement(); - } - if (this._check(TokenTypes.keywords.while)) { - return this._while_statement(); - } - if (this._check(TokenTypes.keywords.continuing)) { - return this._continuing_statement(); - } - if (this._check(TokenTypes.keywords.static_assert)) { - return this._static_assert_statement(); - } - if (this._check(TokenTypes.tokens.brace_left)) { - return this._compound_statement(); - } - let result = null; - if (this._check(TokenTypes.keywords.return)) { - result = this._return_statement(); - } else if (this._check([ - TokenTypes.keywords.var, - TokenTypes.keywords.let, - TokenTypes.keywords.const - ])) { - result = this._variable_statement(); - } else if (this._match(TokenTypes.keywords.discard)) { - result = new Discard(); - } else if (this._match(TokenTypes.keywords.break)) { - result = new Break(); - } else if (this._match(TokenTypes.keywords.continue)) { - result = new Continue(); - } else { - result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement(); - } - if (result != null) { - this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement."); - } - return result; - } - _static_assert_statement() { - if (!this._match(TokenTypes.keywords.static_assert)) { - return null; - } - const expression = this._optional_paren_expression(); - return new StaticAssert(expression); - } - _while_statement() { - if (!this._match(TokenTypes.keywords.while)) { - return null; - } - const condition = this._optional_paren_expression(); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - const block = this._compound_statement(); - return new While(condition, block); - } - _continuing_statement() { - if (!this._match(TokenTypes.keywords.continuing)) { - return null; - } - const block = this._compound_statement(); - return new Continuing(block); - } - _for_statement() { - if (!this._match(TokenTypes.keywords.for)) { - return null; - } - this._consume(TokenTypes.tokens.paren_left, "Expected '('."); - const init = !this._check(TokenTypes.tokens.semicolon) ? this._for_init() : null; - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - const condition = !this._check(TokenTypes.tokens.semicolon) ? this._short_circuit_or_expression() : null; - this._consume(TokenTypes.tokens.semicolon, "Expected ';'."); - const increment = !this._check(TokenTypes.tokens.paren_right) ? this._for_increment() : null; - this._consume(TokenTypes.tokens.paren_right, "Expected ')'."); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - const body = this._compound_statement(); - return new For(init, condition, increment, body); - } - _for_init() { - return this._variable_statement() || this._func_call_statement() || this._assignment_statement(); - } - _for_increment() { - return this._func_call_statement() || this._increment_decrement_statement() || this._assignment_statement(); - } - _variable_statement() { - if (this._check(TokenTypes.keywords.var)) { - const _var = this._variable_decl(); - if (_var === null) { - throw this._error(this._peek(), "Variable declaration expected."); - } - let value = null; - if (this._match(TokenTypes.tokens.equal)) { - value = this._short_circuit_or_expression(); - } - return new Var(_var.name, _var.type, _var.storage, _var.access, value); - } - if (this._match(TokenTypes.keywords.let)) { - const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for let.").toString(); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const typeAttrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = typeAttrs; - } - } - this._consume(TokenTypes.tokens.equal, "Expected '=' for let."); - const value = this._short_circuit_or_expression(); - return new Let(name2, type, null, null, value); - } - if (this._match(TokenTypes.keywords.const)) { - const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for const.").toString(); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const typeAttrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = typeAttrs; - } - } - this._consume(TokenTypes.tokens.equal, "Expected '=' for const."); - const value = this._short_circuit_or_expression(); - return new Const(name2, type, null, null, value); - } - return null; - } - _increment_decrement_statement() { - const savedPos = this._current; - const _var = this._unary_expression(); - if (_var == null) { - return null; - } - if (!this._check(TokenTypes.increment_operators)) { - this._current = savedPos; - return null; - } - const token = this._consume(TokenTypes.increment_operators, "Expected increment operator"); - return new Increment(token.type === TokenTypes.tokens.plus_plus ? IncrementOperator.increment : IncrementOperator.decrement, _var); - } - _assignment_statement() { - let _var = null; - if (this._check(TokenTypes.tokens.brace_right)) { - return null; - } - let isUnderscore = this._match(TokenTypes.tokens.underscore); - if (!isUnderscore) { - _var = this._unary_expression(); - } - if (!isUnderscore && _var == null) { - return null; - } - const type = this._consume(TokenTypes.assignment_operators, "Expected assignment operator."); - const value = this._short_circuit_or_expression(); - return new Assign(AssignOperator.parse(type.lexeme), _var, value); - } - _func_call_statement() { - if (!this._check(TokenTypes.tokens.ident)) { - return null; - } - const savedPos = this._current; - const name2 = this._consume(TokenTypes.tokens.ident, "Expected function name."); - const args = this._argument_expression_list(); - if (args === null) { - this._current = savedPos; - return null; - } - return new Call(name2.lexeme, args); - } - _loop_statement() { - if (!this._match(TokenTypes.keywords.loop)) { - return null; - } - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop."); - const statements = []; - let statement = this._statement(); - while (statement !== null) { - if (Array.isArray(statement)) { - for (let s of statement) { - statements.push(s); - } - } else { - statements.push(statement); - } - statement = this._statement(); - } - let continuing = null; - if (this._match(TokenTypes.keywords.continuing)) { - continuing = this._compound_statement(); - } - this._consume(TokenTypes.tokens.brace_right, "Expected '}' for loop."); - return new Loop(statements, continuing); - } - _switch_statement() { - if (!this._match(TokenTypes.keywords.switch)) { - return null; - } - const condition = this._optional_paren_expression(); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch."); - const body = this._switch_body(); - if (body == null || body.length == 0) { - throw this._error(this._previous(), "Expected 'case' or 'default'."); - } - this._consume(TokenTypes.tokens.brace_right, "Expected '}' for switch."); - return new Switch(condition, body); - } - _switch_body() { - const cases = []; - if (this._match(TokenTypes.keywords.case)) { - const selector = this._case_selectors(); - this._match(TokenTypes.tokens.colon); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch case."); - const body = this._case_body(); - this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch case."); - cases.push(new Case(selector, body)); - } - if (this._match(TokenTypes.keywords.default)) { - this._match(TokenTypes.tokens.colon); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch default."); - const body = this._case_body(); - this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch default."); - cases.push(new Default(body)); - } - if (this._check([TokenTypes.keywords.default, TokenTypes.keywords.case])) { - const _cases = this._switch_body(); - cases.push(_cases[0]); - } - return cases; - } - _case_selectors() { - const selectors = [ - this._shift_expression() - //?.evaluate(this._context).toString() ?? "", - ]; - while (this._match(TokenTypes.tokens.comma)) { - selectors.push(this._shift_expression()); - } - return selectors; - } - _case_body() { - if (this._match(TokenTypes.keywords.fallthrough)) { - this._consume(TokenTypes.tokens.semicolon, "Expected ';'"); - return []; - } - let statement = this._statement(); - if (statement == null) { - return []; - } - if (!(statement instanceof Array)) { - statement = [statement]; - } - const nextStatement = this._case_body(); - if (nextStatement.length == 0) { - return statement; - } - return [...statement, nextStatement[0]]; - } - _if_statement() { - if (!this._match(TokenTypes.keywords.if)) { - return null; - } - const condition = this._optional_paren_expression(); - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - const block = this._compound_statement(); - let elseif = []; - if (this._match_elseif()) { - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - elseif = this._elseif_statement(elseif); - } - let _else = null; - if (this._match(TokenTypes.keywords.else)) { - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - _else = this._compound_statement(); - } - return new If(condition, block, elseif, _else); - } - _match_elseif() { - if (this._tokens[this._current].type === TokenTypes.keywords.else && this._tokens[this._current + 1].type === TokenTypes.keywords.if) { - this._advance(); - this._advance(); - return true; - } - return false; - } - _elseif_statement(elseif = []) { - const condition = this._optional_paren_expression(); - const block = this._compound_statement(); - elseif.push(new ElseIf(condition, block)); - if (this._match_elseif()) { - if (this._check(TokenTypes.tokens.attr)) { - this._attribute(); - } - this._elseif_statement(elseif); - } - return elseif; - } - _return_statement() { - if (!this._match(TokenTypes.keywords.return)) { - return null; - } - const value = this._short_circuit_or_expression(); - return new Return(value); - } - _short_circuit_or_expression() { - let expr = this._short_circuit_and_expr(); - while (this._match(TokenTypes.tokens.or_or)) { - expr = new BinaryOperator(this._previous().toString(), expr, this._short_circuit_and_expr()); - } - return expr; - } - _short_circuit_and_expr() { - let expr = this._inclusive_or_expression(); - while (this._match(TokenTypes.tokens.and_and)) { - expr = new BinaryOperator(this._previous().toString(), expr, this._inclusive_or_expression()); - } - return expr; - } - _inclusive_or_expression() { - let expr = this._exclusive_or_expression(); - while (this._match(TokenTypes.tokens.or)) { - expr = new BinaryOperator(this._previous().toString(), expr, this._exclusive_or_expression()); - } - return expr; - } - _exclusive_or_expression() { - let expr = this._and_expression(); - while (this._match(TokenTypes.tokens.xor)) { - expr = new BinaryOperator(this._previous().toString(), expr, this._and_expression()); - } - return expr; - } - _and_expression() { - let expr = this._equality_expression(); - while (this._match(TokenTypes.tokens.and)) { - expr = new BinaryOperator(this._previous().toString(), expr, this._equality_expression()); - } - return expr; - } - _equality_expression() { - const expr = this._relational_expression(); - if (this._match([TokenTypes.tokens.equal_equal, TokenTypes.tokens.not_equal])) { - return new BinaryOperator(this._previous().toString(), expr, this._relational_expression()); - } - return expr; - } - _relational_expression() { - let expr = this._shift_expression(); - while (this._match([ - TokenTypes.tokens.less_than, - TokenTypes.tokens.greater_than, - TokenTypes.tokens.less_than_equal, - TokenTypes.tokens.greater_than_equal - ])) { - expr = new BinaryOperator(this._previous().toString(), expr, this._shift_expression()); - } - return expr; - } - _shift_expression() { - let expr = this._additive_expression(); - while (this._match([TokenTypes.tokens.shift_left, TokenTypes.tokens.shift_right])) { - expr = new BinaryOperator(this._previous().toString(), expr, this._additive_expression()); - } - return expr; - } - _additive_expression() { - let expr = this._multiplicative_expression(); - while (this._match([TokenTypes.tokens.plus, TokenTypes.tokens.minus])) { - expr = new BinaryOperator(this._previous().toString(), expr, this._multiplicative_expression()); - } - return expr; - } - _multiplicative_expression() { - let expr = this._unary_expression(); - while (this._match([ - TokenTypes.tokens.star, - TokenTypes.tokens.forward_slash, - TokenTypes.tokens.modulo - ])) { - expr = new BinaryOperator(this._previous().toString(), expr, this._unary_expression()); - } - return expr; - } - _unary_expression() { - if (this._match([ - TokenTypes.tokens.minus, - TokenTypes.tokens.bang, - TokenTypes.tokens.tilde, - TokenTypes.tokens.star, - TokenTypes.tokens.and - ])) { - return new UnaryOperator(this._previous().toString(), this._unary_expression()); - } - return this._singular_expression(); - } - _singular_expression() { - const expr = this._primary_expression(); - const p = this._postfix_expression(); - if (p) { - expr.postfix = p; - } - return expr; - } - _postfix_expression() { - if (this._match(TokenTypes.tokens.bracket_left)) { - const expr = this._short_circuit_or_expression(); - this._consume(TokenTypes.tokens.bracket_right, "Expected ']'."); - const arrayIndex = new ArrayIndex(expr); - const p = this._postfix_expression(); - if (p) { - arrayIndex.postfix = p; - } - return arrayIndex; - } - if (this._match(TokenTypes.tokens.period)) { - const name2 = this._consume(TokenTypes.tokens.ident, "Expected member name."); - const p = this._postfix_expression(); - const expr = new StringExpr(name2.lexeme); - if (p) { - expr.postfix = p; - } - return expr; - } - return null; - } - _getStruct(name2) { - if (this._context.aliases.has(name2)) { - const alias = this._context.aliases.get(name2).type; - return alias; - } - if (this._context.structs.has(name2)) { - const struct = this._context.structs.get(name2); - return struct; - } - return null; - } - _primary_expression() { - if (this._match(TokenTypes.tokens.ident)) { - const name2 = this._previous().toString(); - if (this._check(TokenTypes.tokens.paren_left)) { - const args2 = this._argument_expression_list(); - const struct = this._getStruct(name2); - if (struct != null) { - return new CreateExpr(struct, args2); - } - return new CallExpr(name2, args2); - } - if (this._context.constants.has(name2)) { - const c = this._context.constants.get(name2); - return new ConstExpr(name2, c.value); - } - return new VariableExpr(name2); - } - if (this._match(TokenTypes.const_literal)) { - return new LiteralExpr(parseFloat(this._previous().toString())); - } - if (this._check(TokenTypes.tokens.paren_left)) { - return this._paren_expression(); - } - if (this._match(TokenTypes.keywords.bitcast)) { - this._consume(TokenTypes.tokens.less_than, "Expected '<'."); - const type2 = this._type_decl(); - this._consume(TokenTypes.tokens.greater_than, "Expected '>'."); - const value = this._paren_expression(); - return new BitcastExpr(type2, value); - } - const type = this._type_decl(); - const args = this._argument_expression_list(); - return new CreateExpr(type, args); - } - _argument_expression_list() { - if (!this._match(TokenTypes.tokens.paren_left)) { - return null; - } - const args = []; - do { - if (this._check(TokenTypes.tokens.paren_right)) { - break; - } - const arg = this._short_circuit_or_expression(); - args.push(arg); - } while (this._match(TokenTypes.tokens.comma)); - this._consume(TokenTypes.tokens.paren_right, "Expected ')' for agument list"); - return args; - } - _optional_paren_expression() { - this._match(TokenTypes.tokens.paren_left); - const expr = this._short_circuit_or_expression(); - this._match(TokenTypes.tokens.paren_right); - return new GroupingExpr([expr]); - } - _paren_expression() { - this._consume(TokenTypes.tokens.paren_left, "Expected '('."); - const expr = this._short_circuit_or_expression(); - this._consume(TokenTypes.tokens.paren_right, "Expected ')'."); - return new GroupingExpr([expr]); - } - _struct_decl() { - if (!this._match(TokenTypes.keywords.struct)) { - return null; - } - const startLine = this._currentLine; - const name2 = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString(); - this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body."); - const members = []; - while (!this._check(TokenTypes.tokens.brace_right)) { - const memberAttrs = this._attribute(); - const memberName = this._consume(TokenTypes.tokens.ident, "Expected variable name.").toString(); - this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type."); - const typeAttrs = this._attribute(); - const memberType = this._type_decl(); - if (memberType != null) { - memberType.attributes = typeAttrs; - } - if (!this._check(TokenTypes.tokens.brace_right)) - this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member."); - else - this._match(TokenTypes.tokens.comma); - members.push(new Member(memberName, memberType, memberAttrs)); - } - this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body."); - const endLine = this._currentLine; - const structNode = new Struct(name2, members, startLine, endLine); - this._context.structs.set(name2, structNode); - return structNode; - } - _global_variable_decl() { - const _var = this._variable_decl(); - if (_var && this._match(TokenTypes.tokens.equal)) { - _var.value = this._const_expression(); - } - return _var; - } - _override_variable_decl() { - const _override = this._override_decl(); - if (_override && this._match(TokenTypes.tokens.equal)) { - _override.value = this._const_expression(); - } - return _override; - } - _global_const_decl() { - if (!this._match(TokenTypes.keywords.const)) { - return null; - } - const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const attrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = attrs; - } - } - let value = null; - if (this._match(TokenTypes.tokens.equal)) { - const valueExpr = this._short_circuit_or_expression(); - if (valueExpr instanceof CreateExpr) { - value = valueExpr; - } else if (valueExpr instanceof ConstExpr && valueExpr.initializer instanceof CreateExpr) { - value = valueExpr.initializer; - } else { - try { - const constValue = valueExpr.evaluate(this._context); - value = new LiteralExpr(constValue); - } catch (_a2) { - value = valueExpr; - } - } - } - const c = new Const(name2.toString(), type, "", "", value); - this._context.constants.set(c.name, c); - return c; - } - _global_let_decl() { - if (!this._match(TokenTypes.keywords.let)) { - return null; - } - const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const attrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = attrs; - } - } - let value = null; - if (this._match(TokenTypes.tokens.equal)) { - value = this._const_expression(); - } - return new Let(name2.toString(), type, "", "", value); - } - _const_expression() { - return this._short_circuit_or_expression(); - } - _variable_decl() { - if (!this._match(TokenTypes.keywords.var)) { - return null; - } - let storage = ""; - let access = ""; - if (this._match(TokenTypes.tokens.less_than)) { - storage = this._consume(TokenTypes.storage_class, "Expected storage_class.").toString(); - if (this._match(TokenTypes.tokens.comma)) - access = this._consume(TokenTypes.access_mode, "Expected access_mode.").toString(); - this._consume(TokenTypes.tokens.greater_than, "Expected '>'."); - } - const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const attrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = attrs; - } - } - return new Var(name2.toString(), type, storage, access, null); - } - _override_decl() { - if (!this._match(TokenTypes.keywords.override)) { - return null; - } - const name2 = this._consume(TokenTypes.tokens.ident, "Expected variable name"); - let type = null; - if (this._match(TokenTypes.tokens.colon)) { - const attrs = this._attribute(); - type = this._type_decl(); - if (type != null) { - type.attributes = attrs; - } - } - return new Override(name2.toString(), type, null); - } - _diagnostic() { - this._consume(TokenTypes.tokens.paren_left, "Expected '('"); - const severity = this._consume(TokenTypes.tokens.ident, "Expected severity control name."); - this._consume(TokenTypes.tokens.comma, "Expected ','"); - const rule = this._consume(TokenTypes.tokens.ident, "Expected diagnostic rule name."); - this._consume(TokenTypes.tokens.paren_right, "Expected ')'"); - return new Diagnostic(severity.toString(), rule.toString()); - } - _enable_directive() { - const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); - return new Enable(name2.toString()); - } - _requires_directive() { - const extensions = [this._consume(TokenTypes.tokens.ident, "identity expected.").toString()]; - while (this._match(TokenTypes.tokens.comma)) { - const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); - extensions.push(name2.toString()); - } - return new Requires(extensions); - } - _type_alias() { - const name2 = this._consume(TokenTypes.tokens.ident, "identity expected."); - this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias."); - let aliasType = this._type_decl(); - if (aliasType === null) { - throw this._error(this._peek(), "Expected Type for Alias."); - } - if (this._context.aliases.has(aliasType.name)) { - aliasType = this._context.aliases.get(aliasType.name).type; - } - const aliasNode = new Alias(name2.toString(), aliasType); - this._context.aliases.set(aliasNode.name, aliasNode); - return aliasNode; - } - _type_decl() { - if (this._check([ - TokenTypes.tokens.ident, - ...TokenTypes.texel_format, - TokenTypes.keywords.bool, - TokenTypes.keywords.f32, - TokenTypes.keywords.i32, - TokenTypes.keywords.u32 - ])) { - const type2 = this._advance(); - const typeName = type2.toString(); - if (this._context.structs.has(typeName)) { - return this._context.structs.get(typeName); - } - if (this._context.aliases.has(typeName)) { - return this._context.aliases.get(typeName).type; - } - return new Type(type2.toString()); - } - let type = this._texture_sampler_types(); - if (type) { - return type; - } - if (this._check(TokenTypes.template_types)) { - let type2 = this._advance().toString(); - let format = null; - let access = null; - if (this._match(TokenTypes.tokens.less_than)) { - format = this._type_decl(); - access = null; - if (this._match(TokenTypes.tokens.comma)) { - access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString(); - } - this._consume(TokenTypes.tokens.greater_than, "Expected '>' for type."); - } - return new TemplateType(type2, format, access); - } - if (this._match(TokenTypes.keywords.ptr)) { - let pointer = this._previous().toString(); - this._consume(TokenTypes.tokens.less_than, "Expected '<' for pointer."); - const storage = this._consume(TokenTypes.storage_class, "Expected storage_class for pointer"); - this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer."); - const decl = this._type_decl(); - let access = null; - if (this._match(TokenTypes.tokens.comma)) { - access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString(); - } - this._consume(TokenTypes.tokens.greater_than, "Expected '>' for pointer."); - return new PointerType(pointer, storage.toString(), decl, access); - } - const attrs = this._attribute(); - if (this._match(TokenTypes.keywords.array)) { - let format = null; - let countInt = -1; - const array = this._previous(); - let countNode = null; - if (this._match(TokenTypes.tokens.less_than)) { - format = this._type_decl(); - if (this._context.aliases.has(format.name)) { - format = this._context.aliases.get(format.name).type; - } - let count2 = ""; - if (this._match(TokenTypes.tokens.comma)) { - countNode = this._shift_expression(); - try { - count2 = countNode.evaluate(this._context).toString(); - countNode = null; - } catch (e) { - count2 = "1"; - } - } - this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array."); - countInt = count2 ? parseInt(count2) : 0; - } - const arrayType = new ArrayType(array.toString(), attrs, format, countInt); - if (countNode) { - this._deferArrayCountEval.push({ arrayType, countNode }); - } - return arrayType; - } - return null; - } - _texture_sampler_types() { - if (this._match(TokenTypes.sampler_type)) { - return new SamplerType(this._previous().toString(), null, null); - } - if (this._match(TokenTypes.depth_texture_type)) { - return new SamplerType(this._previous().toString(), null, null); - } - if (this._match(TokenTypes.sampled_texture_type) || this._match(TokenTypes.multisampled_texture_type)) { - const sampler = this._previous(); - this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type."); - const format = this._type_decl(); - this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type."); - return new SamplerType(sampler.toString(), format, null); - } - if (this._match(TokenTypes.storage_texture_type)) { - const sampler = this._previous(); - this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type."); - const format = this._consume(TokenTypes.texel_format, "Invalid texel format.").toString(); - this._consume(TokenTypes.tokens.comma, "Expected ',' after texel format."); - const access = this._consume(TokenTypes.access_mode, "Expected access mode for storage texture type.").toString(); - this._consume(TokenTypes.tokens.greater_than, "Expected '>' for sampler type."); - return new SamplerType(sampler.toString(), format, access); - } - return null; - } - _attribute() { - let attributes = []; - while (this._match(TokenTypes.tokens.attr)) { - const name2 = this._consume(TokenTypes.attribute_name, "Expected attribute name"); - const attr = new Attribute(name2.toString(), null); - if (this._match(TokenTypes.tokens.paren_left)) { - attr.value = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString(); - if (this._check(TokenTypes.tokens.comma)) { - this._advance(); - do { - const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString(); - if (!(attr.value instanceof Array)) { - attr.value = [attr.value]; - } - attr.value.push(v); - } while (this._match(TokenTypes.tokens.comma)); - } - this._consume(TokenTypes.tokens.paren_right, "Expected ')'"); - } - attributes.push(attr); - } - if (attributes.length == 0) { - return null; - } - return attributes; - } -}; -var TypeInfo = class { - constructor(name2, attributes) { - this.name = name2; - this.attributes = attributes; - this.size = 0; - } - get isArray() { - return false; - } - get isStruct() { - return false; - } - get isTemplate() { - return false; - } -}; -var MemberInfo = class { - constructor(name2, type, attributes) { - this.name = name2; - this.type = type; - this.attributes = attributes; - this.offset = 0; - this.size = 0; - } - get isArray() { - return this.type.isArray; - } - get isStruct() { - return this.type.isStruct; - } - get isTemplate() { - return this.type.isTemplate; - } - get align() { - return this.type.isStruct ? this.type.align : 0; - } - get members() { - return this.type.isStruct ? this.type.members : null; - } - get format() { - return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null; - } - get count() { - return this.type.isArray ? this.type.count : 0; - } - get stride() { - return this.type.isArray ? this.type.stride : this.size; - } -}; -var StructInfo = class extends TypeInfo { - constructor(name2, attributes) { - super(name2, attributes); - this.members = []; - this.align = 0; - this.startLine = -1; - this.endLine = -1; - this.inUse = false; - } - get isStruct() { - return true; - } -}; -var ArrayInfo = class extends TypeInfo { - constructor(name2, attributes) { - super(name2, attributes); - this.count = 0; - this.stride = 0; - } - get isArray() { - return true; - } -}; -var TemplateInfo = class extends TypeInfo { - constructor(name2, format, attributes, access) { - super(name2, attributes); - this.format = format; - this.access = access; - } - get isTemplate() { - return true; - } -}; -var ResourceType; -(function(ResourceType2) { - ResourceType2[ResourceType2["Uniform"] = 0] = "Uniform"; - ResourceType2[ResourceType2["Storage"] = 1] = "Storage"; - ResourceType2[ResourceType2["Texture"] = 2] = "Texture"; - ResourceType2[ResourceType2["Sampler"] = 3] = "Sampler"; - ResourceType2[ResourceType2["StorageTexture"] = 4] = "StorageTexture"; -})(ResourceType || (ResourceType = {})); -var VariableInfo = class { - constructor(name2, type, group, binding, attributes, resourceType, access) { - this.name = name2; - this.type = type; - this.group = group; - this.binding = binding; - this.attributes = attributes; - this.resourceType = resourceType; - this.access = access; - } - get isArray() { - return this.type.isArray; - } - get isStruct() { - return this.type.isStruct; - } - get isTemplate() { - return this.type.isTemplate; - } - get size() { - return this.type.size; - } - get align() { - return this.type.isStruct ? this.type.align : 0; - } - get members() { - return this.type.isStruct ? this.type.members : null; - } - get format() { - return this.type.isArray ? this.type.format : this.type.isTemplate ? this.type.format : null; - } - get count() { - return this.type.isArray ? this.type.count : 0; - } - get stride() { - return this.type.isArray ? this.type.stride : this.size; - } -}; -var AliasInfo = class { - constructor(name2, type) { - this.name = name2; - this.type = type; - } -}; -var _TypeSize = class { - constructor(align, size) { - this.align = align; - this.size = size; - } -}; -var InputInfo = class { - constructor(name2, type, locationType, location) { - this.name = name2; - this.type = type; - this.locationType = locationType; - this.location = location; - this.interpolation = null; - } -}; -var OutputInfo = class { - constructor(name2, type, locationType, location) { - this.name = name2; - this.type = type; - this.locationType = locationType; - this.location = location; - } -}; -var OverrideInfo = class { - constructor(name2, type, attributes, id) { - this.name = name2; - this.type = type; - this.attributes = attributes; - this.id = id; - } -}; -var ArgumentInfo = class { - constructor(name2, type) { - this.name = name2; - this.type = type; - } -}; -var FunctionInfo = class { - constructor(name2, stage = null) { - this.stage = null; - this.inputs = []; - this.outputs = []; - this.arguments = []; - this.returnType = null; - this.resources = []; - this.overrides = []; - this.startLine = -1; - this.endLine = -1; - this.inUse = false; - this.calls = /* @__PURE__ */ new Set(); - this.name = name2; - this.stage = stage; - } -}; -var EntryFunctions = class { - constructor() { - this.vertex = []; - this.fragment = []; - this.compute = []; - } -}; -var _FunctionResources = class { - constructor(node) { - this.resources = null; - this.inUse = false; - this.info = null; - this.node = node; - } -}; -var WgslReflect = class _WgslReflect { - constructor(code) { - this.uniforms = []; - this.storage = []; - this.textures = []; - this.samplers = []; - this.aliases = []; - this.overrides = []; - this.structs = []; - this.entry = new EntryFunctions(); - this.functions = []; - this._types = /* @__PURE__ */ new Map(); - this._functions = /* @__PURE__ */ new Map(); - if (code) { - this.update(code); - } - } - _isStorageTexture(type) { - return type.name == "texture_storage_1d" || type.name == "texture_storage_2d" || type.name == "texture_storage_2d_array" || type.name == "texture_storage_3d"; - } - update(code) { - const parser = new WgslParser(); - const ast = parser.parse(code); - for (const node of ast) { - if (node instanceof Function) { - this._functions.set(node.name, new _FunctionResources(node)); - } - } - for (const node of ast) { - if (node instanceof Struct) { - const info = this._getTypeInfo(node, null); - if (info instanceof StructInfo) { - this.structs.push(info); - } - } - } - for (const node of ast) { - if (node instanceof Alias) { - this.aliases.push(this._getAliasInfo(node)); - continue; - } - if (node instanceof Override) { - const v = node; - const id = this._getAttributeNum(v.attributes, "id", 0); - const type = v.type != null ? this._getTypeInfo(v.type, v.attributes) : null; - this.overrides.push(new OverrideInfo(v.name, type, v.attributes, id)); - continue; - } - if (this._isUniformVar(node)) { - const v = node; - const g = this._getAttributeNum(v.attributes, "group", 0); - const b = this._getAttributeNum(v.attributes, "binding", 0); - const type = this._getTypeInfo(v.type, v.attributes); - const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Uniform, v.access); - this.uniforms.push(varInfo); - continue; - } - if (this._isStorageVar(node)) { - const v = node; - const g = this._getAttributeNum(v.attributes, "group", 0); - const b = this._getAttributeNum(v.attributes, "binding", 0); - const type = this._getTypeInfo(v.type, v.attributes); - const isStorageTexture = this._isStorageTexture(type); - const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Storage, v.access); - this.storage.push(varInfo); - continue; - } - if (this._isTextureVar(node)) { - const v = node; - const g = this._getAttributeNum(v.attributes, "group", 0); - const b = this._getAttributeNum(v.attributes, "binding", 0); - const type = this._getTypeInfo(v.type, v.attributes); - const isStorageTexture = this._isStorageTexture(type); - const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, isStorageTexture ? ResourceType.StorageTexture : ResourceType.Texture, v.access); - if (isStorageTexture) { - this.storage.push(varInfo); - } else { - this.textures.push(varInfo); - } - continue; - } - if (this._isSamplerVar(node)) { - const v = node; - const g = this._getAttributeNum(v.attributes, "group", 0); - const b = this._getAttributeNum(v.attributes, "binding", 0); - const type = this._getTypeInfo(v.type, v.attributes); - const varInfo = new VariableInfo(v.name, type, g, b, v.attributes, ResourceType.Sampler, v.access); - this.samplers.push(varInfo); - continue; - } - if (node instanceof Function) { - const vertexStage = this._getAttribute(node, "vertex"); - const fragmentStage = this._getAttribute(node, "fragment"); - const computeStage = this._getAttribute(node, "compute"); - const stage = vertexStage || fragmentStage || computeStage; - const fn = new FunctionInfo(node.name, stage === null || stage === void 0 ? void 0 : stage.name); - fn.startLine = node.startLine; - fn.endLine = node.endLine; - this.functions.push(fn); - this._functions.get(node.name).info = fn; - if (stage) { - this._functions.get(node.name).inUse = true; - fn.inUse = true; - fn.resources = this._findResources(node, !!stage); - fn.inputs = this._getInputs(node.args); - fn.outputs = this._getOutputs(node.returnType); - this.entry[stage.name].push(fn); - } else { - fn.arguments = node.args.map((arg) => new ArgumentInfo(arg.name, this._getTypeInfo(arg.type, arg.attributes))); - fn.returnType = node.returnType ? this._getTypeInfo(node.returnType, node.attributes) : null; - } - continue; - } - } - for (const fn of this._functions.values()) { - if (fn.info) { - fn.info.inUse = fn.inUse; - this._addCalls(fn.node, fn.info.calls); - } - } - for (const fn of this._functions.values()) { - fn.node.search((node) => { - var _a2; - if (node.astNodeType === "varExpr") { - const v = node; - for (const override of this.overrides) { - if (v.name == override.name) { - (_a2 = fn.info) === null || _a2 === void 0 ? void 0 : _a2.overrides.push(override); - } - } - } - }); - } - for (const u of this.uniforms) { - this._markStructsInUse(u.type); - } - for (const s of this.storage) { - this._markStructsInUse(s.type); - } - } - _markStructsInUse(type) { - if (!type) { - return; - } - if (type.isStruct) { - type.inUse = true; - if (type.members) { - for (const m of type.members) { - this._markStructsInUse(m.type); - } - } - } else if (type.isArray) { - this._markStructsInUse(type.format); - } else if (type.isTemplate) { - if (type.format) { - this._markStructsInUse(type.format); - } - } else { - const alias = this._getAlias(type.name); - if (alias) { - this._markStructsInUse(alias); - } - } - } - _addCalls(fn, calls) { - var _a2; - for (const call of fn.calls) { - const info = (_a2 = this._functions.get(call.name)) === null || _a2 === void 0 ? void 0 : _a2.info; - if (info) { - calls.add(info); - } - } - } - /// Find a resource by its group and binding. - findResource(group, binding) { - for (const u of this.uniforms) { - if (u.group == group && u.binding == binding) { - return u; - } - } - for (const s of this.storage) { - if (s.group == group && s.binding == binding) { - return s; - } - } - for (const t of this.textures) { - if (t.group == group && t.binding == binding) { - return t; - } - } - for (const s of this.samplers) { - if (s.group == group && s.binding == binding) { - return s; - } - } - return null; - } - _findResource(name2) { - for (const u of this.uniforms) { - if (u.name == name2) { - return u; - } - } - for (const s of this.storage) { - if (s.name == name2) { - return s; - } - } - for (const t of this.textures) { - if (t.name == name2) { - return t; - } - } - for (const s of this.samplers) { - if (s.name == name2) { - return s; - } - } - return null; - } - _markStructsFromAST(type) { - const info = this._getTypeInfo(type, null); - this._markStructsInUse(info); - } - _findResources(fn, isEntry) { - const resources = []; - const self2 = this; - const varStack = []; - fn.search((node) => { - if (node instanceof _BlockStart) { - varStack.push({}); - } else if (node instanceof _BlockEnd) { - varStack.pop(); - } else if (node instanceof Var) { - const v = node; - if (isEntry && v.type !== null) { - this._markStructsFromAST(v.type); - } - if (varStack.length > 0) { - varStack[varStack.length - 1][v.name] = v; - } - } else if (node instanceof CreateExpr) { - const c = node; - if (isEntry && c.type !== null) { - this._markStructsFromAST(c.type); - } - } else if (node instanceof Let) { - const v = node; - if (isEntry && v.type !== null) { - this._markStructsFromAST(v.type); - } - if (varStack.length > 0) { - varStack[varStack.length - 1][v.name] = v; - } - } else if (node instanceof VariableExpr) { - const v = node; - if (varStack.length > 0) { - const varInfo2 = varStack[varStack.length - 1][v.name]; - if (varInfo2) { - return; - } - } - const varInfo = self2._findResource(v.name); - if (varInfo) { - resources.push(varInfo); - } - } else if (node instanceof CallExpr) { - const c = node; - const callFn = self2._functions.get(c.name); - if (callFn) { - if (isEntry) { - callFn.inUse = true; - } - fn.calls.add(callFn.node); - if (callFn.resources === null) { - callFn.resources = self2._findResources(callFn.node, isEntry); - } - resources.push(...callFn.resources); - } - } else if (node instanceof Call) { - const c = node; - const callFn = self2._functions.get(c.name); - if (callFn) { - if (isEntry) { - callFn.inUse = true; - } - fn.calls.add(callFn.node); - if (callFn.resources === null) { - callFn.resources = self2._findResources(callFn.node, isEntry); - } - resources.push(...callFn.resources); - } - } - }); - return [...new Map(resources.map((r) => [r.name, r])).values()]; - } - getBindGroups() { - const groups = []; - function _makeRoom(group, binding) { - if (group >= groups.length) { - groups.length = group + 1; - } - if (groups[group] === void 0) { - groups[group] = []; - } - if (binding >= groups[group].length) { - groups[group].length = binding + 1; - } - } - for (const u of this.uniforms) { - _makeRoom(u.group, u.binding); - const group = groups[u.group]; - group[u.binding] = u; - } - for (const u of this.storage) { - _makeRoom(u.group, u.binding); - const group = groups[u.group]; - group[u.binding] = u; - } - for (const t of this.textures) { - _makeRoom(t.group, t.binding); - const group = groups[t.group]; - group[t.binding] = t; - } - for (const t of this.samplers) { - _makeRoom(t.group, t.binding); - const group = groups[t.group]; - group[t.binding] = t; - } - return groups; - } - _getOutputs(type, outputs = void 0) { - if (outputs === void 0) { - outputs = []; - } - if (type instanceof Struct) { - this._getStructOutputs(type, outputs); - } else { - const output = this._getOutputInfo(type); - if (output !== null) { - outputs.push(output); - } - } - return outputs; - } - _getStructOutputs(struct, outputs) { - for (const m of struct.members) { - if (m.type instanceof Struct) { - this._getStructOutputs(m.type, outputs); - } else { - const location = this._getAttribute(m, "location") || this._getAttribute(m, "builtin"); - if (location !== null) { - const typeInfo = this._getTypeInfo(m.type, m.type.attributes); - const locationValue = this._parseInt(location.value); - const info = new OutputInfo(m.name, typeInfo, location.name, locationValue); - outputs.push(info); - } - } - } - } - _getOutputInfo(type) { - const location = this._getAttribute(type, "location") || this._getAttribute(type, "builtin"); - if (location !== null) { - const typeInfo = this._getTypeInfo(type, type.attributes); - const locationValue = this._parseInt(location.value); - const info = new OutputInfo("", typeInfo, location.name, locationValue); - return info; - } - return null; - } - _getInputs(args, inputs = void 0) { - if (inputs === void 0) { - inputs = []; - } - for (const arg of args) { - if (arg.type instanceof Struct) { - this._getStructInputs(arg.type, inputs); - } else { - const input = this._getInputInfo(arg); - if (input !== null) { - inputs.push(input); - } - } - } - return inputs; - } - _getStructInputs(struct, inputs) { - for (const m of struct.members) { - if (m.type instanceof Struct) { - this._getStructInputs(m.type, inputs); - } else { - const input = this._getInputInfo(m); - if (input !== null) { - inputs.push(input); - } - } - } - } - _getInputInfo(node) { - const location = this._getAttribute(node, "location") || this._getAttribute(node, "builtin"); - if (location !== null) { - const interpolation = this._getAttribute(node, "interpolation"); - const type = this._getTypeInfo(node.type, node.attributes); - const locationValue = this._parseInt(location.value); - const info = new InputInfo(node.name, type, location.name, locationValue); - if (interpolation !== null) { - info.interpolation = this._parseString(interpolation.value); - } - return info; - } - return null; - } - _parseString(s) { - if (s instanceof Array) { - s = s[0]; - } - return s; - } - _parseInt(s) { - if (s instanceof Array) { - s = s[0]; - } - const n = parseInt(s); - return isNaN(n) ? s : n; - } - _getAlias(name2) { - for (const a of this.aliases) { - if (a.name == name2) { - return a.type; - } - } - return null; - } - _getAliasInfo(node) { - return new AliasInfo(node.name, this._getTypeInfo(node.type, null)); - } - _getTypeInfo(type, attributes) { - if (this._types.has(type)) { - return this._types.get(type); - } - if (type instanceof ArrayType) { - const a = type; - const t = a.format ? this._getTypeInfo(a.format, a.attributes) : null; - const info2 = new ArrayInfo(a.name, attributes); - info2.format = t; - info2.count = a.count; - this._types.set(type, info2); - this._updateTypeInfo(info2); - return info2; - } - if (type instanceof Struct) { - const s = type; - const info2 = new StructInfo(s.name, attributes); - info2.startLine = s.startLine; - info2.endLine = s.endLine; - for (const m of s.members) { - const t = this._getTypeInfo(m.type, m.attributes); - info2.members.push(new MemberInfo(m.name, t, m.attributes)); - } - this._types.set(type, info2); - this._updateTypeInfo(info2); - return info2; - } - if (type instanceof SamplerType) { - const s = type; - const formatIsType = s.format instanceof Type; - const format = s.format ? formatIsType ? this._getTypeInfo(s.format, null) : new TypeInfo(s.format, null) : null; - const info2 = new TemplateInfo(s.name, format, attributes, s.access); - this._types.set(type, info2); - this._updateTypeInfo(info2); - return info2; - } - if (type instanceof TemplateType) { - const t = type; - const format = t.format ? this._getTypeInfo(t.format, null) : null; - const info2 = new TemplateInfo(t.name, format, attributes, t.access); - this._types.set(type, info2); - this._updateTypeInfo(info2); - return info2; - } - const info = new TypeInfo(type.name, attributes); - this._types.set(type, info); - this._updateTypeInfo(info); - return info; - } - _updateTypeInfo(type) { - var _a2, _b; - const typeSize = this._getTypeSize(type); - type.size = (_a2 = typeSize === null || typeSize === void 0 ? void 0 : typeSize.size) !== null && _a2 !== void 0 ? _a2 : 0; - if (type instanceof ArrayInfo) { - if (type["format"]) { - const formatInfo = this._getTypeSize(type["format"]); - type.stride = (_b = formatInfo === null || formatInfo === void 0 ? void 0 : formatInfo.size) !== null && _b !== void 0 ? _b : 0; - this._updateTypeInfo(type["format"]); - } - } - if (type instanceof StructInfo) { - this._updateStructInfo(type); - } - } - _updateStructInfo(struct) { - var _a2; - let offset = 0; - let lastSize = 0; - let lastOffset = 0; - let structAlign = 0; - for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) { - const member = struct.members[mi]; - const sizeInfo = this._getTypeSize(member); - if (!sizeInfo) { - continue; - } - (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type; - const align = sizeInfo.align; - const size = sizeInfo.size; - offset = this._roundUp(align, offset + lastSize); - lastSize = size; - lastOffset = offset; - structAlign = Math.max(structAlign, align); - member.offset = offset; - member.size = size; - this._updateTypeInfo(member.type); - } - struct.size = this._roundUp(structAlign, lastOffset + lastSize); - struct.align = structAlign; - } - _getTypeSize(type) { - var _a2, _b; - if (type === null || type === void 0) { - return null; - } - const explicitSize = this._getAttributeNum(type.attributes, "size", 0); - const explicitAlign = this._getAttributeNum(type.attributes, "align", 0); - if (type instanceof MemberInfo) { - type = type.type; - } - if (type instanceof TypeInfo) { - const alias = this._getAlias(type.name); - if (alias !== null) { - type = alias; - } - } - { - const info = _WgslReflect._typeInfo[type.name]; - if (info !== void 0) { - const divisor = ((_a2 = type["format"]) === null || _a2 === void 0 ? void 0 : _a2.name) === "f16" ? 2 : 1; - return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor)); - } - } - { - const info = _WgslReflect._typeInfo[type.name.substring(0, type.name.length - 1)]; - if (info) { - const divisor = type.name[type.name.length - 1] === "h" ? 2 : 1; - return new _TypeSize(Math.max(explicitAlign, info.align / divisor), Math.max(explicitSize, info.size / divisor)); - } - } - if (type instanceof ArrayInfo) { - let arrayType = type; - let align = 8; - let size = 8; - const E = this._getTypeSize(arrayType.format); - if (E !== null) { - size = E.size; - align = E.align; - } - const N = arrayType.count; - const stride = this._getAttributeNum((_b = type === null || type === void 0 ? void 0 : type.attributes) !== null && _b !== void 0 ? _b : null, "stride", this._roundUp(align, size)); - size = N * stride; - if (explicitSize) { - size = explicitSize; - } - return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size)); - } - if (type instanceof StructInfo) { - let align = 0; - let size = 0; - let offset = 0; - let lastSize = 0; - let lastOffset = 0; - for (const m of type.members) { - const mi = this._getTypeSize(m.type); - if (mi !== null) { - align = Math.max(mi.align, align); - offset = this._roundUp(mi.align, offset + lastSize); - lastSize = mi.size; - lastOffset = offset; - } - } - size = this._roundUp(align, lastOffset + lastSize); - return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size)); - } - return null; - } - _isUniformVar(node) { - return node instanceof Var && node.storage == "uniform"; - } - _isStorageVar(node) { - return node instanceof Var && node.storage == "storage"; - } - _isTextureVar(node) { - return node instanceof Var && node.type !== null && _WgslReflect._textureTypes.indexOf(node.type.name) != -1; - } - _isSamplerVar(node) { - return node instanceof Var && node.type !== null && _WgslReflect._samplerTypes.indexOf(node.type.name) != -1; - } - _getAttribute(node, name2) { - const obj = node; - if (!obj || !obj["attributes"]) { - return null; - } - const attrs = obj["attributes"]; - for (let a of attrs) { - if (a.name == name2) { - return a; - } - } - return null; - } - _getAttributeNum(attributes, name2, defaultValue) { - if (attributes === null) { - return defaultValue; - } - for (let a of attributes) { - if (a.name == name2) { - let v = a !== null && a.value !== null ? a.value : defaultValue; - if (v instanceof Array) { - v = v[0]; - } - if (typeof v === "number") { - return v; - } - if (typeof v === "string") { - return parseInt(v); - } - return defaultValue; - } - } - return defaultValue; - } - _roundUp(k, n) { - return Math.ceil(n / k) * k; - } -}; -WgslReflect._typeInfo = { - f16: { align: 2, size: 2 }, - i32: { align: 4, size: 4 }, - u32: { align: 4, size: 4 }, - f32: { align: 4, size: 4 }, - atomic: { align: 4, size: 4 }, - vec2: { align: 8, size: 8 }, - vec3: { align: 16, size: 12 }, - vec4: { align: 16, size: 16 }, - mat2x2: { align: 8, size: 16 }, - mat3x2: { align: 8, size: 24 }, - mat4x2: { align: 8, size: 32 }, - mat2x3: { align: 16, size: 32 }, - mat3x3: { align: 16, size: 48 }, - mat4x3: { align: 16, size: 64 }, - mat2x4: { align: 16, size: 32 }, - mat3x4: { align: 16, size: 48 }, - mat4x4: { align: 16, size: 64 } -}; -WgslReflect._textureTypes = TokenTypes.any_texture_type.map((t) => { - return t.name; -}); -WgslReflect._samplerTypes = TokenTypes.sampler_type.map((t) => { - return t.name; -}); - -// node_modules/@luma.gl/shadertools/dist/lib/wgsl/get-shader-layout-wgsl.js -function getShaderLayoutFromWGSL(source) { - const shaderLayout = { attributes: [], bindings: [] }; - let parsedWGSL; - try { - parsedWGSL = parseWGSL(source); - } catch (error) { - log2.error(error.message)(); - return shaderLayout; - } - for (const uniform of parsedWGSL.uniforms) { - const members = []; - for (const attribute of uniform.type?.members || []) { - members.push({ - name: attribute.name, - type: getType(attribute.type) - }); - } - shaderLayout.bindings.push({ - type: "uniform", - name: uniform.name, - location: uniform.binding, - // @ts-expect-error - group: uniform.group, - members - }); - } - const vertex = parsedWGSL.entry.vertex[0]; - const attributeCount = vertex?.inputs.length || 0; - for (let i = 0; i < attributeCount; i++) { - const wgslAttribute = vertex.inputs[i]; - if (wgslAttribute.locationType === "location") { - const type = getType(wgslAttribute.type); - shaderLayout.attributes.push({ - name: wgslAttribute.name, - location: Number(wgslAttribute.location), - type - }); - } - } - return shaderLayout; -} -function getType(type) { - return type.format ? `${type.name}<${type.format.name}>` : type.name; -} -function parseWGSL(source) { - try { - return new WgslReflect(source); - } catch (error) { - if (error instanceof Error) { - throw error; - } - let message2 = "WGSL parse error"; - if (typeof error === "object" && error?.message) { - message2 += `: ${error.message} `; - } - if (typeof error === "object" && error?.token) { - message2 += error.token.line || ""; - } - throw new Error(message2, { cause: error }); - } -} - -// node_modules/@luma.gl/shadertools/dist/modules/math/fp32/fp32.js -var fp32shader = `#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND -const float TWO_PI = 6.2831854820251465; -const float PI_2 = 1.5707963705062866; -const float PI_16 = 0.1963495463132858; -const float SIN_TABLE_0 = 0.19509032368659973; -const float SIN_TABLE_1 = 0.3826834261417389; -const float SIN_TABLE_2 = 0.5555702447891235; -const float SIN_TABLE_3 = 0.7071067690849304; -const float COS_TABLE_0 = 0.9807852506637573; -const float COS_TABLE_1 = 0.9238795042037964; -const float COS_TABLE_2 = 0.8314695954322815; -const float COS_TABLE_3 = 0.7071067690849304; -const float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; -const float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; -const float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; -const float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; -float sin_taylor_fp32(float a) { -float r, s, t, x; -if (a == 0.0) { -return 0.0; -} -x = -a * a; -s = a; -r = a; -r = r * x; -t = r * INVERSE_FACTORIAL_3; -s = s + t; -r = r * x; -t = r * INVERSE_FACTORIAL_5; -s = s + t; -r = r * x; -t = r * INVERSE_FACTORIAL_7; -s = s + t; -r = r * x; -t = r * INVERSE_FACTORIAL_9; -s = s + t; -return s; -} -void sincos_taylor_fp32(float a, out float sin_t, out float cos_t) { -if (a == 0.0) { -sin_t = 0.0; -cos_t = 1.0; -} -sin_t = sin_taylor_fp32(a); -cos_t = sqrt(1.0 - sin_t * sin_t); -} -float tan_taylor_fp32(float a) { -float sin_a; -float cos_a; -if (a == 0.0) { -return 0.0; -} -float z = floor(a / TWO_PI); -float r = a - TWO_PI * z; -float t; -float q = floor(r / PI_2 + 0.5); -int j = int(q); -if (j < -2 || j > 2) { -return 1.0 / 0.0; -} -t = r - PI_2 * q; -q = floor(t / PI_16 + 0.5); -int k = int(q); -int abs_k = int(abs(float(k))); -if (abs_k > 4) { -return 1.0 / 0.0; -} else { -t = t - PI_16 * q; -} -float u = 0.0; -float v = 0.0; -float sin_t, cos_t; -float s, c; -sincos_taylor_fp32(t, sin_t, cos_t); -if (k == 0) { -s = sin_t; -c = cos_t; -} else { -if (abs(float(abs_k) - 1.0) < 0.5) { -u = COS_TABLE_0; -v = SIN_TABLE_0; -} else if (abs(float(abs_k) - 2.0) < 0.5) { -u = COS_TABLE_1; -v = SIN_TABLE_1; -} else if (abs(float(abs_k) - 3.0) < 0.5) { -u = COS_TABLE_2; -v = SIN_TABLE_2; -} else if (abs(float(abs_k) - 4.0) < 0.5) { -u = COS_TABLE_3; -v = SIN_TABLE_3; -} -if (k > 0) { -s = u * sin_t + v * cos_t; -c = u * cos_t - v * sin_t; -} else { -s = u * sin_t - v * cos_t; -c = u * cos_t + v * sin_t; -} -} -if (j == 0) { -sin_a = s; -cos_a = c; -} else if (j == 1) { -sin_a = c; -cos_a = -s; -} else if (j == -1) { -sin_a = -c; -cos_a = s; -} else { -sin_a = -s; -cos_a = -c; -} -return sin_a / cos_a; -} -#endif -float tan_fp32(float a) { -#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND -return tan_taylor_fp32(a); -#else -return tan(a); -#endif -} -`; -var fp32 = { - name: "fp32", - vs: fp32shader -}; - -// node_modules/@luma.gl/shadertools/dist/modules/engine/picking/picking.js -var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1]; -var vs = `uniform pickingUniforms { -float isActive; -float isAttribute; -float isHighlightActive; -float useFloatColors; -vec3 highlightedObjectColor; -vec4 highlightColor; -} picking; -out vec4 picking_vRGBcolor_Avalid; -vec3 picking_normalizeColor(vec3 color) { -return picking.useFloatColors > 0.5 ? color : color / 255.0; -} -vec4 picking_normalizeColor(vec4 color) { -return picking.useFloatColors > 0.5 ? color : color / 255.0; -} -bool picking_isColorZero(vec3 color) { -return dot(color, vec3(1.0)) < 0.00001; -} -bool picking_isColorValid(vec3 color) { -return dot(color, vec3(1.0)) > 0.00001; -} -bool isVertexHighlighted(vec3 vertexColor) { -vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor); -return -bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor)); -} -void picking_setPickingColor(vec3 pickingColor) { -pickingColor = picking_normalizeColor(pickingColor); -if (bool(picking.isActive)) { -picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor)); -if (!bool(picking.isAttribute)) { -picking_vRGBcolor_Avalid.rgb = pickingColor; -} -} else { -picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor)); -} -} -void picking_setPickingAttribute(float value) { -if (bool(picking.isAttribute)) { -picking_vRGBcolor_Avalid.r = value; -} -} -void picking_setPickingAttribute(vec2 value) { -if (bool(picking.isAttribute)) { -picking_vRGBcolor_Avalid.rg = value; -} -} -void picking_setPickingAttribute(vec3 value) { -if (bool(picking.isAttribute)) { -picking_vRGBcolor_Avalid.rgb = value; -} -} -`; -var fs = `uniform pickingUniforms { -float isActive; -float isAttribute; -float isHighlightActive; -float useFloatColors; -vec3 highlightedObjectColor; -vec4 highlightColor; -} picking; -in vec4 picking_vRGBcolor_Avalid; -vec4 picking_filterHighlightColor(vec4 color) { -if (picking.isActive > 0.5) { -return color; -} -bool selected = bool(picking_vRGBcolor_Avalid.a); -if (selected) { -float highLightAlpha = picking.highlightColor.a; -float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha); -float highLightRatio = highLightAlpha / blendedAlpha; -vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio); -return vec4(blendedRGB, blendedAlpha); -} else { -return color; -} -} -vec4 picking_filterPickingColor(vec4 color) { -if (bool(picking.isActive)) { -if (picking_vRGBcolor_Avalid.a == 0.0) { -discard; -} -return picking_vRGBcolor_Avalid; -} -return color; -} -vec4 picking_filterColor(vec4 color) { -vec4 highlightColor = picking_filterHighlightColor(color); -return picking_filterPickingColor(highlightColor); -} -`; -var picking = { - name: "picking", - vs, - fs, - uniformTypes: { - isActive: "f32", - isAttribute: "f32", - isHighlightActive: "f32", - useFloatColors: "f32", - highlightedObjectColor: "vec3", - highlightColor: "vec4" - }, - defaultUniforms: { - isActive: false, - isAttribute: false, - isHighlightActive: false, - useFloatColors: true, - highlightedObjectColor: [0, 0, 0], - highlightColor: DEFAULT_HIGHLIGHT_COLOR - }, - getUniforms -}; -function getUniforms(opts = {}, prevUniforms) { - const uniforms = {}; - if (opts.highlightedObjectColor === void 0) { - } else if (opts.highlightedObjectColor === null) { - uniforms.isHighlightActive = false; - } else { - uniforms.isHighlightActive = true; - const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3); - uniforms.highlightedObjectColor = highlightedObjectColor; - } - if (opts.highlightColor) { - const color = Array.from(opts.highlightColor, (x) => x / 255); - if (!Number.isFinite(color[3])) { - color[3] = 1; - } - uniforms.highlightColor = color; - } - if (opts.isActive !== void 0) { - uniforms.isActive = Boolean(opts.isActive); - uniforms.isAttribute = Boolean(opts.isAttribute); - } - if (opts.useFloatColors !== void 0) { - uniforms.useFloatColors = Boolean(opts.useFloatColors); - } - return uniforms; -} - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js -function fp64ify(a, out = [], startIndex = 0) { - const hiPart = Math.fround(a); - const loPart = a - hiPart; - out[startIndex] = hiPart; - out[startIndex + 1] = loPart; - return out; -} -function fp64LowPart(a) { - return a - Math.fround(a); -} -function fp64ifyMatrix4(matrix) { - const matrixFP64 = new Float32Array(32); - for (let i = 0; i < 4; ++i) { - for (let j = 0; j < 4; ++j) { - const index2 = i * 4 + j; - fp64ify(matrix[j * 4 + i], matrixFP64, index2 * 2); - } - } - return matrixFP64; -} - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic-glsl.js -var fp64arithmeticShader = `uniform float ONE; -vec2 split(float a) { -const float SPLIT = 4097.0; -float t = a * SPLIT; -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -float a_hi = t * ONE - (t - a); -float a_lo = a * ONE - a_hi; -#else -float a_hi = t - (t - a); -float a_lo = a - a_hi; -#endif -return vec2(a_hi, a_lo); -} -vec2 split2(vec2 a) { -vec2 b = split(a.x); -b.y += a.y; -return b; -} -vec2 quickTwoSum(float a, float b) { -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -float sum = (a + b) * ONE; -float err = b - (sum - a) * ONE; -#else -float sum = a + b; -float err = b - (sum - a); -#endif -return vec2(sum, err); -} -vec2 twoSum(float a, float b) { -float s = (a + b); -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -float v = (s * ONE - a) * ONE; -float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v); -#else -float v = s - a; -float err = (a - (s - v)) + (b - v); -#endif -return vec2(s, err); -} -vec2 twoSub(float a, float b) { -float s = (a - b); -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -float v = (s * ONE - a) * ONE; -float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v); -#else -float v = s - a; -float err = (a - (s - v)) - (b + v); -#endif -return vec2(s, err); -} -vec2 twoSqr(float a) { -float prod = a * a; -vec2 a_fp64 = split(a); -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x * -a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE; -#else -float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y; -#endif -return vec2(prod, err); -} -vec2 twoProd(float a, float b) { -float prod = a * b; -vec2 a_fp64 = split(a); -vec2 b_fp64 = split(b); -float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y + -a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y; -return vec2(prod, err); -} -vec2 sum_fp64(vec2 a, vec2 b) { -vec2 s, t; -s = twoSum(a.x, b.x); -t = twoSum(a.y, b.y); -s.y += t.x; -s = quickTwoSum(s.x, s.y); -s.y += t.y; -s = quickTwoSum(s.x, s.y); -return s; -} -vec2 sub_fp64(vec2 a, vec2 b) { -vec2 s, t; -s = twoSub(a.x, b.x); -t = twoSub(a.y, b.y); -s.y += t.x; -s = quickTwoSum(s.x, s.y); -s.y += t.y; -s = quickTwoSum(s.x, s.y); -return s; -} -vec2 mul_fp64(vec2 a, vec2 b) { -vec2 prod = twoProd(a.x, b.x); -prod.y += a.x * b.y; -#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) -prod = split2(prod); -#endif -prod = quickTwoSum(prod.x, prod.y); -prod.y += a.y * b.x; -#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) -prod = split2(prod); -#endif -prod = quickTwoSum(prod.x, prod.y); -return prod; -} -vec2 div_fp64(vec2 a, vec2 b) { -float xn = 1.0 / b.x; -#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) -vec2 yn = mul_fp64(a, vec2(xn, 0)); -#else -vec2 yn = a * xn; -#endif -float diff = (sub_fp64(a, mul_fp64(b, yn))).x; -vec2 prod = twoProd(xn, diff); -return sum_fp64(yn, prod); -} -vec2 sqrt_fp64(vec2 a) { -if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0); -if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0); -float x = 1.0 / sqrt(a.x); -float yn = a.x * x; -#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND) -vec2 yn_sqr = twoSqr(yn) * ONE; -#else -vec2 yn_sqr = twoSqr(yn); -#endif -float diff = sub_fp64(a, yn_sqr).x; -vec2 prod = twoProd(x * 0.5, diff); -#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND) -return sum_fp64(split(yn), prod); -#else -return sum_fp64(vec2(yn, 0.0), prod); -#endif -} -`; - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64.js -var CONST_UNIFORMS = { - // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND - ONE: 1 -}; -function getUniforms2() { - return CONST_UNIFORMS; -} -var fp64arithmetic = { - name: "fp64-arithmetic", - vs: fp64arithmeticShader, - getUniforms: getUniforms2, - fp64ify, - fp64LowPart, - fp64ifyMatrix4 -}; - -// node_modules/@math.gl/core/dist/lib/common.js -var RADIANS_TO_DEGREES = 1 / Math.PI * 180; -var DEGREES_TO_RADIANS = 1 / 180 * Math.PI; -var DEFAULT_CONFIG = { - EPSILON: 1e-12, - debug: false, - precision: 4, - printTypes: false, - printDegrees: false, - printRowMajor: true, - _cartographicRadians: false -}; -globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } }; -var config = globalThis.mathgl.config; -function formatValue(value, { precision = config.precision } = {}) { - value = round(value); - return `${parseFloat(value.toPrecision(precision))}`; -} -function isArray(value) { - return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); -} -function clamp(value, min7, max7) { - return map(value, (value2) => Math.max(min7, Math.min(max7, value2))); -} -function lerp(a, b, t) { - if (isArray(a)) { - return a.map((ai, i) => lerp(ai, b[i], t)); - } - return t * b + (1 - t) * a; -} -function equals(a, b, epsilon) { - const oldEpsilon = config.EPSILON; - if (epsilon) { - config.EPSILON = epsilon; - } - try { - if (a === b) { - return true; - } - if (isArray(a) && isArray(b)) { - if (a.length !== b.length) { - return false; - } - for (let i = 0; i < a.length; ++i) { - if (!equals(a[i], b[i])) { - return false; - } - } - return true; - } - if (a && a.equals) { - return a.equals(b); - } - if (b && b.equals) { - return b.equals(a); - } - if (typeof a === "number" && typeof b === "number") { - return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b)); - } - return false; - } finally { - config.EPSILON = oldEpsilon; - } -} -function round(value) { - return Math.round(value / config.EPSILON) * config.EPSILON; -} -function duplicateArray(array) { - return array.clone ? array.clone() : new Array(array.length); -} -function map(value, func, result) { - if (isArray(value)) { - const array = value; - result = result || duplicateArray(array); - for (let i = 0; i < result.length && i < array.length; ++i) { - const val = typeof value === "number" ? value : value[i]; - result[i] = func(val, i, result); - } - return result; - } - return func(value); -} - -// node_modules/@math.gl/core/dist/classes/base/math-array.js -var MathArray = class extends Array { - // Common methods - /** - * Clone the current object - * @returns a new copy of this object - */ - clone() { - return new this.constructor().copy(this); - } - fromArray(array, offset = 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = array[i + offset]; - } - return this.check(); - } - toArray(targetArray = [], offset = 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - targetArray[offset + i] = this[i]; - } - return targetArray; - } - toObject(targetObject) { - return targetObject; - } - from(arrayOrObject) { - return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : ( - // @ts-ignore - this.fromObject(arrayOrObject) - ); - } - to(arrayOrObject) { - if (arrayOrObject === this) { - return this; - } - return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); - } - toTarget(target) { - return target ? this.to(target) : this; - } - /** @deprecated */ - toFloat32Array() { - return new Float32Array(this); - } - toString() { - return this.formatString(config); - } - /** Formats string according to options */ - formatString(opts) { - let string = ""; - for (let i = 0; i < this.ELEMENTS; ++i) { - string += (i > 0 ? ", " : "") + formatValue(this[i], opts); - } - return `${opts.printTypes ? this.constructor.name : ""}[${string}]`; - } - equals(array) { - if (!array || this.length !== array.length) { - return false; - } - for (let i = 0; i < this.ELEMENTS; ++i) { - if (!equals(this[i], array[i])) { - return false; - } - } - return true; - } - exactEquals(array) { - if (!array || this.length !== array.length) { - return false; - } - for (let i = 0; i < this.ELEMENTS; ++i) { - if (this[i] !== array[i]) { - return false; - } - } - return true; - } - // Modifiers - /** Negates all values in this object */ - negate() { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = -this[i]; - } - return this.check(); - } - lerp(a, b, t) { - if (t === void 0) { - return this.lerp(this, a, b); - } - for (let i = 0; i < this.ELEMENTS; ++i) { - const ai = a[i]; - const endValue = typeof b === "number" ? b : b[i]; - this[i] = ai + t * (endValue - ai); - } - return this.check(); - } - /** Minimal */ - min(vector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(vector[i], this[i]); - } - return this.check(); - } - /** Maximal */ - max(vector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.max(vector[i], this[i]); - } - return this.check(); - } - clamp(minVector, maxVector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]); - } - return this.check(); - } - add(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] += vector[i]; - } - } - return this.check(); - } - subtract(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] -= vector[i]; - } - } - return this.check(); - } - scale(scale13) { - if (typeof scale13 === "number") { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scale13; - } - } else { - for (let i = 0; i < this.ELEMENTS && i < scale13.length; ++i) { - this[i] *= scale13[i]; - } - } - return this.check(); - } - /** - * Multiplies all elements by `scale` - * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor" - */ - multiplyByScalar(scalar) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scalar; - } - return this.check(); - } - // Debug checks - /** Throws an error if array length is incorrect or contains illegal values */ - check() { - if (config.debug && !this.validate()) { - throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`); - } - return this; - } - /** Returns false if the array length is incorrect or contains illegal values */ - validate() { - let valid = this.length === this.ELEMENTS; - for (let i = 0; i < this.ELEMENTS; ++i) { - valid = valid && Number.isFinite(this[i]); - } - return valid; - } - // three.js compatibility - /** @deprecated */ - sub(a) { - return this.subtract(a); - } - /** @deprecated */ - setScalar(a) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = a; - } - return this.check(); - } - /** @deprecated */ - addScalar(a) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] += a; - } - return this.check(); - } - /** @deprecated */ - subScalar(a) { - return this.addScalar(-a); - } - /** @deprecated */ - multiplyScalar(scalar) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scalar; - } - return this.check(); - } - /** @deprecated */ - divideScalar(a) { - return this.multiplyByScalar(1 / a); - } - /** @deprecated */ - clampScalar(min7, max7) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(Math.max(this[i], min7), max7); - } - return this.check(); - } - /** @deprecated */ - get elements() { - return this; - } -}; - -// node_modules/@math.gl/core/dist/lib/validators.js -function validateVector(v, length10) { - if (v.length !== length10) { - return false; - } - for (let i = 0; i < v.length; ++i) { - if (!Number.isFinite(v[i])) { - return false; - } - } - return true; -} -function checkNumber(value) { - if (!Number.isFinite(value)) { - throw new Error(`Invalid number ${JSON.stringify(value)}`); - } - return value; -} -function checkVector(v, length10, callerName = "") { - if (config.debug && !validateVector(v, length10)) { - throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`); - } - return v; -} - -// node_modules/@math.gl/core/dist/lib/assert.js -function assert7(condition, message2) { - if (!condition) { - throw new Error(`math.gl assertion ${message2}`); - } -} - -// node_modules/@math.gl/core/dist/classes/base/vector.js -var Vector = class extends MathArray { - // ACCESSORS - get x() { - return this[0]; - } - set x(value) { - this[0] = checkNumber(value); - } - get y() { - return this[1]; - } - set y(value) { - this[1] = checkNumber(value); - } - /** - * Returns the length of the vector from the origin to the point described by this vector - * - * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements - * Instead we provide `len` and `magnitude` - */ - len() { - return Math.sqrt(this.lengthSquared()); - } - /** - * Returns the length of the vector from the origin to the point described by this vector - */ - magnitude() { - return this.len(); - } - /** - * Returns the squared length of the vector from the origin to the point described by this vector - */ - lengthSquared() { - let length10 = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - length10 += this[i] * this[i]; - } - return length10; - } - /** - * Returns the squared length of the vector from the origin to the point described by this vector - */ - magnitudeSquared() { - return this.lengthSquared(); - } - distance(mathArray) { - return Math.sqrt(this.distanceSquared(mathArray)); - } - distanceSquared(mathArray) { - let length10 = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - const dist7 = this[i] - mathArray[i]; - length10 += dist7 * dist7; - } - return checkNumber(length10); - } - dot(mathArray) { - let product = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - product += this[i] * mathArray[i]; - } - return checkNumber(product); - } - // MODIFIERS - normalize() { - const length10 = this.magnitude(); - if (length10 !== 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] /= length10; - } - } - return this.check(); - } - multiply(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= vector[i]; - } - } - return this.check(); - } - divide(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] /= vector[i]; - } - } - return this.check(); - } - // THREE.js compatibility - lengthSq() { - return this.lengthSquared(); - } - distanceTo(vector) { - return this.distance(vector); - } - distanceToSquared(vector) { - return this.distanceSquared(vector); - } - getComponent(i) { - assert7(i >= 0 && i < this.ELEMENTS, "index is out of range"); - return checkNumber(this[i]); - } - setComponent(i, value) { - assert7(i >= 0 && i < this.ELEMENTS, "index is out of range"); - this[i] = value; - return this.check(); - } - addVectors(a, b) { - return this.copy(a).add(b); - } - subVectors(a, b) { - return this.copy(a).subtract(b); - } - multiplyVectors(a, b) { - return this.copy(a).multiply(b); - } - addScaledVector(a, b) { - return this.add(new this.constructor(a).multiplyScalar(b)); - } -}; - -// node_modules/@math.gl/core/dist/gl-matrix/vec2.js -var vec2_exports = {}; -__export(vec2_exports, { - add: () => add, - angle: () => angle, - ceil: () => ceil, - clone: () => clone, - copy: () => copy, - create: () => create, - cross: () => cross, - dist: () => dist, - distance: () => distance, - div: () => div, - divide: () => divide, - dot: () => dot, - equals: () => equals2, - exactEquals: () => exactEquals, - floor: () => floor, - forEach: () => forEach2, - fromValues: () => fromValues, - inverse: () => inverse, - len: () => len, - length: () => length, - lerp: () => lerp2, - max: () => max, - min: () => min, - mul: () => mul, - multiply: () => multiply, - negate: () => negate, - normalize: () => normalize, - random: () => random, - rotate: () => rotate, - round: () => round3, - scale: () => scale, - scaleAndAdd: () => scaleAndAdd, - set: () => set, - sqrDist: () => sqrDist, - sqrLen: () => sqrLen, - squaredDistance: () => squaredDistance, - squaredLength: () => squaredLength, - str: () => str, - sub: () => sub, - subtract: () => subtract, - transformMat2: () => transformMat2, - transformMat2d: () => transformMat2d, - transformMat3: () => transformMat3, - transformMat4: () => transformMat4, - zero: () => zero -}); - -// node_modules/@math.gl/core/dist/gl-matrix/common.js -var EPSILON = 1e-6; -var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array; -var RANDOM = Math.random; -function round2(a) { - if (a >= 0) - return Math.round(a); - return a % 0.5 === 0 ? Math.floor(a) : Math.round(a); -} -var degree = Math.PI / 180; - -// node_modules/@math.gl/core/dist/gl-matrix/vec2.js -function create() { - const out = new ARRAY_TYPE(2); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; - } - return out; -} -function clone(a) { - const out = new ARRAY_TYPE(2); - out[0] = a[0]; - out[1] = a[1]; - return out; -} -function fromValues(x, y) { - const out = new ARRAY_TYPE(2); - out[0] = x; - out[1] = y; - return out; -} -function copy(out, a) { - out[0] = a[0]; - out[1] = a[1]; - return out; -} -function set(out, x, y) { - out[0] = x; - out[1] = y; - return out; -} -function add(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - return out; -} -function subtract(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - return out; -} -function multiply(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - return out; -} -function divide(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - return out; -} -function ceil(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - return out; -} -function floor(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - return out; -} -function min(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - return out; -} -function max(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - return out; -} -function round3(out, a) { - out[0] = round2(a[0]); - out[1] = round2(a[1]); - return out; -} -function scale(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - return out; -} -function scaleAndAdd(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - return out; -} -function distance(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - return Math.sqrt(x * x + y * y); -} -function squaredDistance(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - return x * x + y * y; -} -function length(a) { - const x = a[0]; - const y = a[1]; - return Math.sqrt(x * x + y * y); -} -function squaredLength(a) { - const x = a[0]; - const y = a[1]; - return x * x + y * y; -} -function negate(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - return out; -} -function inverse(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - return out; -} -function normalize(out, a) { - const x = a[0]; - const y = a[1]; - let len8 = x * x + y * y; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = a[0] * len8; - out[1] = a[1] * len8; - return out; -} -function dot(a, b) { - return a[0] * b[0] + a[1] * b[1]; -} -function cross(out, a, b) { - const z = a[0] * b[1] - a[1] * b[0]; - out[0] = out[1] = 0; - out[2] = z; - return out; -} -function lerp2(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - return out; -} -function random(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - const r = RANDOM() * 2 * Math.PI; - out[0] = Math.cos(r) * scale13; - out[1] = Math.sin(r) * scale13; - return out; -} -function transformMat2(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y; - out[1] = m[1] * x + m[3] * y; - return out; -} -function transformMat2d(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y + m[4]; - out[1] = m[1] * x + m[3] * y + m[5]; - return out; -} -function transformMat3(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[3] * y + m[6]; - out[1] = m[1] * x + m[4] * y + m[7]; - return out; -} -function transformMat4(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[4] * y + m[12]; - out[1] = m[1] * x + m[5] * y + m[13]; - return out; -} -function rotate(out, a, b, rad) { - const p0 = a[0] - b[0]; - const p1 = a[1] - b[1]; - const sinC = Math.sin(rad); - const cosC = Math.cos(rad); - out[0] = p0 * cosC - p1 * sinC + b[0]; - out[1] = p0 * sinC + p1 * cosC + b[1]; - return out; -} -function angle(a, b) { - const x1 = a[0]; - const y1 = a[1]; - const x2 = b[0]; - const y2 = b[1]; - const mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)); - const cosine = mag && (x1 * x2 + y1 * y2) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); -} -function zero(out) { - out[0] = 0; - out[1] = 0; - return out; -} -function str(a) { - return `vec2(${a[0]}, ${a[1]})`; -} -function exactEquals(a, b) { - return a[0] === b[0] && a[1] === b[1]; -} -function equals2(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const b0 = b[0]; - const b1 = b[1]; - return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)); -} -var len = length; -var sub = subtract; -var mul = multiply; -var div = divide; -var dist = distance; -var sqrDist = squaredDistance; -var sqrLen = squaredLength; -var forEach2 = function() { - const vec = create(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 2; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - } - return a; - }; -}(); - -// node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js -function vec2_transformMat4AsVector(out, a, m) { - const x = a[0]; - const y = a[1]; - const w = m[3] * x + m[7] * y || 1; - out[0] = (m[0] * x + m[4] * y) / w; - out[1] = (m[1] * x + m[5] * y) / w; - return out; -} -function vec3_transformMat4AsVector(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = m[3] * x + m[7] * y + m[11] * z || 1; - out[0] = (m[0] * x + m[4] * y + m[8] * z) / w; - out[1] = (m[1] * x + m[5] * y + m[9] * z) / w; - out[2] = (m[2] * x + m[6] * y + m[10] * z) / w; - return out; -} -function vec3_transformMat2(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y; - out[1] = m[1] * x + m[3] * y; - out[2] = a[2]; - return out; -} - -// node_modules/@math.gl/core/dist/gl-matrix/vec3.js -var vec3_exports = {}; -__export(vec3_exports, { - add: () => add2, - angle: () => angle2, - bezier: () => bezier, - ceil: () => ceil2, - clone: () => clone2, - copy: () => copy2, - create: () => create2, - cross: () => cross2, - dist: () => dist2, - distance: () => distance2, - div: () => div2, - divide: () => divide2, - dot: () => dot2, - equals: () => equals3, - exactEquals: () => exactEquals2, - floor: () => floor2, - forEach: () => forEach3, - fromValues: () => fromValues2, - hermite: () => hermite, - inverse: () => inverse2, - len: () => len2, - length: () => length2, - lerp: () => lerp3, - max: () => max2, - min: () => min2, - mul: () => mul2, - multiply: () => multiply2, - negate: () => negate2, - normalize: () => normalize2, - random: () => random2, - rotateX: () => rotateX, - rotateY: () => rotateY, - rotateZ: () => rotateZ, - round: () => round4, - scale: () => scale2, - scaleAndAdd: () => scaleAndAdd2, - set: () => set2, - slerp: () => slerp, - sqrDist: () => sqrDist2, - sqrLen: () => sqrLen2, - squaredDistance: () => squaredDistance2, - squaredLength: () => squaredLength2, - str: () => str2, - sub: () => sub2, - subtract: () => subtract2, - transformMat3: () => transformMat32, - transformMat4: () => transformMat42, - transformQuat: () => transformQuat, - zero: () => zero2 -}); -function create2() { - const out = new ARRAY_TYPE(3); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - } - return out; -} -function clone2(a) { - const out = new ARRAY_TYPE(3); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - return out; -} -function length2(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - return Math.sqrt(x * x + y * y + z * z); -} -function fromValues2(x, y, z) { - const out = new ARRAY_TYPE(3); - out[0] = x; - out[1] = y; - out[2] = z; - return out; -} -function copy2(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - return out; -} -function set2(out, x, y, z) { - out[0] = x; - out[1] = y; - out[2] = z; - return out; -} -function add2(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - return out; -} -function subtract2(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - return out; -} -function multiply2(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - out[2] = a[2] * b[2]; - return out; -} -function divide2(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - out[2] = a[2] / b[2]; - return out; -} -function ceil2(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - out[2] = Math.ceil(a[2]); - return out; -} -function floor2(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - out[2] = Math.floor(a[2]); - return out; -} -function min2(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - out[2] = Math.min(a[2], b[2]); - return out; -} -function max2(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - out[2] = Math.max(a[2], b[2]); - return out; -} -function round4(out, a) { - out[0] = round2(a[0]); - out[1] = round2(a[1]); - out[2] = round2(a[2]); - return out; -} -function scale2(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - return out; -} -function scaleAndAdd2(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - return out; -} -function distance2(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - return Math.sqrt(x * x + y * y + z * z); -} -function squaredDistance2(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - return x * x + y * y + z * z; -} -function squaredLength2(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - return x * x + y * y + z * z; -} -function negate2(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - out[2] = -a[2]; - return out; -} -function inverse2(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - out[2] = 1 / a[2]; - return out; -} -function normalize2(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let len8 = x * x + y * y + z * z; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = a[0] * len8; - out[1] = a[1] * len8; - out[2] = a[2] * len8; - return out; -} -function dot2(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; -} -function cross2(out, a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - out[0] = ay * bz - az * by; - out[1] = az * bx - ax * bz; - out[2] = ax * by - ay * bx; - return out; -} -function lerp3(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - out[2] = az + t * (b[2] - az); - return out; -} -function slerp(out, a, b, t) { - const angle6 = Math.acos(Math.min(Math.max(dot2(a, b), -1), 1)); - const sinTotal = Math.sin(angle6); - const ratioA = Math.sin((1 - t) * angle6) / sinTotal; - const ratioB = Math.sin(t * angle6) / sinTotal; - out[0] = ratioA * a[0] + ratioB * b[0]; - out[1] = ratioA * a[1] + ratioB * b[1]; - out[2] = ratioA * a[2] + ratioB * b[2]; - return out; -} -function hermite(out, a, b, c, d, t) { - const factorTimes2 = t * t; - const factor1 = factorTimes2 * (2 * t - 3) + 1; - const factor2 = factorTimes2 * (t - 2) + t; - const factor3 = factorTimes2 * (t - 1); - const factor4 = factorTimes2 * (3 - 2 * t); - out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; - out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; - out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; - return out; -} -function bezier(out, a, b, c, d, t) { - const inverseFactor = 1 - t; - const inverseFactorTimesTwo = inverseFactor * inverseFactor; - const factorTimes2 = t * t; - const factor1 = inverseFactorTimesTwo * inverseFactor; - const factor2 = 3 * t * inverseFactorTimesTwo; - const factor3 = 3 * factorTimes2 * inverseFactor; - const factor4 = factorTimes2 * t; - out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; - out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; - out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; - return out; -} -function random2(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - const r = RANDOM() * 2 * Math.PI; - const z = RANDOM() * 2 - 1; - const zScale = Math.sqrt(1 - z * z) * scale13; - out[0] = Math.cos(r) * zScale; - out[1] = Math.sin(r) * zScale; - out[2] = z * scale13; - return out; -} -function transformMat42(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let w = m[3] * x + m[7] * y + m[11] * z + m[15]; - w = w || 1; - out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; - out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; - out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; - return out; -} -function transformMat32(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - out[0] = x * m[0] + y * m[3] + z * m[6]; - out[1] = x * m[1] + y * m[4] + z * m[7]; - out[2] = x * m[2] + y * m[5] + z * m[8]; - return out; -} -function transformQuat(out, a, q) { - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const x = a[0]; - const y = a[1]; - const z = a[2]; - let uvx = qy * z - qz * y; - let uvy = qz * x - qx * z; - let uvz = qx * y - qy * x; - let uuvx = qy * uvz - qz * uvy; - let uuvy = qz * uvx - qx * uvz; - let uuvz = qx * uvy - qy * uvx; - const w2 = qw * 2; - uvx *= w2; - uvy *= w2; - uvz *= w2; - uuvx *= 2; - uuvy *= 2; - uuvz *= 2; - out[0] = x + uvx + uuvx; - out[1] = y + uvy + uuvy; - out[2] = z + uvz + uuvz; - return out; -} -function rotateX(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0]; - r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); - r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateY(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); - r[1] = p[1]; - r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateZ(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); - r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); - r[2] = p[2]; - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function angle2(a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); - const cosine = mag && dot2(a, b) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); -} -function zero2(out) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - return out; -} -function str2(a) { - return `vec3(${a[0]}, ${a[1]}, ${a[2]})`; -} -function exactEquals2(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]; -} -function equals3(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)); -} -var sub2 = subtract2; -var mul2 = multiply2; -var div2 = divide2; -var dist2 = distance2; -var sqrDist2 = squaredDistance2; -var len2 = length2; -var sqrLen2 = squaredLength2; -var forEach3 = function() { - const vec = create2(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 3; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - } - return a; - }; -}(); - -// node_modules/@math.gl/core/dist/classes/vector3.js -var ORIGIN = [0, 0, 0]; -var ZERO; -var Vector3 = class _Vector3 extends Vector { - static get ZERO() { - if (!ZERO) { - ZERO = new _Vector3(0, 0, 0); - Object.freeze(ZERO); - } - return ZERO; - } - /** - * @class - * @param x - * @param y - * @param z - */ - constructor(x = 0, y = 0, z = 0) { - super(-0, -0, -0); - if (arguments.length === 1 && isArray(x)) { - this.copy(x); - } else { - if (config.debug) { - checkNumber(x); - checkNumber(y); - checkNumber(z); - } - this[0] = x; - this[1] = y; - this[2] = z; - } - } - set(x, y, z) { - this[0] = x; - this[1] = y; - this[2] = z; - return this.check(); - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - return this.check(); - } - fromObject(object) { - if (config.debug) { - checkNumber(object.x); - checkNumber(object.y); - checkNumber(object.z); - } - this[0] = object.x; - this[1] = object.y; - this[2] = object.z; - return this.check(); - } - toObject(object) { - object.x = this[0]; - object.y = this[1]; - object.z = this[2]; - return object; - } - // Getters/setters - get ELEMENTS() { - return 3; - } - get z() { - return this[2]; - } - set z(value) { - this[2] = checkNumber(value); - } - // ACCESSORS - angle(vector) { - return angle2(this, vector); - } - // MODIFIERS - cross(vector) { - cross2(this, this, vector); - return this.check(); - } - rotateX({ radians: radians3, origin = ORIGIN }) { - rotateX(this, this, origin, radians3); - return this.check(); - } - rotateY({ radians: radians3, origin = ORIGIN }) { - rotateY(this, this, origin, radians3); - return this.check(); - } - rotateZ({ radians: radians3, origin = ORIGIN }) { - rotateZ(this, this, origin, radians3); - return this.check(); - } - // Transforms - // transforms as point (4th component is implicitly 1) - transform(matrix4) { - return this.transformAsPoint(matrix4); - } - // transforms as point (4th component is implicitly 1) - transformAsPoint(matrix4) { - transformMat42(this, this, matrix4); - return this.check(); - } - // transforms as vector (4th component is implicitly 0, ignores translation. slightly faster) - transformAsVector(matrix4) { - vec3_transformMat4AsVector(this, this, matrix4); - return this.check(); - } - transformByMatrix3(matrix3) { - transformMat32(this, this, matrix3); - return this.check(); - } - transformByMatrix2(matrix2) { - vec3_transformMat2(this, this, matrix2); - return this.check(); - } - transformByQuaternion(quaternion) { - transformQuat(this, this, quaternion); - return this.check(); - } -}; - -// node_modules/@math.gl/core/dist/classes/base/matrix.js -var Matrix = class extends MathArray { - // fromObject(object) { - // const array = object.elements; - // return this.fromRowMajor(array); - // } - // toObject(object) { - // const array = object.elements; - // this.toRowMajor(array); - // return object; - // } - // TODO better override formatString? - toString() { - let string = "["; - if (config.printRowMajor) { - string += "row-major:"; - for (let row = 0; row < this.RANK; ++row) { - for (let col = 0; col < this.RANK; ++col) { - string += ` ${this[col * this.RANK + row]}`; - } - } - } else { - string += "column-major:"; - for (let i = 0; i < this.ELEMENTS; ++i) { - string += ` ${this[i]}`; - } - } - string += "]"; - return string; - } - getElementIndex(row, col) { - return col * this.RANK + row; - } - // By default assumes row major indices - getElement(row, col) { - return this[col * this.RANK + row]; - } - // By default assumes row major indices - setElement(row, col, value) { - this[col * this.RANK + row] = checkNumber(value); - return this; - } - getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { - const firstIndex = columnIndex * this.RANK; - for (let i = 0; i < this.RANK; ++i) { - result[i] = this[firstIndex + i]; - } - return result; - } - setColumn(columnIndex, columnVector) { - const firstIndex = columnIndex * this.RANK; - for (let i = 0; i < this.RANK; ++i) { - this[firstIndex + i] = columnVector[i]; - } - return this; - } -}; - -// node_modules/@math.gl/core/dist/gl-matrix/mat4.js -var mat4_exports = {}; -__export(mat4_exports, { - add: () => add3, - adjoint: () => adjoint, - clone: () => clone3, - copy: () => copy3, - create: () => create3, - decompose: () => decompose, - determinant: () => determinant, - equals: () => equals4, - exactEquals: () => exactEquals3, - frob: () => frob, - fromQuat: () => fromQuat, - fromQuat2: () => fromQuat2, - fromRotation: () => fromRotation, - fromRotationTranslation: () => fromRotationTranslation, - fromRotationTranslationScale: () => fromRotationTranslationScale, - fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin, - fromScaling: () => fromScaling, - fromTranslation: () => fromTranslation, - fromValues: () => fromValues3, - fromXRotation: () => fromXRotation, - fromYRotation: () => fromYRotation, - fromZRotation: () => fromZRotation, - frustum: () => frustum, - getRotation: () => getRotation, - getScaling: () => getScaling, - getTranslation: () => getTranslation, - identity: () => identity, - invert: () => invert, - lookAt: () => lookAt, - mul: () => mul3, - multiply: () => multiply3, - multiplyScalar: () => multiplyScalar, - multiplyScalarAndAdd: () => multiplyScalarAndAdd, - ortho: () => ortho, - orthoNO: () => orthoNO, - orthoZO: () => orthoZO, - perspective: () => perspective, - perspectiveFromFieldOfView: () => perspectiveFromFieldOfView, - perspectiveNO: () => perspectiveNO, - perspectiveZO: () => perspectiveZO, - rotate: () => rotate2, - rotateX: () => rotateX2, - rotateY: () => rotateY2, - rotateZ: () => rotateZ2, - scale: () => scale3, - set: () => set3, - str: () => str3, - sub: () => sub3, - subtract: () => subtract3, - targetTo: () => targetTo, - translate: () => translate, - transpose: () => transpose -}); -function create3() { - const out = new ARRAY_TYPE(16); - if (ARRAY_TYPE != Float32Array) { - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - } - out[0] = 1; - out[5] = 1; - out[10] = 1; - out[15] = 1; - return out; -} -function clone3(a) { - const out = new ARRAY_TYPE(16); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function copy3(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function fromValues3(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - const out = new ARRAY_TYPE(16); - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function set3(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function identity(out) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function transpose(out, a) { - if (out === a) { - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a12 = a[6]; - const a13 = a[7]; - const a23 = a[11]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a01; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a02; - out[9] = a12; - out[11] = a[14]; - out[12] = a03; - out[13] = a13; - out[14] = a23; - } else { - out[0] = a[0]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a[1]; - out[5] = a[5]; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a[2]; - out[9] = a[6]; - out[10] = a[10]; - out[11] = a[14]; - out[12] = a[3]; - out[13] = a[7]; - out[14] = a[11]; - out[15] = a[15]; - } - return out; -} -function invert(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; - if (!det) { - return null; - } - det = 1 / det; - out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; - out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; - out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; - out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; - out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; - out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; - out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; - out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; - out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; - out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; - out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; - out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; - out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; - out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; - out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; - out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; - return out; -} -function adjoint(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - out[0] = a11 * b11 - a12 * b10 + a13 * b09; - out[1] = a02 * b10 - a01 * b11 - a03 * b09; - out[2] = a31 * b05 - a32 * b04 + a33 * b03; - out[3] = a22 * b04 - a21 * b05 - a23 * b03; - out[4] = a12 * b08 - a10 * b11 - a13 * b07; - out[5] = a00 * b11 - a02 * b08 + a03 * b07; - out[6] = a32 * b02 - a30 * b05 - a33 * b01; - out[7] = a20 * b05 - a22 * b02 + a23 * b01; - out[8] = a10 * b10 - a11 * b08 + a13 * b06; - out[9] = a01 * b08 - a00 * b10 - a03 * b06; - out[10] = a30 * b04 - a31 * b02 + a33 * b00; - out[11] = a21 * b02 - a20 * b04 - a23 * b00; - out[12] = a11 * b07 - a10 * b09 - a12 * b06; - out[13] = a00 * b09 - a01 * b07 + a02 * b06; - out[14] = a31 * b01 - a30 * b03 - a32 * b00; - out[15] = a20 * b03 - a21 * b01 + a22 * b00; - return out; -} -function determinant(a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b0 = a00 * a11 - a01 * a10; - const b1 = a00 * a12 - a02 * a10; - const b2 = a01 * a12 - a02 * a11; - const b3 = a20 * a31 - a21 * a30; - const b4 = a20 * a32 - a22 * a30; - const b5 = a21 * a32 - a22 * a31; - const b6 = a00 * b5 - a01 * b4 + a02 * b3; - const b7 = a10 * b5 - a11 * b4 + a12 * b3; - const b8 = a20 * b2 - a21 * b1 + a22 * b0; - const b9 = a30 * b2 - a31 * b1 + a32 * b0; - return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; -} -function multiply3(out, a, b) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - let b0 = b[0]; - let b1 = b[1]; - let b2 = b[2]; - let b3 = b[3]; - out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[4]; - b1 = b[5]; - b2 = b[6]; - b3 = b[7]; - out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[8]; - b1 = b[9]; - b2 = b[10]; - b3 = b[11]; - out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[12]; - b1 = b[13]; - b2 = b[14]; - b3 = b[15]; - out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - return out; -} -function translate(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - if (a === out) { - out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; - out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; - out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; - out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; - } else { - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - out[0] = a00; - out[1] = a01; - out[2] = a02; - out[3] = a03; - out[4] = a10; - out[5] = a11; - out[6] = a12; - out[7] = a13; - out[8] = a20; - out[9] = a21; - out[10] = a22; - out[11] = a23; - out[12] = a00 * x + a10 * y + a20 * z + a[12]; - out[13] = a01 * x + a11 * y + a21 * z + a[13]; - out[14] = a02 * x + a12 * y + a22 * z + a[14]; - out[15] = a03 * x + a13 * y + a23 * z + a[15]; - } - return out; -} -function scale3(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - out[0] = a[0] * x; - out[1] = a[1] * x; - out[2] = a[2] * x; - out[3] = a[3] * x; - out[4] = a[4] * y; - out[5] = a[5] * y; - out[6] = a[6] * y; - out[7] = a[7] * y; - out[8] = a[8] * z; - out[9] = a[9] * z; - out[10] = a[10] * z; - out[11] = a[11] * z; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function rotate2(out, a, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - let b00; - let b01; - let b02; - let b10; - let b11; - let b12; - let b20; - let b21; - let b22; - if (len8 < EPSILON) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - b00 = x * x * t + c; - b01 = y * x * t + z * s; - b02 = z * x * t - y * s; - b10 = x * y * t - z * s; - b11 = y * y * t + c; - b12 = z * y * t + x * s; - b20 = x * z * t + y * s; - b21 = y * z * t - x * s; - b22 = z * z * t + c; - out[0] = a00 * b00 + a10 * b01 + a20 * b02; - out[1] = a01 * b00 + a11 * b01 + a21 * b02; - out[2] = a02 * b00 + a12 * b01 + a22 * b02; - out[3] = a03 * b00 + a13 * b01 + a23 * b02; - out[4] = a00 * b10 + a10 * b11 + a20 * b12; - out[5] = a01 * b10 + a11 * b11 + a21 * b12; - out[6] = a02 * b10 + a12 * b11 + a22 * b12; - out[7] = a03 * b10 + a13 * b11 + a23 * b12; - out[8] = a00 * b20 + a10 * b21 + a20 * b22; - out[9] = a01 * b20 + a11 * b21 + a21 * b22; - out[10] = a02 * b20 + a12 * b21 + a22 * b22; - out[11] = a03 * b20 + a13 * b21 + a23 * b22; - if (a !== out) { - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - return out; -} -function rotateX2(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[4] = a10 * c + a20 * s; - out[5] = a11 * c + a21 * s; - out[6] = a12 * c + a22 * s; - out[7] = a13 * c + a23 * s; - out[8] = a20 * c - a10 * s; - out[9] = a21 * c - a11 * s; - out[10] = a22 * c - a12 * s; - out[11] = a23 * c - a13 * s; - return out; -} -function rotateY2(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c - a20 * s; - out[1] = a01 * c - a21 * s; - out[2] = a02 * c - a22 * s; - out[3] = a03 * c - a23 * s; - out[8] = a00 * s + a20 * c; - out[9] = a01 * s + a21 * c; - out[10] = a02 * s + a22 * c; - out[11] = a03 * s + a23 * c; - return out; -} -function rotateZ2(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - if (a !== out) { - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c + a10 * s; - out[1] = a01 * c + a11 * s; - out[2] = a02 * c + a12 * s; - out[3] = a03 * c + a13 * s; - out[4] = a10 * c - a00 * s; - out[5] = a11 * c - a01 * s; - out[6] = a12 * c - a02 * s; - out[7] = a13 * c - a03 * s; - return out; -} -function fromTranslation(out, v) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromScaling(out, v) { - out[0] = v[0]; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = v[1]; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = v[2]; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotation(out, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - if (len8 < EPSILON) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - out[0] = x * x * t + c; - out[1] = y * x * t + z * s; - out[2] = z * x * t - y * s; - out[3] = 0; - out[4] = x * y * t - z * s; - out[5] = y * y * t + c; - out[6] = z * y * t + x * s; - out[7] = 0; - out[8] = x * z * t + y * s; - out[9] = y * z * t - x * s; - out[10] = z * z * t + c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromXRotation(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = c; - out[6] = s; - out[7] = 0; - out[8] = 0; - out[9] = -s; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromYRotation(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = 0; - out[2] = -s; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = s; - out[9] = 0; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromZRotation(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = s; - out[2] = 0; - out[3] = 0; - out[4] = -s; - out[5] = c; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotationTranslation(out, q, v) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - (yy + zz); - out[1] = xy + wz; - out[2] = xz - wy; - out[3] = 0; - out[4] = xy - wz; - out[5] = 1 - (xx + zz); - out[6] = yz + wx; - out[7] = 0; - out[8] = xz + wy; - out[9] = yz - wx; - out[10] = 1 - (xx + yy); - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromQuat2(out, a) { - const translation = new ARRAY_TYPE(3); - const bx = -a[0]; - const by = -a[1]; - const bz = -a[2]; - const bw = a[3]; - const ax = a[4]; - const ay = a[5]; - const az = a[6]; - const aw = a[7]; - const magnitude = bx * bx + by * by + bz * bz + bw * bw; - if (magnitude > 0) { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; - } else { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; - } - fromRotationTranslation(out, a, translation); - return out; -} -function getTranslation(out, mat) { - out[0] = mat[12]; - out[1] = mat[13]; - out[2] = mat[14]; - return out; -} -function getScaling(out, mat) { - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - return out; -} -function getRotation(out, mat) { - const scaling = new ARRAY_TYPE(3); - getScaling(scaling, mat); - const is1 = 1 / scaling[0]; - const is2 = 1 / scaling[1]; - const is3 = 1 / scaling[2]; - const sm11 = mat[0] * is1; - const sm12 = mat[1] * is2; - const sm13 = mat[2] * is3; - const sm21 = mat[4] * is1; - const sm22 = mat[5] * is2; - const sm23 = mat[6] * is3; - const sm31 = mat[8] * is1; - const sm32 = mat[9] * is2; - const sm33 = mat[10] * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out[3] = 0.25 * S; - out[0] = (sm23 - sm32) / S; - out[1] = (sm31 - sm13) / S; - out[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out[3] = (sm23 - sm32) / S; - out[0] = 0.25 * S; - out[1] = (sm12 + sm21) / S; - out[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out[3] = (sm31 - sm13) / S; - out[0] = (sm12 + sm21) / S; - out[1] = 0.25 * S; - out[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out[3] = (sm12 - sm21) / S; - out[0] = (sm31 + sm13) / S; - out[1] = (sm23 + sm32) / S; - out[2] = 0.25 * S; - } - return out; -} -function decompose(out_r, out_t, out_s, mat) { - out_t[0] = mat[12]; - out_t[1] = mat[13]; - out_t[2] = mat[14]; - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - const is1 = 1 / out_s[0]; - const is2 = 1 / out_s[1]; - const is3 = 1 / out_s[2]; - const sm11 = m11 * is1; - const sm12 = m12 * is2; - const sm13 = m13 * is3; - const sm21 = m21 * is1; - const sm22 = m22 * is2; - const sm23 = m23 * is3; - const sm31 = m31 * is1; - const sm32 = m32 * is2; - const sm33 = m33 * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out_r[3] = 0.25 * S; - out_r[0] = (sm23 - sm32) / S; - out_r[1] = (sm31 - sm13) / S; - out_r[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out_r[3] = (sm23 - sm32) / S; - out_r[0] = 0.25 * S; - out_r[1] = (sm12 + sm21) / S; - out_r[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out_r[3] = (sm31 - sm13) / S; - out_r[0] = (sm12 + sm21) / S; - out_r[1] = 0.25 * S; - out_r[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out_r[3] = (sm12 - sm21) / S; - out_r[0] = (sm31 + sm13) / S; - out_r[1] = (sm23 + sm32) / S; - out_r[2] = 0.25 * S; - } - return out_r; -} -function fromRotationTranslationScale(out, q, v, s) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - out[0] = (1 - (yy + zz)) * sx; - out[1] = (xy + wz) * sx; - out[2] = (xz - wy) * sx; - out[3] = 0; - out[4] = (xy - wz) * sy; - out[5] = (1 - (xx + zz)) * sy; - out[6] = (yz + wx) * sy; - out[7] = 0; - out[8] = (xz + wy) * sz; - out[9] = (yz - wx) * sz; - out[10] = (1 - (xx + yy)) * sz; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromRotationTranslationScaleOrigin(out, q, v, s, o) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - const ox = o[0]; - const oy = o[1]; - const oz = o[2]; - const out0 = (1 - (yy + zz)) * sx; - const out1 = (xy + wz) * sx; - const out2 = (xz - wy) * sx; - const out4 = (xy - wz) * sy; - const out5 = (1 - (xx + zz)) * sy; - const out6 = (yz + wx) * sy; - const out8 = (xz + wy) * sz; - const out9 = (yz - wx) * sz; - const out10 = (1 - (xx + yy)) * sz; - out[0] = out0; - out[1] = out1; - out[2] = out2; - out[3] = 0; - out[4] = out4; - out[5] = out5; - out[6] = out6; - out[7] = 0; - out[8] = out8; - out[9] = out9; - out[10] = out10; - out[11] = 0; - out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); - out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); - out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); - out[15] = 1; - return out; -} -function fromQuat(out, q) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const yx = y * x2; - const yy = y * y2; - const zx = z * x2; - const zy = z * y2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - yy - zz; - out[1] = yx + wz; - out[2] = zx - wy; - out[3] = 0; - out[4] = yx - wz; - out[5] = 1 - xx - zz; - out[6] = zy + wx; - out[7] = 0; - out[8] = zx + wy; - out[9] = zy - wx; - out[10] = 1 - xx - yy; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function frustum(out, left, right, bottom, top, near, far) { - const rl = 1 / (right - left); - const tb = 1 / (top - bottom); - const nf = 1 / (near - far); - out[0] = near * 2 * rl; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = near * 2 * tb; - out[6] = 0; - out[7] = 0; - out[8] = (right + left) * rl; - out[9] = (top + bottom) * tb; - out[10] = (far + near) * nf; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near * 2 * nf; - out[15] = 0; - return out; -} -function perspectiveNO(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = (far + near) * nf; - out[14] = 2 * far * near * nf; - } else { - out[10] = -1; - out[14] = -2 * near; - } - return out; -} -var perspective = perspectiveNO; -function perspectiveZO(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = far * nf; - out[14] = far * near * nf; - } else { - out[10] = -1; - out[14] = -near; - } - return out; -} -function perspectiveFromFieldOfView(out, fov, near, far) { - const upTan = Math.tan(fov.upDegrees * Math.PI / 180); - const downTan = Math.tan(fov.downDegrees * Math.PI / 180); - const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); - const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); - const xScale = 2 / (leftTan + rightTan); - const yScale = 2 / (upTan + downTan); - out[0] = xScale; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = yScale; - out[6] = 0; - out[7] = 0; - out[8] = -((leftTan - rightTan) * xScale * 0.5); - out[9] = (upTan - downTan) * yScale * 0.5; - out[10] = far / (near - far); - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near / (near - far); - out[15] = 0; - return out; -} -function orthoNO(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 2 * nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = (far + near) * nf; - out[15] = 1; - return out; -} -var ortho = orthoNO; -function orthoZO(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = near * nf; - out[15] = 1; - return out; -} -function lookAt(out, eye, center, up) { - let len8; - let x0; - let x1; - let x2; - let y0; - let y1; - let y2; - let z0; - let z1; - let z2; - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - const centerx = center[0]; - const centery = center[1]; - const centerz = center[2]; - if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) { - return identity(out); - } - z0 = eyex - centerx; - z1 = eyey - centery; - z2 = eyez - centerz; - len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); - z0 *= len8; - z1 *= len8; - z2 *= len8; - x0 = upy * z2 - upz * z1; - x1 = upz * z0 - upx * z2; - x2 = upx * z1 - upy * z0; - len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); - if (!len8) { - x0 = 0; - x1 = 0; - x2 = 0; - } else { - len8 = 1 / len8; - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - y0 = z1 * x2 - z2 * x1; - y1 = z2 * x0 - z0 * x2; - y2 = z0 * x1 - z1 * x0; - len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); - if (!len8) { - y0 = 0; - y1 = 0; - y2 = 0; - } else { - len8 = 1 / len8; - y0 *= len8; - y1 *= len8; - y2 *= len8; - } - out[0] = x0; - out[1] = y0; - out[2] = z0; - out[3] = 0; - out[4] = x1; - out[5] = y1; - out[6] = z1; - out[7] = 0; - out[8] = x2; - out[9] = y2; - out[10] = z2; - out[11] = 0; - out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); - out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); - out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); - out[15] = 1; - return out; -} -function targetTo(out, eye, target, up) { - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - let z0 = eyex - target[0]; - let z1 = eyey - target[1]; - let z2 = eyez - target[2]; - let len8 = z0 * z0 + z1 * z1 + z2 * z2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - z0 *= len8; - z1 *= len8; - z2 *= len8; - } - let x0 = upy * z2 - upz * z1; - let x1 = upz * z0 - upx * z2; - let x2 = upx * z1 - upy * z0; - len8 = x0 * x0 + x1 * x1 + x2 * x2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - out[0] = x0; - out[1] = x1; - out[2] = x2; - out[3] = 0; - out[4] = z1 * x2 - z2 * x1; - out[5] = z2 * x0 - z0 * x2; - out[6] = z0 * x1 - z1 * x0; - out[7] = 0; - out[8] = z0; - out[9] = z1; - out[10] = z2; - out[11] = 0; - out[12] = eyex; - out[13] = eyey; - out[14] = eyez; - out[15] = 1; - return out; -} -function str3(a) { - return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; -} -function frob(a) { - return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); -} -function add3(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - out[4] = a[4] + b[4]; - out[5] = a[5] + b[5]; - out[6] = a[6] + b[6]; - out[7] = a[7] + b[7]; - out[8] = a[8] + b[8]; - out[9] = a[9] + b[9]; - out[10] = a[10] + b[10]; - out[11] = a[11] + b[11]; - out[12] = a[12] + b[12]; - out[13] = a[13] + b[13]; - out[14] = a[14] + b[14]; - out[15] = a[15] + b[15]; - return out; -} -function subtract3(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - out[3] = a[3] - b[3]; - out[4] = a[4] - b[4]; - out[5] = a[5] - b[5]; - out[6] = a[6] - b[6]; - out[7] = a[7] - b[7]; - out[8] = a[8] - b[8]; - out[9] = a[9] - b[9]; - out[10] = a[10] - b[10]; - out[11] = a[11] - b[11]; - out[12] = a[12] - b[12]; - out[13] = a[13] - b[13]; - out[14] = a[14] - b[14]; - out[15] = a[15] - b[15]; - return out; -} -function multiplyScalar(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - out[4] = a[4] * b; - out[5] = a[5] * b; - out[6] = a[6] * b; - out[7] = a[7] * b; - out[8] = a[8] * b; - out[9] = a[9] * b; - out[10] = a[10] * b; - out[11] = a[11] * b; - out[12] = a[12] * b; - out[13] = a[13] * b; - out[14] = a[14] * b; - out[15] = a[15] * b; - return out; -} -function multiplyScalarAndAdd(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - out[3] = a[3] + b[3] * scale13; - out[4] = a[4] + b[4] * scale13; - out[5] = a[5] + b[5] * scale13; - out[6] = a[6] + b[6] * scale13; - out[7] = a[7] + b[7] * scale13; - out[8] = a[8] + b[8] * scale13; - out[9] = a[9] + b[9] * scale13; - out[10] = a[10] + b[10] * scale13; - out[11] = a[11] + b[11] * scale13; - out[12] = a[12] + b[12] * scale13; - out[13] = a[13] + b[13] * scale13; - out[14] = a[14] + b[14] * scale13; - out[15] = a[15] + b[15] * scale13; - return out; -} -function exactEquals3(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; -} -function equals4(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const a4 = a[4]; - const a5 = a[5]; - const a6 = a[6]; - const a7 = a[7]; - const a8 = a[8]; - const a9 = a[9]; - const a10 = a[10]; - const a11 = a[11]; - const a12 = a[12]; - const a13 = a[13]; - const a14 = a[14]; - const a15 = a[15]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - const b3 = b[3]; - const b4 = b[4]; - const b5 = b[5]; - const b6 = b[6]; - const b7 = b[7]; - const b8 = b[8]; - const b9 = b[9]; - const b10 = b[10]; - const b11 = b[11]; - const b12 = b[12]; - const b13 = b[13]; - const b14 = b[14]; - const b15 = b[15]; - return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1, Math.abs(a15), Math.abs(b15)); -} -var mul3 = multiply3; -var sub3 = subtract3; - -// node_modules/@math.gl/core/dist/gl-matrix/vec4.js -var vec4_exports = {}; -__export(vec4_exports, { - add: () => add4, - ceil: () => ceil3, - clone: () => clone4, - copy: () => copy4, - create: () => create4, - cross: () => cross3, - dist: () => dist3, - distance: () => distance3, - div: () => div3, - divide: () => divide3, - dot: () => dot3, - equals: () => equals5, - exactEquals: () => exactEquals4, - floor: () => floor3, - forEach: () => forEach4, - fromValues: () => fromValues4, - inverse: () => inverse3, - len: () => len3, - length: () => length3, - lerp: () => lerp4, - max: () => max3, - min: () => min3, - mul: () => mul4, - multiply: () => multiply4, - negate: () => negate3, - normalize: () => normalize3, - random: () => random3, - round: () => round5, - scale: () => scale4, - scaleAndAdd: () => scaleAndAdd3, - set: () => set4, - sqrDist: () => sqrDist3, - sqrLen: () => sqrLen3, - squaredDistance: () => squaredDistance3, - squaredLength: () => squaredLength3, - str: () => str4, - sub: () => sub4, - subtract: () => subtract4, - transformMat4: () => transformMat43, - transformQuat: () => transformQuat2, - zero: () => zero3 -}); -function create4() { - const out = new ARRAY_TYPE(4); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; - } - return out; -} -function clone4(a) { - const out = new ARRAY_TYPE(4); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -function fromValues4(x, y, z, w) { - const out = new ARRAY_TYPE(4); - out[0] = x; - out[1] = y; - out[2] = z; - out[3] = w; - return out; -} -function copy4(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -function set4(out, x, y, z, w) { - out[0] = x; - out[1] = y; - out[2] = z; - out[3] = w; - return out; -} -function add4(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - return out; -} -function subtract4(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - out[3] = a[3] - b[3]; - return out; -} -function multiply4(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - out[2] = a[2] * b[2]; - out[3] = a[3] * b[3]; - return out; -} -function divide3(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - out[2] = a[2] / b[2]; - out[3] = a[3] / b[3]; - return out; -} -function ceil3(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - out[2] = Math.ceil(a[2]); - out[3] = Math.ceil(a[3]); - return out; -} -function floor3(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - out[2] = Math.floor(a[2]); - out[3] = Math.floor(a[3]); - return out; -} -function min3(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - out[2] = Math.min(a[2], b[2]); - out[3] = Math.min(a[3], b[3]); - return out; -} -function max3(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - out[2] = Math.max(a[2], b[2]); - out[3] = Math.max(a[3], b[3]); - return out; -} -function round5(out, a) { - out[0] = round2(a[0]); - out[1] = round2(a[1]); - out[2] = round2(a[2]); - out[3] = round2(a[3]); - return out; -} -function scale4(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - return out; -} -function scaleAndAdd3(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - out[3] = a[3] + b[3] * scale13; - return out; -} -function distance3(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - const w = b[3] - a[3]; - return Math.sqrt(x * x + y * y + z * z + w * w); -} -function squaredDistance3(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - const w = b[3] - a[3]; - return x * x + y * y + z * z + w * w; -} -function length3(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return Math.sqrt(x * x + y * y + z * z + w * w); -} -function squaredLength3(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return x * x + y * y + z * z + w * w; -} -function negate3(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - out[2] = -a[2]; - out[3] = -a[3]; - return out; -} -function inverse3(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - out[2] = 1 / a[2]; - out[3] = 1 / a[3]; - return out; -} -function normalize3(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - let len8 = x * x + y * y + z * z + w * w; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = x * len8; - out[1] = y * len8; - out[2] = z * len8; - out[3] = w * len8; - return out; -} -function dot3(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; -} -function cross3(out, u, v, w) { - const A = v[0] * w[1] - v[1] * w[0]; - const B = v[0] * w[2] - v[2] * w[0]; - const C = v[0] * w[3] - v[3] * w[0]; - const D = v[1] * w[2] - v[2] * w[1]; - const E = v[1] * w[3] - v[3] * w[1]; - const F = v[2] * w[3] - v[3] * w[2]; - const G = u[0]; - const H2 = u[1]; - const I = u[2]; - const J = u[3]; - out[0] = H2 * F - I * E + J * D; - out[1] = -(G * F) + I * C - J * B; - out[2] = G * E - H2 * C + J * A; - out[3] = -(G * D) + H2 * B - I * A; - return out; -} -function lerp4(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - out[2] = az + t * (b[2] - az); - out[3] = aw + t * (b[3] - aw); - return out; -} -function random3(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - let v1; - let v2; - let v3; - let v4; - let s1; - let s2; - do { - v1 = RANDOM() * 2 - 1; - v2 = RANDOM() * 2 - 1; - s1 = v1 * v1 + v2 * v2; - } while (s1 >= 1); - do { - v3 = RANDOM() * 2 - 1; - v4 = RANDOM() * 2 - 1; - s2 = v3 * v3 + v4 * v4; - } while (s2 >= 1); - const d = Math.sqrt((1 - s1) / s2); - out[0] = scale13 * v1; - out[1] = scale13 * v2; - out[2] = scale13 * v3 * d; - out[3] = scale13 * v4 * d; - return out; -} -function transformMat43(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; - out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; - out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; - out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; - return out; -} -function transformQuat2(out, a, q) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const ix = qw * x + qy * z - qz * y; - const iy = qw * y + qz * x - qx * z; - const iz = qw * z + qx * y - qy * x; - const iw = -qx * x - qy * y - qz * z; - out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; - out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; - out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; - out[3] = a[3]; - return out; -} -function zero3(out) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; - return out; -} -function str4(a) { - return `vec4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`; -} -function exactEquals4(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; -} -function equals5(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - const b3 = b[3]; - return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)); -} -var sub4 = subtract4; -var mul4 = multiply4; -var div3 = divide3; -var dist3 = distance3; -var sqrDist3 = squaredDistance3; -var len3 = length3; -var sqrLen3 = squaredLength3; -var forEach4 = function() { - const vec = create4(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 4; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - vec[3] = a[i + 3]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - a[i + 3] = vec[3]; - } - return a; - }; -}(); - -// node_modules/@math.gl/core/dist/classes/matrix4.js -var INDICES; -(function(INDICES3) { - INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; - INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; - INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; - INDICES3[INDICES3["COL0ROW3"] = 3] = "COL0ROW3"; - INDICES3[INDICES3["COL1ROW0"] = 4] = "COL1ROW0"; - INDICES3[INDICES3["COL1ROW1"] = 5] = "COL1ROW1"; - INDICES3[INDICES3["COL1ROW2"] = 6] = "COL1ROW2"; - INDICES3[INDICES3["COL1ROW3"] = 7] = "COL1ROW3"; - INDICES3[INDICES3["COL2ROW0"] = 8] = "COL2ROW0"; - INDICES3[INDICES3["COL2ROW1"] = 9] = "COL2ROW1"; - INDICES3[INDICES3["COL2ROW2"] = 10] = "COL2ROW2"; - INDICES3[INDICES3["COL2ROW3"] = 11] = "COL2ROW3"; - INDICES3[INDICES3["COL3ROW0"] = 12] = "COL3ROW0"; - INDICES3[INDICES3["COL3ROW1"] = 13] = "COL3ROW1"; - INDICES3[INDICES3["COL3ROW2"] = 14] = "COL3ROW2"; - INDICES3[INDICES3["COL3ROW3"] = 15] = "COL3ROW3"; -})(INDICES || (INDICES = {})); -var DEFAULT_FOVY = 45 * Math.PI / 180; -var DEFAULT_ASPECT = 1; -var DEFAULT_NEAR = 0.1; -var DEFAULT_FAR = 500; -var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); -var Matrix4 = class extends Matrix { - static get IDENTITY() { - return getIdentityMatrix(); - } - static get ZERO() { - return getZeroMatrix(); - } - get ELEMENTS() { - return 16; - } - get RANK() { - return 4; - } - get INDICES() { - return INDICES; - } - constructor(array) { - super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0); - if (arguments.length === 1 && Array.isArray(array)) { - this.copy(array); - } else { - this.identity(); - } - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - this[3] = array[3]; - this[4] = array[4]; - this[5] = array[5]; - this[6] = array[6]; - this[7] = array[7]; - this[8] = array[8]; - this[9] = array[9]; - this[10] = array[10]; - this[11] = array[11]; - this[12] = array[12]; - this[13] = array[13]; - this[14] = array[14]; - this[15] = array[15]; - return this.check(); - } - // eslint-disable-next-line max-params - set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m30; - this[4] = m01; - this[5] = m11; - this[6] = m21; - this[7] = m31; - this[8] = m02; - this[9] = m12; - this[10] = m22; - this[11] = m32; - this[12] = m03; - this[13] = m13; - this[14] = m23; - this[15] = m33; - return this.check(); - } - // accepts row major order, stores as column major - // eslint-disable-next-line max-params - setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m30; - this[4] = m01; - this[5] = m11; - this[6] = m21; - this[7] = m31; - this[8] = m02; - this[9] = m12; - this[10] = m22; - this[11] = m32; - this[12] = m03; - this[13] = m13; - this[14] = m23; - this[15] = m33; - return this.check(); - } - toRowMajor(result) { - result[0] = this[0]; - result[1] = this[4]; - result[2] = this[8]; - result[3] = this[12]; - result[4] = this[1]; - result[5] = this[5]; - result[6] = this[9]; - result[7] = this[13]; - result[8] = this[2]; - result[9] = this[6]; - result[10] = this[10]; - result[11] = this[14]; - result[12] = this[3]; - result[13] = this[7]; - result[14] = this[11]; - result[15] = this[15]; - return result; - } - // Constructors - /** Set to identity matrix */ - identity() { - return this.copy(IDENTITY_MATRIX); - } - /** - * - * @param object - * @returns self - */ - // eslint-disable-next-line @typescript-eslint/no-unused-vars - fromObject(object) { - return this.check(); - } - /** - * Calculates a 4x4 matrix from the given quaternion - * @param quaternion Quaternion to create matrix from - * @returns self - */ - fromQuaternion(quaternion) { - fromQuat(this, quaternion); - return this.check(); - } - /** - * Generates a frustum matrix with the given bounds - * @param view.left - Left bound of the frustum - * @param view.right - Right bound of the frustum - * @param view.bottom - Bottom bound of the frustum - * @param view.top - Top bound of the frustum - * @param view.near - Near bound of the frustum - * @param view.far - Far bound of the frustum. Can be set to Infinity. - * @returns self - */ - frustum(view) { - const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; - if (far === Infinity) { - computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near); - } else { - frustum(this, left, right, bottom, top, near, far); - } - return this.check(); - } - /** - * Generates a look-at matrix with the given eye position, focal point, - * and up axis - * @param view.eye - (vector) Position of the viewer - * @param view.center - (vector) Point the viewer is looking at - * @param view.up - (vector) Up axis - * @returns self - */ - lookAt(view) { - const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view; - lookAt(this, eye, center, up); - return this.check(); - } - /** - * Generates a orthogonal projection matrix with the given bounds - * from "traditional" view space parameters - * @param view.left - Left bound of the frustum - * @param view.right number Right bound of the frustum - * @param view.bottom - Bottom bound of the frustum - * @param view.top number Top bound of the frustum - * @param view.near - Near bound of the frustum - * @param view.far number Far bound of the frustum - * @returns self - */ - ortho(view) { - const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; - ortho(this, left, right, bottom, top, near, far); - return this.check(); - } - /** - * Generates an orthogonal projection matrix with the same parameters - * as a perspective matrix (plus focalDistance) - * @param view.fovy Vertical field of view in radians - * @param view.aspect Aspect ratio. Typically viewport width / viewport height - * @param view.focalDistance Distance in the view frustum used for extent calculations - * @param view.near Near bound of the frustum - * @param view.far Far bound of the frustum - * @returns self - */ - orthographic(view) { - const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view; - checkRadians(fovy); - const halfY = fovy / 2; - const top = focalDistance * Math.tan(halfY); - const right = top * aspect; - return this.ortho({ - left: -right, - right, - bottom: -top, - top, - near, - far - }); - } - /** - * Generates a perspective projection matrix with the given bounds - * @param view.fovy Vertical field of view in radians - * @param view.aspect Aspect ratio. typically viewport width/height - * @param view.near Near bound of the frustum - * @param view.far Far bound of the frustum - * @returns self - */ - perspective(view) { - const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view; - checkRadians(fovy); - perspective(this, fovy, aspect, near, far); - return this.check(); - } - // Accessors - determinant() { - return determinant(this); - } - /** - * Extracts the non-uniform scale assuming the matrix is an affine transformation. - * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix. - * @param result - * @returns self - */ - getScale(result = [-0, -0, -0]) { - result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]); - result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]); - result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]); - return result; - } - /** - * Gets the translation portion, assuming the matrix is a affine transformation matrix. - * @param result - * @returns self - */ - getTranslation(result = [-0, -0, -0]) { - result[0] = this[12]; - result[1] = this[13]; - result[2] = this[14]; - return result; - } - /** - * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix - * @param result - * @param scaleResult - * @returns self - */ - getRotation(result, scaleResult) { - result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0]; - scaleResult = scaleResult || [-0, -0, -0]; - const scale13 = this.getScale(scaleResult); - const inverseScale0 = 1 / scale13[0]; - const inverseScale1 = 1 / scale13[1]; - const inverseScale2 = 1 / scale13[2]; - result[0] = this[0] * inverseScale0; - result[1] = this[1] * inverseScale1; - result[2] = this[2] * inverseScale2; - result[3] = 0; - result[4] = this[4] * inverseScale0; - result[5] = this[5] * inverseScale1; - result[6] = this[6] * inverseScale2; - result[7] = 0; - result[8] = this[8] * inverseScale0; - result[9] = this[9] * inverseScale1; - result[10] = this[10] * inverseScale2; - result[11] = 0; - result[12] = 0; - result[13] = 0; - result[14] = 0; - result[15] = 1; - return result; - } - /** - * - * @param result - * @param scaleResult - * @returns self - */ - getRotationMatrix3(result, scaleResult) { - result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0]; - scaleResult = scaleResult || [-0, -0, -0]; - const scale13 = this.getScale(scaleResult); - const inverseScale0 = 1 / scale13[0]; - const inverseScale1 = 1 / scale13[1]; - const inverseScale2 = 1 / scale13[2]; - result[0] = this[0] * inverseScale0; - result[1] = this[1] * inverseScale1; - result[2] = this[2] * inverseScale2; - result[3] = this[4] * inverseScale0; - result[4] = this[5] * inverseScale1; - result[5] = this[6] * inverseScale2; - result[6] = this[8] * inverseScale0; - result[7] = this[9] * inverseScale1; - result[8] = this[10] * inverseScale2; - return result; - } - // Modifiers - transpose() { - transpose(this, this); - return this.check(); - } - invert() { - invert(this, this); - return this.check(); - } - // Operations - multiplyLeft(a) { - multiply3(this, a, this); - return this.check(); - } - multiplyRight(a) { - multiply3(this, this, a); - return this.check(); - } - // Rotates a matrix by the given angle around the X axis - rotateX(radians3) { - rotateX2(this, this, radians3); - return this.check(); - } - // Rotates a matrix by the given angle around the Y axis. - rotateY(radians3) { - rotateY2(this, this, radians3); - return this.check(); - } - /** - * Rotates a matrix by the given angle around the Z axis. - * @param radians - * @returns self - */ - rotateZ(radians3) { - rotateZ2(this, this, radians3); - return this.check(); - } - /** - * - * @param param0 - * @returns self - */ - rotateXYZ(angleXYZ) { - return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]); - } - /** - * - * @param radians - * @param axis - * @returns self - */ - rotateAxis(radians3, axis) { - rotate2(this, this, radians3, axis); - return this.check(); - } - /** - * - * @param factor - * @returns self - */ - scale(factor) { - scale3(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]); - return this.check(); - } - /** - * - * @param vec - * @returns self - */ - translate(vector) { - translate(this, this, vector); - return this.check(); - } - // Transforms - /** - * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points - * @param vector - * @param result - * @returns self - */ - transform(vector, result) { - if (vector.length === 4) { - result = transformMat43(result || [-0, -0, -0, -0], vector, this); - checkVector(result, 4); - return result; - } - return this.transformAsPoint(vector, result); - } - /** - * Transforms any 2 or 3 element array as point (w implicitly 1) - * @param vector - * @param result - * @returns self - */ - transformAsPoint(vector, result) { - const { length: length10 } = vector; - let out; - switch (length10) { - case 2: - out = transformMat4(result || [-0, -0], vector, this); - break; - case 3: - out = transformMat42(result || [-0, -0, -0], vector, this); - break; - default: - throw new Error("Illegal vector"); - } - checkVector(out, vector.length); - return out; - } - /** - * Transforms any 2 or 3 element array as vector (w implicitly 0) - * @param vector - * @param result - * @returns self - */ - transformAsVector(vector, result) { - let out; - switch (vector.length) { - case 2: - out = vec2_transformMat4AsVector(result || [-0, -0], vector, this); - break; - case 3: - out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this); - break; - default: - throw new Error("Illegal vector"); - } - checkVector(out, vector.length); - return out; - } - /** @deprecated */ - transformPoint(vector, result) { - return this.transformAsPoint(vector, result); - } - /** @deprecated */ - transformVector(vector, result) { - return this.transformAsPoint(vector, result); - } - /** @deprecated */ - transformDirection(vector, result) { - return this.transformAsVector(vector, result); - } - // three.js math API compatibility - makeRotationX(radians3) { - return this.identity().rotateX(radians3); - } - makeTranslation(x, y, z) { - return this.identity().translate([x, y, z]); - } -}; -var ZERO2; -var IDENTITY; -function getZeroMatrix() { - if (!ZERO2) { - ZERO2 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); - Object.freeze(ZERO2); - } - return ZERO2; -} -function getIdentityMatrix() { - if (!IDENTITY) { - IDENTITY = new Matrix4(); - Object.freeze(IDENTITY); - } - return IDENTITY; -} -function checkRadians(possiblyDegrees) { - if (possiblyDegrees > Math.PI * 2) { - throw Error("expected radians"); - } -} -function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) { - const column0Row0 = 2 * near / (right - left); - const column1Row1 = 2 * near / (top - bottom); - const column2Row0 = (right + left) / (right - left); - const column2Row1 = (top + bottom) / (top - bottom); - const column2Row2 = -1; - const column2Row3 = -1; - const column3Row2 = -2 * near; - result[0] = column0Row0; - result[1] = 0; - result[2] = 0; - result[3] = 0; - result[4] = 0; - result[5] = column1Row1; - result[6] = 0; - result[7] = 0; - result[8] = column2Row0; - result[9] = column2Row1; - result[10] = column2Row2; - result[11] = column2Row3; - result[12] = 0; - result[13] = 0; - result[14] = column3Row2; - result[15] = 0; - return result; -} - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/lights/lights-glsl.js -var lightingShader = `#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX)) -struct AmbientLight { -vec3 color; -}; -struct PointLight { -vec3 color; -vec3 position; -vec3 attenuation; -}; -struct DirectionalLight { -vec3 color; -vec3 direction; -}; -uniform AmbientLight lighting_uAmbientLight; -uniform PointLight lighting_uPointLight[MAX_LIGHTS]; -uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS]; -uniform int lighting_uPointLightCount; -uniform int lighting_uDirectionalLightCount; -uniform bool lighting_uEnabled; -float getPointLightAttenuation(PointLight pointLight, float distance) { -return pointLight.attenuation.x -+ pointLight.attenuation.y * distance -+ pointLight.attenuation.z * distance * distance; -} -#endif -`; - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/lights/lights.js -var INITIAL_MODULE_OPTIONS = { - lightSources: {} -}; -function convertColor(colorDef = {}) { - const { color = [0, 0, 0], intensity = 1 } = colorDef; - return color.map((component) => component * intensity / 255); -} -function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) { - const lightSourceUniforms = {}; - if (ambientLight) { - lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight); - } else { - lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0]; - } - pointLights.forEach((pointLight, index2) => { - lightSourceUniforms[`lighting_uPointLight[${index2}].color`] = convertColor(pointLight); - lightSourceUniforms[`lighting_uPointLight[${index2}].position`] = pointLight.position; - lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [ - 1, - 0, - 0 - ]; - }); - lightSourceUniforms.lighting_uPointLightCount = pointLights.length; - directionalLights.forEach((directionalLight, index2) => { - lightSourceUniforms[`lighting_uDirectionalLight[${index2}].color`] = convertColor(directionalLight); - lightSourceUniforms[`lighting_uDirectionalLight[${index2}].direction`] = directionalLight.direction; - }); - lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length; - return lightSourceUniforms; -} -function getUniforms3(opts = INITIAL_MODULE_OPTIONS) { - if ("lightSources" in opts) { - const { ambientLight, pointLights, directionalLights } = opts.lightSources || {}; - const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0; - if (!hasLights) { - return { lighting_uEnabled: false }; - } - return Object.assign({}, getLightSourceUniforms({ ambientLight, pointLights, directionalLights }), { - lighting_uEnabled: true - }); - } - if ("lights" in opts) { - const lightSources = { pointLights: [], directionalLights: [] }; - for (const light of opts.lights || []) { - switch (light.type) { - case "ambient": - lightSources.ambientLight = light; - break; - case "directional": - lightSources.directionalLights?.push(light); - break; - case "point": - lightSources.pointLights?.push(light); - break; - default: - } - } - return getUniforms3({ lightSources }); - } - return {}; -} -var lights = { - name: "lights", - vs: lightingShader, - fs: lightingShader, - getUniforms: getUniforms3, - defines: { - MAX_LIGHTS: 3 - } -}; - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.js -var lightingShader2 = `uniform float lighting_uAmbient; -uniform float lighting_uDiffuse; -uniform float lighting_uShininess; -uniform vec3 lighting_uSpecularColor; -vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) { -vec3 halfway_direction = normalize(light_direction + view_direction); -float lambertian = dot(light_direction, normal_worldspace); -float specular = 0.0; -if (lambertian > 0.0) { -float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0); -specular = pow(specular_angle, lighting_uShininess); -} -lambertian = max(lambertian, 0.0); -return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color; -} -vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) { -vec3 lightColor = surfaceColor; -if (lighting_uEnabled) { -vec3 view_direction = normalize(cameraPosition - position_worldspace); -lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color; -for (int i = 0; i < MAX_LIGHTS; i++) { -if (i >= lighting_uPointLightCount) { -break; -} -PointLight pointLight = lighting_uPointLight[i]; -vec3 light_position_worldspace = pointLight.position; -vec3 light_direction = normalize(light_position_worldspace - position_worldspace); -lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color); -} -for (int i = 0; i < MAX_LIGHTS; i++) { -if (i >= lighting_uDirectionalLightCount) { -break; -} -DirectionalLight directionalLight = lighting_uDirectionalLight[i]; -lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color); -} -} -return lightColor; -} -vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) { -vec3 lightColor = vec3(0, 0, 0); -vec3 surfaceColor = vec3(0, 0, 0); -if (lighting_uEnabled) { -vec3 view_direction = normalize(cameraPosition - position_worldspace); -for (int i = 0; i < MAX_LIGHTS; i++) { -if (i >= lighting_uPointLightCount) { -break; -} -PointLight pointLight = lighting_uPointLight[i]; -vec3 light_position_worldspace = pointLight.position; -vec3 light_direction = normalize(light_position_worldspace - position_worldspace); -lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color); -} -for (int i = 0; i < MAX_LIGHTS; i++) { -if (i >= lighting_uDirectionalLightCount) { -break; -} -DirectionalLight directionalLight = lighting_uDirectionalLight[i]; -lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color); -} -} -return lightColor; -} -`; - -// node_modules/@luma.gl/shadertools/dist/modules-webgl1/lighting/phong-lighting/phong-lighting.js -var INITIAL_MODULE_OPTIONS2 = {}; -function getMaterialUniforms(material) { - const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material; - return { - lighting_uAmbient: ambient, - lighting_uDiffuse: diffuse, - lighting_uShininess: shininess, - lighting_uSpecularColor: specularColor.map((x) => x / 255) - }; -} -function getUniforms4(opts = INITIAL_MODULE_OPTIONS2) { - if (!("material" in opts)) { - return {}; - } - const { material } = opts; - if (!material) { - return { lighting_uEnabled: false }; - } - return getMaterialUniforms(material); -} -var gouraudLighting = { - name: "gouraud-lighting", - dependencies: [lights], - vs: lightingShader2, - defines: { - LIGHTING_VERTEX: 1 - }, - getUniforms: getUniforms4 -}; - -// node_modules/@deck.gl/core/dist/shaderlib/misc/geometry.js -var defines = "#define SMOOTH_EDGE_RADIUS 0.5"; -var vs2 = ` -${defines} - -struct VertexGeometry { - vec4 position; - vec3 worldPosition; - vec3 worldPositionAlt; - vec3 normal; - vec2 uv; - vec3 pickingColor; -} geometry = VertexGeometry( - vec4(0.0, 0.0, 1.0, 0.0), - vec3(0.0), - vec3(0.0), - vec3(0.0), - vec2(0.0), - vec3(0.0) -); -`; -var fs2 = ` -${defines} - -struct FragmentGeometry { - vec2 uv; -} geometry; - -float smoothedge(float edge, float x) { - return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x); -} -`; -var geometry_default = { name: "geometry", vs: vs2, fs: fs2 }; - -// node_modules/@deck.gl/core/dist/lib/constants.js -var COORDINATE_SYSTEM = { - /** - * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise - */ - DEFAULT: -1, - /** - * Positions are interpreted as [longitude, latitude, elevation] - * longitude/latitude are in degrees, elevation is in meters. - * Dimensions are in meters. - */ - LNGLAT: 1, - /** - * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin. - * Dimensions are in meters. - */ - METER_OFFSETS: 2, - /** - * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin. - * deltaLng/deltaLat are in degrees, elevation is in meters. - * Dimensions are in meters. - */ - LNGLAT_OFFSETS: 3, - /** - * Positions and dimensions are in the common units of the viewport. - */ - CARTESIAN: 0 -}; -Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", { - get: () => { - log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")(); - return 0; - } -}); -var PROJECTION_MODE = { - /** - * Render geospatial data in Web Mercator projection - */ - WEB_MERCATOR: 1, - /** - * Render geospatial data as a 3D globe - */ - GLOBE: 2, - /** - * (Internal use only) Web Mercator projection at high zoom - */ - WEB_MERCATOR_AUTO_OFFSET: 4, - /** - * No transformation - */ - IDENTITY: 0 -}; -var UNIT = { - common: 0, - meters: 1, - pixels: 2 -}; -var EVENTS = { - click: { handler: "onClick" }, - panstart: { handler: "onDragStart" }, - panmove: { handler: "onDrag" }, - panend: { handler: "onDragEnd" } -}; - -// node_modules/@deck.gl/core/dist/shaderlib/project/project.glsl.js -var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`).join(""); -var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join(""); -var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join(""); -var project_glsl_default = `${COORDINATE_SYSTEM_GLSL_CONSTANTS} -${PROJECTION_MODE_GLSL_CONSTANTS} -${UNIT_GLSL_CONSTANTS} -uniform int project_uCoordinateSystem; -uniform int project_uProjectionMode; -uniform float project_uScale; -uniform bool project_uWrapLongitude; -uniform vec3 project_uCommonUnitsPerMeter; -uniform vec3 project_uCommonUnitsPerWorldUnit; -uniform vec3 project_uCommonUnitsPerWorldUnit2; -uniform vec4 project_uCenter; -uniform mat4 project_uModelMatrix; -uniform mat4 project_uViewProjectionMatrix; -uniform vec2 project_uViewportSize; -uniform float project_uDevicePixelRatio; -uniform float project_uFocalDistance; -uniform vec3 project_uCameraPosition; -uniform vec3 project_uCoordinateOrigin; -uniform vec3 project_uCommonOrigin; -uniform bool project_uPseudoMeters; -const float TILE_SIZE = 512.0; -const float PI = 3.1415926536; -const float WORLD_SCALE = TILE_SIZE / (PI * 2.0); -const vec3 ZERO_64_LOW = vec3(0.0); -const float EARTH_RADIUS = 6370972.0; -const float GLOBE_RADIUS = 256.0; -float project_size_at_latitude(float lat) { -float y = clamp(lat, -89.9, 89.9); -return 1.0 / cos(radians(y)); -} -float project_size() { -if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR && -project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT && -project_uPseudoMeters == false) { -if (geometry.position.w == 0.0) { -return project_size_at_latitude(geometry.worldPosition.y); -} -float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0; -float y2 = y * y; -float y4 = y2 * y2; -float y6 = y4 * y2; -return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6; -} -return 1.0; -} -float project_size_at_latitude(float meters, float lat) { -return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude(lat); -} -float project_size(float meters) { -return meters * project_uCommonUnitsPerMeter.z * project_size(); -} -vec2 project_size(vec2 meters) { -return meters * project_uCommonUnitsPerMeter.xy * project_size(); -} -vec3 project_size(vec3 meters) { -return meters * project_uCommonUnitsPerMeter * project_size(); -} -vec4 project_size(vec4 meters) { -return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w); -} -mat3 project_get_orientation_matrix(vec3 up) { -vec3 uz = normalize(up); -vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0)); -vec3 uy = cross(uz, ux); -return mat3(ux, uy, uz); -} -bool project_needs_rotation(vec3 commonPosition, out mat3 transform) { -if (project_uProjectionMode == PROJECTION_MODE_GLOBE) { -transform = project_get_orientation_matrix(commonPosition); -return true; -} -return false; -} -vec3 project_normal(vec3 vector) { -vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0); -vec3 n = normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter); -mat3 rotation; -if (project_needs_rotation(geometry.position.xyz, rotation)) { -n = rotation * n; -} -return n; -} -vec4 project_offset_(vec4 offset) { -float dy = offset.y; -vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy; -return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w); -} -vec2 project_mercator_(vec2 lnglat) { -float x = lnglat.x; -if (project_uWrapLongitude) { -x = mod(x + 180., 360.0) - 180.; -} -float y = clamp(lnglat.y, -89.9, 89.9); -return vec2( -radians(x) + PI, -PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5)) -) * WORLD_SCALE; -} -vec3 project_globe_(vec3 lnglatz) { -float lambda = radians(lnglatz.x); -float phi = radians(lnglatz.y); -float cosPhi = cos(phi); -float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS; -return vec3( -sin(lambda) * cosPhi, --cos(lambda) * cosPhi, -sin(phi) -) * D; -} -vec4 project_position(vec4 position, vec3 position64Low) { -vec4 position_world = project_uModelMatrix * position; -if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) { -if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { -return vec4( -project_mercator_(position_world.xy), -project_size_at_latitude(position_world.z, position_world.y), -position_world.w -); -} -if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) { -position_world.xyz += project_uCoordinateOrigin; -} -} -if (project_uProjectionMode == PROJECTION_MODE_GLOBE) { -if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { -return vec4( -project_globe_(position_world.xyz), -position_world.w -); -} -} -if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) { -if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) { -if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) { -return vec4( -project_mercator_(position_world.xy) - project_uCommonOrigin.xy, -project_size(position_world.z), -position_world.w -); -} -} -} -if (project_uProjectionMode == PROJECTION_MODE_IDENTITY || -(project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET && -(project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT || -project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) { -position_world.xyz -= project_uCoordinateOrigin; -} -return project_offset_(position_world) + project_offset_(project_uModelMatrix * vec4(position64Low, 0.0)); -} -vec4 project_position(vec4 position) { -return project_position(position, ZERO_64_LOW); -} -vec3 project_position(vec3 position, vec3 position64Low) { -vec4 projected_position = project_position(vec4(position, 1.0), position64Low); -return projected_position.xyz; -} -vec3 project_position(vec3 position) { -vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW); -return projected_position.xyz; -} -vec2 project_position(vec2 position) { -vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW); -return projected_position.xy; -} -vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) { -return viewProjectionMatrix * position + center; -} -vec4 project_common_position_to_clipspace(vec4 position) { -return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter); -} -vec2 project_pixel_size_to_clipspace(vec2 pixels) { -vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0; -return offset * project_uFocalDistance; -} -float project_size_to_pixel(float meters) { -return project_size(meters) * project_uScale; -} -float project_size_to_pixel(float size, int unit) { -if (unit == UNIT_METERS) return project_size_to_pixel(size); -if (unit == UNIT_COMMON) return size * project_uScale; -return size; -} -float project_pixel_size(float pixels) { -return pixels / project_uScale; -} -vec2 project_pixel_size(vec2 pixels) { -return pixels / project_uScale; -} -`; - -// node_modules/@deck.gl/core/dist/utils/memoize.js -function isEqual(a, b) { - if (a === b) { - return true; - } - if (Array.isArray(a)) { - const len8 = a.length; - if (!b || b.length !== len8) { - return false; - } - for (let i = 0; i < len8; i++) { - if (a[i] !== b[i]) { - return false; - } - } - return true; - } - return false; -} -function memoize(compute) { - let cachedArgs = {}; - let cachedResult; - return (args) => { - for (const key in args) { - if (!isEqual(args[key], cachedArgs[key])) { - cachedResult = compute(args); - cachedArgs = args; - break; - } - } - return cachedResult; - }; -} - -// node_modules/@deck.gl/core/dist/shaderlib/project/viewport-uniforms.js -var ZERO_VECTOR = [0, 0, 0, 0]; -var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; -var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; -var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0]; -var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0]; -var getMemoizedViewportUniforms = memoize(calculateViewportUniforms); -function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) { - if (coordinateOrigin.length < 3) { - coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0]; - } - let shaderCoordinateOrigin = coordinateOrigin; - let geospatialOrigin; - let offsetMode = true; - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) { - geospatialOrigin = coordinateOrigin; - } else { - geospatialOrigin = viewport.isGeospatial ? ( - // @ts-expect-error longitude and latitude are not defined on the base Viewport, but is expected on geospatial viewports - [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0] - ) : null; - } - switch (viewport.projectionMode) { - case PROJECTION_MODE.WEB_MERCATOR: - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { - geospatialOrigin = [0, 0, 0]; - offsetMode = false; - } - break; - case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET: - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { - shaderCoordinateOrigin = geospatialOrigin; - } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { - shaderCoordinateOrigin = [ - Math.fround(viewport.center[0]), - Math.fround(viewport.center[1]), - 0 - ]; - geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin); - shaderCoordinateOrigin[0] -= coordinateOrigin[0]; - shaderCoordinateOrigin[1] -= coordinateOrigin[1]; - shaderCoordinateOrigin[2] -= coordinateOrigin[2]; - } - break; - case PROJECTION_MODE.IDENTITY: - shaderCoordinateOrigin = viewport.position.map(Math.fround); - shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0; - break; - case PROJECTION_MODE.GLOBE: - offsetMode = false; - geospatialOrigin = null; - break; - default: - offsetMode = false; - } - return { geospatialOrigin, shaderCoordinateOrigin, offsetMode }; -} -function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) { - const { viewMatrixUncentered, projectionMatrix } = viewport; - let { viewMatrix, viewProjectionMatrix } = viewport; - let projectionCenter = ZERO_VECTOR; - let originCommon = ZERO_VECTOR; - let cameraPosCommon = viewport.cameraPosition; - const { geospatialOrigin, shaderCoordinateOrigin, offsetMode } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin); - if (offsetMode) { - originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); - cameraPosCommon = [ - cameraPosCommon[0] - originCommon[0], - cameraPosCommon[1] - originCommon[1], - cameraPosCommon[2] - originCommon[2] - ]; - originCommon[3] = 1; - projectionCenter = vec4_exports.transformMat4([], originCommon, viewProjectionMatrix); - viewMatrix = viewMatrixUncentered || viewMatrix; - viewProjectionMatrix = mat4_exports.multiply([], projectionMatrix, viewMatrix); - viewProjectionMatrix = mat4_exports.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX); - } - return { - viewMatrix, - viewProjectionMatrix, - projectionCenter, - originCommon, - cameraPosCommon, - shaderCoordinateOrigin, - geospatialOrigin - }; -} -function getUniformsFromViewport({ - viewport, - devicePixelRatio = 1, - modelMatrix = null, - // Match Layer.defaultProps - coordinateSystem = COORDINATE_SYSTEM.DEFAULT, - coordinateOrigin = DEFAULT_COORDINATE_ORIGIN, - autoWrapLongitude = false -}) { - if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { - coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; - } - const uniforms = getMemoizedViewportUniforms({ - viewport, - devicePixelRatio, - coordinateSystem, - coordinateOrigin - }); - uniforms.project_uWrapLongitude = autoWrapLongitude; - uniforms.project_uModelMatrix = modelMatrix || IDENTITY_MATRIX2; - return uniforms; -} -function calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSystem, coordinateOrigin }) { - const { projectionCenter, viewProjectionMatrix, originCommon, cameraPosCommon, shaderCoordinateOrigin, geospatialOrigin } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin); - const distanceScales = viewport.getDistanceScales(); - const viewportSize = [ - viewport.width * devicePixelRatio, - viewport.height * devicePixelRatio - ]; - const focalDistance = vec4_exports.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1; - const uniforms = { - // Projection mode values - project_uCoordinateSystem: coordinateSystem, - project_uProjectionMode: viewport.projectionMode, - project_uCoordinateOrigin: shaderCoordinateOrigin, - project_uCommonOrigin: originCommon.slice(0, 3), - project_uCenter: projectionCenter, - // Backward compatibility - // TODO: remove in v9 - // @ts-expect-error _pseudoMeters is only defined on WebMercator viewport - project_uPseudoMeters: Boolean(viewport._pseudoMeters), - // Screen size - project_uViewportSize: viewportSize, - project_uDevicePixelRatio: devicePixelRatio, - project_uFocalDistance: focalDistance, - project_uCommonUnitsPerMeter: distanceScales.unitsPerMeter, - project_uCommonUnitsPerWorldUnit: distanceScales.unitsPerMeter, - project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2, - project_uScale: viewport.scale, - // This is the mercator scale (2 ** zoom) - project_uWrapLongitude: false, - project_uViewProjectionMatrix: viewProjectionMatrix, - project_uModelMatrix: IDENTITY_MATRIX2, - // This is for lighting calculations - project_uCameraPosition: cameraPosCommon - }; - if (geospatialOrigin) { - const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin); - switch (coordinateSystem) { - case COORDINATE_SYSTEM.METER_OFFSETS: - uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter; - uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2; - break; - case COORDINATE_SYSTEM.LNGLAT: - case COORDINATE_SYSTEM.LNGLAT_OFFSETS: - if (!viewport._pseudoMeters) { - uniforms.project_uCommonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter; - } - uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree; - uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2; - break; - case COORDINATE_SYSTEM.CARTESIAN: - uniforms.project_uCommonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]]; - uniforms.project_uCommonUnitsPerWorldUnit2 = [ - 0, - 0, - distanceScalesAtOrigin.unitsPerMeter2[2] - ]; - break; - default: - break; - } - } - return uniforms; -} - -// node_modules/@deck.gl/core/dist/shaderlib/project/project.js -var INITIAL_MODULE_OPTIONS3 = {}; -function getUniforms5(opts = INITIAL_MODULE_OPTIONS3) { - if ("viewport" in opts) { - return getUniformsFromViewport(opts); - } - return {}; -} -var project_default = { - name: "project", - dependencies: [fp32, geometry_default], - vs: project_glsl_default, - getUniforms: getUniforms5 -}; - -// node_modules/@deck.gl/core/dist/shaderlib/project32/project32.js -var vs3 = ` -vec4 project_position_to_clipspace( - vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition -) { - vec3 projectedPosition = project_position(position, position64Low); - mat3 rotation; - if (project_needs_rotation(projectedPosition, rotation)) { - // offset is specified as ENU - // when in globe projection, rotate offset so that the ground alighs with the surface of the globe - offset = rotation * offset; - } - commonPosition = vec4(projectedPosition + offset, 1.0); - return project_common_position_to_clipspace(commonPosition); -} - -vec4 project_position_to_clipspace( - vec3 position, vec3 position64Low, vec3 offset -) { - vec4 commonPosition; - return project_position_to_clipspace(position, position64Low, offset, commonPosition); -} -`; -var project32_default = { - name: "project32", - dependencies: [project_default], - vs: vs3 -}; - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec2.js -var vec2_exports2 = {}; -__export(vec2_exports2, { - add: () => add5, - angle: () => angle3, - ceil: () => ceil4, - clone: () => clone6, - copy: () => copy5, - create: () => create5, - cross: () => cross4, - dist: () => dist4, - distance: () => distance4, - div: () => div4, - divide: () => divide4, - dot: () => dot4, - equals: () => equals6, - exactEquals: () => exactEquals6, - floor: () => floor4, - forEach: () => forEach5, - fromValues: () => fromValues5, - inverse: () => inverse4, - len: () => len4, - length: () => length4, - lerp: () => lerp5, - max: () => max4, - min: () => min4, - mul: () => mul5, - multiply: () => multiply5, - negate: () => negate4, - normalize: () => normalize4, - random: () => random4, - rotate: () => rotate3, - round: () => round7, - scale: () => scale5, - scaleAndAdd: () => scaleAndAdd4, - set: () => set5, - sqrDist: () => sqrDist4, - sqrLen: () => sqrLen4, - squaredDistance: () => squaredDistance4, - squaredLength: () => squaredLength4, - str: () => str5, - sub: () => sub5, - subtract: () => subtract5, - transformMat2: () => transformMat22, - transformMat2d: () => transformMat2d2, - transformMat3: () => transformMat33, - transformMat4: () => transformMat44, - zero: () => zero4 -}); - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/common.js -var EPSILON2 = 1e-6; -var ARRAY_TYPE2 = typeof Float32Array !== "undefined" ? Float32Array : Array; -var RANDOM2 = Math.random; -function round6(a) { - if (a >= 0) - return Math.round(a); - return a % 0.5 === 0 ? Math.floor(a) : Math.round(a); -} -var degree2 = Math.PI / 180; - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec2.js -function create5() { - const out = new ARRAY_TYPE2(2); - if (ARRAY_TYPE2 != Float32Array) { - out[0] = 0; - out[1] = 0; - } - return out; -} -function clone6(a) { - const out = new ARRAY_TYPE2(2); - out[0] = a[0]; - out[1] = a[1]; - return out; -} -function fromValues5(x, y) { - const out = new ARRAY_TYPE2(2); - out[0] = x; - out[1] = y; - return out; -} -function copy5(out, a) { - out[0] = a[0]; - out[1] = a[1]; - return out; -} -function set5(out, x, y) { - out[0] = x; - out[1] = y; - return out; -} -function add5(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - return out; -} -function subtract5(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - return out; -} -function multiply5(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - return out; -} -function divide4(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - return out; -} -function ceil4(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - return out; -} -function floor4(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - return out; -} -function min4(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - return out; -} -function max4(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - return out; -} -function round7(out, a) { - out[0] = round6(a[0]); - out[1] = round6(a[1]); - return out; -} -function scale5(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - return out; -} -function scaleAndAdd4(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - return out; -} -function distance4(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - return Math.sqrt(x * x + y * y); -} -function squaredDistance4(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - return x * x + y * y; -} -function length4(a) { - const x = a[0]; - const y = a[1]; - return Math.sqrt(x * x + y * y); -} -function squaredLength4(a) { - const x = a[0]; - const y = a[1]; - return x * x + y * y; -} -function negate4(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - return out; -} -function inverse4(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - return out; -} -function normalize4(out, a) { - const x = a[0]; - const y = a[1]; - let len8 = x * x + y * y; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = a[0] * len8; - out[1] = a[1] * len8; - return out; -} -function dot4(a, b) { - return a[0] * b[0] + a[1] * b[1]; -} -function cross4(out, a, b) { - const z = a[0] * b[1] - a[1] * b[0]; - out[0] = out[1] = 0; - out[2] = z; - return out; -} -function lerp5(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - return out; -} -function random4(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - const r = RANDOM2() * 2 * Math.PI; - out[0] = Math.cos(r) * scale13; - out[1] = Math.sin(r) * scale13; - return out; -} -function transformMat22(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y; - out[1] = m[1] * x + m[3] * y; - return out; -} -function transformMat2d2(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y + m[4]; - out[1] = m[1] * x + m[3] * y + m[5]; - return out; -} -function transformMat33(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[3] * y + m[6]; - out[1] = m[1] * x + m[4] * y + m[7]; - return out; -} -function transformMat44(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[4] * y + m[12]; - out[1] = m[1] * x + m[5] * y + m[13]; - return out; -} -function rotate3(out, a, b, rad) { - const p0 = a[0] - b[0]; - const p1 = a[1] - b[1]; - const sinC = Math.sin(rad); - const cosC = Math.cos(rad); - out[0] = p0 * cosC - p1 * sinC + b[0]; - out[1] = p0 * sinC + p1 * cosC + b[1]; - return out; -} -function angle3(a, b) { - const x1 = a[0]; - const y1 = a[1]; - const x2 = b[0]; - const y2 = b[1]; - const mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)); - const cosine = mag && (x1 * x2 + y1 * y2) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); -} -function zero4(out) { - out[0] = 0; - out[1] = 0; - return out; -} -function str5(a) { - return `vec2(${a[0]}, ${a[1]})`; -} -function exactEquals6(a, b) { - return a[0] === b[0] && a[1] === b[1]; -} -function equals6(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const b0 = b[0]; - const b1 = b[1]; - return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)); -} -var len4 = length4; -var sub5 = subtract5; -var mul5 = multiply5; -var div4 = divide4; -var dist4 = distance4; -var sqrDist4 = squaredDistance4; -var sqrLen4 = squaredLength4; -var forEach5 = function() { - const vec = create5(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 2; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - } - return a; - }; -}(); - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec3.js -var vec3_exports2 = {}; -__export(vec3_exports2, { - add: () => add6, - angle: () => angle4, - bezier: () => bezier2, - ceil: () => ceil5, - clone: () => clone7, - copy: () => copy6, - create: () => create6, - cross: () => cross5, - dist: () => dist5, - distance: () => distance5, - div: () => div5, - divide: () => divide5, - dot: () => dot5, - equals: () => equals7, - exactEquals: () => exactEquals7, - floor: () => floor5, - forEach: () => forEach6, - fromValues: () => fromValues6, - hermite: () => hermite2, - inverse: () => inverse5, - len: () => len5, - length: () => length5, - lerp: () => lerp6, - max: () => max5, - min: () => min5, - mul: () => mul6, - multiply: () => multiply6, - negate: () => negate5, - normalize: () => normalize5, - random: () => random5, - rotateX: () => rotateX3, - rotateY: () => rotateY3, - rotateZ: () => rotateZ3, - round: () => round8, - scale: () => scale6, - scaleAndAdd: () => scaleAndAdd5, - set: () => set6, - slerp: () => slerp2, - sqrDist: () => sqrDist5, - sqrLen: () => sqrLen5, - squaredDistance: () => squaredDistance5, - squaredLength: () => squaredLength5, - str: () => str6, - sub: () => sub6, - subtract: () => subtract6, - transformMat3: () => transformMat34, - transformMat4: () => transformMat45, - transformQuat: () => transformQuat3, - zero: () => zero5 -}); -function create6() { - const out = new ARRAY_TYPE2(3); - if (ARRAY_TYPE2 != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - } - return out; -} -function clone7(a) { - const out = new ARRAY_TYPE2(3); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - return out; -} -function length5(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - return Math.sqrt(x * x + y * y + z * z); -} -function fromValues6(x, y, z) { - const out = new ARRAY_TYPE2(3); - out[0] = x; - out[1] = y; - out[2] = z; - return out; -} -function copy6(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - return out; -} -function set6(out, x, y, z) { - out[0] = x; - out[1] = y; - out[2] = z; - return out; -} -function add6(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - return out; -} -function subtract6(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - return out; -} -function multiply6(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - out[2] = a[2] * b[2]; - return out; -} -function divide5(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - out[2] = a[2] / b[2]; - return out; -} -function ceil5(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - out[2] = Math.ceil(a[2]); - return out; -} -function floor5(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - out[2] = Math.floor(a[2]); - return out; -} -function min5(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - out[2] = Math.min(a[2], b[2]); - return out; -} -function max5(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - out[2] = Math.max(a[2], b[2]); - return out; -} -function round8(out, a) { - out[0] = round6(a[0]); - out[1] = round6(a[1]); - out[2] = round6(a[2]); - return out; -} -function scale6(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - return out; -} -function scaleAndAdd5(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - return out; -} -function distance5(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - return Math.sqrt(x * x + y * y + z * z); -} -function squaredDistance5(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - return x * x + y * y + z * z; -} -function squaredLength5(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - return x * x + y * y + z * z; -} -function negate5(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - out[2] = -a[2]; - return out; -} -function inverse5(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - out[2] = 1 / a[2]; - return out; -} -function normalize5(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let len8 = x * x + y * y + z * z; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = a[0] * len8; - out[1] = a[1] * len8; - out[2] = a[2] * len8; - return out; -} -function dot5(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; -} -function cross5(out, a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - out[0] = ay * bz - az * by; - out[1] = az * bx - ax * bz; - out[2] = ax * by - ay * bx; - return out; -} -function lerp6(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - out[2] = az + t * (b[2] - az); - return out; -} -function slerp2(out, a, b, t) { - const angle6 = Math.acos(Math.min(Math.max(dot5(a, b), -1), 1)); - const sinTotal = Math.sin(angle6); - const ratioA = Math.sin((1 - t) * angle6) / sinTotal; - const ratioB = Math.sin(t * angle6) / sinTotal; - out[0] = ratioA * a[0] + ratioB * b[0]; - out[1] = ratioA * a[1] + ratioB * b[1]; - out[2] = ratioA * a[2] + ratioB * b[2]; - return out; -} -function hermite2(out, a, b, c, d, t) { - const factorTimes2 = t * t; - const factor1 = factorTimes2 * (2 * t - 3) + 1; - const factor2 = factorTimes2 * (t - 2) + t; - const factor3 = factorTimes2 * (t - 1); - const factor4 = factorTimes2 * (3 - 2 * t); - out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; - out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; - out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; - return out; -} -function bezier2(out, a, b, c, d, t) { - const inverseFactor = 1 - t; - const inverseFactorTimesTwo = inverseFactor * inverseFactor; - const factorTimes2 = t * t; - const factor1 = inverseFactorTimesTwo * inverseFactor; - const factor2 = 3 * t * inverseFactorTimesTwo; - const factor3 = 3 * factorTimes2 * inverseFactor; - const factor4 = factorTimes2 * t; - out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; - out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; - out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; - return out; -} -function random5(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - const r = RANDOM2() * 2 * Math.PI; - const z = RANDOM2() * 2 - 1; - const zScale = Math.sqrt(1 - z * z) * scale13; - out[0] = Math.cos(r) * zScale; - out[1] = Math.sin(r) * zScale; - out[2] = z * scale13; - return out; -} -function transformMat45(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let w = m[3] * x + m[7] * y + m[11] * z + m[15]; - w = w || 1; - out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; - out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; - out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; - return out; -} -function transformMat34(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - out[0] = x * m[0] + y * m[3] + z * m[6]; - out[1] = x * m[1] + y * m[4] + z * m[7]; - out[2] = x * m[2] + y * m[5] + z * m[8]; - return out; -} -function transformQuat3(out, a, q) { - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const x = a[0]; - const y = a[1]; - const z = a[2]; - let uvx = qy * z - qz * y; - let uvy = qz * x - qx * z; - let uvz = qx * y - qy * x; - let uuvx = qy * uvz - qz * uvy; - let uuvy = qz * uvx - qx * uvz; - let uuvz = qx * uvy - qy * uvx; - const w2 = qw * 2; - uvx *= w2; - uvy *= w2; - uvz *= w2; - uuvx *= 2; - uuvy *= 2; - uuvz *= 2; - out[0] = x + uvx + uuvx; - out[1] = y + uvy + uuvy; - out[2] = z + uvz + uuvz; - return out; -} -function rotateX3(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0]; - r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); - r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateY3(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); - r[1] = p[1]; - r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateZ3(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); - r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); - r[2] = p[2]; - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function angle4(a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); - const cosine = mag && dot5(a, b) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); -} -function zero5(out) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - return out; -} -function str6(a) { - return `vec3(${a[0]}, ${a[1]}, ${a[2]})`; -} -function exactEquals7(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]; -} -function equals7(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)); -} -var sub6 = subtract6; -var mul6 = multiply6; -var div5 = divide5; -var dist5 = distance5; -var sqrDist5 = squaredDistance5; -var len5 = length5; -var sqrLen5 = squaredLength5; -var forEach6 = function() { - const vec = create6(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 3; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - } - return a; - }; -}(); - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/mat4.js -var mat4_exports2 = {}; -__export(mat4_exports2, { - add: () => add7, - adjoint: () => adjoint2, - clone: () => clone8, - copy: () => copy7, - create: () => create7, - decompose: () => decompose2, - determinant: () => determinant2, - equals: () => equals8, - exactEquals: () => exactEquals8, - frob: () => frob2, - fromQuat: () => fromQuat3, - fromQuat2: () => fromQuat22, - fromRotation: () => fromRotation2, - fromRotationTranslation: () => fromRotationTranslation2, - fromRotationTranslationScale: () => fromRotationTranslationScale2, - fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin2, - fromScaling: () => fromScaling2, - fromTranslation: () => fromTranslation2, - fromValues: () => fromValues7, - fromXRotation: () => fromXRotation2, - fromYRotation: () => fromYRotation2, - fromZRotation: () => fromZRotation2, - frustum: () => frustum2, - getRotation: () => getRotation2, - getScaling: () => getScaling2, - getTranslation: () => getTranslation2, - identity: () => identity2, - invert: () => invert2, - lookAt: () => lookAt2, - mul: () => mul7, - multiply: () => multiply7, - multiplyScalar: () => multiplyScalar2, - multiplyScalarAndAdd: () => multiplyScalarAndAdd2, - ortho: () => ortho2, - orthoNO: () => orthoNO2, - orthoZO: () => orthoZO2, - perspective: () => perspective2, - perspectiveFromFieldOfView: () => perspectiveFromFieldOfView2, - perspectiveNO: () => perspectiveNO2, - perspectiveZO: () => perspectiveZO2, - rotate: () => rotate4, - rotateX: () => rotateX4, - rotateY: () => rotateY4, - rotateZ: () => rotateZ4, - scale: () => scale7, - set: () => set7, - str: () => str7, - sub: () => sub7, - subtract: () => subtract7, - targetTo: () => targetTo2, - translate: () => translate2, - transpose: () => transpose2 -}); -function create7() { - const out = new ARRAY_TYPE2(16); - if (ARRAY_TYPE2 != Float32Array) { - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - } - out[0] = 1; - out[5] = 1; - out[10] = 1; - out[15] = 1; - return out; -} -function clone8(a) { - const out = new ARRAY_TYPE2(16); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function copy7(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function fromValues7(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - const out = new ARRAY_TYPE2(16); - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function set7(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function identity2(out) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function transpose2(out, a) { - if (out === a) { - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a12 = a[6]; - const a13 = a[7]; - const a23 = a[11]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a01; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a02; - out[9] = a12; - out[11] = a[14]; - out[12] = a03; - out[13] = a13; - out[14] = a23; - } else { - out[0] = a[0]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a[1]; - out[5] = a[5]; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a[2]; - out[9] = a[6]; - out[10] = a[10]; - out[11] = a[14]; - out[12] = a[3]; - out[13] = a[7]; - out[14] = a[11]; - out[15] = a[15]; - } - return out; -} -function invert2(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; - if (!det) { - return null; - } - det = 1 / det; - out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; - out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; - out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; - out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; - out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; - out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; - out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; - out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; - out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; - out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; - out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; - out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; - out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; - out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; - out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; - out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; - return out; -} -function adjoint2(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - out[0] = a11 * b11 - a12 * b10 + a13 * b09; - out[1] = a02 * b10 - a01 * b11 - a03 * b09; - out[2] = a31 * b05 - a32 * b04 + a33 * b03; - out[3] = a22 * b04 - a21 * b05 - a23 * b03; - out[4] = a12 * b08 - a10 * b11 - a13 * b07; - out[5] = a00 * b11 - a02 * b08 + a03 * b07; - out[6] = a32 * b02 - a30 * b05 - a33 * b01; - out[7] = a20 * b05 - a22 * b02 + a23 * b01; - out[8] = a10 * b10 - a11 * b08 + a13 * b06; - out[9] = a01 * b08 - a00 * b10 - a03 * b06; - out[10] = a30 * b04 - a31 * b02 + a33 * b00; - out[11] = a21 * b02 - a20 * b04 - a23 * b00; - out[12] = a11 * b07 - a10 * b09 - a12 * b06; - out[13] = a00 * b09 - a01 * b07 + a02 * b06; - out[14] = a31 * b01 - a30 * b03 - a32 * b00; - out[15] = a20 * b03 - a21 * b01 + a22 * b00; - return out; -} -function determinant2(a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b0 = a00 * a11 - a01 * a10; - const b1 = a00 * a12 - a02 * a10; - const b2 = a01 * a12 - a02 * a11; - const b3 = a20 * a31 - a21 * a30; - const b4 = a20 * a32 - a22 * a30; - const b5 = a21 * a32 - a22 * a31; - const b6 = a00 * b5 - a01 * b4 + a02 * b3; - const b7 = a10 * b5 - a11 * b4 + a12 * b3; - const b8 = a20 * b2 - a21 * b1 + a22 * b0; - const b9 = a30 * b2 - a31 * b1 + a32 * b0; - return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; -} -function multiply7(out, a, b) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - let b0 = b[0]; - let b1 = b[1]; - let b2 = b[2]; - let b3 = b[3]; - out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[4]; - b1 = b[5]; - b2 = b[6]; - b3 = b[7]; - out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[8]; - b1 = b[9]; - b2 = b[10]; - b3 = b[11]; - out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[12]; - b1 = b[13]; - b2 = b[14]; - b3 = b[15]; - out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - return out; -} -function translate2(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - if (a === out) { - out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; - out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; - out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; - out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; - } else { - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - out[0] = a00; - out[1] = a01; - out[2] = a02; - out[3] = a03; - out[4] = a10; - out[5] = a11; - out[6] = a12; - out[7] = a13; - out[8] = a20; - out[9] = a21; - out[10] = a22; - out[11] = a23; - out[12] = a00 * x + a10 * y + a20 * z + a[12]; - out[13] = a01 * x + a11 * y + a21 * z + a[13]; - out[14] = a02 * x + a12 * y + a22 * z + a[14]; - out[15] = a03 * x + a13 * y + a23 * z + a[15]; - } - return out; -} -function scale7(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - out[0] = a[0] * x; - out[1] = a[1] * x; - out[2] = a[2] * x; - out[3] = a[3] * x; - out[4] = a[4] * y; - out[5] = a[5] * y; - out[6] = a[6] * y; - out[7] = a[7] * y; - out[8] = a[8] * z; - out[9] = a[9] * z; - out[10] = a[10] * z; - out[11] = a[11] * z; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function rotate4(out, a, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - let b00; - let b01; - let b02; - let b10; - let b11; - let b12; - let b20; - let b21; - let b22; - if (len8 < EPSILON2) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - b00 = x * x * t + c; - b01 = y * x * t + z * s; - b02 = z * x * t - y * s; - b10 = x * y * t - z * s; - b11 = y * y * t + c; - b12 = z * y * t + x * s; - b20 = x * z * t + y * s; - b21 = y * z * t - x * s; - b22 = z * z * t + c; - out[0] = a00 * b00 + a10 * b01 + a20 * b02; - out[1] = a01 * b00 + a11 * b01 + a21 * b02; - out[2] = a02 * b00 + a12 * b01 + a22 * b02; - out[3] = a03 * b00 + a13 * b01 + a23 * b02; - out[4] = a00 * b10 + a10 * b11 + a20 * b12; - out[5] = a01 * b10 + a11 * b11 + a21 * b12; - out[6] = a02 * b10 + a12 * b11 + a22 * b12; - out[7] = a03 * b10 + a13 * b11 + a23 * b12; - out[8] = a00 * b20 + a10 * b21 + a20 * b22; - out[9] = a01 * b20 + a11 * b21 + a21 * b22; - out[10] = a02 * b20 + a12 * b21 + a22 * b22; - out[11] = a03 * b20 + a13 * b21 + a23 * b22; - if (a !== out) { - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - return out; -} -function rotateX4(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[4] = a10 * c + a20 * s; - out[5] = a11 * c + a21 * s; - out[6] = a12 * c + a22 * s; - out[7] = a13 * c + a23 * s; - out[8] = a20 * c - a10 * s; - out[9] = a21 * c - a11 * s; - out[10] = a22 * c - a12 * s; - out[11] = a23 * c - a13 * s; - return out; -} -function rotateY4(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c - a20 * s; - out[1] = a01 * c - a21 * s; - out[2] = a02 * c - a22 * s; - out[3] = a03 * c - a23 * s; - out[8] = a00 * s + a20 * c; - out[9] = a01 * s + a21 * c; - out[10] = a02 * s + a22 * c; - out[11] = a03 * s + a23 * c; - return out; -} -function rotateZ4(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - if (a !== out) { - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c + a10 * s; - out[1] = a01 * c + a11 * s; - out[2] = a02 * c + a12 * s; - out[3] = a03 * c + a13 * s; - out[4] = a10 * c - a00 * s; - out[5] = a11 * c - a01 * s; - out[6] = a12 * c - a02 * s; - out[7] = a13 * c - a03 * s; - return out; -} -function fromTranslation2(out, v) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromScaling2(out, v) { - out[0] = v[0]; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = v[1]; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = v[2]; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotation2(out, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - if (len8 < EPSILON2) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - out[0] = x * x * t + c; - out[1] = y * x * t + z * s; - out[2] = z * x * t - y * s; - out[3] = 0; - out[4] = x * y * t - z * s; - out[5] = y * y * t + c; - out[6] = z * y * t + x * s; - out[7] = 0; - out[8] = x * z * t + y * s; - out[9] = y * z * t - x * s; - out[10] = z * z * t + c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromXRotation2(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = c; - out[6] = s; - out[7] = 0; - out[8] = 0; - out[9] = -s; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromYRotation2(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = 0; - out[2] = -s; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = s; - out[9] = 0; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromZRotation2(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = s; - out[2] = 0; - out[3] = 0; - out[4] = -s; - out[5] = c; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotationTranslation2(out, q, v) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - (yy + zz); - out[1] = xy + wz; - out[2] = xz - wy; - out[3] = 0; - out[4] = xy - wz; - out[5] = 1 - (xx + zz); - out[6] = yz + wx; - out[7] = 0; - out[8] = xz + wy; - out[9] = yz - wx; - out[10] = 1 - (xx + yy); - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromQuat22(out, a) { - const translation = new ARRAY_TYPE2(3); - const bx = -a[0]; - const by = -a[1]; - const bz = -a[2]; - const bw = a[3]; - const ax = a[4]; - const ay = a[5]; - const az = a[6]; - const aw = a[7]; - const magnitude = bx * bx + by * by + bz * bz + bw * bw; - if (magnitude > 0) { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; - } else { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; - } - fromRotationTranslation2(out, a, translation); - return out; -} -function getTranslation2(out, mat) { - out[0] = mat[12]; - out[1] = mat[13]; - out[2] = mat[14]; - return out; -} -function getScaling2(out, mat) { - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - return out; -} -function getRotation2(out, mat) { - const scaling = new ARRAY_TYPE2(3); - getScaling2(scaling, mat); - const is1 = 1 / scaling[0]; - const is2 = 1 / scaling[1]; - const is3 = 1 / scaling[2]; - const sm11 = mat[0] * is1; - const sm12 = mat[1] * is2; - const sm13 = mat[2] * is3; - const sm21 = mat[4] * is1; - const sm22 = mat[5] * is2; - const sm23 = mat[6] * is3; - const sm31 = mat[8] * is1; - const sm32 = mat[9] * is2; - const sm33 = mat[10] * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out[3] = 0.25 * S; - out[0] = (sm23 - sm32) / S; - out[1] = (sm31 - sm13) / S; - out[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out[3] = (sm23 - sm32) / S; - out[0] = 0.25 * S; - out[1] = (sm12 + sm21) / S; - out[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out[3] = (sm31 - sm13) / S; - out[0] = (sm12 + sm21) / S; - out[1] = 0.25 * S; - out[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out[3] = (sm12 - sm21) / S; - out[0] = (sm31 + sm13) / S; - out[1] = (sm23 + sm32) / S; - out[2] = 0.25 * S; - } - return out; -} -function decompose2(out_r, out_t, out_s, mat) { - out_t[0] = mat[12]; - out_t[1] = mat[13]; - out_t[2] = mat[14]; - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - const is1 = 1 / out_s[0]; - const is2 = 1 / out_s[1]; - const is3 = 1 / out_s[2]; - const sm11 = m11 * is1; - const sm12 = m12 * is2; - const sm13 = m13 * is3; - const sm21 = m21 * is1; - const sm22 = m22 * is2; - const sm23 = m23 * is3; - const sm31 = m31 * is1; - const sm32 = m32 * is2; - const sm33 = m33 * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out_r[3] = 0.25 * S; - out_r[0] = (sm23 - sm32) / S; - out_r[1] = (sm31 - sm13) / S; - out_r[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out_r[3] = (sm23 - sm32) / S; - out_r[0] = 0.25 * S; - out_r[1] = (sm12 + sm21) / S; - out_r[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out_r[3] = (sm31 - sm13) / S; - out_r[0] = (sm12 + sm21) / S; - out_r[1] = 0.25 * S; - out_r[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out_r[3] = (sm12 - sm21) / S; - out_r[0] = (sm31 + sm13) / S; - out_r[1] = (sm23 + sm32) / S; - out_r[2] = 0.25 * S; - } - return out_r; -} -function fromRotationTranslationScale2(out, q, v, s) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - out[0] = (1 - (yy + zz)) * sx; - out[1] = (xy + wz) * sx; - out[2] = (xz - wy) * sx; - out[3] = 0; - out[4] = (xy - wz) * sy; - out[5] = (1 - (xx + zz)) * sy; - out[6] = (yz + wx) * sy; - out[7] = 0; - out[8] = (xz + wy) * sz; - out[9] = (yz - wx) * sz; - out[10] = (1 - (xx + yy)) * sz; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromRotationTranslationScaleOrigin2(out, q, v, s, o) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - const ox = o[0]; - const oy = o[1]; - const oz = o[2]; - const out0 = (1 - (yy + zz)) * sx; - const out1 = (xy + wz) * sx; - const out2 = (xz - wy) * sx; - const out4 = (xy - wz) * sy; - const out5 = (1 - (xx + zz)) * sy; - const out6 = (yz + wx) * sy; - const out8 = (xz + wy) * sz; - const out9 = (yz - wx) * sz; - const out10 = (1 - (xx + yy)) * sz; - out[0] = out0; - out[1] = out1; - out[2] = out2; - out[3] = 0; - out[4] = out4; - out[5] = out5; - out[6] = out6; - out[7] = 0; - out[8] = out8; - out[9] = out9; - out[10] = out10; - out[11] = 0; - out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); - out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); - out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); - out[15] = 1; - return out; -} -function fromQuat3(out, q) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const yx = y * x2; - const yy = y * y2; - const zx = z * x2; - const zy = z * y2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - yy - zz; - out[1] = yx + wz; - out[2] = zx - wy; - out[3] = 0; - out[4] = yx - wz; - out[5] = 1 - xx - zz; - out[6] = zy + wx; - out[7] = 0; - out[8] = zx + wy; - out[9] = zy - wx; - out[10] = 1 - xx - yy; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function frustum2(out, left, right, bottom, top, near, far) { - const rl = 1 / (right - left); - const tb = 1 / (top - bottom); - const nf = 1 / (near - far); - out[0] = near * 2 * rl; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = near * 2 * tb; - out[6] = 0; - out[7] = 0; - out[8] = (right + left) * rl; - out[9] = (top + bottom) * tb; - out[10] = (far + near) * nf; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near * 2 * nf; - out[15] = 0; - return out; -} -function perspectiveNO2(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = (far + near) * nf; - out[14] = 2 * far * near * nf; - } else { - out[10] = -1; - out[14] = -2 * near; - } - return out; -} -var perspective2 = perspectiveNO2; -function perspectiveZO2(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = far * nf; - out[14] = far * near * nf; - } else { - out[10] = -1; - out[14] = -near; - } - return out; -} -function perspectiveFromFieldOfView2(out, fov, near, far) { - const upTan = Math.tan(fov.upDegrees * Math.PI / 180); - const downTan = Math.tan(fov.downDegrees * Math.PI / 180); - const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); - const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); - const xScale = 2 / (leftTan + rightTan); - const yScale = 2 / (upTan + downTan); - out[0] = xScale; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = yScale; - out[6] = 0; - out[7] = 0; - out[8] = -((leftTan - rightTan) * xScale * 0.5); - out[9] = (upTan - downTan) * yScale * 0.5; - out[10] = far / (near - far); - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near / (near - far); - out[15] = 0; - return out; -} -function orthoNO2(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 2 * nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = (far + near) * nf; - out[15] = 1; - return out; -} -var ortho2 = orthoNO2; -function orthoZO2(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = near * nf; - out[15] = 1; - return out; -} -function lookAt2(out, eye, center, up) { - let len8; - let x0; - let x1; - let x2; - let y0; - let y1; - let y2; - let z0; - let z1; - let z2; - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - const centerx = center[0]; - const centery = center[1]; - const centerz = center[2]; - if (Math.abs(eyex - centerx) < EPSILON2 && Math.abs(eyey - centery) < EPSILON2 && Math.abs(eyez - centerz) < EPSILON2) { - return identity2(out); - } - z0 = eyex - centerx; - z1 = eyey - centery; - z2 = eyez - centerz; - len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); - z0 *= len8; - z1 *= len8; - z2 *= len8; - x0 = upy * z2 - upz * z1; - x1 = upz * z0 - upx * z2; - x2 = upx * z1 - upy * z0; - len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); - if (!len8) { - x0 = 0; - x1 = 0; - x2 = 0; - } else { - len8 = 1 / len8; - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - y0 = z1 * x2 - z2 * x1; - y1 = z2 * x0 - z0 * x2; - y2 = z0 * x1 - z1 * x0; - len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); - if (!len8) { - y0 = 0; - y1 = 0; - y2 = 0; - } else { - len8 = 1 / len8; - y0 *= len8; - y1 *= len8; - y2 *= len8; - } - out[0] = x0; - out[1] = y0; - out[2] = z0; - out[3] = 0; - out[4] = x1; - out[5] = y1; - out[6] = z1; - out[7] = 0; - out[8] = x2; - out[9] = y2; - out[10] = z2; - out[11] = 0; - out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); - out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); - out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); - out[15] = 1; - return out; -} -function targetTo2(out, eye, target, up) { - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - let z0 = eyex - target[0]; - let z1 = eyey - target[1]; - let z2 = eyez - target[2]; - let len8 = z0 * z0 + z1 * z1 + z2 * z2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - z0 *= len8; - z1 *= len8; - z2 *= len8; - } - let x0 = upy * z2 - upz * z1; - let x1 = upz * z0 - upx * z2; - let x2 = upx * z1 - upy * z0; - len8 = x0 * x0 + x1 * x1 + x2 * x2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - out[0] = x0; - out[1] = x1; - out[2] = x2; - out[3] = 0; - out[4] = z1 * x2 - z2 * x1; - out[5] = z2 * x0 - z0 * x2; - out[6] = z0 * x1 - z1 * x0; - out[7] = 0; - out[8] = z0; - out[9] = z1; - out[10] = z2; - out[11] = 0; - out[12] = eyex; - out[13] = eyey; - out[14] = eyez; - out[15] = 1; - return out; -} -function str7(a) { - return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; -} -function frob2(a) { - return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); -} -function add7(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - out[4] = a[4] + b[4]; - out[5] = a[5] + b[5]; - out[6] = a[6] + b[6]; - out[7] = a[7] + b[7]; - out[8] = a[8] + b[8]; - out[9] = a[9] + b[9]; - out[10] = a[10] + b[10]; - out[11] = a[11] + b[11]; - out[12] = a[12] + b[12]; - out[13] = a[13] + b[13]; - out[14] = a[14] + b[14]; - out[15] = a[15] + b[15]; - return out; -} -function subtract7(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - out[3] = a[3] - b[3]; - out[4] = a[4] - b[4]; - out[5] = a[5] - b[5]; - out[6] = a[6] - b[6]; - out[7] = a[7] - b[7]; - out[8] = a[8] - b[8]; - out[9] = a[9] - b[9]; - out[10] = a[10] - b[10]; - out[11] = a[11] - b[11]; - out[12] = a[12] - b[12]; - out[13] = a[13] - b[13]; - out[14] = a[14] - b[14]; - out[15] = a[15] - b[15]; - return out; -} -function multiplyScalar2(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - out[4] = a[4] * b; - out[5] = a[5] * b; - out[6] = a[6] * b; - out[7] = a[7] * b; - out[8] = a[8] * b; - out[9] = a[9] * b; - out[10] = a[10] * b; - out[11] = a[11] * b; - out[12] = a[12] * b; - out[13] = a[13] * b; - out[14] = a[14] * b; - out[15] = a[15] * b; - return out; -} -function multiplyScalarAndAdd2(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - out[3] = a[3] + b[3] * scale13; - out[4] = a[4] + b[4] * scale13; - out[5] = a[5] + b[5] * scale13; - out[6] = a[6] + b[6] * scale13; - out[7] = a[7] + b[7] * scale13; - out[8] = a[8] + b[8] * scale13; - out[9] = a[9] + b[9] * scale13; - out[10] = a[10] + b[10] * scale13; - out[11] = a[11] + b[11] * scale13; - out[12] = a[12] + b[12] * scale13; - out[13] = a[13] + b[13] * scale13; - out[14] = a[14] + b[14] * scale13; - out[15] = a[15] + b[15] * scale13; - return out; -} -function exactEquals8(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; -} -function equals8(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const a4 = a[4]; - const a5 = a[5]; - const a6 = a[6]; - const a7 = a[7]; - const a8 = a[8]; - const a9 = a[9]; - const a10 = a[10]; - const a11 = a[11]; - const a12 = a[12]; - const a13 = a[13]; - const a14 = a[14]; - const a15 = a[15]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - const b3 = b[3]; - const b4 = b[4]; - const b5 = b[5]; - const b6 = b[6]; - const b7 = b[7]; - const b8 = b[8]; - const b9 = b[9]; - const b10 = b[10]; - const b11 = b[11]; - const b12 = b[12]; - const b13 = b[13]; - const b14 = b[14]; - const b15 = b[15]; - return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON2 * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON2 * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON2 * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON2 * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON2 * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON2 * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON2 * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON2 * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON2 * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON2 * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON2 * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON2 * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON2 * Math.max(1, Math.abs(a15), Math.abs(b15)); -} -var mul7 = multiply7; -var sub7 = subtract7; - -// node_modules/@math.gl/web-mercator/node_modules/@math.gl/core/dist/gl-matrix/vec4.js -var vec4_exports2 = {}; -__export(vec4_exports2, { - add: () => add8, - ceil: () => ceil6, - clone: () => clone9, - copy: () => copy8, - create: () => create8, - cross: () => cross6, - dist: () => dist6, - distance: () => distance6, - div: () => div6, - divide: () => divide6, - dot: () => dot6, - equals: () => equals9, - exactEquals: () => exactEquals9, - floor: () => floor6, - forEach: () => forEach7, - fromValues: () => fromValues8, - inverse: () => inverse6, - len: () => len6, - length: () => length6, - lerp: () => lerp7, - max: () => max6, - min: () => min6, - mul: () => mul8, - multiply: () => multiply8, - negate: () => negate6, - normalize: () => normalize6, - random: () => random6, - round: () => round9, - scale: () => scale8, - scaleAndAdd: () => scaleAndAdd6, - set: () => set8, - sqrDist: () => sqrDist6, - sqrLen: () => sqrLen6, - squaredDistance: () => squaredDistance6, - squaredLength: () => squaredLength6, - str: () => str8, - sub: () => sub8, - subtract: () => subtract8, - transformMat4: () => transformMat46, - transformQuat: () => transformQuat4, - zero: () => zero6 -}); -function create8() { - const out = new ARRAY_TYPE2(4); - if (ARRAY_TYPE2 != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; - } - return out; -} -function clone9(a) { - const out = new ARRAY_TYPE2(4); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -function fromValues8(x, y, z, w) { - const out = new ARRAY_TYPE2(4); - out[0] = x; - out[1] = y; - out[2] = z; - out[3] = w; - return out; -} -function copy8(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -function set8(out, x, y, z, w) { - out[0] = x; - out[1] = y; - out[2] = z; - out[3] = w; - return out; -} -function add8(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - return out; -} -function subtract8(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - out[3] = a[3] - b[3]; - return out; -} -function multiply8(out, a, b) { - out[0] = a[0] * b[0]; - out[1] = a[1] * b[1]; - out[2] = a[2] * b[2]; - out[3] = a[3] * b[3]; - return out; -} -function divide6(out, a, b) { - out[0] = a[0] / b[0]; - out[1] = a[1] / b[1]; - out[2] = a[2] / b[2]; - out[3] = a[3] / b[3]; - return out; -} -function ceil6(out, a) { - out[0] = Math.ceil(a[0]); - out[1] = Math.ceil(a[1]); - out[2] = Math.ceil(a[2]); - out[3] = Math.ceil(a[3]); - return out; -} -function floor6(out, a) { - out[0] = Math.floor(a[0]); - out[1] = Math.floor(a[1]); - out[2] = Math.floor(a[2]); - out[3] = Math.floor(a[3]); - return out; -} -function min6(out, a, b) { - out[0] = Math.min(a[0], b[0]); - out[1] = Math.min(a[1], b[1]); - out[2] = Math.min(a[2], b[2]); - out[3] = Math.min(a[3], b[3]); - return out; -} -function max6(out, a, b) { - out[0] = Math.max(a[0], b[0]); - out[1] = Math.max(a[1], b[1]); - out[2] = Math.max(a[2], b[2]); - out[3] = Math.max(a[3], b[3]); - return out; -} -function round9(out, a) { - out[0] = round6(a[0]); - out[1] = round6(a[1]); - out[2] = round6(a[2]); - out[3] = round6(a[3]); - return out; -} -function scale8(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - return out; -} -function scaleAndAdd6(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - out[3] = a[3] + b[3] * scale13; - return out; -} -function distance6(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - const w = b[3] - a[3]; - return Math.sqrt(x * x + y * y + z * z + w * w); -} -function squaredDistance6(a, b) { - const x = b[0] - a[0]; - const y = b[1] - a[1]; - const z = b[2] - a[2]; - const w = b[3] - a[3]; - return x * x + y * y + z * z + w * w; -} -function length6(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return Math.sqrt(x * x + y * y + z * z + w * w); -} -function squaredLength6(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return x * x + y * y + z * z + w * w; -} -function negate6(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - out[2] = -a[2]; - out[3] = -a[3]; - return out; -} -function inverse6(out, a) { - out[0] = 1 / a[0]; - out[1] = 1 / a[1]; - out[2] = 1 / a[2]; - out[3] = 1 / a[3]; - return out; -} -function normalize6(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - let len8 = x * x + y * y + z * z + w * w; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = x * len8; - out[1] = y * len8; - out[2] = z * len8; - out[3] = w * len8; - return out; -} -function dot6(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; -} -function cross6(out, u, v, w) { - const A = v[0] * w[1] - v[1] * w[0]; - const B = v[0] * w[2] - v[2] * w[0]; - const C = v[0] * w[3] - v[3] * w[0]; - const D = v[1] * w[2] - v[2] * w[1]; - const E = v[1] * w[3] - v[3] * w[1]; - const F = v[2] * w[3] - v[3] * w[2]; - const G = u[0]; - const H2 = u[1]; - const I = u[2]; - const J = u[3]; - out[0] = H2 * F - I * E + J * D; - out[1] = -(G * F) + I * C - J * B; - out[2] = G * E - H2 * C + J * A; - out[3] = -(G * D) + H2 * B - I * A; - return out; -} -function lerp7(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - out[2] = az + t * (b[2] - az); - out[3] = aw + t * (b[3] - aw); - return out; -} -function random6(out, scale13) { - scale13 = scale13 === void 0 ? 1 : scale13; - let v1; - let v2; - let v3; - let v4; - let s1; - let s2; - do { - v1 = RANDOM2() * 2 - 1; - v2 = RANDOM2() * 2 - 1; - s1 = v1 * v1 + v2 * v2; - } while (s1 >= 1); - do { - v3 = RANDOM2() * 2 - 1; - v4 = RANDOM2() * 2 - 1; - s2 = v3 * v3 + v4 * v4; - } while (s2 >= 1); - const d = Math.sqrt((1 - s1) / s2); - out[0] = scale13 * v1; - out[1] = scale13 * v2; - out[2] = scale13 * v3 * d; - out[3] = scale13 * v4 * d; - return out; -} -function transformMat46(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; - out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; - out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; - out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; - return out; -} -function transformQuat4(out, a, q) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const ix = qw * x + qy * z - qz * y; - const iy = qw * y + qz * x - qx * z; - const iz = qw * z + qx * y - qy * x; - const iw = -qx * x - qy * y - qz * z; - out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; - out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; - out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; - out[3] = a[3]; - return out; -} -function zero6(out) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; - return out; -} -function str8(a) { - return `vec4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`; -} -function exactEquals9(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; -} -function equals9(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - const b3 = b[3]; - return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON2 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON2 * Math.max(1, Math.abs(a3), Math.abs(b3)); -} -var sub8 = subtract8; -var mul8 = multiply8; -var div6 = divide6; -var dist6 = distance6; -var sqrDist6 = squaredDistance6; -var len6 = length6; -var sqrLen6 = squaredLength6; -var forEach7 = function() { - const vec = create8(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 4; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - vec[3] = a[i + 3]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - a[i + 3] = vec[3]; - } - return a; - }; -}(); - -// node_modules/@math.gl/web-mercator/dist/math-utils.js -function createMat4() { - return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; -} -function transformVector(matrix, vector) { - const result = vec4_exports2.transformMat4([], vector, matrix); - vec4_exports2.scale(result, result, 1 / result[3]); - return result; -} -function mod(value, divisor) { - const modulus = value % divisor; - return modulus < 0 ? divisor + modulus : modulus; -} -function clamp2(x, min7, max7) { - return x < min7 ? min7 : x > max7 ? max7 : x; -} -function ieLog2(x) { - return Math.log(x) * Math.LOG2E; -} -var log22 = Math.log2 || ieLog2; - -// node_modules/@math.gl/web-mercator/dist/assert.js -function assert8(condition, message2) { - if (!condition) { - throw new Error(message2 || "@math.gl/web-mercator: assertion failed."); - } -} - -// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js -var PI = Math.PI; -var PI_4 = PI / 4; -var DEGREES_TO_RADIANS2 = PI / 180; -var RADIANS_TO_DEGREES2 = 180 / PI; -var TILE_SIZE = 512; -var EARTH_CIRCUMFERENCE = 4003e4; -var MAX_LATITUDE = 85.051129; -var DEFAULT_ALTITUDE = 1.5; -function scaleToZoom(scale13) { - return log22(scale13); -} -function lngLatToWorld(lngLat) { - const [lng, lat] = lngLat; - assert8(Number.isFinite(lng)); - assert8(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude"); - const lambda2 = lng * DEGREES_TO_RADIANS2; - const phi2 = lat * DEGREES_TO_RADIANS2; - const x = TILE_SIZE * (lambda2 + PI) / (2 * PI); - const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI); - return [x, y]; -} -function worldToLngLat(xy) { - const [x, y] = xy; - const lambda2 = x / TILE_SIZE * (2 * PI) - PI; - const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4); - return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2]; -} -function getMeterZoom(options) { - const { latitude } = options; - assert8(Number.isFinite(latitude)); - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9; -} -function unitsPerMeter(latitude) { - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - return TILE_SIZE / EARTH_CIRCUMFERENCE / latCosine; -} -function getDistanceScales(options) { - const { latitude, longitude, highPrecision = false } = options; - assert8(Number.isFinite(latitude) && Number.isFinite(longitude)); - const worldSize = TILE_SIZE; - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - const unitsPerDegreeX = worldSize / 360; - const unitsPerDegreeY = unitsPerDegreeX / latCosine; - const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine; - const result = { - unitsPerMeter: [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter], - metersPerUnit: [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter], - unitsPerDegree: [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter], - degreesPerUnit: [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter] - }; - if (highPrecision) { - const latCosine2 = DEGREES_TO_RADIANS2 * Math.tan(latitude * DEGREES_TO_RADIANS2) / latCosine; - const unitsPerDegreeY2 = unitsPerDegreeX * latCosine2 / 2; - const altUnitsPerDegree2 = worldSize / EARTH_CIRCUMFERENCE * latCosine2; - const altUnitsPerMeter2 = altUnitsPerDegree2 / unitsPerDegreeY * altUnitsPerMeter; - result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2]; - result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2]; - } - return result; -} -function addMetersToLngLat(lngLatZ, xyz) { - const [longitude, latitude, z0] = lngLatZ; - const [x, y, z] = xyz; - const { unitsPerMeter: unitsPerMeter2, unitsPerMeter2: unitsPerMeter22 } = getDistanceScales({ - longitude, - latitude, - highPrecision: true - }); - const worldspace = lngLatToWorld(lngLatZ); - worldspace[0] += x * (unitsPerMeter2[0] + unitsPerMeter22[0] * y); - worldspace[1] += y * (unitsPerMeter2[1] + unitsPerMeter22[1] * y); - const newLngLat = worldToLngLat(worldspace); - const newZ = (z0 || 0) + (z || 0); - return Number.isFinite(z0) || Number.isFinite(z) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat; -} -function getViewMatrix(options) { - const { - // Viewport props - height, - pitch, - bearing, - altitude, - // Pre-calculated parameters - scale: scale13, - center - } = options; - const vm = createMat4(); - mat4_exports2.translate(vm, vm, [0, 0, -altitude]); - mat4_exports2.rotateX(vm, vm, -pitch * DEGREES_TO_RADIANS2); - mat4_exports2.rotateZ(vm, vm, bearing * DEGREES_TO_RADIANS2); - const relativeScale = scale13 / height; - mat4_exports2.scale(vm, vm, [relativeScale, relativeScale, relativeScale]); - if (center) { - mat4_exports2.translate(vm, vm, vec3_exports2.negate([], center)); - } - return vm; -} -function getProjectionParameters(options) { - const { width, height, altitude, pitch = 0, offset, center, scale: scale13, nearZMultiplier = 1, farZMultiplier = 1 } = options; - let { fovy = altitudeToFovy(DEFAULT_ALTITUDE) } = options; - if (altitude !== void 0) { - fovy = altitudeToFovy(altitude); - } - const fovRadians = fovy * DEGREES_TO_RADIANS2; - const pitchRadians = pitch * DEGREES_TO_RADIANS2; - const focalDistance = fovyToAltitude(fovy); - let cameraToSeaLevelDistance = focalDistance; - if (center) { - cameraToSeaLevelDistance += center[2] * scale13 / Math.cos(pitchRadians) / height; - } - const fovAboveCenter = fovRadians * (0.5 + (offset ? offset[1] : 0) / height); - const topHalfSurfaceDistance = Math.sin(fovAboveCenter) * cameraToSeaLevelDistance / Math.sin(clamp2(Math.PI / 2 - pitchRadians - fovAboveCenter, 0.01, Math.PI - 0.01)); - const furthestDistance = Math.sin(pitchRadians) * topHalfSurfaceDistance + cameraToSeaLevelDistance; - const horizonDistance = cameraToSeaLevelDistance * 10; - const farZ = Math.min(furthestDistance * farZMultiplier, horizonDistance); - return { - fov: fovRadians, - aspect: width / height, - focalDistance, - near: nearZMultiplier, - far: farZ - }; -} -function altitudeToFovy(altitude) { - return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES2; -} -function fovyToAltitude(fovy) { - return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS2); -} -function worldToPixels(xyz, pixelProjectionMatrix) { - const [x, y, z = 0] = xyz; - assert8(Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)); - return transformVector(pixelProjectionMatrix, [x, y, z, 1]); -} -function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) { - const [x, y, z] = xyz; - assert8(Number.isFinite(x) && Number.isFinite(y), "invalid pixel coordinate"); - if (Number.isFinite(z)) { - const coord = transformVector(pixelUnprojectionMatrix, [x, y, z, 1]); - return coord; - } - const coord0 = transformVector(pixelUnprojectionMatrix, [x, y, 0, 1]); - const coord1 = transformVector(pixelUnprojectionMatrix, [x, y, 1, 1]); - const z0 = coord0[2]; - const z1 = coord1[2]; - const t = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0); - return vec2_exports2.lerp([], coord0, coord1, t); -} - -// node_modules/@math.gl/web-mercator/dist/fit-bounds.js -function fitBounds(options) { - const { - width, - height, - bounds, - minExtent = 0, - // 0.01 would be about 1000 meters (degree is ~110KM) - maxZoom = 24, - // ~x4,000,000 => About 10 meter extents - offset = [0, 0] - } = options; - const [[west, south], [east, north]] = bounds; - const padding = getPaddingObject(options.padding); - const nw = lngLatToWorld([west, clamp2(north, -MAX_LATITUDE, MAX_LATITUDE)]); - const se = lngLatToWorld([east, clamp2(south, -MAX_LATITUDE, MAX_LATITUDE)]); - const size = [ - Math.max(Math.abs(se[0] - nw[0]), minExtent), - Math.max(Math.abs(se[1] - nw[1]), minExtent) - ]; - const targetSize = [ - width - padding.left - padding.right - Math.abs(offset[0]) * 2, - height - padding.top - padding.bottom - Math.abs(offset[1]) * 2 - ]; - assert8(targetSize[0] > 0 && targetSize[1] > 0); - const scaleX2 = targetSize[0] / size[0]; - const scaleY2 = targetSize[1] / size[1]; - const offsetX = (padding.right - padding.left) / 2 / scaleX2; - const offsetY = (padding.top - padding.bottom) / 2 / scaleY2; - const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY]; - const centerLngLat = worldToLngLat(center); - const zoom = Math.min(maxZoom, log22(Math.abs(Math.min(scaleX2, scaleY2)))); - assert8(Number.isFinite(zoom)); - return { - longitude: centerLngLat[0], - latitude: centerLngLat[1], - zoom - }; -} -function getPaddingObject(padding = 0) { - if (typeof padding === "number") { - return { - top: padding, - bottom: padding, - left: padding, - right: padding - }; - } - assert8(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right)); - return padding; -} - -// node_modules/@math.gl/web-mercator/dist/get-bounds.js -var DEGREES_TO_RADIANS3 = Math.PI / 180; -function getBounds(viewport, z = 0) { - const { width, height, unproject } = viewport; - const unprojectOps = { targetZ: z }; - const bottomLeft = unproject([0, height], unprojectOps); - const bottomRight = unproject([width, height], unprojectOps); - let topLeft; - let topRight; - const halfFov = viewport.fovy ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS3 : Math.atan(0.5 / viewport.altitude); - const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS3; - if (halfFov > angleToGround - 0.01) { - topLeft = unprojectOnFarPlane(viewport, 0, z); - topRight = unprojectOnFarPlane(viewport, width, z); - } else { - topLeft = unproject([0, 0], unprojectOps); - topRight = unproject([width, 0], unprojectOps); - } - return [bottomLeft, bottomRight, topRight, topLeft]; -} -function unprojectOnFarPlane(viewport, x, targetZ) { - const { pixelUnprojectionMatrix } = viewport; - const coord0 = transformVector(pixelUnprojectionMatrix, [x, 0, 1, 1]); - const coord1 = transformVector(pixelUnprojectionMatrix, [x, viewport.height, 1, 1]); - const z = targetZ * viewport.distanceScales.unitsPerMeter[2]; - const t = (z - coord0[2]) / (coord1[2] - coord0[2]); - const coord = vec2_exports2.lerp([], coord0, coord1, t); - const result = worldToLngLat(coord); - result.push(targetZ); - return result; -} - -// node_modules/@math.gl/web-mercator/dist/normalize-viewport-props.js -var TILE_SIZE2 = 512; -function normalizeViewportProps(props) { - const { width, height, pitch = 0 } = props; - let { longitude, latitude, zoom, bearing = 0 } = props; - if (longitude < -180 || longitude > 180) { - longitude = mod(longitude + 180, 360) - 180; - } - if (bearing < -180 || bearing > 180) { - bearing = mod(bearing + 180, 360) - 180; - } - const minZoom = log22(height / TILE_SIZE2); - if (zoom <= minZoom) { - zoom = minZoom; - latitude = 0; - } else { - const halfHeightPixels = height / 2 / Math.pow(2, zoom); - const minLatitude = worldToLngLat([0, halfHeightPixels])[1]; - if (latitude < minLatitude) { - latitude = minLatitude; - } else { - const maxLatitude = worldToLngLat([0, TILE_SIZE2 - halfHeightPixels])[1]; - if (latitude > maxLatitude) { - latitude = maxLatitude; - } - } - } - return { width, height, longitude, latitude, zoom, pitch, bearing }; -} - -// node_modules/@deck.gl/core/dist/shaderlib/shadow/shadow.js -var vs4 = ` -const int max_lights = 2; -uniform mat4 shadow_uViewProjectionMatrices[max_lights]; -uniform vec4 shadow_uProjectCenters[max_lights]; -uniform bool shadow_uDrawShadowMap; -uniform bool shadow_uUseShadowMap; -uniform int shadow_uLightId; -uniform float shadow_uLightCount; - -out vec3 shadow_vPosition[max_lights]; - -vec4 shadow_setVertexPosition(vec4 position_commonspace) { - if (shadow_uDrawShadowMap) { - return project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[shadow_uLightId], shadow_uProjectCenters[shadow_uLightId]); - } - if (shadow_uUseShadowMap) { - for (int i = 0; i < max_lights; i++) { - if(i < int(shadow_uLightCount)) { - vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[i], shadow_uProjectCenters[i]); - shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0; - } - } - } - return gl_Position; -} -`; -var fs3 = ` -const int max_lights = 2; -uniform bool shadow_uDrawShadowMap; -uniform bool shadow_uUseShadowMap; -uniform sampler2D shadow_uShadowMap0; -uniform sampler2D shadow_uShadowMap1; -uniform vec4 shadow_uColor; -uniform float shadow_uLightCount; - -in vec3 shadow_vPosition[max_lights]; - -const vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0); -const vec4 bitUnpackShift = 1.0 / bitPackShift; -const vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0); - -float shadow_getShadowWeight(vec3 position, sampler2D shadowMap) { - vec4 rgbaDepth = texture(shadowMap, position.xy); - - float z = dot(rgbaDepth, bitUnpackShift); - return smoothstep(0.001, 0.01, position.z - z); -} - -vec4 shadow_filterShadowColor(vec4 color) { - if (shadow_uDrawShadowMap) { - vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift); - rgbaDepth -= rgbaDepth.gbaa * bitMask; - return rgbaDepth; - } - if (shadow_uUseShadowMap) { - float shadowAlpha = 0.0; - shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0); - if(shadow_uLightCount > 1.0) { - shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1); - } - shadowAlpha *= shadow_uColor.a / shadow_uLightCount; - float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha); - - return vec4( - mix(color.rgb, shadow_uColor.rgb, shadowAlpha / blendedAlpha), - blendedAlpha - ); - } - return color; -} -`; -var getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition); -var getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices); -var DEFAULT_SHADOW_COLOR = [0, 0, 0, 1]; -var VECTOR_TO_POINT_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; -function screenToCommonSpace(xyz, pixelUnprojectionMatrix) { - const [x, y, z] = xyz; - const coord = pixelsToWorld([x, y, z], pixelUnprojectionMatrix); - if (Number.isFinite(z)) { - return coord; - } - return [coord[0], coord[1], 0]; -} -function getViewportCenterPosition({ viewport, center }) { - return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center); -} -function getViewProjectionMatrices({ viewport, shadowMatrices }) { - const projectionMatrices = []; - const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix; - const farZ = viewport.isGeospatial ? void 0 : 1; - const corners = [ - [0, 0, farZ], - // top left ground - [viewport.width, 0, farZ], - // top right ground - [0, viewport.height, farZ], - // bottom left ground - [viewport.width, viewport.height, farZ], - // bottom right ground - [0, 0, -1], - // top left near - [viewport.width, 0, -1], - // top right near - [0, viewport.height, -1], - // bottom left near - [viewport.width, viewport.height, -1] - // bottom right near - ].map((pixel) => ( - // @ts-expect-error z may be undefined - screenToCommonSpace(pixel, pixelUnprojectionMatrix) - )); - for (const shadowMatrix of shadowMatrices) { - const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate()); - const positions = corners.map((corner) => viewMatrix.transform(corner)); - const projectionMatrix = new Matrix4().ortho({ - left: Math.min(...positions.map((position) => position[0])), - right: Math.max(...positions.map((position) => position[0])), - bottom: Math.min(...positions.map((position) => position[1])), - top: Math.max(...positions.map((position) => position[1])), - near: Math.min(...positions.map((position) => -position[2])), - far: Math.max(...positions.map((position) => -position[2])) - }); - projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix)); - } - return projectionMatrices; -} -function createShadowUniforms(opts, context) { - const { shadowEnabled = true } = opts; - if (!shadowEnabled || !opts.shadowMatrices || !opts.shadowMatrices.length) { - return { - shadow_uDrawShadowMap: false, - shadow_uUseShadowMap: false, - shadow_uShadowMap0: opts.dummyShadowMap, - shadow_uShadowMap1: opts.dummyShadowMap - }; - } - const uniforms = { - shadow_uDrawShadowMap: Boolean(opts.drawToShadowMap), - shadow_uUseShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false, - shadow_uColor: opts.shadowColor || DEFAULT_SHADOW_COLOR, - shadow_uLightId: opts.shadowLightId || 0, - shadow_uLightCount: opts.shadowMatrices.length - }; - const center = getMemoizedViewportCenterPosition({ - viewport: opts.viewport, - center: context.project_uCenter - }); - const projectCenters = []; - const viewProjectionMatrices = getMemoizedViewProjectionMatrices({ - shadowMatrices: opts.shadowMatrices, - viewport: opts.viewport - }).slice(); - for (let i = 0; i < opts.shadowMatrices.length; i++) { - const viewProjectionMatrix = viewProjectionMatrices[i]; - const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(opts.viewport.center).negate()); - if (context.project_uCoordinateSystem === COORDINATE_SYSTEM.LNGLAT && context.project_uProjectionMode === PROJECTION_MODE.WEB_MERCATOR) { - viewProjectionMatrices[i] = viewProjectionMatrixCentered; - projectCenters[i] = center; - } else { - viewProjectionMatrices[i] = viewProjectionMatrix.clone().multiplyRight(VECTOR_TO_POINT_MATRIX2); - projectCenters[i] = viewProjectionMatrixCentered.transform(center); - } - } - for (let i = 0; i < viewProjectionMatrices.length; i++) { - uniforms[`shadow_uViewProjectionMatrices[${i}]`] = viewProjectionMatrices[i]; - uniforms[`shadow_uProjectCenters[${i}]`] = projectCenters[i]; - } - for (let i = 0; i < 2; i++) { - uniforms[`shadow_uShadowMap${i}`] = opts.shadowMaps && opts.shadowMaps[i] || opts.dummyShadowMap; - } - return uniforms; -} -var shadow_default = { - name: "shadow", - dependencies: [project_default], - vs: vs4, - fs: fs3, - inject: { - "vs:DECKGL_FILTER_GL_POSITION": ` - position = shadow_setVertexPosition(geometry.position); - `, - "fs:DECKGL_FILTER_COLOR": ` - color = shadow_filterShadowColor(color); - ` - }, - // @ts-expect-error stricter luma gl types - getUniforms: (opts = {}, context = {}) => { - if ("viewport" in opts && (opts.drawToShadowMap || opts.shadowMaps && opts.shadowMaps.length > 0)) { - return createShadowUniforms(opts, context); - } - return {}; - } -}; - -// node_modules/@deck.gl/core/dist/shaderlib/picking/picking.js -var picking_default = { - ...picking, - defaultUniforms: { ...picking.defaultUniforms, useFloatColors: false }, - inject: { - "vs:DECKGL_FILTER_GL_POSITION": ` - // for picking depth values - picking_setPickingAttribute(position.z / position.w); - `, - "vs:DECKGL_FILTER_COLOR": ` - picking_setPickingColor(geometry.pickingColor); - `, - "fs:DECKGL_FILTER_COLOR": { - order: 99, - injection: ` - // use highlight color if this fragment belongs to the selected object. - color = picking_filterHighlightColor(color); - - // use picking color if rendering to picking FBO. - color = picking_filterPickingColor(color); - ` - } - } -}; - -// node_modules/@deck.gl/core/dist/shaderlib/index.js -var DEFAULT_MODULES = [project_default]; -var SHADER_HOOKS = [ - "vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)", - "vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)", - "vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)", - "fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)" -]; -function getShaderAssembler() { - const shaderAssembler = ShaderAssembler.getDefaultShaderAssembler(); - for (const shaderModule of DEFAULT_MODULES) { - shaderAssembler.addDefaultModule(shaderModule); - } - for (const shaderHook of SHADER_HOOKS) { - shaderAssembler.addShaderHook(shaderHook); - } - return shaderAssembler; -} - -// node_modules/@deck.gl/core/dist/effects/lighting/ambient-light.js -var DEFAULT_LIGHT_COLOR = [255, 255, 255]; -var DEFAULT_LIGHT_INTENSITY = 1; -var idCount = 0; -var AmbientLight = class { - constructor(props = {}) { - this.type = "ambient"; - const { color = DEFAULT_LIGHT_COLOR } = props; - const { intensity = DEFAULT_LIGHT_INTENSITY } = props; - this.id = props.id || `ambient-${idCount++}`; - this.color = color; - this.intensity = intensity; - } -}; - -// node_modules/@deck.gl/core/dist/effects/lighting/directional-light.js -var DEFAULT_LIGHT_COLOR2 = [255, 255, 255]; -var DEFAULT_LIGHT_INTENSITY2 = 1; -var DEFAULT_LIGHT_DIRECTION = [0, 0, -1]; -var idCount2 = 0; -var DirectionalLight = class { - constructor(props = {}) { - this.type = "directional"; - const { color = DEFAULT_LIGHT_COLOR2 } = props; - const { intensity = DEFAULT_LIGHT_INTENSITY2 } = props; - const { direction = DEFAULT_LIGHT_DIRECTION } = props; - const { _shadow = false } = props; - this.id = props.id || `directional-${idCount2++}`; - this.color = color; - this.intensity = intensity; - this.type = "directional"; - this.direction = new Vector3(direction).normalize().toArray(); - this.shadow = _shadow; - } - getProjectedLight(opts) { - return this; - } -}; - -// node_modules/@deck.gl/core/dist/passes/pass.js -var Pass = class { - /** Create a new Pass instance */ - constructor(device, props = { id: "pass" }) { - const { id } = props; - this.id = id; - this.device = device; - this.props = { ...props }; - } - setProps(props) { - Object.assign(this.props, props); - } - render(params) { - } - // eslint-disable-line @typescript-eslint/no-empty-function - cleanup() { - } - // eslint-disable-line @typescript-eslint/no-empty-function -}; - -// node_modules/@deck.gl/core/dist/passes/layers-pass.js -var LayersPass = class extends Pass { - constructor() { - super(...arguments); - this._lastRenderIndex = -1; - } - render(options) { - const [width, height] = this.device.canvasContext.getDrawingBufferSize(); - const clearCanvas = options.clearCanvas ?? true; - const clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false); - const clearDepth = clearCanvas ? 1 : false; - const clearStencil = clearCanvas ? 0 : false; - const colorMask = options.colorMask ?? 15; - const parameters = { viewport: [0, 0, width, height] }; - if (options.colorMask) { - parameters.colorMask = colorMask; - } - if (options.scissorRect) { - parameters.scissorRect = options.scissorRect; - } - const renderPass = this.device.beginRenderPass({ - framebuffer: options.target, - parameters, - clearColor, - clearDepth, - clearStencil - }); - try { - return this._drawLayers(renderPass, options); - } finally { - renderPass.end(); - } - } - /** Draw a list of layers in a list of viewports */ - _drawLayers(renderPass, options) { - const { target, moduleParameters, viewports, views, onViewportActive, clearStack = true } = options; - options.pass = options.pass || "unknown"; - if (clearStack) { - this._lastRenderIndex = -1; - } - const renderStats = []; - for (const viewport of viewports) { - const view = views && views[viewport.id]; - onViewportActive?.(viewport); - const drawLayerParams = this._getDrawLayerParams(viewport, options); - const subViewports = viewport.subViewports || [viewport]; - for (const subViewport of subViewports) { - const stats = this._drawLayersInViewport(renderPass, { - target, - moduleParameters, - viewport: subViewport, - view, - pass: options.pass, - layers: options.layers - }, drawLayerParams); - renderStats.push(stats); - } - } - return renderStats; - } - // When a viewport contains multiple subviewports (e.g. repeated web mercator map), - // this is only done once for the parent viewport - /* Resolve the parameters needed to draw each layer */ - _getDrawLayerParams(viewport, { layers, pass, isPicking = false, layerFilter, cullRect, effects, moduleParameters }, evaluateShouldDrawOnly = false) { - const drawLayerParams = []; - const indexResolver = layerIndexResolver(this._lastRenderIndex + 1); - const drawContext = { - layer: layers[0], - viewport, - isPicking, - renderPass: pass, - cullRect - }; - const layerFilterCache = {}; - for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { - const layer = layers[layerIndex]; - const shouldDrawLayer = this._shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache); - const layerParam = { - shouldDrawLayer - }; - if (shouldDrawLayer && !evaluateShouldDrawOnly) { - layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer); - layerParam.moduleParameters = this._getModuleParameters(layer, effects, pass, moduleParameters); - layerParam.layerParameters = { - ...layer.context.deck?.props.parameters, - ...this.getLayerParameters(layer, layerIndex, viewport) - }; - } - drawLayerParams[layerIndex] = layerParam; - } - return drawLayerParams; - } - // Draws a list of layers in one viewport - // TODO - when picking we could completely skip rendering viewports that dont - // intersect with the picking rect - /* eslint-disable max-depth, max-statements */ - _drawLayersInViewport(renderPass, { layers, moduleParameters: globalModuleParameters, pass, target, viewport, view }, drawLayerParams) { - const glViewport = getGLViewport(this.device, { - moduleParameters: globalModuleParameters, - target, - viewport - }); - if (view && view.props.clear) { - const clearOpts = view.props.clear === true ? { color: true, depth: true } : view.props.clear; - this.device.withParametersWebGL({ - scissorTest: true, - scissor: glViewport - }, () => this.device.clearWebGL(clearOpts)); - } - const renderStatus = { - totalCount: layers.length, - visibleCount: 0, - compositeCount: 0, - pickableCount: 0 - }; - renderPass.setParameters({ viewport: glViewport }); - for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { - const layer = layers[layerIndex]; - const { shouldDrawLayer, layerRenderIndex, moduleParameters, layerParameters } = drawLayerParams[layerIndex]; - if (shouldDrawLayer && layer.props.pickable) { - renderStatus.pickableCount++; - } - if (layer.isComposite) { - renderStatus.compositeCount++; - } else if (shouldDrawLayer) { - renderStatus.visibleCount++; - this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex); - moduleParameters.viewport = viewport; - layer.context.renderPass = renderPass; - try { - layer._drawLayer({ - renderPass, - moduleParameters, - uniforms: { layerIndex: layerRenderIndex }, - parameters: layerParameters - }); - } catch (err) { - layer.raiseError(err, `drawing ${layer} to ${pass}`); - } - } - } - return renderStatus; - } - /* eslint-enable max-depth, max-statements */ - /* Methods for subclass overrides */ - shouldDrawLayer(layer) { - return true; - } - getModuleParameters(layer, effects) { - return null; - } - getLayerParameters(layer, layerIndex, viewport) { - return layer.props.parameters; - } - /* Private */ - _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) { - const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer); - if (!shouldDrawLayer) { - return false; - } - drawContext.layer = layer; - let parent = layer.parent; - while (parent) { - if (!parent.props.visible || !parent.filterSubLayer(drawContext)) { - return false; - } - drawContext.layer = parent; - parent = parent.parent; - } - if (layerFilter) { - const rootLayerId = drawContext.layer.id; - if (!(rootLayerId in layerFilterCache)) { - layerFilterCache[rootLayerId] = layerFilter(drawContext); - } - if (!layerFilterCache[rootLayerId]) { - return false; - } - } - layer.activateViewport(drawContext.viewport); - return true; - } - _getModuleParameters(layer, effects, pass, overrides) { - const devicePixelRatio = this.device.canvasContext.cssToDeviceRatio(); - const moduleParameters = Object.assign(Object.create(layer.internalState?.propsInTransition || layer.props), { - autoWrapLongitude: layer.wrapLongitude, - viewport: layer.context.viewport, - mousePosition: layer.context.mousePosition, - picking: { - isActive: 0 - }, - devicePixelRatio - }); - if (effects) { - for (const effect of effects) { - Object.assign(moduleParameters, effect.getModuleParameters?.(layer)); - } - } - return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides); - } -}; -function layerIndexResolver(startIndex = 0, layerIndices = {}) { - const resolvers = {}; - const resolveLayerIndex = (layer, isDrawn) => { - const indexOverride = layer.props._offset; - const layerId = layer.id; - const parentId = layer.parent && layer.parent.id; - let index2; - if (parentId && !(parentId in layerIndices)) { - resolveLayerIndex(layer.parent, false); - } - if (parentId in resolvers) { - const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices); - index2 = resolver(layer, isDrawn); - resolvers[layerId] = resolver; - } else if (Number.isFinite(indexOverride)) { - index2 = indexOverride + (layerIndices[parentId] || 0); - resolvers[layerId] = null; - } else { - index2 = startIndex; - } - if (isDrawn && index2 >= startIndex) { - startIndex = index2 + 1; - } - layerIndices[layerId] = index2; - return index2; - }; - return resolveLayerIndex; -} -function getGLViewport(device, { moduleParameters, target, viewport }) { - const pixelRatio = moduleParameters && moduleParameters.devicePixelRatio || // @ts-expect-error TODO - assuming WebGL context - device.canvasContext.cssToDeviceRatio(); - const [, drawingBufferHeight] = device.canvasContext.getDrawingBufferSize(); - const height = target ? target.height : drawingBufferHeight; - const dimensions = viewport; - return [ - dimensions.x * pixelRatio, - height - (dimensions.y + dimensions.height) * pixelRatio, - dimensions.width * pixelRatio, - dimensions.height * pixelRatio - ]; -} - -// node_modules/@deck.gl/core/dist/passes/shadow-pass.js -var ShadowPass = class extends LayersPass { - constructor(device, props) { - super(device, props); - this.shadowMap = device.createTexture({ - width: 1, - height: 1, - sampler: { - minFilter: "linear", - magFilter: "linear", - addressModeU: "clamp-to-edge", - addressModeV: "clamp-to-edge" - } - }); - this.depthBuffer = device.createTexture({ - format: "depth16unorm", - width: 1, - height: 1, - mipmaps: false, - // TODO fix getWebGLTextureParameters() in luma to avoid passing deprecated parameters - dataFormat: 6402, - // gl.DEPTH_COMPONENT - type: 5125 - // gl.UNSIGNED_INT - }); - this.fbo = device.createFramebuffer({ - id: "shadowmap", - width: 1, - height: 1, - colorAttachments: [this.shadowMap], - // Depth attachment has to be specified for depth test to work - depthStencilAttachment: this.depthBuffer - }); - } - render(params) { - const target = this.fbo; - const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); - const viewport = params.viewports[0]; - const width = viewport.width * pixelRatio; - const height = viewport.height * pixelRatio; - const clearColor = [1, 1, 1, 1]; - if (width !== target.width || height !== target.height) { - target.resize({ width, height }); - } - super.render({ ...params, clearColor, target, pass: "shadow" }); - } - getLayerParameters(layer, layerIndex, viewport) { - return { ...layer.props.parameters, blend: false, depthRange: [0, 1], depthTest: true }; - } - shouldDrawLayer(layer) { - return layer.props.shadowEnabled !== false; - } - getModuleParameters() { - return { - drawToShadowMap: true - }; - } - delete() { - if (this.fbo) { - this.fbo.destroy(); - this.fbo = null; - } - if (this.shadowMap) { - this.shadowMap.destroy(); - this.shadowMap = null; - } - if (this.depthBuffer) { - this.depthBuffer.destroy(); - this.depthBuffer = null; - } - } -}; - -// node_modules/@deck.gl/core/dist/effects/lighting/lighting-effect.js -var DEFAULT_AMBIENT_LIGHT_PROPS = { color: [255, 255, 255], intensity: 1 }; -var DEFAULT_DIRECTIONAL_LIGHT_PROPS = [ - { - color: [255, 255, 255], - intensity: 1, - direction: [-1, 3, -1] - }, - { - color: [255, 255, 255], - intensity: 0.9, - direction: [1, -8, -2.5] - } -]; -var DEFAULT_SHADOW_COLOR2 = [0, 0, 0, 200 / 255]; -var LightingEffect = class { - constructor(props = {}) { - this.id = "lighting-effect"; - this.shadowColor = DEFAULT_SHADOW_COLOR2; - this.shadow = false; - this.ambientLight = null; - this.directionalLights = []; - this.pointLights = []; - this.shadowPasses = []; - this.shadowMaps = []; - this.dummyShadowMap = null; - this.setProps(props); - } - setup(context) { - this.context = context; - const { device, deck } = context; - if (this.shadow && !this.dummyShadowMap) { - this._createShadowPasses(device); - deck._addDefaultShaderModule(shadow_default); - this.dummyShadowMap = device.createTexture({ - width: 1, - height: 1 - }); - } - } - setProps(props) { - this.ambientLight = null; - this.directionalLights = []; - this.pointLights = []; - for (const key in props) { - const lightSource = props[key]; - switch (lightSource.type) { - case "ambient": - this.ambientLight = lightSource; - break; - case "directional": - this.directionalLights.push(lightSource); - break; - case "point": - this.pointLights.push(lightSource); - break; - default: - } - } - this._applyDefaultLights(); - this.shadow = this.directionalLights.some((light) => light.shadow); - if (this.context) { - this.setup(this.context); - } - this.props = props; - } - preRender({ layers, layerFilter, viewports, onViewportActive, views }) { - if (!this.shadow) - return; - this.shadowMatrices = this._calculateMatrices(); - for (let i = 0; i < this.shadowPasses.length; i++) { - const shadowPass = this.shadowPasses[i]; - shadowPass.render({ - layers, - layerFilter, - viewports, - onViewportActive, - views, - moduleParameters: { - shadowLightId: i, - dummyShadowMap: this.dummyShadowMap, - shadowMatrices: this.shadowMatrices - } - }); - } - } - getModuleParameters(layer) { - const parameters = this.shadow ? { - shadowMaps: this.shadowMaps, - dummyShadowMap: this.dummyShadowMap, - shadowColor: this.shadowColor, - shadowMatrices: this.shadowMatrices - } : {}; - parameters.lightSources = { - ambientLight: this.ambientLight, - directionalLights: this.directionalLights.map((directionalLight) => directionalLight.getProjectedLight({ layer })), - pointLights: this.pointLights.map((pointLight) => pointLight.getProjectedLight({ layer })) - }; - return parameters; - } - cleanup(context) { - for (const shadowPass of this.shadowPasses) { - shadowPass.delete(); - } - this.shadowPasses.length = 0; - this.shadowMaps.length = 0; - if (this.dummyShadowMap) { - this.dummyShadowMap.destroy(); - this.dummyShadowMap = null; - context.deck._removeDefaultShaderModule(shadow_default); - } - } - _calculateMatrices() { - const lightMatrices = []; - for (const light of this.directionalLights) { - const viewMatrix = new Matrix4().lookAt({ - eye: new Vector3(light.direction).negate() - }); - lightMatrices.push(viewMatrix); - } - return lightMatrices; - } - _createShadowPasses(device) { - for (let i = 0; i < this.directionalLights.length; i++) { - const shadowPass = new ShadowPass(device); - this.shadowPasses[i] = shadowPass; - this.shadowMaps[i] = shadowPass.shadowMap; - } - } - _applyDefaultLights() { - const { ambientLight, pointLights, directionalLights } = this; - if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) { - this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS); - this.directionalLights.push(new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]), new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1])); - } - } -}; - -// node_modules/@deck.gl/core/dist/utils/typed-array-manager.js -var TypedArrayManager = class { - constructor(options = {}) { - this._pool = []; - this.opts = { overAlloc: 2, poolSize: 100 }; - this.setOptions(options); - } - setOptions(options) { - Object.assign(this.opts, options); - } - allocate(typedArray, count2, { size = 1, type, padding = 0, copy: copy12 = false, initialize = false, maxCount }) { - const Type2 = type || typedArray && typedArray.constructor || Float32Array; - const newSize = count2 * size + padding; - if (ArrayBuffer.isView(typedArray)) { - if (newSize <= typedArray.length) { - return typedArray; - } - if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) { - return new Type2(typedArray.buffer, 0, newSize); - } - } - let maxSize = Infinity; - if (maxCount) { - maxSize = maxCount * size + padding; - } - const newArray = this._allocate(Type2, newSize, initialize, maxSize); - if (typedArray && copy12) { - newArray.set(typedArray); - } else if (!initialize) { - newArray.fill(0, 0, 4); - } - this._release(typedArray); - return newArray; - } - release(typedArray) { - this._release(typedArray); - } - _allocate(Type2, size, initialize, maxSize) { - let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1); - if (sizeToAllocate > maxSize) { - sizeToAllocate = maxSize; - } - const pool = this._pool; - const byteLength = Type2.BYTES_PER_ELEMENT * sizeToAllocate; - const i = pool.findIndex((b) => b.byteLength >= byteLength); - if (i >= 0) { - const array = new Type2(pool.splice(i, 1)[0], 0, sizeToAllocate); - if (initialize) { - array.fill(0); - } - return array; - } - return new Type2(sizeToAllocate); - } - _release(typedArray) { - if (!ArrayBuffer.isView(typedArray)) { - return; - } - const pool = this._pool; - const { buffer } = typedArray; - const { byteLength } = buffer; - const i = pool.findIndex((b) => b.byteLength >= byteLength); - if (i < 0) { - pool.push(buffer); - } else if (i > 0 || pool.length < this.opts.poolSize) { - pool.splice(i, 0, buffer); - } - if (pool.length > this.opts.poolSize) { - pool.shift(); - } - } -}; -var typed_array_manager_default = new TypedArrayManager(); - -// node_modules/@deck.gl/core/dist/utils/math-utils.js -function createMat42() { - return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; -} -function getCameraPosition(viewMatrixInverse) { - return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]]; -} -function getFrustumPlanes(viewProjectionMatrix) { - return { - left: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[0], viewProjectionMatrix[7] + viewProjectionMatrix[4], viewProjectionMatrix[11] + viewProjectionMatrix[8], viewProjectionMatrix[15] + viewProjectionMatrix[12]), - right: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[0], viewProjectionMatrix[7] - viewProjectionMatrix[4], viewProjectionMatrix[11] - viewProjectionMatrix[8], viewProjectionMatrix[15] - viewProjectionMatrix[12]), - bottom: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[1], viewProjectionMatrix[7] + viewProjectionMatrix[5], viewProjectionMatrix[11] + viewProjectionMatrix[9], viewProjectionMatrix[15] + viewProjectionMatrix[13]), - top: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[1], viewProjectionMatrix[7] - viewProjectionMatrix[5], viewProjectionMatrix[11] - viewProjectionMatrix[9], viewProjectionMatrix[15] - viewProjectionMatrix[13]), - near: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[2], viewProjectionMatrix[7] + viewProjectionMatrix[6], viewProjectionMatrix[11] + viewProjectionMatrix[10], viewProjectionMatrix[15] + viewProjectionMatrix[14]), - far: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[2], viewProjectionMatrix[7] - viewProjectionMatrix[6], viewProjectionMatrix[11] - viewProjectionMatrix[10], viewProjectionMatrix[15] - viewProjectionMatrix[14]) - }; -} -var scratchVector = new Vector3(); -function getFrustumPlane(a, b, c, d) { - scratchVector.set(a, b, c); - const L = scratchVector.len(); - return { distance: d / L, normal: new Vector3(-a / L, -b / L, -c / L) }; -} -function fp64LowPart2(x) { - return x - Math.fround(x); -} -var scratchArray; -function toDoublePrecisionArray(typedArray, options) { - const { size = 1, startIndex = 0 } = options; - const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length; - const count2 = (endIndex - startIndex) / size; - scratchArray = typed_array_manager_default.allocate(scratchArray, count2, { - type: Float32Array, - size: size * 2 - }); - let sourceIndex = startIndex; - let targetIndex = 0; - while (sourceIndex < endIndex) { - for (let j = 0; j < size; j++) { - const value = typedArray[sourceIndex++]; - scratchArray[targetIndex + j] = value; - scratchArray[targetIndex + j + size] = fp64LowPart2(value); - } - targetIndex += size * 2; - } - return scratchArray.subarray(0, count2 * size * 2); -} -function mergeBounds(boundsList) { - let mergedBounds = null; - let isMerged = false; - for (const bounds of boundsList) { - if (!bounds) - continue; - if (!mergedBounds) { - mergedBounds = bounds; - } else { - if (!isMerged) { - mergedBounds = [ - [mergedBounds[0][0], mergedBounds[0][1]], - [mergedBounds[1][0], mergedBounds[1][1]] - ]; - isMerged = true; - } - mergedBounds[0][0] = Math.min(mergedBounds[0][0], bounds[0][0]); - mergedBounds[0][1] = Math.min(mergedBounds[0][1], bounds[0][1]); - mergedBounds[1][0] = Math.max(mergedBounds[1][0], bounds[1][0]); - mergedBounds[1][1] = Math.max(mergedBounds[1][1], bounds[1][1]); - } - } - return mergedBounds; -} - -// node_modules/@deck.gl/core/dist/viewports/viewport.js -var DEGREES_TO_RADIANS4 = Math.PI / 180; -var IDENTITY2 = createMat42(); -var ZERO_VECTOR2 = [0, 0, 0]; -var DEFAULT_DISTANCE_SCALES = { - unitsPerMeter: [1, 1, 1], - metersPerUnit: [1, 1, 1] -}; -function createProjectionMatrix({ width, height, orthographic, fovyRadians, focalDistance, padding, near, far }) { - const aspect = width / height; - const matrix = orthographic ? new Matrix4().orthographic({ fovy: fovyRadians, aspect, focalDistance, near, far }) : new Matrix4().perspective({ fovy: fovyRadians, aspect, near, far }); - if (padding) { - const { left = 0, right = 0, top = 0, bottom = 0 } = padding; - const offsetX = clamp((left + width - right) / 2, 0, width) - width / 2; - const offsetY = clamp((top + height - bottom) / 2, 0, height) - height / 2; - matrix[8] -= offsetX * 2 / width; - matrix[9] += offsetY * 2 / height; - } - return matrix; -} -var Viewport = class _Viewport { - // eslint-disable-next-line complexity - constructor(opts = {}) { - this._frustumPlanes = {}; - this.id = opts.id || this.constructor.displayName || "viewport"; - this.x = opts.x || 0; - this.y = opts.y || 0; - this.width = opts.width || 1; - this.height = opts.height || 1; - this.zoom = opts.zoom || 0; - this.padding = opts.padding; - this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES; - this.focalDistance = opts.focalDistance || 1; - this.position = opts.position || ZERO_VECTOR2; - this.modelMatrix = opts.modelMatrix || null; - const { longitude, latitude } = opts; - this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude); - this._initProps(opts); - this._initMatrices(opts); - this.equals = this.equals.bind(this); - this.project = this.project.bind(this); - this.unproject = this.unproject.bind(this); - this.projectPosition = this.projectPosition.bind(this); - this.unprojectPosition = this.unprojectPosition.bind(this); - this.projectFlat = this.projectFlat.bind(this); - this.unprojectFlat = this.unprojectFlat.bind(this); - } - get subViewports() { - return null; - } - get metersPerPixel() { - return this.distanceScales.metersPerUnit[2] / this.scale; - } - get projectionMode() { - if (this.isGeospatial) { - return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET; - } - return PROJECTION_MODE.IDENTITY; - } - // Two viewports are equal if width and height are identical, and if - // their view and projection matrices are (approximately) equal. - equals(viewport) { - if (!(viewport instanceof _Viewport)) { - return false; - } - if (this === viewport) { - return true; - } - return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix); - } - /** - * Projects xyz (possibly latitude and longitude) to pixel coordinates in window - * using viewport projection parameters - * - [longitude, latitude] to [x, y] - * - [longitude, latitude, Z] => [x, y, z] - * Note: By default, returns top-left coordinates for canvas/SVG type render - * - * @param {Array} lngLatZ - [lng, lat] or [lng, lat, Z] - * @param {Object} opts - options - * @param {Object} opts.topLeft=true - Whether projected coords are top left - * @return {Array} - [x, y] or [x, y, z] in top left coords - */ - project(xyz, { topLeft = true } = {}) { - const worldPosition = this.projectPosition(xyz); - const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix); - const [x, y] = coord; - const y2 = topLeft ? y : this.height - y; - return xyz.length === 2 ? [x, y2] : [x, y2, coord[2]]; - } - /** - * Unproject pixel coordinates on screen onto world coordinates, - * (possibly [lon, lat]) on map. - * - [x, y] => [lng, lat] - * - [x, y, z] => [lng, lat, Z] - * @param {Array} xyz - - * @param {Object} opts - options - * @param {Object} opts.topLeft=true - Whether origin is top left - * @return {Array|null} - [lng, lat, Z] or [X, Y, Z] - */ - unproject(xyz, { topLeft = true, targetZ } = {}) { - const [x, y, z] = xyz; - const y2 = topLeft ? y : this.height - y; - const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2]; - const coord = pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix, targetZWorld); - const [X, Y, Z] = this.unprojectPosition(coord); - if (Number.isFinite(z)) { - return [X, Y, Z]; - } - return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; - } - // NON_LINEAR PROJECTION HOOKS - // Used for web meractor projection - projectPosition(xyz) { - const [X, Y] = this.projectFlat(xyz); - const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2]; - return [X, Y, Z]; - } - unprojectPosition(xyz) { - const [X, Y] = this.unprojectFlat(xyz); - const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2]; - return [X, Y, Z]; - } - /** - * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile. - * Performs the nonlinear part of the web mercator projection. - * Remaining projection is done with 4x4 matrices which also handles - * perspective. - * @param {Array} lngLat - [lng, lat] coordinates - * Specifies a point on the sphere to project onto the map. - * @return {Array} [x,y] coordinates. - */ - projectFlat(xyz) { - if (this.isGeospatial) { - const result = lngLatToWorld(xyz); - result[1] = clamp(result[1], -318, 830); - return result; - } - return xyz; - } - /** - * Unproject world point [x,y] on map onto {lat, lon} on sphere - * @param {object|Vector} xy - object with {x,y} members - * representing point on projected map plane - * @return {GeoCoordinates} - object with {lat,lon} of point on sphere. - * Has toArray method if you need a GeoJSON Array. - * Per cartographic tradition, lat and lon are specified as degrees. - */ - unprojectFlat(xyz) { - if (this.isGeospatial) { - return worldToLngLat(xyz); - } - return xyz; - } - /** - * Get bounds of the current viewport - * @return {Array} - [minX, minY, maxX, maxY] - */ - getBounds(options = {}) { - const unprojectOption = { targetZ: options.z || 0 }; - const topLeft = this.unproject([0, 0], unprojectOption); - const topRight = this.unproject([this.width, 0], unprojectOption); - const bottomLeft = this.unproject([0, this.height], unprojectOption); - const bottomRight = this.unproject([this.width, this.height], unprojectOption); - return [ - Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), - Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), - Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), - Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]) - ]; - } - getDistanceScales(coordinateOrigin) { - if (coordinateOrigin) { - return getDistanceScales({ - longitude: coordinateOrigin[0], - latitude: coordinateOrigin[1], - highPrecision: true - }); - } - return this.distanceScales; - } - containsPixel({ x, y, width = 1, height = 1 }) { - return x < this.x + this.width && this.x < x + width && y < this.y + this.height && this.y < y + height; - } - // Extract frustum planes in common space - getFrustumPlanes() { - if (this._frustumPlanes.near) { - return this._frustumPlanes; - } - Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix)); - return this._frustumPlanes; - } - // EXPERIMENTAL METHODS - /** - * Needed by panning and linear transition - * Pan the viewport to place a given world coordinate at screen point [x, y] - * - * @param {Array} coords - world coordinates - * @param {Array} pixel - [x,y] coordinates on screen - * @return {Object} props of the new viewport - */ - panByPosition(coords, pixel) { - return null; - } - // INTERNAL METHODS - /* eslint-disable complexity, max-statements */ - _initProps(opts) { - const longitude = opts.longitude; - const latitude = opts.latitude; - if (this.isGeospatial) { - if (!Number.isFinite(opts.zoom)) { - this.zoom = getMeterZoom({ latitude }) + Math.log2(this.focalDistance); - } - this.distanceScales = opts.distanceScales || getDistanceScales({ latitude, longitude }); - } - const scale13 = Math.pow(2, this.zoom); - this.scale = scale13; - const { position, modelMatrix } = opts; - let meterOffset = ZERO_VECTOR2; - if (position) { - meterOffset = modelMatrix ? new Matrix4(modelMatrix).transformAsVector(position, []) : position; - } - if (this.isGeospatial) { - const center = this.projectPosition([longitude, latitude, 0]); - this.center = new Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center); - } else { - this.center = this.projectPosition(meterOffset); - } - } - /* eslint-enable complexity, max-statements */ - _initMatrices(opts) { - const { - // View matrix - viewMatrix = IDENTITY2, - // Projection matrix - projectionMatrix = null, - // Projection matrix parameters, used if projectionMatrix not supplied - orthographic = false, - fovyRadians, - fovy = 75, - near = 0.1, - // Distance of near clipping plane - far = 1e3, - // Distance of far clipping plane - padding = null, - // Center offset in pixels - focalDistance = 1 - } = opts; - this.viewMatrixUncentered = viewMatrix; - this.viewMatrix = new Matrix4().multiplyRight(viewMatrix).translate(new Vector3(this.center).negate()); - this.projectionMatrix = projectionMatrix || createProjectionMatrix({ - width: this.width, - height: this.height, - orthographic, - fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS4, - focalDistance, - padding, - near, - far - }); - const vpm = createMat42(); - mat4_exports.multiply(vpm, vpm, this.projectionMatrix); - mat4_exports.multiply(vpm, vpm, this.viewMatrix); - this.viewProjectionMatrix = vpm; - this.viewMatrixInverse = mat4_exports.invert([], this.viewMatrix) || this.viewMatrix; - this.cameraPosition = getCameraPosition(this.viewMatrixInverse); - const viewportMatrix = createMat42(); - const pixelProjectionMatrix = createMat42(); - mat4_exports.scale(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]); - mat4_exports.translate(viewportMatrix, viewportMatrix, [1, -1, 0]); - mat4_exports.multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix); - this.pixelProjectionMatrix = pixelProjectionMatrix; - this.pixelUnprojectionMatrix = mat4_exports.invert(createMat42(), this.pixelProjectionMatrix); - if (!this.pixelUnprojectionMatrix) { - log_default.warn("Pixel project matrix not invertible")(); - } - } -}; -Viewport.displayName = "Viewport"; -var viewport_default = Viewport; - -// node_modules/@deck.gl/core/dist/viewports/web-mercator-viewport.js -var WebMercatorViewport2 = class _WebMercatorViewport extends viewport_default { - /* eslint-disable complexity, max-statements */ - constructor(opts = {}) { - const { - latitude = 0, - longitude = 0, - zoom = 0, - pitch = 0, - bearing = 0, - nearZMultiplier = 0.1, - farZMultiplier = 1.01, - nearZ, - farZ, - orthographic = false, - projectionMatrix, - repeat = false, - worldOffset = 0, - position, - padding, - // backward compatibility - // TODO: remove in v9 - legacyMeterSizes = false - } = opts; - let { width, height, altitude = 1.5 } = opts; - const scale13 = Math.pow(2, zoom); - width = width || 1; - height = height || 1; - let fovy; - let projectionParameters = null; - if (projectionMatrix) { - altitude = projectionMatrix[5] / 2; - fovy = altitudeToFovy(altitude); - } else { - if (opts.fovy) { - fovy = opts.fovy; - altitude = fovyToAltitude(fovy); - } else { - fovy = altitudeToFovy(altitude); - } - let offset; - if (padding) { - const { top = 0, bottom = 0 } = padding; - offset = [0, clamp((top + height - bottom) / 2, 0, height) - height / 2]; - } - projectionParameters = getProjectionParameters({ - width, - height, - scale: scale13, - center: position && [0, 0, position[2] * unitsPerMeter(latitude)], - offset, - pitch, - fovy, - nearZMultiplier, - farZMultiplier - }); - if (Number.isFinite(nearZ)) { - projectionParameters.near = nearZ; - } - if (Number.isFinite(farZ)) { - projectionParameters.far = farZ; - } - } - let viewMatrixUncentered = getViewMatrix({ - height, - pitch, - bearing, - scale: scale13, - altitude - }); - if (worldOffset) { - const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]); - viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered); - } - super({ - ...opts, - // x, y, - width, - height, - // view matrix - viewMatrix: viewMatrixUncentered, - longitude, - latitude, - zoom, - // projection matrix parameters - ...projectionParameters, - fovy, - focalDistance: altitude - }); - this.latitude = latitude; - this.longitude = longitude; - this.zoom = zoom; - this.pitch = pitch; - this.bearing = bearing; - this.altitude = altitude; - this.fovy = fovy; - this.orthographic = orthographic; - this._subViewports = repeat ? [] : null; - this._pseudoMeters = legacyMeterSizes; - Object.freeze(this); - } - /* eslint-enable complexity, max-statements */ - get subViewports() { - if (this._subViewports && !this._subViewports.length) { - const bounds = this.getBounds(); - const minOffset = Math.floor((bounds[0] + 180) / 360); - const maxOffset = Math.ceil((bounds[2] - 180) / 360); - for (let x = minOffset; x <= maxOffset; x++) { - const offsetViewport = x ? new _WebMercatorViewport({ - ...this, - worldOffset: x - }) : this; - this._subViewports.push(offsetViewport); - } - } - return this._subViewports; - } - projectPosition(xyz) { - if (this._pseudoMeters) { - return super.projectPosition(xyz); - } - const [X, Y] = this.projectFlat(xyz); - const Z = (xyz[2] || 0) * unitsPerMeter(xyz[1]); - return [X, Y, Z]; - } - unprojectPosition(xyz) { - if (this._pseudoMeters) { - return super.unprojectPosition(xyz); - } - const [X, Y] = this.unprojectFlat(xyz); - const Z = (xyz[2] || 0) / unitsPerMeter(Y); - return [X, Y, Z]; - } - /** - * Add a meter delta to a base lnglat coordinate, returning a new lnglat array - * - * Note: Uses simple linear approximation around the viewport center - * Error increases with size of offset (roughly 1% per 100km) - * - * @param {[Number,Number]|[Number,Number,Number]) lngLatZ - base coordinate - * @param {[Number,Number]|[Number,Number,Number]) xyz - array of meter deltas - * @return {[Number,Number]|[Number,Number,Number]) array of [lng,lat,z] deltas - */ - addMetersToLngLat(lngLatZ, xyz) { - return addMetersToLngLat(lngLatZ, xyz); - } - panByPosition(coords, pixel) { - const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix); - const toLocation = this.projectFlat(coords); - const translate5 = vec2_exports.add([], toLocation, vec2_exports.negate([], fromLocation)); - const newCenter = vec2_exports.add([], this.center, translate5); - const [longitude, latitude] = this.unprojectFlat(newCenter); - return { longitude, latitude }; - } - getBounds(options = {}) { - const corners = getBounds(this, options.z || 0); - return [ - Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), - Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]), - Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), - Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1]) - ]; - } - /** - * Returns a new viewport that fit around the given rectangle. - * Only supports non-perspective mode. - */ - fitBounds(bounds, options = {}) { - const { width, height } = this; - const { longitude, latitude, zoom } = fitBounds({ width, height, bounds, ...options }); - return new _WebMercatorViewport({ width, height, longitude, latitude, zoom }); - } -}; -WebMercatorViewport2.displayName = "WebMercatorViewport"; -var web_mercator_viewport_default = WebMercatorViewport2; - -// node_modules/@deck.gl/core/dist/shaderlib/project/project-functions.js -var DEFAULT_COORDINATE_ORIGIN2 = [0, 0, 0]; -function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) { - const p = viewport.projectPosition(lngLatZ); - if (offsetMode && viewport instanceof web_mercator_viewport_default) { - const [longitude, latitude, z = 0] = lngLatZ; - const distanceScales = viewport.getDistanceScales([longitude, latitude]); - p[2] = z * distanceScales.unitsPerMeter[2]; - } - return p; -} -function normalizeParameters(opts) { - const { viewport, modelMatrix, coordinateOrigin } = opts; - let { coordinateSystem, fromCoordinateSystem, fromCoordinateOrigin } = opts; - if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { - coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; - } - if (fromCoordinateSystem === void 0) { - fromCoordinateSystem = coordinateSystem; - } - if (fromCoordinateOrigin === void 0) { - fromCoordinateOrigin = coordinateOrigin; - } - return { - viewport, - coordinateSystem, - coordinateOrigin, - modelMatrix, - fromCoordinateSystem, - fromCoordinateOrigin - }; -} -function getWorldPosition(position, { viewport, modelMatrix, coordinateSystem, coordinateOrigin, offsetMode }) { - let [x, y, z = 0] = position; - if (modelMatrix) { - [x, y, z] = vec4_exports.transformMat4([], [x, y, z, 1], modelMatrix); - } - switch (coordinateSystem) { - case COORDINATE_SYSTEM.LNGLAT: - return lngLatZToWorldPosition([x, y, z], viewport, offsetMode); - case COORDINATE_SYSTEM.LNGLAT_OFFSETS: - return lngLatZToWorldPosition([x + coordinateOrigin[0], y + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)], viewport, offsetMode); - case COORDINATE_SYSTEM.METER_OFFSETS: - return lngLatZToWorldPosition(addMetersToLngLat(coordinateOrigin, [x, y, z]), viewport, offsetMode); - case COORDINATE_SYSTEM.CARTESIAN: - default: - return viewport.isGeospatial ? [x + coordinateOrigin[0], y + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x, y, z]); - } -} -function projectPosition(position, params) { - const { viewport, coordinateSystem, coordinateOrigin, modelMatrix, fromCoordinateSystem, fromCoordinateOrigin } = normalizeParameters(params); - const { autoOffset = true } = params; - const { geospatialOrigin = DEFAULT_COORDINATE_ORIGIN2, shaderCoordinateOrigin = DEFAULT_COORDINATE_ORIGIN2, offsetMode = false } = autoOffset ? getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin) : {}; - const worldPosition = getWorldPosition(position, { - viewport, - modelMatrix, - coordinateSystem: fromCoordinateSystem, - coordinateOrigin: fromCoordinateOrigin, - offsetMode - }); - if (offsetMode) { - const positionCommonSpace = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); - vec3_exports.sub(worldPosition, worldPosition, positionCommonSpace); - } - return worldPosition; -} - -// node_modules/@luma.gl/engine/dist/animation/timeline.js -var channelHandles = 1; -var animationHandles = 1; -var Timeline = class { - time = 0; - channels = /* @__PURE__ */ new Map(); - animations = /* @__PURE__ */ new Map(); - playing = false; - lastEngineTime = -1; - constructor() { - } - addChannel(props) { - const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props; - const channelId = channelHandles++; - const channel = { - time: 0, - delay, - duration, - rate, - repeat - }; - this._setChannelTime(channel, this.time); - this.channels.set(channelId, channel); - return channelId; - } - removeChannel(channelId) { - this.channels.delete(channelId); - for (const [animationHandle, animation] of this.animations) { - if (animation.channel === channelId) { - this.detachAnimation(animationHandle); - } - } - } - isFinished(channelId) { - const channel = this.channels.get(channelId); - if (channel === void 0) { - return false; - } - return this.time >= channel.delay + channel.duration * channel.repeat; - } - getTime(channelId) { - if (channelId === void 0) { - return this.time; - } - const channel = this.channels.get(channelId); - if (channel === void 0) { - return -1; - } - return channel.time; - } - setTime(time) { - this.time = Math.max(0, time); - const channels = this.channels.values(); - for (const channel of channels) { - this._setChannelTime(channel, this.time); - } - const animations = this.animations.values(); - for (const animationData of animations) { - const { animation, channel } = animationData; - animation.setTime(this.getTime(channel)); - } - } - play() { - this.playing = true; - } - pause() { - this.playing = false; - this.lastEngineTime = -1; - } - reset() { - this.setTime(0); - } - attachAnimation(animation, channelHandle) { - const animationHandle = animationHandles++; - this.animations.set(animationHandle, { - animation, - channel: channelHandle - }); - animation.setTime(this.getTime(channelHandle)); - return animationHandle; - } - detachAnimation(channelId) { - this.animations.delete(channelId); - } - update(engineTime) { - if (this.playing) { - if (this.lastEngineTime === -1) { - this.lastEngineTime = engineTime; - } - this.setTime(this.time + (engineTime - this.lastEngineTime)); - this.lastEngineTime = engineTime; - } - } - _setChannelTime(channel, time) { - const offsetTime = time - channel.delay; - const totalDuration = channel.duration * channel.repeat; - if (offsetTime >= totalDuration) { - channel.time = channel.duration * channel.rate; - } else { - channel.time = Math.max(0, offsetTime) % channel.duration; - channel.time *= channel.rate; - } - } -}; - -// node_modules/@luma.gl/engine/dist/animation-loop/animation-loop.js -var statIdCounter = 0; -var DEFAULT_ANIMATION_LOOP_PROPS = { - device: null, - onAddHTML: () => "", - onInitialize: async () => { - return null; - }, - onRender: () => { - }, - onFinalize: () => { - }, - onError: (error) => console.error(error), - // eslint-disable-line no-console - stats: luma.stats.get(`animation-loop-${statIdCounter++}`), - // view parameters - useDevicePixels: true, - autoResizeViewport: false, - autoResizeDrawingBuffer: false -}; -var AnimationLoop = class { - device = null; - canvas = null; - props; - animationProps = null; - timeline = null; - stats; - cpuTime; - gpuTime; - frameRate; - display; - needsRedraw = "initialized"; - _initialized = false; - _running = false; - _animationFrameId = null; - _nextFramePromise = null; - _resolveNextFrame = null; - _cpuStartTime = 0; - // _gpuTimeQuery: Query | null = null; - /* - * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context - */ - constructor(props) { - this.props = { ...DEFAULT_ANIMATION_LOOP_PROPS, ...props }; - props = this.props; - if (!props.device) { - throw new Error("No device provided"); - } - const { useDevicePixels = true } = this.props; - this.stats = props.stats || new Stats({ id: "animation-loop-stats" }); - this.cpuTime = this.stats.get("CPU Time"); - this.gpuTime = this.stats.get("GPU Time"); - this.frameRate = this.stats.get("Frame Rate"); - this.setProps({ - autoResizeViewport: props.autoResizeViewport, - autoResizeDrawingBuffer: props.autoResizeDrawingBuffer, - useDevicePixels - }); - this.start = this.start.bind(this); - this.stop = this.stop.bind(this); - this._onMousemove = this._onMousemove.bind(this); - this._onMouseleave = this._onMouseleave.bind(this); - } - destroy() { - this.stop(); - this._setDisplay(null); - } - /** @deprecated Use .destroy() */ - delete() { - this.destroy(); - } - /** Flags this animation loop as needing redraw */ - setNeedsRedraw(reason) { - this.needsRedraw = this.needsRedraw || reason; - return this; - } - /** TODO - move these props to CanvasContext? */ - setProps(props) { - if ("autoResizeViewport" in props) { - this.props.autoResizeViewport = props.autoResizeViewport || false; - } - if ("autoResizeDrawingBuffer" in props) { - this.props.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer || false; - } - if ("useDevicePixels" in props) { - this.props.useDevicePixels = props.useDevicePixels || false; - } - return this; - } - /** Starts a render loop if not already running */ - async start() { - if (this._running) { - return this; - } - this._running = true; - try { - let appContext; - if (!this._initialized) { - this._initialized = true; - await this._initDevice(); - this._initialize(); - await this.props.onInitialize(this._getAnimationProps()); - } - if (!this._running) { - return null; - } - if (appContext !== false) { - this._cancelAnimationFrame(); - this._requestAnimationFrame(); - } - return this; - } catch (err) { - const error = err instanceof Error ? err : new Error("Unknown error"); - this.props.onError(error); - throw error; - } - } - /** Stops a render loop if already running, finalizing */ - stop() { - if (this._running) { - if (this.animationProps) { - this.props.onFinalize(this.animationProps); - } - this._cancelAnimationFrame(); - this._nextFramePromise = null; - this._resolveNextFrame = null; - this._running = false; - } - return this; - } - /** Explicitly draw a frame */ - redraw() { - if (this.device?.isLost) { - return this; - } - this._beginFrameTimers(); - this._setupFrame(); - this._updateAnimationProps(); - this._renderFrame(this._getAnimationProps()); - this._clearNeedsRedraw(); - if (this._resolveNextFrame) { - this._resolveNextFrame(this); - this._nextFramePromise = null; - this._resolveNextFrame = null; - } - this._endFrameTimers(); - return this; - } - /** Add a timeline, it will be automatically updated by the animation loop. */ - attachTimeline(timeline) { - this.timeline = timeline; - return this.timeline; - } - /** Remove a timeline */ - detachTimeline() { - this.timeline = null; - } - /** Wait until a render completes */ - waitForRender() { - this.setNeedsRedraw("waitForRender"); - if (!this._nextFramePromise) { - this._nextFramePromise = new Promise((resolve2) => { - this._resolveNextFrame = resolve2; - }); - } - return this._nextFramePromise; - } - /** TODO - should use device.deviceContext */ - async toDataURL() { - this.setNeedsRedraw("toDataURL"); - await this.waitForRender(); - if (this.canvas instanceof HTMLCanvasElement) { - return this.canvas.toDataURL(); - } - throw new Error("OffscreenCanvas"); - } - // PRIVATE METHODS - _initialize() { - this._startEventHandling(); - this._initializeAnimationProps(); - this._updateAnimationProps(); - this._resizeCanvasDrawingBuffer(); - this._resizeViewport(); - } - _setDisplay(display) { - if (this.display) { - this.display.destroy(); - this.display.animationLoop = null; - } - if (display) { - display.animationLoop = this; - } - this.display = display; - } - _requestAnimationFrame() { - if (!this._running) { - return; - } - this._animationFrameId = requestAnimationFrame2(this._animationFrame.bind(this)); - } - _cancelAnimationFrame() { - if (this._animationFrameId === null) { - return; - } - cancelAnimationFrame2(this._animationFrameId); - this._animationFrameId = null; - } - _animationFrame() { - if (!this._running) { - return; - } - this.redraw(); - this._requestAnimationFrame(); - } - // Called on each frame, can be overridden to call onRender multiple times - // to support e.g. stereoscopic rendering - _renderFrame(animationProps) { - if (this.display) { - this.display._renderFrame(animationProps); - return; - } - this.props.onRender(this._getAnimationProps()); - this.device.submit(); - } - _clearNeedsRedraw() { - this.needsRedraw = false; - } - _setupFrame() { - this._resizeCanvasDrawingBuffer(); - this._resizeViewport(); - } - // Initialize the object that will be passed to app callbacks - _initializeAnimationProps() { - if (!this.device) { - throw new Error("loop"); - } - this.animationProps = { - animationLoop: this, - device: this.device, - canvas: this.device?.canvasContext?.canvas, - timeline: this.timeline, - // Initial values - useDevicePixels: this.props.useDevicePixels, - needsRedraw: false, - // Placeholders - width: 1, - height: 1, - aspect: 1, - // Animation props - time: 0, - startTime: Date.now(), - engineTime: 0, - tick: 0, - tock: 0, - // Experimental - _mousePosition: null - // Event props - }; - } - _getAnimationProps() { - if (!this.animationProps) { - throw new Error("animationProps"); - } - return this.animationProps; - } - // Update the context object that will be passed to app callbacks - _updateAnimationProps() { - if (!this.animationProps) { - return; - } - const { width, height, aspect } = this._getSizeAndAspect(); - if (width !== this.animationProps.width || height !== this.animationProps.height) { - this.setNeedsRedraw("drawing buffer resized"); - } - if (aspect !== this.animationProps.aspect) { - this.setNeedsRedraw("drawing buffer aspect changed"); - } - this.animationProps.width = width; - this.animationProps.height = height; - this.animationProps.aspect = aspect; - this.animationProps.needsRedraw = this.needsRedraw; - this.animationProps.engineTime = Date.now() - this.animationProps.startTime; - if (this.timeline) { - this.timeline.update(this.animationProps.engineTime); - } - this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60); - this.animationProps.tock++; - this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime; - } - /** Wait for supplied device */ - async _initDevice() { - this.device = await this.props.device; - if (!this.device) { - throw new Error("No device provided"); - } - this.canvas = this.device.canvasContext?.canvas || null; - } - _createInfoDiv() { - if (this.canvas && this.props.onAddHTML) { - const wrapperDiv = document.createElement("div"); - document.body.appendChild(wrapperDiv); - wrapperDiv.style.position = "relative"; - const div7 = document.createElement("div"); - div7.style.position = "absolute"; - div7.style.left = "10px"; - div7.style.bottom = "10px"; - div7.style.width = "300px"; - div7.style.background = "white"; - if (this.canvas instanceof HTMLCanvasElement) { - wrapperDiv.appendChild(this.canvas); - } - wrapperDiv.appendChild(div7); - const html = this.props.onAddHTML(div7); - if (html) { - div7.innerHTML = html; - } - } - } - _getSizeAndAspect() { - if (!this.device) { - return { width: 1, height: 1, aspect: 1 }; - } - const [width, height] = this.device?.canvasContext?.getPixelSize() || [1, 1]; - let aspect = 1; - const canvas2 = this.device?.canvasContext?.canvas; - if (canvas2 && canvas2.clientHeight) { - aspect = canvas2.clientWidth / canvas2.clientHeight; - } else if (width > 0 && height > 0) { - aspect = width / height; - } - return { width, height, aspect }; - } - /** Default viewport setup */ - _resizeViewport() { - if (this.props.autoResizeViewport && this.device.gl) { - this.device.gl.viewport( - 0, - 0, - // @ts-expect-error Expose canvasContext - this.device.gl.drawingBufferWidth, - // @ts-expect-error Expose canvasContext - this.device.gl.drawingBufferHeight - ); - } - } - /** - * Resize the render buffer of the canvas to match canvas client size - * Optionally multiplying with devicePixel ratio - */ - _resizeCanvasDrawingBuffer() { - if (this.props.autoResizeDrawingBuffer) { - this.device?.canvasContext?.resize({ useDevicePixels: this.props.useDevicePixels }); - } - } - _beginFrameTimers() { - this.frameRate.timeEnd(); - this.frameRate.timeStart(); - this.cpuTime.timeStart(); - } - _endFrameTimers() { - this.cpuTime.timeEnd(); - } - // Event handling - _startEventHandling() { - if (this.canvas) { - this.canvas.addEventListener("mousemove", this._onMousemove.bind(this)); - this.canvas.addEventListener("mouseleave", this._onMouseleave.bind(this)); - } - } - _onMousemove(event) { - if (event instanceof MouseEvent) { - this._getAnimationProps()._mousePosition = [event.offsetX, event.offsetY]; - } - } - _onMouseleave(event) { - this._getAnimationProps()._mousePosition = null; - } -}; - -// node_modules/@luma.gl/engine/dist/geometry/gpu-geometry.js -var GPUGeometry = class { - id; - userData = {}; - /** Determines how vertices are read from the 'vertex' attributes */ - topology; - bufferLayout = []; - vertexCount; - indices; - attributes; - constructor(props) { - this.id = props.id || uid("geometry"); - this.topology = props.topology; - this.indices = props.indices || null; - this.attributes = props.attributes; - this.vertexCount = props.vertexCount; - this.bufferLayout = props.bufferLayout || []; - if (this.indices) { - assert6(this.indices.usage === Buffer2.INDEX); - } - } - destroy() { - this.indices?.destroy(); - for (const attribute of Object.values(this.attributes)) { - attribute.destroy(); - } - } - getVertexCount() { - return this.vertexCount; - } - getAttributes() { - return this.attributes; - } - getIndexes() { - return this.indices; - } - _calculateVertexCount(positions) { - const vertexCount = positions.byteLength / 12; - return vertexCount; - } -}; -function makeGPUGeometry(device, geometry) { - if (geometry instanceof GPUGeometry) { - return geometry; - } - const indices = getIndexBufferFromGeometry(device, geometry); - const { attributes, bufferLayout } = getAttributeBuffersFromGeometry(device, geometry); - return new GPUGeometry({ - topology: geometry.topology || "triangle-list", - bufferLayout, - vertexCount: geometry.vertexCount, - indices, - attributes - }); -} -function getIndexBufferFromGeometry(device, geometry) { - if (!geometry.indices) { - return void 0; - } - const data = geometry.indices.value; - return device.createBuffer({ usage: Buffer2.INDEX, data }); -} -function getAttributeBuffersFromGeometry(device, geometry) { - const bufferLayout = []; - const attributes = {}; - for (const [attributeName, attribute] of Object.entries(geometry.attributes)) { - let name2 = attributeName; - switch (attributeName) { - case "POSITION": - name2 = "positions"; - break; - case "NORMAL": - name2 = "normals"; - break; - case "TEXCOORD_0": - name2 = "texCoords"; - break; - case "COLOR_0": - name2 = "colors"; - break; - } - attributes[name2] = device.createBuffer({ data: attribute.value, id: `${attributeName}-buffer` }); - const { value, size, normalized } = attribute; - bufferLayout.push({ name: name2, format: getVertexFormatFromAttribute(value, size, normalized) }); - } - const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices); - return { attributes, bufferLayout, vertexCount }; -} - -// node_modules/@luma.gl/engine/dist/shader-inputs.js -var ShaderInputs = class { - /** - * The map of modules - * @todo should should this include the resolved dependencies? - */ - modules; - /** Stores the uniform values for each module */ - moduleUniforms; - /** Stores the uniform bindings for each module */ - moduleBindings; - /** Tracks if uniforms have changed */ - moduleUniformsChanged; - /** - * Create a new UniformStore instance - * @param modules - */ - constructor(modules) { - const resolvedModules = resolveModules(Object.values(modules).filter((module) => module.dependencies)); - for (const resolvedModule of resolvedModules) { - modules[resolvedModule.name] = resolvedModule; - } - log2.log(1, "Creating ShaderInputs with modules", Object.keys(modules))(); - this.modules = modules; - this.moduleUniforms = {}; - this.moduleBindings = {}; - for (const [name2, module] of Object.entries(modules)) { - const moduleName = name2; - this.moduleUniforms[moduleName] = module.defaultUniforms || {}; - this.moduleBindings[moduleName] = {}; - } - } - /** Destroy */ - destroy() { - } - /** - * Set module props - */ - setProps(props) { - for (const name2 of Object.keys(props)) { - const moduleName = name2; - const moduleProps = props[moduleName]; - const module = this.modules[moduleName]; - if (!module) { - log2.warn(`Module ${name2} not found`)(); - continue; - } - const oldUniforms = this.moduleUniforms[moduleName]; - const oldBindings = this.moduleBindings[moduleName]; - const uniformsAndBindings = module.getUniforms?.(moduleProps, oldUniforms) || moduleProps; - const { uniforms, bindings } = splitUniformsAndBindings(uniformsAndBindings); - this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms }; - this.moduleBindings[moduleName] = { ...oldBindings, ...bindings }; - } - } - /** Merges all bindings for the shader (from the various modules) */ - // getUniformBlocks(): Record { - // return this.moduleUniforms; - // } - /** - * Return the map of modules - * @todo should should this include the resolved dependencies? - */ - getModules() { - return Object.values(this.modules); - } - /** Get all uniform values for all modules */ - getUniformValues() { - return this.moduleUniforms; - } - /** Merges all bindings for the shader (from the various modules) */ - getBindings() { - const bindings = {}; - for (const moduleBindings of Object.values(this.moduleBindings)) { - Object.assign(bindings, moduleBindings); - } - return bindings; - } - getDebugTable() { - const table = {}; - for (const [moduleName, module] of Object.entries(this.moduleUniforms)) { - for (const [key, value] of Object.entries(module)) { - table[`${moduleName}.${key}`] = { - type: this.modules[moduleName].uniformTypes?.[key], - value: String(value) - }; - } - } - return table; - } -}; - -// node_modules/@luma.gl/engine/dist/lib/pipeline-factory.js -var PipelineFactory = class _PipelineFactory { - static defaultProps = { ...RenderPipeline.defaultProps }; - device; - _hashCounter = 0; - _hashes = {}; - _renderPipelineCache = {}; - _computePipelineCache = {}; - /** Get the singleton default pipeline factory for the specified device */ - static getDefaultPipelineFactory(device) { - device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new _PipelineFactory(device); - return device._lumaData.defaultPipelineFactory; - } - constructor(device) { - this.device = device; - } - /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */ - createRenderPipeline(props) { - const allProps = { ...RenderPipeline.defaultProps, ...props }; - const hash = this._hashRenderPipeline(allProps); - if (!this._renderPipelineCache[hash]) { - const pipeline = this.device.createRenderPipeline({ - ...allProps, - id: allProps.id ? `${allProps.id}-cached` : void 0 - }); - pipeline.hash = hash; - this._renderPipelineCache[hash] = { pipeline, useCount: 0 }; - } - this._renderPipelineCache[hash].useCount++; - return this._renderPipelineCache[hash].pipeline; - } - createComputePipeline(props) { - const allProps = { ...ComputePipeline.defaultProps, ...props }; - const hash = this._hashComputePipeline(allProps); - if (!this._computePipelineCache[hash]) { - const pipeline = this.device.createComputePipeline({ - ...allProps, - id: allProps.id ? `${allProps.id}-cached` : void 0 - }); - pipeline.hash = hash; - this._computePipelineCache[hash] = { pipeline, useCount: 0 }; - } - this._computePipelineCache[hash].useCount++; - return this._computePipelineCache[hash].pipeline; - } - release(pipeline) { - const hash = pipeline.hash; - const cache3 = pipeline instanceof ComputePipeline ? this._computePipelineCache : this._renderPipelineCache; - cache3[hash].useCount--; - if (cache3[hash].useCount === 0) { - cache3[hash].pipeline.destroy(); - delete cache3[hash]; - } - } - // PRIVATE - _hashComputePipeline(props) { - const shaderHash = this._getHash(props.shader.source); - return `${shaderHash}`; - } - /** Calculate a hash based on all the inputs for a render pipeline */ - _hashRenderPipeline(props) { - const vsHash = this._getHash(props.vs.source); - const fsHash = props.fs ? this._getHash(props.fs.source) : 0; - const varyingHash = "-"; - const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout)); - switch (this.device.type) { - case "webgl": - return `${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`; - default: - const parameterHash = this._getHash(JSON.stringify(props.parameters)); - return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}`; - } - } - _getHash(key) { - if (this._hashes[key] === void 0) { - this._hashes[key] = this._hashCounter++; - } - return this._hashes[key]; - } -}; - -// node_modules/@luma.gl/engine/dist/lib/shader-factory.js -var ShaderFactory = class _ShaderFactory { - static defaultProps = { ...Shader.defaultProps }; - device; - _cache = {}; - /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */ - static getDefaultShaderFactory(device) { - device._lumaData.defaultShaderFactory ||= new _ShaderFactory(device); - return device._lumaData.defaultShaderFactory; - } - /** @internal */ - constructor(device) { - this.device = device; - } - /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */ - createShader(props) { - const key = this._hashShader(props); - let cacheEntry = this._cache[key]; - if (!cacheEntry) { - const shader = this.device.createShader({ - ...props, - id: props.id ? `${props.id}-cached` : void 0 - }); - this._cache[key] = cacheEntry = { shader, useCount: 0 }; - } - cacheEntry.useCount++; - return cacheEntry.shader; - } - /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */ - release(shader) { - const key = this._hashShader(shader); - const cacheEntry = this._cache[key]; - if (cacheEntry) { - cacheEntry.useCount--; - if (cacheEntry.useCount === 0) { - delete this._cache[key]; - cacheEntry.shader.destroy(); - } - } - } - // PRIVATE - _hashShader(value) { - return `${value.stage}:${value.source}`; - } -}; - -// node_modules/@luma.gl/engine/dist/debug/debug-shader-layout.js -function getDebugTableForShaderLayout(layout, name2) { - const table = {}; - const header = "Values"; - if (layout.attributes.length === 0 && !layout.varyings?.length) { - return { "No attributes or varyings": { [header]: "N/A" } }; - } - for (const attributeDeclaration of layout.attributes) { - if (attributeDeclaration) { - const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`; - table[`in ${glslDeclaration}`] = { [header]: attributeDeclaration.stepMode || "vertex" }; - } - } - for (const varyingDeclaration of layout.varyings || []) { - const glslDeclaration = `${varyingDeclaration.location} ${varyingDeclaration.name}`; - table[`out ${glslDeclaration}`] = { [header]: JSON.stringify(varyingDeclaration.accessor) }; - } - return table; -} - -// node_modules/@luma.gl/engine/dist/debug/debug-framebuffer.js -var canvas = null; -var ctx = null; -function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgbaScale = 1 }) { - if (!canvas) { - canvas = document.createElement("canvas"); - canvas.id = id; - canvas.title = id; - canvas.style.zIndex = "100"; - canvas.style.position = "absolute"; - canvas.style.top = top; - canvas.style.left = left; - canvas.style.border = "blue 1px solid"; - canvas.style.transform = "scaleY(-1)"; - document.body.appendChild(canvas); - ctx = canvas.getContext("2d"); - } - if (canvas.width !== fbo.width || canvas.height !== fbo.height) { - canvas.width = fbo.width / 2; - canvas.height = fbo.height / 2; - canvas.style.width = "400px"; - canvas.style.height = "400px"; - } - const color = fbo.device.readPixelsToArrayWebGL(fbo); - const imageData = ctx.createImageData(fbo.width, fbo.height); - const offset = 0; - for (let i = 0; i < color.length; i += 4) { - imageData.data[offset + i + 0] = color[i + 0] * rgbaScale; - imageData.data[offset + i + 1] = color[i + 1] * rgbaScale; - imageData.data[offset + i + 2] = color[i + 2] * rgbaScale; - imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale; - } - ctx.putImageData(imageData, 0, 0); -} - -// node_modules/@luma.gl/engine/dist/model/model.js -var LOG_DRAW_PRIORITY = 2; -var LOG_DRAW_TIMEOUT = 1e4; -var Model = class _Model { - static defaultProps = { - ...RenderPipeline.defaultProps, - source: null, - vs: null, - fs: null, - id: "unnamed", - handle: void 0, - userData: {}, - defines: {}, - modules: [], - moduleSettings: void 0, - geometry: null, - indexBuffer: null, - attributes: {}, - constantAttributes: {}, - varyings: [], - isInstanced: void 0, - instanceCount: 0, - vertexCount: 0, - shaderInputs: void 0, - pipelineFactory: void 0, - shaderFactory: void 0, - transformFeedback: void 0, - shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(), - debugShaders: void 0, - disableWarnings: void 0 - }; - device; - id; - source; - vs; - fs; - pipelineFactory; - shaderFactory; - userData = {}; - // Fixed properties (change can trigger pipeline rebuild) - /** The render pipeline GPU parameters, depth testing etc */ - parameters; - /** The primitive topology */ - topology; - /** Buffer layout */ - bufferLayout; - // Dynamic properties - /** Use instanced rendering */ - isInstanced = void 0; - /** instance count. `undefined` means not instanced */ - instanceCount = 0; - /** Vertex count */ - vertexCount; - /** Index buffer */ - indexBuffer = null; - /** Buffer-valued attributes */ - bufferAttributes = {}; - /** Constant-valued attributes */ - constantAttributes = {}; - /** Bindings (textures, samplers, uniform buffers) */ - bindings = {}; - /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/ - uniforms = {}; - /** - * VertexArray - * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt! - * @todo - allow application to define multiple vertex arrays? - * */ - vertexArray; - /** TransformFeedback, WebGL 2 only. */ - transformFeedback = null; - /** The underlying GPU "program". @note May be recreated if parameters change */ - pipeline; - /** ShaderInputs instance */ - shaderInputs; - _uniformStore; - _attributeInfos = {}; - _gpuGeometry = null; - _getModuleUniforms; - props; - _pipelineNeedsUpdate = "newly created"; - _needsRedraw = "initializing"; - _destroyed = false; - /** "Time" of last draw. Monotonically increasing timestamp */ - _lastDrawTimestamp = -1; - constructor(device, props) { - this.props = { ..._Model.defaultProps, ...props }; - props = this.props; - this.id = props.id || uid("model"); - this.device = device; - Object.assign(this.userData, props.userData); - const moduleMap = Object.fromEntries(this.props.modules?.map((module) => [module.name, module]) || []); - this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap)); - const platformInfo = getPlatformInfo(device); - const modules = (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || []; - const isWebGPU = this.device.type === "webgpu"; - if (isWebGPU && this.props.source) { - this.props.shaderLayout ||= getShaderLayoutFromWGSL(this.props.source); - const { source, getUniforms: getUniforms6 } = this.props.shaderAssembler.assembleShader({ - platformInfo, - ...this.props, - modules - }); - this.source = source; - this._getModuleUniforms = getUniforms6; - } else { - const { vs: vs7, fs: fs5, getUniforms: getUniforms6 } = this.props.shaderAssembler.assembleShaderPair({ - platformInfo, - ...this.props, - modules - }); - this.vs = vs7; - this.fs = fs5; - this._getModuleUniforms = getUniforms6; - } - this.vertexCount = this.props.vertexCount; - this.instanceCount = this.props.instanceCount; - this.topology = this.props.topology; - this.bufferLayout = this.props.bufferLayout; - this.parameters = this.props.parameters; - if (props.geometry) { - this.setGeometry(props.geometry); - } - this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device); - this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device); - this.pipeline = this._updatePipeline(); - this.vertexArray = device.createVertexArray({ - renderPipeline: this.pipeline - }); - if (this._gpuGeometry) { - this._setGeometryAttributes(this._gpuGeometry); - } - if ("isInstanced" in props) { - this.isInstanced = props.isInstanced; - } - if (props.instanceCount) { - this.setInstanceCount(props.instanceCount); - } - if (props.vertexCount) { - this.setVertexCount(props.vertexCount); - } - if (props.indexBuffer) { - this.setIndexBuffer(props.indexBuffer); - } - if (props.attributes) { - this.setAttributes(props.attributes); - } - if (props.constantAttributes) { - this.setConstantAttributes(props.constantAttributes); - } - if (props.bindings) { - this.setBindings(props.bindings); - } - if (props.uniforms) { - this.setUniforms(props.uniforms); - } - if (props.moduleSettings) { - this.updateModuleSettings(props.moduleSettings); - } - if (props.transformFeedback) { - this.transformFeedback = props.transformFeedback; - } - Object.seal(this); - } - destroy() { - if (this._destroyed) - return; - this.pipelineFactory.release(this.pipeline); - this.shaderFactory.release(this.pipeline.vs); - if (this.pipeline.fs) { - this.shaderFactory.release(this.pipeline.fs); - } - this._uniformStore.destroy(); - this._gpuGeometry?.destroy(); - this._destroyed = true; - } - // Draw call - /** Query redraw status. Clears the status. */ - needsRedraw() { - if (this._getBindingsUpdateTimestamp() > this._lastDrawTimestamp) { - this.setNeedsRedraw("contents of bound textures or buffers updated"); - } - const needsRedraw = this._needsRedraw; - this._needsRedraw = false; - return needsRedraw; - } - /** Mark the model as needing a redraw */ - setNeedsRedraw(reason) { - this._needsRedraw ||= reason; - } - predraw() { - this.updateShaderInputs(); - this.pipeline = this._updatePipeline(); - } - draw(renderPass) { - this.predraw(); - let drawSuccess; - try { - this._logDrawCallStart(); - this.pipeline = this._updatePipeline(); - this.pipeline.setBindings(this.bindings, { disableWarnings: this.props.disableWarnings }); - if (!isObjectEmpty(this.uniforms)) { - this.pipeline.setUniformsWebGL(this.uniforms); - } - const { indexBuffer } = this.vertexArray; - const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0; - drawSuccess = this.pipeline.draw({ - renderPass, - vertexArray: this.vertexArray, - isInstanced: this.isInstanced, - vertexCount: this.vertexCount, - instanceCount: this.instanceCount, - indexCount, - transformFeedback: this.transformFeedback || void 0, - // WebGL shares underlying cached pipelines even for models that have different parameters and topology, - // so we must provide our unique parameters to each draw - // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call) - parameters: this.parameters, - topology: this.topology - }); - } finally { - this._logDrawCallEnd(); - } - this._logFramebuffer(renderPass); - if (drawSuccess) { - this._lastDrawTimestamp = this.device.timestamp; - this._needsRedraw = false; - } else { - this._needsRedraw = "waiting for resource initialization"; - } - return drawSuccess; - } - // Update fixed fields (can trigger pipeline rebuild) - /** - * Updates the optional geometry - * Geometry, set topology and bufferLayout - * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU - */ - setGeometry(geometry) { - this._gpuGeometry?.destroy(); - const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry); - if (gpuGeometry) { - this.setTopology(gpuGeometry.topology || "triangle-list"); - this.bufferLayout = mergeBufferLayouts(gpuGeometry.bufferLayout, this.bufferLayout); - if (this.vertexArray) { - this._setGeometryAttributes(gpuGeometry); - } - } - this._gpuGeometry = gpuGeometry; - } - /** - * Updates the primitive topology ('triangle-list', 'triangle-strip' etc). - * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU - */ - setTopology(topology) { - if (topology !== this.topology) { - this.topology = topology; - this._setPipelineNeedsUpdate("topology"); - } - } - /** - * Updates the buffer layout. - * @note Triggers a pipeline rebuild / pipeline cache fetch - */ - setBufferLayout(bufferLayout) { - this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout; - this._setPipelineNeedsUpdate("bufferLayout"); - this.pipeline = this._updatePipeline(); - this.vertexArray = this.device.createVertexArray({ - renderPipeline: this.pipeline - }); - if (this._gpuGeometry) { - this._setGeometryAttributes(this._gpuGeometry); - } - } - /** - * Set GPU parameters. - * @note Can trigger a pipeline rebuild / pipeline cache fetch. - * @param parameters - */ - setParameters(parameters) { - if (!deepEqual(parameters, this.parameters, 2)) { - this.parameters = parameters; - this._setPipelineNeedsUpdate("parameters"); - } - } - // Update dynamic fields - /** - * Updates the instance count (used in draw calls) - * @note Any attributes with stepMode=instance need to be at least this big - */ - setInstanceCount(instanceCount) { - this.instanceCount = instanceCount; - if (this.isInstanced === void 0 && instanceCount > 0) { - this.isInstanced = true; - } - this.setNeedsRedraw("instanceCount"); - } - /** - * Updates the vertex count (used in draw calls) - * @note Any attributes with stepMode=vertex need to be at least this big - */ - setVertexCount(vertexCount) { - this.vertexCount = vertexCount; - this.setNeedsRedraw("vertexCount"); - } - /** Set the shader inputs */ - setShaderInputs(shaderInputs) { - this.shaderInputs = shaderInputs; - this._uniformStore = new UniformStore(this.shaderInputs.modules); - for (const moduleName of Object.keys(this.shaderInputs.modules)) { - const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName); - this.bindings[`${moduleName}Uniforms`] = uniformBuffer; - } - this.setNeedsRedraw("shaderInputs"); - } - /** Update uniform buffers from the model's shader inputs */ - updateShaderInputs() { - this._uniformStore.setUniforms(this.shaderInputs.getUniformValues()); - this.setBindings(this.shaderInputs.getBindings()); - this.setNeedsRedraw("shaderInputs"); - } - /** - * Sets bindings (textures, samplers, uniform buffers) - */ - setBindings(bindings) { - Object.assign(this.bindings, bindings); - this.setNeedsRedraw("bindings"); - } - /** - * Updates optional transform feedback. WebGL only. - */ - setTransformFeedback(transformFeedback) { - this.transformFeedback = transformFeedback; - this.setNeedsRedraw("transformFeedback"); - } - /** - * Sets the index buffer - * @todo - how to unset it if we change geometry? - */ - setIndexBuffer(indexBuffer) { - this.vertexArray.setIndexBuffer(indexBuffer); - this.setNeedsRedraw("indexBuffer"); - } - /** - * Sets attributes (buffers) - * @note Overrides any attributes previously set with the same name - */ - setAttributes(buffers, options) { - if (buffers.indices) { - log2.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)(); - } - for (const [bufferName, buffer] of Object.entries(buffers)) { - const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName)); - if (!bufferLayout) { - log2.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)(); - continue; - } - const attributeNames = getAttributeNames(bufferLayout); - let set11 = false; - for (const attributeName of attributeNames) { - const attributeInfo = this._attributeInfos[attributeName]; - if (attributeInfo) { - this.vertexArray.setBuffer(attributeInfo.location, buffer); - set11 = true; - } - } - if (!set11 && !(options?.disableWarnings ?? this.props.disableWarnings)) { - log2.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)(); - } - } - this.setNeedsRedraw("attributes"); - } - /** - * Sets constant attributes - * @note Overrides any attributes previously set with the same name - * Constant attributes are only supported in WebGL, not in WebGPU - * Any attribute that is disabled in the current vertex array object - * is read from the context's global constant value for that attribute location. - * @param constantAttributes - */ - setConstantAttributes(attributes, options) { - for (const [attributeName, value] of Object.entries(attributes)) { - const attributeInfo = this._attributeInfos[attributeName]; - if (attributeInfo) { - this.vertexArray.setConstantWebGL(attributeInfo.location, value); - } else if (!(options?.disableWarnings ?? this.props.disableWarnings)) { - log2.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)(); - } - } - this.setNeedsRedraw("constants"); - } - // DEPRECATED METHODS - /** - * Sets individual uniforms - * @deprecated WebGL only, use uniform buffers for portability - * @param uniforms - */ - setUniforms(uniforms) { - if (!isObjectEmpty(uniforms)) { - this.pipeline.setUniformsWebGL(uniforms); - Object.assign(this.uniforms, uniforms); - } - this.setNeedsRedraw("uniforms"); - } - /** - * @deprecated Updates shader module settings (which results in uniforms being set) - */ - updateModuleSettings(props) { - const { bindings, uniforms } = splitUniformsAndBindings(this._getModuleUniforms(props)); - Object.assign(this.bindings, bindings); - Object.assign(this.uniforms, uniforms); - this.setNeedsRedraw("moduleSettings"); - } - // Internal methods - /** Get the timestamp of the latest updated bound GPU memory resource (buffer/texture). */ - _getBindingsUpdateTimestamp() { - let timestamp = 0; - for (const binding of Object.values(this.bindings)) { - if (binding instanceof TextureView) { - timestamp = Math.max(timestamp, binding.texture.updateTimestamp); - } else if (binding instanceof Buffer2 || binding instanceof Texture) { - timestamp = Math.max(timestamp, binding.updateTimestamp); - } else if (!(binding instanceof Sampler)) { - timestamp = Math.max(timestamp, binding.buffer.updateTimestamp); - } - } - return timestamp; - } - /** - * Updates the optional geometry attributes - * Geometry, sets several attributes, indexBuffer, and also vertex count - * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU - */ - _setGeometryAttributes(gpuGeometry) { - const attributes = { ...gpuGeometry.attributes }; - for (const [attributeName] of Object.entries(attributes)) { - if (!this.pipeline.shaderLayout.attributes.find((layout) => layout.name === attributeName) && attributeName !== "positions") { - delete attributes[attributeName]; - } - } - this.vertexCount = gpuGeometry.vertexCount; - this.setIndexBuffer(gpuGeometry.indices || null); - this.setAttributes(gpuGeometry.attributes, { disableWarnings: true }); - this.setAttributes(attributes, { disableWarnings: this.props.disableWarnings }); - this.setNeedsRedraw("geometry attributes"); - } - /** Mark pipeline as needing update */ - _setPipelineNeedsUpdate(reason) { - this._pipelineNeedsUpdate ||= reason; - this.setNeedsRedraw(reason); - } - /** Update pipeline if needed */ - _updatePipeline() { - if (this._pipelineNeedsUpdate) { - let prevShaderVs = null; - let prevShaderFs = null; - if (this.pipeline) { - log2.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)(); - prevShaderVs = this.pipeline.vs; - prevShaderFs = this.pipeline.fs; - } - this._pipelineNeedsUpdate = false; - const vs7 = this.shaderFactory.createShader({ - id: `${this.id}-vertex`, - stage: "vertex", - source: this.source || this.vs, - debug: this.props.debugShaders - }); - let fs5 = null; - if (this.source) { - fs5 = vs7; - } else if (this.fs) { - fs5 = this.shaderFactory.createShader({ - id: `${this.id}-fragment`, - stage: "fragment", - source: this.source || this.fs, - debug: this.props.debugShaders - }); - } - this.pipeline = this.pipelineFactory.createRenderPipeline({ - ...this.props, - bufferLayout: this.bufferLayout, - topology: this.topology, - parameters: this.parameters, - vs: vs7, - fs: fs5 - }); - this._attributeInfos = getAttributeInfosFromLayouts(this.pipeline.shaderLayout, this.bufferLayout); - if (prevShaderVs) - this.shaderFactory.release(prevShaderVs); - if (prevShaderFs) - this.shaderFactory.release(prevShaderFs); - } - return this.pipeline; - } - /** Throttle draw call logging */ - _lastLogTime = 0; - _logOpen = false; - _logDrawCallStart() { - const logDrawTimeout = log2.level > 3 ? 0 : LOG_DRAW_TIMEOUT; - if (log2.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) { - return; - } - this._lastLogTime = Date.now(); - this._logOpen = true; - log2.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: log2.level <= 2 })(); - } - _logDrawCallEnd() { - if (this._logOpen) { - const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id); - log2.table(LOG_DRAW_PRIORITY, shaderLayoutTable)(); - const uniformTable = this.shaderInputs.getDebugTable(); - for (const [name2, value] of Object.entries(this.uniforms)) { - uniformTable[name2] = { value }; - } - log2.table(LOG_DRAW_PRIORITY, uniformTable)(); - const attributeTable = this._getAttributeDebugTable(); - log2.table(LOG_DRAW_PRIORITY, this._attributeInfos)(); - log2.table(LOG_DRAW_PRIORITY, attributeTable)(); - log2.groupEnd(LOG_DRAW_PRIORITY)(); - this._logOpen = false; - } - } - _drawCount = 0; - _logFramebuffer(renderPass) { - const debugFramebuffers = log2.get("framebuffer"); - this._drawCount++; - if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) { - return; - } - const framebuffer = renderPass.props.framebuffer; - if (framebuffer) { - debugFramebuffer(framebuffer, { id: framebuffer.id, minimap: true }); - } - } - _getAttributeDebugTable() { - const table = {}; - for (const [name2, attributeInfo] of Object.entries(this._attributeInfos)) { - table[attributeInfo.location] = { - name: name2, - type: attributeInfo.shaderType, - values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType) - }; - } - if (this.vertexArray.indexBuffer) { - const { indexBuffer } = this.vertexArray; - const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData); - table.indices = { - name: "indices", - type: indexBuffer.indexType, - values: values.toString() - }; - } - return table; - } - // TODO - fix typing of luma data types - _getBufferOrConstantValues(attribute, dataType) { - const TypedArrayConstructor = getTypedArrayFromDataType(dataType); - const typedArray = attribute instanceof Buffer2 ? new TypedArrayConstructor(attribute.debugData) : attribute; - return typedArray.toString(); - } -}; -function mergeBufferLayouts(layouts1, layouts2) { - const layouts = [...layouts1]; - for (const attribute of layouts2) { - const index2 = layouts.findIndex((attribute2) => attribute2.name === attribute.name); - if (index2 < 0) { - layouts.push(attribute); - } else { - layouts[index2] = attribute; - } - } - return layouts; -} -function getPlatformInfo(device) { - return { - type: device.type, - shaderLanguage: device.info.shadingLanguage, - shaderLanguageVersion: device.info.shadingLanguageVersion, - gpu: device.info.gpu, - // HACK - we pretend that the DeviceFeatures is a Set, it has a similar API - features: device.features - }; -} -function getAttributeNames(bufferLayout) { - return bufferLayout.attributes ? bufferLayout.attributes?.map((layout) => layout.attribute) : [bufferLayout.name]; -} - -// node_modules/@luma.gl/engine/dist/transform/buffer-transform.js -var BufferTransform = class _BufferTransform { - device; - model; - transformFeedback; - /** @deprecated Use device feature test. */ - static isSupported(device) { - return device?.info?.type === "webgl"; - } - constructor(device, props = Model.defaultProps) { - assert6(_BufferTransform.isSupported(device), "BufferTransform not yet implemented on WebGPU"); - this.device = device; - this.model = new Model(this.device, { - id: props.id || "buffer-transform-model", - fs: props.fs || getPassthroughFS(), - topology: props.topology || "point-list", - ...props - }); - this.transformFeedback = this.device.createTransformFeedback({ - layout: this.model.pipeline.shaderLayout, - buffers: props.feedbackBuffers - }); - this.model.setTransformFeedback(this.transformFeedback); - Object.seal(this); - } - /** Destroy owned resources. */ - destroy() { - if (this.model) { - this.model.destroy(); - } - } - /** @deprecated Use {@link destroy}. */ - delete() { - this.destroy(); - } - /** Run one transform loop. */ - run(options) { - const renderPass = this.device.beginRenderPass(options); - this.model.draw(renderPass); - renderPass.end(); - } - /** @deprecated */ - update(...args) { - console.warn("TextureTransform#update() not implemented"); - } - /** Returns the {@link Buffer} or {@link BufferRange} for given varying name. */ - getBuffer(varyingName) { - return this.transformFeedback.getBuffer(varyingName); - } - readAsync(varyingName) { - const result = this.getBuffer(varyingName); - if (result instanceof Buffer2) { - return result.readAsync(); - } - const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result; - return buffer.readAsync(byteOffset, byteLength); - } -}; - -// node_modules/@luma.gl/engine/dist/geometry/geometry.js -var Geometry = class { - id; - /** Determines how vertices are read from the 'vertex' attributes */ - topology; - vertexCount; - indices; - attributes; - userData = {}; - constructor(props) { - const { attributes = {}, indices = null, vertexCount = null } = props; - this.id = props.id || uid("geometry"); - this.topology = props.topology; - if (indices) { - this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices; - } - this.attributes = {}; - for (const [attributeName, attributeValue] of Object.entries(attributes)) { - const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue; - assert6(ArrayBuffer.isView(attribute.value), `${this._print(attributeName)}: must be typed array or object with value as typed array`); - if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) { - attribute.size = 3; - } - if (attributeName === "indices") { - assert6(!this.indices); - this.indices = attribute; - } else { - this.attributes[attributeName] = attribute; - } - } - if (this.indices && this.indices.isIndexed !== void 0) { - this.indices = Object.assign({}, this.indices); - delete this.indices.isIndexed; - } - this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices); - } - getVertexCount() { - return this.vertexCount; - } - /** - * Return an object with all attributes plus indices added as a field. - * TODO Geometry types are a mess - */ - getAttributes() { - return this.indices ? { indices: this.indices, ...this.attributes } : this.attributes; - } - // PRIVATE - _print(attributeName) { - return `Geometry ${this.id} attribute ${attributeName}`; - } - /** - * GeometryAttribute - * value: typed array - * type: indices, vertices, uvs - * size: elements per vertex - * target: WebGL buffer type (string or constant) - * - * @param attributes - * @param indices - * @returns - */ - _setAttributes(attributes, indices) { - return this; - } - _calculateVertexCount(attributes, indices) { - if (indices) { - return indices.value.length; - } - let vertexCount = Infinity; - for (const attribute of Object.values(attributes)) { - const { value, size, constant } = attribute; - if (!constant && value && size >= 1) { - vertexCount = Math.min(vertexCount, value.length / size); - } - } - assert6(Number.isFinite(vertexCount)); - return vertexCount; - } -}; - -// node_modules/@deck.gl/core/dist/passes/pick-layers-pass.js -var PICKING_BLENDING = { - blendColorOperation: "add", - blendColorSrcFactor: "one", - blendColorDstFactor: "zero", - blendAlphaOperation: "add", - blendAlphaSrcFactor: "constant-alpha", - blendAlphaDstFactor: "zero" -}; -var PickLayersPass = class extends LayersPass { - constructor() { - super(...arguments); - this._colorEncoderState = null; - } - render(props) { - if ("pickingFBO" in props) { - return this._drawPickingBuffer(props); - } - return super.render(props); - } - // Private - // Draws list of layers and viewports into the picking buffer - // Note: does not sample the buffer, that has to be done by the caller - _drawPickingBuffer({ layers, layerFilter, views, viewports, onViewportActive, pickingFBO, deviceRect: { x, y, width, height }, cullRect, effects, pass = "picking", pickZ, moduleParameters }) { - this.pickZ = pickZ; - const colorEncoderState = this._resetColorEncoder(pickZ); - const scissorRect = [x, y, width, height]; - const renderStatus = super.render({ - target: pickingFBO, - layers, - layerFilter, - views, - viewports, - onViewportActive, - cullRect, - effects: effects?.filter((e) => e.useInPicking), - pass, - isPicking: true, - moduleParameters, - clearColor: [0, 0, 0, 0], - colorMask: 15, - scissorRect - }); - this._colorEncoderState = null; - const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState); - return { decodePickingColor, stats: renderStatus }; - } - shouldDrawLayer(layer) { - const { pickable, operation } = layer.props; - return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask"); - } - getModuleParameters() { - return { - picking: { - isActive: 1, - isAttribute: this.pickZ - }, - // turn off lighting by adding empty light source object - // lights shader module relies on the `lightSources` to turn on/off lighting - lightSources: {} - }; - } - getLayerParameters(layer, layerIndex, viewport) { - const pickParameters = { - // TODO - When used as a custom layer in older Mapbox versions, context - // state was dirty. Mapbox fixed that; we should test and remove the workaround. - // https://github.com/mapbox/mapbox-gl-js/issues/7801 - depthMask: true, - depthTest: true, - depthRange: [0, 1], - ...layer.props.parameters - }; - const { pickable, operation } = layer.props; - if (!this._colorEncoderState || operation.includes("terrain")) { - pickParameters.blend = false; - } else if (pickable && operation.includes("draw")) { - Object.assign(pickParameters, PICKING_BLENDING); - pickParameters.blend = true; - pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport); - } - return pickParameters; - } - _resetColorEncoder(pickZ) { - this._colorEncoderState = pickZ ? null : { - byLayer: /* @__PURE__ */ new Map(), - byAlpha: [] - }; - return this._colorEncoderState; - } -}; -function encodeColor(encoded, layer, viewport) { - const { byLayer, byAlpha } = encoded; - let a; - let entry = byLayer.get(layer); - if (entry) { - entry.viewports.push(viewport); - a = entry.a; - } else { - a = byLayer.size + 1; - if (a <= 255) { - entry = { a, layer, viewports: [viewport] }; - byLayer.set(layer, entry); - byAlpha[a] = entry; - } else { - log_default.warn("Too many pickable layers, only picking the first 255")(); - a = 0; - } - } - return [0, 0, 0, a / 255]; -} -function decodeColor(encoded, pickedColor) { - const entry = encoded.byAlpha[pickedColor[3]]; - return entry && { - pickedLayer: entry.layer, - pickedViewports: entry.viewports, - pickedObjectIndex: entry.layer.decodePickingColor(pickedColor) - }; -} - -// node_modules/@deck.gl/core/dist/lifecycle/constants.js -var LIFECYCLE = { - NO_STATE: "Awaiting state", - MATCHED: "Matched. State transferred from previous layer", - INITIALIZED: "Initialized", - AWAITING_GC: "Discarded. Awaiting garbage collection", - AWAITING_FINALIZATION: "No longer matched. Awaiting garbage collection", - FINALIZED: "Finalized! Awaiting garbage collection" -}; -var COMPONENT_SYMBOL = Symbol.for("component"); -var PROP_TYPES_SYMBOL = Symbol.for("propTypes"); -var DEPRECATED_PROPS_SYMBOL = Symbol.for("deprecatedProps"); -var ASYNC_DEFAULTS_SYMBOL = Symbol.for("asyncPropDefaults"); -var ASYNC_ORIGINAL_SYMBOL = Symbol.for("asyncPropOriginal"); -var ASYNC_RESOLVED_SYMBOL = Symbol.for("asyncPropResolved"); - -// node_modules/@deck.gl/core/dist/utils/flatten.js -function flatten(array, filter = () => true) { - if (!Array.isArray(array)) { - return filter(array) ? [array] : []; - } - return flattenArray(array, filter, []); -} -function flattenArray(array, filter, result) { - let index2 = -1; - while (++index2 < array.length) { - const value = array[index2]; - if (Array.isArray(value)) { - flattenArray(value, filter, result); - } else if (filter(value)) { - result.push(value); - } - } - return result; -} -function fillArray2({ target, source, start = 0, count: count2 = 1 }) { - const length10 = source.length; - const total = count2 * length10; - let copied = 0; - for (let i = start; copied < length10; copied++) { - target[i++] = source[copied]; - } - while (copied < total) { - if (copied < total - copied) { - target.copyWithin(start + copied, start, start + copied); - copied *= 2; - } else { - target.copyWithin(start + copied, start, start + total - copied); - copied = total; - } - } - return target; -} - -// node_modules/@deck.gl/core/dist/lib/resource/resource.js -var Resource2 = class { - constructor(id, data, context) { - this._loadCount = 0; - this._subscribers = /* @__PURE__ */ new Set(); - this.id = id; - this.context = context; - this.setData(data); - } - // consumer: {onChange: Function} - subscribe(consumer) { - this._subscribers.add(consumer); - } - unsubscribe(consumer) { - this._subscribers.delete(consumer); - } - inUse() { - return this._subscribers.size > 0; - } - delete() { - } - getData() { - return this.isLoaded ? this._error ? Promise.reject(this._error) : this._content : this._loader.then(() => this.getData()); - } - setData(data, forceUpdate) { - if (data === this._data && !forceUpdate) { - return; - } - this._data = data; - const loadCount = ++this._loadCount; - let loader = data; - if (typeof data === "string") { - loader = load(data); - } - if (loader instanceof Promise) { - this.isLoaded = false; - this._loader = loader.then((result) => { - if (this._loadCount === loadCount) { - this.isLoaded = true; - this._error = void 0; - this._content = result; - } - }).catch((error) => { - if (this._loadCount === loadCount) { - this.isLoaded = true; - this._error = error || true; - } - }); - } else { - this.isLoaded = true; - this._error = void 0; - this._content = data; - } - for (const subscriber of this._subscribers) { - subscriber.onChange(this.getData()); - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/resource/resource-manager.js -var ResourceManager = class { - constructor(props) { - this.protocol = props.protocol || "resource://"; - this._context = { - device: props.device, - // @ts-expect-error - gl: props.device?.gl, - resourceManager: this - }; - this._resources = {}; - this._consumers = {}; - this._pruneRequest = null; - } - contains(resourceId) { - if (resourceId.startsWith(this.protocol)) { - return true; - } - return resourceId in this._resources; - } - add({ resourceId, data, forceUpdate = false, persistent = true }) { - let res = this._resources[resourceId]; - if (res) { - res.setData(data, forceUpdate); - } else { - res = new Resource2(resourceId, data, this._context); - this._resources[resourceId] = res; - } - res.persistent = persistent; - } - remove(resourceId) { - const res = this._resources[resourceId]; - if (res) { - res.delete(); - delete this._resources[resourceId]; - } - } - unsubscribe({ consumerId }) { - const consumer = this._consumers[consumerId]; - if (consumer) { - for (const requestId in consumer) { - const request = consumer[requestId]; - const resource = this._resources[request.resourceId]; - if (resource) { - resource.unsubscribe(request); - } - } - delete this._consumers[consumerId]; - this.prune(); - } - } - subscribe({ resourceId, onChange, consumerId, requestId = "default" }) { - const { _resources: resources, protocol } = this; - if (resourceId.startsWith(protocol)) { - resourceId = resourceId.replace(protocol, ""); - if (!resources[resourceId]) { - this.add({ resourceId, data: null, persistent: false }); - } - } - const res = resources[resourceId]; - this._track(consumerId, requestId, res, onChange); - if (res) { - return res.getData(); - } - return void 0; - } - prune() { - if (!this._pruneRequest) { - this._pruneRequest = setTimeout(() => this._prune(), 0); - } - } - finalize() { - for (const key in this._resources) { - this._resources[key].delete(); - } - } - _track(consumerId, requestId, resource, onChange) { - const consumers = this._consumers; - const consumer = consumers[consumerId] = consumers[consumerId] || {}; - let request = consumer[requestId]; - const oldResource = request && request.resourceId && this._resources[request.resourceId]; - if (oldResource) { - oldResource.unsubscribe(request); - this.prune(); - } - if (resource) { - if (request) { - request.onChange = onChange; - request.resourceId = resource.id; - } else { - request = { - onChange, - resourceId: resource.id - }; - } - consumer[requestId] = request; - resource.subscribe(request); - } - } - _prune() { - this._pruneRequest = null; - for (const key of Object.keys(this._resources)) { - const res = this._resources[key]; - if (!res.persistent && !res.inUse()) { - res.delete(); - delete this._resources[key]; - } - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/layer-manager.js -var TRACE_SET_LAYERS = "layerManager.setLayers"; -var TRACE_ACTIVATE_VIEWPORT = "layerManager.activateViewport"; -var LayerManager = class { - /** - * @param device - * @param param1 - */ - // eslint-disable-next-line - constructor(device, props) { - this._lastRenderedLayers = []; - this._needsRedraw = false; - this._needsUpdate = false; - this._nextLayers = null; - this._debug = false; - this._defaultShaderModulesChanged = false; - this.activateViewport = (viewport2) => { - debug(TRACE_ACTIVATE_VIEWPORT, this, viewport2); - if (viewport2) { - this.context.viewport = viewport2; - } - }; - const { deck, stats, viewport, timeline } = props || {}; - this.layers = []; - this.resourceManager = new ResourceManager({ device, protocol: "deck://" }); - this.context = { - mousePosition: null, - userData: {}, - layerManager: this, - device, - // @ts-expect-error - gl: device?.gl, - deck, - shaderAssembler: getShaderAssembler(), - defaultShaderModules: [], - renderPass: void 0, - stats: stats || new Stats({ id: "deck.gl" }), - // Make sure context.viewport is not empty on the first layer initialization - viewport: viewport || new viewport_default({ id: "DEFAULT-INITIAL-VIEWPORT" }), - // Current viewport, exposed to layers for project* function - timeline: timeline || new Timeline(), - resourceManager: this.resourceManager, - onError: void 0 - }; - Object.seal(this); - } - /** Method to call when the layer manager is not needed anymore. */ - finalize() { - this.resourceManager.finalize(); - for (const layer of this.layers) { - this._finalizeLayer(layer); - } - } - /** Check if a redraw is needed */ - needsRedraw(opts = { clearRedrawFlags: false }) { - let redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - for (const layer of this.layers) { - const layerNeedsRedraw = layer.getNeedsRedraw(opts); - redraw = redraw || layerNeedsRedraw; - } - return redraw; - } - /** Check if a deep update of all layers is needed */ - needsUpdate() { - if (this._nextLayers && this._nextLayers !== this._lastRenderedLayers) { - return "layers changed"; - } - if (this._defaultShaderModulesChanged) { - return "shader modules changed"; - } - return this._needsUpdate; - } - /** Layers will be redrawn (in next animation frame) */ - setNeedsRedraw(reason) { - this._needsRedraw = this._needsRedraw || reason; - } - /** Layers will be updated deeply (in next animation frame) - Potentially regenerating attributes and sub layers */ - setNeedsUpdate(reason) { - this._needsUpdate = this._needsUpdate || reason; - } - /** Gets a list of currently rendered layers. Optionally filter by id. */ - getLayers({ layerIds } = {}) { - return layerIds ? this.layers.filter((layer) => layerIds.find((layerId) => layer.id.indexOf(layerId) === 0)) : this.layers; - } - /** Set props needed for layer rendering and picking. */ - setProps(props) { - if ("debug" in props) { - this._debug = props.debug; - } - if ("userData" in props) { - this.context.userData = props.userData; - } - if ("layers" in props) { - this._nextLayers = props.layers; - } - if ("onError" in props) { - this.context.onError = props.onError; - } - } - /** Supply a new layer list, initiating sublayer generation and layer matching */ - setLayers(newLayers, reason) { - debug(TRACE_SET_LAYERS, this, reason, newLayers); - this._lastRenderedLayers = newLayers; - const flatLayers = flatten(newLayers, Boolean); - for (const layer of flatLayers) { - layer.context = this.context; - } - this._updateLayers(this.layers, flatLayers); - } - /** Update layers from last cycle if `setNeedsUpdate()` has been called */ - updateLayers() { - const reason = this.needsUpdate(); - if (reason) { - this.setNeedsRedraw(`updating layers: ${reason}`); - this.setLayers(this._nextLayers || this._lastRenderedLayers, reason); - } - this._nextLayers = null; - } - /** Register a default shader module */ - addDefaultShaderModule(module) { - const { defaultShaderModules } = this.context; - if (!defaultShaderModules.find((m) => m.name === module.name)) { - defaultShaderModules.push(module); - this._defaultShaderModulesChanged = true; - } - } - /** Deregister a default shader module */ - removeDefaultShaderModule(module) { - const { defaultShaderModules } = this.context; - const i = defaultShaderModules.findIndex((m) => m.name === module.name); - if (i >= 0) { - defaultShaderModules.splice(i, 1); - this._defaultShaderModulesChanged = true; - } - } - _handleError(stage, error, layer) { - layer.raiseError(error, `${stage} of ${layer}`); - } - // TODO - mark layers with exceptions as bad and remove from rendering cycle? - /** Match all layers, checking for caught errors - to avoid having an exception in one layer disrupt other layers */ - _updateLayers(oldLayers, newLayers) { - const oldLayerMap = {}; - for (const oldLayer of oldLayers) { - if (oldLayerMap[oldLayer.id]) { - log_default.warn(`Multiple old layers with same id ${oldLayer.id}`)(); - } else { - oldLayerMap[oldLayer.id] = oldLayer; - } - } - if (this._defaultShaderModulesChanged) { - for (const layer of oldLayers) { - layer.setNeedsUpdate(); - layer.setChangeFlags({ extensionsChanged: true }); - } - this._defaultShaderModulesChanged = false; - } - const generatedLayers = []; - this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers); - this._finalizeOldLayers(oldLayerMap); - let needsUpdate = false; - for (const layer of generatedLayers) { - if (layer.hasUniformTransition()) { - needsUpdate = `Uniform transition in ${layer}`; - break; - } - } - this._needsUpdate = needsUpdate; - this.layers = generatedLayers; - } - /* eslint-disable complexity,max-statements */ - // Note: adds generated layers to `generatedLayers` array parameter - _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) { - for (const newLayer of newLayers) { - newLayer.context = this.context; - const oldLayer = oldLayerMap[newLayer.id]; - if (oldLayer === null) { - log_default.warn(`Multiple new layers with same id ${newLayer.id}`)(); - } - oldLayerMap[newLayer.id] = null; - let sublayers = null; - try { - if (this._debug && oldLayer !== newLayer) { - newLayer.validateProps(); - } - if (!oldLayer) { - this._initializeLayer(newLayer); - } else { - this._transferLayerState(oldLayer, newLayer); - this._updateLayer(newLayer); - } - generatedLayers.push(newLayer); - sublayers = newLayer.isComposite ? newLayer.getSubLayers() : null; - } catch (err) { - this._handleError("matching", err, newLayer); - } - if (sublayers) { - this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers); - } - } - } - /* eslint-enable complexity,max-statements */ - // Finalize any old layers that were not matched - _finalizeOldLayers(oldLayerMap) { - for (const layerId in oldLayerMap) { - const layer = oldLayerMap[layerId]; - if (layer) { - this._finalizeLayer(layer); - } - } - } - // / EXCEPTION SAFE LAYER ACCESS - /** Safely initializes a single layer, calling layer methods */ - _initializeLayer(layer) { - try { - layer._initialize(); - layer.lifecycle = LIFECYCLE.INITIALIZED; - } catch (err) { - this._handleError("initialization", err, layer); - } - } - /** Transfer state from one layer to a newer version */ - _transferLayerState(oldLayer, newLayer) { - newLayer._transferState(oldLayer); - newLayer.lifecycle = LIFECYCLE.MATCHED; - if (newLayer !== oldLayer) { - oldLayer.lifecycle = LIFECYCLE.AWAITING_GC; - } - } - /** Safely updates a single layer, cleaning all flags */ - _updateLayer(layer) { - try { - layer._update(); - } catch (err) { - this._handleError("update", err, layer); - } - } - /** Safely finalizes a single layer, removing all resources */ - _finalizeLayer(layer) { - this._needsRedraw = this._needsRedraw || `finalized ${layer}`; - layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION; - try { - layer._finalize(); - layer.lifecycle = LIFECYCLE.FINALIZED; - } catch (err) { - this._handleError("finalization", err, layer); - } - } -}; - -// node_modules/@deck.gl/core/dist/utils/deep-equal.js -function deepEqual2(a, b, depth) { - if (a === b) { - return true; - } - if (!depth || !a || !b) { - return false; - } - if (Array.isArray(a)) { - if (!Array.isArray(b) || a.length !== b.length) { - return false; - } - for (let i = 0; i < a.length; i++) { - if (!deepEqual2(a[i], b[i], depth - 1)) { - return false; - } - } - return true; - } - if (Array.isArray(b)) { - return false; - } - if (typeof a === "object" && typeof b === "object") { - const aKeys = Object.keys(a); - const bKeys = Object.keys(b); - if (aKeys.length !== bKeys.length) { - return false; - } - for (const key of aKeys) { - if (!b.hasOwnProperty(key)) { - return false; - } - if (!deepEqual2(a[key], b[key], depth - 1)) { - return false; - } - } - return true; - } - return false; -} - -// node_modules/@deck.gl/core/dist/lib/view-manager.js -var ViewManager = class { - constructor(props) { - this.views = []; - this.width = 100; - this.height = 100; - this.viewState = {}; - this.controllers = {}; - this.timeline = props.timeline; - this._viewports = []; - this._viewportMap = {}; - this._isUpdating = false; - this._needsRedraw = "First render"; - this._needsUpdate = "Initialize"; - this._eventManager = props.eventManager; - this._eventCallbacks = { - onViewStateChange: props.onViewStateChange, - onInteractionStateChange: props.onInteractionStateChange - }; - Object.seal(this); - this.setProps(props); - } - /** Remove all resources and event listeners */ - finalize() { - for (const key in this.controllers) { - const controller = this.controllers[key]; - if (controller) { - controller.finalize(); - } - } - this.controllers = {}; - } - /** Check if a redraw is needed */ - needsRedraw(opts = { clearRedrawFlags: false }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - return redraw; - } - /** Mark the manager as dirty. Will rebuild all viewports and update controllers. */ - setNeedsUpdate(reason) { - this._needsUpdate = this._needsUpdate || reason; - this._needsRedraw = this._needsRedraw || reason; - } - /** Checks each viewport for transition updates */ - updateViewStates() { - for (const viewId in this.controllers) { - const controller = this.controllers[viewId]; - if (controller) { - controller.updateTransition(); - } - } - } - /** Get a set of viewports for a given width and height - * TODO - Intention is for deck.gl to autodeduce width and height and drop the need for props - * @param rect (object, optional) - filter the viewports - * + not provided - return all viewports - * + {x, y} - only return viewports that contain this pixel - * + {x, y, width, height} - only return viewports that overlap with this rectangle - */ - getViewports(rect) { - if (rect) { - return this._viewports.filter((viewport) => viewport.containsPixel(rect)); - } - return this._viewports; - } - /** Get a map of all views */ - getViews() { - const viewMap = {}; - this.views.forEach((view) => { - viewMap[view.id] = view; - }); - return viewMap; - } - /** Resolves a viewId string to a View */ - getView(viewId) { - return this.views.find((view) => view.id === viewId); - } - /** Returns the viewState for a specific viewId. Matches the viewState by - 1. view.viewStateId - 2. view.id - 3. root viewState - then applies the view's filter if any */ - getViewState(viewOrViewId) { - const view = typeof viewOrViewId === "string" ? this.getView(viewOrViewId) : viewOrViewId; - const viewState = view && this.viewState[view.getViewStateId()] || this.viewState; - return view ? view.filterViewState(viewState) : viewState; - } - getViewport(viewId) { - return this._viewportMap[viewId]; - } - /** - * Unproject pixel coordinates on screen onto world coordinates, - * (possibly [lon, lat]) on map. - * - [x, y] => [lng, lat] - * - [x, y, z] => [lng, lat, Z] - * @param {Array} xyz - - * @param {Object} opts - options - * @param {Object} opts.topLeft=true - Whether origin is top left - * @return {Array|null} - [lng, lat, Z] or [X, Y, Z] - */ - unproject(xyz, opts) { - const viewports = this.getViewports(); - const pixel = { x: xyz[0], y: xyz[1] }; - for (let i = viewports.length - 1; i >= 0; --i) { - const viewport = viewports[i]; - if (viewport.containsPixel(pixel)) { - const p = xyz.slice(); - p[0] -= viewport.x; - p[1] -= viewport.y; - return viewport.unproject(p, opts); - } - } - return null; - } - /** Update the manager with new Deck props */ - setProps(props) { - if (props.views) { - this._setViews(props.views); - } - if (props.viewState) { - this._setViewState(props.viewState); - } - if ("width" in props || "height" in props) { - this._setSize(props.width, props.height); - } - if (!this._isUpdating) { - this._update(); - } - } - // - // PRIVATE METHODS - // - _update() { - this._isUpdating = true; - if (this._needsUpdate) { - this._needsUpdate = false; - this._rebuildViewports(); - } - if (this._needsUpdate) { - this._needsUpdate = false; - this._rebuildViewports(); - } - this._isUpdating = false; - } - _setSize(width, height) { - if (width !== this.width || height !== this.height) { - this.width = width; - this.height = height; - this.setNeedsUpdate("Size changed"); - } - } - // Update the view descriptor list and set change flag if needed - // Does not actually rebuild the `Viewport`s until `getViewports` is called - _setViews(views) { - views = flatten(views, Boolean); - const viewsChanged = this._diffViews(views, this.views); - if (viewsChanged) { - this.setNeedsUpdate("views changed"); - } - this.views = views; - } - _setViewState(viewState) { - if (viewState) { - const viewStateChanged = !deepEqual2(viewState, this.viewState, 3); - if (viewStateChanged) { - this.setNeedsUpdate("viewState changed"); - } - this.viewState = viewState; - } else { - log_default.warn("missing `viewState` or `initialViewState`")(); - } - } - _createController(view, props) { - const Controller2 = props.type; - const controller = new Controller2({ - timeline: this.timeline, - eventManager: this._eventManager, - // Set an internal callback that calls the prop callback if provided - onViewStateChange: this._eventCallbacks.onViewStateChange, - onStateChange: this._eventCallbacks.onInteractionStateChange, - makeViewport: (viewState) => this.getView(view.id)?.makeViewport({ - viewState, - width: this.width, - height: this.height - }) - }); - return controller; - } - _updateController(view, viewState, viewport, controller) { - const controllerProps = view.controller; - if (controllerProps && viewport) { - const resolvedProps = { - ...viewState, - ...controllerProps, - id: view.id, - x: viewport.x, - y: viewport.y, - width: viewport.width, - height: viewport.height - }; - if (!controller || controller.constructor !== controllerProps.type) { - controller = this._createController(view, resolvedProps); - } - if (controller) { - controller.setProps(resolvedProps); - } - return controller; - } - return null; - } - // Rebuilds viewports from descriptors towards a certain window size - _rebuildViewports() { - const { views } = this; - const oldControllers = this.controllers; - this._viewports = []; - this.controllers = {}; - let invalidateControllers = false; - for (let i = views.length; i--; ) { - const view = views[i]; - const viewState = this.getViewState(view); - const viewport = view.makeViewport({ viewState, width: this.width, height: this.height }); - let oldController = oldControllers[view.id]; - const hasController = Boolean(view.controller); - if (hasController && !oldController) { - invalidateControllers = true; - } - if ((invalidateControllers || !hasController) && oldController) { - oldController.finalize(); - oldController = null; - } - this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController); - if (viewport) { - this._viewports.unshift(viewport); - } - } - for (const id in oldControllers) { - const oldController = oldControllers[id]; - if (oldController && !this.controllers[id]) { - oldController.finalize(); - } - } - this._buildViewportMap(); - } - _buildViewportMap() { - this._viewportMap = {}; - this._viewports.forEach((viewport) => { - if (viewport.id) { - this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport; - } - }); - } - // Check if viewport array has changed, returns true if any change - // Note that descriptors can be the same - _diffViews(newViews, oldViews) { - if (newViews.length !== oldViews.length) { - return true; - } - return newViews.some((_, i) => !newViews[i].equals(oldViews[i])); - } -}; - -// node_modules/@deck.gl/core/dist/utils/positions.js -var PERCENT_OR_PIXELS_REGEX = /([0-9]+\.?[0-9]*)(%|px)/; -function parsePosition(value) { - switch (typeof value) { - case "number": - return { - position: value, - relative: false - }; - case "string": - const match = PERCENT_OR_PIXELS_REGEX.exec(value); - if (match && match.length >= 3) { - const relative = match[2] === "%"; - const position = parseFloat(match[1]); - return { - position: relative ? position / 100 : position, - relative - }; - } - default: - throw new Error(`Could not parse position string ${value}`); - } -} -function getPosition(position, extent) { - return position.relative ? Math.round(position.position * extent) : position.position; -} - -// node_modules/@deck.gl/core/dist/views/view.js -var View = class { - constructor(props) { - const { id, x = 0, y = 0, width = "100%", height = "100%", padding = null } = props; - this.id = id || this.constructor.displayName || "view"; - this.props = { ...props, id: this.id }; - this._x = parsePosition(x); - this._y = parsePosition(y); - this._width = parsePosition(width); - this._height = parsePosition(height); - this._padding = padding && { - left: parsePosition(padding.left || 0), - right: parsePosition(padding.right || 0), - top: parsePosition(padding.top || 0), - bottom: parsePosition(padding.bottom || 0) - }; - this.equals = this.equals.bind(this); - Object.seal(this); - } - equals(view) { - if (this === view) { - return true; - } - return this.ViewportType === view.ViewportType && deepEqual2(this.props, view.props, 2); - } - /** Make viewport from canvas dimensions and view state */ - makeViewport({ width, height, viewState }) { - viewState = this.filterViewState(viewState); - const viewportDimensions = this.getDimensions({ width, height }); - if (!viewportDimensions.height || !viewportDimensions.width) { - return null; - } - return new this.ViewportType({ ...viewState, ...this.props, ...viewportDimensions }); - } - getViewStateId() { - const { viewState } = this.props; - if (typeof viewState === "string") { - return viewState; - } - return viewState?.id || this.id; - } - // Allows view to override (or completely define) viewState - filterViewState(viewState) { - if (this.props.viewState && typeof this.props.viewState === "object") { - if (!this.props.viewState.id) { - return this.props.viewState; - } - const newViewState = { ...viewState }; - for (const key in this.props.viewState) { - if (key !== "id") { - newViewState[key] = this.props.viewState[key]; - } - } - return newViewState; - } - return viewState; - } - /** Resolve the dimensions of the view from overall canvas dimensions */ - getDimensions({ width, height }) { - const dimensions = { - x: getPosition(this._x, width), - y: getPosition(this._y, height), - width: getPosition(this._width, width), - height: getPosition(this._height, height) - }; - if (this._padding) { - dimensions.padding = { - left: getPosition(this._padding.left, width), - top: getPosition(this._padding.top, height), - right: getPosition(this._padding.right, width), - bottom: getPosition(this._padding.bottom, height) - }; - } - return dimensions; - } - // Used by sub classes to resolve controller props - get controller() { - const opts = this.props.controller; - if (!opts) { - return null; - } - if (opts === true) { - return { type: this.ControllerType }; - } - if (typeof opts === "function") { - return { type: opts }; - } - return { type: this.ControllerType, ...opts }; - } -}; - -// node_modules/@deck.gl/core/dist/transitions/transition.js -var Transition = class { - /** - * @params timeline {Timeline} - */ - constructor(timeline) { - this._inProgress = false; - this._handle = null; - this.time = 0; - this.settings = { - duration: 0 - }; - this._timeline = timeline; - } - /* Public API */ - get inProgress() { - return this._inProgress; - } - /** - * (re)start this transition. - * @params props {object} - optional overriding props. see constructor - */ - start(settings) { - this.cancel(); - this.settings = settings; - this._inProgress = true; - this.settings.onStart?.(this); - } - /** - * end this transition if it is in progress. - */ - end() { - if (this._inProgress) { - this._timeline.removeChannel(this._handle); - this._handle = null; - this._inProgress = false; - this.settings.onEnd?.(this); - } - } - /** - * cancel this transition if it is in progress. - */ - cancel() { - if (this._inProgress) { - this.settings.onInterrupt?.(this); - this._timeline.removeChannel(this._handle); - this._handle = null; - this._inProgress = false; - } - } - /** - * update this transition. Returns `true` if updated. - */ - update() { - if (!this._inProgress) { - return false; - } - if (this._handle === null) { - const { _timeline: timeline, settings } = this; - this._handle = timeline.addChannel({ - delay: timeline.getTime(), - duration: settings.duration - }); - } - this.time = this._timeline.getTime(this._handle); - this._onUpdate(); - this.settings.onUpdate?.(this); - if (this._timeline.isFinished(this._handle)) { - this.end(); - } - return true; - } - /* Private API */ - _onUpdate() { - } -}; - -// node_modules/@deck.gl/core/dist/controllers/transition-manager.js -var noop2 = () => { -}; -var TRANSITION_EVENTS = { - BREAK: 1, - SNAP_TO_END: 2, - IGNORE: 3 -}; -var DEFAULT_EASING = (t) => t; -var DEFAULT_INTERRUPTION = TRANSITION_EVENTS.BREAK; -var TransitionManager = class { - constructor(opts) { - this._onTransitionUpdate = (transition) => { - const { time, settings: { interpolator, startProps, endProps, duration, easing } } = transition; - const t = easing(time / duration); - const viewport = interpolator.interpolateProps(startProps, endProps, t); - this.propsInTransition = this.getControllerState({ - ...this.props, - ...viewport - }).getViewportProps(); - this.onViewStateChange({ - viewState: this.propsInTransition, - oldViewState: this.props - }); - }; - this.getControllerState = opts.getControllerState; - this.propsInTransition = null; - this.transition = new Transition(opts.timeline); - this.onViewStateChange = opts.onViewStateChange || noop2; - this.onStateChange = opts.onStateChange || noop2; - } - finalize() { - this.transition.cancel(); - } - // Returns current transitioned viewport. - getViewportInTransition() { - return this.propsInTransition; - } - // Process the vewiport change, either ignore or trigger a new transition. - // Return true if a new transition is triggered, false otherwise. - processViewStateChange(nextProps) { - let transitionTriggered = false; - const currentProps = this.props; - this.props = nextProps; - if (!currentProps || this._shouldIgnoreViewportChange(currentProps, nextProps)) { - return false; - } - if (this._isTransitionEnabled(nextProps)) { - let startProps = currentProps; - if (this.transition.inProgress) { - const { interruption, endProps } = this.transition.settings; - startProps = { - ...currentProps, - ...interruption === TRANSITION_EVENTS.SNAP_TO_END ? endProps : this.propsInTransition || currentProps - }; - } - this._triggerTransition(startProps, nextProps); - transitionTriggered = true; - } else { - this.transition.cancel(); - } - return transitionTriggered; - } - updateTransition() { - this.transition.update(); - } - // Helper methods - _isTransitionEnabled(props) { - const { transitionDuration, transitionInterpolator } = props; - return (transitionDuration > 0 || transitionDuration === "auto") && Boolean(transitionInterpolator); - } - _isUpdateDueToCurrentTransition(props) { - if (this.transition.inProgress && this.propsInTransition) { - return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition); - } - return false; - } - _shouldIgnoreViewportChange(currentProps, nextProps) { - if (this.transition.inProgress) { - const transitionSettings = this.transition.settings; - return transitionSettings.interruption === TRANSITION_EVENTS.IGNORE || // Ignore update if it is due to current active transition. - this._isUpdateDueToCurrentTransition(nextProps); - } - if (this._isTransitionEnabled(nextProps)) { - return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps); - } - return true; - } - _triggerTransition(startProps, endProps) { - const startViewstate = this.getControllerState(startProps); - const endViewStateProps = this.getControllerState(endProps).shortestPathFrom(startViewstate); - const transitionInterpolator = endProps.transitionInterpolator; - const duration = transitionInterpolator.getDuration ? transitionInterpolator.getDuration(startProps, endProps) : endProps.transitionDuration; - if (duration === 0) { - return; - } - const initialProps = transitionInterpolator.initializeProps(startProps, endViewStateProps); - this.propsInTransition = {}; - const transitionSettings = { - duration, - easing: endProps.transitionEasing || DEFAULT_EASING, - interpolator: transitionInterpolator, - interruption: endProps.transitionInterruption || DEFAULT_INTERRUPTION, - startProps: initialProps.start, - endProps: initialProps.end, - onStart: endProps.onTransitionStart, - onUpdate: this._onTransitionUpdate, - onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt), - onEnd: this._onTransitionEnd(endProps.onTransitionEnd) - }; - this.transition.start(transitionSettings); - this.onStateChange({ inTransition: true }); - this.updateTransition(); - } - _onTransitionEnd(callback) { - return (transition) => { - this.propsInTransition = null; - this.onStateChange({ - inTransition: false, - isZooming: false, - isPanning: false, - isRotating: false - }); - callback?.(transition); - }; - } -}; - -// node_modules/@deck.gl/core/dist/utils/assert.js -function assert9(condition, message2) { - if (!condition) { - throw new Error(message2 || "deck.gl: assertion failed."); - } -} - -// node_modules/@deck.gl/core/dist/transitions/transition-interpolator.js -var TransitionInterpolator = class { - /** - * @param opts {array|object} - * @param opts.compare {array} - prop names used in equality check - * @param opts.extract {array} - prop names needed for interpolation - * @param opts.required {array} - prop names that must be supplied - * alternatively, supply one list of prop names as `opts` if all of the above are the same. - */ - constructor(opts) { - const { compare, extract, required } = opts; - this._propsToCompare = compare; - this._propsToExtract = extract || compare; - this._requiredProps = required; - } - /** - * Checks if two sets of props need transition in between - * @param currentProps {object} - a list of viewport props - * @param nextProps {object} - a list of viewport props - * @returns {bool} - true if two props are equivalent - */ - arePropsEqual(currentProps, nextProps) { - for (const key of this._propsToCompare) { - if (!(key in currentProps) || !(key in nextProps) || !equals(currentProps[key], nextProps[key])) { - return false; - } - } - return true; - } - /** - * Called before transition starts to validate/pre-process start and end props - * @param startProps {object} - a list of starting viewport props - * @param endProps {object} - a list of target viewport props - * @returns {Object} {start, end} - start and end props to be passed - * to `interpolateProps` - */ - initializeProps(startProps, endProps) { - const startViewStateProps = {}; - const endViewStateProps = {}; - for (const key of this._propsToExtract) { - if (key in startProps || key in endProps) { - startViewStateProps[key] = startProps[key]; - endViewStateProps[key] = endProps[key]; - } - } - this._checkRequiredProps(startViewStateProps); - this._checkRequiredProps(endViewStateProps); - return { start: startViewStateProps, end: endViewStateProps }; - } - /** - * Returns transition duration - * @param startProps {object} - a list of starting viewport props - * @param endProps {object} - a list of target viewport props - * @returns {Number} - transition duration in milliseconds - */ - getDuration(startProps, endProps) { - return endProps.transitionDuration; - } - _checkRequiredProps(props) { - if (!this._requiredProps) { - return; - } - this._requiredProps.forEach((propName) => { - const value = props[propName]; - assert9(Number.isFinite(value) || Array.isArray(value), `${propName} is required for transition`); - }); - } -}; - -// node_modules/@deck.gl/core/dist/transitions/linear-interpolator.js -var DEFAULT_PROPS3 = ["longitude", "latitude", "zoom", "bearing", "pitch"]; -var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"]; -var LinearInterpolator = class extends TransitionInterpolator { - /** - * @param {Object} opts - * @param {Array} opts.transitionProps - list of props to apply linear transition to. - * @param {Array} opts.around - a screen point to zoom/rotate around. - * @param {Function} opts.makeViewport - construct a viewport instance with given props. - */ - constructor(opts = {}) { - const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps; - const normalizedOpts = Array.isArray(opts) ? {} : opts; - normalizedOpts.transitionProps = Array.isArray(transitionProps) ? { - compare: transitionProps, - required: transitionProps - } : transitionProps || { - compare: DEFAULT_PROPS3, - required: DEFAULT_REQUIRED_PROPS - }; - super(normalizedOpts.transitionProps); - this.opts = normalizedOpts; - } - initializeProps(startProps, endProps) { - const result = super.initializeProps(startProps, endProps); - const { makeViewport, around } = this.opts; - if (makeViewport && around) { - const startViewport = makeViewport(startProps); - const endViewport = makeViewport(endProps); - const aroundPosition = startViewport.unproject(around); - result.start.around = around; - Object.assign(result.end, { - around: endViewport.project(aroundPosition), - aroundPosition, - width: endProps.width, - height: endProps.height - }); - } - return result; - } - interpolateProps(startProps, endProps, t) { - const propsInTransition = {}; - for (const key of this._propsToExtract) { - propsInTransition[key] = lerp(startProps[key] || 0, endProps[key] || 0, t); - } - if (endProps.aroundPosition && this.opts.makeViewport) { - const viewport = this.opts.makeViewport({ ...endProps, ...propsInTransition }); - Object.assign(propsInTransition, viewport.panByPosition( - endProps.aroundPosition, - // anchor point in current screen coordinates - lerp(startProps.around, endProps.around, t) - )); - } - return propsInTransition; - } -}; - -// node_modules/@deck.gl/core/dist/controllers/controller.js -var NO_TRANSITION_PROPS = { - transitionDuration: 0 -}; -var DEFAULT_INERTIA = 300; -var INERTIA_EASING = (t) => 1 - (1 - t) * (1 - t); -var EVENT_TYPES = { - WHEEL: ["wheel"], - PAN: ["panstart", "panmove", "panend"], - PINCH: ["pinchstart", "pinchmove", "pinchend"], - TRIPLE_PAN: ["tripanstart", "tripanmove", "tripanend"], - DOUBLE_TAP: ["doubletap"], - KEYBOARD: ["keydown"] -}; -var pinchEventWorkaround = {}; -var Controller = class { - constructor(opts) { - this.state = {}; - this._events = {}; - this._interactionState = { - isDragging: false - }; - this._customEvents = []; - this._eventStartBlocked = null; - this._panMove = false; - this.invertPan = false; - this.dragMode = "rotate"; - this.inertia = 0; - this.scrollZoom = true; - this.dragPan = true; - this.dragRotate = true; - this.doubleClickZoom = true; - this.touchZoom = true; - this.touchRotate = false; - this.keyboard = true; - this.transitionManager = new TransitionManager({ - ...opts, - getControllerState: (props) => new this.ControllerState(props), - onViewStateChange: this._onTransition.bind(this), - onStateChange: this._setInteractionState.bind(this) - }); - this.handleEvent = this.handleEvent.bind(this); - this.eventManager = opts.eventManager; - this.onViewStateChange = opts.onViewStateChange || (() => { - }); - this.onStateChange = opts.onStateChange || (() => { - }); - this.makeViewport = opts.makeViewport; - } - set events(customEvents) { - this.toggleEvents(this._customEvents, false); - this.toggleEvents(customEvents, true); - this._customEvents = customEvents; - if (this.props) { - this.setProps(this.props); - } - } - finalize() { - for (const eventName in this._events) { - if (this._events[eventName]) { - this.eventManager?.off(eventName, this.handleEvent); - } - } - this.transitionManager.finalize(); - } - /** - * Callback for events - */ - handleEvent(event) { - this._controllerState = void 0; - const eventStartBlocked = this._eventStartBlocked; - switch (event.type) { - case "panstart": - return eventStartBlocked ? false : this._onPanStart(event); - case "panmove": - return this._onPan(event); - case "panend": - return this._onPanEnd(event); - case "pinchstart": - return eventStartBlocked ? false : this._onPinchStart(event); - case "pinchmove": - return this._onPinch(event); - case "pinchend": - return this._onPinchEnd(event); - case "tripanstart": - return eventStartBlocked ? false : this._onTriplePanStart(event); - case "tripanmove": - return this._onTriplePan(event); - case "tripanend": - return this._onTriplePanEnd(event); - case "doubletap": - return this._onDoubleTap(event); - case "wheel": - return this._onWheel(event); - case "keydown": - return this._onKeyDown(event); - default: - return false; - } - } - /* Event utils */ - // Event object: http://hammerjs.github.io/api/#event-object - get controllerState() { - this._controllerState = this._controllerState || new this.ControllerState({ - makeViewport: this.makeViewport, - ...this.props, - ...this.state - }); - return this._controllerState; - } - getCenter(event) { - const { x, y } = this.props; - const { offsetCenter } = event; - return [offsetCenter.x - x, offsetCenter.y - y]; - } - isPointInBounds(pos, event) { - const { width, height } = this.props; - if (event && event.handled) { - return false; - } - const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height; - if (inside && event) { - event.stopPropagation(); - } - return inside; - } - isFunctionKeyPressed(event) { - const { srcEvent } = event; - return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey); - } - isDragging() { - return this._interactionState.isDragging || false; - } - // When a multi-touch event ends, e.g. pinch, not all pointers are lifted at the same time. - // This triggers a brief `pan` event. - // Calling this method will temporarily disable *start events to avoid conflicting transitions. - blockEvents(timeout) { - const timer = setTimeout(() => { - if (this._eventStartBlocked === timer) { - this._eventStartBlocked = null; - } - }, timeout); - this._eventStartBlocked = timer; - } - /** - * Extract interactivity options - */ - setProps(props) { - if (props.dragMode) { - this.dragMode = props.dragMode; - } - this.props = props; - if (!("transitionInterpolator" in props)) { - props.transitionInterpolator = this._getTransitionProps().transitionInterpolator; - } - this.transitionManager.processViewStateChange(props); - const { inertia } = props; - this.inertia = Number.isFinite(inertia) ? inertia : inertia === true ? DEFAULT_INERTIA : 0; - const { scrollZoom = true, dragPan = true, dragRotate = true, doubleClickZoom = true, touchZoom = true, touchRotate = false, keyboard = true } = props; - const isInteractive = Boolean(this.onViewStateChange); - this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom); - this.toggleEvents(EVENT_TYPES.PAN, isInteractive); - this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate)); - this.toggleEvents(EVENT_TYPES.TRIPLE_PAN, isInteractive && touchRotate); - this.toggleEvents(EVENT_TYPES.DOUBLE_TAP, isInteractive && doubleClickZoom); - this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard); - this.scrollZoom = scrollZoom; - this.dragPan = dragPan; - this.dragRotate = dragRotate; - this.doubleClickZoom = doubleClickZoom; - this.touchZoom = touchZoom; - this.touchRotate = touchRotate; - this.keyboard = keyboard; - } - updateTransition() { - this.transitionManager.updateTransition(); - } - toggleEvents(eventNames, enabled) { - if (this.eventManager) { - eventNames.forEach((eventName) => { - if (this._events[eventName] !== enabled) { - this._events[eventName] = enabled; - if (enabled) { - this.eventManager.on(eventName, this.handleEvent); - } else { - this.eventManager.off(eventName, this.handleEvent); - } - } - }); - } - } - // Private Methods - /* Callback util */ - // formats map state and invokes callback function - updateViewport(newControllerState, extraProps = null, interactionState = {}) { - const viewState = { ...newControllerState.getViewportProps(), ...extraProps }; - const changed = this.controllerState !== newControllerState; - this.state = newControllerState.getState(); - this._setInteractionState(interactionState); - if (changed) { - const oldViewState = this.controllerState && this.controllerState.getViewportProps(); - if (this.onViewStateChange) { - this.onViewStateChange({ viewState, interactionState: this._interactionState, oldViewState, viewId: this.props.id }); - } - } - } - _onTransition(params) { - this.onViewStateChange({ ...params, interactionState: this._interactionState, viewId: this.props.id }); - } - _setInteractionState(newStates) { - Object.assign(this._interactionState, newStates); - this.onStateChange(this._interactionState); - } - /* Event handlers */ - // Default handler for the `panstart` event. - _onPanStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton || false; - if (this.invertPan || this.dragMode === "pan") { - alternateMode = !alternateMode; - } - const newControllerState = this.controllerState[alternateMode ? "panStart" : "rotateStart"]({ - pos - }); - this._panMove = alternateMode; - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); - return true; - } - // Default handler for the `panmove` and `panend` event. - _onPan(event) { - if (!this.isDragging()) { - return false; - } - return this._panMove ? this._onPanMove(event) : this._onPanRotate(event); - } - _onPanEnd(event) { - if (!this.isDragging()) { - return false; - } - return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event); - } - // Default handler for panning to move. - // Called by `_onPan` when panning without function key pressed. - _onPanMove(event) { - if (!this.dragPan) { - return false; - } - const pos = this.getCenter(event); - const newControllerState = this.controllerState.pan({ pos }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isPanning: true - }); - return true; - } - _onPanMoveEnd(event) { - const { inertia } = this; - if (this.dragPan && inertia && event.velocity) { - const pos = this.getCenter(event); - const endPos = [ - pos[0] + event.velocityX * inertia / 2, - pos[1] + event.velocityY * inertia / 2 - ]; - const newControllerState = this.controllerState.pan({ pos: endPos }).panEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isPanning: true - }); - } else { - const newControllerState = this.controllerState.panEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isPanning: false - }); - } - return true; - } - // Default handler for panning to rotate. - // Called by `_onPan` when panning with function key pressed. - _onPanRotate(event) { - if (!this.dragRotate) { - return false; - } - const pos = this.getCenter(event); - const newControllerState = this.controllerState.rotate({ pos }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isRotating: true - }); - return true; - } - _onPanRotateEnd(event) { - const { inertia } = this; - if (this.dragRotate && inertia && event.velocity) { - const pos = this.getCenter(event); - const endPos = [ - pos[0] + event.velocityX * inertia / 2, - pos[1] + event.velocityY * inertia / 2 - ]; - const newControllerState = this.controllerState.rotate({ pos: endPos }).rotateEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isRotating: true - }); - } else { - const newControllerState = this.controllerState.rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isRotating: false - }); - } - return true; - } - // Default handler for the `wheel` event. - _onWheel(event) { - if (!this.scrollZoom) { - return false; - } - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - event.srcEvent.preventDefault(); - const { speed = 0.01, smooth = false } = this.scrollZoom === true ? {} : this.scrollZoom; - const { delta } = event; - let scale13 = 2 / (1 + Math.exp(-Math.abs(delta * speed))); - if (delta < 0 && scale13 !== 0) { - scale13 = 1 / scale13; - } - const newControllerState = this.controllerState.zoom({ pos, scale: scale13 }); - this.updateViewport(newControllerState, { ...this._getTransitionProps({ around: pos }), transitionDuration: smooth ? 250 : 1 }, { - isZooming: true, - isPanning: true - }); - return true; - } - _onTriplePanStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - const newControllerState = this.controllerState.rotateStart({ pos }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); - return true; - } - _onTriplePan(event) { - if (!this.touchRotate) { - return false; - } - if (!this.isDragging()) { - return false; - } - const pos = this.getCenter(event); - pos[0] -= event.deltaX; - const newControllerState = this.controllerState.rotate({ pos }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isRotating: true - }); - return true; - } - _onTriplePanEnd(event) { - if (!this.isDragging()) { - return false; - } - const { inertia } = this; - if (this.touchRotate && inertia && event.velocityY) { - const pos = this.getCenter(event); - const endPos = [pos[0], pos[1] += event.velocityY * inertia / 2]; - const newControllerState = this.controllerState.rotate({ pos: endPos }); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isRotating: true - }); - this.blockEvents(inertia); - } else { - const newControllerState = this.controllerState.rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isRotating: false - }); - } - return true; - } - // Default handler for the `pinchstart` event. - _onPinchStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - const newControllerState = this.controllerState.zoomStart({ pos }).rotateStart({ pos }); - pinchEventWorkaround._startPinchRotation = event.rotation; - pinchEventWorkaround._lastPinchEvent = event; - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true }); - return true; - } - // Default handler for the `pinchmove` and `pinchend` events. - _onPinch(event) { - if (!this.touchZoom && !this.touchRotate) { - return false; - } - if (!this.isDragging()) { - return false; - } - let newControllerState = this.controllerState; - if (this.touchZoom) { - const { scale: scale13 } = event; - const pos = this.getCenter(event); - newControllerState = newControllerState.zoom({ pos, scale: scale13 }); - } - if (this.touchRotate) { - const { rotation } = event; - newControllerState = newControllerState.rotate({ - deltaAngleX: pinchEventWorkaround._startPinchRotation - rotation - }); - } - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isPanning: this.touchZoom, - isZooming: this.touchZoom, - isRotating: this.touchRotate - }); - pinchEventWorkaround._lastPinchEvent = event; - return true; - } - _onPinchEnd(event) { - if (!this.isDragging()) { - return false; - } - const { inertia } = this; - const { _lastPinchEvent } = pinchEventWorkaround; - if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) { - const pos = this.getCenter(event); - let newControllerState = this.controllerState.rotateEnd(); - const z = Math.log2(event.scale); - const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime); - const endScale = Math.pow(2, z + velocityZ * inertia / 2); - newControllerState = newControllerState.zoom({ pos, scale: endScale }).zoomEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps({ around: pos }), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isPanning: this.touchZoom, - isZooming: this.touchZoom, - isRotating: false - }); - this.blockEvents(inertia); - } else { - const newControllerState = this.controllerState.zoomEnd().rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isPanning: false, - isZooming: false, - isRotating: false - }); - } - pinchEventWorkaround._startPinchRotation = null; - pinchEventWorkaround._lastPinchEvent = null; - return true; - } - // Default handler for the `doubletap` event. - _onDoubleTap(event) { - if (!this.doubleClickZoom) { - return false; - } - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - const isZoomOut = this.isFunctionKeyPressed(event); - const newControllerState = this.controllerState.zoom({ pos, scale: isZoomOut ? 0.5 : 2 }); - this.updateViewport(newControllerState, this._getTransitionProps({ around: pos }), { - isZooming: true, - isPanning: true - }); - this.blockEvents(100); - return true; - } - // Default handler for the `keydown` event - _onKeyDown(event) { - if (!this.keyboard) { - return false; - } - const funcKey = this.isFunctionKeyPressed(event); - const { zoomSpeed, moveSpeed, rotateSpeedX, rotateSpeedY } = this.keyboard === true ? {} : this.keyboard; - const { controllerState } = this; - let newControllerState; - const interactionState = {}; - switch (event.srcEvent.code) { - case "Minus": - newControllerState = funcKey ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed) : controllerState.zoomOut(zoomSpeed); - interactionState.isZooming = true; - break; - case "Equal": - newControllerState = funcKey ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed) : controllerState.zoomIn(zoomSpeed); - interactionState.isZooming = true; - break; - case "ArrowLeft": - if (funcKey) { - newControllerState = controllerState.rotateLeft(rotateSpeedX); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveLeft(moveSpeed); - interactionState.isPanning = true; - } - break; - case "ArrowRight": - if (funcKey) { - newControllerState = controllerState.rotateRight(rotateSpeedX); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveRight(moveSpeed); - interactionState.isPanning = true; - } - break; - case "ArrowUp": - if (funcKey) { - newControllerState = controllerState.rotateUp(rotateSpeedY); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveUp(moveSpeed); - interactionState.isPanning = true; - } - break; - case "ArrowDown": - if (funcKey) { - newControllerState = controllerState.rotateDown(rotateSpeedY); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveDown(moveSpeed); - interactionState.isPanning = true; - } - break; - default: - return false; - } - this.updateViewport(newControllerState, this._getTransitionProps(), interactionState); - return true; - } - _getTransitionProps(opts) { - const { transition } = this; - if (!transition || !transition.transitionInterpolator) { - return NO_TRANSITION_PROPS; - } - return opts ? { - ...transition, - transitionInterpolator: new LinearInterpolator({ - ...opts, - ...transition.transitionInterpolator.opts, - makeViewport: this.controllerState.makeViewport - }) - } : transition; - } -}; - -// node_modules/@deck.gl/core/dist/controllers/view-state.js -var ViewState = class { - constructor(props, state) { - this._viewportProps = this.applyConstraints(props); - this._state = state; - } - getViewportProps() { - return this._viewportProps; - } - getState() { - return this._state; - } -}; - -// node_modules/@deck.gl/core/dist/controllers/map-controller.js -var PITCH_MOUSE_THRESHOLD = 5; -var PITCH_ACCEL = 1.2; -var MapState = class extends ViewState { - constructor(options) { - const { - /** Mapbox viewport properties */ - /** The width of the viewport */ - width, - /** The height of the viewport */ - height, - /** The latitude at the center of the viewport */ - latitude, - /** The longitude at the center of the viewport */ - longitude, - /** The tile zoom level of the map. */ - zoom, - /** The bearing of the viewport in degrees */ - bearing = 0, - /** The pitch of the viewport in degrees */ - pitch = 0, - /** - * Specify the altitude of the viewport camera - * Unit: map heights, default 1.5 - * Non-public API, see https://github.com/mapbox/mapbox-gl-js/issues/1137 - */ - altitude = 1.5, - /** Viewport position */ - position = [0, 0, 0], - /** Viewport constraints */ - maxZoom = 20, - minZoom = 0, - maxPitch = 60, - minPitch = 0, - /** Interaction states, required to calculate change during transform */ - /* The point on map being grabbed when the operation first started */ - startPanLngLat, - /* Center of the zoom when the operation first started */ - startZoomLngLat, - /* Pointer position when rotation started */ - startRotatePos, - /** Bearing when current perspective rotate operation started */ - startBearing, - /** Pitch when current perspective rotate operation started */ - startPitch, - /** Zoom when current zoom operation started */ - startZoom, - /** Normalize viewport props to fit map height into viewport */ - normalize: normalize11 = true - } = options; - assert9(Number.isFinite(longitude)); - assert9(Number.isFinite(latitude)); - assert9(Number.isFinite(zoom)); - super({ - width, - height, - latitude, - longitude, - zoom, - bearing, - pitch, - altitude, - maxZoom, - minZoom, - maxPitch, - minPitch, - normalize: normalize11, - position - }, { - startPanLngLat, - startZoomLngLat, - startRotatePos, - startBearing, - startPitch, - startZoom - }); - this.makeViewport = options.makeViewport; - } - /** - * Start panning - * @param {[Number, Number]} pos - position on screen where the pointer grabs - */ - panStart({ pos }) { - return this._getUpdatedState({ - startPanLngLat: this._unproject(pos) - }); - } - /** - * Pan - * @param {[Number, Number]} pos - position on screen where the pointer is - * @param {[Number, Number], optional} startPos - where the pointer grabbed at - * the start of the operation. Must be supplied of `panStart()` was not called - */ - pan({ pos, startPos }) { - const startPanLngLat = this.getState().startPanLngLat || this._unproject(startPos); - if (!startPanLngLat) { - return this; - } - const viewport = this.makeViewport(this.getViewportProps()); - const newProps = viewport.panByPosition(startPanLngLat, pos); - return this._getUpdatedState(newProps); - } - /** - * End panning - * Must call if `panStart()` was called - */ - panEnd() { - return this._getUpdatedState({ - startPanLngLat: null - }); - } - /** - * Start rotating - * @param {[Number, Number]} pos - position on screen where the center is - */ - rotateStart({ pos }) { - return this._getUpdatedState({ - startRotatePos: pos, - startBearing: this.getViewportProps().bearing, - startPitch: this.getViewportProps().pitch - }); - } - /** - * Rotate - * @param {[Number, Number]} pos - position on screen where the center is - */ - rotate({ pos, deltaAngleX = 0, deltaAngleY = 0 }) { - const { startRotatePos, startBearing, startPitch } = this.getState(); - if (!startRotatePos || startBearing === void 0 || startPitch === void 0) { - return this; - } - let newRotation; - if (pos) { - newRotation = this._getNewRotation(pos, startRotatePos, startPitch, startBearing); - } else { - newRotation = { - bearing: startBearing + deltaAngleX, - pitch: startPitch + deltaAngleY - }; - } - return this._getUpdatedState(newRotation); - } - /** - * End rotating - * Must call if `rotateStart()` was called - */ - rotateEnd() { - return this._getUpdatedState({ - startBearing: null, - startPitch: null - }); - } - /** - * Start zooming - * @param {[Number, Number]} pos - position on screen where the center is - */ - zoomStart({ pos }) { - return this._getUpdatedState({ - startZoomLngLat: this._unproject(pos), - startZoom: this.getViewportProps().zoom - }); - } - /** - * Zoom - * @param {[Number, Number]} pos - position on screen where the current center is - * @param {[Number, Number]} startPos - the center position at - * the start of the operation. Must be supplied of `zoomStart()` was not called - * @param {Number} scale - a number between [0, 1] specifying the accumulated - * relative scale. - */ - zoom({ pos, startPos, scale: scale13 }) { - let { startZoom, startZoomLngLat } = this.getState(); - if (!startZoomLngLat) { - startZoom = this.getViewportProps().zoom; - startZoomLngLat = this._unproject(startPos) || this._unproject(pos); - } - if (!startZoomLngLat) { - return this; - } - const { maxZoom, minZoom } = this.getViewportProps(); - let zoom = startZoom + Math.log2(scale13); - zoom = clamp(zoom, minZoom, maxZoom); - const zoomedViewport = this.makeViewport({ ...this.getViewportProps(), zoom }); - return this._getUpdatedState({ - zoom, - ...zoomedViewport.panByPosition(startZoomLngLat, pos) - }); - } - /** - * End zooming - * Must call if `zoomStart()` was called - */ - zoomEnd() { - return this._getUpdatedState({ - startZoomLngLat: null, - startZoom: null - }); - } - zoomIn(speed = 2) { - return this._zoomFromCenter(speed); - } - zoomOut(speed = 2) { - return this._zoomFromCenter(1 / speed); - } - moveLeft(speed = 100) { - return this._panFromCenter([speed, 0]); - } - moveRight(speed = 100) { - return this._panFromCenter([-speed, 0]); - } - moveUp(speed = 100) { - return this._panFromCenter([0, speed]); - } - moveDown(speed = 100) { - return this._panFromCenter([0, -speed]); - } - rotateLeft(speed = 15) { - return this._getUpdatedState({ - bearing: this.getViewportProps().bearing - speed - }); - } - rotateRight(speed = 15) { - return this._getUpdatedState({ - bearing: this.getViewportProps().bearing + speed - }); - } - rotateUp(speed = 10) { - return this._getUpdatedState({ - pitch: this.getViewportProps().pitch + speed - }); - } - rotateDown(speed = 10) { - return this._getUpdatedState({ - pitch: this.getViewportProps().pitch - speed - }); - } - shortestPathFrom(viewState) { - const fromProps = viewState.getViewportProps(); - const props = { ...this.getViewportProps() }; - const { bearing, longitude } = props; - if (Math.abs(bearing - fromProps.bearing) > 180) { - props.bearing = bearing < 0 ? bearing + 360 : bearing - 360; - } - if (Math.abs(longitude - fromProps.longitude) > 180) { - props.longitude = longitude < 0 ? longitude + 360 : longitude - 360; - } - return props; - } - // Apply any constraints (mathematical or defined by _viewportProps) to map state - applyConstraints(props) { - const { maxZoom, minZoom, zoom } = props; - props.zoom = clamp(zoom, minZoom, maxZoom); - const { maxPitch, minPitch, pitch } = props; - props.pitch = clamp(pitch, minPitch, maxPitch); - const { normalize: normalize11 = true } = props; - if (normalize11) { - Object.assign(props, normalizeViewportProps(props)); - } - return props; - } - /* Private methods */ - _zoomFromCenter(scale13) { - const { width, height } = this.getViewportProps(); - return this.zoom({ - pos: [width / 2, height / 2], - scale: scale13 - }); - } - _panFromCenter(offset) { - const { width, height } = this.getViewportProps(); - return this.pan({ - startPos: [width / 2, height / 2], - pos: [width / 2 + offset[0], height / 2 + offset[1]] - }); - } - _getUpdatedState(newProps) { - return new this.constructor({ - makeViewport: this.makeViewport, - ...this.getViewportProps(), - ...this.getState(), - ...newProps - }); - } - _unproject(pos) { - const viewport = this.makeViewport(this.getViewportProps()); - return pos && viewport.unproject(pos); - } - _getNewRotation(pos, startPos, startPitch, startBearing) { - const deltaX = pos[0] - startPos[0]; - const deltaY = pos[1] - startPos[1]; - const centerY = pos[1]; - const startY = startPos[1]; - const { width, height } = this.getViewportProps(); - const deltaScaleX = deltaX / width; - let deltaScaleY = 0; - if (deltaY > 0) { - if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) { - deltaScaleY = deltaY / (startY - height) * PITCH_ACCEL; - } - } else if (deltaY < 0) { - if (startY > PITCH_MOUSE_THRESHOLD) { - deltaScaleY = 1 - centerY / startY; - } - } - deltaScaleY = clamp(deltaScaleY, -1, 1); - const { minPitch, maxPitch } = this.getViewportProps(); - const bearing = startBearing + 180 * deltaScaleX; - let pitch = startPitch; - if (deltaScaleY > 0) { - pitch = startPitch + deltaScaleY * (maxPitch - startPitch); - } else if (deltaScaleY < 0) { - pitch = startPitch - deltaScaleY * (minPitch - startPitch); - } - return { - pitch, - bearing - }; - } -}; -var MapController = class extends Controller { - constructor() { - super(...arguments); - this.ControllerState = MapState; - this.transition = { - transitionDuration: 300, - transitionInterpolator: new LinearInterpolator({ - transitionProps: { - compare: ["longitude", "latitude", "zoom", "bearing", "pitch", "position"], - required: ["longitude", "latitude", "zoom"] - } - }) - }; - this.dragMode = "pan"; - } - setProps(props) { - props.position = props.position || [0, 0, 0]; - const oldProps = this.props; - super.setProps(props); - const dimensionChanged = !oldProps || oldProps.height !== props.height; - if (dimensionChanged) { - this.updateViewport(new this.ControllerState({ - makeViewport: this.makeViewport, - ...props, - ...this.state - })); - } - } -}; - -// node_modules/@deck.gl/core/dist/views/map-view.js -var MapView = class extends View { - constructor(props = {}) { - super(props); - } - get ViewportType() { - return web_mercator_viewport_default; - } - get ControllerType() { - return MapController; - } -}; -MapView.displayName = "MapView"; -var map_view_default = MapView; - -// node_modules/@deck.gl/core/dist/lib/effect-manager.js -var DEFAULT_LIGHTING_EFFECT = new LightingEffect(); -function compareEffects(e1, e2) { - const o1 = e1.order ?? Infinity; - const o2 = e2.order ?? Infinity; - return o1 - o2; -} -var EffectManager = class { - constructor(context) { - this._resolvedEffects = []; - this._defaultEffects = []; - this.effects = []; - this._context = context; - this._needsRedraw = "Initial render"; - this._setEffects([]); - } - /** - * Register a new default effect, i.e. an effect presents regardless of user supplied props.effects - */ - addDefaultEffect(effect) { - const defaultEffects = this._defaultEffects; - if (!defaultEffects.find((e) => e.id === effect.id)) { - const index2 = defaultEffects.findIndex((e) => compareEffects(e, effect) > 0); - if (index2 < 0) { - defaultEffects.push(effect); - } else { - defaultEffects.splice(index2, 0, effect); - } - effect.setup(this._context); - this._setEffects(this.effects); - } - } - setProps(props) { - if ("effects" in props) { - if (!deepEqual2(props.effects, this.effects, 1)) { - this._setEffects(props.effects); - } - } - } - needsRedraw(opts = { clearRedrawFlags: false }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - return redraw; - } - getEffects() { - return this._resolvedEffects; - } - _setEffects(effects) { - const oldEffectsMap = {}; - for (const effect of this.effects) { - oldEffectsMap[effect.id] = effect; - } - const nextEffects = []; - for (const effect of effects) { - const oldEffect = oldEffectsMap[effect.id]; - let effectToAdd = effect; - if (oldEffect && oldEffect !== effect) { - if (oldEffect.setProps) { - oldEffect.setProps(effect.props); - effectToAdd = oldEffect; - } else { - oldEffect.cleanup(this._context); - } - } else if (!oldEffect) { - effect.setup(this._context); - } - nextEffects.push(effectToAdd); - delete oldEffectsMap[effect.id]; - } - for (const removedEffectId in oldEffectsMap) { - oldEffectsMap[removedEffectId].cleanup(this._context); - } - this.effects = nextEffects; - this._resolvedEffects = nextEffects.concat(this._defaultEffects); - if (!effects.some((effect) => effect instanceof LightingEffect)) { - this._resolvedEffects.push(DEFAULT_LIGHTING_EFFECT); - } - this._needsRedraw = "effects changed"; - } - finalize() { - for (const effect of this._resolvedEffects) { - effect.cleanup(this._context); - } - this.effects.length = 0; - this._resolvedEffects.length = 0; - this._defaultEffects.length = 0; - } -}; - -// node_modules/@deck.gl/core/dist/passes/draw-layers-pass.js -var DrawLayersPass = class extends LayersPass { - shouldDrawLayer(layer) { - const { operation } = layer.props; - return operation.includes("draw") || operation.includes("terrain"); - } -}; - -// node_modules/@deck.gl/core/dist/lib/deck-renderer.js -var TRACE_RENDER_LAYERS = "deckRenderer.renderLayers"; -var DeckRenderer = class { - constructor(device) { - this.device = device; - this.layerFilter = null; - this.drawPickingColors = false; - this.drawLayersPass = new DrawLayersPass(device); - this.pickLayersPass = new PickLayersPass(device); - this.renderCount = 0; - this._needsRedraw = "Initial render"; - this.renderBuffers = []; - this.lastPostProcessEffect = null; - } - setProps(props) { - if (this.layerFilter !== props.layerFilter) { - this.layerFilter = props.layerFilter; - this._needsRedraw = "layerFilter changed"; - } - if (this.drawPickingColors !== props.drawPickingColors) { - this.drawPickingColors = props.drawPickingColors; - this._needsRedraw = "drawPickingColors changed"; - } - } - renderLayers(opts) { - if (!opts.viewports.length) { - return; - } - const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass; - const renderOpts = { - layerFilter: this.layerFilter, - isPicking: this.drawPickingColors, - ...opts - }; - if (renderOpts.effects) { - this._preRender(renderOpts.effects, renderOpts); - } - const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target; - if (this.lastPostProcessEffect) { - renderOpts.clearColor = [0, 0, 0, 0]; - renderOpts.clearCanvas = true; - } - const renderStats = layerPass.render({ ...renderOpts, target: outputBuffer }); - if (renderOpts.effects) { - this._postRender(renderOpts.effects, renderOpts); - } - this.renderCount++; - debug(TRACE_RENDER_LAYERS, this, renderStats, opts); - } - needsRedraw(opts = { clearRedrawFlags: false }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - return redraw; - } - finalize() { - const { renderBuffers } = this; - for (const buffer of renderBuffers) { - buffer.delete(); - } - renderBuffers.length = 0; - } - _preRender(effects, opts) { - this.lastPostProcessEffect = null; - opts.preRenderStats = opts.preRenderStats || {}; - for (const effect of effects) { - opts.preRenderStats[effect.id] = effect.preRender(opts); - if (effect.postRender) { - this.lastPostProcessEffect = effect.id; - } - } - if (this.lastPostProcessEffect) { - this._resizeRenderBuffers(); - } - } - _resizeRenderBuffers() { - const { renderBuffers } = this; - const size = this.device.canvasContext.getDrawingBufferSize(); - if (renderBuffers.length === 0) { - [0, 1].map((i) => { - const texture = this.device.createTexture({ - sampler: { minFilter: "linear", magFilter: "linear" } - }); - renderBuffers.push(this.device.createFramebuffer({ - id: `deck-renderbuffer-${i}`, - colorAttachments: [texture] - })); - }); - } - for (const buffer of renderBuffers) { - buffer.resize(size); - } - } - _postRender(effects, opts) { - const { renderBuffers } = this; - const params = { - ...opts, - inputBuffer: renderBuffers[0], - swapBuffer: renderBuffers[1] - }; - for (const effect of effects) { - if (effect.postRender) { - params.target = effect.id === this.lastPostProcessEffect ? opts.target : void 0; - const buffer = effect.postRender(params); - params.inputBuffer = buffer; - params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0]; - } - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/picking/query-object.js -var NO_PICKED_OBJECT = { - pickedColor: null, - pickedObjectIndex: -1 -}; -function getClosestObject({ pickedColors, decodePickingColor, deviceX, deviceY, deviceRadius, deviceRect }) { - const { x, y, width, height } = deviceRect; - let minSquareDistanceToCenter = deviceRadius * deviceRadius; - let closestPixelIndex = -1; - let i = 0; - for (let row = 0; row < height; row++) { - const dy = row + y - deviceY; - const dy2 = dy * dy; - if (dy2 > minSquareDistanceToCenter) { - i += 4 * width; - } else { - for (let col = 0; col < width; col++) { - const pickedLayerIndex = pickedColors[i + 3] - 1; - if (pickedLayerIndex >= 0) { - const dx = col + x - deviceX; - const d2 = dx * dx + dy2; - if (d2 <= minSquareDistanceToCenter) { - minSquareDistanceToCenter = d2; - closestPixelIndex = i; - } - } - i += 4; - } - } - } - if (closestPixelIndex >= 0) { - const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4); - const pickedObject = decodePickingColor(pickedColor); - if (pickedObject) { - const dy = Math.floor(closestPixelIndex / 4 / width); - const dx = closestPixelIndex / 4 - dy * width; - return { - ...pickedObject, - pickedColor, - pickedX: x + dx, - pickedY: y + dy - }; - } - log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); - } - return NO_PICKED_OBJECT; -} -function getUniqueObjects({ pickedColors, decodePickingColor }) { - const uniqueColors = /* @__PURE__ */ new Map(); - if (pickedColors) { - for (let i = 0; i < pickedColors.length; i += 4) { - const pickedLayerIndex = pickedColors[i + 3] - 1; - if (pickedLayerIndex >= 0) { - const pickedColor = pickedColors.slice(i, i + 4); - const colorKey = pickedColor.join(","); - if (!uniqueColors.has(colorKey)) { - const pickedObject = decodePickingColor(pickedColor); - if (pickedObject) { - uniqueColors.set(colorKey, { - ...pickedObject, - color: pickedColor - }); - } else { - log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); - } - } - } - } - } - return Array.from(uniqueColors.values()); -} - -// node_modules/@deck.gl/core/dist/lib/picking/pick-info.js -function getEmptyPickingInfo({ pickInfo, viewports, pixelRatio, x, y, z }) { - let pickedViewport = viewports[0]; - if (viewports.length > 1) { - pickedViewport = getViewportFromCoordinates(pickInfo?.pickedViewports || viewports, { x, y }); - } - let coordinate; - if (pickedViewport) { - const point = [x - pickedViewport.x, y - pickedViewport.y]; - if (z !== void 0) { - point[2] = z; - } - coordinate = pickedViewport.unproject(point); - } - return { - color: null, - layer: null, - viewport: pickedViewport, - index: -1, - picked: false, - x, - y, - pixel: [x, y], - coordinate, - devicePixel: pickInfo && "pickedX" in pickInfo ? [pickInfo.pickedX, pickInfo.pickedY] : void 0, - pixelRatio - }; -} -function processPickInfo(opts) { - const { pickInfo, lastPickedInfo, mode, layers } = opts; - const { pickedColor, pickedLayer, pickedObjectIndex } = pickInfo; - const affectedLayers = pickedLayer ? [pickedLayer] : []; - if (mode === "hover") { - const lastPickedPixelIndex = lastPickedInfo.index; - const lastPickedLayerId = lastPickedInfo.layerId; - const pickedLayerId = pickedLayer ? pickedLayer.props.id : null; - if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedPixelIndex) { - if (pickedLayerId !== lastPickedLayerId) { - const lastPickedLayer = layers.find((layer) => layer.props.id === lastPickedLayerId); - if (lastPickedLayer) { - affectedLayers.unshift(lastPickedLayer); - } - } - lastPickedInfo.layerId = pickedLayerId; - lastPickedInfo.index = pickedObjectIndex; - lastPickedInfo.info = null; - } - } - const baseInfo = getEmptyPickingInfo(opts); - const infos = /* @__PURE__ */ new Map(); - infos.set(null, baseInfo); - affectedLayers.forEach((layer) => { - let info = { ...baseInfo }; - if (layer === pickedLayer) { - info.color = pickedColor; - info.index = pickedObjectIndex; - info.picked = true; - } - info = getLayerPickingInfo({ layer, info, mode }); - const rootLayer = info.layer; - if (layer === pickedLayer && mode === "hover") { - lastPickedInfo.info = info; - } - infos.set(rootLayer.id, info); - if (mode === "hover") { - rootLayer.updateAutoHighlight(info); - } - }); - return infos; -} -function getLayerPickingInfo({ layer, info, mode }) { - while (layer && info) { - const sourceLayer = info.layer || null; - info.sourceLayer = sourceLayer; - info.layer = layer; - info = layer.getPickingInfo({ info, mode, sourceLayer }); - layer = layer.parent; - } - return info; -} -function getViewportFromCoordinates(viewports, pixel) { - for (let i = viewports.length - 1; i >= 0; i--) { - const viewport = viewports[i]; - if (viewport.containsPixel(pixel)) { - return viewport; - } - } - return viewports[0]; -} - -// node_modules/@deck.gl/core/dist/lib/deck-picker.js -var DeckPicker = class { - constructor(device) { - this._pickable = true; - this.device = device; - this.pickLayersPass = new PickLayersPass(device); - this.lastPickedInfo = { - index: -1, - layerId: null, - info: null - }; - } - setProps(props) { - if ("layerFilter" in props) { - this.layerFilter = props.layerFilter; - } - if ("_pickable" in props) { - this._pickable = props._pickable; - } - } - finalize() { - if (this.pickingFBO) { - this.pickingFBO.destroy(); - } - if (this.depthFBO) { - this.depthFBO.destroy(); - } - } - /** Pick the closest info at given coordinate */ - pickObject(opts) { - return this._pickClosestObject(opts); - } - /** Get all unique infos within a bounding box */ - pickObjects(opts) { - return this._pickVisibleObjects(opts); - } - // Returns a new picking info object by assuming the last picked object is still picked - getLastPickedObject({ x, y, layers, viewports }, lastPickedInfo = this.lastPickedInfo.info) { - const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id; - const lastPickedViewportId = lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id; - const layer = lastPickedLayerId ? layers.find((l) => l.id === lastPickedLayerId) : null; - const viewport = lastPickedViewportId && viewports.find((v) => v.id === lastPickedViewportId) || viewports[0]; - const coordinate = viewport && viewport.unproject([x - viewport.x, y - viewport.y]); - const info = { - x, - y, - viewport, - coordinate, - layer - }; - return { ...lastPickedInfo, ...info }; - } - // Private - /** Ensures that picking framebuffer exists and matches the canvas size */ - _resizeBuffer() { - if (!this.pickingFBO) { - this.pickingFBO = this.device.createFramebuffer({ - colorAttachments: ["rgba8unorm"], - depthStencilAttachment: "depth16unorm" - }); - if (this.device.isTextureFormatRenderable("rgba32float")) { - const depthFBO = this.device.createFramebuffer({ - colorAttachments: ["rgba32float"], - depthStencilAttachment: "depth16unorm" - }); - this.depthFBO = depthFBO; - } - } - const { canvas: canvas2 } = this.device.getCanvasContext(); - this.pickingFBO?.resize({ width: canvas2.width, height: canvas2.height }); - this.depthFBO?.resize({ width: canvas2.width, height: canvas2.height }); - } - /** Preliminary filtering of the layers list. Skid picking pass if no layer is pickable. */ - _getPickable(layers) { - if (this._pickable === false) { - return null; - } - const pickableLayers = layers.filter((layer) => this.pickLayersPass.shouldDrawLayer(layer) && !layer.isComposite); - return pickableLayers.length ? pickableLayers : null; - } - /** Pick the closest object at the given coordinate */ - // eslint-disable-next-line max-statements,complexity - _pickClosestObject({ layers, views, viewports, x, y, radius = 0, depth = 1, mode = "query", unproject3D, onViewportActive, effects }) { - const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); - const pickableLayers = this._getPickable(layers); - if (!pickableLayers || viewports.length === 0) { - return { - result: [], - emptyInfo: getEmptyPickingInfo({ viewports, x, y, pixelRatio }) - }; - } - this._resizeBuffer(); - const devicePixelRange = this.device.canvasContext.cssToDevicePixels([x, y], true); - const devicePixel = [ - devicePixelRange.x + Math.floor(devicePixelRange.width / 2), - devicePixelRange.y + Math.floor(devicePixelRange.height / 2) - ]; - const deviceRadius = Math.round(radius * pixelRatio); - const { width, height } = this.pickingFBO; - const deviceRect = this._getPickingRect({ - deviceX: devicePixel[0], - deviceY: devicePixel[1], - deviceRadius, - deviceWidth: width, - deviceHeight: height - }); - const cullRect = { - x: x - radius, - y: y - radius, - width: radius * 2 + 1, - height: radius * 2 + 1 - }; - let infos; - const result = []; - const affectedLayers = /* @__PURE__ */ new Set(); - for (let i = 0; i < depth; i++) { - let pickInfo; - if (deviceRect) { - const pickedResult = this._drawAndSample({ - layers: pickableLayers, - views, - viewports, - onViewportActive, - deviceRect, - cullRect, - effects, - pass: `picking:${mode}` - }); - pickInfo = getClosestObject({ - ...pickedResult, - deviceX: devicePixel[0], - deviceY: devicePixel[1], - deviceRadius, - deviceRect - }); - } else { - pickInfo = { - pickedColor: null, - pickedObjectIndex: -1 - }; - } - let z; - if (pickInfo.pickedLayer && unproject3D && this.depthFBO) { - const { pickedColors: pickedColors2 } = this._drawAndSample({ - layers: [pickInfo.pickedLayer], - views, - viewports, - onViewportActive, - deviceRect: { - x: pickInfo.pickedX, - y: pickInfo.pickedY, - width: 1, - height: 1 - }, - cullRect, - effects, - pass: `picking:${mode}:z` - }, true); - if (pickedColors2[3]) { - z = pickedColors2[0]; - } - } - if (pickInfo.pickedLayer && i + 1 < depth) { - affectedLayers.add(pickInfo.pickedLayer); - pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex); - } - infos = processPickInfo({ - pickInfo, - lastPickedInfo: this.lastPickedInfo, - mode, - layers: pickableLayers, - viewports, - x, - y, - z, - pixelRatio - }); - for (const info of infos.values()) { - if (info.layer) { - result.push(info); - } - } - if (!pickInfo.pickedColor) { - break; - } - } - for (const layer of affectedLayers) { - layer.restorePickingColors(); - } - return { result, emptyInfo: infos.get(null) }; - } - /** Pick all objects within the given bounding box */ - _pickVisibleObjects({ layers, views, viewports, x, y, width = 1, height = 1, mode = "query", maxObjects = null, onViewportActive, effects }) { - const pickableLayers = this._getPickable(layers); - if (!pickableLayers || viewports.length === 0) { - return []; - } - this._resizeBuffer(); - const pixelRatio = this.device.canvasContext.cssToDeviceRatio(); - const leftTop = this.device.canvasContext.cssToDevicePixels([x, y], true); - const deviceLeft = leftTop.x; - const deviceTop = leftTop.y + leftTop.height; - const rightBottom = this.device.canvasContext.cssToDevicePixels([x + width, y + height], true); - const deviceRight = rightBottom.x + rightBottom.width; - const deviceBottom = rightBottom.y; - const deviceRect = { - x: deviceLeft, - y: deviceBottom, - // deviceTop and deviceRight represent the first pixel outside the desired rect - width: deviceRight - deviceLeft, - height: deviceTop - deviceBottom - }; - const pickedResult = this._drawAndSample({ - layers: pickableLayers, - views, - viewports, - onViewportActive, - deviceRect, - cullRect: { x, y, width, height }, - effects, - pass: `picking:${mode}` - }); - const pickInfos = getUniqueObjects(pickedResult); - const uniquePickedObjects = /* @__PURE__ */ new Map(); - const uniqueInfos = []; - const limitMaxObjects = Number.isFinite(maxObjects); - for (let i = 0; i < pickInfos.length; i++) { - if (limitMaxObjects && uniqueInfos.length >= maxObjects) { - break; - } - const pickInfo = pickInfos[i]; - let info = { - color: pickInfo.pickedColor, - layer: null, - index: pickInfo.pickedObjectIndex, - picked: true, - x, - y, - pixelRatio - }; - info = getLayerPickingInfo({ layer: pickInfo.pickedLayer, info, mode }); - const pickedLayerId = info.layer.id; - if (!uniquePickedObjects.has(pickedLayerId)) { - uniquePickedObjects.set(pickedLayerId, /* @__PURE__ */ new Set()); - } - const uniqueObjectsInLayer = uniquePickedObjects.get(pickedLayerId); - const pickedObjectKey = info.object ?? info.index; - if (!uniqueObjectsInLayer.has(pickedObjectKey)) { - uniqueObjectsInLayer.add(pickedObjectKey); - uniqueInfos.push(info); - } - } - return uniqueInfos; - } - _drawAndSample({ layers, views, viewports, onViewportActive, deviceRect, cullRect, effects, pass }, pickZ = false) { - const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO; - const opts = { - layers, - layerFilter: this.layerFilter, - views, - viewports, - onViewportActive, - pickingFBO, - deviceRect, - cullRect, - effects, - pass, - pickZ, - preRenderStats: {} - }; - for (const effect of effects) { - if (effect.useInPicking) { - opts.preRenderStats[effect.id] = effect.preRender(opts); - } - } - const { decodePickingColor } = this.pickLayersPass.render(opts); - const { x, y, width, height } = deviceRect; - const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4); - this.device.readPixelsToArrayWebGL(pickingFBO, { - sourceX: x, - sourceY: y, - sourceWidth: width, - sourceHeight: height, - target: pickedColors - }); - return { pickedColors, decodePickingColor }; - } - // Calculate a picking rect centered on deviceX and deviceY and clipped to device - // Returns null if pixel is outside of device - _getPickingRect({ deviceX, deviceY, deviceRadius, deviceWidth, deviceHeight }) { - const x = Math.max(0, deviceX - deviceRadius); - const y = Math.max(0, deviceY - deviceRadius); - const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x; - const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y; - if (width <= 0 || height <= 0) { - return null; - } - return { x, y, width, height }; - } -}; - -// node_modules/@deck.gl/core/dist/lib/widget-manager.js -var PLACEMENTS = { - "top-left": { top: 0, left: 0 }, - "top-right": { top: 0, right: 0 }, - "bottom-left": { bottom: 0, left: 0 }, - "bottom-right": { bottom: 0, right: 0 }, - fill: { top: 0, left: 0, bottom: 0, right: 0 } -}; -var DEFAULT_PLACEMENT = "top-left"; -var ROOT_CONTAINER_ID = "__root"; -var WidgetManager = class { - constructor({ deck, parentElement }) { - this.defaultWidgets = []; - this.widgets = []; - this.resolvedWidgets = []; - this.containers = {}; - this.lastViewports = {}; - this.deck = deck; - this.parentElement = parentElement; - } - getWidgets() { - return this.resolvedWidgets; - } - /** Declarative API to configure widgets */ - setProps(props) { - if (props.widgets && !deepEqual2(props.widgets, this.widgets, 1)) { - this._setWidgets(props.widgets); - } - } - finalize() { - for (const widget of this.getWidgets()) { - this._remove(widget); - } - this.defaultWidgets.length = 0; - this.resolvedWidgets.length = 0; - for (const id in this.containers) { - this.containers[id].remove(); - } - } - /** Imperative API. Widgets added this way are not affected by the declarative prop. */ - addDefault(widget) { - if (!this.defaultWidgets.find((w) => w.id === widget.id)) { - this._add(widget); - this.defaultWidgets.push(widget); - this._setWidgets(this.widgets); - } - } - /** Resolve widgets from the declarative prop */ - _setWidgets(nextWidgets) { - const oldWidgetMap = {}; - for (const widget of this.resolvedWidgets) { - oldWidgetMap[widget.id] = widget; - } - this.resolvedWidgets.length = 0; - for (const widget of this.defaultWidgets) { - oldWidgetMap[widget.id] = null; - this.resolvedWidgets.push(widget); - } - for (let widget of nextWidgets) { - const oldWidget = oldWidgetMap[widget.id]; - if (!oldWidget) { - this._add(widget); - } else if ( - // Widget placement changed - oldWidget.viewId !== widget.viewId || oldWidget.placement !== widget.placement - ) { - this._remove(oldWidget); - this._add(widget); - } else if (widget !== oldWidget) { - oldWidget.setProps(widget.props); - widget = oldWidget; - } - oldWidgetMap[widget.id] = null; - this.resolvedWidgets.push(widget); - } - for (const id in oldWidgetMap) { - const oldWidget = oldWidgetMap[id]; - if (oldWidget) { - this._remove(oldWidget); - } - } - this.widgets = nextWidgets; - } - _add(widget) { - const { viewId = null, placement = DEFAULT_PLACEMENT } = widget; - const element = widget.onAdd({ deck: this.deck, viewId }); - if (element) { - this._getContainer(viewId, placement).append(element); - } - widget._element = element; - } - _remove(widget) { - widget.onRemove(); - if (widget._element) { - widget._element.remove(); - } - widget._element = void 0; - } - /* global document */ - _getContainer(viewId, placement) { - const containerId = viewId || ROOT_CONTAINER_ID; - let viewContainer = this.containers[containerId]; - if (!viewContainer) { - viewContainer = document.createElement("div"); - viewContainer.style.pointerEvents = "none"; - viewContainer.style.position = "absolute"; - viewContainer.style.overflow = "hidden"; - this.parentElement?.append(viewContainer); - this.containers[containerId] = viewContainer; - } - let container = viewContainer.querySelector(`.${placement}`); - if (!container) { - container = document.createElement("div"); - container.className = placement; - container.style.position = "absolute"; - container.style.zIndex = "2"; - Object.assign(container.style, PLACEMENTS[placement]); - viewContainer.append(container); - } - return container; - } - _updateContainers() { - const canvasWidth = this.deck.width; - const canvasHeight = this.deck.height; - for (const id in this.containers) { - const viewport = this.lastViewports[id] || null; - const visible = id === ROOT_CONTAINER_ID || viewport; - const container = this.containers[id]; - if (visible) { - container.style.display = "block"; - container.style.left = `${viewport ? viewport.x : 0}px`; - container.style.top = `${viewport ? viewport.y : 0}px`; - container.style.width = `${viewport ? viewport.width : canvasWidth}px`; - container.style.height = `${viewport ? viewport.height : canvasHeight}px`; - } else { - container.style.display = "none"; - } - } - } - onRedraw({ viewports, layers }) { - const viewportsById = viewports.reduce((acc, v) => { - acc[v.id] = v; - return acc; - }, {}); - const { lastViewports } = this; - for (const widget of this.getWidgets()) { - const { viewId } = widget; - if (viewId) { - const viewport = viewportsById[viewId]; - if (viewport) { - if (widget.onViewportChange && !viewport.equals(lastViewports[viewId])) { - widget.onViewportChange(viewport); - } - widget.onRedraw?.({ viewports: [viewport], layers }); - } - } else { - if (widget.onViewportChange) { - for (const viewport of viewports) { - if (!viewport.equals(lastViewports[viewport.id])) { - widget.onViewportChange(viewport); - } - } - } - widget.onRedraw?.({ viewports, layers }); - } - } - this.lastViewports = viewportsById; - this._updateContainers(); - } - onHover(info, event) { - for (const widget of this.getWidgets()) { - const { viewId } = widget; - if (!viewId || viewId === info.viewport?.id) { - widget.onHover?.(info, event); - } - } - } - onEvent(info, event) { - const eventOptions = EVENTS[event.type]; - if (!eventOptions) { - return; - } - for (const widget of this.getWidgets()) { - const { viewId } = widget; - if (!viewId || viewId === info.viewport?.id) { - widget[eventOptions.handler]?.(info, event); - } - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/tooltip.js -var defaultStyle = { - zIndex: "1", - position: "absolute", - pointerEvents: "none", - color: "#a0a7b4", - backgroundColor: "#29323c", - padding: "10px", - top: "0", - left: "0", - display: "none" -}; -var Tooltip = class { - constructor() { - this.id = "default-tooltip"; - this.placement = "fill"; - this.props = {}; - this.isVisible = false; - } - onAdd({ deck }) { - const el = document.createElement("div"); - el.className = "deck-tooltip"; - Object.assign(el.style, defaultStyle); - this.deck = deck; - this.element = el; - return el; - } - onRemove() { - this.deck = void 0; - this.element = void 0; - } - setProps() { - } - onViewportChange(viewport) { - if (this.isVisible && viewport.id === this.lastViewport?.id && viewport !== this.lastViewport) { - this.setTooltip(null); - } - } - onHover(info) { - const { deck } = this; - const getTooltip = deck && deck.props.getTooltip; - if (!getTooltip) { - return; - } - const displayInfo = getTooltip(info); - this.lastViewport = info.viewport; - this.setTooltip(displayInfo, info.x, info.y); - } - setTooltip(displayInfo, x, y) { - const el = this.element; - if (!el) { - return; - } - if (typeof displayInfo === "string") { - el.innerText = displayInfo; - } else if (!displayInfo) { - this.isVisible = false; - el.style.display = "none"; - return; - } else { - if (displayInfo.text) { - el.innerText = displayInfo.text; - } - if (displayInfo.html) { - el.innerHTML = displayInfo.html; - } - if (displayInfo.className) { - el.className = displayInfo.className; - } - } - this.isVisible = true; - el.style.display = "block"; - el.style.transform = `translate(${x}px, ${y}px)`; - if (displayInfo && typeof displayInfo === "object" && "style" in displayInfo) { - Object.assign(el.style, displayInfo.style); - } - } -}; - -// node_modules/@luma.gl/constants/dist/webgl-constants.js -var GLEnum; -(function(GLEnum2) { - GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT"; - GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT"; - GLEnum2[GLEnum2["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT"; - GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS"; - GLEnum2[GLEnum2["LINES"] = 1] = "LINES"; - GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP"; - GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP"; - GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES"; - GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP"; - GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN"; - GLEnum2[GLEnum2["ZERO"] = 0] = "ZERO"; - GLEnum2[GLEnum2["ONE"] = 1] = "ONE"; - GLEnum2[GLEnum2["SRC_COLOR"] = 768] = "SRC_COLOR"; - GLEnum2[GLEnum2["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR"; - GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA"; - GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA"; - GLEnum2[GLEnum2["DST_ALPHA"] = 772] = "DST_ALPHA"; - GLEnum2[GLEnum2["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA"; - GLEnum2[GLEnum2["DST_COLOR"] = 774] = "DST_COLOR"; - GLEnum2[GLEnum2["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR"; - GLEnum2[GLEnum2["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE"; - GLEnum2[GLEnum2["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR"; - GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR"; - GLEnum2[GLEnum2["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA"; - GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA"; - GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD"; - GLEnum2[GLEnum2["FUNC_SUBTRACT"] = 32778] = "FUNC_SUBTRACT"; - GLEnum2[GLEnum2["FUNC_REVERSE_SUBTRACT"] = 32779] = "FUNC_REVERSE_SUBTRACT"; - GLEnum2[GLEnum2["BLEND_EQUATION"] = 32777] = "BLEND_EQUATION"; - GLEnum2[GLEnum2["BLEND_EQUATION_RGB"] = 32777] = "BLEND_EQUATION_RGB"; - GLEnum2[GLEnum2["BLEND_EQUATION_ALPHA"] = 34877] = "BLEND_EQUATION_ALPHA"; - GLEnum2[GLEnum2["BLEND_DST_RGB"] = 32968] = "BLEND_DST_RGB"; - GLEnum2[GLEnum2["BLEND_SRC_RGB"] = 32969] = "BLEND_SRC_RGB"; - GLEnum2[GLEnum2["BLEND_DST_ALPHA"] = 32970] = "BLEND_DST_ALPHA"; - GLEnum2[GLEnum2["BLEND_SRC_ALPHA"] = 32971] = "BLEND_SRC_ALPHA"; - GLEnum2[GLEnum2["BLEND_COLOR"] = 32773] = "BLEND_COLOR"; - GLEnum2[GLEnum2["ARRAY_BUFFER_BINDING"] = 34964] = "ARRAY_BUFFER_BINDING"; - GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER_BINDING"] = 34965] = "ELEMENT_ARRAY_BUFFER_BINDING"; - GLEnum2[GLEnum2["LINE_WIDTH"] = 2849] = "LINE_WIDTH"; - GLEnum2[GLEnum2["ALIASED_POINT_SIZE_RANGE"] = 33901] = "ALIASED_POINT_SIZE_RANGE"; - GLEnum2[GLEnum2["ALIASED_LINE_WIDTH_RANGE"] = 33902] = "ALIASED_LINE_WIDTH_RANGE"; - GLEnum2[GLEnum2["CULL_FACE_MODE"] = 2885] = "CULL_FACE_MODE"; - GLEnum2[GLEnum2["FRONT_FACE"] = 2886] = "FRONT_FACE"; - GLEnum2[GLEnum2["DEPTH_RANGE"] = 2928] = "DEPTH_RANGE"; - GLEnum2[GLEnum2["DEPTH_WRITEMASK"] = 2930] = "DEPTH_WRITEMASK"; - GLEnum2[GLEnum2["DEPTH_CLEAR_VALUE"] = 2931] = "DEPTH_CLEAR_VALUE"; - GLEnum2[GLEnum2["DEPTH_FUNC"] = 2932] = "DEPTH_FUNC"; - GLEnum2[GLEnum2["STENCIL_CLEAR_VALUE"] = 2961] = "STENCIL_CLEAR_VALUE"; - GLEnum2[GLEnum2["STENCIL_FUNC"] = 2962] = "STENCIL_FUNC"; - GLEnum2[GLEnum2["STENCIL_FAIL"] = 2964] = "STENCIL_FAIL"; - GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_FAIL"] = 2965] = "STENCIL_PASS_DEPTH_FAIL"; - GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_PASS"] = 2966] = "STENCIL_PASS_DEPTH_PASS"; - GLEnum2[GLEnum2["STENCIL_REF"] = 2967] = "STENCIL_REF"; - GLEnum2[GLEnum2["STENCIL_VALUE_MASK"] = 2963] = "STENCIL_VALUE_MASK"; - GLEnum2[GLEnum2["STENCIL_WRITEMASK"] = 2968] = "STENCIL_WRITEMASK"; - GLEnum2[GLEnum2["STENCIL_BACK_FUNC"] = 34816] = "STENCIL_BACK_FUNC"; - GLEnum2[GLEnum2["STENCIL_BACK_FAIL"] = 34817] = "STENCIL_BACK_FAIL"; - GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_FAIL"] = 34818] = "STENCIL_BACK_PASS_DEPTH_FAIL"; - GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_PASS"] = 34819] = "STENCIL_BACK_PASS_DEPTH_PASS"; - GLEnum2[GLEnum2["STENCIL_BACK_REF"] = 36003] = "STENCIL_BACK_REF"; - GLEnum2[GLEnum2["STENCIL_BACK_VALUE_MASK"] = 36004] = "STENCIL_BACK_VALUE_MASK"; - GLEnum2[GLEnum2["STENCIL_BACK_WRITEMASK"] = 36005] = "STENCIL_BACK_WRITEMASK"; - GLEnum2[GLEnum2["VIEWPORT"] = 2978] = "VIEWPORT"; - GLEnum2[GLEnum2["SCISSOR_BOX"] = 3088] = "SCISSOR_BOX"; - GLEnum2[GLEnum2["COLOR_CLEAR_VALUE"] = 3106] = "COLOR_CLEAR_VALUE"; - GLEnum2[GLEnum2["COLOR_WRITEMASK"] = 3107] = "COLOR_WRITEMASK"; - GLEnum2[GLEnum2["UNPACK_ALIGNMENT"] = 3317] = "UNPACK_ALIGNMENT"; - GLEnum2[GLEnum2["PACK_ALIGNMENT"] = 3333] = "PACK_ALIGNMENT"; - GLEnum2[GLEnum2["MAX_TEXTURE_SIZE"] = 3379] = "MAX_TEXTURE_SIZE"; - GLEnum2[GLEnum2["MAX_VIEWPORT_DIMS"] = 3386] = "MAX_VIEWPORT_DIMS"; - GLEnum2[GLEnum2["SUBPIXEL_BITS"] = 3408] = "SUBPIXEL_BITS"; - GLEnum2[GLEnum2["RED_BITS"] = 3410] = "RED_BITS"; - GLEnum2[GLEnum2["GREEN_BITS"] = 3411] = "GREEN_BITS"; - GLEnum2[GLEnum2["BLUE_BITS"] = 3412] = "BLUE_BITS"; - GLEnum2[GLEnum2["ALPHA_BITS"] = 3413] = "ALPHA_BITS"; - GLEnum2[GLEnum2["DEPTH_BITS"] = 3414] = "DEPTH_BITS"; - GLEnum2[GLEnum2["STENCIL_BITS"] = 3415] = "STENCIL_BITS"; - GLEnum2[GLEnum2["POLYGON_OFFSET_UNITS"] = 10752] = "POLYGON_OFFSET_UNITS"; - GLEnum2[GLEnum2["POLYGON_OFFSET_FACTOR"] = 32824] = "POLYGON_OFFSET_FACTOR"; - GLEnum2[GLEnum2["TEXTURE_BINDING_2D"] = 32873] = "TEXTURE_BINDING_2D"; - GLEnum2[GLEnum2["SAMPLE_BUFFERS"] = 32936] = "SAMPLE_BUFFERS"; - GLEnum2[GLEnum2["SAMPLES"] = 32937] = "SAMPLES"; - GLEnum2[GLEnum2["SAMPLE_COVERAGE_VALUE"] = 32938] = "SAMPLE_COVERAGE_VALUE"; - GLEnum2[GLEnum2["SAMPLE_COVERAGE_INVERT"] = 32939] = "SAMPLE_COVERAGE_INVERT"; - GLEnum2[GLEnum2["COMPRESSED_TEXTURE_FORMATS"] = 34467] = "COMPRESSED_TEXTURE_FORMATS"; - GLEnum2[GLEnum2["VENDOR"] = 7936] = "VENDOR"; - GLEnum2[GLEnum2["RENDERER"] = 7937] = "RENDERER"; - GLEnum2[GLEnum2["VERSION"] = 7938] = "VERSION"; - GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_TYPE"] = 35738] = "IMPLEMENTATION_COLOR_READ_TYPE"; - GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_FORMAT"] = 35739] = "IMPLEMENTATION_COLOR_READ_FORMAT"; - GLEnum2[GLEnum2["BROWSER_DEFAULT_WEBGL"] = 37444] = "BROWSER_DEFAULT_WEBGL"; - GLEnum2[GLEnum2["STATIC_DRAW"] = 35044] = "STATIC_DRAW"; - GLEnum2[GLEnum2["STREAM_DRAW"] = 35040] = "STREAM_DRAW"; - GLEnum2[GLEnum2["DYNAMIC_DRAW"] = 35048] = "DYNAMIC_DRAW"; - GLEnum2[GLEnum2["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER"; - GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER"; - GLEnum2[GLEnum2["BUFFER_SIZE"] = 34660] = "BUFFER_SIZE"; - GLEnum2[GLEnum2["BUFFER_USAGE"] = 34661] = "BUFFER_USAGE"; - GLEnum2[GLEnum2["CURRENT_VERTEX_ATTRIB"] = 34342] = "CURRENT_VERTEX_ATTRIB"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_ENABLED"] = 34338] = "VERTEX_ATTRIB_ARRAY_ENABLED"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_SIZE"] = 34339] = "VERTEX_ATTRIB_ARRAY_SIZE"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_STRIDE"] = 34340] = "VERTEX_ATTRIB_ARRAY_STRIDE"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_TYPE"] = 34341] = "VERTEX_ATTRIB_ARRAY_TYPE"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_NORMALIZED"] = 34922] = "VERTEX_ATTRIB_ARRAY_NORMALIZED"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_POINTER"] = 34373] = "VERTEX_ATTRIB_ARRAY_POINTER"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"] = 34975] = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; - GLEnum2[GLEnum2["CULL_FACE"] = 2884] = "CULL_FACE"; - GLEnum2[GLEnum2["FRONT"] = 1028] = "FRONT"; - GLEnum2[GLEnum2["BACK"] = 1029] = "BACK"; - GLEnum2[GLEnum2["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK"; - GLEnum2[GLEnum2["BLEND"] = 3042] = "BLEND"; - GLEnum2[GLEnum2["DEPTH_TEST"] = 2929] = "DEPTH_TEST"; - GLEnum2[GLEnum2["DITHER"] = 3024] = "DITHER"; - GLEnum2[GLEnum2["POLYGON_OFFSET_FILL"] = 32823] = "POLYGON_OFFSET_FILL"; - GLEnum2[GLEnum2["SAMPLE_ALPHA_TO_COVERAGE"] = 32926] = "SAMPLE_ALPHA_TO_COVERAGE"; - GLEnum2[GLEnum2["SAMPLE_COVERAGE"] = 32928] = "SAMPLE_COVERAGE"; - GLEnum2[GLEnum2["SCISSOR_TEST"] = 3089] = "SCISSOR_TEST"; - GLEnum2[GLEnum2["STENCIL_TEST"] = 2960] = "STENCIL_TEST"; - GLEnum2[GLEnum2["NO_ERROR"] = 0] = "NO_ERROR"; - GLEnum2[GLEnum2["INVALID_ENUM"] = 1280] = "INVALID_ENUM"; - GLEnum2[GLEnum2["INVALID_VALUE"] = 1281] = "INVALID_VALUE"; - GLEnum2[GLEnum2["INVALID_OPERATION"] = 1282] = "INVALID_OPERATION"; - GLEnum2[GLEnum2["OUT_OF_MEMORY"] = 1285] = "OUT_OF_MEMORY"; - GLEnum2[GLEnum2["CONTEXT_LOST_WEBGL"] = 37442] = "CONTEXT_LOST_WEBGL"; - GLEnum2[GLEnum2["CW"] = 2304] = "CW"; - GLEnum2[GLEnum2["CCW"] = 2305] = "CCW"; - GLEnum2[GLEnum2["DONT_CARE"] = 4352] = "DONT_CARE"; - GLEnum2[GLEnum2["FASTEST"] = 4353] = "FASTEST"; - GLEnum2[GLEnum2["NICEST"] = 4354] = "NICEST"; - GLEnum2[GLEnum2["GENERATE_MIPMAP_HINT"] = 33170] = "GENERATE_MIPMAP_HINT"; - GLEnum2[GLEnum2["BYTE"] = 5120] = "BYTE"; - GLEnum2[GLEnum2["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE"; - GLEnum2[GLEnum2["SHORT"] = 5122] = "SHORT"; - GLEnum2[GLEnum2["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT"; - GLEnum2[GLEnum2["INT"] = 5124] = "INT"; - GLEnum2[GLEnum2["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT"; - GLEnum2[GLEnum2["FLOAT"] = 5126] = "FLOAT"; - GLEnum2[GLEnum2["DOUBLE"] = 5130] = "DOUBLE"; - GLEnum2[GLEnum2["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT"; - GLEnum2[GLEnum2["ALPHA"] = 6406] = "ALPHA"; - GLEnum2[GLEnum2["RGB"] = 6407] = "RGB"; - GLEnum2[GLEnum2["RGBA"] = 6408] = "RGBA"; - GLEnum2[GLEnum2["LUMINANCE"] = 6409] = "LUMINANCE"; - GLEnum2[GLEnum2["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA"; - GLEnum2[GLEnum2["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4"; - GLEnum2[GLEnum2["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1"; - GLEnum2[GLEnum2["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5"; - GLEnum2[GLEnum2["FRAGMENT_SHADER"] = 35632] = "FRAGMENT_SHADER"; - GLEnum2[GLEnum2["VERTEX_SHADER"] = 35633] = "VERTEX_SHADER"; - GLEnum2[GLEnum2["COMPILE_STATUS"] = 35713] = "COMPILE_STATUS"; - GLEnum2[GLEnum2["DELETE_STATUS"] = 35712] = "DELETE_STATUS"; - GLEnum2[GLEnum2["LINK_STATUS"] = 35714] = "LINK_STATUS"; - GLEnum2[GLEnum2["VALIDATE_STATUS"] = 35715] = "VALIDATE_STATUS"; - GLEnum2[GLEnum2["ATTACHED_SHADERS"] = 35717] = "ATTACHED_SHADERS"; - GLEnum2[GLEnum2["ACTIVE_ATTRIBUTES"] = 35721] = "ACTIVE_ATTRIBUTES"; - GLEnum2[GLEnum2["ACTIVE_UNIFORMS"] = 35718] = "ACTIVE_UNIFORMS"; - GLEnum2[GLEnum2["MAX_VERTEX_ATTRIBS"] = 34921] = "MAX_VERTEX_ATTRIBS"; - GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_VECTORS"] = 36347] = "MAX_VERTEX_UNIFORM_VECTORS"; - GLEnum2[GLEnum2["MAX_VARYING_VECTORS"] = 36348] = "MAX_VARYING_VECTORS"; - GLEnum2[GLEnum2["MAX_COMBINED_TEXTURE_IMAGE_UNITS"] = 35661] = "MAX_COMBINED_TEXTURE_IMAGE_UNITS"; - GLEnum2[GLEnum2["MAX_VERTEX_TEXTURE_IMAGE_UNITS"] = 35660] = "MAX_VERTEX_TEXTURE_IMAGE_UNITS"; - GLEnum2[GLEnum2["MAX_TEXTURE_IMAGE_UNITS"] = 34930] = "MAX_TEXTURE_IMAGE_UNITS"; - GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_VECTORS"] = 36349] = "MAX_FRAGMENT_UNIFORM_VECTORS"; - GLEnum2[GLEnum2["SHADER_TYPE"] = 35663] = "SHADER_TYPE"; - GLEnum2[GLEnum2["SHADING_LANGUAGE_VERSION"] = 35724] = "SHADING_LANGUAGE_VERSION"; - GLEnum2[GLEnum2["CURRENT_PROGRAM"] = 35725] = "CURRENT_PROGRAM"; - GLEnum2[GLEnum2["NEVER"] = 512] = "NEVER"; - GLEnum2[GLEnum2["LESS"] = 513] = "LESS"; - GLEnum2[GLEnum2["EQUAL"] = 514] = "EQUAL"; - GLEnum2[GLEnum2["LEQUAL"] = 515] = "LEQUAL"; - GLEnum2[GLEnum2["GREATER"] = 516] = "GREATER"; - GLEnum2[GLEnum2["NOTEQUAL"] = 517] = "NOTEQUAL"; - GLEnum2[GLEnum2["GEQUAL"] = 518] = "GEQUAL"; - GLEnum2[GLEnum2["ALWAYS"] = 519] = "ALWAYS"; - GLEnum2[GLEnum2["KEEP"] = 7680] = "KEEP"; - GLEnum2[GLEnum2["REPLACE"] = 7681] = "REPLACE"; - GLEnum2[GLEnum2["INCR"] = 7682] = "INCR"; - GLEnum2[GLEnum2["DECR"] = 7683] = "DECR"; - GLEnum2[GLEnum2["INVERT"] = 5386] = "INVERT"; - GLEnum2[GLEnum2["INCR_WRAP"] = 34055] = "INCR_WRAP"; - GLEnum2[GLEnum2["DECR_WRAP"] = 34056] = "DECR_WRAP"; - GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST"; - GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR"; - GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST"; - GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST"; - GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR"; - GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR"; - GLEnum2[GLEnum2["TEXTURE_MAG_FILTER"] = 10240] = "TEXTURE_MAG_FILTER"; - GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER"; - GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S"; - GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T"; - GLEnum2[GLEnum2["TEXTURE_2D"] = 3553] = "TEXTURE_2D"; - GLEnum2[GLEnum2["TEXTURE"] = 5890] = "TEXTURE"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP"; - GLEnum2[GLEnum2["TEXTURE_BINDING_CUBE_MAP"] = 34068] = "TEXTURE_BINDING_CUBE_MAP"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z"; - GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z"; - GLEnum2[GLEnum2["MAX_CUBE_MAP_TEXTURE_SIZE"] = 34076] = "MAX_CUBE_MAP_TEXTURE_SIZE"; - GLEnum2[GLEnum2["TEXTURE0"] = 33984] = "TEXTURE0"; - GLEnum2[GLEnum2["ACTIVE_TEXTURE"] = 34016] = "ACTIVE_TEXTURE"; - GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT"; - GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE"; - GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT"; - GLEnum2[GLEnum2["TEXTURE_WIDTH"] = 4096] = "TEXTURE_WIDTH"; - GLEnum2[GLEnum2["TEXTURE_HEIGHT"] = 4097] = "TEXTURE_HEIGHT"; - GLEnum2[GLEnum2["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2"; - GLEnum2[GLEnum2["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3"; - GLEnum2[GLEnum2["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4"; - GLEnum2[GLEnum2["INT_VEC2"] = 35667] = "INT_VEC2"; - GLEnum2[GLEnum2["INT_VEC3"] = 35668] = "INT_VEC3"; - GLEnum2[GLEnum2["INT_VEC4"] = 35669] = "INT_VEC4"; - GLEnum2[GLEnum2["BOOL"] = 35670] = "BOOL"; - GLEnum2[GLEnum2["BOOL_VEC2"] = 35671] = "BOOL_VEC2"; - GLEnum2[GLEnum2["BOOL_VEC3"] = 35672] = "BOOL_VEC3"; - GLEnum2[GLEnum2["BOOL_VEC4"] = 35673] = "BOOL_VEC4"; - GLEnum2[GLEnum2["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2"; - GLEnum2[GLEnum2["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3"; - GLEnum2[GLEnum2["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4"; - GLEnum2[GLEnum2["SAMPLER_2D"] = 35678] = "SAMPLER_2D"; - GLEnum2[GLEnum2["SAMPLER_CUBE"] = 35680] = "SAMPLER_CUBE"; - GLEnum2[GLEnum2["LOW_FLOAT"] = 36336] = "LOW_FLOAT"; - GLEnum2[GLEnum2["MEDIUM_FLOAT"] = 36337] = "MEDIUM_FLOAT"; - GLEnum2[GLEnum2["HIGH_FLOAT"] = 36338] = "HIGH_FLOAT"; - GLEnum2[GLEnum2["LOW_INT"] = 36339] = "LOW_INT"; - GLEnum2[GLEnum2["MEDIUM_INT"] = 36340] = "MEDIUM_INT"; - GLEnum2[GLEnum2["HIGH_INT"] = 36341] = "HIGH_INT"; - GLEnum2[GLEnum2["FRAMEBUFFER"] = 36160] = "FRAMEBUFFER"; - GLEnum2[GLEnum2["RENDERBUFFER"] = 36161] = "RENDERBUFFER"; - GLEnum2[GLEnum2["RGBA4"] = 32854] = "RGBA4"; - GLEnum2[GLEnum2["RGB5_A1"] = 32855] = "RGB5_A1"; - GLEnum2[GLEnum2["RGB565"] = 36194] = "RGB565"; - GLEnum2[GLEnum2["DEPTH_COMPONENT16"] = 33189] = "DEPTH_COMPONENT16"; - GLEnum2[GLEnum2["STENCIL_INDEX"] = 6401] = "STENCIL_INDEX"; - GLEnum2[GLEnum2["STENCIL_INDEX8"] = 36168] = "STENCIL_INDEX8"; - GLEnum2[GLEnum2["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL"; - GLEnum2[GLEnum2["RENDERBUFFER_WIDTH"] = 36162] = "RENDERBUFFER_WIDTH"; - GLEnum2[GLEnum2["RENDERBUFFER_HEIGHT"] = 36163] = "RENDERBUFFER_HEIGHT"; - GLEnum2[GLEnum2["RENDERBUFFER_INTERNAL_FORMAT"] = 36164] = "RENDERBUFFER_INTERNAL_FORMAT"; - GLEnum2[GLEnum2["RENDERBUFFER_RED_SIZE"] = 36176] = "RENDERBUFFER_RED_SIZE"; - GLEnum2[GLEnum2["RENDERBUFFER_GREEN_SIZE"] = 36177] = "RENDERBUFFER_GREEN_SIZE"; - GLEnum2[GLEnum2["RENDERBUFFER_BLUE_SIZE"] = 36178] = "RENDERBUFFER_BLUE_SIZE"; - GLEnum2[GLEnum2["RENDERBUFFER_ALPHA_SIZE"] = 36179] = "RENDERBUFFER_ALPHA_SIZE"; - GLEnum2[GLEnum2["RENDERBUFFER_DEPTH_SIZE"] = 36180] = "RENDERBUFFER_DEPTH_SIZE"; - GLEnum2[GLEnum2["RENDERBUFFER_STENCIL_SIZE"] = 36181] = "RENDERBUFFER_STENCIL_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"] = 36048] = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"] = 36049] = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"] = 36050] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"] = 36051] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT0"] = 36064] = "COLOR_ATTACHMENT0"; - GLEnum2[GLEnum2["DEPTH_ATTACHMENT"] = 36096] = "DEPTH_ATTACHMENT"; - GLEnum2[GLEnum2["STENCIL_ATTACHMENT"] = 36128] = "STENCIL_ATTACHMENT"; - GLEnum2[GLEnum2["DEPTH_STENCIL_ATTACHMENT"] = 33306] = "DEPTH_STENCIL_ATTACHMENT"; - GLEnum2[GLEnum2["NONE"] = 0] = "NONE"; - GLEnum2[GLEnum2["FRAMEBUFFER_COMPLETE"] = 36053] = "FRAMEBUFFER_COMPLETE"; - GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_ATTACHMENT"] = 36054] = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; - GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"] = 36055] = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; - GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_DIMENSIONS"] = 36057] = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"; - GLEnum2[GLEnum2["FRAMEBUFFER_UNSUPPORTED"] = 36061] = "FRAMEBUFFER_UNSUPPORTED"; - GLEnum2[GLEnum2["FRAMEBUFFER_BINDING"] = 36006] = "FRAMEBUFFER_BINDING"; - GLEnum2[GLEnum2["RENDERBUFFER_BINDING"] = 36007] = "RENDERBUFFER_BINDING"; - GLEnum2[GLEnum2["READ_FRAMEBUFFER"] = 36008] = "READ_FRAMEBUFFER"; - GLEnum2[GLEnum2["DRAW_FRAMEBUFFER"] = 36009] = "DRAW_FRAMEBUFFER"; - GLEnum2[GLEnum2["MAX_RENDERBUFFER_SIZE"] = 34024] = "MAX_RENDERBUFFER_SIZE"; - GLEnum2[GLEnum2["INVALID_FRAMEBUFFER_OPERATION"] = 1286] = "INVALID_FRAMEBUFFER_OPERATION"; - GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL"; - GLEnum2[GLEnum2["UNPACK_PREMULTIPLY_ALPHA_WEBGL"] = 37441] = "UNPACK_PREMULTIPLY_ALPHA_WEBGL"; - GLEnum2[GLEnum2["UNPACK_COLORSPACE_CONVERSION_WEBGL"] = 37443] = "UNPACK_COLORSPACE_CONVERSION_WEBGL"; - GLEnum2[GLEnum2["READ_BUFFER"] = 3074] = "READ_BUFFER"; - GLEnum2[GLEnum2["UNPACK_ROW_LENGTH"] = 3314] = "UNPACK_ROW_LENGTH"; - GLEnum2[GLEnum2["UNPACK_SKIP_ROWS"] = 3315] = "UNPACK_SKIP_ROWS"; - GLEnum2[GLEnum2["UNPACK_SKIP_PIXELS"] = 3316] = "UNPACK_SKIP_PIXELS"; - GLEnum2[GLEnum2["PACK_ROW_LENGTH"] = 3330] = "PACK_ROW_LENGTH"; - GLEnum2[GLEnum2["PACK_SKIP_ROWS"] = 3331] = "PACK_SKIP_ROWS"; - GLEnum2[GLEnum2["PACK_SKIP_PIXELS"] = 3332] = "PACK_SKIP_PIXELS"; - GLEnum2[GLEnum2["TEXTURE_BINDING_3D"] = 32874] = "TEXTURE_BINDING_3D"; - GLEnum2[GLEnum2["UNPACK_SKIP_IMAGES"] = 32877] = "UNPACK_SKIP_IMAGES"; - GLEnum2[GLEnum2["UNPACK_IMAGE_HEIGHT"] = 32878] = "UNPACK_IMAGE_HEIGHT"; - GLEnum2[GLEnum2["MAX_3D_TEXTURE_SIZE"] = 32883] = "MAX_3D_TEXTURE_SIZE"; - GLEnum2[GLEnum2["MAX_ELEMENTS_VERTICES"] = 33e3] = "MAX_ELEMENTS_VERTICES"; - GLEnum2[GLEnum2["MAX_ELEMENTS_INDICES"] = 33001] = "MAX_ELEMENTS_INDICES"; - GLEnum2[GLEnum2["MAX_TEXTURE_LOD_BIAS"] = 34045] = "MAX_TEXTURE_LOD_BIAS"; - GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_COMPONENTS"] = 35657] = "MAX_FRAGMENT_UNIFORM_COMPONENTS"; - GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_COMPONENTS"] = 35658] = "MAX_VERTEX_UNIFORM_COMPONENTS"; - GLEnum2[GLEnum2["MAX_ARRAY_TEXTURE_LAYERS"] = 35071] = "MAX_ARRAY_TEXTURE_LAYERS"; - GLEnum2[GLEnum2["MIN_PROGRAM_TEXEL_OFFSET"] = 35076] = "MIN_PROGRAM_TEXEL_OFFSET"; - GLEnum2[GLEnum2["MAX_PROGRAM_TEXEL_OFFSET"] = 35077] = "MAX_PROGRAM_TEXEL_OFFSET"; - GLEnum2[GLEnum2["MAX_VARYING_COMPONENTS"] = 35659] = "MAX_VARYING_COMPONENTS"; - GLEnum2[GLEnum2["FRAGMENT_SHADER_DERIVATIVE_HINT"] = 35723] = "FRAGMENT_SHADER_DERIVATIVE_HINT"; - GLEnum2[GLEnum2["RASTERIZER_DISCARD"] = 35977] = "RASTERIZER_DISCARD"; - GLEnum2[GLEnum2["VERTEX_ARRAY_BINDING"] = 34229] = "VERTEX_ARRAY_BINDING"; - GLEnum2[GLEnum2["MAX_VERTEX_OUTPUT_COMPONENTS"] = 37154] = "MAX_VERTEX_OUTPUT_COMPONENTS"; - GLEnum2[GLEnum2["MAX_FRAGMENT_INPUT_COMPONENTS"] = 37157] = "MAX_FRAGMENT_INPUT_COMPONENTS"; - GLEnum2[GLEnum2["MAX_SERVER_WAIT_TIMEOUT"] = 37137] = "MAX_SERVER_WAIT_TIMEOUT"; - GLEnum2[GLEnum2["MAX_ELEMENT_INDEX"] = 36203] = "MAX_ELEMENT_INDEX"; - GLEnum2[GLEnum2["RED"] = 6403] = "RED"; - GLEnum2[GLEnum2["RGB8"] = 32849] = "RGB8"; - GLEnum2[GLEnum2["RGBA8"] = 32856] = "RGBA8"; - GLEnum2[GLEnum2["RGB10_A2"] = 32857] = "RGB10_A2"; - GLEnum2[GLEnum2["TEXTURE_3D"] = 32879] = "TEXTURE_3D"; - GLEnum2[GLEnum2["TEXTURE_WRAP_R"] = 32882] = "TEXTURE_WRAP_R"; - GLEnum2[GLEnum2["TEXTURE_MIN_LOD"] = 33082] = "TEXTURE_MIN_LOD"; - GLEnum2[GLEnum2["TEXTURE_MAX_LOD"] = 33083] = "TEXTURE_MAX_LOD"; - GLEnum2[GLEnum2["TEXTURE_BASE_LEVEL"] = 33084] = "TEXTURE_BASE_LEVEL"; - GLEnum2[GLEnum2["TEXTURE_MAX_LEVEL"] = 33085] = "TEXTURE_MAX_LEVEL"; - GLEnum2[GLEnum2["TEXTURE_COMPARE_MODE"] = 34892] = "TEXTURE_COMPARE_MODE"; - GLEnum2[GLEnum2["TEXTURE_COMPARE_FUNC"] = 34893] = "TEXTURE_COMPARE_FUNC"; - GLEnum2[GLEnum2["SRGB"] = 35904] = "SRGB"; - GLEnum2[GLEnum2["SRGB8"] = 35905] = "SRGB8"; - GLEnum2[GLEnum2["SRGB8_ALPHA8"] = 35907] = "SRGB8_ALPHA8"; - GLEnum2[GLEnum2["COMPARE_REF_TO_TEXTURE"] = 34894] = "COMPARE_REF_TO_TEXTURE"; - GLEnum2[GLEnum2["RGBA32F"] = 34836] = "RGBA32F"; - GLEnum2[GLEnum2["RGB32F"] = 34837] = "RGB32F"; - GLEnum2[GLEnum2["RGBA16F"] = 34842] = "RGBA16F"; - GLEnum2[GLEnum2["RGB16F"] = 34843] = "RGB16F"; - GLEnum2[GLEnum2["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY"; - GLEnum2[GLEnum2["TEXTURE_BINDING_2D_ARRAY"] = 35869] = "TEXTURE_BINDING_2D_ARRAY"; - GLEnum2[GLEnum2["R11F_G11F_B10F"] = 35898] = "R11F_G11F_B10F"; - GLEnum2[GLEnum2["RGB9_E5"] = 35901] = "RGB9_E5"; - GLEnum2[GLEnum2["RGBA32UI"] = 36208] = "RGBA32UI"; - GLEnum2[GLEnum2["RGB32UI"] = 36209] = "RGB32UI"; - GLEnum2[GLEnum2["RGBA16UI"] = 36214] = "RGBA16UI"; - GLEnum2[GLEnum2["RGB16UI"] = 36215] = "RGB16UI"; - GLEnum2[GLEnum2["RGBA8UI"] = 36220] = "RGBA8UI"; - GLEnum2[GLEnum2["RGB8UI"] = 36221] = "RGB8UI"; - GLEnum2[GLEnum2["RGBA32I"] = 36226] = "RGBA32I"; - GLEnum2[GLEnum2["RGB32I"] = 36227] = "RGB32I"; - GLEnum2[GLEnum2["RGBA16I"] = 36232] = "RGBA16I"; - GLEnum2[GLEnum2["RGB16I"] = 36233] = "RGB16I"; - GLEnum2[GLEnum2["RGBA8I"] = 36238] = "RGBA8I"; - GLEnum2[GLEnum2["RGB8I"] = 36239] = "RGB8I"; - GLEnum2[GLEnum2["RED_INTEGER"] = 36244] = "RED_INTEGER"; - GLEnum2[GLEnum2["RGB_INTEGER"] = 36248] = "RGB_INTEGER"; - GLEnum2[GLEnum2["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER"; - GLEnum2[GLEnum2["R8"] = 33321] = "R8"; - GLEnum2[GLEnum2["RG8"] = 33323] = "RG8"; - GLEnum2[GLEnum2["R16F"] = 33325] = "R16F"; - GLEnum2[GLEnum2["R32F"] = 33326] = "R32F"; - GLEnum2[GLEnum2["RG16F"] = 33327] = "RG16F"; - GLEnum2[GLEnum2["RG32F"] = 33328] = "RG32F"; - GLEnum2[GLEnum2["R8I"] = 33329] = "R8I"; - GLEnum2[GLEnum2["R8UI"] = 33330] = "R8UI"; - GLEnum2[GLEnum2["R16I"] = 33331] = "R16I"; - GLEnum2[GLEnum2["R16UI"] = 33332] = "R16UI"; - GLEnum2[GLEnum2["R32I"] = 33333] = "R32I"; - GLEnum2[GLEnum2["R32UI"] = 33334] = "R32UI"; - GLEnum2[GLEnum2["RG8I"] = 33335] = "RG8I"; - GLEnum2[GLEnum2["RG8UI"] = 33336] = "RG8UI"; - GLEnum2[GLEnum2["RG16I"] = 33337] = "RG16I"; - GLEnum2[GLEnum2["RG16UI"] = 33338] = "RG16UI"; - GLEnum2[GLEnum2["RG32I"] = 33339] = "RG32I"; - GLEnum2[GLEnum2["RG32UI"] = 33340] = "RG32UI"; - GLEnum2[GLEnum2["R8_SNORM"] = 36756] = "R8_SNORM"; - GLEnum2[GLEnum2["RG8_SNORM"] = 36757] = "RG8_SNORM"; - GLEnum2[GLEnum2["RGB8_SNORM"] = 36758] = "RGB8_SNORM"; - GLEnum2[GLEnum2["RGBA8_SNORM"] = 36759] = "RGBA8_SNORM"; - GLEnum2[GLEnum2["RGB10_A2UI"] = 36975] = "RGB10_A2UI"; - GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_FORMAT"] = 37167] = "TEXTURE_IMMUTABLE_FORMAT"; - GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_LEVELS"] = 33503] = "TEXTURE_IMMUTABLE_LEVELS"; - GLEnum2[GLEnum2["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV"; - GLEnum2[GLEnum2["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV"; - GLEnum2[GLEnum2["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV"; - GLEnum2[GLEnum2["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV"; - GLEnum2[GLEnum2["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8"; - GLEnum2[GLEnum2["HALF_FLOAT"] = 5131] = "HALF_FLOAT"; - GLEnum2[GLEnum2["RG"] = 33319] = "RG"; - GLEnum2[GLEnum2["RG_INTEGER"] = 33320] = "RG_INTEGER"; - GLEnum2[GLEnum2["INT_2_10_10_10_REV"] = 36255] = "INT_2_10_10_10_REV"; - GLEnum2[GLEnum2["CURRENT_QUERY"] = 34917] = "CURRENT_QUERY"; - GLEnum2[GLEnum2["QUERY_RESULT"] = 34918] = "QUERY_RESULT"; - GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE"] = 34919] = "QUERY_RESULT_AVAILABLE"; - GLEnum2[GLEnum2["ANY_SAMPLES_PASSED"] = 35887] = "ANY_SAMPLES_PASSED"; - GLEnum2[GLEnum2["ANY_SAMPLES_PASSED_CONSERVATIVE"] = 36202] = "ANY_SAMPLES_PASSED_CONSERVATIVE"; - GLEnum2[GLEnum2["MAX_DRAW_BUFFERS"] = 34852] = "MAX_DRAW_BUFFERS"; - GLEnum2[GLEnum2["DRAW_BUFFER0"] = 34853] = "DRAW_BUFFER0"; - GLEnum2[GLEnum2["DRAW_BUFFER1"] = 34854] = "DRAW_BUFFER1"; - GLEnum2[GLEnum2["DRAW_BUFFER2"] = 34855] = "DRAW_BUFFER2"; - GLEnum2[GLEnum2["DRAW_BUFFER3"] = 34856] = "DRAW_BUFFER3"; - GLEnum2[GLEnum2["DRAW_BUFFER4"] = 34857] = "DRAW_BUFFER4"; - GLEnum2[GLEnum2["DRAW_BUFFER5"] = 34858] = "DRAW_BUFFER5"; - GLEnum2[GLEnum2["DRAW_BUFFER6"] = 34859] = "DRAW_BUFFER6"; - GLEnum2[GLEnum2["DRAW_BUFFER7"] = 34860] = "DRAW_BUFFER7"; - GLEnum2[GLEnum2["DRAW_BUFFER8"] = 34861] = "DRAW_BUFFER8"; - GLEnum2[GLEnum2["DRAW_BUFFER9"] = 34862] = "DRAW_BUFFER9"; - GLEnum2[GLEnum2["DRAW_BUFFER10"] = 34863] = "DRAW_BUFFER10"; - GLEnum2[GLEnum2["DRAW_BUFFER11"] = 34864] = "DRAW_BUFFER11"; - GLEnum2[GLEnum2["DRAW_BUFFER12"] = 34865] = "DRAW_BUFFER12"; - GLEnum2[GLEnum2["DRAW_BUFFER13"] = 34866] = "DRAW_BUFFER13"; - GLEnum2[GLEnum2["DRAW_BUFFER14"] = 34867] = "DRAW_BUFFER14"; - GLEnum2[GLEnum2["DRAW_BUFFER15"] = 34868] = "DRAW_BUFFER15"; - GLEnum2[GLEnum2["MAX_COLOR_ATTACHMENTS"] = 36063] = "MAX_COLOR_ATTACHMENTS"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT1"] = 36065] = "COLOR_ATTACHMENT1"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT2"] = 36066] = "COLOR_ATTACHMENT2"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT3"] = 36067] = "COLOR_ATTACHMENT3"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT4"] = 36068] = "COLOR_ATTACHMENT4"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT5"] = 36069] = "COLOR_ATTACHMENT5"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT6"] = 36070] = "COLOR_ATTACHMENT6"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT7"] = 36071] = "COLOR_ATTACHMENT7"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT8"] = 36072] = "COLOR_ATTACHMENT8"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT9"] = 36073] = "COLOR_ATTACHMENT9"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT10"] = 36074] = "COLOR_ATTACHMENT10"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT11"] = 36075] = "COLOR_ATTACHMENT11"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT12"] = 36076] = "COLOR_ATTACHMENT12"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT13"] = 36077] = "COLOR_ATTACHMENT13"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT14"] = 36078] = "COLOR_ATTACHMENT14"; - GLEnum2[GLEnum2["COLOR_ATTACHMENT15"] = 36079] = "COLOR_ATTACHMENT15"; - GLEnum2[GLEnum2["SAMPLER_3D"] = 35679] = "SAMPLER_3D"; - GLEnum2[GLEnum2["SAMPLER_2D_SHADOW"] = 35682] = "SAMPLER_2D_SHADOW"; - GLEnum2[GLEnum2["SAMPLER_2D_ARRAY"] = 36289] = "SAMPLER_2D_ARRAY"; - GLEnum2[GLEnum2["SAMPLER_2D_ARRAY_SHADOW"] = 36292] = "SAMPLER_2D_ARRAY_SHADOW"; - GLEnum2[GLEnum2["SAMPLER_CUBE_SHADOW"] = 36293] = "SAMPLER_CUBE_SHADOW"; - GLEnum2[GLEnum2["INT_SAMPLER_2D"] = 36298] = "INT_SAMPLER_2D"; - GLEnum2[GLEnum2["INT_SAMPLER_3D"] = 36299] = "INT_SAMPLER_3D"; - GLEnum2[GLEnum2["INT_SAMPLER_CUBE"] = 36300] = "INT_SAMPLER_CUBE"; - GLEnum2[GLEnum2["INT_SAMPLER_2D_ARRAY"] = 36303] = "INT_SAMPLER_2D_ARRAY"; - GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D"] = 36306] = "UNSIGNED_INT_SAMPLER_2D"; - GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_3D"] = 36307] = "UNSIGNED_INT_SAMPLER_3D"; - GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_CUBE"] = 36308] = "UNSIGNED_INT_SAMPLER_CUBE"; - GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D_ARRAY"] = 36311] = "UNSIGNED_INT_SAMPLER_2D_ARRAY"; - GLEnum2[GLEnum2["MAX_SAMPLES"] = 36183] = "MAX_SAMPLES"; - GLEnum2[GLEnum2["SAMPLER_BINDING"] = 35097] = "SAMPLER_BINDING"; - GLEnum2[GLEnum2["PIXEL_PACK_BUFFER"] = 35051] = "PIXEL_PACK_BUFFER"; - GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER"] = 35052] = "PIXEL_UNPACK_BUFFER"; - GLEnum2[GLEnum2["PIXEL_PACK_BUFFER_BINDING"] = 35053] = "PIXEL_PACK_BUFFER_BINDING"; - GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER_BINDING"] = 35055] = "PIXEL_UNPACK_BUFFER_BINDING"; - GLEnum2[GLEnum2["COPY_READ_BUFFER"] = 36662] = "COPY_READ_BUFFER"; - GLEnum2[GLEnum2["COPY_WRITE_BUFFER"] = 36663] = "COPY_WRITE_BUFFER"; - GLEnum2[GLEnum2["COPY_READ_BUFFER_BINDING"] = 36662] = "COPY_READ_BUFFER_BINDING"; - GLEnum2[GLEnum2["COPY_WRITE_BUFFER_BINDING"] = 36663] = "COPY_WRITE_BUFFER_BINDING"; - GLEnum2[GLEnum2["FLOAT_MAT2x3"] = 35685] = "FLOAT_MAT2x3"; - GLEnum2[GLEnum2["FLOAT_MAT2x4"] = 35686] = "FLOAT_MAT2x4"; - GLEnum2[GLEnum2["FLOAT_MAT3x2"] = 35687] = "FLOAT_MAT3x2"; - GLEnum2[GLEnum2["FLOAT_MAT3x4"] = 35688] = "FLOAT_MAT3x4"; - GLEnum2[GLEnum2["FLOAT_MAT4x2"] = 35689] = "FLOAT_MAT4x2"; - GLEnum2[GLEnum2["FLOAT_MAT4x3"] = 35690] = "FLOAT_MAT4x3"; - GLEnum2[GLEnum2["UNSIGNED_INT_VEC2"] = 36294] = "UNSIGNED_INT_VEC2"; - GLEnum2[GLEnum2["UNSIGNED_INT_VEC3"] = 36295] = "UNSIGNED_INT_VEC3"; - GLEnum2[GLEnum2["UNSIGNED_INT_VEC4"] = 36296] = "UNSIGNED_INT_VEC4"; - GLEnum2[GLEnum2["UNSIGNED_NORMALIZED"] = 35863] = "UNSIGNED_NORMALIZED"; - GLEnum2[GLEnum2["SIGNED_NORMALIZED"] = 36764] = "SIGNED_NORMALIZED"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_INTEGER"] = 35069] = "VERTEX_ATTRIB_ARRAY_INTEGER"; - GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_DIVISOR"] = 35070] = "VERTEX_ATTRIB_ARRAY_DIVISOR"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_MODE"] = 35967] = "TRANSFORM_FEEDBACK_BUFFER_MODE"; - GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"] = 35968] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_VARYINGS"] = 35971] = "TRANSFORM_FEEDBACK_VARYINGS"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_START"] = 35972] = "TRANSFORM_FEEDBACK_BUFFER_START"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_SIZE"] = 35973] = "TRANSFORM_FEEDBACK_BUFFER_SIZE"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"] = 35976] = "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; - GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"] = 35978] = "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"; - GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"] = 35979] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"; - GLEnum2[GLEnum2["INTERLEAVED_ATTRIBS"] = 35980] = "INTERLEAVED_ATTRIBS"; - GLEnum2[GLEnum2["SEPARATE_ATTRIBS"] = 35981] = "SEPARATE_ATTRIBS"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER"] = 35982] = "TRANSFORM_FEEDBACK_BUFFER"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_BINDING"] = 35983] = "TRANSFORM_FEEDBACK_BUFFER_BINDING"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK"] = 36386] = "TRANSFORM_FEEDBACK"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PAUSED"] = 36387] = "TRANSFORM_FEEDBACK_PAUSED"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_ACTIVE"] = 36388] = "TRANSFORM_FEEDBACK_ACTIVE"; - GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BINDING"] = 36389] = "TRANSFORM_FEEDBACK_BINDING"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"] = 33296] = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"] = 33297] = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_RED_SIZE"] = 33298] = "FRAMEBUFFER_ATTACHMENT_RED_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"] = 33299] = "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"] = 33300] = "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"] = 33301] = "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"] = 33302] = "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"] = 33303] = "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; - GLEnum2[GLEnum2["FRAMEBUFFER_DEFAULT"] = 33304] = "FRAMEBUFFER_DEFAULT"; - GLEnum2[GLEnum2["DEPTH24_STENCIL8"] = 35056] = "DEPTH24_STENCIL8"; - GLEnum2[GLEnum2["DRAW_FRAMEBUFFER_BINDING"] = 36006] = "DRAW_FRAMEBUFFER_BINDING"; - GLEnum2[GLEnum2["READ_FRAMEBUFFER_BINDING"] = 36010] = "READ_FRAMEBUFFER_BINDING"; - GLEnum2[GLEnum2["RENDERBUFFER_SAMPLES"] = 36011] = "RENDERBUFFER_SAMPLES"; - GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"] = 36052] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"; - GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"] = 36182] = "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; - GLEnum2[GLEnum2["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER"; - GLEnum2[GLEnum2["UNIFORM_BUFFER_BINDING"] = 35368] = "UNIFORM_BUFFER_BINDING"; - GLEnum2[GLEnum2["UNIFORM_BUFFER_START"] = 35369] = "UNIFORM_BUFFER_START"; - GLEnum2[GLEnum2["UNIFORM_BUFFER_SIZE"] = 35370] = "UNIFORM_BUFFER_SIZE"; - GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_BLOCKS"] = 35371] = "MAX_VERTEX_UNIFORM_BLOCKS"; - GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_BLOCKS"] = 35373] = "MAX_FRAGMENT_UNIFORM_BLOCKS"; - GLEnum2[GLEnum2["MAX_COMBINED_UNIFORM_BLOCKS"] = 35374] = "MAX_COMBINED_UNIFORM_BLOCKS"; - GLEnum2[GLEnum2["MAX_UNIFORM_BUFFER_BINDINGS"] = 35375] = "MAX_UNIFORM_BUFFER_BINDINGS"; - GLEnum2[GLEnum2["MAX_UNIFORM_BLOCK_SIZE"] = 35376] = "MAX_UNIFORM_BLOCK_SIZE"; - GLEnum2[GLEnum2["MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"] = 35377] = "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"; - GLEnum2[GLEnum2["MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"] = 35379] = "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; - GLEnum2[GLEnum2["UNIFORM_BUFFER_OFFSET_ALIGNMENT"] = 35380] = "UNIFORM_BUFFER_OFFSET_ALIGNMENT"; - GLEnum2[GLEnum2["ACTIVE_UNIFORM_BLOCKS"] = 35382] = "ACTIVE_UNIFORM_BLOCKS"; - GLEnum2[GLEnum2["UNIFORM_TYPE"] = 35383] = "UNIFORM_TYPE"; - GLEnum2[GLEnum2["UNIFORM_SIZE"] = 35384] = "UNIFORM_SIZE"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_INDEX"] = 35386] = "UNIFORM_BLOCK_INDEX"; - GLEnum2[GLEnum2["UNIFORM_OFFSET"] = 35387] = "UNIFORM_OFFSET"; - GLEnum2[GLEnum2["UNIFORM_ARRAY_STRIDE"] = 35388] = "UNIFORM_ARRAY_STRIDE"; - GLEnum2[GLEnum2["UNIFORM_MATRIX_STRIDE"] = 35389] = "UNIFORM_MATRIX_STRIDE"; - GLEnum2[GLEnum2["UNIFORM_IS_ROW_MAJOR"] = 35390] = "UNIFORM_IS_ROW_MAJOR"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_BINDING"] = 35391] = "UNIFORM_BLOCK_BINDING"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_DATA_SIZE"] = 35392] = "UNIFORM_BLOCK_DATA_SIZE"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORMS"] = 35394] = "UNIFORM_BLOCK_ACTIVE_UNIFORMS"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"] = 35395] = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"] = 35396] = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"; - GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"] = 35398] = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; - GLEnum2[GLEnum2["OBJECT_TYPE"] = 37138] = "OBJECT_TYPE"; - GLEnum2[GLEnum2["SYNC_CONDITION"] = 37139] = "SYNC_CONDITION"; - GLEnum2[GLEnum2["SYNC_STATUS"] = 37140] = "SYNC_STATUS"; - GLEnum2[GLEnum2["SYNC_FLAGS"] = 37141] = "SYNC_FLAGS"; - GLEnum2[GLEnum2["SYNC_FENCE"] = 37142] = "SYNC_FENCE"; - GLEnum2[GLEnum2["SYNC_GPU_COMMANDS_COMPLETE"] = 37143] = "SYNC_GPU_COMMANDS_COMPLETE"; - GLEnum2[GLEnum2["UNSIGNALED"] = 37144] = "UNSIGNALED"; - GLEnum2[GLEnum2["SIGNALED"] = 37145] = "SIGNALED"; - GLEnum2[GLEnum2["ALREADY_SIGNALED"] = 37146] = "ALREADY_SIGNALED"; - GLEnum2[GLEnum2["TIMEOUT_EXPIRED"] = 37147] = "TIMEOUT_EXPIRED"; - GLEnum2[GLEnum2["CONDITION_SATISFIED"] = 37148] = "CONDITION_SATISFIED"; - GLEnum2[GLEnum2["WAIT_FAILED"] = 37149] = "WAIT_FAILED"; - GLEnum2[GLEnum2["SYNC_FLUSH_COMMANDS_BIT"] = 1] = "SYNC_FLUSH_COMMANDS_BIT"; - GLEnum2[GLEnum2["COLOR"] = 6144] = "COLOR"; - GLEnum2[GLEnum2["DEPTH"] = 6145] = "DEPTH"; - GLEnum2[GLEnum2["STENCIL"] = 6146] = "STENCIL"; - GLEnum2[GLEnum2["MIN"] = 32775] = "MIN"; - GLEnum2[GLEnum2["MAX"] = 32776] = "MAX"; - GLEnum2[GLEnum2["DEPTH_COMPONENT24"] = 33190] = "DEPTH_COMPONENT24"; - GLEnum2[GLEnum2["STREAM_READ"] = 35041] = "STREAM_READ"; - GLEnum2[GLEnum2["STREAM_COPY"] = 35042] = "STREAM_COPY"; - GLEnum2[GLEnum2["STATIC_READ"] = 35045] = "STATIC_READ"; - GLEnum2[GLEnum2["STATIC_COPY"] = 35046] = "STATIC_COPY"; - GLEnum2[GLEnum2["DYNAMIC_READ"] = 35049] = "DYNAMIC_READ"; - GLEnum2[GLEnum2["DYNAMIC_COPY"] = 35050] = "DYNAMIC_COPY"; - GLEnum2[GLEnum2["DEPTH_COMPONENT32F"] = 36012] = "DEPTH_COMPONENT32F"; - GLEnum2[GLEnum2["DEPTH32F_STENCIL8"] = 36013] = "DEPTH32F_STENCIL8"; - GLEnum2[GLEnum2["INVALID_INDEX"] = 4294967295] = "INVALID_INDEX"; - GLEnum2[GLEnum2["TIMEOUT_IGNORED"] = -1] = "TIMEOUT_IGNORED"; - GLEnum2[GLEnum2["MAX_CLIENT_WAIT_TIMEOUT_WEBGL"] = 37447] = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL"; - GLEnum2[GLEnum2["UNMASKED_VENDOR_WEBGL"] = 37445] = "UNMASKED_VENDOR_WEBGL"; - GLEnum2[GLEnum2["UNMASKED_RENDERER_WEBGL"] = 37446] = "UNMASKED_RENDERER_WEBGL"; - GLEnum2[GLEnum2["MAX_TEXTURE_MAX_ANISOTROPY_EXT"] = 34047] = "MAX_TEXTURE_MAX_ANISOTROPY_EXT"; - GLEnum2[GLEnum2["TEXTURE_MAX_ANISOTROPY_EXT"] = 34046] = "TEXTURE_MAX_ANISOTROPY_EXT"; - GLEnum2[GLEnum2["R16_EXT"] = 33322] = "R16_EXT"; - GLEnum2[GLEnum2["RG16_EXT"] = 33324] = "RG16_EXT"; - GLEnum2[GLEnum2["RGB16_EXT"] = 32852] = "RGB16_EXT"; - GLEnum2[GLEnum2["RGBA16_EXT"] = 32859] = "RGBA16_EXT"; - GLEnum2[GLEnum2["R16_SNORM_EXT"] = 36760] = "R16_SNORM_EXT"; - GLEnum2[GLEnum2["RG16_SNORM_EXT"] = 36761] = "RG16_SNORM_EXT"; - GLEnum2[GLEnum2["RGB16_SNORM_EXT"] = 36762] = "RGB16_SNORM_EXT"; - GLEnum2[GLEnum2["RGBA16_SNORM_EXT"] = 36763] = "RGBA16_SNORM_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RED_RGTC1_EXT"] = 36283] = "COMPRESSED_RED_RGTC1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_RGTC1_EXT"] = 36284] = "COMPRESSED_SIGNED_RED_RGTC1_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RED_GREEN_RGTC2_EXT"] = 36285] = "COMPRESSED_RED_GREEN_RGTC2_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"] = 36286] = "COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_BPTC_UNORM_EXT"] = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT"; - GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"] = 36493] = "COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"] = 36494] = "COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"; - GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"] = 36495] = "COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"; - GLEnum2[GLEnum2["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC"; - GLEnum2[GLEnum2["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC"; - GLEnum2[GLEnum2["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC"; - GLEnum2[GLEnum2["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC"; - GLEnum2[GLEnum2["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2"; - GLEnum2[GLEnum2["COMPRESSED_RGBA8_ETC2_EAC"] = 37493] = "COMPRESSED_RGBA8_ETC2_EAC"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ETC2"] = 37494] = "COMPRESSED_SRGB8_ETC2"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37495] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; - GLEnum2[GLEnum2["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37496] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37497] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; - GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; - GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; - GLEnum2[GLEnum2["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL"; - GLEnum2[GLEnum2["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x4_KHR"] = 37809] = "COMPRESSED_RGBA_ASTC_5x4_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x5_KHR"] = 37810] = "COMPRESSED_RGBA_ASTC_5x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x5_KHR"] = 37811] = "COMPRESSED_RGBA_ASTC_6x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x6_KHR"] = 37812] = "COMPRESSED_RGBA_ASTC_6x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x5_KHR"] = 37813] = "COMPRESSED_RGBA_ASTC_8x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x6_KHR"] = 37814] = "COMPRESSED_RGBA_ASTC_8x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x8_KHR"] = 37815] = "COMPRESSED_RGBA_ASTC_8x8_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x5_KHR"] = 37816] = "COMPRESSED_RGBA_ASTC_10x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x6_KHR"] = 37817] = "COMPRESSED_RGBA_ASTC_10x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x8_KHR"] = 37818] = "COMPRESSED_RGBA_ASTC_10x8_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x10_KHR"] = 37819] = "COMPRESSED_RGBA_ASTC_10x10_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x10_KHR"] = 37820] = "COMPRESSED_RGBA_ASTC_12x10_KHR"; - GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x12_KHR"] = 37821] = "COMPRESSED_RGBA_ASTC_12x12_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"] = 37840] = "COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"] = 37841] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 37851] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; - GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; - GLEnum2[GLEnum2["QUERY_COUNTER_BITS_EXT"] = 34916] = "QUERY_COUNTER_BITS_EXT"; - GLEnum2[GLEnum2["CURRENT_QUERY_EXT"] = 34917] = "CURRENT_QUERY_EXT"; - GLEnum2[GLEnum2["QUERY_RESULT_EXT"] = 34918] = "QUERY_RESULT_EXT"; - GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT"; - GLEnum2[GLEnum2["TIME_ELAPSED_EXT"] = 35007] = "TIME_ELAPSED_EXT"; - GLEnum2[GLEnum2["TIMESTAMP_EXT"] = 36392] = "TIMESTAMP_EXT"; - GLEnum2[GLEnum2["GPU_DISJOINT_EXT"] = 36795] = "GPU_DISJOINT_EXT"; - GLEnum2[GLEnum2["COMPLETION_STATUS_KHR"] = 37297] = "COMPLETION_STATUS_KHR"; - GLEnum2[GLEnum2["DEPTH_CLAMP_EXT"] = 34383] = "DEPTH_CLAMP_EXT"; - GLEnum2[GLEnum2["FIRST_VERTEX_CONVENTION_WEBGL"] = 36429] = "FIRST_VERTEX_CONVENTION_WEBGL"; - GLEnum2[GLEnum2["LAST_VERTEX_CONVENTION_WEBGL"] = 36430] = "LAST_VERTEX_CONVENTION_WEBGL"; - GLEnum2[GLEnum2["PROVOKING_VERTEX_WEBL"] = 36431] = "PROVOKING_VERTEX_WEBL"; - GLEnum2[GLEnum2["POLYGON_MODE_WEBGL"] = 2880] = "POLYGON_MODE_WEBGL"; - GLEnum2[GLEnum2["POLYGON_OFFSET_LINE_WEBGL"] = 10754] = "POLYGON_OFFSET_LINE_WEBGL"; - GLEnum2[GLEnum2["LINE_WEBGL"] = 6913] = "LINE_WEBGL"; - GLEnum2[GLEnum2["FILL_WEBGL"] = 6914] = "FILL_WEBGL"; - GLEnum2[GLEnum2["MAX_CLIP_DISTANCES_WEBGL"] = 3378] = "MAX_CLIP_DISTANCES_WEBGL"; - GLEnum2[GLEnum2["MAX_CULL_DISTANCES_WEBGL"] = 33529] = "MAX_CULL_DISTANCES_WEBGL"; - GLEnum2[GLEnum2["MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"] = 33530] = "MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE0_WEBGL"] = 12288] = "CLIP_DISTANCE0_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE1_WEBGL"] = 12289] = "CLIP_DISTANCE1_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE2_WEBGL"] = 12290] = "CLIP_DISTANCE2_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE3_WEBGL"] = 12291] = "CLIP_DISTANCE3_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE4_WEBGL"] = 12292] = "CLIP_DISTANCE4_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE5_WEBGL"] = 12293] = "CLIP_DISTANCE5_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE6_WEBGL"] = 12294] = "CLIP_DISTANCE6_WEBGL"; - GLEnum2[GLEnum2["CLIP_DISTANCE7_WEBGL"] = 12295] = "CLIP_DISTANCE7_WEBGL"; - GLEnum2[GLEnum2["POLYGON_OFFSET_CLAMP_EXT"] = 36379] = "POLYGON_OFFSET_CLAMP_EXT"; - GLEnum2[GLEnum2["LOWER_LEFT_EXT"] = 36001] = "LOWER_LEFT_EXT"; - GLEnum2[GLEnum2["UPPER_LEFT_EXT"] = 36002] = "UPPER_LEFT_EXT"; - GLEnum2[GLEnum2["NEGATIVE_ONE_TO_ONE_EXT"] = 37726] = "NEGATIVE_ONE_TO_ONE_EXT"; - GLEnum2[GLEnum2["ZERO_TO_ONE_EXT"] = 37727] = "ZERO_TO_ONE_EXT"; - GLEnum2[GLEnum2["CLIP_ORIGIN_EXT"] = 37724] = "CLIP_ORIGIN_EXT"; - GLEnum2[GLEnum2["CLIP_DEPTH_MODE_EXT"] = 37725] = "CLIP_DEPTH_MODE_EXT"; - GLEnum2[GLEnum2["SRC1_COLOR_WEBGL"] = 35065] = "SRC1_COLOR_WEBGL"; - GLEnum2[GLEnum2["SRC1_ALPHA_WEBGL"] = 34185] = "SRC1_ALPHA_WEBGL"; - GLEnum2[GLEnum2["ONE_MINUS_SRC1_COLOR_WEBGL"] = 35066] = "ONE_MINUS_SRC1_COLOR_WEBGL"; - GLEnum2[GLEnum2["ONE_MINUS_SRC1_ALPHA_WEBGL"] = 35067] = "ONE_MINUS_SRC1_ALPHA_WEBGL"; - GLEnum2[GLEnum2["MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"] = 35068] = "MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"; - GLEnum2[GLEnum2["MIRROR_CLAMP_TO_EDGE_EXT"] = 34627] = "MIRROR_CLAMP_TO_EDGE_EXT"; -})(GLEnum || (GLEnum = {})); - -// node_modules/@luma.gl/webgl/dist/context/parameters/webgl-parameter-tables.js -var GL_PARAMETER_DEFAULTS = { - [3042]: false, - [32773]: new Float32Array([0, 0, 0, 0]), - [32777]: 32774, - [34877]: 32774, - [32969]: 1, - [32968]: 0, - [32971]: 1, - [32970]: 0, - [3106]: new Float32Array([0, 0, 0, 0]), - // TBD - [3107]: [true, true, true, true], - [2884]: false, - [2885]: 1029, - [2929]: false, - [2931]: 1, - [2932]: 513, - [2928]: new Float32Array([0, 1]), - // TBD - [2930]: true, - [3024]: true, - [35725]: null, - // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state. - [36006]: null, - [36007]: null, - [34229]: null, - [34964]: null, - [2886]: 2305, - [33170]: 4352, - [2849]: 1, - [32823]: false, - [32824]: 0, - [10752]: 0, - [32926]: false, - [32928]: false, - [32938]: 1, - [32939]: false, - [3089]: false, - // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box - [3088]: new Int32Array([0, 0, 1024, 1024]), - [2960]: false, - [2961]: 0, - [2968]: 4294967295, - [36005]: 4294967295, - [2962]: 519, - [2967]: 0, - [2963]: 4294967295, - [34816]: 519, - [36003]: 0, - [36004]: 4294967295, - [2964]: 7680, - [2965]: 7680, - [2966]: 7680, - [34817]: 7680, - [34818]: 7680, - [34819]: 7680, - // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame. - [2978]: [0, 0, 1024, 1024], - [36389]: null, - [36662]: null, - [36663]: null, - [35053]: null, - [35055]: null, - [35723]: 4352, - [36010]: null, - [35977]: false, - [3333]: 4, - [3317]: 4, - [37440]: false, - [37441]: false, - [37443]: 37444, - [3330]: 0, - [3332]: 0, - [3331]: 0, - [3314]: 0, - [32878]: 0, - [3316]: 0, - [3315]: 0, - [32877]: 0 -}; -var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key); -var hint = (gl, value, key) => gl.hint(key, value); -var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value); -var bindFramebuffer = (gl, value, key) => { - const target = key === 36006 ? 36009 : 36008; - return gl.bindFramebuffer(target, value); -}; -var bindBuffer = (gl, value, key) => { - const bindingMap = { - [34964]: 34962, - [36662]: 36662, - [36663]: 36663, - [35053]: 35051, - [35055]: 35052 - }; - const glTarget = bindingMap[key]; - gl.bindBuffer(glTarget, value); -}; -function isArray2(array) { - return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView); -} -var GL_PARAMETER_SETTERS = { - [3042]: enable, - [32773]: (gl, value) => gl.blendColor(...value), - [32777]: "blendEquation", - [34877]: "blendEquation", - [32969]: "blendFunc", - [32968]: "blendFunc", - [32971]: "blendFunc", - [32970]: "blendFunc", - [3106]: (gl, value) => gl.clearColor(...value), - [3107]: (gl, value) => gl.colorMask(...value), - [2884]: enable, - [2885]: (gl, value) => gl.cullFace(value), - [2929]: enable, - [2931]: (gl, value) => gl.clearDepth(value), - [2932]: (gl, value) => gl.depthFunc(value), - [2928]: (gl, value) => gl.depthRange(...value), - [2930]: (gl, value) => gl.depthMask(value), - [3024]: enable, - [35723]: hint, - [35725]: (gl, value) => gl.useProgram(value), - [36007]: (gl, value) => gl.bindRenderbuffer(36161, value), - [36389]: (gl, value) => gl.bindTransformFeedback?.(36386, value), - [34229]: (gl, value) => gl.bindVertexArray(value), - // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state. - [36006]: bindFramebuffer, - [36010]: bindFramebuffer, - // Buffers - [34964]: bindBuffer, - [36662]: bindBuffer, - [36663]: bindBuffer, - [35053]: bindBuffer, - [35055]: bindBuffer, - [2886]: (gl, value) => gl.frontFace(value), - [33170]: hint, - [2849]: (gl, value) => gl.lineWidth(value), - [32823]: enable, - [32824]: "polygonOffset", - [10752]: "polygonOffset", - [35977]: enable, - [32926]: enable, - [32928]: enable, - [32938]: "sampleCoverage", - [32939]: "sampleCoverage", - [3089]: enable, - [3088]: (gl, value) => gl.scissor(...value), - [2960]: enable, - [2961]: (gl, value) => gl.clearStencil(value), - [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value), - [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value), - [2962]: "stencilFuncFront", - [2967]: "stencilFuncFront", - [2963]: "stencilFuncFront", - [34816]: "stencilFuncBack", - [36003]: "stencilFuncBack", - [36004]: "stencilFuncBack", - [2964]: "stencilOpFront", - [2965]: "stencilOpFront", - [2966]: "stencilOpFront", - [34817]: "stencilOpBack", - [34818]: "stencilOpBack", - [34819]: "stencilOpBack", - [2978]: (gl, value) => gl.viewport(...value), - // WEBGL2 EXTENSIONS - // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/ - [34383]: enable, - // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/ - // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed - // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/ - // POLYGON_MODE_WEBGL TODO - extension function needed - [10754]: enable, - // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/ - [12288]: enable, - [12289]: enable, - [12290]: enable, - [12291]: enable, - [12292]: enable, - [12293]: enable, - [12294]: enable, - [12295]: enable, - // PIXEL PACK/UNPACK MODES - [3333]: pixelStorei, - [3317]: pixelStorei, - [37440]: pixelStorei, - [37441]: pixelStorei, - [37443]: pixelStorei, - [3330]: pixelStorei, - [3332]: pixelStorei, - [3331]: pixelStorei, - [3314]: pixelStorei, - [32878]: pixelStorei, - [3316]: pixelStorei, - [3315]: pixelStorei, - [32877]: pixelStorei, - // Function-style setters - framebuffer: (gl, framebuffer) => { - const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer; - return gl.bindFramebuffer(36160, handle); - }, - blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042), - blendColor: (gl, value) => gl.blendColor(...value), - blendEquation: (gl, args) => { - const separateModes = typeof args === "number" ? [args, args] : args; - gl.blendEquationSeparate(...separateModes); - }, - blendFunc: (gl, args) => { - const separateFuncs = args?.length === 2 ? [...args, ...args] : args; - gl.blendFuncSeparate(...separateFuncs); - }, - clearColor: (gl, value) => gl.clearColor(...value), - clearDepth: (gl, value) => gl.clearDepth(value), - clearStencil: (gl, value) => gl.clearStencil(value), - colorMask: (gl, value) => gl.colorMask(...value), - cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884), - cullFace: (gl, value) => gl.cullFace(value), - depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929), - depthFunc: (gl, value) => gl.depthFunc(value), - depthMask: (gl, value) => gl.depthMask(value), - depthRange: (gl, value) => gl.depthRange(...value), - dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024), - derivativeHint: (gl, value) => { - gl.hint(35723, value); - }, - frontFace: (gl, value) => gl.frontFace(value), - mipmapHint: (gl, value) => gl.hint(33170, value), - lineWidth: (gl, value) => gl.lineWidth(value), - polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823), - polygonOffset: (gl, value) => gl.polygonOffset(...value), - sampleCoverage: (gl, value) => gl.sampleCoverage(...value), - scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089), - scissor: (gl, value) => gl.scissor(...value), - stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960), - stencilMask: (gl, value) => { - value = isArray2(value) ? value : [value, value]; - const [mask, backMask] = value; - gl.stencilMaskSeparate(1028, mask); - gl.stencilMaskSeparate(1029, backMask); - }, - stencilFunc: (gl, args) => { - args = isArray2(args) && args.length === 3 ? [...args, ...args] : args; - const [func, ref, mask, backFunc, backRef, backMask] = args; - gl.stencilFuncSeparate(1028, func, ref, mask); - gl.stencilFuncSeparate(1029, backFunc, backRef, backMask); - }, - stencilOp: (gl, args) => { - args = isArray2(args) && args.length === 3 ? [...args, ...args] : args; - const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args; - gl.stencilOpSeparate(1028, sfail, dpfail, dppass); - gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass); - }, - viewport: (gl, value) => gl.viewport(...value) -}; -function getValue(glEnum, values, cache3) { - return values[glEnum] !== void 0 ? values[glEnum] : cache3[glEnum]; -} -var GL_COMPOSITE_PARAMETER_SETTERS = { - blendEquation: (gl, values, cache3) => gl.blendEquationSeparate(getValue(32777, values, cache3), getValue(34877, values, cache3)), - blendFunc: (gl, values, cache3) => gl.blendFuncSeparate(getValue(32969, values, cache3), getValue(32968, values, cache3), getValue(32971, values, cache3), getValue(32970, values, cache3)), - polygonOffset: (gl, values, cache3) => gl.polygonOffset(getValue(32824, values, cache3), getValue(10752, values, cache3)), - sampleCoverage: (gl, values, cache3) => gl.sampleCoverage(getValue(32938, values, cache3), getValue(32939, values, cache3)), - stencilFuncFront: (gl, values, cache3) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache3), getValue(2967, values, cache3), getValue(2963, values, cache3)), - stencilFuncBack: (gl, values, cache3) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache3), getValue(36003, values, cache3), getValue(36004, values, cache3)), - stencilOpFront: (gl, values, cache3) => gl.stencilOpSeparate(1028, getValue(2964, values, cache3), getValue(2965, values, cache3), getValue(2966, values, cache3)), - stencilOpBack: (gl, values, cache3) => gl.stencilOpSeparate(1029, getValue(34817, values, cache3), getValue(34818, values, cache3), getValue(34819, values, cache3)) -}; -var GL_HOOKED_SETTERS = { - // GENERIC SETTERS - enable: (update, capability) => update({ - [capability]: true - }), - disable: (update, capability) => update({ - [capability]: false - }), - pixelStorei: (update, pname, value) => update({ - [pname]: value - }), - hint: (update, pname, hint2) => update({ - [pname]: hint2 - }), - // SPECIFIC SETTERS - useProgram: (update, value) => update({ - [35725]: value - }), - bindRenderbuffer: (update, target, value) => update({ - [36007]: value - }), - bindTransformFeedback: (update, target, value) => update({ - [36389]: value - }), - bindVertexArray: (update, value) => update({ - [34229]: value - }), - bindFramebuffer: (update, target, framebuffer) => { - switch (target) { - case 36160: - return update({ - [36006]: framebuffer, - [36010]: framebuffer - }); - case 36009: - return update({ [36006]: framebuffer }); - case 36008: - return update({ [36010]: framebuffer }); - default: - return null; - } - }, - bindBuffer: (update, target, buffer) => { - const pname = { - [34962]: [34964], - [36662]: [36662], - [36663]: [36663], - [35051]: [35053], - [35052]: [35055] - }[target]; - if (pname) { - return update({ [pname]: buffer }); - } - return { valueChanged: true }; - }, - blendColor: (update, r, g, b, a) => update({ - [32773]: new Float32Array([r, g, b, a]) - }), - blendEquation: (update, mode) => update({ - [32777]: mode, - [34877]: mode - }), - blendEquationSeparate: (update, modeRGB, modeAlpha) => update({ - [32777]: modeRGB, - [34877]: modeAlpha - }), - blendFunc: (update, src, dst) => update({ - [32969]: src, - [32968]: dst, - [32971]: src, - [32970]: dst - }), - blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({ - [32969]: srcRGB, - [32968]: dstRGB, - [32971]: srcAlpha, - [32970]: dstAlpha - }), - clearColor: (update, r, g, b, a) => update({ - [3106]: new Float32Array([r, g, b, a]) - }), - clearDepth: (update, depth) => update({ - [2931]: depth - }), - clearStencil: (update, s) => update({ - [2961]: s - }), - colorMask: (update, r, g, b, a) => update({ - [3107]: [r, g, b, a] - }), - cullFace: (update, mode) => update({ - [2885]: mode - }), - depthFunc: (update, func) => update({ - [2932]: func - }), - depthRange: (update, zNear, zFar) => update({ - [2928]: new Float32Array([zNear, zFar]) - }), - depthMask: (update, mask) => update({ - [2930]: mask - }), - frontFace: (update, face) => update({ - [2886]: face - }), - lineWidth: (update, width) => update({ - [2849]: width - }), - polygonOffset: (update, factor, units) => update({ - [32824]: factor, - [10752]: units - }), - sampleCoverage: (update, value, invert6) => update({ - [32938]: value, - [32939]: invert6 - }), - scissor: (update, x, y, width, height) => update({ - [3088]: new Int32Array([x, y, width, height]) - }), - stencilMask: (update, mask) => update({ - [2968]: mask, - [36005]: mask - }), - stencilMaskSeparate: (update, face, mask) => update({ - [face === 1028 ? 2968 : 36005]: mask - }), - stencilFunc: (update, func, ref, mask) => update({ - [2962]: func, - [2967]: ref, - [2963]: mask, - [34816]: func, - [36003]: ref, - [36004]: mask - }), - stencilFuncSeparate: (update, face, func, ref, mask) => update({ - [face === 1028 ? 2962 : 34816]: func, - [face === 1028 ? 2967 : 36003]: ref, - [face === 1028 ? 2963 : 36004]: mask - }), - stencilOp: (update, fail, zfail, zpass) => update({ - [2964]: fail, - [2965]: zfail, - [2966]: zpass, - [34817]: fail, - [34818]: zfail, - [34819]: zpass - }), - stencilOpSeparate: (update, face, fail, zfail, zpass) => update({ - [face === 1028 ? 2964 : 34817]: fail, - [face === 1028 ? 2965 : 34818]: zfail, - [face === 1028 ? 2966 : 34819]: zpass - }), - viewport: (update, x, y, width, height) => update({ - [2978]: [x, y, width, height] - }) -}; -var isEnabled = (gl, key) => gl.isEnabled(key); -var GL_PARAMETER_GETTERS = { - [3042]: isEnabled, - [2884]: isEnabled, - [2929]: isEnabled, - [3024]: isEnabled, - [32823]: isEnabled, - [32926]: isEnabled, - [32928]: isEnabled, - [3089]: isEnabled, - [2960]: isEnabled, - [35977]: isEnabled -}; -var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([ - 34016, - 36388, - 36387, - 35983, - 35368, - 34965, - 35739, - 35738, - 3074, - 34853, - 34854, - 34855, - 34856, - 34857, - 34858, - 34859, - 34860, - 34861, - 34862, - 34863, - 34864, - 34865, - 34866, - 34867, - 34868, - 35097, - 32873, - 35869, - 32874, - 34068 -]); - -// node_modules/@luma.gl/webgl/dist/context/parameters/unified-parameter-api.js -function setGLParameters(gl, parameters) { - if (isObjectEmpty2(parameters)) { - return; - } - const compositeSetters = {}; - for (const key in parameters) { - const glConstant = Number(key); - const setter = GL_PARAMETER_SETTERS[key]; - if (setter) { - if (typeof setter === "string") { - compositeSetters[setter] = true; - } else { - setter(gl, parameters[key], glConstant); - } - } - } - const cache3 = gl.state && gl.state.cache; - if (cache3) { - for (const key in compositeSetters) { - const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key]; - compositeSetter(gl, parameters, cache3); - } - } -} -function getGLParameters(gl, parameters = GL_PARAMETER_DEFAULTS) { - if (typeof parameters === "number") { - const key = parameters; - const getter = GL_PARAMETER_GETTERS[key]; - return getter ? getter(gl, key) : gl.getParameter(key); - } - const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters); - const state = {}; - for (const key of parameterKeys) { - const getter = GL_PARAMETER_GETTERS[key]; - state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key)); - } - return state; -} -function resetGLParameters(gl) { - setGLParameters(gl, GL_PARAMETER_DEFAULTS); -} -function isObjectEmpty2(object) { - for (const key in object) { - return false; - } - return true; -} - -// node_modules/@luma.gl/webgl/dist/context/state-tracker/deep-array-equal.js -function deepArrayEqual(x, y) { - if (x === y) { - return true; - } - const isArrayX = Array.isArray(x) || ArrayBuffer.isView(x); - const isArrayY = Array.isArray(y) || ArrayBuffer.isView(y); - if (isArrayX && isArrayY && x.length === y.length) { - for (let i = 0; i < x.length; ++i) { - if (x[i] !== y[i]) { - return false; - } - } - return true; - } - return false; -} - -// node_modules/@luma.gl/webgl/dist/context/state-tracker/track-context-state.js -var GLState = class { - gl; - program = null; - stateStack = []; - enable = true; - cache; - log; - constructor(gl, { - copyState = false, - // Copy cache from params (slow) or initialize from WebGL defaults (fast) - log: log4 = () => { - } - // Logging function, called when gl parameter change calls are actually issued - } = {}) { - this.gl = gl; - this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS); - this.log = log4; - this._updateCache = this._updateCache.bind(this); - Object.seal(this); - } - push(values = {}) { - this.stateStack.push({}); - } - pop() { - assert6(this.stateStack.length > 0); - const oldValues = this.stateStack[this.stateStack.length - 1]; - setGLParameters(this.gl, oldValues); - this.stateStack.pop(); - } - /** - // interceptor for context set functions - update our cache and our stack - // values (Object) - the key values for this setter - * @param values - * @returns - */ - _updateCache(values) { - let valueChanged = false; - let oldValue; - const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null; - for (const key in values) { - assert6(key !== void 0); - const value = values[key]; - const cached = this.cache[key]; - if (!deepArrayEqual(value, cached)) { - valueChanged = true; - oldValue = cached; - if (oldValues && !(key in oldValues)) { - oldValues[key] = cached; - } - this.cache[key] = value; - } - } - return { valueChanged, oldValue }; - } -}; -function getContextState(gl) { - return gl.state; -} -function trackContextState(gl, options) { - const { enable: enable2 = true, copyState } = options; - assert6(copyState !== void 0); - if (!gl.state) { - gl.state = new GLState(gl, { copyState }); - installProgramSpy(gl); - for (const key in GL_HOOKED_SETTERS) { - const setter = GL_HOOKED_SETTERS[key]; - installSetterSpy(gl, key, setter); - } - installGetterOverride(gl, "getParameter"); - installGetterOverride(gl, "isEnabled"); - } - const glState = getContextState(gl); - glState.enable = enable2; - return gl; -} -function pushContextState(gl) { - let glState = getContextState(gl); - if (!glState) { - trackContextState(gl, { copyState: false }); - glState = getContextState(gl); - } - glState.push(); -} -function popContextState(gl) { - const glState = getContextState(gl); - assert6(glState); - glState.pop(); -} -function installGetterOverride(gl, functionName) { - const originalGetterFunc = gl[functionName].bind(gl); - gl[functionName] = function get(pname) { - if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) { - return originalGetterFunc(pname); - } - const glState = getContextState(gl); - if (!(pname in glState.cache)) { - glState.cache[pname] = originalGetterFunc(pname); - } - return glState.enable ? ( - // Call the getter the params so that it can e.g. serve from a cache - glState.cache[pname] - ) : ( - // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext - originalGetterFunc(pname) - ); - }; - Object.defineProperty(gl[functionName], "name", { - value: `${functionName}-from-cache`, - configurable: false - }); -} -function installSetterSpy(gl, functionName, setter) { - if (!gl[functionName]) { - return; - } - const originalSetterFunc = gl[functionName].bind(gl); - gl[functionName] = function set11(...params) { - const glState = getContextState(gl); - const { valueChanged, oldValue } = setter(glState._updateCache, ...params); - if (valueChanged) { - originalSetterFunc(...params); - } - return oldValue; - }; - Object.defineProperty(gl[functionName], "name", { - value: `${functionName}-to-cache`, - configurable: false - }); -} -function installProgramSpy(gl) { - const originalUseProgram = gl.useProgram.bind(gl); - gl.useProgram = function useProgramLuma(handle) { - const glState = getContextState(gl); - if (glState.program !== handle) { - originalUseProgram(handle); - glState.program = handle; - } - }; -} - -// node_modules/@luma.gl/webgl/dist/context/helpers/create-browser-context.js -var DEFAULT_CONTEXT_PROPS = { - powerPreference: "high-performance", - // After all, most apps are using WebGL for performance reasons - // eslint-disable-next-line no-console - onContextLost: () => console.error("WebGL context lost"), - // eslint-disable-next-line no-console - onContextRestored: () => console.info("WebGL context restored") -}; -function createBrowserContext(canvas2, props) { - props = { ...DEFAULT_CONTEXT_PROPS, ...props }; - let errorMessage = null; - const onCreateError = (error) => errorMessage = error.statusMessage || errorMessage; - canvas2.addEventListener("webglcontextcreationerror", onCreateError, false); - let gl = null; - gl ||= canvas2.getContext("webgl2", props); - canvas2.removeEventListener("webglcontextcreationerror", onCreateError, false); - if (!gl) { - throw new Error(`Failed to create WebGL context: ${errorMessage || "Unknown error"}`); - } - if (props.onContextLost) { - const { onContextLost } = props; - canvas2.addEventListener("webglcontextlost", (event) => onContextLost(event), false); - } - if (props.onContextRestored) { - const { onContextRestored } = props; - canvas2.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false); - } - return gl; -} - -// node_modules/@luma.gl/webgl/dist/context/helpers/webgl-extensions.js -function getWebGLExtension(gl, name2, extensions) { - if (extensions[name2] === void 0) { - extensions[name2] = gl.getExtension(name2) || null; - } - return extensions[name2]; -} - -// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-info.js -function getDeviceInfo(gl, extensions) { - const vendorMasked = gl.getParameter(7936); - const rendererMasked = gl.getParameter(7937); - getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions); - const ext = extensions.WEBGL_debug_renderer_info; - const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936); - const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937); - const vendor = vendorUnmasked || vendorMasked; - const renderer = rendererUnmasked || rendererMasked; - const version2 = gl.getParameter(7938); - const gpu = identifyGPUVendor(vendor, renderer); - const gpuBackend = identifyGPUBackend(vendor, renderer); - const gpuType = identifyGPUType(vendor, renderer); - const shadingLanguage = "glsl"; - const shadingLanguageVersion = 300; - return { - type: "webgl", - gpu, - gpuType, - gpuBackend, - vendor, - renderer, - version: version2, - shadingLanguage, - shadingLanguageVersion - }; -} -function identifyGPUVendor(vendor, renderer) { - if (/NVIDIA/i.exec(vendor) || /NVIDIA/i.exec(renderer)) { - return "nvidia"; - } - if (/INTEL/i.exec(vendor) || /INTEL/i.exec(renderer)) { - return "intel"; - } - if (/Apple/i.exec(vendor) || /Apple/i.exec(renderer)) { - return "apple"; - } - if (/AMD/i.exec(vendor) || /AMD/i.exec(renderer) || /ATI/i.exec(vendor) || /ATI/i.exec(renderer)) { - return "amd"; - } - if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) { - return "software"; - } - return "unknown"; -} -function identifyGPUBackend(vendor, renderer) { - if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) { - return "metal"; - } - if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) { - return "opengl"; - } - return "unknown"; -} -function identifyGPUType(vendor, renderer) { - if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) { - return "cpu"; - } - const gpuVendor = identifyGPUVendor(vendor, renderer); - switch (gpuVendor) { - case "intel": - return "integrated"; - case "software": - return "cpu"; - case "unknown": - return "unknown"; - default: - return "discrete"; - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/converters/vertex-formats.js -function getGLFromVertexType(dataType) { - switch (dataType) { - case "uint8": - return 5121; - case "sint8": - return 5120; - case "unorm8": - return 5121; - case "snorm8": - return 5120; - case "uint16": - return 5123; - case "sint16": - return 5122; - case "unorm16": - return 5123; - case "snorm16": - return 5122; - case "uint32": - return 5125; - case "sint32": - return 5124; - case "float16": - return 5131; - case "float32": - return 5126; - } - throw new Error(String(dataType)); -} - -// node_modules/@luma.gl/webgl/dist/adapter/converters/texture-formats.js -var texture_compression_bc = "texture-compression-bc"; -var texture_compression_astc = "texture-compression-astc"; -var texture_compression_etc2 = "texture-compression-etc2"; -var texture_compression_etc1_webgl = "texture-compression-etc1-webgl"; -var texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl"; -var texture_compression_atc_webgl = "texture-compression-atc-webgl"; -var float32_renderable = "float32-renderable-webgl"; -var float16_renderable = "float16-renderable-webgl"; -var rgb9e5ufloat_renderable = "rgb9e5ufloat_renderable-webgl"; -var snorm8_renderable = "snorm8-renderable-webgl"; -var norm16_renderable = "norm16-renderable-webgl"; -var snorm16_renderable = "snorm16-renderable-webgl"; -var float32_filterable = "float32-filterable"; -var float16_filterable = "float16-filterable-webgl"; -var X_S3TC = "WEBGL_compressed_texture_s3tc"; -var X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb"; -var X_RGTC = "EXT_texture_compression_rgtc"; -var X_BPTC = "EXT_texture_compression_bptc"; -var X_ETC2 = "WEBGL_compressed_texture_etc"; -var X_ASTC = "WEBGL_compressed_texture_astc"; -var X_ETC1 = "WEBGL_compressed_texture_etc1"; -var X_PVRTC = "WEBGL_compressed_texture_pvrtc"; -var X_ATC = "WEBGL_compressed_texture_atc"; -var EXT_texture_norm16 = "EXT_texture_norm16"; -var EXT_render_snorm = "EXT_render_snorm"; -var EXT_color_buffer_float = "EXT_color_buffer_float"; -var TEXTURE_FEATURES = { - "float32-renderable-webgl": ["EXT_color_buffer_float"], - "float16-renderable-webgl": ["EXT_color_buffer_half_float"], - "rgb9e5ufloat_renderable-webgl": ["WEBGL_render_shared_exponent"], - "snorm8-renderable-webgl": [EXT_render_snorm], - "norm16-renderable-webgl": [EXT_texture_norm16], - "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm], - "float32-filterable": ["OES_texture_float_linear"], - "float16-filterable-webgl": ["OES_texture_half_float_linear"], - "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"], - "texture-blend-float-webgl": ["EXT_float_blend"], - "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC], - // 'texture-compression-bc3-srgb-webgl': [X_S3TC_SRGB], - // 'texture-compression-bc3-webgl': [X_S3TC], - "texture-compression-bc5-webgl": [X_RGTC], - "texture-compression-bc7-webgl": [X_BPTC], - "texture-compression-etc2": [X_ETC2], - "texture-compression-astc": [X_ASTC], - "texture-compression-etc1-webgl": [X_ETC1], - "texture-compression-pvrtc-webgl": [X_PVRTC], - "texture-compression-atc-webgl": [X_ATC] -}; -function isTextureFeature(feature) { - return feature in TEXTURE_FEATURES; -} -function checkTextureFeature(gl, feature, extensions) { - const textureExtensions = TEXTURE_FEATURES[feature] || []; - return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions)); -} -var TEXTURE_FORMATS = { - // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants - "rgb8unorm-unsized": { - gl: 6407, - b: 4, - c: 2, - bpp: 4, - dataFormat: 6407, - types: [5121, 33635] - }, - "rgba8unorm-unsized": { - gl: 6408, - b: 4, - c: 2, - bpp: 4, - dataFormat: 6408, - types: [5121, 32819, 32820] - }, - // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4}, - // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB}, - // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB}, - // 8-bit formats - "r8unorm": { gl: 33321, b: 1, c: 1, rb: true }, - "r8snorm": { gl: 36756, b: 1, c: 1, render: snorm8_renderable }, - "r8uint": { gl: 33330, b: 1, c: 1, rb: true }, - "r8sint": { gl: 33329, b: 1, c: 1, rb: true }, - // 16-bit formats - "rg8unorm": { gl: 33323, b: 2, c: 2, rb: true }, - "rg8snorm": { gl: 36757, b: 2, c: 2, render: snorm8_renderable }, - "rg8uint": { gl: 33336, b: 2, c: 2, rb: true }, - "rg8sint": { gl: 33335, b: 2, c: 2, rb: true }, - "r16uint": { gl: 33332, b: 2, c: 1, rb: true }, - "r16sint": { gl: 33331, b: 2, c: 1, rb: true }, - "r16float": { gl: 33325, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", rb: true }, - "r16unorm-webgl": { gl: 33322, b: 2, c: 1, f: norm16_renderable, rb: true }, - "r16snorm-webgl": { gl: 36760, b: 2, c: 1, f: snorm16_renderable }, - // Packed 16-bit formats - "rgba4unorm-webgl": { gl: 32854, b: 2, c: 4, wgpu: false, rb: true }, - "rgb565unorm-webgl": { gl: 36194, b: 2, c: 4, wgpu: false, rb: true }, - "rgb5a1unorm-webgl": { gl: 32855, b: 2, c: 4, wgpu: false, rb: true }, - // 24-bit formats - "rgb8unorm-webgl": { gl: 32849, b: 3, c: 3, wgpu: false }, - "rgb8snorm-webgl": { gl: 36758, b: 3, c: 3, wgpu: false }, - // 32-bit formats - "rgba8unorm": { gl: 32856, b: 4, c: 2, bpp: 4 }, - "rgba8unorm-srgb": { gl: 35907, b: 4, c: 4, bpp: 4 }, - "rgba8snorm": { gl: 36759, b: 4, c: 4, render: snorm8_renderable }, - "rgba8uint": { gl: 36220, b: 4, c: 4, bpp: 4 }, - "rgba8sint": { gl: 36238, b: 4, c: 4, bpp: 4 }, - // reverse colors, webgpu only - "bgra8unorm": { b: 4, c: 4 }, - "bgra8unorm-srgb": { b: 4, c: 4 }, - "rg16uint": { gl: 33338, b: 4, c: 1, bpp: 4 }, - "rg16sint": { gl: 33337, b: 4, c: 2, bpp: 4 }, - // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension - "rg16float": { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true }, - "rg16unorm-webgl": { gl: 33324, b: 2, c: 2, render: norm16_renderable }, - "rg16snorm-webgl": { gl: 36761, b: 2, c: 2, render: snorm16_renderable }, - "r32uint": { gl: 33334, b: 4, c: 1, bpp: 4, rb: true }, - "r32sint": { gl: 33333, b: 4, c: 1, bpp: 4, rb: true }, - "r32float": { gl: 33326, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable }, - // Packed 32-bit formats - "rgb9e5ufloat": { gl: 35901, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable }, - // , filter: true}, - "rg11b10ufloat": { gl: 35898, b: 4, c: 3, p: 1, render: float32_renderable, rb: true }, - "rgb10a2unorm": { gl: 32857, b: 4, c: 4, p: 1, rb: true }, - "rgb10a2uint-webgl": { b: 4, c: 4, gl: 36975, p: 1, wgpu: false, bpp: 4, rb: true }, - // 48-bit formats - "rgb16unorm-webgl": { gl: 32852, b: 2, c: 3, f: norm16_renderable }, - // rgb not renderable - "rgb16snorm-webgl": { gl: 36762, b: 2, c: 3, f: norm16_renderable }, - // rgb not renderable - // 64-bit formats - "rg32uint": { gl: 33340, b: 8, c: 2, rb: true }, - "rg32sint": { gl: 33339, b: 8, c: 2, rb: true }, - "rg32float": { gl: 33328, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true }, - "rgba16uint": { gl: 36214, b: 8, c: 4, rb: true }, - "rgba16sint": { gl: 36232, b: 8, c: 4, rb: true }, - "rgba16float": { gl: 34842, b: 8, c: 4, render: float16_renderable, filter: float16_filterable }, - "rgba16unorm-webgl": { gl: 32859, b: 2, c: 4, render: norm16_renderable, rb: true }, - "rgba16snorm-webgl": { gl: 36763, b: 2, c: 4, render: snorm16_renderable }, - // 96-bit formats (deprecated!) - "rgb32float-webgl": { - gl: 34837, - render: float32_renderable, - filter: float32_filterable, - gl2ext: EXT_color_buffer_float, - dataFormat: 6407, - types: [5126] - }, - // 128-bit formats - "rgba32uint": { gl: 36208, b: 16, c: 4, rb: true }, - "rgba32sint": { gl: 36226, b: 16, c: 4, rb: true }, - "rgba32float": { gl: 34836, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, rb: true }, - // Depth and stencil formats - "stencil8": { gl: 36168, b: 1, c: 1, attachment: 36128, rb: true }, - // 8 stencil bits - "depth16unorm": { - gl: 33189, - b: 2, - c: 1, - attachment: 36096, - dataFormat: 6402, - types: [5123], - rb: true - }, - // 16 depth bits - "depth24plus": { - gl: 33190, - b: 3, - c: 1, - attachment: 36096, - dataFormat: 6402, - types: [5125] - }, - "depth32float": { - gl: 36012, - b: 4, - c: 1, - attachment: 36096, - dataFormat: 6402, - types: [5126], - rb: true - }, - // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value. - "depth24plus-stencil8": { - gl: 35056, - b: 4, - c: 2, - p: 1, - attachment: 33306, - rb: true, - depthTexture: true, - dataFormat: 34041, - types: [34042] - }, - // "depth24unorm-stencil8" feature - "depth24unorm-stencil8": { - gl: 35056, - b: 4, - c: 2, - p: 1, - attachment: 33306, - dataFormat: 34041, - types: [34042], - rb: true - }, - // "depth32float-stencil8" feature - TODO below is render buffer only? - "depth32float-stencil8": { - gl: 36013, - b: 5, - c: 2, - p: 1, - attachment: 33306, - dataFormat: 34041, - types: [36269], - rb: true - }, - // BC compressed formats: check device.features.has("texture-compression-bc"); - "bc1-rgb-unorm-webgl": { gl: 33776, x: X_S3TC, f: texture_compression_bc }, - "bc1-rgb-unorm-srgb-webgl": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc }, - "bc1-rgba-unorm": { gl: 33777, x: X_S3TC, f: texture_compression_bc }, - "bc1-rgba-unorm-srgb": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc }, - "bc2-rgba-unorm": { gl: 33778, x: X_S3TC, f: texture_compression_bc }, - "bc2-rgba-unorm-srgb": { gl: 35918, x: X_S3TC_SRGB, f: texture_compression_bc }, - "bc3-rgba-unorm": { gl: 33779, x: X_S3TC, f: texture_compression_bc }, - "bc3-rgba-unorm-srgb": { gl: 35919, x: X_S3TC_SRGB, f: texture_compression_bc }, - "bc4-r-unorm": { gl: 36283, x: X_RGTC, f: texture_compression_bc }, - "bc4-r-snorm": { gl: 36284, x: X_RGTC, f: texture_compression_bc }, - "bc5-rg-unorm": { gl: 36285, x: X_RGTC, f: texture_compression_bc }, - "bc5-rg-snorm": { gl: 36286, x: X_RGTC, f: texture_compression_bc }, - "bc6h-rgb-ufloat": { gl: 36495, x: X_BPTC, f: texture_compression_bc }, - "bc6h-rgb-float": { gl: 36494, x: X_BPTC, f: texture_compression_bc }, - "bc7-rgba-unorm": { gl: 36492, x: X_BPTC, f: texture_compression_bc }, - "bc7-rgba-unorm-srgb": { gl: 36493, x: X_BPTC, f: texture_compression_bc }, - // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2") - // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression - "etc2-rgb8unorm": { gl: 37492, f: texture_compression_etc2 }, - "etc2-rgb8unorm-srgb": { gl: 37494, f: texture_compression_etc2 }, - "etc2-rgb8a1unorm": { gl: 37496, f: texture_compression_etc2 }, - "etc2-rgb8a1unorm-srgb": { gl: 37497, f: texture_compression_etc2 }, - "etc2-rgba8unorm": { gl: 37493, f: texture_compression_etc2 }, - "etc2-rgba8unorm-srgb": { gl: 37495, f: texture_compression_etc2 }, - "eac-r11unorm": { gl: 37488, f: texture_compression_etc2 }, - "eac-r11snorm": { gl: 37489, f: texture_compression_etc2 }, - "eac-rg11unorm": { gl: 37490, f: texture_compression_etc2 }, - "eac-rg11snorm": { gl: 37491, f: texture_compression_etc2 }, - // X_ASTC compressed formats: device.features.has("texture-compression-astc") - "astc-4x4-unorm": { gl: 37808, f: texture_compression_astc }, - "astc-4x4-unorm-srgb": { gl: 37840, f: texture_compression_astc }, - "astc-5x4-unorm": { gl: 37809, f: texture_compression_astc }, - "astc-5x4-unorm-srgb": { gl: 37841, f: texture_compression_astc }, - "astc-5x5-unorm": { gl: 37810, f: texture_compression_astc }, - "astc-5x5-unorm-srgb": { gl: 37842, f: texture_compression_astc }, - "astc-6x5-unorm": { gl: 37811, f: texture_compression_astc }, - "astc-6x5-unorm-srgb": { gl: 37843, f: texture_compression_astc }, - "astc-6x6-unorm": { gl: 37812, f: texture_compression_astc }, - "astc-6x6-unorm-srgb": { gl: 37844, f: texture_compression_astc }, - "astc-8x5-unorm": { gl: 37813, f: texture_compression_astc }, - "astc-8x5-unorm-srgb": { gl: 37845, f: texture_compression_astc }, - "astc-8x6-unorm": { gl: 37814, f: texture_compression_astc }, - "astc-8x6-unorm-srgb": { gl: 37846, f: texture_compression_astc }, - "astc-8x8-unorm": { gl: 37815, f: texture_compression_astc }, - "astc-8x8-unorm-srgb": { gl: 37847, f: texture_compression_astc }, - "astc-10x5-unorm": { gl: 37819, f: texture_compression_astc }, - "astc-10x5-unorm-srgb": { gl: 37851, f: texture_compression_astc }, - "astc-10x6-unorm": { gl: 37817, f: texture_compression_astc }, - "astc-10x6-unorm-srgb": { gl: 37849, f: texture_compression_astc }, - "astc-10x8-unorm": { gl: 37818, f: texture_compression_astc }, - "astc-10x8-unorm-srgb": { gl: 37850, f: texture_compression_astc }, - "astc-10x10-unorm": { gl: 37819, f: texture_compression_astc }, - "astc-10x10-unorm-srgb": { gl: 37851, f: texture_compression_astc }, - "astc-12x10-unorm": { gl: 37820, f: texture_compression_astc }, - "astc-12x10-unorm-srgb": { gl: 37852, f: texture_compression_astc }, - "astc-12x12-unorm": { gl: 37821, f: texture_compression_astc }, - "astc-12x12-unorm-srgb": { gl: 37853, f: texture_compression_astc }, - // WEBGL_compressed_texture_pvrtc - "pvrtc-rgb4unorm-webgl": { gl: 35840, f: texture_compression_pvrtc_webgl }, - "pvrtc-rgba4unorm-webgl": { gl: 35842, f: texture_compression_pvrtc_webgl }, - "pvrtc-rbg2unorm-webgl": { gl: 35841, f: texture_compression_pvrtc_webgl }, - "pvrtc-rgba2unorm-webgl": { gl: 35843, f: texture_compression_pvrtc_webgl }, - // WEBGL_compressed_texture_etc1 - "etc1-rbg-unorm-webgl": { gl: 36196, f: texture_compression_etc1_webgl }, - // WEBGL_compressed_texture_atc - "atc-rgb-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl }, - "atc-rgba-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl }, - "atc-rgbai-unorm-webgl": { gl: 34798, f: texture_compression_atc_webgl } -}; -var DATA_FORMAT_CHANNELS = { - [6403]: 1, - [36244]: 1, - [33319]: 2, - [33320]: 2, - [6407]: 3, - [36248]: 3, - [6408]: 4, - [36249]: 4, - [6402]: 1, - [34041]: 1, - [6406]: 1, - [6409]: 1, - [6410]: 2 -}; -var TYPE_SIZES3 = { - [5126]: 4, - [5125]: 4, - [5124]: 4, - [5123]: 2, - [5122]: 2, - [5131]: 2, - [5120]: 1, - [5121]: 1 -}; -function isTextureFormatSupported(gl, format, extensions) { - const info = TEXTURE_FORMATS[format]; - if (!info) { - return false; - } - if (info.gl === void 0) { - return false; - } - const extension = info.x || info.gl2ext; - if (extension) { - return Boolean(getWebGLExtension(gl, extension, extensions)); - } - return true; -} -function convertTextureFormatToGL(format) { - const formatInfo = TEXTURE_FORMATS[format]; - const webglFormat = formatInfo?.gl; - if (webglFormat === void 0) { - throw new Error(`Unsupported texture format ${format}`); - } - return webglFormat; -} -function isTextureFormatFilterable(gl, format, extensions) { - if (!isTextureFormatSupported(gl, format, extensions)) { - return false; - } - if (format.startsWith("depth") || format.startsWith("stencil")) { - return false; - } - try { - const decoded = decodeTextureFormat(format); - if (decoded.signed) { - return false; - } - } catch { - return false; - } - if (format.endsWith("32float")) { - return Boolean(getWebGLExtension(gl, "OES_texture_float_linear, extensions", extensions)); - } - if (format.endsWith("16float")) { - return Boolean(getWebGLExtension(gl, "OES_texture_half_float_linear, extensions", extensions)); - } - return true; -} -function isTextureFormatRenderable(gl, format, extensions) { - if (!isTextureFormatSupported(gl, format, extensions)) { - return false; - } - if (typeof format === "number") { - return false; - } - return true; -} -function getWebGLTextureParameters(format) { - const formatData = TEXTURE_FORMATS[format]; - const webglFormat = convertTextureFormatToGL(format); - const decoded = decodeTextureFormat(format); - return { - format: webglFormat, - dataFormat: formatData?.dataFormat || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat), - // depth formats don't have a type - type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : formatData?.types?.[0] || 5121, - // @ts-expect-error - compressed: decoded.compressed - }; -} -function getDepthStencilAttachmentWebGL(format) { - const info = TEXTURE_FORMATS[format]; - if (!info?.attachment) { - throw new Error(`${format} is not a depth stencil format`); - } - return info.attachment; -} -function getTextureFormatBytesPerPixel(format) { - const params = getWebGLTextureParameters(format); - const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4; - const channelSize = TYPE_SIZES3[params.type] || 1; - return channels * channelSize; -} -function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) { - if (format === 6408 || format === 6407) { - return format; - } - switch (dataFormat) { - case "r": - return integer && !normalized ? 36244 : 6403; - case "rg": - return integer && !normalized ? 33320 : 33319; - case "rgb": - return integer && !normalized ? 36248 : 6407; - case "rgba": - return integer && !normalized ? 36249 : 6408; - default: - return 6408; - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-features.js -var WEBGL_FEATURES = { - // optional WebGPU features - "depth-clip-control": "EXT_depth_clamp", - // TODO these seem subtly different - // 'timestamp-query' // GPUQueryType "timestamp-query" - // "indirect-first-instance" - // Textures are handled by getTextureFeatures() - // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8' - // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8' - // optional WebGL features - "timer-query-webgl": "EXT_disjoint_timer_query_webgl2", - "compilation-status-async-webgl": "KHR_parallel_shader_compile", - "polygon-mode-webgl": "WEBGL_polygon_mode", - "provoking-vertex-webgl": "WEBGL_provoking_vertex", - "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance", - "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation", - "shader-conservative-depth-webgl": "EXT_conservative_depth" - // Textures are handled by getTextureFeatures() -}; -var WebGLDeviceFeatures = class extends DeviceFeatures { - gl; - extensions; - testedFeatures = /* @__PURE__ */ new Set(); - constructor(gl, extensions, disabledFeatures) { - super([], disabledFeatures); - this.gl = gl; - this.extensions = extensions; - getWebGLExtension(gl, "EXT_color_buffer_float", extensions); - } - *[Symbol.iterator]() { - const features = this.getFeatures(); - for (const feature of features) { - if (this.has(feature)) { - yield feature; - } - } - return []; - } - has(feature) { - if (this.disabledFeatures[feature]) { - return false; - } - if (!this.testedFeatures.has(feature)) { - this.testedFeatures.add(feature); - if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) { - this.features.add(feature); - } - if (this.getWebGLFeature(feature)) { - this.features.add(feature); - } - } - return this.features.has(feature); - } - // FOR DEVICE - initializeFeatures() { - const features = this.getFeatures().filter((feature) => feature !== "polygon-mode-webgl"); - for (const feature of features) { - this.has(feature); - } - } - // IMPLEMENTATION - getFeatures() { - return [...Object.keys(WEBGL_FEATURES), ...Object.keys(TEXTURE_FEATURES)]; - } - /** Extract all WebGL features */ - getWebGLFeature(feature) { - const featureInfo = WEBGL_FEATURES[feature]; - const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo); - return isSupported; - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/device-helpers/webgl-device-limits.js -var WebGLDeviceLimits = class extends DeviceLimits { - get maxTextureDimension1D() { - return 0; - } - // WebGL does not support 1D textures - get maxTextureDimension2D() { - return this.getParameter(3379); - } - get maxTextureDimension3D() { - return this.getParameter(32883); - } - get maxTextureArrayLayers() { - return this.getParameter(35071); - } - get maxBindGroups() { - return 0; - } - get maxDynamicUniformBuffersPerPipelineLayout() { - return 0; - } - // TBD - get maxDynamicStorageBuffersPerPipelineLayout() { - return 0; - } - // TBD - get maxSampledTexturesPerShaderStage() { - return this.getParameter(35660); - } - // ) TBD - get maxSamplersPerShaderStage() { - return this.getParameter(35661); - } - get maxStorageBuffersPerShaderStage() { - return 0; - } - // TBD - get maxStorageTexturesPerShaderStage() { - return 0; - } - // TBD - get maxUniformBuffersPerShaderStage() { - return this.getParameter(35375); - } - get maxUniformBufferBindingSize() { - return this.getParameter(35376); - } - get maxStorageBufferBindingSize() { - return 0; - } - get minUniformBufferOffsetAlignment() { - return this.getParameter(35380); - } - get minStorageBufferOffsetAlignment() { - return 0; - } - get maxVertexBuffers() { - return 16; - } - // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284 - get maxVertexAttributes() { - return this.getParameter(34921); - } - get maxVertexBufferArrayStride() { - return 2048; - } - // TBD, this is just the default value from WebGPU - get maxInterStageShaderComponents() { - return this.getParameter(35659); - } - get maxComputeWorkgroupStorageSize() { - return 0; - } - // WebGL does not support compute shaders - get maxComputeInvocationsPerWorkgroup() { - return 0; - } - // WebGL does not support compute shaders - get maxComputeWorkgroupSizeX() { - return 0; - } - // WebGL does not support compute shaders - get maxComputeWorkgroupSizeY() { - return 0; - } - // WebGL does not support compute shaders - get maxComputeWorkgroupSizeZ() { - return 0; - } - // WebGL does not support compute shaders - get maxComputeWorkgroupsPerDimension() { - return 0; - } - // WebGL does not support compute shaders - // PRIVATE - gl; - limits = {}; - constructor(gl) { - super(); - this.gl = gl; - } - getParameter(parameter) { - if (this.limits[parameter] === void 0) { - this.limits[parameter] = this.gl.getParameter(parameter); - } - return this.limits[parameter]; - } -}; - -// node_modules/@luma.gl/webgl/dist/context/state-tracker/with-parameters.js -function withGLParameters(gl, parameters, func) { - if (isObjectEmpty3(parameters)) { - return func(gl); - } - const { nocatch = true } = parameters; - pushContextState(gl); - setGLParameters(gl, parameters); - let value; - if (nocatch) { - value = func(gl); - popContextState(gl); - } else { - try { - value = func(gl); - } finally { - popContextState(gl); - } - } - return value; -} -function isObjectEmpty3(object) { - for (const key in object) { - return false; - } - return true; -} - -// node_modules/@luma.gl/webgl/dist/adapter/converters/device-parameters.js -function withDeviceAndGLParameters(device, parameters, glParameters, func) { - if (isObjectEmpty(parameters)) { - return func(device); - } - const webglDevice = device; - pushContextState(webglDevice.gl); - try { - setDeviceParameters(device, parameters); - setGLParameters(webglDevice.gl, glParameters); - return func(device); - } finally { - popContextState(webglDevice.gl); - } -} -function setDeviceParameters(device, parameters) { - const webglDevice = device; - const { gl } = webglDevice; - if (parameters.cullMode) { - switch (parameters.cullMode) { - case "none": - gl.disable(2884); - break; - case "front": - gl.enable(2884); - gl.cullFace(1028); - break; - case "back": - gl.enable(2884); - gl.cullFace(1029); - break; - } - } - if (parameters.frontFace) { - gl.frontFace(map2("frontFace", parameters.frontFace, { - ccw: 2305, - cw: 2304 - })); - } - if (parameters.unclippedDepth) { - if (device.features.has("depth-clip-control")) { - gl.enable(34383); - } - } - if (parameters.depthBias !== void 0) { - gl.enable(32823); - gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0); - } - if (parameters.provokingVertex) { - if (device.features.has("provoking-vertex-webgl")) { - const extensions = webglDevice.getExtension("WEBGL_provoking_vertex"); - const ext = extensions.WEBGL_provoking_vertex; - const vertex = map2("provokingVertex", parameters.provokingVertex, { - first: 36429, - last: 36430 - }); - ext?.provokingVertexWEBGL(vertex); - } - } - if (parameters.polygonMode || parameters.polygonOffsetLine) { - if (device.features.has("polygon-mode-webgl")) { - if (parameters.polygonMode) { - const extensions = webglDevice.getExtension("WEBGL_polygon_mode"); - const ext = extensions.WEBGL_polygon_mode; - const mode = map2("polygonMode", parameters.polygonMode, { - fill: 6914, - line: 6913 - }); - ext?.polygonModeWEBGL(1028, mode); - ext?.polygonModeWEBGL(1029, mode); - } - if (parameters.polygonOffsetLine) { - gl.enable(10754); - } - } - } - if (device.features.has("shader-clip-cull-distance-webgl")) { - if (parameters.clipDistance0) { - gl.enable(12288); - } - if (parameters.clipDistance1) { - gl.enable(12289); - } - if (parameters.clipDistance2) { - gl.enable(12290); - } - if (parameters.clipDistance3) { - gl.enable(12291); - } - if (parameters.clipDistance4) { - gl.enable(12292); - } - if (parameters.clipDistance5) { - gl.enable(12293); - } - if (parameters.clipDistance6) { - gl.enable(12294); - } - if (parameters.clipDistance7) { - gl.enable(12295); - } - } - if (parameters.depthWriteEnabled !== void 0) { - gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled)); - } - if (parameters.depthCompare) { - parameters.depthCompare !== "always" ? gl.enable(2929) : gl.disable(2929); - gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare)); - } - if (parameters.stencilWriteMask) { - const mask = parameters.stencilWriteMask; - gl.stencilMaskSeparate(1028, mask); - gl.stencilMaskSeparate(1029, mask); - } - if (parameters.stencilReadMask) { - log2.warn("stencilReadMask not supported under WebGL"); - } - if (parameters.stencilCompare) { - const mask = parameters.stencilReadMask || 4294967295; - const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare); - parameters.stencilCompare !== "always" ? gl.enable(2960) : gl.disable(2960); - gl.stencilFuncSeparate(1028, glValue, 0, mask); - gl.stencilFuncSeparate(1029, glValue, 0, mask); - } - if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) { - const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation); - const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation); - const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation); - gl.stencilOpSeparate(1028, sfail, dpfail, dppass); - gl.stencilOpSeparate(1029, sfail, dpfail, dppass); - } - if (parameters.blendColorOperation || parameters.blendAlphaOperation) { - gl.enable(3042); - const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add"); - const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add"); - gl.blendEquationSeparate(colorEquation, alphaEquation); - const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one"); - const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero"); - const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one"); - const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero"); - gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor); - } -} -function convertCompareFunction(parameter, value) { - return map2(parameter, value, { - never: 512, - less: 513, - equal: 514, - "less-equal": 515, - greater: 516, - "not-equal": 517, - "greater-equal": 518, - always: 519 - }); -} -function convertStencilOperation(parameter, value) { - return map2(parameter, value, { - keep: 7680, - zero: 0, - replace: 7681, - invert: 5386, - "increment-clamp": 7682, - "decrement-clamp": 7683, - "increment-wrap": 34055, - "decrement-wrap": 34056 - }); -} -function convertBlendOperationToEquation(parameter, value) { - return map2(parameter, value, { - add: 32774, - subtract: 32778, - "reverse-subtract": 32779, - min: 32775, - max: 32776 - }); -} -function convertBlendFactorToFunction(parameter, value) { - return map2(parameter, value, { - one: 1, - zero: 0, - "src-color": 768, - "one-minus-src-color": 769, - "dst-color": 774, - "one-minus-dst-color": 775, - "src-alpha": 770, - "one-minus-src-alpha": 771, - "dst-alpha": 772, - "one-minus-dst-alpha": 773, - "src-alpha-saturated": 776, - "constant-color": 32769, - "one-minus-constant-color": 32770, - "constant-alpha": 32771, - "one-minus-constant-alpha": 32772 - }); -} -function message(parameter, value) { - return `Illegal parameter ${value} for ${parameter}`; -} -function map2(parameter, value, valueMap) { - if (!(value in valueMap)) { - throw new Error(message(parameter, value)); - } - return valueMap[value]; -} -function mapBoolean(parameter, value) { - return value; -} - -// node_modules/@luma.gl/webgl/dist/adapter/converters/sampler-parameters.js -function convertSamplerParametersToWebGL(props) { - const params = {}; - if (props.addressModeU) { - params[10242] = convertAddressMode(props.addressModeU); - } - if (props.addressModeV) { - params[10243] = convertAddressMode(props.addressModeV); - } - if (props.addressModeW) { - params[32882] = convertAddressMode(props.addressModeW); - } - if (props.magFilter) { - params[10240] = convertMaxFilterMode(props.magFilter); - } - if (props.minFilter || props.mipmapFilter) { - params[10241] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter); - } - if (props.lodMinClamp !== void 0) { - params[33082] = props.lodMinClamp; - } - if (props.lodMaxClamp !== void 0) { - params[33083] = props.lodMaxClamp; - } - if (props.type === "comparison-sampler") { - params[34892] = 34894; - } - if (props.compare) { - params[34893] = convertCompareFunction("compare", props.compare); - } - if (props.maxAnisotropy) { - params[34046] = props.maxAnisotropy; - } - return params; -} -function convertAddressMode(addressMode) { - switch (addressMode) { - case "clamp-to-edge": - return 33071; - case "repeat": - return 10497; - case "mirror-repeat": - return 33648; - } -} -function convertMaxFilterMode(maxFilter) { - switch (maxFilter) { - case "nearest": - return 9728; - case "linear": - return 9729; - } -} -function convertMinFilterMode(minFilter, mipmapFilter) { - if (!mipmapFilter) { - return convertMaxFilterMode(minFilter); - } - switch (minFilter) { - case "nearest": - return mipmapFilter === "nearest" ? 9984 : 9986; - case "linear": - return mipmapFilter === "nearest" ? 9985 : 9987; - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-buffer.js -var WEBGLBuffer = class extends Buffer2 { - device; - gl; - handle; - /** Target in OpenGL defines the type of buffer */ - glTarget; - /** Usage is a hint on how frequently the buffer will be updates */ - glUsage; - /** Index type is needed when issuing draw calls, so we pre-compute it */ - glIndexType = 5123; - /** Number of bytes allocated on the GPU for this buffer */ - byteLength; - /** Number of bytes used */ - bytesUsed; - constructor(device, props = {}) { - super(device, props); - this.device = device; - this.gl = this.device.gl; - const handle = typeof props === "object" ? props.handle : void 0; - this.handle = handle || this.gl.createBuffer(); - device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data }); - this.glTarget = getWebGLTarget(this.props.usage); - this.glUsage = getWebGLUsage(this.props.usage); - this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123; - if (props.data) { - this._initWithData(props.data, props.byteOffset, props.byteLength); - } else { - this._initWithByteLength(props.byteLength || 0); - } - } - // PRIVATE METHODS - /** Allocate a new buffer and initialize to contents of typed array */ - _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) { - const glTarget = this.glTarget; - this.gl.bindBuffer(glTarget, this.handle); - this.gl.bufferData(glTarget, byteLength, this.glUsage); - this.gl.bufferSubData(glTarget, byteOffset, data); - this.gl.bindBuffer(glTarget, null); - this.bytesUsed = byteLength; - this.byteLength = byteLength; - this._setDebugData(data, byteOffset, byteLength); - this.trackAllocatedMemory(byteLength); - } - // Allocate a GPU buffer of specified size. - _initWithByteLength(byteLength) { - assert6(byteLength >= 0); - let data = byteLength; - if (byteLength === 0) { - data = new Float32Array(0); - } - const glTarget = this.glTarget; - this.gl.bindBuffer(glTarget, this.handle); - this.gl.bufferData(glTarget, data, this.glUsage); - this.gl.bindBuffer(glTarget, null); - this.bytesUsed = byteLength; - this.byteLength = byteLength; - this._setDebugData(null, 0, byteLength); - this.trackAllocatedMemory(byteLength); - return this; - } - destroy() { - if (!this.destroyed && this.handle) { - this.removeStats(); - this.trackDeallocatedMemory(); - this.gl.deleteBuffer(this.handle); - this.destroyed = true; - this.handle = null; - } - } - write(data, byteOffset = 0) { - const srcOffset = 0; - const byteLength = void 0; - const glTarget = 36663; - this.gl.bindBuffer(glTarget, this.handle); - if (srcOffset !== 0 || byteLength !== void 0) { - this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength); - } else { - this.gl.bufferSubData(glTarget, byteOffset, data); - } - this.gl.bindBuffer(glTarget, null); - this._setDebugData(data, byteOffset, data.byteLength); - } - /** Asynchronously read data from the buffer */ - async readAsync(byteOffset = 0, byteLength) { - return this.readSyncWebGL(byteOffset, byteLength); - } - /** Synchronously read data from the buffer. WebGL only. */ - readSyncWebGL(byteOffset = 0, byteLength) { - byteLength = byteLength ?? this.byteLength - byteOffset; - const data = new Uint8Array(byteLength); - const dstOffset = 0; - this.gl.bindBuffer(36662, this.handle); - this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength); - this.gl.bindBuffer(36662, null); - this._setDebugData(data, byteOffset, byteLength); - return data; - } -}; -function getWebGLTarget(usage) { - if (usage & Buffer2.INDEX) { - return 34963; - } - if (usage & Buffer2.VERTEX) { - return 34962; - } - if (usage & Buffer2.UNIFORM) { - return 35345; - } - return 34962; -} -function getWebGLUsage(usage) { - if (usage & Buffer2.INDEX) { - return 35044; - } - if (usage & Buffer2.VERTEX) { - return 35044; - } - if (usage & Buffer2.UNIFORM) { - return 35048; - } - return 35044; -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-sampler.js -var WEBGLSampler = class extends Sampler { - device; - handle; - parameters; - constructor(device, props) { - super(device, props); - this.device = device; - this.parameters = convertSamplerParametersToWebGL(props); - this.handle = this.handle || this.device.gl.createSampler(); - this._setSamplerParameters(this.parameters); - } - destroy() { - if (this.handle) { - this.device.gl.deleteSampler(this.handle); - this.handle = void 0; - } - } - toString() { - return `Sampler(${this.id},${JSON.stringify(this.props)})`; - } - /** Set sampler parameters on the sampler */ - _setSamplerParameters(parameters) { - for (const [pname, value] of Object.entries(parameters)) { - const param = Number(pname); - switch (param) { - case 33082: - case 33083: - this.device.gl.samplerParameterf(this.handle, param, value); - break; - default: - this.device.gl.samplerParameteri(this.handle, param, value); - break; - } - } - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-texture-view.js -var WEBGLTextureView = class extends TextureView { - device; - gl; - handle; - texture; - constructor(device, props) { - super(device, { ...Texture.defaultProps, ...props }); - this.device = device; - this.gl = this.device.gl; - this.handle = null; - this.texture = props.texture; - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-texture.js -var DEFAULT_WEBGL_TEXTURE_PROPS = { - // deprecated - parameters: {}, - pixelStore: {}, - pixels: null, - border: 0, - dataFormat: void 0, - textureUnit: void 0, - target: void 0 -}; -var WEBGLTexture = class _WEBGLTexture extends Texture { - // TODO - remove? - static FACES = [ - 34069, - 34070, - 34071, - 34072, - 34073, - 34074 - ]; - MAX_ATTRIBUTES; - device; - gl; - handle; - // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */ - sampler = void 0; - view = void 0; - // data; - glFormat = void 0; - type = void 0; - dataFormat = void 0; - mipmaps = void 0; - /** - * @note `target` cannot be modified by bind: - * textures are special because when you first bind them to a target, - * they get special information. When you first bind a texture as a - * GL_TEXTURE_2D, you are saying that this texture is a 2D texture. - * And it will always be a 2D texture; this state cannot be changed ever. - * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D; - * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error - * */ - target; - textureUnit = void 0; - /** - * Program.draw() checks the loaded flag of all textures to avoid - * Textures that are still loading from promises - * Set to true as soon as texture has been initialized with valid data - */ - loaded = false; - _video; - constructor(device, props) { - super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props }); - this.device = device; - this.gl = this.device.gl; - this.handle = this.props.handle || this.gl.createTexture(); - this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data }); - this.glFormat = 6408; - this.target = getWebGLTextureTarget(this.props); - this.loaded = false; - if (typeof this.props?.data === "string") { - Object.assign(this.props, { data: loadImage(this.props.data) }); - } - this.initialize(this.props); - Object.seal(this); - } - destroy() { - if (this.handle) { - this.gl.deleteTexture(this.handle); - this.removeStats(); - this.trackDeallocatedMemory("Texture"); - this.destroyed = true; - } - } - toString() { - return `Texture(${this.id},${this.width}x${this.height})`; - } - createView(props) { - return new WEBGLTextureView(this.device, { ...props, texture: this }); - } - // eslint-disable-next-line max-statements - initialize(props = {}) { - if (this.props.dimension === "cube") { - return this.initializeCube(props); - } - let data = props.data; - if (data instanceof Promise) { - data.then((resolvedImageData) => this.initialize(Object.assign({}, props, { - pixels: resolvedImageData, - data: resolvedImageData - }))); - return this; - } - const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement; - if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) { - this._video = null; - data.addEventListener("loadeddata", () => this.initialize(props)); - return this; - } - const { parameters = {} } = props; - const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props; - if (!data) { - data = pixels; - } - let { width, height, dataFormat, type, compressed = false } = props; - const { depth = 0 } = props; - const glFormat = convertTextureFormatToGL(props.format); - ({ width, height, compressed, dataFormat, type } = this._deduceParameters({ - format: props.format, - type, - dataFormat, - compressed, - data, - width, - height - })); - this.width = width; - this.height = height; - this.glFormat = glFormat; - this.type = type; - this.dataFormat = dataFormat; - this.textureUnit = textureUnit; - if (Number.isFinite(this.textureUnit)) { - this.gl.activeTexture(33984 + this.textureUnit); - this.gl.bindTexture(this.target, this.handle); - } - this.mipmaps = mipmaps; - this.setImageData({ - data, - width, - height, - depth, - format: props.format, - type, - dataFormat, - // @ts-expect-error - parameters: pixelStore, - compressed - }); - this.setSampler(props.sampler); - this._setSamplerParameters(parameters); - this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 }); - if (mipmaps && this.device.isTextureFormatFilterable(props.format)) { - this.generateMipmap(); - } - if (isVideo) { - this._video = { - video: data, - parameters, - // @ts-expect-error - lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1 - }; - } - return this; - } - initializeCube(props) { - const { mipmaps = true, parameters = {} } = props; - this.setCubeMapImageData(props).then(() => { - this.loaded = true; - if (mipmaps) { - this.generateMipmap(props); - } - this.setSampler(props.sampler); - this._setSamplerParameters(parameters); - }); - return this; - } - setSampler(sampler = {}) { - let samplerProps; - if (sampler instanceof WEBGLSampler) { - this.sampler = sampler; - samplerProps = sampler.props; - } else { - this.sampler = new WEBGLSampler(this.device, sampler); - samplerProps = sampler; - } - const parameters = convertSamplerParametersToWebGL(samplerProps); - this._setSamplerParameters(parameters); - return this; - } - /** - * If size has changed, reinitializes with current format - * @note note clears image and mipmaps - */ - resize(options) { - const { height, width, mipmaps = false } = options; - if (width !== this.width || height !== this.height) { - return this.initialize({ - width, - height, - format: this.format, - type: this.type, - dataFormat: this.dataFormat, - mipmaps - }); - } - return this; - } - /** Update external texture (video frame) */ - update() { - if (this._video) { - const { video, parameters, lastTime } = this._video; - if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) { - return; - } - this.setSubImageData({ - data: video, - parameters - }); - if (this.mipmaps) { - this.generateMipmap(); - } - this._video.lastTime = video.currentTime; - } - } - // Call to regenerate mipmaps after modifying texture(s) - generateMipmap(params = {}) { - this.mipmaps = true; - this.gl.bindTexture(this.target, this.handle); - withGLParameters(this.gl, params, () => { - this.gl.generateMipmap(this.target); - }); - this.gl.bindTexture(this.target, null); - return this; - } - /* - * Allocates storage - * @param {*} pixels - - * null - create empty texture of specified format - * Typed array - init from image data in typed array - * Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer - * HTMLImageElement|Image - Inits with content of image. Auto width/height - * HTMLCanvasElement - Inits with contents of canvas. Auto width/height - * HTMLVideoElement - Creates video texture. Auto width/height - * - * @param width - - * @param height - - * @param mipMapLevel - - * @param {GLenum} format - format of image data. - * @param {GLenum} type - * - format of array (autodetect from type) or - * - (WEBGL2) format of buffer - * @param {Number} offset - (WEBGL2) offset from start of buffer - * @parameters - temporary settings to be applied, can be used to supply pixel store settings. - */ - // eslint-disable-next-line max-statements, complexity - setImageData(options) { - if (this.props.dimension === "3d" || this.props.dimension === "2d-array") { - return this.setImageData3D(options); - } - this.trackDeallocatedMemory("Texture"); - const { target = this.target, pixels = null, level = 0, glFormat = this.glFormat, offset = 0, parameters = {} } = options; - let { data = null, type = this.type, width = this.width, height = this.height, dataFormat = this.dataFormat, compressed = false } = options; - if (!data) { - data = pixels; - } - ({ type, dataFormat, compressed, width, height } = this._deduceParameters({ - format: this.props.format, - type, - dataFormat, - compressed, - data, - width, - height - })); - const { gl } = this; - gl.bindTexture(this.target, this.handle); - let dataType = null; - ({ data, dataType } = this._getDataType({ data, compressed })); - withGLParameters(this.gl, parameters, () => { - switch (dataType) { - case "null": - gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data); - break; - case "typed-array": - gl.texImage2D( - target, - level, - glFormat, - width, - height, - 0, - // border (must be 0) - dataFormat, - type, - data, - offset - ); - break; - case "buffer": - this.device.gl.bindBuffer(35052, data.handle || data); - this.device.gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset); - this.device.gl.bindBuffer(35052, null); - break; - case "browser-object": - gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data); - break; - case "compressed": - for (const [levelIndex, levelData] of data.entries()) { - gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data); - } - break; - default: - assert6(false, "Unknown image data type"); - } - }); - if (data && data.byteLength) { - this.trackAllocatedMemory(data.byteLength, "Texture"); - } else { - const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format); - this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture"); - } - this.loaded = true; - return this; - } - /** - * Redefines an area of an existing texture - * Note: does not allocate storage - * Redefines an area of an existing texture - */ - setSubImageData({ target = this.target, pixels = null, data = null, x = 0, y = 0, width = this.width, height = this.height, level = 0, glFormat = this.glFormat, type = this.type, dataFormat = this.dataFormat, compressed = false, offset = 0, parameters = {} }) { - ({ type, dataFormat, compressed, width, height } = this._deduceParameters({ - format: this.props.format, - type, - dataFormat, - compressed, - data, - width, - height - })); - assert6(this.depth === 1, "texSubImage not supported for 3D textures"); - if (!data) { - data = pixels; - } - if (data && data.data) { - const ndarray = data; - data = ndarray.data; - width = ndarray.shape[0]; - height = ndarray.shape[1]; - } - if (data instanceof WEBGLBuffer) { - data = data.handle; - } - this.gl.bindTexture(this.target, this.handle); - withGLParameters(this.gl, parameters, () => { - if (compressed) { - this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data); - } else if (data === null) { - this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null); - } else if (ArrayBuffer.isView(data)) { - this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset); - } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) { - this.device.gl.bindBuffer(35052, data); - this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset); - this.device.gl.bindBuffer(35052, null); - } else { - this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data); - } - }); - this.gl.bindTexture(this.target, null); - } - /** - * Defines a two-dimensional texture image or cube-map texture image with - * pixels from the current framebuffer (rather than from client memory). - * (gl.copyTexImage2D wrapper) - * - * Note that binding a texture into a Framebuffer's color buffer and - * rendering can be faster. - */ - copyFramebuffer(opts = {}) { - log2.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(); - return null; - } - getActiveUnit() { - return this.gl.getParameter(34016) - 33984; - } - bind(textureUnit = this.textureUnit) { - const { gl } = this; - if (textureUnit !== void 0) { - this.textureUnit = textureUnit; - gl.activeTexture(33984 + textureUnit); - } - gl.bindTexture(this.target, this.handle); - return textureUnit; - } - unbind(textureUnit = this.textureUnit) { - const { gl } = this; - if (textureUnit !== void 0) { - this.textureUnit = textureUnit; - gl.activeTexture(33984 + textureUnit); - } - gl.bindTexture(this.target, null); - return textureUnit; - } - // PRIVATE METHODS - _getDataType({ data, compressed = false }) { - if (compressed) { - return { data, dataType: "compressed" }; - } - if (data === null) { - return { data, dataType: "null" }; - } - if (ArrayBuffer.isView(data)) { - return { data, dataType: "typed-array" }; - } - if (data instanceof WEBGLBuffer) { - return { data: data.handle, dataType: "buffer" }; - } - if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) { - return { data, dataType: "buffer" }; - } - return { data, dataType: "browser-object" }; - } - // HELPER METHODS - _deduceParameters(opts) { - const { format, data } = opts; - let { width, height, dataFormat, type, compressed } = opts; - const parameters = getWebGLTextureParameters(format); - dataFormat = dataFormat || parameters.dataFormat; - type = type || parameters.type; - compressed = compressed || parameters.compressed; - ({ width, height } = this._deduceImageSize(data, width, height)); - return { dataFormat, type, compressed, width, height, format, data }; - } - // eslint-disable-next-line complexity - _deduceImageSize(data, width, height) { - let size; - if (typeof ImageData !== "undefined" && data instanceof ImageData) { - size = { width: data.width, height: data.height }; - } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) { - size = { width: data.naturalWidth, height: data.naturalHeight }; - } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) { - size = { width: data.width, height: data.height }; - } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) { - size = { width: data.width, height: data.height }; - } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) { - size = { width: data.videoWidth, height: data.videoHeight }; - } else if (!data) { - size = { width: width >= 0 ? width : 1, height: height >= 0 ? height : 1 }; - } else { - size = { width, height }; - } - assert6(size, "Could not deduced texture size"); - assert6(width === void 0 || size.width === width, "Deduced texture width does not match supplied width"); - assert6(height === void 0 || size.height === height, "Deduced texture height does not match supplied height"); - return size; - } - // CUBE MAP METHODS - /* eslint-disable max-statements, max-len */ - async setCubeMapImageData(options) { - const { gl } = this; - const { width, height, pixels, data, format = 6408, type = 5121 } = options; - const imageDataMap = pixels || data; - const resolvedFaces = await Promise.all(_WEBGLTexture.FACES.map((face) => { - const facePixels = imageDataMap[face]; - return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]); - })); - this.bind(); - _WEBGLTexture.FACES.forEach((face, index2) => { - if (resolvedFaces[index2].length > 1 && this.props.mipmaps !== false) { - log2.warn(`${this.id} has mipmap and multiple LODs.`)(); - } - resolvedFaces[index2].forEach((image, lodLevel) => { - if (width && height) { - gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image); - } else { - gl.texImage2D(face, lodLevel, format, format, type, image); - } - }); - }); - this.unbind(); - } - /** @todo update this method to accept LODs */ - setImageDataForFace(options) { - const { - face, - width, - height, - pixels, - data, - format = 6408, - type = 5121 - // generateMipmap = false // TODO - } = options; - const { gl } = this; - const imageData = pixels || data; - this.bind(); - if (imageData instanceof Promise) { - imageData.then((resolvedImageData) => this.setImageDataForFace(Object.assign({}, options, { - face, - data: resolvedImageData, - pixels: resolvedImageData - }))); - } else if (this.width || this.height) { - gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData); - } else { - gl.texImage2D(face, 0, format, format, type, imageData); - } - return this; - } - /** Image 3D copies from Typed Array or WebGLBuffer */ - setImageData3D(options) { - const { - level = 0, - dataFormat, - format, - type, - // = GL.UNSIGNED_BYTE, - width, - height, - depth = 1, - offset = 0, - data, - parameters = {} - } = options; - this.trackDeallocatedMemory("Texture"); - this.gl.bindTexture(this.target, this.handle); - const webglTextureFormat = getWebGLTextureParameters(format); - withGLParameters(this.gl, parameters, () => { - if (ArrayBuffer.isView(data)) { - this.gl.texImage3D( - this.target, - level, - webglTextureFormat.format, - width, - height, - depth, - 0, - webglTextureFormat.dataFormat, - webglTextureFormat.type, - // dataType: getWebGL, - data - ); - } - if (data instanceof WEBGLBuffer) { - this.gl.bindBuffer(35052, data.handle); - this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset); - } - }); - if (data && data.byteLength) { - this.trackAllocatedMemory(data.byteLength, "Texture"); - } else { - const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format); - this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, "Texture"); - } - this.loaded = true; - return this; - } - // RESOURCE METHODS - /** - * Sets sampler parameters on texture - */ - _setSamplerParameters(parameters) { - if (isObjectEmpty(parameters)) { - return; - } - logParameters(parameters); - this.gl.bindTexture(this.target, this.handle); - for (const [pname, pvalue] of Object.entries(parameters)) { - const param = Number(pname); - const value = pvalue; - switch (param) { - case 33082: - case 33083: - this.gl.texParameterf(this.target, param, value); - break; - default: - this.gl.texParameteri(this.target, param, value); - break; - } - } - this.gl.bindTexture(this.target, null); - return; - } -}; -function getWebGLTextureTarget(props) { - switch (props.dimension) { - case "2d": - return 3553; - case "cube": - return 34067; - case "2d-array": - return 35866; - case "3d": - return 32879; - case "1d": - case "cube-array": - default: - throw new Error(props.dimension); - } -} -function logParameters(parameters) { - log2.log(1, "texture sampler parameters", parameters)(); -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-framebuffer.js -var WEBGLFramebuffer = class extends Framebuffer { - device; - gl; - handle; - get texture() { - return this.colorAttachments[0]; - } - constructor(device, props) { - super(device, props); - const isDefaultFramebuffer = props.handle === null; - this.device = device; - this.gl = device.gl; - this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer(); - if (!isDefaultFramebuffer) { - device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props }); - this.autoCreateAttachmentTextures(); - const prevHandle = this.gl.bindFramebuffer(36160, this.handle); - for (let i = 0; i < this.colorAttachments.length; ++i) { - const attachment = this.colorAttachments[i]; - const attachmentPoint = 36064 + i; - if (attachment) { - this._attachOne(attachmentPoint, attachment); - } - } - if (this.depthStencilAttachment) { - this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment); - } - if (props.check !== false) { - const status = this.gl.checkFramebufferStatus(36160); - if (status !== 36053) { - throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`); - } - } - this.gl.bindFramebuffer(36160, prevHandle); - } - } - /** destroys any auto created resources etc. */ - destroy() { - super.destroy(); - if (!this.destroyed && this.handle !== null) { - this.gl.deleteFramebuffer(this.handle); - } - } - // PRIVATE - /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */ - createDepthStencilTexture(format) { - return new WEBGLTexture(this.device, { - id: `${this.id}-depth-stencil`, - format, - width: this.width, - height: this.height, - mipmaps: false - }); - } - /** - * Attachment resize is expected to be a noop if size is same - */ - resizeAttachments(width, height) { - if (this.handle === null) { - this.width = this.gl.drawingBufferWidth; - this.height = this.gl.drawingBufferHeight; - return this; - } - if (width === void 0) { - width = this.gl.drawingBufferWidth; - } - if (height === void 0) { - height = this.gl.drawingBufferHeight; - } - for (const colorAttachment of this.colorAttachments) { - colorAttachment.texture.resize({ width, height }); - } - if (this.depthStencilAttachment) { - this.depthStencilAttachment.texture.resize({ width, height }); - } - return this; - } - /** Attach one attachment */ - _attachOne(attachmentPoint, attachment) { - if (Array.isArray(attachment)) { - const [texture, layer = 0, level = 0] = attachment; - this._attachTexture(attachmentPoint, texture, layer, level); - return texture; - } - if (attachment instanceof WEBGLTexture) { - this._attachTexture(attachmentPoint, attachment, 0, 0); - return attachment; - } - if (attachment instanceof WEBGLTextureView) { - const textureView = attachment; - this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer); - return attachment.texture; - } - throw new Error("attach"); - } - // TODO - we do not seem to need render buffers in WebGL 2 - // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void { - // this.gl.framebufferRenderbuffer( - // GL.FRAMEBUFFER, - // attachment, - // GL.RENDERBUFFER, - // renderbuffer.handle - // ); - // } - /** - * @param attachment - * @param texture - * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap` - * @param level = 0 - mipmapLevel - */ - _attachTexture(attachment, texture, layer, level) { - const { gl } = this.device; - gl.bindTexture(texture.target, texture.handle); - switch (texture.target) { - case 35866: - case 32879: - gl.framebufferTextureLayer(36160, attachment, texture.target, level, layer); - break; - case 34067: - const face = mapIndexToCubeMapFace(layer); - gl.framebufferTexture2D(36160, attachment, face, texture.handle, level); - break; - case 3553: - gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level); - break; - default: - assert6(false, "Illegal texture type"); - } - gl.bindTexture(texture.target, null); - } -}; -function mapIndexToCubeMapFace(layer) { - return layer < 34069 ? layer + 34069 : layer; -} -function _getFrameBufferStatus(status) { - switch (status) { - case 36053: - return "success"; - case 36054: - return "Mismatched attachments"; - case 36055: - return "No attachments"; - case 36057: - return "Height/width mismatch"; - case 36061: - return "Unsupported or split attachments"; - case 36182: - return "Samples mismatch"; - default: - return `${status}`; - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/webgl-canvas-context.js -var WebGLCanvasContext = class extends CanvasContext { - device; - presentationSize; - _framebuffer = null; - constructor(device, props) { - super(props); - this.device = device; - this.presentationSize = [-1, -1]; - this._setAutoCreatedCanvasId(`${this.device.id}-canvas`); - this.update(); - } - getCurrentFramebuffer() { - this.update(); - this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null }); - return this._framebuffer; - } - /** Resizes and updates render targets if necessary */ - update() { - const size = this.getPixelSize(); - const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1]; - if (sizeChanged) { - this.presentationSize = size; - this.resize(); - } - } - /** - * Resize the canvas' drawing buffer. - * - * Can match the canvas CSS size, and optionally also consider devicePixelRatio - * Can be called every frame - * - * Regardless of size, the drawing buffer will always be scaled to the viewport, but - * for best visual results, usually set to either: - * canvas CSS width x canvas CSS height - * canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio - * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html - */ - resize(options) { - if (!this.device.gl) - return; - if (this.canvas) { - const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels); - this.setDevicePixelRatio(devicePixelRatio, options); - return; - } - } - commit() { - } -}; - -// node_modules/@luma.gl/webgl/dist/context/debug/spector.js -var DEFAULT_SPECTOR_PROPS = { - spector: log2.get("spector") || log2.get("spectorjs") -}; -var SPECTOR_CDN_URL = "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js"; -var LOG_LEVEL = 1; -var spector = null; -var initialized = false; -async function loadSpectorJS(props) { - if (!globalThis.SPECTOR) { - try { - await loadScript(SPECTOR_CDN_URL); - } catch (error) { - log2.warn(String(error)); - } - } -} -function initializeSpectorJS(props) { - props = { ...DEFAULT_SPECTOR_PROPS, ...props }; - if (!props?.spector) { - return null; - } - if (!spector && globalThis.SPECTOR) { - log2.probe(LOG_LEVEL, "SPECTOR found and initialized")(); - spector = new globalThis.SPECTOR.Spector(); - if (globalThis.luma) { - globalThis.luma.spector = spector; - } - } - if (!spector) { - return null; - } - if (!initialized) { - initialized = true; - spector.spyCanvases(); - spector?.onCaptureStarted.add((capture) => log2.info("Spector capture started:", capture)()); - spector?.onCapture.add((capture) => { - log2.info("Spector capture complete:", capture)(); - spector?.getResultUI(); - spector?.resultView.display(); - spector?.resultView.addCapture(capture); - }); - } - if (props?.canvas) { - if (typeof props.spector === "string" && props.spector !== props.canvas.id) { - return spector; - } - spector?.startCapture(props?.canvas, 500); - new Promise((resolve2) => setTimeout(resolve2, 2e3)).then((_) => { - log2.info("Spector capture stopped after 2 seconds")(); - spector?.stopCapture(); - }); - } - return spector; -} - -// node_modules/@luma.gl/webgl/dist/context/debug/webgl-developer-tools.js -var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js"; -function getWebGLContextData(gl) { - gl.luma = gl.luma || {}; - return gl.luma; -} -async function loadWebGLDeveloperTools() { - if (isBrowser2() && !globalThis.WebGLDebugUtils) { - globalThis.global = globalThis.global || globalThis; - globalThis.global.module = {}; - await loadScript(WEBGL_DEBUG_CDN_URL); - } -} -function makeDebugContext(gl, props = {}) { - if (!gl) { - return null; - } - return props.debug ? getDebugContext(gl, props) : getRealContext(gl); -} -function getRealContext(gl) { - const data = getWebGLContextData(gl); - return data.realContext ? data.realContext : gl; -} -function getDebugContext(gl, props) { - if (!globalThis.WebGLDebugUtils) { - log2.warn("webgl-debug not loaded")(); - return gl; - } - const data = getWebGLContextData(gl); - if (data.debugContext) { - return data.debugContext; - } - globalThis.WebGLDebugUtils.init({ ...GLEnum, ...gl }); - const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props)); - for (const key in GLEnum) { - if (!(key in glDebug) && typeof GLEnum[key] === "number") { - glDebug[key] = GLEnum[key]; - } - } - class WebGLDebugContext { - } - Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl)); - Object.setPrototypeOf(WebGLDebugContext, glDebug); - const debugContext = Object.create(WebGLDebugContext); - data.realContext = gl; - data.debugContext = debugContext; - debugContext.debug = true; - return debugContext; -} -function getFunctionString(functionName, functionArgs) { - functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg); - let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs); - args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`; - return `gl.${functionName}(${args})`; -} -function onGLError(props, err, functionName, args) { - args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg); - const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err); - const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args); - const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`; - log2.error(message2)(); - debugger; - if (props.throwOnError) { - throw new Error(message2); - } -} -function onValidateGLFunc(props, functionName, functionArgs) { - let functionString = ""; - if (log2.level >= 1) { - functionString = getFunctionString(functionName, functionArgs); - log2.log(1, functionString)(); - } - if (props.break && props.break.length > 0) { - functionString = functionString || getFunctionString(functionName, functionArgs); - const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1); - if (isBreakpoint) { - debugger; - } - } - for (const arg of functionArgs) { - if (arg === void 0) { - functionString = functionString || getFunctionString(functionName, functionArgs); - if (props.throwOnError) { - throw new Error(`Undefined argument: ${functionString}`); - } else { - log2.error(`Undefined argument: ${functionString}`)(); - debugger; - } - } - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/helpers/parse-shader-compiler-log.js -function parseShaderCompilerLog(errLog) { - const lines = errLog.split(/\r?\n/); - const messages = []; - for (const line of lines) { - if (line.length <= 1) { - continue; - } - const segments = line.split(":"); - if (segments.length === 2) { - const [messageType2, message2] = segments; - messages.push({ - message: message2.trim(), - type: getMessageType(messageType2), - lineNum: 0, - linePos: 0 - }); - continue; - } - const [messageType, linePosition, lineNumber, ...rest] = segments; - let lineNum = parseInt(lineNumber, 10); - if (isNaN(lineNum)) { - lineNum = 0; - } - let linePos = parseInt(linePosition, 10); - if (isNaN(linePos)) { - linePos = 0; - } - messages.push({ - message: rest.join(":").trim(), - type: getMessageType(messageType), - lineNum, - linePos - // TODO - }); - } - return messages; -} -function getMessageType(messageType) { - const MESSAGE_TYPES = ["warning", "error", "info"]; - const lowerCaseType = messageType.toLowerCase(); - return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info"; -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shader.js -var WEBGLShader = class extends Shader { - device; - handle; - constructor(device, props) { - super(device, props); - this.device = device; - switch (this.props.stage) { - case "vertex": - this.handle = this.props.handle || this.device.gl.createShader(35633); - break; - case "fragment": - this.handle = this.props.handle || this.device.gl.createShader(35632); - break; - default: - throw new Error(this.props.stage); - } - this._compile(this.source); - } - destroy() { - if (this.handle) { - this.removeStats(); - this.device.gl.deleteShader(this.handle); - this.destroyed = true; - } - } - async getCompilationInfo() { - await this._waitForCompilationComplete(); - return this.getCompilationInfoSync(); - } - getCompilationInfoSync() { - const log4 = this.device.gl.getShaderInfoLog(this.handle); - return parseShaderCompilerLog(log4); - } - getTranslatedSource() { - const extensions = this.device.getExtension("WEBGL_debug_shaders"); - const ext = extensions.WEBGL_debug_shaders; - return ext?.getTranslatedShaderSource(this.handle); - } - // PRIVATE METHODS - /** Compile a shader and get compilation status */ - async _compile(source) { - const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100 -${source2}`; - source = addGLSLVersion(source); - const { gl } = this.device; - gl.shaderSource(this.handle, source); - gl.compileShader(this.handle); - if (log2.level === 0) { - this.compilationStatus = "pending"; - return; - } - if (!this.device.features.has("compilation-status-async-webgl")) { - this._getCompilationStatus(); - this.debugShader(); - if (this.compilationStatus === "error") { - throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`); - } - return; - } - log2.once(1, "Shader compilation is asynchronous")(); - await this._waitForCompilationComplete(); - log2.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)(); - this._getCompilationStatus(); - this.debugShader(); - } - /** Use KHR_parallel_shader_compile extension if available */ - async _waitForCompilationComplete() { - const waitMs = async (ms) => await new Promise((resolve2) => setTimeout(resolve2, ms)); - const DELAY_MS = 10; - if (!this.device.features.has("compilation-status-async-webgl")) { - await waitMs(DELAY_MS); - return; - } - const { gl } = this.device; - for (; ; ) { - const complete = gl.getShaderParameter(this.handle, 37297); - if (complete) { - return; - } - await waitMs(DELAY_MS); - } - } - /** - * Get the shader compilation status - * TODO - Load log even when no error reported, to catch warnings? - * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings - */ - _getCompilationStatus() { - this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 35713) ? "success" : "error"; - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pass.js -var GL_DEPTH_BUFFER_BIT = 256; -var GL_STENCIL_BUFFER_BIT = 1024; -var GL_COLOR_BUFFER_BIT = 16384; -var GL_COLOR = 6144; -var COLOR_CHANNELS = [1, 2, 4, 8]; -var WEBGLRenderPass = class extends RenderPass { - device; - /** Parameters that should be applied before each draw call */ - glParameters; - constructor(device, props) { - super(device, props); - this.device = device; - pushContextState(this.device.gl); - this.setParameters(this.props.parameters); - this.clear(); - } - end() { - popContextState(this.device.gl); - } - pushDebugGroup(groupLabel) { - } - popDebugGroup() { - } - insertDebugMarker(markerLabel) { - } - // beginOcclusionQuery(queryIndex: number): void; - // endOcclusionQuery(): void; - // executeBundles(bundles: Iterable): void; - /** - * Maps RenderPass parameters to GL parameters - */ - setParameters(parameters = {}) { - const glParameters = { ...this.glParameters }; - if (this.props.framebuffer) { - glParameters.framebuffer = this.props.framebuffer; - } - if (this.props.depthReadOnly) { - glParameters.depthMask = !this.props.depthReadOnly; - } - glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1; - glParameters[35977] = this.props.discard; - if (parameters.viewport) { - if (parameters.viewport.length >= 6) { - glParameters.viewport = parameters.viewport.slice(0, 4); - glParameters.depthRange = [parameters.viewport[4], parameters.viewport[5]]; - } else { - glParameters.viewport = parameters.viewport; - } - } - if (parameters.scissorRect) { - glParameters.scissorTest = true; - glParameters.scissor = parameters.scissorRect; - } - if (parameters.blendConstant) { - glParameters.blendColor = parameters.blendConstant; - } - if (parameters.stencilReference) { - console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL"); - parameters[2967] = parameters.stencilReference; - } - if (parameters.colorMask) { - glParameters.colorMask = COLOR_CHANNELS.map((channel) => Boolean(channel & parameters.colorMask)); - } - this.glParameters = glParameters; - setGLParameters(this.device.gl, glParameters); - } - beginOcclusionQuery(queryIndex) { - const webglQuerySet = this.props.occlusionQuerySet; - webglQuerySet?.beginOcclusionQuery(); - } - endOcclusionQuery() { - const webglQuerySet = this.props.occlusionQuerySet; - webglQuerySet?.endOcclusionQuery(); - } - // PRIVATE - /** - * Optionally clears depth, color and stencil buffers based on parameters - */ - clear() { - const glParameters = { ...this.glParameters }; - let clearMask = 0; - if (this.props.clearColor !== false) { - clearMask |= GL_COLOR_BUFFER_BIT; - glParameters.clearColor = this.props.clearColor; - } - if (this.props.clearDepth !== false) { - clearMask |= GL_DEPTH_BUFFER_BIT; - glParameters.clearDepth = this.props.clearDepth; - } - if (this.props.clearStencil !== false) { - clearMask |= GL_STENCIL_BUFFER_BIT; - glParameters.clearStencil = this.props.clearStencil; - } - if (clearMask !== 0) { - withGLParameters(this.device.gl, glParameters, () => { - this.device.gl.clear(clearMask); - }); - } - } - /** - * WebGL2 - clear a specific color buffer - */ - clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) { - withGLParameters(this.device.gl, { framebuffer: this.props.framebuffer }, () => { - switch (value.constructor) { - case Int32Array: - this.device.gl.clearBufferiv(GL_COLOR, drawBuffer, value); - break; - case Uint32Array: - this.device.gl.clearBufferuiv(GL_COLOR, drawBuffer, value); - break; - case Float32Array: - default: - this.device.gl.clearBufferfv(GL_COLOR, drawBuffer, value); - break; - } - }); - } -}; - -// node_modules/@luma.gl/webgl/dist/classic/typed-array-utils.js -var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array"; -function getGLTypeFromTypedArray(arrayOrType) { - const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; - switch (type) { - case Float32Array: - return 5126; - case Uint16Array: - return 5123; - case Uint32Array: - return 5125; - case Uint8Array: - return 5121; - case Uint8ClampedArray: - return 5121; - case Int8Array: - return 5120; - case Int16Array: - return 5122; - case Int32Array: - return 5124; - default: - throw new Error(ERR_TYPE_DEDUCTION); - } -} -function getTypedArrayFromGLType(glType, options) { - const { clamped = true } = options || {}; - switch (glType) { - case 5126: - return Float32Array; - case 5123: - case 33635: - case 32819: - case 32820: - return Uint16Array; - case 5125: - return Uint32Array; - case 5121: - return clamped ? Uint8ClampedArray : Uint8Array; - case 5120: - return Int8Array; - case 5122: - return Int16Array; - case 5124: - return Int32Array; - default: - throw new Error("Failed to deduce typed array type from GL constant"); - } -} - -// node_modules/@luma.gl/webgl/dist/classic/accessor.js -var DEFAULT_ACCESSOR_VALUES = { - offset: 0, - stride: 0, - type: 5126, - size: 1, - divisor: 0, - normalized: false, - integer: false -}; -var PROP_CHECKS = { - deprecatedProps: { - instanced: "divisor", - isInstanced: "divisor" - } -}; -var Accessor = class _Accessor { - offset; - stride; - type; - size; - divisor; - normalized; - integer; - buffer; - index; - static getBytesPerElement(accessor) { - const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126); - return ArrayType2.BYTES_PER_ELEMENT; - } - static getBytesPerVertex(accessor) { - assert6(accessor.size); - const ArrayType2 = getTypedArrayFromGLType(accessor.type || 5126); - return ArrayType2.BYTES_PER_ELEMENT * accessor.size; - } - // Combines (merges) a list of accessors. On top of default values - // Usually [programAccessor, bufferAccessor, appAccessor] - // All props will be set in the returned object. - // TODO check for conflicts between values in the supplied accessors - static resolve(...accessors) { - return new _Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); - } - constructor(...accessors) { - accessors.forEach((accessor) => this._assign(accessor)); - Object.freeze(this); - } - toString() { - return JSON.stringify(this); - } - // ACCESSORS - // TODO - remove> - get BYTES_PER_ELEMENT() { - return _Accessor.getBytesPerElement(this); - } - get BYTES_PER_VERTEX() { - return _Accessor.getBytesPerVertex(this); - } - // PRIVATE - // eslint-disable-next-line complexity, max-statements - _assign(props = {}) { - props = checkProps("Accessor", props, PROP_CHECKS); - if (props.type !== void 0) { - this.type = props.type; - if (props.type === 5124 || props.type === 5125) { - this.integer = true; - } - } - if (props.size !== void 0) { - this.size = props.size; - } - if (props.offset !== void 0) { - this.offset = props.offset; - } - if (props.stride !== void 0) { - this.stride = props.stride; - } - if (props.normalize !== void 0) { - this.normalized = props.normalize; - } - if (props.normalized !== void 0) { - this.normalized = props.normalized; - } - if (props.integer !== void 0) { - this.integer = props.integer; - } - if (props.divisor !== void 0) { - this.divisor = props.divisor; - } - if (props.buffer !== void 0) { - this.buffer = props.buffer; - } - if (props.index !== void 0) { - if (typeof props.index === "boolean") { - this.index = props.index ? 1 : 0; - } else { - this.index = props.index; - } - } - if (props.instanced !== void 0) { - this.divisor = props.instanced ? 1 : 0; - } - if (props.isInstanced !== void 0) { - this.divisor = props.isInstanced ? 1 : 0; - } - if (this.offset === void 0) - delete this.offset; - if (this.stride === void 0) - delete this.stride; - if (this.type === void 0) - delete this.type; - if (this.size === void 0) - delete this.size; - if (this.divisor === void 0) - delete this.divisor; - if (this.normalized === void 0) - delete this.normalized; - if (this.integer === void 0) - delete this.integer; - if (this.buffer === void 0) - delete this.buffer; - if (this.index === void 0) - delete this.index; - return this; - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/helpers/decode-webgl-types.js -function isSamplerUniform(type) { - return SAMPLER_TYPES.includes(type); -} -var SAMPLER_TYPES = [ - 35678, - 35680, - 35679, - 35682, - 36289, - 36292, - 36293, - 36298, - 36299, - 36300, - 36303, - 36306, - 36307, - 36308, - 36311 -]; -var COMPOSITE_GL_TYPES = { - [5126]: [5126, 1, "float", "f32", "float32"], - [35664]: [5126, 2, "vec2", "vec2", "float32x2"], - [35665]: [5126, 3, "vec3", "vec3", "float32x3"], - [35666]: [5126, 4, "vec4", "vec4", "float32x4"], - [5124]: [5124, 1, "int", "i32", "sint32"], - [35667]: [5124, 2, "ivec2", "vec2", "sint32x2"], - [35668]: [5124, 3, "ivec3", "vec3", "sint32x3"], - [35669]: [5124, 4, "ivec4", "vec4", "sint32x4"], - [5125]: [5125, 1, "uint", "u32", "uint32"], - [36294]: [5125, 2, "uvec2", "vec2", "uint32x2"], - [36295]: [5125, 3, "uvec3", "vec3", "uint32x3"], - [36296]: [5125, 4, "uvec4", "vec4", "uint32x4"], - [35670]: [5126, 1, "bool", "f32", "float32"], - [35671]: [5126, 2, "bvec2", "vec2", "float32x2"], - [35672]: [5126, 3, "bvec3", "vec3", "float32x3"], - [35673]: [5126, 4, "bvec4", "vec4", "float32x4"], - // TODO - are sizes/components below correct? - [35674]: [5126, 8, "mat2", "mat2x2"], - // 4 - [35685]: [5126, 8, "mat2x3", "mat2x3"], - // 6 - [35686]: [5126, 8, "mat2x4", "mat2x4"], - // 8 - [35687]: [5126, 12, "mat3x2", "mat3x2"], - // 6 - [35675]: [5126, 12, "mat3", "mat3x3"], - // 9 - [35688]: [5126, 12, "mat3x4", "mat3x4"], - // 12 - [35689]: [5126, 16, "mat4x2", "mat4x2"], - // 8 - [35690]: [5126, 16, "mat4x3", "mat4x3"], - // 12 - [35676]: [5126, 16, "mat4", "mat4x4"] - // 16 -}; -function decodeGLUniformType(glUniformType) { - const typeAndSize = COMPOSITE_GL_TYPES[glUniformType]; - if (!typeAndSize) { - throw new Error("uniform"); - } - const [glType, components, , format] = typeAndSize; - return { format, components, glType }; -} -function decodeGLAttributeType(glAttributeType) { - const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType]; - if (!typeAndSize) { - throw new Error("attribute"); - } - const [, components, , shaderType, vertexFormat] = typeAndSize; - const attributeType = shaderType; - return { attributeType, vertexFormat, components }; -} - -// node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout.js -function getShaderLayout(gl, program) { - const shaderLayout = { - attributes: [], - bindings: [] - }; - shaderLayout.attributes = readAttributeDeclarations(gl, program); - const uniformBlocks = readUniformBlocks(gl, program); - for (const uniformBlock of uniformBlocks) { - const uniforms2 = uniformBlock.uniforms.map((uniform) => ({ - name: uniform.name, - format: uniform.format, - byteOffset: uniform.byteOffset, - byteStride: uniform.byteStride, - arrayLength: uniform.arrayLength - })); - shaderLayout.bindings.push({ - type: "uniform", - name: uniformBlock.name, - location: uniformBlock.location, - visibility: (uniformBlock.vertex ? 1 : 0) & (uniformBlock.fragment ? 2 : 0), - minBindingSize: uniformBlock.byteLength, - uniforms: uniforms2 - }); - } - const uniforms = readUniformBindings(gl, program); - let textureUnit = 0; - for (const uniform of uniforms) { - if (isSamplerUniform(uniform.type)) { - const { viewDimension, sampleType } = getSamplerInfo(uniform.type); - shaderLayout.bindings.push({ - type: "texture", - name: uniform.name, - location: textureUnit, - viewDimension, - sampleType - }); - uniform.textureUnit = textureUnit; - textureUnit += 1; - } - } - if (uniforms.length) { - shaderLayout.uniforms = uniforms; - } - const varyings = readVaryings(gl, program); - if (varyings?.length) { - shaderLayout.varyings = varyings; - } - return shaderLayout; -} -function readAttributeDeclarations(gl, program) { - const attributes = []; - const count2 = gl.getProgramParameter(program, 35721); - for (let index2 = 0; index2 < count2; index2++) { - const activeInfo = gl.getActiveAttrib(program, index2); - if (!activeInfo) { - throw new Error("activeInfo"); - } - const { - name: name2, - type: compositeType - /* , size*/ - } = activeInfo; - const location = gl.getAttribLocation(program, name2); - if (location >= 0) { - const { attributeType } = decodeGLAttributeType(compositeType); - const stepMode = /instance/i.test(name2) ? "instance" : "vertex"; - attributes.push({ - name: name2, - location, - stepMode, - type: attributeType - // size - for arrays, size is the number of elements in the array - }); - } - } - attributes.sort((a, b) => a.location - b.location); - return attributes; -} -function readVaryings(gl, program) { - const varyings = []; - const count2 = gl.getProgramParameter(program, 35971); - for (let location = 0; location < count2; location++) { - const activeInfo = gl.getTransformFeedbackVarying(program, location); - if (!activeInfo) { - throw new Error("activeInfo"); - } - const { name: name2, type: compositeType, size } = activeInfo; - const { glType, components } = decodeGLUniformType(compositeType); - const accessor = new Accessor({ type: glType, size: size * components }); - const varying = { location, name: name2, accessor }; - varyings.push(varying); - } - varyings.sort((a, b) => a.location - b.location); - return varyings; -} -function readUniformBindings(gl, program) { - const uniforms = []; - const uniformCount = gl.getProgramParameter(program, 35718); - for (let i = 0; i < uniformCount; i++) { - const activeInfo = gl.getActiveUniform(program, i); - if (!activeInfo) { - throw new Error("activeInfo"); - } - const { name: rawName, size, type } = activeInfo; - const { name: name2, isArray: isArray5 } = parseUniformName(rawName); - let webglLocation = gl.getUniformLocation(program, name2); - const uniformInfo = { - // WebGL locations are uniquely typed but just numbers - location: webglLocation, - name: name2, - size, - type, - isArray: isArray5 - }; - uniforms.push(uniformInfo); - if (uniformInfo.size > 1) { - for (let j = 0; j < uniformInfo.size; j++) { - const elementName = `${name2}[${j}]`; - webglLocation = gl.getUniformLocation(program, elementName); - const arrayElementUniformInfo = { - ...uniformInfo, - name: elementName, - location: webglLocation - }; - uniforms.push(arrayElementUniformInfo); - } - } - } - return uniforms; -} -function readUniformBlocks(gl, program) { - const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname); - const uniformBlocks = []; - const blockCount = gl.getProgramParameter(program, 35382); - for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) { - const blockInfo = { - name: gl.getActiveUniformBlockName(program, blockIndex) || "", - location: getBlockParameter(blockIndex, 35391), - byteLength: getBlockParameter(blockIndex, 35392), - vertex: getBlockParameter(blockIndex, 35396), - fragment: getBlockParameter(blockIndex, 35398), - uniformCount: getBlockParameter(blockIndex, 35394), - uniforms: [] - }; - const uniformIndices = getBlockParameter(blockIndex, 35395) || []; - const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383); - const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384); - const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387); - const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388); - for (let i = 0; i < blockInfo.uniformCount; ++i) { - const activeInfo = gl.getActiveUniform(program, uniformIndices[i]); - if (!activeInfo) { - throw new Error("activeInfo"); - } - blockInfo.uniforms.push({ - name: activeInfo.name, - format: decodeGLUniformType(uniformType[i]).format, - type: uniformType[i], - arrayLength: uniformArrayLength[i], - byteOffset: uniformOffset[i], - byteStride: uniformStride[i] - // matrixStride: uniformStride[i], - // rowMajor: uniformRowMajor[i] - }); - } - uniformBlocks.push(blockInfo); - } - uniformBlocks.sort((a, b) => a.location - b.location); - return uniformBlocks; -} -var SAMPLER_UNIFORMS_GL_TO_GPU = { - [35678]: ["2d", "float"], - [35680]: ["cube", "float"], - [35679]: ["3d", "float"], - [35682]: ["3d", "depth"], - [36289]: ["2d-array", "float"], - [36292]: ["2d-array", "depth"], - [36293]: ["cube", "float"], - [36298]: ["2d", "sint"], - [36299]: ["3d", "sint"], - [36300]: ["cube", "sint"], - [36303]: ["2d-array", "uint"], - [36306]: ["2d", "uint"], - [36307]: ["3d", "uint"], - [36308]: ["cube", "uint"], - [36311]: ["2d-array", "uint"] -}; -function getSamplerInfo(type) { - const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type]; - if (!sampler) { - throw new Error("sampler"); - } - const [viewDimension, sampleType] = sampler; - return { viewDimension, sampleType }; -} -function parseUniformName(name2) { - if (name2[name2.length - 1] !== "]") { - return { - name: name2, - length: 1, - isArray: false - }; - } - const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/; - const matches4 = UNIFORM_NAME_REGEXP.exec(name2); - if (!matches4 || matches4.length < 2) { - throw new Error(`Failed to parse GLSL uniform name ${name2}`); - } - return { - name: matches4[1], - length: matches4[2] ? 1 : 0, - isArray: Boolean(matches4[2]) - }; -} - -// node_modules/@luma.gl/webgl/dist/adapter/helpers/set-uniform.js -function setUniform(gl, location, type, value) { - const gl2 = gl; - let uniformValue = value; - if (uniformValue === true) { - uniformValue = 1; - } - if (uniformValue === false) { - uniformValue = 0; - } - const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue; - switch (type) { - case 35678: - case 35680: - case 35679: - case 35682: - case 36289: - case 36292: - case 36293: - case 36298: - case 36299: - case 36300: - case 36303: - case 36306: - case 36307: - case 36308: - case 36311: - if (typeof value !== "number") { - throw new Error("samplers must be set to integers"); - } - return gl.uniform1i(location, value); - case 5126: - return gl.uniform1fv(location, arrayValue); - case 35664: - return gl.uniform2fv(location, arrayValue); - case 35665: - return gl.uniform3fv(location, arrayValue); - case 35666: - return gl.uniform4fv(location, arrayValue); - case 5124: - return gl.uniform1iv(location, arrayValue); - case 35667: - return gl.uniform2iv(location, arrayValue); - case 35668: - return gl.uniform3iv(location, arrayValue); - case 35669: - return gl.uniform4iv(location, arrayValue); - case 35670: - return gl.uniform1iv(location, arrayValue); - case 35671: - return gl.uniform2iv(location, arrayValue); - case 35672: - return gl.uniform3iv(location, arrayValue); - case 35673: - return gl.uniform4iv(location, arrayValue); - case 5125: - return gl2.uniform1uiv(location, arrayValue, 1); - case 36294: - return gl2.uniform2uiv(location, arrayValue, 2); - case 36295: - return gl2.uniform3uiv(location, arrayValue, 3); - case 36296: - return gl2.uniform4uiv(location, arrayValue, 4); - case 35674: - return gl.uniformMatrix2fv(location, false, arrayValue); - case 35675: - return gl.uniformMatrix3fv(location, false, arrayValue); - case 35676: - return gl.uniformMatrix4fv(location, false, arrayValue); - case 35685: - return gl2.uniformMatrix2x3fv(location, false, arrayValue); - case 35686: - return gl2.uniformMatrix2x4fv(location, false, arrayValue); - case 35687: - return gl2.uniformMatrix3x2fv(location, false, arrayValue); - case 35688: - return gl2.uniformMatrix3x4fv(location, false, arrayValue); - case 35689: - return gl2.uniformMatrix4x2fv(location, false, arrayValue); - case 35690: - return gl2.uniformMatrix4x3fv(location, false, arrayValue); - } - throw new Error("Illegal uniform"); -} - -// node_modules/@luma.gl/webgl/dist/adapter/helpers/webgl-topology-utils.js -function getGLDrawMode(topology) { - switch (topology) { - case "point-list": - return 0; - case "line-list": - return 1; - case "line-strip": - return 3; - case "line-loop-webgl": - return 2; - case "triangle-list": - return 4; - case "triangle-strip": - return 5; - case "triangle-fan-webgl": - return 6; - default: - throw new Error(topology); - } -} -function getGLPrimitive(topology) { - switch (topology) { - case "point-list": - return 0; - case "line-list": - return 1; - case "line-strip": - return 1; - case "line-loop-webgl": - return 1; - case "triangle-list": - return 4; - case "triangle-strip": - return 4; - case "triangle-fan-webgl": - return 4; - default: - throw new Error(topology); - } -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js -var LOG_PROGRAM_PERF_PRIORITY = 4; -var WEBGLRenderPipeline = class extends RenderPipeline { - /** The WebGL device that created this render pipeline */ - device; - /** Handle to underlying WebGL program */ - handle; - /** vertex shader */ - vs; - /** fragment shader */ - fs; - /** The layout extracted from shader by WebGL introspection APIs */ - introspectedLayout; - /** Uniforms set on this model */ - uniforms = {}; - /** Bindings set on this model */ - bindings = {}; - /** WebGL varyings */ - varyings = null; - _uniformCount = 0; - _uniformSetters = {}; - // TODO are these used? - constructor(device, props) { - super(device, props); - this.device = device; - this.handle = this.props.handle || this.device.gl.createProgram(); - this.device.setSpectorMetadata(this.handle, { id: this.props.id }); - this.vs = cast(props.vs); - this.fs = cast(props.fs); - const { varyings, bufferMode = 35981 } = props; - if (varyings && varyings.length > 0) { - this.varyings = varyings; - this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode); - } - this._linkShaders(); - log2.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)(); - this.introspectedLayout = getShaderLayout(this.device.gl, this.handle); - log2.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)(); - this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout); - switch (this.props.topology) { - case "triangle-fan-webgl": - case "line-loop-webgl": - log2.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`); - break; - default: - } - } - destroy() { - if (this.handle) { - this.device.gl.deleteProgram(this.handle); - this.destroyed = true; - } - } - /** - * Bindings include: textures, samplers and uniform buffers - * @todo needed for portable model - */ - setBindings(bindings, options) { - for (const [name2, value] of Object.entries(bindings)) { - const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name2) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name2}Uniforms`); - if (!binding) { - const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", "); - if (!options?.disableWarnings) { - log2.warn(`Unknown binding "${name2}" in render pipeline "${this.id}", expected one of ${validBindings}`)(); - } - continue; - } - if (!value) { - log2.warn(`Unsetting binding "${name2}" in render pipeline "${this.id}"`)(); - } - switch (binding.type) { - case "uniform": - if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) { - throw new Error("buffer value"); - } - break; - case "texture": - if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) { - throw new Error("texture value"); - } - break; - case "sampler": - log2.warn(`Ignoring sampler ${name2}`)(); - break; - default: - throw new Error(binding.type); - } - this.bindings[name2] = value; - } - } - /** @todo needed for portable model - * @note The WebGL API is offers many ways to draw things - * This function unifies those ways into a single call using common parameters with sane defaults - */ - draw(options) { - const { - renderPass, - parameters = this.props.parameters, - topology = this.props.topology, - vertexArray, - vertexCount, - // indexCount, - instanceCount, - isInstanced = false, - firstVertex = 0, - // firstIndex, - // firstInstance, - // baseVertex, - transformFeedback - } = options; - const glDrawMode = getGLDrawMode(topology); - const isIndexed = Boolean(vertexArray.indexBuffer); - const glIndexType = vertexArray.indexBuffer?.glIndexType; - if (this.linkStatus !== "success") { - log2.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)(); - return false; - } - if (!this._areTexturesRenderable() || vertexCount === 0) { - log2.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)(); - return false; - } - if (vertexCount === 0) { - log2.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)(); - return true; - } - this.device.gl.useProgram(this.handle); - vertexArray.bindBeforeRender(renderPass); - if (transformFeedback) { - transformFeedback.begin(this.props.topology); - } - this._applyBindings(); - this._applyUniforms(); - const webglRenderPass = renderPass; - withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => { - if (isIndexed && isInstanced) { - this.device.gl.drawElementsInstanced( - glDrawMode, - vertexCount || 0, - // indexCount? - glIndexType, - firstVertex, - instanceCount || 0 - ); - } else if (isIndexed) { - this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex); - } else if (isInstanced) { - this.device.gl.drawArraysInstanced(glDrawMode, firstVertex, vertexCount || 0, instanceCount || 0); - } else { - this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0); - } - if (transformFeedback) { - transformFeedback.end(); - } - }); - vertexArray.unbindAfterRender(renderPass); - return true; - } - // DEPRECATED METHODS - setUniformsWebGL(uniforms) { - const { bindings } = splitUniformsAndBindings(uniforms); - Object.keys(bindings).forEach((name2) => { - log2.warn(`Unsupported value "${JSON.stringify(bindings[name2])}" used in setUniforms() for key ${name2}. Use setBindings() instead?`)(); - }); - Object.assign(this.uniforms, uniforms); - } - // PRIVATE METHODS - // setAttributes(attributes: Record): void {} - // setBindings(bindings: Record): void {} - async _linkShaders() { - const { gl } = this.device; - gl.attachShader(this.handle, this.vs.handle); - gl.attachShader(this.handle, this.fs.handle); - log2.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)(); - gl.linkProgram(this.handle); - log2.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)(); - if (log2.level === 0) { - } - if (!this.device.features.has("compilation-status-async-webgl")) { - const status2 = this._getLinkStatus(); - this._reportLinkStatus(status2); - return; - } - log2.once(1, "RenderPipeline linking is asynchronous")(); - await this._waitForLinkComplete(); - log2.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)(); - const status = this._getLinkStatus(); - this._reportLinkStatus(status); - } - /** Report link status. First, check for shader compilation failures if linking fails */ - _reportLinkStatus(status) { - switch (status) { - case "success": - return; - default: - if (this.vs.compilationStatus === "error") { - this.vs.debugShader(); - throw new Error(`Error during compilation of shader ${this.vs.id}`); - } - if (this.fs?.compilationStatus === "error") { - this.fs.debugShader(); - throw new Error(`Error during compilation of shader ${this.fs.id}`); - } - throw new Error(`Error during ${status}: ${this.device.gl.getProgramInfoLog(this.handle)}`); - } - } - /** - * Get the shader compilation status - * TODO - Load log even when no error reported, to catch warnings? - * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings - */ - _getLinkStatus() { - const { gl } = this.device; - const linked = gl.getProgramParameter(this.handle, 35714); - if (!linked) { - this.linkStatus = "error"; - return "linking"; - } - gl.validateProgram(this.handle); - const validated = gl.getProgramParameter(this.handle, 35715); - if (!validated) { - this.linkStatus = "error"; - return "validation"; - } - this.linkStatus = "success"; - return "success"; - } - /** Use KHR_parallel_shader_compile extension if available */ - async _waitForLinkComplete() { - const waitMs = async (ms) => await new Promise((resolve2) => setTimeout(resolve2, ms)); - const DELAY_MS = 10; - if (!this.device.features.has("compilation-status-async-webgl")) { - await waitMs(DELAY_MS); - return; - } - const { gl } = this.device; - for (; ; ) { - const complete = gl.getProgramParameter(this.handle, 37297); - if (complete) { - return; - } - await waitMs(DELAY_MS); - } - } - /** - * Checks if all texture-values uniforms are renderable (i.e. loaded) - * Update a texture if needed (e.g. from video) - * Note: This is currently done before every draw call - */ - _areTexturesRenderable() { - let texturesRenderable = true; - for (const [, texture] of Object.entries(this.bindings)) { - if (texture instanceof WEBGLTexture) { - texture.update(); - texturesRenderable = texturesRenderable && texture.loaded; - } - } - return texturesRenderable; - } - /** Apply any bindings (before each draw call) */ - _applyBindings() { - if (this.linkStatus !== "success") { - return; - } - const { gl } = this.device; - gl.useProgram(this.handle); - let textureUnit = 0; - let uniformBufferIndex = 0; - for (const binding of this.shaderLayout.bindings) { - const value = this.bindings[binding.name] || this.bindings[binding.name.replace(/Uniforms$/, "")]; - if (!value) { - throw new Error(`No value for binding ${binding.name} in ${this.id}`); - } - switch (binding.type) { - case "uniform": - const { name: name2 } = binding; - const location = gl.getUniformBlockIndex(this.handle, name2); - if (location === 4294967295) { - throw new Error(`Invalid uniform block name ${name2}`); - } - gl.uniformBlockBinding(this.handle, uniformBufferIndex, location); - if (value instanceof WEBGLBuffer) { - gl.bindBufferBase(35345, uniformBufferIndex, value.handle); - } else { - gl.bindBufferRange( - 35345, - uniformBufferIndex, - // @ts-expect-error - value.buffer.handle, - // @ts-expect-error - value.offset || 0, - // @ts-expect-error - value.size || value.buffer.byteLength - value.offset - ); - } - uniformBufferIndex += 1; - break; - case "texture": - if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) { - throw new Error("texture"); - } - let texture; - if (value instanceof WEBGLTextureView) { - texture = value.texture; - } else if (value instanceof WEBGLTexture) { - texture = value; - } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) { - log2.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")(); - texture = value.colorAttachments[0].texture; - } else { - throw new Error("No texture"); - } - gl.activeTexture(33984 + textureUnit); - gl.bindTexture(texture.target, texture.handle); - textureUnit += 1; - break; - case "sampler": - break; - case "storage": - case "read-only-storage": - throw new Error(`binding type '${binding.type}' not supported in WebGL`); - } - } - } - /** - * Due to program sharing, uniforms need to be reset before every draw call - * (though caching will avoid redundant WebGL calls) - */ - _applyUniforms() { - for (const uniformLayout of this.shaderLayout.uniforms || []) { - const { name: name2, location, type, textureUnit } = uniformLayout; - const value = this.uniforms[name2] ?? textureUnit; - if (value !== void 0) { - setUniform(this.device.gl, location, type, value); - } - } - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-buffer.js -function cast2(value) { - return value; -} -var WEBGLCommandBuffer = class extends CommandBuffer { - device; - commands = []; - constructor(device) { - super(device, {}); - this.device = device; - } - submitCommands(commands = this.commands) { - for (const command of commands) { - switch (command.name) { - case "copy-buffer-to-buffer": - _copyBufferToBuffer(this.device, command.options); - break; - case "copy-buffer-to-texture": - _copyBufferToTexture(this.device, command.options); - break; - case "copy-texture-to-buffer": - _copyTextureToBuffer(this.device, command.options); - break; - case "copy-texture-to-texture": - _copyTextureToTexture(this.device, command.options); - break; - } - } - } -}; -function _copyBufferToBuffer(device, options) { - const source = cast2(options.source); - const destination = cast2(options.destination); - device.gl.bindBuffer(36662, source.handle); - device.gl.bindBuffer(36663, destination.handle); - device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size); - device.gl.bindBuffer(36662, null); - device.gl.bindBuffer(36663, null); -} -function _copyBufferToTexture(device, options) { - throw new Error("Not implemented"); -} -function _copyTextureToBuffer(device, options) { - const { - /** Texture to copy to/from. */ - source, - /** Mip-map level of the texture to copy to/from. (Default 0) */ - mipLevel = 0, - /** Defines which aspects of the texture to copy to/from. */ - aspect = "all", - /** Width to copy */ - width = options.source.width, - /** Height to copy */ - height = options.source.height, - depthOrArrayLayers = 0, - /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */ - origin = [0, 0], - /** Destination buffer */ - destination, - /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */ - byteOffset = 0, - /** - * The stride, in bytes, between the beginning of each block row and the subsequent block row. - * Required if there are multiple block rows (i.e. the copy height or depth is more than one block). - */ - bytesPerRow, - /** - * Number of block rows per single image of the texture. - * rowsPerImage × bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image. - * Required if there are multiple images (i.e. the copy depth is more than one). - */ - rowsPerImage - } = options; - if (aspect !== "all") { - throw new Error("not supported"); - } - if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) { - throw new Error("not implemented"); - } - const { framebuffer, destroyFramebuffer } = getFramebuffer(source); - let prevHandle; - try { - const webglBuffer = destination; - const sourceWidth = width || framebuffer.width; - const sourceHeight = height || framebuffer.height; - const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format); - const sourceFormat = sourceParams.dataFormat; - const sourceType = sourceParams.type; - device.gl.bindBuffer(35051, webglBuffer.handle); - prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle); - device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset); - } finally { - device.gl.bindBuffer(35051, null); - if (prevHandle !== void 0) { - device.gl.bindFramebuffer(36160, prevHandle); - } - if (destroyFramebuffer) { - framebuffer.destroy(); - } - } -} -function _copyTextureToTexture(device, options) { - const { - /** Texture to copy to/from. */ - source, - /** Mip-map level of the texture to copy to (Default 0) */ - destinationMipLevel = 0, - /** Defines which aspects of the texture to copy to/from. */ - // aspect = 'all', - /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy from. */ - origin = [0, 0], - /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to. */ - destinationOrigin = [0, 0], - /** Texture to copy to/from. */ - destination - /** Mip-map level of the texture to copy to/from. (Default 0) */ - // destinationMipLevel = options.mipLevel, - /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */ - // destinationOrigin = [0, 0], - /** Defines which aspects of the texture to copy to/from. */ - // destinationAspect = options.aspect, - } = options; - let { - width = options.destination.width, - height = options.destination.height - // depthOrArrayLayers = 0 - } = options; - const { framebuffer, destroyFramebuffer } = getFramebuffer(source); - const [sourceX, sourceY] = origin; - const [destinationX, destinationY, destinationZ] = destinationOrigin; - const prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle); - let texture = null; - let textureTarget; - if (destination instanceof WEBGLTexture) { - texture = destination; - width = Number.isFinite(width) ? width : texture.width; - height = Number.isFinite(height) ? height : texture.height; - texture.bind(0); - textureTarget = texture.target; - } else { - throw new Error("invalid destination"); - } - switch (textureTarget) { - case 3553: - case 34067: - device.gl.copyTexSubImage2D(textureTarget, destinationMipLevel, destinationX, destinationY, sourceX, sourceY, width, height); - break; - case 35866: - case 32879: - device.gl.copyTexSubImage3D(textureTarget, destinationMipLevel, destinationX, destinationY, destinationZ, sourceX, sourceY, width, height); - break; - default: - } - if (texture) { - texture.unbind(); - } - device.gl.bindFramebuffer(36160, prevHandle); - if (destroyFramebuffer) { - framebuffer.destroy(); - } -} -function getFramebuffer(source) { - if (source instanceof Texture) { - const { width, height, id } = source; - const framebuffer = source.device.createFramebuffer({ - id: `framebuffer-for-${id}`, - width, - height, - colorAttachments: [source] - }); - return { framebuffer, destroyFramebuffer: true }; - } - return { framebuffer: source, destroyFramebuffer: false }; -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-encoder.js -var WEBGLCommandEncoder = class extends CommandEncoder { - device; - commandBuffer; - constructor(device, props) { - super(device, props); - this.device = device; - this.commandBuffer = new WEBGLCommandBuffer(device); - } - destroy() { - } - finish() { - this.commandBuffer.submitCommands(); - } - // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder; - // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder; - // finish(options?: {id?: string}): GPUCommandBuffer; - copyBufferToBuffer(options) { - this.commandBuffer.commands.push({ name: "copy-buffer-to-buffer", options }); - } - copyBufferToTexture(options) { - this.commandBuffer.commands.push({ name: "copy-buffer-to-texture", options }); - } - copyTextureToBuffer(options) { - this.commandBuffer.commands.push({ name: "copy-texture-to-buffer", options }); - } - copyTextureToTexture(options) { - this.commandBuffer.commands.push({ name: "copy-texture-to-texture", options }); - } - pushDebugGroup(groupLabel) { - } - popDebugGroup() { - } - insertDebugMarker(markerLabel) { - } - resolveQuerySet(querySet, destination, options) { - } -}; - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-vertex-array.js -var WEBGLVertexArray = class _WEBGLVertexArray extends VertexArray { - get [Symbol.toStringTag]() { - return "VertexArray"; - } - device; - handle; - /** Attribute 0 buffer constant */ - buffer = null; - bufferValue = null; - /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */ - static isConstantAttributeZeroSupported(device) { - return getBrowser() === "Chrome"; - } - // Create a VertexArray - constructor(device, props) { - super(device, props); - this.device = device; - this.handle = this.device.gl.createVertexArray(); - } - destroy() { - super.destroy(); - if (this.buffer) { - this.buffer?.destroy(); - } - if (this.handle) { - this.device.gl.deleteVertexArray(this.handle); - this.handle = void 0; - } - } - /** - // Set (bind/unbind) an elements buffer, for indexed rendering. - // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported - * - * @param elementBuffer - */ - setIndexBuffer(indexBuffer) { - const buffer = indexBuffer; - if (buffer && buffer.glTarget !== 34963) { - throw new Error("Use .setBuffer()"); - } - this.device.gl.bindVertexArray(this.handle); - this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null); - this.indexBuffer = buffer; - this.device.gl.bindVertexArray(null); - } - /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */ - setBuffer(location, attributeBuffer) { - const buffer = attributeBuffer; - if (buffer.glTarget === 34963) { - throw new Error("Use .setIndexBuffer()"); - } - const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location); - this.device.gl.bindVertexArray(this.handle); - this.device.gl.bindBuffer(34962, buffer.handle); - if (integer) { - this.device.gl.vertexAttribIPointer(location, size, type, stride, offset); - } else { - this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset); - } - this.device.gl.bindBuffer(34962, null); - this.device.gl.enableVertexAttribArray(location); - this.device.gl.vertexAttribDivisor(location, divisor || 0); - this.attributes[location] = buffer; - this.device.gl.bindVertexArray(null); - } - /** Set a location in vertex attributes array to a constant value, disables the location */ - setConstantWebGL(location, value) { - this._enable(location, false); - this.attributes[location] = value; - } - bindBeforeRender() { - this.device.gl.bindVertexArray(this.handle); - this._applyConstantAttributes(); - } - unbindAfterRender() { - this.device.gl.bindVertexArray(null); - } - // Internal methods - /** - * Constant attributes need to be reset before every draw call - * Any attribute that is disabled in the current vertex array object - * is read from the context's global constant value for that attribute location. - * @note Constant attributes are only supported in WebGL, not in WebGPU - */ - _applyConstantAttributes() { - for (let location = 0; location < this.maxVertexAttributes; ++location) { - const constant = this.attributes[location]; - if (ArrayBuffer.isView(constant)) { - this.device.setConstantAttributeWebGL(location, constant); - } - } - } - /** - * Set a location in vertex attributes array to a buffer, enables the location, sets divisor - * @note requires vertex array to be bound - */ - // protected _setAttributeLayout(location: number): void { - // const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location); - // // WebGL2 supports *integer* data formats, i.e. GPU will see integer values - // if (integer) { - // this.device.gl.vertexAttribIPointer(location, size, type, stride, offset); - // } else { - // // Attaches ARRAY_BUFFER with specified buffer format to location - // this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset); - // } - // this.device.gl.vertexAttribDivisor(location, divisor || 0); - // } - /** Get an accessor from the */ - _getAccessor(location) { - const attributeInfo = this.attributeInfos[location]; - if (!attributeInfo) { - throw new Error(`Unknown attribute location ${location}`); - } - const glType = getGLFromVertexType(attributeInfo.bufferDataType); - return { - size: attributeInfo.bufferComponents, - type: glType, - stride: attributeInfo.byteStride, - offset: attributeInfo.byteOffset, - normalized: attributeInfo.normalized, - // it is the shader attribute declaration, not the vertex memory format, - // that determines if the data in the buffer will be treated as integers. - // - // Also note that WebGL supports assigning non-normalized integer data to floating point attributes, - // but as far as we can tell, WebGPU does not. - integer: attributeInfo.integer, - divisor: attributeInfo.stepMode === "instance" ? 1 : 0 - }; - } - /** - * Enabling an attribute location makes it reference the currently bound buffer - * Disabling an attribute location makes it reference the global constant value - * TODO - handle single values for size 1 attributes? - * TODO - convert classic arrays based on known type? - */ - _enable(location, enable2 = true) { - const canDisableAttributeZero = _WEBGLVertexArray.isConstantAttributeZeroSupported(this.device); - const canDisableAttribute = canDisableAttributeZero || location !== 0; - if (enable2 || canDisableAttribute) { - location = Number(location); - this.device.gl.bindVertexArray(this.handle); - if (enable2) { - this.device.gl.enableVertexAttribArray(location); - } else { - this.device.gl.disableVertexAttribArray(location); - } - this.device.gl.bindVertexArray(null); - } - } - /** - * Provide a means to create a buffer that is equivalent to a constant. - * NOTE: Desktop OpenGL cannot disable attribute 0. - * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled- - * this-has-significant-performance-penalty - */ - getConstantBuffer(elementCount, value) { - const constantValue = normalizeConstantArrayValue(value); - const byteLength = constantValue.byteLength * elementCount; - const length10 = constantValue.length * elementCount; - if (this.buffer && byteLength !== this.buffer.byteLength) { - throw new Error(`Buffer size is immutable, byte length ${byteLength} !== ${this.buffer.byteLength}.`); - } - let updateNeeded = !this.buffer; - this.buffer = this.buffer || this.device.createBuffer({ byteLength }); - updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue); - if (updateNeeded) { - const typedArray = getScratchArray(value.constructor, length10); - fillArray({ target: typedArray, source: constantValue, start: 0, count: length10 }); - this.buffer.write(typedArray); - this.bufferValue = value; - } - return this.buffer; - } -}; -function normalizeConstantArrayValue(arrayValue) { - if (Array.isArray(arrayValue)) { - return new Float32Array(arrayValue); - } - return arrayValue; -} -function compareConstantArrayValues(v1, v2) { - if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { - return false; - } - for (let i = 0; i < v1.length; ++i) { - if (v1[i] !== v2[i]) { - return false; - } - } - return true; -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-transform-feedback.js -var WEBGLTransformFeedback = class extends TransformFeedback { - device; - gl; - handle; - /** - * NOTE: The Model already has this information while drawing, but - * TransformFeedback currently needs it internally, to look up - * varying information outside of a draw() call. - */ - layout; - buffers = {}; - unusedBuffers = {}; - /** - * Allows us to avoid a Chrome bug where a buffer that is already bound to a - * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target. - * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346 - */ - bindOnUse = true; - _bound = false; - constructor(device, props) { - super(device, props); - this.device = device; - this.gl = device.gl; - this.handle = this.props.handle || this.gl.createTransformFeedback(); - this.layout = this.props.layout; - if (props.buffers) { - this.setBuffers(props.buffers); - } - Object.seal(this); - } - destroy() { - this.gl.deleteTransformFeedback(this.handle); - super.destroy(); - } - begin(topology = "point-list") { - this.gl.bindTransformFeedback(36386, this.handle); - if (this.bindOnUse) { - this._bindBuffers(); - } - this.gl.beginTransformFeedback(getGLPrimitive(topology)); - } - end() { - this.gl.endTransformFeedback(); - if (this.bindOnUse) { - this._unbindBuffers(); - } - this.gl.bindTransformFeedback(36386, null); - } - // SUBCLASS - setBuffers(buffers) { - this.buffers = {}; - this.unusedBuffers = {}; - this.bind(() => { - for (const bufferName in buffers) { - this.setBuffer(bufferName, buffers[bufferName]); - } - }); - } - setBuffer(locationOrName, bufferOrRange) { - const location = this._getVaryingIndex(locationOrName); - const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange); - if (location < 0) { - this.unusedBuffers[locationOrName] = buffer; - log2.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)(); - return; - } - this.buffers[location] = { buffer, byteLength, byteOffset }; - if (!this.bindOnUse) { - this._bindBuffer(location, buffer, byteOffset, byteLength); - } - } - getBuffer(locationOrName) { - if (isIndex(locationOrName)) { - return this.buffers[locationOrName] || null; - } - const location = this._getVaryingIndex(locationOrName); - return location >= 0 ? this.buffers[location] : null; - } - bind(funcOrHandle = this.handle) { - if (typeof funcOrHandle !== "function") { - this.gl.bindTransformFeedback(36386, funcOrHandle); - return this; - } - let value; - if (!this._bound) { - this.gl.bindTransformFeedback(36386, this.handle); - this._bound = true; - value = funcOrHandle(); - this._bound = false; - this.gl.bindTransformFeedback(36386, null); - } else { - value = funcOrHandle(); - } - return value; - } - unbind() { - this.bind(null); - } - // PRIVATE METHODS - /** Extract offsets for bindBufferRange */ - _getBufferRange(bufferOrRange) { - if (bufferOrRange instanceof WEBGLBuffer) { - return { buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength }; - } - const { buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength } = bufferOrRange; - return { buffer, byteOffset, byteLength }; - } - _getVaryingIndex(locationOrName) { - if (isIndex(locationOrName)) { - return Number(locationOrName); - } - for (const varying of this.layout.varyings) { - if (locationOrName === varying.name) { - return varying.location; - } - } - return -1; - } - /** - * Need to avoid chrome bug where buffer that is already bound to a different target - * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target. - */ - _bindBuffers() { - for (const bufferIndex in this.buffers) { - const { buffer, byteLength, byteOffset } = this._getBufferRange(this.buffers[bufferIndex]); - this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength); - } - } - _unbindBuffers() { - for (const bufferIndex in this.buffers) { - this.gl.bindBufferBase(35982, Number(bufferIndex), null); - } - } - _bindBuffer(index2, buffer, byteOffset = 0, byteLength) { - const handle = buffer && buffer.handle; - if (!handle || byteLength === void 0) { - this.gl.bindBufferBase(35982, index2, handle); - } else { - this.gl.bindBufferRange(35982, index2, handle, byteOffset, byteLength); - } - } -}; -function isIndex(value) { - if (typeof value === "number") { - return Number.isInteger(value); - } - return /^\d+$/.test(value); -} - -// node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-query-set.js -var WEBGLQuerySet = class extends QuerySet { - device; - handle; - target = null; - _queryPending = false; - _pollingPromise = null; - get [Symbol.toStringTag]() { - return "Query"; - } - // Create a query class - constructor(device, props) { - super(device, props); - this.device = device; - if (props.count > 1) { - throw new Error("WebGL QuerySet can only have one value"); - } - this.handle = this.device.gl.createQuery(); - Object.seal(this); - } - destroy() { - this.device.gl.deleteQuery(this.handle); - } - // FOR RENDER PASS AND COMMAND ENCODER - /** - * Shortcut for timer query (dependent on extension in both WebGL1 and 2) - * Measures GPU time delta between this call and a matching `end` call in the - * GPU instruction stream. - */ - beginTimestampQuery() { - return this._begin(35007); - } - endTimestampQuery() { - this._end(); - } - // Shortcut for occlusion queries - beginOcclusionQuery(options) { - return this._begin(options?.conservative ? 36202 : 35887); - } - endOcclusionQuery() { - this._end(); - } - // Shortcut for transformFeedbackQuery - beginTransformFeedbackQuery() { - return this._begin(35976); - } - endTransformFeedbackQuery() { - this._end(); - } - async resolveQuery() { - const value = await this.pollQuery(); - return [value]; - } - // PRIVATE METHODS - /** - * Due to OpenGL API limitations, after calling `begin()` on one Query - * instance, `end()` must be called on that same instance before - * calling `begin()` on another query. While there can be multiple - * outstanding queries representing disjoint `begin()`/`end()` intervals. - * It is not possible to interleave or overlap `begin` and `end` calls. - */ - _begin(target) { - if (this._queryPending) { - return; - } - this.target = target; - this.device.gl.beginQuery(this.target, this.handle); - return; - } - // ends the current query - _end() { - if (this._queryPending) { - return; - } - if (this.target) { - this.device.gl.endQuery(this.target); - this.target = null; - this._queryPending = true; - } - return; - } - // Returns true if the query result is available - isResultAvailable() { - if (!this._queryPending) { - return false; - } - const resultAvailable = this.device.gl.getQueryParameter(this.handle, 34919); - if (resultAvailable) { - this._queryPending = false; - } - return resultAvailable; - } - // Timing query is disjoint, i.e. results are invalid - isTimerDisjoint() { - return this.device.gl.getParameter(36795); - } - // Returns query result. - getResult() { - return this.device.gl.getQueryParameter(this.handle, 34918); - } - // Returns the query result, converted to milliseconds to match JavaScript conventions. - getTimerMilliseconds() { - return this.getResult() / 1e6; - } - // Polls the query - pollQuery(limit = Number.POSITIVE_INFINITY) { - if (this._pollingPromise) { - return this._pollingPromise; - } - let counter2 = 0; - this._pollingPromise = new Promise((resolve2, reject) => { - const poll = () => { - if (this.isResultAvailable()) { - resolve2(this.getResult()); - this._pollingPromise = null; - } else if (counter2++ > limit) { - reject("Timed out"); - this._pollingPromise = null; - } else { - requestAnimationFrame(poll); - } - }; - requestAnimationFrame(poll); - }); - return this._pollingPromise; - } -}; - -// node_modules/@luma.gl/webgl/dist/classic/format-utils.js -function glFormatToComponents(format) { - switch (format) { - case 6406: - case 33326: - case 6403: - return 1; - case 33328: - case 33319: - return 2; - case 6407: - case 34837: - return 3; - case 6408: - case 34836: - return 4; - default: - assert6(false); - return 0; - } -} -function glTypeToBytes(type) { - switch (type) { - case 5121: - return 1; - case 33635: - case 32819: - case 32820: - return 2; - case 5126: - return 4; - default: - assert6(false); - return 0; - } -} - -// node_modules/@luma.gl/webgl/dist/classic/copy-and-blit.js -function readPixelsToArray(source, options) { - const { - sourceX = 0, - sourceY = 0, - sourceFormat = 6408, - sourceAttachment = 36064 - // TODO - support gl.readBuffer - } = options || {}; - let { - target = null, - // following parameters are auto deduced if not provided - sourceWidth, - sourceHeight, - sourceType - } = options || {}; - const { framebuffer, deleteFramebuffer } = getFramebuffer2(source); - assert6(framebuffer); - const { gl, handle } = framebuffer; - sourceWidth = sourceWidth || framebuffer.width; - sourceHeight = sourceHeight || framebuffer.height; - const attachment = sourceAttachment - 36064; - sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.type || 5121; - target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight); - sourceType = sourceType || getGLTypeFromTypedArray(target); - const prevHandle = gl.bindFramebuffer(36160, handle); - gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target); - gl.bindFramebuffer(36160, prevHandle || null); - if (deleteFramebuffer) { - framebuffer.destroy(); - } - return target; -} -function readPixelsToBuffer(source, options) { - const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {}; - let { sourceWidth, sourceHeight, sourceType } = options || {}; - const { framebuffer, deleteFramebuffer } = getFramebuffer2(source); - assert6(framebuffer); - sourceWidth = sourceWidth || framebuffer.width; - sourceHeight = sourceHeight || framebuffer.height; - const webglFramebuffer = framebuffer; - sourceType = sourceType || 5121; - let webglBufferTarget = target; - if (!webglBufferTarget) { - const components = glFormatToComponents(sourceFormat); - const byteCount = glTypeToBytes(sourceType); - const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount; - webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength }); - } - const commandEncoder = source.device.createCommandEncoder(); - commandEncoder.copyTextureToBuffer({ - source, - width: sourceWidth, - height: sourceHeight, - origin: [sourceX, sourceY], - destination: webglBufferTarget, - byteOffset: targetByteOffset - }); - commandEncoder.destroy(); - if (deleteFramebuffer) { - framebuffer.destroy(); - } - return webglBufferTarget; -} -function getFramebuffer2(source) { - if (!(source instanceof Framebuffer)) { - return { framebuffer: toFramebuffer(source), deleteFramebuffer: true }; - } - return { framebuffer: source, deleteFramebuffer: false }; -} -function toFramebuffer(texture, props) { - const { device, width, height, id } = texture; - const framebuffer = device.createFramebuffer({ - ...props, - id: `framebuffer-for-${id}`, - width, - height, - colorAttachments: [texture] - }); - return framebuffer; -} -function getPixelArray(pixelArray, type, format, width, height) { - if (pixelArray) { - return pixelArray; - } - type = type || 5121; - const ArrayType2 = getTypedArrayFromGLType(type, { clamped: false }); - const components = glFormatToComponents(format); - return new ArrayType2(width * height * components); -} - -// node_modules/@luma.gl/webgl/dist/classic/clear.js -var GL_DEPTH_BUFFER_BIT2 = 256; -var GL_STENCIL_BUFFER_BIT2 = 1024; -var GL_COLOR_BUFFER_BIT2 = 16384; -var ERR_ARGUMENTS = "clear: bad arguments"; -function clear(device, options) { - const { framebuffer = null, color = null, depth = null, stencil = null } = options || {}; - const parameters = {}; - if (framebuffer) { - parameters.framebuffer = framebuffer; - } - let clearFlags = 0; - if (color) { - clearFlags |= GL_COLOR_BUFFER_BIT2; - if (color !== true) { - parameters.clearColor = color; - } - } - if (depth) { - clearFlags |= GL_DEPTH_BUFFER_BIT2; - if (depth !== true) { - parameters.clearDepth = depth; - } - } - if (stencil) { - clearFlags |= GL_STENCIL_BUFFER_BIT2; - if (depth !== true) { - parameters.clearStencil = depth; - } - } - assert6(clearFlags !== 0, ERR_ARGUMENTS); - const gl = device.gl; - withGLParameters(gl, parameters, () => { - gl.clear(clearFlags); - }); -} - -// node_modules/@luma.gl/webgl/dist/adapter/webgl-device.js -var LOG_LEVEL2 = 1; -var WebGLDevice = class _WebGLDevice extends Device { - // - // Public `Device` API - // - /** type of this device */ - static type = "webgl"; - /** type of this device */ - type = "webgl"; - /** The underlying WebGL context */ - handle; - features; - limits; - info; - canvasContext; - lost; - _resolveContextLost; - // - // Static methods, expected to be present by `luma.createDevice()` - // - /** Check if WebGL 2 is available */ - static isSupported() { - return typeof WebGL2RenderingContext !== "undefined"; - } - /** - * Get a device instance from a GL context - * Creates and instruments the device if not already created - * @param gl - * @returns - */ - static attach(gl) { - if (gl instanceof _WebGLDevice) { - return gl; - } - if (gl?.device instanceof Device) { - return gl.device; - } - if (!isWebGL(gl)) { - throw new Error("Invalid WebGL2RenderingContext"); - } - return new _WebGLDevice({ gl }); - } - static async create(props = {}) { - log2.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")(); - const promises = []; - if (props.debug) { - promises.push(loadWebGLDeveloperTools()); - } - if (props.spector) { - promises.push(loadSpectorJS()); - } - if (typeof props.canvas === "string") { - promises.push(CanvasContext.pageLoaded); - } - const results = await Promise.allSettled(promises); - for (const result of results) { - if (result.status === "rejected") { - log2.error(`Failed to initialize debug libraries ${result.reason}`)(); - } - } - log2.probe(LOG_LEVEL2 + 1, "DOM is loaded")(); - if (props.gl?.device) { - log2.warn("reattaching existing device")(); - return _WebGLDevice.attach(props.gl); - } - const device = new _WebGLDevice(props); - const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`; - log2.probe(LOG_LEVEL2, message2)(); - log2.table(LOG_LEVEL2, device.info)(); - log2.groupEnd(LOG_LEVEL2)(); - return device; - } - // - // Public API - // - constructor(props) { - super({ ...props, id: props.id || uid("webgl-device") }); - const device = props.gl?.device; - if (device) { - throw new Error(`WebGL context already attached to device ${device.id}`); - } - const canvas2 = props.gl?.canvas || props.canvas; - this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas: canvas2 }); - this.lost = new Promise((resolve2) => { - this._resolveContextLost = resolve2; - }); - let gl = props.gl || null; - gl ||= createBrowserContext(this.canvasContext.canvas, { - ...props, - onContextLost: (event) => this._resolveContextLost?.({ - reason: "destroyed", - message: "Entered sleep mode, or too many apps or browser tabs are using the GPU." - }) - }); - if (!gl) { - throw new Error("WebGL context creation failed"); - } - this.handle = gl; - this.gl = gl; - this.gl.device = this; - this.gl._version = 2; - if (props.spector) { - this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas }); - } - this.info = getDeviceInfo(this.gl, this._extensions); - this.limits = new WebGLDeviceLimits(this.gl); - this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures); - if (this.props.initalizeFeatures) { - this.features.initializeFeatures(); - } - this.canvasContext.resize(); - const { enable: enable2 = true, copyState = false } = props; - trackContextState(this.gl, { - enable: enable2, - copyState, - log: (...args) => log2.log(1, ...args)() - }); - if (props.debug) { - this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true }); - this.debug = true; - log2.level = Math.max(log2.level, 1); - log2.warn("WebGL debug mode activated. Performance reduced.")(); - } - } - /** - * Destroys the context - * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts - */ - destroy() { - } - get isLost() { - return this.gl.isContextLost(); - } - getSize() { - return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight]; - } - isTextureFormatSupported(format) { - return isTextureFormatSupported(this.gl, format, this._extensions); - } - isTextureFormatFilterable(format) { - return isTextureFormatFilterable(this.gl, format, this._extensions); - } - isTextureFormatRenderable(format) { - return isTextureFormatRenderable(this.gl, format, this._extensions); - } - // IMPLEMENTATION OF ABSTRACT DEVICE - createCanvasContext(props) { - throw new Error("WebGL only supports a single canvas"); - } - createBuffer(props) { - const newProps = this._getBufferProps(props); - return new WEBGLBuffer(this, newProps); - } - _createTexture(props) { - return new WEBGLTexture(this, props); - } - createExternalTexture(props) { - throw new Error("createExternalTexture() not implemented"); - } - createSampler(props) { - return new WEBGLSampler(this, props); - } - createShader(props) { - return new WEBGLShader(this, props); - } - createFramebuffer(props) { - return new WEBGLFramebuffer(this, props); - } - createVertexArray(props) { - return new WEBGLVertexArray(this, props); - } - createTransformFeedback(props) { - return new WEBGLTransformFeedback(this, props); - } - createQuerySet(props) { - return new WEBGLQuerySet(this, props); - } - createRenderPipeline(props) { - return new WEBGLRenderPipeline(this, props); - } - beginRenderPass(props) { - return new WEBGLRenderPass(this, props); - } - createComputePipeline(props) { - throw new Error("ComputePipeline not supported in WebGL"); - } - beginComputePass(props) { - throw new Error("ComputePass not supported in WebGL"); - } - renderPass = null; - createCommandEncoder(props) { - return new WEBGLCommandEncoder(this, props); - } - /** - * Offscreen Canvas Support: Commit the frame - * https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/commit - * Chrome's offscreen canvas does not require gl.commit - */ - submit() { - this.renderPass?.end(); - this.renderPass = null; - } - // - // TEMPORARY HACKS - will be removed in v9.1 - // - /** @deprecated - should use command encoder */ - readPixelsToArrayWebGL(source, options) { - return readPixelsToArray(source, options); - } - /** @deprecated - should use command encoder */ - readPixelsToBufferWebGL(source, options) { - return readPixelsToBuffer(source, options); - } - setParametersWebGL(parameters) { - setGLParameters(this.gl, parameters); - } - getParametersWebGL(parameters) { - return getGLParameters(this.gl, parameters); - } - withParametersWebGL(parameters, func) { - return withGLParameters(this.gl, parameters, func); - } - clearWebGL(options) { - clear(this, options); - } - resetWebGL() { - log2.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")(); - resetGLParameters(this.gl); - } - // - // WebGL-only API (not part of `Device` API) - // - /** WebGL2 context. */ - gl; - debug = false; - /** State used by luma.gl classes: TODO - move to canvasContext*/ - _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 }; - /** State used by luma.gl classes - TODO - not used? */ - _extensions = {}; - _polyfilled = false; - /** Instance of Spector.js (if initialized) */ - spectorJS; - /** - * Triggers device (or WebGL context) loss. - * @note primarily intended for testing how application reacts to device loss - */ - loseDevice() { - let deviceLossTriggered = false; - const extensions = this.getExtension("WEBGL_lose_context"); - const ext = extensions.WEBGL_lose_context; - if (ext) { - deviceLossTriggered = true; - ext.loseContext(); - } - this._resolveContextLost?.({ - reason: "destroyed", - message: "Application triggered context loss" - }); - return deviceLossTriggered; - } - /** Save current WebGL context state onto an internal stack */ - pushState() { - pushContextState(this.gl); - } - /** Restores previously saved context state */ - popState() { - popContextState(this.gl); - } - /** - * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension - * luma.gl ids and props can be inspected - */ - setSpectorMetadata(handle, props) { - handle.__SPECTOR_Metadata = props; - } - /** - * Returns the GL. constant that corresponds to a numeric value of a GL constant - * Be aware that there are some duplicates especially for constants that are 0, - * so this isn't guaranteed to return the right key in all cases. - */ - getGLKey(value, gl) { - gl = gl || this.gl2 || this.gl; - const number = Number(value); - for (const key in gl) { - if (gl[key] === number) { - return `GL.${key}`; - } - } - return String(value); - } - /** Store constants */ - _constants; - /** - * Set a constant value for a location. Disabled attributes at that location will read from this value - * @note WebGL constants are stored globally on the WebGL context, not the VertexArray - * so they need to be updated before every render - * @todo - remember/cache values to avoid setting them unnecessarily? - */ - setConstantAttributeWebGL(location, constant) { - const maxVertexAttributes = this.limits.maxVertexAttributes; - this._constants = this._constants || new Array(maxVertexAttributes).fill(null); - const currentConstant = this._constants[location]; - if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) { - log2.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)(); - } - this._constants[location] = constant; - switch (constant.constructor) { - case Float32Array: - setConstantFloatArray(this, location, constant); - break; - case Int32Array: - setConstantIntArray(this, location, constant); - break; - case Uint32Array: - setConstantUintArray(this, location, constant); - break; - default: - assert6(false); - } - } - /** Ensure extensions are only requested once */ - getExtension(name2) { - getWebGLExtension(this.gl, name2, this._extensions); - return this._extensions; - } -}; -function isWebGL(gl) { - if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { - return true; - } - return Boolean(gl && Number.isFinite(gl._version)); -} -function setConstantFloatArray(device, location, array) { - switch (array.length) { - case 1: - device.gl.vertexAttrib1fv(location, array); - break; - case 2: - device.gl.vertexAttrib2fv(location, array); - break; - case 3: - device.gl.vertexAttrib3fv(location, array); - break; - case 4: - device.gl.vertexAttrib4fv(location, array); - break; - default: - assert6(false); - } -} -function setConstantIntArray(device, location, array) { - device.gl.vertexAttribI4iv(location, array); -} -function setConstantUintArray(device, location, array) { - device.gl.vertexAttribI4uiv(location, array); -} -function compareConstantArrayValues2(v1, v2) { - if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { - return false; - } - for (let i = 0; i < v1.length; ++i) { - if (v1[i] !== v2[i]) { - return false; - } - } - return true; -} - -// notebooks/shims/hammerjs.mjs -var hammerjs_exports = {}; -__export(hammerjs_exports, { - Manager: () => Manager, - MouseInput: () => MouseInput, - Pan: () => Pan, - Pinch: () => Pinch, - PointerEventInput: () => PointerEventInput, - Press: () => Press, - Rotate: () => Rotate, - Swipe: () => Swipe, - Tap: () => Tap, - default: () => hammerjs_default -}); -var import_hammer = __toESM(require_hammer(), 1); -var PointerEventInput = import_hammer.default.PointerEventInput; -var MouseInput = import_hammer.default.MouseInput; -var Manager = import_hammer.default.Manager; -var Pan = import_hammer.default.Pan; -var Rotate = import_hammer.default.Rotate; -var Pinch = import_hammer.default.Pinch; -var Swipe = import_hammer.default.Swipe; -var Press = import_hammer.default.Press; -var Tap = import_hammer.default.Tap; -var hammerjs_default = import_hammer.default; - -// node_modules/mjolnir.js/dist/esm/utils/hammer-overrides.js -var INPUT_START = 1; -var INPUT_MOVE = 2; -var INPUT_END = 4; -var MOUSE_INPUT_MAP = { - mousedown: INPUT_START, - mousemove: INPUT_MOVE, - mouseup: INPUT_END -}; -function some(array, predict) { - for (let i = 0; i < array.length; i++) { - if (predict(array[i])) { - return true; - } - } - return false; -} -function enhancePointerEventInput(PointerEventInput2) { - const oldHandler = PointerEventInput2.prototype.handler; - PointerEventInput2.prototype.handler = function handler(ev) { - const store = this.store; - if (ev.button > 0 && ev.type === "pointerdown") { - if (!some(store, (e) => e.pointerId === ev.pointerId)) { - store.push(ev); - } - } - oldHandler.call(this, ev); - }; -} -function enhanceMouseInput(MouseInput2) { - MouseInput2.prototype.handler = function handler(ev) { - let eventType = MOUSE_INPUT_MAP[ev.type]; - if (eventType & INPUT_START && ev.button >= 0) { - this.pressed = true; - } - if (eventType & INPUT_MOVE && ev.which === 0) { - eventType = INPUT_END; - } - if (!this.pressed) { - return; - } - if (eventType & INPUT_END) { - this.pressed = false; - } - this.callback(this.manager, eventType, { - pointers: [ev], - changedPointers: [ev], - pointerType: "mouse", - srcEvent: ev - }); - }; -} - -// node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js -enhancePointerEventInput(PointerEventInput); -enhanceMouseInput(MouseInput); -var Manager2 = Manager; -var hammer_browser_default = hammerjs_exports; - -// node_modules/mjolnir.js/dist/esm/inputs/input.js -var Input = class { - constructor(element, callback, options) { - this.element = element; - this.callback = callback; - this.options = { enable: true, ...options }; - } -}; - -// node_modules/mjolnir.js/dist/esm/constants.js -var RECOGNIZERS = hammer_browser_default ? [ - [hammer_browser_default.Pan, { event: "tripan", pointers: 3, threshold: 0, enable: false }], - [hammer_browser_default.Rotate, { enable: false }], - [hammer_browser_default.Pinch, { enable: false }], - [hammer_browser_default.Swipe, { enable: false }], - [hammer_browser_default.Pan, { threshold: 0, enable: false }], - [hammer_browser_default.Press, { enable: false }], - [hammer_browser_default.Tap, { event: "doubletap", taps: 2, enable: false }], - // TODO - rename to 'tap' and 'singletap' in the next major release - [hammer_browser_default.Tap, { event: "anytap", enable: false }], - [hammer_browser_default.Tap, { enable: false }] -] : null; -var RECOGNIZER_COMPATIBLE_MAP = { - tripan: ["rotate", "pinch", "pan"], - rotate: ["pinch"], - pinch: ["pan"], - pan: ["press", "doubletap", "anytap", "tap"], - doubletap: ["anytap"], - anytap: ["tap"] -}; -var RECOGNIZER_FALLBACK_MAP = { - doubletap: ["tap"] -}; -var BASIC_EVENT_ALIASES = { - pointerdown: "pointerdown", - pointermove: "pointermove", - pointerup: "pointerup", - touchstart: "pointerdown", - touchmove: "pointermove", - touchend: "pointerup", - mousedown: "pointerdown", - mousemove: "pointermove", - mouseup: "pointerup" -}; -var INPUT_EVENT_TYPES = { - KEY_EVENTS: ["keydown", "keyup"], - MOUSE_EVENTS: ["mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "mouseleave"], - WHEEL_EVENTS: [ - // Chrome, Safari - "wheel", - // IE - "mousewheel" - ] -}; -var EVENT_RECOGNIZER_MAP = { - tap: "tap", - anytap: "anytap", - doubletap: "doubletap", - press: "press", - pinch: "pinch", - pinchin: "pinch", - pinchout: "pinch", - pinchstart: "pinch", - pinchmove: "pinch", - pinchend: "pinch", - pinchcancel: "pinch", - rotate: "rotate", - rotatestart: "rotate", - rotatemove: "rotate", - rotateend: "rotate", - rotatecancel: "rotate", - tripan: "tripan", - tripanstart: "tripan", - tripanmove: "tripan", - tripanup: "tripan", - tripandown: "tripan", - tripanleft: "tripan", - tripanright: "tripan", - tripanend: "tripan", - tripancancel: "tripan", - pan: "pan", - panstart: "pan", - panmove: "pan", - panup: "pan", - pandown: "pan", - panleft: "pan", - panright: "pan", - panend: "pan", - pancancel: "pan", - swipe: "swipe", - swipeleft: "swipe", - swiperight: "swipe", - swipeup: "swipe", - swipedown: "swipe" -}; -var GESTURE_EVENT_ALIASES = { - click: "tap", - anyclick: "anytap", - dblclick: "doubletap", - mousedown: "pointerdown", - mousemove: "pointermove", - mouseup: "pointerup", - mouseover: "pointerover", - mouseout: "pointerout", - mouseleave: "pointerleave" -}; - -// node_modules/mjolnir.js/dist/esm/utils/globals.js -var userAgent = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : ""; -var window_5 = typeof window !== "undefined" ? window : global; -var passiveSupported = false; -try { - const options = { - // This function will be called when the browser - // attempts to access the passive property. - get passive() { - passiveSupported = true; - return true; - } - }; - window_5.addEventListener("test", null, options); - window_5.removeEventListener("test", null); -} catch (err) { - passiveSupported = false; -} - -// node_modules/mjolnir.js/dist/esm/inputs/wheel-input.js -var firefox = userAgent.indexOf("firefox") !== -1; -var { WHEEL_EVENTS } = INPUT_EVENT_TYPES; -var EVENT_TYPE = "wheel"; -var WHEEL_DELTA_MAGIC_SCALER = 4.000244140625; -var WHEEL_DELTA_PER_LINE = 40; -var SHIFT_MULTIPLIER = 0.25; -var WheelInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - if (!this.options.enable) { - return; - } - let value = event.deltaY; - if (window_5.WheelEvent) { - if (firefox && event.deltaMode === window_5.WheelEvent.DOM_DELTA_PIXEL) { - value /= window_5.devicePixelRatio; - } - if (event.deltaMode === window_5.WheelEvent.DOM_DELTA_LINE) { - value *= WHEEL_DELTA_PER_LINE; - } - } - if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) { - value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER); - } - if (event.shiftKey && value) { - value = value * SHIFT_MULTIPLIER; - } - this.callback({ - type: EVENT_TYPE, - center: { - x: event.clientX, - y: event.clientY - }, - delta: -value, - srcEvent: event, - pointerType: "mouse", - target: event.target - }); - }; - this.events = (this.options.events || []).concat(WHEEL_EVENTS); - this.events.forEach((event) => element.addEventListener(event, this.handleEvent, passiveSupported ? { passive: false } : false)); - } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); - } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === EVENT_TYPE) { - this.options.enable = enabled; - } - } -}; - -// node_modules/mjolnir.js/dist/esm/inputs/move-input.js -var { MOUSE_EVENTS } = INPUT_EVENT_TYPES; -var MOVE_EVENT_TYPE = "pointermove"; -var OVER_EVENT_TYPE = "pointerover"; -var OUT_EVENT_TYPE = "pointerout"; -var ENTER_EVENT_TYPE = "pointerenter"; -var LEAVE_EVENT_TYPE = "pointerleave"; -var MoveInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - this.handleOverEvent(event); - this.handleOutEvent(event); - this.handleEnterEvent(event); - this.handleLeaveEvent(event); - this.handleMoveEvent(event); - }; - this.pressed = false; - const { enable: enable2 } = this.options; - this.enableMoveEvent = enable2; - this.enableLeaveEvent = enable2; - this.enableEnterEvent = enable2; - this.enableOutEvent = enable2; - this.enableOverEvent = enable2; - this.events = (this.options.events || []).concat(MOUSE_EVENTS); - this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); - } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); - } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === MOVE_EVENT_TYPE) { - this.enableMoveEvent = enabled; - } - if (eventType === OVER_EVENT_TYPE) { - this.enableOverEvent = enabled; - } - if (eventType === OUT_EVENT_TYPE) { - this.enableOutEvent = enabled; - } - if (eventType === ENTER_EVENT_TYPE) { - this.enableEnterEvent = enabled; - } - if (eventType === LEAVE_EVENT_TYPE) { - this.enableLeaveEvent = enabled; - } - } - handleOverEvent(event) { - if (this.enableOverEvent) { - if (event.type === "mouseover") { - this._emit(OVER_EVENT_TYPE, event); - } - } - } - handleOutEvent(event) { - if (this.enableOutEvent) { - if (event.type === "mouseout") { - this._emit(OUT_EVENT_TYPE, event); - } - } - } - handleEnterEvent(event) { - if (this.enableEnterEvent) { - if (event.type === "mouseenter") { - this._emit(ENTER_EVENT_TYPE, event); - } - } - } - handleLeaveEvent(event) { - if (this.enableLeaveEvent) { - if (event.type === "mouseleave") { - this._emit(LEAVE_EVENT_TYPE, event); - } - } - } - handleMoveEvent(event) { - if (this.enableMoveEvent) { - switch (event.type) { - case "mousedown": - if (event.button >= 0) { - this.pressed = true; - } - break; - case "mousemove": - if (event.which === 0) { - this.pressed = false; - } - if (!this.pressed) { - this._emit(MOVE_EVENT_TYPE, event); - } - break; - case "mouseup": - this.pressed = false; - break; - default: - } - } - } - _emit(type, event) { - this.callback({ - type, - center: { - x: event.clientX, - y: event.clientY - }, - srcEvent: event, - pointerType: "mouse", - target: event.target - }); - } -}; - -// node_modules/mjolnir.js/dist/esm/inputs/key-input.js -var { KEY_EVENTS } = INPUT_EVENT_TYPES; -var DOWN_EVENT_TYPE = "keydown"; -var UP_EVENT_TYPE = "keyup"; -var KeyInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - const targetElement = event.target || event.srcElement; - if (targetElement.tagName === "INPUT" && targetElement.type === "text" || targetElement.tagName === "TEXTAREA") { - return; - } - if (this.enableDownEvent && event.type === "keydown") { - this.callback({ - type: DOWN_EVENT_TYPE, - srcEvent: event, - key: event.key, - target: event.target - }); - } - if (this.enableUpEvent && event.type === "keyup") { - this.callback({ - type: UP_EVENT_TYPE, - srcEvent: event, - key: event.key, - target: event.target - }); - } - }; - this.enableDownEvent = this.options.enable; - this.enableUpEvent = this.options.enable; - this.events = (this.options.events || []).concat(KEY_EVENTS); - element.tabIndex = this.options.tabIndex || 0; - element.style.outline = "none"; - this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); - } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); - } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === DOWN_EVENT_TYPE) { - this.enableDownEvent = enabled; - } - if (eventType === UP_EVENT_TYPE) { - this.enableUpEvent = enabled; - } - } -}; - -// node_modules/mjolnir.js/dist/esm/inputs/contextmenu-input.js -var EVENT_TYPE2 = "contextmenu"; -var ContextmenuInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - if (!this.options.enable) { - return; - } - this.callback({ - type: EVENT_TYPE2, - center: { - x: event.clientX, - y: event.clientY - }, - srcEvent: event, - pointerType: "mouse", - target: event.target - }); - }; - element.addEventListener("contextmenu", this.handleEvent); - } - destroy() { - this.element.removeEventListener("contextmenu", this.handleEvent); - } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === EVENT_TYPE2) { - this.options.enable = enabled; - } - } -}; - -// node_modules/mjolnir.js/dist/esm/utils/event-utils.js -var DOWN_EVENT = 1; -var MOVE_EVENT = 2; -var UP_EVENT = 4; -var MOUSE_EVENTS2 = { - pointerdown: DOWN_EVENT, - pointermove: MOVE_EVENT, - pointerup: UP_EVENT, - mousedown: DOWN_EVENT, - mousemove: MOVE_EVENT, - mouseup: UP_EVENT -}; -var MOUSE_EVENT_WHICH_LEFT = 1; -var MOUSE_EVENT_WHICH_MIDDLE = 2; -var MOUSE_EVENT_WHICH_RIGHT = 3; -var MOUSE_EVENT_BUTTON_LEFT = 0; -var MOUSE_EVENT_BUTTON_MIDDLE = 1; -var MOUSE_EVENT_BUTTON_RIGHT = 2; -var MOUSE_EVENT_BUTTONS_LEFT_MASK = 1; -var MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2; -var MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4; -function whichButtons(event) { - const eventType = MOUSE_EVENTS2[event.srcEvent.type]; - if (!eventType) { - return null; - } - const { buttons, button, which } = event.srcEvent; - let leftButton = false; - let middleButton = false; - let rightButton = false; - if ( - // button is up, need to find out which one was pressed before - eventType === UP_EVENT || // moving but does not support `buttons` API - eventType === MOVE_EVENT && !Number.isFinite(buttons) - ) { - leftButton = which === MOUSE_EVENT_WHICH_LEFT; - middleButton = which === MOUSE_EVENT_WHICH_MIDDLE; - rightButton = which === MOUSE_EVENT_WHICH_RIGHT; - } else if (eventType === MOVE_EVENT) { - leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK); - middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK); - rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK); - } else if (eventType === DOWN_EVENT) { - leftButton = button === MOUSE_EVENT_BUTTON_LEFT; - middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE; - rightButton = button === MOUSE_EVENT_BUTTON_RIGHT; - } - return { leftButton, middleButton, rightButton }; -} -function getOffsetPosition(event, rootElement) { - const center = event.center; - if (!center) { - return null; - } - const rect = rootElement.getBoundingClientRect(); - const scaleX2 = rect.width / rootElement.offsetWidth || 1; - const scaleY2 = rect.height / rootElement.offsetHeight || 1; - const offsetCenter = { - x: (center.x - rect.left - rootElement.clientLeft) / scaleX2, - y: (center.y - rect.top - rootElement.clientTop) / scaleY2 - }; - return { center, offsetCenter }; -} - -// node_modules/mjolnir.js/dist/esm/utils/event-registrar.js -var DEFAULT_OPTIONS = { - srcElement: "root", - priority: 0 -}; -var EventRegistrar = class { - constructor(eventManager) { - this.handleEvent = (event) => { - if (this.isEmpty()) { - return; - } - const mjolnirEvent = this._normalizeEvent(event); - let target = event.srcEvent.target; - while (target && target !== mjolnirEvent.rootElement) { - this._emit(mjolnirEvent, target); - if (mjolnirEvent.handled) { - return; - } - target = target.parentNode; - } - this._emit(mjolnirEvent, "root"); - }; - this.eventManager = eventManager; - this.handlers = []; - this.handlersByElement = /* @__PURE__ */ new Map(); - this._active = false; - } - // Returns true if there are no non-passive handlers - isEmpty() { - return !this._active; - } - add(type, handler, options, once = false, passive = false) { - const { handlers, handlersByElement } = this; - let opts = DEFAULT_OPTIONS; - if (typeof options === "string" || options && options.addEventListener) { - opts = { ...DEFAULT_OPTIONS, srcElement: options }; - } else if (options) { - opts = { ...DEFAULT_OPTIONS, ...options }; - } - let entries = handlersByElement.get(opts.srcElement); - if (!entries) { - entries = []; - handlersByElement.set(opts.srcElement, entries); - } - const entry = { - type, - handler, - srcElement: opts.srcElement, - priority: opts.priority - }; - if (once) { - entry.once = true; - } - if (passive) { - entry.passive = true; - } - handlers.push(entry); - this._active = this._active || !entry.passive; - let insertPosition = entries.length - 1; - while (insertPosition >= 0) { - if (entries[insertPosition].priority >= entry.priority) { - break; - } - insertPosition--; - } - entries.splice(insertPosition + 1, 0, entry); - } - remove(type, handler) { - const { handlers, handlersByElement } = this; - for (let i = handlers.length - 1; i >= 0; i--) { - const entry = handlers[i]; - if (entry.type === type && entry.handler === handler) { - handlers.splice(i, 1); - const entries = handlersByElement.get(entry.srcElement); - entries.splice(entries.indexOf(entry), 1); - if (entries.length === 0) { - handlersByElement.delete(entry.srcElement); - } - } - } - this._active = handlers.some((entry) => !entry.passive); - } - /** - * Invoke handlers on a particular element - */ - _emit(event, srcElement) { - const entries = this.handlersByElement.get(srcElement); - if (entries) { - let immediatePropagationStopped = false; - const stopPropagation = () => { - event.handled = true; - }; - const stopImmediatePropagation = () => { - event.handled = true; - immediatePropagationStopped = true; - }; - const entriesToRemove = []; - for (let i = 0; i < entries.length; i++) { - const { type, handler, once } = entries[i]; - handler({ - ...event, - // @ts-ignore - type, - stopPropagation, - stopImmediatePropagation - }); - if (once) { - entriesToRemove.push(entries[i]); - } - if (immediatePropagationStopped) { - break; - } - } - for (let i = 0; i < entriesToRemove.length; i++) { - const { type, handler } = entriesToRemove[i]; - this.remove(type, handler); - } - } - } - /** - * Normalizes hammerjs and custom events to have predictable fields. - */ - _normalizeEvent(event) { - const rootElement = this.eventManager.getElement(); - return { - ...event, - ...whichButtons(event), - ...getOffsetPosition(event, rootElement), - preventDefault: () => { - event.srcEvent.preventDefault(); - }, - stopImmediatePropagation: null, - stopPropagation: null, - handled: false, - rootElement - }; - } -}; - -// node_modules/mjolnir.js/dist/esm/event-manager.js -var DEFAULT_OPTIONS2 = { - // event handlers - events: null, - // custom recognizers - recognizers: null, - recognizerOptions: {}, - // Manager class - Manager: Manager2, - // allow browser default touch action - // https://github.com/uber/react-map-gl/issues/506 - touchAction: "none", - tabIndex: 0 -}; -var EventManager = class { - constructor(element = null, options) { - this._onBasicInput = (event) => { - const { srcEvent } = event; - const alias = BASIC_EVENT_ALIASES[srcEvent.type]; - if (alias) { - this.manager.emit(alias, event); - } - }; - this._onOtherEvent = (event) => { - this.manager.emit(event.type, event); - }; - this.options = { ...DEFAULT_OPTIONS2, ...options }; - this.events = /* @__PURE__ */ new Map(); - this.setElement(element); - const { events } = this.options; - if (events) { - this.on(events); - } - } - getElement() { - return this.element; - } - setElement(element) { - if (this.element) { - this.destroy(); - } - this.element = element; - if (!element) { - return; - } - const { options } = this; - const ManagerClass = options.Manager; - this.manager = new ManagerClass(element, { - touchAction: options.touchAction, - recognizers: options.recognizers || RECOGNIZERS - }).on("hammer.input", this._onBasicInput); - if (!options.recognizers) { - Object.keys(RECOGNIZER_COMPATIBLE_MAP).forEach((name2) => { - const recognizer = this.manager.get(name2); - if (recognizer) { - RECOGNIZER_COMPATIBLE_MAP[name2].forEach((otherName) => { - recognizer.recognizeWith(otherName); - }); - } - }); - } - for (const recognizerName in options.recognizerOptions) { - const recognizer = this.manager.get(recognizerName); - if (recognizer) { - const recognizerOption = options.recognizerOptions[recognizerName]; - delete recognizerOption.enable; - recognizer.set(recognizerOption); - } - } - this.wheelInput = new WheelInput(element, this._onOtherEvent, { - enable: false - }); - this.moveInput = new MoveInput(element, this._onOtherEvent, { - enable: false - }); - this.keyInput = new KeyInput(element, this._onOtherEvent, { - enable: false, - tabIndex: options.tabIndex - }); - this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, { - enable: false - }); - for (const [eventAlias, eventRegistrar] of this.events) { - if (!eventRegistrar.isEmpty()) { - this._toggleRecognizer(eventRegistrar.recognizerName, true); - this.manager.on(eventAlias, eventRegistrar.handleEvent); - } - } - } - // Tear down internal event management implementations. - destroy() { - if (this.element) { - this.wheelInput.destroy(); - this.moveInput.destroy(); - this.keyInput.destroy(); - this.contextmenuInput.destroy(); - this.manager.destroy(); - this.wheelInput = null; - this.moveInput = null; - this.keyInput = null; - this.contextmenuInput = null; - this.manager = null; - this.element = null; - } - } - /** Register an event handler function to be called on `event` */ - on(event, handler, opts) { - this._addEventHandler(event, handler, opts, false); - } - once(event, handler, opts) { - this._addEventHandler(event, handler, opts, true); - } - watch(event, handler, opts) { - this._addEventHandler(event, handler, opts, false, true); - } - off(event, handler) { - this._removeEventHandler(event, handler); - } - /* - * Enable/disable recognizer for the given event - */ - _toggleRecognizer(name2, enabled) { - const { manager } = this; - if (!manager) { - return; - } - const recognizer = manager.get(name2); - if (recognizer && recognizer.options.enable !== enabled) { - recognizer.set({ enable: enabled }); - const fallbackRecognizers = RECOGNIZER_FALLBACK_MAP[name2]; - if (fallbackRecognizers && !this.options.recognizers) { - fallbackRecognizers.forEach((otherName) => { - const otherRecognizer = manager.get(otherName); - if (enabled) { - otherRecognizer.requireFailure(name2); - recognizer.dropRequireFailure(otherName); - } else { - otherRecognizer.dropRequireFailure(name2); - } - }); - } - } - this.wheelInput.enableEventType(name2, enabled); - this.moveInput.enableEventType(name2, enabled); - this.keyInput.enableEventType(name2, enabled); - this.contextmenuInput.enableEventType(name2, enabled); - } - /** - * Process the event registration for a single event + handler. - */ - _addEventHandler(event, handler, opts, once, passive) { - if (typeof event !== "string") { - opts = handler; - for (const eventName in event) { - this._addEventHandler(eventName, event[eventName], opts, once, passive); - } - return; - } - const { manager, events } = this; - const eventAlias = GESTURE_EVENT_ALIASES[event] || event; - let eventRegistrar = events.get(eventAlias); - if (!eventRegistrar) { - eventRegistrar = new EventRegistrar(this); - events.set(eventAlias, eventRegistrar); - eventRegistrar.recognizerName = EVENT_RECOGNIZER_MAP[eventAlias] || eventAlias; - if (manager) { - manager.on(eventAlias, eventRegistrar.handleEvent); - } - } - eventRegistrar.add(event, handler, opts, once, passive); - if (!eventRegistrar.isEmpty()) { - this._toggleRecognizer(eventRegistrar.recognizerName, true); - } - } - /** - * Process the event deregistration for a single event + handler. - */ - _removeEventHandler(event, handler) { - if (typeof event !== "string") { - for (const eventName in event) { - this._removeEventHandler(eventName, event[eventName]); - } - return; - } - const { events } = this; - const eventAlias = GESTURE_EVENT_ALIASES[event] || event; - const eventRegistrar = events.get(eventAlias); - if (!eventRegistrar) { - return; - } - eventRegistrar.remove(event, handler); - if (eventRegistrar.isEmpty()) { - const { recognizerName } = eventRegistrar; - let isRecognizerUsed = false; - for (const eh of events.values()) { - if (eh.recognizerName === recognizerName && !eh.isEmpty()) { - isRecognizerUsed = true; - break; - } - } - if (!isRecognizerUsed) { - this._toggleRecognizer(recognizerName, false); - } - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/deck.js -function noop3() { -} -var getCursor = ({ isDragging }) => isDragging ? "grabbing" : "grab"; -var defaultProps = { - id: "", - width: "100%", - height: "100%", - style: null, - viewState: null, - initialViewState: null, - pickingRadius: 0, - layerFilter: null, - parameters: {}, - parent: null, - device: null, - deviceProps: { type: "webgl" }, - gl: null, - glOptions: {}, - canvas: null, - layers: [], - effects: [], - views: null, - controller: null, - // Rely on external controller, e.g. react-map-gl - useDevicePixels: true, - touchAction: "none", - eventRecognizerOptions: {}, - _framebuffer: null, - _animate: false, - _pickable: true, - _typedArrayManagerProps: {}, - _customRender: null, - widgets: [], - onDeviceInitialized: noop3, - onWebGLInitialized: noop3, - onResize: noop3, - onViewStateChange: noop3, - onInteractionStateChange: noop3, - onBeforeRender: noop3, - onAfterRender: noop3, - onLoad: noop3, - onError: (error) => log_default.error(error.message, error.cause)(), - onHover: null, - onClick: null, - onDragStart: null, - onDrag: null, - onDragEnd: null, - _onMetrics: null, - getCursor, - getTooltip: null, - debug: false, - drawPickingColors: false -}; -var Deck = class { - constructor(props) { - this.width = 0; - this.height = 0; - this.userData = {}; - this.device = null; - this.canvas = null; - this.viewManager = null; - this.layerManager = null; - this.effectManager = null; - this.deckRenderer = null; - this.deckPicker = null; - this.eventManager = null; - this.widgetManager = null; - this.tooltip = null; - this.animationLoop = null; - this.cursorState = { - isHovering: false, - isDragging: false - }; - this.stats = new Stats({ id: "deck.gl" }); - this.metrics = { - fps: 0, - setPropsTime: 0, - updateAttributesTime: 0, - framesRedrawn: 0, - pickTime: 0, - pickCount: 0, - gpuTime: 0, - gpuTimePerFrame: 0, - cpuTime: 0, - cpuTimePerFrame: 0, - bufferMemory: 0, - textureMemory: 0, - renderbufferMemory: 0, - gpuMemory: 0 - }; - this._metricsCounter = 0; - this._needsRedraw = "Initial render"; - this._pickRequest = { - mode: "hover", - x: -1, - y: -1, - radius: 0, - event: null - }; - this._lastPointerDownInfo = null; - this._onPointerMove = (event) => { - const { _pickRequest } = this; - if (event.type === "pointerleave") { - _pickRequest.x = -1; - _pickRequest.y = -1; - _pickRequest.radius = 0; - } else if (event.leftButton || event.rightButton) { - return; - } else { - const pos = event.offsetCenter; - if (!pos) { - return; - } - _pickRequest.x = pos.x; - _pickRequest.y = pos.y; - _pickRequest.radius = this.props.pickingRadius; - } - if (this.layerManager) { - this.layerManager.context.mousePosition = { x: _pickRequest.x, y: _pickRequest.y }; - } - _pickRequest.event = event; - }; - this._onEvent = (event) => { - const eventOptions = EVENTS[event.type]; - const pos = event.offsetCenter; - if (!eventOptions || !pos || !this.layerManager) { - return; - } - const layers = this.layerManager.getLayers(); - const info = this.deckPicker.getLastPickedObject({ - x: pos.x, - y: pos.y, - layers, - viewports: this.getViewports(pos) - }, this._lastPointerDownInfo); - const { layer } = info; - const layerHandler = layer && (layer[eventOptions.handler] || layer.props[eventOptions.handler]); - const rootHandler = this.props[eventOptions.handler]; - let handled = false; - if (layerHandler) { - handled = layerHandler.call(layer, info, event); - } - if (!handled) { - rootHandler?.(info, event); - this.widgetManager.onEvent(info, event); - } - }; - this._onPointerDown = (event) => { - const pos = event.offsetCenter; - const pickedInfo = this._pick("pickObject", "pickObject Time", { - x: pos.x, - y: pos.y, - radius: this.props.pickingRadius - }); - this._lastPointerDownInfo = pickedInfo.result[0] || pickedInfo.emptyInfo; - }; - this.props = { ...defaultProps, ...props }; - props = this.props; - if (props.viewState && props.initialViewState) { - log_default.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(); - } - this.viewState = this.props.initialViewState; - if (props.device) { - this.device = props.device; - } else if (props.gl) { - if (props.gl instanceof WebGLRenderingContext) { - log_default.error("WebGL1 context not supported.")(); - } - this.device = WebGLDevice.attach(props.gl); - } - let deviceOrPromise = this.device; - if (!deviceOrPromise) { - luma.registerDevices([WebGLDevice]); - deviceOrPromise = luma.createDevice({ - ...props.deviceProps, - canvas: this._createCanvas(props) - }); - } - this.animationLoop = this._createAnimationLoop(deviceOrPromise, props); - this.setProps(props); - if (props._typedArrayManagerProps) { - typed_array_manager_default.setOptions(props._typedArrayManagerProps); - } - this.animationLoop.start(); - } - /** Stop rendering and dispose all resources */ - finalize() { - this.animationLoop?.stop(); - this.animationLoop?.destroy(); - this.animationLoop = null; - this._lastPointerDownInfo = null; - this.layerManager?.finalize(); - this.layerManager = null; - this.viewManager?.finalize(); - this.viewManager = null; - this.effectManager?.finalize(); - this.effectManager = null; - this.deckRenderer?.finalize(); - this.deckRenderer = null; - this.deckPicker?.finalize(); - this.deckPicker = null; - this.eventManager?.destroy(); - this.eventManager = null; - this.widgetManager?.finalize(); - this.widgetManager = null; - if (!this.props.canvas && !this.props.device && !this.props.gl && this.canvas) { - this.canvas.parentElement?.removeChild(this.canvas); - this.canvas = null; - } - } - /** Partially update props */ - setProps(props) { - this.stats.get("setProps Time").timeStart(); - if ("onLayerHover" in props) { - log_default.removed("onLayerHover", "onHover")(); - } - if ("onLayerClick" in props) { - log_default.removed("onLayerClick", "onClick")(); - } - if (props.initialViewState && // depth = 3 when comparing viewStates: viewId.position.0 - !deepEqual2(this.props.initialViewState, props.initialViewState, 3)) { - this.viewState = props.initialViewState; - } - Object.assign(this.props, props); - this._setCanvasSize(this.props); - const resolvedProps = Object.create(this.props); - Object.assign(resolvedProps, { - views: this._getViews(), - width: this.width, - height: this.height, - viewState: this._getViewState() - }); - this.animationLoop?.setProps(resolvedProps); - if (this.layerManager) { - this.viewManager.setProps(resolvedProps); - this.layerManager.activateViewport(this.getViewports()[0]); - this.layerManager.setProps(resolvedProps); - this.effectManager.setProps(resolvedProps); - this.deckRenderer.setProps(resolvedProps); - this.deckPicker.setProps(resolvedProps); - this.widgetManager.setProps(resolvedProps); - } - this.stats.get("setProps Time").timeEnd(); - } - // Public API - /** - * Check if a redraw is needed - * @returns `false` or a string summarizing the redraw reason - */ - needsRedraw(opts = { clearRedrawFlags: false }) { - if (!this.layerManager) { - return false; - } - if (this.props._animate) { - return "Deck._animate"; - } - let redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts); - const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts); - const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts); - const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts); - redraw = redraw || viewManagerNeedsRedraw || layerManagerNeedsRedraw || effectManagerNeedsRedraw || deckRendererNeedsRedraw; - return redraw; - } - /** - * Redraw the GL context - * @param reason If not provided, only redraw if deemed necessary. Otherwise redraw regardless of internal states. - * @returns - */ - redraw(reason) { - if (!this.layerManager) { - return; - } - let redrawReason = this.needsRedraw({ clearRedrawFlags: true }); - redrawReason = reason || redrawReason; - if (!redrawReason) { - return; - } - this.stats.get("Redraw Count").incrementCount(); - if (this.props._customRender) { - this.props._customRender(redrawReason); - } else { - this._drawLayers(redrawReason); - } - } - /** Flag indicating that the Deck instance has initialized its resources and it's safe to call public methods. */ - get isInitialized() { - return this.viewManager !== null; - } - /** Get a list of views that are currently rendered */ - getViews() { - assert9(this.viewManager); - return this.viewManager.views; - } - /** Get a list of viewports that are currently rendered. - * @param rect If provided, only returns viewports within the given bounding box. - */ - getViewports(rect) { - assert9(this.viewManager); - return this.viewManager.getViewports(rect); - } - /** Get the current canvas element. */ - getCanvas() { - return this.canvas; - } - /** Query the object rendered on top at a given point */ - pickObject(opts) { - const infos = this._pick("pickObject", "pickObject Time", opts).result; - return infos.length ? infos[0] : null; - } - /* Query all rendered objects at a given point */ - pickMultipleObjects(opts) { - opts.depth = opts.depth || 10; - return this._pick("pickObject", "pickMultipleObjects Time", opts).result; - } - /* Query all objects rendered on top within a bounding box */ - pickObjects(opts) { - return this._pick("pickObjects", "pickObjects Time", opts); - } - /** Experimental - * Add a global resource for sharing among layers - */ - _addResources(resources, forceUpdate = false) { - for (const id in resources) { - this.layerManager.resourceManager.add({ resourceId: id, data: resources[id], forceUpdate }); - } - } - /** Experimental - * Remove a global resource - */ - _removeResources(resourceIds) { - for (const id of resourceIds) { - this.layerManager.resourceManager.remove(id); - } - } - /** Experimental - * Register a default effect. Effects will be sorted by order, those with a low order will be rendered first - */ - _addDefaultEffect(effect) { - this.effectManager.addDefaultEffect(effect); - } - _addDefaultShaderModule(module) { - this.layerManager.addDefaultShaderModule(module); - } - _removeDefaultShaderModule(module) { - this.layerManager?.removeDefaultShaderModule(module); - } - _pick(method, statKey, opts) { - assert9(this.deckPicker); - const { stats } = this; - stats.get("Pick Count").incrementCount(); - stats.get(statKey).timeStart(); - const infos = this.deckPicker[method]({ - // layerManager, viewManager and effectManager are always defined if deckPicker is - layers: this.layerManager.getLayers(opts), - views: this.viewManager.getViews(), - viewports: this.getViewports(opts), - onViewportActive: this.layerManager.activateViewport, - effects: this.effectManager.getEffects(), - ...opts - }); - stats.get(statKey).timeEnd(); - return infos; - } - /** Resolve props.canvas to element */ - _createCanvas(props) { - let canvas2 = props.canvas; - if (typeof canvas2 === "string") { - canvas2 = document.getElementById(canvas2); - assert9(canvas2); - } - if (!canvas2) { - canvas2 = document.createElement("canvas"); - canvas2.id = props.id || "deckgl-overlay"; - const parent = props.parent || document.body; - parent.appendChild(canvas2); - } - Object.assign(canvas2.style, props.style); - return canvas2; - } - /** Updates canvas width and/or height, if provided as props */ - _setCanvasSize(props) { - if (!this.canvas) { - return; - } - const { width, height } = props; - if (width || width === 0) { - const cssWidth = Number.isFinite(width) ? `${width}px` : width; - this.canvas.style.width = cssWidth; - } - if (height || height === 0) { - const cssHeight = Number.isFinite(height) ? `${height}px` : height; - this.canvas.style.position = props.style?.position || "absolute"; - this.canvas.style.height = cssHeight; - } - } - /** If canvas size has changed, reads out the new size and update */ - _updateCanvasSize() { - const { canvas: canvas2 } = this; - if (!canvas2) { - return; - } - const newWidth = canvas2.clientWidth ?? canvas2.width; - const newHeight = canvas2.clientHeight ?? canvas2.height; - if (newWidth !== this.width || newHeight !== this.height) { - this.width = newWidth; - this.height = newHeight; - this.viewManager?.setProps({ width: newWidth, height: newHeight }); - this.layerManager?.activateViewport(this.getViewports()[0]); - this.props.onResize({ width: newWidth, height: newHeight }); - } - } - _createAnimationLoop(deviceOrPromise, props) { - const { - // width, - // height, - gl, - // deviceProps, - // glOptions, - // debug, - onError, - // onBeforeRender, - // onAfterRender, - useDevicePixels - } = props; - return new AnimationLoop({ - device: deviceOrPromise, - useDevicePixels, - // TODO v9 - autoResizeDrawingBuffer: !gl, - // do not auto resize external context - autoResizeViewport: false, - // @ts-expect-error luma.gl needs to accept Promise return value - onInitialize: (context) => this._setDevice(context.device), - onRender: this._onRenderFrame.bind(this), - // @ts-expect-error typing mismatch: AnimationLoop does not accept onError:null - onError - // onBeforeRender, - // onAfterRender, - }); - } - // Get the most relevant view state: props.viewState, if supplied, shadows internal viewState - // TODO: For backwards compatibility ensure numeric width and height is added to the viewState - _getViewState() { - return this.props.viewState || this.viewState; - } - // Get the view descriptor list - _getViews() { - const { views } = this.props; - const normalizedViews = Array.isArray(views) ? views : ( - // If null, default to a full screen map view port - views ? [views] : [new map_view_default({ id: "default-view" })] - ); - if (normalizedViews.length && this.props.controller) { - normalizedViews[0].props.controller = this.props.controller; - } - return normalizedViews; - } - _onContextLost() { - const { onError } = this.props; - if (this.animationLoop && onError) { - onError(new Error("WebGL context is lost")); - } - } - /** Actually run picking */ - _pickAndCallback() { - const { _pickRequest } = this; - if (_pickRequest.event) { - const { result, emptyInfo } = this._pick("pickObject", "pickObject Time", _pickRequest); - this.cursorState.isHovering = result.length > 0; - let pickedInfo = emptyInfo; - let handled = false; - for (const info of result) { - pickedInfo = info; - handled = info.layer?.onHover(info, _pickRequest.event) || handled; - } - if (!handled) { - this.props.onHover?.(pickedInfo, _pickRequest.event); - this.widgetManager.onHover(pickedInfo, _pickRequest.event); - } - _pickRequest.event = null; - } - } - _updateCursor() { - const container = this.props.parent || this.canvas; - if (container) { - container.style.cursor = this.props.getCursor(this.cursorState); - } - } - _setDevice(device) { - this.device = device; - if (!this.animationLoop) { - return; - } - if (!this.canvas) { - this.canvas = this.device.canvasContext?.canvas; - } - this.device.setParametersWebGL({ - blend: true, - blendFunc: [770, 771, 1, 771], - polygonOffsetFill: true, - depthTest: true, - depthFunc: 515 - }); - this.props.onDeviceInitialized(this.device); - if (this.device instanceof WebGLDevice) { - this.props.onWebGLInitialized(this.device.gl); - } - const timeline = new Timeline(); - timeline.play(); - this.animationLoop.attachTimeline(timeline); - this.eventManager = new EventManager(this.props.parent || this.canvas, { - touchAction: this.props.touchAction, - recognizerOptions: this.props.eventRecognizerOptions, - events: { - pointerdown: this._onPointerDown, - pointermove: this._onPointerMove, - pointerleave: this._onPointerMove - } - }); - for (const eventType in EVENTS) { - this.eventManager.on(eventType, this._onEvent); - } - this.viewManager = new ViewManager({ - timeline, - eventManager: this.eventManager, - onViewStateChange: this._onViewStateChange.bind(this), - onInteractionStateChange: this._onInteractionStateChange.bind(this), - views: this._getViews(), - viewState: this._getViewState(), - width: this.width, - height: this.height - }); - const viewport = this.viewManager.getViewports()[0]; - this.layerManager = new LayerManager(this.device, { - deck: this, - stats: this.stats, - viewport, - timeline - }); - this.effectManager = new EffectManager({ - deck: this, - device: this.device - }); - this.deckRenderer = new DeckRenderer(this.device); - this.deckPicker = new DeckPicker(this.device); - this.widgetManager = new WidgetManager({ - deck: this, - parentElement: this.canvas?.parentElement - }); - this.widgetManager.addDefault(new Tooltip()); - this.setProps(this.props); - this._updateCanvasSize(); - this.props.onLoad(); - } - /** Internal only: default render function (redraw all layers and views) */ - _drawLayers(redrawReason, renderOptions) { - const { device, gl } = this.layerManager.context; - this.props.onBeforeRender({ device, gl }); - const opts = { - target: this.props._framebuffer, - layers: this.layerManager.getLayers(), - viewports: this.viewManager.getViewports(), - onViewportActive: this.layerManager.activateViewport, - views: this.viewManager.getViews(), - pass: "screen", - effects: this.effectManager.getEffects(), - ...renderOptions - }; - this.deckRenderer?.renderLayers(opts); - if (opts.pass === "screen") { - this.widgetManager.onRedraw({ - viewports: opts.viewports, - layers: opts.layers - }); - } - this.props.onAfterRender({ device, gl }); - } - // Callbacks - _onRenderFrame() { - this._getFrameStats(); - if (this._metricsCounter++ % 60 === 0) { - this._getMetrics(); - this.stats.reset(); - log_default.table(4, this.metrics)(); - if (this.props._onMetrics) { - this.props._onMetrics(this.metrics); - } - } - this._updateCanvasSize(); - this._updateCursor(); - this.layerManager.updateLayers(); - this._pickAndCallback(); - this.redraw(); - if (this.viewManager) { - this.viewManager.updateViewStates(); - } - } - // Callbacks - _onViewStateChange(params) { - const viewState = this.props.onViewStateChange(params) || params.viewState; - if (this.viewState) { - this.viewState = { ...this.viewState, [params.viewId]: viewState }; - if (!this.props.viewState) { - if (this.viewManager) { - this.viewManager.setProps({ viewState: this.viewState }); - } - } - } - } - _onInteractionStateChange(interactionState) { - this.cursorState.isDragging = interactionState.isDragging || false; - this.props.onInteractionStateChange(interactionState); - } - _getFrameStats() { - const { stats } = this; - stats.get("frameRate").timeEnd(); - stats.get("frameRate").timeStart(); - const animationLoopStats = this.animationLoop.stats; - stats.get("GPU Time").addTime(animationLoopStats.get("GPU Time").lastTiming); - stats.get("CPU Time").addTime(animationLoopStats.get("CPU Time").lastTiming); - } - _getMetrics() { - const { metrics, stats } = this; - metrics.fps = stats.get("frameRate").getHz(); - metrics.setPropsTime = stats.get("setProps Time").time; - metrics.updateAttributesTime = stats.get("Update Attributes").time; - metrics.framesRedrawn = stats.get("Redraw Count").count; - metrics.pickTime = stats.get("pickObject Time").time + stats.get("pickMultipleObjects Time").time + stats.get("pickObjects Time").time; - metrics.pickCount = stats.get("Pick Count").count; - metrics.gpuTime = stats.get("GPU Time").time; - metrics.cpuTime = stats.get("CPU Time").time; - metrics.gpuTimePerFrame = stats.get("GPU Time").getAverageTime(); - metrics.cpuTimePerFrame = stats.get("CPU Time").getAverageTime(); - const memoryStats = luma.stats.get("Memory Usage"); - metrics.bufferMemory = memoryStats.get("Buffer Memory").count; - metrics.textureMemory = memoryStats.get("Texture Memory").count; - metrics.renderbufferMemory = memoryStats.get("Renderbuffer Memory").count; - metrics.gpuMemory = memoryStats.get("GPU Memory").count; - } -}; -Deck.defaultProps = defaultProps; -Deck.VERSION = VERSION5; -var deck_default = Deck; - -// node_modules/@deck.gl/core/dist/lib/attribute/gl-utils.js -function typedArrayFromDataType(type) { - switch (type) { - case "float64": - return Float64Array; - case "uint8": - case "unorm8": - return Uint8ClampedArray; - default: - return getTypedArrayFromDataType(type); - } -} -var dataTypeFromTypedArray = getDataTypeFromTypedArray; -function getBufferAttributeLayout(name2, accessor) { - return { - attribute: name2, - // @ts-expect-error Not all combinations are valid vertex formats; it's up to DataColumn to ensure - format: accessor.size > 1 ? `${accessor.type}x${accessor.size}` : accessor.type, - byteOffset: accessor.offset || 0 - // Note stride is set on the top level - }; -} -function getStride(accessor) { - return accessor.stride || accessor.size * accessor.bytesPerElement; -} -function bufferLayoutEqual(accessor1, accessor2) { - return accessor1.type === accessor2.type && accessor1.size === accessor2.size && getStride(accessor1) === getStride(accessor2) && (accessor1.offset || 0) === (accessor2.offset || 0); -} - -// node_modules/@deck.gl/core/dist/lib/attribute/data-column.js -function resolveShaderAttribute(baseAccessor, shaderAttributeOptions) { - if (shaderAttributeOptions.offset) { - log_default.removed("shaderAttribute.offset", "vertexOffset, elementOffset")(); - } - const stride = getStride(baseAccessor); - const vertexOffset = shaderAttributeOptions.vertexOffset !== void 0 ? shaderAttributeOptions.vertexOffset : baseAccessor.vertexOffset || 0; - const elementOffset = shaderAttributeOptions.elementOffset || 0; - const offset = ( - // offsets defined by the attribute - vertexOffset * stride + elementOffset * baseAccessor.bytesPerElement + // offsets defined by external buffers if any - (baseAccessor.offset || 0) - ); - return { - ...shaderAttributeOptions, - offset, - stride - }; -} -function resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) { - const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions); - return { - high: resolvedOptions, - low: { - ...resolvedOptions, - offset: resolvedOptions.offset + baseAccessor.size * 4 - } - }; -} -var DataColumn = class { - /* eslint-disable max-statements */ - constructor(device, opts, state) { - this._buffer = null; - this.device = device; - this.id = opts.id || ""; - this.size = opts.size || 1; - const logicalType = opts.logicalType || opts.type; - const doublePrecision = logicalType === "float64"; - let { defaultValue } = opts; - defaultValue = Number.isFinite(defaultValue) ? [defaultValue] : defaultValue || new Array(this.size).fill(0); - let bufferType; - if (doublePrecision) { - bufferType = "float32"; - } else if (!logicalType && opts.isIndexed) { - bufferType = "uint32"; - } else { - bufferType = logicalType || "float32"; - } - let defaultType = typedArrayFromDataType(logicalType || bufferType); - this.doublePrecision = doublePrecision; - if (doublePrecision && opts.fp64 === false) { - defaultType = Float32Array; - } - this.value = null; - this.settings = { - ...opts, - defaultType, - defaultValue, - logicalType, - type: bufferType, - normalized: bufferType.includes("norm"), - size: this.size, - bytesPerElement: defaultType.BYTES_PER_ELEMENT - }; - this.state = { - ...state, - externalBuffer: null, - bufferAccessor: this.settings, - allocatedValue: null, - numInstances: 0, - bounds: null, - constant: false - }; - } - /* eslint-enable max-statements */ - get isConstant() { - return this.state.constant; - } - get buffer() { - return this._buffer; - } - get byteOffset() { - const accessor = this.getAccessor(); - if (accessor.vertexOffset) { - return accessor.vertexOffset * getStride(accessor); - } - return 0; - } - get numInstances() { - return this.state.numInstances; - } - set numInstances(n) { - this.state.numInstances = n; - } - delete() { - if (this._buffer) { - this._buffer.delete(); - this._buffer = null; - } - typed_array_manager_default.release(this.state.allocatedValue); - } - getBuffer() { - if (this.state.constant) { - return null; - } - return this.state.externalBuffer || this._buffer; - } - getValue(attributeName = this.id, options = null) { - const result = {}; - if (this.state.constant) { - const value = this.value; - if (options) { - const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options); - const offset = shaderAttributeDef.offset / value.BYTES_PER_ELEMENT; - const size = shaderAttributeDef.size || this.size; - result[attributeName] = value.subarray(offset, offset + size); - } else { - result[attributeName] = value; - } - } else { - result[attributeName] = this.getBuffer(); - } - if (this.doublePrecision) { - if (this.value instanceof Float64Array) { - result[`${attributeName}64Low`] = result[attributeName]; - } else { - result[`${attributeName}64Low`] = new Float32Array(this.size); - } - } - return result; - } - _getBufferLayout(attributeName = this.id, options = null) { - const accessor = this.getAccessor(); - const attributes = []; - const result = { - name: this.id, - byteStride: getStride(accessor), - attributes - }; - if (this.doublePrecision) { - const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(accessor, options || {}); - attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...doubleShaderAttributeDefs.high }), getBufferAttributeLayout(`${attributeName}64Low`, { - ...accessor, - ...doubleShaderAttributeDefs.low - })); - } else if (options) { - const shaderAttributeDef = resolveShaderAttribute(accessor, options); - attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...shaderAttributeDef })); - } else { - attributes.push(getBufferAttributeLayout(attributeName, accessor)); - } - return result; - } - setAccessor(accessor) { - this.state.bufferAccessor = accessor; - } - getAccessor() { - return this.state.bufferAccessor; - } - // Returns [min: Array(size), max: Array(size)] - /* eslint-disable max-depth */ - getBounds() { - if (this.state.bounds) { - return this.state.bounds; - } - let result = null; - if (this.state.constant && this.value) { - const min7 = Array.from(this.value); - result = [min7, min7]; - } else { - const { value, numInstances, size } = this; - const len8 = numInstances * size; - if (value && len8 && value.length >= len8) { - const min7 = new Array(size).fill(Infinity); - const max7 = new Array(size).fill(-Infinity); - for (let i = 0; i < len8; ) { - for (let j = 0; j < size; j++) { - const v = value[i++]; - if (v < min7[j]) - min7[j] = v; - if (v > max7[j]) - max7[j] = v; - } - } - result = [min7, max7]; - } - } - this.state.bounds = result; - return result; - } - // returns true if success - // eslint-disable-next-line max-statements - setData(data) { - const { state } = this; - let opts; - if (ArrayBuffer.isView(data)) { - opts = { value: data }; - } else if (data instanceof Buffer2) { - opts = { buffer: data }; - } else { - opts = data; - } - const accessor = { ...this.settings, ...opts }; - if (ArrayBuffer.isView(opts.value)) { - if (!opts.type) { - const is64Bit = this.doublePrecision && opts.value instanceof Float64Array; - if (is64Bit) { - accessor.type = "float32"; - } else { - const type = dataTypeFromTypedArray(opts.value); - accessor.type = accessor.normalized ? type.replace("int", "norm") : type; - } - } - accessor.bytesPerElement = opts.value.BYTES_PER_ELEMENT; - accessor.stride = getStride(accessor); - } - state.bounds = null; - if (opts.constant) { - let value = opts.value; - value = this._normalizeValue(value, [], 0); - if (this.settings.normalized) { - value = this.normalizeConstant(value); - } - const hasChanged = !state.constant || !this._areValuesEqual(value, this.value); - if (!hasChanged) { - return false; - } - state.externalBuffer = null; - state.constant = true; - this.value = ArrayBuffer.isView(value) ? value : new Float32Array(value); - } else if (opts.buffer) { - const buffer = opts.buffer; - state.externalBuffer = buffer; - state.constant = false; - this.value = opts.value || null; - } else if (opts.value) { - this._checkExternalBuffer(opts); - let value = opts.value; - state.externalBuffer = null; - state.constant = false; - this.value = value; - let { buffer } = this; - const stride = getStride(accessor); - const byteOffset = (accessor.vertexOffset || 0) * stride; - if (this.doublePrecision && value instanceof Float64Array) { - value = toDoublePrecisionArray(value, accessor); - } - if (this.settings.isIndexed) { - const ArrayType2 = this.settings.defaultType; - if (value.constructor !== ArrayType2) { - value = new ArrayType2(value); - } - } - const requiredBufferSize = value.byteLength + byteOffset + stride * 2; - if (!buffer || buffer.byteLength < requiredBufferSize) { - buffer = this._createBuffer(requiredBufferSize); - } - buffer.write(value, byteOffset); - } - this.setAccessor(accessor); - return true; - } - updateSubBuffer(opts = {}) { - this.state.bounds = null; - const value = this.value; - const { startOffset = 0, endOffset } = opts; - this.buffer.write(this.doublePrecision && value instanceof Float64Array ? toDoublePrecisionArray(value, { - size: this.size, - startIndex: startOffset, - endIndex: endOffset - }) : value.subarray(startOffset, endOffset), startOffset * value.BYTES_PER_ELEMENT + this.byteOffset); - } - allocate(numInstances, copy12 = false) { - const { state } = this; - const oldValue = state.allocatedValue; - const value = typed_array_manager_default.allocate(oldValue, numInstances + 1, { - size: this.size, - type: this.settings.defaultType, - copy: copy12 - }); - this.value = value; - const { byteOffset } = this; - let { buffer } = this; - if (!buffer || buffer.byteLength < value.byteLength + byteOffset) { - buffer = this._createBuffer(value.byteLength + byteOffset); - if (copy12 && oldValue) { - buffer.write(oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue, byteOffset); - } - } - state.allocatedValue = value; - state.constant = false; - state.externalBuffer = null; - this.setAccessor(this.settings); - return true; - } - // PRIVATE HELPER METHODS - _checkExternalBuffer(opts) { - const { value } = opts; - if (!ArrayBuffer.isView(value)) { - throw new Error(`Attribute ${this.id} value is not TypedArray`); - } - const ArrayType2 = this.settings.defaultType; - let illegalArrayType = false; - if (this.doublePrecision) { - illegalArrayType = value.BYTES_PER_ELEMENT < 4; - } - if (illegalArrayType) { - throw new Error(`Attribute ${this.id} does not support ${value.constructor.name}`); - } - if (!(value instanceof ArrayType2) && this.settings.normalized && !("normalized" in opts)) { - log_default.warn(`Attribute ${this.id} is normalized`)(); - } - } - // https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer - normalizeConstant(value) { - switch (this.settings.type) { - case "snorm8": - return new Float32Array(value).map((x) => (x + 128) / 255 * 2 - 1); - case "snorm16": - return new Float32Array(value).map((x) => (x + 32768) / 65535 * 2 - 1); - case "unorm8": - return new Float32Array(value).map((x) => x / 255); - case "unorm16": - return new Float32Array(value).map((x) => x / 65535); - default: - return value; - } - } - /* check user supplied values and apply fallback */ - _normalizeValue(value, out, start) { - const { defaultValue, size } = this.settings; - if (Number.isFinite(value)) { - out[start] = value; - return out; - } - if (!value) { - let i = size; - while (--i >= 0) { - out[start + i] = defaultValue[i]; - } - return out; - } - switch (size) { - case 4: - out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3]; - case 3: - out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2]; - case 2: - out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1]; - case 1: - out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0]; - break; - default: - let i = size; - while (--i >= 0) { - out[start + i] = Number.isFinite(value[i]) ? value[i] : defaultValue[i]; - } - } - return out; - } - _areValuesEqual(value1, value2) { - if (!value1 || !value2) { - return false; - } - const { size } = this; - for (let i = 0; i < size; i++) { - if (value1[i] !== value2[i]) { - return false; - } - } - return true; - } - _createBuffer(byteLength) { - if (this._buffer) { - this._buffer.destroy(); - } - const { isIndexed, type } = this.settings; - this._buffer = this.device.createBuffer({ - ...this._buffer?.props, - id: this.id, - usage: isIndexed ? Buffer2.INDEX : Buffer2.VERTEX, - indexType: isIndexed ? type : void 0, - byteLength - }); - return this._buffer; - } -}; - -// node_modules/@deck.gl/core/dist/utils/iterable-utils.js -var EMPTY_ARRAY = []; -var placeholderArray = []; -function createIterable(data, startRow = 0, endRow = Infinity) { - let iterable = EMPTY_ARRAY; - const objectInfo = { - index: -1, - data, - // visitor can optionally utilize this to avoid constructing a new array for every object - target: [] - }; - if (!data) { - iterable = EMPTY_ARRAY; - } else if (typeof data[Symbol.iterator] === "function") { - iterable = data; - } else if (data.length > 0) { - placeholderArray.length = data.length; - iterable = placeholderArray; - } - if (startRow > 0 || Number.isFinite(endRow)) { - iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow); - objectInfo.index = startRow - 1; - } - return { iterable, objectInfo }; -} -function isAsyncIterable2(data) { - return data && data[Symbol.asyncIterator]; -} -function getAccessorFromBuffer(typedArray, options) { - const { size, stride, offset, startIndices, nested } = options; - const bytesPerElement = typedArray.BYTES_PER_ELEMENT; - const elementStride = stride ? stride / bytesPerElement : size; - const elementOffset = offset ? offset / bytesPerElement : 0; - const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride); - return (_, { index: index2, target }) => { - if (!startIndices) { - const sourceIndex = index2 * elementStride + elementOffset; - for (let j = 0; j < size; j++) { - target[j] = typedArray[sourceIndex + j]; - } - return target; - } - const startIndex = startIndices[index2]; - const endIndex = startIndices[index2 + 1] || vertexCount; - let result; - if (nested) { - result = new Array(endIndex - startIndex); - for (let i = startIndex; i < endIndex; i++) { - const sourceIndex = i * elementStride + elementOffset; - target = new Array(size); - for (let j = 0; j < size; j++) { - target[j] = typedArray[sourceIndex + j]; - } - result[i - startIndex] = target; - } - } else if (elementStride === size) { - result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset); - } else { - result = new typedArray.constructor((endIndex - startIndex) * size); - let targetIndex = 0; - for (let i = startIndex; i < endIndex; i++) { - const sourceIndex = i * elementStride + elementOffset; - for (let j = 0; j < size; j++) { - result[targetIndex++] = typedArray[sourceIndex + j]; - } - } - } - return result; - }; -} - -// node_modules/@deck.gl/core/dist/utils/range.js -var EMPTY = []; -var FULL = [[0, Infinity]]; -function add9(rangeList, range) { - if (rangeList === FULL) { - return rangeList; - } - if (range[0] < 0) { - range[0] = 0; - } - if (range[0] >= range[1]) { - return rangeList; - } - const newRangeList = []; - const len8 = rangeList.length; - let insertPosition = 0; - for (let i = 0; i < len8; i++) { - const range0 = rangeList[i]; - if (range0[1] < range[0]) { - newRangeList.push(range0); - insertPosition = i + 1; - } else if (range0[0] > range[1]) { - newRangeList.push(range0); - } else { - range = [Math.min(range0[0], range[0]), Math.max(range0[1], range[1])]; - } - } - newRangeList.splice(insertPosition, 0, range); - return newRangeList; -} - -// node_modules/@deck.gl/core/dist/lib/attribute/transition-settings.js -var DEFAULT_TRANSITION_SETTINGS = { - interpolation: { - duration: 0, - easing: (t) => t - }, - spring: { - stiffness: 0.05, - damping: 0.5 - } -}; -function normalizeTransitionSettings(userSettings, layerSettings) { - if (!userSettings) { - return null; - } - if (Number.isFinite(userSettings)) { - userSettings = { type: "interpolation", duration: userSettings }; - } - const type = userSettings.type || "interpolation"; - return { - ...DEFAULT_TRANSITION_SETTINGS[type], - ...layerSettings, - ...userSettings, - type - }; -} - -// node_modules/@deck.gl/core/dist/lib/attribute/attribute.js -var Attribute2 = class extends DataColumn { - constructor(device, opts) { - super(device, opts, { - startIndices: null, - lastExternalBuffer: null, - binaryValue: null, - binaryAccessor: null, - needsUpdate: true, - needsRedraw: false, - layoutChanged: false, - updateRanges: FULL - }); - this.constant = false; - this.settings.update = opts.update || (opts.accessor ? this._autoUpdater : void 0); - Object.seal(this.settings); - Object.seal(this.state); - this._validateAttributeUpdaters(); - } - get startIndices() { - return this.state.startIndices; - } - set startIndices(layout) { - this.state.startIndices = layout; - } - needsUpdate() { - return this.state.needsUpdate; - } - needsRedraw({ clearChangedFlags = false } = {}) { - const needsRedraw = this.state.needsRedraw; - this.state.needsRedraw = needsRedraw && !clearChangedFlags; - return needsRedraw; - } - layoutChanged() { - return this.state.layoutChanged; - } - setAccessor(accessor) { - var _a2; - (_a2 = this.state).layoutChanged || (_a2.layoutChanged = !bufferLayoutEqual(accessor, this.getAccessor())); - super.setAccessor(accessor); - } - getUpdateTriggers() { - const { accessor } = this.settings; - return [this.id].concat(typeof accessor !== "function" && accessor || []); - } - supportsTransition() { - return Boolean(this.settings.transition); - } - // Resolve transition settings object if transition is enabled, otherwise `null` - getTransitionSetting(opts) { - if (!opts || !this.supportsTransition()) { - return null; - } - const { accessor } = this.settings; - const layerSettings = this.settings.transition; - const userSettings = Array.isArray(accessor) ? ( - // @ts-ignore - opts[accessor.find((a) => opts[a])] - ) : ( - // @ts-ignore - opts[accessor] - ); - return normalizeTransitionSettings(userSettings, layerSettings); - } - setNeedsUpdate(reason = this.id, dataRange) { - this.state.needsUpdate = this.state.needsUpdate || reason; - this.setNeedsRedraw(reason); - if (dataRange) { - const { startRow = 0, endRow = Infinity } = dataRange; - this.state.updateRanges = add9(this.state.updateRanges, [startRow, endRow]); - } else { - this.state.updateRanges = FULL; - } - } - clearNeedsUpdate() { - this.state.needsUpdate = false; - this.state.updateRanges = EMPTY; - } - setNeedsRedraw(reason = this.id) { - this.state.needsRedraw = this.state.needsRedraw || reason; - } - allocate(numInstances) { - const { state, settings } = this; - if (settings.noAlloc) { - return false; - } - if (settings.update) { - super.allocate(numInstances, state.updateRanges !== FULL); - return true; - } - return false; - } - updateBuffer({ numInstances, data, props, context }) { - if (!this.needsUpdate()) { - return false; - } - const { state: { updateRanges }, settings: { update, noAlloc } } = this; - let updated = true; - if (update) { - for (const [startRow, endRow] of updateRanges) { - update.call(context, this, { data, startRow, endRow, props, numInstances }); - } - if (!this.value) { - } else if (this.constant || !this.buffer || this.buffer.byteLength < this.value.byteLength + this.byteOffset) { - this.setData({ - value: this.value, - constant: this.constant - }); - this.constant = false; - } else { - for (const [startRow, endRow] of updateRanges) { - const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0; - const endOffset = Number.isFinite(endRow) ? this.getVertexOffset(endRow) : noAlloc || !Number.isFinite(numInstances) ? this.value.length : numInstances * this.size; - super.updateSubBuffer({ startOffset, endOffset }); - } - } - this._checkAttributeArray(); - } else { - updated = false; - } - this.clearNeedsUpdate(); - this.setNeedsRedraw(); - return updated; - } - // Use generic value - // Returns true if successful - setConstantValue(value) { - if (value === void 0 || typeof value === "function") { - return false; - } - const hasChanged = this.setData({ constant: true, value }); - if (hasChanged) { - this.setNeedsRedraw(); - } - this.clearNeedsUpdate(); - return true; - } - // Use external buffer - // Returns true if successful - // eslint-disable-next-line max-statements - setExternalBuffer(buffer) { - const { state } = this; - if (!buffer) { - state.lastExternalBuffer = null; - return false; - } - this.clearNeedsUpdate(); - if (state.lastExternalBuffer === buffer) { - return true; - } - state.lastExternalBuffer = buffer; - this.setNeedsRedraw(); - this.setData(buffer); - return true; - } - // Binary value is a typed array packed from mapping the source data with the accessor - // If the returned value from the accessor is the same as the attribute value, set it directly - // Otherwise use the auto updater for transform/normalization - setBinaryValue(buffer, startIndices = null) { - const { state, settings } = this; - if (!buffer) { - state.binaryValue = null; - state.binaryAccessor = null; - return false; - } - if (settings.noAlloc) { - return false; - } - if (state.binaryValue === buffer) { - this.clearNeedsUpdate(); - return true; - } - state.binaryValue = buffer; - this.setNeedsRedraw(); - const needsUpdate = settings.transform || startIndices !== this.startIndices; - if (needsUpdate) { - if (ArrayBuffer.isView(buffer)) { - buffer = { value: buffer }; - } - const binaryValue = buffer; - assert9(ArrayBuffer.isView(binaryValue.value), `invalid ${settings.accessor}`); - const needsNormalize = Boolean(binaryValue.size) && binaryValue.size !== this.size; - state.binaryAccessor = getAccessorFromBuffer(binaryValue.value, { - size: binaryValue.size || this.size, - stride: binaryValue.stride, - offset: binaryValue.offset, - startIndices, - nested: needsNormalize - }); - return false; - } - this.clearNeedsUpdate(); - this.setData(buffer); - return true; - } - getVertexOffset(row) { - const { startIndices } = this; - const vertexIndex = startIndices ? row < startIndices.length ? startIndices[row] : this.numInstances : row; - return vertexIndex * this.size; - } - getValue() { - const shaderAttributeDefs = this.settings.shaderAttributes; - const result = super.getValue(); - if (!shaderAttributeDefs) { - return result; - } - for (const shaderAttributeName in shaderAttributeDefs) { - Object.assign(result, super.getValue(shaderAttributeName, shaderAttributeDefs[shaderAttributeName])); - } - return result; - } - /** Generate WebGPU-style buffer layout descriptor from this attribute */ - getBufferLayout(modelInfo) { - this.state.layoutChanged = false; - const shaderAttributeDefs = this.settings.shaderAttributes; - const result = super._getBufferLayout(); - const { stepMode } = this.settings; - if (stepMode === "dynamic") { - result.stepMode = modelInfo ? modelInfo.isInstanced ? "instance" : "vertex" : "instance"; - } else { - result.stepMode = stepMode ?? "vertex"; - } - if (!shaderAttributeDefs) { - return result; - } - for (const shaderAttributeName in shaderAttributeDefs) { - const map3 = super._getBufferLayout(shaderAttributeName, shaderAttributeDefs[shaderAttributeName]); - result.attributes.push(...map3.attributes); - } - return result; - } - /* eslint-disable max-depth, max-statements */ - _autoUpdater(attribute, { data, startRow, endRow, props, numInstances }) { - if (attribute.constant) { - return; - } - const { settings, state, value, size, startIndices } = attribute; - const { accessor, transform } = settings; - const accessorFunc = state.binaryAccessor || // @ts-ignore - (typeof accessor === "function" ? accessor : props[accessor]); - assert9(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`); - let i = attribute.getVertexOffset(startRow); - const { iterable, objectInfo } = createIterable(data, startRow, endRow); - for (const object of iterable) { - objectInfo.index++; - let objectValue = accessorFunc(object, objectInfo); - if (transform) { - objectValue = transform.call(this, objectValue); - } - if (startIndices) { - const numVertices = (objectInfo.index < startIndices.length - 1 ? startIndices[objectInfo.index + 1] : numInstances) - startIndices[objectInfo.index]; - if (objectValue && Array.isArray(objectValue[0])) { - let startIndex = i; - for (const item of objectValue) { - attribute._normalizeValue(item, value, startIndex); - startIndex += size; - } - } else if (objectValue && objectValue.length > size) { - value.set(objectValue, i); - } else { - attribute._normalizeValue(objectValue, objectInfo.target, 0); - fillArray2({ - target: value, - source: objectInfo.target, - start: i, - count: numVertices - }); - } - i += numVertices * size; - } else { - attribute._normalizeValue(objectValue, value, i); - i += size; - } - } - } - /* eslint-enable max-depth, max-statements */ - // Validate deck.gl level fields - _validateAttributeUpdaters() { - const { settings } = this; - const hasUpdater = settings.noAlloc || typeof settings.update === "function"; - if (!hasUpdater) { - throw new Error(`Attribute ${this.id} missing update or accessor`); - } - } - // check that the first few elements of the attribute are reasonable - /* eslint-disable no-fallthrough */ - _checkAttributeArray() { - const { value } = this; - const limit = Math.min(4, this.size); - if (value && value.length >= limit) { - let valid = true; - switch (limit) { - case 4: - valid = valid && Number.isFinite(value[3]); - case 3: - valid = valid && Number.isFinite(value[2]); - case 2: - valid = valid && Number.isFinite(value[1]); - case 1: - valid = valid && Number.isFinite(value[0]); - break; - default: - valid = false; - } - if (!valid) { - throw new Error(`Illegal attribute generated for ${this.id}`); - } - } - } -}; - -// node_modules/@deck.gl/core/dist/utils/array-utils.js -function padArrayChunk(options) { - const { source, target, start = 0, size, getData } = options; - const end = options.end || target.length; - const sourceLength = source.length; - const targetLength = end - start; - if (sourceLength > targetLength) { - target.set(source.subarray(0, targetLength), start); - return; - } - target.set(source, start); - if (!getData) { - return; - } - let i = sourceLength; - while (i < targetLength) { - const datum = getData(i, source); - for (let j = 0; j < size; j++) { - target[start + i] = datum[j] || 0; - i++; - } - } -} -function padArray({ source, target, size, getData, sourceStartIndices, targetStartIndices }) { - if (!sourceStartIndices || !targetStartIndices) { - padArrayChunk({ - source, - target, - size, - getData - }); - return target; - } - let sourceIndex = 0; - let targetIndex = 0; - const getChunkData = getData && ((i, chunk) => getData(i + targetIndex, chunk)); - const n = Math.min(sourceStartIndices.length, targetStartIndices.length); - for (let i = 1; i < n; i++) { - const nextSourceIndex = sourceStartIndices[i] * size; - const nextTargetIndex = targetStartIndices[i] * size; - padArrayChunk({ - source: source.subarray(sourceIndex, nextSourceIndex), - target, - start: targetIndex, - end: nextTargetIndex, - size, - getData: getChunkData - }); - sourceIndex = nextSourceIndex; - targetIndex = nextTargetIndex; - } - if (targetIndex < target.length) { - padArrayChunk({ - // @ts-ignore - source: [], - target, - start: targetIndex, - size, - getData: getChunkData - }); - } - return target; -} - -// node_modules/@deck.gl/core/dist/transitions/gpu-transition-utils.js -function cloneAttribute(attribute) { - const { device, settings, value } = attribute; - const newAttribute = new Attribute2(device, settings); - newAttribute.setData({ - value: value instanceof Float64Array ? new Float64Array(0) : new Float32Array(0), - normalized: settings.normalized - }); - return newAttribute; -} -function getAttributeTypeFromSize(size) { - switch (size) { - case 1: - return "float"; - case 2: - return "vec2"; - case 3: - return "vec3"; - case 4: - return "vec4"; - default: - throw new Error(`No defined attribute type for size "${size}"`); - } -} -function getFloat32VertexFormat(size) { - switch (size) { - case 1: - return "float32"; - case 2: - return "float32x2"; - case 3: - return "float32x3"; - case 4: - return "float32x4"; - default: - throw new Error("invalid type size"); - } -} -function cycleBuffers(buffers) { - buffers.push(buffers.shift()); -} -function getAttributeBufferLength(attribute, numInstances) { - const { doublePrecision, settings, value, size } = attribute; - const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1; - let maxVertexOffset = 0; - const { shaderAttributes } = attribute.settings; - if (shaderAttributes) { - for (const shaderAttribute of Object.values(shaderAttributes)) { - maxVertexOffset = Math.max(maxVertexOffset, shaderAttribute.vertexOffset ?? 0); - } - } - return (settings.noAlloc ? value.length : (numInstances + maxVertexOffset) * size) * multiplier; -} -function matchBuffer({ device, source, target }) { - if (!target || target.byteLength < source.byteLength) { - target?.destroy(); - target = device.createBuffer({ - byteLength: source.byteLength, - usage: source.usage - }); - } - return target; -} -function padBuffer({ device, buffer, attribute, fromLength, toLength, fromStartIndices, getData = (x) => x }) { - const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1; - const size = attribute.size * precisionMultiplier; - const byteOffset = attribute.byteOffset; - const targetByteOffset = attribute.settings.bytesPerElement < 4 ? byteOffset / attribute.settings.bytesPerElement * 4 : byteOffset; - const toStartIndices = attribute.startIndices; - const hasStartIndices = fromStartIndices && toStartIndices; - const isConstant = attribute.isConstant; - if (!hasStartIndices && buffer && fromLength >= toLength) { - return buffer; - } - const ArrayType2 = attribute.value instanceof Float64Array ? Float32Array : attribute.value.constructor; - const toData = isConstant ? attribute.value : ( - // TODO(v9.1): Avoid non-portable synchronous reads. - new ArrayType2(attribute.getBuffer().readSyncWebGL(byteOffset, toLength * ArrayType2.BYTES_PER_ELEMENT).buffer) - ); - if (attribute.settings.normalized && !isConstant) { - const getter = getData; - getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk)); - } - const getMissingData = isConstant ? (i, chunk) => getData(toData, chunk) : (i, chunk) => getData(toData.subarray(i + byteOffset, i + byteOffset + size), chunk); - const source = buffer ? new Float32Array(buffer.readSyncWebGL(targetByteOffset, fromLength * 4).buffer) : new Float32Array(0); - const target = new Float32Array(toLength); - padArray({ - source, - target, - sourceStartIndices: fromStartIndices, - targetStartIndices: toStartIndices, - size, - getData: getMissingData - }); - if (!buffer || buffer.byteLength < target.byteLength + targetByteOffset) { - buffer?.destroy(); - buffer = device.createBuffer({ - byteLength: target.byteLength + targetByteOffset, - usage: 35050 - }); - } - buffer.write(target, targetByteOffset); - return buffer; -} - -// node_modules/@deck.gl/core/dist/transitions/gpu-transition.js -var GPUTransitionBase = class { - constructor({ device, attribute, timeline }) { - this.buffers = []; - this.currentLength = 0; - this.device = device; - this.transition = new Transition(timeline); - this.attribute = attribute; - this.attributeInTransition = cloneAttribute(attribute); - this.currentStartIndices = attribute.startIndices; - } - get inProgress() { - return this.transition.inProgress; - } - start(transitionSettings, numInstances, duration = Infinity) { - this.settings = transitionSettings; - this.currentStartIndices = this.attribute.startIndices; - this.currentLength = getAttributeBufferLength(this.attribute, numInstances); - this.transition.start({ ...transitionSettings, duration }); - } - update() { - const updated = this.transition.update(); - if (updated) { - this.onUpdate(); - } - return updated; - } - setBuffer(buffer) { - this.attributeInTransition.setData({ - buffer, - normalized: this.attribute.settings.normalized, - // Retain placeholder value to generate correct shader layout - value: this.attributeInTransition.value - }); - } - cancel() { - this.transition.cancel(); - } - delete() { - this.cancel(); - for (const buffer of this.buffers) { - buffer.destroy(); - } - this.buffers.length = 0; - } -}; - -// node_modules/@deck.gl/core/dist/transitions/gpu-interpolation-transition.js -var GPUInterpolationTransition = class extends GPUTransitionBase { - constructor({ device, attribute, timeline }) { - super({ device, attribute, timeline }); - this.type = "interpolation"; - this.transform = getTransform(device, attribute); - } - start(transitionSettings, numInstances) { - const prevLength = this.currentLength; - const prevStartIndices = this.currentStartIndices; - super.start(transitionSettings, numInstances, transitionSettings.duration); - if (transitionSettings.duration <= 0) { - this.transition.cancel(); - return; - } - const { buffers, attribute } = this; - cycleBuffers(buffers); - buffers[0] = padBuffer({ - device: this.device, - buffer: buffers[0], - attribute, - fromLength: prevLength, - toLength: this.currentLength, - fromStartIndices: prevStartIndices, - getData: transitionSettings.enter - }); - buffers[1] = matchBuffer({ - device: this.device, - source: buffers[0], - target: buffers[1] - }); - this.setBuffer(buffers[1]); - const { transform } = this; - const model = transform.model; - let vertexCount = Math.floor(this.currentLength / attribute.size); - if (useFp64(attribute)) { - vertexCount /= 2; - } - model.setVertexCount(vertexCount); - if (attribute.isConstant) { - model.setAttributes({ aFrom: buffers[0] }); - model.setConstantAttributes({ aTo: attribute.value }); - } else { - model.setAttributes({ - aFrom: buffers[0], - aTo: attribute.getBuffer() - }); - } - transform.transformFeedback.setBuffers({ vCurrent: buffers[1] }); - } - onUpdate() { - const { duration, easing } = this.settings; - const { time } = this.transition; - let t = time / duration; - if (easing) { - t = easing(t); - } - const { model } = this.transform; - model.setUniforms({ time: t }); - this.transform.run({ discard: true }); - } - delete() { - super.delete(); - this.transform.destroy(); - } -}; -var vs5 = `#version 300 es -#define SHADER_NAME interpolation-transition-vertex-shader - -uniform float time; -in ATTRIBUTE_TYPE aFrom; -in ATTRIBUTE_TYPE aTo; -out ATTRIBUTE_TYPE vCurrent; - -void main(void) { - vCurrent = mix(aFrom, aTo, time); - gl_Position = vec4(0.0); -} -`; -var vs64 = `#version 300 es -#define SHADER_NAME interpolation-transition-vertex-shader - -uniform float time; -in ATTRIBUTE_TYPE aFrom; -in ATTRIBUTE_TYPE aFrom64Low; -in ATTRIBUTE_TYPE aTo; -in ATTRIBUTE_TYPE aTo64Low; -out ATTRIBUTE_TYPE vCurrent; -out ATTRIBUTE_TYPE vCurrent64Low; - -vec2 mix_fp64(vec2 a, vec2 b, float x) { - vec2 range = sub_fp64(b, a); - return sum_fp64(a, mul_fp64(range, vec2(x, 0.0))); -} - -void main(void) { - for (int i=0; i 0; - if (!isTransitioning) { - transition.end(); - } - } - delete() { - super.delete(); - this.transform.destroy(); - this.texture.destroy(); - this.framebuffer.destroy(); - } -}; -var vs6 = `#version 300 es -#define SHADER_NAME spring-transition-vertex-shader - -#define EPSILON 0.00001 - -uniform float stiffness; -uniform float damping; -in ATTRIBUTE_TYPE aPrev; -in ATTRIBUTE_TYPE aCur; -in ATTRIBUTE_TYPE aTo; -out ATTRIBUTE_TYPE vNext; -out float vIsTransitioningFlag; - -ATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) { - ATTRIBUTE_TYPE velocity = cur - prev; - ATTRIBUTE_TYPE delta = dest - cur; - ATTRIBUTE_TYPE spring = delta * stiffness; - ATTRIBUTE_TYPE damper = velocity * -1.0 * damping; - return spring + damper + velocity + cur; -} - -void main(void) { - bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON; - vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0; - - vNext = getNextValue(aCur, aPrev, aTo); - gl_Position = vec4(0, 0, 0, 1); - gl_PointSize = 100.0; -} -`; -var fs4 = `#version 300 es -#define SHADER_NAME spring-transition-is-transitioning-fragment-shader - -in float vIsTransitioningFlag; - -out vec4 fragColor; - -void main(void) { - if (vIsTransitioningFlag == 0.0) { - discard; - } - fragColor = vec4(1.0); -}`; -function getTransform2(device, attribute) { - const attributeType = getAttributeTypeFromSize(attribute.size); - const format = getFloat32VertexFormat(attribute.size); - return new BufferTransform(device, { - vs: vs6, - fs: fs4, - bufferLayout: [ - { name: "aPrev", format }, - { name: "aCur", format }, - { name: "aTo", format: attribute.getBufferLayout().attributes[0].format } - ], - varyings: ["vNext"], - defines: { ATTRIBUTE_TYPE: attributeType }, - parameters: { - depthCompare: "always", - blendColorOperation: "max", - blendColorSrcFactor: "one", - blendColorDstFactor: "one", - blendAlphaOperation: "max", - blendAlphaSrcFactor: "one", - blendAlphaDstFactor: "one" - } - }); -} -function getTexture(device) { - return device.createTexture({ - data: new Uint8Array(4), - format: "rgba8unorm", - mipmaps: false, - // dataFormat: GL.RGBA, - width: 1, - height: 1 - }); -} -function getFramebuffer3(device, texture) { - return device.createFramebuffer({ - id: "spring-transition-is-transitioning-framebuffer", - width: 1, - height: 1, - colorAttachments: [texture] - }); -} - -// node_modules/@deck.gl/core/dist/lib/attribute/attribute-transition-manager.js -var TRANSITION_TYPES = { - interpolation: GPUInterpolationTransition, - spring: GPUSpringTransition -}; -var AttributeTransitionManager = class { - constructor(device, { id, timeline }) { - if (!device) - throw new Error("AttributeTransitionManager is constructed without device"); - this.id = id; - this.device = device; - this.timeline = timeline; - this.transitions = {}; - this.needsRedraw = false; - this.numInstances = 1; - } - finalize() { - for (const attributeName in this.transitions) { - this._removeTransition(attributeName); - } - } - /* Public methods */ - // Called when attribute manager updates - // Check the latest attributes for updates. - update({ attributes, transitions, numInstances }) { - this.numInstances = numInstances || 1; - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - const settings = attribute.getTransitionSetting(transitions); - if (!settings) - continue; - this._updateAttribute(attributeName, attribute, settings); - } - for (const attributeName in this.transitions) { - const attribute = attributes[attributeName]; - if (!attribute || !attribute.getTransitionSetting(transitions)) { - this._removeTransition(attributeName); - } - } - } - // Returns `true` if attribute is transition-enabled - hasAttribute(attributeName) { - const transition = this.transitions[attributeName]; - return transition && transition.inProgress; - } - // Get all the animated attributes - getAttributes() { - const animatedAttributes = {}; - for (const attributeName in this.transitions) { - const transition = this.transitions[attributeName]; - if (transition.inProgress) { - animatedAttributes[attributeName] = transition.attributeInTransition; - } - } - return animatedAttributes; - } - /* eslint-disable max-statements */ - // Called every render cycle, run transform feedback - // Returns `true` if anything changes - run() { - if (this.numInstances === 0) { - return false; - } - for (const attributeName in this.transitions) { - const updated = this.transitions[attributeName].update(); - if (updated) { - this.needsRedraw = true; - } - } - const needsRedraw = this.needsRedraw; - this.needsRedraw = false; - return needsRedraw; - } - /* eslint-enable max-statements */ - /* Private methods */ - _removeTransition(attributeName) { - this.transitions[attributeName].delete(); - delete this.transitions[attributeName]; - } - // Check an attributes for updates - // Returns a transition object if a new transition is triggered. - _updateAttribute(attributeName, attribute, settings) { - const transition = this.transitions[attributeName]; - let isNew = !transition || transition.type !== settings.type; - if (isNew) { - if (transition) { - this._removeTransition(attributeName); - } - const TransitionType = TRANSITION_TYPES[settings.type]; - if (TransitionType) { - this.transitions[attributeName] = new TransitionType({ - attribute, - timeline: this.timeline, - device: this.device - }); - } else { - log_default.error(`unsupported transition type '${settings.type}'`)(); - isNew = false; - } - } - if (isNew || attribute.needsRedraw()) { - this.needsRedraw = true; - this.transitions[attributeName].start(settings, this.numInstances); - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/attribute/attribute-manager.js -var TRACE_INVALIDATE = "attributeManager.invalidate"; -var TRACE_UPDATE_START = "attributeManager.updateStart"; -var TRACE_UPDATE_END = "attributeManager.updateEnd"; -var TRACE_ATTRIBUTE_UPDATE_START = "attribute.updateStart"; -var TRACE_ATTRIBUTE_ALLOCATE = "attribute.allocate"; -var TRACE_ATTRIBUTE_UPDATE_END = "attribute.updateEnd"; -var AttributeManager = class { - constructor(device, { id = "attribute-manager", stats, timeline } = {}) { - this.mergeBoundsMemoized = memoize(mergeBounds); - this.id = id; - this.device = device; - this.attributes = {}; - this.updateTriggers = {}; - this.needsRedraw = true; - this.userData = {}; - this.stats = stats; - this.attributeTransitionManager = new AttributeTransitionManager(device, { - id: `${id}-transitions`, - timeline - }); - Object.seal(this); - } - finalize() { - for (const attributeName in this.attributes) { - this.attributes[attributeName].delete(); - } - this.attributeTransitionManager.finalize(); - } - // Returns the redraw flag, optionally clearing it. - // Redraw flag will be set if any attributes attributes changed since - // flag was last cleared. - // - // @param {String} [clearRedrawFlags=false] - whether to clear the flag - // @return {false|String} - reason a redraw is needed. - getNeedsRedraw(opts = { clearRedrawFlags: false }) { - const redraw = this.needsRedraw; - this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags; - return redraw && this.id; - } - // Sets the redraw flag. - // @param {Boolean} redraw=true - setNeedsRedraw() { - this.needsRedraw = true; - } - // Adds attributes - add(attributes) { - this._add(attributes); - } - // Adds attributes - addInstanced(attributes) { - this._add(attributes, { stepMode: "instance" }); - } - /** - * Removes attributes - * Takes an array of attribute names and delete them from - * the attribute map if they exists - * - * @example - * attributeManager.remove(['position']); - * - * @param {Object} attributeNameArray - attribute name array (see above) - */ - remove(attributeNameArray) { - for (const name2 of attributeNameArray) { - if (this.attributes[name2] !== void 0) { - this.attributes[name2].delete(); - delete this.attributes[name2]; - } - } - } - // Marks an attribute for update - invalidate(triggerName, dataRange) { - const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange); - debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes); - } - invalidateAll(dataRange) { - for (const attributeName in this.attributes) { - this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange); - } - debug(TRACE_INVALIDATE, this, "all"); - } - // Ensure all attribute buffers are updated from props or data. - // eslint-disable-next-line complexity - update({ data, numInstances, startIndices = null, transitions, props = {}, buffers = {}, context = {} }) { - let updated = false; - debug(TRACE_UPDATE_START, this); - if (this.stats) { - this.stats.get("Update Attributes").timeStart(); - } - for (const attributeName in this.attributes) { - const attribute = this.attributes[attributeName]; - const accessorName = attribute.settings.accessor; - attribute.startIndices = startIndices; - attribute.numInstances = numInstances; - if (props[attributeName]) { - log_default.removed(`props.${attributeName}`, `data.attributes.${attributeName}`)(); - } - if (attribute.setExternalBuffer(buffers[attributeName])) { - } else if (attribute.setBinaryValue(typeof accessorName === "string" ? buffers[accessorName] : void 0, data.startIndices)) { - } else if (typeof accessorName === "string" && !buffers[accessorName] && attribute.setConstantValue(props[accessorName])) { - } else if (attribute.needsUpdate()) { - updated = true; - this._updateAttribute({ - attribute, - numInstances, - data, - props, - context - }); - } - this.needsRedraw = this.needsRedraw || attribute.needsRedraw(); - } - if (updated) { - debug(TRACE_UPDATE_END, this, numInstances); - } - if (this.stats) { - this.stats.get("Update Attributes").timeEnd(); - } - this.attributeTransitionManager.update({ - attributes: this.attributes, - numInstances, - transitions - }); - } - // Update attribute transition to the current timestamp - // Returns `true` if any transition is in progress - updateTransition() { - const { attributeTransitionManager } = this; - const transitionUpdated = attributeTransitionManager.run(); - this.needsRedraw = this.needsRedraw || transitionUpdated; - return transitionUpdated; - } - /** - * Returns all attribute descriptors - * Note: Format matches luma.gl Model/Program.setAttributes() - * @return {Object} attributes - descriptors - */ - getAttributes() { - return { ...this.attributes, ...this.attributeTransitionManager.getAttributes() }; - } - /** - * Computes the spatial bounds of a given set of attributes - */ - getBounds(attributeNames) { - const bounds = attributeNames.map((attributeName) => this.attributes[attributeName]?.getBounds()); - return this.mergeBoundsMemoized(bounds); - } - /** - * Returns changed attribute descriptors - * This indicates which WebGLBuffers need to be updated - * @return {Object} attributes - descriptors - */ - getChangedAttributes(opts = { clearChangedFlags: false }) { - const { attributes, attributeTransitionManager } = this; - const changedAttributes = { ...attributeTransitionManager.getAttributes() }; - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) { - changedAttributes[attributeName] = attribute; - } - } - return changedAttributes; - } - /** Generate WebGPU-style buffer layout descriptors from all attributes */ - getBufferLayouts(modelInfo) { - return Object.values(this.getAttributes()).map((attribute) => attribute.getBufferLayout(modelInfo)); - } - // PRIVATE METHODS - /** Register new attributes */ - _add(attributes, overrideOptions) { - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - const props = { - ...attribute, - id: attributeName, - size: attribute.isIndexed && 1 || attribute.size || 1, - ...overrideOptions - }; - this.attributes[attributeName] = new Attribute2(this.device, props); - } - this._mapUpdateTriggersToAttributes(); - } - // build updateTrigger name to attribute name mapping - _mapUpdateTriggersToAttributes() { - const triggers = {}; - for (const attributeName in this.attributes) { - const attribute = this.attributes[attributeName]; - attribute.getUpdateTriggers().forEach((triggerName) => { - if (!triggers[triggerName]) { - triggers[triggerName] = []; - } - triggers[triggerName].push(attributeName); - }); - } - this.updateTriggers = triggers; - } - _invalidateTrigger(triggerName, dataRange) { - const { attributes, updateTriggers } = this; - const invalidatedAttributes = updateTriggers[triggerName]; - if (invalidatedAttributes) { - invalidatedAttributes.forEach((name2) => { - const attribute = attributes[name2]; - if (attribute) { - attribute.setNeedsUpdate(attribute.id, dataRange); - } - }); - } - return invalidatedAttributes; - } - _updateAttribute(opts) { - const { attribute, numInstances } = opts; - debug(TRACE_ATTRIBUTE_UPDATE_START, attribute); - if (attribute.constant) { - attribute.setConstantValue(attribute.value); - return; - } - if (attribute.allocate(numInstances)) { - debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances); - } - const updated = attribute.updateBuffer(opts); - if (updated) { - this.needsRedraw = true; - debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances); - } - } -}; - -// node_modules/@deck.gl/core/dist/transitions/cpu-interpolation-transition.js -var CPUInterpolationTransition = class extends Transition { - get value() { - return this._value; - } - _onUpdate() { - const { time, settings: { fromValue, toValue, duration, easing } } = this; - const t = easing(time / duration); - this._value = lerp(fromValue, toValue, t); - } -}; - -// node_modules/@deck.gl/core/dist/transitions/cpu-spring-transition.js -var EPSILON3 = 1e-5; -function updateSpringElement(prev, cur, dest, damping, stiffness) { - const velocity = cur - prev; - const delta = dest - cur; - const spring = delta * stiffness; - const damper = -velocity * damping; - return spring + damper + velocity + cur; -} -function updateSpring(prev, cur, dest, damping, stiffness) { - if (Array.isArray(dest)) { - const next = []; - for (let i = 0; i < dest.length; i++) { - next[i] = updateSpringElement(prev[i], cur[i], dest[i], damping, stiffness); - } - return next; - } - return updateSpringElement(prev, cur, dest, damping, stiffness); -} -function distance7(value1, value2) { - if (Array.isArray(value1)) { - let distanceSquare = 0; - for (let i = 0; i < value1.length; i++) { - const d = value1[i] - value2[i]; - distanceSquare += d * d; - } - return Math.sqrt(distanceSquare); - } - return Math.abs(value1 - value2); -} -var CPUSpringTransition = class extends Transition { - get value() { - return this._currValue; - } - _onUpdate() { - const { fromValue, toValue, damping, stiffness } = this.settings; - const { _prevValue = fromValue, _currValue = fromValue } = this; - let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness); - const delta = distance7(nextValue, toValue); - const velocity = distance7(nextValue, _currValue); - if (delta < EPSILON3 && velocity < EPSILON3) { - nextValue = toValue; - this.end(); - } - this._prevValue = _currValue; - this._currValue = nextValue; - } -}; - -// node_modules/@deck.gl/core/dist/lib/uniform-transition-manager.js -var TRANSITION_TYPES2 = { - interpolation: CPUInterpolationTransition, - spring: CPUSpringTransition -}; -var UniformTransitionManager = class { - constructor(timeline) { - this.transitions = /* @__PURE__ */ new Map(); - this.timeline = timeline; - } - get active() { - return this.transitions.size > 0; - } - add(key, fromValue, toValue, settings) { - const { transitions } = this; - if (transitions.has(key)) { - const transition2 = transitions.get(key); - const { value = transition2.settings.fromValue } = transition2; - fromValue = value; - this.remove(key); - } - settings = normalizeTransitionSettings(settings); - if (!settings) { - return; - } - const TransitionType = TRANSITION_TYPES2[settings.type]; - if (!TransitionType) { - log_default.error(`unsupported transition type '${settings.type}'`)(); - return; - } - const transition = new TransitionType(this.timeline); - transition.start({ - ...settings, - fromValue, - toValue - }); - transitions.set(key, transition); - } - remove(key) { - const { transitions } = this; - if (transitions.has(key)) { - transitions.get(key).cancel(); - transitions.delete(key); - } - } - update() { - const propsInTransition = {}; - for (const [key, transition] of this.transitions) { - transition.update(); - propsInTransition[key] = transition.value; - if (!transition.inProgress) { - this.remove(key); - } - } - return propsInTransition; - } - clear() { - for (const key of this.transitions.keys()) { - this.remove(key); - } - } -}; - -// node_modules/@deck.gl/core/dist/lifecycle/props.js -function validateProps(props) { - const propTypes = props[PROP_TYPES_SYMBOL]; - for (const propName in propTypes) { - const propType = propTypes[propName]; - const { validate: validate2 } = propType; - if (validate2 && !validate2(props[propName], propType)) { - throw new Error(`Invalid prop ${propName}: ${props[propName]}`); - } - } -} -function diffProps(props, oldProps) { - const propsChangedReason = compareProps({ - newProps: props, - oldProps, - propTypes: props[PROP_TYPES_SYMBOL], - ignoreProps: { data: null, updateTriggers: null, extensions: null, transitions: null } - }); - const dataChangedReason = diffDataProps(props, oldProps); - let updateTriggersChangedReason = false; - if (!dataChangedReason) { - updateTriggersChangedReason = diffUpdateTriggers(props, oldProps); - } - return { - dataChanged: dataChangedReason, - propsChanged: propsChangedReason, - updateTriggersChanged: updateTriggersChangedReason, - extensionsChanged: diffExtensions(props, oldProps), - transitionsChanged: diffTransitions(props, oldProps) - }; -} -function diffTransitions(props, oldProps) { - if (!props.transitions) { - return false; - } - const result = {}; - const propTypes = props[PROP_TYPES_SYMBOL]; - let changed = false; - for (const key in props.transitions) { - const propType = propTypes[key]; - const type = propType && propType.type; - const isTransitionable = type === "number" || type === "color" || type === "array"; - if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) { - result[key] = true; - changed = true; - } - } - return changed ? result : false; -} -function compareProps({ newProps, oldProps, ignoreProps = {}, propTypes = {}, triggerName = "props" }) { - if (oldProps === newProps) { - return false; - } - if (typeof newProps !== "object" || newProps === null) { - return `${triggerName} changed shallowly`; - } - if (typeof oldProps !== "object" || oldProps === null) { - return `${triggerName} changed shallowly`; - } - for (const key of Object.keys(newProps)) { - if (!(key in ignoreProps)) { - if (!(key in oldProps)) { - return `${triggerName}.${key} added`; - } - const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); - if (changed) { - return `${triggerName}.${key} ${changed}`; - } - } - } - for (const key of Object.keys(oldProps)) { - if (!(key in ignoreProps)) { - if (!(key in newProps)) { - return `${triggerName}.${key} dropped`; - } - if (!Object.hasOwnProperty.call(newProps, key)) { - const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); - if (changed) { - return `${triggerName}.${key} ${changed}`; - } - } - } - } - return false; -} -function comparePropValues(newProp, oldProp, propType) { - let equal = propType && propType.equal; - if (equal && !equal(newProp, oldProp, propType)) { - return "changed deeply"; - } - if (!equal) { - equal = newProp && oldProp && newProp.equals; - if (equal && !equal.call(newProp, oldProp)) { - return "changed deeply"; - } - } - if (!equal && oldProp !== newProp) { - return "changed shallowly"; - } - return null; -} -function diffDataProps(props, oldProps) { - if (oldProps === null) { - return "oldProps is null, initial diff"; - } - let dataChanged = false; - const { dataComparator, _dataDiff } = props; - if (dataComparator) { - if (!dataComparator(props.data, oldProps.data)) { - dataChanged = "Data comparator detected a change"; - } - } else if (props.data !== oldProps.data) { - dataChanged = "A new data container was supplied"; - } - if (dataChanged && _dataDiff) { - dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged; - } - return dataChanged; -} -function diffUpdateTriggers(props, oldProps) { - if (oldProps === null) { - return { all: true }; - } - if ("all" in props.updateTriggers) { - const diffReason = diffUpdateTrigger(props, oldProps, "all"); - if (diffReason) { - return { all: true }; - } - } - const reason = {}; - let changed = false; - for (const triggerName in props.updateTriggers) { - if (triggerName !== "all") { - const diffReason = diffUpdateTrigger(props, oldProps, triggerName); - if (diffReason) { - reason[triggerName] = true; - changed = true; - } - } - } - return changed ? reason : false; -} -function diffExtensions(props, oldProps) { - if (oldProps === null) { - return true; - } - const oldExtensions = oldProps.extensions; - const { extensions } = props; - if (extensions === oldExtensions) { - return false; - } - if (!oldExtensions || !extensions) { - return true; - } - if (extensions.length !== oldExtensions.length) { - return true; - } - for (let i = 0; i < extensions.length; i++) { - if (!extensions[i].equals(oldExtensions[i])) { - return true; - } - } - return false; -} -function diffUpdateTrigger(props, oldProps, triggerName) { - let newTriggers = props.updateTriggers[triggerName]; - newTriggers = newTriggers === void 0 || newTriggers === null ? {} : newTriggers; - let oldTriggers = oldProps.updateTriggers[triggerName]; - oldTriggers = oldTriggers === void 0 || oldTriggers === null ? {} : oldTriggers; - const diffReason = compareProps({ - oldProps: oldTriggers, - newProps: newTriggers, - triggerName - }); - return diffReason; -} - -// node_modules/@deck.gl/core/dist/utils/count.js -var ERR_NOT_OBJECT = "count(): argument not an object"; -var ERR_NOT_CONTAINER = "count(): argument not a container"; -function count(container) { - if (!isObject2(container)) { - throw new Error(ERR_NOT_OBJECT); - } - if (typeof container.count === "function") { - return container.count(); - } - if (Number.isFinite(container.size)) { - return container.size; - } - if (Number.isFinite(container.length)) { - return container.length; - } - if (isPlainObject(container)) { - return Object.keys(container).length; - } - throw new Error(ERR_NOT_CONTAINER); -} -function isPlainObject(value) { - return value !== null && typeof value === "object" && value.constructor === Object; -} -function isObject2(value) { - return value !== null && typeof value === "object"; -} - -// node_modules/@deck.gl/core/dist/utils/shader.js -function mergeShaders(target, source) { - if (!source) { - return target; - } - const result = { ...target, ...source }; - if ("defines" in source) { - result.defines = { ...target.defines, ...source.defines }; - } - if ("modules" in source) { - result.modules = (target.modules || []).concat(source.modules); - if (source.modules.some((module) => module.name === "project64")) { - const index2 = result.modules.findIndex((module) => module.name === "project32"); - if (index2 >= 0) { - result.modules.splice(index2, 1); - } - } - } - if ("inject" in source) { - if (!target.inject) { - result.inject = source.inject; - } else { - const mergedInjection = { ...target.inject }; - for (const key in source.inject) { - mergedInjection[key] = (mergedInjection[key] || "") + source.inject[key]; - } - result.inject = mergedInjection; - } - } - return result; -} - -// node_modules/@deck.gl/core/dist/utils/texture.js -var DEFAULT_TEXTURE_PARAMETERS = { - minFilter: "linear", - mipmapFilter: "linear", - magFilter: "linear", - addressModeU: "clamp-to-edge", - addressModeV: "clamp-to-edge" -}; -var internalTextures = {}; -function createTexture(owner, device, image, sampler) { - if (image instanceof Texture) { - return image; - } else if (image.constructor && image.constructor.name !== "Object") { - image = { data: image }; - } - let samplerParameters = null; - if (image.compressed) { - samplerParameters = { - minFilter: "linear", - mipmapFilter: image.data.length > 1 ? "nearest" : "linear" - }; - } - const texture = device.createTexture({ - ...image, - sampler: { - ...DEFAULT_TEXTURE_PARAMETERS, - ...samplerParameters, - ...sampler - } - }); - internalTextures[texture.id] = owner; - return texture; -} -function destroyTexture(owner, texture) { - if (!texture || !(texture instanceof Texture)) { - return; - } - if (internalTextures[texture.id] === owner) { - texture.delete(); - delete internalTextures[texture.id]; - } -} - -// node_modules/@deck.gl/core/dist/lifecycle/prop-types.js -var TYPE_DEFINITIONS = { - boolean: { - validate(value, propType) { - return true; - }, - equal(value1, value2, propType) { - return Boolean(value1) === Boolean(value2); - } - }, - number: { - validate(value, propType) { - return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); - } - }, - color: { - validate(value, propType) { - return propType.optional && !value || isArray3(value) && (value.length === 3 || value.length === 4); - }, - equal(value1, value2, propType) { - return deepEqual2(value1, value2, 1); - } - }, - accessor: { - validate(value, propType) { - const valueType = getTypeOf2(value); - return valueType === "function" || valueType === getTypeOf2(propType.value); - }, - equal(value1, value2, propType) { - if (typeof value2 === "function") { - return true; - } - return deepEqual2(value1, value2, 1); - } - }, - array: { - validate(value, propType) { - return propType.optional && !value || isArray3(value); - }, - equal(value1, value2, propType) { - const { compare } = propType; - const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; - return compare ? deepEqual2(value1, value2, depth) : value1 === value2; - } - }, - object: { - equal(value1, value2, propType) { - if (propType.ignore) { - return true; - } - const { compare } = propType; - const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; - return compare ? deepEqual2(value1, value2, depth) : value1 === value2; - } - }, - function: { - validate(value, propType) { - return propType.optional && !value || typeof value === "function"; - }, - equal(value1, value2, propType) { - const shouldIgnore = !propType.compare && propType.ignore !== false; - return shouldIgnore || value1 === value2; - } - }, - data: { - transform: (value, propType, component) => { - if (!value) { - return value; - } - const { dataTransform } = component.props; - if (dataTransform) { - return dataTransform(value); - } - if (typeof value.shape === "string" && value.shape.endsWith("-table") && Array.isArray(value.data)) { - return value.data; - } - return value; - } - }, - image: { - transform: (value, propType, component) => { - const context = component.context; - if (!context || !context.device) { - return null; - } - return createTexture(component.id, context.device, value, { - ...propType.parameters, - ...component.props.textureParameters - }); - }, - release: (value, propType, component) => { - destroyTexture(component.id, value); - } - } -}; -function parsePropTypes(propDefs) { - const propTypes = {}; - const defaultProps14 = {}; - const deprecatedProps = {}; - for (const [propName, propDef] of Object.entries(propDefs)) { - const deprecated = propDef?.deprecatedFor; - if (deprecated) { - deprecatedProps[propName] = Array.isArray(deprecated) ? deprecated : [deprecated]; - } else { - const propType = parsePropType(propName, propDef); - propTypes[propName] = propType; - defaultProps14[propName] = propType.value; - } - } - return { propTypes, defaultProps: defaultProps14, deprecatedProps }; -} -function parsePropType(name2, propDef) { - switch (getTypeOf2(propDef)) { - case "object": - return normalizePropDefinition(name2, propDef); - case "array": - return normalizePropDefinition(name2, { type: "array", value: propDef, compare: false }); - case "boolean": - return normalizePropDefinition(name2, { type: "boolean", value: propDef }); - case "number": - return normalizePropDefinition(name2, { type: "number", value: propDef }); - case "function": - return normalizePropDefinition(name2, { type: "function", value: propDef, compare: true }); - default: - return { name: name2, type: "unknown", value: propDef }; - } -} -function normalizePropDefinition(name2, propDef) { - if (!("type" in propDef)) { - if (!("value" in propDef)) { - return { name: name2, type: "object", value: propDef }; - } - return { name: name2, type: getTypeOf2(propDef.value), ...propDef }; - } - return { name: name2, ...TYPE_DEFINITIONS[propDef.type], ...propDef }; -} -function isArray3(value) { - return Array.isArray(value) || ArrayBuffer.isView(value); -} -function getTypeOf2(value) { - if (isArray3(value)) { - return "array"; - } - if (value === null) { - return "null"; - } - return typeof value; -} - -// node_modules/@deck.gl/core/dist/lifecycle/create-props.js -function createProps(component, propObjects) { - let extensions; - for (let i = propObjects.length - 1; i >= 0; i--) { - const props = propObjects[i]; - if ("extensions" in props) { - extensions = props.extensions; - } - } - const propsPrototype = getPropsPrototype(component.constructor, extensions); - const propsInstance = Object.create(propsPrototype); - propsInstance[COMPONENT_SYMBOL] = component; - propsInstance[ASYNC_ORIGINAL_SYMBOL] = {}; - propsInstance[ASYNC_RESOLVED_SYMBOL] = {}; - for (let i = 0; i < propObjects.length; ++i) { - const props = propObjects[i]; - for (const key in props) { - propsInstance[key] = props[key]; - } - } - Object.freeze(propsInstance); - return propsInstance; -} -var MergedDefaultPropsCacheKey = "_mergedDefaultProps"; -function getPropsPrototype(componentClass, extensions) { - if (!(componentClass instanceof component_default.constructor)) - return {}; - let cacheKey = MergedDefaultPropsCacheKey; - if (extensions) { - for (const extension of extensions) { - const ExtensionClass = extension.constructor; - if (ExtensionClass) { - cacheKey += `:${ExtensionClass.extensionName || ExtensionClass.name}`; - } - } - } - const defaultProps14 = getOwnProperty(componentClass, cacheKey); - if (!defaultProps14) { - return componentClass[cacheKey] = createPropsPrototypeAndTypes(componentClass, extensions || []); - } - return defaultProps14; -} -function createPropsPrototypeAndTypes(componentClass, extensions) { - const parent = componentClass.prototype; - if (!parent) { - return null; - } - const parentClass = Object.getPrototypeOf(componentClass); - const parentDefaultProps = getPropsPrototype(parentClass); - const componentDefaultProps = getOwnProperty(componentClass, "defaultProps") || {}; - const componentPropDefs = parsePropTypes(componentDefaultProps); - const defaultProps14 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps, componentPropDefs.defaultProps); - const propTypes = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps?.[PROP_TYPES_SYMBOL], componentPropDefs.propTypes); - const deprecatedProps = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps?.[DEPRECATED_PROPS_SYMBOL], componentPropDefs.deprecatedProps); - for (const extension of extensions) { - const extensionDefaultProps = getPropsPrototype(extension.constructor); - if (extensionDefaultProps) { - Object.assign(defaultProps14, extensionDefaultProps); - Object.assign(propTypes, extensionDefaultProps[PROP_TYPES_SYMBOL]); - Object.assign(deprecatedProps, extensionDefaultProps[DEPRECATED_PROPS_SYMBOL]); - } - } - createPropsPrototype(defaultProps14, componentClass); - addAsyncPropsToPropPrototype(defaultProps14, propTypes); - addDeprecatedPropsToPropPrototype(defaultProps14, deprecatedProps); - defaultProps14[PROP_TYPES_SYMBOL] = propTypes; - defaultProps14[DEPRECATED_PROPS_SYMBOL] = deprecatedProps; - if (extensions.length === 0 && !hasOwnProperty(componentClass, "_propTypes")) { - componentClass._propTypes = propTypes; - } - return defaultProps14; -} -function createPropsPrototype(defaultProps14, componentClass) { - const id = getComponentName(componentClass); - Object.defineProperties(defaultProps14, { - // `id` is treated specially because layer might need to override it - id: { - writable: true, - value: id - } - }); -} -function addDeprecatedPropsToPropPrototype(defaultProps14, deprecatedProps) { - for (const propName in deprecatedProps) { - Object.defineProperty(defaultProps14, propName, { - enumerable: false, - set(newValue) { - const nameStr = `${this.id}: ${propName}`; - for (const newPropName of deprecatedProps[propName]) { - if (!hasOwnProperty(this, newPropName)) { - this[newPropName] = newValue; - } - } - log_default.deprecated(nameStr, deprecatedProps[propName].join("/"))(); - } - }); - } -} -function addAsyncPropsToPropPrototype(defaultProps14, propTypes) { - const defaultValues = {}; - const descriptors = {}; - for (const propName in propTypes) { - const propType = propTypes[propName]; - const { name: name2, value } = propType; - if (propType.async) { - defaultValues[name2] = value; - descriptors[name2] = getDescriptorForAsyncProp(name2); - } - } - defaultProps14[ASYNC_DEFAULTS_SYMBOL] = defaultValues; - defaultProps14[ASYNC_ORIGINAL_SYMBOL] = {}; - Object.defineProperties(defaultProps14, descriptors); -} -function getDescriptorForAsyncProp(name2) { - return { - enumerable: true, - // Save the provided value for async props in a special map - set(newValue) { - if (typeof newValue === "string" || newValue instanceof Promise || isAsyncIterable2(newValue)) { - this[ASYNC_ORIGINAL_SYMBOL][name2] = newValue; - } else { - this[ASYNC_RESOLVED_SYMBOL][name2] = newValue; - } - }, - // Only the component's state knows the true value of async prop - get() { - if (this[ASYNC_RESOLVED_SYMBOL]) { - if (name2 in this[ASYNC_RESOLVED_SYMBOL]) { - const value = this[ASYNC_RESOLVED_SYMBOL][name2]; - return value || this[ASYNC_DEFAULTS_SYMBOL][name2]; - } - if (name2 in this[ASYNC_ORIGINAL_SYMBOL]) { - const state = this[COMPONENT_SYMBOL] && this[COMPONENT_SYMBOL].internalState; - if (state && state.hasAsyncProp(name2)) { - return state.getAsyncProp(name2) || this[ASYNC_DEFAULTS_SYMBOL][name2]; - } - } - } - return this[ASYNC_DEFAULTS_SYMBOL][name2]; - } - }; -} -function hasOwnProperty(object, prop) { - return Object.prototype.hasOwnProperty.call(object, prop); -} -function getOwnProperty(object, prop) { - return hasOwnProperty(object, prop) && object[prop]; -} -function getComponentName(componentClass) { - const componentName = componentClass.componentName; - if (!componentName) { - log_default.warn(`${componentClass.name}.componentName not specified`)(); - } - return componentName || componentClass.name; -} - -// node_modules/@deck.gl/core/dist/lifecycle/component.js -var counter = 0; -var Component = class { - constructor(...propObjects) { - this.props = createProps(this, propObjects); - this.id = this.props.id; - this.count = counter++; - } - // clone this layer with modified props - clone(newProps) { - const { props } = this; - const asyncProps = {}; - for (const key in props[ASYNC_DEFAULTS_SYMBOL]) { - if (key in props[ASYNC_RESOLVED_SYMBOL]) { - asyncProps[key] = props[ASYNC_RESOLVED_SYMBOL][key]; - } else if (key in props[ASYNC_ORIGINAL_SYMBOL]) { - asyncProps[key] = props[ASYNC_ORIGINAL_SYMBOL][key]; - } - } - return new this.constructor({ ...props, ...asyncProps, ...newProps }); - } -}; -Component.componentName = "Component"; -Component.defaultProps = {}; -var component_default = Component; - -// node_modules/@deck.gl/core/dist/lifecycle/component-state.js -var EMPTY_PROPS = Object.freeze({}); -var ComponentState = class { - constructor(component) { - this.component = component; - this.asyncProps = {}; - this.onAsyncPropUpdated = () => { - }; - this.oldProps = null; - this.oldAsyncProps = null; - } - finalize() { - for (const propName in this.asyncProps) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp && asyncProp.type && asyncProp.type.release) { - asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component); - } - } - this.asyncProps = {}; - this.component = null; - this.resetOldProps(); - } - /* Layer-facing props API */ - getOldProps() { - return this.oldAsyncProps || this.oldProps || EMPTY_PROPS; - } - resetOldProps() { - this.oldAsyncProps = null; - this.oldProps = this.component ? this.component.props : null; - } - // Checks if a prop is overridden - hasAsyncProp(propName) { - return propName in this.asyncProps; - } - // Returns value of an overriden prop - getAsyncProp(propName) { - const asyncProp = this.asyncProps[propName]; - return asyncProp && asyncProp.resolvedValue; - } - isAsyncPropLoading(propName) { - if (propName) { - const asyncProp = this.asyncProps[propName]; - return Boolean(asyncProp && asyncProp.pendingLoadCount > 0 && asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount); - } - for (const key in this.asyncProps) { - if (this.isAsyncPropLoading(key)) { - return true; - } - } - return false; - } - // Without changing the original prop value, swap out the data resolution under the hood - reloadAsyncProp(propName, value) { - this._watchPromise(propName, Promise.resolve(value)); - } - // Updates all async/overridden props (when new props come in) - // Checks if urls have changed, starts loading, or removes override - setAsyncProps(props) { - this.component = props[COMPONENT_SYMBOL] || this.component; - const resolvedValues = props[ASYNC_RESOLVED_SYMBOL] || {}; - const originalValues = props[ASYNC_ORIGINAL_SYMBOL] || props; - const defaultValues = props[ASYNC_DEFAULTS_SYMBOL] || {}; - for (const propName in resolvedValues) { - const value = resolvedValues[propName]; - this._createAsyncPropData(propName, defaultValues[propName]); - this._updateAsyncProp(propName, value); - resolvedValues[propName] = this.getAsyncProp(propName); - } - for (const propName in originalValues) { - const value = originalValues[propName]; - this._createAsyncPropData(propName, defaultValues[propName]); - this._updateAsyncProp(propName, value); - } - } - /* Placeholder methods for subclassing */ - _fetch(propName, url) { - return null; - } - _onResolve(propName, value) { - } - // eslint-disable-line @typescript-eslint/no-empty-function - _onError(propName, error) { - } - // eslint-disable-line @typescript-eslint/no-empty-function - // Intercept strings (URLs) and Promises and activates loading and prop rewriting - _updateAsyncProp(propName, value) { - if (!this._didAsyncInputValueChange(propName, value)) { - return; - } - if (typeof value === "string") { - value = this._fetch(propName, value); - } - if (value instanceof Promise) { - this._watchPromise(propName, value); - return; - } - if (isAsyncIterable2(value)) { - this._resolveAsyncIterable(propName, value); - return; - } - this._setPropValue(propName, value); - } - // Whenever async props are changing, we need to make a copy of oldProps - // otherwise the prop rewriting will affect the value both in props and oldProps. - // While the copy is relatively expensive, this only happens on load completion. - _freezeAsyncOldProps() { - if (!this.oldAsyncProps && this.oldProps) { - this.oldAsyncProps = Object.create(this.oldProps); - for (const propName in this.asyncProps) { - Object.defineProperty(this.oldAsyncProps, propName, { - enumerable: true, - value: this.oldProps[propName] - }); - } - } - } - // Checks if an input value actually changed (to avoid reloading/rewatching promises/urls) - _didAsyncInputValueChange(propName, value) { - const asyncProp = this.asyncProps[propName]; - if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) { - return false; - } - asyncProp.lastValue = value; - return true; - } - // Set normal, non-async value - _setPropValue(propName, value) { - this._freezeAsyncOldProps(); - const asyncProp = this.asyncProps[propName]; - if (asyncProp) { - value = this._postProcessValue(asyncProp, value); - asyncProp.resolvedValue = value; - asyncProp.pendingLoadCount++; - asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount; - } - } - // Set a just resolved async value, calling onAsyncPropUpdates if value changes asynchronously - _setAsyncPropValue(propName, value, loadCount) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== void 0) { - this._freezeAsyncOldProps(); - asyncProp.resolvedValue = value; - asyncProp.resolvedLoadCount = loadCount; - this.onAsyncPropUpdated(propName, value); - } - } - // Tracks a promise, sets the prop when loaded, handles load count - _watchPromise(propName, promise) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp) { - asyncProp.pendingLoadCount++; - const loadCount = asyncProp.pendingLoadCount; - promise.then((data) => { - if (!this.component) { - return; - } - data = this._postProcessValue(asyncProp, data); - this._setAsyncPropValue(propName, data, loadCount); - this._onResolve(propName, data); - }).catch((error) => { - this._onError(propName, error); - }); - } - } - async _resolveAsyncIterable(propName, iterable) { - if (propName !== "data") { - this._setPropValue(propName, iterable); - return; - } - const asyncProp = this.asyncProps[propName]; - if (!asyncProp) { - return; - } - asyncProp.pendingLoadCount++; - const loadCount = asyncProp.pendingLoadCount; - let data = []; - let count2 = 0; - for await (const chunk of iterable) { - if (!this.component) { - return; - } - const { dataTransform } = this.component.props; - if (dataTransform) { - data = dataTransform(chunk, data); - } else { - data = data.concat(chunk); - } - Object.defineProperty(data, "__diff", { - enumerable: false, - value: [{ startRow: count2, endRow: data.length }] - }); - count2 = data.length; - this._setAsyncPropValue(propName, data, loadCount); - } - this._onResolve(propName, data); - } - // Give the app a chance to post process the loaded data - _postProcessValue(asyncProp, value) { - const propType = asyncProp.type; - if (propType && this.component) { - if (propType.release) { - propType.release(asyncProp.resolvedValue, propType, this.component); - } - if (propType.transform) { - return propType.transform(value, propType, this.component); - } - } - return value; - } - // Creating an asyncProp record if needed - _createAsyncPropData(propName, defaultValue) { - const asyncProp = this.asyncProps[propName]; - if (!asyncProp) { - const propTypes = this.component && this.component.props[PROP_TYPES_SYMBOL]; - this.asyncProps[propName] = { - type: propTypes && propTypes[propName], - lastValue: null, - resolvedValue: defaultValue, - pendingLoadCount: 0, - resolvedLoadCount: 0 - }; - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/layer-state.js -var LayerState = class extends ComponentState { - constructor({ attributeManager, layer }) { - super(layer); - this.attributeManager = attributeManager; - this.needsRedraw = true; - this.needsUpdate = true; - this.subLayers = null; - this.usesPickingColorCache = false; - } - get layer() { - return this.component; - } - /* Override base Component methods with Layer-specific handling */ - _fetch(propName, url) { - const layer = this.layer; - const fetch2 = layer?.props.fetch; - if (fetch2) { - return fetch2(url, { propName, layer }); - } - return super._fetch(propName, url); - } - _onResolve(propName, value) { - const layer = this.layer; - if (layer) { - const onDataLoad = layer.props.onDataLoad; - if (propName === "data" && onDataLoad) { - onDataLoad(value, { propName, layer }); - } - } - } - _onError(propName, error) { - const layer = this.layer; - if (layer) { - layer.raiseError(error, `loading ${propName} of ${this.layer}`); - } - } -}; - -// node_modules/@deck.gl/core/dist/lib/layer.js -var TRACE_CHANGE_FLAG = "layer.changeFlag"; -var TRACE_INITIALIZE = "layer.initialize"; -var TRACE_UPDATE = "layer.update"; -var TRACE_FINALIZE = "layer.finalize"; -var TRACE_MATCHED = "layer.matched"; -var MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1; -var EMPTY_ARRAY2 = Object.freeze([]); -var areViewportsEqual = memoize(({ oldViewport, viewport }) => { - return oldViewport.equals(viewport); -}); -var pickingColorCache = new Uint8ClampedArray(0); -var defaultProps2 = { - // data: Special handling for null, see below - data: { type: "data", value: EMPTY_ARRAY2, async: true }, - dataComparator: { type: "function", value: null, optional: true }, - _dataDiff: { - type: "function", - // @ts-ignore __diff is not defined on data - value: (data) => data && data.__diff, - optional: true - }, - dataTransform: { type: "function", value: null, optional: true }, - onDataLoad: { type: "function", value: null, optional: true }, - onError: { type: "function", value: null, optional: true }, - fetch: { - type: "function", - value: (url, { propName, layer, loaders, loadOptions, signal }) => { - const { resourceManager } = layer.context; - loadOptions = loadOptions || layer.getLoadOptions(); - loaders = loaders || layer.props.loaders; - if (signal) { - loadOptions = { - ...loadOptions, - fetch: { - ...loadOptions?.fetch, - signal - } - }; - } - let inResourceManager = resourceManager.contains(url); - if (!inResourceManager && !loadOptions) { - resourceManager.add({ resourceId: url, data: load(url, loaders), persistent: false }); - inResourceManager = true; - } - if (inResourceManager) { - return resourceManager.subscribe({ - resourceId: url, - onChange: (data) => layer.internalState?.reloadAsyncProp(propName, data), - consumerId: layer.id, - requestId: propName - }); - } - return load(url, loaders, loadOptions); - } - }, - updateTriggers: {}, - // Update triggers: a core change detection mechanism in deck.gl - visible: true, - pickable: false, - opacity: { type: "number", min: 0, max: 1, value: 1 }, - operation: "draw", - onHover: { type: "function", value: null, optional: true }, - onClick: { type: "function", value: null, optional: true }, - onDragStart: { type: "function", value: null, optional: true }, - onDrag: { type: "function", value: null, optional: true }, - onDragEnd: { type: "function", value: null, optional: true }, - coordinateSystem: COORDINATE_SYSTEM.DEFAULT, - coordinateOrigin: { type: "array", value: [0, 0, 0], compare: true }, - modelMatrix: { type: "array", value: null, compare: true, optional: true }, - wrapLongitude: false, - positionFormat: "XYZ", - colorFormat: "RGBA", - parameters: { type: "object", value: {}, optional: true, compare: 2 }, - loadOptions: { type: "object", value: null, optional: true, ignore: true }, - transitions: null, - extensions: [], - loaders: { type: "array", value: [], optional: true, ignore: true }, - // Offset depth based on layer index to avoid z-fighting. - // Negative values pull layer towards the camera - // https://www.opengl.org/archives/resources/faq/technical/polygonoffset.htm - getPolygonOffset: { - type: "function", - value: ({ layerIndex }) => [0, -layerIndex * 100] - }, - // Selection/Highlighting - highlightedObjectIndex: null, - autoHighlight: false, - highlightColor: { type: "accessor", value: [0, 0, 128, 128] } -}; -var Layer = class extends component_default { - constructor() { - super(...arguments); - this.internalState = null; - this.lifecycle = LIFECYCLE.NO_STATE; - this.parent = null; - } - static get componentName() { - return Object.prototype.hasOwnProperty.call(this, "layerName") ? this.layerName : ""; - } - get root() { - let layer = this; - while (layer.parent) { - layer = layer.parent; - } - return layer; - } - toString() { - const className = this.constructor.layerName || this.constructor.name; - return `${className}({id: '${this.props.id}'})`; - } - // Public API for users - /** Projects a point with current view state from the current layer's coordinate system to screen */ - project(xyz) { - assert9(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - const worldPosition = getWorldPosition(xyz, { - viewport, - modelMatrix: this.props.modelMatrix, - coordinateOrigin: this.props.coordinateOrigin, - coordinateSystem: this.props.coordinateSystem - }); - const [x, y, z] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix); - return xyz.length === 2 ? [x, y] : [x, y, z]; - } - /** Unprojects a screen pixel to the current view's default coordinate system - Note: this does not reverse `project`. */ - unproject(xy) { - assert9(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - return viewport.unproject(xy); - } - /** Projects a point with current view state from the current layer's coordinate system to the world space */ - projectPosition(xyz, params) { - assert9(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - return projectPosition(xyz, { - viewport, - modelMatrix: this.props.modelMatrix, - coordinateOrigin: this.props.coordinateOrigin, - coordinateSystem: this.props.coordinateSystem, - ...params - }); - } - // Public API for custom layer implementation - /** `true` if this layer renders other layers */ - get isComposite() { - return false; - } - /** Updates selected state members and marks the layer for redraw */ - setState(partialState) { - this.setChangeFlags({ stateChanged: true }); - Object.assign(this.state, partialState); - this.setNeedsRedraw(); - } - /** Sets the redraw flag for this layer, will trigger a redraw next animation frame */ - setNeedsRedraw() { - if (this.internalState) { - this.internalState.needsRedraw = true; - } - } - /** Mark this layer as needs a deep update */ - setNeedsUpdate() { - if (this.internalState) { - this.context.layerManager.setNeedsUpdate(String(this)); - this.internalState.needsUpdate = true; - } - } - /** Returns true if all async resources are loaded */ - get isLoaded() { - return this.internalState ? !this.internalState.isAsyncPropLoading() : false; - } - /** Returns true if using shader-based WGS84 longitude wrapping */ - get wrapLongitude() { - return this.props.wrapLongitude; - } - /** @deprecated Returns true if the layer is visible in the picking pass */ - isPickable() { - return this.props.pickable && this.props.visible; - } - /** Returns an array of models used by this layer, can be overriden by layer subclass */ - getModels() { - const state = this.state; - return state && (state.models || state.model && [state.model]) || []; - } - // TODO deprecate in favour of setShaderModuleProps - /** Update shader module parameters */ - setModuleParameters(moduleParameters) { - for (const model of this.getModels()) { - model.updateModuleSettings(moduleParameters); - } - } - /** Update shader input parameters */ - setShaderModuleProps(...props) { - for (const model of this.getModels()) { - model.shaderInputs.setProps(...props); - } - } - /** Returns the attribute manager of this layer */ - getAttributeManager() { - return this.internalState && this.internalState.attributeManager; - } - /** Returns the most recent layer that matched to this state - (When reacting to an async event, this layer may no longer be the latest) */ - getCurrentLayer() { - return this.internalState && this.internalState.layer; - } - /** Returns the default parse options for async props */ - getLoadOptions() { - return this.props.loadOptions; - } - use64bitPositions() { - const { coordinateSystem } = this.props; - return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN; - } - // Event handling - onHover(info, pickingEvent) { - if (this.props.onHover) { - return this.props.onHover(info, pickingEvent) || false; - } - return false; - } - onClick(info, pickingEvent) { - if (this.props.onClick) { - return this.props.onClick(info, pickingEvent) || false; - } - return false; - } - // Returns the picking color that doesn't match any subfeature - // Use if some graphics do not belong to any pickable subfeature - // @return {Array} - a black color - nullPickingColor() { - return [0, 0, 0]; - } - // Returns the picking color that doesn't match any subfeature - // Use if some graphics do not belong to any pickable subfeature - encodePickingColor(i, target = []) { - target[0] = i + 1 & 255; - target[1] = i + 1 >> 8 & 255; - target[2] = i + 1 >> 8 >> 8 & 255; - return target; - } - // Returns the index corresponding to a picking color that doesn't match any subfeature - // @param {Uint8Array} color - color array to be decoded - // @return {Array} - the decoded picking color - decodePickingColor(color) { - assert9(color instanceof Uint8Array); - const [i1, i2, i3] = color; - const index2 = i1 + i2 * 256 + i3 * 65536 - 1; - return index2; - } - /** Deduces number of instances. Intention is to support: - - Explicit setting of numInstances - - Auto-deduction for ES6 containers that define a size member - - Auto-deduction for Classic Arrays via the built-in length attribute - - Auto-deduction via arrays */ - getNumInstances() { - if (Number.isFinite(this.props.numInstances)) { - return this.props.numInstances; - } - if (this.state && this.state.numInstances !== void 0) { - return this.state.numInstances; - } - return count(this.props.data); - } - /** Buffer layout describes how many attribute values are packed for each data object - The default (null) is one value each object. - Some data formats (e.g. paths, polygons) have various length. Their buffer layout - is in the form of [L0, L1, L2, ...] */ - getStartIndices() { - if (this.props.startIndices) { - return this.props.startIndices; - } - if (this.state && this.state.startIndices) { - return this.state.startIndices; - } - return null; - } - // Default implementation - getBounds() { - return this.getAttributeManager()?.getBounds(["positions", "instancePositions"]); - } - getShaders(shaders) { - shaders = mergeShaders(shaders, { - disableWarnings: true, - modules: this.context.defaultShaderModules - }); - for (const extension of this.props.extensions) { - shaders = mergeShaders(shaders, extension.getShaders.call(this, extension)); - } - return shaders; - } - /** Controls if updateState should be called. By default returns true if any prop has changed */ - shouldUpdateState(params) { - return params.changeFlags.propsOrDataChanged; - } - /** Default implementation, all attributes will be invalidated and updated when data changes */ - // eslint-disable-next-line complexity - updateState(params) { - const attributeManager = this.getAttributeManager(); - const { dataChanged } = params.changeFlags; - if (dataChanged && attributeManager) { - if (Array.isArray(dataChanged)) { - for (const dataRange of dataChanged) { - attributeManager.invalidateAll(dataRange); - } - } else { - attributeManager.invalidateAll(); - } - } - if (attributeManager) { - const { props } = params; - const hasPickingBuffer = this.internalState.hasPickingBuffer; - const needsPickingBuffer = Number.isInteger(props.highlightedObjectIndex) || props.pickable || props.extensions.some((extension) => extension.getNeedsPickingBuffer.call(this, extension)); - if (hasPickingBuffer !== needsPickingBuffer) { - this.internalState.hasPickingBuffer = needsPickingBuffer; - const { pickingColors, instancePickingColors } = attributeManager.attributes; - const pickingColorsAttribute = pickingColors || instancePickingColors; - if (pickingColorsAttribute) { - if (needsPickingBuffer && pickingColorsAttribute.constant) { - pickingColorsAttribute.constant = false; - attributeManager.invalidate(pickingColorsAttribute.id); - } - if (!pickingColorsAttribute.value && !needsPickingBuffer) { - pickingColorsAttribute.constant = true; - pickingColorsAttribute.value = [0, 0, 0]; - } - } - } - } - } - /** Called once when layer is no longer matched and state will be discarded. Layers can destroy WebGL resources here. */ - finalizeState(context) { - for (const model of this.getModels()) { - model.destroy(); - } - const attributeManager = this.getAttributeManager(); - if (attributeManager) { - attributeManager.finalize(); - } - if (this.context) { - this.context.resourceManager.unsubscribe({ consumerId: this.id }); - } - if (this.internalState) { - this.internalState.uniformTransitions.clear(); - this.internalState.finalize(); - } - } - // If state has a model, draw it with supplied uniforms - draw(opts) { - for (const model of this.getModels()) { - model.draw(opts); - } - } - // called to populate the info object that is passed to the event handler - // @return null to cancel event - getPickingInfo({ info, mode, sourceLayer }) { - const { index: index2 } = info; - if (index2 >= 0) { - if (Array.isArray(this.props.data)) { - info.object = this.props.data[index2]; - } - } - return info; - } - // END LIFECYCLE METHODS - // / INTERNAL METHODS - called by LayerManager, DeckRenderer and DeckPicker - /** (Internal) Propagate an error event through the system */ - raiseError(error, message2) { - if (message2) { - error = new Error(`${message2}: ${error.message}`, { cause: error }); - } - if (!this.props.onError?.(error)) { - this.context?.onError?.(error, this); - } - } - /** (Internal) Checks if this layer needs redraw */ - getNeedsRedraw(opts = { clearRedrawFlags: false }) { - return this._getNeedsRedraw(opts); - } - /** (Internal) Checks if this layer needs a deep update */ - needsUpdate() { - if (!this.internalState) { - return false; - } - return this.internalState.needsUpdate || this.hasUniformTransition() || this.shouldUpdateState(this._getUpdateParams()); - } - /** Checks if this layer has ongoing uniform transition */ - hasUniformTransition() { - return this.internalState?.uniformTransitions.active || false; - } - /** Called when this layer is rendered into the given viewport */ - activateViewport(viewport) { - if (!this.internalState) { - return; - } - const oldViewport = this.internalState.viewport; - this.internalState.viewport = viewport; - if (!oldViewport || !areViewportsEqual({ oldViewport, viewport })) { - this.setChangeFlags({ viewportChanged: true }); - if (this.isComposite) { - if (this.needsUpdate()) { - this.setNeedsUpdate(); - } - } else { - this._update(); - } - } - } - /** Default implementation of attribute invalidation, can be redefined */ - invalidateAttribute(name2 = "all") { - const attributeManager = this.getAttributeManager(); - if (!attributeManager) { - return; - } - if (name2 === "all") { - attributeManager.invalidateAll(); - } else { - attributeManager.invalidate(name2); - } - } - /** Send updated attributes to the WebGL model */ - updateAttributes(changedAttributes) { - let bufferLayoutChanged = false; - for (const id in changedAttributes) { - if (changedAttributes[id].layoutChanged()) { - bufferLayoutChanged = true; - } - } - for (const model of this.getModels()) { - this._setModelAttributes(model, changedAttributes, bufferLayoutChanged); - } - } - /** Recalculate any attributes if needed */ - _updateAttributes() { - const attributeManager = this.getAttributeManager(); - if (!attributeManager) { - return; - } - const props = this.props; - const numInstances = this.getNumInstances(); - const startIndices = this.getStartIndices(); - attributeManager.update({ - data: props.data, - numInstances, - startIndices, - props, - transitions: props.transitions, - // @ts-ignore (TS2339) property attribute is not present on some acceptable data types - buffers: props.data.attributes, - context: this - }); - const changedAttributes = attributeManager.getChangedAttributes({ clearChangedFlags: true }); - this.updateAttributes(changedAttributes); - } - /** Update attribute transitions. This is called in drawLayer, no model updates required. */ - _updateAttributeTransition() { - const attributeManager = this.getAttributeManager(); - if (attributeManager) { - attributeManager.updateTransition(); - } - } - /** Update uniform (prop) transitions. This is called in updateState, may result in model updates. */ - _updateUniformTransition() { - const { uniformTransitions } = this.internalState; - if (uniformTransitions.active) { - const propsInTransition = uniformTransitions.update(); - const props = Object.create(this.props); - for (const key in propsInTransition) { - Object.defineProperty(props, key, { value: propsInTransition[key] }); - } - return props; - } - return this.props; - } - /** Updater for the automatically populated instancePickingColors attribute */ - calculateInstancePickingColors(attribute, { numInstances }) { - if (attribute.constant) { - return; - } - const cacheSize = Math.floor(pickingColorCache.length / 4); - this.internalState.usesPickingColorCache = true; - if (cacheSize < numInstances) { - if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) { - log_default.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(); - } - pickingColorCache = typed_array_manager_default.allocate(pickingColorCache, numInstances, { - size: 4, - copy: true, - maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE) - }); - const newCacheSize = Math.floor(pickingColorCache.length / 4); - const pickingColor = []; - for (let i = cacheSize; i < newCacheSize; i++) { - this.encodePickingColor(i, pickingColor); - pickingColorCache[i * 4 + 0] = pickingColor[0]; - pickingColorCache[i * 4 + 1] = pickingColor[1]; - pickingColorCache[i * 4 + 2] = pickingColor[2]; - } - } - attribute.value = pickingColorCache.subarray(0, numInstances * 4); - } - /** Apply changed attributes to model */ - _setModelAttributes(model, changedAttributes, bufferLayoutChanged = false) { - if (!Object.keys(changedAttributes).length) { - return; - } - if (bufferLayoutChanged) { - const attributeManager = this.getAttributeManager(); - model.setBufferLayout(attributeManager.getBufferLayouts(model)); - changedAttributes = attributeManager.getAttributes(); - } - const excludeAttributes = model.userData?.excludeAttributes || {}; - const attributeBuffers = {}; - const constantAttributes = {}; - for (const name2 in changedAttributes) { - if (excludeAttributes[name2]) { - continue; - } - const values = changedAttributes[name2].getValue(); - for (const attributeName in values) { - const value = values[attributeName]; - if (value instanceof Buffer2) { - if (changedAttributes[name2].settings.isIndexed) { - model.setIndexBuffer(value); - } else { - attributeBuffers[attributeName] = value; - } - } else if (value) { - constantAttributes[attributeName] = value; - } - } - } - model.setAttributes(attributeBuffers); - model.setConstantAttributes(constantAttributes); - } - /** (Internal) Sets the picking color at the specified index to null picking color. Used for multi-depth picking. - This method may be overriden by layer implementations */ - disablePickingIndex(objectIndex) { - const data = this.props.data; - if (!("attributes" in data)) { - this._disablePickingIndex(objectIndex); - return; - } - const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - const externalColorAttribute = colors && data.attributes && data.attributes[colors.id]; - if (externalColorAttribute && externalColorAttribute.value) { - const values = externalColorAttribute.value; - const objectColor = this.encodePickingColor(objectIndex); - for (let index2 = 0; index2 < data.length; index2++) { - const i = colors.getVertexOffset(index2); - if (values[i] === objectColor[0] && values[i + 1] === objectColor[1] && values[i + 2] === objectColor[2]) { - this._disablePickingIndex(index2); - } - } - } else { - this._disablePickingIndex(objectIndex); - } - } - // TODO - simplify subclassing interface - _disablePickingIndex(objectIndex) { - const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - if (!colors) { - return; - } - const start = colors.getVertexOffset(objectIndex); - const end = colors.getVertexOffset(objectIndex + 1); - colors.buffer.write(new Uint8Array(end - start), start); - } - /** (Internal) Re-enable all picking indices after multi-depth picking */ - restorePickingColors() { - const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - if (!colors) { - return; - } - if ( - // @ts-ignore (TS2531) this method is only called internally with internalState defined - this.internalState.usesPickingColorCache && colors.value.buffer !== pickingColorCache.buffer - ) { - colors.value = pickingColorCache.subarray(0, colors.value.length); - } - colors.updateSubBuffer({ startOffset: 0 }); - } - /* eslint-disable max-statements */ - /* (Internal) Called by layer manager when a new layer is found */ - _initialize() { - assert9(!this.internalState); - assert9(Number.isFinite(this.props.coordinateSystem)); - debug(TRACE_INITIALIZE, this); - const attributeManager = this._getAttributeManager(); - if (attributeManager) { - attributeManager.addInstanced({ - instancePickingColors: { - type: "uint8", - size: 4, - noAlloc: true, - // Updaters are always called with `this` pointing to the layer - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculateInstancePickingColors - } - }); - } - this.internalState = new LayerState({ - attributeManager, - layer: this - }); - this._clearChangeFlags(); - this.state = {}; - Object.defineProperty(this.state, "attributeManager", { - get: () => { - log_default.deprecated("layer.state.attributeManager", "layer.getAttributeManager()")(); - return attributeManager; - } - }); - this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline); - this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this); - this.internalState.setAsyncProps(this.props); - this.initializeState(this.context); - for (const extension of this.props.extensions) { - extension.initializeState.call(this, this.context, extension); - } - this.setChangeFlags({ - dataChanged: "init", - propsChanged: "init", - viewportChanged: true, - extensionsChanged: true - }); - this._update(); - } - /** (Internal) Called by layer manager to transfer state from an old layer */ - _transferState(oldLayer) { - debug(TRACE_MATCHED, this, this === oldLayer); - const { state, internalState } = oldLayer; - if (this === oldLayer) { - return; - } - this.internalState = internalState; - this.state = state; - this.internalState.setAsyncProps(this.props); - this._diffProps(this.props, this.internalState.getOldProps()); - } - /** (Internal) Called by layer manager when a new layer is added or an existing layer is matched with a new instance */ - _update() { - const stateNeedsUpdate = this.needsUpdate(); - debug(TRACE_UPDATE, this, stateNeedsUpdate); - if (!stateNeedsUpdate) { - return; - } - const currentProps = this.props; - const context = this.context; - const internalState = this.internalState; - const currentViewport = context.viewport; - const propsInTransition = this._updateUniformTransition(); - internalState.propsInTransition = propsInTransition; - context.viewport = internalState.viewport || currentViewport; - this.props = propsInTransition; - try { - const updateParams = this._getUpdateParams(); - const oldModels = this.getModels(); - if (context.device) { - this.updateState(updateParams); - } else { - try { - this.updateState(updateParams); - } catch (error) { - } - } - for (const extension of this.props.extensions) { - extension.updateState.call(this, updateParams, extension); - } - const modelChanged = this.getModels()[0] !== oldModels[0]; - this._postUpdate(updateParams, modelChanged); - } finally { - context.viewport = currentViewport; - this.props = currentProps; - this._clearChangeFlags(); - internalState.needsUpdate = false; - internalState.resetOldProps(); - } - } - /* eslint-enable max-statements */ - /** (Internal) Called by manager when layer is about to be disposed - Note: not guaranteed to be called on application shutdown */ - _finalize() { - debug(TRACE_FINALIZE, this); - this.finalizeState(this.context); - for (const extension of this.props.extensions) { - extension.finalizeState.call(this, this.context, extension); - } - } - // Calculates uniforms - _drawLayer({ renderPass, moduleParameters = null, uniforms = {}, parameters = {} }) { - this._updateAttributeTransition(); - const currentProps = this.props; - const context = this.context; - this.props = this.internalState.propsInTransition || currentProps; - const opacity = this.props.opacity; - uniforms.opacity = Math.pow(opacity, 1 / 2.2); - try { - if (moduleParameters) { - const { isActive, isAttribute } = moduleParameters.picking; - this.setModuleParameters(moduleParameters); - this.setShaderModuleProps({ picking: { isActive, isAttribute } }); - } - const { getPolygonOffset } = this.props; - const offsets = getPolygonOffset && getPolygonOffset(uniforms) || [0, 0]; - context.device.setParametersWebGL({ polygonOffset: offsets }); - for (const model of this.getModels()) { - model.setParameters(parameters); - } - context.device.withParametersWebGL(parameters, () => { - const opts = { renderPass, moduleParameters, uniforms, parameters, context }; - for (const extension of this.props.extensions) { - extension.draw.call(this, opts, extension); - } - this.draw(opts); - }); - } finally { - this.props = currentProps; - } - } - // Helper methods - /** Returns the current change flags */ - getChangeFlags() { - return this.internalState?.changeFlags; - } - /* eslint-disable complexity */ - /** Dirty some change flags, will be handled by updateLayer */ - setChangeFlags(flags) { - if (!this.internalState) { - return; - } - const { changeFlags } = this.internalState; - for (const key in flags) { - if (flags[key]) { - let flagChanged = false; - switch (key) { - case "dataChanged": - const dataChangedReason = flags[key]; - const prevDataChangedReason = changeFlags[key]; - if (dataChangedReason && Array.isArray(prevDataChangedReason)) { - changeFlags.dataChanged = Array.isArray(dataChangedReason) ? prevDataChangedReason.concat(dataChangedReason) : dataChangedReason; - flagChanged = true; - } - default: - if (!changeFlags[key]) { - changeFlags[key] = flags[key]; - flagChanged = true; - } - } - if (flagChanged) { - debug(TRACE_CHANGE_FLAG, this, key, flags); - } - } - } - const propsOrDataChanged = Boolean(changeFlags.dataChanged || changeFlags.updateTriggersChanged || changeFlags.propsChanged || changeFlags.extensionsChanged); - changeFlags.propsOrDataChanged = propsOrDataChanged; - changeFlags.somethingChanged = propsOrDataChanged || changeFlags.viewportChanged || changeFlags.stateChanged; - } - /* eslint-enable complexity */ - /** Clear all changeFlags, typically after an update */ - _clearChangeFlags() { - this.internalState.changeFlags = { - dataChanged: false, - propsChanged: false, - updateTriggersChanged: false, - viewportChanged: false, - stateChanged: false, - extensionsChanged: false, - propsOrDataChanged: false, - somethingChanged: false - }; - } - /** Compares the layers props with old props from a matched older layer - and extracts change flags that describe what has change so that state - can be update correctly with minimal effort */ - _diffProps(newProps, oldProps) { - const changeFlags = diffProps(newProps, oldProps); - if (changeFlags.updateTriggersChanged) { - for (const key in changeFlags.updateTriggersChanged) { - if (changeFlags.updateTriggersChanged[key]) { - this.invalidateAttribute(key); - } - } - } - if (changeFlags.transitionsChanged) { - for (const key in changeFlags.transitionsChanged) { - this.internalState.uniformTransitions.add(key, oldProps[key], newProps[key], newProps.transitions?.[key]); - } - } - return this.setChangeFlags(changeFlags); - } - /** (Internal) called by layer manager to perform extra props validation (in development only) */ - validateProps() { - validateProps(this.props); - } - /** (Internal) Called by deck picker when the hovered object changes to update the auto highlight */ - updateAutoHighlight(info) { - if (this.props.autoHighlight && !Number.isInteger(this.props.highlightedObjectIndex)) { - this._updateAutoHighlight(info); - } - } - // May be overriden by subclasses - // TODO - simplify subclassing interface - /** Update picking module parameters to highlight the hovered object */ - _updateAutoHighlight(info) { - const picking2 = { - // @ts-expect-error stricter luma gl types - highlightedObjectColor: info.picked ? info.color : null - }; - const { highlightColor } = this.props; - if (info.picked && typeof highlightColor === "function") { - picking2.highlightColor = highlightColor(info); - } - this.setShaderModuleProps({ picking: picking2 }); - this.setNeedsRedraw(); - } - /** Create new attribute manager */ - _getAttributeManager() { - const context = this.context; - return new AttributeManager(context.device, { - id: this.props.id, - stats: context.stats, - timeline: context.timeline - }); - } - // Private methods - /** Called after updateState to perform common tasks */ - _postUpdate(updateParams, forceUpdate) { - const { props, oldProps } = updateParams; - this.setNeedsRedraw(); - this._updateAttributes(); - const model = this.state.model; - if (model?.isInstanced) { - model.setInstanceCount(this.getNumInstances()); - } - const { autoHighlight, highlightedObjectIndex, highlightColor } = props; - if (forceUpdate || oldProps.autoHighlight !== autoHighlight || oldProps.highlightedObjectIndex !== highlightedObjectIndex || oldProps.highlightColor !== highlightColor) { - const picking2 = {}; - if (Array.isArray(highlightColor)) { - picking2.highlightColor = highlightColor; - } - if (forceUpdate || oldProps.autoHighlight !== autoHighlight || highlightedObjectIndex !== oldProps.highlightedObjectIndex) { - picking2.highlightedObjectColor = Number.isFinite(highlightedObjectIndex) && highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null; - } - this.setShaderModuleProps({ picking: picking2 }); - } - } - _getUpdateParams() { - return { - props: this.props, - // @ts-ignore TS2531 this method can only be called internally with internalState assigned - oldProps: this.internalState.getOldProps(), - context: this.context, - // @ts-ignore TS2531 this method can only be called internally with internalState assigned - changeFlags: this.internalState.changeFlags - }; - } - /** Checks state of attributes and model */ - _getNeedsRedraw(opts) { - if (!this.internalState) { - return false; - } - let redraw = false; - redraw = redraw || this.internalState.needsRedraw && this.id; - const attributeManager = this.getAttributeManager(); - const attributeManagerNeedsRedraw = attributeManager ? attributeManager.getNeedsRedraw(opts) : false; - redraw = redraw || attributeManagerNeedsRedraw; - if (redraw) { - for (const extension of this.props.extensions) { - extension.onNeedsRedraw.call(this, extension); - } - } - this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags; - return redraw; - } - /** Callback when asyn prop is loaded */ - _onAsyncPropUpdated() { - this._diffProps(this.props, this.internalState.getOldProps()); - this.setNeedsUpdate(); - } -}; -Layer.defaultProps = defaultProps2; -Layer.layerName = "Layer"; -var layer_default = Layer; - -// node_modules/@deck.gl/core/dist/lib/composite-layer.js -var TRACE_RENDER_LAYERS2 = "compositeLayer.renderLayers"; -var CompositeLayer = class extends layer_default { - /** `true` if this layer renders other layers */ - get isComposite() { - return true; - } - /** Returns true if all async resources are loaded */ - get isLoaded() { - return super.isLoaded && this.getSubLayers().every((layer) => layer.isLoaded); - } - /** Return last rendered sub layers */ - getSubLayers() { - return this.internalState && this.internalState.subLayers || []; - } - // initializeState is usually not needed for composite layers - // Provide empty definition to disable check for missing definition - // eslint-disable-next-line @typescript-eslint/no-empty-function - initializeState(context) { - } - /** Updates selected state members and marks the composite layer to need rerender */ - setState(updateObject) { - super.setState(updateObject); - this.setNeedsUpdate(); - } - /** called to augment the info object that is bubbled up from a sublayer - override Layer.getPickingInfo() because decoding / setting uniform do - not apply to a composite layer. */ - getPickingInfo({ info }) { - const { object } = info; - const isDataWrapped = object && object.__source && object.__source.parent && object.__source.parent.id === this.id; - if (!isDataWrapped) { - return info; - } - info.object = object.__source.object; - info.index = object.__source.index; - return info; - } - /** - * Filters sub layers at draw time. Return true if the sub layer should be drawn. - */ - filterSubLayer(context) { - return true; - } - /** Returns true if sub layer needs to be rendered */ - shouldRenderSubLayer(subLayerId, data) { - return data && data.length; - } - /** Returns sub layer class for a specific sublayer */ - getSubLayerClass(subLayerId, DefaultLayerClass) { - const { _subLayerProps: overridingProps } = this.props; - return overridingProps && overridingProps[subLayerId] && overridingProps[subLayerId].type || DefaultLayerClass; - } - /** When casting user data into another format to pass to sublayers, - add reference to the original object and object index */ - getSubLayerRow(row, sourceObject, sourceObjectIndex) { - row.__source = { - parent: this, - object: sourceObject, - index: sourceObjectIndex - }; - return row; - } - /** Some composite layers cast user data into another format before passing to sublayers - We need to unwrap them before calling the accessor so that they see the original data - objects */ - getSubLayerAccessor(accessor) { - if (typeof accessor === "function") { - const objectInfo = { - index: -1, - // @ts-ignore accessing resolved data - data: this.props.data, - target: [] - }; - return (x, i) => { - if (x && x.__source) { - objectInfo.index = x.__source.index; - return accessor(x.__source.object, objectInfo); - } - return accessor(x, i); - }; - } - return accessor; - } - /** Returns sub layer props for a specific sublayer */ - // eslint-disable-next-line complexity - getSubLayerProps(sublayerProps = {}) { - const { opacity, pickable, visible, parameters, getPolygonOffset, highlightedObjectIndex, autoHighlight, highlightColor, coordinateSystem, coordinateOrigin, wrapLongitude, positionFormat, modelMatrix, extensions, fetch: fetch2, operation, _subLayerProps: overridingProps } = this.props; - const newProps = { - id: "", - updateTriggers: {}, - opacity, - pickable, - visible, - parameters, - getPolygonOffset, - highlightedObjectIndex, - autoHighlight, - highlightColor, - coordinateSystem, - coordinateOrigin, - wrapLongitude, - positionFormat, - modelMatrix, - extensions, - fetch: fetch2, - operation - }; - const overridingSublayerProps = overridingProps && sublayerProps.id && overridingProps[sublayerProps.id]; - const overridingSublayerTriggers = overridingSublayerProps && overridingSublayerProps.updateTriggers; - const sublayerId = sublayerProps.id || "sublayer"; - if (overridingSublayerProps) { - const propTypes = this.props[PROP_TYPES_SYMBOL]; - const subLayerPropTypes = sublayerProps.type ? sublayerProps.type._propTypes : {}; - for (const key in overridingSublayerProps) { - const propType = subLayerPropTypes[key] || propTypes[key]; - if (propType && propType.type === "accessor") { - overridingSublayerProps[key] = this.getSubLayerAccessor(overridingSublayerProps[key]); - } - } - } - Object.assign( - newProps, - sublayerProps, - // experimental feature that allows users to override sublayer props via parent layer prop - overridingSublayerProps - ); - newProps.id = `${this.props.id}-${sublayerId}`; - newProps.updateTriggers = { - all: this.props.updateTriggers?.all, - ...sublayerProps.updateTriggers, - ...overridingSublayerTriggers - }; - for (const extension of extensions) { - const passThroughProps = extension.getSubLayerProps.call(this, extension); - if (passThroughProps) { - Object.assign(newProps, passThroughProps, { - updateTriggers: Object.assign(newProps.updateTriggers, passThroughProps.updateTriggers) - }); - } - } - return newProps; - } - /** Update sub layers to highlight the hovered object */ - _updateAutoHighlight(info) { - for (const layer of this.getSubLayers()) { - layer.updateAutoHighlight(info); - } - } - /** Override base Layer method */ - _getAttributeManager() { - return null; - } - /** (Internal) Called after an update to rerender sub layers */ - _postUpdate(updateParams, forceUpdate) { - let subLayers = this.internalState.subLayers; - const shouldUpdate = !subLayers || this.needsUpdate(); - if (shouldUpdate) { - const subLayersList = this.renderLayers(); - subLayers = flatten(subLayersList, Boolean); - this.internalState.subLayers = subLayers; - } - debug(TRACE_RENDER_LAYERS2, this, shouldUpdate, subLayers); - for (const layer of subLayers) { - layer.parent = this; - } - } -}; -CompositeLayer.layerName = "CompositeLayer"; -var composite_layer_default = CompositeLayer; - -// node_modules/@deck.gl/core/dist/viewports/globe-viewport.js -var DEGREES_TO_RADIANS5 = Math.PI / 180; -var RADIANS_TO_DEGREES3 = 180 / Math.PI; -var EARTH_RADIUS = 6370972; -var GLOBE_RADIUS = 256; -function getDistanceScales2() { - const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS; - const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS; - return { - unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2], - unitsPerMeter2: [0, 0, 0], - metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2], - unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2], - unitsPerDegree2: [0, 0, 0], - degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2] - }; -} -var GlobeViewport = class extends viewport_default { - constructor(opts = {}) { - const { latitude = 0, longitude = 0, zoom = 0, nearZMultiplier = 0.1, farZMultiplier = 2, resolution = 10 } = opts; - let { height, altitude = 1.5 } = opts; - height = height || 1; - altitude = Math.max(0.75, altitude); - const viewMatrix = new Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }); - const scale13 = Math.pow(2, zoom); - viewMatrix.rotateX(latitude * DEGREES_TO_RADIANS5); - viewMatrix.rotateZ(-longitude * DEGREES_TO_RADIANS5); - viewMatrix.scale(scale13 / height); - const halfFov = Math.atan(0.5 / altitude); - const relativeScale = GLOBE_RADIUS * 2 * scale13 / height; - super({ - ...opts, - // x, y, width, - height, - // view matrix - viewMatrix, - longitude, - latitude, - zoom, - // projection matrix parameters - distanceScales: getDistanceScales2(), - fovyRadians: halfFov * 2, - focalDistance: altitude, - near: nearZMultiplier, - far: Math.min(2, 1 / relativeScale + 1) * altitude * farZMultiplier - }); - this.latitude = latitude; - this.longitude = longitude; - this.resolution = resolution; - } - get projectionMode() { - return PROJECTION_MODE.GLOBE; - } - getDistanceScales() { - return this.distanceScales; - } - getBounds(options = {}) { - const unprojectOption = { targetZ: options.z || 0 }; - const left = this.unproject([0, this.height / 2], unprojectOption); - const top = this.unproject([this.width / 2, 0], unprojectOption); - const right = this.unproject([this.width, this.height / 2], unprojectOption); - const bottom = this.unproject([this.width / 2, this.height], unprojectOption); - if (right[0] < this.longitude) - right[0] += 360; - if (left[0] > this.longitude) - left[0] -= 360; - return [ - Math.min(left[0], right[0], top[0], bottom[0]), - Math.min(left[1], right[1], top[1], bottom[1]), - Math.max(left[0], right[0], top[0], bottom[0]), - Math.max(left[1], right[1], top[1], bottom[1]) - ]; - } - unproject(xyz, { topLeft = true, targetZ } = {}) { - const [x, y, z] = xyz; - const y2 = topLeft ? y : this.height - y; - const { pixelUnprojectionMatrix } = this; - let coord; - if (Number.isFinite(z)) { - coord = transformVector2(pixelUnprojectionMatrix, [x, y2, z, 1]); - } else { - const coord0 = transformVector2(pixelUnprojectionMatrix, [x, y2, -1, 1]); - const coord1 = transformVector2(pixelUnprojectionMatrix, [x, y2, 1, 1]); - const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS; - const lSqr = vec3_exports.sqrLen(vec3_exports.sub([], coord0, coord1)); - const l0Sqr = vec3_exports.sqrLen(coord0); - const l1Sqr = vec3_exports.sqrLen(coord1); - const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16; - const dSqr = 4 * sSqr / lSqr; - const r0 = Math.sqrt(l0Sqr - dSqr); - const dr = Math.sqrt(Math.max(0, lt * lt - dSqr)); - const t = (r0 - dr) / Math.sqrt(lSqr); - coord = vec3_exports.lerp([], coord0, coord1, t); - } - const [X, Y, Z] = this.unprojectPosition(coord); - if (Number.isFinite(z)) { - return [X, Y, Z]; - } - return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; - } - projectPosition(xyz) { - const [lng, lat, Z = 0] = xyz; - const lambda = lng * DEGREES_TO_RADIANS5; - const phi = lat * DEGREES_TO_RADIANS5; - const cosPhi = Math.cos(phi); - const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS; - return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D]; - } - unprojectPosition(xyz) { - const [x, y, z] = xyz; - const D = vec3_exports.len(xyz); - const phi = Math.asin(z / D); - const lambda = Math.atan2(x, -y); - const lng = lambda * RADIANS_TO_DEGREES3; - const lat = phi * RADIANS_TO_DEGREES3; - const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS; - return [lng, lat, Z]; - } - projectFlat(xyz) { - return xyz; - } - unprojectFlat(xyz) { - return xyz; - } - panByPosition(coords, pixel) { - const fromPosition = this.unproject(pixel); - return { - longitude: coords[0] - fromPosition[0] + this.longitude, - latitude: coords[1] - fromPosition[1] + this.latitude - }; - } -}; -function transformVector2(matrix, vector) { - const result = vec4_exports.transformMat4([], vector, matrix); - vec4_exports.scale(result, result, 1 / result[3]); - return result; -} - -// node_modules/@deck.gl/core/dist/utils/tesselator.js -var Tesselator = class { - constructor(opts) { - this.indexStarts = [0]; - this.vertexStarts = [0]; - this.vertexCount = 0; - this.instanceCount = 0; - const { attributes = {} } = opts; - this.typedArrayManager = typed_array_manager_default; - this.attributes = {}; - this._attributeDefs = attributes; - this.opts = opts; - this.updateGeometry(opts); - } - /* Public methods */ - updateGeometry(opts) { - Object.assign(this.opts, opts); - const { data, buffers = {}, getGeometry, geometryBuffer, positionFormat, dataChanged, normalize: normalize11 = true } = this.opts; - this.data = data; - this.getGeometry = getGeometry; - this.positionSize = // @ts-ignore (2339) when geometryBuffer is a luma Buffer, size falls back to positionFormat - geometryBuffer && geometryBuffer.size || (positionFormat === "XY" ? 2 : 3); - this.buffers = buffers; - this.normalize = normalize11; - if (geometryBuffer) { - assert9(data.startIndices); - this.getGeometry = this.getGeometryFromBuffer(geometryBuffer); - if (!normalize11) { - buffers.vertexPositions = geometryBuffer; - } - } - this.geometryBuffer = buffers.vertexPositions; - if (Array.isArray(dataChanged)) { - for (const dataRange of dataChanged) { - this._rebuildGeometry(dataRange); - } - } else { - this._rebuildGeometry(); - } - } - updatePartialGeometry({ startRow, endRow }) { - this._rebuildGeometry({ startRow, endRow }); - } - getGeometryFromBuffer(geometryBuffer) { - const value = geometryBuffer.value || geometryBuffer; - if (!ArrayBuffer.isView(value)) { - return null; - } - return getAccessorFromBuffer(value, { - size: this.positionSize, - offset: geometryBuffer.offset, - stride: geometryBuffer.stride, - startIndices: this.data.startIndices - }); - } - /* Private utility methods */ - _allocate(instanceCount, copy12) { - const { attributes, buffers, _attributeDefs, typedArrayManager } = this; - for (const name2 in _attributeDefs) { - if (name2 in buffers) { - typedArrayManager.release(attributes[name2]); - attributes[name2] = null; - } else { - const def = _attributeDefs[name2]; - def.copy = copy12; - attributes[name2] = typedArrayManager.allocate(attributes[name2], instanceCount, def); - } - } - } - /** - * Visit all objects - * `data` is expected to be an iterable consistent with the base Layer expectation - */ - _forEachGeometry(visitor, startRow, endRow) { - const { data, getGeometry } = this; - const { iterable, objectInfo } = createIterable(data, startRow, endRow); - for (const object of iterable) { - objectInfo.index++; - const geometry = getGeometry ? getGeometry(object, objectInfo) : null; - visitor(geometry, objectInfo.index); - } - } - /* eslint-disable complexity,max-statements */ - _rebuildGeometry(dataRange) { - if (!this.data) { - return; - } - let { indexStarts, vertexStarts, instanceCount } = this; - const { data, geometryBuffer } = this; - const { startRow = 0, endRow = Infinity } = dataRange || {}; - const normalizedData = {}; - if (!dataRange) { - indexStarts = [0]; - vertexStarts = [0]; - } - if (this.normalize || !geometryBuffer) { - this._forEachGeometry((geometry, dataIndex) => { - const normalizedGeometry = geometry && this.normalizeGeometry(geometry); - normalizedData[dataIndex] = normalizedGeometry; - vertexStarts[dataIndex + 1] = vertexStarts[dataIndex] + (normalizedGeometry ? this.getGeometrySize(normalizedGeometry) : 0); - }, startRow, endRow); - instanceCount = vertexStarts[vertexStarts.length - 1]; - } else { - vertexStarts = data.startIndices; - instanceCount = vertexStarts[data.length] || 0; - if (ArrayBuffer.isView(geometryBuffer)) { - instanceCount = instanceCount || geometryBuffer.length / this.positionSize; - } else if (geometryBuffer instanceof Buffer2) { - const byteStride = this.positionSize * 4; - instanceCount = instanceCount || geometryBuffer.byteLength / byteStride; - } else if (geometryBuffer.buffer) { - const byteStride = geometryBuffer.stride || this.positionSize * 4; - instanceCount = instanceCount || geometryBuffer.buffer.byteLength / byteStride; - } else if (geometryBuffer.value) { - const bufferValue = geometryBuffer.value; - const elementStride = ( - // @ts-ignore (2339) if stride is not specified, will fall through to positionSize - geometryBuffer.stride / bufferValue.BYTES_PER_ELEMENT || this.positionSize - ); - instanceCount = instanceCount || bufferValue.length / elementStride; - } - } - this._allocate(instanceCount, Boolean(dataRange)); - this.indexStarts = indexStarts; - this.vertexStarts = vertexStarts; - this.instanceCount = instanceCount; - const context = {}; - this._forEachGeometry((geometry, dataIndex) => { - const normalizedGeometry = normalizedData[dataIndex] || geometry; - context.vertexStart = vertexStarts[dataIndex]; - context.indexStart = indexStarts[dataIndex]; - const vertexEnd = dataIndex < vertexStarts.length - 1 ? vertexStarts[dataIndex + 1] : instanceCount; - context.geometrySize = vertexEnd - vertexStarts[dataIndex]; - context.geometryIndex = dataIndex; - this.updateGeometryAttributes(normalizedGeometry, context); - }, startRow, endRow); - this.vertexCount = indexStarts[indexStarts.length - 1]; - } -}; - -// node_modules/@deck.gl/layers/dist/bitmap-layer/create-mesh.js -var DEFAULT_INDICES = new Uint32Array([0, 2, 1, 0, 3, 2]); -var DEFAULT_TEX_COORDS = new Float32Array([0, 1, 0, 0, 1, 0, 1, 1]); -function createMesh(bounds, resolution) { - if (!resolution) { - return createQuad(bounds); - } - const maxXSpan = Math.max(Math.abs(bounds[0][0] - bounds[3][0]), Math.abs(bounds[1][0] - bounds[2][0])); - const maxYSpan = Math.max(Math.abs(bounds[1][1] - bounds[0][1]), Math.abs(bounds[2][1] - bounds[3][1])); - const uCount = Math.ceil(maxXSpan / resolution) + 1; - const vCount = Math.ceil(maxYSpan / resolution) + 1; - const vertexCount = (uCount - 1) * (vCount - 1) * 6; - const indices = new Uint32Array(vertexCount); - const texCoords = new Float32Array(uCount * vCount * 2); - const positions = new Float64Array(uCount * vCount * 3); - let vertex = 0; - let index2 = 0; - for (let u = 0; u < uCount; u++) { - const ut = u / (uCount - 1); - for (let v = 0; v < vCount; v++) { - const vt = v / (vCount - 1); - const p = interpolateQuad(bounds, ut, vt); - positions[vertex * 3 + 0] = p[0]; - positions[vertex * 3 + 1] = p[1]; - positions[vertex * 3 + 2] = p[2] || 0; - texCoords[vertex * 2 + 0] = ut; - texCoords[vertex * 2 + 1] = 1 - vt; - if (u > 0 && v > 0) { - indices[index2++] = vertex - vCount; - indices[index2++] = vertex - vCount - 1; - indices[index2++] = vertex - 1; - indices[index2++] = vertex - vCount; - indices[index2++] = vertex - 1; - indices[index2++] = vertex; - } - vertex++; - } - } - return { - vertexCount, - positions, - indices, - texCoords - }; -} -function createQuad(bounds) { - const positions = new Float64Array(12); - for (let i = 0; i < bounds.length; i++) { - positions[i * 3 + 0] = bounds[i][0]; - positions[i * 3 + 1] = bounds[i][1]; - positions[i * 3 + 2] = bounds[i][2] || 0; - } - return { - vertexCount: 6, - positions, - indices: DEFAULT_INDICES, - texCoords: DEFAULT_TEX_COORDS - }; -} -function interpolateQuad(quad, ut, vt) { - return lerp(lerp(quad[0], quad[1], vt), lerp(quad[3], quad[2], vt), ut); -} - -// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer-vertex.js -var bitmap_layer_vertex_default = `#version 300 es -#define SHADER_NAME bitmap-layer-vertex-shader - -in vec2 texCoords; -in vec3 positions; -in vec3 positions64Low; - -out vec2 vTexCoord; -out vec2 vTexPos; - -uniform float coordinateConversion; - -const vec3 pickingColor = vec3(1.0, 0.0, 0.0); - -void main(void) { - geometry.worldPosition = positions; - geometry.uv = texCoords; - geometry.pickingColor = pickingColor; - - gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position); - DECKGL_FILTER_GL_POSITION(gl_Position, geometry); - - vTexCoord = texCoords; - - if (coordinateConversion < -0.5) { - vTexPos = geometry.position.xy + project_uCommonOrigin.xy; - } else if (coordinateConversion > 0.5) { - vTexPos = geometry.worldPosition.xy; - } - - vec4 color = vec4(0.0); - DECKGL_FILTER_COLOR(color, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer-fragment.js -var packUVsIntoRGB = ` -vec3 packUVsIntoRGB(vec2 uv) { - // Extract the top 8 bits. We want values to be truncated down so we can add a fraction - vec2 uv8bit = floor(uv * 256.); - - // Calculate the normalized remainders of u and v parts that do not fit into 8 bits - // Scale and clamp to 0-1 range - vec2 uvFraction = fract(uv * 256.); - vec2 uvFraction4bit = floor(uvFraction * 16.); - - // Remainder can be encoded in blue channel, encode as 4 bits for pixel coordinates - float fractions = uvFraction4bit.x + uvFraction4bit.y * 16.; - - return vec3(uv8bit, fractions) / 255.; -} -`; -var bitmap_layer_fragment_default = `#version 300 es -#define SHADER_NAME bitmap-layer-fragment-shader - -#ifdef GL_ES -precision highp float; -#endif - -uniform sampler2D bitmapTexture; - -in vec2 vTexCoord; -in vec2 vTexPos; - -out vec4 fragColor; - -uniform float desaturate; -uniform vec4 transparentColor; -uniform vec3 tintColor; -uniform float opacity; - -uniform float coordinateConversion; -uniform vec4 bounds; - -/* projection utils */ -const float TILE_SIZE = 512.0; -const float PI = 3.1415926536; -const float WORLD_SCALE = TILE_SIZE / PI / 2.0; - -// from degrees to Web Mercator -vec2 lnglat_to_mercator(vec2 lnglat) { - float x = lnglat.x; - float y = clamp(lnglat.y, -89.9, 89.9); - return vec2( - radians(x) + PI, - PI + log(tan(PI * 0.25 + radians(y) * 0.5)) - ) * WORLD_SCALE; -} - -// from Web Mercator to degrees -vec2 mercator_to_lnglat(vec2 xy) { - xy /= WORLD_SCALE; - return degrees(vec2( - xy.x - PI, - atan(exp(xy.y - PI)) * 2.0 - PI * 0.5 - )); -} -/* End projection utils */ - -// apply desaturation -vec3 color_desaturate(vec3 color) { - float luminance = (color.r + color.g + color.b) * 0.333333333; - return mix(color, vec3(luminance), desaturate); -} - -// apply tint -vec3 color_tint(vec3 color) { - return color * tintColor; -} - -// blend with background color -vec4 apply_opacity(vec3 color, float alpha) { - if (transparentColor.a == 0.0) { - return vec4(color, alpha); - } - float blendedAlpha = alpha + transparentColor.a * (1.0 - alpha); - float highLightRatio = alpha / blendedAlpha; - vec3 blendedRGB = mix(transparentColor.rgb, color, highLightRatio); - return vec4(blendedRGB, blendedAlpha); -} - -vec2 getUV(vec2 pos) { - return vec2( - (pos.x - bounds[0]) / (bounds[2] - bounds[0]), - (pos.y - bounds[3]) / (bounds[1] - bounds[3]) - ); -} - -${packUVsIntoRGB} - -void main(void) { - vec2 uv = vTexCoord; - if (coordinateConversion < -0.5) { - vec2 lnglat = mercator_to_lnglat(vTexPos); - uv = getUV(lnglat); - } else if (coordinateConversion > 0.5) { - vec2 commonPos = lnglat_to_mercator(vTexPos); - uv = getUV(commonPos); - } - vec4 bitmapColor = texture(bitmapTexture, uv); - - fragColor = apply_opacity(color_tint(color_desaturate(bitmapColor.rgb)), bitmapColor.a * opacity); - - geometry.uv = uv; - DECKGL_FILTER_COLOR(fragColor, geometry); - - if (bool(picking.isActive) && !bool(picking.isAttribute)) { - // Since instance information is not used, we can use picking color for pixel index - fragColor.rgb = packUVsIntoRGB(uv); - } -} -`; - -// node_modules/@deck.gl/layers/dist/bitmap-layer/bitmap-layer.js -var defaultProps3 = { - image: { type: "image", value: null, async: true }, - bounds: { type: "array", value: [1, 0, 0, 1], compare: true }, - _imageCoordinateSystem: COORDINATE_SYSTEM.DEFAULT, - desaturate: { type: "number", min: 0, max: 1, value: 0 }, - // More context: because of the blending mode we're using for ground imagery, - // alpha is not effective when blending the bitmap layers with the base map. - // Instead we need to manually dim/blend rgb values with a background color. - transparentColor: { type: "color", value: [0, 0, 0, 0] }, - tintColor: { type: "color", value: [255, 255, 255] }, - textureParameters: { type: "object", ignore: true, value: null } -}; -var BitmapLayer = class extends layer_default { - getShaders() { - return super.getShaders({ vs: bitmap_layer_vertex_default, fs: bitmap_layer_fragment_default, modules: [project32_default, picking_default] }); - } - initializeState() { - const attributeManager = this.getAttributeManager(); - attributeManager.remove(["instancePickingColors"]); - const noAlloc = true; - attributeManager.add({ - indices: { - size: 1, - isIndexed: true, - update: (attribute) => attribute.value = this.state.mesh.indices, - noAlloc - }, - positions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - update: (attribute) => attribute.value = this.state.mesh.positions, - noAlloc - }, - texCoords: { - size: 2, - update: (attribute) => attribute.value = this.state.mesh.texCoords, - noAlloc - } - }); - } - updateState({ props, oldProps, changeFlags }) { - const attributeManager = this.getAttributeManager(); - if (changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - attributeManager.invalidateAll(); - } - if (props.bounds !== oldProps.bounds) { - const oldMesh = this.state.mesh; - const mesh = this._createMesh(); - this.state.model.setVertexCount(mesh.vertexCount); - for (const key in mesh) { - if (oldMesh && oldMesh[key] !== mesh[key]) { - attributeManager.invalidate(key); - } - } - this.setState({ mesh, ...this._getCoordinateUniforms() }); - } else if (props._imageCoordinateSystem !== oldProps._imageCoordinateSystem) { - this.setState(this._getCoordinateUniforms()); - } - } - getPickingInfo(params) { - const { image } = this.props; - const info = params.info; - if (!info.color || !image) { - info.bitmap = null; - return info; - } - const { width, height } = image; - info.index = 0; - const uv = unpackUVsFromRGB(info.color); - info.bitmap = { - size: { width, height }, - uv, - pixel: [Math.floor(uv[0] * width), Math.floor(uv[1] * height)] - }; - return info; - } - // Override base Layer multi-depth picking logic - disablePickingIndex() { - this.setState({ disablePicking: true }); - } - restorePickingColors() { - this.setState({ disablePicking: false }); - } - _updateAutoHighlight(info) { - super._updateAutoHighlight({ - ...info, - color: this.encodePickingColor(0) - }); - } - _createMesh() { - const { bounds } = this.props; - let normalizedBounds = bounds; - if (isRectangularBounds(bounds)) { - normalizedBounds = [ - [bounds[0], bounds[1]], - [bounds[0], bounds[3]], - [bounds[2], bounds[3]], - [bounds[2], bounds[1]] - ]; - } - return createMesh(normalizedBounds, this.context.viewport.resolution); - } - _getModel() { - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - topology: "triangle-list", - isInstanced: false - }); - } - draw(opts) { - const { uniforms, moduleParameters } = opts; - const { model, coordinateConversion, bounds, disablePicking } = this.state; - const { image, desaturate, transparentColor, tintColor } = this.props; - if (moduleParameters.picking.isActive && disablePicking) { - return; - } - if (image && model) { - model.setUniforms(uniforms); - model.setBindings({ bitmapTexture: image }); - model.setUniforms({ - desaturate, - transparentColor: transparentColor.map((x) => x / 255), - // @ts-expect-error stricter luma gl types - tintColor: tintColor.slice(0, 3).map((x) => x / 255), - coordinateConversion, - bounds - }); - model.draw(this.context.renderPass); - } - } - _getCoordinateUniforms() { - const { LNGLAT, CARTESIAN, DEFAULT } = COORDINATE_SYSTEM; - let { _imageCoordinateSystem: imageCoordinateSystem } = this.props; - if (imageCoordinateSystem !== DEFAULT) { - const { bounds } = this.props; - if (!isRectangularBounds(bounds)) { - throw new Error("_imageCoordinateSystem only supports rectangular bounds"); - } - const defaultImageCoordinateSystem = this.context.viewport.resolution ? LNGLAT : CARTESIAN; - imageCoordinateSystem = imageCoordinateSystem === LNGLAT ? LNGLAT : CARTESIAN; - if (imageCoordinateSystem === LNGLAT && defaultImageCoordinateSystem === CARTESIAN) { - return { coordinateConversion: -1, bounds }; - } - if (imageCoordinateSystem === CARTESIAN && defaultImageCoordinateSystem === LNGLAT) { - const bottomLeft = lngLatToWorld([bounds[0], bounds[1]]); - const topRight = lngLatToWorld([bounds[2], bounds[3]]); - return { - coordinateConversion: 1, - bounds: [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]] - }; - } - } - return { - coordinateConversion: 0, - bounds: [0, 0, 0, 0] - }; - } -}; -BitmapLayer.layerName = "BitmapLayer"; -BitmapLayer.defaultProps = defaultProps3; -var bitmap_layer_default = BitmapLayer; -function unpackUVsFromRGB(color) { - const [u, v, fracUV] = color; - const vFrac = (fracUV & 240) / 256; - const uFrac = (fracUV & 15) / 16; - return [(u + uFrac) / 256, (v + vFrac) / 256]; -} -function isRectangularBounds(bounds) { - return Number.isFinite(bounds[0]); -} - -// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer-vertex.glsl.js -var icon_layer_vertex_glsl_default = `#version 300 es -#define SHADER_NAME icon-layer-vertex-shader -in vec2 positions; -in vec3 instancePositions; -in vec3 instancePositions64Low; -in float instanceSizes; -in float instanceAngles; -in vec4 instanceColors; -in vec3 instancePickingColors; -in vec4 instanceIconFrames; -in float instanceColorModes; -in vec2 instanceOffsets; -in vec2 instancePixelOffset; -uniform float sizeScale; -uniform vec2 iconsTextureDim; -uniform float sizeMinPixels; -uniform float sizeMaxPixels; -uniform bool billboard; -uniform int sizeUnits; -out float vColorMode; -out vec4 vColor; -out vec2 vTextureCoords; -out vec2 uv; -vec2 rotate_by_angle(vec2 vertex, float angle) { -float angle_radian = angle * PI / 180.0; -float cos_angle = cos(angle_radian); -float sin_angle = sin(angle_radian); -mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle); -return rotationMatrix * vertex; -} -void main(void) { -geometry.worldPosition = instancePositions; -geometry.uv = positions; -geometry.pickingColor = instancePickingColors; -uv = positions; -vec2 iconSize = instanceIconFrames.zw; -float sizePixels = clamp( -project_size_to_pixel(instanceSizes * sizeScale, sizeUnits), -sizeMinPixels, sizeMaxPixels -); -float instanceScale = iconSize.y == 0.0 ? 0.0 : sizePixels / iconSize.y; -vec2 pixelOffset = positions / 2.0 * iconSize + instanceOffsets; -pixelOffset = rotate_by_angle(pixelOffset, instanceAngles) * instanceScale; -pixelOffset += instancePixelOffset; -pixelOffset.y *= -1.0; -if (billboard) { -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -vec3 offset = vec3(pixelOffset, 0.0); -DECKGL_FILTER_SIZE(offset, geometry); -gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); -} else { -vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0); -DECKGL_FILTER_SIZE(offset_common, geometry); -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -} -vTextureCoords = mix( -instanceIconFrames.xy, -instanceIconFrames.xy + iconSize, -(positions.xy + 1.0) / 2.0 -) / iconsTextureDim; -vColor = instanceColors; -DECKGL_FILTER_COLOR(vColor, geometry); -vColorMode = instanceColorModes; -} -`; - -// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer-fragment.glsl.js -var icon_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME icon-layer-fragment-shader -precision highp float; -uniform float opacity; -uniform sampler2D iconsTexture; -uniform float alphaCutoff; -in float vColorMode; -in vec4 vColor; -in vec2 vTextureCoords; -in vec2 uv; -out vec4 fragColor; -void main(void) { -geometry.uv = uv; -vec4 texColor = texture(iconsTexture, vTextureCoords); -vec3 color = mix(texColor.rgb, vColor.rgb, vColorMode); -float a = texColor.a * opacity * vColor.a; -if (a < alphaCutoff) { -discard; -} -fragColor = vec4(color, a); -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/icon-layer/icon-manager.js -var DEFAULT_CANVAS_WIDTH = 1024; -var DEFAULT_BUFFER = 4; -var noop4 = () => { -}; -var DEFAULT_SAMPLER_PARAMETERS = { - minFilter: "linear", - mipmapFilter: "linear", - // LINEAR is the default value but explicitly set it here - magFilter: "linear", - // minimize texture boundary artifacts - addressModeU: "clamp-to-edge", - addressModeV: "clamp-to-edge" -}; -var MISSING_ICON = { - x: 0, - y: 0, - width: 0, - height: 0 -}; -function nextPowOfTwo(number) { - return Math.pow(2, Math.ceil(Math.log2(number))); -} -function resizeImage(ctx2, imageData, maxWidth, maxHeight) { - const resizeRatio = Math.min(maxWidth / imageData.width, maxHeight / imageData.height); - const width = Math.floor(imageData.width * resizeRatio); - const height = Math.floor(imageData.height * resizeRatio); - if (resizeRatio === 1) { - return { data: imageData, width, height }; - } - ctx2.canvas.height = height; - ctx2.canvas.width = width; - ctx2.clearRect(0, 0, width, height); - ctx2.drawImage(imageData, 0, 0, imageData.width, imageData.height, 0, 0, width, height); - return { data: ctx2.canvas, width, height }; -} -function getIconId(icon) { - return icon && (icon.id || icon.url); -} -function resizeTexture(texture, width, height, sampler) { - const { width: oldWidth, height: oldHeight, device } = texture; - const newTexture = device.createTexture({ format: "rgba8unorm", width, height, sampler }); - const commandEncoder = device.createCommandEncoder(); - commandEncoder.copyTextureToTexture({ - source: texture, - destination: newTexture, - width: oldWidth, - height: oldHeight - }); - commandEncoder.finish(); - texture.destroy(); - return newTexture; -} -function buildRowMapping(mapping, columns, yOffset) { - for (let i = 0; i < columns.length; i++) { - const { icon, xOffset } = columns[i]; - const id = getIconId(icon); - mapping[id] = { - ...icon, - x: xOffset, - y: yOffset - }; - } -} -function buildMapping({ icons, buffer, mapping = {}, xOffset = 0, yOffset = 0, rowHeight = 0, canvasWidth }) { - let columns = []; - for (let i = 0; i < icons.length; i++) { - const icon = icons[i]; - const id = getIconId(icon); - if (!mapping[id]) { - const { height, width } = icon; - if (xOffset + width + buffer > canvasWidth) { - buildRowMapping(mapping, columns, yOffset); - xOffset = 0; - yOffset = rowHeight + yOffset + buffer; - rowHeight = 0; - columns = []; - } - columns.push({ - icon, - xOffset - }); - xOffset = xOffset + width + buffer; - rowHeight = Math.max(rowHeight, height); - } - } - if (columns.length > 0) { - buildRowMapping(mapping, columns, yOffset); - } - return { - mapping, - rowHeight, - xOffset, - yOffset, - canvasWidth, - canvasHeight: nextPowOfTwo(rowHeight + yOffset + buffer) - }; -} -function getDiffIcons(data, getIcon, cachedIcons) { - if (!data || !getIcon) { - return null; - } - cachedIcons = cachedIcons || {}; - const icons = {}; - const { iterable, objectInfo } = createIterable(data); - for (const object of iterable) { - objectInfo.index++; - const icon = getIcon(object, objectInfo); - const id = getIconId(icon); - if (!icon) { - throw new Error("Icon is missing."); - } - if (!icon.url) { - throw new Error("Icon url is missing."); - } - if (!icons[id] && (!cachedIcons[id] || icon.url !== cachedIcons[id].url)) { - icons[id] = { ...icon, source: object, sourceIndex: objectInfo.index }; - } - } - return icons; -} -var IconManager = class { - constructor(device, { onUpdate = noop4, onError = noop4 }) { - this._loadOptions = null; - this._texture = null; - this._externalTexture = null; - this._mapping = {}; - this._textureParameters = null; - this._pendingCount = 0; - this._autoPacking = false; - this._xOffset = 0; - this._yOffset = 0; - this._rowHeight = 0; - this._buffer = DEFAULT_BUFFER; - this._canvasWidth = DEFAULT_CANVAS_WIDTH; - this._canvasHeight = 0; - this._canvas = null; - this.device = device; - this.onUpdate = onUpdate; - this.onError = onError; - } - finalize() { - this._texture?.delete(); - } - getTexture() { - return this._texture || this._externalTexture; - } - getIconMapping(icon) { - const id = this._autoPacking ? getIconId(icon) : icon; - return this._mapping[id] || MISSING_ICON; - } - setProps({ loadOptions, autoPacking, iconAtlas, iconMapping, textureParameters }) { - if (loadOptions) { - this._loadOptions = loadOptions; - } - if (autoPacking !== void 0) { - this._autoPacking = autoPacking; - } - if (iconMapping) { - this._mapping = iconMapping; - } - if (iconAtlas) { - this._texture?.delete(); - this._texture = null; - this._externalTexture = iconAtlas; - } - if (textureParameters) { - this._textureParameters = textureParameters; - } - } - get isLoaded() { - return this._pendingCount === 0; - } - packIcons(data, getIcon) { - if (!this._autoPacking || typeof document === "undefined") { - return; - } - const icons = Object.values(getDiffIcons(data, getIcon, this._mapping) || {}); - if (icons.length > 0) { - const { mapping, xOffset, yOffset, rowHeight, canvasHeight } = buildMapping({ - icons, - buffer: this._buffer, - canvasWidth: this._canvasWidth, - mapping: this._mapping, - rowHeight: this._rowHeight, - xOffset: this._xOffset, - yOffset: this._yOffset - }); - this._rowHeight = rowHeight; - this._mapping = mapping; - this._xOffset = xOffset; - this._yOffset = yOffset; - this._canvasHeight = canvasHeight; - if (!this._texture) { - this._texture = this.device.createTexture({ - format: "rgba8unorm", - width: this._canvasWidth, - height: this._canvasHeight, - sampler: this._textureParameters || DEFAULT_SAMPLER_PARAMETERS - }); - } - if (this._texture.height !== this._canvasHeight) { - this._texture = resizeTexture(this._texture, this._canvasWidth, this._canvasHeight, this._textureParameters || DEFAULT_SAMPLER_PARAMETERS); - } - this.onUpdate(); - this._canvas = this._canvas || document.createElement("canvas"); - this._loadIcons(icons); - } - } - _loadIcons(icons) { - const ctx2 = this._canvas.getContext("2d", { - willReadFrequently: true - }); - for (const icon of icons) { - this._pendingCount++; - load(icon.url, this._loadOptions).then((imageData) => { - const id = getIconId(icon); - const iconDef = this._mapping[id]; - const { x, y, width: maxWidth, height: maxHeight } = iconDef; - const { data, width, height } = resizeImage(ctx2, imageData, maxWidth, maxHeight); - this._texture.setSubImageData({ - data, - x: x + (maxWidth - width) / 2, - y: y + (maxHeight - height) / 2, - width, - height - }); - iconDef.width = width; - iconDef.height = height; - this._texture.generateMipmap(); - this.onUpdate(); - }).catch((error) => { - this.onError({ - url: icon.url, - source: icon.source, - sourceIndex: icon.sourceIndex, - loadOptions: this._loadOptions, - error - }); - }).finally(() => { - this._pendingCount--; - }); - } - } -}; - -// node_modules/@deck.gl/layers/dist/icon-layer/icon-layer.js -var DEFAULT_COLOR = [0, 0, 0, 255]; -var defaultProps4 = { - iconAtlas: { type: "image", value: null, async: true }, - iconMapping: { type: "object", value: {}, async: true }, - sizeScale: { type: "number", value: 1, min: 0 }, - billboard: true, - sizeUnits: "pixels", - sizeMinPixels: { type: "number", min: 0, value: 0 }, - // min point radius in pixels - sizeMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, - // max point radius in pixels - alphaCutoff: { type: "number", value: 0.05, min: 0, max: 1 }, - getPosition: { type: "accessor", value: (x) => x.position }, - getIcon: { type: "accessor", value: (x) => x.icon }, - getColor: { type: "accessor", value: DEFAULT_COLOR }, - getSize: { type: "accessor", value: 1 }, - getAngle: { type: "accessor", value: 0 }, - getPixelOffset: { type: "accessor", value: [0, 0] }, - onIconError: { type: "function", value: null, optional: true }, - textureParameters: { type: "object", ignore: true, value: null } -}; -var IconLayer = class extends layer_default { - getShaders() { - return super.getShaders({ vs: icon_layer_vertex_glsl_default, fs: icon_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); - } - initializeState() { - this.state = { - iconManager: new IconManager(this.context.device, { - onUpdate: this._onUpdate.bind(this), - onError: this._onError.bind(this) - }) - }; - const attributeManager = this.getAttributeManager(); - attributeManager.addInstanced({ - instancePositions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - transition: true, - accessor: "getPosition" - }, - instanceSizes: { - size: 1, - transition: true, - accessor: "getSize", - defaultValue: 1 - }, - instanceOffsets: { - size: 2, - accessor: "getIcon", - // eslint-disable-next-line @typescript-eslint/unbound-method - transform: this.getInstanceOffset - }, - instanceIconFrames: { - size: 4, - accessor: "getIcon", - // eslint-disable-next-line @typescript-eslint/unbound-method - transform: this.getInstanceIconFrame - }, - instanceColorModes: { - size: 1, - type: "uint8", - accessor: "getIcon", - // eslint-disable-next-line @typescript-eslint/unbound-method - transform: this.getInstanceColorMode - }, - instanceColors: { - size: this.props.colorFormat.length, - type: "unorm8", - transition: true, - accessor: "getColor", - defaultValue: DEFAULT_COLOR - }, - instanceAngles: { - size: 1, - transition: true, - accessor: "getAngle" - }, - instancePixelOffset: { - size: 2, - transition: true, - accessor: "getPixelOffset" - } - }); - } - /* eslint-disable max-statements, complexity */ - updateState(params) { - super.updateState(params); - const { props, oldProps, changeFlags } = params; - const attributeManager = this.getAttributeManager(); - const { iconAtlas, iconMapping, data, getIcon, textureParameters } = props; - const { iconManager } = this.state; - if (typeof iconAtlas === "string") { - return; - } - const prePacked = iconAtlas || this.internalState.isAsyncPropLoading("iconAtlas"); - iconManager.setProps({ - loadOptions: props.loadOptions, - autoPacking: !prePacked, - iconAtlas, - iconMapping: prePacked ? iconMapping : null, - textureParameters - }); - if (prePacked) { - if (oldProps.iconMapping !== props.iconMapping) { - attributeManager.invalidate("getIcon"); - } - } else if (changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getIcon)) { - iconManager.packIcons(data, getIcon); - } - if (changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - attributeManager.invalidateAll(); - } - } - /* eslint-enable max-statements, complexity */ - get isLoaded() { - return super.isLoaded && this.state.iconManager.isLoaded; - } - finalizeState(context) { - super.finalizeState(context); - this.state.iconManager.finalize(); - } - draw({ uniforms }) { - const { sizeScale, sizeMinPixels, sizeMaxPixels, sizeUnits, billboard, alphaCutoff } = this.props; - const { iconManager } = this.state; - const iconsTexture = iconManager.getTexture(); - if (iconsTexture) { - const model = this.state.model; - model.setBindings({ iconsTexture }); - model.setUniforms(uniforms); - model.setUniforms({ - iconsTextureDim: [iconsTexture.width, iconsTexture.height], - sizeUnits: UNIT[sizeUnits], - sizeScale, - sizeMinPixels, - sizeMaxPixels, - billboard, - alphaCutoff - }); - model.draw(this.context.renderPass); - } - } - _getModel() { - const positions = [-1, -1, 1, -1, -1, 1, 1, 1]; - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - geometry: new Geometry({ - topology: "triangle-strip", - attributes: { - // The size must be explicitly passed here otherwise luma.gl - // will default to assuming that positions are 3D (x,y,z) - positions: { - size: 2, - value: new Float32Array(positions) - } - } - }), - isInstanced: true - }); - } - _onUpdate() { - this.setNeedsRedraw(); - } - _onError(evt) { - const onIconError = this.getCurrentLayer()?.props.onIconError; - if (onIconError) { - onIconError(evt); - } else { - log_default.error(evt.error.message)(); - } - } - getInstanceOffset(icon) { - const { width, height, anchorX = width / 2, anchorY = height / 2 } = this.state.iconManager.getIconMapping(icon); - return [width / 2 - anchorX, height / 2 - anchorY]; - } - getInstanceColorMode(icon) { - const mapping = this.state.iconManager.getIconMapping(icon); - return mapping.mask ? 1 : 0; - } - getInstanceIconFrame(icon) { - const { x, y, width, height } = this.state.iconManager.getIconMapping(icon); - return [x, y, width, height]; - } -}; -IconLayer.defaultProps = defaultProps4; -IconLayer.layerName = "IconLayer"; -var icon_layer_default = IconLayer; - -// node_modules/@deck.gl/layers/dist/line-layer/line-layer-vertex.glsl.js -var line_layer_vertex_glsl_default = `#version 300 es -#define SHADER_NAME line-layer-vertex-shader -in vec3 positions; -in vec3 instanceSourcePositions; -in vec3 instanceTargetPositions; -in vec3 instanceSourcePositions64Low; -in vec3 instanceTargetPositions64Low; -in vec4 instanceColors; -in vec3 instancePickingColors; -in float instanceWidths; -uniform float opacity; -uniform float widthScale; -uniform float widthMinPixels; -uniform float widthMaxPixels; -uniform float useShortestPath; -uniform int widthUnits; -out vec4 vColor; -out vec2 uv; -vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) { -vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize); -dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x); -return dir_screenspace * offset_direction * width / 2.0; -} -vec3 splitLine(vec3 a, vec3 b, float x) { -float t = (x - a.x) / (b.x - a.x); -return vec3(x, mix(a.yz, b.yz, t)); -} -void main(void) { -geometry.worldPosition = instanceSourcePositions; -geometry.worldPositionAlt = instanceTargetPositions; -vec3 source_world = instanceSourcePositions; -vec3 target_world = instanceTargetPositions; -vec3 source_world_64low = instanceSourcePositions64Low; -vec3 target_world_64low = instanceTargetPositions64Low; -if (useShortestPath > 0.5 || useShortestPath < -0.5) { -source_world.x = mod(source_world.x + 180., 360.0) - 180.; -target_world.x = mod(target_world.x + 180., 360.0) - 180.; -float deltaLng = target_world.x - source_world.x; -if (deltaLng * useShortestPath > 180.) { -source_world.x += 360. * useShortestPath; -source_world = splitLine(source_world, target_world, 180. * useShortestPath); -source_world_64low = vec3(0.0); -} else if (deltaLng * useShortestPath < -180.) { -target_world.x += 360. * useShortestPath; -target_world = splitLine(source_world, target_world, 180. * useShortestPath); -target_world_64low = vec3(0.0); -} else if (useShortestPath < 0.) { -gl_Position = vec4(0.); -return; -} -} -vec4 source_commonspace; -vec4 target_commonspace; -vec4 source = project_position_to_clipspace(source_world, source_world_64low, vec3(0.), source_commonspace); -vec4 target = project_position_to_clipspace(target_world, target_world_64low, vec3(0.), target_commonspace); -float segmentIndex = positions.x; -vec4 p = mix(source, target, segmentIndex); -geometry.position = mix(source_commonspace, target_commonspace, segmentIndex); -uv = positions.xy; -geometry.uv = uv; -geometry.pickingColor = instancePickingColors; -float widthPixels = clamp( -project_size_to_pixel(instanceWidths * widthScale, widthUnits), -widthMinPixels, widthMaxPixels -); -vec3 offset = vec3( -getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels), -0.0); -DECKGL_FILTER_SIZE(offset, geometry); -DECKGL_FILTER_GL_POSITION(p, geometry); -gl_Position = p + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0); -vColor = vec4(instanceColors.rgb, instanceColors.a * opacity); -DECKGL_FILTER_COLOR(vColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/line-layer/line-layer-fragment.glsl.js -var line_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME line-layer-fragment-shader -precision highp float; -in vec4 vColor; -in vec2 uv; -out vec4 fragColor; -void main(void) { -geometry.uv = uv; -fragColor = vColor; -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/line-layer/line-layer.js -var DEFAULT_COLOR2 = [0, 0, 0, 255]; -var defaultProps5 = { - getSourcePosition: { type: "accessor", value: (x) => x.sourcePosition }, - getTargetPosition: { type: "accessor", value: (x) => x.targetPosition }, - getColor: { type: "accessor", value: DEFAULT_COLOR2 }, - getWidth: { type: "accessor", value: 1 }, - widthUnits: "pixels", - widthScale: { type: "number", value: 1, min: 0 }, - widthMinPixels: { type: "number", value: 0, min: 0 }, - widthMaxPixels: { type: "number", value: Number.MAX_SAFE_INTEGER, min: 0 } -}; -var LineLayer = class extends layer_default { - getBounds() { - return this.getAttributeManager()?.getBounds([ - "instanceSourcePositions", - "instanceTargetPositions" - ]); - } - getShaders() { - return super.getShaders({ vs: line_layer_vertex_glsl_default, fs: line_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); - } - // This layer has its own wrapLongitude logic - get wrapLongitude() { - return false; - } - initializeState() { - const attributeManager = this.getAttributeManager(); - attributeManager.addInstanced({ - instanceSourcePositions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - transition: true, - accessor: "getSourcePosition" - }, - instanceTargetPositions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - transition: true, - accessor: "getTargetPosition" - }, - instanceColors: { - size: this.props.colorFormat.length, - type: "unorm8", - transition: true, - accessor: "getColor", - defaultValue: [0, 0, 0, 255] - }, - instanceWidths: { - size: 1, - transition: true, - accessor: "getWidth", - defaultValue: 1 - } - }); - } - updateState(params) { - super.updateState(params); - if (params.changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - this.getAttributeManager().invalidateAll(); - } - } - draw({ uniforms }) { - const { widthUnits, widthScale, widthMinPixels, widthMaxPixels, wrapLongitude } = this.props; - const model = this.state.model; - model.setUniforms(uniforms); - model.setUniforms({ - widthUnits: UNIT[widthUnits], - widthScale, - widthMinPixels, - widthMaxPixels, - useShortestPath: wrapLongitude ? 1 : 0 - }); - model.draw(this.context.renderPass); - if (wrapLongitude) { - model.setUniforms({ - useShortestPath: -1 - }); - model.draw(this.context.renderPass); - } - } - _getModel() { - const positions = [0, -1, 0, 0, 1, 0, 1, -1, 0, 1, 1, 0]; - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - geometry: new Geometry({ - topology: "triangle-strip", - attributes: { - positions: { size: 3, value: new Float32Array(positions) } - } - }), - isInstanced: true - }); - } -}; -LineLayer.layerName = "LineLayer"; -LineLayer.defaultProps = defaultProps5; -var line_layer_default = LineLayer; - -// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer-vertex.glsl.js -var scatterplot_layer_vertex_glsl_default = `#version 300 es -#define SHADER_NAME scatterplot-layer-vertex-shader -in vec3 positions; -in vec3 instancePositions; -in vec3 instancePositions64Low; -in float instanceRadius; -in float instanceLineWidths; -in vec4 instanceFillColors; -in vec4 instanceLineColors; -in vec3 instancePickingColors; -uniform float opacity; -uniform float radiusScale; -uniform float radiusMinPixels; -uniform float radiusMaxPixels; -uniform float lineWidthScale; -uniform float lineWidthMinPixels; -uniform float lineWidthMaxPixels; -uniform float stroked; -uniform bool filled; -uniform bool antialiasing; -uniform bool billboard; -uniform int radiusUnits; -uniform int lineWidthUnits; -out vec4 vFillColor; -out vec4 vLineColor; -out vec2 unitPosition; -out float innerUnitRadius; -out float outerRadiusPixels; -void main(void) { -geometry.worldPosition = instancePositions; -outerRadiusPixels = clamp( -project_size_to_pixel(radiusScale * instanceRadius, radiusUnits), -radiusMinPixels, radiusMaxPixels -); -float lineWidthPixels = clamp( -project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits), -lineWidthMinPixels, lineWidthMaxPixels -); -outerRadiusPixels += stroked * lineWidthPixels / 2.0; -float edgePadding = antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0; -unitPosition = edgePadding * positions.xy; -geometry.uv = unitPosition; -geometry.pickingColor = instancePickingColors; -innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels; -if (billboard) { -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -vec3 offset = edgePadding * positions * outerRadiusPixels; -DECKGL_FILTER_SIZE(offset, geometry); -gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); -} else { -vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels); -DECKGL_FILTER_SIZE(offset, geometry); -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -} -vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity); -DECKGL_FILTER_COLOR(vFillColor, geometry); -vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); -DECKGL_FILTER_COLOR(vLineColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer-fragment.glsl.js -var scatterplot_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME scatterplot-layer-fragment-shader -precision highp float; -uniform bool filled; -uniform float stroked; -uniform bool antialiasing; -in vec4 vFillColor; -in vec4 vLineColor; -in vec2 unitPosition; -in float innerUnitRadius; -in float outerRadiusPixels; -out vec4 fragColor; -void main(void) { -geometry.uv = unitPosition; -float distToCenter = length(unitPosition) * outerRadiusPixels; -float inCircle = antialiasing ? -smoothedge(distToCenter, outerRadiusPixels) : -step(distToCenter, outerRadiusPixels); -if (inCircle == 0.0) { -discard; -} -if (stroked > 0.5) { -float isLine = antialiasing ? -smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) : -step(innerUnitRadius * outerRadiusPixels, distToCenter); -if (filled) { -fragColor = mix(vFillColor, vLineColor, isLine); -} else { -if (isLine == 0.0) { -discard; -} -fragColor = vec4(vLineColor.rgb, vLineColor.a * isLine); -} -} else if (!filled) { -discard; -} else { -fragColor = vFillColor; -} -fragColor.a *= inCircle; -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/scatterplot-layer/scatterplot-layer.js -var DEFAULT_COLOR3 = [0, 0, 0, 255]; -var defaultProps6 = { - radiusUnits: "meters", - radiusScale: { type: "number", min: 0, value: 1 }, - radiusMinPixels: { type: "number", min: 0, value: 0 }, - // min point radius in pixels - radiusMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, - // max point radius in pixels - lineWidthUnits: "meters", - lineWidthScale: { type: "number", min: 0, value: 1 }, - lineWidthMinPixels: { type: "number", min: 0, value: 0 }, - lineWidthMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, - stroked: false, - filled: true, - billboard: false, - antialiasing: true, - getPosition: { type: "accessor", value: (x) => x.position }, - getRadius: { type: "accessor", value: 1 }, - getFillColor: { type: "accessor", value: DEFAULT_COLOR3 }, - getLineColor: { type: "accessor", value: DEFAULT_COLOR3 }, - getLineWidth: { type: "accessor", value: 1 }, - // deprecated - strokeWidth: { deprecatedFor: "getLineWidth" }, - outline: { deprecatedFor: "stroked" }, - getColor: { deprecatedFor: ["getFillColor", "getLineColor"] } -}; -var ScatterplotLayer = class extends layer_default { - getShaders() { - return super.getShaders({ vs: scatterplot_layer_vertex_glsl_default, fs: scatterplot_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); - } - initializeState() { - this.getAttributeManager().addInstanced({ - instancePositions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - transition: true, - accessor: "getPosition" - }, - instanceRadius: { - size: 1, - transition: true, - accessor: "getRadius", - defaultValue: 1 - }, - instanceFillColors: { - size: this.props.colorFormat.length, - transition: true, - type: "unorm8", - accessor: "getFillColor", - defaultValue: [0, 0, 0, 255] - }, - instanceLineColors: { - size: this.props.colorFormat.length, - transition: true, - type: "unorm8", - accessor: "getLineColor", - defaultValue: [0, 0, 0, 255] - }, - instanceLineWidths: { - size: 1, - transition: true, - accessor: "getLineWidth", - defaultValue: 1 - } - }); - } - updateState(params) { - super.updateState(params); - if (params.changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - this.getAttributeManager().invalidateAll(); - } - } - draw({ uniforms }) { - const { radiusUnits, radiusScale, radiusMinPixels, radiusMaxPixels, stroked, filled, billboard, antialiasing, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels } = this.props; - const model = this.state.model; - model.setUniforms(uniforms); - model.setUniforms({ - stroked: stroked ? 1 : 0, - filled, - billboard, - antialiasing, - radiusUnits: UNIT[radiusUnits], - radiusScale, - radiusMinPixels, - radiusMaxPixels, - lineWidthUnits: UNIT[lineWidthUnits], - lineWidthScale, - lineWidthMinPixels, - lineWidthMaxPixels - }); - model.draw(this.context.renderPass); - } - _getModel() { - const positions = [-1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0]; - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - geometry: new Geometry({ - topology: "triangle-strip", - attributes: { - positions: { size: 3, value: new Float32Array(positions) } - } - }), - isInstanced: true - }); - } -}; -ScatterplotLayer.defaultProps = defaultProps6; -ScatterplotLayer.layerName = "ScatterplotLayer"; -var scatterplot_layer_default = ScatterplotLayer; - -// node_modules/@math.gl/polygon/dist/polygon-utils.js -var WINDING = { - CLOCKWISE: 1, - COUNTER_CLOCKWISE: -1 -}; -function modifyPolygonWindingDirection(points, direction, options = {}) { - const windingDirection = getPolygonWindingDirection(points, options); - if (windingDirection !== direction) { - reversePolygon(points, options); - return true; - } - return false; -} -function getPolygonWindingDirection(points, options = {}) { - return Math.sign(getPolygonSignedArea(points, options)); -} -var DimIndex = { - x: 0, - y: 1, - z: 2 -}; -function getPolygonSignedArea(points, options = {}) { - const { start = 0, end = points.length, plane = "xy" } = options; - const dim = options.size || 2; - let area = 0; - const i0 = DimIndex[plane[0]]; - const i1 = DimIndex[plane[1]]; - for (let i = start, j = end - dim; i < end; i += dim) { - area += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]); - j = i; - } - return area / 2; -} -function reversePolygon(points, options) { - const { start = 0, end = points.length, size = 2 } = options; - const numPoints = (end - start) / size; - const numSwaps = Math.floor(numPoints / 2); - for (let i = 0; i < numSwaps; ++i) { - const b1 = start + i * size; - const b2 = start + (numPoints - 1 - i) * size; - for (let j = 0; j < size; ++j) { - const tmp = points[b1 + j]; - points[b1 + j] = points[b2 + j]; - points[b2 + j] = tmp; - } - } -} - -// node_modules/@math.gl/polygon/dist/utils.js -function push(target, source) { - const size = source.length; - const startIndex = target.length; - if (startIndex > 0) { - let isDuplicate = true; - for (let i = 0; i < size; i++) { - if (target[startIndex - size + i] !== source[i]) { - isDuplicate = false; - break; - } - } - if (isDuplicate) { - return false; - } - } - for (let i = 0; i < size; i++) { - target[startIndex + i] = source[i]; - } - return true; -} -function copy9(target, source) { - const size = source.length; - for (let i = 0; i < size; i++) { - target[i] = source[i]; - } -} -function getPointAtIndex(positions, index2, size, offset, out = []) { - const startI = offset + index2 * size; - for (let i = 0; i < size; i++) { - out[i] = positions[startI + i]; - } - return out; -} - -// node_modules/@math.gl/polygon/dist/lineclip.js -function intersect(a, b, edge, bbox, out = []) { - let t; - let snap; - if (edge & 8) { - t = (bbox[3] - a[1]) / (b[1] - a[1]); - snap = 3; - } else if (edge & 4) { - t = (bbox[1] - a[1]) / (b[1] - a[1]); - snap = 1; - } else if (edge & 2) { - t = (bbox[2] - a[0]) / (b[0] - a[0]); - snap = 2; - } else if (edge & 1) { - t = (bbox[0] - a[0]) / (b[0] - a[0]); - snap = 0; - } else { - return null; - } - for (let i = 0; i < a.length; i++) { - out[i] = (snap & 1) === i ? bbox[snap] : t * (b[i] - a[i]) + a[i]; - } - return out; -} -function bitCode(p, bbox) { - let code = 0; - if (p[0] < bbox[0]) - code |= 1; - else if (p[0] > bbox[2]) - code |= 2; - if (p[1] < bbox[1]) - code |= 4; - else if (p[1] > bbox[3]) - code |= 8; - return code; -} - -// node_modules/@math.gl/polygon/dist/cut-by-grid.js -function cutPolylineByGrid(positions, options) { - const { size = 2, broken = false, gridResolution = 10, gridOffset = [0, 0], startIndex = 0, endIndex = positions.length } = options || {}; - const numPoints = (endIndex - startIndex) / size; - let part = []; - const result = [part]; - const a = getPointAtIndex(positions, 0, size, startIndex); - let b; - let codeB; - const cell = getGridCell(a, gridResolution, gridOffset, []); - const scratchPoint = []; - push(part, a); - for (let i = 1; i < numPoints; i++) { - b = getPointAtIndex(positions, i, size, startIndex, b); - codeB = bitCode(b, cell); - while (codeB) { - intersect(a, b, codeB, cell, scratchPoint); - const codeAlt = bitCode(scratchPoint, cell); - if (codeAlt) { - intersect(a, scratchPoint, codeAlt, cell, scratchPoint); - codeB = codeAlt; - } - push(part, scratchPoint); - copy9(a, scratchPoint); - moveToNeighborCell(cell, gridResolution, codeB); - if (broken && part.length > size) { - part = []; - result.push(part); - push(part, a); - } - codeB = bitCode(b, cell); - } - push(part, b); - copy9(a, b); - } - return broken ? result : result[0]; -} -var TYPE_INSIDE = 0; -var TYPE_BORDER = 1; -function cutPolygonByGrid(positions, holeIndices = null, options) { - if (!positions.length) { - return []; - } - const { size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false } = options || {}; - const result = []; - const queue = [ - { - pos: positions, - types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null, - holes: holeIndices || [] - } - ]; - const bbox = [[], []]; - let cell = []; - while (queue.length) { - const { pos, types, holes } = queue.shift(); - getBoundingBox(pos, size, holes[0] || pos.length, bbox); - cell = getGridCell(bbox[0], gridResolution, gridOffset, cell); - const code = bitCode(bbox[1], cell); - if (code) { - let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code); - const polygonLow = { pos: parts[0].pos, types: parts[0].types, holes: [] }; - const polygonHigh = { pos: parts[1].pos, types: parts[1].types, holes: [] }; - queue.push(polygonLow, polygonHigh); - for (let i = 0; i < holes.length; i++) { - parts = bisectPolygon(pos, types, size, holes[i], holes[i + 1] || pos.length, cell, code); - if (parts[0]) { - polygonLow.holes.push(polygonLow.pos.length); - polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos); - if (edgeTypes) { - polygonLow.types = concatInPlace(polygonLow.types, parts[0].types); - } - } - if (parts[1]) { - polygonHigh.holes.push(polygonHigh.pos.length); - polygonHigh.pos = concatInPlace(polygonHigh.pos, parts[1].pos); - if (edgeTypes) { - polygonHigh.types = concatInPlace(polygonHigh.types, parts[1].types); - } - } - } - } else { - const polygon = { positions: pos }; - if (edgeTypes) { - polygon.edgeTypes = types; - } - if (holes.length) { - polygon.holeIndices = holes; - } - result.push(polygon); - } - } - return result; -} -function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, edge) { - const numPoints = (endIndex - startIndex) / size; - const resultLow = []; - const resultHigh = []; - const typesLow = []; - const typesHigh = []; - const scratchPoint = []; - let p; - let side; - let type; - const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex); - let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]); - let prevType = edgeTypes && edgeTypes[numPoints - 1]; - let lowPointCount = 0; - let highPointCount = 0; - for (let i = 0; i < numPoints; i++) { - p = getPointAtIndex(positions, i, size, startIndex, p); - side = Math.sign(edge & 8 ? p[1] - bbox[3] : p[0] - bbox[2]); - type = edgeTypes && edgeTypes[startIndex / size + i]; - if (side && prevSide && prevSide !== side) { - intersect(prev, p, edge, bbox, scratchPoint); - push(resultLow, scratchPoint) && typesLow.push(prevType); - push(resultHigh, scratchPoint) && typesHigh.push(prevType); - } - if (side <= 0) { - push(resultLow, p) && typesLow.push(type); - lowPointCount -= side; - } else if (typesLow.length) { - typesLow[typesLow.length - 1] = TYPE_INSIDE; - } - if (side >= 0) { - push(resultHigh, p) && typesHigh.push(type); - highPointCount += side; - } else if (typesHigh.length) { - typesHigh[typesHigh.length - 1] = TYPE_INSIDE; - } - copy9(prev, p); - prevSide = side; - prevType = type; - } - return [ - lowPointCount ? { pos: resultLow, types: edgeTypes && typesLow } : null, - highPointCount ? { pos: resultHigh, types: edgeTypes && typesHigh } : null - ]; -} -function getGridCell(p, gridResolution, gridOffset, out) { - const left = Math.floor((p[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0]; - const bottom = Math.floor((p[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1]; - out[0] = left; - out[1] = bottom; - out[2] = left + gridResolution; - out[3] = bottom + gridResolution; - return out; -} -function moveToNeighborCell(cell, gridResolution, edge) { - if (edge & 8) { - cell[1] += gridResolution; - cell[3] += gridResolution; - } else if (edge & 4) { - cell[1] -= gridResolution; - cell[3] -= gridResolution; - } else if (edge & 2) { - cell[0] += gridResolution; - cell[2] += gridResolution; - } else if (edge & 1) { - cell[0] -= gridResolution; - cell[2] -= gridResolution; - } -} -function getBoundingBox(positions, size, endIndex, out) { - let minX = Infinity; - let maxX = -Infinity; - let minY = Infinity; - let maxY = -Infinity; - for (let i = 0; i < endIndex; i += size) { - const x = positions[i]; - const y = positions[i + 1]; - minX = x < minX ? x : minX; - maxX = x > maxX ? x : maxX; - minY = y < minY ? y : minY; - maxY = y > maxY ? y : maxY; - } - out[0][0] = minX; - out[0][1] = minY; - out[1][0] = maxX; - out[1][1] = maxY; - return out; -} -function concatInPlace(arr1, arr2) { - for (let i = 0; i < arr2.length; i++) { - arr1.push(arr2[i]); - } - return arr1; -} - -// node_modules/@math.gl/polygon/dist/cut-by-mercator-bounds.js -var DEFAULT_MAX_LATITUDE = 85.051129; -function cutPolylineByMercatorBounds(positions, options) { - const { size = 2, startIndex = 0, endIndex = positions.length, normalize: normalize11 = true } = options || {}; - const newPositions = positions.slice(startIndex, endIndex); - wrapLongitudesForShortestPath(newPositions, size, 0, endIndex - startIndex); - const parts = cutPolylineByGrid(newPositions, { - size, - broken: true, - gridResolution: 360, - gridOffset: [-180, -180] - }); - if (normalize11) { - for (const part of parts) { - shiftLongitudesIntoRange(part, size); - } - } - return parts; -} -function cutPolygonByMercatorBounds(positions, holeIndices = null, options) { - const { size = 2, normalize: normalize11 = true, edgeTypes = false } = options || {}; - holeIndices = holeIndices || []; - const newPositions = []; - const newHoleIndices = []; - let srcStartIndex = 0; - let targetIndex = 0; - for (let ringIndex = 0; ringIndex <= holeIndices.length; ringIndex++) { - const srcEndIndex = holeIndices[ringIndex] || positions.length; - const targetStartIndex = targetIndex; - const splitIndex = findSplitIndex(positions, size, srcStartIndex, srcEndIndex); - for (let i = splitIndex; i < srcEndIndex; i++) { - newPositions[targetIndex++] = positions[i]; - } - for (let i = srcStartIndex; i < splitIndex; i++) { - newPositions[targetIndex++] = positions[i]; - } - wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex); - insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options?.maxLatitude); - srcStartIndex = srcEndIndex; - newHoleIndices[ringIndex] = targetIndex; - } - newHoleIndices.pop(); - const parts = cutPolygonByGrid(newPositions, newHoleIndices, { - size, - gridResolution: 360, - gridOffset: [-180, -180], - edgeTypes - }); - if (normalize11) { - for (const part of parts) { - shiftLongitudesIntoRange(part.positions, size); - } - } - return parts; -} -function findSplitIndex(positions, size, startIndex, endIndex) { - let maxLat = -1; - let pointIndex = -1; - for (let i = startIndex + 1; i < endIndex; i += size) { - const lat = Math.abs(positions[i]); - if (lat > maxLat) { - maxLat = lat; - pointIndex = i - 1; - } - } - return pointIndex; -} -function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) { - const firstLng = positions[startIndex]; - const lastLng = positions[endIndex - size]; - if (Math.abs(firstLng - lastLng) > 180) { - const p = getPointAtIndex(positions, 0, size, startIndex); - p[0] += Math.round((lastLng - firstLng) / 360) * 360; - push(positions, p); - p[1] = Math.sign(p[1]) * maxLatitude; - push(positions, p); - p[0] = firstLng; - push(positions, p); - } -} -function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) { - let prevLng = positions[0]; - let lng; - for (let i = startIndex; i < endIndex; i += size) { - lng = positions[i]; - const delta = lng - prevLng; - if (delta > 180 || delta < -180) { - lng -= Math.round(delta / 360) * 360; - } - positions[i] = prevLng = lng; - } -} -function shiftLongitudesIntoRange(positions, size) { - let refLng; - const pointCount = positions.length / size; - for (let i = 0; i < pointCount; i++) { - refLng = positions[i * size]; - if ((refLng + 180) % 360 !== 0) { - break; - } - } - const delta = -Math.round(refLng / 360) * 360; - if (delta === 0) { - return; - } - for (let i = 0; i < pointCount; i++) { - positions[i * size] += delta; - } -} - -// node_modules/@deck.gl/layers/dist/path-layer/path.js -function normalizePath(path, size, gridResolution, wrapLongitude) { - let flatPath; - if (Array.isArray(path[0])) { - const length10 = path.length * size; - flatPath = new Array(length10); - for (let i = 0; i < path.length; i++) { - for (let j = 0; j < size; j++) { - flatPath[i * size + j] = path[i][j] || 0; - } - } - } else { - flatPath = path; - } - if (gridResolution) { - return cutPolylineByGrid(flatPath, { size, gridResolution }); - } - if (wrapLongitude) { - return cutPolylineByMercatorBounds(flatPath, { size }); - } - return flatPath; -} - -// node_modules/@deck.gl/layers/dist/path-layer/path-tesselator.js -var START_CAP = 1; -var END_CAP = 2; -var INVALID = 4; -var PathTesselator = class extends Tesselator { - constructor(opts) { - super({ - ...opts, - attributes: { - // Padding covers shaderAttributes for last segment in largest case fp64 - // additional vertex + hi & low parts, 3 * 6 - positions: { - size: 3, - padding: 18, - initialize: true, - type: opts.fp64 ? Float64Array : Float32Array - }, - segmentTypes: { size: 1, type: Uint8ClampedArray } - } - }); - } - /** Get packed attribute by name */ - get(attributeName) { - return this.attributes[attributeName]; - } - /* Implement base Tesselator interface */ - getGeometryFromBuffer(buffer) { - if (this.normalize) { - return super.getGeometryFromBuffer(buffer); - } - return null; - } - /* Implement base Tesselator interface */ - normalizeGeometry(path) { - if (this.normalize) { - return normalizePath(path, this.positionSize, this.opts.resolution, this.opts.wrapLongitude); - } - return path; - } - /* Implement base Tesselator interface */ - getGeometrySize(path) { - if (isCut(path)) { - let size = 0; - for (const subPath of path) { - size += this.getGeometrySize(subPath); - } - return size; - } - const numPoints = this.getPathLength(path); - if (numPoints < 2) { - return 0; - } - if (this.isClosed(path)) { - return numPoints < 3 ? 0 : numPoints + 2; - } - return numPoints; - } - /* Implement base Tesselator interface */ - updateGeometryAttributes(path, context) { - if (context.geometrySize === 0) { - return; - } - if (path && isCut(path)) { - for (const subPath of path) { - const geometrySize = this.getGeometrySize(subPath); - context.geometrySize = geometrySize; - this.updateGeometryAttributes(subPath, context); - context.vertexStart += geometrySize; - } - } else { - this._updateSegmentTypes(path, context); - this._updatePositions(path, context); - } - } - _updateSegmentTypes(path, context) { - const segmentTypes = this.attributes.segmentTypes; - const isPathClosed = path ? this.isClosed(path) : false; - const { vertexStart, geometrySize } = context; - segmentTypes.fill(0, vertexStart, vertexStart + geometrySize); - if (isPathClosed) { - segmentTypes[vertexStart] = INVALID; - segmentTypes[vertexStart + geometrySize - 2] = INVALID; - } else { - segmentTypes[vertexStart] += START_CAP; - segmentTypes[vertexStart + geometrySize - 2] += END_CAP; - } - segmentTypes[vertexStart + geometrySize - 1] = INVALID; - } - _updatePositions(path, context) { - const { positions } = this.attributes; - if (!positions || !path) { - return; - } - const { vertexStart, geometrySize } = context; - const p = new Array(3); - for (let i = vertexStart, ptIndex = 0; ptIndex < geometrySize; i++, ptIndex++) { - this.getPointOnPath(path, ptIndex, p); - positions[i * 3] = p[0]; - positions[i * 3 + 1] = p[1]; - positions[i * 3 + 2] = p[2]; - } - } - // Utilities - /** Returns the number of points in the path */ - getPathLength(path) { - return path.length / this.positionSize; - } - /** Returns a point on the path at the specified index */ - getPointOnPath(path, index2, target = []) { - const { positionSize } = this; - if (index2 * positionSize >= path.length) { - index2 += 1 - path.length / positionSize; - } - const i = index2 * positionSize; - target[0] = path[i]; - target[1] = path[i + 1]; - target[2] = positionSize === 3 && path[i + 2] || 0; - return target; - } - // Returns true if the first and last points are identical - isClosed(path) { - if (!this.normalize) { - return Boolean(this.opts.loop); - } - const { positionSize } = this; - const lastPointIndex = path.length - positionSize; - return path[0] === path[lastPointIndex] && path[1] === path[lastPointIndex + 1] && (positionSize === 2 || path[2] === path[lastPointIndex + 2]); - } -}; -function isCut(path) { - return Array.isArray(path[0]); -} - -// node_modules/@deck.gl/layers/dist/path-layer/path-layer-vertex.glsl.js -var path_layer_vertex_glsl_default = `#version 300 es -#define SHADER_NAME path-layer-vertex-shader -in vec2 positions; -in float instanceTypes; -in vec3 instanceStartPositions; -in vec3 instanceEndPositions; -in vec3 instanceLeftPositions; -in vec3 instanceRightPositions; -in vec3 instanceLeftPositions64Low; -in vec3 instanceStartPositions64Low; -in vec3 instanceEndPositions64Low; -in vec3 instanceRightPositions64Low; -in float instanceStrokeWidths; -in vec4 instanceColors; -in vec3 instancePickingColors; -uniform float widthScale; -uniform float widthMinPixels; -uniform float widthMaxPixels; -uniform float jointType; -uniform float capType; -uniform float miterLimit; -uniform bool billboard; -uniform int widthUnits; -uniform float opacity; -out vec4 vColor; -out vec2 vCornerOffset; -out float vMiterLength; -out vec2 vPathPosition; -out float vPathLength; -out float vJointType; -const float EPSILON = 0.001; -const vec3 ZERO_OFFSET = vec3(0.0); -float flipIfTrue(bool flag) { -return -(float(flag) * 2. - 1.); -} -vec3 getLineJoinOffset( -vec3 prevPoint, vec3 currPoint, vec3 nextPoint, -vec2 width -) { -bool isEnd = positions.x > 0.0; -float sideOfPath = positions.y; -float isJoint = float(sideOfPath == 0.0); -vec3 deltaA3 = (currPoint - prevPoint); -vec3 deltaB3 = (nextPoint - currPoint); -mat3 rotationMatrix; -bool needsRotation = !billboard && project_needs_rotation(currPoint, rotationMatrix); -if (needsRotation) { -deltaA3 = deltaA3 * rotationMatrix; -deltaB3 = deltaB3 * rotationMatrix; -} -vec2 deltaA = deltaA3.xy / width; -vec2 deltaB = deltaB3.xy / width; -float lenA = length(deltaA); -float lenB = length(deltaB); -vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0); -vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0); -vec2 perpA = vec2(-dirA.y, dirA.x); -vec2 perpB = vec2(-dirB.y, dirB.x); -vec2 tangent = dirA + dirB; -tangent = length(tangent) > 0. ? normalize(tangent) : perpA; -vec2 miterVec = vec2(-tangent.y, tangent.x); -vec2 dir = isEnd ? dirA : dirB; -vec2 perp = isEnd ? perpA : perpB; -float L = isEnd ? lenA : lenB; -float sinHalfA = abs(dot(miterVec, perp)); -float cosHalfA = abs(dot(dirA, miterVec)); -float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x); -float cornerPosition = sideOfPath * turnDirection; -float miterSize = 1.0 / max(sinHalfA, EPSILON); -miterSize = mix( -min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)), -miterSize, -step(0.0, cornerPosition) -); -vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition)) -* (sideOfPath + isJoint * turnDirection); -bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0)); -bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0)); -bool isCap = isStartCap || isEndCap; -if (isCap) { -offsetVec = mix(perp * sideOfPath, dir * capType * 4.0 * flipIfTrue(isStartCap), isJoint); -vJointType = capType; -} else { -vJointType = jointType; -} -vPathLength = L; -vCornerOffset = offsetVec; -vMiterLength = dot(vCornerOffset, miterVec * turnDirection); -vMiterLength = isCap ? isJoint : vMiterLength; -vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd); -vPathPosition = vec2( -dot(offsetFromStartOfPath, perp), -dot(offsetFromStartOfPath, dir) -); -geometry.uv = vPathPosition; -float isValid = step(instanceTypes, 3.5); -vec3 offset = vec3(offsetVec * width * isValid, 0.0); -if (needsRotation) { -offset = rotationMatrix * offset; -} -return offset; -} -void clipLine(inout vec4 position, vec4 refPosition) { -if (position.w < EPSILON) { -float r = (EPSILON - refPosition.w) / (position.w - refPosition.w); -position = refPosition + (position - refPosition) * r; -} -} -void main() { -geometry.pickingColor = instancePickingColors; -vColor = vec4(instanceColors.rgb, instanceColors.a * opacity); -float isEnd = positions.x; -vec3 prevPosition = mix(instanceLeftPositions, instanceStartPositions, isEnd); -vec3 prevPosition64Low = mix(instanceLeftPositions64Low, instanceStartPositions64Low, isEnd); -vec3 currPosition = mix(instanceStartPositions, instanceEndPositions, isEnd); -vec3 currPosition64Low = mix(instanceStartPositions64Low, instanceEndPositions64Low, isEnd); -vec3 nextPosition = mix(instanceEndPositions, instanceRightPositions, isEnd); -vec3 nextPosition64Low = mix(instanceEndPositions64Low, instanceRightPositions64Low, isEnd); -geometry.worldPosition = currPosition; -vec2 widthPixels = vec2(clamp( -project_size_to_pixel(instanceStrokeWidths * widthScale, widthUnits), -widthMinPixels, widthMaxPixels) / 2.0); -vec3 width; -if (billboard) { -vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET); -vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position); -vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET); -clipLine(prevPositionScreen, currPositionScreen); -clipLine(nextPositionScreen, currPositionScreen); -clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd)); -width = vec3(widthPixels, 0.0); -DECKGL_FILTER_SIZE(width, geometry); -vec3 offset = getLineJoinOffset( -prevPositionScreen.xyz / prevPositionScreen.w, -currPositionScreen.xyz / currPositionScreen.w, -nextPositionScreen.xyz / nextPositionScreen.w, -project_pixel_size_to_clipspace(width.xy) -); -DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry); -gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w); -} else { -prevPosition = project_position(prevPosition, prevPosition64Low); -currPosition = project_position(currPosition, currPosition64Low); -nextPosition = project_position(nextPosition, nextPosition64Low); -width = vec3(project_pixel_size(widthPixels), 0.0); -DECKGL_FILTER_SIZE(width, geometry); -vec3 offset = getLineJoinOffset(prevPosition, currPosition, nextPosition, width.xy); -geometry.position = vec4(currPosition + offset, 1.0); -gl_Position = project_common_position_to_clipspace(geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -} -DECKGL_FILTER_COLOR(vColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/path-layer/path-layer-fragment.glsl.js -var path_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME path-layer-fragment-shader -precision highp float; -uniform float miterLimit; -in vec4 vColor; -in vec2 vCornerOffset; -in float vMiterLength; -in vec2 vPathPosition; -in float vPathLength; -in float vJointType; -out vec4 fragColor; -void main(void) { -geometry.uv = vPathPosition; -if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) { -if (vJointType > 0.5 && length(vCornerOffset) > 1.0) { -discard; -} -if (vJointType < 0.5 && vMiterLength > miterLimit + 1.0) { -discard; -} -} -fragColor = vColor; -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/path-layer/path-layer.js -var DEFAULT_COLOR4 = [0, 0, 0, 255]; -var defaultProps7 = { - widthUnits: "meters", - widthScale: { type: "number", min: 0, value: 1 }, - widthMinPixels: { type: "number", min: 0, value: 0 }, - widthMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER }, - jointRounded: false, - capRounded: false, - miterLimit: { type: "number", min: 0, value: 4 }, - billboard: false, - _pathType: null, - getPath: { type: "accessor", value: (object) => object.path }, - getColor: { type: "accessor", value: DEFAULT_COLOR4 }, - getWidth: { type: "accessor", value: 1 }, - // deprecated props - rounded: { deprecatedFor: ["jointRounded", "capRounded"] } -}; -var ATTRIBUTE_TRANSITION = { - enter: (value, chunk) => { - return chunk.length ? chunk.subarray(chunk.length - value.length) : value; - } -}; -var PathLayer = class extends layer_default { - getShaders() { - return super.getShaders({ vs: path_layer_vertex_glsl_default, fs: path_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); - } - get wrapLongitude() { - return false; - } - getBounds() { - return this.getAttributeManager()?.getBounds(["vertexPositions"]); - } - initializeState() { - const noAlloc = true; - const attributeManager = this.getAttributeManager(); - attributeManager.addInstanced({ - vertexPositions: { - size: 3, - // Start filling buffer from 1 vertex in - vertexOffset: 1, - type: "float64", - fp64: this.use64bitPositions(), - transition: ATTRIBUTE_TRANSITION, - accessor: "getPath", - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculatePositions, - noAlloc, - shaderAttributes: { - instanceLeftPositions: { - vertexOffset: 0 - }, - instanceStartPositions: { - vertexOffset: 1 - }, - instanceEndPositions: { - vertexOffset: 2 - }, - instanceRightPositions: { - vertexOffset: 3 - } - } - }, - instanceTypes: { - size: 1, - type: "uint8", - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculateSegmentTypes, - noAlloc - }, - instanceStrokeWidths: { - size: 1, - accessor: "getWidth", - transition: ATTRIBUTE_TRANSITION, - defaultValue: 1 - }, - instanceColors: { - size: this.props.colorFormat.length, - type: "unorm8", - accessor: "getColor", - transition: ATTRIBUTE_TRANSITION, - defaultValue: DEFAULT_COLOR4 - }, - instancePickingColors: { - size: 4, - type: "uint8", - accessor: (object, { index: index2, target: value }) => this.encodePickingColor(object && object.__source ? object.__source.index : index2, value) - } - }); - this.setState({ - pathTesselator: new PathTesselator({ - fp64: this.use64bitPositions() - }) - }); - } - updateState(params) { - super.updateState(params); - const { props, changeFlags } = params; - const attributeManager = this.getAttributeManager(); - const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath); - if (geometryChanged) { - const { pathTesselator } = this.state; - const buffers = props.data.attributes || {}; - pathTesselator.updateGeometry({ - data: props.data, - geometryBuffer: buffers.getPath, - buffers, - normalize: !props._pathType, - loop: props._pathType === "loop", - getGeometry: props.getPath, - positionFormat: props.positionFormat, - wrapLongitude: props.wrapLongitude, - // TODO - move the flag out of the viewport - resolution: this.context.viewport.resolution, - dataChanged: changeFlags.dataChanged - }); - this.setState({ - numInstances: pathTesselator.instanceCount, - startIndices: pathTesselator.vertexStarts - }); - if (!changeFlags.dataChanged) { - attributeManager.invalidateAll(); - } - } - if (changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - attributeManager.invalidateAll(); - } - } - getPickingInfo(params) { - const info = super.getPickingInfo(params); - const { index: index2 } = info; - const data = this.props.data; - if (data[0] && data[0].__source) { - info.object = data.find((d) => d.__source.index === index2); - } - return info; - } - /** Override base Layer method */ - disablePickingIndex(objectIndex) { - const data = this.props.data; - if (data[0] && data[0].__source) { - for (let i = 0; i < data.length; i++) { - if (data[i].__source.index === objectIndex) { - this._disablePickingIndex(i); - } - } - } else { - super.disablePickingIndex(objectIndex); - } - } - draw({ uniforms }) { - const { jointRounded, capRounded, billboard, miterLimit, widthUnits, widthScale, widthMinPixels, widthMaxPixels } = this.props; - const model = this.state.model; - model.setUniforms(uniforms); - model.setUniforms({ - jointType: Number(jointRounded), - capType: Number(capRounded), - billboard, - widthUnits: UNIT[widthUnits], - widthScale, - miterLimit, - widthMinPixels, - widthMaxPixels - }); - model.draw(this.context.renderPass); - } - _getModel() { - const SEGMENT_INDICES = [ - // start corner - 0, - 1, - 2, - // body - 1, - 4, - 2, - 1, - 3, - 4, - // end corner - 3, - 5, - 4 - ]; - const SEGMENT_POSITIONS = [ - // bevel start corner - 0, - 0, - // start inner corner - 0, - -1, - // start outer corner - 0, - 1, - // end inner corner - 1, - -1, - // end outer corner - 1, - 1, - // bevel end corner - 1, - 0 - ]; - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - geometry: new Geometry({ - topology: "triangle-list", - attributes: { - indices: new Uint16Array(SEGMENT_INDICES), - positions: { value: new Float32Array(SEGMENT_POSITIONS), size: 2 } - } - }), - isInstanced: true - }); - } - calculatePositions(attribute) { - const { pathTesselator } = this.state; - attribute.startIndices = pathTesselator.vertexStarts; - attribute.value = pathTesselator.get("positions"); - } - calculateSegmentTypes(attribute) { - const { pathTesselator } = this.state; - attribute.startIndices = pathTesselator.vertexStarts; - attribute.value = pathTesselator.get("segmentTypes"); - } -}; -PathLayer.defaultProps = defaultProps7; -PathLayer.layerName = "PathLayer"; -var path_layer_default = PathLayer; - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/polygon.js -var import_earcut2 = __toESM(require_earcut(), 1); -var OUTER_POLYGON_WINDING = WINDING.CLOCKWISE; -var HOLE_POLYGON_WINDING = WINDING.COUNTER_CLOCKWISE; -var windingOptions = { - isClosed: true -}; -function validate(polygon) { - polygon = polygon && polygon.positions || polygon; - if (!Array.isArray(polygon) && !ArrayBuffer.isView(polygon)) { - throw new Error("invalid polygon"); - } -} -function getPositions(polygon) { - return "positions" in polygon ? polygon.positions : polygon; -} -function getHoleIndices(polygon) { - return "holeIndices" in polygon ? polygon.holeIndices : null; -} -function isNested(polygon) { - return Array.isArray(polygon[0]); -} -function isSimple(polygon) { - return polygon.length >= 1 && polygon[0].length >= 2 && Number.isFinite(polygon[0][0]); -} -function isNestedRingClosed(simplePolygon) { - const p0 = simplePolygon[0]; - const p1 = simplePolygon[simplePolygon.length - 1]; - return p0[0] === p1[0] && p0[1] === p1[1] && p0[2] === p1[2]; -} -function isFlatRingClosed(positions, size, startIndex, endIndex) { - for (let i = 0; i < size; i++) { - if (positions[startIndex + i] !== positions[endIndex - size + i]) { - return false; - } - } - return true; -} -function copyNestedRing(target, targetStartIndex, simplePolygon, size, windingDirection) { - let targetIndex = targetStartIndex; - const len8 = simplePolygon.length; - for (let i = 0; i < len8; i++) { - for (let j = 0; j < size; j++) { - target[targetIndex++] = simplePolygon[i][j] || 0; - } - } - if (!isNestedRingClosed(simplePolygon)) { - for (let j = 0; j < size; j++) { - target[targetIndex++] = simplePolygon[0][j] || 0; - } - } - windingOptions.start = targetStartIndex; - windingOptions.end = targetIndex; - windingOptions.size = size; - modifyPolygonWindingDirection(target, windingDirection, windingOptions); - return targetIndex; -} -function copyFlatRing(target, targetStartIndex, positions, size, srcStartIndex = 0, srcEndIndex, windingDirection) { - srcEndIndex = srcEndIndex || positions.length; - const srcLength = srcEndIndex - srcStartIndex; - if (srcLength <= 0) { - return targetStartIndex; - } - let targetIndex = targetStartIndex; - for (let i = 0; i < srcLength; i++) { - target[targetIndex++] = positions[srcStartIndex + i]; - } - if (!isFlatRingClosed(positions, size, srcStartIndex, srcEndIndex)) { - for (let i = 0; i < size; i++) { - target[targetIndex++] = positions[srcStartIndex + i]; - } - } - windingOptions.start = targetStartIndex; - windingOptions.end = targetIndex; - windingOptions.size = size; - modifyPolygonWindingDirection(target, windingDirection, windingOptions); - return targetIndex; -} -function normalize7(polygon, positionSize) { - validate(polygon); - const positions = []; - const holeIndices = []; - if ("positions" in polygon) { - const { positions: srcPositions, holeIndices: srcHoleIndices } = polygon; - if (srcHoleIndices) { - let targetIndex = 0; - for (let i = 0; i <= srcHoleIndices.length; i++) { - targetIndex = copyFlatRing(positions, targetIndex, srcPositions, positionSize, srcHoleIndices[i - 1], srcHoleIndices[i], i === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); - holeIndices.push(targetIndex); - } - holeIndices.pop(); - return { positions, holeIndices }; - } - polygon = srcPositions; - } - if (!isNested(polygon)) { - copyFlatRing(positions, 0, polygon, positionSize, 0, positions.length, OUTER_POLYGON_WINDING); - return positions; - } - if (!isSimple(polygon)) { - let targetIndex = 0; - for (const [polygonIndex, simplePolygon] of polygon.entries()) { - targetIndex = copyNestedRing(positions, targetIndex, simplePolygon, positionSize, polygonIndex === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); - holeIndices.push(targetIndex); - } - holeIndices.pop(); - return { positions, holeIndices }; - } - copyNestedRing(positions, 0, polygon, positionSize, OUTER_POLYGON_WINDING); - return positions; -} -function getPlaneArea(positions, xIndex, yIndex) { - const numVerts = positions.length / 3; - let area = 0; - for (let i = 0; i < numVerts; i++) { - const j = (i + 1) % numVerts; - area += positions[i * 3 + xIndex] * positions[j * 3 + yIndex]; - area -= positions[j * 3 + xIndex] * positions[i * 3 + yIndex]; - } - return Math.abs(area / 2); -} -function permutePositions(positions, xIndex, yIndex, zIndex) { - const numVerts = positions.length / 3; - for (let i = 0; i < numVerts; i++) { - const o = i * 3; - const x = positions[o + 0]; - const y = positions[o + 1]; - const z = positions[o + 2]; - positions[o + xIndex] = x; - positions[o + yIndex] = y; - positions[o + zIndex] = z; - } -} -function getSurfaceIndices(polygon, positionSize, preproject, full3d) { - let holeIndices = getHoleIndices(polygon); - if (holeIndices) { - holeIndices = holeIndices.map((positionIndex) => positionIndex / positionSize); - } - let positions = getPositions(polygon); - const is3d = full3d && positionSize === 3; - if (preproject) { - const n = positions.length; - positions = positions.slice(); - const p = []; - for (let i = 0; i < n; i += positionSize) { - p[0] = positions[i]; - p[1] = positions[i + 1]; - if (is3d) { - p[2] = positions[i + 2]; - } - const xy = preproject(p); - positions[i] = xy[0]; - positions[i + 1] = xy[1]; - if (is3d) { - positions[i + 2] = xy[2]; - } - } - } - if (is3d) { - const xyArea = getPlaneArea(positions, 0, 1); - const xzArea = getPlaneArea(positions, 0, 2); - const yzArea = getPlaneArea(positions, 1, 2); - if (!xyArea && !xzArea && !yzArea) { - return []; - } - if (xyArea > xzArea && xyArea > yzArea) { - } else if (xzArea > yzArea) { - if (!preproject) { - positions = positions.slice(); - } - permutePositions(positions, 0, 2, 1); - } else { - if (!preproject) { - positions = positions.slice(); - } - permutePositions(positions, 2, 0, 1); - } - } - return (0, import_earcut2.default)(positions, holeIndices, positionSize); -} - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/polygon-tesselator.js -var PolygonTesselator = class extends Tesselator { - constructor(opts) { - const { fp64: fp642, IndexType = Uint32Array } = opts; - super({ - ...opts, - attributes: { - positions: { size: 3, type: fp642 ? Float64Array : Float32Array }, - vertexValid: { type: Uint16Array, size: 1 }, - indices: { type: IndexType, size: 1 } - } - }); - } - /** Get attribute by name */ - get(attributeName) { - const { attributes } = this; - if (attributeName === "indices") { - return attributes.indices && attributes.indices.subarray(0, this.vertexCount); - } - return attributes[attributeName]; - } - /** Override base Tesselator method */ - updateGeometry(opts) { - super.updateGeometry(opts); - const externalIndices = this.buffers.indices; - if (externalIndices) { - this.vertexCount = (externalIndices.value || externalIndices).length; - } else if (this.data && !this.getGeometry) { - throw new Error("missing indices buffer"); - } - } - /** Implement base Tesselator interface */ - normalizeGeometry(polygon) { - if (this.normalize) { - const normalizedPolygon = normalize7(polygon, this.positionSize); - if (this.opts.resolution) { - return cutPolygonByGrid(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { - size: this.positionSize, - gridResolution: this.opts.resolution, - edgeTypes: true - }); - } - if (this.opts.wrapLongitude) { - return cutPolygonByMercatorBounds(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { - size: this.positionSize, - maxLatitude: 86, - edgeTypes: true - }); - } - return normalizedPolygon; - } - return polygon; - } - /** Implement base Tesselator interface */ - getGeometrySize(polygon) { - if (isCut2(polygon)) { - let size = 0; - for (const subPolygon of polygon) { - size += this.getGeometrySize(subPolygon); - } - return size; - } - return getPositions(polygon).length / this.positionSize; - } - /** Override base Tesselator method */ - getGeometryFromBuffer(buffer) { - if (this.normalize || !this.buffers.indices) { - return super.getGeometryFromBuffer(buffer); - } - return null; - } - /** Implement base Tesselator interface */ - updateGeometryAttributes(polygon, context) { - if (polygon && isCut2(polygon)) { - for (const subPolygon of polygon) { - const geometrySize = this.getGeometrySize(subPolygon); - context.geometrySize = geometrySize; - this.updateGeometryAttributes(subPolygon, context); - context.vertexStart += geometrySize; - context.indexStart = this.indexStarts[context.geometryIndex + 1]; - } - } else { - const normalizedPolygon = polygon; - this._updateIndices(normalizedPolygon, context); - this._updatePositions(normalizedPolygon, context); - this._updateVertexValid(normalizedPolygon, context); - } - } - // Flatten the indices array - _updateIndices(polygon, { geometryIndex, vertexStart: offset, indexStart }) { - const { attributes, indexStarts, typedArrayManager } = this; - let target = attributes.indices; - if (!target || !polygon) { - return; - } - let i = indexStart; - const indices = getSurfaceIndices(polygon, this.positionSize, this.opts.preproject, this.opts.full3d); - target = typedArrayManager.allocate(target, indexStart + indices.length, { - copy: true - }); - for (let j = 0; j < indices.length; j++) { - target[i++] = indices[j] + offset; - } - indexStarts[geometryIndex + 1] = indexStart + indices.length; - attributes.indices = target; - } - // Flatten out all the vertices of all the sub subPolygons - _updatePositions(polygon, { vertexStart, geometrySize }) { - const { attributes: { positions }, positionSize } = this; - if (!positions || !polygon) { - return; - } - const polygonPositions = getPositions(polygon); - for (let i = vertexStart, j = 0; j < geometrySize; i++, j++) { - const x = polygonPositions[j * positionSize]; - const y = polygonPositions[j * positionSize + 1]; - const z = positionSize > 2 ? polygonPositions[j * positionSize + 2] : 0; - positions[i * 3] = x; - positions[i * 3 + 1] = y; - positions[i * 3 + 2] = z; - } - } - _updateVertexValid(polygon, { vertexStart, geometrySize }) { - const { positionSize } = this; - const vertexValid = this.attributes.vertexValid; - const holeIndices = polygon && getHoleIndices(polygon); - if (polygon && polygon.edgeTypes) { - vertexValid.set(polygon.edgeTypes, vertexStart); - } else { - vertexValid.fill(1, vertexStart, vertexStart + geometrySize); - } - if (holeIndices) { - for (let j = 0; j < holeIndices.length; j++) { - vertexValid[vertexStart + holeIndices[j] / positionSize - 1] = 0; - } - } - vertexValid[vertexStart + geometrySize - 1] = 0; - } -}; -function isCut2(polygon) { - return Array.isArray(polygon) && polygon.length > 0 && !Number.isFinite(polygon[0]); -} - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-main.glsl.js -var solid_polygon_layer_vertex_main_glsl_default = `uniform bool extruded; -uniform bool isWireframe; -uniform float elevationScale; -uniform float opacity; -in vec4 fillColors; -in vec4 lineColors; -in vec3 pickingColors; -out vec4 vColor; -struct PolygonProps { -vec3 positions; -vec3 positions64Low; -vec3 normal; -float elevations; -}; -vec3 project_offset_normal(vec3 vector) { -if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT || -project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSETS) { -return normalize(vector * project_uCommonUnitsPerWorldUnit); -} -return project_normal(vector); -} -void calculatePosition(PolygonProps props) { -vec3 pos = props.positions; -vec3 pos64Low = props.positions64Low; -vec3 normal = props.normal; -vec4 colors = isWireframe ? lineColors : fillColors; -geometry.worldPosition = props.positions; -geometry.pickingColor = pickingColors; -if (extruded) { -pos.z += props.elevations * elevationScale; -} -gl_Position = project_position_to_clipspace(pos, pos64Low, vec3(0.), geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -if (extruded) { -#ifdef IS_SIDE_VERTEX -normal = project_offset_normal(normal); -#else -normal = project_normal(normal); -#endif -geometry.normal = normal; -vec3 lightColor = lighting_getLightColor(colors.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal); -vColor = vec4(lightColor, colors.a * opacity); -} else { -vColor = vec4(colors.rgb, colors.a * opacity); -} -DECKGL_FILTER_COLOR(vColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-top.glsl.js -var solid_polygon_layer_vertex_top_glsl_default = `#version 300 es -#define SHADER_NAME solid-polygon-layer-vertex-shader -in vec3 vertexPositions; -in vec3 vertexPositions64Low; -in float elevations; -${solid_polygon_layer_vertex_main_glsl_default} -void main(void) { -PolygonProps props; -props.positions = vertexPositions; -props.positions64Low = vertexPositions64Low; -props.elevations = elevations; -props.normal = vec3(0.0, 0.0, 1.0); -calculatePosition(props); -} -`; - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-vertex-side.glsl.js -var solid_polygon_layer_vertex_side_glsl_default = `#version 300 es -#define SHADER_NAME solid-polygon-layer-vertex-shader-side -#define IS_SIDE_VERTEX -in vec2 positions; -in vec3 vertexPositions; -in vec3 nextVertexPositions; -in vec3 vertexPositions64Low; -in vec3 nextVertexPositions64Low; -in float elevations; -in float instanceVertexValid; -${solid_polygon_layer_vertex_main_glsl_default} -void main(void) { -if(instanceVertexValid < 0.5){ -gl_Position = vec4(0.); -return; -} -PolygonProps props; -vec3 pos; -vec3 pos64Low; -vec3 nextPos; -vec3 nextPos64Low; -#if RING_WINDING_ORDER_CW == 1 -pos = vertexPositions; -pos64Low = vertexPositions64Low; -nextPos = nextVertexPositions; -nextPos64Low = nextVertexPositions64Low; -#else -pos = nextVertexPositions; -pos64Low = nextVertexPositions64Low; -nextPos = vertexPositions; -nextPos64Low = vertexPositions64Low; -#endif -props.positions = mix(pos, nextPos, positions.x); -props.positions64Low = mix(pos64Low, nextPos64Low, positions.x); -props.normal = vec3( -pos.y - nextPos.y + (pos64Low.y - nextPos64Low.y), -nextPos.x - pos.x + (nextPos64Low.x - pos64Low.x), -0.0); -props.elevations = elevations * positions.y; -calculatePosition(props); -} -`; - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer-fragment.glsl.js -var solid_polygon_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME solid-polygon-layer-fragment-shader -precision highp float; -in vec4 vColor; -out vec4 fragColor; -void main(void) { -fragColor = vColor; -geometry.uv = vec2(0.); -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/solid-polygon-layer/solid-polygon-layer.js -var DEFAULT_COLOR5 = [0, 0, 0, 255]; -var defaultProps8 = { - filled: true, - extruded: false, - wireframe: false, - _normalize: true, - _windingOrder: "CW", - _full3d: false, - elevationScale: { type: "number", min: 0, value: 1 }, - getPolygon: { type: "accessor", value: (f) => f.polygon }, - getElevation: { type: "accessor", value: 1e3 }, - getFillColor: { type: "accessor", value: DEFAULT_COLOR5 }, - getLineColor: { type: "accessor", value: DEFAULT_COLOR5 }, - material: true -}; -var ATTRIBUTE_TRANSITION2 = { - enter: (value, chunk) => { - return chunk.length ? chunk.subarray(chunk.length - value.length) : value; - } -}; -var SolidPolygonLayer = class extends layer_default { - getShaders(type) { - return super.getShaders({ - vs: type === "top" ? solid_polygon_layer_vertex_top_glsl_default : solid_polygon_layer_vertex_side_glsl_default, - fs: solid_polygon_layer_fragment_glsl_default, - defines: { - RING_WINDING_ORDER_CW: !this.props._normalize && this.props._windingOrder === "CCW" ? 0 : 1 - }, - modules: [project32_default, gouraudLighting, picking_default] - }); - } - get wrapLongitude() { - return false; - } - getBounds() { - return this.getAttributeManager()?.getBounds(["vertexPositions"]); - } - initializeState() { - const { viewport } = this.context; - let { coordinateSystem } = this.props; - const { _full3d } = this.props; - if (viewport.isGeospatial && coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { - coordinateSystem = COORDINATE_SYSTEM.LNGLAT; - } - let preproject; - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { - if (_full3d) { - preproject = viewport.projectPosition.bind(viewport); - } else { - preproject = viewport.projectFlat.bind(viewport); - } - } - this.setState({ - numInstances: 0, - polygonTesselator: new PolygonTesselator({ - // Lnglat coordinates are usually projected non-linearly, which affects tesselation results - // Provide a preproject function if the coordinates are in lnglat - preproject, - fp64: this.use64bitPositions(), - IndexType: Uint32Array - }) - }); - const attributeManager = this.getAttributeManager(); - const noAlloc = true; - attributeManager.remove(["instancePickingColors"]); - attributeManager.add({ - indices: { - size: 1, - isIndexed: true, - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculateIndices, - noAlloc - }, - vertexPositions: { - size: 3, - type: "float64", - stepMode: "dynamic", - fp64: this.use64bitPositions(), - transition: ATTRIBUTE_TRANSITION2, - accessor: "getPolygon", - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculatePositions, - noAlloc, - shaderAttributes: { - nextVertexPositions: { - vertexOffset: 1 - } - } - }, - instanceVertexValid: { - size: 1, - type: "uint16", - stepMode: "instance", - // eslint-disable-next-line @typescript-eslint/unbound-method - update: this.calculateVertexValid, - noAlloc - }, - elevations: { - size: 1, - stepMode: "dynamic", - transition: ATTRIBUTE_TRANSITION2, - accessor: "getElevation" - }, - fillColors: { - size: this.props.colorFormat.length, - type: "unorm8", - stepMode: "dynamic", - transition: ATTRIBUTE_TRANSITION2, - accessor: "getFillColor", - defaultValue: DEFAULT_COLOR5 - }, - lineColors: { - size: this.props.colorFormat.length, - type: "unorm8", - stepMode: "dynamic", - transition: ATTRIBUTE_TRANSITION2, - accessor: "getLineColor", - defaultValue: DEFAULT_COLOR5 - }, - pickingColors: { - size: 4, - type: "uint8", - stepMode: "dynamic", - accessor: (object, { index: index2, target: value }) => this.encodePickingColor(object && object.__source ? object.__source.index : index2, value) - } - }); - } - getPickingInfo(params) { - const info = super.getPickingInfo(params); - const { index: index2 } = info; - const data = this.props.data; - if (data[0] && data[0].__source) { - info.object = data.find((d) => d.__source.index === index2); - } - return info; - } - disablePickingIndex(objectIndex) { - const data = this.props.data; - if (data[0] && data[0].__source) { - for (let i = 0; i < data.length; i++) { - if (data[i].__source.index === objectIndex) { - this._disablePickingIndex(i); - } - } - } else { - super.disablePickingIndex(objectIndex); - } - } - draw({ uniforms }) { - const { extruded, filled, wireframe, elevationScale } = this.props; - const { topModel, sideModel, wireframeModel, polygonTesselator } = this.state; - const renderUniforms = { - ...uniforms, - extruded: Boolean(extruded), - elevationScale - }; - if (wireframeModel && wireframe) { - wireframeModel.setInstanceCount(polygonTesselator.instanceCount - 1); - wireframeModel.setUniforms(renderUniforms); - wireframeModel.draw(this.context.renderPass); - } - if (sideModel && filled) { - sideModel.setInstanceCount(polygonTesselator.instanceCount - 1); - sideModel.setUniforms(renderUniforms); - sideModel.draw(this.context.renderPass); - } - if (topModel && filled) { - topModel.setVertexCount(polygonTesselator.vertexCount); - topModel.setUniforms(renderUniforms); - topModel.draw(this.context.renderPass); - } - } - updateState(updateParams) { - super.updateState(updateParams); - this.updateGeometry(updateParams); - const { props, oldProps, changeFlags } = updateParams; - const attributeManager = this.getAttributeManager(); - const regenerateModels = changeFlags.extensionsChanged || props.filled !== oldProps.filled || props.extruded !== oldProps.extruded; - if (regenerateModels) { - this.state.models?.forEach((model) => model.destroy()); - this.setState(this._getModels()); - attributeManager.invalidateAll(); - } - } - updateGeometry({ props, oldProps, changeFlags }) { - const geometryConfigChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPolygon); - if (geometryConfigChanged) { - const { polygonTesselator } = this.state; - const buffers = props.data.attributes || {}; - polygonTesselator.updateGeometry({ - data: props.data, - normalize: props._normalize, - geometryBuffer: buffers.getPolygon, - buffers, - getGeometry: props.getPolygon, - positionFormat: props.positionFormat, - wrapLongitude: props.wrapLongitude, - // TODO - move the flag out of the viewport - resolution: this.context.viewport.resolution, - fp64: this.use64bitPositions(), - dataChanged: changeFlags.dataChanged, - full3d: props._full3d - }); - this.setState({ - numInstances: polygonTesselator.instanceCount, - startIndices: polygonTesselator.vertexStarts - }); - if (!changeFlags.dataChanged) { - this.getAttributeManager().invalidateAll(); - } - } - } - _getModels() { - const { id, filled, extruded } = this.props; - let topModel; - let sideModel; - let wireframeModel; - if (filled) { - const shaders = this.getShaders("top"); - shaders.defines.NON_INSTANCED_MODEL = 1; - const bufferLayout = this.getAttributeManager().getBufferLayouts({ isInstanced: false }); - topModel = new Model(this.context.device, { - ...shaders, - id: `${id}-top`, - topology: "triangle-list", - uniforms: { - isWireframe: false - }, - bufferLayout, - isIndexed: true, - userData: { - excludeAttributes: { instanceVertexValid: true } - } - }); - } - if (extruded) { - const bufferLayout = this.getAttributeManager().getBufferLayouts({ isInstanced: true }); - sideModel = new Model(this.context.device, { - ...this.getShaders("side"), - id: `${id}-side`, - bufferLayout, - uniforms: { - isWireframe: false - }, - geometry: new Geometry({ - topology: "triangle-strip", - attributes: { - // top right - top left - bottom right - bottom left - positions: { - size: 2, - value: new Float32Array([1, 0, 0, 0, 1, 1, 0, 1]) - } - } - }), - isInstanced: true, - userData: { - excludeAttributes: { indices: true } - } - }); - wireframeModel = new Model(this.context.device, { - ...this.getShaders("side"), - id: `${id}-wireframe`, - bufferLayout, - uniforms: { - isWireframe: true - }, - geometry: new Geometry({ - topology: "line-strip", - attributes: { - // top right - top left - bottom left - bottom right - positions: { - size: 2, - value: new Float32Array([1, 0, 0, 0, 0, 1, 1, 1]) - } - } - }), - isInstanced: true, - userData: { - excludeAttributes: { indices: true } - } - }); - } - return { - models: [sideModel, wireframeModel, topModel].filter(Boolean), - topModel, - sideModel, - wireframeModel - }; - } - calculateIndices(attribute) { - const { polygonTesselator } = this.state; - attribute.startIndices = polygonTesselator.indexStarts; - attribute.value = polygonTesselator.get("indices"); - } - calculatePositions(attribute) { - const { polygonTesselator } = this.state; - attribute.startIndices = polygonTesselator.vertexStarts; - attribute.value = polygonTesselator.get("positions"); - } - calculateVertexValid(attribute) { - attribute.value = this.state.polygonTesselator.get("vertexValid"); - } -}; -SolidPolygonLayer.defaultProps = defaultProps8; -SolidPolygonLayer.layerName = "SolidPolygonLayer"; -var solid_polygon_layer_default = SolidPolygonLayer; - -// node_modules/@deck.gl/layers/dist/utils.js -function replaceInRange({ data, getIndex, dataRange, replace }) { - const { startRow = 0, endRow = Infinity } = dataRange; - const count2 = data.length; - let replaceStart = count2; - let replaceEnd = count2; - for (let i = 0; i < count2; i++) { - const row = getIndex(data[i]); - if (replaceStart > i && row >= startRow) { - replaceStart = i; - } - if (row >= endRow) { - replaceEnd = i; - break; - } - } - let index2 = replaceStart; - const dataLengthChanged = replaceEnd - replaceStart !== replace.length; - const endChunk = dataLengthChanged ? data.slice(replaceEnd) : void 0; - for (let i = 0; i < replace.length; i++) { - data[index2++] = replace[i]; - } - if (endChunk) { - for (let i = 0; i < endChunk.length; i++) { - data[index2++] = endChunk[i]; - } - data.length = index2; - } - return { - startRow: replaceStart, - endRow: replaceStart + replace.length - }; -} - -// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-binary.js -function binaryToFeatureForAccesor(data, index2) { - if (!data) { - return null; - } - const featureIndex = "startIndices" in data ? data.startIndices[index2] : index2; - const geometryIndex = data.featureIds.value[featureIndex]; - if (featureIndex !== -1) { - return getPropertiesForIndex(data, geometryIndex, featureIndex); - } - return null; -} -function getPropertiesForIndex(data, propertiesIndex, numericPropsIndex) { - const feature = { - properties: { ...data.properties[propertiesIndex] } - }; - for (const prop in data.numericProps) { - feature.properties[prop] = data.numericProps[prop].value[numericPropsIndex]; - } - return feature; -} -function calculatePickingColors(geojsonBinary, encodePickingColor) { - const pickingColors = { - points: null, - lines: null, - polygons: null - }; - for (const key in pickingColors) { - const featureIds = geojsonBinary[key].globalFeatureIds.value; - pickingColors[key] = new Uint8ClampedArray(featureIds.length * 3); - const pickingColor = []; - for (let i = 0; i < featureIds.length; i++) { - encodePickingColor(featureIds[i], pickingColor); - pickingColors[key][i * 3 + 0] = pickingColor[0]; - pickingColors[key][i * 3 + 1] = pickingColor[1]; - pickingColors[key][i * 3 + 2] = pickingColor[2]; - } - } - return pickingColors; -} - -// node_modules/@deck.gl/layers/dist/text-layer/multi-icon-layer/multi-icon-layer-fragment.glsl.js -var multi_icon_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME multi-icon-layer-fragment-shader -precision highp float; -uniform float opacity; -uniform sampler2D iconsTexture; -uniform float gamma; -uniform bool sdf; -uniform float alphaCutoff; -uniform float sdfBuffer; -uniform float outlineBuffer; -uniform vec4 outlineColor; -in vec4 vColor; -in vec2 vTextureCoords; -in vec2 uv; -out vec4 fragColor; -void main(void) { -geometry.uv = uv; -if (!bool(picking.isActive)) { -float alpha = texture(iconsTexture, vTextureCoords).a; -vec4 color = vColor; -if (sdf) { -float distance = alpha; -alpha = smoothstep(sdfBuffer - gamma, sdfBuffer + gamma, distance); -if (outlineBuffer > 0.0) { -float inFill = alpha; -float inBorder = smoothstep(outlineBuffer - gamma, outlineBuffer + gamma, distance); -color = mix(outlineColor, vColor, inFill); -alpha = inBorder; -} -} -float a = alpha * color.a; -if (a < alphaCutoff) { -discard; -} -fragColor = vec4(color.rgb, a * opacity); -} -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/text-layer/multi-icon-layer/multi-icon-layer.js -var DEFAULT_BUFFER2 = 192 / 256; -var EMPTY_ARRAY3 = []; -var defaultProps9 = { - getIconOffsets: { type: "accessor", value: (x) => x.offsets }, - alphaCutoff: 1e-3, - smoothing: 0.1, - outlineWidth: 0, - outlineColor: { type: "color", value: [0, 0, 0, 255] } -}; -var MultiIconLayer = class extends icon_layer_default { - getShaders() { - return { ...super.getShaders(), fs: multi_icon_layer_fragment_glsl_default }; - } - initializeState() { - super.initializeState(); - const attributeManager = this.getAttributeManager(); - attributeManager.addInstanced({ - instanceOffsets: { - size: 2, - accessor: "getIconOffsets" - }, - instancePickingColors: { - type: "uint8", - size: 3, - accessor: (object, { index: index2, target: value }) => this.encodePickingColor(index2, value) - } - }); - } - updateState(params) { - super.updateState(params); - const { props, oldProps } = params; - let { outlineColor } = props; - if (outlineColor !== oldProps.outlineColor) { - outlineColor = outlineColor.map((x) => x / 255); - outlineColor[3] = Number.isFinite(outlineColor[3]) ? outlineColor[3] : 1; - this.setState({ - outlineColor - }); - } - if (!props.sdf && props.outlineWidth) { - log_default.warn(`${this.id}: fontSettings.sdf is required to render outline`)(); - } - } - draw(params) { - const { sdf, smoothing, outlineWidth } = this.props; - const { outlineColor } = this.state; - const outlineBuffer = outlineWidth ? Math.max(smoothing, DEFAULT_BUFFER2 * (1 - outlineWidth)) : -1; - params.uniforms = { - ...params.uniforms, - // Refer the following doc about gamma and buffer - // https://blog.mapbox.com/drawing-text-with-signed-distance-fields-in-mapbox-gl-b0933af6f817 - sdfBuffer: DEFAULT_BUFFER2, - outlineBuffer, - gamma: smoothing, - sdf: Boolean(sdf), - outlineColor - }; - super.draw(params); - if (sdf && outlineWidth) { - const { iconManager } = this.state; - const iconsTexture = iconManager.getTexture(); - const model = this.state.model; - if (iconsTexture) { - model.setUniforms({ outlineBuffer: DEFAULT_BUFFER2 }); - model.draw(this.context.renderPass); - } - } - } - getInstanceOffset(icons) { - return icons ? Array.from(icons).flatMap((icon) => super.getInstanceOffset(icon)) : EMPTY_ARRAY3; - } - getInstanceColorMode(icons) { - return 1; - } - getInstanceIconFrame(icons) { - return icons ? Array.from(icons).flatMap((icon) => super.getInstanceIconFrame(icon)) : EMPTY_ARRAY3; - } -}; -MultiIconLayer.defaultProps = defaultProps9; -MultiIconLayer.layerName = "MultiIconLayer"; -var multi_icon_layer_default = MultiIconLayer; - -// node_modules/@mapbox/tiny-sdf/index.js -var INF = 1e20; -var TinySDF = class { - constructor({ - fontSize = 24, - buffer = 3, - radius = 8, - cutoff = 0.25, - fontFamily = "sans-serif", - fontWeight = "normal", - fontStyle = "normal" - } = {}) { - this.buffer = buffer; - this.cutoff = cutoff; - this.radius = radius; - const size = this.size = fontSize + buffer * 4; - const canvas2 = this._createCanvas(size); - const ctx2 = this.ctx = canvas2.getContext("2d", { willReadFrequently: true }); - ctx2.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`; - ctx2.textBaseline = "alphabetic"; - ctx2.textAlign = "left"; - ctx2.fillStyle = "black"; - this.gridOuter = new Float64Array(size * size); - this.gridInner = new Float64Array(size * size); - this.f = new Float64Array(size); - this.z = new Float64Array(size + 1); - this.v = new Uint16Array(size); - } - _createCanvas(size) { - const canvas2 = document.createElement("canvas"); - canvas2.width = canvas2.height = size; - return canvas2; - } - draw(char) { - const { - width: glyphAdvance, - actualBoundingBoxAscent, - actualBoundingBoxDescent, - actualBoundingBoxLeft, - actualBoundingBoxRight - } = this.ctx.measureText(char); - const glyphTop = Math.ceil(actualBoundingBoxAscent); - const glyphLeft = 0; - const glyphWidth = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(actualBoundingBoxRight - actualBoundingBoxLeft))); - const glyphHeight = Math.min(this.size - this.buffer, glyphTop + Math.ceil(actualBoundingBoxDescent)); - const width = glyphWidth + 2 * this.buffer; - const height = glyphHeight + 2 * this.buffer; - const len8 = Math.max(width * height, 0); - const data = new Uint8ClampedArray(len8); - const glyph = { data, width, height, glyphWidth, glyphHeight, glyphTop, glyphLeft, glyphAdvance }; - if (glyphWidth === 0 || glyphHeight === 0) - return glyph; - const { ctx: ctx2, buffer, gridInner, gridOuter } = this; - ctx2.clearRect(buffer, buffer, glyphWidth, glyphHeight); - ctx2.fillText(char, buffer, buffer + glyphTop); - const imgData = ctx2.getImageData(buffer, buffer, glyphWidth, glyphHeight); - gridOuter.fill(INF, 0, len8); - gridInner.fill(0, 0, len8); - for (let y = 0; y < glyphHeight; y++) { - for (let x = 0; x < glyphWidth; x++) { - const a = imgData.data[4 * (y * glyphWidth + x) + 3] / 255; - if (a === 0) - continue; - const j = (y + buffer) * width + x + buffer; - if (a === 1) { - gridOuter[j] = 0; - gridInner[j] = INF; - } else { - const d = 0.5 - a; - gridOuter[j] = d > 0 ? d * d : 0; - gridInner[j] = d < 0 ? d * d : 0; - } - } - } - edt(gridOuter, 0, 0, width, height, width, this.f, this.v, this.z); - edt(gridInner, buffer, buffer, glyphWidth, glyphHeight, width, this.f, this.v, this.z); - for (let i = 0; i < len8; i++) { - const d = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]); - data[i] = Math.round(255 - 255 * (d / this.radius + this.cutoff)); - } - return glyph; - } -}; -function edt(data, x0, y0, width, height, gridSize, f, v, z) { - for (let x = x0; x < x0 + width; x++) - edt1d(data, y0 * gridSize + x, gridSize, height, f, v, z); - for (let y = y0; y < y0 + height; y++) - edt1d(data, y * gridSize + x0, 1, width, f, v, z); -} -function edt1d(grid, offset, stride, length10, f, v, z) { - v[0] = 0; - z[0] = -INF; - z[1] = INF; - f[0] = grid[offset]; - for (let q = 1, k = 0, s = 0; q < length10; q++) { - f[q] = grid[offset + q * stride]; - const q2 = q * q; - do { - const r = v[k]; - s = (f[q] - f[r] + q2 - r * r) / (q - r) / 2; - } while (s <= z[k] && --k > -1); - k++; - v[k] = q; - z[k] = s; - z[k + 1] = INF; - } - for (let q = 0, k = 0; q < length10; q++) { - while (z[k + 1] < q) - k++; - const r = v[k]; - const qr = q - r; - grid[offset + q * stride] = f[r] + qr * qr; - } -} - -// node_modules/@deck.gl/layers/dist/text-layer/utils.js -var MISSING_CHAR_WIDTH = 32; -var SINGLE_LINE = []; -function nextPowOfTwo2(number) { - return Math.pow(2, Math.ceil(Math.log2(number))); -} -function buildMapping2({ characterSet, getFontWidth, fontHeight, buffer, maxCanvasWidth, mapping = {}, xOffset = 0, yOffset = 0 }) { - let row = 0; - let x = xOffset; - const rowHeight = fontHeight + buffer * 2; - for (const char of characterSet) { - if (!mapping[char]) { - const width = getFontWidth(char); - if (x + width + buffer * 2 > maxCanvasWidth) { - x = 0; - row++; - } - mapping[char] = { - x: x + buffer, - y: yOffset + row * rowHeight + buffer, - width, - height: rowHeight, - layoutWidth: width, - layoutHeight: fontHeight - }; - x += width + buffer * 2; - } - } - return { - mapping, - xOffset: x, - yOffset: yOffset + row * rowHeight, - canvasHeight: nextPowOfTwo2(yOffset + (row + 1) * rowHeight) - }; -} -function getTextWidth(text, startIndex, endIndex, mapping) { - let width = 0; - for (let i = startIndex; i < endIndex; i++) { - const character = text[i]; - width += mapping[character]?.layoutWidth || 0; - } - return width; -} -function breakAll(text, startIndex, endIndex, maxWidth, iconMapping, target) { - let rowStartCharIndex = startIndex; - let rowOffsetLeft = 0; - for (let i = startIndex; i < endIndex; i++) { - const textWidth = getTextWidth(text, i, i + 1, iconMapping); - if (rowOffsetLeft + textWidth > maxWidth) { - if (rowStartCharIndex < i) { - target.push(i); - } - rowStartCharIndex = i; - rowOffsetLeft = 0; - } - rowOffsetLeft += textWidth; - } - return rowOffsetLeft; -} -function breakWord(text, startIndex, endIndex, maxWidth, iconMapping, target) { - let rowStartCharIndex = startIndex; - let groupStartCharIndex = startIndex; - let groupEndCharIndex = startIndex; - let rowOffsetLeft = 0; - for (let i = startIndex; i < endIndex; i++) { - if (text[i] === " ") { - groupEndCharIndex = i + 1; - } else if (text[i + 1] === " " || i + 1 === endIndex) { - groupEndCharIndex = i + 1; - } - if (groupEndCharIndex > groupStartCharIndex) { - let groupWidth = getTextWidth(text, groupStartCharIndex, groupEndCharIndex, iconMapping); - if (rowOffsetLeft + groupWidth > maxWidth) { - if (rowStartCharIndex < groupStartCharIndex) { - target.push(groupStartCharIndex); - rowStartCharIndex = groupStartCharIndex; - rowOffsetLeft = 0; - } - if (groupWidth > maxWidth) { - groupWidth = breakAll(text, groupStartCharIndex, groupEndCharIndex, maxWidth, iconMapping, target); - rowStartCharIndex = target[target.length - 1]; - } - } - groupStartCharIndex = groupEndCharIndex; - rowOffsetLeft += groupWidth; - } - } - return rowOffsetLeft; -} -function autoWrapping(text, wordBreak, maxWidth, iconMapping, startIndex = 0, endIndex) { - if (endIndex === void 0) { - endIndex = text.length; - } - const result = []; - if (wordBreak === "break-all") { - breakAll(text, startIndex, endIndex, maxWidth, iconMapping, result); - } else { - breakWord(text, startIndex, endIndex, maxWidth, iconMapping, result); - } - return result; -} -function transformRow(line, startIndex, endIndex, iconMapping, leftOffsets, rowSize) { - let x = 0; - let rowHeight = 0; - for (let i = startIndex; i < endIndex; i++) { - const character = line[i]; - const frame = iconMapping[character]; - if (frame) { - if (!rowHeight) { - rowHeight = frame.layoutHeight; - } - leftOffsets[i] = x + frame.layoutWidth / 2; - x += frame.layoutWidth; - } else { - log_default.warn(`Missing character: ${character} (${character.codePointAt(0)})`)(); - leftOffsets[i] = x; - x += MISSING_CHAR_WIDTH; - } - } - rowSize[0] = x; - rowSize[1] = rowHeight; -} -function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth, iconMapping) { - const characters = Array.from(paragraph); - const numCharacters = characters.length; - const x = new Array(numCharacters); - const y = new Array(numCharacters); - const rowWidth = new Array(numCharacters); - const autoWrappingEnabled = (wordBreak === "break-word" || wordBreak === "break-all") && isFinite(maxWidth) && maxWidth > 0; - const size = [0, 0]; - const rowSize = [0, 0]; - let rowOffsetTop = 0; - let lineStartIndex = 0; - let lineEndIndex = 0; - for (let i = 0; i <= numCharacters; i++) { - const char = characters[i]; - if (char === "\n" || i === numCharacters) { - lineEndIndex = i; - } - if (lineEndIndex > lineStartIndex) { - const rows = autoWrappingEnabled ? autoWrapping(characters, wordBreak, maxWidth, iconMapping, lineStartIndex, lineEndIndex) : SINGLE_LINE; - for (let rowIndex = 0; rowIndex <= rows.length; rowIndex++) { - const rowStart = rowIndex === 0 ? lineStartIndex : rows[rowIndex - 1]; - const rowEnd = rowIndex < rows.length ? rows[rowIndex] : lineEndIndex; - transformRow(characters, rowStart, rowEnd, iconMapping, x, rowSize); - for (let j = rowStart; j < rowEnd; j++) { - const char2 = characters[j]; - const layoutOffsetY = iconMapping[char2]?.layoutOffsetY || 0; - y[j] = rowOffsetTop + rowSize[1] / 2 + layoutOffsetY; - rowWidth[j] = rowSize[0]; - } - rowOffsetTop = rowOffsetTop + rowSize[1] * lineHeight; - size[0] = Math.max(size[0], rowSize[0]); - } - lineStartIndex = lineEndIndex; - } - if (char === "\n") { - x[lineStartIndex] = 0; - y[lineStartIndex] = 0; - rowWidth[lineStartIndex] = 0; - lineStartIndex++; - } - } - size[1] = rowOffsetTop; - return { x, y, rowWidth, size }; -} -function getTextFromBuffer({ value, length: length10, stride, offset, startIndices, characterSet }) { - const bytesPerElement = value.BYTES_PER_ELEMENT; - const elementStride = stride ? stride / bytesPerElement : 1; - const elementOffset = offset ? offset / bytesPerElement : 0; - const characterCount = startIndices[length10] || Math.ceil((value.length - elementOffset) / elementStride); - const autoCharacterSet = characterSet && /* @__PURE__ */ new Set(); - const texts = new Array(length10); - let codes = value; - if (elementStride > 1 || elementOffset > 0) { - const ArrayType2 = value.constructor; - codes = new ArrayType2(characterCount); - for (let i = 0; i < characterCount; i++) { - codes[i] = value[i * elementStride + elementOffset]; - } - } - for (let index2 = 0; index2 < length10; index2++) { - const startIndex = startIndices[index2]; - const endIndex = startIndices[index2 + 1] || characterCount; - const codesAtIndex = codes.subarray(startIndex, endIndex); - texts[index2] = String.fromCodePoint.apply(null, codesAtIndex); - if (autoCharacterSet) { - codesAtIndex.forEach(autoCharacterSet.add, autoCharacterSet); - } - } - if (autoCharacterSet) { - for (const charCode of autoCharacterSet) { - characterSet.add(String.fromCodePoint(charCode)); - } - } - return { texts, characterCount }; -} - -// node_modules/@deck.gl/layers/dist/text-layer/lru-cache.js -var LRUCache = class { - constructor(limit = 5) { - this._cache = {}; - this._order = []; - this.limit = limit; - } - get(key) { - const value = this._cache[key]; - if (value) { - this._deleteOrder(key); - this._appendOrder(key); - } - return value; - } - set(key, value) { - if (!this._cache[key]) { - if (Object.keys(this._cache).length === this.limit) { - this.delete(this._order[0]); - } - this._cache[key] = value; - this._appendOrder(key); - } else { - this.delete(key); - this._cache[key] = value; - this._appendOrder(key); - } - } - delete(key) { - const value = this._cache[key]; - if (value) { - delete this._cache[key]; - this._deleteOrder(key); - } - } - _deleteOrder(key) { - const index2 = this._order.indexOf(key); - if (index2 >= 0) { - this._order.splice(index2, 1); - } - } - _appendOrder(key) { - this._order.push(key); - } -}; - -// node_modules/@deck.gl/layers/dist/text-layer/font-atlas-manager.js -function getDefaultCharacterSet() { - const charSet = []; - for (let i = 32; i < 128; i++) { - charSet.push(String.fromCharCode(i)); - } - return charSet; -} -var DEFAULT_FONT_SETTINGS = { - fontFamily: "Monaco, monospace", - fontWeight: "normal", - characterSet: getDefaultCharacterSet(), - fontSize: 64, - buffer: 4, - sdf: false, - cutoff: 0.25, - radius: 12, - smoothing: 0.1 -}; -var MAX_CANVAS_WIDTH = 1024; -var BASELINE_SCALE = 0.9; -var HEIGHT_SCALE = 1.2; -var CACHE_LIMIT = 3; -var cache2 = new LRUCache(CACHE_LIMIT); -function getNewChars(cacheKey, characterSet) { - let newCharSet; - if (typeof characterSet === "string") { - newCharSet = new Set(Array.from(characterSet)); - } else { - newCharSet = new Set(characterSet); - } - const cachedFontAtlas = cache2.get(cacheKey); - if (!cachedFontAtlas) { - return newCharSet; - } - for (const char in cachedFontAtlas.mapping) { - if (newCharSet.has(char)) { - newCharSet.delete(char); - } - } - return newCharSet; -} -function populateAlphaChannel(alphaChannel, imageData) { - for (let i = 0; i < alphaChannel.length; i++) { - imageData.data[4 * i + 3] = alphaChannel[i]; - } -} -function setTextStyle(ctx2, fontFamily, fontSize, fontWeight) { - ctx2.font = `${fontWeight} ${fontSize}px ${fontFamily}`; - ctx2.fillStyle = "#000"; - ctx2.textBaseline = "alphabetic"; - ctx2.textAlign = "left"; -} -function setFontAtlasCacheLimit(limit) { - log_default.assert(Number.isFinite(limit) && limit >= CACHE_LIMIT, "Invalid cache limit"); - cache2 = new LRUCache(limit); -} -var FontAtlasManager = class { - constructor() { - this.props = { ...DEFAULT_FONT_SETTINGS }; - } - get atlas() { - return this._atlas; - } - // TODO - cut during v9 porting as types reveal this is not correct - // get texture(): Texture | undefined { - // return this._atlas; - // } - get mapping() { - return this._atlas && this._atlas.mapping; - } - get scale() { - const { fontSize, buffer } = this.props; - return (fontSize * HEIGHT_SCALE + buffer * 2) / fontSize; - } - setProps(props = {}) { - Object.assign(this.props, props); - this._key = this._getKey(); - const charSet = getNewChars(this._key, this.props.characterSet); - const cachedFontAtlas = cache2.get(this._key); - if (cachedFontAtlas && charSet.size === 0) { - if (this._atlas !== cachedFontAtlas) { - this._atlas = cachedFontAtlas; - } - return; - } - const fontAtlas = this._generateFontAtlas(charSet, cachedFontAtlas); - this._atlas = fontAtlas; - cache2.set(this._key, fontAtlas); - } - // eslint-disable-next-line max-statements - _generateFontAtlas(characterSet, cachedFontAtlas) { - const { fontFamily, fontWeight, fontSize, buffer, sdf, radius, cutoff } = this.props; - let canvas2 = cachedFontAtlas && cachedFontAtlas.data; - if (!canvas2) { - canvas2 = document.createElement("canvas"); - canvas2.width = MAX_CANVAS_WIDTH; - } - const ctx2 = canvas2.getContext("2d", { willReadFrequently: true }); - setTextStyle(ctx2, fontFamily, fontSize, fontWeight); - const { mapping, canvasHeight, xOffset, yOffset } = buildMapping2({ - getFontWidth: (char) => ctx2.measureText(char).width, - fontHeight: fontSize * HEIGHT_SCALE, - buffer, - characterSet, - maxCanvasWidth: MAX_CANVAS_WIDTH, - ...cachedFontAtlas && { - mapping: cachedFontAtlas.mapping, - xOffset: cachedFontAtlas.xOffset, - yOffset: cachedFontAtlas.yOffset - } - }); - if (canvas2.height !== canvasHeight) { - const imageData = ctx2.getImageData(0, 0, canvas2.width, canvas2.height); - canvas2.height = canvasHeight; - ctx2.putImageData(imageData, 0, 0); - } - setTextStyle(ctx2, fontFamily, fontSize, fontWeight); - if (sdf) { - const tinySDF = new TinySDF({ - fontSize, - buffer, - radius, - cutoff, - fontFamily, - fontWeight: `${fontWeight}` - }); - for (const char of characterSet) { - const { data, width, height, glyphTop } = tinySDF.draw(char); - mapping[char].width = width; - mapping[char].layoutOffsetY = fontSize * BASELINE_SCALE - glyphTop; - const imageData = ctx2.createImageData(width, height); - populateAlphaChannel(data, imageData); - ctx2.putImageData(imageData, mapping[char].x, mapping[char].y); - } - } else { - for (const char of characterSet) { - ctx2.fillText(char, mapping[char].x, mapping[char].y + buffer + fontSize * BASELINE_SCALE); - } - } - return { - xOffset, - yOffset, - mapping, - data: canvas2, - width: canvas2.width, - height: canvas2.height - }; - } - _getKey() { - const { fontFamily, fontWeight, fontSize, buffer, sdf, radius, cutoff } = this.props; - if (sdf) { - return `${fontFamily} ${fontWeight} ${fontSize} ${buffer} ${radius} ${cutoff}`; - } - return `${fontFamily} ${fontWeight} ${fontSize} ${buffer}`; - } -}; - -// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer-vertex.glsl.js -var text_background_layer_vertex_glsl_default = `#version 300 es -#define SHADER_NAME text-background-layer-vertex-shader -in vec2 positions; -in vec3 instancePositions; -in vec3 instancePositions64Low; -in vec4 instanceRects; -in float instanceSizes; -in float instanceAngles; -in vec2 instancePixelOffsets; -in float instanceLineWidths; -in vec4 instanceFillColors; -in vec4 instanceLineColors; -in vec3 instancePickingColors; -uniform bool billboard; -uniform float opacity; -uniform float sizeScale; -uniform float sizeMinPixels; -uniform float sizeMaxPixels; -uniform vec4 padding; -uniform int sizeUnits; -out vec4 vFillColor; -out vec4 vLineColor; -out float vLineWidth; -out vec2 uv; -out vec2 dimensions; -vec2 rotate_by_angle(vec2 vertex, float angle) { -float angle_radian = radians(angle); -float cos_angle = cos(angle_radian); -float sin_angle = sin(angle_radian); -mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle); -return rotationMatrix * vertex; -} -void main(void) { -geometry.worldPosition = instancePositions; -geometry.uv = positions; -geometry.pickingColor = instancePickingColors; -uv = positions; -vLineWidth = instanceLineWidths; -float sizePixels = clamp( -project_size_to_pixel(instanceSizes * sizeScale, sizeUnits), -sizeMinPixels, sizeMaxPixels -); -dimensions = instanceRects.zw * sizePixels + padding.xy + padding.zw; -vec2 pixelOffset = (positions * instanceRects.zw + instanceRects.xy) * sizePixels + mix(-padding.xy, padding.zw, positions); -pixelOffset = rotate_by_angle(pixelOffset, instanceAngles); -pixelOffset += instancePixelOffsets; -pixelOffset.y *= -1.0; -if (billboard) { -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -vec3 offset = vec3(pixelOffset, 0.0); -DECKGL_FILTER_SIZE(offset, geometry); -gl_Position.xy += project_pixel_size_to_clipspace(offset.xy); -} else { -vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0); -DECKGL_FILTER_SIZE(offset_common, geometry); -gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position); -DECKGL_FILTER_GL_POSITION(gl_Position, geometry); -} -vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity); -DECKGL_FILTER_COLOR(vFillColor, geometry); -vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity); -DECKGL_FILTER_COLOR(vLineColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer-fragment.glsl.js -var text_background_layer_fragment_glsl_default = `#version 300 es -#define SHADER_NAME text-background-layer-fragment-shader -precision highp float; -uniform bool stroked; -in vec4 vFillColor; -in vec4 vLineColor; -in float vLineWidth; -in vec2 uv; -in vec2 dimensions; -out vec4 fragColor; -void main(void) { -geometry.uv = uv; -vec2 pixelPosition = uv * dimensions; -if (stroked) { -float distToEdge = min( -min(pixelPosition.x, dimensions.x - pixelPosition.x), -min(pixelPosition.y, dimensions.y - pixelPosition.y) -); -float isBorder = smoothedge(distToEdge, vLineWidth); -fragColor = mix(vFillColor, vLineColor, isBorder); -} else { -fragColor = vFillColor; -} -DECKGL_FILTER_COLOR(fragColor, geometry); -} -`; - -// node_modules/@deck.gl/layers/dist/text-layer/text-background-layer/text-background-layer.js -var defaultProps10 = { - billboard: true, - sizeScale: 1, - sizeUnits: "pixels", - sizeMinPixels: 0, - sizeMaxPixels: Number.MAX_SAFE_INTEGER, - padding: { type: "array", value: [0, 0, 0, 0] }, - getPosition: { type: "accessor", value: (x) => x.position }, - getSize: { type: "accessor", value: 1 }, - getAngle: { type: "accessor", value: 0 }, - getPixelOffset: { type: "accessor", value: [0, 0] }, - getBoundingRect: { type: "accessor", value: [0, 0, 0, 0] }, - getFillColor: { type: "accessor", value: [0, 0, 0, 255] }, - getLineColor: { type: "accessor", value: [0, 0, 0, 255] }, - getLineWidth: { type: "accessor", value: 1 } -}; -var TextBackgroundLayer = class extends layer_default { - getShaders() { - return super.getShaders({ vs: text_background_layer_vertex_glsl_default, fs: text_background_layer_fragment_glsl_default, modules: [project32_default, picking_default] }); - } - initializeState() { - this.getAttributeManager().addInstanced({ - instancePositions: { - size: 3, - type: "float64", - fp64: this.use64bitPositions(), - transition: true, - accessor: "getPosition" - }, - instanceSizes: { - size: 1, - transition: true, - accessor: "getSize", - defaultValue: 1 - }, - instanceAngles: { - size: 1, - transition: true, - accessor: "getAngle" - }, - instanceRects: { - size: 4, - accessor: "getBoundingRect" - }, - instancePixelOffsets: { - size: 2, - transition: true, - accessor: "getPixelOffset" - }, - instanceFillColors: { - size: 4, - transition: true, - type: "unorm8", - accessor: "getFillColor", - defaultValue: [0, 0, 0, 255] - }, - instanceLineColors: { - size: 4, - transition: true, - type: "unorm8", - accessor: "getLineColor", - defaultValue: [0, 0, 0, 255] - }, - instanceLineWidths: { - size: 1, - transition: true, - accessor: "getLineWidth", - defaultValue: 1 - } - }); - } - updateState(params) { - super.updateState(params); - const { changeFlags } = params; - if (changeFlags.extensionsChanged) { - this.state.model?.destroy(); - this.state.model = this._getModel(); - this.getAttributeManager().invalidateAll(); - } - } - draw({ uniforms }) { - const { billboard, sizeScale, sizeUnits, sizeMinPixels, sizeMaxPixels, getLineWidth } = this.props; - let { padding } = this.props; - if (padding.length < 4) { - padding = [padding[0], padding[1], padding[0], padding[1]]; - } - const model = this.state.model; - model.setUniforms(uniforms); - model.setUniforms({ - billboard, - stroked: Boolean(getLineWidth), - padding, - sizeUnits: UNIT[sizeUnits], - sizeScale, - sizeMinPixels, - sizeMaxPixels - }); - model.draw(this.context.renderPass); - } - _getModel() { - const positions = [0, 0, 1, 0, 1, 1, 0, 1]; - return new Model(this.context.device, { - ...this.getShaders(), - id: this.props.id, - bufferLayout: this.getAttributeManager().getBufferLayouts(), - geometry: new Geometry({ - topology: "triangle-fan-webgl", - vertexCount: 4, - attributes: { - positions: { size: 2, value: new Float32Array(positions) } - } - }), - isInstanced: true - }); - } -}; -TextBackgroundLayer.defaultProps = defaultProps10; -TextBackgroundLayer.layerName = "TextBackgroundLayer"; -var text_background_layer_default = TextBackgroundLayer; - -// node_modules/@deck.gl/layers/dist/text-layer/text-layer.js -var TEXT_ANCHOR = { - start: 1, - middle: 0, - end: -1 -}; -var ALIGNMENT_BASELINE = { - top: 1, - center: 0, - bottom: -1 -}; -var DEFAULT_COLOR6 = [0, 0, 0, 255]; -var DEFAULT_LINE_HEIGHT = 1; -var defaultProps11 = { - billboard: true, - sizeScale: 1, - sizeUnits: "pixels", - sizeMinPixels: 0, - sizeMaxPixels: Number.MAX_SAFE_INTEGER, - background: false, - getBackgroundColor: { type: "accessor", value: [255, 255, 255, 255] }, - getBorderColor: { type: "accessor", value: DEFAULT_COLOR6 }, - getBorderWidth: { type: "accessor", value: 0 }, - backgroundPadding: { type: "array", value: [0, 0, 0, 0] }, - characterSet: { type: "object", value: DEFAULT_FONT_SETTINGS.characterSet }, - fontFamily: DEFAULT_FONT_SETTINGS.fontFamily, - fontWeight: DEFAULT_FONT_SETTINGS.fontWeight, - lineHeight: DEFAULT_LINE_HEIGHT, - outlineWidth: { type: "number", value: 0, min: 0 }, - outlineColor: { type: "color", value: DEFAULT_COLOR6 }, - fontSettings: { type: "object", value: {}, compare: 1 }, - // auto wrapping options - wordBreak: "break-word", - maxWidth: { type: "number", value: -1 }, - getText: { type: "accessor", value: (x) => x.text }, - getPosition: { type: "accessor", value: (x) => x.position }, - getColor: { type: "accessor", value: DEFAULT_COLOR6 }, - getSize: { type: "accessor", value: 32 }, - getAngle: { type: "accessor", value: 0 }, - getTextAnchor: { type: "accessor", value: "middle" }, - getAlignmentBaseline: { type: "accessor", value: "center" }, - getPixelOffset: { type: "accessor", value: [0, 0] }, - // deprecated - backgroundColor: { deprecatedFor: ["background", "getBackgroundColor"] } -}; -var TextLayer = class extends composite_layer_default { - constructor() { - super(...arguments); - this.getBoundingRect = (object, objectInfo) => { - let { size: [width, height] } = this.transformParagraph(object, objectInfo); - const { fontSize } = this.state.fontAtlasManager.props; - width /= fontSize; - height /= fontSize; - const { getTextAnchor, getAlignmentBaseline } = this.props; - const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; - const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; - return [(anchorX - 1) * width / 2, (anchorY - 1) * height / 2, width, height]; - }; - this.getIconOffsets = (object, objectInfo) => { - const { getTextAnchor, getAlignmentBaseline } = this.props; - const { x, y, rowWidth, size: [width, height] } = this.transformParagraph(object, objectInfo); - const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; - const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; - const numCharacters = x.length; - const offsets = new Array(numCharacters * 2); - let index2 = 0; - for (let i = 0; i < numCharacters; i++) { - const rowOffset = (1 - anchorX) * (width - rowWidth[i]) / 2; - offsets[index2++] = (anchorX - 1) * width / 2 + rowOffset + x[i]; - offsets[index2++] = (anchorY - 1) * height / 2 + y[i]; - } - return offsets; - }; - } - initializeState() { - this.state = { - styleVersion: 0, - fontAtlasManager: new FontAtlasManager() - }; - if (this.props.maxWidth > 0) { - log_default.warn("v8.9 breaking change: TextLayer maxWidth is now relative to text size")(); - } - } - // eslint-disable-next-line complexity - updateState(params) { - const { props, oldProps, changeFlags } = params; - const textChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getText); - if (textChanged) { - this._updateText(); - } - const fontChanged = this._updateFontAtlas(); - const styleChanged = fontChanged || props.lineHeight !== oldProps.lineHeight || props.wordBreak !== oldProps.wordBreak || props.maxWidth !== oldProps.maxWidth; - if (styleChanged) { - this.setState({ - styleVersion: this.state.styleVersion + 1 - }); - } - } - getPickingInfo({ info }) { - info.object = info.index >= 0 ? this.props.data[info.index] : null; - return info; - } - /** Returns true if font has changed */ - _updateFontAtlas() { - const { fontSettings, fontFamily, fontWeight } = this.props; - const { fontAtlasManager, characterSet } = this.state; - const fontProps = { - ...fontSettings, - characterSet, - fontFamily, - fontWeight - }; - if (!fontAtlasManager.mapping) { - fontAtlasManager.setProps(fontProps); - return true; - } - for (const key in fontProps) { - if (fontProps[key] !== fontAtlasManager.props[key]) { - fontAtlasManager.setProps(fontProps); - return true; - } - } - return false; - } - // Text strings are variable width objects - // Count characters and start offsets - _updateText() { - const { data, characterSet } = this.props; - const textBuffer = data.attributes?.getText; - let { getText } = this.props; - let startIndices = data.startIndices; - let numInstances; - const autoCharacterSet = characterSet === "auto" && /* @__PURE__ */ new Set(); - if (textBuffer && startIndices) { - const { texts, characterCount } = getTextFromBuffer({ - ...ArrayBuffer.isView(textBuffer) ? { value: textBuffer } : textBuffer, - // @ts-ignore if data.attribute is defined then length is expected - length: data.length, - startIndices, - characterSet: autoCharacterSet - }); - numInstances = characterCount; - getText = (_, { index: index2 }) => texts[index2]; - } else { - const { iterable, objectInfo } = createIterable(data); - startIndices = [0]; - numInstances = 0; - for (const object of iterable) { - objectInfo.index++; - const text = Array.from(getText(object, objectInfo) || ""); - if (autoCharacterSet) { - text.forEach(autoCharacterSet.add, autoCharacterSet); - } - numInstances += text.length; - startIndices.push(numInstances); - } - } - this.setState({ - getText, - startIndices, - numInstances, - characterSet: autoCharacterSet || characterSet - }); - } - /** There are two size systems in this layer: - - + Pixel size: user-specified text size, via getSize, sizeScale, sizeUnits etc. - The layer roughly matches the output of the layer to CSS pixels, e.g. getSize: 12, sizeScale: 2 - in layer props is roughly equivalent to font-size: 24px in CSS. - + Texture size: internally, character positions in a text blob are calculated using the sizes of iconMapping, - which depends on how large each character is drawn into the font atlas. This is controlled by - fontSettings.fontSize (default 64) and most users do not set it manually. - These numbers are intended to be used in the vertex shader and never to be exposed to the end user. - - All surfaces exposed to the user should either use the pixel size or a multiplier relative to the pixel size. */ - /** Calculate the size and position of each character in a text string. - * Values are in texture size */ - transformParagraph(object, objectInfo) { - const { fontAtlasManager } = this.state; - const iconMapping = fontAtlasManager.mapping; - const getText = this.state.getText; - const { wordBreak, lineHeight, maxWidth } = this.props; - const paragraph = getText(object, objectInfo) || ""; - return transformParagraph(paragraph, lineHeight, wordBreak, maxWidth * fontAtlasManager.props.fontSize, iconMapping); - } - renderLayers() { - const { startIndices, numInstances, getText, fontAtlasManager: { scale: scale13, atlas, mapping }, styleVersion } = this.state; - const { data, _dataDiff, getPosition: getPosition2, getColor: getColor2, getSize, getAngle, getPixelOffset, getBackgroundColor, getBorderColor, getBorderWidth, backgroundPadding, background, billboard, fontSettings, outlineWidth, outlineColor, sizeScale, sizeUnits, sizeMinPixels, sizeMaxPixels, transitions, updateTriggers } = this.props; - const CharactersLayerClass = this.getSubLayerClass("characters", multi_icon_layer_default); - const BackgroundLayerClass = this.getSubLayerClass("background", text_background_layer_default); - return [ - background && new BackgroundLayerClass({ - // background props - getFillColor: getBackgroundColor, - getLineColor: getBorderColor, - getLineWidth: getBorderWidth, - padding: backgroundPadding, - // props shared with characters layer - getPosition: getPosition2, - getSize, - getAngle, - getPixelOffset, - billboard, - sizeScale, - sizeUnits, - sizeMinPixels, - sizeMaxPixels, - transitions: transitions && { - getPosition: transitions.getPosition, - getAngle: transitions.getAngle, - getSize: transitions.getSize, - getFillColor: transitions.getBackgroundColor, - getLineColor: transitions.getBorderColor, - getLineWidth: transitions.getBorderWidth, - getPixelOffset: transitions.getPixelOffset - } - }, this.getSubLayerProps({ - id: "background", - updateTriggers: { - getPosition: updateTriggers.getPosition, - getAngle: updateTriggers.getAngle, - getSize: updateTriggers.getSize, - getFillColor: updateTriggers.getBackgroundColor, - getLineColor: updateTriggers.getBorderColor, - getLineWidth: updateTriggers.getBorderWidth, - getPixelOffset: updateTriggers.getPixelOffset, - getBoundingRect: { - getText: updateTriggers.getText, - getTextAnchor: updateTriggers.getTextAnchor, - getAlignmentBaseline: updateTriggers.getAlignmentBaseline, - styleVersion - } - } - }), { - data: ( - // @ts-ignore (2339) attribute is not defined on all data types - data.attributes && data.attributes.background ? ( - // @ts-ignore (2339) attribute is not defined on all data types - { length: data.length, attributes: data.attributes.background } - ) : data - ), - _dataDiff, - // Maintain the same background behavior as <=8.3. Remove in v9? - autoHighlight: false, - getBoundingRect: this.getBoundingRect - }), - new CharactersLayerClass({ - sdf: fontSettings.sdf, - smoothing: Number.isFinite(fontSettings.smoothing) ? fontSettings.smoothing : DEFAULT_FONT_SETTINGS.smoothing, - outlineWidth: outlineWidth / (fontSettings.radius || DEFAULT_FONT_SETTINGS.radius), - outlineColor, - iconAtlas: atlas, - iconMapping: mapping, - getPosition: getPosition2, - getColor: getColor2, - getSize, - getAngle, - getPixelOffset, - billboard, - sizeScale: sizeScale * scale13, - sizeUnits, - sizeMinPixels: sizeMinPixels * scale13, - sizeMaxPixels: sizeMaxPixels * scale13, - transitions: transitions && { - getPosition: transitions.getPosition, - getAngle: transitions.getAngle, - getColor: transitions.getColor, - getSize: transitions.getSize, - getPixelOffset: transitions.getPixelOffset - } - }, this.getSubLayerProps({ - id: "characters", - updateTriggers: { - all: updateTriggers.getText, - getPosition: updateTriggers.getPosition, - getAngle: updateTriggers.getAngle, - getColor: updateTriggers.getColor, - getSize: updateTriggers.getSize, - getPixelOffset: updateTriggers.getPixelOffset, - getIconOffsets: { - getTextAnchor: updateTriggers.getTextAnchor, - getAlignmentBaseline: updateTriggers.getAlignmentBaseline, - styleVersion - } - } - }), { - data, - _dataDiff, - startIndices, - numInstances, - getIconOffsets: this.getIconOffsets, - getIcon: getText - }) - ]; - } - static set fontAtlasCacheLimit(limit) { - setFontAtlasCacheLimit(limit); - } -}; -TextLayer.defaultProps = defaultProps11; -TextLayer.layerName = "TextLayer"; -var text_layer_default = TextLayer; - -// node_modules/@deck.gl/layers/dist/geojson-layer/sub-layer-map.js -var POINT_LAYER = { - circle: { - type: scatterplot_layer_default, - props: { - filled: "filled", - stroked: "stroked", - lineWidthMaxPixels: "lineWidthMaxPixels", - lineWidthMinPixels: "lineWidthMinPixels", - lineWidthScale: "lineWidthScale", - lineWidthUnits: "lineWidthUnits", - pointRadiusMaxPixels: "radiusMaxPixels", - pointRadiusMinPixels: "radiusMinPixels", - pointRadiusScale: "radiusScale", - pointRadiusUnits: "radiusUnits", - pointAntialiasing: "antialiasing", - pointBillboard: "billboard", - getFillColor: "getFillColor", - getLineColor: "getLineColor", - getLineWidth: "getLineWidth", - getPointRadius: "getRadius" - } - }, - icon: { - type: icon_layer_default, - props: { - iconAtlas: "iconAtlas", - iconMapping: "iconMapping", - iconSizeMaxPixels: "sizeMaxPixels", - iconSizeMinPixels: "sizeMinPixels", - iconSizeScale: "sizeScale", - iconSizeUnits: "sizeUnits", - iconAlphaCutoff: "alphaCutoff", - iconBillboard: "billboard", - getIcon: "getIcon", - getIconAngle: "getAngle", - getIconColor: "getColor", - getIconPixelOffset: "getPixelOffset", - getIconSize: "getSize" - } - }, - text: { - type: text_layer_default, - props: { - textSizeMaxPixels: "sizeMaxPixels", - textSizeMinPixels: "sizeMinPixels", - textSizeScale: "sizeScale", - textSizeUnits: "sizeUnits", - textBackground: "background", - textBackgroundPadding: "backgroundPadding", - textFontFamily: "fontFamily", - textFontWeight: "fontWeight", - textLineHeight: "lineHeight", - textMaxWidth: "maxWidth", - textOutlineColor: "outlineColor", - textOutlineWidth: "outlineWidth", - textWordBreak: "wordBreak", - textCharacterSet: "characterSet", - textBillboard: "billboard", - textFontSettings: "fontSettings", - getText: "getText", - getTextAngle: "getAngle", - getTextColor: "getColor", - getTextPixelOffset: "getPixelOffset", - getTextSize: "getSize", - getTextAnchor: "getTextAnchor", - getTextAlignmentBaseline: "getAlignmentBaseline", - getTextBackgroundColor: "getBackgroundColor", - getTextBorderColor: "getBorderColor", - getTextBorderWidth: "getBorderWidth" - } - } -}; -var LINE_LAYER = { - type: path_layer_default, - props: { - lineWidthUnits: "widthUnits", - lineWidthScale: "widthScale", - lineWidthMinPixels: "widthMinPixels", - lineWidthMaxPixels: "widthMaxPixels", - lineJointRounded: "jointRounded", - lineCapRounded: "capRounded", - lineMiterLimit: "miterLimit", - lineBillboard: "billboard", - getLineColor: "getColor", - getLineWidth: "getWidth" - } -}; -var POLYGON_LAYER = { - type: solid_polygon_layer_default, - props: { - extruded: "extruded", - filled: "filled", - wireframe: "wireframe", - elevationScale: "elevationScale", - material: "material", - _full3d: "_full3d", - getElevation: "getElevation", - getFillColor: "getFillColor", - getLineColor: "getLineColor" - } -}; -function getDefaultProps({ type, props }) { - const result = {}; - for (const key in props) { - result[key] = type.defaultProps[props[key]]; - } - return result; -} -function forwardProps(layer, mapping) { - const { transitions, updateTriggers } = layer.props; - const result = { - updateTriggers: {}, - transitions: transitions && { - getPosition: transitions.geometry - } - }; - for (const sourceKey in mapping) { - const targetKey = mapping[sourceKey]; - let value = layer.props[sourceKey]; - if (sourceKey.startsWith("get")) { - value = layer.getSubLayerAccessor(value); - result.updateTriggers[targetKey] = updateTriggers[sourceKey]; - if (transitions) { - result.transitions[targetKey] = transitions[sourceKey]; - } - } - result[targetKey] = value; - } - return result; -} - -// node_modules/@deck.gl/layers/dist/geojson-layer/geojson.js -function getGeojsonFeatures(geojson) { - if (Array.isArray(geojson)) { - return geojson; - } - log_default.assert(geojson.type, "GeoJSON does not have type"); - switch (geojson.type) { - case "Feature": - return [geojson]; - case "FeatureCollection": - log_default.assert(Array.isArray(geojson.features), "GeoJSON does not have features array"); - return geojson.features; - default: - return [{ geometry: geojson }]; - } -} -function separateGeojsonFeatures(features, wrapFeature, dataRange = {}) { - const separated = { - pointFeatures: [], - lineFeatures: [], - polygonFeatures: [], - polygonOutlineFeatures: [] - }; - const { startRow = 0, endRow = features.length } = dataRange; - for (let featureIndex = startRow; featureIndex < endRow; featureIndex++) { - const feature = features[featureIndex]; - const { geometry } = feature; - if (!geometry) { - continue; - } - if (geometry.type === "GeometryCollection") { - log_default.assert(Array.isArray(geometry.geometries), "GeoJSON does not have geometries array"); - const { geometries } = geometry; - for (let i = 0; i < geometries.length; i++) { - const subGeometry = geometries[i]; - separateGeometry(subGeometry, separated, wrapFeature, feature, featureIndex); - } - } else { - separateGeometry(geometry, separated, wrapFeature, feature, featureIndex); - } - } - return separated; -} -function separateGeometry(geometry, separated, wrapFeature, sourceFeature, sourceFeatureIndex) { - const { type, coordinates } = geometry; - const { pointFeatures, lineFeatures, polygonFeatures, polygonOutlineFeatures } = separated; - if (!validateGeometry(type, coordinates)) { - log_default.warn(`${type} coordinates are malformed`)(); - return; - } - switch (type) { - case "Point": - pointFeatures.push(wrapFeature({ - geometry - }, sourceFeature, sourceFeatureIndex)); - break; - case "MultiPoint": - coordinates.forEach((point) => { - pointFeatures.push(wrapFeature({ - geometry: { type: "Point", coordinates: point } - }, sourceFeature, sourceFeatureIndex)); - }); - break; - case "LineString": - lineFeatures.push(wrapFeature({ - geometry - }, sourceFeature, sourceFeatureIndex)); - break; - case "MultiLineString": - coordinates.forEach((path) => { - lineFeatures.push(wrapFeature({ - geometry: { type: "LineString", coordinates: path } - }, sourceFeature, sourceFeatureIndex)); - }); - break; - case "Polygon": - polygonFeatures.push(wrapFeature({ - geometry - }, sourceFeature, sourceFeatureIndex)); - coordinates.forEach((path) => { - polygonOutlineFeatures.push(wrapFeature({ - geometry: { type: "LineString", coordinates: path } - }, sourceFeature, sourceFeatureIndex)); - }); - break; - case "MultiPolygon": - coordinates.forEach((polygon) => { - polygonFeatures.push(wrapFeature({ - geometry: { type: "Polygon", coordinates: polygon } - }, sourceFeature, sourceFeatureIndex)); - polygon.forEach((path) => { - polygonOutlineFeatures.push(wrapFeature({ - geometry: { type: "LineString", coordinates: path } - }, sourceFeature, sourceFeatureIndex)); - }); - }); - break; - default: - } -} -var COORDINATE_NEST_LEVEL = { - Point: 1, - MultiPoint: 2, - LineString: 2, - MultiLineString: 3, - Polygon: 3, - MultiPolygon: 4 -}; -function validateGeometry(type, coordinates) { - let nestLevel = COORDINATE_NEST_LEVEL[type]; - log_default.assert(nestLevel, `Unknown GeoJSON type ${type}`); - while (coordinates && --nestLevel > 0) { - coordinates = coordinates[0]; - } - return coordinates && Number.isFinite(coordinates[0]); -} - -// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-layer-props.js -function createEmptyLayerProps() { - return { - points: {}, - lines: {}, - polygons: {}, - polygonsOutline: {} - }; -} -function getCoordinates(f) { - return f.geometry.coordinates; -} -function createLayerPropsFromFeatures(features, featuresDiff) { - const layerProps = createEmptyLayerProps(); - const { pointFeatures, lineFeatures, polygonFeatures, polygonOutlineFeatures } = features; - layerProps.points.data = pointFeatures; - layerProps.points._dataDiff = featuresDiff.pointFeatures && (() => featuresDiff.pointFeatures); - layerProps.points.getPosition = getCoordinates; - layerProps.lines.data = lineFeatures; - layerProps.lines._dataDiff = featuresDiff.lineFeatures && (() => featuresDiff.lineFeatures); - layerProps.lines.getPath = getCoordinates; - layerProps.polygons.data = polygonFeatures; - layerProps.polygons._dataDiff = featuresDiff.polygonFeatures && (() => featuresDiff.polygonFeatures); - layerProps.polygons.getPolygon = getCoordinates; - layerProps.polygonsOutline.data = polygonOutlineFeatures; - layerProps.polygonsOutline._dataDiff = featuresDiff.polygonOutlineFeatures && (() => featuresDiff.polygonOutlineFeatures); - layerProps.polygonsOutline.getPath = getCoordinates; - return layerProps; -} -function createLayerPropsFromBinary(geojsonBinary, encodePickingColor) { - const layerProps = createEmptyLayerProps(); - const { points, lines, polygons } = geojsonBinary; - const customPickingColors = calculatePickingColors(geojsonBinary, encodePickingColor); - layerProps.points.data = { - length: points.positions.value.length / points.positions.size, - attributes: { - ...points.attributes, - getPosition: points.positions, - instancePickingColors: { - size: 3, - value: customPickingColors.points - } - }, - properties: points.properties, - numericProps: points.numericProps, - featureIds: points.featureIds - }; - layerProps.lines.data = { - length: lines.pathIndices.value.length - 1, - startIndices: lines.pathIndices.value, - attributes: { - ...lines.attributes, - getPath: lines.positions, - instancePickingColors: { - size: 3, - value: customPickingColors.lines - } - }, - properties: lines.properties, - numericProps: lines.numericProps, - featureIds: lines.featureIds - }; - layerProps.lines._pathType = "open"; - layerProps.polygons.data = { - length: polygons.polygonIndices.value.length - 1, - startIndices: polygons.polygonIndices.value, - attributes: { - ...polygons.attributes, - getPolygon: polygons.positions, - pickingColors: { - size: 3, - value: customPickingColors.polygons - } - }, - properties: polygons.properties, - numericProps: polygons.numericProps, - featureIds: polygons.featureIds - }; - layerProps.polygons._normalize = false; - if (polygons.triangles) { - layerProps.polygons.data.attributes.indices = polygons.triangles.value; - } - layerProps.polygonsOutline.data = { - length: polygons.primitivePolygonIndices.value.length - 1, - startIndices: polygons.primitivePolygonIndices.value, - attributes: { - ...polygons.attributes, - getPath: polygons.positions, - instancePickingColors: { - size: 3, - value: customPickingColors.polygons - } - }, - properties: polygons.properties, - numericProps: polygons.numericProps, - featureIds: polygons.featureIds - }; - layerProps.polygonsOutline._pathType = "open"; - return layerProps; -} - -// node_modules/@deck.gl/layers/dist/geojson-layer/geojson-layer.js -var FEATURE_TYPES = ["points", "linestrings", "polygons"]; -var defaultProps12 = { - ...getDefaultProps(POINT_LAYER.circle), - ...getDefaultProps(POINT_LAYER.icon), - ...getDefaultProps(POINT_LAYER.text), - ...getDefaultProps(LINE_LAYER), - ...getDefaultProps(POLYGON_LAYER), - // Overwrite sub layer defaults - stroked: true, - filled: true, - extruded: false, - wireframe: false, - _full3d: false, - iconAtlas: { type: "object", value: null }, - iconMapping: { type: "object", value: {} }, - getIcon: { type: "accessor", value: (f) => f.properties.icon }, - getText: { type: "accessor", value: (f) => f.properties.text }, - // Self props - pointType: "circle", - // TODO: deprecated, remove in v9 - getRadius: { deprecatedFor: "getPointRadius" } -}; -var GeoJsonLayer = class extends composite_layer_default { - initializeState() { - this.state = { - layerProps: {}, - features: {}, - featuresDiff: {} - }; - } - updateState({ props, changeFlags }) { - if (!changeFlags.dataChanged) { - return; - } - const { data } = this.props; - const binary = data && "points" in data && "polygons" in data && "lines" in data; - this.setState({ binary }); - if (binary) { - this._updateStateBinary({ props, changeFlags }); - } else { - this._updateStateJSON({ props, changeFlags }); - } - } - _updateStateBinary({ props, changeFlags }) { - const layerProps = createLayerPropsFromBinary(props.data, this.encodePickingColor); - this.setState({ layerProps }); - } - _updateStateJSON({ props, changeFlags }) { - const features = getGeojsonFeatures(props.data); - const wrapFeature = this.getSubLayerRow.bind(this); - let newFeatures = {}; - const featuresDiff = {}; - if (Array.isArray(changeFlags.dataChanged)) { - const oldFeatures = this.state.features; - for (const key in oldFeatures) { - newFeatures[key] = oldFeatures[key].slice(); - featuresDiff[key] = []; - } - for (const dataRange of changeFlags.dataChanged) { - const partialFeatures = separateGeojsonFeatures(features, wrapFeature, dataRange); - for (const key in oldFeatures) { - featuresDiff[key].push(replaceInRange({ - data: newFeatures[key], - getIndex: (f) => f.__source.index, - dataRange, - replace: partialFeatures[key] - })); - } - } - } else { - newFeatures = separateGeojsonFeatures(features, wrapFeature); - } - const layerProps = createLayerPropsFromFeatures(newFeatures, featuresDiff); - this.setState({ - features: newFeatures, - featuresDiff, - layerProps - }); - } - getPickingInfo(params) { - const info = super.getPickingInfo(params); - const { index: index2, sourceLayer } = info; - info.featureType = FEATURE_TYPES.find((ft) => sourceLayer.id.startsWith(`${this.id}-${ft}-`)); - if (index2 >= 0 && sourceLayer.id.startsWith(`${this.id}-points-text`) && this.state.binary) { - info.index = this.props.data.points.globalFeatureIds.value[index2]; - } - return info; - } - _updateAutoHighlight(info) { - const pointLayerIdPrefix = `${this.id}-points-`; - const sourceIsPoints = info.featureType === "points"; - for (const layer of this.getSubLayers()) { - if (layer.id.startsWith(pointLayerIdPrefix) === sourceIsPoints) { - layer.updateAutoHighlight(info); - } - } - } - _renderPolygonLayer() { - const { extruded, wireframe } = this.props; - const { layerProps } = this.state; - const id = "polygons-fill"; - const PolygonFillLayer = this.shouldRenderSubLayer(id, layerProps.polygons?.data) && this.getSubLayerClass(id, POLYGON_LAYER.type); - if (PolygonFillLayer) { - const forwardedProps = forwardProps(this, POLYGON_LAYER.props); - const useLineColor = extruded && wireframe; - if (!useLineColor) { - delete forwardedProps.getLineColor; - } - forwardedProps.updateTriggers.lineColors = useLineColor; - return new PolygonFillLayer(forwardedProps, this.getSubLayerProps({ - id, - updateTriggers: forwardedProps.updateTriggers - }), layerProps.polygons); - } - return null; - } - _renderLineLayers() { - const { extruded, stroked } = this.props; - const { layerProps } = this.state; - const polygonStrokeLayerId = "polygons-stroke"; - const lineStringsLayerId = "linestrings"; - const PolygonStrokeLayer = !extruded && stroked && this.shouldRenderSubLayer(polygonStrokeLayerId, layerProps.polygonsOutline?.data) && this.getSubLayerClass(polygonStrokeLayerId, LINE_LAYER.type); - const LineStringsLayer = this.shouldRenderSubLayer(lineStringsLayerId, layerProps.lines?.data) && this.getSubLayerClass(lineStringsLayerId, LINE_LAYER.type); - if (PolygonStrokeLayer || LineStringsLayer) { - const forwardedProps = forwardProps(this, LINE_LAYER.props); - return [ - PolygonStrokeLayer && new PolygonStrokeLayer(forwardedProps, this.getSubLayerProps({ - id: polygonStrokeLayerId, - updateTriggers: forwardedProps.updateTriggers - }), layerProps.polygonsOutline), - LineStringsLayer && new LineStringsLayer(forwardedProps, this.getSubLayerProps({ - id: lineStringsLayerId, - updateTriggers: forwardedProps.updateTriggers - }), layerProps.lines) - ]; - } - return null; - } - _renderPointLayers() { - const { pointType } = this.props; - const { layerProps, binary } = this.state; - let { highlightedObjectIndex } = this.props; - if (!binary && Number.isFinite(highlightedObjectIndex)) { - highlightedObjectIndex = layerProps.points.data.findIndex((d) => d.__source.index === highlightedObjectIndex); - } - const types = new Set(pointType.split("+")); - const pointLayers = []; - for (const type of types) { - const id = `points-${type}`; - const PointLayerMapping = POINT_LAYER[type]; - const PointsLayer = PointLayerMapping && this.shouldRenderSubLayer(id, layerProps.points?.data) && this.getSubLayerClass(id, PointLayerMapping.type); - if (PointsLayer) { - const forwardedProps = forwardProps(this, PointLayerMapping.props); - let pointsLayerProps = layerProps.points; - if (type === "text" && binary) { - const { instancePickingColors, ...rest } = pointsLayerProps.data.attributes; - pointsLayerProps = { - ...pointsLayerProps, - // @ts-expect-error TODO - type binary data - data: { ...pointsLayerProps.data, attributes: rest } - }; - } - pointLayers.push(new PointsLayer(forwardedProps, this.getSubLayerProps({ - id, - updateTriggers: forwardedProps.updateTriggers, - highlightedObjectIndex - }), pointsLayerProps)); - } - } - return pointLayers; - } - renderLayers() { - const { extruded } = this.props; - const polygonFillLayer = this._renderPolygonLayer(); - const lineLayers = this._renderLineLayers(); - const pointLayers = this._renderPointLayers(); - return [ - // If not extruded: flat fill layer is drawn below outlines - !extruded && polygonFillLayer, - lineLayers, - pointLayers, - // If extruded: draw fill layer last for correct blending behavior - extruded && polygonFillLayer - ]; - } - getSubLayerAccessor(accessor) { - const { binary } = this.state; - if (!binary || typeof accessor !== "function") { - return super.getSubLayerAccessor(accessor); - } - return (object, info) => { - const { data, index: index2 } = info; - const feature = binaryToFeatureForAccesor(data, index2); - return accessor(feature, info); - }; - } -}; -GeoJsonLayer.layerName = "GeoJsonLayer"; -GeoJsonLayer.defaultProps = defaultProps12; -var geojson_layer_default = GeoJsonLayer; - -// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tile-2d-header.js -var Tile2DHeader = class { - constructor(index2) { - this.index = index2; - this.isVisible = false; - this.isSelected = false; - this.parent = null; - this.children = []; - this.content = null; - this._loader = void 0; - this._abortController = null; - this._loaderId = 0; - this._isLoaded = false; - this._isCancelled = false; - this._needsReload = false; - } - /** @deprecated use `boundingBox` instead */ - get bbox() { - return this._bbox; - } - // TODO - remove in v9 - set bbox(value) { - if (this._bbox) - return; - this._bbox = value; - if ("west" in value) { - this.boundingBox = [ - [value.west, value.south], - [value.east, value.north] - ]; - } else { - this.boundingBox = [ - [value.left, value.top], - [value.right, value.bottom] - ]; - } - } - get data() { - return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content; - } - get isLoaded() { - return this._isLoaded && !this._needsReload; - } - get isLoading() { - return Boolean(this._loader) && !this._isCancelled; - } - get needsReload() { - return this._needsReload || this._isCancelled; - } - get byteLength() { - const result = this.content ? this.content.byteLength : 0; - if (!Number.isFinite(result)) { - console.error("byteLength not defined in tile data"); - } - return result; - } - /* eslint-disable max-statements */ - async _loadData({ getData, requestScheduler, onLoad, onError }) { - const { index: index2, id, bbox, userData, zoom } = this; - const loaderId = this._loaderId; - this._abortController = new AbortController(); - const { signal } = this._abortController; - const requestToken = await requestScheduler.scheduleRequest(this, (tile) => { - return tile.isSelected ? 1 : -1; - }); - if (!requestToken) { - this._isCancelled = true; - return; - } - if (this._isCancelled) { - requestToken.done(); - return; - } - let tileData = null; - let error; - try { - tileData = await getData({ index: index2, id, bbox, userData, zoom, signal }); - } catch (err) { - error = err || true; - } finally { - requestToken.done(); - } - if (loaderId !== this._loaderId) { - return; - } - this._loader = void 0; - this.content = tileData; - if (this._isCancelled && !tileData) { - this._isLoaded = false; - return; - } - this._isLoaded = true; - this._isCancelled = false; - if (error) { - onError(error, this); - } else { - onLoad(this); - } - } - loadData(opts) { - this._isLoaded = false; - this._isCancelled = false; - this._needsReload = false; - this._loaderId++; - this._loader = this._loadData(opts); - return this._loader; - } - setNeedsReload() { - if (this.isLoading) { - this.abort(); - this._loader = void 0; - } - this._needsReload = true; - } - abort() { - if (this.isLoaded) { - return; - } - this._isCancelled = true; - this._abortController?.abort(); - } -}; - -// node_modules/@math.gl/culling/dist/constants.js -var INTERSECTION = { - OUTSIDE: -1, - // Represents that an object is not contained within the frustum. - INTERSECTING: 0, - // Represents that an object intersects one of the frustum's planes. - INSIDE: 1 - // Represents that an object is fully within the frustum. -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/common.js -var RADIANS_TO_DEGREES4 = 1 / Math.PI * 180; -var DEGREES_TO_RADIANS6 = 1 / 180 * Math.PI; -var DEFAULT_CONFIG2 = { - EPSILON: 1e-12, - debug: false, - precision: 4, - printTypes: false, - printDegrees: false, - printRowMajor: true, - _cartographicRadians: false -}; -globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG2 } }; -var config2 = globalThis.mathgl.config; -function formatValue2(value, { precision = config2.precision } = {}) { - value = round10(value); - return `${parseFloat(value.toPrecision(precision))}`; -} -function isArray4(value) { - return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); -} -function equals10(a, b, epsilon) { - const oldEpsilon = config2.EPSILON; - if (epsilon) { - config2.EPSILON = epsilon; - } - try { - if (a === b) { - return true; - } - if (isArray4(a) && isArray4(b)) { - if (a.length !== b.length) { - return false; - } - for (let i = 0; i < a.length; ++i) { - if (!equals10(a[i], b[i])) { - return false; - } - } - return true; - } - if (a && a.equals) { - return a.equals(b); - } - if (b && b.equals) { - return b.equals(a); - } - if (typeof a === "number" && typeof b === "number") { - return Math.abs(a - b) <= config2.EPSILON * Math.max(1, Math.abs(a), Math.abs(b)); - } - return false; - } finally { - config2.EPSILON = oldEpsilon; - } -} -function round10(value) { - return Math.round(value / config2.EPSILON) * config2.EPSILON; -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/math-array.js -var MathArray2 = class extends Array { - // Common methods - /** - * Clone the current object - * @returns a new copy of this object - */ - clone() { - return new this.constructor().copy(this); - } - fromArray(array, offset = 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = array[i + offset]; - } - return this.check(); - } - toArray(targetArray = [], offset = 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - targetArray[offset + i] = this[i]; - } - return targetArray; - } - toObject(targetObject) { - return targetObject; - } - from(arrayOrObject) { - return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : ( - // @ts-ignore - this.fromObject(arrayOrObject) - ); - } - to(arrayOrObject) { - if (arrayOrObject === this) { - return this; - } - return isArray4(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); - } - toTarget(target) { - return target ? this.to(target) : this; - } - /** @deprecated */ - toFloat32Array() { - return new Float32Array(this); - } - toString() { - return this.formatString(config2); - } - /** Formats string according to options */ - formatString(opts) { - let string = ""; - for (let i = 0; i < this.ELEMENTS; ++i) { - string += (i > 0 ? ", " : "") + formatValue2(this[i], opts); - } - return `${opts.printTypes ? this.constructor.name : ""}[${string}]`; - } - equals(array) { - if (!array || this.length !== array.length) { - return false; - } - for (let i = 0; i < this.ELEMENTS; ++i) { - if (!equals10(this[i], array[i])) { - return false; - } - } - return true; - } - exactEquals(array) { - if (!array || this.length !== array.length) { - return false; - } - for (let i = 0; i < this.ELEMENTS; ++i) { - if (this[i] !== array[i]) { - return false; - } - } - return true; - } - // Modifiers - /** Negates all values in this object */ - negate() { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = -this[i]; - } - return this.check(); - } - lerp(a, b, t) { - if (t === void 0) { - return this.lerp(this, a, b); - } - for (let i = 0; i < this.ELEMENTS; ++i) { - const ai = a[i]; - const endValue = typeof b === "number" ? b : b[i]; - this[i] = ai + t * (endValue - ai); - } - return this.check(); - } - /** Minimal */ - min(vector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(vector[i], this[i]); - } - return this.check(); - } - /** Maximal */ - max(vector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.max(vector[i], this[i]); - } - return this.check(); - } - clamp(minVector, maxVector) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]); - } - return this.check(); - } - add(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] += vector[i]; - } - } - return this.check(); - } - subtract(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] -= vector[i]; - } - } - return this.check(); - } - scale(scale13) { - if (typeof scale13 === "number") { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scale13; - } - } else { - for (let i = 0; i < this.ELEMENTS && i < scale13.length; ++i) { - this[i] *= scale13[i]; - } - } - return this.check(); - } - /** - * Multiplies all elements by `scale` - * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor" - */ - multiplyByScalar(scalar) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scalar; - } - return this.check(); - } - // Debug checks - /** Throws an error if array length is incorrect or contains illegal values */ - check() { - if (config2.debug && !this.validate()) { - throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`); - } - return this; - } - /** Returns false if the array length is incorrect or contains illegal values */ - validate() { - let valid = this.length === this.ELEMENTS; - for (let i = 0; i < this.ELEMENTS; ++i) { - valid = valid && Number.isFinite(this[i]); - } - return valid; - } - // three.js compatibility - /** @deprecated */ - sub(a) { - return this.subtract(a); - } - /** @deprecated */ - setScalar(a) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = a; - } - return this.check(); - } - /** @deprecated */ - addScalar(a) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] += a; - } - return this.check(); - } - /** @deprecated */ - subScalar(a) { - return this.addScalar(-a); - } - /** @deprecated */ - multiplyScalar(scalar) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= scalar; - } - return this.check(); - } - /** @deprecated */ - divideScalar(a) { - return this.multiplyByScalar(1 / a); - } - /** @deprecated */ - clampScalar(min7, max7) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] = Math.min(Math.max(this[i], min7), max7); - } - return this.check(); - } - /** @deprecated */ - get elements() { - return this; - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/validators.js -function validateVector2(v, length10) { - if (v.length !== length10) { - return false; - } - for (let i = 0; i < v.length; ++i) { - if (!Number.isFinite(v[i])) { - return false; - } - } - return true; -} -function checkNumber2(value) { - if (!Number.isFinite(value)) { - throw new Error(`Invalid number ${JSON.stringify(value)}`); - } - return value; -} -function checkVector2(v, length10, callerName = "") { - if (config2.debug && !validateVector2(v, length10)) { - throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`); - } - return v; -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/assert.js -function assert10(condition, message2) { - if (!condition) { - throw new Error(`math.gl assertion ${message2}`); - } -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/vector.js -var Vector2 = class extends MathArray2 { - // ACCESSORS - get x() { - return this[0]; - } - set x(value) { - this[0] = checkNumber2(value); - } - get y() { - return this[1]; - } - set y(value) { - this[1] = checkNumber2(value); - } - /** - * Returns the length of the vector from the origin to the point described by this vector - * - * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements - * Instead we provide `len` and `magnitude` - */ - len() { - return Math.sqrt(this.lengthSquared()); - } - /** - * Returns the length of the vector from the origin to the point described by this vector - */ - magnitude() { - return this.len(); - } - /** - * Returns the squared length of the vector from the origin to the point described by this vector - */ - lengthSquared() { - let length10 = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - length10 += this[i] * this[i]; - } - return length10; - } - /** - * Returns the squared length of the vector from the origin to the point described by this vector - */ - magnitudeSquared() { - return this.lengthSquared(); - } - distance(mathArray) { - return Math.sqrt(this.distanceSquared(mathArray)); - } - distanceSquared(mathArray) { - let length10 = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - const dist7 = this[i] - mathArray[i]; - length10 += dist7 * dist7; - } - return checkNumber2(length10); - } - dot(mathArray) { - let product = 0; - for (let i = 0; i < this.ELEMENTS; ++i) { - product += this[i] * mathArray[i]; - } - return checkNumber2(product); - } - // MODIFIERS - normalize() { - const length10 = this.magnitude(); - if (length10 !== 0) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] /= length10; - } - } - return this.check(); - } - multiply(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] *= vector[i]; - } - } - return this.check(); - } - divide(...vectors) { - for (const vector of vectors) { - for (let i = 0; i < this.ELEMENTS; ++i) { - this[i] /= vector[i]; - } - } - return this.check(); - } - // THREE.js compatibility - lengthSq() { - return this.lengthSquared(); - } - distanceTo(vector) { - return this.distance(vector); - } - distanceToSquared(vector) { - return this.distanceSquared(vector); - } - getComponent(i) { - assert10(i >= 0 && i < this.ELEMENTS, "index is out of range"); - return checkNumber2(this[i]); - } - setComponent(i, value) { - assert10(i >= 0 && i < this.ELEMENTS, "index is out of range"); - this[i] = value; - return this.check(); - } - addVectors(a, b) { - return this.copy(a).add(b); - } - subVectors(a, b) { - return this.copy(a).subtract(b); - } - multiplyVectors(a, b) { - return this.copy(a).multiply(b); - } - addScaledVector(a, b) { - return this.add(new this.constructor(a).multiplyScalar(b)); - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/common.js -var EPSILON4 = 1e-6; -var ARRAY_TYPE3 = typeof Float32Array !== "undefined" ? Float32Array : Array; -var degree3 = Math.PI / 180; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec2.js -function create9() { - const out = new ARRAY_TYPE3(2); - if (ARRAY_TYPE3 != Float32Array) { - out[0] = 0; - out[1] = 0; - } - return out; -} -function transformMat35(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[3] * y + m[6]; - out[1] = m[1] * x + m[4] * y + m[7]; - return out; -} -var forEach8 = function() { - const vec = create9(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 2; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - } - return a; - }; -}(); - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js -function vec3_transformMat4AsVector2(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = m[3] * x + m[7] * y + m[11] * z || 1; - out[0] = (m[0] * x + m[4] * y + m[8] * z) / w; - out[1] = (m[1] * x + m[5] * y + m[9] * z) / w; - out[2] = (m[2] * x + m[6] * y + m[10] * z) / w; - return out; -} -function vec3_transformMat22(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y; - out[1] = m[1] * x + m[3] * y; - out[2] = a[2]; - return out; -} -function vec4_transformMat2(out, a, m) { - const x = a[0]; - const y = a[1]; - out[0] = m[0] * x + m[2] * y; - out[1] = m[1] * x + m[3] * y; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -function vec4_transformMat3(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - out[0] = m[0] * x + m[3] * y + m[6] * z; - out[1] = m[1] * x + m[4] * y + m[7] * z; - out[2] = m[2] * x + m[5] * y + m[8] * z; - out[3] = a[3]; - return out; -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec3.js -function create10() { - const out = new ARRAY_TYPE3(3); - if (ARRAY_TYPE3 != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - } - return out; -} -function length7(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - return Math.sqrt(x * x + y * y + z * z); -} -function fromValues9(x, y, z) { - const out = new ARRAY_TYPE3(3); - out[0] = x; - out[1] = y; - out[2] = z; - return out; -} -function normalize8(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let len8 = x * x + y * y + z * z; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = a[0] * len8; - out[1] = a[1] * len8; - out[2] = a[2] * len8; - return out; -} -function dot7(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; -} -function cross7(out, a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - out[0] = ay * bz - az * by; - out[1] = az * bx - ax * bz; - out[2] = ax * by - ay * bx; - return out; -} -function transformMat47(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - let w = m[3] * x + m[7] * y + m[11] * z + m[15]; - w = w || 1; - out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; - out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; - out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; - return out; -} -function transformMat36(out, a, m) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - out[0] = x * m[0] + y * m[3] + z * m[6]; - out[1] = x * m[1] + y * m[4] + z * m[7]; - out[2] = x * m[2] + y * m[5] + z * m[8]; - return out; -} -function transformQuat5(out, a, q) { - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const x = a[0]; - const y = a[1]; - const z = a[2]; - let uvx = qy * z - qz * y; - let uvy = qz * x - qx * z; - let uvz = qx * y - qy * x; - let uuvx = qy * uvz - qz * uvy; - let uuvy = qz * uvx - qx * uvz; - let uuvz = qx * uvy - qy * uvx; - const w2 = qw * 2; - uvx *= w2; - uvy *= w2; - uvz *= w2; - uuvx *= 2; - uuvy *= 2; - uuvz *= 2; - out[0] = x + uvx + uuvx; - out[1] = y + uvy + uuvy; - out[2] = z + uvz + uuvz; - return out; -} -function rotateX5(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0]; - r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad); - r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateY5(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad); - r[1] = p[1]; - r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function rotateZ5(out, a, b, rad) { - const p = []; - const r = []; - p[0] = a[0] - b[0]; - p[1] = a[1] - b[1]; - p[2] = a[2] - b[2]; - r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad); - r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad); - r[2] = p[2]; - out[0] = r[0] + b[0]; - out[1] = r[1] + b[1]; - out[2] = r[2] + b[2]; - return out; -} -function angle5(a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)); - const cosine = mag && dot7(a, b) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); -} -var len7 = length7; -var forEach9 = function() { - const vec = create10(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 3; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - } - return a; - }; -}(); - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/vector3.js -var ORIGIN2 = [0, 0, 0]; -var ZERO3; -var Vector32 = class _Vector3 extends Vector2 { - static get ZERO() { - if (!ZERO3) { - ZERO3 = new _Vector3(0, 0, 0); - Object.freeze(ZERO3); - } - return ZERO3; - } - /** - * @class - * @param x - * @param y - * @param z - */ - constructor(x = 0, y = 0, z = 0) { - super(-0, -0, -0); - if (arguments.length === 1 && isArray4(x)) { - this.copy(x); - } else { - if (config2.debug) { - checkNumber2(x); - checkNumber2(y); - checkNumber2(z); - } - this[0] = x; - this[1] = y; - this[2] = z; - } - } - set(x, y, z) { - this[0] = x; - this[1] = y; - this[2] = z; - return this.check(); - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - return this.check(); - } - fromObject(object) { - if (config2.debug) { - checkNumber2(object.x); - checkNumber2(object.y); - checkNumber2(object.z); - } - this[0] = object.x; - this[1] = object.y; - this[2] = object.z; - return this.check(); - } - toObject(object) { - object.x = this[0]; - object.y = this[1]; - object.z = this[2]; - return object; - } - // Getters/setters - get ELEMENTS() { - return 3; - } - get z() { - return this[2]; - } - set z(value) { - this[2] = checkNumber2(value); - } - // ACCESSORS - angle(vector) { - return angle5(this, vector); - } - // MODIFIERS - cross(vector) { - cross7(this, this, vector); - return this.check(); - } - rotateX({ radians: radians3, origin = ORIGIN2 }) { - rotateX5(this, this, origin, radians3); - return this.check(); - } - rotateY({ radians: radians3, origin = ORIGIN2 }) { - rotateY5(this, this, origin, radians3); - return this.check(); - } - rotateZ({ radians: radians3, origin = ORIGIN2 }) { - rotateZ5(this, this, origin, radians3); - return this.check(); - } - // Transforms - // transforms as point (4th component is implicitly 1) - transform(matrix4) { - return this.transformAsPoint(matrix4); - } - // transforms as point (4th component is implicitly 1) - transformAsPoint(matrix4) { - transformMat47(this, this, matrix4); - return this.check(); - } - // transforms as vector (4th component is implicitly 0, ignores translation. slightly faster) - transformAsVector(matrix4) { - vec3_transformMat4AsVector2(this, this, matrix4); - return this.check(); - } - transformByMatrix3(matrix3) { - transformMat36(this, this, matrix3); - return this.check(); - } - transformByMatrix2(matrix2) { - vec3_transformMat22(this, this, matrix2); - return this.check(); - } - transformByQuaternion(quaternion) { - transformQuat5(this, this, quaternion); - return this.check(); - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/vector4.js -var ZERO4; -var Vector4 = class _Vector4 extends Vector2 { - static get ZERO() { - if (!ZERO4) { - ZERO4 = new _Vector4(0, 0, 0, 0); - Object.freeze(ZERO4); - } - return ZERO4; - } - constructor(x = 0, y = 0, z = 0, w = 0) { - super(-0, -0, -0, -0); - if (isArray4(x) && arguments.length === 1) { - this.copy(x); - } else { - if (config2.debug) { - checkNumber2(x); - checkNumber2(y); - checkNumber2(z); - checkNumber2(w); - } - this[0] = x; - this[1] = y; - this[2] = z; - this[3] = w; - } - } - set(x, y, z, w) { - this[0] = x; - this[1] = y; - this[2] = z; - this[3] = w; - return this.check(); - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - this[3] = array[3]; - return this.check(); - } - fromObject(object) { - if (config2.debug) { - checkNumber2(object.x); - checkNumber2(object.y); - checkNumber2(object.z); - checkNumber2(object.w); - } - this[0] = object.x; - this[1] = object.y; - this[2] = object.z; - this[3] = object.w; - return this; - } - toObject(object) { - object.x = this[0]; - object.y = this[1]; - object.z = this[2]; - object.w = this[3]; - return object; - } - // Getters/setters - /* eslint-disable no-multi-spaces, brace-style, no-return-assign */ - get ELEMENTS() { - return 4; - } - get z() { - return this[2]; - } - set z(value) { - this[2] = checkNumber2(value); - } - get w() { - return this[3]; - } - set w(value) { - this[3] = checkNumber2(value); - } - transform(matrix4) { - transformMat47(this, this, matrix4); - return this.check(); - } - transformByMatrix3(matrix3) { - vec4_transformMat3(this, this, matrix3); - return this.check(); - } - transformByMatrix2(matrix2) { - vec4_transformMat2(this, this, matrix2); - return this.check(); - } - transformByQuaternion(quaternion) { - transformQuat5(this, this, quaternion); - return this.check(); - } - // three.js compatibility - applyMatrix4(m) { - m.transform(this, this); - return this; - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/base/matrix.js -var Matrix2 = class extends MathArray2 { - // fromObject(object) { - // const array = object.elements; - // return this.fromRowMajor(array); - // } - // toObject(object) { - // const array = object.elements; - // this.toRowMajor(array); - // return object; - // } - // TODO better override formatString? - toString() { - let string = "["; - if (config2.printRowMajor) { - string += "row-major:"; - for (let row = 0; row < this.RANK; ++row) { - for (let col = 0; col < this.RANK; ++col) { - string += ` ${this[col * this.RANK + row]}`; - } - } - } else { - string += "column-major:"; - for (let i = 0; i < this.ELEMENTS; ++i) { - string += ` ${this[i]}`; - } - } - string += "]"; - return string; - } - getElementIndex(row, col) { - return col * this.RANK + row; - } - // By default assumes row major indices - getElement(row, col) { - return this[col * this.RANK + row]; - } - // By default assumes row major indices - setElement(row, col, value) { - this[col * this.RANK + row] = checkNumber2(value); - return this; - } - getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { - const firstIndex = columnIndex * this.RANK; - for (let i = 0; i < this.RANK; ++i) { - result[i] = this[firstIndex + i]; - } - return result; - } - setColumn(columnIndex, columnVector) { - const firstIndex = columnIndex * this.RANK; - for (let i = 0; i < this.RANK; ++i) { - this[firstIndex + i] = columnVector[i]; - } - return this; - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/mat3.js -function create11() { - const out = new ARRAY_TYPE3(9); - if (ARRAY_TYPE3 != Float32Array) { - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[5] = 0; - out[6] = 0; - out[7] = 0; - } - out[0] = 1; - out[4] = 1; - out[8] = 1; - return out; -} -function transpose3(out, a) { - if (out === a) { - const a01 = a[1]; - const a02 = a[2]; - const a12 = a[5]; - out[1] = a[3]; - out[2] = a[6]; - out[3] = a01; - out[5] = a[7]; - out[6] = a02; - out[7] = a12; - } else { - out[0] = a[0]; - out[1] = a[3]; - out[2] = a[6]; - out[3] = a[1]; - out[4] = a[4]; - out[5] = a[7]; - out[6] = a[2]; - out[7] = a[5]; - out[8] = a[8]; - } - return out; -} -function invert3(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a10 = a[3]; - const a11 = a[4]; - const a12 = a[5]; - const a20 = a[6]; - const a21 = a[7]; - const a22 = a[8]; - const b01 = a22 * a11 - a12 * a21; - const b11 = -a22 * a10 + a12 * a20; - const b21 = a21 * a10 - a11 * a20; - let det = a00 * b01 + a01 * b11 + a02 * b21; - if (!det) { - return null; - } - det = 1 / det; - out[0] = b01 * det; - out[1] = (-a22 * a01 + a02 * a21) * det; - out[2] = (a12 * a01 - a02 * a11) * det; - out[3] = b11 * det; - out[4] = (a22 * a00 - a02 * a20) * det; - out[5] = (-a12 * a00 + a02 * a10) * det; - out[6] = b21 * det; - out[7] = (-a21 * a00 + a01 * a20) * det; - out[8] = (a11 * a00 - a01 * a10) * det; - return out; -} -function determinant3(a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a10 = a[3]; - const a11 = a[4]; - const a12 = a[5]; - const a20 = a[6]; - const a21 = a[7]; - const a22 = a[8]; - return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20); -} -function multiply9(out, a, b) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a10 = a[3]; - const a11 = a[4]; - const a12 = a[5]; - const a20 = a[6]; - const a21 = a[7]; - const a22 = a[8]; - const b00 = b[0]; - const b01 = b[1]; - const b02 = b[2]; - const b10 = b[3]; - const b11 = b[4]; - const b12 = b[5]; - const b20 = b[6]; - const b21 = b[7]; - const b22 = b[8]; - out[0] = b00 * a00 + b01 * a10 + b02 * a20; - out[1] = b00 * a01 + b01 * a11 + b02 * a21; - out[2] = b00 * a02 + b01 * a12 + b02 * a22; - out[3] = b10 * a00 + b11 * a10 + b12 * a20; - out[4] = b10 * a01 + b11 * a11 + b12 * a21; - out[5] = b10 * a02 + b11 * a12 + b12 * a22; - out[6] = b20 * a00 + b21 * a10 + b22 * a20; - out[7] = b20 * a01 + b21 * a11 + b22 * a21; - out[8] = b20 * a02 + b21 * a12 + b22 * a22; - return out; -} -function translate3(out, a, v) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a10 = a[3]; - const a11 = a[4]; - const a12 = a[5]; - const a20 = a[6]; - const a21 = a[7]; - const a22 = a[8]; - const x = v[0]; - const y = v[1]; - out[0] = a00; - out[1] = a01; - out[2] = a02; - out[3] = a10; - out[4] = a11; - out[5] = a12; - out[6] = x * a00 + y * a10 + a20; - out[7] = x * a01 + y * a11 + a21; - out[8] = x * a02 + y * a12 + a22; - return out; -} -function rotate5(out, a, rad) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a10 = a[3]; - const a11 = a[4]; - const a12 = a[5]; - const a20 = a[6]; - const a21 = a[7]; - const a22 = a[8]; - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c * a00 + s * a10; - out[1] = c * a01 + s * a11; - out[2] = c * a02 + s * a12; - out[3] = c * a10 - s * a00; - out[4] = c * a11 - s * a01; - out[5] = c * a12 - s * a02; - out[6] = a20; - out[7] = a21; - out[8] = a22; - return out; -} -function scale9(out, a, v) { - const x = v[0]; - const y = v[1]; - out[0] = x * a[0]; - out[1] = x * a[1]; - out[2] = x * a[2]; - out[3] = y * a[3]; - out[4] = y * a[4]; - out[5] = y * a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - return out; -} -function fromQuat4(out, q) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const yx = y * x2; - const yy = y * y2; - const zx = z * x2; - const zy = z * y2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - yy - zz; - out[3] = yx - wz; - out[6] = zx + wy; - out[1] = yx + wz; - out[4] = 1 - xx - zz; - out[7] = zy - wx; - out[2] = zx - wy; - out[5] = zy + wx; - out[8] = 1 - xx - yy; - return out; -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/matrix3.js -var INDICES2; -(function(INDICES3) { - INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; - INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; - INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; - INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0"; - INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1"; - INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2"; - INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0"; - INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1"; - INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2"; -})(INDICES2 || (INDICES2 = {})); -var IDENTITY_MATRIX3 = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]); -var Matrix3 = class extends Matrix2 { - static get IDENTITY() { - return getIdentityMatrix2(); - } - static get ZERO() { - return getZeroMatrix2(); - } - get ELEMENTS() { - return 9; - } - get RANK() { - return 3; - } - get INDICES() { - return INDICES2; - } - constructor(array, ...args) { - super(-0, -0, -0, -0, -0, -0, -0, -0, -0); - if (arguments.length === 1 && Array.isArray(array)) { - this.copy(array); - } else if (args.length > 0) { - this.copy([array, ...args]); - } else { - this.identity(); - } - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - this[3] = array[3]; - this[4] = array[4]; - this[5] = array[5]; - this[6] = array[6]; - this[7] = array[7]; - this[8] = array[8]; - return this.check(); - } - // Constructors - identity() { - return this.copy(IDENTITY_MATRIX3); - } - /** - * - * @param object - * @returns self - */ - // eslint-disable-next-line @typescript-eslint/no-unused-vars - fromObject(object) { - return this.check(); - } - /** Calculates a 3x3 matrix from the given quaternion - * q quat Quaternion to create matrix from - */ - fromQuaternion(q) { - fromQuat4(this, q); - return this.check(); - } - /** - * accepts column major order, stores in column major order - */ - // eslint-disable-next-line max-params - set(m00, m10, m20, m01, m11, m21, m02, m12, m22) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m01; - this[4] = m11; - this[5] = m21; - this[6] = m02; - this[7] = m12; - this[8] = m22; - return this.check(); - } - /** - * accepts row major order, stores as column major - */ - // eslint-disable-next-line max-params - setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m01; - this[4] = m11; - this[5] = m21; - this[6] = m02; - this[7] = m12; - this[8] = m22; - return this.check(); - } - // Accessors - determinant() { - return determinant3(this); - } - // Modifiers - transpose() { - transpose3(this, this); - return this.check(); - } - /** Invert a matrix. Note that this can fail if the matrix is not invertible */ - invert() { - invert3(this, this); - return this.check(); - } - // Operations - multiplyLeft(a) { - multiply9(this, a, this); - return this.check(); - } - multiplyRight(a) { - multiply9(this, this, a); - return this.check(); - } - rotate(radians3) { - rotate5(this, this, radians3); - return this.check(); - } - scale(factor) { - if (Array.isArray(factor)) { - scale9(this, this, factor); - } else { - scale9(this, this, [factor, factor]); - } - return this.check(); - } - translate(vec) { - translate3(this, this, vec); - return this.check(); - } - // Transforms - transform(vector, result) { - let out; - switch (vector.length) { - case 2: - out = transformMat35(result || [-0, -0], vector, this); - break; - case 3: - out = transformMat36(result || [-0, -0, -0], vector, this); - break; - case 4: - out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this); - break; - default: - throw new Error("Illegal vector"); - } - checkVector2(out, vector.length); - return out; - } - /** @deprecated */ - transformVector(vector, result) { - return this.transform(vector, result); - } - /** @deprecated */ - transformVector2(vector, result) { - return this.transform(vector, result); - } - /** @deprecated */ - transformVector3(vector, result) { - return this.transform(vector, result); - } -}; -var ZERO_MATRIX3; -var IDENTITY_MATRIX32 = null; -function getZeroMatrix2() { - if (!ZERO_MATRIX3) { - ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); - Object.freeze(ZERO_MATRIX3); - } - return ZERO_MATRIX3; -} -function getIdentityMatrix2() { - if (!IDENTITY_MATRIX32) { - IDENTITY_MATRIX32 = new Matrix3(); - Object.freeze(IDENTITY_MATRIX32); - } - return IDENTITY_MATRIX32; -} - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/mat4.js -var mat4_exports3 = {}; -__export(mat4_exports3, { - add: () => add10, - adjoint: () => adjoint3, - clone: () => clone10, - copy: () => copy10, - create: () => create12, - decompose: () => decompose3, - determinant: () => determinant4, - equals: () => equals11, - exactEquals: () => exactEquals10, - frob: () => frob3, - fromQuat: () => fromQuat5, - fromQuat2: () => fromQuat23, - fromRotation: () => fromRotation3, - fromRotationTranslation: () => fromRotationTranslation3, - fromRotationTranslationScale: () => fromRotationTranslationScale3, - fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin3, - fromScaling: () => fromScaling3, - fromTranslation: () => fromTranslation3, - fromValues: () => fromValues10, - fromXRotation: () => fromXRotation3, - fromYRotation: () => fromYRotation3, - fromZRotation: () => fromZRotation3, - frustum: () => frustum3, - getRotation: () => getRotation3, - getScaling: () => getScaling3, - getTranslation: () => getTranslation3, - identity: () => identity3, - invert: () => invert4, - lookAt: () => lookAt3, - mul: () => mul9, - multiply: () => multiply10, - multiplyScalar: () => multiplyScalar3, - multiplyScalarAndAdd: () => multiplyScalarAndAdd3, - ortho: () => ortho3, - orthoNO: () => orthoNO3, - orthoZO: () => orthoZO3, - perspective: () => perspective3, - perspectiveFromFieldOfView: () => perspectiveFromFieldOfView3, - perspectiveNO: () => perspectiveNO3, - perspectiveZO: () => perspectiveZO3, - rotate: () => rotate6, - rotateX: () => rotateX6, - rotateY: () => rotateY6, - rotateZ: () => rotateZ6, - scale: () => scale10, - set: () => set9, - str: () => str9, - sub: () => sub9, - subtract: () => subtract9, - targetTo: () => targetTo3, - translate: () => translate4, - transpose: () => transpose4 -}); -function create12() { - const out = new ARRAY_TYPE3(16); - if (ARRAY_TYPE3 != Float32Array) { - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - } - out[0] = 1; - out[5] = 1; - out[10] = 1; - out[15] = 1; - return out; -} -function clone10(a) { - const out = new ARRAY_TYPE3(16); - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function copy10(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function fromValues10(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - const out = new ARRAY_TYPE3(16); - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function set9(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - out[0] = m00; - out[1] = m01; - out[2] = m02; - out[3] = m03; - out[4] = m10; - out[5] = m11; - out[6] = m12; - out[7] = m13; - out[8] = m20; - out[9] = m21; - out[10] = m22; - out[11] = m23; - out[12] = m30; - out[13] = m31; - out[14] = m32; - out[15] = m33; - return out; -} -function identity3(out) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function transpose4(out, a) { - if (out === a) { - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a12 = a[6]; - const a13 = a[7]; - const a23 = a[11]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a01; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a02; - out[9] = a12; - out[11] = a[14]; - out[12] = a03; - out[13] = a13; - out[14] = a23; - } else { - out[0] = a[0]; - out[1] = a[4]; - out[2] = a[8]; - out[3] = a[12]; - out[4] = a[1]; - out[5] = a[5]; - out[6] = a[9]; - out[7] = a[13]; - out[8] = a[2]; - out[9] = a[6]; - out[10] = a[10]; - out[11] = a[14]; - out[12] = a[3]; - out[13] = a[7]; - out[14] = a[11]; - out[15] = a[15]; - } - return out; -} -function invert4(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; - if (!det) { - return null; - } - det = 1 / det; - out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; - out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; - out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; - out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; - out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; - out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; - out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; - out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; - out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; - out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; - out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; - out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; - out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; - out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; - out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; - out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; - return out; -} -function adjoint3(out, a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b00 = a00 * a11 - a01 * a10; - const b01 = a00 * a12 - a02 * a10; - const b02 = a00 * a13 - a03 * a10; - const b03 = a01 * a12 - a02 * a11; - const b04 = a01 * a13 - a03 * a11; - const b05 = a02 * a13 - a03 * a12; - const b06 = a20 * a31 - a21 * a30; - const b07 = a20 * a32 - a22 * a30; - const b08 = a20 * a33 - a23 * a30; - const b09 = a21 * a32 - a22 * a31; - const b10 = a21 * a33 - a23 * a31; - const b11 = a22 * a33 - a23 * a32; - out[0] = a11 * b11 - a12 * b10 + a13 * b09; - out[1] = a02 * b10 - a01 * b11 - a03 * b09; - out[2] = a31 * b05 - a32 * b04 + a33 * b03; - out[3] = a22 * b04 - a21 * b05 - a23 * b03; - out[4] = a12 * b08 - a10 * b11 - a13 * b07; - out[5] = a00 * b11 - a02 * b08 + a03 * b07; - out[6] = a32 * b02 - a30 * b05 - a33 * b01; - out[7] = a20 * b05 - a22 * b02 + a23 * b01; - out[8] = a10 * b10 - a11 * b08 + a13 * b06; - out[9] = a01 * b08 - a00 * b10 - a03 * b06; - out[10] = a30 * b04 - a31 * b02 + a33 * b00; - out[11] = a21 * b02 - a20 * b04 - a23 * b00; - out[12] = a11 * b07 - a10 * b09 - a12 * b06; - out[13] = a00 * b09 - a01 * b07 + a02 * b06; - out[14] = a31 * b01 - a30 * b03 - a32 * b00; - out[15] = a20 * b03 - a21 * b01 + a22 * b00; - return out; -} -function determinant4(a) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - const b0 = a00 * a11 - a01 * a10; - const b1 = a00 * a12 - a02 * a10; - const b2 = a01 * a12 - a02 * a11; - const b3 = a20 * a31 - a21 * a30; - const b4 = a20 * a32 - a22 * a30; - const b5 = a21 * a32 - a22 * a31; - const b6 = a00 * b5 - a01 * b4 + a02 * b3; - const b7 = a10 * b5 - a11 * b4 + a12 * b3; - const b8 = a20 * b2 - a21 * b1 + a22 * b0; - const b9 = a30 * b2 - a31 * b1 + a32 * b0; - return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9; -} -function multiply10(out, a, b) { - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - const a30 = a[12]; - const a31 = a[13]; - const a32 = a[14]; - const a33 = a[15]; - let b0 = b[0]; - let b1 = b[1]; - let b2 = b[2]; - let b3 = b[3]; - out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[4]; - b1 = b[5]; - b2 = b[6]; - b3 = b[7]; - out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[8]; - b1 = b[9]; - b2 = b[10]; - b3 = b[11]; - out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - b0 = b[12]; - b1 = b[13]; - b2 = b[14]; - b3 = b[15]; - out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; - out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; - out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; - out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; - return out; -} -function translate4(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - if (a === out) { - out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; - out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; - out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; - out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; - } else { - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - out[0] = a00; - out[1] = a01; - out[2] = a02; - out[3] = a03; - out[4] = a10; - out[5] = a11; - out[6] = a12; - out[7] = a13; - out[8] = a20; - out[9] = a21; - out[10] = a22; - out[11] = a23; - out[12] = a00 * x + a10 * y + a20 * z + a[12]; - out[13] = a01 * x + a11 * y + a21 * z + a[13]; - out[14] = a02 * x + a12 * y + a22 * z + a[14]; - out[15] = a03 * x + a13 * y + a23 * z + a[15]; - } - return out; -} -function scale10(out, a, v) { - const x = v[0]; - const y = v[1]; - const z = v[2]; - out[0] = a[0] * x; - out[1] = a[1] * x; - out[2] = a[2] * x; - out[3] = a[3] * x; - out[4] = a[4] * y; - out[5] = a[5] * y; - out[6] = a[6] * y; - out[7] = a[7] * y; - out[8] = a[8] * z; - out[9] = a[9] * z; - out[10] = a[10] * z; - out[11] = a[11] * z; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - return out; -} -function rotate6(out, a, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - let a00; - let a01; - let a02; - let a03; - let a10; - let a11; - let a12; - let a13; - let a20; - let a21; - let a22; - let a23; - let b00; - let b01; - let b02; - let b10; - let b11; - let b12; - let b20; - let b21; - let b22; - if (len8 < EPSILON4) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - a00 = a[0]; - a01 = a[1]; - a02 = a[2]; - a03 = a[3]; - a10 = a[4]; - a11 = a[5]; - a12 = a[6]; - a13 = a[7]; - a20 = a[8]; - a21 = a[9]; - a22 = a[10]; - a23 = a[11]; - b00 = x * x * t + c; - b01 = y * x * t + z * s; - b02 = z * x * t - y * s; - b10 = x * y * t - z * s; - b11 = y * y * t + c; - b12 = z * y * t + x * s; - b20 = x * z * t + y * s; - b21 = y * z * t - x * s; - b22 = z * z * t + c; - out[0] = a00 * b00 + a10 * b01 + a20 * b02; - out[1] = a01 * b00 + a11 * b01 + a21 * b02; - out[2] = a02 * b00 + a12 * b01 + a22 * b02; - out[3] = a03 * b00 + a13 * b01 + a23 * b02; - out[4] = a00 * b10 + a10 * b11 + a20 * b12; - out[5] = a01 * b10 + a11 * b11 + a21 * b12; - out[6] = a02 * b10 + a12 * b11 + a22 * b12; - out[7] = a03 * b10 + a13 * b11 + a23 * b12; - out[8] = a00 * b20 + a10 * b21 + a20 * b22; - out[9] = a01 * b20 + a11 * b21 + a21 * b22; - out[10] = a02 * b20 + a12 * b21 + a22 * b22; - out[11] = a03 * b20 + a13 * b21 + a23 * b22; - if (a !== out) { - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - return out; -} -function rotateX6(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[4] = a10 * c + a20 * s; - out[5] = a11 * c + a21 * s; - out[6] = a12 * c + a22 * s; - out[7] = a13 * c + a23 * s; - out[8] = a20 * c - a10 * s; - out[9] = a21 * c - a11 * s; - out[10] = a22 * c - a12 * s; - out[11] = a23 * c - a13 * s; - return out; -} -function rotateY6(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a20 = a[8]; - const a21 = a[9]; - const a22 = a[10]; - const a23 = a[11]; - if (a !== out) { - out[4] = a[4]; - out[5] = a[5]; - out[6] = a[6]; - out[7] = a[7]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c - a20 * s; - out[1] = a01 * c - a21 * s; - out[2] = a02 * c - a22 * s; - out[3] = a03 * c - a23 * s; - out[8] = a00 * s + a20 * c; - out[9] = a01 * s + a21 * c; - out[10] = a02 * s + a22 * c; - out[11] = a03 * s + a23 * c; - return out; -} -function rotateZ6(out, a, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - const a00 = a[0]; - const a01 = a[1]; - const a02 = a[2]; - const a03 = a[3]; - const a10 = a[4]; - const a11 = a[5]; - const a12 = a[6]; - const a13 = a[7]; - if (a !== out) { - out[8] = a[8]; - out[9] = a[9]; - out[10] = a[10]; - out[11] = a[11]; - out[12] = a[12]; - out[13] = a[13]; - out[14] = a[14]; - out[15] = a[15]; - } - out[0] = a00 * c + a10 * s; - out[1] = a01 * c + a11 * s; - out[2] = a02 * c + a12 * s; - out[3] = a03 * c + a13 * s; - out[4] = a10 * c - a00 * s; - out[5] = a11 * c - a01 * s; - out[6] = a12 * c - a02 * s; - out[7] = a13 * c - a03 * s; - return out; -} -function fromTranslation3(out, v) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromScaling3(out, v) { - out[0] = v[0]; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = v[1]; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = v[2]; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotation3(out, rad, axis) { - let x = axis[0]; - let y = axis[1]; - let z = axis[2]; - let len8 = Math.sqrt(x * x + y * y + z * z); - let c; - let s; - let t; - if (len8 < EPSILON4) { - return null; - } - len8 = 1 / len8; - x *= len8; - y *= len8; - z *= len8; - s = Math.sin(rad); - c = Math.cos(rad); - t = 1 - c; - out[0] = x * x * t + c; - out[1] = y * x * t + z * s; - out[2] = z * x * t - y * s; - out[3] = 0; - out[4] = x * y * t - z * s; - out[5] = y * y * t + c; - out[6] = z * y * t + x * s; - out[7] = 0; - out[8] = x * z * t + y * s; - out[9] = y * z * t - x * s; - out[10] = z * z * t + c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromXRotation3(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = c; - out[6] = s; - out[7] = 0; - out[8] = 0; - out[9] = -s; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromYRotation3(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = 0; - out[2] = -s; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = s; - out[9] = 0; - out[10] = c; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromZRotation3(out, rad) { - const s = Math.sin(rad); - const c = Math.cos(rad); - out[0] = c; - out[1] = s; - out[2] = 0; - out[3] = 0; - out[4] = -s; - out[5] = c; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function fromRotationTranslation3(out, q, v) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - (yy + zz); - out[1] = xy + wz; - out[2] = xz - wy; - out[3] = 0; - out[4] = xy - wz; - out[5] = 1 - (xx + zz); - out[6] = yz + wx; - out[7] = 0; - out[8] = xz + wy; - out[9] = yz - wx; - out[10] = 1 - (xx + yy); - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromQuat23(out, a) { - const translation = new ARRAY_TYPE3(3); - const bx = -a[0]; - const by = -a[1]; - const bz = -a[2]; - const bw = a[3]; - const ax = a[4]; - const ay = a[5]; - const az = a[6]; - const aw = a[7]; - const magnitude = bx * bx + by * by + bz * bz + bw * bw; - if (magnitude > 0) { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; - } else { - translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; - translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; - translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; - } - fromRotationTranslation3(out, a, translation); - return out; -} -function getTranslation3(out, mat) { - out[0] = mat[12]; - out[1] = mat[13]; - out[2] = mat[14]; - return out; -} -function getScaling3(out, mat) { - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - return out; -} -function getRotation3(out, mat) { - const scaling = new ARRAY_TYPE3(3); - getScaling3(scaling, mat); - const is1 = 1 / scaling[0]; - const is2 = 1 / scaling[1]; - const is3 = 1 / scaling[2]; - const sm11 = mat[0] * is1; - const sm12 = mat[1] * is2; - const sm13 = mat[2] * is3; - const sm21 = mat[4] * is1; - const sm22 = mat[5] * is2; - const sm23 = mat[6] * is3; - const sm31 = mat[8] * is1; - const sm32 = mat[9] * is2; - const sm33 = mat[10] * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out[3] = 0.25 * S; - out[0] = (sm23 - sm32) / S; - out[1] = (sm31 - sm13) / S; - out[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out[3] = (sm23 - sm32) / S; - out[0] = 0.25 * S; - out[1] = (sm12 + sm21) / S; - out[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out[3] = (sm31 - sm13) / S; - out[0] = (sm12 + sm21) / S; - out[1] = 0.25 * S; - out[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out[3] = (sm12 - sm21) / S; - out[0] = (sm31 + sm13) / S; - out[1] = (sm23 + sm32) / S; - out[2] = 0.25 * S; - } - return out; -} -function decompose3(out_r, out_t, out_s, mat) { - out_t[0] = mat[12]; - out_t[1] = mat[13]; - out_t[2] = mat[14]; - const m11 = mat[0]; - const m12 = mat[1]; - const m13 = mat[2]; - const m21 = mat[4]; - const m22 = mat[5]; - const m23 = mat[6]; - const m31 = mat[8]; - const m32 = mat[9]; - const m33 = mat[10]; - out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); - out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); - out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); - const is1 = 1 / out_s[0]; - const is2 = 1 / out_s[1]; - const is3 = 1 / out_s[2]; - const sm11 = m11 * is1; - const sm12 = m12 * is2; - const sm13 = m13 * is3; - const sm21 = m21 * is1; - const sm22 = m22 * is2; - const sm23 = m23 * is3; - const sm31 = m31 * is1; - const sm32 = m32 * is2; - const sm33 = m33 * is3; - const trace = sm11 + sm22 + sm33; - let S = 0; - if (trace > 0) { - S = Math.sqrt(trace + 1) * 2; - out_r[3] = 0.25 * S; - out_r[0] = (sm23 - sm32) / S; - out_r[1] = (sm31 - sm13) / S; - out_r[2] = (sm12 - sm21) / S; - } else if (sm11 > sm22 && sm11 > sm33) { - S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2; - out_r[3] = (sm23 - sm32) / S; - out_r[0] = 0.25 * S; - out_r[1] = (sm12 + sm21) / S; - out_r[2] = (sm31 + sm13) / S; - } else if (sm22 > sm33) { - S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2; - out_r[3] = (sm31 - sm13) / S; - out_r[0] = (sm12 + sm21) / S; - out_r[1] = 0.25 * S; - out_r[2] = (sm23 + sm32) / S; - } else { - S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2; - out_r[3] = (sm12 - sm21) / S; - out_r[0] = (sm31 + sm13) / S; - out_r[1] = (sm23 + sm32) / S; - out_r[2] = 0.25 * S; - } - return out_r; -} -function fromRotationTranslationScale3(out, q, v, s) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - out[0] = (1 - (yy + zz)) * sx; - out[1] = (xy + wz) * sx; - out[2] = (xz - wy) * sx; - out[3] = 0; - out[4] = (xy - wz) * sy; - out[5] = (1 - (xx + zz)) * sy; - out[6] = (yz + wx) * sy; - out[7] = 0; - out[8] = (xz + wy) * sz; - out[9] = (yz - wx) * sz; - out[10] = (1 - (xx + yy)) * sz; - out[11] = 0; - out[12] = v[0]; - out[13] = v[1]; - out[14] = v[2]; - out[15] = 1; - return out; -} -function fromRotationTranslationScaleOrigin3(out, q, v, s, o) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const xy = x * y2; - const xz = x * z2; - const yy = y * y2; - const yz = y * z2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - const sx = s[0]; - const sy = s[1]; - const sz = s[2]; - const ox = o[0]; - const oy = o[1]; - const oz = o[2]; - const out0 = (1 - (yy + zz)) * sx; - const out1 = (xy + wz) * sx; - const out2 = (xz - wy) * sx; - const out4 = (xy - wz) * sy; - const out5 = (1 - (xx + zz)) * sy; - const out6 = (yz + wx) * sy; - const out8 = (xz + wy) * sz; - const out9 = (yz - wx) * sz; - const out10 = (1 - (xx + yy)) * sz; - out[0] = out0; - out[1] = out1; - out[2] = out2; - out[3] = 0; - out[4] = out4; - out[5] = out5; - out[6] = out6; - out[7] = 0; - out[8] = out8; - out[9] = out9; - out[10] = out10; - out[11] = 0; - out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); - out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); - out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); - out[15] = 1; - return out; -} -function fromQuat5(out, q) { - const x = q[0]; - const y = q[1]; - const z = q[2]; - const w = q[3]; - const x2 = x + x; - const y2 = y + y; - const z2 = z + z; - const xx = x * x2; - const yx = y * x2; - const yy = y * y2; - const zx = z * x2; - const zy = z * y2; - const zz = z * z2; - const wx = w * x2; - const wy = w * y2; - const wz = w * z2; - out[0] = 1 - yy - zz; - out[1] = yx + wz; - out[2] = zx - wy; - out[3] = 0; - out[4] = yx - wz; - out[5] = 1 - xx - zz; - out[6] = zy + wx; - out[7] = 0; - out[8] = zx + wy; - out[9] = zy - wx; - out[10] = 1 - xx - yy; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; -} -function frustum3(out, left, right, bottom, top, near, far) { - const rl = 1 / (right - left); - const tb = 1 / (top - bottom); - const nf = 1 / (near - far); - out[0] = near * 2 * rl; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = near * 2 * tb; - out[6] = 0; - out[7] = 0; - out[8] = (right + left) * rl; - out[9] = (top + bottom) * tb; - out[10] = (far + near) * nf; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near * 2 * nf; - out[15] = 0; - return out; -} -function perspectiveNO3(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = (far + near) * nf; - out[14] = 2 * far * near * nf; - } else { - out[10] = -1; - out[14] = -2 * near; - } - return out; -} -var perspective3 = perspectiveNO3; -function perspectiveZO3(out, fovy, aspect, near, far) { - const f = 1 / Math.tan(fovy / 2); - out[0] = f / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - const nf = 1 / (near - far); - out[10] = far * nf; - out[14] = far * near * nf; - } else { - out[10] = -1; - out[14] = -near; - } - return out; -} -function perspectiveFromFieldOfView3(out, fov, near, far) { - const upTan = Math.tan(fov.upDegrees * Math.PI / 180); - const downTan = Math.tan(fov.downDegrees * Math.PI / 180); - const leftTan = Math.tan(fov.leftDegrees * Math.PI / 180); - const rightTan = Math.tan(fov.rightDegrees * Math.PI / 180); - const xScale = 2 / (leftTan + rightTan); - const yScale = 2 / (upTan + downTan); - out[0] = xScale; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = yScale; - out[6] = 0; - out[7] = 0; - out[8] = -((leftTan - rightTan) * xScale * 0.5); - out[9] = (upTan - downTan) * yScale * 0.5; - out[10] = far / (near - far); - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near / (near - far); - out[15] = 0; - return out; -} -function orthoNO3(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 2 * nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = (far + near) * nf; - out[15] = 1; - return out; -} -var ortho3 = orthoNO3; -function orthoZO3(out, left, right, bottom, top, near, far) { - const lr = 1 / (left - right); - const bt = 1 / (bottom - top); - const nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = near * nf; - out[15] = 1; - return out; -} -function lookAt3(out, eye, center, up) { - let len8; - let x0; - let x1; - let x2; - let y0; - let y1; - let y2; - let z0; - let z1; - let z2; - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - const centerx = center[0]; - const centery = center[1]; - const centerz = center[2]; - if (Math.abs(eyex - centerx) < EPSILON4 && Math.abs(eyey - centery) < EPSILON4 && Math.abs(eyez - centerz) < EPSILON4) { - return identity3(out); - } - z0 = eyex - centerx; - z1 = eyey - centery; - z2 = eyez - centerz; - len8 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); - z0 *= len8; - z1 *= len8; - z2 *= len8; - x0 = upy * z2 - upz * z1; - x1 = upz * z0 - upx * z2; - x2 = upx * z1 - upy * z0; - len8 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); - if (!len8) { - x0 = 0; - x1 = 0; - x2 = 0; - } else { - len8 = 1 / len8; - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - y0 = z1 * x2 - z2 * x1; - y1 = z2 * x0 - z0 * x2; - y2 = z0 * x1 - z1 * x0; - len8 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); - if (!len8) { - y0 = 0; - y1 = 0; - y2 = 0; - } else { - len8 = 1 / len8; - y0 *= len8; - y1 *= len8; - y2 *= len8; - } - out[0] = x0; - out[1] = y0; - out[2] = z0; - out[3] = 0; - out[4] = x1; - out[5] = y1; - out[6] = z1; - out[7] = 0; - out[8] = x2; - out[9] = y2; - out[10] = z2; - out[11] = 0; - out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); - out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); - out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); - out[15] = 1; - return out; -} -function targetTo3(out, eye, target, up) { - const eyex = eye[0]; - const eyey = eye[1]; - const eyez = eye[2]; - const upx = up[0]; - const upy = up[1]; - const upz = up[2]; - let z0 = eyex - target[0]; - let z1 = eyey - target[1]; - let z2 = eyez - target[2]; - let len8 = z0 * z0 + z1 * z1 + z2 * z2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - z0 *= len8; - z1 *= len8; - z2 *= len8; - } - let x0 = upy * z2 - upz * z1; - let x1 = upz * z0 - upx * z2; - let x2 = upx * z1 - upy * z0; - len8 = x0 * x0 + x1 * x1 + x2 * x2; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - x0 *= len8; - x1 *= len8; - x2 *= len8; - } - out[0] = x0; - out[1] = x1; - out[2] = x2; - out[3] = 0; - out[4] = z1 * x2 - z2 * x1; - out[5] = z2 * x0 - z0 * x2; - out[6] = z0 * x1 - z1 * x0; - out[7] = 0; - out[8] = z0; - out[9] = z1; - out[10] = z2; - out[11] = 0; - out[12] = eyex; - out[13] = eyey; - out[14] = eyez; - out[15] = 1; - return out; -} -function str9(a) { - return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`; -} -function frob3(a) { - return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]); -} -function add10(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - out[4] = a[4] + b[4]; - out[5] = a[5] + b[5]; - out[6] = a[6] + b[6]; - out[7] = a[7] + b[7]; - out[8] = a[8] + b[8]; - out[9] = a[9] + b[9]; - out[10] = a[10] + b[10]; - out[11] = a[11] + b[11]; - out[12] = a[12] + b[12]; - out[13] = a[13] + b[13]; - out[14] = a[14] + b[14]; - out[15] = a[15] + b[15]; - return out; -} -function subtract9(out, a, b) { - out[0] = a[0] - b[0]; - out[1] = a[1] - b[1]; - out[2] = a[2] - b[2]; - out[3] = a[3] - b[3]; - out[4] = a[4] - b[4]; - out[5] = a[5] - b[5]; - out[6] = a[6] - b[6]; - out[7] = a[7] - b[7]; - out[8] = a[8] - b[8]; - out[9] = a[9] - b[9]; - out[10] = a[10] - b[10]; - out[11] = a[11] - b[11]; - out[12] = a[12] - b[12]; - out[13] = a[13] - b[13]; - out[14] = a[14] - b[14]; - out[15] = a[15] - b[15]; - return out; -} -function multiplyScalar3(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - out[4] = a[4] * b; - out[5] = a[5] * b; - out[6] = a[6] * b; - out[7] = a[7] * b; - out[8] = a[8] * b; - out[9] = a[9] * b; - out[10] = a[10] * b; - out[11] = a[11] * b; - out[12] = a[12] * b; - out[13] = a[13] * b; - out[14] = a[14] * b; - out[15] = a[15] * b; - return out; -} -function multiplyScalarAndAdd3(out, a, b, scale13) { - out[0] = a[0] + b[0] * scale13; - out[1] = a[1] + b[1] * scale13; - out[2] = a[2] + b[2] * scale13; - out[3] = a[3] + b[3] * scale13; - out[4] = a[4] + b[4] * scale13; - out[5] = a[5] + b[5] * scale13; - out[6] = a[6] + b[6] * scale13; - out[7] = a[7] + b[7] * scale13; - out[8] = a[8] + b[8] * scale13; - out[9] = a[9] + b[9] * scale13; - out[10] = a[10] + b[10] * scale13; - out[11] = a[11] + b[11] * scale13; - out[12] = a[12] + b[12] * scale13; - out[13] = a[13] + b[13] * scale13; - out[14] = a[14] + b[14] * scale13; - out[15] = a[15] + b[15] * scale13; - return out; -} -function exactEquals10(a, b) { - return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; -} -function equals11(a, b) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const a4 = a[4]; - const a5 = a[5]; - const a6 = a[6]; - const a7 = a[7]; - const a8 = a[8]; - const a9 = a[9]; - const a10 = a[10]; - const a11 = a[11]; - const a12 = a[12]; - const a13 = a[13]; - const a14 = a[14]; - const a15 = a[15]; - const b0 = b[0]; - const b1 = b[1]; - const b2 = b[2]; - const b3 = b[3]; - const b4 = b[4]; - const b5 = b[5]; - const b6 = b[6]; - const b7 = b[7]; - const b8 = b[8]; - const b9 = b[9]; - const b10 = b[10]; - const b11 = b[11]; - const b12 = b[12]; - const b13 = b[13]; - const b14 = b[14]; - const b15 = b[15]; - return Math.abs(a0 - b0) <= EPSILON4 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON4 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON4 * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON4 * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON4 * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON4 * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON4 * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON4 * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON4 * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON4 * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON4 * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON4 * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON4 * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON4 * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON4 * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON4 * Math.max(1, Math.abs(a15), Math.abs(b15)); -} -var mul9 = multiply10; -var sub9 = subtract9; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/vec4.js -function create13() { - const out = new ARRAY_TYPE3(4); - if (ARRAY_TYPE3 != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; - } - return out; -} -function add11(out, a, b) { - out[0] = a[0] + b[0]; - out[1] = a[1] + b[1]; - out[2] = a[2] + b[2]; - out[3] = a[3] + b[3]; - return out; -} -function scale11(out, a, b) { - out[0] = a[0] * b; - out[1] = a[1] * b; - out[2] = a[2] * b; - out[3] = a[3] * b; - return out; -} -function length8(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return Math.sqrt(x * x + y * y + z * z + w * w); -} -function squaredLength7(a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - return x * x + y * y + z * z + w * w; -} -function normalize9(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const w = a[3]; - let len8 = x * x + y * y + z * z + w * w; - if (len8 > 0) { - len8 = 1 / Math.sqrt(len8); - } - out[0] = x * len8; - out[1] = y * len8; - out[2] = z * len8; - out[3] = w * len8; - return out; -} -function dot8(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; -} -function lerp9(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - out[0] = ax + t * (b[0] - ax); - out[1] = ay + t * (b[1] - ay); - out[2] = az + t * (b[2] - az); - out[3] = aw + t * (b[3] - aw); - return out; -} -function transformQuat6(out, a, q) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - const qx = q[0]; - const qy = q[1]; - const qz = q[2]; - const qw = q[3]; - const ix = qw * x + qy * z - qz * y; - const iy = qw * y + qz * x - qx * z; - const iz = qw * z + qx * y - qy * x; - const iw = -qx * x - qy * y - qz * z; - out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; - out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; - out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; - out[3] = a[3]; - return out; -} -var forEach10 = function() { - const vec = create13(); - return function(a, stride, offset, count2, fn, arg) { - let i; - let l; - if (!stride) { - stride = 4; - } - if (!offset) { - offset = 0; - } - if (count2) { - l = Math.min(count2 * stride + offset, a.length); - } else { - l = a.length; - } - for (i = offset; i < l; i += stride) { - vec[0] = a[i]; - vec[1] = a[i + 1]; - vec[2] = a[i + 2]; - vec[3] = a[i + 3]; - fn(vec, vec, arg); - a[i] = vec[0]; - a[i + 1] = vec[1]; - a[i + 2] = vec[2]; - a[i + 3] = vec[3]; - } - return a; - }; -}(); - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/gl-matrix/quat.js -function create14() { - const out = new ARRAY_TYPE3(4); - if (ARRAY_TYPE3 != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - } - out[3] = 1; - return out; -} -function identity4(out) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 1; - return out; -} -function setAxisAngle(out, axis, rad) { - rad = rad * 0.5; - const s = Math.sin(rad); - out[0] = s * axis[0]; - out[1] = s * axis[1]; - out[2] = s * axis[2]; - out[3] = Math.cos(rad); - return out; -} -function multiply11(out, a, b) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - const bx = b[0]; - const by = b[1]; - const bz = b[2]; - const bw = b[3]; - out[0] = ax * bw + aw * bx + ay * bz - az * by; - out[1] = ay * bw + aw * by + az * bx - ax * bz; - out[2] = az * bw + aw * bz + ax * by - ay * bx; - out[3] = aw * bw - ax * bx - ay * by - az * bz; - return out; -} -function rotateX7(out, a, rad) { - rad *= 0.5; - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - const bx = Math.sin(rad); - const bw = Math.cos(rad); - out[0] = ax * bw + aw * bx; - out[1] = ay * bw + az * bx; - out[2] = az * bw - ay * bx; - out[3] = aw * bw - ax * bx; - return out; -} -function rotateY7(out, a, rad) { - rad *= 0.5; - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - const by = Math.sin(rad); - const bw = Math.cos(rad); - out[0] = ax * bw - az * by; - out[1] = ay * bw + aw * by; - out[2] = az * bw + ax * by; - out[3] = aw * bw - ay * by; - return out; -} -function rotateZ7(out, a, rad) { - rad *= 0.5; - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - const bz = Math.sin(rad); - const bw = Math.cos(rad); - out[0] = ax * bw + ay * bz; - out[1] = ay * bw - ax * bz; - out[2] = az * bw + aw * bz; - out[3] = aw * bw - az * bz; - return out; -} -function calculateW(out, a) { - const x = a[0]; - const y = a[1]; - const z = a[2]; - out[0] = x; - out[1] = y; - out[2] = z; - out[3] = Math.sqrt(Math.abs(1 - x * x - y * y - z * z)); - return out; -} -function slerp3(out, a, b, t) { - const ax = a[0]; - const ay = a[1]; - const az = a[2]; - const aw = a[3]; - let bx = b[0]; - let by = b[1]; - let bz = b[2]; - let bw = b[3]; - let cosom; - let omega; - let scale0; - let scale1; - let sinom; - cosom = ax * bx + ay * by + az * bz + aw * bw; - if (cosom < 0) { - cosom = -cosom; - bx = -bx; - by = -by; - bz = -bz; - bw = -bw; - } - if (1 - cosom > EPSILON4) { - omega = Math.acos(cosom); - sinom = Math.sin(omega); - scale0 = Math.sin((1 - t) * omega) / sinom; - scale1 = Math.sin(t * omega) / sinom; - } else { - scale0 = 1 - t; - scale1 = t; - } - out[0] = scale0 * ax + scale1 * bx; - out[1] = scale0 * ay + scale1 * by; - out[2] = scale0 * az + scale1 * bz; - out[3] = scale0 * aw + scale1 * bw; - return out; -} -function invert5(out, a) { - const a0 = a[0]; - const a1 = a[1]; - const a2 = a[2]; - const a3 = a[3]; - const dot10 = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3; - const invDot = dot10 ? 1 / dot10 : 0; - out[0] = -a0 * invDot; - out[1] = -a1 * invDot; - out[2] = -a2 * invDot; - out[3] = a3 * invDot; - return out; -} -function conjugate(out, a) { - out[0] = -a[0]; - out[1] = -a[1]; - out[2] = -a[2]; - out[3] = a[3]; - return out; -} -function fromMat3(out, m) { - const fTrace = m[0] + m[4] + m[8]; - let fRoot; - if (fTrace > 0) { - fRoot = Math.sqrt(fTrace + 1); - out[3] = 0.5 * fRoot; - fRoot = 0.5 / fRoot; - out[0] = (m[5] - m[7]) * fRoot; - out[1] = (m[6] - m[2]) * fRoot; - out[2] = (m[1] - m[3]) * fRoot; - } else { - let i = 0; - if (m[4] > m[0]) - i = 1; - if (m[8] > m[i * 3 + i]) - i = 2; - const j = (i + 1) % 3; - const k = (i + 2) % 3; - fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1); - out[i] = 0.5 * fRoot; - fRoot = 0.5 / fRoot; - out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot; - out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot; - out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot; - } - return out; -} -var add12 = add11; -var scale12 = scale11; -var dot9 = dot8; -var lerp10 = lerp9; -var length9 = length8; -var squaredLength8 = squaredLength7; -var normalize10 = normalize9; -var rotationTo = function() { - const tmpvec3 = create10(); - const xUnitVec3 = fromValues9(1, 0, 0); - const yUnitVec3 = fromValues9(0, 1, 0); - return function(out, a, b) { - const dot10 = dot7(a, b); - if (dot10 < -0.999999) { - cross7(tmpvec3, xUnitVec3, a); - if (len7(tmpvec3) < 1e-6) - cross7(tmpvec3, yUnitVec3, a); - normalize8(tmpvec3, tmpvec3); - setAxisAngle(out, tmpvec3, Math.PI); - return out; - } else if (dot10 > 0.999999) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 1; - return out; - } - cross7(tmpvec3, a, b); - out[0] = tmpvec3[0]; - out[1] = tmpvec3[1]; - out[2] = tmpvec3[2]; - out[3] = 1 + dot10; - return normalize10(out, out); - }; -}(); -var sqlerp = function() { - const temp1 = create14(); - const temp2 = create14(); - return function(out, a, b, c, d, t) { - slerp3(temp1, a, d, t); - slerp3(temp2, b, c, t); - slerp3(out, temp1, temp2, 2 * t * (1 - t)); - return out; - }; -}(); -var setAxes = function() { - const matr = create11(); - return function(out, view, right, up) { - matr[0] = right[0]; - matr[3] = right[1]; - matr[6] = right[2]; - matr[1] = up[0]; - matr[4] = up[1]; - matr[7] = up[2]; - matr[2] = -view[0]; - matr[5] = -view[1]; - matr[8] = -view[2]; - return normalize10(out, fromMat3(out, matr)); - }; -}(); - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/classes/quaternion.js -var IDENTITY_QUATERNION = [0, 0, 0, 1]; -var Quaternion = class extends MathArray2 { - constructor(x = 0, y = 0, z = 0, w = 1) { - super(-0, -0, -0, -0); - if (Array.isArray(x) && arguments.length === 1) { - this.copy(x); - } else { - this.set(x, y, z, w); - } - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - this[3] = array[3]; - return this.check(); - } - set(x, y, z, w) { - this[0] = x; - this[1] = y; - this[2] = z; - this[3] = w; - return this.check(); - } - fromObject(object) { - this[0] = object.x; - this[1] = object.y; - this[2] = object.z; - this[3] = object.w; - return this.check(); - } - /** - * Creates a quaternion from the given 3x3 rotation matrix. - * NOTE: The resultant quaternion is not normalized, so you should - * be sure to renormalize the quaternion yourself where necessary. - * @param m - * @returns - */ - fromMatrix3(m) { - fromMat3(this, m); - return this.check(); - } - fromAxisRotation(axis, rad) { - setAxisAngle(this, axis, rad); - return this.check(); - } - /** Set a quat to the identity quaternion */ - identity() { - identity4(this); - return this.check(); - } - // Set the components of a quat to the given values - // set(i, j, k, l) { - // quat_set(this, i, j, k, l); - // return this.check(); - // } - // Sets a quat from the given angle and rotation axis, then returns it. - setAxisAngle(axis, rad) { - return this.fromAxisRotation(axis, rad); - } - // Getters/setters - get ELEMENTS() { - return 4; - } - get x() { - return this[0]; - } - set x(value) { - this[0] = checkNumber2(value); - } - get y() { - return this[1]; - } - set y(value) { - this[1] = checkNumber2(value); - } - get z() { - return this[2]; - } - set z(value) { - this[2] = checkNumber2(value); - } - get w() { - return this[3]; - } - set w(value) { - this[3] = checkNumber2(value); - } - // Calculates the length of a quat - len() { - return length9(this); - } - // Calculates the squared length of a quat - lengthSquared() { - return squaredLength8(this); - } - // Calculates the dot product of two quat's - // @return {Number} - dot(a) { - return dot9(this, a); - } - // Gets the rotation axis and angle for a given quaternion. - // If a quaternion is created with setAxisAngle, this method will - // return the same values as providied in the original parameter - // list OR functionally equivalent values. - // Example: The quaternion formed by axis [0, 0, 1] and angle -90 - // is the same as the quaternion formed by [0, 0, 1] and 270. - // This method favors the latter. - // @return {{[x,y,z], Number}} - // getAxisAngle() { - // const axis = []; - // // const angle = quat_getAxisAngle(axis, this); - // return {axis, angle}; - // } - // MODIFIERS - // Sets a quaternion to represent the shortest rotation from one vector - // to another. Both vectors are assumed to be unit length. - rotationTo(vectorA, vectorB) { - rotationTo(this, vectorA, vectorB); - return this.check(); - } - // Sets the specified quaternion with values corresponding to the given axes. - // Each axis is a vec3 and is expected to be unit length and perpendicular - // to all other specified axes. - // setAxes() { - // Number - // } - // Performs a spherical linear interpolation with two control points - // sqlerp() { - // Number; - // } - // Adds two quat's - add(a) { - add12(this, this, a); - return this.check(); - } - // Calculates the W component of a quat from the X, Y, and Z components. - // Any existing W component will be ignored. - calculateW() { - calculateW(this, this); - return this.check(); - } - // Calculates the conjugate of a quat If the quaternion is normalized, - // this function is faster than quat_invert and produces the same result. - conjugate() { - conjugate(this, this); - return this.check(); - } - // Calculates the inverse of a quat - invert() { - invert5(this, this); - return this.check(); - } - // Performs a linear interpolation between two quat's - lerp(a, b, t) { - if (t === void 0) { - return this.lerp(this, a, b); - } - lerp10(this, a, b, t); - return this.check(); - } - // Multiplies two quat's - multiplyRight(a) { - multiply11(this, this, a); - return this.check(); - } - multiplyLeft(a) { - multiply11(this, a, this); - return this.check(); - } - // Normalize a quat - normalize() { - const length10 = this.len(); - const l = length10 > 0 ? 1 / length10 : 0; - this[0] = this[0] * l; - this[1] = this[1] * l; - this[2] = this[2] * l; - this[3] = this[3] * l; - if (length10 === 0) { - this[3] = 1; - } - return this.check(); - } - // Rotates a quaternion by the given angle about the X axis - rotateX(rad) { - rotateX7(this, this, rad); - return this.check(); - } - // Rotates a quaternion by the given angle about the Y axis - rotateY(rad) { - rotateY7(this, this, rad); - return this.check(); - } - // Rotates a quaternion by the given angle about the Z axis - rotateZ(rad) { - rotateZ7(this, this, rad); - return this.check(); - } - // Scales a quat by a scalar number - scale(b) { - scale12(this, this, b); - return this.check(); - } - // Performs a spherical linear interpolation between two quat - slerp(arg0, arg1, arg2) { - let start; - let target; - let ratio; - switch (arguments.length) { - case 1: - ({ - start = IDENTITY_QUATERNION, - target, - ratio - } = arg0); - break; - case 2: - start = this; - target = arg0; - ratio = arg1; - break; - default: - start = arg0; - target = arg1; - ratio = arg2; - } - slerp3(this, start, target, ratio); - return this.check(); - } - transformVector4(vector, result = new Vector4()) { - transformQuat6(result, vector, this); - return checkVector2(result, 4); - } - // THREE.js Math API compatibility - lengthSq() { - return this.lengthSquared(); - } - setFromAxisAngle(axis, rad) { - return this.setAxisAngle(axis, rad); - } - premultiply(a) { - return this.multiplyLeft(a); - } - multiply(a) { - return this.multiplyRight(a); - } -}; - -// node_modules/@math.gl/culling/node_modules/@math.gl/core/dist/lib/math-utils.js -var math_utils_exports3 = {}; -__export(math_utils_exports3, { - EPSILON1: () => EPSILON1, - EPSILON10: () => EPSILON10, - EPSILON11: () => EPSILON11, - EPSILON12: () => EPSILON12, - EPSILON13: () => EPSILON13, - EPSILON14: () => EPSILON14, - EPSILON15: () => EPSILON15, - EPSILON16: () => EPSILON16, - EPSILON17: () => EPSILON17, - EPSILON18: () => EPSILON18, - EPSILON19: () => EPSILON19, - EPSILON2: () => EPSILON22, - EPSILON20: () => EPSILON20, - EPSILON3: () => EPSILON32, - EPSILON4: () => EPSILON42, - EPSILON5: () => EPSILON5, - EPSILON6: () => EPSILON6, - EPSILON7: () => EPSILON7, - EPSILON8: () => EPSILON8, - EPSILON9: () => EPSILON9, - PI_OVER_FOUR: () => PI_OVER_FOUR, - PI_OVER_SIX: () => PI_OVER_SIX, - PI_OVER_TWO: () => PI_OVER_TWO, - TWO_PI: () => TWO_PI -}); -var EPSILON1 = 0.1; -var EPSILON22 = 0.01; -var EPSILON32 = 1e-3; -var EPSILON42 = 1e-4; -var EPSILON5 = 1e-5; -var EPSILON6 = 1e-6; -var EPSILON7 = 1e-7; -var EPSILON8 = 1e-8; -var EPSILON9 = 1e-9; -var EPSILON10 = 1e-10; -var EPSILON11 = 1e-11; -var EPSILON12 = 1e-12; -var EPSILON13 = 1e-13; -var EPSILON14 = 1e-14; -var EPSILON15 = 1e-15; -var EPSILON16 = 1e-16; -var EPSILON17 = 1e-17; -var EPSILON18 = 1e-18; -var EPSILON19 = 1e-19; -var EPSILON20 = 1e-20; -var PI_OVER_TWO = Math.PI / 2; -var PI_OVER_FOUR = Math.PI / 4; -var PI_OVER_SIX = Math.PI / 6; -var TWO_PI = Math.PI * 2; - -// node_modules/@math.gl/culling/dist/lib/bounding-volumes/axis-aligned-bounding-box.js -var scratchVector2 = new Vector32(); -var scratchNormal = new Vector32(); -var AxisAlignedBoundingBox = class _AxisAlignedBoundingBox { - /** - * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes. - * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes. - * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes. - * @param center The center of the box; automatically computed if not supplied. - */ - constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) { - center = center || scratchVector2.copy(minimum).add(maximum).scale(0.5); - this.center = new Vector32(center); - this.halfDiagonal = new Vector32(maximum).subtract(this.center); - this.minimum = new Vector32(minimum); - this.maximum = new Vector32(maximum); - } - /** - * Duplicates a AxisAlignedBoundingBox instance. - * - * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance. - */ - clone() { - return new _AxisAlignedBoundingBox(this.minimum, this.maximum, this.center); - } - /** - * Compares the provided AxisAlignedBoundingBox componentwise and returns - * true if they are equal, false otherwise. - * - * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with. - * @returns {Boolean} true if left and right are equal, false otherwise. - */ - equals(right) { - return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum); - } - /** - * Applies a 4x4 affine transformation matrix to a bounding sphere. - * @param transform The transformation matrix to apply to the bounding sphere. - * @returns itself, i.e. the modified BoundingVolume. - */ - transform(transform) { - this.center.transformAsPoint(transform); - this.halfDiagonal.transform(transform); - this.minimum.transform(transform); - this.maximum.transform(transform); - return this; - } - /** - * Determines which side of a plane a box is located. - */ - intersectPlane(plane) { - const { halfDiagonal } = this; - const normal = scratchNormal.from(plane.normal); - const e = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z); - const s = this.center.dot(normal) + plane.distance; - if (s - e > 0) { - return INTERSECTION.INSIDE; - } - if (s + e < 0) { - return INTERSECTION.OUTSIDE; - } - return INTERSECTION.INTERSECTING; - } - /** Computes the estimated distance from the closest point on a bounding box to a point. */ - distanceTo(point) { - return Math.sqrt(this.distanceSquaredTo(point)); - } - /** Computes the estimated distance squared from the closest point on a bounding box to a point. */ - distanceSquaredTo(point) { - const offset = scratchVector2.from(point).subtract(this.center); - const { halfDiagonal } = this; - let distanceSquared = 0; - let d; - d = Math.abs(offset.x) - halfDiagonal.x; - if (d > 0) { - distanceSquared += d * d; - } - d = Math.abs(offset.y) - halfDiagonal.y; - if (d > 0) { - distanceSquared += d * d; - } - d = Math.abs(offset.z) - halfDiagonal.z; - if (d > 0) { - distanceSquared += d * d; - } - return distanceSquared; - } -}; - -// node_modules/@math.gl/culling/dist/lib/bounding-volumes/bounding-sphere.js -var scratchVector3 = new Vector32(); -var scratchVector22 = new Vector32(); -var BoundingSphere = class _BoundingSphere { - /** Creates a bounding sphere */ - constructor(center = [0, 0, 0], radius = 0) { - this.radius = -0; - this.center = new Vector32(); - this.fromCenterRadius(center, radius); - } - /** Sets the bounding sphere from `center` and `radius`. */ - fromCenterRadius(center, radius) { - this.center.from(center); - this.radius = radius; - return this; - } - /** - * Computes a bounding sphere from the corner points of an axis-aligned bounding box. The sphere - * tightly and fully encompasses the box. - */ - fromCornerPoints(corner, oppositeCorner) { - oppositeCorner = scratchVector3.from(oppositeCorner); - this.center = new Vector32().from(corner).add(oppositeCorner).scale(0.5); - this.radius = this.center.distance(oppositeCorner); - return this; - } - /** Compares the provided BoundingSphere component wise */ - equals(right) { - return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius; - } - /** Duplicates a BoundingSphere instance. */ - clone() { - return new _BoundingSphere(this.center, this.radius); - } - /** Computes a bounding sphere that contains both the left and right bounding spheres. */ - union(boundingSphere) { - const leftCenter = this.center; - const leftRadius = this.radius; - const rightCenter = boundingSphere.center; - const rightRadius = boundingSphere.radius; - const toRightCenter = scratchVector3.copy(rightCenter).subtract(leftCenter); - const centerSeparation = toRightCenter.magnitude(); - if (leftRadius >= centerSeparation + rightRadius) { - return this.clone(); - } - if (rightRadius >= centerSeparation + leftRadius) { - return boundingSphere.clone(); - } - const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5; - scratchVector22.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter); - this.center.copy(scratchVector22); - this.radius = halfDistanceBetweenTangentPoints; - return this; - } - /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */ - expand(point) { - const scratchPoint = scratchVector3.from(point); - const radius = scratchPoint.subtract(this.center).magnitude(); - if (radius > this.radius) { - this.radius = radius; - } - return this; - } - // BoundingVolume interface - /** - * Applies a 4x4 affine transformation matrix to a bounding sphere. - * @param sphere The bounding sphere to apply the transformation to. - * @param transform The transformation matrix to apply to the bounding sphere. - * @returns self. - */ - transform(transform) { - this.center.transform(transform); - const scale13 = mat4_exports3.getScaling(scratchVector3, transform); - this.radius = Math.max(scale13[0], Math.max(scale13[1], scale13[2])) * this.radius; - return this; - } - /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */ - distanceSquaredTo(point) { - const d = this.distanceTo(point); - return d * d; - } - /** Computes the estimated distance from the closest point on a bounding sphere to a point. */ - distanceTo(point) { - const scratchPoint = scratchVector3.from(point); - const delta = scratchPoint.subtract(this.center); - return Math.max(0, delta.len() - this.radius); - } - /** Determines which side of a plane a sphere is located. */ - intersectPlane(plane) { - const center = this.center; - const radius = this.radius; - const normal = plane.normal; - const distanceToPlane = normal.dot(center) + plane.distance; - if (distanceToPlane < -radius) { - return INTERSECTION.OUTSIDE; - } - if (distanceToPlane < radius) { - return INTERSECTION.INTERSECTING; - } - return INTERSECTION.INSIDE; - } -}; - -// node_modules/@math.gl/culling/dist/lib/bounding-volumes/oriented-bounding-box.js -var scratchVector32 = new Vector32(); -var scratchOffset = new Vector32(); -var scratchVectorU = new Vector32(); -var scratchVectorV = new Vector32(); -var scratchVectorW = new Vector32(); -var scratchCorner = new Vector32(); -var scratchToCenter = new Vector32(); -var MATRIX3 = { - COLUMN0ROW0: 0, - COLUMN0ROW1: 1, - COLUMN0ROW2: 2, - COLUMN1ROW0: 3, - COLUMN1ROW1: 4, - COLUMN1ROW2: 5, - COLUMN2ROW0: 6, - COLUMN2ROW1: 7, - COLUMN2ROW2: 8 -}; -var OrientedBoundingBox = class _OrientedBoundingBox { - constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) { - this.center = new Vector32().from(center); - this.halfAxes = new Matrix3(halfAxes); - } - /** Returns an array with three halfSizes for the bounding box */ - get halfSize() { - const xAxis = this.halfAxes.getColumn(0); - const yAxis = this.halfAxes.getColumn(1); - const zAxis = this.halfAxes.getColumn(2); - return [new Vector32(xAxis).len(), new Vector32(yAxis).len(), new Vector32(zAxis).len()]; - } - /** Returns a quaternion describing the orientation of the bounding box */ - get quaternion() { - const xAxis = this.halfAxes.getColumn(0); - const yAxis = this.halfAxes.getColumn(1); - const zAxis = this.halfAxes.getColumn(2); - const normXAxis = new Vector32(xAxis).normalize(); - const normYAxis = new Vector32(yAxis).normalize(); - const normZAxis = new Vector32(zAxis).normalize(); - return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis])); - } - /** - * Create OrientedBoundingBox from quaternion based OBB, - */ - fromCenterHalfSizeQuaternion(center, halfSize, quaternion) { - const quaternionObject = new Quaternion(quaternion); - const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject); - directionsMatrix[0] = directionsMatrix[0] * halfSize[0]; - directionsMatrix[1] = directionsMatrix[1] * halfSize[0]; - directionsMatrix[2] = directionsMatrix[2] * halfSize[0]; - directionsMatrix[3] = directionsMatrix[3] * halfSize[1]; - directionsMatrix[4] = directionsMatrix[4] * halfSize[1]; - directionsMatrix[5] = directionsMatrix[5] * halfSize[1]; - directionsMatrix[6] = directionsMatrix[6] * halfSize[2]; - directionsMatrix[7] = directionsMatrix[7] * halfSize[2]; - directionsMatrix[8] = directionsMatrix[8] * halfSize[2]; - this.center = new Vector32().from(center); - this.halfAxes = directionsMatrix; - return this; - } - /** Duplicates a OrientedBoundingBox instance. */ - clone() { - return new _OrientedBoundingBox(this.center, this.halfAxes); - } - /** Compares the provided OrientedBoundingBox component wise and returns */ - equals(right) { - return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes); - } - /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */ - getBoundingSphere(result = new BoundingSphere()) { - const halfAxes = this.halfAxes; - const u = halfAxes.getColumn(0, scratchVectorU); - const v = halfAxes.getColumn(1, scratchVectorV); - const w = halfAxes.getColumn(2, scratchVectorW); - const cornerVector = scratchVector32.copy(u).add(v).add(w); - result.center.copy(this.center); - result.radius = cornerVector.magnitude(); - return result; - } - /** Determines which side of a plane the oriented bounding box is located. */ - intersectPlane(plane) { - const center = this.center; - const normal = plane.normal; - const halfAxes = this.halfAxes; - const normalX = normal.x; - const normalY = normal.y; - const normalZ = normal.z; - const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]); - const distanceToPlane = normal.dot(center) + plane.distance; - if (distanceToPlane <= -radEffective) { - return INTERSECTION.OUTSIDE; - } else if (distanceToPlane >= radEffective) { - return INTERSECTION.INSIDE; - } - return INTERSECTION.INTERSECTING; - } - /** Computes the estimated distance from the closest point on a bounding box to a point. */ - distanceTo(point) { - return Math.sqrt(this.distanceSquaredTo(point)); - } - /** - * Computes the estimated distance squared from the closest point - * on a bounding box to a point. - * See Geometric Tools for Computer Graphics 10.4.2 - */ - distanceSquaredTo(point) { - const offset = scratchOffset.from(point).subtract(this.center); - const halfAxes = this.halfAxes; - const u = halfAxes.getColumn(0, scratchVectorU); - const v = halfAxes.getColumn(1, scratchVectorV); - const w = halfAxes.getColumn(2, scratchVectorW); - const uHalf = u.magnitude(); - const vHalf = v.magnitude(); - const wHalf = w.magnitude(); - u.normalize(); - v.normalize(); - w.normalize(); - let distanceSquared = 0; - let d; - d = Math.abs(offset.dot(u)) - uHalf; - if (d > 0) { - distanceSquared += d * d; - } - d = Math.abs(offset.dot(v)) - vHalf; - if (d > 0) { - distanceSquared += d * d; - } - d = Math.abs(offset.dot(w)) - wHalf; - if (d > 0) { - distanceSquared += d * d; - } - return distanceSquared; - } - /** - * The distances calculated by the vector from the center of the bounding box - * to position projected onto direction. - * - * - If you imagine the infinite number of planes with normal direction, - * this computes the smallest distance to the closest and farthest planes - * from `position` that intersect the bounding box. - * - * @param position The position to calculate the distance from. - * @param direction The direction from position. - * @param result An Interval (array of length 2) to store the nearest and farthest distances. - * @returns Interval (array of length 2) with nearest and farthest distances - * on the bounding box from position in direction. - */ - // eslint-disable-next-line max-statements - computePlaneDistances(position, direction, result = [-0, -0]) { - let minDist = Number.POSITIVE_INFINITY; - let maxDist = Number.NEGATIVE_INFINITY; - const center = this.center; - const halfAxes = this.halfAxes; - const u = halfAxes.getColumn(0, scratchVectorU); - const v = halfAxes.getColumn(1, scratchVectorV); - const w = halfAxes.getColumn(2, scratchVectorW); - const corner = scratchCorner.copy(u).add(v).add(w).add(center); - const toCenter = scratchToCenter.copy(corner).subtract(position); - let mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - corner.copy(center).add(u).add(v).subtract(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - corner.copy(center).add(u).subtract(v).add(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - corner.copy(center).add(u).subtract(v).subtract(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - center.copy(corner).subtract(u).add(v).add(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - center.copy(corner).subtract(u).add(v).subtract(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - center.copy(corner).subtract(u).subtract(v).add(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - center.copy(corner).subtract(u).subtract(v).subtract(w); - toCenter.copy(corner).subtract(position); - mag = direction.dot(toCenter); - minDist = Math.min(mag, minDist); - maxDist = Math.max(mag, maxDist); - result[0] = minDist; - result[1] = maxDist; - return result; - } - /** - * Applies a 4x4 affine transformation matrix to a bounding sphere. - * @param transform The transformation matrix to apply to the bounding sphere. - * @returns itself, i.e. the modified BoundingVolume. - */ - transform(transformation) { - this.center.transformAsPoint(transformation); - const xAxis = this.halfAxes.getColumn(0, scratchVectorU); - xAxis.transformAsPoint(transformation); - const yAxis = this.halfAxes.getColumn(1, scratchVectorV); - yAxis.transformAsPoint(transformation); - const zAxis = this.halfAxes.getColumn(2, scratchVectorW); - zAxis.transformAsPoint(transformation); - this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]); - return this; - } - getTransform() { - throw new Error("not implemented"); - } -}; - -// node_modules/@math.gl/culling/dist/lib/plane.js -var scratchPosition = new Vector32(); -var scratchNormal2 = new Vector32(); -var Plane = class _Plane { - constructor(normal = [0, 0, 1], distance8 = 0) { - this.normal = new Vector32(); - this.distance = -0; - this.fromNormalDistance(normal, distance8); - } - /** Creates a plane from a normal and a distance from the origin. */ - fromNormalDistance(normal, distance8) { - assert10(Number.isFinite(distance8)); - this.normal.from(normal).normalize(); - this.distance = distance8; - return this; - } - /** Creates a plane from a normal and a point on the plane. */ - fromPointNormal(point, normal) { - point = scratchPosition.from(point); - this.normal.from(normal).normalize(); - const distance8 = -this.normal.dot(point); - this.distance = distance8; - return this; - } - /** Creates a plane from the general equation */ - fromCoefficients(a, b, c, d) { - this.normal.set(a, b, c); - assert10(equals10(this.normal.len(), 1)); - this.distance = d; - return this; - } - /** Duplicates a Plane instance. */ - clone() { - return new _Plane(this.normal, this.distance); - } - /** Compares the provided Planes by normal and distance */ - equals(right) { - return equals10(this.distance, right.distance) && equals10(this.normal, right.normal); - } - /** Computes the signed shortest distance of a point to a plane. - * The sign of the distance determines which side of the plane the point is on. - */ - getPointDistance(point) { - return this.normal.dot(point) + this.distance; - } - /** Transforms the plane by the given transformation matrix. */ - transform(matrix4) { - const normal = scratchNormal2.copy(this.normal).transformAsVector(matrix4).normalize(); - const point = this.normal.scale(-this.distance).transform(matrix4); - return this.fromPointNormal(point, normal); - } - projectPointOntoPlane(point, result = [0, 0, 0]) { - const scratchPoint = scratchPosition.from(point); - const pointDistance = this.getPointDistance(scratchPoint); - const scaledNormal = scratchNormal2.copy(this.normal).scale(pointDistance); - return scratchPoint.subtract(scaledNormal).to(result); - } -}; - -// node_modules/@math.gl/culling/dist/lib/culling-volume.js -var faces = [new Vector32([1, 0, 0]), new Vector32([0, 1, 0]), new Vector32([0, 0, 1])]; -var scratchPlaneCenter = new Vector32(); -var scratchPlaneNormal = new Vector32(); -var CullingVolume = class _CullingVolume { - /** - * Create a new `CullingVolume` bounded by an array of clipping planed - * @param planes Array of clipping planes. - * */ - constructor(planes = []) { - this.planes = planes; - } - /** - * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere. - * The planes are aligned to the x, y, and z axes in world coordinates. - */ - fromBoundingSphere(boundingSphere) { - this.planes.length = 2 * faces.length; - const center = boundingSphere.center; - const radius = boundingSphere.radius; - let planeIndex = 0; - for (const faceNormal of faces) { - let plane0 = this.planes[planeIndex]; - let plane1 = this.planes[planeIndex + 1]; - if (!plane0) { - plane0 = this.planes[planeIndex] = new Plane(); - } - if (!plane1) { - plane1 = this.planes[planeIndex + 1] = new Plane(); - } - const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center); - plane0.fromPointNormal(plane0Center, faceNormal); - const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center); - const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate(); - plane1.fromPointNormal(plane1Center, negatedFaceNormal); - planeIndex += 2; - } - return this; - } - /** Determines whether a bounding volume intersects the culling volume. */ - computeVisibility(boundingVolume) { - let intersect2 = INTERSECTION.INSIDE; - for (const plane of this.planes) { - const result = boundingVolume.intersectPlane(plane); - switch (result) { - case INTERSECTION.OUTSIDE: - return INTERSECTION.OUTSIDE; - case INTERSECTION.INTERSECTING: - intersect2 = INTERSECTION.INTERSECTING; - break; - default: - } - } - return intersect2; - } - /** - * Determines whether a bounding volume intersects the culling volume. - * - * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling - * volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then - * the parent (and therefore this) volume is completely inside plane[planeIndex] - * and that plane check can be skipped. - */ - computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) { - assert10(Number.isFinite(parentPlaneMask), "parentPlaneMask is required."); - if (parentPlaneMask === _CullingVolume.MASK_OUTSIDE || parentPlaneMask === _CullingVolume.MASK_INSIDE) { - return parentPlaneMask; - } - let mask = _CullingVolume.MASK_INSIDE; - const planes = this.planes; - for (let k = 0; k < this.planes.length; ++k) { - const flag = k < 31 ? 1 << k : 0; - if (k < 31 && (parentPlaneMask & flag) === 0) { - continue; - } - const plane = planes[k]; - const result = boundingVolume.intersectPlane(plane); - if (result === INTERSECTION.OUTSIDE) { - return _CullingVolume.MASK_OUTSIDE; - } else if (result === INTERSECTION.INTERSECTING) { - mask |= flag; - } - } - return mask; - } -}; -CullingVolume.MASK_OUTSIDE = 4294967295; -CullingVolume.MASK_INSIDE = 0; -CullingVolume.MASK_INDETERMINATE = 2147483647; - -// node_modules/@math.gl/culling/dist/lib/perspective-off-center-frustum.js -var scratchPlaneUpVector = new Vector32(); -var scratchPlaneRightVector = new Vector32(); -var scratchPlaneNearCenter = new Vector32(); -var scratchPlaneFarCenter = new Vector32(); -var scratchPlaneNormal2 = new Vector32(); - -// node_modules/@math.gl/culling/dist/lib/algorithms/bounding-sphere-from-points.js -var fromPointsXMin = new Vector32(); -var fromPointsYMin = new Vector32(); -var fromPointsZMin = new Vector32(); -var fromPointsXMax = new Vector32(); -var fromPointsYMax = new Vector32(); -var fromPointsZMax = new Vector32(); -var fromPointsCurrentPos = new Vector32(); -var fromPointsScratch = new Vector32(); -var fromPointsRitterCenter = new Vector32(); -var fromPointsMinBoxPt = new Vector32(); -var fromPointsMaxBoxPt = new Vector32(); -var fromPointsNaiveCenterScratch = new Vector32(); - -// node_modules/@math.gl/culling/dist/lib/algorithms/compute-eigen-decomposition.js -var scratchMatrix = new Matrix3(); -var scratchUnitary = new Matrix3(); -var scratchDiagonal = new Matrix3(); -var jMatrix = new Matrix3(); -var jMatrixTranspose = new Matrix3(); -function computeEigenDecomposition(matrix, result = {}) { - const EIGEN_TOLERANCE = math_utils_exports3.EPSILON20; - const EIGEN_MAX_SWEEPS = 10; - let count2 = 0; - let sweep = 0; - const unitaryMatrix = scratchUnitary; - const diagonalMatrix = scratchDiagonal; - unitaryMatrix.identity(); - diagonalMatrix.copy(matrix); - const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix); - while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) { - shurDecomposition(diagonalMatrix, jMatrix); - jMatrixTranspose.copy(jMatrix).transpose(); - diagonalMatrix.multiplyRight(jMatrix); - diagonalMatrix.multiplyLeft(jMatrixTranspose); - unitaryMatrix.multiplyRight(jMatrix); - if (++count2 > 2) { - ++sweep; - count2 = 0; - } - } - result.unitary = unitaryMatrix.toTarget(result.unitary); - result.diagonal = diagonalMatrix.toTarget(result.diagonal); - return result; -} -function computeFrobeniusNorm(matrix) { - let norm = 0; - for (let i = 0; i < 9; ++i) { - const temp = matrix[i]; - norm += temp * temp; - } - return Math.sqrt(norm); -} -var rowVal = [1, 0, 0]; -var colVal = [2, 2, 1]; -function offDiagonalFrobeniusNorm(matrix) { - let norm = 0; - for (let i = 0; i < 3; ++i) { - const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]; - norm += 2 * temp * temp; - } - return Math.sqrt(norm); -} -function shurDecomposition(matrix, result) { - const tolerance = math_utils_exports3.EPSILON15; - let maxDiagonal = 0; - let rotAxis = 1; - for (let i = 0; i < 3; ++i) { - const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]); - if (temp > maxDiagonal) { - rotAxis = i; - maxDiagonal = temp; - } - } - const p = rowVal[rotAxis]; - const q = colVal[rotAxis]; - let c = 1; - let s = 0; - if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) { - const qq = matrix[scratchMatrix.getElementIndex(q, q)]; - const pp = matrix[scratchMatrix.getElementIndex(p, p)]; - const qp = matrix[scratchMatrix.getElementIndex(q, p)]; - const tau = (qq - pp) / 2 / qp; - let t; - if (tau < 0) { - t = -1 / (-tau + Math.sqrt(1 + tau * tau)); - } else { - t = 1 / (tau + Math.sqrt(1 + tau * tau)); - } - c = 1 / Math.sqrt(1 + t * t); - s = t * c; - } - Matrix3.IDENTITY.to(result); - result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c; - result[scratchMatrix.getElementIndex(q, p)] = s; - result[scratchMatrix.getElementIndex(p, q)] = -s; - return result; -} - -// node_modules/@math.gl/culling/dist/lib/algorithms/bounding-box-from-points.js -var scratchVector23 = new Vector32(); -var scratchVector33 = new Vector32(); -var scratchVector4 = new Vector32(); -var scratchVector5 = new Vector32(); -var scratchVector6 = new Vector32(); -var scratchCovarianceResult = new Matrix3(); -var scratchEigenResult = { - diagonal: new Matrix3(), - unitary: new Matrix3() -}; -function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) { - if (!positions || positions.length === 0) { - result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); - result.center = new Vector32(); - return result; - } - const length10 = positions.length; - const meanPoint = new Vector32(0, 0, 0); - for (const position of positions) { - meanPoint.add(position); - } - const invLength = 1 / length10; - meanPoint.multiplyByScalar(invLength); - let exx = 0; - let exy = 0; - let exz = 0; - let eyy = 0; - let eyz = 0; - let ezz = 0; - for (const position of positions) { - const p = scratchVector23.copy(position).subtract(meanPoint); - exx += p.x * p.x; - exy += p.x * p.y; - exz += p.x * p.z; - eyy += p.y * p.y; - eyz += p.y * p.z; - ezz += p.z * p.z; - } - exx *= invLength; - exy *= invLength; - exz *= invLength; - eyy *= invLength; - eyz *= invLength; - ezz *= invLength; - const covarianceMatrix = scratchCovarianceResult; - covarianceMatrix[0] = exx; - covarianceMatrix[1] = exy; - covarianceMatrix[2] = exz; - covarianceMatrix[3] = exy; - covarianceMatrix[4] = eyy; - covarianceMatrix[5] = eyz; - covarianceMatrix[6] = exz; - covarianceMatrix[7] = eyz; - covarianceMatrix[8] = ezz; - const { unitary } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult); - const rotation = result.halfAxes.copy(unitary); - let v1 = rotation.getColumn(0, scratchVector4); - let v2 = rotation.getColumn(1, scratchVector5); - let v3 = rotation.getColumn(2, scratchVector6); - let u1 = -Number.MAX_VALUE; - let u2 = -Number.MAX_VALUE; - let u3 = -Number.MAX_VALUE; - let l1 = Number.MAX_VALUE; - let l2 = Number.MAX_VALUE; - let l3 = Number.MAX_VALUE; - for (const position of positions) { - scratchVector23.copy(position); - u1 = Math.max(scratchVector23.dot(v1), u1); - u2 = Math.max(scratchVector23.dot(v2), u2); - u3 = Math.max(scratchVector23.dot(v3), u3); - l1 = Math.min(scratchVector23.dot(v1), l1); - l2 = Math.min(scratchVector23.dot(v2), l2); - l3 = Math.min(scratchVector23.dot(v3), l3); - } - v1 = v1.multiplyByScalar(0.5 * (l1 + u1)); - v2 = v2.multiplyByScalar(0.5 * (l2 + u2)); - v3 = v3.multiplyByScalar(0.5 * (l3 + u3)); - result.center.copy(v1).add(v2).add(v3); - const scale13 = scratchVector33.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5); - const scaleMatrix = new Matrix3([scale13[0], 0, 0, 0, scale13[1], 0, 0, 0, scale13[2]]); - result.halfAxes.multiplyRight(scaleMatrix); - return result; -} - -// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tile-2d-traversal.js -var TILE_SIZE3 = 512; -var MAX_MAPS = 3; -var REF_POINTS_5 = [ - [0.5, 0.5], - [0, 0], - [0, 1], - [1, 0], - [1, 1] -]; -var REF_POINTS_9 = REF_POINTS_5.concat([ - [0, 0.5], - [0.5, 0], - [1, 0.5], - [0.5, 1] -]); -var REF_POINTS_11 = REF_POINTS_9.concat([ - [0.25, 0.5], - [0.75, 0.5] -]); -var OSMNode = class _OSMNode { - constructor(x, y, z) { - this.x = x; - this.y = y; - this.z = z; - } - get children() { - if (!this._children) { - const x = this.x * 2; - const y = this.y * 2; - const z = this.z + 1; - this._children = [ - new _OSMNode(x, y, z), - new _OSMNode(x, y + 1, z), - new _OSMNode(x + 1, y, z), - new _OSMNode(x + 1, y + 1, z) - ]; - } - return this._children; - } - // eslint-disable-next-line complexity - update(params) { - const { viewport, cullingVolume, elevationBounds, minZ, maxZ, bounds, offset, project } = params; - const boundingVolume = this.getBoundingVolume(elevationBounds, offset, project); - if (bounds && !this.insideBounds(bounds)) { - return false; - } - const isInside = cullingVolume.computeVisibility(boundingVolume); - if (isInside < 0) { - return false; - } - if (!this.childVisible) { - let { z } = this; - if (z < maxZ && z >= minZ) { - const distance8 = boundingVolume.distanceTo(viewport.cameraPosition) * viewport.scale / viewport.height; - z += Math.floor(Math.log2(distance8)); - } - if (z >= maxZ) { - this.selected = true; - return true; - } - } - this.selected = false; - this.childVisible = true; - for (const child of this.children) { - child.update(params); - } - return true; - } - getSelected(result = []) { - if (this.selected) { - result.push(this); - } - if (this._children) { - for (const node of this._children) { - node.getSelected(result); - } - } - return result; - } - insideBounds([minX, minY, maxX, maxY]) { - const scale13 = Math.pow(2, this.z); - const extent = TILE_SIZE3 / scale13; - return this.x * extent < maxX && this.y * extent < maxY && (this.x + 1) * extent > minX && (this.y + 1) * extent > minY; - } - getBoundingVolume(zRange, worldOffset, project) { - if (project) { - const refPoints = this.z < 1 ? REF_POINTS_11 : this.z < 2 ? REF_POINTS_9 : REF_POINTS_5; - const refPointPositions = []; - for (const p of refPoints) { - const lngLat = osmTile2lngLat(this.x + p[0], this.y + p[1], this.z); - lngLat[2] = zRange[0]; - refPointPositions.push(project(lngLat)); - if (zRange[0] !== zRange[1]) { - lngLat[2] = zRange[1]; - refPointPositions.push(project(lngLat)); - } - } - return makeOrientedBoundingBoxFromPoints(refPointPositions); - } - const scale13 = Math.pow(2, this.z); - const extent = TILE_SIZE3 / scale13; - const originX = this.x * extent + worldOffset * TILE_SIZE3; - const originY = TILE_SIZE3 - (this.y + 1) * extent; - return new AxisAlignedBoundingBox([originX, originY, zRange[0]], [originX + extent, originY + extent, zRange[1]]); - } -}; -function getOSMTileIndices(viewport, maxZ, zRange, bounds) { - const project = viewport instanceof GlobeViewport && viewport.resolution ? ( - // eslint-disable-next-line @typescript-eslint/unbound-method - viewport.projectPosition - ) : null; - const planes = Object.values(viewport.getFrustumPlanes()).map(({ normal, distance: distance8 }) => new Plane(normal.clone().negate(), distance8)); - const cullingVolume = new CullingVolume(planes); - const unitsPerMeter2 = viewport.distanceScales.unitsPerMeter[2]; - const elevationMin = zRange && zRange[0] * unitsPerMeter2 || 0; - const elevationMax = zRange && zRange[1] * unitsPerMeter2 || 0; - const minZ = viewport instanceof web_mercator_viewport_default && viewport.pitch <= 60 ? maxZ : 0; - if (bounds) { - const [minLng, minLat, maxLng, maxLat] = bounds; - const topLeft = lngLatToWorld([minLng, maxLat]); - const bottomRight = lngLatToWorld([maxLng, minLat]); - bounds = [topLeft[0], TILE_SIZE3 - topLeft[1], bottomRight[0], TILE_SIZE3 - bottomRight[1]]; - } - const root = new OSMNode(0, 0, 0); - const traversalParams = { - viewport, - project, - cullingVolume, - elevationBounds: [elevationMin, elevationMax], - minZ, - maxZ, - bounds, - // num. of worlds from the center. For repeated maps - offset: 0 - }; - root.update(traversalParams); - if (viewport instanceof web_mercator_viewport_default && viewport.subViewports && viewport.subViewports.length > 1) { - traversalParams.offset = -1; - while (root.update(traversalParams)) { - if (--traversalParams.offset < -MAX_MAPS) { - break; - } - } - traversalParams.offset = 1; - while (root.update(traversalParams)) { - if (++traversalParams.offset > MAX_MAPS) { - break; - } - } - } - return root.getSelected(); -} - -// node_modules/@deck.gl/geo-layers/dist/tileset-2d/utils.js -var TILE_SIZE4 = 512; -var DEFAULT_EXTENT = [-Infinity, -Infinity, Infinity, Infinity]; -var urlType = { - type: "object", - value: null, - validate: (value, propType) => propType.optional && value === null || typeof value === "string" || Array.isArray(value) && value.every((url) => typeof url === "string"), - equal: (value1, value2) => { - if (value1 === value2) { - return true; - } - if (!Array.isArray(value1) || !Array.isArray(value2)) { - return false; - } - const len8 = value1.length; - if (len8 !== value2.length) { - return false; - } - for (let i = 0; i < len8; i++) { - if (value1[i] !== value2[i]) { - return false; - } - } - return true; - } -}; -function transformBox(bbox, modelMatrix) { - const transformedCoords = [ - // top-left - modelMatrix.transformAsPoint([bbox[0], bbox[1]]), - // top-right - modelMatrix.transformAsPoint([bbox[2], bbox[1]]), - // bottom-left - modelMatrix.transformAsPoint([bbox[0], bbox[3]]), - // bottom-right - modelMatrix.transformAsPoint([bbox[2], bbox[3]]) - ]; - const transformedBox = [ - // Minimum x coord - Math.min(...transformedCoords.map((i) => i[0])), - // Minimum y coord - Math.min(...transformedCoords.map((i) => i[1])), - // Max x coord - Math.max(...transformedCoords.map((i) => i[0])), - // Max y coord - Math.max(...transformedCoords.map((i) => i[1])) - ]; - return transformedBox; -} -function stringHash(s) { - return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0)); -} -function getURLFromTemplate(template, tile) { - if (!template || !template.length) { - return null; - } - const { index: index2, id } = tile; - if (Array.isArray(template)) { - const i = stringHash(id) % template.length; - template = template[i]; - } - let url = template; - for (const key of Object.keys(index2)) { - const regex = new RegExp(`{${key}}`, "g"); - url = url.replace(regex, String(index2[key])); - } - if (Number.isInteger(index2.y) && Number.isInteger(index2.z)) { - url = url.replace(/\{-y\}/g, String(Math.pow(2, index2.z) - index2.y - 1)); - } - return url; -} -function getBoundingBox2(viewport, zRange, extent) { - let bounds; - if (zRange && zRange.length === 2) { - const [minZ, maxZ] = zRange; - const bounds0 = viewport.getBounds({ z: minZ }); - const bounds1 = viewport.getBounds({ z: maxZ }); - bounds = [ - Math.min(bounds0[0], bounds1[0]), - Math.min(bounds0[1], bounds1[1]), - Math.max(bounds0[2], bounds1[2]), - Math.max(bounds0[3], bounds1[3]) - ]; - } else { - bounds = viewport.getBounds(); - } - if (!viewport.isGeospatial) { - return [ - // Top corner should not be more then bottom corner in either direction - Math.max(Math.min(bounds[0], extent[2]), extent[0]), - Math.max(Math.min(bounds[1], extent[3]), extent[1]), - // Bottom corner should not be less then top corner in either direction - Math.min(Math.max(bounds[2], extent[0]), extent[2]), - Math.min(Math.max(bounds[3], extent[1]), extent[3]) - ]; - } - return [ - Math.max(bounds[0], extent[0]), - Math.max(bounds[1], extent[1]), - Math.min(bounds[2], extent[2]), - Math.min(bounds[3], extent[3]) - ]; -} -function getCullBounds({ viewport, z, cullRect }) { - const subViewports = viewport.subViewports || [viewport]; - return subViewports.map((v) => getCullBoundsInViewport(v, z || 0, cullRect)); -} -function getCullBoundsInViewport(viewport, z, cullRect) { - if (!Array.isArray(z)) { - const x = cullRect.x - viewport.x; - const y = cullRect.y - viewport.y; - const { width, height } = cullRect; - const unprojectOption = { targetZ: z }; - const topLeft = viewport.unproject([x, y], unprojectOption); - const topRight = viewport.unproject([x + width, y], unprojectOption); - const bottomLeft = viewport.unproject([x, y + height], unprojectOption); - const bottomRight = viewport.unproject([x + width, y + height], unprojectOption); - return [ - Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), - Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), - Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), - Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]) - ]; - } - const bounds0 = getCullBoundsInViewport(viewport, z[0], cullRect); - const bounds1 = getCullBoundsInViewport(viewport, z[1], cullRect); - return [ - Math.min(bounds0[0], bounds1[0]), - Math.min(bounds0[1], bounds1[1]), - Math.max(bounds0[2], bounds1[2]), - Math.max(bounds0[3], bounds1[3]) - ]; -} -function getIndexingCoords(bbox, scale13, modelMatrixInverse) { - if (modelMatrixInverse) { - const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map((i) => i * scale13 / TILE_SIZE4); - return transformedTileIndex; - } - return bbox.map((i) => i * scale13 / TILE_SIZE4); -} -function getScale(z, tileSize) { - return Math.pow(2, z) * TILE_SIZE4 / tileSize; -} -function osmTile2lngLat(x, y, z) { - const scale13 = getScale(z, TILE_SIZE4); - const lng = x / scale13 * 360 - 180; - const n = Math.PI - 2 * Math.PI * y / scale13; - const lat = 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))); - return [lng, lat]; -} -function tile2XY(x, y, z, tileSize) { - const scale13 = getScale(z, tileSize); - return [x / scale13 * TILE_SIZE4, y / scale13 * TILE_SIZE4]; -} -function tileToBoundingBox(viewport, x, y, z, tileSize = TILE_SIZE4) { - if (viewport.isGeospatial) { - const [west, north] = osmTile2lngLat(x, y, z); - const [east, south] = osmTile2lngLat(x + 1, y + 1, z); - return { west, north, east, south }; - } - const [left, top] = tile2XY(x, y, z, tileSize); - const [right, bottom] = tile2XY(x + 1, y + 1, z, tileSize); - return { left, top, right, bottom }; -} -function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInverse) { - const bbox = getBoundingBox2(viewport, null, extent); - const scale13 = getScale(z, tileSize); - const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale13, modelMatrixInverse); - const indices = []; - for (let x = Math.floor(minX); x < maxX; x++) { - for (let y = Math.floor(minY); y < maxY; y++) { - indices.push({ x, y, z }); - } - } - return indices; -} -function getTileIndices({ viewport, maxZoom, minZoom, zRange, extent, tileSize = TILE_SIZE4, modelMatrix, modelMatrixInverse, zoomOffset = 0 }) { - let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset; - if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) { - if (!extent) { - return []; - } - z = minZoom; - } - if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) { - z = maxZoom; - } - let transformedExtent = extent; - if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) { - transformedExtent = transformBox(extent, modelMatrix); - } - return viewport.isGeospatial ? getOSMTileIndices(viewport, z, zRange, extent) : getIdentityTileIndices(viewport, z, tileSize, transformedExtent || DEFAULT_EXTENT, modelMatrixInverse); -} - -// node_modules/@deck.gl/geo-layers/dist/tileset-2d/memoize.js -function memoize2(compute) { - let cachedArgs = {}; - let cachedResult; - return (args) => { - for (const key in args) { - if (!isEqual2(args[key], cachedArgs[key])) { - cachedResult = compute(args); - cachedArgs = args; - break; - } - } - return cachedResult; - }; -} -function isEqual2(a, b) { - if (a === b) { - return true; - } - if (Array.isArray(a)) { - const len8 = a.length; - if (!b || b.length !== len8) { - return false; - } - for (let i = 0; i < len8; i++) { - if (a[i] !== b[i]) { - return false; - } - } - return true; - } - return false; -} - -// node_modules/@deck.gl/geo-layers/dist/tileset-2d/tileset-2d.js -var TILE_STATE_VISITED = 1; -var TILE_STATE_VISIBLE = 2; -var STRATEGY_NEVER = "never"; -var STRATEGY_REPLACE = "no-overlap"; -var STRATEGY_DEFAULT = "best-available"; -var DEFAULT_CACHE_SCALE = 5; -var STRATEGIES = { - [STRATEGY_DEFAULT]: updateTileStateDefault, - [STRATEGY_REPLACE]: updateTileStateReplace, - [STRATEGY_NEVER]: () => { - } -}; -var DEFAULT_TILESET2D_PROPS = { - extent: null, - tileSize: 512, - maxZoom: null, - minZoom: null, - maxCacheSize: null, - maxCacheByteSize: null, - refinementStrategy: "best-available", - zRange: null, - maxRequests: 6, - debounceTime: 0, - zoomOffset: 0, - // onTileLoad: (tile: Tile2DHeader) => void, // onTileUnload: (tile: Tile2DHeader) => void, // onTileError: (error: any, tile: Tile2DHeader) => void, /** Called when all tiles in the current viewport are loaded. */ - // onViewportLoad: ((tiles: Tile2DHeader[]) => void) | null, - onTileLoad: () => { - }, - onTileUnload: () => { - }, - onTileError: () => { - } -}; -var Tileset2D = class { - /** - * Takes in a function that returns tile data, a cache size, and a max and a min zoom level. - * Cache size defaults to 5 * number of tiles in the current viewport - */ - constructor(opts) { - this._getCullBounds = memoize2(getCullBounds); - this.opts = { ...DEFAULT_TILESET2D_PROPS, ...opts }; - this.setOptions(this.opts); - this.onTileLoad = (tile) => { - this.opts.onTileLoad?.(tile); - if (this.opts.maxCacheByteSize != null) { - this._cacheByteSize += tile.byteLength; - this._resizeCache(); - } - }; - this._requestScheduler = new RequestScheduler({ - throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0, - maxRequests: this.opts.maxRequests, - debounceTime: this.opts.debounceTime - }); - this._cache = /* @__PURE__ */ new Map(); - this._tiles = []; - this._dirty = false; - this._cacheByteSize = 0; - this._viewport = null; - this._zRange = null; - this._selectedTiles = null; - this._frameNumber = 0; - this._modelMatrix = new Matrix4(); - this._modelMatrixInverse = new Matrix4(); - } - /* Public API */ - get tiles() { - return this._tiles; - } - get selectedTiles() { - return this._selectedTiles; - } - get isLoaded() { - return this._selectedTiles !== null && this._selectedTiles.every((tile) => tile.isLoaded); - } - get needsReload() { - return this._selectedTiles !== null && this._selectedTiles.some((tile) => tile.needsReload); - } - setOptions(opts) { - Object.assign(this.opts, opts); - if (Number.isFinite(opts.maxZoom)) { - this._maxZoom = Math.floor(opts.maxZoom); - } - if (Number.isFinite(opts.minZoom)) { - this._minZoom = Math.ceil(opts.minZoom); - } - } - // Clean up any outstanding tile requests. - finalize() { - for (const tile of this._cache.values()) { - if (tile.isLoading) { - tile.abort(); - } - } - this._cache.clear(); - this._tiles = []; - this._selectedTiles = null; - } - reloadAll() { - for (const id of this._cache.keys()) { - const tile = this._cache.get(id); - if (!this._selectedTiles || !this._selectedTiles.includes(tile)) { - this._cache.delete(id); - } else { - tile.setNeedsReload(); - } - } - } - /** - * Update the cache with the given viewport and model matrix and triggers callback onUpdate. - */ - update(viewport, { zRange, modelMatrix } = { - zRange: null, - modelMatrix: null - }) { - const modelMatrixAsMatrix4 = modelMatrix ? new Matrix4(modelMatrix) : new Matrix4(); - const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix); - if (!this._viewport || !viewport.equals(this._viewport) || !equals(this._zRange, zRange) || isModelMatrixNew) { - if (isModelMatrixNew) { - this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert(); - this._modelMatrix = modelMatrixAsMatrix4; - } - this._viewport = viewport; - this._zRange = zRange; - const tileIndices = this.getTileIndices({ - viewport, - maxZoom: this._maxZoom, - minZoom: this._minZoom, - zRange, - modelMatrix: this._modelMatrix, - modelMatrixInverse: this._modelMatrixInverse - }); - this._selectedTiles = tileIndices.map((index2) => this._getTile(index2, true)); - if (this._dirty) { - this._rebuildTree(); - } - } else if (this.needsReload) { - this._selectedTiles = this._selectedTiles.map((tile) => this._getTile(tile.index, true)); - } - const changed = this.updateTileStates(); - this._pruneRequests(); - if (this._dirty) { - this._resizeCache(); - } - if (changed) { - this._frameNumber++; - } - return this._frameNumber; - } - // eslint-disable-next-line complexity - isTileVisible(tile, cullRect) { - if (!tile.isVisible) { - return false; - } - if (cullRect && this._viewport) { - const boundsArr = this._getCullBounds({ - viewport: this._viewport, - z: this._zRange, - cullRect - }); - const { bbox } = tile; - for (const [minX, minY, maxX, maxY] of boundsArr) { - let overlaps; - if ("west" in bbox) { - overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY; - } else { - const y0 = Math.min(bbox.top, bbox.bottom); - const y1 = Math.max(bbox.top, bbox.bottom); - overlaps = bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY; - } - if (overlaps) { - return true; - } - } - return false; - } - return true; - } - /* Public interface for subclassing */ - /** Returns array of tile indices in the current viewport */ - getTileIndices({ viewport, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) { - const { tileSize, extent, zoomOffset } = this.opts; - return getTileIndices({ - viewport, - maxZoom, - minZoom, - zRange, - tileSize, - extent, - modelMatrix, - modelMatrixInverse, - zoomOffset - }); - } - /** Returns unique string key for a tile index */ - getTileId(index2) { - return `${index2.x}-${index2.y}-${index2.z}`; - } - /** Returns a zoom level for a tile index */ - getTileZoom(index2) { - return index2.z; - } - /** Returns additional metadata to add to tile, bbox by default */ - getTileMetadata(index2) { - const { tileSize } = this.opts; - return { bbox: tileToBoundingBox(this._viewport, index2.x, index2.y, index2.z, tileSize) }; - } - /** Returns index of the parent tile */ - getParentIndex(index2) { - const x = Math.floor(index2.x / 2); - const y = Math.floor(index2.y / 2); - const z = index2.z - 1; - return { x, y, z }; - } - // Returns true if any tile's visibility changed - updateTileStates() { - const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT; - const visibilities = new Array(this._cache.size); - let i = 0; - for (const tile of this._cache.values()) { - visibilities[i++] = tile.isVisible; - tile.isSelected = false; - tile.isVisible = false; - } - for (const tile of this._selectedTiles) { - tile.isSelected = true; - tile.isVisible = true; - } - (typeof refinementStrategy === "function" ? refinementStrategy : STRATEGIES[refinementStrategy])(Array.from(this._cache.values())); - i = 0; - for (const tile of this._cache.values()) { - if (visibilities[i++] !== tile.isVisible) { - return true; - } - } - return false; - } - _pruneRequests() { - const { maxRequests = 0 } = this.opts; - const abortCandidates = []; - let ongoingRequestCount = 0; - for (const tile of this._cache.values()) { - if (tile.isLoading) { - ongoingRequestCount++; - if (!tile.isSelected && !tile.isVisible) { - abortCandidates.push(tile); - } - } - } - while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) { - const tile = abortCandidates.shift(); - tile.abort(); - ongoingRequestCount--; - } - } - // This needs to be called every time some tiles have been added/removed from cache - _rebuildTree() { - const { _cache } = this; - for (const tile of _cache.values()) { - tile.parent = null; - if (tile.children) { - tile.children.length = 0; - } - } - for (const tile of _cache.values()) { - const parent = this._getNearestAncestor(tile); - tile.parent = parent; - if (parent?.children) { - parent.children.push(tile); - } - } - } - /** - * Clear tiles that are not visible when the cache is full - */ - /* eslint-disable complexity */ - _resizeCache() { - const { _cache, opts } = this; - const maxCacheSize = opts.maxCacheSize ?? // @ts-expect-error called only when selectedTiles is initialized - (opts.maxCacheByteSize != null ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length); - const maxCacheByteSize = opts.maxCacheByteSize ?? Infinity; - const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize; - if (overflown) { - for (const [id, tile] of _cache) { - if (!tile.isVisible && !tile.isSelected) { - this._cacheByteSize -= opts.maxCacheByteSize != null ? tile.byteLength : 0; - _cache.delete(id); - this.opts.onTileUnload?.(tile); - } - if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) { - break; - } - } - this._rebuildTree(); - this._dirty = true; - } - if (this._dirty) { - this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom); - this._dirty = false; - } - } - _getTile(index2, create15) { - const id = this.getTileId(index2); - let tile = this._cache.get(id); - let needsReload = false; - if (!tile && create15) { - tile = new Tile2DHeader(index2); - Object.assign(tile, this.getTileMetadata(tile.index)); - Object.assign(tile, { id, zoom: this.getTileZoom(tile.index) }); - needsReload = true; - this._cache.set(id, tile); - this._dirty = true; - } else if (tile && tile.needsReload) { - needsReload = true; - } - if (tile && needsReload) { - tile.loadData({ - getData: this.opts.getTileData, - requestScheduler: this._requestScheduler, - onLoad: this.onTileLoad, - onError: this.opts.onTileError - }); - } - return tile; - } - _getNearestAncestor(tile) { - const { _minZoom = 0 } = this; - let index2 = tile.index; - while (this.getTileZoom(index2) > _minZoom) { - index2 = this.getParentIndex(index2); - const parent = this._getTile(index2); - if (parent) { - return parent; - } - } - return null; - } -}; -function updateTileStateDefault(allTiles) { - for (const tile of allTiles) { - tile.state = 0; - } - for (const tile of allTiles) { - if (tile.isSelected && !getPlaceholderInAncestors(tile)) { - getPlaceholderInChildren(tile); - } - } - for (const tile of allTiles) { - tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); - } -} -function updateTileStateReplace(allTiles) { - for (const tile of allTiles) { - tile.state = 0; - } - for (const tile of allTiles) { - if (tile.isSelected) { - getPlaceholderInAncestors(tile); - } - } - const sortedTiles = Array.from(allTiles).sort((t1, t2) => t1.zoom - t2.zoom); - for (const tile of sortedTiles) { - tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); - if (tile.children && (tile.isVisible || tile.state & TILE_STATE_VISITED)) { - for (const child of tile.children) { - child.state = TILE_STATE_VISITED; - } - } else if (tile.isSelected) { - getPlaceholderInChildren(tile); - } - } -} -function getPlaceholderInAncestors(startTile) { - let tile = startTile; - while (tile) { - if (tile.isLoaded || tile.content) { - tile.state |= TILE_STATE_VISIBLE; - return true; - } - tile = tile.parent; - } - return false; -} -function getPlaceholderInChildren(tile) { - for (const child of tile.children) { - if (child.isLoaded || child.content) { - child.state |= TILE_STATE_VISIBLE; - } else { - getPlaceholderInChildren(child); - } - } -} - -// node_modules/@deck.gl/geo-layers/dist/tile-layer/tile-layer.js -var defaultProps13 = { - TilesetClass: Tileset2D, - data: { type: "data", value: [] }, - dataComparator: urlType.equal, - renderSubLayers: { type: "function", value: (props) => new geojson_layer_default(props) }, - getTileData: { type: "function", optional: true, value: null }, - // TODO - change to onViewportLoad to align with Tile3DLayer - onViewportLoad: { type: "function", optional: true, value: null }, - onTileLoad: { type: "function", value: (tile) => { - } }, - onTileUnload: { type: "function", value: (tile) => { - } }, - // eslint-disable-next-line - onTileError: { type: "function", value: (err) => console.error(err) }, - extent: { type: "array", optional: true, value: null, compare: true }, - tileSize: 512, - maxZoom: null, - minZoom: 0, - maxCacheSize: null, - maxCacheByteSize: null, - refinementStrategy: STRATEGY_DEFAULT, - zRange: null, - maxRequests: 6, - debounceTime: 0, - zoomOffset: 0 -}; -var TileLayer = class extends composite_layer_default { - initializeState() { - this.state = { - tileset: null, - isLoaded: false - }; - } - finalizeState() { - this.state?.tileset?.finalize(); - } - get isLoaded() { - return Boolean(this.state?.tileset?.selectedTiles?.every((tile) => tile.isLoaded && tile.layers && tile.layers.every((layer) => layer.isLoaded))); - } - shouldUpdateState({ changeFlags }) { - return changeFlags.somethingChanged; - } - updateState({ changeFlags }) { - let { tileset } = this.state; - const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged; - const dataChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData); - if (!tileset) { - tileset = new this.props.TilesetClass(this._getTilesetOptions()); - this.setState({ tileset }); - } else if (propsChanged) { - tileset.setOptions(this._getTilesetOptions()); - if (dataChanged) { - tileset.reloadAll(); - } else { - tileset.tiles.forEach((tile) => { - tile.layers = null; - }); - } - } - this._updateTileset(); - } - _getTilesetOptions() { - const { tileSize, maxCacheSize, maxCacheByteSize, refinementStrategy, extent, maxZoom, minZoom, maxRequests, debounceTime, zoomOffset } = this.props; - return { - maxCacheSize, - maxCacheByteSize, - maxZoom, - minZoom, - tileSize, - refinementStrategy, - extent, - maxRequests, - debounceTime, - zoomOffset, - getTileData: this.getTileData.bind(this), - onTileLoad: this._onTileLoad.bind(this), - onTileError: this._onTileError.bind(this), - onTileUnload: this._onTileUnload.bind(this) - }; - } - _updateTileset() { - const tileset = this.state.tileset; - const { zRange, modelMatrix } = this.props; - const frameNumber = tileset.update(this.context.viewport, { zRange, modelMatrix }); - const { isLoaded } = tileset; - const loadingStateChanged = this.state.isLoaded !== isLoaded; - const tilesetChanged = this.state.frameNumber !== frameNumber; - if (isLoaded && (loadingStateChanged || tilesetChanged)) { - this._onViewportLoad(); - } - if (tilesetChanged) { - this.setState({ frameNumber }); - } - this.state.isLoaded = isLoaded; - } - _onViewportLoad() { - const { tileset } = this.state; - const { onViewportLoad } = this.props; - if (onViewportLoad) { - onViewportLoad(tileset.selectedTiles); - } - } - _onTileLoad(tile) { - this.props.onTileLoad(tile); - tile.layers = null; - this.setNeedsUpdate(); - } - _onTileError(error, tile) { - this.props.onTileError(error); - tile.layers = null; - this.setNeedsUpdate(); - } - _onTileUnload(tile) { - this.props.onTileUnload(tile); - } - // Methods for subclass to override - getTileData(tile) { - const { data, getTileData, fetch: fetch2 } = this.props; - const { signal } = tile; - tile.url = typeof data === "string" || Array.isArray(data) ? getURLFromTemplate(data, tile) : null; - if (getTileData) { - return getTileData(tile); - } - if (fetch2 && tile.url) { - return fetch2(tile.url, { propName: "data", layer: this, signal }); - } - return null; - } - renderSubLayers(props) { - return this.props.renderSubLayers(props); - } - getSubLayerPropsByTile(tile) { - return null; - } - getPickingInfo(params) { - const sourceLayer = params.sourceLayer; - const sourceTile = sourceLayer.props.tile; - const info = params.info; - if (info.picked) { - info.tile = sourceTile; - } - info.sourceTile = sourceTile; - info.sourceTileSubLayer = sourceLayer; - return info; - } - _updateAutoHighlight(info) { - info.sourceTileSubLayer.updateAutoHighlight(info); - } - renderLayers() { - return this.state.tileset.tiles.map((tile) => { - const subLayerProps = this.getSubLayerPropsByTile(tile); - if (!tile.isLoaded && !tile.content) { - } else if (!tile.layers) { - const layers = this.renderSubLayers({ - ...this.props, - ...this.getSubLayerProps({ - id: tile.id, - updateTriggers: this.props.updateTriggers - }), - data: tile.content, - _offset: 0, - tile - }); - tile.layers = flatten(layers, Boolean).map((layer) => layer.clone({ - tile, - ...subLayerProps - })); - } else if (subLayerProps && tile.layers[0] && Object.keys(subLayerProps).some((propName) => tile.layers[0].props[propName] !== subLayerProps[propName])) { - tile.layers = tile.layers.map((layer) => layer.clone(subLayerProps)); - } - return tile.layers; - }); - } - filterSubLayer({ layer, cullRect }) { - const { tile } = layer.props; - return this.state.tileset.isTileVisible(tile, cullRect); - } -}; -TileLayer.defaultProps = defaultProps13; -TileLayer.layerName = "TileLayer"; -var tile_layer_default = TileLayer; - -// notebooks/bike_flow_map_widget.mjs -var Observable = (initialValue) => { - let value = initialValue; - const subscribers = /* @__PURE__ */ new Set(); - return { - get: () => value, - set: (newValue) => { - if (value === newValue) - return; - value = newValue; - subscribers.forEach((fn) => fn(value)); - }, - subscribe: (fn, options = { immediate: true }) => { - subscribers.add(fn); - if (options.immediate) - fn(value); - return () => subscribers.delete(fn); - } - }; -}; -var createStore = () => ({ - stations: Observable([]), - edge_index: Observable({}), - click_info: Observable({}), - selected_rows: Observable([]), - selected_cols: Observable([]), - width: Observable(560), - height: Observable(800), - debug: Observable(false), - focus: Observable(""), - highlights: Observable([]), - edges: Observable([]), - deck_check: Observable({ inputs: true, computed: true, layers: true }), - deck_ready: Observable(false), - palette_rgb: Observable([]), - matrix_axis_slice: Observable({}) -}); -var log3 = (store, ...args) => { - if (store.debug.get()) - console.log("[bike-map]", ...args); -}; -var MAP_STATION_SLICE_TOP_K = 25; -function pushRowColMatrixSliceRequest(model, rowIndex, colIndex) { - if (!model?.set) - return; - const req_id = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `r${Date.now()}-${Math.random().toString(16).slice(2)}`; - model.set("matrix_slice_request_out", {}); - model.set("matrix_slice_request_out", { - req_id, - op: "row_col", - row_index: Number(rowIndex), - col_index: Number(colIndex), - max_entries: MAP_STATION_SLICE_TOP_K - }); - model.save_changes(); -} -function findAxisIndex(names, raw) { - const want = String(raw || "").trim(); - if (!want || !Array.isArray(names)) - return -1; - let i = names.findIndex((x) => String(x).trim() === want); - if (i >= 0) - return i; - if (want.includes("|")) { - const rhs = want.split("|", 2)[1].trim(); - i = names.findIndex((x) => String(x).trim() === rhs); - if (i >= 0) - return i; - } - return -1; -} -var sameList = (a, b) => { - if (!Array.isArray(a) || !Array.isArray(b)) - return false; - if (a.length !== b.length) - return false; - for (let i = 0; i < a.length; i += 1) - if (a[i] !== b[i]) - return false; - return true; -}; -var setDerivedState = (store, { focus, highlights, edges }) => { - const curFocus = store.focus.get() || ""; - const curHighlights = store.highlights.get() || []; - const curEdges = store.edges.get() || []; - const nextFocus = focus || ""; - const nextHighlights = highlights || []; - const nextEdges = edges || []; - let changed = false; - if (curFocus !== nextFocus) { - store.focus.set(nextFocus); - changed = true; - } - if (!sameList(curHighlights, nextHighlights)) { - store.highlights.set(nextHighlights); - changed = true; - } - const curStr = JSON.stringify(curEdges); - const nextStr = JSON.stringify(nextEdges); - if (curStr !== nextStr) { - store.edges.set(nextEdges); - changed = true; - } - return changed; -}; -function basemapLayer() { - return new tile_layer_default({ - id: "bike-basemap", - data: "https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png", - minZoom: 0, - maxZoom: 19, - tileSize: 256, - renderSubLayers: (props) => { - if (!props.data || !props.tile) - return null; - let west; - let south; - let east; - let north; - const bb = props.tile.boundingBox; - if (bb && bb.length === 2) { - [[west, south], [east, north]] = bb; - } else if (props.tile.bbox && "west" in props.tile.bbox) { - ({ west, south, east, north } = props.tile.bbox); - } else { - return null; - } - return new bitmap_layer_default(props, { - id: `${props.id}-bitmap`, - data: [0], - image: props.data, - bounds: [west, south, east, north] - }); - } - }); -} -var STATION_PALETTE_HEX = [ - "#E69F00", - "#56B4E9", - "#009E73", - "#F0E442", - "#0072B2", - "#D55E00", - "#CC79A7", - "#393b79", - "#aec7e8", - "#ff7f0e", - "#ffbb78", - "#98df8a", - "#bcbd22", - "#404040", - "#ff9896", - "#c5b0d5", - "#8c5648", - "#1f77b4", - "#5254a3", - "#FFDB58", - "#c49c94", - "#e377c2", - "#7f7f7f", - "#2ca02c", - "#9467bd", - "#dbdb8d", - "#17becf", - "#637939", - "#6b6ecf", - "#9c9ede", - "#d62728", - "#8ca252", - "#8c6d31", - "#bd9e39", - "#e7cb94", - "#843c39", - "#ad494a", - "#d6616b", - "#7b4173", - "#a55194", - "#ce6dbd", - "#de9ed6" -]; -function hexToRgb(hex) { - const h = String(hex).replace("#", ""); - if (h.length !== 6) - return [145, 150, 170]; - return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)]; -} -var DEFAULT_PALETTE_RGB = STATION_PALETTE_HEX.map(hexToRgb); -function resolvePaletteRgb(store) { - const raw = store.palette_rgb.get(); - if (Array.isArray(raw) && raw.length > 0) { - return raw.map((row) => { - if (Array.isArray(row) && row.length >= 3) { - return [Number(row[0]), Number(row[1]), Number(row[2])]; - } - return [145, 150, 170]; - }); - } - return DEFAULT_PALETTE_RGB; -} -var CLUSTER_UNKNOWN_RGB = [176, 180, 190]; -var TRAFFIC_UNCONNECTED_RGBA = [168, 172, 180, 118]; -function clusterRgbFromId(clusterId, paletteRgb) { - const id = Number(clusterId); - if (!Number.isFinite(id) || id <= 0) - return CLUSTER_UNKNOWN_RGB; - const pal = paletteRgb.length ? paletteRgb : DEFAULT_PALETTE_RGB; - const c = pal[(id - 1) % pal.length]; - return [c[0], c[1], c[2]]; -} -function clusterFillWithAlpha(clusterId, alpha, paletteRgb) { - const [r, g, b] = clusterRgbFromId(clusterId, paletteRgb); - return [r, g, b, alpha]; -} -function clusterFillColor(clusterId, paletteRgb) { - return clusterFillWithAlpha(clusterId, 228, paletteRgb); -} -var FLOW_OUT_RGB = [255, 70, 70]; -var FLOW_IN_RGB = [70, 150, 255]; -function flowBlendRgb(outW, inW) { - const o = Math.max(0, Number(outW) || 0); - const i = Math.max(0, Number(inW) || 0); - const sum = o + i; - if (sum <= 0) - return [145, 150, 170]; - const t = o / sum; - const lerp12 = (a, b, x) => Math.round(a + (b - a) * x); - return [ - lerp12(FLOW_IN_RGB[0], FLOW_OUT_RGB[0], t), - lerp12(FLOW_IN_RGB[1], FLOW_OUT_RGB[1], t), - lerp12(FLOW_IN_RGB[2], FLOW_OUT_RGB[2], t) - ]; -} -function flowBlendWithAlpha(outW, inW, alpha) { - const [r, g, b] = flowBlendRgb(outW, inW); - return [r, g, b, alpha]; -} -function fitViewState(stations) { - if (!stations.length) - return { longitude: -73.98, latitude: 40.75, zoom: 10.5, pitch: 0, bearing: 0 }; - let minLat = Infinity; - let maxLat = -Infinity; - let minLng = Infinity; - let maxLng = -Infinity; - for (const s of stations) { - const lat = Number(s.lat); - const lng = Number(s.lng); - if (!Number.isFinite(lat) || !Number.isFinite(lng)) - continue; - minLat = Math.min(minLat, lat); - maxLat = Math.max(maxLat, lat); - minLng = Math.min(minLng, lng); - maxLng = Math.max(maxLng, lng); - } - const latitude = (minLat + maxLat) / 2; - const longitude = (minLng + maxLng) / 2; - const span = Math.max(maxLat - minLat, maxLng - minLng, 0.02); - const zoom = Math.min(14, Math.max(9, 12 - Math.log2(span * 80))); - return { latitude, longitude, zoom, pitch: 0, bearing: 0 }; -} -function render({ model, el }) { - const store = createStore(); - const root = document.createElement("div"); - root.style.background = "#e2e4e8"; - root.style.borderRadius = "4px"; - root.style.overflow = "hidden"; - el.appendChild(root); - let deck = null; - let raf = 0; - let renderVersion = 0; - let lastActionKey = null; - let lastActionSeq = -1; - let linkInteractionSeq = 0; - let linkSnap = { ci: "", rows: "", cols: "", sl: "" }; - const getLinkedWeights = () => { - const focus = store.focus.get(); - const out = /* @__PURE__ */ new Map(); - const inn = /* @__PURE__ */ new Map(); - if (!focus) - return { out, inn }; - for (const e of store.edges.get() || []) { - if (e.direction === "out" && e.source_name === focus) { - out.set(e.target_name, Number(e.weight) || 0); - } else if (e.direction === "in" && e.target_name === focus) { - inn.set(e.source_name, Number(e.weight) || 0); - } - } - return { out, inn }; - }; - const computeStateFromInputs = () => { - const info = store.click_info.get() || {}; - const t = String(info.type || "").replace("-", "_"); - const v = info.value || {}; - const idx = store.edge_index.get() || {}; - const seq = linkInteractionSeq; - log3(store, "compute start", t, "rows", (store.selected_rows.get() || []).length, "cols", (store.selected_cols.get() || []).length); - const setState = (focus, highlights, edges) => setDerivedState(store, { focus, highlights, edges }); - const stationFrom = (raw) => { - const txt = String(raw || "").trim(); - if (idx[txt]) - return txt; - if (txt.includes("|")) { - const rhs = txt.split("|", 2)[1].trim(); - if (idx[rhs]) - return rhs; - } - return txt; - }; - const coordMap = {}; - for (const s of store.stations.get() || []) { - const k = stationFrom(String(s.name || "")); - if (k && s.lng != null && s.lat != null) { - coordMap[k] = [Number(s.lng), Number(s.lat)]; - } - } - const acoord = (n) => n && idx[n]?.coord || (n ? coordMap[n] : void 0); - if (t === "row_label" || t === "col_label") { - const name2 = stationFrom(v.name); - const actionKey = `${t}:${name2}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState("", [], []); - lastActionKey = null; - lastActionSeq = seq; - log3(store, "label toggle off", t, name2); - return; - } - const sl = store.matrix_axis_slice.get() || {}; - const entries = sl.entries; - const rowAxis = t === "row_label" && sl.slice_kind === "row_axis"; - const colAxis = t === "col_label" && sl.slice_kind === "col_axis"; - if (Array.isArray(entries) && (rowAxis || colAxis)) { - const primary = stationFrom(sl.primary_name); - if (primary === name2 && entries.length) { - const edges2 = []; - for (const e of entries) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(other); - const ct = acoord(name2); - if (!other || !cs || !ct) - continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - if (rowAxis) { - edges2.push({ - source_name: other, - target_name: name2, - direction: "in", - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct - }); - } else { - edges2.push({ - source_name: name2, - target_name: other, - direction: "out", - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: ct, - target: cs - }); - } - } - setState(name2, name2 ? [name2] : [], edges2); - lastActionKey = actionKey; - lastActionSeq = seq; - log3(store, "label+axis_slice", t, name2, sl.slice_kind, "edges", edges2.length); - return; - } - } - const bucket = idx[name2] || { out: [], in: [] }; - const edges = [ - ...(bucket.out || []).map((e) => ({ - source_name: name2, - target_name: e.name, - direction: "out", - opacity: e.opacity, - weight: e.w, - geom_share: e.geom_share, - trips: e.trips, - source: e.source, - target: e.target - })), - ...(bucket.in || []).map((e) => ({ - source_name: e.name, - target_name: name2, - direction: "in", - opacity: e.opacity, - weight: e.w, - geom_share: e.geom_share, - trips: e.trips, - source: e.source, - target: e.target - })) - ]; - setState(name2, name2 ? [name2] : [], edges); - lastActionKey = actionKey; - lastActionSeq = seq; - log3(store, "label", t, name2, "edges", edges.length); - return; - } - if (t === "mat_value") { - const row = stationFrom((v.row || {}).name); - const col = stationFrom((v.col || {}).name); - const actionKey = `mat:${col}->${row}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState("", [], []); - lastActionKey = null; - lastActionSeq = seq; - log3(store, "mat toggle off", col, row); - return; - } - const p = Number(v.value || 0); - const src = acoord(col); - const dst = acoord(row); - const outEdge = (idx[col]?.out || []).find((e) => e.name === row); - const g = outEdge != null ? Number(outEdge.geom_share) : NaN; - const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); - const edge = src && dst ? [{ - source_name: col, - target_name: row, - direction: "direct", - opacity: Math.max(0.2, Math.min(0.98, p * 3)), - weight: p, - geom_share: geom, - trips: outEdge?.trips, - source: src, - target: dst - }] : []; - setState("", [col, row].filter(Boolean), edge); - lastActionKey = actionKey; - lastActionSeq = seq; - log3(store, "mat", col, "->", row, p); - return; - } - if (t === "row_dendro" || t === "col_dendro") { - const hasStation = (n) => Boolean(n && (idx[n] || coordMap[n])); - const fromClick = (v.selected_names || []).map(stationFrom).filter(hasStation); - const rows = (store.selected_rows.get() || []).map(stationFrom).filter(hasStation); - const cols = (store.selected_cols.get() || []).map(stationFrom).filter(hasStation); - if (v.is_unselecting || Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0) { - setState("", [], []); - lastActionKey = null; - lastActionSeq = seq; - log3(store, "dendro clear", t); - return; - } - const names = t === "col_dendro" ? cols.length ? cols : fromClick.length ? fromClick : rows : rows.length ? rows : fromClick.length ? fromClick : cols; - const actionKey = `${t}:${names.slice().sort().join("|")}`; - setState("", names, []); - lastActionKey = actionKey; - lastActionSeq = seq; - log3(store, "dendro", t, "names", names.length, "rows", rows.length, "cols", cols.length); - return; - } - if (t === "cat_value") { - const axis = v.axis; - const attrIndex = v.attr_index; - const catVal = v.value; - const rawNames = Array.isArray(v.node_names) ? v.node_names : []; - const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n] || coordMap[n]))]; - const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState("", [], []); - lastActionKey = null; - lastActionSeq = seq; - log3(store, "cat toggle off", axis, catVal); - return; - } - setState("", names, []); - lastActionKey = actionKey; - lastActionSeq = seq; - log3(store, "cat", axis, "value", catVal, "stations", names.length); - return; - } - const slPair = store.matrix_axis_slice.get() || {}; - if (slPair.slice_kind === "row_col") { - const primaryRaw = slPair.row_axis?.primary_name ?? slPair.col_axis?.primary_name ?? null; - if (!primaryRaw) - return; - const focusName = stationFrom(primaryRaw); - const focusNow = store.focus.get() || ""; - if (focusNow && focusName !== focusNow) { - log3(store, "row_col slice skip (stale vs map focus)", focusName, focusNow); - return; - } - const incoming = slPair.row_axis?.entries || []; - const outgoing = slPair.col_axis?.entries || []; - const edges = []; - for (const e of incoming) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(other); - const ct = acoord(focusName); - if (!other || !cs || !ct) - continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - edges.push({ - source_name: other, - target_name: focusName, - direction: "in", - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct - }); - } - for (const e of outgoing) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(focusName); - const ct = acoord(other); - if (!other || !cs || !ct) - continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - edges.push({ - source_name: focusName, - target_name: other, - direction: "out", - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct - }); - } - setState(focusName, focusName ? [focusName] : [], edges); - lastActionKey = `row_col:${focusName}`; - lastActionSeq = seq; - log3(store, "row_col slice", focusName, "edges", edges.length); - return; - } - }; - const buildLayers = () => { - const stations = store.stations.get() || []; - const focus = store.focus.get(); - const highlightArr = store.highlights.get() || []; - const highlights = new Set(highlightArr); - const edges = store.edges.get() || []; - const stationNameSet = new Set(stations.map((d) => d.name)); - const overlap = highlightArr.filter((n) => stationNameSet.has(n)); - log3(store, "buildLayers", { - focus, - highlightCount: highlightArr.length, - overlap: overlap.length, - sample: overlap.slice(0, 5), - stations: stations.length, - edges: edges.length, - version: renderVersion - }); - const hasSel = Boolean(focus) || highlights.size > 0; - const { out, inn } = getLinkedWeights(); - const highlightKey = Array.from(highlights).sort().join("|"); - const outKey = Array.from(out.entries()).map(([k, v]) => `${k}:${v}`).sort().join("|"); - const inKey = Array.from(inn.entries()).map(([k, v]) => `${k}:${v}`).sort().join("|"); - const styleKey = `${focus}__${highlightKey}__${outKey}__${inKey}__${hasSel}`; - let peakLinkWeight = 0; - for (const v of out.values()) - peakLinkWeight = Math.max(peakLinkWeight, v); - for (const v of inn.values()) - peakLinkWeight = Math.max(peakLinkWeight, v); - let hubSumOut = 0; - let hubSumIn = 0; - for (const v of out.values()) - hubSumOut += Number(v) || 0; - for (const v of inn.values()) - hubSumIn += Number(v) || 0; - const linkedRadius = (n) => { - const wo = out.has(n) ? Math.min(1, Math.max(0, out.get(n) || 0)) : 0; - const wi = inn.has(n) ? Math.min(1, Math.max(0, inn.get(n) || 0)) : 0; - const w = Math.max(wo, wi); - return 100 + 125 * Math.sqrt(w); - }; - const focusHubRadius = () => 178 + 48 * Math.sqrt(Math.min(1, peakLinkWeight)); - const palRgb = resolvePaletteRgb(store); - const pointData = stations.map((d) => d); - const points = new scatterplot_layer_default({ - id: "bike-stations", - data: pointData, - pickable: true, - radiusUnits: "meters", - radiusMinPixels: 3, - radiusMaxPixels: 56, - getPosition: (d) => [Number(d.lng), Number(d.lat)], - getRadius: (d) => { - const n = d.name; - if (focus && n === focus) - return focusHubRadius(); - if (focus && (out.has(n) || inn.has(n))) - return linkedRadius(n); - if (highlights.has(n)) - return 90; - return hasSel ? 70 : 90; - }, - getFillColor: (d) => { - const n = d.name; - if (focus) { - if (n === focus) { - return flowBlendWithAlpha(hubSumOut, hubSumIn, 248); - } - if (out.has(n) || inn.has(n)) { - const wo = out.has(n) ? Math.max(0, out.get(n) || 0) : 0; - const wi = inn.has(n) ? Math.max(0, inn.get(n) || 0) : 0; - const w = Math.max(wo, wi); - const a = Math.round(148 + 102 * Math.sqrt(Math.min(1, w))); - return flowBlendWithAlpha(wo, wi, a); - } - return TRAFFIC_UNCONNECTED_RGBA; - } - if (highlights.size > 0) { - const c = clusterFillColor(d.cluster_id, palRgb); - if (highlights.has(n)) - return [c[0], c[1], c[2], 242]; - return [c[0], c[1], c[2], 36]; - } - return clusterFillColor(d.cluster_id, palRgb); - }, - updateTriggers: { - getRadius: [styleKey, renderVersion], - getFillColor: [styleKey, renderVersion] - }, - onClick: (info) => { - if (!info.object) - return; - const n = String(info.object.name || "").trim(); - if (store.focus.get() === n) { - setDerivedState(store, { focus: "", highlights: [], edges: [] }); - lastActionKey = null; - model.set("click_info", {}); - model.set("matrix_axis_slice", {}); - model.save_changes(); - scheduleRender(); - log3(store, "map toggle off", n); - return; - } - const rowNames = model.get("cg_row_names") || []; - const colNames = model.get("cg_col_names") || []; - const rowIx = findAxisIndex(rowNames, n); - const colIx = findAxisIndex(colNames, n); - if (rowIx < 0 || colIx < 0) { - log3(store, "map click: missing matrix axis index", n, "row", rowIx, "col", colIx); - return; - } - model.set("click_info", {}); - model.set("matrix_axis_slice", {}); - model.save_changes(); - pushRowColMatrixSliceRequest(model, rowIx, colIx); - setDerivedState(store, { focus: n, highlights: [n], edges: [] }); - lastActionKey = null; - scheduleRender(); - log3(store, "map click -> row_col request", n, rowIx, colIx); - } - }); - const lineWidthFor = (d) => { - if (d.direction === "direct") { - const g2 = Number(d.geom_share); - const x = Number.isFinite(g2) ? Math.min(1, Math.max(0, g2)) : 0; - return 4 + 14 * x; - } - const g = Number(d.geom_share); - if (Number.isFinite(g) && g > 0) { - const x = Math.min(1, g); - return 4 + 22 * x ** 0.92; - } - return 2.5; - }; - const lines = new line_layer_default({ - id: "bike-flow-lines", - data: edges, - widthUnits: "pixels", - getSourcePosition: (d) => d.source, - getTargetPosition: (d) => d.target, - getWidth: lineWidthFor, - updateTriggers: { - getWidth: [styleKey, renderVersion] - }, - getColor: (d) => { - const a = Math.round(Math.max(0, Math.min(1, Number(d.opacity) || 0)) * 255); - if (d.direction === "in") - return [70, 150, 255, a]; - if (d.direction === "out") - return [255, 70, 70, a]; - return [255, 240, 120, a]; - } - }); - return [basemapLayer(), lines, points]; - }; - let pendingProps = null; - const prepareDeckProps = () => { - const stations = store.stations.get() || []; - const w = Number(store.width.get() || 560); - const h = Number(store.height.get() || 800); - root.style.width = `${w}px`; - root.style.height = `${h}px`; - const props = { - parent: root, - width: w, - height: h, - controller: true, - layers: buildLayers(), - getTooltip: ({ object, layer }) => { - if (!object || layer.id !== "bike-stations") - return null; - const sid = object.station_id != null ? String(object.station_id) : ""; - const nm = object.name != null ? String(object.name) : ""; - const html = sid ? `
id ${sid}
name ${nm}
` : `
${nm}
`; - return { - html, - style: { - backgroundColor: "rgba(255,255,255,0.94)", - color: "#1a1d24", - padding: "6px 10px", - borderRadius: "4px", - boxShadow: "0 1px 4px rgba(0,0,0,0.18)" - } - }; - } - }; - if (!deck) { - deck = new deck_default({ ...props, initialViewState: fitViewState(stations) }); - log3(store, "deck init", "stations", stations.length); - pendingProps = null; - return; - } - pendingProps = props; - }; - const applyDeckProps = () => { - if (deck && pendingProps) { - deck.setProps(pendingProps); - if (typeof deck.redraw === "function") - deck.redraw(true); - log3(store, "deck setProps", { - layers: pendingProps.layers.length, - highlights: (store.highlights.get() || []).length, - edges: (store.edges.get() || []).length, - version: renderVersion - }); - pendingProps = null; - } - }; - store.deck_check.subscribe( - (check) => { - const ready = Object.values(check).every((v) => v === true); - if (store.deck_ready.get() !== ready) - store.deck_ready.set(ready); - }, - { immediate: true } - ); - store.deck_ready.subscribe( - (ready) => { - if (!ready) - return; - log3(store, "deck_ready -> apply"); - applyDeckProps(); - }, - { immediate: false } - ); - const scheduleRender = () => { - if (raf) - return; - raf = requestAnimationFrame(() => { - raf = 0; - renderVersion += 1; - log3(store, "flush start", { version: renderVersion }); - store.deck_check.set({ inputs: false, computed: false, layers: false }); - store.deck_check.set({ ...store.deck_check.get(), inputs: true }); - computeStateFromInputs(); - store.deck_check.set({ ...store.deck_check.get(), computed: true }); - prepareDeckProps(); - store.deck_check.set({ ...store.deck_check.get(), layers: true }); - log3(store, "flush end", store.deck_check.get()); - }); - }; - [ - store.stations, - store.edge_index, - store.click_info, - store.selected_rows, - store.selected_cols, - store.width, - store.height, - store.palette_rgb, - store.matrix_axis_slice - ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); - const syncFromModel = () => { - const ci = JSON.stringify(model.get("click_info") || {}); - const rows = JSON.stringify(model.get("selected_rows") || []); - const cols = JSON.stringify(model.get("selected_cols") || []); - const sl = JSON.stringify(model.get("matrix_axis_slice") || {}); - if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols || sl !== linkSnap.sl) { - linkSnap = { ci, rows, cols, sl }; - } - log3(store, "syncFromModel start"); - store.stations.set(model.get("stations") || []); - store.palette_rgb.set(model.get("palette_rgb") || []); - store.edge_index.set(model.get("edge_index") || {}); - store.click_info.set(model.get("click_info") || {}); - store.selected_rows.set(model.get("selected_rows") || []); - store.selected_cols.set(model.get("selected_cols") || []); - store.matrix_axis_slice.set(model.get("matrix_axis_slice") || {}); - store.width.set(model.get("width") || 560); - store.height.set(model.get("height") || 800); - store.debug.set(Boolean(model.get("debug"))); - log3(store, "syncFromModel done", { - linkSeq: linkInteractionSeq, - rows: (store.selected_rows.get() || []).length, - cols: (store.selected_cols.get() || []).length, - clickType: (store.click_info.get() || {}).type || null - }); - scheduleRender(); - }; - model.on("change:click_info", () => { - linkInteractionSeq += 1; - syncFromModel(); - }); - [ - "stations", - "edge_index", - "selected_rows", - "selected_cols", - "width", - "height", - "debug", - "palette_rgb", - "matrix_axis_slice" - ].forEach((name2) => model.on(`change:${name2}`, syncFromModel)); - model.on("change:cg_row_names", () => scheduleRender()); - model.on("change:cg_col_names", () => scheduleRender()); - syncFromModel(); - return () => { - if (raf) - cancelAnimationFrame(raf); - if (deck) - deck.finalize(); - }; -} -var bike_flow_map_widget_default = { render }; -export { - bike_flow_map_widget_default as default -}; diff --git a/notebooks/bike_flow_map_widget.mjs b/notebooks/bike_flow_map_widget.mjs deleted file mode 100644 index d9c284cb5..000000000 --- a/notebooks/bike_flow_map_widget.mjs +++ /dev/null @@ -1,871 +0,0 @@ -import { BitmapLayer, Deck, LineLayer, ScatterplotLayer, TileLayer } from 'deck.gl'; - -const Observable = (initialValue) => { - let value = initialValue; - const subscribers = new Set(); - return { - get: () => value, - set: (newValue) => { - if (value === newValue) return; - value = newValue; - subscribers.forEach((fn) => fn(value)); - }, - subscribe: (fn, options = { immediate: true }) => { - subscribers.add(fn); - if (options.immediate) fn(value); - return () => subscribers.delete(fn); - }, - }; -}; - -const createStore = () => ({ - stations: Observable([]), - edge_index: Observable({}), - click_info: Observable({}), - selected_rows: Observable([]), - selected_cols: Observable([]), - width: Observable(560), - height: Observable(800), - debug: Observable(false), - focus: Observable(''), - highlights: Observable([]), - edges: Observable([]), - deck_check: Observable({ inputs: true, computed: true, layers: true }), - deck_ready: Observable(false), - palette_rgb: Observable([]), - matrix_axis_slice: Observable({}), -}); - -const log = (store, ...args) => { - if (store.debug.get()) console.log('[bike-map]', ...args); -}; - -/** Map station click: keep top-K neighbors per direction (row + col slices) for readability. */ -const MAP_STATION_SLICE_TOP_K = 25; - -/** - * Ask the Clustergram for a normal row-axis + col-axis slice (same station on both axes). - */ -function pushRowColMatrixSliceRequest(model, rowIndex, colIndex) { - if (!model?.set) return; - const req_id = - typeof crypto !== 'undefined' && crypto.randomUUID - ? crypto.randomUUID() - : `r${Date.now()}-${Math.random().toString(16).slice(2)}`; - model.set('matrix_slice_request_out', {}); - model.set('matrix_slice_request_out', { - req_id, - op: 'row_col', - row_index: Number(rowIndex), - col_index: Number(colIndex), - max_entries: MAP_STATION_SLICE_TOP_K, - }); - model.save_changes(); -} - -function findAxisIndex(names, raw) { - const want = String(raw || '').trim(); - if (!want || !Array.isArray(names)) return -1; - let i = names.findIndex((x) => String(x).trim() === want); - if (i >= 0) return i; - if (want.includes('|')) { - const rhs = want.split('|', 2)[1].trim(); - i = names.findIndex((x) => String(x).trim() === rhs); - if (i >= 0) return i; - } - return -1; -} - -const sameList = (a, b) => { - if (!Array.isArray(a) || !Array.isArray(b)) return false; - if (a.length !== b.length) return false; - for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false; - return true; -}; - -const setDerivedState = (store, { focus, highlights, edges }) => { - const curFocus = store.focus.get() || ''; - const curHighlights = store.highlights.get() || []; - const curEdges = store.edges.get() || []; - - const nextFocus = focus || ''; - const nextHighlights = highlights || []; - const nextEdges = edges || []; - - let changed = false; - if (curFocus !== nextFocus) { - store.focus.set(nextFocus); - changed = true; - } - if (!sameList(curHighlights, nextHighlights)) { - store.highlights.set(nextHighlights); - changed = true; - } - const curStr = JSON.stringify(curEdges); - const nextStr = JSON.stringify(nextEdges); - if (curStr !== nextStr) { - store.edges.set(nextEdges); - changed = true; - } - return changed; -}; - -function basemapLayer() { - return new TileLayer({ - id: 'bike-basemap', - data: 'https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png', - minZoom: 0, - maxZoom: 19, - tileSize: 256, - renderSubLayers: (props) => { - if (!props.data || !props.tile) return null; - let west; - let south; - let east; - let north; - const bb = props.tile.boundingBox; - if (bb && bb.length === 2) { - [[west, south], [east, north]] = bb; - } else if (props.tile.bbox && 'west' in props.tile.bbox) { - ({ west, south, east, north } = props.tile.bbox); - } else { - return null; - } - return new BitmapLayer(props, { - id: `${props.id}-bitmap`, - data: [0], - image: props.data, - bounds: [west, south, east, north], - }); - }, - }); -} - -/** Okabe-Ito (colorblind-safe) first, then Celldega `clust.constants._COLOR_PALETTE` - keep in sync with notebook `STATION_PALETTE_HEX`. */ -const STATION_PALETTE_HEX = [ - '#E69F00', '#56B4E9', '#009E73', '#F0E442', '#0072B2', '#D55E00', '#CC79A7', - '#393b79', '#aec7e8', '#ff7f0e', '#ffbb78', '#98df8a', '#bcbd22', '#404040', - '#ff9896', '#c5b0d5', '#8c5648', '#1f77b4', '#5254a3', '#FFDB58', '#c49c94', - '#e377c2', '#7f7f7f', '#2ca02c', '#9467bd', '#dbdb8d', '#17becf', '#637939', - '#6b6ecf', '#9c9ede', '#d62728', '#8ca252', '#8c6d31', '#bd9e39', '#e7cb94', - '#843c39', '#ad494a', '#d6616b', '#7b4173', '#a55194', '#ce6dbd', '#de9ed6', -]; - -function hexToRgb(hex) { - const h = String(hex).replace('#', ''); - if (h.length !== 6) return [145, 150, 170]; - return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)]; -} - -const DEFAULT_PALETTE_RGB = STATION_PALETTE_HEX.map(hexToRgb); - -function resolvePaletteRgb(store) { - const raw = store.palette_rgb.get(); - if (Array.isArray(raw) && raw.length > 0) { - return raw.map((row) => { - if (Array.isArray(row) && row.length >= 3) { - return [Number(row[0]), Number(row[1]), Number(row[2])]; - } - return [145, 150, 170]; - }); - } - return DEFAULT_PALETTE_RGB; -} - -/** cluster_id 0 = unclustered / unknown (matches Clustergram label "0"). */ -const CLUSTER_UNKNOWN_RGB = [176, 180, 190]; - -/** Traffic view: stations with no edge to the focused hub. */ -const TRAFFIC_UNCONNECTED_RGBA = [168, 172, 180, 118]; - -function clusterRgbFromId(clusterId, paletteRgb) { - const id = Number(clusterId); - if (!Number.isFinite(id) || id <= 0) return CLUSTER_UNKNOWN_RGB; - const pal = paletteRgb.length ? paletteRgb : DEFAULT_PALETTE_RGB; - const c = pal[(id - 1) % pal.length]; - return [c[0], c[1], c[2]]; -} - -function clusterFillWithAlpha(clusterId, alpha, paletteRgb) { - const [r, g, b] = clusterRgbFromId(clusterId, paletteRgb); - return [r, g, b, alpha]; -} - -function clusterFillColor(clusterId, paletteRgb) { - return clusterFillWithAlpha(clusterId, 228, paletteRgb); -} - -/** Same endpoints as LineLayer getColor: out red, in blue. */ -const FLOW_OUT_RGB = [255, 70, 70]; -const FLOW_IN_RGB = [70, 150, 255]; - -function flowBlendRgb(outW, inW) { - const o = Math.max(0, Number(outW) || 0); - const i = Math.max(0, Number(inW) || 0); - const sum = o + i; - if (sum <= 0) return [145, 150, 170]; - const t = o / sum; - const lerp = (a, b, x) => Math.round(a + (b - a) * x); - return [ - lerp(FLOW_IN_RGB[0], FLOW_OUT_RGB[0], t), - lerp(FLOW_IN_RGB[1], FLOW_OUT_RGB[1], t), - lerp(FLOW_IN_RGB[2], FLOW_OUT_RGB[2], t), - ]; -} - -function flowBlendWithAlpha(outW, inW, alpha) { - const [r, g, b] = flowBlendRgb(outW, inW); - return [r, g, b, alpha]; -} - -function fitViewState(stations) { - if (!stations.length) return { longitude: -73.98, latitude: 40.75, zoom: 10.5, pitch: 0, bearing: 0 }; - let minLat = Infinity; let maxLat = -Infinity; let minLng = Infinity; let maxLng = -Infinity; - for (const s of stations) { - const lat = Number(s.lat); const lng = Number(s.lng); - if (!Number.isFinite(lat) || !Number.isFinite(lng)) continue; - minLat = Math.min(minLat, lat); maxLat = Math.max(maxLat, lat); - minLng = Math.min(minLng, lng); maxLng = Math.max(maxLng, lng); - } - const latitude = (minLat + maxLat) / 2; - const longitude = (minLng + maxLng) / 2; - const span = Math.max(maxLat - minLat, maxLng - minLng, 0.02); - const zoom = Math.min(14, Math.max(9, 12 - Math.log2(span * 80))); - return { latitude, longitude, zoom, pitch: 0, bearing: 0 }; -} - -function render({ model, el }) { - const store = createStore(); - const root = document.createElement('div'); - root.style.background = '#e2e4e8'; - root.style.borderRadius = '4px'; - root.style.overflow = 'hidden'; - el.appendChild(root); - - let deck = null; - let raf = 0; - let renderVersion = 0; - let lastActionKey = null; - let lastActionSeq = -1; - /** - * Increments on each `click_info` comm update from the Clustergram (including the null-then-set pair). - * Used for label/mat/cat toggle detection. Intentionally not tied to `matrix_slice_result` alone so - * slice-only updates do not spuriously toggle the map off. - */ - let linkInteractionSeq = 0; - let linkSnap = { ci: '', rows: '', cols: '', sl: '' }; - - const getLinkedWeights = () => { - const focus = store.focus.get(); - const out = new Map(); - const inn = new Map(); - if (!focus) return { out, inn }; - for (const e of store.edges.get() || []) { - if (e.direction === 'out' && e.source_name === focus) { - out.set(e.target_name, Number(e.weight) || 0); - } else if (e.direction === 'in' && e.target_name === focus) { - inn.set(e.source_name, Number(e.weight) || 0); - } - } - return { out, inn }; - }; - - const computeStateFromInputs = () => { - const info = store.click_info.get() || {}; - const t = String(info.type || '').replace('-', '_'); - const v = info.value || {}; - const idx = store.edge_index.get() || {}; - const seq = linkInteractionSeq; - log(store, 'compute start', t, 'rows', (store.selected_rows.get()||[]).length, 'cols', (store.selected_cols.get()||[]).length); - - const setState = (focus, highlights, edges) => - setDerivedState(store, { focus, highlights, edges }); - - const stationFrom = (raw) => { - const txt = String(raw || '').trim(); - if (idx[txt]) return txt; - if (txt.includes('|')) { - const rhs = txt.split('|', 2)[1].trim(); - if (idx[rhs]) return rhs; - } - return txt; - }; - - const coordMap = {}; - for (const s of store.stations.get() || []) { - const k = stationFrom(String(s.name || '')); - if (k && s.lng != null && s.lat != null) { - coordMap[k] = [Number(s.lng), Number(s.lat)]; - } - } - const acoord = (n) => (n && idx[n]?.coord) || (n ? coordMap[n] : undefined); - - if (t === 'row_label' || t === 'col_label') { - const name = stationFrom(v.name); - const actionKey = `${t}:${name}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState('', [], []); - lastActionKey = null; - lastActionSeq = seq; - log(store, 'label toggle off', t, name); - return; - } - const sl = store.matrix_axis_slice.get() || {}; - const entries = sl.entries; - const rowAxis = t === 'row_label' && sl.slice_kind === 'row_axis'; - const colAxis = t === 'col_label' && sl.slice_kind === 'col_axis'; - if (Array.isArray(entries) && (rowAxis || colAxis)) { - const primary = stationFrom(sl.primary_name); - if (primary === name && entries.length) { - const edges = []; - for (const e of entries) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(other); - const ct = acoord(name); - if (!other || !cs || !ct) continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - if (rowAxis) { - edges.push({ - source_name: other, - target_name: name, - direction: 'in', - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct, - }); - } else { - edges.push({ - source_name: name, - target_name: other, - direction: 'out', - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: ct, - target: cs, - }); - } - } - setState(name, name ? [name] : [], edges); - lastActionKey = actionKey; - lastActionSeq = seq; - log(store, 'label+axis_slice', t, name, sl.slice_kind, 'edges', edges.length); - return; - } - } - const bucket = idx[name] || { out: [], in: [] }; - const edges = [ - ...(bucket.out || []).map((e) => ({ - source_name: name, - target_name: e.name, - direction: 'out', - opacity: e.opacity, - weight: e.w, - geom_share: e.geom_share, - trips: e.trips, - source: e.source, - target: e.target, - })), - ...(bucket.in || []).map((e) => ({ - source_name: e.name, - target_name: name, - direction: 'in', - opacity: e.opacity, - weight: e.w, - geom_share: e.geom_share, - trips: e.trips, - source: e.source, - target: e.target, - })), - ]; - setState(name, name ? [name] : [], edges); - lastActionKey = actionKey; - lastActionSeq = seq; - log(store, 'label', t, name, 'edges', edges.length); - return; - } - - if (t === 'mat_value') { - const row = stationFrom((v.row || {}).name); - const col = stationFrom((v.col || {}).name); - const actionKey = `mat:${col}->${row}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState('', [], []); - lastActionKey = null; - lastActionSeq = seq; - log(store, 'mat toggle off', col, row); - return; - } - const p = Number(v.value || 0); - const src = acoord(col); - const dst = acoord(row); - const outEdge = (idx[col]?.out || []).find((e) => e.name === row); - const g = outEdge != null ? Number(outEdge.geom_share) : NaN; - const geom = Number.isFinite(g) && g > 0 ? g : Math.sqrt(Math.max(0, p)); - const edge = src && dst - ? [{ - source_name: col, - target_name: row, - direction: 'direct', - opacity: Math.max(0.2, Math.min(0.98, p * 3)), - weight: p, - geom_share: geom, - trips: outEdge?.trips, - source: src, - target: dst, - }] - : []; - setState('', [col, row].filter(Boolean), edge); - lastActionKey = actionKey; - lastActionSeq = seq; - log(store, 'mat', col, '->', row, p); - return; - } - - if (t === 'row_dendro' || t === 'col_dendro') { - const hasStation = (n) => Boolean(n && (idx[n] || coordMap[n])); - const fromClick = (v.selected_names || []).map(stationFrom).filter(hasStation); - const rows = (store.selected_rows.get() || []).map(stationFrom).filter(hasStation); - const cols = (store.selected_cols.get() || []).map(stationFrom).filter(hasStation); - - if (v.is_unselecting || (Array.isArray(v.selected_names) && v.selected_names.length === 0 && rows.length === 0 && cols.length === 0)) { - setState('', [], []); - lastActionKey = null; - lastActionSeq = seq; - log(store, 'dendro clear', t); - return; - } - - // Prefer axis traitlets (they represent full live dendrogram selection); - // click_info.selected_names can be a smaller interim payload. - const names = t === 'col_dendro' - ? (cols.length ? cols : (fromClick.length ? fromClick : rows)) - : (rows.length ? rows : (fromClick.length ? fromClick : cols)); - - // No actionKey "toggle off" vs linkInteractionSeq here: dendrogram updates can - // re-send the same selection across frames; toggling off would flicker. - const actionKey = `${t}:${names.slice().sort().join('|')}`; - setState('', names, []); - lastActionKey = actionKey; - lastActionSeq = seq; - log(store, 'dendro', t, 'names', names.length, 'rows', rows.length, 'cols', cols.length); - return; - } - - if (t === 'cat_value') { - const axis = v.axis; - const attrIndex = v.attr_index; - const catVal = v.value; - const rawNames = Array.isArray(v.node_names) ? v.node_names : []; - const names = [...new Set(rawNames.map(stationFrom).filter((n) => idx[n] || coordMap[n]))]; - const actionKey = `cat:${axis}:${attrIndex}:${String(catVal)}`; - if (actionKey === lastActionKey && seq !== lastActionSeq) { - setState('', [], []); - lastActionKey = null; - lastActionSeq = seq; - log(store, 'cat toggle off', axis, catVal); - return; - } - setState('', names, []); - lastActionKey = actionKey; - lastActionSeq = seq; - log(store, 'cat', axis, 'value', catVal, 'stations', names.length); - return; - } - - const slPair = store.matrix_axis_slice.get() || {}; - if (slPair.slice_kind === 'row_col') { - const primaryRaw = - slPair.row_axis?.primary_name ?? slPair.col_axis?.primary_name ?? null; - if (!primaryRaw) return; - const focusName = stationFrom(primaryRaw); - const focusNow = store.focus.get() || ''; - if (focusNow && focusName !== focusNow) { - log(store, 'row_col slice skip (stale vs map focus)', focusName, focusNow); - return; - } - const incoming = slPair.row_axis?.entries || []; - const outgoing = slPair.col_axis?.entries || []; - const edges = []; - for (const e of incoming) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(other); - const ct = acoord(focusName); - if (!other || !cs || !ct) continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - edges.push({ - source_name: other, - target_name: focusName, - direction: 'in', - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct, - }); - } - for (const e of outgoing) { - const other = stationFrom(e.counterpart_name); - const cs = acoord(focusName); - const ct = acoord(other); - if (!other || !cs || !ct) continue; - const w = Number(e.value) || 0; - const geom = Math.sqrt(Math.max(0, w)); - edges.push({ - source_name: focusName, - target_name: other, - direction: 'out', - opacity: Math.max(0.15, Math.min(0.98, w * 3)), - weight: w, - geom_share: geom, - source: cs, - target: ct, - }); - } - setState(focusName, focusName ? [focusName] : [], edges); - lastActionKey = `row_col:${focusName}`; - lastActionSeq = seq; - log(store, 'row_col slice', focusName, 'edges', edges.length); - return; - } - }; - - const buildLayers = () => { - const stations = store.stations.get() || []; - const focus = store.focus.get(); - const highlightArr = store.highlights.get() || []; - const highlights = new Set(highlightArr); - const edges = store.edges.get() || []; - const stationNameSet = new Set(stations.map((d) => d.name)); - const overlap = highlightArr.filter((n) => stationNameSet.has(n)); - log(store, 'buildLayers', { - focus, - highlightCount: highlightArr.length, - overlap: overlap.length, - sample: overlap.slice(0, 5), - stations: stations.length, - edges: edges.length, - version: renderVersion, - }); - const hasSel = Boolean(focus) || highlights.size > 0; - const { out, inn } = getLinkedWeights(); - const highlightKey = Array.from(highlights).sort().join('|'); - const outKey = Array.from(out.entries()) - .map(([k, v]) => `${k}:${v}`) - .sort() - .join('|'); - const inKey = Array.from(inn.entries()) - .map(([k, v]) => `${k}:${v}`) - .sort() - .join('|'); - const styleKey = `${focus}__${highlightKey}__${outKey}__${inKey}__${hasSel}`; - - let peakLinkWeight = 0; - for (const v of out.values()) peakLinkWeight = Math.max(peakLinkWeight, v); - for (const v of inn.values()) peakLinkWeight = Math.max(peakLinkWeight, v); - - let hubSumOut = 0; - let hubSumIn = 0; - for (const v of out.values()) hubSumOut += Number(v) || 0; - for (const v of inn.values()) hubSumIn += Number(v) || 0; - - const linkedRadius = (n) => { - const wo = out.has(n) ? Math.min(1, Math.max(0, out.get(n) || 0)) : 0; - const wi = inn.has(n) ? Math.min(1, Math.max(0, inn.get(n) || 0)) : 0; - const w = Math.max(wo, wi); - return 100 + 125 * Math.sqrt(w); - }; - - const focusHubRadius = () => - 178 + 48 * Math.sqrt(Math.min(1, peakLinkWeight)); - - const palRgb = resolvePaletteRgb(store); - - // Force a new data container each render so style-only updates always propagate - const pointData = stations.map((d) => d); - - const points = new ScatterplotLayer({ - id: 'bike-stations', - data: pointData, - pickable: true, - radiusUnits: 'meters', - radiusMinPixels: 3, - radiusMaxPixels: 56, - getPosition: (d) => [Number(d.lng), Number(d.lat)], - getRadius: (d) => { - const n = d.name; - if (focus && n === focus) return focusHubRadius(); - if (focus && (out.has(n) || inn.has(n))) return linkedRadius(n); - if (highlights.has(n)) return 90; - return hasSel ? 70 : 90; - }, - getFillColor: (d) => { - const n = d.name; - // Focus / traffic: hub + neighbors use red↔blue blend from out vs in weight (lines still encode direction/width). - if (focus) { - if (n === focus) { - return flowBlendWithAlpha(hubSumOut, hubSumIn, 248); - } - if (out.has(n) || inn.has(n)) { - const wo = out.has(n) ? Math.max(0, out.get(n) || 0) : 0; - const wi = inn.has(n) ? Math.max(0, inn.get(n) || 0) : 0; - const w = Math.max(wo, wi); - const a = Math.round(148 + 102 * Math.sqrt(Math.min(1, w))); - return flowBlendWithAlpha(wo, wi, a); - } - return TRAFFIC_UNCONNECTED_RGBA; - } - // Dendrogram / matrix highlights (no focus): cluster colors from palette_rgb - if (highlights.size > 0) { - const c = clusterFillColor(d.cluster_id, palRgb); - if (highlights.has(n)) return [c[0], c[1], c[2], 242]; - return [c[0], c[1], c[2], 36]; - } - return clusterFillColor(d.cluster_id, palRgb); - }, - updateTriggers: { - getRadius: [styleKey, renderVersion], - getFillColor: [styleKey, renderVersion], - }, - onClick: (info) => { - if (!info.object) return; - const n = String(info.object.name || '').trim(); - if (store.focus.get() === n) { - setDerivedState(store, { focus: '', highlights: [], edges: [] }); - lastActionKey = null; - model.set('click_info', {}); - model.set('matrix_axis_slice', {}); - model.save_changes(); - scheduleRender(); - log(store, 'map toggle off', n); - return; - } - const rowNames = model.get('cg_row_names') || []; - const colNames = model.get('cg_col_names') || []; - const rowIx = findAxisIndex(rowNames, n); - const colIx = findAxisIndex(colNames, n); - if (rowIx < 0 || colIx < 0) { - log(store, 'map click: missing matrix axis index', n, 'row', rowIx, 'col', colIx); - return; - } - model.set('click_info', {}); - model.set('matrix_axis_slice', {}); - model.save_changes(); - pushRowColMatrixSliceRequest(model, rowIx, colIx); - setDerivedState(store, { focus: n, highlights: [n], edges: [] }); - lastActionKey = null; - scheduleRender(); - log(store, 'map click -> row_col request', n, rowIx, colIx); - }, - }); - - // geom_share in [0,1]; scale like matrix emphasis (stronger than before, pixel units). - const lineWidthFor = (d) => { - if (d.direction === 'direct') { - const g = Number(d.geom_share); - const x = Number.isFinite(g) ? Math.min(1, Math.max(0, g)) : 0; - return 4 + 14 * x; - } - const g = Number(d.geom_share); - if (Number.isFinite(g) && g > 0) { - const x = Math.min(1, g); - return 4 + 22 * x ** 0.92; - } - return 2.5; - }; - - const lines = new LineLayer({ - id: 'bike-flow-lines', - data: edges, - widthUnits: 'pixels', - getSourcePosition: (d) => d.source, - getTargetPosition: (d) => d.target, - getWidth: lineWidthFor, - updateTriggers: { - getWidth: [styleKey, renderVersion], - }, - getColor: (d) => { - const a = Math.round(Math.max(0, Math.min(1, Number(d.opacity) || 0)) * 255); - if (d.direction === 'in') return [70, 150, 255, a]; - if (d.direction === 'out') return [255, 70, 70, a]; - return [255, 240, 120, a]; - }, - }); - - return [basemapLayer(), lines, points]; - }; - - let pendingProps = null; - - const prepareDeckProps = () => { - const stations = store.stations.get() || []; - const w = Number(store.width.get() || 560); - const h = Number(store.height.get() || 800); - root.style.width = `${w}px`; - root.style.height = `${h}px`; - - - const props = { - parent: root, - width: w, - height: h, - controller: true, - layers: buildLayers(), - getTooltip: ({ object, layer }) => { - if (!object || layer.id !== 'bike-stations') return null; - const sid = object.station_id != null ? String(object.station_id) : ''; - const nm = object.name != null ? String(object.name) : ''; - const html = sid - ? `
id ${sid}
name ${nm}
` - : `
${nm}
`; - return { - html, - style: { - backgroundColor: 'rgba(255,255,255,0.94)', - color: '#1a1d24', - padding: '6px 10px', - borderRadius: '4px', - boxShadow: '0 1px 4px rgba(0,0,0,0.18)', - }, - }; - }, - }; - - if (!deck) { - deck = new Deck({ ...props, initialViewState: fitViewState(stations) }); - log(store, 'deck init', 'stations', stations.length); - pendingProps = null; - return; - } - - pendingProps = props; - }; - - const applyDeckProps = () => { - if (deck && pendingProps) { - deck.setProps(pendingProps); - if (typeof deck.redraw === 'function') deck.redraw(true); - log(store, 'deck setProps', { - layers: pendingProps.layers.length, - highlights: (store.highlights.get() || []).length, - edges: (store.edges.get() || []).length, - version: renderVersion, - }); - pendingProps = null; - } - }; - - store.deck_check.subscribe( - (check) => { - const ready = Object.values(check).every((v) => v === true); - if (store.deck_ready.get() !== ready) store.deck_ready.set(ready); - }, - { immediate: true } - ); - - store.deck_ready.subscribe( - (ready) => { - if (!ready) return; - log(store, 'deck_ready -> apply'); - applyDeckProps(); - }, - { immediate: false } - ); - - const scheduleRender = () => { - if (raf) return; - raf = requestAnimationFrame(() => { - raf = 0; - renderVersion += 1; - log(store, 'flush start', { version: renderVersion }); - store.deck_check.set({ inputs: false, computed: false, layers: false }); - - // 1) inputs considered synced for this frame - store.deck_check.set({ ...store.deck_check.get(), inputs: true }); - - // 2) derive interaction state - computeStateFromInputs(); - store.deck_check.set({ ...store.deck_check.get(), computed: true }); - - // 3) prepare deck props (or init deck) - prepareDeckProps(); - store.deck_check.set({ ...store.deck_check.get(), layers: true }); - - log(store, 'flush end', store.deck_check.get()); - }); - }; - - // subscriptions: any change schedules one render pass - [ - store.stations, - store.edge_index, - store.click_info, - store.selected_rows, - store.selected_cols, - store.width, - store.height, - store.palette_rgb, - store.matrix_axis_slice, - ].forEach((obs) => obs.subscribe(() => scheduleRender(), { immediate: false })); - - const syncFromModel = () => { - const ci = JSON.stringify(model.get('click_info') || {}); - const rows = JSON.stringify(model.get('selected_rows') || []); - const cols = JSON.stringify(model.get('selected_cols') || []); - const sl = JSON.stringify(model.get('matrix_axis_slice') || {}); - if (ci !== linkSnap.ci || rows !== linkSnap.rows || cols !== linkSnap.cols || sl !== linkSnap.sl) { - linkSnap = { ci, rows, cols, sl }; - } - log(store, 'syncFromModel start'); - store.stations.set(model.get('stations') || []); - store.palette_rgb.set(model.get('palette_rgb') || []); - store.edge_index.set(model.get('edge_index') || {}); - store.click_info.set(model.get('click_info') || {}); - store.selected_rows.set(model.get('selected_rows') || []); - store.selected_cols.set(model.get('selected_cols') || []); - store.matrix_axis_slice.set(model.get('matrix_axis_slice') || {}); - store.width.set(model.get('width') || 560); - store.height.set(model.get('height') || 800); - store.debug.set(Boolean(model.get('debug'))); - log(store, 'syncFromModel done', { - linkSeq: linkInteractionSeq, - rows: (store.selected_rows.get() || []).length, - cols: (store.selected_cols.get() || []).length, - clickType: (store.click_info.get() || {}).type || null, - }); - scheduleRender(); - }; - - model.on('change:click_info', () => { - linkInteractionSeq += 1; - syncFromModel(); - }); - - [ - 'stations', - 'edge_index', - 'selected_rows', - 'selected_cols', - 'width', - 'height', - 'debug', - 'palette_rgb', - 'matrix_axis_slice', - ].forEach((name) => model.on(`change:${name}`, syncFromModel)); - - model.on('change:cg_row_names', () => scheduleRender()); - model.on('change:cg_col_names', () => scheduleRender()); - - syncFromModel(); - - return () => { - if (raf) cancelAnimationFrame(raf); - if (deck) deck.finalize(); - }; -} - -export default { render }; From 2ba08d710085a12772fcab87ea66df6e1d58dad7 Mon Sep 17 00:00:00 2001 From: Nicolas Fernandez Date: Sun, 28 Jun 2026 00:00:11 -0400 Subject: [PATCH 7/7] ruff check --- src/celldega/viz/widget.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/celldega/viz/widget.py b/src/celldega/viz/widget.py index 6bef45fcf..bb053a268 100644 --- a/src/celldega/viz/widget.py +++ b/src/celldega/viz/widget.py @@ -7,12 +7,12 @@ import importlib.metadata import json import os -import time -import uuid from pathlib import Path import re -from typing import Any +import time +from typing import Any, Literal import urllib.error +import uuid import warnings import anywidget @@ -23,7 +23,6 @@ import scanpy as sc from shapely.affinity import affine_transform import traitlets -from typing import Literal _clustergram_registry = {} # maps names to widget instances